İşleme çerçevesi I: İşlemeye giriş

Uyarı

Bu konu, DirectX öğretici serisi ile basit bir Evrensel Windows Platformu (UWP) oluşturma oyunun bir parçasıdır. Bu bağlantıdaki konu başlığı, serinin bağlamını ayarlar.

Şimdiye kadar bir Evrensel Windows Platformu (UWP) oyununun nasıl yapılandırılacağını ve oyunun akışını işlemek için bir durum makinesi tanımlamayı ele aldık. Şimdi işleme çerçevesini geliştirmeyi öğrenmenin zamanı geldi. Örnek oyunun Direct3D 11 kullanarak oyun sahnesini nasıl işlemesine bakalım.

Direct3D 11, oyunlar gibi yoğun grafik kullanan uygulamalar için 3B grafikler oluşturmak için kullanılabilecek yüksek performanslı grafik donanımının gelişmiş özelliklerine erişim sağlayan bir dizi API içerir.

Oyun grafiklerini ekranda işlemek, temelde ekranda bir dizi karenin işlenmesi anlamına gelir. Her çerçevede, görünüme bağlı olarak sahnede görünen nesneleri işlemeniz gerekir.

Bir çerçeveyi işlemek için, ekranda görüntülenebilmesi için gerekli sahne bilgilerini donanıma geçirmeniz gerekir. Ekranda herhangi bir şeyin görüntülenmesini istiyorsanız, oyun çalışmaya başlar başlamaz işlemeye başlamanız gerekir.

Hedef

Bir UWP DirectX oyununun grafik çıkışını görüntülemek üzere temel bir işleme çerçevesi ayarlamak için. Bunu bu üç adıma bölebilirsiniz.

1. Grafik arabirimine bir bağlantı oluşturun.
2. Grafikleri çizmek için gereken kaynakları oluşturun.
3. Çerçeveyi işleyerek grafikleri görüntüleyin.

Bu konu başlığı altında, 1. ve 3. adımları kapsayan grafiklerin nasıl işlendiği açıklanmaktadır.

İşleme çerçevesi II: Oyun işleme , işleme çerçevesinin nasıl ayarlanacağı ve işleme gerçekleşmeden önce verilerin nasıl hazırlandığı gibi 2. adımı kapsar.

Başlayın

Temel grafikler ve işleme kavramları hakkında bilgi sahibi olmak iyi bir fikirdir. Direct3D ve işleme konusunda yeniyseniz, bu konuda kullanılan grafiklerin ve işleme terimlerinin kısa bir açıklaması için terimler ve kavramlar bölümüne bakın.

Bu oyun için GameRenderer sınıfı, bu örnek oyun için işleyiciyi temsil eder. Bu, oyun görsellerini oluşturmak için kullanılan tüm Direct3D 11 ve Direct2D nesnelerini oluşturmak ve korumakla sorumludur. Ayrıca, oluşturulacak nesnelerin listesini almak üzere kullanılan Simple3DGame nesnesine ve başüstü ekranı (HUD) için oyunun durumuna ilişkin bir başvuru tutar.

Eğitimin bu bölümünde, oyundaki 3B nesneleri görüntülemeye odaklanacağız.

Grafik arabirimine bağlantı kurma

İşleme için donanıma erişme hakkında bilgi için Oyunun UWP uygulama çerçevesini tanımlama konusuna bakın.

App::Initialize yöntemi

aşağıda gösterildiği gibi std::make_shared işlevi, cihaza erişim de sağlayan DX::D eviceResourcesiçin bir shared_ptr oluşturmak için kullanılır.

Direct3D 11'de, nesneleri ayırmak ve yok etmek, ilkelleri işlemek ve grafik sürücüsü aracılığıyla grafik kartıyla iletişim kurmak için bir cihaz kullanılır.

void Initialize(CoreApplicationView const& applicationView)
{
    ...

    // At this point we have access to the device. 
    // We can create the device-dependent resources.
    m_deviceResources = std::make_shared<DX::DeviceResources>();
}

Çerçeveyi işleyerek grafikleri görüntüle

Oyun başlatıldığında oyun sahnesinin işlenmesi gerekir. İşleme yönergeleri aşağıda gösterildiği gibi GameMain::Run yönteminde başlar.

Basit akış şudur.

1. Güncelleştirme
2. İşleme
3. Mevcut

GameMain::Run yöntemi

void GameMain::Run()
{
    while (!m_windowClosed)
    {
        if (m_visible) // if the window is visible
        {
            switch (m_updateState)
            {
            ...
            default:
                CoreWindow::GetForCurrentThread().Dispatcher().ProcessEvents(CoreProcessEventsOption::ProcessAllIfPresent);
                Update();
                m_renderer->Render();
                m_deviceResources->Present();
                m_renderNeeded = false;
            }
        }
        else
        {
            CoreWindow::GetForCurrentThread().Dispatcher().ProcessEvents(CoreProcessEventsOption::ProcessOneAndAllPending);
        }
    }
    m_game->OnSuspending();  // Exiting due to window close, so save state.
}

Güncelleştir

GameMain::Update yönteminde oyun durumlarının nasıl güncelleştirildiğini öğrenmek için Oyun akışı yönetimi konusuna bakın.

Görselleştirmek

İşleme, GameRenderer::Render metodu GameMain::Runyönteminden çağrılarak uygulanır.

stereo işleme etkinse, biri sol göz, diğeri sağ göz için olmak üzere iki işleme geçişi vardır. Her işleme geçişinde işleme hedefini ve derinlik kalıbı görünümünü cihaza bağlarız. Daha sonra derinlik-şablon görünümünü de temizleriz.

Uyarı

Stereo işleme, köşe örnekleme veya geometri gölgelendiriciler kullanılarak tek geçişli stereo gibi diğer yöntemler ile gerçekleştirilebilir. İki işlemeli geçiş yöntemi, stereo işlemeyi başarmak için daha yavaş ama daha kolay bir yoldur.

Oyun çalıştırıldıktan ve kaynaklar yüklendikten sonra, işleme geçişi başına bir kez projeksiyon matrisini güncelleştiririz. Nesneler her görünümden biraz farklıdır. Ardından, grafik işleme işlem hattınıkuruyoruz.

Uyarı

Kaynakların nasıl yüklendiği hakkında daha fazla bilgi için bkz. DirectX grafik kaynakları oluşturma ve yükleme .

Bu örnek oyunda işleyici, tüm nesneler arasında standart bir köşe düzeni kullanacak şekilde tasarlanmıştır. Bu, gölgelendirici tasarımını basitleştirir ve nesnelerin geometrilerinden bağımsız olarak gölgelendiriciler arasında kolay değişiklikler yapılmasını sağlar.

