Google utilizza la tecnologia AI per tradurre i contenuti nella tua lingua preferita. Le traduzioni generate dall'AI potrebbero contenere errori.

Guida al dispositivo di illuminazione

I dispositivi di illuminazione utilizzano i tratti Matter standard per identificare gli apparecchi, attivare/disattivare gli stati di alimentazione e regolare i livelli di luminosità.

Il tipo di dispositivo di illuminazione più semplice è OnOffLight, che viene implementato con i tratti OnOff e Identify e supporta facoltativamente i tratti LevelControl e LightEffects.

Altri tipi di luci offrono funzionalità aggiuntive e vengono implementati con tratti diversi:

Tipo di dispositivo delle API Home	Tratti	App di esempio Kotlin	Caso d'uso
Luce con temperatura di colore `ColorTemperatureLightDevice` `home.matter.0000.types.010c` Un dispositivo di illuminazione che può essere acceso o spento e di cui è possibile regolare l'intensità della luce e la temperatura di colore.	Tratti obbligatori matter Identify matter OnOff matter LevelControl matter ColorControl Tratti facoltativi google LightEffects google ExtendedColorControl	on e off, luminosità	Chiaro
Luce dimmerabile `DimmableLightDevice` `home.matter.0000.types.0101` Un dispositivo di illuminazione che può essere acceso o spento, la cui intensità della luce può essere regolata e che può essere attivato tramite un sensore di presenza associato.	Tratti obbligatori matter Identify matter OnOff matter LevelControl Tratti facoltativi google LightEffects	on e off, luminosità	Chiaro
Luce a gamma cromatica estesa `ExtendedColorLightDevice` `home.matter.0000.types.010d` Un dispositivo di illuminazione che può essere acceso o spento, la cui intensità della luce e la temperatura di colore possono essere regolate e che può essere attivato tramite un sensore di presenza associato.	Tratti obbligatori matter Identify matter OnOff matter LevelControl matter ColorControl Tratti facoltativi google LightEffects google ExtendedColorControl	on e off, luminosità	Chiaro
Luce On/Off `OnOffLightDevice` `home.matter.0000.types.0100` Un dispositivo di illuminazione che può essere acceso o spento.	Tratti obbligatori matter Identify matter OnOff Tratti facoltativi matter LevelControl google LightEffects	on e off, luminosità	Chiaro

Controlla sempre il supporto di attributi e comandi per un dispositivo prima di utilizzare qualsiasi funzionalità o di tentare di aggiornare gli attributi. Per saperne di più, consulta Controlla i dispositivi su Android.

Prerequisiti

Prima di utilizzare i dispositivi di illuminazione e le curve di illuminazione, assicurati che l'app inizializzi Home SDK e includa le importazioni richieste:

import com.google.home.HomeDevice
import com.google.home.Structure
import com.google.home.google.DayOfWeek
import com.google.home.google.ExtendedColorControl
import com.google.home.google.ExtendedColorControlTrait
import com.google.home.google.LightingCurve
import com.google.home.google.LightingCurveTrait
import com.google.home.matter.standard.ColorControl
import com.google.home.matter.standard.ColorControlTrait
import com.google.home.matter.standard.ColorTemperatureLightDevice
import com.google.home.matter.standard.DimmableLightDevice
import com.google.home.matter.standard.ExtendedColorLightDevice
import com.google.home.matter.standard.GeneralDiagnostics
import com.google.home.matter.standard.Identify
import com.google.home.matter.standard.IdentifyTrait
import com.google.home.matter.standard.LevelControl
import com.google.home.matter.standard.LevelControlTrait
import com.google.home.matter.standard.OnOff
import com.google.home.matter.standard.OnOffLightDevice
import com.google.home.matter.standard.OnOffTrait
import com.google.home.matter.standard.RootNodeDevice
import kotlinx.coroutines.flow.first
import kotlinx.coroutines.flow.firstOrNull

Trova i dispositivi di illuminazione

Per trovare i dispositivi di illuminazione in una struttura, filtra l'elenco dei dispositivi per tipo, ad esempio OnOffLightDevice e DimmableLightDevice.

// Get all On/Off Light devices in the structure
val onOffLights: List<HomeDevice> =
  home.devices().list().filter { it.has(OnOffLightDevice) }

// Get all Dimmable Light devices in the structure
val dimmableLights: List<HomeDevice> =
  home.devices().list().filter { it.has(DimmableLightDevice) }

