/// <summary>
/// Merge this state set with another one.
/// </summary>
/// <param name="stateSet">
/// A <see cref="GraphicsStateSet"/> to be merged with this GraphicsStateSet.
/// </param>
/// <remarks>
/// <para>
/// After a call to this routine, this GraphicsStateSet store the union of the previous information
/// and of the information of <paramref name="stateSet"/>.
/// </para>
/// <para>
/// The semantic of the merge result is dependent by each <see cref="IGraphicsState"/> defined in both
/// state sets.
/// </para>
/// <para>
/// In the case a kind of GraphicsState is defined only in this GraphicsStateSet, the specific state remains
/// unchanged, except when the state is not inheritable; in this case the specific state will be undefined.
/// </para>
/// <para>
/// In the case a kind of GraphicsState is defined only in <paramref name="stateSet"/>, that state will be
/// defined equally in this GraphicsStateSet.
/// </para>
/// <para>
/// In the case a kind of GraphicsState is defined by both state sets, the state defined in this GraphicsStateSet
/// will be merged with the one defined in <paramref name="stateSet"/>, by calling <see cref="IGraphicsState.Merge"/>.
/// </para>
/// </remarks>
public void Merge(GraphicsStateSet stateSet)
{
if (stateSet == null)
{
throw new ArgumentNullException("stateSet");
}
List <IGraphicsState> thisSetStates = new List <IGraphicsState>(States);
// Merge states defined by stateSet
foreach (GraphicsState state in thisSetStates)
{
IGraphicsState otherState = stateSet[state.StateIdentifier];
if (otherState != null)
{
state.Merge(otherState);
}
}
// Include states not defined by this
foreach (GraphicsState state in stateSet.States)
{
if (IsDefinedState(state.StateIdentifier) == false)
{
DefineState(state.Copy());
}
}
}
/// <summary>
/// Factory method for getting the current render state set.
/// </summary>
/// <param name="ctx">
/// A <see cref="GraphicsContext"/> defining the state vector.
/// </param>
/// <returns>
/// It returns a GraphicsStateSet representing the currently active state vector.
/// </returns>
public static GraphicsStateSet GetCurrentStateSet(GraphicsContext ctx)
{
if (ctx == null)
{
throw new ArgumentNullException("ctx");
}
if (ctx.IsCurrent == false)
{
throw new ArgumentException("not current", "ctx");
}
GraphicsStateSet renderStateSet = new GraphicsStateSet();
// Instantiate all context-bound states
renderStateSet.DefineState(new PolygonModeState(ctx));
renderStateSet.DefineState(new BlendState(ctx));
renderStateSet.DefineState(new DepthTestState(ctx));
renderStateSet.DefineState(new CullFaceState(ctx));
renderStateSet.DefineState(new RenderBufferState(ctx));
renderStateSet.DefineState(new ViewportState(ctx));
renderStateSet.DefineState(new TransformState(ctx));
sLog.Verbose("Detected current state set:");
foreach (KeyValuePair <string, IGraphicsState> pair in renderStateSet._RenderStates)
{
sLog.Verbose(pair.Value.ToString());
}
return(renderStateSet);
}
/// <summary>
/// Construct a GraphicsStateSetStack representing the current state.
/// </summary>
/// <param name="ctx">
/// A <see cref="GraphicsContext"/> to query the state.
/// </param>
public GraphicsStateSetStack(GraphicsContext ctx)
{
GraphicsStateSet defaultSet = GraphicsStateSet.GetCurrentStateSet(ctx);
// Avoid a disposition of this state set
defaultSet.IncRef();
// The stack always defines a current state
mStateSetStack.AddLast(defaultSet);
}
/// <summary>
/// Construct a GraphicsStateSetStack.
/// </summary>
public GraphicsStateSetStack()
{
GraphicsStateSet defaultSet = GraphicsStateSet.GetDefaultSet();
// Avoid a disposition of this state set
defaultSet.IncRef();
// The stack always defines a current state
_StateSetStack.AddLast(defaultSet);
}
/// <summary>
/// Clone this GraphicsStateSet.
/// </summary>
/// <returns>
/// It returns a deep copy of this GraphicsStateSet.
/// </returns>
public GraphicsStateSet Copy()
{
GraphicsStateSet clone = new GraphicsStateSet();
foreach (KeyValuePair <string, IGraphicsState> pair in mRenderStates)
{
clone.mRenderStates.Add(pair.Key, pair.Value.Copy());
}
return(clone);
}
/// <summary>
/// Clone this GraphicsStateSet.
/// </summary>
/// <returns>
/// It returns a deep copy of this GraphicsStateSet.
/// </returns>
public GraphicsStateSet Copy()
{
GraphicsStateSet clone = new GraphicsStateSet();
foreach (KeyValuePair <string, IGraphicsState> pair in _RenderStates)
{
clone.DefineState(pair.Value.Copy());
}
return(clone);
}
/// <summary>
/// Push a copy of the current state set onto the stack.
/// </summary>
public void Push()
{
if (IsDisposed)
{
throw new ObjectDisposedException("GraphicsStateSetStack");
}
GraphicsStateSet currentStateSetCopy = Current.Copy();
// Avoid a disposition of this state set
currentStateSetCopy.IncRef();
// Set the copy as the current state set
mStateSetStack.AddLast(currentStateSetCopy);
}
/// <summary>
/// Push a copy of the current state set onto the stack.
/// </summary>
/// <param name="mergedState">
/// A <see cref="GraphicsStateSet"/> to be merged on current render state set after having pushed it
/// onto the stack.
/// </param>
public void Push(GraphicsStateSet mergedState)
{
if (IsDisposed)
{
throw new ObjectDisposedException("GraphicsStateSetStack");
}
if (mergedState == null)
{
throw new ArgumentNullException("mergedState");
}
// Push the current state onto the stack
Push();
// Merge current state with the specified one
Current.Merge(mergedState);
}
/// <summary>
/// Factory method for getting the default render state set.
/// </summary>
/// <returns>
/// It returns a GraphicsStateSet representing the default state set.
/// </returns>
public static GraphicsStateSet GetDefaultSet()
{
GraphicsStateSet renderStateSet = new GraphicsStateSet();
// Instantiate all context-bound states
renderStateSet.DefineState(UniformColorState.DefaultState);
renderStateSet.DefineState(PolygonModeState.DefaultState);
renderStateSet.DefineState(TransformState.DefaultState);
renderStateSet.DefineState(BlendState.DefaultState);
renderStateSet.DefineState(DepthTestState.DefaultState);
renderStateSet.DefineState(CullFaceState.DefaultState);
renderStateSet.DefineState(RenderBufferState.DefaultState);
renderStateSet.DefineState(ViewportState.DefaultState);
return (renderStateSet);
}
/// <summary>
/// Factory method for getting the default render state set.
/// </summary>
/// <returns>
/// It returns a GraphicsStateSet representing the default state set.
/// </returns>
public static GraphicsStateSet GetDefaultSet()
{
GraphicsStateSet renderStateSet = new GraphicsStateSet();
// Instantiate all context-bound states
renderStateSet.DefineState(UniformColorState.DefaultState);
renderStateSet.DefineState(TransformState.DefaultState);
//renderStateSet.DefineState(PolygonModeState.DefaultState);
//renderStateSet.DefineState(BlendState.DefaultState);
//renderStateSet.DefineState(DepthTestState.DefaultState);
//renderStateSet.DefineState(CullFaceState.DefaultState);
//renderStateSet.DefineState(RenderBufferState.DefaultState);
//renderStateSet.DefineState(ViewportState.DefaultState);
return(renderStateSet);
}
/// <summary>
/// Pop the current state on top of the stack.
/// </summary>
public void Pop()
{
if (IsDisposed)
{
throw new ObjectDisposedException("GraphicsStateSetStack");
}
if (mStateSetStack.Count == 1)
{
throw new InvalidOperationException("stack underflow");
}
GraphicsStateSet currentStateSet = Current;
// Possibly dispose this state set
currentStateSet.DecRef();
// Restore previous state set
mStateSetStack.RemoveLast();
}
/// <summary>
/// Apply the set of GraphicsState collected by this instance.
/// </summary>
/// <param name="ctx">
/// A <see cref="GraphicsContext"/> defining the state vector.
/// </param>
/// <param name="program">
/// A <see cref="ShaderProgram"/> defining the uniform state.
/// </param>
/// <param name="currentStateSet">
///
/// </param>
private void Apply(GraphicsContext ctx, ShaderProgram program, GraphicsStateSet currentStateSet)
{
if (ctx == null)
{
throw new ArgumentNullException("ctx");
}
// Reset texture unit state
if (program != null)
{
program.ResetTextureUnits();
}
// Apply known states
foreach (KeyValuePair <string, IGraphicsState> pair in mRenderStates)
{
IGraphicsState state = pair.Value;
if (state.IsContextBound && (currentStateSet != null) && (currentStateSet.IsDefinedState(state.StateIdentifier)))
{
IGraphicsState currentState = currentStateSet[state.StateIdentifier];
if (currentState.Inheritable && state.Equals(currentState))
{
continue;
}
}
// Apply state if the state is context-bound, or a shader is currently in use
if ((program != null) || (state.IsContextBound))
{
state.ApplyState(ctx, program);
}
}
// Apply custom states, if any
foreach (GraphicsState customState in mCustomStates)
{
if ((program != null) || (customState.IsContextBound))
{
customState.ApplyState(ctx, program);
}
}
}
/// <summary>
/// Merge this state set with another one.
/// </summary>
/// <param name="stateSet">
/// A <see cref="GraphicsStateSet"/> to be merged with this GraphicsStateSet.
/// </param>
/// <remarks>
/// <para>
/// After a call to this routine, this GraphicsStateSet store the union of the previous information
/// and of the information of <paramref name="stateSet"/>.
/// </para>
/// <para>
/// The semantic of the merge result is dependent by each <see cref="IGraphicsState"/> defined in both
/// state sets.
/// </para>
/// <para>
/// In the case a kind of GraphicsState is defined only in this GraphicsStateSet, the specific state remains
/// unchanged, except when the state is not inheritable; in this case the specific state will be undefined.
/// </para>
/// <para>
/// In the case a kind of GraphicsState is defined only in <paramref name="stateSet"/>, that state will be
/// defined equally in this GraphicsStateSet.
/// </para>
/// <para>
/// In the case a kind of GraphicsState is defined by both state sets, the state defined in this GraphicsStateSet
/// will be merged with the one defined in <paramref name="stateSet"/>, by calling <see cref="IGraphicsState.Merge"/>.
/// </para>
/// </remarks>
public void Merge(GraphicsStateSet stateSet)
{
if (stateSet == null)
{
throw new ArgumentNullException("stateSet");
}
List <IGraphicsState> thisSetStates = new List <IGraphicsState>(States);
// Merge states defined by stateSet
foreach (GraphicsState state in thisSetStates)
{
IGraphicsState otherState = stateSet[state.StateIdentifier];
if (state.Inheritable == false)
{
// Do not include non-inheritable states
UndefineState(state.StateIdentifier);
// Include merged state, if defined
if (otherState != null)
{
DefineState(otherState);
}
}
else
{
if (otherState != null)
{
state.Merge(otherState);
}
}
}
// Include states not defined by this
foreach (GraphicsState state in stateSet.States)
{
if (IsDefinedState(state.StateIdentifier) == false)
{
DefineState(state);
}
}
}
/// <summary>
/// Construct a Technique.
/// </summary>
/// <param name="vertexArray">
/// The vertex array feeding data to the GPU pipeline.
/// </param>
/// <param name="shaderProgram">
/// Shader program used for drawing. If it is null, it is assumed that the OpenGL
/// fixed pipeline program is used.
/// </param>
/// <param name="stateSet">
/// The graphics state set applied before the technique is executed.
/// </param>
/// <exception cref="ArgumentNullException">
/// Exception thrown if <paramref name="vertexArray"/> is null.
/// </exception>
public Technique(VertexArrayObject vertexArray, ShaderProgram shaderProgram, State.GraphicsStateSet stateSet)
{
if (vertexArray == null)
{
throw new ArgumentNullException("vertexArray");
}
VertexArray = vertexArray;
Program = shaderProgram;
StateSet = stateSet;
LinkResource(vertexArray);
if (shaderProgram != null)
{
LinkResource(shaderProgram);
}
if (stateSet != null)
{
LinkResource(stateSet);
}
}
/// <summary>
/// Merge this GraphicsStateSet with a current state.
/// </summary>
/// <param name="ctx">
/// A <see cref="GraphicsContext"/> defining the state vector.
/// </param>
/// <param name="program">
/// A <see cref="ShaderProgram"/> defining the uniform state.
/// </param>
/// <param name="currentStateSet">
///
/// </param>
/// <returns></returns>
internal GraphicsStateSet Merge(GraphicsContext ctx, ShaderProgram program, GraphicsStateSet currentStateSet)
{
GraphicsStateSet mergedState = new GraphicsStateSet();
if (ctx == null)
{
throw new ArgumentNullException("ctx");
}
if (currentStateSet == null)
{
throw new ArgumentNullException("currentStateSet");
}
// Apply most recent states
foreach (KeyValuePair <string, IGraphicsState> pair in _RenderStates)
{
mergedState.DefineState(pair.Value.Copy());
}
// Keep inherited states
foreach (KeyValuePair <string, IGraphicsState> pair in currentStateSet._RenderStates)
{
IGraphicsState state = pair.Value;
if (mergedState.IsDefinedState(state.StateIdentifier) == false)
{
mergedState.DefineState(state.Copy());
}
else
{
mergedState[state.StateIdentifier].Merge(state);
}
}
mergedState.Apply(ctx, program);
return(mergedState);
}
/// <summary>
/// Apply the set of GraphicsState collected by this instance.
/// </summary>
/// <param name="ctx">
/// A <see cref="GraphicsContext"/> defining the state vector.
/// </param>
/// <param name="program">
/// A <see cref="ShaderProgram"/> defining the uniform state.
/// </param>
/// <param name="currentStateSet">
///
/// </param>
private void Apply(GraphicsContext ctx, ShaderProgram program, GraphicsStateSet currentStateSet)
{
if (ctx == null)
{
throw new ArgumentNullException("ctx");
}
// Reset texture unit state
if (program != null)
{
program.ResetTextureUnits();
}
// Apply known states
foreach (KeyValuePair <string, IGraphicsState> pair in _RenderStates)
{
IGraphicsState state = pair.Value;
if (state.IsContextBound && (currentStateSet != null) && (currentStateSet.IsDefinedState(state.StateIdentifier)))
{
IGraphicsState currentState = currentStateSet[state.StateIdentifier];
if (state.Equals(currentState))
{
continue;
}
}
// Apply state if:
// - the state is context-bound, or
// - the state is program-bound and a shader program is currently in use
if (state.IsContextBound || (state.IsShaderProgramBound && program != null))
{
state.ApplyState(ctx, program);
}
}
}
/// <summary>
/// Factory method for getting the current render state set.
/// </summary>
/// <param name="ctx">
/// A <see cref="GraphicsContext"/> defining the state vector.
/// </param>
/// <returns>
/// It returns a GraphicsStateSet representing the currently active state vector.
/// </returns>
public static GraphicsStateSet GetCurrentStateSet(GraphicsContext ctx)
{
if (ctx == null)
throw new ArgumentNullException("ctx");
if (ctx.IsCurrent == false)
throw new ArgumentException("not current", "ctx");
GraphicsStateSet renderStateSet = new GraphicsStateSet();
// Instantiate all context-bound states
renderStateSet.DefineState(new PolygonModeState(ctx));
renderStateSet.DefineState(new BlendState(ctx));
renderStateSet.DefineState(new DepthTestState(ctx));
renderStateSet.DefineState(new CullFaceState(ctx));
renderStateSet.DefineState(new RenderBufferState(ctx));
renderStateSet.DefineState(new ViewportState(ctx));
renderStateSet.DefineState(new TransformState(ctx));
sLog.Verbose("Detected current state set:");
foreach (KeyValuePair<string, IGraphicsState> pair in renderStateSet.mRenderStates)
sLog.Verbose(pair.Value.ToString());
return (renderStateSet);
}
/// <summary>
/// Apply the set of GraphicsState collected by this instance.
/// </summary>
/// <param name="ctx">
/// A <see cref="GraphicsContext"/> defining the state vector.
/// </param>
/// <param name="program">
/// A <see cref="ShaderProgram"/> defining the uniform state.
/// </param>
/// <param name="currentStateSet">
///
/// </param>
private void Apply(GraphicsContext ctx, ShaderProgram program, GraphicsStateSet currentStateSet)
{
if (ctx == null)
throw new ArgumentNullException("ctx");
// Reset texture unit state
if (program != null)
program.ResetTextureUnits();
// Apply known states
foreach (KeyValuePair<string, IGraphicsState> pair in mRenderStates) {
IGraphicsState state = pair.Value;
if (state.IsContextBound && (currentStateSet != null) && (currentStateSet.IsDefinedState(state.StateIdentifier))) {
IGraphicsState currentState = currentStateSet[state.StateIdentifier];
if (currentState.Inheritable && state.Equals(currentState))
continue;
}
// Apply state if the state is context-bound, or a shader is currently in use
if ((program != null) || (state.IsContextBound))
state.ApplyState(ctx, program);
}
// Apply custom states, if any
foreach (GraphicsState customState in mCustomStates) {
if ((program != null) || (customState.IsContextBound))
customState.ApplyState(ctx, program);
}
}
/// <summary>
/// Merge this GraphicsStateSet with a current state.
/// </summary>
/// <param name="ctx">
/// A <see cref="GraphicsContext"/> defining the state vector.
/// </param>
/// <param name="program">
/// A <see cref="ShaderProgram"/> defining the uniform state.
/// </param>
/// <param name="currentStateSet">
///
/// </param>
/// <returns></returns>
internal GraphicsStateSet Merge(GraphicsContext ctx, ShaderProgram program, GraphicsStateSet currentStateSet)
{
GraphicsStateSet mergedState = new GraphicsStateSet();
if (ctx == null)
throw new ArgumentNullException("ctx");
if (currentStateSet == null)
throw new ArgumentNullException("currentStateSet");
// Apply most recent states
foreach (KeyValuePair<string, IGraphicsState> pair in mRenderStates)
mergedState.DefineState(pair.Value.Copy());
// Keep inherited states
foreach (KeyValuePair<string, IGraphicsState> pair in currentStateSet.mRenderStates) {
IGraphicsState state = pair.Value;
if (mergedState.IsDefinedState(state.StateIdentifier) == false)
mergedState.DefineState(state.Copy());
else
mergedState[state.StateIdentifier].Merge(state);
}
mergedState.Apply(ctx, program);
return (mergedState);
}
/// <summary>
/// Clone this GraphicsStateSet.
/// </summary>
/// <returns>
/// It returns a deep copy of this GraphicsStateSet.
/// </returns>
public GraphicsStateSet Copy()
{
GraphicsStateSet clone = new GraphicsStateSet();
foreach (KeyValuePair<string, IGraphicsState> pair in mRenderStates)
clone.mRenderStates.Add(pair.Key, pair.Value.Copy());
return (clone);
}
/// <summary>
/// Merge this state set with another one.
/// </summary>
/// <param name="stateSet">
/// A <see cref="GraphicsStateSet"/> to be merged with this GraphicsStateSet.
/// </param>
/// <remarks>
/// <para>
/// After a call to this routine, this GraphicsStateSet store the union of the previous information
/// and of the information of <paramref name="stateSet"/>.
/// </para>
/// <para>
/// The semantic of the merge result is dependent by each <see cref="IGraphicsState"/> defined in both
/// state sets.
/// </para>
/// <para>
/// In the case a kind of GraphicsState is defined only in this GraphicsStateSet, the specific state remains
/// unchanged, except when the state is not inheritable; in this case the specific state will be undefined.
/// </para>
/// <para>
/// In the case a kind of GraphicsState is defined only in <paramref name="stateSet"/>, that state will be
/// defined equally in this GraphicsStateSet.
/// </para>
/// <para>
/// In the case a kind of GraphicsState is defined by both state sets, the state defined in this GraphicsStateSet
/// will be merged with the one defined in <paramref name="stateSet"/>, by calling <see cref="IGraphicsState.Merge"/>.
/// </para>
/// </remarks>
public void Merge(GraphicsStateSet stateSet)
{
if (stateSet == null)
throw new ArgumentNullException("stateSet");
List<IGraphicsState> thisSetStates = new List<IGraphicsState>(States);
// Merge states defined by stateSet
foreach (GraphicsState state in thisSetStates) {
IGraphicsState otherState = stateSet[state.StateIdentifier];
if (state.Inheritable == false) {
// Do not include non-inheritable states
UndefineState(state.StateIdentifier);
// Include merged state, if defined
if (otherState != null)
DefineState(otherState);
} else {
if (otherState != null)
state.Merge(otherState);
}
}
// Include states not defined by this
foreach (GraphicsState state in stateSet.States)
if (IsDefinedState(state.StateIdentifier) == false)
DefineState(state);
}
/// <summary>
/// Push a copy of the current state set onto the stack.
/// </summary>
/// <param name="mergedState">
/// A <see cref="GraphicsStateSet"/> to be merged on current render state set after having pushed it
/// onto the stack.
/// </param>
public void Push(GraphicsStateSet mergedState)
{
if (IsDisposed)
throw new ObjectDisposedException("GraphicsStateSetStack");
if (mergedState == null)
throw new ArgumentNullException("mergedState");
// Push the current state onto the stack
Push();
// Merge current state with the specified one
Current.Merge(mergedState);
}