Introduction


DirectX

DirectX is Microsoft technology to render 3D graphics. You can use DirectX to create games or high-performance multimedia applications. The DirectX runtime library is a program that allows running DirectX programs. All computers running Windows 8 or later have a version of DirectX already installed. DirectX uses the Common Object Model (COM).
DirectX es una tecnología de Microsoft para dibujar gráficos en 3D. Usted puede usar DirectX para crear juegos o aplicaciones multimedia de alto desempeño. La librería de ejecución de DirectX es un programa que permite correr programas de DirectX. Todas las computadoras corriendo Windows 8 o posterior tienen una versión de DirectX instalada. DirectX utiliza el Model de Objetos comunes (COM).DEFINITON DirectX Diagnostic ToolIt is an executable program (dxdiag.exe) that provides diagnostic information about DirectX. You can run this tool directly from the Windows start button or from the MS DOS prompt (cmd.exe).
Es un programa ejecutable (dxdiag.exe) que proporciona informa de diagnostico sobre DirectX. Usted puede ejecutar esta herramienta directamente desde el botón de inicio de Windows o desde la ventana de MS DOS (cmd.exe)

DiagnosticTool

DirectX Caps Viewer

This tool provides detail information about your Graphics card and DirectX support. To open the viewer, you must locate and execute dxcapsviewer.exe. You can open a CMD window (MSDOS prompt) and use dir dxcapsviewer.exe /s to find this file. Do not forget to run the dir command at the root folder C:\.
Esta herramienta proporciona información con detalles acerca de su tarjeta de Gráficos y el suporte de DirectX. Para abrir el visor, usted debe ubicar y ejecutar dxcapsviewer.exe. Use puede abrir una ventana de CMD (MSDOS prompt) y usar dir dxcapsviewer.exe /s para encontrar el archivo. No se olvide de correr el comando dir en la carpeta raíz C:\.

MSDOS: cmd.exe
C:\>dir dxcapsviewer.exe /s
 Volume in drive C is TI106240W0D
 Volume Serial Number is 18D4-6275

 Directory of C:\Program Files (x86)\Windows Kits\10\bin\10.0.15063.0\arm

10/01/2017  08:01 AM           168,496 dxcapsviewer.exe
               1 File(s)        168,496 bytes

 Directory of C:\Program Files (x86)\Windows Kits\10\bin\10.0.15063.0\arm64

09/30/2017  12:27 PM           192,560 dxcapsviewer.exe
               1 File(s)        192,560 bytes

 Directory of C:\Program Files (x86)\Windows Kits\10\bin\10.0.15063.0\x64

09/30/2017  02:17 AM           190,912 dxcapsviewer.exe
               1 File(s)        190,912 bytes

 Directory of C:\Program Files (x86)\Windows Kits\10\bin\10.0.15063.0\x86

09/29/2017  10:11 PM           173,368 dxcapsviewer.exe
               1 File(s)        173,368 bytes

 Directory of C:\Program Files (x86)\Windows Kits\10\bin\10.0.17134.0\arm

04/20/2018  06:32 PM           172,592 dxcapsviewer.exe
               1 File(s)        172,592 bytes

 Directory of C:\Program Files (x86)\Windows Kits\10\bin\10.0.17134.0\arm64

04/20/2018  08:56 PM           193,072 dxcapsviewer.exe
               1 File(s)        193,072 bytes

 Directory of C:\Program Files (x86)\Windows Kits\10\bin\10.0.17134.0\x64

04/20/2018  09:29 AM           195,336 dxcapsviewer.exe
               1 File(s)        195,336 bytes

 Directory of C:\Program Files (x86)\Windows Kits\10\bin\10.0.17134.0\x86

04/20/2018  02:05 AM           173,320 dxcapsviewer.exe
               1 File(s)        173,320 bytes

 Directory of C:\Program Files (x86)\Windows Kits\10\bin\10.0.17763.0\arm

10/23/2018  08:01 AM           172,728 dxcapsviewer.exe
               1 File(s)        172,728 bytes

 Directory of C:\Program Files (x86)\Windows Kits\10\bin\10.0.17763.0\arm64

10/23/2018  12:50 PM           193,696 dxcapsviewer.exe
               1 File(s)        193,696 bytes


DxCapsViewer

Direct3D

