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/SapphireGPUController/SapphireNitroGlowV3Controller/RGBController_SapphireNitroGlowV3.cpp
+253
View File
@@ -0,0 +1,253 @@
/*---------------------------------------------------------*\
| RGBController_SapphireNitroGlowV3.cpp |
| |
| RGBController for Sapphire Nitro Glow V3 |
| |
| K900 03 Feb 2021 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include "RGBController_SapphireNitroGlowV3.h"
/**------------------------------------------------------------------*\
@name Sapphire Nitro Glow v3
@category GPU
@type I2C
@save :x:
@direct :x:
@effects :white_check_mark:
@detectors DetectSapphireV3Controllers
@comment
\*-------------------------------------------------------------------*/
RGBController_SapphireNitroGlowV3::RGBController_SapphireNitroGlowV3(SapphireNitroGlowV3Controller* controller_ptr)
{
controller = controller_ptr;
name = controller->GetDeviceName();
vendor = "Sapphire";
description = "Sapphire Nitro Glow V3 Device";
location = controller->GetDeviceLocation();
type = DEVICE_TYPE_GPU;
mode Static;
Static.name = "Static";
Static.value = SAPPHIRE_NITRO_GLOW_V3_MODE_CUSTOM;
Static.flags = MODE_FLAG_HAS_PER_LED_COLOR;
Static.color_mode = MODE_COLORS_PER_LED;
modes.push_back(Static);
mode Rainbow;
Rainbow.name = "Rainbow Wave";
Rainbow.value = SAPPHIRE_NITRO_GLOW_V3_MODE_RAINBOW;
Rainbow.flags = MODE_FLAG_HAS_SPEED;
Rainbow.speed_min = 10;
Rainbow.speed_max = 250;
Rainbow.color_mode = MODE_COLORS_NONE;
modes.push_back(Rainbow);
mode Runway;
Runway.name = "Runway";
Runway.value = SAPPHIRE_NITRO_GLOW_V3_MODE_RUNWAY;
Runway.flags = MODE_FLAG_HAS_SPEED;
Runway.speed_min = 5;
Runway.speed_max = 50;
Runway.color_mode = MODE_COLORS_NONE;
modes.push_back(Runway);
mode ColorCycle;
ColorCycle.name = "Spectrum Cycle";
ColorCycle.value = SAPPHIRE_NITRO_GLOW_V3_MODE_COLOR_CYCLE;
ColorCycle.flags = MODE_FLAG_HAS_SPEED;
ColorCycle.speed_min = 30;
ColorCycle.speed_max = 1;
ColorCycle.color_mode = MODE_COLORS_NONE;
modes.push_back(ColorCycle);
mode Serial;
Serial.name = "Serial";
Serial.value = SAPPHIRE_NITRO_GLOW_V3_MODE_SERIAL;
Serial.flags = MODE_FLAG_HAS_SPEED;
Serial.speed_min = 255;
Serial.speed_max = 5;
Serial.color_mode = MODE_COLORS_NONE;
modes.push_back(Serial);
mode External;
External.name = "External Control";
External.value = SAPPHIRE_NITRO_GLOW_V3_MODE_EXTERNAL_CONTROL;
External.flags = 0;
External.color_mode = MODE_COLORS_NONE;
modes.push_back(External);
mode Off;
Off.name = "Off";
Off.value = SAPPHIRE_NITRO_GLOW_V3_MODE_OFF;
Off.flags = 0;
Off.color_mode = MODE_COLORS_NONE;
modes.push_back(Off);
SetupZones();
ReadConfiguration();
}
RGBController_SapphireNitroGlowV3::~RGBController_SapphireNitroGlowV3()
{
delete controller;
}
void RGBController_SapphireNitroGlowV3::SetupZones()
{
/*---------------------------------------------------------*\
| This device only has one LED, so create a single zone and |
| LED for it |
\*---------------------------------------------------------*/
zone* new_zone = new zone();
led* new_led = new led();
new_zone->name = "GPU Zone";
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;
new_led->name = "GPU LED";
/*---------------------------------------------------------*\
| Push the zone and LED on to device vectors |
\*---------------------------------------------------------*/
leds.push_back(*new_led);
zones.push_back(*new_zone);
SetupColors();
}
void RGBController_SapphireNitroGlowV3::ReadConfiguration()
{
modes[1].speed = controller->GetRainbowAnimationSpeed();
modes[2].speed = controller->GetRunwayAnimationSpeed();
modes[3].speed = controller->GetColorCycleAnimationSpeed();
modes[4].speed = controller->GetSerialAnimationSpeed();
colors[0] = ToRGBColor(
controller->GetRed(),
controller->GetBlue(),
controller->GetGreen()
);
if(controller->GetExternalControl())
{
active_mode = 5;
return;
}
switch(controller->GetMode())
{
case SAPPHIRE_NITRO_GLOW_V3_MODE_CUSTOM:
active_mode = 0;
break;
case SAPPHIRE_NITRO_GLOW_V3_MODE_RAINBOW:
active_mode = 1;
break;
case SAPPHIRE_NITRO_GLOW_V3_MODE_RUNWAY:
active_mode = 2;
break;
case SAPPHIRE_NITRO_GLOW_V3_MODE_COLOR_CYCLE:
active_mode = 3;
break;
case SAPPHIRE_NITRO_GLOW_V3_MODE_SERIAL:
active_mode = 4;
break;
case SAPPHIRE_NITRO_GLOW_V3_MODE_OFF:
active_mode = 6;
colors[0] = ToRGBColor(0, 0, 0);
break;
default:
active_mode = 0;
break;
}
}
void RGBController_SapphireNitroGlowV3::ResizeZone(int /*zone*/, int /*new_size*/)
{
/*---------------------------------------------------------*\
| This device does not support resizing zones |
\*---------------------------------------------------------*/
}
void RGBController_SapphireNitroGlowV3::DeviceUpdateLEDs()
{
RGBColor color = colors[0];
unsigned char red = RGBGetRValue(color);
unsigned char grn = RGBGetGValue(color);
unsigned char blu = RGBGetBValue(color);
controller->SetColor(red, grn, blu);
}
void RGBController_SapphireNitroGlowV3::UpdateZoneLEDs(int /*zone*/)
{
DeviceUpdateLEDs();
}
void RGBController_SapphireNitroGlowV3::UpdateSingleLED(int /*led*/)
{
DeviceUpdateLEDs();
}
void RGBController_SapphireNitroGlowV3::DeviceUpdateMode()
{
auto mode = modes[active_mode];
switch(mode.value)
{
case SAPPHIRE_NITRO_GLOW_V3_MODE_CUSTOM:
controller->SetExternalControl(false);
controller->SetMode(mode.value);
break;
case SAPPHIRE_NITRO_GLOW_V3_MODE_RAINBOW:
controller->SetExternalControl(false);
controller->SetRainbowAnimationSpeed(mode.speed);
controller->SetMode(mode.value);
break;
case SAPPHIRE_NITRO_GLOW_V3_MODE_RUNWAY:
controller->SetExternalControl(false);
controller->SetRunwayAnimationSpeed(mode.speed);
controller->SetMode(mode.value);
break;
case SAPPHIRE_NITRO_GLOW_V3_MODE_COLOR_CYCLE:
controller->SetExternalControl(false);
controller->SetColorCycleAnimationSpeed(mode.speed);
controller->SetMode(mode.value);
break;
case SAPPHIRE_NITRO_GLOW_V3_MODE_SERIAL:
controller->SetExternalControl(false);
controller->SetSerialAnimationSpeed(mode.speed);
controller->SetMode(mode.value);
break;
case SAPPHIRE_NITRO_GLOW_V3_MODE_EXTERNAL_CONTROL:
controller->SetExternalControl(true);
break;
case SAPPHIRE_NITRO_GLOW_V3_MODE_OFF:
controller->SetExternalControl(false);
controller->SetColor(0, 0, 0);
controller->SetMode(mode.value);
break;
}
}
Controllers/SapphireGPUController/SapphireNitroGlowV3Controller/RGBController_SapphireNitroGlowV3.h
+36
View File
@@ -0,0 +1,36 @@
/*---------------------------------------------------------*\
| RGBController_SapphireNitroGlowV3.h |
| |
| RGBController for Sapphire Nitro Glow V3 |
| |
| K900 03 Feb 2021 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#pragma once
#include "RGBController.h"
#include "SapphireNitroGlowV3Controller.h"
class RGBController_SapphireNitroGlowV3 : public RGBController
{
public:
RGBController_SapphireNitroGlowV3(SapphireNitroGlowV3Controller* controller_ptr);
~RGBController_SapphireNitroGlowV3();
void SetupZones();
void ResizeZone(int zone, int new_size);
void DeviceUpdateLEDs();
void UpdateZoneLEDs(int zone);
void UpdateSingleLED(int led);
void DeviceUpdateMode();
private:
SapphireNitroGlowV3Controller* controller;
void ReadConfiguration();
};
Controllers/SapphireGPUController/SapphireNitroGlowV3Controller/SapphireNitroGlowV3Controller.cpp
+141
View File
@@ -0,0 +1,141 @@
/*---------------------------------------------------------*\
| SapphireNitroGlowV3Controller.cpp |
| |
| Driver for Sapphire Nitro Glow V3 |
| |
| K900 03 Feb 2021 |
| |
| This file is part of the OpenRGB project |
| SPDX-License-Identifier: GPL-2.0-or-later |
\*---------------------------------------------------------*/
#include "SapphireNitroGlowV3Controller.h"
SapphireNitroGlowV3Controller::SapphireNitroGlowV3Controller(i2c_smbus_interface* bus, sapphire_dev_id dev, std::string dev_name)
{
this->bus = bus;
this->dev = dev;
this->name = dev_name;
}
SapphireNitroGlowV3Controller::~SapphireNitroGlowV3Controller()
{
}
std::string SapphireNitroGlowV3Controller::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 SapphireNitroGlowV3Controller::GetDeviceName()
{
return(name);
}
unsigned char SapphireNitroGlowV3Controller::GetRed()
{
return(bus->i2c_smbus_read_byte_data(dev, SAPPHIRE_NITRO_GLOW_V3_REG_RED));
}
unsigned char SapphireNitroGlowV3Controller::GetGreen()
{
return(bus->i2c_smbus_read_byte_data(dev, SAPPHIRE_NITRO_GLOW_V3_REG_GREEN));
}
unsigned char SapphireNitroGlowV3Controller::GetBlue()
{
return(bus->i2c_smbus_read_byte_data(dev, SAPPHIRE_NITRO_GLOW_V3_REG_BLUE));
}
void SapphireNitroGlowV3Controller::SetColor(unsigned char red, unsigned char green, unsigned char blue)
{
bus->i2c_smbus_write_byte_data(dev, SAPPHIRE_NITRO_GLOW_V3_REG_RED, red);
bus->i2c_smbus_write_byte_data(dev, SAPPHIRE_NITRO_GLOW_V3_REG_GREEN, green);
bus->i2c_smbus_write_byte_data(dev, SAPPHIRE_NITRO_GLOW_V3_REG_BLUE, blue);
}
unsigned char SapphireNitroGlowV3Controller::GetMode()
{
return(bus->i2c_smbus_read_byte_data(dev, SAPPHIRE_NITRO_GLOW_V3_REG_MODE));
}
void SapphireNitroGlowV3Controller::SetMode(unsigned char mode)
{
bus->i2c_smbus_write_byte_data(dev, SAPPHIRE_NITRO_GLOW_V3_REG_MODE, mode);
}
bool SapphireNitroGlowV3Controller::GetExternalControl()
{
return((bool)bus->i2c_smbus_read_byte_data(dev, SAPPHIRE_NITRO_GLOW_V3_REG_EXTERNAL_CONTROL));
}
void SapphireNitroGlowV3Controller::SetExternalControl(bool enabled)
{
bus->i2c_smbus_write_byte_data(dev, SAPPHIRE_NITRO_GLOW_V3_REG_EXTERNAL_CONTROL, (unsigned char)enabled);
}
unsigned char SapphireNitroGlowV3Controller::GetBrightness()
{
return(bus->i2c_smbus_read_byte_data(dev, SAPPHIRE_NITRO_GLOW_V3_REG_BRIGHTNESS));
}
void SapphireNitroGlowV3Controller::SetBrightness(unsigned char brightness)
{
bus->i2c_smbus_write_byte_data(dev, SAPPHIRE_NITRO_GLOW_V3_REG_BRIGHTNESS, brightness);
}
unsigned char SapphireNitroGlowV3Controller::GetRainbowAnimationSpeed()
{
return(bus->i2c_smbus_read_byte_data(dev, SAPPHIRE_NITRO_GLOW_V3_REG_RAINBOW_ANIMATION_SPEED));
}
void SapphireNitroGlowV3Controller::SetRainbowAnimationSpeed(unsigned char speed)
{
bus->i2c_smbus_write_byte_data(dev, SAPPHIRE_NITRO_GLOW_V3_REG_RAINBOW_ANIMATION_SPEED, speed);
}
unsigned char SapphireNitroGlowV3Controller::GetRunwayAnimationSpeed()
{
return(bus->i2c_smbus_read_byte_data(dev, SAPPHIRE_NITRO_GLOW_V3_REG_RUNWAY_ANIMATION_SPEED));
}
void SapphireNitroGlowV3Controller::SetRunwayAnimationSpeed(unsigned char speed)
{
bus->i2c_smbus_write_byte_data(dev, SAPPHIRE_NITRO_GLOW_V3_REG_RUNWAY_ANIMATION_SPEED, speed);
}
unsigned char SapphireNitroGlowV3Controller::GetRunwayAnimationRepeatCount()
{
return(bus->i2c_smbus_read_byte_data(dev, SAPPHIRE_NITRO_GLOW_V3_REG_RUNWAY_ANIMATION_REPEAT_COUNT));
}
void SapphireNitroGlowV3Controller::SetRunwayAnimationRepeatCount(unsigned char count)
{
bus->i2c_smbus_write_byte_data(dev, SAPPHIRE_NITRO_GLOW_V3_REG_RUNWAY_ANIMATION_REPEAT_COUNT, count);
}
unsigned char SapphireNitroGlowV3Controller::GetColorCycleAnimationSpeed()
{
return(bus->i2c_smbus_read_byte_data(dev, SAPPHIRE_NITRO_GLOW_V3_REG_COLOR_CYCLE_ANIMATION_SPEED));
}
void SapphireNitroGlowV3Controller::SetColorCycleAnimationSpeed(unsigned char speed)
{
bus->i2c_smbus_write_byte_data(dev, SAPPHIRE_NITRO_GLOW_V3_REG_COLOR_CYCLE_ANIMATION_SPEED, speed);
}
unsigned char SapphireNitroGlowV3Controller::GetSerialAnimationSpeed()
{
return(bus->i2c_smbus_read_byte_data(dev, SAPPHIRE_NITRO_GLOW_V3_REG_SERIAL_ANIMATION_SPEED));
}
void SapphireNitroGlowV3Controller::SetSerialAnimationSpeed(unsigned char speed)
{
bus->i2c_smbus_write_byte_data(dev, SAPPHIRE_NITRO_GLOW_V3_REG_SERIAL_ANIMATION_SPEED, speed);
}
Controllers/SapphireGPUController/SapphireNitroGlowV3Controller/SapphireNitroGlowV3Controller.h
+91
View File
@@ -0,0 +1,91 @@
/*---------------------------------------------------------*\
| SapphireNitroGlowV3Controller.h |
| |
| Driver for Sapphire Nitro Glow V3 |
| |
| K900 03 Feb 2021 |
| |
| 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 sapphire_dev_id;
enum
{
SAPPHIRE_NITRO_GLOW_V3_REG_MODE = 0x10,
SAPPHIRE_NITRO_GLOW_V3_REG_EXTERNAL_CONTROL = 0x0F,
SAPPHIRE_NITRO_GLOW_V3_REG_BRIGHTNESS = 0x3E,
SAPPHIRE_NITRO_GLOW_V3_REG_RUNWAY_ANIMATION_SPEED = 0x11,
SAPPHIRE_NITRO_GLOW_V3_REG_RUNWAY_ANIMATION_REPEAT_COUNT = 0x12,
SAPPHIRE_NITRO_GLOW_V3_REG_COLOR_CYCLE_ANIMATION_SPEED = 0x13,
SAPPHIRE_NITRO_GLOW_V3_REG_RAINBOW_ANIMATION_SPEED = 0x15,
SAPPHIRE_NITRO_GLOW_V3_REG_SERIAL_ANIMATION_SPEED = 0x16,
SAPPHIRE_NITRO_GLOW_V3_REG_MUSIC_VOLUME = 0x29,
SAPPHIRE_NITRO_GLOW_V3_REG_RED = 0x1A,
SAPPHIRE_NITRO_GLOW_V3_REG_GREEN = 0x1B,
SAPPHIRE_NITRO_GLOW_V3_REG_BLUE = 0x1C,
};
enum
{
SAPPHIRE_NITRO_GLOW_V3_MODE_RAINBOW = 0x00,
SAPPHIRE_NITRO_GLOW_V3_MODE_RUNWAY = 0x01,
SAPPHIRE_NITRO_GLOW_V3_MODE_COLOR_CYCLE = 0x02,
SAPPHIRE_NITRO_GLOW_V3_MODE_SERIAL = 0x03,
SAPPHIRE_NITRO_GLOW_V3_MODE_SAPPHIRE_BLUE = 0x04,
SAPPHIRE_NITRO_GLOW_V3_MODE_AUDIO_VISUALIZATION = 0x05,
SAPPHIRE_NITRO_GLOW_V3_MODE_CUSTOM = 0x06,
SAPPHIRE_NITRO_GLOW_V3_MODE_OFF = 0x07,
SAPPHIRE_NITRO_GLOW_V3_MODE_EXTERNAL_CONTROL = 0xFF,
};
class SapphireNitroGlowV3Controller
{
public:
SapphireNitroGlowV3Controller(i2c_smbus_interface* bus, sapphire_dev_id dev, std::string dev_name);
~SapphireNitroGlowV3Controller();
std::string GetDeviceLocation();
std::string GetDeviceName();
unsigned char GetRed();
unsigned char GetGreen();
unsigned char GetBlue();
void SetColor(unsigned char red, unsigned char green, unsigned char blue);
unsigned char GetMode();
void SetMode(unsigned char mode);
bool GetExternalControl();
void SetExternalControl(bool enabled);
unsigned char GetBrightness();
void SetBrightness(unsigned char brightness);
unsigned char GetRainbowAnimationSpeed();
void SetRainbowAnimationSpeed(unsigned char speed);
unsigned char GetRunwayAnimationSpeed();
void SetRunwayAnimationSpeed(unsigned char speed);
unsigned char GetRunwayAnimationRepeatCount();
void SetRunwayAnimationRepeatCount(unsigned char count);
unsigned char GetColorCycleAnimationSpeed();
void SetColorCycleAnimationSpeed(unsigned char speed);
unsigned char GetSerialAnimationSpeed();
void SetSerialAnimationSpeed(unsigned char speed);
private:
i2c_smbus_interface* bus;
sapphire_dev_id dev;
std::string name;
};