Definir cores em um LampArray

Todas as funções de atualização de cor em ILampArray usam o struct 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 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.

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

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.

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 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:

#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 Referência de ILampArray LampArrayColor ILampArray::SetColor ILampArray::SetColorsForIndices ILampArray::SetColorsForScanCodes

Porting

Build Paths

Atualizar todas as Lamps

Direcionar Lamps individuais ou grupos de Lamps

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

Confira também

​Atualizar todas as Lamps

​Direcionar Lamps individuais ou grupos de Lamps

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

​Confira também

Atualizar todas as Lamps

Direcionar Lamps individuais ou grupos de Lamps

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

Confira também