Jens/LumaOps-Public
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Publish LumaOps source

Browse Source
This commit is contained in:
LumaOps release export
2026-09-03 01:18:36 +02:00
commit 7f1c0e5f71
2363 changed files with 501543 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Controllers/GalaxGPUController/GalaxGPUv1Controller/GalaxGPUv1Controller.cpp
+108
View File
@@ -0,0 +1,108 @@
/*---------------------------------------------------------*\
| GalaxGPUv1Controller.cpp |
| |
| Driver for Galax/KFA2 GPU |
| |
| Niels Westphal (crashniels) 12 Jul 2020 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include <cstring>
#include "GalaxGPUv1Controller.h"
GalaxGPUv1Controller::GalaxGPUv1Controller(i2c_smbus_interface* bus, galax_gpu_dev_id dev, std::string dev_name)
{
this->bus = bus;
this->dev = dev;
this->name = dev_name;
}
GalaxGPUv1Controller::~GalaxGPUv1Controller()
{
}
std::string GalaxGPUv1Controller::GetDeviceLocation()
{
std::string return_string(bus->device_name);
char addr[5];
snprintf(addr, 5, "0x%02X", dev);
return_string.append(", address ");
return_string.append(addr);
return("I2C: " + return_string);
}
std::string GalaxGPUv1Controller::GetDeviceName()
{
return(name);
}
unsigned char GalaxGPUv1Controller::GetLEDRed()
{
return(GalaxGPURegisterRead(GALAX_V1_RED_REGISTER));
}
unsigned char GalaxGPUv1Controller::GetLEDGreen()
{
return(GalaxGPURegisterRead(GALAX_V1_GREEN_REGISTER));
}
unsigned char GalaxGPUv1Controller::GetLEDBlue()
{
return(GalaxGPURegisterRead(GALAX_V1_BLUE_REGISTER));
}
void GalaxGPUv1Controller::SetLEDColorsDirect(unsigned char red, unsigned char green, unsigned char blue) // Direct Mode is just Static Mode without applying color changes
{
GalaxGPURegisterWrite(GALAX_V1_RED_REGISTER, red);
GalaxGPURegisterWrite(GALAX_V1_GREEN_REGISTER, green);
GalaxGPURegisterWrite(GALAX_V1_BLUE_REGISTER, blue);
}
void GalaxGPUv1Controller::SetLEDColorsEffect(unsigned char red, unsigned char green, unsigned char blue)
{
GalaxGPURegisterWrite(GALAX_V1_RED_REGISTER, red);
GalaxGPURegisterWrite(GALAX_V1_GREEN_REGISTER, green);
GalaxGPURegisterWrite(GALAX_V1_BLUE_REGISTER, blue);
}
void GalaxGPUv1Controller::SetMode(unsigned char mode)
{
switch(mode)
{
case 1:
GalaxGPURegisterWrite(GALAX_V1_MODE_REGISTER_1, GALAX_V1_MODE_STATIC_VALUE_1);
GalaxGPURegisterWrite(GALAX_V1_MODE_REGISTER_2, GALAX_V1_MODE_STATIC_VALUE_2);
break;
case 2:
GalaxGPURegisterWrite(GALAX_V1_MODE_REGISTER_1, GALAX_V1_MODE_BREATHING_VALUE_1);
GalaxGPURegisterWrite(GALAX_V1_MODE_REGISTER_2, GALAX_V1_MODE_BREATHING_VALUE_2);
break;
case 3:
GalaxGPURegisterWrite(GALAX_V1_MODE_REGISTER_1, GALAX_V1_MODE_RAINBOW_VALUE_1);
GalaxGPURegisterWrite(GALAX_V1_MODE_REGISTER_2, GALAX_V1_MODE_RAINBOW_VALUE_2);
break;
case 4:
GalaxGPURegisterWrite(GALAX_V1_MODE_REGISTER_1, GALAX_V1_MODE_CYCLE_BREATHING_VALUE_1);
GalaxGPURegisterWrite(GALAX_V1_MODE_REGISTER_2, GALAX_V1_MODE_CYCLE_BREATHING_VALUE_2);
break;
default:
break;
}
}
unsigned char GalaxGPUv1Controller::GalaxGPURegisterRead(unsigned char reg)
{
return(bus->i2c_smbus_read_byte_data(dev, reg));
}
void GalaxGPUv1Controller::GalaxGPURegisterWrite(unsigned char reg, unsigned char val)
{
bus->i2c_smbus_write_byte_data(dev, reg, val);
}
Controllers/GalaxGPUController/GalaxGPUv1Controller/GalaxGPUv1Controller.h
+70
View File
@@ -0,0 +1,70 @@
/*---------------------------------------------------------*\
| GalaxGPUv1Controller.h |
| |
| Driver for Galax/KFA2 GPU |
| |
| Niels Westphal (crashniels) 12 Jul 2020 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#pragma once
#include <string>
#include "i2c_smbus.h"
typedef unsigned char galax_gpu_dev_id;
enum
{
/* RGB Registers */
GALAX_V1_RED_REGISTER = 0x02, /* Red Register */
GALAX_V1_GREEN_REGISTER = 0x03, /* Green Register */
GALAX_V1_BLUE_REGISTER = 0x04, /* Blue Register */
/* MODE Registers */
GALAX_V1_MODE_REGISTER_1 = 0x05, /* Mode Register 1 */
GALAX_V1_MODE_REGISTER_2 = 0x06, /* Mode Register 2 */
};
enum
{
/* Static Mode Values */
GALAX_V1_MODE_STATIC_VALUE_1 = 0x00,
GALAX_V1_MODE_STATIC_VALUE_2 = 0x01,
/* Breathing Mode Values */
GALAX_V1_MODE_BREATHING_VALUE_1 = 0x04,
GALAX_V1_MODE_BREATHING_VALUE_2 = 0x00,
/* Rainbow Mode Values */
GALAX_V1_MODE_RAINBOW_VALUE_1 = 0x84,
GALAX_V1_MODE_RAINBOW_VALUE_2 = 0x02,
/* Cycle Breathing Mode Values */
GALAX_V1_MODE_CYCLE_BREATHING_VALUE_1 = 0x84,
GALAX_V1_MODE_CYCLE_BREATHING_VALUE_2 = 0x40,
};
class GalaxGPUv1Controller
{
public:
GalaxGPUv1Controller(i2c_smbus_interface* bus, galax_gpu_dev_id, std::string dev_name);
~GalaxGPUv1Controller();
std::string GetDeviceLocation();
std::string GetDeviceName();
unsigned char GetLEDRed();
unsigned char GetLEDGreen();
unsigned char GetLEDBlue();
void SetLEDColorsDirect(unsigned char red, unsigned char green, unsigned char blue);
void SetLEDColorsEffect(unsigned char red, unsigned char green, unsigned char blue);
void SetMode(unsigned char mode);
unsigned char GalaxGPURegisterRead(unsigned char reg);
void GalaxGPURegisterWrite(unsigned char reg, unsigned char val);
bool direct = false; // Temporary solution to check if we are in "Direct" mode
private:
i2c_smbus_interface * bus;
galax_gpu_dev_id dev;
std::string name;
};
Controllers/GalaxGPUController/GalaxGPUv1Controller/RGBController_GalaxGPUv1.cpp
+179
View File
@@ -0,0 +1,179 @@
/*---------------------------------------------------------*\
| RGBController_GalaxGPUv1.cpp |
| |
| RGBController for Galax/KFA2 GPU |
| |
| Niels Westphal (crashniels) 12 Jul 2020 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include "RGBController_GalaxGPUv1.h"
int RGBController_GalaxGPUv1::GetDeviceMode()
{
int modereg1 = controller->GalaxGPURegisterRead(GALAX_V1_MODE_REGISTER_1);
int modereg2 = controller->GalaxGPURegisterRead(GALAX_V1_MODE_REGISTER_2);
if(modereg1 == GALAX_V1_MODE_STATIC_VALUE_1 && modereg2 == GALAX_V1_MODE_STATIC_VALUE_2)
{
active_mode = 1;
modes[active_mode].color_mode = MODE_COLORS_PER_LED;
}
if(modereg1 == GALAX_V1_MODE_BREATHING_VALUE_1 && modereg2 == GALAX_V1_MODE_BREATHING_VALUE_2)
{
active_mode = 2;
modes[active_mode].color_mode = MODE_COLORS_PER_LED;
}
if(modereg1 == GALAX_V1_MODE_RAINBOW_VALUE_1 && modereg2 == GALAX_V1_MODE_RAINBOW_VALUE_2)
{
active_mode = 3;
modes[active_mode].color_mode = MODE_COLORS_NONE;
}
if(modereg1 == GALAX_V1_MODE_CYCLE_BREATHING_VALUE_1 && modereg2 == GALAX_V1_MODE_CYCLE_BREATHING_VALUE_2)
{
active_mode = 4;
modes[active_mode].color_mode = MODE_COLORS_NONE;
}
return(active_mode);
}
/**------------------------------------------------------------------*\
@name Galax GPU v1
@category GPU
@type I2C
@save :x:
@direct :white_check_mark:
@effects :white_check_mark:
@detectors DetectGalaxGPUv1Controllers
@comment
\*-------------------------------------------------------------------*/
RGBController_GalaxGPUv1::RGBController_GalaxGPUv1(GalaxGPUv1Controller* controller_ptr)
{
controller = controller_ptr;
name = controller->GetDeviceName();
vendor = "GALAX";
type = DEVICE_TYPE_GPU;
description = "GALAX / KFA2 RTX GPU";
location = controller->GetDeviceLocation();
mode Direct;
Direct.name = "Direct";
Direct.value = 1;
Direct.flags = MODE_FLAG_HAS_PER_LED_COLOR;
Direct.color_mode = MODE_COLORS_PER_LED;
modes.push_back(Direct);
mode Breathing;
Breathing.name = "Breathing";
Breathing.value = 2;
Breathing.flags = MODE_FLAG_HAS_PER_LED_COLOR;
Breathing.color_mode = MODE_COLORS_PER_LED;
modes.push_back(Breathing);
mode Rainbow;
Rainbow.name = "Rainbow";
Rainbow.value = 3;
Rainbow.flags = 0;
Rainbow.color_mode = MODE_COLORS_NONE;
modes.push_back(Rainbow);
mode Cycle_Breathing;
Cycle_Breathing.name = "Cycle Breathing";
Cycle_Breathing.value = 4;
Cycle_Breathing.flags = 0;
Cycle_Breathing.color_mode = MODE_COLORS_NONE;
modes.push_back(Cycle_Breathing);
SetupZones();
active_mode = GetDeviceMode();
}
RGBController_GalaxGPUv1::~RGBController_GalaxGPUv1()
{
delete controller;
}
void RGBController_GalaxGPUv1::SetupZones()
{
/*---------------------------------------------------------*\
| Set up zone |
\*---------------------------------------------------------*/
zone galax_gpu_zone;
galax_gpu_zone.name = "GPU";
galax_gpu_zone.type = ZONE_TYPE_SINGLE;
galax_gpu_zone.leds_min = 1;
galax_gpu_zone.leds_max = 1;
galax_gpu_zone.leds_count = 1;
galax_gpu_zone.matrix_map = NULL;
zones.push_back(galax_gpu_zone);
/*---------------------------------------------------------*\
| Set up LED |
\*---------------------------------------------------------*/
led galax_gpu_led;
galax_gpu_led.name = "GPU";
leds.push_back(galax_gpu_led);
SetupColors();
/*---------------------------------------------------------*\
| Initialize color |
\*---------------------------------------------------------*/
unsigned char red = controller->GetLEDRed();
unsigned char grn = controller->GetLEDGreen();
unsigned char blu = controller->GetLEDBlue();
colors[0] = ToRGBColor(red, grn, blu);
}
void RGBController_GalaxGPUv1::ResizeZone(int /*zone*/, int /*new_size*/)
{
/*---------------------------------------------------------*\
| This device does not support resizing zones |
\*---------------------------------------------------------*/
}
void RGBController_GalaxGPUv1::DeviceUpdateLEDs()
{
for(std::size_t led = 0; led < colors.size(); led++)
{
unsigned char red = RGBGetRValue(colors[led]);
unsigned char grn = RGBGetGValue(colors[led]);
unsigned char blu = RGBGetBValue(colors[led]);
if(GetMode() == 1)
{
controller->SetLEDColorsDirect(red, grn, blu);
}
else
{
controller->SetLEDColorsEffect(red, grn, blu);
}
}
}
void RGBController_GalaxGPUv1::UpdateZoneLEDs(int /*zone*/)
{
DeviceUpdateLEDs();
}
void RGBController_GalaxGPUv1::UpdateSingleLED(int /*led*/)
{
DeviceUpdateLEDs();
}
void RGBController_GalaxGPUv1::DeviceUpdateMode()
{
int new_mode = modes[active_mode].value;
controller->SetMode(new_mode);
}
Controllers/GalaxGPUController/GalaxGPUv1Controller/RGBController_GalaxGPUv1.h
+37
View File
@@ -0,0 +1,37 @@
/*---------------------------------------------------------*\
| RGBController_GalaxGPUv1.h |
| |
| RGBController for Galax/KFA2 GPU |
| |
| Niels Westphal (crashniels) 12 Jul 2020 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#pragma once
#include "RGBController.h"
#include "GalaxGPUv1Controller.h"
class RGBController_GalaxGPUv1 : public RGBController
{
public:
RGBController_GalaxGPUv1(GalaxGPUv1Controller* controller_ptr);
~RGBController_GalaxGPUv1();
void SetupZones();
void ResizeZone(int zone, int new_size);
void DeviceUpdateLEDs();
void UpdateZoneLEDs(int zone);
void UpdateSingleLED(int led);
void DeviceUpdateMode();
private:
GalaxGPUv1Controller* controller;
int GetDeviceMode();
};