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 sourceRgb, BlendFactor sourceAlpha, BlendFactor destinationRgb, BlendFactor destinationAlpha, BlendEquation equationRgb, BlendEquation equationAlpha)
{
SourceRgb = sourceRgb;
SourceAlpha = sourceAlpha;
DestinationRgb = destinationRgb;
DestinationAlpha = destinationAlpha;
EquationRgb = equationRgb;
EquationAlpha = equationAlpha;
}
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)
{
}
