birkeh/o3de
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Updated all array_view uses with the C++20 span. (#7157)

Browse Source 
* Updated all array_view uses with the C++20 span.

The updates were done in the following order
1. `AZStd::array_view<([^>].+)\* ?>`  -> `AZStd::span<\1 const>`
2. `AZStd::array_view<(?:const )(.+)>` -> `AZStd::span<const \1>`
3. `AZStd::array_view` -> `AZStd::span`

Removed the implementation of array_view.

Signed-off-by: lumberyard-employee-dm <56135373+lumberyard-employee-dm@users.noreply.github.com>

* Added missing whitespace between `const` and the typename for spans.

Updated the ShaderTest comparison of the ShaderResourceGroupLayout span
to compare the sizes as well

Updated comments on some of the methods that stated that they return "an
array" to mention they return "a span".

Signed-off-by: lumberyard-employee-dm <56135373+lumberyard-employee-dm@users.noreply.github.com>
This commit is contained in:
lumberyard-employee-dm
2022-01-26 16:15:47 -06:00
committed by GitHub
parent 48cea89910
commit b9824ed172
170 changed files with 833 additions and 1274 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Code/Framework/AtomCore/AtomCore/atomcore_files.cmake
-1
View File
@@ -13,7 +13,6 @@ set(FILES
Instance/InstanceData.h
Instance/InstanceData.cpp
Instance/InstanceDatabase.h
std/containers/array_view.h
std/containers/fixed_vector_set.h
std/containers/lru_cache.h
std/containers/vector_set.h
Code/Framework/AtomCore/AtomCore/std/containers/array_view.h
-156
View File
@@ -1,156 +0,0 @@
/*
* Copyright (c) Contributors to the Open 3D Engine Project.
* For complete copyright and license terms please see the LICENSE at the root of this distribution.
*
* SPDX-License-Identifier: Apache-2.0 OR MIT
*
*/
#pragma once
#include <AzCore/std/containers/vector.h>
#include <AzCore/std/containers/fixed_vector.h>
#include <AzCore/std/containers/array.h>
namespace AZStd
{
/**
* Immutable wrapper for an array of data. It does not maintain storage for the data,
* but just holds pointers to mark the beginning and end of the array. It can be
* conveniently constructed from a variety of other container types like array,
* vector, and fixed_vector.
*
* Example:
* Given "void Func(AZStd::array_view<int> a) {...}" you can call...
* - Func({1,2,3});
* - AZStd::array<int,3> a = {1,2,3};
* Func(a);
* - AZStd::vector<int> v = {1,2,3};
* Func(v);
* - AZStd::fixed_vector<int,10> fv = {1,2,3};
* Func(fv);
*
* Since the array_view does not copy and store any data, it is only valid as long as the data used to create it is valid.
*/
template <class Element>
class array_view final
{
public:
using value_type = Element;
using pointer = value_type*;
using const_pointer = const value_type*;
using reference = value_type&;
using const_reference = const value_type&;
using size_type = AZStd::size_t;
using difference_type = AZStd::ptrdiff_t;
using iterator = const value_type*;
using const_iterator = const value_type*;
using reverse_iterator = AZStd::reverse_iterator<iterator>;
using const_reverse_iterator = AZStd::reverse_iterator<const_iterator>;
array_view()
: m_begin(nullptr)
, m_end(nullptr)
{ }
~array_view() = default;
array_view(const_pointer s, size_type length)
: m_begin(s)
, m_end(m_begin + length)
{
if (length == 0) erase();
}
array_view(const_pointer first, const_pointer last)
: m_begin(first)
, m_end(last)
{ }
// We explicitly delete this constructor because it's too easy to accidentally
// create an array_view to just the first element instead of an entire array.
array_view(const_pointer s) = delete;
template<AZStd::size_t N>
array_view(const AZStd::array<value_type, N>& data)
: m_begin(data.data())
, m_end(m_begin + data.size())
{ }
array_view(const AZStd::vector<value_type>& data)
: m_begin(data.data())
, m_end(m_begin + data.size())
{ }
template<AZStd::size_t N>
array_view(const AZStd::fixed_vector<value_type, N>& data)
: m_begin(data.data())
, m_end(m_begin + data.size())
{ }
array_view(const array_view&) = default;
array_view(array_view&& other)
: array_view(other.m_begin, other.m_end)
{
#if AZ_DEBUG_BUILD // Clearing the original pointers isn't necessary, but is good for debugging
other.m_begin = nullptr;
other.m_end = nullptr;
#endif
}
array_view& operator=(const array_view& other) = default;
array_view& operator=(array_view&& other)
{
m_begin = other.m_begin;
m_end = other.m_end;
#if AZ_DEBUG_BUILD // Clearing the original pointers isn't necessary, but is good for debugging
other.m_begin = nullptr;
other.m_end = nullptr;
#endif
return *this;
}
size_type size() const { return m_end - m_begin; }
bool empty() const { return m_end == m_begin; }
const_pointer data() const { return m_begin; }
const_reference operator[](size_type index) const
{
AZ_Assert(index < size(), "index value is out of range");
return m_begin[index];
}
void erase() { m_begin = m_end = nullptr; }
iterator begin() const { return m_begin; }
iterator end() const { return m_end; }
const_iterator cbegin() const { return m_begin; }
const_iterator cend() const { return m_end; }
reverse_iterator rbegin() const { return reverse_iterator(m_end); }
reverse_iterator rend() const { return reverse_iterator(m_begin); }
const_reverse_iterator crbegin() const { return const_reverse_iterator(cend()); }
const_reverse_iterator crend() const { return const_reverse_iterator(cbegin()); }
friend bool operator==(array_view lhs, array_view rhs)
{
return lhs.m_begin == rhs.m_begin && lhs.m_end == rhs.m_end;
}
friend bool operator!=(array_view lhs, array_view rhs) { return !(lhs == rhs); }
friend bool operator< (array_view lhs, array_view rhs) { return lhs.m_begin < rhs.m_begin || lhs.m_begin == rhs.m_begin && lhs.m_end < rhs.m_end; }
friend bool operator> (array_view lhs, array_view rhs) { return lhs.m_begin > rhs.m_begin || lhs.m_begin == rhs.m_begin && lhs.m_end > rhs.m_end; }
friend bool operator<=(array_view lhs, array_view rhs) { return lhs == rhs || lhs < rhs; }
friend bool operator>=(array_view lhs, array_view rhs) { return lhs == rhs || lhs > rhs; }
private:
const_pointer m_begin;
const_pointer m_end;
};
} // namespace AZStd
Code/Framework/AtomCore/Tests/ArrayView.cpp
-300
View File
@@ -1,300 +0,0 @@
/*
* Copyright (c) Contributors to the Open 3D Engine Project.
* For complete copyright and license terms please see the LICENSE at the root of this distribution.
*
* SPDX-License-Identifier: Apache-2.0 OR MIT
*
*/
#include <AtomCore/std/containers/array_view.h>
#include <AzCore/std/containers/array.h>
#include <AzCore/UnitTest/TestTypes.h>
namespace UnitTest
{
using namespace AZStd;
class ArrayView : public AllocatorsTestFixture
{
protected:
template<typename T>
void ExpectEqual(initializer_list<T> expectedValues, array_view<T> arrayView)
{
EXPECT_EQ(false, arrayView.empty());
EXPECT_EQ(expectedValues.size(), arrayView.size());
typename AZStd::vector<T>::const_iterator iterator = arrayView.begin();
for (int i = 0; i < expectedValues.size(); ++i, ++iterator)
{
EXPECT_EQ(expectedValues.begin()[i], arrayView[i]);
EXPECT_EQ(expectedValues.begin()[i], *iterator);
}
EXPECT_EQ(iterator, arrayView.end());
}
};
TEST_F(ArrayView, DefaultConstructor)
{
array_view<bool> defaultView;
EXPECT_EQ(nullptr, defaultView.begin());
EXPECT_EQ(nullptr, defaultView.end());
EXPECT_EQ(0, defaultView.size());
EXPECT_EQ(true, defaultView.empty());
}
TEST_F(ArrayView, PointerConstructor1)
{
int originalValues[4] = { 2,3,4,5 };
array_view<int> view(originalValues, AZ_ARRAY_SIZE(originalValues));
ExpectEqual({ 2,3,4,5 }, view);
EXPECT_EQ(originalValues, view.begin());
EXPECT_EQ(&originalValues[4], view.end());
}
TEST_F(ArrayView, PointerConstructor2)
{
int originalValues[3] = { 6,7,8 };
array_view<int> view(originalValues, &originalValues[3]);
ExpectEqual({ 6,7,8 }, view);
EXPECT_EQ(originalValues, view.begin());
EXPECT_EQ(&originalValues[3], view.end());
}
TEST_F(ArrayView, ArrayConstructor)
{
array<int, 4> originalValues = { 9,10,11,12 };
array_view<int> view(originalValues);
ExpectEqual({ 9,10,11,12 }, view);
EXPECT_EQ(originalValues.begin(), view.begin());
EXPECT_EQ(originalValues.end(), view.end());
}
TEST_F(ArrayView, VectorConstructor)
{
vector<int> originalValues = { 13,14,15,16,17,18 };
array_view<int> view(originalValues);
ExpectEqual({ 13,14,15,16,17,18 }, view);
EXPECT_EQ(originalValues.begin(), view.begin());
EXPECT_EQ(originalValues.end(), view.end());
}
TEST_F(ArrayView, FixedVectorConstructor)
{
fixed_vector<int, 10> originalValues = { 17,18,19 }; // Note that even though the fixed_vector capacity is 10, it's size is 3, so the view size will be 3 as well
array_view<int> view(originalValues);
ExpectEqual({ 17,18,19 }, view);
EXPECT_EQ(originalValues.begin(), view.begin());
EXPECT_EQ(originalValues.end(), view.end());
}
TEST_F(ArrayView, CopyConstructor)
{
fixed_vector<int, 2> originalValues = { 27,28 };
array_view<int> view1(originalValues);
array_view<int> view2(view1);
ExpectEqual({ 27,28 }, view2);
EXPECT_EQ(view1.begin(), view2.begin());
EXPECT_EQ(view1.end(), view2.end());
}
TEST_F(ArrayView, MoveConstructor)
{
int originalValues[] = { 29,30,31 };
array_view<int> view1(originalValues, AZ_ARRAY_SIZE(originalValues));
array_view<int> view2(AZStd::move(view1));
ExpectEqual({ 29,30,31 }, view2);
EXPECT_EQ(originalValues, view2.begin());
EXPECT_EQ(&originalValues[3], view2.end());
// This isn't strictly necessary but is a good way to make sure the move
// constructor actually exists and it itn't just calling the copy constructor
#if AZ_DEBUG_BUILD // The pointers are only cleared in debug
EXPECT_EQ(nullptr, view1.begin());
EXPECT_EQ(nullptr, view1.end());
#endif
}
TEST_F(ArrayView, AssignmentOperator)
{
fixed_vector<int, 4> originalValues = { 32,33,34,35 };
array_view<int> view1(originalValues);
array_view<int> view2;
view2 = view1;
ExpectEqual({ 32,33,34,35 }, view2);
EXPECT_EQ(view1.begin(), view2.begin());
EXPECT_EQ(view1.end(), view2.end());
}
TEST_F(ArrayView, MoveAssignmentOperator)
{
int originalValues[] = { 36,37,38,39,40 };
array_view<int> view1(originalValues, AZ_ARRAY_SIZE(originalValues));
array_view<int> view2;
view2 = AZStd::move(view1);
ExpectEqual({ 36,37,38,39,40 }, view2);
EXPECT_EQ(originalValues, view2.begin());
EXPECT_EQ(&originalValues[5], view2.end());
// This isn't strictly necessary but is a good way to make sure the move
// assignment operator actually exists and it itn't just calling the norm
// assignment operator
#if AZ_DEBUG_BUILD // The pointers are only cleared in debug
EXPECT_EQ(nullptr, view1.begin());
EXPECT_EQ(nullptr, view1.end());
#endif
}
TEST_F(ArrayView, Erase)
{
fixed_vector<int, 4> originalValues = { 1,2,3,4 };
array_view<int> view(originalValues);
view.erase();
EXPECT_EQ(nullptr, view.begin());
EXPECT_EQ(nullptr, view.end());
EXPECT_EQ(0, view.size());
EXPECT_EQ(true, view.empty());
}
TEST_F(ArrayView, BeginAndEnd)
{
fixed_vector<int, 4> originalValues = { 1,2,3,4 };
array_view<int> view(originalValues);
EXPECT_EQ(1, view.begin()[0]);
EXPECT_EQ(4, view.end()[-1]);
EXPECT_EQ(1, view.cbegin()[0]);
EXPECT_EQ(4, view.cend()[-1]);
EXPECT_EQ(4, view.rbegin()[0]);
EXPECT_EQ(1, view.rend()[-1]);
EXPECT_EQ(4, view.crbegin()[0]);
EXPECT_EQ(1, view.crend()[-1]);
}
TEST_F(ArrayView, ImplicitConstruction)
{
// This test verifies that we can pass in various non-array_view types
// into functions that take an array_view
// The compile cannot detect the correct template type so that has to be specified explicitly
ExpectEqual<int>({ 1,2,3 }, vector<int>({ 1,2,3 }));
ExpectEqual<int>({ 1,2,3 }, fixed_vector<int, 3>({ 1,2,3 }));
ExpectEqual<int>({ 1,2,3 }, array<int, 3>({ 1,2,3 }));
}
void CheckComparisonOperators(bool areEqual, array_view<int> a, array_view<int> b)
{
EXPECT_EQ(areEqual, a == b);
// For less/greater operators, the exact order doesn't really matter;
// We just check for internal consistency
if (areEqual)
{
EXPECT_EQ(false, a != b);
EXPECT_EQ(false, a < b);
EXPECT_EQ(false, a > b);
EXPECT_EQ(true, a <= b);
EXPECT_EQ(true, a >= b);
}
else
{
EXPECT_EQ(true, a != b);
EXPECT_EQ(a > b, a >= b);
EXPECT_EQ(a < b, a <= b);
EXPECT_NE(a > b, a < b);
EXPECT_NE(a >= b, a <= b);
EXPECT_NE(a >= b, a < b);
EXPECT_NE(a > b, a <= b);
EXPECT_NE(a <= b, a > b);
EXPECT_NE(a < b, a >= b);
}
}
TEST_F(ArrayView, ComparisonOperators)
{
int arrayA[] = { 1,2,3 };
int arrayB[] = { 1,2,3 };
array_view<int> arrayA_view(arrayA, 3);
array_view<int> arrayB_view(arrayB, 3);
array_view<int> arrayA_otherView(arrayA, 3);
// view of a sub-array aligned to the beginning of the array
array_view<int> arrayA_headView(arrayA, 2);
array_view<int> arrayB_headView(arrayB, 2);
// view of a sub-array aligned to the end of the array
array_view<int> arrayA_tailView(&arrayA[1], 2);
array_view<int> arrayB_tailView(&arrayB[1], 2);
// view of a sub-array in the middle of the array
array_view<int> arrayA_centerView(&arrayA[1], 1);
array_view<int> arrayB_centerView(&arrayB[1], 1);
// Same view
CheckComparisonOperators(true, arrayA_view, arrayA_view);
// Different view, same array
CheckComparisonOperators(true, arrayA_view, arrayA_otherView);
CheckComparisonOperators(true, arrayA_otherView, arrayA_view);
// Different arrays
CheckComparisonOperators(false, arrayA_view, arrayB_view);
CheckComparisonOperators(false, arrayB_view, arrayA_view);
// Same arrays, but one is a just a subset of the array
CheckComparisonOperators(false, arrayA_view, arrayA_headView);
CheckComparisonOperators(false, arrayA_view, arrayA_tailView);
CheckComparisonOperators(false, arrayA_view, arrayA_centerView);
CheckComparisonOperators(false, arrayA_headView, arrayA_view);
CheckComparisonOperators(false, arrayA_tailView, arrayA_view);
CheckComparisonOperators(false, arrayA_centerView, arrayA_view);
// Different arrays, different lengths
CheckComparisonOperators(false, arrayA_view, arrayB_headView);
CheckComparisonOperators(false, arrayB_view, arrayA_headView);
CheckComparisonOperators(false, arrayB_headView, arrayA_view);
CheckComparisonOperators(false, arrayA_headView, arrayB_view);
}
TEST_F(ArrayView, AssertOutOfBounds)
{
array_view<int> view({ 1,2,3,4 });
AZ_TEST_START_TRACE_SUPPRESSION;
view[4];
view[5];
AZ_TEST_STOP_TRACE_SUPPRESSION(2);
}
}
Code/Framework/AtomCore/Tests/atomcore_tests_files.cmake
-1
View File
@@ -7,7 +7,6 @@
#
set(FILES
ArrayView.cpp
ConcurrencyCheckerTests.cpp
InstanceDatabase.cpp
lru_cache.cpp
Code/Framework/AzCore/AzCore/std/containers/span.h
+9 -10
View File
@@ -42,12 +42,11 @@ namespace AZStd::Internal
namespace AZStd
{
/**
* First pass partial implementation of span copied over from array_view. It
* returns non-const iterator/pointers. first(), last(), and subspan()
* are yet to be implemented. It does not maintain storage for the data,
* but just holds pointers to mark the beginning and end of the array.
* It can be conveniently constructed from a variety of other container
* types like array, vector, and fixed_vector.
* Full C++20 implementation of span done using the C++ draft at https://eel.is/c++draft/views.
* It does not maintain storage for the data,
* but just hold a pointer to mark the beginning and the size for the elements.
* It can be constructed any type that models the C++ contiguous_range concept
* such like array, vector, fixed_vector, raw-array, string_view, string, etc... .
*
* Example:
* Given "void Func(AZStd::span<int> a) {...}" you can call...
@@ -84,7 +83,7 @@ namespace AZStd
inline static constexpr size_t extent = Extent;
constexpr span() noexcept = default;;
constexpr span() noexcept = default;
~span() = default;
@@ -110,12 +109,12 @@ namespace AZStd
Extent != dynamic_extent, int> = 0>
constexpr explicit span(It first, End last);
template<size_t N, class = enable_if_t<N == dynamic_extent || N == Extent>>
template<size_t N, class = enable_if_t<extent == dynamic_extent || N == Extent>>
constexpr span(type_identity_t<element_type> (&arr)[N]) noexcept;
template <class U, size_t N, class = enable_if_t<N == dynamic_extent || N == Extent>>
template <class U, size_t N, class = enable_if_t<extent == dynamic_extent || N == Extent>>
constexpr span(array<U, N>& data) noexcept;
template <class U, size_t N, class = enable_if_t<N == dynamic_extent || N == Extent>>
template <class U, size_t N, class = enable_if_t<extent == dynamic_extent || N == Extent>>
constexpr span(const array<U, N>& data) noexcept;
template <class R, class = enable_if_t<ranges::contiguous_range<R> &&
Code/Framework/AzCore/Tests/AZStd/SpanTests.cpp
+12
View File
@@ -246,4 +246,16 @@ namespace UnitTest
AZ_TEST_STOP_TRACE_SUPPRESSION(1);
}
}
TEST_F(SpanTestFixture, CanInitializeFixedArrayToDynamicExtentSpan)
{
constexpr size_t arrayElementCount = 5;
static constexpr AZStd::array<int, arrayElementCount> intArray{ 4, 5, 6, 1, 7 };
constexpr AZStd::span<const int, AZStd::dynamic_extent> arraySpan(intArray);
static_assert(intArray.data() == arraySpan.data());
constexpr AZStd::span<const int, arrayElementCount> arraySpanFixedExtent(intArray);
static_assert(intArray.data() == arraySpanFixedExtent.data());
}
}
Gems/Atom/Asset/ImageProcessingAtom/Code/Source/Processing/Utils.cpp
+1 -1
View File
@@ -286,7 +286,7 @@ namespace ImageProcessingAtom
for (u32 slice = 0; slice < arraySize; slice++)
{
AZStd::array_view<uint8_t> imageData = imageAsset->GetSubImageData(mip, slice);
AZStd::span<const uint8_t> imageData = imageAsset->GetSubImageData(mip, slice);
memcpy(imageBuf + slice * imageData.size(), imageData.data(), imageData.size());
}
}
Gems/Atom/Asset/Shader/Code/Tests/SupervariantCmdArgumentTests.cpp
+11 -11
View File
@@ -71,7 +71,7 @@ namespace UnitTest
//! Helper function.
//! Given an input list of {Key, Value} pairs returns a list of strings where each string is of the form: "Key=Value".
AZStd::vector<AZStd::string> CreateListOfStringsFromListOfKeyValues(AZStd::array_view<KeyValueView> listOfKeyValues) const
AZStd::vector<AZStd::string> CreateListOfStringsFromListOfKeyValues(AZStd::span<const KeyValueView> listOfKeyValues) const
{
AZStd::vector<AZStd::string> listOfStrings;
for (const auto& keyValue : listOfKeyValues)
@@ -90,7 +90,7 @@ namespace UnitTest
//! Helper function.
//! Given an input list of {Key, Value} pairs returns a list of strings where each string is of the form: "Key1", "Value1", "Key2", "Value2".
AZStd::vector<AZStd::string> CreateListOfSingleStringsFromListOfKeyValues(AZStd::array_view<KeyValueView> listOfKeyValues) const
AZStd::vector<AZStd::string> CreateListOfSingleStringsFromListOfKeyValues(AZStd::span<const KeyValueView> listOfKeyValues) const
{
AZStd::vector<AZStd::string> listOfStrings;
for (const auto& keyValue : listOfKeyValues)
@@ -134,7 +134,7 @@ namespace UnitTest
//! Returns a command line string that results of concatenating the input list of {Key, Value} pairs (with '=').
//! Example of a returned string:
//! "key1=value1 key2 key3 key4=value"
AZStd::string CreateCmdLineStringFromListOfKeyValues(AZStd::array_view<KeyValueView> listOfKeyValues) const
AZStd::string CreateCmdLineStringFromListOfKeyValues(AZStd::span<const KeyValueView> listOfKeyValues) const
{
AZStd::string cmdLineString;
for (const auto& keyValueView : listOfKeyValues)
@@ -148,7 +148,7 @@ namespace UnitTest
//! Returns a command line string of macro definitions that results of concatenating the input list of {Key, Value} pairs.
//! Example of a returned string:
//! "-Dkey1=value1 -Dkey2 -Dkey3 -Dkey4=value"
AZStd::string CreateMacroDefinitionCmdLineStringFromListOfKeyValues(AZStd::array_view<KeyValueView> listOfKeyValues) const
AZStd::string CreateMacroDefinitionCmdLineStringFromListOfKeyValues(AZStd::span<const KeyValueView> listOfKeyValues) const
{
AZStd::string cmdLineString;
for (const auto& keyValueView : listOfKeyValues)
@@ -161,7 +161,7 @@ namespace UnitTest
//! @param includePaths A List of folder paths
//! @param predefinedMacros A List of strings with format: "name[=value]"
ShaderBuilder::PreprocessorOptions CreatePreprocessorOptions(
AZStd::array_view<AZStd::string> includePaths, AZStd::array_view<AZStd::string> predefinedMacros) const
AZStd::span<const AZStd::string> includePaths, AZStd::span<const AZStd::string> predefinedMacros) const
{
ShaderBuilder::PreprocessorOptions preprocessorOptions;
@@ -200,8 +200,8 @@ namespace UnitTest
//! @param azslcAdditionalFreeArguments A string representing series of command line arguments for AZSLc.
//! @param dxcAdditionalFreeArguments: A string representing series of command line arguments for DXC.
ShaderBuilder::GlobalBuildOptions CreateGlobalBuildOptions(
AZStd::array_view<AZStd::string> includePaths,
AZStd::array_view<AZStd::string> predefinedMacros,
AZStd::span<const AZStd::string> includePaths,
AZStd::span<const AZStd::string> predefinedMacros,
AZStd::string_view azslcAdditionalFreeArguments,
AZStd::string_view dxcAdditionalFreeArguments) const
{
@@ -227,7 +227,7 @@ namespace UnitTest
return supervariantInfo;
}
bool StringContainsAllSubstrings(AZStd::string_view haystack, AZStd::array_view<AZStd::string> substrings)
bool StringContainsAllSubstrings(AZStd::string_view haystack, AZStd::span<const AZStd::string> substrings)
{
return AZStd::all_of(AZ_BEGIN_END(substrings),
[&](AZStd::string_view needle) -> bool
@@ -237,7 +237,7 @@ namespace UnitTest
);
}
bool StringDoesNotContainAnyOneOfTheSubstrings(AZStd::string_view haystack, AZStd::array_view<AZStd::string> substrings)
bool StringDoesNotContainAnyOneOfTheSubstrings(AZStd::string_view haystack, AZStd::span<const AZStd::string> substrings)
{
return AZStd::all_of(AZ_BEGIN_END(substrings), [&](AZStd::string_view needle) -> bool {
return (haystack.find(needle) == AZStd::string::npos);
@@ -247,7 +247,7 @@ namespace UnitTest
//! @returns: True if all strings in @substring appear in @vectorOfString.
//! @remark: Keep in mind that this is not the same as saying that all strings in @vectorOfStrings appear in @substrings.
bool VectorContainsAllSubstrings(
AZStd::array_view<AZStd::string> vectorOfStrings, AZStd::array_view<AZStd::string> substrings)
AZStd::span<const AZStd::string> vectorOfStrings, AZStd::span<const AZStd::string> substrings)
{
return AZStd::all_of(
AZ_BEGIN_END(substrings),
@@ -264,7 +264,7 @@ namespace UnitTest
}
//! @returns: True only if None of the strings in @vectorOfStrings contains any of the strings in @substrings.
bool VectorDoesNotContainAnyOneOfTheSubstrings(AZStd::array_view<AZStd::string> vectorOfStrings, AZStd::array_view<AZStd::string> substrings)
bool VectorDoesNotContainAnyOneOfTheSubstrings(AZStd::span<const AZStd::string> vectorOfStrings, AZStd::span<const AZStd::string> substrings)
{
return AZStd::all_of(AZ_BEGIN_END(vectorOfStrings), [&](AZStd::string_view haystack) -> bool {
return StringDoesNotContainAnyOneOfTheSubstrings(haystack, substrings);
Gems/Atom/Feature/Common/Code/Include/Atom/Feature/SkinnedMesh/SkinnedMeshInputBuffers.h
+4 -4
View File
@@ -27,13 +27,13 @@ namespace AZ
class BufferView;
class IndexBufferView;
}
namespace RPI
{
class Model;
class ShaderResourceGroup;
}
namespace Render
{
//! Info needed to create per-submesh views into the skinned mesh buffers so that the target skinned model can be broken into multiple sub-meshes.
@@ -212,8 +212,8 @@ namespace AZ
//! Get an individual lod
const SkinnedMeshInputLod& GetLod(size_t lodIndex) const;
//! Get an array_view of the buffer views for all the input streams
AZStd::array_view<AZ::RHI::Ptr<RHI::BufferView>> GetInputBufferViews(size_t lodIndex) const;
//! Get a span of the buffer views for all the input streams
AZStd::span<const AZ::RHI::Ptr<RHI::BufferView>> GetInputBufferViews(size_t lodIndex) const;
//! Get the buffer view for a specific input stream
AZ::RHI::Ptr<const RHI::BufferView> GetInputBufferView(size_t lodIndex, uint8_t inputStream) const;
Gems/Atom/Feature/Common/Code/Include/Atom/Feature/Utils/IndexedDataVector.h
+1 -1
View File
@@ -8,7 +8,7 @@
#pragma once
#include <AtomCore/std/containers/array_view.h>
#include <AzCore/std/containers/span.h>
#include <AzCore/std/containers/vector.h>
namespace AZ::Render
Gems/Atom/Feature/Common/Code/Include/Atom/Feature/Utils/MultiIndexedDataVector.h
+1 -1
View File
@@ -9,7 +9,7 @@
#pragma once
#include <AzCore/std/containers/vector.h>
#include <AtomCore/std/containers/array_view.h>
#include <AzCore/std/containers/span.h>
namespace AZ
{
Gems/Atom/Feature/Common/Code/Source/CoreLights/CascadedShadowmapsPass.cpp
+2 -2
View File
@@ -71,7 +71,7 @@ namespace AZ
}
}
const AZStd::array_view<RPI::PipelineViewTag> CascadedShadowmapsPass::GetPipelineViewTags()
const AZStd::span<const RPI::PipelineViewTag> CascadedShadowmapsPass::GetPipelineViewTags()
{
if (m_childrenPipelineViewTags.size() != Shadow::MaxNumberOfCascades)
{
@@ -181,7 +181,7 @@ namespace AZ
RPI::Ptr<ShadowmapPass> CascadedShadowmapsPass::CreateChild(uint16_t cascadeIndex)
{
const AZStd::array_view<RPI::PipelineViewTag> childrenViewTags = GetPipelineViewTags();
const AZStd::span<const RPI::PipelineViewTag> childrenViewTags = GetPipelineViewTags();
const Name passName{ AZStd::string::format("DirectionalLightShadowmapPass.%d", cascadeIndex) };
auto passData = AZStd::make_shared<RPI::RasterPassData>();
Gems/Atom/Feature/Common/Code/Source/CoreLights/CascadedShadowmapsPass.h
+2 -2
View File
@@ -9,7 +9,7 @@
#include <Atom/Feature/CoreLights/CoreLightsConstants.h>
#include <Atom/RPI.Public/Pass/ParentPass.h>
#include <AtomCore/std/containers/array_view.h>
#include <AzCore/std/containers/span.h>
#include <AzCore/std/containers/fixed_vector.h>
#include <CoreLights/ShadowmapAtlas.h>
#include <CoreLights/ShadowmapPass.h>
@@ -36,7 +36,7 @@ namespace AZ
void SetCameraViewName(const AZStd::string& viewName);
//! This returns pipeline view tag for children.
const AZStd::array_view<RPI::PipelineViewTag> GetPipelineViewTags();
const AZStd::span<const RPI::PipelineViewTag> GetPipelineViewTags();
//! This exposes the shadowmap atlas.
ShadowmapAtlas& GetShadowmapAtlas();
Gems/Atom/Feature/Common/Code/Source/CoreLights/DirectionalLightFeatureProcessor.cpp
+1 -1
View File
@@ -1018,7 +1018,7 @@ namespace AZ
for (const auto& passIt : m_cascadedShadowmapsPasses)
{
CascadedShadowmapsPass* shadowPass = passIt.second.front();
const AZStd::array_view<RPI::PipelineViewTag>& viewTags = shadowPass->GetPipelineViewTags();
const AZStd::span<const RPI::PipelineViewTag>& viewTags = shadowPass->GetPipelineViewTags();
AZ_Assert(viewTags.size() >= cascadeCount, "DirectionalLightFeatureProcessor: There is not enough pipeline view tags.");
RPI::RenderPipeline* pipeline = shadowPass->GetRenderPipeline();
Gems/Atom/Feature/Common/Code/Source/CoreLights/EsmShadowmapsPass.cpp
+1 -1
View File
@@ -112,7 +112,7 @@ namespace AZ
m_shadowmapImageSize = inputBinding.m_attachment->m_descriptor.m_image.m_size;
m_shadowmapArraySize = inputBinding.m_attachment->m_descriptor.m_image.m_arraySize;
const AZStd::array_view<RPI::Ptr<RPI::Pass>>& children = GetChildren();
const AZStd::span<const RPI::Ptr<RPI::Pass>>& children = GetChildren();
AZ_Assert(children.size() == EsmChildPassKindCount, "[EsmShadowmapsPass '%s'] The count of children is wrong.", GetPathName().GetCStr());
for (uint32_t childPassIndex = 0; childPassIndex < EsmChildPassKindCount; ++childPassIndex)
Gems/Atom/Feature/Common/Code/Source/CoreLights/EsmShadowmapsPass.h
+1 -1
View File
@@ -15,7 +15,7 @@
#include <Atom/RPI.Public/Buffer/Buffer.h>
#include <Atom/RHI.Reflect/ShaderResourceGroupLayoutDescriptor.h>
#include <AtomCore/Instance/Instance.h>
#include <AtomCore/std/containers/array_view.h>
#include <AzCore/std/containers/span.h>
#include <AzCore/std/containers/array.h>
#include <AzCore/Preprocessor/Enum.h>
Gems/Atom/Feature/Common/Code/Source/CoreLights/ProjectedShadowmapsPass.h
+1 -1
View File
@@ -9,7 +9,7 @@
#include <Atom/Feature/CoreLights/CoreLightsConstants.h>
#include <Atom/RPI.Public/Pass/ParentPass.h>
#include <AtomCore/std/containers/array_view.h>
#include <AzCore/std/containers/span.h>
#include <AzCore/std/containers/vector.h>
#include <CoreLights/ShadowmapAtlas.h>
#include <CoreLights/ShadowmapPass.h>
Gems/Atom/Feature/Common/Code/Source/Decals/DecalFeatureProcessor.cpp
+5 -5
View File
@@ -16,7 +16,7 @@
#include <Atom/RPI.Public/Scene.h>
#include <Atom/RPI.Public/View.h>
#include <AzCore/Math/Quaternion.h>
#include <AtomCore/std/containers/array_view.h>
#include <AzCore/std/containers/span.h>
#include <Atom/RPI.Reflect/Asset/AssetUtils.h>
namespace AZ
@@ -114,14 +114,14 @@ namespace AZ
}
}
AZStd::array_view<Data::Instance<RPI::Image>> DecalFeatureProcessor::GetImageArray() const
AZStd::span<const Data::Instance<RPI::Image>> DecalFeatureProcessor::GetImageArray() const
{
// [GFX TODO][ATOM-4445] Replace this hardcoded constant with atlasing / bindless so we can have far more than 8 decal textures
// Note this constant also is defined in View.srg
const size_t MaxDecals = 8;
size_t numImages = AZStd::min(MaxDecals, m_decalData.GetDataCount());
AZStd::array_view<ImagePtr> imageArrayView(m_decalData.GetDataVector<1>().begin(), m_decalData.GetDataVector<1>().begin() + numImages);
AZStd::span<const ImagePtr> imageArrayView(m_decalData.GetDataVector<1>().begin(), m_decalData.GetDataVector<1>().begin() + numImages);
return imageArrayView;
}
@@ -130,8 +130,8 @@ namespace AZ
{
AZ_PROFILE_SCOPE(RPI, "DecalFeatureProcessor: Render");
AZStd::array_view<Data::Instance<RPI::Image>> baseMaps = GetImagesFromDecalData<1>();
AZStd::array_view<Data::Instance<RPI::Image>> opacityMaps = GetImagesFromDecalData<2>();
AZStd::span<const Data::Instance<RPI::Image>> baseMaps = GetImagesFromDecalData<1>();
AZStd::span<const Data::Instance<RPI::Image>> opacityMaps = GetImagesFromDecalData<2>();
for (const RPI::ViewPtr& view : packet.m_views)
{
Gems/Atom/Feature/Common/Code/Source/Decals/DecalFeatureProcessor.h
+4 -4
View File
@@ -81,11 +81,11 @@ namespace AZ
DecalFeatureProcessor(const DecalFeatureProcessor&) = delete;
Data::Instance<RPI::Image> GetImageFromMaterial(const AZ::Name& mapName, Data::Instance<RPI::Material> materialInstance) const;
AZStd::array_view<Data::Instance<RPI::Image>> GetImageArray() const;
AZStd::span<const Data::Instance<RPI::Image>> GetImageArray() const;
void CacheShaderIndices();
template<size_t ArrayIndex>
AZStd::array_view<Data::Instance<RPI::Image>> GetImagesFromDecalData();
AZStd::span<const Data::Instance<RPI::Image>> GetImagesFromDecalData();
static constexpr const char* FeatureProcessorName = "DecalFeatureProcessor";
@@ -105,7 +105,7 @@ namespace AZ
};
template<size_t ArrayIndex>
AZStd::array_view<Data::Instance<RPI::Image>>
AZStd::span<const Data::Instance<RPI::Image>>
AZ::Render::DecalFeatureProcessor::GetImagesFromDecalData()
{
// [GFX TODO][ATOM-4445] Replace this hardcoded constant with atlasing / bindless so we can have far more than 8 decal textures
@@ -113,7 +113,7 @@ namespace AZ
const size_t MaxDecals = 4;
size_t numImages = AZStd::min(MaxDecals, m_decalData.GetDataCount());
AZStd::array_view<ImagePtr> imageArrayView(m_decalData.GetDataVector<ArrayIndex>().begin(), m_decalData.GetDataVector<ArrayIndex>().begin() + numImages);
AZStd::span<const ImagePtr> imageArrayView(m_decalData.GetDataVector<ArrayIndex>().begin(), m_decalData.GetDataVector<ArrayIndex>().begin() + numImages);
return imageArrayView;
}
} // namespace Render
Gems/Atom/Feature/Common/Code/Source/Decals/DecalTextureArray.cpp
+1 -1
View File
@@ -267,7 +267,7 @@ namespace AZ
return AZ::RHI::GetImageSubresourceLayout(mipSize, descriptor.m_format);
}
AZStd::array_view<uint8_t> DecalTextureArray::GetRawImageData(const AZ::Name& mapName, int arrayLevel, const int mip) const
AZStd::span<const uint8_t> DecalTextureArray::GetRawImageData(const AZ::Name& mapName, int arrayLevel, const int mip) const
{
// We always want to provide valid data to the AssetCreator for each texture.
// If this spot in the array is empty, just provide some random image as filler.
Gems/Atom/Feature/Common/Code/Source/Decals/DecalTextureArray.h
+2 -2
View File
@@ -13,7 +13,7 @@
#include <AzCore/Asset/AssetCommon.h>
#include <Atom/RHI.Reflect/ImageDescriptor.h>
#include <Atom/RHI.Reflect/ImageSubresource.h>
#include <AtomCore/std/containers/array_view.h>
#include <AzCore/std/containers/span.h>
#include <Atom/RPI.Public/Image/StreamingImage.h>
@@ -81,7 +81,7 @@ namespace AZ
RHI::Size GetImageDimensions(const DecalMapType mapType) const;
RHI::Format GetFormat(const DecalMapType mapType) const;
RHI::ImageSubresourceLayout GetLayout(const DecalMapType mapType, int mip) const;
AZStd::array_view<uint8_t> GetRawImageData(const AZ::Name& mapName, int arrayLevel, int mip) const;
AZStd::span<const uint8_t> GetRawImageData(const AZ::Name& mapName, int arrayLevel, int mip) const;
bool AreAllAssetsReady() const;
bool IsAssetReady(const MaterialData& materialData) const;
Gems/Atom/Feature/Common/Code/Source/Decals/DecalTextureArrayFeatureProcessor.cpp
+1 -1
View File
@@ -13,7 +13,7 @@
#include <Atom/RPI.Public/Scene.h>
#include <Atom/RPI.Public/View.h>
#include <AzCore/Math/Quaternion.h>
#include <AtomCore/std/containers/array_view.h>
#include <AzCore/std/containers/span.h>
#include <Atom/RPI.Public/Image/ImageSystemInterface.h>
#include <Atom/RPI.Reflect/Image/StreamingImageAssetHandler.h>
#include <AtomCore/Instance/InstanceDatabase.h>
Gems/Atom/Feature/Common/Code/Source/Mesh/MeshFeatureProcessor.cpp
+1 -1
View File
@@ -772,7 +772,7 @@ namespace AZ
return;
}
const AZStd::array_view<Data::Instance<RPI::ModelLod>>& modelLods = m_model->GetLods();
const AZStd::span<const Data::Instance<RPI::ModelLod>>& modelLods = m_model->GetLods();
if (modelLods.empty())
{
return;
Gems/Atom/Feature/Common/Code/Source/SkinnedMesh/SkinnedMeshDispatchItem.cpp
+2 -2
View File
@@ -225,12 +225,12 @@ namespace AZ
return m_boneTransforms;
}
AZStd::array_view<AZ::RHI::Ptr<RHI::BufferView>> SkinnedMeshDispatchItem::GetSourceUnskinnedBufferViews() const
AZStd::span<const AZ::RHI::Ptr<RHI::BufferView>> SkinnedMeshDispatchItem::GetSourceUnskinnedBufferViews() const
{
return m_inputBuffers->GetInputBufferViews(m_lodIndex);
}
AZStd::array_view<AZ::RHI::Ptr<RHI::BufferView>> SkinnedMeshDispatchItem::GetTargetSkinnedBufferViews() const
AZStd::span<const AZ::RHI::Ptr<RHI::BufferView>> SkinnedMeshDispatchItem::GetTargetSkinnedBufferViews() const
{
return m_actorInstanceBufferViews;
}
Gems/Atom/Feature/Common/Code/Source/SkinnedMesh/SkinnedMeshDispatchItem.h
+2 -2
View File
@@ -65,8 +65,8 @@ namespace AZ
const RHI::DispatchItem& GetRHIDispatchItem() const;
Data::Instance<RPI::Buffer> GetBoneTransforms() const;
AZStd::array_view<RHI::Ptr<RHI::BufferView>> GetSourceUnskinnedBufferViews() const;
AZStd::array_view<RHI::Ptr<RHI::BufferView>> GetTargetSkinnedBufferViews() const;
AZStd::span<const RHI::Ptr<RHI::BufferView>> GetSourceUnskinnedBufferViews() const;
AZStd::span<const RHI::Ptr<RHI::BufferView>> GetTargetSkinnedBufferViews() const;
size_t GetVertexCount() const;
private:
// SkinnedMeshShaderOptionNotificationBus::Handler
Gems/Atom/Feature/Common/Code/Source/SkinnedMesh/SkinnedMeshInputBuffers.cpp
+2 -2
View File
@@ -212,7 +212,7 @@ namespace AZ
void SkinnedMeshInputLod::CreateSharedSubMeshBufferViews()
{
AZStd::array_view<RPI::ModelLodAsset::Mesh> meshes = m_modelLodAsset->GetMeshes();
AZStd::span<const RPI::ModelLodAsset::Mesh> meshes = m_modelLodAsset->GetMeshes();
m_sharedSubMeshViews.resize(meshes.size());
// The index and static buffer views will be shared by all instances that use the same SkinnedMeshInputBuffers, so set them here
@@ -307,7 +307,7 @@ namespace AZ
return m_lods[lodIndex];
}
AZStd::array_view<AZ::RHI::Ptr<RHI::BufferView>> SkinnedMeshInputBuffers::GetInputBufferViews(size_t lodIndex) const
AZStd::span<const AZ::RHI::Ptr<RHI::BufferView>> SkinnedMeshInputBuffers::GetInputBufferViews(size_t lodIndex) const
{
return m_lods[lodIndex].m_bufferViews;
}
Gems/Atom/Feature/Common/Code/Source/SkinnedMesh/SkinnedMeshRenderProxy.cpp
+1 -1
View File
@@ -145,7 +145,7 @@ namespace AZ
}
}
AZStd::array_view<AZStd::unique_ptr<SkinnedMeshDispatchItem>> SkinnedMeshRenderProxy::GetDispatchItems() const
AZStd::span<const AZStd::unique_ptr<SkinnedMeshDispatchItem>> SkinnedMeshRenderProxy::GetDispatchItems() const
{
return m_dispatchItemsByLod;
}
Gems/Atom/Feature/Common/Code/Source/SkinnedMesh/SkinnedMeshRenderProxy.h
+1 -1
View File
@@ -45,7 +45,7 @@ namespace AZ
void SetSkinningMatrices(const AZStd::vector<float>& data) override;
void SetMorphTargetWeights(uint32_t lodIndex, const AZStd::vector<float>& weights) override;
AZStd::array_view< AZStd::unique_ptr<SkinnedMeshDispatchItem>> GetDispatchItems() const;
AZStd::span<const AZStd::unique_ptr<SkinnedMeshDispatchItem>> GetDispatchItems() const;
private:
AZ_DISABLE_COPY_MOVE(SkinnedMeshRenderProxy);
Gems/Atom/Feature/Common/Code/Source/SkinnedMesh/SkinnedMeshStatsCollector.cpp
+2 -2
View File
@@ -78,7 +78,7 @@ namespace AZ
}
}
void SkinnedMeshStatsCollector::AddReadOnlyBufferViewsToSceneStats(const AZStd::array_view<AZ::RHI::Ptr<RHI::BufferView>>& sourceUnskinnedBufferViews)
void SkinnedMeshStatsCollector::AddReadOnlyBufferViewsToSceneStats(const AZStd::span<const AZ::RHI::Ptr<RHI::BufferView>>& sourceUnskinnedBufferViews)
{
for (const AZ::RHI::Ptr<RHI::BufferView>& bufferView : sourceUnskinnedBufferViews)
{
@@ -94,7 +94,7 @@ namespace AZ
}
}
void SkinnedMeshStatsCollector::AddWritableBufferViewsToSceneStats(const AZStd::array_view<AZ::RHI::Ptr<RHI::BufferView>>& targetSkinnedBufferViews)
void SkinnedMeshStatsCollector::AddWritableBufferViewsToSceneStats(const AZStd::span<const AZ::RHI::Ptr<RHI::BufferView>>& targetSkinnedBufferViews)
{
for (const AZ::RHI::Ptr<RHI::BufferView>& bufferView : targetSkinnedBufferViews)
{
Gems/Atom/Feature/Common/Code/Source/SkinnedMesh/SkinnedMeshStatsCollector.h
+2 -2
View File
@@ -33,8 +33,8 @@ namespace AZ
void ResetAllStats();
void AddDispatchItemToSceneStats(const AZStd::unique_ptr<SkinnedMeshDispatchItem>& dispatchItem);
void AddBonesToSceneStats(const Data::Instance<RPI::Buffer>& boneTransformBuffer);
void AddReadOnlyBufferViewsToSceneStats(const AZStd::array_view<AZ::RHI::Ptr<RHI::BufferView>>& sourceUnskinnedBufferViews);
void AddWritableBufferViewsToSceneStats(const AZStd::array_view<AZ::RHI::Ptr<RHI::BufferView>>& targetSkinnedBufferViews);
void AddReadOnlyBufferViewsToSceneStats(const AZStd::span<const AZ::RHI::Ptr<RHI::BufferView>>& sourceUnskinnedBufferViews);
void AddWritableBufferViewsToSceneStats(const AZStd::span<const AZ::RHI::Ptr<RHI::BufferView>>& targetSkinnedBufferViews);
void AddVerticesToSceneStats(size_t vertexCount);
SkinnedMeshSceneStats m_sceneStats;
Gems/Atom/RHI/Code/Include/Atom/RHI.Edit/ShaderCompilerArguments.h
+1 -1
View File
@@ -10,7 +10,7 @@
#include <AzCore/Serialization/SerializeContext.h>
#include <AzCore/Preprocessor/Enum.h>
#include <AzCore/std/string/string.h>
#include <AtomCore/std/containers/array_view.h>
#include <AzCore/std/containers/span.h>
namespace AZ
{
Gems/Atom/RHI/Code/Include/Atom/RHI.Edit/Utils.h
+1 -1
View File
@@ -129,7 +129,7 @@ namespace AZ
//! @returns A new string based on @commandLineString but with the matching arguments and their values
//! removed from it.
AZStd::string RemoveArgumentsFromCommandLineString(
AZStd::array_view<AZStd::string> listOfArguments, AZStd::string_view commandLineString);
AZStd::span<const AZStd::string> listOfArguments, AZStd::string_view commandLineString);
//! @param commandLineString: " --arg1 -arg2 --arg3=foo --arg4=bar "
//! @returns "--arg1 -arg2 --arg3=foo --arg4=bar"
Gems/Atom/RHI/Code/Include/Atom/RHI.Reflect/ConstantsLayout.h
+3 -3
View File
@@ -9,7 +9,7 @@
#include <Atom/RHI.Reflect/ShaderResourceGroupLayoutDescriptor.h>
#include <Atom/RHI.Reflect/NameIdReflectionMap.h>
#include <AtomCore/std/containers/array_view.h>
#include <AzCore/std/containers/span.h>
#include <AzCore/std/smart_ptr/intrusive_base.h>
#include <AzCore/Utils/TypeHash.h>
@@ -72,7 +72,7 @@ namespace AZ
//! Returns the full lists of shader input added to the layout. Inputs
//! maintain their original order with respect to AddShaderInput.
AZStd::array_view<ShaderInputConstantDescriptor> GetShaderInputList() const;
AZStd::span<const ShaderInputConstantDescriptor> GetShaderInputList() const;
//! Returns the total size in bytes used by the constants.
uint32_t GetDataSize() const;
@@ -84,7 +84,7 @@ namespace AZ
//! Prints to the console the shader input names specified by input list of indices
//! Will ignore any indices outside of the inputs array bounds
void DebugPrintNames(AZStd::array_view<ShaderInputConstantIndex> constantList) const;
void DebugPrintNames(AZStd::span<const ShaderInputConstantIndex> constantList) const;
protected:
ConstantsLayout() = default;
Gems/Atom/RHI/Code/Include/Atom/RHI.Reflect/IndirectBufferLayout.h
+2 -2
View File
@@ -12,7 +12,7 @@
#include <AzCore/Memory/SystemAllocator.h>
#include <AzCore/RTTI/RTTI.h>
#include <AzCore/Utils/TypeHash.h>
#include <AtomCore/std/containers/array_view.h>
#include <AzCore/std/containers/span.h>
namespace AZ
{
@@ -137,7 +137,7 @@ namespace AZ
bool AddIndirectCommand(const IndirectCommandDescriptor& command);
/// Returns the list of indirect commands of the layout. Must be called after the layout is finalized.
AZStd::array_view<IndirectCommandDescriptor> GetCommands() const;
AZStd::span<const IndirectCommandDescriptor> GetCommands() const;
//! Returns the position of a command.
//! Must be called after the layout is finalized.
Gems/Atom/RHI/Code/Include/Atom/RHI.Reflect/InputStreamLayout.h
+3 -3
View File
@@ -10,7 +10,7 @@
#include <Atom/RHI.Reflect/Format.h>
#include <Atom/RHI.Reflect/Limits.h>
#include <Atom/RHI.Reflect/ShaderSemantic.h>
#include <AtomCore/std/containers/array_view.h>
#include <AzCore/std/containers/span.h>
#include <AzCore/std/containers/fixed_vector.h>
#include <AzCore/Utils/TypeHash.h>
@@ -158,10 +158,10 @@ namespace AZ
const PrimitiveTopology GetTopology() const;
/// Returns the list of stream channels.
AZStd::array_view<StreamChannelDescriptor> GetStreamChannels() const;
AZStd::span<const StreamChannelDescriptor> GetStreamChannels() const;
/// Returns the list of stream buffers.
AZStd::array_view<StreamBufferDescriptor> GetStreamBuffers() const;
AZStd::span<const StreamBufferDescriptor> GetStreamBuffers() const;
/// Returns the hash computed in Finalize(), which must be called first.
HashValue64 GetHash() const;
Gems/Atom/RHI/Code/Include/Atom/RHI.Reflect/PipelineLayoutDescriptor.h
+1 -1
View File
@@ -10,7 +10,7 @@
#include <Atom/RHI.Reflect/ShaderResourceGroupLayout.h>
#include <Atom/RHI.Reflect/ConstantsLayout.h>
#include <AtomCore/std/containers/array_view.h>
#include <AzCore/std/containers/span.h>
#include <AzCore/Name/Name.h>
#include <AzCore/Serialization/SerializeContext.h>
Gems/Atom/RHI/Code/Include/Atom/RHI.Reflect/PipelineLibraryData.h
+2 -2
View File
@@ -8,7 +8,7 @@
#pragma once
#include <Atom/RHI.Reflect/Base.h>
#include <AtomCore/std/containers/array_view.h>
#include <AzCore/std/containers/span.h>
#include <AzCore/Serialization/SerializeContext.h>
#include <AzCore/std/smart_ptr/intrusive_base.h>
@@ -47,7 +47,7 @@ namespace AZ
static ConstPtr<PipelineLibraryData> Create(AZStd::vector<uint8_t>&& data);
/// Returns the data payload which describes the platform-specific pipeline library data.
AZStd::array_view<uint8_t> GetData() const;
AZStd::span<const uint8_t> GetData() const;
private:
PipelineLibraryData(AZStd::vector<uint8_t>&& data);
Gems/Atom/RHI/Code/Include/Atom/RHI.Reflect/RenderAttachmentLayout.h
+1 -1
View File
@@ -13,7 +13,7 @@
#include <Atom/RHI.Reflect/Limits.h>
#include <AzCore/Utils/TypeHash.h>
#include <AzCore/std/containers/array.h>
#include <AtomCore/std/containers/array_view.h>
#include <AzCore/std/containers/span.h>
namespace AZ
{
Gems/Atom/RHI/Code/Include/Atom/RHI.Reflect/ShaderResourceGroupLayout.h
+8 -8
View File
@@ -10,7 +10,7 @@
#include <Atom/RHI.Reflect/ConstantsLayout.h>
#include <Atom/RHI.Reflect/ShaderResourceGroupLayoutDescriptor.h>
#include <Atom/RHI.Reflect/NameIdReflectionMap.h>
#include <AtomCore/std/containers/array_view.h>
#include <AzCore/std/containers/span.h>
#include <AzCore/std/smart_ptr/intrusive_base.h>
#include <AzCore/Outcome/Outcome.h>
#include <AzCore/Serialization/SerializeContext.h>
@@ -116,7 +116,7 @@ namespace AZ
// The following methods are only permitted on a finalized layout.
/// Returns the full list of static samplers descriptors declared on the layout.
AZStd::array_view<ShaderInputStaticSamplerDescriptor> GetStaticSamplers() const;
AZStd::span<const ShaderInputStaticSamplerDescriptor> GetStaticSamplers() const;
/**
* Resolves an shader input name to an index for each type of shader input. To maximize performance,
@@ -148,13 +148,13 @@ namespace AZ
* maintain their original order with respect to AddShaderInput. Each type
* of shader input has its own separate list.
*/
AZStd::array_view<ShaderInputBufferDescriptor> GetShaderInputListForBuffers() const;
AZStd::array_view<ShaderInputImageDescriptor> GetShaderInputListForImages() const;
AZStd::array_view<ShaderInputSamplerDescriptor> GetShaderInputListForSamplers() const;
AZStd::array_view<ShaderInputConstantDescriptor> GetShaderInputListForConstants() const;
AZStd::span<const ShaderInputBufferDescriptor> GetShaderInputListForBuffers() const;
AZStd::span<const ShaderInputImageDescriptor> GetShaderInputListForImages() const;
AZStd::span<const ShaderInputSamplerDescriptor> GetShaderInputListForSamplers() const;
AZStd::span<const ShaderInputConstantDescriptor> GetShaderInputListForConstants() const;
AZStd::array_view<ShaderInputBufferUnboundedArrayDescriptor> GetShaderInputListForBufferUnboundedArrays() const;
AZStd::array_view<ShaderInputImageUnboundedArrayDescriptor> GetShaderInputListForImageUnboundedArrays() const;
AZStd::span<const ShaderInputBufferUnboundedArrayDescriptor> GetShaderInputListForBufferUnboundedArrays() const;
AZStd::span<const ShaderInputImageUnboundedArrayDescriptor> GetShaderInputListForImageUnboundedArrays() const;
/**
* Each shader input may contain multiple shader resources. The layout computes
Gems/Atom/RHI/Code/Include/Atom/RHI/CommandListStates.h
+1 -1
View File
@@ -20,7 +20,7 @@ namespace AZ
struct CommandListRenderTargetsState
{
using StateList = AZStd::fixed_vector<T, RHI::Limits::Pipeline::AttachmentColorCountMax>;
void Set(AZStd::array_view<T> newElements)
void Set(AZStd::span<const T> newElements)
{
m_states = StateList(newElements.begin(), newElements.end());
m_isDirty = true;
Gems/Atom/RHI/Code/Include/Atom/RHI/ConstantsData.h
+18 -18
View File
@@ -20,11 +20,11 @@ namespace AZ
{
namespace RHI
{
//! The intent of this class is to provide fast and thin access to the underlying constant
//! data (inline or from an SRG), with basic validation to protect the user. As a secondary objective, it provides type-specific convenience
//! operations as long as they don't violate the primary "fast" and "thin" objectives. To clarify, thin means
//! we don't make assumptions about the data or how the user wants to operate on the data, and the convenience
//! operations boil down to thin wrappers for single calls to SetConstantRaw and GetConstantRaw. So these
//! The intent of this class is to provide fast and thin access to the underlying constant
//! data (inline or from an SRG), with basic validation to protect the user. As a secondary objective, it provides type-specific convenience
//! operations as long as they don't violate the primary "fast" and "thin" objectives. To clarify, thin means
//! we don't make assumptions about the data or how the user wants to operate on the data, and the convenience
//! operations boil down to thin wrappers for single calls to SetConstantRaw and GetConstantRaw. So these
//! convenience functions are provided in situations that are "low-hanging-fruit".
class ConstantsData
{
@@ -53,7 +53,7 @@ namespace AZ
//! Assigns an array of type T to the constant shader input.
template <typename T>
bool SetConstantArray(ShaderInputConstantIndex inputIndex, AZStd::array_view<T> values);
bool SetConstantArray(ShaderInputConstantIndex inputIndex, AZStd::span<const T> values);
//! Assigns constant data as a whole.
bool SetConstantData(const void* bytes, size_t byteCount);
@@ -64,7 +64,7 @@ namespace AZ
//! of elements in the returned array is the number of evenly divisible elements.
//! If the strides do not match, an empty array is returned.
template <typename T>
AZStd::array_view<T> GetConstantArray(ShaderInputConstantIndex inputIndex) const;
AZStd::span<const T> GetConstantArray(ShaderInputConstantIndex inputIndex) const;
//! Returns the constant data as type 'T' returned by value. The size of the constant region
//! must match the size of T exactly. Otherwise, an empty instance is returned.
@@ -77,11 +77,11 @@ namespace AZ
template <typename T>
T GetConstant(ShaderInputConstantIndex inputIndex, uint32_t arrayIndex) const;
//! Returns constant data for the given shader input index as an array of bytes.
AZStd::array_view<uint8_t> GetConstantRaw(ShaderInputConstantIndex inputIndex) const;
//! Returns constant data for the given shader input index as a span of bytes.
AZStd::span<const uint8_t> GetConstantRaw(ShaderInputConstantIndex inputIndex) const;
//! Returns the opaque constant data populated by calls to SetConstant and SetConstantData.
AZStd::array_view<uint8_t> GetConstantData() const;
AZStd::span<const uint8_t> GetConstantData() const;
//! Returns the constants layout.
const ConstantsLayout* GetLayout() const;
@@ -123,7 +123,7 @@ namespace AZ
template <typename T>
bool ConstantsData::SetConstant(ShaderInputConstantIndex inputIndex, const T& value)
{
AZStd::array_view<T> valueArray(&value, 1);
AZStd::span<const T> valueArray(&value, 1);
return SetConstantArray(inputIndex, valueArray);
}
@@ -152,7 +152,7 @@ namespace AZ
bool ConstantsData::SetConstant<Color>(ShaderInputConstantIndex inputIndex, const Color& value);
template <>
bool ConstantsData::SetConstantArray<bool>(ShaderInputConstantIndex inputIndex, AZStd::array_view<bool> values);
bool ConstantsData::SetConstantArray<bool>(ShaderInputConstantIndex inputIndex, AZStd::span<const bool> values);
template <>
bool ConstantsData::GetConstant<bool>(ShaderInputConstantIndex inputIndex) const;
@@ -213,7 +213,7 @@ namespace AZ
}
template <typename T>
bool ConstantsData::SetConstantArray(ShaderInputConstantIndex inputIndex, AZStd::array_view<T> values)
bool ConstantsData::SetConstantArray(ShaderInputConstantIndex inputIndex, AZStd::span<const T> values)
{
const size_t sizeInBytes = values.size() * sizeof(T);
if (ValidateConstantAccess(inputIndex, ValidateConstantAccessExpect::Complete, 0, sizeInBytes))
@@ -224,15 +224,15 @@ namespace AZ
}
template <typename T>
AZStd::array_view<T> ConstantsData::GetConstantArray(ShaderInputConstantIndex inputIndex) const
AZStd::span<const T> ConstantsData::GetConstantArray(ShaderInputConstantIndex inputIndex) const
{
AZStd::array_view<uint8_t> constantBytes = GetConstantRaw(inputIndex);
AZStd::span<const uint8_t> constantBytes = GetConstantRaw(inputIndex);
const size_t elementSize = sizeof(T);
const size_t elementCount = DivideByMultiple(constantBytes.size(), elementSize);
const size_t sizeInBytes = elementCount * elementSize;
if (ValidateConstantAccess(inputIndex, ValidateConstantAccessExpect::Complete, 0, sizeInBytes))
{
return AZStd::array_view<T>(reinterpret_cast<const T*>(constantBytes.data()), elementCount);
return AZStd::span<const T>(reinterpret_cast<const T*>(constantBytes.data()), elementCount);
}
return {};
}
@@ -240,7 +240,7 @@ namespace AZ
template <typename T>
T ConstantsData::GetConstant(ShaderInputConstantIndex inputIndex) const
{
AZStd::array_view<uint8_t> constantBytes = GetConstantRaw(inputIndex);
AZStd::span<const uint8_t> constantBytes = GetConstantRaw(inputIndex);
const size_t sizeInBytes = sizeof(T);
if (ValidateConstantAccess(inputIndex, ValidateConstantAccessExpect::Complete, 0, sizeInBytes))
{
@@ -252,7 +252,7 @@ namespace AZ
template <typename T>
T ConstantsData::GetConstant(ShaderInputConstantIndex inputIndex, uint32_t arrayIndex) const
{
AZStd::array_view<uint8_t> constantBytes = GetConstantRaw(inputIndex);
AZStd::span<const uint8_t> constantBytes = GetConstantRaw(inputIndex);
const size_t elementSize = sizeof(T);
const size_t elementOffset = arrayIndex * elementSize;
if (ValidateConstantAccess(inputIndex, ValidateConstantAccessExpect::ArrayElement, elementOffset, elementSize))
Gems/Atom/RHI/Code/Include/Atom/RHI/DrawList.h
+2 -2
View File
@@ -11,7 +11,7 @@
#include <Atom/RHI.Reflect/Base.h>
#include <Atom/RHI.Reflect/Handle.h>
#include <AtomCore/std/containers/array_view.h>
#include <AzCore/std/containers/span.h>
#include <AzCore/std/containers/bitset.h>
@@ -36,7 +36,7 @@ namespace AZ
using DrawListMask = AZStd::bitset<RHI::Limits::Pipeline::DrawListTagCountMax>;
using DrawList = AZStd::vector<RHI::DrawItemProperties>;
using DrawListView = AZStd::array_view<RHI::DrawItemProperties>;
using DrawListView = AZStd::span<const RHI::DrawItemProperties>;
/// Contains a table of draw lists, indexed by the tag.
using DrawListsByTag = AZStd::array<DrawList, RHI::Limits::Pipeline::DrawListTagCountMax>;
Gems/Atom/RHI/Code/Include/Atom/RHI/DrawPacketBuilder.h
+5 -5
View File
@@ -32,7 +32,7 @@ namespace AZ
uint8_t m_stencilRef = 0;
//! The array of stream buffers to bind for this draw item.
AZStd::array_view<StreamBufferView> m_streamBufferViews;
AZStd::span<const StreamBufferView> m_streamBufferViews;
//! Shader resource group unique for this draw request
const ShaderResourceGroup* m_uniqueShaderResourceGroup = nullptr;
@@ -56,13 +56,13 @@ namespace AZ
void SetIndexBufferView(const IndexBufferView& indexBufferView);
void SetRootConstants(AZStd::array_view<uint8_t> rootConstants);
void SetRootConstants(AZStd::span<const uint8_t> rootConstants);
void SetScissors(AZStd::array_view<Scissor> scissors);
void SetScissors(AZStd::span<const Scissor> scissors);
void SetScissor(const Scissor& scissor);
void SetViewports(AZStd::array_view<Viewport> viewports);
void SetViewports(AZStd::span<const Viewport> viewports);
void SetViewport(const Viewport& viewport);
@@ -85,7 +85,7 @@ namespace AZ
IndexBufferView m_indexBufferView;
AZStd::fixed_vector<DrawRequest, DrawItemCountMax> m_drawRequests;
AZStd::fixed_vector<const ShaderResourceGroup*, Limits::Pipeline::ShaderResourceGroupCountMax> m_shaderResourceGroups;
AZStd::array_view<uint8_t> m_rootConstants;
AZStd::span<const uint8_t> m_rootConstants;
AZStd::fixed_vector<Scissor, Limits::Pipeline::AttachmentColorCountMax> m_scissors;
AZStd::fixed_vector<Viewport, Limits::Pipeline::AttachmentColorCountMax> m_viewports;
};
Gems/Atom/RHI/Code/Include/Atom/RHI/FrameGraph.h
+4 -4
View File
@@ -7,7 +7,7 @@
*/
#pragma once
#include <AtomCore/std/containers/array_view.h>
#include <AzCore/std/containers/span.h>
#include <Atom/RHI.Reflect/BufferScopeAttachmentDescriptor.h>
#include <Atom/RHI.Reflect/ImageScopeAttachmentDescriptor.h>
@@ -105,11 +105,11 @@ namespace AZ
// See RHI::FrameGraphInterface for detailed comments
ResultCode UseAttachment(const BufferScopeAttachmentDescriptor& descriptor, ScopeAttachmentAccess access, ScopeAttachmentUsage usage);
ResultCode UseAttachment(const ImageScopeAttachmentDescriptor& descriptor, ScopeAttachmentAccess access, ScopeAttachmentUsage usage);
ResultCode UseAttachments(AZStd::array_view<ImageScopeAttachmentDescriptor> descriptors, ScopeAttachmentAccess access, ScopeAttachmentUsage usage);
ResultCode UseAttachments(AZStd::span<const ImageScopeAttachmentDescriptor> descriptors, ScopeAttachmentAccess access, ScopeAttachmentUsage usage);
ResultCode UseResolveAttachment(const ResolveScopeAttachmentDescriptor& descriptor);
ResultCode UseColorAttachments(AZStd::array_view<ImageScopeAttachmentDescriptor> descriptors);
ResultCode UseColorAttachments(AZStd::span<const ImageScopeAttachmentDescriptor> descriptors);
ResultCode UseDepthStencilAttachment(const ImageScopeAttachmentDescriptor& descriptor, ScopeAttachmentAccess access);
ResultCode UseSubpassInputAttachments(AZStd::array_view<ImageScopeAttachmentDescriptor> descriptors);
ResultCode UseSubpassInputAttachments(AZStd::span<const ImageScopeAttachmentDescriptor> descriptors);
ResultCode UseShaderAttachment(const BufferScopeAttachmentDescriptor& descriptor, ScopeAttachmentAccess access);
ResultCode UseShaderAttachment(const ImageScopeAttachmentDescriptor& descriptor, ScopeAttachmentAccess access);
ResultCode UseCopyAttachment(const BufferScopeAttachmentDescriptor& descriptor, ScopeAttachmentAccess access);
Gems/Atom/RHI/Code/Include/Atom/RHI/FrameGraphExecuter.h
+1 -1
View File
@@ -124,7 +124,7 @@ namespace AZ
FrameGraphExecuteGroupType* AddGroup();
//! Returns a list of the registered execute groups.
AZStd::array_view<AZStd::unique_ptr<FrameGraphExecuteGroup>> GetGroups() const;
AZStd::span<const AZStd::unique_ptr<FrameGraphExecuteGroup>> GetGroups() const;
private:
//////////////////////////////////////////////////////////////////////////
Gems/Atom/RHI/Code/Include/Atom/RHI/FrameGraphInterface.h
+4 -4
View File
@@ -18,7 +18,7 @@
#include <Atom/RHI.Reflect/ResolveScopeAttachmentDescriptor.h>
#include <Atom/RHI.Reflect/ScopeId.h>
#include <AtomCore/std/containers/array_view.h>
#include <AzCore/std/containers/span.h>
namespace AZ
{
@@ -79,7 +79,7 @@ namespace AZ
//! Declares an array of image attachments for use on the current scope.
ResultCode UseAttachments(
AZStd::array_view<ImageScopeAttachmentDescriptor> descriptors,
AZStd::span<const ImageScopeAttachmentDescriptor> descriptors,
ScopeAttachmentAccess access,
ScopeAttachmentUsage usage)
{
@@ -87,7 +87,7 @@ namespace AZ
}
//! Declares an array of color attachments for use on the current scope.
ResultCode UseColorAttachments(AZStd::array_view<ImageScopeAttachmentDescriptor> descriptors)
ResultCode UseColorAttachments(AZStd::span<const ImageScopeAttachmentDescriptor> descriptors)
{
return m_frameGraph.UseColorAttachments(descriptors);
}
@@ -100,7 +100,7 @@ namespace AZ
//! Declares an array of subpass input attachments for use on the current scope.
//! See UseSubpassInputAttachment for a definition about a SubpassInput.
ResultCode UseSubpassInputAttachments(AZStd::array_view<ImageScopeAttachmentDescriptor> descriptors)
ResultCode UseSubpassInputAttachments(AZStd::span<const ImageScopeAttachmentDescriptor> descriptors)
{
return m_frameGraph.UseSubpassInputAttachments(descriptors);
}
Gems/Atom/RHI/Code/Include/Atom/RHI/PipelineLibrary.h
+3 -3
View File
@@ -19,7 +19,7 @@ namespace AZ
/// A handle typed to the pipeline library. Used by the PipelineStateCache to abstract access.
using PipelineLibraryHandle = Handle<uint32_t, class PipelineLibrary>;
//! PipelineState initialization is an expensive operation on certain platforms. If multiple pipeline states
//! are created with little variation between them, the contents are still duplicated. This class is an allocation
//! context for pipeline states, provided at PipelineState::Init, which will perform de-duplication of
@@ -58,7 +58,7 @@ namespace AZ
//! libraries and merge them into a single unified library. The serialized data can then be
//! extracted from the unified library. An error code is returned on failure and the behavior
//! is as if the method was never called.
ResultCode MergeInto(AZStd::array_view<const PipelineLibrary*> librariesToMerge);
ResultCode MergeInto(AZStd::span<const PipelineLibrary* const> librariesToMerge);
//! Serializes the platform-specific data and returns it as a new PipelineLibraryData instance.
//! The data is opaque to the user and can only be used to re-initialize the library. Use
@@ -85,7 +85,7 @@ namespace AZ
virtual void ShutdownInternal() = 0;
/// Called when libraries are being merged into this one.
virtual ResultCode MergeIntoInternal(AZStd::array_view<const PipelineLibrary*> libraries) = 0;
virtual ResultCode MergeIntoInternal(AZStd::span<const PipelineLibrary* const> libraries) = 0;
/// Called when the library is serializing out platform-specific data.
virtual ConstPtr<PipelineLibraryData> GetSerializedDataInternal() const = 0;
Gems/Atom/RHI/Code/Include/Atom/RHI/ShaderResourceGroupData.h
+38 -38
View File
@@ -24,16 +24,16 @@ namespace AZ
//! and shader constants. It utilizes basic reflection information from the shader resource group layout
//! to construct the table in the correct format for the platform-specific compile phase. The user
//! is expected to create instances of this class, fill data, and then push it to an SRG instance.
//!
//!
//! The shader resource group (SRG) includes a set of built-in SRG constants in a single internally-managed
//! constant buffer. This is separate from any custom constant buffers that some SRG layouts may include
//! as shader resources. SRG constants can be conveniently accessed through a variety of SetConstant.
//!
//!
//! This data structure holds strong references to the resource views bound onto it.
//!
//!
//! NOTE [Performance Warning]: This data structure allocates memory. If compiling several SRG's in a batch,
//! prefer to share the data between them (i.e. within a single job).
//!
//!
//! NOTE [SRG Constants]: The ConstantsData class is used for efficiently setting/getting the constants values of the SRG.
class ShaderResourceGroupData
{
@@ -65,25 +65,25 @@ namespace AZ
bool SetImageView(ShaderInputImageIndex inputIndex, const ImageView* imageView, uint32_t arrayIndex);
//! Sets an array of image view for the given shader input index.
bool SetImageViewArray(ShaderInputImageIndex inputIndex, AZStd::array_view<const ImageView*> imageViews, uint32_t arrayIndex = 0);
bool SetImageViewArray(ShaderInputImageIndex inputIndex, AZStd::span<const ImageView* const> imageViews, uint32_t arrayIndex = 0);
//! Sets an unbounded array of image view for the given shader input index.
bool SetImageViewUnboundedArray(ShaderInputImageUnboundedArrayIndex inputIndex, AZStd::array_view<const ImageView*> imageViews);
bool SetImageViewUnboundedArray(ShaderInputImageUnboundedArrayIndex inputIndex, AZStd::span<const ImageView* const> imageViews);
//! Sets one buffer view for the given shader input index.
bool SetBufferView(ShaderInputBufferIndex inputIndex, const BufferView* bufferView, uint32_t arrayIndex = 0);
//! Sets an array of image view for the given shader input index.
bool SetBufferViewArray(ShaderInputBufferIndex inputIndex, AZStd::array_view<const BufferView*> bufferViews, uint32_t arrayIndex = 0);
bool SetBufferViewArray(ShaderInputBufferIndex inputIndex, AZStd::span<const BufferView* const> bufferViews, uint32_t arrayIndex = 0);
//! Sets an unbounded array of buffer view for the given shader input index.
bool SetBufferViewUnboundedArray(ShaderInputBufferUnboundedArrayIndex inputIndex, AZStd::array_view<const BufferView*> bufferViews);
bool SetBufferViewUnboundedArray(ShaderInputBufferUnboundedArrayIndex inputIndex, AZStd::span<const BufferView* const> bufferViews);
//! Sets one sampler for the given shader input index, using the bindingIndex as the key.
bool SetSampler(ShaderInputSamplerIndex inputIndex, const SamplerState& sampler, uint32_t arrayIndex = 0);
//! Sets an array of samplers for the given shader input index.
bool SetSamplerArray(ShaderInputSamplerIndex inputIndex, AZStd::array_view<SamplerState> samplers, uint32_t arrayIndex = 0);
bool SetSamplerArray(ShaderInputSamplerIndex inputIndex, AZStd::span<const SamplerState> samplers, uint32_t arrayIndex = 0);
//! Assigns constant data for the given constant shader input index.
bool SetConstantRaw(ShaderInputConstantIndex inputIndex, const void* bytes, uint32_t byteCount);
@@ -96,17 +96,17 @@ namespace AZ
//! Assigns a specified number of rows from a Matrix
template <typename T>
bool SetConstantMatrixRows(ShaderInputConstantIndex inputIndex, const T& value, uint32_t rowCount);
//! Assigns a value of type T to the constant shader input, at an array offset.
template <typename T>
bool SetConstant(ShaderInputConstantIndex inputIndex, const T& value, uint32_t arrayIndex);
//! Assigns an array of type T to the constant shader input.
template <typename T>
bool SetConstantArray(ShaderInputConstantIndex inputIndex, AZStd::array_view<T> values);
bool SetConstantArray(ShaderInputConstantIndex inputIndex, AZStd::span<const T> values);
//! Assigns constant data as a whole.
//!
//!
//! CAUTION!
//! Different platforms might follow different packing rules for the internally-managed SRG constant buffer.
//! To set manually a constant buffer as a whole please use Constant Buffers in AZSL,
@@ -118,33 +118,33 @@ namespace AZ
//! Returns a single image view associated with the image shader input index and array offset.
const ConstPtr<ImageView>& GetImageView(ShaderInputImageIndex inputIndex, uint32_t arrayIndex) const;
//! Returns an array of image views associated with the given image shader input index.
AZStd::array_view<ConstPtr<ImageView>> GetImageViewArray(ShaderInputImageIndex inputIndex) const;
//! Returns a span of image views associated with the given image shader input index.
AZStd::span<const ConstPtr<ImageView>> GetImageViewArray(ShaderInputImageIndex inputIndex) const;
//! Returns an unbounded array of image views associated with the given buffer shader input index.
AZStd::array_view<ConstPtr<ImageView>> GetImageViewUnboundedArray(ShaderInputImageUnboundedArrayIndex inputIndex) const;
//! Returns an unbounded span of image views associated with the given buffer shader input index.
AZStd::span<const ConstPtr<ImageView>> GetImageViewUnboundedArray(ShaderInputImageUnboundedArrayIndex inputIndex) const;
//! Returns a single buffer view associated with the buffer shader input index and array offset.
const ConstPtr<BufferView>& GetBufferView(ShaderInputBufferIndex inputIndex, uint32_t arrayIndex) const;
//! Returns an array of buffer views associated with the given buffer shader input index.
AZStd::array_view<ConstPtr<BufferView>> GetBufferViewArray(ShaderInputBufferIndex inputIndex) const;
//! Returns a span of buffer views associated with the given buffer shader input index.
AZStd::span<const ConstPtr<BufferView>> GetBufferViewArray(ShaderInputBufferIndex inputIndex) const;
//! Returns an unbounded array of buffer views associated with the given buffer shader input index.
AZStd::array_view<ConstPtr<BufferView>> GetBufferViewUnboundedArray(ShaderInputBufferUnboundedArrayIndex inputIndex) const;
//! Returns an unbounded span of buffer views associated with the given buffer shader input index.
AZStd::span<const ConstPtr<BufferView>> GetBufferViewUnboundedArray(ShaderInputBufferUnboundedArrayIndex inputIndex) const;
//! Returns a single sampler associated with the sampler shader input index and array offset.
const SamplerState& GetSampler(ShaderInputSamplerIndex inputIndex, uint32_t arrayIndex) const;
//! Returns an array of samplers associated with the sampler shader input index.
AZStd::array_view<SamplerState> GetSamplerArray(ShaderInputSamplerIndex inputIndex) const;
//! Returns a span of samplers associated with the sampler shader input index.
AZStd::span<const SamplerState> GetSamplerArray(ShaderInputSamplerIndex inputIndex) const;
//! Returns constant data for the given shader input index as a template type.
//! The stride of T must match the size of the constant input region. The number
//! of elements in the returned array is the number of evenly divisible elements.
//! If the strides do not match, an empty array is returned.
//! of elements in the returned span is the number of evenly divisible elements.
//! If the strides do not match, an empty span is returned.
template <typename T>
AZStd::array_view<T> GetConstantArray(ShaderInputConstantIndex inputIndex) const;
AZStd::span<const T> GetConstantArray(ShaderInputConstantIndex inputIndex) const;
//! Returns the constant data as type 'T' returned by value. The size of the constant region
//! must match the size of T exactly. Otherwise, an empty instance is returned.
@@ -157,25 +157,25 @@ namespace AZ
template <typename T>
T GetConstant(ShaderInputConstantIndex inputIndex, uint32_t arrayIndex) const;
//! Returns constant data for the given shader input index as an array of bytes.
AZStd::array_view<uint8_t> GetConstantRaw(ShaderInputConstantIndex inputIndex) const;
//! Returns constant data for the given shader input index as a span of bytes.
AZStd::span<const uint8_t> GetConstantRaw(ShaderInputConstantIndex inputIndex) const;
//! Returns a {Buffer, Image, Sampler} shader resource group. Each resource type has its own separate group.
//! - The size of this group matches the size provided by ShaderResourceGroupLayout::GetGroupSizeFor{Buffer, Image, Sampler}.
//! - Use ShaderResourceGroupLayout::GetGroupInterval to retrieve a [min, max) interval into the array.
AZStd::array_view<ConstPtr<ImageView>> GetImageGroup() const;
AZStd::array_view<ConstPtr<BufferView>> GetBufferGroup() const;
AZStd::array_view<SamplerState> GetSamplerGroup() const;
//! - Use ShaderResourceGroupLayout::GetGroupInterval to retrieve a [min, max) interval into the span.
AZStd::span<const ConstPtr<ImageView>> GetImageGroup() const;
AZStd::span<const ConstPtr<BufferView>> GetBufferGroup() const;
AZStd::span<const SamplerState> GetSamplerGroup() const;
//! Reset image and buffer views setup for this ShaderResourceGroupData
//! So it won't hold references for any RHI resources
void ResetViews();
//! Returns the opaque constant data populated by calls to SetConstant and SetConstantData.
//!
//!
//! CAUTION!
//! Different platforms might follow different packing rules for the internally-managed SRG constant buffer.
AZStd::array_view<uint8_t> GetConstantData() const;
AZStd::span<const uint8_t> GetConstantData() const;
//! Returns the underlying ConstantsData struct
const ConstantsData& GetConstantsData() const;
@@ -213,7 +213,7 @@ namespace AZ
//! times in order to ensure all SRG buffers are updated.
void DisableCompilationForAllResourceTypes();
//! Returns true if any of the resource type has been enabled for compilation.
//! Returns true if any of the resource type has been enabled for compilation.
bool IsAnyResourceTypeUpdated() const;
//! Enable compilation for a resourceType specified by resourceType/resourceTypeMask
@@ -265,7 +265,7 @@ namespace AZ
EnableResourceTypeCompilation(ResourceTypeMask::ConstantDataMask, ResourceType::ConstantData);
return m_constantsData.SetConstant(inputIndex, value, arrayIndex);
}
template<typename T>
bool ShaderResourceGroupData::SetConstantMatrixRows(ShaderInputConstantIndex inputIndex, const T& value, uint32_t rowCount)
{
@@ -274,7 +274,7 @@ namespace AZ
}
template <typename T>
bool ShaderResourceGroupData::SetConstantArray(ShaderInputConstantIndex inputIndex, AZStd::array_view<T> values)
bool ShaderResourceGroupData::SetConstantArray(ShaderInputConstantIndex inputIndex, AZStd::span<const T> values)
{
if (!values.empty())
{
@@ -284,7 +284,7 @@ namespace AZ
}
template <typename T>
AZStd::array_view<T> ShaderResourceGroupData::GetConstantArray(ShaderInputConstantIndex inputIndex) const
AZStd::span<const T> ShaderResourceGroupData::GetConstantArray(ShaderInputConstantIndex inputIndex) const
{
return m_constantsData.GetConstantArray<T>(inputIndex);
}
Gems/Atom/RHI/Code/Include/Atom/RHI/StreamBufferView.h
+2 -2
View File
@@ -8,7 +8,7 @@
#pragma once
#include <Atom/RHI.Reflect/Format.h>
#include <AtomCore/std/containers/array_view.h>
#include <AzCore/std/containers/span.h>
#include <AzCore/Utils/TypeHash.h>
namespace AZ
@@ -65,6 +65,6 @@ namespace AZ
};
/// Utility function for checking that the set of StreamBufferViews aligns with the InputStreamLayout
bool ValidateStreamBufferViews(const InputStreamLayout& inputStreamLayout, AZStd::array_view<StreamBufferView> streamBufferViews);
bool ValidateStreamBufferViews(const InputStreamLayout& inputStreamLayout, AZStd::span<const StreamBufferView> streamBufferViews);
}
}
Gems/Atom/RHI/Code/Include/Atom/RHI/StreamingImagePool.h
+5 -5
View File
@@ -11,7 +11,7 @@
#include <Atom/RHI/Image.h>
#include <Atom/RHI/ImagePoolBase.h>
#include <AtomCore/std/containers/array_view.h>
#include <AzCore/std/containers/span.h>
namespace AZ
{
@@ -34,7 +34,7 @@ namespace AZ
struct StreamingImageMipSlice
{
/// An array of subresource datas. The size of this array must match the array size of the image.
AZStd::array_view<StreamingImageSubresourceData> m_subresources;
AZStd::span<const StreamingImageSubresourceData> m_subresources;
/// The layout of each image in the array.
ImageSubresourceLayout m_subresourceLayout;
@@ -52,7 +52,7 @@ namespace AZ
StreamingImageInitRequest(
Image& image,
const ImageDescriptor& descriptor,
AZStd::array_view<StreamingImageMipSlice> tailMipSlices);
AZStd::span<const StreamingImageMipSlice> tailMipSlices);
/// The image to initialize.
Image* m_image = nullptr;
@@ -65,7 +65,7 @@ namespace AZ
* This should only include the baseline set of mips necessary to render the image at
* its lowest resolution. The uploads is performed synchronously.
*/
AZStd::array_view<StreamingImageMipSlice> m_tailMipSlices;
AZStd::span<const StreamingImageMipSlice> m_tailMipSlices;
};
/**
@@ -83,7 +83,7 @@ namespace AZ
* remain valid for the duration of the upload (until m_completeCallback
* is triggered).
*/
AZStd::array_view<StreamingImageMipSlice> m_mipSlices;
AZStd::span<const StreamingImageMipSlice> m_mipSlices;
/// Whether the function need to wait until the upload is finished.
bool m_waitForUpload = false;
Gems/Atom/RHI/Code/Include/Atom/RHI/TransientAttachmentPool.h
+1 -1
View File
@@ -123,7 +123,7 @@ namespace AZ
protected:
// Adds the stats of a list of heaps into the Pool's TransientAttachmentStatistics.
void CollectHeapStats(AliasedResourceTypeFlags typeMask, AZStd::array_view<TransientAttachmentStatistics::Heap> heapStats);
void CollectHeapStats(AliasedResourceTypeFlags typeMask, AZStd::span<const TransientAttachmentStatistics::Heap> heapStats);
Scope* m_currentScope = nullptr;
RHI::TransientAttachmentStatistics m_statistics;
Gems/Atom/RHI/Code/Source/RHI.Edit/Utils.cpp
+1 -1
View File
@@ -496,7 +496,7 @@ namespace AZ
}
AZStd::string RemoveArgumentsFromCommandLineString(
AZStd::array_view<AZStd::string> listOfArgumentsToRemove, AZStd::string_view commandLineString)
AZStd::span<const AZStd::string> listOfArgumentsToRemove, AZStd::string_view commandLineString)
{
AZStd::string customizedArguments = commandLineString;
for (const AZStd::string& azslcArgumentName : listOfArgumentsToRemove)
Gems/Atom/RHI/Code/Source/RHI.Reflect/ConstantsLayout.cpp
+2 -2
View File
@@ -106,7 +106,7 @@ namespace AZ
return m_inputs[inputIndex.GetIndex()];
}
AZStd::array_view<ShaderInputConstantDescriptor> ConstantsLayout::GetShaderInputList() const
AZStd::span<const ShaderInputConstantDescriptor> ConstantsLayout::GetShaderInputList() const
{
return m_inputs;
}
@@ -145,7 +145,7 @@ namespace AZ
return true;
}
void ConstantsLayout::DebugPrintNames(AZStd::array_view<ShaderInputConstantIndex> constantList) const
void ConstantsLayout::DebugPrintNames(AZStd::span<const ShaderInputConstantIndex> constantList) const
{
AZStd::string output;
for (const ShaderInputConstantIndex& constantIdx : constantList)
Gems/Atom/RHI/Code/Source/RHI.Reflect/IndirectBufferLayout.cpp
+2 -2
View File
@@ -137,11 +137,11 @@ namespace AZ
return true;
}
AZStd::array_view<IndirectCommandDescriptor> IndirectBufferLayout::GetCommands() const
AZStd::span<const IndirectCommandDescriptor> IndirectBufferLayout::GetCommands() const
{
if (!ValidateFinalizeState(ValidateFinalizeStateExpect::Finalized))
{
return AZStd::array_view<IndirectCommandDescriptor>();
return AZStd::span<const IndirectCommandDescriptor>();
}
return m_commands;
}
Gems/Atom/RHI/Code/Source/RHI.Reflect/InputStreamLayout.cpp
+2 -2
View File
@@ -159,12 +159,12 @@ namespace AZ
return m_topology;
}
AZStd::array_view<StreamChannelDescriptor> InputStreamLayout::GetStreamChannels() const
AZStd::span<const StreamChannelDescriptor> InputStreamLayout::GetStreamChannels() const
{
return m_streamChannels;
}
AZStd::array_view<StreamBufferDescriptor> InputStreamLayout::GetStreamBuffers() const
AZStd::span<const StreamBufferDescriptor> InputStreamLayout::GetStreamBuffers() const
{
return m_streamBuffers;
}
Gems/Atom/RHI/Code/Source/RHI.Reflect/PipelineLibraryData.cpp
+1 -1
View File
@@ -31,7 +31,7 @@ namespace AZ
: m_data{AZStd::move(data)}
{}
AZStd::array_view<uint8_t> PipelineLibraryData::GetData() const
AZStd::span<const uint8_t> PipelineLibraryData::GetData() const
{
return m_data;
}
Gems/Atom/RHI/Code/Source/RHI.Reflect/ShaderResourceGroupLayout.cpp
+7 -7
View File
@@ -432,7 +432,7 @@ namespace AZ
m_bindingSlot = Handle<uint32_t>(bindingSlot);
}
AZStd::array_view<ShaderInputStaticSamplerDescriptor> ShaderResourceGroupLayout::GetStaticSamplers() const
AZStd::span<const ShaderInputStaticSamplerDescriptor> ShaderResourceGroupLayout::GetStaticSamplers() const
{
return m_staticSamplers;
}
@@ -497,32 +497,32 @@ namespace AZ
return m_constantsDataLayout->GetShaderInput(index);
}
AZStd::array_view<ShaderInputBufferDescriptor> ShaderResourceGroupLayout::GetShaderInputListForBuffers() const
AZStd::span<const ShaderInputBufferDescriptor> ShaderResourceGroupLayout::GetShaderInputListForBuffers() const
{
return m_inputsForBuffers;
}
AZStd::array_view<ShaderInputImageDescriptor> ShaderResourceGroupLayout::GetShaderInputListForImages() const
AZStd::span<const ShaderInputImageDescriptor> ShaderResourceGroupLayout::GetShaderInputListForImages() const
{
return m_inputsForImages;
}
AZStd::array_view<ShaderInputSamplerDescriptor> ShaderResourceGroupLayout::GetShaderInputListForSamplers() const
AZStd::span<const ShaderInputSamplerDescriptor> ShaderResourceGroupLayout::GetShaderInputListForSamplers() const
{
return m_inputsForSamplers;
}
AZStd::array_view<ShaderInputConstantDescriptor> ShaderResourceGroupLayout::GetShaderInputListForConstants() const
AZStd::span<const ShaderInputConstantDescriptor> ShaderResourceGroupLayout::GetShaderInputListForConstants() const
{
return m_constantsDataLayout->GetShaderInputList();
}
AZStd::array_view<ShaderInputBufferUnboundedArrayDescriptor> ShaderResourceGroupLayout::GetShaderInputListForBufferUnboundedArrays() const
AZStd::span<const ShaderInputBufferUnboundedArrayDescriptor> ShaderResourceGroupLayout::GetShaderInputListForBufferUnboundedArrays() const
{
return m_inputsForBufferUnboundedArrays;
}
AZStd::array_view<ShaderInputImageUnboundedArrayDescriptor> ShaderResourceGroupLayout::GetShaderInputListForImageUnboundedArrays() const
AZStd::span<const ShaderInputImageUnboundedArrayDescriptor> ShaderResourceGroupLayout::GetShaderInputListForImageUnboundedArrays() const
{
return m_inputsForImageUnboundedArrays;
}
Gems/Atom/RHI/Code/Source/RHI/ConstantsData.cpp
+17 -17
View File
@@ -144,7 +144,7 @@ namespace AZ
}
template <>
bool ConstantsData::SetConstantArray<bool>(ShaderInputConstantIndex inputIndex, AZStd::array_view<bool> values)
bool ConstantsData::SetConstantArray<bool>(ShaderInputConstantIndex inputIndex, AZStd::span<const bool> values)
{
// The shader packs type bool as 4 bytes
const size_t elementSize = 4;
@@ -310,7 +310,7 @@ namespace AZ
template <>
bool ConstantsData::GetConstant<bool>(ShaderInputConstantIndex inputIndex) const
{
AZStd::array_view<uint8_t> constantBytes = GetConstantRaw(inputIndex);
AZStd::span<const uint8_t> constantBytes = GetConstantRaw(inputIndex);
// The shader packs bool data as 4 bytes
const size_t sizeInBytes = 4;
if (ValidateConstantAccess(inputIndex, ValidateConstantAccessExpect::Complete, 0, sizeInBytes))
@@ -328,7 +328,7 @@ namespace AZ
const size_t sizeInBytes = sizeof(float) * 11;
if (ValidateConstantAccess(inputIndex, ValidateConstantAccessExpect::Complete, 0, sizeInBytes))
{
const AZStd::array_view<uint8_t> constantBytes = GetConstantRaw(inputIndex);
const AZStd::span<const uint8_t> constantBytes = GetConstantRaw(inputIndex);
// As per shader packing rules the Matrix3x3 is stored as 11 floats (2 are padding).
float localData[12];
@@ -348,7 +348,7 @@ namespace AZ
const uint32_t sizeInBytes = sizeof(Matrix3x4);
if (ValidateConstantAccess(inputIndex, ValidateConstantAccessExpect::Complete, 0, sizeInBytes))
{
const AZStd::array_view<uint8_t> constantBytes = GetConstantRaw(inputIndex);
const AZStd::span<const uint8_t> constantBytes = GetConstantRaw(inputIndex);
const Matrix3x4& resultMatrix = Matrix3x4::CreateFromRowMajorFloat12(reinterpret_cast<const float*>(constantBytes.data()));
return resultMatrix;
}
@@ -361,7 +361,7 @@ namespace AZ
const size_t sizeInBytes = sizeof(float) * 16;
if (ValidateConstantAccess(inputIndex, ValidateConstantAccessExpect::Complete, 0, sizeInBytes))
{
const AZStd::array_view<uint8_t> constantBytes = GetConstantRaw(inputIndex);
const AZStd::span<const uint8_t> constantBytes = GetConstantRaw(inputIndex);
const Matrix4x4& resultMatrix = Matrix4x4::CreateFromRowMajorFloat16(reinterpret_cast<const float*>(constantBytes.data()));
return resultMatrix;
}
@@ -374,7 +374,7 @@ namespace AZ
constexpr size_t vector2Size = 8;
if (ValidateConstantAccess(inputIndex, ValidateConstantAccessExpect::Complete, 0, aznumeric_caster(vector2Size)))
{
AZStd::array_view<uint8_t> constantBytes = GetConstantRaw(inputIndex);
AZStd::span<const uint8_t> constantBytes = GetConstantRaw(inputIndex);
return Vector2::CreateFromFloat2(reinterpret_cast<const float*>(constantBytes.data()));
}
return Vector2();
@@ -387,7 +387,7 @@ namespace AZ
constexpr size_t vector3Size = sizeof(float) * 3;
if (ValidateConstantAccess(inputIndex, ValidateConstantAccessExpect::Complete, 0, vector3Size))
{
AZStd::array_view<uint8_t> constantBytes = GetConstantRaw(inputIndex);
AZStd::span<const uint8_t> constantBytes = GetConstantRaw(inputIndex);
return Vector3::CreateFromFloat3(reinterpret_cast<const float*>(constantBytes.data()));
}
return Vector3();
@@ -399,7 +399,7 @@ namespace AZ
constexpr size_t vector4Size = 16;
if (ValidateConstantAccess(inputIndex, ValidateConstantAccessExpect::Complete, 0, aznumeric_caster(vector4Size)))
{
AZStd::array_view<uint8_t> constantBytes = GetConstantRaw(inputIndex);
AZStd::span<const uint8_t> constantBytes = GetConstantRaw(inputIndex);
return Vector4::CreateFromFloat4(reinterpret_cast<const float*>(constantBytes.data()));
}
return Vector4();
@@ -411,19 +411,19 @@ namespace AZ
constexpr size_t colorSize = sizeof(Color);
if (ValidateConstantAccess(inputIndex, ValidateConstantAccessExpect::Complete, 0, aznumeric_caster(colorSize)))
{
AZStd::array_view<uint8_t> constantBytes = GetConstantRaw(inputIndex);
AZStd::span<const uint8_t> constantBytes = GetConstantRaw(inputIndex);
return Color::CreateFromFloat4(reinterpret_cast<const float*>(constantBytes.data()));
}
return Color();
}
AZStd::array_view<uint8_t> ConstantsData::GetConstantRaw(ShaderInputConstantIndex inputIndex) const
AZStd::span<const uint8_t> ConstantsData::GetConstantRaw(ShaderInputConstantIndex inputIndex) const
{
const Interval interval = GetLayout()->GetInterval(inputIndex);
return AZStd::array_view<uint8_t>(&m_constantData[interval.m_min], interval.m_max - interval.m_min);
return AZStd::span<const uint8_t>(&m_constantData[interval.m_min], interval.m_max - interval.m_min);
}
AZStd::array_view<uint8_t> ConstantsData::GetConstantData() const
AZStd::span<const uint8_t> ConstantsData::GetConstantData() const
{
return m_constantData;
}
@@ -436,11 +436,11 @@ namespace AZ
bool ConstantsData::ConstantIsEqual(const ConstantsData& other, ShaderInputConstantIndex inputIndex) const
{
AZStd::array_view<uint8_t> myConstant = GetConstantRaw(inputIndex);
AZStd::array_view<uint8_t> otherConstant = other.GetConstantRaw(inputIndex);
AZStd::span<const uint8_t> myConstant = GetConstantRaw(inputIndex);
AZStd::span<const uint8_t> otherConstant = other.GetConstantRaw(inputIndex);
// If they point to the same data, they are equal
if (myConstant == otherConstant)
if (myConstant.data() == otherConstant.data() && myConstant.size() == otherConstant.size())
{
return true;
}
@@ -474,8 +474,8 @@ namespace AZ
return differingIndices;
}
AZStd::array_view<ShaderInputConstantDescriptor> myShaderInputs = m_layout->GetShaderInputList();
AZStd::array_view<ShaderInputConstantDescriptor> otherShaderInputs = other.m_layout->GetShaderInputList();
AZStd::span<const ShaderInputConstantDescriptor> myShaderInputs = m_layout->GetShaderInputList();
AZStd::span<const ShaderInputConstantDescriptor> otherShaderInputs = other.m_layout->GetShaderInputList();
size_t minSize = AZStd::min(myShaderInputs.size(), otherShaderInputs.size());
size_t maxSize = AZStd::max(myShaderInputs.size(), otherShaderInputs.size());
Gems/Atom/RHI/Code/Source/RHI/DrawPacketBuilder.cpp
+5 -5
View File
@@ -33,29 +33,29 @@ namespace AZ
m_indexBufferView = indexBufferView;
}
void DrawPacketBuilder::SetRootConstants(AZStd::array_view<uint8_t> rootConstants)
void DrawPacketBuilder::SetRootConstants(AZStd::span<const uint8_t> rootConstants)
{
m_rootConstants = rootConstants;
}
void DrawPacketBuilder::SetScissors(AZStd::array_view<Scissor> scissors)
void DrawPacketBuilder::SetScissors(AZStd::span<const Scissor> scissors)
{
m_scissors = decltype(m_scissors)(scissors.begin(), scissors.end());
}
void DrawPacketBuilder::SetScissor(const Scissor& scissor)
{
SetScissors(AZStd::array_view<Scissor>(&scissor, 1));
SetScissors(AZStd::span<const Scissor>(&scissor, 1));
}
void DrawPacketBuilder::SetViewports(AZStd::array_view<Viewport> viewports)
void DrawPacketBuilder::SetViewports(AZStd::span<const Viewport> viewports)
{
m_viewports = decltype(m_viewports)(viewports.begin(), viewports.end());
}
void DrawPacketBuilder::SetViewport(const Viewport& viewport)
{
SetViewports(AZStd::array_view<Viewport>(&viewport, 1));
SetViewports(AZStd::span<const Viewport>(&viewport, 1));
}
void DrawPacketBuilder::AddShaderResourceGroup(const ShaderResourceGroup* shaderResourceGroup)
Gems/Atom/RHI/Code/Source/RHI/FrameGraph.cpp
+3 -3
View File
@@ -327,7 +327,7 @@ namespace AZ
return ResultCode::InvalidArgument;
}
ResultCode FrameGraph::UseAttachments(AZStd::array_view<ImageScopeAttachmentDescriptor> descriptors, ScopeAttachmentAccess access, ScopeAttachmentUsage usage)
ResultCode FrameGraph::UseAttachments(AZStd::span<const ImageScopeAttachmentDescriptor> descriptors, ScopeAttachmentAccess access, ScopeAttachmentUsage usage)
{
for (const ImageScopeAttachmentDescriptor& descriptor : descriptors)
{
@@ -354,7 +354,7 @@ namespace AZ
return ResultCode::InvalidArgument;
}
ResultCode FrameGraph::UseColorAttachments(AZStd::array_view<ImageScopeAttachmentDescriptor> descriptors)
ResultCode FrameGraph::UseColorAttachments(AZStd::span<const ImageScopeAttachmentDescriptor> descriptors)
{
return UseAttachments(descriptors, ScopeAttachmentAccess::Write, ScopeAttachmentUsage::RenderTarget);
}
@@ -364,7 +364,7 @@ namespace AZ
return UseAttachment(descriptor, access, ScopeAttachmentUsage::DepthStencil);
}
ResultCode FrameGraph::UseSubpassInputAttachments(AZStd::array_view<ImageScopeAttachmentDescriptor> descriptors)
ResultCode FrameGraph::UseSubpassInputAttachments(AZStd::span<const ImageScopeAttachmentDescriptor> descriptors)
{
return UseAttachments(descriptors, ScopeAttachmentAccess::Read, ScopeAttachmentUsage::SubpassInput);
}
Gems/Atom/RHI/Code/Source/RHI/FrameGraphExecuter.cpp
+1 -1
View File
@@ -19,7 +19,7 @@ namespace AZ
m_jobPolicy = jobPolicy;
}
AZStd::array_view<AZStd::unique_ptr<FrameGraphExecuteGroup>> FrameGraphExecuter::GetGroups() const
AZStd::span<const AZStd::unique_ptr<FrameGraphExecuteGroup>> FrameGraphExecuter::GetGroups() const
{
return m_groups;
}
Gems/Atom/RHI/Code/Source/RHI/PipelineLibrary.cpp
+1 -1
View File
@@ -44,7 +44,7 @@ namespace AZ
return resultCode;
}
ResultCode PipelineLibrary::MergeInto(AZStd::array_view<const PipelineLibrary*> librariesToMerge)
ResultCode PipelineLibrary::MergeInto(AZStd::span<const PipelineLibrary* const> librariesToMerge)
{
if (!ValidateIsInitialized())
{
Gems/Atom/RHI/Code/Source/RHI/ShaderResourceGroupData.cpp
+24 -24
View File
@@ -112,7 +112,7 @@ namespace AZ
return SetImageViewArray(inputIndex, imageViews, arrayIndex);
}
bool ShaderResourceGroupData::SetImageViewArray(ShaderInputImageIndex inputIndex, AZStd::array_view<const ImageView*> imageViews, uint32_t arrayIndex)
bool ShaderResourceGroupData::SetImageViewArray(ShaderInputImageIndex inputIndex, AZStd::span<const ImageView* const> imageViews, uint32_t arrayIndex)
{
if (GetLayout()->ValidateAccess(inputIndex, static_cast<uint32_t>(arrayIndex + imageViews.size() - 1)))
{
@@ -132,13 +132,13 @@ namespace AZ
{
EnableResourceTypeCompilation(ResourceTypeMask::ImageViewMask, ResourceType::ImageView);
}
return isValidAll;
}
return false;
}
bool ShaderResourceGroupData::SetImageViewUnboundedArray(ShaderInputImageUnboundedArrayIndex inputIndex, AZStd::array_view<const ImageView*> imageViews)
bool ShaderResourceGroupData::SetImageViewUnboundedArray(ShaderInputImageUnboundedArrayIndex inputIndex, AZStd::span<const ImageView* const> imageViews)
{
if (GetLayout()->ValidateAccess(inputIndex))
{
@@ -169,7 +169,7 @@ namespace AZ
return SetBufferViewArray(inputIndex, bufferViews, arrayIndex);
}
bool ShaderResourceGroupData::SetBufferViewArray(ShaderInputBufferIndex inputIndex, AZStd::array_view<const BufferView*> bufferViews, uint32_t arrayIndex)
bool ShaderResourceGroupData::SetBufferViewArray(ShaderInputBufferIndex inputIndex, AZStd::span<const BufferView* const> bufferViews, uint32_t arrayIndex)
{
if (GetLayout()->ValidateAccess(inputIndex, static_cast<uint32_t>(arrayIndex + bufferViews.size() - 1)))
{
@@ -194,7 +194,7 @@ namespace AZ
return false;
}
bool ShaderResourceGroupData::SetBufferViewUnboundedArray(ShaderInputBufferUnboundedArrayIndex inputIndex, AZStd::array_view<const BufferView*> bufferViews)
bool ShaderResourceGroupData::SetBufferViewUnboundedArray(ShaderInputBufferUnboundedArrayIndex inputIndex, AZStd::span<const BufferView* const> bufferViews)
{
if (GetLayout()->ValidateAccess(inputIndex))
{
@@ -221,10 +221,10 @@ namespace AZ
bool ShaderResourceGroupData::SetSampler(ShaderInputSamplerIndex inputIndex, const SamplerState& sampler, uint32_t arrayIndex)
{
return SetSamplerArray(inputIndex, AZStd::array_view<SamplerState>(&sampler, 1), arrayIndex);
return SetSamplerArray(inputIndex, AZStd::span<const SamplerState>(&sampler, 1), arrayIndex);
}
bool ShaderResourceGroupData::SetSamplerArray(ShaderInputSamplerIndex inputIndex, AZStd::array_view<SamplerState> samplers, uint32_t arrayIndex)
bool ShaderResourceGroupData::SetSamplerArray(ShaderInputSamplerIndex inputIndex, AZStd::span<const SamplerState> samplers, uint32_t arrayIndex)
{
if (GetLayout()->ValidateAccess(inputIndex, static_cast<uint32_t>(arrayIndex + samplers.size() - 1)))
{
@@ -241,7 +241,7 @@ namespace AZ
return true;
}
return false;
}
}
bool ShaderResourceGroupData::SetConstantRaw(ShaderInputConstantIndex inputIndex, const void* bytes, uint32_t byteCount)
{
@@ -265,7 +265,7 @@ namespace AZ
EnableResourceTypeCompilation(ResourceTypeMask::ConstantDataMask, ResourceType::ConstantData);
return m_constantsData.SetConstantData(bytes, byteOffset, byteCount);
}
const RHI::ConstPtr<RHI::ImageView>& ShaderResourceGroupData::GetImageView(RHI::ShaderInputImageIndex inputIndex, uint32_t arrayIndex) const
{
if (GetLayout()->ValidateAccess(inputIndex, arrayIndex))
@@ -276,21 +276,21 @@ namespace AZ
return s_nullImageView;
}
AZStd::array_view<RHI::ConstPtr<RHI::ImageView>> ShaderResourceGroupData::GetImageViewArray(RHI::ShaderInputImageIndex inputIndex) const
AZStd::span<const RHI::ConstPtr<RHI::ImageView>> ShaderResourceGroupData::GetImageViewArray(RHI::ShaderInputImageIndex inputIndex) const
{
if (GetLayout()->ValidateAccess(inputIndex, 0))
{
const Interval interval = GetLayout()->GetGroupInterval(inputIndex);
return AZStd::array_view<RHI::ConstPtr<RHI::ImageView>>(&m_imageViews[interval.m_min], interval.m_max - interval.m_min);
return AZStd::span<const RHI::ConstPtr<RHI::ImageView>>(&m_imageViews[interval.m_min], interval.m_max - interval.m_min);
}
return {};
}
AZStd::array_view<RHI::ConstPtr<RHI::ImageView>> ShaderResourceGroupData::GetImageViewUnboundedArray(RHI::ShaderInputImageUnboundedArrayIndex inputIndex) const
AZStd::span<const RHI::ConstPtr<RHI::ImageView>> ShaderResourceGroupData::GetImageViewUnboundedArray(RHI::ShaderInputImageUnboundedArrayIndex inputIndex) const
{
if (GetLayout()->ValidateAccess(inputIndex))
{
return AZStd::array_view<RHI::ConstPtr<RHI::ImageView>>(m_imageViewsUnboundedArray.data(), m_imageViewsUnboundedArray.size());
return AZStd::span<const RHI::ConstPtr<RHI::ImageView>>(m_imageViewsUnboundedArray.data(), m_imageViewsUnboundedArray.size());
}
return {};
}
@@ -305,21 +305,21 @@ namespace AZ
return s_nullBufferView;
}
AZStd::array_view<RHI::ConstPtr<RHI::BufferView>> ShaderResourceGroupData::GetBufferViewArray(RHI::ShaderInputBufferIndex inputIndex) const
AZStd::span<const RHI::ConstPtr<RHI::BufferView>> ShaderResourceGroupData::GetBufferViewArray(RHI::ShaderInputBufferIndex inputIndex) const
{
if (GetLayout()->ValidateAccess(inputIndex, 0))
{
const Interval interval = GetLayout()->GetGroupInterval(inputIndex);
return AZStd::array_view<RHI::ConstPtr<RHI::BufferView>>(&m_bufferViews[interval.m_min], interval.m_max - interval.m_min);
return AZStd::span<const RHI::ConstPtr<RHI::BufferView>>(&m_bufferViews[interval.m_min], interval.m_max - interval.m_min);
}
return {};
}
AZStd::array_view<RHI::ConstPtr<RHI::BufferView>> ShaderResourceGroupData::GetBufferViewUnboundedArray(RHI::ShaderInputBufferUnboundedArrayIndex inputIndex) const
AZStd::span<const RHI::ConstPtr<RHI::BufferView>> ShaderResourceGroupData::GetBufferViewUnboundedArray(RHI::ShaderInputBufferUnboundedArrayIndex inputIndex) const
{
if (GetLayout()->ValidateAccess(inputIndex))
{
return AZStd::array_view<RHI::ConstPtr<RHI::BufferView>>(m_bufferViewsUnboundedArray.data(), m_bufferViewsUnboundedArray.size());
return AZStd::span<const RHI::ConstPtr<RHI::BufferView>>(m_bufferViewsUnboundedArray.data(), m_bufferViewsUnboundedArray.size());
}
return {};
}
@@ -334,28 +334,28 @@ namespace AZ
return s_nullSamplerState;
}
AZStd::array_view<RHI::SamplerState> ShaderResourceGroupData::GetSamplerArray(RHI::ShaderInputSamplerIndex inputIndex) const
AZStd::span<const RHI::SamplerState> ShaderResourceGroupData::GetSamplerArray(RHI::ShaderInputSamplerIndex inputIndex) const
{
const Interval interval = GetLayout()->GetGroupInterval(inputIndex);
return AZStd::array_view<RHI::SamplerState>(&m_samplers[interval.m_min], interval.m_max - interval.m_min);
return AZStd::span<const RHI::SamplerState>(&m_samplers[interval.m_min], interval.m_max - interval.m_min);
}
AZStd::array_view<uint8_t> ShaderResourceGroupData::GetConstantRaw(ShaderInputConstantIndex inputIndex) const
AZStd::span<const uint8_t> ShaderResourceGroupData::GetConstantRaw(ShaderInputConstantIndex inputIndex) const
{
return m_constantsData.GetConstantRaw(inputIndex);
}
AZStd::array_view<ConstPtr<ImageView>> ShaderResourceGroupData::GetImageGroup() const
AZStd::span<const ConstPtr<ImageView>> ShaderResourceGroupData::GetImageGroup() const
{
return m_imageViews;
}
AZStd::array_view<ConstPtr<BufferView>> ShaderResourceGroupData::GetBufferGroup() const
AZStd::span<const ConstPtr<BufferView>> ShaderResourceGroupData::GetBufferGroup() const
{
return m_bufferViews;
}
AZStd::array_view<SamplerState> ShaderResourceGroupData::GetSamplerGroup() const
AZStd::span<const SamplerState> ShaderResourceGroupData::GetSamplerGroup() const
{
return m_samplers;
}
@@ -368,7 +368,7 @@ namespace AZ
m_bufferViewsUnboundedArray.assign(m_bufferViewsUnboundedArray.size(), nullptr);
}
AZStd::array_view<uint8_t> ShaderResourceGroupData::GetConstantData() const
AZStd::span<const uint8_t> ShaderResourceGroupData::GetConstantData() const
{
return m_constantsData.GetConstantData();
}
Gems/Atom/RHI/Code/Source/RHI/ShaderResourceGroupPool.cpp
+4 -4
View File
@@ -202,8 +202,8 @@ namespace AZ
// Generate diffs for image views.
if (HasImageGroup())
{
AZStd::array_view<ConstPtr<ImageView>> viewGroupOld = shaderResourceGroup.GetData().GetImageGroup();
AZStd::array_view<ConstPtr<ImageView>> viewGroupNew = groupData.GetImageGroup();
AZStd::span<const ConstPtr<ImageView>> viewGroupOld = shaderResourceGroup.GetData().GetImageGroup();
AZStd::span<const ConstPtr<ImageView>> viewGroupNew = groupData.GetImageGroup();
AZ_Assert(viewGroupOld.size() == viewGroupNew.size(), "ShaderResourceGroupData layouts do not match.");
for (size_t i = 0; i < viewGroupOld.size(); ++i)
{
@@ -214,8 +214,8 @@ namespace AZ
// Generate diffs for buffer views.
if (HasBufferGroup())
{
AZStd::array_view<ConstPtr<BufferView>> viewGroupOld = shaderResourceGroup.GetData().GetBufferGroup();
AZStd::array_view<ConstPtr<BufferView>> viewGroupNew = groupData.GetBufferGroup();
AZStd::span<const ConstPtr<BufferView>> viewGroupOld = shaderResourceGroup.GetData().GetBufferGroup();
AZStd::span<const ConstPtr<BufferView>> viewGroupNew = groupData.GetBufferGroup();
AZ_Assert(viewGroupOld.size() == viewGroupNew.size(), "ShaderResourceGroupData layouts do not match.");
for (size_t i = 0; i < viewGroupOld.size(); ++i)
{
Gems/Atom/RHI/Code/Source/RHI/StreamBufferView.cpp
+1 -1
View File
@@ -56,7 +56,7 @@ namespace AZ
return m_byteStride;
}
bool ValidateStreamBufferViews(const RHI::InputStreamLayout& inputStreamLayout, AZStd::array_view<RHI::StreamBufferView> streamBufferViews)
bool ValidateStreamBufferViews(const RHI::InputStreamLayout& inputStreamLayout, AZStd::span<const RHI::StreamBufferView> streamBufferViews)
{
bool ok = true;
Gems/Atom/RHI/Code/Source/RHI/StreamingImagePool.cpp
+1 -1
View File
@@ -14,7 +14,7 @@ namespace AZ
StreamingImageInitRequest::StreamingImageInitRequest(
Image& image,
const ImageDescriptor& descriptor,
AZStd::array_view<StreamingImageMipSlice> tailMipSlices)
AZStd::span<const StreamingImageMipSlice> tailMipSlices)
: m_image{&image}
, m_descriptor{descriptor}
, m_tailMipSlices{tailMipSlices}
Gems/Atom/RHI/Code/Source/RHI/TransientAttachmentPool.cpp
+1 -1
View File
@@ -117,7 +117,7 @@ namespace AZ
return m_compileFlags;
}
void TransientAttachmentPool::CollectHeapStats(AliasedResourceTypeFlags typeMask, AZStd::array_view<TransientAttachmentStatistics::Heap> heapStats)
void TransientAttachmentPool::CollectHeapStats(AliasedResourceTypeFlags typeMask, AZStd::span<const TransientAttachmentStatistics::Heap> heapStats)
{
// [GFX_TODO][ATOM-4162] Report the memory allocated stat correctly (or as close as possible) when the heap
// supports multiple resource types. Right now we are assigning all the memory used to one resource type.
Gems/Atom/RHI/Code/Tests/InputStreamLayoutBuilderTests.cpp
+2 -2
View File
@@ -20,7 +20,7 @@ namespace UnitTest
{
protected:
void ExpectEq(AZStd::array_view<StreamBufferDescriptor> expected, AZStd::array_view<StreamBufferDescriptor> actual)
void ExpectEq(AZStd::span<const StreamBufferDescriptor> expected, AZStd::span<const StreamBufferDescriptor> actual)
{
EXPECT_EQ(expected.size(), actual.size());
for (int i = 0; i < expected.size() && i < actual.size(); ++i)
@@ -31,7 +31,7 @@ namespace UnitTest
}
}
void ExpectEq(AZStd::array_view<StreamChannelDescriptor> expected, AZStd::array_view<StreamChannelDescriptor> actual)
void ExpectEq(AZStd::span<const StreamChannelDescriptor> expected, AZStd::span<const StreamChannelDescriptor> actual)
{
EXPECT_EQ(expected.size(), actual.size());
for (int i = 0; i < expected.size() && i < actual.size(); ++i)
Gems/Atom/RHI/Code/Tests/PipelineState.cpp
+1 -1
View File
@@ -28,7 +28,7 @@ namespace UnitTest
{
}
RHI::ResultCode PipelineLibrary::MergeIntoInternal([[maybe_unused]] AZStd::array_view<const RHI::PipelineLibrary*> libraries)
RHI::ResultCode PipelineLibrary::MergeIntoInternal([[maybe_unused]] AZStd::span<const RHI::PipelineLibrary* const> libraries)
{
return RHI::ResultCode::Success;
}
Gems/Atom/RHI/Code/Tests/PipelineState.h
+1 -1
View File
@@ -25,7 +25,7 @@ namespace UnitTest
private:
AZ::RHI::ResultCode InitInternal(AZ::RHI::Device&, const AZ::RHI::PipelineLibraryData*) override { return AZ::RHI::ResultCode::Success; }
void ShutdownInternal() override;
AZ::RHI::ResultCode MergeIntoInternal(AZStd::array_view<const AZ::RHI::PipelineLibrary*>) override;
AZ::RHI::ResultCode MergeIntoInternal(AZStd::span<const AZ::RHI::PipelineLibrary* const>) override;
AZ::RHI::ConstPtr<AZ::RHI::PipelineLibraryData> GetSerializedDataInternal() const override { return nullptr; }
};
Gems/Atom/RHI/Code/Tests/RenderAttachmentLayoutBuilderTests.cpp
+2 -2
View File
@@ -21,13 +21,13 @@ namespace UnitTest
protected:
template<class T>
void ExpectEqMemory(AZStd::array_view<T> expected, AZStd::array_view<T> actual)
void ExpectEqMemory(AZStd::span<const T> expected, AZStd::span<const T> actual)
{
EXPECT_EQ(expected.size(), actual.size());
EXPECT_TRUE(memcmp(expected.data(), actual.data(), expected.size() * sizeof(T)) == 0);
}
void ExpectEq(AZStd::array_view<SubpassRenderAttachmentLayout> expected, AZStd::array_view<SubpassRenderAttachmentLayout> actual)
void ExpectEq(AZStd::span<const SubpassRenderAttachmentLayout> expected, AZStd::span<const SubpassRenderAttachmentLayout> actual)
{
EXPECT_EQ(expected.size(), actual.size());
for (int i = 0; i < expected.size() && i < actual.size(); ++i)
Gems/Atom/RHI/Code/Tests/ShaderResourceGroupTests.cpp
+9 -9
View File
@@ -316,7 +316,7 @@ namespace UnitTest
const auto ValidateFloat4Values = [&]()
{
AZStd::array_view<float> float4ValueResult = srgData.GetConstantArray<float>(float4ValueIndex);
AZStd::span<const float> float4ValueResult = srgData.GetConstantArray<float>(float4ValueIndex);
EXPECT_EQ(float4ValueResult.size(), 4);
EXPECT_EQ(float4ValueResult[0], float4Values[0]);
EXPECT_EQ(float4ValueResult[1], float4Values[1]);
@@ -324,13 +324,13 @@ namespace UnitTest
EXPECT_EQ(float4ValueResult[3], float4Values[3]);
};
AZStd::array_view<uint32_t> uintValuesResult = srgData.GetConstantArray<uint32_t>(uintValueIndex);
AZStd::span<const uint32_t> uintValuesResult = srgData.GetConstantArray<uint32_t>(uintValueIndex);
EXPECT_EQ(uintValuesResult.size(), 3);
EXPECT_EQ(uintValuesResult[0], uintValues[0]);
EXPECT_EQ(uintValuesResult[1], uintValues[1]);
EXPECT_EQ(uintValuesResult[2], uintValues[2]);
AZStd::array_view<NestedData> nestedDataResult = srgData.GetConstantArray<NestedData>(nestedDataIndex);
AZStd::span<const NestedData> nestedDataResult = srgData.GetConstantArray<NestedData>(nestedDataIndex);
EXPECT_EQ(nestedDataResult.size(), 16);
ValidateFloat4Values();
@@ -484,17 +484,17 @@ namespace UnitTest
const Vector4 vector4 = Vector4::CreateFromFloat4(vector4values);
EXPECT_TRUE(srgData.SetConstant(vector2index, vector2));
AZStd::array_view<uint8_t> resultVector2 = srgData.GetConstantRaw(vector2index);
AZStd::span<const uint8_t> resultVector2 = srgData.GetConstantRaw(vector2index);
const Vector2 vector2result = *reinterpret_cast<const Vector2*>(resultVector2.data());
EXPECT_EQ(vector2result, vector2);
EXPECT_TRUE(srgData.SetConstant(vector3index, vector3));
AZStd::array_view<uint8_t> resutVector3 = srgData.GetConstantRaw(vector3index);
AZStd::span<const uint8_t> resutVector3 = srgData.GetConstantRaw(vector3index);
const Vector3 vector3result = *reinterpret_cast<const Vector3*>(resutVector3.data());
EXPECT_EQ(vector3result, vector3);
EXPECT_TRUE(srgData.SetConstant(vector4index, vector4));
AZStd::array_view<uint8_t> resutVector4 = srgData.GetConstantRaw(vector4index);
AZStd::span<const uint8_t> resutVector4 = srgData.GetConstantRaw(vector4index);
const Vector4 vector4result = *reinterpret_cast<const Vector4*>(resutVector4.data());
EXPECT_EQ(vector4result, vector4);
}
@@ -524,7 +524,7 @@ namespace UnitTest
AZ_TEST_START_ASSERTTEST;
EXPECT_FALSE(srgData.SetConstant(vector2index, vector3));
AZ_TEST_STOP_ASSERTTEST(1);
AZStd::array_view<uint8_t> resutV3 = srgData.GetConstantRaw(vector2index);
AZStd::span<const uint8_t> resutV3 = srgData.GetConstantRaw(vector2index);
const Vector3 v3result = *reinterpret_cast<const Vector3*>(resutV3.data());
EXPECT_NE(v3result, vector3);
@@ -534,7 +534,7 @@ namespace UnitTest
AZ_TEST_START_ASSERTTEST;
EXPECT_FALSE(srgData.SetConstant(vector3index, vector4));
AZ_TEST_STOP_ASSERTTEST(1);
AZStd::array_view<uint8_t> resutV4 = srgData.GetConstantRaw(vector3index);
AZStd::span<const uint8_t> resutV4 = srgData.GetConstantRaw(vector3index);
const Vector4 v4result = *reinterpret_cast<const Vector4*>(resutV4.data());
EXPECT_NE(v4result, vector4);
@@ -544,7 +544,7 @@ namespace UnitTest
AZ_TEST_START_ASSERTTEST;
EXPECT_FALSE(srgData.SetConstant(vector4index, vector3));
AZ_TEST_STOP_ASSERTTEST(1);
AZStd::array_view<uint8_t> resutV3FromIndex4 = srgData.GetConstantRaw(vector4index);
AZStd::span<const uint8_t> resutV3FromIndex4 = srgData.GetConstantRaw(vector4index);
const Vector4 v4resultFromIndex4 = *reinterpret_cast<const Vector4*>(resutV3FromIndex4.data());
EXPECT_NE(v4resultFromIndex4, vector4);
}
Gems/Atom/RHI/DX12/Code/Include/Atom/RHI.Reflect/DX12/ShaderStageFunction.h
+2 -2
View File
@@ -8,7 +8,7 @@
#pragma once
#include <Atom/RHI.Reflect/ShaderStageFunction.h>
#include <AtomCore/std/containers/array_view.h>
#include <AzCore/std/containers/span.h>
#include <AzCore/Memory/SystemAllocator.h>
#include <AzCore/std/containers/array.h>
#include <AzCore/std/containers/vector.h>
@@ -19,7 +19,7 @@ namespace AZ
namespace DX12
{
using ShaderByteCode = AZStd::vector<uint8_t>;
using ShaderByteCodeView = AZStd::array_view<uint8_t>;
using ShaderByteCodeView = AZStd::span<const uint8_t>;
/**
* A set of indices used to access physical sub-stages within a virtual stage.
Gems/Atom/RHI/DX12/Code/Source/RHI/AsyncUploadQueue.h
+1 -1
View File
@@ -9,7 +9,7 @@
#include <RHI/CommandQueue.h>
#include <AtomCore/std/containers/array_view.h>
#include <AzCore/std/containers/span.h>
namespace AZ
{
Gems/Atom/RHI/DX12/Code/Source/RHI/CommandList.cpp
+2 -2
View File
@@ -129,14 +129,14 @@ namespace AZ
const RHI::Viewport* viewports,
uint32_t count)
{
m_state.m_viewportState.Set(AZStd::array_view<RHI::Viewport>(viewports, count));
m_state.m_viewportState.Set(AZStd::span<const RHI::Viewport>(viewports, count));
}
void CommandList::SetScissors(
const RHI::Scissor* scissors,
uint32_t count)
{
m_state.m_scissorState.Set(AZStd::array_view<RHI::Scissor>(scissors, count));
m_state.m_scissorState.Set(AZStd::span<const RHI::Scissor>(scissors, count));
}
void CommandList::SetShaderResourceGroupForDraw(const RHI::ShaderResourceGroup& shaderResourceGroup)
Gems/Atom/RHI/DX12/Code/Source/RHI/CommandList.h
+1 -1
View File
@@ -18,7 +18,7 @@
#include <Atom/RHI/CommandListValidator.h>
#include <Atom/RHI/CommandListStates.h>
#include <Atom/RHI/ObjectPool.h>
#include <AtomCore/std/containers/array_view.h>
#include <AzCore/std/containers/span.h>
#include <AzCore/Memory/SystemAllocator.h>
#include <AzCore/std/containers/array.h>
Gems/Atom/RHI/DX12/Code/Source/RHI/PipelineLibrary.cpp
+4 -4
View File
@@ -46,7 +46,7 @@ namespace AZ
ID3D12DeviceX* dx12Device = device.GetDevice();
#if defined (AZ_DX12_USE_PIPELINE_LIBRARY)
AZStd::array_view<uint8_t> bytes;
AZStd::span<const uint8_t> bytes;
bool shouldCreateLibFromSerializedData = true;
if (RHI::Factory::Get().IsRenderDocModuleLoaded() ||
@@ -214,7 +214,7 @@ namespace AZ
#endif
}
RHI::ResultCode PipelineLibrary::MergeIntoInternal([[maybe_unused]] AZStd::array_view<const RHI::PipelineLibrary*> pipelineLibraries)
RHI::ResultCode PipelineLibrary::MergeIntoInternal([[maybe_unused]] AZStd::span<const RHI::PipelineLibrary* const> pipelineLibraries)
{
if (RHI::Factory::Get().IsRenderDocModuleLoaded() ||
RHI::Factory::Get().IsPixModuleLoaded())
@@ -239,14 +239,14 @@ namespace AZ
}
}
#endif
return RHI::ResultCode::Success;
return RHI::ResultCode::Success;
}
RHI::ConstPtr<RHI::PipelineLibraryData> PipelineLibrary::GetSerializedDataInternal() const
{
#if defined (AZ_DX12_USE_PIPELINE_LIBRARY)
AZStd::lock_guard<AZStd::mutex> lock(m_mutex);
AZStd::vector<uint8_t> serializedData(m_library->GetSerializedSize());
HRESULT hr = m_library->Serialize(serializedData.data(), serializedData.size());
Gems/Atom/RHI/DX12/Code/Source/RHI/PipelineLibrary.h
+1 -1
View File
@@ -33,7 +33,7 @@ namespace AZ
// RHI::PipelineLibrary
RHI::ResultCode InitInternal(RHI::Device& device, const RHI::PipelineLibraryData* serializedData) override;
void ShutdownInternal() override;
RHI::ResultCode MergeIntoInternal(AZStd::array_view<const RHI::PipelineLibrary*> libraries) override;
RHI::ResultCode MergeIntoInternal(AZStd::span<const RHI::PipelineLibrary* const> libraries) override;
RHI::ConstPtr<RHI::PipelineLibraryData> GetSerializedDataInternal() const override;
bool IsMergeRequired() const;
//////////////////////////////////////////////////////////////////////////
Gems/Atom/RHI/DX12/Code/Source/RHI/ShaderResourceGroupPool.cpp
+13 -13
View File
@@ -20,7 +20,7 @@ namespace AZ
namespace DX12
{
template<typename T, typename U>
AZStd::vector<DescriptorHandle> ShaderResourceGroupPool::GetSRVsFromImageViews(const AZStd::array_view<RHI::ConstPtr<T>>& imageViews, D3D12_SRV_DIMENSION dimension)
AZStd::vector<DescriptorHandle> ShaderResourceGroupPool::GetSRVsFromImageViews(const AZStd::span<const RHI::ConstPtr<T>>& imageViews, D3D12_SRV_DIMENSION dimension)
{
AZStd::vector<DescriptorHandle> cpuSourceDescriptors(imageViews.size(), m_descriptorContext->GetNullHandleSRV(dimension));
@@ -36,7 +36,7 @@ namespace AZ
}
template<typename T, typename U>
AZStd::vector<DescriptorHandle> ShaderResourceGroupPool::GetUAVsFromImageViews(const AZStd::array_view<RHI::ConstPtr<T>>& imageViews, D3D12_UAV_DIMENSION dimension)
AZStd::vector<DescriptorHandle> ShaderResourceGroupPool::GetUAVsFromImageViews(const AZStd::span<const RHI::ConstPtr<T>>& imageViews, D3D12_UAV_DIMENSION dimension)
{
AZStd::vector<DescriptorHandle> cpuSourceDescriptors(imageViews.size(), m_descriptorContext->GetNullHandleUAV(dimension));
for (size_t i = 0; i < cpuSourceDescriptors.size(); ++i)
@@ -50,7 +50,7 @@ namespace AZ
return cpuSourceDescriptors;
}
AZStd::vector<DescriptorHandle> ShaderResourceGroupPool::GetCBVsFromBufferViews(const AZStd::array_view<RHI::ConstPtr<RHI::BufferView>>& bufferViews)
AZStd::vector<DescriptorHandle> ShaderResourceGroupPool::GetCBVsFromBufferViews(const AZStd::span<const RHI::ConstPtr<RHI::BufferView>>& bufferViews)
{
AZStd::vector<DescriptorHandle> cpuSourceDescriptors(bufferViews.size(), m_descriptorContext->GetNullHandleCBV());
@@ -278,7 +278,7 @@ namespace AZ
{
const RHI::ShaderInputBufferIndex bufferInputIndex(shaderInputIndex);
AZStd::array_view<RHI::ConstPtr<RHI::BufferView>> bufferViews = groupData.GetBufferViewArray(bufferInputIndex);
AZStd::span<const RHI::ConstPtr<RHI::BufferView>> bufferViews = groupData.GetBufferViewArray(bufferInputIndex);
D3D12_DESCRIPTOR_RANGE_TYPE descriptorRangeType = ConvertShaderInputBufferAccess(shaderInputBuffer.m_access);
AZStd::vector<DescriptorHandle> descriptorHandles;
switch (descriptorRangeType)
@@ -313,7 +313,7 @@ namespace AZ
{
const RHI::ShaderInputImageIndex imageInputIndex(shaderInputIndex);
AZStd::array_view<RHI::ConstPtr<RHI::ImageView>> imageViews = groupData.GetImageViewArray(imageInputIndex);
AZStd::span<const RHI::ConstPtr<RHI::ImageView>> imageViews = groupData.GetImageViewArray(imageInputIndex);
D3D12_DESCRIPTOR_RANGE_TYPE descriptorRangeType = ConvertShaderInputImageAccess(shaderInputImage.m_access);
AZStd::vector<DescriptorHandle> descriptorHandles;
@@ -349,7 +349,7 @@ namespace AZ
{
const RHI::ShaderInputSamplerIndex samplerInputIndex(shaderInputIndex);
AZStd::array_view<RHI::SamplerState> samplers = groupData.GetSamplerArray(samplerInputIndex);
AZStd::span<const RHI::SamplerState> samplers = groupData.GetSamplerArray(samplerInputIndex);
UpdateDescriptorTableRange(descriptorTable, samplerInputIndex, samplers);
}
}
@@ -364,7 +364,7 @@ namespace AZ
for (const RHI::ShaderInputBufferUnboundedArrayDescriptor& shaderInputBufferUnboundedArray : groupLayout.GetShaderInputListForBufferUnboundedArrays())
{
const RHI::ShaderInputBufferUnboundedArrayIndex bufferUnboundedArrayInputIndex(shaderInputIndex);
AZStd::array_view<RHI::ConstPtr<RHI::BufferView>> bufferViews = groupData.GetBufferViewUnboundedArray(bufferUnboundedArrayInputIndex);
AZStd::span<const RHI::ConstPtr<RHI::BufferView>> bufferViews = groupData.GetBufferViewUnboundedArray(bufferUnboundedArrayInputIndex);
uint32_t tableIndex = shaderInputIndex * RHI::Limits::Device::FrameCountMax + group.m_compiledDataIndex;
@@ -403,7 +403,7 @@ namespace AZ
for (const RHI::ShaderInputImageUnboundedArrayDescriptor& shaderInputImageUnboundedArray : groupLayout.GetShaderInputListForImageUnboundedArrays())
{
const RHI::ShaderInputImageUnboundedArrayIndex imageUnboundedArrayInputIndex(shaderInputIndex);
AZStd::array_view<RHI::ConstPtr<RHI::ImageView>> imageViews = groupData.GetImageViewUnboundedArray(imageUnboundedArrayInputIndex);
AZStd::span<const RHI::ConstPtr<RHI::ImageView>> imageViews = groupData.GetImageViewUnboundedArray(imageUnboundedArrayInputIndex);
uint32_t tableIndex = shaderInputIndex * RHI::Limits::Device::FrameCountMax + group.m_compiledDataIndex;
@@ -447,7 +447,7 @@ namespace AZ
RHI::ShaderInputBufferAccess bufferAccess)
{
const RHI::ShaderInputBufferUnboundedArrayIndex bufferUnboundedArrayInputIndex(shaderInputIndex);
AZStd::array_view<RHI::ConstPtr<RHI::BufferView>> bufferViews =
AZStd::span<const RHI::ConstPtr<RHI::BufferView>> bufferViews =
groupData.GetBufferViewUnboundedArray(bufferUnboundedArrayInputIndex);
if (bufferViews.empty())
@@ -488,7 +488,7 @@ namespace AZ
RHI::ShaderInputImageType imageType)
{
const RHI::ShaderInputImageUnboundedArrayIndex imageUnboundedArrayInputIndex(shaderInputIndex);
AZStd::array_view<RHI::ConstPtr<RHI::ImageView>> imageViews =
AZStd::span<const RHI::ConstPtr<RHI::ImageView>> imageViews =
groupData.GetImageViewUnboundedArray(imageUnboundedArrayInputIndex);
if (imageViews.empty())
@@ -565,7 +565,7 @@ namespace AZ
for (const RHI::ShaderInputBufferUnboundedArrayDescriptor& shaderInputBufferUnboundedArray : groupLayout.GetShaderInputListForBufferUnboundedArrays())
{
const RHI::ShaderInputBufferUnboundedArrayIndex bufferUnboundedArrayInputIndex(shaderInputIndex);
AZStd::array_view<RHI::ConstPtr<RHI::BufferView>> bufferViews = groupData.GetBufferViewUnboundedArray(bufferUnboundedArrayInputIndex);
AZStd::span<const RHI::ConstPtr<RHI::BufferView>> bufferViews = groupData.GetBufferViewUnboundedArray(bufferUnboundedArrayInputIndex);
uint32_t tableIndex = shaderInputIndex * RHI::Limits::Device::FrameCountMax + group.m_compiledDataIndex;
if (!bufferViews.empty())
@@ -597,7 +597,7 @@ namespace AZ
groupLayout.GetShaderInputListForImageUnboundedArrays())
{
const RHI::ShaderInputImageUnboundedArrayIndex imageUnboundedArrayInputIndex(shaderInputIndex);
AZStd::array_view<RHI::ConstPtr<RHI::ImageView>> imageViews =
AZStd::span<const RHI::ConstPtr<RHI::ImageView>> imageViews =
groupData.GetImageViewUnboundedArray(imageUnboundedArrayInputIndex);
uint32_t tableIndex = shaderInputIndex * RHI::Limits::Device::FrameCountMax + group.m_compiledDataIndex;
@@ -675,7 +675,7 @@ namespace AZ
void ShaderResourceGroupPool::UpdateDescriptorTableRange(
DescriptorTable descriptorTable,
RHI::ShaderInputSamplerIndex samplerInputIndex,
AZStd::array_view<RHI::SamplerState> samplerStates)
AZStd::span<const RHI::SamplerState> samplerStates)
{
const DescriptorHandle nullHandle = m_descriptorContext->GetNullHandleSampler();
AZStd::vector<DescriptorHandle> cpuSourceDescriptors(aznumeric_caster(samplerStates.size()), nullHandle);
Gems/Atom/RHI/DX12/Code/Source/RHI/ShaderResourceGroupPool.h
+4 -4
View File
@@ -82,7 +82,7 @@ namespace AZ
void UpdateDescriptorTableRange(
DescriptorTable descriptorTable,
RHI::ShaderInputSamplerIndex samplerIndex,
AZStd::array_view<RHI::SamplerState> samplerStates);
AZStd::span<const RHI::SamplerState> samplerStates);
//Cache all the gpu handles for the Descriptor tables related to all the views
void CacheGpuHandlesForViews(ShaderResourceGroup& group);
@@ -93,12 +93,12 @@ namespace AZ
DescriptorTable GetSamplerTable(DescriptorTable descriptorTable, RHI::ShaderInputSamplerIndex samplerInputIndex) const;
template<typename T, typename U>
AZStd::vector<DescriptorHandle> GetSRVsFromImageViews(const AZStd::array_view<RHI::ConstPtr<T>>& imageViews, D3D12_SRV_DIMENSION dimension);
AZStd::vector<DescriptorHandle> GetSRVsFromImageViews(const AZStd::span<const RHI::ConstPtr<T>>& imageViews, D3D12_SRV_DIMENSION dimension);
template<typename T, typename U>
AZStd::vector<DescriptorHandle> GetUAVsFromImageViews(const AZStd::array_view<RHI::ConstPtr<T>>& bufferViews, D3D12_UAV_DIMENSION dimension);
AZStd::vector<DescriptorHandle> GetUAVsFromImageViews(const AZStd::span<const RHI::ConstPtr<T>>& bufferViews, D3D12_UAV_DIMENSION dimension);
AZStd::vector<DescriptorHandle> GetCBVsFromBufferViews(const AZStd::array_view<RHI::ConstPtr<RHI::BufferView>>& bufferViews);
AZStd::vector<DescriptorHandle> GetCBVsFromBufferViews(const AZStd::span<const RHI::ConstPtr<RHI::BufferView>>& bufferViews);
MemoryPoolSubAllocator m_constantAllocator;
DescriptorContext* m_descriptorContext = nullptr;
Gems/Atom/RHI/Metal/Code/Include/Atom/RHI.Reflect/Metal/ShaderStageFunction.h
+1 -1
View File
@@ -9,7 +9,7 @@
#include <Atom/RHI.Reflect/Metal/Base.h>
#include <Atom/RHI.Reflect/ShaderStageFunction.h>
#include <AtomCore/std/containers/array_view.h>
#include <AzCore/std/containers/span.h>
#include <AzCore/Memory/SystemAllocator.h>
#include <AzCore/std/containers/array.h>
#include <AzCore/std/containers/vector.h>
Gems/Atom/RHI/Metal/Code/Source/RHI.Builders/ShaderPlatformInterface.cpp
+74 -74
View File
@@ -53,7 +53,7 @@ namespace AZ
{
return AZ::Metal::PipelineLayoutDescriptor::Create();
}
bool ShaderPlatformInterface::BuildPipelineLayoutDescriptor(
RHI::Ptr<RHI::PipelineLayoutDescriptor> pipelineLayoutDescriptor,
const ShaderResourceGroupInfoList& srgInfoList,
@@ -62,10 +62,10 @@ namespace AZ
{
AZ::Metal::PipelineLayoutDescriptor* metalDescriptor = azrtti_cast<AZ::Metal::PipelineLayoutDescriptor*>(pipelineLayoutDescriptor.get());
AZ_Assert(metalDescriptor, "PipelineLayoutDescriptor should have been created by now");
const uint32_t groupLayoutCount = static_cast<uint32_t>(srgInfoList.size());
AZ_Assert(groupLayoutCount <= RHI::Limits::Pipeline::ShaderResourceGroupCountMax, "Exceeded ShaderResourceGroupLayout count limit.");
// Slot to index mapping
AZ::Metal::SlotToIndexTable slotToIndexTable;
AZ::Metal::IndexToSlotTable indexToSlotTable;
@@ -81,17 +81,17 @@ namespace AZ
{
return first.m_layout->GetBindingSlot() < second.m_layout->GetBindingSlot();
});
for (uint32_t groupLayoutIndex = 0; groupLayoutIndex < groupLayoutCount; ++groupLayoutIndex)
{
const auto& srgInfo = sortedSrgInfos[groupLayoutIndex];
const RHI::ShaderResourceGroupLayout& groupLayout = *srgInfo.m_layout;
const uint32_t srgLayoutSlot = groupLayout.GetBindingSlot();
AZ_Assert(srgLayoutSlot <= RHI::Limits::Pipeline::ShaderResourceGroupCountMax, "Cannot exceed the array limit");
slotToIndexTable[srgLayoutSlot] = groupLayoutIndex;
indexToSlotTable[groupLayoutIndex] = srgLayoutSlot;
ShaderResourceGroupVisibility srgVisibility;
for (const auto& resourceBindInfo : srgInfo.m_bindingInfo.m_resourcesRegisterMap)
{
@@ -99,24 +99,24 @@ namespace AZ
}
srgVisibility.m_constantDataStageMask = srgInfo.m_bindingInfo.m_constantDataBindingInfo.m_shaderStageMask;
metalDescriptor->AddShaderResourceGroupVisibility(srgVisibility);
//cache the layout in order to fill out unused variables
m_srgLayouts[groupLayoutIndex] = srgInfo.m_layout;
}
if (rootConstantsInfo.m_totalSizeInBytes > 0)
{
metalDescriptor->SetRootConstantBinding(RootConstantBinding{ rootConstantsInfo.m_registerId, rootConstantsInfo.m_spaceId });
}
metalDescriptor->SetBindingTables(slotToIndexTable, indexToSlotTable);
return metalDescriptor->Finalize() == RHI::ResultCode::Success;
}
RHI::Ptr<RHI::ShaderStageFunction> ShaderPlatformInterface::CreateShaderStageFunction(const StageDescriptor& stageDescriptor)
{
RHI::Ptr<ShaderStageFunction> newShaderStageFunction = ShaderStageFunction::Create(RHI::ToRHIShaderStage(stageDescriptor.m_stageType));
const Metal::ShaderSourceCode& sourceCode = stageDescriptor.m_sourceCode;
//Metal sourceCode is great for debugging but it is not needed as we are also packing the bytecode. This
@@ -127,7 +127,7 @@ namespace AZ
const AZStd::string& entryFunctionName = stageDescriptor.m_entryFunctionName;
newShaderStageFunction->SetByteCode(byteCode);
newShaderStageFunction->SetEntryFunctionName(entryFunctionName);
newShaderStageFunction->Finalize();
return newShaderStageFunction;
}
@@ -159,7 +159,7 @@ namespace AZ
return shaderCompilerArguments.MakeAdditionalAzslcCommandLineString() +
" --use-spaces --unique-idx --namespace=mt,vk --root-const=128 --pad-root-const";
}
AZStd::string ShaderPlatformInterface::GetAzslCompilerWarningParameters(const RHI::ShaderCompilerArguments& shaderCompilerArguments) const
{
return shaderCompilerArguments.MakeAdditionalAzslcWarningCommandLineString();
@@ -255,7 +255,7 @@ namespace AZ
// Stage profile name parameter
const AZStd::string shaderModelVersion = "6_2";
const AZStd::unordered_map<RHI::ShaderHardwareStage, AZStd::string> stageToProfileName =
{
{RHI::ShaderHardwareStage::Vertex, "vs_" + shaderModelVersion},
@@ -268,15 +268,15 @@ namespace AZ
AZ_Error(MetalShaderPlatformName, false, "Unsupported shader stage");
return false;
}
// For this approach we will be doing hlsl->spirv(through dxc) and spirv->metalSL(through spirv cross)
// Output spirv file
AZStd::string shaderSpirvOutputFile = RHI::BuildFileNameWithExtension(shaderSourceFile, tempFolder, "spirv");
// Compilation parameters
AZStd::string params = shaderCompilerArguments.MakeAdditionalDxcCommandLineString();
params += " -spirv"; // Generate SPIRV shader
// Enable half precision types when shader model >= 6.2
int shaderModelMajor = 0;
int shaderModelMinor = 0;
@@ -318,7 +318,7 @@ namespace AZ
params.c_str(), // 3
shaderSpirvOutputFile.c_str(), // 4
dxcInputFile.c_str()); // 5
// Run dxc Compiler
if (!RHI::ExecuteShaderCompiler(dxcRelativePath, dxcCommandOptions, shaderSourceFile, "DXC"))
{
@@ -329,9 +329,9 @@ namespace AZ
{
byProducts.m_intermediatePaths.insert(shaderSpirvOutputFile); // the spirv spit by DXC
}
IO::FileIOStream spirvOutFileStream(shaderSpirvOutputFile.data(), AZ::IO::OpenMode::ModeRead | AZ::IO::OpenMode::ModeBinary);
if (!spirvOutFileStream.IsOpen())
{
AZ_Error(MetalShaderPlatformName, false, "Failed because the shader file \"%s\" could not be opened", shaderSpirvOutputFile.data());
@@ -343,12 +343,12 @@ namespace AZ
spirvOutFileStream.Close();
return false;
}
// spirv cross compiler executable
static const char* spirvCrossRelativePath = "Builders/SPIRVCross/spirv-cross";
AZStd::string spirvCrossCommandOptions = AZStd::string::format("--msl --msl-version 20100 --msl-invariant-float-math --msl-argument-buffers --msl-decoration-binding --msl-texture-buffer-native --output \"%s\" \"%s\"", shaderMSLOutputFile.c_str(), shaderSpirvOutputFile.c_str());
// Run spirv cross
if (!RHI::ExecuteShaderCompiler(spirvCrossRelativePath, spirvCrossCommandOptions, shaderSpirvOutputFile, "SpirvCross"))
{
@@ -357,7 +357,7 @@ namespace AZ
return false;
}
spirvOutFileStream.Close();
IO::FileIOStream outFileStream(shaderMSLOutputFile.data(), IO::OpenMode::ModeRead);
bool finalizeShaderResult = UpdateCompiledShader(outFileStream, MetalShaderPlatformName, shaderMSLOutputFile.data(), sourceMetalShader);
AZ_Assert(finalizeShaderResult, "Final compiled shader was not created. Check if %s was created", shaderMSLOutputFile.c_str());
@@ -366,7 +366,7 @@ namespace AZ
{
byProducts.m_intermediatePaths.emplace(AZStd::move(shaderMSLOutputFile)); // .msl metal out of sv-cross
}
bool compileMetalSL = CreateMetalLib(MetalShaderPlatformName, shaderSourceFile, tempFolder, compiledByteCode, sourceMetalShader, platform);
if (!compileMetalSL)
{
@@ -376,7 +376,7 @@ namespace AZ
return finalizeShaderResult;
}
bool ShaderPlatformInterface::UpdateCompiledShader(AZ::IO::FileIOStream& fileStream, const char* platformName, const char* fileName, AZStd::vector<char>& compiledShader) const
{
if (!fileStream.IsOpen())
@@ -390,16 +390,16 @@ namespace AZ
fileStream.Close();
return false;
}
compiledShader.resize(fileStream.GetLength() + 1); // +1 to add end of string
memset(compiledShader.data(), 0, fileStream.GetLength() + 1);
fileStream.Read(fileStream.GetLength(), compiledShader.data());
fileStream.Close();
//Ensure that the argument buffer declaration in the shader matches the srg layout
return AddUnusedResources(compiledShader);
}
bool ShaderPlatformInterface::CreateMetalLib(const char* platformName,
const AZStd::string& shaderSourceFile,
const AZStd::string& tempFolder,
@@ -408,22 +408,22 @@ namespace AZ
const AssetBuilderSDK::PlatformInfo& platform) const
{
AZStd::string inputMetalFile = RHI::BuildFileNameWithExtension(shaderSourceFile, tempFolder, "metal");
AZ::IO::FileIOStream sourceMtlfileStream(inputMetalFile.c_str(), AZ::IO::OpenMode::ModeWrite | AZ::IO::OpenMode::ModeBinary);
if (!sourceMtlfileStream.IsOpen())
{
AZ_Error(platformName, false, "Failed because the shader file \"%s\" could not be opened", inputMetalFile.c_str());
return false;
}
AZStd::string mtlSource = AZStd::string(sourceMetalShader.begin(), sourceMetalShader.end());
sourceMtlfileStream.Write(mtlSource.size(), mtlSource.data());
sourceMtlfileStream.Close();
AZStd::string outputAirFile = RHI::BuildFileNameWithExtension(shaderSourceFile, tempFolder, "air");
AZStd::string outMetalLibFile = RHI::BuildFileNameWithExtension(shaderSourceFile, tempFolder, "metallib");
//Debug symbols are always enabled at the moment. Need to turn them off for optimized shader assets.
//Debug symbols are always enabled at the moment. Need to turn them off for optimized shader assets.
AZStd::string shaderDebugInfo = "-gline-tables-only -MO";
AZStd::string shaderMslToAirOptions = "-fpreserve-invariance";
@@ -434,47 +434,47 @@ namespace AZ
{
platformSdk = "iphoneos";
}
//Convert to air file
AZStd::string mslToAirCommandOptions = AZStd::string::format("-sdk %s metal \"%s\" %s %s -c -o \"%s\"", platformSdk.c_str(), inputMetalFile.c_str(), shaderDebugInfo.c_str(), shaderMslToAirOptions.c_str(), outputAirFile.c_str());
if (!RHI::ExecuteShaderCompiler("/usr/bin/xcrun", mslToAirCommandOptions, inputMetalFile, "MslToAir"))
{
AZ_Error(MetalShaderPlatformName, false, "Failed to convert to AIR file %s", inputMetalFile.c_str());
return false;
}
//convert to metallib
AZStd::string airToMetalLibCommandOptions = AZStd::string::format("-sdk %s metallib \"%s\" -o \"%s\"", platformSdk.c_str(), outputAirFile.c_str(), outMetalLibFile.c_str());
if (!RHI::ExecuteShaderCompiler("/usr/bin/xcrun", airToMetalLibCommandOptions, outputAirFile, "AirToMetallib"))
{
AZ_Error(MetalShaderPlatformName, false, "Failed to convert to metallib file");
return false;
}
AZ::IO::FileIOStream fileStream(outMetalLibFile.data(), AZ::IO::OpenMode::ModeRead);
compiledByteCode.resize(fileStream.GetLength());
memset(compiledByteCode.data(), 0, fileStream.GetLength() );
fileStream.Read(fileStream.GetLength(), compiledByteCode.data());
fileStream.Close();
return true;
}
bool ShaderPlatformInterface::AddUnusedResources(AZStd::vector<char>& compiledShader) const
{
AZStd::string finalMetalSLStr = AZStd::string(compiledShader.begin(), compiledShader.end());
const uint32_t groupLayoutCount = static_cast<uint32_t>(m_srgLayouts.size());
AZStd::string constantBufferTempStructs = "\n";
AZStd::string structuredBufferTempStructs = "\n";
for (uint32_t groupLayoutIndex = 0; groupLayoutIndex < groupLayoutCount; ++groupLayoutIndex)
{
//const auto& srgInfo = m_srgInfoList[groupLayoutIndex];
const RHI::ShaderResourceGroupLayout& groupLayout = *m_srgLayouts[groupLayoutIndex];
//Check if an argument buffer declaration exists for this srg layout.
AZStd::string srgBuffer = AZStd::string::format("spvDescriptorSetBuffer%i", groupLayoutIndex);
size_t startOfArgBufferPos = finalMetalSLStr.find(srgBuffer);
@@ -485,7 +485,7 @@ namespace AZ
size_t endOfArgBufferPos = finalMetalSLStr.find("}", startOfArgBufferPos);
AZStd::string fullArgBufferDeclarationStr = finalMetalSLStr.substr(startOfArgBufferPos,endOfArgBufferPos - startOfArgBufferPos + 1);
//Add all the existing or dummy entries into m_argBufferEntries which is a set. The reason for using a set
//is because we need the entries to be sorted based on the register and we do not want duplicates.
bool result = AddConstantBufferEntries(groupLayout, constantBufferTempStructs, fullArgBufferDeclarationStr, groupLayoutIndex);
@@ -494,44 +494,44 @@ namespace AZ
AZ_Error(MetalShaderPlatformName, false, "Failed because adding constant buffer entries within AddUnusedResources failed");
return false;
}
result = AddImageEntries(groupLayout, fullArgBufferDeclarationStr);
if(!result)
{
AZ_Error(MetalShaderPlatformName, false, "Failed because adding image entries within AddUnusedResources failed");
return false;
}
result = AddSamplerEntries(groupLayout, fullArgBufferDeclarationStr);
if(!result)
{
AZ_Error(MetalShaderPlatformName, false, "Failed because adding static sampler entries within AddUnusedResources failed");
return false;
}
result = AddBufferEntries(groupLayout, structuredBufferTempStructs, fullArgBufferDeclarationStr, groupLayoutIndex);
if(!result)
{
AZ_Error(MetalShaderPlatformName, false, "Failed because adding buffer entries within AddUnusedResources failed");
return false;
}
//Create a new spvDescriptorSetBuffer which matches the layout.
AZStd::string newArgBufferLayoutStr = "\n";
for (const ArgBufferEntries &entry : m_argBufferEntries )
{
newArgBufferLayoutStr += " " + entry.first + "\n";
}
//Replace the existing declaration with the new one just generated.
//We look for '{' and '}' to find out boundaries of the argument buffer declaration to replace
size_t startOfArgBufferBracketPos = finalMetalSLStr.find("{", startOfArgBufferPos) + 1;
size_t endOfArgBufferBracketPos = finalMetalSLStr.find("}", startOfArgBufferBracketPos) - 1;
finalMetalSLStr.replace(startOfArgBufferBracketPos, endOfArgBufferBracketPos - startOfArgBufferBracketPos, newArgBufferLayoutStr);
m_argBufferEntries.clear();
}
//Add dummy definitions of constant buffer and structured buffer types to the top of the file
AZStd::string startOfShaderTag = "using namespace metal;";
const size_t startOfShaderPos = finalMetalSLStr.find(startOfShaderTag);
@@ -540,28 +540,28 @@ namespace AZ
finalMetalSLStr.insert(startOfShaderPos + startOfShaderTag.length() + 1, constantBufferTempStructs);
finalMetalSLStr.insert(startOfShaderPos + startOfShaderTag.length() + 1, structuredBufferTempStructs);
}
compiledShader = AZStd::vector<char>(finalMetalSLStr.begin(), finalMetalSLStr.end());
return true;
}
bool ShaderPlatformInterface::AddConstantBufferEntries(const RHI::ShaderResourceGroupLayout& groupLayout,
AZStd::string& constantBufferTempStructs,
AZStd::string& argBufferStr,
uint32_t groupLayoutIndex) const
{
AZStd::array_view<RHI::ShaderInputConstantDescriptor> shaderInputConstantList = groupLayout.GetShaderInputListForConstants();
AZStd::span<const RHI::ShaderInputConstantDescriptor> shaderInputConstantList = groupLayout.GetShaderInputListForConstants();
if (shaderInputConstantList.empty())
{
return true;
}
//Only need the information from the first element of the constant buffer.
const RHI::ShaderInputConstantDescriptor& shaderInputConstant = shaderInputConstantList[0];
uint32_t regId = shaderInputConstant.m_registerId;
AZStd::string srgResource = AZStd::string::format("id(%i)", regId);
size_t resourceStartPos = argBufferStr.find(srgResource);
//Check if we need to create a dummy entry
if (resourceStartPos == AZStd::string::npos)
@@ -578,7 +578,7 @@ namespace AZ
*
*/
constantBufferTempStructs += AZStd::string::format("struct type_DummyStruct%i_DescSet%i\n{\n float dummyArray[%i];\n};\n", regId, groupLayoutIndex, numElements);
//Create the final resource entry to be added to the set
AZStd::string dummyResource = AZStd::string::format("constant type_DummyStruct%i_DescSet%i* dummyConstantBuffer%i [[id(%i)]];", regId, groupLayoutIndex, regId, regId);
m_argBufferEntries.insert(AZStd::make_pair(dummyResource, regId));
@@ -590,7 +590,7 @@ namespace AZ
return AddExistingResourceEntry("constant type_ConstantBuffer", resourceStartPos, regId, argBufferStr);
}
}
bool ShaderPlatformInterface::AddImageEntries(const RHI::ShaderResourceGroupLayout& groupLayout,
AZStd::string& argBufferStr) const
{
@@ -599,7 +599,7 @@ namespace AZ
{
uint32_t regId = shaderInputImage.m_registerId;
AZStd::string srgResource = AZStd::string::format("id(%i)", regId);
const size_t resourceStartPos = argBufferStr.find(srgResource);
//Check if we need to create a dummy entry
if (resourceStartPos == AZStd::string::npos)
@@ -652,7 +652,7 @@ namespace AZ
AZ_Assert(false, "Invalid texture type.");
}
}
//Create the resource entry to be added to the set. Handle arrays by checking the shaderInputImage.m_count
AZStd::string dummyResource;
if(shaderInputImage.m_count > 1)
@@ -678,11 +678,11 @@ namespace AZ
}
return result;
}
bool ShaderPlatformInterface::ProcessSamplerEntry(uint32_t regId, AZStd::string& argBufferStr, uint32_t samplercount) const
{
AZStd::string srgResource = AZStd::string::format("id(%i)", regId);
const size_t resourceStartPos = argBufferStr.find(srgResource);
//Check if we need to create a dummy entry
if (resourceStartPos == AZStd::string::npos)
@@ -705,7 +705,7 @@ namespace AZ
return AddExistingResourceEntry("sampler", resourceStartPos, regId, argBufferStr);
}
}
bool ShaderPlatformInterface::AddSamplerEntries(const RHI::ShaderResourceGroupLayout& groupLayout,
AZStd::string& argBufferStr) const
{
@@ -714,15 +714,15 @@ namespace AZ
{
result &= ProcessSamplerEntry(staticSampler.m_registerId, argBufferStr, 0);
}
for (const RHI::ShaderInputSamplerDescriptor& dynamicSampler : groupLayout.GetShaderInputListForSamplers())
{
result &= ProcessSamplerEntry(dynamicSampler.m_registerId, argBufferStr, dynamicSampler.m_count);
}
return result;
}
bool ShaderPlatformInterface::AddBufferEntries(const RHI::ShaderResourceGroupLayout& groupLayout,
AZStd::string& structuredBufferTempStructs,
AZStd::string& argBufferStr,
@@ -733,7 +733,7 @@ namespace AZ
{
uint32_t regId = shaderInputBuffer.m_registerId;
AZStd::string srgResource = AZStd::string::format("id(%i)", regId);
size_t resourceStartPos = argBufferStr.find(srgResource);
//Check if we need to create a dummy entry
if (resourceStartPos == AZStd::string::npos)
@@ -755,7 +755,7 @@ namespace AZ
*/
structuredBufferTempStructs += AZStd::string::format("struct DummySRG_%s_DescSet%i\n{\n float dummyArray[%i];\n};\n", shaderInputBuffer.m_name.GetCStr(), groupLayoutIndex, numElements);
structuredBufferTempStructs += AZStd::string::format("struct type_RWStructuredDummyBuffer%i_DescSet%i\n{\n DummySRG_%s_DescSet%i _m0[%i];\n};\n", regId, groupLayoutIndex, shaderInputBuffer.m_name.GetCStr(), groupLayoutIndex, shaderInputBuffer.m_count);
//Create the final resource entry to be added to the set
AZStd::string dummyResource = AZStd::string::format("device type_RWStructuredDummyBuffer%i_DescSet%i* dummyStructuredBuffer%i [[id(%i)]];", regId, groupLayoutIndex, regId, regId);
m_argBufferEntries.insert(AZStd::make_pair(dummyResource, regId));
@@ -823,7 +823,7 @@ namespace AZ
}
return result;
}
bool ShaderPlatformInterface::AddExistingResourceEntry(const char* resourceStr,
size_t resourceStartPos,
uint32_t regId,
@@ -832,8 +832,8 @@ namespace AZ
size_t prevEndOfLine = argBufferStr.rfind("\n", resourceStartPos);
size_t nextEndOfLine = argBufferStr.find("\n", resourceStartPos);
size_t startOfEntryPos = argBufferStr.find(resourceStr, prevEndOfLine);
//Check to see if a valid entry is found.
//Check to see if a valid entry is found.
if(startOfEntryPos == AZStd::string::npos || startOfEntryPos > nextEndOfLine)
{
AZ_Error(MetalShaderPlatformName, startOfEntryPos != AZStd::string::npos, "Entry-> %s not found within Descriptor set %s", resourceStr, argBufferStr.c_str());
@@ -843,7 +843,7 @@ namespace AZ
{
size_t endOfEntryPos = argBufferStr.find("\n", startOfEntryPos);
AZ_Assert(endOfEntryPos != AZStd::string::npos, "Resource entry missing");
AZStd::string existingEntry = argBufferStr.substr(prevEndOfLine,endOfEntryPos - prevEndOfLine);
m_argBufferEntries.insert(AZStd::make_pair(existingEntry, regId));
return true;
Gems/Atom/RHI/Metal/Code/Source/RHI/ArgumentBuffer.cpp
+60 -60
View File
@@ -23,14 +23,14 @@ namespace AZ
{
return aznew ArgumentBuffer();
}
void ArgumentBuffer::Init(Device* device, RHI::ConstPtr<RHI::ShaderResourceGroupLayout> srgLayout, ShaderResourceGroup& group, ShaderResourceGroupPool* srgPool)
{
@autoreleasepool
{
m_device = device;
m_srgLayout = srgLayout;
m_constantBufferSize = srgLayout->GetConstantDataSize();
if (m_constantBufferSize)
{
@@ -47,23 +47,23 @@ namespace AZ
m_constantBuffer.SetName(constantBufferName.c_str());
AZ_Assert(m_constantBuffer.IsValid(), "Couldnt allocate memory for Constant buffer")
}
NSMutableArray* argBufferDecriptors = [[[NSMutableArray alloc] init] autorelease];
bool argDescriptorsCreated = CreateArgumentDescriptors(argBufferDecriptors);
if(argDescriptorsCreated)
{
NSSortDescriptor* sortDescriptor;
sortDescriptor = [[[NSSortDescriptor alloc] initWithKey:@"index"
ascending:YES] autorelease];
NSArray* sortedArgDescriptors = [argBufferDecriptors sortedArrayUsingDescriptors:@[sortDescriptor]];
m_argumentEncoder = [m_device->GetMtlDevice() newArgumentEncoderWithArguments:sortedArgDescriptors];
NSUInteger argumentBufferLength = m_argumentEncoder.encodedLength;
RHI::BufferDescriptor bufferDescriptor;
bufferDescriptor.m_byteCount = argumentBufferLength;
bufferDescriptor.m_bindFlags = RHI::BufferBindFlags::Constant;
AZStd::string argBufferName = "ArgumentBuffer";
@@ -77,24 +77,24 @@ namespace AZ
m_argumentBuffer.SetName(argBufferName.c_str());
SetName(Name(argBufferName.c_str()));
//Attach the argument buffer to the argument encoder
[m_argumentEncoder setArgumentBuffer:m_argumentBuffer.GetGpuAddress<id<MTLBuffer>>()
offset:m_argumentBuffer.GetOffset()];
//Attach the static samplers
AttachStaticSamplers();
//Attach the constant buffer
AttachConstantBuffer();
}
}
}
bool ArgumentBuffer::CreateArgumentDescriptors(NSMutableArray* argBufferDecriptors)
{
bool resourceAdded = false;
for (const RHI::ShaderInputBufferDescriptor& shaderInputBuffer : m_srgLayout->GetShaderInputListForBuffers())
{
MTLArgumentDescriptor* bufferArgDescriptor = [[[MTLArgumentDescriptor alloc] init] autorelease];
@@ -102,7 +102,7 @@ namespace AZ
[argBufferDecriptors addObject:bufferArgDescriptor];
resourceAdded = true;
}
for (const RHI::ShaderInputImageDescriptor& shaderInputImage : m_srgLayout->GetShaderInputListForImages())
{
MTLArgumentDescriptor* imgArgDescriptor = [[[MTLArgumentDescriptor alloc] init] autorelease];
@@ -110,7 +110,7 @@ namespace AZ
[argBufferDecriptors addObject:imgArgDescriptor];
resourceAdded = true;
}
for (const RHI::ShaderInputSamplerDescriptor& shaderInputSampler : m_srgLayout->GetShaderInputListForSamplers())
{
MTLArgumentDescriptor* samplerArgDescriptor = [[[MTLArgumentDescriptor alloc] init] autorelease];
@@ -121,7 +121,7 @@ namespace AZ
[argBufferDecriptors addObject:samplerArgDescriptor];
resourceAdded = true;
}
for (const RHI::ShaderInputStaticSamplerDescriptor& staticSamplerInput : m_srgLayout->GetStaticSamplers())
{
MTLArgumentDescriptor* staticSamplerArgDescriptor = [[[MTLArgumentDescriptor alloc] init] autorelease];
@@ -131,8 +131,8 @@ namespace AZ
[argBufferDecriptors addObject:staticSamplerArgDescriptor];
resourceAdded = true;
}
AZStd::array_view<RHI::ShaderInputConstantDescriptor> shaderInputConstantList = m_srgLayout->GetShaderInputListForConstants();
AZStd::span<const RHI::ShaderInputConstantDescriptor> shaderInputConstantList = m_srgLayout->GetShaderInputListForConstants();
if (!shaderInputConstantList.empty())
{
const RHI::ShaderInputConstantDescriptor& shaderInputConstant = shaderInputConstantList[0];
@@ -143,10 +143,10 @@ namespace AZ
[argBufferDecriptors addObject:constBufferArgDescriptor];
resourceAdded = true;
}
return resourceAdded;
}
void ArgumentBuffer::AttachStaticSamplers()
{
for (const RHI::ShaderInputStaticSamplerDescriptor& staticSampler : m_srgLayout->GetStaticSamplers())
@@ -157,17 +157,17 @@ namespace AZ
[m_argumentEncoder setSamplerState:mtlSamplerState atIndex:staticSampler.m_registerId];
}
}
void ArgumentBuffer::AttachConstantBuffer()
{
AZStd::array_view<RHI::ShaderInputConstantDescriptor> shaderInputConstantList = m_srgLayout->GetShaderInputListForConstants();
AZStd::span<const RHI::ShaderInputConstantDescriptor> shaderInputConstantList = m_srgLayout->GetShaderInputListForConstants();
if (!shaderInputConstantList.empty())
{
const RHI::ShaderInputConstantDescriptor& shaderInputConstant = shaderInputConstantList[0];
[m_argumentEncoder setBuffer:m_constantBuffer.GetGpuAddress<id<MTLBuffer>>() offset:m_constantBuffer.GetOffset() atIndex:shaderInputConstant.m_registerId];
}
}
void ArgumentBuffer::BindNullSamplers(uint32_t registerId, uint32_t samplerCount)
{
AZStd::array<id<MTLSamplerState>, MaxEntriesInArgTable> mtlSamplers;
@@ -177,25 +177,25 @@ namespace AZ
{
mtlSamplers[i] = nullMtlSampler;
}
NSRange range = {registerId, samplerCount};
[m_argumentEncoder setSamplerStates : mtlSamplers.data()
withRange : range];
}
void ArgumentBuffer::UpdateImageViews(const RHI::ShaderInputImageDescriptor& shaderInputImage,
const RHI::ShaderInputImageIndex shaderInputIndex,
const AZStd::array_view<RHI::ConstPtr<RHI::ImageView>>& imageViews)
const AZStd::span<const RHI::ConstPtr<RHI::ImageView>>& imageViews)
{
int imageArrayLen = 0;
AZStd::array<id<MTLTexture>, MaxEntriesInArgTable> mtlTextures;
for (const RHI::ConstPtr<RHI::ImageView>& imageViewBase : imageViews)
{
if (imageViewBase && !imageViewBase->IsStale())
{
const auto& imageView = static_cast<const ImageView&>(*imageViewBase);
RHI::Ptr<Memory> textureMemPtr = imageView.GetMemoryView().GetMemory();
mtlTextures[imageArrayLen] = textureMemPtr->GetGpuAddress<id<MTLTexture>>();
m_resourceBindings[shaderInputImage.m_name].insert(ResourceBindingData{textureMemPtr, .m_imageAccess = shaderInputImage.m_access});
@@ -208,7 +208,7 @@ namespace AZ
}
imageArrayLen++;
}
AZ_Assert(imageArrayLen==shaderInputImage.m_count, "Make sure we have created the correct length of texture array");
if(imageArrayLen > 0)
{
@@ -217,10 +217,10 @@ namespace AZ
withRange : range];
}
}
void ArgumentBuffer::UpdateSamplers(const RHI::ShaderInputSamplerDescriptor& shaderInputSampler,
const RHI::ShaderInputSamplerIndex shaderInputIndex,
const AZStd::array_view<RHI::SamplerState>& samplerStates)
const AZStd::span<const RHI::SamplerState>& samplerStates)
{
int samplerArrayLen = 0;
AZStd::array<id<MTLSamplerState>, MaxEntriesInArgTable> mtlSamplers;
@@ -232,7 +232,7 @@ namespace AZ
mtlSamplers[samplerArrayLen] = GetMtlSampler(samplerDesc);
samplerArrayLen++;
}
AZ_Assert(samplerArrayLen==shaderInputSampler.m_count, "Make sure we dont have a nil sampler within mtlSamplers");
if(samplerArrayLen > 0)
{
@@ -245,16 +245,16 @@ namespace AZ
BindNullSamplers(shaderInputSampler.m_registerId, shaderInputSampler.m_count);
}
}
void ArgumentBuffer::UpdateBufferViews(const RHI::ShaderInputBufferDescriptor& shaderInputBuffer,
const RHI::ShaderInputBufferIndex shaderInputIndex,
const AZStd::array_view<RHI::ConstPtr<RHI::BufferView>>& bufferViews)
const AZStd::span<const RHI::ConstPtr<RHI::BufferView>>& bufferViews)
{
int bufferArrayLen = 0;
AZStd::array<id<MTLBuffer>, MaxEntriesInArgTable> mtlBuffers;
AZStd::array<NSUInteger, MaxEntriesInArgTable> mtlBufferOffsets;
AZStd::array<id<MTLTexture>, MaxEntriesInArgTable> mtlTextures;
for (const RHI::ConstPtr<RHI::BufferView>& bufferViewBase : bufferViews)
{
if (bufferViewBase && !bufferViewBase->IsStale())
@@ -298,12 +298,12 @@ namespace AZ
bufferArrayLen++;
}
AZ_Assert(bufferArrayLen==shaderInputBuffer.m_count, "Make sure we have created the correct length of buffer array");
if(bufferArrayLen > 0)
{
NSRange range = {shaderInputBuffer.m_registerId, bufferArrayLen};
if(shaderInputBuffer.m_type == RHI::ShaderInputBufferType::Typed)
{
[m_argumentEncoder setTextures : mtlTextures.data()
@@ -317,8 +317,8 @@ namespace AZ
}
}
}
void ArgumentBuffer::UpdateConstantBufferViews(AZStd::array_view<uint8_t> rawData)
void ArgumentBuffer::UpdateConstantBufferViews(AZStd::span<const uint8_t> rawData)
{
AZ_Assert(rawData.size() <= m_constantBufferSize, "rawData size can not be bigger than constant Buffer Size");
if ( (m_constantBufferSize > 0) && (rawData.size() <= m_constantBufferSize))
@@ -326,11 +326,11 @@ namespace AZ
memcpy(m_constantBuffer.GetCpuAddress(), rawData.data(), rawData.size());
}
}
void ArgumentBuffer::Shutdown()
{
ClearResourceTracking();
#if defined(ARGUMENTBUFFER_PAGEALLOCATOR)
if(m_constantBuffer.IsValid())
{
@@ -339,13 +339,13 @@ namespace AZ
if(m_argumentBuffer.IsValid())
{
m_device->GetArgumentBufferAllocator().DeAllocate(m_argumentBuffer);
}
}
#else
if(m_argumentBuffer.IsValid())
{
m_device->QueueForRelease(m_argumentBuffer);
}
if(m_constantBuffer.IsValid())
{
m_device->QueueForRelease(m_constantBuffer);
@@ -354,28 +354,28 @@ namespace AZ
m_argumentBuffer = {};
m_constantBuffer = {};
[m_argumentEncoder release];
m_argumentEncoder = nil;
Base::Shutdown();
}
id<MTLBuffer> ArgumentBuffer::GetArgEncoderBuffer() const
{
return m_argumentBuffer.GetGpuAddress<id<MTLBuffer>>();
};
size_t ArgumentBuffer::GetOffset() const
{
return m_argumentBuffer.GetOffset();
};
void ArgumentBuffer::ClearResourceTracking()
{
m_resourceBindings.clear();
}
id<MTLSamplerState> ArgumentBuffer::GetMtlSampler(MTLSamplerDescriptor* samplerDesc)
{
const NSCache* samplerCache = m_device->GetSamplerCache();
@@ -385,10 +385,10 @@ namespace AZ
mtlSamplerState = [m_device->GetMtlDevice() newSamplerStateWithDescriptor:samplerDesc];
[samplerCache setObject:mtlSamplerState forKey:samplerDesc];
}
return mtlSamplerState;
}
void ArgumentBuffer::CollectUntrackedResources(id<MTLCommandEncoder> commandEncoder,
const ShaderResourceGroupVisibility& srgResourcesVisInfo,
ComputeResourcesToMakeResidentMap& resourcesToMakeResidentCompute,
@@ -408,19 +408,19 @@ namespace AZ
else
{
MTLRenderStages mtlRenderStages = GetRenderStages(srgResourcesVisInfo.m_constantDataStageMask);
AZStd::pair <MTLResourceUsage,MTLRenderStages> key = AZStd::make_pair(MTLResourceUsageRead, mtlRenderStages);
AZStd::pair <MTLResourceUsage,MTLRenderStages> key = AZStd::make_pair(MTLResourceUsageRead, mtlRenderStages);
resourcesToMakeResidentGraphics[key].emplace(mtlconstantBufferResource);
}
}
}
//Cach all the resources within a srg that are used by the shader based on the visibility information
for (const auto& it : m_resourceBindings)
{
//Extract the visibility mask for the give resource
auto visMaskIt = srgResourcesVisInfo.m_resourcesStageMask.find(it.first);
AZ_Assert(visMaskIt != srgResourcesVisInfo.m_resourcesStageMask.end(), "No Visibility information available")
uint8_t numBitsSet = RHI::CountBitsSet(static_cast<uint64_t>(visMaskIt->second));
//Only use this resource if it is used in one of the shaders
if (numBitsSet > 0)
@@ -464,7 +464,7 @@ namespace AZ
AZ_Assert(false, "Undefined Resource type");
}
}
id<MTLResource> mtlResourceToBind = resourceBindingData.m_resourcPtr->GetGpuAddress<id<MTLResource>>();
resourcesToMakeResidentMap[resourceUsage].emplace(mtlResourceToBind);
}
@@ -475,7 +475,7 @@ namespace AZ
const ResourceBindingsSet& resourceBindingDataSet,
GraphicsResourcesToMakeResidentMap& resourcesToMakeResidentMap) const
{
MTLRenderStages mtlRenderStages = GetRenderStages(visShaderMask);
MTLResourceUsage resourceUsage = MTLResourceUsageRead;
for (const auto& resourceBindingData : resourceBindingDataSet)
@@ -498,17 +498,17 @@ namespace AZ
AZ_Assert(false, "Undefined Resource type");
}
}
AZStd::pair <MTLResourceUsage, MTLRenderStages> key = AZStd::make_pair(resourceUsage, mtlRenderStages);
id<MTLResource> mtlResourceToBind = resourceBindingData.m_resourcPtr->GetGpuAddress<id<MTLResource>>();
resourcesToMakeResidentMap[key].emplace(mtlResourceToBind);
}
}
bool ArgumentBuffer::IsNullHeapNeededForVertexStage(const ShaderResourceGroupVisibility& srgResourcesVisInfo) const
{
bool isUsedByVertexStage = false;
//Iterate over all the SRG entries
for (const auto& it : srgResourcesVisInfo.m_resourcesStageMask)
{
@@ -520,7 +520,7 @@ namespace AZ
}
return isUsedByVertexStage;
}
bool ArgumentBuffer::IsNullDescHeapNeeded() const
{
return m_useNullDescriptorHeap;
Gems/Atom/RHI/Metal/Code/Source/RHI/ArgumentBuffer.h
+23 -23
View File
@@ -26,12 +26,12 @@ struct ResourceBindingData
AZ::RHI::ShaderInputImageAccess m_imageAccess;
AZ::RHI::ShaderInputBufferAccess m_bufferAccess;
};
bool operator==(const ResourceBindingData& other) const
{
return this->m_resourcPtr == other.m_resourcPtr;
};
size_t GetHash() const
{
return static_cast<size_t>(m_resourcPtr->GetHash());
@@ -58,12 +58,12 @@ namespace AZ
class BufferMemoryAllocator;
class ShaderResourceGroup;
struct ShaderResourceGroupCompiledData;
class ArgumentBuffer final
: public RHI::DeviceObject
{
using Base = RHI::DeviceObject;
public:
AZ_CLASS_ALLOCATOR(ArgumentBuffer, AZ::SystemAllocator, 0);
AZ_RTTI(ArgumentBuffer, "FEFE8823-7772-4EA0-9241-65C49ADFF6B3", Base);
@@ -78,21 +78,21 @@ namespace AZ
void UpdateImageViews(const RHI::ShaderInputImageDescriptor& shaderInputImage,
const RHI::ShaderInputImageIndex shaderInputIndex,
const AZStd::array_view<RHI::ConstPtr<RHI::ImageView>>& imageViews);
const AZStd::span<const RHI::ConstPtr<RHI::ImageView>>& imageViews);
void UpdateSamplers(const RHI::ShaderInputSamplerDescriptor& shaderInputSampler,
const RHI::ShaderInputSamplerIndex shaderInputIndex,
const AZStd::array_view<RHI::SamplerState>& samplerStates);
const AZStd::span<const RHI::SamplerState>& samplerStates);
void UpdateBufferViews(const RHI::ShaderInputBufferDescriptor& shaderInputBuffer,
const RHI::ShaderInputBufferIndex shaderInputIndex,
const AZStd::array_view<RHI::ConstPtr<RHI::BufferView>>& bufferViews);
void UpdateConstantBufferViews(AZStd::array_view<uint8_t> rawData);
const AZStd::span<const RHI::ConstPtr<RHI::BufferView>>& bufferViews);
void UpdateConstantBufferViews(AZStd::span<const uint8_t> rawData);
id<MTLBuffer> GetArgEncoderBuffer() const;
size_t GetOffset() const;
//Map to cache all the resources based on the usage as we can batch all the resources for a given usage.
using ComputeResourcesToMakeResidentMap = AZStd::unordered_map<MTLResourceUsage, AZStd::unordered_set<id <MTLResource>>>;
//Map to cache all the resources based on the usage and shader stage as we can batch all the resources for a given usage/shader usage.
@@ -102,31 +102,31 @@ namespace AZ
const ShaderResourceGroupVisibility& srgResourcesVisInfo,
ComputeResourcesToMakeResidentMap& resourcesToMakeResidentCompute,
GraphicsResourcesToMakeResidentMap& resourcesToMakeResidentGraphics) const;
void ClearResourceTracking();
bool IsNullHeapNeededForVertexStage(const ShaderResourceGroupVisibility& srgResourcesVisInfo) const;
bool IsNullDescHeapNeeded() const;
//////////////////////////////////////////////////////////////////////////
// RHI::DeviceObject
void Shutdown() override;
//////////////////////////////////////////////////////////////////////////
private:
bool CreateArgumentDescriptors(NSMutableArray * argBufferDecriptors);
void AttachStaticSamplers();
void AttachConstantBuffer();
// Use a cache to store and retrieve samplers
id<MTLSamplerState> GetMtlSampler(MTLSamplerDescriptor* samplerDesc);
using ResourceBindingsSet = AZStd::unordered_set<ResourceBindingData>;
using ResourceBindingsMap = AZStd::unordered_map<AZ::Name, ResourceBindingsSet>;
ResourceBindingsMap m_resourceBindings;
static const int MaxEntriesInArgTable = 31;
void CollectResourcesForCompute(id<MTLCommandEncoder> encoder,
const ResourceBindingsSet& resourceBindingData,
ComputeResourcesToMakeResidentMap& resourcesToMakeResidentMap) const;
@@ -139,13 +139,13 @@ namespace AZ
const ResourceBindingsMap& resourceMap,
const ShaderResourceGroupVisibility& srgResourcesVisInfo) const;
void BindNullSamplers(uint32_t registerId, uint32_t samplerCount);
Device* m_device = nullptr;
RHI::ConstPtr<RHI::ShaderResourceGroupLayout> m_srgLayout;
id <MTLArgumentEncoder> m_argumentEncoder;
uint32_t m_constantBufferSize = 0;
#if defined(ARGUMENTBUFFER_PAGEALLOCATOR)
BufferMemoryView m_argumentBuffer;
BufferMemoryView m_constantBuffer;
Gems/Atom/RHI/Metal/Code/Source/RHI/AsyncUploadQueue.h
+10 -10
View File
@@ -10,7 +10,7 @@
#include <Atom/RHI/AsyncWorkQueue.h>
#include <Atom/RHI/DeviceObject.h>
#include <Atom/RHI/StreamingImagePool.h>
#include <AtomCore/std/containers/array_view.h>
#include <AzCore/std/containers/span.h>
#include <RHI/CommandQueue.h>
#include <RHI/Buffer.h>
#include <RHI/Image.h>
@@ -34,7 +34,7 @@ namespace AZ
: public RHI::DeviceObject
{
using Base = RHI::DeviceObject;
public:
AsyncUploadQueue() = default;
@@ -57,13 +57,13 @@ namespace AZ
uint64_t QueueUpload(const RHI::BufferStreamRequest& request);
//! Queue copy commands to upload image subresources.
//! @param residentMip is the resident mip level the expand request starts from.
//! @param residentMip is the resident mip level the expand request starts from.
//! @return queue id which can be use to check whether upload finished or wait for upload finish
RHI::AsyncWorkHandle QueueUpload(const RHI::StreamingImageExpandRequest& request, uint32_t residentMip);
bool IsUploadFinished(uint64_t fenceValue);
void WaitForUpload(const RHI::AsyncWorkHandle& workHandle);
private:
struct FramePacket;
RHI::AsyncWorkHandle CreateAsyncWork(Fence& fence, RHI::Fence::SignalCallback callback = nullptr);
@@ -84,26 +84,26 @@ namespace AZ
Fence m_fence;
// Using persistent mapping for the staging resource so the Map function only need to be called called once.
uint8_t* m_stagingResourceData = nullptr;
uint8_t* m_stagingResourceData = nullptr;
uint32_t m_dataOffset = 0;
};
RHI::Ptr<CommandQueue> m_copyQueue;
// Begin the frame packet which m_frameIndex point to and get ready to start recording copy command by using this frame packet
// Begin the frame packet which m_frameIndex point to and get ready to start recording copy command by using this frame packet
FramePacket* BeginFramePacket(CommandQueue* commandQueue);
void EndFramePacket(CommandQueue* commandQueue);
bool m_recordingFrame = false;
AZStd::vector<FramePacket> m_framePackets;
AZStd::vector<FramePacket> m_framePackets;
size_t m_frameIndex = 0;
Descriptor m_descriptor;
// Fence for external upload request
Fence m_uploadFence;
RHI::Ptr<Device> m_device;
//Command Buffer associated with the async copy queue
CommandQueueCommandBuffer m_commandBuffer;
Gems/Atom/RHI/Metal/Code/Source/RHI/CommandList.cpp
+89 -89
View File
@@ -28,7 +28,7 @@ namespace AZ
{
return aznew CommandList();
}
void CommandList::Init(RHI::HardwareQueueClass hardwareQueueClass, Device* device)
{
CommandListBase::Init(hardwareQueueClass, device);
@@ -39,13 +39,13 @@ namespace AZ
//Undefined symbols for architecture arm64:
// "_objc_memmove_collectable", referenced from:
//We can come back and revisit this after upgrading the build server machines to Mojave.
m_state.m_pipelineState = nullptr;
m_state.m_pipelineLayout = nullptr;
m_state.m_streamsHash = AZ::HashValue64{0};
m_state.m_indicesHash = AZ::HashValue64{0};
m_state.m_stencilRef = -1;
CommandListBase::Reset();
}
@@ -59,11 +59,11 @@ namespace AZ
Reset();
CommandListBase::FlushEncoder();
}
void CommandList::Submit(const RHI::CopyItem& copyItem)
{
CreateEncoder(CommandEncoderType::Blit);
id<MTLBlitCommandEncoder> blitEncoder = GetEncoder<id<MTLBlitCommandEncoder>>();
switch (copyItem.m_type)
{
@@ -78,7 +78,7 @@ namespace AZ
toBuffer:destinationBuffer->GetMemoryView().GetGpuAddress<id<MTLBuffer>>()
destinationOffset:descriptor.m_destinationOffset
size:descriptor.m_size];
Platform::SynchronizeBufferOnGPU(blitEncoder, destinationBuffer->GetMemoryView().GetGpuAddress<id<MTLBuffer>>());
break;
}
@@ -87,19 +87,19 @@ namespace AZ
const RHI::CopyImageDescriptor& descriptor = copyItem.m_image;
const Image* sourceImage = static_cast<const Image*>(descriptor.m_sourceImage);
const Image* destinationImage = static_cast<const Image*>(descriptor.m_destinationImage);
MTLOrigin sourceOrigin = MTLOriginMake(descriptor.m_sourceOrigin.m_left,
descriptor.m_sourceOrigin.m_top,
descriptor.m_sourceOrigin.m_front);
MTLSize sourceSize = MTLSizeMake(descriptor.m_sourceSize.m_width,
descriptor.m_sourceSize.m_height,
descriptor.m_sourceSize.m_depth);
MTLOrigin destinationOrigin = MTLOriginMake(descriptor.m_destinationOrigin.m_left,
descriptor.m_destinationOrigin.m_top,
descriptor.m_destinationOrigin.m_front);
[blitEncoder copyFromTexture: sourceImage->GetMemoryView().GetGpuAddress<id<MTLTexture>>()
sourceSlice: descriptor.m_sourceSubresource.m_arraySlice
sourceLevel: descriptor.m_sourceSubresource.m_mipSlice
@@ -109,7 +109,7 @@ namespace AZ
destinationSlice: descriptor.m_destinationSubresource.m_arraySlice
destinationLevel: descriptor.m_destinationSubresource.m_mipSlice
destinationOrigin: destinationOrigin];
Platform::SynchronizeTextureOnGPU(blitEncoder, destinationImage->GetMemoryView().GetGpuAddress<id<MTLTexture>>());
break;
}
@@ -122,11 +122,11 @@ namespace AZ
MTLOrigin destinationOrigin = MTLOriginMake(descriptor.m_destinationOrigin.m_left,
descriptor.m_destinationOrigin.m_top,
descriptor.m_destinationOrigin.m_front);
MTLSize sourceSize = MTLSizeMake(descriptor.m_sourceSize.m_width,
descriptor.m_sourceSize.m_height,
descriptor.m_sourceSize.m_depth);
[blitEncoder copyFromBuffer:sourceBuffer->GetMemoryView().GetGpuAddress<id<MTLBuffer>>()
sourceOffset:sourceBuffer->GetMemoryView().GetOffset() + descriptor.m_sourceOffset
sourceBytesPerRow:descriptor.m_sourceBytesPerRow
@@ -136,7 +136,7 @@ namespace AZ
destinationSlice:descriptor.m_destinationSubresource.m_arraySlice
destinationLevel:descriptor.m_destinationSubresource.m_mipSlice
destinationOrigin:destinationOrigin];
Platform::SynchronizeTextureOnGPU(blitEncoder, destinationImage->GetMemoryView().GetGpuAddress<id<MTLTexture>>());
break;
}
@@ -145,15 +145,15 @@ namespace AZ
const RHI::CopyImageToBufferDescriptor& descriptor = copyItem.m_imageToBuffer;
const auto* sourceImage = static_cast<const Image*>(descriptor.m_sourceImage);
const auto* destinationBuffer = static_cast<const Buffer*>(descriptor.m_destinationBuffer);
MTLOrigin sourceOrigin = MTLOriginMake(descriptor.m_sourceOrigin.m_left,
descriptor.m_sourceOrigin.m_top,
descriptor.m_sourceOrigin.m_front);
MTLSize sourceSize = MTLSizeMake(descriptor.m_sourceSize.m_width,
descriptor.m_sourceSize.m_height,
descriptor.m_sourceSize.m_depth);
[blitEncoder copyFromTexture:sourceImage->GetMemoryView().GetGpuAddress<id<MTLTexture>>()
sourceSlice:descriptor.m_sourceSubresource.m_arraySlice
sourceLevel:descriptor.m_sourceSubresource.m_mipSlice
@@ -163,7 +163,7 @@ namespace AZ
destinationOffset:destinationBuffer->GetMemoryView().GetOffset() + descriptor.m_destinationOffset
destinationBytesPerRow:descriptor.m_destinationBytesPerRow
destinationBytesPerImage:descriptor.m_destinationBytesPerImage];
Platform::SynchronizeBufferOnGPU(blitEncoder, destinationBuffer->GetMemoryView().GetGpuAddress<id<MTLBuffer>>());
break;
}
@@ -173,27 +173,27 @@ namespace AZ
}
}
}
void CommandList::Submit(const RHI::DispatchItem& dispatchItem)
{
AZ_PROFILE_FUNCTION(RHI);
CreateEncoder(CommandEncoderType::Compute);
bool bindResourceSuccessfull = CommitShaderResources<RHI::PipelineStateType::Dispatch>(dispatchItem);
if(!bindResourceSuccessfull)
{
AZ_Assert(false, "Resource binding was unsuccessfully.");
return;
}
const RHI::DispatchDirect& arguments = dispatchItem.m_arguments.m_direct;
MTLSize threadsPerGroup = {arguments.m_threadsPerGroupX, arguments.m_threadsPerGroupY, arguments.m_threadsPerGroupZ};
MTLSize threadsPerGroup = {arguments.m_threadsPerGroupX, arguments.m_threadsPerGroupY, arguments.m_threadsPerGroupZ};
MTLSize numThreadGroup = {arguments.GetNumberOfGroupsX(), arguments.GetNumberOfGroupsY(), arguments.GetNumberOfGroupsZ()};
id<MTLComputeCommandEncoder> computeEncoder = GetEncoder<id<MTLComputeCommandEncoder>>();
[computeEncoder dispatchThreadgroups: numThreadGroup
threadsPerThreadgroup: threadsPerGroup];
}
void CommandList::Submit(const RHI::DispatchRaysItem& dispatchRaysItem)
@@ -204,14 +204,14 @@ namespace AZ
void CommandList::SetViewports(const RHI::Viewport* rhiViewports, uint32_t count)
{
m_state.m_viewportState.Set(AZStd::array_view<RHI::Viewport>(rhiViewports, count));
m_state.m_viewportState.Set(AZStd::span<const RHI::Viewport>(rhiViewports, count));
}
void CommandList::SetScissors(const RHI::Scissor* rhiScissors, uint32_t count)
{
m_state.m_scissorState.Set(AZStd::array_view<RHI::Scissor>(rhiScissors, count));
m_state.m_scissorState.Set(AZStd::span<const RHI::Scissor>(rhiScissors, count));
}
template <typename Item>
void CommandList::SetRootConstants(const Item& item, const PipelineState* pipelineState)
{
@@ -221,15 +221,15 @@ namespace AZ
if(m_commandEncoderType == CommandEncoderType::Render)
{
id<MTLRenderCommandEncoder> renderEncoder = GetEncoder<id<MTLRenderCommandEncoder>>();
[renderEncoder setVertexBytes: item.m_rootConstants
length: pipelineLayout.GetRootConstantsSize()
atIndex: pipelineLayout.GetRootConstantsSlotIndex()];
[renderEncoder setFragmentBytes: item.m_rootConstants
length: pipelineLayout.GetRootConstantsSize()
atIndex: pipelineLayout.GetRootConstantsSlotIndex()];
}
else if(m_commandEncoderType == CommandEncoderType::Compute)
{
@@ -237,39 +237,39 @@ namespace AZ
[computeEncoder setBytes: item.m_rootConstants
length: pipelineLayout.GetRootConstantsSize()
atIndex: pipelineLayout.GetRootConstantsSlotIndex()];
}
}
}
bool CommandList::SetArgumentBuffers(const PipelineState* pipelineState, RHI::PipelineStateType stateType)
{
bool bindNullDescriptorHeap = false;
MTLRenderStages mtlRenderStagesForNullDescHeap = 0;
ShaderResourceBindings& bindings = GetShaderResourceBindingsByPipelineType(stateType);
const PipelineLayout& pipelineLayout = pipelineState->GetPipelineLayout();
uint32_t bufferVertexRegisterIdMin = RHI::Limits::Pipeline::ShaderResourceGroupCountMax;
uint32_t bufferFragmentOrComputeRegisterIdMin = RHI::Limits::Pipeline::ShaderResourceGroupCountMax;
uint32_t bufferVertexRegisterIdMax = 0;
uint32_t bufferFragmentOrComputeRegisterIdMax = 0;
//Arrays to cache all the buffers and offsets in order to make batch calls
MetalArgumentBufferArray mtlVertexArgBuffers;
MetalArgumentBufferArrayOffsets mtlVertexArgBufferOffsets;
MetalArgumentBufferArray mtlFragmentOrComputeArgBuffers;
MetalArgumentBufferArrayOffsets mtlFragmentOrComputeArgBufferOffsets;
mtlVertexArgBuffers.fill(nil);
mtlFragmentOrComputeArgBuffers.fill(nil);
mtlVertexArgBufferOffsets.fill(0);
mtlFragmentOrComputeArgBufferOffsets.fill(0);
//Map to cache all the resources based on the usage as we can batch all the resources for a given usage
ArgumentBuffer::ComputeResourcesToMakeResidentMap resourcesToMakeResidentCompute;
//Map to cache all the resources based on the usage and shader stage as we can batch all the resources for a given usage/shader usage
ArgumentBuffer::GraphicsResourcesToMakeResidentMap resourcesToMakeResidentGraphics;
for (uint32_t slot = 0; slot < RHI::Limits::Pipeline::ShaderResourceGroupCountMax; ++slot)
{
const ShaderResourceGroup* shaderResourceGroup = bindings.m_srgsBySlot[slot];
@@ -282,7 +282,7 @@ namespace AZ
uint32_t srgVisIndex = pipelineLayout.GetIndexBySlot(shaderResourceGroup->GetBindingSlot());
const RHI::ShaderStageMask& srgVisInfo = pipelineLayout.GetSrgVisibility(srgVisIndex);
const ShaderResourceGroupVisibility& srgResourcesVisInfo = pipelineLayout.GetSrgResourcesVisibility(srgVisIndex);
bool isSrgUpdatd = bindings.m_srgsByIndex[slot] != shaderResourceGroup;
if(isSrgUpdatd)
{
@@ -290,12 +290,12 @@ namespace AZ
auto& compiledArgBuffer = shaderResourceGroup->GetCompiledArgumentBuffer();
id<MTLBuffer> argBuffer = compiledArgBuffer.GetArgEncoderBuffer();
size_t argBufferOffset = compiledArgBuffer.GetOffset();
if(srgVisInfo != RHI::ShaderStageMask::None)
{
bool isNullDescHeapNeeded = compiledArgBuffer.IsNullDescHeapNeeded();
bindNullDescriptorHeap |= isNullDescHeapNeeded;
//For graphics and compute shader stages, cache all the argument buffers, offsets and track the min/max indices
if(m_commandEncoderType == CommandEncoderType::Render)
{
@@ -305,11 +305,11 @@ namespace AZ
mtlVertexArgBuffers[slotIndex] = argBuffer;
mtlVertexArgBufferOffsets[slotIndex] = argBufferOffset;
bufferVertexRegisterIdMin = AZStd::min(slotIndex, bufferVertexRegisterIdMin);
bufferVertexRegisterIdMax = AZStd::max(slotIndex, bufferVertexRegisterIdMax);
bufferVertexRegisterIdMax = AZStd::max(slotIndex, bufferVertexRegisterIdMax);
mtlRenderStagesForNullDescHeap = shaderResourceGroup->IsNullHeapNeededForVertexStage(srgResourcesVisInfo) ?
mtlRenderStagesForNullDescHeap | MTLRenderStageVertex : mtlRenderStagesForNullDescHeap;
}
if( numBitsSet > 1 || srgVisInfo == RHI::ShaderStageMask::Fragment)
{
mtlFragmentOrComputeArgBuffers[slotIndex] = argBuffer;
@@ -328,7 +328,7 @@ namespace AZ
}
}
}
//Check if the srg has been updated or if the srg resources visibility hash has been updated
//as it is possible for draw items to have different PSOs in the same pass.
const AZ::HashValue64 srgResourcesVisHash = pipelineLayout.GetSrgResourcesVisibilityHash(srgVisIndex);
@@ -337,8 +337,8 @@ namespace AZ
bindings.m_srgVisHashByIndex[slot] = srgResourcesVisHash;
if(srgVisInfo != RHI::ShaderStageMask::None)
{
//For graphics and compute encoder make the resource resident (call UseResource) for the duration
//of the work associated with the current scope and ensure that it's in a
//format compatible with the appropriate metal function.
@@ -353,7 +353,7 @@ namespace AZ
}
}
}
//For graphics and compute encoder bind all the argument buffers
if(m_commandEncoderType == CommandEncoderType::Render)
{
@@ -362,7 +362,7 @@ namespace AZ
bufferVertexRegisterIdMax,
mtlVertexArgBuffers,
mtlVertexArgBufferOffsets);
BindArgumentBuffers(RHI::ShaderStage::Fragment,
bufferFragmentOrComputeRegisterIdMin,
bufferFragmentOrComputeRegisterIdMax,
@@ -377,40 +377,40 @@ namespace AZ
mtlFragmentOrComputeArgBuffers,
mtlFragmentOrComputeArgBufferOffsets);
}
id<MTLRenderCommandEncoder> renderEncoder = GetEncoder<id<MTLRenderCommandEncoder>>();
id<MTLComputeCommandEncoder> computeEncoder = GetEncoder<id<MTLComputeCommandEncoder>>();
//Call UseResource on all resources for Compute stage
for (const auto& key : resourcesToMakeResidentCompute)
{
AZStd::vector<id <MTLResource>> resourcesToProcessVec(key.second.begin(), key.second.end());
[computeEncoder useResources: &resourcesToProcessVec[0]
count: resourcesToProcessVec.size()
usage: key.first];
}
//Call UseResource on all resources for Vertex and Fragment stages
for (const auto& key : resourcesToMakeResidentGraphics)
{
AZStd::vector<id <MTLResource>> resourcesToProcessVec(key.second.begin(), key.second.end());
[renderEncoder useResources: &resourcesToProcessVec[0]
count: resourcesToProcessVec.size()
usage: key.first.first
stages: key.first.second];
}
if(bindNullDescriptorHeap)
{
MakeHeapsResident(mtlRenderStagesForNullDescHeap);
}
return true;
}
void CommandList::BindArgumentBuffers(RHI::ShaderStage shaderStage,
uint16_t registerIdMin,
uint16_t registerIdMax,
@@ -428,7 +428,7 @@ namespace AZ
if(mtlArgBuffers[i] == nil)
{
NSRange range = { startingIndex, i-startingIndex };
switch(shaderStage)
{
case RHI::ShaderStage::Vertex:
@@ -462,7 +462,7 @@ namespace AZ
}
trackingRange = false;
}
}
else
@@ -475,13 +475,13 @@ namespace AZ
}
}
}
void CommandList::Submit(const RHI::DrawItem& drawItem)
{
AZ_PROFILE_FUNCTION(RHI);
CreateEncoder(CommandEncoderType::Render);
RHI::CommandListScissorState scissorState;
if (drawItem.m_scissorsCount)
{
@@ -496,15 +496,15 @@ namespace AZ
}
CommitViewportState();
CommitScissorState();
const PipelineState* pipelineState = static_cast<const PipelineState*>(drawItem.m_pipelineState);
AZ_Assert(pipelineState, "PipelineState can not be null");
if(m_renderPassMultiSampleState != pipelineState->m_pipelineStateMultiSampleState)
{
AZ_Assert(false,"MultisampleState in the image descriptor needs to match the one provided in the pipeline state");
}
id<MTLRenderCommandEncoder> renderEncoder = GetEncoder<id<MTLRenderCommandEncoder>>();
bool bindResourceSuccessfull = CommitShaderResources<RHI::PipelineStateType::Draw>(drawItem);
if(!bindResourceSuccessfull)
@@ -512,21 +512,21 @@ namespace AZ
AZ_Assert(false, "Resource binding was unsuccessfully.");
return;
}
SetStreamBuffers(drawItem.m_streamBufferViews, drawItem.m_streamBufferViewCount);
SetStencilRef(drawItem.m_stencilRef);
MTLPrimitiveType mtlPrimType = pipelineState->GetPipelineTopology();
switch (drawItem.m_arguments.m_type)
{
case RHI::DrawType::Indexed:
{
const RHI::DrawIndexed& indexed = drawItem.m_arguments.m_indexed;
const RHI::IndexBufferView& indexBuffDescriptor = *drawItem.m_indexBufferView;
AZ::HashValue64 indicesHash = indexBuffDescriptor.GetHash();
m_state.m_indicesHash = indicesHash;
const Buffer * buff = static_cast<const Buffer*>(indexBuffDescriptor.GetBuffer());
id<MTLBuffer> mtlBuff = buff->GetMemoryView().GetGpuAddress<id<MTLBuffer>>();
@@ -534,7 +534,7 @@ namespace AZ
MTLIndexTypeUInt16 : MTLIndexTypeUInt32;
uint32_t indexTypeSize = 0;
GetIndexTypeSizeInBytes(mtlIndexType, indexTypeSize);
uint32_t indexOffset = indexBuffDescriptor.GetByteOffset() + (indexed.m_indexOffset * indexTypeSize) + buff->GetMemoryView().GetOffset();
[renderEncoder drawIndexedPrimitives: mtlPrimType
indexCount: indexed.m_indexCount
@@ -546,15 +546,15 @@ namespace AZ
baseInstance: indexed.m_instanceOffset];
break;
}
case RHI::DrawType::Linear:
{
{
const RHI::DrawLinear& linear = drawItem.m_arguments.m_linear;
[renderEncoder drawPrimitives: mtlPrimType
vertexStart: linear.m_vertexOffset
vertexCount: linear.m_vertexCount
instanceCount: linear.m_instanceCount
baseInstance: linear.m_instanceOffset];
baseInstance: linear.m_instanceOffset];
break;
}
}
@@ -576,7 +576,7 @@ namespace AZ
{
CommandListBase::Shutdown();
}
void CommandList::SetPipelineState(const PipelineState* pipelineState)
{
if (m_state.m_pipelineState != pipelineState)
@@ -608,7 +608,7 @@ namespace AZ
AZ_Assert(false, "Type not supported.");
}
}
ShaderResourceBindings& bindings = GetShaderResourceBindingsByPipelineType(pipelineState->GetType());
for (size_t i = 0; i < bindings.m_srgsByIndex.size(); ++i)
{
@@ -623,7 +623,7 @@ namespace AZ
}
}
}
void CommandList::SetStencilRef(uint8_t stencilRef)
{
if (m_state.m_stencilRef != stencilRef)
@@ -633,24 +633,24 @@ namespace AZ
m_state.m_stencilRef = stencilRef;
}
}
void CommandList::SetStreamBuffers(const RHI::StreamBufferView* streams, uint32_t count)
{
uint16_t bufferArrayLen = 0;
AZStd::array<id<MTLBuffer>, METAL_MAX_ENTRIES_BUFFER_ARG_TABLE> mtlStreamBuffers;
AZStd::array<NSUInteger, METAL_MAX_ENTRIES_BUFFER_ARG_TABLE> mtlStreamBufferOffsets;
AZ::HashValue64 streamsHash = AZ::HashValue64{0};
for (uint32_t i = 0; i < count; ++i)
{
streamsHash = AZ::TypeHash64(streamsHash, streams[i].GetHash());
}
if (streamsHash != m_state.m_streamsHash)
{
m_state.m_streamsHash = streamsHash;
AZ_Assert(count <= METAL_MAX_ENTRIES_BUFFER_ARG_TABLE , "Slots needed cannot exceed METAL_MAX_ENTRIES_BUFFER_ARG_TABLE");
NSRange range = {METAL_MAX_ENTRIES_BUFFER_ARG_TABLE - count, count};
//The stream buffers are populated from bottom to top as the top slots are taken by argument buffers
for (int i = count-1; i >= 0; --i)
@@ -671,7 +671,7 @@ namespace AZ
withRange: range];
}
}
void CommandList::SetRasterizerState(const RasterizerState& rastState)
{
id<MTLRenderCommandEncoder> renderEncoder = GetEncoder<id<MTLRenderCommandEncoder>>();
@@ -681,17 +681,17 @@ namespace AZ
[renderEncoder setTriangleFillMode: rastState.m_triangleFillMode];
[renderEncoder setDepthClipMode: rastState.m_depthClipMode];
}
void CommandList::SetShaderResourceGroupForDraw(const RHI::ShaderResourceGroup& shaderResourceGroup)
{
SetShaderResourceGroup<RHI::PipelineStateType::Draw>(static_cast<const ShaderResourceGroup*>(&shaderResourceGroup));
}
void CommandList::SetShaderResourceGroupForDispatch(const RHI::ShaderResourceGroup& shaderResourceGroup)
{
SetShaderResourceGroup<RHI::PipelineStateType::Dispatch>(static_cast<const ShaderResourceGroup*>(&shaderResourceGroup));
}
CommandList::ShaderResourceBindings& CommandList::GetShaderResourceBindingsByPipelineType(RHI::PipelineStateType pipelineType)
{
return m_state.m_bindingsByPipe[static_cast<size_t>(pipelineType)];
@@ -706,15 +706,15 @@ namespace AZ
AZ_Assert(false, "Pipeline state not provided");
return false;
}
SetPipelineState(pipelineState);
// Assign shader resource groups from the item to slot bindings.
for (uint32_t srgIndex = 0; srgIndex < item.m_shaderResourceGroupCount; ++srgIndex)
{
SetShaderResourceGroup<pipelineType>(static_cast<const ShaderResourceGroup*>(item.m_shaderResourceGroups[srgIndex]));
}
if (item.m_uniqueShaderResourceGroup)
{
SetShaderResourceGroup<pipelineType>(static_cast<const ShaderResourceGroup*>(item.m_uniqueShaderResourceGroup));
@@ -730,7 +730,7 @@ namespace AZ
{
return;
}
AZ_PROFILE_FUNCTION(RHI);
const auto& viewports = m_state.m_viewportState.m_states;
MTLViewport metalViewports[viewports.size()];
@@ -744,7 +744,7 @@ namespace AZ
metalViewports[i].znear = viewports[i].m_minZ;
metalViewports[i].zfar = viewports[i].m_maxZ;
}
id<MTLRenderCommandEncoder> renderEncoder = GetEncoder<id<MTLRenderCommandEncoder>>();
[renderEncoder setViewports: metalViewports
count: viewports.size()];
@@ -760,7 +760,7 @@ namespace AZ
AZStd::array<MTLScissorRect, MaxScissorsAllowed> metalScissorRects;
const auto& scissors = m_state.m_scissorState.m_states;
AZ_Assert(scissors.size() <= MaxScissorsAllowed , "Number of scissors violate the maximum number of scissors allowed");
for (uint32_t i = 0; i < scissors.size(); ++i)
{
Gems/Atom/RHI/Metal/Code/Source/RHI/PipelineLibrary.cpp
+1 -1
View File
@@ -27,7 +27,7 @@ namespace AZ
{
}
RHI::ResultCode PipelineLibrary::MergeIntoInternal(AZStd::array_view<const RHI::PipelineLibrary*> pipelineLibraries)
RHI::ResultCode PipelineLibrary::MergeIntoInternal(AZStd::span<const RHI::PipelineLibrary* const> pipelineLibraries)
{
return RHI::ResultCode::Success;
}
Gems/Atom/RHI/Metal/Code/Source/RHI/PipelineLibrary.h
+1 -1
View File
@@ -30,7 +30,7 @@ namespace AZ
// RHI::PipelineLibrary
RHI::ResultCode InitInternal(RHI::Device& device, const RHI::PipelineLibraryData* serializedData) override;
void ShutdownInternal() override;
RHI::ResultCode MergeIntoInternal(AZStd::array_view<const RHI::PipelineLibrary*> libraries) override;
RHI::ResultCode MergeIntoInternal(AZStd::span<const RHI::PipelineLibrary* const> libraries) override;
RHI::ConstPtr<RHI::PipelineLibraryData> GetSerializedDataInternal() const override;
//////////////////////////////////////////////////////////////////////////
Gems/Atom/RHI/Metal/Code/Source/RHI/ShaderResourceGroupPool.cpp
+4 -4
View File
@@ -37,7 +37,7 @@ namespace AZ
RHI::ResultCode ShaderResourceGroupPool::InitGroupInternal(RHI::ShaderResourceGroup& groupBase)
{
ShaderResourceGroup& group = static_cast<ShaderResourceGroup&>(groupBase);
for (size_t i = 0; i < RHI::Limits::Device::FrameCountMax; ++i)
{
auto argBuffer = ArgumentBuffer::Create();
@@ -82,7 +82,7 @@ namespace AZ
for (const RHI::ShaderInputImageDescriptor& shaderInputImage : layout->GetShaderInputListForImages())
{
const RHI::ShaderInputImageIndex imageInputIndex(shaderInputIndex);
AZStd::array_view<RHI::ConstPtr<RHI::ImageView>> imageViews = groupData.GetImageViewArray(imageInputIndex);
AZStd::span<const RHI::ConstPtr<RHI::ImageView>> imageViews = groupData.GetImageViewArray(imageInputIndex);
argBuffer.UpdateImageViews(shaderInputImage, imageInputIndex, imageViews);
++shaderInputIndex;
}
@@ -91,7 +91,7 @@ namespace AZ
for (const RHI::ShaderInputSamplerDescriptor& shaderInputSampler : layout->GetShaderInputListForSamplers())
{
const RHI::ShaderInputSamplerIndex samplerInputIndex(shaderInputIndex);
AZStd::array_view<RHI::SamplerState> samplerStates = groupData.GetSamplerArray(samplerInputIndex);
AZStd::span<const RHI::SamplerState> samplerStates = groupData.GetSamplerArray(samplerInputIndex);
argBuffer.UpdateSamplers(shaderInputSampler, samplerInputIndex, samplerStates);
++shaderInputIndex;
}
@@ -100,7 +100,7 @@ namespace AZ
for (const RHI::ShaderInputBufferDescriptor& shaderInputBuffer : layout->GetShaderInputListForBuffers())
{
const RHI::ShaderInputBufferIndex bufferInputIndex(shaderInputIndex);
AZStd::array_view<RHI::ConstPtr<RHI::BufferView>> bufferViews = groupData.GetBufferViewArray(bufferInputIndex);
AZStd::span<const RHI::ConstPtr<RHI::BufferView>> bufferViews = groupData.GetBufferViewArray(bufferInputIndex);
argBuffer.UpdateBufferViews(shaderInputBuffer, bufferInputIndex, bufferViews);
++shaderInputIndex;
}
Gems/Atom/RHI/Null/Code/Source/RHI/PipelineLibrary.h
+1 -1
View File
@@ -30,7 +30,7 @@ namespace AZ
// RHI::PipelineLibrary
RHI::ResultCode InitInternal([[maybe_unused]] RHI::Device& device, [[maybe_unused]] const RHI::PipelineLibraryData* serializedData) override { return RHI::ResultCode::Success;}
void ShutdownInternal() override {}
RHI::ResultCode MergeIntoInternal([[maybe_unused]] AZStd::array_view<const RHI::PipelineLibrary*> libraries) override { return RHI::ResultCode::Success;}
RHI::ResultCode MergeIntoInternal([[maybe_unused]] AZStd::span<const RHI::PipelineLibrary* const> libraries) override { return RHI::ResultCode::Success;}
RHI::ConstPtr<RHI::PipelineLibraryData> GetSerializedDataInternal() const override { return nullptr;}
//////////////////////////////////////////////////////////////////////////
};
Gems/Atom/RHI/Vulkan/Code/Include/Atom/RHI.Reflect/Vulkan/ShaderStageFunction.h
+2 -2
View File
@@ -9,7 +9,7 @@
#include <Atom/RHI.Reflect/Vulkan/Base.h>
#include <Atom/RHI.Reflect/ShaderStageFunction.h>
#include <AtomCore/std/containers/array_view.h>
#include <AzCore/std/containers/span.h>
#include <AzCore/Memory/SystemAllocator.h>
#include <AzCore/std/containers/array.h>
#include <AzCore/std/string/string_view.h>
@@ -21,7 +21,7 @@ namespace AZ
namespace Vulkan
{
using ShaderByteCode = AZStd::vector<uint8_t>;
using ShaderByteCodeView = AZStd::array_view<uint8_t>;
using ShaderByteCodeView = AZStd::span<const uint8_t>;
/**
* A set of indices used to access physical sub-stages within a virtual stage.
Gems/Atom/RHI/Vulkan/Code/Source/RHI/CommandList.cpp
+3 -3
View File
@@ -76,12 +76,12 @@ namespace AZ
void CommandList::SetViewports(const RHI::Viewport* rhiViewports, uint32_t count)
{
m_state.m_viewportState.Set(AZStd::array_view<RHI::Viewport>(rhiViewports, count));
m_state.m_viewportState.Set(AZStd::span<const RHI::Viewport>(rhiViewports, count));
}
void CommandList::SetScissors(const RHI::Scissor* rhiScissors, uint32_t count)
{
m_state.m_scissorState.Set(AZStd::array_view<RHI::Scissor>(rhiScissors, count));
m_state.m_scissorState.Set(AZStd::span<const RHI::Scissor>(rhiScissors, count));
}
void CommandList::SetShaderResourceGroupForDraw(const RHI::ShaderResourceGroup& shaderResourceGroup)
@@ -625,7 +625,7 @@ namespace AZ
return ConvertResult(vkResult);
}
void CommandList::ExecuteSecondaryCommandLists(const AZStd::array_view<RHI::Ptr<CommandList>>& commands)
void CommandList::ExecuteSecondaryCommandLists(const AZStd::span<const RHI::Ptr<CommandList>>& commands)
{
AZ_Assert(m_isUpdating, "Secondary command buffers must be executed between BeginCommandBuffer() and EndCommandBuffer().");
AZ_Assert(m_descriptor.m_level == VK_COMMAND_BUFFER_LEVEL_PRIMARY, "Trying to execute commands from a secondary command list");
Gems/Atom/RHI/Vulkan/Code/Source/RHI/CommandList.h
+2 -2
View File
@@ -17,7 +17,7 @@
#include <Atom/RHI.Reflect/Limits.h>
#include <Atom/RHI.Reflect/ScopeId.h>
#include <Atom/RHI.Reflect/Interval.h>
#include <AtomCore/std/containers/array_view.h>
#include <AzCore/std/containers/span.h>
#include <AzCore/std/containers/list.h>
#include <AzCore/std/containers/unordered_set.h>
#include <AzCore/std/containers/vector.h>
@@ -103,7 +103,7 @@ namespace AZ
bool IsInsideRenderPass() const;
const Framebuffer* GetActiveFramebuffer() const;
const RenderPass* GetActiveRenderpass() const;
void ExecuteSecondaryCommandLists(const AZStd::array_view<RHI::Ptr<CommandList>>& commands);
void ExecuteSecondaryCommandLists(const AZStd::span<const RHI::Ptr<CommandList>>& commands);
uint32_t GetQueueFamilyIndex() const;
Gems/Atom/RHI/Vulkan/Code/Source/RHI/DescriptorSet.cpp
+4 -4
View File
@@ -39,7 +39,7 @@ namespace AZ
}
}
void DescriptorSet::UpdateBufferViews(uint32_t layoutIndex, const AZStd::array_view<RHI::ConstPtr<RHI::BufferView>>& bufViews)
void DescriptorSet::UpdateBufferViews(uint32_t layoutIndex, const AZStd::span<const RHI::ConstPtr<RHI::BufferView>>& bufViews)
{
const DescriptorSetLayout& layout = *m_descriptor.m_descriptorSetLayout;
VkDescriptorType type = layout.GetDescriptorType(layoutIndex);
@@ -119,7 +119,7 @@ namespace AZ
m_updateData.push_back(AZStd::move(data));
}
void DescriptorSet::UpdateImageViews(uint32_t layoutIndex, const AZStd::array_view<RHI::ConstPtr<RHI::ImageView>>& imageViews, RHI::ShaderInputImageType imageType)
void DescriptorSet::UpdateImageViews(uint32_t layoutIndex, const AZStd::span<const RHI::ConstPtr<RHI::ImageView>>& imageViews, RHI::ShaderInputImageType imageType)
{
const DescriptorSetLayout& layout = *m_descriptor.m_descriptorSetLayout;
@@ -169,7 +169,7 @@ namespace AZ
m_updateData.push_back(AZStd::move(data));
}
void DescriptorSet::UpdateSamplers(uint32_t layoutIndex, const AZStd::array_view<RHI::SamplerState>& samplers)
void DescriptorSet::UpdateSamplers(uint32_t layoutIndex, const AZStd::span<const RHI::SamplerState>& samplers)
{
auto& device = static_cast<Device&>(GetDevice());
@@ -189,7 +189,7 @@ namespace AZ
m_updateData.push_back(AZStd::move(data));
}
void DescriptorSet::UpdateConstantData(AZStd::array_view<uint8_t> rawData)
void DescriptorSet::UpdateConstantData(AZStd::span<const uint8_t> rawData)
{
AZ_Assert(m_constantDataBuffer, "Null constant buffer");
const DescriptorSetLayout& layout = *m_descriptor.m_descriptorSetLayout;
Gems/Atom/RHI/Vulkan/Code/Source/RHI/DescriptorSet.h
+5 -5
View File
@@ -13,7 +13,7 @@
#include <Atom/RHI/Image.h>
#include <Atom/RHI/ImageView.h>
#include <Atom/RHI.Reflect/SamplerState.h>
#include <AtomCore/std/containers/array_view.h>
#include <AzCore/std/containers/span.h>
#include <AzCore/Memory/PoolAllocator.h>
#include <RHI/Buffer.h>
@@ -57,10 +57,10 @@ namespace AZ
void CommitUpdates();
void UpdateBufferViews(uint32_t index, const AZStd::array_view<RHI::ConstPtr<RHI::BufferView>>& bufViews);
void UpdateImageViews(uint32_t index, const AZStd::array_view<RHI::ConstPtr<RHI::ImageView>>& imageViews, RHI::ShaderInputImageType imageType);
void UpdateSamplers(uint32_t index, const AZStd::array_view<RHI::SamplerState>& samplers);
void UpdateConstantData(AZStd::array_view<uint8_t> data);
void UpdateBufferViews(uint32_t index, const AZStd::span<const RHI::ConstPtr<RHI::BufferView>>& bufViews);
void UpdateImageViews(uint32_t index, const AZStd::span<const RHI::ConstPtr<RHI::ImageView>>& imageViews, RHI::ShaderInputImageType imageType);
void UpdateSamplers(uint32_t index, const AZStd::span<const RHI::SamplerState>& samplers);
void UpdateConstantData(AZStd::span<const uint8_t> data);
RHI::Ptr<BufferView> GetConstantDataBufferView() const;
Gems/Atom/RHI/Vulkan/Code/Source/RHI/DescriptorSetLayout.cpp
+7 -7
View File
@@ -152,12 +152,12 @@ namespace AZ
RHI::ResultCode DescriptorSetLayout::BuildDescriptorSetLayoutBindings()
{
const AZStd::array_view<RHI::ShaderInputBufferDescriptor> bufferDescs = m_shaderResourceGroupLayout->GetShaderInputListForBuffers();
const AZStd::array_view<RHI::ShaderInputImageDescriptor> imageDescs = m_shaderResourceGroupLayout->GetShaderInputListForImages();
const AZStd::array_view<RHI::ShaderInputBufferUnboundedArrayDescriptor> bufferUnboundedArrayDescs = m_shaderResourceGroupLayout->GetShaderInputListForBufferUnboundedArrays();
const AZStd::array_view<RHI::ShaderInputImageUnboundedArrayDescriptor> imageUnboundedArrayDescs = m_shaderResourceGroupLayout->GetShaderInputListForImageUnboundedArrays();
const AZStd::array_view<RHI::ShaderInputSamplerDescriptor> samplerDescs = m_shaderResourceGroupLayout->GetShaderInputListForSamplers();
const AZStd::array_view<RHI::ShaderInputStaticSamplerDescriptor>& staticSamplerDescs = m_shaderResourceGroupLayout->GetStaticSamplers();
const AZStd::span<const RHI::ShaderInputBufferDescriptor> bufferDescs = m_shaderResourceGroupLayout->GetShaderInputListForBuffers();
const AZStd::span<const RHI::ShaderInputImageDescriptor> imageDescs = m_shaderResourceGroupLayout->GetShaderInputListForImages();
const AZStd::span<const RHI::ShaderInputBufferUnboundedArrayDescriptor> bufferUnboundedArrayDescs = m_shaderResourceGroupLayout->GetShaderInputListForBufferUnboundedArrays();
const AZStd::span<const RHI::ShaderInputImageUnboundedArrayDescriptor> imageUnboundedArrayDescs = m_shaderResourceGroupLayout->GetShaderInputListForImageUnboundedArrays();
const AZStd::span<const RHI::ShaderInputSamplerDescriptor> samplerDescs = m_shaderResourceGroupLayout->GetShaderInputListForSamplers();
const AZStd::span<const RHI::ShaderInputStaticSamplerDescriptor>& staticSamplerDescs = m_shaderResourceGroupLayout->GetStaticSamplers();
// The + 1 is for Constant Data.
m_descriptorSetLayoutBindings.reserve(
@@ -173,7 +173,7 @@ namespace AZ
m_constantDataSize = m_shaderResourceGroupLayout->GetConstantDataSize();
if (m_constantDataSize)
{
AZStd::array_view<RHI::ShaderInputConstantDescriptor> inputListForConstants = m_shaderResourceGroupLayout->GetShaderInputListForConstants();
AZStd::span<const RHI::ShaderInputConstantDescriptor> inputListForConstants = m_shaderResourceGroupLayout->GetShaderInputListForConstants();
AZ_Assert(!inputListForConstants.empty(), "Empty constant input list");
m_descriptorSetLayoutBindings.emplace_back(VkDescriptorSetLayoutBinding{});
VkDescriptorSetLayoutBinding& vbinding = m_descriptorSetLayoutBindings.back();
Gems/Atom/RHI/Vulkan/Code/Source/RHI/FrameGraphExecuteGroup.cpp
+3 -3
View File
@@ -81,12 +81,12 @@ namespace AZ
{
}
AZStd::array_view<const Scope*> FrameGraphExecuteGroup::GetScopes() const
AZStd::span<const Scope* const> FrameGraphExecuteGroup::GetScopes() const
{
return AZStd::array_view<const Scope*>(&m_scope, 1);
return AZStd::span<const Scope* const>(&m_scope, 1);
}
AZStd::array_view<RHI::Ptr<CommandList>> FrameGraphExecuteGroup::GetCommandLists() const
AZStd::span<const RHI::Ptr<CommandList>> FrameGraphExecuteGroup::GetCommandLists() const
{
return m_secondaryCommands;
}
Gems/Atom/RHI/Vulkan/Code/Source/RHI/FrameGraphExecuteGroup.h
+2 -2
View File
@@ -44,8 +44,8 @@ namespace AZ
//////////////////////////////////////////////////////////////////////////
// FrameGraphExecuteGroupBase
AZStd::array_view<const Scope*> GetScopes() const override;
AZStd::array_view<RHI::Ptr<CommandList>> GetCommandLists() const override;
AZStd::span<const Scope* const> GetScopes() const override;
AZStd::span<const RHI::Ptr<CommandList>> GetCommandLists() const override;
//////////////////////////////////////////////////////////////////////////
//! Set the render context and subpass that will be used by this execute group.
Gems/Atom/RHI/Vulkan/Code/Source/RHI/FrameGraphExecuteGroupBase.h
+2 -2
View File
@@ -37,9 +37,9 @@ namespace AZ
const RHI::GraphGroupId& GetGroupId() const;
virtual AZStd::array_view<const Scope*> GetScopes() const = 0;
virtual AZStd::span<const Scope* const> GetScopes() const = 0;
virtual AZStd::array_view<RHI::Ptr<CommandList>> GetCommandLists() const = 0;
virtual AZStd::span<const RHI::Ptr<CommandList>> GetCommandLists() const = 0;
protected:
RHI::Ptr<CommandList> AcquireCommandList(VkCommandBufferLevel level) const;
Gems/Atom/RHI/Vulkan/Code/Source/RHI/FrameGraphExecuteGroupMerged.cpp
+4 -4
View File
@@ -113,14 +113,14 @@ namespace AZ
scope->EmitScopeBarriers(*m_commandList, Scope::BarrierSlot::Epilogue);
}
AZStd::array_view<const Scope*> FrameGraphExecuteGroupMerged::GetScopes() const
AZStd::span<const Scope* const> FrameGraphExecuteGroupMerged::GetScopes() const
{
return m_scopes;
}
AZStd::array_view<RHI::Ptr<CommandList>> FrameGraphExecuteGroupMerged::GetCommandLists() const
AZStd::span<const RHI::Ptr<CommandList>> FrameGraphExecuteGroupMerged::GetCommandLists() const
{
return AZStd::array_view<RHI::Ptr<CommandList>>(&m_commandList, 1);
return AZStd::span<const RHI::Ptr<CommandList>>(&m_commandList, 1);
}
void FrameGraphExecuteGroupMerged::SetPrimaryCommandList(CommandList& commandList)
@@ -128,7 +128,7 @@ namespace AZ
m_commandList = &commandList;
}
void FrameGraphExecuteGroupMerged::SetRenderPasscontexts(AZStd::array_view<RenderPassContext> renderPassContexts)
void FrameGraphExecuteGroupMerged::SetRenderPasscontexts(AZStd::span<const RenderPassContext> renderPassContexts)
{
m_renderPassContexts = renderPassContexts;
}

Some files were not shown because too many files have changed in this diff Show More