mirror/OpenRGB
1
0
Fork 0
mirror of https://github.com/CalcProgrammer1/OpenRGB.git synced 2026-05-24 22:45:55 -04:00
Code Issues Packages Projects Releases Wiki Activity

Organize most controller files into subfolders

Browse Source
This commit is contained in:
Adam Honse
2024-04-30 17:18:39 -05:00
parent ba57bad361
commit d52ad02c5c
415 changed files with 44 additions and 43 deletions
Download Patch File Download Diff File Expand all files Collapse all files

82
Controllers/A4TechController/BloodyMouseController/BloodyMouseController.cpp Normal file
View File

@@ -0,0 +1,82 @@
/*---------------------------------------------------------------------*\
| BloodyMouseController.cpp |
| |
| Driver for BloodyMouse USB Controller |
| |
| Chris M (Dr_No) 30 Jun 2022 |
| |
\*---------------------------------------------------------------------*/
#include "BloodyMouseController.h"
#include "LogManager.h"
BloodyMouseController::BloodyMouseController(hid_device* dev_handle, const char* path, uint16_t product_id)
{
dev = dev_handle;
location = path;
pid = product_id;
InitDevice();
}
BloodyMouseController::~BloodyMouseController()
{
hid_close(dev);
}
uint16_t BloodyMouseController::GetPid()
{
return pid;
}
std::string BloodyMouseController::GetSerial()
{
const uint8_t sz = HID_MAX_STR;
wchar_t tmp[sz];
int ret = hid_get_serial_number_string(dev, tmp, sz);
if (ret != 0)
{
LOG_DEBUG("[BloodyMouse] Get HID Serial string failed");
return("");
}
std::wstring w_tmp = std::wstring(tmp);
std::string serial = std::string(w_tmp.begin(), w_tmp.end());
return serial;
}
std::string BloodyMouseController::GetLocation()
{
return("HID: " + location);
}
void BloodyMouseController::InitDevice()
{
uint8_t buffer[BLOODYMOUSE_WRITE_PACKET_SIZE] = { 0x07, 0x03, 0x06, 0x01, 0x00, 0x00, 0x00, 0x00 };
hid_send_feature_report(dev, buffer, BLOODYMOUSE_WRITE_PACKET_SIZE);
buffer[BLOODYMOUSE_MODE_BYTE] = 0;
buffer[BLOODYMOUSE_DATA_BYTE] = 1;
hid_send_feature_report(dev, buffer, BLOODYMOUSE_WRITE_PACKET_SIZE);
}
void BloodyMouseController::SetLedsDirect(std::vector<RGBColor> colors)
{
uint8_t buffer[BLOODYMOUSE_WRITE_PACKET_SIZE] = { 0x07, 0x03, 0x06, 0x02, 0x00, 0x00, 0x00, 0x00 };
for(uint8_t i = 0; i < colors.size(); i++)
{
uint8_t offset = 3 * (colors[i] >> 24) + BLOODYMOUSE_DATA_BYTE;
buffer[offset] = RGBGetRValue(colors[i]);
buffer[offset + 1] = RGBGetGValue(colors[i]);
buffer[offset + 2] = RGBGetBValue(colors[i]);
}
hid_send_feature_report(dev, buffer, BLOODYMOUSE_WRITE_PACKET_SIZE);
}

63
Controllers/A4TechController/BloodyMouseController/BloodyMouseController.h Normal file
View File

@@ -0,0 +1,63 @@
/*---------------------------------------------------------------------*\
| BloodyMouseController.h |
| |
| Driver for BloodyMouse USB Controller |
| |
| Chris M (Dr_No) 30 Jun 2022 |
| |
\*---------------------------------------------------------------------*/
#include <string>
#include <hidapi/hidapi.h>
#include "RGBController.h"
#pragma once
/*-----------------------------------------------------*\
| Mouse product IDs |
\*-----------------------------------------------------*/
#define BLOODY_W60_PRO_PID 0x37EA
#define BLOODY_W90_MAX_PID 0x3666
/*-----------------------------------------------------*\
| Mousemat product IDs |
\*-----------------------------------------------------*/
#define BLOODY_MP_50RS_PID 0xFA60
#define HID_MAX_STR 255
#define BLOODYMOUSE_WRITE_PACKET_SIZE 64
#define BLOODYMOUSE_BRIGHTNESS_MIN 0
#define BLOODYMOUSE_BRIGHTNESS_MAX 255
enum
{
BLOODYMOUSE_MODE_DIRECT = 0x01, //Direct Led Control - Independently set LEDs in zone
};
enum
{
BLOODYMOUSE_REPORT_BYTE = 1,
BLOODYMOUSE_COMMAND_BYTE = 2,
BLOODYMOUSE_MODE_BYTE = 3,
BLOODYMOUSE_DATA_BYTE = 8,
};
class BloodyMouseController
{
public:
BloodyMouseController(hid_device* dev_handle, const char* path, uint16_t product_id);
~BloodyMouseController();
uint16_t GetPid();
std::string GetSerial();
std::string GetLocation();
void SetLedsDirect(std::vector<RGBColor> colors);
private:
uint16_t pid;
std::string location;
hid_device* dev;
void InitDevice();
};

192
Controllers/A4TechController/BloodyMouseController/RGBController_BloodyMouse.cpp Normal file
View File

