Freigeben über

Anwenden von Texturen auf Primitiven

Hier laden wir Rohe Texturdaten und wenden diese Daten auf einen 3D-Grundtyp an, indem wir den Würfel verwenden, den wir in erstellt haben, unter Nutzung von Tiefe und Effekten auf Grundtypen. Darüber hinaus stellen wir ein einfaches Punktprodukt-Beleuchtungsmodell vor, bei dem die Würfeloberflächen je nach Entfernung und Winkel relativ zu einer Lichtquelle heller oder dunkler sind.

Ziel: Texturen auf Primitives anwenden.

Voraussetzungen

Um dieses Thema optimal nutzen zu können, müssen Sie mit C++ vertraut sein. Außerdem benötigen Sie grundlegende Erfahrungen mit Grafikprogrammierungskonzepten. Im Idealfall müssen Sie bereits mit Schnellstart gefolgt sein: Einrichten von DirectX-Ressourcen und Anzeigen eines Bilds, Erstellen von Shadern und Zeichnen von Grundtypenund Verwenden von Tiefe und Effekten auf Grundtypen.

Zeit bis zum Abschluss: 20 Minuten.

Anweisungen

1. Definieren von Variablen für einen texturierten Würfel

Zunächst müssen wir die BasicVertex- und ConstantBuffer- Strukturen für den texturierten Würfel definieren. Diese Strukturen geben die Vertexpositionen, Ausrichtungen und Texturen für den Würfel an und wie der Würfel betrachtet wird. Andernfalls deklarieren wir Variablen ähnlich wie im vorherigen Lernprogramm, Verwenden von Tiefe und Effekten auf Grundtypen.

struct BasicVertex
{
    DirectX::XMFLOAT3 pos;  // Position
    DirectX::XMFLOAT3 norm; // Surface normal vector
    DirectX::XMFLOAT2 tex;  // Texture coordinate
};

struct ConstantBuffer
{
    DirectX::XMFLOAT4X4 model;
    DirectX::XMFLOAT4X4 view;
    DirectX::XMFLOAT4X4 projection;
};

