Triangle


DrawPrimitive

One of the most important functions in DirectX 9 is DrawPrimitive. It can be used to draw different objects. DrawPrimitive takes three parameters. The first parameter indicates the type of primitive and can be any of:
  1. D3DPT_POINTLIST
  2. D3DPT_LINELIST
  3. D3DPT_LINESTRIP
  4. D3DPT_TRIANGLELIST
  5. D3DPT_TRIANGLESTRIP
  6. D3DPT_TRIANGLEFAN
  7. D3DPT_FORCE_DWORD
The second parameter is the start vertex. The last parameter is the number of primitives to draw.Triangles are very important in 3D because they can be used to describe and draw complex objects. DirectX offers: triangle lists, triangle strips and triangle fans.
Una de las funciones más importantes funciones en DirectX 9 es DrawPrimite. Esta puede ser usada para dibujar diferentes objetos. DrawPrimite toma tres parámetros. El primer parámetro indica el tipo de primitiva y puede ser cualquier de los siguientes valores:
  1. D3DPT_POINTLIST
  2. D3DPT_LINELIST
  3. D3DPT_LINESTRIP
  4. D3DPT_TRIANGLELIST
  5. D3DPT_TRIANGLESTRIP
  6. D3DPT_TRIANGLEFAN
  7. D3DPT_FORCE_DWORD
El segundo parámetro el vértice de inicio. El último parámetro es el número de primitivos que se dibujarán. Los triángulos son muy importantes en 3D porque estos pueden ser usados para describir y dibujar objetos complejos. DirectX proporciona: listas de triángulos, bandas de triángulos y ventiladores de triángulos.

device->IASetPrimitiveTopology

One of the most important functions in DirectX 10 and 11 is IASetPrimitiveTopology. It can be used to draw different type of objects. The only parameter indicates the type of primitive and can be any of:
  1. D3D10_PRIMITIVE_TOPOLOGY_POINTLIST
  2. D3D10_PRIMITIVE_TOPOLOGY_LINELIST
  3. D3D10_PRIMITIVE_TOPOLOGY_LINESTRIP
  4. D3D10_PRIMITIVE_TOPOLOGY_TRIANGLELIST
  5. D3D10_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP
  6. D3D10_PRIMITIVE_TOPOLOGY_LINELIST_ADJ
  7. D3D10_PRIMITIVE_TOPOLOGY_LINESTRIP_ADJ
  8. D3D10_PRIMITIVE_TOPOLOGY_TRIANGLELIST_ADJ
  9. D3D10_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP_ADJ
  10. D3D11_PRIMITIVE_TOPOLOGY_POINTLIST
  11. D3D11_PRIMITIVE_TOPOLOGY_LINELIST
  12. D3D11_PRIMITIVE_TOPOLOGY_LINESTRIP
  13. D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST
  14. D3D11_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP
  15. D3D11_PRIMITIVE_TOPOLOGY_LINELIST_ADJ
  16. D3D11_PRIMITIVE_TOPOLOGY_LINESTRIP_ADJ
  17. D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST_ADJ
  18. D3D11_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP_ADJ

Una de las funciones mas importantes en DirectX 10 y 11 es IASetPrimitiveTopology. Esta puede ser usada para dibujar distintos tipos de objetos. El único parámetro indica el tipo de primitiva y puede ser: (ver la lista en inglés).

Triangle List

A triangle list is a list of isolated triangles as shown in the figure below. They are use to create an object that is composed of disjoint pieces. DirectX allows applying a material and texture to a triangle list to simulate real scenes. A triangle list must have at least three vertices and the total number of vertices must be divisible by three.
Una lista de triángulos es una lista de triángulos aislados como se muestra en la figura de abajo. Estas son usadas para crear un objeto que está compuesto de piezas separadas. DirectX permite aplicar un material y una textura a la lista de triángulos para simular escenas reales. Una lista de triángulos debe tener al menos tres vértices y el número total de vértices debe ser divisible entre tres.

TriangleList

Triangle Strip

