Neblina de vértice (Direct3D 9)

Quando o sistema executa o embaçamento de vértice, ele aplica cálculos de neblina em cada vértice em um polígono e interpola os resultados na face do polígono durante a rasterização. Os efeitos de neblina de vértice são computados pelo mecanismo de transformação e iluminação do Direct3D. Para obter mais informações, consulte parâmetros de neblina (Direct3D 9).

Se o aplicativo não usar o Direct3D para transformação e iluminação, o aplicativo deverá executar cálculos de neblina. Nesse caso, coloque o fator de neblina que é calculado no componente alfa da cor especular para cada vértice. Você é livre para usar as fórmulas desejadas – baseadas em intervalo, volumétricas ou de outra forma. O Direct3D usa o fator de neblina fornecido para interpolar na face de cada polígono. Os aplicativos que executam sua própria transformação e iluminação também devem executar seus próprios cálculos de neblina de vértice. Como resultado, esse aplicativo só precisa habilitar a mistura de neblina e definir a cor da neblina por meio dos estados de renderização associados, conforme descrito em direct3D 9 e Cor de Neblina (Direct3D 9).

Neblina Range-Based

Às vezes, o uso de neblina pode introduzir artefatos gráficos que fazem com que os objetos sejam misturados com a cor da neblina de maneiras não intuitivas. Por exemplo, imagine uma cena em que há dois objetos visíveis: um distante o suficiente para ser afetado pela neblina e o outro próximo o suficiente para não ser afetado. Se a área de exibição girar no local, os efeitos de neblina aparentes poderão ser alterados, mesmo que os objetos estejam estacionários. O diagrama a seguir mostra uma exibição de cima para baixo de tal situação.

A neblina baseada em intervalo é outra maneira, mais precisa, de determinar os efeitos de neblina. Na neblina baseada em intervalo, o Direct3D usa a distância real do ponto de vista para um vértice para seus cálculos de neblina. O Direct3D aumenta o efeito da neblina à medida que a distância entre os dois pontos aumenta, em vez da profundidade do vértice dentro da cena, evitando assim artefatos rotacionais.

Se o dispositivo atual der suporte à neblina baseada em intervalo, ele definirá o valor D3DPRASTERCAPS_FOGRANGE no membro rasterCaps de D3DCAPS9 quando você chamar o métodoIDirect3DDevice9::GetDeviceCaps. Para habilitar a neblina baseada em intervalo, defina o estado de renderização D3DRS_RANGEFOGENABLE para true.

A neblina baseada em intervalo é calculada pelo Direct3D durante a transformação e a iluminação. Os aplicativos que não usam a transformação Direct3D e o mecanismo de iluminação também devem executar seus próprios cálculos de neblina de vértice. Nesse caso, forneça o fator de neblina baseado em intervalo no componente alfa do componente especular para cada vértice.

Usando a neblina de vértice

Use as etapas a seguir para habilitar a neblina de vértice em seu aplicativo.

1. Habilite a mesclagem de neblina definindo D3DRS_FOGENABLE para VERDADEIRO.
2. Defina a cor da neblina no estado de renderização D3DRS_FOGCOLOR.
3. Escolha a fórmula de neblina desejada definindo o estado de renderização D3DRS_FOGVERTEXMODE para um membro do tipo enumerado D3DFOGMODE.
4. Defina os parâmetros de neblina conforme desejado para a fórmula de neblina selecionada nos estados de renderização.

O exemplo a seguir, escrito em C++, mostra como essas etapas podem ser no código.

// For brevity, error values in this example are not checked 
//   after each call. A real-world application should check 
//   these values appropriately.
//
// For the purposes of this example, g_pDevice is a valid
//   pointer to an IDirect3DDevice9 interface.
void SetupVertexFog(DWORD Color, DWORD Mode, BOOL UseRange, FLOAT Density)
{
    float Start = 0.5f,    // Linear fog distances
          End   = 0.8f;
 
    // Enable fog blending.
    g_pDevice->SetRenderState(D3DRS_FOGENABLE, TRUE);
 
    // Set the fog color.
    g_pDevice->SetRenderState(D3DRS_FOGCOLOR, Color);
    
    // Set fog parameters.
    if(D3DFOG_LINEAR == Mode)
    {
        g_pDevice->SetRenderState(D3DRS_FOGVERTEXMODE, Mode);
        g_pDevice->SetRenderState(D3DRS_FOGSTART, *(DWORD *)(&Start));
        g_pDevice->SetRenderState(D3DRS_FOGEND,   *(DWORD *)(&End));
    }
    else
    {
        g_pDevice->SetRenderState(D3DRS_FOGVERTEXMODE, Mode);
        g_pDevice->SetRenderState(D3DRS_FOGDENSITY, *(DWORD *)(&Density));
    }

    // Enable range-based fog if desired (only supported for
    //   vertex fog). For this example, it is assumed that UseRange
    //   is set to a nonzero value only if the driver exposes the 
    //   D3DPRASTERCAPS_FOGRANGE capability.
    // Note: This is slightly more performance intensive
    //   than non-range-based fog.
    if(UseRange)
        g_pDevice->SetRenderState(D3DRS_RANGEFOGENABLE, TRUE);
}

Alguns parâmetros de neblina são necessários como valores de ponto flutuante, embora o método IDirect3DDevice9::SetRenderState aceite apenas valores DWORD no segundo parâmetro. Este exemplo fornece com êxito os valores de ponto flutuante para esses métodos sem tradução de dados, convertendo os endereços das variáveis de ponto flutuante como ponteiros DWORD e, em seguida, desreferenciando-os.

Tópicos relacionados

tipos de neblina