GameRenderer::Render yöntemi

Direct3D bağlamını giriş köşe düzenini kullanacak şekilde ayarladık. Giriş düzeni nesneleri, köşe tamponu verilerinin işleme işlem hattınanasıl aktığını açıklar.

Ardından Direct3D bağlamı, köşe gölgelendiricisi ve piksel gölgelendiricisi işlem hattı aşamaları tarafından kullanılan önceden tanımlanmış sabit arabellekleri kullanacak şekilde ayarlanır.

Uyarı

Sabit arabelleklerin tanımı hakkında daha fazla bilgi için Render Çerçevesi II: Oyun Renderi bölümüne bakın.

İşlem hattındaki tüm gölgelendiriciler için aynı giriş düzeni ve sabit arabellek kümesi kullanıldığından, çerçeve başına bir kez ayarlanır.

void GameRenderer::Render()
{
    bool stereoEnabled{ m_deviceResources->GetStereoState() };

    auto d3dContext{ m_deviceResources->GetD3DDeviceContext() };
    auto d2dContext{ m_deviceResources->GetD2DDeviceContext() };

    int renderingPasses = 1;
    if (stereoEnabled)
    {
        renderingPasses = 2;
    }

    for (int i = 0; i < renderingPasses; i++)
    {
        // Iterate through the number of rendering passes to be completed.
        // 2 rendering passes if stereo is enabled.
        if (i > 0)
        {
            // Doing the Right Eye View.
            ID3D11RenderTargetView* const targets[1] = { m_deviceResources->GetBackBufferRenderTargetViewRight() };

            // Resets render targets to the screen.
            // OMSetRenderTargets binds 2 things to the device.
            // 1. Binds one render target atomically to the device.
            // 2. Binds the depth-stencil view, as returned by the GetDepthStencilView method, to the device.
            // For more info, see
            // https://learn.microsoft.com/windows/win32/api/d3d11/nf-d3d11-id3d11devicecontext-omsetrendertargets

            d3dContext->OMSetRenderTargets(1, targets, m_deviceResources->GetDepthStencilView());

            // Clears the depth stencil view.
            // A depth stencil view contains the format and buffer to hold depth and stencil info.
            // For more info about depth stencil view, go to: 
            // https://learn.microsoft.com/windows/uwp/graphics-concepts/depth-stencil-view--dsv-
            // A depth buffer is used to store depth information to control which areas of 
            // polygons are rendered rather than hidden from view. To learn more about a depth buffer,
            // go to: https://learn.microsoft.com/windows/uwp/graphics-concepts/depth-buffers
            // A stencil buffer is used to mask pixels in an image, to produce special effects. 
            // The mask determines whether a pixel is drawn or not,
            // by setting the bit to a 1 or 0. To learn more about a stencil buffer,
            // go to: https://learn.microsoft.com/windows/uwp/graphics-concepts/stencil-buffers

            d3dContext->ClearDepthStencilView(m_deviceResources->GetDepthStencilView(), D3D11_CLEAR_DEPTH, 1.0f, 0);

            // Direct2D -- discussed later
            d2dContext->SetTarget(m_deviceResources->GetD2DTargetBitmapRight());
        }
        else
        {
            // Doing the Mono or Left Eye View.
            // As compared to the right eye:
            // m_deviceResources->GetBackBufferRenderTargetView instead of GetBackBufferRenderTargetViewRight
            ID3D11RenderTargetView* const targets[1] = { m_deviceResources->GetBackBufferRenderTargetView() };

            // Same as the Right Eye View.
            d3dContext->OMSetRenderTargets(1, targets, m_deviceResources->GetDepthStencilView());
            d3dContext->ClearDepthStencilView(m_deviceResources->GetDepthStencilView(), D3D11_CLEAR_DEPTH, 1.0f, 0);

            // d2d -- Discussed later under Adding UI
            d2dContext->SetTarget(m_deviceResources->GetD2DTargetBitmap());
        }

        const float clearColor[4] = { 0.5f, 0.5f, 0.8f, 1.0f };

        // Only need to clear the background when not rendering the full 3D scene since
        // the 3D world is a fully enclosed box and the dynamics prevents the camera from
        // moving outside this space.
        if (i > 0)
        {
            // Doing the Right Eye View.
            d3dContext->ClearRenderTargetView(m_deviceResources->GetBackBufferRenderTargetViewRight(), clearColor);
        }
        else
        {
            // Doing the Mono or Left Eye View.
            d3dContext->ClearRenderTargetView(m_deviceResources->GetBackBufferRenderTargetView(), clearColor);
        }

        // Render the scene objects
        if (m_game != nullptr && m_gameResourcesLoaded && m_levelResourcesLoaded)
        {
            // This section is only used after the game state has been initialized and all device
            // resources needed for the game have been created and associated with the game objects.
            if (stereoEnabled)
            {
                // When doing stereo, it is necessary to update the projection matrix once per rendering pass.

                auto orientation = m_deviceResources->GetOrientationTransform3D();

                ConstantBufferChangeOnResize changesOnResize;
                // Apply either a left or right eye projection, which is an offset from the middle
                XMStoreFloat4x4(
                    &changesOnResize.projection,
                    XMMatrixMultiply(
                        XMMatrixTranspose(
                            i == 0 ?
                            m_game->GameCamera().LeftEyeProjection() :
                            m_game->GameCamera().RightEyeProjection()
                            ),
                        XMMatrixTranspose(XMLoadFloat4x4(&orientation))
                        )
                    );

                d3dContext->UpdateSubresource(
                    m_constantBufferChangeOnResize.get(),
                    0,
                    nullptr,
                    &changesOnResize,
                    0,
                    0
                    );
            }

            // Update variables that change once per frame.
            ConstantBufferChangesEveryFrame constantBufferChangesEveryFrameValue;
            XMStoreFloat4x4(
                &constantBufferChangesEveryFrameValue.view,
                XMMatrixTranspose(m_game->GameCamera().View())
                );
            d3dContext->UpdateSubresource(
                m_constantBufferChangesEveryFrame.get(),
                0,
                nullptr,
                &constantBufferChangesEveryFrameValue,
                0,
                0
                );

            // Set up the graphics pipeline. This sample uses the same InputLayout and set of
            // constant buffers for all shaders, so they only need to be set once per frame.
            // For more info about the graphics or rendering pipeline, see
            // https://learn.microsoft.com/windows/win32/direct3d11/overviews-direct3d-11-graphics-pipeline

            // IASetInputLayout binds an input-layout object to the input-assembler (IA) stage. 
            // Input-layout objects describe how vertex buffer data is streamed into the IA pipeline stage.
            // Set up the Direct3D context to use this vertex layout. For more info, see
            // https://learn.microsoft.com/windows/win32/api/d3d11/nf-d3d11-id3d11devicecontext-iasetinputlayout
            d3dContext->IASetInputLayout(m_vertexLayout.get());

            // VSSetConstantBuffers sets the constant buffers used by the vertex shader pipeline stage.
            // Set up the Direct3D context to use these constant buffers. For more info, see
            // https://learn.microsoft.com/windows/win32/api/d3d11/nf-d3d11-id3d11devicecontext-vssetconstantbuffers

            ID3D11Buffer* constantBufferNeverChanges{ m_constantBufferNeverChanges.get() };
            d3dContext->VSSetConstantBuffers(0, 1, &constantBufferNeverChanges);
            ID3D11Buffer* constantBufferChangeOnResize{ m_constantBufferChangeOnResize.get() };
            d3dContext->VSSetConstantBuffers(1, 1, &constantBufferChangeOnResize);
            ID3D11Buffer* constantBufferChangesEveryFrame{ m_constantBufferChangesEveryFrame.get() };
            d3dContext->VSSetConstantBuffers(2, 1, &constantBufferChangesEveryFrame);
            ID3D11Buffer* constantBufferChangesEveryPrim{ m_constantBufferChangesEveryPrim.get() };
            d3dContext->VSSetConstantBuffers(3, 1, &constantBufferChangesEveryPrim);

            // Sets the constant buffers used by the pixel shader pipeline stage. 
            // For more info, see
            // https://learn.microsoft.com/windows/win32/api/d3d11/nf-d3d11-id3d11devicecontext-pssetconstantbuffers

            d3dContext->PSSetConstantBuffers(2, 1, &constantBufferChangesEveryFrame);
            d3dContext->PSSetConstantBuffers(3, 1, &constantBufferChangesEveryPrim);
            ID3D11SamplerState* samplerLinear{ m_samplerLinear.get() };
            d3dContext->PSSetSamplers(0, 1, &samplerLinear);

            for (auto&& object : m_game->RenderObjects())
            {
                // The 3D object render method handles the rendering.
                // For more info, see Primitive rendering below.
                object->Render(d3dContext, m_constantBufferChangesEveryPrim.get());
            }
        }

        // Start of 2D rendering
        ...
    }
}

