#ifndef _modelo
#define _modelo
//#define _XM_NO_INTRINSICS_
#include <d3d11.h>
#include <d3dx11.h>
#include <DxErr.h>
#include <D3Dcompiler.h>
#include <d3dx10math.h>
#include <conio.h>
#include <vector>
#include <iostream>
#include "loadModel.h"
using namespace std;
class ModeloRR {
private:
struct VertexComponent
{
D3DXVECTOR3 pos;
D3DXVECTOR2 UV;
D3DXVECTOR3 normal;
};
struct VertexCollide
{
D3DXVECTOR3 pos;
};
struct vector3 {
float x, y, z;
};
struct vector2 {
float u, v;
};
ID3D11VertexShader* VertexShaderVS;
ID3D11PixelShader* solidColorPS;
ID3D11InputLayout* inputLayout;
ID3D11Buffer* vertexBuffer;
ID3D11Buffer* indexBuffer;
ID3D11ShaderResourceView* colorMap;
ID3D11ShaderResourceView* specMap;
ID3D11SamplerState* colorMapSampler;
ID3D11Buffer* viewCB;
ID3D11Buffer* projCB;
ID3D11Buffer* worldCB;
D3DXMATRIX viewMatrix;
D3DXMATRIX projMatrix;
ID3D11Buffer* cameraPosCB;
XMFLOAT3 camPos;
ID3D11Buffer* specForceCB;
float specForce;
int ancho, alto;
int anchoTexTerr, altoTexTerr;
float anchof, altof;
float deltax, deltay;
ID3D11Device* d3dDevice;
ID3D11DeviceContext* d3dContext;
CObjParser m_ObjParser;
float posX;
float posZ;
//////////
// matriz para rotacion de la camara
//////////
D3DXVECTOR3 rotCam;
//Variables para colision
float collision[3];
public:
ModeloRR(ID3D11Device* D3DDevice, ID3D11DeviceContext* D3DContext, char*
ModelPath, WCHAR* colorTexturePath, WCHAR* specularTexturePath, float _posX, float
_posZ)
{
//copiamos el device y el device context a la clase terreno
d3dContext = D3DContext;
d3dDevice = D3DDevice;
posX = _posX;
posZ = _posZ;
//aqui cargamos las texturas de alturas y el cesped
CargaParametros(ModelPath, colorTexturePath,
specularTexturePath);//L"Assets/Tent-Tower/tent_diffuse.jpg"
}
~ModeloRR()
{
//libera recursos
UnloadContent();
}
float getPosX() {
return this->posX;
}
float getPosZ() {
return this->posZ;
}
//COLISIONES
float* getCollisionSphere(float radio) {
collision[0] = posX;
collision[1] = posZ;
collision[2] = radio;
return collision;
}
//////////
// funciones set X y Z
//////////
void setPosX(float posX) {
this->posX = posX;
}
void setPosZ(float posZ) {
this->posZ = posZ;
}
//////////
// funcion rotacion de la camara
//////////
void setRotCamp(D3DXVECTOR3 rotCam) {
this->rotCam = rotCam;
}
bool CompileD3DShader(WCHAR* filePath, char* entry, char* shaderModel,
ID3DBlob** buffer)
{
//forma de compilar el shader
DWORD shaderFlags = D3DCOMPILE_ENABLE_STRICTNESS;
ID3DBlob* errorBuffer = 0;
HRESULT result;
result = D3DX11CompileFromFile(filePath, 0, 0, entry, shaderModel,
shaderFlags,
0, 0, buffer, &errorBuffer, 0);
if (FAILED(result))
{
if (errorBuffer != 0)
{
OutputDebugStringA((char*)errorBuffer->GetBufferPointer());
errorBuffer->Release();
}
return false;
}
if (errorBuffer != 0)
errorBuffer->Release();
return true;
}
bool CargaParametros(char* ModelPath, WCHAR* diffuseTex, WCHAR* specularTex)
{
HRESULT d3dResult;
ID3DBlob* vsBuffer = 0;
//cargamos el shaders de vertices que esta contenido en el Shader.fx,
note
//que VS_Main es el nombre del vertex shader en el shader, vsBuffer
contendra
//al puntero del mismo
bool compileResult = CompileD3DShader(L"Modelo.fx", "VS_Main",
"vs_4_0", &vsBuffer);
//en caso de no poder cargarse ahi muere la cosa
if (compileResult == false)
{
return false;
}
//aloja al shader en la memeoria del gpu o el cpu
d3dResult = d3dDevice->CreateVertexShader(vsBuffer->GetBufferPointer(),
vsBuffer->GetBufferSize(), 0, &VertexShaderVS);
//en caso de falla sale
if (FAILED(d3dResult))
{
if (vsBuffer)
vsBuffer->Release();
return false;
}
//lo nuevo, antes creabamos una estructura con la definicion del
vertice, ahora creamos un mapa o layout
//de como queremos construir al vertice, esto es la definicion
D3D11_INPUT_ELEMENT_DESC solidColorLayout[] =
{
{ "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0,
D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT, 0,
D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "NORMAL", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0,
D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_VERTEX_DATA, 0},
};
unsigned int totalLayoutElements = ARRAYSIZE(solidColorLayout);
d3dResult = d3dDevice->CreateInputLayout(solidColorLayout,
totalLayoutElements,
vsBuffer->GetBufferPointer(), vsBuffer->GetBufferSize(),
&inputLayout);
vsBuffer->Release();
if (FAILED(d3dResult))
{
return false;
}
ID3DBlob* psBuffer = 0;
// de los vertices pasamos al pixel shader, note que el nombre del
shader es el mismo
//ahora buscamos al pixel shader llamado PS_Main
compileResult = CompileD3DShader(L"Modelo.fx", "PS_Main", "ps_4_0",
&psBuffer);
if (compileResult == false)
{
return false;
}
//ya compilado y sin error lo ponemos en la memoria
d3dResult = d3dDevice->CreatePixelShader(psBuffer->GetBufferPointer(),
psBuffer->GetBufferSize(), 0, &solidColorPS);
psBuffer->Release();
if (FAILED(d3dResult))
{
return false;
}
//aqui va la carga del modelo con el metodo creadoModelPath
m_ObjParser.LoadFile(ModelPath); //"Assets/Tent-Tower/Tienda-Top.obj"
//proceso de guardar el buffer de vertices para su uso en el render
D3D11_BUFFER_DESC vertexDesc;
ZeroMemory(&vertexDesc, sizeof(vertexDesc));
vertexDesc.Usage = D3D11_USAGE_DEFAULT;
vertexDesc.BindFlags = D3D11_BIND_VERTEX_BUFFER;
vertexDesc.ByteWidth = sizeof(VertexObj) * m_ObjParser.m_nVertexCount;
D3D11_SUBRESOURCE_DATA resourceData;
ZeroMemory(&resourceData, sizeof(resourceData));
resourceData.pSysMem = m_ObjParser.m_pVertex;
d3dResult = d3dDevice->CreateBuffer(&vertexDesc, &resourceData,
&vertexBuffer);
if (FAILED(d3dResult))
{
MessageBox(0, L"Error", L"Error al crear vertex buffer", MB_OK);
return false;
}
//crea los accesos de las texturas para los shaders
d3dResult = D3DX11CreateShaderResourceViewFromFile(d3dDevice,
diffuseTex, 0, 0, &colorMap, 0);
d3dResult = D3DX11CreateShaderResourceViewFromFile(d3dDevice,
specularTex, 0, 0, &specMap, 0);
if (FAILED(d3dResult))
{
return false;
}
//aqui creamos el sampler
D3D11_SAMPLER_DESC colorMapDesc;
ZeroMemory(&colorMapDesc, sizeof(colorMapDesc));
colorMapDesc.AddressU = D3D11_TEXTURE_ADDRESS_WRAP;
colorMapDesc.AddressV = D3D11_TEXTURE_ADDRESS_WRAP;
colorMapDesc.AddressW = D3D11_TEXTURE_ADDRESS_WRAP;
colorMapDesc.ComparisonFunc = D3D11_COMPARISON_NEVER;
colorMapDesc.Filter = D3D11_FILTER_MIN_MAG_MIP_LINEAR;
colorMapDesc.MaxLOD = D3D11_FLOAT32_MAX;
//con la estructura de descripion creamos el sampler
d3dResult = d3dDevice->CreateSamplerState(&colorMapDesc,
&colorMapSampler);
if (FAILED(d3dResult))
{
return false;
}
//creamos los buffers para el shader para poder pasarle las matrices
D3D11_BUFFER_DESC constDesc;
ZeroMemory(&constDesc, sizeof(constDesc));
constDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
constDesc.ByteWidth = sizeof(D3DXMATRIX);
constDesc.Usage = D3D11_USAGE_DEFAULT;
//de vista
d3dResult = d3dDevice->CreateBuffer(&constDesc, 0, &viewCB);
if (FAILED(d3dResult))
{
return false;
}
//de proyeccion
d3dResult = d3dDevice->CreateBuffer(&constDesc, 0, &projCB);
if (FAILED(d3dResult))
{
return false;
}
//de mundo
d3dResult = d3dDevice->CreateBuffer(&constDesc, 0, &worldCB);
if (FAILED(d3dResult))
{
return false;
}
constDesc.ByteWidth = sizeof(XMFLOAT4);
d3dResult = d3dDevice->CreateBuffer(&constDesc, 0, &cameraPosCB);
d3dResult = d3dDevice->CreateBuffer(&constDesc, 0, &specForceCB);
if (FAILED(d3dResult))
{
return false;
}
//posicion de la camara
D3DXVECTOR3 eye = D3DXVECTOR3(0.0f, 100.0f, 200.0f);
//a donde ve
D3DXVECTOR3 target = D3DXVECTOR3(0.0f, 0.0f, 0.0f);
D3DXVECTOR3 up = D3DXVECTOR3(0.0f, 1.0f, 0.0f);
//crea la matriz de vista
D3DXMatrixLookAtLH(&viewMatrix, &eye, &target, &up);
//la de proyeccion
D3DXMatrixPerspectiveFovLH(&projMatrix, D3DX_PI / 4.0, ancho / alto,
0.01f, 1000.0f);
//las transpone para acelerar la multiplicacion
D3DXMatrixTranspose(&viewMatrix, &viewMatrix);
D3DXMatrixTranspose(&projMatrix, &projMatrix);
return true;
}
bool UnloadContent()
{
if (colorMapSampler)
colorMapSampler->Release();
if (colorMap)
colorMap->Release();
if (specMap)
specMap->Release();
if (VertexShaderVS)
VertexShaderVS->Release();
if (solidColorPS)
solidColorPS->Release();
if (inputLayout)
inputLayout->Release();
if (vertexBuffer)
vertexBuffer->Release();
if (viewCB)
viewCB->Release();
if (projCB)
projCB->Release();
if (worldCB)
worldCB->Release();
if (cameraPosCB)
cameraPosCB->Release();
if (specForceCB)
specForceCB->Release();
colorMapSampler = 0;
colorMap = 0;
specMap = 0;
VertexShaderVS = 0;
solidColorPS = 0;
inputLayout = 0;
vertexBuffer = 0;
indexBuffer = 0;
viewCB = 0;
projCB = 0;
worldCB = 0;
cameraPosCB = 0;
specForceCB = 0;
}
void Update(float dt)
{
void Draw(D3DXMATRIX vista, D3DXMATRIX proyeccion, float ypos, D3DXVECTOR3
posCam, float specForce, float rot, char angle, float scale, bool tipoCamara, bool
movCam)
//////////
// nuevas variables tipoCamara
//////////
{
static float rotation = 0.0f;
rotation += 0.01;
//paso de datos, es decir cuanto es el ancho de la estructura
unsigned int stride = sizeof(VertexObj);
unsigned int offset = 0;
camPos.x = posCam.x;
camPos.y = posCam.y;
camPos.z = posCam.z;
//define la estructura del vertice a traves de layout
d3dContext->IASetInputLayout(inputLayout);
//define con que buffer trabajara
d3dContext->IASetVertexBuffers(0, 1, &vertexBuffer, &stride, &offset);
//define la forma de conexion de los vertices
d3dContext-
>IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
//Establece el vertex y pixel shader que utilizara
d3dContext->VSSetShader(VertexShaderVS, 0, 0);
d3dContext->PSSetShader(solidColorPS, 0, 0);
//pasa lo sbuffers al shader
d3dContext->PSSetShaderResources(0, 1, &colorMap);
d3dContext->PSSetShaderResources(1, 1, &specMap);
d3dContext->PSSetSamplers(0, 1, &colorMapSampler);
//////////
// separar de la camara cuando es tercera persona
//////////
D3DXMATRIX translationRotCam;
if (tipoCamara) {
D3DXMatrixTranslation(&translationRotCam, 0.0, 0.0, -0.4);
}
else {
D3DXMatrixTranslation(&translationRotCam, 0.0, 0.0, 0.0);
}
//Rotar alrededor de la camara
D3DXMATRIX rotationMat;
D3DXMatrixRotationYawPitchRoll(&rotationMat, 0.0f, 0.0f, 0.0f);
D3DXMATRIX translationMat;
D3DXMatrixTranslation(&translationMat, posX, ypos, posZ);
if (angle == 'X')
D3DXMatrixRotationX(&rotationMat, rot);
else if (angle == 'Y')
D3DXMatrixRotationY(&rotationMat, rot);
else if (angle == 'Z')
D3DXMatrixRotationZ(&rotationMat, rot);
viewMatrix *= rotationMat;
//////////
// Mover a donde esta la camara
//////////
//D3DMATRIX translationMat;
//D3DXMatrixTranslation(&translationMat, posX, ypos, posZ);
D3DXMATRIX scaleMat;
D3DXMatrixScaling(&scaleMat, scale, scale, scale); //SACALA NORMAL 1
PERO SE PUEDE ESCALAR
//validar movacam
D3DXMATRIX worldMat;
if (movCam) {
worldMat = rotationMat * scaleMat * translationMat *
translationRotCam;
}
else {
worldMat = rotationMat * scaleMat * translationMat;
}
//D3DXMATRIX worldMat = rotationMat * scaleMat * translationMat;
D3DXMatrixTranspose(&worldMat, &worldMat);
//actualiza los buffers del shader
d3dContext->UpdateSubresource(worldCB, 0, 0, &worldMat, 0, 0);
d3dContext->UpdateSubresource(viewCB, 0, 0, &vista, 0, 0);
d3dContext->UpdateSubresource(projCB, 0, 0, &proyeccion, 0, 0);
d3dContext->UpdateSubresource(cameraPosCB, 0, 0, &camPos, 0, 0);
d3dContext->UpdateSubresource(specForceCB, 0, 0, &specForce, 0, 0);
//le pasa al shader los buffers
d3dContext->VSSetConstantBuffers(0, 1, &worldCB);
d3dContext->VSSetConstantBuffers(1, 1, &viewCB);
d3dContext->VSSetConstantBuffers(2, 1, &projCB);
d3dContext->VSSetConstantBuffers(3, 1, &cameraPosCB);
d3dContext->VSSetConstantBuffers(4, 1, &specForceCB);
//cantidad de trabajos
d3dContext->Draw(m_ObjParser.m_nVertexCount, 0);
}
};
#endif
