You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
962 lines
36 KiB
962 lines
36 KiB
/****************************************************************************
|
|
Copyright (c) 2021-2023 Xiamen Yaji Software Co., Ltd.
|
|
|
|
http://www.cocos.com
|
|
|
|
Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
of this software and associated documentation files (the "Software"), to deal
|
|
in the Software without restriction, including without limitation the rights to
|
|
use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
|
|
of the Software, and to permit persons to whom the Software is furnished to do so,
|
|
subject to the following conditions:
|
|
|
|
The above copyright notice and this permission notice shall be included in
|
|
all copies or substantial portions of the Software.
|
|
|
|
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
|
THE SOFTWARE.
|
|
****************************************************************************/
|
|
|
|
/**
|
|
* ========================= !DO NOT CHANGE THE FOLLOWING SECTION MANUALLY! =========================
|
|
* The following section is auto-generated.
|
|
* ========================= !DO NOT CHANGE THE FOLLOWING SECTION MANUALLY! =========================
|
|
*/
|
|
// clang-format off
|
|
#pragma once
|
|
#include <string_view>
|
|
#include <tuple>
|
|
#include "cocos/renderer/pipeline/custom/FGDispatcherTypes.h"
|
|
#include "cocos/renderer/pipeline/custom/details/GraphImpl.h"
|
|
#include "cocos/renderer/pipeline/custom/details/Overload.h"
|
|
#include "cocos/renderer/pipeline/custom/details/PathUtils.h"
|
|
|
|
namespace cc {
|
|
|
|
namespace render {
|
|
|
|
// IncidenceGraph
|
|
inline ResourceAccessGraph::vertex_descriptor
|
|
source(const ResourceAccessGraph::edge_descriptor& e, const ResourceAccessGraph& /*g*/) noexcept {
|
|
return e.source;
|
|
}
|
|
|
|
inline ResourceAccessGraph::vertex_descriptor
|
|
target(const ResourceAccessGraph::edge_descriptor& e, const ResourceAccessGraph& /*g*/) noexcept {
|
|
return e.target;
|
|
}
|
|
|
|
inline std::pair<ResourceAccessGraph::out_edge_iterator, ResourceAccessGraph::out_edge_iterator>
|
|
out_edges(ResourceAccessGraph::vertex_descriptor u, const ResourceAccessGraph& g) noexcept { // NOLINT
|
|
return std::make_pair(
|
|
ResourceAccessGraph::out_edge_iterator(const_cast<ResourceAccessGraph&>(g).getOutEdgeList(u).begin(), u),
|
|
ResourceAccessGraph::out_edge_iterator(const_cast<ResourceAccessGraph&>(g).getOutEdgeList(u).end(), u));
|
|
}
|
|
|
|
inline ResourceAccessGraph::degree_size_type
|
|
out_degree(ResourceAccessGraph::vertex_descriptor u, const ResourceAccessGraph& g) noexcept { // NOLINT
|
|
return gsl::narrow_cast<ResourceAccessGraph::degree_size_type>(g.getOutEdgeList(u).size());
|
|
}
|
|
|
|
inline std::pair<ResourceAccessGraph::edge_descriptor, bool>
|
|
edge(ResourceAccessGraph::vertex_descriptor u, ResourceAccessGraph::vertex_descriptor v, const ResourceAccessGraph& g) noexcept {
|
|
const auto& outEdgeList = g.getOutEdgeList(u);
|
|
auto iter = std::find(outEdgeList.begin(), outEdgeList.end(), ResourceAccessGraph::OutEdge(v));
|
|
bool hasEdge = (iter != outEdgeList.end());
|
|
return {ResourceAccessGraph::edge_descriptor(u, v), hasEdge};
|
|
}
|
|
|
|
// BidirectionalGraph(Directed)
|
|
inline std::pair<ResourceAccessGraph::in_edge_iterator, ResourceAccessGraph::in_edge_iterator>
|
|
in_edges(ResourceAccessGraph::vertex_descriptor u, const ResourceAccessGraph& g) noexcept { // NOLINT
|
|
return std::make_pair(
|
|
ResourceAccessGraph::in_edge_iterator(const_cast<ResourceAccessGraph&>(g).getInEdgeList(u).begin(), u),
|
|
ResourceAccessGraph::in_edge_iterator(const_cast<ResourceAccessGraph&>(g).getInEdgeList(u).end(), u));
|
|
}
|
|
|
|
inline ResourceAccessGraph::degree_size_type
|
|
in_degree(ResourceAccessGraph::vertex_descriptor u, const ResourceAccessGraph& g) noexcept { // NOLINT
|
|
return gsl::narrow_cast<ResourceAccessGraph::degree_size_type>(g.getInEdgeList(u).size());
|
|
}
|
|
|
|
inline ResourceAccessGraph::degree_size_type
|
|
degree(ResourceAccessGraph::vertex_descriptor u, const ResourceAccessGraph& g) noexcept {
|
|
return in_degree(u, g) + out_degree(u, g);
|
|
}
|
|
|
|
// AdjacencyGraph
|
|
inline std::pair<ResourceAccessGraph::adjacency_iterator, ResourceAccessGraph::adjacency_iterator>
|
|
adjacent_vertices(ResourceAccessGraph::vertex_descriptor u, const ResourceAccessGraph& g) noexcept { // NOLINT
|
|
auto edges = out_edges(u, g);
|
|
return std::make_pair(ResourceAccessGraph::adjacency_iterator(edges.first, &g), ResourceAccessGraph::adjacency_iterator(edges.second, &g));
|
|
}
|
|
|
|
// VertexListGraph
|
|
inline std::pair<ResourceAccessGraph::vertex_iterator, ResourceAccessGraph::vertex_iterator>
|
|
vertices(const ResourceAccessGraph& g) noexcept {
|
|
return std::make_pair(const_cast<ResourceAccessGraph&>(g).getVertexList().begin(), const_cast<ResourceAccessGraph&>(g).getVertexList().end());
|
|
}
|
|
|
|
inline ResourceAccessGraph::vertices_size_type
|
|
num_vertices(const ResourceAccessGraph& g) noexcept { // NOLINT
|
|
return gsl::narrow_cast<ResourceAccessGraph::vertices_size_type>(g.getVertexList().size());
|
|
}
|
|
|
|
// EdgeListGraph
|
|
inline std::pair<ResourceAccessGraph::edge_iterator, ResourceAccessGraph::edge_iterator>
|
|
edges(const ResourceAccessGraph& g0) noexcept {
|
|
auto& g = const_cast<ResourceAccessGraph&>(g0);
|
|
return std::make_pair(
|
|
ResourceAccessGraph::edge_iterator(g.getVertexList().begin(), g.getVertexList().begin(), g.getVertexList().end(), g),
|
|
ResourceAccessGraph::edge_iterator(g.getVertexList().begin(), g.getVertexList().end(), g.getVertexList().end(), g));
|
|
}
|
|
|
|
inline ResourceAccessGraph::edges_size_type
|
|
num_edges(const ResourceAccessGraph& g) noexcept { // NOLINT
|
|
ResourceAccessGraph::edges_size_type numEdges = 0;
|
|
|
|
auto range = vertices(g);
|
|
for (auto iter = range.first; iter != range.second; ++iter) {
|
|
numEdges += out_degree(*iter, g);
|
|
}
|
|
return numEdges;
|
|
}
|
|
|
|
// MutableGraph(Edge)
|
|
inline std::pair<ResourceAccessGraph::edge_descriptor, bool>
|
|
add_edge( // NOLINT
|
|
ResourceAccessGraph::vertex_descriptor u,
|
|
ResourceAccessGraph::vertex_descriptor v, ResourceAccessGraph& g) {
|
|
auto& outEdgeList = g.getOutEdgeList(u);
|
|
outEdgeList.emplace_back(v);
|
|
|
|
auto& inEdgeList = g.getInEdgeList(v);
|
|
inEdgeList.emplace_back(u);
|
|
|
|
return std::make_pair(ResourceAccessGraph::edge_descriptor(u, v), true);
|
|
}
|
|
|
|
inline void remove_edge(ResourceAccessGraph::vertex_descriptor u, ResourceAccessGraph::vertex_descriptor v, ResourceAccessGraph& g) noexcept { // NOLINT
|
|
auto& s = g._vertices[u];
|
|
auto& t = g._vertices[v];
|
|
s.outEdges.erase(std::remove(s.outEdges.begin(), s.outEdges.end(), ResourceAccessGraph::OutEdge(v)), s.outEdges.end());
|
|
t.inEdges.erase(std::remove(t.inEdges.begin(), t.inEdges.end(), ResourceAccessGraph::InEdge(u)), t.inEdges.end());
|
|
}
|
|
|
|
inline void remove_edge(ResourceAccessGraph::out_edge_iterator outIter, ResourceAccessGraph& g) noexcept { // NOLINT
|
|
auto e = *outIter;
|
|
const auto u = source(e, g);
|
|
const auto v = target(e, g);
|
|
auto& s = g._vertices[u];
|
|
auto& t = g._vertices[v];
|
|
auto inIter = std::find(t.inEdges.begin(), t.inEdges.end(), ResourceAccessGraph::InEdge(u));
|
|
CC_EXPECTS(inIter != t.inEdges.end());
|
|
t.inEdges.erase(inIter);
|
|
s.outEdges.erase(outIter.base());
|
|
}
|
|
|
|
inline void remove_edge(ResourceAccessGraph::edge_descriptor e, ResourceAccessGraph& g) noexcept { // NOLINT
|
|
const auto u = source(e, g);
|
|
const auto v = target(e, g);
|
|
auto& s = g._vertices[u];
|
|
auto outIter = std::find(s.outEdges.begin(), s.outEdges.end(), ResourceAccessGraph::OutEdge(v));
|
|
CC_EXPECTS(outIter != s.outEdges.end());
|
|
remove_edge(ResourceAccessGraph::out_edge_iterator(outIter, u), g);
|
|
}
|
|
|
|
// MutableGraph(Vertex)
|
|
inline void clear_out_edges(ResourceAccessGraph::vertex_descriptor u, ResourceAccessGraph& g) noexcept { // NOLINT
|
|
// Bidirectional (OutEdges)
|
|
auto& outEdgeList = g.getOutEdgeList(u);
|
|
auto outEnd = outEdgeList.end();
|
|
for (auto iter = outEdgeList.begin(); iter != outEnd; ++iter) {
|
|
auto& inEdgeList = g.getInEdgeList((*iter).get_target());
|
|
// eraseFromIncidenceList
|
|
impl::sequenceEraseIf(inEdgeList, [u](const auto& e) {
|
|
return e.get_target() == u;
|
|
});
|
|
}
|
|
outEdgeList.clear();
|
|
}
|
|
|
|
inline void clear_in_edges(ResourceAccessGraph::vertex_descriptor u, ResourceAccessGraph& g) noexcept { // NOLINT
|
|
// Bidirectional (InEdges)
|
|
auto& inEdgeList = g.getInEdgeList(u);
|
|
auto inEnd = inEdgeList.end();
|
|
for (auto iter = inEdgeList.begin(); iter != inEnd; ++iter) {
|
|
auto& outEdgeList = g.getOutEdgeList((*iter).get_target());
|
|
// eraseFromIncidenceList
|
|
impl::sequenceEraseIf(outEdgeList, [u](const auto& e) {
|
|
return e.get_target() == u;
|
|
});
|
|
}
|
|
inEdgeList.clear();
|
|
}
|
|
|
|
inline void clear_vertex(ResourceAccessGraph::vertex_descriptor u, ResourceAccessGraph& g) noexcept { // NOLINT
|
|
clear_out_edges(u, g);
|
|
clear_in_edges(u, g);
|
|
}
|
|
|
|
inline void remove_vertex(ResourceAccessGraph::vertex_descriptor u, ResourceAccessGraph& g) noexcept { // NOLINT
|
|
{ // UuidGraph
|
|
const auto& key = g.passID[u];
|
|
auto num = g.passIndex.erase(key);
|
|
CC_ENSURES(num == 1);
|
|
for (auto&& pair : g.passIndex) {
|
|
auto& v = pair.second;
|
|
if (v > u) {
|
|
--v;
|
|
}
|
|
}
|
|
}
|
|
impl::removeVectorVertex(const_cast<ResourceAccessGraph&>(g), u, ResourceAccessGraph::directed_category{});
|
|
|
|
// remove components
|
|
g.passID.erase(g.passID.begin() + static_cast<std::ptrdiff_t>(u));
|
|
g.passResource.erase(g.passResource.begin() + static_cast<std::ptrdiff_t>(u));
|
|
g.rpInfo.erase(g.rpInfo.begin() + static_cast<std::ptrdiff_t>(u));
|
|
g.barrier.erase(g.barrier.begin() + static_cast<std::ptrdiff_t>(u));
|
|
}
|
|
|
|
// MutablePropertyGraph(Vertex)
|
|
template <class Component0, class Component1, class Component2, class Component3>
|
|
inline ResourceAccessGraph::vertex_descriptor
|
|
addVertex(Component0&& c0, Component1&& c1, Component2&& c2, Component3&& c3, ResourceAccessGraph& g) {
|
|
auto v = gsl::narrow_cast<ResourceAccessGraph::vertex_descriptor>(g._vertices.size());
|
|
|
|
g._vertices.emplace_back();
|
|
|
|
{ // UuidGraph
|
|
const auto& uuid = c0;
|
|
auto res = g.passIndex.emplace(uuid, v);
|
|
CC_ENSURES(res.second);
|
|
}
|
|
g.passID.emplace_back(std::forward<Component0>(c0));
|
|
g.passResource.emplace_back(std::forward<Component1>(c1));
|
|
g.rpInfo.emplace_back(std::forward<Component2>(c2));
|
|
g.barrier.emplace_back(std::forward<Component3>(c3));
|
|
|
|
return v;
|
|
}
|
|
|
|
template <class Component0, class Component1, class Component2, class Component3>
|
|
inline ResourceAccessGraph::vertex_descriptor
|
|
addVertex(std::piecewise_construct_t /*tag*/, Component0&& c0, Component1&& c1, Component2&& c2, Component3&& c3, ResourceAccessGraph& g) {
|
|
auto v = gsl::narrow_cast<ResourceAccessGraph::vertex_descriptor>(g._vertices.size());
|
|
|
|
g._vertices.emplace_back();
|
|
|
|
{ // UuidGraph
|
|
std::apply(
|
|
[&](const auto&... args) {
|
|
auto res = g.passIndex.emplace(std::piecewise_construct, std::forward_as_tuple(args...), std::forward_as_tuple(v));
|
|
CC_ENSURES(res.second);
|
|
},
|
|
c0);
|
|
}
|
|
|
|
std::apply(
|
|
[&](auto&&... args) {
|
|
g.passID.emplace_back(std::forward<decltype(args)>(args)...);
|
|
},
|
|
std::forward<Component0>(c0));
|
|
|
|
std::apply(
|
|
[&](auto&&... args) {
|
|
g.passResource.emplace_back(std::forward<decltype(args)>(args)...);
|
|
},
|
|
std::forward<Component1>(c1));
|
|
|
|
std::apply(
|
|
[&](auto&&... args) {
|
|
g.rpInfo.emplace_back(std::forward<decltype(args)>(args)...);
|
|
},
|
|
std::forward<Component2>(c2));
|
|
|
|
std::apply(
|
|
[&](auto&&... args) {
|
|
g.barrier.emplace_back(std::forward<decltype(args)>(args)...);
|
|
},
|
|
std::forward<Component3>(c3));
|
|
|
|
return v;
|
|
}
|
|
|
|
// IncidenceGraph
|
|
inline RelationGraph::vertex_descriptor
|
|
source(const RelationGraph::edge_descriptor& e, const RelationGraph& /*g*/) noexcept {
|
|
return e.source;
|
|
}
|
|
|
|
inline RelationGraph::vertex_descriptor
|
|
target(const RelationGraph::edge_descriptor& e, const RelationGraph& /*g*/) noexcept {
|
|
return e.target;
|
|
}
|
|
|
|
inline std::pair<RelationGraph::out_edge_iterator, RelationGraph::out_edge_iterator>
|
|
out_edges(RelationGraph::vertex_descriptor u, const RelationGraph& g) noexcept { // NOLINT
|
|
return std::make_pair(
|
|
RelationGraph::out_edge_iterator(const_cast<RelationGraph&>(g).getOutEdgeList(u).begin(), u),
|
|
RelationGraph::out_edge_iterator(const_cast<RelationGraph&>(g).getOutEdgeList(u).end(), u));
|
|
}
|
|
|
|
inline RelationGraph::degree_size_type
|
|
out_degree(RelationGraph::vertex_descriptor u, const RelationGraph& g) noexcept { // NOLINT
|
|
return gsl::narrow_cast<RelationGraph::degree_size_type>(g.getOutEdgeList(u).size());
|
|
}
|
|
|
|
inline std::pair<RelationGraph::edge_descriptor, bool>
|
|
edge(RelationGraph::vertex_descriptor u, RelationGraph::vertex_descriptor v, const RelationGraph& g) noexcept {
|
|
const auto& outEdgeList = g.getOutEdgeList(u);
|
|
auto iter = std::find(outEdgeList.begin(), outEdgeList.end(), RelationGraph::OutEdge(v));
|
|
bool hasEdge = (iter != outEdgeList.end());
|
|
return {RelationGraph::edge_descriptor(u, v), hasEdge};
|
|
}
|
|
|
|
// BidirectionalGraph(Directed)
|
|
inline std::pair<RelationGraph::in_edge_iterator, RelationGraph::in_edge_iterator>
|
|
in_edges(RelationGraph::vertex_descriptor u, const RelationGraph& g) noexcept { // NOLINT
|
|
return std::make_pair(
|
|
RelationGraph::in_edge_iterator(const_cast<RelationGraph&>(g).getInEdgeList(u).begin(), u),
|
|
RelationGraph::in_edge_iterator(const_cast<RelationGraph&>(g).getInEdgeList(u).end(), u));
|
|
}
|
|
|
|
inline RelationGraph::degree_size_type
|
|
in_degree(RelationGraph::vertex_descriptor u, const RelationGraph& g) noexcept { // NOLINT
|
|
return gsl::narrow_cast<RelationGraph::degree_size_type>(g.getInEdgeList(u).size());
|
|
}
|
|
|
|
inline RelationGraph::degree_size_type
|
|
degree(RelationGraph::vertex_descriptor u, const RelationGraph& g) noexcept {
|
|
return in_degree(u, g) + out_degree(u, g);
|
|
}
|
|
|
|
// AdjacencyGraph
|
|
inline std::pair<RelationGraph::adjacency_iterator, RelationGraph::adjacency_iterator>
|
|
adjacent_vertices(RelationGraph::vertex_descriptor u, const RelationGraph& g) noexcept { // NOLINT
|
|
auto edges = out_edges(u, g);
|
|
return std::make_pair(RelationGraph::adjacency_iterator(edges.first, &g), RelationGraph::adjacency_iterator(edges.second, &g));
|
|
}
|
|
|
|
// VertexListGraph
|
|
inline std::pair<RelationGraph::vertex_iterator, RelationGraph::vertex_iterator>
|
|
vertices(const RelationGraph& g) noexcept {
|
|
return std::make_pair(const_cast<RelationGraph&>(g).getVertexList().begin(), const_cast<RelationGraph&>(g).getVertexList().end());
|
|
}
|
|
|
|
inline RelationGraph::vertices_size_type
|
|
num_vertices(const RelationGraph& g) noexcept { // NOLINT
|
|
return gsl::narrow_cast<RelationGraph::vertices_size_type>(g.getVertexList().size());
|
|
}
|
|
|
|
// EdgeListGraph
|
|
inline std::pair<RelationGraph::edge_iterator, RelationGraph::edge_iterator>
|
|
edges(const RelationGraph& g0) noexcept {
|
|
auto& g = const_cast<RelationGraph&>(g0);
|
|
return std::make_pair(
|
|
RelationGraph::edge_iterator(g.getVertexList().begin(), g.getVertexList().begin(), g.getVertexList().end(), g),
|
|
RelationGraph::edge_iterator(g.getVertexList().begin(), g.getVertexList().end(), g.getVertexList().end(), g));
|
|
}
|
|
|
|
inline RelationGraph::edges_size_type
|
|
num_edges(const RelationGraph& g) noexcept { // NOLINT
|
|
RelationGraph::edges_size_type numEdges = 0;
|
|
|
|
auto range = vertices(g);
|
|
for (auto iter = range.first; iter != range.second; ++iter) {
|
|
numEdges += out_degree(*iter, g);
|
|
}
|
|
return numEdges;
|
|
}
|
|
|
|
// MutableGraph(Edge)
|
|
inline std::pair<RelationGraph::edge_descriptor, bool>
|
|
add_edge( // NOLINT
|
|
RelationGraph::vertex_descriptor u,
|
|
RelationGraph::vertex_descriptor v, RelationGraph& g) {
|
|
auto& outEdgeList = g.getOutEdgeList(u);
|
|
outEdgeList.emplace_back(v);
|
|
|
|
auto& inEdgeList = g.getInEdgeList(v);
|
|
inEdgeList.emplace_back(u);
|
|
|
|
return std::make_pair(RelationGraph::edge_descriptor(u, v), true);
|
|
}
|
|
|
|
inline void remove_edge(RelationGraph::vertex_descriptor u, RelationGraph::vertex_descriptor v, RelationGraph& g) noexcept { // NOLINT
|
|
auto& s = g._vertices[u];
|
|
auto& t = g._vertices[v];
|
|
s.outEdges.erase(std::remove(s.outEdges.begin(), s.outEdges.end(), RelationGraph::OutEdge(v)), s.outEdges.end());
|
|
t.inEdges.erase(std::remove(t.inEdges.begin(), t.inEdges.end(), RelationGraph::InEdge(u)), t.inEdges.end());
|
|
}
|
|
|
|
inline void remove_edge(RelationGraph::out_edge_iterator outIter, RelationGraph& g) noexcept { // NOLINT
|
|
auto e = *outIter;
|
|
const auto u = source(e, g);
|
|
const auto v = target(e, g);
|
|
auto& s = g._vertices[u];
|
|
auto& t = g._vertices[v];
|
|
auto inIter = std::find(t.inEdges.begin(), t.inEdges.end(), RelationGraph::InEdge(u));
|
|
CC_EXPECTS(inIter != t.inEdges.end());
|
|
t.inEdges.erase(inIter);
|
|
s.outEdges.erase(outIter.base());
|
|
}
|
|
|
|
inline void remove_edge(RelationGraph::edge_descriptor e, RelationGraph& g) noexcept { // NOLINT
|
|
const auto u = source(e, g);
|
|
const auto v = target(e, g);
|
|
auto& s = g._vertices[u];
|
|
auto outIter = std::find(s.outEdges.begin(), s.outEdges.end(), RelationGraph::OutEdge(v));
|
|
CC_EXPECTS(outIter != s.outEdges.end());
|
|
remove_edge(RelationGraph::out_edge_iterator(outIter, u), g);
|
|
}
|
|
|
|
// MutableGraph(Vertex)
|
|
inline void clear_out_edges(RelationGraph::vertex_descriptor u, RelationGraph& g) noexcept { // NOLINT
|
|
// Bidirectional (OutEdges)
|
|
auto& outEdgeList = g.getOutEdgeList(u);
|
|
auto outEnd = outEdgeList.end();
|
|
for (auto iter = outEdgeList.begin(); iter != outEnd; ++iter) {
|
|
auto& inEdgeList = g.getInEdgeList((*iter).get_target());
|
|
// eraseFromIncidenceList
|
|
impl::sequenceEraseIf(inEdgeList, [u](const auto& e) {
|
|
return e.get_target() == u;
|
|
});
|
|
}
|
|
outEdgeList.clear();
|
|
}
|
|
|
|
inline void clear_in_edges(RelationGraph::vertex_descriptor u, RelationGraph& g) noexcept { // NOLINT
|
|
// Bidirectional (InEdges)
|
|
auto& inEdgeList = g.getInEdgeList(u);
|
|
auto inEnd = inEdgeList.end();
|
|
for (auto iter = inEdgeList.begin(); iter != inEnd; ++iter) {
|
|
auto& outEdgeList = g.getOutEdgeList((*iter).get_target());
|
|
// eraseFromIncidenceList
|
|
impl::sequenceEraseIf(outEdgeList, [u](const auto& e) {
|
|
return e.get_target() == u;
|
|
});
|
|
}
|
|
inEdgeList.clear();
|
|
}
|
|
|
|
inline void clear_vertex(RelationGraph::vertex_descriptor u, RelationGraph& g) noexcept { // NOLINT
|
|
clear_out_edges(u, g);
|
|
clear_in_edges(u, g);
|
|
}
|
|
|
|
inline void remove_vertex(RelationGraph::vertex_descriptor u, RelationGraph& g) noexcept { // NOLINT
|
|
{ // UuidGraph
|
|
const auto& key = g.descID[u];
|
|
auto num = g.vertexMap.erase(key);
|
|
CC_ENSURES(num == 1);
|
|
for (auto&& pair : g.vertexMap) {
|
|
auto& v = pair.second;
|
|
if (v > u) {
|
|
--v;
|
|
}
|
|
}
|
|
}
|
|
impl::removeVectorVertex(const_cast<RelationGraph&>(g), u, RelationGraph::directed_category{});
|
|
|
|
// remove components
|
|
g.descID.erase(g.descID.begin() + static_cast<std::ptrdiff_t>(u));
|
|
}
|
|
|
|
// MutablePropertyGraph(Vertex)
|
|
template <class Component0>
|
|
inline RelationGraph::vertex_descriptor
|
|
addVertex(Component0&& c0, RelationGraph& g) {
|
|
auto v = gsl::narrow_cast<RelationGraph::vertex_descriptor>(g._vertices.size());
|
|
|
|
g._vertices.emplace_back();
|
|
|
|
{ // UuidGraph
|
|
const auto& uuid = c0;
|
|
auto res = g.vertexMap.emplace(uuid, v);
|
|
CC_ENSURES(res.second);
|
|
}
|
|
g.descID.emplace_back(std::forward<Component0>(c0));
|
|
|
|
return v;
|
|
}
|
|
|
|
template <class Component0>
|
|
inline RelationGraph::vertex_descriptor
|
|
addVertex(std::piecewise_construct_t /*tag*/, Component0&& c0, RelationGraph& g) {
|
|
auto v = gsl::narrow_cast<RelationGraph::vertex_descriptor>(g._vertices.size());
|
|
|
|
g._vertices.emplace_back();
|
|
|
|
{ // UuidGraph
|
|
std::apply(
|
|
[&](const auto&... args) {
|
|
auto res = g.vertexMap.emplace(std::piecewise_construct, std::forward_as_tuple(args...), std::forward_as_tuple(v));
|
|
CC_ENSURES(res.second);
|
|
},
|
|
c0);
|
|
}
|
|
|
|
std::apply(
|
|
[&](auto&&... args) {
|
|
g.descID.emplace_back(std::forward<decltype(args)>(args)...);
|
|
},
|
|
std::forward<Component0>(c0));
|
|
|
|
return v;
|
|
}
|
|
|
|
} // namespace render
|
|
|
|
} // namespace cc
|
|
|
|
namespace boost {
|
|
|
|
// Vertex Index
|
|
template <>
|
|
struct property_map<cc::render::ResourceAccessGraph, vertex_index_t> {
|
|
using const_type = identity_property_map;
|
|
using type = identity_property_map;
|
|
};
|
|
|
|
// Vertex Component
|
|
template <>
|
|
struct property_map<cc::render::ResourceAccessGraph, cc::render::ResourceAccessGraph::PassIDTag> {
|
|
using const_type = cc::render::impl::VectorVertexComponentPropertyMap<
|
|
lvalue_property_map_tag,
|
|
const cc::render::ResourceAccessGraph,
|
|
const ccstd::pmr::vector<cc::render::RenderGraph::vertex_descriptor>,
|
|
cc::render::RenderGraph::vertex_descriptor,
|
|
const cc::render::RenderGraph::vertex_descriptor&>;
|
|
using type = cc::render::impl::VectorVertexComponentPropertyMap<
|
|
lvalue_property_map_tag,
|
|
cc::render::ResourceAccessGraph,
|
|
ccstd::pmr::vector<cc::render::RenderGraph::vertex_descriptor>,
|
|
cc::render::RenderGraph::vertex_descriptor,
|
|
cc::render::RenderGraph::vertex_descriptor&>;
|
|
};
|
|
|
|
// Vertex Component
|
|
template <>
|
|
struct property_map<cc::render::ResourceAccessGraph, cc::render::ResourceAccessGraph::PassNodeTag> {
|
|
using const_type = cc::render::impl::VectorVertexComponentPropertyMap<
|
|
lvalue_property_map_tag,
|
|
const cc::render::ResourceAccessGraph,
|
|
const ccstd::pmr::vector<cc::render::ResourceAccessNode>,
|
|
cc::render::ResourceAccessNode,
|
|
const cc::render::ResourceAccessNode&>;
|
|
using type = cc::render::impl::VectorVertexComponentPropertyMap<
|
|
lvalue_property_map_tag,
|
|
cc::render::ResourceAccessGraph,
|
|
ccstd::pmr::vector<cc::render::ResourceAccessNode>,
|
|
cc::render::ResourceAccessNode,
|
|
cc::render::ResourceAccessNode&>;
|
|
};
|
|
|
|
// Vertex ComponentMember
|
|
template <class T>
|
|
struct property_map<cc::render::ResourceAccessGraph, T cc::render::ResourceAccessNode::*> {
|
|
using const_type = cc::render::impl::VectorVertexComponentMemberPropertyMap<
|
|
lvalue_property_map_tag,
|
|
const cc::render::ResourceAccessGraph,
|
|
const ccstd::pmr::vector<cc::render::ResourceAccessNode>,
|
|
T,
|
|
const T&,
|
|
T cc::render::ResourceAccessNode::*>;
|
|
using type = cc::render::impl::VectorVertexComponentMemberPropertyMap<
|
|
lvalue_property_map_tag,
|
|
cc::render::ResourceAccessGraph,
|
|
ccstd::pmr::vector<cc::render::ResourceAccessNode>,
|
|
T,
|
|
T&,
|
|
T cc::render::ResourceAccessNode::*>;
|
|
};
|
|
|
|
// Vertex Component
|
|
template <>
|
|
struct property_map<cc::render::ResourceAccessGraph, cc::render::ResourceAccessGraph::RenderPassInfoTag> {
|
|
using const_type = cc::render::impl::VectorVertexComponentPropertyMap<
|
|
lvalue_property_map_tag,
|
|
const cc::render::ResourceAccessGraph,
|
|
const ccstd::pmr::vector<cc::render::FGRenderPassInfo>,
|
|
cc::render::FGRenderPassInfo,
|
|
const cc::render::FGRenderPassInfo&>;
|
|
using type = cc::render::impl::VectorVertexComponentPropertyMap<
|
|
lvalue_property_map_tag,
|
|
cc::render::ResourceAccessGraph,
|
|
ccstd::pmr::vector<cc::render::FGRenderPassInfo>,
|
|
cc::render::FGRenderPassInfo,
|
|
cc::render::FGRenderPassInfo&>;
|
|
};
|
|
|
|
// Vertex ComponentMember
|
|
template <class T>
|
|
struct property_map<cc::render::ResourceAccessGraph, T cc::render::FGRenderPassInfo::*> {
|
|
using const_type = cc::render::impl::VectorVertexComponentMemberPropertyMap<
|
|
lvalue_property_map_tag,
|
|
const cc::render::ResourceAccessGraph,
|
|
const ccstd::pmr::vector<cc::render::FGRenderPassInfo>,
|
|
T,
|
|
const T&,
|
|
T cc::render::FGRenderPassInfo::*>;
|
|
using type = cc::render::impl::VectorVertexComponentMemberPropertyMap<
|
|
lvalue_property_map_tag,
|
|
cc::render::ResourceAccessGraph,
|
|
ccstd::pmr::vector<cc::render::FGRenderPassInfo>,
|
|
T,
|
|
T&,
|
|
T cc::render::FGRenderPassInfo::*>;
|
|
};
|
|
|
|
// Vertex Component
|
|
template <>
|
|
struct property_map<cc::render::ResourceAccessGraph, cc::render::ResourceAccessGraph::BarrierTag> {
|
|
using const_type = cc::render::impl::VectorVertexComponentPropertyMap<
|
|
lvalue_property_map_tag,
|
|
const cc::render::ResourceAccessGraph,
|
|
const ccstd::pmr::vector<cc::render::BarrierNode>,
|
|
cc::render::BarrierNode,
|
|
const cc::render::BarrierNode&>;
|
|
using type = cc::render::impl::VectorVertexComponentPropertyMap<
|
|
lvalue_property_map_tag,
|
|
cc::render::ResourceAccessGraph,
|
|
ccstd::pmr::vector<cc::render::BarrierNode>,
|
|
cc::render::BarrierNode,
|
|
cc::render::BarrierNode&>;
|
|
};
|
|
|
|
// Vertex ComponentMember
|
|
template <class T>
|
|
struct property_map<cc::render::ResourceAccessGraph, T cc::render::BarrierNode::*> {
|
|
using const_type = cc::render::impl::VectorVertexComponentMemberPropertyMap<
|
|
lvalue_property_map_tag,
|
|
const cc::render::ResourceAccessGraph,
|
|
const ccstd::pmr::vector<cc::render::BarrierNode>,
|
|
T,
|
|
const T&,
|
|
T cc::render::BarrierNode::*>;
|
|
using type = cc::render::impl::VectorVertexComponentMemberPropertyMap<
|
|
lvalue_property_map_tag,
|
|
cc::render::ResourceAccessGraph,
|
|
ccstd::pmr::vector<cc::render::BarrierNode>,
|
|
T,
|
|
T&,
|
|
T cc::render::BarrierNode::*>;
|
|
};
|
|
|
|
// Vertex Index
|
|
template <>
|
|
struct property_map<cc::render::RelationGraph, vertex_index_t> {
|
|
using const_type = identity_property_map;
|
|
using type = identity_property_map;
|
|
};
|
|
|
|
// Vertex Component
|
|
template <>
|
|
struct property_map<cc::render::RelationGraph, cc::render::RelationGraph::DescIDTag> {
|
|
using const_type = cc::render::impl::VectorVertexComponentPropertyMap<
|
|
lvalue_property_map_tag,
|
|
const cc::render::RelationGraph,
|
|
const ccstd::pmr::vector<cc::render::ResourceAccessGraph::vertex_descriptor>,
|
|
cc::render::ResourceAccessGraph::vertex_descriptor,
|
|
const cc::render::ResourceAccessGraph::vertex_descriptor&>;
|
|
using type = cc::render::impl::VectorVertexComponentPropertyMap<
|
|
lvalue_property_map_tag,
|
|
cc::render::RelationGraph,
|
|
ccstd::pmr::vector<cc::render::ResourceAccessGraph::vertex_descriptor>,
|
|
cc::render::ResourceAccessGraph::vertex_descriptor,
|
|
cc::render::ResourceAccessGraph::vertex_descriptor&>;
|
|
};
|
|
|
|
} // namespace boost
|
|
|
|
namespace cc {
|
|
|
|
namespace render {
|
|
|
|
// Vertex Index
|
|
inline boost::property_map<ResourceAccessGraph, boost::vertex_index_t>::const_type
|
|
get(boost::vertex_index_t /*tag*/, const ResourceAccessGraph& /*g*/) noexcept {
|
|
return {};
|
|
}
|
|
|
|
inline boost::property_map<ResourceAccessGraph, boost::vertex_index_t>::type
|
|
get(boost::vertex_index_t /*tag*/, ResourceAccessGraph& /*g*/) noexcept {
|
|
return {};
|
|
}
|
|
|
|
inline impl::ColorMap<ResourceAccessGraph::vertex_descriptor>
|
|
get(ccstd::pmr::vector<boost::default_color_type>& colors, const ResourceAccessGraph& /*g*/) noexcept {
|
|
return {colors};
|
|
}
|
|
|
|
// Vertex Component
|
|
inline typename boost::property_map<ResourceAccessGraph, ResourceAccessGraph::PassIDTag>::const_type
|
|
get(ResourceAccessGraph::PassIDTag /*tag*/, const ResourceAccessGraph& g) noexcept {
|
|
return {g.passID};
|
|
}
|
|
|
|
inline typename boost::property_map<ResourceAccessGraph, ResourceAccessGraph::PassIDTag>::type
|
|
get(ResourceAccessGraph::PassIDTag /*tag*/, ResourceAccessGraph& g) noexcept {
|
|
return {g.passID};
|
|
}
|
|
|
|
// Vertex Component
|
|
inline typename boost::property_map<ResourceAccessGraph, ResourceAccessGraph::PassNodeTag>::const_type
|
|
get(ResourceAccessGraph::PassNodeTag /*tag*/, const ResourceAccessGraph& g) noexcept {
|
|
return {g.passResource};
|
|
}
|
|
|
|
inline typename boost::property_map<ResourceAccessGraph, ResourceAccessGraph::PassNodeTag>::type
|
|
get(ResourceAccessGraph::PassNodeTag /*tag*/, ResourceAccessGraph& g) noexcept {
|
|
return {g.passResource};
|
|
}
|
|
|
|
// Vertex ComponentMember
|
|
template <class T>
|
|
inline typename boost::property_map<ResourceAccessGraph, T ResourceAccessNode::*>::const_type
|
|
get(T ResourceAccessNode::*memberPointer, const ResourceAccessGraph& g) noexcept {
|
|
return {g.passResource, memberPointer};
|
|
}
|
|
|
|
template <class T>
|
|
inline typename boost::property_map<ResourceAccessGraph, T ResourceAccessNode::*>::type
|
|
get(T ResourceAccessNode::*memberPointer, ResourceAccessGraph& g) noexcept {
|
|
return {g.passResource, memberPointer};
|
|
}
|
|
|
|
// Vertex Component
|
|
inline typename boost::property_map<ResourceAccessGraph, ResourceAccessGraph::RenderPassInfoTag>::const_type
|
|
get(ResourceAccessGraph::RenderPassInfoTag /*tag*/, const ResourceAccessGraph& g) noexcept {
|
|
return {g.rpInfo};
|
|
}
|
|
|
|
inline typename boost::property_map<ResourceAccessGraph, ResourceAccessGraph::RenderPassInfoTag>::type
|
|
get(ResourceAccessGraph::RenderPassInfoTag /*tag*/, ResourceAccessGraph& g) noexcept {
|
|
return {g.rpInfo};
|
|
}
|
|
|
|
// Vertex ComponentMember
|
|
template <class T>
|
|
inline typename boost::property_map<ResourceAccessGraph, T FGRenderPassInfo::*>::const_type
|
|
get(T FGRenderPassInfo::*memberPointer, const ResourceAccessGraph& g) noexcept {
|
|
return {g.rpInfo, memberPointer};
|
|
}
|
|
|
|
template <class T>
|
|
inline typename boost::property_map<ResourceAccessGraph, T FGRenderPassInfo::*>::type
|
|
get(T FGRenderPassInfo::*memberPointer, ResourceAccessGraph& g) noexcept {
|
|
return {g.rpInfo, memberPointer};
|
|
}
|
|
|
|
// Vertex Component
|
|
inline typename boost::property_map<ResourceAccessGraph, ResourceAccessGraph::BarrierTag>::const_type
|
|
get(ResourceAccessGraph::BarrierTag /*tag*/, const ResourceAccessGraph& g) noexcept {
|
|
return {g.barrier};
|
|
}
|
|
|
|
inline typename boost::property_map<ResourceAccessGraph, ResourceAccessGraph::BarrierTag>::type
|
|
get(ResourceAccessGraph::BarrierTag /*tag*/, ResourceAccessGraph& g) noexcept {
|
|
return {g.barrier};
|
|
}
|
|
|
|
// Vertex ComponentMember
|
|
template <class T>
|
|
inline typename boost::property_map<ResourceAccessGraph, T BarrierNode::*>::const_type
|
|
get(T BarrierNode::*memberPointer, const ResourceAccessGraph& g) noexcept {
|
|
return {g.barrier, memberPointer};
|
|
}
|
|
|
|
template <class T>
|
|
inline typename boost::property_map<ResourceAccessGraph, T BarrierNode::*>::type
|
|
get(T BarrierNode::*memberPointer, ResourceAccessGraph& g) noexcept {
|
|
return {g.barrier, memberPointer};
|
|
}
|
|
|
|
// Vertex Constant Getter
|
|
template <class Tag>
|
|
inline decltype(auto)
|
|
get(Tag tag, const ResourceAccessGraph& g, ResourceAccessGraph::vertex_descriptor v) noexcept {
|
|
return get(get(tag, g), v);
|
|
}
|
|
|
|
// Vertex Mutable Getter
|
|
template <class Tag>
|
|
inline decltype(auto)
|
|
get(Tag tag, ResourceAccessGraph& g, ResourceAccessGraph::vertex_descriptor v) noexcept {
|
|
return get(get(tag, g), v);
|
|
}
|
|
|
|
// Vertex Setter
|
|
template <class Tag, class... Args>
|
|
inline void put(
|
|
Tag tag, ResourceAccessGraph& g,
|
|
ResourceAccessGraph::vertex_descriptor v,
|
|
Args&&... args) {
|
|
put(get(tag, g), v, std::forward<Args>(args)...);
|
|
}
|
|
|
|
// UuidGraph
|
|
inline ResourceAccessGraph::vertex_descriptor
|
|
vertex(const RenderGraph::vertex_descriptor& key, const ResourceAccessGraph& g) {
|
|
return g.passIndex.at(key);
|
|
}
|
|
|
|
template <class KeyLike>
|
|
inline ResourceAccessGraph::vertex_descriptor
|
|
vertex(const KeyLike& key, const ResourceAccessGraph& g) {
|
|
const auto& index = g.passIndex;
|
|
auto iter = index.find(key);
|
|
if (iter == index.end()) {
|
|
throw std::out_of_range("at(key, ResourceAccessGraph) out of range");
|
|
}
|
|
return iter->second;
|
|
}
|
|
|
|
template <class KeyLike>
|
|
inline ResourceAccessGraph::vertex_descriptor
|
|
findVertex(const KeyLike& key, const ResourceAccessGraph& g) noexcept {
|
|
const auto& index = g.passIndex;
|
|
auto iter = index.find(key);
|
|
if (iter == index.end()) {
|
|
return ResourceAccessGraph::null_vertex();
|
|
}
|
|
return iter->second;
|
|
}
|
|
|
|
inline bool
|
|
contains(const RenderGraph::vertex_descriptor& key, const ResourceAccessGraph& g) noexcept {
|
|
auto iter = g.passIndex.find(key);
|
|
return iter != g.passIndex.end();
|
|
}
|
|
|
|
template <class KeyLike>
|
|
inline bool
|
|
contains(const KeyLike& key, const ResourceAccessGraph& g) noexcept {
|
|
auto iter = g.passIndex.find(key);
|
|
return iter != g.passIndex.end();
|
|
}
|
|
|
|
// MutableGraph(Vertex)
|
|
inline ResourceAccessGraph::vertex_descriptor
|
|
add_vertex(ResourceAccessGraph& g, const RenderGraph::vertex_descriptor& key) { // NOLINT
|
|
return addVertex(
|
|
std::piecewise_construct,
|
|
std::forward_as_tuple(key), // passID
|
|
std::forward_as_tuple(), // passResource
|
|
std::forward_as_tuple(), // rpInfo
|
|
std::forward_as_tuple(), // barrier
|
|
g);
|
|
}
|
|
|
|
// Vertex Index
|
|
inline boost::property_map<RelationGraph, boost::vertex_index_t>::const_type
|
|
get(boost::vertex_index_t /*tag*/, const RelationGraph& /*g*/) noexcept {
|
|
return {};
|
|
}
|
|
|
|
inline boost::property_map<RelationGraph, boost::vertex_index_t>::type
|
|
get(boost::vertex_index_t /*tag*/, RelationGraph& /*g*/) noexcept {
|
|
return {};
|
|
}
|
|
|
|
inline impl::ColorMap<RelationGraph::vertex_descriptor>
|
|
get(ccstd::pmr::vector<boost::default_color_type>& colors, const RelationGraph& /*g*/) noexcept {
|
|
return {colors};
|
|
}
|
|
|
|
// Vertex Component
|
|
inline typename boost::property_map<RelationGraph, RelationGraph::DescIDTag>::const_type
|
|
get(RelationGraph::DescIDTag /*tag*/, const RelationGraph& g) noexcept {
|
|
return {g.descID};
|
|
}
|
|
|
|
inline typename boost::property_map<RelationGraph, RelationGraph::DescIDTag>::type
|
|
get(RelationGraph::DescIDTag /*tag*/, RelationGraph& g) noexcept {
|
|
return {g.descID};
|
|
}
|
|
|
|
// Vertex Constant Getter
|
|
template <class Tag>
|
|
inline decltype(auto)
|
|
get(Tag tag, const RelationGraph& g, RelationGraph::vertex_descriptor v) noexcept {
|
|
return get(get(tag, g), v);
|
|
}
|
|
|
|
// Vertex Mutable Getter
|
|
template <class Tag>
|
|
inline decltype(auto)
|
|
get(Tag tag, RelationGraph& g, RelationGraph::vertex_descriptor v) noexcept {
|
|
return get(get(tag, g), v);
|
|
}
|
|
|
|
// Vertex Setter
|
|
template <class Tag, class... Args>
|
|
inline void put(
|
|
Tag tag, RelationGraph& g,
|
|
RelationGraph::vertex_descriptor v,
|
|
Args&&... args) {
|
|
put(get(tag, g), v, std::forward<Args>(args)...);
|
|
}
|
|
|
|
// UuidGraph
|
|
inline RelationGraph::vertex_descriptor
|
|
vertex(const ResourceAccessGraph::vertex_descriptor& key, const RelationGraph& g) {
|
|
return g.vertexMap.at(key);
|
|
}
|
|
|
|
template <class KeyLike>
|
|
inline RelationGraph::vertex_descriptor
|
|
vertex(const KeyLike& key, const RelationGraph& g) {
|
|
const auto& index = g.vertexMap;
|
|
auto iter = index.find(key);
|
|
if (iter == index.end()) {
|
|
throw std::out_of_range("at(key, RelationGraph) out of range");
|
|
}
|
|
return iter->second;
|
|
}
|
|
|
|
template <class KeyLike>
|
|
inline RelationGraph::vertex_descriptor
|
|
findVertex(const KeyLike& key, const RelationGraph& g) noexcept {
|
|
const auto& index = g.vertexMap;
|
|
auto iter = index.find(key);
|
|
if (iter == index.end()) {
|
|
return RelationGraph::null_vertex();
|
|
}
|
|
return iter->second;
|
|
}
|
|
|
|
inline bool
|
|
contains(const ResourceAccessGraph::vertex_descriptor& key, const RelationGraph& g) noexcept {
|
|
auto iter = g.vertexMap.find(key);
|
|
return iter != g.vertexMap.end();
|
|
}
|
|
|
|
template <class KeyLike>
|
|
inline bool
|
|
contains(const KeyLike& key, const RelationGraph& g) noexcept {
|
|
auto iter = g.vertexMap.find(key);
|
|
return iter != g.vertexMap.end();
|
|
}
|
|
|
|
// MutableGraph(Vertex)
|
|
inline RelationGraph::vertex_descriptor
|
|
add_vertex(RelationGraph& g, const ResourceAccessGraph::vertex_descriptor& key) { // NOLINT
|
|
return addVertex(
|
|
std::piecewise_construct,
|
|
std::forward_as_tuple(key), // descID
|
|
g);
|
|
}
|
|
|
|
} // namespace render
|
|
|
|
} // namespace cc
|
|
|
|
// clang-format on
|
|
|