İlkel renderleme

Sahneyi işlerken işlenmesi gereken tüm nesneler arasında döngü oluşturursunuz. Aşağıdaki adımlar her nesne için yinelenir (ilkel).

• Sabit arabelleği (m_constantBufferChangesEveryPrim) modelin dünya dönüşüm matrisi ve malzeme bilgileriyle güncelleyin.
• m_constantBufferChangesEveryPrim her nesne için parametreler içerir. Nesneden dünyaya dönüştürme matrisinin yanı sıra, aydınlatma hesaplamaları için renk ve yansıma katsayısı gibi malzeme özelliklerini içerir.
• işleme işlem hattıgiriş-derleyicisi (IA) aşamasına akışla aktarılacak mesh nesnesi verilerinin giriş köşesi düzenini kullanmak için Direct3D bağlamını ayarlayın.
• IA aşamasında dizin arabelleği kullanmak için Direct3D bağlamını ayarlayın. İlkel bilgileri sağlayın: tür, veri sırası.
• Dizine alınmış, örneklenmemiş temel öğeyi çizmek için bir çizim çağrısı gönderin. GameObject::Render yöntemi, temel sabit arabelleği belirli bir temel öğeye özgü verilerle güncelleştirir. Bu, her bir temel öğenin geometrisini çizmek için bağlam üzerinde DrawIndexed çağrısıyla sonuçlanır. Bu çizim çağrısı, sabit arabellek bilgileri ile parametrelendirilen komutları ve verileri grafik işleme birimine (GPU) kuyruğa alır. Her çizim çağrısı, köşedeki her köşe için bir kez köşe gölgelendiricisini yürütür ve ardından piksel gölgelendiricisi, ilkeldeki her üçgenin her pikseli için bir kez çalıştırılır. Dokular, piksel gölgelendiricisinin işlemeyi yapmak için kullandığı durumun bir parçasıdır.

Birden çok sabit arabellek kullanmanın nedenleri şunlardır.

• Oyun birden fazla sabit arabellek kullanır, ancak bu arabellekleri primitif başına yalnızca bir kez güncelleştirmesi gerekir. Daha önce belirtildiği gibi, sabit arabellekler her primitif için gölgelendiricileri çalıştıran girişler gibidir. Bazı veriler statiktir (m_constantBufferNeverChanges); bazı veriler, kameranın konumu gibi çerçeve (m_constantBufferChangesEveryFrame) üzerinde sabittir; ve bazı veriler, rengi ve dokuları (m_constantBufferChangesEveryPrim) gibi temel öğelere özgüdür.
• Oyun oluşturucu, CPU ve GPU tarafından kullanılan bellek bant genişliğini iyileştirmek için bu girişleri farklı sabit arabelleklere ayırır. Bu yaklaşım, GPU'nun izlemesi gereken veri miktarını en aza indirmeye de yardımcı olur. GPU'nun büyük bir komut kuyruğu vardır ve oyun her Drawçağırdığında, bu komut kendisiyle ilişkili verilerle birlikte kuyruğa alınır. Oyun temel sabit arabelleği güncelleştirdiğinde ve bir sonraki Draw komutunu çıkardığında, grafik sürücüsü bu sonraki komutu ve ilişkili verileri kuyruğa ekler. Oyun 100 temel öğe çizerse, kuyruktaki sabit arabellek verilerinin 100 kopyasına sahip olabilir. Oyunun GPU'ya gönderdiği veri miktarını en aza indirmek için, oyun yalnızca her temel öğe için güncelleştirmeleri içeren ayrı bir temel sabit arabellek kullanır.

GameObject::Render yöntemi

