543 lines
25 KiB
C++
543 lines
25 KiB
C++
#include "MeshLoader.h"
|
|
#include "Asset/AssetImporter.h"
|
|
#include "Asset/MaterialAsset.h"
|
|
#include "Asset/MeshAsset.h"
|
|
#include "Graphics/Graphics.h"
|
|
#include "Graphics/Mesh.h"
|
|
#include "Graphics/Shader.h"
|
|
#include "Graphics/StaticMeshVertexData.h"
|
|
#include <Asset/MaterialLoader.h>
|
|
#include <Asset/TextureLoader.h>
|
|
#include <assimp/Importer.hpp>
|
|
#include <assimp/config.h>
|
|
#include <assimp/material.h>
|
|
#include <assimp/postprocess.h>
|
|
#include <assimp/scene.h>
|
|
#include <fmt/core.h>
|
|
#include <fstream>
|
|
#include <iostream>
|
|
#include <set>
|
|
#include <stb_image_write.h>
|
|
|
|
|
|
using namespace Seele;
|
|
|
|
MeshLoader::MeshLoader(Gfx::PGraphics graphics) : graphics(graphics) {}
|
|
|
|
MeshLoader::~MeshLoader() {}
|
|
|
|
void MeshLoader::importAsset(MeshImportArgs args) {
|
|
std::filesystem::path assetPath = args.filePath.filename();
|
|
assetPath.replace_extension("asset");
|
|
OMeshAsset asset = new MeshAsset(args.importPath, assetPath.stem().string());
|
|
PMeshAsset ref = asset;
|
|
asset->setStatus(Asset::Status::Loading);
|
|
AssetRegistry::get().registerMesh(std::move(asset));
|
|
import(args, ref);
|
|
}
|
|
|
|
void MeshLoader::convertAssimpARGB(unsigned char* dst, aiTexel* src, uint32 numPixels) {
|
|
for (uint32 i = 0; i < numPixels; ++i) {
|
|
dst[i * 4 + 0] = src[i].r;
|
|
dst[i * 4 + 1] = src[i].g;
|
|
dst[i * 4 + 2] = src[i].b;
|
|
dst[i * 4 + 3] = src[i].a;
|
|
}
|
|
}
|
|
void MeshLoader::loadTextures(const aiScene* scene, const std::filesystem::path& meshDirectory, const std::string& importPath,
|
|
Array<PTextureAsset>& textures) {
|
|
for (uint32 i = 0; i < scene->mNumTextures; ++i) {
|
|
aiTexture* tex = scene->mTextures[i];
|
|
auto texPath = std::filesystem::path(tex->mFilename.C_Str());
|
|
if (std::filesystem::exists(texPath)) {
|
|
} else if (std::filesystem::exists(meshDirectory / texPath)) {
|
|
texPath = meshDirectory / texPath;
|
|
} else {
|
|
texPath = (meshDirectory / texPath).replace_extension("png");
|
|
if (tex->mHeight == 0) {
|
|
std::cout << "Dumping texture " << texPath << std::endl;
|
|
// already compressed, just dump it to the disk
|
|
std::ofstream file(texPath, std::ios::binary);
|
|
file.write((const char*)tex->pcData, tex->mWidth);
|
|
file.flush();
|
|
} else {
|
|
std::cout << "Writing extracted png " << texPath << std::endl;
|
|
// recompress data so that the TextureLoader can read it
|
|
unsigned char* texData = new unsigned char[tex->mWidth * tex->mHeight * 4];
|
|
convertAssimpARGB(texData, tex->pcData, tex->mWidth * tex->mHeight);
|
|
stbi_write_png(texPath.string().c_str(), tex->mWidth, tex->mHeight, 4, tex->pcData, tex->mWidth * 32);
|
|
delete[] texData;
|
|
}
|
|
}
|
|
std::cout << "Loading model texture " << texPath.string() << std::endl;
|
|
AssetImporter::importTexture(TextureImportArgs{
|
|
.filePath = texPath,
|
|
.importPath = importPath,
|
|
});
|
|
textures.add(AssetRegistry::findTexture(importPath, texPath.stem().string()));
|
|
}
|
|
}
|
|
|
|
constexpr const char* KEY_DIFFUSE_COLOR = "k_d";
|
|
constexpr const char* KEY_SPECULAR_COLOR = "k_s";
|
|
constexpr const char* KEY_AMBIENT_COLOR = "k_a";
|
|
constexpr const char* KEY_SHININESS = "k_shiny";
|
|
constexpr const char* KEY_ROUGHNESS = "k_r";
|
|
constexpr const char* KEY_METALLIC = "k_m";
|
|
|
|
constexpr const char* KEY_DIFFUSE_TEXTURE = "tex_d";
|
|
constexpr const char* KEY_SPECULAR_TEXTURE = "tex_s";
|
|
constexpr const char* KEY_AMBIENT_TEXTURE = "tex_a";
|
|
constexpr const char* KEY_NORMAL_TEXTURE = "tex_n";
|
|
constexpr const char* KEY_SHININESS_TEXTURE = "tex_shiny";
|
|
constexpr const char* KEY_ROUGHNESS_TEXTURE = "tex_r";
|
|
constexpr const char* KEY_METALLIC_TEXTURE = "tex_m";
|
|
constexpr const char* KEY_AMBIENT_OCCLUSION_TEXTURE = "tex_ao";
|
|
|
|
void MeshLoader::loadMaterials(const aiScene* scene, const Array<PTextureAsset>& textures, const std::string& baseName,
|
|
const std::filesystem::path& meshDirectory, const std::string& importPath,
|
|
Array<PMaterialInstanceAsset>& globalMaterials) {
|
|
for (uint32 m = 0; m < scene->mNumMaterials; ++m) {
|
|
aiMaterial* material = scene->mMaterials[m];
|
|
aiString texPath;
|
|
std::string materialName = fmt::format("M{0}{1}{2}", baseName, material->GetName().C_Str(), m);
|
|
materialName.erase(std::remove(materialName.begin(), materialName.end(), '.'),
|
|
materialName.end()); // dots break adding the .asset extension later
|
|
materialName.erase(std::remove(materialName.begin(), materialName.end(), '-'),
|
|
materialName.end()); // dots break adding the .asset extension later
|
|
materialName.erase(std::remove(materialName.begin(), materialName.end(), ' '),
|
|
materialName.end()); // dots break adding the .asset extension later
|
|
materialName.erase(std::remove(materialName.begin(), materialName.end(), '('),
|
|
materialName.end()); // dots break adding the .asset extension later
|
|
materialName.erase(std::remove(materialName.begin(), materialName.end(), ')'),
|
|
materialName.end()); // dots break adding the .asset extension later
|
|
Array<OShaderExpression> expressions;
|
|
Array<std::string> parameters;
|
|
uint32 numTextures = 0;
|
|
uint32 numSamplers = 0;
|
|
uint32 numFloats = 0;
|
|
auto addScalarParameter = [&](std::string paramKey, const char* matKey, int type, int index) {
|
|
float scalar;
|
|
material->Get(matKey, type, index, scalar);
|
|
expressions.add(new FloatParameter(paramKey, scalar, numFloats++));
|
|
parameters.add(paramKey);
|
|
};
|
|
|
|
auto addVectorParameter = [&](std::string paramKey, const char* matKey, int type, int index) {
|
|
aiColor3D color;
|
|
material->Get(matKey, type, index, color);
|
|
expressions.add(new VectorParameter(paramKey, Vector(color.r, color.g, color.b), numFloats));
|
|
numFloats += 3;
|
|
parameters.add(paramKey);
|
|
};
|
|
|
|
auto addTextureParameter = [&](std::string paramKey, aiTextureType type, int index, std::string& result,
|
|
StaticArray<int32, 4> extractMask = {0, 1, 2, -1}) {
|
|
aiString texPath;
|
|
aiTextureMapping mapping;
|
|
uint32 uvIndex = 0;
|
|
aiTextureMapMode mapMode = aiTextureMapMode_Clamp;
|
|
float blend = std::numeric_limits<float>::max();
|
|
aiTextureOp op;
|
|
if (material->GetTexture(type, index, &texPath, &mapping, &uvIndex, nullptr, nullptr, nullptr) != AI_SUCCESS) {
|
|
std::cout << "fuck" << std::endl;
|
|
}
|
|
std::string textureKey = fmt::format("{0}Texture{1}", paramKey, index);
|
|
auto texFilename = std::filesystem::path(texPath.C_Str());
|
|
PTextureAsset texture;
|
|
|
|
if (texFilename.string()[0] == '*') {
|
|
texture = textures[atoi(texFilename.string().substr(1).c_str())];
|
|
} else if (std::filesystem::exists(texFilename)) {
|
|
AssetImporter::importTexture(TextureImportArgs{
|
|
.filePath = texFilename,
|
|
.importPath = importPath,
|
|
});
|
|
texture = AssetRegistry::findTexture(importPath, texFilename.stem().string());
|
|
} else if (std::filesystem::exists(meshDirectory / texFilename)) {
|
|
AssetImporter::importTexture(TextureImportArgs{
|
|
.filePath = meshDirectory / texFilename,
|
|
.importPath = importPath,
|
|
.type = type == aiTextureType_NORMALS ? TextureImportType::TEXTURE_NORMAL : TextureImportType::TEXTURE_2D,
|
|
});
|
|
texture = AssetRegistry::findTexture(importPath, texFilename.stem().string());
|
|
} else if (std::filesystem::exists(meshDirectory.parent_path() / "textures" / texFilename)) {
|
|
AssetImporter::importTexture(TextureImportArgs{
|
|
.filePath = meshDirectory.parent_path() / "textures" / texFilename,
|
|
.importPath = importPath,
|
|
.type = type == aiTextureType_NORMALS ? TextureImportType::TEXTURE_NORMAL : TextureImportType::TEXTURE_2D,
|
|
});
|
|
texture = AssetRegistry::findTexture(importPath, texFilename.stem().string());
|
|
} else {
|
|
std::cout << "couldnt find " << texPath.C_Str() << std::endl;
|
|
return;
|
|
}
|
|
expressions.add(new TextureParameter(textureKey, texture, numTextures++));
|
|
parameters.add(textureKey);
|
|
|
|
std::string samplerKey = fmt::format("{0}Sampler{1}", paramKey, index);
|
|
SamplerCreateInfo samplerInfo = {};
|
|
switch (mapMode) {
|
|
case aiTextureMapMode_Wrap:
|
|
samplerInfo.addressModeU = Gfx::SE_SAMPLER_ADDRESS_MODE_REPEAT;
|
|
samplerInfo.addressModeV = Gfx::SE_SAMPLER_ADDRESS_MODE_REPEAT;
|
|
samplerInfo.addressModeW = Gfx::SE_SAMPLER_ADDRESS_MODE_REPEAT;
|
|
break;
|
|
case aiTextureMapMode_Clamp:
|
|
samplerInfo.addressModeU = Gfx::SE_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
|
|
samplerInfo.addressModeV = Gfx::SE_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
|
|
samplerInfo.addressModeW = Gfx::SE_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
|
|
break;
|
|
case aiTextureMapMode_Decal:
|
|
samplerInfo.addressModeU = Gfx::SE_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER;
|
|
samplerInfo.addressModeV = Gfx::SE_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER;
|
|
samplerInfo.addressModeW = Gfx::SE_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER;
|
|
break;
|
|
case aiTextureMapMode_Mirror:
|
|
samplerInfo.addressModeU = Gfx::SE_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT;
|
|
samplerInfo.addressModeV = Gfx::SE_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT;
|
|
samplerInfo.addressModeW = Gfx::SE_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT;
|
|
break;
|
|
}
|
|
expressions.add(new SamplerParameter(samplerKey, graphics->createSampler(samplerInfo), numSamplers++));
|
|
parameters.add(samplerKey);
|
|
|
|
std::string sampleKey = fmt::format("{0}Sample{1}", paramKey, index);
|
|
expressions.add(new SampleExpression());
|
|
expressions.back()->key = sampleKey;
|
|
expressions.back()->inputs["texture"].source = textureKey;
|
|
expressions.back()->inputs["sampler"].source = samplerKey;
|
|
expressions.back()->inputs["coords"].source = fmt::format("input.texCoords[{0}]", uvIndex);
|
|
|
|
std::string colorExtract = fmt::format("{0}Extract{1}", paramKey, index);
|
|
expressions.add(new SwizzleExpression(extractMask));
|
|
expressions.back()->key = colorExtract;
|
|
expressions.back()->inputs["target"].source = sampleKey;
|
|
// TODO: extract alpha, set opacity
|
|
|
|
if (blend == std::numeric_limits<float>::max()) {
|
|
result = colorExtract;
|
|
return;
|
|
}
|
|
std::string blendFactorKey = fmt::format("{0}BlendFactor{1}", paramKey, index);
|
|
expressions.add(new FloatParameter(blendFactorKey, blend, numFloats++));
|
|
parameters.add(blendFactorKey);
|
|
|
|
std::string strengthKey = fmt::format("{0}Strength{1}", paramKey, index);
|
|
expressions.add(new MulExpression());
|
|
expressions.back()->key = strengthKey;
|
|
expressions.back()->inputs["lhs"].source = colorExtract;
|
|
expressions.back()->inputs["rhs"].source = blendFactorKey;
|
|
|
|
std::string blendKey = fmt::format("{0}Blend{1}", paramKey, index);
|
|
switch (op) {
|
|
/** T = T1 * T2 */
|
|
case aiTextureOp_Multiply:
|
|
expressions.add(new MulExpression());
|
|
break;
|
|
|
|
/** T = T1 - T2 */
|
|
case aiTextureOp_Subtract:
|
|
expressions.add(new SubExpression());
|
|
break;
|
|
|
|
/** T = T1 / T2 */
|
|
case aiTextureOp_Divide:
|
|
// expressions[blendKey] = new DivExpression();
|
|
throw std::logic_error("Not implemented");
|
|
|
|
/** T = (T1 + T2) - (T1 * T2) */
|
|
case aiTextureOp_SmoothAdd:
|
|
throw std::logic_error("Not implemented");
|
|
|
|
/** T = T1 + (T2-0.5) */
|
|
case aiTextureOp_SignedAdd:
|
|
throw std::logic_error("Not implemented");
|
|
|
|
/** T = T1 + T2 */
|
|
case aiTextureOp_Add:
|
|
default:
|
|
expressions.add(new AddExpression());
|
|
break;
|
|
}
|
|
expressions.back()->key = blendKey;
|
|
expressions.back()->inputs["lhs"].source = result;
|
|
expressions.back()->inputs["rhs"].source = strengthKey;
|
|
|
|
result = blendKey;
|
|
};
|
|
|
|
// Diffuse
|
|
addVectorParameter(KEY_DIFFUSE_COLOR, AI_MATKEY_COLOR_DIFFUSE);
|
|
std::string outputDiffuse = KEY_DIFFUSE_COLOR;
|
|
uint32 numDiffuseTextures = material->GetTextureCount(aiTextureType_DIFFUSE);
|
|
for (uint32 i = 0; i < numDiffuseTextures; ++i) {
|
|
addTextureParameter(KEY_DIFFUSE_TEXTURE, aiTextureType_DIFFUSE, i, outputDiffuse);
|
|
}
|
|
|
|
// Specular
|
|
addVectorParameter(KEY_SPECULAR_COLOR, AI_MATKEY_COLOR_SPECULAR);
|
|
std::string outputSpecular = KEY_SPECULAR_COLOR;
|
|
uint32 numSpecular = material->GetTextureCount(aiTextureType_SPECULAR);
|
|
for (uint32 i = 0; i < numSpecular; ++i) {
|
|
addTextureParameter(KEY_SPECULAR_TEXTURE, aiTextureType_SPECULAR, i, outputSpecular);
|
|
}
|
|
|
|
// Normal
|
|
std::string outputNormal = "";
|
|
uint32 numNormal = material->GetTextureCount(aiTextureType_NORMALS);
|
|
for (uint32 i = 0; i < numNormal; ++i) {
|
|
addTextureParameter(KEY_NORMAL_TEXTURE, aiTextureType_NORMALS, i, outputNormal);
|
|
}
|
|
|
|
// Ambient Color
|
|
addVectorParameter(KEY_AMBIENT_COLOR, AI_MATKEY_COLOR_AMBIENT);
|
|
std::string outputAmbient = KEY_AMBIENT_COLOR;
|
|
uint32 numAmbient = material->GetTextureCount(aiTextureType_AMBIENT);
|
|
for (uint32 i = 0; i < numAmbient; ++i) {
|
|
addTextureParameter(KEY_AMBIENT_TEXTURE, aiTextureType_AMBIENT, i, outputAmbient);
|
|
}
|
|
|
|
// Shininess
|
|
addScalarParameter(KEY_SHININESS, AI_MATKEY_SHININESS);
|
|
std::string outputShininess = KEY_SHININESS;
|
|
uint32 numShiny = material->GetTextureCount(aiTextureType_SHININESS);
|
|
for (uint32 i = 0; i < numShiny; ++i) {
|
|
addTextureParameter(KEY_SHININESS_TEXTURE, aiTextureType_SHININESS, i, outputShininess, {0, -1, -1, -1});
|
|
}
|
|
|
|
// Roughness
|
|
addScalarParameter(KEY_ROUGHNESS, AI_MATKEY_ROUGHNESS_FACTOR);
|
|
std::string outputRoughness = KEY_ROUGHNESS;
|
|
uint32 numRoughness = material->GetTextureCount(aiTextureType_DIFFUSE_ROUGHNESS);
|
|
for (uint32 i = 0; i < numRoughness; ++i) {
|
|
addTextureParameter(KEY_ROUGHNESS_TEXTURE, aiTextureType_DIFFUSE_ROUGHNESS, i, outputRoughness, {0, -1, -1, -1});
|
|
}
|
|
|
|
// Metallic
|
|
addScalarParameter(KEY_METALLIC, AI_MATKEY_METALLIC_FACTOR);
|
|
std::string outputMetallic = KEY_METALLIC;
|
|
uint32 numMetallic = material->GetTextureCount(aiTextureType_METALNESS);
|
|
for (uint32 i = 0; i < numMetallic; ++i) {
|
|
addTextureParameter(KEY_METALLIC_TEXTURE, aiTextureType_METALNESS, i, outputMetallic, {0, -1, -1, -1});
|
|
}
|
|
|
|
// Ambient Occlusion
|
|
std::string outputAO = "";
|
|
uint32 numAO = material->GetTextureCount(aiTextureType_AMBIENT_OCCLUSION);
|
|
for (uint32 i = 0; i < numAO; ++i) {
|
|
addTextureParameter(KEY_AMBIENT_OCCLUSION_TEXTURE, aiTextureType_AMBIENT_OCCLUSION, i, outputAO, {0, -1, -1, -1});
|
|
}
|
|
|
|
MaterialNode brdf;
|
|
brdf.variables["baseColor"] = outputDiffuse;
|
|
if (!outputNormal.empty()) {
|
|
expressions.add(new MulExpression());
|
|
expressions.back()->key = "NormalMul";
|
|
expressions.back()->inputs["lhs"].source = "2";
|
|
expressions.back()->inputs["rhs"].source = outputNormal;
|
|
|
|
expressions.add(new SubExpression());
|
|
expressions.back()->key = "NormalSub";
|
|
expressions.back()->inputs["lhs"].source = "NormalMul";
|
|
expressions.back()->inputs["rhs"].source = "float3(1,1,1)";
|
|
|
|
brdf.variables["normal"] = "NormalSub";
|
|
}
|
|
aiShadingMode mode;
|
|
material->Get(AI_MATKEY_SHADING_MODEL, mode);
|
|
switch (mode) {
|
|
case aiShadingMode_Blinn:
|
|
brdf.profile = "BlinnPhong";
|
|
brdf.variables["specularColor"] = outputSpecular;
|
|
brdf.variables["ambient"] = outputAmbient;
|
|
brdf.variables["shininess"] = outputShininess;
|
|
break;
|
|
case aiShadingMode_Phong:
|
|
brdf.profile = "Phong";
|
|
brdf.variables["specular"] = outputSpecular;
|
|
brdf.variables["ambient"] = outputAmbient;
|
|
brdf.variables["shininess"] = outputShininess;
|
|
break;
|
|
case aiShadingMode_Toon:
|
|
brdf.profile = "CelShading";
|
|
break;
|
|
default:
|
|
case aiShadingMode_CookTorrance:
|
|
brdf.profile = "CookTorrance";
|
|
brdf.variables["roughness"] = outputRoughness;
|
|
brdf.variables["metallic"] = outputMetallic;
|
|
if (!outputAO.empty()) {
|
|
brdf.variables["ambientOcclusion"] = outputAmbient;
|
|
}
|
|
break;
|
|
};
|
|
|
|
OMaterialAsset baseMat = new MaterialAsset(importPath, materialName);
|
|
baseMat->material = new Material(graphics, numTextures, numSamplers, numFloats, materialName, std::move(expressions),
|
|
std::move(parameters), std::move(brdf));
|
|
baseMat->material->compile();
|
|
graphics->getShaderCompiler()->registerMaterial(baseMat->material);
|
|
globalMaterials[m] = baseMat->instantiate(InstantiationParameter{
|
|
.name = fmt::format("{0}_Inst_0", baseMat->getName()),
|
|
.folderPath = baseMat->getFolderPath(),
|
|
});
|
|
AssetRegistry::get().saveAsset(PMaterialAsset(baseMat), MaterialAsset::IDENTIFIER, baseMat->getFolderPath(), baseMat->getName());
|
|
AssetRegistry::get().registerMaterial(std::move(baseMat));
|
|
}
|
|
}
|
|
|
|
void findMeshRoots(aiNode* node, List<aiNode*>& meshNodes) {
|
|
if (node->mNumMeshes > 0) {
|
|
meshNodes.add(node);
|
|
return;
|
|
}
|
|
for (uint32 i = 0; i < node->mNumChildren; ++i) {
|
|
findMeshRoots(node->mChildren[i], meshNodes);
|
|
}
|
|
}
|
|
|
|
void MeshLoader::loadGlobalMeshes(const aiScene* scene, const Array<PMaterialInstanceAsset>& materials, Array<OMesh>& globalMeshes,
|
|
Component::Collider& collider) {
|
|
for (int32 meshIndex = 0; meshIndex < scene->mNumMeshes; ++meshIndex) {
|
|
aiMesh* mesh = scene->mMeshes[meshIndex];
|
|
if (!(mesh->mPrimitiveTypes & aiPrimitiveType_TRIANGLE))
|
|
continue;
|
|
collider.boundingbox.adjust(Vector(mesh->mAABB.mMin.x, mesh->mAABB.mMin.y, mesh->mAABB.mMin.z));
|
|
collider.boundingbox.adjust(Vector(mesh->mAABB.mMax.x, mesh->mAABB.mMax.y, mesh->mAABB.mMax.z));
|
|
|
|
// assume static mesh for now
|
|
Array<Vector4> positions(mesh->mNumVertices);
|
|
StaticArray<Array<Vector2>, MAX_TEXCOORDS> texCoords;
|
|
for (size_t i = 0; i < MAX_TEXCOORDS; ++i) {
|
|
texCoords[i].resize(mesh->mNumVertices);
|
|
}
|
|
Array<Vector4> normals(mesh->mNumVertices);
|
|
Array<Vector4> tangents(mesh->mNumVertices);
|
|
Array<Vector4> biTangents(mesh->mNumVertices);
|
|
Array<Vector4> colors(mesh->mNumVertices);
|
|
|
|
StaticMeshVertexData* vertexData = StaticMeshVertexData::getInstance();
|
|
for (int32 i = 0; i < mesh->mNumVertices; ++i) {
|
|
positions[i] = Vector4(mesh->mVertices[i].x, mesh->mVertices[i].y, mesh->mVertices[i].z, 1.0f);
|
|
for (size_t j = 0; j < MAX_TEXCOORDS; ++j) {
|
|
if (mesh->HasTextureCoords(j)) {
|
|
texCoords[j][i] = Vector2(mesh->mTextureCoords[j][i].x, mesh->mTextureCoords[j][i].y);
|
|
} else {
|
|
texCoords[j][i] = Vector2(0, 0);
|
|
}
|
|
}
|
|
normals[i] = Vector4(mesh->mNormals[i].x, mesh->mNormals[i].y, mesh->mNormals[i].z, 1.0f);
|
|
if (mesh->HasTangentsAndBitangents()) {
|
|
tangents[i] = Vector4(mesh->mTangents[i].x, mesh->mTangents[i].y, mesh->mTangents[i].z, 1.0f);
|
|
biTangents[i] = Vector4(mesh->mBitangents[i].x, mesh->mBitangents[i].y, mesh->mBitangents[i].z, 1.0f);
|
|
} else {
|
|
tangents[i] = Vector4(0, 0, 1, 1);
|
|
biTangents[i] = Vector4(1, 0, 0, 1);
|
|
}
|
|
if (mesh->HasVertexColors(0)) {
|
|
colors[i] = Vector4(mesh->mColors[0][i].r, mesh->mColors[0][i].g, mesh->mColors[0][i].b, 1.0f);
|
|
} else {
|
|
colors[i] = Vector4(1, 1, 1, 1);
|
|
}
|
|
}
|
|
MeshId id = vertexData->allocateVertexData(mesh->mNumVertices);
|
|
vertexData->loadPositions(id, positions);
|
|
|
|
for (size_t i = 0; i < MAX_TEXCOORDS; ++i) {
|
|
vertexData->loadTexCoords(id, i, texCoords[i]);
|
|
}
|
|
vertexData->loadNormals(id, normals);
|
|
vertexData->loadTangents(id, tangents);
|
|
vertexData->loadBiTangents(id, biTangents);
|
|
vertexData->loadColors(id, colors);
|
|
|
|
Array<uint32> indices(mesh->mNumFaces * 3);
|
|
for (int32 faceIndex = 0; faceIndex < mesh->mNumFaces; ++faceIndex) {
|
|
indices[faceIndex * 3 + 0] = mesh->mFaces[faceIndex].mIndices[0];
|
|
indices[faceIndex * 3 + 1] = mesh->mFaces[faceIndex].mIndices[1];
|
|
indices[faceIndex * 3 + 2] = mesh->mFaces[faceIndex].mIndices[2];
|
|
}
|
|
|
|
Array<Meshlet> meshlets;
|
|
meshlets.reserve(indices.size() / (3ull * Gfx::numPrimitivesPerMeshlet));
|
|
Meshlet::build(positions, indices, meshlets);
|
|
vertexData->loadMesh(id, indices, meshlets);
|
|
|
|
// collider.physicsMesh.addCollider(positions, indices, Matrix4(1.0f));
|
|
|
|
globalMeshes[meshIndex] = new Mesh();
|
|
globalMeshes[meshIndex]->vertexData = vertexData;
|
|
globalMeshes[meshIndex]->id = id;
|
|
globalMeshes[meshIndex]->referencedMaterial = materials[mesh->mMaterialIndex];
|
|
globalMeshes[meshIndex]->meshlets = std::move(meshlets);
|
|
globalMeshes[meshIndex]->indices = std::move(indices);
|
|
globalMeshes[meshIndex]->vertexCount = mesh->mNumVertices;
|
|
globalMeshes[meshIndex]->blas =
|
|
graphics->createBottomLevelAccelerationStructure(Gfx::BottomLevelASCreateInfo(globalMeshes[meshIndex]));
|
|
}
|
|
}
|
|
|
|
Matrix4 convertMatrix(aiMatrix4x4 matrix) {
|
|
return Matrix4(matrix.a1, matrix.b1, matrix.c1, matrix.d1, matrix.a2, matrix.b2, matrix.c2, matrix.d2, matrix.a3, matrix.b3, matrix.c3,
|
|
matrix.d3, matrix.a4, matrix.b4, matrix.c4, matrix.d4);
|
|
}
|
|
|
|
aiMatrix4x4 loadNodeTransform(aiNode* node) {
|
|
aiMatrix4x4 parent = aiMatrix4x4();
|
|
if (node->mParent != nullptr) {
|
|
parent = loadNodeTransform(node->mParent);
|
|
}
|
|
return node->mTransformation * parent;
|
|
}
|
|
|
|
void MeshLoader::import(MeshImportArgs args, PMeshAsset meshAsset) {
|
|
std::cout << "Starting to import " << args.filePath << std::endl;
|
|
meshAsset->setStatus(Asset::Status::Loading);
|
|
Assimp::Importer importer;
|
|
importer.ReadFile(args.filePath.string().c_str(),
|
|
(uint32)(aiProcess_JoinIdenticalVertices | aiProcess_FlipUVs | aiProcess_Triangulate | aiProcess_SortByPType |
|
|
aiProcess_GenBoundingBoxes | aiProcess_GenSmoothNormals | aiProcess_ImproveCacheLocality |
|
|
aiProcess_GenUVCoords | aiProcess_FindDegenerates));
|
|
const aiScene* scene = importer.ApplyPostProcessing(aiProcess_CalcTangentSpace);
|
|
std::cout << importer.GetErrorString() << std::endl;
|
|
|
|
Array<PTextureAsset> textures;
|
|
loadTextures(scene, args.filePath.parent_path(), args.importPath, textures);
|
|
Array<PMaterialInstanceAsset> globalMaterials(scene->mNumMaterials);
|
|
loadMaterials(scene, textures, args.filePath.stem().string(), args.filePath.parent_path(), args.importPath, globalMaterials);
|
|
|
|
Array<OMesh> globalMeshes(scene->mNumMeshes);
|
|
Component::Collider collider;
|
|
loadGlobalMeshes(scene, globalMaterials, globalMeshes, collider);
|
|
|
|
List<aiNode*> meshNodes;
|
|
findMeshRoots(scene->mRootNode, meshNodes);
|
|
|
|
Array<OMesh> meshes;
|
|
for (auto meshNode : meshNodes) {
|
|
for (uint32 i = 0; i < meshNode->mNumMeshes; ++i) {
|
|
if (globalMeshes[meshNode->mMeshes[i]] == nullptr) {
|
|
continue;
|
|
}
|
|
meshes.add(std::move(globalMeshes[meshNode->mMeshes[i]]));
|
|
meshes.back()->transform = convertMatrix(loadNodeTransform(meshNode));
|
|
}
|
|
}
|
|
meshAsset->meshes = std::move(meshes);
|
|
meshAsset->physicsMesh = std::move(collider);
|
|
|
|
auto stream = AssetRegistry::createWriteStream(
|
|
(std::filesystem::path(meshAsset->getFolderPath()) / meshAsset->getName()).replace_extension("asset").string(), std::ios::binary);
|
|
|
|
ArchiveBuffer archive;
|
|
Serialization::save(archive, MeshAsset::IDENTIFIER);
|
|
Serialization::save(archive, meshAsset->getName());
|
|
Serialization::save(archive, meshAsset->getFolderPath());
|
|
meshAsset->save(archive);
|
|
archive.writeToStream(stream);
|
|
|
|
meshAsset->setStatus(Asset::Status::Ready);
|
|
std::cout << "Finished loading " << args.filePath << std::endl;
|
|
}
|