A triangle strip is a list of connected triangles. As the triangles are connected, it is not necessary to repeatedly specify all three vertices of each triangle. In the figure below, only seven vertices are required to define (and draw) the triangle strip composed of five triangles: 012, 123, 234, 345, and 456. Triangle strips are used to define most objects in 3D scenes, including very complex objects such as people, cars, etc.
Una banda de triángulos es una lista de triángulos conectados. Como los triángulos están conectados, no es necesario especificar en forma repetida los tres vértices de cada triángulo. En la figura de abajo, sólo se requieren siete vértices para definir (y dibujar) la banda de triángulos compuesta de cinco triángulos: 012, 123, 234, 345 y 456. Las bandas de triángulos son usadas para definir la mayoría de los objetos en escenas de 3D, incluyendo objetos muy complejos tales como personas, carros, etc.

TriangleStrip

Degenerate Triangle

A degenerate triangle is a triangle whose area is zero. A degenerate triangle can be included in a triangle strip to render triangles that are not connected to one another in DirectX 9. The code shown below draws two separate triangles. In DirectX 10 and 11, a strip-cut index is used to cut a strip, a strip-cut index is simply the maximum possible value for the index (0xffff for a 16-bit index, 0xffffffff for a 32-bit index) as shown in the figure.
Un triángulo degenerado es un triángulo que tiene una área de cero. Un triángulo degenerado puede ser usado en una banda de triángulos para dibujar triángulos que no están conectados uno con el otro en DirectX 9. El código de abajo dibuja dos triángulos separados. En DirectX 10 y 11, un índice de corte de banda es usado para cortar una banda de triángulos, un índice de corte de banda es simplemente el máximo valor posible para el índice (0xffff para un índice de 16 bits, 0xffffffff para un índice de 32 bits) cómo se muestra en al figura.

Program.cpp
//_______________________________________ DirectX 9
CUSTOMVERTEX vertices[] =
{
{-5.0, -5.0, 0.0},
{ 0.0, 5.0, 0.0},
{ 5.0, -5.0, 0.0},
{ 5.0, -5.0, 0.0}, // degenerate triangle
{10.0, 5.0, 0.0}, // degenerate triangle
{10.0, 5.0, 0.0},
{15.0, -5.0, 0.0},
{20.0, 5.0, 0.0}
};


VertexAndIndex

Triangle Fan

Triangle Fans are not longer supported in new versions of DirectX because Triangle Strips can do anything that Triangle Fans can do. A triangle fan can be used to draw a polygon or a circle.
Los Ventiladores de Triángulos ya no son soportados en las nuevas versiones de DirectX porque las Bandas de Triángulos pueden hacer todo lo que los Ventiladores de Triángulos pueden hacer. Un ventilador de triángulos puede usarse para dibujar un polígono o un círculo.

Vertex Buffer in DirectX 9

When drawing a set of vertices, performance can be improved using vertex buffer. In this case the vertex values are not filled with the vertices every time the screen is drawn, instead the buffer is created only once before the first rendered. A vertex buffer requires a smart pointer member variable as shown in the header file shown below. The source file shows how to use a vertex buffer. First, the vertex buffer is created. Second, the buffer memory must be locked. Third, vertices data is copied to the vertex buffer. Finally, the buffer memory must the unlocked as shown below.
Cuando se dibujan un conjunto de vértices, el desempeño puede ser mejorado usando un buffer de vértices. En este caso los valores de los vértices no son llenados cada vez que se dibuja la pantalla, en su lugar el buffer es creado solamente una vez antes de dibujar la pantalla por primera vez. Un buffer de vértices requiere una variable miembro del tipo puntero inteligente como se muestra en el archivo de encabezado mostrado debajo. El código fuente mostrado debajo ilustra cómo usar un buffer de vértices. Primero, el buffer de vértices es creado. Segundo, se coloca un candado en la memoria del buffer. Tercero, los datos de los vértices son copiados al buffer. Finalmente, el candado de la memoria del buffer es removido como se muestra debajo.

Program.h
#pragma once //______________________________________ Program.h
#include "Resource.h"
class Program: public Win::Window
{
public:
     Program()
     {
     }
     ~Program()
     {
     }
     IDirect3DVertexBuffer9* vertexBuffer;
     ...
};

