Função DrvAlphaBlend (winddi.h)

Artigo
03/13/2024

A função DrvAlphaBlend fornece recursos de transferência de bloco de bits com mesclagem alfa.

Sintaxe

BOOL DrvAlphaBlend(
  [in, out]      SURFOBJ  *psoDest,
  [in]           SURFOBJ  *psoSrc,
  [in]           CLIPOBJ  *pco,
  [in, optional] XLATEOBJ *pxlo,
  [in]           RECTL    *prclDest,
  [in]           RECTL    *prclSrc,
  [in]           BLENDOBJ *pBlendObj
);

Parâmetros

[in, out] psoDest

Ponteiro para uma estrutura SURFOBJ que identifica a superfície na qual desenhar.

[in] psoSrc

Ponteiro para uma estrutura SURFOBJ que identifica a superfície de origem.

[in] pco

Ponteiro para uma estrutura CLIPOBJ . As rotinas de serviço CLIPOBJ_Xxx são fornecidas para enumerar a região de clipe como um conjunto de retângulos. Essa enumeração limita a área do destino que é modificado. Sempre que possível, a GDI simplifica o recorte envolvido. No entanto, ao contrário do DrvBitBlt, DrvAlphaBlend pode ser chamado com um único retângulo para evitar erros de arredondamento ao recortar a saída.

[in, optional] pxlo

Ponteiro para uma estrutura XLATEOBJ que especifica como os índices de cor devem ser convertidos entre as superfícies de origem e destino. Se pxlo for NULL, nenhuma tradução será necessária.

Se a superfície de origem for gerenciada pela paleta, suas cores serão representadas por índices em uma tabela de pesquisa de valores de cor RGB. Nesse caso, o XLATEOBJ pode ser consultado para um vetor de tradução que permite que o driver de dispositivo converta rapidamente qualquer índice de origem em um índice de cores para o destino.

A situação é mais complicada quando, por exemplo, a origem é RGB, mas o destino é gerenciado por paleta. Nesse caso, a correspondência mais próxima de cada valor RGB de origem deve ser encontrada na paleta de destino. O driver pode chamar a rotina de serviço XLATEOBJ_iXlate para executar essa operação de correspondência.

[in] prclDest

Ponteiro para uma estrutura RECTL que define a área retangular a ser modificada. Esse retângulo é especificado no sistema de coordenadas da superfície de destino e é definido por dois pontos: superior esquerdo e inferior direito. Os dois pontos que definem o retângulo são sempre bem ordenados. O retângulo é exclusivo inferior direito; ou seja, suas bordas inferior e direita não fazem parte da mistura.

O driver deve ter cuidado para fazer o recorte adequado ao gravar os pixels porque o retângulo especificado pode sobresabar a superfície de destino.

DrvAlphaBlend nunca é chamado com um retângulo de destino vazio.

[in] prclSrc

Ponteiro para uma estrutura RECTL que define a área a ser copiada. Esse retângulo é especificado no sistema de coordenadas da superfície de origem e é definido por dois pontos: superior esquerdo e inferior direito. Os dois pontos que definem o retângulo são sempre bem ordenados. O retângulo é exclusivo inferior direito; ou seja, suas bordas inferior e direita não fazem parte da mistura.

O retângulo de origem nunca excederá os limites da superfície de origem e, portanto, nunca sobrepõe a superfície de origem.

DrvAlphaBlend nunca é chamado com um retângulo de origem vazio.

O mapeamento é definido por prclSrc e prclDest. Os pontos especificados em prclDest e prclSrc estão em coordenadas de inteiro, que correspondem aos centros de pixel. Um retângulo definido por dois desses pontos é considerado um retângulo geométrico com dois vértices cujas coordenadas são os pontos determinados, mas com 0,5 subtraído de cada coordenada. (As estruturas POINTL são notação abreviada para especificar esses vértices de coordenadas fracionárias.)

[in] pBlendObj

Ponteiro para uma estrutura BLENDOBJ que descreve a operação de mesclagem a ser executada entre as superfícies de origem e destino. Essa estrutura é um wrapper para a estrutura BLENDFUNCTION, que inclui as informações necessárias de formato de origem e destino não disponíveis no XLATEOBJ. A estrutura BLENDFUNCTION é definida na documentação do SDK do Microsoft Windows. Seus membros são definidos da seguinte maneira:

O BlendOp define a operação de mesclagem a ser executada. Atualmente, esse valor deve ser AC_SRC_OVER, o que significa que o bitmap de origem é colocado sobre o bitmap de destino com base nos valores alfa dos pixels de origem. Há três casos possíveis que essa operação de mesclagem deve tratar. Eles são descritos na seção Comentários.

BlendFlags é reservado e atualmente está definido como zero.

SourceConstantAlpha define o fator de mesclagem constante a ser aplicado a toda a superfície de origem. Esse valor está no intervalo de [0.255], em que 0 é completamente transparente e 255 é completamente opaco.

AlphaFormat define se a superfície deve ter um canal alfa. Opcionalmente, esse membro pode ser definido com o seguinte valor:

AC_SRC_ALPHA

A superfície de origem pode ser considerada em um formato "BGRA" alfa 32bpp pré-multiplicado; ou seja, o tipo de superfície é BMF_32BPP e o tipo de paleta é BI_RGB. O componente alfa é um inteiro no intervalo de [0.255], em que 0 é completamente transparente e 255 é completamente opaco.

