> ## 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.

# Definir cores em um LampArray

> Definir cores em um LampArray

Todas as funções de atualização de cor em ILampArray usam o struct [LampArrayColor](/pt-BR/reference/lighting/lamparray/structs/lamparraycolor) para representar um valor de cor RGBA.

O valor alfa (LampArrayColor::a) representa a transparência relativa de uma cor, em que zero é totalmente transparente e 0xFF é totalmente opaco. Se for usado um valor alfa diferente de 0xFF, a cor passará por uma etapa adicional de mesclagem com o preto. Para evitar essa etapa de mesclagem, não passe um valor alfa diferente de 0xFF ao definir cores.

As APIs SetColor de ILampArray foram projetadas para serem chamadas de um único thread, para obter o melhor desempenho e a consistência do estado das Lamps.

## Atualizar todas as Lamps

O método [ILampArray::SetColor](/pt-BR/reference/lighting/lamparray/interfaces/ilamparray/methods/ilamparray_setcolor) altera todas as Lamps do dispositivo para corresponder à cor desejada.

O exemplo a seguir registra um retorno de chamada de LampArray e define a cor de cada dispositivo conectado.

```cpp theme={null}
const LampArrayColor greenColor = { 0x0 /* r */, 0xFF /* g */, 0x0 /* b */, 0xFF /* a */};
std::vector<Microsoft::WRL::ComPtr<ILampArray>> 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);
    }
}
```

## Direcionar Lamps individuais ou grupos de Lamps

[ILampArray::SetColorsForIndices](/pt-BR/reference/lighting/lamparray/interfaces/ilamparray/methods/ilamparray_setcolorsforindices) é usado para atualizar uma ou mais Lamps de um LampArray. Os índices de Lamp passados para essa API podem estar em qualquer ordem.

O exemplo a seguir ilustra como definir cores alternadas em todas as Lamps de um 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<uint32_t> indicesBuffer(lampCount);
    std::vector<LampArrayColor> 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());
}
```

O exemplo a seguir mostra como atualizar as cores de Lamps individuais ou de grupos de Lamps em um 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<uint32_t> indicesBuffer = { 1, 3 };
    std::vector<LampArrayColor> colorsBuffer = { yellowColor, whiteColor };

    // Apply the colors to the LampArray
    lampArray->SetColorsForIndices(static_cast<uint32_t>(indicesBuffer.size()), indicesBuffer.data(), colorsBuffer.data());
}
```

## Direcionar Lamps usando códigos de verificação do teclado

[ILampArray::SetColorsForScanCodes](/pt-BR/reference/lighting/lamparray/interfaces/ilamparray/methods/ilamparray_setcolorsforscancodes) oferece uma maneira fácil de definir as cores das Lamps de teclas específicas em um teclado LampArray. Isso pode ser útil, por exemplo, para ensinar aos usuários quais teclas pressionar em um tutorial ou para mostrar no teclado informações relacionadas ao estado do jogo.

O exemplo a seguir ilustra como alterar a cor das Lamps das teclas WASD em um teclado 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<uint32_t> 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<LampArrayColor> 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<uint32_t>(scanCodesBuffer.size()), scanCodesBuffer.data(), colorsBuffer.data());
}
```

## Confira também

[Visão geral da API de iluminação](/pt-BR/build/core-features/common/lighting/gc-lighting-toc)
[Referência de ILampArray](/pt-BR/reference/lighting/lamparray/interfaces/ilamparray/ilamparray)
[LampArrayColor](/pt-BR/reference/lighting/lamparray/structs/lamparraycolor)
[ILampArray::SetColor](/pt-BR/reference/lighting/lamparray/interfaces/ilamparray/methods/ilamparray_setcolor)
[ILampArray::SetColorsForIndices](/pt-BR/reference/lighting/lamparray/interfaces/ilamparray/methods/ilamparray_setcolorsforindices)
[ILampArray::SetColorsForScanCodes](/pt-BR/reference/lighting/lamparray/interfaces/ilamparray/methods/ilamparray_setcolorsforscancodes)


## Related topics

- [LampArray Basics](/build/core-features/common/lighting/lighting-basics.md)
- [LampArray Effects](/build/core-features/common/lighting/lighting-effects.md)
- [LampArray 效果](/zh-CN/build/core-features/common/lighting/lighting-effects.md)
- [LampArray 효과](/ko/build/core-features/common/lighting/lighting-effects.md)
- [Referencia de la función LampArrayCallback](/es/reference/lighting/lamparray/functions/lamparraycallback.md)