/// <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."); }