/// <summary>
/// Changes the way alpha and color values are stored.
/// Optionally, all existing vertices are updated.
/// </summary>
public void SetPremultipliedAlpha(bool value, bool updateVertices)
{
if (value == _premultipliedAlpha)
{
return;
}
if (updateVertices)
{
if (value)
{
for (int i = 0; i < _numVertices; ++i)
{
_vertexColors[i] = VertexColorHelper.PremultiplyAlpha(_vertexColors[i]);
}
}
else
{
for (int i = 0; i < _numVertices; ++i)
{
_vertexColors[i] = VertexColorHelper.UnmultiplyAlpha(_vertexColors[i]);
}
}
}
_premultipliedAlpha = value;
}
/// <summary>
/// Multiplies a range of alpha values with a certain factor.
/// </summary>
public void ScaleAlphas(float factor, int index, int numVertices)
{
if (index < 0 || index >= _numVertices)
{
throw new IndexOutOfRangeException("Invalid vertex index");
}
if (factor == 1.0f)
{
return;
}
int minAlpha = _premultipliedAlpha ? (int)(MinAlpha * 255.0f) : 0;
for (int i = index; i < index + numVertices; ++i)
{
VertexColor vertexColor = _vertexColors[i];
byte newAlpha = Convert.ToByte(MathUtil.Clamp(vertexColor.A * factor, minAlpha, 255));
if (_premultipliedAlpha)
{
vertexColor = VertexColorHelper.UnmultiplyAlpha(vertexColor);
vertexColor.A = newAlpha;
_vertexColors[i] = VertexColorHelper.PremultiplyAlpha(vertexColor);
}
else
{
_vertexColors[i] = VertexColorHelper.CreateVertexColor(vertexColor.R, vertexColor.G, vertexColor.B, newAlpha);
}
}
}
public void TestScaleAlphaWithoutPMA()
{
VertexData vertexData = new VertexData(1);
vertexData.SetColor(ColorUtil.GetRGB(80, 60, 40), 128 / 255.0f);
vertexData.ScaleAlphaBy(0.5f);
CompareVertexColor(VertexColorHelper.CreateVertexColor(80, 60, 40, 64), vertexData.VertexColors[0]);
}
/// <summary>
/// Updates the color of a vertex. The method always expects non-premultiplied alpha values.
/// </summary>
public void SetColor(int atIndex, uint color, float alpha)
{
if (atIndex < 0 || atIndex >= _numVertices)
{
throw new IndexOutOfRangeException("Invalid vertex index");
}
alpha = MathUtil.Clamp(alpha, _premultipliedAlpha ? MinAlpha : 0.0f, 1.0f);
VertexColor vertexColor = VertexColorHelper.CreateVertexColor(color, alpha);
_vertexColors[atIndex] = _premultipliedAlpha ? VertexColorHelper.PremultiplyAlpha(vertexColor) : vertexColor;
}
public void TestScaleAlphaWithPMA()
{
VertexData vertexData = new VertexData(1, true);
vertexData.SetColor(ColorUtil.GetRGB(80, 60, 40), 204 / 255.0f);
vertexData.ScaleAlphaBy(0.8f);
CompareVertexColor(VertexColorHelper.CreateVertexColor(
(byte)(80 * 0.64f + 0.5f),
(byte)(60 * 0.64f + 0.5f),
(byte)(40 * 0.64f + 0.5f),
(byte)(204 * 0.8f + 0.5f)), vertexData.VertexColors[0]);
}
public void TestPremultipliedAlpha()
{
VertexData vertexData = new VertexData(1);
vertexData.SetColor(ColorUtil.GetRGB(80, 60, 40), 204 / 255.0f);
vertexData.SetPremultipliedAlpha(true, true);
CompareVertexColor(VertexColorHelper.CreateVertexColor(64, 48, 32, 204), vertexData.VertexColors[0]);
vertexData.SetPremultipliedAlpha(false, true);
CompareVertexColor(VertexColorHelper.CreateVertexColor(80, 60, 40, 204), vertexData.VertexColors[0]);
}
public static VertexColor UnmultiplyAlpha(VertexColor color)
{
float alpha = color.A / 255.0f;
if (alpha == 0.0f || alpha == 1.0f)
{
return(color);
}
// 0.5f is added to prevent rounding issues, see
// http://stackoverflow.com/questions/25703304/why-does-a-division-result-differ-based-on-the-cast-type
return(VertexColorHelper.CreateVertexColor(
(byte)(color.R / alpha + 0.5f),
(byte)(color.G / alpha + 0.5f),
(byte)(color.B / alpha + 0.5f),
color.A));
}
/// <summary>
/// Writes the given RGB and alpha values to the specified vertices.
/// </summary>
public void Colorize(uint color, float alpha, int vertexId, int numVertices)
{
if (numVertices < 0 || vertexId + numVertices > _numVertices)
{
numVertices = _numVertices - vertexId;
}
alpha = MathUtil.Clamp(alpha, _premultipliedAlpha ? MinAlpha : 0.0f, 1.0f);
VertexColor vertexColor = VertexColorHelper.CreateVertexColor(color, alpha);
VertexColor col = _premultipliedAlpha ? VertexColorHelper.PremultiplyAlpha(vertexColor) : vertexColor;
for (int i = vertexId; i < numVertices; i++)
{
_vertexColors[i] = col;
}
}
/// <summary>
/// Returns the RGB color of a vertex (without premultiplied alpha).
/// </summary>
public uint GetColor(int index)
{
if (index < 0 || index >= _numVertices)
{
throw new IndexOutOfRangeException("Invalid vertex index");
}
VertexColor vertexColor = _vertexColors[index];
if (_premultipliedAlpha)
{
vertexColor = VertexColorHelper.UnmultiplyAlpha(vertexColor);
}
return(ColorUtil.GetRGB(vertexColor.R, vertexColor.G, vertexColor.B));
}
public static VertexColor PremultiplyAlpha(VertexColor color)
{
float alpha = color.A / 255.0f;
if (alpha == 1.0f)
{
return(color);
}
else
{
return(VertexColorHelper.CreateVertexColor(
(byte)(color.R * alpha + 0.5f),
(byte)(color.G * alpha + 0.5f),
(byte)(color.B * alpha + 0.5f),
color.A));
}
}
protected void Init(float width = 32, float height = 32, uint color = 0xffffff, bool premultipliedAlpha = false)
{
if (width <= MIN_SIZE)
{
width = MIN_SIZE;
}
if (height <= MIN_SIZE)
{
height = MIN_SIZE;
}
_color = color;
_vertexData = new VertexData(4, premultipliedAlpha);
_vertexData.Vertices[1].Position.X = width;
_vertexData.Vertices[2].Position.Y = height;
_vertexData.Vertices[3].Position.X = width;
_vertexData.Vertices[3].Position.Y = height;
for (int i = 0; i < 4; ++i)
{
_vertexData.VertexColors[i] = VertexColorHelper.CreateVertexColor(color, 1.0f);
}
VertexDataDidChange();
}
