mirror of
https://github.com/DarthAffe/CUE.NET.git
synced 2025-12-13 09:08:34 +00:00
518 lines
26 KiB
C#
518 lines
26 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Drawing;
|
|
using System.Linq;
|
|
using System.Threading;
|
|
using System.Threading.Tasks;
|
|
using CUE.NET;
|
|
using CUE.NET.Brushes;
|
|
using CUE.NET.Devices;
|
|
using CUE.NET.Devices.Generic;
|
|
using CUE.NET.Devices.Generic.Enums;
|
|
using CUE.NET.Effects;
|
|
using CUE.NET.Exceptions;
|
|
using CUE.NET.Gradients;
|
|
using CUE.NET.Groups;
|
|
using CUE.NET.Devices.Mouse;
|
|
|
|
namespace SimpleDevTest
|
|
{
|
|
internal class Program
|
|
{
|
|
private static readonly Random Rand = new Random();
|
|
|
|
public static void Main(string[] args)
|
|
{
|
|
//Console.WriteLine("Press any key to exit ...");
|
|
//Console.WriteLine();
|
|
//Task.Factory.StartNew(
|
|
// () =>
|
|
// {
|
|
// Console.ReadKey();
|
|
// Environment.Exit(0);
|
|
// });
|
|
|
|
//try
|
|
//{
|
|
// bool test = CueSDK.IsSDKAvailable();
|
|
|
|
// // Initialize CUE-SDK
|
|
// CueSDK.Initialize();
|
|
// Console.WriteLine("Initialized with " + CueSDK.LoadedArchitecture + "-SDK");
|
|
|
|
// CueSDK.KeyboardSDK.Brush = (SolidColorBrush)Color.Black;
|
|
// //CueSDK.KeyboardSDK[CorsairLedId.Z].Color = Color.Red;
|
|
// //CueSDK.KeyboardSDK[CorsairLedId.Z].IsLocked = true;
|
|
|
|
// float thirdKeyboardWidth = CueSDK.KeyboardSDK.DeviceRectangle.Width / 3f;
|
|
// ILedGroup left = new RectangleLedGroup(CueSDK.KeyboardSDK, new RectangleF(CueSDK.KeyboardSDK.DeviceRectangle.X, CueSDK.KeyboardSDK.DeviceRectangle.Y, thirdKeyboardWidth, CueSDK.KeyboardSDK.DeviceRectangle.Height));
|
|
// ILedGroup mid = new RectangleLedGroup(CueSDK.KeyboardSDK, new RectangleF(CueSDK.KeyboardSDK.DeviceRectangle.X + thirdKeyboardWidth, CueSDK.KeyboardSDK.DeviceRectangle.Y, thirdKeyboardWidth, CueSDK.KeyboardSDK.DeviceRectangle.Height));
|
|
// ILedGroup right = new RectangleLedGroup(CueSDK.KeyboardSDK, new RectangleF(CueSDK.KeyboardSDK.DeviceRectangle.X + thirdKeyboardWidth * 2, CueSDK.KeyboardSDK.DeviceRectangle.Y, thirdKeyboardWidth, CueSDK.KeyboardSDK.DeviceRectangle.Height));
|
|
|
|
// //CueSDK.KeyboardSDK.Brush = new LinearGradientBrush(new LinearGradient(true, new GradientStop(0, Color.Blue), new GradientStop(0.5f, Color.Red)));
|
|
// left.Brush = new ConicalGradientBrush(new PointF(0.6f, 0.7f), new RainbowGradient(360, 0));
|
|
// left.Brush.AddEffect(new MoveGradientEffect());
|
|
|
|
// mid.Brush = new ConicalGradientBrush(new PointF(0.5f, 0.3f), new RainbowGradient());
|
|
// mid.Brush.AddEffect(new MoveGradientEffect());
|
|
|
|
// right.Brush = new ConicalGradientBrush(new PointF(0.4f, 0.7f), new RainbowGradient(360, 0));
|
|
// right.Brush.AddEffect(new MoveGradientEffect());
|
|
|
|
// //float halfKeyboardWidth = CueSDK.KeyboardSDK.DeviceRectangle.Width / 2f;
|
|
// //ILedGroup left = new RectangleLedGroup(CueSDK.KeyboardSDK, new RectangleF(CueSDK.KeyboardSDK.DeviceRectangle.X, CueSDK.KeyboardSDK.DeviceRectangle.Y, halfKeyboardWidth, CueSDK.KeyboardSDK.DeviceRectangle.Height));
|
|
// //ILedGroup right = new RectangleLedGroup(CueSDK.KeyboardSDK, new RectangleF(CueSDK.KeyboardSDK.DeviceRectangle.X + halfKeyboardWidth, CueSDK.KeyboardSDK.DeviceRectangle.Y, halfKeyboardWidth, CueSDK.KeyboardSDK.DeviceRectangle.Height));
|
|
|
|
// ////CueSDK.KeyboardSDK.Brush = new LinearGradientBrush(new LinearGradient(true, new GradientStop(0, Color.Blue), new GradientStop(0.5f, Color.Red)));
|
|
// //left.Brush = new ConicalGradientBrush(new PointF(0.6f, 0.6f), new RainbowGradient(360, 0));
|
|
// //left.Brush.AddEffect(new MoveGradientEffect());
|
|
|
|
// //right.Brush = new ConicalGradientBrush(new PointF(0.4f, 0.6f), new RainbowGradient());
|
|
// //right.Brush.AddEffect(new MoveGradientEffect());
|
|
|
|
// CueSDK.UpdateMode = UpdateMode.Continuous;
|
|
|
|
// //IBrush rainbowBrush = new LinearGradientBrush(new RainbowGradient());
|
|
// //rainbowBrush.AddEffect(new FlashEffect { Attack = 5f, Sustain = 1f, Decay = 0, Release = 5f, Interval = 1f });
|
|
// //rainbowBrush.AddEffect(new MoveRainbowEffect());
|
|
// //rainbowBrush.AddEffect(new RemoveRedEffect());
|
|
|
|
// //foreach (ICueDevice device in CueSDK.InitializedDevices)
|
|
// // AddTestBrush(device, rainbowBrush);
|
|
|
|
// //// Get connected keyboard or throw exception if there is no light controllable keyboard connected
|
|
// //CorsairKeyboard keyboard = CueSDK.KeyboardSDK;
|
|
// //if (keyboard == null)
|
|
// // throw new WrapperException("No keyboard found");
|
|
|
|
// //const float SPEED = 100f; // mm/sec
|
|
// //const float BRUSH_MODE_CHANGE_TIMER = 2f;
|
|
// //Random random = new Random();
|
|
|
|
// //keyboard.UpdateMode = UpdateMode.Continuous;
|
|
// //keyboard.Brush = new SolidColorBrush(Color.Black);
|
|
|
|
// //RectangleF spot = new RectangleF(keyboard.DeviceRectangle.Width / 2f, keyboard.DeviceRectangle.Y / 2f, 160, 80);
|
|
// //PointF target = new PointF(spot.X, spot.Y);
|
|
// //RectangleLedGroup spotGroup = new RectangleLedGroup(keyboard, spot) { Brush = new LinearGradientBrush(new RainbowGradient()) };
|
|
|
|
// //float brushModeTimer = BRUSH_MODE_CHANGE_TIMER;
|
|
// //keyboard.Updating += (sender, eventArgs) =>
|
|
// //{
|
|
// // brushModeTimer -= eventArgs.DeltaTime;
|
|
// // if (brushModeTimer <= 0)
|
|
// // {
|
|
// // spotGroup.Brush.BrushCalculationMode = spotGroup.Brush.BrushCalculationMode == BrushCalculationMode.Relative
|
|
// // ? BrushCalculationMode.Absolute : BrushCalculationMode.Relative;
|
|
// // brushModeTimer = BRUSH_MODE_CHANGE_TIMER + brushModeTimer;
|
|
// // }
|
|
|
|
// // if (spot.Contains(target))
|
|
// // target = new PointF((float)(keyboard.DeviceRectangle.X + (random.NextDouble() * keyboard.DeviceRectangle.Width)),
|
|
// // (float)(keyboard.DeviceRectangle.Y + (random.NextDouble() * keyboard.DeviceRectangle.Height)));
|
|
// // else
|
|
// // spot.Location = Interpolate(spot.Location, target, eventArgs.DeltaTime * SPEED);
|
|
// // spotGroup.Rectangle = spot;
|
|
// //};
|
|
|
|
// //CorsairMousemat mousemat = CueSDK.MousematSDK;
|
|
// //mousemat.UpdateMode = UpdateMode.Continuous;
|
|
|
|
// //// Left
|
|
// //mousemat[CorsairMousematLedId.Zone1].Color = Color.Red;
|
|
// //mousemat[CorsairMousematLedId.Zone2].Color = Color.Red;
|
|
// //mousemat[CorsairMousematLedId.Zone3].Color = Color.Red;
|
|
// //mousemat[CorsairMousematLedId.Zone4].Color = Color.Red;
|
|
// //mousemat[CorsairMousematLedId.Zone5].Color = Color.Red;
|
|
// //// Bottom
|
|
// //mousemat[CorsairMousematLedId.Zone6].Color = Color.LawnGreen;
|
|
// //mousemat[CorsairMousematLedId.Zone7].Color = Color.LawnGreen;
|
|
// //mousemat[CorsairMousematLedId.Zone8].Color = Color.LawnGreen;
|
|
// //mousemat[CorsairMousematLedId.Zone9].Color = Color.LawnGreen;
|
|
// //mousemat[CorsairMousematLedId.Zone10].Color = Color.LawnGreen;
|
|
// //// Right
|
|
// //mousemat[CorsairMousematLedId.Zone11].Color = Color.Blue;
|
|
// //mousemat[CorsairMousematLedId.Zone12].Color = Color.Blue;
|
|
// //mousemat[CorsairMousematLedId.Zone13].Color = Color.Blue;
|
|
// //mousemat[CorsairMousematLedId.Zone14].Color = Color.Blue;
|
|
// //mousemat[CorsairMousematLedId.Zone15].Color = Color.Blue;
|
|
|
|
// // Random colors to show update rate
|
|
// //foreach (var mousematLed in mousemat.Leds)
|
|
// // mousematLed.Color = GetRandomRainbowColor();
|
|
|
|
// //mousemat.Updating += (sender, eventArgs) =>
|
|
// //{
|
|
// // foreach (var mousematLed in mousemat.Leds)
|
|
// // {
|
|
// // mousematLed.Color = ShiftColor(mousematLed.Color, 20);
|
|
// // }
|
|
// //};
|
|
|
|
// //keyboard.Brush = new SolidColorBrush(Color.Black);
|
|
// //ILedGroup group = new RectangleLedGroup(keyboard, CorsairKeyboardKeyId.F1, CorsairKeyboardKeyId.RightShift);
|
|
// //group.Brush = new LinearGradientBrush(new RainbowGradient());
|
|
// //bool tmp = false;
|
|
// //while (true)
|
|
// //{
|
|
// // group.Brush.BrushCalculationMode = tmp ? BrushCalculationMode.Absolute : BrushCalculationMode.Relative;
|
|
|
|
// // tmp = !tmp;
|
|
// // keyboard.Update();
|
|
// // Wait(1);
|
|
// //}
|
|
|
|
// //keyboard.Brush = new SolidColorBrush(Color.Aqua);
|
|
// //keyboard.Update();
|
|
|
|
// //ILedGroup specialKeyGroup = new ListLedGroup(keyboard, CorsairKeyboardKeyId.Brightness, CorsairKeyboardKeyId.WinLock);
|
|
// //specialKeyGroup.Brush = new SolidColorBrush(Color.Aqua);
|
|
// //keyboard.Update();
|
|
|
|
// //// Replacing the specialKeyGroup with this won't work
|
|
// //keyboard[CorsairKeyboardKeyId.Brightness].Led.Color = Color.Aqua;
|
|
// //keyboard[CorsairKeyboardKeyId.Brightness].Led.IsLocked = true;
|
|
// //keyboard[CorsairKeyboardKeyId.WinLock].Led.Color = Color.Aqua;
|
|
// //keyboard[CorsairKeyboardKeyId.WinLock].Led.IsLocked = true;
|
|
// //keyboard.Update();
|
|
|
|
// //Wait(3);
|
|
|
|
// //CueSDK.Reinitialize();
|
|
// ////keyboard.Brush = CueProfiles.LoadProfileByID()[null];
|
|
// ////keyboard.Update();
|
|
|
|
// //Wait(3);
|
|
|
|
// //// My Profile 'K95 RGB Default 2' is all black - this could lead to different behavior than cue has since transparent isn't black in CUE.NET
|
|
// //// To swap a profile like CUE does we would need to black out the keyboard before
|
|
// //// OR work with a key group containing all keys and leave the background black - this should be always the prefered solution
|
|
// //keyboard.Brush = new SolidColorBrush(Color.Black);
|
|
// //keyboard.Update();
|
|
// ////keyboard.Brush = CueProfiles.LoadProfileByID()["K95 RGB Default 2"];
|
|
// ////keyboard.Update();
|
|
|
|
// //Wait(3);
|
|
|
|
// //ListLedGroup ledGroup = new ListLedGroup(keyboard, keyboard['R'].KeyId);
|
|
// //ledGroup.Brush = new SolidColorBrush(Color.White);
|
|
// //keyboard.Update();
|
|
// //Wait(2);
|
|
// //ledGroup.RemoveKey(keyboard['R'].KeyId);
|
|
// //keyboard['R'].Led.Color = Color.Black;
|
|
// //ledGroup.AddKey(keyboard['T'].KeyId);
|
|
// //keyboard.Update();
|
|
|
|
// //Wait(10);
|
|
|
|
// //return;
|
|
|
|
// // ---------------------------------------------------------------------------
|
|
// // First we'll look at some basic coloring
|
|
|
|
// //Console.WriteLine("Basic color-test ...");
|
|
// //// Ink all numbers on the keypad except the '5' purple, we want that to be gray
|
|
// //ListLedGroup purpleGroup = new RectangleLedGroup(keyboard, CorsairKeyboardKeyId.Keypad7, CorsairKeyboardKeyId.Keypad3)
|
|
// //{ Brush = new SolidColorBrush(Color.Purple) }
|
|
// //.Exclude(CorsairKeyboardKeyId.Keypad5);
|
|
// //keyboard[CorsairKeyboardKeyId.Keypad5].Led.Color = Color.Gray;
|
|
|
|
// //// Ink the Keys 'r', 'g', 'b' in their respective color
|
|
// //// The char access fails for everything except letters (SDK doesn't return a valid keyId)
|
|
// //keyboard['R'].Led.Color = Color.Red;
|
|
// //keyboard[CorsairKeyboardKeyId.G].Led.Color = Color.Green;
|
|
// //keyboard['B'].Led.Color = Color.Blue;
|
|
|
|
// //// Lock the 'r', 'g', 'b' keys. We want them to stay like this forever (commented since it looks quite stupid later, but feel free tu uncomment this)
|
|
// ////keyboard['R'].Led.IsLocked = true;
|
|
// ////keyboard['G'].Led.IsLocked = true;
|
|
// ////keyboard['B'].Led.IsLocked = true;
|
|
|
|
// //// Ink the letters of 'white' white
|
|
// //ListLedGroup whiteGroup = new ListLedGroup(keyboard, CorsairKeyboardKeyId.W, CorsairKeyboardKeyId.H, CorsairKeyboardKeyId.I, CorsairKeyboardKeyId.T, CorsairKeyboardKeyId.E)
|
|
// //{ Brush = new SolidColorBrush(Color.White) };
|
|
|
|
// //// Ink the keys '1' to '0' yellow
|
|
// //RectangleLedGroup yellowGroup = new RectangleLedGroup(keyboard, CorsairKeyboardKeyId.D1, CorsairKeyboardKeyId.D0)
|
|
// //{ Brush = new SolidColorBrush(Color.Yellow) };
|
|
|
|
// //// Update the keyboard to show the configured colors, (your CUE settings defines the rest)
|
|
// //keyboard.Update();
|
|
|
|
// //Wait(3);
|
|
|
|
// //// Remove all the groups we created above to clear the keyboard
|
|
// //purpleGroup.Detach();
|
|
// //whiteGroup.Detach();
|
|
// //yellowGroup.Detach();
|
|
|
|
|
|
// //// ---------------------------------------------------------------------------
|
|
// //// Next we add a nice linear gradient brush over the keyboard and play around with the offset of one stop
|
|
|
|
// //Console.WriteLine("gradient-brush-test");
|
|
|
|
// //// Create our gradient stop to play with
|
|
// //GradientStop moveableStop = new GradientStop(0, Color.FromArgb(0, 255, 0));
|
|
|
|
// //// Create a basic (by default horizontal) brush ...
|
|
// //LinearGradientBrush linearBrush = new LinearGradientBrush(new LinearGradient(new GradientStop(0, Color.Blue), moveableStop, new GradientStop(1f, Color.White)));
|
|
|
|
// //// ... and add it as the keyboard background
|
|
// //keyboard.Brush = linearBrush;
|
|
|
|
// //// Move the brush from left to right
|
|
// //for (float offset = 0; offset <= 1f; offset += 0.02f)
|
|
// //{
|
|
// // moveableStop.Offset = offset;
|
|
// // keyboard.Update();
|
|
// // Thread.Sleep(100);
|
|
// //}
|
|
|
|
// //// And back to center
|
|
// //for (float offset = 1f; offset >= 0.5f; offset -= 0.02f)
|
|
// //{
|
|
// // moveableStop.Offset = offset;
|
|
// // keyboard.Update();
|
|
// // Thread.Sleep(100);
|
|
// //}
|
|
|
|
// //// "Rotate" the brush (this is of course not the best implementation for this but you see the point)
|
|
// //for (float rotateX = 0, rotateY = 0; rotateX <= 1f; rotateX += 0.02f, rotateY = 0.04f)
|
|
// //{
|
|
// // if (rotateY > 1f)
|
|
// // rotateY = 1f - (rotateY - 1f);
|
|
|
|
// // linearBrush.StartPoint = new PointF(rotateX, rotateY);
|
|
// // linearBrush.EndPoint = new PointF(1f - rotateX, 1f - rotateY);
|
|
|
|
// // keyboard.Update();
|
|
// // Thread.Sleep(100);
|
|
// //}
|
|
|
|
// //Wait(2);
|
|
|
|
// //// ---------------------------------------------------------------------------
|
|
// //// Time for an even better brush: rainbow
|
|
|
|
// //Console.WriteLine("rainbow-test");
|
|
|
|
// //// Create an simple horizontal rainbow containing two times the full spectrum
|
|
// //RainbowGradient rainbowGradient = new RainbowGradient(0, 720);
|
|
|
|
// //// Add the rainbow to the keyboard and perform an initial update
|
|
// //keyboard.Brush = new LinearGradientBrush(rainbowGradient);
|
|
// //keyboard.Update();
|
|
|
|
// //// Let the rainbow move around for 10 secs
|
|
// //for (int i = 0; i < 100; i++)
|
|
// //{
|
|
// // rainbowGradient.StartHue += 10f;
|
|
// // rainbowGradient.EndHue += 10f;
|
|
// // keyboard.Update();
|
|
// // Thread.Sleep(100);
|
|
// //}
|
|
|
|
// //Wait(2);
|
|
|
|
|
|
// // ---------------------------------------------------------------------------
|
|
// // Now let us move some points random over the keyboard
|
|
// // Something like this could become some sort of effect
|
|
|
|
// // Initialize needed stuff
|
|
// // const float SPEED = 6f; // mm/tick
|
|
// //Random random = new Random();
|
|
|
|
// //// Flash whole keyboard three times to ... well ... just to make it happen
|
|
// //for (int i = 0; i < 3; i++)
|
|
// //{
|
|
// // keyboard.Brush = new SolidColorBrush(Color.Aquamarine);
|
|
// // keyboard.Update();
|
|
// // Thread.Sleep(160);
|
|
// // keyboard.Brush = new SolidColorBrush(Color.Black);
|
|
// // keyboard.Update();
|
|
// // Thread.Sleep(200);
|
|
// //}
|
|
|
|
// //// Set keyboard 'background' to black with low alpha (this will add a nice "fade" effect instead of just clearing the keyboard every frame)
|
|
// //keyboard.Brush = new SolidColorBrush(Color.FromArgb(25, 0, 0, 0));
|
|
|
|
// //// Define how many points we have
|
|
// //const int NUM_POINTS = 6;
|
|
|
|
// //// The points we want to draw (rectangle since circles are too hard to calculate :p)
|
|
// //RectangleF[] points = new RectangleF[NUM_POINTS];
|
|
|
|
// //// KeyGroups which represents our point on the keyboard
|
|
// //RectangleLedGroup[] pointGroups = new RectangleLedGroup[NUM_POINTS];
|
|
|
|
// //// Target of our movement
|
|
// //PointF[] targets = new PointF[NUM_POINTS];
|
|
|
|
// //// Initialize all the stuff
|
|
// //for (int i = 0; i < NUM_POINTS; i++)
|
|
// //{
|
|
// // // Spawn our point in the top-left corner (right over G1 or on ESC depending on your keyboard)
|
|
// // points[i] = new RectangleF(keyboard.KeyboardRectangle.X, keyboard.KeyboardRectangle.Y, 60, 60);
|
|
// // pointGroups[i] = new RectangleLedGroup(keyboard, points[i], 0.1f) { Brush = new SolidColorBrush(Color.White) };
|
|
// // targets[i] = new PointF(points[i].X, points[i].Y);
|
|
// //}
|
|
|
|
// //// We set colors manually since white points are kinda boring (notice, that we use alpha values)
|
|
// //pointGroups[0].Brush = new RadialGradientBrush(new LinearGradient(new GradientStop(0, Color.FromArgb(127, 255, 0, 0)), new GradientStop(0.5f, Color.FromArgb(127, 255, 0, 0)), new GradientStop(1, Color.FromArgb(0, 255, 0, 0))));
|
|
// //pointGroups[1].Brush = new RadialGradientBrush(new LinearGradient(new GradientStop(0, Color.FromArgb(127, 0, 255, 0)), new GradientStop(0.5f, Color.FromArgb(127, 0, 255, 0)), new GradientStop(1, Color.FromArgb(0, 0, 255, 0))));
|
|
// //pointGroups[2].Brush = new RadialGradientBrush(new LinearGradient(new GradientStop(0, Color.FromArgb(127, 0, 0, 255)), new GradientStop(0.5f, Color.FromArgb(127, 0, 0, 255)), new GradientStop(1, Color.FromArgb(0, 0, 0, 255))));
|
|
// //pointGroups[3].Brush = new RadialGradientBrush(new LinearGradient(new GradientStop(0, Color.FromArgb(127, 255, 0, 255)), new GradientStop(0.5f, Color.FromArgb(127, 255, 0, 255)), new GradientStop(1, Color.FromArgb(0, 255, 0, 255))));
|
|
// //pointGroups[4].Brush = new RadialGradientBrush(new LinearGradient(new GradientStop(0, Color.FromArgb(127, 255, 255, 0)), new GradientStop(0.5f, Color.FromArgb(127, 255, 255, 0)), new GradientStop(1, Color.FromArgb(0, 255, 255, 0))));
|
|
// //pointGroups[5].Brush = new RadialGradientBrush(new LinearGradient(new GradientStop(0, Color.FromArgb(127, 0, 255, 255)), new GradientStop(0.5f, Color.FromArgb(127, 0, 255, 255)), new GradientStop(1, Color.FromArgb(0, 0, 255, 255))));
|
|
|
|
// //while (true)
|
|
// //{
|
|
// // // Calculate all the points
|
|
// // for (int i = 0; i < NUM_POINTS; i++)
|
|
// // {
|
|
// // // Choose new target if we arrived
|
|
// // if (points[i].Contains(targets[i]))
|
|
// // targets[i] = new PointF((float)(keyboard.KeyboardRectangle.X + (random.NextDouble() * keyboard.KeyboardRectangle.Width)),
|
|
// // (float)(keyboard.KeyboardRectangle.Y + (random.NextDouble() * keyboard.KeyboardRectangle.Height)));
|
|
// // else
|
|
// // // Calculate movement
|
|
// // points[i].Location = Interpolate(points[i].Location, targets[i], SPEED); // It would be better to calculate from the center of our rectangle but the easy way is enough here
|
|
|
|
// // // Move our rectangle to the new position
|
|
// // pointGroups[i].Rectangle = points[i];
|
|
// // }
|
|
|
|
// // // Update changed leds
|
|
// // keyboard.Update();
|
|
|
|
// // // 20 updates per sec should be enought for this
|
|
// // Thread.Sleep(50);
|
|
// //}
|
|
//}
|
|
//catch (CUEException ex)
|
|
//{
|
|
// Console.WriteLine("CUE Exception! ErrorCode: " + Enum.GetName(typeof(CorsairError), ex.Error));
|
|
//}
|
|
//catch (WrapperException ex)
|
|
//{
|
|
// Console.WriteLine("Wrapper Exception! Message:" + ex.Message);
|
|
//}
|
|
//catch (Exception ex)
|
|
//{
|
|
// Console.WriteLine("Exception! Message:" + ex.Message);
|
|
//}
|
|
|
|
//while (true)
|
|
// Thread.Sleep(1000); // Don't exit after exception
|
|
|
|
CueSDK.Initialize();
|
|
|
|
CorsairMouse mouse = CueSDK.MouseSDK;
|
|
|
|
//mouse.Initialize();
|
|
|
|
mouse[CorsairLedId.B1].Color = Color.Red;
|
|
mouse[CorsairLedId.B2].Color = Color.Green;
|
|
mouse[CorsairLedId.B3].Color = Color.Blue;
|
|
|
|
mouse.Update();
|
|
|
|
Console.ReadLine();
|
|
}
|
|
|
|
private static void AddTestBrush(ICueDevice device, IBrush brush)
|
|
{
|
|
if (device == null) return;
|
|
|
|
device.Brush = (SolidColorBrush)Color.Black;
|
|
ILedGroup leds = new ListLedGroup(device, device);
|
|
leds.Brush = brush;
|
|
}
|
|
|
|
private static void Wait(int sec)
|
|
{
|
|
for (int i = sec; i > 0; i--)
|
|
{
|
|
Console.WriteLine(i);
|
|
Thread.Sleep(1000);
|
|
}
|
|
}
|
|
|
|
private static PointF Interpolate(PointF p1, PointF p2, float length)
|
|
{
|
|
float distance = (float)(Math.Sqrt(Math.Pow(p2.X - p1.X, 2) + Math.Pow(p2.Y - p1.Y, 2)));
|
|
if (distance > length)
|
|
{
|
|
float t = length / distance;
|
|
float xt = (1 - t) * p1.X + (t * p2.X);
|
|
float yt = (1 - t) * p1.Y + (t * p2.Y);
|
|
return new PointF(xt, yt);
|
|
}
|
|
return p2;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Comes up with a 'pure' psuedo-random color
|
|
/// </summary>
|
|
/// <returns>The color</returns>
|
|
public static Color GetRandomRainbowColor()
|
|
{
|
|
List<int> colors = new List<int>();
|
|
for (int i = 0; i < 3; i++)
|
|
colors.Add(Rand.Next(0, 256));
|
|
|
|
int highest = colors.Max();
|
|
int lowest = colors.Min();
|
|
colors[colors.FindIndex(c => c == highest)] = 255;
|
|
colors[colors.FindIndex(c => c == lowest)] = 0;
|
|
|
|
Color returnColor = Color.FromArgb(255, colors[0], colors[1], colors[2]);
|
|
|
|
return returnColor;
|
|
}
|
|
public static Color ShiftColor(Color c, int shiftAmount)
|
|
{
|
|
int newRed = c.R;
|
|
int newGreen = c.G;
|
|
int newBlue = c.B;
|
|
|
|
// Red to purple
|
|
if (c.R == 255 && c.B < 255 && c.G == 0)
|
|
newBlue = newBlue + shiftAmount;
|
|
// Purple to blue
|
|
else if (c.B == 255 && c.R > 0)
|
|
newRed = newRed - shiftAmount;
|
|
// Blue to light-blue
|
|
else if (c.B == 255 && c.G < 255)
|
|
newGreen = newGreen + shiftAmount;
|
|
// Light-blue to green
|
|
else if (c.G == 255 && c.B > 0)
|
|
newBlue = newBlue - shiftAmount;
|
|
// Green to yellow
|
|
else if (c.G == 255 && c.R < 255)
|
|
newRed = newRed + shiftAmount;
|
|
// Yellow to red
|
|
else if (c.R == 255 && c.G > 0)
|
|
newGreen = newGreen - shiftAmount;
|
|
|
|
newRed = BringIntInColorRange(newRed);
|
|
newGreen = BringIntInColorRange(newGreen);
|
|
newBlue = BringIntInColorRange(newBlue);
|
|
|
|
return Color.FromArgb(c.A, newRed, newGreen, newBlue);
|
|
}
|
|
|
|
private static int BringIntInColorRange(int i)
|
|
{
|
|
if (i < 0)
|
|
return 0;
|
|
if (i > 255)
|
|
return 255;
|
|
|
|
return i;
|
|
}
|
|
}
|
|
}
|