Compartir a través de

Dibujar en la pantalla

  • Artículo

API importantes

Por último, portamos el código que dibuja el cubo giratorio a la pantalla.

En OpenGL ES 2.0, el contexto de dibujo se define como un tipo EGLContext, que contiene los parámetros de ventana y superficie, así como los recursos necesarios para dibujar en los destinos de representación que se usarán para componer la imagen final mostrada en la ventana. Use este contexto para configurar los recursos gráficos para mostrar correctamente los resultados de la canalización del sombreador en la pantalla. Uno de los recursos principales es el "búfer de reserva" (o "objeto de búfer de marco") que contiene los destinos de representación compuestos finales, listos para su presentación en la pantalla.

Con Direct3D, el proceso de configuración de los recursos gráficos para dibujar en la pantalla es más pausado y requiere bastantes API más. (Sin embargo, una plantilla de Microsoft Visual Studio Direct3D puede simplificar significativamente este proceso). Para obtener un contexto (denominado contexto de dispositivo Direct3D), primero debe obtener un objeto ID3D11Device1 y usarlo para crear y configurar un objeto ID3D11DeviceContext1. Estos dos objetos se usan junto con para configurar los recursos específicos que necesita para dibujar en la pantalla.

En resumen, las API DXGI contienen principalmente API para administrar recursos que pertenecen directamente al adaptador de gráficos y Direct3D contiene las API que permiten interactuar entre la GPU y el programa principal que se ejecuta en la CPU.

Para los fines de la comparación en este ejemplo, estos son los tipos pertinentes de cada API:

  • ID3D11Device1: proporciona una representación virtual del dispositivo gráfico y sus recursos.
  • ID3D11DeviceContext1: proporciona la interfaz para configurar búferes y emitir comandos de representación.
  • IDXGISwapChain1: la cadena de intercambio es análoga al búfer de reserva en OpenGL ES 2.0. Es la región de memoria del adaptador de gráficos que contiene las imágenes representadas finales para mostrar. Se denomina "cadena de intercambio" porque tiene varios búferes que se pueden escribir en y "intercambiar" para presentar la última representación en la pantalla.
  • ID3D11RenderTargetView: contiene el búfer de mapa de bits 2D en el que se dibuja el contexto del dispositivo Direct3D y que presenta la cadena de intercambio. Al igual que con OpenGL ES 2.0, puede tener varios destinos de representación, algunos de los cuales no están enlazados a la cadena de intercambio, pero se usan para técnicas de sombreado de varios pasos.

En la plantilla, el objeto de representador contiene los siguientes campos:

Direct3D 11: declaraciones de contexto de dispositivo y dispositivo

Platform::Agile<Windows::UI::Core::CoreWindow>       m_window;

Microsoft::WRL::ComPtr<ID3D11Device1>                m_d3dDevice;
Microsoft::WRL::ComPtr<ID3D11DeviceContext1>          m_d3dContext;
Microsoft::WRL::ComPtr<IDXGISwapChain1>                      m_swapChainCoreWindow;
Microsoft::WRL::ComPtr<ID3D11RenderTargetView>          m_d3dRenderTargetViewWin;

Aquí se muestra cómo se configura el búfer de reserva como destino de representación y se proporciona a la cadena de intercambio.

ComPtr<ID3D11Texture2D> backBuffer;
m_swapChainCoreWindow->GetBuffer(0, IID_PPV_ARGS(backBuffer));
m_d3dDevice->CreateRenderTargetView(
  backBuffer.Get(),
  nullptr,
  &m_d3dRenderTargetViewWin);

El tiempo de ejecución de Direct3D crea implícitamente un IDXGISurface1 para id3D11Texture2D, que representa la textura como un "búfer de reserva" que la cadena de intercambio puede usar para mostrarse.

La inicialización y configuración del contexto del dispositivo y el dispositivo Direct3D, así como los destinos de representación, se pueden encontrar en los métodos CreateDeviceResources personalizados y CreateWindowSizeDependentResources en la plantilla direct3D.

Para obtener más información sobre el contexto del dispositivo Direct3D en relación con EGL y el tipo EGLContext, lea El código EGL de puerto a DXGI y Direct3D.

Instrucciones

Paso 1: Representar la escena y mostrarla

