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

Formatted EVERYTHING

Browse Source
This commit is contained in:
Dynamitos
2024-06-09 12:20:53 +02:00
parent f18bf8acbe
commit d95dab850c
265 changed files with 8002 additions and 12310 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/Engine/Asset/Asset.cpp
+8 -33
View File
@@ -4,44 +4,19 @@
using namespace Seele;
Asset::Asset()
: folderPath("")
, name("")
, status(Status::Uninitialized)
, byteSize(0)
{
}
Asset::Asset(std::string_view _folderPath, std::string_view _name)
: folderPath(_folderPath)
, name(_name)
, status(Status::Uninitialized)
{
if (folderPath.empty())
{
Asset::Asset() : folderPath(""), name(""), status(Status::Uninitialized), byteSize(0) {}
Asset::Asset(std::string_view _folderPath, std::string_view _name) : folderPath(_folderPath), name(_name), status(Status::Uninitialized) {
if (folderPath.empty()) {
assetId = name;
}
else
{
} else {
assetId = folderPath + "/" + name;
}
}
Asset::~Asset() {}
Asset::~Asset()
{
}
std::string Asset::getFolderPath() const { return folderPath; }
std::string Asset::getFolderPath() const
{
return folderPath;
}
std::string Asset::getName() const { return name; }
std::string Asset::getName() const
{
return name;
}
std::string Asset::getAssetIdentifier() const
{
return assetId;
}
std::string Asset::getAssetIdentifier() const { return assetId; }
src/Engine/Asset/Asset.h
+9 -21
View File
@@ -2,18 +2,11 @@
#include "MinimalEngine.h"
#include "Serialization/ArchiveBuffer.h"
namespace Seele
{
namespace Seele {
DECLARE_NAME_REF(Gfx, Graphics)
class Asset
{
public:
enum class Status
{
Uninitialized,
Loading,
Ready
};
class Asset {
public:
enum class Status { Uninitialized, Loading, Ready };
Asset();
Asset(std::string_view folderPath, std::string_view name);
virtual ~Asset();
@@ -22,7 +15,7 @@ public:
virtual void save(ArchiveBuffer& buffer) const = 0;
virtual void load(ArchiveBuffer& buffer) = 0;
bool isModified() const;
// returns the assets name
std::string getName() const;
@@ -31,15 +24,10 @@ public:
// returns the identifier with which it can be found from the asset registry
std::string getAssetIdentifier() const;
constexpr Status getStatus()
{
return status;
}
constexpr void setStatus(Status _status)
{
status = _status;
}
protected:
constexpr Status getStatus() { return status; }
constexpr void setStatus(Status _status) { status = _status; }
protected:
std::string folderPath;
std::string name;
std::string assetId;
src/Engine/Asset/AssetRegistry.cpp
+68 -150
View File
@@ -1,134 +1,96 @@
#include "AssetRegistry.h"
#include "MeshAsset.h"
#include "FontAsset.h"
#include "TextureAsset.h"
#include "Graphics/Graphics.h"
#include "Graphics/Mesh.h"
#include "MaterialAsset.h"
#include "MaterialInstanceAsset.h"
#include "Graphics/Mesh.h"
#include "Graphics/Graphics.h"
#include "Window/WindowManager.h"
#include "MeshAsset.h"
#include <nlohmann/json.hpp>
#include <iostream>
#include "TextureAsset.h"
#include "Window/WindowManager.h"
#include <fstream>
#include <iostream>
#include <nlohmann/json.hpp>
using namespace Seele;
AssetRegistry* _instance = new AssetRegistry();
AssetRegistry::~AssetRegistry()
{
delete assetRoot;
}
AssetRegistry::~AssetRegistry() { delete assetRoot; }
void AssetRegistry::init(std::filesystem::path rootFolder, Gfx::PGraphics graphics)
{
get().initialize(rootFolder, graphics);
}
void AssetRegistry::init(std::filesystem::path rootFolder, Gfx::PGraphics graphics) { get().initialize(rootFolder, graphics); }
PMeshAsset AssetRegistry::findMesh(std::string_view folderPath, std::string_view filePath)
{
PMeshAsset AssetRegistry::findMesh(std::string_view folderPath, std::string_view filePath) {
AssetFolder* folder = get().assetRoot;
if (!folderPath.empty())
{
if (!folderPath.empty()) {
folder = get().getOrCreateFolder(folderPath);
}
return folder->meshes.at(std::string(filePath));
}
PTextureAsset AssetRegistry::findTexture(std::string_view folderPath, std::string_view filePath)
{
PTextureAsset AssetRegistry::findTexture(std::string_view folderPath, std::string_view filePath) {
AssetFolder* folder = get().assetRoot;
if (!folderPath.empty())
{
if (!folderPath.empty()) {
folder = get().getOrCreateFolder(folderPath);
}
return folder->textures.at(std::string(filePath));
}
PFontAsset AssetRegistry::findFont(std::string_view folderPath, std::string_view filePath)
{
PFontAsset AssetRegistry::findFont(std::string_view folderPath, std::string_view filePath) {
AssetFolder* folder = get().assetRoot;
if (!folderPath.empty())
{
if (!folderPath.empty()) {
folder = get().getOrCreateFolder(folderPath);
}
return folder->fonts.at(std::string(filePath));
}
PMaterialAsset AssetRegistry::findMaterial(std::string_view folderPath, std::string_view filePath)
{
PMaterialAsset AssetRegistry::findMaterial(std::string_view folderPath, std::string_view filePath) {
AssetFolder* folder = get().assetRoot;
if (!folderPath.empty())
{
if (!folderPath.empty()) {
folder = get().getOrCreateFolder(folderPath);
}
return folder->materials.at(std::string(filePath));
}
PMaterialInstanceAsset AssetRegistry::findMaterialInstance(std::string_view folderPath, std::string_view filePath)
{
PMaterialInstanceAsset AssetRegistry::findMaterialInstance(std::string_view folderPath, std::string_view filePath) {
AssetFolder* folder = get().assetRoot;
if (!folderPath.empty())
{
if (!folderPath.empty()) {
folder = get().getOrCreateFolder(folderPath);
}
return folder->instances.at(std::string(filePath));
}
std::ofstream AssetRegistry::createWriteStream(const std::filesystem::path& relativePath, std::ios_base::openmode openmode)
{
std::ofstream AssetRegistry::createWriteStream(const std::filesystem::path& relativePath, std::ios_base::openmode openmode) {
return get().internalCreateWriteStream(relativePath, openmode);
}
std::ifstream AssetRegistry::createReadStream(const std::filesystem::path& relativePath, std::ios_base::openmode openmode)
{
std::ifstream AssetRegistry::createReadStream(const std::filesystem::path& relativePath, std::ios_base::openmode openmode) {
return get().internalCreateReadStream(relativePath, openmode);
}
AssetRegistry &AssetRegistry::get()
{
return *_instance;
}
AssetRegistry& AssetRegistry::get() { return *_instance; }
AssetRegistry::AssetRegistry()
: assetRoot(nullptr)
{
}
AssetRegistry::AssetRegistry() : assetRoot(nullptr) {}
AssetRegistry* AssetRegistry::getInstance()
{
return _instance;
}
AssetRegistry* AssetRegistry::getInstance() { return _instance; }
void AssetRegistry::loadRegistry()
{
get().loadRegistryInternal();
}
void AssetRegistry::loadRegistry() { get().loadRegistryInternal(); }
void AssetRegistry::saveRegistry()
{
get().saveRegistryInternal();
}
void AssetRegistry::saveRegistry() { get().saveRegistryInternal(); }
AssetRegistry::AssetFolder* AssetRegistry::getOrCreateFolder(std::string_view fullPath)
{
AssetRegistry::AssetFolder* AssetRegistry::getOrCreateFolder(std::string_view fullPath) {
AssetFolder* result = assetRoot;
std::string temp = std::string(fullPath);
while (!temp.empty())
{
while (!temp.empty()) {
size_t slashLoc = temp.find("/");
if (slashLoc == std::string::npos)
{
if (!result->children.contains(temp))
{
if (slashLoc == std::string::npos) {
if (!result->children.contains(temp)) {
result->children[temp] = new AssetFolder(temp);
}
return result->children[temp];
}
std::string folderName = temp.substr(0, slashLoc);
if (!result->children.contains(folderName))
{
if (!result->children.contains(folderName)) {
result->children[folderName] = new AssetFolder(fullPath);
}
result = result->children[folderName];
@@ -137,40 +99,31 @@ AssetRegistry::AssetFolder* AssetRegistry::getOrCreateFolder(std::string_view fu
return result;
}
void AssetRegistry::initialize(const std::filesystem::path &_rootFolder, Gfx::PGraphics _graphics)
{
void AssetRegistry::initialize(const std::filesystem::path& _rootFolder, Gfx::PGraphics _graphics) {
this->graphics = _graphics;
this->rootFolder = _rootFolder;
this->assetRoot = new AssetFolder("");
loadRegistryInternal();
}
void AssetRegistry::loadRegistryInternal()
{
void AssetRegistry::loadRegistryInternal() {
peekFolder(assetRoot);
loadFolder(assetRoot);
}
void AssetRegistry::peekFolder(AssetFolder* folder)
{
for (const auto& entry : std::filesystem::directory_iterator(rootFolder / folder->folderPath))
{
void AssetRegistry::peekFolder(AssetFolder* folder) {
for (const auto& entry : std::filesystem::directory_iterator(rootFolder / folder->folderPath)) {
const auto& stem = entry.path().stem().string();
if (entry.is_directory())
{
if (folder->folderPath.empty())
{
if (entry.is_directory()) {
if (folder->folderPath.empty()) {
folder->children[stem] = new AssetFolder(stem);
}
else
{
} else {
folder->children[stem] = new AssetFolder(folder->folderPath + "/" + stem);
}
peekFolder(folder->children[stem]);
continue;
}
if(entry.path().filename().compare(".DS_Store") == 0)
{
if (entry.path().filename().compare(".DS_Store") == 0) {
continue;
}
auto stream = std::ifstream(entry.path(), std::ios::binary);
@@ -181,20 +134,16 @@ void AssetRegistry::peekFolder(AssetFolder* folder)
}
}
void AssetRegistry::loadFolder(AssetFolder* folder)
{
for (const auto& entry : std::filesystem::directory_iterator(rootFolder / folder->folderPath))
{
void AssetRegistry::loadFolder(AssetFolder* folder) {
for (const auto& entry : std::filesystem::directory_iterator(rootFolder / folder->folderPath)) {
const auto& path = entry.path();
if (entry.is_directory())
{
if (entry.is_directory()) {
auto relative = path.stem().string();
loadFolder(folder->children[relative]);
continue;
}
if(entry.path().filename().compare(".DS_Store") == 0)
{
if (entry.path().filename().compare(".DS_Store") == 0) {
continue;
}
auto stream = std::ifstream(path, std::ios::binary);
@@ -205,8 +154,7 @@ void AssetRegistry::loadFolder(AssetFolder* folder)
}
}
void AssetRegistry::peekAsset(ArchiveBuffer& buffer)
{
void AssetRegistry::peekAsset(ArchiveBuffer& buffer) {
// Read asset type
uint64 identifier;
Serialization::load(buffer, identifier);
@@ -222,8 +170,7 @@ void AssetRegistry::peekAsset(ArchiveBuffer& buffer)
AssetFolder* folder = getOrCreateFolder(folderPath);
OAsset asset;
switch (identifier)
{
switch (identifier) {
case TextureAsset::IDENTIFIER:
asset = new TextureAsset(folderPath, name);
folder->textures[name] = std::move(asset);
@@ -249,8 +196,7 @@ void AssetRegistry::peekAsset(ArchiveBuffer& buffer)
}
}
void AssetRegistry::loadAsset(ArchiveBuffer& buffer)
{
void AssetRegistry::loadAsset(ArchiveBuffer& buffer) {
// Read asset type
uint64 identifier;
Serialization::load(buffer, identifier);
@@ -264,10 +210,9 @@ void AssetRegistry::loadAsset(ArchiveBuffer& buffer)
Serialization::load(buffer, folderPath);
AssetFolder* folder = getOrCreateFolder(folderPath);
PAsset asset;
switch (identifier)
{
switch (identifier) {
case TextureAsset::IDENTIFIER:
asset = PTextureAsset(folder->textures.at(name));
break;
@@ -289,42 +234,31 @@ void AssetRegistry::loadAsset(ArchiveBuffer& buffer)
asset->load(buffer);
}
void AssetRegistry::saveRegistryInternal()
{
saveFolder("", assetRoot);
}
void AssetRegistry::saveRegistryInternal() { saveFolder("", assetRoot); }
void AssetRegistry::saveFolder(const std::filesystem::path& folderPath, AssetFolder* folder)
{
void AssetRegistry::saveFolder(const std::filesystem::path& folderPath, AssetFolder* folder) {
std::filesystem::create_directory(rootFolder / folderPath);
for (const auto& [name, texture] : folder->textures)
{
for (const auto& [name, texture] : folder->textures) {
saveAsset(PTextureAsset(texture), TextureAsset::IDENTIFIER, folderPath, name);
}
for (const auto& [name, mesh] : folder->meshes)
{
for (const auto& [name, mesh] : folder->meshes) {
saveAsset(PMeshAsset(mesh), MeshAsset::IDENTIFIER, folderPath, name);
}
for (const auto& [name, material] : folder->materials)
{
for (const auto& [name, material] : folder->materials) {
saveAsset(PMaterialAsset(material), MaterialAsset::IDENTIFIER, folderPath, name);
}
for (const auto& [name, material] : folder->instances)
{
for (const auto& [name, material] : folder->instances) {
saveAsset(PMaterialInstanceAsset(material), MaterialInstanceAsset::IDENTIFIER, folderPath, name);
}
for (const auto& [name, font] : folder->fonts)
{
for (const auto& [name, font] : folder->fonts) {
saveAsset(PFontAsset(font), FontAsset::IDENTIFIER, folderPath, name);
}
for (auto& [name, child] : folder->children)
{
for (auto& [name, child] : folder->children) {
saveFolder(folderPath / name, child);
}
}
void AssetRegistry::saveAsset(PAsset asset, uint64 identifier, const std::filesystem::path& folderPath, std::string name)
{
void AssetRegistry::saveAsset(PAsset asset, uint64 identifier, const std::filesystem::path& folderPath, std::string name) {
if (name.empty())
return;
@@ -342,65 +276,49 @@ void AssetRegistry::saveAsset(PAsset asset, uint64 identifier, const std::filesy
buffer.writeToStream(assetStream);
}
std::filesystem::path AssetRegistry::getRootFolder()
{
return get().rootFolder;
}
std::filesystem::path AssetRegistry::getRootFolder() { return get().rootFolder; }
void AssetRegistry::registerMesh(OMeshAsset mesh)
{
void AssetRegistry::registerMesh(OMeshAsset mesh) {
AssetFolder* folder = getOrCreateFolder(mesh->getFolderPath());
folder->meshes[mesh->getName()] = std::move(mesh);
}
void AssetRegistry::registerTexture(OTextureAsset texture)
{
void AssetRegistry::registerTexture(OTextureAsset texture) {
AssetFolder* folder = getOrCreateFolder(texture->getFolderPath());
folder->textures[texture->getName()] = std::move(texture);
}
void AssetRegistry::registerFont(OFontAsset font)
{
void AssetRegistry::registerFont(OFontAsset font) {
AssetFolder* folder = getOrCreateFolder(font->getFolderPath());
folder->fonts[font->getName()] = std::move(font);
}
void AssetRegistry::registerMaterial(OMaterialAsset material)
{
void AssetRegistry::registerMaterial(OMaterialAsset material) {
AssetFolder* folder = getOrCreateFolder(material->getFolderPath());
folder->materials[material->getName()] = std::move(material);
}
void AssetRegistry::registerMaterialInstance(OMaterialInstanceAsset material)
{
void AssetRegistry::registerMaterialInstance(OMaterialInstanceAsset material) {
AssetFolder* folder = getOrCreateFolder(material->getFolderPath());
folder->instances[material->getName()] = std::move(material);
}
std::ofstream AssetRegistry::internalCreateWriteStream(const std::filesystem::path& relativePath, std::ios_base::openmode openmode)
{
std::ofstream AssetRegistry::internalCreateWriteStream(const std::filesystem::path& relativePath, std::ios_base::openmode openmode) {
auto fullPath = rootFolder / relativePath;
std::filesystem::create_directories(fullPath.parent_path());
return std::ofstream(fullPath.string(), openmode);
}
std::ifstream AssetRegistry::internalCreateReadStream(const std::filesystem::path& relativePath, std::ios_base::openmode openmode)
{
std::ifstream AssetRegistry::internalCreateReadStream(const std::filesystem::path& relativePath, std::ios_base::openmode openmode) {
auto fullPath = rootFolder / relativePath;
std::filesystem::create_directories(fullPath.parent_path());
return std::ifstream(fullPath.string(), openmode);
}
AssetRegistry::AssetFolder::AssetFolder(std::string_view folderPath)
: folderPath(folderPath)
{}
AssetRegistry::AssetFolder::AssetFolder(std::string_view folderPath) : folderPath(folderPath) {}
AssetRegistry::AssetFolder::~AssetFolder()
{
for (auto [_, child] : children)
{
AssetRegistry::AssetFolder::~AssetFolder() {
for (auto [_, child] : children) {
delete child;
}
}
src/Engine/Asset/AssetRegistry.h
+10 -11
View File
@@ -1,21 +1,20 @@
#pragma once
#include "MinimalEngine.h"
#include "Asset.h"
#include "Containers/Map.h"
#include <string>
#include "MinimalEngine.h"
#include <filesystem>
#include <string>
namespace Seele
{
namespace Seele {
DECLARE_REF(TextureAsset)
DECLARE_REF(FontAsset)
DECLARE_REF(MeshAsset)
DECLARE_REF(MaterialAsset)
DECLARE_REF(MaterialInstanceAsset)
DECLARE_NAME_REF(Gfx, Graphics)
class AssetRegistry
{
public:
class AssetRegistry {
public:
~AssetRegistry();
static void init(std::filesystem::path path, Gfx::PGraphics graphics);
@@ -34,8 +33,7 @@ public:
static void loadRegistry();
static void saveRegistry();
struct AssetFolder
{
struct AssetFolder {
std::string folderPath;
Map<std::string, AssetFolder*> children;
Map<std::string, OTextureAsset> textures;
@@ -49,7 +47,8 @@ public:
AssetFolder* getOrCreateFolder(std::string_view foldername);
AssetRegistry();
static AssetRegistry* getInstance();
private:
private:
static AssetRegistry& get();
void initialize(const std::filesystem::path& rootFolder, Gfx::PGraphics graphics);
@@ -81,4 +80,4 @@ private:
friend class MaterialLoader;
friend class MeshLoader;
};
}
} // namespace Seele
src/Engine/Asset/FontAsset.cpp
+23 -45
View File
@@ -5,26 +5,16 @@
using namespace Seele;
FontAsset::FontAsset()
{
}
FontAsset::FontAsset() {}
FontAsset::FontAsset(std::string_view folderPath, std::string_view name)
: Asset(folderPath, name)
{
}
FontAsset::FontAsset(std::string_view folderPath, std::string_view name) : Asset(folderPath, name) {}
FontAsset::~FontAsset()
{
}
FontAsset::~FontAsset() {}
void FontAsset::save(ArchiveBuffer& buffer) const
{
void FontAsset::save(ArchiveBuffer& buffer) const {
Serialization::save(buffer, glyphs);
Serialization::save(buffer, usedTextures.size());
for (uint32 x = 0; x < usedTextures.size(); ++x)
{
for (uint32 x = 0; x < usedTextures.size(); ++x) {
Array<uint8> textureData;
ktxTexture2* kTexture;
ktxTextureCreateInfo createInfo = {
@@ -34,7 +24,9 @@ void FontAsset::save(ArchiveBuffer& buffer) const
.baseWidth = usedTextures[x]->getWidth(),
.baseHeight = usedTextures[x]->getHeight(),
.baseDepth = usedTextures[x]->getDepth(),
.numDimensions = usedTextures[x]->getDepth() > 1 ? 3u : usedTextures[x]->getHeight() > 1 ? 2u : 1u,
.numDimensions = usedTextures[x]->getDepth() > 1 ? 3u
: usedTextures[x]->getHeight() > 1 ? 2u
: 1u,
.numLevels = usedTextures[x]->getMipLevels(),
.numLayers = usedTextures[x]->getDepth(),
.numFaces = usedTextures[x]->getNumFaces(),
@@ -43,10 +35,8 @@ void FontAsset::save(ArchiveBuffer& buffer) const
};
ktxTexture2_Create(&createInfo, KTX_TEXTURE_CREATE_ALLOC_STORAGE, &kTexture);
for (uint32 depth = 0; depth < usedTextures[x]->getDepth(); ++depth)
{
for (uint32 face = 0; face < usedTextures[x]->getNumFaces(); ++face)
{
for (uint32 depth = 0; depth < usedTextures[x]->getDepth(); ++depth) {
for (uint32 face = 0; face < usedTextures[x]->getNumFaces(); ++face) {
// technically, downloading cant be const, because we have to allocate temporary buffers and change layouts
// but practically the texture stays the same
const_cast<Gfx::Texture2D*>(*(usedTextures[x]))->download(0, depth, face, textureData);
@@ -55,9 +45,7 @@ void FontAsset::save(ArchiveBuffer& buffer) const
}
char writer[100];
snprintf(writer, sizeof(writer), "%s version %s", "SeeleEngine", "0.0.1");
ktxHashList_AddKVPair(&kTexture->kvDataHead, KTX_WRITER_KEY,
(ktx_uint32_t)strlen(writer) + 1,
writer);
ktxHashList_AddKVPair(&kTexture->kvDataHead, KTX_WRITER_KEY, (ktx_uint32_t)strlen(writer) + 1, writer);
ktxTexture2_TranscodeBasis(kTexture, KTX_TTF_ASTC_4x4_RGBA, 0);
@@ -74,31 +62,26 @@ void FontAsset::save(ArchiveBuffer& buffer) const
}
}
void FontAsset::load(ArchiveBuffer& buffer)
{
void FontAsset::load(ArchiveBuffer& buffer) {
Serialization::load(buffer, glyphs);
size_t numTextures;
Serialization::load(buffer, numTextures);
for (uint64 x = 0; x < numTextures; ++x)
{
for (uint64 x = 0; x < numTextures; ++x) {
Array<uint8> rawTex;
Serialization::load(buffer, rawTex);
ktxTexture2* kTexture;
ktxTexture2_CreateFromMemory(rawTex.data(),
rawTex.size(),
KTX_TEXTURE_CREATE_LOAD_IMAGE_DATA_BIT,
&kTexture);
ktxTexture2_CreateFromMemory(rawTex.data(), rawTex.size(), KTX_TEXTURE_CREATE_LOAD_IMAGE_DATA_BIT, &kTexture);
ktxTexture2_TranscodeBasis(kTexture, KTX_TTF_BC7_RGBA, 0);
TextureCreateInfo createInfo = {
.sourceData = {
.size = ktxTexture_GetDataSize(ktxTexture(kTexture)),
.data = ktxTexture_GetData(ktxTexture(kTexture)),
.owner = Gfx::QueueType::GRAPHICS,
},
.sourceData =
{
.size = ktxTexture_GetDataSize(ktxTexture(kTexture)),
.data = ktxTexture_GetData(ktxTexture(kTexture)),
.owner = Gfx::QueueType::GRAPHICS,
},
.format = (Gfx::SeFormat)kTexture->vkFormat,
.width = kTexture->baseWidth,
.height = kTexture->baseHeight,
@@ -116,21 +99,16 @@ void FontAsset::load(ArchiveBuffer& buffer)
}
}
void Seele::FontAsset::setUsedTextures(Array<Gfx::OTexture2D> _usedTextures)
{
usedTextures = std::move(_usedTextures);
}
void Seele::FontAsset::setUsedTextures(Array<Gfx::OTexture2D> _usedTextures) { usedTextures = std::move(_usedTextures); }
void FontAsset::Glyph::save(ArchiveBuffer& buffer) const
{
void FontAsset::Glyph::save(ArchiveBuffer& buffer) const {
Serialization::save(buffer, textureIndex);
Serialization::save(buffer, size);
Serialization::save(buffer, bearing);
Serialization::save(buffer, advance);
}
void FontAsset::Glyph::load(ArchiveBuffer& buffer)
{
void FontAsset::Glyph::load(ArchiveBuffer& buffer) {
Serialization::load(buffer, textureIndex);
Serialization::load(buffer, size);
Serialization::load(buffer, bearing);
src/Engine/Asset/FontAsset.h
+6 -8
View File
@@ -3,12 +3,10 @@
#include "Containers/Map.h"
#include "Math/Math.h"
namespace Seele
{
namespace Seele {
DECLARE_NAME_REF(Gfx, Texture2D)
class FontAsset : public Asset
{
public:
class FontAsset : public Asset {
public:
static constexpr uint64 IDENTIFIER = 0x10;
FontAsset();
FontAsset(std::string_view folderPath, std::string_view name);
@@ -16,8 +14,7 @@ public:
virtual void save(ArchiveBuffer& buffer) const override;
virtual void load(ArchiveBuffer& buffer) override;
struct Glyph
{
struct Glyph {
uint32 textureIndex;
IVector2 size;
IVector2 bearing;
@@ -28,7 +25,8 @@ public:
const Map<uint32, Glyph> getGlyphData() const { return glyphs; }
Gfx::PTexture2D getTexture(uint32 index) { return usedTextures[index]; }
void setUsedTextures(Array<Gfx::OTexture2D> _usedTextures);
private:
private:
Array<Gfx::OTexture2D> usedTextures;
Map<uint32, Glyph> glyphs;
friend class FontLoader;
src/Engine/Asset/LevelAsset.cpp
+5 -21
View File
@@ -2,28 +2,12 @@
using namespace Seele;
LevelAsset::LevelAsset()
{
}
LevelAsset::LevelAsset() {}
LevelAsset::LevelAsset(std::string_view folderPath, std::string_view name)
: Asset(folderPath, name)
{
}
LevelAsset::LevelAsset(std::string_view folderPath, std::string_view name) : Asset(folderPath, name) {}
LevelAsset::~LevelAsset()
{
}
LevelAsset::~LevelAsset() {}
void LevelAsset::save(ArchiveBuffer&) const
{
}
void LevelAsset::save(ArchiveBuffer&) const {}
void LevelAsset::load(ArchiveBuffer&)
{
}
void LevelAsset::load(ArchiveBuffer&) {}
src/Engine/Asset/LevelAsset.h
+4 -6
View File
@@ -1,18 +1,16 @@
#pragma once
#include "Asset.h"
namespace Seele
{
class LevelAsset : public Asset
{
public:
namespace Seele {
class LevelAsset : public Asset {
public:
static constexpr uint64 IDENTIFIER = 0x20;
LevelAsset();
LevelAsset(std::string_view folderPath, std::string_view name);
virtual ~LevelAsset();
virtual void save(ArchiveBuffer& buffer) const override;
virtual void load(ArchiveBuffer& buffer) override;
private:
private:
};
} // namespace Seele
src/Engine/Asset/MaterialAsset.cpp
+10 -21
View File
@@ -1,38 +1,27 @@
#include "MaterialAsset.h"
#include "Material/Material.h"
#include "Graphics/Graphics.h"
#include "MaterialInstanceAsset.h"
#include "Asset/AssetRegistry.h"
#include "Graphics/Graphics.h"
#include "Material/Material.h"
#include "MaterialInstanceAsset.h"
using namespace Seele;
MaterialAsset::MaterialAsset()
{
}
MaterialAsset::MaterialAsset() {}
MaterialAsset::MaterialAsset(std::string_view folderPath, std::string_view name)
: Asset(folderPath, name)
{
}
MaterialAsset::MaterialAsset(std::string_view folderPath, std::string_view name) : Asset(folderPath, name) {}
MaterialAsset::~MaterialAsset()
{
}
MaterialAsset::~MaterialAsset() {}
void MaterialAsset::save(ArchiveBuffer& buffer) const
{
material->save(buffer);
}
void MaterialAsset::save(ArchiveBuffer& buffer) const { material->save(buffer); }
void MaterialAsset::load(ArchiveBuffer& buffer)
{
void MaterialAsset::load(ArchiveBuffer& buffer) {
material = new Material();
material->load(buffer);
material->compile();
}
PMaterialInstanceAsset MaterialAsset::instantiate(const InstantiationParameter& params)
{
PMaterialInstanceAsset MaterialAsset::instantiate(const InstantiationParameter& params) {
OMaterialInstance instance = material->instantiate();
instance->setBaseMaterial(this);
OMaterialInstanceAsset asset = new MaterialInstanceAsset(params.folderPath, params.name);
src/Engine/Asset/MaterialAsset.h
+6 -8
View File
@@ -1,18 +1,15 @@
#pragma once
#include "Asset.h"
namespace Seele
{
namespace Seele {
DECLARE_REF(Material)
DECLARE_REF(MaterialInstanceAsset)
struct InstantiationParameter
{
struct InstantiationParameter {
std::string name;
std::string folderPath;
};
class MaterialAsset : public Asset
{
public:
class MaterialAsset : public Asset {
public:
static constexpr uint64 IDENTIFIER = 0x4;
MaterialAsset();
MaterialAsset(std::string_view folderPath, std::string_view name);
@@ -21,7 +18,8 @@ public:
virtual void load(ArchiveBuffer& buffer) override;
PMaterial getMaterial() const { return material; }
PMaterialInstanceAsset instantiate(const InstantiationParameter& params);
private:
private:
OMaterial material;
friend class MaterialLoader;
friend class MeshLoader;
src/Engine/Asset/MaterialInstanceAsset.cpp
+9 -18
View File
@@ -1,34 +1,25 @@
#include "MaterialInstanceAsset.h"
#include "Material/MaterialInstance.h"
#include "Material/Material.h"
#include "Graphics/Graphics.h"
#include "Asset/AssetRegistry.h"
#include "Graphics/Graphics.h"
#include "Material/Material.h"
#include "Material/MaterialInstance.h"
using namespace Seele;
MaterialInstanceAsset::MaterialInstanceAsset()
{
}
MaterialInstanceAsset::MaterialInstanceAsset() {}
MaterialInstanceAsset::MaterialInstanceAsset(std::string_view folderPath, std::string_view name)
: Asset(folderPath, name)
{
}
MaterialInstanceAsset::MaterialInstanceAsset(std::string_view folderPath, std::string_view name) : Asset(folderPath, name) {}
MaterialInstanceAsset::~MaterialInstanceAsset()
{
}
MaterialInstanceAsset::~MaterialInstanceAsset() {}
void MaterialInstanceAsset::save(ArchiveBuffer& buffer) const
{
void MaterialInstanceAsset::save(ArchiveBuffer& buffer) const {
Serialization::save(buffer, baseMaterial->getFolderPath());
Serialization::save(buffer, baseMaterial->getName());
material->save(buffer);
}
void MaterialInstanceAsset::load(ArchiveBuffer& buffer)
{
void MaterialInstanceAsset::load(ArchiveBuffer& buffer) {
std::string folder;
Serialization::load(buffer, folder);
std::string id;
src/Engine/Asset/MaterialInstanceAsset.h
+5 -6
View File
@@ -2,11 +2,9 @@
#include "Asset.h"
#include "Material/MaterialInstance.h"
namespace Seele
{
class MaterialInstanceAsset : public Asset
{
public:
namespace Seele {
class MaterialInstanceAsset : public Asset {
public:
static constexpr uint64 IDENTIFIER = 0x8;
MaterialInstanceAsset();
MaterialInstanceAsset(std::string_view folderPath, std::string_view name);
@@ -16,7 +14,8 @@ public:
void setHandle(OMaterialInstance handle) { material = std::move(handle); }
void setBase(PMaterialAsset base) { baseMaterial = base; }
PMaterialInstance getHandle() const { return material; }
private:
private:
OMaterialInstance material;
PMaterialAsset baseMaterial;
};
src/Engine/Asset/MeshAsset.cpp
+7 -19
View File
@@ -1,29 +1,17 @@
#include "MeshAsset.h"
#include "AssetRegistry.h"
#include "Graphics/Graphics.h"
#include "Graphics/Mesh.h"
#include "AssetRegistry.h"
using namespace Seele;
MeshAsset::MeshAsset()
{
}
MeshAsset::MeshAsset() {}
MeshAsset::MeshAsset(std::string_view folderPath, std::string_view name)
: Asset(folderPath, name)
{
}
MeshAsset::MeshAsset(std::string_view folderPath, std::string_view name) : Asset(folderPath, name) {}
MeshAsset::~MeshAsset()
{
}
MeshAsset::~MeshAsset() {}
void MeshAsset::save(ArchiveBuffer& buffer) const
{
Serialization::save(buffer, meshes);
}
void MeshAsset::save(ArchiveBuffer& buffer) const { Serialization::save(buffer, meshes); }
void MeshAsset::load(ArchiveBuffer& buffer)
{
Serialization::load(buffer, meshes);
}
void MeshAsset::load(ArchiveBuffer& buffer) { Serialization::load(buffer, meshes); }
src/Engine/Asset/MeshAsset.h
+4 -6
View File
@@ -2,20 +2,18 @@
#include "Asset.h"
#include "Component/Collider.h"
namespace Seele
{
namespace Seele {
DECLARE_REF(Mesh)
DECLARE_REF(MaterialInterface)
class MeshAsset : public Asset
{
public:
class MeshAsset : public Asset {
public:
static constexpr uint64 IDENTIFIER = 0x2;
MeshAsset();
MeshAsset(std::string_view folderPath, std::string_view name);
virtual ~MeshAsset();
virtual void save(ArchiveBuffer& buffer) const override;
virtual void load(ArchiveBuffer& buffer) override;
//Workaround while no editor
// Workaround while no editor
Array<OMesh> meshes;
Component::Collider physicsMesh;
};
src/Engine/Asset/TextureAsset.cpp
+49 -65
View File
@@ -1,69 +1,67 @@
#include "TextureAsset.h"
#include "Graphics/Graphics.h"
#include "Window/WindowManager.h"
#include "Graphics/Vulkan/Enums.h"
#include "Graphics/Texture.h"
#include "Graphics/Vulkan/Enums.h"
#include "Window/WindowManager.h"
#include "ktx.h"
using namespace Seele;
#define KTX_ASSERT(x) { auto error = x; if(error != KTX_SUCCESS) { std::cout << ktxErrorString(error) << std::endl; abort(); } }
#define KTX_ASSERT(x) \
{ \
auto error = x; \
if (error != KTX_SUCCESS) { \
std::cout << ktxErrorString(error) << std::endl; \
abort(); \
} \
}
TextureAsset::TextureAsset()
{
}
TextureAsset::TextureAsset() {}
TextureAsset::TextureAsset(std::string_view folderPath, std::string_view name)
: Asset(folderPath, name)
{
}
TextureAsset::TextureAsset(std::string_view folderPath, std::string_view name) : Asset(folderPath, name) {}
TextureAsset::~TextureAsset()
{
}
TextureAsset::~TextureAsset() {}
void TextureAsset::save(ArchiveBuffer& buffer) const
{
//ktxBasisParams basisParams = {
// .structSize = sizeof(ktxBasisParams),
// .uastc = true,
// .threadCount = std::thread::hardware_concurrency(),
// .normalMap = normalMap,
// .uastcFlags = KTX_PACK_UASTC_LEVEL_VERYSLOW,
// .uastcRDO = true,
// .uastcRDOQualityScalar = 1,
//};
//KTX_ASSERT(ktxTexture2_CompressBasisEx(ktxHandle, &basisParams));
//KTX_ASSERT(ktxTexture2_DeflateZstd(ktxHandle, 20));
//ktx_uint8_t* texData;
//ktx_size_t texSize;
//KTX_ASSERT(ktxTexture_WriteToMemory(ktxTexture(ktxHandle), &texData, &texSize));
void TextureAsset::save(ArchiveBuffer& buffer) const {
// ktxBasisParams basisParams = {
// .structSize = sizeof(ktxBasisParams),
// .uastc = true,
// .threadCount = std::thread::hardware_concurrency(),
// .normalMap = normalMap,
// .uastcFlags = KTX_PACK_UASTC_LEVEL_VERYSLOW,
// .uastcRDO = true,
// .uastcRDOQualityScalar = 1,
// };
// KTX_ASSERT(ktxTexture2_CompressBasisEx(ktxHandle, &basisParams));
// KTX_ASSERT(ktxTexture2_DeflateZstd(ktxHandle, 20));
// ktx_uint8_t* texData;
// ktx_size_t texSize;
// KTX_ASSERT(ktxTexture_WriteToMemory(ktxTexture(ktxHandle), &texData, &texSize));
//
//Array<uint8> rawData(texSize);
//std::memcpy(rawData.data(), texData, texSize);
//Serialization::save(buffer, rawData);
//free(texData);
// Array<uint8> rawData(texSize);
// std::memcpy(rawData.data(), texData, texSize);
// Serialization::save(buffer, rawData);
// free(texData);
}
void TextureAsset::load(ArchiveBuffer& buffer)
{
void TextureAsset::load(ArchiveBuffer& buffer) {
std::string ktxPath;
Serialization::load(buffer, ktxPath);
ktxTexture2* ktxHandle;
KTX_ASSERT(ktxTexture_CreateFromNamedFile(ktxPath.c_str(),
KTX_TEXTURE_CREATE_NO_FLAGS,
(ktxTexture**)&ktxHandle));
KTX_ASSERT(ktxTexture_CreateFromNamedFile(ktxPath.c_str(), KTX_TEXTURE_CREATE_NO_FLAGS, (ktxTexture**)&ktxHandle));
KTX_ASSERT(ktxTexture2_TranscodeBasis(ktxHandle, KTX_TTF_BC7_RGBA, 0));
Gfx::PGraphics graphics = buffer.getGraphics();
TextureCreateInfo createInfo = {
.sourceData = {
.size = ktxTexture_GetDataSize(ktxTexture(ktxHandle)),
.data = ktxTexture_GetData(ktxTexture(ktxHandle)),
.owner = Gfx::QueueType::TRANSFER,
},
.sourceData =
{
.size = ktxTexture_GetDataSize(ktxTexture(ktxHandle)),
.data = ktxTexture_GetData(ktxTexture(ktxHandle)),
.owner = Gfx::QueueType::TRANSFER,
},
.format = (Gfx::SeFormat)ktxHandle->vkFormat,
.width = ktxHandle->baseWidth,
.height = ktxHandle->baseHeight,
@@ -73,34 +71,20 @@ void TextureAsset::load(ArchiveBuffer& buffer)
.elements = ktxHandle->numLayers,
.usage = Gfx::SE_IMAGE_USAGE_SAMPLED_BIT,
};
if (ktxHandle->isCubemap)
{
if (ktxHandle->isCubemap) {
texture = graphics->createTextureCube(createInfo);
}
else if (ktxHandle->isArray)
{
} else if (ktxHandle->isArray) {
texture = graphics->createTexture3D(createInfo);
}
else
{
} else {
texture = graphics->createTexture2D(createInfo);
}
texture->transferOwnership(Gfx::QueueType::GRAPHICS);
ktxTexture_Destroy(ktxTexture(ktxHandle));
}
void TextureAsset::setTexture(Gfx::OTexture _texture)
{
texture = std::move(_texture);
}
void TextureAsset::setTexture(Gfx::OTexture _texture) { texture = std::move(_texture); }
uint32 TextureAsset::getWidth()
{
return texture->getWidth();
}
uint32 TextureAsset::getWidth() { return texture->getWidth(); }
uint32 TextureAsset::getHeight()
{
return texture->getHeight();
}
uint32 TextureAsset::getHeight() { return texture->getHeight(); }
src/Engine/Asset/TextureAsset.h
+6 -10
View File
@@ -2,12 +2,10 @@
#include "Asset.h"
struct ktxTexture2;
namespace Seele
{
namespace Seele {
DECLARE_NAME_REF(Gfx, Texture)
class TextureAsset : public Asset
{
public:
class TextureAsset : public Asset {
public:
static constexpr uint64 IDENTIFIER = 0x1;
TextureAsset();
TextureAsset(std::string_view folderPath, std::string_view name);
@@ -15,13 +13,11 @@ public:
virtual void save(ArchiveBuffer& buffer) const override;
virtual void load(ArchiveBuffer& buffer) override;
void setTexture(Gfx::OTexture _texture);
Gfx::PTexture getTexture()
{
return texture;
}
Gfx::PTexture getTexture() { return texture; }
uint32 getWidth();
uint32 getHeight();
private:
private:
Gfx::OTexture texture;
bool normalMap;
friend class TextureLoader;