// Retrieve a specific device type instance to access its traits
val onOffLightDevice: OnOffLightDevice? =
  onOffLights.firstOrNull()?.type(OnOffLightDevice)?.firstOrNull()

val dimmableLightDevice: DimmableLightDevice? =
  dimmableLights.firstOrNull()?.type(DimmableLightDevice)?.firstOrNull()

Puoi anche recuperare tutti i dispositivi di illuminazione di più tipi di dispositivi di illuminazione in un unico filtro:

// Get a list of devices with similar device types (lights)
val lightDevices =
  home.devices().map { devices ->
    devices.filter {
      it.has(DimmableLightDevice) ||
        it.has(OnOffLightDevice) ||
        it.has(ColorTemperatureLightDevice) ||
        it.has(ExtendedColorLightDevice)
    }
  }

Ricevi informazioni di base su un dispositivo

Implementato nell'app di esempio per Android

Il tratto BasicInformation include informazioni come il nome del fornitore, l'ID fornitore, l'ID prodotto, il nome del prodotto (incluse le informazioni sul modello) e la versione software di un dispositivo:

// Get device basic information. All general information traits are on the RootNodeDevice type.
    device.type(RootNodeDevice).first().standardTraits.basicInformation?.let { basicInformation ->
        println("vendorName ${basicInformation.vendorName}")
        println("vendorId ${basicInformation.vendorId}")
        println("productId ${basicInformation.productId}")
        println("productName ${basicInformation.productName}")
        println("softwareVersion ${basicInformation.softwareVersion}")
    }

Identifica un dispositivo di illuminazione

Quando una stanza contiene più luci, puoi aiutare gli utenti a individuare un apparecchio fisico specifico attivando uno stato di identificazione visiva, ad esempio facendo lampeggiare la luce per alcuni secondi. Tutti e quattro i tipi di dispositivi luminosi richiedono il tratto Identify.

Chiama il comando identify con una durata identifyTime in secondi per avviare lo stato di identificazione. Se passi 0, lo stato di identificazione viene interrotto immediatamente. Puoi anche chiamare triggerEffect per eseguire un effetto visivo specifico, come Blink o Breathe.

suspend fun identifyLight(lightDevice: DimmableLightDevice) {
  val identifyTrait = lightDevice.standardTraits.identify ?: return

  // Blink the light for 10 seconds so the user can locate it
  if (identifyTrait.supports(Identify.Command.Identify)) {
    identifyTrait.identify(identifyTime = 10u)
  }

  // Or trigger a specific visual identification effect
  if (identifyTrait.supports(Identify.Command.TriggerEffect)) {
    identifyTrait.triggerEffect(
      effectIdentifier = IdentifyTrait.EffectIdentifierEnum.Blink,
      effectVariant = IdentifyTrait.EffectVariantEnum.Default
    )
  }
}

Controllare la connettività di un dispositivo di illuminazione

La connettività di un dispositivo viene effettivamente controllata a livello di tipo di dispositivo, perché alcuni dispositivi supportano più tipi di dispositivi. Lo stato restituito è una combinazione degli stati di connettività per tutti i trait di quel dispositivo.

let lightConnectivity =
  dimmableLightDeviceType.metadata.sourceConnectivity
  .connectivityState

In caso di tipi di dispositivi misti, potrebbe essere osservato uno stato di partiallyOnline quando non è presente una connessione a internet. I tratti standard Matter potrebbero essere ancora online grazie al routing locale, ma i tratti basati su cloud saranno offline.

Recupera l'indirizzo IP del dispositivo

Per trovare l'indirizzo IP del dispositivo, utilizza l'attributo networkInterfaces di GeneralDiagnosticsTrait. Gli indirizzi vengono restituiti come oggetti Data, che puoi formattare in stringhe IPv4 o IPv6 standard utilizzando il framework Network:

func getIpAddresses(trait: Matter.GeneralDiagnosticsTrait) -> [String] {
  let interfaces = trait.attributes.networkInterfaces ?? []
  var ipAddresses: [String] = []

  for interface in interfaces {
    for data in interface.iPv4Addresses {
      if let ipv4 = IPv4Address(data) {
        ipAddresses.append(String(describing: ipv4))
      }
    }
    for data in interface.iPv6Addresses {
      if let ipv6 = IPv6Address(data) {
        ipAddresses.append(String(describing: ipv6))
      }
    }
  }

  return ipAddresses
}

