xiaoqi
/
SHADE_Y3
1
0
Fork 0
Code Issues 12 Pull Requests Packages Projects Releases 9 Wiki Activity

SP3-103 SP3-104 Separated mesh and texture loading 

Added in lines in SBApplication to load racoon fbx and dds textures

Racoon shows up in renderdoc hehe
This commit is contained in:
Xiao Qi 2022-09-26 14:38:12 +08:00
parent a0a57e7c29
commit 99534c1613
12 changed files with 107 additions and 5081 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

BIN
Assets/racoon.bin
View File

Binary file not shown.

BIN
Assets/racoon.fbx
View File

Binary file not shown.

5027
Assets/racoon.gltf
View File

File diff suppressed because it is too large Load Diff

4
SHADE_Application/src/Application/SBApplication.cpp
View File

@ -74,7 +74,11 @@ namespace Sandbox
SHADE::SHComponentManager::CreateComponentSparseSet<SHADE::SHRenderable>();
SHADE::SHComponentManager::CreateComponentSparseSet<SHADE::SHTransformComponent>();
//TODO: REMOVE AFTER PRESENTATION
SHADE::SHAssetManager::LoadDataTemp("../../Assets/racoon.fbx");
SHADE::SHAssetManager::LoadDataTemp("../../Assets/RaccoonBag_Color_Ver4.dds");
SHADE::SHAssetManager::LoadDataTemp("../../Assets/RaccoonPreTexturedVer1_Base9.dds");
//TODO: REMOVE AFTER PRESENTATION
// Set up graphics system and windows
graphicsSystem->SetWindow(&window);

44
SHADE_Application/src/Scenes/SBTestScene.cpp
View File

@ -10,6 +10,8 @@
#include "Scripting/SHScriptEngine.h"
#include "Math/Transform/SHTransformComponent.h"
#include "Assets/SHAssetManager.h"
using namespace SHADE;
namespace Sandbox
@ -33,6 +35,23 @@ namespace Sandbox
SHADE::SHGraphicsSystem* graphicsSystem = static_cast<SHADE::SHGraphicsSystem*>(SHADE::SHSystemManager::GetSystem<SHADE::SHGraphicsSystem>());
// Create temp meshes
const auto CUBE_MESH = SHADE::SHPrimitiveGenerator::Cube(*graphicsSystem);
//graphicsSystem->BuildMeshBuffers();
//Test Racoon mesh
auto meshes = SHADE::SHAssetManager::GetAllMeshes();
std::vector<Handle<SHMesh>> handles;
for (auto const& mesh : meshes)
{
handles.push_back(graphicsSystem->AddMesh(
mesh.header.vertexCount,
mesh.vertexPosition.data(),
mesh.texCoords.data(),
mesh.vertexTangent.data(),
mesh.vertexNormal.data(),
mesh.header.indexCount,
mesh.indices.data()
));
}
graphicsSystem->BuildMeshBuffers();
// Create Materials
@ -44,22 +63,33 @@ namespace Sandbox
constexpr int NUM_COLS = 100;
static const SHVec3 TEST_OBJ_SPACING = { 1.0f, 1.0f, 1.0f };
static const SHVec3 TEST_OBJ_START_POS = { - (NUM_COLS / 2 * TEST_OBJ_SPACING.x ), 0.0f, 0.0f };
for (int z = 0; z < NUM_ROWS; ++z)
for (int x = 0; x < NUM_COLS; ++x)
{
//for (int z = 0; z < NUM_ROWS; ++z)
//for (int x = 0; x < NUM_COLS; ++x)
//{
// auto entity = SHEntityManager::CreateEntity<SHRenderable, SHTransformComponent>();
// auto& renderable = *SHComponentManager::GetComponent_s<SHRenderable>(entity);
// auto& transform = *SHComponentManager::GetComponent_s<SHTransformComponent>(entity);
// renderable.Mesh = handles.front();
// renderable.SetMaterial(matInst);
// // Set initial positions
// transform.SetWorldPosition(TEST_OBJ_START_POS + SHVec3{ x * TEST_OBJ_SPACING.x, 0.0f, z * TEST_OBJ_SPACING.z });
// //transform.SetLocalScale(TEST_OBJ_SCALE);
// stressTestObjects.emplace_back(entity);
//}
auto entity = SHEntityManager::CreateEntity<SHRenderable, SHTransformComponent>();
auto& renderable = *SHComponentManager::GetComponent_s<SHRenderable>(entity);
auto& transform = *SHComponentManager::GetComponent_s<SHTransformComponent>(entity);
renderable.Mesh = CUBE_MESH;
renderable.Mesh = handles.front();
renderable.SetMaterial(matInst);
// Set initial positions
transform.SetWorldPosition(TEST_OBJ_START_POS + SHVec3{ x * TEST_OBJ_SPACING.x, 0.0f, z * TEST_OBJ_SPACING.z });
//transform.SetLocalScale(TEST_OBJ_SCALE);
stressTestObjects.emplace_back(entity);
}
// Create blank entity with a script
testObj = SHADE::SHEntityManager::CreateEntity();

