Organize most controller files into subfolders

Controllers/HyperXMouseController/HyperXPulsefireRaidController/HyperXPulsefireRaidController.cpp

@@ -0,0 +1,81 @@
+/*-------------------------------------------*\
+|  HyperXPulsefireRaidController.cpp          |
+|                                             |
+|  Driver for HyperX Pulsefire Raid           |
+|  lighting controller                        |
+|                                             |
+|  Morgan Guimard (morg) 04/06/2022           |
+\*-------------------------------------------*/
+
+#include "HyperXPulsefireRaidController.h"
+#include <cstring>
+
+using namespace std::chrono_literals;
+
+HyperXPulsefireRaidController::HyperXPulsefireRaidController(hid_device* dev_handle, const hid_device_info& info)
+{
+    dev                 = dev_handle;
+    location            = info.path;
+    version             = "";
+
+    wchar_t serial_string[128];
+    int ret = hid_get_serial_number_string(dev, serial_string, 128);
+
+    if(ret != 0)
+    {
+        serial_number = "";
+    }
+    else
+    {
+        std::wstring return_wstring = serial_string;
+        serial_number = std::string(return_wstring.begin(), return_wstring.end());
+    }
+
+}
+
+HyperXPulsefireRaidController::~HyperXPulsefireRaidController()
+{
+    hid_close(dev);
+}
+
+std::string HyperXPulsefireRaidController::GetDeviceLocation()
+{
+    return("HID: " + location);
+}
+
+std::string HyperXPulsefireRaidController::GetSerialString()
+{
+    return(serial_number);
+}
+
+std::string HyperXPulsefireRaidController::GetFirmwareVersion()
+{
+    return(version);
+}
+
+void HyperXPulsefireRaidController::SendColors(std::vector<RGBColor> colors)
+{
+    unsigned char usb_buf[HYPERX_PULSFIRE_RAID_PACKET_DATA_LENGTH];
+    memset(usb_buf, 0x00, HYPERX_PULSFIRE_RAID_PACKET_DATA_LENGTH);
+
+    usb_buf[0] = HYPERX_PULSFIRE_RAID_REPORT_ID;
+    usb_buf[1] = HYPERX_PULSFIRE_RAID_DIRECT_MODE_START_PACKET;
+
+    for(unsigned int i = 0; i < 2; i++)
+    {
+        usb_buf[3 * i + 2] = RGBGetRValue(colors[i]);
+        usb_buf[3 * i + 3] = RGBGetGValue(colors[i]);
+        usb_buf[3 * i + 4] = RGBGetBValue(colors[i]);
+    }
+
+    usb_buf[8] = HYPERX_PULSFIRE_RAID_DIRECT_MODE_END_PACKET;
+
+    Send(usb_buf);
+}
+
+
+void HyperXPulsefireRaidController::Send(unsigned char* packet)
+{
+    hid_send_feature_report(dev, packet, HYPERX_PULSFIRE_RAID_PACKET_DATA_LENGTH);    
+    std::this_thread::sleep_for(10ms);
+}

Controllers/HyperXMouseController/HyperXPulsefireRaidController/HyperXPulsefireRaidController.h

@@ -0,0 +1,50 @@
+/*-------------------------------------------*\
+|  HyperXPulsefireRaidController.h            |
+|                                             |
+|  Definitions and types for HyperX           |
+|  Pulsefire Raid lighting controller         |
+|                                             |
+|  Morgan Guimard (morg) 04/06/2022           |
+\*-------------------------------------------*/
+
+#include "RGBController.h"
+
+#include <string>
+#include <hidapi/hidapi.h>
+
+#pragma once
+
+#define HYPERX_PULSFIRE_RAID_PACKET_DATA_LENGTH         264
+#define HYPERX_PULSFIRE_RAID_REPORT_ID                  0x07
+#define HYPERX_PULSFIRE_RAID_LEDS_COUNT                 2
+#define HYPERX_PULSFIRE_RAID_DIRECT_MODE_START_PACKET   0x0A
+#define HYPERX_PULSFIRE_RAID_DIRECT_MODE_END_PACKET     0xA0
+
+enum
+{
+    HYPERX_PULSFIRE_RAID_BRIGHTNESS_MIN = 0x00,
+    HYPERX_PULSFIRE_RAID_BRIGHTNESS_MAX = 0x64
+};
+
+class HyperXPulsefireRaidController
+{
+public:
+    HyperXPulsefireRaidController(hid_device* dev_handle, const hid_device_info& info);
+    ~HyperXPulsefireRaidController();    
+
+    std::string GetSerialString();
+    std::string GetDeviceLocation();
+    std::string GetFirmwareVersion();
+    void        SendColors(std::vector<RGBColor> colors);
+    void        SetBrightness(unsigned char brightness);
+
+protected:
+    hid_device* dev;
+
+private:
+    std::string location;
+    std::string serial_number;
+    std::string version;
+
+    void        Send(unsigned char* packet);
+};

Controllers/HyperXMouseController/HyperXPulsefireRaidController/RGBController_HyperXPulsefireRaid.cpp

