thirdpartymirrors/RingRacers
1
0
Fork 0
mirror of https://github.com/KartKrewDev/RingRacers.git synced 2025-10-30 08:01:28 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

rhi: Remove the old Pass concept

Browse source 
This was already slated to be removed; the old PassManager was a failed
attempt to centralize and pipeline all graphics logic for a frame. Let's
remove it as a step towards simplifying some of this code.
This commit is contained in:
Eidolon 2024-10-24 14:10:41 -05:00
parent dae2e8ba17
commit bba1d56529
10 changed files with 24 additions and 348 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
src/hwr2/CMakeLists.txt
View file

@ -7,12 +7,8 @@ target_sources(SRB2SDL2 PRIVATE
hardware_state.hpp hardware_state.hpp
pass_imgui.cpp pass_imgui.cpp
pass_imgui.hpp pass_imgui.hpp
pass_manager.cpp
pass_manager.hpp
pass_resource_managers.cpp pass_resource_managers.cpp
pass_resource_managers.hpp pass_resource_managers.hpp
pass.cpp
pass.hpp
patch_atlas.cpp patch_atlas.cpp
patch_atlas.hpp patch_atlas.hpp
postprocess_wipe.cpp postprocess_wipe.cpp

16
src/hwr2/pass.cpp
View file

@ -1,16 +0,0 @@
// DR. ROBOTNIK'S RING RACERS
//-----------------------------------------------------------------------------
// Copyright (C) 2024 by Ronald "Eidolon" Kinard
// Copyright (C) 2024 by Kart Krew
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
// See the 'LICENSE' file for more details.
//-----------------------------------------------------------------------------
#include "pass.hpp"
using namespace srb2;
using namespace srb2::hwr2;
Pass::~Pass() = default;

47
src/hwr2/pass.hpp
View file

@ -1,47 +0,0 @@
// DR. ROBOTNIK'S RING RACERS
//-----------------------------------------------------------------------------
// Copyright (C) 2024 by Ronald "Eidolon" Kinard
// Copyright (C) 2024 by Kart Krew
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
// See the 'LICENSE' file for more details.
//-----------------------------------------------------------------------------
#ifndef __SRB2_HWR2_PASS_HPP__
#define __SRB2_HWR2_PASS_HPP__
#include "../rhi/rhi.hpp"
namespace srb2::hwr2
{
/// @brief A rendering pass which performs logic during each phase of a frame render.
/// During rendering, all registered Pass's individual stages will be run together.
class Pass
{
public:
virtual ~Pass();
/// @brief Perform rendering logic and create necessary GPU resources.
/// @param rhi
virtual void prepass(rhi::Rhi& rhi) = 0;
/// @brief Upload contents for needed GPU resources. Passes must implement but this will be removed soon.
/// @param rhi
/// @param ctx
virtual void transfer(rhi::Rhi& rhi) = 0;
/// @brief Issue draw calls.
/// @param rhi
/// @param ctx
virtual void graphics(rhi::Rhi& rhi) = 0;
/// @brief Cleanup GPU resources. Transient resources should be cleaned up here.
/// @param rhi
virtual void postpass(rhi::Rhi& rhi) = 0;
};
} // namespace srb2::hwr2
#endif // __SRB2_HWR2_PASS_HPP__

2
src/hwr2/pass_imgui.cpp
View file

@ -40,7 +40,7 @@ static const PipelineDesc kPipelineDesc = {
FaceWinding::kCounterClockwise, FaceWinding::kCounterClockwise,
{0.f, 0.f, 0.f, 1.f}}; {0.f, 0.f, 0.f, 1.f}};
ImguiPass::ImguiPass() : Pass() ImguiPass::ImguiPass()
{ {
} }

14
src/hwr2/pass_imgui.hpp
View file

