public static D3D9.TextureOperation ConvertEnum(LayerBlendOperationEx lbo, D3D9.Capabilities devCaps) { switch (lbo) { case LayerBlendOperationEx.Source1: return(D3D9.TextureOperation.SelectArg1); case LayerBlendOperationEx.Source2: return(D3D9.TextureOperation.SelectArg2); case LayerBlendOperationEx.Modulate: return(D3D9.TextureOperation.Modulate); case LayerBlendOperationEx.ModulateX2: return(D3D9.TextureOperation.Modulate2X); case LayerBlendOperationEx.ModulateX4: return(D3D9.TextureOperation.Modulate4X); case LayerBlendOperationEx.Add: return(D3D9.TextureOperation.Add); case LayerBlendOperationEx.AddSigned: return(D3D9.TextureOperation.AddSigned); case LayerBlendOperationEx.AddSmooth: return(D3D9.TextureOperation.AddSmooth); case LayerBlendOperationEx.Subtract: return(D3D9.TextureOperation.Subtract); case LayerBlendOperationEx.BlendDiffuseAlpha: return(D3D9.TextureOperation.BlendDiffuseAlpha); case LayerBlendOperationEx.BlendTextureAlpha: return(D3D9.TextureOperation.BlendTextureAlpha); case LayerBlendOperationEx.BlendCurrentAlpha: return(D3D9.TextureOperation.BlendCurrentAlpha); case LayerBlendOperationEx.BlendManual: return(D3D9.TextureOperation.BlendFactorAlpha); case LayerBlendOperationEx.DotProduct: return((devCaps.TextureOperationCaps & D3D9.TextureOperationCaps.DotProduct3) != 0 ? D3D9.TextureOperation.DotProduct3 : D3D9.TextureOperation.Modulate); case LayerBlendOperationEx.BlendDiffuseColor: return((devCaps.TextureOperationCaps & D3D9.TextureOperationCaps.Lerp) != 0 ? D3D9.TextureOperation.Lerp : D3D9.TextureOperation.Modulate); } return(0); }
/// <summary> /// /// </summary> private void ToggleBlending() { if (++currentLbxIndex == blendModes.Length) { currentLbxIndex = 0; } // get the current color blend mode to use currentLbx = (LayerBlendOperationEx)Enum.Parse(typeof(LayerBlendOperationEx), blendModes[currentLbxIndex], true); PrepareEntity(meshes[currentMeshIndex]); // update the UI OverlayElementManager.Instance.GetElement("Example/CubeMapping/Material").Text = string.Format("[M] Material: {0}", blendModes[currentLbxIndex]); }
/// <summary> /// /// </summary> private void ToggleBlending() { if(++currentLbxIndex == blendModes.Length) { currentLbxIndex = 0; } // get the current color blend mode to use currentLbx = (LayerBlendOperationEx)Enum.Parse(typeof(LayerBlendOperationEx), blendModes[currentLbxIndex], true); PrepareEntity(meshes[currentMeshIndex]); // update the UI OverlayElementManager.Instance.GetElement("Example/CubeMapping/Material").Text = string.Format("[M] Material: {0}", blendModes[currentLbxIndex]); }
/// <summary> /// Static method for converting LayerBlendOperationEx enum values to the Direct3D /// TextureOperation enum. /// </summary> /// <param name="blendop"></param> /// <returns></returns> public static XFG.BlendFunction Convert( LayerBlendOperationEx blendop ) { XFG.BlendFunction xnaTexOp = 0; // figure out what is what switch ( blendop ) { /*case LayerBlendOperationEx.Source1: d3dTexOp = XFG.Blend.BlendFunction.SelectArg1; break; case LayerBlendOperationEx.Source2: d3dTexOp = XFG.TextureOperation.SelectArg2; break; case LayerBlendOperationEx.Modulate: d3dTexOp = BlendFunction.moXFG.TextureOperation.Modulate; break; case LayerBlendOperationEx.ModulateX2: d3dTexOp = XFG.TextureOperation.Modulate2X; break; case LayerBlendOperationEx.ModulateX4: d3dTexOp = XFG.TextureOperation.Modulate4X; break;*/ case LayerBlendOperationEx.Add: xnaTexOp = XFG.BlendFunction.Add; break; case LayerBlendOperationEx.AddSigned: xnaTexOp = XFG.BlendFunction.Add; break; case LayerBlendOperationEx.AddSmooth: xnaTexOp = XFG.BlendFunction.Add; break; case LayerBlendOperationEx.Subtract: xnaTexOp = XFG.BlendFunction.Subtract; break; default: xnaTexOp = XFG.BlendFunction.Add; break; /* case LayerBlendOperationEx.BlendDiffuseAlpha: d3dTexOp = XFG.BlendFunction..BlendDiffuseAlpha; break; case LayerBlendOperationEx.BlendTextureAlpha: d3dTexOp = XFG.TextureOperation.BlendTextureAlpha; break; case LayerBlendOperationEx.BlendCurrentAlpha: d3dTexOp = XFG.TextureOperation.BlendCurrentAlpha; break; case LayerBlendOperationEx.BlendManual: d3dTexOp = XFG.TextureOperation.BlendFactorAlpha; break; case LayerBlendOperationEx.DotProduct: if ( Root.Instance.RenderSystem.Caps.CheckCap( Capabilities.Dot3 ) ) { d3dTexOp = XFG.TextureOperation.DotProduct3; } else { d3dTexOp = XFG.TextureOperation.Modulate; } break;*/ } // end switch return xnaTexOp; }
/// <summary> /// Static method for converting LayerBlendOperationEx enum values to the Direct3D /// TextureOperation enum. /// </summary> /// <param name="blendop"></param> /// <returns></returns> public static D3D.TextureOperation ConvertEnum( LayerBlendOperationEx blendop ) { D3D.TextureOperation d3dTexOp = 0; // figure out what is what switch ( blendop ) { case LayerBlendOperationEx.Source1: d3dTexOp = D3D.TextureOperation.SelectArg1; break; case LayerBlendOperationEx.Source2: d3dTexOp = D3D.TextureOperation.SelectArg2; break; case LayerBlendOperationEx.Modulate: d3dTexOp = D3D.TextureOperation.Modulate; break; case LayerBlendOperationEx.ModulateX2: d3dTexOp = D3D.TextureOperation.Modulate2X; break; case LayerBlendOperationEx.ModulateX4: d3dTexOp = D3D.TextureOperation.Modulate4X; break; case LayerBlendOperationEx.Add: d3dTexOp = D3D.TextureOperation.Add; break; case LayerBlendOperationEx.AddSigned: d3dTexOp = D3D.TextureOperation.AddSigned; break; case LayerBlendOperationEx.AddSmooth: d3dTexOp = D3D.TextureOperation.AddSmooth; break; case LayerBlendOperationEx.Subtract: d3dTexOp = D3D.TextureOperation.Subtract; break; case LayerBlendOperationEx.BlendDiffuseAlpha: d3dTexOp = D3D.TextureOperation.BlendDiffuseAlpha; break; case LayerBlendOperationEx.BlendTextureAlpha: d3dTexOp = D3D.TextureOperation.BlendTextureAlpha; break; case LayerBlendOperationEx.BlendCurrentAlpha: d3dTexOp = D3D.TextureOperation.BlendCurrentAlpha; break; case LayerBlendOperationEx.BlendManual: d3dTexOp = D3D.TextureOperation.BlendFactorAlpha; break; case LayerBlendOperationEx.DotProduct: if ( Root.Instance.RenderSystem.Capabilities.HasCapability( Capabilities.Dot3 ) ) { d3dTexOp = D3D.TextureOperation.DotProduct3; } else { d3dTexOp = D3D.TextureOperation.Modulate; } break; } // end switch return d3dTexOp; }
public static TextureOperation ConvertEnum(LayerBlendOperationEx lbo, SlimDX.Direct3D9.Capabilities devCaps) { switch (lbo) { case LayerBlendOperationEx.Source1: return TextureOperation.SelectArg1; case LayerBlendOperationEx.Source2: return TextureOperation.SelectArg2; case LayerBlendOperationEx.Modulate: return TextureOperation.Modulate; case LayerBlendOperationEx.ModulateX2: return TextureOperation.Modulate2X; case LayerBlendOperationEx.ModulateX4: return TextureOperation.Modulate4X; case LayerBlendOperationEx.Add: return TextureOperation.Add; case LayerBlendOperationEx.AddSigned: return TextureOperation.AddSigned; case LayerBlendOperationEx.AddSmooth: return TextureOperation.AddSmooth; case LayerBlendOperationEx.Subtract: return TextureOperation.Subtract; case LayerBlendOperationEx.BlendDiffuseAlpha: return TextureOperation.BlendDiffuseAlpha; case LayerBlendOperationEx.BlendTextureAlpha: return TextureOperation.BlendTextureAlpha; case LayerBlendOperationEx.BlendCurrentAlpha: return TextureOperation.BlendCurrentAlpha; case LayerBlendOperationEx.BlendManual: return TextureOperation.BlendFactorAlpha; case LayerBlendOperationEx.DotProduct: return (devCaps.TextureOperationCaps & TextureOperationCaps.DotProduct3) != 0 ? TextureOperation.DotProduct3 : TextureOperation.Modulate; case LayerBlendOperationEx.BlendDiffuseColor: return (devCaps.TextureOperationCaps & TextureOperationCaps.Lerp) != 0 ? TextureOperation.Lerp : TextureOperation.Modulate; } return 0; }
/// <summary> /// Overloaded method. /// </summary> /// <param name="operation">The operation to be used, e.g. modulate (multiply), add, subtract.</param> public void SetAlphaOperation( LayerBlendOperationEx operation ) { SetAlphaOperation( operation, LayerBlendSource.Texture, LayerBlendSource.Current, 1.0f, 1.0f, 0.0f ); }
/// <summary> /// Sets the alpha operation to be applied to this texture. /// </summary> /// <remarks> /// This works in exactly the same way as SetColorOperation, except /// that the effect is applied to the level of alpha (i.e. transparency) /// of the texture rather than its color. When the alpha of a texel (a pixel /// on a texture) is 1.0, it is opaque, wheras it is fully transparent if the /// alpha is 0.0. Please refer to the SetColorOperation method for more info. /// </remarks> /// <param name="operation">The operation to be used, e.g. modulate (multiply), add, subtract.</param> /// <param name="source1">The source of the first alpha value to the operation e.g. texture alpha.</param> /// <param name="source2">The source of the second alpha value to the operation e.g. current surface alpha.</param> /// <param name="arg1">Manually supplied alpha value (only required if source1 = LayerBlendSource.Manual).</param> /// <param name="arg2">Manually supplied alpha value (only required if source2 = LayerBlendSource.Manual).</param> /// <param name="blendFactor">Manually supplied 'blend' value - only required for operations /// which require manual blend e.g. LayerBlendOperationEx.BlendManual. /// </param> public void SetAlphaOperation( LayerBlendOperationEx operation, LayerBlendSource source1, LayerBlendSource source2, Real arg1, Real arg2, Real blendFactor ) { this.alphaBlendMode.operation = operation; this.alphaBlendMode.source1 = source1; this.alphaBlendMode.source2 = source2; this.alphaBlendMode.alphaArg1 = arg1; this.alphaBlendMode.alphaArg2 = arg2; this.alphaBlendMode.blendFactor = blendFactor; }
/// <summary> /// Overloaded method. /// </summary> /// <param name="operation">The operation to be used, e.g. modulate (multiply), add, subtract.</param> /// <param name="source1">The source of the first color to the operation e.g. texture color.</param> /// <param name="source2">The source of the second color to the operation e.g. current surface color.</param> /// <param name="arg1">Manually supplied color value (only required if source1 = Manual).</param> public void SetColorOperationEx( LayerBlendOperationEx operation, LayerBlendSource source1, LayerBlendSource source2, ColorEx arg1 ) { SetColorOperationEx( operation, source1, source2, arg1, ColorEx.White, 0.0f ); }
/// <summary> /// Overloaded method. /// </summary> /// <param name="operation">The operation to be used, e.g. modulate (multiply), add, subtract.</param> public void SetColorOperationEx( LayerBlendOperationEx operation ) { SetColorOperationEx( operation, LayerBlendSource.Texture, LayerBlendSource.Current, ColorEx.White, ColorEx.White, 0.0f ); }
/// <summary> /// For setting advanced blending options. /// </summary> /// <remarks> /// This is an extended version of the <see cref="TextureUnitState.SetColorOperation"/> method which allows /// extremely detailed control over the blending applied between this and earlier layers. /// See the IMPORTANT note below about the issues between mulitpass and multitexturing that /// using this method can create. /// <p/> /// Texture color operations determine how the final color of the surface appears when /// rendered. Texture units are used to combine color values from various sources (ie. the /// diffuse color of the surface from lighting calculations, combined with the color of /// the texture). This method allows you to specify the 'operation' to be used, ie. the /// calculation such as adds or multiplies, and which values to use as arguments, such as /// a fixed value or a value from a previous calculation. /// <p/> /// The defaults for each layer are: /// <ul> /// <li>op = Modulate</li> /// <li>source1 = Texture</li> /// <li>source2 = Current</li> /// </ul> /// ie. each layer takes the color results of the previous layer, and multiplies them /// with the new texture being applied. Bear in mind that colors are RGB values from /// 0.0 - 1.0 so multiplying them together will result in values in the same range, /// 'tinted' by the multiply. Note however that a straight multiply normally has the /// effect of darkening the textures - for this reason there are brightening operations /// like ModulateX2. See the LayerBlendOperation and LayerBlendSource enumerated /// types for full details. /// <p/> /// Because of the limitations on some underlying APIs (Direct3D included) /// the Texture argument can only be used as the first argument, not the second. /// <p/> /// The final 3 parameters are only required if you decide to pass values manually /// into the operation, i.e. you want one or more of the inputs to the color calculation /// to come from a fixed value that you supply. Hence you only need to fill these in if /// you supply <code>Manual</code> to the corresponding source, or use the /// <code>BlendManual</code> operation. /// <p/> /// The engine tries to use multitexturing hardware to blend texture layers /// together. However, if it runs out of texturing units (e.g. 2 of a GeForce2, 4 on a /// GeForce3) it has to fall back on multipass rendering, i.e. rendering the same object /// multiple times with different textures. This is both less efficient and there is a smaller /// range of blending operations which can be performed. For this reason, if you use this method /// you MUST also call <see cref="TextureUnitState.SetColorOpMultipassFallback"/> to specify which effect you /// want to fall back on if sufficient hardware is not available. /// <p/> /// If you wish to avoid having to do this, use the simpler <see cref="TextureUnitState.SetColorOperation"/> method /// which allows less flexible blending options but sets up the multipass fallback automatically, /// since it only allows operations which have direct multipass equivalents. /// <p/> /// This has no effect in the programmable pipeline. /// </remarks> /// <param name="operation">The operation to be used, e.g. modulate (multiply), add, subtract.</param> /// <param name="source1">The source of the first color to the operation e.g. texture color.</param> /// <param name="source2">The source of the second color to the operation e.g. current surface color.</param> /// <param name="arg1">Manually supplied color value (only required if source1 = Manual).</param> /// <param name="arg2">Manually supplied color value (only required if source2 = Manual)</param> /// <param name="blendFactor"> /// Manually supplied 'blend' value - only required for operations /// which require manual blend e.g. LayerBlendOperationEx.BlendManual /// </param> public void SetColorOperationEx( LayerBlendOperationEx operation, LayerBlendSource source1, LayerBlendSource source2, ColorEx arg1, ColorEx arg2, float blendFactor ) { this.colorBlendMode.operation = operation; this.colorBlendMode.source1 = source1; this.colorBlendMode.source2 = source2; this.colorBlendMode.colorArg1 = arg1; this.colorBlendMode.colorArg2 = arg2; this.colorBlendMode.blendFactor = blendFactor; }
/// <summary> /// Overloaded method. /// </summary> public void SetAlphaOperation(LayerBlendOperationEx operation, LayerBlendSource source1, LayerBlendSource source2) { SetAlphaOperation(operation, source1, source2, 1.0f, 1.0f, 0.0f); }
/// <summary> /// Sets the alpha operation to be applied to this texture. /// </summary> /// <remarks> /// This works in exactly the same way as SetColorOperation, except /// that the effect is applied to the level of alpha (i.e. transparency) /// of the texture rather than its color. When the alpha of a texel (a pixel /// on a texture) is 1.0, it is opaque, wheras it is fully transparent if the /// alpha is 0.0. Please refer to the SetColorOperation method for more info. /// </remarks> /// <param name="operation">The operation to be used, e.g. modulate (multiply), add, subtract.</param> /// <param name="source1">The source of the first alpha value to the operation e.g. texture alpha.</param> /// <param name="source2">The source of the second alpha value to the operation e.g. current surface alpha.</param> /// <param name="arg1">Manually supplied alpha value (only required if source1 = LayerBlendSource.Manual).</param> /// <param name="arg2">Manually supplied alpha value (only required if source2 = LayerBlendSource.Manual).</param> /// <param name="blendFactor">Manually supplied 'blend' value - only required for operations /// which require manual blend e.g. LayerBlendOperationEx.BlendManual. /// </param> public void SetAlphaOperation(LayerBlendOperationEx operation, LayerBlendSource source1, LayerBlendSource source2, float arg1, float arg2, float blendFactor) { alphaBlendMode.operation = operation; alphaBlendMode.source1 = source1; alphaBlendMode.source2 = source2; alphaBlendMode.alphaArg1 = arg1; alphaBlendMode.alphaArg2 = arg2; alphaBlendMode.blendFactor = blendFactor; }
/// <summary> /// Static method for converting LayerBlendOperationEx enum values to the Direct3D /// TextureOperation enum. /// </summary> /// <param name="blendop"></param> /// <returns></returns> public static BlendFunction Convert( LayerBlendOperationEx blendop ) { BlendFunction xnaTexOp = 0; // figure out what is what switch ( blendop ) { //case LayerBlendOperationEx.Source1: // xnaTexOp = BlendFunction.SelectArg1; // break; //case LayerBlendOperationEx.Source2: // xnaTexOp = BlendFunction.SelectArg2; // break; //case LayerBlendOperationEx.Modulate: // xnaTexOp = BlendFunction.moXFG.TextureOperation.Modulate; // break; //case LayerBlendOperationEx.ModulateX2: // xnaTexOp = BlendFunction.Modulate2X; // break; //case LayerBlendOperationEx.ModulateX4: // xnaTexOp = BlendFunction.Modulate4X; // break; case LayerBlendOperationEx.Add: xnaTexOp = BlendFunction.Add; break; case LayerBlendOperationEx.AddSigned: xnaTexOp = BlendFunction.Add; break; case LayerBlendOperationEx.AddSmooth: xnaTexOp = BlendFunction.Add; break; case LayerBlendOperationEx.Subtract: xnaTexOp = BlendFunction.Subtract; break; //case LayerBlendOperationEx.BlendDiffuseAlpha: // xnaTexOp = BlendFunction.BlendDiffuseAlpha; // break; //case LayerBlendOperationEx.BlendTextureAlpha: // xnaTexOp = BlendFunction.BlendTextureAlpha; // break; //case LayerBlendOperationEx.BlendCurrentAlpha: // xnaTexOp = BlendFunction.BlendCurrentAlpha; // break; //case LayerBlendOperationEx.BlendManual: // xnaTexOp = BlendFunction.BlendFactorAlpha; // break; //case LayerBlendOperationEx.DotProduct: // if ( Root.Instance.RenderSystem.Capabilities.HasCapability( Capabilities.Dot3 )) // xnaTexOp = BlendFunction.DotProduct3; // else // xnaTexOp = BlendFunction.Modulate; // break; default: xnaTexOp = BlendFunction.Add; break; } // end switch return xnaTexOp; }
/// <summary> /// Static method for converting LayerBlendOperationEx enum values to the Direct3D /// TextureOperation enum. /// </summary> /// <param name="blendop"></param> /// <returns></returns> public static D3D.TextureOperation ConvertEnum(LayerBlendOperationEx blendop, D3D.Caps devCaps) { D3D.TextureOperation d3dTexOp = 0; // figure out what is what switch (blendop) { case LayerBlendOperationEx.Source1: d3dTexOp = D3D.TextureOperation.SelectArg1; break; case LayerBlendOperationEx.Source2: d3dTexOp = D3D.TextureOperation.SelectArg2; break; case LayerBlendOperationEx.Modulate: d3dTexOp = D3D.TextureOperation.Modulate; break; case LayerBlendOperationEx.ModulateX2: d3dTexOp = D3D.TextureOperation.Modulate2X; break; case LayerBlendOperationEx.ModulateX4: d3dTexOp = D3D.TextureOperation.Modulate4X; break; case LayerBlendOperationEx.Add: d3dTexOp = D3D.TextureOperation.Add; break; case LayerBlendOperationEx.AddSigned: d3dTexOp = D3D.TextureOperation.AddSigned; break; case LayerBlendOperationEx.AddSmooth: d3dTexOp = D3D.TextureOperation.AddSmooth; break; case LayerBlendOperationEx.Subtract: d3dTexOp = D3D.TextureOperation.Subtract; break; case LayerBlendOperationEx.BlendDiffuseAlpha: d3dTexOp = D3D.TextureOperation.BlendDiffuseAlpha; break; case LayerBlendOperationEx.BlendTextureAlpha: d3dTexOp = D3D.TextureOperation.BlendTextureAlpha; break; case LayerBlendOperationEx.BlendCurrentAlpha: d3dTexOp = D3D.TextureOperation.BlendCurrentAlpha; break; case LayerBlendOperationEx.BlendManual: d3dTexOp = D3D.TextureOperation.BlendFactorAlpha; break; case LayerBlendOperationEx.DotProduct: if (Root.Instance.RenderSystem.Caps.CheckCap(Capabilities.Dot3)) { d3dTexOp = D3D.TextureOperation.DotProduct3; } else { d3dTexOp = D3D.TextureOperation.Modulate; } break; case LayerBlendOperationEx.BlendDiffuseColor: if (devCaps.TextureOperationCaps.SupportsLerp) { d3dTexOp = D3D.TextureOperation.Lerp; } else { d3dTexOp = D3D.TextureOperation.Modulate; } break; } // end switch return(d3dTexOp); }
/// <summary> /// Static method for converting LayerBlendOperationEx enum values to the Direct3D /// TextureOperation enum. /// </summary> /// <param name="blendop"></param> /// <returns></returns> public static BlendFunction Convert(LayerBlendOperationEx blendop) { BlendFunction xnaTexOp = 0; // figure out what is what switch (blendop) { //case LayerBlendOperationEx.Source1: // xnaTexOp = BlendFunction.SelectArg1; // break; //case LayerBlendOperationEx.Source2: // xnaTexOp = BlendFunction.SelectArg2; // break; //case LayerBlendOperationEx.Modulate: // xnaTexOp = BlendFunction.moXFG.TextureOperation.Modulate; // break; //case LayerBlendOperationEx.ModulateX2: // xnaTexOp = BlendFunction.Modulate2X; // break; //case LayerBlendOperationEx.ModulateX4: // xnaTexOp = BlendFunction.Modulate4X; // break; case LayerBlendOperationEx.Add: xnaTexOp = BlendFunction.Add; break; case LayerBlendOperationEx.AddSigned: xnaTexOp = BlendFunction.Add; break; case LayerBlendOperationEx.AddSmooth: xnaTexOp = BlendFunction.Add; break; case LayerBlendOperationEx.Subtract: xnaTexOp = BlendFunction.Subtract; break; //case LayerBlendOperationEx.BlendDiffuseAlpha: // xnaTexOp = BlendFunction.BlendDiffuseAlpha; // break; //case LayerBlendOperationEx.BlendTextureAlpha: // xnaTexOp = BlendFunction.BlendTextureAlpha; // break; //case LayerBlendOperationEx.BlendCurrentAlpha: // xnaTexOp = BlendFunction.BlendCurrentAlpha; // break; //case LayerBlendOperationEx.BlendManual: // xnaTexOp = BlendFunction.BlendFactorAlpha; // break; //case LayerBlendOperationEx.DotProduct: // if ( Root.Instance.RenderSystem.Capabilities.HasCapability( Capabilities.Dot3 )) // xnaTexOp = BlendFunction.DotProduct3; // else // xnaTexOp = BlendFunction.Modulate; // break; default: xnaTexOp = BlendFunction.Add; break; } // end switch return(xnaTexOp); }