Matrix


Coordinate System

DirectX uses a left-handed coordinate system as shown below. In this figure, the camera is located over the Z axis, anything behind the camera cannot be seen. Understanding the coordinate system is very important to solve problems in your program.
DirectX usa un sistema de coordenadas de mano izquierda como se muestra debajo. En la figura, la cámara está ubicada sobre el eje Z, cualquier objeto atrás de la cámara no se puede ver. Entender el sistema de coordinadas es muy importante para resolver problemas en su programa.

CoordinateSystem

Vector

DirectX provides the DirectX::XMVECTOR class to store vectors in a 3D space.
DirectX propociona la clase DirectX::XMVECTOR para almacenar vectores en un espacio 3D.

Matrix

Most 3D operations require the fast manipulations of matrices. DirectX provides several structures and functions to manipulate matrices. One common structure to store a matrix is DirectX::XMMATRIX. Typically, a DirectX project must have at least three matrices: the view matrix, the projection matrix, and the world matrix. The equation below shows how to compute the screen data

Screen data = (World Matrix) × (View Matrix) × (Projection Matrix) × (Object data)
La mayoría de las operaciones de 3D requieren la manipulación rápida de matrices. DirectX proporciona varias estructuras y funciones para manipular matrices. Una estructura común para almacenar una matriz es DirectX::XMMATRIX. Típicamente, un proyecto de DirectX debe tener al menos tres matrices: la matriz de vista, la matriz de proyección, y la matriz de mundo. La ecuación de abajo muestra cómo calcular los datos de la pantalla

Screen data = (World Matrix) × (View Matrix) × (Projection Matrix) × (Object data)

View Matrix

The view matrix is used to specify the position and direction of the eye that is looking at the objects in the scene. You must use the DirectX::XMMatrixLookAtLH function to create a view matrix (the first parameter is the matrix where the output will be stored). In order to set the view, you need:
  • A matrix to store the resulting view matrix
  • A vector to set the position of the eye
  • A vector to set the look at direction
  • A vector to set the up direction, for instance the z-axis or y-axis can be used to indicate up
  • To call the DirectX::XMMatrixLookAtLH function
The code below that illustrate how to create the view matrix.
La matriz de vista es usada para especificar la posición y la dirección del ojo que está observando los objetos de la escena. Usted debe usar la función DirectX::XMMatrixLookAtLH para crear una matriz de vista (el primer parámetro es la matriz dónde se almacenará la salida.) A fin de usar la vista, usted necesita
  • Una matriz para almacenar la matriz de vista resultante
  • Un vector para indicar la posición del ojo
  • Un vector para indicar la dirección hacia donde ve el ojo
  • Un vector para indicar la dirección hacia arriba, por ejemplo el eje y o el eje z pueden indicar hacia arriba
  • Llamar la función DirectX::XMMatrixLookAtLH
El código de abajo que ilustra cómo crear la matriz de vista.

Example.cpp
void Example::InitDevice()
{
     . . .
     //_____________________________________________________________ View Matrix
     // Set the eye point, a point to look at, and a direction for which way is up.
     // The eye is five units back along the z-axis and up three units, look at the origin, and define "up" to be in the y-direction.
     DirectX::XMVECTOR eye =DirectX::XMVectorSet(0.0f, 3.0f, -5.0f, 0.0f);
     DirectX::XMVECTOR lookAt = DirectX::XMVectorSet(0.0f, 0.0f, 1.0f, 0.0f);
     DirectX::XMVECTOR up = DirectX::XMVectorSet(0.0f, 1.0f, 0.0f, 0.0f);
     view = DirectX::XMMatrixLookAtLH (eye, lookAt, up);
     . . .
}

bool Example::RenderScene()
{
     . . .
     // Use the View Matrix: view
     . . .
}


Projection Matrix

The projection matrix sets up a perspective transform which transforms geometry from 3D view space to a 2D viewport space, with a perspective making objects smaller in the distance. In order to set the projection matrix you need to call DirectX::XMMatrixPerspectiveFovLH function. The code shown below illustrates how to create a projection matrix.
La matriz de proyección configura la transformación de perspectiva la cual transforma la geometría desde un espacio de vista en 3D a un espacio 2D, con una perspectiva haciendo los objetos distantes más pequeños. A fin de fijar la matriz de proyección usted necesita llamar la función DirectX::XMMatrixPerspectiveFovLH. El código de abajo ilustra cómo crear la matriz de proyección.