Controlla i dispositivi di illuminazione

I tipi di dispositivi OnOffLight e DimmableLight utilizzano i tratti Matter standard per identificare gli impianti, attivare/disattivare gli stati di alimentazione e regolare i livelli di luminosità.

Accendere o spegnere una luce

Utilizza il tratto OnOff per leggere lo stato di alimentazione corrente di un OnOffLight o DimmableLight e per accendere o spegnere la luce.

Prima di leggere l'attributo onOff, verifica che il dispositivo lo supporti. Alcuni dispositivi funzionano come endpoint di soli comandi e non segnalano lo stato.

// Check if the OnOff trait supports the onOff attribute.
if (onOffTrait.supports(OnOff.Attribute.onOff)) {
  println("onOffTrait supports onOff state")
} else {
  println("onOffTrait is for a command only device!")
}

Quando onOff è true, la spia è accesa. Quando onOff è false, la spia è spenta.

Per modificare lo stato di alimentazione della luce, verifica che il tratto supporti il comando previsto, quindi chiama on(), off() o toggle().

// Check if the OnOff trait supports the toggle command.
if (onOffTrait.supports(OnOff.Command.Toggle)) {
  println("onOffTrait supports toggle command")
} else {
  println("onOffTrait does not support stateful toggle command")
}

// Calling a command on a trait.
try {
  onOffTrait.toggle()
} catch (e: HomeException) {
  // Code for handling the exception
}

Puoi anche chiamare direttamente on() e off() per impostare uno stato esplicito:

onOffTrait.off()
onOffTrait.on()

Per spegnere una luce con una transizione visiva graduale, chiama offWithEffect() e specifica un valore EffectIdentifierEnum:

// Turn off the light using the DyingLight effect.
onOffTrait.offWithEffect(
  effectIdentifier = OnOffTrait.EffectIdentifierEnum.DyingLight,
  effectVariant = 0u,
)

Regola la luminosità

Un DimmableLight richiede il tratto LevelControl, mentre un OnOffLight può supportarlo facoltativamente. Utilizza questo tratto per leggere e controllare il livello di luminosità di una luce.

L'attributo currentLevel indica il livello di luminosità attuale su una scala da 0 a 254. Puoi anche esaminare minLevel e maxLevel per determinare l'intervallo di luminosità valido supportato dall'hardware.

Per impostare la luminosità su un valore specifico, chiama moveToLevel(). Tieni presente che moveToLevel() modifica il livello corrente solo quando la luce è già accesa, a meno che non configuri optionsOverride con executeIfOff. Per accendere automaticamente la luce quando imposti un livello di luminosità diverso da zero (o per spegnerla quando imposti il livello al minimo), utilizza moveToLevelWithOnOff().

// Change the brightness of the light to 50%
levelControlTrait.moveToLevel(
  level = 127u.toUByte(),
  transitionTime = null,
  optionsMask = LevelControlTrait.OptionsBitmap(),
  optionsOverride = LevelControlTrait.OptionsBitmap(),
)

L'esempio seguente legge il livello di luminosità corrente e utilizza moveToLevelWithOnOff() per impostare una luce dimmerabile su una luminosità del 75% (190u) in una transizione di 1 secondo (10u decimi di secondo):

suspend fun setLightBrightness(lightDevice: DimmableLightDevice) {
  val levelControl = lightDevice.standardTraits.levelControl ?: return

  // Read the current brightness level (0 to 254)
  val currentLevel: UByte? = levelControl.currentLevel
  println("Current brightness level: $currentLevel")

  // Move to ~75% brightness (190 out of 254) and turn on the light if it is off
  if (levelControl.supports(LevelControl.Command.MoveToLevelWithOnOff)) {
    levelControl.moveToLevelWithOnOff(
      level = 190u,
      transitionTime = 10u,
      optionsMask = LevelControlTrait.OptionsBitmap(),
      optionsOverride = LevelControlTrait.OptionsBitmap()
    )
  }
}

Puoi anche aumentare o diminuire la luminosità rispetto al livello corrente chiamando stepWithOnOff() con StepModeEnum.Up o StepModeEnum.Down e un stepSize.

Colore del controllo

Il tratto ColorControl è disponibile sia su ColorTemperatureLightDevice sia su ExtendedColorLightDevice.

Questo tratto consente di regolare la temperatura di colore in gradi microreciproci o mired.

