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) |
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 |
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
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:
|
| 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 |
|
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.
Es un lenguaje para crear pequeñas piezas de código que se ejecutan en el GPU.
|
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. |
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. The output produced by the vertex shader is passed to the pixel shader. 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. La salida producida por el vertex shader se pasa al pixel shader. |
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 and return the color of the pixel (RGBA). 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í y regresar el color del pixel (RGBA). |
| 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. You can type the "Escape" key to exit from the program. 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. Usted pude pulsar la tecla de "Escape" para salirse del programa. |
| Step A |
| Open Solution Explorer and take a look to the project structure. You will find four main folders: Header Files, Resource Files 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 y Source Files. Wintempla genera dos archivos con un conjunto de clases para simplificar el uso de DirectX: DX11.h y DX11.cpp. Usted puede inspeccionar estos dos archivos. |
| Step B |
| A DirectX scene is a class that manages one set of 3D objects. Add a new DirectX scene called MainScene, from Microsoft Visual Studio menu look for Add Wintempla item. . . > DirectX scene . . Una escena de DirectX es una clase que administra un conjunto de objectos 3D. Agregue una escena de DirectX llamada MainScene, desde el menú de Microsoft Visual Studio busque Add Wintempla item. . . > DirectX scene . . |
| Step C |
| A DirectX object is a class that represents a 3D object. Each scene can host several 3D objects. Add a DirectX object called Triangle, from Microsoft Visual Studio menu look for Add Wintempla item. . . > DirectX object . Un objeto de DirectX es una clase que representa un objeto en 3D. Cada escena puede hospedas varios objetos 3D. Agregue un objecto de DirectX llamado Triangle, desde el menú de Microsoft Visual Studio busque por Add Wintempla item. . . > DirectX object . |
| Step D |
| Open the file Triangle.h. The class Triangle is derived from DX11::ColorVertexBuffer. A vertex buffer is a buffer that stores a set of vertex. A DX11::ColorVertexBuffer is a vertex buffer where each vertex has a position and a color. Abra el archivo Triangle.h. La clase Triangle se deriva de DX11::ColorVertexBuffer. Un buffer de vértices es buffer que almacena un conjunto de vértices. Un DX11::ColorVertexBuffer es un buffer de vértices dónde cada vértice tiene una posición y un color. |
| Triangle.h |
| //____________________________________________________________ Triangle.h #pragma once class Triangle : public DX11::Object3D { bool OnCreateScene(DX11::Engine& engine); void OnUpdate(DX11::Engine& engine, float sec, float deltaSec); void OnRender3D(DX11::Engine& engine); void OnRender2D(DX11::Engine& engine); void OnCollision(DX11::Engine& engine, DX11::Object3D& collisionObject); void OnDeleteScene(DX11::Engine& engine, float sec); void OnSceneSize(DX11::Engine& engine); }; |
| Step E |
| Edit the Triangle.cpp file as shown. The triangle requires three vertex and three index. Edite el archivo Triangle.cpp cómo se muestra. El triángulo requiere tres vértices y tres índices. |
| Triangle.cpp |
| . . . void Triangle::OnRender3D(DX11::Engine& engine) { engine.shaderColor.Render(engine, world, vertexBuffer->GetIndexCount(), 0, 0); } . . . |
| Step F |
| Edit the MainScene.h file as shown. We need to include the Triangle.h file. Edite el archivo MainScene.h cómo se muestra. Necesitamos incluir el archivo Triangle.h. |
| MainScene.h |
| //____________________________________________________________ MainScene.h #pragma once #include "Triangle.h" class MainScene : public DX11::Scene { public: Triangle triangle; void OnCreateScene(DX11::Engine& engine); void OnUpdate(DX11::Engine& engine, float sec, float deltaSec); void OnDeleteScene(DX11::Engine& engine, float sec); void AfterCreatingChildren(DX11::Engine& engine); }; |
| Step G |
| Edit the MainScene.cpp file as shown. Please a look to the function Update, the camera in the scene is being controlled with the arrow keys in the keyboard and the mouse wheel. Edite el archivo MainScene.cpp cómo se muestra. Por favor de un vistazo a la función Update, la cámara en la escena se controla por medio de las teclas de flecha en el teclado y la llanta del ratón. |
| MainScene.cpp |
| . . . void MainScene::OnCreateScene(DX11::Engine& engine) { //______________________________ 1. Set back color RGBA this->SetBackColor(0.0f, 0.0f, 0.4f, 1.0f); //______________________________ 2. Add children this->AddChild(triangle); //______________________________ 3. Camera & Light setup (light.ambientColor) . . . } |
| Step H |
| Edit the BasicX.h file as shown. We need to include the MainScene.h file. Edite el archivo BasicX.h cómo se muestra. Necesitamos incluir el archivo MainScene.h. |
| BasicX.h |
| #pragma once //______________________________________ BasicX.h #include "Resource.h" #include "MainScene.h" class BasicX : public DX11::Window { public: MainScene mainScene; DX11::ColorVertexBuffer vbTriangle; }; |
| Step I |
| Edit the BasicX.cpp file as shown. Here, we set a name to each scene in the project. We also indicate which is the first scene to shown. In the code, "engine" is the main object, it has access to all the resources, functions and operations. Compile and run the program, you will be able to move the camera with the arrow keys and the mouse wheel. Edite el archivo BasicX.cpp cómo se muestra. Aquí, nosotros fijamos un nombre a cada una de las escenas en el proyecto. También indicamos cual es la primer escena que se muestra. En el código, "engine" es el objeto principal, este tiene acceso a todos los recursos, funciones y operaciones. Compile y ejecute el programa, usted podrá mover la cámara con las teclas de flechas y la llanta del ratón. |
| BasicX.cpp |
| . . . int APIENTRY wWinMain(. . .) { BasicX app; //_________________________________________________________ 1. Create vertex buffers if (app.vbTriangle.CreateData(3, 3, D3D11_USAGE_DEFAULT, D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST) == false) { ::MessageBox(NULL, L"Unable to create vertex buffer", L"BasicX", MB_OK | MB_ICONERROR); return 0; } DX11::ColorVertex* vertex = app.vbTriangle.vertex; // 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 // Index Setup app.vbTriangle.index[0] = 0; // Bottom left app.vbTriangle.index[1] = 1; // Top middle app.vbTriangle.index[2] = 2; // Bottom right //_________________________________________________________ 2. Add vertex buffers to the engine app.engine.AddChild(app.vbTriangle); //_________________________________________________________ 3. Set vertex buffers to the 3D objects app.mainScene.triangle.vertexBuffer = &app.vbTriangle; //_________________________________________________________ 4. Scene setup app.engine.scene[L"mainScene"] = &app.mainScene; app.engine.SetCurrentScene(L"mainScene"); //_________________________________________________________ 5. Run the app return app.Run(. . .); } |
Render |
| Each objects has a Render function that is periodically called to draw the object in the scene. Typically, this function is 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. Cada objeto tiene una función Render que es llamada periódicamente para dibujar el objeto en la escena. Típicamente, esta función se llama 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. |
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:
DirectX y OpenGL son librerías de gráficos:
|