Program.cpp
void Program::Window_Open(Win::Event& e)
{
     ...

     CG::Vertex vertex[] =
     {
          { -1.0f,-1.0f, 0.0f, 0xffff0000, },
          { 1.0f,-1.0f, 0.0f, 0xff0000ff, },
          { 0.0f, 1.0f, 0.0f, 0xff00ff00, },
     };
     try
     {
          //_______________________________________________________ 1. CREATE
          d3dDevice->CreateVertexBuffer(3*sizeof(Game::Vertex), 0,
               D3DFVF_XYZ|D3DFVF_DIFFUSE, D3DPOOL_DEFAULT, &vertexBuffer, NULL);

          VOID* pVertices;
          //_______________________________________________________ 2. LOCK
          vertexBuffer->Lock(0, sizeof( vertex ), ( void** )&pVertices, 0 );
          //_______________________________________________________ 3. COPY
          memcpy( pVertices, vertex, sizeof(vertex) );
          //_______________________________________________________ 4. UNLOCK
          vertexBuffer->Unlock();
     }
     catch(_com_error & e)
     {
          this->MessageBox(e.ErrorMessage(), L"COM Error", MB_OK | MB_ICONERROR);
     }

     ...
}


Tip
The code shown below illustrates how to render a vertex buffer in DirectX 9. First, the SetStreamSource function is called to set a specific vertex buffer corresponding to an object in the scene. Second, the DrawPrimite function can be used to draw the object.
El código de abajo ilustra como dibujar un buffer de vértices en DirectX 9. Primero, la función SetStreamSource es llamada para fijar un buffer de vértices específico que corresponde a un objeto en la escena. Segundo, la función DrawPrimitive puede ser usada para dibujar el objeto.

Program.cpp
bool Program::RenderScene()
{
     ...
     d3dDevice->SetStreamSource( 0, vertexBuffer, 0, sizeof(CG::Vertex) );
     d3dDevice->SetFVF(D3DFVF_XYZ|D3DFVF_DIFFUSE);
     d3dDevice->DrawPrimitive(D3DPT_TRIANGLELIST, 0, 1);
     ...
}


Normal Vector

A normal vector is a unit vector perpendicular to a surface. The direction of the vector is determined by the order in which the vertices are defined and the coordinate system. The surface has two faces: the back face and the front face as shown in the figure. DirectX does not always render back faces. Normal vectors can also be assigned to each vertex, in this case, the normal vector can be used to produce effects on the surface of the object such as lighting.
Un vector normal es un vector perpendicular a una superficie. La dirección del vector está determinada por el orden en el cual los vértices están definidos y el sistema de coordenadas. La superficie tiene dos caras: la cara de atrás y la cara enfrente como se muestra en la figura. DirectX no siempre dibuja ambas caras. Los vectores normales pueden ser asignados a cada vértice, en este caso, el vector normal puede ser usado para producir efectos en la superficie del objecto tales como iluminación.

NormalVector

Normal Vector Computation

It is possible to compute the normal vector for each vertex in a triangle using the cross product as shown in the figure. In a triangle strip, each vertex is shared by three triangles, and therefore, the resulting normal is usually computed as the average of the three normal vectors. In a more complex mesh, each vertex may be shared by more than three triangles, and consequently, the resulting normal may be computed as the average of all the normal vectors of the adjacent triangles.
Es posible calcular el vector normal para vértice en un triángulo usando el producto cruz cómo se muestra en la figura. En una banda de triángulos, cada vértice está compartido por tres triángulos, y por lo tanto, la normal resultante es usualmente calculada cómo el promedio de los tres vectores normales. En un malla más compleja, cada vértice puede ser compartido por más de tres triángulos, y consecuentemente, la normal resultante puede ser calculada como el promedio de todas los vectores normales de los triángulos adyacentes.

NormalComputation

Culling in DirectX

DirectX has several options to draw the faces of the surface, these options are called culling options. You can use the SetRenderState function to set the culling mode in DirectX 9. The options are: D3DCULL_NONE (no culling), D3DCULL_CW (clockwise culling), and D3DCULL_CCW (counter clockwise culling). In DirectX 11, you can use the D3D11_RASTERIZER_DESC structure to set the CullMode, the available values are: D3D11_CULL_NONE, D3D11_CULL_BACK and D3D11_CULL_FRONT.
DirectX tiene varias opciones para dibujar las caras de una superficie, estas opciones son llamadas opciones de culling. Usted puede usar la función SetRenderState para fijar el modo de culling en DirectX 9. Las opciones son: D3DCULL_NONE (no culling), D3DCULL_CW (culling en la dirección de las manecillas reloj), and D3DCULL_CCW (culling en la dirección contraria a las manecillas reloj). En DirectX 11, usted puede usar la estructura D3D10_RASTERIZER_DESC para fijar el CullMode, los valores disponibles son: D3D11_CULL_NONE, D3D11_CULL_BACK y D3D11_CULL_FRONT.