val colorControlTrait =
  colorTempLightDevice.standardTraits.colorControl ?: return
// Read the current color temperature and hardware limits in mireds
// (Mireds = 1,000,000 / Kelvin; e.g., 370 mireds ≈ 2700K warm white, 250 mireds = 4000K cool white)
val currentMireds = colorControlTrait.colorTemperatureMireds
val minMireds = colorControlTrait.colorTempPhysicalMinMireds ?: 153u // ~6500K (coolest)
val maxMireds = colorControlTrait.colorTempPhysicalMaxMireds ?: 500u // 2000K (warmest)
// Clamp target (370 mireds ≈ 2700K) to the device's physical bounds
val targetMireds = 370u.toUShort().coerceIn(minMireds, maxMireds)
if (
  colorControlTrait.supports(
    ColorControl.Command.MoveToColorTemperature
  )
) {
  colorControlTrait.moveToColorTemperature(
    colorTemperatureMireds = targetMireds,
    transitionTime = 20u, // 2.0 seconds (in 0.1s units)
    optionsMask = ColorControlTrait.OptionsBitmap(),
    optionsOverride = ColorControlTrait.OptionsBitmap()
  )
}

Puoi anche impostare il colore utilizzando le coordinate di cromaticità CIE 1931 e i valori di tonalità e saturazione a 16 bit.

val colorControlTrait =
  extendedColorLightDevice.standardTraits.colorControl ?: return
// 1. Move to CIE 1931 xy chromaticity coordinates (scaled 0..65279)
// Example: x = 0.3127 (20493), y = 0.3290 (21561) for D65 white point
if (colorControlTrait.supports(ColorControl.Command.MoveToColor)) {
  colorControlTrait.moveToColor(
    colorX = 20493u,
    colorY = 21561u,
    transitionTime = 10u, // 1.0 second (in 0.1s units)
    optionsMask = ColorControlTrait.OptionsBitmap(),
    optionsOverride = ColorControlTrait.OptionsBitmap()
  )
}
val currentX = colorControlTrait.currentX
val currentY = colorControlTrait.currentY
// 2. Move to 16-bit Enhanced Hue (0..65534) and 8-bit Saturation (0..254)
if (
  colorControlTrait.supports(
    ColorControl.Command.EnhancedMoveToHueAndSaturation
  )
) {
  colorControlTrait.enhancedMoveToHueAndSaturation(
    enhancedHue = 43690u, // ~240° (Blue) on the 0..65534 scale
    saturation = 254u,    // Full saturation
    transitionTime = 15u, // 1.5 seconds (in 0.1s units)
    optionsMask = ColorControlTrait.OptionsBitmap(),
    optionsOverride = ColorControlTrait.OptionsBitmap()
  )
}
// 3. Start a hardware color loop across the device's hue range
if (colorControlTrait.supports(ColorControl.Command.ColorLoopSet)) {
  colorControlTrait.colorLoopSet(
    updateFlags =
      ColorControlTrait.UpdateFlagsBitmap(
        updateAction = true,
        updateDirection = true,
        updateTime = true,
        updateStartHue = true
      ),
    action =
      ColorControlTrait.ColorLoopActionEnum
        .ActivateFromColorLoopStartEnhancedHue,
    direction = ColorControlTrait.ColorLoopDirectionEnum.Increment,
    time = 30u, // 30 seconds per full cycle
    startHue = 0u,
    optionsMask = ColorControlTrait.OptionsBitmap(),
    optionsOverride = ColorControlTrait.OptionsBitmap()
  )
}

ExtendedColorControl è un trait Google facoltativo su ExtendedColorLightDevice che semplifica il controllo del colore accettando nomi di colori, valori RGB o valori HSV in rappresentazione in virgola mobile unificati che combinano colore e luminosità in un'unica unità.

val extendedColorControlTrait =
  extendedColorLightDevice.googleTraits.extendedColorControl ?: return