void GameObject::Render(
    _In_ ID3D11DeviceContext* context,
    _In_ ID3D11Buffer* primitiveConstantBuffer
    )
{
    if (!m_active || (m_mesh == nullptr) || (m_normalMaterial == nullptr))
    {
        return;
    }

    ConstantBufferChangesEveryPrim constantBuffer;

    // Put the model matrix info into a constant buffer, in world matrix.
    XMStoreFloat4x4(
        &constantBuffer.worldMatrix,
        XMMatrixTranspose(ModelMatrix())
        );

    // Check to see which material to use on the object.
    // If a collision (a hit) is detected, GameObject::Render checks the current context, which 
    // indicates whether the target has been hit by an ammo sphere. If the target has been hit, 
    // this method applies a hit material, which reverses the colors of the rings of the target to 
    // indicate a successful hit to the player. Otherwise, it applies the default material 
    // with the same method. In both cases, it sets the material by calling Material::RenderSetup, 
    // which sets the appropriate constants into the constant buffer. Then, it calls 
    // ID3D11DeviceContext::PSSetShaderResources to set the corresponding texture resource for the 
    // pixel shader, and ID3D11DeviceContext::VSSetShader and ID3D11DeviceContext::PSSetShader 
    // to set the vertex shader and pixel shader objects themselves, respectively.

    if (m_hit && m_hitMaterial != nullptr)
    {
        m_hitMaterial->RenderSetup(context, &constantBuffer);
    }
    else
    {
        m_normalMaterial->RenderSetup(context, &constantBuffer);
    }

    // Update the primitive constant buffer with the object model's info.
    context->UpdateSubresource(primitiveConstantBuffer, 0, nullptr, &constantBuffer, 0, 0);

    // Render the mesh.
    // See MeshObject::Render method below.
    m_mesh->Render(context);
}

MeshObject::Render yöntemi

void MeshObject::Render(_In_ ID3D11DeviceContext* context)
{
    // PNTVertex is a struct. stride provides us the size required for all the mesh data
    // struct PNTVertex
    //{
    //  DirectX::XMFLOAT3 position;
    //  DirectX::XMFLOAT3 normal;
    //  DirectX::XMFLOAT2 textureCoordinate;
    //};
    uint32_t stride{ sizeof(PNTVertex) };
    uint32_t offset{ 0 };

    // Similar to the main render loop.
    // Input-layout objects describe how vertex buffer data is streamed into the IA pipeline stage.
    ID3D11Buffer* vertexBuffer{ m_vertexBuffer.get() };
    context->IASetVertexBuffers(0, 1, &vertexBuffer, &stride, &offset);

    // IASetIndexBuffer binds an index buffer to the input-assembler stage.
    // For more info, see
    // https://learn.microsoft.com/windows/win32/api/d3d11/nf-d3d11-id3d11devicecontext-iasetindexbuffer.
    context->IASetIndexBuffer(m_indexBuffer.get(), DXGI_FORMAT_R16_UINT, 0);

    // Binds information about the primitive type, and data order that describes input data for the input assembler stage.
    // For more info, see
    // https://learn.microsoft.com/windows/win32/api/d3d11/nf-d3d11-id3d11devicecontext-iasetprimitivetopology.
    context->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);

    // Draw indexed, non-instanced primitives. A draw API submits work to the rendering pipeline.
    // For more info, see
    // https://learn.microsoft.com/windows/win32/api/d3d11/nf-d3d11-id3d11devicecontext-drawindexed.
    context->DrawIndexed(m_indexCount, 0, 0);
}

DeviceResources::P resent yöntemi

Arabelleklere yerleştirdiğimiz içeriği görüntülemek için DeviceResources::Present yöntemini çağırırız.

Kullanıcıya çerçeveleri görüntülemek için kullanılan arabellek koleksiyonu için "swap chain" terimini kullanırız. Her uygulama bir gösterim için yeni bir çerçeve sunduğunda, takas zincirindeki ilk arabellek gösterilen arabelleğin yerini alır. Bu işleme değiştirme veya çevirme denir. Daha fazla bilgi için bkz. takas zincirleri.

• IDXGISwapChain1 arabiriminin Present yöntemi, DXGI'yi dikey eşitleme (VSync) gerçekleşene kadar beklemesi için talimat verir ve uygulamayı bir sonraki VSync'e kadar uyku moduna geçirir. Bu, ekranda hiçbir zaman görüntülenmeyecek çerçeveleri işleme döngülerini boşa harcamamanızı sağlar.
• ID3D11DeviceContext3 arabiriminin DiscardView yöntemi, işleme hedefininiçeriğini yok sayar. Bu, yalnızca mevcut içerik tamamen üzerine yazıldığında geçerli bir işlemdir. Kirli veya kaydırma dikdörtgenleri kullanılıyorsa, bu çağrı kaldırılmalıdır.

• Aynı DiscardView yöntemini kullanarak derinlik kalıbıiçeriğini atın.
• HandleDeviceLost yöntemi, kaldırılan cihaz durumunu yönetmek için kullanılır. Cihaz bir bağlantı kesilmesi veya sürücü yükseltmesi tarafından kaldırıldıysa, tüm cihaz kaynaklarını yeniden oluşturmanız gerekir. Daha fazla bilgi için bkz. Direct3D 11'de cihaz kaldırma senaryolarını işleme.

Tavsiye

Düzgün bir kare hızı elde etmek için, bir çerçeveyi işlemek için gereken çalışma miktarının VSync'ler arasındaki zamana uyduğundan emin olmanız gerekir.

// Present the contents of the swap chain to the screen.
void DX::DeviceResources::Present()
{
    // The first argument instructs DXGI to block until VSync, putting the application
    // to sleep until the next VSync. This ensures we don't waste any cycles rendering
    // frames that will never be displayed to the screen.
    HRESULT hr = m_swapChain->Present(1, 0);

    // Discard the contents of the render target.
    // This is a valid operation only when the existing contents will be entirely
    // overwritten. If dirty or scroll rects are used, this call should be removed.
    m_d3dContext->DiscardView(m_d3dRenderTargetView.get());

    // Discard the contents of the depth stencil.
    m_d3dContext->DiscardView(m_d3dDepthStencilView.get());

    // If the device was removed either by a disconnection or a driver upgrade, we 
    // must recreate all device resources.
    if (hr == DXGI_ERROR_DEVICE_REMOVED || hr == DXGI_ERROR_DEVICE_RESET)
    {
        HandleDeviceLost();
    }
    else
    {
        winrt::check_hresult(hr);
    }
}

Sonraki Adımlar

Bu konu başlığı altında, grafiklerin ekranda nasıl işlendiği açıklanır ve kullanılan işleme terimlerinden bazıları için kısa bir açıklama sağlanır (aşağıda). İşleme çerçevesi II: Oyun işleme konusunda işleme hakkında daha fazla bilgi edinin ve işlemeden önce gereken verileri hazırlamayı öğrenin.

Terimler ve kavramlar