@ -14,12 +14,11 @@
#include <vector> #include <vector>
#include "../rhi/rhi.hpp" #include "../rhi/rhi.hpp"
#include "pass.hpp"
namespace srb2::hwr2 namespace srb2::hwr2
{ {
class ImguiPass final : public Pass class ImguiPass final
{ {
struct DrawCmd struct DrawCmd
{ {
@ -49,13 +48,10 @@ public:
ImguiPass(); ImguiPass();
virtual ~ImguiPass(); virtual ~ImguiPass();
virtual void prepass(rhi::Rhi& rhi) override; void prepass(rhi::Rhi& rhi);
void transfer(rhi::Rhi& rhi);
virtual void transfer(rhi::Rhi& rhi) override; void graphics(rhi::Rhi& rhi);
void postpass(rhi::Rhi& rhi);
virtual void graphics(rhi::Rhi& rhi) override;
virtual void postpass(rhi::Rhi& rhi) override;
}; };
} // namespace srb2::hwr2 } // namespace srb2::hwr2

187
src/hwr2/pass_manager.cpp
View file

@ -1,187 +0,0 @@
// DR. ROBOTNIK'S RING RACERS
//-----------------------------------------------------------------------------
// Copyright (C) 2024 by Ronald "Eidolon" Kinard
// Copyright (C) 2024 by Kart Krew
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
// See the 'LICENSE' file for more details.
//-----------------------------------------------------------------------------
#include "pass_manager.hpp"
using namespace srb2;
using namespace srb2::hwr2;
using namespace srb2::rhi;
namespace
{
class LambdaPass final : public Pass
{
PassManager* mgr_;
std::function<void(PassManager&, rhi::Rhi&)> prepass_func_;
std::function<void(PassManager&, rhi::Rhi&)> postpass_func_;
public:
LambdaPass(PassManager* mgr, std::function<void(PassManager&, rhi::Rhi&)> prepass_func);
LambdaPass(
PassManager* mgr,
std::function<void(PassManager&, rhi::Rhi&)> prepass_func,
std::function<void(PassManager&, rhi::Rhi&)> postpass_func
);
virtual ~LambdaPass();
virtual void prepass(rhi::Rhi& rhi) override;
virtual void transfer(rhi::Rhi& rhi) override;
virtual void graphics(rhi::Rhi& rhi) override;
virtual void postpass(rhi::Rhi& rhi) override;
};
} // namespace
LambdaPass::LambdaPass(PassManager* mgr, std::function<void(PassManager&, rhi::Rhi&)> prepass_func)
: mgr_(mgr), prepass_func_(prepass_func)
{
}
LambdaPass::LambdaPass(
PassManager* mgr,
std::function<void(PassManager&, rhi::Rhi&)> prepass_func,
std::function<void(PassManager&, rhi::Rhi&)> postpass_func
)
: mgr_(mgr), prepass_func_(prepass_func), postpass_func_(postpass_func)
{
}
LambdaPass::~LambdaPass() = default;
void LambdaPass::prepass(Rhi& rhi)
{
if (prepass_func_)
{
(prepass_func_)(*mgr_, rhi);
}
}
void LambdaPass::transfer(Rhi&)
{
}
void LambdaPass::graphics(Rhi&)
{
}
void LambdaPass::postpass(Rhi& rhi)
{
if (postpass_func_)
{
(postpass_func_)(*mgr_, rhi);
}
}
PassManager::PassManager() = default;
PassManager::PassManager(const PassManager&) = default;
PassManager& PassManager::operator=(const PassManager&) = default;
void PassManager::insert(const std::string& name, std::shared_ptr<Pass> pass)
{
SRB2_ASSERT(pass_by_name_.find(name) == pass_by_name_.end());
std::size_t index = passes_.size();
passes_.push_back(PassManagerEntry {name, pass, true});
pass_by_name_.insert({name, index});
}
void PassManager::insert(const std::string& name, std::function<void(PassManager&, Rhi&)> prepass_func)
{
insert(std::forward<const std::string>(name), std::make_shared<LambdaPass>(LambdaPass {this, prepass_func}));
}
void PassManager::insert(
const std::string& name,
std::function<void(PassManager&, Rhi&)> prepass_func,
std::function<void(PassManager&, Rhi&)> postpass_func
)
{
insert(
std::forward<const std::string>(name),
std::make_shared<LambdaPass>(LambdaPass {this, prepass_func, postpass_func})
);
}
void PassManager::set_pass_enabled(const std::string& name, bool enabled)
{
SRB2_ASSERT(pass_by_name_.find(name) != pass_by_name_.end());
passes_[pass_by_name_[name]].enabled = enabled;
}
std::weak_ptr<Pass> PassManager::for_name(const std::string& name)
{
auto itr = pass_by_name_.find(name);
if (itr == pass_by_name_.end())
{
return std::weak_ptr<Pass>();
}
return passes_[itr->second].pass;
}
void PassManager::prepass(Rhi& rhi)
{
for (auto& pass : passes_)
{
if (pass.enabled)
{
pass.pass->prepass(rhi);
}
}
}
void PassManager::transfer(Rhi& rhi)
{
for (auto& pass : passes_)
{
if (pass.enabled)
{
pass.pass->transfer(rhi);
}
}
}
void PassManager::graphics(Rhi& rhi)
{
for (auto& pass : passes_)
{
if (pass.enabled)
{
pass.pass->graphics(rhi);
}
}
}
void PassManager::postpass(Rhi& rhi)
{
for (auto& pass : passes_)
{
if (pass.enabled)
{
pass.pass->postpass(rhi);
}
}
}
void PassManager::render(Rhi& rhi)
{
if (passes_.empty())
{
return;
}
prepass(rhi);
transfer(rhi);
graphics(rhi);
postpass(rhi);
}

66
src/hwr2/pass_manager.hpp
View file

@ -1,66 +0,0 @@
// DR. ROBOTNIK'S RING RACERS
//-----------------------------------------------------------------------------
// Copyright (C) 2024 by Ronald "Eidolon" Kinard
// Copyright (C) 2024 by Kart Krew
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
// See the 'LICENSE' file for more details.
//-----------------------------------------------------------------------------
#ifndef __SRB2_HWR2_PASS_MANAGER_HPP__
#define __SRB2_HWR2_PASS_MANAGER_HPP__
#include <cstddef>
#include <functional>
#include <memory>
#include <string>
#include <unordered_map>
#include <vector>
#include "../rhi/rhi.hpp"
#include "pass.hpp"
namespace srb2::hwr2
{
class PassManager final : public Pass
{
struct PassManagerEntry
{
std::string name;
std::shared_ptr<Pass> pass;
bool enabled;
};
std::unordered_map<std::string, std::size_t> pass_by_name_;
std::vector<PassManagerEntry> passes_;
public:
PassManager();
PassManager(const PassManager&);
PassManager(PassManager&&) = delete;
PassManager& operator=(const PassManager&);
PassManager& operator=(PassManager&&) = delete;
virtual void prepass(rhi::Rhi& rhi) override;
virtual void transfer(rhi::Rhi& rhi) override;
virtual void graphics(rhi::Rhi& rhi) override;
virtual void postpass(rhi::Rhi& rhi) override;
void insert(const std::string& name, std::shared_ptr<Pass> pass);
void insert(const std::string& name, std::function<void(PassManager&, rhi::Rhi&)> prepass_func);
void insert(
const std::string& name,
std::function<void(PassManager&, rhi::Rhi&)> prepass_func,
std::function<void(PassManager&, rhi::Rhi&)> postpass_func
);
std::weak_ptr<Pass> for_name(const std::string& name);
void set_pass_enabled(const std::string& name, bool enabled);
void render(rhi::Rhi& rhi);
};
} // namespace srb2::hwr2
#endif // __SRB2_HWR2_PASS_MANAGER_HPP__

2
src/hwr2/pass_resource_managers.cpp
View file

@ -21,7 +21,7 @@ using namespace srb2;
using namespace srb2::hwr2; using namespace srb2::hwr2;
using namespace srb2::rhi; using namespace srb2::rhi;
FramebufferManager::FramebufferManager() : Pass() FramebufferManager::FramebufferManager()
{ {
} }

32
src/hwr2/pass_resource_managers.hpp
View file

@ -16,12 +16,12 @@
#include <unordered_map> #include <unordered_map>
#include <vector> #include <vector>
#include "pass.hpp" #include "../rhi/rhi.hpp"
namespace srb2::hwr2 namespace srb2::hwr2
{ {
class FramebufferManager final : public Pass class FramebufferManager final
{ {
rhi::Handle<rhi::Texture> main_color_; rhi::Handle<rhi::Texture> main_color_;
std::array<rhi::Handle<rhi::Texture>, 2> post_colors_; std::array<rhi::Handle<rhi::Texture>, 2> post_colors_;
@ -36,10 +36,10 @@ public:
FramebufferManager(); FramebufferManager();
virtual ~FramebufferManager(); virtual ~FramebufferManager();
virtual void prepass(rhi::Rhi& rhi) override; void prepass(rhi::Rhi& rhi);
virtual void transfer(rhi::Rhi& rhi) override; void transfer(rhi::Rhi& rhi);
virtual void graphics(rhi::Rhi& rhi) override; void graphics(rhi::Rhi& rhi);
virtual void postpass(rhi::Rhi& rhi) override; void postpass(rhi::Rhi& rhi);
/// @brief Swap the current and previous postprocess FB textures. Use between pass prepass phases to alternate. /// @brief Swap the current and previous postprocess FB textures. Use between pass prepass phases to alternate.
void swap_post() noexcept void swap_post() noexcept
@ -70,7 +70,7 @@ public:
std::size_t height() const noexcept { return height_; } std::size_t height() const noexcept { return height_; }
}; };
class MainPaletteManager final : public Pass class MainPaletteManager final
{ {
rhi::Handle<rhi::Texture> palette_; rhi::Handle<rhi::Texture> palette_;
rhi::Handle<rhi::Texture> lighttable_; rhi::Handle<rhi::Texture> lighttable_;
@ -91,10 +91,10 @@ public:
MainPaletteManager(); MainPaletteManager();
virtual ~MainPaletteManager(); virtual ~MainPaletteManager();
virtual void prepass(rhi::Rhi& rhi) override; void prepass(rhi::Rhi& rhi);
virtual void transfer(rhi::Rhi& rhi) override; void transfer(rhi::Rhi& rhi);
virtual void graphics(rhi::Rhi& rhi) override; void graphics(rhi::Rhi& rhi);
virtual void postpass(rhi::Rhi& rhi) override; void postpass(rhi::Rhi& rhi);
rhi::Handle<rhi::Texture> palette() const noexcept { return palette_; } rhi::Handle<rhi::Texture> palette() const noexcept { return palette_; }
rhi::Handle<rhi::Texture> lighttable() const noexcept { return lighttable_; } rhi::Handle<rhi::Texture> lighttable() const noexcept { return lighttable_; }
@ -107,7 +107,7 @@ public:
rhi::Handle<rhi::Texture> find_extra_lighttable(srb2::NotNull<const uint8_t*> lighttable) const; rhi::Handle<rhi::Texture> find_extra_lighttable(srb2::NotNull<const uint8_t*> lighttable) const;
}; };
class CommonResourcesManager final : public Pass class CommonResourcesManager final
{ {
bool init_ = false; bool init_ = false;
rhi::Handle<rhi::Texture> black_; rhi::Handle<rhi::Texture> black_;
@ -118,10 +118,10 @@ public:
CommonResourcesManager(); CommonResourcesManager();
virtual ~CommonResourcesManager(); virtual ~CommonResourcesManager();
virtual void prepass(rhi::Rhi& rhi) override; void prepass(rhi::Rhi& rhi);
virtual void transfer(rhi::Rhi& rhi) override; void transfer(rhi::Rhi& rhi);
virtual void graphics(rhi::Rhi& rhi) override; void graphics(rhi::Rhi& rhi);
virtual void postpass(rhi::Rhi& rhi) override; void postpass(rhi::Rhi& rhi);
rhi::Handle<rhi::Texture> black() const noexcept { return black_; } rhi::Handle<rhi::Texture> black() const noexcept { return black_; }
rhi::Handle<rhi::Texture> white() const noexcept { return white_; } rhi::Handle<rhi::Texture> white() const noexcept { return white_; }

2
src/hwr2/patch_atlas.hpp
View file

@ -20,8 +20,8 @@
#include <tcb/span.hpp> #include <tcb/span.hpp>
#include "pass.hpp"
#include "../r_defs.h" #include "../r_defs.h"
#include "../rhi/rhi.hpp"
extern "C" extern "C"
{ {