Lighting


Diffuse Lighting

Diffuse lighting is a similar how the Sun illuminates the earth. In diffuse lighting, there se a light source located a great distance away from the objects in the scene. Diffuse lighting has a direction and a color.
La iluminación difusa es similar a cómo el Sol ilumina la tierra. En la iluminación difusa, hay una fuente de luz ubicada a una gran distancia de los objetos en la escena. La iluminación difusa tiene una dirección y un color.

Ambient Lighting

Ambient lighting is a similar to the general light that there is in a place. In ambient lighting, the walls, the ceiling and the floor reflect some amount of light and provide a constant light coming from all directions. Ambient lighting has a color.
La iluminación ambiental es semejante a la luz general que hay en un lugar. En iluminación ambiental, las paredes, el techo y el piso reflejan una cierta cantidad de luz y proporcionan una luz constante llegando de todas direcciones. La iluminación ambiental tiene un color.

Specular Lighting

Specular lighting is produced over shinning or polish surfaces like those in metal and ceramic. In specular lighting, the surface of an object may reflect a high amount of light in very specific parts of a 3D object depending on the position of the object as well as on the position of light source. The specular lighting has a color and an amount of power.
La iluminación especular es producida sobre superficies brillantes o pulidas como en aquellas de los metales o de las cerámicas. En la iluminación especular, la superficie de un objeto puede reflejar una cantidad alta de luz en partes muy específicas de un objeto 3D dependiendo de la posición del objeto así como también de la posición de la fuente de luz. La iluminación especular tiene un color y una cantidad de fuerza.

Shader

A shader is a program than runs in the GPU. A shader is written in High Level Shading Language (HLSL). The table below provides some information about the shaders of your project. You are welcome to inspect the classes that implement the shader as well as the HLSL files (the vertex shader VS*.hlsl and the pixel shader PS*.hlsl).
Un shader es un programa que corre en la GPU. Un shader está escrito en High Level Shading Language (HLSL). La tabla de abajo proporciona algo de información sobre los shaders de su proyecto. Usted puede inspeccionar las clases que implementan los shaders así como también los archivos HLSL (el shader de vértices VS*.hlsl y el shader de pixeles PS*.hlsl).

Wintempla Class    Objects with    Normal vector    Diffuse lighting    Ambient lighting    Specular lighting  
DX10::ColorShadercolorno requirednonono
DX10::ColorAmbientLightShadercolorrequiredyesyesno
DX10::ColorDiffuseLightShadercolorrequiredyesnono
DX10::ColorSpecularLightShadercolorrequiredyesyesyes
DX10::TextureShadertextureno requirednonono
DX10::TextureAmbientLightShadertexturerequiredyesyesno
DX10::TextureDiffuseLightShadertexturerequiredyesnono
DX10::TextureSpecularLightShadertexturerequiredyesyesyes

Tip
To know the IDs of the shaders in your project, you can use Resource View under the "BIN" folder as shown in the figure below.
Para conocer los IDs de los shaders en su proyecto, usted puede usar Resource View dentro de la carpeta de "BIN" cómo se muestra en la figura de abajo.

IDSL

Problem 1
Create a DirectX application using Wintempla called Cloud to test diffuse lighting in objects with solid colors. After creating the project, add a new class called Cube. The program will draw three cubes, starting on the left, the first cube has diffuse lighting, the second cube has ambient and diffuse lighting, while the last one has ambient, diffuse and specular lighting.
Cree una aplicación de DirectX usando Wintempla llamada Cloud para probar la iluminación difusa en objetos con colores sólidos. Después de crear el proyecto, agregue una clase nueva llamada Cube. El programa dibujará tres cubos, empezando en la izquierda, el primer cubo tiene iluminación difusa, el segundo cubo tiene luz ambiental y difusa, mientras que el último tiene iluminación ambiental, difusa y especular.

CloudRun1

CloudRun2

CloudRun3

