You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
339 lines
13 KiB
C++
339 lines
13 KiB
C++
/*
|
|
* 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 <Atom/RHI.Reflect/ShaderResourceGroupLayoutDescriptor.h>
|
|
#include <AzCore/Serialization/SerializeContext.h>
|
|
#include <AzCore/Utils/TypeHash.h>
|
|
|
|
namespace AZ
|
|
{
|
|
namespace RHI
|
|
{
|
|
void ShaderInputBufferDescriptor::Reflect(ReflectContext* context)
|
|
{
|
|
if (SerializeContext* serializeContext = azrtti_cast<SerializeContext*>(context))
|
|
{
|
|
serializeContext->Class<ShaderInputBufferDescriptor>()
|
|
->Version(4)
|
|
->Field("m_name", &ShaderInputBufferDescriptor::m_name)
|
|
->Field("m_type", &ShaderInputBufferDescriptor::m_type)
|
|
->Field("m_access", &ShaderInputBufferDescriptor::m_access)
|
|
->Field("m_count", &ShaderInputBufferDescriptor::m_count)
|
|
->Field("m_strideSize", &ShaderInputBufferDescriptor::m_strideSize)
|
|
->Field("m_registerId", &ShaderInputBufferDescriptor::m_registerId);
|
|
}
|
|
|
|
ShaderInputBufferIndex::Reflect(context);
|
|
}
|
|
|
|
ShaderInputBufferDescriptor::ShaderInputBufferDescriptor(
|
|
const Name& name,
|
|
ShaderInputBufferAccess access,
|
|
ShaderInputBufferType type,
|
|
uint32_t bufferCount,
|
|
uint32_t strideSize,
|
|
uint32_t registerId
|
|
)
|
|
: m_name{name}
|
|
, m_access{access}
|
|
, m_type{type}
|
|
, m_count{bufferCount}
|
|
, m_strideSize{ strideSize }
|
|
, m_registerId{ registerId }
|
|
{}
|
|
|
|
HashValue64 ShaderInputBufferDescriptor::GetHash(HashValue64 seed) const
|
|
{
|
|
seed = TypeHash64(m_name.GetHash(), seed);
|
|
seed = TypeHash64(m_access, seed);
|
|
seed = TypeHash64(m_type, seed);
|
|
seed = TypeHash64(m_count, seed);
|
|
seed = TypeHash64(m_strideSize, seed);
|
|
seed = TypeHash64(m_registerId, seed);
|
|
return seed;
|
|
}
|
|
|
|
void ShaderInputImageDescriptor::Reflect(ReflectContext* context)
|
|
{
|
|
if (SerializeContext* serializeContext = azrtti_cast<SerializeContext*>(context))
|
|
{
|
|
serializeContext->Class<ShaderInputImageDescriptor>()
|
|
->Version(3)
|
|
->Field("m_name", &ShaderInputImageDescriptor::m_name)
|
|
->Field("m_type", &ShaderInputImageDescriptor::m_type)
|
|
->Field("m_access", &ShaderInputImageDescriptor::m_access)
|
|
->Field("m_count", &ShaderInputImageDescriptor::m_count)
|
|
->Field("m_registerId", &ShaderInputImageDescriptor::m_registerId);
|
|
}
|
|
|
|
ShaderInputImageIndex::Reflect(context);
|
|
}
|
|
|
|
ShaderInputImageDescriptor::ShaderInputImageDescriptor(
|
|
const Name& name,
|
|
ShaderInputImageAccess access,
|
|
ShaderInputImageType type,
|
|
uint32_t imageCount,
|
|
uint32_t registerId)
|
|
: m_name{name}
|
|
, m_access{access}
|
|
, m_type{type}
|
|
, m_count{imageCount}
|
|
, m_registerId{ registerId }
|
|
{}
|
|
|
|
HashValue64 ShaderInputImageDescriptor::GetHash(HashValue64 seed) const
|
|
{
|
|
seed = TypeHash64(m_name.GetHash(), seed);
|
|
seed = TypeHash64(m_access, seed);
|
|
seed = TypeHash64(m_type, seed);
|
|
seed = TypeHash64(m_count, seed);
|
|
seed = TypeHash64(m_registerId, seed);
|
|
return seed;
|
|
}
|
|
|
|
void ShaderInputBufferUnboundedArrayDescriptor::Reflect(ReflectContext* context)
|
|
{
|
|
if (SerializeContext* serializeContext = azrtti_cast<SerializeContext*>(context))
|
|
{
|
|
serializeContext->Class<ShaderInputBufferUnboundedArrayDescriptor>()
|
|
->Version(1)
|
|
->Field("m_name", &ShaderInputBufferUnboundedArrayDescriptor::m_name)
|
|
->Field("m_type", &ShaderInputBufferUnboundedArrayDescriptor::m_type)
|
|
->Field("m_access", &ShaderInputBufferUnboundedArrayDescriptor::m_access)
|
|
->Field("m_strideSize", &ShaderInputBufferUnboundedArrayDescriptor::m_strideSize)
|
|
->Field("m_registerId", &ShaderInputBufferUnboundedArrayDescriptor::m_registerId);
|
|
}
|
|
|
|
ShaderInputBufferUnboundedArrayIndex::Reflect(context);
|
|
}
|
|
|
|
ShaderInputBufferUnboundedArrayDescriptor::ShaderInputBufferUnboundedArrayDescriptor(
|
|
const Name& name,
|
|
ShaderInputBufferAccess access,
|
|
ShaderInputBufferType type,
|
|
uint32_t strideSize,
|
|
uint32_t registerId)
|
|
: m_name{ name }
|
|
, m_access{ access }
|
|
, m_type{ type }
|
|
, m_strideSize { strideSize }
|
|
, m_registerId{ registerId }
|
|
{}
|
|
|
|
HashValue64 ShaderInputBufferUnboundedArrayDescriptor::GetHash(HashValue64 seed) const
|
|
{
|
|
seed = TypeHash64(m_name.GetHash(), seed);
|
|
seed = TypeHash64(m_access, seed);
|
|
seed = TypeHash64(m_type, seed);
|
|
seed = TypeHash64(m_strideSize, seed);
|
|
seed = TypeHash64(m_registerId, seed);
|
|
return seed;
|
|
}
|
|
|
|
void ShaderInputImageUnboundedArrayDescriptor::Reflect(ReflectContext* context)
|
|
{
|
|
if (SerializeContext* serializeContext = azrtti_cast<SerializeContext*>(context))
|
|
{
|
|
serializeContext->Class<ShaderInputImageUnboundedArrayDescriptor>()
|
|
->Version(1)
|
|
->Field("m_name", &ShaderInputImageUnboundedArrayDescriptor::m_name)
|
|
->Field("m_type", &ShaderInputImageUnboundedArrayDescriptor::m_type)
|
|
->Field("m_access", &ShaderInputImageUnboundedArrayDescriptor::m_access)
|
|
->Field("m_registerId", &ShaderInputImageUnboundedArrayDescriptor::m_registerId);
|
|
}
|
|
|
|
ShaderInputImageUnboundedArrayIndex::Reflect(context);
|
|
}
|
|
|
|
ShaderInputImageUnboundedArrayDescriptor::ShaderInputImageUnboundedArrayDescriptor(
|
|
const Name& name,
|
|
ShaderInputImageAccess access,
|
|
ShaderInputImageType type,
|
|
uint32_t registerId)
|
|
: m_name{ name }
|
|
, m_access{ access }
|
|
, m_type { type }
|
|
, m_registerId{ registerId }
|
|
{}
|
|
|
|
HashValue64 ShaderInputImageUnboundedArrayDescriptor::GetHash(HashValue64 seed) const
|
|
{
|
|
seed = TypeHash64(m_name.GetHash(), seed);
|
|
seed = TypeHash64(m_access, seed);
|
|
seed = TypeHash64(m_type, seed);
|
|
seed = TypeHash64(m_registerId, seed);
|
|
return seed;
|
|
}
|
|
|
|
void ShaderInputSamplerDescriptor::Reflect(ReflectContext* context)
|
|
{
|
|
if (SerializeContext* serializeContext = azrtti_cast<SerializeContext*>(context))
|
|
{
|
|
serializeContext->Class<ShaderInputSamplerDescriptor>()
|
|
->Version(3)
|
|
->Field("m_name", &ShaderInputSamplerDescriptor::m_name)
|
|
->Field("m_count", &ShaderInputSamplerDescriptor::m_count)
|
|
->Field("m_registerId", &ShaderInputSamplerDescriptor::m_registerId);
|
|
}
|
|
|
|
ShaderInputSamplerIndex::Reflect(context);
|
|
}
|
|
|
|
ShaderInputSamplerDescriptor::ShaderInputSamplerDescriptor(
|
|
const Name& name,
|
|
uint32_t samplerCount,
|
|
uint32_t registerId)
|
|
: m_name{name}
|
|
, m_count{samplerCount}
|
|
, m_registerId{registerId}
|
|
{}
|
|
|
|
HashValue64 ShaderInputSamplerDescriptor::GetHash(HashValue64 seed) const
|
|
{
|
|
seed = TypeHash64(m_name.GetHash(), seed);
|
|
seed = TypeHash64(m_count, seed);
|
|
seed = TypeHash64(m_registerId, seed);
|
|
return seed;
|
|
}
|
|
|
|
void ShaderInputConstantDescriptor::Reflect(ReflectContext* context)
|
|
{
|
|
if (SerializeContext* serializeContext = azrtti_cast<SerializeContext*>(context))
|
|
{
|
|
serializeContext->Class<ShaderInputConstantDescriptor>()
|
|
->Version(3)
|
|
->Field("m_name", &ShaderInputConstantDescriptor::m_name)
|
|
->Field("m_constantByteOffset", &ShaderInputConstantDescriptor::m_constantByteOffset)
|
|
->Field("m_constantByteCount", &ShaderInputConstantDescriptor::m_constantByteCount)
|
|
->Field("m_registerId", &ShaderInputConstantDescriptor::m_registerId);
|
|
}
|
|
|
|
ShaderInputConstantIndex::Reflect(context);
|
|
}
|
|
|
|
ShaderInputConstantDescriptor::ShaderInputConstantDescriptor(
|
|
const Name& name,
|
|
uint32_t constantByteOffset,
|
|
uint32_t constantByteCount,
|
|
uint32_t registerId)
|
|
: m_name{name}
|
|
, m_constantByteOffset{constantByteOffset}
|
|
, m_constantByteCount{constantByteCount}
|
|
, m_registerId{registerId}
|
|
{}
|
|
|
|
HashValue64 ShaderInputConstantDescriptor::GetHash(HashValue64 seed) const
|
|
{
|
|
seed = TypeHash64(m_name.GetHash(), seed);
|
|
seed = TypeHash64(m_constantByteOffset, seed);
|
|
seed = TypeHash64(m_constantByteCount, seed);
|
|
seed = TypeHash64(m_registerId, seed);
|
|
return seed;
|
|
}
|
|
|
|
void ShaderInputStaticSamplerDescriptor::Reflect(ReflectContext* context)
|
|
{
|
|
if (SerializeContext* serializeContext = azrtti_cast<SerializeContext*>(context))
|
|
{
|
|
serializeContext->Class<ShaderInputStaticSamplerDescriptor>()
|
|
->Version(1)
|
|
->Field("m_name", &ShaderInputStaticSamplerDescriptor::m_name)
|
|
->Field("m_samplerState", &ShaderInputStaticSamplerDescriptor::m_samplerState)
|
|
->Field("m_registerId", &ShaderInputStaticSamplerDescriptor::m_registerId);
|
|
}
|
|
|
|
ShaderInputStaticSamplerIndex::Reflect(context);
|
|
}
|
|
|
|
ShaderInputStaticSamplerDescriptor::ShaderInputStaticSamplerDescriptor(
|
|
const Name& name, const SamplerState& samplerState, uint32_t registerId)
|
|
: m_name{name}
|
|
, m_samplerState{ samplerState }
|
|
, m_registerId{ registerId }
|
|
{}
|
|
|
|
HashValue64 ShaderInputStaticSamplerDescriptor::GetHash(HashValue64 seed) const
|
|
{
|
|
seed = TypeHash64(m_name.GetHash(), seed);
|
|
seed = m_samplerState.GetHash(seed);
|
|
seed = TypeHash64(m_registerId, seed);
|
|
return seed;
|
|
}
|
|
|
|
const char* GetShaderInputTypeName(ShaderInputBufferType bufferInputType)
|
|
{
|
|
switch (bufferInputType)
|
|
{
|
|
case ShaderInputBufferType::Structured:
|
|
return "Structured";
|
|
case ShaderInputBufferType::Typed:
|
|
return "Typed";
|
|
case ShaderInputBufferType::Raw:
|
|
return "Raw";
|
|
case ShaderInputBufferType::AccelerationStructure:
|
|
return "AccelerationStructure";
|
|
}
|
|
return "";
|
|
}
|
|
|
|
const char* GetShaderInputTypeName(ShaderInputImageType imageInputType)
|
|
{
|
|
switch (imageInputType)
|
|
{
|
|
case ShaderInputImageType::Image1D:
|
|
return "Image1D";
|
|
case ShaderInputImageType::Image1DArray:
|
|
return "Image1DArray";
|
|
case ShaderInputImageType::Image2D:
|
|
return "Image2D";
|
|
case ShaderInputImageType::Image2DArray:
|
|
return "Image2DArray";
|
|
case ShaderInputImageType::Image2DMultisample:
|
|
return "Image2DMultisample";
|
|
case ShaderInputImageType::Image2DMultisampleArray:
|
|
return "Image2DMultisampleArray";
|
|
case ShaderInputImageType::Image3D:
|
|
return "Image3D";
|
|
case ShaderInputImageType::ImageCube:
|
|
return "ImageCube";
|
|
case ShaderInputImageType::ImageCubeArray:
|
|
return "ImageCubeArray";
|
|
case ShaderInputImageType::SubpassInput:
|
|
return "SubpassInput";
|
|
}
|
|
return "";
|
|
}
|
|
|
|
const char* GetShaderInputAccessName(ShaderInputBufferAccess bufferInputAcces)
|
|
{
|
|
switch (bufferInputAcces)
|
|
{
|
|
case ShaderInputBufferAccess::Constant:
|
|
return "BufferConstant";
|
|
case ShaderInputBufferAccess::Read:
|
|
return "BufferRead";
|
|
case ShaderInputBufferAccess::ReadWrite:
|
|
return "BufferReadWrite";
|
|
}
|
|
return "";
|
|
}
|
|
|
|
const char* GetShaderInputAccessName(ShaderInputImageAccess imageInputAccess)
|
|
{
|
|
switch (imageInputAccess)
|
|
{
|
|
case ShaderInputImageAccess::Read:
|
|
return "ImageRead";
|
|
case ShaderInputImageAccess::ReadWrite:
|
|
return "ImageReadWrite";
|
|
}
|
|
return "";
|
|
}
|
|
}
|
|
}
|