Example.cpp
void Example::InitDevice()
{
     . . .
     projection = DirectX::XMMatrixPerspectiveFovLH(DirectX::XM_PI / 4, 1.0f, 1.0f, 100.0f);
}

bool Example::RenderScene()
{
     . . .
     // Use the Projection Matrix: projection
     . . .
}


World Matrix

The world matrix allows:
  • Translating an object (use the DirectX::XMMatrixTranslation function to create the matrix to translate)
  • Rotating an object (DirectX::XMMatrixRotationX, DirectX::XMMatrixRotationY,DirectX::XMMatrixRotationZ)
  • Scaling an object (DirectX::XMMatrixScaling)
  • Apply an affine transformation (DirectX::XMMatrixAffineTransformation)

La matriz de mundo permite:
  • Transladar un objeto(use la función D3DXMatrixTranslation para crear la matriz para transladar)
  • Rotar un objeto (DirectX::XMMatrixRotationX, DirectX::XMMatrixRotationY, DirectX::XMMatrixRotationZ)
  • Escalar un objeto (DirectX::XMMatrixScaling)
  • Aplicar una transformación de afinidad (DirectX::XMMatrixAffineTransformation)

The Keyboard

There are several ways to incorporate user input (such the keyboard and mouse) in a DirectX application. The class of your project provides a simple way to provide basic keyboard interaction. The code shown below shows how this class handles the keyboard. The class has an array of bool values called keyboard. Every time the user presses a key (in the event Window_KeyDown), one value in the array is set to true. When the user releases the key (in the event Window_KeyUp), the corresponding bool value in the array is restored to false. You may overwrite these functions to change the class behavior. You can use Direct Input instead.
Hay varias formas para incorporar entrada del usuario (tal como el teclado o el ratón) en una aplicación de DirectX. La clase de su proyecto proporciona una forma simple para proporcionar interacción básica con el teclado. El código de abajo muestra como la clase para manejar el teclado. La clase tiene un arreglo de valores booleanos llamada keyboard. Cada vez que el usuario presiona una tecla (en el evento Window_KeyDown), un valor en el arreglo es fijado en verdadero. Cuando el usuario libera la tecla (en el evento Window_KeyUp), el correspondiente valor booleano es restablecido en falso. Usted puede sobre-escribir estas funciones para cambiar el comportamiento de la clase. Usted puede usar Direct Input en su lugar.

Program.h
class Program: public . . .
{
public:
     Program();
     ~ Program();
     ...
protected:
     bool keyboard[256];
     ...
     virtual void Window_KeyDown(Win::Event& e);
     virtual void Window_KeyUp(Win::Event& e);
};

Program.cpp
...
void Program::Window_KeyDown(Win::Event& e)
{
     if (e.wParam>255) return;
     keyboard[e.wParam] =true;
}

void Program::Window_KeyUp(Win::Event& e)
{
     if (e.wParam>255) return;
     keyboard[e.wParam] =false;
}


Problem 1
Open the BasicX project of Wintempla > DirectX > Introduction and edit the Triangle.cpp file as shown. In this case, we will use the transformation matrix world to move the triangle up and down when the user presses the Up or Down arrows from the keyboard. Do not forget to restore the colors to their original values.
Abra el proyecto BasicX de Wintempla > DirectX > Introduction y edite el archivo Triangle.cpp como se muestra. En este caso, usaremos la matriz de transformación world para mover el triángulo para arriba y para abajo cuando el usuario presiona las flechas de Arriba y Abajo en el teclado. No se olvide de reestablecer los colores a sus valores originales.

TranslateRun

Step A
Add a FLOAT variable to store the y position of the triangle by editing the Triangle.h file. Add also a function called Update to modify the position of the triangle using the transformation matrix world
Agregue una variable FLOAT para almacenar la posición y del triángulo editando el archivo Triangle.h. Agregué también una función llamada Update para modificar la posición del triángulo usando la matriz de transformación world.

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

