मेरे पास एक लंबवत बफर में लोड 4 वर्ट्स की एक सूची है, और एक इंडेक्स इंडेक्स बफर में लोड किया गया है।

मेरे पास मुद्दा यह है कि जब लाइनलिस्ट रेंडरमोड एक क्वाड को ठीक दिखाता है (नीचे देखें) त्रिभुज सूची कुछ भी नहीं दिखाती है (नीचे देखें)

void BLX::Model::load(std::filesystem::path path, Model* model, ID3D11Device* d3dDevice, ID3D11DeviceContext* d3dContext)
{
    // tmp: just making a quad
    float num = 0.5f;
    std::vector<BLX::Vertex> vertices = {
        BLX::Vertex { DirectX::XMFLOAT3(-num, -num, 0.0f), DirectX::XMFLOAT3(0.0f, 0.0f, 0.5f), },  // 0 = TL
        BLX::Vertex { DirectX::XMFLOAT3(num, -num, 0.0f), DirectX::XMFLOAT3(0.0f, 0.5f, 0.0f), },   // 1 = TR
        BLX::Vertex { DirectX::XMFLOAT3(num, num, 0.0f), DirectX::XMFLOAT3(0.5f, 0.0f, 0.0f), }, // 2 = BR
        BLX::Vertex { DirectX::XMFLOAT3(-num, num, 0.0f), DirectX::XMFLOAT3(0.5f, 0.5f, 0.0f), },  // 3 = BL
    };

    // line list
    //std::vector<unsigned int> indices = { 0, 1, 1, 2, 2, 3, 3, 0 };

    // triangle list
    std::vector<unsigned int> indices = { 0, 1, 3, 3, 1, 2 };

    model->vertexCount = vertices.size();
    model->indexCount = indices.size();

    // Vertex Buffer

    D3D11_BUFFER_DESC vbd = {};
    vbd.BindFlags = D3D11_BIND_VERTEX_BUFFER;
    vbd.Usage = D3D11_USAGE_DEFAULT;
    vbd.CPUAccessFlags = 0u;
    vbd.MiscFlags = 0u;
    vbd.ByteWidth = sizeof(BLX::Vertex) * model->vertexCount;

    vbd.StructureByteStride = sizeof(BLX::Vertex);

    D3D11_SUBRESOURCE_DATA vsd = {};
    vsd.pSysMem = &vertices[0];
    vsd.SysMemPitch = 0;
    vsd.SysMemSlicePitch = 0;

    d3dDevice->CreateBuffer(&vbd, &vsd, &model->vertexBuffer);

    /// Index Buffer
    
    D3D11_BUFFER_DESC ibd = {};
    ibd.Usage = D3D11_USAGE_DEFAULT;
    ibd.ByteWidth = sizeof(unsigned int) * model->indexCount;
    ibd.BindFlags = D3D11_BIND_INDEX_BUFFER;
    ibd.CPUAccessFlags = 0;
    ibd.MiscFlags = 0;

    D3D11_SUBRESOURCE_DATA isd = {};
    isd.pSysMem = &indices[0];
    isd.SysMemPitch = 0;
    isd.SysMemSlicePitch = 0;

    d3dDevice->CreateBuffer(&ibd, &isd, &model->indexBuffer);


    // IA = Input Assembly

    // pixel shader
    D3DReadFileToBlob(L"PixelShader2.cso", &model->pBlob);
    d3dDevice->CreatePixelShader(model->pBlob->GetBufferPointer(), model->pBlob->GetBufferSize(), nullptr, &model->pPixelShader);

    // Vertex Shader
    D3DReadFileToBlob(L"VertexShader2.cso", &model->pBlob);
    d3dDevice->CreateVertexShader(model->pBlob->GetBufferPointer(), model->pBlob->GetBufferSize(), nullptr, &model->pVertexShader);

    const D3D11_INPUT_ELEMENT_DESC ied[] =
    {
        // "Position" correcponds to Vertex Shader Semantic Name
                    // semantic index
                        // data type format
                                                  // Input slot
                                                     // Aligned byte offset
                                                        // Input slot class
                                                                                     // Instance data step rate
        { "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0},
        { "COLOR", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 12, D3D11_INPUT_PER_VERTEX_DATA, 0 },
    };
    // needs vertex shader blob
    d3dDevice->CreateInputLayout(ied, ARRAYSIZE(ied), model->pBlob->GetBufferPointer(), model->pBlob->GetBufferSize(), &model->pInputLayout);
}

void BLX::Model::render(ID3D11Device* d3dDevice, ID3D11DeviceContext* d3dContext, D3D11_VIEWPORT * vp)
{
    const UINT stride = sizeof(Vertex);
    const UINT offset[] = { 0u, 0u };

    d3dContext->IASetVertexBuffers(0u, 1u, vertexBuffer.GetAddressOf(), &stride, &offset[0]);
    d3dContext->IASetIndexBuffer(*indexBuffer.GetAddressOf(), DXGI_FORMAT_R32_UINT, offset[1]);

    d3dContext->PSSetShader(pPixelShader.Get(), nullptr, 0u);
    d3dContext->VSSetShader(pVertexShader.Get(), nullptr, 0u);

    d3dContext->IASetInputLayout(pInputLayout.Get());

    d3dContext->RSSetViewports(1u, vp);

    //d3dContext->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY::D3D11_PRIMITIVE_TOPOLOGY_LINELIST);
    d3dContext->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY::D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
    d3dContext->DrawIndexed(indexCount, 0, 0);
}

लाइनलिस्ट इंडेक्स और टोपोलॉजी का उपयोग करते समय: यहां छवि विवरण दर्ज करें

TriangleList अनुक्रमणिका और टोपोलॉजी का उपयोग करते समय: यहां छवि विवरण दर्ज करें

लेकिन जब मैं यह कर रहा था:

    // tmp: just making a quad
    float num = 0.5f;
    std::vector<BLX::Vertex> vertices = {
        BLX::Vertex { DirectX::XMFLOAT3(0.0f, num, 0.0f), DirectX::XMFLOAT3(0.0f, 0.0f, 0.5f), },
        BLX::Vertex { DirectX::XMFLOAT3(num, -num, 0.0f), DirectX::XMFLOAT3(0.0f, 0.5f, 0.0f), },
        BLX::Vertex { DirectX::XMFLOAT3(-num, -num, 0.0f), DirectX::XMFLOAT3(0.5f, 0.0f, 0.0f), },
    };

    // triangle list
    std::vector<unsigned int> indices = { 0, 1, 2 };

(बाकी सब ठीक वही) मुझे यह मिला: यहां छवि विवरण दर्ज करें

क्वाड बनाने के लिए दो त्रिकोण प्रस्तुत करने का प्रयास करते समय मैं वास्तव में उत्सुक हूं या नहीं देख रहा हूं

3
RedactedProfile 16 अक्टूबर 2020, 02:17

2 जवाब

सबसे बढ़िया उत्तर

आपके आयत में घड़ी की दिशा में व्यवस्थित सूचकांक हैं, जो डिफ़ॉल्ट रास्टराइज़र द्वारा खींचे जाते हैं (चूंकि आप एक निर्दिष्ट नहीं करते हैं, यह दक्षिणावर्त आदिम को खींचता है)

आपका त्रिभुज शीर्ष क्रम वामावर्त था, इसलिए आदिम को नहीं खींचा गया था।

इसे हल करने के लिए, दो समाधान:

  • अपना सूचकांक क्रम बदलें:

      std::vector<unsigned int> indices = { 0, 3, 1, 3, 2, 1 };
    
  • रास्टराइज़र अवस्था में कलिंग अक्षम करें :

पहले एक रास्टराइज़र विवरण बनाएं

D3D11_RASTERIZER_DESC raster_desc;
raster_desc.FillMode = D3D11_FILL_SOLID;
raster_desc.CullMode= D3D11_CULL_NONE;
raster_desc.FrontCounterClockwise = false;
raster_desc.DepthBias = 0;
raster_desc.DepthBiasClamp= 0.0f;
raster_desc.SlopeScaledDepthBias= 0.0f;
raster_desc.DepthClipEnable= true;
raster_desc.ScissorEnable= false;
raster_desc.MultisampleEnable= false;
raster_desc.AntialiasedLineEnable= false;

फिर अपने डिवाइस का उपयोग करके रास्टराइज़र स्थिति बनाएं:

   ID3D11RasterizerState* raster_state;
   HRESULT hr =d3dDevice->CreateRasterizerState(&raster_desc, &raster_state);

ड्रा से पहले, अपने रैस्टराइज़र स्थिति को अपने संदर्भ में निर्दिष्ट करें:

   d3dContext->RSSetState(raster_state);
2
catflier 16 अक्टूबर 2020, 14:14

आपके दो जाल, त्रिभुज और क्वाड, में विपरीत त्रिभुज घुमावदार क्रम है। ऐसे।

enter image description here

डिफ़ॉल्ट रूप से, D3D11 CullMode=Back और FrontCounterClockwise=FALSE का उपयोग करता है। इसका मतलब है कि यह केवल सामने के चेहरों को प्रस्तुत करता है, और सामने के चेहरे को "जब कोने वामावर्त होते हैं" के रूप में परिभाषित किया जाता है।

जैसा कि आप उपरोक्त चित्रण से देखते हैं, आपके त्रिभुज में वास्तव में वामावर्त क्रम है, हालाँकि आपके क्वाड के दोनों त्रिभुज दक्षिणावर्त हैं, GPU उन्हें पीछे के चेहरे के रूप में मानता है और दोनों को छोड़ देता है।

आपके पास ठीक करने के कई तरीके हैं, इनमें से कोई भी काम करेगा।

  1. वर्टेक्स बफर में पुन: क्रमित करें।
  2. इंडेक्स बफ़र में त्रिभुजों को { 0, 3, 1, 1, 3, 2 } पर फ़्लिप करें
  3. बैक फेस कलिंग को अक्षम करने के लिए रास्टराइज़र स्थिति बदलें, CullMode=D3D11_CULL_NONE
  4. फ्रंट फेस वाइंडिंग दिशा बदलने के लिए रास्टराइज़र स्थिति बदलें, FrontCounterClockwise=TRUE
  5. मिररिंग घटक को शामिल करने के लिए मैट्रिक्स को वर्टेक्स शेडर में बदलें, उदा। वेक्टर के साथ स्केल [ -1, 1, 1 ] एक दर्पण परिवर्तन का प्रतिनिधित्व करता है जो X को फ़्लिप करता है, यह पूरे जाल के घुमावदार क्रम को फ्लिप करेगा।
1
Soonts 16 अक्टूबर 2020, 14:04