public void PlatformClear(ClearOptions options, Vector4 color, float depth, int stencil)
{
// TODO: We need to figure out how to detect if we have a
// depth stencil buffer or not, and clear options relating
// to them if not attached.
_graphics.SetClearColor(color.ToPssVector4());
_graphics.Clear();
}
public void Clear(ClearOptions options, Vector4 color, float depth, int stencil)
{
GLDevice.Clear(
options,
color,
depth,
stencil
);
}
public void Clear(ClearOptions options, Vector4 color, float depth, int stencil)
{
PlatformClear(options, color, depth, stencil);
unchecked
{
_graphicsMetrics._clearCount++;
}
}
public void Clear(ClearOptions options, Color color, float depth, int stencil)
{
Clear(
options,
color.ToVector4(),
depth,
stencil
);
}
public StateManager(Game2D game, ClearOptions clearOptions) : base(game)
{
_clearOptions = clearOptions;
_availableStates = new Dictionary <Type, IState>();
_availableTransitions = new Dictionary <Type, ITransition>();
_sourceRenderTarget = new RenderTarget2D(Game.GraphicsDevice, Game.GraphicsDevice.Viewport.Width,
Game.GraphicsDevice.Viewport.Height);
_targetRenderTarget = new RenderTarget2D(Game.GraphicsDevice, Game.GraphicsDevice.Viewport.Width,
Game.GraphicsDevice.Viewport.Height);
}
public void Clear(ClearOptions options, Vector4 color, float depth, int stencil)
{
// The following was not working with Color.Transparent
// Once we get some regression tests take the following out
//GL.ClearColor (color.X, color.Y, color.Z, 1.0f);
GL.ClearColor(color.X, color.Y, color.Z, color.W);
GL.ClearDepth(depth);
GL.ClearStencil(stencil);
GL.Clear((ClearBufferMask.ColorBufferBit | ClearBufferMask.DepthBufferBit | ClearBufferMask.StencilBufferBit));
}
/// <summary>
/// Construct the clear buffer modifier, clearing all buffers
/// </summary>
/// <param name="clearOptions"></param>
/// <param name="colourValue">colour to clear the render target</param>
/// <param name="depthValue">Depth to clear the render target (usuall 1.0f)</param>
/// <param name="stencilValue">Stencil value to clear the stencil buffer to</param>
public ClearBufferModifier(ClearOptions clearOptions, Color colourValue, float depthValue, byte stencilValue)
{
this.ClearColourEnabled = (clearOptions & ClearOptions.Target) == ClearOptions.Target;
this.ClearColour = colourValue;
this.ClearStencilEnabled = (clearOptions & ClearOptions.Stencil) == ClearOptions.Stencil;
this.ClearStencilValue = stencilValue;
this.ClearDepthEnabled = (clearOptions & ClearOptions.DepthBuffer) == ClearOptions.DepthBuffer;
this.ClearDepth = depthValue;
}
public void Clear(
ClearOptions options,
Vector4 color,
float depth,
int stencil
)
{
ForceToMainThread(() =>
{
GLDevice.Clear(options, color, depth, stencil);
}); // End ForceToMainThread
}
public static void ClearSubstitute <T>(this T substitute, ClearOptions options = ClearOptions.All) where T : class
{
if (substitute == null)
{
throw new NullSubstituteReferenceException();
}
var context = SubstitutionContext.Current;
var router = context.GetCallRouterFor(substitute !);
router.Clear(options);
}
public void Clear(ClearOptions options, Color4 color, float depth, byte stencil)
{
if (options == ClearOptions.None)
{
return;
}
EnsureRenderTarget();
BindClearValues(false, options, color, depth, stencil);
ClearBufferMask glClearBufferMask = 0;
if ((options & ClearOptions.ColorBuffer) != 0)
{
glClearBufferMask |= ClearBufferMask.ColorBufferBit;
if (boundColorWriteMask != ColorWriteMask.All)
{
GL.ColorMask(true, true, true, true);
GLHelper.CheckGLErrors();
boundColorWriteMask = ColorWriteMask.All;
}
}
if ((options & ClearOptions.DepthBuffer) != 0)
{
glClearBufferMask |= ClearBufferMask.DepthBufferBit;
if (!boundDepthState.WriteEnable)
{
GL.DepthMask(true);
GLHelper.CheckGLErrors();
boundDepthState.WriteEnable = true;
depthStateDirty = true;
}
}
if ((options & ClearOptions.StencilBuffer) != 0)
{
glClearBufferMask |= ClearBufferMask.StencilBufferBit;
if (boundStencilState.WriteMask != 0xff)
{
GL.StencilMask(0xff);
GLHelper.CheckGLErrors();
boundStencilState.WriteMask = 0xff;
stencilStateDirty = true;
}
}
if (boundScissorState.Enable)
{
GL.Disable(EnableCap.ScissorTest);
GLHelper.CheckGLErrors();
boundScissorState.Enable = false;
scissorStateDirty = true;
}
GL.Clear(glClearBufferMask);
GLHelper.CheckGLErrors();
}
/// <inheritdoc/>
public void Clear(ClearOptions options, Color color, Double depth, Int32 stencil)
{
Contract.EnsureNotDisposed(this, Disposed);
var mask = 0u;
var resetColorWriteChannels = false;
var resetDepthMask = false;
if ((options & ClearOptions.Target) == ClearOptions.Target && (renderTarget == null || renderTarget.HasColorBuffer))
{
if (blendState.ColorWriteChannels != ColorWriteChannels.All)
{
resetColorWriteChannels = true;
OpenGLState.ColorMask = ColorWriteChannels.All;
}
OpenGLState.ClearColor = color;
mask |= gl.GL_COLOR_BUFFER_BIT;
}
if ((options & ClearOptions.DepthBuffer) == ClearOptions.DepthBuffer && (renderTarget == null || renderTarget.HasDepthBuffer))
{
if (!depthStencilState.DepthBufferEnable)
{
resetDepthMask = true;
OpenGLState.DepthMask = true;
}
OpenGLState.ClearDepth = depth;
mask |= gl.GL_DEPTH_BUFFER_BIT;
}
if ((options & ClearOptions.Stencil) == ClearOptions.Stencil && (renderTarget == null || renderTarget.HasStencilBuffer))
{
OpenGLState.ClearStencil = stencil;
mask |= gl.GL_STENCIL_BUFFER_BIT;
}
gl.Clear(mask);
gl.ThrowIfError();
if (resetColorWriteChannels)
{
OpenGLState.ColorMask = blendState.ColorWriteChannels;
}
if (resetDepthMask)
{
OpenGLState.DepthMask = depthStencilState.DepthBufferWriteEnable;
}
}
static int Clear(ClearOptions copts)
{
conf.GetInstance().debug = copts.Verbose;
string wpPath = WinApi.GetCurrentWallpaperPath();
WinApi.SystemParametersInfo(SPI_SETDESKWALLPAPER,
0,
wpPath,
SPIF_UPDATEINIFILE | SPIF_SENDWININICHANGE);
if (conf.GetInstance().debug)
{
Console.WriteLine("Desktop change request sent!");
}
return(1);
}
public override void Clear(ClearOptions options, Color color, float depth, int stencil)
{
XNA.Color c;
XNAHelper.ConvertColor(ref color, out c);
XFG.ClearOptions xfgClear = XFG.ClearOptions.Target;
if ((options & ClearOptions.Depth) == ClearOptions.Depth)
{
xfgClear |= XFG.ClearOptions.DepthBuffer;
}
if ((options & ClearOptions.Stencil) == ClearOptions.Stencil)
{
xfgClear |= XFG.ClearOptions.Stencil;
}
_graphicsDevice.Clear(xfgClear, c, depth, stencil);
}
public void Clear(ClearOptions options)
{
if ((options & ClearOptions.CallActions) == ClearOptions.CallActions)
{
_substituteState.CallActions.Clear();
}
if ((options & ClearOptions.ReturnValues) == ClearOptions.ReturnValues)
{
_substituteState.CallResults.Clear();
_substituteState.ResultsForType.Clear();
}
if ((options & ClearOptions.ReceivedCalls) == ClearOptions.ReceivedCalls)
{
_substituteState.ReceivedCalls.Clear();
}
}
public void ShouldNotResetCachedValuesOnSubsituteClear(ClearOptions options)
{
// Arrange
var fixture = new Fixture().Customize(new AutoConfiguredNSubstituteCustomization());
var substitute = fixture.Create <IInterfaceWithMethod>();
string arg = "argValue";
// Act
var resultBefore = substitute.Method(arg);
substitute.ClearSubstitute(options);
var resultAfter = substitute.Method(arg);
// Assert
Assert.Equal(resultBefore, resultAfter);
}
public void Clear(ClearOptions options)
{
if ((options & ClearOptions.CallActions) == ClearOptions.CallActions)
{
_substituteState.CallActions.Clear();
}
if ((options & ClearOptions.ReturnValues) == ClearOptions.ReturnValues)
{
_substituteState.CallResults.Clear();
_substituteState.ResultsForType.Clear();
}
if ((options & ClearOptions.ReceivedCalls) == ClearOptions.ReceivedCalls)
{
_substituteState.ReceivedCalls.Clear();
}
}
public void Clear(ClearOptions options, Vector4 color, float depth, int stencil)
{
if (openGLESVersion == GLContextVersion.Gles2_0)
{
GL20.ClearColor(color.X, color.Y, color.Z, color.W);
GL20.ClearDepth(depth);
GL20.ClearStencil(stencil);
GL20.Clear((uint)(All20.ColorBufferBit | All20.DepthBufferBit | All20.StencilBufferBit));
}
else
{
GL11.ClearColor(color.X, color.Y, color.Z, color.W);
GL11.ClearDepth(depth);
GL11.ClearStencil(stencil);
GL11.Clear((uint)(All11.ColorBufferBit | All11.DepthBufferBit | All11.StencilBufferBit));
}
}
public IRenderService SetRenderTarget(string Key, ClearOptions CO, Color ClearColor, float Depth)
{
bool didStop = false;
if (IsDrawing)
{
spriteBatch.End();
didStop = true;
}
currentTarget = Key != null ? targets[Key] : null;
GraphicsDevice.SetRenderTarget(currentTarget);
GraphicsDevice.Clear(CO | ClearOptions.Stencil, ClearColor, Depth, 0);
if (didStop)
{
return(Start());
}
return(this);
}
public void ShouldNotResetCachedValuesOnSubsituteClear(ClearOptions options)
{
// Fixture setup
var fixture = new Fixture().Customize(new AutoConfiguredNSubstituteCustomization());
var substitute = fixture.Create <IInterfaceWithMethod>();
string arg = "argValue";
// Exercise system
var resultBefore = substitute.Method(arg);
substitute.ClearSubstitute(options);
var resultAfter = substitute.Method(arg);
// Verify outcome
Assert.Equal(resultBefore, resultAfter);
// Teardown
}
public void Clear(ClearOptions options, Vector4 color, float depth, int stencil)
{
uint mask = 0;
if (color.X != 0f || color.Y != 0f || color.Z != 0f || color.W != 0f)
{
GL.ClearColor(color.X, color.Y, color.Z, color.W);
mask = (uint)ClearBufferMask.ColorBufferBit | mask;
}
GL.ClearDepth(depth);
mask = (uint)ClearBufferMask.DepthBufferBit | mask;
GL.ClearStencil(stencil);
mask = (uint)ClearBufferMask.StencilBufferBit | mask;
GL.Clear(mask);
}
/// <summary>
/// Everything between <c>BeginAntialising()</c> and <c>EndAntialising()</c> will be affected by MSAA.
/// </summary>
/// <example>
/// <code>
/// protected override void Draw()
/// {
/// base.Draw();
///
/// Editor.BeginAntialising();
///
/// Editor.spriteBatch.Begin();
///
/// //Your drawings
///
/// Editor.spriteBatch.End();
///
/// Editor.EndAntialising();
/// }
/// </code>
/// </example>
/// <param name="clearGraphics"><c>false</c> if you don't want to to call <see cref="graphics"/>.Clear() after setting the <see cref="RenderTarget2D"/>.</param>
/// <param name="clearColor">The <see cref="Color"/> to be used to clear the <see cref="graphics"/> after setting the <see cref="RenderTarget2D"/>.</param>
/// <param name="clearOptions">Define your custom <see cref="ClearOptions"/>.</param>
/// <param name="depth">The depth.</param>
/// <param name="stencil">The stencil</param>
public void BeginAntialising(
bool clearGraphics = true,
Color?clearColor = null,
ClearOptions clearOptions = ClearOptions.DepthBuffer | ClearOptions.Stencil | ClearOptions.Target,
float depth = 0f,
int stencil = 0)
{
if (AntialisingRenderTarget.GetRenderTarget2D == null ||
AntialisingRenderTarget.IsRefreshing ||
!AntialisingRenderTarget.Enabled)
{
return;
}
graphics.SetRenderTarget(AntialisingRenderTarget.GetRenderTarget2D);
if (clearGraphics)
{
graphics.Clear(clearOptions, clearColor ?? BackgroundColor, depth, stencil);
}
}
/// <summary>
/// Sets the swapchain's backbuffer as the active render target and clears it.
/// </summary>
/// <param name="options">Clear option flags defining which buffer to clear.</param>
/// <param name="color">Color to clear the color buffer to</param>
/// <param name="depth">Depth value to clear the depth buffer to</param>
/// <param name="stencil">Stencil value to clear the stencil buffer to</param>
public override void Clear(ClearOptions options, Color color, float depth, int stencil)
{
if (_resetting)
{
return;
}
SlimDX.Color4 sc;
D3D10Helper.Convert(ref color, out sc);
_renderer.TargetManager.SetActiveSwapChain(this);
if (_depthStencilView != null)
{
_graphicsDevice.OutputMerger.SetTargets(_depthStencilView, _renderTargetView);
if (((options & ClearOptions.Depth) == ClearOptions.Depth) && ((options & ClearOptions.Stencil) == ClearOptions.Stencil))
{
_graphicsDevice.ClearDepthStencilView(_depthStencilView, D3D.DepthStencilClearFlags.Depth | D3D.DepthStencilClearFlags.Stencil, depth, (byte)stencil);
}
else if ((options & ClearOptions.Depth) == ClearOptions.Depth)
{
_graphicsDevice.ClearDepthStencilView(_depthStencilView, D3D.DepthStencilClearFlags.Depth, depth, (byte)stencil);
}
else if ((options & ClearOptions.Stencil) == ClearOptions.Stencil)
{
_graphicsDevice.ClearDepthStencilView(_depthStencilView, D3D.DepthStencilClearFlags.Stencil, depth, (byte)stencil);
}
if ((options & ClearOptions.Target) == ClearOptions.Target)
{
_graphicsDevice.ClearRenderTargetView(_renderTargetView, sc);
}
}
else
{
_graphicsDevice.OutputMerger.SetTargets(_renderTargetView);
if ((options & ClearOptions.Target) == ClearOptions.Target)
{
_graphicsDevice.ClearRenderTargetView(_renderTargetView, sc);
}
}
}
/// <summary>
/// Everything between <c>BeginRenderTarget()</c> and <c>EndRenderTarget()</c> will be drawn to the <see cref="RenderTarget2D"/>.
/// </summary>
/// <example>
/// <code>
/// protected override void Draw()
/// {
/// base.Draw();
///
/// Editor.BeginRenderTarget("MyRenderTarget");
///
/// Editor.spriteBatch.Begin();
///
/// //Your drawings
///
/// Editor.spriteBatch.End();
///
/// Editor.EndRenderTarget("MyRenderTarget", false);
/// }
/// </code>
/// </example>
/// <param name="key">Please enter a previously set key of the <see cref="RenderTarget2D"/> you want to begin with.</param>
/// <param name="clearGraphics"><c>false</c> if you don't want to to call <see cref="graphics"/>.Clear() after setting the <see cref="RenderTarget2D"/>.</param>
/// <param name="clearColor">The <see cref="Color"/> to be used to clear the <see cref="graphics"/> after setting the <see cref="RenderTarget2D"/>.</param>
/// <param name="clearOptions">Define your custom <see cref="ClearOptions"/>.</param>
/// <param name="depth">The depth.</param>
/// <param name="stencil">The stencil</param>
public void BeginRenderTarget(
string key,
bool clearGraphics = true,
Color?clearColor = null,
ClearOptions clearOptions = ClearOptions.DepthBuffer | ClearOptions.Stencil | ClearOptions.Target,
float depth = 0f,
int stencil = 0)
{
if (GetRenderTargetManager.GetRenderTarget2D(key) == null ||
GetRenderTargetManager.RenderTargets[key].IsRefreshing ||
!GetRenderTargetManager.RenderTargets[key].Enabled)
{
return;
}
graphics.SetRenderTarget(GetRenderTargetManager.GetRenderTarget2D(key));
if (clearGraphics)
{
graphics.Clear(clearOptions, clearColor ?? BackgroundColor, depth, stencil);
}
}
private ClearBufferMask CreateClearOptions(ClearOptions clearOptions, float depth, int stencil)
{
ClearBufferMask bufferMask = 0;
if (clearOptions.HasFlag(ClearOptions.Target))
{
bufferMask = bufferMask | ClearBufferMask.ColorBufferBit;
}
if (clearOptions.HasFlag(ClearOptions.Stencil))
{
GL.ClearStencil(stencil);
bufferMask = bufferMask | ClearBufferMask.StencilBufferBit;
}
if (clearOptions.HasFlag(ClearOptions.DepthBuffer))
{
GL.ClearDepth(depth);
bufferMask = bufferMask | ClearBufferMask.DepthBufferBit;
}
return(bufferMask);
}
public override void clear(Background background)
{
Color color1 = Color.Black;
ClearOptions options = ClearOptions.Target;
bool flag = false;
if (background != null)
{
if (background.isColorClearEnabled())
{
int color2 = background.getColor();
float num = 0.003921569f;
color1 = new Color((float)((color2 & 16711680) >> 16) * num, (float)((color2 & 65280) >> 8) * num, (float)(color2 & (int)byte.MaxValue) * num) * ((float)(((long)color2 & 4278190080L) >> 24) * num);
flag = true;
}
if (background.isDepthClearEnabled())
{
if (background.isColorClearEnabled())
{
options |= ClearOptions.DepthBuffer;
flag = true;
}
else
{
options = ClearOptions.DepthBuffer;
flag = true;
}
}
}
else
{
options = ClearOptions.Target | ClearOptions.DepthBuffer;
flag = true;
}
if (!flag)
{
return;
}
this.device.Clear(options, color1, 1f, 0);
}
//GG EDIT IMPLEMENTED
public void Clear(ClearOptions options, Color color, float depth, int stencil)
{
Vector4 vector = color.ToEAGLColor();
GL.ClearColor(vector.X, vector.Y, vector.Z, 1.0f);
switch (options)
{
case ClearOptions.DepthBuffer:
GL.ClearDepth(depth);
GL.Clear(ClearBufferMask.DepthBufferBit);
break;
case ClearOptions.Stencil:
GL.ClearStencil(stencil);
GL.Clear(ClearBufferMask.StencilBufferBit);
break;
case ClearOptions.Target:
throw new NotImplementedException();
}
}
public static void Clear(Action <GraphicsDevice, ClearOptions, Vector4, float, int> orig, GraphicsDevice self, ClearOptions options, Vector4 color, float depth, int stencil)
{
if (SkipClear > 0)
{
SkipClear--;
return;
}
orig(self, options, color, depth, stencil);
}
public static void Clear(ClearOptions options, Color color, float depth, int stencil)
{
Device.Clear(options, color, 0, 0);
}
public static void Begin(ClearOptions options, Color color, float depth, int stencil)
{
Device.Clear(options, color, depth, stencil);
MainEffect.Begin();
MainEffect.CurrentTechnique.Passes[0].Begin();
}
public void Clear(ClearOptions clear) { }
public abstract void Clear (ClearOptions options, Vector4 color, float depth, int stencil);
public void Clear(ClearOptions options, Vector4 color, float depth, int stencil, Rectangle[] regions)
{
throw new NotImplementedException();
}
/// <inheritdoc/>
public void Clear(ClearOptions options, Color color, Double depth, Int32 stencil)
{
Contract.EnsureNotDisposed(this, Disposed);
var mask = 0u;
var resetColorWriteChannels = false;
var resetDepthTest = false;
var resetStencilTest = false;
if ((options & ClearOptions.Target) == ClearOptions.Target)
{
if (blendState.ColorWriteChannels != ColorWriteChannels.All)
{
resetColorWriteChannels = true;
gl.ColorMask(true, true, true, true);
}
gl.ClearColor(color.R / 255f, color.G / 255f, color.B / 255f, color.A / 255f);
mask |= gl.GL_COLOR_BUFFER_BIT;
}
if ((options & ClearOptions.DepthBuffer) == ClearOptions.DepthBuffer)
{
if (!depthStencilState.DepthBufferEnable)
{
resetDepthTest = true;
gl.Enable(gl.GL_DEPTH_TEST);
gl.DepthMask(true);
}
gl.ClearDepth(depth);
mask |= gl.GL_DEPTH_BUFFER_BIT;
}
if ((options & ClearOptions.Stencil) == ClearOptions.Stencil)
{
if (!depthStencilState.StencilEnable)
{
resetStencilTest = true;
gl.Enable(gl.GL_STENCIL_TEST);
}
gl.ClearStencil(stencil);
mask |= gl.GL_STENCIL_BUFFER_BIT;
}
gl.Clear(mask);
if (resetColorWriteChannels)
{
gl.ColorMask(
(blendState.ColorWriteChannels & ColorWriteChannels.Red) == ColorWriteChannels.Red,
(blendState.ColorWriteChannels & ColorWriteChannels.Green) == ColorWriteChannels.Green,
(blendState.ColorWriteChannels & ColorWriteChannels.Blue) == ColorWriteChannels.Blue,
(blendState.ColorWriteChannels & ColorWriteChannels.Alpha) == ColorWriteChannels.Alpha);
gl.ThrowIfError();
}
if (resetDepthTest)
{
gl.Enable(gl.GL_DEPTH_TEST, depthStencilState.DepthBufferEnable);
gl.ThrowIfError();
gl.DepthMask(depthStencilState.DepthBufferWriteEnable);
gl.ThrowIfError();
}
if (resetStencilTest)
{
gl.Enable(gl.GL_STENCIL_TEST, depthStencilState.StencilEnable);
gl.ThrowIfError();
}
}
public void Clear(ClearOptions options, Vector4 color, float depth, int stencil)
{
// glClear depends on the scissor rectangle!
if (scissorTestEnable)
{
glDisable(GLenum.GL_SCISSOR_TEST);
}
bool clearTarget = (options & ClearOptions.Target) == ClearOptions.Target;
bool clearDepth = (options & ClearOptions.DepthBuffer) == ClearOptions.DepthBuffer;
bool clearStencil = (options & ClearOptions.Stencil) == ClearOptions.Stencil;
// Get the clear mask, set the clear properties if needed
GLenum clearMask = GLenum.GL_ZERO;
if (clearTarget)
{
clearMask |= GLenum.GL_COLOR_BUFFER_BIT;
if (!color.Equals(currentClearColor))
{
glClearColor(
color.X,
color.Y,
color.Z,
color.W
);
currentClearColor = color;
}
// glClear depends on the color write mask!
if (colorWriteEnable != ColorWriteChannels.All)
{
// FIXME: ColorWriteChannels1/2/3? -flibit
glColorMask(true, true, true, true);
}
}
if (clearDepth)
{
clearMask |= GLenum.GL_DEPTH_BUFFER_BIT;
if (depth != currentClearDepth)
{
glClearDepth((double) depth);
currentClearDepth = depth;
}
// glClear depends on the depth write mask!
if (!zWriteEnable)
{
glDepthMask(true);
}
}
if (clearStencil)
{
clearMask |= GLenum.GL_STENCIL_BUFFER_BIT;
if (stencil != currentClearStencil)
{
glClearStencil(stencil);
currentClearStencil = stencil;
}
// glClear depends on the stencil write mask!
if (stencilWriteMask != -1)
{
// AKA 0xFFFFFFFF, ugh -flibit
glStencilMask(-1);
}
}
// CLEAR!
glClear(clearMask);
// Clean up after ourselves.
if (scissorTestEnable)
{
glEnable(GLenum.GL_SCISSOR_TEST);
}
if (clearTarget && colorWriteEnable != ColorWriteChannels.All)
{
// FIXME: ColorWriteChannels1/2/3? -flibit
glColorMask(
(colorWriteEnable & ColorWriteChannels.Red) != 0,
(colorWriteEnable & ColorWriteChannels.Blue) != 0,
(colorWriteEnable & ColorWriteChannels.Green) != 0,
(colorWriteEnable & ColorWriteChannels.Alpha) != 0
);
}
if (clearDepth && !zWriteEnable)
{
glDepthMask(false);
}
if (clearStencil && stencilWriteMask != -1) // AKA 0xFFFFFFFF, ugh -flibit
{
glStencilMask(stencilWriteMask);
}
}
/// <inheritdoc/>
public void Clear(ClearOptions options, Color color, Double depth, Int32 stencil)
{
Contract.EnsureNotDisposed(this, Disposed);
}
/// <summary>
/// Construct the clear buffer modifier
/// </summary>
/// <param name="clearOptions"></param>
public ClearBufferModifier(ClearOptions clearOptions)
: this(clearOptions, Color.CornflowerBlue, 1, 0)
{
}
/// <summary>
/// Construct the clear buffer modifier
/// </summary>
/// <param name="clearOptions"></param>
/// <param name="colourValue">Colour to clear the render target</param>
public ClearBufferModifier(ClearOptions clearOptions, Color colourValue)
: this(clearOptions, colourValue, 1, 0)
{
}
/// <summary>
/// Construct the clear buffer modifier, clearing all buffers
/// </summary>
/// <param name="clearOptions"></param>
/// <param name="colourValue">colour to clear the render target</param>
/// <param name="depthValue">Depth to clear the render target (usuall 1.0f)</param>
/// <param name="stencilValue">Stencil value to clear the stencil buffer to</param>
public ClearBufferModifier(ClearOptions clearOptions, Color colourValue, float depthValue, byte stencilValue)
{
this.ClearColourEnabled = (clearOptions & ClearOptions.Target) == ClearOptions.Target;
this.ClearColour = colourValue;
this.ClearStencilEnabled = (clearOptions & ClearOptions.Stencil) == ClearOptions.Stencil;
this.ClearStencilValue = stencilValue;
this.ClearDepthEnabled = (clearOptions & ClearOptions.DepthBuffer) == ClearOptions.DepthBuffer;
this.ClearDepth = depthValue;
}
public abstract void Clear (ClearOptions options, Color color, float depth, int stencil, Rectangle[] regions);
private void PlatformClear(ClearOptions options, Vector4 color, float depth, int stencil)
{
// TODO: We need to figure out how to detect if we have a
// depth stencil buffer or not, and clear options relating
// to them if not attached.
// Unlike with XNA and DirectX... GL.Clear() obeys several
// different render states:
//
// - The color write flags.
// - The scissor rectangle.
// - The depth/stencil state.
//
// So overwrite these states with what is needed to perform
// the clear correctly and restore it afterwards.
//
var prevScissorRect = ScissorRectangle;
var prevDepthStencilState = DepthStencilState;
var prevBlendState = BlendState;
ScissorRectangle = _viewport.Bounds;
// DepthStencilState.Default has the Stencil Test disabled;
// make sure stencil test is enabled before we clear since
// some drivers won't clear with stencil test disabled
DepthStencilState = _clearDepthStencilState;
BlendState = BlendState.Opaque;
ApplyState(false);
ClearBufferMask bufferMask = 0;
if ((options & ClearOptions.Color) == ClearOptions.Color)
{
if (color != _lastClearColor)
{
GL.ClearColor(color.X, color.Y, color.Z, color.W);
GL.CheckError();
_lastClearColor = color;
}
bufferMask |= ClearBufferMask.ColorBufferBit;
}
if ((options & ClearOptions.Stencil) == ClearOptions.Stencil)
{
if (stencil != _lastClearStencil)
{
GL.ClearStencil(stencil);
GL.CheckError();
_lastClearStencil = stencil;
}
bufferMask |= ClearBufferMask.StencilBufferBit;
}
if ((options & ClearOptions.DepthBuffer) == ClearOptions.DepthBuffer)
{
if (depth != _lastClearDepth)
{
if (GL.ClearDepthF != null)
{
GL.ClearDepthF(depth);
}
else
{
GL.ClearDepth(depth);
}
GL.CheckError();
_lastClearDepth = depth;
}
bufferMask |= ClearBufferMask.DepthBufferBit;
}
#if MONOMAC || IOS
if (GL.CheckFramebufferStatus(FramebufferTarget.FramebufferExt) ==
FramebufferErrorCode.FramebufferComplete)
#endif
{
GL.Clear(bufferMask);
GL.CheckError();
}
// Restore the previous render state.
ScissorRectangle = prevScissorRect;
DepthStencilState = prevDepthStencilState;
BlendState = prevBlendState;
}
public void Clear(ClearOptions clear) => throw new NotImplementedException();
public void Clear(ClearOptions options, Color color, Single depth, int stencil, Rectangle[] regions)
{
throw new NotImplementedException();
}
public void SetRenderTargets(params RenderTargetBinding[] renderTargets)
{
currentRenderTargets = renderTargets;
if (currentRenderTargets != null)
{
// TODO: For speed we need to consider using FBO switching instead
// of multiple FBO's if they are the same size.
// http://www.songho.ca/opengl/gl_fbo.html
// Get the currently bound frame buffer object. On most platforms this just gives 0.
GL.GetInteger(All.FramebufferBindingOes, ref originalFbo);
frameBufferIDs = new int[currentRenderTargets.Length];
renderBufferIDs = new int[currentRenderTargets.Length];
GL.Oes.GenRenderbuffers(currentRenderTargets.Length, renderBufferIDs);
for (int i = 0; i < currentRenderTargets.Length; i++)
{
RenderTarget2D target = (RenderTarget2D)currentRenderTargets[i].RenderTarget;
// create a renderbuffer object to store depth info
GL.Oes.BindRenderbuffer(All.RenderbufferOes, renderBufferIDs[i]);
ClearOptions clearOptions = ClearOptions.Target | ClearOptions.DepthBuffer;
switch (target.DepthStencilFormat)
{
case DepthFormat.Depth16:
GL.Oes.RenderbufferStorage(All.RenderbufferOes, All.DepthComponent16Oes,
target.Width, target.Height);
break;
case DepthFormat.Depth24:
GL.Oes.RenderbufferStorage(All.RenderbufferOes, All.DepthComponent24Oes,
target.Width, target.Height);
break;
case DepthFormat.Depth24Stencil8:
GL.Oes.RenderbufferStorage(All.RenderbufferOes, All.Depth24Stencil8Oes,
target.Width, target.Height);
GL.Oes.FramebufferRenderbuffer(All.FramebufferOes, All.StencilAttachmentOes,
All.RenderbufferOes, renderBufferIDs[i]);
clearOptions = clearOptions | ClearOptions.Stencil;
break;
default:
GL.Oes.RenderbufferStorage(All.RenderbufferOes, All.DepthComponent24Oes,
target.Width, target.Height);
break;
}
// create framebuffer
GL.Oes.GenFramebuffers(1, ref frameBufferIDs[i]);
GL.Oes.BindFramebuffer(All.FramebufferOes, frameBufferIDs[i]);
// attach the texture to FBO color attachment point
GL.Oes.FramebufferTexture2D(All.FramebufferOes, All.ColorAttachment0Oes, All.Texture2D, target.ID, 0);
// attach the renderbuffer to depth attachment point
GL.Oes.FramebufferRenderbuffer(All.FramebufferOes, All.DepthAttachmentOes,
All.RenderbufferOes, renderBufferIDs[i]);
if (target.RenderTargetUsage == RenderTargetUsage.DiscardContents)
{
Clear(clearOptions, Color.Transparent, 0, 0);
}
GL.Oes.BindRenderbuffer(All.FramebufferOes, originalFbo);
}
All status = GL.Oes.CheckFramebufferStatus(All.FramebufferOes);
if (status != All.FramebufferCompleteOes)
{
throw new Exception("Error creating framebuffer: " + status);
}
// We need to start saving off the ViewPort and setting the current ViewPort to
// the width and height of the texture. Then when we pop off the rendertarget
// it needs to be reset. This causes drawing problems if we do not set the viewport.
// Makes sense once you follow the flow (hits head on desk)
// For an example of this take a look at NetRumble's sample for the BloomPostprocess
// Save off the current viewport to be reset later
savedViewport = Viewport;
// Create a new Viewport
Viewport renderTargetViewPort = new Viewport();
// Set the new viewport to the width and height of the render target
Texture2D target2 = (Texture2D)currentRenderTargets[0].RenderTarget;
renderTargetViewPort.Width = target2.Width;
renderTargetViewPort.Height = target2.Height;
// now we set our viewport to the new rendertarget viewport just created.
Viewport = renderTargetViewPort;
}
}
public void Clear(ClearOptions options, Vector4 color, Single depth, int stencil)
{
throw new NotImplementedException();
}