/// <inheritdoc />
public override void Destroy()
{
base.Destroy();
lock (Renderer.Locker)
{
CanRender = false;
_bloomEffect.Destroy();
_ambientOcclusion.Destroy();
RenderHandle = IntPtr.Zero;
lock (Locker)
{
LayerCollectors.Clear();
}
Constants.Dispose();
RenderTarget2D?.Dispose();
BackBuffer?.Dispose();
Buffer0?.Dispose();
Buffer1?.Dispose();
Buffer2?.Dispose();
Buffer3?.Dispose();
BufferDownscaleHalf0?.Dispose();
BufferDownscaleHalf1?.Dispose();
BufferDownscaleQuarter0?.Dispose();
BufferDownscaleQuarter1?.Dispose();
DepthStencilBuffer?.Dispose();
SwapChain?.Dispose();
BackBuffer = null;
Buffer0 = null;
Buffer1 = null;
Buffer2 = null;
Buffer3 = null;
}
}
private static void TestWithCovariance()
{
IBuffer2 <string> b1 = new Buffer2 <string>();
IBuffer2 <object> b2 = b1;
}
public bool Proccess(ref ServerAsyncEventArgs e, out bool closeConnection)
{
// ----------------------------------------------------------
// | | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 |
// ----------------------------------------------------------
// | e | H | HC | | | | | | | |
// | e1 | | | H | HC | H | H | | | |
// | Buffer1 | | | | | C | | H | HC | H |
// | Buffer2 | | | | | | C | | | C |
// ----------------------------------------------------------
closeConnection = false;
switch (state)
{
case StreamState.WaitingHeaders:
{
int oldBytesProccessed = bytesProccessed;
var data = new ArraySegment <byte>(e.Buffer, e.Offset + bytesProccessed, e.BytesTransferred - bytesProccessed);
PreProcessRaw(data);
var result = Parse(data);
switch (result.ParseCode)
{
case ParseCode.NotEnoughData:
{
bytesProccessed += data.Count;
ResetParser(ResetReason.NotEnoughData);
Buffer1.Resize(MaximumHeadersSize);
Buffer1.CopyTransferredFrom(e, oldBytesProccessed);
state = StreamState.WaitingHeadersContinue;
}
break;
case ParseCode.Error:
{
closeConnection = true;
}
break;
case ParseCode.Skip:
{
bytesProccessed += result.Count;
}
break;
case ParseCode.HeaderDone:
{
bytesProccessed += result.HeaderLength;
SetReaderStorage(Storage.E, e.Buffer, e.Offset + oldBytesProccessed, result.HeaderLength);
expectedContentLength = result.ContentLength;
if (expectedContentLength <= 0)
{
SetReady();
}
else
{
int bytesLeft = e.BytesTransferred - bytesProccessed;
if (bytesLeft >= expectedContentLength)
{
SetReady(Storage.E, e.Buffer, e.Offset + bytesProccessed, expectedContentLength);
bytesProccessed += expectedContentLength;
}
else
{
if (expectedContentLength <= e.Count - e.BytesTransferred)
{
state = StreamState.WaitingMicroBody;
}
else if (expectedContentLength < MaximumHeadersSize)
{
if (Buffer1.IsInvalid || Buffer1.Capacity < expectedContentLength)
{
if (Buffer1.Resize(Math.Max(expectedContentLength, MinimumBuffer1Size)) == false)
{
closeConnection = true;
}
}
if (closeConnection == false)
{
Buffer1.CopyTransferredFrom(e, bytesProccessed);
state = StreamState.WaitingSmallBody;
}
}
else
{
if (Buffer2.Resize(expectedContentLength) == false)
{
closeConnection = true;
}
else
{
Buffer2.CopyTransferredFrom(e, bytesProccessed);
state = StreamState.WaitingBigBody;
}
}
if (closeConnection == false)
{
e1 = e;
e = null;
readerStorage = Storage.E1;
}
bytesProccessed += bytesLeft;
receivedContentLength += bytesLeft;
}
}
}
break;
}
}
break;
case StreamState.WaitingHeadersContinue:
{
int count = Math.Min(e.BytesTransferred - bytesProccessed, Buffer1.FreeSize);
PreProcessRaw(new ArraySegment <byte>(e.Buffer, e.Offset, e.BytesTransferred - bytesProccessed));
System.Buffer.BlockCopy(e.Buffer, e.Offset, Buffer1.Array, Buffer1.Offset + Buffer1.Count, count);
var data = new ArraySegment <byte>(Buffer1.Array, Buffer1.Offset, Buffer1.Count + count);
var result = Parse(data);
switch (result.ParseCode)
{
case ParseCode.NotEnoughData:
{
ResetParser(ResetReason.NotEnoughData);
if (data.Count < Buffer1.Capacity)
{
Buffer1.AddCount(count);
bytesProccessed += count;
}
else
{
closeConnection = true;
}
}
break;
case ParseCode.Error:
{
closeConnection = true;
}
break;
case ParseCode.Skip:
throw new NotImplementedException();
case ParseCode.HeaderDone:
{
int delta = result.HeaderLength - Buffer1.Count;
Buffer1.AddCount(delta);
bytesProccessed += delta;
SetReaderStorage(Storage.Buffer1, Buffer1.Array, Buffer1.Offset, result.HeaderLength);
expectedContentLength = result.ContentLength;
if (expectedContentLength <= 0)
{
SetReady();
}
else
{
int bytesLeft = e.BytesTransferred - bytesProccessed;
if (bytesLeft >= expectedContentLength)
{
SetReady(Storage.E, e.Buffer, e.Offset + bytesProccessed, expectedContentLength);
bytesProccessed += expectedContentLength;
}
else
{
if (expectedContentLength < Buffer1.FreeSize)
{
Buffer1.AddCount(bytesLeft);
state = StreamState.WaitingSmallBody;
}
else
{
if (Buffer2.Resize(expectedContentLength) == false)
{
closeConnection = true;
}
Buffer2.CopyTransferredFrom(e, bytesProccessed);
state = StreamState.WaitingBigBody;
}
bytesProccessed += bytesLeft;
receivedContentLength += bytesLeft;
}
}
}
break;
}
}
break;
case StreamState.WaitingMicroBody:
{
int count = Math.Min(e.BytesTransferred - bytesProccessed,
expectedContentLength - receivedContentLength);
var data = new ArraySegment <byte>(e.Buffer, e.Offset + bytesProccessed, count);
PreProcessRaw(data);
System.Buffer.BlockCopy(data.Array, data.Offset, e1.Buffer, e1.Offset + e1.BytesTransferred, data.Count);
//System.Buffer.BlockCopy(e.Buffer, e.Offset + bytesProccessed,
// e1.Buffer, e1.Offset + e1.BytesTransferred, count);
e1.BytesTransferred += count;
receivedContentLength += count;
bytesProccessed += count;
if (receivedContentLength == expectedContentLength)
{
SetReady(Storage.E1, e1.Buffer, e1.Offset + e1.BytesTransferred - receivedContentLength, receivedContentLength);
}
}
break;
case StreamState.WaitingSmallBody:
{
int count = Math.Min(e.BytesTransferred - bytesProccessed,
expectedContentLength - receivedContentLength);
var data = new ArraySegment <byte>(e.Buffer, e.Offset + bytesProccessed, count);
PreProcessRaw(data);
Buffer1.CopyFrom(data);
//Buffer1.CopyFrom(e.Buffer, e.Offset + bytesProccessed, count);
receivedContentLength += count;
bytesProccessed += count;
if (receivedContentLength == expectedContentLength)
{
SetReady(Storage.Buffer1, Buffer1.Array, Buffer1.Offset + Buffer1.Count - receivedContentLength, receivedContentLength);
}
}
break;
case StreamState.WaitingBigBody:
{
int count = Math.Min(e.BytesTransferred - bytesProccessed,
expectedContentLength - receivedContentLength);
var data = new ArraySegment <byte>(e.Buffer, e.Offset + bytesProccessed, count);
PreProcessRaw(data);
Buffer2.CopyFrom(data);
//Buffer2.CopyFrom(e.Buffer, e.Offset + bytesProccessed, count);
receivedContentLength += count;
bytesProccessed += count;
if (receivedContentLength == expectedContentLength)
{
SetReady(Storage.Buffer2, Buffer2.Array, Buffer2.Offset + Buffer2.Count - receivedContentLength, receivedContentLength);
}
}
break;
}
bool continueProccessing = closeConnection == false &&
e != null && bytesProccessed < e.BytesTransferred;
if (continueProccessing == false)
{
bytesProccessed = 0;
}
return(continueProccessing);
}
/// <summary>
/// Resizes the GBuffer.
/// </summary>
internal void Resize(Device device)
{
UpdateProjectionMatrix();
RebuildFrustum(_frustumCulling);
CanRender = false;
var newWidth = Math.Max(1, (int)_viewportSize.x);
var newHeight = Math.Max(1, (int)_viewportSize.y);
RenderTarget2D?.Dispose();
RenderTarget2D = null;
Renderer.Context2D.Target = null;
_surface?.Dispose();
BackBuffer?.Dispose();
Buffer0?.Dispose();
Buffer1?.Dispose();
Buffer2?.Dispose();
Buffer3?.Dispose();
DepthStencilBuffer?.Dispose();
Viewport = new ViewportF(0, 0, ViewportSize.x, ViewportSize.y);
try
{
SwapChain.ResizeBuffers(RenderConstants.FrameCount, newWidth, newHeight,
RenderConstants.BackBufferFormat, SwapChainFlags.None);
}
catch (SharpDXException e)
{
Logger.Error(e);
throw;
}
var backBufferTexture = Resource.FromSwapChain <Texture2D>(SwapChain, 0);
BackBuffer = new Texture(backBufferTexture);
Buffer0 = CreateCameraBuffer("Buffer0", 1f, RenderConstants.BackBufferFormat);
Buffer1 = CreateCameraBuffer("Buffer1", 1f, Format.R8G8B8A8_UNorm);
Buffer2 = CreateCameraBuffer("Buffer2", 1f, Format.R16G16B16A16_Float);
Buffer3 = CreateCameraBuffer("Buffer3", 1f, Format.R8G8B8A8_UNorm);
BufferDownscaleHalf0 = CreateCameraBuffer("BufferDownsampleHalf0", 1 / 2f, Format.R8G8B8A8_UNorm);
BufferDownscaleHalf1 = CreateCameraBuffer("BufferDownsampleHalf1", 1 / 2f, Format.R8G8B8A8_UNorm);
BufferDownscaleQuarter0 = CreateCameraBuffer("BufferDownsampleQuarter0", 1 / 4f, Format.R8G8B8A8_UNorm);
BufferDownscaleQuarter1 = CreateCameraBuffer("BufferDownsampleQuarter1", 1 / 4f, Format.R8G8B8A8_UNorm);
var depthStencilBuffer = new Texture2D(Renderer.Device, new Texture2DDescription
{
Format = Format.R24G8_Typeless,
ArraySize = 1,
MipLevels = 1,
Width = newWidth,
Height = newHeight,
SampleDescription = new SampleDescription(1, 0),
Usage = ResourceUsage.Default,
BindFlags = BindFlags.DepthStencil | BindFlags.ShaderResource,
CpuAccessFlags = CpuAccessFlags.None,
OptionFlags = ResourceOptionFlags.None
});
DepthStencilBuffer = new Texture(depthStencilBuffer, new DepthStencilViewDescription
{
Format = Format.D24_UNorm_S8_UInt,
Dimension = DepthStencilViewDimension.Texture2D
}, new ShaderResourceViewDescription
{
Format = Format.R24_UNorm_X8_Typeless,
Dimension = ShaderResourceViewDimension.Texture2D,
Texture2D = new ShaderResourceViewDescription.Texture2DResource
{
MostDetailedMip = 0,
MipLevels = -1
}
});
_surface = BackBuffer.QueryInterface <Surface>();
_surface.DebugName = "BackBufferSurface";
try
{
RenderTarget2D = new Bitmap1(Renderer.Context2D, _surface,
new BitmapProperties1(new PixelFormat(_surface.Description.Format, AlphaMode.Premultiplied), 96,
96, BitmapOptions.Target | BitmapOptions.CannotDraw));
}
catch (Exception)
{
_surface.Dispose();
RenderTarget2D?.Dispose();
Logger.Info("An exception occured while creating the GUI surface render target.");
throw;
}
lock (Locker)
{
foreach (var collector in LayerCollectors)
{
collector.Target = RenderTarget2D;
}
}
lock (PostEffectsLocker)
{
foreach (var effect in PostEffects)
{
effect.UpdateSize(this);
}
}
var cb = Constants;
cb.Data.ScreenParams.X = newWidth;
cb.Data.ScreenParams.Y = newHeight;
cb.Data.ScreenParams.Z = AspectRatio;
cb.Data.ScreenParams.W = FieldOfView * 0.5f / newHeight;
NeedsResize = false;
CanRender = true;
//Logger.Trace("Camera resized.");
}