Problem 1
Create a DirectX application called Scene to draw a cube using triangle strips. The cube must rotate horizontally. Use the following colors for the cube faces: red, blue, green, yellow, purple, and cyan. Be sure to set the appropriate culling mode. Add a class called Cube to your project to store the vertex and indexes of the cube. Each face requires four vertex. The full cube requires 24 vertex. The number of indexes is 24 plus five to separate each triangle strip with a strip-cut index, a total of 29 indexes. Use D3D11_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP. In this problem, we will move the camera up and down using the arrow keys from the keyboard.
Cree una aplicación de DirectX llamada Scene para dibujar un cubo usando bandas de triángulos. El cubo de rotar en forma horizontal. Use los siguientes colores para las caras del cubo: rojo, azul, verde, amarillo, morado y azul claro. Asegúrese de configurar el modo apropiado de culling. Agregue una clase llamada Cube a su proyecto para almacenar los vértices y los índices del cubo. Cada cara requiere cuatro vértices. El cubo completo requiere 24 vértices. El número de índices es 24 más cinco adicionales índices para separar cada banda de triángulos con un índice de corte de banda, un total de 29 índices. Use D3D11_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP. En este problema, moveremos la cámara para arriba y para abajo usando las teclas de las flechas del teclado.

CubeTriangleStrips

SceneRun1

SceneRun2

SceneRun3

Scene.h
#pragma once //______________________________________ Scene.h
#include "Resource.h"
#include "Cube.h"

class Scene: public . . .
{
public:
     . . .
     //____________________________________________________ 1. Application
     Cube cube;
     . . .
};


Scene.cpp
. . .
void Scene::Window_Open(Win::Event& e)
{
     . . .
     //________________________________________________________________ 5. Cube Setup
     if (cube.Create(hWnd, device) == false) this->Destroy();
}

void Scene::RenderScene()
{
     //________________________________________________ 1. Clear screen
     Clear(0.0f, 0.0f, 0.2f, 1.0f);
     //________________________________________________ 2. Move the camera with the up and down with the keyboard arrows
     if (keyboard[VK_UP]) camera.position.y += (FLOAT)(1.0*stopWatch.GetSeconds());
     if (keyboard[VK_DOWN]) camera.position.y -= (FLOAT)(1.0*stopWatch.GetSeconds());
     camera.Update();
     //________________________________________________ 3. Render objects
     cube.Update(keyboard, stopWatch);
     cube.Render(deviceContext);
     colorShader.Render(deviceContext, cube.GetIndexCount(), cube.world, camera);
}


Cube.h
#pragma once
class Cube : public DX11::ColorVertexBuffer
{
public:
     Cube();
     ~Cube();
     FLOAT angleY;
     DirectX::XMMATRIX world;
     void Update(bool * keyboard, Sys::Stopwatch& stopWatch);
};


Cube.cpp
#include "stdafx.h"
#include "Cube.h"

Cube::Cube()
{
     world = DirectX::XMMatrixIdentity();
     angleY = 0.0f;
     if (Setup(29, 24, D3D11_USAGE_DEFAULT, D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP) == false) return;
     //_________________________________________________________________ 1. Vertex Setup
     unsigned int i;
     //_________________________________ Blue Top
     for(i = 0; i < 4; i++) vertex[i].color = DirectX::XMFLOAT4(0.0f, 0.0f, 1.0f, 1.0f);
     vertex[0].position = DirectX::XMFLOAT3(1.0f, 1.0f, -1.0f);
     vertex[1].position = DirectX::XMFLOAT3(-1.0f, 1.0f, -1.0f);
     vertex[2].position = DirectX::XMFLOAT3(1.0f, 1.0f, 1.0f);
     vertex[3].position = DirectX::XMFLOAT3(-1.0f, 1.0f, 1.0f);
     //_________________________________ Yellow Left
     . . .
     //____________________________________________________________________ 2. Index Setup
     index[0] = 0; // Top face
     index[1] = 1;
     index[2] = 2;
     index[3] = 3;
     index[4] = 0xffffffff; //strip-cut index
     index[5] = 4; // Left face
     . . .
}