@@ -0,0 +1,192 @@
/*---------------------------------------------------------------------*\
| RGBController_BloodyMouse.cpp |
| |
| Driver for BloodyMouse USB Controller |
| |
| Chris M (Dr_No) 30 Jun 2022 |
| |
\*---------------------------------------------------------------------*/
#include "RGBController_BloodyMouse.h"
static const mouse_layout w60_pro
{
{
"Scroll Wheel", { 14 }
},
{
"Mid Line", { 0, 1, 2, 9, 3, 4, 5, 6 }
},
{
"Logo", { 10 }
},
{
"Rear", { 8, 7, 13, 12, 11 }
}
};
static const mouse_layout w90_max
{
{
"Scroll Wheel", { 14 }
},
{
"Logo", { 7 }
},
{
"Rear", { 13, 12, 11, 10, 9, 8, 6, 5, 4, 3, 2, 1, 0 }
}
};
static const mouse_layout mp_50rs
{
{
"Mouse Pad", { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }
}
};
/**------------------------------------------------------------------*\
@name BloodyMouse
@category Mouse
@type USB
@save :x:
@direct :white_check_mark:
@effects :x:
@detectors DetectA4TechMouseControllers
@comment
\*-------------------------------------------------------------------*/
RGBController_BloodyMouse::RGBController_BloodyMouse(BloodyMouseController *controller_ptr)
{
controller = controller_ptr;
switch(controller->GetPid())
{
case BLOODY_MP_50RS_PID:
type = DEVICE_TYPE_MOUSEMAT;
break;
default:
type = DEVICE_TYPE_MOUSE;
}
vendor = "Bloody";
description = "Controller compatible with the Bloody W60 Pro and MP 50RS";
serial = controller->GetSerial();
location = controller->GetLocation();
mode Direct;
Direct.name = "Direct";
Direct.value = BLOODYMOUSE_MODE_DIRECT;
Direct.flags = MODE_FLAG_HAS_PER_LED_COLOR;
Direct.color_mode = MODE_COLORS_PER_LED;
modes.push_back(Direct);
SetupZones();
}
RGBController_BloodyMouse::~RGBController_BloodyMouse()
{
delete controller;
}
void RGBController_BloodyMouse::SetupZones()
{
/*-------------------------------------------------*\
| Clear any existing color/LED configuration |
\*-------------------------------------------------*/
leds.clear();
colors.clear();
/*-------------------------------------------------*\
| Select layout from PID |
\*-------------------------------------------------*/
mouse_layout layout;
switch(controller->GetPid())
{
case BLOODY_W60_PRO_PID:
layout = w60_pro;
break;
case BLOODY_W90_MAX_PID:
layout = w90_max;
break;
case BLOODY_MP_50RS_PID:
layout = mp_50rs;
break;
}
/*---------------------------------------------------------*\
| Set up zones |
\*---------------------------------------------------------*/
for(uint8_t zone_idx = 0; zone_idx < layout.size(); zone_idx++)
{
mouse_zone mz = layout[zone_idx];
bool bool_single = mz.zone_leds.size() == 1;
zone new_zone;
new_zone.name = mz.name;
new_zone.leds_min = (unsigned int)mz.zone_leds.size();
new_zone.leds_max = new_zone.leds_min;
new_zone.leds_count = new_zone.leds_min;
new_zone.type = bool_single ? ZONE_TYPE_SINGLE : ZONE_TYPE_LINEAR;
new_zone.matrix_map = NULL;
zones.push_back(new_zone);
for(unsigned int lp_idx = 0; lp_idx < zones[zone_idx].leds_count; lp_idx++)
{
led new_led;
new_led.value = mz.zone_leds[lp_idx];
if(bool_single)
{
new_led.name = mz.name + " LED";
}
else
{
new_led.name = mz.name;
new_led.name.append(" LED " + std::to_string(lp_idx));
}
leds.push_back(new_led);
}
}
SetupColors();
}
void RGBController_BloodyMouse::ResizeZone(int /*zone*/, int /*new_size*/)
{
/*---------------------------------------------------------*\
| This device does not support resizing zones |
\*---------------------------------------------------------*/
}
void RGBController_BloodyMouse::DeviceUpdateLEDs()
{
std::vector<RGBColor> colour;
for(size_t i = 0; i < colors.size(); i++)
{
RGBColor c = colors[i] | (leds[i].value << 24);
colour.push_back(c);
}
controller->SetLedsDirect(colour);
}
void RGBController_BloodyMouse::UpdateZoneLEDs(int /*zone*/)
{
DeviceUpdateLEDs();
}
void RGBController_BloodyMouse::UpdateSingleLED(int /*led*/)
{
DeviceUpdateLEDs();
}
void RGBController_BloodyMouse::DeviceUpdateMode()
{
/*---------------------------------------------------------*\
| This device only supports Direct mode |
\*---------------------------------------------------------*/
}

40
Controllers/A4TechController/BloodyMouseController/RGBController_BloodyMouse.h Normal file
View File

@@ -0,0 +1,40 @@
/*---------------------------------------------------------------------*\
| RGBController_BloodyMouse.h |
| |
| Driver for BloodyMouse USB Controller |
| |
| Chris M (Dr_No) 30 Jun 2022 |
| |
\*---------------------------------------------------------------------*/
#pragma once
#include <vector>
#include "RGBController.h"
#include "BloodyMouseController.h"
struct mouse_zone
{
std::string name;
std::vector<uint8_t> zone_leds;
};
typedef std::vector<mouse_zone> mouse_layout;
class RGBController_BloodyMouse : public RGBController
{
public:
RGBController_BloodyMouse(BloodyMouseController* controller_ptr);
~RGBController_BloodyMouse();
void SetupZones();
void ResizeZone(int zone, int new_size);
void DeviceUpdateLEDs();
void UpdateZoneLEDs(int zone);
void UpdateSingleLED(int led);
void DeviceUpdateMode();
private:
BloodyMouseController* controller;
};