public void ColorRGBAF_Accessor()
{
float r = (float)NextComponent(1.0f);
float g = (float)NextComponent(1.0f);
float b = (float)NextComponent(1.0f);
float a = (float)NextComponent(1.0f);
ColorRGBAF v = new ColorRGBAF(r, g, b, a);
float c;
Assert.DoesNotThrow(() => c = v[0]);
Assert.DoesNotThrow(() => c = v[1]);
Assert.DoesNotThrow(() => c = v[2]);
Assert.DoesNotThrow(() => c = v[3]);
Assert.Throws <IndexOutOfRangeException>(() => c = v[+4]);
Assert.Throws <IndexOutOfRangeException>(() => c = v[-1]);
Assert.DoesNotThrow(() => v[0] = 1.0f);
Assert.DoesNotThrow(() => v[1] = 1.0f);
Assert.DoesNotThrow(() => v[2] = 1.0f);
Assert.DoesNotThrow(() => v[3] = 1.0f);
Assert.Throws <IndexOutOfRangeException>(() => v[+4] = 0.0f);
Assert.Throws <IndexOutOfRangeException>(() => v[-1] = 0.0f);
Assert.DoesNotThrow(() => v[3] = 0.0f);
Assert.DoesNotThrow(() => v[3] = 1.0f);
Assert.Throws <InvalidOperationException>(() => v[3] = -1.0f);
Assert.Throws <InvalidOperationException>(() => v[3] = +1.1f);
}
public ColorRGBA(ColorRGBAF c)
{
Red = c.Red;
Green = c.Green;
Blue = c.Blue;
Alpha = c.Alpha;
}
public void ColorRGBAF_OperatorInequality()
{
ColorRGBAF v = ColorRGBAF.ColorRed;
Assert.IsFalse(v != ColorRGBAF.ColorRed);
Assert.IsTrue(v != ColorRGBAF.ColorGreen);
}
/// <summary>
/// Draw a character sequence.
/// </summary>
/// <param name="ctx">
/// The <see cref="GraphicsContext"/> used for drawing.
/// </param>
/// <param name="modelview">
/// The <see cref="Matrix4x4"/> the model-view-projection matrix for the first character of <paramref name="s"/>.
/// </param>
/// <param name="color">
/// The <see cref="ColorRGBAF"/> that specifies the glyph color.
/// </param>
/// <param name="s">
/// A <see cref="String"/> that specifies the characters for be drawn.
/// </param>
public override void DrawString(GraphicsContext ctx, Matrix4x4 modelview, ColorRGBAF color, string s)
{
ModelMatrix charModel = new ModelMatrix(modelview);
ctx.Bind(_FontProgram);
_FontProgram.SetUniform(ctx, "glo_UniformColor", color);
foreach (char c in s)
{
Glyph glyph;
if (_Glyphs.TryGetValue(c, out glyph) == false)
{
continue;
}
if (glyph.ElementIndex >= 0)
{
// Set model-view
_FontProgram.SetUniform(ctx, "glo_ModelViewProjection", charModel);
// Rasterize it
_VertexArrays.Draw(ctx, _FontProgram, glyph.ElementIndex);
}
// Move next
charModel.Translate(glyph.GlyphSize.Width, 0.0f);
}
}
/// <summary>
/// Draw a character sequence.
/// </summary>
/// <param name="ctx">
/// The <see cref="GraphicsContext"/> used for drawing.
/// </param>
/// <param name="modelview">
/// The <see cref="Matrix4x4f"/> the model-view-projection matrix for the first character of <paramref name="s"/>.
/// </param>
/// <param name="color">
/// The <see cref="ColorRGBAF"/> that specifies the glyph color.
/// </param>
/// <param name="s">
/// A <see cref="String"/> that specifies the characters for be drawn.
/// </param>
public override void DrawString(GraphicsContext ctx, Matrix4x4f modelview, ColorRGBAF color, string s)
{
List <GlyphModelType> glyphsInstances = GetGlyphsInstances(modelview, s);
UpdateGlyphBuffer(ctx, glyphsInstances);
DrawStringCore(ctx, _FontTexture, color, glyphsInstances);
}
/// <summary>
/// Construct a Material with a specific diffuse color.
/// </summary>
/// <param name="diffuse"></param>
public Material(ColorRGBAF diffuse)
{
Ambient = ColorRGBAF.ColorBlack;
Emissive = ColorRGBAF.ColorBlack;
Diffuse = diffuse;
Specular = ColorRGBAF.ColorBlack;
Shininess = 32.0f;
}
public void ColorRGBAF_Equals_ColorRGBAF()
{
ColorRGBAF v = ColorRGBAF.ColorRed;
Assert.IsTrue(v.Equals(ColorRGBAF.ColorRed));
Assert.IsFalse(v.Equals(ColorRGBAF.ColorGreen));
Assert.IsFalse(v.Equals(ColorRGBAF.ColorBlue));
}
/// <summary>
/// Draw a character sequence.
/// </summary>
/// <param name="ctx">
/// The <see cref="GraphicsContext"/> used for drawing.
/// </param>
/// <param name="modelview">
/// The <see cref="Matrix4x4"/> the model-view-projection matrix for the first character of <paramref name="s"/>.
/// </param>
/// <param name="color">
/// The <see cref="ColorRGBAF"/> that specifies the glyph color.
/// </param>
/// <param name="s">
/// A <see cref="String"/> that specifies the characters for be drawn.
/// </param>
public override void DrawString(GraphicsContext ctx, Matrix4x4 modelview, ColorRGBAF color, string s)
{
ModelMatrix charModel = new ModelMatrix(modelview);
ctx.Bind(_FontProgram);
// Set uniforms
_FontProgram.SetUniform(ctx, "glo_UniformColor", color);
_FontProgram.SetUniform(ctx, "glo_FontGlyph", _FontTexture);
// Set instances
char[] fontChars = s.ToCharArray();
uint instances = 0;
_GlyphInstances.Map(ctx, BufferAccessARB.WriteOnly);
try {
for (int i = 0; i < fontChars.Length; i++)
{
Glyph glyph;
if (_GlyphDb.TryGetValue(fontChars[i], out glyph) == false)
{
continue;
}
// Set instance information
Matrix4x4f modelViewProjection = new Matrix4x4f(
new Vertex4f(charModel.GetColumn(0)),
new Vertex4f(charModel.GetColumn(1)),
new Vertex4f(charModel.GetColumn(2)),
new Vertex4f(charModel.GetColumn(3))
);
Vertex3f glyphVertexParams = new Vertex3f(
glyph.GlyphSize.Width, glyph.GlyphSize.Height,
glyph.Layer
);
Vertex2f glyphTexParams = new Vertex2f(
glyph.TexScale.Width, glyph.TexScale.Height
);
_GlyphInstances.SetElement(modelViewProjection, instances, 0);
_GlyphInstances.SetElement(glyphVertexParams, instances, 1);
_GlyphInstances.SetElement(glyphTexParams, instances, 2);
// Count the instance
instances++;
// Move next
charModel.Translate(glyph.GlyphSize.Width, 0.0f);
}
} finally {
_GlyphInstances.Unmap(ctx);
}
// Rasterize it
using (State.BlendState stateBlend = State.BlendState.AlphaBlending) {
stateBlend.ApplyState(ctx, _FontProgram);
_VertexArrays.DrawInstanced(ctx, _FontProgram, instances);
}
}
public void ColorRGBF_CastToRGBA()
{
float r = (float)NextComponent(1.0f);
float g = (float)NextComponent(1.0f);
float b = (float)NextComponent(1.0f);
ColorRGBF v = new ColorRGBF(r, g, b);
ColorRGBAF vRGBA = v;
}
public void ColorRGBAF_PixelType()
{
float r = (float)NextComponent(1.0f);
float g = (float)NextComponent(1.0f);
float b = (float)NextComponent(1.0f);
float a = (float)NextComponent(1.0f);
ColorRGBAF v = new ColorRGBAF(r, g, b, a);
Assert.AreNotEqual(PixelLayout.None, v.PixelType);
}
public void ColorRGBAF_GetHashCode()
{
float r = (float)NextComponent(float.MaxValue);
float g = (float)NextComponent(float.MaxValue);
float b = (float)NextComponent(float.MaxValue);
float a = (float)NextComponent(float.MaxValue);
ColorRGBAF v = new ColorRGBAF(r, g, b, a);
Assert.DoesNotThrow(() => v.GetHashCode());
}
public void ColorRGBAF_Equals_Object()
{
ColorRGBAF v = ColorRGBAF.ColorRed;
Assert.IsFalse(v.Equals(null));
Assert.IsFalse(v.Equals(String.Empty));
Assert.IsFalse(v.Equals(0.0f));
Assert.IsTrue(v.Equals((object)ColorRGBAF.ColorRed));
Assert.IsFalse(v.Equals((object)ColorRGBAF.ColorGreen));
Assert.IsFalse(v.Equals((object)ColorRGBAF.ColorBlue));
}
/// <summary>
/// Construct a BlendState with separated RGB/Alpha functions.
/// </summary>
/// <param name="rgbEquation">
/// A <see cref="BlendEquationModeEXT"/> flag indicating which equation to used for blending RGB color components.
/// </param>
/// <param name="alphaEquation">
/// A <see cref="BlendEquationModeEXT"/> flag indicating which equation to used for blending Alpha color component.
/// </param>
/// <param name="srcRgbFactor">
/// A <see cref="BlendingFactorSrc"/> that specify the scaling factors applied to the source color (alpha component excluded).
/// </param>
/// <param name="srcAlphaFactor">
/// A <see cref="BlendingFactorSrc"/> that specify the scaling factors applied to only the source alpha component.
/// </param>
/// <param name="dstRgbFactor">
/// A <see cref="BlendingFactorDest"/> that specify the scaling factors applied to the destination color (alpha component excluded).
/// </param>
/// <param name="dstAlphaFactor">
/// A <see cref="BlendingFactorDest"/> that specify the scaling factors applied to only the destination alpha component.
/// </param>
/// <param name="constColor">
/// A <see cref="ColorRGBAF"/> that specify the constant color used in blending functions.
/// </param>
public BlendState(BlendEquationModeEXT rgbEquation, BlendEquationModeEXT alphaEquation, BlendingFactorSrc srcRgbFactor, BlendingFactorSrc srcAlphaFactor, BlendingFactorDest dstRgbFactor, BlendingFactorDest dstAlphaFactor, ColorRGBAF constColor)
{
if (IsSupportedEquation(rgbEquation) == false)
{
throw new ArgumentException("not supported blending equation " + srcRgbFactor, "rgbEquation");
}
if (IsSupportedEquation(alphaEquation) == false)
{
throw new ArgumentException("not supported blending equation " + alphaEquation, "rgbEquation");
}
if (IsSupportedFunction(srcRgbFactor) == false)
{
throw new ArgumentException("not supported blending function " + srcRgbFactor, "srcRgbFactor");
}
if (IsSupportedFunction(srcAlphaFactor) == false)
{
throw new ArgumentException("not supported blending function " + srcAlphaFactor, "srcAlphaFactor");
}
if (IsSupportedFunction(dstRgbFactor) == false)
{
throw new ArgumentException("not supported blending function " + dstRgbFactor, "dstRgbFactor");
}
if (IsSupportedFunction(dstAlphaFactor) == false)
{
throw new ArgumentException("not supported blending function " + dstAlphaFactor, "dstAlphaFactor");
}
// Blend enabled
mEnabled = true;
// Store RGB separate equation
mRgbEquation = rgbEquation;
// Store alpha separate equation
mAlphaEquation = alphaEquation;
// Store rgb separate function
mRgbSrcFactor = srcRgbFactor;
mRgbDstFactor = dstRgbFactor;
// Store alpha separate function
mAlphaSrcFactor = srcAlphaFactor;
mAlphaDstFactor = dstAlphaFactor;
// Store blend color
mBlendColor = constColor;
if (EquationSeparated && !GraphicsContext.CurrentCaps.GlExtensions.BlendEquationSeparate_EXT)
{
throw new InvalidOperationException("not supported separated blending equations");
}
if (FunctionSeparated && !GraphicsContext.CurrentCaps.GlExtensions.BlendFuncSeparate_EXT)
{
throw new InvalidOperationException("not supported separated blending functions");
}
}
public void ColorRGBAF_TestConstructor1()
{
float r = (float)NextComponent(1.0f);
float g = (float)NextComponent(1.0f);
float b = (float)NextComponent(1.0f);
ColorRGBAF v = new ColorRGBAF(r, g, b);
Assert.AreEqual(r, v.r);
Assert.AreEqual(g, v.g);
Assert.AreEqual(b, v.b);
Assert.AreEqual(1.0f, v.a);
}
/// <summary>
/// Convert a <see cref="Single[]"/> to <see cref="ColorRGBAF[]"/>.
/// </summary>
/// <param name="array">
/// The <see cref="Single[]"/> to be converted.
/// </param>
/// <returns>
/// It returns the <see cref="ColorRGBAF[]"/> equivalent to <paramref name="array"/>.
/// </returns>
public static ColorRGBAF[] ToColorRGBAF(this float[] array)
{
int structArrayLength = array.Length / 4;
ColorRGBAF[] structArray = new ColorRGBAF[structArrayLength];
for (int i = 0, j = 0; i < structArrayLength; i++, j += 4)
{
structArray[i] = new ColorRGBAF(array[j + 0], array[j + 1], array[j + 2], array[j + 3]);
}
return(structArray);
}
public void ColorRGBF_CastToRGBA()
{
float r = (float)NextComponent(1.0f);
float g = (float)NextComponent(1.0f);
float b = (float)NextComponent(1.0f);
ColorRGBF v = new ColorRGBF(r, g, b);
ColorRGBAF vRGBA = v;
Assert.AreEqual(v.Red, vRGBA.Red);
Assert.AreEqual(v.Green, vRGBA.Green);
Assert.AreEqual(v.Blue, vRGBA.Blue);
Assert.AreEqual(1.0f, vRGBA.Alpha);
}
/// <summary>
/// Draw a character sequence.
/// </summary>
/// <param name="ctx">
/// The <see cref="GraphicsContext"/> used for drawing.
/// </param>
/// <param name="modelview">
/// The <see cref="Matrix4x4"/> the model-view-projection matrix for the first character of <paramref name="s"/>.
/// </param>
/// <param name="color">
/// The <see cref="ColorRGBAF"/> that specifies the glyph color.
/// </param>
/// <param name="s">
/// A <see cref="String"/> that specifies the characters for be drawn.
/// </param>
public override void DrawString(GraphicsContext ctx, Matrix4x4 modelview, ColorRGBAF color, string s)
{
// Draw the string
DrawStringCore(ctx, modelview, color, s);
// Shadow effect
if (_FxShadow != null)
{
ModelMatrix shadowModel = new ModelMatrix(modelview);
shadowModel.Translate(_FxShadow.Offset);
DrawStringCore(ctx, shadowModel, _FxShadow.Color, s);
}
}
/// <summary>
/// Draw a character sequence (base method).
/// </summary>
/// <param name="ctx">
/// The <see cref="GraphicsContext"/> used for drawing.
/// </param>
/// <param name="color">
/// The <see cref="ColorRGBAF"/> that specifies the glyph color.
/// </param>
/// <param name="s">
/// A <see cref="String"/> that specifies the characters for be drawn.
/// </param>
private void DrawStringCore(GraphicsContext ctx, TextureArray2d texture, ColorRGBAF color, List <GlyphModelType> glyphInstances)
{
if (ctx.Extensions.InstancedArrays)
{
DrawStringCore_InstancedArrays(ctx, texture, color, glyphInstances);
}
else if (ctx.Extensions.DrawInstanced_ARB)
{
DrawStringCore_Instanced(ctx, texture, color, glyphInstances);
}
else
{
DrawStringCore_Compatibility(ctx, texture, color, glyphInstances);
}
}
public void ColorRGBAF_CastToVertex4()
{
float r = (float)NextComponent(1.0f);
float g = (float)NextComponent(1.0f);
float b = (float)NextComponent(1.0f);
float a = (float)NextComponent(1.0f);
ColorRGBAF v = new ColorRGBAF(r, g, b, a);
Vertex4f vArray = v;
Assert.AreEqual(r, vArray.x);
Assert.AreEqual(g, vArray.y);
Assert.AreEqual(b, vArray.z);
Assert.AreEqual(a, vArray.w);
}
public void ColorRGBAF_TestConstructor2()
{
Random random = new Random();
float r = (float)NextComponent(random, 1.0f);
float g = (float)NextComponent(random, 1.0f);
float b = (float)NextComponent(random, 1.0f);
float a = (float)NextComponent(random, 1.0f);
ColorRGBAF v = new ColorRGBAF(r, g, b, a);
Assert.AreEqual(r, v.r);
Assert.AreEqual(g, v.g);
Assert.AreEqual(b, v.b);
Assert.AreEqual(a, v.a);
}
public void ColorRGBAF_CastToArray()
{
float r = (float)NextComponent(1.0f);
float g = (float)NextComponent(1.0f);
float b = (float)NextComponent(1.0f);
float a = (float)NextComponent(1.0f);
ColorRGBAF v = new ColorRGBAF(r, g, b, a);
float[] vArray = v;
Assert.AreEqual(4, vArray.Length);
Assert.AreEqual(r, vArray[0]);
Assert.AreEqual(g, vArray[1]);
Assert.AreEqual(b, vArray[2]);
Assert.AreEqual(a, vArray[3]);
}
public void ColorRGBAF_Multiply()
{
float r = (float)NextComponent(1.0f);
float g = (float)NextComponent(1.0f);
float b = (float)NextComponent(1.0f);
float a = (float)NextComponent(1.0f);
ColorRGBAF v = new ColorRGBAF(r, g, b, a);
ColorRGBAF c = v * 0.5f;
c = c * 2.0f;
Assert.AreEqual(c.r, v.r, 1.0);
Assert.AreEqual(c.g, v.g, 1.0);
Assert.AreEqual(c.b, v.b, 1.0);
Assert.AreEqual(c.a, v.a, 1.0);
}
public void ColorRGBAF_CastFromColor()
{
const double Epsilon = 1e-2;
double r = NextComponent(1.0);
double g = NextComponent(1.0);
double b = NextComponent(1.0);
double a = NextComponent(1.0);
Color c = Color.FromArgb((int)(a * byte.MaxValue), (int)(r * byte.MaxValue), (int)(g * byte.MaxValue), (int)(b * byte.MaxValue));
ColorRGBAF v = (ColorRGBAF)c;
Assert.AreEqual((float)r, v[0], Epsilon);
Assert.AreEqual((float)g, v[1], Epsilon);
Assert.AreEqual((float)b, v[2], Epsilon);
Assert.AreEqual((float)a, v[3], Epsilon);
}
/// <summary>
/// Merge this state with another one.
/// </summary>
/// <param name="state">
/// A <see cref="IGraphicsState"/> having the same <see cref="StateIdentifier"/> of this state.
/// </param>
public override void Merge(IGraphicsState state)
{
if (state == null)
{
throw new ArgumentNullException("state");
}
BlendState otherState = state as BlendState;
if (otherState == null)
{
throw new ArgumentException("not a BlendState", "state");
}
mEnabled = otherState.mEnabled;
mRgbEquation = otherState.mRgbEquation;
mAlphaEquation = otherState.mAlphaEquation;
mRgbSrcFactor = otherState.mRgbSrcFactor;
mAlphaSrcFactor = otherState.mAlphaSrcFactor;
mRgbDstFactor = otherState.mRgbDstFactor;
mAlphaDstFactor = otherState.mAlphaDstFactor;
mBlendColor = otherState.mBlendColor;
}
/// <summary>
/// Set the color used for clearing this GraphicsSurface color buffer.
/// </summary>
/// <param name="color">
/// A <see cref="ColorRGBAF"/> which holds the RGBA values used for clearing
/// this GraphicsSurface color buffer.
/// </param>
public void SetClearColor(ColorRGBAF color)
{
// Store clear color
mClearColor = color;
}
/// <summary>
/// Set uniform state variable (variant type variable)
/// </summary>
/// <param name="ctx">
/// A <see cref="GraphicsContext"/> used for operations.
/// </param>
/// <param name="uniformName">
/// A <see cref="String"/> that specify the variable name in the shader source.
/// </param>
/// <param name="v">
/// A <see cref="ColorRGBAF"/> holding the uniform variabile data.
/// </param>
public void SetVariantUniform(GraphicsContext ctx, string uniformName, ColorRGBAF v)
{
SetVariantUniform(ctx, uniformName, v.r, v.g, v.b, v.a);
}
/// <summary>
/// Set the color used for clearing this GraphicsSurface color buffer.
/// </summary>
/// <param name="color">
/// A <see cref="ColorRGBAF"/> which holds the RGBA values used for clearing
/// this GraphicsSurface color buffer.
/// </param>
public void SetClearColor(ColorRGBAF color)
{
// Store clear color
mClearColor = color;
}
/// <summary>
/// Draw a character sequence.
/// </summary>
/// <param name="ctx">
/// The <see cref="GraphicsContext"/> used for drawing.
/// </param>
/// <param name="modelview">
/// The <see cref="Matrix4x4"/> the model-view-projection matrix for the first character of <paramref name="s"/>.
/// </param>
/// <param name="color">
/// The <see cref="ColorRGBAF"/> that specifies the glyph color.
/// </param>
/// <param name="s">
/// A <see cref="String"/> that specifies the characters for be drawn.
/// </param>
private void DrawStringCore(GraphicsContext ctx, Matrix4x4 modelview, ColorRGBAF color, string s)
{
ModelMatrix charModel = new ModelMatrix(modelview);
ctx.Bind(_FontProgram);
_FontProgram.SetUniform(ctx, "glo_UniformColor", color);
if (ctx.Extensions.ShaderDrawParameters_ARB)
{
List <VertexArrayObject.IElement> glyphElements = new List <VertexArrayObject.IElement>();
int drawInstanceId = 0;
foreach (char c in s)
{
Glyph glyph;
if (_Glyphs.TryGetValue(c, out glyph) == false)
{
continue;
}
if (glyph.ElementIndex >= 0)
{
// Collect draw instance element
glyphElements.Add(_VertexArrays.GetElementArray(glyph.ElementIndex));
// Set model-view
_FontProgram.SetUniform(ctx, "glo_CharModelViewProjection[" + drawInstanceId + "]", charModel);
// Next instance
drawInstanceId++;
}
// Move next
charModel.Translate(glyph.GlyphSize.Width, 0.0f);
}
// Draw using Multi-Draw primitive
VertexArrayObject.IElement multiElement = _VertexArrays.CombineArrayElements(glyphElements);
_VertexArrays.Draw(ctx, _FontProgram, multiElement);
}
else
{
foreach (char c in s)
{
Glyph glyph;
if (_Glyphs.TryGetValue(c, out glyph) == false)
{
continue;
}
if (glyph.ElementIndex >= 0)
{
// Set model-view
_FontProgram.SetUniform(ctx, "glo_ModelViewProjection", charModel);
// Rasterize it
_VertexArrays.Draw(ctx, _FontProgram, glyph.ElementIndex);
}
// Move next
charModel.Translate(glyph.GlyphSize.Width, 0.0f);
}
}
}
/// <summary>
/// Construct a BlendState with separated RGB/Alpha functions.
/// </summary>
/// <param name="rgbEquation">
/// A <see cref="BlendEquationModeEXT"/> flag indicating which equation to used for blending RGB color components.
/// </param>
/// <param name="alphaEquation">
/// A <see cref="BlendEquationModeEXT"/> flag indicating which equation to used for blending Alpha color component.
/// </param>
/// <param name="srcRgbFactor">
/// A <see cref="BlendingFactorSrc"/> that specify the scaling factors applied to the source color (alpha component excluded).
/// </param>
/// <param name="srcAlphaFactor">
/// A <see cref="BlendingFactorSrc"/> that specify the scaling factors applied to only the source alpha component.
/// </param>
/// <param name="dstRgbFactor">
/// A <see cref="BlendingFactorDest"/> that specify the scaling factors applied to the destination color (alpha component excluded).
/// </param>
/// <param name="dstAlphaFactor">
/// A <see cref="BlendingFactorDest"/> that specify the scaling factors applied to only the destination alpha component.
/// </param>
/// <param name="constColor">
/// A <see cref="ColorRGBAF"/> that specify the constant color used in blending functions.
/// </param>
public BlendState(BlendEquationModeEXT rgbEquation, BlendEquationModeEXT alphaEquation, BlendingFactorSrc srcRgbFactor, BlendingFactorSrc srcAlphaFactor, BlendingFactorDest dstRgbFactor, BlendingFactorDest dstAlphaFactor, ColorRGBAF constColor)
{
if (IsSupportedEquation(rgbEquation) == false)
throw new ArgumentException("not supported blending equation " + srcRgbFactor, "rgbEquation");
if (IsSupportedEquation(alphaEquation) == false)
throw new ArgumentException("not supported blending equation " + alphaEquation, "rgbEquation");
if (IsSupportedFunction(srcRgbFactor) == false)
throw new ArgumentException("not supported blending function " + srcRgbFactor, "srcRgbFactor");
if (IsSupportedFunction(srcAlphaFactor) == false)
throw new ArgumentException("not supported blending function " + srcAlphaFactor, "srcAlphaFactor");
if (IsSupportedFunction(dstRgbFactor) == false)
throw new ArgumentException("not supported blending function " + dstRgbFactor, "dstRgbFactor");
if (IsSupportedFunction(dstAlphaFactor) == false)
throw new ArgumentException("not supported blending function " + dstAlphaFactor, "dstAlphaFactor");
// Blend enabled
mEnabled = true;
// Store RGB separate equation
mRgbEquation = rgbEquation;
// Store alpha separate equation
mAlphaEquation = alphaEquation;
// Store rgb separate function
mRgbSrcFactor = srcRgbFactor;
mRgbDstFactor = dstRgbFactor;
// Store alpha separate function
mAlphaSrcFactor = srcAlphaFactor;
mAlphaDstFactor = dstAlphaFactor;
// Store blend color
mBlendColor = constColor;
if (EquationSeparated && !GraphicsContext.CurrentCaps.GlExtensions.BlendEquationSeparate_EXT)
throw new InvalidOperationException("not supported separated blending equations");
if (FunctionSeparated && !GraphicsContext.CurrentCaps.GlExtensions.BlendFuncSeparate_EXT)
throw new InvalidOperationException("not supported separated blending functions");
}
/// <summary>
/// Construct the current BlendState.
/// </summary>
/// <param name="ctx">
/// A <see cref="GraphicsContext"/> defining this GraphicsState.
/// </param>
public BlendState(GraphicsContext ctx)
{
if (ctx == null)
throw new ArgumentNullException("ctx");
int blendRgbEquation, blendAlphaEquation;
int blendRgbSrcFunct, blendAlphaSrcFunct;
int blendRgbDstFunct, blendAlphaDstFunct;
// Blend enabled
mEnabled = Gl.IsEnabled(EnableCap.Blend);
if (ctx.Caps.GlExtensions.BlendEquationSeparate_EXT) {
// Blend equation (RGB)
Gl.Get(Gl.BLEND_EQUATION_RGB, out blendRgbEquation);
// Blend equation (Alpha)
Gl.Get(Gl.BLEND_EQUATION_ALPHA, out blendAlphaEquation);
} else {
if (ctx.Caps.GlExtensions.BlendMinmax_EXT) {
// Blend equation (RGBA)
Gl.Get(GetPName.BlendEquation, out blendRgbEquation);
// Alpha equation is the same for RGB!
blendAlphaEquation = blendRgbEquation;
} else {
blendRgbEquation = blendAlphaEquation = (int)BlendEquationModeEXT.FuncAdd;
}
}
if (ctx.Caps.GlExtensions.BlendFuncSeparate_EXT) {
// Blend source function (RGB)
Gl.Get(Gl.BLEND_SRC_RGB, out blendRgbSrcFunct);
// Blend source function (Alpha)
Gl.Get(Gl.BLEND_SRC_ALPHA, out blendAlphaSrcFunct);
// Blend destination function (RGB)
Gl.Get(Gl.BLEND_DST_RGB, out blendRgbDstFunct);
// Blend destination function (Alpha)
Gl.Get(Gl.BLEND_DST_ALPHA, out blendAlphaDstFunct);
} else {
// Blend source function (RGBA)
Gl.Get(GetPName.BlendSrc, out blendRgbSrcFunct);
blendAlphaSrcFunct = blendRgbSrcFunct;
// Blend destination function (RGBA)
Gl.Get(GetPName.BlendDst, out blendRgbDstFunct);
blendAlphaDstFunct = blendRgbDstFunct;
}
// Store blending equation
mRgbEquation = (BlendEquationModeEXT)blendRgbEquation;
mAlphaEquation = (BlendEquationModeEXT)blendAlphaEquation;
// Store blending function
mRgbSrcFactor = (BlendingFactorSrc)blendRgbSrcFunct;
mAlphaSrcFactor = (BlendingFactorSrc)blendAlphaSrcFunct;
mRgbDstFactor = (BlendingFactorDest)blendRgbDstFunct;
mAlphaDstFactor = (BlendingFactorDest)blendAlphaDstFunct;
// Store blend color
if (ctx.Caps.GlExtensions.BlendColor_EXT) {
float[] blendColor = new float[4];
Gl.Get(GetPName.BlendColor, blendColor);
mBlendColor = new ColorRGBAF(blendColor[0], blendColor[1], blendColor[2], blendColor[3]);
}
}
/// <summary>
/// Merge this state with another one.
/// </summary>
/// <param name="state">
/// A <see cref="IGraphicsState"/> having the same <see cref="StateIdentifier"/> of this state.
/// </param>
public override void Merge(IGraphicsState state)
{
if (state == null)
throw new ArgumentNullException("state");
BlendState otherState = state as BlendState;
if (otherState == null)
throw new ArgumentException("not a BlendState", "state");
mEnabled = otherState.mEnabled;
mRgbEquation = otherState.mRgbEquation;
mAlphaEquation = otherState.mAlphaEquation;
mRgbSrcFactor = otherState.mRgbSrcFactor;
mAlphaSrcFactor = otherState.mAlphaSrcFactor;
mRgbDstFactor = otherState.mRgbDstFactor;
mAlphaDstFactor = otherState.mAlphaDstFactor;
mBlendColor = otherState.mBlendColor;
}
/// <summary>
/// Construct a BlendState with unified RGB/Alpha function.
/// </summary>
/// <param name="equation">
/// A <see cref="BlendEquationModeEXT"/> flag indicating which equation to used for blending.
/// </param>
/// <param name="srcFactor">
/// A <see cref="BlendingFactorSrc"/> that specify the scaling factors applied to the source color (including alpha).
/// </param>
/// <param name="dstFactor">
/// A <see cref="BlendingFactorDest"/> that specify the scaling factors applied to the destination color (including alpha).
/// </param>
/// <param name="constColor">
/// A <see cref="ColorRGBAF"/> that specify the constant color used in blending functions.
/// </param>
public BlendState(BlendEquationModeEXT equation, BlendingFactorSrc srcFactor, BlendingFactorDest dstFactor, ColorRGBAF constColor)
: this(equation, equation, srcFactor, srcFactor, dstFactor, dstFactor, constColor)
{
}
/// <summary>
/// Set uniform state variable (variant type variable)
/// </summary>
/// <param name="ctx">
/// A <see cref="GraphicsContext"/> used for operations.
/// </param>
/// <param name="uniformName">
/// A <see cref="String"/> that specify the variable name in the shader source.
/// </param>
/// <param name="v">
/// A <see cref="ColorRGBAF"/> holding the uniform variabile data.
/// </param>
public void SetVariantUniform(GraphicsContext ctx, string uniformName, ColorRGBAF v)
{
SetVariantUniform(ctx, uniformName, v.Red, v.Green, v.Blue, v.Alpha);
}
/// <summary>
/// Draw a character sequence (base method).
/// </summary>
/// <param name="ctx">
/// The <see cref="GraphicsContext"/> used for drawing.
/// </param>
/// <param name="color">
/// The <see cref="ColorRGBAF"/> that specifies the glyph color.
/// </param>
/// <param name="s">
/// A <see cref="String"/> that specifies the characters for be drawn.
/// </param>
private void DrawStringCore_InstancedArrays(GraphicsContext ctx, TextureArray2d texture, ColorRGBAF color, List <GlyphModelType> glyphInstances)
{
ctx.Bind(_FontProgram);
// Set uniforms
_FontProgram.SetUniform(ctx, "glo_UniformColor", color);
_FontProgram.SetUniform(ctx, "glo_FontGlyph", texture);
// Rasterize it
State.BlendState.AlphaBlending.Apply(ctx, _FontProgram);
_VertexArrays.DrawInstanced(ctx, _FontProgram, (uint)glyphInstances.Count);
}
/// <summary>
/// Draw a character sequence (base method).
/// </summary>
/// <param name="ctx">
/// The <see cref="GraphicsContext"/> used for drawing.
/// </param>
/// <param name="modelview">
/// The <see cref="Matrix4x4"/> the model-view-projection matrix for the first character of <paramref name="s"/>.
/// </param>
/// <param name="color">
/// The <see cref="ColorRGBAF"/> that specifies the glyph color.
/// </param>
/// <param name="s">
/// A <see cref="String"/> that specifies the characters for be drawn.
/// </param>
private void DrawStringCore_Instanced(GraphicsContext ctx, TextureArray2d texture, ColorRGBAF color, List <GlyphModelType> glyphsInstances)
{
ctx.Bind(_FontProgram);
// Set uniforms
_FontProgram.SetUniform(ctx, "glo_UniformColor", color);
_FontProgram.SetUniform(ctx, "glo_FontGlyph", texture);
// Set instances
if (_GlyphUniformBuffer == null)
{
// Set instances
for (int i = 0; i < glyphsInstances.Count; i++)
{
string structName = "glo_Glyphs[" + i + "]";
_FontProgram.SetUniform(ctx, structName + ".ModelViewProjection", glyphsInstances[i].ModelViewProjection);
_FontProgram.SetUniform(ctx, structName + ".VertexParams", glyphsInstances[i].VertexParams);
_FontProgram.SetUniform(ctx, structName + ".TexParams", glyphsInstances[i].TexParams);
}
}
else
{
// Bind uniform block
// Note: already updated by DrawString
_FontProgram.SetUniformBlock(ctx, "Glyphs", _GlyphUniformBuffer);
}
// Rasterize it
State.BlendState.AlphaBlending.Apply(ctx, _FontProgram);
_VertexArrays.DrawInstanced(ctx, _FontProgram, (uint)glyphsInstances.Count);
}
/// <summary>
/// Draw a character sequence (base method).
/// </summary>
/// <param name="ctx">
/// The <see cref="GraphicsContext"/> used for drawing.
/// </param>
/// <param name="color">
/// The <see cref="ColorRGBAF"/> that specifies the glyph color.
/// </param>
/// <param name="s">
/// A <see cref="String"/> that specifies the characters for be drawn.
/// </param>
private void DrawStringCore_Compatibility(GraphicsContext ctx, TextureArray2d texture, ColorRGBAF color, List <GlyphModelType> glyphsInstances)
{
ctx.Bind(_FontProgram);
// Set uniforms
_FontProgram.SetUniform(ctx, "glo_UniformColor", color);
_FontProgram.SetUniform(ctx, "glo_FontGlyph", texture);
// Rasterize it
State.BlendState.AlphaBlending.Apply(ctx, _FontProgram);
for (int i = 0; i < glyphsInstances.Count; i++)
{
_FontProgram.SetUniform(ctx, "glo_ModelViewProjection", glyphsInstances[i].ModelViewProjection);
_FontProgram.SetUniform(ctx, "glo_VertexParams", glyphsInstances[i].VertexParams);
_FontProgram.SetUniform(ctx, "glo_TexParams", glyphsInstances[i].TexParams);
_VertexArrays.Draw(ctx, _FontProgram);
}
}
/// <summary>
/// Set uniform state variable (variant type variable)
/// </summary>
/// <param name="ctx">
/// A <see cref="GraphicsContext"/> used for operations.
/// </param>
/// <param name="uniformName">
/// A <see cref="String"/> that specify the variable name in the shader source.
/// </param>
/// <param name="v">
/// A <see cref="ColorRGBAF"/> holding the uniform variabile data.
/// </param>
public void SetVariantUniform(GraphicsContext ctx, string uniformName, ColorRGBAF v)
{
SetVariantUniform(ctx, uniformName, v.Red, v.Green, v.Blue, v.Alpha);
}
