//Init
bool cScene::Init(const std::string &lacNameId, const std::string &lacFile)
{
macFile = lacFile;
mbLoaded = false;
//Create an instance of the importer class
Assimp::Importer lImporter;
//Load the scene
const aiScene* lpScene = lImporter.ReadFile( macFile.c_str(),
aiProcess_CalcTangentSpace |
aiProcess_Triangulate |
aiProcess_JoinIdenticalVertices |
aiProcess_SortByPType);
// If the import failed, report it
if (!lpScene)
{
printf( lImporter.GetErrorString() );
return false;
}
ProcessScene(lpScene);
lImporter.FreeScene();
mbLoaded = true;
return true;
}
void SpotLightDemo::Initialize()
{
glEnable(GL_DEPTH_TEST);
program.AddShaderFile(ShaderType::Vertex, "Assets/Shaders/Vertex/spotlight.vert");
program.AddShaderFile(ShaderType::Fragment, "Assets/Shaders/Fragment/spotlight.frag");
program.Build();
using std::unique_ptr;
monkey = std::unique_ptr<GameObject>(new GameObject());
monkey->GetTransform()->SetPosition({ 0.0f,0.0f,-5.0f });
monkey->Update();
light.color = glm::vec3(0.4f, 0.5f, 0.7f);
light.position = glm::vec3(2.0f, 0.0f, -1.0f);
light.direction = glm::normalize( glm::vec3(0.0f, 0.0f, -5.0f ) - light.position);
light.cutOffAngle = 12.0f;
light.exponent = 5.0f;
program.AddUniformBlock({ "TransformBlock",{
{ "TransformBlock.view", &camera->GetView()[0][0],sizeof(camera->GetView()) },
{ "TransformBlock.projection", &camera->GetProjection()[0][0],sizeof(camera->GetProjection()) },
{"TransformBlock.eyePosition", &camera->GetPosition()[0],sizeof(camera->GetPosition())},
} });
program.AddUniformBlock({ "LightBlock", {
{ "LightBlock.color", &light.color.x,sizeof(light.color) },
{ "LightBlock.position", &light.position.x,sizeof(light.position) },
{ "LightBlock.direction", &light.direction.x,sizeof(light.direction) },
{ "LightBlock.exponent", &light.exponent,sizeof(light.exponent) },
{ "LightBlock.cutOffAngle", &light.cutOffAngle,sizeof(light.cutOffAngle) },
} });
Assimp::Importer importer;
auto scene = importer.ReadFile("Assets/Models/Obj/monkey.obj", aiProcess_Triangulate);
if (scene && scene->HasMeshes())
{
mesh = std::unique_ptr<MeshComponent>(new MeshComponent(monkey.get()));
mesh->Initialize(scene->mMeshes[0], program, {
{ "world", UniformType::MAT4,&monkey->GetWorld()[0][0] },
{ "material.ambient",UniformType::VEC3, &mesh->GetMaterial().ambient[0] },
{ "material.diffuse",UniformType::VEC3, &mesh->GetMaterial().diffuse[0] } ,
{ "material.specular", UniformType::VEC4, &mesh->GetMaterial().specular[0] }
});
monkey->AddComponent(mesh.get());
mesh->GetMaterial().ambient = glm::vec3(0.2f, 0.4f, 0.7f);
mesh->GetMaterial().diffuse = glm::vec3(0.8f, 0.1f, 0.1f);
mesh->GetMaterial().specular = glm::vec4(0.3f, 0.7f, 0.3f,10.0f);
}
importer.FreeScene();
}
void LoadingObjDemo::InitializeObj(string filePath)
{
Assimp::Importer importer;
auto scene = importer.ReadFile(filePath.c_str(),
aiProcess_Triangulate | aiProcess_GenSmoothNormals | aiProcess_FlipUVs );
if (scene)
{
auto mesh = scene->mMeshes[0];
gameObject = std::unique_ptr<GameObject>(new GameObject());
meshComponent = std::unique_ptr<MeshComponent>(new MeshComponent(gameObject.get()));
meshComponent->Initialize(mesh, program, {
{ "model", UniformType::MAT4,&gameObject->GetWorld()[0][0] }
});
gameObject->GetTransform()->SetPosition(glm::vec3(0, 0, -10));
}
importer.FreeScene();
}
ScenePtr ModelLoader::loadScene(const std::string & path) {
//Création de la scène
ScenePtr scene(new Scene);
SceneObjectPtr &rootObject = scene->getRootObject();
//Chargement du modèle dans assimp
Assimp::Importer importer;
const aiScene *aiScene = importer.ReadFile(path, aiProcess_Triangulate | aiProcess_FlipUVs | aiProcess_CalcTangentSpace);
if (!aiScene) {
throw std::runtime_error(importer.GetErrorString());
}
importer.ApplyPostProcessing(aiProcess_GenNormals);
if (!aiScene || aiScene->mFlags == AI_SCENE_FLAGS_INCOMPLETE || !aiScene->mRootNode) {
cout << "ERROR::ASSIMP::" << importer.GetErrorString() << endl;
return ScenePtr(nullptr);
}
m_directory = path.substr(0, path.find_last_of('/'));
processNode(aiScene, scene, aiScene->mRootNode, rootObject, glm::mat4());
importer.FreeScene();
return std::move(scene);
}
void KeCloseScene()
{
/* Close this mesh currently in memory */
importer.FreeScene();
}
void FrameBufferDemo::Initialize()
{
fboProgram.AddShaderFile(ShaderType::Vertex,"Assets/Shaders/Vertex/fbo.vert");
fboProgram.AddShaderFile(ShaderType::Fragment,"Assets/Shaders/Fragment/fbo.frag");
fboProgram.Build();
textureProgram.AddShaderFile(ShaderType::Vertex, "Assets/Shaders/Vertex/texture.vert");
textureProgram.AddShaderFile(ShaderType::Fragment, "Assets/Shaders/Fragment/texture.frag");
textureProgram.Build();
textureProgram.AddUniformBlock({ "TransformBlock", {
{ "TransformBlock.view", &camera->GetView()[0][0], sizeof(camera->GetView()) },
{ "TransformBlock.projection", &camera->GetProjection()[0][0], sizeof(camera->GetProjection()) },
} });
fboProgram.AddUniformBlock({ "TransformBlock",{
{ "TransformBlock.view", &camera->GetView()[0][0], sizeof(camera->GetView()) },
{ "TransformBlock.projection", &camera->GetProjection()[0][0], sizeof(camera->GetProjection()) },
} });
input->addBinding(GLFW_KEY_LEFT, [this](InputInfo info) {
camera->MoveLeft();
fboProgram.UpdateUniformBlock("TransformBlock");
textureProgram.UpdateUniformBlock("TransformBlock");
});
input->addBinding(GLFW_KEY_RIGHT, [this](InputInfo info) {
camera->MoveRight();
fboProgram.UpdateUniformBlock("TransformBlock");
textureProgram.UpdateUniformBlock("TransformBlock");
});
input->addBinding(GLFW_KEY_UP, [this](InputInfo info) {
camera->MoveForward();
textureProgram.UpdateUniformBlock("TransformBlock");
fboProgram.UpdateUniformBlock("TransformBlock");
});
input->addBinding(GLFW_KEY_DOWN, [this](InputInfo info) {
camera->MoveBack();
textureProgram.UpdateUniformBlock("TransformBlock");
fboProgram.UpdateUniformBlock("TransformBlock");
});
glGenFramebuffers(1, &fboHandle);
glBindFramebuffer(GL_FRAMEBUFFER, fboHandle);
glGenTextures(1, &renderTargetTexture);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, renderTargetTexture);
glTexStorage2D(GL_TEXTURE_2D, 1, GL_RGBA8, 512, 512);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, renderTargetTexture,0);
glGenRenderbuffers(1, &depthBufferTexture);
glBindRenderbuffer(GL_RENDERBUFFER, depthBufferTexture);
glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT, 512, 512);
GLenum drawBufs[] = { GL_COLOR_ATTACHMENT0 };
glDrawBuffers(1, drawBufs);
glBindFramebuffer(GL_FRAMEBUFFER, 0);
Assimp::Importer importer;
auto cubeScene = importer.ReadFile("Assets/Models/Obj/box.obj", aiProcess_Triangulate);
cube = std::unique_ptr<GameObject>(new GameObject());
cube->GetTransform()->SetPosition({ 0.0f,0.0f,-5.0f });
cube->GetTransform()->SetScale({ 20.0f,20.0f,20.0f });
cube->Update();
if (cubeScene && cubeScene->HasMeshes())
{
cubeMesh = std::unique_ptr<MeshComponent>(new MeshComponent(cube.get()));
cubeMesh->Initialize(cubeScene->mMeshes[0], fboProgram, {
{"world", UniformType::MAT4, &cube->GetWorld()[0][0]},
});
cubeMesh->AddTexture({ renderTargetTexture,GL_TEXTURE_2D, renderer->GetSampler(SamplerType::Linear).sampler });
}
auto monkeyScene = importer.ReadFile("Assets/Models/Obj/monkey.obj", aiProcess_Triangulate);
monkey = std::unique_ptr<GameObject>(new GameObject());
monkey->GetTransform()->SetPosition({ 2.0f,0.0f,-2.0f });
monkey->Update();
if (monkeyScene && monkeyScene->HasMeshes())
{
monkeyMesh = std::unique_ptr<MeshComponent>(new MeshComponent(monkey.get()));
monkeyMesh->Initialize(monkeyScene->mMeshes[0], textureProgram, {
{"world", UniformType::MAT4, &monkey->GetWorld()[0][0]}
});
monkeyMesh->AddTexture("Assets/Textures/brick.jpg");
}
importer.FreeScene();
}
bool AssimpModelImporter::Load(const std::string& Filename)
{
// Assimp Importer
Assimp::Importer Importer;
// Load Model
assimp_model = Importer.ReadFile(Filename.c_str(),aiProcessPreset_TargetRealtime_Fast | aiProcess_OptimizeMeshes | aiProcess_JoinIdenticalVertices | aiProcess_LimitBoneWeights | aiProcess_FlipUVs | aiProcess_CalcTangentSpace);
// Path Relative to Model File
std::string RelativePath = Filename.substr(0,Filename.find_last_of("/")+1);
if (!assimp_model)
{
echo("Failed To Import Model: " + Filename + " ERROR: " + Importer.GetErrorString());
return false;
} else {
// Build Skeleton
// initial bone count
boneCount = 0;
// Get Skeleton
GetBone(assimp_model->mRootNode);
for (uint32 i=0;i<assimp_model->mNumMeshes;i++)
{
// loop through meshes
const aiMesh* mesh = assimp_model->mMeshes[i];
// create submesh
SubMesh subMesh;
// set submesh id
subMesh.ID = i;
// set name
subMesh.Name = mesh->mName.data;
for (uint32 t = 0; t < mesh->mNumFaces;t++) {
const aiFace* face = &mesh->mFaces[t];
subMesh.tIndex.push_back(face->mIndices[0]);
subMesh.tIndex.push_back(face->mIndices[1]);
subMesh.tIndex.push_back(face->mIndices[2]);
}
// get posisitons
if (mesh->HasPositions())
{
subMesh.hasVertex = true;
subMesh.tVertex.resize(mesh->mNumVertices);
memcpy(&subMesh.tVertex[0],&mesh->mVertices[0],mesh->mNumVertices*sizeof(Vec3));
} else subMesh.hasVertex = false;
// get normals
if (mesh->HasNormals())
{
subMesh.hasNormal = true;
subMesh.tNormal.resize(mesh->mNumVertices);
memcpy(&subMesh.tNormal[0],&mesh->mNormals[0],mesh->mNumVertices*sizeof(Vec3));
} else subMesh.hasNormal = false;
// get texcoords
if (mesh->HasTextureCoords(0))
{
subMesh.hasTexcoord = true;
for (uint32 k = 0; k < mesh->mNumVertices;k++)
{
subMesh.tTexcoord.push_back(Vec2(mesh->mTextureCoords[0][k].x,mesh->mTextureCoords[0][k].y));
}
} else subMesh.hasTexcoord = false;
// get tangent
if (mesh->HasTangentsAndBitangents())
{
subMesh.hasTangentBitangent = true;
subMesh.tTangent.resize(mesh->mNumVertices);
subMesh.tBitangent.resize(mesh->mNumVertices);
memcpy(&subMesh.tTangent[0],&mesh->mTangents[0],mesh->mNumVertices*sizeof(Vec3));
memcpy(&subMesh.tBitangent[0],&mesh->mBitangents[0],mesh->mNumVertices*sizeof(Vec3));
} else subMesh.hasTangentBitangent = false;
// get vertex colors
if (mesh->HasVertexColors(0))
{
subMesh.hasVertexColor = true;
subMesh.tVertexColor.resize(mesh->mNumVertices);
memcpy(&subMesh.tVertexColor[0],&mesh->mColors[0],mesh->mNumVertices*sizeof(Vec4));
} else subMesh.hasVertexColor = false;
// get vertex weights
if (mesh->HasBones())
{
// Set Flag
subMesh.hasBones = true;
// Create Bone's Sub Mesh Internal ID
uint32 count = 0;
for (uint32 k = 0; k < mesh->mNumBones; k++)
{
// Save Offset Matrix
Matrix _offsetMatrix;
_offsetMatrix.m[0] = mesh->mBones[k]->mOffsetMatrix.a1; _offsetMatrix.m[1] = mesh->mBones[k]->mOffsetMatrix.b1; _offsetMatrix.m[2] = mesh->mBones[k]->mOffsetMatrix.c1; _offsetMatrix.m[3] = mesh->mBones[k]->mOffsetMatrix.d1;
_offsetMatrix.m[4] = mesh->mBones[k]->mOffsetMatrix.a2; _offsetMatrix.m[5] = mesh->mBones[k]->mOffsetMatrix.b2; _offsetMatrix.m[6] = mesh->mBones[k]->mOffsetMatrix.c2; _offsetMatrix.m[7] = mesh->mBones[k]->mOffsetMatrix.d2;
_offsetMatrix.m[8] = mesh->mBones[k]->mOffsetMatrix.a3; _offsetMatrix.m[9] = mesh->mBones[k]->mOffsetMatrix.b3; _offsetMatrix.m[10] = mesh->mBones[k]->mOffsetMatrix.c3; _offsetMatrix.m[11] = mesh->mBones[k]->mOffsetMatrix.d3;
_offsetMatrix.m[12] = mesh->mBones[k]->mOffsetMatrix.a4; _offsetMatrix.m[13] = mesh->mBones[k]->mOffsetMatrix.b4; _offsetMatrix.m[14] = mesh->mBones[k]->mOffsetMatrix.c4; _offsetMatrix.m[15] = mesh->mBones[k]->mOffsetMatrix.d4;
uint32 boneID = GetBoneID(mesh->mBones[k]->mName.data);
subMesh.BoneOffsetMatrix[boneID] = _offsetMatrix;
subMesh.MapBoneIDs[boneID] = count;
count++;
}
// Add Bones and Weights to SubMesh Structure, based on Internal IDs
for (uint32 j = 0; j < mesh->mNumVertices; j++)
{
// get values
std::vector<uint32> boneID(4,0);
std::vector<f32> weightValue(4,0.f);
uint32 count = 0;
for (uint32 k = 0; k < mesh->mNumBones; k++)
{
for (uint32 l = 0; l < mesh->mBones[k]->mNumWeights; l++)
{
if (mesh->mBones[k]->mWeights[l].mVertexId == j)
{
// Convert Bone ID to Internal of the Sub Mesh
boneID[count] = subMesh.MapBoneIDs[GetBoneID(mesh->mBones[k]->mName.data)];
// Add Bone Weight
weightValue[count] = mesh->mBones[k]->mWeights[l].mWeight;
count++;
}
}
}
subMesh.tBonesID.push_back(Vec4((f32)boneID[0],(f32)boneID[1],(f32)boneID[2],(f32)boneID[3]));
subMesh.tBonesWeight.push_back(Vec4(weightValue[0],weightValue[1],weightValue[2],weightValue[3]));
}
} else subMesh.hasBones = false;
// Get SubMesh Material ID
subMesh.materialID = mesh->mMaterialIndex;
// add to submeshes vector
subMeshes.push_back(subMesh);
}
// Build Materials List
for (uint32 i=0;i<assimp_model->mNumMaterials;++i)
{
MaterialProperties material;
// Get Material
const aiMaterial* pMaterial = assimp_model->mMaterials[i];
material.id = i;
aiString name;
pMaterial->Get(AI_MATKEY_NAME, name);
material.Name.resize(name.length);
memcpy(&material.Name[0], name.data, name.length);
aiColor3D color;
material.haveColor = false;
if (pMaterial->Get(AI_MATKEY_COLOR_DIFFUSE, color)==AI_SUCCESS)
{
material.haveColor = true;
material.Color = Vec4(color.r, color.g, color.b, 1.0);
}
material.haveAmbient = false;
if (pMaterial->Get(AI_MATKEY_COLOR_AMBIENT, color)==AI_SUCCESS)
{
material.haveAmbient = true;
material.Ambient = Vec4(color.r, color.g, color.b, 1.0);
}
material.haveSpecular = false;
if (pMaterial->Get(AI_MATKEY_COLOR_SPECULAR, color)==AI_SUCCESS)
{
material.haveSpecular = true;
material.Specular = Vec4(color.r, color.g, color.b, 1.0);
}
material.haveEmissive = false;
if (pMaterial->Get(AI_MATKEY_COLOR_EMISSIVE, color)==AI_SUCCESS)
{
material.haveEmissive = true;
material.Emissive = Vec4(color.r, color.g, color.b, 1.0);
}
bool flag = false;
pMaterial->Get(AI_MATKEY_ENABLE_WIREFRAME, flag);
material.WireFrame = flag;
flag = false;
pMaterial->Get(AI_MATKEY_TWOSIDED, flag);
material.Twosided = flag;
f32 value = 1.0f;
pMaterial->Get(AI_MATKEY_OPACITY, value);
material.Opacity = value;
value = 0.0f;
pMaterial->Get(AI_MATKEY_SHININESS, value);
material.Shininess = value;
value = 0.0f;
pMaterial->Get(AI_MATKEY_SHININESS_STRENGTH, value);
material.ShininessStrength = value;
// Save Properties
aiString path;
aiReturn texFound;
// Diffuse
texFound = assimp_model->mMaterials[i]->GetTexture(aiTextureType_DIFFUSE, 0, &path);
if (texFound==AI_SUCCESS)
{
material.haveColorMap = true;
material.colorMap.resize(path.length);
memcpy(&material.colorMap[0],&path.data,path.length);
std::replace(material.colorMap.begin(), material.colorMap.end(),'\\','/');
}
// Bump Map
texFound = assimp_model->mMaterials[i]->GetTexture(aiTextureType_NORMALS, 0, &path);
if (texFound==AI_SUCCESS)
{
material.haveNormalMap = true;
material.normalMap.resize(path.length);
memcpy(&material.normalMap[0],&path.data,path.length);
std::replace(material.normalMap.begin(), material.normalMap.end(),'\\','/');
} else {
// Height Map
texFound = assimp_model->mMaterials[i]->GetTexture(aiTextureType_HEIGHT, 0, &path);
if (texFound==AI_SUCCESS)
{
material.haveNormalMap = true;
material.normalMap.resize(path.length);
memcpy(&material.normalMap[0],&path.data,path.length);
std::replace(material.normalMap.begin(), material.normalMap.end(),'\\','/');
}
}
// Specular
texFound = assimp_model->mMaterials[i]->GetTexture(aiTextureType_SPECULAR, 0, &path);
if (texFound==AI_SUCCESS)
{
material.haveSpecularMap = true;
material.specularMap.resize(path.length);
memcpy(&material.specularMap[0],&path.data,path.length);
std::replace(material.specularMap.begin(), material.specularMap.end(),'\\','/');
}
// Add Material to List
materials.push_back(material);
}
}
Importer.FreeScene();
return true;
}
void DiffuseDemo::Initialize()
{
glEnable(GL_DEPTH_TEST);
glClearColor(0.4f, 0.7f, 0.2f, 1.0f);
program.Initialize();
program.AddShaderFile(ShaderType::Vertex, "Assets/Shaders/Vertex/diffuseLight.vert");
program.AddShaderFile(ShaderType::Fragment, "Assets/Shaders/Fragment/diffuseLight.frag");
program.Build();
light.position = glm::vec3(5.0f, 5.0f, -5.0f);
light.color = glm::vec3(0.0f, 0.5f, 0.5f);
program.AddUniformBlock({
"TransformBlock",{
{ "TransformBlock.view", &camera->GetView()[0][0],sizeof(camera->GetView()) },
{ "TransformBlock.projection", &camera->GetProjection()[0][0],sizeof(camera->GetProjection()) }
}
});
program.AddUniformBlock({
"LightBlock", {
{ "LightBlock.position", &light.position[0],sizeof(light.position) },
{ "LightBlock.color", &light.color[0],sizeof(light.color) }
}
});
monkeyObject = std::unique_ptr<GameObject>(new GameObject());
boxObject = std::unique_ptr<GameObject>(new GameObject());
monkeyObject->GetTransform()->SetPosition(glm::vec3(0, 0, -5));
monkeyObject->GetTransform()->Update();
boxObject->GetTransform()->SetPosition(glm::vec3(2, 2, -7));
boxObject->GetTransform()->Update();
program.AddUniform("view", &camera->GetView()[0][0], UniformType::MAT4);
program.AddUniform("projection", &camera->GetProjection()[0][0], UniformType::MAT4);
Assimp::Importer importer;
auto monkeyScene = importer.ReadFile("Assets/Models/Obj/monkey.obj", aiProcess_Triangulate);
if (monkeyScene)
{
monkey = std::unique_ptr<MeshComponent>(new MeshComponent(monkeyObject.get()));
monkey->Initialize(monkeyScene->mMeshes[0], program, {
{ "world", UniformType::MAT4,&monkeyObject->GetWorld()[0][0] },
{ "diffuse", UniformType::VEC3,&monkey->GetMaterial().diffuse[0] }
});
monkeyObject->AddComponent(monkey.get());
}
importer.FreeScene();
auto boxScene = importer.ReadFile("Assets/Models/Obj/box.obj", aiProcess_Triangulate);
if (boxScene)
{
box = std::unique_ptr<MeshComponent>(new MeshComponent(boxObject.get()));
box->Initialize(boxScene->mMeshes[0], program, {
{ "world",UniformType::MAT4,&boxObject->GetWorld()[0][0] },
{ "diffuse", UniformType::VEC3,&box->GetMaterial().diffuse[0] }
});
box->GetMaterial().diffuse = glm::vec3(0.2f, 0.7f, 0.5);
boxObject->AddComponent(box.get());
}
importer.FreeScene();
}
MeshData(const string& name)
{
static Assimp::Importer importer;
D3DInfo& d3d = *D3DInfo::CurrentInstance();
// Read the mesh data from file using Asset Importer.
const aiScene* scene = importer.ReadFile(config::Meshes + name, ImportSetting);
if (!scene || !scene->mNumMeshes)
{
Warn("Mesh read failed for " + name);
return;
}
const aiMesh* mesh = scene->mMeshes[0];
WarnIf(scene->mNumMeshes > 1, "Mesh " + name + " has more sub-meshes than are currently supported");
// Verify mesh texture coordinates and tangents.
bool hasTexCoords = true;
if (!mesh->HasTextureCoords(0))
{
hasTexCoords = false;
Warn("Mesh " + name + " doesn't have texture coordinates");
}
bool hasTangents = true;
if (!mesh->HasTangentsAndBitangents())
{
hasTangents = false;
Warn("Mesh " + name + " doesn't have tangents/bitangents");
}
float minFloat = numeric_limits<float>::min();
float maxFloat = numeric_limits<float>::max();
boundingBox.max = { minFloat, minFloat, minFloat };
boundingBox.min = { maxFloat, maxFloat, maxFloat };
// Copy all vertices.
vertices.resize(mesh->mNumVertices);
for (size_t i = 0; i < mesh->mNumVertices; ++i)
{
vertices[i].position = reinterpret_cast<const float3&>(mesh->mVertices[i]);
vertices[i].normal = reinterpret_cast<const float3&>(mesh->mNormals[i]);
if (hasTexCoords)
{
vertices[i].tex = reinterpret_cast<const float2&>(mesh->mTextureCoords[0][i]);
}
if (hasTangents)
{
vertices[i].tangent = reinterpret_cast<const float3&>(mesh->mTangents[i]);
vertices[i].bitangent = reinterpret_cast<const float3&>(mesh->mBitangents[i]);
}
// Determine the min and max extents of the mesh.
if (vertices[i].position.x < boundingBox.min.x) boundingBox.min.x = vertices[i].position.x;
if (vertices[i].position.y < boundingBox.min.y) boundingBox.min.y = vertices[i].position.y;
if (vertices[i].position.z < boundingBox.min.z) boundingBox.min.z = vertices[i].position.z;
if (vertices[i].position.x > boundingBox.max.x) boundingBox.max.x = vertices[i].position.x;
if (vertices[i].position.y > boundingBox.max.y) boundingBox.max.y = vertices[i].position.y;
if (vertices[i].position.z > boundingBox.max.z) boundingBox.max.z = vertices[i].position.z;
}
// Calculate the centroid of the mesh: centroid = min + ((max - min) / 2)
XMVECTOR minVector = XMLoadFloat3(&boundingBox.min);
XMVECTOR cornerToCorner = XMVectorSubtract(XMLoadFloat3(&boundingBox.max), minVector);
XMStoreFloat3(
&boundingBox.centroid,
XMVectorAdd(
minVector,
XMVectorScale(cornerToCorner, 0.5f)));
// Center the mesh on (0,0,0) by subtracting the centroid position from all vertex positions.
for (auto& vertex : vertices)
{
vertex.position.x -= boundingBox.centroid.x;
vertex.position.y -= boundingBox.centroid.y;
vertex.position.z -= boundingBox.centroid.z;
}
// Copy all indices.
indices.resize(mesh->mNumFaces * 3);
for (size_t i = 0; i < mesh->mNumFaces; ++i)
{
indices[i * 3 + 0] = mesh->mFaces[i].mIndices[0];
indices[i * 3 + 1] = mesh->mFaces[i].mIndices[1];
indices[i * 3 + 2] = mesh->mFaces[i].mIndices[2];
}
// Free the loaded scene.
importer.FreeScene();
// Create the index buffer.
D3D11_BUFFER_DESC bufferDesc;
bufferDesc.BindFlags = D3D11_BIND_INDEX_BUFFER;
bufferDesc.ByteWidth = indices.size() * sizeof(indices[0]);
bufferDesc.CPUAccessFlags = 0;
bufferDesc.MiscFlags = 0;
bufferDesc.StructureByteStride = 0;
bufferDesc.Usage = D3D11_USAGE_IMMUTABLE;
D3D11_SUBRESOURCE_DATA initData;
initData.pSysMem = indices.data();
initData.SysMemPitch = 0;
initData.SysMemSlicePitch = 0;
DX(d3d.Device->CreateBuffer(&bufferDesc, &initData, indexBuffer));
// Create the vertex buffer.
bufferDesc.BindFlags = D3D11_BIND_VERTEX_BUFFER;
bufferDesc.ByteWidth = vertices.size() * sizeof(vertices[0]);
initData.pSysMem = vertices.data();
DX(d3d.Device->CreateBuffer(&bufferDesc, &initData, vertexBuffer));
// Create the constant buffer.
D3D11_BUFFER_DESC cbDesc;
ZeroMemory(&cbDesc, sizeof(cbDesc));
cbDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
cbDesc.ByteWidth = sizeof(ObjectConstants);
cbDesc.Usage = D3D11_USAGE_DEFAULT;
DX(d3d.Device->CreateBuffer(&cbDesc, nullptr, constantBuffer));
}
void MultiLightDemo::Initialize()
{
glEnable(GL_DEPTH_TEST);
glClearColor(0.3f, 0.2f, 0.7f, 1.0f);
program.AddShaderFile(ShaderType::Vertex, "Assets/Shaders/Vertex/multiLight.vert");
program.AddShaderFile(ShaderType::Fragment, "Assets/Shaders/Fragment/multiLight.frag");
program.Build();
program.AddUniformBlock({ "TransformBlock",{
{ "TransformBlock.view",&camera->GetView()[0][0], sizeof(camera->GetView()) },
{ "TransformBlock.projection",&camera->GetProjection()[0][0], sizeof(camera->GetProjection()) },
{ "TransformBlock.eyePosition",&camera->GetPosition()[0], sizeof(camera->GetPosition()) },
} });
lights[0].position = glm::vec3(0.0f, 0.0f, -2.0f);
lights[1].position = glm::vec3(-2.0f, -3.0f, -2.0f);
lights[2].position = glm::vec3(4.0f, 7.0f, -2.0f);
lights[0].color = glm::vec3(0.9f,0.5f,0.3f);
lights[1].color = glm::vec3(0.2f,0.9f,0.2f);
lights[2].color = glm::vec3(0.2f,0.4f,0.9f);
program.AddUniform("lights[0].position", &lights[0].position[0], UniformType::VEC3);
program.AddUniform("lights[0].color", &lights[0].color[0], UniformType::VEC3);
program.AddUniform("lights[1].position", &lights[1].position[0], UniformType::VEC3);
program.AddUniform("lights[1].color", &lights[1].color[0], UniformType::VEC3);
program.AddUniform("lights[2].position", &lights[2].position[0], UniformType::VEC3);
program.AddUniform("lights[2].color", &lights[2].color[0], UniformType::VEC3);
input->addBinding(GLFW_KEY_LEFT, [this](InputInfo info) {
camera->MoveLeft();
program.UpdateUniformBlock("TransformBlock");
});
input->addBinding(GLFW_KEY_RIGHT, [this](InputInfo info) {
camera->MoveRight();
program.UpdateUniformBlock("TransformBlock");
});
input->addBinding(GLFW_KEY_UP, [this](InputInfo info) {
camera->MoveForward();
program.UpdateUniformBlock("TransformBlock");
});
input->addBinding(GLFW_KEY_DOWN, [this](InputInfo info) {
camera->MoveBack();
program.UpdateUniformBlock("TransformBlock");
});
//program.AddUniform("light[0].position", &lights[0].position[0], UniformType::VEC3);
//program.AddUniform("light[0].color", &lights[0].color[0], UniformType::VEC3);
//program.AddUniform("light[1].position", &lights[1].position[0], UniformType::VEC3);
//program.AddUniform("light[1].color", &lights[1].color[0], UniformType::VEC3);
//program.AddUniform("light[2].position", &lights[2].position[0], UniformType::VEC3);
//program.AddUniform("light[2].color", &lights[2].color[0], UniformType::VEC3);
using std::unique_ptr;
monkey = unique_ptr<GameObject>(new GameObject());
monkey->GetTransform()->SetPosition({ 0.0f,0.0f,-5.0f });
monkey->Update();
Assimp::Importer importer;
auto scene = importer.ReadFile("Assets/Models/Obj/monkey.obj", aiProcess_Triangulate);
if (scene && scene->HasMeshes())
{
mesh = unique_ptr<MeshComponent>(new MeshComponent(monkey.get()));
mesh->Initialize(scene->mMeshes[0], program, {
{ "world", UniformType::MAT4, &monkey->GetWorld()[0][0] },
{ "material.ambient", UniformType::VEC3, &mesh->GetMaterial().ambient[0] },
{ "material.diffuse", UniformType::VEC3, &mesh->GetMaterial().diffuse[0] },
{ "material.specular", UniformType::VEC4, &mesh->GetMaterial().specular[0] },
});
monkey->AddComponent(mesh.get());
}
mesh->GetMaterial().ambient = glm::vec3(0.6f, 0.7f, 0.1f);
mesh->GetMaterial().diffuse = glm::vec3(0.5f, 0.2f, 0.8f);
mesh->GetMaterial().specular = glm::vec4(0.3f, 0.2f, 0.2f, 10.0f);
importer.FreeScene();
}
void ke_close_scene()
{
/* Close this mesh currently in memory */
importer.FreeScene();
}
