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

Reworked mesh asset loading

Browse Source
This commit is contained in:
Dynamitos
2024-05-01 14:10:52 +02:00
parent 19922f4624
commit 2c1669aab4
23 changed files with 647 additions and 460 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/Engine/Asset/AssetRegistry.cpp
+46 -61
View File
@@ -26,69 +26,54 @@ void AssetRegistry::init(std::filesystem::path rootFolder, Gfx::PGraphics graphi
get().initialize(rootFolder, graphics);
}
PMeshAsset AssetRegistry::findMesh(const std::string &filePath)
PMeshAsset AssetRegistry::findMesh(std::string_view folderPath, std::string_view filePath)
{
AssetFolder* folder = get().assetRoot;
std::string fileName = filePath;
size_t slashLoc = filePath.rfind("/");
if(slashLoc != std::string::npos)
if (!folderPath.empty())
{
folder = get().getOrCreateFolder(filePath.substr(0, slashLoc));
fileName = filePath.substr(slashLoc+1, filePath.size());
folder = get().getOrCreateFolder(folderPath);
}
return folder->meshes.at(fileName);
return folder->meshes.at(std::string(filePath));
}
PTextureAsset AssetRegistry::findTexture(const std::string &filePath)
PTextureAsset AssetRegistry::findTexture(std::string_view folderPath, std::string_view filePath)
{
AssetFolder* folder = get().assetRoot;
std::string fileName = filePath;
size_t slashLoc = filePath.rfind("/");
if (slashLoc != std::string::npos)
if (!folderPath.empty())
{
folder = get().getOrCreateFolder(filePath.substr(0, slashLoc));
fileName = filePath.substr(slashLoc + 1, filePath.size());
folder = get().getOrCreateFolder(folderPath);
}
return folder->textures.at(fileName);
return folder->textures.at(std::string(filePath));
}
PFontAsset AssetRegistry::findFont(const std::string& filePath)
PFontAsset AssetRegistry::findFont(std::string_view folderPath, std::string_view filePath)
{
AssetFolder* folder = get().assetRoot;
std::string fileName = filePath;
size_t slashLoc = filePath.rfind("/");
if(slashLoc != std::string::npos)
if (!folderPath.empty())
{
folder = get().getOrCreateFolder(filePath.substr(0, slashLoc));
fileName = filePath.substr(slashLoc+1, filePath.size());
folder = get().getOrCreateFolder(folderPath);
}
return folder->fonts.at(fileName);
return folder->fonts.at(std::string(filePath));
}
PMaterialAsset AssetRegistry::findMaterial(const std::string &filePath)
PMaterialAsset AssetRegistry::findMaterial(std::string_view folderPath, std::string_view filePath)
{
AssetFolder* folder = get().assetRoot;
std::string fileName = filePath;
size_t slashLoc = filePath.rfind("/");
if (slashLoc != std::string::npos)
if (!folderPath.empty())
{
folder = get().getOrCreateFolder(filePath.substr(0, slashLoc));
fileName = filePath.substr(slashLoc + 1, filePath.size());
folder = get().getOrCreateFolder(folderPath);
}
return folder->materials.at(fileName);
return folder->materials.at(std::string(filePath));
}
PMaterialInstanceAsset AssetRegistry::findMaterialInstance(const std::string &filePath)
PMaterialInstanceAsset AssetRegistry::findMaterialInstance(std::string_view folderPath, std::string_view filePath)
{
AssetFolder* folder = get().assetRoot;
std::string fileName = filePath;
size_t slashLoc = filePath.rfind("/");
if (slashLoc != std::string::npos)
if (!folderPath.empty())
{
folder = get().getOrCreateFolder(filePath.substr(0, slashLoc));
fileName = filePath.substr(slashLoc + 1, filePath.size());
folder = get().getOrCreateFolder(folderPath);
}
return folder->instances.at(fileName);
return folder->instances.at(std::string(filePath));
}
std::ofstream AssetRegistry::createWriteStream(const std::filesystem::path& relativePath, std::ios_base::openmode openmode)
@@ -126,6 +111,31 @@ void AssetRegistry::saveRegistry()
get().saveRegistryInternal();
}
AssetRegistry::AssetFolder* AssetRegistry::getOrCreateFolder(std::string_view fullPath)
{
AssetFolder* result = assetRoot;
std::string temp = std::string(fullPath);
while (!temp.empty())
{
size_t slashLoc = temp.find("/");
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))
{
result->children[folderName] = new AssetFolder(fullPath);
}
result = result->children[folderName];
temp = temp.substr(slashLoc + 1, temp.size());
}
return result;
}
void AssetRegistry::initialize(const std::filesystem::path &_rootFolder, Gfx::PGraphics _graphics)
{
@@ -318,7 +328,7 @@ void AssetRegistry::saveAsset(PAsset asset, uint64 identifier, const std::filesy
if (name.empty())
return;
std::string path = (folderPath / name).replace_extension("asset").string();
std::string path = (folderPath / name).string().append(".asset");
auto assetStream = createWriteStream(std::move(path), std::ios::binary);
ArchiveBuffer buffer(graphics);
// write identifier
@@ -367,31 +377,6 @@ void AssetRegistry::registerMaterialInstance(OMaterialInstanceAsset material)
folder->instances[material->getName()] = std::move(material);
}
AssetRegistry::AssetFolder* AssetRegistry::getOrCreateFolder(std::string fullPath)
{
AssetFolder* result = assetRoot;
std::string temp = fullPath;
while(!fullPath.empty())
{
size_t slashLoc = fullPath.find("/");
if(slashLoc == std::string::npos)
{
if (!result->children.contains(fullPath))
{
result->children[fullPath] = new AssetFolder(fullPath);
}
return result->children[fullPath];
}
std::string folderName = fullPath.substr(0, slashLoc);
if (!result->children.contains(folderName))
{
result->children[folderName] = new AssetFolder(temp);
}
result = result->children[folderName];
fullPath = fullPath.substr(slashLoc+1, fullPath.size());
}
return result;
}
std::ofstream AssetRegistry::internalCreateWriteStream(const std::filesystem::path& relativePath, std::ios_base::openmode openmode)
{
src/Engine/Asset/AssetRegistry.h
+6 -6
View File
@@ -21,11 +21,11 @@ public:
static std::filesystem::path getRootFolder();
static PMeshAsset findMesh(const std::string& filePath);
static PTextureAsset findTexture(const std::string& filePath);
static PFontAsset findFont(const std::string& name);
static PMaterialAsset findMaterial(const std::string& filePath);
static PMaterialInstanceAsset findMaterialInstance(const std::string& filePath);
static PMeshAsset findMesh(std::string_view folderPath, std::string_view filePath);
static PTextureAsset findTexture(std::string_view folderPath, std::string_view filePath);
static PFontAsset findFont(std::string_view folderPath, std::string_view name);
static PMaterialAsset findMaterial(std::string_view folderPath, std::string_view filePath);
static PMaterialInstanceAsset findMaterialInstance(std::string_view folderPath, std::string_view filePath);
static std::ofstream createWriteStream(const std::filesystem::path& relativePath, std::ios_base::openmode openmode = std::ios::out);
static std::ifstream createReadStream(const std::filesystem::path& relativePath, std::ios_base::openmode openmode = std::ios::in);
@@ -46,7 +46,7 @@ public:
AssetFolder(std::string_view folderPath);
~AssetFolder();
};
AssetFolder* getOrCreateFolder(std::string foldername);
AssetFolder* getOrCreateFolder(std::string_view foldername);
AssetRegistry();
static AssetRegistry* getInstance();
private:
src/Engine/Asset/MaterialAsset.h
+1
View File
@@ -24,6 +24,7 @@ public:
private:
OMaterial material;
friend class MaterialLoader;
friend class MeshLoader;
};
DEFINE_REF(MaterialAsset)
} // namespace Seele
src/Engine/Asset/MaterialInstanceAsset.cpp
+5 -2
View File
@@ -22,16 +22,19 @@ MaterialInstanceAsset::~MaterialInstanceAsset()
void MaterialInstanceAsset::save(ArchiveBuffer& buffer) const
{
Serialization::save(buffer, baseMaterial->getAssetIdentifier());
Serialization::save(buffer, baseMaterial->getFolderPath());
Serialization::save(buffer, baseMaterial->getName());
material->save(buffer);
}
void MaterialInstanceAsset::load(ArchiveBuffer& buffer)
{
std::string folder;
Serialization::load(buffer, folder);
std::string id;
Serialization::load(buffer, id);
material = new MaterialInstance();
material->load(buffer);
baseMaterial = AssetRegistry::findMaterial(id);
baseMaterial = AssetRegistry::findMaterial(folder, id);
material->setBaseMaterial(baseMaterial);
}
src/Engine/Asset/TextureAsset.cpp
+19 -51
View File
@@ -20,91 +20,60 @@ TextureAsset::TextureAsset(std::string_view folderPath, std::string_view name)
TextureAsset::~TextureAsset()
{
ktxTexture_Destroy(ktxTexture(ktxHandle));
}
void TextureAsset::save(ArchiveBuffer&) const
void TextureAsset::save(ArchiveBuffer& buffer) const
{
/*ktxTexture2* kTexture;
ktxTextureCreateInfo createInfo = {
.vkFormat = (uint32_t)texture->getFormat(),
.baseWidth = texture->getSizeX(),
.baseHeight = texture->getSizeY(),
.baseDepth = texture->getSizeZ(),
.numDimensions = texture->getSizeZ() > 1 ? 3u : texture->getSizeY() > 1 ? 2u : 1u,
.numLevels = texture->getMipLevels(),
.numLayers = 1,
.numFaces = texture->getNumFaces(),
.isArray = false,
.generateMipmaps = false,
};
KTX_CHECK(ktxTexture2_Create(&createInfo, KTX_TEXTURE_CREATE_ALLOC_STORAGE, &kTexture));
for (uint32 depth = 0; depth < texture->getSizeZ(); ++depth)
{
for (uint32 face = 0; face < texture->getNumFaces(); ++face)
{
// technically, downloading cant be const, because we have to allocate temporary buffers and change layouts
// but practically the texture stays the same
Array<uint8> faceData;
const_cast<Gfx::Texture*>(texture.getHandle())->download(0, depth, face, faceData);
KTX_CHECK(ktxTexture_SetImageFromMemory(ktxTexture(kTexture), 0, depth, face, faceData.data(), faceData.size()));
}
}
char writer[100];
snprintf(writer, sizeof(writer), "%s version %s", "SeeleEngine", "0.0.1");
ktxHashList_AddKVPair(&kTexture->kvDataHead, KTX_WRITER_KEY,
ktxHashList_AddKVPair(&ktxHandle->kvDataHead, KTX_WRITER_KEY,
(ktx_uint32_t)strlen(writer) + 1,
writer);
KTX_CHECK(ktxTexture2_CompressAstc(kTexture, 0));
ktx_uint8_t* texData;
ktx_size_t texSize;
KTX_CHECK(ktxTexture_WriteToMemory(ktxTexture(kTexture), &texData, &texSize));
KTX_CHECK(ktxTexture_WriteToMemory(ktxTexture(ktxHandle), &texData, &texSize));
Array<uint8> rawData(texSize);
std::memcpy(rawData.data(), texData, texSize);
Serialization::save(buffer, rawData);
free(texData);*/
assert(false); // TODO
free(texData);
}
void TextureAsset::load(ArchiveBuffer& buffer)
{
Gfx::PGraphics graphics = buffer.getGraphics();
Serialization::load(buffer, rawPixels);
Array<uint8> rawData;
Serialization::load(buffer, rawData);
ktxTexture2* kTexture;
KTX_CHECK(ktxTexture_CreateFromMemory(rawData.data(),
rawData.size(),
KTX_TEXTURE_CREATE_LOAD_IMAGE_DATA_BIT,
(ktxTexture**)&kTexture));
(ktxTexture**)&ktxHandle));
ktx_error_code_e e = ktxTexture2_TranscodeBasis(kTexture, KTX_TTF_BC7_RGBA, 0);
assert(e == ktx_error_code_e::KTX_SUCCESS);
//ktx_error_code_e e = ktxTexture2_TranscodeBasis(ktxHandle, KTX_TTF_BC7_RGBA, 0);
//assert(e == ktx_error_code_e::KTX_SUCCESS);
TextureCreateInfo createInfo = {
.sourceData = {
.size = ktxTexture_GetDataSize(ktxTexture(kTexture)),
.data = ktxTexture_GetData(ktxTexture(kTexture)),
.size = ktxTexture_GetDataSize(ktxTexture(ktxHandle)),
.data = ktxTexture_GetData(ktxTexture(ktxHandle)),
.owner = Gfx::QueueType::TRANSFER,
},
.format = (Gfx::SeFormat)kTexture->vkFormat,
.width = kTexture->baseWidth,
.height = kTexture->baseHeight,
.depth = kTexture->baseDepth,
.mipLevels = kTexture->numLevels,
.layers = kTexture->numFaces,
.elements = kTexture->numLayers,
.format = (Gfx::SeFormat)ktxHandle->vkFormat,
.width = ktxHandle->baseWidth,
.height = ktxHandle->baseHeight,
.depth = ktxHandle->baseDepth,
.mipLevels = ktxHandle->numLevels,
.layers = ktxHandle->numFaces,
.elements = ktxHandle->numLayers,
.usage = Gfx::SE_IMAGE_USAGE_SAMPLED_BIT,
};
if (kTexture->isCubemap)
if (ktxHandle->isCubemap)
{
texture = graphics->createTextureCube(createInfo);
}
else if (kTexture->isArray)
else if (ktxHandle->isArray)
{
texture = graphics->createTexture3D(createInfo);
}
@@ -113,7 +82,6 @@ void TextureAsset::load(ArchiveBuffer& buffer)
texture = graphics->createTexture2D(createInfo);
}
texture->transferOwnership(Gfx::QueueType::GRAPHICS);
ktxTexture_Destroy(ktxTexture(kTexture));
}
void TextureAsset::setTexture(Gfx::OTexture _texture)
src/Engine/Asset/TextureAsset.h
+2 -5
View File
@@ -1,6 +1,7 @@
#pragma once
#include "Asset.h"
struct ktxTexture2;
namespace Seele
{
DECLARE_NAME_REF(Gfx, Texture)
@@ -18,14 +19,10 @@ public:
{
return texture;
}
const Array<uint8>& getRawPixels()
{
return rawPixels;
}
uint32 getWidth();
uint32 getHeight();
private:
Array<uint8> rawPixels;
struct ktxTexture2* ktxHandle;
Gfx::OTexture texture;
friend class TextureLoader;
};
src/Engine/Graphics/Mesh.cpp
+5 -2
View File
@@ -19,7 +19,8 @@ void Mesh::save(ArchiveBuffer& buffer) const
Serialization::save(buffer, vertexCount);
Serialization::save(buffer, indices);
Serialization::save(buffer, meshlets);
Serialization::save(buffer, referencedMaterial->getAssetIdentifier());
Serialization::save(buffer, referencedMaterial->getFolderPath());
Serialization::save(buffer, referencedMaterial->getName());
vertexData->serializeMesh(id, vertexCount, buffer);
}
@@ -32,9 +33,11 @@ void Mesh::load(ArchiveBuffer& buffer)
vertexData = VertexData::findByTypeName(typeName);
Serialization::load(buffer, indices);
Serialization::load(buffer, meshlets);
std::string refFolder;
Serialization::load(buffer, refFolder);
std::string refId;
Serialization::load(buffer, refId);
referencedMaterial = AssetRegistry::findMaterialInstance(refId);
referencedMaterial = AssetRegistry::findMaterialInstance(refFolder, refId);
id = vertexData->allocateVertexData(vertexCount);
vertexData->loadMesh(id, indices, meshlets);
vertexData->deserializeMesh(id, buffer);
src/Engine/Graphics/RenderPass/SkyboxRenderPass.cpp
+2 -2
View File
@@ -9,8 +9,8 @@ SkyboxRenderPass::SkyboxRenderPass(Gfx::PGraphics graphics, PScene scene)
: RenderPass(graphics, scene)
{
skybox = Seele::Component::Skybox{
.day = AssetRegistry::findTexture("FS000_Day_01")->getTexture().cast<Gfx::TextureCube>(),
.night = AssetRegistry::findTexture("FS000_Night_01")->getTexture().cast<Gfx::TextureCube>(),
//.day = AssetRegistry::findTexture("FS000_Day_01")->getTexture().cast<Gfx::TextureCube>(),
//.night = AssetRegistry::findTexture("FS000_Night_01")->getTexture().cast<Gfx::TextureCube>(),
.fogColor = Vector(0.1, 0.1, 0.8),
.blendFactor = 0,
};
src/Engine/Graphics/StaticMeshVertexData.cpp
+41 -13
View File
@@ -22,7 +22,11 @@ StaticMeshVertexData* StaticMeshVertexData::getInstance()
void StaticMeshVertexData::loadPositions(MeshId id, const Array<Vector>& data)
{
uint64 offset = meshOffsets[id];
uint64 offset;
{
std::unique_lock l(mutex);
offset = meshOffsets[id];
}
assert(offset + data.size() <= head);
std::memcpy(positionData.data() + offset, data.data(), data.size() * sizeof(Vector));
dirty = true;
@@ -30,7 +34,11 @@ void StaticMeshVertexData::loadPositions(MeshId id, const Array<Vector>& data)
void StaticMeshVertexData::loadTexCoords(MeshId id, const Array<Vector2>& data)
{
uint64 offset = meshOffsets[id];
uint64 offset;
{
std::unique_lock l(mutex);
offset = meshOffsets[id];
}
assert(offset + data.size() <= head);
std::memcpy(texCoordsData.data() + offset, data.data(), data.size() * sizeof(Vector2));
dirty = true;
@@ -38,7 +46,11 @@ void StaticMeshVertexData::loadTexCoords(MeshId id, const Array<Vector2>& data)
void StaticMeshVertexData::loadNormals(MeshId id, const Array<Vector>& data)
{
uint64 offset = meshOffsets[id];
uint64 offset;
{
std::unique_lock l(mutex);
offset = meshOffsets[id];
}
assert(offset + data.size() <= head);
std::memcpy(normalData.data() + offset, data.data(), data.size() * sizeof(Vector));
dirty = true;
@@ -46,7 +58,11 @@ void StaticMeshVertexData::loadNormals(MeshId id, const Array<Vector>& data)
void StaticMeshVertexData::loadTangents(MeshId id, const Array<Vector>& data)
{
uint64 offset = meshOffsets[id];
uint64 offset;
{
std::unique_lock l(mutex);
offset = meshOffsets[id];
}
assert(offset + data.size() <= head);
std::memcpy(tangentData.data() + offset, data.data(), data.size() * sizeof(Vector));
dirty = true;
@@ -54,7 +70,11 @@ void StaticMeshVertexData::loadTangents(MeshId id, const Array<Vector>& data)
void StaticMeshVertexData::loadBiTangents(MeshId id, const Array<Vector>& data)
{
uint64 offset = meshOffsets[id];
uint64 offset;
{
std::unique_lock l(mutex);
offset = meshOffsets[id];
}
assert(offset + data.size() <= head);
std::memcpy(biTangentData.data() + offset, data.data(), data.size() * sizeof(Vector));
dirty = true;
@@ -62,7 +82,11 @@ void StaticMeshVertexData::loadBiTangents(MeshId id, const Array<Vector>& data)
void Seele::StaticMeshVertexData::loadColors(MeshId id, const Array<Vector>& data)
{
uint64 offset = meshOffsets[id];
uint64 offset;
{
std::unique_lock l(mutex);
offset = meshOffsets[id];
}
assert(offset + data.size() <= head);
std::memcpy(colorData.data() + offset, data.data(), data.size() * sizeof(Vector));
dirty = true;
@@ -70,19 +94,23 @@ void Seele::StaticMeshVertexData::loadColors(MeshId id, const Array<Vector>& dat
void StaticMeshVertexData::serializeMesh(MeshId id, uint64 numVertices, ArchiveBuffer& buffer)
{
uint64 offset = meshOffsets[id];
uint64 offset;
{
std::unique_lock l(mutex);
offset = meshOffsets[id];
}
Array<Vector> pos(numVertices);
Array<Vector2> tex(numVertices);
Array<Vector> nor(numVertices);
Array<Vector> tan(numVertices);
Array<Vector> bit(numVertices);
Array<Vector> col(numVertices);
std::copy(positionData.begin() + offset, positionData.begin() + offset + numVertices, pos.begin());
std::copy(texCoordsData.begin() + offset, texCoordsData.begin() + offset + numVertices, tex.begin());
std::copy(normalData.begin() + offset, normalData.begin() + offset + numVertices, nor.begin());
std::copy(tangentData.begin() + offset, tangentData.begin() + offset + numVertices, tan.begin());
std::copy(biTangentData.begin() + offset, biTangentData.begin() + offset + numVertices, bit.begin());
std::copy(colorData.begin() + offset, colorData.begin() + offset + numVertices, col.begin());
std::memcpy(positionData.data() + offset, pos.data(), numVertices * sizeof(Vector));
std::memcpy(texCoordsData.data() + offset, tex.data(), numVertices * sizeof(Vector2));
std::memcpy(normalData.data() + offset, nor.data(), numVertices * sizeof(Vector));
std::memcpy(tangentData.data() + offset, tan.data(), numVertices * sizeof(Vector));
std::memcpy(biTangentData.data() + offset, bit.data(), numVertices * sizeof(Vector));
std::memcpy(colorData.data() + offset, col.data(), numVertices * sizeof(Vector));
Serialization::save(buffer, pos);
Serialization::save(buffer, tex);
Serialization::save(buffer, nor);
src/Engine/Graphics/StaticMeshVertexData.h
+1
View File
@@ -29,6 +29,7 @@ public:
private:
virtual void resizeBuffers() override;
virtual void updateBuffers() override;
std::mutex mutex;
Gfx::OShaderBuffer positions;
Array<Vector> positionData;
Gfx::OShaderBuffer texCoords;
src/Engine/Graphics/VertexData.cpp
+2
View File
@@ -146,6 +146,7 @@ void VertexData::createDescriptors()
void VertexData::loadMesh(MeshId id, Array<uint32> loadedIndices, Array<Meshlet> loadedMeshlets)
{
std::unique_lock l(vertexDataLock);
meshlets.reserve(meshlets.size() + loadedMeshlets.size());
vertexIndices.reserve(vertexIndices.size() + loadedMeshlets.size() * Gfx::numVerticesPerMeshlet);
primitiveIndices.reserve(primitiveIndices.size() + loadedMeshlets.size() * Gfx::numPrimitivesPerMeshlet * 3);
@@ -225,6 +226,7 @@ void VertexData::loadMesh(MeshId id, Array<uint32> loadedIndices, Array<Meshlet>
MeshId VertexData::allocateVertexData(uint64 numVertices)
{
std::unique_lock l(vertexDataLock);
MeshId res{ idCounter++ };
meshOffsets[res] = head;
meshVertexCounts[res] = numVertices;
src/Engine/Graphics/VertexData.h
+1
View File
@@ -95,6 +95,7 @@ protected:
};
std::mutex materialDataLock;
Map<std::string, MaterialData> materialData;
std::mutex vertexDataLock;
Map<MeshId, Array<MeshData>> meshData;
Map<MeshId, uint64> meshOffsets;
Map<MeshId, uint64> meshVertexCounts;
src/Engine/Material/ShaderExpression.cpp
+68 -21
View File
@@ -91,9 +91,9 @@ void ShaderParameter::load(ArchiveBuffer& buffer)
Serialization::load(buffer, binding);
}
FloatParameter::FloatParameter(std::string name, uint32 byteOffset, uint32 binding)
FloatParameter::FloatParameter(std::string name, float data, uint32 byteOffset, uint32 binding)
: ShaderParameter(name, byteOffset, binding)
, data(0)
, data(data)
{
output.name = name;
output.type = ExpressionType::FLOAT;
@@ -122,12 +122,12 @@ void FloatParameter::updateDescriptorSet(Gfx::PDescriptorSet, uint8* dst)
void FloatParameter::generateDeclaration(std::ofstream& stream) const
{
stream << "\tlayout(offset = " << byteOffset << ") float " << key << ";\n";
stream << "\tfloat " << key << ";\n";
}
VectorParameter::VectorParameter(std::string name, uint32 byteOffset, uint32 binding)
VectorParameter::VectorParameter(std::string name, Vector data, uint32 byteOffset, uint32 binding)
: ShaderParameter(name, byteOffset, binding)
, data()
, data(data)
{
output.name = name;
output.type = ExpressionType::FLOAT3;
@@ -144,7 +144,7 @@ void VectorParameter::updateDescriptorSet(Gfx::PDescriptorSet, uint8* dst)
void VectorParameter::generateDeclaration(std::ofstream& stream) const
{
stream << "\tlayout(offset = " << byteOffset << ") float3 " << key << ";\n";
stream << "\tfloat3 " << key << ";\n";
}
void VectorParameter::save(ArchiveBuffer& buffer) const
@@ -159,8 +159,9 @@ void VectorParameter::load(ArchiveBuffer& buffer)
Serialization::load(buffer, data);
}
TextureParameter::TextureParameter(std::string name, uint32 byteOffset, uint32 binding)
: ShaderParameter(name, byteOffset, binding)
TextureParameter::TextureParameter(std::string name, PTextureAsset asset, uint32 binding)
: ShaderParameter(name, 0, binding)
, data(asset)
{
output.name = name;
output.type = ExpressionType::TEXTURE;
@@ -183,19 +184,23 @@ void TextureParameter::generateDeclaration(std::ofstream& stream) const
void TextureParameter::save(ArchiveBuffer& buffer) const
{
ShaderParameter::save(buffer);
Serialization::save(buffer, data->getAssetIdentifier());
Serialization::save(buffer, data->getFolderPath());
Serialization::save(buffer, data->getName());
}
void TextureParameter::load(ArchiveBuffer& buffer)
{
ShaderParameter::load(buffer);
std::string folder;
Serialization::load(buffer, folder);
std::string filename;
Serialization::load(buffer, filename);
data = AssetRegistry::findTexture(filename);
data = AssetRegistry::findTexture(folder, filename);
}
SamplerParameter::SamplerParameter(std::string name, uint32 byteOffset, uint32 binding)
: ShaderParameter(name, byteOffset, binding)
SamplerParameter::SamplerParameter(std::string name, Gfx::OSampler sampler, uint32 binding)
: ShaderParameter(name, 0, binding)
, data(std::move(sampler))
{
output.name = name;
output.type = ExpressionType::SAMPLER;
@@ -227,8 +232,10 @@ void SamplerParameter::load(ArchiveBuffer& buffer)
data = buffer.getGraphics()->createSampler(SamplerCreateInfo{});
}
CombinedTextureParameter::CombinedTextureParameter(std::string name, uint32 byteOffset, uint32 binding)
: ShaderParameter(name, byteOffset, binding)
CombinedTextureParameter::CombinedTextureParameter(std::string name, PTextureAsset data, Gfx::OSampler sampler, uint32 binding)
: ShaderParameter(name, 0, binding)
, data(data)
, sampler(std::move(sampler))
{
output.name = name;
output.type = ExpressionType::TEXTURE;
@@ -252,15 +259,18 @@ void CombinedTextureParameter::generateDeclaration(std::ofstream& stream) const
void CombinedTextureParameter::save(ArchiveBuffer& buffer) const
{
ShaderParameter::save(buffer);
Serialization::save(buffer, data->getAssetIdentifier());
Serialization::save(buffer, data->getFolderPath());
Serialization::save(buffer, data->getName());
}
void CombinedTextureParameter::load(ArchiveBuffer& buffer)
{
ShaderParameter::load(buffer);
std::string folder;
Serialization::load(buffer, folder);
std::string filename;
Serialization::load(buffer, filename);
data = AssetRegistry::findTexture(filename);
data = AssetRegistry::findTexture(folder, filename);
sampler = buffer.getGraphics()->createSampler({});
}
@@ -313,7 +323,18 @@ std::string AddExpression::evaluate(Map<std::string, std::string>& varState) con
{
std::string varName = fmt::format("exp_{}", key);
varState[key] = varName;
return fmt::format("let {} = {} + {};\n", varName, varState[inputs.at("lhs").source], varState[inputs.at("rhs").source]);
std::string lhs = inputs.at("lhs").source;
if (varState.contains(lhs))
{
lhs = varState[lhs];
}
std::string rhs = inputs.at("rhs").source;
if (varState.contains(rhs))
{
rhs = varState[rhs];
}
return fmt::format("let {} = {} + {};\n", varName, lhs, rhs);
}
void AddExpression::save(ArchiveBuffer& buffer) const
@@ -330,7 +351,18 @@ std::string SubExpression::evaluate(Map<std::string, std::string>& varState) con
{
std::string varName = fmt::format("exp_{}", key);
varState[key] = varName;
return fmt::format("let {} = {} - {};\n", varName, varState[inputs.at("lhs").source], varState[inputs.at("rhs").source]);
std::string lhs = inputs.at("lhs").source;
if (varState.contains(lhs))
{
lhs = varState[lhs];
}
std::string rhs = inputs.at("rhs").source;
if (varState.contains(rhs))
{
rhs = varState[rhs];
}
return fmt::format("let {} = {} - {};\n", varName, lhs, rhs);
}
void SubExpression::save(ArchiveBuffer& buffer) const
@@ -347,7 +379,17 @@ std::string MulExpression::evaluate(Map<std::string, std::string>& varState) con
{
std::string varName = fmt::format("exp_{}", key);
varState[key] = varName;
return fmt::format("let {} = {} * {};\n", varName, varState[inputs.at("lhs").source], varState[inputs.at("rhs").source]);
std::string lhs = inputs.at("lhs").source;
if (varState.contains(lhs))
{
lhs = varState[lhs];
}
std::string rhs = inputs.at("rhs").source;
if (varState.contains(rhs))
{
rhs = varState[rhs];
}
return fmt::format("let {} = {} * {};\n", varName, lhs, rhs);
}
void MulExpression::save(ArchiveBuffer& buffer) const
@@ -408,13 +450,18 @@ std::string SampleExpression::evaluate(Map<std::string, std::string>& varState)
{
std::string varName = fmt::format("exp_{}", key);
varState[key] = varName;
std::string texCoords = inputs.at("coords").source;
if (varState.contains(inputs.at("coords").source))
{
texCoords = varState[inputs.at("coords").source];
}
if (inputs.contains("texture"))
{
return fmt::format("let {} = {}.Sample({}, {});\n", varName, varState[inputs.at("texture").source], varState[inputs.at("sampler").source], varState[inputs.at("coords").source]);
return fmt::format("let {} = {}.Sample({}, {});\n", varName, varState[inputs.at("texture").source], varState[inputs.at("sampler").source], texCoords);
}
else
{
return fmt::format("let {} = {}.Sample({});\n", varName, varState[inputs.at("sampler").source], varState[inputs.at("coords").source]);
return fmt::format("let {} = {}.Sample({});\n", varName, varState[inputs.at("sampler").source], texCoords);
}
}
src/Engine/Material/ShaderExpression.h
+7 -6
View File
@@ -69,7 +69,7 @@ struct FloatParameter : public ShaderParameter
static constexpr uint64 IDENTIFIER = 0x01;
float data = 0.0f;
FloatParameter() {}
FloatParameter(std::string name, uint32 byteOffset, uint32 binding);
FloatParameter(std::string name, float data, uint32 byteOffset, uint32 binding);
virtual ~FloatParameter();
virtual void updateDescriptorSet(Gfx::PDescriptorSet descriptorSet, uint8* dst) override;
virtual void generateDeclaration(std::ofstream& stream) const override;
@@ -83,7 +83,7 @@ struct VectorParameter : public ShaderParameter
static constexpr uint64 IDENTIFIER = 0x02;
Vector data = Vector();
VectorParameter() {}
VectorParameter(std::string name, uint32 byteOffset, uint32 binding);
VectorParameter(std::string name, Vector data, uint32 byteOffset, uint32 binding);
virtual ~VectorParameter();
virtual void updateDescriptorSet(Gfx::PDescriptorSet descriptorSet, uint8* dst) override;
virtual void generateDeclaration(std::ofstream& stream) const override;
@@ -97,7 +97,7 @@ struct TextureParameter : public ShaderParameter
static constexpr uint64 IDENTIFIER = 0x04;
PTextureAsset data = nullptr;
TextureParameter() {}
TextureParameter(std::string name, uint32 byteOffset, uint32 binding);
TextureParameter(std::string name, PTextureAsset data, uint32 binding);
virtual ~TextureParameter();
virtual void updateDescriptorSet(Gfx::PDescriptorSet descriptorSet, uint8* dst) override;
virtual void generateDeclaration(std::ofstream& stream) const override;
@@ -112,7 +112,7 @@ struct SamplerParameter : public ShaderParameter
static constexpr uint64 IDENTIFIER = 0x08;
Gfx::OSampler data = nullptr;
SamplerParameter() {}
SamplerParameter(std::string name, uint32 byteOffset, uint32 binding);
SamplerParameter(std::string name, Gfx::OSampler sampler, uint32 binding);
virtual ~SamplerParameter();
virtual void updateDescriptorSet(Gfx::PDescriptorSet descriptorSet, uint8* dst) override;
virtual void generateDeclaration(std::ofstream& stream) const override;
@@ -125,9 +125,9 @@ struct CombinedTextureParameter : public ShaderParameter
{
static constexpr uint64 IDENTIFIER = 0x10;
PTextureAsset data = nullptr;
Gfx::PSampler sampler = nullptr;
Gfx::OSampler sampler = nullptr;
CombinedTextureParameter() {}
CombinedTextureParameter(std::string name, uint32 byteOffset, uint32 binding);
CombinedTextureParameter(std::string name, PTextureAsset data, Gfx::OSampler sampler, uint32 binding);
virtual ~CombinedTextureParameter();
virtual void updateDescriptorSet(Gfx::PDescriptorSet descriptorSet, uint8* dst) override;
virtual void generateDeclaration(std::ofstream& stream) const override;
@@ -189,6 +189,7 @@ struct SwizzleExpression : public ShaderExpression
static constexpr uint64 IDENTIFIER = 0x15;
StaticArray<int32, 4> comp = {-1, -1, -1, -1};
SwizzleExpression() {}
SwizzleExpression(StaticArray<int32,4> comp) : comp(std::move(comp)) {}
virtual ~SwizzleExpression() {}
virtual uint64 getIdentifier() const override { return IDENTIFIER; }
virtual std::string evaluate(Map<std::string, std::string>& varState) const override;
src/Engine/Serialization/Serialization.h
+2 -32
View File
@@ -55,41 +55,11 @@ namespace Serialization
}
static void load(ArchiveBuffer& buffer, Matrix4& mat)
{
load(buffer, mat[0][0]);
load(buffer, mat[0][1]);
load(buffer, mat[0][2]);
load(buffer, mat[0][3]);
load(buffer, mat[1][0]);
load(buffer, mat[1][1]);
load(buffer, mat[1][2]);
load(buffer, mat[1][3]);
load(buffer, mat[2][0]);
load(buffer, mat[2][1]);
load(buffer, mat[2][2]);
load(buffer, mat[2][3]);
load(buffer, mat[3][0]);
load(buffer, mat[3][1]);
load(buffer, mat[3][2]);
load(buffer, mat[3][3]);
buffer.readBytes(&mat, sizeof(Matrix4));
}
static void save(ArchiveBuffer& buffer, const Matrix4& mat)
{
save(buffer, mat[0][0]);
save(buffer, mat[0][1]);
save(buffer, mat[0][2]);
save(buffer, mat[0][3]);
save(buffer, mat[1][0]);
save(buffer, mat[1][1]);
save(buffer, mat[1][2]);
save(buffer, mat[1][3]);
save(buffer, mat[2][0]);
save(buffer, mat[2][1]);
save(buffer, mat[2][2]);
save(buffer, mat[2][3]);
save(buffer, mat[3][0]);
save(buffer, mat[3][1]);
save(buffer, mat[3][2]);
save(buffer, mat[3][3]);
buffer.writeBytes(&mat, sizeof(Matrix4));
}
static void load(ArchiveBuffer& buffer, Vector& vec)
{