public void ClonedStructShouldBeIdentical()
{
var original = new CustomMouseEffect(Color.Red);
var clone = original.Clone();
Assert.That(clone, Is.EqualTo(original));
}
public void ShouldHaveDifferentHashCodesOnDifferentInstances()
{
var a = CustomMouseEffect.Create();
var b = CustomMouseEffect.Create();
Assert.AreNotEqual(a.GetHashCode(), b.GetHashCode());
}
public void ShouldSetCorrectColorWithLedIndexer()
{
var effect = CustomMouseEffect.Create();
effect[GridLed.Logo] = Color.Red;
Assert.AreEqual(Color.Red, effect[GridLed.Logo]);
}
public void ShouldSetCorrectColorWithIndexIndexer()
{
var effect = CustomMouseEffect.Create();
effect[5] = Color.Red;
Assert.AreEqual(Color.Red, effect[5]);
}
public void ShouldConstructProperMultiArray()
{
var effect = CustomMouseEffect.Create();
effect[2, 2] = Color.Red;
var array = effect.ToMultiArray();
Assert.AreEqual(Color.Red, array[2, 2]);
}
public static CustomMouseEffect Combine(this CustomMouseEffect mouse, Color c, double cPct = 0.5)
{
for (var i = 0; i < MouseConstants.MaxLeds; i++)
{
mouse[i] = mouse[i].Combine(c, cPct);
}
return(mouse);
}
public static CustomMouseEffect Max(this CustomMouseEffect mouse, Color c)
{
for (var i = 0; i < MouseConstants.MaxLeds; i++)
{
mouse[i] = mouse[i].Max(c);
}
return(mouse);
}
public void ClonedStructShouldBeIndependent()
{
var original = new CustomMouseEffect(Color.Red);
var clone = original.Clone();
clone.Set(Color.Blue);
Assert.That(clone, Is.Not.EqualTo(original));
}
public void ShouldEqualIdenticalEffect()
{
var a = new CustomMouseEffect(Color.Red);
var b = new CustomMouseEffect(Color.Red);
Assert.True(a == b);
Assert.False(a != b);
Assert.True(a.Equals(b));
Assert.AreEqual(a, b);
}
public void ShouldNotEqual1DArrayWithInvalidSize()
{
var grid = CustomMouseEffect.Create();
var arr = new Color[2];
Assert.False(grid == arr);
Assert.True(grid != arr);
Assert.False(grid.Equals(arr));
Assert.AreNotEqual(grid, arr);
}
public void ShouldNotEqualArbitraryObject()
{
var effect = CustomMouseEffect.Create();
var obj = new object();
Assert.False(effect == obj);
Assert.True(effect != obj);
Assert.False(effect.Equals(obj));
Assert.AreNotEqual(effect, obj);
}
public void ShouldNotEqualDifferentEffect()
{
var a = new CustomMouseEffect(Color.Red);
var b = new CustomMouseEffect(Color.Blue);
Assert.False(a == b);
Assert.True(a != b);
Assert.False(a.Equals(b));
Assert.AreNotEqual(a, b);
}
public void ShouldNotEqual2DArrayWithInvalidRowCount()
{
var effect = CustomMouseEffect.Create();
var array = new Color[1][];
Assert.False(effect == array);
Assert.True(effect != array);
Assert.False(effect.Equals(array));
Assert.AreNotEqual(effect, array);
}
public void ShouldConstructFromColor()
{
var effect = new CustomMouseEffect(Color.Red);
for (var row = 0; row < MouseConstants.MaxRows; row++)
{
for (var column = 0; column < MouseConstants.MaxColumns; column++)
{
Assert.AreEqual(Color.Red, effect[row, column]);
}
}
}
public void ShouldCreateWithAllBlackColors()
{
var effect = CustomMouseEffect.Create();
for (var row = 0; row < MouseConstants.MaxRows; row++)
{
for (var column = 0; column < MouseConstants.MaxColumns; column++)
{
Assert.AreEqual(Color.Black, effect[row, column]);
}
}
}
public void ShouldNotEqual2DArrayWithInvalidColumnCount()
{
var effect = CustomMouseEffect.Create();
var array = new Color[MouseConstants.MaxRows][];
array[0] = new Color[1];
Assert.False(effect == array);
Assert.True(effect != array);
Assert.False(effect.Equals(array));
Assert.AreNotEqual(effect, array);
}
public void ShouldSetCorrectColorWithSet()
{
var effect = CustomMouseEffect.Create();
effect.Set(Color.Red);
for (var row = 0; row < MouseConstants.MaxRows; row++)
{
for (var column = 0; column < MouseConstants.MaxColumns; column++)
{
Assert.AreEqual(Color.Red, effect[row, column]);
}
}
}
public async Task ApplyAsync(IVirtualLedGrid virtualGrid, CancellationToken cancellationToken = default)
{
var keyboardGrid = CustomKeyboardEffect.Create();
var mouseGrid = CustomMouseEffect.Create();
var mousepadGrid = CustomMousepadEffect.Create();
var headsetGrid = CustomHeadsetEffect.Create();
var chromaLinkGrid = CustomChromaLinkEffect.Create();
foreach (var k in virtualGrid)
{
switch (k.Type)
{
case KeyType.Invalid:
break;
case KeyType.Keyboard:
var kbVal = (Key)Enum.Parse(typeof(Key), k.FriendlyName);
keyboardGrid[kbVal] = ToColoreColor(k.Color);
break;
case KeyType.Mouse:
var mouseVal = (GridLed)Enum.Parse(typeof(GridLed), k.FriendlyName);
mouseGrid[mouseVal] = ToColoreColor(k.Color);
break;
case KeyType.Mousepad:
mousepadGrid[k.KeyCode] = ToColoreColor(k.Color);
break;
case KeyType.Headset:
headsetGrid[k.KeyCode] = ToColoreColor(k.Color);
break;
case KeyType.ChromaLink:
chromaLinkGrid[k.KeyCode] = ToColoreColor(k.Color);
break;
}
}
await this._chromaInterface.Keyboard.SetCustomAsync(keyboardGrid);
await this._chromaInterface.Mouse.SetGridAsync(mouseGrid);
await this._chromaInterface.Mousepad.SetCustomAsync(mousepadGrid);
await this._chromaInterface.Headset.SetCustomAsync(headsetGrid);
await this._chromaInterface.ChromaLink.SetCustomAsync(chromaLinkGrid);
}
public void ShouldNotEqualDifferent1DArray()
{
var grid = new CustomMouseEffect(Color.Pink);
var arr = new Color[MouseConstants.MaxLeds];
for (var index = 0; index < MouseConstants.MaxLeds; index++)
{
arr[index] = Color.Red;
}
Assert.False(grid == arr);
Assert.True(grid != arr);
Assert.False(grid.Equals(arr));
Assert.AreNotEqual(grid, arr);
}
public void ShouldConstructFrom1DArray()
{
var arr = new Color[MouseConstants.MaxLeds];
arr[2] = Color.Pink;
arr[4] = Color.Red;
arr[8] = Color.Blue;
var grid = new CustomMouseEffect(arr);
for (var index = 0; index < MouseConstants.MaxLeds; index++)
{
Assert.That(grid[index], Is.EqualTo(arr[index]));
}
}
public override Task ApplyAsync(IVirtualLedGrid virtualGrid, CancellationToken cancellationToken = default)
{
if (!this.Initialized)
{
return(Task.CompletedTask);
}
var mouseGrid = CustomMouseEffect.Create();
for (var row = 0; row < virtualGrid.RowCount; row++)
{
for (var col = 0; col < virtualGrid.ColumnCount; col++)
{
mouseGrid[row, col] = ToColoreColor(virtualGrid[col, row]);
}
}
return(this.ChromaInterface !.Mouse.SetGridAsync(mouseGrid));
}
public void ShouldThrowWhenOutOfRange1DSet()
{
var grid = CustomMouseEffect.Create();
Assert.That(
() => grid[-1] = Color.Red,
Throws.InstanceOf <ArgumentOutOfRangeException>()
.With.Property("ParamName")
.EqualTo("index")
.And.Property("ActualValue")
.EqualTo(-1));
Assert.That(
() => grid[MouseConstants.MaxLeds] = Color.Red,
Throws.InstanceOf <ArgumentOutOfRangeException>()
.With.Property("ParamName")
.EqualTo("index")
.And.Property("ActualValue")
.EqualTo(MouseConstants.MaxLeds));
}
public void ShouldNotEqualDifferent2DArray()
{
var effect = new CustomMouseEffect(Color.Red);
var array = new Color[MouseConstants.MaxRows][];
for (var row = 0; row < MouseConstants.MaxRows; row++)
{
array[row] = new Color[MouseConstants.MaxColumns];
for (var column = 0; column < MouseConstants.MaxColumns; column++)
{
array[row][column] = Color.Blue;
}
}
Assert.False(effect == array);
Assert.True(effect != array);
Assert.False(effect.Equals(array));
Assert.AreNotEqual(effect, array);
}
public void ShouldThrowWhenOutOfRange2DGet()
{
var effect = CustomMouseEffect.Create();
// ReSharper disable once NotAccessedVariable
Color dummy;
Assert.That(
() => dummy = effect[-1, 0],
Throws.InstanceOf <ArgumentOutOfRangeException>()
.With.Property("ParamName")
.EqualTo("row")
.And.Property("ActualValue")
.EqualTo(-1));
Assert.That(
() => dummy = effect[MouseConstants.MaxRows, 0],
Throws.InstanceOf <ArgumentOutOfRangeException>()
.With.Property("ParamName")
.EqualTo("row")
.And.Property("ActualValue")
.EqualTo(MouseConstants.MaxRows));
Assert.That(
() => dummy = effect[0, -1],
Throws.InstanceOf <ArgumentOutOfRangeException>()
.With.Property("ParamName")
.EqualTo("column")
.And.Property("ActualValue")
.EqualTo(-1));
Assert.That(
() => dummy = effect[0, MouseConstants.MaxColumns],
Throws.InstanceOf <ArgumentOutOfRangeException>()
.With.Property("ParamName")
.EqualTo("column")
.And.Property("ActualValue")
.EqualTo(MouseConstants.MaxColumns));
}
public void ShouldThrowWhenOutOfRange1DGet()
{
var grid = CustomMouseEffect.Create();
// ReSharper disable once NotAccessedVariable
Color dummy;
Assert.That(
() => dummy = grid[-1],
Throws.InstanceOf <ArgumentOutOfRangeException>()
.With.Property("ParamName")
.EqualTo("index")
.And.Property("ActualValue")
.EqualTo(-1));
Assert.That(
() => dummy = grid[MouseConstants.MaxLeds],
Throws.InstanceOf <ArgumentOutOfRangeException>()
.With.Property("ParamName")
.EqualTo("index")
.And.Property("ActualValue")
.EqualTo(MouseConstants.MaxLeds));
}
public void ShouldConstructFrom2DArray()
{
var colors = new Color[MouseConstants.MaxRows][];
for (var row = 0; row < MouseConstants.MaxRows; row++)
{
colors[row] = new Color[MouseConstants.MaxColumns];
}
colors[1][2] = Color.Red;
colors[0][4] = Color.Blue;
colors[3][1] = Color.Green;
var effect = new CustomMouseEffect(colors);
for (var row = 0; row < MouseConstants.MaxRows; row++)
{
for (var column = 0; column < MouseConstants.MaxColumns; column++)
{
Assert.AreEqual(colors[row][column], effect[row, column]);
}
}
}
public void ShouldThrowWhenOutOfRange2DSet()
{
var effect = CustomMouseEffect.Create();
Assert.That(
() => effect[-1, 0] = Color.Red,
Throws.InstanceOf <ArgumentOutOfRangeException>()
.With.Property("ParamName")
.EqualTo("row")
.And.Property("ActualValue")
.EqualTo(-1));
Assert.That(
() => effect[MouseConstants.MaxRows, 0] = Color.Red,
Throws.InstanceOf <ArgumentOutOfRangeException>()
.With.Property("ParamName")
.EqualTo("row")
.And.Property("ActualValue")
.EqualTo(MouseConstants.MaxRows));
Assert.That(
() => effect[0, -1] = Color.Red,
Throws.InstanceOf <ArgumentOutOfRangeException>()
.With.Property("ParamName")
.EqualTo("column")
.And.Property("ActualValue")
.EqualTo(-1));
Assert.That(
() => effect[0, MouseConstants.MaxColumns] = Color.Red,
Throws.InstanceOf <ArgumentOutOfRangeException>()
.With.Property("ParamName")
.EqualTo("column")
.And.Property("ActualValue")
.EqualTo(MouseConstants.MaxColumns));
}
/// <inheritdoc />
/// <summary>
/// Initializes a new instance of the <see cref="MouseImplementation" /> class.
/// </summary>
public MouseImplementation(IChromaApi api)
: base(api)
{
Log.Info("Mouse is initializing");
_custom = CustomMouseEffect.Create();
}
private void Render(CustomMouseEffect mouse, Color c, double lastZ)
{
// Particles are drawn as stretched lines, as with keyboard.
const int yMin = 1;
const int yMax = MouseConstants.MaxRows - 1;
const int xMax = MouseConstants.MaxColumns - 1;
const double yScale = MouseConstants.MaxRows - yMin;
if (_angle > 90)
{
return;
}
switch (_angle % 4)
{
case 0:
mouse[GridLed.ScrollWheel] = mouse[GridLed.ScrollWheel].Max(c);
return;
case 1:
mouse[GridLed.Logo] = mouse[GridLed.Logo].Max(c);
return;
}
Debug.Assert(lastZ >= Z, "Z always decreases");
var yPrev = (lastZ < 0 ? Math.Max(1 / lastZ, -2) : -2) * yScale;
var yCurr = (Z < 0 ? Math.Max(1 / Z, -2) : -2) * yScale;
var y0 = (yScale + yPrev) + yMin;
var y1 = (yScale + yCurr) + yMin;
if (y1 < yMin)
{
mouse[yMin, 0] = mouse[yMin, 0].Max(c);
mouse[yMin, xMax] = mouse[yMin, 0];
return;
}
// First pixel
var yi = (int)Math.Floor(y0);
if (yi >= yMin && yi <= yMax)
{
var caa = c.Transform(1 - (y0 - yi));
mouse[yi, 0] = mouse[yi, 0].Max(caa);
mouse[yi, xMax] = mouse[yi, 0];
}
// Last pixel
var yj = (int)Math.Ceiling(y1);
if (yj >= yMin && yj <= yMax)
{
var caa = c.Transform(1 - (yj - y1));
mouse[yj, 0] = mouse[yj, 0].Max(caa);
mouse[yj, xMax] = mouse[yj, 0];
}
// Middle pixels
yi = Math.Max(yMin, yi + 1);
yj = Math.Min(yj, yMax);
for (; yi <= yj; yi++)
{
mouse[yi, 0] = mouse[yi, 0].Max(c);
mouse[yi, xMax] = mouse[yi, 0];
}
}
public void ShouldHaveZeroHashCodeOnDefaultInstance()
{
var effect = new CustomMouseEffect();
Assert.Zero(effect.GetHashCode());
}
