internal CompositeOperationState(BlendFactor srcRgb, BlendFactor dstRgb, BlendFactor srcAlpha, BlendFactor dstAlpha) { SrcRgb = srcRgb; DstRgb = dstRgb; SrcAlpha = srcAlpha; DstAlpha = dstAlpha; }
public void Apply() { if (m_stateBlock == null) { m_device.BeginStateBlock(); m_device.SetRenderState(RenderState.AlphaBlendEnable, true); m_device.SetRenderState(RenderState.AlphaFunc, Compare.Always); m_device.SetRenderState(RenderState.BlendOperationAlpha, AlphaBlendFunction); m_device.SetRenderState(RenderState.DestinationBlendAlpha, AlphaDestinationBlend); m_device.SetRenderState(RenderState.SourceBlendAlpha, AlphaSourceBlend); m_device.SetRenderState(RenderState.BlendFactor, BlendFactor.ToRgba()); m_device.SetRenderState(RenderState.BlendOperation, ColorBlendFunction); m_device.SetRenderState(RenderState.DestinationBlend, ColorDestinationBlend); m_device.SetRenderState(RenderState.SourceBlend, ColorSourceBlend); m_device.SetRenderState(RenderState.ColorWriteEnable, ColorWriteChannels); m_device.SetRenderState(RenderState.ColorWriteEnable1, ColorWriteChannels1); m_device.SetRenderState(RenderState.ColorWriteEnable2, ColorWriteChannels2); m_device.SetRenderState(RenderState.ColorWriteEnable3, ColorWriteChannels3); m_stateBlock = m_device.EndStateBlock(); m_instances.Add(this); } m_stateBlock.Apply(); Current = this; }
public PipelineKey( FaceCullMode cullMode, bool depthWriteEnabled, ComparisonKind depthComparison, bool blendEnabled, BlendFactor sourceFactor, BlendFactor destinationColorFactor, BlendFactor destinationAlphaFactor) { CullMode = cullMode; DepthWriteEnabled = depthWriteEnabled; DepthComparison = depthComparison; BlendEnabled = blendEnabled; SourceFactor = sourceFactor; DestinationColorFactor = destinationColorFactor; DestinationAlphaFactor = destinationAlphaFactor; _hashCode = HashCode.Combine( CullMode, DepthWriteEnabled, DepthComparison, BlendEnabled, SourceFactor, DestinationColorFactor, DestinationAlphaFactor); }
public RenderTargetBlend(RenderTargetBlendDescription bRenderTargetBlend) { if (bRenderTargetBlend.BlendEnable) { SrcFactor = CtObjectGL.BlendFactor(bRenderTargetBlend.SourceBlend); DestFactor = CtObjectGL.BlendFactor(bRenderTargetBlend.DestinationBlend); EquationMode = CtObjectGL.BlendFunc(bRenderTargetBlend.BlendOperation); SrcFactorAlpha = CtObjectGL.BlendFactor(bRenderTargetBlend.SourceBlendAlpha); DestFactorAlpha = CtObjectGL.BlendFactor(bRenderTargetBlend.DestinationBlendAlpha); EquationModeAlpha = CtObjectGL.BlendFunc(bRenderTargetBlend.BlendOperationAlpha); } else { SrcFactor = BlendFactor.One; DestFactor = BlendFactor.Zero; EquationMode = BlendFunc.Add; SrcFactorAlpha = BlendFactor.One; DestFactorAlpha = BlendFactor.Zero; EquationModeAlpha = BlendFunc.Add; } Separate = SrcFactor != SrcFactorAlpha || DestFactor != DestFactorAlpha || EquationMode != EquationModeAlpha; }
private void Update(EvaluationContext context) { var resourceManager = ResourceManager.Instance(); var device = resourceManager.Device; var deviceContext = device.ImmediateContext; var outputMerger = deviceContext.OutputMerger; DepthStencilView.GetValue(context); DepthStencilReference.GetValue(context); BlendFactor.GetValue(context); BlendSampleMask.GetValue(context); RenderTargetViews.GetValues(ref _renderTargetViews, context); UnorderedAccessViews.GetValues(ref _unorderedAccessViews, context); _prevRenderTargetViews = outputMerger.GetRenderTargets(_renderTargetViews.Length); // if (_unorderedAccessViews.Length > 0) // _prevUnorderedAccessViews = outputMerger.GetUnorderedAccessViews(1, _unorderedAccessViews.Length); outputMerger.GetRenderTargets(out _prevDepthStencilView); outputMerger.SetDepthStencilState(DepthStencilState.GetValue(context)); _prevBlendState = outputMerger.GetBlendState(out _prevBlendFactor, out _prevSampleMask); if (_renderTargetViews.Length > 0) { outputMerger.SetRenderTargets(null, _renderTargetViews); } if (_unorderedAccessViews.Length > 0) { // Log.Debug($"num uavs: {_unorderedAccessViews.Length}"); outputMerger.SetUnorderedAccessViews(1, _unorderedAccessViews); } outputMerger.BlendState = BlendState.GetValue(context); }
public override void Write(Vault vault, BinaryWriter bw) { _debugNameText.Write(vault, bw); bw.Write(BlendEnable); bw.Write(AlphaTestEnable); bw.AlignWriter(4); bw.Write(AlphaTestRef); bw.WriteEnum(AlphaTestFunc); bw.WriteArray(SourceColor, bw.WriteEnum); bw.WriteArray(DestColor, bw.WriteEnum); bw.WriteArray(OperationColor, bw.WriteEnum); bw.WriteArray(SourceAlpha, bw.WriteEnum); bw.WriteArray(DestAlpha, bw.WriteEnum); bw.WriteArray(OperationAlpha, bw.WriteEnum); BlendFactor.Write(vault, bw); bw.WriteArray(RGBAEnableRT0, bw.Write); bw.WriteArray(RGBAEnableRT1, bw.Write); bw.WriteArray(RGBAEnableRT2, bw.Write); bw.WriteArray(RGBAEnableRT3, bw.Write); bw.Write(AlphaToMaskEnable_XENON); bw.WriteArray(HiPrecisionBlendEnable_XENON, bw.Write); bw.WriteArray(BlendEnable_PS3, bw.Write); bw.Write(BlendFactorF16_PS3); bw.AlignWriter(4); }
/// <summary> /// /// </summary> /// <param name="blendMode"></param> /// <param name="srcFactor"></param> /// <param name="dstFactor"></param> public static void Override(BlendMode blendMode, NativeBlendMode srcFactor, NativeBlendMode dstFactor) { BlendFactor bf = Factors[(int)blendMode]; bf.srcFactor = srcFactor; bf.dstFactor = dstFactor; }
internal static VkBlendFactor VdToVkBlendFactor(BlendFactor factor) { switch (factor) { case BlendFactor.Zero: return VkBlendFactor.Zero; case BlendFactor.One: return VkBlendFactor.One; case BlendFactor.SourceAlpha: return VkBlendFactor.SrcAlpha; case BlendFactor.InverseSourceAlpha: return VkBlendFactor.OneMinusSrcAlpha; case BlendFactor.DestinationAlpha: return VkBlendFactor.DstAlpha; case BlendFactor.InverseDestinationAlpha: return VkBlendFactor.OneMinusDstAlpha; case BlendFactor.SourceColor: return VkBlendFactor.SrcColor; case BlendFactor.InverseSourceColor: return VkBlendFactor.OneMinusSrcColor; case BlendFactor.DestinationColor: return VkBlendFactor.DstColor; case BlendFactor.InverseDestinationColor: return VkBlendFactor.OneMinusDstColor; case BlendFactor.BlendFactor: return VkBlendFactor.ConstantColor; case BlendFactor.InverseBlendFactor: return VkBlendFactor.OneMinusConstantColor; default: throw Illegal.Value<BlendFactor>(); } }
public static extern BlendMode ComposeCustomBlendMode( BlendFactor srcColorFactor, BlendFactor dstColorFactor, BlendOperation colorOperation, BlendFactor srcAlphaFactor, BlendFactor dstAlphaFactor, BlendOperation alphaOperation);
public BlendState(BlendFactor sourceRgb, BlendFactor sourceAlpha, BlendFactor destinationRgb, BlendFactor destinationAlpha, BlendEquation equationRgb, BlendEquation equationAlpha) { SourceRgb = sourceRgb; SourceAlpha = sourceAlpha; DestinationRgb = destinationRgb; DestinationAlpha = destinationAlpha; EquationRgb = equationRgb; EquationAlpha = equationAlpha; }
public static void Set(this IBinding <BlendFunction> binding, BlendFactor sourceRgb, BlendFactor destinationRgb, BlendFactor sourceAlpha, BlendFactor destinationAlpha) { binding.Set(new BlendFunction { SourceRgb = sourceRgb, SourceAlpha = sourceAlpha, DestinationRgb = destinationRgb, DestinationAlpha = destinationAlpha }); }
public static void Set(this IBinding<BlendFunction> binding, BlendFactor sourceRgb, BlendFactor destinationRgb, BlendFactor sourceAlpha, BlendFactor destinationAlpha) { binding.Set(new BlendFunction { SourceRgb = sourceRgb, SourceAlpha = sourceAlpha, DestinationRgb = destinationRgb, DestinationAlpha = destinationAlpha }); }
/// <summary> /// /// </summary> public PipelineColorBlendAttachmentState(Bool32 blendEnable, BlendFactor sourceColorBlendFactor, BlendFactor destinationColorBlendFactor, BlendOp colorBlendOp, BlendFactor sourceAlphaBlendFactor, BlendFactor destinationAlphaBlendFactor, BlendOp alphaBlendOp, ColorComponentFlags colorWriteMask) { this.BlendEnable = blendEnable; this.SourceColorBlendFactor = sourceColorBlendFactor; this.DestinationColorBlendFactor = destinationColorBlendFactor; this.ColorBlendOp = colorBlendOp; this.SourceAlphaBlendFactor = sourceAlphaBlendFactor; this.DestinationAlphaBlendFactor = destinationAlphaBlendFactor; this.AlphaBlendOp = alphaBlendOp; this.ColorWriteMask = colorWriteMask; }
public BlendMode(bool enabled) { Enabled = enabled; SourceFactor = BlendFactor.SourceAlpha; DestinationFactor = BlendFactor.InvSourceAlpha; Operation = BlendOperation.Add; SourceAlphaFactor = BlendFactor.SourceAlpha; DestinationAlphaFactor = BlendFactor.InvSourceAlpha; AlphaOperation = BlendOperation.Add; }
/// <summary> /// /// </summary> /// <param name="mat"></param> /// <param name="blendMode"></param> public static void Apply(Material mat, BlendMode blendMode) { BlendFactor bf = Factors[(int)blendMode]; mat.SetFloat("_BlendSrcFactor", (float)bf.srcFactor); mat.SetFloat("_BlendDstFactor", (float)bf.dstFactor); if (bf.pma) { mat.SetFloat("_ColorOption", 1); } }
internal static OpenGLBindings.BlendFactor ToOpenGL(this BlendFactor blendFactor) { switch (blendFactor) { case BlendFactor.Zero: return(OpenGLBindings.BlendFactor.Zero); case BlendFactor.One: return(OpenGLBindings.BlendFactor.One); case BlendFactor.SrcColour: return(OpenGLBindings.BlendFactor.SrcColour); case BlendFactor.OneMinusSrcColour: return(OpenGLBindings.BlendFactor.OneMinusSrcColour); case BlendFactor.SrcAlpha: return(OpenGLBindings.BlendFactor.SrcAlpha); case BlendFactor.OneMinusSrcAlpha: return(OpenGLBindings.BlendFactor.OneMinusSrcAlpha); case BlendFactor.DstAlpha: return(OpenGLBindings.BlendFactor.DstAlpha); case BlendFactor.OneMinusDstAlpha: return(OpenGLBindings.BlendFactor.OneMinusDstAlpha); case BlendFactor.DstColour: return(OpenGLBindings.BlendFactor.DstColour); case BlendFactor.OneMinusDstcolour: return(OpenGLBindings.BlendFactor.OneMinusDstcolour); case BlendFactor.SrcAlphaSaturate: return(OpenGLBindings.BlendFactor.SrcAlphaSaturate); case BlendFactor.ConstantColour: return(OpenGLBindings.BlendFactor.ConstantColour); case BlendFactor.OneMinusConstantColour: return(OpenGLBindings.BlendFactor.OneMinusConstantColour); case BlendFactor.ConstantAlpha: return(OpenGLBindings.BlendFactor.ConstantAlpha); case BlendFactor.OneMinusConstantAlpha: return(OpenGLBindings.BlendFactor.OneMinusConstantAlpha); default: throw new IllegalValueException(typeof(BlendFactor), blendFactor); } }
/// <summary> /// /// </summary> /// <param name="mat"></param> /// <param name="blendMode"></param> public static void Apply(Material mat, BlendMode blendMode) { BlendFactor bf = Factors[(int)blendMode]; mat.SetFloat(ShaderConfig._properyIDs._BlendSrcFactor, (float)bf.srcFactor); mat.SetFloat(ShaderConfig._properyIDs._BlendDstFactor, (float)bf.dstFactor); if (bf.pma) { mat.SetFloat(ShaderConfig._properyIDs._ColorOption, 1); } }
internal static double ToWebGL(this BlendFactor blendFactor) { switch (blendFactor) { case BlendFactor.Zero: return(GL.ZERO); case BlendFactor.One: return(GL.ONE); case BlendFactor.SrcColour: return(GL.SRC_COLOR); case BlendFactor.OneMinusSrcColour: return(GL.ONE_MINUS_SRC_COLOR); case BlendFactor.SrcAlpha: return(GL.SRC_ALPHA); case BlendFactor.OneMinusSrcAlpha: return(GL.ONE_MINUS_SRC_ALPHA); case BlendFactor.DstAlpha: return(GL.DST_ALPHA); case BlendFactor.OneMinusDstAlpha: return(GL.ONE_MINUS_DST_ALPHA); case BlendFactor.DstColour: return(GL.DST_COLOR); case BlendFactor.OneMinusDstcolour: return(GL.ONE_MINUS_DST_COLOR); case BlendFactor.SrcAlphaSaturate: return(GL.SRC_ALPHA_SATURATE); case BlendFactor.ConstantColour: return(GL.CONSTANT_COLOR); case BlendFactor.OneMinusConstantColour: return(GL.ONE_MINUS_CONSTANT_COLOR); case BlendFactor.ConstantAlpha: return(GL.CONSTANT_ALPHA); case BlendFactor.OneMinusConstantAlpha: return(GL.ONE_MINUS_CONSTANT_ALPHA); default: throw new IllegalValueException(typeof(BlendFactor), blendFactor); } }
public Pipeline GetCachedPipeline( FaceCullMode cullMode, bool depthWriteEnabled, ComparisonKind depthComparison, bool blendEnabled, BlendFactor sourceFactor, BlendFactor destinationColorFactor, BlendFactor destinationAlphaFactor) { var key = new PipelineKey( cullMode, depthWriteEnabled, depthComparison, blendEnabled, sourceFactor, destinationColorFactor, destinationAlphaFactor); if (!_pipelines.TryGetValue(key, out var result)) { var blendState = new BlendStateDescription( RgbaFloat.White, new BlendAttachmentDescription( blendEnabled, sourceFactor, destinationColorFactor, BlendFunction.Add, sourceFactor, destinationAlphaFactor, BlendFunction.Add)); var depthState = DepthStencilStateDescription.DepthOnlyLessEqual; depthState.DepthWriteEnabled = depthWriteEnabled; depthState.DepthComparison = depthComparison; var rasterizerState = RasterizerStateDescriptionUtility.DefaultFrontIsCounterClockwise; rasterizerState.CullMode = cullMode; _pipelines.Add(key, result = AddDisposable(GraphicsDevice.ResourceFactory.CreateGraphicsPipeline( new GraphicsPipelineDescription( blendState, depthState, rasterizerState, PrimitiveTopology.TriangleList, ShaderSet.Description, _resourceLayouts, RenderPipeline.GameOutputDescription)))); } return(result); }
private void Update(EvaluationContext context) { if (!_initialized) { if (Parent?.Symbol == null) { Log.Warning("Can't register Preset blending for undefined parent", this.SymbolChildId); return; } BlendSettingForCompositionIds[Parent.Symbol.Id] = _blendSetting; _initialized = true; } // Evaluate subtree SubTree.GetValue(context); var wasUpdated = false; var groupIndex = GroupIndex.GetValue(context); if (groupIndex != _blendSetting.GroupIndex) { wasUpdated = true; _blendSetting.GroupIndex = groupIndex; } var presetA = PresetA.GetValue(context); if (presetA != _blendSetting.PresetAIndex) { wasUpdated = true; _blendSetting.PresetAIndex = presetA; } var presetB = PresetB.GetValue(context); if (presetB != _blendSetting.PresetBIndex) { wasUpdated = true; _blendSetting.PresetBIndex = presetB; } var blendFactor = BlendFactor.GetValue(context); if (Math.Abs(blendFactor - _blendSetting.BlendFactor) > 0.001f) { wasUpdated = true; _blendSetting.BlendFactor = blendFactor; } _blendSetting.WasActivatedLastFrame = wasUpdated; }
public BlendState( bool enabled, BlendFactor source, BlendFactor destination) : this( enabled, source, source, destination, destination, BlendEquation.Add, BlendEquation.Add) { }
public RenderTargetBlendDesc_NativeInterop(ref RenderTargetBlendDesc desc) { blendingEnabled = (byte)(desc.blendingEnabled ? 1 : 0); logicOperationEnabled = (byte)(desc.logicOperationEnabled ? 1 : 0); alphaBlendingSeparated = (byte)(desc.alphaBlendingSeparated ? 1 : 0); sourceFactor = desc.sourceFactor; destinationFactor = desc.destinationFactor; operation = desc.operation; sourceAlphaFactor = desc.sourceAlphaFactor; destinationAlphaFactor = desc.destinationAlphaFactor; alphaOperation = desc.alphaOperation; logicalOperation = desc.logicalOperation; writeMask = desc.writeMask; }
public BlendState( bool enabled, BlendFactor colourSource, BlendFactor colourDestination, BlendFactor alphaSource, BlendFactor alphaDestination) : this( enabled, colourSource, alphaSource, colourDestination, alphaDestination, BlendEquation.Add, BlendEquation.Add) { }
internal void UpdateBlendState(XnaBlendState state) { state.AlphaBlendFunction = (XnaBlendFunc)AlphaBlendFunction; state.AlphaDestinationBlend = (XnaBlend)AlphaDestinationBlend; state.AlphaSourceBlend = (XnaBlend)AlphaSourceBlend; state.BlendFactor = BlendFactor.ToXnaColor(); state.ColorBlendFunction = (XnaBlendFunc)ColorBlendFunction; state.ColorDestinationBlend = (XnaBlend)ColorDestinationBlend; state.ColorSourceBlend = (XnaBlend)ColorSourceBlend; state.ColorWriteChannels = (XnaBlendChannel)ColorWriteChannels; state.ColorWriteChannels1 = (XnaBlendChannel)ColorWriteChannels1; state.ColorWriteChannels2 = (XnaBlendChannel)ColorWriteChannels2; state.ColorWriteChannels3 = (XnaBlendChannel)ColorWriteChannels3; state.MultiSampleMask = MultiSampleMask; blendStateDirty = false; }
public BlendState( bool enabled, BlendFactor colourSource, BlendFactor alphaSource, BlendFactor colourDestination, BlendFactor alphaDestination, BlendEquation colourEquation, BlendEquation alphaEquation) { Enabled = enabled; ColourSource = colourSource; AlphaSource = alphaSource; ColourDestination = colourDestination; AlphaDestination = alphaDestination; ColourEquation = colourEquation; AlphaEquation = alphaEquation; }
public BlendDescriptor( bool enable, BlendOp colorOp, BlendFactor colorSrcFactor, BlendFactor colorDstFactor, BlendOp alphaOp, BlendFactor alphaSrcFactor, BlendFactor alphaDstFactor) { Enable = enable; ColorOp = colorOp; ColorSrcFactor = colorSrcFactor; ColorDstFactor = colorDstFactor; AlphaOp = alphaOp; AlphaSrcFactor = alphaSrcFactor; AlphaDstFactor = alphaDstFactor; }
/// <summary> /// Constructs a new <see cref="BlendAttachmentDescription"/>. /// </summary> /// <param name="blendEnabled">Controls whether blending is enabled for the color attachment.</param> /// <param name="sourceColorFactor">Controls the source color's influence on the blend result.</param> /// <param name="destinationColorFactor">Controls the destination color's influence on the blend result.</param> /// <param name="colorFunction">Controls the function used to combine the source and destination color factors.</param> /// <param name="sourceAlphaFactor">Controls the source alpha's influence on the blend result.</param> /// <param name="destinationAlphaFactor">Controls the destination alpha's influence on the blend result.</param> /// <param name="alphaFunction">Controls the function used to combine the source and destination alpha factors.</param> public BlendAttachmentDescription( bool blendEnabled, BlendFactor sourceColorFactor, BlendFactor destinationColorFactor, BlendFunction colorFunction, BlendFactor sourceAlphaFactor, BlendFactor destinationAlphaFactor, BlendFunction alphaFunction) { BlendEnabled = blendEnabled; SourceColorFactor = sourceColorFactor; DestinationColorFactor = destinationColorFactor; ColorFunction = colorFunction; SourceAlphaFactor = sourceAlphaFactor; DestinationAlphaFactor = destinationAlphaFactor; AlphaFunction = alphaFunction; }
static bool IsDualSource(BlendFactor factor) { switch (factor) { case BlendFactor.Src1Color: case BlendFactor.Src1ColorGl: case BlendFactor.Src1Alpha: case BlendFactor.Src1AlphaGl: case BlendFactor.OneMinusSrc1Color: case BlendFactor.OneMinusSrc1ColorGl: case BlendFactor.OneMinusSrc1Alpha: case BlendFactor.OneMinusSrc1AlphaGl: return(true); } return(false); }
private static GLEnum ConvertBlend(BlendFactor op) { return(op switch { BlendFactor.Zero => GLEnum.Zero, BlendFactor.One => GLEnum.One, BlendFactor.SrcColour => GLEnum.SrcColor, BlendFactor.OneMinusSrcColour => GLEnum.OneMinusSrcColor, BlendFactor.DstColour => GLEnum.DstColor, BlendFactor.OneMinusDstColour => GLEnum.OneMinusDstColor, BlendFactor.SrcAlpha => GLEnum.SrcAlpha, BlendFactor.OneMinusSrcAlpha => GLEnum.OneMinusSrcAlpha, BlendFactor.DstAlpha => GLEnum.DstAlpha, BlendFactor.OneMinusDstAlpha => GLEnum.OneMinusDstAlpha, BlendFactor.SrcAlphaSaturate => GLEnum.SrcAlphaSaturate, _ => GLEnum.InvalidEnum });
internal static BlendOption VdToD3D11BlendOption(BlendFactor factor) { switch (factor) { case BlendFactor.Zero: return(BlendOption.Zero); case BlendFactor.One: return(BlendOption.One); case BlendFactor.SourceAlpha: return(BlendOption.SourceAlpha); case BlendFactor.InverseSourceAlpha: return(BlendOption.InverseSourceAlpha); case BlendFactor.DestinationAlpha: return(BlendOption.DestinationAlpha); case BlendFactor.InverseDestinationAlpha: return(BlendOption.InverseDestinationAlpha); case BlendFactor.SourceColor: return(BlendOption.SourceColor); case BlendFactor.InverseSourceColor: return(BlendOption.InverseSourceColor); case BlendFactor.DestinationColor: return(BlendOption.DestinationColor); case BlendFactor.InverseDestinationColor: return(BlendOption.InverseDestinationColor); case BlendFactor.BlendFactor: return(BlendOption.BlendFactor); case BlendFactor.InverseBlendFactor: return(BlendOption.BlendFactor); default: throw Illegal.Value <BlendFactor>(); } }
internal static MTLBlendFactor VdToMTLBlendFactor(BlendFactor vdFactor) { switch (vdFactor) { case BlendFactor.Zero: return(MTLBlendFactor.Zero); case BlendFactor.One: return(MTLBlendFactor.One); case BlendFactor.SourceAlpha: return(MTLBlendFactor.SourceAlpha); case BlendFactor.InverseSourceAlpha: return(MTLBlendFactor.OneMinusSourceAlpha); case BlendFactor.DestinationAlpha: return(MTLBlendFactor.DestinationAlpha); case BlendFactor.InverseDestinationAlpha: return(MTLBlendFactor.OneMinusDestinationAlpha); case BlendFactor.SourceColor: return(MTLBlendFactor.SourceColor); case BlendFactor.InverseSourceColor: return(MTLBlendFactor.OneMinusSourceColor); case BlendFactor.DestinationColor: return(MTLBlendFactor.DestinationColor); case BlendFactor.InverseDestinationColor: return(MTLBlendFactor.OneMinusDestinationColor); case BlendFactor.BlendFactor: return(MTLBlendFactor.BlendColor); case BlendFactor.InverseBlendFactor: return(MTLBlendFactor.OneMinusBlendColor); default: throw Illegal.Value <BlendFactor>(); } }
internal static BlendingFactorSrc VdToGLBlendFactorSrc(BlendFactor factor) { switch (factor) { case BlendFactor.Zero: return(BlendingFactorSrc.Zero); case BlendFactor.One: return(BlendingFactorSrc.One); case BlendFactor.SourceAlpha: return(BlendingFactorSrc.SrcAlpha); case BlendFactor.InverseSourceAlpha: return(BlendingFactorSrc.OneMinusSrcAlpha); case BlendFactor.DestinationAlpha: return(BlendingFactorSrc.DstAlpha); case BlendFactor.InverseDestinationAlpha: return(BlendingFactorSrc.OneMinusDstAlpha); case BlendFactor.SourceColor: return(BlendingFactorSrc.SrcColor); case BlendFactor.InverseSourceColor: return(BlendingFactorSrc.OneMinusSrcColor); case BlendFactor.DestinationColor: return(BlendingFactorSrc.DstColor); case BlendFactor.InverseDestinationColor: return(BlendingFactorSrc.OneMinusDstColor); case BlendFactor.BlendFactor: return(BlendingFactorSrc.ConstantColor); case BlendFactor.InverseBlendFactor: return(BlendingFactorSrc.OneMinusConstantColor); default: throw Illegal.Value <BlendFactor>(); } }
/// <summary> /// Copy constructor /// </summary> /// <param name="src">Source render state to copy</param> public OpenGlRenderState( OpenGlRenderState src ) { Arguments.CheckNotNull( src, "src" ); m_Lighting = src.m_Lighting; m_DepthOffset = src.m_DepthOffset; m_DepthBias = src.m_DepthBias; m_PassDepthTest = src.m_PassDepthTest; m_DepthTest = src.m_DepthTest; m_DepthWrite = src.m_DepthWrite; m_CullBackFaces = src.m_CullBackFaces; m_CullFrontFaces = src.m_CullFrontFaces; m_FaceWinding = src.m_FaceWinding; m_FrontFaceRenderMode = src.m_FrontFaceRenderMode; m_BackFaceRenderMode = src.m_BackFaceRenderMode; m_Colour = src.m_Colour; m_ShadeMode = src.m_ShadeMode; m_Enable2dTextures = src.m_Enable2dTextures; m_Blend = src.m_Blend; m_SourceBlend = src.m_SourceBlend; m_DestinationBlend = src.m_DestinationBlend; m_PointSize = src.m_PointSize; m_LineWidth = src.m_LineWidth; m_TextureUnits = src.m_TextureUnits; }
/// <summary> /// Gets the GL blend factor value from a <see cref="BlendFactor"/> value /// </summary> private static int GetBlendFactor( BlendFactor factor ) { switch ( factor ) { case BlendFactor.Zero : return Gl.GL_ZERO; case BlendFactor.DstColour : return Gl.GL_DST_COLOR; case BlendFactor.OneMinusDstColour : return Gl.GL_ONE_MINUS_DST_COLOR; case BlendFactor.DstAlpha : return Gl.GL_DST_ALPHA; case BlendFactor.OneMinusDstAlpha : return Gl.GL_ONE_MINUS_DST_ALPHA; case BlendFactor.SrcColour : return Gl.GL_SRC_COLOR; case BlendFactor.OneMinusSrcColour : return Gl.GL_ONE_MINUS_SRC_COLOR; case BlendFactor.SrcAlpha : return Gl.GL_SRC_ALPHA; case BlendFactor.OneMinusSrcAlpha : return Gl.GL_ONE_MINUS_SRC_ALPHA; case BlendFactor.SrcAlphaSaturate : return Gl.GL_SRC_ALPHA_SATURATE; case BlendFactor.One : return Gl.GL_ONE; } throw new ApplicationException( string.Format( "Unhandled blend factor \"{0}\"", factor ) ); }
public BlendState(BlendFactor source, BlendFactor destination, BlendEquation equation) : this(source, source, destination, destination, equation, equation) { }
public BlendState(BlendFactor sourceFactor, BlendFactor destinationFactor) : this(sourceFactor, destinationFactor, BlendEquation.Add) { }