@@ -0,0 +1,134 @@
+/*-------------------------------------------*\
+|  RGBController_HyperXPulsefireRaid.cpp      |
+|                                             |
+|  Generic RGB Interface for HyperX           |
+|  Pulsefire Raid                             |
+|                                             |
+|  Morgan Guimard (morg) 04/06/2022           |
+\*-------------------------------------------*/
+
+#include "RGBController_HyperXPulsefireRaid.h"
+
+/**------------------------------------------------------------------*\
+    @name HyperX Pulsefire Raid
+    @category Mouse
+    @type USB
+    @save :x:
+    @direct :white_check_mark:
+    @effects :x:
+    @detectors DetectHyperXPulsefireRaidControllers
+    @comment
+\*-------------------------------------------------------------------*/
+
+using namespace std::chrono_literals;
+
+RGBController_HyperXPulsefireRaid::RGBController_HyperXPulsefireRaid(HyperXPulsefireRaidController* controller_ptr)
+{
+    controller  = controller_ptr;
+
+    name        = "HyperX Pulsefire Raid Device";
+    vendor      = "HyperX";
+    type        = DEVICE_TYPE_MOUSE;
+    description = "HyperX Pulsefire Raid Device";
+    location    = controller->GetDeviceLocation();
+    serial      = controller->GetSerialString();
+    version     = controller->GetFirmwareVersion();
+
+    mode Direct;
+    Direct.name           = "Direct";
+    Direct.value          = 0x00;
+    Direct.flags          = MODE_FLAG_HAS_PER_LED_COLOR | MODE_FLAG_HAS_BRIGHTNESS;
+    Direct.color_mode     = MODE_COLORS_PER_LED;
+    Direct.brightness     = HYPERX_PULSFIRE_RAID_BRIGHTNESS_MAX;
+    Direct.brightness_min = HYPERX_PULSFIRE_RAID_BRIGHTNESS_MIN;
+    Direct.brightness_max = HYPERX_PULSFIRE_RAID_BRIGHTNESS_MAX;
+
+    modes.push_back(Direct);
+
+    SetupZones();
+
+    /*-----------------------------------------------------*\
+    | This devices requires a keepalive thread or it will   |
+    | reset to default (flash)                              |
+    \*-----------------------------------------------------*/
+    keepalive_thread_run = 1;
+    keepalive_thread = new std::thread(&RGBController_HyperXPulsefireRaid::KeepaliveThread, this);
+}
+
+RGBController_HyperXPulsefireRaid::~RGBController_HyperXPulsefireRaid()
+{
+
+}
+
+void RGBController_HyperXPulsefireRaid::SetupZones()
+{    
+    std::string led_names[HYPERX_PULSFIRE_RAID_LEDS_COUNT] =
+    {
+        "Scroll Wheel", "Logo"
+    };
+
+    for(unsigned int i = 0; i < HYPERX_PULSFIRE_RAID_LEDS_COUNT; i++)
+    {
+        zone new_zone;
+        new_zone.name        = led_names[i];
+        new_zone.type        = ZONE_TYPE_SINGLE;
+        new_zone.leds_min    = 1;
+        new_zone.leds_max    = 1;
+        new_zone.leds_count  = 1;
+        new_zone.matrix_map  = NULL;
+        zones.push_back(new_zone);
+
+        led new_led;
+        new_led.name         = led_names[i];
+        leds.push_back(new_led);
+    }
+
+    SetupColors();
+}
+
+void RGBController_HyperXPulsefireRaid::ResizeZone(int /*zone*/, int /*new_size*/)
+{
+
+}
+
+void RGBController_HyperXPulsefireRaid::DeviceUpdateLEDs()
+{
+    UpdateSingleLED(0);
+}
+
+void RGBController_HyperXPulsefireRaid::UpdateZoneLEDs(int zone)
+{
+    UpdateSingleLED(zone);
+}
+
+void RGBController_HyperXPulsefireRaid::UpdateSingleLED(int /*led*/)
+{
+    last_update_time = std::chrono::steady_clock::now();
+    controller->SendColors(colors);
+}
+
+void RGBController_HyperXPulsefireRaid::DeviceUpdateMode()
+{
+
+}
+
+void RGBController_HyperXPulsefireRaid::DeviceSaveMode()
+{
+
+}
+
+void RGBController_HyperXPulsefireRaid::KeepaliveThread()
+{
+    while(keepalive_thread_run.load())
+    {
+        if(active_mode == 0)
+        {
+            if((std::chrono::steady_clock::now() - last_update_time) > 1s)
+            {
+                UpdateLEDs();
+            }
+        }
+
+        std::this_thread::sleep_for(10ms);
+    }
+}

Controllers/HyperXMouseController/HyperXPulsefireRaidController/RGBController_HyperXPulsefireRaid.h

@@ -0,0 +1,38 @@
+/*-------------------------------------------*\
+|  RGBController_HyperXPulsefireRaid.h        |
+|                                             |
+|  Generic RGB Interface for HyperX           |
+|  Pulsefire Raid                             |
+|                                             |
+|  Morgan Guimard (morg) 04/06/2022           |
+\*-------------------------------------------*/
+
+#pragma once
+#include <chrono>
+
+#include "RGBController.h"
+#include "HyperXPulsefireRaidController.h"
+
+class RGBController_HyperXPulsefireRaid : public RGBController
+{
+public:
+    RGBController_HyperXPulsefireRaid(HyperXPulsefireRaidController* controller_ptr);
+    ~RGBController_HyperXPulsefireRaid();
+
+    void SetupZones();
+    void ResizeZone(int zone, int new_size);
+    
+    void DeviceUpdateLEDs();
+    void UpdateZoneLEDs(int zone);
+    void UpdateSingleLED(int led);
+
+    void DeviceUpdateMode();
+    void DeviceSaveMode();
+    
+private:
+    HyperXPulsefireRaidController*                      controller;
+    std::thread*                                        keepalive_thread;
+    std::atomic<bool>                                   keepalive_thread_run;
+    std::chrono::time_point<std::chrono::steady_clock>  last_update_time;
+    void                                                KeepaliveThread();
+};