Effectuer une relecture à partir de textures et de surfaces Direct3D

Les plus impliqués partie est de la lecture à partir d'une certaine surface, qui est dans la mémoire vidéo ("pool par défaut"). C'est le plus souvent les cibles de rendu.

Let's get le plus facile d'abord:

1. lecture à partir d'une texture est la même que la lecture de 0 au niveau de la surface de la texture. Voir ci-dessous.
2. la même pour le sous-ensemble d'une texture.
3. lecture à partir d'une surface qui est en non-valeur par défaut du pool de mémoire ("système" ou "réussi") est simplement le verrouillage et la lecture des octets.
4. la même pour le sous-ensemble de la surface. Verrouillez simplement partie pertinente et de le lire.

Alors maintenant, nous avons laissé les surfaces qui sont dans la mémoire vidéo ("pool par défaut"). Ce serait n'importe quelle surface/texture marqué comme cible de rendu, ou n'importe quelle surface/texture que vous avez créé dans le pool par défaut, ou le backbuffer lui-même. Le complexe est ici que vous ne pouvez pas verrouiller.

Réponse courte est: GetRenderTargetData méthode sur D3D device.

Réponds plus (une ébauche du code ci-dessous):

1. rt = obtenir le rendu de surface de la cible (ce qui peut être la surface de la texture, ou backbuffer, etc.)
2. si rt est multisampled (GetDesc, vérifiez D3DSURFACE_DESC.MultiSampleType), alors: a) créer une autre cible de rendu de surface de la même taille, le même format, mais sans multisampling; b) StretchRect de rt dans cette nouvelle surface; c) rt = cette nouvelle surface (c'est à dire passer sur cette nouvelle surface).
3. hors = créer à l'écran de la plaine de surface (CreateOffscreenPlainSurface, en d3dpool_systemmem piscine)
4. device->GetRenderTargetData( rthors )
5. maintenant hors contient cible de rendu des données. LockRect(), les données de lecture, UnlockRect ().
6. nettoyage

Même plus répondre (dans le coller dans le code, je travaille sur) de la façon suivante. Cette ne compiler hors de la boîte, car il utilise certaines classes, des fonctions, des macros et des utilitaires à partir du reste de la base de code; mais il devrait vous obtenir a commencé. J'ai aussi oublié la plupart de vérification des erreurs (par exemple, si la largeur/hauteur est hors des limites du terrain). J'ai aussi omis la partie qui lit pixels réels et, éventuellement, les convertit en format de destination (c'est assez facile, mais il peut faire de long, selon le nombre de conversions de format que vous souhaitez à l'appui).

bool GfxDeviceD3D9::ReadbackImage( /* params */)
{
    HRESULT hr;
    IDirect3DDevice9* dev = GetD3DDevice();
    SurfacePointer renderTarget;
    hr = dev->GetRenderTarget( 0, &renderTarget );
    if( !renderTarget || FAILED(hr) )
        return false;

    D3DSURFACE_DESC rtDesc;
    renderTarget->GetDesc( &rtDesc );

    SurfacePointer resolvedSurface;
    if( rtDesc.MultiSampleType != D3DMULTISAMPLE_NONE )
    {
        hr = dev->CreateRenderTarget( rtDesc.Width, rtDesc.Height, rtDesc.Format, D3DMULTISAMPLE_NONE, 0, FALSE, &resolvedSurface, NULL );
        if( FAILED(hr) )
            return false;
        hr = dev->StretchRect( renderTarget, NULL, resolvedSurface, NULL, D3DTEXF_NONE );
        if( FAILED(hr) )
            return false;
        renderTarget = resolvedSurface;
    }

    SurfacePointer offscreenSurface;
    hr = dev->CreateOffscreenPlainSurface( rtDesc.Width, rtDesc.Height, rtDesc.Format, D3DPOOL_SYSTEMMEM, &offscreenSurface, NULL );
    if( FAILED(hr) )
        return false;

    hr = dev->GetRenderTargetData( renderTarget, offscreenSurface );
    bool ok = SUCCEEDED(hr);
    if( ok )
    {
        //Here we have data in offscreenSurface.
        D3DLOCKED_RECT lr;
        RECT rect;
        rect.left = 0;
        rect.right = rtDesc.Width;
        rect.top = 0;
        rect.bottom = rtDesc.Height;
        //Lock the surface to read pixels
        hr = offscreenSurface->LockRect( &lr, &rect, D3DLOCK_READONLY );
        if( SUCCEEDED(hr) )
        {
            //Pointer to data is lt.pBits, each row is
            //lr.Pitch bytes apart (often it is the same as width*bpp, but
            //can be larger if driver uses padding)

            //Read the data here!
            offscreenSurface->UnlockRect();
        }
        else
        {
            ok = false;
        }
    }

    return ok;
}

SurfacePointer dans le code ci-dessus est une smart pointeur vers un objet COM (il libère de l'objet sur la cession ou le destructeur). Simplifie la gestion des erreurs beaucoup. Ceci est très similaire à _comptr_t choses dans Visual C++.

Le code ci-dessus se lit arrière sur toute la surface. Si vous voulez lire une partie seulement de manière efficace, alors je crois que la façon la plus rapide est d'environ:

1. créer un pool par défaut de surface qui est de la taille nécessaire.
2. StretchRect de la partie de surface d'origine pour que les plus petits.
3. procéder comme d'habitude avec les petits.

En fait, c'est assez similaire à ce code ci-dessus ne pour gérer les multi-échantillonnés surfaces. Si vous souhaitez obtenir juste une partie d'un multi-échantillonnés surface, vous pouvez faire un multi-échantillons résoudre et obtenir une partie d'une StretchRect, je pense.

Modifier: enlevé un morceau de code qui n'réelle de lecture des pixels et des conversions de format. N'est pas directement reliée à la question, et le code a été long.

Modifier: mise à jour pour correspondre édité question.