C++: La texture DirectX est mal alignée/décalée

Question

J'essaye de rendre un carré avec une texture. Est-ce que quelqu'un sait pourquoi cette texture semble être déplacée ou désalignée?

Voici comment il est censé regarder: http://imgur.com/siCQXXT

Voici comment la question semble: http://imgur.com/rj6tHcX

auto createVSTask = loadVSTask.then([this](const std::vector<byte>& fileData) { 
    DX::ThrowIfFailed(
     m_deviceResources->GetD3DDevice()->CreateVertexShader(
      &fileData[0], 
      fileData.size(), 
      nullptr, 
      &m_vertexShader 
     ) 
    ); 

    static const D3D11_INPUT_ELEMENT_DESC vertexDesc[] = 
    { 
     { "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0 }, 
     { "NORMAL", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_VERTEX_DATA, 0 }, 
     { "TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT, 0, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_VERTEX_DATA, 0 }, 
    }; 

    DX::ThrowIfFailed(
     m_deviceResources->GetD3DDevice()->CreateInputLayout(
      vertexDesc, 
      ARRAYSIZE(vertexDesc), 
      &fileData[0], 
      fileData.size(), 
      &m_inputLayout 
     ) 
    ); 
}); 

auto createPSTask = loadPSTask.then([this](const std::vector<byte>& fileData) { 
    DX::ThrowIfFailed(
     m_deviceResources->GetD3DDevice()->CreatePixelShader(
      &fileData[0], 
      fileData.size(), 
      nullptr, 
      &m_pixelShader 
     ) 
    ); 

    CD3D11_BUFFER_DESC constantBufferDesc(sizeof(ModelViewProjectionConstantBuffer), D3D11_BIND_CONSTANT_BUFFER); 
    DX::ThrowIfFailed(
     m_deviceResources->GetD3DDevice()->CreateBuffer(
      &constantBufferDesc, 
      nullptr, 
      &m_constantBuffer 
     ) 
    ); 
}); 

auto createPrimitiveTask = (createPSTask && createVSTask).then([this]() { 

    const VertexPositionColor cubeVertices[] = 
    { 
     { DirectX::XMFLOAT3(-1.0f, -1.0f, 0.0f), DirectX::XMFLOAT3(0.0f, 1.0f, 0.0f), DirectX::XMFLOAT2(0.0f, 0.0f) }, 
     { DirectX::XMFLOAT3(1.0f, -1.0f, 0.0f), DirectX::XMFLOAT3(0.0f, 1.0f, 0.0f), DirectX::XMFLOAT2(1.0f, 0.0f) }, 
     { DirectX::XMFLOAT3(1.0f, 1.0f, 0.0f), DirectX::XMFLOAT3(0.0f, 1.0f, 0.0f), DirectX::XMFLOAT2(1.0f, 1.0f) }, 
     { DirectX::XMFLOAT3(-1.0f, 1.0f, 0.0f), DirectX::XMFLOAT3(0.0f, 1.0f, 0.0f), DirectX::XMFLOAT2(0.0f, 1.0f) }, 
    }; 

    static const unsigned short cubeIndices[] = 
    { 
     0, 1, 2, 
     0, 2, 3 
    }; 

    m_indexCount = ARRAYSIZE(cubeIndices); 

    D3D11_SUBRESOURCE_DATA vertexBufferData = { 0 }; 
    vertexBufferData.pSysMem = cubeVertices; 
    vertexBufferData.SysMemPitch = 0; 
    vertexBufferData.SysMemSlicePitch = 0; 
    CD3D11_BUFFER_DESC vertexBufferDesc(sizeof(cubeVertices), D3D11_BIND_VERTEX_BUFFER); 
    DX::ThrowIfFailed(
     m_deviceResources->GetD3DDevice()->CreateBuffer(
      &vertexBufferDesc, 
      &vertexBufferData, 
      &m_vertexBuffer 
     ) 
    ); 

    D3D11_SUBRESOURCE_DATA indexBufferData = { 0 }; 
    indexBufferData.pSysMem = cubeIndices; 
    indexBufferData.SysMemPitch = 0; 
    indexBufferData.SysMemSlicePitch = 0; 
    CD3D11_BUFFER_DESC indexBufferDesc(sizeof(cubeIndices), D3D11_BIND_INDEX_BUFFER); 
    DX::ThrowIfFailed(
     m_deviceResources->GetD3DDevice()->CreateBuffer(
      &indexBufferDesc, 
      &indexBufferData, 
      &m_indexBuffer 
     ) 
    ); 
}); 

auto loadTDTask = DX::ReadDataAsync(m_textureFile); 

auto createSubresourceTask = loadTDTask.then([=](std::vector<byte>& textureData) { 

    D3D11_SUBRESOURCE_DATA textureSubresourceData = { 0 }; 
    textureSubresourceData.pSysMem = &textureData[0]; 
    textureSubresourceData.SysMemPitch = 1024; 
    textureSubresourceData.SysMemSlicePitch = 0; 

    D3D11_TEXTURE2D_DESC textureDesc = { 0 }; 
    textureDesc.Width = 256; 
    textureDesc.Height = 256; 
    textureDesc.Format = DXGI_FORMAT_B8G8R8A8_UNORM; 
    textureDesc.Usage = D3D11_USAGE_DEFAULT; 
    textureDesc.CPUAccessFlags = 0; 
    textureDesc.ArraySize = 1; 
    textureDesc.SampleDesc.Count = 1; 
    textureDesc.SampleDesc.Quality = 0; 
    textureDesc.MiscFlags = D3D11_RESOURCE_MISC_GENERATE_MIPS; 
    textureDesc.MipLevels = 0; 
    textureDesc.BindFlags = D3D11_BIND_SHADER_RESOURCE | D3D11_BIND_RENDER_TARGET; 

    DX::ThrowIfFailed(m_d3dDevice->CreateTexture2D(
     &textureDesc, 
     nullptr, 
     &m_texture 
    ); 

    if (m_texture != NULL) 
    { 
     D3D11_SHADER_RESOURCE_VIEW_DESC textureViewDesc; 
     ZeroMemory(&textureViewDesc, sizeof(textureViewDesc)); 
     textureViewDesc.Format = textureDesc.Format; 
     textureViewDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2D; 
     textureViewDesc.Texture2D.MipLevels = -1; 
     textureViewDesc.Texture2D.MostDetailedMip = 0; 

     DX::ThrowIfFailed(
      m_d3dDevice->CreateShaderResourceView(
      m_texture.Get(), 
      &textureViewDesc, 
      &m_textureView 
      ) 
     ); 

     context->UpdateSubresource(m_texture.Get(), 0, nullptr, &textureData[0], textureSubresourceData.SysMemPitch, textureDesc.Width); 
     context->GenerateMips(m_textureView.Get()); 
    } 
} 

D3D11_SAMPLER_DESC samplerDesc; 
ZeroMemory(&samplerDesc, sizeof(samplerDesc)); 
samplerDesc.Filter = D3D11_FILTER_MIN_MAG_MIP_LINEAR; 
samplerDesc.MaxAnisotropy = 0; 
samplerDesc.AddressU = D3D11_TEXTURE_ADDRESS_WRAP; 
samplerDesc.AddressV = D3D11_TEXTURE_ADDRESS_WRAP; 
samplerDesc.AddressW = D3D11_TEXTURE_ADDRESS_WRAP; 
samplerDesc.MipLODBias = 0.0f; 
samplerDesc.MinLOD = 0; 
samplerDesc.MaxLOD = D3D11_FLOAT32_MAX; 
samplerDesc.ComparisonFunc = D3D11_COMPARISON_NEVER; 
samplerDesc.BorderColor[0] = 0.0f; 
samplerDesc.BorderColor[1] = 0.0f; 
samplerDesc.BorderColor[2] = 0.0f; 
samplerDesc.BorderColor[3] = 0.0f; 

DX::ThrowIfFailed(
    m_d3dDevice->CreateSamplerState(
    &samplerDesc, 
    &m_sampler 
    ) 
); 

Answer 1

Tout d'abord, vous avez confirmé qu'il était pas problème d'état ou de géométrie avec l'expérience de serrage, en second lieu, vous avez dit que vous utilisez un DDS i mage, et c'est la clé. Selon votre code, l'image a une largeur de 256 RGBA8, car la pierre est 1/8 de celle-ci, cela signifie qu'ils couvrent 32 * 4 = 128 octets. Assez proche, le DDS header est de 124 octets quand vous n'avez pas le morceau dx10 dedans et cela explique pourquoi l'image est décalée comme ça.

Tout ce que vous avez à faire est de passer l'en-tête et de transmettre uniquement les données d'image à UpdateSubResource. Je vous invite à regarder le DDS reference pour apprendre comment le fichier est mise en page afin que vous puissiez lire les tailles, le format, passer correctement au début des données, et aussi tirer parti de la DDS pour stocker le format compressé, et inclure les cartes mip avant de ne pas utiliser GenerateMips qui est une mauvaise pratique.