20
SHADE_Engine/src/Assets/Libraries/SHDDSLoader.cpp
View File

@ -26,25 +26,13 @@ namespace SHADE
}
}
void SHDDSLoader::LoadImageAsset(std::vector<AssetPath> const& paths, std::vector<SHDDSAsset>& images)
void SHDDSLoader::LoadImageAsset(AssetPath path, SHDDSAsset& asset)
{
std::vector<SHDDSAsset> result;
tinyddsloader::Result loadResult = tinyddsloader::Result::Success;
AssetPath lastPath;
for (auto const& path : paths)
loadResult = asset.image.Load(path.string().c_str());
if (loadResult != tinyddsloader::Result::Success)
{
if (loadResult == tinyddsloader::Result::Success)
{
result.emplace_back();
}
else
{
SHLOG_ERROR("Unable to load DDS file: {} at {}", TinyDDSResultToString(loadResult), lastPath.string());
}
loadResult = result.back().image.Load(path.string().c_str());
lastPath = path;
SHLOG_ERROR("Unable to load DDS file: {} at {}", TinyDDSResultToString(loadResult), path.string());
}
std::swap(images, result);
}
}

2
SHADE_Engine/src/Assets/Libraries/SHDDSLoader.h
View File

@ -13,6 +13,6 @@ namespace SHADE
private:
static std::string TinyDDSResultToString(tinyddsloader::Result value);
public:
static void LoadImageAsset(std::vector<AssetPath> const& paths, std::vector<SHDDSAsset>& images);
static void LoadImageAsset(AssetPath paths, SHDDSAsset& image);
};
}

21
SHADE_Engine/src/Assets/Libraries/SHMeshLoader.cpp
View File

@ -14,7 +14,7 @@ namespace SHADE
meshes.push_back(ProcessMesh(*mesh, scene));
}
for (size_t i{ 0 }; i < node.mNumMeshes; ++i)
for (size_t i{ 0 }; i < node.mNumChildren; ++i)
{
ProcessNode(*node.mChildren[i], scene, meshes);
}
@ -85,7 +85,7 @@ namespace SHADE
return result;
}
bool SHMeshLoader::LoadMesh(std::vector<SHMeshAsset>& meshes, std::vector<AssetPath>& images, AssetPath path)
bool SHMeshLoader::LoadMesh(std::vector<SHMeshAsset>& meshes, AssetPath path)
{
const aiScene* scene = aiImporter.ReadFile(path.string().c_str(),
aiProcess_Triangulate
@ -111,11 +111,18 @@ namespace SHADE
SHLOG_ERROR("ERROR in GLTF::ASSIMP: {}\nFile: {}", aiImporter.GetErrorString(), path.string());
return false;
}
for (size_t i {0}; i < scene->mNumTextures; ++i)
{
images.push_back(AssetPath(scene->mTextures[i]->mFilename.C_Str()));
}
//TODO MATERIALS FROM MESHES
//if (scene->HasMaterials())
//{
// for (int i{0}; i < scene->mNumMaterials; ++i)
// {
// if (scene->mMaterials[i]->mNumProperties > 0)
// {
// for (int j{0}; j < scene->mMaterials[i]->mProperties[j].)
// }
//std::cout << scene->mMaterials[i]->;
// }
//}
ProcessNode(*scene->mRootNode, *scene, meshes);

2
SHADE_Engine/src/Assets/Libraries/SHMeshLoader.h
View File

@ -16,6 +16,6 @@ namespace SHADE
static SHMeshAsset ProcessMesh(aiMesh const& mesh, aiScene const& scene);
public:
static bool LoadMesh(std::vector<SHMeshAsset>& meshes, std::vector<AssetPath>& images, AssetPath path);
static bool LoadMesh(std::vector<SHMeshAsset>& meshes, AssetPath path);
};
}

