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 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 abstract void SemiDotHLine(CompareFunction cmp, int xc1, int yc1, int xc2, int yc2, int x1, int y1, int x2);
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)
{
}
