Move all engine-specific models, materials etc. to a new base directory

This is a huge change, and basically breaks everything (as per usual!)

First of, this includes stuff like shaders so anything involving those
are broken and then fixed. A new BuildAssets cmake file is added to
aid in running AssetCompiler, and it seems to work fine on the engine
base assets.

The File API will eventually be revamped to handle this new way of
organizing the files and domains will eventually be gotten rid of all
together since I probably will replace it with game directory
priorities. As it stands right now, there isn't a way to easily
replace say - render_options.cfg with your own game-specific version.

Apple builds are probably broken by this commit (since I'm moving
around content and shader directories) to be fixed later.

cmake/AddPlatformExecutable.cmake

@@ -45,6 +45,12 @@ function(add_platform_executable)
             ExtraLibrariesPlatform
         )
 
+    # there's no point in including the base assets if it doesn't need data at all,
+    # and this prevents a cyclic dependency with assetpipeline, modelcompiler, etc.
+    if(NOT ${add_platform_executable_SKIP_DATA})
+        add_dependencies(${add_platform_executable_TARGET} EngineBase)
+    endif()
+
     if("${add_platform_executable_APP_NAME}")
         set_target_properties(${add_platform_executable_TARGET} PROPERTIES XCODE_ATTRIBUTE_EXECUTABLE_NAME ${add_platform_executable_APP_NAME})
         set_target_properties(${add_platform_executable_TARGET} PROPERTIES MACOSX_BUNDLE_BUNDLE_NAME ${add_platform_executable_APP_NAME})

cmake/BuildAssets.cmake

@@ -0,0 +1,8 @@
+function(add_content_directory target content_dir game_dir)
+
+    add_custom_target(base_run_${target}_pipeline
+            COMMAND AssetPipeline ${content_dir} ${game_dir})
+
+    add_dependencies(${target} base_run_${target}_pipeline)
+
+endfunction()

cmake/BuildShaders.cmake

@@ -5,7 +5,7 @@ function(add_shader_command)
     cmake_path(REMOVE_EXTENSION ARGS_FILENAME LAST_ONLY OUTPUT_VARIABLE FILENAME_WITHOUT_EXT)
 
     set(SRC_FILENAME ${CMAKE_CURRENT_SOURCE_DIR}/${ARGS_FILENAME})
-    set(OUTPUT_FILENAME ${CMAKE_BINARY_DIR}/bin/${FILENAME_WITHOUT_EXT}.${ARGS_LANG})
+    set(OUTPUT_FILENAME ${CMAKE_BINARY_DIR}/${FILENAME_WITHOUT_EXT}.${ARGS_LANG})
 
     message(${SRC_FILENAME})
     message("new output filename " .. ${OUTPUT_FILENAME})
@@ -61,4 +61,4 @@ function(add_shaders)
 endfunction()
 
 # make the shader directory if it doesnt exist already
-file(MAKE_DIRECTORY ${CMAKE_BINARY_DIR}/bin/shaders)
+file(MAKE_DIRECTORY ${CMAKE_BINARY_DIR}/shaders)

engine/CMakeLists.txt

@@ -9,50 +9,9 @@ add_subdirectory(log)
 add_subdirectory(asset)
 add_subdirectory(shadercompiler)
 add_subdirectory(platform)
+add_subdirectory(base)
 
 if(NOT ENABLE_IOS AND NOT ENABLE_TVOS)
     add_subdirectory(audio)
     add_subdirectory(tests)