Cube::~Cube()
{
}

void Cube::Update(bool * keyboard, Sys::Stopwatch& stopWatch)
{
     . . .
}


Tip
In game development, artists use special software to create and edit 3D characters. Programmers, then, just load the characters into the program. The artist should try to use the smaller number of triangles while keeping a good appearance in the objects. Typically, the artist draws an image on each triangle to improve the quality of the objects.
En el desarrollo de juegos, los artistas usan software especializado para crear y editar los caracteres 3D. Los programadores, entonces, sólo cargan los caracteres en el programa. El artista debe tratar de usar el menor número de triángulos mientras mantiene una buena apariencia en los objetos. Típicamente, el artista dibuja una imagen en cada triángulo para mejorar la calidad de los objetos.

Game Platform

A game development platform may be a thin layer of encapsulation to help beginner programmer to create game using DirectX. Programmers, who have been working on game development for a long time, have their own set of classes for game development.
Una plataforma de desarrollo de juegos puede ser una capa delgada de encapsulación para ayudar a los programadores novatos a crear un juego en DirectX. Los programadores que han estado trabajando en desarrollo de juegos por un largo tiempo, tienen su propio conjunto de clases para el desarrollo de juegos.

Texture

A texture is an image that can be drawn on the surface of a 3D object. The texture size must be a power of 2: 16, 32, 64, 128, etc. The image for the texture can be loaded directly from a bitmap; the bitmap can be created from a resource or a file. The figure below shows how the values tu and tv are used to specify the corners of the image. These values are used when applying the texture.
Una textura es una imagen que puede dibujarse sobre la superficie de un objeto en 3D. El tamaño de la textura debe ser una potencia de 2: 16, 32, 64, 128, etc. La imagen para la textura puede cargarse desde un bitmap; el bitmap puede ser creado desde un recurso o un archivo. La figura de abajo muestra cómo los valores de tu y tv son usados para especificar las esquinas de la imagen. Estos valores son usados al aplicar la textura.

Texture

Problem 2
Create a DirectX application called Skin to draw a texture over a triangle. For this problem, you need a BMP image of size 256x256 with no compression and 32 bits (or a GIF). After creating the project, add a new class called TexTriangle to store the vertex and indexes of a triangle with texture. To display both sides of the triangle set the Cull Mode to D3D11_CULL_NONE.
Cree una aplicación de DirectX llamada Skin para dibujar una textura sobre un triángulo. Para este problema, usted necesita una imagen BMP de tamaño 256x256 sin compresión de 32 bits (o un GIF). Después de crear el proyecto, agregue una nueva clase llamada TexTriangle para almacenar los vértices y los índices de un triángulo con una textura. Para mostrar los dos lados del triángulo fije el modo de Cull en D3D11_CULL_NONE.

SkinFolder

SkinRun

Step A
Edit the Skin.h file, include the TexTriangle.h file at the top, create one object of the TexTriangle class and another object of the DX11::Texture class.
Edite el archivo Skin.h, incluya el archivo TexTriangle.h en la parte de arriba, cree un objeto de la clase TexTriangle y otro objeto de la clase DX11::Texture.

Skin.h
#pragma once //______________________________________ Skin.h
#include "Resource.h"
#include "TexTriangle.h"

class Skin: public . . .
{
public:
     . . .
     //____________________________________________________ 1. Application
     TexTriangle triangle;
     DX11::Texture texture;
     . . .
};


Step B
Edit the Skin.cpp file, to create the texture triangle and the texture. Then, edit the file to render the texture triangle using a texture shader. Change the culling mode to D3D11_CULL_NONE.
Edite el archivo Skin.cpp, para crear el triángulo de textura y la textura. Entonces edite el archivo para renderice el triángulo de textura usando un shader de textura. Cambie el modo culling a D3D11_CULL_NONE.

