public PlotterGraphPaneEx() { memGraphics = new BackBuffer(); InitializeComponent(); this.Resize += new System.EventHandler(this.OnResizeForm); this.MouseDown += new MouseEventHandler(OnMouseDown); this.MouseUp += new MouseEventHandler(OnMouseUp); this.MouseMove += new MouseEventHandler(OnMouseMove); }
protected virtual void Initialize2D() { #if DEBUG Factory2D = new SharpDX.Direct2D1.Factory(FactoryType.SingleThreaded, DebugLevel.Information); #else Factory2D = new SharpDX.Direct2D1.Factory(FactoryType.SingleThreaded); #endif using (var surface = BackBuffer.QueryInterface <Surface>()) { RenderTarget = new RenderTarget(Factory2D, surface, new RenderTargetProperties(new PixelFormat(Format.Unknown, AlphaMode.Premultiplied))); } RenderTarget.AntialiasMode = AntialiasMode.PerPrimitive; FactoryDWrite = new SharpDX.DirectWrite.Factory(); SceneColorBrush = new SolidColorBrush(RenderTarget, Color.White); }
/// <summary> /// Copies any current content to the back buffer so that drawing should occur on the /// back buffer (instead of the fore-buffer). Calling draw methods without /// calling this may cause exceptions. /// </summary> /// <param name="preserve">Boolean, true if the front buffer content should be copied to the back buffer /// where drawing will be taking place.</param> public void StartDrawing(bool preserve) { Bitmap backBuffer = new Bitmap(BufferRectangle.Width, BufferRectangle.Height); if (Buffer != null && preserve && Buffer.Width == backBuffer.Width && Buffer.Height == backBuffer.Height) { Graphics g = Graphics.FromImage(backBuffer); g.DrawImageUnscaled(Buffer, 0, 0); } if (BackBuffer != null && BackBuffer != Buffer) { BackBuffer.Dispose(); } BackBuffer = backBuffer; OnStartDrawing(); }
/// <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; } }
public void Dispose() { if (IsDisposed) { return; } if (RenderContext != null) { RenderContext.Dispose(); } if (BackBuffer != null) { BackBuffer.Dispose(); } if (DepthStencilBuffer != null) { DepthStencilBuffer.Dispose(); } //if (Factory != null) //Factory.Dispose(); if (swapChain != null) { swapChain.Dispose(); } GraphicsObject[] created = CreatedObjects.ToArray(); for (int i = 0; i < created.Length; i++) { if (!created[i].IsDisposed) { Log.Warning("{0} was not disposed! Created at:\r\n{1}", created[i].GetType().Name, created[i].CreationStack); created[i].Dispose(); } } CreatedObjects.Clear(); if (Device != null) { Device.Dispose(); } IsDisposed = true; }
/// <summary> /// Resets the engine /// </summary> private void Reset() { // Set flag to prevent infinite loop of resets _isResetting = true; #region Cleanup Log.Info("Clearing Direct3D resources"); BackBuffer.Dispose(); DeviceLost?.Invoke(); #endregion #region Wait // Wait in case the device isn't ready to be reset while (Device.TestCooperativeLevel() == ResultCode.DeviceLost) { Thread.Sleep(100); WinForms.Application.DoEvents(); } // Catch internal driver errors var result = Device.TestCooperativeLevel(); if (result != ResultCode.DeviceNotReset && result != ResultCode.Success) { throw new Direct3D9Exception(result); } #endregion #region Reset Log.Info("Resetting Direct3D device"); Log.Info("Presentation parameters:\n" + PresentParams); Device.Reset(PresentParams); // Setup the default values for the Direct3D device and restore resources SetupTextureFiltering(); RenderViewport = Device.Viewport; BackBuffer = Device.GetBackBuffer(0, 0); DeviceReset?.Invoke(); State.Reset(); Performance.Reset(); #endregion _isResetting = NeedsReset = false; }
public void Shutdown() { // Before shutting down set to windowed mode or when you release the swap chain it will throw an exception. _swapChain?.SetFullscreenState(false, null); _alphaEnableBlendingState?.Dispose(); _alphaEnableBlendingState = null; _alphaDisableBlendingState?.Dispose(); _alphaDisableBlendingState = null; BackBuffer?.Dispose(); BackBuffer = null; _depthDisabledStencilState?.Dispose(); _depthDisabledStencilState = null; _rasterState?.Dispose(); _rasterState = null; DepthStencilView?.Dispose(); DepthStencilView = null; _depthStencilState?.Dispose(); _depthStencilState = null; DepthStencilBuffer?.Dispose(); DepthStencilBuffer = null; _renderTargetView?.Dispose(); _renderTargetView = null; DeviceContext?.Dispose(); DeviceContext = null; Device?.Dispose(); Device = null; BackBuffer?.Dispose(); BackBuffer = null; _swapChain?.Dispose(); _swapChain = null; }
public void UnloadDirect3D() { if (!Ready) { return; } TextureCache.Dispose(); DefaultTextureView.Dispose(); DefaultTexture.Dispose(); SampleState.Dispose(); DefaultEffect.Dispose(); BackBufferView.Dispose(); BackBuffer.Dispose(); DepthBufferView.Dispose(); DepthBuffer.Dispose(); Device.Dispose(); }
/// <summary> /// /// </summary> private void InitializeD2D() { mFactory2D = new SharpDX.Direct2D1.Factory(); using (var surface = BackBuffer.QueryInterface <DXGI.Surface>()) { mRenderTarget2D = new RenderTarget(mFactory2D, surface, new RenderTargetProperties(new PixelFormat(DXGI.Format.Unknown, AlphaMode.Premultiplied))); } mRenderTarget2D.AntialiasMode = AntialiasMode.PerPrimitive; mFactoryDWrite = new SharpDX.DirectWrite.Factory(); SceneColorBrush = new SolidColorBrush(mRenderTarget2D, Color.White); // Initialize fonts foreach (eTextSize size in Enum.GetValues(typeof(eTextSize))) { mTextFormats.Add(size, new SharpDX.DirectWrite.TextFormat(mFactoryDWrite, "Arial", (int)size)); } }
/// <inheritdoc /> protected override void RenderInternal() { var graphics = BackBuffer.Graphics; var t = DateTime.UtcNow.Millisecond / 1000.0; Color GetColor(int x, int y) => Color.FromArgb ( byte.MaxValue, (byte)((double)x / BufferSize.Width * byte.MaxValue), (byte)((double)y / BufferSize.Height * byte.MaxValue), (byte)(Math.Sin(t * Math.PI) * byte.MaxValue) ); Parallel.For(0, BackBuffer.Buffer.Length, index => { BackBuffer.GetXY(index, out var x, out var y); BackBuffer.Buffer[index] = GetColor(x, y).ToArgb(); });
/// <inheritdoc /> protected override void RenderInternal(IEnumerable <IPrimitive> primitives) { // clear buffers BackBuffer.Clear(Color.Black); // render primitives RenderPrimitives(primitives); // draw fps BackBuffer.Graphics.DrawString(FpsCounter.FpsString, FontConsolas12, Brushes.Red, 0, 0); // flush and swap buffers BufferedGraphics.Graphics.DrawImage( BackBuffer.Bitmap, new RectangleF(PointF.Empty, HostSize), new RectangleF(new PointF(-0.5f, -0.5f), BufferSize), GraphicsUnit.Pixel); BufferedGraphics.Render(GraphicsHostDeviceContext); }
private void FullRender() { if (BackBuffer == null) { return; } if (_CurrentTable == null || _CurrentPalette == null || _CurrentDefiniton == null) { Graphics.FromImage(BackBuffer).Clear(Color.Black); return; } BitmapData data = BackBuffer.LockBits(new Rectangle(0, 0, BackBuffer.Width, BackBuffer.Height), ImageLockMode.WriteOnly, PixelFormat.Format32bppArgb); for (int i = 0; i < _CurrentWorld.Height; i++) { for (int j = 0; j < _CurrentWorld.Width; j++) { int tileValue = CurrentWorld.LevelData[j, i]; int PaletteIndex = tileValue / 0x40; Block b = CurrentDefiniton[tileValue]; RenderTile(_CurrentTable[b[0, 0]], j * 16, i * 16, PaletteIndex, data); RenderTile(_CurrentTable[b[0, 1]], j * 16, i * 16 + 8, PaletteIndex, data); RenderTile(_CurrentTable[b[1, 0]], j * 16 + 8, i * 16, PaletteIndex, data); RenderTile(_CurrentTable[b[1, 1]], j * 16 + 8, i * 16 + 8, PaletteIndex, data); if (_ShowPointers) { WorldPointer p = CurrentWorld.Pointers.Find(pt => (pt.X == j && pt.Y == i)); if (p != null) { RenderSpecialTileAlpha(_SpecialTable[0xA2], j * 16, i * 16, 5, data, 1.0); RenderSpecialTileAlpha(_SpecialTable[0xB2], j * 16, i * 16 + 8, 5, data, 1.0); RenderSpecialTileAlpha(_SpecialTable[0xA3], j * 16 + 8, i * 16, 5, data, 1.0); RenderSpecialTileAlpha(_SpecialTable[0xB3], j * 16 + 8, i * 16 + 8, 5, data, 1.0); } } } } BackBuffer.UnlockBits(data); }
protected override void WindowResize(int width, int height) { base.WindowResize(width, height); Device.ImmediateContext.ClearState(); _renderTarget2D.Dispose(); BackBuffer.Dispose(); RenderView.Dispose(); _surface?.Dispose(); SwapChain.ResizeBuffers(1, 0, 0, Format.R8G8B8A8_UNorm, SwapChainFlags.None); BackBuffer = Resource.FromSwapChain <Texture2D>(SwapChain, 0); RenderView = new RenderTargetView(Device, BackBuffer); _surface = BackBuffer.QueryInterface <Surface>(); _renderTarget2D = new RenderTarget(Factory2D, _surface, new RenderTargetProperties(new PixelFormat(Format.R8G8B8A8_UNorm, AlphaMode.Premultiplied))); }
public void Render() { lock (_updateLock) { FpsCounter.StartFrame(); Task.Delay(10).Wait(); var t = DateTime.UtcNow.Millisecond / 1000.0; Color GetColor(int x, int y) => Color.FromArgb ( byte.MaxValue, (byte)((double)x / _bufferSize.Width * byte.MaxValue), (byte)((double)y / _bufferSize.Height * byte.MaxValue), (byte)(Math.Sin(t * Math.PI) * byte.MaxValue) ); Parallel.For(0, BackBuffer.Buffer.Length, index => { BackBuffer.GetXY(index, out var x, out var y); BackBuffer.Buffer[index] = GetColor(x, y).ToArgb(); });
public void ExitAndRelease() { try { D2Ddevice.ImmediateContext.ClearState(); //设备即时上下文清理状态 D2Ddevice.ImmediateContext.Flush(); //设备即时上下文刷新 D2Ddevice.Dispose(); //设备销毁 D2Ddevice.Dispose(); //设备销毁 SwapChain.Dispose(); //基础交换链销毁 DXGIFactory.Dispose(); //基础工厂销毁 BackBufferView.Dispose(); //后备缓冲视图销毁 BackBuffer.Dispose(); //后备缓冲销毁 } catch (Exception) { return; } }
protected virtual void CreateResource() { //*** using (var surface = BackBuffer.QueryInterface<DXGI.Surface>()) { renderTarget = new D2D.RenderTarget(DirectX.Factory2D, surface, new D2D.RenderTargetProperties() { PixelFormat = new D2D.PixelFormat(DXGI.Format.Unknown, D2D.AlphaMode.Premultiplied), }); } renderTarget.AntialiasMode = D2D.AntialiasMode.PerPrimitive; /***/ /*** using (var surface = BackBuffer.QueryInterface<DXGI.Surface>()) { deviceContext = new D2D.DeviceContext(surface, new SharpDX.Direct2D1.CreationProperties() { DebugLevel = SharpDX.Direct2D1.DebugLevel.Information, Options = SharpDX.Direct2D1.DeviceContextOptions.None, ThreadingMode = SharpDX.Direct2D1.ThreadingMode.SingleThreaded } ); bitmap = new SharpDX.Direct2D1.Bitmap1(deviceContext, surface, new SharpDX.Direct2D1.BitmapProperties1() { BitmapOptions = SharpDX.Direct2D1.BitmapOptions.Target | SharpDX.Direct2D1.BitmapOptions.CannotDraw, PixelFormat = new SharpDX.Direct2D1.PixelFormat(DXGI.Format.B8G8R8A8_UNorm, SharpDX.Direct2D1.AlphaMode.Ignore), DpiX = (float)Dpi, DpiY = (float)Dpi } ); deviceContext.Target = bitmap; } deviceContext.AntialiasMode = D2D.AntialiasMode.PerPrimitive; /***/ }
public Win32VtkRenderingSurface(IntPtr windowId, bool offscreen) { _imageBuffer = new BitmapBuffer(PixelFormat.Format32bppRgb); _overlayBuffer = new BitmapBuffer(PixelFormat.Format32bppArgb); _finalBuffer = new BackBuffer(); _vtkRenderer = new vtkRenderer(); _vtkRenderer.SetBackground(0.0f, 0.0f, 0.0f); _vtkRenderWindow = new vtkWin32OpenGLRenderWindow(); _vtkRenderWindow.OffScreenRenderingOn(); _vtkRenderWindow.DoubleBufferOff(); _vtkRenderWindow.EraseOn(); _vtkRenderWindow.SwapBuffersOff(); _vtkRenderWindow.SetDesiredUpdateRate(_dynamicFrameRate); _vtkRenderWindow.AddRenderer(_vtkRenderer); _dynamicRenderEventPublisher = !offscreen ? new DelayedEventPublisher((s, e) => Render(true, null)) : null; WindowID = windowId; }
/// <inheritdoc /> protected override void Dispose(bool disposing) { if (disposing) { if (Buffer != BackBuffer && Buffer != null) { Buffer.Dispose(); Buffer = null; } if (BackBuffer != null) { BackBuffer.Dispose(); BackBuffer = null; } BufferEnvelope = null; BufferRectangle = Rectangle.Empty; IsInitialized = false; } base.Dispose(disposing); }
/// <summary> /// Updates the backbuffer /// </summary> public void UpdateBackBuffer() { if (BackBuffer != null) { BackBuffer.Dispose(); } Size size = GetSize(); BackBuffer = new Bitmap(size.Width, size.Height, PixelFormat.Format32bppPArgb); Graphics gfx = Graphics.FromImage(BackBuffer); gfx.Clear(BackColor); if (_useHatch) { using (HatchBrush brush = new HatchBrush(_hatchStyle, _hatchForeColor, _hatchBackColor)) { gfx.FillRectangle(brush, new Rectangle(Point.Empty, size)); } } Point origin = GetOrigin(); if (_image != null && !UseCanvas) { gfx.DrawImage(ImageAlpha != 1 ? BitmapTransparency(_image, ImageAlpha) : _image, origin); } OnAfterDrawOnBackbuffer(ref gfx, ref origin); if (gfx != null) { gfx.Dispose(); } // Flip to screen Invalidate(); }
/// <summary> /// On control paint /// </summary> protected override void OnPaint(PaintEventArgs e) { if (!Enabled || BackBuffer == null) { e.Graphics.FillRectangle(SystemBrushes.ControlDark, ClientRectangle); return; } Rectangle src = new Rectangle(0, 0, BackBuffer.Width, BackBuffer.Height); using (Bitmap image = BackBuffer.Clone(src, BackBuffer.PixelFormat)) { Point srcPoint = GetTranslatePoint(Point.Empty); Size size = UseCanvas && _canvas != Size.Empty ? _canvas : _image != null ? _image.Size : BackBuffer.Size; AutoScrollMinSize = new Size(size.Width * _scale, size.Height * _scale); e.Graphics.PixelOffsetMode = PixelOffsetMode.Half; e.Graphics.InterpolationMode = InterpolationMode.NearestNeighbor; e.Graphics.ScaleTransform(_scale, _scale); e.Graphics.DrawImage(image, ClientRectangle, srcPoint.X, srcPoint.Y, ClientSize.Width, ClientSize.Height, GraphicsUnit.Pixel); e.Graphics.ResetTransform(); OnDrawAfterOnPaint(ref e); } }
void OnAudioFilterRead(float[] bufferData, int bufferChannels) { if (!IsReady || !_isPlaying) { return; } double samplesPerTick = _sampleRate * 60.0F / bpm * 4.0F / signatureLo; double sample = AudioSettings.dspTime * _sampleRate; if (_newPercentage > -1) { UpdatePercentage(); return; } if (isMuted) { int dataLeft = bufferData.Length; while (dataLeft > 0) { double newSample = sample + dataLeft; if (_nextTick < newSample) { dataLeft = (int)(newSample - _nextTick); _nextTick += samplesPerTick; if (++_currentStep > signatureLo) { _currentStep = 1; } _progress = _currentStep * samplesPerTick; if (sequence[_currentStep - 1]) { _index = 0; if (OnBeat != null) { _fireBeatEvent++; } } else { _index = -1; } if (OnAnyStep != null) { _fireAnyStepEvent++; } } else { break; } } } else { for (int dataIndex = 0; dataIndex < bufferData.Length / bufferChannels; dataIndex++) { if (_activeBackBuffers != null) { for (int backBufferIndex = 0; backBufferIndex < _activeBackBuffers.Count; backBufferIndex++) { BackBuffer bb = _activeBackBuffers[backBufferIndex]; int clipChannel = 0; int sourceChannel = 0; while (sourceChannel < bufferChannels) { bufferData[dataIndex * bufferChannels + sourceChannel] += bb.data[bb.index * _clipChannels + clipChannel]; sourceChannel++; clipChannel++; if (clipChannel == _clipChannels - 1) { clipChannel = 0; } } bb.index++; if (bb.index >= bb.data.Length / bufferChannels) { ReleaseBackBuffer(backBufferIndex); backBufferIndex--; if (log) { print("BackBuffer recycled. Total: " + _activeBackBuffers.Count); } } } } if (_index != -1) { int clipChannel = 0; int sourceChannel = 0; while (sourceChannel < bufferChannels) { bufferData[dataIndex * bufferChannels + sourceChannel] += _clipData[_index * _clipChannels + clipChannel]; sourceChannel++; clipChannel++; if (clipChannel == _clipChannels - 1) { clipChannel = 0; } } _index++; if (_index >= _clipData.Length / _clipChannels) { _index = -1; } } _progress = _currentStep * samplesPerTick + dataIndex; if (sample + dataIndex >= _nextTick) { //Refactored to increase readability. AddToBackBuffer(bufferChannels); _nextTick += samplesPerTick; if (++_currentStep > signatureLo) { _currentStep = 1; } _progress = _currentStep * samplesPerTick; if (sequence[_currentStep - 1]) { _index = 0; if (OnBeat != null) { _fireBeatEvent++; } } else { _index = -1; } if (OnAnyStep != null) { _fireAnyStepEvent++; } if (log) { Debug.Log("Tick: " + _currentStep + " (%" + GetPercentage() + ")"); } } } } }
/// <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."); }
/// <summary> /// Initializes a new Configurator class. /// </summary> /// <param name="backbuffer">The BackBuffer.</param> /// <param name="gameInstance">The GameInstance.</param> /// <param name="renderTarget">The RenderTarget.</param> public Configurator(BackBuffer backbuffer, Game gameInstance, RenderTarget renderTarget) : this(60, backbuffer, gameInstance, renderTarget) { }
public virtual void Dispose() { BackBuffer?.Dispose(); BackBuffer = null; Resource.Dispose(); }
private void DisposeBuffers() { BackBuffer.Dispose(); BackBuffer = default; }
protected override IResult Execute(CancellationToken cancellationToken) { if (string.IsNullOrWhiteSpace(FormulaFile)) { WriteHelp(); return(Result.Success); } Log.Write("Preparing..."); var formulaFileName = Path.GetFileName(FormulaFile); var directory = new FileSystemStore(Path.GetDirectoryName(FormulaFile) ?? throw new FileNotFoundException("Unable to access formula file", FormulaFile)); var size = Resolution <= 0 ? 512 : Resolution; using (var backBuffer = new BackBuffer(size, size)) { using var bitmap = new Bitmap(backBuffer.Width, backBuffer.Height, PixelFormat.Format32bppArgb); using var diagnostics = new DiagnosticsWindow(); using var preview = new PreviewControl(backBuffer, bitmap); var formula = AttractorModel.FromJson(directory.Open(formulaFileName).AsText()); var iterator = new Iterator(backBuffer).Configure(config => config .Statistics(s => s.SetEnabled(Trace)) .PerformanceCounter(s => s.SetEnabled(Trace)) .OnFinalize(WriteHeader) .Log(Log)); iterator.AllowMultithreading = !ForceSingleThreading; var n = 0; using (var bitmapG = Graphics.FromImage(bitmap)) { bitmapG.FillRectangle(Brushes.Black, 0, 0, bitmap.Width, bitmap.Height); } preview.SampleCallback = (sample, stats) => { diagnostics.Invoke(new Action( () => { diagnostics.brightness.Series[0].Points.AddXY(iterator.GetCurrentDensity(), stats.AverageBrightness); diagnostics.peakPoint.Series[0].Points.AddXY(iterator.GetCurrentDensity(), stats.HighAccumulator); diagnostics.peakPoint.Series[1].Points.AddXY(iterator.GetCurrentDensity(), stats.LowAccumulator); })); }; preview.RenderCallback = () => { var cd = iterator.GetCurrentDensity(); var increment = cd < 10 ? 1 : GetDensity(++n) / 10.0; // ReSharper disable once MethodSupportsCancellation iterator.Iterate(formula, increment); _totalDensity = iterator.GetCurrentDensity(); }; preview.Dock = DockStyle.Fill; diagnostics.histogramPanel.Controls.Add(preview); var thread = new Thread(() => preview.RenderLoop(() => !preview.Visible)) { IsBackground = true }; diagnostics.Shown += (o, e) => thread.Start(); diagnostics.ShowDialog(); } return(Result.Success); }
public override void InitRenderTarget() { BackBuffer?.Dispose(); RenderTargetViewRef?.Dispose(); DepthStencilSRVRef?.Dispose(); ZBuffer?.Dispose(); DepthStencilViewRef?.Dispose(); RenderTarget2D?.Dispose(); SwapChainRef.ResizeBuffers(1, Width, Height, Format.R8G8B8A8_UNorm, SwapChainFlags.None); using (Surface surface = SwapChainRef.GetBackBuffer <Surface>(0)) { RenderTarget2D = new RenderTarget(Factory2D, surface, RenderTarget2DProperites); } RenderTarget2D.AntialiasMode = AntialiasMode.PerPrimitive; RenderTarget2D.TextAntialiasMode = TextAntialiasMode.Cleartype; BackBuffer = SwapChainRef.GetBackBuffer <Texture2D>(0); BackBuffer.DebugName = "BackBuffer"; RenderTargetViewRef = new RenderTargetView(DeviceRef, BackBuffer); RenderTargetViewRef.DebugName = "BackBufferRenderTargetView"; ZBufferTextureDescription.Width = Width; ZBufferTextureDescription.Height = Height; ZBuffer = new Texture2D(DeviceRef, ZBufferTextureDescription); ZBuffer.DebugName = "ZBuffer"; DepthStencilViewRef = new DepthStencilView(DeviceRef, ZBuffer, new DepthStencilViewDescription { Format = Format.D32_Float, Dimension = MSamplesCount > 1 ? DepthStencilViewDimension.Texture2DMultisampled : DepthStencilViewDimension.Texture2D, Flags = DepthStencilViewFlags.None, }); DepthStencilViewRef.DebugName = "ZBufferDepthStencilView"; ShaderResourceViewDescription SRVDesc = new ShaderResourceViewDescription() { Format = Format.R32_Float, }; if (MSamplesCount > 1) { SRVDesc.Dimension = ShaderResourceViewDimension.Texture2DMultisampled; SRVDesc.Texture2DMS = new ShaderResourceViewDescription.Texture2DMultisampledResource(); } else { SRVDesc.Dimension = ShaderResourceViewDimension.Texture2D; SRVDesc.Texture2D = new ShaderResourceViewDescription.Texture2DResource() { MostDetailedMip = 0, MipLevels = 1, }; } DepthStencilSRVRef = new ShaderResourceView(DeviceRef, ZBuffer, SRVDesc); DepthStencilSRVRef.DebugName = "ZBufferDepthStencilSRV"; SetUpViewport(); OnInitRenderTarget?.Invoke(); }
public DX11(RenderForm form, CoreSettings coreSettings) { _form = form; sw = Stopwatch.StartNew(); LoadedTexturesByName = new Dictionary <string, ShaderResourceView>(); LoadedTexturesByPtrs = new Dictionary <IntPtr, ShaderResourceView>(); var swapChainDesc = new SwapChainDescription { Usage = Usage.RenderTargetOutput, OutputHandle = form.Handle, BufferCount = 1, IsWindowed = true, Flags = SwapChainFlags.AllowModeSwitch, SwapEffect = SwapEffect.Discard, SampleDescription = new SampleDescription(1, 0), ModeDescription = new ModeDescription { Format = Format.R8G8B8A8_UNorm, Width = form.Width, Height = form.Height, Scaling = DisplayModeScaling.Unspecified, RefreshRate = new Rational(60, 1), ScanlineOrdering = DisplayModeScanlineOrder.Unspecified } }; Device.CreateWithSwapChain(DriverType.Hardware, DeviceCreationFlags.None, new[] { FeatureLevel.Level_11_0, FeatureLevel.Level_10_0 }, swapChainDesc, out var device, out var swapChain); D11Device = device; DeviceContext = device.ImmediateContext; _swapChain = swapChain; factory = swapChain.GetParent <Factory>(); factory.MakeWindowAssociation(form.Handle, WindowAssociationFlags.IgnoreAll); BackBuffer = Resource.FromSwapChain <Texture2D>(swapChain, 0); RenderTargetView = new RenderTargetView(device, BackBuffer); using (new PerformanceTimer("Init ImGuiRender")) { ImGuiRender = new ImGuiRender(this, form, coreSettings); } using (new PerformanceTimer("Init SpriteRender")) { SpritesRender = new SpritesRender(this, form, coreSettings); } InitStates(); form.UserResized += (sender, args) => { RenderTargetView?.Dispose(); BackBuffer.Dispose(); swapChain.ResizeBuffers(1, form.Width, form.Height, Format.R8G8B8A8_UNorm, SwapChainFlags.None); BackBuffer = Resource.FromSwapChain <Texture2D>(swapChain, 0); RenderTargetView = new RenderTargetView(device, BackBuffer); ImGuiRender.Resize(form.Bounds); ImGuiRender.UpdateConstantBuffer(); SpritesRender.ResizeConstBuffer(BackBuffer.Description); var descp = BackBuffer.Description; Viewport.Height = form.Height; Viewport.Width = form.Width; DeviceContext.Rasterizer.SetViewport(Viewport); DeviceContext.OutputMerger.SetRenderTargets(RenderTargetView); }; ImGuiDebug = new DebugInformation("ImGui"); SpritesDebug = new DebugInformation("Sprites"); SwapchainDebug = new DebugInformation("Swapchain"); // Core.DebugInformations.Add(ImGuiDebug); // Core.DebugInformations.Add(ImGuiInputDebug); // Core.DebugInformations.Add(SpritesDebug); // Core.DebugInformations.Add(SwapchainDebug); }
protected virtual void Dispose(bool disposing) { if (disposing) { if (_dynamicRenderEventPublisher != null) { _dynamicRenderEventPublisher.Cancel(); _dynamicRenderEventPublisher.Dispose(); _dynamicRenderEventPublisher = null; } if (_vtkRenderWindow != null) { _vtkRenderWindow.Dispose(); _vtkRenderWindow = null; } if (_vtkRenderer != null) { _vtkRenderer.Dispose(); _vtkRenderer = null; } if (_sceneGraphRoot != null) { _sceneGraphRoot.Dispose(); _sceneGraphRoot = null; } if (_imageBuffer != null) { _imageBuffer.Dispose(); _imageBuffer = null; } if (_overlayBuffer != null) { _overlayBuffer.Dispose(); _overlayBuffer = null; } if (_finalBuffer != null) { _finalBuffer.Dispose(); _finalBuffer = null; } } }
/// <summary> /// is called when the <see cref="WinControl"/> has changed his size. /// </summary> /// <param name="width">the new width of the Wincontrol</param> /// <param name="height">the new height of the Wincontrol</param> protected virtual void OnViewPortChanged(int width, int height) { //if (FirstViewPortChanged) //{ FirstViewPortChanged = false; // OnCreated(); // if (this._RenderMode == Mode.Allways) // SetTimer(); //} // return; //CheckError(); if ((width == 0) || (height == 0)) { return; } MakeCurrent(); Matrix old = EyeMatrix(new Size((int)ViewPort.Width, (int)ViewPort.Height), FieldOfView).invert(); double Fa = ViewPort.Width / (float)width; double Fb = ViewPort.Height / (float)height; ViewPort = new Rectangle(0, 0, width, height); ShadowFBO.InitForDepth(ShadowSetting.Width, ShadowSetting.Height); CheckError(); Matrix New = EyeMatrix(new Size(width, height), FieldOfView); Matrix M = ((Matrix.LookAt(Camera.Position, Camera.Position + Camera.Direction, Camera.UpVector)));//* Matrix.Scale(PerspektiveFactor, PerspektiveFactor, PerspektiveFactor)); if (FieldOfView == 0) { Fa = 1; Fb = 1; } ProjectionMatrix = Matrix.Scale(Fa, Fb, 1) * ProjectionMatrix * M.invert() * old * New * M; Camera.MakeConsistent(); if (FirstViewPortChanged) { Camera.setDefZoom(); FirstViewPortChanged = false; Shader = SmallShader; OnCreated(); SizeChanged(); if (this._RenderMode == Mode.Allways) { SetTimer(); } } try { if (ForegroundDrawEnable) { BackBuffer.Init(width, height); RefreshBackGround(); CopyFromBackGround(); } } catch (System.Exception) { _ForegroundDrawEnable = false; } CheckError(); }
void ReleaseBackBuffer(BackBuffer bb) { _activeBackBuffers.Remove(bb); bb.ClearData(); if (_backBufferPool == null) _backBufferPool = new List<BackBuffer>(); _backBufferPool.Add(bb); }
BackBuffer BackBufferFactory() { BackBuffer bb = null; if (_activeBackBuffers == null && maxBackBufferSize > 0 && increaseBackBufferBy > 0) _activeBackBuffers = new List<BackBuffer>(increaseBackBufferBy); if (_activeBackBuffers != null && _activeBackBuffers.Count < maxBackBufferSize) { if (_activeBackBuffers.Count == _activeBackBuffers.Capacity) { int newCap = _activeBackBuffers.Capacity + increaseBackBufferBy; if (newCap > maxBackBufferSize) newCap = maxBackBufferSize; _activeBackBuffers.Capacity = newCap; } if (_backBufferPool != null && _backBufferPool.Count > 0) { bb = _backBufferPool[0]; _backBufferPool.RemoveAt(0); } else { bb = new BackBuffer(); } _activeBackBuffers.Add(bb); } return bb; }