49. obj文件读数据并渲染的演示程序
token.h
#ifndef _UGP_TOKEN_H_
#define _UGP_TOKEN_H_
class CToken
{
public:
CToken() : m_length(0), m_startIndex(0), m_endIndex(0), m_data(0) {}
~CToken() { Shutdown(); }
void Reset(){ m_startIndex = m_endIndex = 0; }
void SetTokenStream(char *data);
bool GetNextToken(char *buffer);
bool GetNextToken(char *token, char *buffer);
bool MoveToNextLine(char *buffer);
void Shutdown();
private:
int m_length;
int m_startIndex, m_endIndex;
char *m_data;
};
#endif
token.cpp
#include<string.h>
#include"Token.h"
bool isValidIdentifier(char c)
{
// It is valid if it falls within one of these ranges.
if((c >= '0' && c <= '9') || (c >= 'a' && c <= 'z') ||
(c >= 'A' && c <= 'Z') || c == '_' || c =='"' || c =='/' ||
c =='(' || c ==')' || c =='-' || c=='.')
return true;
return false;
}
void CToken::SetTokenStream(char *data)
{
Shutdown();
m_length = strlen(data);
m_data = new char[(m_length + 1) * sizeof(char)];
strcpy(m_data, data);
m_data[m_length] = '\0';
}
bool CToken::GetNextToken(char *buffer)
{
bool inString = false;
m_startIndex = m_endIndex;
if(buffer) buffer[0] = '\0';
while(m_startIndex < m_length && ((m_data[m_startIndex] == ' ' || m_data[m_startIndex] == '\t') ||
inString))
{
if(m_data[m_startIndex] == '"') inString = !inString;
m_startIndex++;
}
m_endIndex = m_startIndex + 1;
if(m_startIndex < m_length)
{
bool valid = true;
if(isValidIdentifier(m_data[m_startIndex]))
while(isValidIdentifier(m_data[m_endIndex]) || m_data[m_endIndex] == '.') m_endIndex++;
else valid = false;
if(buffer != NULL)
{
if(valid)
{
strncpy(buffer, m_data + m_startIndex, m_endIndex - m_startIndex);
buffer[m_endIndex - m_startIndex] = '\0';
if(strcmp(buffer, "\n") == 0) buffer[0] = '\0';
}
else buffer[0] = '\0';
}
return true;
}
return false;
}
bool CToken::GetNextToken(char *token, char *buffer)
{
char tok[256];
while(GetNextToken(tok))
if(stricmp(tok, token) == 0) return GetNextToken(buffer);
return false;
}
bool CToken::MoveToNextLine(char *buffer)
{
if(m_startIndex < m_length && m_endIndex < m_length)
{
m_startIndex = m_endIndex;
while(m_endIndex < m_length && (m_data[m_endIndex] != '\n' &&
m_data[m_endIndex] != '\r' && m_data[m_endIndex] != '\0')) m_endIndex++;
if(m_endIndex - m_startIndex >= 511) return false;
if(buffer != NULL)
{
strncpy(buffer, m_data + m_startIndex, m_endIndex - m_startIndex);
buffer[m_endIndex - m_startIndex] = '\0';
}
}
else
return false;
return true;
}
void CToken::Shutdown()
{
if(m_data) delete[] m_data;
m_data = NULL;
m_length = m_startIndex = m_endIndex = 0;
}
objLoader.h
#ifndef _OBJ_LOADER_H_
#define _OBJ_LOADER_H_
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include"Token.h"
// Pretty straight forward don't you think?
struct stObjModel
{
float *vertices;
float *normals;
float *texCoords;
int numFaces;
};
stObjModel *LoadOBJModel(char *fileName);
void FreeModel(stObjModel *model);
////////////////////////////////////////////////////////// hkx add//////////////////////////////////////
#include <vector>
#include <fstream>
#include <iostream>
// 顶点， 法线顶点
struct vertex
{
vertex(float x = 0, float y = 0, float z = 0):m_x(x), m_y(y), m_z(z){}
float m_x;
float m_y;
float m_z;
};
// 纹理坐标顶点
struct texVertex
{
texVertex(float x = 0, float y = 0):m_u(x), m_v(y) {}
float m_u;
float m_v;
};
// 面；三角形，里面存的顶点的索引
struct face
{
int m_vertexIndex1;
int m_vertexIndex2;
int m_vertexIndex3;
int m_texVertexIndex1;
int m_texVertexIndex2;
int m_texVertexIndex3;
int m_normalVertexIndex1;
int m_normalVertexIndex2;
int m_normalVertexIndex3;
};
// obj文件存的所有内容
struct ObjModel
{
std::vector<vertex> m_vecVertex; // 顶点数组
std::vector<vertex> m_vecNormalVertex; // 法线坐标顶点数组
std::vector<texVertex> m_vecTexVertex; // 纹理坐标顶点数组
int m_nFaces; // 三角形的个数
};
class CObjModelManager
{
public:
static CObjModelManager& GetSingleton()
{
static CObjModelManager manager;
return manager;
}
static void CloseSingleton()
{
}
void LoadObjModel(char *fileName)
{
m_vecObjModel.clear();
std::ifstream ifs;
ifs.open(fileName);
if (ifs.fail())
return;
int tmp = ifs.tellg();
ifs.seekg(0, std::ios_base::end);
int size = ifs.tellg();
ifs.seekg(tmp);
char* data = 0;
data = new char[(size + 1) * sizeof(char)];
if(!data)
return;
ifs.read(data, size);
data[size] = '\0';
ifs.close();
CToken lexer, tempLex;
char tempLine[512];
char token[512];
lexer.SetTokenStream(data);
delete[] data; data = 0;
bool validFile = false;
while(lexer.GetNextToken(token))
{
if(strcmp(token, "Wavefront") == 0)
{
validFile = true;
break;
}
}
if(!validFile) return;
lexer.Reset();
ObjModel obj;
std::vector<vertex> tempVecVertex;
std::vector<vertex> tempNormalVertex;
std::vector<texVertex> tempVectexVertex;
std::vector<face> vecFaces;
vertex vert;
vertex normalvert;
texVertex texvert;
while(lexer.MoveToNextLine(tempLine))
{
tempLex.SetTokenStream(tempLine);
lexer.GetNextToken(NULL);
if(!tempLex.GetNextToken(token)) continue;
if(strcmp(token, "v") == 0)
{
tempLex.GetNextToken(token);
vert.m_x = (float)atof(token);
tempLex.GetNextToken(token);
vert.m_y = (float)atof(token);
tempLex.GetNextToken(token);
vert.m_z = (float)atof(token);
tempVecVertex.push_back(vert);
}
else if(strcmp(token, "vn") == 0)
{
tempLex.GetNextToken(token);
normalvert.m_x = (float)atof(token);
tempLex.GetNextToken(token);
normalvert.m_y = (float)atof(token);
tempLex.GetNextToken(token);
normalvert.m_z = (float)atof(token);
tempNormalVertex.push_back(normalvert);
}
else if(strcmp(token, "vt") == 0)
{
tempLex.GetNextToken(token);
texvert.m_u = (float)atof(token);
tempLex.GetNextToken(token);
texvert.m_v = (float)atof(token);
tempVectexVertex.push_back(texvert);
}
else if(strcmp(token, "f") == 0)
{
face f;
for(int i = 0; i < 3; i++)
{
tempLex.GetNextToken(token);
if(i == 0)
sscanf_s(token, "%d/%d/%d", &(f.m_vertexIndex1),
&(f.m_texVertexIndex1), &(f.m_normalVertexIndex1));
else if (i == 1)
sscanf_s(token, "%d/%d/%d", &(f.m_vertexIndex2),
&(f.m_texVertexIndex2), &(f.m_normalVertexIndex2));
else
sscanf_s(token, "%d/%d/%d", &(f.m_vertexIndex3),
&(f.m_texVertexIndex3), &(f.m_normalVertexIndex3));
}//for
vecFaces.push_back(f);
}
token[0] = '\0';
}
// No longer need.
lexer.Shutdown();
obj.m_nFaces = vecFaces.size();
for (int i=0; i<vecFaces.size(); ++i)
{
obj.m_vecVertex.push_back(tempVecVertex[vecFaces[i].m_vertexIndex1 - 1]);
obj.m_vecVertex.push_back(tempVecVertex[vecFaces[i].m_vertexIndex2 - 1]);
obj.m_vecVertex.push_back(tempVecVertex[vecFaces[i].m_vertexIndex3 - 1]);
obj.m_vecTexVertex.push_back(tempVectexVertex[vecFaces[i].m_texVertexIndex1 - 1]);
obj.m_vecTexVertex.push_back(tempVectexVertex[vecFaces[i].m_texVertexIndex2 - 1]);
obj.m_vecTexVertex.push_back(tempVectexVertex[vecFaces[i].m_texVertexIndex3 - 1]);
obj.m_vecNormalVertex.push_back(tempNormalVertex[vecFaces[i].m_normalVertexIndex1 - 1]);
obj.m_vecNormalVertex.push_back(tempNormalVertex[vecFaces[i].m_normalVertexIndex2 - 1]);
obj.m_vecNormalVertex.push_back(tempNormalVertex[vecFaces[i].m_normalVertexIndex3 - 1]);
}
m_vecObjModel.push_back(obj);
}
std::vector<ObjModel> m_vecObjModel;
};
////////////////////////////////////////////////////////////////////////////////////////////////////////////
#endif
objLoader.cpp
#include"objLoader.h"
stObjModel *LoadOBJModel(char *fileName)
{
FILE *file;
char *data = NULL;
CToken lexer, tempLex;
char tempLine[512];
char token[512];
// Open file for input.
file = fopen(fileName, "r");
if(!file) return NULL;
// Get the length of the file.
fseek(file, 0, SEEK_END);
int length = ftell(file);
fseek(file, 0, SEEK_SET);
// Read in all data from the file.
data = new char[(length + 1) * sizeof(char)];
if(!data) return NULL;
fread(data, length, 1, file);
data[length] = '\0';
// Close the file when we are done.
fclose(file);
// Set our file to our lexer.
lexer.SetTokenStream(data);
// No longer need.
delete[] data; data = NULL;
bool validFile = false;
// Look for the word Wavefront somewhere in the file to
// determine if this .obj is compatiable since so modelers export
// to slightly different formats.
while(lexer.GetNextToken(token))
{
if(strcmp(token, "Wavefront") == 0)
{
validFile = true;
break;
}
}
if(!validFile) return NULL;
// Reset for next pass.
lexer.Reset();
// Used to get the total number of each declared in a file.
// Since faces uses indices these number could be different.
int totalVertices = 0, totalNormals = 0,
totalTexC = 0, totalFaces = 0;
// Get the first (or next) line.
while(lexer.MoveToNextLine(tempLine))
{
// Set line to the temp lexer.
tempLex.SetTokenStream(tempLine);
// Read the new line character.
lexer.GetNextToken(NULL);
// If something was set to the temp lex then we keep going.
if(!tempLex.GetNextToken(token)) continue;
// If the first token of the line is a v, vn, vt, or f
// increment the respective counter.
if(strcmp(token, "v") == 0) totalVertices++;
else if(strcmp(token, "vn") == 0) totalNormals++;
else if(strcmp(token, "vt") == 0) totalTexC++;
else if(strcmp(token, "f") == 0) totalFaces++; // f开头的代表一个三角形，也就是一个面
token[0] = '\0';
}
// Allocate temp space to hold the data. Face are by 9 since there are
// 3 vertices each with 3 values (v index/vt index/vn index).
float *verts = new float[totalVertices * 3];
float *norms = new float[totalNormals * 3];
float *texC = new float[totalTexC * 2];
int *faces = new int[totalFaces * 9]; //一个三角形有三个顶点，每个顶点三个坐标
int vIndex = 0, nIndex = 0, tIndex = 0, fIndex = 0, index = 0;
// Move to the beginning of the file.
lexer.Reset();
// 记录faces数组中索引的总数
int facesArraySize = 0;
// Do it all again but this time we get the data.
while(lexer.MoveToNextLine(tempLine))
{
// Set to temp lex, read past newline, get token.
tempLex.SetTokenStream(tempLine);
lexer.GetNextToken(NULL);
if(!tempLex.GetNextToken(token)) continue;
// If v then we get the vertex x, y, z.
if(strcmp(token, "v") == 0)
{
// Get the x and save it.
tempLex.GetNextToken(token);
verts[vIndex] = (float)atof(token);
vIndex++;
// Get the y and save it.
tempLex.GetNextToken(token);
verts[vIndex] = (float)atof(token);
vIndex++;
// Get the z and save it.
tempLex.GetNextToken(token);
verts[vIndex] = (float)atof(token);
vIndex++;
}
// Else If vn then we get the normal x, y, z.
else if(strcmp(token, "vn") == 0)
{
// Get the x and save it.
tempLex.GetNextToken(token);
norms[nIndex] = (float)atof(token);
nIndex++;
// Get the y and save it.
tempLex.GetNextToken(token);
norms[nIndex] = (float)atof(token);
nIndex++;
// Get the z and save it.
tempLex.GetNextToken(token);
norms[nIndex] = (float)atof(token);
nIndex++;
}
// Else If vt then we get the tex coord u, v.
else if(strcmp(token, "vt") == 0)
{
// Get the u and save it.
tempLex.GetNextToken(token);
texC[tIndex] = (float)atof(token);
tIndex++;
// Get the v and save it.
tempLex.GetNextToken(token);
texC[tIndex] = (float)atof(token);
tIndex++;
}
// Else If f then get each vertex 3 indices set.
else if(strcmp(token, "f") == 0)
{
// Load for each vertex (3 in a triangle).
for(int i = 0; i < 3; i++)
{
// Get first set. Get the length of it.
tempLex.GetNextToken(token);
int len = strlen(token);
// Since there are no spaces between a set (1/1/1)
// we can't simply read tokens so we must loop
// through and take out each value before the / sign.
for(int s = 0; s < len + 1; s++)
{
char buff[64];
// If this is not a / or if not at the end.
if(token[s] != '/' && s < len)
{
buff[index] = token[s];
index++;
}
else
{
// Else end the string, convert it, save it.
buff[index] = '\0';
faces[fIndex] = (int)atoi(buff);
fIndex++;
index = 0;
facesArraySize ++;
}
}
}
}
token[0] = '\0';
}
// No longer need.
lexer.Shutdown();
// Create the model object by allocating.
stObjModel *model = new stObjModel;
if(!model) return NULL;
memset(model, 0, sizeof(stObjModel));
// Save face count.
model->numFaces = totalFaces;
// Reset temp counters.
vIndex = 0, nIndex = 0, tIndex = 0, fIndex = 0, index = 0;
// Allocate data for each part of the model.
// 因为vertices是float数组，每个三角形三个顶点，每个顶点有3个坐标位置x,y,z
model->vertices = new float[totalFaces * 3 * 3];
// 因为normals是float数组，每个三角形三个顶点，每个顶点有3个法线坐标nx,ny,nz
if(totalNormals) model->normals = new float[totalFaces * 3 * 3];
// 因为texCoords是float数组，每个三角形三个顶点，每个顶点有2个纹理坐标点u,v
if(totalTexC) model->texCoords = new float[totalFaces * 3 * 2];
// Loop through and fill in our model.
// 总顶点个数为totalFaces * 9
for(int f = 0; f < totalFaces * 9; f += 3)
{
// Get vertex. We subtract by 1 since we need our indices to be
// in the range of 0 to max - 1 not 1 to max. We multiply by 3
// since there are 3 componets (x, y, z) in a vertex.
//faces数组中存的是顶点的索引
// 得到一个索引后还需从verts中取出对象顶点的三个坐标分量复制到model->vertices中去
if (f >= facesArraySize)
continue;
model->vertices[vIndex + 0] = verts[(faces[f + 0] - 1) * 3 + 0];
model->vertices[vIndex + 1] = verts[(faces[f + 0] - 1) * 3 + 1];
model->vertices[vIndex + 2] = verts[(faces[f + 0] - 1) * 3 + 2];
vIndex += 3;
// We do the same with the texture coordinate data. Since tex coord
// data in the second thing we app 1 to f (v/vt/vn).
if(model->texCoords)
{
model->texCoords[tIndex + 0] = texC[(faces[f + 1] - 1) * 2 + 0];
model->texCoords[tIndex + 1] = texC[(faces[f + 1] - 1) * 2 + 1];
tIndex += 2;
}
// We do the same with the normal coordinate data.
if(model->normals)
{
model->normals[nIndex + 0] = norms[(faces[f + 2] - 1) * 3 + 0];
model->normals[nIndex + 1] = norms[(faces[f + 2] - 1) * 3 + 1];
model->normals[nIndex + 2] = norms[(faces[f + 2] - 1) * 3 + 2];
nIndex += 3;
}
}
// Delete temp data.
delete[] verts;
delete[] norms;
delete[] texC;
delete[] faces;
return model;
}
void FreeModel(stObjModel *model)
{
if(!model) return;
// Release all resources.
if(model->vertices) delete[] model->vertices;
model->vertices = NULL;
if(model->normals) delete[] model->normals;
model->normals = NULL;
if(model->texCoords) delete[] model->texCoords;
model->texCoords = NULL;
delete model;
model = NULL;
}
main.cpp
#include<d3d9.h>
#include<d3dx9.h>
#include"objLoader.h"
#pragma comment(lib, "d3d9.lib")
#pragma comment(lib, "d3dx9.lib")
#define WINDOW_CLASS "UGPDX"
#define WINDOW_NAME "OBJ Model Loading"
#define WINDOW_WIDTH 640
#define WINDOW_HEIGHT 480
#define FULLSCREEN 0
// Function Prototypes...
bool InitializeD3D();
bool InitializeObjects();
void RenderScene();
void Shutdown();
// Global window handle.
HWND g_hwnd = 0;
// Direct3D object and device.
LPDIRECT3D9 g_D3D = NULL;
LPDIRECT3DDEVICE9 g_D3DDevice = NULL;
// Matrices.
D3DXMATRIX g_projection;
D3DXMATRIX g_worldMatrix;
D3DXMATRIX g_ViewMatrix;
// Vertex buffer to hold the geometry.
LPDIRECT3DVERTEXBUFFER9 g_vertexBuffer = NULL;
// A structure for our custom vertex type
struct stD3DVertex
{
float x, y, z;
float nx, ny, nz;
unsigned long color;
};
// Our custom FVF, which describes our custom vertex structure
#define D3DFVF_VERTEX (D3DFVF_XYZ | D3DFVF_NORMAL | D3DFVF_DIFFUSE)
// Model we are loading.
stObjModel *g_model;
// These are the x and y rotations for our object.
float g_xRot = 0.0f;
float g_yRot = 0.0f;
// Scene light source.
D3DLIGHT9 g_light;
LRESULT WINAPI MsgProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
static POINT oldMousePos;
static POINT currentMousePos;
static bool isMouseActive;
switch(msg)
{
case WM_DESTROY:
case WM_CLOSE:
PostQuitMessage(0);
return 0;
break;
case WM_KEYUP:
if(wParam == VK_ESCAPE) PostQuitMessage(0);
break;
case WM_LBUTTONDOWN:
oldMousePos.x = currentMousePos.x = LOWORD(lParam);
oldMousePos.y = currentMousePos.y = HIWORD(lParam);
isMouseActive = true;
break;
case WM_LBUTTONUP:
isMouseActive = false;
break;
case WM_MOUSEMOVE:
currentMousePos.x = LOWORD (lParam);
currentMousePos.y = HIWORD (lParam);
if(isMouseActive)
{
g_xRot -= (currentMousePos.x - oldMousePos.x);
g_yRot -= (currentMousePos.y - oldMousePos.y);
}
oldMousePos.x = currentMousePos.x;
oldMousePos.y = currentMousePos.y;
break;
}
return DefWindowProc(hWnd, msg, wParam, lParam);
}
int WINAPI WinMain(HINSTANCE hInst, HINSTANCE prevhInst, LPSTR cmdLine, int show)
{
// Register the window class
WNDCLASSEX wc = { sizeof(WNDCLASSEX), CS_CLASSDC, MsgProc, 0L, 0L,
GetModuleHandle(NULL), NULL, NULL, NULL, NULL,
WINDOW_CLASS, NULL };
RegisterClassEx(&wc);
// Create the application's window
HWND hWnd = CreateWindow(WINDOW_CLASS, WINDOW_NAME, WS_OVERLAPPEDWINDOW,
100, 100, WINDOW_WIDTH, WINDOW_HEIGHT,
GetDesktopWindow(), NULL, wc.hInstance, NULL);
// Show the window
ShowWindow(hWnd, SW_SHOWDEFAULT);
UpdateWindow(hWnd);
// Record for global.
g_hwnd = hWnd;
// Initialize Direct3D
if(InitializeD3D())
{
// Enter the message loop
MSG msg;
ZeroMemory(&msg, sizeof(msg));
while(msg.message != WM_QUIT)
{
if(PeekMessage(&msg, NULL, 0U, 0U, PM_REMOVE))
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
else
RenderScene();
}
}
// Release any and all resources.
Shutdown();
// Unregister our window.
UnregisterClass(WINDOW_CLASS, wc.hInstance);
return 0;
}
bool InitializeD3D()
{
D3DDISPLAYMODE displayMode;
// Create the D3D object.
g_D3D = Direct3DCreate9(D3D_SDK_VERSION);
if(g_D3D == NULL) return false;
// Get the desktop display mode.
if(FAILED(g_D3D->GetAdapterDisplayMode(D3DADAPTER_DEFAULT, &displayMode)))
return false;
// Set up the structure used to create the D3DDevice
D3DPRESENT_PARAMETERS d3dpp;
ZeroMemory(&d3dpp, sizeof(d3dpp));
if(FULLSCREEN)
{
d3dpp.Windowed = FALSE;
d3dpp.BackBufferWidth = WINDOW_WIDTH;
d3dpp.BackBufferHeight = WINDOW_HEIGHT;
}
else
d3dpp.Windowed = TRUE;
d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;
d3dpp.BackBufferFormat = displayMode.Format;
d3dpp.BackBufferCount = 1;
d3dpp.EnableAutoDepthStencil = TRUE;
d3dpp.AutoDepthStencilFormat = D3DFMT_D16;
// Create the D3DDevice
if(FAILED(g_D3D->CreateDevice(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, g_hwnd,
D3DCREATE_HARDWARE_VERTEXPROCESSING | D3DCREATE_PUREDEVICE,
&d3dpp, &g_D3DDevice))) return false;
// Initialize any objects we will be displaying.
if(!InitializeObjects()) return false;
return true;
}
bool InitializeObjects()
{
// Set default rendering states.
g_D3DDevice->SetRenderState(D3DRS_LIGHTING, TRUE);
g_D3DDevice->SetRenderState(D3DRS_CULLMODE, D3DCULL_NONE);
g_D3DDevice->SetRenderState(D3DRS_ZENABLE, TRUE);
// Setup the g_light source and material.
g_light.Type = D3DLIGHT_DIRECTIONAL;
g_light.Direction = D3DXVECTOR3(0.0f, 0.0f, 1.0f);
D3DCOLORVALUE white;
white.a = white.r = white.g = white.b = 1;
g_light.Diffuse = white;
g_light.Specular = white;
g_D3DDevice->SetLight(0, &g_light);
g_D3DDevice->LightEnable(0, TRUE);
// Load the model from the file.
g_model = LoadOBJModel("SmoothCube.obj");
if(!g_model) return false;
//
CObjModelManager::GetSingleton().LoadObjModel("SmoothCube.obj");
//
// Allocate temp D3D array for model data.
stD3DVertex *objData = new stD3DVertex[g_model->numFaces * 3]; // 每个面有3个顶点
int size = sizeof(stD3DVertex) * (g_model->numFaces * 3);
// 方案1
int tmp1 = 0;
int tmp2 = 0;
for (int i=0; i<CObjModelManager::GetSingleton().m_vecObjModel[0].m_nFaces * 3; ++i)
{
objData[i].x = CObjModelManager::GetSingleton().m_vecObjModel[0].m_vecVertex[tmp1].m_x;
objData[i].y = CObjModelManager::GetSingleton().m_vecObjModel[0].m_vecVertex[tmp1].m_y;
objData[i].z = CObjModelManager::GetSingleton().m_vecObjModel[0].m_vecVertex[tmp1].m_z;
tmp1 ++;
objData[i].nx = CObjModelManager::GetSingleton().m_vecObjModel[0].m_vecNormalVertex[tmp2].m_x;
objData[i].ny = CObjModelManager::GetSingleton().m_vecObjModel[0].m_vecNormalVertex[tmp2].m_y;
objData[i].nz = CObjModelManager::GetSingleton().m_vecObjModel[0].m_vecNormalVertex[tmp2].m_z;
tmp2 ++;
objData[i].color = D3DCOLOR_XRGB(255,255,255);
}
//
// 方案2
// Copy model data into vertex buffer.
//int v = 0, n = 0;
//for(int i = 0; i < g_model->numFaces * 3; i++)
//{
// objData[i].x = g_model->vertices[v++];
// objData[i].y = g_model->vertices[v++];
// objData[i].z = g_model->vertices[v++];
// objData[i].nx = g_model->normals[n++];
// objData[i].ny = g_model->normals[n++];
// objData[i].nz = g_model->normals[n++];
// objData[i].color = D3DCOLOR_XRGB(255,255,255);
//}
// Create the vertex buffer.
if(FAILED(g_D3DDevice->CreateVertexBuffer(size, 0,
D3DFVF_VERTEX, D3DPOOL_DEFAULT,
&g_vertexBuffer, NULL))) return false;
// Fill the vertex buffer.
void *ptr;
if(FAILED(g_vertexBuffer->Lock(0, size,
(void**)&ptr, 0))) return false;
memcpy(ptr, objData, size);
g_vertexBuffer->Unlock();
if(objData) delete[] objData;
// Set the projection matrix.
D3DXMatrixPerspectiveFovLH(&g_projection, D3DX_PI / 4,
WINDOW_WIDTH/WINDOW_HEIGHT, 0.1f, 1000.0f);
g_D3DDevice->SetTransform(D3DTS_PROJECTION, &g_projection);
// Define camera information.
D3DXVECTOR3 cameraPos(0.0f, 0.0f, -5.0f);
D3DXVECTOR3 lookAtPos(0.0f, 0.0f, 0.0f);
D3DXVECTOR3 upDir(0.0f, 1.0f, 0.0f);
// Build view matrix.
D3DXMatrixLookAtLH(&g_ViewMatrix, &cameraPos,
&lookAtPos, &upDir);
return true;
}
void RenderScene()
{
// Clear the backbuffer.
g_D3DDevice->Clear(0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER,
D3DCOLOR_XRGB(0,0,0), 1.0f, 0);
// Begin the scene. Start rendering.
g_D3DDevice->BeginScene();
// Apply the view (camera).
g_D3DDevice->SetTransform(D3DTS_VIEW, &g_ViewMatrix);
// Used to rotate by mouse.
D3DXMATRIX rot, rotX, rotY;
// Set the rot value to the matrix. Convert deg to rad.
D3DXMatrixRotationX(&rotX, -g_yRot / 180.0f * 3.141592654f);
D3DXMatrixRotationY(&rotY, g_xRot / 180.0f * 3.141592654f);
// Set the rotation matrix.
rot = rotX * rotY;
g_D3DDevice->SetTransform(D3DTS_WORLD, &rot);
// Draw the model.
g_D3DDevice->SetStreamSource(0, g_vertexBuffer, 0, sizeof(stD3DVertex));
g_D3DDevice->SetFVF(D3DFVF_VERTEX);
g_D3DDevice->DrawPrimitive(D3DPT_TRIANGLELIST, 0, g_model->numFaces);
// End the scene. Stop rendering.
g_D3DDevice->EndScene();
// Display the scene.
g_D3DDevice->Present(NULL, NULL, NULL, NULL);
}
void Shutdown()
{
if(g_D3DDevice != NULL) g_D3DDevice->Release();
g_D3DDevice = NULL;
if(g_D3D != NULL) g_D3D->Release();
g_D3D = NULL;
if(g_vertexBuffer != NULL) g_vertexBuffer->Release();
g_vertexBuffer = NULL;
if(g_model) FreeModel(g_model);
g_model = NULL;
}
