eden-emu/eden
24
3
Fork 15
Code Issues 138 Pull requests 56 Projects 1 Releases Packages Wiki Activity Actions

[common] remove ranges polyfill
Some checks failed
eden-license / license-header (pull_request) Failing after 18s
Details

Browse source 
Signed-off-by: lizzie <lizzie@eden-emu.dev>
This commit is contained in:
lizzie 2025-09-21 14:12:48 +00:00 • committed by crueter
parent 191e4c75a1
commit e9ce8c9ad4
38 changed files with 37 additions and 567 deletions
Download patch file Download diff file Expand all files Collapse all files

2
src/audio_core/audio_event.cpp
View file

@ -3,7 +3,7 @@
#include "audio_core/audio_event.h"
#include "common/assert.h"
#include "common/polyfill_ranges.h"
#include <ranges>
namespace AudioCore {

2
src/audio_core/common/feature_support.h
View file

@ -13,7 +13,7 @@
#include "common/assert.h"
#include "common/common_funcs.h"
#include "common/common_types.h"
#include "common/polyfill_ranges.h"
#include <ranges>
namespace AudioCore {
constexpr u32 CurrentRevision = 16;

2
src/audio_core/renderer/command/effect/i3dl2_reverb.cpp
View file

@ -8,7 +8,7 @@
#include "audio_core/adsp/apps/audio_renderer/command_list_processor.h"
#include "audio_core/renderer/command/effect/i3dl2_reverb.h"
#include "common/polyfill_ranges.h"
#include <ranges>
namespace AudioCore::Renderer {

2
src/audio_core/renderer/command/effect/reverb.cpp
View file

@ -9,7 +9,7 @@
#include "audio_core/adsp/apps/audio_renderer/command_list_processor.h"
#include "audio_core/renderer/command/effect/reverb.h"
#include "common/polyfill_ranges.h"
#include <ranges>
namespace AudioCore::Renderer {

2
src/audio_core/renderer/mix/mix_context.cpp
View file

@ -8,7 +8,7 @@
#include "audio_core/renderer/mix/mix_context.h"
#include "audio_core/renderer/splitter/splitter_context.h"
#include "common/polyfill_ranges.h"
#include <ranges>
namespace AudioCore::Renderer {

2
src/audio_core/renderer/voice/voice_context.cpp
View file

@ -4,7 +4,7 @@
#include <ranges>
#include "audio_core/renderer/voice/voice_context.h"
#include "common/polyfill_ranges.h"
#include <ranges>
namespace AudioCore::Renderer {

2
src/common/fs/fs_util.cpp
View file

@ -4,7 +4,7 @@
#include <algorithm>
#include "common/fs/fs_util.h"
#include "common/polyfill_ranges.h"
#include <ranges>
namespace Common::FS {

530
src/common/polyfill_ranges.h
View file

@ -1,530 +0,0 @@
// SPDX-FileCopyrightText: 2022 yuzu Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
//
// TODO: remove this file when ranges are supported by all compilation targets
//
#pragma once
#include <algorithm>
#include <utility>
#include <version>
#ifndef __cpp_lib_ranges
namespace std {
namespace ranges {
template <typename T>
concept range = requires(T& t) {
begin(t);
end(t);
};
template <typename T>
concept input_range = range<T>;
template <typename T>
concept output_range = range<T>;
template <range R>
using range_difference_t = ptrdiff_t;
//
// find, find_if, find_if_not
//
struct find_fn {
template <typename Iterator, typename T, typename Proj = std::identity>
constexpr Iterator operator()(Iterator first, Iterator last, const T& value,
Proj proj = {}) const {
for (; first != last; ++first) {
if (std::invoke(proj, *first) == value) {
return first;
}
}
return first;
}
template <ranges::input_range R, typename T, typename Proj = std::identity>
constexpr ranges::iterator_t<R> operator()(R&& r, const T& value, Proj proj = {}) const {
return operator()(ranges::begin(r), ranges::end(r), value, std::ref(proj));
}
};
struct find_if_fn {
template <typename Iterator, typename Proj = std::identity, typename Pred>
constexpr Iterator operator()(Iterator first, Iterator last, Pred pred, Proj proj = {}) const {
for (; first != last; ++first) {
if (std::invoke(pred, std::invoke(proj, *first))) {
return first;
}
}
return first;
}
template <ranges::input_range R, typename Proj = std::identity, typename Pred>
constexpr ranges::iterator_t<R> operator()(R&& r, Pred pred, Proj proj = {}) const {
return operator()(ranges::begin(r), ranges::end(r), std::ref(pred), std::ref(proj));
}
};
struct find_if_not_fn {
template <typename Iterator, typename Proj = std::identity, typename Pred>
constexpr Iterator operator()(Iterator first, Iterator last, Pred pred, Proj proj = {}) const {
for (; first != last; ++first) {
if (!std::invoke(pred, std::invoke(proj, *first))) {
return first;
}
}
return first;
}
template <ranges::input_range R, typename Proj = std::identity, typename Pred>
constexpr ranges::iterator_t<R> operator()(R&& r, Pred pred, Proj proj = {}) const {
return operator()(ranges::begin(r), ranges::end(r), std::ref(pred), std::ref(proj));
}
};
inline constexpr find_fn find;
inline constexpr find_if_fn find_if;
inline constexpr find_if_not_fn find_if_not;
//
// any_of, all_of, none_of
//
struct all_of_fn {
template <typename Iterator, typename Proj = std::identity, typename Pred>
constexpr bool operator()(Iterator first, Iterator last, Pred pred, Proj proj = {}) const {
return ranges::find_if_not(first, last, std::ref(pred), std::ref(proj)) == last;
}
template <ranges::input_range R, typename Proj = std::identity, typename Pred>
constexpr bool operator()(R&& r, Pred pred, Proj proj = {}) const {
return operator()(ranges::begin(r), ranges::end(r), std::ref(pred), std::ref(proj));
}
};
struct any_of_fn {
template <typename Iterator, typename Proj = std::identity, typename Pred>
constexpr bool operator()(Iterator first, Iterator last, Pred pred, Proj proj = {}) const {
return ranges::find_if(first, last, std::ref(pred), std::ref(proj)) != last;
}
template <ranges::input_range R, typename Proj = std::identity, typename Pred>
constexpr bool operator()(R&& r, Pred pred, Proj proj = {}) const {
return operator()(ranges::begin(r), ranges::end(r), std::ref(pred), std::ref(proj));
}
};
struct none_of_fn {
template <typename Iterator, typename Proj = std::identity, typename Pred>
constexpr bool operator()(Iterator first, Iterator last, Pred pred, Proj proj = {}) const {
return ranges::find_if(first, last, std::ref(pred), std::ref(proj)) == last;
}
template <ranges::input_range R, typename Proj = std::identity, typename Pred>
constexpr bool operator()(R&& r, Pred pred, Proj proj = {}) const {
return operator()(ranges::begin(r), ranges::end(r), std::ref(pred), std::ref(proj));
}
};
inline constexpr any_of_fn any_of;
inline constexpr all_of_fn all_of;
inline constexpr none_of_fn none_of;
//
// count, count_if
//
struct count_fn {
template <typename Iterator, typename T, typename Proj = std::identity>
constexpr ptrdiff_t operator()(Iterator first, Iterator last, const T& value,
Proj proj = {}) const {
ptrdiff_t counter = 0;
for (; first != last; ++first)
if (std::invoke(proj, *first) == value)
++counter;
return counter;
}
template <ranges::input_range R, typename T, typename Proj = std::identity>
constexpr ptrdiff_t operator()(R&& r, const T& value, Proj proj = {}) const {
return operator()(ranges::begin(r), ranges::end(r), value, std::ref(proj));
}
};
struct count_if_fn {
template <typename Iterator, typename Proj = std::identity, typename Pred>
constexpr ptrdiff_t operator()(Iterator first, Iterator last, Pred pred, Proj proj = {}) const {
ptrdiff_t counter = 0;
for (; first != last; ++first)
if (std::invoke(pred, std::invoke(proj, *first)))
++counter;
return counter;
}
template <ranges::input_range R, typename Proj = std::identity, typename Pred>
constexpr ptrdiff_t operator()(R&& r, Pred pred, Proj proj = {}) const {
return operator()(ranges::begin(r), ranges::end(r), std::ref(pred), std::ref(proj));
}
};
inline constexpr count_fn count;
inline constexpr count_if_fn count_if;
//
// transform
//
struct transform_fn {
template <typename InputIterator, typename OutputIterator, typename F,
typename Proj = std::identity>
constexpr void operator()(InputIterator first1, InputIterator last1, OutputIterator result,
F op, Proj proj = {}) const {
for (; first1 != last1; ++first1, (void)++result) {
*result = std::invoke(op, std::invoke(proj, *first1));
}
}
template <ranges::input_range R, typename OutputIterator, typename F,
typename Proj = std::identity>
constexpr void operator()(R&& r, OutputIterator result, F op, Proj proj = {}) const {
return operator()(ranges::begin(r), ranges::end(r), result, std::ref(op), std::ref(proj));
}
};
inline constexpr transform_fn transform;
//
// sort
//
struct sort_fn {
template <typename Iterator, typename Comp = ranges::less, typename Proj = std::identity>
constexpr void operator()(Iterator first, Iterator last, Comp comp = {}, Proj proj = {}) const {
if (first == last)
return;
Iterator last_iter = ranges::next(first, last);
std::sort(first, last_iter,
[&](auto& lhs, auto& rhs) { return comp(proj(lhs), proj(rhs)); });
}
template <ranges::input_range R, typename Comp = ranges::less, typename Proj = std::identity>
constexpr void operator()(R&& r, Comp comp = {}, Proj proj = {}) const {
return operator()(ranges::begin(r), ranges::end(r), std::move(comp), std::move(proj));
}
};
inline constexpr sort_fn sort;
//
// fill
//
struct fill_fn {
template <typename T, typename OutputIterator>
constexpr OutputIterator operator()(OutputIterator first, OutputIterator last,
const T& value) const {
while (first != last) {
*first++ = value;
}
return first;
}
template <typename T, ranges::output_range R>
constexpr ranges::iterator_t<R> operator()(R&& r, const T& value) const {
return operator()(ranges::begin(r), ranges::end(r), value);
}
};
inline constexpr fill_fn fill;
//
// for_each
//
struct for_each_fn {
template <typename Iterator, typename Proj = std::identity, typename Fun>
constexpr void operator()(Iterator first, Iterator last, Fun f, Proj proj = {}) const {
for (; first != last; ++first) {
std::invoke(f, std::invoke(proj, *first));
}
}
template <ranges::input_range R, typename Proj = std::identity, typename Fun>
constexpr void operator()(R&& r, Fun f, Proj proj = {}) const {
return operator()(ranges::begin(r), ranges::end(r), std::move(f), std::ref(proj));
}
};
inline constexpr for_each_fn for_each;
//
// min_element, max_element
//
struct min_element_fn {
template <typename Iterator, typename Proj = std::identity, typename Comp = ranges::less>
constexpr Iterator operator()(Iterator first, Iterator last, Comp comp = {},
Proj proj = {}) const {
if (first == last) {
return last;
}
auto smallest = first;
++first;
for (; first != last; ++first) {
if (!std::invoke(comp, std::invoke(proj, *smallest), std::invoke(proj, *first))) {
smallest = first;
}
}
return smallest;
}
template <ranges::input_range R, typename Proj = std::identity, typename Comp = ranges::less>
constexpr ranges::iterator_t<R> operator()(R&& r, Comp comp = {}, Proj proj = {}) const {
return operator()(ranges::begin(r), ranges::end(r), std::ref(comp), std::ref(proj));
}
};
struct max_element_fn {
template <typename Iterator, typename Proj = std::identity, typename Comp = ranges::less>
constexpr Iterator operator()(Iterator first, Iterator last, Comp comp = {},
Proj proj = {}) const {
if (first == last) {
return last;
}
auto largest = first;
++first;
for (; first != last; ++first) {
if (std::invoke(comp, std::invoke(proj, *largest), std::invoke(proj, *first))) {
largest = first;
}
}
return largest;
}
template <ranges::input_range R, typename Proj = std::identity, typename Comp = ranges::less>
constexpr ranges::iterator_t<R> operator()(R&& r, Comp comp = {}, Proj proj = {}) const {
return operator()(ranges::begin(r), ranges::end(r), std::ref(comp), std::ref(proj));
}
};
inline constexpr min_element_fn min_element;
inline constexpr max_element_fn max_element;
//
// replace, replace_if
//
struct replace_fn {
template <typename Iterator, typename T1, typename T2, typename Proj = std::identity>
constexpr Iterator operator()(Iterator first, Iterator last, const T1& old_value,
const T2& new_value, Proj proj = {}) const {
for (; first != last; ++first) {
if (old_value == std::invoke(proj, *first)) {
*first = new_value;
}
}
return first;
}
template <ranges::input_range R, typename T1, typename T2, typename Proj = std::identity>
constexpr ranges::iterator_t<R> operator()(R&& r, const T1& old_value, const T2& new_value,
Proj proj = {}) const {
return operator()(ranges::begin(r), ranges::end(r), old_value, new_value, std::move(proj));
}
};
struct replace_if_fn {
template <typename Iterator, typename T, typename Proj = std::identity, typename Pred>
constexpr Iterator operator()(Iterator first, Iterator last, Pred pred, const T& new_value,
Proj proj = {}) const {
for (; first != last; ++first) {
if (!!std::invoke(pred, std::invoke(proj, *first))) {
*first = new_value;
}
}
return std::move(first);
}
template <ranges::input_range R, typename T, typename Proj = std::identity, typename Pred>
constexpr ranges::iterator_t<R> operator()(R&& r, Pred pred, const T& new_value,
Proj proj = {}) const {
return operator()(ranges::begin(r), ranges::end(r), std::move(pred), new_value,
std::move(proj));
}
};
inline constexpr replace_fn replace;
inline constexpr replace_if_fn replace_if;
//
// copy, copy_if
//
struct copy_fn {
template <typename InputIterator, typename OutputIterator>
constexpr void operator()(InputIterator first, InputIterator last,
OutputIterator result) const {
for (; first != last; ++first, (void)++result) {
*result = *first;
}
}
template <ranges::input_range R, typename OutputIterator>
constexpr void operator()(R&& r, OutputIterator result) const {
return operator()(ranges::begin(r), ranges::end(r), std::move(result));
}
};
struct copy_if_fn {
template <typename InputIterator, typename OutputIterator, typename Proj = std::identity,
typename Pred>
constexpr void operator()(InputIterator first, InputIterator last, OutputIterator result,
Pred pred, Proj proj = {}) const {
for (; first != last; ++first) {
if (std::invoke(pred, std::invoke(proj, *first))) {
*result = *first;
++result;
}
}
}
template <ranges::input_range R, typename OutputIterator, typename Proj = std::identity,
typename Pred>
constexpr void operator()(R&& r, OutputIterator result, Pred pred, Proj proj = {}) const {
return operator()(ranges::begin(r), ranges::end(r), std::move(result), std::ref(pred),
std::ref(proj));
}
};
inline constexpr copy_fn copy;
inline constexpr copy_if_fn copy_if;
//
// generate
//
struct generate_fn {
template <typename Iterator, typename F>
constexpr Iterator operator()(Iterator first, Iterator last, F gen) const {
for (; first != last; *first = std::invoke(gen), ++first)
;
return first;
}
template <typename R, std::copy_constructible F>
requires std::invocable<F&> && ranges::output_range<R>
constexpr ranges::iterator_t<R> operator()(R&& r, F gen) const {
return operator()(ranges::begin(r), ranges::end(r), std::move(gen));
}
};
inline constexpr generate_fn generate;
//
// lower_bound, upper_bound
//
struct lower_bound_fn {
template <typename Iterator, typename T, typename Proj = std::identity,
typename Comp = ranges::less>
constexpr Iterator operator()(Iterator first, Iterator last, const T& value, Comp comp = {},
Proj proj = {}) const {
Iterator it;
std::ptrdiff_t _count, _step;
_count = std::distance(first, last);
while (_count > 0) {
it = first;
_step = _count / 2;
ranges::advance(it, _step, last);
if (comp(std::invoke(proj, *it), value)) {
first = ++it;
_count -= _step + 1;
} else {
_count = _step;
}
}
return first;
}
template <ranges::input_range R, typename T, typename Proj = std::identity,
typename Comp = ranges::less>
constexpr ranges::iterator_t<R> operator()(R&& r, const T& value, Comp comp = {},
Proj proj = {}) const {
return operator()(ranges::begin(r), ranges::end(r), value, std::ref(comp), std::ref(proj));
}
};
struct upper_bound_fn {
template <typename Iterator, typename T, typename Proj = std::identity,
typename Comp = ranges::less>
constexpr Iterator operator()(Iterator first, Iterator last, const T& value, Comp comp = {},
Proj proj = {}) const {
Iterator it;
std::ptrdiff_t _count, _step;
_count = std::distance(first, last);
while (_count > 0) {
it = first;
_step = _count / 2;
ranges::advance(it, _step, last);
if (!comp(value, std::invoke(proj, *it))) {
first = ++it;
_count -= _step + 1;
} else {
_count = _step;
}
}
return first;
}
template <ranges::input_range R, typename T, typename Proj = std::identity,
typename Comp = ranges::less>
constexpr ranges::iterator_t<R> operator()(R&& r, const T& value, Comp comp = {},
Proj proj = {}) const {
return operator()(ranges::begin(r), ranges::end(r), value, std::ref(comp), std::ref(proj));
}
};
inline constexpr lower_bound_fn lower_bound;
inline constexpr upper_bound_fn upper_bound;
//
// adjacent_find
//
struct adjacent_find_fn {
template <typename Iterator, typename Proj = std::identity, typename Pred = ranges::equal_to>
constexpr Iterator operator()(Iterator first, Iterator last, Pred pred = {},
Proj proj = {}) const {
if (first == last)
return first;
auto _next = ranges::next(first);
for (; _next != last; ++_next, ++first)
if (std::invoke(pred, std::invoke(proj, *first), std::invoke(proj, *_next)))
return first;
return _next;
}
template <ranges::input_range R, typename Proj = std::identity,
typename Pred = ranges::equal_to>
constexpr ranges::iterator_t<R> operator()(R&& r, Pred pred = {}, Proj proj = {}) const {
return operator()(ranges::begin(r), ranges::end(r), std::ref(pred), std::ref(proj));
}
};
inline constexpr adjacent_find_fn adjacent_find;
} // namespace ranges
} // namespace std
#endif

2
src/common/slot_vector.h
View file

@ -15,7 +15,7 @@
#include "common/assert.h"
#include "common/common_types.h"
#include "common/polyfill_ranges.h"
#include <ranges>
namespace Common {

2
src/core/file_sys/content_archive.cpp
View file

@ -10,7 +10,7 @@
#include <utility>
#include "common/logging/log.h"
#include "common/polyfill_ranges.h"
#include <ranges>
#include "core/crypto/aes_util.h"
#include "core/crypto/ctr_encryption_layer.h"
#include "core/crypto/key_manager.h"

2
src/core/hle/kernel/k_thread_local_page.h
View file

@ -10,7 +10,7 @@
#include "common/assert.h"
#include "common/common_types.h"
#include "common/intrusive_red_black_tree.h"
#include "common/polyfill_ranges.h"
#include <ranges>
#include "core/hle/kernel/memory_types.h"
#include "core/hle/kernel/slab_helpers.h"
#include "core/hle/result.h"

2
src/core/hle/service/acc/acc.cpp
View file

@ -11,7 +11,7 @@
#include "common/fs/file.h"
#include "common/fs/path_util.h"
#include "common/logging/log.h"
#include "common/polyfill_ranges.h"
#include <ranges>
#include "common/stb.h"
#include "common/string_util.h"
#include "common/swap.h"

2
src/core/hle/service/acc/profile_manager.cpp
View file

@ -12,7 +12,7 @@
#include "common/fs/file.h"
#include "common/fs/fs.h"
#include "common/fs/path_util.h"
#include "common/polyfill_ranges.h"
#include <ranges>
#include "common/settings.h"
#include "common/string_util.h"
#include "core/hle/service/acc/profile_manager.h"

2
src/core/internal_network/network_interface.cpp
View file

@ -9,7 +9,7 @@
#include "common/bit_cast.h"
#include "common/common_types.h"
#include "common/logging/log.h"
#include "common/polyfill_ranges.h"
#include <ranges>
#include "common/settings.h"
#include "common/string_util.h"
#include "core/internal_network/emu_net_state.h"

2
src/hid_core/frontend/emulated_controller.cpp
View file

@ -8,7 +8,7 @@
#include <chrono>
#include <common/scope_exit.h>
#include "common/polyfill_ranges.h"
#include <ranges>
#include "common/thread.h"
#include "hid_core/frontend/emulated_controller.h"
#include "hid_core/frontend/input_converter.h"

2
src/input_common/drivers/joycon.cpp
View file

@ -4,7 +4,7 @@
#include <fmt/ranges.h>
#include "common/param_package.h"
#include "common/polyfill_ranges.h"
#include <ranges>
#include "common/polyfill_thread.h"
#include "common/settings.h"
#include "common/thread.h"

2
src/shader_recompiler/frontend/ir/opcodes.h
View file

@ -8,7 +8,7 @@
#include <fmt/ranges.h>
#include "common/polyfill_ranges.h"
#include <ranges>
#include "shader_recompiler/frontend/ir/type.h"
namespace Shader::IR {

2
src/shader_recompiler/frontend/maxwell/control_flow.cpp
View file

@ -9,7 +9,7 @@
#include <fmt/ranges.h>
#include "common/polyfill_ranges.h"
#include <ranges>
#include "shader_recompiler/exception.h"
#include "shader_recompiler/frontend/maxwell/control_flow.h"
#include "shader_recompiler/frontend/maxwell/decode.h"

2
src/shader_recompiler/frontend/maxwell/decode.cpp
View file

@ -9,7 +9,7 @@
#include <memory>
#include "common/common_types.h"
#include "common/polyfill_ranges.h"
#include <ranges>
#include "shader_recompiler/exception.h"
#include "shader_recompiler/frontend/maxwell/decode.h"
#include "shader_recompiler/frontend/maxwell/opcodes.h"

2
src/shader_recompiler/frontend/maxwell/structured_control_flow.cpp
View file

@ -12,7 +12,7 @@
#include <boost/intrusive/list.hpp>
#include "common/polyfill_ranges.h"
#include <ranges>
#include "shader_recompiler/environment.h"
#include "shader_recompiler/frontend/ir/basic_block.h"
#include "shader_recompiler/frontend/ir/ir_emitter.h"

2
src/video_core/engines/maxwell_dma.cpp
View file

@ -7,7 +7,7 @@
#include "common/algorithm.h"
#include "common/assert.h"
#include "common/logging/log.h"
#include "common/polyfill_ranges.h"
#include <ranges>
#include "common/settings.h"
#include "core/core.h"
#include "video_core/engines/maxwell_3d.h"

2
src/video_core/renderer_opengl/gl_device.cpp
View file

@ -14,7 +14,7 @@
#include "common/literals.h"
#include "common/logging/log.h"
#include "common/polyfill_ranges.h"
#include <ranges>
#include "common/settings.h"
#include "shader_recompiler/stage.h"
#include "video_core/renderer_opengl/gl_device.h"

2
src/video_core/renderer_vulkan/fixed_pipeline_state.cpp
View file

@ -7,7 +7,7 @@
#include "common/bit_cast.h"
#include "common/cityhash.h"
#include "common/common_types.h"
#include "common/polyfill_ranges.h"
#include <ranges>
#include "video_core/engines/draw_manager.h"
#include "video_core/renderer_vulkan/fixed_pipeline_state.h"
#include "video_core/renderer_vulkan/vk_state_tracker.h"

2
src/video_core/renderer_vulkan/present/smaa.cpp
View file

@ -4,7 +4,7 @@
#include <list>
#include "common/assert.h"
#include "common/polyfill_ranges.h"
#include <ranges>
#include "video_core/renderer_vulkan/present/smaa.h"
#include "video_core/renderer_vulkan/present/util.h"

2
src/video_core/renderer_vulkan/present/util.cpp
View file

@ -5,7 +5,7 @@
// SPDX-License-Identifier: GPL-2.0-or-later
#include "common/assert.h"
#include "common/polyfill_ranges.h"
#include <ranges>
#include "video_core/renderer_vulkan/present/util.h"
namespace Vulkan {

2
src/video_core/renderer_vulkan/renderer_vulkan.cpp
View file

@ -15,7 +15,7 @@
#include <fmt/ranges.h>
#include "common/logging/log.h"
#include "common/polyfill_ranges.h"
#include <ranges>
#include "common/scope_exit.h"
#include "common/settings.h"
#include "core/core_timing.h"

2
src/video_core/renderer_vulkan/vk_descriptor_pool.cpp
View file

@ -7,7 +7,7 @@
#include <vector>
#include "common/common_types.h"
#include "common/polyfill_ranges.h"
#include <ranges>
#include "video_core/renderer_vulkan/vk_descriptor_pool.h"
#include "video_core/renderer_vulkan/vk_resource_pool.h"
#include "video_core/renderer_vulkan/vk_scheduler.h"

2
src/video_core/renderer_vulkan/vk_master_semaphore.cpp
View file

@ -6,7 +6,7 @@
#include <thread>
#include "common/polyfill_ranges.h"
#include <ranges>
#include "common/settings.h"
#include "video_core/renderer_vulkan/vk_master_semaphore.h"
#include "video_core/vulkan_common/vulkan_device.h"

2
src/video_core/renderer_vulkan/vk_swapchain.cpp
View file

@ -10,7 +10,7 @@
#include <vector>
#include "common/logging/log.h"
#include "common/polyfill_ranges.h"
#include <ranges>
#include "common/settings.h"
#include "core/core.h"
#include "video_core/renderer_vulkan/vk_scheduler.h"

2
src/video_core/shader_cache.h
View file

@ -12,7 +12,7 @@
#include <vector>
#include "common/common_types.h"
#include "common/polyfill_ranges.h"
#include <ranges>
#include "video_core/control/channel_state_cache.h"
#include "video_core/host1x/gpu_device_memory_manager.h"
#include "video_core/rasterizer_interface.h"

2
src/video_core/shader_environment.cpp
View file

@ -18,7 +18,7 @@
#include "common/fs/fs.h"
#include "common/fs/path_util.h"
#include "common/logging/log.h"
#include "common/polyfill_ranges.h"
#include <ranges>
#include "shader_recompiler/environment.h"
#include "video_core/engines/kepler_compute.h"
#include "video_core/memory_manager.h"

2
src/video_core/texture_cache/formatter.cpp
View file

@ -7,7 +7,7 @@
#include <algorithm>
#include <string>
#include "common/polyfill_ranges.h"
#include <ranges>
#include "video_core/texture_cache/formatter.h"
#include "video_core/texture_cache/image_base.h"
#include "video_core/texture_cache/image_info.h"

2
src/video_core/texture_cache/texture_cache_base.h
View file

@ -22,7 +22,7 @@
#include "common/hash.h"
#include "common/literals.h"
#include "common/lru_cache.h"
#include "common/polyfill_ranges.h"
#include <ranges>
#include "common/scratch_buffer.h"
#include "common/slot_vector.h"
#include "common/thread_worker.h"

2
src/video_core/textures/astc.cpp
View file

@ -18,7 +18,7 @@
#include "common/alignment.h"
#include "common/common_types.h"
#include "common/polyfill_ranges.h"
#include <ranges>
#include "video_core/textures/astc.h"
#include "video_core/textures/workers.h"

2
src/video_core/transform_feedback.cpp
View file

@ -10,7 +10,7 @@
#include "common/alignment.h"
#include "common/assert.h"
#include "common/polyfill_ranges.h"
#include <ranges>
#include "shader_recompiler/shader_info.h"
#include "video_core/transform_feedback.h"

2
src/video_core/vulkan_common/vulkan_device.cpp
View file

@ -15,7 +15,7 @@
#include "common/assert.h"
#include "common/literals.h"
#include "common/polyfill_ranges.h"
#include <ranges>
#include "common/settings.h"
#include "video_core/vulkan_common/nsight_aftermath_tracker.h"
#include "video_core/vulkan_common/vma.h"

2
src/video_core/vulkan_common/vulkan_instance.cpp
View file

@ -9,7 +9,7 @@
#include "common/common_types.h"
#include "common/dynamic_library.h"
#include "common/logging/log.h"
#include "common/polyfill_ranges.h"
#include <ranges>
#include "core/frontend/emu_window.h"
#include "video_core/vulkan_common/vulkan_instance.h"
#include "video_core/vulkan_common/vulkan_wrapper.h"

2
src/video_core/vulkan_common/vulkan_memory_allocator.cpp
View file

@ -17,7 +17,7 @@
#include "common/common_types.h"
#include "common/literals.h"
#include "common/logging/log.h"
#include "common/polyfill_ranges.h"
#include <ranges>
#include "video_core/vulkan_common/vma.h"
#include "video_core/vulkan_common/vulkan_device.h"
#include "video_core/vulkan_common/vulkan_memory_allocator.h"