redstrate/prism
Archived
1
Fork 0
Code Activity

Rename File -> file and move under the prism namespace

Browse source
This commit is contained in:
redstrate 2021-05-12 08:50:02 -04:00
parent ee2771f45f
commit 01966c1d81
33 changed files with 186 additions and 186 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

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

@ -11,28 +11,28 @@
namespace std {
template <>
struct hash<file::Path> {
std::size_t operator()(const file::Path& k) const {
struct hash<prism::Path> {
std::size_t operator()(const prism::Path& k) const {
return (std::hash<std::string>()(k.string()));
}
};
}
template<typename T>
std::unique_ptr<T> load_asset(const file::Path p);
std::unique_ptr<T> load_asset(const prism::Path p);
template<typename T>
bool can_load_asset(const file::Path p);
bool can_load_asset(const prism::Path p);
template<class AssetType>
using AssetStore = std::unordered_map<file::Path, std::unique_ptr<AssetType>>;
using AssetStore = std::unordered_map<prism::Path, std::unique_ptr<AssetType>>;
template<class... Assets>
class AssetPool : public AssetStore<Assets>... {
public:
template<typename T>
AssetPtr<T> add() {
const auto p = file::Path();
const auto p = prism::Path();
auto reference_block = get_reference_block(p);
AssetStore<T>::try_emplace(p, std::make_unique<T>());
@ -41,7 +41,7 @@ public:
}
template<typename T>
AssetPtr<T> get(const file::Path path) {
AssetPtr<T> get(const prism::Path path) {
return fetch<T>(path, get_reference_block(path));
}
@ -58,14 +58,14 @@ public:
}
template<typename T>
AssetPtr<T> fetch(const file::Path path, ReferenceBlock* reference_block) {
AssetPtr<T> fetch(const prism::Path path, ReferenceBlock* reference_block) {
if(!AssetStore<T>::count(path))
AssetStore<T>::try_emplace(path, load_asset<T>(path));
return AssetPtr<T>(AssetStore<T>::at(path).get(), reference_block);
}
std::tuple<Asset*, ReferenceBlock*> load_asset_generic(const file::Path path) {
std::tuple<Asset*, ReferenceBlock*> load_asset_generic(const prism::Path path) {
Asset* asset = nullptr;
ReferenceBlock* block = nullptr;
@ -88,10 +88,10 @@ public:
}
}
std::unordered_map<file::Path, std::unique_ptr<ReferenceBlock>> reference_blocks;
std::unordered_map<prism::Path, std::unique_ptr<ReferenceBlock>> reference_blocks;
private:
ReferenceBlock* get_reference_block(const file::Path path) {
ReferenceBlock* get_reference_block(const prism::Path path) {
if(!reference_blocks.count(path))
reference_blocks.try_emplace(path, std::make_unique<ReferenceBlock>());
@ -99,7 +99,7 @@ private:
}
template<typename T>
void load_asset_generic(const file::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(!AssetStore<T>::count(path))
AssetStore<T>::try_emplace(path, load_asset<T>(path));
@ -110,7 +110,7 @@ private:
}
template<typename T>
void delete_asset(const file::Path path) {
void delete_asset(const prism::Path path) {
auto iter = AssetStore<T>::find(path);
if(iter != AssetStore<T>::end()) {
auto& [_, asset] = *iter;
@ -126,14 +126,14 @@ using AssetManager = AssetPool<Mesh, Material, Texture>;
inline std::unique_ptr<AssetManager> assetm;
std::unique_ptr<Mesh> load_mesh(const file::Path path);
std::unique_ptr<Material> load_material(const file::Path path);
std::unique_ptr<Texture> load_texture(const file::Path path);
std::unique_ptr<Mesh> load_mesh(const prism::Path path);
std::unique_ptr<Material> load_material(const prism::Path path);
std::unique_ptr<Texture> load_texture(const prism::Path path);
void save_material(Material* material, const file::Path path);
void save_material(Material* material, const prism::Path path);
template<typename T>
std::unique_ptr<T> load_asset(const file::Path path) {
std::unique_ptr<T> load_asset(const prism::Path path) {
if constexpr (std::is_same_v<T, Mesh>) {
return load_mesh(path);
} else if constexpr(std::is_same_v<T, Material>) {
@ -144,7 +144,7 @@ std::unique_ptr<T> load_asset(const file::Path path) {
}
template<typename T>
bool can_load_asset(const file::Path path) {
bool can_load_asset(const prism::Path path) {
if constexpr(std::is_same_v<T, Mesh>) {
return path.extension() == ".model";
} else if constexpr(std::is_same_v<T, Material>) {

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

@ -15,10 +15,10 @@
#include "physics.hpp"
#include "imgui_backend.hpp"
std::unique_ptr<Mesh> load_mesh(const file::Path path) {
std::unique_ptr<Mesh> load_mesh(const prism::Path path) {
Expects(!path.empty());
auto file = file::open(path, true);
auto file = prism::open_file(path, true);
if(!file.has_value()) {
prism::log::error(System::Renderer, "Failed to load mesh from {}!", path);
return nullptr;
@ -185,10 +185,10 @@ std::unique_ptr<Mesh> load_mesh(const file::Path path) {
return mesh;
}
std::unique_ptr<Texture> load_texture(const file::Path path) {
std::unique_ptr<Texture> load_texture(const prism::Path path) {
Expects(!path.empty());
auto file = file::open(path, true);
auto file = prism::open_file(path, true);
if(!file.has_value()) {
prism::log::error(System::Renderer, "Failed to load texture from {}!", path);
return nullptr;
@ -242,10 +242,10 @@ std::unique_ptr<Texture> load_texture(const file::Path path) {
return texture;
}
std::unique_ptr<Material> load_material(const file::Path path) {
std::unique_ptr<Material> load_material(const prism::Path path) {
Expects(!path.empty());
auto file = file::open(path);
auto file = prism::open_file(path);
if(!file.has_value()) {
prism::log::error(System::Core, "Failed to load material from {}!", path);
return {};
@ -287,7 +287,7 @@ std::unique_ptr<Material> load_material(const file::Path path) {
p.float_value = property["float_value"];
if(!property["asset_value"].get<std::string>().empty()) {
p.value_tex = assetm->get<Texture>(file::app_domain / property["asset_value"].get<std::string>());
p.value_tex = assetm->get<Texture>(prism::app_domain / property["asset_value"].get<std::string>());
}
}
}
@ -331,7 +331,7 @@ std::unique_ptr<Material> load_material(const file::Path path) {
return mat;
}
void save_material(Material* material, const file::Path path) {
void save_material(Material* material, const prism::Path path) {
Expects(material != nullptr);
Expects(!path.empty());

2
engine/audio/include/audio.hpp
View file

@ -8,5 +8,5 @@
namespace audio {
void initialize();
void play_file(const file::Path path, const float gain = 1.0f);
void play_file(const prism::Path path, const float gain = 1.0f);
}

4
engine/audio/src/audio.cpp
View file

@ -77,8 +77,8 @@ void audio::initialize() {
Pa_StartStream(stream);
}
void audio::play_file(const file::Path path, const float gain) {
auto audio_file = file::open(path);
void audio::play_file(const prism::Path path, const float gain) {
auto audio_file = prism::open_file(path);
if(audio_file == std::nullopt)
return;

10
engine/core/include/engine.hpp
View file

@ -134,7 +134,7 @@ namespace prism {
@param path The scene file path.
@return Returns a instance of the scene is successful, and nullptr on failure.
*/
Scene* load_scene(const file::Path& path);
Scene* load_scene(const prism::Path& path);
/** Save the current scene to disk.
@param path The absolute file path.
@ -145,7 +145,7 @@ namespace prism {
@param path The screen file path.
@return Returns a instance of the screen if successful, and nullptr on failure.
*/
ui::Screen* load_screen(const file::Path& path);
ui::Screen* load_screen(const prism::Path& path);
/** Set the current screen.
@param screen The screen object to set as current. Can be null.
@ -162,7 +162,7 @@ namespace prism {
@param path The prefab file path.
@param override_name If not empty, the root object's new name. Defaulted to a empty string.
*/
Object add_prefab(Scene& scene, const file::Path& path, std::string_view override_name = "");
Object add_prefab(Scene& scene, const prism::Path& path, std::string_view override_name = "");
/** Save a tree of objects as a prefab to disk.
@param root The parent object to save as a prefab.
@ -180,12 +180,12 @@ namespace prism {
@param path The animation file path.
@return An animation.
*/
Animation load_animation(const file::Path& path);
Animation load_animation(const prism::Path& path);
/** Load a cutscene from disk. This changes the current cutscene.
@param path The cutscene file path.
*/
void load_cutscene(const file::Path& path);
void load_cutscene(const prism::Path& path);
/** Saves the current cutscene to disk.
@param path The absolute file path.

2
engine/core/include/screen.hpp
View file

@ -15,7 +15,7 @@ namespace ui {
class Screen {
public:
Screen() {}
Screen(const file::Path path);
Screen(const prism::Path path);
void process_event(const std::string& type, std::string data = "");

8
engine/core/src/debug.cpp
View file

@ -169,7 +169,7 @@ void draw_shader_editor() {
if(ImGui::Button("Select Path")) {
platform::open_dialog(false, [](std::string path) {
// open_dialog() can't select folders yet, so use this as a workaround
options.shader_source_path = file::Path(path).parent_path().string();
options.shader_source_path = prism::Path(path).parent_path().string();
});
}
} else {
@ -186,13 +186,13 @@ void draw_shader_editor() {
if(!selected_shader.empty()) {
if(loaded_shader_string.empty()) {
file::Path base_shader_path = options.shader_source_path;
prism::Path base_shader_path = options.shader_source_path;
shader_compiler.set_include_path(base_shader_path.string());
file::Path shader_path = file::Path(selected_shader);
prism::Path shader_path = prism::Path(selected_shader);
auto file = file::open(base_shader_path / shader_path.replace_extension(shader_path.extension().string() + ".glsl"));
auto file = prism::open_file(base_shader_path / shader_path.replace_extension(shader_path.extension().string() + ".glsl"));
loaded_shader_string = file->read_as_string();
}

24
engine/core/src/engine.cpp
View file

@ -63,7 +63,7 @@ prism::app* engine::get_app() const {
void engine::load_localization(const std::string_view path) {
Expects(!path.empty());
auto file = file::open(file::app_domain / path);
auto file = prism::open_file(prism::app_domain / path);
if(file.has_value()) {
nlohmann::json j;
file->read_as_stream() >> j;
@ -131,10 +131,10 @@ void engine::create_empty_scene() {
current_scene = scenes.back().get();
}
Scene* engine::load_scene(const file::Path& path) {
Scene* engine::load_scene(const prism::Path& path) {
Expects(!path.empty());
auto file = file::open(path);
auto file = prism::open_file(path);
if(!file.has_value()) {
prism::log::error(System::Core, "Failed to load scene from {}!", path);
return nullptr;
@ -149,7 +149,7 @@ Scene* engine::load_scene(const file::Path& path) {
for(auto& obj : j["objects"]) {
if(obj.contains("prefabPath")) {
Object o = add_prefab(*scene, file::app_domain / obj["prefabPath"].get<std::string_view>());
Object o = add_prefab(*scene, prism::app_domain / obj["prefabPath"].get<std::string_view>());
scene->get(o).name = obj["name"];
@ -191,7 +191,7 @@ void engine::save_scene(const std::string_view path) {
out << j;
}
ui::Screen* engine::load_screen(const file::Path& path) {
ui::Screen* engine::load_screen(const prism::Path& path) {
Expects(!path.empty());
return new ui::Screen(path);
@ -224,10 +224,10 @@ AnimationChannel engine::load_animation(nlohmann::json a) {
return animation;
}
Animation engine::load_animation(const file::Path& path) {
Animation engine::load_animation(const prism::Path& path) {
Expects(!path.empty());
auto file = file::open(path, true);
auto file = prism::open_file(path, true);
if(!file.has_value()) {
prism::log::error(System::Core, "Failed to load animation from {}!", path);
return {};
@ -282,12 +282,12 @@ Animation engine::load_animation(const file::Path& path) {
return anim;
}
void engine::load_cutscene(const file::Path& path) {
void engine::load_cutscene(const prism::Path& path) {
Expects(!path.empty());
cutscene = std::make_unique<Cutscene>();
auto file = file::open(path);
auto file = prism::open_file(path);
if(!file.has_value()) {
prism::log::error(System::Core, "Failed to load cutscene from {}!", path);
return;
@ -316,7 +316,7 @@ void engine::load_cutscene(const file::Path& path) {
anim.target = obj;
}
} else {
load_scene(file::root_path(path) / s["scene"].get<std::string_view>());
load_scene(prism::root_path(path) / s["scene"].get<std::string_view>());
if(get_scene() == nullptr)
create_empty_scene();
@ -359,10 +359,10 @@ void engine::save_cutscene(const std::string_view path) {
out << j;
}
Object engine::add_prefab(Scene& scene, const file::Path& path, const std::string_view override_name) {
Object engine::add_prefab(Scene& scene, const prism::Path& path, const std::string_view override_name) {
Expects(!path.empty());
auto file = file::open(path);
auto file = prism::open_file(path);
if(!file.has_value()) {
prism::log::error(System::Core, "Failed to load prefab from {}!", path);
return NullObject;

18
engine/core/src/file.cpp
View file

@ -6,7 +6,7 @@
#include "log.hpp"
#include "assertions.hpp"
file::Path file::root_path(const Path path) {
prism::Path prism::root_path(const Path path) {
auto p = path;
while(p.parent_path() != p && p.parent_path() != "/") {
p = p.parent_path();
@ -15,7 +15,7 @@ file::Path file::root_path(const Path path) {
return p;
}
std::optional<file::File> file::open(const file::Path path, const bool binary_mode) {
std::optional<prism::file> prism::open_file(const prism::Path path, const bool binary_mode) {
Expects(!path.empty());
auto str = get_file_path(path).string();
@ -25,30 +25,30 @@ std::optional<file::File> file::open(const file::Path path, const bool binary_mo
return {};
}
return file::File(file);
return prism::file(file);
}
file::Path file::get_file_path(const file::Path path) {
prism::Path prism::get_file_path(const prism::Path& path) {
auto fixed_path = path;
auto root = root_path(path);
if(root == app_domain) {
fixed_path = domain_data[static_cast<int>(Domain::App)] / path.lexically_relative(root_path(path));
fixed_path = domain_data[static_cast<int>(domain::app)] / path.lexically_relative(root_path(path));
} else if(root == internal_domain) {
fixed_path = domain_data[static_cast<int>(Domain::Internal)] / path.lexically_relative(root_path(path));
fixed_path = domain_data[static_cast<int>(domain::internal)] / path.lexically_relative(root_path(path));
}
return fixed_path;
}
file::Path file::get_domain_path(const Domain domain) {
prism::Path prism::get_domain_path(const domain domain) {
return domain_data[static_cast<int>(domain)];
}
file::Path parent_domain(const file::Path path) {
prism::Path parent_domain(const prism::Path& path) {
return path;
}
file::Path file::get_relative_path(const Domain domain, const Path path) {
prism::Path prism::get_relative_path(const domain domain, const Path path) {
// unimplemented
return path;
}

4
engine/core/src/scene.cpp
View file

@ -19,10 +19,10 @@ void load_transform_component(nlohmann::json j, Transform& t) {
void load_renderable_component(nlohmann::json j, Renderable& t) {
if(j.contains("path"))
t.mesh = assetm->get<Mesh>(file::app_domain / j["path"].get<std::string_view>());
t.mesh = assetm->get<Mesh>(prism::app_domain / j["path"].get<std::string_view>());
for(auto& material : j["materials"])
t.materials.push_back(assetm->get<Material>(file::app_domain / material.get<std::string_view>()));
t.materials.push_back(assetm->get<Material>(prism::app_domain / material.get<std::string_view>()));
}
void load_camera_component(nlohmann::json j, Camera& camera) {

4
engine/core/src/screen.cpp
View file

@ -94,8 +94,8 @@ UIElement* ui::Screen::find_element(const std::string& id) {
return foundElement;
}
ui::Screen::Screen(const file::Path path) {
auto file = file::open(path);
ui::Screen::Screen(const prism::Path path) {
auto file = prism::open_file(path);
if(!file.has_value()) {
prism::log::error(System::Core, "Failed to load UI from {}!", path);
return;

6
engine/gfx/vulkan/src/gfx_vulkan.cpp
View file

@ -754,7 +754,7 @@ GFXPipeline* GFXVulkan::create_graphics_pipeline(const GFXGraphicsPipelineCreate
vertex_module = createShaderModule(vertex_shader_vector.data(), vertex_shader_vector.size() * sizeof(uint32_t));
}
else {
auto vertex_shader = file::open(file::internal_domain / (info.shaders.vertex_src.as_path().string()), true);
auto vertex_shader = prism::open_file(prism::internal_domain / (info.shaders.vertex_src.as_path().string()), true);
vertex_shader->read_all();
vertex_module = createShaderModule(vertex_shader->cast_data<uint32_t>(), vertex_shader->size());
@ -781,7 +781,7 @@ GFXPipeline* GFXVulkan::create_graphics_pipeline(const GFXGraphicsPipelineCreate
fragment_module = createShaderModule(fragment_shader_vector.data(), fragment_shader_vector.size() * sizeof(uint32_t));
}
else {
auto fragment_shader = file::open(file::internal_domain / (info.shaders.fragment_src.as_path().string()), true);
auto fragment_shader = prism::open_file(prism::internal_domain / (info.shaders.fragment_src.as_path().string()), true);
fragment_shader->read_all();
fragment_module = createShaderModule(fragment_shader->cast_data<uint32_t>(), fragment_shader->size());
@ -1035,7 +1035,7 @@ GFXPipeline* GFXVulkan::create_compute_pipeline(const GFXComputePipelineCreateIn
compute_module = createShaderModule(shader_vector.data(), shader_vector.size() * sizeof(uint32_t));
}
else {
auto shader = file::open(file::internal_domain / (info.compute_src.as_path().string()), true);
auto shader = prism::open_file(prism::internal_domain / (info.compute_src.as_path().string()), true);
shader->read_all();
compute_module = createShaderModule(shader->cast_data<uint32_t>(), shader->size());

34
engine/platform/include/file.hpp
View file

@ -11,24 +11,24 @@
#include "file_utils.hpp"
#include "path.hpp"
namespace file {
enum class Domain {
System,
Internal,
App
namespace prism {
enum class domain {
system,
internal,
app
};
/// Represents a file handle. The file may or may not be fully loaded in memory.
class File {
class file {
public:
File(FILE* handle) : handle(handle) {}
explicit file(FILE* handle) : handle(handle) {}
File(File&& f) noexcept :
file(file&& f) noexcept :
mem(std::move(f.mem)),
handle(std::exchange(f.handle, nullptr)),
data(std::move(f.data)) {}
~File() {
~file() {
if(handle != nullptr)
fclose(handle);
}
@ -57,7 +57,7 @@ namespace file {
/// Loads the entire file into memory, accessible via cast_data()
void read_all() {
fseek(handle, 0L, SEEK_END);
const size_t _size = static_cast<size_t>(ftell(handle));
const auto _size = static_cast<size_t>(ftell(handle));
rewind(handle);
data.resize(_size);
@ -71,7 +71,7 @@ namespace file {
}
/// If the file is loaded in memory, return the size of the file.
size_t size() const {
[[nodiscard]] size_t size() const {
return data.size();
}
@ -110,11 +110,11 @@ namespace file {
@param mode The access mode.
@param path The absolute file path.
*/
void set_domain_path(const Domain domain, const Path path);
Path get_domain_path(const Domain domain);
void set_domain_path(domain domain, Path path);
Path get_domain_path(domain domain);
/// Converts an absolute path to a domain relative path.
Path get_relative_path(const Domain domain, const Path path);
Path get_relative_path(domain domain, Path path);
/// Returns the path to a writeable directory.
Path get_writeable_directory();
@ -126,10 +126,10 @@ namespace file {
@param binary_mode Whether or not to open the file as binary or ASCII. Defaults to false.
@return An optional with a value if the file was loaded correctly, otherwise it's empty.
*/
std::optional<File> open(const Path path, const bool binary_mode = false);
std::optional<file> open_file(Path path, bool binary_mode = false);
Path root_path(const Path path);
Path get_file_path(const Path path);
Path root_path(Path path);
Path get_file_path(const Path& path);
inline Path internal_domain = "/internal", app_domain = "/app";
}

2
engine/renderer/include/imguipass.hpp
View file

@ -24,7 +24,7 @@ private:
void create_font_texture();
void update_buffers(RenderTarget& target, const ImDrawData& draw_data);
std::unique_ptr<file::File> font_file;
std::unique_ptr<prism::file> font_file;
GFXPipeline* pipeline = nullptr;
GFXTexture* font_texture = nullptr;

6
engine/renderer/src/dofpass.cpp
View file

@ -9,7 +9,7 @@
AssetPtr<Texture> aperture_texture;
DoFPass::DoFPass(GFX* gfx, prism::renderer* renderer) : renderer(renderer) {
aperture_texture = assetm->get<Texture>(file::app_domain / "textures/aperture.png");
aperture_texture = assetm->get<Texture>(prism::app_domain / "textures/aperture.png");
GFXRenderPassCreateInfo renderPassInfo = {};
renderPassInfo.label = "Depth of Field";
@ -28,9 +28,9 @@ DoFPass::DoFPass(GFX* gfx, prism::renderer* renderer) : renderer(renderer) {
height_constant.value = extent.height;
GFXGraphicsPipelineCreateInfo create_info = {};
create_info.shaders.vertex_src = ShaderSource(file::Path("dof.vert"));
create_info.shaders.vertex_src = ShaderSource(prism::Path("dof.vert"));
create_info.shaders.vertex_constants = {width_constant, height_constant};
create_info.shaders.fragment_src = ShaderSource(file::Path("dof.frag"));
create_info.shaders.fragment_src = ShaderSource(prism::Path("dof.frag"));
create_info.shader_input.bindings = {
{0, GFXBindingType::StorageImage},

8
engine/renderer/src/imguipass.cpp
View file

@ -23,8 +23,8 @@ void ImGuiPass::create_render_target_resources(RenderTarget& target) {
if(pipeline == nullptr) {
GFXGraphicsPipelineCreateInfo createInfo;
createInfo.label = "ImGui";
createInfo.shaders.vertex_src = ShaderSource(file::Path("imgui.vert"));
createInfo.shaders.fragment_src = ShaderSource(file::Path("imgui.frag"));
createInfo.shaders.vertex_src = ShaderSource(prism::Path("imgui.vert"));
createInfo.shaders.fragment_src = ShaderSource(prism::Path("imgui.frag"));
GFXVertexInput vertexInput = {};
vertexInput.stride = sizeof(ImDrawVert);
@ -153,9 +153,9 @@ void ImGuiPass::load_font(const std::string_view filename) {
ImGuiIO& io = ImGui::GetIO();
if(io.Fonts->Fonts.empty()) {
auto file = file::open(file::app_domain / filename);
auto file = prism::open_file(prism::app_domain / filename);
if(file != std::nullopt) {
font_file = std::make_unique<file::File>(std::move(file.value()));
font_file = std::make_unique<prism::file>(std::move(file.value()));
font_file->read_all();

2
engine/renderer/src/materialcompiler.cpp
View file

@ -11,7 +11,7 @@
#include "renderer.hpp"
ShaderSource get_shader(std::string filename, bool skinned, bool cubemap) {
auto shader_file = file::open(file::internal_domain / filename);
auto shader_file = prism::open_file(prism::internal_domain / filename);
if(!shader_file.has_value()) {
prism::log::error(System::Renderer, "Failed to open shader file {}!", filename);
return {};

42
engine/renderer/src/renderer.cpp
View file

@ -91,7 +91,7 @@ struct SkyPushConstant {
renderer::renderer(GFX* gfx, const bool enable_imgui) : gfx(gfx) {
Expects(gfx != nullptr);
shader_compiler.set_include_path(file::get_domain_path(file::Domain::Internal).string());
shader_compiler.set_include_path(prism::get_domain_path(prism::domain::internal).string());
create_dummy_texture();
create_histogram_resources();
@ -144,8 +144,8 @@ void renderer::resize_render_target(RenderTarget& target, const prism::Extent ex
GFXGraphicsPipelineCreateInfo pipelineInfo = {};
pipelineInfo.label = "Text";
pipelineInfo.shaders.vertex_src = ShaderSource(file::Path("text.vert"));
pipelineInfo.shaders.fragment_src = ShaderSource(file::Path("text.frag"));
pipelineInfo.shaders.vertex_src = ShaderSource(prism::Path("text.vert"));
pipelineInfo.shaders.fragment_src = ShaderSource(prism::Path("text.frag"));
pipelineInfo.rasterization.primitive_type = GFXPrimitiveType::TriangleStrip;
@ -222,7 +222,7 @@ void renderer::update_screen() {
if(current_screen != nullptr) {
for(auto& element : current_screen->elements) {
if(!element.background.image.empty())
element.background.texture = assetm->get<Texture>(file::app_domain / element.background.image);
element.background.texture = assetm->get<Texture>(prism::app_domain / element.background.image);
}
}
}
@ -718,8 +718,8 @@ void renderer::create_mesh_pipeline(Material& material) const {
GFXGraphicsPipelineCreateInfo pipelineInfo = {};
pipelineInfo.label = "Mesh";
pipelineInfo.shaders.vertex_src = ShaderSource(file::Path("mesh.vert"));
pipelineInfo.shaders.fragment_src = ShaderSource(file::Path("mesh.frag"));
pipelineInfo.shaders.vertex_src = ShaderSource(prism::Path("mesh.vert"));
pipelineInfo.shaders.fragment_src = ShaderSource(prism::Path("mesh.frag"));
pipelineInfo.shaders.vertex_constants = {materials_constant, lights_constant, spot_lights_constant, probes_constant};
pipelineInfo.shaders.fragment_constants = {materials_constant, lights_constant, spot_lights_constant, probes_constant};
@ -814,8 +814,8 @@ void renderer::create_render_target_resources(RenderTarget& target) {
GFXGraphicsPipelineCreateInfo pipelineInfo = {};
pipelineInfo.label = "Post";
pipelineInfo.shaders.vertex_src = ShaderSource(file::Path("post.vert"));
pipelineInfo.shaders.fragment_src = ShaderSource(file::Path("post.frag"));
pipelineInfo.shaders.vertex_src = ShaderSource(prism::Path("post.vert"));
pipelineInfo.shaders.fragment_src = ShaderSource(prism::Path("post.frag"));
pipelineInfo.shader_input.bindings = {
{4, GFXBindingType::PushConstant},
@ -841,8 +841,8 @@ void renderer::create_post_pipelines() {
GFXGraphicsPipelineCreateInfo pipelineInfo = {};
pipelineInfo.label = "Post";
pipelineInfo.shaders.vertex_src = ShaderSource(file::Path("post.vert"));
pipelineInfo.shaders.fragment_src = ShaderSource(file::Path("post.frag"));
pipelineInfo.shaders.vertex_src = ShaderSource(prism::Path("post.vert"));
pipelineInfo.shaders.fragment_src = ShaderSource(prism::Path("post.frag"));
pipelineInfo.shader_input.bindings = {
{4, GFXBindingType::PushConstant},
@ -862,7 +862,7 @@ void renderer::create_post_pipelines() {
}
void renderer::create_font_texture() {
auto file = file::open(file::app_domain / "font.fp", true);
auto file = prism::open_file(prism::app_domain / "font.fp", true);
if(file == std::nullopt) {
prism::log::error(System::Renderer, "Failed to load font file!");
return;
@ -920,8 +920,8 @@ void renderer::create_ui_pipelines() {
GFXGraphicsPipelineCreateInfo pipelineInfo = {};
pipelineInfo.label = "UI";
pipelineInfo.shaders.vertex_src = ShaderSource(file::Path("ui.vert"));
pipelineInfo.shaders.fragment_src = ShaderSource(file::Path("ui.frag"));
pipelineInfo.shaders.vertex_src = ShaderSource(prism::Path("ui.vert"));
pipelineInfo.shaders.fragment_src = ShaderSource(prism::Path("ui.frag"));
pipelineInfo.rasterization.primitive_type = GFXPrimitiveType::TriangleStrip;
@ -959,8 +959,8 @@ void renderer::generate_brdf() {
GFXGraphicsPipelineCreateInfo pipelineInfo = {};
pipelineInfo.label = "BRDF";
pipelineInfo.shaders.vertex_src = ShaderSource(file::Path("brdf.vert"));
pipelineInfo.shaders.fragment_src = ShaderSource(file::Path("brdf.frag"));
pipelineInfo.shaders.vertex_src = ShaderSource(prism::Path("brdf.vert"));
pipelineInfo.shaders.fragment_src = ShaderSource(prism::Path("brdf.frag"));
pipelineInfo.render_pass = brdf_render_pass;
@ -1006,7 +1006,7 @@ void renderer::generate_brdf() {
void renderer::create_histogram_resources() {
GFXComputePipelineCreateInfo create_info = {};
create_info.compute_src = ShaderSource(file::Path("histogram.comp"));
create_info.compute_src = ShaderSource(prism::Path("histogram.comp"));
create_info.workgroup_size_x = 16;
create_info.workgroup_size_y = 16;
@ -1022,7 +1022,7 @@ void renderer::create_histogram_resources() {
histogram_pipeline = gfx->create_compute_pipeline(create_info);
create_info.compute_src = ShaderSource(file::Path("histogram-average.comp"));
create_info.compute_src = ShaderSource(prism::Path("histogram-average.comp"));
create_info.workgroup_size_x = 256;
create_info.workgroup_size_y = 1;
@ -1055,15 +1055,15 @@ ShaderSource renderer::register_shader(const std::string_view shader_file) {
}
}
file::Path base_shader_path = get_shader_source_directory();
prism::Path base_shader_path = get_shader_source_directory();
// if shader editor system is not initialized, use prebuilt shaders
if(base_shader_path.empty())
return ShaderSource(file::Path(shader_file));
return ShaderSource(prism::Path(shader_file));
shader_compiler.set_include_path(base_shader_path.string());
file::Path shader_path = file::Path(shader_file);
prism::Path shader_path = prism::Path(shader_file);
ShaderStage stage = ShaderStage::Vertex;
if(shader_path.extension() == ".vert")
@ -1072,7 +1072,7 @@ ShaderSource renderer::register_shader(const std::string_view shader_file) {
stage = ShaderStage::Fragment;
if(found_shader_source.empty()) {
auto file = file::open(base_shader_path / shader_path.replace_extension(shader_path.extension().string() + ".glsl"));
auto file = prism::open_file(base_shader_path / shader_path.replace_extension(shader_path.extension().string() + ".glsl"));
return shader_compiler.compile(ShaderLanguage::GLSL, stage, ShaderSource(file->read_as_string()), gfx->accepted_shader_language()).value();
} else {

14
engine/renderer/src/scenecapture.cpp
View file

@ -68,7 +68,7 @@ const std::array<Matrix4x4, 6> sceneTransforms = {
inline AssetPtr<Mesh> cubeMesh;
SceneCapture::SceneCapture(GFX* gfx) {
cubeMesh = assetm->get<Mesh>(file::app_domain / "models/cube.model");
cubeMesh = assetm->get<Mesh>(prism::app_domain / "models/cube.model");
// render pass
GFXRenderPassCreateInfo renderPassInfo = {};
@ -407,8 +407,8 @@ void SceneCapture::createSkyResources() {
pipelineInfo.label = "Sky Scene Capture";
pipelineInfo.render_pass = renderPass;
pipelineInfo.shaders.vertex_src = ShaderSource(file::Path("sky.vert"));
pipelineInfo.shaders.fragment_src = ShaderSource(file::Path("sky.frag"));
pipelineInfo.shaders.vertex_src = ShaderSource(prism::Path("sky.vert"));
pipelineInfo.shaders.fragment_src = ShaderSource(prism::Path("sky.frag"));
pipelineInfo.shader_input.bindings = {
{1, GFXBindingType::PushConstant}
@ -451,8 +451,8 @@ void SceneCapture::createIrradianceResources() {
GFXGraphicsPipelineCreateInfo pipelineInfo = {};
pipelineInfo.label = "Irradiance Convolution";
pipelineInfo.shaders.vertex_src = ShaderSource(file::Path("irradiance.vert"));
pipelineInfo.shaders.fragment_src = ShaderSource(file::Path("irradiance.frag"));
pipelineInfo.shaders.vertex_src = ShaderSource(prism::Path("irradiance.vert"));
pipelineInfo.shaders.fragment_src = ShaderSource(prism::Path("irradiance.frag"));
GFXVertexInput input;
input.stride = sizeof(Vector3);
@ -503,8 +503,8 @@ void SceneCapture::createPrefilterResources() {
GFXGraphicsPipelineCreateInfo pipelineInfo = {};
pipelineInfo.label = "Prefilter";
pipelineInfo.shaders.vertex_src = ShaderSource(file::Path("filter.vert"));
pipelineInfo.shaders.fragment_src = ShaderSource(file::Path("filter.frag"));
pipelineInfo.shaders.vertex_src = ShaderSource(prism::Path("filter.vert"));
pipelineInfo.shaders.fragment_src = ShaderSource(prism::Path("filter.frag"));
pipelineInfo.shaders.fragment_constants = {size_constant};

4
engine/renderer/src/shadowpass.cpp
View file

@ -320,7 +320,7 @@ void ShadowPass::create_pipelines() {
GFXGraphicsPipelineCreateInfo pipelineInfo = {};
pipelineInfo.shaders.vertex_constants = {point_light_max_constant};
pipelineInfo.shaders.vertex_src = ShaderSource(file::Path("shadow.vert"));
pipelineInfo.shaders.vertex_src = ShaderSource(prism::Path("shadow.vert"));
pipelineInfo.shaders.fragment_constants = { point_light_max_constant };
@ -364,7 +364,7 @@ void ShadowPass::create_pipelines() {
{
pipelineInfo.label = "Point Shadow";
pipelineInfo.shaders.fragment_src = ShaderSource(file::Path("omnishadow.frag"));
pipelineInfo.shaders.fragment_src = ShaderSource(prism::Path("omnishadow.frag"));
auto [static_pipeline, skinned_pipeline] = material_compiler.create_pipeline_permutations(pipelineInfo, true);

8
engine/renderer/src/smaapass.cpp
View file

@ -137,8 +137,8 @@ void SMAAPass::create_pipelines() {
GFXGraphicsPipelineCreateInfo createInfo = {};
createInfo.label = "SMAA Edge";
createInfo.shaders.vertex_src = ShaderSource(file::Path("edge.vert"));
createInfo.shaders.fragment_src = ShaderSource(file::Path("edge.frag"));
createInfo.shaders.vertex_src = ShaderSource(prism::Path("edge.vert"));
createInfo.shaders.fragment_src = ShaderSource(prism::Path("edge.frag"));
createInfo.render_pass = render_pass;
@ -155,8 +155,8 @@ void SMAAPass::create_pipelines() {
edge_pipeline = gfx->create_graphics_pipeline(createInfo);
createInfo.label = "SMAA Blend";
createInfo.shaders.vertex_src = ShaderSource(file::Path("blend.vert"));
createInfo.shaders.fragment_src = ShaderSource(file::Path("blend.frag"));
createInfo.shaders.vertex_src = ShaderSource(prism::Path("blend.vert"));
createInfo.shaders.fragment_src = ShaderSource(prism::Path("blend.frag"));
createInfo.shader_input.bindings.push_back({3, GFXBindingType::Texture});
blend_pipeline = gfx->create_graphics_pipeline(createInfo);

10
engine/shadercompiler/include/shadercompiler.hpp
View file

@ -43,13 +43,13 @@ public:
ShaderSource(const ShaderSource& rhs) : source (rhs.source) {}
explicit ShaderSource(const std::string& source_string) : source(source_string) {}
explicit ShaderSource(const std::vector<uint32_t>& source_bytecode) : source(source_bytecode) {}
explicit ShaderSource(const file::Path& shader_path) : source(shader_path) {}
explicit ShaderSource(const prism::Path& shader_path) : source(shader_path) {}
std::variant<std::monostate, file::Path, std::string, std::vector<uint32_t>> source;
std::variant<std::monostate, prism::Path, std::string, std::vector<uint32_t>> source;
/// Returns a view of the shader source as a path.
[[nodiscard]] file::Path as_path() const {
return std::get<file::Path>(source);
[[nodiscard]] prism::Path as_path() const {
return std::get<prism::Path>(source);
}
/// Returns a view of the shader source as plaintext.
@ -67,7 +67,7 @@ public:
}
[[nodiscard]] bool is_path() const {
return std::holds_alternative<file::Path>(source);
return std::holds_alternative<prism::Path>(source);
}
[[nodiscard]] bool is_string() const {

2
engine/shadercompiler/src/includer.hpp
View file

@ -134,7 +134,7 @@ protected:
// If no path markers, return current working directory.
// Otherwise, strip file name and return path leading up to it.
virtual std::string getDirectory(const std::string) const {
//return file::get_domain_path(file::Domain::Internal).string();
//return file::get_domain_path(file::domain::Internal).string();
return "";
}
};

4
engine/utility/include/file_utils.hpp
View file

@ -3,12 +3,12 @@
#include <string>
#include <filesystem>
namespace file {
namespace prism {
using Path = std::filesystem::path;
}
namespace prism::log {
inline void internal_format(std::string& msg, const file::Path& arg) {
inline void internal_format(std::string& msg, const prism::Path& arg) {
auto pos = msg.find_first_of("{}");
msg.replace(pos, 2, arg.string());
}

2
engine/utility/include/path.hpp
View file

@ -2,6 +2,6 @@
#include <filesystem>
namespace file {
namespace prism {
using Path = std::filesystem::path;
}

4
example/src/example.cpp
View file

@ -6,8 +6,8 @@
#include "scene.hpp"
void app_main(prism::engine* engine) {
file::set_domain_path(file::Domain::App, "data");
file::set_domain_path(file::Domain::Internal, "{resource_dir}/shaders");
prism::set_domain_path(prism::domain::app, "data");
prism::set_domain_path(prism::domain::internal, "{resource_dir}/shaders");
platform::open_window("Example", {-1, -1, 1280, 720}, WindowFlags::Resizable);
}

4
platforms/sdl/file.cpp
View file

@ -2,10 +2,10 @@
#include "string_utils.hpp"
void file::set_domain_path(const file::Domain domain, const file::Path path) {
void prism::set_domain_path(const prism::domain domain, const prism::Path path) {
domain_data[(int)domain] = replace_substring(path.string(), "{resource_dir}/", "");
}
file::Path file::get_writeable_directory() {
prism::Path prism::get_writeable_directory() {
return "~";
}

6
tools/common/include/commoneditor.hpp
View file

@ -188,7 +188,7 @@ public:
}
}
GFXTexture* get_asset_thumbnail(const file::Path path) {
GFXTexture* get_asset_thumbnail(const prism::Path path) {
if(asset_thumbnails.count(path.string())) {
return asset_thumbnails[path.string()];
} else {
@ -272,7 +272,7 @@ public:
current_asset_type = get_asset_type<T>();
open_asset_popup = true;
on_asset_select = [&asset, this](auto p) {
asset = assetm->get<T>(file::app_domain / p);
asset = assetm->get<T>(prism::app_domain / p);
has_asset_edit_changed = true;
};
}
@ -360,7 +360,7 @@ inline void editPath(const char* label, std::string& path, bool editable = true,
if(ImGui::Button("...")) {
platform::open_dialog(false, [&path, &on_selected](std::string p) {
path = file::get_relative_path(file::Domain::App, p).string();
path = prism::get_relative_path(prism::domain::app, p).string();
if(on_selected != nullptr)
on_selected();

40
tools/common/src/commoneditor.cpp
View file

@ -49,15 +49,15 @@ const std::map<ImGuiKey, InputButton> imToPl = {
CommonEditor::CommonEditor(std::string id) : id(id) {
#ifdef PLATFORM_MACOS
file::set_domain_path(file::Domain::App, "../../../data");
file::set_domain_path(file::domain::App, "../../../data");
#else
file::set_domain_path(file::Domain::App, "data");
prism::set_domain_path(prism::domain::app, "data");
#endif
file::set_domain_path(file::Domain::Internal, "{resource_dir}/shaders");
prism::set_domain_path(prism::domain::internal, "{resource_dir}/shaders");
ImGuiIO& io = ImGui::GetIO();
iniFileName = (file::get_writeable_directory() / "imgui.ini").string();
iniFileName = (prism::get_writeable_directory() / "imgui.ini").string();
io.IniFilename = iniFileName.c_str();
@ -260,7 +260,7 @@ void CommonEditor::begin_frame() {
int column = 0;
for(auto& [p, a_type] : asset_files) {
if(current_asset_type == a_type) {
if(ImGui::ImageButton(get_asset_thumbnail(file::app_domain / p), ImVec2(64, 64))) {
if(ImGui::ImageButton(get_asset_thumbnail(prism::app_domain / p), ImVec2(64, 64))) {
on_asset_select(p);
ImGui::CloseCurrentPopup();
}
@ -465,7 +465,7 @@ void editUI(UI& ui) {
ImGui::InputText("Path", &ui.ui_path);
if(ImGui::Button("Reload")) {
ui.screen = engine->load_screen(file::app_domain / ui.ui_path);
ui.screen = engine->load_screen(prism::app_domain / ui.ui_path);
engine->get_renderer()->init_screen(ui.screen);
ui.screen->extent.width = ui.width;
ui.screen->extent.height = ui.height;
@ -723,8 +723,8 @@ void CommonEditor::set_undo_stack(UndoStack *stack) {
current_stack = stack;
}
bool mesh_readable(const file::Path path) {
auto file = file::open(path);
bool mesh_readable(const prism::Path path) {
auto file = prism::open_file(path);
if(!file.has_value()) {
prism::log::error(System::Renderer, "Failed to load mesh from {}!", path);
return false;
@ -736,8 +736,8 @@ bool mesh_readable(const file::Path path) {
return version == 5 || version == 6;
}
bool material_readable(const file::Path path) {
auto file = file::open(path);
bool material_readable(const prism::Path path) {
auto file = prism::open_file(path);
if(!file.has_value()) {
prism::log::error(System::Core, "Failed to load material from {}!", path);
return false;
@ -783,8 +783,8 @@ void CommonEditor::drawAssets() {
for(auto& [p, type] : asset_files) {
ImGui::PushID(&p);
if(ImGui::ImageButton(get_asset_thumbnail(file::app_domain / p), ImVec2(64, 64)))
asset_selected(file::app_domain / p, type);
if(ImGui::ImageButton(get_asset_thumbnail(prism::app_domain / p), ImVec2(64, 64)))
asset_selected(prism::app_domain / p, type);
if(ImGui::BeginPopupContextItem()) {
ImGui::TextDisabled("%s", p.string().c_str());
@ -792,7 +792,7 @@ void CommonEditor::drawAssets() {
ImGui::Separator();
if(ImGui::Button("Regenerate thumbnail")) {
asset_thumbnails.erase(asset_thumbnails.find((file::app_domain / p).string()));
asset_thumbnails.erase(asset_thumbnails.find((prism::app_domain / p).string()));
}
ImGui::EndPopup();
@ -814,8 +814,8 @@ GFXTexture* CommonEditor::get_material_preview(Material& material) {
Scene scene;
auto sphere = scene.add_object();
scene.add<Renderable>(sphere).mesh = assetm->get<Mesh>(file::app_domain / "models" / "sphere.model");
scene.get<Renderable>(sphere).materials.push_back(assetm->get<Material>(file::app_domain / material.path)); // we throw away our material handle here :-(
scene.add<Renderable>(sphere).mesh = assetm->get<Mesh>(prism::app_domain / "models" / "sphere.model");
scene.get<Renderable>(sphere).materials.push_back(assetm->get<Material>(prism::app_domain / material.path)); // we throw away our material handle here :-(
scene.get<Transform>(sphere).rotation = euler_to_quat(Vector3(radians(90.0f), 0, 0));
@ -826,7 +826,7 @@ GFXTexture* CommonEditor::get_mesh_preview(Mesh& mesh) {
Scene scene;
auto mesh_obj = scene.add_object();
scene.add<Renderable>(mesh_obj).mesh = assetm->get<Mesh>(file::app_domain / mesh.path);
scene.add<Renderable>(mesh_obj).mesh = assetm->get<Mesh>(prism::app_domain / mesh.path);
float biggest_component = 0.0f;
for(const auto& part : scene.get<Renderable>(mesh_obj).mesh->parts) {
@ -840,7 +840,7 @@ GFXTexture* CommonEditor::get_mesh_preview(Mesh& mesh) {
find_biggest_component(part.aabb.min);
find_biggest_component(part.aabb.max);
scene.get<Renderable>(mesh_obj).materials.push_back(assetm->get<Material>(file::app_domain / "materials" / "Material.material"));
scene.get<Renderable>(mesh_obj).materials.push_back(assetm->get<Material>(prism::app_domain / "materials" / "Material.material"));
}
return generate_common_preview(scene, Vector3(biggest_component * 2.0f));
@ -1045,7 +1045,7 @@ void CommonEditor::drawConsole() {
}
void CommonEditor::load_options() {
std::ifstream i(file::get_writeable_directory() / (id + "options.json"));
std::ifstream i(prism::get_writeable_directory() / (id + "options.json"));
if (i.is_open()) {
nlohmann::json j;
i >> j;
@ -1077,12 +1077,12 @@ void CommonEditor::save_options() {
j["height"] = height;
j["files"] = lastOpenedFiles;
std::ofstream out(file::get_writeable_directory() / (id + "options.json"));
std::ofstream out(prism::get_writeable_directory() / (id + "options.json"));
out << j;
}
void CommonEditor::load_thumbnail_cache() {
auto thumbnail_cache = file::open("./thumbnail-cache");
auto thumbnail_cache = prism::open_file("./thumbnail-cache");
if(thumbnail_cache != std::nullopt) {
int size;
thumbnail_cache->read(&size);

30
tools/common/src/debugpass.cpp
View file

@ -21,8 +21,8 @@ void DebugPass::initialize() {
{
GFXGraphicsPipelineCreateInfo createInfo;
createInfo.shaders.vertex_src = ShaderSource(file::Path("debug.vert"));
createInfo.shaders.fragment_src = ShaderSource(file::Path("debug.frag"));
createInfo.shaders.vertex_src = ShaderSource(prism::Path("debug.vert"));
createInfo.shaders.fragment_src = ShaderSource(prism::Path("debug.frag"));
GFXVertexInput vertexInput = {};
vertexInput.stride = sizeof(Vector3);
@ -47,14 +47,14 @@ void DebugPass::initialize() {
primitive_pipeline = engine->get_gfx()->create_graphics_pipeline(createInfo);
cubeMesh = assetm->get<Mesh>(file::app_domain / "models/cube.model");
sphereMesh = assetm->get<Mesh>(file::app_domain / "models/sphere.model");
cubeMesh = assetm->get<Mesh>(prism::app_domain / "models/cube.model");
sphereMesh = assetm->get<Mesh>(prism::app_domain / "models/sphere.model");
createInfo.rasterization.polygon_type = GFXPolygonType::Fill;
arrow_pipeline = engine->get_gfx()->create_graphics_pipeline(createInfo);
arrowMesh = assetm->get<Mesh>(file::app_domain / "models/arrow.model");
arrowMesh = assetm->get<Mesh>(prism::app_domain / "models/arrow.model");
}
{
@ -69,8 +69,8 @@ void DebugPass::initialize() {
// pipeline
GFXGraphicsPipelineCreateInfo pipelineInfo = {};
pipelineInfo.shaders.vertex_src = ShaderSource(file::Path("color.vert"));
pipelineInfo.shaders.fragment_src = ShaderSource(file::Path("color.frag"));
pipelineInfo.shaders.vertex_src = ShaderSource(prism::Path("color.vert"));
pipelineInfo.shaders.fragment_src = ShaderSource(prism::Path("color.frag"));
GFXVertexInput input;
input.stride = sizeof(Vector3);
@ -110,8 +110,8 @@ void DebugPass::initialize() {
GFXGraphicsPipelineCreateInfo pipelineInfo = {};
pipelineInfo.label = "Sobel";
pipelineInfo.shaders.vertex_src = ShaderSource(file::Path("color.vert"));
pipelineInfo.shaders.fragment_src = ShaderSource(file::Path("color.frag"));
pipelineInfo.shaders.vertex_src = ShaderSource(prism::Path("color.vert"));
pipelineInfo.shaders.fragment_src = ShaderSource(prism::Path("color.frag"));
GFXVertexInput input;
input.stride = sizeof(Vector3);
@ -142,8 +142,8 @@ void DebugPass::initialize() {
GFXGraphicsPipelineCreateInfo pipelineInfo = {};
pipelineInfo.label = "Billboard";
pipelineInfo.shaders.vertex_src = ShaderSource(file::Path("billboard.vert"));
pipelineInfo.shaders.fragment_src = ShaderSource(file::Path("billboard.frag"));
pipelineInfo.shaders.vertex_src = ShaderSource(prism::Path("billboard.vert"));
pipelineInfo.shaders.fragment_src = ShaderSource(prism::Path("billboard.frag"));
pipelineInfo.shader_input.bindings = {
{1, GFXBindingType::PushConstant},
@ -163,10 +163,10 @@ void DebugPass::initialize() {
billboard_pipeline = engine->get_gfx()->create_graphics_pipeline(pipelineInfo);
pointTexture = assetm->get<Texture>(file::app_domain / "textures/point.png");
spotTexture = assetm->get<Texture>(file::app_domain / "textures/spot.png");
sunTexture = assetm->get<Texture>(file::app_domain / "textures/sun.png");
probeTexture = assetm->get<Texture>(file::app_domain / "textures/probe.png");
pointTexture = assetm->get<Texture>(prism::app_domain / "textures/point.png");
spotTexture = assetm->get<Texture>(prism::app_domain / "textures/spot.png");
sunTexture = assetm->get<Texture>(prism::app_domain / "textures/sun.png");
probeTexture = assetm->get<Texture>(prism::app_domain / "textures/probe.png");
}
}

2
tools/editor/include/prismeditor.hpp
View file

@ -61,7 +61,7 @@ public:
void asset_selected(std::filesystem::path path, AssetType type) override;
private:
void open_asset(const file::Path path);
void open_asset(const prism::Path path);
void setup_editor(Editor* editor);
};

2
tools/editor/src/materialeditor.cpp
View file

@ -137,7 +137,7 @@ void MaterialEditor::draw(CommonEditor* editor) {
save_material(*material, path);
});
} else {
save_material(*material, file::get_file_path(path));
save_material(*material, prism::get_file_path(path));
}
}

10
tools/editor/src/prismeditor.cpp
View file

@ -81,7 +81,7 @@ void prepPrefabScene() {
scene->get<Transform>(plane).position = Vector3(0, -1, 0);
scene->get<Transform>(plane).scale = Vector3(50);
scene->add<Renderable>(plane).mesh = assetm->get<Mesh>(file::app_domain / "models/plane.model");
scene->add<Renderable>(plane).mesh = assetm->get<Mesh>(prism::app_domain / "models/plane.model");
prepThreePointLighting();
}
@ -96,8 +96,8 @@ Renderable* prepMaterialScene() {
scene->get<Transform>(plane).position = Vector3(0, -1, 0);
scene->get<Transform>(plane).scale = Vector3(50);
scene->add<Renderable>(plane).mesh = assetm->get<Mesh>(file::app_domain / "models/plane.model");
scene->get<Renderable>(plane).materials.push_back(assetm->get<Material>(file::app_domain / "materials/Material.material"));
scene->add<Renderable>(plane).mesh = assetm->get<Mesh>(prism::app_domain / "models/plane.model");
scene->get<Renderable>(plane).materials.push_back(assetm->get<Material>(prism::app_domain / "materials/Material.material"));
auto sphere = scene->add_object();
scene->get(sphere).name = "sphere";
@ -105,7 +105,7 @@ Renderable* prepMaterialScene() {
scene->get<Transform>(sphere).rotation = euler_to_quat(Vector3(radians(90.0f), 0, 0));
scene->add<Renderable>(sphere).mesh = assetm->get<Mesh>(file::app_domain / "models/sphere.model");
scene->add<Renderable>(sphere).mesh = assetm->get<Mesh>(prism::app_domain / "models/sphere.model");
prepThreePointLighting();
@ -125,7 +125,7 @@ void PrismEditor::setup_editor(Editor* editor) {
}
void PrismEditor::open_asset(const file::Path path) {
void PrismEditor::open_asset(const prism::Path path) {
if(path.extension() == ".prefab") {
PrefabEditor* editor = new PrefabEditor();
editor->path = path.string();