Después de actualizar los datos del cubo (en este caso, girando ligeramente alrededor del eje Y), el método Render establece la ventanilla en las dimensiones del contexto de dibujo (un EGLContext). Este contexto contiene el búfer de colores que se mostrará en la superficie de la ventana (un EGLSurface), mediante la pantalla configurada (EGLDisplay). En este momento, el ejemplo actualiza los atributos de datos de vértices, vuelve a enlazar el búfer de índices, dibuja el cubo y intercambia el búfer de color dibujado por la canalización de sombreado a la superficie de visualización.

OpenGL ES 2.0: Representación de un marco para mostrar

void Render(GraphicsContext *drawContext)
{
  Renderer *renderer = drawContext->renderer;

  int loc;
   
  // Set the viewport
  glViewport ( 0, 0, drawContext->width, drawContext->height );
   
   
  // Clear the color buffer
  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  glEnable(GL_DEPTH_TEST);


  // Use the program object
  glUseProgram (renderer->programObject);

  // Load the a_position attribute with the vertex position portion of a vertex buffer element
  loc = glGetAttribLocation(renderer->programObject, "a_position");
  glVertexAttribPointer(loc, 3, GL_FLOAT, GL_FALSE, 
      sizeof(Vertex), 0);
  glEnableVertexAttribArray(loc);

  // Load the a_color attribute with the color position portion of a vertex buffer element
  loc = glGetAttribLocation(renderer->programObject, "a_color");
  glVertexAttribPointer(loc, 4, GL_FLOAT, GL_FALSE, 
      sizeof(Vertex), (GLvoid*) (sizeof(float) * 3));
  glEnableVertexAttribArray(loc);

  // Bind the index buffer
  glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, renderer->indexBuffer);

  // Load the MVP matrix
  glUniformMatrix4fv(renderer->mvpLoc, 1, GL_FALSE, (GLfloat*) &renderer->mvpMatrix.m[0][0]);

  // Draw the cube
  glDrawElements(GL_TRIANGLES, renderer->numIndices, GL_UNSIGNED_INT, 0);

  eglSwapBuffers(drawContext->eglDisplay, drawContext->eglSurface);
}

En Direct3D 11, el proceso es muy similar. (Suponiendo que usa la ventanilla y la configuración de destino de representación de la plantilla de Direct3D.

Direct3D 11: Representación de un marco para mostrar

void RenderObject::Render()
{
  // ...

  // Only update shader resources that have changed since the last frame.
  m_d3dContext->UpdateSubresource(
    m_constantBuffer.Get(),
    0,
    NULL,
    &m_constantBufferData,
    0,
    0);

  // Set up the IA stage corresponding to the current draw operation.
  UINT stride = sizeof(VertexPositionColor);
  UINT offset = 0;
  m_d3dContext->IASetVertexBuffers(
    0,
    1,
    m_vertexBuffer.GetAddressOf(),
    &stride,
    &offset);

  m_d3dContext->IASetIndexBuffer(
    m_indexBuffer.Get(),
    DXGI_FORMAT_R16_UINT,
    0);

  m_d3dContext->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
  m_d3dContext->IASetInputLayout(m_inputLayout.Get());

  // Set up the vertex shader corresponding to the current draw operation.
  m_d3dContext->VSSetShader(
    m_vertexShader.Get(),
    nullptr,
    0);

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

  // Set up the pixel shader corresponding to the current draw operation.
  m_d3dContext->PSSetShader(
    m_pixelShader.Get(),
    nullptr,
    0);

  m_d3dContext->DrawIndexed(
    m_indexCount,
    0,
    0);

    // ...

  m_swapChainCoreWindow->Present1(1, 0, &parameters);
}

Una vez que se llama a IDXGISwapChain1::P resent1 , el fotograma se genera en la pantalla configurada.

Paso anterior

Puerto de GLSL

Comentarios

En este ejemplo se analiza gran parte de la complejidad que entra en la configuración de recursos de dispositivo, especialmente para aplicaciones directX de Plataforma universal de Windows (UWP). Se recomienda revisar el código de plantilla completo, especialmente las partes que realizan la configuración y administración de recursos de dispositivo y ventana. Las aplicaciones para UWP tienen que admitir eventos de rotación, así como eventos de suspensión y reanudación, y la plantilla muestra los procedimientos recomendados para controlar la pérdida de una interfaz o un cambio en los parámetros de visualización.