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

Merge branch 'development' of https://github.com/o3de/o3de into cgalvan/DraftStreamingImageAssetPixelAPI

Browse Source
This commit is contained in:
Chris Galvan
2022-01-26 16:46:58 -06:00
parent 0550167f9f b9824ed172
commit f3fa731fef
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