-endif()
+endif()
-
-include(../cmake/BuildShaders.cmake)
-
-add_shaders(TARGET Renderer
-        SHADERS
-        shaders/mesh.vert.nocompile.glsl
-        shaders/post.vert.glsl
-        shaders/post.frag.glsl
-        shaders/imgui.vert.glsl
-        shaders/imgui.frag.glsl
-        shaders/debug.vert.glsl
-        shaders/debug.frag.glsl
-        shaders/gaussian.vert.glsl
-        shaders/gaussian.frag.glsl
-        shaders/shadow.vert.nocompile.glsl
-        shaders/shadow.frag.glsl
-        shaders/color.vert.glsl
-        shaders/color.frag.glsl
-        shaders/omnishadow.frag.glsl
-        shaders/edge.vert.glsl
-        shaders/edge.frag.glsl
-        shaders/blend.vert.glsl
-        shaders/blend.frag.glsl
-        shaders/sky.vert.glsl
-        shaders/sky.frag.glsl
-        shaders/billboard.vert.glsl
-        shaders/billboard.frag.glsl
-        shaders/scenecapture.vert.nocompile.glsl
-        shaders/irradiance.vert.glsl
-        shaders/irradiance.frag.glsl
-        shaders/filter.vert.glsl
-        shaders/filter.frag.glsl
-        shaders/brdf.vert.glsl
-        shaders/brdf.frag.glsl
-        shaders/rendering.nocompile.glsl
-        shaders/common.nocompile.glsl
-        shaders/dof.vert.glsl
-        shaders/dof.frag.glsl
-        shaders/histogram.comp.glsl
-        shaders/histogram-average.comp.glsl
-        shaders/expose.frag.glsl
-        shaders/expose.vert.glsl)

engine/asset/src/asset.cpp

