public static void StencilFuncSeparateATI(StencilFunction frontfunc, StencilFunction backfunc, Int32 @ref, UInt32 mask)
{
Debug.Assert(Delegates.pglStencilFuncSeparateATI != null, "pglStencilFuncSeparateATI not implemented");
Delegates.pglStencilFuncSeparateATI((Int32)frontfunc, (Int32)backfunc, @ref, mask);
LogFunction("glStencilFuncSeparateATI({0}, {1}, {2}, {3})", frontfunc, backfunc, @ref, mask);
DebugCheckErrors(null);
}
public static void StencilFuncSeparateATI(StencilFunction frontfunc, StencilFunction backfunc, Int32 @ref, UInt32 mask)
{
Debug.Assert(Delegates.pglStencilFuncSeparateATI != null, "pglStencilFuncSeparateATI not implemented");
Delegates.pglStencilFuncSeparateATI((Int32)frontfunc, (Int32)backfunc, @ref, mask);
LogCommand("glStencilFuncSeparateATI", null, frontfunc, backfunc, @ref, mask);
DebugCheckErrors(null);
}
/// <summary>
/// Set up the stencil condition, full control.
/// See <href>https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/glStencilFuncSeparate.xhtml</href>
/// See <href>https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/glStencilOpSeparate.xhtml</href>
/// </summary>
/// <param name="function">Stencil function to use</param>
/// <param name="refvalue">Reference value</param>
/// <param name="mask">Stencil test mask (ref AND mask) func (stencil AND mask)</param>
/// <param name="face">For this face (default front and back) perform stencil operation on</param>
public GLOperationStencilOnlyIf(StencilFunction function, int refvalue = 1, int mask = 0xff, StencilFace face = StencilFace.FrontAndBack)
{
this.f = function;
this.v = refvalue;
this.mask = mask;
this.face = face;
}
public StencilMode(StencilOperation operation, StencilFunction compare)
{
IsEnabled = true;
CompareFront = compare;
CompareBack = compare;
OperationFront = operation;
OperationBack = operation;
}
public StencilMode(StencilOperation frontOperation, StencilFunction frontCompare, StencilOperation backOperation, StencilFunction backCompare)
{
IsEnabled = true;
CompareFront = frontCompare;
CompareBack = backCompare;
OperationFront = frontOperation;
OperationBack = backOperation;
}
/// <summary>
/// Use after drawing, to set up next draw with stencil conditions
/// Set up the stencil condition
/// </summary>
/// <param name="function">Stencil function</param>
/// <param name="refvalue">Reference value</param>
/// <param name="mask">Stencil test mask (ref AND mask) func (stencil AND mask)</param>
/// <param name="face">For this face (default front and back) perform stencil operation on</param>
static public void OnlyIf(StencilFunction function, int refvalue = 1, int mask = 0xff, StencilFace face = StencilFace.FrontAndBack)
{
// stencil passes if V op stencil[pixel]
GL.StencilFuncSeparate(face, function, refvalue, mask);
GL.StencilOpSeparate(face, StencilOp.Keep, //if it fails, keep stencil value
StencilOp.Keep, //if depth buffer fails, keep stencil value
StencilOp.Keep); //if passed, keep stencil value
}
public StencilState( StencilFunction func, int reference, int mask, StencilOperator zfail, StencilOperator fail, StencilOperator pass )
{
Function = func;
Reference = reference;
Mask = mask;
ZFail = zfail;
Fail = fail;
Pass = pass;
}
internal void PlatformApplyState(GraphicsDevice device)
{
if (_state == null)
{
// Build the description.
var desc = new SharpDX.Direct3D11.DepthStencilStateDescription
{
IsDepthEnabled = DepthBufferEnable,
DepthComparison = DepthBufferFunction.ToComparison()
};
if (DepthBufferWriteEnable)
{
desc.DepthWriteMask = SharpDX.Direct3D11.DepthWriteMask.All;
}
else
{
desc.DepthWriteMask = SharpDX.Direct3D11.DepthWriteMask.Zero;
}
desc.IsStencilEnabled = StencilEnable;
desc.StencilReadMask = (byte)StencilMask; // TODO: Should this instead grab the upper 8bits?
desc.StencilWriteMask = (byte)StencilWriteMask;
if (TwoSidedStencilMode)
{
desc.BackFace.Comparison = CounterClockwiseStencilFunction.ToComparison();
desc.BackFace.DepthFailOperation = GetStencilOp(CounterClockwiseStencilDepthBufferFail);
desc.BackFace.FailOperation = GetStencilOp(CounterClockwiseStencilFail);
desc.BackFace.PassOperation = GetStencilOp(CounterClockwiseStencilPass);
}
else
{ //use same settings as frontFace
desc.BackFace.Comparison = StencilFunction.ToComparison();
desc.BackFace.DepthFailOperation = GetStencilOp(StencilDepthBufferFail);
desc.BackFace.FailOperation = GetStencilOp(StencilFail);
desc.BackFace.PassOperation = GetStencilOp(StencilPass);
}
desc.FrontFace.Comparison = StencilFunction.ToComparison();
desc.FrontFace.DepthFailOperation = GetStencilOp(StencilDepthBufferFail);
desc.FrontFace.FailOperation = GetStencilOp(StencilFail);
desc.FrontFace.PassOperation = GetStencilOp(StencilPass);
// Create the state.
_state = new SharpDX.Direct3D11.DepthStencilState(GraphicsDevice._d3dDevice, desc);
}
Debug.Assert(GraphicsDevice == device, "The state was created for a different device!");
// NOTE: We make the assumption here that the caller has
// locked the d3dContext for us to use.
// Apply the state!
device._d3dContext.OutputMerger.SetDepthStencilState(_state, ReferenceStencil);
}
internal void StencilFunc(StencilFunction func, int @ref, uint mask)
{
if (Filter.StencilFunc != func ||
Filter.StencilFuncRef != @ref ||
Filter.StencilFuncMask != mask)
{
Filter.StencilFunc = func;
Filter.StencilFuncRef = @ref;
Filter.StencilFuncMask = mask;
Gl.StencilFunc(func, @ref, mask);
}
}
/// <summary>
/// Creates a <see cref="StencilState"/> with the specified stencil testing parameters.
/// </summary>
/// <param name="testingEnabled">Whether stencil testing is enabled.</param>
/// <param name="clearStencil">The stencil value to set on a clear operation.</param>
/// <param name="writeMask">The mask to apply when writting to the stencil buffer.</param>
/// <param name="function">The function to use for comparing stencil values.</param>
/// <param name="refValue">A value used for comparison during the stencil test.</param>
/// <param name="testMask">A mask applied before comparison during the stencil test.</param>
/// <param name="sfail">The operation to do when a stencil test fails.</param>
/// <param name="dpfail">The operation to do when a depth test fails.</param>
/// <param name="dppass">The operation to do when both the depth and stencil tests pass.</param>
public StencilState(bool testingEnabled, int clearStencil = 0, uint writeMask = FullMask,
StencilFunction function = StencilFunction.Greater, int refValue = 0, uint testMask = FullMask,
StencilOperation sfail = StencilOperation.Keep, StencilOperation dpfail = StencilOperation.Keep, StencilOperation dppass = StencilOperation.Keep)
{
StencilTestingEnabled = testingEnabled;
ClearStencil = clearStencil;
FrontWriteMask = writeMask;
BackWriteMask = writeMask;
FrontFunction = function;
BackFunction = function;
FrontRefValue = refValue;
BackRefValue = refValue;
FrontTestMask = testMask;
BackTestMask = testMask;
FrontStencilFailOperation = sfail;
BackStencilFailOperation = sfail;
FrontDepthFailOperation = dpfail;
BackDepthFailOperation = dpfail;
FrontPassOperation = dppass;
BackPassOperation = dppass;
}
public static void BeginUseStencilMask(StencilFunction Func, int Ref, uint Mask, bool WriteDepth = true, bool CullFront = true)
{
RenderAPI.DbgPushGroup("BeginUseStencilMask");
RenderState RS = Gfx.PeekRenderState();
RS.EnableStencilTest = true;
RS.StencilFunc(Func, Ref, Mask);
RS.StencilOp(StencilOperation.Keep, StencilOperation.Keep, StencilOperation.Keep);
RS.EnableDepthTest = false;
//if (CullFront) {
RS.EnableCullFace = true;
RS.CullFace = CullFace.Front;
//}
RS.SetColorMask(true);
RS.EnableDepthMask = WriteDepth;
Gfx.PushRenderState(RS);
}
internal static void SetDepthStencilState(DepthStencilState state)
{
if (state.DepthBufferEnable)
{
// enable Depth Buffer
GL.Enable(EnableCap.DepthTest);
}
else
{
GL.Disable(EnableCap.DepthTest);
}
if (state.StencilEnable)
{
// enable Stencil
GL.Enable(EnableCap.StencilTest);
// Set color mask - not needed
//GL.ColorMask(false, false, false, false); //Disable drawing colors to the screen
// set function
StencilFunction func = StencilFunction.Always;
switch (state.StencilFunction)
{
case CompareFunction.Always:
func = StencilFunction.Always;
break;
case CompareFunction.Equal:
func = StencilFunction.Equal;
break;
case CompareFunction.Greater:
func = StencilFunction.Greater;
break;
case CompareFunction.GreaterEqual:
func = StencilFunction.Gequal;
break;
case CompareFunction.Less:
func = StencilFunction.Less;
break;
case CompareFunction.LessEqual:
func = StencilFunction.Lequal;
break;
case CompareFunction.Never:
func = StencilFunction.Never;
break;
case CompareFunction.NotEqual:
func = StencilFunction.Notequal;
break;
}
GL.StencilFunc(func, state.ReferenceStencil, state.StencilMask);
GL.StencilOp(GetStencilOp(state.StencilFail), GetStencilOp(state.StencilDepthBufferFail)
, GetStencilOp(state.StencilPass));
}
else
{
// Set color mask - not needed
//GL.ColorMask(true, true, true, true); // Enable drawing colors to the screen
GL.Disable(EnableCap.StencilTest);
}
}
internal static extern void glStencilFunc(StencilFunction func, Int32 @ref, UInt32 mask);
public void StencilOpSeparate(Face face, StencilFunction fail, StencilFunction zfail, StencilFunction zpass) => this.CallMethod <object>(STENCIL_OP_SEPARATE, face, fail, zfail, zpass);
private int ConvertStencilFunc( StencilFunction func )
{
switch ( func )
{
case StencilFunction.Always: return ( int ) SharpDX.Direct3D9.Compare.Always;
case StencilFunction.Never: return ( int ) SharpDX.Direct3D9.Compare.Never;
case StencilFunction.Equal: return ( int ) SharpDX.Direct3D9.Compare.Equal;
case StencilFunction.NotEqual: return ( int ) SharpDX.Direct3D9.Compare.NotEqual;
case StencilFunction.Greater: return ( int ) SharpDX.Direct3D9.Compare.Greater;
case StencilFunction.GreaterEqual: return ( int ) SharpDX.Direct3D9.Compare.GreaterEqual;
case StencilFunction.Less: return ( int ) SharpDX.Direct3D9.Compare.Less;
case StencilFunction.LessEqual: return ( int ) SharpDX.Direct3D9.Compare.LessEqual;
default: throw new ArgumentException ();
}
}
public void StencilFunc(StencilFunction func, int reference, uint mask)
{
gl.glStencilFunc((int)func, reference, mask);
}
public void StencilOp(StencilFunction fail, StencilFunction zfail, StencilFunction zpass) => this.CallMethod <object>(STENCIL_OP, fail, zfail, zpass);
public static void StencilFuncSeparateATI( StencilFunction frontfunc, StencilFunction backfunc, int @ref, uint mask )
{
if (_StencilFuncSeparateATI == null) throw new Exception( "Extension method StencilFuncSeparateATI not found" );
_StencilFuncSeparateATI( frontfunc, backfunc, @ref, mask );
}
private OpenTK.Graphics.OpenGL.StencilFunction MistyValueToOriginal( StencilFunction func )
{
switch ( func )
{
case StencilFunction.Never: return OpenTK.Graphics.OpenGL.StencilFunction.Never;
case StencilFunction.Always: return OpenTK.Graphics.OpenGL.StencilFunction.Always;
case StencilFunction.Equal: return OpenTK.Graphics.OpenGL.StencilFunction.Equal;
case StencilFunction.NotEqual: return OpenTK.Graphics.OpenGL.StencilFunction.Notequal;
case StencilFunction.Greater: return OpenTK.Graphics.OpenGL.StencilFunction.Greater;
case StencilFunction.Less: return OpenTK.Graphics.OpenGL.StencilFunction.Less;
case StencilFunction.GreaterEqual: return OpenTK.Graphics.OpenGL.StencilFunction.Gequal;
case StencilFunction.LessEqual: return OpenTK.Graphics.OpenGL.StencilFunction.Lequal;
default: throw new ArgumentException ();
}
}
public static void StencilFuncSeparate(StencilFace face, StencilFunction func, int reference, uint mask)
{
glStencilFuncSeparate deleg = BaseGraphicsContext.Current.Loader.Get<glStencilFuncSeparate>();
if (deleg != null)
deleg(face, func, reference, mask);
}
public static void StencilFuncSeparate(StencilFaceDirection face, StencilFunction func, Int32 @ref, UInt32 mask)
{
Debug.Assert(Delegates.pglStencilFuncSeparate != null, "pglStencilFuncSeparate not implemented");
Delegates.pglStencilFuncSeparate((Int32)face, (Int32)func, @ref, mask);
LogFunction("glStencilFuncSeparate({0}, {1}, {2}, {3})", face, func, @ref, mask);
DebugCheckErrors(null);
}
public static void StencilFunc(StencilFunction func, int value, uint mask)
{
CheckCurrent();
_bindings.glStencilFunc((int)func, (IntPtr)value, mask);
CheckError();
}
public static void glStencilFunc(StencilFunction func, Int32 @ref, UInt32 mask)
{
i_OpenGL1_0.glStencilFunc(func, @ref, mask);
}
/// <summary>
/// Stencil test function
/// </summary>
/// <param name="function">Test function</param>
/// <param name="reference">Reference value</param>
/// <param name="mask">Mask</param>
public static void StencilFunction(StencilFunction function, int reference, int mask)
{
TK.GL.StencilFunc((TK.StencilFunction)function, reference, mask);
}
internal static extern void glStencilFunc(StencilFunction func, Int32 @ref, UInt32 mask);
public static void func(StencilFunction f, int @r, uint mask)
{
GL.StencilFunc(f, r, mask);
}
public static void StencilFunc(StencilFunction func, Int32 @ref, UInt32 mask)
{
Debug.Assert(Delegates.pglStencilFunc != null, "pglStencilFunc not implemented");
Delegates.pglStencilFunc((Int32)func, @ref, mask);
CallLog("glStencilFunc({0}, {1}, {2})", func, @ref, mask);
DebugCheckErrors();
}
public static void PathStencilFuncNV(StencilFunction func, Int32 @ref, UInt32 mask)
{
Debug.Assert(Delegates.pglPathStencilFuncNV != null, "pglPathStencilFuncNV not implemented");
Delegates.pglPathStencilFuncNV((Int32)func, @ref, mask);
LogFunction("glPathStencilFuncNV({0}, {1}, {2})", func, @ref, mask);
DebugCheckErrors(null);
}
public partial void StencilFuncSeparate([Flow(FlowDirection.In)] StencilFunction frontfunc, [Flow(FlowDirection.In)] StencilFunction backfunc, [Flow(FlowDirection.In)] int @ref, [Flow(FlowDirection.In)] uint mask);
public static extern void glStencilFunc(StencilFunction function, int @ref, uint mask);
public static void StencilFunc(StencilFunction function, int @ref, uint mask)
{
Delegates.glStencilFunc(function, @ref, mask);
}
public static void StencilFunc(StencilFunction func, int reference, uint mask)
{
glStencilFunc deleg = BaseGraphicsContext.Current.Loader.Get<glStencilFunc>();
if (deleg != null)
deleg(func, reference, mask);
}
