qmk-rgb/internal/rgb/effects.go

package rgb

import (
	"fmt"
	"math"
	"strconv"
)

// Effect defines an RGB lighting effect.
type Effect uint8

const (
	Static       Effect = 0
	Breathing    Effect = 1
	EffectAlmond Effect = 2
	BandSat      Effect = 3
	BandVal      Effect = 4
	BandHue      Effect = 5
	Chroma       Effect = 6
	Rainbow      Effect = 7
	RainbowWave  Effect = 8
	Dance        Effect = 9
	RainbowDance Effect = 10
	ChromaDance  Effect = 11
	Snake        Effect = 12
	Tail         Effect = 13
	Split        Effect = 14
	Heartbeat    Effect = 15
	Blink        Effect = 16
	BlinkStatic  Effect = 17
	Gradient     Effect = 18
	Testing      Effect = 19
)

// EffectName returns the human-readable name of an effect.
func (e Effect) String() string {
	names := map[Effect]string{
		Static:       "static",
		Breathing:    "breathing",
		EffectAlmond: "almond",
		BandSat:      "band_sat",
		BandVal:      "band_val",
		BandHue:      "band_hue",
		Chroma:       "chroma",
		Rainbow:      "rainbow",
		RainbowWave:  "rainbow_wave",
		Dance:        "dance",
		RainbowDance: "rainbow_dance",
		ChromaDance:  "chroma_dance",
		Snake:        "snake",
		Tail:         "tail",
		Split:        "split",
		Heartbeat:    "heartbeat",
		Blink:        "blink",
		BlinkStatic:  "blink_static",
		Gradient:     "gradient",
		Testing:      "testing",
	}
	if name, ok := names[e]; ok {
		return name
	}
	return "unknown"
}

// ParseEffect converts a string name to an Effect.
func ParseEffect(name string) (Effect, error) {
	switch name {
	case "static":
		return Static, nil
	case "breathing":
		return Breathing, nil
	case "almond":
		return EffectAlmond, nil
	case "band_sat":
		return BandSat, nil
	case "band_val":
		return BandVal, nil
	case "band_hue":
		return BandHue, nil
	case "chroma":
		return Chroma, nil
	case "rainbow":
		return Rainbow, nil
	case "rainbow_wave":
		return RainbowWave, nil
	case "dance":
		return Dance, nil
	case "rainbow_dance":
		return RainbowDance, nil
	case "chroma_dance":
		return ChromaDance, nil
	case "snake":
		return Snake, nil
	case "tail":
		return Tail, nil
	case "split":
		return Split, nil
	case "heartbeat":
		return Heartbeat, nil
	case "blink":
		return Blink, nil
	case "blink_static":
		return BlinkStatic, nil
	case "gradient":
		return Gradient, nil
	case "testing":
		return Testing, nil
	default:
		return 0, fmt.Errorf("unknown effect: %s", name)
	}
}

func Impact80EffectName(value uint8) string {
	switch value {
	case 0:
		return "none"
	case 1:
		return "wave"
	case 2:
		return "fixed_wave"
	case 3:
		return "spectrum"
	case 4:
		return "breathing"
	case 5:
		return "light"
	case 6:
		return "shutdown"
	default:
		return "unknown"
	}
}

func ParseImpact80Effect(name string) (uint8, error) {
	switch name {
	case "none", "off":
		return 0, nil
	case "wave", "rainbow_wave":
		return 1, nil
	case "fixed_wave":
		return 2, nil
	case "spectrum", "rainbow":
		return 3, nil
	case "breathing", "breathe":
		return 4, nil
	case "light", "static", "solid":
		return 5, nil
	case "shutdown":
		return 6, nil
	default:
		return 0, fmt.Errorf("unknown Impact 80 effect: %s", name)
	}
}

// LEDParam defines QMK rgblight parameter indices.
type LEDParam uint8

const (
	Brightness LEDParam = 1
	EffectID   LEDParam = 2
	Speed      LEDParam = 3
	ColorValue LEDParam = 4

	Mode   LEDParam = EffectID
	Enable LEDParam = EffectID
)

// Color represents an RGB color.
type Color struct {
	R uint8
	G uint8
	B uint8
}

// ParseHexColor parses a 6-digit hex color string (e.g. "ff0000").
func ParseHexColor(s string) (Color, error) {
	if len(s) != 6 {
		return Color{}, fmt.Errorf("invalid hex color: %s", s)
	}

	r, err := strconv.ParseUint(s[0:2], 16, 8)
	if err != nil {
		return Color{}, fmt.Errorf("invalid hex color: %s", s)
	}
	g, err := strconv.ParseUint(s[2:4], 16, 8)
	if err != nil {
		return Color{}, fmt.Errorf("invalid hex color: %s", s)
	}
	b, err := strconv.ParseUint(s[4:6], 16, 8)
	if err != nil {
		return Color{}, fmt.Errorf("invalid hex color: %s", s)
	}
	return Color{R: uint8(r), G: uint8(g), B: uint8(b)}, nil
}

// State represents the current RGB state from the keyboard.
type State struct {
	Enabled    bool
	Mode       Effect
	Brightness uint8
	Speed      uint8
	Color      Color
}

// HSV converts the color to HSV (QMK rgblight uses 0-255 ranges for H, S, V).
func (c Color) HSV() (h, s, v uint8) {
	r, g, b := float64(c.R), float64(c.G), float64(c.B)
	max := math.Max(r, math.Max(g, b))
	min := math.Min(r, math.Min(g, b))
	v = uint8(max)

	d := max - min
	if d == 0 {
		return 0, 0, v
	}

	if max > 0 {
		s = uint8((d / max) * 255)
	} else {
		return 0, 0, 0
	}

	var hFloat float64
	switch {
	case max == r:
		hFloat = ((g - b) / d) * 60.0
	case max == g:
		hFloat = ((b-r)/d)*60.0 + 120.0
	case max == b:
		hFloat = ((r-g)/d)*60.0 + 240.0
	}

	if hFloat < 0 {
		hFloat += 360.0
	}

	h = uint8((hFloat / 360.0) * 255.0)
	if h >= 255 {
		h = 254
	}

	return h, s, v
}