Retornar valor

DrvAlphaBlend retorna TRUE após o sucesso. Caso contrário, ele relatará um erro e retornará FALSE.

Comentários

O driver pode dar suporte a uma transferência de bloco de bits com mesclagem alfa entre as seguintes superfícies:

De uma superfície gerenciada pelo dispositivo para outra superfície gerenciada pelo dispositivo.
De um bitmap de formato padrão gerenciado por GDI para outro bitmap de formato padrão gerenciado por GDI.
De uma superfície gerenciada por dispositivo para uma superfície gerenciada por GDI e vice-versa.

O motorista pode enviar chamadas para EngAlphaBlend.

O driver nunca será chamado com retângulos de origem e destino sobrepostos na mesma superfície.

Os três casos possíveis para a função de combinação AC_SRC_OVER são:

O bitmap de origem não tem alfa por pixel (AC_SRC_ALPHA não está definido), portanto, a combinação é aplicada aos canais de cores do pixel com base no valor alfa de origem constante especificado em SourceConstantAlpha da seguinte maneira:

Dst.Red = Round(((Src.Red * SourceConstantAlpha) + 
    ((255 − SourceConstantAlpha) * Dst.Red)) / 255);
Dst.Green = Round(((Src.Green * SourceConstantAlpha) + 
    ((255 − SourceConstantAlpha) * Dst.Green)) / 255);
Dst.Blue = Round(((Src.Blue * SourceConstantAlpha) + 
    ((255 − SourceConstantAlpha) * Dst.Blue)) / 255);
/* Do the next computation only if the destination bitmap 
    has an alpha channel. */
Dst.Alpha = Round(((Src.Alpha * SourceConstantAlpha) + 
    ((255 − SourceConstantAlpha) * Dst.Alpha)) / 255);

O bitmap de origem tem valores alfa por pixel (AC_SRC_ALPHA está definido) e SourceConstantAlpha não é usado (está definido como 255). A combinação é computada da seguinte maneira:

Dst.Red = Src.Red + 
    Round(((255 − Src.Alpha) * Dst.Red) / 255);
Dst.Green = Src.Green + 
    Round(((255 − Src.Alpha) * Dst.Green) / 255);
Dst.Blue = Src.Blue + 
    Round(((255 − Src.Alpha) * Dst.Blue) / 255);
/* Do the next computation only if the destination bitmap 
    has an alpha channel. */
Dst.Alpha = Src.Alpha + 
    Round(((255 − Src.Alpha) * Dst.Alpha) / 255);

O bitmap de origem tem valores alfa por pixel (AC_SRC_ALPHA está definido) e SourceConstantAlpha é usado (não está definido como 255). A combinação é computada da seguinte maneira:

Temp.Red = Round((Src.Red * SourceConstantAlpha) / 255);
Temp.Green = Round((Src.Green * SourceConstantAlpha) / 255);
Temp.Blue = Round((Src.Blue * SourceConstantAlpha) / 255);
/* The next computation must be done even if the 
    destination bitmap does not have an alpha channel. */
Temp.Alpha = Round((Src.Alpha * SourceConstantAlpha) / 255);
 
/* Note that the following equations use the just-computed 
   Temp.Alpha value: */
Dst.Red = Temp.Red + 
    Round(((255 − Temp.Alpha) * Dst.Red) / 255);
Dst.Green = Temp.Green + 
    Round(((255 − Temp.Alpha) * Dst.Green) / 255);
Dst.Blue = Temp.Blue + 
    Round(((255 − Temp.Alpha) * Dst.Blue) / 255);
/* Do the next computation only if the destination bitmap 
    has an alpha channel.  */
Dst.Alpha = Temp.Alpha + 
    Round(((255 − Temp.Alpha) * Dst.Alpha) / 255);

A função Round(x) arredonda para o inteiro mais próximo, calculado como:

Trunc(x + 0.5);

DrvAlphaBlend pode ser implementado opcionalmente em drivers gráficos. Ele pode ser fornecido para lidar com alguns tipos de misturas alfa, como mesclagem em que as superfícies de origem e destino são do mesmo formato e não contêm um canal alfa.

Uma implementação de hardware pode usar ponto flutuante ou ponto fixo na operação de mesclagem. Os testes de compatibilidade serão responsáveis por algum erro numérico nos resultados; consulte Efeitos especiais em Drivers de Exibição para obter informações sobre o erro máximo permitido. Ao usar o ponto fixo, uma aproximação aceitável para o termo x/255 é (x*257)/65536. Incorporando arredondamento, a expressão:

((255 - Src.Alpha) * Dst.Red) / 255

pode ser aproximado como:

temp = ((255 - Src.Alpha) * Dst.Red) + 128;
result = (temp + (temp >> 8)) >> 8;

O driver conecta DrvAlphaBlend definindo o sinalizador HOOK_ALPHABLEND quando ele chama EngAssociateSurface. Se o driver tiver fisgado DrvAlphaBlend e for chamado para executar uma operação à qual não dá suporte, o driver deverá ter o GDI para manipular a operação pontuando os dados em uma chamada para EngAlphaBlend.