// 1. Set color by name
if (
  extendedColorControlTrait.supports(
    ExtendedColorControl.Command.MoveToColorName
  )
) {
  extendedColorControlTrait.moveToColorName(colorName = "Lavender")
}
val currentColorName = extendedColorControlTrait.currentName
// 2. Set color using 8-bit RGB values (0..255 per channel)
// Automatically coordinates brightness (LevelControl) and color (ColorControl)
if (
  extendedColorControlTrait.supports(
    ExtendedColorControl.Command.MoveToColorRgb
  )
) {
  extendedColorControlTrait.moveToColorRgb(
    red = 255u,
    green = 128u,
    blue = 0u
  )
}
val currentRed = extendedColorControlTrait.currentRed
val currentGreen = extendedColorControlTrait.currentGreen
val currentBlue = extendedColorControlTrait.currentBlue
// 3. Set color and brightness together using floating-point HSV
// hue: 0.0f..360.0f, saturation: 0.0f..1.0f, value (brightness): 0.0f..1.0f
if (
  extendedColorControlTrait.supports(
    ExtendedColorControl.Command.MoveToColorHsv
  )
) {
  extendedColorControlTrait.moveToColorHsv(
    hue = 210.0f,
    saturation = 0.85f,
    value = 0.75f
  )
}
val currentHue = extendedColorControlTrait.currentHue
val currentSaturation = extendedColorControlTrait.currentSaturation
val currentValue = extendedColorControlTrait.currentValue

Gestisci le curve di illuminazione

Una curva di illuminazione definisce una programmazione automatica che regola gradualmente la luminosità e la temperatura di colore facoltativa delle luci target nel corso della giornata. Ad esempio, una curva di illuminazione può aumentare gradualmente la luminosità delle luci al mattino e diminuirla fino a una tonalità più calda la sera. I tipi di dispositivi di illuminazione che supportano solo la luminosità, come la luce dimmerabile, seguono la curva di luminosità e ignorano la temperatura di colore.

Il tratto LightingCurve è un tratto Google Home platform a livello di struttura. Puoi accedervi da un'istanza Structure anziché da un singolo dispositivo di illuminazione.

Ogni programmazione del tratto è rappresentata da un LightingCurveSetting, che associa un settingId univoco a un LightingCurveConfig. La tabella seguente descrive i campi di configurazione di LightingCurveConfig:

Campo	Descrizione
`curvePointsList`	Una sequenza di almeno due elementi `CurvePoint` con orari distinti. Ogni punto specifica un `time` (`CurveTimeOfDay` con `hours` da `0` a `23` e `minutes` da `0` a `59`), un `brightnessPercent` (da `0` a `100`) e un `colorTemperature` facoltativo in Kelvin. Se `colorTemperature` è specificato per un punto, deve essere un valore positivo per tutti i punti.
`roomId`	L'ID della stanza di destinazione (ad esempio, `room@{uuid}`). Applica la curva di illuminazione alle luci dimmerabili e con temperatura di colore compatibili in quella stanza. Specifica `roomId` o `devices`.
`devices`	Un oggetto `TargetDevices` contenente un elenco di voci `TargetDevice`, ciascuna con un `id` dispositivo e un ID dispositivo `type` (ad esempio `home.matter.0000.types.0101` per `DimmableLight` o `home.matter.0000.types.010c` per `ColorTemperatureLight`). Specifica `devices` o `roomId`.
`daysOfWeekList`	I giorni della settimana in cui viene eseguita la curva di illuminazione (`DayOfWeek`). Se l'elenco è vuoto, la curva di illuminazione viene eseguita ogni giorno.
`adaptive`	Valore booleano facoltativo che indica se la curva di illuminazione è adattiva, ovvero se una luce target riprende il livello della curva attiva quando viene accesa durante la finestra di programmazione. Quando `false`, una modifica manuale di una luce la disattiva dalla curva di illuminazione per il resto della giornata. Quando `true`, una luce che viene spenta e poi riaccesa durante la finestra di programmazione si ricollega alla curva di illuminazione, adattandosi alla luminosità e alla temperatura di colore attuali della curva e seguendola da quel momento in poi.
`enabled`	Valore booleano facoltativo che indica se l'impostazione della curva di illuminazione è attiva. Il valore predefinito è `true` quando crei una nuova impostazione. Quando `enabled` viene omesso da un comando di aggiornamento, lo stato di `enabled` non cambia.

Lettura delle impostazioni della curva di illuminazione

Per esaminare le curve di illuminazione configurate per una struttura, recupera il tratto LightingCurve da Structure e leggi il relativo attributo lightingCurveSettingsList.

suspend fun readLightingCurves(structure: Structure) {
  val lightingCurve = structure.trait(LightingCurve).firstOrNull() ?: return

  for (setting in lightingCurve.lightingCurveSettingsList) {
    val settingId = setting.settingId
    val config = setting.config
    println("Setting ID: $settingId, enabled: ${config?.enabled}")
    config?.curvePointsList?.forEach { point ->
      println(
        "  Time: ${point.time?.hours}:${point.time?.minutes}, " +
          "Brightness: ${point.brightnessPercent}%, " +
          "ColorTemp: ${point.colorTemperature}K"
      )
    }
  }
}

