Dynamitos/Seele
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Loading logic moved to Asset classes

Browse Source
This commit is contained in:
Dynamitos
2020-06-08 01:44:47 +02:00
parent 356e6058fe
commit ab4a3b5e23
50 changed files with 966 additions and 558 deletions
Download Patch File Download Diff File Expand all files Collapse all files
cmake/FindAssimp.cmake
-2
View File
@@ -89,7 +89,5 @@ if (ASSIMP_FOUND)
set(ASSIMP_INCLUDE_DIRS ${ASSIMP_INCLUDE_DIR})
endif()
message(STATUS BINARY: ${ASSIMP_BINARY})
# Hide some variables
mark_as_advanced(ASSIMP_INCLUDE_DIR ASSIMP_LIBRARY)
cmake/FindGLFW.cmake
-2
View File
@@ -46,8 +46,6 @@ if (WIN32)
${GLFW_ROOT}/src
PATH_SUFFIXES Debug Release)
message(STATUS cant find ${GLFW_LIBRARY_NAME} in ${GLFW_ROOT}/src)
unset(GLFW_LIBRARY_NAME)
find_file(
src/Engine/Asset/Asset.cpp
-4
View File
@@ -19,10 +19,6 @@ Asset::Asset(const std::filesystem::path& path)
name = fullPath.stem();
extension = fullPath.extension();
}
Asset::Asset(const std::string &fullPath)
: Asset(std::filesystem::path(fullPath))
{
}
Asset::Asset(const std::string &directory, const std::string &fileName)
: Asset(std::filesystem::path(directory + fileName))
src/Engine/Asset/Asset.h
+6 -4
View File
@@ -13,12 +13,12 @@ public:
Ready
};
Asset();
Asset(const std::filesystem::path& path);
Asset(const std::string& directory, const std::string& name);
Asset(const std::string& fullPath);
Asset(const std::filesystem::path& path);
virtual ~Asset();
std::ifstream& getReadStream();
std::ofstream& getWriteStream();
virtual void save() = 0;
virtual void load() = 0;
// returns the name of the file, without extension
std::string getFileName();
@@ -38,6 +38,8 @@ public:
}
protected:
std::mutex lock;
std::ifstream& getReadStream();
std::ofstream& getWriteStream();
private:
Status status;
std::filesystem::path fullPath;
src/Engine/Asset/AssetRegistry.cpp
+15 -13
View File
@@ -7,6 +7,7 @@
#include "Material/Material.h"
#include "Graphics/Graphics.h"
#include "graphics/WindowManager.h"
#include <filesystem>
using namespace Seele;
@@ -21,21 +22,22 @@ void AssetRegistry::init(const std::string& rootFolder)
void AssetRegistry::importFile(const std::string &filePath)
{
std::string extension = filePath.substr(filePath.find_last_of(".") + 1);
std::filesystem::path fsPath = std::filesystem::path(filePath);
std::string extension = fsPath.extension().string();
std::cout << extension << std::endl;
if (extension.compare("fbx") == 0
|| extension.compare("obj") == 0)
if (extension.compare(".fbx") == 0
|| extension.compare(".obj") == 0)
{
get().registerMesh(filePath);
get().registerMesh(fsPath);
}
if (extension.compare("png") == 0
|| extension.compare("jpg") == 0)
if (extension.compare(".png") == 0
|| extension.compare(".jpg") == 0)
{
get().registerTexture(filePath);
get().registerTexture(fsPath);
}
if (extension.compare("semat") == 0)
if (extension.compare(".semat") == 0)
{
get().registerMaterial(filePath);
get().registerMaterial(fsPath);
}
}
@@ -64,7 +66,7 @@ AssetRegistry::AssetRegistry()
{
}
void AssetRegistry::init(const std::string &rootFolder, Gfx::PGraphics graphics)
void AssetRegistry::init(const std::filesystem::path &rootFolder, Gfx::PGraphics graphics)
{
AssetRegistry &reg = get();
reg.rootFolder = rootFolder;
@@ -73,17 +75,17 @@ void AssetRegistry::init(const std::string &rootFolder, Gfx::PGraphics graphics)
reg.materialLoader = new MaterialLoader(graphics);
}
void AssetRegistry::registerMesh(const std::string &filePath)
void AssetRegistry::registerMesh(const std::filesystem::path &filePath)
{
meshLoader->importAsset(filePath);
}
void AssetRegistry::registerTexture(const std::string &filePath)
void AssetRegistry::registerTexture(const std::filesystem::path &filePath)
{
textureLoader->importAsset(filePath);
}
void AssetRegistry::registerMaterial(const std::string &filePath)
void AssetRegistry::registerMaterial(const std::filesystem::path &filePath)
{
materialLoader->queueAsset(filePath);
}
src/Engine/Asset/AssetRegistry.h
+5 -5
View File
@@ -27,13 +27,13 @@ private:
static AssetRegistry& get();
AssetRegistry();
void init(const std::string& rootFolder, Gfx::PGraphics graphics);
void init(const std::filesystem::path& rootFolder, Gfx::PGraphics graphics);
void registerMesh(const std::string& filePath);
void registerTexture(const std::string& filePath);
void registerMaterial(const std::string& filePath);
void registerMesh(const std::filesystem::path& filePath);
void registerTexture(const std::filesystem::path& filePath);
void registerMaterial(const std::filesystem::path& filePath);
std::string rootFolder;
std::filesystem::path rootFolder;
Map<std::string, PTextureAsset> textures;
Map<std::string, PMeshAsset> meshes;
Map<std::string, PMaterialAsset> materials;
src/Engine/Asset/MaterialLoader.cpp
+3 -2
View File
@@ -14,9 +14,10 @@ MaterialLoader::~MaterialLoader()
{
}
PMaterial MaterialLoader::queueAsset(const std::string& filePath)
PMaterial MaterialLoader::queueAsset(const std::filesystem::path& filePath)
{
PMaterial result = new Material(filePath);
//TODO
// TODO: There is actually no real reason to import a standalone material,
// maybe in the future there could be a substance loader or something
return result;
}
src/Engine/Asset/MaterialLoader.h
+1 -1
View File
@@ -13,7 +13,7 @@ class MaterialLoader
public:
MaterialLoader(Gfx::PGraphics graphic);
~MaterialLoader();
PMaterial queueAsset(const std::string& filePath);
PMaterial queueAsset(const std::filesystem::path& filePath);
private:
List<std::future<void>> futures;
PMaterial placeholderMaterial;
src/Engine/Asset/MeshAsset.cpp
+14 -1
View File
@@ -7,11 +7,24 @@ using namespace Seele;
MeshAsset::MeshAsset()
{
}
MeshAsset::MeshAsset(const std::string& directory, const std::string& name)
: Asset(directory, name)
{
}
MeshAsset::MeshAsset(const std::string& fullPath)
MeshAsset::MeshAsset(const std::filesystem::path& fullPath)
: Asset(fullPath)
{
}
MeshAsset::~MeshAsset()
{
}
void MeshAsset::save()
{
//TODO:
}
void MeshAsset::load()
{
//TODO:
}
src/Engine/Asset/MeshAsset.h
+13 -4
View File
@@ -4,19 +4,28 @@
namespace Seele
{
DECLARE_REF(Mesh);
DECLARE_REF(MaterialAsset);
class MeshAsset : public Asset
{
public:
MeshAsset();
MeshAsset(const std::string& directory, const std::string& name);
MeshAsset(const std::string& fullPath);
void setMesh(PMesh mesh)
MeshAsset(const std::filesystem::path& fullPath);
virtual ~MeshAsset();
virtual void save() override;
virtual void load() override;
void addMesh(PMesh mesh)
{
std::scoped_lock lck(lock);
this->mesh = mesh;
meshes.add(mesh);
}
const Array<PMesh> getMeshes() const
{
return meshes;
}
private:
PMesh mesh;
Array<PMesh> meshes;
Array<PMaterialAsset> referencedMaterials;
};
DEFINE_REF(MeshAsset);
} // namespace Seele
src/Engine/Asset/MeshLoader.cpp
+219 -17
View File
@@ -1,10 +1,18 @@
#include "MeshLoader.h"
#include "Graphics/Graphics.h"
#include "Graphics/GraphicsResources.h"
#include "MeshAsset.h"
#include "Graphics/Mesh.h"
#include "AssetRegistry.h"
#include <filesystem>
#include <fstream>
#include <nlohmann/json.hpp>
#include <stb_image_write.h>
#include <assimp/config.h>
#include <assimp/Importer.hpp>
#include <assimp/scene.h>
#include <assimp/postprocess.h>
#include <assimp/material.h>
using namespace Seele;
@@ -17,45 +25,239 @@ MeshLoader::~MeshLoader()
{
}
void MeshLoader::importAsset(const std::string& path)
void MeshLoader::importAsset(const std::filesystem::path &path)
{
futures.add(std::async(std::launch::async, &MeshLoader::import, this, path));
}
void findMeshRoots(aiNode* node, List<aiNode*>& meshNodes)
void findMeshRoots(aiNode *node, List<aiNode *> &meshNodes)
{
if(node->mNumMeshes > 0)
if (node->mNumMeshes > 0)
{
meshNodes.add(node);
return;
}
for(uint32 i = 0; i < node->mNumChildren; ++i)
for (uint32 i = 0; i < node->mNumChildren; ++i)
{
findMeshRoots(node->mChildren[i], meshNodes);
}
}
void loadToBuffer(Array<Vector>& buffer, const aiVector3D* sourceData, uint32 size)
{
buffer.resize(size);
for(uint32 i = 0; i < size; ++i)
{
buffer[i] = Vector(sourceData[i].x, sourceData[i].y, sourceData[i].z);
}
}
Gfx::VertexStream createVertexStream(uint32 size, aiVector3D* sourceData, Gfx::PGraphics graphics)
{
Array<Vector> buffer(size);
for(uint32 i = 0; i < size; ++i)
{
buffer[i] = Vector(sourceData[i].x, sourceData[i].y, sourceData[i].z);
}
VertexBufferCreateInfo vbInfo;
vbInfo.numVertices = size;
vbInfo.vertexSize = sizeof(Vector);
vbInfo.resourceData.data = (uint8 *)buffer.data();
vbInfo.resourceData.owner = Gfx::QueueType::DEDICATED_TRANSFER;
vbInfo.resourceData.size = buffer.size();
Gfx::PVertexBuffer vertexBuffer = graphics->createVertexBuffer(vbInfo);
auto stream = Gfx::VertexStream(vbInfo.vertexSize, 0, false, vertexBuffer);
stream.addVertexElement(Gfx::VertexElement(0, Gfx::SE_FORMAT_R32G32_SFLOAT, 0));
return stream;
}
Gfx::VertexStream createVertexStream(uint32 size, aiVector2D* sourceData, Gfx::PGraphics graphics)
{
Array<Vector2> buffer(size);
for(uint32 i = 0; i < size; ++i)
{
buffer[i] = Vector2(sourceData[i].x, sourceData[i].y);
}
VertexBufferCreateInfo vbInfo;
vbInfo.numVertices = size;
vbInfo.vertexSize = sizeof(Vector2);
vbInfo.resourceData.data = (uint8 *)buffer.data();
vbInfo.resourceData.owner = Gfx::QueueType::DEDICATED_TRANSFER;
vbInfo.resourceData.size = buffer.size();
Gfx::PVertexBuffer vertexBuffer = graphics->createVertexBuffer(vbInfo);
auto stream = Gfx::VertexStream(vbInfo.vertexSize, 0, false, vertexBuffer);
stream.addVertexElement(Gfx::VertexElement(0, Gfx::SE_FORMAT_R32G32B32_SFLOAT, 0));
return stream;
}
void loadGlobalMeshes(const aiScene* scene, Array<PMesh>& globalMeshes, Gfx::PGraphics graphics)
{
for (uint32 meshIndex = 0; meshIndex < scene->mNumMeshes; ++meshIndex)
{
aiMesh *mesh = scene->mMeshes[meshIndex];
void MeshLoader::import(const std::string& path)
MeshDescription description;
Gfx::PVertexDeclaration declaration = new Gfx::VertexDeclaration();
declaration->addVertexStream(createVertexStream(mesh->mNumVertices, mesh->mVertices, graphics));
description.layout.add(VertexAttribute::POSITION);
for(uint32 i = 0; i < MAX_TEX_CHANNELS; ++i)
{
if(mesh->HasTextureCoords(i))
{
declaration->addVertexStream(createVertexStream(mesh->mNumVertices, mesh->mTextureCoords[i], graphics));
description.layout.add(VertexAttribute::TEXCOORD);
}
}
if(mesh->HasNormals())
{
declaration->addVertexStream(createVertexStream(mesh->mNumVertices, mesh->mNormals, graphics));
description.layout.add(VertexAttribute::NORMAL);
}
if(mesh->HasTangentsAndBitangents())
{
declaration->addVertexStream(createVertexStream(mesh->mNumVertices, mesh->mVertices, graphics));
declaration->addVertexStream(createVertexStream(mesh->mNumVertices, mesh->mVertices, graphics));
description.layout.add(VertexAttribute::TANGENT);
description.layout.add(VertexAttribute::BITANGENT);
}
description.declaration = declaration;
Array<uint32> indices(mesh->mNumFaces * 3);
for (uint32 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];
}
IndexBufferCreateInfo idxInfo;
idxInfo.indexType = Gfx::SE_INDEX_TYPE_UINT32;
idxInfo.resourceData.data = (uint8 *)indices.data();
idxInfo.resourceData.owner = Gfx::QueueType::DEDICATED_TRANSFER;
idxInfo.resourceData.size = indices.size();
Gfx::PIndexBuffer indexBuffer = graphics->createIndexBuffer(idxInfo);
indexBuffer->transferOwnership(Gfx::QueueType::GRAPHICS);
globalMeshes[meshIndex] = new Mesh(description, indexBuffer);
}
}
void 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 loadTextures(const aiScene* scene, Gfx::PGraphics graphics, const std::filesystem::path& meshPath)
{
for (uint32 i = 0; i < scene->mNumTextures; ++i)
{
aiTexture* tex = scene->mTextures[i];
auto texPath = std::filesystem::path(tex->mFilename.C_Str());
auto texPngPath = meshPath.parent_path().append(texPath.filename().string());
if(tex->mHeight == 0)
{
// already compressed, just dump it to the disk
std::ofstream file(texPngPath, std::ios::binary);
file.write((const char*)tex->pcData, tex->mWidth);
file.flush();
}
else
{
// 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(texPngPath.string().c_str(), tex->mWidth, tex->mHeight, 4, tex->pcData, tex->mWidth * 32);
delete texData;
}
AssetRegistry::importFile(texPngPath.string());
}
}
void loadMaterials(const aiScene* scene, Gfx::PGraphics graphics)
{
using json = nlohmann::json;
for(uint32 i = 0; i < scene->mNumMaterials; ++i)
{
aiMaterial* material = scene->mMaterials[i];
json matCode;
matCode["name"] = material->GetName().C_Str();
matCode["profile"] = "BlinnPhong"; //TODO: other shading models
std::vector<std::string> code;
aiString texPath;
//TODO make samplers based on used textures
matCode["params"]["texSampler"] =
{
{"type", "SamplerState"}
};
if(material->GetTexture(aiTextureType_DIFFUSE, 0, &texPath) == AI_SUCCESS)
{
std::string texFilename = std::filesystem::path(texPath.C_Str()).stem().string();
matCode["params"]["diffuseTexture"] =
{
{"type", "Texture2D"},
{"default", texFilename}
};
code.push_back("result.baseColor = diffuseTexture.Sample(textureSampler, geometry.texCoord).xyz;\n");
}
if(material->GetTexture(aiTextureType_SPECULAR, 0, &texPath) == AI_SUCCESS)
{
std::string texFilename = std::filesystem::path(texPath.C_Str()).stem().string();
matCode["params"]["specularTexture"] =
{
{"type", "Texture2D"},
{"default", texFilename}
};
code.push_back("result.specular = specularTexture.Sample(textureSampler, geometry.texCoord).xyz;\n");
}
if(material->GetTexture(aiTextureType_NORMALS, 0, &texPath) == AI_SUCCESS)
{
std::string texFilename = std::filesystem::path(texPath.C_Str()).stem().string();
matCode["params"]["normalTexture"] =
{
{"type", "Texture2D"},
{"default", texFilename}
};
code.push_back("float3 bumpMapNormal = normalTexture.Sample(textureSampler, geometry.texCoord).xyz;\n");
code.push_back("bumpMapNormal = 2.0 * bumpMapNormal - float3(1.0f, 1.0f, 1.0f);\n");
code.push_back("result.normal = geometry.transformLocalToWorld(bumpMapNormal);\n");
}
code.push_back("return result;\n");
matCode["code"] = code;
std::ofstream outMatFile(material->GetName().C_Str());
outMatFile << std::setw(4) << matCode;
outMatFile.flush();
}
}
void MeshLoader::import(const std::filesystem::path &path)
{
PMeshAsset asset = new MeshAsset(path);
asset->setStatus(Asset::Status::Loading);
Assimp::Importer importer;
const aiScene* scene = importer.ReadFile(path.c_str(),
aiProcess_CalcTangentSpace |
importer.ReadFile(path.string().c_str(),
aiProcess_FlipUVs |
aiProcess_ImproveCacheLocality |
aiProcess_OptimizeMeshes |
aiProcess_GenBoundingBoxes |
aiProcessPreset_TargetRealtime_Fast);
aiProcess_Triangulate |
aiProcess_SortByPType |
aiProcess_GenSmoothNormals |
aiProcess_GenUVCoords |
aiProcess_FindDegenerates |
aiProcess_EmbedTextures);
const aiScene *scene = importer.ApplyPostProcessing(aiProcess_CalcTangentSpace);
Array<PMesh> globalMeshes(scene->mNumMeshes);
loadGlobalMeshes(scene, globalMeshes, graphics);
loadTextures(scene, graphics, path);
loadMaterials(scene, graphics);
List<aiNode*> meshNodes;
List<aiNode *> meshNodes;
findMeshRoots(scene->mRootNode, meshNodes);
for(auto meshNode : meshNodes)
for (auto meshNode : meshNodes)
{
std::cout << "Test:" << meshNode->mNumMeshes << std::endl;
std::string fileName = std::string(meshNode->mName.C_Str()).append(".asset");
PMeshAsset meshAsset = new MeshAsset(fileName);
for(uint32 i = 0; i < meshNode->mNumMeshes; ++i)
{
meshAsset->addMesh(globalMeshes[meshNode->mMeshes[i]]);
}
AssetRegistry::get().meshes[meshAsset->getFileName()] = meshAsset;
}
PMesh mesh = new Mesh(nullptr, nullptr);
asset->setMesh(mesh);
asset->setStatus(Asset::Status::Ready);
}
src/Engine/Asset/MeshLoader.h
+2 -2
View File
@@ -13,9 +13,9 @@ class MeshLoader
public:
MeshLoader(Gfx::PGraphics graphic);
~MeshLoader();
void importAsset(const std::string& filePath);
void importAsset(const std::filesystem::path& filePath);
private:
void import(const std::string& path);
void import(const std::filesystem::path& path);
List<std::future<void>> futures;
Gfx::PGraphics graphics;
};
src/Engine/Asset/TextureAsset.cpp
+36 -1
View File
@@ -1,5 +1,9 @@
#include "TextureAsset.h"
#include "Graphics/GraphicsResources.h"
#include "Graphics/Graphics.h"
#include "Graphics/WindowManager.h"
#include <stb_image.h>
#include <stb_image_write.h>
using namespace Seele;
@@ -11,7 +15,38 @@ TextureAsset::TextureAsset(const std::string& directory, const std::string& name
: Asset(directory, name)
{
}
TextureAsset::TextureAsset(const std::string& fullPath)
TextureAsset::TextureAsset(const std::filesystem::path& fullPath)
: Asset(fullPath)
{
}
TextureAsset::~TextureAsset()
{
}
void TextureAsset::save()
{
//TODO: make this an actual file, not just a png wrapper
}
void TextureAsset::load()
{
setStatus(Status::Loading);
int x, y, n;
unsigned char* data = stbi_load(getFullPath().c_str(), &x, &y, &n, 4);
TextureCreateInfo createInfo;
//TODO: support other formats
createInfo.format = Gfx::SE_FORMAT_R8G8B8A8_UINT;
createInfo.resourceData.data = data;
createInfo.resourceData.size = x * y * 4 * sizeof(unsigned char);
createInfo.resourceData.owner = Gfx::QueueType::DEDICATED_TRANSFER;
createInfo.width = x;
createInfo.height = y;
Gfx::PTexture2D texture = WindowManager::getGraphics()->createTexture2D(createInfo);
stbi_image_free(data);
texture->transferOwnership(Gfx::QueueType::GRAPHICS);
setTexture(texture);
setStatus(Asset::Status::Ready);
}
src/Engine/Asset/TextureAsset.h
+4 -1
View File
@@ -8,7 +8,10 @@ class TextureAsset : public Asset
public:
TextureAsset();
TextureAsset(const std::string& directory, const std::string& name);
TextureAsset(const std::string& fullPath);
TextureAsset(const std::filesystem::path& fullPath);
virtual ~TextureAsset();
virtual void save() override;
virtual void load() override;
void setTexture(Gfx::PTexture texture)
{
std::scoped_lock lck(lock);
src/Engine/Asset/TextureLoader.cpp
+12 -24
View File
@@ -4,6 +4,8 @@
#include "AssetRegistry.h"
#define STB_IMAGE_IMPLEMENTATION
#include <stb_image.h>
#define STB_IMAGE_WRITE_IMPLEMENTATION
#include <stb_image_write.h>
using namespace Seele;
@@ -18,44 +20,30 @@ TextureLoader::~TextureLoader()
{
}
void TextureLoader::importAsset(const std::string& filePath)
void TextureLoader::importAsset(const std::filesystem::path& filePath)
{
futures.add(std::async(std::launch::async, &TextureLoader::import, this, filePath));
}
void TextureLoader::import(const std::string& path)
void TextureLoader::import(const std::filesystem::path& path)
{
PTextureAsset asset = new TextureAsset(path);
AssetRegistry::get().textures[path] = asset;
std::filesystem::path assetPath = path.stem().append(".asset");
PTextureAsset asset = new TextureAsset(assetPath);
asset->setStatus(Asset::Status::Loading);
int x, y, n;
const std::string fullPath = std::string(asset->getFullPath());
unsigned char* data = stbi_load(fullPath.c_str(), &x, &y, &n, 0);
unsigned char* data = stbi_load(path.string().c_str(), &x, &y, &n, 4);
TextureCreateInfo createInfo;
createInfo.format = Gfx::SE_FORMAT_R8G8B8A8_UINT;
createInfo.resourceData.data = data;
createInfo.resourceData.size = x * y * n * sizeof(unsigned char);
createInfo.resourceData.size = x * y * 4 * sizeof(unsigned char);
createInfo.resourceData.owner = Gfx::QueueType::DEDICATED_TRANSFER;
createInfo.width = x;
createInfo.height = y;
switch (n)
{
case 1:
createInfo.format = Gfx::SE_FORMAT_R8_UINT;
break;
case 2:
createInfo.format = Gfx::SE_FORMAT_R8G8_UINT;
break;
case 3:
createInfo.format = Gfx::SE_FORMAT_R8G8B8_UINT;
break;
case 4:
createInfo.format = Gfx::SE_FORMAT_R8G8B8A8_UINT;
break;
default:
break;
}
createInfo.resourceData.owner = Gfx::QueueType::DEDICATED_TRANSFER;
Gfx::PTexture2D texture = graphics->createTexture2D(createInfo);
stbi_image_free(data);
texture->transferOwnership(Gfx::QueueType::GRAPHICS);
asset->setTexture(texture);
asset->setStatus(Asset::Status::Ready);
AssetRegistry::get().textures[assetPath.string()] = asset;
}
src/Engine/Asset/TextureLoader.h
+2 -2
View File
@@ -13,9 +13,9 @@ class TextureLoader
public:
TextureLoader(Gfx::PGraphics graphic);
~TextureLoader();
void importAsset(const std::string& filePath);
void importAsset(const std::filesystem::path& filePath);
private:
void import(const std::string& path);
void import(const std::filesystem::path& path);
Gfx::PGraphics graphics;
List<std::future<void>> futures;
PTextureAsset placeholderTexture;
src/Engine/Containers/Array.h
+57 -20
View File
@@ -10,16 +10,16 @@
namespace Seele
{
template <typename T>
struct Array
{
public:
template <typename T>
struct Array
{
public:
Array()
: allocated(DEFAULT_ALLOC_SIZE), arraySize(0)
{
_data = new T[DEFAULT_ALLOC_SIZE];
assert(_data != nullptr);
memset(_data, 0, sizeof(T) * DEFAULT_ALLOC_SIZE);
//std::memset(_data, 0, sizeof(T) * DEFAULT_ALLOC_SIZE);
refreshIterators();
}
Array(uint32 size, T value = T())
@@ -190,19 +190,19 @@ public:
}
return endIt;
}
Iterator begin()
{
return beginIt;
}
Iterator begin() const
{
return beginIt;
}
Iterator end()
Iterator end() const
{
return endIt;
}
Iterator end() const
ConstIterator cbegin() const
{
return beginIt;
}
ConstIterator cend() const
{
return endIt;
}
@@ -226,6 +226,26 @@ public:
refreshIterators();
return _data[arraySize - 1];
}
template<typename... args>
T &emplace(args...)
{
if (arraySize == allocated)
{
uint32 newSize = arraySize + 1;
allocated = calculateGrowth(newSize);
T *tempArray = new T[allocated];
assert(tempArray != nullptr);
for (uint32 i = 0; i < arraySize; ++i)
{
tempArray[i] = _data[i];
}
delete[] _data;
_data = tempArray;
}
_data[arraySize++] = T(args...);
refreshIterators();
return _data[arraySize - 1];
}
void remove(Iterator it, bool keepOrder = true)
{
remove(it - beginIt, keepOrder);
@@ -287,6 +307,7 @@ public:
void pop()
{
arraySize--;
refreshIterators();
}
T &operator[](uint32 index)
{
@@ -315,7 +336,7 @@ public:
return this->operator[]((uint32)index);
}
private:
private:
uint32 calculateGrowth(uint32 newSize) const
{
const uint32 oldCapacity = capacity();
@@ -344,12 +365,12 @@ private:
Iterator beginIt;
Iterator endIt;
T *_data;
};
};
template <typename T, uint32 N>
struct StaticArray
{
public:
template <typename T, uint32 N>
struct StaticArray
{
public:
StaticArray()
{
beginIt = Iterator(_data);
@@ -376,7 +397,7 @@ public:
{
return _data;
}
inline const T* data() const
inline const T *data() const
{
return _data;
}
@@ -443,9 +464,25 @@ public:
typedef IteratorBase<T> Iterator;
typedef IteratorBase<const T> ConstIterator;
private:
Iterator begin()
{
return beginIt;
}
Iterator end()
{
return endIt;
}
ConstIterator begin() const
{
return beginIt;
}
ConstIterator end() const
{
return beginIt;
}
private:
T _data[N];
Iterator beginIt;
Iterator endIt;
};
};
} // namespace Seele
src/Engine/Graphics/Graphics.h
+1
View File
@@ -2,6 +2,7 @@
#include "MinimalEngine.h"
#include "GraphicsResources.h"
#include "Containers/Array.h"
#include "RenderPass/VertexFactory.h"
namespace Seele
{
src/Engine/Graphics/GraphicsEnums.h
+1 -1
View File
@@ -5,7 +5,7 @@ namespace Seele
namespace Gfx
{
static constexpr bool useAsyncCompute = true;
static constexpr bool waitIdleOnSubmit = false;
static constexpr bool waitIdleOnSubmit = true;
static constexpr uint32 numFramesBuffered = 3;
typedef uint32_t SeFlags;
src/Engine/Graphics/GraphicsResources.cpp
+4 -2
View File
@@ -126,8 +126,10 @@ IndexBuffer::IndexBuffer(PGraphics graphics, uint32 size, Gfx::SeIndexType index
IndexBuffer::~IndexBuffer()
{
}
VertexStream::VertexStream(uint32 stride, uint8 instanced)
: stride(stride), instanced(instanced)
VertexStream::VertexStream()
{}
VertexStream::VertexStream(uint32 stride, uint32 offset, uint8 instanced, Gfx::PVertexBuffer vertexBuffer)
: stride(stride), instanced(instanced), offset(offset), vertexBuffer(vertexBuffer)
{
}
VertexStream::~VertexStream()
src/Engine/Graphics/GraphicsResources.h
+4 -4
View File
@@ -13,7 +13,7 @@
namespace Seele
{
struct VertexInputStream;
namespace Gfx
{
DECLARE_REF(Graphics);
@@ -297,8 +297,8 @@ DEFINE_REF(StructuredBuffer);
class VertexStream
{
public:
VertexStream() {}
VertexStream(uint32 stride, uint8 instanced);
VertexStream();
VertexStream(uint32 stride, uint32 offset, uint8 instanced, Gfx::PVertexBuffer vertexBuffer);
~VertexStream();
void addVertexElement(VertexElement element);
const Array<VertexElement> getVertexDescriptions() const;
@@ -363,7 +363,7 @@ public:
virtual ~RenderCommand();
virtual void bindPipeline(Gfx::PGraphicsPipeline pipeline) = 0;
virtual void bindDescriptor(Gfx::PDescriptorSet set) = 0;
virtual void bindVertexBuffer(Gfx::PVertexBuffer vertexBuffer) = 0;
virtual void bindVertexBuffer(const Array<VertexInputStream>& streams) = 0;
virtual void bindIndexBuffer(Gfx::PIndexBuffer indexBuffer) = 0;
virtual void draw(const MeshBatchElement& data) = 0;
};
src/Engine/Graphics/Mesh.cpp
+2 -2
View File
@@ -2,8 +2,8 @@
using namespace Seele;
Mesh::Mesh(Gfx::PVertexBuffer vertexBuffer, Gfx::PIndexBuffer indexBuffer)
: vertexBuffer(vertexBuffer)
Mesh::Mesh(MeshDescription description, Gfx::PIndexBuffer indexBuffer)
: description(description)
, indexBuffer(indexBuffer)
{
}
src/Engine/Graphics/Mesh.h
+42 -3
View File
@@ -3,15 +3,54 @@
namespace Seele
{
#define MAX_TEX_CHANNELS 4
enum class VertexAttribute
{
POSITION,
TEXCOORD,
NORMAL,
TANGENT,
BITANGENT
};
struct MeshDescription
{
Array<VertexAttribute> layout;
Gfx::PVertexDeclaration declaration;
uint32 getStride() const
{
return getNumFloats() * sizeof(float);
}
uint32 getNumFloats() const
{
uint32 vertexSize = 0;
for(auto a : layout)
{
switch (a)
{
case VertexAttribute::POSITION:
case VertexAttribute::NORMAL:
case VertexAttribute::TANGENT:
case VertexAttribute::BITANGENT:
vertexSize += 3;
break;
case VertexAttribute::TEXCOORD:
vertexSize += 2;
break;
}
}
return vertexSize;
}
};
DECLARE_REF(MaterialAsset);
class Mesh
{
public:
Mesh(Gfx::PVertexBuffer vertexBuffer, Gfx::PIndexBuffer indexBuffer);
Mesh(MeshDescription description, Gfx::PIndexBuffer indexBuffer);
~Mesh();
private:
Gfx::PVertexBuffer vertexBuffer;
Gfx::PIndexBuffer indexBuffer;
MeshDescription description;
PMaterialAsset referencedMaterial;
};
DEFINE_REF(Mesh);
} // namespace Seele
src/Engine/Graphics/MeshBatch.h
+3 -3
View File
@@ -50,11 +50,11 @@ struct MeshBatch
uint8 isCastingShadow : 1;
uint8 useWireframe : 1;
const Gfx::SePrimitiveTopology topology;
Gfx::SePrimitiveTopology topology;
const PVertexFactory vertexFactory;
PVertexFactory vertexFactory;
const PMaterial material;
PMaterial material;
inline int32 getNumPrimitives() const
{
src/Engine/Graphics/RenderCore.cpp
+1
View File
@@ -24,6 +24,7 @@ void Seele::RenderCore::init()
sceneViewInfo.offsetX = 0;
sceneViewInfo.offsetY = 0;
PSceneView sceneView = new SceneView(windowManager->getGraphics(), window, sceneViewInfo);
window->addView(sceneView);
}
void Seele::RenderCore::renderLoop()
src/Engine/Graphics/RenderPass/MeshProcessor.cpp
+10 -3
View File
@@ -15,9 +15,11 @@ MeshProcessor::~MeshProcessor()
{
}
void MeshProcessor::buildMeshDrawCommands(
void MeshProcessor::buildMeshDrawCommand(
const MeshBatch& meshBatch,
const PPrimitiveComponent primitiveComponent,
const Gfx::PRenderPass renderPass,
Gfx::PRenderCommand drawCommand,
PMaterial material,
Gfx::PVertexShader vertexShader,
Gfx::PControlShader controlShader,
@@ -37,6 +39,7 @@ void MeshProcessor::buildMeshDrawCommands(
pipelineInitializer.evalShader = evaluationShader;
pipelineInitializer.geometryShader = geometryShader;
pipelineInitializer.fragmentShader = fragmentShader;
pipelineInitializer.renderPass = renderPass;
VertexInputStreamArray vertexStreams;
if(positionOnly)
@@ -47,8 +50,12 @@ void MeshProcessor::buildMeshDrawCommands(
{
vertexFactory->getStreams(vertexStreams);
}
if(vertexShader != nullptr)
drawCommand->bindVertexBuffer(vertexStreams);
Gfx::PGraphicsPipeline pipeline = graphics->createGraphicsPipeline(pipelineInitializer);
drawCommand->bindPipeline(pipeline);
for(auto element : meshBatch.elements)
{
drawCommand->bindIndexBuffer(element.indexBuffer);
drawCommand->draw(element);
}
}
src/Engine/Graphics/RenderPass/MeshProcessor.h
+3 -1
View File
@@ -18,9 +18,11 @@ private:
const MeshBatch& meshBatch,
const PPrimitiveComponent primitiveComponent,
int32 staticMeshId = -1) = 0;
void buildMeshDrawCommands(
void buildMeshDrawCommand(
const MeshBatch& meshBatch,
const PPrimitiveComponent primitiveComponent,
const Gfx::PRenderPass renderPass,
Gfx::PRenderCommand drawCommand,
PMaterial material,
Gfx::PVertexShader vertexShader,
Gfx::PControlShader controlShader,
src/Engine/Graphics/RenderPass/VertexFactory.cpp
+37
View File
@@ -1,7 +1,44 @@
#include "VertexFactory.h"
#include "Graphics/Mesh.h"
#include <memory>
using namespace Seele;
List<PVertexFactory> VertexFactory::registeredVertexFactories;
std::mutex VertexFactory::registeredVertexFactoryLock;
VertexFactory::VertexFactory()
{
std::scoped_lock lock(registeredVertexFactoryLock);
registeredVertexFactories.add(this);
}
VertexFactory::VertexFactory(MeshDescription description)
: declaration(description.declaration)
{
auto declStreams = declaration->getVertexStreams();
std::copy(declStreams.begin(), declStreams.end(), streams.begin());
uint32 positionStreamIndex = 0;
positionDeclaration = new Gfx::VertexDeclaration();
for (uint32 i = 0; i < declStreams.size(); i++)
{
if(description.layout[i] == VertexAttribute::POSITION)
{
positionStream[positionStreamIndex++] = declStreams[i];
positionDeclaration->addVertexStream(declStreams[i]);
}
}
std::scoped_lock lock(registeredVertexFactoryLock);
registeredVertexFactories.add(this);
}
VertexFactory::~VertexFactory()
{
registeredVertexFactories.remove(registeredVertexFactories.find(this));
}
void VertexFactory::getStreams(VertexInputStreamArray& outVertexStreams) const
{
for(uint32 i = 0; i < streams.size(); ++i)
src/Engine/Graphics/RenderPass/VertexFactory.h
+9 -5
View File
@@ -35,7 +35,7 @@ struct VertexInputStream
}
};
struct VertexStreamComponent
/*struct VertexStreamComponent
{
const Gfx::PVertexBuffer vertexBuffer = nullptr;
@@ -68,21 +68,25 @@ struct VertexStreamComponent
, type(type)
{
}
};
};*/
typedef Array<VertexInputStream> VertexInputStreamArray;
struct MeshDescription;
DECLARE_REF(VertexFactory);
class VertexFactory
{
public:
VertexFactory()
{
}
VertexFactory();
VertexFactory(MeshDescription description);
~VertexFactory();
void getStreams(VertexInputStreamArray& outVertexStreams) const;
void getPositionOnlyStream(VertexInputStreamArray& outVertexStreams) const;
virtual bool supportsTesselation() { return false; }
Gfx::PVertexDeclaration getDeclaration() const {return declaration;}
Gfx::PVertexDeclaration getPositionDeclaration() const {return positionDeclaration;}
private:
static List<PVertexFactory> registeredVertexFactories;
static std::mutex registeredVertexFactoryLock;
StaticArray<Gfx::VertexStream, 16> streams;
StaticArray<Gfx::VertexStream, 16> positionStream;
Gfx::PVertexDeclaration declaration;
src/Engine/Graphics/SceneRenderPath.cpp
+5
View File
@@ -1,12 +1,17 @@
#include "SceneRenderPath.h"
#include "Scene/Scene.h"
#include "Material/Material.h"
#include "Asset/AssetRegistry.h"
using namespace Seele;
SceneRenderPath::SceneRenderPath(Gfx::PGraphics graphics, Gfx::PViewport target)
: RenderPath(graphics, target)
{
scene = new Scene();
PMeshAsset asset = AssetRegistry::findMesh("Unbenannt");
PActor rootActor = new Actor();
PPrimitiveComponent primitiveComponent = new PrimitiveComponent();
}
SceneRenderPath::~SceneRenderPath()
src/Engine/Graphics/SceneView.cpp
+1
View File
@@ -1,5 +1,6 @@
#include "SceneView.h"
#include "SceneRenderPath.h"
#include "Scene/Scene.h"
#include "Window.h"
Seele::SceneView::SceneView(Gfx::PGraphics graphics, PWindow owner, const ViewportCreateInfo &createInfo)
src/Engine/Graphics/Vulkan/VulkanBuffer.cpp
+1 -1
View File
@@ -129,7 +129,7 @@ void Buffer::executeOwnershipBarrier(Gfx::QueueType newOwner)
dynamicBarriers[i] = barrier;
dynamicBarriers[i].buffer = buffers[i].buffer;
dynamicBarriers[i].offset = 0;
dynamicBarriers[i].size = buffers[i].allocation->getSize();
dynamicBarriers[i].size = size;
}
vkCmdPipelineBarrier(srcCommand, srcStage, dstStage, 0, 0, nullptr, numBuffers, dynamicBarriers, 0, nullptr);
vkCmdPipelineBarrier(dstCommand, srcStage, dstStage, 0, 0, nullptr, numBuffers, dynamicBarriers, 0, nullptr);
src/Engine/Graphics/Vulkan/VulkanCommandBuffer.cpp
+11 -6
View File
@@ -163,12 +163,17 @@ void SecondaryCmdBuffer::bindDescriptor(Gfx::PDescriptorSet descriptorSet)
VkDescriptorSet setHandle = descriptorSet.cast<DescriptorSet>()->getHandle();
vkCmdBindDescriptorSets(handle, VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline->getLayout(), descriptorSet->getSetIndex(), 1, &setHandle, 0, nullptr);
}
void SecondaryCmdBuffer::bindVertexBuffer(Gfx::PVertexBuffer vertexBuffer)
void SecondaryCmdBuffer::bindVertexBuffer(const Array<VertexInputStream>& streams)
{
PVertexBuffer buf = vertexBuffer.cast<VertexBuffer>();
const VkBuffer bufHandle[1] = {buf->getHandle()};
const VkDeviceSize offsets[1] = {0};
vkCmdBindVertexBuffers(handle, 0, 1, bufHandle, offsets);
Array<VkBuffer> buffers(streams.size());
Array<VkDeviceSize> offsets(streams.size());
for(uint32 i = 0; i < streams.size(); ++i)
{
PVertexBuffer buf = streams[i].vertexBuffer.cast<VertexBuffer>();
buffers[i] = buf->getHandle();
offsets[i] = streams[i].offset;
};
vkCmdBindVertexBuffers(handle, 0, streams.size(), buffers.data(), offsets.data());
}
void SecondaryCmdBuffer::bindIndexBuffer(Gfx::PIndexBuffer indexBuffer)
{
@@ -181,7 +186,7 @@ void SecondaryCmdBuffer::draw(const MeshBatchElement& data)
}
CommandBufferManager::CommandBufferManager(PGraphics graphics, PQueue queue)
: graphics(graphics), queue(queue)
: graphics(graphics), queue(queue), queueFamilyIndex(queue->getFamilyIndex())
{
VkCommandPoolCreateInfo info =
init::CommandPoolCreateInfo();
src/Engine/Graphics/Vulkan/VulkanCommandBuffer.h
+2 -1
View File
@@ -4,6 +4,7 @@
namespace Seele
{
struct VertexInputStream;
namespace Vulkan
{
DECLARE_REF(RenderPass);
@@ -75,7 +76,7 @@ public:
void end();
virtual void bindPipeline(Gfx::PGraphicsPipeline pipeline) override;
virtual void bindDescriptor(Gfx::PDescriptorSet descriptorSet) override;
virtual void bindVertexBuffer(Gfx::PVertexBuffer vertexBuffer) override;
virtual void bindVertexBuffer(const Array<VertexInputStream>& streams) override;
virtual void bindIndexBuffer(Gfx::PIndexBuffer indexBuffer) override;
virtual void draw(const MeshBatchElement& data) override;
src/Engine/Graphics/Vulkan/VulkanGraphics.cpp
+40 -23
View File
@@ -21,12 +21,6 @@ Graphics::Graphics()
Graphics::~Graphics()
{
allocator = nullptr;
stagingManager = nullptr;
graphicsCommands = nullptr;
computeCommands = nullptr;
transferCommands = nullptr;
dedicatedTransferCommands = nullptr;
viewports.clear();
vkDestroyDevice(handle, nullptr);
DestroyDebugReportCallbackEXT(instance, nullptr, callback);
@@ -41,10 +35,6 @@ void Graphics::init(GraphicsInitializer initInfo)
createDevice(initInfo);
allocator = new Allocator(this);
stagingManager = new StagingManager(this, allocator);
graphicsCommands = new CommandBufferManager(this, graphicsQueue);
computeCommands = new CommandBufferManager(this, computeQueue);
transferCommands = new CommandBufferManager(this, transferQueue);
dedicatedTransferCommands = new CommandBufferManager(this, dedicatedTransferQueue);
pipelineCache = new PipelineCache(this, "pipeline.cache");
}
@@ -79,12 +69,12 @@ void Graphics::beginRenderPass(Gfx::PRenderPass renderPass)
{
framebuffer = found->value;
}
graphicsCommands->getCommands()->beginRenderPass(rp, framebuffer);
getGraphicsCommands()->getCommands()->beginRenderPass(rp, framebuffer);
}
void Graphics::endRenderPass()
{
graphicsCommands->getCommands()->endRenderPass();
getGraphicsCommands()->getCommands()->endRenderPass();
}
void Graphics::executeCommands(Array<Gfx::PRenderCommand> commands)
@@ -96,7 +86,7 @@ void Graphics::executeCommands(Array<Gfx::PRenderCommand> commands)
buf->end();
cmdBuffers[i] = buf->getHandle();
}
vkCmdExecuteCommands(graphicsCommands->getCommands()->getHandle(), cmdBuffers.size(), cmdBuffers.data());
vkCmdExecuteCommands(getGraphicsCommands()->getCommands()->getHandle(), cmdBuffers.size(), cmdBuffers.data());
}
Gfx::PTexture2D Graphics::createTexture2D(const TextureCreateInfo &createInfo)
@@ -129,7 +119,7 @@ Gfx::PIndexBuffer Graphics::createIndexBuffer(const IndexBufferCreateInfo &bulkD
}
Gfx::PRenderCommand Graphics::createRenderCommand()
{
PSecondaryCmdBuffer cmdBuffer = graphicsCommands->createSecondaryCmdBuffer();
PSecondaryCmdBuffer cmdBuffer = getGraphicsCommands()->createSecondaryCmdBuffer();
cmdBuffer->begin(getGraphicsCommands()->getCommands());
return cmdBuffer;
}
@@ -199,33 +189,60 @@ PCommandBufferManager Graphics::getQueueCommands(Gfx::QueueType queueType)
switch (queueType)
{
case Gfx::QueueType::GRAPHICS:
return graphicsCommands;
return getGraphicsCommands();
case Gfx::QueueType::COMPUTE:
return computeCommands;
return getComputeCommands();
case Gfx::QueueType::TRANSFER:
return transferCommands;
return getTransferCommands();
case Gfx::QueueType::DEDICATED_TRANSFER:
return dedicatedTransferCommands;
return getDedicatedTransferCommands();
default:
throw new std::logic_error("invalid queue type");
}
}
std::mutex graphicsCommandLock;
PCommandBufferManager Graphics::getGraphicsCommands()
{
return graphicsCommands;
std::scoped_lock lock(graphicsCommandLock);
auto id = std::this_thread::get_id();
if(graphicsCommands.find(id) == graphicsCommands.end())
{
graphicsCommands[id] = new CommandBufferManager(this, graphicsQueue);
}
return graphicsCommands[id];
}
std::mutex computeCommandLock;
PCommandBufferManager Graphics::getComputeCommands()
{
return computeCommands;
std::scoped_lock lock(computeCommandLock);
auto id = std::this_thread::get_id();
if(computeCommands.find(id) == computeCommands.end())
{
computeCommands[id] = new CommandBufferManager(this, computeQueue);
}
return computeCommands[id];
}
std::mutex transferCommandLock;
PCommandBufferManager Graphics::getTransferCommands()
{
return transferCommands;
std::scoped_lock lock(transferCommandLock);
auto id = std::this_thread::get_id();
if(transferCommands.find(id) == transferCommands.end())
{
transferCommands[id] = new CommandBufferManager(this, transferQueue);
}
return transferCommands[id];
}
std::mutex dedicatedCommandLock;
PCommandBufferManager Graphics::getDedicatedTransferCommands()
{
return dedicatedTransferCommands;
std::scoped_lock lock(dedicatedCommandLock);
auto id = std::this_thread::get_id();
if(dedicatedTransferCommands.find(id) == dedicatedTransferCommands.end())
{
dedicatedTransferCommands[id] = new CommandBufferManager(this, dedicatedTransferQueue);
}
return dedicatedTransferCommands[id];
}
PAllocator Graphics::getAllocator()
{
src/Engine/Graphics/Vulkan/VulkanGraphics.h
+4 -4
View File
@@ -80,10 +80,10 @@ protected:
PQueue dedicatedTransferQueue;
QueueOwnedResourceDeletion deletionQueue;
PPipelineCache pipelineCache;
PCommandBufferManager graphicsCommands;
PCommandBufferManager computeCommands;
PCommandBufferManager transferCommands;
PCommandBufferManager dedicatedTransferCommands;
Map<std::thread::id, PCommandBufferManager> graphicsCommands;
Map<std::thread::id, PCommandBufferManager> computeCommands;
Map<std::thread::id, PCommandBufferManager> transferCommands;
Map<std::thread::id, PCommandBufferManager> dedicatedTransferCommands;
VkPhysicalDeviceProperties props;
VkPhysicalDeviceFeatures features;
VkDebugReportCallbackEXT callback;
src/Engine/Graphics/Vulkan/VulkanTexture.cpp
+1
View File
@@ -78,6 +78,7 @@ TextureHandle::TextureHandle(PGraphics graphics, VkImageViewType viewType,
default:
break;
}
info.initialLayout = layout;
info.mipLevels = mipLevels;
info.arrayLayers = arrayCount * layerCount;
src/Engine/Material/Material.cpp
+1 -1
View File
@@ -15,7 +15,7 @@ Material::Material(const std::string& directory, const std::string& name)
{
}
Material::Material(const std::string& fullPath)
Material::Material(const std::filesystem::path& fullPath)
: MaterialAsset(fullPath)
{
}
src/Engine/Material/Material.h
+2 -1
View File
@@ -10,12 +10,13 @@ class Material : public MaterialAsset
public:
Material();
Material(const std::string &directory, const std::string &name);
Material(const std::string &fullPath);
Material(const std::filesystem::path& fullPath);
~Material();
inline std::string getMaterialName() const {return materialName;}
private:
void compile();
std::string materialName;
Array<std::string> materialCode;
friend class MaterialLoader;
};
DEFINE_REF(Material);
src/Engine/Material/MaterialAsset.cpp
+1 -1
View File
@@ -11,7 +11,7 @@ MaterialAsset::MaterialAsset(const std::string& directory, const std::string& na
{
}
MaterialAsset::MaterialAsset(const std::string& fullPath)
MaterialAsset::MaterialAsset(const std::filesystem::path& fullPath)
: Asset(fullPath)
{
}
src/Engine/Material/MaterialAsset.h
+1 -1
View File
@@ -9,7 +9,7 @@ class MaterialAsset : public Asset
public:
MaterialAsset();
MaterialAsset(const std::string &directory, const std::string &name);
MaterialAsset(const std::string &fullPath);
MaterialAsset(const std::filesystem::path &fullPath);
~MaterialAsset();
protected:
//For now its simply the collection of parameters, since there is no point for expressions
src/Engine/Material/MaterialInstance.cpp
+5
View File
@@ -17,6 +17,11 @@ MaterialInstance::MaterialInstance(const std::string& fullPath)
{
}
MaterialInstance::MaterialInstance(const std::filesystem::path& fullPath)
: Asset(fullPath)
{
}
MaterialInstance::~MaterialInstance()
{
}
src/Engine/Material/MaterialInstance.h
+1
View File
@@ -11,6 +11,7 @@ public:
MaterialInstance();
MaterialInstance(const std::string& directory, const std::string& name);
MaterialInstance(const std::string& fullPath);
MaterialInstance(const std::filesystem::path& fullPath);
~MaterialInstance();
PMaterial getBaseMaterial() const;
Gfx::PDescriptorSet getDescriptor();
src/Engine/MinimalEngine.cpp
+1
View File
@@ -1,3 +1,4 @@
#include "MinimalEngine.h"
Seele::Map<void *, void *> registeredObjects;
std::mutex registeredObjectsLock;
src/Engine/MinimalEngine.h
+2
View File
@@ -25,6 +25,7 @@
}
extern Seele::Map<void *, void *> registeredObjects;
extern std::mutex registeredObjectsLock;
namespace Seele
{
template <typename T>
@@ -34,6 +35,7 @@ public:
RefObject(T *ptr)
: handle(ptr), refCount(1)
{
std::scoped_lock lock(registeredObjectsLock);
registeredObjects[ptr] = this;
}
RefObject(const RefObject &rhs)
src/Engine/Scene/Components/PrimitiveComponent.cpp
+6
View File
@@ -1,6 +1,8 @@
#include "PrimitiveComponent.h"
#include "Scene/Scene.h"
#include "Material/MaterialInstance.h"
#include "Asset/MeshAsset.h"
#include "Graphics/RenderPass/VertexFactory.h"
using namespace Seele;
@@ -8,6 +10,10 @@ PrimitiveComponent::PrimitiveComponent()
{
}
PrimitiveComponent::PrimitiveComponent(PMeshAsset asset)
{
}
PrimitiveComponent::~PrimitiveComponent()
{
}
src/Engine/Scene/Components/PrimitiveComponent.h
+4 -3
View File
@@ -2,24 +2,25 @@
#include "Component.h"
#include "Graphics/GraphicsResources.h"
#include "Graphics/Mesh.h"
#include "Material/MaterialInstance.h"
#include "Material/MaterialAsset.h"
#include "Graphics/MeshBatch.h"
namespace Seele
{
DECLARE_REF(MeshAsset);
class PrimitiveComponent : public Component
{
public:
PrimitiveComponent();
PrimitiveComponent(PMeshAsset asset);
~PrimitiveComponent();
virtual void notifySceneAttach(PScene scene) override;
Matrix4 getRenderMatrix();
private:
Array<PMaterialInstance> materials;
Array<PMaterialAsset> materials;
Gfx::PUniformBuffer uniformBuffer;
Array<StaticMeshBatch> staticMeshes;
PMesh mesh;
friend class Scene;
};
DEFINE_REF(PrimitiveComponent);
src/Engine/Scene/Scene.cpp
+3 -19
View File
@@ -32,31 +32,15 @@ void Scene::addPrimitiveComponent(PPrimitiveComponent comp)
primitives.add(comp);
}
Map<PMaterial, MeshBatch> Scene::getMeshBatches()
Array<MeshBatch> Scene::getMeshBatches()
{
meshBatches.clear();
for (auto primitive : primitives)
{
/* Array<PMaterial> materials = primitive->materials;
PMaterialInstance matInstance = primitive->;
PMaterial mat = matInstance->getBaseMaterial();
MeshBatch inst;
inst.instance = primitive->instance;
inst.vertexBuffer = primitive->vertexBuffer;
inst.indexBuffer = primitive->indexBuffer;
inst.modelMatrix = primitive->getRenderMatrix();
if (meshBatches.find(mat) != meshBatches.end())
for(auto batch : primitive->staticMeshes)
{
MeshBatchElement &state = meshBatches[mat];
state.instances.add(inst);
meshBatches.add(batch);
}
else
{
MeshBatchElement state;
state.instances.add(inst);
meshBatches[mat] = state;
}*/
}
return meshBatches;
}
src/Engine/Scene/Scene.h
+2 -2
View File
@@ -20,11 +20,11 @@ public:
void addPrimitiveComponent(PPrimitiveComponent comp);
private:
Map<PMaterial, MeshBatch> meshBatches;
Array<MeshBatch> meshBatches;
Array<PActor> rootActors;
Array<PPrimitiveComponent> primitives;
const static int constant = 10;
public:
Map<PMaterial, MeshBatch> getMeshBatches();
Array<MeshBatch> getMeshBatches();
};
} // namespace Seele
src/Engine/main.cpp
+2 -2
View File
@@ -5,8 +5,8 @@ int main()
{
RenderCore core;
core.init();
AssetRegistry::init("./");
AssetRegistry::importFile("D:\\Private\\Programming\\Unreal Engine\\Assets\\TestAssets\\Unbenannt.fbx");
AssetRegistry::init("D:\\Private\\Programming\\C++\\TestSeeleProject");
AssetRegistry::importFile("D:\\Private\\Programming\\Unreal Engine\\Assets\\Arissa\\Arissa.fbx");
core.renderLoop();
core.shutdown();
return 0;