public void SetDefaults() { StencilFailOp = StencilOperation.Keep; StencilDepthFailOp = StencilOperation.Keep; StencilPassOp = StencilOperation.Keep; StencilFunc = Comparison.Always; }
public static SharpVulkan.StencilOperation ConvertStencilOperation(StencilOperation operation) { switch (operation) { case StencilOperation.Decrement: return(SharpVulkan.StencilOperation.DecrementAndWrap); case StencilOperation.DecrementSaturation: return(SharpVulkan.StencilOperation.DecrementAndClamp); case StencilOperation.Increment: return(SharpVulkan.StencilOperation.IncrementAndWrap); case StencilOperation.IncrementSaturation: return(SharpVulkan.StencilOperation.IncrementAndClamp); case StencilOperation.Invert: return(SharpVulkan.StencilOperation.Invert); case StencilOperation.Keep: return(SharpVulkan.StencilOperation.Keep); case StencilOperation.Replace: return(SharpVulkan.StencilOperation.Replace); default: throw new ArgumentOutOfRangeException(); } }
/// <summary> /// Initializes a new instance of the <see cref="DepthStencilOperationDescription"/> struct. /// </summary> /// <param name="stencilFailOp">A <see cref="StencilOperation"/> value that identifies the stencil operation to perform when stencil testing fails.</param> /// <param name="stencilDepthFailOp">A <see cref="StencilOperation"/> value that identifies the stencil operation to perform when stencil testing passes and depth testing fails.</param> /// <param name="stencilPassOp">A <see cref="StencilOperation"/> value that identifies the stencil operation to perform when stencil testing and depth testing both pass.</param> /// <param name="stencilFunc">A <see cref="ComparisonFunction"/> value that identifies the function that compares stencil data against existing stencil data.</param> public DepthStencilOperationDescription(StencilOperation stencilFailOp, StencilOperation stencilDepthFailOp, StencilOperation stencilPassOp, ComparisonFunction stencilFunc) { StencilFailOp = stencilFailOp; StencilDepthFailOp = stencilDepthFailOp; StencilPassOp = stencilPassOp; StencilFunc = stencilFunc; }
internal static XFG.StencilOperation ToXNAStencilOperation(StencilOperation op) { switch (op) { case StencilOperation.Decrement: return(XFG.StencilOperation.Decrement); case StencilOperation.DecrementAndClamp: return(XFG.StencilOperation.DecrementSaturation); case StencilOperation.Increment: return(XFG.StencilOperation.Increment); case StencilOperation.IncrementAndClamp: return(XFG.StencilOperation.IncrementSaturation); case StencilOperation.Invert: return(XFG.StencilOperation.Invert); case StencilOperation.Keep: return(XFG.StencilOperation.Keep); case StencilOperation.Replace: return(XFG.StencilOperation.Replace); case StencilOperation.Zero: return(XFG.StencilOperation.Zero); default: throw new InvalidCastException(); } }
public DepthStencilState(bool depthEnabled, bool stencilEnabled, Comparison depthComparison, Comparison frontFaceComparison, StencilOperation frontFaceDepthFailOp, StencilOperation frontFaceFailOp, StencilOperation frontFacePassOp, Comparison backFaceComparison, StencilOperation backFaceDepthFailOp, StencilOperation backFaceFailOp, StencilOperation backFacePassOp) { DepthStencilStateDescription desc = new DepthStencilStateDescription() { IsDepthEnabled = depthEnabled, IsStencilEnabled = stencilEnabled, DepthWriteMask = SharpDX.Direct3D11.DepthWriteMask.All, FrontFace = new DepthStencilOperationDescription() { Comparison = frontFaceComparison, DepthFailOperation = frontFaceDepthFailOp, FailOperation = frontFaceFailOp, PassOperation = frontFacePassOp }, BackFace = new DepthStencilOperationDescription() { Comparison = backFaceComparison, DepthFailOperation = backFaceDepthFailOp, FailOperation = backFaceFailOp, PassOperation = backFacePassOp }, DepthComparison = depthComparison }; NativeDepthStencilState = new SharpDX.Direct3D11.DepthStencilState(GraphicManager.Device, desc); }
public static StencilOp ToOpenGL(this StencilOperation operation) { switch (operation) { case StencilOperation.Keep: return(StencilOp.Keep); case StencilOperation.Zero: return(StencilOp.Zero); case StencilOperation.Replace: return(StencilOp.Replace); case StencilOperation.IncrementSaturation: return(StencilOp.Incr); case StencilOperation.DecrementSaturation: return(StencilOp.Decr); case StencilOperation.Invert: return(StencilOp.Invert); case StencilOperation.Increment: return(StencilOp.IncrWrap); case StencilOperation.Decrement: return(StencilOp.DecrWrap); default: throw new ArgumentOutOfRangeException("operation"); } }
public static StencilOp To(StencilOperation operation) { switch (operation) { case StencilOperation.Zero: return(StencilOp.Zero); case StencilOperation.Invert: return(StencilOp.Invert); case StencilOperation.Keep: return(StencilOp.Keep); case StencilOperation.Replace: return(StencilOp.Replace); case StencilOperation.Increment: return(StencilOp.Incr); case StencilOperation.Decrement: return(StencilOp.Decr); case StencilOperation.IncrementWrap: return(StencilOp.IncrWrap); case StencilOperation.DecrementWrap: return(StencilOp.DecrWrap); } throw new ArgumentException("operation"); }
public StencilTestOperationDesc_NativeInterop(ref StencilTestOperationDesc desc) { stencilTestFunction = desc.stencilTestFunction; stencilFailOperation = desc.stencilFailOperation; stencilDepthFailOperation = desc.stencilDepthFailOperation; stencilPassOperation = desc.stencilPassOperation; }
internal static D3D.StencilOperation ToD3DStencilOperation(StencilOperation func) { switch (func) { case StencilOperation.Zero: return(D3D.StencilOperation.Zero); case StencilOperation.Replace: return(D3D.StencilOperation.Replace); case StencilOperation.Keep: return(D3D.StencilOperation.Keep); case StencilOperation.Invert: return(D3D.StencilOperation.Invert); case StencilOperation.IncrementAndClamp: return(D3D.StencilOperation.IncrementAndClamp); case StencilOperation.Increment: return(D3D.StencilOperation.Increment); case StencilOperation.DecrementAndClamp: return(D3D.StencilOperation.DecrementAndClamp); case StencilOperation.Decrement: return(D3D.StencilOperation.Decrement); default: throw new ArgumentException("Invalid stencil function"); } }
/// <summary> /// Initializes a new instance of the <see cref="DepthStencilDescription"/> struct. /// </summary> /// <param name="depthEnable">Specifies whether to enable depth testing. Set this member to <b>true</b> to enable depth testing.</param> /// <param name="depthWriteEnable">Specifies a value that identifies a portion of the depth-stencil buffer that can be modified by depth data.</param> /// <param name="depthFunc">A <see cref="ComparisonFunction"/> value that identifies a function that compares depth data against existing depth data.</param> /// <param name="stencilEnable">Specifies whether to enable stencil testing. Set this member to <b>true</b> to enable stencil testing.</param> /// <param name="stencilReadMask">Identify a portion of the depth-stencil buffer for reading stencil data.</param> /// <param name="stencilWriteMask">Identify a portion of the depth-stencil buffer for writing stencil data.</param> /// <param name="frontStencilFailOp"></param> /// <param name="frontStencilDepthFailOp"></param> /// <param name="frontStencilPassOp"></param> /// <param name="frontStencilFunc"></param> /// <param name="backStencilFailOp"></param> /// <param name="backStencilDepthFailOp"></param> /// <param name="backStencilPassOp"></param> /// <param name="backStencilFunc"></param> public DepthStencilDescription( bool depthEnable, bool depthWriteEnable, ComparisonFunction depthFunc, bool stencilEnable, byte stencilReadMask, byte stencilWriteMask, StencilOperation frontStencilFailOp, StencilOperation frontStencilDepthFailOp, StencilOperation frontStencilPassOp, ComparisonFunction frontStencilFunc, StencilOperation backStencilFailOp, StencilOperation backStencilDepthFailOp, StencilOperation backStencilPassOp, ComparisonFunction backStencilFunc) { DepthEnable = depthEnable; DepthWriteMask = depthWriteEnable ? DepthWriteMask.All : DepthWriteMask.Zero; DepthFunc = depthFunc; StencilEnable = stencilEnable; StencilReadMask = stencilReadMask; StencilWriteMask = stencilWriteMask; FrontFace.StencilFailOp = frontStencilFailOp; FrontFace.StencilDepthFailOp = frontStencilDepthFailOp; FrontFace.StencilPassOp = frontStencilPassOp; FrontFace.StencilFunc = frontStencilFunc; BackFace.StencilFailOp = backStencilFailOp; BackFace.StencilDepthFailOp = backStencilDepthFailOp; BackFace.StencilPassOp = backStencilPassOp; BackFace.StencilFunc = backStencilFunc; }
/// <summary> /// Find the GL int value for the StencilOperation enum. /// </summary> /// <param name="op"></param> /// <returns></returns> public static int ConvertEnum(StencilOperation op, bool invert) { switch (op) { case StencilOperation.Keep: return(Gl.GL_KEEP); case StencilOperation.Zero: return(Gl.GL_ZERO); case StencilOperation.Replace: return(Gl.GL_REPLACE); case StencilOperation.Increment: return(invert ? Gl.GL_DECR : Gl.GL_INCR); case StencilOperation.Decrement: return(invert ? Gl.GL_INCR : Gl.GL_DECR); case StencilOperation.IncrementWrap: return(invert ? Gl.GL_DECR_WRAP_EXT : Gl.GL_INCR_WRAP_EXT); case StencilOperation.DecrementWrap: return(invert ? Gl.GL_INCR_WRAP_EXT : Gl.GL_DECR_WRAP_EXT); case StencilOperation.Invert: return(Gl.GL_INVERT); } // make the compiler happy return(Gl.GL_KEEP); }
public CompositionPass(CompositionTargetPass parent) { this.parent = parent; this.type = CompositorPassType.RenderQuad; this.identifier = 0; this.firstRenderQueue = RenderQueueGroupID.Background; this.lastRenderQueue = RenderQueueGroupID.SkiesLate; this.materialSchemeName = string.Empty; this.clearBuffers = FrameBufferType.Color | FrameBufferType.Depth; this.clearColor = new ColorEx(0f, 0f, 0f, 0f); this.clearDepth = 1.0f; this.clearStencil = 0; this.stencilCheck = false; this.stencilFunc = CompareFunction.AlwaysPass; this.stencilRefValue = 0; this.stencilMask = 0x7FFFFFFF; this.stencilFailOp = StencilOperation.Keep; this.stencilDepthFailOp = StencilOperation.Keep; this.stencilPassOp = StencilOperation.Keep; this.stencilTwoSidedOperation = false; this.quadCornerModified = false; this.quadLeft = -1; this.quadTop = 1; this.quadRight = 1; this.quadBottom = -1; this.quadFarCorners = false; this.quadFarCornersViewSpace = false; }
private static StencilOp GetStencilOp(StencilOperation operation) { switch (operation) { case StencilOperation.Keep: return(StencilOp.Keep); case StencilOperation.Decrement: return(StencilOp.DecrWrap); case StencilOperation.DecrementSaturation: return(StencilOp.Decr); case StencilOperation.IncrementSaturation: return(StencilOp.Incr); case StencilOperation.Increment: return(StencilOp.IncrWrap); case StencilOperation.Invert: return(StencilOp.Invert); case StencilOperation.Replace: return(StencilOp.Replace); case StencilOperation.Zero: return(StencilOp.Zero); default: return(StencilOp.Keep); } }
internal static VkStencilOp VdToVkStencilOp(StencilOperation op) { switch (op) { case StencilOperation.Keep: return(VkStencilOp.Keep); case StencilOperation.Zero: return(VkStencilOp.Zero); case StencilOperation.Replace: return(VkStencilOp.Replace); case StencilOperation.IncrementAndClamp: return(VkStencilOp.IncrementAndClamp); case StencilOperation.DecrementAndClamp: return(VkStencilOp.DecrementAndClamp); case StencilOperation.Invert: return(VkStencilOp.Invert); case StencilOperation.IncrementAndWrap: return(VkStencilOp.IncrementAndWrap); case StencilOperation.DecrementAndWrap: return(VkStencilOp.DecrementAndWrap); default: throw Illegal.Value <StencilOperation>(); } }
static private SharpDX.Direct3D11.StencilOperation GetStencilOp(StencilOperation op) { switch (op) { case StencilOperation.Decrement: return(SharpDX.Direct3D11.StencilOperation.Decrement); case StencilOperation.DecrementSaturation: return(SharpDX.Direct3D11.StencilOperation.DecrementAndClamp); case StencilOperation.Increment: return(SharpDX.Direct3D11.StencilOperation.Increment); case StencilOperation.IncrementSaturation: return(SharpDX.Direct3D11.StencilOperation.IncrementAndClamp); case StencilOperation.Invert: return(SharpDX.Direct3D11.StencilOperation.Invert); case StencilOperation.Keep: return(SharpDX.Direct3D11.StencilOperation.Keep); case StencilOperation.Replace: return(SharpDX.Direct3D11.StencilOperation.Replace); case StencilOperation.Zero: return(SharpDX.Direct3D11.StencilOperation.Zero); default: throw new NotImplementedException("Invalid stencil operation!"); } }
static private SharpDX.Direct3D11.StencilOperation GetStencilOp(StencilOperation op) { switch (op) { case StencilOperation.Decrement: return SharpDX.Direct3D11.StencilOperation.Decrement; case StencilOperation.DecrementSaturation: return SharpDX.Direct3D11.StencilOperation.DecrementAndClamp; case StencilOperation.Increment: return SharpDX.Direct3D11.StencilOperation.Increment; case StencilOperation.IncrementSaturation: return SharpDX.Direct3D11.StencilOperation.IncrementAndClamp; case StencilOperation.Invert: return SharpDX.Direct3D11.StencilOperation.Invert; case StencilOperation.Keep: return SharpDX.Direct3D11.StencilOperation.Keep; case StencilOperation.Replace: return SharpDX.Direct3D11.StencilOperation.Replace; case StencilOperation.Zero: return SharpDX.Direct3D11.StencilOperation.Zero; default: throw new ArgumentException("Invalid stencil operation!"); } }
/// <summary> /// Gets the OpenGL enum value that corresponds to the specified StencilOperation value. /// </summary> /// <param name="op">The StencilOperation value to convert.</param> /// <returns>The converted value.</returns> private static UInt32 GetStencilOpGL(StencilOperation op) { switch (op) { case StencilOperation.Decrement: return(gl.GL_DECR_WRAP); case StencilOperation.DecrementSaturation: return(gl.GL_DECR); case StencilOperation.Increment: return(gl.GL_INCR_WRAP); case StencilOperation.IncrementSaturation: return(gl.GL_INCR); case StencilOperation.Invert: return(gl.GL_INVERT); case StencilOperation.Keep: return(gl.GL_KEEP); case StencilOperation.Replace: return(gl.GL_REPLACE); case StencilOperation.Zero: return(gl.GL_ZERO); } throw new NotSupportedException(); }
internal static SharpDX.Direct3D11.StencilOperation ToD3D11StencilOperation(StencilOperation op) { switch (op) { case StencilOperation.Keep: return(SharpDX.Direct3D11.StencilOperation.Keep); case StencilOperation.Zero: return(SharpDX.Direct3D11.StencilOperation.Zero); case StencilOperation.Replace: return(SharpDX.Direct3D11.StencilOperation.Replace); case StencilOperation.IncrementAndClamp: return(SharpDX.Direct3D11.StencilOperation.IncrementAndClamp); case StencilOperation.DecrementAndClamp: return(SharpDX.Direct3D11.StencilOperation.DecrementAndClamp); case StencilOperation.Invert: return(SharpDX.Direct3D11.StencilOperation.Invert); case StencilOperation.IncrementAndWrap: return(SharpDX.Direct3D11.StencilOperation.Increment); case StencilOperation.DecrementAndWrap: return(SharpDX.Direct3D11.StencilOperation.Decrement); default: throw Illegal.Value <StencilOperation>(); } }
/// <summary> /// Initializes a new instance of the <see cref="DepthStencilDescriptor"/> struct. /// </summary> /// <param name="isDepthWriteEnabled">A bool value that indicates whether depth values can be written to the depth attachment.</param> /// <param name="depthCompareFunction">The <see cref="CompareFunction"/> that is performed between a fragment’s depth value and the depth value in the attachment, which determines whether to discard the fragment.</param> /// <param name="frontFaceStencilFailOperation"></param> /// <param name="frontFaceStencilDepthFailOperation"></param> /// <param name="frontFaceStencilPassOperation"></param> /// <param name="frontFaceStencilCompareFunction"></param> /// <param name="backFaceStencilFailOperation"></param> /// <param name="backFaceStencilDepthFailOperation"></param> /// <param name="backFaceStencilPassOperation"></param> /// <param name="backFaceStencilCompareFunction"></param> /// <param name="stencilReadMask">A bitmask that determines from which bits that stencil comparison tests can read.</param> /// <param name="stencilWriteMask">A bitmask that determines to which bits that stencil operations can write.</param> public DepthStencilDescriptor( bool isDepthWriteEnabled, CompareFunction depthCompareFunction, StencilOperation frontFaceStencilFailOperation, StencilOperation frontFaceStencilDepthFailOperation, StencilOperation frontFaceStencilPassOperation, CompareFunction frontFaceStencilCompareFunction, StencilOperation backFaceStencilFailOperation, StencilOperation backFaceStencilDepthFailOperation, StencilOperation backFaceStencilPassOperation, CompareFunction backFaceStencilCompareFunction, byte stencilReadMask = DefaultStencilReadMask, byte stencilWriteMask = DefaultStencilWriteMask) { IsDepthWriteEnabled = isDepthWriteEnabled; DepthCompareFunction = depthCompareFunction; // Front FrontFaceStencil = new DepthStencilOperationDescriptor( frontFaceStencilFailOperation, frontFaceStencilDepthFailOperation, frontFaceStencilPassOperation, frontFaceStencilCompareFunction); // Back BackFaceStencil = new DepthStencilOperationDescriptor( backFaceStencilFailOperation, backFaceStencilDepthFailOperation, backFaceStencilPassOperation, backFaceStencilCompareFunction); StencilReadMask = stencilReadMask; StencilWriteMask = stencilWriteMask; }
//--------------------------------------------------------------- #endregion //--------------------------------------------------------------- //--------------------------------------------------------------- #region Methods //--------------------------------------------------------------- /// <summary> /// Saves the current state into the current <see cref="IRenderState"/> object. /// </summary> public void Save() { this.Enable = Device.Instance.RenderStates.TwoSidedStencilMode; this.Function = Device.Instance.RenderStates.CounterClockwiseStencilFunction; this.Fail = Device.Instance.RenderStates.CounterClockwiseStencilFail; this.Pass = Device.Instance.RenderStates.CounterClockwiseStencilPass; this.ZBufferFail = Device.Instance.RenderStates.CounterClockwiseStencilZBufferFail; }
/// <summary> /// Creates a new instance of a <see cref="StencilState"/>. /// </summary> /// <param name="device">The device from which to fill this RenderState.</param> public StencilState(Device device) { this.Enable = device.RenderStates.StencilTest; this.Function = device.RenderStates.StencilFunction; this.Fail = device.RenderStates.StencilFail; this.Pass = device.RenderStates.StencilPass; this.ZBufferFail = device.RenderStates.StencilZBufferFail; }
/// <summary> /// Applies the <see cref="StencilState"/> defined by the passed parameters. /// </summary> /// <remarks> /// Use this static method if you don't want to allocate a renderState object. /// </remarks> /// <param name="enable">True to turn on stencil testing.</param> /// <param name="function">Stencil compare function.</param> /// <param name="pass">The operation to perform if the stencil test passes.</param> /// <param name="fail">The operation to perform if the stencil test fails.</param> /// <param name="zBufferFail">The operation to perform if the stencil test passes but the zBuffer Test fails.</param> public static void Apply(bool enable, Compare function, StencilOperation pass, StencilOperation fail, StencilOperation zBufferFail) { Device.Instance.RenderStates.StencilFunction = function; Device.Instance.RenderStates.StencilTest = enable; Device.Instance.RenderStates.StencilFail = fail; Device.Instance.RenderStates.StencilPass = pass; Device.Instance.RenderStates.StencilZBufferFail = zBufferFail; }
public void setStencilPassOp(StencilOperation value) { OgrePINVOKE.CompositionPass_setStencilPassOp(swigCPtr, (int)value); if (OgrePINVOKE.SWIGPendingException.Pending) { throw OgrePINVOKE.SWIGPendingException.Retrieve(); } }
//--------------------------------------------------------------- #endregion //--------------------------------------------------------------- //--------------------------------------------------------------- #region Methods //--------------------------------------------------------------- /// <summary> /// Saves the current state into the current <see cref="IRenderState"/> object. /// </summary> public void Save() { this.Enable = Device.Instance.RenderStates.StencilTest; this.Function = Device.Instance.RenderStates.StencilFunction; this.Fail = Device.Instance.RenderStates.StencilFail; this.Pass = Device.Instance.RenderStates.StencilPass; this.ZBufferFail = Device.Instance.RenderStates.StencilZBufferFail; }
public StencilMode(StencilOperation frontOperation, StencilFunction frontCompare, StencilOperation backOperation, StencilFunction backCompare) { IsEnabled = true; CompareFront = frontCompare; CompareBack = backCompare; OperationFront = frontOperation; OperationBack = backOperation; }
/// <summary> /// Creates a new instance of a <see cref="StencilState"/>. /// </summary> /// <param name="device">The device from which to fill this RenderState.</param> public CCWStencilState(Device device) { this.Enable = device.RenderStates.TwoSidedStencilMode; this.Function = device.RenderStates.CounterClockwiseStencilFunction; this.Fail = device.RenderStates.CounterClockwiseStencilFail; this.Pass = device.RenderStates.CounterClockwiseStencilPass; this.ZBufferFail = device.RenderStates.CounterClockwiseStencilZBufferFail; }
/// <summary> /// Applies the <see cref="StencilState"/> defined by the passed parameters. /// </summary> /// <remarks> /// Use this static method if you don't want to allocate a renderState object. /// </remarks> /// <param name="enable">True to turn on two sided stencil testing.</param> /// <param name="function">Stencil compare function.</param> /// <param name="pass">The operation to perform if the stencil test passes.</param> /// <param name="fail">The operation to perform if the stencil test fails.</param> /// <param name="zBufferFail">The operation to perform if the stencil test passes but the zBuffer Test fails.</param> public static void Apply(bool enable, Compare function, StencilOperation pass, StencilOperation fail, StencilOperation zBufferFail) { Device.Instance.RenderStates.CounterClockwiseStencilFunction = function; Device.Instance.RenderStates.TwoSidedStencilMode = enable; Device.Instance.RenderStates.CounterClockwiseStencilFail = fail; Device.Instance.RenderStates.CounterClockwiseStencilPass = pass; Device.Instance.RenderStates.CounterClockwiseStencilZBufferFail = zBufferFail; }
public StencilMode(StencilOperation operation, StencilFunction compare) { IsEnabled = true; CompareFront = compare; CompareBack = compare; OperationFront = operation; OperationBack = operation; }
//--------------------------------------------------------------- #endregion //--------------------------------------------------------------- //--------------------------------------------------------------- #region Initialisation //--------------------------------------------------------------- /// <summary> /// Creates a new instance of a <see cref="StencilState"/>. /// </summary> /// <param name="enable">True to turn on stencil testing.</param> /// <param name="function">The compare function to use for the stencil test.</param> /// <param name="fail">The stencil operation to perform when the stencil test fails.</param> /// <param name="pass">The stencil operation to perform when the stencil test passes.</param> /// <param name="zBufferFail">The stencil operation to perform when the stencil test passes but the zBuffer test fails.</param> public StencilState(bool enable, Compare function, StencilOperation pass, StencilOperation fail, StencilOperation zBufferFail) { Enable = enable; Function = function; Fail = fail; Pass = pass; ZBufferFail = zBufferFail; }
internal static StencilOp Convert(StencilOperation stencilOperation) { if (!stencilOperations.ContainsKey(stencilOperation)) { throw new NotSupportedException("indexFormat is not supported"); } return(stencilOperations[stencilOperation]); }
public StencilOperation getStencilPassOp() { StencilOperation ret = (StencilOperation)OgrePINVOKE.CompositionPass_getStencilPassOp(swigCPtr); if (OgrePINVOKE.SWIGPendingException.Pending) { throw OgrePINVOKE.SWIGPendingException.Retrieve(); } return(ret); }
/// <summary> /// Initializes a new instance of the <see cref="DepthStencilOperationDescriptor"/> struct. /// </summary> /// <param name="stencilFailOperation">A <see cref="StencilOperation"/> value that identifies the stencil operation to perform when stencil testing fails.</param> /// <param name="stencilDepthFailOperation">A <see cref="StencilOperation"/> value that identifies the stencil operation to perform when stencil testing passes and depth testing fails.</param> /// <param name="stencilPassOperation">A <see cref="StencilOperation"/> value that identifies the stencil operation to perform when stencil testing and depth testing both pass.</param> /// <param name="stencilCompareFunction">A <see cref="CompareFunction"/> value that identifies the function that compares stencil data against existing stencil data.</param> public DepthStencilOperationDescriptor( StencilOperation stencilFailOperation, StencilOperation stencilDepthFailOperation, StencilOperation stencilPassOperation, CompareFunction stencilCompareFunction) { StencilFailOperation = stencilFailOperation; StencilDepthFailOperation = stencilDepthFailOperation; StencilPassOperation = stencilPassOperation; StencilCompareFunction = stencilCompareFunction; }
private DepthStencilState(DepthStencilState cloneSource) { Name = cloneSource.Name; _depthBufferEnable = cloneSource._depthBufferEnable; _depthBufferWriteEnable = cloneSource._depthBufferWriteEnable; _counterClockwiseStencilDepthBufferFail = cloneSource._counterClockwiseStencilDepthBufferFail; _counterClockwiseStencilFail = cloneSource._counterClockwiseStencilFail; _counterClockwiseStencilFunction = cloneSource._counterClockwiseStencilFunction; _counterClockwiseStencilPass = cloneSource._counterClockwiseStencilPass; _depthBufferFunction = cloneSource._depthBufferFunction; _referenceStencil = cloneSource._referenceStencil; _stencilDepthBufferFail = cloneSource._stencilDepthBufferFail; _stencilEnable = cloneSource._stencilEnable; _stencilFail = cloneSource._stencilFail; _stencilFunction = cloneSource._stencilFunction; _stencilMask = cloneSource._stencilMask; _stencilPass = cloneSource._stencilPass; _stencilWriteMask = cloneSource._stencilWriteMask; _twoSidedStencilMode = cloneSource._twoSidedStencilMode; }
public static StencilOp To(StencilOperation operation) { switch (operation) { case StencilOperation.Zero: return StencilOp.Zero; case StencilOperation.Invert: return StencilOp.Invert; case StencilOperation.Keep: return StencilOp.Keep; case StencilOperation.Replace: return StencilOp.Replace; case StencilOperation.Increment: return StencilOp.Incr; case StencilOperation.Decrement: return StencilOp.Decr; case StencilOperation.IncrementWrap: return StencilOp.IncrWrap; case StencilOperation.DecrementWrap: return StencilOp.DecrWrap; } throw new ArgumentException("operation"); }
/// <summary> /// Gets the OpenGL enum value that corresponds to the specified StencilOperation value. /// </summary> /// <param name="op">The StencilOperation value to convert.</param> /// <returns>The converted value.</returns> private static UInt32 GetStencilOpGL(StencilOperation op) { switch (op) { case StencilOperation.Decrement: return gl.GL_DECR_WRAP; case StencilOperation.DecrementSaturation: return gl.GL_DECR; case StencilOperation.Increment: return gl.GL_INCR_WRAP; case StencilOperation.IncrementSaturation: return gl.GL_INCR; case StencilOperation.Invert: return gl.GL_INVERT; case StencilOperation.Keep: return gl.GL_KEEP; case StencilOperation.Replace: return gl.GL_REPLACE; case StencilOperation.Zero: return gl.GL_ZERO; } throw new NotSupportedException(); }
public override void SetStencilBufferParams( CompareFunction func, int refValue, int mask, StencilOperation stencilFailOp, StencilOperation depthFailOp, StencilOperation passOp, bool twoSidedOperation ) { if (twoSidedOperation) { if ( !currentCapabilities.HasCapability( Graphics.Capabilities.TwoSidedStencil ) ) { throw new AxiomException( "2-sided stencils are not supported on this hardware!" ); } // NB: We should always treat CCW as front face for consistent with default // culling mode. Therefore, we must take care with two-sided stencil settings. var flip = ( invertVertexWinding ^ activeRenderTarget.RequiresTextureFlipping ); if ( GLEW_VERSION_2_0 ) // New GL2 commands { // Back Gl.glStencilMaskSeparate( Gl.GL_BACK, mask ); Gl.glStencilFuncSeparate( Gl.GL_BACK, GLHelper.ConvertEnum( func ), refValue, mask ); Gl.glStencilOpSeparate( Gl.GL_BACK, GLHelper.ConvertEnum( stencilFailOp, !flip ), GLHelper.ConvertEnum( depthFailOp, !flip ), GLHelper.ConvertEnum( passOp, !flip ) ); // Front Gl.glStencilMaskSeparate( Gl.GL_FRONT, mask ); Gl.glStencilFuncSeparate( Gl.GL_FRONT, GLHelper.ConvertEnum( func ), refValue, mask ); Gl.glStencilOpSeparate( Gl.GL_FRONT, GLHelper.ConvertEnum( stencilFailOp, flip ), GLHelper.ConvertEnum( depthFailOp, flip ), GLHelper.ConvertEnum( passOp, flip ) ); Gl.glActiveStencilFaceEXT( Gl.GL_FRONT ); } else // EXT_stencil_two_side { Gl.glEnable( Gl.GL_STENCIL_TEST_TWO_SIDE_EXT ); // Back Gl.glActiveStencilFaceEXT( Gl.GL_BACK ); Gl.glStencilMask( mask ); Gl.glStencilFunc( GLHelper.ConvertEnum( func ), refValue, mask ); Gl.glStencilOp( GLHelper.ConvertEnum( stencilFailOp, !flip ), GLHelper.ConvertEnum( depthFailOp, !flip ), GLHelper.ConvertEnum( passOp, !flip ) ); // Front Gl.glActiveStencilFaceEXT( Gl.GL_FRONT ); Gl.glStencilMask( mask ); Gl.glStencilFunc( GLHelper.ConvertEnum( func ), refValue, mask ); Gl.glStencilOp( GLHelper.ConvertEnum( stencilFailOp, flip ), GLHelper.ConvertEnum( depthFailOp, flip ), GLHelper.ConvertEnum( passOp, flip ) ); } } else { Gl.glDisable(Gl.GL_STENCIL_TEST_TWO_SIDE_EXT); var flip = false; Gl.glStencilMask(mask); Gl.glStencilFunc(GLHelper.ConvertEnum(func), refValue, mask); Gl.glStencilOp( GLHelper.ConvertEnum(stencilFailOp, flip), GLHelper.ConvertEnum(depthFailOp, flip), GLHelper.ConvertEnum(passOp, flip)); } }
public static extern void glStencilOp(StencilOperation fail, StencilOperation zfail, StencilOperation zpass);
/// <summary> /// This method allows you to set all the stencil buffer parameters in one call. /// </summary> /// <remarks> /// <para> /// The stencil buffer is used to mask out pixels in the render target, allowing /// you to do effects like mirrors, cut-outs, stencil shadows and more. Each of /// your batches of rendering is likely to ignore the stencil buffer, /// update it with new values, or apply it to mask the output of the render. /// The stencil test is:<PRE> /// (Reference Value & Mask) CompareFunction (Stencil Buffer Value & Mask)</PRE> /// The result of this will cause one of 3 actions depending on whether the test fails, /// succeeds but with the depth buffer check still failing, or succeeds with the /// depth buffer check passing too.</para> /// <para> /// Unlike other render states, stencilling is left for the application to turn /// on and off when it requires. This is because you are likely to want to change /// parameters between batches of arbitrary objects and control the ordering yourself. /// In order to batch things this way, you'll want to use OGRE's separate render queue /// groups (see RenderQueue) and register a RenderQueueListener to get notifications /// between batches.</para> /// <para> /// There are individual state change methods for each of the parameters set using /// this method. /// Note that the default values in this method represent the defaults at system /// start up too.</para> /// </remarks> /// <param name="function">The comparison function applied.</param> /// <param name="refValue">The reference value used in the comparison.</param> /// <param name="mask"> /// The bitmask applied to both the stencil value and the reference value /// before comparison. /// </param> /// <param name="stencilFailOp">The action to perform when the stencil check fails.</param> /// <param name="depthFailOp"> /// The action to perform when the stencil check passes, but the depth buffer check still fails. /// </param> /// <param name="passOp">The action to take when both the stencil and depth check pass.</param> /// <param name="twoSidedOperation"> /// If set to true, then if you render both back and front faces /// (you'll have to turn off culling) then these parameters will apply for front faces, /// and the inverse of them will happen for back faces (keep remains the same). /// </param> public abstract void SetStencilBufferParams(CompareFunction function, int refValue, int mask, StencilOperation stencilFailOp, StencilOperation depthFailOp, StencilOperation passOp, bool twoSidedOperation);
public GLenum ConvertStencilOp( StencilOperation op, bool invert ) { switch ( op ) { case StencilOperation.Keep: return GLenum.Keep; case StencilOperation.Zero: return GLenum.Zero; case StencilOperation.Replace: return GLenum.Replace; case StencilOperation.Increment: return invert ? GLenum.Decr : GLenum.Incr; case StencilOperation.Decrement: return invert ? GLenum.Incr : GLenum.Decr; case StencilOperation.IncrementWrap: return invert ? GLenum.DecrWrap : GLenum.IncrWrap; case StencilOperation.DecrementWrap: return invert ? GLenum.IncrWrap : GLenum.DecrWrap; case StencilOperation.Invert: return GLenum.Invert; default: return GLenum.Invert; // to keep compiler happy } }
public static void StencilOp(StencilOperation sfail, StencilOperation spass) { GDTransport.cmd32((12 << 24) | ((byte)sfail << 3) | (byte)spass); }
public override void SetStencilBufferParams( CompareFunction function, int refValue, int mask, StencilOperation stencilFailOp, StencilOperation depthFailOp, StencilOperation passOp, bool twoSidedOperation ) { bool flip; this.stencilMask = (uint) mask; if ( twoSidedOperation ) { if ( !currentCapabilities.HasCapability( Graphics.Capabilities.TwoSidedStencil ) ) { throw new AxiomException( "2-sided stencils are not supported" ); } // NB: We should always treat CCW as front face for consistent with default // culling mode. Therefore, we must take care with two-sided stencil settings flip = ( invertVertexWinding && !activeRenderTarget.RequiresTextureFlipping ) || ( !invertVertexWinding && activeRenderTarget.RequiresTextureFlipping ); //Back GL.StencilMaskSeparate( GLenum.Back, mask ); GLES2Config.GlCheckError( this ); GL.StencilFuncSeparate( GLenum.Back, this.ConvertCompareFunction( function ), refValue, mask ); GLES2Config.GlCheckError( this ); GL.StencilOpSeparate( GLenum.Back, this.ConvertStencilOp( stencilFailOp, !flip ), this.ConvertStencilOp( depthFailOp, !flip ), this.ConvertStencilOp( passOp, !flip ) ); GLES2Config.GlCheckError( this ); //Front GL.StencilMaskSeparate( GLenum.Front, mask ); GLES2Config.GlCheckError( this ); GL.StencilFuncSeparate( GLenum.Front, this.ConvertCompareFunction( function ), refValue, mask ); GLES2Config.GlCheckError( this ); GL.StencilOpSeparate( GLenum.Front, this.ConvertStencilOp( stencilFailOp, flip ), this.ConvertStencilOp( depthFailOp, flip ), this.ConvertStencilOp( passOp, flip ) ); GLES2Config.GlCheckError( this ); } else { flip = ( faceCount == 0 ) ? false : true; GL.StencilMask( mask ); GLES2Config.GlCheckError( this ); GL.StencilFunc( this.ConvertCompareFunction( function ), refValue, mask ); GLES2Config.GlCheckError( this ); GL.StencilOp( this.ConvertStencilOp( stencilFailOp, flip ), this.ConvertStencilOp( depthFailOp, flip ), this.ConvertStencilOp( passOp, flip ) ); GLES2Config.GlCheckError( this ); } }
public GLenum ConvertStencilOp( StencilOperation op ) { return this.ConvertStencilOp( op, false ); }
private static StencilOp GetStencilOp(StencilOperation operation) { switch (operation) { case StencilOperation.Keep: return StencilOp.Keep; case StencilOperation.Decrement: return StencilOp.DecrWrap; case StencilOperation.DecrementSaturation: return StencilOp.Decr; case StencilOperation.IncrementSaturation: return StencilOp.Incr; case StencilOperation.Increment: return StencilOp.IncrWrap; case StencilOperation.Invert: return StencilOp.Invert; case StencilOperation.Replace: return StencilOp.Replace; case StencilOperation.Zero: return StencilOp.Zero; default: return StencilOp.Keep; } }
public RSStencilOperation( bool stencilCheck, CompareFunction func, int refValue, int mask, StencilOperation stencilFailOp, StencilOperation depthFailOp, StencilOperation passOp, bool twoSidedOperation ) { this.stencilCheck = stencilCheck; this.func = func; this.refValue = refValue; this.mask = mask; this.stencilFailOp = stencilFailOp; this.depthFailOp = depthFailOp; this.passOp = passOp; this.twoSidedOperation = twoSidedOperation; }
public static void StencilOp(StencilOperation fail, StencilOperation zfail, StencilOperation zpass) { Delegates.glStencilOp(fail, zfail, zpass); }
public override void SetStencilBufferParams(CompareFunction function, int refValue, int mask, StencilOperation stencilFailOp, StencilOperation depthFailOp, StencilOperation passOp, bool twoSidedOperation) { if (twoSidedOperation) { if(!caps.CheckCap(Capabilities.TwoSidedStencil)) { throw new AxiomException("2-sided stencils are not supported on this hardware!"); } Gl.glActiveStencilFaceEXT(Gl.GL_FRONT); } Gl.glStencilMask(mask); Gl.glStencilFunc(GLHelper.ConvertEnum(function), refValue, mask); Gl.glStencilOp(GLHelper.ConvertEnum(stencilFailOp), GLHelper.ConvertEnum(depthFailOp), GLHelper.ConvertEnum(passOp)); if (twoSidedOperation) { // set everything again, inverted Gl.glActiveStencilFaceEXT(Gl.GL_BACK); Gl.glStencilMask(mask); Gl.glStencilFunc(GLHelper.ConvertEnum(function), refValue, mask); Gl.glStencilOp( GLHelper.ConvertEnum(stencilFailOp, true), GLHelper.ConvertEnum(depthFailOp, true), GLHelper.ConvertEnum(passOp, true)); // reset Gl.glActiveStencilFaceEXT(Gl.GL_FRONT); Gl.glEnable(Gl.GL_STENCIL_TEST_TWO_SIDE_EXT); } else { Gl.glDisable(Gl.GL_STENCIL_TEST_TWO_SIDE_EXT); } }
public void SetStencilBufferParams(CompareFunction function, int refValue, int mask, StencilOperation stencilFailOp, StencilOperation depthFailOp, StencilOperation passOp) { SetStencilBufferParams(function, refValue, mask, stencilFailOp, depthFailOp, passOp, false); }
public static StencilOp StencilOp(StencilOperation bStencilOperation) { switch (bStencilOperation) { case StencilOperation.Keep: return OpenTK.Graphics.OpenGL.StencilOp.Keep; case StencilOperation.Zero: return OpenTK.Graphics.OpenGL.StencilOp.Zero; case StencilOperation.Replace: return OpenTK.Graphics.OpenGL.StencilOp.Replace; case StencilOperation.IncrementSaturate: return OpenTK.Graphics.OpenGL.StencilOp.Incr; case StencilOperation.DecrementSaturate: return OpenTK.Graphics.OpenGL.StencilOp.Decr; case StencilOperation.Invert: return OpenTK.Graphics.OpenGL.StencilOp.Invert; case StencilOperation.Increment: return OpenTK.Graphics.OpenGL.StencilOp.IncrWrap; case StencilOperation.Decrement: return OpenTK.Graphics.OpenGL.StencilOp.DecrWrap; default: throw new ArgumentOutOfRangeException("bStencilOperation"); } }
public static SharpVulkan.StencilOperation ConvertStencilOperation(StencilOperation operation) { switch (operation) { case StencilOperation.Decrement: return SharpVulkan.StencilOperation.DecrementAndWrap; case StencilOperation.DecrementSaturation: return SharpVulkan.StencilOperation.DecrementAndClamp; case StencilOperation.Increment: return SharpVulkan.StencilOperation.IncrementAndWrap; case StencilOperation.IncrementSaturation: return SharpVulkan.StencilOperation.IncrementAndClamp; case StencilOperation.Invert: return SharpVulkan.StencilOperation.Invert; case StencilOperation.Keep: return SharpVulkan.StencilOperation.Keep; case StencilOperation.Replace: return SharpVulkan.StencilOperation.Replace; default: throw new ArgumentOutOfRangeException(); } }
public static int ConvertEnum(StencilOperation op) { return ConvertEnum(op, false); }
public override void SetStencilBufferParams( CompareFunction function, int refValue, int mask, StencilOperation stencilFailOp, StencilOperation depthFailOp, StencilOperation passOp, bool twoSidedOperation ) { throw new NotImplementedException(); }
public void SetDepthStencilState(DepthStencilState depthStencilState) { if (depthStencilState.DepthBufferEnable != zEnable) { zEnable = depthStencilState.DepthBufferEnable; ToggleGLState(GLenum.GL_DEPTH_TEST, zEnable); } if (zEnable) { if (depthStencilState.DepthBufferWriteEnable != zWriteEnable) { zWriteEnable = depthStencilState.DepthBufferWriteEnable; glDepthMask(zWriteEnable); } if (depthStencilState.DepthBufferFunction != depthFunc) { depthFunc = depthStencilState.DepthBufferFunction; glDepthFunc(XNAToGL.CompareFunc[(int) depthFunc]); } } if (depthStencilState.StencilEnable != stencilEnable) { stencilEnable = depthStencilState.StencilEnable; ToggleGLState(GLenum.GL_STENCIL_TEST, stencilEnable); } if (stencilEnable) { if (depthStencilState.StencilWriteMask != stencilWriteMask) { stencilWriteMask = depthStencilState.StencilWriteMask; glStencilMask(stencilWriteMask); } // TODO: Can we split StencilFunc/StencilOp up nicely? -flibit if ( depthStencilState.TwoSidedStencilMode != separateStencilEnable || depthStencilState.ReferenceStencil != stencilRef || depthStencilState.StencilMask != stencilMask || depthStencilState.StencilFunction != stencilFunc || depthStencilState.CounterClockwiseStencilFunction != ccwStencilFunc || depthStencilState.StencilFail != stencilFail || depthStencilState.StencilDepthBufferFail != stencilZFail || depthStencilState.StencilPass != stencilPass || depthStencilState.CounterClockwiseStencilFail != ccwStencilFail || depthStencilState.CounterClockwiseStencilDepthBufferFail != ccwStencilZFail || depthStencilState.CounterClockwiseStencilPass != ccwStencilPass ) { separateStencilEnable = depthStencilState.TwoSidedStencilMode; stencilRef = depthStencilState.ReferenceStencil; stencilMask = depthStencilState.StencilMask; stencilFunc = depthStencilState.StencilFunction; stencilFail = depthStencilState.StencilFail; stencilZFail = depthStencilState.StencilDepthBufferFail; stencilPass = depthStencilState.StencilPass; if (separateStencilEnable) { ccwStencilFunc = depthStencilState.CounterClockwiseStencilFunction; ccwStencilFail = depthStencilState.CounterClockwiseStencilFail; ccwStencilZFail = depthStencilState.CounterClockwiseStencilDepthBufferFail; ccwStencilPass = depthStencilState.CounterClockwiseStencilPass; glStencilFuncSeparate( GLenum.GL_FRONT, XNAToGL.CompareFunc[(int) stencilFunc], stencilRef, stencilMask ); glStencilFuncSeparate( GLenum.GL_BACK, XNAToGL.CompareFunc[(int) ccwStencilFunc], stencilRef, stencilMask ); glStencilOpSeparate( GLenum.GL_FRONT, XNAToGL.GLStencilOp[(int) stencilFail], XNAToGL.GLStencilOp[(int) stencilZFail], XNAToGL.GLStencilOp[(int) stencilPass] ); glStencilOpSeparate( GLenum.GL_BACK, XNAToGL.GLStencilOp[(int) ccwStencilFail], XNAToGL.GLStencilOp[(int) ccwStencilZFail], XNAToGL.GLStencilOp[(int) ccwStencilPass] ); } else { glStencilFunc( XNAToGL.CompareFunc[(int) stencilFunc], stencilRef, stencilMask ); glStencilOp( XNAToGL.GLStencilOp[(int) stencilFail], XNAToGL.GLStencilOp[(int) stencilZFail], XNAToGL.GLStencilOp[(int) stencilPass] ); } } } }
/// <summary> /// Find the GL int value for the StencilOperation enum. /// </summary> /// <param name="op"></param> /// <returns></returns> public static int ConvertEnum(StencilOperation op, bool invert) { switch(op) { case StencilOperation.Keep: return Gl.GL_KEEP; case StencilOperation.Zero: return Gl.GL_ZERO; case StencilOperation.Replace: return Gl.GL_REPLACE; case StencilOperation.Increment: return invert ? Gl.GL_DECR : Gl.GL_INCR; case StencilOperation.Decrement: return invert ? Gl.GL_INCR : Gl.GL_DECR; case StencilOperation.IncrementWrap: return invert ? Gl.GL_DECR_WRAP_EXT : Gl.GL_INCR_WRAP_EXT; case StencilOperation.DecrementWrap: return invert ? Gl.GL_INCR_WRAP_EXT : Gl.GL_DECR_WRAP_EXT; case StencilOperation.Invert: return Gl.GL_INVERT; } // make the compiler happy return Gl.GL_KEEP; }
public CompositionPass(CompositionTargetPass parent) { this.parent = parent; type = CompositorPassType.RenderQuad; identifier = 0; firstRenderQueue = RenderQueueGroupID.SkiesEarly; lastRenderQueue = RenderQueueGroupID.SkiesLate; clearBuffers = FrameBuffer.Color | FrameBuffer.Depth; clearColor = new ColorEx(0f, 0f, 0f, 0f); clearDepth = 1.0f; clearStencil = 0; stencilCheck = false; stencilFunc = CompareFunction.AlwaysPass; stencilRefValue = 0; stencilMask = (int)0x7FFFFFFF; stencilFailOp = StencilOperation.Keep; stencilDepthFailOp = StencilOperation.Keep; stencilPassOp = StencilOperation.Keep; stencilTwoSidedOperation = false; }
private All ConvertStencilOP( StencilOperation op, bool invert ) { switch ( op ) { case StencilOperation.Keep: return All.Keep; case StencilOperation.Zero: return All.Zero; case StencilOperation.Replace: return All.Replace; case StencilOperation.IncrementWrap: case StencilOperation.Increment: return invert == true ? All.Decr : All.Incr; case StencilOperation.DecrementWrap: case StencilOperation.Decrement: return invert == true ? All.Incr : All.Decr; case StencilOperation.Invert: return All.Invert; default: // to keep compiler happy return All.Keep; } }
public CompositionPass( CompositionTargetPass parent ) { this.parent = parent; type = CompositorPassType.RenderQuad; identifier = 0; firstRenderQueue = RenderQueueGroupID.Background; lastRenderQueue = RenderQueueGroupID.SkiesLate; materialSchemeName = string.Empty; clearBuffers = FrameBufferType.Color | FrameBufferType.Depth; clearColor = new ColorEx( 0f, 0f, 0f, 0f ); clearDepth = 1.0f; clearStencil = 0; stencilCheck = false; stencilFunc = CompareFunction.AlwaysPass; stencilRefValue = 0; stencilMask = 0x7FFFFFFF; stencilFailOp = StencilOperation.Keep; stencilDepthFailOp = StencilOperation.Keep; stencilPassOp = StencilOperation.Keep; stencilTwoSidedOperation = false; quadCornerModified = false; quadLeft = -1; quadTop = 1; quadRight = 1; quadBottom = -1; quadFarCorners = false; quadFarCornersViewSpace = false; }
void GetFaceForDepthStencil(XmlNode node, out Comparison comparison, out StencilOperation failDepthOp, out StencilOperation failOp, out StencilOperation passOp) { Comparison cmp = Comparison.LessEqual; StencilOperation faildepth = StencilOperation.Keep; StencilOperation fail = StencilOperation.Keep; StencilOperation pass = StencilOperation.Replace; foreach (XmlNode parameter in node.ChildNodes) { switch (parameter.Name.ToLower()) { case "comparison": cmp = GetComparison(parameter.InnerText); break; case "depthfailop": faildepth = GetStencilOperation(parameter.InnerText); break; case "failop": fail = GetStencilOperation(parameter.InnerText); break; case "passop": pass = GetStencilOperation(parameter.InnerText); break; default: throw new Exception("Unknow parameter for face operation on depthstencil"); } } comparison = cmp; failDepthOp = faildepth; failOp = fail; passOp = pass; }