Crea un'impostazione della curva di illuminazione

Per creare una nuova programmazione della curva di illuminazione su una struttura, crea un LightingCurveConfig con almeno due voci CurvePoint, luci target (specificate da roomId o devices) e i giorni della settimana attivi. Poi, passa la configurazione a createLightingCurveSetting(). Il comando restituisce l'identificatore univoco settingId assegnato alla nuova impostazione della curva di illuminazione.

L'esempio seguente crea una curva di illuminazione per i giorni feriali per una stanza. La luminosità aumenta dal 30% con una temperatura calda di 2700 K alle 07:00 all'80% con una temperatura più fredda di 4000 K alle 09:00, per poi diminuire al 20% con una temperatura molto calda di 2200 K entro le 21:00:

suspend fun createRoomLightingCurve(
  structure: Structure,
  targetRoomId: String
): String? {
  val lightingCurve = structure.trait(LightingCurve).firstOrNull() ?: return null

  val curvePoints = listOf(
    LightingCurveTrait.CurvePoint(
      time = LightingCurveTrait.CurveTimeOfDay(hours = 7, minutes = 0),
      brightnessPercent = 30,
      colorTemperature = 2700
    ),
    LightingCurveTrait.CurvePoint(
      time = LightingCurveTrait.CurveTimeOfDay(hours = 9, minutes = 0),
      brightnessPercent = 80,
      colorTemperature = 4000
    ),
    LightingCurveTrait.CurvePoint(
      time = LightingCurveTrait.CurveTimeOfDay(hours = 21, minutes = 0),
      brightnessPercent = 20,
      colorTemperature = 2200
    )
  )

  val config = LightingCurveTrait.LightingCurveConfig(
    curvePointsList = curvePoints,
    roomId = targetRoomId,
    daysOfWeekList = listOf(
      DayOfWeek.MONDAY,
      DayOfWeek.TUESDAY,
      DayOfWeek.WEDNESDAY,
      DayOfWeek.THURSDAY,
      DayOfWeek.FRIDAY
    ),
    adaptive = true,
    enabled = true
  )

  // Returns the newly created settingId
  return lightingCurve.createLightingCurveSetting(config = config)
}

Per scegliere come target dispositivi di illuminazione specifici anziché un'intera stanza, fornisci il parametro devices utilizzando LightingCurveTrait.TargetDevices:

val targetDevices = LightingCurveTrait.TargetDevices(
  devicesList = listOf(
    LightingCurveTrait.TargetDevice(
      id = dimmableLight.id.id,
      type = DimmableLightDevice.TYPE_ID
    )
  )
)

val deviceCurveConfig = LightingCurveTrait.LightingCurveConfig(
  curvePointsList = curvePoints,
  devices = targetDevices,
  daysOfWeekList = listOf(DayOfWeek.SATURDAY, DayOfWeek.SUNDAY),
  adaptive = true,
  enabled = true
)

val settingId = lightingCurve.createLightingCurveSetting(
  config = deviceCurveConfig
)

Aggiorna un'impostazione della curva di illuminazione

Per modificare una curva di illuminazione esistente, ad esempio modificando i punti della curva, aggiornando i giorni della settimana attivi o attivando e disattivando la programmazione, chiama updateLightingCurveSetting() con il settingId target e un LightingCurveConfig aggiornato.

suspend fun updateLightingCurve(
  structure: Structure,
  settingId: String,
  updatedConfig: LightingCurveTrait.LightingCurveConfig
) {
  val lightingCurve = structure.trait(LightingCurve).firstOrNull() ?: return

  lightingCurve.updateLightingCurveSetting(
    settingId = settingId,
    config = updatedConfig
  )
}

Elimina un'impostazione della curva di illuminazione

Per rimuovere un'impostazione della curva di illuminazione da una struttura, chiama deleteLightingCurveSetting() con il settingId dell'impostazione che vuoi eliminare.

suspend fun deleteLightingCurve(
  structure: Structure,
  settingId: String
) {
  val lightingCurve = structure.trait(LightingCurve).firstOrNull() ?: return

  lightingCurve.deleteLightingCurveSetting(settingId = settingId)
}