static private SharpDX.Direct3D11.Comparison GetComparison( CompareFunction compare) { switch (compare) { case CompareFunction.Always: return SharpDX.Direct3D11.Comparison.Always; case CompareFunction.Equal: return SharpDX.Direct3D11.Comparison.Equal; case CompareFunction.Greater: return SharpDX.Direct3D11.Comparison.Greater; case CompareFunction.GreaterEqual: return SharpDX.Direct3D11.Comparison.GreaterEqual; case CompareFunction.Less: return SharpDX.Direct3D11.Comparison.Less; case CompareFunction.LessEqual: return SharpDX.Direct3D11.Comparison.LessEqual; case CompareFunction.Never: return SharpDX.Direct3D11.Comparison.Never; case CompareFunction.NotEqual: return SharpDX.Direct3D11.Comparison.NotEqual; default: throw new ArgumentException("Invalid comparison!"); } }
public static void PrepareStencilReadWrite(this GraphicsDevice _, CompareFunction comparison, StencilMask reference) { GraphicsDeviceExtensions.dssCombiner.StencilEnable = true; GraphicsDeviceExtensions.dssCombiner.StencilPass = StencilOperation.Replace; GraphicsDeviceExtensions.dssCombiner.StencilFunction = comparison; GraphicsDeviceExtensions.dssCombiner.ReferenceStencil = (int) reference; }
/// <summary> /// Sets default values for this instance. /// </summary> public DepthStencilStateDescription SetDefault() { DepthBufferEnable = true; DepthBufferWriteEnable = true; DepthBufferFunction = CompareFunction.LessEqual; StencilEnable = false; FrontFace.StencilFunction = CompareFunction.Always; FrontFace.StencilPass = StencilOperation.Keep; FrontFace.StencilFail = StencilOperation.Keep; FrontFace.StencilDepthBufferFail = StencilOperation.Keep; BackFace.StencilFunction = CompareFunction.Always; BackFace.StencilPass = StencilOperation.Keep; BackFace.StencilFail = StencilOperation.Keep; BackFace.StencilDepthBufferFail = StencilOperation.Keep; StencilMask = byte.MaxValue; StencilWriteMask = byte.MaxValue; return this; }
public override void SetAlphaRejectSettings( CompareFunction func, byte value, bool alphaToCoverage) { var a2C = false; if ( func != CompareFunction.AlwaysPass ) { SetRenderState( RenderState.AlphaTestEnable, true ); a2C = alphaToCoverage; } else { SetRenderState( RenderState.AlphaTestEnable, false ); } // Set always just be sure SetRenderState(RenderState.AlphaFunc, (int)D3DHelper.ConvertEnum(func)); SetRenderState(RenderState.AlphaRef, value); // Alpha to coverage if ( !Capabilities.HasCapability( Graphics.Capabilities.AlphaToCoverage ) ) return; // Vendor-specific hacks on renderstate, gotta love 'em switch ( Capabilities.Vendor ) { case GPUVendor.Nvidia: if ( a2C ) { SetRenderState( RenderState.AdaptiveTessY, ( 'A' | ( 'T' ) << 8 | ( 'O' ) << 16 | ( 'C' ) << 24 ) ); } else { SetRenderState( RenderState.AdaptiveTessY, (int)Format.Unknown ); } break; case GPUVendor.Ati: if ( a2C ) { SetRenderState( RenderState.AdaptiveTessY, ( 'A' | ( '2' ) << 8 | ( 'M' ) << 16 | ( '1' ) << 24 ) ); } else { // discovered this through trial and error, seems to work SetRenderState( RenderState.AdaptiveTessY, ( 'A' | ( '2' ) << 8 | ( 'M' ) << 16 | ( '0' ) << 24 ) ); } break; } // no hacks available for any other vendors? //lasta2c = a2c; }
public GLenum ConvertCompareFunction( CompareFunction func ) { switch ( func ) { case CompareFunction.AlwaysFail: return GLenum.Never; case CompareFunction.AlwaysPass: return GLenum.Always; case CompareFunction.Less: return GLenum.Less; case CompareFunction.LessEqual: return GLenum.Lequal; case CompareFunction.Equal: return GLenum.Equal; case CompareFunction.NotEqual: return GLenum.Notequal; case CompareFunction.GreaterEqual: return GLenum.Gequal; case CompareFunction.Greater: return GLenum.Greater; default: return GLenum.Always; //To keep compiler happy } }
public override void SetDepthBufferParams( bool depthTest, bool depthWrite, CompareFunction depthFunction ) { DepthBufferCheckEnabled = depthTest; DepthBufferWriteEnabled = depthWrite; DepthBufferFunction = depthFunction; }
/// <summary> /// Sets the way the pass will have use alpha to totally reject pixels from the pipeline. /// </summary> /// <remarks> /// The default is <see ref="CompareFunction.AlwaysPass" /> i.e. alpha is not used to reject pixels. /// <para>This option applies in both the fixed function and the programmable pipeline.</para></remarks> /// <param name="alphaRejectFunction">The comparison which must pass for the pixel to be written.</param> /// <param name="value">value against which alpha values will be tested [(0-255]</param> public void SetAlphaRejectSettings( CompareFunction alphaRejectFunction, int value ) { _alphaRejectFunction = alphaRejectFunction; _alphaRejectValue = value; }
int INativeLibraryFacade.mdb_set_compare(IntPtr txn, uint dbi, CompareFunction cmp) { return Native64BitLibraryFacade.mdb_set_compare(txn, dbi, cmp); }
public abstract void SemiDotHLine(CompareFunction cmp, int xc1, int yc1, int xc2, int yc2, int x1, int y1, int x2);
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] ); } } } }
private static int DrawOutlineables(OutlineParameters parameters, CompareFunction function, bool edgeShiftOnly, float shift, Func <Outlinable, bool> shouldRender, Func <Outlinable, Color> colorProvider, Material material, RenderStyle styleMask, OutlinableDrawingMode modeMask = OutlinableDrawingMode.Normal) { var drawnCount = 0; parameters.Buffer.SetGlobalInt(ZTestHash, (int)function); foreach (var outlinable in parameters.OutlinablesToRender) { if ((int)(outlinable.RenderStyle & styleMask) == 0) { continue; } if ((int)(outlinable.DrawingMode & modeMask) == 0) { continue; } var color = shouldRender(outlinable) ? colorProvider(outlinable) : Color.clear; parameters.Buffer.SetGlobalColor(ColorHash, color); foreach (var target in outlinable.OutlineTargets) { var postProcessing = !target.CanUseEdgeDilateShift || target.DilateRenderingMode == DilateRenderMode.PostProcessing; if (edgeShiftOnly && postProcessing) { continue; } var renderer = target.Renderer; if (renderer == null || !renderer.gameObject.activeInHierarchy || !renderer.enabled) { continue; } if (!postProcessing) { var dilateShift = 0.0f; switch (function) { case CompareFunction.Always: dilateShift = target.EdgeDilateAmount; break; case CompareFunction.NotEqual: dilateShift = target.BackEdgeDilateAmount; break; case CompareFunction.LessEqual: dilateShift = target.FrontEdgeDilateAmount; break; } parameters.Buffer.SetGlobalFloat(DilateShiftHash, shift < 0.0f ? dilateShift : shift); } parameters.Buffer.SetGlobalInt(ColorMaskHash, postProcessing ? 255 : 0); SetupCutout(parameters, target); SetupCull(parameters, target); if (postProcessing || edgeShiftOnly) { drawnCount++; } parameters.Buffer.DrawRenderer(renderer, material, target.ShiftedSubmeshIndex); } } return(drawnCount); }
internal static void ApplyWireMaterial() { CompareFunction zTest = CompareFunction.Always; ApplyWireMaterial(zTest); }
public static Material Add(Material baseMat, int stencilID, StencilOp operation, CompareFunction compareFunction, ColorWriteMask colorWriteMask, int readMask, int writeMask) { if (((stencilID <= 0) && (colorWriteMask == ColorWriteMask.All)) || (baseMat == null)) { return(baseMat); } if (!baseMat.HasProperty("_Stencil")) { Debug.LogWarning("Material " + baseMat.name + " doesn't have _Stencil property", baseMat); return(baseMat); } if (!baseMat.HasProperty("_StencilOp")) { Debug.LogWarning("Material " + baseMat.name + " doesn't have _StencilOp property", baseMat); return(baseMat); } if (!baseMat.HasProperty("_StencilComp")) { Debug.LogWarning("Material " + baseMat.name + " doesn't have _StencilComp property", baseMat); return(baseMat); } if (!baseMat.HasProperty("_StencilReadMask")) { Debug.LogWarning("Material " + baseMat.name + " doesn't have _StencilReadMask property", baseMat); return(baseMat); } if (!baseMat.HasProperty("_StencilReadMask")) { Debug.LogWarning("Material " + baseMat.name + " doesn't have _StencilWriteMask property", baseMat); return(baseMat); } if (!baseMat.HasProperty("_ColorMask")) { Debug.LogWarning("Material " + baseMat.name + " doesn't have _ColorMask property", baseMat); return(baseMat); } for (int i = 0; i < m_List.Count; i++) { MatEntry entry = m_List[i]; if ((((entry.baseMat == baseMat) && (entry.stencilId == stencilID)) && ((entry.operation == operation) && (entry.compareFunction == compareFunction))) && (((entry.readMask == readMask) && (entry.writeMask == writeMask)) && (entry.colorMask == colorWriteMask))) { entry.count++; return(entry.customMat); } } MatEntry item = new MatEntry { count = 1, baseMat = baseMat, customMat = new Material(baseMat) }; item.customMat.hideFlags = HideFlags.HideAndDontSave; item.stencilId = stencilID; item.operation = operation; item.compareFunction = compareFunction; item.readMask = readMask; item.writeMask = writeMask; item.colorMask = colorWriteMask; item.useAlphaClip = (operation != StencilOp.Keep) && (writeMask > 0); object[] args = new object[] { stencilID, operation, compareFunction, writeMask, readMask, colorWriteMask, item.useAlphaClip, baseMat.name }; item.customMat.name = string.Format("Stencil Id:{0}, Op:{1}, Comp:{2}, WriteMask:{3}, ReadMask:{4}, ColorMask:{5} AlphaClip:{6} ({7})", args); item.customMat.SetInt("_Stencil", stencilID); item.customMat.SetInt("_StencilOp", (int)operation); item.customMat.SetInt("_StencilComp", (int)compareFunction); item.customMat.SetInt("_StencilReadMask", readMask); item.customMat.SetInt("_StencilWriteMask", writeMask); item.customMat.SetInt("_ColorMask", (int)colorWriteMask); item.customMat.SetInt("_UseAlphaClip", !item.useAlphaClip ? 0 : 1); m_List.Add(item); return(item.customMat); }
public static void AddBlendingStatesShaderProperties( PropertyCollector collector, SurfaceType surface, BlendMode blend, int sortingPriority, bool alphaToMask, bool transparentZWrite, TransparentCullMode transparentCullMode, OpaqueCullMode opaqueCullMode, CompareFunction zTest, bool backThenFrontRendering, bool fogOnTransparent) { collector.AddFloatProperty("_SurfaceType", (int)surface); collector.AddFloatProperty("_BlendMode", (int)blend, HLSLDeclaration.UnityPerMaterial); // All these properties values will be patched with the material keyword update collector.AddFloatProperty("_SrcBlend", 1.0f); collector.AddFloatProperty("_DstBlend", 0.0f); collector.AddFloatProperty("_AlphaSrcBlend", 1.0f); collector.AddFloatProperty("_AlphaDstBlend", 0.0f); collector.AddToggleProperty("_AlphaToMask", alphaToMask); collector.AddToggleProperty("_AlphaToMaskInspectorValue", alphaToMask); collector.AddToggleProperty(kZWrite, (surface == SurfaceType.Transparent) ? transparentZWrite : true); collector.AddToggleProperty(kTransparentZWrite, transparentZWrite); collector.AddFloatProperty("_CullMode", (int)CullMode.Back); collector.AddIntProperty(kTransparentSortPriority, sortingPriority); collector.AddToggleProperty(kEnableFogOnTransparent, fogOnTransparent); collector.AddFloatProperty("_CullModeForward", (int)CullMode.Back); collector.AddShaderProperty(new Vector1ShaderProperty { overrideReferenceName = kTransparentCullMode, floatType = FloatType.Enum, value = (int)transparentCullMode, enumNames = { "Front", "Back" }, enumValues = { (int)TransparentCullMode.Front, (int)TransparentCullMode.Back }, hidden = true, overrideHLSLDeclaration = true, hlslDeclarationOverride = HLSLDeclaration.DoNotDeclare, }); collector.AddShaderProperty(new Vector1ShaderProperty { overrideReferenceName = kOpaqueCullMode, floatType = FloatType.Enum, value = (int)opaqueCullMode, enumType = EnumType.CSharpEnum, cSharpEnumType = typeof(OpaqueCullMode), hidden = true, overrideHLSLDeclaration = true, hlslDeclarationOverride = HLSLDeclaration.DoNotDeclare, }); // Add ZTest properties: collector.AddIntProperty("_ZTestDepthEqualForOpaque", (int)CompareFunction.LessEqual); collector.AddShaderProperty(new Vector1ShaderProperty { overrideReferenceName = kZTestTransparent, floatType = FloatType.Enum, value = (int)zTest, enumType = EnumType.CSharpEnum, cSharpEnumType = typeof(CompareFunction), hidden = true, overrideHLSLDeclaration = true, hlslDeclarationOverride = HLSLDeclaration.DoNotDeclare, }); collector.AddToggleProperty(kTransparentBackfaceEnable, backThenFrontRendering); }
static void Render(Dictionary <ProBuilderMesh, MeshHandle> handles, Material material, Color color, CompareFunction func, bool zWrite) { material.SetInt("_HandleZTest", (int)func); material.SetInt("_HandleZWrite", zWrite ? 1 : 0); material.SetColor("_Color", color); if (material.SetPass(0)) { foreach (var kvp in handles) { kvp.Value.DrawMeshNow(0); } } }
public MetricFunction(CompareFunction labelPredictionFunction) { LabelPredictionFunction = labelPredictionFunction; }
public override void OnInspectorGUI() { serializedObject.Update(); EditorGUILayout.Space(); EditorGUILayout.LabelField(Styles.FilteringLabel, EditorStyles.boldLabel); EditorGUI.indentLevel++; EditorGUILayout.PropertyField(m_OpaqueLayerMask, Styles.OpaqueMask); EditorGUILayout.PropertyField(m_TransparentLayerMask, Styles.TransparentMask); EditorGUI.indentLevel--; EditorGUILayout.Space(); EditorGUILayout.LabelField(Styles.RenderingLabel, EditorStyles.boldLabel); EditorGUI.indentLevel++; EditorGUILayout.PropertyField(m_RenderingMode, Styles.RenderingModeLabel); if (m_RenderingMode.intValue == (int)RenderingMode.Deferred) { EditorGUI.indentLevel++; EditorGUILayout.PropertyField(m_AccurateGbufferNormals, Styles.accurateGbufferNormalsLabel, true); //EditorGUILayout.PropertyField(m_TiledDeferredShading, Styles.tiledDeferredShadingLabel, true); EditorGUI.indentLevel--; } if (m_RenderingMode.intValue == (int)RenderingMode.Forward) { EditorGUI.indentLevel++; if (s_EnableClusteredUI) { EditorGUILayout.PropertyField(m_ClusteredRendering, Styles.clusteredRenderingLabel); EditorGUI.BeginDisabledGroup(!m_ClusteredRendering.boolValue); EditorGUILayout.PropertyField(m_TileSize); EditorGUI.EndDisabledGroup(); } EditorGUILayout.PropertyField(m_DepthPrimingMode, Styles.DepthPrimingModeLabel); if (m_DepthPrimingMode.intValue != (int)DepthPrimingMode.Disabled) { EditorGUILayout.HelpBox(Styles.DepthPrimingModeInfo.text, MessageType.Info); } EditorGUI.indentLevel--; } EditorGUI.indentLevel--; EditorGUILayout.Space(); EditorGUILayout.LabelField("RenderPass", EditorStyles.boldLabel); EditorGUI.indentLevel++; EditorGUILayout.PropertyField(m_UseNativeRenderPass, Styles.RenderPassLabel); EditorGUI.indentLevel--; EditorGUILayout.Space(); EditorGUILayout.LabelField("Shadows", EditorStyles.boldLabel); EditorGUI.indentLevel++; EditorGUILayout.PropertyField(m_ShadowTransparentReceiveProp, Styles.shadowTransparentReceiveLabel); EditorGUI.indentLevel--; EditorGUILayout.Space(); EditorGUILayout.LabelField("Post-processing", EditorStyles.boldLabel); EditorGUI.indentLevel++; EditorGUI.BeginChangeCheck(); var postProcessIncluded = EditorGUILayout.Toggle(Styles.PostProcessIncluded, m_PostProcessData.objectReferenceValue != null); if (EditorGUI.EndChangeCheck()) { m_PostProcessData.objectReferenceValue = postProcessIncluded ? PostProcessData.GetDefaultPostProcessData() : null; } if (postProcessIncluded) { EditorGUILayout.PropertyField(m_PostProcessData, Styles.PostProcessLabel); } //m_PostProcessData.objectReferenceValue = PostProcessData.GetDefaultPostProcessData(); EditorGUI.indentLevel--; EditorGUILayout.Space(); EditorGUILayout.LabelField("Overrides", EditorStyles.boldLabel); EditorGUI.indentLevel++; EditorGUILayout.PropertyField(m_DefaultStencilState, Styles.defaultStencilStateLabel, true); SerializedProperty overrideStencil = m_DefaultStencilState.FindPropertyRelative("overrideStencilState"); if (overrideStencil.boolValue && m_RenderingMode.intValue == (int)RenderingMode.Deferred) { CompareFunction stencilFunction = (CompareFunction)m_DefaultStencilState.FindPropertyRelative("stencilCompareFunction").enumValueIndex; StencilOp stencilPass = (StencilOp)m_DefaultStencilState.FindPropertyRelative("passOperation").enumValueIndex; StencilOp stencilFail = (StencilOp)m_DefaultStencilState.FindPropertyRelative("failOperation").enumValueIndex; StencilOp stencilZFail = (StencilOp)m_DefaultStencilState.FindPropertyRelative("zFailOperation").enumValueIndex; bool invalidFunction = stencilFunction == CompareFunction.Disabled || stencilFunction == CompareFunction.Never; bool invalidOp = stencilPass != StencilOp.Replace && stencilFail != StencilOp.Replace && stencilZFail != StencilOp.Replace; if (invalidFunction || invalidOp) { EditorGUILayout.HelpBox(Styles.invalidStencilOverride.text, MessageType.Error, true); } } EditorGUI.indentLevel--; EditorGUILayout.Space(); serializedObject.ApplyModifiedProperties(); base.OnInspectorGUI(); // Draw the base UI, contains ScriptableRenderFeatures list // Add a "Reload All" button in inspector when we are in developer's mode if (EditorPrefs.GetBool("DeveloperMode")) { EditorGUILayout.Space(); EditorGUILayout.PropertyField(m_Shaders, true); if (GUILayout.Button("Reload All")) { var resources = target as UniversalRendererData; resources.shaders = null; ResourceReloader.ReloadAllNullIn(target, UniversalRenderPipelineAsset.packagePath); } } }
public static Material Add(Material baseMat, int stencilID, StencilOp operation, CompareFunction compareFunction, ColorWriteMask colorWriteMask) { return StencilMaterial.Add(baseMat, stencilID, operation, compareFunction, colorWriteMask, (int) byte.MaxValue, (int) byte.MaxValue); }
public BinaryHeap(CompareFunction compare) : this() { _compare = compare; }
public GL10() { int num; this.color = new float[4]; this.clearColor = Color.Black; this.ColorWriteChannels = ColorWriteChannels.All; this.AlphaDestinationBlend = Blend.InverseSourceAlpha; this.depthFunc = CompareFunction.Always; this.textureFilter = TextureFilter.Linear; this.textureAddressU = TextureAddressMode.Clamp; this.textureAddressV = TextureAddressMode.Clamp; this.vertex = new Vertex[8]; this.texture = new Texture[0x100]; this.matrixStack = new Stack<Matrix>(); this.effect = new BasicEffect(GLEx.device); this.effect.VertexColorEnabled = true; this.alphaTestEffect = new AlphaTestEffect(GLEx.device); this.alphaTestEffect.VertexColorEnabled = true; for (num = 0; num < this.vertex.Length; num++) { this.vertex[num] = new Vertex(); } for (num = 0; num < 4; num++) { this.color[num] = 1f; } }
public static Material Add(Material baseMat, int stencilID, StencilOp operation, CompareFunction compareFunction, ColorWriteMask colorWriteMask) => Add(baseMat, stencilID, operation, compareFunction, colorWriteMask, 0xff, 0xff);
public GL() { int num; camera = new GLExCamera(); camera.viewMatrix = camera.Result; this.rstateScissor = new RasterizerState(); this.rstateScissor.CullMode = CullMode.None; this.rstateScissor.ScissorTestEnable = true; this.color = new float[4]; this.clearColor = Color.Black; this.ColorWriteChannels = Microsoft.Xna.Framework.Graphics.ColorWriteChannels.All; this.AlphaDestinationBlend = Blend.InverseSourceAlpha; this.depthFunc = CompareFunction.Always; this.vertex = new Vertex[8]; sTextures.Add(null); this.matrixStack = new Stack<Matrix>(); this.matrixStack.Push(Matrix.Identity); this.effect = new BasicEffect(device); this.effect.VertexColorEnabled = true; this.effect.Projection = Microsoft.Xna.Framework.Matrix.CreateOrthographicOffCenter(0f, LSystem.screenRect.width, LSystem.screenRect.height, 0f, -1.0f, 1.0f); this.alphaTestEffect = new AlphaTestEffect(device); this.alphaTestEffect.VertexColorEnabled = true; device.RasterizerState = RasterizerState.CullNone; device.DepthStencilState = DepthStencilState.None; for (num = 0; num < this.vertex.Length; num++) { this.vertex[num] = new Vertex(); } for (num = 0; num < 4; num++) { this.color[num] = 1f; } EnableTextures(); }
public static Material Add(Material baseMat, int stencilID, StencilOp operation, CompareFunction compareFunction, ColorWriteMask colorWriteMask, int readMask, int writeMask) { if (((stencilID <= 0) && (colorWriteMask == ColorWriteMask.All)) || (baseMat == null)) { return(baseMat); } if (!baseMat.HasProperty("_Stencil")) { Debug.LogWarning("Material " + baseMat.name + " doesn't have _Stencil property", baseMat); return(baseMat); } if (!baseMat.HasProperty("_StencilOp")) { Debug.LogWarning("Material " + baseMat.name + " doesn't have _StencilOp property", baseMat); return(baseMat); } if (!baseMat.HasProperty("_StencilComp")) { Debug.LogWarning("Material " + baseMat.name + " doesn't have _StencilComp property", baseMat); return(baseMat); } if (!baseMat.HasProperty("_StencilReadMask")) { Debug.LogWarning("Material " + baseMat.name + " doesn't have _StencilReadMask property", baseMat); return(baseMat); } if (!baseMat.HasProperty("_StencilReadMask")) { Debug.LogWarning("Material " + baseMat.name + " doesn't have _StencilWriteMask property", baseMat); return(baseMat); } if (!baseMat.HasProperty("_ColorMask")) { Debug.LogWarning("Material " + baseMat.name + " doesn't have _ColorMask property", baseMat); return(baseMat); } for (int i = 0; i < m_List.Count; i++) { MatEntry entry = m_List[i]; if ((((entry.baseMat == baseMat) && (entry.stencilId == stencilID)) && ((entry.operation == operation) && (entry.compareFunction == compareFunction))) && (((entry.readMask == readMask) && (entry.writeMask == writeMask)) && (entry.colorMask == colorWriteMask))) { entry.count++; return(entry.customMat); } } MatEntry item = new MatEntry { count = 1, baseMat = baseMat, customMat = new Material(baseMat) }; item.customMat.hideFlags = HideFlags.HideAndDontSave; item.stencilId = stencilID; item.operation = operation; item.compareFunction = compareFunction; item.readMask = readMask; item.writeMask = writeMask; item.colorMask = colorWriteMask; item.useAlphaClip = (operation != StencilOp.Keep) && (writeMask > 0); item.customMat.name = $"Stencil Id:{stencilID}, Op:{operation}, Comp:{compareFunction}, WriteMask:{writeMask}, ReadMask:{readMask}, ColorMask:{colorWriteMask} AlphaClip:{item.useAlphaClip} ({baseMat.name})"; item.customMat.SetInt("_Stencil", stencilID); item.customMat.SetInt("_StencilOp", (int)operation); item.customMat.SetInt("_StencilComp", (int)compareFunction); item.customMat.SetInt("_StencilReadMask", readMask); item.customMat.SetInt("_StencilWriteMask", writeMask); item.customMat.SetInt("_ColorMask", (int)colorWriteMask); if (item.customMat.HasProperty("_UseAlphaClip")) { item.customMat.SetInt("_UseAlphaClip", !item.useAlphaClip ? 0 : 1); } if (item.useAlphaClip) { item.customMat.EnableKeyword("UNITY_UI_ALPHACLIP"); } else { item.customMat.DisableKeyword("UNITY_UI_ALPHACLIP"); } m_List.Add(item); return(item.customMat); }
/// <summary> /// Creates a new AlphaTestEffect by cloning parameter settings from an existing instance. /// </summary> protected AlphaTestEffect(AlphaTestEffect cloneSource) : base(cloneSource) { CacheEffectParameters(); fogEnabled = cloneSource.fogEnabled; vertexColorEnabled = cloneSource.vertexColorEnabled; world = cloneSource.world; view = cloneSource.view; projection = cloneSource.projection; diffuseColor = cloneSource.diffuseColor; alpha = cloneSource.alpha; fogStart = cloneSource.fogStart; fogEnd = cloneSource.fogEnd; alphaFunction = cloneSource.alphaFunction; referenceAlpha = cloneSource.referenceAlpha; }
public static int mdb_set_dupsort(IntPtr txn, uint dbi, CompareFunction cmp) { return(check(LmdbMethods.mdb_set_dupsort(txn, dbi, cmp))); }
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; }
protected override void doUpdateSprite(Transform t, CompareFunction comp, int stencil) { #if SPRITE_MASK_DEBUG log("doUpdateSprite >>> t=" + t.name + " comp=" + comp + " stencil=" + stencil + " t.childsCount=" + t.childCount); #endif if (hasSkipMasking(t)) { return; } if (hasMaskingPart(t)) { // 't' will take a part in masking Renderer r = getRenderer(t); if (r != null) { r.sharedMaterial = maskMaterial; } } else { SpriteMaskingComponent masking = getMaskingComponent(t); bool updateRenderer = true; if (masking != null) { if (masking == this) { updateRenderer = false; } else if (masking.owner == this) { updateRenderer = true; } else if (masking is SpriteMask) { updateRenderer = false; if (masking.isEnabled) { #if UNITY_EDITOR if (Application.isPlaying) // Don't update in edit mode. Update() will be called on child masks. #endif ((SpriteMask)masking).update(); return; } } else if (masking.isEnabled) { return; } } if (updateRenderer) { Renderer r = getRenderer(t); #if SPRITE_MASK_DEBUG log("doUpdateSprite: renderer=" + r); #endif if (r != null) { Material[] ms = r.sharedMaterials; if (ms.Length > 1) { // More than one material for (int i = 0; i < ms.Length; i++) { // if (ms [i] == null || !hasStencilSupport (ms [i]) || forceDefaultMaterialOnChilds) { if (ms [i] != null && hasStencilSupport(ms [i])) { if (forceIndividualMaterialOnChilds) { if (ms [i].GetInstanceID() > 0) { ms [i] = getIndividualMaterial(ms [i]); } } ms [i].renderQueue = spriteRenderQueue; updateMaterial(ms [i], stencil, comp, null); } } } else { // Has zero or one matrial Material m; if (ms.Length == 0) { // No material on renderer m = defaultSpriteMaterial; r.sharedMaterial = m; } else { m = ms [0]; if (m == null || !hasStencilSupport(m) || forceDefaultMaterialOnChilds) { m = defaultSpriteMaterial; r.sharedMaterial = m; } else { if (forceIndividualMaterialOnChilds) { if (m.GetInstanceID() > 0) { m = getIndividualMaterial(m); r.sharedMaterial = m; } } } } m.renderQueue = spriteRenderQueue; updateMaterial(m, stencil, comp, null); } } } int childsCount = t.childCount; if (childsCount > 0) { for (int i = 0; i < childsCount; i++) { doUpdateSprite(t.GetChild(i), comp, stencil); } } } #if SPRITE_MASK_DEBUG log("doUpdateSprite <<<"); #endif }
public override void SemiDotHLine(CompareFunction cmp, int xc1, int yc1, int xc2, int yc2, int x1, int y1, int x2) { }
public void SetDetphState(bool writeEnabled, CompareFunction function = CompareFunction.Less) { m_RenderStateBlock.mask |= RenderStateMask.Depth; m_RenderStateBlock.depthState = new DepthState(writeEnabled, function); }
public static int mdb_set_dupsort(IntPtr txn, uint dbi, CompareFunction cmp) { return check(LmdbMethods.mdb_set_dupsort(txn, dbi, cmp)); }
internal static void ApplyDottedWireMaterial() { CompareFunction zTest = CompareFunction.Always; HandleUtility.ApplyDottedWireMaterial(zTest); }
public override void SetStencilBufferParams( CompareFunction function = CompareFunction.AlwaysPass, int refValue = 0, int mask = -1, StencilOperation stencilFailOp = StencilOperation.Keep, StencilOperation depthFailOp = StencilOperation.Keep, StencilOperation passOp = StencilOperation.Keep, bool twoSidedOperation = false ) { bool flip; // 2 sided operation? if ( twoSidedOperation ) { if (!currentCapabilities.HasCapability(Graphics.Capabilities.TwoSidedStencil)) { throw new AxiomException( "2-sided stencils are not supported on this hardware!" ); } SetRenderState( RenderState.TwoSidedStencilMode, true ); // 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); SetRenderState( RenderState.CcwStencilFail, (int)D3DHelper.ConvertEnum( stencilFailOp, !flip ) ); SetRenderState( RenderState.CcwStencilZFail, (int)D3DHelper.ConvertEnum( depthFailOp, !flip ) ); SetRenderState( RenderState.CcwStencilPass, (int)D3DHelper.ConvertEnum( passOp, !flip ) ); } else { SetRenderState( RenderState.TwoSidedStencilMode, false ); flip = false; } // configure standard version of the stencil operations SetRenderState( RenderState.StencilFunc, (int)D3DHelper.ConvertEnum( function ) ); SetRenderState( RenderState.StencilRef, refValue ); SetRenderState( RenderState.StencilMask, mask ); SetRenderState( RenderState.StencilFail, (int)D3DHelper.ConvertEnum( stencilFailOp, flip ) ); SetRenderState( RenderState.StencilZFail, (int)D3DHelper.ConvertEnum( depthFailOp, flip ) ); SetRenderState( RenderState.StencilPass, (int)D3DHelper.ConvertEnum( passOp, flip ) ); }
public static void Draw(ProBuilderMesh mesh, IEnumerable <Face> faces, Color color, CompareFunction compareFunction = CompareFunction.LessEqual) { if (mesh == null) { return; } faceMaterial.SetColor("_Color", color); faceMaterial.SetInt("_HandleZTest", (int)compareFunction); if (!faceMaterial.SetPass(0)) { return; } GL.PushMatrix(); GL.Begin(GL.TRIANGLES); GL.MultMatrix(mesh.transform.localToWorldMatrix); var positions = mesh.positions; foreach (var face in faces) { if (face == null) { continue; } var indices = face.indexes; for (int i = 0, c = indices.Count; i < c; i += 3) { GL.Vertex(positions[indices[i + 0]]); GL.Vertex(positions[indices[i + 1]]); GL.Vertex(positions[indices[i + 2]]); } } GL.End(); GL.PopMatrix(); }
public static CompareOperation ConvertComparisonFunction(CompareFunction comparison) { switch (comparison) { case CompareFunction.Always: return CompareOperation.Always; case CompareFunction.Never: return CompareOperation.Never; case CompareFunction.Equal: return CompareOperation.Equal; case CompareFunction.Greater: return CompareOperation.Greater; case CompareFunction.GreaterEqual: return CompareOperation.GreaterOrEqual; case CompareFunction.Less: return CompareOperation.Less; case CompareFunction.LessEqual: return CompareOperation.LessOrEqual; case CompareFunction.NotEqual: return CompareOperation.NotEqual; default: throw new ArgumentOutOfRangeException(); } }
public static extern int mdb_set_dupsort(IntPtr txn, uint dbi, CompareFunction cmp);
public static Material Add(Material baseMat, int stencilID, StencilOp operation, CompareFunction compareFunction, ColorWriteMask colorWriteMask, int readMask, int writeMask) { if (stencilID <= 0 && colorWriteMask == ColorWriteMask.All || (UnityEngine.Object) baseMat == (UnityEngine.Object) null) return baseMat; if (!baseMat.HasProperty("_Stencil")) { Debug.LogWarning((object) ("Material " + baseMat.name + " doesn't have _Stencil property"), (UnityEngine.Object) baseMat); return baseMat; } if (!baseMat.HasProperty("_StencilOp")) { Debug.LogWarning((object) ("Material " + baseMat.name + " doesn't have _StencilOp property"), (UnityEngine.Object) baseMat); return baseMat; } if (!baseMat.HasProperty("_StencilComp")) { Debug.LogWarning((object) ("Material " + baseMat.name + " doesn't have _StencilComp property"), (UnityEngine.Object) baseMat); return baseMat; } if (!baseMat.HasProperty("_StencilReadMask")) { Debug.LogWarning((object) ("Material " + baseMat.name + " doesn't have _StencilReadMask property"), (UnityEngine.Object) baseMat); return baseMat; } if (!baseMat.HasProperty("_StencilReadMask")) { Debug.LogWarning((object) ("Material " + baseMat.name + " doesn't have _StencilWriteMask property"), (UnityEngine.Object) baseMat); return baseMat; } if (!baseMat.HasProperty("_ColorMask")) { Debug.LogWarning((object) ("Material " + baseMat.name + " doesn't have _ColorMask property"), (UnityEngine.Object) baseMat); return baseMat; } for (int index = 0; index < StencilMaterial.m_List.Count; ++index) { StencilMaterial.MatEntry matEntry = StencilMaterial.m_List[index]; if ((UnityEngine.Object) matEntry.baseMat == (UnityEngine.Object) baseMat && matEntry.stencilId == stencilID && (matEntry.operation == operation && matEntry.compareFunction == compareFunction) && (matEntry.readMask == readMask && matEntry.writeMask == writeMask && matEntry.colorMask == colorWriteMask)) { ++matEntry.count; return matEntry.customMat; } } StencilMaterial.MatEntry matEntry1 = new StencilMaterial.MatEntry(); matEntry1.count = 1; matEntry1.baseMat = baseMat; matEntry1.customMat = new Material(baseMat); matEntry1.customMat.hideFlags = HideFlags.HideAndDontSave; matEntry1.stencilId = stencilID; matEntry1.operation = operation; matEntry1.compareFunction = compareFunction; matEntry1.readMask = readMask; matEntry1.writeMask = writeMask; matEntry1.colorMask = colorWriteMask; matEntry1.useAlphaClip = operation != StencilOp.Keep && writeMask > 0; matEntry1.customMat.name = string.Format("Stencil Id:{0}, Op:{1}, Comp:{2}, WriteMask:{3}, ReadMask:{4}, ColorMask:{5} AlphaClip:{6} ({7})", (object) stencilID, (object) operation, (object) compareFunction, (object) writeMask, (object) readMask, (object) colorWriteMask, (object) (bool) (matEntry1.useAlphaClip ? 1 : 0), (object) baseMat.name); matEntry1.customMat.SetInt("_Stencil", stencilID); matEntry1.customMat.SetInt("_StencilOp", (int) operation); matEntry1.customMat.SetInt("_StencilComp", (int) compareFunction); matEntry1.customMat.SetInt("_StencilReadMask", readMask); matEntry1.customMat.SetInt("_StencilWriteMask", writeMask); matEntry1.customMat.SetInt("_ColorMask", (int) colorWriteMask); if (matEntry1.customMat.HasProperty("_UseAlphaClip")) matEntry1.customMat.SetInt("_UseAlphaClip", !matEntry1.useAlphaClip ? 0 : 1); if (matEntry1.useAlphaClip) matEntry1.customMat.EnableKeyword("UNITY_UI_ALPHACLIP"); else matEntry1.customMat.DisableKeyword("UNITY_UI_ALPHACLIP"); StencilMaterial.m_List.Add(matEntry1); return matEntry1.customMat; }
/// <summary> /// Add a new material using the specified base and stencil ID. /// </summary> public static Material Add(Material baseMat, int stencilID, StencilOp operation, CompareFunction compareFunction, ColorWriteMask colorWriteMask, int readMask, int writeMask) { if ((stencilID <= 0 && colorWriteMask == ColorWriteMask.All) || baseMat == null) { return(baseMat); } if (!baseMat.HasProperty("_Stencil")) { Debug.LogWarning("Material " + baseMat.name + " doesn't have _Stencil property", baseMat); return(baseMat); } if (!baseMat.HasProperty("_StencilOp")) { Debug.LogWarning("Material " + baseMat.name + " doesn't have _StencilOp property", baseMat); return(baseMat); } if (!baseMat.HasProperty("_StencilComp")) { Debug.LogWarning("Material " + baseMat.name + " doesn't have _StencilComp property", baseMat); return(baseMat); } if (!baseMat.HasProperty("_StencilReadMask")) { Debug.LogWarning("Material " + baseMat.name + " doesn't have _StencilReadMask property", baseMat); return(baseMat); } if (!baseMat.HasProperty("_StencilWriteMask")) { Debug.LogWarning("Material " + baseMat.name + " doesn't have _StencilWriteMask property", baseMat); return(baseMat); } if (!baseMat.HasProperty("_ColorMask")) { Debug.LogWarning("Material " + baseMat.name + " doesn't have _ColorMask property", baseMat); return(baseMat); } for (int i = 0; i < m_List.Count; ++i) { MatEntry ent = m_List[i]; if (ent.baseMat == baseMat && ent.stencilId == stencilID && ent.operation == operation && ent.compareFunction == compareFunction && ent.readMask == readMask && ent.writeMask == writeMask && ent.colorMask == colorWriteMask) { ++ent.count; return(ent.customMat); } } var newEnt = new MatEntry(); newEnt.count = 1; newEnt.baseMat = baseMat; newEnt.customMat = new Material(baseMat); newEnt.customMat.hideFlags = HideFlags.HideAndDontSave; newEnt.stencilId = stencilID; newEnt.operation = operation; newEnt.compareFunction = compareFunction; newEnt.readMask = readMask; newEnt.writeMask = writeMask; newEnt.colorMask = colorWriteMask; newEnt.useAlphaClip = operation != StencilOp.Keep && writeMask > 0; newEnt.customMat.name = string.Format("Stencil Id:{0}, Op:{1}, Comp:{2}, WriteMask:{3}, ReadMask:{4}, ColorMask:{5} AlphaClip:{6} ({7})", stencilID, operation, compareFunction, writeMask, readMask, colorWriteMask, newEnt.useAlphaClip, baseMat.name); newEnt.customMat.SetInt("_Stencil", stencilID); newEnt.customMat.SetInt("_StencilOp", (int)operation); newEnt.customMat.SetInt("_StencilComp", (int)compareFunction); newEnt.customMat.SetInt("_StencilReadMask", readMask); newEnt.customMat.SetInt("_StencilWriteMask", writeMask); newEnt.customMat.SetInt("_ColorMask", (int)colorWriteMask); // left for backwards compatability if (newEnt.customMat.HasProperty("_UseAlphaClip")) { newEnt.customMat.SetInt("_UseAlphaClip", newEnt.useAlphaClip ? 1 : 0); } if (newEnt.useAlphaClip) { newEnt.customMat.EnableKeyword("UNITY_UI_ALPHACLIP"); } else { newEnt.customMat.DisableKeyword("UNITY_UI_ALPHACLIP"); } m_List.Add(newEnt); return(newEnt.customMat); }
public abstract void SemiDot(CompareFunction cmp, int xc1, int yc1, int xc2, int yc2);
public void AddComparer(CompareFunction compare) { var handle = GCHandle.Alloc(compare); _comparisons.Add(handle); }
public void GLDepthFunc(int func) { switch (func) { case 0x206: this.depthFunc = CompareFunction.GreaterEqual; break; case 0x207: this.depthFunc = CompareFunction.Always; break; case 0x202: this.depthFunc = CompareFunction.Equal; break; } }
/// <summary> /// Add a new material using the specified base and stencil ID. /// </summary> public static Material Add(Material baseMat, int stencilID, StencilOp operation, CompareFunction compareFunction, ColorWriteMask colorWriteMask) { return(Add(baseMat, stencilID, operation, compareFunction, colorWriteMask, 255, 255)); }
public static extern int mdb_set_compare(IntPtr txn, uint dbi, CompareFunction cmp);
public StencilState(bool enabled, byte readMask, byte writeMask, CompareFunction compareFunctionFront, StencilOp passOperationFront, StencilOp failOperationFront, StencilOp zFailOperationFront, CompareFunction compareFunctionBack, StencilOp passOperationBack, StencilOp failOperationBack, StencilOp zFailOperationBack) { this.m_Enabled = Convert.ToByte(enabled); this.m_ReadMask = readMask; this.m_WriteMask = writeMask; this.m_Padding = 0; this.m_CompareFunctionFront = (byte)compareFunctionFront; this.m_PassOperationFront = (byte)passOperationFront; this.m_FailOperationFront = (byte)failOperationFront; this.m_ZFailOperationFront = (byte)zFailOperationFront; this.m_CompareFunctionBack = (byte)compareFunctionBack; this.m_PassOperationBack = (byte)passOperationBack; this.m_FailOperationBack = (byte)failOperationBack; this.m_ZFailOperationBack = (byte)zFailOperationBack; }
/// <summary> /// Default constructor. /// </summary> /// <param name="parent">Technique that owns this Pass.</param> /// <param name="index">Index of this pass.</param> public Pass( Technique parent, int index ) { this._parent = parent; this._index = index; lock ( passLock ) { this.passId = nextPassId++; } // color defaults _ambient = ColorEx.White; _diffuse = ColorEx.White; _specular = ColorEx.Black; _emissive = ColorEx.Black; // by default, don't override the scene's fog settings _fogOverride = false; _fogMode = FogMode.None; _fogColor = ColorEx.White; _fogStart = 0; _fogEnd = 1; _fogDensity = 0.001f; // default blending (overwrite) _sourceBlendFactor = SceneBlendFactor.One; _destinationBlendFactor = SceneBlendFactor.Zero; // depth buffer settings _depthCheck = true; _depthWrite = true; _colorWriteEnabled = true; _depthFunction = CompareFunction.LessEqual; // cull settings _cullingMode = CullingMode.Clockwise; _manualCullingMode = ManualCullingMode.Back; // light settings _lightingEnabled = true; _runOnlyForOneLightType = true; _onlyLightType = LightType.Point; _shadingMode = Shading.Gouraud; // Default max lights to the global max _maxSimultaneousLights = Config.MaxSimultaneousLights; _name = index.ToString(); IterationCount = 1; DirtyHash(); }
int INativeLibraryFacade.mdb_set_dupsort(IntPtr txn, uint dbi, CompareFunction cmp) { return FallbackLibraryFacade.mdb_set_dupsort(txn, dbi, cmp); }
private static GLStencilFunction GetStencilFunc(CompareFunction function) { switch (function) { case CompareFunction.Always: return GLStencilFunction.Always; case CompareFunction.Equal: return GLStencilFunction.Equal; case CompareFunction.Greater: return GLStencilFunction.Greater; case CompareFunction.GreaterEqual: return GLStencilFunction.Gequal; case CompareFunction.Less: return GLStencilFunction.Less; case CompareFunction.LessEqual: return GLStencilFunction.Lequal; case CompareFunction.Never: return GLStencilFunction.Never; case CompareFunction.NotEqual: return GLStencilFunction.Notequal; default: return GLStencilFunction.Always; } }
public StencilState(bool enabled = false, byte readMask = 255, byte writeMask = 255, CompareFunction compareFunction = CompareFunction.Always, StencilOp passOperation = StencilOp.Keep, StencilOp failOperation = StencilOp.Keep, StencilOp zFailOperation = StencilOp.Keep) { this = new StencilState(enabled, readMask, writeMask, compareFunction, passOperation, failOperation, zFailOperation, compareFunction, passOperation, failOperation, zFailOperation); }
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 override void SetAlphaRejectSettings( CompareFunction func, byte value, bool alphaToCoverage ) { bool a2c = false; if ( func != CompareFunction.AlwaysPass ) { a2c = alphaToCoverage; } if ( a2c != this.lasta2c && Capabilities.HasCapability( Graphics.Capabilities.AlphaToCoverage ) ) { if ( a2c ) { GL.Enable( All.SampleAlphaToCoverage ); GLES2Config.GlCheckError( this ); } else { GL.Disable( All.SampleAlphaToCoverage ); GLES2Config.GlCheckError( this ); } this.lasta2c = a2c; } }
private static extern int mdb_set_dupsort(IntPtr txn, uint dbi, CompareFunction cmp);
public override void SemiDot(CompareFunction cmp, int xc1, int yc1, int xc2, int yc2) { }
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; }
public override void semidot_hline(CompareFunction cmp, int xc1, int yc1, int xc2, int yc2, int x1, int y1, int x2) { }