SlimDX (DirectX10) - Comment changer un texel en texture?

Question

J'essaie de changer les texels d'une texture déjà chargée.

Mon hypothèse était d'utiliser les fonctions Texture2D :: Map et UnMap, mais rien ne change lorsque je modifie les données d'un DataRectangle donné.

Il me faut un exemple simple, par exemple, créer une texture de 128x128 avec un dégradé du noir au blanc de chaque côté.

Thx

ps: Un exemple de Direct3D 10 C ++ peut également aider, SlimDX n’est qu’un wrapper et a presque les mêmes fonctions.

Answer 1

Ceci est mon chargeur de texture 2D D3D10

bool D3D10Texture::Init( GFXHandler* pHandler, unsigned int usage, unsigned int width, unsigned int height, unsigned int textureType, bool bMipmapped, void* pTextureData )
{
    mMipmapped      = bMipmapped;

    //SetData( pHandler, 0 );

    D3D10Handler* pD3DHandler   = (D3D10Handler*)pHandler;
    ID3D10Device* pDevice       = pD3DHandler->GetDevice();

    DXGI_SAMPLE_DESC dxgiSampleDesc;
    dxgiSampleDesc.Count    = 1;
    dxgiSampleDesc.Quality  = 0;

    D3D10_USAGE d3d10Usage;
    if ( usage & RU_All_Dynamic )   d3d10Usage  = D3D10_USAGE_DYNAMIC;
    else                            d3d10Usage  = D3D10_USAGE_DEFAULT;

    //unsigned int cpuAccess    = D3D10_CPU_ACCESS_WRITE;
    //if ( (usage & RU_Buffer_WriteOnly) == 0 ) cpuAccess |= D3D10_CPU_ACCESS_READ;

    unsigned int cpuAccess = 0;
    if ( !pTextureData )
    {
        cpuAccess   = D3D10_CPU_ACCESS_WRITE;
        //if ( (usage & RU_Buffer_WriteOnly) == 0 ) cpuAccess |= D3D10_CPU_ACCESS_READ;
    }

    unsigned int bindFlags  = D3D10_BIND_SHADER_RESOURCE;
    if ( usage & RU_Texture_RenderTarget )  bindFlags |= D3D10_BIND_RENDER_TARGET;

    unsigned int miscFlags  = 0;
    if ( usage & RU_Texture_AutoGenMipmap ) miscFlags |= D3D10_RESOURCE_MISC_GENERATE_MIPS;

    D3D10_TEXTURE2D_DESC d3d10Texture2DDesc;
    d3d10Texture2DDesc.Width            = width;
    d3d10Texture2DDesc.Height           = height;
    d3d10Texture2DDesc.MipLevels        = GetNumMipMaps( width, height, bMipmapped );
    d3d10Texture2DDesc.ArraySize        = 1;
    d3d10Texture2DDesc.Format           = GetD3DFormat( (TextureTypes)textureType );
    d3d10Texture2DDesc.SampleDesc       = dxgiSampleDesc;
    d3d10Texture2DDesc.Usage            = d3d10Usage;
    d3d10Texture2DDesc.BindFlags        = D3D10_BIND_SHADER_RESOURCE;
    d3d10Texture2DDesc.CPUAccessFlags   = cpuAccess;
    d3d10Texture2DDesc.MiscFlags        = miscFlags;

    //D3D10_SUBRESOURCE_DATA d3d10SubResourceData;
    //d3d10SubResourceData.pSysMem          = pTextureData;
    //d3d10SubResourceData.SysMemPitch      = GetPitch( width, (TextureTypes)textureType );
    //d3d10SubResourceData.SysMemSlicePitch = 0;

    D3D10_SUBRESOURCE_DATA* pSubResourceData    = NULL;
    if ( pTextureData ) 
    {
        pSubResourceData    = new D3D10_SUBRESOURCE_DATA[d3d10Texture2DDesc.MipLevels];

        char* pTexPos       = (char*)pTextureData;
        unsigned int pitch  = GetPitch( width, (TextureTypes)textureType );

        unsigned int count  = 0;
        unsigned int max    = d3d10Texture2DDesc.MipLevels;
        while( count < max )
        {
            pSubResourceData[count].pSysMem             = pTexPos;
            pSubResourceData[count].SysMemPitch         = pitch;
            pSubResourceData[count].SysMemSlicePitch    = 0;

            pTexPos += pitch * height;
            pitch   >>= 1;
            count++;
        }
    }

    if ( FAILED( pDevice->CreateTexture2D( &d3d10Texture2DDesc, pSubResourceData, &mpTexture ) ) )
    {
        return false;
    }

    if ( pSubResourceData )
    {
        delete[] pSubResourceData;
        pSubResourceData    = NULL;
    }

    mWidth  = width;
    mHeight = height;
    mFormat = (TextureTypes)textureType;

    mpTexture->AddRef();
    mpTexture->Release();

    D3D10_SHADER_RESOURCE_VIEW_DESC d3d10ShaderResourceViewDesc;
    d3d10ShaderResourceViewDesc.Format                      = d3d10Texture2DDesc.Format;
    d3d10ShaderResourceViewDesc.ViewDimension               = D3D10_SRV_DIMENSION_TEXTURE2D;
    d3d10ShaderResourceViewDesc.Texture2D.MostDetailedMip   = 0;
    d3d10ShaderResourceViewDesc.Texture2D.MipLevels         = GetNumMipMaps( width, height, bMipmapped );

    if ( FAILED( pDevice->CreateShaderResourceView( mpTexture, &d3d10ShaderResourceViewDesc, &mpView ) ) )
    {
        return false;
    }

    ResourceRecorder::Instance()->AddResource( this );
    return true;
}

Avec cette fonction, il vous suffit de passer de la texture au noir. Par exemple, pour écrire un texte 256x256 avec chaque ligne horizontale une plus claire que la ligne précédente, le code suivant fonctionnera

int* pTexture = new int[256 * 256];
int count = 0;
while( count < 256 )
{
    int count2 = 0;
    while( count2 < 256 )
    {
        pTexture[(count * 256) + count2] = 0xff000000 | (count << 16) | (count << 8) | count;
        count2++;
    }
    count++;
}

Answer 2

Assurez-vous de suivre les règles de la section "Restrictions d'utilisation des ressources". section: MSDN: D3D10_USAGE

Answer 3

    public void NewData(byte[] newData)
    {
        DataRectangle mappedTex = null;
        //assign and lock the resource
        mappedTex = pTexture.Map(0, D3D10.MapMode.WriteDiscard, D3D10.MapFlags.None);
        // if unable to hold texture
        if (!mappedTex.Data.CanWrite)
        {
            throw new ApplicationException("Cannot Write to the Texture");
        }
        // write new data to the texture
        mappedTex.Data.WriteRange<byte>(newData);
        // unlock the resource
        pTexture.Unmap(0);
        if (samplerflag)
            temptex = newData;
    }

ceci écrase le tampon à chaque nouvelle image, vous pouvez utiliser un fichier D3D10.MapMode.readwrite ou quelque chose si vous essayez uniquement d’écrire un texel

vous aurez également besoin d'écrire dans l'angle de données en un point spécifique en utilisant l'une des autres fonctions d'écriture