Step B
Edite the Triangle.cpp file.
Editando el archivo Triangle.cpp.

Triangle.cpp
#include "stdafx.h"
#include "Triangle.h"

Triangle::Triangle()
{
     y = 0.0f;
     world = DirectX::XMMatrixIdentity();
     if (Setup(3, 3, D3D11_USAGE_DEFAULT, D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST) == false) return;
     . . .
}

Triangle::~Triangle()
{
}

void Triangle::Update(bool * keyboard, Sys::Stopwatch& stopWatch)
{
     const FLOAT delta = (FLOAT)stopWatch.GetSeconds();
     //________________________________________________________ 1. Translate
     DirectX::XMMATRIX translation;
     if (keyboard[VK_DOWN]) y -= (0.5f*delta);
     if (keyboard[VK_UP]) y += (0.5f*delta);
     world = DirectX::XMMatrixTranslation(0.0f, y, 0.0f);
}

Step C
Edite the BasicX.cpp file. When done, compile and run the program.
Editando el archivo BasicX.cpp. Cuando termine, compile y ejecute el programa.

BasicX.cpp
. . .
void BasicX::RenderScene()
{
     . . .
     //_________________________________________ 2. Render the triangle using the Color Shader
     triangle.Update(keyboard, stopWatch);
     triangle.Render(deviceContext);
     colorShader.Render(deviceContext, triangle.GetIndexCount(), triangle.world, camera);
}


Problem 2
Open the BasicX project of the previous problem, and edit the Triangle.cpp file as shown. In this case, we will use the transformation matrix world to rotate the triangle
Abra el proyecto BasicX del problema anterior y edite el archive Triangle.cpp como se muestra. En este caso, usaremos la matriz de transformación world para mover rotar el triángulo.

Step A
Add a FLOAT variable to store the angle around the axis y of the triangle by editing the Triangle.h file.
Agregue una variable FLOAT para almacenar el ángulo alrededor del eje y del triángulo editando el archivo Triangle.h.

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


Step B
Edite the Triangle.cpp file. When done, compile and run the program. You should be able to translate and rotate the triangle using the left arrow key and the right arrow key.
Editando el archivo Triangle.cpp. Cuando termine, compile y ejecute el programa. Usted debe poder trasladar y rotar el triángulo usando la tecla de la flecha a la izquierda y la techa de la flecha a la derecha.

Triangle.cpp
...
Triangle::Triangle()
{
     y = 0.0f;
     angleY = 0.0f;
     world = DirectX::XMMatrixIdentity();
     if (Setup(3, 3, D3D11_USAGE_DEFAULT, D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST) == false) return;
     . . .
}

void Triangle::Update(bool * keyboard, Sys::Stopwatch& stopWatch)
{
     const FLOAT delta = (FLOAT)stopWatch.GetSeconds();
     //________________________________________________________ 1. Translate
     DirectX::XMMATRIX translation;
     if (keyboard[VK_DOWN]) y -= (0.5f*delta);
     if (keyboard[VK_UP]) y += (0.5f*delta);
     translation = DirectX::XMMatrixTranslation(0.0f, y, 0.0f);
     //________________________________________________________ 2. Rotate
     DirectX::XMMATRIX rotation;
     if (keyboard[VK_RIGHT]) angleY -= (0.5f*delta);
     if (keyboard[VK_LEFT]) angleY += (0.5f*delta);
     rotation = DirectX::XMMatrixRotationY(angleY);
     //________________________________________________________ 3. Compute world matrix
     world = DirectX::XMMatrixMultiply(rotation, translation);
}


Step C
Edit the BasicX.cpp file, to change the culling mode to D3D11_CULL_NONE.
Edite el archivo BasicX.cpp, para cambie el modo culling a D3D11_CULL_NONE.

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();
     . . .
}


RotateRun

Problem 3
Open the BasicX project of the previous problem and change the color of the triangle to yellow as shown.
Abra el proyecto BasicX del problema anterior y cambie el color del triángulo a amarillo como se muestra.

YellowRun

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