// This class defines the application as a whole.
ref class Direct3DTutorialFrameworkView : public IFrameworkView
{
private:
    Platform::Agile<CoreWindow> m_window;
    ComPtr<IDXGISwapChain1> m_swapChain;
    ComPtr<ID3D11Device1> m_d3dDevice;
    ComPtr<ID3D11DeviceContext1> m_d3dDeviceContext;
    ComPtr<ID3D11RenderTargetView> m_renderTargetView;
    ComPtr<ID3D11DepthStencilView> m_depthStencilView;
    ComPtr<ID3D11Buffer> m_constantBuffer;
    ConstantBuffer m_constantBufferData;

2. Erstellen von Vertex- und Pixelshadern mit Oberflächen- und Texturelementen

Hier erstellen wir komplexere Vertex- und Pixelshader als im vorherigen Tutorial, Nutzung von Tiefe und Effekten auf Grundtypen. Der Vertex-Shader dieser App transformiert jede Vertexposition in den Projektionsraum und übergibt die Vertex-Texturkoordinate an den Pixelshader.

Das App-Array von D3D11_INPUT_ELEMENT_DESC Strukturen, die das Layout des Vertex-Shadercodes beschreiben, weist drei Layoutelemente auf: ein Element definiert die Vertexposition, ein anderes Element definiert den Oberflächennormalvektor (die Richtung, die die Oberfläche normalerweise angibt), und das dritte Element definiert die Texturkoordinaten.

Wir erstellen Vertex-, Index- und Konstantenpuffer, die einen orbitierenden texturierten Würfel definieren.

So definieren Sie einen umlaufbahnenden texturierten Würfel

  1. Zunächst definieren wir den Würfel. Jedem Scheitelpunkt wird eine Position, ein Oberflächennormalvektor und Texturkoordinaten zugewiesen. Wir verwenden für jede Ecke mehrere Scheitelpunkte, damit für jedes Gesicht unterschiedliche normale Vektoren und Texturkoordinaten definiert werden können.
  2. Als Nächstes beschreiben wir die Vertex- und Indexpuffer (D3D11_BUFFER_DESC und D3D11_SUBRESOURCE_DATA) mithilfe der Cube-Definition. Wir rufen ID3D11Device::CreateBuffer einmal für jeden Puffer auf.
  3. Als nächstes erstellen wir einen konstanten Puffer (D3D11_BUFFER_DESC), um Modell-, Ansichts- und Projektionsmatrizen an den Vertex-Shader zu übergeben. Später können wir den Konstantenpuffer verwenden, um den Würfel zu drehen und eine perspektivische Projektion darauf anzuwenden. Wir rufen ID3D11Device::CreateBuffer auf, um den Konstantenpuffer zu erstellen.
  4. Schließlich geben wir die Ansichtstransformation an, die einer Kameraposition von X = 0, Y = 1, Z = 2 entspricht.
auto loadVSTask = DX::ReadDataAsync(L"SimpleVertexShader.cso");
auto loadPSTask = DX::ReadDataAsync(L"SimplePixelShader.cso");

auto createVSTask = loadVSTask.then([this](const std::vector<byte>& vertexShaderBytecode)
{
    ComPtr<ID3D11VertexShader> vertexShader;
    DX::ThrowIfFailed(
        m_d3dDevice->CreateVertexShader(
            vertexShaderBytecode->Data,
            vertexShaderBytecode->Length,
            nullptr,
            &vertexShader
        )
    );

    // Create an input layout that matches the layout defined in the vertex shader code.
    // These correspond to the elements of the BasicVertex struct defined above.
    const D3D11_INPUT_ELEMENT_DESC basicVertexLayoutDesc[] =
    {
        { "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0,  0, D3D11_INPUT_PER_VERTEX_DATA, 0 },
        { "NORMAL",   0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 12, D3D11_INPUT_PER_VERTEX_DATA, 0 },
        { "TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT,    0, 24, D3D11_INPUT_PER_VERTEX_DATA, 0 },
    };

    ComPtr<ID3D11InputLayout> inputLayout;
    DX::ThrowIfFailed(
        m_d3dDevice->CreateInputLayout(
            basicVertexLayoutDesc,
            ARRAYSIZE(basicVertexLayoutDesc),
            vertexShaderBytecode->Data,
            vertexShaderBytecode->Length,
            &inputLayout
        )
    );
});

// Load the raw pixel shader bytecode from disk and create a pixel shader with it.
auto createPSTask = loadPSTask.then([this](const std::vector<byte>& pixelShaderBytecode)
{
    ComPtr<ID3D11PixelShader> pixelShader;
    DX::ThrowIfFailed(
        m_d3dDevice->CreatePixelShader(
            pixelShaderBytecode->Data,
            pixelShaderBytecode->Length,
            nullptr,
            &pixelShader
        )
    );
});

// Create vertex and index buffers that define a simple unit cube.
auto createCubeTask = (createPSTask && createVSTask).then([this]()
{
    // In the array below, which will be used to initialize the cube vertex buffers,
    // multiple vertices are used for each corner to allow different normal vectors and
    // texture coordinates to be defined for each face.
    BasicVertex cubeVertices[] =
    {
        { DirectX::XMFLOAT3(-0.5f, 0.5f, -0.5f), DirectX::XMFLOAT3(0.0f, 1.0f, 0.0f), DirectX::XMFLOAT2(0.0f, 0.0f) }, // +Y (top face)
        { DirectX::XMFLOAT3(0.5f, 0.5f, -0.5f), DirectX::XMFLOAT3(0.0f, 1.0f, 0.0f), DirectX::XMFLOAT2(1.0f, 0.0f) },
        { DirectX::XMFLOAT3(0.5f, 0.5f,  0.5f), DirectX::XMFLOAT3(0.0f, 1.0f, 0.0f), DirectX::XMFLOAT2(1.0f, 1.0f) },
        { DirectX::XMFLOAT3(-0.5f, 0.5f,  0.5f), DirectX::XMFLOAT3(0.0f, 1.0f, 0.0f), DirectX::XMFLOAT2(0.0f, 1.0f) },

        { DirectX::XMFLOAT3(-0.5f, -0.5f,  0.5f), DirectX::XMFLOAT3(0.0f, -1.0f, 0.0f), DirectX::XMFLOAT2(0.0f, 0.0f) }, // -Y (bottom face)
        { DirectX::XMFLOAT3(0.5f, -0.5f,  0.5f), DirectX::XMFLOAT3(0.0f, -1.0f, 0.0f), DirectX::XMFLOAT2(1.0f, 0.0f) },
        { DirectX::XMFLOAT3(0.5f, -0.5f, -0.5f), DirectX::XMFLOAT3(0.0f, -1.0f, 0.0f), DirectX::XMFLOAT2(1.0f, 1.0f) },
        { DirectX::XMFLOAT3(-0.5f, -0.5f, -0.5f), DirectX::XMFLOAT3(0.0f, -1.0f, 0.0f), DirectX::XMFLOAT2(0.0f, 1.0f) },

        { DirectX::XMFLOAT3(0.5f,  0.5f,  0.5f), DirectX::XMFLOAT3(1.0f, 0.0f, 0.0f), DirectX::XMFLOAT2(0.0f, 0.0f) }, // +X (right face)
        { DirectX::XMFLOAT3(0.5f,  0.5f, -0.5f), DirectX::XMFLOAT3(1.0f, 0.0f, 0.0f), DirectX::XMFLOAT2(1.0f, 0.0f) },
        { DirectX::XMFLOAT3(0.5f, -0.5f, -0.5f), DirectX::XMFLOAT3(1.0f, 0.0f, 0.0f), DirectX::XMFLOAT2(1.0f, 1.0f) },
        { DirectX::XMFLOAT3(0.5f, -0.5f,  0.5f), DirectX::XMFLOAT3(1.0f, 0.0f, 0.0f), DirectX::XMFLOAT2(0.0f, 1.0f) },

        { DirectX::XMFLOAT3(-0.5f,  0.5f, -0.5f), DirectX::XMFLOAT3(-1.0f, 0.0f, 0.0f), DirectX::XMFLOAT2(0.0f, 0.0f) }, // -X (left face)
        { DirectX::XMFLOAT3(-0.5f,  0.5f,  0.5f), DirectX::XMFLOAT3(-1.0f, 0.0f, 0.0f), DirectX::XMFLOAT2(1.0f, 0.0f) },
        { DirectX::XMFLOAT3(-0.5f, -0.5f,  0.5f), DirectX::XMFLOAT3(-1.0f, 0.0f, 0.0f), DirectX::XMFLOAT2(1.0f, 1.0f) },
        { DirectX::XMFLOAT3(-0.5f, -0.5f, -0.5f), DirectX::XMFLOAT3(-1.0f, 0.0f, 0.0f), DirectX::XMFLOAT2(0.0f, 1.0f) },

        { DirectX::XMFLOAT3(-0.5f,  0.5f, 0.5f), DirectX::XMFLOAT3(0.0f, 0.0f, 1.0f), DirectX::XMFLOAT2(0.0f, 0.0f) }, // +Z (front face)
        { DirectX::XMFLOAT3(0.5f,  0.5f, 0.5f), DirectX::XMFLOAT3(0.0f, 0.0f, 1.0f), DirectX::XMFLOAT2(1.0f, 0.0f) },
        { DirectX::XMFLOAT3(0.5f, -0.5f, 0.5f), DirectX::XMFLOAT3(0.0f, 0.0f, 1.0f), DirectX::XMFLOAT2(1.0f, 1.0f) },
        { DirectX::XMFLOAT3(-0.5f, -0.5f, 0.5f), DirectX::XMFLOAT3(0.0f, 0.0f, 1.0f), DirectX::XMFLOAT2(0.0f, 1.0f) },

        { DirectX::XMFLOAT3(0.5f,  0.5f, -0.5f), DirectX::XMFLOAT3(0.0f, 0.0f, -1.0f), DirectX::XMFLOAT2(0.0f, 0.0f) }, // -Z (back face)
        { DirectX::XMFLOAT3(-0.5f,  0.5f, -0.5f), DirectX::XMFLOAT3(0.0f, 0.0f, -1.0f), DirectX::XMFLOAT2(1.0f, 0.0f) },
        { DirectX::XMFLOAT3(-0.5f, -0.5f, -0.5f), DirectX::XMFLOAT3(0.0f, 0.0f, -1.0f), DirectX::XMFLOAT2(1.0f, 1.0f) },
        { DirectX::XMFLOAT3(0.5f, -0.5f, -0.5f), DirectX::XMFLOAT3(0.0f, 0.0f, -1.0f), DirectX::XMFLOAT2(0.0f, 1.0f) },
    };

    unsigned short cubeIndices[] =
    {
        0, 1, 2,
        0, 2, 3,

        4, 5, 6,
        4, 6, 7,

        8, 9, 10,
        8, 10, 11,

        12, 13, 14,
        12, 14, 15,

        16, 17, 18,
        16, 18, 19,

        20, 21, 22,
        20, 22, 23
    };

    D3D11_BUFFER_DESC vertexBufferDesc = { 0 };
    vertexBufferDesc.ByteWidth = sizeof(BasicVertex) * ARRAYSIZE(cubeVertices);
    vertexBufferDesc.Usage = D3D11_USAGE_DEFAULT;
    vertexBufferDesc.BindFlags = D3D11_BIND_VERTEX_BUFFER;
    vertexBufferDesc.CPUAccessFlags = 0;
    vertexBufferDesc.MiscFlags = 0;
    vertexBufferDesc.StructureByteStride = 0;

    D3D11_SUBRESOURCE_DATA vertexBufferData;
    vertexBufferData.pSysMem = cubeVertices;
    vertexBufferData.SysMemPitch = 0;
    vertexBufferData.SysMemSlicePitch = 0;

    ComPtr<ID3D11Buffer> vertexBuffer;
    DX::ThrowIfFailed(
        m_d3dDevice->CreateBuffer(
            &vertexBufferDesc,
            &vertexBufferData,
            &vertexBuffer
        )
    );

    D3D11_BUFFER_DESC indexBufferDesc;
    indexBufferDesc.ByteWidth = sizeof(unsigned short) * ARRAYSIZE(cubeIndices);
    indexBufferDesc.Usage = D3D11_USAGE_DEFAULT;
    indexBufferDesc.BindFlags = D3D11_BIND_INDEX_BUFFER;
    indexBufferDesc.CPUAccessFlags = 0;
    indexBufferDesc.MiscFlags = 0;
    indexBufferDesc.StructureByteStride = 0;

    D3D11_SUBRESOURCE_DATA indexBufferData;
    indexBufferData.pSysMem = cubeIndices;
    indexBufferData.SysMemPitch = 0;
    indexBufferData.SysMemSlicePitch = 0;

    ComPtr<ID3D11Buffer> indexBuffer;
    DX::ThrowIfFailed(
        m_d3dDevice->CreateBuffer(
            &indexBufferDesc,
            &indexBufferData,
            &indexBuffer
        )
    );

    // Create a constant buffer for passing model, view, and projection matrices
    // to the vertex shader.  This will allow us to rotate the cube and apply
    // a perspective projection to it.

    D3D11_BUFFER_DESC constantBufferDesc = { 0 };
    constantBufferDesc.ByteWidth = sizeof(m_constantBufferData);
    constantBufferDesc.Usage = D3D11_USAGE_DEFAULT;
    constantBufferDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
    constantBufferDesc.CPUAccessFlags = 0;
    constantBufferDesc.MiscFlags = 0;
    constantBufferDesc.StructureByteStride = 0;
    DX::ThrowIfFailed(
        m_d3dDevice->CreateBuffer(
            &constantBufferDesc,
            nullptr,
            &m_constantBuffer
        )
    );

    // Specify the view transform corresponding to a camera position of
    // X = 0, Y = 1, Z = 2.  For a generalized camera class, see Lesson 5.

    m_constantBufferData.view = DirectX::XMFLOAT4X4(
        -1.00000000f, 0.00000000f, 0.00000000f, 0.00000000f,
        0.00000000f, 0.89442718f, 0.44721359f, 0.00000000f,
        0.00000000f, 0.44721359f, -0.89442718f, -2.23606800f,
        0.00000000f, 0.00000000f, 0.00000000f, 1.00000000f
    );
});

3. Erstellen von Texturen und Samplern

Hier versehen wir einen Würfel mit Texturdaten anstatt wie im vorherigen Tutorial Farben anzuwenden, Verwenden von Tiefe und Effekten auf Grundtypen.

Wir verwenden rohe Texturdaten, um Texturen zu erstellen.

So erstellen Sie Texturen und Sampler

  1. Zunächst lesen wir unformatierte Texturdaten aus der texturedata.bin Datei auf dem Datenträger.
  2. Als Nächstes erstellen wir eine D3D11_SUBRESOURCE_DATA Struktur, die auf diese rohen Texturdaten verweist.
  3. Anschließend füllen wir eine D3D11_TEXTURE2D_DESC Struktur aus, um die Textur zu beschreiben. Anschließend übergeben wir in einem Aufruf von ID3D11Device::CreateTexture2D die D3D11_SUBRESOURCE_DATA- und D3D11_TEXTURE2D_DESC-Strukturen, um die Textur zu erstellen.
  4. Als Nächstes erstellen wir eine Shaderressourcenansicht der Textur, damit Shader die Textur verwenden können. Zum Erstellen der Shaderressourcenansicht füllen wir eine D3D11_SHADER_RESOURCE_VIEW_DESC aus, um die Shaderressourcenansicht zu beschreiben, und übergeben die Beschreibung der Shaderressourcenansicht sowie die Textur an ID3D11Device::CreateShaderResourceView. Im Allgemeinen stimmen Sie die Beschreibung der Ansicht mit der Texturbeschreibung ab.
  5. Als Nächstes erstellen wir den Samplerstatus für die Textur. Dieser Samplerzustand verwendet die relevanten Texturdaten, um zu definieren, wie die Farbe für eine bestimmte Texturkoordinate bestimmt wird. Wir füllen eine D3D11_SAMPLER_DESC Struktur aus, um den Samplerzustand zu beschreiben. Anschließend übergeben wir die Struktur D3D11_SAMPLER_DESC in einem Aufruf von ID3D11Device::CreateSamplerState, um den Samplerzustand zu erstellen.
  6. Schließlich deklarieren wir eine Variable vom Grad , die wir verwenden, um den Würfel zu animieren, indem wir ihn in jedem Frame drehen.
// Load the raw texture data from disk and construct a subresource description that references it.
auto loadTDTask = DX::ReadDataAsync(L"texturedata.bin");

auto constructSubresourceTask = loadTDTask.then([this](const std::vector<byte>& textureData)
{
    D3D11_SUBRESOURCE_DATA textureSubresourceData = { 0 };
    textureSubresourceData.pSysMem = textureData.data();

    // Specify the size of a row in bytes, known as a priori about the texture data.
    textureSubresourceData.SysMemPitch = 1024;

    // As this is not a texture array or 3D texture, this parameter is ignored.
    textureSubresourceData.SysMemSlicePitch = 0;

    // Create a texture description from information known as a priori about the data.
    // Generalized texture loading code can be found in the Resource Loading sample.
    D3D11_TEXTURE2D_DESC textureDesc = { 0 };
    textureDesc.Width = 256;
    textureDesc.Height = 256;
    textureDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
    textureDesc.Usage = D3D11_USAGE_DEFAULT;
    textureDesc.CPUAccessFlags = 0;
    textureDesc.MiscFlags = 0;

    // Most textures contain more than one MIP level.  For simplicity, this sample uses only one.
    textureDesc.MipLevels = 1;

    // As this will not be a texture array, this parameter is ignored.
    textureDesc.ArraySize = 1;

    // Don't use multi-sampling.
    textureDesc.SampleDesc.Count = 1;
    textureDesc.SampleDesc.Quality = 0;

    // Allow the texture to be bound as a shader resource.
    textureDesc.BindFlags = D3D11_BIND_SHADER_RESOURCE;

    ComPtr<ID3D11Texture2D> texture;
    DX::ThrowIfFailed(
        m_d3dDevice->CreateTexture2D(
            &textureDesc,
            &textureSubresourceData,
            &texture
        )
    );

    // Once the texture is created, we must create a shader resource view of it
    // so that shaders may use it.  In general, the view description will match
    // the texture description.
    D3D11_SHADER_RESOURCE_VIEW_DESC textureViewDesc;
    ZeroMemory(&textureViewDesc, sizeof(textureViewDesc));
    textureViewDesc.Format = textureDesc.Format;
    textureViewDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2D;
    textureViewDesc.Texture2D.MipLevels = textureDesc.MipLevels;
    textureViewDesc.Texture2D.MostDetailedMip = 0;

    ComPtr<ID3D11ShaderResourceView> textureView;
    DX::ThrowIfFailed(
        m_d3dDevice->CreateShaderResourceView(
            texture.Get(),
            &textureViewDesc,
            &textureView
        )
    );

    // Once the texture view is created, create a sampler.  This defines how the color
    // for a particular texture coordinate is determined using the relevant texture data.
    D3D11_SAMPLER_DESC samplerDesc;
    ZeroMemory(&samplerDesc, sizeof(samplerDesc));

    samplerDesc.Filter = D3D11_FILTER_MIN_MAG_MIP_LINEAR;

    // The sampler does not use anisotropic filtering, so this parameter is ignored.
    samplerDesc.MaxAnisotropy = 0;

    // Specify how texture coordinates outside of the range 0..1 are resolved.
    samplerDesc.AddressU = D3D11_TEXTURE_ADDRESS_WRAP;
    samplerDesc.AddressV = D3D11_TEXTURE_ADDRESS_WRAP;
    samplerDesc.AddressW = D3D11_TEXTURE_ADDRESS_WRAP;

    // Use no special MIP clamping or bias.
    samplerDesc.MipLODBias = 0.0f;
    samplerDesc.MinLOD = 0;
    samplerDesc.MaxLOD = D3D11_FLOAT32_MAX;

    // Don't use a comparison function.
    samplerDesc.ComparisonFunc = D3D11_COMPARISON_NEVER;

    // Border address mode is not used, so this parameter is ignored.
    samplerDesc.BorderColor[0] = 0.0f;
    samplerDesc.BorderColor[1] = 0.0f;
    samplerDesc.BorderColor[2] = 0.0f;
    samplerDesc.BorderColor[3] = 0.0f;

    ComPtr<ID3D11SamplerState> sampler;
    DX::ThrowIfFailed(
        m_d3dDevice->CreateSamplerState(
            &samplerDesc,
            &sampler
        )
    );
});

// This value will be used to animate the cube by rotating it every frame;
float degree = 0.0f;

4. Drehen und Zeichnen des texturierten Würfels und Darstellung des gerenderten Bilds

Wie in den vorherigen Tutorials treten wir in eine Endlosschleife ein, um die Szene kontinuierlich zu rendern und anzuzeigen. Wir rufen die RotationY Inlinefunktion (BasicMath.h) mit einer Drehungsmenge auf, um Werte festzulegen, die die Modellmatrix des Würfels um die Y-Achse drehen. Anschließend rufen wir ID3D11DeviceContext::UpdateSubresource auf, um den Konstantenpuffer zu aktualisieren und das Würfelmodell zu drehen. Als Nächstes rufen wir ID3D11DeviceContext::OMSetRenderTargets auf, um das Renderziel und die Depth-Stencil-Ansicht anzugeben. Wir rufen ID3D11DeviceContext::ClearRenderTargetView auf, um das Renderziel in einfarbig blau zu färben, und ID3D11DeviceContext::ClearDepthStencilView, um den Tiefenpuffer zu löschen.

In der Endlosschleife zeichnen wir auch den texturierten Würfel auf der blauen Oberfläche.

So zeichnen Sie den texturierten Würfel

  1. Zunächst rufen wir ID3D11DeviceContext::IASetInputLayout auf, um zu beschreiben, wie Vertexpufferdaten in die Eingabeassemblerphase gestreamt werden.
  2. Als Nächstes rufen wir ID3D11DeviceContext::IASetVertexBuffers und ID3D11DeviceContext::IASetIndexBuffer auf, um die Vertex- und Indexpuffer an die Eingabeassembler-Stufe zu binden.
  3. Als Nächstes rufen wir ID3D11DeviceContext::IASetPrimitiveTopology mit dem Wert D3D11_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP auf, um für die Eingabeassembler-Stufe anzugeben, dass die Vertex-Daten als Dreiecksstreifen interpretiert werden sollen.
  4. Als Nächstes rufen wir ID3D11DeviceContext::VSSetShader auf, um die Vertex-Shader-Stufe mit dem Vertex-Shadercode zu initialisieren und ID3D11DeviceContext::PSSetShader auf, um die Pixel-Shader-Stufe mit dem Pixelshadercode zu initialisieren.
  5. Als Nächstes rufen wir ID3D11DeviceContext::VSSetConstantBuffers auf, um den Konstantenpuffer festzulegen, der in der Vertex-Shader-Pipeline-Phase verwendet wird.
  6. Als Nächstes rufen wir PSSetShaderResources auf, um die Shader-Ressourcen-Ansicht der Textur an die Pixel-Shader-Pipeline-Phase zu binden.
  7. Als Nächstes rufen wir PSSetSamplers auf, um den Samplerzustand für die Pipeline-Phase des Pixelshaders festzulegen.
  8. Schließlich rufen wir ID3D11DeviceContext::DrawIndexed auf, um den Würfel zu zeichnen und an die Rendering-Pipeline zu übermitteln.

Wie in den vorherigen Lernprogrammen rufen wir IDXGISwapChain::Present auf, um das gerenderte Bild im Fenster anzuzeigen.

// Update the constant buffer to rotate the cube model.
m_constantBufferData.model = DirectX::XMMatrixRotationY(-degree);
degree += 1.0f;

m_d3dDeviceContext->UpdateSubresource(
    m_constantBuffer.Get(),
    0,
    nullptr,
    &m_constantBufferData,
    0,
    0
);

// Specify the render target and depth stencil we created as the output target.
m_d3dDeviceContext->OMSetRenderTargets(
    1,
    m_renderTargetView.GetAddressOf(),
    m_depthStencilView.Get()
);

// Clear the render target to a solid color, and reset the depth stencil.
const float clearColor[4] = { 0.071f, 0.04f, 0.561f, 1.0f };
m_d3dDeviceContext->ClearRenderTargetView(
    m_renderTargetView.Get(),
    clearColor
);

m_d3dDeviceContext->ClearDepthStencilView(
    m_depthStencilView.Get(),
    D3D11_CLEAR_DEPTH,
    1.0f,
    0
);

m_d3dDeviceContext->IASetInputLayout(inputLayout.Get());

// Set the vertex and index buffers, and specify the way they define geometry.
UINT stride = sizeof(BasicVertex);
UINT offset = 0;
m_d3dDeviceContext->IASetVertexBuffers(
    0,
    1,
    vertexBuffer.GetAddressOf(),
    &stride,
    &offset
);

m_d3dDeviceContext->IASetIndexBuffer(
    indexBuffer.Get(),
    DXGI_FORMAT_R16_UINT,
    0
);

m_d3dDeviceContext->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);

// Set the vertex and pixel shader stage state.
m_d3dDeviceContext->VSSetShader(
    vertexShader.Get(),
    nullptr,
    0
);

m_d3dDeviceContext->VSSetConstantBuffers(
    0,
    1,
    m_constantBuffer.GetAddressOf()
);

m_d3dDeviceContext->PSSetShader(
    pixelShader.Get(),
    nullptr,
    0
);

m_d3dDeviceContext->PSSetShaderResources(
    0,
    1,
    textureView.GetAddressOf()
);

m_d3dDeviceContext->PSSetSamplers(
    0,
    1,
    sampler.GetAddressOf()
);

// Draw the cube.
m_d3dDeviceContext->DrawIndexed(
    ARRAYSIZE(cubeIndices),
    0,
    0
);

// Present the rendered image to the window.  Because the maximum frame latency is set to 1,
// the render loop will generally be throttled to the screen refresh rate, typically around
// 60 Hz, by sleeping the application on Present until the screen is refreshed.
DX::ThrowIfFailed(
    m_swapChain->Present(1, 0)
);

Zusammenfassung

In diesem Thema haben wir unformatierte Texturdaten geladen und diese Daten auf einen 3D-Grundtyp angewendet.