> ## Documentation Index > Fetch the complete documentation index at: https://devdocs.xbox.com/llms.txt > Use this file to discover all available pages before exploring further. # Définition des couleurs sur un LampArray > Définition des couleurs sur un LampArray Toutes les fonctions de mise à jour des couleurs sur ILampArray utilisent la structure [LampArrayColor](/fr/reference/lighting/lamparray/structs/lamparraycolor) pour représenter une valeur de couleur RGBA. La valeur alpha (LampArrayColor::a) représente la transparence relative d'une couleur, où zéro correspond à une transparence totale et 0xFF à une opacité totale. Si une valeur alpha autre que 0xFF est utilisée, la couleur subit une étape de fusion supplémentaire avec le noir. Pour éviter cette étape de fusion, ne transmettez pas de valeur alpha autre que 0xFF lors de la définition des couleurs. Les API SetColor d'ILampArray sont conçues pour être appelées à partir d'un seul thread, afin d'obtenir les meilleures performances et la cohérence de l'état des Lamps. ## Mise à jour de toutes les Lamps La méthode [ILampArray::SetColor](/fr/reference/lighting/lamparray/interfaces/ilamparray/methods/ilamparray_setcolor) modifie toutes les Lamps de l'appareil pour qu'elles correspondent à la couleur souhaitée. L'exemple suivant inscrit un rappel LampArray et définit la couleur de chaque appareil connecté. ```cpp theme={null} const LampArrayColor greenColor = { 0x0 /* r */, 0xFF /* g */, 0x0 /* b */, 0xFF /* a */}; std::vector> lampArrays; void MyLampArrayStatusCallback( _In_opt_ void* context, LampArrayStatus currentStatus, LampArrayStatus previousStatus, _In_ ILampArray* lampArray) { const bool wasAttached = (previousStatus & LampArrayStatus::Connected) == LampArrayStatus::Connected; const bool isAttached = (currentStatus & LampArrayStatus::Connected) == LampArrayStatus::Connected; if (wasAttached != isAttached) { if (isAttached) { lampArray->SetColor(greenColor); lampArrays.push_back(lampArray); } else { for (auto iter = lampArrays.begin(); iter != lampArrays.end(); ) { if (iter->Get() == lampArray) { lampArrays.erase(iter); } else { iter++; } } } } } void MainLoop( _In_ volatile bool & cancelMonitoring) noexcept { LampArrayCallbackToken token = LAMPARRAY_INVALID_CALLBACK_TOKEN_VALUE; if (SUCCEEDED(RegisterLampArrayStatusCallback( MyLampArrayStatusCallback, LampArrayEnumerationKind::Async, nullptr /* context */, &token))) { while (!cancelMonitoring) { Sleep(100); } UnregisterLampArrayCallback(token, 5000); } } ``` ## Cibler des Lamps individuelles ou des groupes de Lamps [ILampArray::SetColorsForIndices](/fr/reference/lighting/lamparray/interfaces/ilamparray/methods/ilamparray_setcolorsforindices) permet de mettre à jour une ou plusieurs Lamps d'un LampArray. Les indices de Lamp transmis à cette API peuvent être dans n'importe quel ordre. L'exemple suivant montre comment définir des couleurs alternées sur toutes les Lamps d'un LampArray. ```cpp theme={null} void SetAlternatingColors(ILampArray* lampArray) { const LampArrayColor blueColor = { 0x0 /* r */, 0x0 /* g */, 0xFF /* b */, 0xFF /* a */}; const LampArrayColor redColor = { 0xFF /* r */, 0x0 /* g */, 0x0 /* b */, 0xFF /* a */}; const uint32_t lampCount = lampArray->GetLampCount(); // Set up our index and color buffers std::vector indicesBuffer(lampCount); std::vector colorsBuffer(lampCount); // Populate the buffers for (uint32_t i = 0; i < lampCount; i++) { // We will use all the Lamps for this update. indicesBuffer[i] = i; // Odd numbered indices will be red, even numbered indices will be blue if (i % 2 != 0) { colorsBuffer[i] = redColor; } else { colorsBuffer[i] = blueColor; } } // Apply the colors to the LampArray lampArray->SetColorsForIndices(lampCount, indicesBuffer.data(), colorsBuffer.data()); } ``` L'exemple suivant montre comment mettre à jour les couleurs de Lamps individuelles ou de groupes de Lamps sur un LampArray. ```cpp theme={null} void MyCustomColorUpdate(ILampArray* lampArray) { const LampArrayColor greenColor = { 0x0 /* r */, 0xFF /* g */, 0x0 /* b */, 0xFF /* a */}; const LampArrayColor yellowColor = { 0xFF /* r */, 0xFF /* g */, 0x0 /* b */, 0xFF /* a */}; const LampArrayColor whiteColor = { 0xFF /* r */, 0xFF /* g */, 0xFF /* b */, 0xFF /* a */}; const uint32_t lampCount = lampArray->GetLampCount(); // Set custom colors for a single lamp at index 4 const uint32_t index = 4; lampArray->SetColorsForIndices(1, &index, &greenColor); // Simultaneously make Lamp 1 yellow and Lamp 3 white std::vector indicesBuffer = { 1, 3 }; std::vector colorsBuffer = { yellowColor, whiteColor }; // Apply the colors to the LampArray lampArray->SetColorsForIndices(static_cast(indicesBuffer.size()), indicesBuffer.data(), colorsBuffer.data()); } ``` ## Cibler des Lamps à l'aide des codes de touche du clavier [ILampArray::SetColorsForScanCodes](/fr/reference/lighting/lamparray/interfaces/ilamparray/methods/ilamparray_setcolorsforscancodes) offre un moyen simple de définir les couleurs des Lamps de touches spécifiques sur un clavier LampArray. Cela peut être utile, par exemple, pour apprendre aux utilisateurs quelles touches appuyer dans un tutoriel, ou pour afficher sur le clavier des informations relatives à l'état du jeu. L'exemple suivant montre comment modifier la couleur des Lamps des touches WASD sur un clavier LampArray : ```cpp theme={null} #define SC_W 0x11 #define SC_A 0x1E #define SC_S 0x1F #define SC_D 0x20 void UpdateWASDKeys(ILampArray* lampArray) { const LampArrayColor blueColor = { 0x0 /* r */, 0x0 /* g */, 0xFF /* b */, 0xFF /* a */}; const LampArrayColor yellowColor = { 0xFF /* r */, 0xFF /* g */, 0x0 /* b */, 0xFF /* a */}; // Set the color for all lamps. We will override the WASD keys below. lampArray->SetColor(blueColor); // Set up the buffer of scan codes for the Lamps we want to target std::vector scanCodesBuffer = { SC_W, SC_A, SC_S, SC_D }; // Create a matching buffer of LampArrayColors. In this example, we will set all of the WASD keys to yellow. std::vector colorsBuffer; for (size_t i = 0; i < scanCodesBuffer.size(); i++) { colorsBuffer.push_back(yellowColor); } // Set the color for the WASD keys lampArray->SetColorsForScanCodes(static_cast(scanCodesBuffer.size()), scanCodesBuffer.data(), colorsBuffer.data()); } ``` ## Voir aussi [Vue d'ensemble de l'API d'éclairage](/fr/build/core-features/common/lighting/gc-lighting-toc) [Référence ILampArray](/fr/reference/lighting/lamparray/interfaces/ilamparray/ilamparray) [LampArrayColor](/fr/reference/lighting/lamparray/structs/lamparraycolor) [ILampArray::SetColor](/fr/reference/lighting/lamparray/interfaces/ilamparray/methods/ilamparray_setcolor) [ILampArray::SetColorsForIndices](/fr/reference/lighting/lamparray/interfaces/ilamparray/methods/ilamparray_setcolorsforindices) [ILampArray::SetColorsForScanCodes](/fr/reference/lighting/lamparray/interfaces/ilamparray/methods/ilamparray_setcolorsforscancodes) ## Related topics - [Efectos de LampArray](/es/build/core-features/common/lighting/lighting-effects.md) - [LampArrayCallback function reference](/reference/lighting/lamparray/functions/lamparraycallback.md) - [LampArray](/ko/reference/lighting/lamparray/lamparray_members.md) - [Establecimiento de colores en un LampArray](/es/build/core-features/common/lighting/lighting-colors.md) - [LampArrayStatusCallback function reference](/reference/lighting/lamparray/functions/lamparraystatuscallback.md)