3D-opzoektabeleffect

Een 3D-opzoektabel is een algemeen effect dat wordt gebruikt voor het inkapselen van een 1:1 beeldeffect door vooraf te berekenen hoe het effect invoer toebedeelt aan uitvoer voor een subset van alle invoerwaarden.

Het effect 3D Lookup Table (LUT) wijzigt een invoerafbeelding met behulp van de RGB-kleurwaarde van de afbeelding om een 3D-patroon te indexeren, waarbij het patroon een vooraf berekende uitvoerwaarde van een willekeurige effectpijplijn bevat.

De 3D LUT moet worden geladen in een GPU-patroonresource om te worden weergegeven, en dit kan duur zijn, afhankelijk van de grootte van het patroon en de mogelijkheden van het apparaat. Toepassingsontwikkelaars kunnen opgeven wanneer deze kosten moeten worden betaald met behulp van de ID2D1LookupTable3D D2D-resource. ID2D1LookupTable3D- heeft de volgende kenmerken:

• Biedt een abstracte weergave van de GPU-resource van 3D LUT.
• Afhankelijk van de mogelijkheden van het apparaat wordt een 2D- of 3D-patroon gemaakt en gevuld met de meegeleverde LUT-gegevens.
• Kan worden doorgegeven aan de eigenschap van het 3D LUT-effect voor rendering.

De CLSID voor dit effect is CLSID_D2D1LookupTable3D.

• voorbeeldafbeelding
• voorbeeldcode
• effecteigenschappen
• vereisten
• Verwante onderwerpen

Voorbeeldafbeelding

Voorbeeldcode

//
    // 1. Generate the lookup table data and create an ID2D1LookupTable3D.
    //
 
    // Create a 16x16x16 LUT of arbitrary data type T.
    UINT extents[] = { 16, 16, 16 };
    UINT cElements = extents[0] * extents[1] * extents[2] * 4;
    UINT cbElements = cElements * formatSize;
 
    // Compute the step size in each direction to vary the RGB 
    // channels uniformly over the range [0, 1]
    float steps[] = 
    { 
        1.0f / static_cast<float>(extents[0] - 1),
        1.0f / static_cast<float>(extents[1] - 1),
        1.0f / static_cast<float>(extents[2] - 1),
    };
 
    CArray<BYTE> lutData;
    IFR(lutData.Resize(cbElements));
 
    T* pData = reinterpret_cast<T *>(lutData.GetData());
    T oneValue = ConvertValue<T>(1.0f);
    
    // Generate the LUT by applying an imaging pipeline to RGB values.
    for (UINT iR = 0; iR < extents[2]; iR++)
    {
        for (UINT iG = 0; iG < extents[1]; iG++)
        {
            for (UINT iB = 0; iB < extents[0]; iB++)
            {
                T outputColor[3];
                ApplyPipeline(iR * steps[2], iG * steps[1], iB * steps[0], &outputColor);
 
                pData[0] = outColor[0];
                pData[1] = outColor[1];
                pData[2] = outColor[2];
 
                // Set opaque alpha in the output
                pData[3] = oneValue;
 
                // Advance the pointer
                pData += sizeof(T) * 4;
            }
        }
    }
    
    // Compute the strides of the LUT data.
    UINT strides[2];
    IFR(UIntMult(sizeof(T) * 4, extents[0], &strides[0]));
    IFR(UIntMult(strides[0], extents[1], &strides[1]));
    
    D2D1_BUFFER_PRECISION precision = GetBufferPrecision<T>();
 
    // Create an ID2D1LookupTable3D from the LUT data.
    CComPtr<ID2D1LookupTable3D> sp3dLut;
    IFR(_spEffectContext1->CreateLookupTable3D(
        precision,
        extents,
        lutData.GetData(),
        lutData.GetCount(),
        strides,
        &sp3dLut
        )); 
 
    //
    // 2. To apply the lookup table to an input image, create a LookupTable3D effect
    //    and pass the ID2D1LookupTable3D to the effect as a property.
    //
 
    // Create a 3D LUT effect to render our LUT.
    CComPtr<ID2D1Effect> sp3dLutEffect;
    IFR(pEffectContext->CreateEffect(CLSID_D2D1LookupTable3D, &sp3dLutEffect)); 
 
    // Set the LUT as a property on the effect.
    IFR(sp3dLutEffect->SetValue(D2D1_LOOKUPTABLE3D_PROP_LUT, _spLut));

Effecteigenschappen

De eigenschappen voor het 3D-opzoektabeleffect worden gedefinieerd door de opsomming D2D1_LOOKUPTABLE3D_PROP.

Eisen

Verwante onderwerpen

• id2D1Effect-interface