public Task ApplyAsync(IVirtualLedGrid virtualGrid, CancellationToken cancellationToken = default)
{
if (_sdk == null || this._notebookKeyboard == null)
{
return(Task.CompletedTask);
}
foreach (var key in virtualGrid.Where(x => x.Type != KeyType.Headset))
{
var color = ToRGBNetColor(key.Color);
switch (key.FriendlyName)
{
case "Enter":
_notebookKeyboard.Lights[(int)RogStrixKeyboardMap.OemEnterLed0].Color = color;
_notebookKeyboard.Lights[(int)RogStrixKeyboardMap.OemEnterLed1].Color = color;
_notebookKeyboard.Lights[(int)RogStrixKeyboardMap.OemEnterLed2].Color = color;
break;
case "RightShift":
_notebookKeyboard.Lights[(int)RogStrixKeyboardMap.RightShiftLed0].Color = color;
_notebookKeyboard.Lights[(int)RogStrixKeyboardMap.RightShiftLed1].Color = color;
_notebookKeyboard.Lights[(int)RogStrixKeyboardMap.RightShiftLed2].Color = color;
break;
case "Backspace":
_notebookKeyboard.Lights[(int)RogStrixKeyboardMap.BackspaceLed0].Color = color;
_notebookKeyboard.Lights[(int)RogStrixKeyboardMap.BackspaceLed1].Color = color;
_notebookKeyboard.Lights[(int)RogStrixKeyboardMap.BackspaceLed2].Color = color;
break;
case "Space":
_notebookKeyboard.Lights[(int)RogStrixKeyboardMap.SpaceLed0].Color = color;
_notebookKeyboard.Lights[(int)RogStrixKeyboardMap.SpaceLed1].Color = color;
_notebookKeyboard.Lights[(int)RogStrixKeyboardMap.SpaceLed2].Color = color;
_notebookKeyboard.Lights[(int)RogStrixKeyboardMap.SpaceLed3].Color = color;
break;
default:
var asusKey = KeyConvert(key.FriendlyName);
if (asusKey == RogStrixKeyboardMap.GhostKey)
{
continue;
}
var led = _notebookKeyboard.Lights[(int)asusKey];
if (led == null)
{
continue;
}
led.Color = color;
break;
}
}
_notebookKeyboard.Apply();
return(Task.CompletedTask);
}
private void SetGridBackground(IVirtualLedGrid grid, Color[][] colorMap, double brightness)
{
for (var y = 0; y < colorMap.GetLength(0); y++)
{
var row = colorMap[y];
for (var x = 0; x < row.Length; x++)
{
grid[x, y] = row[x].ChangeBrightnessLevel(brightness);
}
}
}
public static void Set(this IVirtualLedGrid grid, Listener.Plugin.ChromaEffect.Implementation.Color[][] colors, double brightness)
{
for (var y = 0; y < colors.GetLength(0); y++)
{
var row = colors[y];
for (var x = 0; x < row.Length; x++)
{
grid[x, y] = row[x].ChangeBrightnessLevel(brightness);
}
}
}
internal VirtualGridRendererImpl(IVirtualLedGrid grid, int boxWidth, int boxHeight)
{
this.grid = grid;
var totalWidth = (grid.ColumnCount + 1) * boxWidth;
var totalHeight = (grid.RowCount + 1) * boxHeight;
var fontSize = 13 * (boxWidth / 100.0f);
font = new Font("Microsoft Sans Serif", fontSize, System.Drawing.FontStyle.Regular);
bitmap = GetGridBoilerplate(totalWidth, totalHeight, boxWidth, boxHeight);
graphics = System.Drawing.Graphics.FromImage(bitmap);
}
public void SetEffect(IVirtualLedGrid virtualGrid, Color firstColor, Color secondaryColor, ICollection <Color> albumColor, Color[][] albumArtworkColor, double[] spectrumValues, double position, double brightnessMultiplier)
{
if (double.IsNaN(position) || double.IsInfinity(position))
{
return;
}
for (var x = 0; x < virtualGrid.ColumnCount; x++)
{
var background = albumColor.ElementAt(x).ChangeBrightnessLevel(brightnessMultiplier);
foreach (var key in virtualGrid.Where(e => e.Index.X == x))
{
key.Color = background;
}
}
var keyboardGrid = virtualGrid.Where(x => x.Type == KeyType.Keyboard || x.Type == KeyType.Mousepad || x.Type == KeyType.Invalid);
var keyboardRowCount = keyboardGrid.Max(e => e.Index.Y) + 1;
for (var rowIdx = 0; rowIdx < keyboardRowCount; rowIdx++)
{
var row = keyboardGrid.Where(e => e.Index.Y == rowIdx && e.Index.X < 22).ToArray();
var pos = (int)Math.Round(position * ((double)(row.Length - 1) / 10), 0);
var key = row[pos];
virtualGrid[key.Index.X, key.Index.Y] = firstColor;
if (0 < pos - 1 && pos + 1 < row.Length)
{
var leftKey = row[pos - 1];
var rightKey = row[pos + 1];
var adjacentColor = firstColor.ChangeBrightnessLevel(0.5);
virtualGrid[leftKey.Index.X, leftKey.Index.Y] = adjacentColor;
virtualGrid[rightKey.Index.X, rightKey.Index.Y] = adjacentColor;
}
}
var maxMouseY = virtualGrid.Where(x => 22 < x.Index.X && x.Index.X < 29).Max(x => x.Index.Y) + 1;
var currentPlayPosition = (int)Math.Round(position * ((double)(maxMouseY - 1) / 10), 0);
virtualGrid[22, currentPlayPosition] = firstColor;
var vizColor = albumColor.First();
for (var x = 23; x < 29; x++)
{
var volume = spectrumValues[x - 23];
var absPosition = maxMouseY - (int)Math.Round((volume / 100d) * maxMouseY, 0);
for (var y = maxMouseY - 1; y >= absPosition; y--)
{
virtualGrid[x, y] = vizColor;
}
}
}
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);
}
private ChromaWorker()
{
this._albumColors = AutoshiftCirculaQueue <ChromaColor> .Empty;
this.FullGridArray = Listener.Plugin.ChromaEffect.Implementation.VirtualLedGrid.CreateDefaultGrid();
try
{
var adapters = new List <IPhysicalDeviceAdapter>();
adapters.Add(new RazerSdkAdapter());
adapters.Add(new AsusSdkAdapter());
this._deviceAdapters = adapters;
}
catch (Exception ex)
{
this.IsError = true;
Debug.WriteLine(ex);
}
}
public void SetEffect(IVirtualLedGrid virtualGrid, Color firstColor, Color secondaryColor, ICollection <Color> albumColor, Color[][] albumArtworkColor, double[] spectrumValues, double position, double brightnessMultiplier)
{
virtualGrid.Set(Color.Black);
var fullLength = virtualGrid.ColumnCount;
var volume = spectrumValues[0] / 100.0;
var startPosition = 0;
var absolutePosition = Math.Round((volume * fullLength), 0) / 2;
for (var row = 0; row < virtualGrid.RowCount; row++)
{
for (var col = startPosition; col < startPosition + absolutePosition; col++)
{
var color = Listener.Plugin.ChromaEffect.Shared.SharedColors.RainbowColor.ElementAt(col).ChangeBrightnessLevel(volume);
virtualGrid[col, row] = color;
virtualGrid[fullLength - col - 1, row] = color;
}
}
}
public override Task ApplyAsync(IVirtualLedGrid virtualGrid, CancellationToken cancellationToken = default)
{
if (!this.Initialized)
{
return(Task.CompletedTask);
}
var chromaLinkGrid = CustomChromaLinkEffect.Create();
var keyIdx = 0;
foreach (var key in virtualGrid)
{
chromaLinkGrid[keyIdx++] = ToColoreColor(key.Color);
}
return(this.ChromaInterface !.ChromaLink.SetCustomAsync(chromaLinkGrid));
}
/// <inheritdoc/>
public void SetEffect(IVirtualLedGrid virtualGrid, Color firstColor, Color secondaryColor, ICollection <Color> albumColor, Color[][] albumArtworkColor, double[] spectrumValues, double position, double brightnessMultiplier)
{
for (var x = 0; x < virtualGrid.ColumnCount; x++)
{
var foreground = albumColor.ElementAt(albumColor.Count - 1 - x);
var background = foreground.ChangeBrightnessLevel(brightnessMultiplier);
foreach (var key in virtualGrid.Where(e => e.Index.X == x))
{
key.Color = background;
}
var c = spectrumValues[x];
var absSpectrum = virtualGrid.RowCount - (int)Math.Round((virtualGrid.RowCount * (c / 100.0d)), 0);
for (var y = virtualGrid.RowCount - 1; y >= absSpectrum; y--)
{
virtualGrid[x, y] = foreground;
}
}
}
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 SetEffect(IVirtualLedGrid virtualGrid, Color firstColor, Color secondaryColor, ICollection <Color> albumColor, Color[][] albumArtworkColor, double[] spectrumValues, double position, double brightnessMultiplier)
{
if (albumArtworkColor == null)
{
return;
}
SetGridBackground(virtualGrid, albumArtworkColor, brightnessMultiplier);
for (var x = 0; x < virtualGrid.ColumnCount; x++)
{
var foreground = albumColor.ElementAt(albumColor.Count - 1 - x);
var c = spectrumValues[x];
var absSpectrum = virtualGrid.RowCount - (int)Math.Round((virtualGrid.RowCount * (c / 100.0d)), 0);
for (var y = virtualGrid.RowCount - 1; y >= absSpectrum; y--)
{
virtualGrid[x, y] = foreground;
}
}
}
public void SetEffect(IVirtualLedGrid virtualGrid, Color firstColor, Color secondaryColor, ICollection <Color> albumColor, Color[][] albumArtworkColor, double[] spectrumValues, double position, double brightnessMultiplier)
{
virtualGrid.Set(Color.Black);
var keyboardGrid = virtualGrid.Where(x => x.Type == KeyType.Keyboard);
foreach (var key in keyboardGrid)
{
key.Color = Color.Red;
}
var mouseGrid = virtualGrid.Where(x => x.Type == KeyType.Mouse);
foreach (var key in mouseGrid)
{
key.Color = Color.Blue;
}
var mousepadGrid = virtualGrid.Where(x => x.Type == KeyType.Mousepad);
foreach (var key in mousepadGrid)
{
key.Color = Color.Purple;
}
var chromaLinkGrid = virtualGrid.Where(x => x.Type == KeyType.ChromaLink);
foreach (var key in chromaLinkGrid)
{
key.Color = Color.Green;
}
var headsetGrid = virtualGrid.Where(x => x.Type == KeyType.Headset);
foreach (var key in headsetGrid)
{
key.Color = Color.White;
}
}
/// <inheritdoc/>
public Task ApplyAsync(IVirtualLedGrid virtualGrid, CancellationToken cancellationToken = default)
{
if (!this.Initialized)
{
return(Task.CompletedTask);
}
for (var row = 0; row < virtualGrid.RowCount; row++)
{
var physicalRow = _representor[row];
for (var col = 0; col < virtualGrid.ColumnCount; col++)
{
var cellColor = virtualGrid[col, row];
if (cellColor == null)
{
continue;
}
var key = physicalRow[col];
if (IsInvalidKey(key))
{
continue;
}
var color = ToUint(cellColor.Value);
_notebookKeyboard.Lights[(int)key].Color = color;
}
}
_notebookKeyboard.Apply();
return(Task.CompletedTask);
}
public override Task ApplyAsync(IVirtualLedGrid virtualGrid, CancellationToken cancellationToken = default)
{
if (!this.Initialized)
{
return(Task.CompletedTask);
}
var headset = CustomHeadsetEffect.Create();
var actualIdx = 0;
var keyIdx = 0;
foreach (var cell in virtualGrid)
{
if (keyIdx++ % 2 != 0)
{
continue;
}
headset[actualIdx++] = ToColoreColor(cell.Color);
}
return(this.ChromaInterface !.Headset.SetCustomAsync(headset));
}
public void SetEffect(IVirtualLedGrid virtualGrid, Color firstColor, Color secondaryColor, ICollection <Color> albumColor, Color[][] albumArtworkColor, double[] spectrumValues, double position, double brightnessMultiplier)
{
var colors = Listener.Plugin.ChromaEffect.Shared.SharedColors.RainbowColor;
var visualizeRowCount = virtualGrid.RowCount - 1;
for (var col = 0; col < virtualGrid.ColumnCount; col++)
{
var foreground = colors.ElementAt(colors.Count - 1 - col);
var background = foreground.ChangeBrightnessLevel(brightnessMultiplier);
foreach (var key in virtualGrid.Where(e => e.Index.X == col))
{
key.Color = background;
}
var c = spectrumValues[col];
var absSpectrum = virtualGrid.RowCount - (int)Math.Round((visualizeRowCount * (c / 100.0d)), 0);
for (var row = virtualGrid.RowCount - 1; row >= absSpectrum; row--)
{
virtualGrid[col, row] = Color.White;
}
}
var avgVolume = spectrumValues.Average() / 100.0;
var startPosition = virtualGrid.ColumnCount / 2;
var absolutePosition = (int)Math.Round((avgVolume * virtualGrid.ColumnCount), 0) / 2;
var upperbound = startPosition + absolutePosition;
for (var col = startPosition; col < upperbound; col++)
{
var color = colors.ElementAt(upperbound - col).ChangeBrightnessLevel(1);
var left = col;
var right = virtualGrid.ColumnCount - col - 1;
virtualGrid[left, 0] = color;
virtualGrid[right, 0] = color;
}
}
public Task ApplyAsync(IVirtualLedGrid virtualGrid, CancellationToken cancellationToken = default)
{
return(Task.CompletedTask);
}
/// <inheritdoc/> public abstract Task ApplyAsync(IVirtualLedGrid virtualGrid, CancellationToken cancellationToken = default);
public static VirtualGridRendererImpl CreateGridRendererInstance(IVirtualLedGrid grid, int boxWidth, int boxHeight)
{
return(new VirtualGridRendererImpl(grid, boxWidth, boxHeight));
}