Step A
Edit the Cloud.h file, include the Cube.h file at the top. Then, create an object array of the Cube class. At the top of the file define CUBE_COUNT with a value of three.
Edite el archivo SunX.h, incluya el archivo Cube.h en la parte de arriba, cree un arreglo de objetos de la clase Cube. En la parte superior del archivo defina CUBE_COUNT con un valor de tres.

Cloud.h
#pragma once //______________________________________ Cloud.h
#include "Resource.h"
#include "Cube.h"
#define CUBE_COUNT 3

class Cloud: public . . .
{
public:
     . . .
     //____________________________________________________ 1. Application
     Cube cube[CUBE_COUNT];
     . . .
};


Step B
Edit the Cloud.cpp file to set the direction of the light and the color of the cubes. Then, create the cubes, and finally, set the position of the cubes.
Edite el archivo Cloud.cpp, para fijar la dirección de la luz y el color de los cubos. Entonces, crear los cubos, y finalmente, fijar la posición de los cubos.

Cloud.cpp
. . .
void Cloud::Window_Open(Win::Event& e)
{
     const wchar_t* error = NULL;
     //________________________________________________________________ 1. Initialize device (D3D10_CULL_NONE, D3D10_CULL_FRONT)
     . . .
     //________________________________________________________________ 4. Setup the camera
     . . .
     //________________________________________________________________ 5. Setup the light
     light.SetDirection(-0.5f, -0.5f, 0.5f);
     //________________________________________________________________ 6. Create the cubes
     cube[0].SetColor(DirectX::XMFLOAT4(0.0f, 1.0f, 0.0f, 1.0f));
     cube[1].SetColor(DirectX::XMFLOAT4(1.0f, 0.0f, 0.0f, 1.0f));
     cube[2].SetColor(DirectX::XMFLOAT4(0.0f, 0.0f, 1.0f, 1.0f));
     for (unsigned int i = 0; i < CUBE_COUNT; i++)
     {
          if (cube[i].Create(hWnd, device) == false) break;
     }
     cube[0].x = 0.0f;
     cube[1].x = -1.8f;
     cube[2].x = 1.8f;
}

void Cloud::RenderScene()
{
     //________________________________________________ 1. Clear screen and camera update
     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[0].Update(keyboard, stopWatch);
     cube[0].Render(deviceContext);
     colorALShader.Render(deviceContext, cube[0].GetIndexCount(), cube[0].world, camera, light);
     //
     cube[1].Update(keyboard, stopWatch);
     cube[1].Render(deviceContext);
     colorDLShader.Render(deviceContext, cube[1].GetIndexCount(), cube[1].world, camera, light);
     //
     cube[2].Update(keyboard, stopWatch);
     cube[2].Render(deviceContext);
     colorSLShader.Render(deviceContext, cube[2].GetIndexCount(), cube[2].world, camera, light);
}


Step C
Edit the files Cube.h and Cube.cpp as shown. Observe that the lighting requires the normal vector for each vertex.
Edite los archivos Cube.h and Cube.cpp como se muestra. Observe que la iluminación requiere el vector normal por cada vértice.

Cube.h
#pragma once

class Cube : public DX11::ColorNormVertexBuffer
{
public:
     Cube();
     ~Cube();
     FLOAT x;
     FLOAT y;
     FLOAT z;
     DirectX::XMMATRIX world;
     DirectX::XMMATRIX scale;
     void SetColor(DirectX::XMFLOAT4 color);
     void Update(bool * keyboard, Sys::Stopwatch& stopWatch);
private:
     FLOAT angleY;
};


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

Cube::Cube()
{
     //_______________________________________________________________________ 1. Initialize member variables
     world = DirectX::XMMatrixIdentity();
     scale = DirectX::XMMatrixScaling(0.6f, 0.6f, 0.6f);
     x = 0.0f;
     y = 0.0f;
     y = 0.0f;
     angleY = 0.0f;
}