@@ -278,7 +278,7 @@ std::unique_ptr<Material> load_material(const prism::path& path) {
         p.type = property["type"];
 
         if(!property["asset_value"].get<std::string>().empty()) {
-            p.value_tex = assetm->get<Texture>(prism::app_domain / property["asset_value"].get<std::string>());
+            p.value_tex = assetm->get<Texture>(prism::game_domain / property["asset_value"].get<std::string>());
         }
 
         return p;

engine/base/CMakeLists.txt

@@ -0,0 +1,62 @@
+include(../../cmake/BuildShaders.cmake)
+include(../../cmake/BuildAssets.cmake)
+
+add_custom_target(EngineBase)
+
+add_shaders(TARGET EngineBase
+        SHADERS
+        shaders/mesh.vert.nocompile.glsl
+        shaders/post.vert.glsl
+        shaders/post.frag.glsl
+        shaders/imgui.vert.glsl
+        shaders/imgui.frag.glsl
+        shaders/debug.vert.glsl
+        shaders/debug.frag.glsl
+        shaders/gaussian.vert.glsl
+        shaders/gaussian.frag.glsl
+        shaders/shadow.vert.nocompile.glsl
+        shaders/shadow.frag.glsl
+        shaders/color.vert.glsl
+        shaders/color.frag.glsl
+        shaders/omnishadow.frag.glsl
+        shaders/edge.vert.glsl
+        shaders/edge.frag.glsl
+        shaders/blend.vert.glsl
+        shaders/blend.frag.glsl
+        shaders/sky.vert.glsl
+        shaders/sky.frag.glsl
+        shaders/billboard.vert.glsl
+        shaders/billboard.frag.glsl
+        shaders/scenecapture.vert.nocompile.glsl
+        shaders/irradiance.vert.glsl
+        shaders/irradiance.frag.glsl
+        shaders/filter.vert.glsl
+        shaders/filter.frag.glsl
+        shaders/brdf.vert.glsl
+        shaders/brdf.frag.glsl
+        shaders/rendering.nocompile.glsl
+        shaders/common.nocompile.glsl
+        shaders/dof.vert.glsl
+        shaders/dof.frag.glsl
+        shaders/histogram.comp.glsl
+        shaders/histogram-average.comp.glsl
+        shaders/expose.frag.glsl
+        shaders/expose.vert.glsl)
+
+add_content_directory(EngineBase
+        ${CMAKE_CURRENT_SOURCE_DIR}/content
+        ${CMAKE_CURRENT_SOURCE_DIR}/game)
+
+file(MAKE_DIRECTORY ${CMAKE_BINARY_DIR}/bin/base)
+
+# copy shaders target
+add_custom_target(base_copy_shaders
+        COMMAND ${CMAKE_COMMAND} -E copy_directory ${CMAKE_BINARY_DIR}/shaders ${CMAKE_BINARY_DIR}/bin/base/shaders)
+
+add_dependencies(EngineBase base_copy_shaders)
+
+# copy game target
+add_custom_target(base_copy_game
+        COMMAND ${CMAKE_COMMAND} -E copy_directory ${CMAKE_CURRENT_SOURCE_DIR}/game ${CMAKE_BINARY_DIR}/bin/base)
+
+add_dependencies(EngineBase base_copy_game)

engine/core/CMakeLists.txt

@@ -46,4 +46,4 @@ target_link_libraries(Core PUBLIC
     BulletDynamics
     BulletCollision
     LinearMath)
-set_engine_properties(Core)
+set_engine_properties(Core)

engine/core/src/engine.cpp

@@ -82,7 +82,7 @@ void engine::set_app(prism::app* p_app) {
         ImGui::GetIO().ConfigFlags |= ImGuiConfigFlags_ViewportsEnable;
     }
 
-    console::load_cfg(prism::app_domain / "render_options.cfg");
+    console::load_cfg(prism::base_domain / "render_options.cfg");
 }
 
 prism::app* engine::get_app() const {
@@ -166,7 +166,7 @@ Scene* engine::load_scene(const prism::path& path) {
 
     for(auto& obj : j["objects"]) {
         if(obj.contains("prefabPath")) {
-            Object o = add_prefab(*scene, prism::app_domain / obj["prefabPath"].get<std::string_view>());
+            Object o = add_prefab(*scene, prism::game_domain / obj["prefabPath"].get<std::string_view>());
 
             scene->get(o).name = obj["name"];
 

engine/core/src/file.cpp

@@ -30,12 +30,12 @@ std::optional<prism::file> prism::open_file(const prism::path& path, const bool
 prism::path prism::get_file_path(const prism::path& path) {
     auto fixed_path = path;
     auto root = root_path(path);
-    if(root == app_domain) {
+    if(root == game_domain) {
-        fixed_path = domain_data[static_cast<int>(domain::app)] / path.lexically_relative(root_path(path));
+        fixed_path = domain_data[static_cast<int>(domain::game)] / path.lexically_relative(root_path(path));
-    } else if(root == internal_domain) {
+    } else if(root == base_domain) {
-        fixed_path = domain_data[static_cast<int>(domain::internal)] / path.lexically_relative(root_path(path));
+        fixed_path = domain_data[static_cast<int>(domain::base)] / path.lexically_relative(root_path(path));
     }
-    
+
     return fixed_path;
 }
 

engine/core/src/scene.cpp

@@ -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>(prism::app_domain / j["path"].get<std::string_view>());
+        t.mesh = assetm->get<Mesh>(prism::game_domain / j["path"].get<std::string_view>());
     
     for(auto& material : j["materials"])
-        t.materials.push_back(assetm->get<Material>(prism::app_domain / material.get<std::string_view>()));
+        t.materials.push_back(assetm->get<Material>(prism::game_domain / material.get<std::string_view>()));
 }
 
 void load_camera_component(nlohmann::json j, Camera& camera) {

engine/gfx/vulkan/src/gfx_vulkan.cpp

@@ -906,7 +906,7 @@ GFXVulkan::create_graphics_pipeline(const GFXGraphicsPipelineCreateInfo& info) {
                                                    sizeof(uint32_t));
         } else {
             auto vertex_shader = prism::open_file(
-                prism::internal_domain /
+                prism::base_domain /
                     (info.shaders.vertex_src.as_path().string() + ".spv"),
                 true);
             vertex_shader->read_all();
@@ -961,7 +961,7 @@ GFXVulkan::create_graphics_pipeline(const GFXGraphicsPipelineCreateInfo& info) {
                                                      sizeof(uint32_t));
         } else {
             auto fragment_shader = prism::open_file(
-                prism::internal_domain /
+                prism::base_domain /
                     (info.shaders.fragment_src.as_path().string() + ".spv"),
                 true);
             fragment_shader->read_all();
@@ -1274,7 +1274,7 @@ GFXVulkan::create_compute_pipeline(const GFXComputePipelineCreateInfo& info) {
             shader_vector.data(), shader_vector.size() * sizeof(uint32_t));
     } else {
         auto shader =
-            prism::open_file(prism::internal_domain /
+            prism::open_file(prism::base_domain /
                                  (info.compute_src.as_path().string() + ".spv"),
                              true);
         shader->read_all();

engine/platform/include/file.hpp

@@ -12,9 +12,8 @@
 
 namespace prism {
     enum class domain {
-        system,
+        game,
-        internal,
+        base
-        app
     };
 
     /// Represents a file handle. The file may or may not be fully loaded in memory.
@@ -133,7 +132,7 @@ namespace prism {
     path root_path(const path& path);
     path get_file_path(const path& path);
     
-    inline path internal_domain = "/internal", app_domain = "/app";
+    inline path base_domain = "/base", game_domain = "/game";
 }
 
 inline std::array<std::string, 3> domain_data;

engine/renderer/src/dofpass.cpp

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

engine/renderer/src/imguipass.cpp

@@ -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(prism::path("imgui.vert"));
+        createInfo.shaders.vertex_src = ShaderSource(prism::path("shaders/imgui.vert"));
-        createInfo.shaders.fragment_src = ShaderSource(prism::path("imgui.frag"));
+        createInfo.shaders.fragment_src = ShaderSource(prism::path("shaders/imgui.frag"));
 
         GFXVertexInput vertexInput = {};
         vertexInput.stride = sizeof(ImDrawVert);
@@ -160,7 +160,7 @@ void ImGuiPass::load_font(const std::string_view filename) {
     ImGuiIO& io = ImGui::GetIO();
 
     if(io.Fonts->Fonts.empty()) {
-        auto file = prism::open_file(prism::app_domain / filename);
+        auto file = prism::open_file(prism::base_domain / filename);
         if(file != std::nullopt) {
             font_file = std::make_unique<prism::file>(std::move(file.value()));
 

engine/renderer/src/materialcompiler.cpp

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

engine/renderer/src/renderer.cpp

@@ -60,7 +60,7 @@ struct SkyPushConstant {
 renderer::renderer(GFX* gfx, const bool enable_imgui) : gfx(gfx) {
     Expects(gfx != nullptr);
     
-    shader_compiler.set_include_path(prism::get_domain_path(prism::domain::internal).string());
+    shader_compiler.set_include_path(prism::get_domain_path(prism::domain::base).string() + "/shaders");
 
     create_dummy_texture();
     create_histogram_resources();
@@ -516,8 +516,8 @@ void renderer::create_mesh_pipeline(Material& material) const {
     
     GFXGraphicsPipelineCreateInfo pipelineInfo = {};
     pipelineInfo.label = "Mesh " + material.path;
-    pipelineInfo.shaders.vertex_src = ShaderSource(prism::path("mesh.vert"));
+    pipelineInfo.shaders.vertex_src = ShaderSource(prism::path("shaders/mesh.vert"));
-    pipelineInfo.shaders.fragment_src = ShaderSource(prism::path("mesh.frag"));
+    pipelineInfo.shaders.fragment_src = ShaderSource(prism::path("shaders/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};
@@ -638,8 +638,8 @@ void renderer::create_post_pipelines() {
     GFXGraphicsPipelineCreateInfo pipelineInfo = {};
     pipelineInfo.label = "Post";
     
-    pipelineInfo.shaders.vertex_src = ShaderSource(prism::path("post.vert"));
+    pipelineInfo.shaders.vertex_src = ShaderSource(prism::path("shaders/post.vert"));
-    pipelineInfo.shaders.fragment_src = ShaderSource(prism::path("post.frag"));
+    pipelineInfo.shaders.fragment_src = ShaderSource(prism::path("shaders/post.frag"));
     
     pipelineInfo.shader_input.bindings = {
         {4, GFXBindingType::PushConstant},
@@ -655,8 +655,8 @@ void renderer::create_post_pipelines() {
     post_pipeline = gfx->create_graphics_pipeline(pipelineInfo);
 
     pipelineInfo.label = "Expose";
-    pipelineInfo.shaders.vertex_src = ShaderSource(prism::path("expose.vert"));
+    pipelineInfo.shaders.vertex_src = ShaderSource(prism::path("shaders/expose.vert"));
-    pipelineInfo.shaders.fragment_src = ShaderSource(prism::path("expose.frag"));
+    pipelineInfo.shaders.fragment_src = ShaderSource(prism::path("shaders/expose.frag"));
     pipelineInfo.render_pass = unorm_render_pass;
 
     pipelineInfo.shader_input.bindings = {
@@ -674,8 +674,8 @@ void renderer::create_sky_pipeline() {
     pipelineInfo.label = "Sky";
     pipelineInfo.render_pass = offscreen_render_pass;
 
-    pipelineInfo.shaders.vertex_src = register_shader("sky.vert");
+    pipelineInfo.shaders.vertex_src = register_shader("shaders/sky.vert");
-    pipelineInfo.shaders.fragment_src = register_shader("sky.frag");
+    pipelineInfo.shaders.fragment_src = register_shader("shaders/sky.frag");
 
     pipelineInfo.shader_input.bindings = {
         {1, GFXBindingType::PushConstant}
@@ -688,14 +688,6 @@ void renderer::create_sky_pipeline() {
     pipelineInfo.depth.depth_mode = GFXDepthMode::LessOrEqual;
 
     sky_pipeline = gfx->create_graphics_pipeline(pipelineInfo);
-    
-    associate_shader_reload("sky.vert", [this] {
-        create_sky_pipeline();
-    });
-    
-    associate_shader_reload("sky.frag", [this] {
-        create_sky_pipeline();
-    });
 }
 
 void renderer::generate_brdf() {
@@ -709,8 +701,8 @@ void renderer::generate_brdf() {
     GFXGraphicsPipelineCreateInfo pipelineInfo = {};
     pipelineInfo.label = "BRDF";
     
-    pipelineInfo.shaders.vertex_src = ShaderSource(prism::path("brdf.vert"));
+    pipelineInfo.shaders.vertex_src = ShaderSource(prism::path("shaders/brdf.vert"));
-    pipelineInfo.shaders.fragment_src = ShaderSource(prism::path("brdf.frag"));
+    pipelineInfo.shaders.fragment_src = ShaderSource(prism::path("shaders/brdf.frag"));
     
     pipelineInfo.render_pass = brdf_render_pass;
 
@@ -757,7 +749,7 @@ void renderer::generate_brdf() {
 void renderer::create_histogram_resources() {
     GFXComputePipelineCreateInfo create_info = {};
     create_info.label = "Histogram";
-    create_info.compute_src = ShaderSource(prism::path("histogram.comp"));
+    create_info.compute_src = ShaderSource(prism::path("shaders/histogram.comp"));
     create_info.workgroup_size_x = 16;
     create_info.workgroup_size_y = 16;
     
@@ -774,7 +766,7 @@ void renderer::create_histogram_resources() {
     histogram_pipeline = gfx->create_compute_pipeline(create_info);
 
     create_info.label = "Histogram Average";
-    create_info.compute_src = ShaderSource(prism::path("histogram-average.comp"));
+    create_info.compute_src = ShaderSource(prism::path("shaders/histogram-average.comp"));
     create_info.workgroup_size_x = 256;
     create_info.workgroup_size_y = 1;
     

engine/renderer/src/scenecapture.cpp

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

engine/renderer/src/shadowpass.cpp

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

engine/renderer/src/smaapass.cpp

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

example/src/example.cpp

@@ -8,9 +8,6 @@
 #include "path.hpp"
 
 void app_main(prism::engine*) {
-    prism::set_domain_path(prism::domain::app, "{resource_dir}/game");
-    prism::set_domain_path(prism::domain::internal, "{resource_dir}/shaders");
-
     platform::open_window("Example", {-1, -1, 1280, 720}, WindowFlags::Resizable);
 }
 
@@ -48,16 +45,16 @@ void ExampleApp::initialize_render() {
 
     main_object = scene->add_object();
     auto& sphere_render = scene->add<Renderable>(main_object);
-    sphere_render.mesh = assetm->get<Mesh>(prism::path(prism::app_domain / "models/bunny.model"));
+    sphere_render.mesh = assetm->get<Mesh>(prism::path(prism::game_domain / "models/bunny.model"));
-    sphere_render.materials = { assetm->get<Material>(prism::path(prism::app_domain / "materials/Material.material")) };
+    sphere_render.materials = { assetm->get<Material>(prism::path(prism::game_domain / "materials/Material.material")) };
 
     auto sibenik_obj = scene->add_object();
     auto& sibenik_render = scene->add<Renderable>(sibenik_obj);
-    sibenik_render.mesh = assetm->get<Mesh>(prism::path(prism::app_domain / "models/sibenik.model"));
+    sibenik_render.mesh = assetm->get<Mesh>(prism::path(prism::game_domain / "models/sibenik.model"));
     scene->get<Transform>(sibenik_obj).position.y = 13.5;
 
     for(auto& part : sibenik_render.mesh->parts) {
-        sibenik_render.materials.push_back(assetm->get<Material>(prism::path(prism::app_domain / "materials" / (part.material_hint + ".material"))));
+        sibenik_render.materials.push_back(assetm->get<Material>(prism::path(prism::game_domain / "materials" / (part.material_hint + ".material"))));
     }
 
     auto probe_obj = scene->add_object();

platforms/sdl/CMakeLists.txt

@@ -44,19 +44,6 @@ add_platform(
 )
 
 function(add_platform_commands target data_directory skip_data)
-    if(ENABLE_MACOS)
-        set(DUMMY_NAME ${target}-CopyShaders)
-
-        add_custom_target(${DUMMY_NAME} ALL DEPENDS ${CMAKE_BINARY_DIR}/${target}-dummy)
-
-        add_custom_command(OUTPUT ${CMAKE_BINARY_DIR}/${target}-dummy
-                COMMAND ${CMAKE_COMMAND} -E make_directory $<TARGET_FILE_DIR:${target}>/../Resources/shaders
-                COMMAND ${CMAKE_COMMAND} -E copy_directory ${CMAKE_BINARY_DIR}/bin/shaders $<TARGET_FILE_DIR:${target}>/../Resources/shaders
-                )
-
-        add_dependencies(${target} ${DUMMY_NAME})
-    endif()
-
     if(NOT skip_data)
         if(ENABLE_MACOS)
             add_custom_target(${target}_copy_assets

platforms/sdl/main.cpp.in

@@ -471,6 +471,9 @@ int main(int argc, char* argv[]) {
         return -1;
     }
 
+    prism::set_domain_path(prism::domain::game, "{resource_dir}/game");
+    prism::set_domain_path(prism::domain::base, "{resource_dir}/base");
+
     app = new @APP_CLASS@();
     engine->set_app(app);
 

tools/common/include/commoneditor.hpp

@@ -277,7 +277,7 @@ public:
             current_asset_type = get_asset_type<T>();
             open_asset_popup = true;
             on_asset_select = [&asset, this](auto p) {
-                asset = assetm->get<T>(prism::app_domain / p);
+                asset = assetm->get<T>(prism::game_domain / p);
                 has_asset_edit_changed = true;
             };
         }
@@ -368,7 +368,7 @@ inline void editPath(const char* label, std::string& path, bool editable = true,
 
     if(ImGui::Button("...")) {
         engine->get_imgui().open_dialog(false, [&path, &on_selected](std::string p) {
-            path = prism::get_relative_path(prism::domain::app, p).string();
+            path = prism::get_relative_path(prism::domain::game, p).string();
 
             if(on_selected != nullptr)
                 on_selected();

tools/common/src/commoneditor.cpp

@@ -43,9 +43,6 @@ const std::map<ImGuiKey, InputButton> imToPl = {
 };
 
 CommonEditor::CommonEditor(const std::string_view id) : id(id) {
-    prism::set_domain_path(prism::domain::app, "{resource_dir}/game");
-    prism::set_domain_path(prism::domain::internal, "{resource_dir}/shaders");
-    
     ImGuiIO& io = ImGui::GetIO();
     
     iniFileName = (prism::get_writeable_directory() / "imgui.ini").string();
@@ -254,7 +251,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(prism::app_domain / p), ImVec2(64, 64))) {
+                if(ImGui::ImageButton(get_asset_thumbnail(prism::game_domain / p), ImVec2(64, 64))) {
                     on_asset_select(p);
                     ImGui::CloseCurrentPopup();
                 }
@@ -767,8 +764,8 @@ void CommonEditor::drawAssets() {
     for(auto& [p, type] : asset_files) {
         ImGui::PushID(&p);
         
-        if(ImGui::ImageButton(get_asset_thumbnail(prism::app_domain / p), ImVec2(64, 64)))
+        if(ImGui::ImageButton(get_asset_thumbnail(prism::game_domain / p), ImVec2(64, 64)))
-            asset_selected(prism::app_domain / p, type);
+            asset_selected(prism::game_domain / p, type);
 
         if(ImGui::BeginPopupContextItem()) {
             ImGui::TextDisabled("%s", p.string().c_str());
@@ -776,7 +773,7 @@ void CommonEditor::drawAssets() {
             ImGui::Separator();
 
             if(ImGui::Button("Regenerate thumbnail")) {
-                asset_thumbnails.erase(asset_thumbnails.find((prism::app_domain / p).string()));
+                asset_thumbnails.erase(asset_thumbnails.find((prism::game_domain / p).string()));
             }
 
             ImGui::EndPopup();
@@ -798,8 +795,8 @@ GFXTexture* CommonEditor::get_material_preview(Material& material) {
     Scene scene;
     
     auto sphere = scene.add_object();
-    scene.add<Renderable>(sphere).mesh = assetm->get<Mesh>(prism::app_domain / "models" / "sphere.model");
+    scene.add<Renderable>(sphere).mesh = assetm->get<Mesh>(prism::base_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<Renderable>(sphere).materials.push_back(assetm->get<Material>(prism::game_domain / material.path)); // we throw away our material handle here :-(
     
     scene.get<Transform>(sphere).rotation = euler_to_quat(prism::float3(radians(90.0f), 0, 0));
 
@@ -810,7 +807,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>(prism::app_domain / mesh.path);
+    scene.add<Renderable>(mesh_obj).mesh = assetm->get<Mesh>(prism::game_domain / mesh.path);
     
     float biggest_component = 0.0f;
     for(const auto& part : scene.get<Renderable>(mesh_obj).mesh->parts) {
@@ -824,7 +821,7 @@ GFXTexture* CommonEditor::get_mesh_preview(Mesh& mesh) {
         find_biggest_component(part.bounding_box.min);
         find_biggest_component(part.bounding_box.max);
         
-        scene.get<Renderable>(mesh_obj).materials.push_back(assetm->get<Material>(prism::app_domain / "materials" / "Material.material"));
+        scene.get<Renderable>(mesh_obj).materials.push_back(assetm->get<Material>(prism::game_domain / "materials" / "Material.material"));
     }
     
     return generate_common_preview(scene, prism::float3(biggest_component * 2.0f));

tools/common/src/debugpass.cpp

@@ -45,14 +45,14 @@ void DebugPass::initialize() {
 
         primitive_pipeline = engine->get_gfx()->create_graphics_pipeline(createInfo);
 
-        cubeMesh = assetm->get<Mesh>(prism::app_domain / "models/cube.model");
+        cubeMesh = assetm->get<Mesh>(prism::base_domain / "models/cube.model");
-        sphereMesh = assetm->get<Mesh>(prism::app_domain / "models/sphere.model");
+        sphereMesh = assetm->get<Mesh>(prism::base_domain / "models/sphere.model");
 
         createInfo.rasterization.polygon_type = GFXPolygonType::Fill;
 
         arrow_pipeline = engine->get_gfx()->create_graphics_pipeline(createInfo);
         
-        arrowMesh = assetm->get<Mesh>(prism::app_domain / "models/arrow.model");
+        arrowMesh = assetm->get<Mesh>(prism::base_domain / "models/arrow.model");
     }
 
     {
@@ -161,10 +161,10 @@ void DebugPass::initialize() {
         
         billboard_pipeline = engine->get_gfx()->create_graphics_pipeline(pipelineInfo);
         
-        pointTexture = assetm->get<Texture>(prism::app_domain / "textures/point.png");
+        pointTexture = assetm->get<Texture>(prism::base_domain / "textures/point.png");
-        spotTexture = assetm->get<Texture>(prism::app_domain / "textures/spot.png");
+        spotTexture = assetm->get<Texture>(prism::base_domain / "textures/spot.png");
-        sunTexture = assetm->get<Texture>(prism::app_domain / "textures/sun.png");
+        sunTexture = assetm->get<Texture>(prism::base_domain / "textures/sun.png");
-        probeTexture = assetm->get<Texture>(prism::app_domain / "textures/probe.png");
+        probeTexture = assetm->get<Texture>(prism::base_domain / "textures/probe.png");
     }
 }