Anwenden von Texturen auf Grundtypen
Hier laden wir unformatierte Texturdaten und wenden diese Daten mithilfe des Würfels, den wir unter Verwendung von Tiefe und Effekten für Grundtypen erstellt haben, auf einen 3D-Grundtyp an. 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: So wenden Sie Texturen auf Grundtypen an.
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 sich bereits mit der Schnellstartanleitung vertraut machen: Einrichten von DirectX-Ressourcen und Anzeigen eines Bilds, Erstellen von Shadern und Zeichnen von Grundtypen sowie Verwenden von Tiefe und Effekten für 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 und die Darstellung des Würfels an. Andernfalls deklarieren wir Variablen ähnlich wie im vorherigen Lernprogramm unter Verwendung von Tiefe und Effekten für 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 Lernprogramm: Verwenden von Tiefe und Effekten für Grundtypen. Der Vertex-Shader dieser App wandelt jede Vertexposition in den Projektionsbereich um und übergibt die Vertextextkoordinate an den Pixelshader.
Das Array der App mit 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 vorgibt), 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
- 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.
- Als Nächstes beschreiben wir die Vertex- und Indexpuffer (D3D11_BUFFER_DESC und D3D11_SUBRESOURCE_DATA) mithilfe der Cubedefinition. Wir rufen ID3D11Device::CreateBuffer einmal für jeden Puffer auf.
- Als Nächstes erstellen wir einen Konstantenpuffer (D3D11_BUFFER_DESC) zum Übergeben von Modell-, Ansichts- und Projektionsmatrizen an den Vertex-Shader. 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.
- 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 wenden wir Texturdaten auf einen Würfel an, anstatt Farben anzuwenden, wie im vorherigen Lernprogramm unter Verwendung von Tiefe und Effekten auf Grundtypen.
Wir verwenden rohe Texturdaten, um Texturen zu erstellen.
So erstellen Sie Texturen und Sampler
- Zunächst lesen wir unformatierte Texturdaten aus der texturedata.bin Datei auf dem Datenträger.
- Als Nächstes erstellen wir eine D3D11_SUBRESOURCE_DATA Struktur, die auf diese rohen Texturdaten verweist.
- Anschließend füllen wir eine D3D11_TEXTURE2D_DESC Struktur auf, um die Textur zu beschreiben. Anschließend übergeben wir die D3D11_SUBRESOURCE_DATA- und D3D11_TEXTURE2D_DESC Strukturen in einem Aufruf von ID3D11Device::CreateTexture2D, um die Textur zu erstellen.
- 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 auf, um die Shaderressourcenansicht zu beschreiben und die Beschreibung der Shaderressourcenansicht und die Textur an ID3D11Device::CreateShaderResourceView zu übergeben. Im Allgemeinen stimmen Sie mit der Beschreibung der Ansicht mit der Texturbeschreibung überein.
- 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 auf, um den Samplerzustand zu beschreiben. Anschließend übergeben wir die D3D11_SAMPLER_DESC Struktur in einem Aufruf von ID3D11Device::CreateSamplerState, um den Samplerzustand zu erstellen.
- Schließlich deklarieren wir eine Gradvariable , mit der wir den Würfel animieren, indem wir ihn jeden 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 Darstellen des gerenderten Bilds
Wie in den vorherigen Lernprogrammen geben wir 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 Cubemodell zu drehen. Als Nächstes rufen wir ID3D11DeviceContext::OMSetRenderTargets auf, um das Renderziel und die Tiefenschablonenansicht anzugeben. Wir rufen ID3D11DeviceContext::ClearRenderTargetView auf, um das Renderziel auf eine vollblaue Farbe zu löschen und ID3D11DeviceContext::ClearDepthStencilView aufzurufen, 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
- Zunächst rufen wir ID3D11DeviceContext::IASetInputLayout auf, um zu beschreiben, wie Vertexpufferdaten in die Eingabeassemblerphase gestreamt werden.
- Als Nächstes rufen wir ID3D11DeviceContext::IASetVertexBuffers und ID3D11DeviceContext::IASetIndexBuffer auf, um die Vertex- und Indexpuffer an die Eingabeassemblerphase zu binden.
- Als Nächstes rufen wir ID3D11DeviceContext::IASetPrimitiveTopology mit dem D3D11_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP Wert auf, der für die Eingabeassemblerphase angegeben werden soll, um die Vertexdaten als Dreiecksstreifen zu interpretieren.
- Als Nächstes rufen wir ID3D11DeviceContext::VSSetShader auf, um die Vertex-Shaderphase mit dem Vertex-Shadercode und ID3D11DeviceContext::P SSetShader zu initialisieren, um die Pixelshaderphase mit dem Pixelshadercode zu initialisieren.
- Als Nächstes rufen wir ID3D11DeviceContext::VSSetConstantBuffers auf, um den Konstantenpuffer festzulegen, der von der Vertex-Shaderpipelinephase verwendet wird.
- Als Nächstes rufen wir PSSetShaderResources auf, um die Shaderressourcenansicht der Textur an die Pipelinephase des Pixelshaders zu binden.
- Als Nächstes rufen wir PSSetSamplers auf, um den Samplerzustand auf die Pipelinephase des Pixelshaders festzulegen.
- Schließlich rufen wir ID3D11DeviceContext::D rawIndexed auf, um den Cube zu zeichnen und an die Renderingpipeline zu übermitteln.
Wie in den vorherigen Lernprogrammen rufen wir IDXGISwapChain::P resent auf, um das gerenderte Bild im Fenster darzustellen.
// 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.