2
SHADE_Engine/src/Assets/SHAssetMacros.h
View File

@ -70,7 +70,7 @@ enum class AssetType : uint8_t
#define PREFAB_EXTENSION ".SHPrefab"
#define MATERIAL_EXTENSION ".SHMat"
#define TEXTURE_EXTENSION ".dds"
#define MESH_EXTENSION ".gltf"
#define MESH_EXTENSION ".fbx"
std::string const EXTENSIONS[] = {
AUDIO_EXTENSION,

64
SHADE_Engine/src/Assets/SHAssetManager.cpp
View File

@ -199,17 +199,41 @@ namespace SHADE
{
AssetPath path{ p };
LoadGLTF(
{
.name {path.filename().string()},
.id {0},
.type {AssetType::MESH},
.path {path},
.location {0}
}
);
if (path.extension().string() == MESH_EXTENSION)
{
LoadGLTF(
{
.name {path.filename().string()},
.id {0},
.type {AssetType::MESH},
.path {path},
.location {0}
}
);
}
else if (path.extension().string() == TEXTURE_EXTENSION)
{
LoadDDS(
{
.name {path.filename().string()},
.id {0},
.type {AssetType::DDS},
.path {path},
.location {0}
}
);
}
}
SHLOG_INFO("Loaded meshes\n");
std::vector<SHMeshAsset> SHAssetManager::GetAllMeshes() noexcept
{
std::vector<SHMeshAsset> result;
for (auto const& mesh : meshCollection)
{
result.push_back(mesh.second);
}
return result;
}
/****************************************************************************
@ -259,24 +283,22 @@ namespace SHADE
void SHAssetManager::LoadGLTF(SHAsset asset) noexcept
{
std::vector<SHMeshAsset> meshes;
std::vector<AssetPath> imagePaths;
std::vector<SHDDSAsset> images;
SHMeshLoader::LoadMesh(meshes, imagePaths, asset.path);
SHDDSLoader::LoadImageAsset(imagePaths, images);
//TODO Recognise new meshes as asset as well and write mesh into binary
//TODO
SHMeshLoader::LoadMesh(meshes, asset.path);
for (auto const& mesh : meshes)
{
meshCollection.emplace(GenerateAssetID(AssetType::MESH), mesh);
}
}
for (auto const& image : images)
{
ddsCollection.emplace(GenerateAssetID(AssetType::DDS), image);
}
void SHAssetManager::LoadDDS(SHAsset asset) noexcept
{
SHDDSAsset image;
SHDDSLoader::LoadImageAsset(asset.path, image);
ddsCollection.emplace(GenerateAssetID(AssetType::DDS), image);
}
/****************************************************************************

2
SHADE_Engine/src/Assets/SHAssetManager.h
View File

@ -72,6 +72,7 @@ namespace SHADE
//TODO: TEMPORARY FOR TESTING GLTF & DDS
static void LoadDataTemp(std::string path) noexcept;
static std::vector<SHMeshAsset> GetAllMeshes() noexcept;
private:
/****************************************************************************
@ -116,6 +117,7 @@ namespace SHADE
// Specialised load calls
static void LoadGLTF(SHAsset asset) noexcept;
static void LoadDDS(SHAsset asset) noexcept;
static FMOD::System* audioSystem;
static std::unordered_map<AssetID,SHSound>* audioSoundList;