redstrate/prism
Archived
1
Fork 0
Code Activity

Try reformatting asset code with clang-format

Browse source
This commit is contained in:
Joshua Goins 2022-08-15 10:54:34 -04:00
parent e2d29f34f2
commit 069318dc0b
5 changed files with 173 additions and 192 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

20
engine/asset/CMakeLists.txt
View file

@ -1,18 +1,18 @@
set(SRC set(SRC
include/asset_types.hpp include/asset_types.hpp
include/asset.hpp include/asset.hpp
include/assetptr.hpp include/assetptr.hpp
src/asset.cpp) src/asset.cpp)
add_library(Asset STATIC ${SRC}) add_library(Asset STATIC ${SRC})
target_include_directories(Asset PUBLIC include) target_include_directories(Asset PUBLIC include)
target_link_libraries(Asset target_link_libraries(Asset
PUBLIC PUBLIC
Math Math
Renderer Renderer
PRIVATE PRIVATE
stb stb
Log Log
Core) Core)
set_engine_properties(Asset) set_engine_properties(Asset)

110
engine/asset/include/asset.hpp
View file

@ -1,113 +1,101 @@
#pragma once #pragma once
#include <array>
#include <memory> #include <memory>
#include <unordered_map> #include <unordered_map>
#include <array>
#include "file.hpp"
#include "assetptr.hpp"
#include "asset_types.hpp" #include "asset_types.hpp"
#include "assetptr.hpp"
#include "file.hpp"
#include "string_utils.hpp" #include "string_utils.hpp"
template<typename T> template<typename T> std::unique_ptr<T> load_asset(const prism::path& p);
std::unique_ptr<T> load_asset(const prism::path& p);
template<typename T> template<typename T> bool can_load_asset(const prism::path& p);
bool can_load_asset(const prism::path& p);
template<class AssetType> template<class AssetType> using AssetStore = std::unordered_map<prism::path, std::unique_ptr<AssetType>>;
using AssetStore = std::unordered_map<prism::path, std::unique_ptr<AssetType>>;
template<class... Assets> template<class... Assets> class AssetPool : public AssetStore<Assets>... {
class AssetPool : public AssetStore<Assets>... {
public: public:
template<typename T> template<typename T> AssetPtr<T> add() {
AssetPtr<T> add() {
const auto p = prism::path(); const auto p = prism::path();
auto reference_block = get_reference_block(p); auto reference_block = get_reference_block(p);
AssetStore<T>::try_emplace(p, std::make_unique<T>()); AssetStore<T>::try_emplace(p, std::make_unique<T>());
return AssetPtr<T>(AssetStore<T>::at(p).get(), reference_block); return AssetPtr<T>(AssetStore<T>::at(p).get(), reference_block);
} }
template<typename T> template<typename T> AssetPtr<T> get(const prism::path path) { return fetch<T>(path, get_reference_block(path)); }
AssetPtr<T> get(const prism::path path) {
return fetch<T>(path, get_reference_block(path)); template<typename T> std::vector<T*> get_all() {
}
template<typename T>
std::vector<T*> get_all() {
std::vector<T*> assets; std::vector<T*> assets;
for(auto iter = AssetStore<T>::begin(); iter != AssetStore<T>::end(); iter++) { for (auto iter = AssetStore<T>::begin(); iter != AssetStore<T>::end(); iter++) {
auto& [p, asset] = *iter; auto& [p, asset] = *iter;
assets.push_back(asset.get()); assets.push_back(asset.get());
} }
return assets; return assets;
} }
template<typename T> template<typename T> AssetPtr<T> fetch(const prism::path path, ReferenceBlock* reference_block) {
AssetPtr<T> fetch(const prism::path path, ReferenceBlock* reference_block) { if (!AssetStore<T>::count(path))
if(!AssetStore<T>::count(path))
AssetStore<T>::try_emplace(path, load_asset<T>(path)); AssetStore<T>::try_emplace(path, load_asset<T>(path));
return AssetPtr<T>(AssetStore<T>::at(path).get(), reference_block); return AssetPtr<T>(AssetStore<T>::at(path).get(), reference_block);
} }
std::tuple<Asset*, ReferenceBlock*> load_asset_generic(const prism::path path) { std::tuple<Asset*, ReferenceBlock*> load_asset_generic(const prism::path path) {
Asset* asset = nullptr; Asset* asset = nullptr;
ReferenceBlock* block = nullptr; ReferenceBlock* block = nullptr;
(load_asset_generic<Assets>(path, asset, block), ...); (load_asset_generic<Assets>(path, asset, block), ...);
return {asset, block}; return {asset, block};
} }
void perform_cleanup() { void perform_cleanup() {
for(auto iter = reference_blocks.begin(); iter != reference_blocks.end();) { for (auto iter = reference_blocks.begin(); iter != reference_blocks.end();) {
auto& [path, block] = *iter; auto& [path, block] = *iter;
if(block->references == 0) { if (block->references == 0) {
((delete_asset<Assets>(path)), ...); ((delete_asset<Assets>(path)), ...);
iter = reference_blocks.erase(iter); iter = reference_blocks.erase(iter);
} else { } else {
iter = std::next(iter); iter = std::next(iter);
} }
} }
} }
std::unordered_map<prism::path, std::unique_ptr<ReferenceBlock>> reference_blocks; std::unordered_map<prism::path, std::unique_ptr<ReferenceBlock>> reference_blocks;
private: private:
ReferenceBlock* get_reference_block(const prism::path& path) { ReferenceBlock* get_reference_block(const prism::path& path) {
if(!reference_blocks.count(path)) if (!reference_blocks.count(path))
reference_blocks.try_emplace(path, std::make_unique<ReferenceBlock>()); reference_blocks.try_emplace(path, std::make_unique<ReferenceBlock>());
return reference_blocks[path].get(); return reference_blocks[path].get();
} }
template<typename T> template<typename T> void load_asset_generic(const prism::path& path, Asset*& at, ReferenceBlock*& block) {
void load_asset_generic(const prism::path& path, Asset*& at, ReferenceBlock*& block) { if (can_load_asset<T>(path)) {
if(can_load_asset<T>(path)) { if (!AssetStore<T>::count(path))
if(!AssetStore<T>::count(path))
AssetStore<T>::try_emplace(path, load_asset<T>(path)); AssetStore<T>::try_emplace(path, load_asset<T>(path));
at = AssetStore<T>::at(path).get(); at = AssetStore<T>::at(path).get();
block = get_reference_block(path); block = get_reference_block(path);
} }
} }
template<typename T> template<typename T> void delete_asset(const prism::path path) {
void delete_asset(const prism::path path) {
auto iter = AssetStore<T>::find(path); auto iter = AssetStore<T>::find(path);
if(iter != AssetStore<T>::end()) { if (iter != AssetStore<T>::end()) {
auto& [_, asset] = *iter; auto& [_, asset] = *iter;
asset.reset(); asset.reset();
AssetStore<T>::erase(iter); AssetStore<T>::erase(iter);
} }
} }
@ -123,24 +111,22 @@ std::unique_ptr<Texture> load_texture(const prism::path& path);
void save_material(Material* material, const prism::path& path); void save_material(Material* material, const prism::path& path);
template<typename T> template<typename T> std::unique_ptr<T> load_asset(const prism::path& path) {
std::unique_ptr<T> load_asset(const prism::path& path) {
if constexpr (std::is_same_v<T, Mesh>) { if constexpr (std::is_same_v<T, Mesh>) {
return load_mesh(path); return load_mesh(path);
} else if constexpr(std::is_same_v<T, Material>) { } else if constexpr (std::is_same_v<T, Material>) {
return load_material(path); return load_material(path);
} else if constexpr(std::is_same_v<T, Texture>) { } else if constexpr (std::is_same_v<T, Texture>) {
return load_texture(path); return load_texture(path);
} }
} }
template<typename T> template<typename T> bool can_load_asset(const prism::path& path) {
bool can_load_asset(const prism::path& path) { if constexpr (std::is_same_v<T, Mesh>) {
if constexpr(std::is_same_v<T, Mesh>) {
return path.extension() == ".model"; return path.extension() == ".model";
} else if constexpr(std::is_same_v<T, Material>) { } else if constexpr (std::is_same_v<T, Material>) {
return path.extension() == ".material"; return path.extension() == ".material";
} else if constexpr(std::is_same_v<T, Texture>) { } else if constexpr (std::is_same_v<T, Texture>) {
return path.extension() == ".png"; return path.extension() == ".png";
} }
} }

19
engine/asset/include/asset_types.hpp
View file

@ -2,16 +2,16 @@
#include <map> #include <map>
#include "aabb.hpp"
#include "assetptr.hpp" #include "assetptr.hpp"
#include "math.hpp" #include "math.hpp"
#include "aabb.hpp"
#include "utility.hpp" #include "utility.hpp"
class GFXBuffer; class GFXBuffer;
class GFXTexture; class GFXTexture;
class Texture : public Asset { class Texture : public Asset {
public: public:
GFXTexture* handle = nullptr; GFXTexture* handle = nullptr;
int width = 0, height = 0; int width = 0, height = 0;
}; };
@ -75,16 +75,17 @@ struct Bone {
class Mesh : public Asset { class Mesh : public Asset {
public: public:
// meshes are rendered in parts if we cannot batch it in one call, i.e. a mesh // meshes are rendered in parts if we cannot batch it in one call, i.e. a
// with multiple materials with different textures, etc // mesh with multiple materials with different textures, etc
struct Part { struct Part {
std::string name; std::string name;
prism::aabb bounding_box; prism::aabb bounding_box;
GFXBuffer* bone_batrix_buffer = nullptr; GFXBuffer* bone_batrix_buffer = nullptr;
std::vector<Matrix4x4> offset_matrices; std::vector<Matrix4x4> offset_matrices;
uint32_t index_offset = 0, index_count = 0;; uint32_t index_offset = 0, index_count = 0;
;
int32_t vertex_offset = 0; int32_t vertex_offset = 0;
int32_t material_override = -1; int32_t material_override = -1;
std::string material_hint; std::string material_hint;
@ -101,9 +102,9 @@ public:
GFXBuffer* tangent_buffer = nullptr; GFXBuffer* tangent_buffer = nullptr;
GFXBuffer* bitangent_buffer = nullptr; GFXBuffer* bitangent_buffer = nullptr;
GFXBuffer* bone_buffer = nullptr; GFXBuffer* bone_buffer = nullptr;
GFXBuffer* index_buffer = nullptr; GFXBuffer* index_buffer = nullptr;
Matrix4x4 global_inverse_transformation; Matrix4x4 global_inverse_transformation;
uint32_t num_indices = 0; uint32_t num_indices = 0;

43
engine/asset/include/assetptr.hpp
View file

@ -12,24 +12,21 @@ public:
std::string path; std::string path;
}; };
template<class T> template<class T> struct AssetPtr {
struct AssetPtr {
AssetPtr() = default; AssetPtr() = default;
AssetPtr(T* ptr, ReferenceBlock* block) : handle(ptr), block(block) { AssetPtr(T* ptr, ReferenceBlock* block) : handle(ptr), block(block) { block->references++; }
block->references++;
}
AssetPtr(const AssetPtr &rhs) { AssetPtr(const AssetPtr& rhs) {
handle = rhs.handle; handle = rhs.handle;
block = rhs.block; block = rhs.block;
if(block != nullptr) if (block != nullptr)
block->references++; block->references++;
} }
AssetPtr& operator=(const AssetPtr& rhs) { AssetPtr& operator=(const AssetPtr& rhs) {
if(&rhs != this) { if (&rhs != this) {
handle = rhs.handle; handle = rhs.handle;
block = rhs.block; block = rhs.block;
@ -41,14 +38,14 @@ struct AssetPtr {
} }
~AssetPtr() { ~AssetPtr() {
if(block != nullptr) if (block != nullptr)
block->references--; block->references--;
} }
void clear() { void clear() {
if(block != nullptr) if (block != nullptr)
block->references--; block->references--;
block = nullptr; block = nullptr;
handle = nullptr; handle = nullptr;
} }
@ -56,23 +53,13 @@ struct AssetPtr {
T* handle = nullptr; T* handle = nullptr;
ReferenceBlock* block = nullptr; ReferenceBlock* block = nullptr;
explicit operator bool() const{ explicit operator bool() const { return handle != nullptr; }
return handle != nullptr;
}
T* operator->() { T* operator->() { return handle; }
return handle;
}
T* operator->() const { T* operator->() const { return handle; }
return handle;
}
T* operator*() {
return handle;
}
T* operator*() const { T* operator*() { return handle; }
return handle;
} T* operator*() const { return handle; }
}; };

173
engine/asset/src/asset.cpp
View file

@ -1,25 +1,25 @@
#include "asset.hpp" #include "asset.hpp"
#include <map>
#include <array> #include <array>
#include <map>
#include <stb_image.h> #include <stb_image.h>
#include "log.hpp" #include "assertions.hpp"
#include "engine.hpp" #include "engine.hpp"
#include "gfx.hpp" #include "gfx.hpp"
#include "json_conversions.hpp"
#include "gfx_commandbuffer.hpp" #include "gfx_commandbuffer.hpp"
#include "assertions.hpp"
#include "renderer.hpp"
#include "input.hpp"
#include "physics.hpp"
#include "imgui_backend.hpp" #include "imgui_backend.hpp"
#include "input.hpp"
#include "json_conversions.hpp"
#include "log.hpp"
#include "physics.hpp"
#include "renderer.hpp"
std::unique_ptr<Mesh> load_mesh(const prism::path& path) { std::unique_ptr<Mesh> load_mesh(const prism::path& path) {
Expects(!path.empty()); Expects(!path.empty());
auto file = prism::open_file(path, true); auto file = prism::open_file(path, true);
if(!file.has_value()) { if (!file.has_value()) {
prism::log("Failed to load mesh from {}!", path.string()); prism::log("Failed to load mesh from {}!", path.string());
return nullptr; return nullptr;
} }
@ -27,7 +27,7 @@ std::unique_ptr<Mesh> load_mesh(const prism::path& path) {
int version = 0; int version = 0;
file->read(&version); file->read(&version);
if(version == 5 || version == 6 || version == 7) { if (version == 5 || version == 6 || version == 7) {
} else { } else {
prism::log("{} failed the mesh version check! reported version = {}", path.string(), version); prism::log("{} failed the mesh version check! reported version = {}", path.string(), version);
return nullptr; return nullptr;
@ -35,34 +35,35 @@ std::unique_ptr<Mesh> load_mesh(const prism::path& path) {
auto mesh = std::make_unique<Mesh>(); auto mesh = std::make_unique<Mesh>();
mesh->path = path.string(); mesh->path = path.string();
enum MeshType : int { enum MeshType : int {
Static, Static,
Skinned Skinned
} mesh_type; } mesh_type;
file->read(&mesh_type); file->read(&mesh_type);
// TODO: use unsigned int here // TODO: use unsigned int here
int numVertices = 0; int numVertices = 0;
file->read(&numVertices); file->read(&numVertices);
Expects(numVertices > 0); Expects(numVertices > 0);
const auto read_buffer = [&f = file.value(), numVertices](unsigned int size) -> GFXBuffer* { const auto read_buffer = [&f = file.value(), numVertices](unsigned int size) -> GFXBuffer* {
auto buffer = engine->get_gfx()->create_buffer(nullptr, size * static_cast<unsigned int>(numVertices), false, GFXBufferUsage::Vertex); auto buffer = engine->get_gfx()->create_buffer(
nullptr, size * static_cast<unsigned int>(numVertices), false, GFXBufferUsage::Vertex);
auto buffer_ptr = reinterpret_cast<unsigned char*>(engine->get_gfx()->get_buffer_contents(buffer)); auto buffer_ptr = reinterpret_cast<unsigned char*>(engine->get_gfx()->get_buffer_contents(buffer));
if(buffer_ptr != nullptr) { if (buffer_ptr != nullptr) {
f.read(buffer_ptr, size * static_cast<unsigned int>(numVertices)); f.read(buffer_ptr, size * static_cast<unsigned int>(numVertices));
engine->get_gfx()->release_buffer_contents(buffer, buffer_ptr); engine->get_gfx()->release_buffer_contents(buffer, buffer_ptr);
} else { } else {
f.seek(size * static_cast<unsigned int>(numVertices)); f.seek(size * static_cast<unsigned int>(numVertices));
} }
return buffer; return buffer;
}; };
// read positions // read positions
mesh->position_buffer = read_buffer(sizeof(prism::float3)); mesh->position_buffer = read_buffer(sizeof(prism::float3));
mesh->normal_buffer = read_buffer(sizeof(prism::float3)); mesh->normal_buffer = read_buffer(sizeof(prism::float3));
@ -70,51 +71,52 @@ std::unique_ptr<Mesh> load_mesh(const prism::path& path) {
mesh->tangent_buffer = read_buffer(sizeof(prism::float3)); mesh->tangent_buffer = read_buffer(sizeof(prism::float3));
mesh->bitangent_buffer = read_buffer(sizeof(prism::float3)); mesh->bitangent_buffer = read_buffer(sizeof(prism::float3));
if(mesh_type == MeshType::Skinned) if (mesh_type == MeshType::Skinned)
mesh->bone_buffer = read_buffer(sizeof(BoneVertexData)); mesh->bone_buffer = read_buffer(sizeof(BoneVertexData));
int numIndices = 0; int numIndices = 0;
file->read(&numIndices); file->read(&numIndices);
Expects(numIndices > 0); Expects(numIndices > 0);
mesh->index_buffer = engine->get_gfx()->create_buffer(nullptr, sizeof(uint32_t) * numIndices, false, GFXBufferUsage::Index); mesh->index_buffer =
engine->get_gfx()->create_buffer(nullptr, sizeof(uint32_t) * numIndices, false, GFXBufferUsage::Index);
auto index_ptr = reinterpret_cast<uint32_t*>(engine->get_gfx()->get_buffer_contents(mesh->index_buffer)); auto index_ptr = reinterpret_cast<uint32_t*>(engine->get_gfx()->get_buffer_contents(mesh->index_buffer));
if(index_ptr != nullptr) { if (index_ptr != nullptr) {
file->read(index_ptr, sizeof(uint32_t) * numIndices); file->read(index_ptr, sizeof(uint32_t) * numIndices);
} else { } else {
file->seek(sizeof(uint32_t) * numIndices); file->seek(sizeof(uint32_t) * numIndices);
} }
engine->get_gfx()->release_buffer_contents(mesh->index_buffer, index_ptr); engine->get_gfx()->release_buffer_contents(mesh->index_buffer, index_ptr);
int bone_len = 0; int bone_len = 0;
file->read(&bone_len); file->read(&bone_len);
mesh->bones.reserve(bone_len); mesh->bones.reserve(bone_len);
if(bone_len > 0) { if (bone_len > 0) {
file->read(&mesh->global_inverse_transformation); file->read(&mesh->global_inverse_transformation);
std::map<std::string, uint32_t> boneMapping; std::map<std::string, uint32_t> boneMapping;
std::map<size_t, std::string> parentQueue; std::map<size_t, std::string> parentQueue;
for (int v = 0; v < bone_len; v++) { for (int v = 0; v < bone_len; v++) {
std::string bone, parent; std::string bone, parent;
file->read_string(bone); file->read_string(bone);
file->read_string(parent); file->read_string(parent);
prism::float3 pos; prism::float3 pos;
file->read(&pos); file->read(&pos);
Quaternion rot; Quaternion rot;
file->read(&rot); file->read(&rot);
prism::float3 scl; prism::float3 scl;
file->read(&scl); file->read(&scl);
if(!boneMapping.count(bone)) { if (!boneMapping.count(bone)) {
Bone b; Bone b;
b.index = mesh->bones.size(); b.index = mesh->bones.size();
b.name = bone; b.name = bone;
@ -122,67 +124,68 @@ std::unique_ptr<Mesh> load_mesh(const prism::path& path) {
b.position = pos; b.position = pos;
b.rotation = rot; b.rotation = rot;
b.scale = scl; b.scale = scl;
if(parent != "none" && !parent.empty()) if (parent != "none" && !parent.empty())
parentQueue[b.index] = parent; parentQueue[b.index] = parent;
mesh->bones.push_back(b); mesh->bones.push_back(b);
boneMapping[bone] = b.index; boneMapping[bone] = b.index;
} }
} }
for(auto& [index, parentName] : parentQueue) { for (auto& [index, parentName] : parentQueue) {
for(auto& bone : mesh->bones) { for (auto& bone : mesh->bones) {
if(bone.name == parentName) if (bone.name == parentName)
mesh->bones[index].parent = &bone; mesh->bones[index].parent = &bone;
} }
} }
for(auto& bone : mesh->bones) { for (auto& bone : mesh->bones) {
if(bone.parent == nullptr) if (bone.parent == nullptr)
mesh->root_bone = &bone; mesh->root_bone = &bone;
} }
} }
int numMeshes = 0; int numMeshes = 0;
file->read(&numMeshes); file->read(&numMeshes);
Expects(numMeshes > 0); Expects(numMeshes > 0);
mesh->parts.resize(numMeshes); mesh->parts.resize(numMeshes);
uint32_t vertexOffset = 0, indexOffset = 0; uint32_t vertexOffset = 0, indexOffset = 0;
for(int i = 0; i < numMeshes; i++) { for (int i = 0; i < numMeshes; i++) {
auto& p = mesh->parts[i]; auto& p = mesh->parts[i];
p.vertex_offset = vertexOffset; p.vertex_offset = vertexOffset;
p.index_offset = indexOffset; p.index_offset = indexOffset;
file->read_string(p.name); file->read_string(p.name);
if(version >= 6) { if (version >= 6) {
file->read(&p.bounding_box); file->read(&p.bounding_box);
} }
int numVerts = 0; int numVerts = 0;
file->read(&numVerts); file->read(&numVerts);
file->read(&p.index_count); file->read(&p.index_count);
int numBones = 0; int numBones = 0;
file->read(&numBones); file->read(&numBones);
p.bone_batrix_buffer = engine->get_gfx()->create_buffer(nullptr, sizeof(Matrix4x4) * 128, true, GFXBufferUsage::Storage); p.bone_batrix_buffer =
engine->get_gfx()->create_buffer(nullptr, sizeof(Matrix4x4) * 128, true, GFXBufferUsage::Storage);
if(numBones > 0) {
if (numBones > 0) {
p.offset_matrices.resize(numBones); p.offset_matrices.resize(numBones);
file->read(p.offset_matrices.data(), sizeof(Matrix4x4) * numBones); file->read(p.offset_matrices.data(), sizeof(Matrix4x4) * numBones);
} }
file->read(&p.material_override); file->read(&p.material_override);
if(version == 7) { if (version == 7) {
file->read_string(p.material_hint); file->read_string(p.material_hint);
} }
@ -197,52 +200,56 @@ std::unique_ptr<Mesh> load_mesh(const prism::path& path) {
std::unique_ptr<Texture> load_texture(const prism::path& path) { std::unique_ptr<Texture> load_texture(const prism::path& path) {
Expects(!path.empty()); Expects(!path.empty());
auto file = prism::open_file(path, true); auto file = prism::open_file(path, true);
if(!file.has_value()) { if (!file.has_value()) {
prism::log("Failed to load texture from {}!", path.string()); prism::log("Failed to load texture from {}!", path.string());
return nullptr; return nullptr;
} }
// TODO: expose somehow?? // TODO: expose somehow??
const bool should_generate_mipmaps = true; const bool should_generate_mipmaps = true;
file->read_all(); file->read_all();
int width, height, channels; int width, height, channels;
unsigned char* data = stbi_load_from_memory(file->cast_data<unsigned char>(), file->size(), &width, &height, &channels, 4); unsigned char* data =
if(!data) { stbi_load_from_memory(file->cast_data<unsigned char>(), file->size(), &width, &height, &channels, 4);
if (!data) {
prism::log("Failed to load texture from {}!", path.string()); prism::log("Failed to load texture from {}!", path.string());
return nullptr; return nullptr;
} }
Expects(width > 0); Expects(width > 0);
Expects(height > 0); Expects(height > 0);
auto texture = std::make_unique<Texture>(); auto texture = std::make_unique<Texture>();
texture->path = path.string(); texture->path = path.string();
texture->width = width; texture->width = width;
texture->height = height; texture->height = height;
GFXTextureCreateInfo createInfo = {}; GFXTextureCreateInfo createInfo = {};
createInfo.label = path.string(); createInfo.label = path.string();
createInfo.width = width; createInfo.width = width;
createInfo.height = height; createInfo.height = height;
createInfo.format = GFXPixelFormat::R8G8B8A8_UNORM; createInfo.format = GFXPixelFormat::R8G8B8A8_UNORM;
createInfo.usage = GFXTextureUsage::Sampled | GFXTextureUsage::TransferDst | GFXTextureUsage::TransferSrc; // src and dst are needed for copy tex data -> image and mipmap gen (from image data) respectively createInfo.usage = GFXTextureUsage::Sampled | GFXTextureUsage::TransferDst |
GFXTextureUsage::TransferSrc; // src and dst are needed for copy tex
if(should_generate_mipmaps) // data -> image and mipmap gen (from
// image data) respectively
if (should_generate_mipmaps)
createInfo.mip_count = std::floor(std::log2(std::max(width, height))) + 1; createInfo.mip_count = std::floor(std::log2(std::max(width, height))) + 1;
texture->handle = engine->get_gfx()->create_texture(createInfo); texture->handle = engine->get_gfx()->create_texture(createInfo);
engine->get_gfx()->copy_texture(texture->handle, data, width * height * 4); engine->get_gfx()->copy_texture(texture->handle, data, width * height * 4);
if(createInfo.mip_count > 1) { if (createInfo.mip_count > 1) {
GFXCommandBuffer* cmd_buf = engine->get_gfx()->acquire_command_buffer(false); GFXCommandBuffer* cmd_buf = engine->get_gfx()->acquire_command_buffer(false);
cmd_buf->generate_mipmaps(texture->handle, createInfo.mip_count); cmd_buf->generate_mipmaps(texture->handle, createInfo.mip_count);
engine->get_gfx()->submit(cmd_buf, nullptr); engine->get_gfx()->submit(cmd_buf, nullptr);
} }
@ -253,20 +260,20 @@ std::unique_ptr<Texture> load_texture(const prism::path& path) {
std::unique_ptr<Material> load_material(const prism::path& path) { std::unique_ptr<Material> load_material(const prism::path& path) {
Expects(!path.empty()); Expects(!path.empty());
auto file = prism::open_file(path); auto file = prism::open_file(path);
if(!file.has_value()) { if (!file.has_value()) {
prism::log("Failed to load material from {}!", path.string()); prism::log("Failed to load material from {}!", path.string());
return {}; return {};
} }
nlohmann::json j; nlohmann::json j;
file->read_as_stream() >> j; file->read_as_stream() >> j;
auto mat = std::make_unique<Material>(); auto mat = std::make_unique<Material>();
mat->path = path.string(); mat->path = path.string();
if(!j.count("version") || j["version"] != 3) { if (!j.count("version") || j["version"] != 3) {
prism::log("Material {} failed the version check!", path.string()); prism::log("Material {} failed the version check!", path.string());
return mat; return mat;
} }
@ -277,7 +284,7 @@ std::unique_ptr<Material> load_material(const prism::path& path) {
p.float_value = property["float_value"]; p.float_value = property["float_value"];
p.type = property["type"]; p.type = property["type"];
if(!property["asset_value"].get<std::string>().empty()) { if (!property["asset_value"].get<std::string>().empty()) {
p.value_tex = assetm->get<Texture>(prism::game_domain / property["asset_value"].get<std::string>()); p.value_tex = assetm->get<Texture>(prism::game_domain / property["asset_value"].get<std::string>());
} }
@ -286,7 +293,7 @@ std::unique_ptr<Material> load_material(const prism::path& path) {
mat->colorProperty = loadProperty(j["color"]); mat->colorProperty = loadProperty(j["color"]);
if(j.contains("normal")) if (j.contains("normal"))
mat->normalProperty = loadProperty(j["normal"]); mat->normalProperty = loadProperty(j["normal"]);
return mat; return mat;
@ -295,7 +302,7 @@ std::unique_ptr<Material> load_material(const prism::path& path) {
void save_material(Material* material, const prism::path& path) { void save_material(Material* material, const prism::path& path) {
Expects(material != nullptr); Expects(material != nullptr);
Expects(!path.empty()); Expects(!path.empty());
nlohmann::json j; nlohmann::json j;
j["version"] = 3; j["version"] = 3;