It is a low-level API that can be used to draw triangles, lines or points. Direct3D can also be used for highly parallel operations on the GPU. You need to include some version of #include <d3d.h> and link with the corresponding version of "d3d.lib" to use Direct3D (see code below). Typical versions are: 9, 10, 11 and 12. Direct3D includes
  1. Logical color
  2. Depth buffer
  3. Clipping
  4. Alpha blending
  5. Drawing: points, lines and triangles
  6. Texture
  7. Fogging
  8. Shading (GPU processing of vertexex and pixels

Es una API de bajo nivel que puede ser usada para dibujar triángulos, líneas y puntos. Direct3D puede también ser usada para operación altamente paralelas en el GPU. Usted necesita incluir alguna versión de #include <d3d.h> y enlazar con versión respectiva de "d3d.lib" para usar Direct3D (vea el código de abajo). Las versiones típicas son: 9, 10, 11 y 12. Direct3D incluye:
  1. Colores lógicos
  2. Buffer de profundidad
  3. Recorte fuera de visión
  4. Transparencia
  5. Dibujar: puntos, líneas y triángulos
  6. Texturas
  7. Niebla
  8. Shading (procesamiento en del GPU de vértices y pixeles

stdafx.h
...
//_______________________________________________ DirectX 9
#include <d3d9.h>
#include <DirectXMath.h>
#pragma comment(lib, "d3d9.lib")
#pragma comment(lib, "dxguid.lib")


stdafx.h
...
//_______________________________________________ DirectX 10
#include <d3d10.h>
#include <DirectXMath.h>
#include <D3Dcompiler.h>
#pragma comment(lib, "d3d10.lib")
#pragma comment(lib, "dxguid.lib")
#pragma comment(lib, "dxgi.lib")
#pragma comment(lib, "d3dcompiler.lib")


stdafx.h
...
//_______________________________________________ DirectX 11
#include <d3d11.h>
#include <DirectXMath.h>
#include <D3Dcompiler.h>
#pragma comment(lib, "d3d11.lib")
//#pragma comment(lib, "dxguid.lib")
#pragma comment(lib, "dxgi.lib")
#pragma comment(lib, "d3dcompiler.lib")


DirectXMath

This API provides SIMD-friendly C++ types and functions to perform common linear algebra operations and math operations that are typically used on DirectX applications. You need to include #include <DirectXMath.h> to use DirectXMath as shown in the previous code.
Es una API que proporciona tipos de datos C++ SIMD compatible y funciones para realizar operaciones comunes de algebra lineal y operaciones matemáticas que son usadas típicamente en aplicaciones DirectX. Usted necesita incluir #include <DirectXMath.h> para usar DirectXMath como se muestra en el código previo.

DirecXMath Functions

  1. XM_PI
  2. XM_1DIVPI
  3. XMConvertToRadians
  4. XMConvertToDegrees
  5. BoundingBox::Intersects(XMVECTOR, XMVECTOR, float&)
  6. BoundingBox::CreateFromPoints
  7. BoundingSphere::CreateFromPoints
  8. BoundingSphere::Intersects(XMVECTOR, XMVECTOR, float&)
  9. TriangleTests::Intersects
  10. XMConvertFloatToHalfStream
  11. XMConvertHalfToFloatStream
  12. XMVector2Length or XMVector2LengthEst
  13. XMVector2LengthSq
  14. XMVector2Dot
  15. XMVector2Cross
  16. XMVectorAdd
  17. XMVectorSubtract
  18. XMVectorMin
  19. XMVectorMax
  20. XMVectorScale
  21. XMVectorLerp or XMVectorLerpV
  22. XMVector2Normalize or XMVector2NormalizeEst
  23. XMVectorHermite or XMVectorHermiteV
  24. XMVectorCatmullRom or XMVectorCatmullRomV
  25. XMVectorBaryCentric or XMVectorBaryCentricV
  26. XMVector2Transform
  27. XMVector2TransformCoord
  28. XMVector2TransformNormal
  29. XMVector2TransformStream
  30. XMVector2TransformCoordStream
  31. XMVector2TransformNormalStream
  32. XMVector3Length or XMVector3LengthEst
  33. XMVector3LengthSq
  34. XMVector3Dot
  35. XMVector3Cross
  36. XMVectorAdd
  37. XMVectorSubtract
  38. XMVectorLerp or XMVectorLerpV
  39. XMVector3Normalize or XMVector3NormalizeEst
  40. XMVectorHermite or XMVectorHermiteV
  41. XMVectorCatmullRom or XMVectorCatmullRomV
  42. XMVectorBaryCentric or XMVectorBaryCentricV
  43. XMVector3Transform
  44. XMVector3TransformCoord
  45. XMVector3TransformNormal
  46. XMVector3TransformStream
  47. XMVector3TransformCoordStream
  48. XMVector3TransformNormalStream
  49. XMVector3Project
  50. XMVector3Unproject
  51. XMVector3ProjectStream
  52. XMVector3UnprojectStream
  53. XMVector4Length or XMVector4LengthEst
  54. XMVector4LengthSq
  55. XMVector4Dot
  56. XMVectorScale
  57. XMVectorLerp or XMVectorLerpV
  58. XMVector4Cross
  59. XMVector4Normalize or XMVector4NormalizeEst
  60. XMVectorHermite or XMVectorHermiteV
  61. XMVectorCatmullRom or XMVectorCatmullRomV
  62. XMVectorBaryCentric or XMVectorBaryCentricV
  63. XMVector4Transform
  64. XMVector4TransformStream
  65. XMMatrixIdentity
  66. XMMatrixDeterminant
  67. XMMatrixDecompose
  68. XMMatrixTranspose
  69. XMMatrixMultiply
  70. XMMatrixMultiplyTranspose
  71. XMMatrixInverse
  72. XMMatrixScaling
  73. XMMatrixTranslation
  74. XMMatrixRotationX
  75. XMMatrixRotationY
  76. XMMatrixRotationZ
  77. XMMatrixRotationAxis
  78. XMMatrixRotationQuaternion
  79. XMMatrixRotationRollPitchYaw
  80. XMMatrixTransformation
  81. XMMatrixTransformation2D
  82. XMMatrixAffineTransformation
  83. XMMatrixAffineTransformation2D
  84. XMMatrixLookAtRH
  85. XMMatrixLookAtLH
  86. XMMatrixPerspectiveRH
  87. XMMatrixPerspectiveLH
  88. XMMatrixPerspectiveFovRH
  89. XMMatrixPerspectiveFovLH
  90. XMMatrixPerspectiveOffCenterRH
  91. XMMatrixPerspectiveOffCenterLH
  92. XMMatrixOrthographicRH
  93. XMMatrixOrthographicLH
  94. XMMatrixOrthographicOffCenterRH
  95. XMMatrixOrthographicOffCenterLH
  96. XMMatrixShadow
  97. XMMatrixReflect
  98. XMQuaternionLength
  99. XMQuaternionLengthSq
  100. XMQuaternionDot
  101. XMQuaternionIdentity
  102. XMQuaternionIsIdentity
  103. XMQuaternionConjugate
  104. XMQuaternionToAxisAngle
  105. XMQuaternionRotationMatrix
  106. XMQuaternionRotationAxis
  107. XMQuaternionRotationRollPitchYaw
  108. XMQuaternionMultiply
  109. XMQuaternionNormalize or XMQuaternionNormalizeEst
  110. XMQuaternionInverse
  111. XMQuaternionLn
  112. XMQuaternionExp
  113. XMQuaternionSlerp or XMQuaternionSlerpV
  114. XMQuaternionSquad or XMQuaternionSquadV
  115. XMQuaternionSquadSetup
  116. XMQuaternionBaryCentric or XMQuaternionBaryCentricV
  117. XMPlaneDot
  118. XMPlaneDotCoord
  119. XMPlaneDotNormal
  120. XMVectorScale
  121. XMPlaneNormalize or XMPlaneNormalizeEst
  122. XMPlaneIntersectLine
  123. XMPlaneFromPointNormal
  124. XMPlaneFromPoints
  125. XMPlaneTransform

Back Buffer

It is a part of Graphic Processing Unit (GPU) memory where pixels can be drawn. Eventually, the back buffer is flipped and sent to the screen on a refresh signal. A set of swappable buffers than can be flipped using multiple buffering strategies is called a swap chain.
Es una parte de la memoria de la Unidad de Procesamiento Gráfico (GPU) dónde los pixeles pueden ser dibujados. Eventualmente, se le da la vuelta al back buffer y este se envía a la pantalla cuando se refresca la señal. Un conjunto de buffers intercambiables que pueden ser enviado usando varias estrategias de almacenamiento es llamado un "swap chain".

Microsoft High Level Shading Language

It is a language to create a small piece of code that is executed in the GPU.
  1. Data types bool, uint, dword, half, int, float, float1, float2, float3, float4, double, vector, matrix
  2. Flow controlfor, if, switch, while, do, break, continue and discard
  3. Functions abort, abs, acos, asin, atan, atan2, ceil, clamp, clip, cos, cosh, cross, ddx, ddy, degrees, determinant, distance, dot, dst, exp, exp2, floor, fma, fmod, frac, frexp, fwith, ...
For a complete reference see: https://docs.microsoft.com/en-us/windows/desktop/direct3dhlsl/dx-graphics-hlsl-reference
Es un lenguaje para crear pequeñas piezas de código que se ejecutan en el GPU.
  1. Tipos de datos bool, uint, dword, half, int, float, float1, float2, float3, float4, double, vector, matrix
  2. Flujo de controlfor, if, switch, while, do, break, continue and discard
  3. Funciones abort, abs, acos, asin, atan, atan2, ceil, clamp, clip, cos, cosh, cross, ddx, ddy, degrees, determinant, distance, dot, dst, exp, exp2, floor, fma, fmod, frac, frexp, fwith, ...
Por una lista completa vea: https://docs.microsoft.com/en-us/windows/desktop/direct3dhlsl/dx-graphics-hlsl-reference

Shader

It is a small, low-level program. In DirectX, shaders are written in Microsoft High Level Shader (HSLS) language. These programs are compiled when the rest of the program is compiled producing a CSO file (*.cso). They are executed at specific stages in the graphics pipeline. A shader can execute floating point mathematical operations very fast. Shaders are designed to be executed in the GPU. More information about shaders can be found at https://docs.microsoft.com/en-us/windows/desktop/direct3dgetstarted/work-with-shaders-and-shader-resources.
Es un pequeño programa de bajo nivel. En DirectX, los shaders están escritos en el lenguaje Microsoft High Level Shader (HSLS). Estos programas se compilan cuando el resto del programa se compila produciendo un archivo CSO (*.cso). Estos se ejecutan en etapas específicas en la pipeline gráfica. Un shader puede ejecutar muy rápido operaciones matemáticas de punto flotante. Los shaders diseñados para ser ejecutados en la GPU. Más información sobre los shaders se puede encontrar en https://docs.microsoft.com/en-us/windows/desktop/direct3dgetstarted/work-with-shaders-and-shader-resources.

DirectX Pipeline

There are several stages that the data goes through in DirectX before it is ready to be shown in the screen. The figure below show the DirectX 10 and DirectX 11 pipeline. The green boxes represent those stages that can include a small program written in HLSL.
Hay varias etapas por las cuales los datos tienen que pasar en DirectX antes de estar listos para ser mostrados en la pantalla. La figura de abajo muestra la pipeline de DirectX 10 y DirectX 11. Las cajas verdes representan aquellas etapas que pueden incluir un pequeño programa escrito en HLSL.

Pipeline

Vertex Shader

It is a program that is executed for each vertex in a vertex buffer. The source code is typically stored in a HLSL file (*.hlsl). A vertex shader can provide realistic effects in 3D drawing such different types of lighting. The figure below shows how to move data from the CPU to the vertex shader in the GPU. The vertex shader program is executed for each vertex. In the example below, three matrixes are passed to the shader, if you need only the product of the three matrices, you must pass only the product of the matrices, otherwise the product will be executed for each vertex.
Este es un programa que se ejecuta por cada vértice en un vertex buffer. El código fuente es típicamente almacenado en un archivo HLSL (*.hlsl). Un vertex shader puede proporcionar efectos realísticos en el dibujo tal cómo distintos tipos de iluminación. La figura de abajo muestra cómo mover datos desde el CPU al vertex shader en el GPU. El programa de vertex shader se ejecuta por cada vértice. En el ejemplo de abajo, tres matrices se pasan al shader, si usted sólo necesita el producto de las tres matrices, usted debe pasar sólo el producto de las matrices, de otro modo el producto se ejecutará por cada vértice.

MoveVertexShader

Pixel Shader

It is a program that is executed for each pixel in a render target. The source code is typically stored in a HLSL file (*.hlsl). As this program is executed for each pixel, the code must be very small and fast. A pixel shader provides a method to produce light effects that can greatly improve the appearance of 3D objects. The figure below shows how to move data from the CPU to the pixel shader in the GPU. The pixel shader is executed for each pixel, you must perform only the minimum necessary operations here.
Este es un programa que se ejecuta por cada pixel en una objetivo de renderización. El código fuente es típicamente almacenado en un archivo HLSL (*.hlsl). Como este programa se ejecuta por cada pixel, el código debe ser muy pequeño y rápido. Un pixel shader proporciona un método para producir efecto de luz que pueden mejorar en forma considerable la apariencia de los objetos 3D. La figura de abajo muestra cómo mover datos desde el CPU al pixel shader in the GPU. El shader de pixeles es ejecutado por cada pixel, usted debe realizar sólo las mínimas operaciones necesarias aquí.

MovePixelShader

Problem 1
Create a DirectX project using Wintempla called BasicX as shown to test Direct3D API. Compile and run the program. The program will display a dark blue screen. If you are using Microsoft Visual Studio 2015, be sure to compile the program in 64 bits, x64.
Cree un proyecto de DirectX usando Wintempla llamado BasicX as shown para probar la API Direct3D. Compile y corra el programa. El programa mostrará una pantalla azul oscuro. Si usted está usando Microsoft Visual Studio 2015, asegúrese de compilar el programa en 64 bits, x64.

BasicXRun1

Step A
Open Solution Explorer and take a look to the project structure. You will find four main folders: Header Files, Resource Files, Shading Language and Source Files. Wintempla generates two files with a set of classes to simplify the use of DirectX: DX11.h and DX11.cpp. You should inspect these two files.
Abra el Solution Explorer y de le una vista a la estructura del proyecto. Usted encontrará cuatro carpetas principales: Header Files, Resource Files, Shading Language and Source Files. Wintempla genera dos archivos con un conjunto de clases para simplificar el uso de DirectX: DX11.h y DX11.cpp. Usted debería inspeccionar estos dos archivos.

SolutionExplorer

The main class

The main class is called BasicX, this class is implemented in the files: BasicX.h and BasicX.cpp. The RenderScene function is where the 3D rendering occurs.
La clase principal se llama BasicX, esta clase está implementada en los archivos: BasicX.h y BasicX.cpp . La función RenderScene es donde el dibujado en 3D ocurre.

Window_Open

Please inspect the Window_Open function of your project. The function InitDevice functions is called to setup many smart pointers required for DirectX. Then, some typical shaders are created.
Por favor inspeccione la función Window_Open de su proyecto. La función InitDevice es llamada para configurar varios punteros inteligentes requeridos por DirectX. Entonces, algunos shaders comunes son creados.

BasicX.cpp
void BasicX::Window_Open(Win::Event& e)
{
     const wchar_t* error = NULL;
     //________________________________________________________________ 1. Initialize device (D3D11_CULL_NONE, D3D11_CULL_FRONT)
     if (InitDevice(D3D11_CULL_BACK, 1, 0) == false) return this->Destroy();
     //________________________________________________________________ 2. Create shaders for objects with color
     if (colorShader.CreateFromResource(device, hWnd, IDSL_PSCOLOR, "main", IDSL_VSCOLOR, "main", hInstance) == false) return this->Destroy();
     if (colorALShader.CreateFromResource(device, hWnd, IDSL_PSCOLORAMBI, "main", IDSL_VSCOLORAMBI, "main", hInstance) == false) return this->Destroy();
     if (colorDLShader.CreateFromResource(device, hWnd, IDSL_PSCOLORDIFF, "main", IDSL_VSCOLORDIFF, "main", hInstance) == false) return this->Destroy();
     if (colorSLShader.CreateFromResource(device, hWnd, IDSL_PSCOLORSPEC, "main", IDSL_VSCOLORSPEC, "main", hInstance) == false) return this->Destroy();
     //________________________________________________________________ 3. Create shaders for objects with texture
     if (textuShader.CreateFromResource(device, hWnd, IDSL_PSTEXTU, "main", IDSL_VSTEXTU, "main", hInstance) == false) return this->Destroy();
     if (textuALShader.CreateFromResource(device, hWnd, IDSL_PSTEXTUAMBI, "main", IDSL_VSTEXTUAMBI, "main", hInstance) == false) return this->Destroy();
     if (textuDLShader.CreateFromResource(device, hWnd, IDSL_PSTEXTUDIFF, "main", IDSL_VSTEXTUDIFF, "main", hInstance) == false) return this->Destroy();
     if (textuSLShader.CreateFromResource(device, hWnd, IDSL_PSTEXTUSPEC, "main", IDSL_VSTEXTUSPEC, "main", hInstance) == false) return this->Destroy();
     //________________________________________________________________ 2. Setup the camera
     camera.position.x = 0.0f;
     camera.position.y = 0.0f;
     camera.position.z = -5.0f;
     //
     camera.lookAt.x = 0.0f;
     camera.lookAt.y = 0.0f;
     camera.lookAt.z = 1.0f;
     //
     camera.SetViewSize(modeDesc.Width, modeDesc.Height);
     //__________________________________________________________ 3. Triangle Setup
}


RenderScene

The RenderScene function is periodically called to draw the window of the DirectX application. Typically, this function must be called 60 times per second. However, it can be called less than 60 times per second, if the computer does not have a graphics card and the rendering of the objects is demanding. The function begins by painting the window by calling ClearRenderTargetView. You may use this function to set the color of the window. Finally, to display the scene on the screen, Present is used. You must return true to keep running the application, or return false to close the application.
La función RenderScene es llamada periódicamente para dibujar la ventana de la aplicación de DirectX. Típicamente, esta función debe llamarse 60 veces por segundo. Sin embargo, esta puede ser llamada menos de 60 veces por segundo, si la computadora no tiene una tarjeta de gráficos y el dibujado de los objetos es demandante. La función comienza pintando la ventana llamando ClearRenderTargetView. Usted debe usar esta función para fijar el color de la ventana. Finalmente, para mostrar la escena en la pantalla se usa Present(). Usted debe regresar true para que la aplicación siga corriendo, o puede regresar false para cerrar la aplicación.

Example.cpp
void Example::RenderScene()
{
     //_________________________________________ 1. Clear backbuffer
     FLOAT bgColor[4];
     bgColor[0] = 0.0f; // RED
     bgColor[1] = 0.0f; // GREEN
     bgColor[2] = 0.2f; // BLUE
     bgColor[3] = 1.0f; // ALPHA
     //
     device->ClearRenderTargetView(renderTargetView, bgColor);
     device->ClearDepthStencilView(depthStencilView, D3D10_CLEAR_DEPTH, 1.0f, 0);
     camera.Render();
     //_________________________________________ 2. Render objects

     //_________________________________________ 3. Present the backbuffer to the screen
     swapChain->Present(1, 0);
}


Vertex

A vertex (plural vertices) is a data structure that describes a point in 2D or 3D space. DirectX uses vertices to describe complex 2D or 3D objects.
Un vertex (vértices en plural) es una estructura de datos que describe un punto en dos o tres dimensiones. DirectX usa los vértices para describir objetos completos en 2D o 3D.

Tip
DirectX and OpenGL and graphics libraries:
  • They are very fast., faster than GDI or GDI+.
  • They are used in graphics simulation and video games.
  • The program runs continuously, executing a function to render the scene.
  • They handle surfaces, lights, shadows, perspective, and transparency.
  • The programmer must have knowledge of: Physics, Mathematics and matrices to create programs that simulate real life events
  • The programmer must know how to program time and frames per second.
  • A program that uses these technologies can be implemented as a state machine to manage the several stages of the game, such as: intro, levels, etc.
  • The programmer must use the POO to simplify the function that renders the scene.

DirectX y OpenGL son librerías de gráficos:
  • Son muy rápidas, más rápidas que GDI o GDI+.
  • Son usadas en simulaciones gráficas y video juegos.
  • El programa se ejecuta en forma continua, ejecutando la función que dibuja la escena.
  • Manejan en forma automática, superficies, luces, sombras, perspectiva, y transparencia.
  • El programador debe tener conocimientos de: Física, Matemáticas y matrices para crear programas que simulen eventos de la vida real
  • Se requiere conocimiento del manejo del tiempo y las frames por segundo
  • Un programa que usa estas tecnologías puede ser implementado como una máquina de estados para manejar los diversos estados del juego, tales como: introducción, niveles, etc.
  • El programador debe usar la POO para simplificar la función que dibuja la escena.

Problem 2
Open the BasicX project, then add a new class called Triangle. From the menu: Project > Add class. . . . After the wizard has finished creating the files Triangle.h and Triangle.cpp, edit both files as shown. Observe that the Triangle class is derived from DX1a::ColorVertexBuffer (a buffer to hold a set of color vertexes); you may inspect the DX1a::ColorVertexBuffer class to learn the details about how to create a buffer in DirectX. The Triangle class has a world matrix that can be used to store the triangle transformation (like translation, rotation or scaling).
Abra el projecto BasicX, entonces agregue una nueva clase llamada Triangle. Desde el menú: Proyecto > Agregar clase. . . . Después que el asistente ha terminado creando los archivos Triangle.h y Triangle.cpp, edite los dos archivos como se muestra. Observe que la clase Triangle se deriva de DX1a::ColorVertexBuffer (un buffer para guardar los vértices con color); usted puede inspeccionar la clase DX1a::ColorVertexBuffer para aprender los detalles de como crear un buffer en DirectX. La clase Triangle tiene una matriz de world que puede usarse para almacenar la transformación del triángulo (como translación, rotación o escalamiento).

Triangle.h
#pragma once
class Triangle : public DX11::ColorVertexBuffer
{
public:
     Triangle();
     ~Triangle();
     DirectX::XMMATRIX world;
};


Triangle.cpp
Triangle::Triangle()
{
     world = DirectX::XMMatrixIdentity();
     if (Setup(3, 3, D3D11_USAGE_DEFAULT, D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST) == false) return;
     //___________________________________________________________1. Vertex Setup
     // Bottom left
     vertex[0].position = DirectX::XMFLOAT3(-1.0f, -1.0f, 0.0f);
     vertex[0].color = DirectX::XMFLOAT4(1.0f, 0.0f, 0.0f, 1.0f); // RED
     // Top middle
     vertex[1].position = DirectX::XMFLOAT3(0.0f, 1.0f, 0.0f);
     vertex[1].color = DirectX::XMFLOAT4(0.0f, 1.0f, 0.0f, 1.0f); // GREEN
     // Bottom right
     vertex[2].position = DirectX::XMFLOAT3(1.0f, -1.0f, 0.0f);
     vertex[2].color = DirectX::XMFLOAT4(0.0f, 0.0f, 1.0f, 1.0f); // BLUE
     //___________________________________________________________2. Index Setup
     index[0] = 0; // Bottom left
     index[1] = 1; // Top middle
     index[2] = 2; // Bottom right
}

Triangle::~Triangle()
{
}


Step 1
Edit the BasicX.h file to include the Triangle.h file and create one object of the Triangle class.
Edite el archivo BasicX.h para incluir el archivo Triangle.h y crear un objeto de la clase Triangle.

BasicX.h
#pragma once //______________________________________ BasicX.h
#include "Resource.h"
#include "Triangle.h"

class BasicX: public . . .
{
public:
     . . .
     //____________________________________________________ 1. Application
     Triangle triangle;
     . . .
};

Step 2
Edit the BasicX.cpp file to create and render the triangle using the Color Shader. When finish, compile and run the program.
Edite el archivo BasicX.cpp para crear y dibujar el triángulo usando el Color Shader. Cuando termine, compile y corra el programa.

BasicX.cpp
void BasicX::Window_Open(Win::Event& e)
{
     . . .
     //__________________________________________________________ 3. Triangle Setup
     if (triangle.Create(hWnd, device) == false) return this->Destroy();
}

void BasicX::RenderScene()
{
     . . .
     //________________________________________________ 2. Application objects
     triangle.Render(deviceContext);
     colorShader.Render(deviceContext, triangle.GetIndexCount(), triangle.world, camera);
}

BasicXRun2

Problem 3
Modify the previous problem to change the background to light blue and the triangle to pink as shown.
Modifique el problema anterior para cambiar el fondo a azul claro y el triángulo a rosa cómo se muestra.

ChangeColorRun

© Copyright 2000-2019 Wintempla selo. All Rights Reserved. Sep 05 2019. Home