Cube::~Cube()
{
}

void Cube::SetColor(DirectX::XMFLOAT4 color)
{
     //_______________________________________________________________________ 1. Create
     const unsigned int indexCount = DX11::Cube::GetIndexCount();
     const unsigned int vertexCount = DX11::Cube::GetVertexCount();
     if (Setup(indexCount, vertexCount, D3D11_USAGE_DEFAULT, D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP) == false) return;
     //_______________________________________________________________________ 2. Vertex setup
     vector<DX11::ColorNormVertex> vx;
     DX11::Cube::GetVertex(color, color, color, color, color, color, vx);
     for(size_t i = 0; i < vx.size(); i++) vertex[i] = vx[i];
     //_______________________________________________________________________ 3. Index setup
     vector<unsigned int> idx;
     DX11::Cube::GetIndex(idx);
     for(size_t i = 0; i < idx.size(); i++) index[i] = idx[i];
}

void Cube::Update(bool * keyboard, Sys::Stopwatch& stopWatch)
{
     const FLOAT delta = (FLOAT)stopWatch.GetSeconds();
     //________________________________________________________ 1. Rotate, translate and scale
     angleY += (0.5f*delta);
     world = DirectX::XMMatrixRotationY(angleY);
     DirectX::XMMATRIX translation = DirectX::XMMatrixTranslation(x, y, z);
     world = DirectX::XMMatrixMultiply(world, translation);
     world = DirectX::XMMatrixMultiply(scale, world);
     if (angleY > DirectX::XM_2PI) angleY -= DirectX::XM_2PI;
}


Problem 2
Create a DirectX application using Wintempla called SunX to test diffuse lighting on objects with textures. After creating the project, add a new class called TexCube. For this exercise, we will need a bitmap uncompressed with 32 bits or a GIF. The program will draw three cubes, starting on the left, the first cube has diffused lighting, the second cube has ambient and diffuse lighting, while the last one has ambient, diffused and specular lighting.
Cree una aplicación de DirectX usando Wintempla llamada SunX para probar la iluminación difusa en objetos con texturas. Después de crear el proyecto, agregue una clase nueva llamada TexCube. Para este ejercicio, nosotros necesitaremos un bitmap sin comprimir de 32 bits o un GIF. El programa dibujará tres cubos, empezando en la izquierda, el primer cubo tiene iluminación difusa, el segundo cubo tiene luz ambiental y difusa, mientras que el último tiene iluminación ambiental, difusa y especular.

SunXRun1

SunXRun2

SunXRun3

SunXRun4

Step A
Edit the SunX.h file, include the TexCube.h file at the top. Then, create an object array of the TexCube class and one object of the DX10::Texture class. At the top of the file define CUBE_COUNT with a value of three.
Edite el archivo SunX.h, incluya el archivo TexCube.h en la parte de arriba, cree un arreglo de objetos de la clase TexCube y un objeto de la clase DX10::Texture. En la parte superior del archivo defina CUBE_COUNT con un valor de tres.

SunX.h
#pragma once //______________________________________ SunX.h
#include "Resource.h"
#include "TexCube.h"
#define CUBE_COUNT 3

class SunX: public . . .
{
public:
     . . .
     //____________________________________________________ 1. Application
     TexCube cube[CUBE_COUNT];
     DX11::Texture texture;
     . . .
};


Step B
Edit the SunX.cpp file, to set the direction of the light, create the texture cube and the texture. And finally, to set the position of the cubes.
Edite el archivo SunX.cpp, para fijar la dirección de la luz, crear el cubo de textura y la textura. Y finalmente para fijar la posición de los cubos