Skin.cpp
. . .
void Skin::Window_Open(Win::Event& e)
{
     . . .
     if (InitDevice(D3D11_CULL_NONE, 1, 0) == false) return this->Destroy();
     . . .
     //________________________________________________________________ 5. Load the texture and create the triangle
     error = texture.Create(device, deviceContext, L"floor.bmp", 1, 0);
     if (error != NULL) this->MessageBox(error, L"Skin", MB_OK | MB_ICONERROR);
     if (triangle.Create(hWnd, device) == false) this->Destroy();
}

void Skin::RenderScene()
{
     . . .
     //________________________________________________ 2. Application objects
     triangle.Update(keyboard, stopWatch);
     triangle.Render(deviceContext);
     textuShader.Render(deviceContext, triangle.GetIndexCount(), triangle.worldMatrix, camera, texture.resView);
}


Step C
Edit the files TexTriangle.h and TexTriangle.cpp
Edite los archivos TexTriangle.h y TexTriangle.cpp

TexTriangle.h
#pragma once
class TexTriangle : public DX11::TextureVertexBuffer
{
public:
     TexTriangle();
     ~TexTriangle();
     FLOAT angleY;
     DirectX::XMMATRIX worldMatrix;
     void Update(bool * keyboard, Sys::Stopwatch& stopWatch);
};


TexTriangle.cpp
#include "stdafx.h"
#include "TexTriangle.h"

TexTriangle::TexTriangle()
{
     worldMatrix = DirectX::XMMatrixIdentity();
     angleY = 0.0f;
     if (Setup(3, 3, D3D11_USAGE_DEFAULT, D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST) == false) return;
     //_________________________________________________________ 1.1 Bottom left
     vertex[0].position = DirectX::XMFLOAT3(-1.0f, -1.0f, 0.0f);
     vertex[0].texture = DirectX::XMFLOAT2(0.0f, 1.0f);
     //_________________________________________________________ 1.2. Top middle
     vertex[1].position = DirectX::XMFLOAT3(0.0f, 1.0f, 0.0f);
     vertex[1].texture = DirectX::XMFLOAT2(0.5f, 0.0f);
     //_________________________________________________________ 1.3. Bottom right
     vertex[2].position = DirectX::XMFLOAT3(1.0f, -1.0f, 0.0f);
     vertex[2].texture =DirectX::XMFLOAT2(1.0f, 1.0f);
     //_________________________________________________________ 2. Index setup
     index[0] = 0; // Bottom left.
     index[1] = 1; // Top middle.
     index[2] = 2; // Bottom right
}

TexTriangle::~TexTriangle()
{
}

void TexTriangle::Update(bool * keyboard, Sys::Stopwatch& stopWatch)
{
     const FLOAT delta = (FLOAT)stopWatch.GetSeconds();
     angleY += (0.5f*delta);
     worldMatrix = DirectX::XMMatrixRotationY(angleY);
     if (angleY > DirectX::XM_2PI) angleY -= DirectX::XM_2PI;
}


Problem 3
Create a DirectX application called FloorCorner to draw an image in front of the 3D objects (2D drawing). For this problem, you need a BMP image of size 256x256 with no compression and 32 bits (or a GIF) . After creating the project, create an object of the class DX10::TextureRect2D and another of the class DX11::Texture to draw a rectangle with the bitmap as a texture.
Cree una aplicación de DirectX llamada FloorCorner para dibujar una imagen enfrente de los objetos 3D (dibujado en 2D). Para este problema, usted necesita una imagen BMP de tamaño 256x256 sin compresión de 32 bits (o un GIF). Después de crear el proyecto, cree un objeto de la clase DX11::TextureRect2D y otro de la clase DX10::Texture para dibujar el rectángulo con el bitmap como textura.

FloorCorner.h
#pragma once //______________________________________ FloorCorner.h
#include "Resource.h"

class FloorCorner: public . . .
{
public:
     . . .
     //____________________________________________________ 1. Application
     DX11::TextureRect2D textuRect2D;
     DX11::Texture texture;
     . . .
};


Step A
Edit the FloorCorner.cpp file to create the texture from the bitmap, and render the rectangle using a texture shader.
Edite el archivo FloorCorner.cpp para crear la textura con el bitmap, y renderizar el rectángulo usando la textura.