Basit oyun sahnesi

Basit bir oyun sahnesi, birkaç ışık kaynağı olan birkaç nesneden oluşur.

Nesnenin şekli, boşluktaki X, Y, Z koordinatları kümesiyle tanımlanır. Oyun dünyasındaki gerçek işleme konumu, konumsal X, Y, Z koordinatlarına bir dönüşüm matrisi uygulanarak belirlenebilir. Ayrıca, bir malzemenin nesneye nasıl uygulandığını belirten bir dizi doku koordinatları (U ve V) olabilir. Bu, nesnenin yüzey özelliklerini tanımlar ve bir nesnenin pürüzlü bir yüzeye (tenis topu gibi) veya pürüzsüz parlak bir yüzeye (bowling topu gibi) sahip olup olmadığını görmenizi sağlar.

Sahne ve nesne bilgileri, ekranınızda canlanan sahneyi kare kare yeniden oluşturmak için işleme çerçevesi altyapısı tarafından kullanılır.

Görüntü işleme hattı

İşleme işlem hattı, 3B sahne bilgilerinin ekranda görüntülenen bir görüntüye çevrildiği işlemdir. Direct3D 11'de bu işlem hattı programlanabilir. Aşamaları işleme gereksinimlerinizi destekleyecek şekilde uyarlayabilirsiniz. Ortak gölgelendirici çekirdekleri içeren aşamalar, HLSL programlama dili kullanılarak programlanabilir. grafik işleme işlem hattıolarak da bilinir veya yalnızca işlem hattıolarak.

Bu işlem hattını oluşturmanıza yardımcı olmak için bu ayrıntılar hakkında bilgi sahibi olmanız gerekir.

• HLSL. UWP DirectX oyunları için HLSL Shader Model 5.1 ve üzerini kullanmanızı öneririz.
• Shader'lar.
• Köşe gölgelendiricileri ve piksel gölgelendiricileri.
• Shader aşamaları.
• çeşitli gölgelendirici dosya biçimleri.

Daha fazla bilgi için bkz. Direct3D 11 işleme işlem hattı ve Grafik işlem hattı.

HLSL

HLSL, DirectX için üst düzey gölgelendirici dilidir. HLSL kullanarak Direct3D işlem hattı için C benzeri programlanabilir gölgelendiriciler oluşturabilirsiniz. Daha fazla bilgi için bkz. HLSL.

Gölgelendiriciler

