public void Resize(uint width, uint height)
{
this.width = width;
this.height = height;
frameBuffer?.Dispose();
createGBuff();
frameBuffer = new FrameBuffer(renderPass, width, height, new Image[] {
hdrImgResolved, null, gbColorRough, gbEmitMetal, gbN_AO, gbPos
});
}
/// <summary>Releases the resources that are used by the object.</summary>
internal virtual void DisposeInternal()
{
if (!disposed)
{
//after shutdown check
if (RenderingSystem.Disposed)
{
//waiting for .NET Standard 2.0
Log.Fatal("Renderer: Dispose after Shutdown.");
//Log.Fatal( "Renderer: Dispose after Shutdown: {0}()", System.Reflection.MethodInfo.GetCurrentMethod().Name );
}
lock (RenderingSystem.renderTargets)
RenderingSystem.renderTargets.Remove(this);
//lock( RendererWorld.renderTargets )
// RendererWorld.renderTargets.Remove( (IntPtr)realObject );
while (viewports.Count != 0)
{
Viewport viewport = viewports[viewports.Count - 1];
viewport.Dispose();
}
if (frameBufferNeedDispose)
{
frameBuffer.Dispose();
}
disposed = true;
}
GC.SuppressFinalize(this);
}
public void TestDepthFromOtherFrameBuffer()
{
Runner.ExecuteAsLoop(_ =>
{
FrameBuffer testBuffer = new FrameBuffer(Engine.Renderer.DrawBuffer.Size).WithColor().WithDepth(true);
var shader = Engine.AssetLoader.Get <ShaderAsset>("Shaders/DepthTest.xml");
RenderComposer composer = Engine.Renderer.StartFrame();
composer.RenderTo(testBuffer);
composer.ClearFrameBuffer();
composer.RenderSprite(new Vector3(0, 0, 10), new Vector2(100, 100), Color.Green);
composer.RenderTo(null);
composer.SetUseViewMatrix(false);
composer.SetShader(shader.Shader);
shader.Shader.SetUniformInt("depthTexture", 1);
Texture.EnsureBound(testBuffer.DepthTexture.Pointer, 1);
composer.RenderSprite(new Vector3(0, 0, 0), testBuffer.Texture.Size, Color.White, testBuffer.Texture);
composer.SetShader();
composer.SetUseViewMatrix(true);
composer.RenderSprite(new Vector3(20, 20, 15), new Vector2(100, 100), Color.Blue);
composer.RenderSprite(new Vector3(10, 10, 0), new Vector2(100, 100), Color.Red);
Engine.Renderer.EndFrame();
Runner.VerifyScreenshot(ResultDb.TestDepthFromOtherFrameBuffer);
testBuffer.Dispose();
}).WaitOne();
}
public override void Dispose()
{
if (_matHblur != null)
{
_matHblur.Dispose();
}
if (_matVblur != null)
{
_matVblur.Dispose();
}
if (_sprites != null)
{
_sprites.Dispose();
}
if (_fb != null)
{
_fb.Dispose();
}
if (_quad != null)
{
_quad.Dispose();
}
base.Dispose();
}
public void FrameBufferAttachColorTextureWithUInt()
{
tlog.Debug(tag, $"FrameBufferAttachColorTextureWithUInt START");
var testingTarget = new FrameBuffer(10, 20, 3);
Assert.IsNotNull(testingTarget, "Can't create success object FrameBuffer.");
Assert.IsInstanceOf <FrameBuffer>(testingTarget, "Should return FrameBuffer instance.");
using (Texture texture = new Texture(TextureType.TEXTURE_2D, PixelFormat.BGR8888, 100, 80))
{
try
{
testingTarget.AttachColorTexture(texture, 2, 1);
}
catch (Exception e)
{
tlog.Debug(tag, e.Message.ToString());
Assert.Fail("Caught Exception : Failed!");
}
}
testingTarget.Dispose();
tlog.Debug(tag, $"FrameBufferAttachColorTextureWithUInt END (OK)");
}
protected virtual void Dispose(bool disposing)
{
if (disposing)
{
frame_buffer.Dispose();
}
}
public void Dispose()
{
shadowPipeline?.Dispose();
fbShadowMap?.Dispose();
shadowMap?.Dispose();
descriptorPool?.Dispose();
}
protected override void Dispose(bool disposing)
{
if (!IsDisposed)
{
#if DIRECTX
if (disposing)
{
SharpDX.Utilities.Dispose(ref _renderTargetView);
SharpDX.Utilities.Dispose(ref _depthStencilView);
}
#elif PSM
_frameBuffer.Dispose();
#elif OPENGL
GraphicsDevice.AddDisposeAction(() =>
{
if (this.glStencilBuffer != 0 && this.glStencilBuffer != this.glDepthBuffer)
{
GL.DeleteRenderbuffers(1, ref this.glStencilBuffer);
}
GL.DeleteRenderbuffers(1, ref this.glDepthBuffer);
GraphicsExtensions.CheckGLError();
});
#endif
}
base.Dispose(disposing);
}
public void FramebufferResizing()
{
Runner.ExecuteAsLoop(_ =>
{
FrameBuffer testBuffer = new FrameBuffer(new Vector2(1000, 1000)).WithColor();
RenderComposer composer = Engine.Renderer.StartFrame();
composer.RenderToAndClear(testBuffer);
composer.RenderSprite(new Vector3(0, 0, 0), new Vector2(1000, 1000), Color.Red);
composer.RenderTo(null);
composer.RenderSprite(new Vector3(0, 0, 0), new Vector2(100, 100), Color.White, testBuffer.Texture);
testBuffer.Resize(new Vector2(500, 500), true);
composer.RenderToAndClear(testBuffer);
composer.RenderSprite(new Vector3(0, 0, 0), new Vector2(500, 500), Color.Green);
composer.RenderTo(null);
composer.RenderFrameBuffer(testBuffer, new Vector2(100, 100), new Vector3(100, 0, 0));
Engine.Renderer.EndFrame();
Runner.VerifyScreenshot(ResultDb.FramebufferResizing);
testBuffer.Dispose();
}).WaitOne();
}
public void CopyFramebuffer_ThrowsOnDisposed()
{
var frameBuffer = new FrameBuffer();
frameBuffer.Dispose();
Assert.Throws <ObjectDisposedException>(() => frameBuffer.CopyFramebuffer(new byte[] { }));
}
// --------------------------------------------------------------------
public void Dispose()
{
mFrameBuffer.Dispose();
Scene.Dispose();
Camera.Dispose();
mFrameBuffer = null;
Scene = null;
Camera = null;
}
public void Dispose()
{
vbTeapot.Dispose();
shaderTexture.Dispose();
shaderGaussianX.Dispose();
shaderGaussianY.Dispose();
gaussianXYBuffer.Dispose();
gaussianXBuffer.Dispose();
sceneBuffer.Dispose();
}
public void FrameBufferConstructor()
{
tlog.Debug(tag, $"FrameBufferConstructor START");
var testingTarget = new FrameBuffer(10, 20, 3);
Assert.IsNotNull(testingTarget, "Can't create success object FrameBuffer.");
Assert.IsInstanceOf <FrameBuffer>(testingTarget, "Should return FrameBuffer instance.");
testingTarget.Dispose();
tlog.Debug(tag, $"FrameBufferConstructor END (OK)");
}
/// Release unmanaged resources
public void Dispose()
{
texShadow.Dispose();
texColorMap.Dispose();
texRenderer.Dispose();
frameBuffer.Dispose();
shaderTexture.Dispose();
shaderShadowMap.Dispose();
shaderProjectionShadow.Dispose();
vbTeapot.Dispose();
vbGrid.Dispose();
meshGrid.Dispose();
}
void wnd_3_Resize(object sender, EventArgs e)
{
var ctrl = (System.Windows.Forms.Control)sender;
FrameBuffer newBuffer = new FrameBuffer(ctrl.Width, ctrl.Height);
Display.RenderTarget = newBuffer;
Display.BeginFrame();
Display.Clear(Color.FromArgb(0, 0, 0, 0));
Display.RenderState.AlphaBlend = false;
frameBuffer.RenderTarget.Draw();
Display.EndFrame();
Display.RenderState.AlphaBlend = true;
frameBuffer.Dispose();
frameBuffer = newBuffer;
}
private void getImageGL(Action <Image <Rgba32> > callback)
{
host.DrawThread.Scheduler.Add(() =>
{
var image = new Image <Rgba32>((int)DrawWidth, (int)DrawHeight);
var sharedData = (BufferedDrawNodeSharedData)typeof(BufferedContainer <Drawable>).GetField("sharedData", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(this);
var fbo = new FrameBuffer();
fbo.Bind();
GL.FramebufferTexture2D(FramebufferTarget.Framebuffer, FramebufferAttachment.ColorAttachment0, TextureTarget2d.Texture2D, sharedData.MainBuffer.Texture.TextureId, 0);
bool success = image.TryGetSinglePixelSpan(out var span);
Debug.Assert(success);
GL.ReadPixels(0, 0, (int)DrawWidth, (int)DrawHeight, PixelFormat.Rgba, PixelType.UnsignedByte, ref MemoryMarshal.GetReference(span));
fbo.Dispose();
GLWrapper.BindFrameBuffer(GLWrapper.DefaultFrameBuffer);
callback(image);
});
}
private void setTexture()
{
float num;
float num2;
if (this.needPartialTexture)
{
num = FMath.Min(this.frontPanel.Width, this.MaxTextureWidth) * UISystem.Scale;
num2 = FMath.Min(this.frontPanel.Height, this.MaxTextureHeight) * UISystem.Scale;
}
else
{
num = this.frontPanel.Width * UISystem.Scale;
num2 = this.frontPanel.Height * UISystem.Scale;
}
if (this.cacheTexture == null || this.cacheTexture.Width != (int)num || this.cacheTexture.Height != (int)num2)
{
if (this.cacheTexture != null)
{
this.cacheTexture.Dispose();
}
this.cacheTexture = new Texture2D((int)num, (int)num2, false, (PixelFormat)1, (PixelBufferOption)1);
}
Matrix4 matrix = new Matrix4(1f, 0f, 0f, 0f, 0f, 1f, 0f, 0f, 0f, 0f, 1f, 0f, -this.textureOffsetX, -this.textureOffsetY, 0f, 1f);
FrameBuffer frameBuffer = new FrameBuffer();
frameBuffer.SetColorTarget(this.cacheTexture, 0);
this.frontPanel.RenderToFrameBuffer(frameBuffer, ref matrix, true);
frameBuffer.Dispose();
if (this.animationSprt.Image != null)
{
this.animationSprt.Image.Dispose();
}
this.animationSprt.Image = new ImageAsset(this.cacheTexture);
this.animationSprt.Image.AdjustScaledSize = true;
this.texImage = this.animationSprt.Image;
this.animationSprt.Visible = true;
this.frontPanel.Visible = false;
}
/// <summary>
/// Unload contents
/// </summary>
public override void UnloadContent()
{
if (Plane != null)
{
Plane.Dispose();
}
Plane = null;
if (Torus != null)
{
Torus.Dispose();
}
Torus = null;
if (SceneShader != null)
{
SceneShader.Dispose();
}
SceneShader = null;
if (Font != null)
{
Font.Dispose();
}
Font = null;
if (SpriteBatch != null)
{
SpriteBatch.Dispose();
}
SpriteBatch = null;
if (FrameBuffer != null)
{
FrameBuffer.Dispose();
}
FrameBuffer = null;
}
void FreeResources()
{
if (_prevFBO != null)
{
_prevFBO.Dispose();
}
if (_nextFBO != null)
{
_nextFBO.Dispose();
}
if (_prevTexture != null)
{
_prevTexture.Dispose();
}
if (_nextTexture != null)
{
_nextTexture.Dispose();
}
_prevFBO = null;
_nextFBO = null;
_prevTexture = null;
_nextTexture = null;
}
// --------------------------------------------------------------------
protected override void OnHandleDestroyed(EventArgs e)
{
base.OnHandleDestroyed(e);
mFrameBuffer.Dispose();
}
protected override void Dispose(bool disposing)
{
_frameBuffer.Dispose();
base.Dispose(disposing);
}
static void Term()
{
SampleDraw.Term();
frameBuffer.Dispose();
graphics.Dispose();
}
private void ImplDispose()
{
FrameBuffer.Dispose();
}
public static CubeMapTexture Generate(int seed, int resolution, int samples)
{
var rand = seed == 0 ? new Random() : new Random(seed);
var stars = Star.Generate(rand, rand.Next(16384, 32768));
var dusts = DustCloud.Generate(rand, rand.Next(4096, 8192));
int renderResolution = resolution * samples;
var camera = new Camera(renderResolution, renderResolution, MathHelper.PiOver2, 4f, 64f);
var starShader = new StarShader {
Camera = camera
};
var dustShader = new DustCloudShader {
Camera = camera
};
var target = new FrameBuffer(new BitmapTexture2D(new Bitmap(renderResolution, renderResolution)), 16);
var angles = new[] {
Tuple.Create(0f, MathHelper.PiOver2),
Tuple.Create(0f, -MathHelper.PiOver2),
Tuple.Create(MathHelper.PiOver2, 0f),
Tuple.Create(-MathHelper.PiOver2, 0f),
Tuple.Create(0f, 0f),
Tuple.Create(0f, MathHelper.Pi)
};
var bmps = new Bitmap[6];
target.Begin();
GL.ClearColor(Color.Black);
var bmp = new Bitmap(renderResolution, renderResolution);
for (int i = 0; i < 6; ++i)
{
camera.Pitch = angles[i].Item1;
camera.Yaw = angles[i].Item2;
GL.Clear(ClearBufferMask.ColorBufferBit | ClearBufferMask.DepthBufferBit);
dustShader.BeginBatch();
foreach (var dust in dusts)
{
dustShader.Render(dust);
}
dustShader.EndBatch();
starShader.BeginBatch();
foreach (var star in stars)
{
starShader.Render(star);
}
starShader.EndBatch();
var data = bmp.LockBits(new Rectangle(0, 0, renderResolution, renderResolution), ImageLockMode.WriteOnly, System.Drawing.Imaging.PixelFormat.Format32bppArgb);
GL.ReadPixels(0, 0, renderResolution, renderResolution, OpenTK.Graphics.OpenGL.PixelFormat.Bgra, PixelType.UnsignedByte, data.Scan0);
bmp.UnlockBits(data);
bmps[i] = new Bitmap(bmp, new Size(resolution, resolution));
}
bmp.Dispose();
target.End();
target.Dispose();
return(new CubeMapTexture(bmps[0], bmps[1], bmps[2], bmps[3], bmps[4], bmps[5]));
}
public void Unload()
{
GLThread.ExecuteGLThread(() => { _fbo.Dispose(); });
}
protected override void Dispose(bool isDisposing)
{
frameBuffer.Dispose();
base.Dispose(isDisposing);
}
public static void FlipFontAtlas(RenderContext renderContext, Texture2D texture)
{
var previousFrameBuffer = renderContext.FrameBuffer;
var previousScissorTest = renderContext.ScissorTest;
var previousDepthTest = renderContext.DepthTest;
var previousViewport = renderContext.ViewportRectangle;
var previousCullBackfaces = renderContext.CullBackfaces;
var previousBlend = renderContext.Blend;
renderContext.GetBlendFunc(out var previousSFactor, out var previousDFactor);
renderContext.ScissorTest = false;
renderContext.DepthTest = false;
renderContext.ViewportRectangle = new Rectangle(0, 0, texture._width, texture._height);
renderContext.CullBackfaces = false;
renderContext.SetBlendFunc(BlendingFactor.One, BlendingFactor.Zero);
var shaderProgram = CreateAtlasFlippingProgram(renderContext);
var tempFrameBuffer = new FrameBuffer(renderContext,
texture._width,
texture._height,
FrameBufferFlags.Color);
var atlasFrameBuffer = new FrameBuffer(renderContext, texture);
VertexPosition2Texture[] vertices =
{
new VertexPosition2Texture(new Vector2(0, 0), new Vector2(0, 1)),
new VertexPosition2Texture(new Vector2(texture._width, 0), new Vector2(1, 1)),
new VertexPosition2Texture(new Vector2(texture._width, texture._height), new Vector2(1, 0)),
new VertexPosition2Texture(new Vector2(0, texture._height), new Vector2(0, 0)),
};
uint[] indices =
{
2, 1, 0,
2, 0, 3,
};
var vertexBuffer = VertexBuffer.Create(renderContext, vertices, BufferUsageHint.StaticDraw, true);
var indexBuffer = IndexBuffer.Create(renderContext, indices, BufferUsageHint.StaticDraw, true);
// Draw atlas texture to temporary frame buffer.
renderContext.BindFrameBuffer(tempFrameBuffer);
renderContext.Clear(Color.Transparent);
renderContext.BindTexture2D(0, texture);
shaderProgram.SetUniform("projection",
Matrix4x4.CreateOrthographicOffCenter(0f,
texture._width,
texture._height,
0f,
-1f,
1f));
renderContext.Render(PrimitiveType.Triangles, vertexBuffer, indexBuffer, shaderProgram);
// Draw temporary render target to atlas texture.
renderContext.BindFrameBuffer(atlasFrameBuffer);
renderContext.Clear(Color.Transparent);
renderContext.BindTexture2D(0, tempFrameBuffer.ColorTexture);
shaderProgram.SetUniform("projection",
Matrix4x4.CreateOrthographicOffCenter(0f,
texture._width,
0f,
texture._height,
-1f,
1f));
renderContext.Render(PrimitiveType.Triangles, vertexBuffer, indexBuffer, shaderProgram);
renderContext.ViewportRectangle = previousViewport;
renderContext.DepthTest = previousDepthTest;
renderContext.ScissorTest = previousScissorTest;
renderContext.CullBackfaces = previousCullBackfaces;
renderContext.Blend = previousBlend;
renderContext.SetBlendFunc(previousSFactor, previousDFactor);
renderContext.BindFrameBuffer(previousFrameBuffer);
vertexBuffer.Dispose();
indexBuffer.Dispose();
tempFrameBuffer.Dispose();
atlasFrameBuffer.Dispose();
shaderProgram.Dispose();
}