SunX.cpp
void SunX::Window_Open(Win::Event& e)
{
     . . .
     //________________________________________________________________ 5. Setup the light
     light.SetDirection(-0.5f, -0.5f, 0.5f);
     //________________________________________________________________ 6. Load the texture and create the cubes
     error = texture.Create(device, deviceContext, L"floor.bmp", 1, 0);
     if (error != NULL) this->MessageBox(error, L"Skin", MB_OK | MB_ICONERROR);
     for (unsigned int i = 0; i < CUBE_COUNT; i++)
     {
          if (cube[i].Create(hWnd, device) == false) break;
     }
     cube[0].x = 0.0f;
     cube[1].x = -1.8f;
     cube[2].x = 1.8f;
}

void SunX::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[0].Update(keyboard, stopWatch);
     cube[0].Render(deviceContext);
     textuALShader.Render(deviceContext, cube[0].GetIndexCount(), cube[0].world, camera, texture.resView, light);
     //
     cube[1].Update(keyboard, stopWatch);
     cube[1].Render(deviceContext);
     textuDLShader.Render(deviceContext, cube[1].GetIndexCount(), cube[1].world, camera, texture.resView, light);
     //
     cube[2].Update(keyboard, stopWatch);
     cube[2].Render(deviceContext);
     textuSLShader.Render(deviceContext, cube[2].GetIndexCount(), cube[2].world, camera, texture.resView, light);
}


Step C
Edit the files TexCube.h and TexCube.cpp as shown. Observe that the lighting requires the normal vector for each vertex. Be sure to set the stride and the PRIMITIVE_TOPOLOGY on the render function of the cube.
Edite los archivos TexCube.h and TexCube.cpp como se muestra. Observe que la iluminación requiere el vector normal por cada vértice. Asegúrese de fijar el stride y el PRIMITIVE_TOPOLOGY en la función de renderizado del cubo.

TexCube.h
#pragma once

class TexCube : public DX11::TextureNormVertexBuffer
{
public:
     TexCube();
     ~TexCube();
     FLOAT x;
     FLOAT y;
     FLOAT z;
     FLOAT angleY;
     DirectX::XMMATRIX world;
     DirectX::XMMATRIX scale;
     void Update(bool * keyboard, Sys::Stopwatch& stopWatch);
};



TexCube.cpp
#include "stdafx.h"
#include "TexCube.h"

TexCube::TexCube()
{
     //_______________________________________________________________________ 1. Initialize member variables
     world = DirectX::XMMatrixIdentity();
     scale = DirectX::XMMatrixScaling(0.6f, 0.6f, 0.6f);
     x = 0.0f;
     y = 0.0f;
     y = 0.0f;
     angleY = 0.0f;
     //_______________________________________________________________________ 2. Create
     const unsigned int indexCount = DX11::Cube::GetIndexCount();
     const unsigned int vertexCount = DX11::Cube::GetVertexCount();
     if (Setup(indexCount, vertexCount, D3D11_USAGE_DEFAULT, D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP) == false) return;
     //_______________________________________________________________________ 3. Vertex setup
     vector<DX11::TextureNormVertex> vx;
     DX11::Cube::GetVertex(vx);
     for(size_t i = 0; i < vx.size(); i++) vertex[i] = vx[i];
     //_______________________________________________________________________ 4. Index setup
     vector<unsigned int> idx;
     DX11::Cube::GetIndex(idx);
     for(size_t i = 0; i < idx.size(); i++) index[i] = idx[i];
}

TexCube::~TexCube()
{
}

void TexCube::Update(bool * keyboard, Sys::Stopwatch& stopWatch)
{
     const FLOAT delta = (FLOAT)stopWatch.GetSeconds();
     //________________________________________________________ 1. Rotate, translate and scale
     angleY += (0.5f*delta);
     world = DirectX::XMMatrixRotationY(angleY);
     DirectX::XMMATRIX translation = DirectX::XMMatrixTranslation(x, y, z);
     world = DirectX::XMMatrixMultiply(world, translation);
     world = DirectX::XMMatrixMultiply(scale, world);
     if (angleY > DirectX::XM_2PI) angleY -= DirectX::XM_2PI;
}


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