Gölgelendirici, bir nesnenin yüzeyinin işlendiğinde nasıl görüneceğini belirleyen yönergeler kümesi olarak düşünülebilir. HLSL kullanılarak programlananlar HLSL gölgelendiricileri olarak bilinir. [HLSL])(#hlsl) gölgelendiricileri için kaynak kod dosyaları dosya uzantısına .hlsl sahiptir. Bu gölgelendiriciler derleme zamanında veya çalışma zamanında derlenebilir ve çalışma zamanında uygun işlem hattı aşamasına ayarlanabilir. Derlenmiş bir gölgelendirici nesnesinin dosya uzantısı .cso'dir.

Direct3D 9 gölgelendiricileri gölgelendirici model 1, gölgelendirici model 2 ve gölgelendirici model 3 kullanılarak tasarlanabilir; Direct3D 10 gölgelendiriciler yalnızca gölgelendirici model 4 üzerinde tasarlanabilir. Direct3D 11 gölgelendiriciler, gölgelendirici model 5 üzerinde tasarlanabilir. Direct3D 11.3 ve Direct3D 12, gölgelendirici modeli 5.1 üzerinde tasarlanabilir ve Direct3D 12 de gölgelendirici model 6 üzerinde tasarlanabilir.

Köşe gölgelendiricileri ve piksel gölgelendiricileri

Veriler grafik işlem hattına ilkel öğeler akışı olarak girer ve köşe gölgelendiricileri ve piksel gölgelendiricileri gibi çeşitli gölgelendiriciler tarafından işlenir.

Köşe gölgelendiricileri köşeleri işler ve genellikle dönüşümler, kaplama ve aydınlatma gibi işlemler gerçekleştirir. Piksel gölgelendiriciler, piksel başına aydınlatma ve işlem sonrası gibi zengin gölgelendirme tekniklerini etkinleştirir. Sabit değişkenleri, doku verilerini, köşe başına değerleri ve diğer verileri bir araya getirerek piksel başına çıkışlar oluşturur.

Gölgelendirici aşamaları

Bu temel öğe akışını işlemek için tanımlanan bu çeşitli gölgelendiricilerden oluşan bir dizi, işleme işlem hattında gölgelendirici aşamaları olarak bilinir. Gerçek aşamalar Direct3D sürümüne bağlıdır, ancak genellikle köşe, geometri ve piksel aşamalarını içerir. Teselasyon için kabuk ve etki alanı gölgelendiricileri ile işlem gölgelendiricisi gibi başka aşamalar da vardır. Tüm bu aşamalar HLSL kullanılarak tamamen programlanabilir. Daha fazla bilgi için bkz . Grafik işlem hattı.

Çeşitli gölgelendirici dosya biçimleri

Gölgelendirici kod dosyası uzantıları aşağıdadır.

• Uzantılı .hlsl bir dosya [HLSL])(#hlsl) kaynak kodunu barındırır.
• Uzantılı .cso bir dosya derlenmiş bir gölgelendirici nesnesi barındırır.
• Uzantılı .h bir dosya bir üst bilgi dosyasıdır, ancak gölgelendirici kod bağlamında, bu üst bilgi dosyası gölgelendirici verilerini tutan bir bayt dizisi tanımlar.
• .hlsli uzantısına sahip bir dosya sabit arabelleklerin formatını içerir. Örnek oyunda, dosya Shaders>ConstantBuffers.hlsli.

Uyarı

Yürütme zamanında bir .cso dosyası yükleyerek veya yürütülebilir kodunuza bir .h dosyası ekleyerek bir gölgelendirici gömersiniz. Ama ikisini de aynı gölgelendirici için kullanmazsınız.

DirectX hakkında daha ayrıntılı bilgi

Direct3D 11, yoğun hesaplamayı işlemek için iyi bir grafik kartına sahip olmak istediğimiz oyunlar gibi yoğun grafik kullanan uygulamalar için grafik oluşturmamıza yardımcı olabilecek bir dizi API'dir. Bu bölümde Direct3D 11 grafik programlama kavramları kısaca açıklanmaktadır: kaynak, alt kaynak, cihaz ve cihaz bağlamı.

Kaynak

Kaynakları (cihaz kaynakları olarak da bilinir) doku, konum veya renk gibi bir nesneyi işleme hakkında bilgi olarak düşünebilirsiniz. Kaynaklar işlem hattına veri sağlar ve sahnenizde görüntülenenleri tanımlar. Kaynaklar oyun medyanızdan yüklenebilir veya çalışma zamanında dinamik olarak oluşturulabilir.

Kaynak, aslındaDirect3D işlem hattı tarafından erişilebilen bellek alanıdır. İşlem hattının belleğe verimli bir şekilde erişebilmesi için işlem hattına sağlanan verilerin (giriş geometrisi, gölgelendirici kaynakları ve dokular gibi) bir kaynakta depolanması gerekir. Tüm Direct3D kaynaklarının türetildiği iki tür kaynak vardır: arabellek veya doku. Her işlem hattı aşaması için en fazla 128 kaynak etkin olabilir. Daha fazla bilgi için bkz . Kaynaklar.

Alt Kaynak

Alt kaynak terimi bir kaynağın alt kümesine başvurur. Direct3D bir kaynağın tamamına veya kaynağın alt kümelerine başvurabilir. Daha fazla bilgi için bkz. Alt kaynak.

Derinlik kalıbı

Derinlik-şablon kaynağı, derinlik ve şablon bilgilerini tutmak için biçimi ve tamponu içerir. Bir doku kaynağı kullanılarak oluşturulmuştur. Derinlik şablonu kaynağı oluşturma hakkında daha fazla bilgi için, Yapılandırma Depth-Stencil İşlevsellikbölümüne bakın. ID3D11DepthStencilView arabirimi kullanılarak oluşturulan derinlik-stencil görünümü aracılığıyla derinlik-stencil kaynağına erişiyoruz.

Derinlik bilgileri, hangi çokgen alanlarının diğerlerinin arkasında olduğunu bildirir, böylece hangilerinin gizlendiğini belirleyebiliriz. Kalıp bilgileri hangi piksellerin maskelendiğini bize bildirir. Bir pikselin çizilip çekilmediğini belirlediği için özel efektler üretmek için kullanılabilir; biti 1 veya 0 olarak ayarlar.

Daha fazla bilgi için bkz Derinlik-şablon görünümü, derinlik arabelleği ve şablon arabelleği.

Görüntü hedefi

İşleme hedefi, bir render geçişinin sonunda yazabileceğimiz bir kaynaktır. Genellikle ID3D11Device::CreateRenderTargetView yöntemi kullanılarak giriş parametresi olarak değiştirme zinciri geri arabelleği (aynı zamanda bir kaynaktır) kullanılarak oluşturulur.

İşleme hedefini kullanmadan önce ayarlamak için OMSetRenderTargets kullandığımızda derinlik kalıbı görünümü de gerektirdiğinden, her işleme hedefinin de buna karşılık gelen bir derinlik kalıbı görünümü olmalıdır. id3D11RenderTargetView arabirimi kullanılarak uygulanan işleme hedef görünümü aracılığıyla işleme hedef kaynağına erişiyoruz.

Aygıt

Bir cihazı nesneleri ayırmanın ve yok etmenin, temel nesneleri işlemenin ve grafik sürücüsü aracılığıyla grafik kartıyla iletişim kurmanın bir yolu olarak düşünebilirsiniz.

Daha kesin bir açıklama için Direct3D cihazı, Direct3D'nin işleme bileşenidir. Cihaz işleme durumunu kapsüller ve depolar, dönüştürmeler ve aydınlatma işlemleri gerçekleştirir ve bir görüntüyü bir yüzeye rasterleştirir. Daha fazla bilgi için bkz. Devices

Bir cihaz ID3D11Device arabirimiyle temsil edilir. Başka bir deyişle , ID3D11Device arabirimi bir sanal görüntü bağdaştırıcısını temsil eder ve bir cihaza ait kaynakları oluşturmak için kullanılır.

ID3D11Device'in farklı sürümleri vardır. ID3D11Device5 en son sürümdür ve ID3D11Device4'tekilere yeni yöntemler ekler. Direct3D'nin temel donanımla iletişim kurması hakkında daha fazla bilgi için bkz. Windows Cihaz Sürücü Modeli (WDDM) mimarisi.

Her uygulamanın en az bir cihazı olmalıdır; çoğu uygulama yalnızca bir tane oluşturur. D3D11CreateDevice veyaD3D11CreateDeviceAndSwapChain çağrısı yaparak ve D3D_DRIVER_TYPE bayrağıyla sürücü türünü belirterek makinenizde yüklü donanım sürücülerinden biri için bir cihaz oluşturun. Her cihaz, istenen işlevselliğe bağlı olarak bir veya daha fazla cihaz bağlamı kullanabilir. Daha fazla bilgi için bkz. D3D11CreateDevice işlevi.

Cihaz bağlamı

Cihaz bağlamı, işlem hattı durumunu ayarlamak ve bir cihazsahip kaynaklarını kullanarak işleme komutları oluşturmak için kullanılır.

Direct3D 11, biri anında işleme, diğeri ertelenmiş işleme için olmak üzere iki tür cihaz bağlamı uygular; her iki bağlam da ID3D11DeviceContext arabirimiyle temsil edilir.

ID3D11DeviceContext arabirimlerinin farklı sürümleri vardır; ID3D11DeviceContext4, ID3D11DeviceContext3 içindekilere yeni yöntemler ekler.

ID3D11DeviceContext4 , Windows 10 Creators Update'te kullanıma sunulmuştur ve ID3D11DeviceContext arabiriminin en son sürümüdür. Windows 10 Creators Update ve sonraki sürümleri hedefleyen uygulamalar önceki sürümler yerine bu arabirimi kullanmalıdır. Daha fazla bilgi için bkz. ID3D11DeviceContext4.

DX::D eviceResources

DX::D eviceResources sınıfı DeviceResources.cpp.h/ dosyalarındadır ve tüm DirectX cihaz kaynaklarını denetler.

Tampon

Bir arabellek kaynağı, tam tipli verilerin öğeler halinde gruplandırıldığı bir koleksiyondur. Konum vektörleri, normal vektörler, köşe arabelleğindeki doku koordinatları, dizin arabelleğindeki dizinler veya cihaz durumu gibi çok çeşitli verileri depolamak için arabellekleri kullanabilirsiniz. Arabellek öğeleri paketlenmiş veri değerlerini ( R8G8B8A8 yüzey değerleri gibi), tek 8 bit tamsayıları veya dört 32 bit kayan nokta değerini içerebilir.

Kullanılabilir üç arabellek türü vardır: köşe arabelleği, dizin arabelleği ve sabit arabellek.

Köşe arabelleği

Geometrinizi tanımlamak için kullanılan köşe verilerini içerir. Köşe noktası verileri, konum koordinatlarını, renk verilerini, doku koordinatlarını, normal verilerini vb. içerir.

Dizin arabelleği

Köşe arabelleklerine tamsayı uzaklıkları içerir ve ilkelleri daha verimli bir şekilde işlemek için kullanılır. Dizin arabelleği 16 bit veya 32 bit dizinlerden oluşan sıralı bir küme içerir; her dizin, bir köşe arabelleğindeki bir köşeyi tanımlamak için kullanılır.

Sabit arabellek veya gölgelendirici-sabit arabellek

İşlem hattına gölgelendirici verilerini verimli bir şekilde sağlamanıza olanak tanır. Sabit arabellekleri, her temel öğe için çalışan gölgelendiricilere giriş olarak kullanabilir ve işleme işlem hattının akış çıkış aşamasının sonuçlarını depolayabilirsiniz. Kavramsal olarak, sabit bir arabellek aynı tek öğeli köşe arabelleği gibi görünür.

Arabelleklere yönelik tasarım ve uygulama

Veri türüne göre arabellekler tasarlayabilirsiniz, örneğin örnek oyunumuzda olduğu gibi, bir arabellek statik veriler için oluşturulur, diğeri çerçeve üzerinde sabit olan veriler için ve diğeri de ilkel verilere özgü veriler için oluşturulur.

Tüm arabellek türleri ID3D11Buffer arabirimi tarafından kapsüllenir ve ID3D11Device::CreateBufferçağrısı yaparak bir arabellek kaynağı oluşturabilirsiniz. Ancak bir arabelleğe erişilmeden önce işlem hattına bağlı olması gerekir. Arabellekler, okuma için aynı anda birden çok işlem hattı aşamasına bağlanabilir. Arabellek, yazma için tek bir işlem hattı aşamasına da bağlanabilir; ancak, aynı arabellek aynı anda hem okuma hem de yazma için bağlanamaz.

Arabellekleri bu yollarla bağlayabilirsiniz.

• ID3D11DeviceContext::IASetVertexBuffers ve ID3D11DeviceContext::IASetVertexBuffers ve ID3D11DeviceContext::IASetIndexBuffergibi ID3D11DeviceContext yöntemlerini çağırarak input-assembler aşamasına geçin.
• ID3D11DeviceContext::SOSetTargetsçağırarak stream-output aşamasına geçiş yapın.
• Gölgelendirici yöntemlerini, ID3D11DeviceContext::VSSetConstantBuffersgibi, çağırarak gölgelendirici aşamasına geçin.

Daha fazla bilgi için bkz. Direct3D 11'de arabelleklere giriş.

DXGI

Microsoft DirectX Grafik Altyapısı (DXGI), Direct3D tarafından gereken bazı alt düzey görevleri kapsülleyen bir alt sistemdir. Kilitlenmelerin oluşmadığından emin olmak için çok iş parçacıklı bir uygulamada DXGI kullanılırken özel özen gösterilmelidir. Daha fazla bilgi için bkz . Çoklu iş parçacığı kullanımı ve DXGI

Özellik düzeyi

Özellik düzeyi, direct3D 11'de yeni ve mevcut makinelerdeki ekran kartlarının çeşitliliğini ele almak için sunulan bir kavramdır. Özellik düzeyi, iyi tanımlanmış bir grafik işleme birimi (GPU) işlevselliği kümesidir.

Her ekran kartı, yüklü GPU'lara bağlı olarak belirli bir DirectX işlevselliği düzeyi uygular. Microsoft Direct3D'nin önceki sürümlerinde, uygulanan video kartının Direct3D sürümünü bulabilir ve uygulamanızı buna göre programlayabilirsiniz.

Özellik düzeyiyle, bir cihaz oluşturduğunuzda, istediğiniz özellik düzeyi için bir cihaz oluşturmayı deneyebilirsiniz. Cihaz oluşturma işlemi başarılı olursa, bu özellik düzeyi mevcut demektir; eğer değilse, donanım bu özellik düzeyini desteklemiyor demektir. Bir cihazı daha düşük bir özellik düzeyinde yeniden oluşturmayı deneyebilir veya uygulamadan çıkmayı seçebilirsiniz. Örneğin, 12_0 özellik düzeyi Için Direct3D 11.3 veya Direct3D 12 ve gölgelendirici modeli 5.1 gerekir. Daha fazla bilgi için bkz. Direct3D özellik düzeyleri: Her özellik düzeyi için genel bakış.

Özellik düzeylerini kullanarak Direct3D 9, Microsoft Direct3D 10 veya Direct3D 11 için bir uygulama geliştirebilir ve ardından 9, 10 veya 11 donanımlarında (bazı özel durumlar dışında) çalıştırabilirsiniz. Daha fazla bilgi için bkz. Direct3D özellik düzeyleri.

Stereo işleme

Stereo işleme, derinlik yanılsamasını geliştirmek için kullanılır. Ekran ekranında bir sahne görüntülemek için biri sol gözle, diğeri sağ gözle olmak üzere iki resim kullanır.

Matematiksel olarak, normal mono projeksiyon matrisine göre sağa ve sola doğru hafif bir yatay kaydırma içeren bir stereo projeksiyon matrisi uygularız ve bu şekilde bunu başarırız.

Bu örnek oyunda stereo işleme elde etmek için iki işleme geçişi yaptık.

• Sağ işleme hedefine bağlanın, sağ projeksiyonu uygulayın ve ardından ilkel nesneyi çizin.
• Sol görüntüleme hedefine bağlanın, sol projeksiyonu uygulayın, sonra ilkel nesneyi çizin.

Kamera ve koordinat alanı

Oyun, dünyayı kendi koordinat sisteminde (bazen dünya uzayı veya sahne alanı olarak adlandırılır) güncelleştirmek için bir koda sahiptir. Kamera da dahil olmak üzere tüm nesneler bu alanda konumlandırılır ve yönlendirilir. Daha fazla bilgi için bkz . Koordinat sistemleri.

Köşe gölgelendiricisi, aşağıdaki algoritmayla model koordinatlarından cihaz koordinatlarına dönüştürme işleminin ağır bir şekilde kaldırılmasını yapar (burada V bir vektör, M ise matristir).

V(device) = V(model) x M(model-to-world) x M(world-to-view) x M(view-to-device)

• M(model-to-world) model koordinatları için dünya koordinatlarına yönelik bir dönüştürme matrisidir ve Dünya dönüşüm matrisi olarak da bilinir. Bu, ilkel tarafından sağlanır.
• M(world-to-view), Görünüm dönüştürme matrisiolarak da bilinen koordinatları görüntülemek için dünya koordinatlarına yönelik bir dönüştürme matrisidir.
  • Bu, kameranın görünüm matrisi tarafından sağlanır. Kameranın konumuyla birlikte görünüm vektörleriyle tanımlanır (doğrudan kameradan sahnenin içine işaret eden vektöre bakar ve yukarı doğru dik olan vektörü arar).
  • Örnek oyunda m_viewMatrix görünüm dönüştürme matrisidir ve Camera::SetViewParams kullanılarak hesaplanır.
• M(view-to-device), görünüm koordinatlarından cihaz koordinatlarına dönüştürme için kullanılan, Projeksiyon dönüştürme matrisiolarak da bilinen bir dönüştürme matrisidir.
  • Bu, kameranın projeksiyonu tarafından sağlanır. Son sahnede bu alanın ne kadarının gerçekten görünür olduğu hakkında bilgi sağlar. Görüş alanı (FoV), en boy oranı ve kırpma düzlemleri projeksiyon dönüştürme matrisini tanımlar.
  • Örnek oyunda m_projectionMatrix , Camera::SetProjParams kullanılarak hesaplanan projeksiyon koordinatlarına dönüştürmeyi tanımlar (Stereo projeksiyon için iki projeksiyon matrisi kullanırsınız( her gözün görünümü için bir tane).

VertexShader.hlsl'daki gölgelendirici kodu, sabit arabelleklerden gelen bu vektör ve matrislerle yüklenir ve her köşe için bu dönüşümü uygular.

Eşgüdümlü dönüştürme

Direct3D, 3B model koordinatlarınızı piksel koordinatlarına (ekran alanı) dönüştürmek için üç dönüştürme kullanır. Bu dönüşümler dünya dönüşümü, görünüm dönüşümü ve projeksiyon dönüşümü olarak adlandırılır. Daha fazla bilgi için bkz. Dönüştürmeye genel bakış.

Dünya dönüşüm matrisi

Dünya dönüşümü, köşelerin modelin yerel kaynağına göre tanımlandığı model alanından, köşelerin sahnedeki tüm nesneler için ortak olan bir kaynakla göreli olarak tanımlandığı dünya uzayı koordinatlarını değiştirir. Özünde, dünya dönüşümü dünyaya bir model yerleştirir; bu nedenle adı. Daha fazla bilgi için bkz . Dünya dönüşümü.

Dönüştürme matrisi görüntüleme

Görünüm dönüşümü, görüntüleyiciyi dünya uzayında bulur ve köşeleri kamera alanına dönüştürür. Kamera alanında, kamera veya görüntüleyici çıkış noktasındadır ve pozitif z yönüne bakar. Daha fazla bilgi için Görünüm dönüştürme'a gidin.

Projeksiyon dönüştürme matrisi

Projeksiyon dönüşümü, görüntüleme frustumunu küboid şekle dönüştürür. Görüş hacmi, görünüm penceresi kamerasına göre konumlandırılmış bir sahnedeki 3B hacimdir. Görünüm penceresi, 3B bir sahnenin 2B düzlemine yansıtıldığı dikdörtgendir. Daha fazla bilgi için bkz. görünüm alanları ve kırpma

Görüntüleme frustumunun yakın ucu uzak uçtan daha küçük olduğundan, bu, kameraya yakın nesneleri genişletme etkisine sahiptir; Perspektif bu şekilde sahneye uygulanır. Böylece oyuncuya daha yakın olan nesneler daha büyük görünür; daha uzaktaki nesneler daha küçük görünür.

Matematiksel olarak projeksiyon dönüşümü genellikle hem ölçek hem de perspektif projeksiyonu olan bir matristir. Bir kameranın lensi gibi çalışır. Daha fazla bilgi için Projeksyon Dönüşümükısmına bakınız.

Örnekleyici Durumu

Örnekleyici durumu doku adresleme modları, filtreleme ve ayrıntı düzeyi kullanılarak doku verilerinin nasıl örnekleneceğini belirler. Her bir doku pikseli (veya texel) dokudan okunduğunda örnekleme yapılır.

Doku, bir dizi doku pikseli içerir. Her bir texel'in konumu, (u,v)ile gösterilir, burada u genişlik ve v yükseklik olup, doku genişliği ve yüksekliğine göre 0 ile 1 arasında eşlenir. Sonuçta elde edilen doku koordinatları, bir doku örneklenirken bir texeli adreslemek için kullanılır.

Doku koordinatları 0'dan küçük veya 1'den büyük olduğunda, doku adresleme modu doku koordinatının bir texel konumunu nasıl adresleyeceğini tanımlar. Örneğin , TextureAddressMode.Clamp kullanılırken, 0-1 aralığının dışındaki herhangi bir koordinat, örneklemeden önce maksimum 1 değerine ve en az 0 değerine kelepçelenir.

Doku çokgen için çok büyük veya çok küçükse, doku alana sığacak şekilde filtrelenmiş olur. Büyütme filtresi bir dokuyu büyütür, küçültme filtresi dokuyu daha küçük bir alana sığacak şekilde azaltır. Doku büyütme, bulanık bir görüntü oluşturan bir veya daha fazla adres için örnek texel'i yineler. Birden fazla texel değerinin tek bir değerde birleştirilmesi gerektiğinden, doku küçültülmesi daha karmaşıktır. Bu, doku verilerine bağlı olarak iz düşümüne veya pürüzlü kenarlara neden olabilir. Küçültme için en popüler yaklaşım, mipmap kullanmaktır. Mipmap, çok seviyeli bir doku. Her seviyenin boyutu, önceki seviyeye göre 2 kat daha küçük olup, en küçük olarak 1x1 dokuya kadar inen bir ölçüde küçülür. Küçültme kullanıldığında, oyun işleme zamanında gereken boyuta en yakın mipmap düzeyini seçer.

BasicLoader sınıfı

BasicLoader , disk üzerindeki dosyalardan gölgelendiriciler, dokular ve ağlar yükleme desteği sağlayan basit bir yükleyici sınıfıdır. Hem zaman uyumlu hem de zaman uyumsuz yöntemler sağlar. Bu örnek oyunda dosyalar BasicLoader.h/.cppYardımcı Programlar klasöründe bulunur.

Daha fazla bilgi için bkz. Temel Yükleyici.