FloorCorner.cpp
...
void FloorCorner::Window_Open(Win::Event& e)
{
     ...
     //________________________________________________________________ 5. Create the texture and the rectangle
     error = texture.Create(device, deviceContext, L"floor.bmp", 1, 0);
     if (error != NULL) this->MessageBox(error, L"FloorCorner", MB_OK | MB_ICONERROR);
     RECT rect = {0, (int)modeDesc.Height -texture.GetHeight(), texture.GetWidth(), (int)modeDesc.Height};
     if (textuRect2D.Create(hWnd, device, rect, modeDesc.Width, modeDesc.Height, D3D11_USAGE_DEFAULT) == false) this->Destroy();
}

void FloorCorner::RenderScene()
{
     . . .
     //________________________________________________ 2. Application objects
     ZBuffer(false);
     textuRect2D.Render(deviceContext);
     textuShader.RenderOrthographic(deviceContext, textuRect2D.GetIndexCount(), camera, texture.resView);
     ZBuffer(true);
}


FloorCornerRun

Problem 4
Create a DirectX application called GdiCorner to draw an image generated using GDI in front of the 3D objects. After creating the project, create a new class called Diagram to perform GDI drawing.
Cree una aplicación de DirectX llamada GdiCorner para dibujar una imagen generada usando GDI enfrente de los objetos 3D. Después de crear el proyecto, cree una nueva clase llamada Diagram para realizar dibujado con GDI.

Step A
Edit the files Diagram.h and Diagram.cpp as shown.
Edite los archivos Diagram.h y Diagram.cpp como se muestra.

Diagram.h
#pragma once
class Diagram : public DX11::DynamicTexture
{
public:
     Diagram();
     ~Diagram();
     void GdiDraw(CG::Gdi& gdi, int width, int height);
};


Diagram.cpp
#include "stdafx.h"
#include "Diagram.h"

Diagram::Diagram()
{
}

Diagram::~Diagram()
{
}

void Diagram::GdiDraw(CG::Gdi& gdi, int width, int height)
{
     CG::Brush brush(RGB(220, 220, 255));
     gdi.FillRect(0, 0, width, height, brush);
     const int radius = (int)(0.9*MINIMUM(width/2, height/2)+0.5);
     gdi.Circle(width/2, height/2, radius);
     gdi.TextOut(0, 0, L"GDI");
}


Step B
Edit the GdiCorner.h file to create an object of the class DX11::TextureRect2D and another of the class Diagram. Do not forget to include the Diagram.h file at the top of the GdiCorner.h file.
Después de crear el proyecto, cree un objeto de la clase DX11::TextureRect2D y otro de la clase Diagram. No se olvide de incluir el archivo Diagram.h en la parte de arriba del archivo GdiCorner.h.

GdiCorner.h
#pragma once //______________________________________ GdiCorner.h
#include "Resource.h"
#include "Diagram.h"

class GdiCorner: public . . .
{
public:
     . . .
     //____________________________________________________ 1. Application
     DX11::TextureRect2D textuRect2D;
     Diagram diagram;
     . . .
};


Step B
Edit the GdiCorner.cpp file to create the texture using GDI, and render the rectangle using a texture shader.
Edite el archivo GdiCorner.cpp para crear la textura usando GDI, y renderizar el rectángulo usando la textura.

FloorCorner.cpp
...
void GdiCorner::Window_Open(Win::Event& e)
{
     . . .
     //________________________________________________________________ 5. Create the texture and the rectangle
     error = diagram.Create(device, deviceContext, 300, 100, 1, 0);
     if (error != NULL) this->MessageBox(error, L"Basic", MB_OK | MB_ICONERROR);
     //
     RECT rect = {0, 0, diagram.GetWidth(), diagram.GetHeight()};
     if (textuRect2D.Create(hWnd, device, rect, modeDesc.Width, modeDesc.Height, D3D11_USAGE_DEFAULT) == false) return this->Destroy();
}

void GdiCorner::RenderScene()
{
     . . .
     //________________________________________________ 2. Application objects
     ZBuffer(false);
     textuRect2D.Render(deviceContext);
     textuShader.RenderOrthographic(deviceContext, textuRect2D.GetIndexCount(), camera, diagram.textureView);
     ZBuffer(true);
}


GdiCornerRun

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