redstrate/prism
Archived
1
Fork 0
Code Activity

Rename Renderer to renderer, move it to prism namespace, and rename last of member variables

Browse source
This commit is contained in:
redstrate 2021-04-20 13:53:38 -04:00
parent ff8e52ed90
commit 7b23fdfa09
12 changed files with 211 additions and 186 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

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

@ -16,7 +16,6 @@ namespace ui {
} }
class Scene; class Scene;
class Renderer;
class RenderTarget; class RenderTarget;
class Physics; class Physics;
struct Timer; struct Timer;
@ -25,6 +24,7 @@ namespace prism {
class app; class app;
class imgui_backend; class imgui_backend;
class input_system; class input_system;
class renderer;
struct AnimationTarget { struct AnimationTarget {
float current_time = 0.0f; float current_time = 0.0f;
@ -120,7 +120,7 @@ namespace prism {
@param index Index of the window. Default is 0. @param index Index of the window. Default is 0.
@return Instance of the renderer. Will not be null. @return Instance of the renderer. Will not be null.
*/ */
Renderer* get_renderer(); renderer* get_renderer();
/** Get the physics system. /** Get the physics system.
@return Instance of the physics system. Will not be null. @return Instance of the physics system. Will not be null.
@ -373,7 +373,7 @@ namespace prism {
std::unique_ptr<input_system> input; std::unique_ptr<input_system> input;
std::unique_ptr<Physics> physics; std::unique_ptr<Physics> physics;
std::unique_ptr<Renderer> renderer; std::unique_ptr<renderer> renderer;
std::vector<Timer*> timers, timers_to_remove; std::vector<Timer*> timers, timers_to_remove;

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

@ -114,7 +114,7 @@ prism::input_system* engine::get_input() {
return input.get(); return input.get();
} }
Renderer* engine::get_renderer() { prism::renderer* engine::get_renderer() {
return renderer.get(); return renderer.get();
} }
@ -414,7 +414,7 @@ void engine::add_window(void* native_handle, const int identifier, const prism::
Expects(identifier >= 0); Expects(identifier >= 0);
if(identifier == 0) { if(identifier == 0) {
renderer = std::make_unique<Renderer>(gfx); renderer = std::make_unique<prism::renderer>(gfx);
} }
const auto drawable_extent = platform::get_window_drawable_size(identifier); const auto drawable_extent = platform::get_window_drawable_size(identifier);

9
engine/renderer/include/dofpass.hpp
View file

@ -7,11 +7,14 @@ class GFXPipeline;
class GFXRenderPass; class GFXRenderPass;
class GFXTexture; class GFXTexture;
class Scene; class Scene;
class Renderer;
namespace prism {
class renderer;
}
class DoFPass { class DoFPass {
public: public:
DoFPass(GFX* gfx, Renderer* renderer); DoFPass(GFX* gfx, prism::renderer* renderer);
void render(GFXCommandBuffer* command_buffer, Scene& scene); void render(GFXCommandBuffer* command_buffer, Scene& scene);
@ -24,7 +27,7 @@ public:
GFXRenderPass* renderpass = nullptr; GFXRenderPass* renderpass = nullptr;
private: private:
Renderer* renderer = nullptr; prism::renderer* renderer = nullptr;
GFXPipeline* pipeline = nullptr; GFXPipeline* pipeline = nullptr;
}; };

236
engine/renderer/include/renderer.hpp
View file

@ -35,127 +35,145 @@ struct Camera;
constexpr int max_scene_materials = 25, max_scene_lights = 25; constexpr int max_scene_materials = 25, max_scene_lights = 25;
struct RenderScreenOptions { struct render_screen_options {
bool render_world = false; bool render_world = false;
Matrix4x4 mvp; Matrix4x4 mvp;
}; };
class Material; class Material;
class Renderer { namespace prism {
public: class renderer {
explicit Renderer(GFX* gfx, bool enable_imgui = true); public:
~Renderer(); explicit renderer(GFX* gfx, bool enable_imgui = true);
RenderTarget* allocate_render_target(prism::Extent extent); ~renderer();
void resize_render_target(RenderTarget& target, prism::Extent extent);
void recreate_all_render_targets();
void set_screen(ui::Screen* screen);
void init_screen(ui::Screen* screen);
void update_screen();
struct ControllerContinuity { RenderTarget* allocate_render_target(prism::Extent extent);
int elementOffset = 0;
};
void render(GFXCommandBuffer* command_buffer, Scene* scene, RenderTarget& target, int index); void resize_render_target(RenderTarget& target, prism::Extent extent);
void render_screen(GFXCommandBuffer* commandBuffer, ui::Screen* screen, prism::Extent extent, ControllerContinuity& continuity, RenderScreenOptions options = RenderScreenOptions()); void recreate_all_render_targets();
void render_camera(GFXCommandBuffer* command_buffer, Scene& scene, Object camera_object, Camera& camera, prism::Extent extent, RenderTarget& target, ControllerContinuity& continuity);
void create_mesh_pipeline(Material& material) const;
// passes
template<class T, typename... Args>
T* addPass(Args&&... args) {
auto t = std::make_unique<T>(args...);
t->initialize();
return static_cast<T*>(passes.emplace_back(std::move(t)).get());
}
GFXTexture* get_requested_texture(PassTextureType type) { void set_screen(ui::Screen* screen);
for(auto& pass : passes) {
auto texture = pass->get_requested_texture(type); void init_screen(ui::Screen* screen);
if(texture != nullptr)
return texture; void update_screen();
struct controller_continuity {
int elementOffset = 0;
};
void render(GFXCommandBuffer* command_buffer, Scene* scene, RenderTarget& target, int index);
void render_screen(GFXCommandBuffer* commandBuffer, ui::Screen* screen, prism::Extent extent,
controller_continuity& continuity, render_screen_options options = render_screen_options());
void render_camera(GFXCommandBuffer* command_buffer, Scene& scene, Object camera_object, Camera& camera,
prism::Extent extent, RenderTarget& target, controller_continuity &continuity);
void create_mesh_pipeline(Material& material) const;
// passes
template<class T, typename... Args>
T* addPass(Args &&... args) {
auto t = std::make_unique<T>(args...);
t->initialize();
return static_cast<T*>(passes.emplace_back(std::move(t)).get());
} }
return nullptr; GFXTexture* get_requested_texture(PassTextureType type) {
} for (auto& pass : passes) {
auto texture = pass->get_requested_texture(type);
GFXRenderPass* offscreenRenderPass = nullptr; if (texture != nullptr)
return texture;
std::unique_ptr<ShadowPass> shadow_pass; }
std::unique_ptr<SceneCapture> scene_capture;
GFXTexture* dummyTexture = nullptr; return nullptr;
GFXRenderPass* unormRenderPass = nullptr; }
GFXPipeline* renderToUnormTexturePipeline = nullptr;
GFXRenderPass* viewportRenderPass = nullptr; GFXRenderPass* offscreen_render_pass = nullptr;
ShaderSource register_shader(std::string_view shader_file); std::unique_ptr<ShadowPass> shadow_pass;
void associate_shader_reload(std::string_view shader_file, const std::function<void()>& reload_function); std::unique_ptr<SceneCapture> scene_capture;
void reload_shader(std::string_view shader_file, std::string_view shader_source);
GFXTexture* dummy_texture = nullptr;
struct RegisteredShader { GFXRenderPass* unorm_render_pass = nullptr;
std::string filename; GFXPipeline* render_to_unorm_texture_pipeline = nullptr;
std::string injected_shader_source;
std::function<void()> reload_function; ShaderSource register_shader(std::string_view shader_file);
void associate_shader_reload(std::string_view shader_file, const std::function<void()> &reload_function);
void reload_shader(std::string_view shader_file, std::string_view shader_source);
struct RegisteredShader {
std::string filename;
std::string injected_shader_source;
std::function<void()> reload_function;
};
std::vector<RegisteredShader> registered_shaders;
bool reloading_shader = false;
[[nodiscard]] std::vector<RenderTarget*> get_all_render_targets() const {
return render_targets;
}
private:
void create_dummy_texture();
void create_render_target_resources(RenderTarget& target);
void create_post_pipelines();
void create_font_texture();
void create_sky_pipeline();
void create_ui_pipelines();
void generate_brdf();
void create_histogram_resources();
GFX* gfx = nullptr;
std::vector<RenderTarget*> render_targets;
ui::Screen* current_screen = nullptr;
// sky
GFXPipeline* sky_pipeline = nullptr;
// post
GFXPipeline* post_pipeline = nullptr;
// font
GFXTexture* font_texture = nullptr;
GFXPipeline* text_pipeline, *world_text_pipeline = nullptr;
int instance_alignment = 0;
// brdf
GFXPipeline* brdf_pipeline = nullptr;
GFXTexture* brdf_texture = nullptr;
GFXFramebuffer* brdf_framebuffer = nullptr;
GFXRenderPass* brdf_render_pass = nullptr;
// general ui
GFXPipeline* general_pipeline, *world_general_pipeline = nullptr;
// histogram compute
GFXPipeline* histogram_pipeline = nullptr, *histogram_average_pipeline = nullptr;
GFXBuffer* histogram_buffer = nullptr;
GFXTexture* average_luminance_texture = nullptr;
std::unique_ptr<SMAAPass> smaa_pass;
std::unique_ptr<DoFPass> dof_pass;
std::vector<std::unique_ptr<Pass>> passes;
}; };
}
std::vector<RegisteredShader> registered_shaders;
bool reloading_shader = false;
[[nodiscard]] std::vector<RenderTarget*> get_all_render_targets() const {
return render_targets;
}
private:
void create_dummy_texture();
void create_render_target_resources(RenderTarget& target);
void create_post_pipelines();
void create_font_texture();
void create_sky_pipeline();
void create_ui_pipelines();
void generate_brdf();
void create_histogram_resources();
GFX* gfx = nullptr;
std::vector<RenderTarget*> render_targets;
ui::Screen* current_screen = nullptr;
// sky
GFXPipeline* sky_pipeline = nullptr;
// post
GFXPipeline* post_pipeline = nullptr;
// font
GFXTexture* font_texture = nullptr;
GFXPipeline* text_pipeline, *world_text_pipeline = nullptr;
int instance_alignment = 0;
// brdf
GFXPipeline* brdf_pipeline = nullptr;
GFXTexture* brdf_texture = nullptr;
GFXFramebuffer* brdf_framebuffer = nullptr;
GFXRenderPass* brdf_render_pass = nullptr;
// general ui
GFXPipeline* general_pipeline, *world_general_pipeline = nullptr;
// histogram compute
GFXPipeline* histogram_pipeline = nullptr, *histogram_average_pipeline = nullptr;
GFXBuffer* histogram_buffer = nullptr;
GFXTexture* average_luminance_texture = nullptr;
std::unique_ptr<SMAAPass> smaa_pass;
std::unique_ptr<DoFPass> dof_pass;
std::vector<std::unique_ptr<Pass>> passes;
};

11
engine/renderer/include/smaapass.hpp
View file

@ -9,12 +9,15 @@ class GFXFramebuffer;
class GFXPipeline; class GFXPipeline;
class GFXRenderPass; class GFXRenderPass;
class GFXTexture; class GFXTexture;
class Renderer;
class RenderTarget; class RenderTarget;
namespace prism {
class renderer;
}
class SMAAPass { class SMAAPass {
public: public:
SMAAPass(GFX* gfx, Renderer* renderer); SMAAPass(GFX* gfx, prism::renderer* renderer);
void create_render_target_resources(RenderTarget& target); void create_render_target_resources(RenderTarget& target);
@ -24,8 +27,8 @@ private:
void create_textures(); void create_textures();
void create_render_pass(); void create_render_pass();
void create_pipelines(); void create_pipelines();
Renderer* renderer = nullptr; prism::renderer* renderer = nullptr;
GFXTexture* area_image = nullptr; GFXTexture* area_image = nullptr;
GFXTexture* search_image = nullptr; GFXTexture* search_image = nullptr;

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

@ -8,7 +8,7 @@
AssetPtr<Texture> aperture_texture; AssetPtr<Texture> aperture_texture;
DoFPass::DoFPass(GFX* gfx, Renderer* renderer) : renderer(renderer) { 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>(file::app_domain / "textures/aperture.png");
GFXRenderPassCreateInfo renderPassInfo = {}; GFXRenderPassCreateInfo renderPassInfo = {};

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

@ -9,7 +9,6 @@
#include "scene.hpp" #include "scene.hpp"
#include "font.hpp" #include "font.hpp"
#include "vector.hpp" #include "vector.hpp"
#include "engine.hpp"
#include "imguipass.hpp" #include "imguipass.hpp"
#include "gfx.hpp" #include "gfx.hpp"
#include "log.hpp" #include "log.hpp"
@ -25,6 +24,8 @@
#include "asset.hpp" #include "asset.hpp"
#include "debug.hpp" #include "debug.hpp"
using prism::renderer;
struct ElementInstance { struct ElementInstance {
Vector4 color; Vector4 color;
uint32_t position = 0, size = 0; uint32_t position = 0, size = 0;
@ -87,7 +88,7 @@ struct SkyPushConstant {
float aspect; float aspect;
}; };
Renderer::Renderer(GFX* gfx, const bool enable_imgui) : gfx(gfx) { renderer::renderer(GFX* gfx, const bool enable_imgui) : gfx(gfx) {
Expects(gfx != nullptr); Expects(gfx != nullptr);
shader_compiler.set_include_path(file::get_domain_path(file::Domain::Internal).string()); shader_compiler.set_include_path(file::get_domain_path(file::Domain::Internal).string());
@ -109,21 +110,21 @@ Renderer::Renderer(GFX* gfx, const bool enable_imgui) : gfx(gfx) {
renderPassInfo.attachments.push_back(GFXPixelFormat::RGBA_32F); renderPassInfo.attachments.push_back(GFXPixelFormat::RGBA_32F);
renderPassInfo.attachments.push_back(GFXPixelFormat::DEPTH_32F); renderPassInfo.attachments.push_back(GFXPixelFormat::DEPTH_32F);
renderPassInfo.will_use_in_shader = true; renderPassInfo.will_use_in_shader = true;
offscreenRenderPass = gfx->create_render_pass(renderPassInfo); offscreen_render_pass = gfx->create_render_pass(renderPassInfo);
renderPassInfo.label = "Offscreen (UNORM)"; renderPassInfo.label = "Offscreen (UNORM)";
renderPassInfo.attachments = {GFXPixelFormat::R8G8B8A8_UNORM}; renderPassInfo.attachments = {GFXPixelFormat::R8G8B8A8_UNORM};
unormRenderPass = gfx->create_render_pass(renderPassInfo); unorm_render_pass = gfx->create_render_pass(renderPassInfo);
create_font_texture(); create_font_texture();
create_sky_pipeline(); create_sky_pipeline();
} }
Renderer::~Renderer() = default; renderer::~renderer() = default;
RenderTarget* Renderer::allocate_render_target(const prism::Extent extent) { RenderTarget* renderer::allocate_render_target(const prism::Extent extent) {
auto target = new RenderTarget(); auto target = new RenderTarget();
resize_render_target(*target, extent); resize_render_target(*target, extent);
@ -133,7 +134,7 @@ RenderTarget* Renderer::allocate_render_target(const prism::Extent extent) {
return target; return target;
} }
void Renderer::resize_render_target(RenderTarget& target, const prism::Extent extent) { void renderer::resize_render_target(RenderTarget& target, const prism::Extent extent) {
target.extent = extent; target.extent = extent;
create_render_target_resources(target); create_render_target_resources(target);
@ -167,7 +168,7 @@ void Renderer::resize_render_target(RenderTarget& target, const prism::Extent ex
text_pipeline = gfx->create_graphics_pipeline(pipelineInfo); text_pipeline = gfx->create_graphics_pipeline(pipelineInfo);
if(world_text_pipeline == nullptr) { if(world_text_pipeline == nullptr) {
pipelineInfo.render_pass = offscreenRenderPass; pipelineInfo.render_pass = offscreen_render_pass;
pipelineInfo.label = "Text World"; pipelineInfo.label = "Text World";
pipelineInfo.depth.depth_mode = GFXDepthMode::LessOrEqual; pipelineInfo.depth.depth_mode = GFXDepthMode::LessOrEqual;
@ -180,11 +181,11 @@ void Renderer::resize_render_target(RenderTarget& target, const prism::Extent ex
pass->create_render_target_resources(target); pass->create_render_target_resources(target);
} }
void Renderer::recreate_all_render_targets() { void renderer::recreate_all_render_targets() {
} }
void Renderer::set_screen(ui::Screen* screen) { void renderer::set_screen(ui::Screen* screen) {
Expects(screen != nullptr); Expects(screen != nullptr);
current_screen = screen; current_screen = screen;
@ -194,7 +195,7 @@ void Renderer::set_screen(ui::Screen* screen) {
update_screen(); update_screen();
} }
void Renderer::init_screen(ui::Screen* screen) { void renderer::init_screen(ui::Screen* screen) {
Expects(screen != nullptr); Expects(screen != nullptr);
std::array<GylphMetric, numGlyphs> metrics = {}; std::array<GylphMetric, numGlyphs> metrics = {};
@ -217,7 +218,7 @@ void Renderer::init_screen(ui::Screen* screen) {
screen->instance_buffer = gfx->create_buffer(nullptr, sizeof(StringInstance) * 50, true, GFXBufferUsage::Storage); screen->instance_buffer = gfx->create_buffer(nullptr, sizeof(StringInstance) * 50, true, GFXBufferUsage::Storage);
} }
void Renderer::update_screen() { void renderer::update_screen() {
if(current_screen != nullptr) { if(current_screen != nullptr) {
for(auto& element : current_screen->elements) { for(auto& element : current_screen->elements) {
if(!element.background.image.empty()) if(!element.background.image.empty())
@ -226,7 +227,7 @@ void Renderer::update_screen() {
} }
} }
void Renderer::render(GFXCommandBuffer* commandbuffer, Scene* scene, RenderTarget& target, int index) { void renderer::render(GFXCommandBuffer* commandbuffer, Scene* scene, RenderTarget& target, int index) {
const auto extent = target.extent; const auto extent = target.extent;
const auto render_extent = target.get_render_extent(); const auto render_extent = target.get_render_extent();
@ -252,10 +253,10 @@ void Renderer::render(GFXCommandBuffer* commandbuffer, Scene* scene, RenderTarge
GFXRenderPassBeginInfo beginInfo = {}; GFXRenderPassBeginInfo beginInfo = {};
beginInfo.framebuffer = target.offscreenFramebuffer; beginInfo.framebuffer = target.offscreenFramebuffer;
beginInfo.render_pass = offscreenRenderPass; beginInfo.render_pass = offscreen_render_pass;
beginInfo.render_area.extent = render_extent; beginInfo.render_area.extent = render_extent;
ControllerContinuity continuity; controller_continuity continuity;
if(scene != nullptr) { if(scene != nullptr) {
commandbuffer->push_group("Shadow Rendering"); commandbuffer->push_group("Shadow Rendering");
@ -368,14 +369,14 @@ void Renderer::render(GFXCommandBuffer* commandbuffer, Scene* scene, RenderTarge
if(auto texture = get_requested_texture(PassTextureType::SelectionSobel)) if(auto texture = get_requested_texture(PassTextureType::SelectionSobel))
commandbuffer->bind_texture(texture, 5); commandbuffer->bind_texture(texture, 5);
else else
commandbuffer->bind_texture(dummyTexture, 5); commandbuffer->bind_texture(dummy_texture, 5);
commandbuffer->bind_texture(average_luminance_texture, 6); commandbuffer->bind_texture(average_luminance_texture, 6);
if(render_options.enable_depth_of_field) if(render_options.enable_depth_of_field)
commandbuffer->bind_texture(dof_pass->far_field, 7); commandbuffer->bind_texture(dof_pass->far_field, 7);
else else
commandbuffer->bind_texture(dummyTexture, 7); commandbuffer->bind_texture(dummy_texture, 7);
PostPushConstants pc; PostPushConstants pc;
pc.options.x = render_options.enable_aa; pc.options.x = render_options.enable_aa;
@ -409,7 +410,7 @@ void Renderer::render(GFXCommandBuffer* commandbuffer, Scene* scene, RenderTarge
target.current_frame = (target.current_frame + 1) % RT_MAX_FRAMES_IN_FLIGHT; target.current_frame = (target.current_frame + 1) % RT_MAX_FRAMES_IN_FLIGHT;
} }
void Renderer::render_camera(GFXCommandBuffer* command_buffer, Scene& scene, Object camera_object, Camera& camera, prism::Extent extent, RenderTarget& target, ControllerContinuity& continuity) { void renderer::render_camera(GFXCommandBuffer* command_buffer, Scene& scene, Object camera_object, Camera& camera, prism::Extent extent, RenderTarget& target, controller_continuity& continuity) {
// frustum test // frustum test
const auto frustum = normalize_frustum(camera_extract_frustum(scene, camera_object)); const auto frustum = normalize_frustum(camera_extract_frustum(scene, camera_object));
@ -514,7 +515,7 @@ void Renderer::render_camera(GFXCommandBuffer* command_buffer, Scene& scene, Obj
command_buffer->set_push_constant(&pc, sizeof(PushConstant)); command_buffer->set_push_constant(&pc, sizeof(PushConstant));
for(const auto& [index, texture] : mesh.materials[material_index]->bound_textures) { for(const auto& [index, texture] : mesh.materials[material_index]->bound_textures) {
GFXTexture* texture_to_bind = dummyTexture; GFXTexture* texture_to_bind = dummy_texture;
if(texture) if(texture)
texture_to_bind = texture->handle; texture_to_bind = texture->handle;
@ -530,7 +531,7 @@ void Renderer::render_camera(GFXCommandBuffer* command_buffer, Scene& scene, Obj
if(!screen.screen) if(!screen.screen)
continue; continue;
RenderScreenOptions options = {}; render_screen_options options = {};
options.render_world = true; options.render_world = true;
options.mvp = camera.perspective * camera.view * scene.get<Transform>(obj).model; options.mvp = camera.perspective * camera.view * scene.get<Transform>(obj).model;
@ -560,7 +561,7 @@ void Renderer::render_camera(GFXCommandBuffer* command_buffer, Scene& scene, Obj
gfx->copy_buffer(target.sceneBuffer, &sceneInfo, 0, sizeof(SceneInformation)); gfx->copy_buffer(target.sceneBuffer, &sceneInfo, 0, sizeof(SceneInformation));
} }
void Renderer::render_screen(GFXCommandBuffer *commandbuffer, ui::Screen* screen, prism::Extent extent, ControllerContinuity& continuity, RenderScreenOptions options) { void renderer::render_screen(GFXCommandBuffer *commandbuffer, ui::Screen* screen, prism::Extent extent, controller_continuity& continuity, render_screen_options options) {
std::array<GlyphInstance, maxInstances> instances; std::array<GlyphInstance, maxInstances> instances;
std::vector<ElementInstance> elementInstances; std::vector<ElementInstance> elementInstances;
std::array<StringInstance, 50> stringInstances = {}; std::array<StringInstance, 50> stringInstances = {};
@ -658,7 +659,7 @@ void Renderer::render_screen(GFXCommandBuffer *commandbuffer, ui::Screen* screen
commandbuffer->bind_texture(element.background.texture->handle, 2); commandbuffer->bind_texture(element.background.texture->handle, 2);
} }
else { else {
commandbuffer->bind_texture(dummyTexture, 2); commandbuffer->bind_texture(dummy_texture, 2);
} }
commandbuffer->set_push_constant(&pc, sizeof(UIPushConstant)); commandbuffer->set_push_constant(&pc, sizeof(UIPushConstant));
@ -690,7 +691,7 @@ void Renderer::render_screen(GFXCommandBuffer *commandbuffer, ui::Screen* screen
continuity.elementOffset += numElements; continuity.elementOffset += numElements;
} }
void Renderer::create_mesh_pipeline(Material& material) const { void renderer::create_mesh_pipeline(Material& material) const {
GFXShaderConstant materials_constant = {}; GFXShaderConstant materials_constant = {};
materials_constant.type = GFXShaderConstant::Type::Integer; materials_constant.type = GFXShaderConstant::Type::Integer;
materials_constant.value = max_scene_materials; materials_constant.value = max_scene_materials;
@ -733,7 +734,7 @@ void Renderer::create_mesh_pipeline(Material& material) const {
{9, GFXBindingType::Texture} {9, GFXBindingType::Texture}
}; };
pipelineInfo.render_pass = offscreenRenderPass; pipelineInfo.render_pass = offscreen_render_pass;
pipelineInfo.depth.depth_mode = GFXDepthMode::Less; pipelineInfo.depth.depth_mode = GFXDepthMode::Less;
pipelineInfo.rasterization.culling_mode = GFXCullingMode::Backface; pipelineInfo.rasterization.culling_mode = GFXCullingMode::Backface;
pipelineInfo.blending.src_rgb = GFXBlendFactor::SrcAlpha; pipelineInfo.blending.src_rgb = GFXBlendFactor::SrcAlpha;
@ -763,7 +764,7 @@ void Renderer::create_mesh_pipeline(Material& material) const {
material.capture_pipeline = material_compiler.create_static_pipeline(pipelineInfo, false, true); material.capture_pipeline = material_compiler.create_static_pipeline(pipelineInfo, false, true);
} }
void Renderer::create_dummy_texture() { void renderer::create_dummy_texture() {
GFXTextureCreateInfo createInfo = {}; GFXTextureCreateInfo createInfo = {};
createInfo.label = "Dummy"; createInfo.label = "Dummy";
createInfo.width = 1; createInfo.width = 1;
@ -771,14 +772,14 @@ void Renderer::create_dummy_texture() {
createInfo.format = GFXPixelFormat::R8G8B8A8_UNORM; createInfo.format = GFXPixelFormat::R8G8B8A8_UNORM;
createInfo.usage = GFXTextureUsage::Sampled; createInfo.usage = GFXTextureUsage::Sampled;
dummyTexture = gfx->create_texture(createInfo); dummy_texture = gfx->create_texture(createInfo);
uint8_t tex[4] = {0, 0, 0, 0}; uint8_t tex[4] = {0, 0, 0, 0};
gfx->copy_texture(dummyTexture, tex, sizeof(tex)); gfx->copy_texture(dummy_texture, tex, sizeof(tex));
} }
void Renderer::create_render_target_resources(RenderTarget& target) { void renderer::create_render_target_resources(RenderTarget& target) {
const auto extent = target.get_render_extent(); const auto extent = target.get_render_extent();
GFXTextureCreateInfo textureInfo = {}; GFXTextureCreateInfo textureInfo = {};
@ -797,7 +798,7 @@ void Renderer::create_render_target_resources(RenderTarget& target) {
target.offscreenDepthTexture = gfx->create_texture(textureInfo); target.offscreenDepthTexture = gfx->create_texture(textureInfo);
GFXFramebufferCreateInfo framebufferInfo = {}; GFXFramebufferCreateInfo framebufferInfo = {};
framebufferInfo.render_pass = offscreenRenderPass; framebufferInfo.render_pass = offscreen_render_pass;
framebufferInfo.attachments.push_back(target.offscreenColorTexture); framebufferInfo.attachments.push_back(target.offscreenColorTexture);
framebufferInfo.attachments.push_back(target.offscreenDepthTexture); framebufferInfo.attachments.push_back(target.offscreenDepthTexture);
@ -830,7 +831,7 @@ void Renderer::create_render_target_resources(RenderTarget& target) {
target.sceneBuffer = gfx->create_buffer(nullptr, sizeof(SceneInformation), true, GFXBufferUsage::Storage); target.sceneBuffer = gfx->create_buffer(nullptr, sizeof(SceneInformation), true, GFXBufferUsage::Storage);
} }
void Renderer::create_post_pipelines() { void renderer::create_post_pipelines() {
GFXGraphicsPipelineCreateInfo pipelineInfo = {}; GFXGraphicsPipelineCreateInfo pipelineInfo = {};
pipelineInfo.label = "Post"; pipelineInfo.label = "Post";
@ -854,7 +855,7 @@ void Renderer::create_post_pipelines() {
post_pipeline = gfx->create_graphics_pipeline(pipelineInfo); post_pipeline = gfx->create_graphics_pipeline(pipelineInfo);
} }
void Renderer::create_font_texture() { void renderer::create_font_texture() {
auto file = file::open(file::app_domain / "font.fp", true); auto file = file::open(file::app_domain / "font.fp", true);
if(file == std::nullopt) { if(file == std::nullopt) {
prism::log::error(System::Renderer, "Failed to load font file!"); prism::log::error(System::Renderer, "Failed to load font file!");
@ -880,10 +881,10 @@ void Renderer::create_font_texture() {
gfx->copy_texture(font_texture, bitmap.data(), font.width * font.height); gfx->copy_texture(font_texture, bitmap.data(), font.width * font.height);
} }
void Renderer::create_sky_pipeline() { void renderer::create_sky_pipeline() {
GFXGraphicsPipelineCreateInfo pipelineInfo = {}; GFXGraphicsPipelineCreateInfo pipelineInfo = {};
pipelineInfo.label = "Sky"; pipelineInfo.label = "Sky";
pipelineInfo.render_pass = offscreenRenderPass; pipelineInfo.render_pass = offscreen_render_pass;
pipelineInfo.shaders.vertex_src = register_shader("sky.vert"); pipelineInfo.shaders.vertex_src = register_shader("sky.vert");
pipelineInfo.shaders.fragment_src = register_shader("sky.frag"); pipelineInfo.shaders.fragment_src = register_shader("sky.frag");
@ -909,7 +910,7 @@ void Renderer::create_sky_pipeline() {
}); });
} }
void Renderer::create_ui_pipelines() { void renderer::create_ui_pipelines() {
GFXGraphicsPipelineCreateInfo pipelineInfo = {}; GFXGraphicsPipelineCreateInfo pipelineInfo = {};
pipelineInfo.label = "UI"; pipelineInfo.label = "UI";
@ -935,13 +936,13 @@ void Renderer::create_ui_pipelines() {
general_pipeline = gfx->create_graphics_pipeline(pipelineInfo); general_pipeline = gfx->create_graphics_pipeline(pipelineInfo);
pipelineInfo.label = "UI World"; pipelineInfo.label = "UI World";
pipelineInfo.render_pass = offscreenRenderPass; pipelineInfo.render_pass = offscreen_render_pass;
pipelineInfo.depth.depth_mode = GFXDepthMode::LessOrEqual; pipelineInfo.depth.depth_mode = GFXDepthMode::LessOrEqual;
world_general_pipeline = gfx->create_graphics_pipeline(pipelineInfo); world_general_pipeline = gfx->create_graphics_pipeline(pipelineInfo);
} }
void Renderer::generate_brdf() { void renderer::generate_brdf() {
GFXRenderPassCreateInfo renderPassInfo = {}; GFXRenderPassCreateInfo renderPassInfo = {};
renderPassInfo.label = "BRDF Gen"; renderPassInfo.label = "BRDF Gen";
renderPassInfo.attachments.push_back(GFXPixelFormat::R8G8_SFLOAT); renderPassInfo.attachments.push_back(GFXPixelFormat::R8G8_SFLOAT);
@ -997,7 +998,7 @@ void Renderer::generate_brdf() {
gfx->submit(command_buffer); gfx->submit(command_buffer);
} }
void Renderer::create_histogram_resources() { void renderer::create_histogram_resources() {
GFXComputePipelineCreateInfo create_info = {}; GFXComputePipelineCreateInfo create_info = {};
create_info.shaders.compute_path = "histogram.comp"; create_info.shaders.compute_path = "histogram.comp";
create_info.workgroup_size_x = 16; create_info.workgroup_size_x = 16;
@ -1027,7 +1028,7 @@ void Renderer::create_histogram_resources() {
average_luminance_texture = gfx->create_texture(texture_info); average_luminance_texture = gfx->create_texture(texture_info);
} }
ShaderSource Renderer::register_shader(const std::string_view shader_file) { ShaderSource renderer::register_shader(const std::string_view shader_file) {
if(!reloading_shader) { if(!reloading_shader) {
RegisteredShader shader; RegisteredShader shader;
shader.filename = shader_file; shader.filename = shader_file;
@ -1067,7 +1068,7 @@ ShaderSource Renderer::register_shader(const std::string_view shader_file) {
} }
} }
void Renderer::associate_shader_reload(const std::string_view shader_file, const std::function<void()>& reload_function) { void renderer::associate_shader_reload(const std::string_view shader_file, const std::function<void()>& reload_function) {
if(reloading_shader) if(reloading_shader)
return; return;
@ -1077,7 +1078,7 @@ void Renderer::associate_shader_reload(const std::string_view shader_file, const
} }
} }
void Renderer::reload_shader(const std::string_view shader_file, const std::string_view shader_source) { void renderer::reload_shader(const std::string_view shader_file, const std::string_view shader_source) {
for(auto& shader : registered_shaders) { for(auto& shader : registered_shaders) {
if(shader.filename == shader_file) { if(shader.filename == shader_file) {
shader.injected_shader_source = shader_source; shader.injected_shader_source = shader_source;

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

@ -274,7 +274,7 @@ void SceneCapture::render(GFXCommandBuffer* command_buffer, Scene* scene) {
command_buffer->set_push_constant(&pc, sizeof(PushConstant)); command_buffer->set_push_constant(&pc, sizeof(PushConstant));
for(auto& [index, texture] : mesh.materials[material_index]->bound_textures) { for(auto& [index, texture] : mesh.materials[material_index]->bound_textures) {
GFXTexture* texture_to_bind = engine->get_renderer()->dummyTexture; GFXTexture* texture_to_bind = engine->get_renderer()->dummy_texture;
if(texture) if(texture)
texture_to_bind = texture->handle; texture_to_bind = texture->handle;

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

@ -9,7 +9,7 @@
#include <AreaTex.h> #include <AreaTex.h>
#include <SearchTex.h> #include <SearchTex.h>
SMAAPass::SMAAPass(GFX* gfx, Renderer* renderer) : renderer(renderer) { SMAAPass::SMAAPass(GFX* gfx, prism::renderer* renderer) : renderer(renderer) {
Expects(gfx != nullptr); Expects(gfx != nullptr);
Expects(renderer != nullptr); Expects(renderer != nullptr);

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

@ -183,7 +183,7 @@ public:
return texture; return texture;
} else { } else {
return engine->get_renderer()->dummyTexture; return engine->get_renderer()->dummy_texture;
} }
} }
} }
@ -196,9 +196,9 @@ public:
// store as dummy texture, as to stop infinite reload because of failure (e.g. out of date model) // store as dummy texture, as to stop infinite reload because of failure (e.g. out of date model)
if(asset == nullptr) { if(asset == nullptr) {
asset_thumbnails[path.string()] = engine->get_renderer()->dummyTexture; asset_thumbnails[path.string()] = engine->get_renderer()->dummy_texture;
return engine->get_renderer()->dummyTexture; return engine->get_renderer()->dummy_texture;
} }
if(can_load_asset<Material>(path)) { if(can_load_asset<Material>(path)) {
@ -214,7 +214,7 @@ public:
return get_asset_thumbnail(ptr); return get_asset_thumbnail(ptr);
} else { } else {
return engine->get_renderer()->dummyTexture; return engine->get_renderer()->dummy_texture;
} }
} }
} }

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

@ -860,7 +860,7 @@ GFXTexture* CommonEditor::get_texture_preview(Texture& texture) {
GFXFramebufferCreateInfo framebuffer_create_info = {}; GFXFramebufferCreateInfo framebuffer_create_info = {};
framebuffer_create_info.attachments = {final_texture}; framebuffer_create_info.attachments = {final_texture};
framebuffer_create_info.render_pass = engine->get_renderer()->unormRenderPass; framebuffer_create_info.render_pass = engine->get_renderer()->unorm_render_pass;
auto final_framebuffer = gfx->create_framebuffer(framebuffer_create_info); auto final_framebuffer = gfx->create_framebuffer(framebuffer_create_info);
@ -871,7 +871,7 @@ GFXTexture* CommonEditor::get_texture_preview(Texture& texture) {
GFXRenderPassBeginInfo begin_info = {}; GFXRenderPassBeginInfo begin_info = {};
begin_info.render_area.extent = {thumbnail_resolution, thumbnail_resolution}; begin_info.render_area.extent = {thumbnail_resolution, thumbnail_resolution};
begin_info.framebuffer = final_framebuffer; begin_info.framebuffer = final_framebuffer;
begin_info.render_pass = renderer->unormRenderPass; begin_info.render_pass = renderer->unorm_render_pass;
command_buffer->set_render_pass(begin_info); command_buffer->set_render_pass(begin_info);
@ -881,12 +881,12 @@ GFXTexture* CommonEditor::get_texture_preview(Texture& texture) {
command_buffer->set_viewport(viewport); command_buffer->set_viewport(viewport);
command_buffer->set_graphics_pipeline(renderer->renderToUnormTexturePipeline); command_buffer->set_graphics_pipeline(renderer->render_to_unorm_texture_pipeline);
command_buffer->bind_texture(texture.handle, 1); command_buffer->bind_texture(texture.handle, 1);
command_buffer->bind_texture(renderer->dummyTexture, 2); command_buffer->bind_texture(renderer->dummy_texture, 2);
command_buffer->bind_texture(renderer->dummyTexture, 3); command_buffer->bind_texture(renderer->dummy_texture, 3);
command_buffer->bind_texture(renderer->dummyTexture, 4); command_buffer->bind_texture(renderer->dummy_texture, 4);
struct PostPushConstants { struct PostPushConstants {
Vector4 viewport; Vector4 viewport;
@ -963,13 +963,13 @@ GFXTexture* CommonEditor::generate_common_preview(Scene& scene, const Vector3 ca
GFXFramebufferCreateInfo framebuffer_create_info = {}; GFXFramebufferCreateInfo framebuffer_create_info = {};
framebuffer_create_info.attachments = {offscreen_color_texture, offscreen_depth_texture}; framebuffer_create_info.attachments = {offscreen_color_texture, offscreen_depth_texture};
framebuffer_create_info.render_pass = renderer->offscreenRenderPass; framebuffer_create_info.render_pass = renderer->offscreen_render_pass;
auto offscreen_framebuffer = gfx->create_framebuffer(framebuffer_create_info); auto offscreen_framebuffer = gfx->create_framebuffer(framebuffer_create_info);
framebuffer_create_info = {}; framebuffer_create_info = {};
framebuffer_create_info.attachments = {final_texture}; framebuffer_create_info.attachments = {final_texture};
framebuffer_create_info.render_pass = renderer->unormRenderPass; framebuffer_create_info.render_pass = renderer->unorm_render_pass;
auto final_framebuffer = gfx->create_framebuffer(framebuffer_create_info); auto final_framebuffer = gfx->create_framebuffer(framebuffer_create_info);
@ -982,17 +982,17 @@ GFXTexture* CommonEditor::generate_common_preview(Scene& scene, const Vector3 ca
GFXRenderPassBeginInfo begin_info = {}; GFXRenderPassBeginInfo begin_info = {};
begin_info.framebuffer = offscreen_framebuffer; begin_info.framebuffer = offscreen_framebuffer;
begin_info.render_pass = renderer->offscreenRenderPass; begin_info.render_pass = renderer->offscreen_render_pass;
begin_info.render_area.extent = {thumbnail_resolution, thumbnail_resolution}; begin_info.render_area.extent = {thumbnail_resolution, thumbnail_resolution};
command_buffer->set_render_pass(begin_info); command_buffer->set_render_pass(begin_info);
Renderer::ControllerContinuity continuity; prism::renderer::controller_continuity continuity;
renderer->render_camera(command_buffer, scene, camera, scene.get<Camera>(camera), begin_info.render_area.extent, *target, continuity); renderer->render_camera(command_buffer, scene, camera, scene.get<Camera>(camera), begin_info.render_area.extent, *target, continuity);
// render post // render post
begin_info.framebuffer = final_framebuffer; begin_info.framebuffer = final_framebuffer;
begin_info.render_pass = renderer->unormRenderPass; begin_info.render_pass = renderer->unorm_render_pass;
command_buffer->set_render_pass(begin_info); command_buffer->set_render_pass(begin_info);
@ -1002,12 +1002,12 @@ GFXTexture* CommonEditor::generate_common_preview(Scene& scene, const Vector3 ca
command_buffer->set_viewport(viewport); command_buffer->set_viewport(viewport);
command_buffer->set_graphics_pipeline(renderer->renderToUnormTexturePipeline); command_buffer->set_graphics_pipeline(renderer->render_to_unorm_texture_pipeline);
command_buffer->bind_texture(offscreen_color_texture, 1); command_buffer->bind_texture(offscreen_color_texture, 1);
command_buffer->bind_texture(renderer->dummyTexture, 2); command_buffer->bind_texture(renderer->dummy_texture, 2);
command_buffer->bind_texture(renderer->dummyTexture, 3); command_buffer->bind_texture(renderer->dummy_texture, 3);
command_buffer->bind_texture(renderer->dummyTexture, 4); command_buffer->bind_texture(renderer->dummy_texture, 4);
struct PostPushConstants { struct PostPushConstants {
Vector4 viewport; Vector4 viewport;

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

@ -42,7 +42,7 @@ void DebugPass::initialize() {
{1, GFXBindingType::PushConstant} {1, GFXBindingType::PushConstant}
}; };
createInfo.render_pass = engine->get_renderer()->offscreenRenderPass; createInfo.render_pass = engine->get_renderer()->offscreen_render_pass;
createInfo.rasterization.polygon_type = GFXPolygonType::Line; createInfo.rasterization.polygon_type = GFXPolygonType::Line;
primitive_pipeline = engine->get_gfx()->create_graphics_pipeline(createInfo); primitive_pipeline = engine->get_gfx()->create_graphics_pipeline(createInfo);
@ -159,7 +159,7 @@ void DebugPass::initialize() {
pipelineInfo.blending.enable_blending = true; pipelineInfo.blending.enable_blending = true;
pipelineInfo.render_pass = engine->get_renderer()->offscreenRenderPass; pipelineInfo.render_pass = engine->get_renderer()->offscreen_render_pass;
billboard_pipeline = engine->get_gfx()->create_graphics_pipeline(pipelineInfo); billboard_pipeline = engine->get_gfx()->create_graphics_pipeline(pipelineInfo);