From 3aa3262089534df259c9680a977d712acb57c7f9 Mon Sep 17 00:00:00 2001 From: baldurk Date: Wed, 27 Sep 2017 16:07:51 +0100 Subject: [PATCH] Expose ToStr interface publicly, split out into separate files * Note that while this is public and uses std::string, because it's a template with specialisations in a .inl the string never crosses a module boundary - each including module has its own implementation. * This will be used as part of the upcoming serialisation refactor. * Some POD structs are still given ToStr implementations as we haven't yet switched over the serialisation system to expect all structs to have serialise functions. --- qrenderdoc/Code/QRDUtils.cpp | 18 + qrenderdoc/Code/QRDUtils.h | 549 +----- qrenderdoc/Code/pyrenderdoc/pyconversion.i | 22 +- .../pyrenderdoc/pyrenderdoc_module.vcxproj | 2 +- qrenderdoc/Code/pyrenderdoc/renderdoc.i | 5 + qrenderdoc/qrenderdoc_local.vcxproj | 2 +- renderdoc/CMakeLists.txt | 2 + renderdoc/api/replay/renderdoc_replay.h | 20 +- renderdoc/api/replay/renderdoc_tostr.inl | 876 +++++++++ renderdoc/api/replay/stringise.h | 155 ++ renderdoc/api/replay/structured_data.h | 3 + renderdoc/common/custom_assert.h | 30 +- renderdoc/core/core.cpp | 157 +- renderdoc/core/remote_server.cpp | 24 - renderdoc/core/replay_proxy.cpp | 289 +-- renderdoc/driver/d3d11/d3d11_analyse.cpp | 106 +- renderdoc/driver/d3d11/d3d11_common.cpp | 593 +----- renderdoc/driver/d3d11/d3d11_common.h | 34 + renderdoc/driver/d3d11/d3d11_context.cpp | 2 +- .../driver/d3d11/d3d11_context1_wrap.cpp | 6 +- renderdoc/driver/d3d11/d3d11_context_wrap.cpp | 71 +- renderdoc/driver/d3d11/d3d11_counters.cpp | 4 +- renderdoc/driver/d3d11/d3d11_debug.cpp | 197 +- renderdoc/driver/d3d11/d3d11_device.cpp | 20 +- renderdoc/driver/d3d11/d3d11_device.h | 2 +- renderdoc/driver/d3d11/d3d11_device1_wrap.cpp | 4 +- renderdoc/driver/d3d11/d3d11_device3_wrap.cpp | 14 +- renderdoc/driver/d3d11/d3d11_device_wrap.cpp | 68 +- renderdoc/driver/d3d11/d3d11_hooks.cpp | 6 +- renderdoc/driver/d3d11/d3d11_resources.cpp | 35 - renderdoc/driver/d3d11/d3d11_resources.h | 6 +- renderdoc/driver/d3d11/d3d11_stringise.cpp | 630 ++++++ .../driver/d3d11/renderdoc_d3d11.vcxproj | 1 + .../d3d11/renderdoc_d3d11.vcxproj.filters | 3 + .../driver/d3d12/d3d12_command_list_wrap.cpp | 35 +- renderdoc/driver/d3d12/d3d12_command_queue.h | 2 +- .../driver/d3d12/d3d12_command_queue_wrap.cpp | 7 +- renderdoc/driver/d3d12/d3d12_commands.cpp | 4 +- renderdoc/driver/d3d12/d3d12_common.cpp | 958 +-------- renderdoc/driver/d3d12/d3d12_debug.cpp | 2 +- renderdoc/driver/d3d12/d3d12_device.cpp | 8 +- renderdoc/driver/d3d12/d3d12_device.h | 2 +- renderdoc/driver/d3d12/d3d12_device_wrap.cpp | 6 +- renderdoc/driver/d3d12/d3d12_hooks.cpp | 7 +- renderdoc/driver/d3d12/d3d12_replay.cpp | 2 +- renderdoc/driver/d3d12/d3d12_resources.h | 4 +- renderdoc/driver/d3d12/d3d12_stringise.cpp | 819 ++++++++ .../driver/d3d12/renderdoc_d3d12.vcxproj | 3 +- .../d3d12/renderdoc_d3d12.vcxproj.filters | 3 + renderdoc/driver/d3d8/d3d8_debug.cpp | 6 +- renderdoc/driver/d3d8/d3d8_device.cpp | 3 +- renderdoc/driver/d3d8/d3d8_resources.h | 2 +- renderdoc/driver/d3d9/d3d9_debug.cpp | 6 +- renderdoc/driver/d3d9/d3d9_device.cpp | 3 +- renderdoc/driver/dxgi/dxgi_common.cpp | 207 +- renderdoc/driver/dxgi/dxgi_common.h | 6 + renderdoc/driver/dxgi/dxgi_stringise.cpp | 241 +++ renderdoc/driver/dxgi/dxgi_wrapped.cpp | 31 +- renderdoc/driver/dxgi/renderdoc_dxgi.vcxproj | 3 +- .../dxgi/renderdoc_dxgi.vcxproj.filters | 3 + renderdoc/driver/gl/gl_common.cpp | 50 +- renderdoc/driver/gl/gl_debug.cpp | 6 +- renderdoc/driver/gl/gl_driver.cpp | 5 +- renderdoc/driver/gl/gl_replay.cpp | 6 +- renderdoc/driver/gl/gl_resources.cpp | 18 +- renderdoc/driver/gl/gl_shader_refl.cpp | 4 +- .../driver/gl/wrappers/gl_buffer_funcs.cpp | 6 +- .../driver/gl/wrappers/gl_draw_funcs.cpp | 172 +- renderdoc/driver/gl/wrappers/gl_emulated.cpp | 8 +- .../gl/wrappers/gl_framebuffer_funcs.cpp | 2 +- .../driver/gl/wrappers/gl_interop_funcs.cpp | 2 +- .../driver/gl/wrappers/gl_query_funcs.cpp | 2 +- .../driver/gl/wrappers/gl_texture_funcs.cpp | 8 +- renderdoc/driver/shaders/dxbc/dxbc_debug.cpp | 20 +- .../driver/shaders/dxbc/dxbc_inspect.cpp | 2 +- renderdoc/driver/shaders/spirv/CMakeLists.txt | 1 + .../shaders/spirv/renderdoc_spirv.vcxproj | 3 +- .../spirv/renderdoc_spirv.vcxproj.filters | 1 + .../shaders/spirv/spirv_disassemble.cpp | 961 +-------- .../driver/shaders/spirv/spirv_stringise.cpp | 857 ++++++++ renderdoc/driver/vulkan/CMakeLists.txt | 1 + .../driver/vulkan/renderdoc_vulkan.vcxproj | 13 +- .../vulkan/renderdoc_vulkan.vcxproj.filters | 3 + renderdoc/driver/vulkan/vk_common.cpp | 1742 ----------------- renderdoc/driver/vulkan/vk_common.h | 7 + renderdoc/driver/vulkan/vk_core.cpp | 2 +- renderdoc/driver/vulkan/vk_debug.cpp | 10 +- renderdoc/driver/vulkan/vk_manager.cpp | 16 +- renderdoc/driver/vulkan/vk_replay.cpp | 2 +- renderdoc/driver/vulkan/vk_stringise.cpp | 1486 ++++++++++++++ .../driver/vulkan/wrappers/vk_cmd_funcs.cpp | 23 +- .../vulkan/wrappers/vk_device_funcs.cpp | 2 +- .../driver/vulkan/wrappers/vk_draw_funcs.cpp | 42 +- .../driver/vulkan/wrappers/vk_queue_funcs.cpp | 6 +- renderdoc/renderdoc.vcxproj | 2 + renderdoc/renderdoc.vcxproj.filters | 6 + renderdoc/serialise/serialiser.cpp | 96 +- renderdoc/serialise/serialiser.h | 66 +- renderdoccmd/renderdoccmd.cpp | 27 +- 99 files changed, 5927 insertions(+), 6088 deletions(-) create mode 100644 renderdoc/api/replay/renderdoc_tostr.inl create mode 100644 renderdoc/api/replay/stringise.h create mode 100644 renderdoc/driver/d3d11/d3d11_stringise.cpp create mode 100644 renderdoc/driver/d3d12/d3d12_stringise.cpp create mode 100644 renderdoc/driver/dxgi/dxgi_stringise.cpp create mode 100644 renderdoc/driver/shaders/spirv/spirv_stringise.cpp create mode 100644 renderdoc/driver/vulkan/vk_stringise.cpp diff --git a/qrenderdoc/Code/QRDUtils.cpp b/qrenderdoc/Code/QRDUtils.cpp index e08ba71e6..6f1ca1bac 100644 --- a/qrenderdoc/Code/QRDUtils.cpp +++ b/qrenderdoc/Code/QRDUtils.cpp @@ -41,6 +41,24 @@ #include #include +// normally this is in the renderdoc core library, but it's needed for the 'unknown enum' path, +// so we implement it here using QString. It's inefficient, but this is a very uncommon path - +// either for invalid values or for when a new enum is added and the code isn't updated +template <> +std::string DoStringise(const uint32_t &el) +{ + return QString::number(el).toStdString(); +} + +// this one we do by hand as it requires formatting +template <> +std::string DoStringise(const ResourceId &el) +{ + return QString::number((const uint64_t &)el).toStdString(); +} + +#include "renderdoc_tostr.inl" + QString ToQStr(const ResourceUsage usage, const GraphicsAPI apitype) { if(IsD3D(apitype)) diff --git a/qrenderdoc/Code/QRDUtils.h b/qrenderdoc/Code/QRDUtils.h index df9977b6c..70ff9184b 100644 --- a/qrenderdoc/Code/QRDUtils.h +++ b/qrenderdoc/Code/QRDUtils.h @@ -44,560 +44,13 @@ inline T AlignUp(T x, T a) #define ARRAY_COUNT(arr) (sizeof(arr) / sizeof(arr[0])) #endif -// total hack, expose the same basic interface as on renderdoc side. -// Eventually we want to move the code in the main project into header-only -// and .inl implementations for at least the public API, so it can be compiled -// directly without duplication - -struct ToStr -{ - static std::string Get(const ResourceId &el) - { - // super inefficient to convert to qstr then std::string then back to qstr - // but this is just a temporary measure - uint64_t num = 0; - memcpy(&num, &el, sizeof(num)); - return QString::number(num).toStdString(); - } - - static std::string Get(const ReplayStatus &el) - { - switch(el) - { - case ReplayStatus::Succeeded: return "Success"; - case ReplayStatus::UnknownError: return "Unknown error"; - case ReplayStatus::InternalError: return "Internal error"; - case ReplayStatus::FileNotFound: return "File not found"; - case ReplayStatus::InjectionFailed: return "RenderDoc injection failed"; - case ReplayStatus::IncompatibleProcess: return "Process is incompatible"; - case ReplayStatus::NetworkIOFailed: return "Network I/O operation failed"; - case ReplayStatus::NetworkRemoteBusy: return "Remote side of network connection is busy"; - case ReplayStatus::NetworkVersionMismatch: return "Version mismatch between network clients"; - case ReplayStatus::FileIOFailed: return "File I/O failed"; - case ReplayStatus::FileIncompatibleVersion: return "File of incompatible version"; - case ReplayStatus::FileCorrupted: return "File corrupted"; - case ReplayStatus::APIUnsupported: return "API unsupported"; - case ReplayStatus::APIInitFailed: return "API initialisation failed"; - case ReplayStatus::APIIncompatibleVersion: return "API incompatible version"; - case ReplayStatus::APIHardwareUnsupported: return "API hardware unsupported"; - default: break; - } - return "Invalid error code"; - } - - static std::string Get(const CompType &el) - { - switch(el) - { - case CompType::Typeless: return "Typeless"; - case CompType::Float: return "Float"; - case CompType::UNorm: return "UNorm"; - case CompType::SNorm: return "SNorm"; - case CompType::UInt: return "UInt"; - case CompType::SInt: return "SInt"; - case CompType::UScaled: return "UScaled"; - case CompType::SScaled: return "SScaled"; - case CompType::Depth: return "Depth/Stencil"; - case CompType::Double: return "Double"; - default: break; - } - return "Invalid component type"; - } - - static std::string Get(const FileType &el) - { - switch(el) - { - case FileType::DDS: return "DDS"; - case FileType::PNG: return "PNG"; - case FileType::JPG: return "JPG"; - case FileType::BMP: return "BMP"; - case FileType::TGA: return "TGA"; - case FileType::HDR: return "HDR"; - case FileType::EXR: return "EXR"; - default: break; - } - return "Invalid file type"; - } - - static std::string Get(const AlphaMapping &el) - { - switch(el) - { - case AlphaMapping::Discard: return "Discard"; - case AlphaMapping::BlendToColor: return "Blend to Color"; - case AlphaMapping::BlendToCheckerboard: return "Blend to Checkerboard"; - case AlphaMapping::Preserve: return "Preserve"; - default: break; - } - return "Invalid mapping"; - } - - static std::string Get(const EnvMod &el) - { - switch(el) - { - case EnvMod::Set: return "Set"; - case EnvMod::Append: return "Append"; - case EnvMod::Prepend: return "Prepend"; - default: break; - } - return "Invalid modification"; - } - - static std::string Get(const EnvSep &el) - { - switch(el) - { - case EnvSep::Platform: return "Platform style"; - case EnvSep::SemiColon: return "Semi-colon (;)"; - case EnvSep::Colon: return "Colon (:)"; - case EnvSep::NoSep: return "No Separator"; - default: break; - } - return "Invalid separator"; - } - - static std::string Get(const Topology &el) - { - switch(el) - { - case Topology::Unknown: return "Unknown"; - case Topology::PointList: return "Point List"; - case Topology::LineList: return "Line List"; - case Topology::LineStrip: return "Line Strip"; - case Topology::LineLoop: return "Line Loop"; - case Topology::TriangleList: return "Triangle List"; - case Topology::TriangleStrip: return "Triangle Strip"; - case Topology::TriangleFan: return "Triangle Fan"; - case Topology::LineList_Adj: return "Line List with Adjacency"; - case Topology::LineStrip_Adj: return "Line Strip with Adjacency"; - case Topology::TriangleList_Adj: return "Triangle List with Adjacency"; - case Topology::TriangleStrip_Adj: return "Triangle Strip with Adjacency"; - case Topology::PatchList_1CPs: - case Topology::PatchList_2CPs: - case Topology::PatchList_3CPs: - case Topology::PatchList_4CPs: - case Topology::PatchList_5CPs: - case Topology::PatchList_6CPs: - case Topology::PatchList_7CPs: - case Topology::PatchList_8CPs: - case Topology::PatchList_9CPs: - case Topology::PatchList_10CPs: - case Topology::PatchList_11CPs: - case Topology::PatchList_12CPs: - case Topology::PatchList_13CPs: - case Topology::PatchList_14CPs: - case Topology::PatchList_15CPs: - case Topology::PatchList_16CPs: - case Topology::PatchList_17CPs: - case Topology::PatchList_18CPs: - case Topology::PatchList_19CPs: - case Topology::PatchList_20CPs: - case Topology::PatchList_21CPs: - case Topology::PatchList_22CPs: - case Topology::PatchList_23CPs: - case Topology::PatchList_24CPs: - case Topology::PatchList_25CPs: - case Topology::PatchList_26CPs: - case Topology::PatchList_27CPs: - case Topology::PatchList_28CPs: - case Topology::PatchList_29CPs: - case Topology::PatchList_30CPs: - case Topology::PatchList_31CPs: - case Topology::PatchList_32CPs: return "Patch List"; - default: break; - } - return "Unknown topology"; - } - - static std::string Get(const FillMode &el) - { - switch(el) - { - case FillMode::Solid: return "Solid"; - case FillMode::Wireframe: return "Wireframe"; - case FillMode::Point: return "Point"; - default: break; - } - return "Unknown"; - } - - static std::string Get(const CullMode &el) - { - switch(el) - { - case CullMode::NoCull: return "None"; - case CullMode::Front: return "Front"; - case CullMode::Back: return "Back"; - case CullMode::FrontAndBack: return "Front & Back"; - default: break; - } - return "Unknown"; - } - - static std::string Get(const FilterMode &el) - { - switch(el) - { - case FilterMode::NoFilter: return "None"; - case FilterMode::Point: return "Point"; - case FilterMode::Linear: return "Linear"; - case FilterMode::Cubic: return "Cubic"; - case FilterMode::Anisotropic: return "Anisotropic"; - } - return "Unknown"; - } - - static std::string Get(const FilterFunc &el) - { - switch(el) - { - case FilterFunc::Normal: return "Normal"; - case FilterFunc::Comparison: return "Comparison"; - case FilterFunc::Minimum: return "Minimum"; - case FilterFunc::Maximum: return "Maximum"; - } - return "Unknown"; - } - - static std::string Get(const CompareFunc &el) - { - switch(el) - { - case CompareFunc::Never: return "Never"; - case CompareFunc::AlwaysTrue: return "Always"; - case CompareFunc::Less: return "Less"; - case CompareFunc::LessEqual: return "Less Equal"; - case CompareFunc::Greater: return "Greater"; - case CompareFunc::GreaterEqual: return "Greater Equal"; - case CompareFunc::Equal: return "Equal"; - case CompareFunc::NotEqual: return "NotEqual"; - } - return "Unknown"; - } - - static std::string Get(const AddressMode &el) - { - switch(el) - { - case AddressMode::Wrap: return "Wrap"; - case AddressMode::Mirror: return "Mirror"; - case AddressMode::MirrorOnce: return "Mirror Once"; - case AddressMode::ClampEdge: return "Clamp Edge"; - case AddressMode::ClampBorder: return "Clamp Border"; - } - return "Unknown"; - } - - static std::string Get(const BlendMultiplier &el) - { - switch(el) - { - case BlendMultiplier::Zero: return "Zero"; - case BlendMultiplier::One: return "One"; - case BlendMultiplier::SrcCol: return "Src Col"; - case BlendMultiplier::InvSrcCol: return "1 - Src Col"; - case BlendMultiplier::DstCol: return "Dst Col"; - case BlendMultiplier::InvDstCol: return "1 - Dst Col"; - case BlendMultiplier::SrcAlpha: return "Src Alpha"; - case BlendMultiplier::InvSrcAlpha: return "1 - Src Alpha"; - case BlendMultiplier::DstAlpha: return "Dst Alpha"; - case BlendMultiplier::InvDstAlpha: return "1 - Dst Alpha"; - case BlendMultiplier::SrcAlphaSat: return "Src Alpha Sat"; - case BlendMultiplier::FactorRGB: return "Constant RGB"; - case BlendMultiplier::InvFactorRGB: return "1 - Constant RGB"; - case BlendMultiplier::FactorAlpha: return "Constant A"; - case BlendMultiplier::InvFactorAlpha: return "1 - Constant A"; - case BlendMultiplier::Src1Col: return "Src1 Col"; - case BlendMultiplier::InvSrc1Col: return "1 - Src1 Col"; - case BlendMultiplier::Src1Alpha: return "Src1 Alpha"; - case BlendMultiplier::InvSrc1Alpha: return "1 - Src1 Alpha"; - } - return "Unknown"; - } - - static std::string Get(const BlendOp &el) - { - switch(el) - { - case BlendOp::Add: return "Add"; - case BlendOp::Subtract: return "Subtract"; - case BlendOp::ReversedSubtract: return "Rev. Subtract"; - case BlendOp::Minimum: return "Minimum"; - case BlendOp::Maximum: return "Maximum"; - } - return "Unknown"; - } - - static std::string Get(const StencilOp &el) - { - switch(el) - { - case StencilOp::Keep: return "Keep"; - case StencilOp::Zero: return "Zero"; - case StencilOp::Replace: return "Replace"; - case StencilOp::IncSat: return "Inc Sat"; - case StencilOp::DecSat: return "Dec Sat"; - case StencilOp::IncWrap: return "Inc Wrap"; - case StencilOp::DecWrap: return "Dec Wrap"; - case StencilOp::Invert: return "Invert"; - } - return "Unknown"; - } - - static std::string Get(const LogicOp &el) - { - switch(el) - { - case LogicOp::NoOp: return "No-Op"; - case LogicOp::Clear: return "Clear"; - case LogicOp::Set: return "Set"; - case LogicOp::Copy: return "Copy"; - case LogicOp::CopyInverted: return "Copy Inverted"; - case LogicOp::Invert: return "Invert"; - case LogicOp::And: return "And"; - case LogicOp::Nand: return "Nand"; - case LogicOp::Or: return "Or"; - case LogicOp::Xor: return "Xor"; - case LogicOp::Nor: return "Nor"; - case LogicOp::Equivalent: return "Equivalent"; - case LogicOp::AndReverse: return "And Reverse"; - case LogicOp::AndInverted: return "And Inverted"; - case LogicOp::OrReverse: return "Or Reverse"; - case LogicOp::OrInverted: return "Or Inverted"; - } - return "Unknown"; - } - - static std::string Get(const QualityHint &el) - { - switch(el) - { - case QualityHint::DontCare: return "Don't Care"; - case QualityHint::Nicest: return "Nicest"; - case QualityHint::Fastest: return "Fastest"; - } - return "Unknown"; - } - - static std::string Get(const TextureFilter &el) - { - std::string filter = ""; - std::string filtPrefix = ""; - std::string filtVal = ""; - - std::string filters[] = {ToStr::Get(el.minify), ToStr::Get(el.magnify), ToStr::Get(el.mip)}; - std::string filterPrefixes[] = {"Min", "Mag", "Mip"}; - - for(int a = 0; a < 3; a++) - { - if(a == 0 || filters[a] == filters[a - 1]) - { - if(filtPrefix != "") - filtPrefix += "/"; - filtPrefix += filterPrefixes[a]; - } - else - { - filter += filtPrefix + ": " + filtVal + ", "; - - filtPrefix = filterPrefixes[a]; - } - filtVal = filters[a]; - } - - filter += filtPrefix + ": " + filtVal; - - return filter; - } - - static std::string Get(const D3DBufferViewFlags &el) - { - std::string ret; - - if(el == D3DBufferViewFlags::NoFlags) - return ""; - - if(el & D3DBufferViewFlags::Raw) - ret += " | Raw"; - if(el & D3DBufferViewFlags::Append) - ret += " | Append"; - if(el & D3DBufferViewFlags::Counter) - ret += " | Counter"; - - if(!ret.empty()) - ret = ret.substr(3); - - return ret; - } - - static std::string Get(const TextureDim &el) - { - switch(el) - { - case TextureDim::Unknown: return "Unknown"; - case TextureDim::Buffer: return "Buffer"; - case TextureDim::Texture1D: return "Texture 1D"; - case TextureDim::Texture1DArray: return "Texture 1D Array"; - case TextureDim::Texture2D: return "Texture 2D"; - case TextureDim::TextureRect: return "Texture Rect"; - case TextureDim::Texture2DArray: return "Texture 2D Array"; - case TextureDim::Texture2DMS: return "Texture 2D MS"; - case TextureDim::Texture2DMSArray: return "Texture 2D MS Array"; - case TextureDim::Texture3D: return "Texture 3D"; - case TextureDim::TextureCube: return "Texture Cube"; - case TextureDim::TextureCubeArray: return "Texture Cube Array"; - default: break; - } - return "Unknown"; - } - - static std::string Get(const ShaderBuiltin &el) - { - switch(el) - { - case ShaderBuiltin::Undefined: return "Undefined"; - case ShaderBuiltin::Position: return "Position"; - case ShaderBuiltin::PointSize: return "Point Size"; - case ShaderBuiltin::ClipDistance: return "Clip Distance"; - case ShaderBuiltin::CullDistance: return "Cull Distance"; - case ShaderBuiltin::RTIndex: return "RT Index"; - case ShaderBuiltin::ViewportIndex: return "Viewport Index"; - case ShaderBuiltin::VertexIndex: return "Vertex Index"; - case ShaderBuiltin::PrimitiveIndex: return "Primitive Index"; - case ShaderBuiltin::InstanceIndex: return "Instance Index"; - case ShaderBuiltin::DispatchSize: return "Dispatch Size"; - case ShaderBuiltin::DispatchThreadIndex: return "Dispatch Thread Index"; - case ShaderBuiltin::GroupIndex: return "Group Index"; - case ShaderBuiltin::GroupFlatIndex: return "Group Flat Index"; - case ShaderBuiltin::GroupThreadIndex: return "Group Thread Index"; - case ShaderBuiltin::GSInstanceIndex: return "GS Instance Index"; - case ShaderBuiltin::OutputControlPointIndex: return "Output Control Point Index"; - case ShaderBuiltin::DomainLocation: return "Domain Location"; - case ShaderBuiltin::IsFrontFace: return "Is FrontFace"; - case ShaderBuiltin::MSAACoverage: return "MSAA Coverage"; - case ShaderBuiltin::MSAASamplePosition: return "MSAA Sample Position"; - case ShaderBuiltin::MSAASampleIndex: return "MSAA Sample Index"; - case ShaderBuiltin::PatchNumVertices: return "Patch NumVertices"; - case ShaderBuiltin::OuterTessFactor: return "Outer TessFactor"; - case ShaderBuiltin::InsideTessFactor: return "Inside TessFactor"; - case ShaderBuiltin::ColorOutput: return "Color Output"; - case ShaderBuiltin::DepthOutput: return "Depth Output"; - case ShaderBuiltin::DepthOutputGreaterEqual: return "Depth Output (GEqual)"; - case ShaderBuiltin::DepthOutputLessEqual: return "Depth Output (LEqual)"; - default: break; - } - return "Unknown"; - } - - static std::string Get(const BindType &el) - { - switch(el) - { - case BindType::ConstantBuffer: return "Constants"; - case BindType::Sampler: return "Sampler"; - case BindType::ImageSampler: return "Image&Sampler"; - case BindType::ReadOnlyImage: return "Image"; - case BindType::ReadWriteImage: return "RW Image"; - case BindType::ReadOnlyTBuffer: return "TexBuffer"; - case BindType::ReadWriteTBuffer: return "RW TexBuffer"; - case BindType::ReadOnlyBuffer: return "Buffer"; - case BindType::ReadWriteBuffer: return "RW Buffer"; - case BindType::InputAttachment: return "Input"; - default: break; - } - return "Unknown"; - } - - static std::string Get(const MessageSource &el) - { - switch(el) - { - case MessageSource::API: return "API"; - case MessageSource::RedundantAPIUse: return "Redundant API Use"; - case MessageSource::IncorrectAPIUse: return "Incorrect API Use"; - case MessageSource::GeneralPerformance: return "General Performance"; - case MessageSource::GCNPerformance: return "GCN Performance"; - case MessageSource::RuntimeWarning: return "Runtime Warning"; - case MessageSource::UnsupportedConfiguration: return "Unsupported Configuration"; - default: break; - } - return "Unknown"; - } - - static std::string Get(const MessageSeverity &el) - { - switch(el) - { - case MessageSeverity::High: return "High"; - case MessageSeverity::Medium: return "Medium"; - case MessageSeverity::Low: return "Low"; - case MessageSeverity::Info: return "Info"; - default: break; - } - return "Unknown"; - } - - static std::string Get(const MessageCategory &el) - { - switch(el) - { - case MessageCategory::Application_Defined: return "Application Defined"; - case MessageCategory::Miscellaneous: return "Miscellaneous"; - case MessageCategory::Initialization: return "Initialization"; - case MessageCategory::Cleanup: return "Cleanup"; - case MessageCategory::Compilation: return "Compilation"; - case MessageCategory::State_Creation: return "State Creation"; - case MessageCategory::State_Setting: return "State Setting"; - case MessageCategory::State_Getting: return "State Getting"; - case MessageCategory::Resource_Manipulation: return "Resource Manipulation"; - case MessageCategory::Execution: return "Execution"; - case MessageCategory::Shaders: return "Shaders"; - case MessageCategory::Deprecated: return "Deprecated"; - case MessageCategory::Undefined: return "Undefined"; - case MessageCategory::Portability: return "Portability"; - case MessageCategory::Performance: return "Performance"; - default: break; - } - return "Unknown"; - } - - static std::string Get(const TextureSwizzle &el) - { - switch(el) - { - case TextureSwizzle::Red: return "R"; - case TextureSwizzle::Green: return "G"; - case TextureSwizzle::Blue: return "B"; - case TextureSwizzle::Alpha: return "A"; - case TextureSwizzle::Zero: return "0"; - case TextureSwizzle::One: return "1"; - } - return "Unknown"; - } - - static std::string Get(const VarType &el) - { - switch(el) - { - case VarType::Float: return "float"; - case VarType::Int: return "int"; - case VarType::UInt: return "uint"; - case VarType::Double: return "double"; - case VarType::Unknown: break; - } - return "Unknown"; - } -}; - // this will be here to lighten the burden of converting from std::string to // QString everywhere. template inline QString ToQStr(const T &el) { - return QString::fromStdString(ToStr::Get(el)); + return QString::fromStdString(ToStr(el)); } // overload for a couple of things that need to know the pipeline type when converting diff --git a/qrenderdoc/Code/pyrenderdoc/pyconversion.i b/qrenderdoc/Code/pyrenderdoc/pyconversion.i index 9433655f1..03631881b 100644 --- a/qrenderdoc/Code/pyrenderdoc/pyconversion.i +++ b/qrenderdoc/Code/pyrenderdoc/pyconversion.i @@ -107,17 +107,17 @@ SIMPLE_TYPEMAPS_VARIANT(SimpleType, SimpleType &) #include "Code/pyrenderdoc/pyconversion.h" // declare the basic building blocks as stringize types - DECLARE_REFLECTION_STRUCT(int8_t); - DECLARE_REFLECTION_STRUCT(uint8_t); - DECLARE_REFLECTION_STRUCT(int16_t); - DECLARE_REFLECTION_STRUCT(uint16_t); - DECLARE_REFLECTION_STRUCT(int32_t); - DECLARE_REFLECTION_STRUCT(uint32_t); - DECLARE_REFLECTION_STRUCT(int64_t); - DECLARE_REFLECTION_STRUCT(uint64_t); - DECLARE_REFLECTION_STRUCT(float); - DECLARE_REFLECTION_STRUCT(double); - DECLARE_REFLECTION_STRUCT(rdcstr); + DECLARE_STRINGISE_TYPE(int8_t); + DECLARE_STRINGISE_TYPE(uint8_t); + DECLARE_STRINGISE_TYPE(int16_t); + DECLARE_STRINGISE_TYPE(uint16_t); + DECLARE_STRINGISE_TYPE(int32_t); + DECLARE_STRINGISE_TYPE(uint32_t); + DECLARE_STRINGISE_TYPE(int64_t); + DECLARE_STRINGISE_TYPE(uint64_t); + DECLARE_STRINGISE_TYPE(float); + DECLARE_STRINGISE_TYPE(double); + DECLARE_STRINGISE_TYPE(rdcstr); %} diff --git a/qrenderdoc/Code/pyrenderdoc/pyrenderdoc_module.vcxproj b/qrenderdoc/Code/pyrenderdoc/pyrenderdoc_module.vcxproj index 1a6793bef..0b7677a80 100644 --- a/qrenderdoc/Code/pyrenderdoc/pyrenderdoc_module.vcxproj +++ b/qrenderdoc/Code/pyrenderdoc/pyrenderdoc_module.vcxproj @@ -225,7 +225,7 @@ Document - %(Fullpath);container_handling.i;pyconversion.i;cosmetics.i;$(SolutionDir)renderdoc\api\replay\basic_types.h;$(SolutionDir)renderdoc\api\replay\capture_options.h;$(SolutionDir)renderdoc\api\replay\control_types.h;$(SolutionDir)renderdoc\api\replay\d3d11_pipestate.h;$(SolutionDir)renderdoc\api\replay\d3d12_pipestate.h;$(SolutionDir)renderdoc\api\replay\data_types.h;$(SolutionDir)renderdoc\api\replay\gl_pipestate.h;$(SolutionDir)renderdoc\api\replay\renderdoc_replay.h;$(SolutionDir)renderdoc\api\replay\replay_enums.h;$(SolutionDir)renderdoc\api\replay\shader_types.h;$(SolutionDir)renderdoc\api\replay\version.h;$(SolutionDir)renderdoc\api\replay\structured_data.h;$(SolutionDir)renderdoc\api\replay\vk_pipestate.h;%(AdditionalInputs) + %(Fullpath);container_handling.i;pyconversion.i;cosmetics.i;$(SolutionDir)renderdoc\api\replay\basic_types.h;$(SolutionDir)renderdoc\api\replay\capture_options.h;$(SolutionDir)renderdoc\api\replay\control_types.h;$(SolutionDir)renderdoc\api\replay\d3d11_pipestate.h;$(SolutionDir)renderdoc\api\replay\d3d12_pipestate.h;$(SolutionDir)renderdoc\api\replay\data_types.h;$(SolutionDir)renderdoc\api\replay\gl_pipestate.h;$(SolutionDir)renderdoc\api\replay\renderdoc_replay.h;$(SolutionDir)renderdoc\api\replay\replay_enums.h;$(SolutionDir)renderdoc\api\replay\shader_types.h;$(SolutionDir)renderdoc\api\replay\version.h;$(SolutionDir)renderdoc\api\replay\stringise.h;$(SolutionDir)renderdoc\api\replay\structured_data.h;$(SolutionDir)renderdoc\api\replay\vk_pipestate.h;%(AdditionalInputs) $(ProjectDir)..\..\3rdparty\swig\swig.exe -v -Wextra -Werror -O -c++ -python -modern -modernargs -enumclass -fastunpack -py3 -builtin -I$(SolutionDir)renderdoc\api\replay -outdir $(IntDir)generated -o $(IntDir)generated\%(Filename)_python.cxx %(FullPath) Compiling SWIG interface $(IntDir)generated\%(Filename).py;$(IntDir)generated\r%(Filename)_python.cxx;%(Outputs) diff --git a/qrenderdoc/Code/pyrenderdoc/renderdoc.i b/qrenderdoc/Code/pyrenderdoc/renderdoc.i index 396ca679b..03278bc7d 100644 --- a/qrenderdoc/Code/pyrenderdoc/renderdoc.i +++ b/qrenderdoc/Code/pyrenderdoc/renderdoc.i @@ -9,6 +9,10 @@ // we don't need these for the interface, they just confuse things #define NO_ENUM_CLASS_OPERATORS +// swig's pre-processor trips up on this definition, and it's only needed for template expansions +// in the conversion code +#define DECLARE_REFLECTION_STRUCT(t) + // use documentation for docstrings #define DOCUMENT(text) %feature("docstring") text #define DOCUMENT2(text1, text2) %feature("docstring") text1 text2 @@ -136,6 +140,7 @@ TEMPLATE_ARRAY_DECLARE(rdcarray); %include "renderdoc_replay.h" %include "basic_types.h" +%include "stringise.h" %include "structured_data.h" %include "capture_options.h" %include "control_types.h" diff --git a/qrenderdoc/qrenderdoc_local.vcxproj b/qrenderdoc/qrenderdoc_local.vcxproj index 0204f2cf7..09ff0a3bd 100644 --- a/qrenderdoc/qrenderdoc_local.vcxproj +++ b/qrenderdoc/qrenderdoc_local.vcxproj @@ -1241,7 +1241,7 @@ Document - %(Fullpath);container_handling.i;pyconversion.i;cosmetics.i;document_check.h;$(SolutionDir)renderdoc\api\replay\basic_types.h;$(SolutionDir)renderdoc\api\replay\capture_options.h;$(SolutionDir)renderdoc\api\replay\control_types.h;$(SolutionDir)renderdoc\api\replay\d3d11_pipestate.h;$(SolutionDir)renderdoc\api\replay\d3d12_pipestate.h;$(SolutionDir)renderdoc\api\replay\data_types.h;$(SolutionDir)renderdoc\api\replay\gl_pipestate.h;$(SolutionDir)renderdoc\api\replay\renderdoc_replay.h;$(SolutionDir)renderdoc\api\replay\replay_enums.h;$(SolutionDir)renderdoc\api\replay\shader_types.h;$(SolutionDir)renderdoc\api\replay\structured_data.h;$(SolutionDir)renderdoc\api\replay\vk_pipestate.h;%(AdditionalInputs) + %(Fullpath);container_handling.i;pyconversion.i;cosmetics.i;document_check.h;$(SolutionDir)renderdoc\api\replay\basic_types.h;$(SolutionDir)renderdoc\api\replay\capture_options.h;$(SolutionDir)renderdoc\api\replay\control_types.h;$(SolutionDir)renderdoc\api\replay\d3d11_pipestate.h;$(SolutionDir)renderdoc\api\replay\d3d12_pipestate.h;$(SolutionDir)renderdoc\api\replay\data_types.h;$(SolutionDir)renderdoc\api\replay\gl_pipestate.h;$(SolutionDir)renderdoc\api\replay\renderdoc_replay.h;$(SolutionDir)renderdoc\api\replay\replay_enums.h;$(SolutionDir)renderdoc\api\replay\shader_types.h;$(SolutionDir)renderdoc\api\replay\stringise.h;$(SolutionDir)renderdoc\api\replay\structured_data.h;$(SolutionDir)renderdoc\api\replay\vk_pipestate.h;%(AdditionalInputs) "$(ProjectDir)3rdparty\swig\swig.exe" -v -Wextra -Werror -O -c++ -python -modern -modernargs -enumclass -fastunpack -py3 -builtin -I"$(SolutionDir)renderdoc\api\replay" -outdir "$(IntDir)generated" -o "$(IntDir)generated\%(Filename)_python.cxx" "%(FullPath)" Compiling SWIG interface $(IntDir)generated\%(Filename).py;$(IntDir)generated\%(Filename)_python.cxx;%(Outputs) diff --git a/renderdoc/CMakeLists.txt b/renderdoc/CMakeLists.txt index 1ffb2781e..af73bfce2 100644 --- a/renderdoc/CMakeLists.txt +++ b/renderdoc/CMakeLists.txt @@ -55,6 +55,7 @@ endif() set(sources api/app/renderdoc_app.h api/replay/basic_types.h + api/replay/stringise.h api/replay/structured_data.h api/replay/capture_options.h api/replay/control_types.h @@ -66,6 +67,7 @@ set(sources api/replay/shader_types.h api/replay/vk_pipestate.h api/replay/version.h + api/replay/renderdoc_tostr.inl common/common.cpp common/common.h common/custom_assert.h diff --git a/renderdoc/api/replay/renderdoc_replay.h b/renderdoc/api/replay/renderdoc_replay.h index aba642bcf..d6fd431af 100644 --- a/renderdoc/api/replay/renderdoc_replay.h +++ b/renderdoc/api/replay/renderdoc_replay.h @@ -28,16 +28,6 @@ #include #include -template -inline const char *TypeName(); - -#define DECLARE_REFLECTION_STRUCT(type) \ - template <> \ - inline const char *TypeName() \ - { \ - return #type; \ - } - // Guidelines for documentation: // // * If you only need a short string, use DOCUMENT("Here is my string"); @@ -345,6 +335,16 @@ inline enum_name operator++(enum_name &a) \ #define ENUM_ARRAY_SIZE(enum_name) size_t(enum_name::Count) #include "basic_types.h" +#include "stringise.h" + +#ifndef DECLARE_REFLECTION_STRUCT +#define DECLARE_REFLECTION_STRUCT(type) DECLARE_STRINGISE_TYPE(type) +#endif + +#ifndef DECLARE_REFLECTION_ENUM +#define DECLARE_REFLECTION_ENUM(type) DECLARE_STRINGISE_TYPE(type) +#endif + #include "structured_data.h" #ifdef RENDERDOC_EXPORTS diff --git a/renderdoc/api/replay/renderdoc_tostr.inl b/renderdoc/api/replay/renderdoc_tostr.inl new file mode 100644 index 000000000..1fd4ecd9b --- /dev/null +++ b/renderdoc/api/replay/renderdoc_tostr.inl @@ -0,0 +1,876 @@ +/****************************************************************************** + * The MIT License (MIT) + * + * Copyright (c) 2017 Baldur Karlsson + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ + +template <> +std::string DoStringise(const ReplayStatus &el) +{ + BEGIN_ENUM_STRINGISE(ReplayStatus) + { + STRINGISE_ENUM_CLASS_NAMED(Succeeded, "Success"); + STRINGISE_ENUM_CLASS_NAMED(UnknownError, "Unknown error"); + STRINGISE_ENUM_CLASS_NAMED(InternalError, "Internal error"); + STRINGISE_ENUM_CLASS_NAMED(FileNotFound, "File not found"); + STRINGISE_ENUM_CLASS_NAMED(InjectionFailed, "RenderDoc injection failed"); + STRINGISE_ENUM_CLASS_NAMED(IncompatibleProcess, "Process is incompatible"); + STRINGISE_ENUM_CLASS_NAMED(NetworkIOFailed, "Network I/O operation failed"); + STRINGISE_ENUM_CLASS_NAMED(NetworkRemoteBusy, "Remote side of network connection is busy"); + STRINGISE_ENUM_CLASS_NAMED(NetworkVersionMismatch, "Version mismatch between network clients"); + STRINGISE_ENUM_CLASS_NAMED(FileIOFailed, "File I/O failed"); + STRINGISE_ENUM_CLASS_NAMED(FileIncompatibleVersion, "File of incompatible version"); + STRINGISE_ENUM_CLASS_NAMED(FileCorrupted, "File corrupted"); + STRINGISE_ENUM_CLASS_NAMED(APIUnsupported, "API unsupported"); + STRINGISE_ENUM_CLASS_NAMED(APIInitFailed, "API initialisation failed"); + STRINGISE_ENUM_CLASS_NAMED(APIIncompatibleVersion, "API incompatible version"); + STRINGISE_ENUM_CLASS_NAMED(APIHardwareUnsupported, "API hardware unsupported"); + } + END_ENUM_STRINGISE(); +} + +template <> +std::string DoStringise(const ResourceFormatType &el) +{ + BEGIN_ENUM_STRINGISE(ResourceFormatType) + { + STRINGISE_ENUM_CLASS(Regular); + STRINGISE_ENUM_CLASS(Undefined); + STRINGISE_ENUM_CLASS(BC1); + STRINGISE_ENUM_CLASS(BC2); + STRINGISE_ENUM_CLASS(BC3); + STRINGISE_ENUM_CLASS(BC4); + STRINGISE_ENUM_CLASS(BC5); + STRINGISE_ENUM_CLASS(BC6); + STRINGISE_ENUM_CLASS(BC7); + STRINGISE_ENUM_CLASS(ETC2); + STRINGISE_ENUM_CLASS(EAC); + STRINGISE_ENUM_CLASS(ASTC); + STRINGISE_ENUM_CLASS(R10G10B10A2); + STRINGISE_ENUM_CLASS(R11G11B10); + STRINGISE_ENUM_CLASS(R5G6B5); + STRINGISE_ENUM_CLASS(R5G5B5A1); + STRINGISE_ENUM_CLASS(R9G9B9E5); + STRINGISE_ENUM_CLASS(R4G4B4A4); + STRINGISE_ENUM_CLASS(R4G4); + STRINGISE_ENUM_CLASS(D16S8); + STRINGISE_ENUM_CLASS(D24S8); + STRINGISE_ENUM_CLASS(D32S8); + STRINGISE_ENUM_CLASS(S8); + STRINGISE_ENUM_CLASS(YUV); + } + END_ENUM_STRINGISE(); +} + +template <> +std::string DoStringise(const CompType &el) +{ + BEGIN_ENUM_STRINGISE(CompType) + { + STRINGISE_ENUM_CLASS(Typeless); + STRINGISE_ENUM_CLASS(Float); + STRINGISE_ENUM_CLASS(UNorm); + STRINGISE_ENUM_CLASS(SNorm); + STRINGISE_ENUM_CLASS(UInt); + STRINGISE_ENUM_CLASS(SInt); + STRINGISE_ENUM_CLASS(UScaled); + STRINGISE_ENUM_CLASS(SScaled); + STRINGISE_ENUM_CLASS_NAMED(Depth, "Depth/Stencil"); + STRINGISE_ENUM_CLASS(Double); + } + END_ENUM_STRINGISE(); +} + +template <> +std::string DoStringise(const FileType &el) +{ + BEGIN_ENUM_STRINGISE(FileType) + { + STRINGISE_ENUM_CLASS(DDS); + STRINGISE_ENUM_CLASS(PNG); + STRINGISE_ENUM_CLASS(JPG); + STRINGISE_ENUM_CLASS(BMP); + STRINGISE_ENUM_CLASS(TGA); + STRINGISE_ENUM_CLASS(HDR); + STRINGISE_ENUM_CLASS(EXR); + } + END_ENUM_STRINGISE(); +} + +template <> +std::string DoStringise(const AlphaMapping &el) +{ + BEGIN_ENUM_STRINGISE(AlphaMapping) + { + STRINGISE_ENUM_CLASS_NAMED(Discard, "Discard"); + STRINGISE_ENUM_CLASS_NAMED(BlendToColor, "Blend to Color"); + STRINGISE_ENUM_CLASS_NAMED(BlendToCheckerboard, "Blend to Checkerboard"); + STRINGISE_ENUM_CLASS_NAMED(Preserve, "Preserve"); + } + END_ENUM_STRINGISE(); +} + +template <> +std::string DoStringise(const EnvMod &el) +{ + BEGIN_ENUM_STRINGISE(EnvMod) + { + STRINGISE_ENUM_CLASS(Set); + STRINGISE_ENUM_CLASS(Append); + STRINGISE_ENUM_CLASS(Prepend); + } + END_ENUM_STRINGISE(); +} + +template <> +std::string DoStringise(const EnvSep &el) +{ + BEGIN_ENUM_STRINGISE(EnvSep) + { + STRINGISE_ENUM_CLASS_NAMED(Platform, "Platform style"); + STRINGISE_ENUM_CLASS_NAMED(SemiColon, "Semi-colon (;)"); + STRINGISE_ENUM_CLASS_NAMED(Colon, "Colon (:)"); + STRINGISE_ENUM_CLASS_NAMED(NoSep, "No Separator"); + } + END_ENUM_STRINGISE(); +} + +template <> +std::string DoStringise(const Topology &el) +{ + BEGIN_ENUM_STRINGISE(Topology) + { + STRINGISE_ENUM_CLASS_NAMED(Unknown, "Unknown"); + STRINGISE_ENUM_CLASS_NAMED(PointList, "Point List"); + STRINGISE_ENUM_CLASS_NAMED(LineList, "Line List"); + STRINGISE_ENUM_CLASS_NAMED(LineStrip, "Line Strip"); + STRINGISE_ENUM_CLASS_NAMED(LineLoop, "Line Loop"); + STRINGISE_ENUM_CLASS_NAMED(TriangleList, "Triangle List"); + STRINGISE_ENUM_CLASS_NAMED(TriangleStrip, "Triangle Strip"); + STRINGISE_ENUM_CLASS_NAMED(TriangleFan, "Triangle Fan"); + STRINGISE_ENUM_CLASS_NAMED(LineList_Adj, "Line List with Adjacency"); + STRINGISE_ENUM_CLASS_NAMED(LineStrip_Adj, "Line Strip with Adjacency"); + STRINGISE_ENUM_CLASS_NAMED(TriangleList_Adj, "Triangle List with Adjacency"); + STRINGISE_ENUM_CLASS_NAMED(TriangleStrip_Adj, "Triangle Strip with Adjacency"); + STRINGISE_ENUM_CLASS_NAMED(PatchList_1CPs, "Patch List 1 CP"); + STRINGISE_ENUM_CLASS_NAMED(PatchList_2CPs, "Patch List 2 CPs"); + STRINGISE_ENUM_CLASS_NAMED(PatchList_3CPs, "Patch List 3 CPs"); + STRINGISE_ENUM_CLASS_NAMED(PatchList_4CPs, "Patch List 4 CPs"); + STRINGISE_ENUM_CLASS_NAMED(PatchList_5CPs, "Patch List 5 CPs"); + STRINGISE_ENUM_CLASS_NAMED(PatchList_6CPs, "Patch List 6 CPs"); + STRINGISE_ENUM_CLASS_NAMED(PatchList_7CPs, "Patch List 7 CPs"); + STRINGISE_ENUM_CLASS_NAMED(PatchList_8CPs, "Patch List 8 CPs"); + STRINGISE_ENUM_CLASS_NAMED(PatchList_9CPs, "Patch List 9 CPs"); + STRINGISE_ENUM_CLASS_NAMED(PatchList_10CPs, "Patch List 10 CPs"); + STRINGISE_ENUM_CLASS_NAMED(PatchList_11CPs, "Patch List 11 CPs"); + STRINGISE_ENUM_CLASS_NAMED(PatchList_12CPs, "Patch List 12 CPs"); + STRINGISE_ENUM_CLASS_NAMED(PatchList_13CPs, "Patch List 13 CPs"); + STRINGISE_ENUM_CLASS_NAMED(PatchList_14CPs, "Patch List 14 CPs"); + STRINGISE_ENUM_CLASS_NAMED(PatchList_15CPs, "Patch List 15 CPs"); + STRINGISE_ENUM_CLASS_NAMED(PatchList_16CPs, "Patch List 16 CPs"); + STRINGISE_ENUM_CLASS_NAMED(PatchList_17CPs, "Patch List 17 CPs"); + STRINGISE_ENUM_CLASS_NAMED(PatchList_18CPs, "Patch List 18 CPs"); + STRINGISE_ENUM_CLASS_NAMED(PatchList_19CPs, "Patch List 19 CPs"); + STRINGISE_ENUM_CLASS_NAMED(PatchList_20CPs, "Patch List 20 CPs"); + STRINGISE_ENUM_CLASS_NAMED(PatchList_21CPs, "Patch List 21 CPs"); + STRINGISE_ENUM_CLASS_NAMED(PatchList_22CPs, "Patch List 22 CPs"); + STRINGISE_ENUM_CLASS_NAMED(PatchList_23CPs, "Patch List 23 CPs"); + STRINGISE_ENUM_CLASS_NAMED(PatchList_24CPs, "Patch List 24 CPs"); + STRINGISE_ENUM_CLASS_NAMED(PatchList_25CPs, "Patch List 25 CPs"); + STRINGISE_ENUM_CLASS_NAMED(PatchList_26CPs, "Patch List 26 CPs"); + STRINGISE_ENUM_CLASS_NAMED(PatchList_27CPs, "Patch List 27 CPs"); + STRINGISE_ENUM_CLASS_NAMED(PatchList_28CPs, "Patch List 28 CPs"); + STRINGISE_ENUM_CLASS_NAMED(PatchList_29CPs, "Patch List 29 CPs"); + STRINGISE_ENUM_CLASS_NAMED(PatchList_30CPs, "Patch List 30 CPs"); + STRINGISE_ENUM_CLASS_NAMED(PatchList_31CPs, "Patch List 31 CPs"); + } + END_ENUM_STRINGISE(); +} + +template <> +std::string DoStringise(const FillMode &el) +{ + BEGIN_ENUM_STRINGISE(FillMode) + { + STRINGISE_ENUM_CLASS(Solid); + STRINGISE_ENUM_CLASS(Wireframe); + STRINGISE_ENUM_CLASS(Point); + } + END_ENUM_STRINGISE(); +} + +template <> +std::string DoStringise(const CullMode &el) +{ + BEGIN_ENUM_STRINGISE(CullMode) + { + STRINGISE_ENUM_CLASS_NAMED(NoCull, "None"); + STRINGISE_ENUM_CLASS_NAMED(Front, "Front"); + STRINGISE_ENUM_CLASS_NAMED(Back, "Back"); + STRINGISE_ENUM_CLASS_NAMED(FrontAndBack, "Front & Back"); + } + END_ENUM_STRINGISE(); +} + +template <> +std::string DoStringise(const FilterMode &el) +{ + BEGIN_ENUM_STRINGISE(FilterMode) + { + STRINGISE_ENUM_CLASS_NAMED(NoFilter, "None"); + STRINGISE_ENUM_CLASS_NAMED(Point, "Point"); + STRINGISE_ENUM_CLASS_NAMED(Linear, "Linear"); + STRINGISE_ENUM_CLASS_NAMED(Cubic, "Cubic"); + STRINGISE_ENUM_CLASS_NAMED(Anisotropic, "Anisotropic"); + } + END_ENUM_STRINGISE(); +} + +template <> +std::string DoStringise(const FilterFunc &el) +{ + BEGIN_ENUM_STRINGISE(FilterFunc) + { + STRINGISE_ENUM_CLASS(Normal); + STRINGISE_ENUM_CLASS(Comparison); + STRINGISE_ENUM_CLASS(Minimum); + STRINGISE_ENUM_CLASS(Maximum); + } + END_ENUM_STRINGISE(); +} + +template <> +std::string DoStringise(const CompareFunc &el) +{ + BEGIN_ENUM_STRINGISE(CompareFunc) + { + STRINGISE_ENUM_CLASS_NAMED(Never, "Never"); + STRINGISE_ENUM_CLASS_NAMED(AlwaysTrue, "Always"); + STRINGISE_ENUM_CLASS_NAMED(Less, "Less"); + STRINGISE_ENUM_CLASS_NAMED(LessEqual, "Less Equal"); + STRINGISE_ENUM_CLASS_NAMED(Greater, "Greater"); + STRINGISE_ENUM_CLASS_NAMED(GreaterEqual, "Greater Equal"); + STRINGISE_ENUM_CLASS_NAMED(Equal, "Equal"); + STRINGISE_ENUM_CLASS_NAMED(NotEqual, "NotEqual"); + } + END_ENUM_STRINGISE(); +} + +template <> +std::string DoStringise(const BlendMultiplier &el) +{ + BEGIN_ENUM_STRINGISE(BlendMultiplier) + { + STRINGISE_ENUM_CLASS_NAMED(Zero, "Zero"); + STRINGISE_ENUM_CLASS_NAMED(One, "One"); + STRINGISE_ENUM_CLASS_NAMED(SrcCol, "Src Col"); + STRINGISE_ENUM_CLASS_NAMED(InvSrcCol, "1 - Src Col"); + STRINGISE_ENUM_CLASS_NAMED(DstCol, "Dst Col"); + STRINGISE_ENUM_CLASS_NAMED(InvDstCol, "1 - Dst Col"); + STRINGISE_ENUM_CLASS_NAMED(SrcAlpha, "Src Alpha"); + STRINGISE_ENUM_CLASS_NAMED(InvSrcAlpha, "1 - Src Alpha"); + STRINGISE_ENUM_CLASS_NAMED(DstAlpha, "Dst Alpha"); + STRINGISE_ENUM_CLASS_NAMED(InvDstAlpha, "1 - Dst Alpha"); + STRINGISE_ENUM_CLASS_NAMED(SrcAlphaSat, "Src Alpha Sat"); + STRINGISE_ENUM_CLASS_NAMED(FactorRGB, "Constant RGB"); + STRINGISE_ENUM_CLASS_NAMED(InvFactorRGB, "1 - Constant RGB"); + STRINGISE_ENUM_CLASS_NAMED(FactorAlpha, "Constant A"); + STRINGISE_ENUM_CLASS_NAMED(InvFactorAlpha, "1 - Constant A"); + STRINGISE_ENUM_CLASS_NAMED(Src1Col, "Src1 Col"); + STRINGISE_ENUM_CLASS_NAMED(InvSrc1Col, "1 - Src1 Col"); + STRINGISE_ENUM_CLASS_NAMED(Src1Alpha, "Src1 Alpha"); + STRINGISE_ENUM_CLASS_NAMED(InvSrc1Alpha, "1 - Src1 Alpha"); + } + END_ENUM_STRINGISE(); +} + +template <> +std::string DoStringise(const BlendOp &el) +{ + BEGIN_ENUM_STRINGISE(BlendOp) + { + STRINGISE_ENUM_CLASS_NAMED(Add, "Add"); + STRINGISE_ENUM_CLASS_NAMED(Subtract, "Subtract"); + STRINGISE_ENUM_CLASS_NAMED(ReversedSubtract, "Rev. Subtract"); + STRINGISE_ENUM_CLASS_NAMED(Minimum, "Minimum"); + STRINGISE_ENUM_CLASS_NAMED(Maximum, "Maximum"); + } + END_ENUM_STRINGISE(); +} + +template <> +std::string DoStringise(const StencilOp &el) +{ + BEGIN_ENUM_STRINGISE(StencilOp) + { + STRINGISE_ENUM_CLASS_NAMED(Keep, "Keep"); + STRINGISE_ENUM_CLASS_NAMED(Zero, "Zero"); + STRINGISE_ENUM_CLASS_NAMED(Replace, "Replace"); + STRINGISE_ENUM_CLASS_NAMED(IncSat, "Inc Sat"); + STRINGISE_ENUM_CLASS_NAMED(DecSat, "Dec Sat"); + STRINGISE_ENUM_CLASS_NAMED(IncWrap, "Inc Wrap"); + STRINGISE_ENUM_CLASS_NAMED(DecWrap, "Dec Wrap"); + STRINGISE_ENUM_CLASS_NAMED(Invert, "Invert"); + } + END_ENUM_STRINGISE(); +} + +template <> +std::string DoStringise(const LogicOp &el) +{ + BEGIN_ENUM_STRINGISE(LogicOp) + { + STRINGISE_ENUM_CLASS_NAMED(NoOp, "No-Op"); + STRINGISE_ENUM_CLASS_NAMED(Clear, "Clear"); + STRINGISE_ENUM_CLASS_NAMED(Set, "Set"); + STRINGISE_ENUM_CLASS_NAMED(Copy, "Copy"); + STRINGISE_ENUM_CLASS_NAMED(CopyInverted, "Copy Inverted"); + STRINGISE_ENUM_CLASS_NAMED(Invert, "Invert"); + STRINGISE_ENUM_CLASS_NAMED(And, "And"); + STRINGISE_ENUM_CLASS_NAMED(Nand, "Nand"); + STRINGISE_ENUM_CLASS_NAMED(Or, "Or"); + STRINGISE_ENUM_CLASS_NAMED(Xor, "Xor"); + STRINGISE_ENUM_CLASS_NAMED(Nor, "Nor"); + STRINGISE_ENUM_CLASS_NAMED(Equivalent, "Equivalent"); + STRINGISE_ENUM_CLASS_NAMED(AndReverse, "And Reverse"); + STRINGISE_ENUM_CLASS_NAMED(AndInverted, "And Inverted"); + STRINGISE_ENUM_CLASS_NAMED(OrReverse, "Or Reverse"); + STRINGISE_ENUM_CLASS_NAMED(OrInverted, "Or Inverted"); + } + END_ENUM_STRINGISE(); +} + +template <> +std::string DoStringise(const QualityHint &el) +{ + BEGIN_ENUM_STRINGISE(QualityHint) + { + STRINGISE_ENUM_CLASS_NAMED(DontCare, "Don't Care"); + STRINGISE_ENUM_CLASS_NAMED(Nicest, "Nicest"); + STRINGISE_ENUM_CLASS_NAMED(Fastest, "Fastest"); + } + END_ENUM_STRINGISE(); +} + +template <> +std::string DoStringise(const TextureFilter &el) +{ + std::string filter = ""; + std::string filtPrefix = ""; + std::string filtVal = ""; + + std::string filters[] = {ToStr(el.minify), ToStr(el.magnify), ToStr(el.mip)}; + std::string filterPrefixes[] = {"Min", "Mag", "Mip"}; + + for(int a = 0; a < 3; a++) + { + if(a == 0 || filters[a] == filters[a - 1]) + { + if(filtPrefix != "") + filtPrefix += "/"; + filtPrefix += filterPrefixes[a]; + } + else + { + filter += filtPrefix + ": " + filtVal + ", "; + + filtPrefix = filterPrefixes[a]; + } + filtVal = filters[a]; + } + + filter += filtPrefix + ": " + filtVal; + + return filter; +} + +template <> +std::string DoStringise(const AddressMode &el) +{ + BEGIN_ENUM_STRINGISE(AddressMode); + { + STRINGISE_ENUM_CLASS(Wrap); + STRINGISE_ENUM_CLASS(Mirror); + STRINGISE_ENUM_CLASS(MirrorOnce); + STRINGISE_ENUM_CLASS(ClampEdge); + STRINGISE_ENUM_CLASS(ClampBorder); + } + END_ENUM_STRINGISE(); +} + +template <> +std::string DoStringise(const TextureDim &el) +{ + BEGIN_ENUM_STRINGISE(TextureDim) + { + STRINGISE_ENUM_CLASS_NAMED(Unknown, "Unknown"); + STRINGISE_ENUM_CLASS_NAMED(Buffer, "Buffer"); + STRINGISE_ENUM_CLASS_NAMED(Texture1D, "Texture 1D"); + STRINGISE_ENUM_CLASS_NAMED(Texture1DArray, "Texture 1D Array"); + STRINGISE_ENUM_CLASS_NAMED(Texture2D, "Texture 2D"); + STRINGISE_ENUM_CLASS_NAMED(TextureRect, "Texture Rect"); + STRINGISE_ENUM_CLASS_NAMED(Texture2DArray, "Texture 2D Array"); + STRINGISE_ENUM_CLASS_NAMED(Texture2DMS, "Texture 2D MS"); + STRINGISE_ENUM_CLASS_NAMED(Texture2DMSArray, "Texture 2D MS Array"); + STRINGISE_ENUM_CLASS_NAMED(Texture3D, "Texture 3D"); + STRINGISE_ENUM_CLASS_NAMED(TextureCube, "Texture Cube"); + STRINGISE_ENUM_CLASS_NAMED(TextureCubeArray, "Texture Cube Array"); + } + END_ENUM_STRINGISE(); +} + +template <> +std::string DoStringise(const ShaderBuiltin &el) +{ + BEGIN_ENUM_STRINGISE(ShaderBuiltin) + { + STRINGISE_ENUM_CLASS_NAMED(Undefined, "Undefined"); + STRINGISE_ENUM_CLASS_NAMED(Position, "Position"); + STRINGISE_ENUM_CLASS_NAMED(PointSize, "Point Size"); + STRINGISE_ENUM_CLASS_NAMED(ClipDistance, "Clip Distance"); + STRINGISE_ENUM_CLASS_NAMED(CullDistance, "Cull Distance"); + STRINGISE_ENUM_CLASS_NAMED(RTIndex, "RT Index"); + STRINGISE_ENUM_CLASS_NAMED(ViewportIndex, "Viewport Index"); + STRINGISE_ENUM_CLASS_NAMED(VertexIndex, "Vertex Index"); + STRINGISE_ENUM_CLASS_NAMED(PrimitiveIndex, "Primitive Index"); + STRINGISE_ENUM_CLASS_NAMED(InstanceIndex, "Instance Index"); + STRINGISE_ENUM_CLASS_NAMED(DispatchSize, "Dispatch Size"); + STRINGISE_ENUM_CLASS_NAMED(DispatchThreadIndex, "Dispatch Thread Index"); + STRINGISE_ENUM_CLASS_NAMED(GroupIndex, "Group Index"); + STRINGISE_ENUM_CLASS_NAMED(GroupFlatIndex, "Group Flat Index"); + STRINGISE_ENUM_CLASS_NAMED(GroupThreadIndex, "Group Thread Index"); + STRINGISE_ENUM_CLASS_NAMED(GSInstanceIndex, "GS Instance Index"); + STRINGISE_ENUM_CLASS_NAMED(OutputControlPointIndex, "Output Control Point Index"); + STRINGISE_ENUM_CLASS_NAMED(DomainLocation, "Domain Location"); + STRINGISE_ENUM_CLASS_NAMED(IsFrontFace, "Is FrontFace"); + STRINGISE_ENUM_CLASS_NAMED(MSAACoverage, "MSAA Coverage"); + STRINGISE_ENUM_CLASS_NAMED(MSAASamplePosition, "MSAA Sample Position"); + STRINGISE_ENUM_CLASS_NAMED(MSAASampleIndex, "MSAA Sample Index"); + STRINGISE_ENUM_CLASS_NAMED(PatchNumVertices, "Patch NumVertices"); + STRINGISE_ENUM_CLASS_NAMED(OuterTessFactor, "Outer TessFactor"); + STRINGISE_ENUM_CLASS_NAMED(InsideTessFactor, "Inside TessFactor"); + STRINGISE_ENUM_CLASS_NAMED(ColorOutput, "Color Output"); + STRINGISE_ENUM_CLASS_NAMED(DepthOutput, "Depth Output"); + STRINGISE_ENUM_CLASS_NAMED(DepthOutputGreaterEqual, "Depth Output (GEqual)"); + STRINGISE_ENUM_CLASS_NAMED(DepthOutputLessEqual, "Depth Output (LEqual)"); + } + END_ENUM_STRINGISE(); +} + +template <> +std::string DoStringise(const BindType &el) +{ + BEGIN_ENUM_STRINGISE(BindType) + { + STRINGISE_ENUM_CLASS_NAMED(ConstantBuffer, "Constants"); + STRINGISE_ENUM_CLASS_NAMED(Sampler, "Sampler"); + STRINGISE_ENUM_CLASS_NAMED(ImageSampler, "Image&Sampler"); + STRINGISE_ENUM_CLASS_NAMED(ReadOnlyImage, "Image"); + STRINGISE_ENUM_CLASS_NAMED(ReadWriteImage, "RW Image"); + STRINGISE_ENUM_CLASS_NAMED(ReadOnlyTBuffer, "TexBuffer"); + STRINGISE_ENUM_CLASS_NAMED(ReadWriteTBuffer, "RW TexBuffer"); + STRINGISE_ENUM_CLASS_NAMED(ReadOnlyBuffer, "Buffer"); + STRINGISE_ENUM_CLASS_NAMED(ReadWriteBuffer, "RW Buffer"); + STRINGISE_ENUM_CLASS_NAMED(InputAttachment, "Input"); + } + END_ENUM_STRINGISE(); +} + +template <> +std::string DoStringise(const MessageSource &el) +{ + BEGIN_ENUM_STRINGISE(MessageSource) + { + STRINGISE_ENUM_CLASS_NAMED(API, "API"); + STRINGISE_ENUM_CLASS_NAMED(RedundantAPIUse, "Redundant API Use"); + STRINGISE_ENUM_CLASS_NAMED(IncorrectAPIUse, "Incorrect API Use"); + STRINGISE_ENUM_CLASS_NAMED(GeneralPerformance, "General Performance"); + STRINGISE_ENUM_CLASS_NAMED(GCNPerformance, "GCN Performance"); + STRINGISE_ENUM_CLASS_NAMED(RuntimeWarning, "Runtime Warning"); + STRINGISE_ENUM_CLASS_NAMED(UnsupportedConfiguration, "Unsupported Configuration"); + } + END_ENUM_STRINGISE(); +} + +template <> +std::string DoStringise(const MessageSeverity &el) +{ + BEGIN_ENUM_STRINGISE(MessageSeverity) + { + STRINGISE_ENUM_CLASS(High); + STRINGISE_ENUM_CLASS(Medium); + STRINGISE_ENUM_CLASS(Low); + STRINGISE_ENUM_CLASS(Info); + } + END_ENUM_STRINGISE(); +} + +template <> +std::string DoStringise(const MessageCategory &el) +{ + BEGIN_ENUM_STRINGISE(MessageCategory) + { + STRINGISE_ENUM_CLASS_NAMED(Application_Defined, "Application Defined"); + STRINGISE_ENUM_CLASS_NAMED(Miscellaneous, "Miscellaneous"); + STRINGISE_ENUM_CLASS_NAMED(Initialization, "Initialization"); + STRINGISE_ENUM_CLASS_NAMED(Cleanup, "Cleanup"); + STRINGISE_ENUM_CLASS_NAMED(Compilation, "Compilation"); + STRINGISE_ENUM_CLASS_NAMED(State_Creation, "State Creation"); + STRINGISE_ENUM_CLASS_NAMED(State_Setting, "State Setting"); + STRINGISE_ENUM_CLASS_NAMED(State_Getting, "State Getting"); + STRINGISE_ENUM_CLASS_NAMED(Resource_Manipulation, "Resource Manipulation"); + STRINGISE_ENUM_CLASS_NAMED(Execution, "Execution"); + STRINGISE_ENUM_CLASS_NAMED(Shaders, "Shaders"); + STRINGISE_ENUM_CLASS_NAMED(Deprecated, "Deprecated"); + STRINGISE_ENUM_CLASS_NAMED(Undefined, "Undefined"); + STRINGISE_ENUM_CLASS_NAMED(Portability, "Portability"); + STRINGISE_ENUM_CLASS_NAMED(Performance, "Performance"); + } + END_ENUM_STRINGISE(); +} + +template <> +std::string DoStringise(const TextureSwizzle &el) +{ + BEGIN_ENUM_STRINGISE(TextureSwizzle) + { + STRINGISE_ENUM_CLASS_NAMED(Red, "R"); + STRINGISE_ENUM_CLASS_NAMED(Green, "G"); + STRINGISE_ENUM_CLASS_NAMED(Blue, "B"); + STRINGISE_ENUM_CLASS_NAMED(Alpha, "A"); + STRINGISE_ENUM_CLASS_NAMED(Zero, "0"); + STRINGISE_ENUM_CLASS_NAMED(One, "1"); + } + END_ENUM_STRINGISE(); +} + +template <> +std::string DoStringise(const ResourceUsage &el) +{ + BEGIN_ENUM_STRINGISE(ResourceUsage) + { + STRINGISE_ENUM_CLASS_NAMED(Unused, "Unused"); + + STRINGISE_ENUM_CLASS_NAMED(VertexBuffer, "Vertex Buffer"); + STRINGISE_ENUM_CLASS_NAMED(IndexBuffer, "Index Buffer"); + + STRINGISE_ENUM_CLASS_NAMED(VS_Constants, "VS - Constants"); + STRINGISE_ENUM_CLASS_NAMED(HS_Constants, "HS - Constants"); + STRINGISE_ENUM_CLASS_NAMED(DS_Constants, "DS - Constants"); + STRINGISE_ENUM_CLASS_NAMED(GS_Constants, "GS - Constants"); + STRINGISE_ENUM_CLASS_NAMED(PS_Constants, "PS - Constants"); + STRINGISE_ENUM_CLASS_NAMED(CS_Constants, "CS - Constants"); + + STRINGISE_ENUM_CLASS_NAMED(All_Constants, "All Stages - Constants"); + + STRINGISE_ENUM_CLASS_NAMED(StreamOut, "Stream-Out"); + + STRINGISE_ENUM_CLASS_NAMED(VS_Resource, "VS - Read-only Resource"); + STRINGISE_ENUM_CLASS_NAMED(HS_Resource, "HS - Read-only Resource"); + STRINGISE_ENUM_CLASS_NAMED(DS_Resource, "DS - Read-only Resource"); + STRINGISE_ENUM_CLASS_NAMED(GS_Resource, "GS - Read-only Resource"); + STRINGISE_ENUM_CLASS_NAMED(PS_Resource, "PS - Read-only Resource"); + STRINGISE_ENUM_CLASS_NAMED(CS_Resource, "CS - Read-only Resource"); + + STRINGISE_ENUM_CLASS_NAMED(All_Resource, "All Stages - Read-only Resource"); + + STRINGISE_ENUM_CLASS_NAMED(VS_RWResource, "VS - Read-write Resource"); + STRINGISE_ENUM_CLASS_NAMED(HS_RWResource, "HS - Read-write Resource"); + STRINGISE_ENUM_CLASS_NAMED(DS_RWResource, "DS - Read-write Resource"); + STRINGISE_ENUM_CLASS_NAMED(GS_RWResource, "GS - Read-write Resource"); + STRINGISE_ENUM_CLASS_NAMED(PS_RWResource, "PS - Read-write Resource"); + STRINGISE_ENUM_CLASS_NAMED(CS_RWResource, "CS - Read-write Resource"); + + STRINGISE_ENUM_CLASS_NAMED(All_RWResource, "All Stages - Read-write Resource"); + + STRINGISE_ENUM_CLASS_NAMED(InputTarget, "Input target"); + STRINGISE_ENUM_CLASS_NAMED(ColorTarget, "Color target"); + STRINGISE_ENUM_CLASS_NAMED(DepthStencilTarget, "Depth/stencil target"); + + STRINGISE_ENUM_CLASS_NAMED(Indirect, "Indirect parameters"); + + STRINGISE_ENUM_CLASS_NAMED(Clear, "Clear"); + + STRINGISE_ENUM_CLASS_NAMED(GenMips, "Mip Generation"); + STRINGISE_ENUM_CLASS_NAMED(Resolve, "Resolve - Source&Dest"); + STRINGISE_ENUM_CLASS_NAMED(ResolveSrc, "Resolve - Source"); + STRINGISE_ENUM_CLASS_NAMED(ResolveDst, "Resolve - Destination"); + STRINGISE_ENUM_CLASS_NAMED(Copy, "Copy - Source&Dest"); + STRINGISE_ENUM_CLASS_NAMED(CopySrc, "Copy - Source"); + STRINGISE_ENUM_CLASS_NAMED(CopyDst, "Copy - Destination"); + + STRINGISE_ENUM_CLASS_NAMED(Barrier, "Barrier"); + } + END_ENUM_STRINGISE(); +} + +template <> +std::string DoStringise(const VarType &el) +{ + BEGIN_ENUM_STRINGISE(VarType) + { + STRINGISE_ENUM_CLASS_NAMED(Float, "float"); + STRINGISE_ENUM_CLASS_NAMED(Int, "int"); + STRINGISE_ENUM_CLASS_NAMED(UInt, "uint"); + STRINGISE_ENUM_CLASS_NAMED(Double, "double"); + STRINGISE_ENUM_CLASS_NAMED(Unknown, "unknown"); + } + END_ENUM_STRINGISE(); +} + +template <> +std::string DoStringise(const GPUCounter &el) +{ + if(IsAMDCounter(el)) + return "AMD Counter " + ToStr((uint32_t)el); + + if(IsNvidiaCounter(el)) + return "Nvidia Counter " + ToStr((uint32_t)el); + + if(IsIntelCounter(el)) + return "Intel Counter " + ToStr((uint32_t)el); + + BEGIN_ENUM_STRINGISE(GPUCounter) + { + STRINGISE_ENUM_CLASS(EventGPUDuration); + STRINGISE_ENUM_CLASS(InputVerticesRead); + STRINGISE_ENUM_CLASS(IAPrimitives); + STRINGISE_ENUM_CLASS(GSPrimitives); + STRINGISE_ENUM_CLASS(RasterizerInvocations); + STRINGISE_ENUM_CLASS(RasterizedPrimitives); + STRINGISE_ENUM_CLASS(SamplesWritten); + STRINGISE_ENUM_CLASS(VSInvocations); + STRINGISE_ENUM_CLASS(HSInvocations); + STRINGISE_ENUM_CLASS(DSInvocations); + STRINGISE_ENUM_CLASS(GSInvocations); + STRINGISE_ENUM_CLASS(PSInvocations); + STRINGISE_ENUM_CLASS(CSInvocations); + } + END_ENUM_STRINGISE(); +} + +template <> +std::string DoStringise(const CounterUnit &el) +{ + BEGIN_ENUM_STRINGISE(CounterUnit) + { + STRINGISE_ENUM_CLASS(Absolute); + STRINGISE_ENUM_CLASS(Seconds); + STRINGISE_ENUM_CLASS(Percentage); + STRINGISE_ENUM_CLASS(Ratio); + STRINGISE_ENUM_CLASS(Bytes); + STRINGISE_ENUM_CLASS(Cycles); + } + END_ENUM_STRINGISE(); +} + +template <> +std::string DoStringise(const ShaderStage &el) +{ + BEGIN_ENUM_STRINGISE(ShaderStage) + { + STRINGISE_ENUM_CLASS(Vertex); + STRINGISE_ENUM_CLASS(Hull); + STRINGISE_ENUM_CLASS(Domain); + STRINGISE_ENUM_CLASS(Geometry); + STRINGISE_ENUM_CLASS(Pixel); + STRINGISE_ENUM_CLASS(Compute); + } + END_ENUM_STRINGISE(); +} + +template <> +std::string DoStringise(const MeshDataStage &el) +{ + BEGIN_ENUM_STRINGISE(MeshDataStage) + { + STRINGISE_ENUM_CLASS(Unknown); + STRINGISE_ENUM_CLASS(VSIn); + STRINGISE_ENUM_CLASS(VSOut); + STRINGISE_ENUM_CLASS(GSOut); + } + END_ENUM_STRINGISE(); +} + +template <> +std::string DoStringise(const DebugOverlay &el) +{ + BEGIN_ENUM_STRINGISE(DebugOverlay) + { + STRINGISE_ENUM_CLASS(NoOverlay); + STRINGISE_ENUM_CLASS(Drawcall); + STRINGISE_ENUM_CLASS(Wireframe); + STRINGISE_ENUM_CLASS(Depth); + STRINGISE_ENUM_CLASS(Stencil); + STRINGISE_ENUM_CLASS(BackfaceCull); + STRINGISE_ENUM_CLASS(ViewportScissor); + STRINGISE_ENUM_CLASS(NaN); + STRINGISE_ENUM_CLASS(Clipping); + STRINGISE_ENUM_CLASS(ClearBeforePass); + STRINGISE_ENUM_CLASS(ClearBeforeDraw); + STRINGISE_ENUM_CLASS(QuadOverdrawPass); + STRINGISE_ENUM_CLASS(QuadOverdrawDraw); + STRINGISE_ENUM_CLASS(TriangleSizePass); + STRINGISE_ENUM_CLASS(TriangleSizeDraw); + } + END_ENUM_STRINGISE(); +} + +template <> +std::string DoStringise(const GraphicsAPI &el) +{ + BEGIN_ENUM_STRINGISE(GraphicsAPI) + { + STRINGISE_ENUM_CLASS(D3D11); + STRINGISE_ENUM_CLASS(D3D12); + STRINGISE_ENUM_CLASS(OpenGL); + STRINGISE_ENUM_CLASS(Vulkan); + } + END_ENUM_STRINGISE(); +} + +template <> +std::string DoStringise(const D3DBufferViewFlags &el) +{ + BEGIN_BITFIELD_STRINGISE(D3DBufferViewFlags); + { + STRINGISE_BITFIELD_CLASS_VALUE_NAMED(NoFlags, ""); + + STRINGISE_BITFIELD_CLASS_BIT(Raw); + STRINGISE_BITFIELD_CLASS_BIT(Append); + STRINGISE_BITFIELD_CLASS_BIT(Counter); + } + END_BITFIELD_STRINGISE(); +} + +template <> +std::string DoStringise(const PathProperty &el) +{ + BEGIN_BITFIELD_STRINGISE(PathProperty); + { + STRINGISE_BITFIELD_CLASS_VALUE_NAMED(ErrorUnknown, "Unknown Error"); + STRINGISE_BITFIELD_CLASS_VALUE_NAMED(ErrorAccessDenied, "Access Denied"); + STRINGISE_BITFIELD_CLASS_VALUE_NAMED(ErrorInvalidPath, "Invalid Path"); + STRINGISE_BITFIELD_CLASS_VALUE_NAMED(NoFlags, "No Flags"); + + STRINGISE_BITFIELD_CLASS_BIT(Directory); + STRINGISE_BITFIELD_CLASS_BIT(Hidden); + STRINGISE_BITFIELD_CLASS_BIT(Executable); + } + END_BITFIELD_STRINGISE(); +} + +template <> +std::string DoStringise(const ShaderEvents &el) +{ + BEGIN_BITFIELD_STRINGISE(ShaderEvents); + { + STRINGISE_BITFIELD_CLASS_VALUE_NAMED(NoEvent, "None"); + + STRINGISE_BITFIELD_CLASS_BIT(SampleLoadGather); + STRINGISE_BITFIELD_CLASS_BIT(GeneratedNanOrInf); + } + END_BITFIELD_STRINGISE(); +} + +template <> +std::string DoStringise(const TextureCategory &el) +{ + BEGIN_BITFIELD_STRINGISE(TextureCategory); + { + STRINGISE_BITFIELD_CLASS_VALUE_NAMED(NoFlags, "None"); + + STRINGISE_BITFIELD_CLASS_BIT(ShaderRead); + STRINGISE_BITFIELD_CLASS_BIT(ColorTarget); + STRINGISE_BITFIELD_CLASS_BIT(DepthTarget); + STRINGISE_BITFIELD_CLASS_BIT(ShaderReadWrite); + STRINGISE_BITFIELD_CLASS_BIT(SwapBuffer); + } + END_BITFIELD_STRINGISE(); +} + +template <> +std::string DoStringise(const BufferCategory &el) +{ + BEGIN_BITFIELD_STRINGISE(BufferCategory); + { + STRINGISE_BITFIELD_CLASS_VALUE_NAMED(NoFlags, "None"); + + STRINGISE_BITFIELD_CLASS_BIT(Vertex); + STRINGISE_BITFIELD_CLASS_BIT(Index); + STRINGISE_BITFIELD_CLASS_BIT(Constants); + STRINGISE_BITFIELD_CLASS_BIT(ReadWrite); + STRINGISE_BITFIELD_CLASS_BIT(Indirect); + } + END_BITFIELD_STRINGISE(); +} + +template <> +std::string DoStringise(const DrawFlags &el) +{ + BEGIN_BITFIELD_STRINGISE(DrawFlags); + { + STRINGISE_BITFIELD_CLASS_VALUE_NAMED(NoFlags, "None"); + + STRINGISE_BITFIELD_CLASS_BIT(Clear); + STRINGISE_BITFIELD_CLASS_BIT(Drawcall); + STRINGISE_BITFIELD_CLASS_BIT(Dispatch); + STRINGISE_BITFIELD_CLASS_BIT(CmdList); + STRINGISE_BITFIELD_CLASS_BIT(SetMarker); + STRINGISE_BITFIELD_CLASS_BIT(PushMarker); + STRINGISE_BITFIELD_CLASS_BIT(PopMarker); + STRINGISE_BITFIELD_CLASS_BIT(Present); + STRINGISE_BITFIELD_CLASS_BIT(MultiDraw); + STRINGISE_BITFIELD_CLASS_BIT(Copy); + STRINGISE_BITFIELD_CLASS_BIT(Resolve); + STRINGISE_BITFIELD_CLASS_BIT(GenMips); + STRINGISE_BITFIELD_CLASS_BIT(PassBoundary); + + STRINGISE_BITFIELD_CLASS_BIT(UseIBuffer); + STRINGISE_BITFIELD_CLASS_BIT(Instanced); + STRINGISE_BITFIELD_CLASS_BIT(Auto); + STRINGISE_BITFIELD_CLASS_BIT(Indirect); + STRINGISE_BITFIELD_CLASS_BIT(ClearColor); + STRINGISE_BITFIELD_CLASS_BIT(ClearDepthStencil); + STRINGISE_BITFIELD_CLASS_BIT(BeginPass); + STRINGISE_BITFIELD_CLASS_BIT(EndPass); + STRINGISE_BITFIELD_CLASS_BIT(APICalls); + } + END_BITFIELD_STRINGISE(); +} + +template <> +std::string DoStringise(const ShaderStageMask &el) +{ + BEGIN_BITFIELD_STRINGISE(ShaderStageMask); + { + STRINGISE_BITFIELD_CLASS_VALUE(Unknown); + STRINGISE_BITFIELD_CLASS_VALUE(All); + + STRINGISE_BITFIELD_CLASS_BIT(Vertex); + STRINGISE_BITFIELD_CLASS_BIT(Hull); + STRINGISE_BITFIELD_CLASS_BIT(Domain); + STRINGISE_BITFIELD_CLASS_BIT(Geometry); + STRINGISE_BITFIELD_CLASS_BIT(Pixel); + STRINGISE_BITFIELD_CLASS_BIT(Compute); + } + END_BITFIELD_STRINGISE(); +} \ No newline at end of file diff --git a/renderdoc/api/replay/stringise.h b/renderdoc/api/replay/stringise.h new file mode 100644 index 000000000..78ea964fe --- /dev/null +++ b/renderdoc/api/replay/stringise.h @@ -0,0 +1,155 @@ +/****************************************************************************** + * The MIT License (MIT) + * + * Copyright (c) 2016 Baldur Karlsson + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ + +#pragma once + +#include +#include + +template +std::string DoStringise(const T &el); + +template ::value> +struct StringConverter +{ + static std::string Do(const T &el) { return DoStringise(el); } +}; + +template +struct StringConverter +{ + static std::string Do(const T &el) { return DoStringise(el); } +}; + +template +std::string ToStr(const T &el) +{ + return StringConverter::Do(el); +} + +// helper macros for common enum switch +#define BEGIN_ENUM_STRINGISE(type) \ + using enumType = type; \ + static const char unknown_prefix[] = #type "<"; \ + static_assert(std::is_same::value, \ + "Type in macro doesn't match el"); \ + (void)(enumType) el; \ + switch(el) \ + { \ + default: break; + +// stringise the parameter +#define STRINGISE_ENUM_CLASS(a) \ + case enumType::a: return #a; + +// stringise the parameter with a custom string +#define STRINGISE_ENUM_CLASS_NAMED(value, str) \ + case enumType::value: return str; + +// stringise the parameter +#define STRINGISE_ENUM(a) \ + case a: return #a; + +// stringise the parameter with a custom string +#define STRINGISE_ENUM_NAMED(value, str) \ + case value: return str; + +// end enum switches +#define END_ENUM_STRINGISE() \ + } \ + return unknown_prefix + ToStr((uint32_t)el) + ">"; + +// helper macros for common bitfield check-and-append +#define BEGIN_BITFIELD_STRINGISE(type) \ + using enumType = type; \ + static const char unknown_prefix[] = " | " #type "("; \ + static_assert(std::is_same::value, \ + "Type in macro doesn't match el"); \ + uint32_t local = (uint32_t)el; \ + (void)(enumType) el; \ + std::string ret; + +#define STRINGISE_BITFIELD_VALUE(b) \ + if(el == b) \ + return #b; + +#define STRINGISE_BITFIELD_CLASS_VALUE(b) \ + if(el == enumType::b) \ + return #b; + +#define STRINGISE_BITFIELD_VALUE_NAMED(b, str) \ + if(el == b) \ + return str; + +#define STRINGISE_BITFIELD_CLASS_VALUE_NAMED(b, str) \ + if(el == enumType::b) \ + return str; + +#define STRINGISE_BITFIELD_BIT(b) \ + if(el & b) \ + { \ + local -= (uint32_t)b; \ + ret += " | " #b; \ + } + +#define STRINGISE_BITFIELD_CLASS_BIT(b) \ + if(el & enumType::b) \ + { \ + local -= (uint32_t)enumType::b; \ + ret += " | " #b; \ + } + +#define STRINGISE_BITFIELD_BIT_NAMED(b, str) \ + if(el & b) \ + { \ + local -= (uint32_t)b; \ + ret += " | " str; \ + } + +#define STRINGISE_BITFIELD_CLASS_BIT_NAMED(b, str) \ + if(el & enumType::b) \ + { \ + local -= (uint32_t)b; \ + ret += " | " str; \ + } + +#define END_BITFIELD_STRINGISE() \ + if(local) \ + ret += unknown_prefix + ToStr(local) + ")"; \ + \ + if(!ret.empty()) \ + { \ + ret = ret.substr(3); \ + } \ + return ret; + +template +inline const char *TypeName(); + +#define DECLARE_STRINGISE_TYPE(type) \ + template <> \ + inline const char *TypeName() \ + { \ + return #type; \ + } diff --git a/renderdoc/api/replay/structured_data.h b/renderdoc/api/replay/structured_data.h index 0bb004815..f7d3064e1 100644 --- a/renderdoc/api/replay/structured_data.h +++ b/renderdoc/api/replay/structured_data.h @@ -25,6 +25,7 @@ #pragma once #include +#include "stringise.h" DOCUMENT(R"(The basic irreducible type of an object. Every other more complex type is built on these. @@ -97,6 +98,8 @@ enum class SDBasic : uint32_t Character, }; +DECLARE_STRINGISE_TYPE(SDBasic); + DOCUMENT(R"(Bitfield flags that could be applied to a type. .. data:: NoFlags diff --git a/renderdoc/common/custom_assert.h b/renderdoc/common/custom_assert.h index 76d67f9ab..e0a0ea7ca 100644 --- a/renderdoc/common/custom_assert.h +++ b/renderdoc/common/custom_assert.h @@ -38,27 +38,27 @@ // // A few more twiddles by hand to get everything playing nicely -#define RDCASSERT_FAILMSG_1(value) failmsg += (STRINGIZE(value) "=") + ToStr::Get(value) + ", "; -#define RDCASSERT_FAILMSG_2(value, _1) \ - failmsg += (STRINGIZE(value) "=") + ToStr::Get(value) + ", "; \ +#define RDCASSERT_FAILMSG_1(value) failmsg += (STRINGIZE(value) "=") + ToStr(value) + ", "; +#define RDCASSERT_FAILMSG_2(value, _1) \ + failmsg += (STRINGIZE(value) "=") + ToStr(value) + ", "; \ RDCASSERT_FAILMSG_1(_1) -#define RDCASSERT_FAILMSG_3(value, _1, _2) \ - failmsg += (STRINGIZE(value) "=") + ToStr::Get(value) + ", "; \ +#define RDCASSERT_FAILMSG_3(value, _1, _2) \ + failmsg += (STRINGIZE(value) "=") + ToStr(value) + ", "; \ RDCASSERT_FAILMSG_2(_1, _2) -#define RDCASSERT_FAILMSG_4(value, _1, _2, _3) \ - failmsg += (STRINGIZE(value) "=") + ToStr::Get(value) + ", "; \ +#define RDCASSERT_FAILMSG_4(value, _1, _2, _3) \ + failmsg += (STRINGIZE(value) "=") + ToStr(value) + ", "; \ RDCASSERT_FAILMSG_3(_1, _2, _3) -#define RDCASSERT_FAILMSG_5(value, _1, _2, _3, _4) \ - failmsg += (STRINGIZE(value) "=") + ToStr::Get(value) + ", "; \ +#define RDCASSERT_FAILMSG_5(value, _1, _2, _3, _4) \ + failmsg += (STRINGIZE(value) "=") + ToStr(value) + ", "; \ RDCASSERT_FAILMSG_4(_1, _2, _3, _4) -#define RDCASSERT_FAILMSG_6(value, _1, _2, _3, _4, _5) \ - failmsg += (STRINGIZE(value) "=") + ToStr::Get(value) + ", "; \ +#define RDCASSERT_FAILMSG_6(value, _1, _2, _3, _4, _5) \ + failmsg += (STRINGIZE(value) "=") + ToStr(value) + ", "; \ RDCASSERT_FAILMSG_5(_1, _2, _3, _4, _5) -#define RDCASSERT_FAILMSG_7(value, _1, _2, _3, _4, _5, _6) \ - failmsg += (STRINGIZE(value) "=") + ToStr::Get(value) + ", "; \ +#define RDCASSERT_FAILMSG_7(value, _1, _2, _3, _4, _5, _6) \ + failmsg += (STRINGIZE(value) "=") + ToStr(value) + ", "; \ RDCASSERT_FAILMSG_6(_1, _2, _3, _4, _5, _6) -#define RDCASSERT_FAILMSG_8(value, _1, _2, _3, _4, _5, _6, _7) \ - failmsg += (STRINGIZE(value) "=") + ToStr::Get(value) + ", "; \ +#define RDCASSERT_FAILMSG_8(value, _1, _2, _3, _4, _5, _6, _7) \ + failmsg += (STRINGIZE(value) "=") + ToStr(value) + ", "; \ RDCASSERT_FAILMSG_7(_1, _2, _3, _4, _5, _6, _7) // this is the terminating clause diff --git a/renderdoc/core/core.cpp b/renderdoc/core/core.cpp index 4aeceff1a..7c38e3b5f 100644 --- a/renderdoc/core/core.cpp +++ b/renderdoc/core/core.cpp @@ -36,8 +36,10 @@ #include "strings/string_utils.h" #include "crash_handler.h" +#include "api/replay/renderdoc_tostr.inl" + template <> -string ToStrHelper::Get(const ResourceId &el) +std::string DoStringise(const ResourceId &el) { char tostrBuf[256] = {0}; @@ -71,81 +73,41 @@ bool is_exr_file(FILE *f) } template <> -string ToStrHelper::Get(const RDCDriver &el) +std::string DoStringise(const RDCDriver &el) { - switch(el) + BEGIN_ENUM_STRINGISE(RDCDriver); { - case RDC_Unknown: return "Unknown"; - case RDC_OpenGL: return "OpenGL"; - case RDC_OpenGLES: return "OpenGLES"; - case RDC_Mantle: return "Mantle"; - case RDC_D3D12: return "D3D12"; - case RDC_D3D11: return "D3D11"; - case RDC_D3D10: return "D3D10"; - case RDC_D3D9: return "D3D9"; - case RDC_D3D8: return "D3D8"; - case RDC_Image: return "Image"; - case RDC_Vulkan: return "Vulkan"; - default: break; + STRINGISE_ENUM_NAMED(RDC_Unknown, "Unknown"); + STRINGISE_ENUM_NAMED(RDC_OpenGL, "OpenGL"); + STRINGISE_ENUM_NAMED(RDC_OpenGLES, "OpenGLES"); + STRINGISE_ENUM_NAMED(RDC_Mantle, "Mantle"); + STRINGISE_ENUM_NAMED(RDC_D3D12, "D3D12"); + STRINGISE_ENUM_NAMED(RDC_D3D11, "D3D11"); + STRINGISE_ENUM_NAMED(RDC_D3D10, "D3D10"); + STRINGISE_ENUM_NAMED(RDC_D3D9, "D3D9"); + STRINGISE_ENUM_NAMED(RDC_D3D8, "D3D8"); + STRINGISE_ENUM_NAMED(RDC_Image, "Image"); + STRINGISE_ENUM_NAMED(RDC_Vulkan, "Vulkan"); } - - char tostrBuf[256] = {0}; - StringFormat::snprintf(tostrBuf, 255, "RDCDriver<%d>", el); - - return tostrBuf; + END_ENUM_STRINGISE(); } template <> -string ToStrHelper::Get(const WindowingSystem &el) +std::string DoStringise(const WindowingSystem &el) { - switch(el) + BEGIN_ENUM_STRINGISE(WindowingSystem); { - case WindowingSystem::Unknown: return "Unknown"; - case WindowingSystem::Win32: return "Win32"; - case WindowingSystem::Xlib: return "Xlib"; - case WindowingSystem::XCB: return "XCB"; - case WindowingSystem::Android: return "Android"; - default: break; + STRINGISE_ENUM_CLASS(Unknown); + STRINGISE_ENUM_CLASS(Win32); + STRINGISE_ENUM_CLASS(Xlib); + STRINGISE_ENUM_CLASS(XCB); + STRINGISE_ENUM_CLASS(Android); } - - char tostrBuf[256] = {0}; - StringFormat::snprintf(tostrBuf, 255, "WindowingSystem<%d>", el); - - return tostrBuf; + END_ENUM_STRINGISE(); } template <> -string ToStrHelper::Get(const ReplayStatus &el) -{ - switch(el) - { - case ReplayStatus::Succeeded: return "Succeeded"; - case ReplayStatus::UnknownError: return "Unknown error"; - case ReplayStatus::InternalError: return "Internal error"; - case ReplayStatus::FileNotFound: return "File not found"; - case ReplayStatus::InjectionFailed: return "RenderDoc injection failed"; - case ReplayStatus::IncompatibleProcess: return "Process is incompatible"; - case ReplayStatus::NetworkIOFailed: return "Network I/O operation failed"; - case ReplayStatus::NetworkRemoteBusy: return "Remote side of network connection is busy"; - case ReplayStatus::NetworkVersionMismatch: return "Version mismatch between network clients"; - case ReplayStatus::FileIOFailed: return "File I/O failed"; - case ReplayStatus::FileIncompatibleVersion: return "File of incompatible version"; - case ReplayStatus::FileCorrupted: return "File corrupted"; - case ReplayStatus::APIUnsupported: return "API unsupported"; - case ReplayStatus::APIInitFailed: return "API initialisation failed"; - case ReplayStatus::APIIncompatibleVersion: return "API incompatible version"; - case ReplayStatus::APIHardwareUnsupported: return "API hardware unsupported"; - default: break; - } - - char tostrBuf[256] = {0}; - StringFormat::snprintf(tostrBuf, 255, "StatusCode<%d>", el); - - return tostrBuf; -} - -template <> -string ToStrHelper::Get(const RENDERDOC_InputButton &el) +std::string DoStringise(const RENDERDOC_InputButton &el) { char alphanumericbuf[2] = {'A', 0}; @@ -157,44 +119,39 @@ string ToStrHelper::Get(const RENDERDOC_InputButto return alphanumericbuf; } - switch(el) + BEGIN_ENUM_STRINGISE(RENDERDOC_InputButton); { - case eRENDERDOC_Key_Divide: return "/"; - case eRENDERDOC_Key_Multiply: return "*"; - case eRENDERDOC_Key_Subtract: return "-"; - case eRENDERDOC_Key_Plus: return "+"; + STRINGISE_ENUM_NAMED(eRENDERDOC_Key_Divide, "/"); + STRINGISE_ENUM_NAMED(eRENDERDOC_Key_Multiply, "*"); + STRINGISE_ENUM_NAMED(eRENDERDOC_Key_Subtract, "-"); + STRINGISE_ENUM_NAMED(eRENDERDOC_Key_Plus, "+"); - case eRENDERDOC_Key_F1: return "F1"; - case eRENDERDOC_Key_F2: return "F2"; - case eRENDERDOC_Key_F3: return "F3"; - case eRENDERDOC_Key_F4: return "F4"; - case eRENDERDOC_Key_F5: return "F5"; - case eRENDERDOC_Key_F6: return "F6"; - case eRENDERDOC_Key_F7: return "F7"; - case eRENDERDOC_Key_F8: return "F8"; - case eRENDERDOC_Key_F9: return "F9"; - case eRENDERDOC_Key_F10: return "F10"; - case eRENDERDOC_Key_F11: return "F11"; - case eRENDERDOC_Key_F12: return "F12"; + STRINGISE_ENUM_NAMED(eRENDERDOC_Key_F1, "F1"); + STRINGISE_ENUM_NAMED(eRENDERDOC_Key_F2, "F2"); + STRINGISE_ENUM_NAMED(eRENDERDOC_Key_F3, "F3"); + STRINGISE_ENUM_NAMED(eRENDERDOC_Key_F4, "F4"); + STRINGISE_ENUM_NAMED(eRENDERDOC_Key_F5, "F5"); + STRINGISE_ENUM_NAMED(eRENDERDOC_Key_F6, "F6"); + STRINGISE_ENUM_NAMED(eRENDERDOC_Key_F7, "F7"); + STRINGISE_ENUM_NAMED(eRENDERDOC_Key_F8, "F8"); + STRINGISE_ENUM_NAMED(eRENDERDOC_Key_F9, "F9"); + STRINGISE_ENUM_NAMED(eRENDERDOC_Key_F10, "F10"); + STRINGISE_ENUM_NAMED(eRENDERDOC_Key_F11, "F11"); + STRINGISE_ENUM_NAMED(eRENDERDOC_Key_F12, "F12"); - case eRENDERDOC_Key_Home: return "Home"; - case eRENDERDOC_Key_End: return "End"; - case eRENDERDOC_Key_Insert: return "Insert"; - case eRENDERDOC_Key_Delete: return "Delete"; - case eRENDERDOC_Key_PageUp: return "PageUp"; - case eRENDERDOC_Key_PageDn: return "PageDn"; + STRINGISE_ENUM_NAMED(eRENDERDOC_Key_Home, "Home"); + STRINGISE_ENUM_NAMED(eRENDERDOC_Key_End, "End"); + STRINGISE_ENUM_NAMED(eRENDERDOC_Key_Insert, "Insert"); + STRINGISE_ENUM_NAMED(eRENDERDOC_Key_Delete, "Delete"); + STRINGISE_ENUM_NAMED(eRENDERDOC_Key_PageUp, "PageUp"); + STRINGISE_ENUM_NAMED(eRENDERDOC_Key_PageDn, "PageDn"); - case eRENDERDOC_Key_Backspace: return "Backspace"; - case eRENDERDOC_Key_Tab: return "Tab"; - case eRENDERDOC_Key_PrtScrn: return "PrtScrn"; - case eRENDERDOC_Key_Pause: return "Pause"; - default: break; + STRINGISE_ENUM_NAMED(eRENDERDOC_Key_Backspace, "Backspace"); + STRINGISE_ENUM_NAMED(eRENDERDOC_Key_Tab, "Tab"); + STRINGISE_ENUM_NAMED(eRENDERDOC_Key_PrtScrn, "PrtScrn"); + STRINGISE_ENUM_NAMED(eRENDERDOC_Key_Pause, "Pause"); } - - char tostrBuf[256] = {0}; - StringFormat::snprintf(tostrBuf, 255, "RENDERDOC_InputButton<%d>", el); - - return tostrBuf; + END_ENUM_STRINGISE(); } RenderDoc *RenderDoc::m_Inst = NULL; @@ -609,7 +566,7 @@ string RenderDoc::GetOverlayText(RDCDriver driver, uint32_t frameNumber, int fla uint32_t overlay = GetOverlayBits(); - string overlayText = ToStr::Get(driver) + ". "; + std::string overlayText = ToStr(driver) + ". "; if(activeWindow) { @@ -624,7 +581,7 @@ string RenderDoc::GetOverlayText(RDCDriver driver, uint32_t frameNumber, int fla if(i > 0) overlayText += ", "; - overlayText += ToStr::Get(keys[i]); + overlayText += ToStr(keys[i]); } if(!keys.empty()) @@ -686,7 +643,7 @@ string RenderDoc::GetOverlayText(RDCDriver driver, uint32_t frameNumber, int fla else overlayText += ", "; - overlayText += ToStr::Get(keys[i]); + overlayText += ToStr(keys[i]); } if(!keys.empty()) diff --git a/renderdoc/core/remote_server.cpp b/renderdoc/core/remote_server.cpp index 24ceea14d..7a35c6bdf 100644 --- a/renderdoc/core/remote_server.cpp +++ b/renderdoc/core/remote_server.cpp @@ -37,18 +37,6 @@ using std::pair; -template <> -string ToStrHelper::Get(const PathProperty &el) -{ - return "<...>"; -} - -template <> -string ToStrHelper::Get(const CaptureOptions &el) -{ - return "<...>"; -} - template <> void Serialiser::Serialise(const char *name, PathEntry &el) { @@ -60,18 +48,6 @@ void Serialiser::Serialise(const char *name, PathEntry &el) Serialise("size", el.size); } -template <> -string ToStrHelper::Get(const EnvMod &el) -{ - return "<...>"; -} - -template <> -string ToStrHelper::Get(const EnvSep &el) -{ - return "<...>"; -} - template <> void Serialiser::Serialise(const char *name, EnvironmentModification &el) { diff --git a/renderdoc/core/replay_proxy.cpp b/renderdoc/core/replay_proxy.cpp index 442b76ad2..319580355 100644 --- a/renderdoc/core/replay_proxy.cpp +++ b/renderdoc/core/replay_proxy.cpp @@ -56,49 +56,6 @@ class undersized #pragma region General Shader / State -template <> -string ToStrHelper::Get(const ShaderBuiltin &el) -{ - switch(el) - { - TOSTR_CASE_STRINGIZE_SCOPED(ShaderBuiltin, Undefined) - TOSTR_CASE_STRINGIZE_SCOPED(ShaderBuiltin, Position) - TOSTR_CASE_STRINGIZE_SCOPED(ShaderBuiltin, PointSize) - TOSTR_CASE_STRINGIZE_SCOPED(ShaderBuiltin, ClipDistance) - TOSTR_CASE_STRINGIZE_SCOPED(ShaderBuiltin, CullDistance) - TOSTR_CASE_STRINGIZE_SCOPED(ShaderBuiltin, RTIndex) - TOSTR_CASE_STRINGIZE_SCOPED(ShaderBuiltin, ViewportIndex) - TOSTR_CASE_STRINGIZE_SCOPED(ShaderBuiltin, VertexIndex) - TOSTR_CASE_STRINGIZE_SCOPED(ShaderBuiltin, PrimitiveIndex) - TOSTR_CASE_STRINGIZE_SCOPED(ShaderBuiltin, InstanceIndex) - TOSTR_CASE_STRINGIZE_SCOPED(ShaderBuiltin, DispatchSize) - TOSTR_CASE_STRINGIZE_SCOPED(ShaderBuiltin, DispatchThreadIndex) - TOSTR_CASE_STRINGIZE_SCOPED(ShaderBuiltin, GroupIndex) - TOSTR_CASE_STRINGIZE_SCOPED(ShaderBuiltin, GroupFlatIndex) - TOSTR_CASE_STRINGIZE_SCOPED(ShaderBuiltin, GroupThreadIndex) - TOSTR_CASE_STRINGIZE_SCOPED(ShaderBuiltin, GSInstanceIndex) - TOSTR_CASE_STRINGIZE_SCOPED(ShaderBuiltin, OutputControlPointIndex) - TOSTR_CASE_STRINGIZE_SCOPED(ShaderBuiltin, DomainLocation) - TOSTR_CASE_STRINGIZE_SCOPED(ShaderBuiltin, IsFrontFace) - TOSTR_CASE_STRINGIZE_SCOPED(ShaderBuiltin, MSAACoverage) - TOSTR_CASE_STRINGIZE_SCOPED(ShaderBuiltin, MSAASamplePosition) - TOSTR_CASE_STRINGIZE_SCOPED(ShaderBuiltin, MSAASampleIndex) - TOSTR_CASE_STRINGIZE_SCOPED(ShaderBuiltin, PatchNumVertices) - TOSTR_CASE_STRINGIZE_SCOPED(ShaderBuiltin, OuterTessFactor) - TOSTR_CASE_STRINGIZE_SCOPED(ShaderBuiltin, InsideTessFactor) - TOSTR_CASE_STRINGIZE_SCOPED(ShaderBuiltin, ColorOutput) - TOSTR_CASE_STRINGIZE_SCOPED(ShaderBuiltin, DepthOutput) - TOSTR_CASE_STRINGIZE_SCOPED(ShaderBuiltin, DepthOutputGreaterEqual) - TOSTR_CASE_STRINGIZE_SCOPED(ShaderBuiltin, DepthOutputLessEqual) - default: break; - } - - char tostrBuf[256] = {0}; - StringFormat::snprintf(tostrBuf, 255, "SystemAttribute<%d>", el); - - return tostrBuf; -} - template <> void Serialiser::Serialise(const char *name, ResourceFormat &el) { @@ -1669,336 +1626,176 @@ void Serialiser::Serialise(const char *name, PixelModification &el) #pragma endregion Data descriptors -#pragma region Ignored Enums - -// don't need string representation of these enums -template <> -string ToStrHelper::Get(const ResourceFormatType &el) -{ - return "<...>"; -} -template <> -string ToStrHelper::Get(const CompType &el) -{ - switch(el) - { - case CompType::Typeless: return "Typeless"; - case CompType::Float: return "Float"; - case CompType::UNorm: return "UNorm"; - case CompType::SNorm: return "SNorm"; - case CompType::UInt: return "UInt"; - case CompType::SInt: return "SInt"; - case CompType::UScaled: return "UScaled"; - case CompType::SScaled: return "SScaled"; - case CompType::Depth: return "Depth"; - case CompType::Double: return "Double"; - } - - return StringFormat::Fmt("CompType<%d>", el); -} -template <> -string ToStrHelper::Get(const ShaderEvents &el) -{ - return "<...>"; -} -template <> -string ToStrHelper::Get(const TextureCategory &el) -{ - return "<...>"; -} -template <> -string ToStrHelper::Get(const BufferCategory &el) -{ - return "<...>"; -} -template <> -string ToStrHelper::Get(const D3DBufferViewFlags &el) -{ - return "<...>"; -} -template <> -string ToStrHelper::Get(const DrawFlags &el) -{ - return "<...>"; -} -template <> -string ToStrHelper::Get(const GPUCounter &el) -{ - return "<...>"; -} -template <> -string ToStrHelper::Get(const TextureSwizzle &el) -{ - return "<...>"; -} -template <> -string ToStrHelper::Get(const AddressMode &el) -{ - return "<...>"; -} -template <> -string ToStrHelper::Get(const CompareFunc &el) -{ - return "<...>"; -} -template <> -string ToStrHelper::Get(const BlendMultiplier &el) -{ - return "<...>"; -} -template <> -string ToStrHelper::Get(const BlendOp &el) -{ - return "<...>"; -} -template <> -string ToStrHelper::Get(const LogicOp &el) -{ - return "<...>"; -} -template <> -string ToStrHelper::Get(const StencilOp &el) -{ - return "<...>"; -} -template <> -string ToStrHelper::Get(const CounterUnit &el) -{ - return "<...>"; -} -template <> -string ToStrHelper::Get(const Topology &el) -{ - return "<...>"; -} -template <> -string ToStrHelper::Get(const ShaderStage &el) -{ - return "<...>"; -} -template <> -string ToStrHelper::Get(const ShaderStageMask &el) -{ - return "<...>"; -} -template <> -string ToStrHelper::Get(const BindType &el) -{ - return "<...>"; -} -template <> -string ToStrHelper::Get(const TextureDim &el) -{ - return "<...>"; -} -template <> -string ToStrHelper::Get(const MessageCategory &el) -{ - return "<...>"; -} -template <> -string ToStrHelper::Get(const MessageSeverity &el) -{ - return "<...>"; -} -template <> -string ToStrHelper::Get(const MessageSource &el) -{ - return "<...>"; -} -template <> -string ToStrHelper::Get(const VarType &el) -{ - return "<...>"; -} -template <> -string ToStrHelper::Get(const MeshDataStage &el) -{ - return "<...>"; -} -template <> -string ToStrHelper::Get(const DebugOverlay &el) -{ - return "<...>"; -} -template <> -string ToStrHelper::Get(const GraphicsAPI &el) -{ - return "<...>"; -} - -#pragma endregion Ignored Enums - #pragma region Plain - old data structures // these structures we can just serialise as a blob, since they're POD. template <> -string ToStrHelper::Get(const D3D11Pipe::VB &el) +std::string DoStringise(const CaptureOptions &el) { return "<...>"; } template <> -string ToStrHelper::Get(const D3D11Pipe::RasterizerState &el) +std::string DoStringise(const D3D11Pipe::VB &el) { return "<...>"; } template <> -string ToStrHelper::Get(const D3D11Pipe::CBuffer &el) +std::string DoStringise(const D3D11Pipe::RasterizerState &el) { return "<...>"; } template <> -string ToStrHelper::Get(const D3D11Pipe::Scissor &el) +std::string DoStringise(const D3D11Pipe::CBuffer &el) { return "<...>"; } template <> -string ToStrHelper::Get(const D3D11Pipe::Viewport &el) +std::string DoStringise(const D3D11Pipe::Scissor &el) { return "<...>"; } template <> -string ToStrHelper::Get(const D3D11Pipe::SOBind &el) +std::string DoStringise(const D3D11Pipe::Viewport &el) { return "<...>"; } template <> -string ToStrHelper::Get(const D3D12Pipe::VB &el) +std::string DoStringise(const D3D11Pipe::SOBind &el) { return "<...>"; } template <> -string ToStrHelper::Get(const D3D12Pipe::SOBind &el) +std::string DoStringise(const D3D12Pipe::VB &el) { return "<...>"; } template <> -string ToStrHelper::Get(const D3D12Pipe::Scissor &el) +std::string DoStringise(const D3D12Pipe::SOBind &el) { return "<...>"; } template <> -string ToStrHelper::Get(const D3D12Pipe::Viewport &el) +std::string DoStringise(const D3D12Pipe::Scissor &el) { return "<...>"; } template <> -string ToStrHelper::Get(const D3D12Pipe::RasterizerState &el) +std::string DoStringise(const D3D12Pipe::Viewport &el) { return "<...>"; } template <> -string ToStrHelper::Get(const GLPipe::VB &el) +std::string DoStringise(const D3D12Pipe::RasterizerState &el) { return "<...>"; } template <> -string ToStrHelper::Get(const GLPipe::FixedVertexProcessing &el) +std::string DoStringise(const GLPipe::VB &el) { return "<...>"; } template <> -string ToStrHelper::Get(const GLPipe::Texture &el) +std::string DoStringise(const GLPipe::FixedVertexProcessing &el) { return "<...>"; } template <> -string ToStrHelper::Get(const GLPipe::Buffer &el) +std::string DoStringise(const GLPipe::Texture &el) { return "<...>"; } template <> -string ToStrHelper::Get(const GLPipe::Feedback &el) +std::string DoStringise(const GLPipe::Buffer &el) { return "<...>"; } template <> -string ToStrHelper::Get(const GLPipe::Viewport &el) +std::string DoStringise(const GLPipe::Feedback &el) { return "<...>"; } template <> -string ToStrHelper::Get(const GLPipe::Scissor &el) +std::string DoStringise(const GLPipe::Viewport &el) { return "<...>"; } template <> -string ToStrHelper::Get(const GLPipe::RasterizerState &el) +std::string DoStringise(const GLPipe::Scissor &el) { return "<...>"; } template <> -string ToStrHelper::Get(const GLPipe::Hints &el) +std::string DoStringise(const GLPipe::RasterizerState &el) { return "<...>"; } template <> -string ToStrHelper::Get(const VKPipe::RenderArea &el) +std::string DoStringise(const GLPipe::Hints &el) { return "<...>"; } template <> -string ToStrHelper::Get(const VKPipe::InputAssembly &el) +std::string DoStringise(const VKPipe::RenderArea &el) { return "<...>"; } template <> -string ToStrHelper::Get(const VKPipe::Tessellation &el) +std::string DoStringise(const VKPipe::InputAssembly &el) { return "<...>"; } template <> -string ToStrHelper::Get(const VKPipe::Raster &el) +std::string DoStringise(const VKPipe::Tessellation &el) { return "<...>"; } template <> -string ToStrHelper::Get(const VKPipe::MultiSample &el) +std::string DoStringise(const VKPipe::Raster &el) { return "<...>"; } template <> -string ToStrHelper::Get(const VKPipe::BindingElement &el) +std::string DoStringise(const VKPipe::MultiSample &el) { return "<...>"; } template <> -string ToStrHelper::Get(const VKPipe::VertexBinding &el) +std::string DoStringise(const VKPipe::BindingElement &el) { return "<...>"; } template <> -string ToStrHelper::Get(const VKPipe::VB &el) +std::string DoStringise(const VKPipe::VertexBinding &el) { return "<...>"; } template <> -string ToStrHelper::Get(const VKPipe::ViewportScissor &el) +std::string DoStringise(const VKPipe::VB &el) { return "<...>"; } template <> -string ToStrHelper::Get(const EventUsage &el) +std::string DoStringise(const VKPipe::ViewportScissor &el) { return "<...>"; } template <> -string ToStrHelper::Get(const CounterResult &el) +std::string DoStringise(const EventUsage &el) { return "<...>"; } template <> -string ToStrHelper::Get(const ReplayLogType &el) +std::string DoStringise(const CounterResult &el) { return "<...>"; } template <> -string ToStrHelper::Get(const FloatVector &el) +std::string DoStringise(const ReplayLogType &el) { return "<...>"; } template <> -string ToStrHelper::Get(const TextureFilter &el) +std::string DoStringise(const FloatVector &el) { return "<...>"; } @@ -2037,19 +1834,17 @@ bool ReplayProxy::SendReplayCommand(ReplayProxyPacket type) } template <> -string ToStrHelper::Get(const RemapTextureEnum &el) +std::string DoStringise(const RemapTextureEnum &el) { - switch(el) + BEGIN_ENUM_STRINGISE(RemapTextureEnum); { - TOSTR_CASE_STRINGIZE(eRemap_None) - TOSTR_CASE_STRINGIZE(eRemap_RGBA8) - TOSTR_CASE_STRINGIZE(eRemap_RGBA16) - TOSTR_CASE_STRINGIZE(eRemap_RGBA32) - TOSTR_CASE_STRINGIZE(eRemap_D32S8) - default: break; + STRINGISE_ENUM(eRemap_None) + STRINGISE_ENUM(eRemap_RGBA8) + STRINGISE_ENUM(eRemap_RGBA16) + STRINGISE_ENUM(eRemap_RGBA32) + STRINGISE_ENUM(eRemap_D32S8) } - - return StringFormat::Fmt("RemapTextureEnum<%d>", el); + END_ENUM_STRINGISE(); } // If a remap is required, modify the params that are used when getting the proxy texture data diff --git a/renderdoc/driver/d3d11/d3d11_analyse.cpp b/renderdoc/driver/d3d11/d3d11_analyse.cpp index 406a80b0b..29b04a43d 100644 --- a/renderdoc/driver/d3d11/d3d11_analyse.cpp +++ b/renderdoc/driver/d3d11/d3d11_analyse.cpp @@ -1085,7 +1085,7 @@ ShaderDebugTrace D3D11DebugManager::DebugVertex(uint32_t eventID, uint32_t verti el = &inputlayout[l]; break; } - if(signame == layoutname + ToStr::Get(inputlayout[l].SemanticIndex)) + if(signame == layoutname + ToStr(inputlayout[l].SemanticIndex)) { el = &inputlayout[l]; break; @@ -1485,7 +1485,7 @@ ShaderDebugTrace D3D11DebugManager::DebugPixel(uint32_t eventID, uint32_t x, uin std::string name = prevdxbc->m_OutputSig[os].semanticIdxName; - extractHlsl += ToStr::Get((uint32_t)numCols) + " input_" + name + " : " + name + ";\n"; + extractHlsl += ToStr((uint32_t)numCols) + " input_" + name + " : " + name + ";\n"; } } } @@ -1493,7 +1493,7 @@ ShaderDebugTrace D3D11DebugManager::DebugPixel(uint32_t eventID, uint32_t x, uin if(!filled) { string dummy_reg = "dummy_register"; - dummy_reg += ToStr::Get((uint32_t)nextreg + dummy); + dummy_reg += ToStr((uint32_t)nextreg + dummy); extractHlsl += "float4 var_" + dummy_reg + " : semantic_" + dummy_reg + ";\n"; initialValues.push_back(DataOutput(-1, 0, 4, ShaderBuiltin::Undefined, true)); @@ -1621,9 +1621,9 @@ ShaderDebugTrace D3D11DebugManager::DebugPixel(uint32_t eventID, uint32_t x, uin } } - extractHlsl += ToStr::Get((uint32_t)numCols) + " input_" + name; + extractHlsl += ToStr((uint32_t)numCols) + " input_" + name; if(arrayLength > 0) - extractHlsl += "[" + ToStr::Get(arrayLength) + "]"; + extractHlsl += "[" + ToStr(arrayLength) + "]"; extractHlsl += " : " + name; if(included && dxbc->m_InputSig[i].compType == CompType::Float) @@ -1635,7 +1635,7 @@ ShaderDebugTrace D3D11DebugManager::DebugPixel(uint32_t eventID, uint32_t x, uin else { for(int a = 0; a < arrayLength; a++) - floatInputs.push_back("input_" + name + "[" + ToStr::Get(a) + "]"); + floatInputs.push_back("input_" + name + "[" + ToStr(a) + "]"); } } @@ -1687,17 +1687,17 @@ ShaderDebugTrace D3D11DebugManager::DebugPixel(uint32_t eventID, uint32_t x, uin "struct PSInitialData { uint hit; float3 pos; uint prim; uint fface; uint sample; uint " "covge; float derivValid; PSInput IN; PSInput INddx; PSInput INddy; PSInput INddxfine; " "PSInput INddyfine; };\n\n"; - extractHlsl += "RWStructuredBuffer PSInitialBuffer : register(u" + - ToStr::Get(uavslot) + ");\n\n"; + extractHlsl += + "RWStructuredBuffer PSInitialBuffer : register(u" + ToStr(uavslot) + ");\n\n"; extractHlsl += "void ExtractInputsPS(PSInput IN, float4 debug_pixelPos : SV_Position, uint prim : " "SV_PrimitiveID, uint sample : SV_SampleIndex, uint covge : SV_Coverage, bool fface : " "SV_IsFrontFace)\n{\n"; - extractHlsl += " uint idx = " + ToStr::Get(overdrawLevels) + ";\n"; - extractHlsl += " if(abs(debug_pixelPos.x - " + ToStr::Get(x) + - ".5) < 0.5f && abs(debug_pixelPos.y - " + ToStr::Get(y) + ".5) < 0.5f)\n"; + extractHlsl += " uint idx = " + ToStr(overdrawLevels) + ";\n"; + extractHlsl += " if(abs(debug_pixelPos.x - " + ToStr(x) + + ".5) < 0.5f && abs(debug_pixelPos.y - " + ToStr(y) + ".5) < 0.5f)\n"; extractHlsl += " InterlockedAdd(PSInitialBuffer[0].hit, 1, idx);\n\n"; - extractHlsl += " idx = min(idx, " + ToStr::Get(overdrawLevels) + ");\n\n"; + extractHlsl += " idx = min(idx, " + ToStr(overdrawLevels) + ");\n\n"; extractHlsl += " PSInitialBuffer[idx].pos = debug_pixelPos.xyz;\n"; extractHlsl += " PSInitialBuffer[idx].prim = prim;\n"; extractHlsl += " PSInitialBuffer[idx].fface = fface;\n"; @@ -1747,7 +1747,7 @@ ShaderDebugTrace D3D11DebugManager::DebugPixel(uint32_t eventID, uint32_t x, uin if(FAILED(hr)) { - RDCERR("Failed to create buffer %08x", hr); + RDCERR("Failed to create buffer HRESULT: %s", ToStr(hr).c_str()); return empty; } @@ -1762,7 +1762,7 @@ ShaderDebugTrace D3D11DebugManager::DebugPixel(uint32_t eventID, uint32_t x, uin if(FAILED(hr)) { - RDCERR("Failed to create buffer %08x", hr); + RDCERR("Failed to create buffer HRESULT: %s", ToStr(hr).c_str()); return empty; } @@ -1778,7 +1778,7 @@ ShaderDebugTrace D3D11DebugManager::DebugPixel(uint32_t eventID, uint32_t x, uin if(FAILED(hr)) { - RDCERR("Failed to create buffer %08x", hr); + RDCERR("Failed to create buffer HRESULT: %s", ToStr(hr).c_str()); return empty; } @@ -1806,7 +1806,7 @@ ShaderDebugTrace D3D11DebugManager::DebugPixel(uint32_t eventID, uint32_t x, uin if(FAILED(hr)) { - RDCERR("Failed to map stage buff %08x", hr); + RDCERR("Failed to map stage buff HRESULT: %s", ToStr(hr).c_str()); return empty; } @@ -2546,7 +2546,7 @@ uint32_t D3D11DebugManager::PickVertex(uint32_t eventID, const MeshDisplay &cfg, if(FAILED(hr)) { - RDCERR("Failed to create PickIBBuf %08x", hr); + RDCERR("Failed to create PickIBBuf HRESULT: %s", ToStr(hr).c_str()); return ~0U; } @@ -2562,7 +2562,7 @@ uint32_t D3D11DebugManager::PickVertex(uint32_t eventID, const MeshDisplay &cfg, if(FAILED(hr)) { SAFE_RELEASE(m_DebugRender.PickIBBuf); - RDCERR("Failed to create PickIBSRV %08x", hr); + RDCERR("Failed to create PickIBSRV HRESULT: %s", ToStr(hr).c_str()); return ~0U; } } @@ -2606,7 +2606,7 @@ uint32_t D3D11DebugManager::PickVertex(uint32_t eventID, const MeshDisplay &cfg, if(FAILED(hr)) { - RDCERR("Failed to create PickVBBuf %08x", hr); + RDCERR("Failed to create PickVBBuf HRESULT: %s", ToStr(hr).c_str()); return ~0U; } @@ -2622,7 +2622,7 @@ uint32_t D3D11DebugManager::PickVertex(uint32_t eventID, const MeshDisplay &cfg, if(FAILED(hr)) { SAFE_RELEASE(m_DebugRender.PickVBBuf); - RDCERR("Failed to create PickVBSRV %08x", hr); + RDCERR("Failed to create PickVBSRV HRESULT: %s", ToStr(hr).c_str()); return ~0U; } } @@ -2837,7 +2837,7 @@ void D3D11DebugManager::PickPixel(ResourceId texture, uint32_t x, uint32_t y, ui if(FAILED(hr)) { - RDCERR("Failed to map stage buff %08x", hr); + RDCERR("Failed to map stage buff HRESULT: %s", ToStr(hr).c_str()); } float *pix = (float *)mapped.pData; @@ -2909,7 +2909,7 @@ byte *D3D11DebugManager::GetTextureData(ResourceId tex, uint32_t arrayIdx, uint3 if(FAILED(hr)) { - RDCERR("Couldn't create staging texture to retrieve data. %08x", hr); + RDCERR("Couldn't create staging texture to retrieve data. HRESULT: %s", ToStr(hr).c_str()); return NULL; } @@ -2931,7 +2931,7 @@ byte *D3D11DebugManager::GetTextureData(ResourceId tex, uint32_t arrayIdx, uint3 if(FAILED(hr)) { - RDCERR("Couldn't create target texture to downcast texture. %08x", hr); + RDCERR("Couldn't create target texture to downcast texture. HRESULT: %s", ToStr(hr).c_str()); SAFE_RELEASE(d); return NULL; } @@ -2945,7 +2945,7 @@ byte *D3D11DebugManager::GetTextureData(ResourceId tex, uint32_t arrayIdx, uint3 hr = m_pDevice->CreateRenderTargetView(rtTex, &rtvDesc, &wrappedrtv); if(FAILED(hr)) { - RDCERR("Couldn't create target rtv to downcast texture. %08x", hr); + RDCERR("Couldn't create target rtv to downcast texture. HRESULT: %s", ToStr(hr).c_str()); SAFE_RELEASE(d); SAFE_RELEASE(rtTex); return NULL; @@ -3049,7 +3049,7 @@ byte *D3D11DebugManager::GetTextureData(ResourceId tex, uint32_t arrayIdx, uint3 if(FAILED(hr)) { - RDCERR("Couldn't create staging texture to retrieve data. %08x", hr); + RDCERR("Couldn't create staging texture to retrieve data. HRESULT: %s", ToStr(hr).c_str()); return NULL; } @@ -3071,7 +3071,7 @@ byte *D3D11DebugManager::GetTextureData(ResourceId tex, uint32_t arrayIdx, uint3 if(FAILED(hr)) { - RDCERR("Couldn't create target texture to downcast texture. %08x", hr); + RDCERR("Couldn't create target texture to downcast texture. HRESULT: %s", ToStr(hr).c_str()); SAFE_RELEASE(d); return NULL; } @@ -3085,7 +3085,7 @@ byte *D3D11DebugManager::GetTextureData(ResourceId tex, uint32_t arrayIdx, uint3 hr = m_pDevice->CreateRenderTargetView(rtTex, &rtvDesc, &wrappedrtv); if(FAILED(hr)) { - RDCERR("Couldn't create target rtv to downcast texture. %08x", hr); + RDCERR("Couldn't create target rtv to downcast texture. HRESULT: %s", ToStr(hr).c_str()); SAFE_RELEASE(d); SAFE_RELEASE(rtTex); return NULL; @@ -3146,7 +3146,7 @@ byte *D3D11DebugManager::GetTextureData(ResourceId tex, uint32_t arrayIdx, uint3 if(FAILED(hr)) { - RDCERR("Couldn't create target texture to resolve texture. %08x", hr); + RDCERR("Couldn't create target texture to resolve texture. HRESULT: %s", ToStr(hr).c_str()); SAFE_RELEASE(d); return NULL; } @@ -3202,7 +3202,7 @@ byte *D3D11DebugManager::GetTextureData(ResourceId tex, uint32_t arrayIdx, uint3 if(FAILED(hr)) { - RDCERR("Couldn't create staging texture to retrieve data. %08x", hr); + RDCERR("Couldn't create staging texture to retrieve data. HRESULT: %s", ToStr(hr).c_str()); return NULL; } @@ -3224,7 +3224,7 @@ byte *D3D11DebugManager::GetTextureData(ResourceId tex, uint32_t arrayIdx, uint3 if(FAILED(hr)) { - RDCERR("Couldn't create target texture to downcast texture. %08x", hr); + RDCERR("Couldn't create target texture to downcast texture. HRESULT: %s", ToStr(hr).c_str()); SAFE_RELEASE(d); return NULL; } @@ -3249,7 +3249,7 @@ byte *D3D11DebugManager::GetTextureData(ResourceId tex, uint32_t arrayIdx, uint3 hr = m_pDevice->CreateRenderTargetView(rtTex, &rtvDesc, &wrappedrtv); if(FAILED(hr)) { - RDCERR("Couldn't create target rtv to downcast texture. %08x", hr); + RDCERR("Couldn't create target rtv to downcast texture. HRESULT: %s", ToStr(hr).c_str()); SAFE_RELEASE(d); SAFE_RELEASE(rtTex); return NULL; @@ -3339,7 +3339,7 @@ byte *D3D11DebugManager::GetTextureData(ResourceId tex, uint32_t arrayIdx, uint3 } else { - RDCERR("Couldn't map staging texture to retrieve data. %08x", hr); + RDCERR("Couldn't map staging texture to retrieve data. HRESULT: %s", ToStr(hr).c_str()); } SAFE_RELEASE(dummyTex); @@ -3369,7 +3369,7 @@ ResourceId D3D11DebugManager::ApplyCustomShader(ResourceId shader, ResourceId te if(FAILED(hr)) { - RDCERR("Failed to create custom shader rtv %08x", hr); + RDCERR("Failed to create custom shader rtv HRESULT: %s", ToStr(hr).c_str()); return m_CustomShaderResourceId; } } @@ -3448,7 +3448,7 @@ void D3D11DebugManager::CreateCustomShaderTex(uint32_t w, uint32_t h) if(FAILED(hr)) { - RDCERR("Failed to create custom shader tex %08x", hr); + RDCERR("Failed to create custom shader tex HRESULT: %s", ToStr(hr).c_str()); } else { @@ -3504,7 +3504,7 @@ ResourceId D3D11DebugManager::RenderOverlay(ResourceId texid, CompType typeHint, HRESULT hr = m_pDevice->CreateTexture2D(&realTexDesc, NULL, &customRenderTex); if(FAILED(hr)) { - RDCERR("Failed to create custom render tex %08x", hr); + RDCERR("Failed to create custom render tex HRESULT: %s", ToStr(hr).c_str()); return ResourceId(); } wrappedCustomRenderTex = (WrappedID3D11Texture2D1 *)customRenderTex; @@ -3541,14 +3541,14 @@ ResourceId D3D11DebugManager::RenderOverlay(ResourceId texid, CompType typeHint, hr = m_pDevice->CreateTexture2D(&desc, NULL, &preDrawDepth); if(FAILED(hr)) { - RDCERR("Failed to create preDrawDepth %08x", hr); + RDCERR("Failed to create preDrawDepth HRESULT: %s", ToStr(hr).c_str()); SAFE_RELEASE(realDepth); return m_OverlayResourceId; } hr = m_pDevice->CreateTexture2D(&desc, NULL, &renderDepth); if(FAILED(hr)) { - RDCERR("Failed to create renderDepth %08x", hr); + RDCERR("Failed to create renderDepth HRESULT: %s", ToStr(hr).c_str()); SAFE_RELEASE(realDepth); return m_OverlayResourceId; } @@ -3572,7 +3572,7 @@ ResourceId D3D11DebugManager::RenderOverlay(ResourceId texid, CompType typeHint, HRESULT hr = m_pDevice->CreateRenderTargetView(wrappedCustomRenderTex, &rtDesc, &rtv); if(FAILED(hr)) { - RDCERR("Failed to create custom render tex RTV %08x", hr); + RDCERR("Failed to create custom render tex RTV HRESULT: %s", ToStr(hr).c_str()); return m_OverlayResourceId; } @@ -3586,7 +3586,7 @@ ResourceId D3D11DebugManager::RenderOverlay(ResourceId texid, CompType typeHint, hr = m_pDevice->CreateDepthStencilView(renderDepth, &dsViewDesc, &dsView); if(FAILED(hr)) { - RDCERR("Failed to create renderDepth DSV %08x", hr); + RDCERR("Failed to create renderDepth DSV HRESULT: %s", ToStr(hr).c_str()); return m_OverlayResourceId; } } @@ -3624,7 +3624,7 @@ ResourceId D3D11DebugManager::RenderOverlay(ResourceId texid, CompType typeHint, hr = m_pDevice->CreateDepthStencilState(&dsDesc, &os); if(FAILED(hr)) { - RDCERR("Failed to create drawcall depth stencil state %08x", hr); + RDCERR("Failed to create drawcall depth stencil state HRESULT: %s", ToStr(hr).c_str()); return m_OverlayResourceId; } @@ -3650,7 +3650,7 @@ ResourceId D3D11DebugManager::RenderOverlay(ResourceId texid, CompType typeHint, hr = m_pDevice->CreateRasterizerState(&rdesc, &rs); if(FAILED(hr)) { - RDCERR("Failed to create drawcall rast state %08x", hr); + RDCERR("Failed to create drawcall rast state HRESULT: %s", ToStr(hr).c_str()); return m_OverlayResourceId; } } @@ -3681,7 +3681,7 @@ ResourceId D3D11DebugManager::RenderOverlay(ResourceId texid, CompType typeHint, hr = m_pDevice->CreateDepthStencilState(&dsDesc, &os); if(FAILED(hr)) { - RDCERR("Failed to create drawcall depth stencil state %08x", hr); + RDCERR("Failed to create drawcall depth stencil state HRESULT: %s", ToStr(hr).c_str()); return m_OverlayResourceId; } @@ -3721,7 +3721,7 @@ ResourceId D3D11DebugManager::RenderOverlay(ResourceId texid, CompType typeHint, hr = m_pDevice->CreateRasterizerState(&rdesc, &rs); if(FAILED(hr)) { - RDCERR("Failed to create drawcall rast state %08x", hr); + RDCERR("Failed to create drawcall rast state HRESULT: %s", ToStr(hr).c_str()); return m_OverlayResourceId; } @@ -3730,7 +3730,7 @@ ResourceId D3D11DebugManager::RenderOverlay(ResourceId texid, CompType typeHint, hr = m_pDevice->CreateRasterizerState(&rdesc, &rsCull); if(FAILED(hr)) { - RDCERR("Failed to create drawcall rast state %08x", hr); + RDCERR("Failed to create drawcall rast state HRESULT: %s", ToStr(hr).c_str()); return m_OverlayResourceId; } } @@ -3794,7 +3794,7 @@ ResourceId D3D11DebugManager::RenderOverlay(ResourceId texid, CompType typeHint, hr = m_pDevice->CreateDepthStencilState(&dsDesc, &os); if(FAILED(hr)) { - RDCERR("Failed to create drawcall depth stencil state %08x", hr); + RDCERR("Failed to create drawcall depth stencil state HRESULT: %s", ToStr(hr).c_str()); return m_OverlayResourceId; } @@ -3838,7 +3838,7 @@ ResourceId D3D11DebugManager::RenderOverlay(ResourceId texid, CompType typeHint, hr = m_pDevice->CreateRasterizerState(&rdesc, &rs); if(FAILED(hr)) { - RDCERR("Failed to create drawcall rast state %08x", hr); + RDCERR("Failed to create drawcall rast state HRESULT: %s", ToStr(hr).c_str()); return m_OverlayResourceId; } } @@ -3911,7 +3911,7 @@ ResourceId D3D11DebugManager::RenderOverlay(ResourceId texid, CompType typeHint, hr = m_pDevice->CreateDepthStencilState(&dsDesc, &os); if(FAILED(hr)) { - RDCERR("Failed to create wireframe depth state %08x", hr); + RDCERR("Failed to create wireframe depth state HRESULT: %s", ToStr(hr).c_str()); return m_OverlayResourceId; } @@ -3951,7 +3951,7 @@ ResourceId D3D11DebugManager::RenderOverlay(ResourceId texid, CompType typeHint, hr = m_pDevice->CreateRasterizerState(&rdesc, &rs); if(FAILED(hr)) { - RDCERR("Failed to create wireframe rast state %08x", hr); + RDCERR("Failed to create wireframe rast state HRESULT: %s", ToStr(hr).c_str()); return m_OverlayResourceId; } } @@ -4029,7 +4029,7 @@ ResourceId D3D11DebugManager::RenderOverlay(ResourceId texid, CompType typeHint, if(FAILED(hr)) { - RDCERR("Failed to create m_MeshDisplayLayout %08x", hr); + RDCERR("Failed to create m_MeshDisplayLayout HRESULT: %s", ToStr(hr).c_str()); m_MeshDisplayLayout = NULL; } @@ -4504,7 +4504,7 @@ ResourceId D3D11DebugManager::RenderOverlay(ResourceId texid, CompType typeHint, hr = m_pDevice->CreateDepthStencilState(&d, &os); if(FAILED(hr)) { - RDCERR("Failed to create depth/stencil overlay depth state %08x", hr); + RDCERR("Failed to create depth/stencil overlay depth state HRESULT: %s", ToStr(hr).c_str()); return m_OverlayResourceId; } @@ -4541,7 +4541,7 @@ ResourceId D3D11DebugManager::RenderOverlay(ResourceId texid, CompType typeHint, hr = m_pDevice->CreateDepthStencilState(&d, &os); if(FAILED(hr)) { - RDCERR("Failed to create depth/stencil overlay depth state 2 %08x", hr); + RDCERR("Failed to create depth/stencil overlay depth state 2 HRESULT: %s", ToStr(hr).c_str()); return m_OverlayResourceId; } @@ -4574,7 +4574,7 @@ ResourceId D3D11DebugManager::RenderOverlay(ResourceId texid, CompType typeHint, hr = m_pDevice->CreateDepthStencilState(&dsDesc, &os); if(FAILED(hr)) { - RDCERR("Failed to create drawcall depth stencil state %08x", hr); + RDCERR("Failed to create drawcall depth stencil state HRESULT: %s", ToStr(hr).c_str()); return m_OverlayResourceId; } @@ -4600,7 +4600,7 @@ ResourceId D3D11DebugManager::RenderOverlay(ResourceId texid, CompType typeHint, hr = m_pDevice->CreateRasterizerState(&rdesc, &rs); if(FAILED(hr)) { - RDCERR("Failed to create drawcall rast state %08x", hr); + RDCERR("Failed to create drawcall rast state HRESULT: %s", ToStr(hr).c_str()); return m_OverlayResourceId; } } diff --git a/renderdoc/driver/d3d11/d3d11_common.cpp b/renderdoc/driver/d3d11/d3d11_common.cpp index fbd872ca0..91c79fadc 100644 --- a/renderdoc/driver/d3d11/d3d11_common.cpp +++ b/renderdoc/driver/d3d11/d3d11_common.cpp @@ -1419,591 +1419,16 @@ void Serialiser::Serialise(const char *name, D3D11_SUBRESOURCE_DATA &el) Serialise("SysMemSlicePitch", el.SysMemSlicePitch); } -///////////////////////////////////////////////////////////// -// Trivial structures - -string ToStrHelper::Get(const D3D11_VIEWPORT &el) -{ - char tostrBuf[256] = {0}; - StringFormat::snprintf(tostrBuf, 255, "Viewport<%.0fx%.0f+%.0f+%.0f z=%f->%f>", el.Width, - el.Height, el.TopLeftX, el.TopLeftY, el.MinDepth, el.MaxDepth); - - return tostrBuf; -} - -string ToStrHelper::Get(const D3D11_RECT &el) -{ - char tostrBuf[256] = {0}; - StringFormat::snprintf(tostrBuf, 255, "RECT<%d,%d,%d,%d>", el.left, el.right, el.top, el.bottom); - - return tostrBuf; -} - -string ToStrHelper::Get(const D3D11_BOX &el) -{ - char tostrBuf[256] = {0}; - StringFormat::snprintf(tostrBuf, 255, "BOX<%d,%d,%d,%d,%d,%d>", el.left, el.right, el.top, - el.bottom, el.front, el.back); - - return tostrBuf; -} - -string ToStrHelper::Get(const D3D11_BIND_FLAG &el) -{ - string ret; - - if(el & D3D11_BIND_VERTEX_BUFFER) - ret += " | D3D11_BIND_VERTEX_BUFFER"; - if(el & D3D11_BIND_INDEX_BUFFER) - ret += " | D3D11_BIND_INDEX_BUFFER"; - if(el & D3D11_BIND_CONSTANT_BUFFER) - ret += " | D3D11_BIND_CONSTANT_BUFFER"; - if(el & D3D11_BIND_SHADER_RESOURCE) - ret += " | D3D11_BIND_SHADER_RESOURCE"; - if(el & D3D11_BIND_STREAM_OUTPUT) - ret += " | D3D11_BIND_STREAM_OUTPUT"; - if(el & D3D11_BIND_RENDER_TARGET) - ret += " | D3D11_BIND_RENDER_TARGET"; - if(el & D3D11_BIND_DEPTH_STENCIL) - ret += " | D3D11_BIND_DEPTH_STENCIL"; - if(el & D3D11_BIND_UNORDERED_ACCESS) - ret += " | D3D11_BIND_UNORDERED_ACCESS"; - - if(!ret.empty()) - ret = ret.substr(3); - - return ret; -} - -string ToStrHelper::Get(const D3D11_CPU_ACCESS_FLAG &el) -{ - string ret; - - if(el & D3D11_CPU_ACCESS_READ) - ret += " | D3D11_CPU_ACCESS_READ"; - if(el & D3D11_CPU_ACCESS_WRITE) - ret += " | D3D11_CPU_ACCESS_WRITE"; - - if(!ret.empty()) - ret = ret.substr(3); - - return ret; -} - -string ToStrHelper::Get(const D3D11_RESOURCE_MISC_FLAG &el) -{ - string ret; - - if(el & D3D11_RESOURCE_MISC_GENERATE_MIPS) - ret + " | D3D11_RESOURCE_MISC_GENERATE_MIPS"; - if(el & D3D11_RESOURCE_MISC_SHARED) - ret + " | D3D11_RESOURCE_MISC_SHARED"; - if(el & D3D11_RESOURCE_MISC_TEXTURECUBE) - ret + " | D3D11_RESOURCE_MISC_TEXTURECUBE"; - if(el & D3D11_RESOURCE_MISC_DRAWINDIRECT_ARGS) - ret + " | D3D11_RESOURCE_MISC_DRAWINDIRECT_ARGS"; - if(el & D3D11_RESOURCE_MISC_BUFFER_ALLOW_RAW_VIEWS) - ret + " | D3D11_RESOURCE_MISC_BUFFER_ALLOW_RAW_VIEWS"; - if(el & D3D11_RESOURCE_MISC_BUFFER_STRUCTURED) - ret + " | D3D11_RESOURCE_MISC_BUFFER_STRUCTURED"; - if(el & D3D11_RESOURCE_MISC_RESOURCE_CLAMP) - ret + " | D3D11_RESOURCE_MISC_RESOURCE_CLAMP"; - if(el & D3D11_RESOURCE_MISC_SHARED_KEYEDMUTEX) - ret + " | D3D11_RESOURCE_MISC_SHARED_KEYEDMUTEX"; - if(el & D3D11_RESOURCE_MISC_GDI_COMPATIBLE) - ret + " | D3D11_RESOURCE_MISC_GDI_COMPATIBLE"; - - if(!ret.empty()) - ret = ret.substr(3); - - return ret; -} - -string ToStrHelper::Get(const D3D11_TEXTURE_LAYOUT &el) -{ - switch(el) - { - TOSTR_CASE_STRINGIZE(D3D11_TEXTURE_LAYOUT_UNDEFINED) - TOSTR_CASE_STRINGIZE(D3D11_TEXTURE_LAYOUT_ROW_MAJOR) - TOSTR_CASE_STRINGIZE(D3D11_TEXTURE_LAYOUT_64K_STANDARD_SWIZZLE) - default: break; - } - - return StringFormat::Fmt("D3D11_TEXTURE_LAYOUT<%d>", el); -} - -///////////////////////////////////////////////////////////// -// Enums and lists - -string ToStrHelper::Get(const D3D11_DEPTH_WRITE_MASK &el) -{ - switch(el) - { - TOSTR_CASE_STRINGIZE(D3D11_DEPTH_WRITE_MASK_ZERO) - TOSTR_CASE_STRINGIZE(D3D11_DEPTH_WRITE_MASK_ALL) - default: break; - } - - char tostrBuf[256] = {0}; - StringFormat::snprintf(tostrBuf, 255, "D3D11_DEPTH_WRITE_MASK<%d>", el); - - return tostrBuf; -} - -string ToStrHelper::Get(const D3D11_COMPARISON_FUNC &el) -{ - switch(el) - { - case D3D11_COMPARISON_NEVER: return "NEVER"; - case D3D11_COMPARISON_LESS: return "LESS"; - case D3D11_COMPARISON_EQUAL: return "EQUAL"; - case D3D11_COMPARISON_LESS_EQUAL: return "LESS_EQUAL"; - case D3D11_COMPARISON_GREATER: return "GREATER"; - case D3D11_COMPARISON_NOT_EQUAL: return "NOT_EQUAL"; - case D3D11_COMPARISON_GREATER_EQUAL: return "GREATER_EQUAL"; - case D3D11_COMPARISON_ALWAYS: return "ALWAYS"; - default: break; - } - - char tostrBuf[256] = {0}; - StringFormat::snprintf(tostrBuf, 255, "D3D11_COMPARISON_FUNC<%d>", el); - - return tostrBuf; -} - -string ToStrHelper::Get(const D3D11_STENCIL_OP &el) -{ - switch(el) - { - case D3D11_STENCIL_OP_KEEP: return "KEEP"; - case D3D11_STENCIL_OP_ZERO: return "ZERO"; - case D3D11_STENCIL_OP_REPLACE: return "REPLACE"; - case D3D11_STENCIL_OP_INCR_SAT: return "INCR_SAT"; - case D3D11_STENCIL_OP_DECR_SAT: return "DECR_SAT"; - case D3D11_STENCIL_OP_INVERT: return "INVERT"; - case D3D11_STENCIL_OP_INCR: return "INCR"; - case D3D11_STENCIL_OP_DECR: return "DECR"; - default: break; - } - - char tostrBuf[256] = {0}; - StringFormat::snprintf(tostrBuf, 255, "D3D11_STENCIL_OP<%d>", el); - - return tostrBuf; -} - -string ToStrHelper::Get(const D3D11_BLEND &el) -{ - switch(el) - { - case D3D11_BLEND_ZERO: return "ZERO"; - case D3D11_BLEND_ONE: return "ONE"; - case D3D11_BLEND_SRC_COLOR: return "SRC_COLOR"; - case D3D11_BLEND_INV_SRC_COLOR: return "INV_SRC_COLOR"; - case D3D11_BLEND_SRC_ALPHA: return "SRC_ALPHA"; - case D3D11_BLEND_INV_SRC_ALPHA: return "INV_SRC_ALPHA"; - case D3D11_BLEND_DEST_ALPHA: return "DEST_ALPHA"; - case D3D11_BLEND_INV_DEST_ALPHA: return "INV_DEST_ALPHA"; - case D3D11_BLEND_DEST_COLOR: return "DEST_COLOR"; - case D3D11_BLEND_INV_DEST_COLOR: return "INV_DEST_COLOR"; - case D3D11_BLEND_SRC_ALPHA_SAT: return "SRC_ALPHA_SAT"; - case D3D11_BLEND_BLEND_FACTOR: return "BLEND_FACTOR"; - case D3D11_BLEND_INV_BLEND_FACTOR: return "INV_BLEND_FACTOR"; - case D3D11_BLEND_SRC1_COLOR: return "SRC1_COLOR"; - case D3D11_BLEND_INV_SRC1_COLOR: return "INV_SRC1_COLOR"; - case D3D11_BLEND_SRC1_ALPHA: return "SRC1_ALPHA"; - case D3D11_BLEND_INV_SRC1_ALPHA: return "INV_SRC1_ALPHA"; - default: break; - } - - char tostrBuf[256] = {0}; - StringFormat::snprintf(tostrBuf, 255, "D3D11_BLEND<%d>", el); - - return tostrBuf; -} - -string ToStrHelper::Get(const D3D11_BLEND_OP &el) -{ - switch(el) - { - case D3D11_BLEND_OP_ADD: return "ADD"; - case D3D11_BLEND_OP_SUBTRACT: return "SUBTRACT"; - case D3D11_BLEND_OP_REV_SUBTRACT: return "REV_SUBTRACT"; - case D3D11_BLEND_OP_MIN: return "MIN"; - case D3D11_BLEND_OP_MAX: return "MAX"; - default: break; - } - - char tostrBuf[256] = {0}; - StringFormat::snprintf(tostrBuf, 255, "D3D11_BLEND_OP<%d>", el); - - return tostrBuf; -} - -string ToStrHelper::Get(const D3D11_CULL_MODE &el) -{ - switch(el) - { - case D3D11_CULL_NONE: return "NONE"; - case D3D11_CULL_FRONT: return "FRONT"; - case D3D11_CULL_BACK: return "BACK"; - default: break; - } - - char tostrBuf[256] = {0}; - StringFormat::snprintf(tostrBuf, 255, "D3D11_CULL_MODE<%d>", el); - - return tostrBuf; -} - -string ToStrHelper::Get(const D3D11_FILL_MODE &el) -{ - switch(el) - { - case D3D11_FILL_WIREFRAME: return "WIREFRAME"; - case D3D11_FILL_SOLID: return "SOLID"; - default: break; - } - - char tostrBuf[256] = {0}; - StringFormat::snprintf(tostrBuf, 255, "D3D11_FILL_MODE<%d>", el); - - return tostrBuf; -} - -string ToStrHelper::Get( - const D3D11_CONSERVATIVE_RASTERIZATION_MODE &el) -{ - return el == D3D11_CONSERVATIVE_RASTERIZATION_MODE_ON ? "ON" : "OFF"; -} - -string ToStrHelper::Get(const D3D11_TEXTURE_ADDRESS_MODE &el) -{ - switch(el) - { - case D3D11_TEXTURE_ADDRESS_WRAP: return "WRAP"; - case D3D11_TEXTURE_ADDRESS_MIRROR: return "MIRROR"; - case D3D11_TEXTURE_ADDRESS_CLAMP: return "CLAMP"; - case D3D11_TEXTURE_ADDRESS_BORDER: return "BORDER"; - case D3D11_TEXTURE_ADDRESS_MIRROR_ONCE: return "MIRROR_ONCE"; - default: break; - } - - char tostrBuf[256] = {0}; - StringFormat::snprintf(tostrBuf, 255, "D3D11_TEXTURE_ADDRESS_MODE<%d>", el); - - return tostrBuf; -} - -string ToStrHelper::Get(const D3D11_FILTER &el) -{ - switch(el) - { - case D3D11_FILTER_MIN_MAG_MIP_POINT: return "MIN_MAG_MIP_POINT"; - case D3D11_FILTER_MIN_MAG_POINT_MIP_LINEAR: return "MIN_MAG_POINT_MIP_LINEAR"; - case D3D11_FILTER_MIN_POINT_MAG_LINEAR_MIP_POINT: return "MIN_POINT_MAG_LINEAR_MIP_POINT"; - case D3D11_FILTER_MIN_POINT_MAG_MIP_LINEAR: return "MIN_POINT_MAG_MIP_LINEAR"; - case D3D11_FILTER_MIN_LINEAR_MAG_MIP_POINT: return "MIN_LINEAR_MAG_MIP_POINT"; - case D3D11_FILTER_MIN_LINEAR_MAG_POINT_MIP_LINEAR: return "MIN_LINEAR_MAG_POINT_MIP_LINEAR"; - case D3D11_FILTER_MIN_MAG_LINEAR_MIP_POINT: return "MIN_MAG_LINEAR_MIP_POINT"; - case D3D11_FILTER_MIN_MAG_MIP_LINEAR: return "MIN_MAG_MIP_LINEAR"; - case D3D11_FILTER_ANISOTROPIC: return "ANISOTROPIC"; - case D3D11_FILTER_COMPARISON_MIN_MAG_MIP_POINT: return "CMP:MIN_MAG_MIP_POINT"; - case D3D11_FILTER_COMPARISON_MIN_MAG_POINT_MIP_LINEAR: return "CMP:MIN_MAG_POINT_MIP_LINEAR"; - case D3D11_FILTER_COMPARISON_MIN_POINT_MAG_LINEAR_MIP_POINT: - return "CMP:MIN_POINT_MAG_LINEAR_MIP_POINT"; - case D3D11_FILTER_COMPARISON_MIN_POINT_MAG_MIP_LINEAR: return "CMP:MIN_POINT_MAG_MIP_LINEAR"; - case D3D11_FILTER_COMPARISON_MIN_LINEAR_MAG_MIP_POINT: return "CMP:MIN_LINEAR_MAG_MIP_POINT"; - case D3D11_FILTER_COMPARISON_MIN_LINEAR_MAG_POINT_MIP_LINEAR: - return "CMP:MIN_LINEAR_MAG_POINT_MIP_LINEAR"; - case D3D11_FILTER_COMPARISON_MIN_MAG_LINEAR_MIP_POINT: return "CMP:MIN_MAG_LINEAR_MIP_POINT"; - case D3D11_FILTER_COMPARISON_MIN_MAG_MIP_LINEAR: return "CMP:MIN_MAG_MIP_LINEAR"; - case D3D11_FILTER_COMPARISON_ANISOTROPIC: return "CMP:ANISOTROPIC"; - default: break; - } - - char tostrBuf[256] = {0}; - StringFormat::snprintf(tostrBuf, 255, "D3D11_FILTER<%d>", el); - - return tostrBuf; -} - -string ToStrHelper::Get(const D3D11_SRV_DIMENSION &el) -{ - switch(el) - { - TOSTR_CASE_STRINGIZE(D3D11_SRV_DIMENSION_BUFFER) - TOSTR_CASE_STRINGIZE(D3D11_SRV_DIMENSION_TEXTURE1D) - TOSTR_CASE_STRINGIZE(D3D11_SRV_DIMENSION_TEXTURE1DARRAY) - TOSTR_CASE_STRINGIZE(D3D11_SRV_DIMENSION_TEXTURE2D) - TOSTR_CASE_STRINGIZE(D3D11_SRV_DIMENSION_TEXTURE2DARRAY) - TOSTR_CASE_STRINGIZE(D3D11_SRV_DIMENSION_TEXTURE2DMS) - TOSTR_CASE_STRINGIZE(D3D11_SRV_DIMENSION_TEXTURE2DMSARRAY) - TOSTR_CASE_STRINGIZE(D3D11_SRV_DIMENSION_TEXTURE3D) - TOSTR_CASE_STRINGIZE(D3D11_SRV_DIMENSION_TEXTURECUBE) - TOSTR_CASE_STRINGIZE(D3D11_SRV_DIMENSION_TEXTURECUBEARRAY) - TOSTR_CASE_STRINGIZE(D3D11_SRV_DIMENSION_BUFFEREX) - default: break; - } - - char tostrBuf[256] = {0}; - StringFormat::snprintf(tostrBuf, 255, "D3D11_SRV_DIMENSION<%d>", el); - - return tostrBuf; -} - -string ToStrHelper::Get(const D3D11_RTV_DIMENSION &el) -{ - switch(el) - { - TOSTR_CASE_STRINGIZE(D3D11_RTV_DIMENSION_BUFFER) - TOSTR_CASE_STRINGIZE(D3D11_RTV_DIMENSION_TEXTURE1D) - TOSTR_CASE_STRINGIZE(D3D11_RTV_DIMENSION_TEXTURE1DARRAY) - TOSTR_CASE_STRINGIZE(D3D11_RTV_DIMENSION_TEXTURE2D) - TOSTR_CASE_STRINGIZE(D3D11_RTV_DIMENSION_TEXTURE2DARRAY) - TOSTR_CASE_STRINGIZE(D3D11_RTV_DIMENSION_TEXTURE2DMS) - TOSTR_CASE_STRINGIZE(D3D11_RTV_DIMENSION_TEXTURE2DMSARRAY) - TOSTR_CASE_STRINGIZE(D3D11_RTV_DIMENSION_TEXTURE3D) - default: break; - } - - char tostrBuf[256] = {0}; - StringFormat::snprintf(tostrBuf, 255, "D3D11_RTV_DIMENSION<%d>", el); - - return tostrBuf; -} - -string ToStrHelper::Get(const D3D11_UAV_DIMENSION &el) -{ - switch(el) - { - TOSTR_CASE_STRINGIZE(D3D11_UAV_DIMENSION_BUFFER) - TOSTR_CASE_STRINGIZE(D3D11_UAV_DIMENSION_TEXTURE1D) - TOSTR_CASE_STRINGIZE(D3D11_UAV_DIMENSION_TEXTURE1DARRAY) - TOSTR_CASE_STRINGIZE(D3D11_UAV_DIMENSION_TEXTURE2D) - TOSTR_CASE_STRINGIZE(D3D11_UAV_DIMENSION_TEXTURE2DARRAY) - TOSTR_CASE_STRINGIZE(D3D11_UAV_DIMENSION_TEXTURE3D) - default: break; - } - - char tostrBuf[256] = {0}; - StringFormat::snprintf(tostrBuf, 255, "D3D11_UAV_DIMENSION<%d>", el); - - return tostrBuf; -} - -string ToStrHelper::Get(const D3D11_DSV_DIMENSION &el) -{ - switch(el) - { - TOSTR_CASE_STRINGIZE(D3D11_DSV_DIMENSION_TEXTURE1D) - TOSTR_CASE_STRINGIZE(D3D11_DSV_DIMENSION_TEXTURE1DARRAY) - TOSTR_CASE_STRINGIZE(D3D11_DSV_DIMENSION_TEXTURE2D) - TOSTR_CASE_STRINGIZE(D3D11_DSV_DIMENSION_TEXTURE2DARRAY) - TOSTR_CASE_STRINGIZE(D3D11_DSV_DIMENSION_TEXTURE2DMS) - TOSTR_CASE_STRINGIZE(D3D11_DSV_DIMENSION_TEXTURE2DMSARRAY) - default: break; - } - - char tostrBuf[256] = {0}; - StringFormat::snprintf(tostrBuf, 255, "D3D11_DSV_DIMENSION<%d>", el); - - return tostrBuf; -} - -string ToStrHelper::Get(const D3D11_CONTEXT_TYPE &el) -{ - switch(el) - { - TOSTR_CASE_STRINGIZE(D3D11_CONTEXT_TYPE_ALL) - TOSTR_CASE_STRINGIZE(D3D11_CONTEXT_TYPE_3D) - TOSTR_CASE_STRINGIZE(D3D11_CONTEXT_TYPE_COMPUTE) - TOSTR_CASE_STRINGIZE(D3D11_CONTEXT_TYPE_COPY) - TOSTR_CASE_STRINGIZE(D3D11_CONTEXT_TYPE_VIDEO) - default: break; - } - - return StringFormat::Fmt("D3D11_CONTEXT_TYPE<%d>", el); -} - -string ToStrHelper::Get(const D3D11_QUERY &el) -{ - switch(el) - { - TOSTR_CASE_STRINGIZE(D3D11_QUERY_EVENT) - TOSTR_CASE_STRINGIZE(D3D11_QUERY_OCCLUSION) - TOSTR_CASE_STRINGIZE(D3D11_QUERY_TIMESTAMP) - TOSTR_CASE_STRINGIZE(D3D11_QUERY_TIMESTAMP_DISJOINT) - TOSTR_CASE_STRINGIZE(D3D11_QUERY_PIPELINE_STATISTICS) - TOSTR_CASE_STRINGIZE(D3D11_QUERY_OCCLUSION_PREDICATE) - TOSTR_CASE_STRINGIZE(D3D11_QUERY_SO_STATISTICS) - TOSTR_CASE_STRINGIZE(D3D11_QUERY_SO_OVERFLOW_PREDICATE) - TOSTR_CASE_STRINGIZE(D3D11_QUERY_SO_STATISTICS_STREAM0) - TOSTR_CASE_STRINGIZE(D3D11_QUERY_SO_OVERFLOW_PREDICATE_STREAM0) - TOSTR_CASE_STRINGIZE(D3D11_QUERY_SO_STATISTICS_STREAM1) - TOSTR_CASE_STRINGIZE(D3D11_QUERY_SO_OVERFLOW_PREDICATE_STREAM1) - TOSTR_CASE_STRINGIZE(D3D11_QUERY_SO_STATISTICS_STREAM2) - TOSTR_CASE_STRINGIZE(D3D11_QUERY_SO_OVERFLOW_PREDICATE_STREAM2) - TOSTR_CASE_STRINGIZE(D3D11_QUERY_SO_STATISTICS_STREAM3) - TOSTR_CASE_STRINGIZE(D3D11_QUERY_SO_OVERFLOW_PREDICATE_STREAM3) - default: break; - } - - char tostrBuf[256] = {0}; - StringFormat::snprintf(tostrBuf, 255, "D3D11_QUERY<%d>", el); - - return tostrBuf; -} - -string ToStrHelper::Get(const D3D11_COUNTER &el) -{ - switch(el) - { - TOSTR_CASE_STRINGIZE(D3D11_COUNTER_DEVICE_DEPENDENT_0) - default: break; - } - - char tostrBuf[256] = {0}; - StringFormat::snprintf(tostrBuf, 255, "D3D11_COUNTER<%d>", el); - - return tostrBuf; -} - -string ToStrHelper::Get(const D3D11_MAP &el) -{ - switch(el) - { - TOSTR_CASE_STRINGIZE(D3D11_MAP_READ) - TOSTR_CASE_STRINGIZE(D3D11_MAP_WRITE) - TOSTR_CASE_STRINGIZE(D3D11_MAP_READ_WRITE) - TOSTR_CASE_STRINGIZE(D3D11_MAP_WRITE_DISCARD) - TOSTR_CASE_STRINGIZE(D3D11_MAP_WRITE_NO_OVERWRITE) - default: break; - } - - char tostrBuf[256] = {0}; - StringFormat::snprintf(tostrBuf, 255, "D3D11_MAP<%d>", el); - - return tostrBuf; -} - -string ToStrHelper::Get(const D3D11_PRIMITIVE_TOPOLOGY &el) -{ - switch(el) - { - case D3D11_PRIMITIVE_TOPOLOGY_POINTLIST: return "PointList"; - case D3D11_PRIMITIVE_TOPOLOGY_LINELIST: return "LineList"; - case D3D11_PRIMITIVE_TOPOLOGY_LINESTRIP: return "LineStrip"; - case D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST: return "TriangleList"; - case D3D11_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP: return "TriangleStrip"; - case D3D11_PRIMITIVE_TOPOLOGY_LINELIST_ADJ: return "LineListAdj"; - case D3D11_PRIMITIVE_TOPOLOGY_LINESTRIP_ADJ: return "LineStripAdj"; - case D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST_ADJ: return "TriangleListAdj"; - case D3D11_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP_ADJ: return "TriangleStripAdj"; - default: break; - } - - char tostrBuf[256] = {0}; - - if(el >= D3D11_PRIMITIVE_TOPOLOGY_1_CONTROL_POINT_PATCHLIST && - el <= D3D11_PRIMITIVE_TOPOLOGY_32_CONTROL_POINT_PATCHLIST) - { - StringFormat::snprintf(tostrBuf, 255, "Patchlist_%dCPs", - el - D3D11_PRIMITIVE_TOPOLOGY_1_CONTROL_POINT_PATCHLIST + 1); - } - else - { - StringFormat::snprintf(tostrBuf, 255, "D3D11_PRIMITIVE_TOPOLOGY<%d>", el); - } - - return tostrBuf; -} - -string ToStrHelper::Get(const D3D11_USAGE &el) -{ - switch(el) - { - TOSTR_CASE_STRINGIZE(D3D11_USAGE_DEFAULT) - TOSTR_CASE_STRINGIZE(D3D11_USAGE_IMMUTABLE) - TOSTR_CASE_STRINGIZE(D3D11_USAGE_DYNAMIC) - TOSTR_CASE_STRINGIZE(D3D11_USAGE_STAGING) - default: break; - } - - char tostrBuf[256] = {0}; - StringFormat::snprintf(tostrBuf, 255, "D3D11_USAGE<%d>", el); - - return tostrBuf; -} - -string ToStrHelper::Get(const D3D11_INPUT_CLASSIFICATION &el) -{ - switch(el) - { - TOSTR_CASE_STRINGIZE(D3D11_INPUT_PER_VERTEX_DATA) - TOSTR_CASE_STRINGIZE(D3D11_INPUT_PER_INSTANCE_DATA) - default: break; - } - - char tostrBuf[256] = {0}; - StringFormat::snprintf(tostrBuf, 255, "D3D11_INPUT_CLASSIFICATION<%d>", el); - - return tostrBuf; -} - -string ToStrHelper::Get(const D3D11_LOGIC_OP &el) -{ - switch(el) - { - case D3D11_LOGIC_OP_CLEAR: return "CLEAR"; - case D3D11_LOGIC_OP_SET: return "SET"; - case D3D11_LOGIC_OP_COPY: return "COPY"; - case D3D11_LOGIC_OP_COPY_INVERTED: return "COPY_INVERTED"; - case D3D11_LOGIC_OP_NOOP: return "NOOP"; - case D3D11_LOGIC_OP_INVERT: return "INVERT"; - case D3D11_LOGIC_OP_AND: return "AND"; - case D3D11_LOGIC_OP_NAND: return "NAND"; - case D3D11_LOGIC_OP_OR: return "OR"; - case D3D11_LOGIC_OP_NOR: return "NOR"; - case D3D11_LOGIC_OP_XOR: return "XOR"; - case D3D11_LOGIC_OP_EQUIV: return "EQUIV"; - case D3D11_LOGIC_OP_AND_REVERSE: return "AND_REVERSE"; - case D3D11_LOGIC_OP_AND_INVERTED: return "AND_INVERTED"; - case D3D11_LOGIC_OP_OR_REVERSE: return "OR_REVERSE"; - case D3D11_LOGIC_OP_OR_INVERTED: return "OR_INVERTED"; - default: break; - } - - char tostrBuf[256] = {0}; - StringFormat::snprintf(tostrBuf, 255, "D3D11_LOGIC_OP<%d>", el); - - return tostrBuf; -} - -// for HRESULT template <> -string ToStrHelper::Get(const long &el) +std::string DoStringise(const D3D11_BOX &el) { - HRESULT hr = (HRESULT)el; + return StringFormat::Fmt("BOX<%d,%d,%d,%d,%d,%d>", el.left, el.right, el.top, el.bottom, el.front, + el.back); +} - switch(hr) - { - case DXGI_ERROR_INVALID_CALL: return "HRESULT(DXGI_ERROR_INVALID_CALL)"; - case DXGI_ERROR_NOT_FOUND: return "HRESULT(DXGI_ERROR_NOT_FOUND)"; - case DXGI_ERROR_DEVICE_REMOVED: return "HRESULT(DXGI_ERROR_DEVICE_REMOVED)"; - case DXGI_ERROR_DEVICE_HUNG: return "HRESULT(DXGI_ERROR_DEVICE_HUNG)"; - case DXGI_ERROR_DEVICE_RESET: return "HRESULT(DXGI_ERROR_DEVICE_RESET)"; - case DXGI_ERROR_WAS_STILL_DRAWING: return "HRESULT(DXGI_ERROR_WAS_STILL_DRAWING)"; - case E_OUTOFMEMORY: return "HRESULT(E_OUTOFMEMORY)"; - case E_INVALIDARG: return "HRESULT(E_INVALIDARG)"; - case E_NOINTERFACE: return "HRESULT(E_NOINTERFACE)"; - case E_ABORT: return "HRESULT(E_ABORT)"; - case E_FAIL: return "HRESULT(E_FAIL)"; - } - - char tostrBuf[64] = {0}; - - StringFormat::snprintf(tostrBuf, 63, "HRESULT(0x%x)", el); - - return tostrBuf; +template <> +std::string DoStringise(const D3D11_VIEWPORT &el) +{ + return StringFormat::Fmt("Viewport<%.0fx%.0f+%.0f+%.0f z=%f->%f>", el.Width, el.Height, + el.TopLeftX, el.TopLeftY, el.MinDepth, el.MaxDepth); } \ No newline at end of file diff --git a/renderdoc/driver/d3d11/d3d11_common.h b/renderdoc/driver/d3d11/d3d11_common.h index 49eb424bf..9c59bf99f 100644 --- a/renderdoc/driver/d3d11/d3d11_common.h +++ b/renderdoc/driver/d3d11/d3d11_common.h @@ -477,3 +477,37 @@ enum D3D11ChunkType }; #pragma endregion Chunks + +DECLARE_REFLECTION_ENUM(D3D11_BIND_FLAG); +DECLARE_REFLECTION_ENUM(D3D11_CPU_ACCESS_FLAG); +DECLARE_REFLECTION_ENUM(D3D11_RESOURCE_MISC_FLAG); +DECLARE_REFLECTION_ENUM(D3D11_COLOR_WRITE_ENABLE); +DECLARE_REFLECTION_ENUM(D3D11_BUFFER_UAV_FLAG); +DECLARE_REFLECTION_ENUM(D3D11_DSV_FLAG); +DECLARE_REFLECTION_ENUM(D3D11_COPY_FLAGS); +DECLARE_REFLECTION_ENUM(D3D11_MAP_FLAG); +DECLARE_REFLECTION_ENUM(D3D11_CLEAR_FLAG); +DECLARE_REFLECTION_ENUM(D3D11_BUFFEREX_SRV_FLAG); +DECLARE_REFLECTION_ENUM(D3D11_TEXTURE_LAYOUT); +DECLARE_REFLECTION_ENUM(D3D11_DEPTH_WRITE_MASK); +DECLARE_REFLECTION_ENUM(D3D11_COMPARISON_FUNC); +DECLARE_REFLECTION_ENUM(D3D11_STENCIL_OP); +DECLARE_REFLECTION_ENUM(D3D11_BLEND); +DECLARE_REFLECTION_ENUM(D3D11_BLEND_OP); +DECLARE_REFLECTION_ENUM(D3D11_CULL_MODE); +DECLARE_REFLECTION_ENUM(D3D11_FILL_MODE); +DECLARE_REFLECTION_ENUM(D3D11_CONSERVATIVE_RASTERIZATION_MODE); +DECLARE_REFLECTION_ENUM(D3D11_TEXTURE_ADDRESS_MODE); +DECLARE_REFLECTION_ENUM(D3D11_FILTER); +DECLARE_REFLECTION_ENUM(D3D11_SRV_DIMENSION); +DECLARE_REFLECTION_ENUM(D3D11_RTV_DIMENSION); +DECLARE_REFLECTION_ENUM(D3D11_UAV_DIMENSION); +DECLARE_REFLECTION_ENUM(D3D11_DSV_DIMENSION); +DECLARE_REFLECTION_ENUM(D3D11_CONTEXT_TYPE); +DECLARE_REFLECTION_ENUM(D3D11_QUERY); +DECLARE_REFLECTION_ENUM(D3D11_COUNTER); +DECLARE_REFLECTION_ENUM(D3D11_MAP); +DECLARE_REFLECTION_ENUM(D3D11_PRIMITIVE_TOPOLOGY); +DECLARE_REFLECTION_ENUM(D3D11_USAGE); +DECLARE_REFLECTION_ENUM(D3D11_INPUT_CLASSIFICATION); +DECLARE_REFLECTION_ENUM(D3D11_LOGIC_OP); \ No newline at end of file diff --git a/renderdoc/driver/d3d11/d3d11_context.cpp b/renderdoc/driver/d3d11/d3d11_context.cpp index 0e752a96c..7c31de16b 100644 --- a/renderdoc/driver/d3d11/d3d11_context.cpp +++ b/renderdoc/driver/d3d11/d3d11_context.cpp @@ -1668,7 +1668,7 @@ HRESULT STDMETHODCALLTYPE WrappedID3D11DeviceContext::QueryInterface(REFIID riid } else { - string guid = ToStr::Get(riid); + string guid = ToStr(riid); RDCWARN("Querying ID3D11DeviceContext for interface: %s", guid.c_str()); } diff --git a/renderdoc/driver/d3d11/d3d11_context1_wrap.cpp b/renderdoc/driver/d3d11/d3d11_context1_wrap.cpp index 6e9e4adc6..aae947266 100644 --- a/renderdoc/driver/d3d11/d3d11_context1_wrap.cpp +++ b/renderdoc/driver/d3d11/d3d11_context1_wrap.cpp @@ -469,8 +469,8 @@ bool WrappedID3D11DeviceContext::Serialise_ClearView(ID3D11View *pView, const FL if(m_State == READING) { AddEvent(desc); - string name = "ClearView(" + ToStr::Get(Color[0]) + ", " + ToStr::Get(Color[1]) + ", " + - ToStr::Get(Color[2]) + ", " + ToStr::Get(Color[3]) + ", " + ToStr::Get(numRects) + + string name = "ClearView(" + ToStr(Color[0]) + ", " + ToStr(Color[1]) + ", " + ToStr(Color[2]) + + ", " + ToStr(Color[3]) + ", " + ToStr(numRects) + " rects" ")"; @@ -1941,7 +1941,7 @@ bool WrappedID3D11DeviceContext::Serialise_DiscardView1(ID3D11View *pResourceVie if(m_State == READING) { AddEvent(desc); - string name = "DiscardView1(" + ToStr::Get(numRects) + " rects)"; + string name = "DiscardView1(" + ToStr(numRects) + " rects)"; DrawcallDescription draw; diff --git a/renderdoc/driver/d3d11/d3d11_context_wrap.cpp b/renderdoc/driver/d3d11/d3d11_context_wrap.cpp index 9c4fe8bf4..d20902c33 100644 --- a/renderdoc/driver/d3d11/d3d11_context_wrap.cpp +++ b/renderdoc/driver/d3d11/d3d11_context_wrap.cpp @@ -2427,7 +2427,7 @@ bool WrappedID3D11DeviceContext::Serialise_RSSetViewports(UINT NumViewports_, if(pViewports) view = pViewports[i]; - m_pSerialiser->SerialisePODArray<6>((string("Viewport[") + ToStr::Get(i) + "]").c_str(), + m_pSerialiser->SerialisePODArray<6>((string("Viewport[") + ToStr(i) + "]").c_str(), (FLOAT *)&view); views[i] = view; @@ -3773,8 +3773,8 @@ bool WrappedID3D11DeviceContext::Serialise_DrawIndexedInstanced(UINT IndexCountP if(m_State == READING) { AddEvent(desc); - string name = "DrawIndexedInstanced(" + ToStr::Get(IndexCountPerInstance) + ", " + - ToStr::Get(InstanceCount) + ")"; + string name = + "DrawIndexedInstanced(" + ToStr(IndexCountPerInstance) + ", " + ToStr(InstanceCount) + ")"; DrawcallDescription draw; draw.name = name; @@ -3842,8 +3842,8 @@ bool WrappedID3D11DeviceContext::Serialise_DrawInstanced(UINT VertexCountPerInst if(m_State == READING) { AddEvent(desc); - string name = "DrawInstanced(" + ToStr::Get(VertexCountPerInstance) + ", " + - ToStr::Get(InstanceCount) + ")"; + string name = + "DrawInstanced(" + ToStr(VertexCountPerInstance) + ", " + ToStr(InstanceCount) + ")"; DrawcallDescription draw; draw.name = name; @@ -3905,7 +3905,7 @@ bool WrappedID3D11DeviceContext::Serialise_DrawIndexed(UINT IndexCount_, UINT St if(m_State == READING) { AddEvent(desc); - string name = "DrawIndexed(" + ToStr::Get(IndexCount) + ")"; + string name = "DrawIndexed(" + ToStr(IndexCount) + ")"; DrawcallDescription draw; draw.name = name; @@ -3962,7 +3962,7 @@ bool WrappedID3D11DeviceContext::Serialise_Draw(UINT VertexCount_, UINT StartVer if(m_State == READING) { AddEvent(desc); - string name = "Draw(" + ToStr::Get(VertexCount) + ")"; + string name = "Draw(" + ToStr(VertexCount) + ")"; DrawcallDescription draw; draw.name = name; @@ -4064,7 +4064,7 @@ bool WrappedID3D11DeviceContext::Serialise_DrawAuto() if(m_State == READING) { AddEvent(desc); - string name = "DrawAuto(<" + ToStr::Get(numVerts) + ">)"; + string name = "DrawAuto(<" + ToStr(numVerts) + ">)"; DrawcallDescription draw; draw.name = name; @@ -4156,8 +4156,8 @@ bool WrappedID3D11DeviceContext::Serialise_DrawIndexedInstancedIndirect(ID3D11Bu RecordDrawStats(true, true, draw.numInstances); - name = "DrawIndexedInstancedIndirect(<" + ToStr::Get(draw.numIndices) + ", " + - ToStr::Get(draw.numInstances) + ">)"; + name = "DrawIndexedInstancedIndirect(<" + ToStr(draw.numIndices) + ", " + + ToStr(draw.numInstances) + ">)"; } else { @@ -4266,8 +4266,7 @@ bool WrappedID3D11DeviceContext::Serialise_DrawInstancedIndirect(ID3D11Buffer *p draw.vertexOffset = uargs[2]; draw.instanceOffset = uargs[3]; - name = - "DrawInstancedIndirect(<" + ToStr::Get(uargs[0]) + ", " + ToStr::Get(uargs[1]) + ">)"; + name = "DrawInstancedIndirect(<" + ToStr(uargs[0]) + ", " + ToStr(uargs[1]) + ">)"; RecordDrawStats(true, true, draw.numInstances); } @@ -4863,7 +4862,7 @@ bool WrappedID3D11DeviceContext::Serialise_ExecuteCommandList(ID3D11CommandList if(m_State == READING) { - string name = "ExecuteCommandList(" + ToStr::Get(cmdList) + ")"; + string name = "ExecuteCommandList(" + ToStr(cmdList) + ")"; DrawcallDescription draw; draw.name = name; @@ -4968,8 +4967,8 @@ bool WrappedID3D11DeviceContext::Serialise_Dispatch(UINT ThreadGroupCountX_, if(m_State == READING) { AddEvent(desc); - string name = "Dispatch(" + ToStr::Get(ThreadGroupCountX) + ", " + - ToStr::Get(ThreadGroupCountY) + ", " + ToStr::Get(ThreadGroupCountZ) + ")"; + string name = "Dispatch(" + ToStr(ThreadGroupCountX) + ", " + ToStr(ThreadGroupCountY) + ", " + + ToStr(ThreadGroupCountZ) + ")"; DrawcallDescription draw; draw.name = name; @@ -5065,8 +5064,8 @@ bool WrappedID3D11DeviceContext::Serialise_DispatchIndirect(ID3D11Buffer *pBuffe draw.dispatchDimension[1] = uargs[1]; draw.dispatchDimension[2] = uargs[2]; - name = "DispatchIndirect(<" + ToStr::Get(uargs[0]) + ", " + ToStr::Get(uargs[1]) + +", " + - ToStr::Get(uargs[2]) + ">)"; + name = "DispatchIndirect(<" + ToStr(uargs[0]) + ", " + ToStr(uargs[1]) + +", " + + ToStr(uargs[2]) + ">)"; } else { @@ -5145,7 +5144,7 @@ bool WrappedID3D11DeviceContext::Serialise_FinishCommandList(BOOL RestoreDeferre if(m_State == READING) { AddEvent(desc); - string name = "FinishCommandList() -> " + ToStr::Get(cmdList); + string name = "FinishCommandList() -> " + ToStr(cmdList); DrawcallDescription draw; draw.name = name; @@ -5350,9 +5349,9 @@ bool WrappedID3D11DeviceContext::Serialise_CopySubresourceRegion( std::string srcName = GetDebugName(m_pDevice->GetResourceManager()->GetLiveResource(Source)); if(dstName == "") - dstName = ToStr::Get(Destination); + dstName = ToStr(Destination); if(srcName == "") - srcName = ToStr::Get(Source); + srcName = ToStr(Source); AddEvent(desc); string name = "CopySubresourceRegion(" + dstName + ", " + srcName + ")"; @@ -5499,9 +5498,9 @@ bool WrappedID3D11DeviceContext::Serialise_CopyResource(ID3D11Resource *pDstReso std::string srcName = GetDebugName(m_pDevice->GetResourceManager()->GetLiveResource(Source)); if(dstName == "") - dstName = ToStr::Get(Destination); + dstName = ToStr(Destination); if(srcName == "") - srcName = ToStr::Get(Source); + srcName = ToStr(Source); AddEvent(desc); string name = "CopyResource(" + dstName + ", " + srcName + ")"; @@ -6034,9 +6033,9 @@ bool WrappedID3D11DeviceContext::Serialise_ResolveSubresource(ID3D11Resource *pD GetDebugName(m_pDevice->GetResourceManager()->GetLiveResource(SourceResource)); if(dstName == "") - dstName = ToStr::Get(DestResource); + dstName = ToStr(DestResource); if(srcName == "") - srcName = ToStr::Get(SourceResource); + srcName = ToStr(SourceResource); AddEvent(desc); string name = "ResolveSubresource(" + dstName + ", " + srcName + ")"; @@ -6193,7 +6192,7 @@ bool WrappedID3D11DeviceContext::Serialise_GenerateMips(ID3D11ShaderResourceView std::string resName = GetDebugName(m_pDevice->GetResourceManager()->GetLiveResource(id)); if(resName == "") - resName = ToStr::Get(id); + resName = ToStr(id); AddEvent(desc); string name = "GenerateMips(" + resName + ")"; @@ -6349,8 +6348,8 @@ bool WrappedID3D11DeviceContext::Serialise_ClearRenderTargetView( if(m_State == READING) { AddEvent(desc); - string name = "ClearRenderTargetView(" + ToStr::Get(Color[0]) + ", " + ToStr::Get(Color[1]) + - ", " + ToStr::Get(Color[2]) + ", " + ToStr::Get(Color[3]) + ")"; + string name = "ClearRenderTargetView(" + ToStr(Color[0]) + ", " + ToStr(Color[1]) + ", " + + ToStr(Color[2]) + ", " + ToStr(Color[3]) + ")"; DrawcallDescription draw; draw.name = name; @@ -6514,9 +6513,8 @@ bool WrappedID3D11DeviceContext::Serialise_ClearUnorderedAccessViewUint( if(m_State == READING) { AddEvent(desc); - string name = "ClearUnorderedAccessViewUint(" + ToStr::Get(Values[0]) + ", " + - ToStr::Get(Values[1]) + ", " + ToStr::Get(Values[2]) + ", " + - ToStr::Get(Values[3]) + ")"; + string name = "ClearUnorderedAccessViewUint(" + ToStr(Values[0]) + ", " + ToStr(Values[1]) + + ", " + ToStr(Values[2]) + ", " + ToStr(Values[3]) + ")"; DrawcallDescription draw; draw.name = name; @@ -6674,9 +6672,8 @@ bool WrappedID3D11DeviceContext::Serialise_ClearUnorderedAccessViewFloat( if(m_State == READING) { AddEvent(desc); - string name = "ClearUnorderedAccessViewFloat(" + ToStr::Get(Values[0]) + ", " + - ToStr::Get(Values[1]) + ", " + ToStr::Get(Values[2]) + ", " + - ToStr::Get(Values[3]) + ", " + ")"; + string name = "ClearUnorderedAccessViewFloat(" + ToStr(Values[0]) + ", " + ToStr(Values[1]) + + ", " + ToStr(Values[2]) + ", " + ToStr(Values[3]) + ", " + ")"; DrawcallDescription draw; draw.name = (name); @@ -6821,7 +6818,7 @@ bool WrappedID3D11DeviceContext::Serialise_ClearDepthStencilView( if(m_State == READING) { AddEvent(desc); - string name = "ClearDepthStencilView(" + ToStr::Get(Depth) + ", " + ToStr::Get(Stencil) + ")"; + string name = "ClearDepthStencilView(" + ToStr(Depth) + ", " + ToStr(Stencil) + ")"; DrawcallDescription draw; draw.name = name; @@ -7422,7 +7419,7 @@ bool WrappedID3D11DeviceContext::Serialise_Map(ID3D11Resource *pResource, UINT S if(FAILED(hr)) { - RDCERR("Failed to map while getting initial states %08x", hr); + RDCERR("Failed to map while getting initial states HRESULT: %s", ToStr(hr).c_str()); } else { @@ -7800,7 +7797,7 @@ bool WrappedID3D11DeviceContext::Serialise_Unmap(ID3D11Resource *pResource, UINT if(FAILED(hr)) { - RDCERR("Failed to create temp Unmap() buffer %08x", hr); + RDCERR("Failed to create temp Unmap() buffer HRESULT: %s", ToStr(hr).c_str()); } else { @@ -7824,7 +7821,7 @@ bool WrappedID3D11DeviceContext::Serialise_Unmap(ID3D11Resource *pResource, UINT if(FAILED(hr)) { - RDCERR("Failed to map resource, HRESULT: 0x%08x", hr); + RDCERR("Failed to map resource, HRESULT: %s", ToStr(hr).c_str()); } else { diff --git a/renderdoc/driver/d3d11/d3d11_counters.cpp b/renderdoc/driver/d3d11/d3d11_counters.cpp index 6cff515af..ba190d8ca 100644 --- a/renderdoc/driver/d3d11/d3d11_counters.cpp +++ b/renderdoc/driver/d3d11/d3d11_counters.cpp @@ -484,14 +484,14 @@ vector D3D11DebugManager::FetchCounters(const vector hr = m_pDevice->CreateQuery(&disjointdesc, &disjoint); if(FAILED(hr)) { - RDCERR("Failed to create disjoint query %08x", hr); + RDCERR("Failed to create disjoint query HRESULT: %s", ToStr(hr).c_str()); return ret; } hr = m_pDevice->CreateQuery(&qdesc, &start); if(FAILED(hr)) { - RDCERR("Failed to create start query %08x", hr); + RDCERR("Failed to create start query HRESULT: %s", ToStr(hr).c_str()); return ret; } diff --git a/renderdoc/driver/d3d11/d3d11_debug.cpp b/renderdoc/driver/d3d11/d3d11_debug.cpp index e7229ad7c..26f3ab4e6 100644 --- a/renderdoc/driver/d3d11/d3d11_debug.cpp +++ b/renderdoc/driver/d3d11/d3d11_debug.cpp @@ -65,7 +65,7 @@ struct D3DBlobShaderCallbacks if(FAILED(hr)) { - RDCERR("Couldn't create blob of size %u from shadercache: %08x", size, hr); + RDCERR("Couldn't create blob of size %u from shadercache: %s", size, ToStr(ret).c_str()); return false; } @@ -330,7 +330,7 @@ ID3D11VertexShader *D3D11DebugManager::MakeVShader(const char *source, const cha if(FAILED(hr)) { - RDCERR("Couldn't create vertex shader for %s %08x", entry, hr); + RDCERR("Couldn't create vertex shader for %s %s", entry, ToStr(ret).c_str()); SAFE_RELEASE(byteBlob); @@ -343,7 +343,7 @@ ID3D11VertexShader *D3D11DebugManager::MakeVShader(const char *source, const cha if(FAILED(hr)) { - RDCERR("Couldn't create input layout for %s %08x", entry, hr); + RDCERR("Couldn't create input layout for %s %s", entry, ToStr(ret).c_str()); } } @@ -379,7 +379,7 @@ ID3D11GeometryShader *D3D11DebugManager::MakeGShader(const char *source, const c if(FAILED(hr)) { - RDCERR("Couldn't create geometry shader for %s %08x", entry, hr); + RDCERR("Couldn't create geometry shader for %s %s", entry, ToStr(hr).c_str()); return NULL; } @@ -407,7 +407,7 @@ ID3D11PixelShader *D3D11DebugManager::MakePShader(const char *source, const char if(FAILED(hr)) { - RDCERR("Couldn't create pixel shader for %s %08x", entry, hr); + RDCERR("Couldn't create pixel shader for %s %s", entry, ToStr(hr).c_str()); return NULL; } @@ -435,7 +435,7 @@ ID3D11ComputeShader *D3D11DebugManager::MakeCShader(const char *source, const ch if(FAILED(hr)) { - RDCERR("Couldn't create compute shader for %s %08x", entry, hr); + RDCERR("Couldn't create compute shader for %s %s", entry, ToStr(hr).c_str()); return NULL; } @@ -586,7 +586,7 @@ ID3D11Buffer *D3D11DebugManager::MakeCBuffer(UINT size) if(FAILED(hr)) { - RDCERR("Failed to create CBuffer %08x", hr); + RDCERR("Failed to create CBuffer HRESULT: %s", ToStr(hr).c_str()); return NULL; } @@ -601,7 +601,7 @@ void D3D11DebugManager::FillCBuffer(ID3D11Buffer *buf, const void *data, size_t if(FAILED(hr)) { - RDCERR("Can't fill cbuffer %08x", hr); + RDCERR("Can't fill cbuffer HRESULT: %s", ToStr(hr).c_str()); } else { @@ -739,9 +739,9 @@ bool D3D11DebugManager::InitDebugRendering() // float, uint, sint for(int i = 0; i < 3; i++) { - string hlsl = string("#define SHADER_RESTYPE ") + ToStr::Get(t) + "\n"; - hlsl += string("#define UINT_TEX ") + (i == 1 ? "1" : "0") + "\n"; - hlsl += string("#define SINT_TEX ") + (i == 2 ? "1" : "0") + "\n"; + string hlsl = std::string("#define SHADER_RESTYPE ") + ToStr(t) + "\n"; + hlsl += std::string("#define UINT_TEX ") + (i == 1 ? "1" : "0") + "\n"; + hlsl += std::string("#define SINT_TEX ") + (i == 2 ? "1" : "0") + "\n"; hlsl += histogramhlsl; m_DebugRender.TileMinMaxCS[t][i] = @@ -793,7 +793,7 @@ bool D3D11DebugManager::InitDebugRendering() if(FAILED(hr)) { - RDCERR("Failed to create default blendstate %08x", hr); + RDCERR("Failed to create default blendstate HRESULT: %s", ToStr(hr).c_str()); } blendDesc.RenderTarget[0].BlendEnable = FALSE; @@ -803,7 +803,7 @@ bool D3D11DebugManager::InitDebugRendering() if(FAILED(hr)) { - RDCERR("Failed to create nop blendstate %08x", hr); + RDCERR("Failed to create nop blendstate HRESULT: %s", ToStr(hr).c_str()); } D3D11_RASTERIZER_DESC rastDesc; @@ -817,7 +817,7 @@ bool D3D11DebugManager::InitDebugRendering() if(FAILED(hr)) { - RDCERR("Failed to create default rasterizer state %08x", hr); + RDCERR("Failed to create default rasterizer state HRESULT: %s", ToStr(hr).c_str()); } D3D11_SAMPLER_DESC sampDesc; @@ -834,7 +834,7 @@ bool D3D11DebugManager::InitDebugRendering() if(FAILED(hr)) { - RDCERR("Failed to create linear sampler state %08x", hr); + RDCERR("Failed to create linear sampler state HRESULT: %s", ToStr(hr).c_str()); } sampDesc.Filter = D3D11_FILTER_MIN_MAG_MIP_POINT; @@ -843,7 +843,7 @@ bool D3D11DebugManager::InitDebugRendering() if(FAILED(hr)) { - RDCERR("Failed to create point sampler state %08x", hr); + RDCERR("Failed to create point sampler state HRESULT: %s", ToStr(hr).c_str()); } { @@ -865,7 +865,7 @@ bool D3D11DebugManager::InitDebugRendering() if(FAILED(hr)) { - RDCERR("Failed to create no-depth depthstencilstate %08x", hr); + RDCERR("Failed to create no-depth depthstencilstate HRESULT: %s", ToStr(hr).c_str()); } desc.DepthEnable = TRUE; @@ -876,7 +876,7 @@ bool D3D11DebugManager::InitDebugRendering() if(FAILED(hr)) { - RDCERR("Failed to create less-equal depthstencilstate %08x", hr); + RDCERR("Failed to create less-equal depthstencilstate HRESULT: %s", ToStr(hr).c_str()); } desc.DepthFunc = D3D11_COMPARISON_ALWAYS; @@ -886,7 +886,7 @@ bool D3D11DebugManager::InitDebugRendering() if(FAILED(hr)) { - RDCERR("Failed to create always pass depthstencilstate %08x", hr); + RDCERR("Failed to create always pass depthstencilstate HRESULT: %s", ToStr(hr).c_str()); } desc.DepthEnable = FALSE; @@ -898,7 +898,7 @@ bool D3D11DebugManager::InitDebugRendering() if(FAILED(hr)) { - RDCERR("Failed to create nop depthstencilstate %08x", hr); + RDCERR("Failed to create nop depthstencilstate HRESULT: %s", ToStr(hr).c_str()); } desc.StencilReadMask = desc.StencilWriteMask = 0xff; @@ -914,7 +914,8 @@ bool D3D11DebugManager::InitDebugRendering() if(FAILED(hr)) { - RDCERR("Failed to create always pass stencil increment depthstencilstate %08x", hr); + RDCERR("Failed to create always pass stencil increment depthstencilstate HRESULT: %s", + ToStr(hr).c_str()); } desc.DepthEnable = TRUE; @@ -926,7 +927,8 @@ bool D3D11DebugManager::InitDebugRendering() if(FAILED(hr)) { - RDCERR("Failed to create always pass stencil increment depthstencilstate %08x", hr); + RDCERR("Failed to create always pass stencil increment depthstencilstate HRESULT: %s", + ToStr(hr).c_str()); } } @@ -953,7 +955,7 @@ bool D3D11DebugManager::InitDebugRendering() if(FAILED(hr)) { - RDCERR("Failed to create pick tex %08x", hr); + RDCERR("Failed to create pick tex HRESULT: %s", ToStr(hr).c_str()); } else { @@ -961,7 +963,7 @@ bool D3D11DebugManager::InitDebugRendering() if(FAILED(hr)) { - RDCERR("Failed to create pick rt %08x", hr); + RDCERR("Failed to create pick rt HRESULT: %s", ToStr(hr).c_str()); } SAFE_RELEASE(pickTex); @@ -986,7 +988,7 @@ bool D3D11DebugManager::InitDebugRendering() if(FAILED(hr)) { - RDCERR("Failed to create pick stage tex %08x", hr); + RDCERR("Failed to create pick stage tex HRESULT: %s", ToStr(hr).c_str()); } } @@ -1010,7 +1012,7 @@ bool D3D11DebugManager::InitDebugRendering() if(FAILED(hr)) { - RDCERR("Failed to create tile result buffer %08x", hr); + RDCERR("Failed to create tile result buffer HRESULT: %s", ToStr(hr).c_str()); } D3D11_SHADER_RESOURCE_VIEW_DESC srvDesc; @@ -1023,21 +1025,21 @@ bool D3D11DebugManager::InitDebugRendering() &m_DebugRender.tileResultSRV[0]); if(FAILED(hr)) - RDCERR("Failed to create tile result SRV 0 %08x", hr); + RDCERR("Failed to create tile result SRV 0 HRESULT: %s", ToStr(hr).c_str()); srvDesc.Format = DXGI_FORMAT_R32G32B32A32_UINT; hr = m_pDevice->CreateShaderResourceView(m_DebugRender.tileResultBuff, &srvDesc, &m_DebugRender.tileResultSRV[1]); if(FAILED(hr)) - RDCERR("Failed to create tile result SRV 1 %08x", hr); + RDCERR("Failed to create tile result SRV 1 HRESULT: %s", ToStr(hr).c_str()); srvDesc.Format = DXGI_FORMAT_R32G32B32A32_SINT; hr = m_pDevice->CreateShaderResourceView(m_DebugRender.tileResultBuff, &srvDesc, &m_DebugRender.tileResultSRV[2]); if(FAILED(hr)) - RDCERR("Failed to create tile result SRV 2 %08x", hr); + RDCERR("Failed to create tile result SRV 2 HRESULT: %s", ToStr(hr).c_str()); D3D11_UNORDERED_ACCESS_VIEW_DESC uavDesc; @@ -1051,21 +1053,21 @@ bool D3D11DebugManager::InitDebugRendering() &m_DebugRender.tileResultUAV[0]); if(FAILED(hr)) - RDCERR("Failed to create tile result UAV 0 %08x", hr); + RDCERR("Failed to create tile result UAV 0 HRESULT: %s", ToStr(hr).c_str()); uavDesc.Format = DXGI_FORMAT_R32G32B32A32_UINT; hr = m_pDevice->CreateUnorderedAccessView(m_DebugRender.tileResultBuff, &uavDesc, &m_DebugRender.tileResultUAV[1]); if(FAILED(hr)) - RDCERR("Failed to create tile result UAV 1 %08x", hr); + RDCERR("Failed to create tile result UAV 1 HRESULT: %s", ToStr(hr).c_str()); uavDesc.Format = DXGI_FORMAT_R32G32B32A32_SINT; hr = m_pDevice->CreateUnorderedAccessView(m_DebugRender.tileResultBuff, &uavDesc, &m_DebugRender.tileResultUAV[2]); if(FAILED(hr)) - RDCERR("Failed to create tile result UAV 2 %08x", hr); + RDCERR("Failed to create tile result UAV 2 HRESULT: %s", ToStr(hr).c_str()); uavDesc.Format = DXGI_FORMAT_R32_UINT; uavDesc.Buffer.NumElements = HGRAM_NUM_BUCKETS; @@ -1074,13 +1076,13 @@ bool D3D11DebugManager::InitDebugRendering() hr = m_pDevice->CreateBuffer(&bDesc, NULL, &m_DebugRender.histogramBuff); if(FAILED(hr)) - RDCERR("Failed to create histogram buff %08x", hr); + RDCERR("Failed to create histogram buff HRESULT: %s", ToStr(hr).c_str()); hr = m_pDevice->CreateUnorderedAccessView(m_DebugRender.histogramBuff, &uavDesc, &m_DebugRender.histogramUAV); if(FAILED(hr)) - RDCERR("Failed to create histogram UAV %08x", hr); + RDCERR("Failed to create histogram UAV HRESULT: %s", ToStr(hr).c_str()); bDesc.BindFlags = 0; bDesc.CPUAccessFlags = D3D11_CPU_ACCESS_READ; @@ -1089,7 +1091,7 @@ bool D3D11DebugManager::InitDebugRendering() hr = m_pDevice->CreateBuffer(&bDesc, NULL, &m_DebugRender.histogramStageBuff); if(FAILED(hr)) - RDCERR("Failed to create histogram stage buff %08x", hr); + RDCERR("Failed to create histogram stage buff HRESULT: %s", ToStr(hr).c_str()); bDesc.BindFlags = D3D11_BIND_UNORDERED_ACCESS; bDesc.CPUAccessFlags = 0; @@ -1099,7 +1101,7 @@ bool D3D11DebugManager::InitDebugRendering() hr = m_pDevice->CreateBuffer(&bDesc, NULL, &m_DebugRender.resultBuff); if(FAILED(hr)) - RDCERR("Failed to create result buff %08x", hr); + RDCERR("Failed to create result buff HRESULT: %s", ToStr(hr).c_str()); uavDesc.Format = DXGI_FORMAT_R32G32B32A32_FLOAT; uavDesc.Buffer.NumElements = 2; @@ -1108,21 +1110,21 @@ bool D3D11DebugManager::InitDebugRendering() &m_DebugRender.resultUAV[0]); if(FAILED(hr)) - RDCERR("Failed to create result UAV 0 %08x", hr); + RDCERR("Failed to create result UAV 0 HRESULT: %s", ToStr(hr).c_str()); uavDesc.Format = DXGI_FORMAT_R32G32B32A32_UINT; hr = m_pDevice->CreateUnorderedAccessView(m_DebugRender.resultBuff, &uavDesc, &m_DebugRender.resultUAV[1]); if(FAILED(hr)) - RDCERR("Failed to create result UAV 1 %08x", hr); + RDCERR("Failed to create result UAV 1 HRESULT: %s", ToStr(hr).c_str()); uavDesc.Format = DXGI_FORMAT_R32G32B32A32_SINT; hr = m_pDevice->CreateUnorderedAccessView(m_DebugRender.resultBuff, &uavDesc, &m_DebugRender.resultUAV[2]); if(FAILED(hr)) - RDCERR("Failed to create result UAV 2 %08x", hr); + RDCERR("Failed to create result UAV 2 HRESULT: %s", ToStr(hr).c_str()); bDesc.BindFlags = 0; bDesc.CPUAccessFlags = D3D11_CPU_ACCESS_READ; @@ -1131,7 +1133,7 @@ bool D3D11DebugManager::InitDebugRendering() hr = m_pDevice->CreateBuffer(&bDesc, NULL, &m_DebugRender.resultStageBuff); if(FAILED(hr)) - RDCERR("Failed to create result stage buff %08x", hr); + RDCERR("Failed to create result stage buff HRESULT: %s", ToStr(hr).c_str()); bDesc.ByteWidth = sizeof(Vec4f) * DebugRenderData::maxMeshPicks; bDesc.BindFlags = D3D11_BIND_UNORDERED_ACCESS; @@ -1143,7 +1145,7 @@ bool D3D11DebugManager::InitDebugRendering() hr = m_pDevice->CreateBuffer(&bDesc, NULL, &m_DebugRender.PickResultBuf); if(FAILED(hr)) - RDCERR("Failed to create mesh pick result buff %08x", hr); + RDCERR("Failed to create mesh pick result buff HRESULT: %s", ToStr(hr).c_str()); uavDesc.ViewDimension = D3D11_UAV_DIMENSION_BUFFER; uavDesc.Format = DXGI_FORMAT_UNKNOWN; @@ -1155,7 +1157,7 @@ bool D3D11DebugManager::InitDebugRendering() &m_DebugRender.PickResultUAV); if(FAILED(hr)) - RDCERR("Failed to create mesh pick result UAV %08x", hr); + RDCERR("Failed to create mesh pick result UAV HRESULT: %s", ToStr(hr).c_str()); // created/sized on demand m_DebugRender.PickIBBuf = m_DebugRender.PickVBBuf = NULL; @@ -1177,7 +1179,7 @@ bool D3D11DebugManager::InitDebugRendering() hr = m_pDevice->CreateBuffer(&desc, NULL, &m_DebugRender.StageBuffer); if(FAILED(hr)) - RDCERR("Failed to create map staging buffer %08x", hr); + RDCERR("Failed to create map staging buffer HRESULT: %s", ToStr(hr).c_str()); } return true; @@ -1222,7 +1224,7 @@ bool D3D11DebugManager::InitStreamOut() m_SOStatsQueries.push_back(NULL); hr = m_pDevice->CreateQuery(&qdesc, &m_SOStatsQueries[0]); if(FAILED(hr)) - RDCERR("Failed to create m_SOStatsQuery %08x", hr); + RDCERR("Failed to create m_SOStatsQuery HRESULT: %s", ToStr(hr).c_str()); { D3D11_RASTERIZER_DESC desc; @@ -1239,28 +1241,28 @@ bool D3D11DebugManager::InitStreamOut() hr = m_pDevice->CreateRasterizerState(&desc, &m_WireframeHelpersRS); if(FAILED(hr)) - RDCERR("Failed to create m_WireframeHelpersRS %08x", hr); + RDCERR("Failed to create m_WireframeHelpersRS HRESULT: %s", ToStr(hr).c_str()); desc.FrontCounterClockwise = TRUE; desc.CullMode = D3D11_CULL_FRONT; hr = m_pDevice->CreateRasterizerState(&desc, &m_WireframeHelpersCullCCWRS); if(FAILED(hr)) - RDCERR("Failed to create m_WireframeHelpersCullCCWRS %08x", hr); + RDCERR("Failed to create m_WireframeHelpersCullCCWRS HRESULT: %s", ToStr(hr).c_str()); desc.FrontCounterClockwise = FALSE; desc.CullMode = D3D11_CULL_FRONT; hr = m_pDevice->CreateRasterizerState(&desc, &m_WireframeHelpersCullCWRS); if(FAILED(hr)) - RDCERR("Failed to create m_WireframeHelpersCullCCWRS %08x", hr); + RDCERR("Failed to create m_WireframeHelpersCullCCWRS HRESULT: %s", ToStr(hr).c_str()); desc.FillMode = D3D11_FILL_SOLID; desc.CullMode = D3D11_CULL_NONE; hr = m_pDevice->CreateRasterizerState(&desc, &m_SolidHelpersRS); if(FAILED(hr)) - RDCERR("Failed to create m_SolidHelpersRS %08x", hr); + RDCERR("Failed to create m_SolidHelpersRS HRESULT: %s", ToStr(hr).c_str()); } { @@ -1280,7 +1282,7 @@ bool D3D11DebugManager::InitStreamOut() hr = m_pDevice->CreateBlendState(&desc, &m_WireframeHelpersBS); if(FAILED(hr)) - RDCERR("Failed to create m_WireframeHelpersRS %08x", hr); + RDCERR("Failed to create m_WireframeHelpersRS HRESULT: %s", ToStr(hr).c_str()); } { @@ -1302,7 +1304,7 @@ bool D3D11DebugManager::InitStreamOut() hr = m_pDevice->CreateBuffer(&bdesc, &data, &m_AxisHelper); if(FAILED(hr)) - RDCERR("Failed to create m_AxisHelper %08x", hr); + RDCERR("Failed to create m_AxisHelper HRESULT: %s", ToStr(hr).c_str()); } { @@ -1339,7 +1341,7 @@ bool D3D11DebugManager::InitStreamOut() hr = m_pDevice->CreateBuffer(&bdesc, &data, &m_FrustumHelper); if(FAILED(hr)) - RDCERR("Failed to create m_FrustumHelper %08x", hr); + RDCERR("Failed to create m_FrustumHelper HRESULT: %s", ToStr(hr).c_str()); } { @@ -1353,7 +1355,7 @@ bool D3D11DebugManager::InitStreamOut() hr = m_pDevice->CreateBuffer(&bdesc, NULL, &m_TriHighlightHelper); if(FAILED(hr)) - RDCERR("Failed to create m_TriHighlightHelper %08x", hr); + RDCERR("Failed to create m_TriHighlightHelper HRESULT: %s", ToStr(hr).c_str()); } return true; @@ -1372,14 +1374,14 @@ void D3D11DebugManager::CreateSOBuffers() hr = m_pDevice->CreateBuffer(&bufferDesc, NULL, &m_SOBuffer); if(FAILED(hr)) - RDCERR("Failed to create m_SOBuffer %08x", hr); + RDCERR("Failed to create m_SOBuffer HRESULT: %s", ToStr(hr).c_str()); bufferDesc.Usage = D3D11_USAGE_STAGING; bufferDesc.BindFlags = 0; bufferDesc.CPUAccessFlags = D3D11_CPU_ACCESS_READ; hr = m_pDevice->CreateBuffer(&bufferDesc, NULL, &m_SOStagingBuffer); if(FAILED(hr)) - RDCERR("Failed to create m_SOStagingBuffer %08x", hr); + RDCERR("Failed to create m_SOStagingBuffer HRESULT: %s", ToStr(hr).c_str()); } bool D3D11DebugManager::InitFontRendering() @@ -1439,14 +1441,14 @@ bool D3D11DebugManager::InitFontRendering() hr = m_pDevice->CreateTexture2D(&desc, &initialData, &debugTex); if(FAILED(hr)) - RDCERR("Failed to create debugTex %08x", hr); + RDCERR("Failed to create debugTex HRESULT: %s", ToStr(hr).c_str()); delete[] buf; hr = m_pDevice->CreateShaderResourceView(debugTex, NULL, &m_Font.Tex); if(FAILED(hr)) - RDCERR("Failed to create m_Font.Tex %08x", hr); + RDCERR("Failed to create m_Font.Tex HRESULT: %s", ToStr(hr).c_str()); SAFE_RELEASE(debugTex); @@ -1509,7 +1511,7 @@ void D3D11DebugManager::OutputWindow::MakeRTV() if(FAILED(hr)) { - RDCERR("Failed to get swap chain buffer, HRESULT: 0x%08x", hr); + RDCERR("Failed to get swap chain buffer, HRESULT: %s", ToStr(hr).c_str()); SAFE_RELEASE(texture); return; } @@ -1520,7 +1522,7 @@ void D3D11DebugManager::OutputWindow::MakeRTV() if(FAILED(hr)) { - RDCERR("Failed to create RTV for swap chain buffer, HRESULT: 0x%08x", hr); + RDCERR("Failed to create RTV for swap chain buffer, HRESULT: %s", ToStr(hr).c_str()); SAFE_RELEASE(swap); return; } @@ -1533,7 +1535,7 @@ void D3D11DebugManager::OutputWindow::MakeDSV() if(FAILED(hr)) { - RDCERR("Failed to get swap chain buffer, HRESULT: 0x%08x", hr); + RDCERR("Failed to get swap chain buffer, HRESULT: %s", ToStr(hr).c_str()); SAFE_RELEASE(texture); return; } @@ -1550,7 +1552,7 @@ void D3D11DebugManager::OutputWindow::MakeDSV() if(FAILED(hr)) { - RDCERR("Failed to create DSV texture for main output, HRESULT: 0x%08x", hr); + RDCERR("Failed to create DSV texture for main output, HRESULT: %s", ToStr(hr).c_str()); SAFE_RELEASE(swap); SAFE_RELEASE(rtv); return; @@ -1562,7 +1564,7 @@ void D3D11DebugManager::OutputWindow::MakeDSV() if(FAILED(hr)) { - RDCERR("Failed to create DSV for main output, HRESULT: 0x%08x", hr); + RDCERR("Failed to create DSV for main output, HRESULT: %s", ToStr(hr).c_str()); SAFE_RELEASE(swap); SAFE_RELEASE(rtv); return; @@ -1601,7 +1603,7 @@ uint64_t D3D11DebugManager::MakeOutputWindow(WindowingSystem system, void *data, if(FAILED(hr)) { - RDCERR("Failed to create swap chain for HWND, HRESULT: 0x%08x", hr); + RDCERR("Failed to create swap chain for HWND, HRESULT: %s", ToStr(hr).c_str()); return 0; } @@ -1668,7 +1670,7 @@ bool D3D11DebugManager::CheckResizeOutputWindow(uint64_t id) if(FAILED(hr)) { - RDCERR("Failed to resize swap chain, HRESULT: 0x%08x", hr); + RDCERR("Failed to resize swap chain, HRESULT: %s", ToStr(hr).c_str()); return true; } @@ -1767,7 +1769,7 @@ uint32_t D3D11DebugManager::GetStructCount(ID3D11UnorderedAccessView *uav) if(FAILED(hr)) { - RDCERR("Failed to Map %08x", hr); + RDCERR("Failed to Map HRESULT: %s", ToStr(hr).c_str()); return ~0U; } @@ -1882,7 +1884,7 @@ bool D3D11DebugManager::GetHistogram(ResourceId texid, uint32_t sliceFace, uint3 if(FAILED(hr)) { - RDCERR("Can't map histogram stage buff %08x", hr); + RDCERR("Can't map histogram stage buff HRESULT: %s", ToStr(hr).c_str()); } else { @@ -1980,7 +1982,7 @@ bool D3D11DebugManager::GetMinMax(ResourceId texid, uint32_t sliceFace, uint32_t if(FAILED(hr)) { - RDCERR("Failed to map minmax results buffer %08x", hr); + RDCERR("Failed to map minmax results buffer HRESULT: %s", ToStr(hr).c_str()); } else { @@ -2085,7 +2087,7 @@ void D3D11DebugManager::GetBufferData(ID3D11Buffer *buffer, uint64_t offset, uin if(FAILED(hr)) { - RDCERR("Failed to map bufferdata buffer %08x", hr); + RDCERR("Failed to map bufferdata buffer HRESULT: %s", ToStr(hr).c_str()); return; } else @@ -2142,14 +2144,14 @@ void D3D11DebugManager::CopyArrayToTex2DMS(ID3D11Texture2D *destMS, ID3D11Textur hr = m_pDevice->CreateTexture2D(&rtvResDesc, NULL, &rtvResource); if(FAILED(hr)) { - RDCERR("0x%08x", hr); + RDCERR("0xHRESULT: %s", ToStr(hr).c_str()); return; } hr = m_pDevice->CreateTexture2D(&srvResDesc, NULL, &srvResource); if(FAILED(hr)) { - RDCERR("0x%08x", hr); + RDCERR("0xHRESULT: %s", ToStr(hr).c_str()); return; } @@ -2273,7 +2275,7 @@ void D3D11DebugManager::CopyArrayToTex2DMS(ID3D11Texture2D *destMS, ID3D11Textur hr = m_pDevice->CreateShaderResourceView(srvResource, &srvDesc, &srvArray); if(FAILED(hr)) { - RDCERR("0x%08x", hr); + RDCERR("0xHRESULT: %s", ToStr(hr).c_str()); return; } @@ -2303,7 +2305,7 @@ void D3D11DebugManager::CopyArrayToTex2DMS(ID3D11Texture2D *destMS, ID3D11Textur if(FAILED(hr)) { SAFE_RELEASE(srvArray); - RDCERR("0x%08x", hr); + RDCERR("0xHRESULT: %s", ToStr(hr).c_str()); return; } @@ -2329,7 +2331,7 @@ void D3D11DebugManager::CopyArrayToTex2DMS(ID3D11Texture2D *destMS, ID3D11Textur hr = m_pDevice->CreateShaderResourceView(srvResource, &srvDesc, &srvArray); if(FAILED(hr)) { - RDCERR("0x%08x", hr); + RDCERR("0xHRESULT: %s", ToStr(hr).c_str()); return; } @@ -2367,7 +2369,7 @@ void D3D11DebugManager::CopyArrayToTex2DMS(ID3D11Texture2D *destMS, ID3D11Textur { SAFE_RELEASE(srvArray); SAFE_RELEASE(dsState); - RDCERR("0x%08x", hr); + RDCERR("0xHRESULT: %s", ToStr(hr).c_str()); return; } @@ -2591,14 +2593,14 @@ void D3D11DebugManager::CopyTex2DMSToArray(ID3D11Texture2D *destArray, ID3D11Tex hr = dev->CreateTexture2D(&rtvResDesc, NULL, &rtvResource); if(FAILED(hr)) { - RDCERR("0x%08x", hr); + RDCERR("0xHRESULT: %s", ToStr(hr).c_str()); return; } hr = dev->CreateTexture2D(&srvResDesc, NULL, &srvResource); if(FAILED(hr)) { - RDCERR("0x%08x", hr); + RDCERR("0xHRESULT: %s", ToStr(hr).c_str()); return; } @@ -2721,7 +2723,7 @@ void D3D11DebugManager::CopyTex2DMSToArray(ID3D11Texture2D *destArray, ID3D11Tex hr = dev->CreateShaderResourceView(srvResource, &srvDesc, &srvMS); if(FAILED(hr)) { - RDCERR("0x%08x", hr); + RDCERR("0xHRESULT: %s", ToStr(hr).c_str()); return; } @@ -2761,7 +2763,7 @@ void D3D11DebugManager::CopyTex2DMSToArray(ID3D11Texture2D *destArray, ID3D11Tex { SAFE_RELEASE(rtvArray); SAFE_RELEASE(dsvArray); - RDCERR("0x%08x", hr); + RDCERR("0xHRESULT: %s", ToStr(hr).c_str()); return; } @@ -2786,7 +2788,7 @@ void D3D11DebugManager::CopyTex2DMSToArray(ID3D11Texture2D *destArray, ID3D11Tex hr = dev->CreateShaderResourceView(srvResource, &srvDesc, &srvMS); if(FAILED(hr)) { - RDCERR("0x%08x", hr); + RDCERR("0xHRESULT: %s", ToStr(hr).c_str()); return; } @@ -2827,7 +2829,7 @@ void D3D11DebugManager::CopyTex2DMSToArray(ID3D11Texture2D *destArray, ID3D11Tex { SAFE_RELEASE(dsState); SAFE_RELEASE(srvMS); - RDCERR("0x%08x", hr); + RDCERR("0xHRESULT: %s", ToStr(hr).c_str()); return; } @@ -2940,7 +2942,7 @@ D3D11DebugManager::TextureShaderDetails D3D11DebugManager::GetShaderDetails(Reso if(FAILED(hr)) { - RDCERR("Failed to create temporary Texture1D %08x", hr); + RDCERR("Failed to create temporary Texture1D HRESULT: %s", ToStr(hr).c_str()); } cache.srvResource = tmp; @@ -3037,7 +3039,7 @@ D3D11DebugManager::TextureShaderDetails D3D11DebugManager::GetShaderDetails(Reso if(FAILED(hr)) { - RDCERR("Failed to create temporary Texture2D %08x", hr); + RDCERR("Failed to create temporary Texture2D HRESULT: %s", ToStr(hr).c_str()); } cache.srvResource = tmp; @@ -3096,7 +3098,7 @@ D3D11DebugManager::TextureShaderDetails D3D11DebugManager::GetShaderDetails(Reso if(FAILED(hr)) { - RDCERR("Failed to create temporary Texture3D %08x", hr); + RDCERR("Failed to create temporary Texture3D HRESULT: %s", ToStr(hr).c_str()); } cache.srvResource = tmp; @@ -3207,7 +3209,7 @@ D3D11DebugManager::TextureShaderDetails D3D11DebugManager::GetShaderDetails(Reso &cache.srv[0]); if(FAILED(hr)) - RDCERR("Failed to create cache SRV 0, type %d %08x", details.texType, hr); + RDCERR("Failed to create cache SRV 0, type %d HRESULT: %s", details.texType, ToStr(hr).c_str()); } details.srv[details.texType] = cache.srv[0]; @@ -3220,7 +3222,8 @@ D3D11DebugManager::TextureShaderDetails D3D11DebugManager::GetShaderDetails(Reso &cache.srv[1]); if(FAILED(hr)) - RDCERR("Failed to create cache SRV 1, type %d %08x", details.texType, hr); + RDCERR("Failed to create cache SRV 1, type %d HRESULT: %s", details.texType, + ToStr(hr).c_str()); } details.srv[eTexType_Stencil] = cache.srv[1]; @@ -3300,7 +3303,7 @@ void D3D11DebugManager::RenderTextInternal(float x, float y, const char *text) if(FAILED(hr)) { - RDCERR("Failed to map charbuffer %08x", hr); + RDCERR("Failed to map charbuffer HRESULT: %s", ToStr(hr).c_str()); return; } @@ -4002,7 +4005,7 @@ void D3D11DebugManager::InitPostVSBuffers(uint32_t eventID) if(FAILED(hr)) { - RDCERR("Failed to create Geometry Shader + SO %08x", hr); + RDCERR("Failed to create Geometry Shader + SO HRESULT: %s", ToStr(hr).c_str()); return; } @@ -4226,7 +4229,7 @@ void D3D11DebugManager::InitPostVSBuffers(uint32_t eventID) if(FAILED(hr)) { - RDCERR("Failed to map sobuffer %08x", hr); + RDCERR("Failed to map sobuffer HRESULT: %s", ToStr(hr).c_str()); SAFE_RELEASE(idxBuf); return; } @@ -4251,7 +4254,7 @@ void D3D11DebugManager::InitPostVSBuffers(uint32_t eventID) if(FAILED(hr)) { - RDCERR("Failed to create postvs pos buffer %08x", hr); + RDCERR("Failed to create postvs pos buffer HRESULT: %s", ToStr(hr).c_str()); m_pImmediateContext->Unmap(m_SOStagingBuffer, 0); SAFE_RELEASE(idxBuf); @@ -4417,7 +4420,7 @@ void D3D11DebugManager::InitPostVSBuffers(uint32_t eventID) if(FAILED(hr)) { - RDCERR("Failed to create Geometry Shader + SO %08x", hr); + RDCERR("Failed to create Geometry Shader + SO HRESULT: %s", ToStr(hr).c_str()); return; } @@ -4509,7 +4512,7 @@ void D3D11DebugManager::InitPostVSBuffers(uint32_t eventID) ID3D11Query *q = NULL; hr = m_pDevice->CreateQuery(&qdesc, &q); if(FAILED(hr)) - RDCERR("Failed to create m_SOStatsQuery %08x", hr); + RDCERR("Failed to create m_SOStatsQuery HRESULT: %s", ToStr(hr).c_str()); m_SOStatsQueries.push_back(q); } @@ -4587,7 +4590,7 @@ void D3D11DebugManager::InitPostVSBuffers(uint32_t eventID) if(FAILED(hr)) { - RDCERR("Failed to map sobuffer %08x", hr); + RDCERR("Failed to map sobuffer HRESULT: %s", ToStr(hr).c_str()); return; } @@ -4619,7 +4622,7 @@ void D3D11DebugManager::InitPostVSBuffers(uint32_t eventID) if(FAILED(hr)) { - RDCERR("Failed to create postvs pos buffer %08x", hr); + RDCERR("Failed to create postvs pos buffer HRESULT: %s", ToStr(hr).c_str()); m_pImmediateContext->Unmap(m_SOStagingBuffer, 0); return; @@ -4842,7 +4845,7 @@ void D3D11DebugManager::RenderMesh(uint32_t eventID, const vector &s if(FAILED(hr)) { - RDCERR("Failed to create m_MeshDisplayLayout %08x", hr); + RDCERR("Failed to create m_MeshDisplayLayout HRESULT: %s", ToStr(hr).c_str()); m_MeshDisplayLayout = NULL; } } @@ -5168,7 +5171,7 @@ void D3D11DebugManager::RenderMesh(uint32_t eventID, const vector &s if(FAILED(hr)) { - RDCERR("Failde to map m_TriHighlightHelper %08x", hr); + RDCERR("Failde to map m_TriHighlightHelper HRESULT: %s", ToStr(hr).c_str()); return; } @@ -5188,7 +5191,7 @@ void D3D11DebugManager::RenderMesh(uint32_t eventID, const vector &s if(FAILED(hr)) { - RDCERR("Failde to map m_TriHighlightHelper %08x", hr); + RDCERR("Failde to map m_TriHighlightHelper HRESULT: %s", ToStr(hr).c_str()); return; } @@ -5220,7 +5223,7 @@ void D3D11DebugManager::RenderMesh(uint32_t eventID, const vector &s if(FAILED(hr)) { - RDCERR("Failde to map m_TriHighlightHelper %08x", hr); + RDCERR("Failde to map m_TriHighlightHelper HRESULT: %s", ToStr(hr).c_str()); return; } @@ -5241,7 +5244,7 @@ void D3D11DebugManager::RenderMesh(uint32_t eventID, const vector &s if(FAILED(hr)) { - RDCERR("Failde to map m_TriHighlightHelper %08x", hr); + RDCERR("Failde to map m_TriHighlightHelper HRESULT: %s", ToStr(hr).c_str()); return; } diff --git a/renderdoc/driver/d3d11/d3d11_device.cpp b/renderdoc/driver/d3d11/d3d11_device.cpp index a859d0242..2c10e6d4b 100644 --- a/renderdoc/driver/d3d11/d3d11_device.cpp +++ b/renderdoc/driver/d3d11/d3d11_device.cpp @@ -602,7 +602,7 @@ HRESULT STDMETHODCALLTYPE WrappedID3D11Debug::QueryInterface(REFIID riid, void * return S_OK; } - string guid = ToStr::Get(riid); + string guid = ToStr(riid); RDCWARN("Querying ID3D11Debug for interface: %s", guid.c_str()); return m_pDebug->QueryInterface(riid, ppvObject); @@ -811,7 +811,7 @@ HRESULT WrappedID3D11Device::QueryInterface(REFIID riid, void **ppvObject) "If you want direct access, enable API validation and query for %s. This will return the " "real ID3D11InfoQueue - be careful as it is unwrapped so you should not call " "QueryInterface on it.", - ToStr::Get(unwrappedID3D11InfoQueue__uuid).c_str()); + ToStr(unwrappedID3D11InfoQueue__uuid).c_str()); *ppvObject = (ID3D11InfoQueue *)&m_DummyInfoQueue; m_DummyInfoQueue.AddRef(); return S_OK; @@ -862,7 +862,7 @@ HRESULT WrappedID3D11Device::QueryInterface(REFIID riid, void **ppvObject) } else { - string guid = ToStr::Get(riid); + string guid = ToStr(riid); RDCWARN("Querying ID3D11Device for interface: %s", guid.c_str()); } @@ -885,7 +885,7 @@ const char *WrappedID3D11Device::GetChunkName(uint32_t idx) } template <> -string ToStrHelper::Get(const D3D11ChunkType &el) +std::string DoStringise(const D3D11ChunkType &el) { return WrappedID3D11Device::GetChunkName(el); } @@ -2593,7 +2593,7 @@ bool WrappedID3D11Device::Serialise_WrapSwapchainBuffer(WrappedIDXGISwapChain4 * if(FAILED(hr)) { - RDCERR("Failed to create fake back buffer, HRESULT: 0x%08x", hr); + RDCERR("Failed to create fake back buffer, HRESULT: %s", ToStr(hr).c_str()); } else { @@ -2667,7 +2667,7 @@ IUnknown *WrappedID3D11Device::WrapSwapchainBuffer(WrappedIDXGISwapChain4 *swap, HRESULT hr = m_pDevice->CreateRenderTargetView(UNWRAP(WrappedID3D11Texture2D1, pTex), NULL, &rtv); if(FAILED(hr)) - RDCERR("Couldn't create RTV for swapchain tex %08x", hr); + RDCERR("Couldn't create RTV for swapchain tex HRESULT: %s", ToStr(hr).c_str()); m_SwapChains[swap] = rtv; } @@ -2859,7 +2859,7 @@ bool WrappedID3D11Device::EndFrameCapture(void *dev, void *wnd) if(FAILED(hr)) { - RDCERR("Couldn't create staging texture to create thumbnail. %08x", hr); + RDCERR("Couldn't create staging texture to create thumbnail. HRESULT: %s", ToStr(hr).c_str()); } else { @@ -2875,7 +2875,8 @@ bool WrappedID3D11Device::EndFrameCapture(void *dev, void *wnd) if(FAILED(hr)) { - RDCERR("Couldn't create resolve texture to create thumbnail. %08x", hr); + RDCERR("Couldn't create resolve texture to create thumbnail. HRESULT: %s", + ToStr(hr).c_str()); tex = NULL; } else @@ -2899,7 +2900,8 @@ bool WrappedID3D11Device::EndFrameCapture(void *dev, void *wnd) if(FAILED(hr)) { - RDCERR("Couldn't map staging texture to create thumbnail. %08x", hr); + RDCERR("Couldn't map staging texture to create thumbnail. HRESULT: %s", + ToStr(hr).c_str()); } else { diff --git a/renderdoc/driver/d3d11/d3d11_device.h b/renderdoc/driver/d3d11/d3d11_device.h index 14d3a402d..f988e606a 100644 --- a/renderdoc/driver/d3d11/d3d11_device.h +++ b/renderdoc/driver/d3d11/d3d11_device.h @@ -484,7 +484,7 @@ public: else if(iid == __uuidof(ID3D11Device4)) return (ID3D11Device4 *)this; - RDCERR("Requested unknown device interface %s", ToStr::Get(iid).c_str()); + RDCERR("Requested unknown device interface %s", ToStr(iid).c_str()); return NULL; } diff --git a/renderdoc/driver/d3d11/d3d11_device1_wrap.cpp b/renderdoc/driver/d3d11/d3d11_device1_wrap.cpp index 2bda6d439..fc267f4e0 100644 --- a/renderdoc/driver/d3d11/d3d11_device1_wrap.cpp +++ b/renderdoc/driver/d3d11/d3d11_device1_wrap.cpp @@ -85,7 +85,7 @@ bool WrappedID3D11Device::Serialise_CreateBlendState1(const D3D11_BLEND_DESC1 *p if(FAILED(hr)) { - RDCERR("Failed on resource serialise-creation, HRESULT: 0x%08x", hr); + RDCERR("Failed on resource serialise-creation, HRESULT: %s", ToStr(hr).c_str()); } else { @@ -176,7 +176,7 @@ bool WrappedID3D11Device::Serialise_CreateRasterizerState1( if(FAILED(hr)) { - RDCERR("Failed on resource serialise-creation, HRESULT: 0x%08x", hr); + RDCERR("Failed on resource serialise-creation, HRESULT: %s", ToStr(hr).c_str()); } else { diff --git a/renderdoc/driver/d3d11/d3d11_device3_wrap.cpp b/renderdoc/driver/d3d11/d3d11_device3_wrap.cpp index 6e2636228..a286cc9f3 100644 --- a/renderdoc/driver/d3d11/d3d11_device3_wrap.cpp +++ b/renderdoc/driver/d3d11/d3d11_device3_wrap.cpp @@ -68,7 +68,7 @@ bool WrappedID3D11Device::Serialise_CreateTexture2D1(const D3D11_TEXTURE2D_DESC1 if(FAILED(hr)) { - RDCERR("Failed on resource serialise-creation, HRESULT: 0x%08x", hr); + RDCERR("Failed on resource serialise-creation, HRESULT: %s", ToStr(hr).c_str()); } else { @@ -175,7 +175,7 @@ bool WrappedID3D11Device::Serialise_CreateTexture3D1(const D3D11_TEXTURE3D_DESC1 if(FAILED(hr)) { - RDCERR("Failed on resource serialise-creation, HRESULT: 0x%08x", hr); + RDCERR("Failed on resource serialise-creation, HRESULT: %s", ToStr(hr).c_str()); } else { @@ -309,7 +309,7 @@ bool WrappedID3D11Device::Serialise_CreateShaderResourceView1( if(FAILED(hr)) { - RDCERR("Failed on resource serialise-creation, HRESULT: 0x%08x", hr); + RDCERR("Failed on resource serialise-creation, HRESULT: %s", ToStr(hr).c_str()); } else { @@ -449,7 +449,7 @@ bool WrappedID3D11Device::Serialise_CreateRenderTargetView1(ID3D11Resource *pRes if(FAILED(hr)) { - RDCERR("Failed on resource serialise-creation, HRESULT: 0x%08x", hr); + RDCERR("Failed on resource serialise-creation, HRESULT: %s", ToStr(hr).c_str()); } else { @@ -561,7 +561,7 @@ bool WrappedID3D11Device::Serialise_CreateUnorderedAccessView1( if(FAILED(hr)) { - RDCERR("Failed on resource serialise-creation, HRESULT: 0x%08x", hr); + RDCERR("Failed on resource serialise-creation, HRESULT: %s", ToStr(hr).c_str()); } else { @@ -657,7 +657,7 @@ bool WrappedID3D11Device::Serialise_CreateRasterizerState2( if(FAILED(hr)) { - RDCERR("Failed on resource serialise-creation, HRESULT: 0x%08x", hr); + RDCERR("Failed on resource serialise-creation, HRESULT: %s", ToStr(hr).c_str()); } else { @@ -749,7 +749,7 @@ bool WrappedID3D11Device::Serialise_CreateQuery1(const D3D11_QUERY_DESC1 *pQuery if(FAILED(hr)) { - RDCERR("Failed on resource serialise-creation, HRESULT: 0x%08x", hr); + RDCERR("Failed on resource serialise-creation, HRESULT: %s", ToStr(hr).c_str()); } else { diff --git a/renderdoc/driver/d3d11/d3d11_device_wrap.cpp b/renderdoc/driver/d3d11/d3d11_device_wrap.cpp index 34c96f035..f13c62816 100644 --- a/renderdoc/driver/d3d11/d3d11_device_wrap.cpp +++ b/renderdoc/driver/d3d11/d3d11_device_wrap.cpp @@ -99,7 +99,7 @@ bool WrappedID3D11Device::Serialise_CreateBuffer(const D3D11_BUFFER_DESC *pDesc, if(FAILED(hr)) { - RDCERR("Failed on resource serialise-creation, HRESULT: 0x%08x", hr); + RDCERR("Failed on resource serialise-creation, HRESULT: %s", ToStr(hr).c_str()); } else { @@ -128,7 +128,8 @@ bool WrappedID3D11Device::Serialise_CreateBuffer(const D3D11_BUFFER_DESC *pDesc, if(FAILED(hr) || stage == NULL) { - RDCERR("Failed to create staging buffer for buffer initial contents %08x", hr); + RDCERR("Failed to create staging buffer for buffer initial contents HRESULT: %s", + ToStr(hr).c_str()); } else { @@ -338,7 +339,7 @@ bool WrappedID3D11Device::Serialise_CreateTexture1D(const D3D11_TEXTURE1D_DESC * if(FAILED(hr)) { - RDCERR("Failed on resource serialise-creation, HRESULT: 0x%08x", hr); + RDCERR("Failed on resource serialise-creation, HRESULT: %s", ToStr(hr).c_str()); } else { @@ -435,7 +436,7 @@ bool WrappedID3D11Device::Serialise_CreateTexture2D(const D3D11_TEXTURE2D_DESC * if(FAILED(hr)) { - RDCERR("Failed on resource serialise-creation, HRESULT: 0x%08x", hr); + RDCERR("Failed on resource serialise-creation, HRESULT: %s", ToStr(hr).c_str()); } else { @@ -532,7 +533,7 @@ bool WrappedID3D11Device::Serialise_CreateTexture3D(const D3D11_TEXTURE3D_DESC * if(FAILED(hr)) { - RDCERR("Failed on resource serialise-creation, HRESULT: 0x%08x", hr); + RDCERR("Failed on resource serialise-creation, HRESULT: %s", ToStr(hr).c_str()); } else { @@ -653,7 +654,7 @@ bool WrappedID3D11Device::Serialise_CreateShaderResourceView(ID3D11Resource *pRe if(FAILED(hr)) { - RDCERR("Failed on resource serialise-creation, HRESULT: 0x%08x", hr); + RDCERR("Failed on resource serialise-creation, HRESULT: %s", ToStr(hr).c_str()); } else { @@ -753,7 +754,7 @@ bool WrappedID3D11Device::Serialise_CreateUnorderedAccessView( if(FAILED(hr)) { - RDCERR("Failed on resource serialise-creation, HRESULT: 0x%08x", hr); + RDCERR("Failed on resource serialise-creation, HRESULT: %s", ToStr(hr).c_str()); } else { @@ -880,7 +881,7 @@ bool WrappedID3D11Device::Serialise_CreateRenderTargetView(ID3D11Resource *pReso if(FAILED(hr)) { - RDCERR("Failed on resource serialise-creation, HRESULT: 0x%08x", hr); + RDCERR("Failed on resource serialise-creation, HRESULT: %s", ToStr(hr).c_str()); } else { @@ -980,7 +981,7 @@ bool WrappedID3D11Device::Serialise_CreateDepthStencilView(ID3D11Resource *pReso if(FAILED(hr)) { - RDCERR("Failed on resource serialise-creation, HRESULT: 0x%08x", hr); + RDCERR("Failed on resource serialise-creation, HRESULT: %s", ToStr(hr).c_str()); } else { @@ -1088,7 +1089,7 @@ bool WrappedID3D11Device::Serialise_CreateInputLayout( if(FAILED(hr)) { - RDCERR("Failed on resource serialise-creation, HRESULT: 0x%08x", hr); + RDCERR("Failed on resource serialise-creation, HRESULT: %s", ToStr(hr).c_str()); } else { @@ -1179,7 +1180,7 @@ bool WrappedID3D11Device::Serialise_CreateVertexShader(const void *pShaderByteco if(FAILED(hr)) { - RDCERR("Failed on resource serialise-creation, HRESULT: 0x%08x", hr); + RDCERR("Failed on resource serialise-creation, HRESULT: %s", ToStr(hr).c_str()); } else { @@ -1267,7 +1268,7 @@ bool WrappedID3D11Device::Serialise_CreateGeometryShader(const void *pShaderByte if(FAILED(hr)) { - RDCERR("Failed on resource serialise-creation, HRESULT: 0x%08x", hr); + RDCERR("Failed on resource serialise-creation, HRESULT: %s", ToStr(hr).c_str()); } else { @@ -1368,7 +1369,7 @@ bool WrappedID3D11Device::Serialise_CreateGeometryShaderWithStreamOutput( if(FAILED(hr)) { - RDCERR("Failed on resource serialise-creation, HRESULT: 0x%08x", hr); + RDCERR("Failed on resource serialise-creation, HRESULT: %s", ToStr(hr).c_str()); } else { @@ -1466,7 +1467,7 @@ bool WrappedID3D11Device::Serialise_CreatePixelShader(const void *pShaderBytecod if(FAILED(hr)) { - RDCERR("Failed on resource serialise-creation, HRESULT: 0x%08x", hr); + RDCERR("Failed on resource serialise-creation, HRESULT: %s", ToStr(hr).c_str()); } else { @@ -1553,7 +1554,7 @@ bool WrappedID3D11Device::Serialise_CreateHullShader(const void *pShaderBytecode if(FAILED(hr)) { - RDCERR("Failed on resource serialise-creation, HRESULT: 0x%08x", hr); + RDCERR("Failed on resource serialise-creation, HRESULT: %s", ToStr(hr).c_str()); } else { @@ -1640,7 +1641,7 @@ bool WrappedID3D11Device::Serialise_CreateDomainShader(const void *pShaderByteco if(FAILED(hr)) { - RDCERR("Failed on resource serialise-creation, HRESULT: 0x%08x", hr); + RDCERR("Failed on resource serialise-creation, HRESULT: %s", ToStr(hr).c_str()); } else { @@ -1728,7 +1729,7 @@ bool WrappedID3D11Device::Serialise_CreateComputeShader(const void *pShaderBytec if(FAILED(hr)) { - RDCERR("Failed on resource serialise-creation, HRESULT: 0x%08x", hr); + RDCERR("Failed on resource serialise-creation, HRESULT: %s", ToStr(hr).c_str()); } else { @@ -1823,7 +1824,7 @@ bool WrappedID3D11Device::Serialise_CreateClassInstance( if(FAILED(hr)) { - RDCERR("Failed on resource serialise-creation, HRESULT: 0x%08x", hr); + RDCERR("Failed on resource serialise-creation, HRESULT: %s", ToStr(hr).c_str()); } else { @@ -1885,7 +1886,7 @@ bool WrappedID3D11Device::Serialise_GetClassInstance(LPCSTR pClassInstanceName, if(FAILED(hr)) { - RDCERR("Failed on resource serialise-creation, HRESULT: 0x%08x", hr); + RDCERR("Failed on resource serialise-creation, HRESULT: %s", ToStr(hr).c_str()); } else { @@ -1935,7 +1936,7 @@ bool WrappedID3D11Device::Serialise_CreateClassLinkage(ID3D11ClassLinkage **ppLi if(FAILED(hr)) { - RDCERR("Failed on resource serialise-creation, HRESULT: 0x%08x", hr); + RDCERR("Failed on resource serialise-creation, HRESULT: %s", ToStr(hr).c_str()); } else { @@ -1991,7 +1992,7 @@ bool WrappedID3D11Device::Serialise_CreateBlendState(const D3D11_BLEND_DESC *pBl if(FAILED(hr)) { - RDCERR("Failed on resource serialise-creation, HRESULT: 0x%08x", hr); + RDCERR("Failed on resource serialise-creation, HRESULT: %s", ToStr(hr).c_str()); } else { @@ -2076,7 +2077,7 @@ bool WrappedID3D11Device::Serialise_CreateDepthStencilState( if(FAILED(hr)) { - RDCERR("Failed on resource serialise-creation, HRESULT: 0x%08x", hr); + RDCERR("Failed on resource serialise-creation, HRESULT: %s", ToStr(hr).c_str()); } else { @@ -2161,7 +2162,7 @@ bool WrappedID3D11Device::Serialise_CreateRasterizerState(const D3D11_RASTERIZER if(FAILED(hr)) { - RDCERR("Failed on resource serialise-creation, HRESULT: 0x%08x", hr); + RDCERR("Failed on resource serialise-creation, HRESULT: %s", ToStr(hr).c_str()); } else { @@ -2246,7 +2247,7 @@ bool WrappedID3D11Device::Serialise_CreateSamplerState(const D3D11_SAMPLER_DESC if(FAILED(hr)) { - RDCERR("Failed on resource serialise-creation, HRESULT: 0x%08x", hr); + RDCERR("Failed on resource serialise-creation, HRESULT: %s", ToStr(hr).c_str()); } else { @@ -2331,7 +2332,7 @@ bool WrappedID3D11Device::Serialise_CreateQuery(const D3D11_QUERY_DESC *pQueryDe if(FAILED(hr)) { - RDCERR("Failed on resource serialise-creation, HRESULT: 0x%08x", hr); + RDCERR("Failed on resource serialise-creation, HRESULT: %s", ToStr(hr).c_str()); } else { @@ -2376,7 +2377,7 @@ bool WrappedID3D11Device::Serialise_CreatePredicate(const D3D11_QUERY_DESC *pPre if(FAILED(hr)) { - RDCERR("Failed on resource serialise-creation, HRESULT: 0x%08x", hr); + RDCERR("Failed on resource serialise-creation, HRESULT: %s", ToStr(hr).c_str()); } else { @@ -2433,7 +2434,7 @@ bool WrappedID3D11Device::Serialise_CreateCounter(const D3D11_COUNTER_DESC *pCou if(FAILED(hr)) { - RDCERR("Failed on resource serialise-creation, HRESULT: 0x%08x", hr); + RDCERR("Failed on resource serialise-creation, HRESULT: %s", ToStr(hr).c_str()); } else { @@ -2480,7 +2481,7 @@ bool WrappedID3D11Device::Serialise_CreateDeferredContext(const UINT ContextFlag if(FAILED(hr)) { - RDCERR("Failed on resource serialise-creation, HRESULT: 0x%08x", hr); + RDCERR("Failed on resource serialise-creation, HRESULT: %s", ToStr(hr).c_str()); } else { @@ -2589,7 +2590,7 @@ bool WrappedID3D11Device::Serialise_OpenSharedResource(HANDLE hResource, REFIID if(FAILED(hr)) { - RDCERR("Failed on resource serialise-creation, HRESULT: 0x%08x", hr); + RDCERR("Failed on resource serialise-creation, HRESULT: %s", ToStr(hr).c_str()); } else { @@ -2616,7 +2617,8 @@ bool WrappedID3D11Device::Serialise_OpenSharedResource(HANDLE hResource, REFIID if(FAILED(hr) || stage == NULL) { - RDCERR("Failed to create staging buffer for buffer initial contents %08x", hr); + RDCERR("Failed to create staging buffer for buffer initial contents HRESULT: %s", + ToStr(hr).c_str()); } else { @@ -2662,7 +2664,7 @@ bool WrappedID3D11Device::Serialise_OpenSharedResource(HANDLE hResource, REFIID if(FAILED(hr)) { - RDCERR("Failed on resource serialise-creation, HRESULT: 0x%08x", hr); + RDCERR("Failed on resource serialise-creation, HRESULT: %s", ToStr(hr).c_str()); } else { @@ -2705,7 +2707,7 @@ bool WrappedID3D11Device::Serialise_OpenSharedResource(HANDLE hResource, REFIID if(FAILED(hr)) { - RDCERR("Failed on resource serialise-creation, HRESULT: 0x%08x", hr); + RDCERR("Failed on resource serialise-creation, HRESULT: %s", ToStr(hr).c_str()); } else { @@ -2748,7 +2750,7 @@ bool WrappedID3D11Device::Serialise_OpenSharedResource(HANDLE hResource, REFIID if(FAILED(hr)) { - RDCERR("Failed on resource serialise-creation, HRESULT: 0x%08x", hr); + RDCERR("Failed on resource serialise-creation, HRESULT: %s", ToStr(hr).c_str()); } else { diff --git a/renderdoc/driver/d3d11/d3d11_hooks.cpp b/renderdoc/driver/d3d11/d3d11_hooks.cpp index 628af0d66..1e00cf9b4 100644 --- a/renderdoc/driver/d3d11/d3d11_hooks.cpp +++ b/renderdoc/driver/d3d11/d3d11_hooks.cpp @@ -276,7 +276,7 @@ private: } else { - RDCDEBUG("failed. 0x%08x", ret); + RDCDEBUG("failed. HRESULT: %s", ToStr(ret).c_str()); } m_InsideCreate = false; @@ -410,7 +410,7 @@ private: } else { - RDCDEBUG("failed. 0x%08x", ret); + RDCDEBUG("failed. HRESULT: %s", ToStr(ret).c_str()); } return ret; @@ -486,7 +486,7 @@ private: } else { - RDCDEBUG("failed. 0x%08x", ret); + RDCDEBUG("failed. HRESULT: %s", ToStr(ret).c_str()); } return ret; diff --git a/renderdoc/driver/d3d11/d3d11_resources.cpp b/renderdoc/driver/d3d11/d3d11_resources.cpp index 2c3d0730e..9076c1639 100644 --- a/renderdoc/driver/d3d11/d3d11_resources.cpp +++ b/renderdoc/driver/d3d11/d3d11_resources.cpp @@ -277,41 +277,6 @@ UINT GetByteSize(ID3D11Texture3D *tex, int SubResource) return GetByteSize(desc.Width, desc.Height, desc.Depth, desc.Format, SubResource); } -string ToStrHelper::Get(const ResourceType &el) -{ - switch(el) - { - TOSTR_CASE_STRINGIZE(Resource_InputLayout) - TOSTR_CASE_STRINGIZE(Resource_Buffer) - TOSTR_CASE_STRINGIZE(Resource_Texture1D) - TOSTR_CASE_STRINGIZE(Resource_Texture2D) - TOSTR_CASE_STRINGIZE(Resource_Texture3D) - TOSTR_CASE_STRINGIZE(Resource_RasterizerState) - TOSTR_CASE_STRINGIZE(Resource_BlendState) - TOSTR_CASE_STRINGIZE(Resource_DepthStencilState) - TOSTR_CASE_STRINGIZE(Resource_SamplerState) - TOSTR_CASE_STRINGIZE(Resource_RenderTargetView) - TOSTR_CASE_STRINGIZE(Resource_ShaderResourceView) - TOSTR_CASE_STRINGIZE(Resource_DepthStencilView) - TOSTR_CASE_STRINGIZE(Resource_Shader) - TOSTR_CASE_STRINGIZE(Resource_UnorderedAccessView) - TOSTR_CASE_STRINGIZE(Resource_Counter) - TOSTR_CASE_STRINGIZE(Resource_Query) - TOSTR_CASE_STRINGIZE(Resource_Predicate) - TOSTR_CASE_STRINGIZE(Resource_ClassInstance) - TOSTR_CASE_STRINGIZE(Resource_ClassLinkage) - - TOSTR_CASE_STRINGIZE(Resource_DeviceContext) - TOSTR_CASE_STRINGIZE(Resource_CommandList) - default: break; - } - - char tostrBuf[256] = {0}; - StringFormat::snprintf(tostrBuf, 255, "ResourceType<%d>", el); - - return tostrBuf; -} - ResourceId GetIDForDeviceChild(ID3D11DeviceChild *ptr) { if(ptr == NULL) diff --git a/renderdoc/driver/d3d11/d3d11_resources.h b/renderdoc/driver/d3d11/d3d11_resources.h index 705a96de1..16474ab60 100644 --- a/renderdoc/driver/d3d11/d3d11_resources.h +++ b/renderdoc/driver/d3d11/d3d11_resources.h @@ -60,6 +60,8 @@ enum ResourceType Resource_DeviceState, }; +DECLARE_REFLECTION_ENUM(ResourceType); + ResourceType IdentifyTypeByPtr(IUnknown *ptr); ResourceId GetIDForDeviceChild(ID3D11DeviceChild *ptr); template @@ -114,7 +116,7 @@ protected: bool ret = m_pDevice->GetResourceManager()->AddWrapper(this, real); if(!ret) - RDCERR("Error adding wrapper for type %s", ToStr::Get(__uuidof(NestedType)).c_str()); + RDCERR("Error adding wrapper for type %s", ToStr(__uuidof(NestedType)).c_str()); m_pDevice->GetResourceManager()->AddCurrentResource(GetResourceID(), this); } @@ -259,7 +261,7 @@ public: } else { - RDCWARN("Unexpected guid %s", ToStr::Get(riid).c_str()); + RDCWARN("Unexpected guid %s", ToStr(riid).c_str()); SAFE_DELETE(dxgiWrapper); } diff --git a/renderdoc/driver/d3d11/d3d11_stringise.cpp b/renderdoc/driver/d3d11/d3d11_stringise.cpp new file mode 100644 index 000000000..9cb74c9fc --- /dev/null +++ b/renderdoc/driver/d3d11/d3d11_stringise.cpp @@ -0,0 +1,630 @@ +/****************************************************************************** + * The MIT License (MIT) + * + * Copyright (c) 2017 Baldur Karlsson + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ + +#include "common/common.h" +#include "d3d11_common.h" +#include "d3d11_resources.h" + +template <> +std::string DoStringise(const ResourceType &el) +{ + BEGIN_ENUM_STRINGISE(ResourceType); + { + STRINGISE_ENUM(Resource_InputLayout) + STRINGISE_ENUM(Resource_Buffer) + STRINGISE_ENUM(Resource_Texture1D) + STRINGISE_ENUM(Resource_Texture2D) + STRINGISE_ENUM(Resource_Texture3D) + STRINGISE_ENUM(Resource_RasterizerState) + STRINGISE_ENUM(Resource_BlendState) + STRINGISE_ENUM(Resource_DepthStencilState) + STRINGISE_ENUM(Resource_SamplerState) + STRINGISE_ENUM(Resource_RenderTargetView) + STRINGISE_ENUM(Resource_ShaderResourceView) + STRINGISE_ENUM(Resource_DepthStencilView) + STRINGISE_ENUM(Resource_Shader) + STRINGISE_ENUM(Resource_UnorderedAccessView) + STRINGISE_ENUM(Resource_Counter) + STRINGISE_ENUM(Resource_Query) + STRINGISE_ENUM(Resource_Predicate) + STRINGISE_ENUM(Resource_ClassInstance) + STRINGISE_ENUM(Resource_ClassLinkage) + STRINGISE_ENUM(Resource_DeviceContext) + STRINGISE_ENUM(Resource_CommandList) + } + END_ENUM_STRINGISE(); +} + +template <> +std::string DoStringise(const D3D11_BIND_FLAG &el) +{ + BEGIN_BITFIELD_STRINGISE(D3D11_BIND_FLAG); + { + STRINGISE_BITFIELD_VALUE(0) + + STRINGISE_BITFIELD_BIT(D3D11_BIND_VERTEX_BUFFER) + STRINGISE_BITFIELD_BIT(D3D11_BIND_INDEX_BUFFER) + STRINGISE_BITFIELD_BIT(D3D11_BIND_CONSTANT_BUFFER) + STRINGISE_BITFIELD_BIT(D3D11_BIND_SHADER_RESOURCE) + STRINGISE_BITFIELD_BIT(D3D11_BIND_STREAM_OUTPUT) + STRINGISE_BITFIELD_BIT(D3D11_BIND_RENDER_TARGET) + STRINGISE_BITFIELD_BIT(D3D11_BIND_DEPTH_STENCIL) + STRINGISE_BITFIELD_BIT(D3D11_BIND_UNORDERED_ACCESS) + STRINGISE_BITFIELD_BIT(D3D11_BIND_DECODER) + STRINGISE_BITFIELD_BIT(D3D11_BIND_VIDEO_ENCODER) + } + END_BITFIELD_STRINGISE(); +} + +template <> +std::string DoStringise(const D3D11_CPU_ACCESS_FLAG &el) +{ + BEGIN_BITFIELD_STRINGISE(D3D11_CPU_ACCESS_FLAG); + { + STRINGISE_BITFIELD_VALUE(0) + + STRINGISE_BITFIELD_BIT(D3D11_CPU_ACCESS_READ) + STRINGISE_BITFIELD_BIT(D3D11_CPU_ACCESS_WRITE) + } + END_BITFIELD_STRINGISE(); +} + +template <> +std::string DoStringise(const D3D11_RESOURCE_MISC_FLAG &el) +{ + BEGIN_BITFIELD_STRINGISE(D3D11_RESOURCE_MISC_FLAG); + { + STRINGISE_BITFIELD_VALUE(0) + + STRINGISE_BITFIELD_BIT(D3D11_RESOURCE_MISC_GENERATE_MIPS) + STRINGISE_BITFIELD_BIT(D3D11_RESOURCE_MISC_SHARED) + STRINGISE_BITFIELD_BIT(D3D11_RESOURCE_MISC_TEXTURECUBE) + STRINGISE_BITFIELD_BIT(D3D11_RESOURCE_MISC_DRAWINDIRECT_ARGS) + STRINGISE_BITFIELD_BIT(D3D11_RESOURCE_MISC_BUFFER_ALLOW_RAW_VIEWS) + STRINGISE_BITFIELD_BIT(D3D11_RESOURCE_MISC_BUFFER_STRUCTURED) + STRINGISE_BITFIELD_BIT(D3D11_RESOURCE_MISC_RESOURCE_CLAMP) + STRINGISE_BITFIELD_BIT(D3D11_RESOURCE_MISC_SHARED_KEYEDMUTEX) + STRINGISE_BITFIELD_BIT(D3D11_RESOURCE_MISC_GDI_COMPATIBLE) + STRINGISE_BITFIELD_BIT(D3D11_RESOURCE_MISC_SHARED_NTHANDLE) + STRINGISE_BITFIELD_BIT(D3D11_RESOURCE_MISC_RESTRICTED_CONTENT) + STRINGISE_BITFIELD_BIT(D3D11_RESOURCE_MISC_RESTRICT_SHARED_RESOURCE) + STRINGISE_BITFIELD_BIT(D3D11_RESOURCE_MISC_RESTRICT_SHARED_RESOURCE_DRIVER) + STRINGISE_BITFIELD_BIT(D3D11_RESOURCE_MISC_GUARDED) + STRINGISE_BITFIELD_BIT(D3D11_RESOURCE_MISC_TILE_POOL) + STRINGISE_BITFIELD_BIT(D3D11_RESOURCE_MISC_TILED) + STRINGISE_BITFIELD_BIT(D3D11_RESOURCE_MISC_HW_PROTECTED) + } + END_BITFIELD_STRINGISE(); +} + +template <> +std::string DoStringise(const D3D11_COLOR_WRITE_ENABLE &el) +{ + BEGIN_BITFIELD_STRINGISE(D3D11_COLOR_WRITE_ENABLE); + { + STRINGISE_BITFIELD_VALUE(0) + STRINGISE_BITFIELD_VALUE(D3D11_COLOR_WRITE_ENABLE_ALL); + + STRINGISE_BITFIELD_BIT(D3D11_COLOR_WRITE_ENABLE_RED) + STRINGISE_BITFIELD_BIT(D3D11_COLOR_WRITE_ENABLE_GREEN) + STRINGISE_BITFIELD_BIT(D3D11_COLOR_WRITE_ENABLE_BLUE) + STRINGISE_BITFIELD_BIT(D3D11_COLOR_WRITE_ENABLE_ALPHA) + } + END_BITFIELD_STRINGISE(); +} + +template <> +std::string DoStringise(const D3D11_BUFFER_UAV_FLAG &el) +{ + BEGIN_BITFIELD_STRINGISE(D3D11_BUFFER_UAV_FLAG); + { + STRINGISE_BITFIELD_VALUE(0) + + STRINGISE_BITFIELD_BIT(D3D11_BUFFER_UAV_FLAG_RAW) + STRINGISE_BITFIELD_BIT(D3D11_BUFFER_UAV_FLAG_APPEND) + STRINGISE_BITFIELD_BIT(D3D11_BUFFER_UAV_FLAG_COUNTER) + } + END_BITFIELD_STRINGISE(); +} + +template <> +std::string DoStringise(const D3D11_DSV_FLAG &el) +{ + BEGIN_BITFIELD_STRINGISE(D3D11_DSV_FLAG); + { + STRINGISE_BITFIELD_VALUE(0) + + STRINGISE_BITFIELD_BIT(D3D11_DSV_READ_ONLY_DEPTH) + STRINGISE_BITFIELD_BIT(D3D11_DSV_READ_ONLY_STENCIL) + } + END_BITFIELD_STRINGISE(); +} + +template <> +std::string DoStringise(const D3D11_COPY_FLAGS &el) +{ + BEGIN_BITFIELD_STRINGISE(D3D11_COPY_FLAGS); + { + STRINGISE_BITFIELD_VALUE(0) + + STRINGISE_BITFIELD_BIT(D3D11_COPY_NO_OVERWRITE) + STRINGISE_BITFIELD_BIT(D3D11_COPY_DISCARD) + } + END_BITFIELD_STRINGISE(); +} + +template <> +std::string DoStringise(const D3D11_MAP_FLAG &el) +{ + BEGIN_BITFIELD_STRINGISE(D3D11_MAP_FLAG); + { + STRINGISE_BITFIELD_VALUE(0) + + STRINGISE_BITFIELD_BIT(D3D11_MAP_FLAG_DO_NOT_WAIT) + } + END_BITFIELD_STRINGISE(); +} + +template <> +std::string DoStringise(const D3D11_CLEAR_FLAG &el) +{ + BEGIN_BITFIELD_STRINGISE(D3D11_CLEAR_FLAG); + { + STRINGISE_BITFIELD_VALUE(0) + + STRINGISE_BITFIELD_BIT(D3D11_CLEAR_DEPTH) + STRINGISE_BITFIELD_BIT(D3D11_CLEAR_STENCIL) + } + END_BITFIELD_STRINGISE(); +} + +template <> +std::string DoStringise(const D3D11_BUFFEREX_SRV_FLAG &el) +{ + BEGIN_BITFIELD_STRINGISE(D3D11_BUFFEREX_SRV_FLAG); + { + STRINGISE_BITFIELD_VALUE(0) + + STRINGISE_BITFIELD_BIT(D3D11_BUFFEREX_SRV_FLAG_RAW) + } + END_BITFIELD_STRINGISE(); +} + +template <> +std::string DoStringise(const D3D11_TEXTURE_LAYOUT &el) +{ + BEGIN_ENUM_STRINGISE(D3D11_TEXTURE_LAYOUT); + { + STRINGISE_ENUM(D3D11_TEXTURE_LAYOUT_UNDEFINED) + STRINGISE_ENUM(D3D11_TEXTURE_LAYOUT_ROW_MAJOR) + STRINGISE_ENUM(D3D11_TEXTURE_LAYOUT_64K_STANDARD_SWIZZLE) + } + END_ENUM_STRINGISE(); +} + +template <> +std::string DoStringise(const D3D11_DEPTH_WRITE_MASK &el) +{ + BEGIN_ENUM_STRINGISE(D3D11_DEPTH_WRITE_MASK); + { + STRINGISE_ENUM(D3D11_DEPTH_WRITE_MASK_ZERO) + STRINGISE_ENUM(D3D11_DEPTH_WRITE_MASK_ALL) + } + END_ENUM_STRINGISE(); +} + +template <> +std::string DoStringise(const D3D11_COMPARISON_FUNC &el) +{ + BEGIN_ENUM_STRINGISE(D3D11_COMPARISON_FUNC); + { + STRINGISE_ENUM(D3D11_COMPARISON_NEVER); + STRINGISE_ENUM(D3D11_COMPARISON_LESS); + STRINGISE_ENUM(D3D11_COMPARISON_EQUAL); + STRINGISE_ENUM(D3D11_COMPARISON_LESS_EQUAL); + STRINGISE_ENUM(D3D11_COMPARISON_GREATER); + STRINGISE_ENUM(D3D11_COMPARISON_NOT_EQUAL); + STRINGISE_ENUM(D3D11_COMPARISON_GREATER_EQUAL); + STRINGISE_ENUM(D3D11_COMPARISON_ALWAYS); + } + END_ENUM_STRINGISE(); +} + +template <> +std::string DoStringise(const D3D11_STENCIL_OP &el) +{ + BEGIN_ENUM_STRINGISE(D3D11_STENCIL_OP); + { + STRINGISE_ENUM(D3D11_STENCIL_OP_KEEP); + STRINGISE_ENUM(D3D11_STENCIL_OP_ZERO); + STRINGISE_ENUM(D3D11_STENCIL_OP_REPLACE); + STRINGISE_ENUM(D3D11_STENCIL_OP_INCR_SAT); + STRINGISE_ENUM(D3D11_STENCIL_OP_DECR_SAT); + STRINGISE_ENUM(D3D11_STENCIL_OP_INVERT); + STRINGISE_ENUM(D3D11_STENCIL_OP_INCR); + STRINGISE_ENUM(D3D11_STENCIL_OP_DECR); + } + END_ENUM_STRINGISE(); +} + +template <> +std::string DoStringise(const D3D11_BLEND &el) +{ + BEGIN_ENUM_STRINGISE(D3D11_BLEND); + { + STRINGISE_ENUM(D3D11_BLEND_ZERO); + STRINGISE_ENUM(D3D11_BLEND_ONE); + STRINGISE_ENUM(D3D11_BLEND_SRC_COLOR); + STRINGISE_ENUM(D3D11_BLEND_INV_SRC_COLOR); + STRINGISE_ENUM(D3D11_BLEND_SRC_ALPHA); + STRINGISE_ENUM(D3D11_BLEND_INV_SRC_ALPHA); + STRINGISE_ENUM(D3D11_BLEND_DEST_ALPHA); + STRINGISE_ENUM(D3D11_BLEND_INV_DEST_ALPHA); + STRINGISE_ENUM(D3D11_BLEND_DEST_COLOR); + STRINGISE_ENUM(D3D11_BLEND_INV_DEST_COLOR); + STRINGISE_ENUM(D3D11_BLEND_SRC_ALPHA_SAT); + STRINGISE_ENUM(D3D11_BLEND_BLEND_FACTOR); + STRINGISE_ENUM(D3D11_BLEND_INV_BLEND_FACTOR); + STRINGISE_ENUM(D3D11_BLEND_SRC1_COLOR); + STRINGISE_ENUM(D3D11_BLEND_INV_SRC1_COLOR); + STRINGISE_ENUM(D3D11_BLEND_SRC1_ALPHA); + STRINGISE_ENUM(D3D11_BLEND_INV_SRC1_ALPHA); + } + END_ENUM_STRINGISE(); +} + +template <> +std::string DoStringise(const D3D11_BLEND_OP &el) +{ + BEGIN_ENUM_STRINGISE(D3D11_BLEND_OP); + { + STRINGISE_ENUM(D3D11_BLEND_OP_ADD); + STRINGISE_ENUM(D3D11_BLEND_OP_SUBTRACT); + STRINGISE_ENUM(D3D11_BLEND_OP_REV_SUBTRACT); + STRINGISE_ENUM(D3D11_BLEND_OP_MIN); + STRINGISE_ENUM(D3D11_BLEND_OP_MAX); + } + END_ENUM_STRINGISE(); +} + +template <> +std::string DoStringise(const D3D11_CULL_MODE &el) +{ + BEGIN_ENUM_STRINGISE(D3D11_CULL_MODE); + { + STRINGISE_ENUM(D3D11_CULL_NONE); + STRINGISE_ENUM(D3D11_CULL_FRONT); + STRINGISE_ENUM(D3D11_CULL_BACK); + } + END_ENUM_STRINGISE(); +} + +template <> +std::string DoStringise(const D3D11_FILL_MODE &el) +{ + BEGIN_ENUM_STRINGISE(D3D11_FILL_MODE); + { + STRINGISE_ENUM(D3D11_FILL_WIREFRAME); + STRINGISE_ENUM(D3D11_FILL_SOLID); + } + END_ENUM_STRINGISE(); +} + +template <> +std::string DoStringise(const D3D11_CONSERVATIVE_RASTERIZATION_MODE &el) +{ + BEGIN_ENUM_STRINGISE(D3D11_CONSERVATIVE_RASTERIZATION_MODE); + { + STRINGISE_ENUM(D3D11_CONSERVATIVE_RASTERIZATION_MODE_ON); + STRINGISE_ENUM(D3D11_CONSERVATIVE_RASTERIZATION_MODE_OFF); + } + END_ENUM_STRINGISE(); +} + +template <> +std::string DoStringise(const D3D11_TEXTURE_ADDRESS_MODE &el) +{ + BEGIN_ENUM_STRINGISE(D3D11_TEXTURE_ADDRESS_MODE); + { + STRINGISE_ENUM(D3D11_TEXTURE_ADDRESS_WRAP); + STRINGISE_ENUM(D3D11_TEXTURE_ADDRESS_MIRROR); + STRINGISE_ENUM(D3D11_TEXTURE_ADDRESS_CLAMP); + STRINGISE_ENUM(D3D11_TEXTURE_ADDRESS_BORDER); + STRINGISE_ENUM(D3D11_TEXTURE_ADDRESS_MIRROR_ONCE); + } + END_ENUM_STRINGISE(); +} + +template <> +std::string DoStringise(const D3D11_FILTER &el) +{ + BEGIN_ENUM_STRINGISE(D3D11_FILTER); + { + STRINGISE_ENUM(D3D11_FILTER_MIN_MAG_MIP_POINT); + STRINGISE_ENUM(D3D11_FILTER_MIN_MAG_POINT_MIP_LINEAR); + STRINGISE_ENUM(D3D11_FILTER_MIN_POINT_MAG_LINEAR_MIP_POINT); + STRINGISE_ENUM(D3D11_FILTER_MIN_POINT_MAG_MIP_LINEAR); + STRINGISE_ENUM(D3D11_FILTER_MIN_LINEAR_MAG_MIP_POINT); + STRINGISE_ENUM(D3D11_FILTER_MIN_LINEAR_MAG_POINT_MIP_LINEAR); + STRINGISE_ENUM(D3D11_FILTER_MIN_MAG_LINEAR_MIP_POINT); + STRINGISE_ENUM(D3D11_FILTER_MIN_MAG_MIP_LINEAR); + STRINGISE_ENUM(D3D11_FILTER_ANISOTROPIC); + STRINGISE_ENUM(D3D11_FILTER_COMPARISON_MIN_MAG_MIP_POINT); + STRINGISE_ENUM(D3D11_FILTER_COMPARISON_MIN_MAG_POINT_MIP_LINEAR); + STRINGISE_ENUM(D3D11_FILTER_COMPARISON_MIN_POINT_MAG_LINEAR_MIP_POINT); + STRINGISE_ENUM(D3D11_FILTER_COMPARISON_MIN_POINT_MAG_MIP_LINEAR); + STRINGISE_ENUM(D3D11_FILTER_COMPARISON_MIN_LINEAR_MAG_MIP_POINT); + STRINGISE_ENUM(D3D11_FILTER_COMPARISON_MIN_LINEAR_MAG_POINT_MIP_LINEAR); + STRINGISE_ENUM(D3D11_FILTER_COMPARISON_MIN_MAG_LINEAR_MIP_POINT); + STRINGISE_ENUM(D3D11_FILTER_COMPARISON_MIN_MAG_MIP_LINEAR); + STRINGISE_ENUM(D3D11_FILTER_COMPARISON_ANISOTROPIC); + } + END_ENUM_STRINGISE(); +} + +template <> +std::string DoStringise(const D3D11_SRV_DIMENSION &el) +{ + BEGIN_ENUM_STRINGISE(D3D11_SRV_DIMENSION); + { + STRINGISE_ENUM(D3D11_SRV_DIMENSION_BUFFER) + STRINGISE_ENUM(D3D11_SRV_DIMENSION_TEXTURE1D) + STRINGISE_ENUM(D3D11_SRV_DIMENSION_TEXTURE1DARRAY) + STRINGISE_ENUM(D3D11_SRV_DIMENSION_TEXTURE2D) + STRINGISE_ENUM(D3D11_SRV_DIMENSION_TEXTURE2DARRAY) + STRINGISE_ENUM(D3D11_SRV_DIMENSION_TEXTURE2DMS) + STRINGISE_ENUM(D3D11_SRV_DIMENSION_TEXTURE2DMSARRAY) + STRINGISE_ENUM(D3D11_SRV_DIMENSION_TEXTURE3D) + STRINGISE_ENUM(D3D11_SRV_DIMENSION_TEXTURECUBE) + STRINGISE_ENUM(D3D11_SRV_DIMENSION_TEXTURECUBEARRAY) + STRINGISE_ENUM(D3D11_SRV_DIMENSION_BUFFEREX) + } + END_ENUM_STRINGISE(); +} + +template <> +std::string DoStringise(const D3D11_RTV_DIMENSION &el) +{ + BEGIN_ENUM_STRINGISE(D3D11_RTV_DIMENSION); + { + STRINGISE_ENUM(D3D11_RTV_DIMENSION_BUFFER) + STRINGISE_ENUM(D3D11_RTV_DIMENSION_TEXTURE1D) + STRINGISE_ENUM(D3D11_RTV_DIMENSION_TEXTURE1DARRAY) + STRINGISE_ENUM(D3D11_RTV_DIMENSION_TEXTURE2D) + STRINGISE_ENUM(D3D11_RTV_DIMENSION_TEXTURE2DARRAY) + STRINGISE_ENUM(D3D11_RTV_DIMENSION_TEXTURE2DMS) + STRINGISE_ENUM(D3D11_RTV_DIMENSION_TEXTURE2DMSARRAY) + STRINGISE_ENUM(D3D11_RTV_DIMENSION_TEXTURE3D) + } + END_ENUM_STRINGISE(); +} + +template <> +std::string DoStringise(const D3D11_UAV_DIMENSION &el) +{ + BEGIN_ENUM_STRINGISE(D3D11_UAV_DIMENSION); + { + STRINGISE_ENUM(D3D11_UAV_DIMENSION_BUFFER) + STRINGISE_ENUM(D3D11_UAV_DIMENSION_TEXTURE1D) + STRINGISE_ENUM(D3D11_UAV_DIMENSION_TEXTURE1DARRAY) + STRINGISE_ENUM(D3D11_UAV_DIMENSION_TEXTURE2D) + STRINGISE_ENUM(D3D11_UAV_DIMENSION_TEXTURE2DARRAY) + STRINGISE_ENUM(D3D11_UAV_DIMENSION_TEXTURE3D) + } + END_ENUM_STRINGISE(); +} + +template <> +std::string DoStringise(const D3D11_DSV_DIMENSION &el) +{ + BEGIN_ENUM_STRINGISE(D3D11_DSV_DIMENSION); + { + STRINGISE_ENUM(D3D11_DSV_DIMENSION_TEXTURE1D) + STRINGISE_ENUM(D3D11_DSV_DIMENSION_TEXTURE1DARRAY) + STRINGISE_ENUM(D3D11_DSV_DIMENSION_TEXTURE2D) + STRINGISE_ENUM(D3D11_DSV_DIMENSION_TEXTURE2DARRAY) + STRINGISE_ENUM(D3D11_DSV_DIMENSION_TEXTURE2DMS) + STRINGISE_ENUM(D3D11_DSV_DIMENSION_TEXTURE2DMSARRAY) + } + END_ENUM_STRINGISE(); +} + +template <> +std::string DoStringise(const D3D11_CONTEXT_TYPE &el) +{ + BEGIN_ENUM_STRINGISE(D3D11_CONTEXT_TYPE); + { + STRINGISE_ENUM(D3D11_CONTEXT_TYPE_ALL) + STRINGISE_ENUM(D3D11_CONTEXT_TYPE_3D) + STRINGISE_ENUM(D3D11_CONTEXT_TYPE_COMPUTE) + STRINGISE_ENUM(D3D11_CONTEXT_TYPE_COPY) + STRINGISE_ENUM(D3D11_CONTEXT_TYPE_VIDEO) + } + END_ENUM_STRINGISE(); +} + +template <> +std::string DoStringise(const D3D11_QUERY &el) +{ + BEGIN_ENUM_STRINGISE(D3D11_QUERY); + { + STRINGISE_ENUM(D3D11_QUERY_EVENT) + STRINGISE_ENUM(D3D11_QUERY_OCCLUSION) + STRINGISE_ENUM(D3D11_QUERY_TIMESTAMP) + STRINGISE_ENUM(D3D11_QUERY_TIMESTAMP_DISJOINT) + STRINGISE_ENUM(D3D11_QUERY_PIPELINE_STATISTICS) + STRINGISE_ENUM(D3D11_QUERY_OCCLUSION_PREDICATE) + STRINGISE_ENUM(D3D11_QUERY_SO_STATISTICS) + STRINGISE_ENUM(D3D11_QUERY_SO_OVERFLOW_PREDICATE) + STRINGISE_ENUM(D3D11_QUERY_SO_STATISTICS_STREAM0) + STRINGISE_ENUM(D3D11_QUERY_SO_OVERFLOW_PREDICATE_STREAM0) + STRINGISE_ENUM(D3D11_QUERY_SO_STATISTICS_STREAM1) + STRINGISE_ENUM(D3D11_QUERY_SO_OVERFLOW_PREDICATE_STREAM1) + STRINGISE_ENUM(D3D11_QUERY_SO_STATISTICS_STREAM2) + STRINGISE_ENUM(D3D11_QUERY_SO_OVERFLOW_PREDICATE_STREAM2) + STRINGISE_ENUM(D3D11_QUERY_SO_STATISTICS_STREAM3) + STRINGISE_ENUM(D3D11_QUERY_SO_OVERFLOW_PREDICATE_STREAM3) + } + END_ENUM_STRINGISE(); +} + +template <> +std::string DoStringise(const D3D11_COUNTER &el) +{ + BEGIN_ENUM_STRINGISE(D3D11_COUNTER); + { + STRINGISE_ENUM(D3D11_COUNTER_DEVICE_DEPENDENT_0) + } + END_ENUM_STRINGISE(); +} + +template <> +std::string DoStringise(const D3D11_MAP &el) +{ + BEGIN_ENUM_STRINGISE(D3D11_MAP); + { + STRINGISE_ENUM(D3D11_MAP_READ) + STRINGISE_ENUM(D3D11_MAP_WRITE) + STRINGISE_ENUM(D3D11_MAP_READ_WRITE) + STRINGISE_ENUM(D3D11_MAP_WRITE_DISCARD) + STRINGISE_ENUM(D3D11_MAP_WRITE_NO_OVERWRITE) + } + END_ENUM_STRINGISE(); +} + +template <> +std::string DoStringise(const D3D11_PRIMITIVE_TOPOLOGY &el) +{ + BEGIN_ENUM_STRINGISE(D3D11_PRIMITIVE_TOPOLOGY); + { + STRINGISE_ENUM(D3D_PRIMITIVE_TOPOLOGY_UNDEFINED); + STRINGISE_ENUM(D3D_PRIMITIVE_TOPOLOGY_POINTLIST); + STRINGISE_ENUM(D3D_PRIMITIVE_TOPOLOGY_LINELIST); + STRINGISE_ENUM(D3D_PRIMITIVE_TOPOLOGY_LINESTRIP); + STRINGISE_ENUM(D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST); + STRINGISE_ENUM(D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP); + STRINGISE_ENUM(D3D_PRIMITIVE_TOPOLOGY_LINELIST_ADJ); + STRINGISE_ENUM(D3D_PRIMITIVE_TOPOLOGY_LINESTRIP_ADJ); + STRINGISE_ENUM(D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST_ADJ); + STRINGISE_ENUM(D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP_ADJ); + STRINGISE_ENUM(D3D_PRIMITIVE_TOPOLOGY_1_CONTROL_POINT_PATCHLIST); + STRINGISE_ENUM(D3D_PRIMITIVE_TOPOLOGY_2_CONTROL_POINT_PATCHLIST); + STRINGISE_ENUM(D3D_PRIMITIVE_TOPOLOGY_3_CONTROL_POINT_PATCHLIST); + STRINGISE_ENUM(D3D_PRIMITIVE_TOPOLOGY_4_CONTROL_POINT_PATCHLIST); + STRINGISE_ENUM(D3D_PRIMITIVE_TOPOLOGY_5_CONTROL_POINT_PATCHLIST); + STRINGISE_ENUM(D3D_PRIMITIVE_TOPOLOGY_6_CONTROL_POINT_PATCHLIST); + STRINGISE_ENUM(D3D_PRIMITIVE_TOPOLOGY_7_CONTROL_POINT_PATCHLIST); + STRINGISE_ENUM(D3D_PRIMITIVE_TOPOLOGY_8_CONTROL_POINT_PATCHLIST); + STRINGISE_ENUM(D3D_PRIMITIVE_TOPOLOGY_9_CONTROL_POINT_PATCHLIST); + STRINGISE_ENUM(D3D_PRIMITIVE_TOPOLOGY_10_CONTROL_POINT_PATCHLIST); + STRINGISE_ENUM(D3D_PRIMITIVE_TOPOLOGY_11_CONTROL_POINT_PATCHLIST); + STRINGISE_ENUM(D3D_PRIMITIVE_TOPOLOGY_12_CONTROL_POINT_PATCHLIST); + STRINGISE_ENUM(D3D_PRIMITIVE_TOPOLOGY_13_CONTROL_POINT_PATCHLIST); + STRINGISE_ENUM(D3D_PRIMITIVE_TOPOLOGY_14_CONTROL_POINT_PATCHLIST); + STRINGISE_ENUM(D3D_PRIMITIVE_TOPOLOGY_15_CONTROL_POINT_PATCHLIST); + STRINGISE_ENUM(D3D_PRIMITIVE_TOPOLOGY_16_CONTROL_POINT_PATCHLIST); + STRINGISE_ENUM(D3D_PRIMITIVE_TOPOLOGY_17_CONTROL_POINT_PATCHLIST); + STRINGISE_ENUM(D3D_PRIMITIVE_TOPOLOGY_18_CONTROL_POINT_PATCHLIST); + STRINGISE_ENUM(D3D_PRIMITIVE_TOPOLOGY_19_CONTROL_POINT_PATCHLIST); + STRINGISE_ENUM(D3D_PRIMITIVE_TOPOLOGY_20_CONTROL_POINT_PATCHLIST); + STRINGISE_ENUM(D3D_PRIMITIVE_TOPOLOGY_21_CONTROL_POINT_PATCHLIST); + STRINGISE_ENUM(D3D_PRIMITIVE_TOPOLOGY_22_CONTROL_POINT_PATCHLIST); + STRINGISE_ENUM(D3D_PRIMITIVE_TOPOLOGY_23_CONTROL_POINT_PATCHLIST); + STRINGISE_ENUM(D3D_PRIMITIVE_TOPOLOGY_24_CONTROL_POINT_PATCHLIST); + STRINGISE_ENUM(D3D_PRIMITIVE_TOPOLOGY_25_CONTROL_POINT_PATCHLIST); + STRINGISE_ENUM(D3D_PRIMITIVE_TOPOLOGY_26_CONTROL_POINT_PATCHLIST); + STRINGISE_ENUM(D3D_PRIMITIVE_TOPOLOGY_27_CONTROL_POINT_PATCHLIST); + STRINGISE_ENUM(D3D_PRIMITIVE_TOPOLOGY_28_CONTROL_POINT_PATCHLIST); + STRINGISE_ENUM(D3D_PRIMITIVE_TOPOLOGY_29_CONTROL_POINT_PATCHLIST); + STRINGISE_ENUM(D3D_PRIMITIVE_TOPOLOGY_30_CONTROL_POINT_PATCHLIST); + STRINGISE_ENUM(D3D_PRIMITIVE_TOPOLOGY_31_CONTROL_POINT_PATCHLIST); + STRINGISE_ENUM(D3D_PRIMITIVE_TOPOLOGY_32_CONTROL_POINT_PATCHLIST); + } + END_ENUM_STRINGISE(); +} + +template <> +std::string DoStringise(const D3D11_USAGE &el) +{ + BEGIN_ENUM_STRINGISE(D3D11_USAGE); + { + STRINGISE_ENUM(D3D11_USAGE_DEFAULT) + STRINGISE_ENUM(D3D11_USAGE_IMMUTABLE) + STRINGISE_ENUM(D3D11_USAGE_DYNAMIC) + STRINGISE_ENUM(D3D11_USAGE_STAGING) + } + END_ENUM_STRINGISE(); +} + +template <> +std::string DoStringise(const D3D11_INPUT_CLASSIFICATION &el) +{ + BEGIN_ENUM_STRINGISE(D3D11_INPUT_CLASSIFICATION); + { + STRINGISE_ENUM(D3D11_INPUT_PER_VERTEX_DATA) + STRINGISE_ENUM(D3D11_INPUT_PER_INSTANCE_DATA) + } + END_ENUM_STRINGISE(); +} + +template <> +std::string DoStringise(const D3D11_LOGIC_OP &el) +{ + BEGIN_ENUM_STRINGISE(D3D11_LOGIC_OP); + { + STRINGISE_ENUM(D3D11_LOGIC_OP_CLEAR); + STRINGISE_ENUM(D3D11_LOGIC_OP_SET); + STRINGISE_ENUM(D3D11_LOGIC_OP_COPY); + STRINGISE_ENUM(D3D11_LOGIC_OP_COPY_INVERTED); + STRINGISE_ENUM(D3D11_LOGIC_OP_NOOP); + STRINGISE_ENUM(D3D11_LOGIC_OP_INVERT); + STRINGISE_ENUM(D3D11_LOGIC_OP_AND); + STRINGISE_ENUM(D3D11_LOGIC_OP_NAND); + STRINGISE_ENUM(D3D11_LOGIC_OP_OR); + STRINGISE_ENUM(D3D11_LOGIC_OP_NOR); + STRINGISE_ENUM(D3D11_LOGIC_OP_XOR); + STRINGISE_ENUM(D3D11_LOGIC_OP_EQUIV); + STRINGISE_ENUM(D3D11_LOGIC_OP_AND_REVERSE); + STRINGISE_ENUM(D3D11_LOGIC_OP_AND_INVERTED); + STRINGISE_ENUM(D3D11_LOGIC_OP_OR_REVERSE); + STRINGISE_ENUM(D3D11_LOGIC_OP_OR_INVERTED); + } + END_ENUM_STRINGISE(); +} + +#if ENABLED(ENABLE_UNIT_TESTS) +#include "3rdparty/catch/catch.hpp" + +TEST_CASE("D3D11 ToStr", "[tostr][d3d]") +{ + CHECK(ToStr(D3D11_LOGIC_OP_SET) == "SET"); + CHECK(ToStr(D3D11_LOGIC_OP(9999)) == "D3D11_LOGIC_OP<9999>"); + + CHECK(ToStr(D3D11_BIND_FLAG(D3D11_BIND_VERTEX_BUFFER | D3D11_BIND_INDEX_BUFFER)) == + "D3D11_BIND_VERTEX_BUFFER | D3D11_BIND_INDEX_BUFFER"); + CHECK(ToStr(D3D11_BIND_FLAG(D3D11_BIND_VERTEX_BUFFER | D3D11_BIND_INDEX_BUFFER | 0x9b000)) == + "D3D11_BIND_VERTEX_BUFFER | D3D11_BIND_INDEX_BUFFER | D3D11_BIND_FLAG(634880)"); +} + +#endif \ No newline at end of file diff --git a/renderdoc/driver/d3d11/renderdoc_d3d11.vcxproj b/renderdoc/driver/d3d11/renderdoc_d3d11.vcxproj index e81b1b174..c1a663377 100644 --- a/renderdoc/driver/d3d11/renderdoc_d3d11.vcxproj +++ b/renderdoc/driver/d3d11/renderdoc_d3d11.vcxproj @@ -117,6 +117,7 @@ + Create diff --git a/renderdoc/driver/d3d11/renderdoc_d3d11.vcxproj.filters b/renderdoc/driver/d3d11/renderdoc_d3d11.vcxproj.filters index 2ac751a66..ff9282c43 100644 --- a/renderdoc/driver/d3d11/renderdoc_d3d11.vcxproj.filters +++ b/renderdoc/driver/d3d11/renderdoc_d3d11.vcxproj.filters @@ -84,6 +84,9 @@ PCH + + Util + diff --git a/renderdoc/driver/d3d12/d3d12_command_list_wrap.cpp b/renderdoc/driver/d3d12/d3d12_command_list_wrap.cpp index dfe2c8bc7..d134db467 100644 --- a/renderdoc/driver/d3d12/d3d12_command_list_wrap.cpp +++ b/renderdoc/driver/d3d12/d3d12_command_list_wrap.cpp @@ -2889,7 +2889,7 @@ bool WrappedID3D12GraphicsCommandList::Serialise_DrawInstanced(UINT VertexCountP const string desc = m_pSerialiser->GetDebugStr(); m_Cmd->AddEvent(desc); - string name = "DrawInstanced(" + ToStr::Get(vtxCount) + ", " + ToStr::Get(instCount) + ")"; + string name = "DrawInstanced(" + ToStr(vtxCount) + ", " + ToStr(instCount) + ")"; DrawcallDescription draw; draw.name = name; @@ -2965,8 +2965,7 @@ bool WrappedID3D12GraphicsCommandList::Serialise_DrawIndexedInstanced(UINT Index const string desc = m_pSerialiser->GetDebugStr(); m_Cmd->AddEvent(desc); - string name = - "DrawIndexedInstanced(" + ToStr::Get(idxCount) + ", " + ToStr::Get(instCount) + ")"; + string name = "DrawIndexedInstanced(" + ToStr(idxCount) + ", " + ToStr(instCount) + ")"; DrawcallDescription draw; draw.name = name; @@ -3040,7 +3039,7 @@ bool WrappedID3D12GraphicsCommandList::Serialise_Dispatch(UINT ThreadGroupCountX const string desc = m_pSerialiser->GetDebugStr(); m_Cmd->AddEvent(desc); - string name = "Dispatch(" + ToStr::Get(x) + ", " + ToStr::Get(y) + ", " + ToStr::Get(z) + ")"; + string name = "Dispatch(" + ToStr(x) + ", " + ToStr(y) + ", " + ToStr(z) + ")"; DrawcallDescription draw; draw.name = name; @@ -3120,7 +3119,7 @@ bool WrappedID3D12GraphicsCommandList::Serialise_ExecuteBundle(ID3D12GraphicsCom const string desc = m_pSerialiser->GetDebugStr(); m_Cmd->AddEvent(desc); - string name = "ExecuteBundle(" + ToStr::Get(Bundle) + ")"; + string name = "ExecuteBundle(" + ToStr(Bundle) + ")"; DrawcallDescription draw; draw.name = name; @@ -3531,7 +3530,7 @@ void WrappedID3D12GraphicsCommandList::PatchExecuteIndirect(BakedCmdListInfo &in name += StringFormat::Fmt("\tView.BufferLocation: %llu\n", id); name += StringFormat::Fmt("\tView.BufferLocation: %llu\n", offs); name += StringFormat::Fmt("\tView.SizeInBytes: %u\n", ib->SizeInBytes); - name += StringFormat::Fmt("\tView.Format: %s\n", ToStr::Get(ib->Format).c_str()); + name += StringFormat::Fmt("\tView.Format: %s\n", ToStr(ib->Format).c_str()); name += "}\n"; DrawcallDescription &draw = draws[idx].draw; @@ -4200,7 +4199,7 @@ bool WrappedID3D12GraphicsCommandList::Serialise_ClearDepthStencilView( { m_Cmd->AddEvent(desc); - string name = "ClearDepthStencilView(" + ToStr::Get(d) + "," + ToStr::Get(s) + ")"; + string name = "ClearDepthStencilView(" + ToStr(d) + "," + ToStr(s) + ")"; D3D12Descriptor *descriptor = DescriptorFromPortableHandle(GetResourceManager(), dsv); @@ -4288,8 +4287,8 @@ bool WrappedID3D12GraphicsCommandList::Serialise_ClearRenderTargetView( { m_Cmd->AddEvent(desc); - string name = "ClearRenderTargetView(" + ToStr::Get(Color[0]) + "," + ToStr::Get(Color[1]) + - "," + ToStr::Get(Color[2]) + "," + ToStr::Get(Color[3]) + ")"; + string name = "ClearRenderTargetView(" + ToStr(Color[0]) + "," + ToStr(Color[1]) + "," + + ToStr(Color[2]) + "," + ToStr(Color[3]) + ")"; D3D12Descriptor *descriptor = DescriptorFromPortableHandle(GetResourceManager(), rtv); @@ -4387,9 +4386,8 @@ bool WrappedID3D12GraphicsCommandList::Serialise_ClearUnorderedAccessViewUint( { m_Cmd->AddEvent(desc); - string name = "ClearUnorderedAccessViewUint(" + ToStr::Get(vals[0]) + "," + - ToStr::Get(vals[1]) + "," + ToStr::Get(vals[2]) + "," + ToStr::Get(vals[3]) + - ")"; + string name = "ClearUnorderedAccessViewUint(" + ToStr(vals[0]) + "," + ToStr(vals[1]) + "," + + ToStr(vals[2]) + "," + ToStr(vals[3]) + ")"; DrawcallDescription draw; draw.name = name; @@ -4491,9 +4489,8 @@ bool WrappedID3D12GraphicsCommandList::Serialise_ClearUnorderedAccessViewFloat( { m_Cmd->AddEvent(desc); - string name = "ClearUnorderedAccessViewFloat(" + ToStr::Get(vals[0]) + "," + - ToStr::Get(vals[1]) + "," + ToStr::Get(vals[2]) + "," + ToStr::Get(vals[3]) + - ")"; + string name = "ClearUnorderedAccessViewFloat(" + ToStr(vals[0]) + "," + ToStr(vals[1]) + "," + + ToStr(vals[2]) + "," + ToStr(vals[3]) + ")"; DrawcallDescription draw; draw.name = name; @@ -4633,7 +4630,7 @@ bool WrappedID3D12GraphicsCommandList::Serialise_CopyBufferRegion(ID3D12Resource { m_Cmd->AddEvent(desc); - string name = "CopyBufferRegion(" + ToStr::Get(src) + "," + ToStr::Get(dst) + ")"; + string name = "CopyBufferRegion(" + ToStr(src) + "," + ToStr(dst) + ")"; DrawcallDescription draw; draw.name = name; @@ -4721,7 +4718,7 @@ bool WrappedID3D12GraphicsCommandList::Serialise_CopyTextureRegion( ResourceId origSrc = GetResourceManager()->GetOriginalID(liveSrc); ResourceId origDst = GetResourceManager()->GetOriginalID(liveDst); - string name = "CopyTextureRegion(" + ToStr::Get(origSrc) + "," + ToStr::Get(origDst) + ")"; + string name = "CopyTextureRegion(" + ToStr(origSrc) + "," + ToStr(origDst) + ")"; DrawcallDescription draw; draw.name = name; @@ -4810,7 +4807,7 @@ bool WrappedID3D12GraphicsCommandList::Serialise_CopyResource(ID3D12Resource *pD { m_Cmd->AddEvent(desc); - string name = "CopyResource(" + ToStr::Get(src) + "," + ToStr::Get(dst) + ")"; + string name = "CopyResource(" + ToStr(src) + "," + ToStr(dst) + ")"; DrawcallDescription draw; draw.name = name; @@ -4900,7 +4897,7 @@ bool WrappedID3D12GraphicsCommandList::Serialise_ResolveSubresource(ID3D12Resour { m_Cmd->AddEvent(desc); - string name = "ResolveSubresource(" + ToStr::Get(src) + "," + ToStr::Get(dst) + ")"; + string name = "ResolveSubresource(" + ToStr(src) + "," + ToStr(dst) + ")"; DrawcallDescription draw; draw.name = name; diff --git a/renderdoc/driver/d3d12/d3d12_command_queue.h b/renderdoc/driver/d3d12/d3d12_command_queue.h index 538a81246..537f0021a 100644 --- a/renderdoc/driver/d3d12/d3d12_command_queue.h +++ b/renderdoc/driver/d3d12/d3d12_command_queue.h @@ -139,7 +139,7 @@ public: if(iid == __uuidof(ID3D12CommandQueue)) return (ID3D12CommandQueue *)this; - RDCERR("Requested unknown device interface %s", ToStr::Get(iid).c_str()); + RDCERR("Requested unknown device interface %s", ToStr(iid).c_str()); return NULL; } diff --git a/renderdoc/driver/d3d12/d3d12_command_queue_wrap.cpp b/renderdoc/driver/d3d12/d3d12_command_queue_wrap.cpp index 0d44402bc..a3dcfb89a 100644 --- a/renderdoc/driver/d3d12/d3d12_command_queue_wrap.cpp +++ b/renderdoc/driver/d3d12/d3d12_command_queue_wrap.cpp @@ -208,12 +208,12 @@ bool WrappedID3D12CommandQueue::Serialise_ExecuteCommandLists(UINT NumCommandLis // we're adding multiple events, need to increment ourselves m_Cmd.m_RootEventID++; - string basename = "ExecuteCommandLists(" + ToStr::Get(numCmds) + ")"; + string basename = "ExecuteCommandLists(" + ToStr(numCmds) + ")"; for(uint32_t c = 0; c < numCmds; c++) { string name = StringFormat::Fmt("=> %s[%u]: ID3D12CommandList(%s)", basename.c_str(), c, - ToStr::Get(cmdIds[c]).c_str()); + ToStr(cmdIds[c]).c_str()); // add a fake marker DrawcallDescription draw; @@ -252,8 +252,7 @@ bool WrappedID3D12CommandQueue::Serialise_ExecuteCommandLists(UINT NumCommandLis m_Cmd.m_RootEventID += cmdBufInfo.eventCount; m_Cmd.m_RootDrawcallID += cmdBufInfo.drawCount; - name = StringFormat::Fmt("=> %s[%u]: Close(%s)", basename.c_str(), c, - ToStr::Get(cmdIds[c]).c_str()); + name = StringFormat::Fmt("=> %s[%u]: Close(%s)", basename.c_str(), c, ToStr(cmdIds[c]).c_str()); draw.name = name; draw.flags = DrawFlags::PassBoundary | DrawFlags::EndPass; m_Cmd.AddEvent(name); diff --git a/renderdoc/driver/d3d12/d3d12_commands.cpp b/renderdoc/driver/d3d12/d3d12_commands.cpp index 1d07a13f3..3d5160e03 100644 --- a/renderdoc/driver/d3d12/d3d12_commands.cpp +++ b/renderdoc/driver/d3d12/d3d12_commands.cpp @@ -236,7 +236,7 @@ HRESULT STDMETHODCALLTYPE WrappedID3D12CommandQueue::QueryInterface(REFIID riid, } else { - string guid = ToStr::Get(riid); + string guid = ToStr(riid); RDCWARN("Querying ID3D12CommandQueue for interface: %s", guid.c_str()); } @@ -740,7 +740,7 @@ HRESULT STDMETHODCALLTYPE WrappedID3D12GraphicsCommandList::QueryInterface(REFII } else { - string guid = ToStr::Get(riid); + string guid = ToStr(riid); RDCWARN("Querying ID3D12GraphicsCommandList for interface: %s", guid.c_str()); } diff --git a/renderdoc/driver/d3d12/d3d12_common.cpp b/renderdoc/driver/d3d12/d3d12_common.cpp index bf651feb7..d55a1a546 100644 --- a/renderdoc/driver/d3d12/d3d12_common.cpp +++ b/renderdoc/driver/d3d12/d3d12_common.cpp @@ -368,12 +368,13 @@ enum D3D12ResourceBarrierSubresource D3D12AllSubresources = D3D12_RESOURCE_BARRIER_ALL_SUBRESOURCES }; -string ToStrHelper::Get(const D3D12ResourceBarrierSubresource &el) +template <> +std::string DoStringise(const D3D12ResourceBarrierSubresource &el) { if(el == D3D12AllSubresources) return "All Subresources"; - return ToStr::Get(uint32_t(el)); + return ToStr(uint32_t(el)); } enum D3D12ComponentMapping @@ -478,12 +479,13 @@ ShaderStageMask ConvertVisibility(D3D12_SHADER_VISIBILITY ShaderVisibility) return ShaderStageMask::Vertex; } -string ToStrHelper::Get(const D3D12ComponentMapping &el) +template <> +std::string DoStringise(const D3D12ComponentMapping &el) { - string ret; + std::string ret; // value should always be <= 5, see D3D12_SHADER_COMPONENT_MAPPING - const char mapping[] = {'R', 'G', 'B', 'A', '0', '1', '?', '?'}; + const char mapping[] = {'R', 'G', 'B', 'A', '0', '1', '?', '!'}; uint32_t swizzle = (uint32_t)el; @@ -1493,957 +1495,25 @@ void Serialiser::Serialise(const char *name, D3D12_SAMPLER_DESC &el) Serialise("MaxLOD", el.MaxLOD); } -string ToStrHelper::Get(const D3D12_VIEWPORT &el) +template <> +std::string DoStringise(const D3D12_VIEWPORT &el) { return StringFormat::Fmt("Viewport<%.0fx%.0f+%.0f+%.0f z=%f->%f>", el.Width, el.Height, el.TopLeftX, el.TopLeftY, el.MinDepth, el.MaxDepth); } -string ToStrHelper::Get(const D3D12_BOX &el) +template <> +std::string DoStringise(const D3D12_BOX &el) { return StringFormat::Fmt("Box<%u,%u,%u -> %u,%u,%u>", el.left, el.top, el.front, el.right, el.bottom, el.back); } -string ToStrHelper::Get(const PortableHandle &el) +template <> +std::string DoStringise(const PortableHandle &el) { if(el.heap == ResourceId()) return "NULL"; - return StringFormat::Fmt("D3D12_CPU_DESCRIPTOR_HANDLE(%s, %u)", ToStr::Get(el.heap).c_str(), - el.index); -} - -string ToStrHelper::Get(const D3D12Descriptor::DescriptorType &el) -{ - switch(el) - { - case D3D12Descriptor::TypeCBV: return "CBV"; - case D3D12Descriptor::TypeSRV: return "SRV"; - case D3D12Descriptor::TypeUAV: return "UAV"; - case D3D12Descriptor::TypeRTV: return "RTV"; - case D3D12Descriptor::TypeDSV: return "DSV"; - case D3D12Descriptor::TypeUndefined: return "Undefined"; - default: break; - } - - if((uint32_t)el < D3D12Descriptor::TypeCBV) - return "Sampler"; - - return StringFormat::Fmt("DescriptorType<%d>", el); -} - -string ToStrHelper::Get(const D3D12ResourceType &el) -{ - switch(el) - { - case Resource_Device: return "Device"; - case Resource_Unknown: return "Unknown"; - case Resource_CommandAllocator: return "Command Allocator"; - case Resource_CommandQueue: return "Command Queue"; - case Resource_CommandSignature: return "Command Signature"; - case Resource_DescriptorHeap: return "Descriptor Heap"; - case Resource_Fence: return "Fence"; - case Resource_Heap: return "Heap"; - case Resource_PipelineState: return "Pipeline State"; - case Resource_QueryHeap: return "Query Heap"; - case Resource_Resource: return "Resource"; - case Resource_GraphicsCommandList: return "Graphics CommandList"; - case Resource_RootSignature: return "Root Signature"; - default: break; - } - - return StringFormat::Fmt("D3D12ResourceType<%d>", el); -} - -string ToStrHelper::Get(const D3D12_HEAP_TYPE &el) -{ - switch(el) - { - TOSTR_CASE_STRINGIZE(D3D12_HEAP_TYPE_DEFAULT) - TOSTR_CASE_STRINGIZE(D3D12_HEAP_TYPE_UPLOAD) - TOSTR_CASE_STRINGIZE(D3D12_HEAP_TYPE_READBACK) - TOSTR_CASE_STRINGIZE(D3D12_HEAP_TYPE_CUSTOM) - default: break; - } - - return StringFormat::Fmt("D3D12_HEAP_TYPE<%d>", el); -} - -string ToStrHelper::Get(const D3D12_CPU_PAGE_PROPERTY &el) -{ - switch(el) - { - TOSTR_CASE_STRINGIZE(D3D12_CPU_PAGE_PROPERTY_UNKNOWN) - TOSTR_CASE_STRINGIZE(D3D12_CPU_PAGE_PROPERTY_NOT_AVAILABLE) - TOSTR_CASE_STRINGIZE(D3D12_CPU_PAGE_PROPERTY_WRITE_COMBINE) - TOSTR_CASE_STRINGIZE(D3D12_CPU_PAGE_PROPERTY_WRITE_BACK) - default: break; - } - - return StringFormat::Fmt("D3D12_CPU_PAGE_PROPERTY<%d>", el); -} - -string ToStrHelper::Get(const D3D12_MEMORY_POOL &el) -{ - switch(el) - { - TOSTR_CASE_STRINGIZE(D3D12_MEMORY_POOL_UNKNOWN) - TOSTR_CASE_STRINGIZE(D3D12_MEMORY_POOL_L0) - TOSTR_CASE_STRINGIZE(D3D12_MEMORY_POOL_L1) - default: break; - } - - return StringFormat::Fmt("D3D12_MEMORY_POOL<%d>", el); -} - -string ToStrHelper::Get(const D3D12_QUERY_HEAP_TYPE &el) -{ - switch(el) - { - TOSTR_CASE_STRINGIZE(D3D12_QUERY_HEAP_TYPE_OCCLUSION) - TOSTR_CASE_STRINGIZE(D3D12_QUERY_HEAP_TYPE_TIMESTAMP) - TOSTR_CASE_STRINGIZE(D3D12_QUERY_HEAP_TYPE_PIPELINE_STATISTICS) - TOSTR_CASE_STRINGIZE(D3D12_QUERY_HEAP_TYPE_SO_STATISTICS) - default: break; - } - - return StringFormat::Fmt("D3D12_QUERY_HEAP_TYPE<%d>", el); -} - -string ToStrHelper::Get(const D3D12_QUERY_TYPE &el) -{ - switch(el) - { - TOSTR_CASE_STRINGIZE(D3D12_QUERY_TYPE_OCCLUSION) - TOSTR_CASE_STRINGIZE(D3D12_QUERY_TYPE_BINARY_OCCLUSION) - TOSTR_CASE_STRINGIZE(D3D12_QUERY_TYPE_TIMESTAMP) - TOSTR_CASE_STRINGIZE(D3D12_QUERY_TYPE_PIPELINE_STATISTICS) - TOSTR_CASE_STRINGIZE(D3D12_QUERY_TYPE_SO_STATISTICS_STREAM0) - TOSTR_CASE_STRINGIZE(D3D12_QUERY_TYPE_SO_STATISTICS_STREAM1) - TOSTR_CASE_STRINGIZE(D3D12_QUERY_TYPE_SO_STATISTICS_STREAM2) - TOSTR_CASE_STRINGIZE(D3D12_QUERY_TYPE_SO_STATISTICS_STREAM3) - default: break; - } - - return StringFormat::Fmt("D3D12_QUERY_TYPE<%d>", el); -} - -string ToStrHelper::Get(const D3D12_PREDICATION_OP &el) -{ - switch(el) - { - TOSTR_CASE_STRINGIZE(D3D12_PREDICATION_OP_EQUAL_ZERO) - TOSTR_CASE_STRINGIZE(D3D12_PREDICATION_OP_NOT_EQUAL_ZERO) - default: break; - } - - return StringFormat::Fmt("D3D12_PREDICATION_OP<%d>", el); -} - -string ToStrHelper::Get(const D3D12_DESCRIPTOR_HEAP_TYPE &el) -{ - switch(el) - { - TOSTR_CASE_STRINGIZE(D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV) - TOSTR_CASE_STRINGIZE(D3D12_DESCRIPTOR_HEAP_TYPE_SAMPLER) - TOSTR_CASE_STRINGIZE(D3D12_DESCRIPTOR_HEAP_TYPE_RTV) - TOSTR_CASE_STRINGIZE(D3D12_DESCRIPTOR_HEAP_TYPE_DSV) - default: break; - } - - return StringFormat::Fmt("D3D12_DESCRIPTOR_HEAP_TYPE<%d>", el); -} - -string ToStrHelper::Get(const D3D12_RESOURCE_BARRIER_TYPE &el) -{ - switch(el) - { - TOSTR_CASE_STRINGIZE(D3D12_RESOURCE_BARRIER_TYPE_TRANSITION) - TOSTR_CASE_STRINGIZE(D3D12_RESOURCE_BARRIER_TYPE_ALIASING) - TOSTR_CASE_STRINGIZE(D3D12_RESOURCE_BARRIER_TYPE_UAV) - default: break; - } - - return StringFormat::Fmt("D3D12_RESOURCE_BARRIER_TYPE<%d>", el); -} - -string ToStrHelper::Get(const D3D12_SRV_DIMENSION &el) -{ - switch(el) - { - TOSTR_CASE_STRINGIZE(D3D12_SRV_DIMENSION_UNKNOWN) - TOSTR_CASE_STRINGIZE(D3D12_SRV_DIMENSION_BUFFER) - TOSTR_CASE_STRINGIZE(D3D12_SRV_DIMENSION_TEXTURE1D) - TOSTR_CASE_STRINGIZE(D3D12_SRV_DIMENSION_TEXTURE1DARRAY) - TOSTR_CASE_STRINGIZE(D3D12_SRV_DIMENSION_TEXTURE2D) - TOSTR_CASE_STRINGIZE(D3D12_SRV_DIMENSION_TEXTURE2DARRAY) - TOSTR_CASE_STRINGIZE(D3D12_SRV_DIMENSION_TEXTURE2DMS) - TOSTR_CASE_STRINGIZE(D3D12_SRV_DIMENSION_TEXTURE2DMSARRAY) - TOSTR_CASE_STRINGIZE(D3D12_SRV_DIMENSION_TEXTURE3D) - TOSTR_CASE_STRINGIZE(D3D12_SRV_DIMENSION_TEXTURECUBE) - TOSTR_CASE_STRINGIZE(D3D12_SRV_DIMENSION_TEXTURECUBEARRAY) - default: break; - } - - return StringFormat::Fmt("D3D12_SRV_DIMENSION<%d>", el); -} - -string ToStrHelper::Get(const D3D12_RTV_DIMENSION &el) -{ - switch(el) - { - TOSTR_CASE_STRINGIZE(D3D12_RTV_DIMENSION_UNKNOWN) - TOSTR_CASE_STRINGIZE(D3D12_RTV_DIMENSION_BUFFER) - TOSTR_CASE_STRINGIZE(D3D12_RTV_DIMENSION_TEXTURE1D) - TOSTR_CASE_STRINGIZE(D3D12_RTV_DIMENSION_TEXTURE1DARRAY) - TOSTR_CASE_STRINGIZE(D3D12_RTV_DIMENSION_TEXTURE2D) - TOSTR_CASE_STRINGIZE(D3D12_RTV_DIMENSION_TEXTURE2DARRAY) - TOSTR_CASE_STRINGIZE(D3D12_RTV_DIMENSION_TEXTURE2DMS) - TOSTR_CASE_STRINGIZE(D3D12_RTV_DIMENSION_TEXTURE2DMSARRAY) - TOSTR_CASE_STRINGIZE(D3D12_RTV_DIMENSION_TEXTURE3D) - default: break; - } - - return StringFormat::Fmt("D3D12_RTV_DIMENSION<%d>", el); -} - -string ToStrHelper::Get(const D3D12_UAV_DIMENSION &el) -{ - switch(el) - { - TOSTR_CASE_STRINGIZE(D3D12_UAV_DIMENSION_BUFFER) - TOSTR_CASE_STRINGIZE(D3D12_UAV_DIMENSION_TEXTURE1D) - TOSTR_CASE_STRINGIZE(D3D12_UAV_DIMENSION_TEXTURE1DARRAY) - TOSTR_CASE_STRINGIZE(D3D12_UAV_DIMENSION_TEXTURE2D) - TOSTR_CASE_STRINGIZE(D3D12_UAV_DIMENSION_TEXTURE2DARRAY) - TOSTR_CASE_STRINGIZE(D3D12_UAV_DIMENSION_TEXTURE3D) - default: break; - } - - return StringFormat::Fmt("D3D12_UAV_DIMENSION<%d>", el); -} - -string ToStrHelper::Get(const D3D12_DSV_DIMENSION &el) -{ - switch(el) - { - TOSTR_CASE_STRINGIZE(D3D12_DSV_DIMENSION_UNKNOWN) - TOSTR_CASE_STRINGIZE(D3D12_DSV_DIMENSION_TEXTURE1D) - TOSTR_CASE_STRINGIZE(D3D12_DSV_DIMENSION_TEXTURE1DARRAY) - TOSTR_CASE_STRINGIZE(D3D12_DSV_DIMENSION_TEXTURE2D) - TOSTR_CASE_STRINGIZE(D3D12_DSV_DIMENSION_TEXTURE2DARRAY) - TOSTR_CASE_STRINGIZE(D3D12_DSV_DIMENSION_TEXTURE2DMS) - TOSTR_CASE_STRINGIZE(D3D12_DSV_DIMENSION_TEXTURE2DMSARRAY) - default: break; - } - - return StringFormat::Fmt("D3D12_DSV_DIMENSION<%d>", el); -} - -string ToStrHelper::Get(const D3D12_FILTER &el) -{ - switch(el) - { - case D3D12_FILTER_MIN_MAG_MIP_POINT: return "MIN_MAG_MIP_POINT"; - case D3D12_FILTER_MIN_MAG_POINT_MIP_LINEAR: return "MIN_MAG_POINT_MIP_LINEAR"; - case D3D12_FILTER_MIN_POINT_MAG_LINEAR_MIP_POINT: return "MIN_POINT_MAG_LINEAR_MIP_POINT"; - case D3D12_FILTER_MIN_POINT_MAG_MIP_LINEAR: return "MIN_POINT_MAG_MIP_LINEAR"; - case D3D12_FILTER_MIN_LINEAR_MAG_MIP_POINT: return "MIN_LINEAR_MAG_MIP_POINT"; - case D3D12_FILTER_MIN_LINEAR_MAG_POINT_MIP_LINEAR: return "MIN_LINEAR_MAG_POINT_MIP_LINEAR"; - case D3D12_FILTER_MIN_MAG_LINEAR_MIP_POINT: return "MIN_MAG_LINEAR_MIP_POINT"; - case D3D12_FILTER_MIN_MAG_MIP_LINEAR: return "MIN_MAG_MIP_LINEAR"; - case D3D12_FILTER_ANISOTROPIC: return "ANISOTROPIC"; - - case D3D12_FILTER_COMPARISON_MIN_MAG_MIP_POINT: return "CMP:MIN_MAG_MIP_POINT"; - case D3D12_FILTER_COMPARISON_MIN_MAG_POINT_MIP_LINEAR: return "CMP:MIN_MAG_POINT_MIP_LINEAR"; - case D3D12_FILTER_COMPARISON_MIN_POINT_MAG_LINEAR_MIP_POINT: - return "CMP:MIN_POINT_MAG_LINEAR_MIP_POINT"; - case D3D12_FILTER_COMPARISON_MIN_POINT_MAG_MIP_LINEAR: return "CMP:MIN_POINT_MAG_MIP_LINEAR"; - case D3D12_FILTER_COMPARISON_MIN_LINEAR_MAG_MIP_POINT: return "CMP:MIN_LINEAR_MAG_MIP_POINT"; - case D3D12_FILTER_COMPARISON_MIN_LINEAR_MAG_POINT_MIP_LINEAR: - return "CMP:MIN_LINEAR_MAG_POINT_MIP_LINEAR"; - case D3D12_FILTER_COMPARISON_MIN_MAG_LINEAR_MIP_POINT: return "CMP:MIN_MAG_LINEAR_MIP_POINT"; - case D3D12_FILTER_COMPARISON_MIN_MAG_MIP_LINEAR: return "CMP:MIN_MAG_MIP_LINEAR"; - case D3D12_FILTER_COMPARISON_ANISOTROPIC: return "CMP:ANISOTROPIC"; - - case D3D12_FILTER_MINIMUM_MIN_MAG_MIP_POINT: return "MIN:MIN_MAG_MIP_POINT"; - case D3D12_FILTER_MINIMUM_MIN_MAG_POINT_MIP_LINEAR: return "MIN:MIN_MAG_POINT_MIP_LINEAR"; - case D3D12_FILTER_MINIMUM_MIN_POINT_MAG_LINEAR_MIP_POINT: - return "MIN:MIN_POINT_MAG_LINEAR_MIP_POINT"; - case D3D12_FILTER_MINIMUM_MIN_POINT_MAG_MIP_LINEAR: return "MIN:MIN_POINT_MAG_MIP_LINEAR"; - case D3D12_FILTER_MINIMUM_MIN_LINEAR_MAG_MIP_POINT: return "MIN:MIN_LINEAR_MAG_MIP_POINT"; - case D3D12_FILTER_MINIMUM_MIN_LINEAR_MAG_POINT_MIP_LINEAR: - return "MIN:MIN_LINEAR_MAG_POINT_MIP_LINEAR"; - case D3D12_FILTER_MINIMUM_MIN_MAG_LINEAR_MIP_POINT: return "MIN:MIN_MAG_LINEAR_MIP_POINT"; - case D3D12_FILTER_MINIMUM_MIN_MAG_MIP_LINEAR: return "MIN:MIN_MAG_MIP_LINEAR"; - case D3D12_FILTER_MINIMUM_ANISOTROPIC: return "MIN:ANISOTROPIC"; - - case D3D12_FILTER_MAXIMUM_MIN_MAG_MIP_POINT: return "MAX:MIN_MAG_MIP_POINT"; - case D3D12_FILTER_MAXIMUM_MIN_MAG_POINT_MIP_LINEAR: return "MAX:MIN_MAG_POINT_MIP_LINEAR"; - case D3D12_FILTER_MAXIMUM_MIN_POINT_MAG_LINEAR_MIP_POINT: - return "MAX:MIN_POINT_MAG_LINEAR_MIP_POINT"; - case D3D12_FILTER_MAXIMUM_MIN_POINT_MAG_MIP_LINEAR: return "MAX:MIN_POINT_MAG_MIP_LINEAR"; - case D3D12_FILTER_MAXIMUM_MIN_LINEAR_MAG_MIP_POINT: return "MAX:MIN_LINEAR_MAG_MIP_POINT"; - case D3D12_FILTER_MAXIMUM_MIN_LINEAR_MAG_POINT_MIP_LINEAR: - return "MAX:MIN_LINEAR_MAG_POINT_MIP_LINEAR"; - case D3D12_FILTER_MAXIMUM_MIN_MAG_LINEAR_MIP_POINT: return "MAX:MIN_MAG_LINEAR_MIP_POINT"; - case D3D12_FILTER_MAXIMUM_MIN_MAG_MIP_LINEAR: return "MAX:MIN_MAG_MIP_LINEAR"; - case D3D12_FILTER_MAXIMUM_ANISOTROPIC: return "MAX:ANISOTROPIC"; - - default: break; - } - - return StringFormat::Fmt("D3D12_FILTER<%d>", el); -} - -string ToStrHelper::Get(const D3D12_TEXTURE_ADDRESS_MODE &el) -{ - switch(el) - { - case D3D12_TEXTURE_ADDRESS_MODE_WRAP: return "WRAP"; - case D3D12_TEXTURE_ADDRESS_MODE_MIRROR: return "MIRROR"; - case D3D12_TEXTURE_ADDRESS_MODE_CLAMP: return "CLAMP"; - case D3D12_TEXTURE_ADDRESS_MODE_BORDER: return "BORDER"; - case D3D12_TEXTURE_ADDRESS_MODE_MIRROR_ONCE: return "MIRROR_ONCE"; - default: break; - } - - // possible for unused fields via 0-initialisation - if((int)el == 0) - return "--"; - - return StringFormat::Fmt("D3D12_TEXTURE_ADDRESS_MODE<%d>", el); -} - -string ToStrHelper::Get(const D3D12_BLEND &el) -{ - switch(el) - { - case D3D12_BLEND_ZERO: return "ZERO"; - case D3D12_BLEND_ONE: return "ONE"; - case D3D12_BLEND_SRC_COLOR: return "SRC_COLOR"; - case D3D12_BLEND_INV_SRC_COLOR: return "INV_SRC_COLOR"; - case D3D12_BLEND_SRC_ALPHA: return "SRC_ALPHA"; - case D3D12_BLEND_INV_SRC_ALPHA: return "INV_SRC_ALPHA"; - case D3D12_BLEND_DEST_ALPHA: return "DEST_ALPHA"; - case D3D12_BLEND_INV_DEST_ALPHA: return "INV_DEST_ALPHA"; - case D3D12_BLEND_DEST_COLOR: return "DEST_COLOR"; - case D3D12_BLEND_INV_DEST_COLOR: return "INV_DEST_COLOR"; - case D3D12_BLEND_SRC_ALPHA_SAT: return "SRC_ALPHA_SAT"; - case D3D12_BLEND_BLEND_FACTOR: return "BLEND_FACTOR"; - case D3D12_BLEND_INV_BLEND_FACTOR: return "INV_BLEND_FACTOR"; - case D3D12_BLEND_SRC1_COLOR: return "SRC1_COLOR"; - case D3D12_BLEND_INV_SRC1_COLOR: return "INV_SRC1_COLOR"; - case D3D12_BLEND_SRC1_ALPHA: return "SRC1_ALPHA"; - case D3D12_BLEND_INV_SRC1_ALPHA: return "INV_SRC1_ALPHA"; - default: break; - } - - // possible for unused fields via 0-initialisation - if((int)el == 0) - return "--"; - - return StringFormat::Fmt("D3D12_BLEND<%d>", el); -} - -string ToStrHelper::Get(const D3D12_BLEND_OP &el) -{ - switch(el) - { - case D3D12_BLEND_OP_ADD: return "ADD"; - case D3D12_BLEND_OP_SUBTRACT: return "SUBTRACT"; - case D3D12_BLEND_OP_REV_SUBTRACT: return "REV_SUBTRACT"; - case D3D12_BLEND_OP_MIN: return "MIN"; - case D3D12_BLEND_OP_MAX: return "MAX"; - default: break; - } - - // possible for unused fields via 0-initialisation - if((int)el == 0) - return "--"; - - return StringFormat::Fmt("D3D12_BLEND_OP<%d>", el); -} - -string ToStrHelper::Get(const D3D12_LOGIC_OP &el) -{ - switch(el) - { - case D3D12_LOGIC_OP_CLEAR: return "CLEAR"; - case D3D12_LOGIC_OP_SET: return "SET"; - case D3D12_LOGIC_OP_COPY: return "COPY"; - case D3D12_LOGIC_OP_COPY_INVERTED: return "COPY_INVERTED"; - case D3D12_LOGIC_OP_NOOP: return "NOOP"; - case D3D12_LOGIC_OP_INVERT: return "INVERT"; - case D3D12_LOGIC_OP_AND: return "AND"; - case D3D12_LOGIC_OP_NAND: return "NAND"; - case D3D12_LOGIC_OP_OR: return "OR"; - case D3D12_LOGIC_OP_NOR: return "NOR"; - case D3D12_LOGIC_OP_XOR: return "XOR"; - case D3D12_LOGIC_OP_EQUIV: return "EQUIV"; - case D3D12_LOGIC_OP_AND_REVERSE: return "AND_REVERSE"; - case D3D12_LOGIC_OP_AND_INVERTED: return "AND_INVERTED"; - case D3D12_LOGIC_OP_OR_REVERSE: return "OR_REVERSE"; - case D3D12_LOGIC_OP_OR_INVERTED: return "OR_INVERTED"; - default: break; - } - - return StringFormat::Fmt("D3D12_LOGIC_OP<%d>", el); -} - -string ToStrHelper::Get(const D3D12_FILL_MODE &el) -{ - switch(el) - { - case D3D12_FILL_MODE_WIREFRAME: return "WIREFRAME"; - case D3D12_FILL_MODE_SOLID: return "SOLID"; - default: break; - } - - // possible for unused fields via 0-initialisation - if((int)el == 0) - return "--"; - - return StringFormat::Fmt("D3D12_FILL_MODE<%d>", el); -} - -string ToStrHelper::Get(const D3D12_CULL_MODE &el) -{ - switch(el) - { - case D3D12_CULL_MODE_NONE: return "NONE"; - case D3D12_CULL_MODE_FRONT: return "FRONT"; - case D3D12_CULL_MODE_BACK: return "BACK"; - default: break; - } - - // possible for unused fields via 0-initialisation - if((int)el == 0) - return "--"; - - return StringFormat::Fmt("D3D12_CULL_MODE<%d>", el); -} - -string ToStrHelper::Get( - const D3D12_CONSERVATIVE_RASTERIZATION_MODE &el) -{ - switch(el) - { - TOSTR_CASE_STRINGIZE(D3D12_CONSERVATIVE_RASTERIZATION_MODE_OFF) - TOSTR_CASE_STRINGIZE(D3D12_CONSERVATIVE_RASTERIZATION_MODE_ON) - default: break; - } - - return StringFormat::Fmt("D3D12_CONSERVATIVE_RASTERIZATION_MODE<%d>", el); -} - -string ToStrHelper::Get(const D3D12_COMPARISON_FUNC &el) -{ - switch(el) - { - case D3D12_COMPARISON_FUNC_NEVER: return "NEVER"; - case D3D12_COMPARISON_FUNC_LESS: return "LESS"; - case D3D12_COMPARISON_FUNC_EQUAL: return "EQUAL"; - case D3D12_COMPARISON_FUNC_LESS_EQUAL: return "LESS_EQUAL"; - case D3D12_COMPARISON_FUNC_GREATER: return "GREATER"; - case D3D12_COMPARISON_FUNC_NOT_EQUAL: return "NOT_EQUAL"; - case D3D12_COMPARISON_FUNC_GREATER_EQUAL: return "GREATER_EQUAL"; - case D3D12_COMPARISON_FUNC_ALWAYS: return "ALWAYS"; - default: break; - } - - // possible for unused fields via 0-initialisation - if((int)el == 0) - return "--"; - - return StringFormat::Fmt("D3D12_COMPARISON_FUNC<%d>", el); -} - -string ToStrHelper::Get(const D3D12_DEPTH_WRITE_MASK &el) -{ - switch(el) - { - TOSTR_CASE_STRINGIZE(D3D12_DEPTH_WRITE_MASK_ZERO) - TOSTR_CASE_STRINGIZE(D3D12_DEPTH_WRITE_MASK_ALL) - default: break; - } - - return StringFormat::Fmt("D3D12_DEPTH_WRITE_MASK<%d>", el); -} - -string ToStrHelper::Get(const D3D12_STENCIL_OP &el) -{ - switch(el) - { - case D3D12_STENCIL_OP_KEEP: return "KEEP"; - case D3D12_STENCIL_OP_ZERO: return "ZERO"; - case D3D12_STENCIL_OP_REPLACE: return "REPLACE"; - case D3D12_STENCIL_OP_INCR_SAT: return "INCR_SAT"; - case D3D12_STENCIL_OP_DECR_SAT: return "DECR_SAT"; - case D3D12_STENCIL_OP_INVERT: return "INVERT"; - case D3D12_STENCIL_OP_INCR: return "INCR"; - case D3D12_STENCIL_OP_DECR: return "DECR"; - default: break; - } - - // possible for unused fields via 0-initialisation - if((int)el == 0) - return "--"; - - return StringFormat::Fmt("D3D12_STENCIL_OP<%d>", el); -} - -string ToStrHelper::Get(const D3D12_INPUT_CLASSIFICATION &el) -{ - switch(el) - { - TOSTR_CASE_STRINGIZE(D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA) - TOSTR_CASE_STRINGIZE(D3D12_INPUT_CLASSIFICATION_PER_INSTANCE_DATA) - default: break; - } - - return StringFormat::Fmt("D3D12_INPUT_CLASSIFICATION<%d>", el); -} - -string ToStrHelper::Get( - const D3D12_INDEX_BUFFER_STRIP_CUT_VALUE &el) -{ - switch(el) - { - TOSTR_CASE_STRINGIZE(D3D12_INDEX_BUFFER_STRIP_CUT_VALUE_DISABLED) - TOSTR_CASE_STRINGIZE(D3D12_INDEX_BUFFER_STRIP_CUT_VALUE_0xFFFF) - TOSTR_CASE_STRINGIZE(D3D12_INDEX_BUFFER_STRIP_CUT_VALUE_0xFFFFFFFF) - default: break; - } - - return StringFormat::Fmt("D3D12_INDEX_BUFFER_STRIP_CUT_VALUE<%d>", el); -} - -string ToStrHelper::Get(const D3D12_PRIMITIVE_TOPOLOGY_TYPE &el) -{ - switch(el) - { - TOSTR_CASE_STRINGIZE(D3D12_PRIMITIVE_TOPOLOGY_TYPE_UNDEFINED) - TOSTR_CASE_STRINGIZE(D3D12_PRIMITIVE_TOPOLOGY_TYPE_POINT) - TOSTR_CASE_STRINGIZE(D3D12_PRIMITIVE_TOPOLOGY_TYPE_LINE) - TOSTR_CASE_STRINGIZE(D3D12_PRIMITIVE_TOPOLOGY_TYPE_TRIANGLE) - TOSTR_CASE_STRINGIZE(D3D12_PRIMITIVE_TOPOLOGY_TYPE_PATCH) - default: break; - } - - return StringFormat::Fmt("D3D12_PRIMITIVE_TOPOLOGY_TYPE<%d>", el); -} - -string ToStrHelper::Get(const D3D12_INDIRECT_ARGUMENT_TYPE &el) -{ - switch(el) - { - TOSTR_CASE_STRINGIZE(D3D12_INDIRECT_ARGUMENT_TYPE_DRAW) - TOSTR_CASE_STRINGIZE(D3D12_INDIRECT_ARGUMENT_TYPE_DRAW_INDEXED) - TOSTR_CASE_STRINGIZE(D3D12_INDIRECT_ARGUMENT_TYPE_DISPATCH) - TOSTR_CASE_STRINGIZE(D3D12_INDIRECT_ARGUMENT_TYPE_VERTEX_BUFFER_VIEW) - TOSTR_CASE_STRINGIZE(D3D12_INDIRECT_ARGUMENT_TYPE_INDEX_BUFFER_VIEW) - TOSTR_CASE_STRINGIZE(D3D12_INDIRECT_ARGUMENT_TYPE_CONSTANT) - TOSTR_CASE_STRINGIZE(D3D12_INDIRECT_ARGUMENT_TYPE_CONSTANT_BUFFER_VIEW) - TOSTR_CASE_STRINGIZE(D3D12_INDIRECT_ARGUMENT_TYPE_SHADER_RESOURCE_VIEW) - TOSTR_CASE_STRINGIZE(D3D12_INDIRECT_ARGUMENT_TYPE_UNORDERED_ACCESS_VIEW) - default: break; - } - - return StringFormat::Fmt("D3D12_INDIRECT_ARGUMENT_TYPE<%d>", el); -} - -string ToStrHelper::Get(const D3D12_COMMAND_LIST_TYPE &el) -{ - switch(el) - { - TOSTR_CASE_STRINGIZE(D3D12_COMMAND_LIST_TYPE_DIRECT) - TOSTR_CASE_STRINGIZE(D3D12_COMMAND_LIST_TYPE_BUNDLE) - TOSTR_CASE_STRINGIZE(D3D12_COMMAND_LIST_TYPE_COMPUTE) - TOSTR_CASE_STRINGIZE(D3D12_COMMAND_LIST_TYPE_COPY) - default: break; - } - - return StringFormat::Fmt("D3D12_COMMAND_LIST_TYPE<%d>", el); -} - -string ToStrHelper::Get(const D3D12_TEXTURE_COPY_TYPE &el) -{ - switch(el) - { - TOSTR_CASE_STRINGIZE(D3D12_TEXTURE_COPY_TYPE_SUBRESOURCE_INDEX) - TOSTR_CASE_STRINGIZE(D3D12_TEXTURE_COPY_TYPE_PLACED_FOOTPRINT) - default: break; - } - - return StringFormat::Fmt("D3D12_TEXTURE_COPY_TYPE<%d>", el); -} - -string ToStrHelper::Get(const D3D12_RESOURCE_DIMENSION &el) -{ - switch(el) - { - TOSTR_CASE_STRINGIZE(D3D12_RESOURCE_DIMENSION_UNKNOWN) - TOSTR_CASE_STRINGIZE(D3D12_RESOURCE_DIMENSION_BUFFER) - TOSTR_CASE_STRINGIZE(D3D12_RESOURCE_DIMENSION_TEXTURE1D) - TOSTR_CASE_STRINGIZE(D3D12_RESOURCE_DIMENSION_TEXTURE2D) - TOSTR_CASE_STRINGIZE(D3D12_RESOURCE_DIMENSION_TEXTURE3D) - default: break; - } - - return StringFormat::Fmt("D3D12_RESOURCE_DIMENSION<%d>", el); -} - -string ToStrHelper::Get(const D3D12_TEXTURE_LAYOUT &el) -{ - switch(el) - { - TOSTR_CASE_STRINGIZE(D3D12_TEXTURE_LAYOUT_UNKNOWN) - TOSTR_CASE_STRINGIZE(D3D12_TEXTURE_LAYOUT_ROW_MAJOR) - TOSTR_CASE_STRINGIZE(D3D12_TEXTURE_LAYOUT_64KB_UNDEFINED_SWIZZLE) - TOSTR_CASE_STRINGIZE(D3D12_TEXTURE_LAYOUT_64KB_STANDARD_SWIZZLE) - default: break; - } - - return StringFormat::Fmt("D3D12_TEXTURE_LAYOUT<%d>", el); -} - -string ToStrHelper::Get(const D3D12_CLEAR_FLAGS &el) -{ - string ret; - - if(el & D3D12_CLEAR_FLAG_DEPTH) - ret += " | D3D12_CLEAR_FLAG_DEPTH"; - - if(el & D3D12_CLEAR_FLAG_STENCIL) - ret += " | D3D12_CLEAR_FLAG_STENCIL"; - - if(!ret.empty()) - ret = ret.substr(3); - - return ret; -} - -string ToStrHelper::Get(const D3D12_BUFFER_SRV_FLAGS &el) -{ - string ret; - - if(el == D3D12_BUFFER_SRV_FLAG_NONE) - return "D3D12_BUFFER_SRV_FLAG_NONE"; - - if(el & D3D12_BUFFER_SRV_FLAG_RAW) - ret += " | D3D12_BUFFER_SRV_FLAG_RAW"; - - if(!ret.empty()) - ret = ret.substr(3); - - return ret; -} - -string ToStrHelper::Get(const D3D12_DSV_FLAGS &el) -{ - string ret; - - if(el == D3D12_DSV_FLAG_NONE) - return "D3D12_DSV_FLAG_NONE"; - - if(el & D3D12_DSV_FLAG_READ_ONLY_DEPTH) - ret += " | D3D12_DSV_FLAG_READ_ONLY_DEPTH"; - if(el & D3D12_DSV_FLAG_READ_ONLY_STENCIL) - ret += " | D3D12_DSV_FLAG_READ_ONLY_STENCIL"; - - if(!ret.empty()) - ret = ret.substr(3); - - return ret; -} - -string ToStrHelper::Get(const D3D12_BUFFER_UAV_FLAGS &el) -{ - string ret; - - if(el == D3D12_BUFFER_UAV_FLAG_NONE) - return "D3D12_BUFFER_UAV_FLAG_NONE"; - - if(el & D3D12_BUFFER_UAV_FLAG_RAW) - ret += " | D3D12_BUFFER_UAV_FLAG_RAW"; - - if(!ret.empty()) - ret = ret.substr(3); - - return ret; -} - -string ToStrHelper::Get(const D3D12_HEAP_FLAGS &el) -{ - string ret; - - if(el == D3D12_HEAP_FLAG_NONE) - return "D3D12_HEAP_FLAG_NONE"; - - if(el & D3D12_HEAP_FLAG_SHARED) - ret += " | D3D12_HEAP_FLAG_SHARED"; - if(el & D3D12_HEAP_FLAG_DENY_BUFFERS) - ret += " | D3D12_HEAP_FLAG_DENY_BUFFERS"; - if(el & D3D12_HEAP_FLAG_ALLOW_DISPLAY) - ret += " | D3D12_HEAP_FLAG_ALLOW_DISPLAY"; - if(el & D3D12_HEAP_FLAG_SHARED_CROSS_ADAPTER) - ret += " | D3D12_HEAP_FLAG_SHARED_CROSS_ADAPTER"; - if(el & D3D12_HEAP_FLAG_DENY_RT_DS_TEXTURES) - ret += " | D3D12_HEAP_FLAG_DENY_RT_DS_TEXTURES"; - if(el & D3D12_HEAP_FLAG_DENY_NON_RT_DS_TEXTURES) - ret += " | D3D12_HEAP_FLAG_DENY_NON_RT_DS_TEXTURES"; - if(el & D3D12_HEAP_FLAG_ALLOW_ALL_BUFFERS_AND_TEXTURES) - ret += " | D3D12_HEAP_FLAG_ALLOW_ALL_BUFFERS_AND_TEXTURES"; - if(el & D3D12_HEAP_FLAG_ALLOW_ONLY_BUFFERS) - ret += " | D3D12_HEAP_FLAG_ALLOW_ONLY_BUFFERS"; - if(el & D3D12_HEAP_FLAG_ALLOW_ONLY_NON_RT_DS_TEXTURES) - ret += " | D3D12_HEAP_FLAG_ALLOW_ONLY_NON_RT_DS_TEXTURES"; - if(el & D3D12_HEAP_FLAG_ALLOW_ONLY_RT_DS_TEXTURES) - ret += " | D3D12_HEAP_FLAG_ALLOW_ONLY_RT_DS_TEXTURES"; - - if(!ret.empty()) - ret = ret.substr(3); - - return ret; -} - -string ToStrHelper::Get(const D3D12_FENCE_FLAGS &el) -{ - string ret; - - if(el == D3D12_FENCE_FLAG_NONE) - return "D3D12_FENCE_FLAG_NONE"; - - if(el & D3D12_FENCE_FLAG_SHARED) - ret += " | D3D12_FENCE_FLAG_SHARED"; - if(el & D3D12_FENCE_FLAG_SHARED_CROSS_ADAPTER) - ret += " | D3D12_FENCE_FLAG_SHARED_CROSS_ADAPTER"; - - if(!ret.empty()) - ret = ret.substr(3); - - return ret; -} - -string ToStrHelper::Get(const D3D12_DESCRIPTOR_HEAP_FLAGS &el) -{ - string ret; - - if(el == D3D12_DESCRIPTOR_HEAP_FLAG_NONE) - return "D3D12_DESCRIPTOR_HEAP_FLAG_NONE"; - - if(el & D3D12_DESCRIPTOR_HEAP_FLAG_SHADER_VISIBLE) - ret += " | D3D12_DESCRIPTOR_HEAP_FLAG_SHADER_VISIBLE"; - - if(!ret.empty()) - ret = ret.substr(3); - - return ret; -} - -string ToStrHelper::Get(const D3D12_RESOURCE_BARRIER_FLAGS &el) -{ - string ret; - - if(el == D3D12_RESOURCE_BARRIER_FLAG_NONE) - return "D3D12_RESOURCE_BARRIER_FLAG_NONE"; - - if(el & D3D12_RESOURCE_BARRIER_FLAG_BEGIN_ONLY) - ret += " | D3D12_RESOURCE_BARRIER_FLAG_BEGIN_ONLY"; - if(el & D3D12_RESOURCE_BARRIER_FLAG_END_ONLY) - ret += " | D3D12_RESOURCE_BARRIER_FLAG_END_ONLY"; - - if(!ret.empty()) - ret = ret.substr(3); - - return ret; -} - -string ToStrHelper::Get(const D3D12_RESOURCE_STATES &el) -{ - string ret; - - if(el == D3D12_RESOURCE_STATE_COMMON) - return "COMMON/PRESENT"; - - if(el == D3D12_RESOURCE_STATE_GENERIC_READ) - return "GENERIC_READ"; - - if(el & D3D12_RESOURCE_STATE_VERTEX_AND_CONSTANT_BUFFER) - ret += " | VB & CB"; - if(el & D3D12_RESOURCE_STATE_INDEX_BUFFER) - ret += " | IB"; - if(el & D3D12_RESOURCE_STATE_RENDER_TARGET) - ret += " | RTV"; - if(el & D3D12_RESOURCE_STATE_UNORDERED_ACCESS) - ret += " | UAV"; - if(el & D3D12_RESOURCE_STATE_DEPTH_WRITE) - ret += " | DSV Write"; - if(el & D3D12_RESOURCE_STATE_DEPTH_READ) - ret += " | DSV Read"; - if(el & D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE) - ret += " | SRV (Non-Pixel)"; - if(el & D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE) - ret += " | SRV (Pixel)"; - if(el & D3D12_RESOURCE_STATE_STREAM_OUT) - ret += " | Stream Out"; - if(el & D3D12_RESOURCE_STATE_INDIRECT_ARGUMENT) - ret += " | Indirect"; - if(el & D3D12_RESOURCE_STATE_COPY_DEST) - ret += " | Copy (Dst)"; - if(el & D3D12_RESOURCE_STATE_COPY_SOURCE) - ret += " | Copy (Src)"; - if(el & D3D12_RESOURCE_STATE_RESOLVE_DEST) - ret += " | Resolve (Dst)"; - if(el & D3D12_RESOURCE_STATE_RESOLVE_SOURCE) - ret += " | Resolve (Src)"; - if(el & D3D12_RESOURCE_STATE_PREDICATION) - ret += " | Predication"; - - if(!ret.empty()) - ret = ret.substr(3); - - return ret; -} - -string ToStrHelper::Get(const D3D12_PIPELINE_STATE_FLAGS &el) -{ - string ret; - - if(el == D3D12_PIPELINE_STATE_FLAG_NONE) - return "D3D12_PIPELINE_STATE_FLAG_NONE"; - - if(el & D3D12_PIPELINE_STATE_FLAG_TOOL_DEBUG) - ret += " | D3D12_PIPELINE_STATE_FLAG_TOOL_DEBUG"; - - if(!ret.empty()) - ret = ret.substr(3); - - return ret; -} - -string ToStrHelper::Get(const D3D12_RESOURCE_FLAGS &el) -{ - string ret; - - if(el == D3D12_RESOURCE_FLAG_NONE) - return "D3D12_RESOURCE_FLAG_NONE"; - - if(el & D3D12_RESOURCE_FLAG_ALLOW_RENDER_TARGET) - ret += " | D3D12_RESOURCE_FLAG_ALLOW_RENDER_TARGET"; - if(el & D3D12_RESOURCE_FLAG_ALLOW_DEPTH_STENCIL) - ret += " | D3D12_RESOURCE_FLAG_ALLOW_DEPTH_STENCIL"; - if(el & D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS) - ret += " | D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS"; - if(el & D3D12_RESOURCE_FLAG_DENY_SHADER_RESOURCE) - ret += " | D3D12_RESOURCE_FLAG_DENY_SHADER_RESOURCE"; - if(el & D3D12_RESOURCE_FLAG_ALLOW_CROSS_ADAPTER) - ret += " | D3D12_RESOURCE_FLAG_ALLOW_CROSS_ADAPTER"; - if(el & D3D12_RESOURCE_FLAG_ALLOW_SIMULTANEOUS_ACCESS) - ret += " | D3D12_RESOURCE_FLAG_ALLOW_SIMULTANEOUS_ACCESS"; - - if(!ret.empty()) - ret = ret.substr(3); - - return ret; -} - -string ToStrHelper::Get(const D3D12_COMMAND_QUEUE_FLAGS &el) -{ - string ret; - - if(el == D3D12_COMMAND_QUEUE_FLAG_NONE) - return "D3D12_COMMAND_QUEUE_FLAG_NONE"; - - if(el & D3D12_COMMAND_QUEUE_FLAG_DISABLE_GPU_TIMEOUT) - ret += " | D3D12_COMMAND_QUEUE_FLAG_DISABLE_GPU_TIMEOUT"; - - if(!ret.empty()) - ret = ret.substr(3); - - return ret; -} - -string ToStrHelper::Get(const D3D12_TILE_COPY_FLAGS &el) -{ - string ret; - - if(el == D3D12_TILE_COPY_FLAG_NONE) - return "D3D12_TILE_COPY_FLAG_NONE"; - - if(el & D3D12_TILE_COPY_FLAG_NO_HAZARD) - ret += " | D3D12_TILE_COPY_FLAG_NO_HAZARD"; - - if(el & D3D12_TILE_COPY_FLAG_LINEAR_BUFFER_TO_SWIZZLED_TILED_RESOURCE) - ret += " | D3D12_TILE_COPY_FLAG_LINEAR_BUFFER_TO_SWIZZLED_TILED_RESOURCE"; - - if(el & D3D12_TILE_COPY_FLAG_SWIZZLED_TILED_RESOURCE_TO_LINEAR_BUFFER) - ret += " | D3D12_TILE_COPY_FLAG_SWIZZLED_TILED_RESOURCE_TO_LINEAR_BUFFER"; - - if(!ret.empty()) - ret = ret.substr(3); - - return ret; -} - -string ToStrHelper::Get(const D3D12_TILE_MAPPING_FLAGS &el) -{ - string ret; - - if(el == D3D12_TILE_MAPPING_FLAG_NONE) - return "D3D12_TILE_MAPPING_FLAG_NONE"; - - if(el & D3D12_TILE_MAPPING_FLAG_NO_HAZARD) - ret += " | D3D12_TILE_MAPPING_FLAG_NO_HAZARD"; - - if(!ret.empty()) - ret = ret.substr(3); - - return ret; -} - -string ToStrHelper::Get(const D3D12_TILE_RANGE_FLAGS &el) -{ - string ret; - - if(el == D3D12_TILE_RANGE_FLAG_NONE) - return "D3D12_TILE_RANGE_FLAG_NONE"; - - if(el & D3D12_TILE_RANGE_FLAG_NULL) - ret += " | D3D12_TILE_RANGE_FLAG_NULL"; - - if(el & D3D12_TILE_RANGE_FLAG_SKIP) - ret += " | D3D12_TILE_RANGE_FLAG_SKIP"; - - if(el & D3D12_TILE_RANGE_FLAG_REUSE_SINGLE_TILE) - ret += " | D3D12_TILE_RANGE_FLAG_REUSE_SINGLE_TILE"; - - if(!ret.empty()) - ret = ret.substr(3); - - return ret; -} - -string ToStrHelper::Get(const D3D12_TILED_RESOURCES_TIER &el) -{ - string ret; - - if(el == D3D12_TILED_RESOURCES_TIER_NOT_SUPPORTED) - return "D3D12_TILED_RESOURCES_TIER_NOT_SUPPORTED"; - - if(el & D3D12_TILED_RESOURCES_TIER_1) - ret += " | D3D12_TILED_RESOURCES_TIER_1"; - - if(el & D3D12_TILED_RESOURCES_TIER_2) - ret += " | D3D12_TILED_RESOURCES_TIER_2"; - - if(el & D3D12_TILED_RESOURCES_TIER_3) - ret += " | D3D12_TILED_RESOURCES_TIER_3"; - - if(!ret.empty()) - ret = ret.substr(3); - - return ret; + return StringFormat::Fmt("D3D12_CPU_DESCRIPTOR_HANDLE(%s, %u)", ToStr(el.heap).c_str(), el.index); } diff --git a/renderdoc/driver/d3d12/d3d12_debug.cpp b/renderdoc/driver/d3d12/d3d12_debug.cpp index 10ff8856d..5b703be69 100644 --- a/renderdoc/driver/d3d12/d3d12_debug.cpp +++ b/renderdoc/driver/d3d12/d3d12_debug.cpp @@ -742,7 +742,7 @@ D3D12DebugManager::D3D12DebugManager(WrappedID3D12Device *wrapper) ID3DBlob *result = NULL; ID3DBlob *histogram = NULL; - string hlsl = string("#define SHADER_RESTYPE ") + ToStr::Get(t) + "\n"; + string hlsl = string("#define SHADER_RESTYPE ") + ToStr(t) + "\n"; hlsl += string("#define UINT_TEX ") + (i == 1 ? "1" : "0") + "\n"; hlsl += string("#define SINT_TEX ") + (i == 2 ? "1" : "0") + "\n"; hlsl += histogramhlsl; diff --git a/renderdoc/driver/d3d12/d3d12_device.cpp b/renderdoc/driver/d3d12/d3d12_device.cpp index fa12a3818..10472180f 100644 --- a/renderdoc/driver/d3d12/d3d12_device.cpp +++ b/renderdoc/driver/d3d12/d3d12_device.cpp @@ -89,7 +89,7 @@ const char *WrappedID3D12Device::GetChunkName(uint32_t idx) } template <> -string ToStrHelper::Get(const D3D12ChunkType &el) +std::string DoStringise(const D3D12ChunkType &el) { return WrappedID3D12Device::GetChunkName(el); } @@ -131,7 +131,7 @@ HRESULT STDMETHODCALLTYPE DummyID3D12DebugDevice::QueryInterface(REFIID riid, vo return S_OK; } - RDCWARN("Querying ID3D12DebugDevice for interface: %s", ToStr::Get(riid).c_str()); + RDCWARN("Querying ID3D12DebugDevice for interface: %s", ToStr(riid).c_str()); return E_NOINTERFACE; } @@ -161,7 +161,7 @@ HRESULT STDMETHODCALLTYPE WrappedID3D12DebugDevice::QueryInterface(REFIID riid, return S_OK; } - string guid = ToStr::Get(riid); + string guid = ToStr(riid); RDCWARN("Querying ID3D12DebugDevice for interface: %s", guid.c_str()); return m_pDebug->QueryInterface(riid, ppvObject); @@ -537,7 +537,7 @@ HRESULT WrappedID3D12Device::QueryInterface(REFIID riid, void **ppvObject) } else { - string guid = ToStr::Get(riid); + string guid = ToStr(riid); RDCWARN("Querying ID3D12Device for interface: %s", guid.c_str()); } diff --git a/renderdoc/driver/d3d12/d3d12_device.h b/renderdoc/driver/d3d12/d3d12_device.h index e3f717600..a282703a0 100644 --- a/renderdoc/driver/d3d12/d3d12_device.h +++ b/renderdoc/driver/d3d12/d3d12_device.h @@ -467,7 +467,7 @@ public: if(iid == __uuidof(ID3D12Device)) return (ID3D12Device *)this; - RDCERR("Requested unknown device interface %s", ToStr::Get(iid).c_str()); + RDCERR("Requested unknown device interface %s", ToStr(iid).c_str()); return NULL; } diff --git a/renderdoc/driver/d3d12/d3d12_device_wrap.cpp b/renderdoc/driver/d3d12/d3d12_device_wrap.cpp index 7051489b1..a9a8f4cbf 100644 --- a/renderdoc/driver/d3d12/d3d12_device_wrap.cpp +++ b/renderdoc/driver/d3d12/d3d12_device_wrap.cpp @@ -993,7 +993,7 @@ bool WrappedID3D12Device::Serialise_CreateCommittedResource( else { SetObjName(ret, StringFormat::Fmt("Committed Resource %s ID %llu", - ToStr::Get(desc.Dimension).c_str(), Res)); + ToStr(desc.Dimension).c_str(), Res)); ret = new WrappedID3D12Resource(ret, this); @@ -1187,8 +1187,8 @@ bool WrappedID3D12Device::Serialise_CreatePlacedResource( } else { - SetObjName(ret, StringFormat::Fmt("Placed Resource %s ID %llu", - ToStr::Get(desc.Dimension).c_str(), Res)); + SetObjName( + ret, StringFormat::Fmt("Placed Resource %s ID %llu", ToStr(desc.Dimension).c_str(), Res)); ret = new WrappedID3D12Resource(ret, this); diff --git a/renderdoc/driver/d3d12/d3d12_hooks.cpp b/renderdoc/driver/d3d12/d3d12_hooks.cpp index 3bbf09176..fc6639811 100644 --- a/renderdoc/driver/d3d12/d3d12_hooks.cpp +++ b/renderdoc/driver/d3d12/d3d12_hooks.cpp @@ -175,12 +175,11 @@ private: if(riid != __uuidof(ID3D12Device) && riid != __uuidof(ID3D12Device1)) { - RDCERR("Unsupported UUID %s for D3D12CreateDevice", ToStr::Get(riid).c_str()); + RDCERR("Unsupported UUID %s for D3D12CreateDevice", ToStr(riid).c_str()); return E_NOINTERFACE; } - RDCDEBUG("Call to Create_Internal Feature Level %x", MinimumFeatureLevel, - ToStr::Get(riid).c_str()); + RDCDEBUG("Call to Create_Internal Feature Level %x", MinimumFeatureLevel, ToStr(riid).c_str()); bool reading = RenderDoc::Inst().IsReplayApp(); @@ -330,7 +329,7 @@ private: releaseme->Release(); RDCWARN("Unknown UUID passed to D3D12GetDebugInterface: %s. Real call %s succeed (%x).", - ToStr::Get(riid).c_str(), SUCCEEDED(real) ? "did" : "did not", real); + ToStr(riid).c_str(), SUCCEEDED(real) ? "did" : "did not", real); return E_NOINTERFACE; } diff --git a/renderdoc/driver/d3d12/d3d12_replay.cpp b/renderdoc/driver/d3d12/d3d12_replay.cpp index b540e242f..c6ce0f163 100644 --- a/renderdoc/driver/d3d12/d3d12_replay.cpp +++ b/renderdoc/driver/d3d12/d3d12_replay.cpp @@ -1189,7 +1189,7 @@ void D3D12Replay::SavePipelineState() res.states.resize(it->second.size()); for(size_t l = 0; l < it->second.size(); l++) - res.states[l].name = ToStr::Get(it->second[l]); + res.states[l].name = ToStr(it->second[l]); i++; } diff --git a/renderdoc/driver/d3d12/d3d12_resources.h b/renderdoc/driver/d3d12/d3d12_resources.h index 92b7751cc..4efb451f7 100644 --- a/renderdoc/driver/d3d12/d3d12_resources.h +++ b/renderdoc/driver/d3d12/d3d12_resources.h @@ -69,7 +69,7 @@ protected: { bool ret = m_pDevice->GetResourceManager()->AddWrapper(this, real); if(!ret) - RDCERR("Error adding wrapper for type %s", ToStr::Get(__uuidof(NestedType)).c_str()); + RDCERR("Error adding wrapper for type %s", ToStr(__uuidof(NestedType)).c_str()); } m_pDevice->GetResourceManager()->AddCurrentResource(GetResourceID(), this); @@ -239,7 +239,7 @@ public: } else { - RDCWARN("Unexpected guid %s", ToStr::Get(riid).c_str()); + RDCWARN("Unexpected guid %s", ToStr(riid).c_str()); SAFE_DELETE(dxgiWrapper); } diff --git a/renderdoc/driver/d3d12/d3d12_stringise.cpp b/renderdoc/driver/d3d12/d3d12_stringise.cpp new file mode 100644 index 000000000..6d34c1ffd --- /dev/null +++ b/renderdoc/driver/d3d12/d3d12_stringise.cpp @@ -0,0 +1,819 @@ +/****************************************************************************** + * The MIT License (MIT) + * + * Copyright (c) 2016-2017 Baldur Karlsson + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ + +#include "d3d12_common.h" +#include "d3d12_resources.h" + +template <> +std::string DoStringise(const D3D12Descriptor::DescriptorType &el) +{ + if((uint32_t)el < D3D12Descriptor::TypeCBV) + return "Sampler"; + + BEGIN_ENUM_STRINGISE(D3D12Descriptor::DescriptorType); + { + STRINGISE_ENUM_NAMED(D3D12Descriptor::TypeCBV, "CBV"); + STRINGISE_ENUM_NAMED(D3D12Descriptor::TypeSRV, "SRV"); + STRINGISE_ENUM_NAMED(D3D12Descriptor::TypeUAV, "UAV"); + STRINGISE_ENUM_NAMED(D3D12Descriptor::TypeRTV, "RTV"); + STRINGISE_ENUM_NAMED(D3D12Descriptor::TypeDSV, "DSV"); + STRINGISE_ENUM_NAMED(D3D12Descriptor::TypeUndefined, "Undefined"); + } + END_ENUM_STRINGISE(); +} + +template <> +std::string DoStringise(const D3D12ResourceType &el) +{ + BEGIN_ENUM_STRINGISE(D3D12ResourceType); + { + STRINGISE_ENUM_NAMED(Resource_Device, "Device"); + STRINGISE_ENUM_NAMED(Resource_Unknown, "Unknown"); + STRINGISE_ENUM_NAMED(Resource_CommandAllocator, "Command Allocator"); + STRINGISE_ENUM_NAMED(Resource_CommandQueue, "Command Queue"); + STRINGISE_ENUM_NAMED(Resource_CommandSignature, "Command Signature"); + STRINGISE_ENUM_NAMED(Resource_DescriptorHeap, "Descriptor Heap"); + STRINGISE_ENUM_NAMED(Resource_Fence, "Fence"); + STRINGISE_ENUM_NAMED(Resource_Heap, "Heap"); + STRINGISE_ENUM_NAMED(Resource_PipelineState, "Pipeline State"); + STRINGISE_ENUM_NAMED(Resource_QueryHeap, "Query Heap"); + STRINGISE_ENUM_NAMED(Resource_Resource, "Resource"); + STRINGISE_ENUM_NAMED(Resource_GraphicsCommandList, "Graphics CommandList"); + STRINGISE_ENUM_NAMED(Resource_RootSignature, "Root Signature"); + } + END_ENUM_STRINGISE(); +} + +template <> +std::string DoStringise(const D3D12_HEAP_TYPE &el) +{ + BEGIN_ENUM_STRINGISE(D3D12_HEAP_TYPE); + { + STRINGISE_ENUM(D3D12_HEAP_TYPE_DEFAULT) + STRINGISE_ENUM(D3D12_HEAP_TYPE_UPLOAD) + STRINGISE_ENUM(D3D12_HEAP_TYPE_READBACK) + STRINGISE_ENUM(D3D12_HEAP_TYPE_CUSTOM) + } + END_ENUM_STRINGISE(); +} + +template <> +std::string DoStringise(const D3D12_CPU_PAGE_PROPERTY &el) +{ + BEGIN_ENUM_STRINGISE(D3D12_CPU_PAGE_PROPERTY); + { + STRINGISE_ENUM(D3D12_CPU_PAGE_PROPERTY_UNKNOWN) + STRINGISE_ENUM(D3D12_CPU_PAGE_PROPERTY_NOT_AVAILABLE) + STRINGISE_ENUM(D3D12_CPU_PAGE_PROPERTY_WRITE_COMBINE) + STRINGISE_ENUM(D3D12_CPU_PAGE_PROPERTY_WRITE_BACK) + } + END_ENUM_STRINGISE(); +} + +template <> +std::string DoStringise(const D3D12_MEMORY_POOL &el) +{ + BEGIN_ENUM_STRINGISE(D3D12_MEMORY_POOL); + { + STRINGISE_ENUM(D3D12_MEMORY_POOL_UNKNOWN) + STRINGISE_ENUM(D3D12_MEMORY_POOL_L0) + STRINGISE_ENUM(D3D12_MEMORY_POOL_L1) + } + END_ENUM_STRINGISE(); +} + +template <> +std::string DoStringise(const D3D12_QUERY_HEAP_TYPE &el) +{ + BEGIN_ENUM_STRINGISE(D3D12_QUERY_HEAP_TYPE); + { + STRINGISE_ENUM(D3D12_QUERY_HEAP_TYPE_OCCLUSION) + STRINGISE_ENUM(D3D12_QUERY_HEAP_TYPE_TIMESTAMP) + STRINGISE_ENUM(D3D12_QUERY_HEAP_TYPE_PIPELINE_STATISTICS) + STRINGISE_ENUM(D3D12_QUERY_HEAP_TYPE_SO_STATISTICS) + } + END_ENUM_STRINGISE(); +} + +template <> +std::string DoStringise(const D3D12_QUERY_TYPE &el) +{ + BEGIN_ENUM_STRINGISE(D3D12_QUERY_TYPE); + { + STRINGISE_ENUM(D3D12_QUERY_TYPE_OCCLUSION) + STRINGISE_ENUM(D3D12_QUERY_TYPE_BINARY_OCCLUSION) + STRINGISE_ENUM(D3D12_QUERY_TYPE_TIMESTAMP) + STRINGISE_ENUM(D3D12_QUERY_TYPE_PIPELINE_STATISTICS) + STRINGISE_ENUM(D3D12_QUERY_TYPE_SO_STATISTICS_STREAM0) + STRINGISE_ENUM(D3D12_QUERY_TYPE_SO_STATISTICS_STREAM1) + STRINGISE_ENUM(D3D12_QUERY_TYPE_SO_STATISTICS_STREAM2) + STRINGISE_ENUM(D3D12_QUERY_TYPE_SO_STATISTICS_STREAM3) + } + END_ENUM_STRINGISE(); +} + +template <> +std::string DoStringise(const D3D12_PREDICATION_OP &el) +{ + BEGIN_ENUM_STRINGISE(D3D12_PREDICATION_OP); + { + STRINGISE_ENUM(D3D12_PREDICATION_OP_EQUAL_ZERO) + STRINGISE_ENUM(D3D12_PREDICATION_OP_NOT_EQUAL_ZERO) + } + END_ENUM_STRINGISE(); +} + +template <> +std::string DoStringise(const D3D12_DESCRIPTOR_HEAP_TYPE &el) +{ + BEGIN_ENUM_STRINGISE(D3D12_DESCRIPTOR_HEAP_TYPE); + { + STRINGISE_ENUM(D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV) + STRINGISE_ENUM(D3D12_DESCRIPTOR_HEAP_TYPE_SAMPLER) + STRINGISE_ENUM(D3D12_DESCRIPTOR_HEAP_TYPE_RTV) + STRINGISE_ENUM(D3D12_DESCRIPTOR_HEAP_TYPE_DSV) + } + END_ENUM_STRINGISE(); +} + +template <> +std::string DoStringise(const D3D12_RESOURCE_BARRIER_TYPE &el) +{ + BEGIN_ENUM_STRINGISE(D3D12_RESOURCE_BARRIER_TYPE); + { + STRINGISE_ENUM(D3D12_RESOURCE_BARRIER_TYPE_TRANSITION) + STRINGISE_ENUM(D3D12_RESOURCE_BARRIER_TYPE_ALIASING) + STRINGISE_ENUM(D3D12_RESOURCE_BARRIER_TYPE_UAV) + } + END_ENUM_STRINGISE(); +} + +template <> +std::string DoStringise(const D3D12_SRV_DIMENSION &el) +{ + BEGIN_ENUM_STRINGISE(D3D12_SRV_DIMENSION); + { + STRINGISE_ENUM(D3D12_SRV_DIMENSION_UNKNOWN) + STRINGISE_ENUM(D3D12_SRV_DIMENSION_BUFFER) + STRINGISE_ENUM(D3D12_SRV_DIMENSION_TEXTURE1D) + STRINGISE_ENUM(D3D12_SRV_DIMENSION_TEXTURE1DARRAY) + STRINGISE_ENUM(D3D12_SRV_DIMENSION_TEXTURE2D) + STRINGISE_ENUM(D3D12_SRV_DIMENSION_TEXTURE2DARRAY) + STRINGISE_ENUM(D3D12_SRV_DIMENSION_TEXTURE2DMS) + STRINGISE_ENUM(D3D12_SRV_DIMENSION_TEXTURE2DMSARRAY) + STRINGISE_ENUM(D3D12_SRV_DIMENSION_TEXTURE3D) + STRINGISE_ENUM(D3D12_SRV_DIMENSION_TEXTURECUBE) + STRINGISE_ENUM(D3D12_SRV_DIMENSION_TEXTURECUBEARRAY) + } + END_ENUM_STRINGISE(); +} + +template <> +std::string DoStringise(const D3D12_RTV_DIMENSION &el) +{ + BEGIN_ENUM_STRINGISE(D3D12_RTV_DIMENSION); + { + STRINGISE_ENUM(D3D12_RTV_DIMENSION_UNKNOWN) + STRINGISE_ENUM(D3D12_RTV_DIMENSION_BUFFER) + STRINGISE_ENUM(D3D12_RTV_DIMENSION_TEXTURE1D) + STRINGISE_ENUM(D3D12_RTV_DIMENSION_TEXTURE1DARRAY) + STRINGISE_ENUM(D3D12_RTV_DIMENSION_TEXTURE2D) + STRINGISE_ENUM(D3D12_RTV_DIMENSION_TEXTURE2DARRAY) + STRINGISE_ENUM(D3D12_RTV_DIMENSION_TEXTURE2DMS) + STRINGISE_ENUM(D3D12_RTV_DIMENSION_TEXTURE2DMSARRAY) + STRINGISE_ENUM(D3D12_RTV_DIMENSION_TEXTURE3D) + } + END_ENUM_STRINGISE(); +} + +template <> +std::string DoStringise(const D3D12_UAV_DIMENSION &el) +{ + BEGIN_ENUM_STRINGISE(D3D12_UAV_DIMENSION); + { + STRINGISE_ENUM(D3D12_UAV_DIMENSION_BUFFER) + STRINGISE_ENUM(D3D12_UAV_DIMENSION_TEXTURE1D) + STRINGISE_ENUM(D3D12_UAV_DIMENSION_TEXTURE1DARRAY) + STRINGISE_ENUM(D3D12_UAV_DIMENSION_TEXTURE2D) + STRINGISE_ENUM(D3D12_UAV_DIMENSION_TEXTURE2DARRAY) + STRINGISE_ENUM(D3D12_UAV_DIMENSION_TEXTURE3D) + } + END_ENUM_STRINGISE(); +} + +template <> +std::string DoStringise(const D3D12_DSV_DIMENSION &el) +{ + BEGIN_ENUM_STRINGISE(D3D12_DSV_DIMENSION); + { + STRINGISE_ENUM(D3D12_DSV_DIMENSION_UNKNOWN) + STRINGISE_ENUM(D3D12_DSV_DIMENSION_TEXTURE1D) + STRINGISE_ENUM(D3D12_DSV_DIMENSION_TEXTURE1DARRAY) + STRINGISE_ENUM(D3D12_DSV_DIMENSION_TEXTURE2D) + STRINGISE_ENUM(D3D12_DSV_DIMENSION_TEXTURE2DARRAY) + STRINGISE_ENUM(D3D12_DSV_DIMENSION_TEXTURE2DMS) + STRINGISE_ENUM(D3D12_DSV_DIMENSION_TEXTURE2DMSARRAY) + } + END_ENUM_STRINGISE(); +} + +template <> +std::string DoStringise(const D3D12_FILTER &el) +{ + BEGIN_ENUM_STRINGISE(D3D12_FILTER); + { + STRINGISE_ENUM(D3D12_FILTER_MIN_MAG_MIP_POINT); + STRINGISE_ENUM(D3D12_FILTER_MIN_MAG_POINT_MIP_LINEAR); + STRINGISE_ENUM(D3D12_FILTER_MIN_POINT_MAG_LINEAR_MIP_POINT); + STRINGISE_ENUM(D3D12_FILTER_MIN_POINT_MAG_MIP_LINEAR); + STRINGISE_ENUM(D3D12_FILTER_MIN_LINEAR_MAG_MIP_POINT); + STRINGISE_ENUM(D3D12_FILTER_MIN_LINEAR_MAG_POINT_MIP_LINEAR); + STRINGISE_ENUM(D3D12_FILTER_MIN_MAG_LINEAR_MIP_POINT); + STRINGISE_ENUM(D3D12_FILTER_MIN_MAG_MIP_LINEAR); + STRINGISE_ENUM(D3D12_FILTER_ANISOTROPIC); + STRINGISE_ENUM(D3D12_FILTER_COMPARISON_MIN_MAG_MIP_POINT); + STRINGISE_ENUM(D3D12_FILTER_COMPARISON_MIN_MAG_POINT_MIP_LINEAR); + STRINGISE_ENUM(D3D12_FILTER_COMPARISON_MIN_POINT_MAG_LINEAR_MIP_POINT); + STRINGISE_ENUM(D3D12_FILTER_COMPARISON_MIN_POINT_MAG_MIP_LINEAR); + STRINGISE_ENUM(D3D12_FILTER_COMPARISON_MIN_LINEAR_MAG_MIP_POINT); + STRINGISE_ENUM(D3D12_FILTER_COMPARISON_MIN_LINEAR_MAG_POINT_MIP_LINEAR); + STRINGISE_ENUM(D3D12_FILTER_COMPARISON_MIN_MAG_LINEAR_MIP_POINT); + STRINGISE_ENUM(D3D12_FILTER_COMPARISON_MIN_MAG_MIP_LINEAR); + STRINGISE_ENUM(D3D12_FILTER_COMPARISON_ANISOTROPIC); + STRINGISE_ENUM(D3D12_FILTER_MINIMUM_MIN_MAG_MIP_POINT); + STRINGISE_ENUM(D3D12_FILTER_MINIMUM_MIN_MAG_POINT_MIP_LINEAR); + STRINGISE_ENUM(D3D12_FILTER_MINIMUM_MIN_POINT_MAG_LINEAR_MIP_POINT); + STRINGISE_ENUM(D3D12_FILTER_MINIMUM_MIN_POINT_MAG_MIP_LINEAR); + STRINGISE_ENUM(D3D12_FILTER_MINIMUM_MIN_LINEAR_MAG_MIP_POINT); + STRINGISE_ENUM(D3D12_FILTER_MINIMUM_MIN_LINEAR_MAG_POINT_MIP_LINEAR); + STRINGISE_ENUM(D3D12_FILTER_MINIMUM_MIN_MAG_LINEAR_MIP_POINT); + STRINGISE_ENUM(D3D12_FILTER_MINIMUM_MIN_MAG_MIP_LINEAR); + STRINGISE_ENUM(D3D12_FILTER_MINIMUM_ANISOTROPIC); + STRINGISE_ENUM(D3D12_FILTER_MAXIMUM_MIN_MAG_MIP_POINT); + STRINGISE_ENUM(D3D12_FILTER_MAXIMUM_MIN_MAG_POINT_MIP_LINEAR); + STRINGISE_ENUM(D3D12_FILTER_MAXIMUM_MIN_POINT_MAG_LINEAR_MIP_POINT); + STRINGISE_ENUM(D3D12_FILTER_MAXIMUM_MIN_POINT_MAG_MIP_LINEAR); + STRINGISE_ENUM(D3D12_FILTER_MAXIMUM_MIN_LINEAR_MAG_MIP_POINT); + STRINGISE_ENUM(D3D12_FILTER_MAXIMUM_MIN_LINEAR_MAG_POINT_MIP_LINEAR); + STRINGISE_ENUM(D3D12_FILTER_MAXIMUM_MIN_MAG_LINEAR_MIP_POINT); + STRINGISE_ENUM(D3D12_FILTER_MAXIMUM_MIN_MAG_MIP_LINEAR); + STRINGISE_ENUM(D3D12_FILTER_MAXIMUM_ANISOTROPIC); + } + END_ENUM_STRINGISE(); +} + +template <> +std::string DoStringise(const D3D12_TEXTURE_ADDRESS_MODE &el) +{ + // possible for unused fields via 0-initialisation + if((int)el == 0) + return "--"; + + BEGIN_ENUM_STRINGISE(D3D12_TEXTURE_ADDRESS_MODE); + { + STRINGISE_ENUM(D3D12_TEXTURE_ADDRESS_MODE_WRAP); + STRINGISE_ENUM(D3D12_TEXTURE_ADDRESS_MODE_MIRROR); + STRINGISE_ENUM(D3D12_TEXTURE_ADDRESS_MODE_CLAMP); + STRINGISE_ENUM(D3D12_TEXTURE_ADDRESS_MODE_BORDER); + STRINGISE_ENUM(D3D12_TEXTURE_ADDRESS_MODE_MIRROR_ONCE); + } + END_ENUM_STRINGISE(); +} + +template <> +std::string DoStringise(const D3D12_BLEND &el) +{ + // possible for unused fields via 0-initialisation + if((int)el == 0) + return "--"; + + BEGIN_ENUM_STRINGISE(D3D12_BLEND); + { + STRINGISE_ENUM(D3D12_BLEND_ZERO); + STRINGISE_ENUM(D3D12_BLEND_ONE); + STRINGISE_ENUM(D3D12_BLEND_SRC_COLOR); + STRINGISE_ENUM(D3D12_BLEND_INV_SRC_COLOR); + STRINGISE_ENUM(D3D12_BLEND_SRC_ALPHA); + STRINGISE_ENUM(D3D12_BLEND_INV_SRC_ALPHA); + STRINGISE_ENUM(D3D12_BLEND_DEST_ALPHA); + STRINGISE_ENUM(D3D12_BLEND_INV_DEST_ALPHA); + STRINGISE_ENUM(D3D12_BLEND_DEST_COLOR); + STRINGISE_ENUM(D3D12_BLEND_INV_DEST_COLOR); + STRINGISE_ENUM(D3D12_BLEND_SRC_ALPHA_SAT); + STRINGISE_ENUM(D3D12_BLEND_BLEND_FACTOR); + STRINGISE_ENUM(D3D12_BLEND_INV_BLEND_FACTOR); + STRINGISE_ENUM(D3D12_BLEND_SRC1_COLOR); + STRINGISE_ENUM(D3D12_BLEND_INV_SRC1_COLOR); + STRINGISE_ENUM(D3D12_BLEND_SRC1_ALPHA); + STRINGISE_ENUM(D3D12_BLEND_INV_SRC1_ALPHA); + } + END_ENUM_STRINGISE(); +} + +template <> +std::string DoStringise(const D3D12_BLEND_OP &el) +{ + // possible for unused fields via 0-initialisation + if((int)el == 0) + return "--"; + + BEGIN_ENUM_STRINGISE(D3D12_BLEND_OP); + { + STRINGISE_ENUM(D3D12_BLEND_OP_ADD); + STRINGISE_ENUM(D3D12_BLEND_OP_SUBTRACT); + STRINGISE_ENUM(D3D12_BLEND_OP_REV_SUBTRACT); + STRINGISE_ENUM(D3D12_BLEND_OP_MIN); + STRINGISE_ENUM(D3D12_BLEND_OP_MAX); + } + END_ENUM_STRINGISE(); +} + +template <> +std::string DoStringise(const D3D12_LOGIC_OP &el) +{ + BEGIN_ENUM_STRINGISE(D3D12_LOGIC_OP); + { + STRINGISE_ENUM(D3D12_LOGIC_OP_CLEAR); + STRINGISE_ENUM(D3D12_LOGIC_OP_SET); + STRINGISE_ENUM(D3D12_LOGIC_OP_COPY); + STRINGISE_ENUM(D3D12_LOGIC_OP_COPY_INVERTED); + STRINGISE_ENUM(D3D12_LOGIC_OP_NOOP); + STRINGISE_ENUM(D3D12_LOGIC_OP_INVERT); + STRINGISE_ENUM(D3D12_LOGIC_OP_AND); + STRINGISE_ENUM(D3D12_LOGIC_OP_NAND); + STRINGISE_ENUM(D3D12_LOGIC_OP_OR); + STRINGISE_ENUM(D3D12_LOGIC_OP_NOR); + STRINGISE_ENUM(D3D12_LOGIC_OP_XOR); + STRINGISE_ENUM(D3D12_LOGIC_OP_EQUIV); + STRINGISE_ENUM(D3D12_LOGIC_OP_AND_REVERSE); + STRINGISE_ENUM(D3D12_LOGIC_OP_AND_INVERTED); + STRINGISE_ENUM(D3D12_LOGIC_OP_OR_REVERSE); + STRINGISE_ENUM(D3D12_LOGIC_OP_OR_INVERTED); + } + END_ENUM_STRINGISE(); +} + +template <> +std::string DoStringise(const D3D12_FILL_MODE &el) +{ + // possible for unused fields via 0-initialisation + if((int)el == 0) + return "--"; + + BEGIN_ENUM_STRINGISE(D3D12_FILL_MODE); + { + STRINGISE_ENUM(D3D12_FILL_MODE_WIREFRAME); + STRINGISE_ENUM(D3D12_FILL_MODE_SOLID); + } + END_ENUM_STRINGISE(); +} + +template <> +std::string DoStringise(const D3D12_CULL_MODE &el) +{ + // possible for unused fields via 0-initialisation + if((int)el == 0) + return "--"; + + BEGIN_ENUM_STRINGISE(D3D12_CULL_MODE); + { + STRINGISE_ENUM(D3D12_CULL_MODE_NONE); + STRINGISE_ENUM(D3D12_CULL_MODE_FRONT); + STRINGISE_ENUM(D3D12_CULL_MODE_BACK); + } + END_ENUM_STRINGISE(); +} + +template <> +std::string DoStringise(const D3D12_CONSERVATIVE_RASTERIZATION_MODE &el) +{ + BEGIN_ENUM_STRINGISE(D3D12_CONSERVATIVE_RASTERIZATION_MODE); + { + STRINGISE_ENUM(D3D12_CONSERVATIVE_RASTERIZATION_MODE_OFF) + STRINGISE_ENUM(D3D12_CONSERVATIVE_RASTERIZATION_MODE_ON) + } + END_ENUM_STRINGISE(); +} + +template <> +std::string DoStringise(const D3D12_COMPARISON_FUNC &el) +{ + // possible for unused fields via 0-initialisation + if((int)el == 0) + return "--"; + + BEGIN_ENUM_STRINGISE(D3D12_COMPARISON_FUNC); + { + STRINGISE_ENUM(D3D12_COMPARISON_FUNC_NEVER); + STRINGISE_ENUM(D3D12_COMPARISON_FUNC_LESS); + STRINGISE_ENUM(D3D12_COMPARISON_FUNC_EQUAL); + STRINGISE_ENUM(D3D12_COMPARISON_FUNC_LESS_EQUAL); + STRINGISE_ENUM(D3D12_COMPARISON_FUNC_GREATER); + STRINGISE_ENUM(D3D12_COMPARISON_FUNC_NOT_EQUAL); + STRINGISE_ENUM(D3D12_COMPARISON_FUNC_GREATER_EQUAL); + STRINGISE_ENUM(D3D12_COMPARISON_FUNC_ALWAYS); + } + END_ENUM_STRINGISE(); +} + +template <> +std::string DoStringise(const D3D12_DEPTH_WRITE_MASK &el) +{ + BEGIN_ENUM_STRINGISE(D3D12_DEPTH_WRITE_MASK); + { + STRINGISE_ENUM(D3D12_DEPTH_WRITE_MASK_ZERO) + STRINGISE_ENUM(D3D12_DEPTH_WRITE_MASK_ALL) + } + END_ENUM_STRINGISE(); +} + +template <> +std::string DoStringise(const D3D12_STENCIL_OP &el) +{ + // possible for unused fields via 0-initialisation + if((int)el == 0) + return "--"; + + BEGIN_ENUM_STRINGISE(D3D12_STENCIL_OP); + { + STRINGISE_ENUM(D3D12_STENCIL_OP_KEEP); + STRINGISE_ENUM(D3D12_STENCIL_OP_ZERO); + STRINGISE_ENUM(D3D12_STENCIL_OP_REPLACE); + STRINGISE_ENUM(D3D12_STENCIL_OP_INCR_SAT); + STRINGISE_ENUM(D3D12_STENCIL_OP_DECR_SAT); + STRINGISE_ENUM(D3D12_STENCIL_OP_INVERT); + STRINGISE_ENUM(D3D12_STENCIL_OP_INCR); + STRINGISE_ENUM(D3D12_STENCIL_OP_DECR); + } + END_ENUM_STRINGISE(); +} + +template <> +std::string DoStringise(const D3D12_INPUT_CLASSIFICATION &el) +{ + BEGIN_ENUM_STRINGISE(D3D12_INPUT_CLASSIFICATION); + { + STRINGISE_ENUM(D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA) + STRINGISE_ENUM(D3D12_INPUT_CLASSIFICATION_PER_INSTANCE_DATA) + } + END_ENUM_STRINGISE(); +} + +template <> +std::string DoStringise(const D3D12_INDEX_BUFFER_STRIP_CUT_VALUE &el) +{ + BEGIN_ENUM_STRINGISE(D3D12_INDEX_BUFFER_STRIP_CUT_VALUE); + { + STRINGISE_ENUM(D3D12_INDEX_BUFFER_STRIP_CUT_VALUE_DISABLED) + STRINGISE_ENUM(D3D12_INDEX_BUFFER_STRIP_CUT_VALUE_0xFFFF) + STRINGISE_ENUM(D3D12_INDEX_BUFFER_STRIP_CUT_VALUE_0xFFFFFFFF) + } + END_ENUM_STRINGISE(); +} + +template <> +std::string DoStringise(const D3D12_PRIMITIVE_TOPOLOGY_TYPE &el) +{ + BEGIN_ENUM_STRINGISE(D3D12_PRIMITIVE_TOPOLOGY_TYPE); + { + STRINGISE_ENUM(D3D12_PRIMITIVE_TOPOLOGY_TYPE_UNDEFINED) + STRINGISE_ENUM(D3D12_PRIMITIVE_TOPOLOGY_TYPE_POINT) + STRINGISE_ENUM(D3D12_PRIMITIVE_TOPOLOGY_TYPE_LINE) + STRINGISE_ENUM(D3D12_PRIMITIVE_TOPOLOGY_TYPE_TRIANGLE) + STRINGISE_ENUM(D3D12_PRIMITIVE_TOPOLOGY_TYPE_PATCH) + } + END_ENUM_STRINGISE(); +} + +template <> +std::string DoStringise(const D3D12_INDIRECT_ARGUMENT_TYPE &el) +{ + BEGIN_ENUM_STRINGISE(D3D12_INDIRECT_ARGUMENT_TYPE); + { + STRINGISE_ENUM(D3D12_INDIRECT_ARGUMENT_TYPE_DRAW) + STRINGISE_ENUM(D3D12_INDIRECT_ARGUMENT_TYPE_DRAW_INDEXED) + STRINGISE_ENUM(D3D12_INDIRECT_ARGUMENT_TYPE_DISPATCH) + STRINGISE_ENUM(D3D12_INDIRECT_ARGUMENT_TYPE_VERTEX_BUFFER_VIEW) + STRINGISE_ENUM(D3D12_INDIRECT_ARGUMENT_TYPE_INDEX_BUFFER_VIEW) + STRINGISE_ENUM(D3D12_INDIRECT_ARGUMENT_TYPE_CONSTANT) + STRINGISE_ENUM(D3D12_INDIRECT_ARGUMENT_TYPE_CONSTANT_BUFFER_VIEW) + STRINGISE_ENUM(D3D12_INDIRECT_ARGUMENT_TYPE_SHADER_RESOURCE_VIEW) + STRINGISE_ENUM(D3D12_INDIRECT_ARGUMENT_TYPE_UNORDERED_ACCESS_VIEW) + } + END_ENUM_STRINGISE(); +} + +template <> +std::string DoStringise(const D3D12_COMMAND_LIST_TYPE &el) +{ + BEGIN_ENUM_STRINGISE(D3D12_COMMAND_LIST_TYPE); + { + STRINGISE_ENUM(D3D12_COMMAND_LIST_TYPE_DIRECT) + STRINGISE_ENUM(D3D12_COMMAND_LIST_TYPE_BUNDLE) + STRINGISE_ENUM(D3D12_COMMAND_LIST_TYPE_COMPUTE) + STRINGISE_ENUM(D3D12_COMMAND_LIST_TYPE_COPY) + } + END_ENUM_STRINGISE(); +} + +template <> +std::string DoStringise(const D3D12_TEXTURE_COPY_TYPE &el) +{ + BEGIN_ENUM_STRINGISE(D3D12_TEXTURE_COPY_TYPE); + { + STRINGISE_ENUM(D3D12_TEXTURE_COPY_TYPE_SUBRESOURCE_INDEX) + STRINGISE_ENUM(D3D12_TEXTURE_COPY_TYPE_PLACED_FOOTPRINT) + } + END_ENUM_STRINGISE(); +} + +template <> +std::string DoStringise(const D3D12_RESOURCE_DIMENSION &el) +{ + BEGIN_ENUM_STRINGISE(D3D12_RESOURCE_DIMENSION); + { + STRINGISE_ENUM(D3D12_RESOURCE_DIMENSION_UNKNOWN) + STRINGISE_ENUM(D3D12_RESOURCE_DIMENSION_BUFFER) + STRINGISE_ENUM(D3D12_RESOURCE_DIMENSION_TEXTURE1D) + STRINGISE_ENUM(D3D12_RESOURCE_DIMENSION_TEXTURE2D) + STRINGISE_ENUM(D3D12_RESOURCE_DIMENSION_TEXTURE3D) + } + END_ENUM_STRINGISE(); +} + +template <> +std::string DoStringise(const D3D12_TEXTURE_LAYOUT &el) +{ + BEGIN_ENUM_STRINGISE(D3D12_TEXTURE_LAYOUT); + { + STRINGISE_ENUM(D3D12_TEXTURE_LAYOUT_UNKNOWN) + STRINGISE_ENUM(D3D12_TEXTURE_LAYOUT_ROW_MAJOR) + STRINGISE_ENUM(D3D12_TEXTURE_LAYOUT_64KB_UNDEFINED_SWIZZLE) + STRINGISE_ENUM(D3D12_TEXTURE_LAYOUT_64KB_STANDARD_SWIZZLE) + } + END_ENUM_STRINGISE(); +} + +template <> +std::string DoStringise(const D3D12_TILED_RESOURCES_TIER &el) +{ + BEGIN_ENUM_STRINGISE(D3D12_TILED_RESOURCES_TIER); + { + STRINGISE_ENUM(D3D12_TILED_RESOURCES_TIER_NOT_SUPPORTED) + STRINGISE_ENUM(D3D12_TILED_RESOURCES_TIER_1) + STRINGISE_ENUM(D3D12_TILED_RESOURCES_TIER_2) + STRINGISE_ENUM(D3D12_TILED_RESOURCES_TIER_3) + } + END_ENUM_STRINGISE(); +} + +template <> +std::string DoStringise(const D3D12_CLEAR_FLAGS &el) +{ + BEGIN_BITFIELD_STRINGISE(D3D12_CLEAR_FLAGS); + { + STRINGISE_BITFIELD_BIT(D3D12_CLEAR_FLAG_DEPTH); + STRINGISE_BITFIELD_BIT(D3D12_CLEAR_FLAG_STENCIL); + } + END_BITFIELD_STRINGISE(); +} + +template <> +std::string DoStringise(const D3D12_BUFFER_SRV_FLAGS &el) +{ + BEGIN_BITFIELD_STRINGISE(D3D12_BUFFER_SRV_FLAGS); + { + STRINGISE_BITFIELD_VALUE(D3D12_BUFFER_SRV_FLAG_NONE); + + STRINGISE_BITFIELD_BIT(D3D12_BUFFER_SRV_FLAG_RAW); + } + END_BITFIELD_STRINGISE(); +} + +template <> +std::string DoStringise(const D3D12_DSV_FLAGS &el) +{ + BEGIN_BITFIELD_STRINGISE(D3D12_DSV_FLAGS); + { + STRINGISE_BITFIELD_VALUE(D3D12_DSV_FLAG_NONE); + + STRINGISE_BITFIELD_BIT(D3D12_DSV_FLAG_READ_ONLY_DEPTH); + STRINGISE_BITFIELD_BIT(D3D12_DSV_FLAG_READ_ONLY_STENCIL); + } + END_BITFIELD_STRINGISE(); +} + +template <> +std::string DoStringise(const D3D12_BUFFER_UAV_FLAGS &el) +{ + BEGIN_BITFIELD_STRINGISE(D3D12_BUFFER_UAV_FLAGS); + { + STRINGISE_BITFIELD_VALUE(D3D12_BUFFER_UAV_FLAG_NONE); + + STRINGISE_BITFIELD_BIT(D3D12_BUFFER_UAV_FLAG_RAW); + } + END_BITFIELD_STRINGISE(); +} + +template <> +std::string DoStringise(const D3D12_HEAP_FLAGS &el) +{ + BEGIN_BITFIELD_STRINGISE(D3D12_HEAP_FLAGS); + { + STRINGISE_BITFIELD_VALUE(D3D12_HEAP_FLAG_NONE); + + STRINGISE_BITFIELD_BIT(D3D12_HEAP_FLAG_SHARED); + STRINGISE_BITFIELD_BIT(D3D12_HEAP_FLAG_DENY_BUFFERS); + STRINGISE_BITFIELD_BIT(D3D12_HEAP_FLAG_ALLOW_DISPLAY); + STRINGISE_BITFIELD_BIT(D3D12_HEAP_FLAG_SHARED_CROSS_ADAPTER); + STRINGISE_BITFIELD_BIT(D3D12_HEAP_FLAG_DENY_RT_DS_TEXTURES); + STRINGISE_BITFIELD_BIT(D3D12_HEAP_FLAG_DENY_NON_RT_DS_TEXTURES); + STRINGISE_BITFIELD_BIT(D3D12_HEAP_FLAG_ALLOW_ALL_BUFFERS_AND_TEXTURES); + STRINGISE_BITFIELD_BIT(D3D12_HEAP_FLAG_ALLOW_ONLY_BUFFERS); + STRINGISE_BITFIELD_BIT(D3D12_HEAP_FLAG_ALLOW_ONLY_NON_RT_DS_TEXTURES); + STRINGISE_BITFIELD_BIT(D3D12_HEAP_FLAG_ALLOW_ONLY_RT_DS_TEXTURES); + } + END_BITFIELD_STRINGISE(); +} + +template <> +std::string DoStringise(const D3D12_FENCE_FLAGS &el) +{ + BEGIN_BITFIELD_STRINGISE(D3D12_FENCE_FLAGS); + { + STRINGISE_BITFIELD_VALUE(D3D12_FENCE_FLAG_NONE); + + STRINGISE_BITFIELD_BIT(D3D12_FENCE_FLAG_SHARED); + STRINGISE_BITFIELD_BIT(D3D12_FENCE_FLAG_SHARED_CROSS_ADAPTER); + } + END_BITFIELD_STRINGISE(); +} + +template <> +std::string DoStringise(const D3D12_DESCRIPTOR_HEAP_FLAGS &el) +{ + BEGIN_BITFIELD_STRINGISE(D3D12_DESCRIPTOR_HEAP_FLAGS); + { + STRINGISE_BITFIELD_VALUE(D3D12_DESCRIPTOR_HEAP_FLAG_NONE); + + STRINGISE_BITFIELD_BIT(D3D12_DESCRIPTOR_HEAP_FLAG_SHADER_VISIBLE); + } + END_BITFIELD_STRINGISE(); +} + +template <> +std::string DoStringise(const D3D12_RESOURCE_BARRIER_FLAGS &el) +{ + BEGIN_BITFIELD_STRINGISE(D3D12_RESOURCE_BARRIER_FLAGS); + { + STRINGISE_BITFIELD_VALUE(D3D12_RESOURCE_BARRIER_FLAG_NONE); + + STRINGISE_BITFIELD_BIT(D3D12_RESOURCE_BARRIER_FLAG_BEGIN_ONLY); + STRINGISE_BITFIELD_BIT(D3D12_RESOURCE_BARRIER_FLAG_END_ONLY); + } + END_BITFIELD_STRINGISE(); +} + +template <> +std::string DoStringise(const D3D12_RESOURCE_STATES &el) +{ + BEGIN_BITFIELD_STRINGISE(D3D12_RESOURCE_STATES); + { + STRINGISE_BITFIELD_VALUE(D3D12_RESOURCE_STATE_COMMON); + STRINGISE_BITFIELD_VALUE(D3D12_RESOURCE_STATE_GENERIC_READ); + + STRINGISE_BITFIELD_BIT(D3D12_RESOURCE_STATE_VERTEX_AND_CONSTANT_BUFFER); + STRINGISE_BITFIELD_BIT(D3D12_RESOURCE_STATE_INDEX_BUFFER); + STRINGISE_BITFIELD_BIT(D3D12_RESOURCE_STATE_RENDER_TARGET); + STRINGISE_BITFIELD_BIT(D3D12_RESOURCE_STATE_UNORDERED_ACCESS); + STRINGISE_BITFIELD_BIT(D3D12_RESOURCE_STATE_DEPTH_WRITE); + STRINGISE_BITFIELD_BIT(D3D12_RESOURCE_STATE_DEPTH_READ); + STRINGISE_BITFIELD_BIT(D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE); + STRINGISE_BITFIELD_BIT(D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE); + STRINGISE_BITFIELD_BIT(D3D12_RESOURCE_STATE_STREAM_OUT); + STRINGISE_BITFIELD_BIT(D3D12_RESOURCE_STATE_INDIRECT_ARGUMENT); + STRINGISE_BITFIELD_BIT(D3D12_RESOURCE_STATE_COPY_DEST); + STRINGISE_BITFIELD_BIT(D3D12_RESOURCE_STATE_COPY_SOURCE); + STRINGISE_BITFIELD_BIT(D3D12_RESOURCE_STATE_RESOLVE_DEST); + STRINGISE_BITFIELD_BIT(D3D12_RESOURCE_STATE_RESOLVE_SOURCE); + STRINGISE_BITFIELD_BIT(D3D12_RESOURCE_STATE_PREDICATION); + } + END_BITFIELD_STRINGISE(); +} + +template <> +std::string DoStringise(const D3D12_PIPELINE_STATE_FLAGS &el) +{ + BEGIN_BITFIELD_STRINGISE(D3D12_PIPELINE_STATE_FLAGS); + { + STRINGISE_BITFIELD_VALUE(D3D12_PIPELINE_STATE_FLAG_NONE); + + STRINGISE_BITFIELD_BIT(D3D12_PIPELINE_STATE_FLAG_TOOL_DEBUG); + } + END_BITFIELD_STRINGISE(); +} + +template <> +std::string DoStringise(const D3D12_RESOURCE_FLAGS &el) +{ + BEGIN_BITFIELD_STRINGISE(D3D12_RESOURCE_FLAGS); + { + STRINGISE_BITFIELD_VALUE(D3D12_RESOURCE_FLAG_NONE); + + STRINGISE_BITFIELD_BIT(D3D12_RESOURCE_FLAG_ALLOW_RENDER_TARGET); + STRINGISE_BITFIELD_BIT(D3D12_RESOURCE_FLAG_ALLOW_DEPTH_STENCIL); + STRINGISE_BITFIELD_BIT(D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS); + STRINGISE_BITFIELD_BIT(D3D12_RESOURCE_FLAG_DENY_SHADER_RESOURCE); + STRINGISE_BITFIELD_BIT(D3D12_RESOURCE_FLAG_ALLOW_CROSS_ADAPTER); + STRINGISE_BITFIELD_BIT(D3D12_RESOURCE_FLAG_ALLOW_SIMULTANEOUS_ACCESS); + } + END_BITFIELD_STRINGISE(); +} + +template <> +std::string DoStringise(const D3D12_COMMAND_QUEUE_FLAGS &el) +{ + BEGIN_BITFIELD_STRINGISE(D3D12_COMMAND_QUEUE_FLAGS); + { + STRINGISE_BITFIELD_VALUE(D3D12_COMMAND_QUEUE_FLAG_NONE); + + STRINGISE_BITFIELD_BIT(D3D12_COMMAND_QUEUE_FLAG_DISABLE_GPU_TIMEOUT); + } + END_BITFIELD_STRINGISE(); +} + +template <> +std::string DoStringise(const D3D12_TILE_COPY_FLAGS &el) +{ + BEGIN_BITFIELD_STRINGISE(D3D12_TILE_COPY_FLAGS); + { + STRINGISE_BITFIELD_VALUE(D3D12_TILE_COPY_FLAG_NONE); + + STRINGISE_BITFIELD_BIT(D3D12_TILE_COPY_FLAG_NO_HAZARD); + STRINGISE_BITFIELD_BIT(D3D12_TILE_COPY_FLAG_LINEAR_BUFFER_TO_SWIZZLED_TILED_RESOURCE); + STRINGISE_BITFIELD_BIT(D3D12_TILE_COPY_FLAG_SWIZZLED_TILED_RESOURCE_TO_LINEAR_BUFFER); + } + END_BITFIELD_STRINGISE(); +} + +template <> +std::string DoStringise(const D3D12_TILE_MAPPING_FLAGS &el) +{ + BEGIN_BITFIELD_STRINGISE(D3D12_TILE_MAPPING_FLAGS); + { + STRINGISE_BITFIELD_VALUE(D3D12_TILE_MAPPING_FLAG_NONE); + + STRINGISE_BITFIELD_BIT(D3D12_TILE_MAPPING_FLAG_NO_HAZARD); + } + END_BITFIELD_STRINGISE(); +} + +template <> +std::string DoStringise(const D3D12_TILE_RANGE_FLAGS &el) +{ + BEGIN_BITFIELD_STRINGISE(D3D12_TILE_RANGE_FLAGS); + { + STRINGISE_BITFIELD_VALUE(D3D12_TILE_RANGE_FLAG_NONE); + + STRINGISE_BITFIELD_BIT(D3D12_TILE_RANGE_FLAG_NULL); + STRINGISE_BITFIELD_BIT(D3D12_TILE_RANGE_FLAG_SKIP); + STRINGISE_BITFIELD_BIT(D3D12_TILE_RANGE_FLAG_REUSE_SINGLE_TILE); + } + END_BITFIELD_STRINGISE(); +} + +template <> +std::string DoStringise(const D3D12_COLOR_WRITE_ENABLE &el) +{ + BEGIN_BITFIELD_STRINGISE(D3D12_COLOR_WRITE_ENABLE); + { + STRINGISE_BITFIELD_VALUE(D3D12_COLOR_WRITE_ENABLE_ALL); + + STRINGISE_BITFIELD_BIT(D3D12_COLOR_WRITE_ENABLE_RED); + STRINGISE_BITFIELD_BIT(D3D12_COLOR_WRITE_ENABLE_GREEN); + STRINGISE_BITFIELD_BIT(D3D12_COLOR_WRITE_ENABLE_BLUE); + STRINGISE_BITFIELD_BIT(D3D12_COLOR_WRITE_ENABLE_ALPHA); + } + END_BITFIELD_STRINGISE(); +} \ No newline at end of file diff --git a/renderdoc/driver/d3d12/renderdoc_d3d12.vcxproj b/renderdoc/driver/d3d12/renderdoc_d3d12.vcxproj index d3205502e..452adccb0 100644 --- a/renderdoc/driver/d3d12/renderdoc_d3d12.vcxproj +++ b/renderdoc/driver/d3d12/renderdoc_d3d12.vcxproj @@ -59,7 +59,7 @@ RELEASE;%(PreprocessorDefinitions) - + MultiThreadedDLL false @@ -111,6 +111,7 @@ + Create diff --git a/renderdoc/driver/d3d12/renderdoc_d3d12.vcxproj.filters b/renderdoc/driver/d3d12/renderdoc_d3d12.vcxproj.filters index 670e76443..0c0866ce4 100644 --- a/renderdoc/driver/d3d12/renderdoc_d3d12.vcxproj.filters +++ b/renderdoc/driver/d3d12/renderdoc_d3d12.vcxproj.filters @@ -107,5 +107,8 @@ PCH + + Util + \ No newline at end of file diff --git a/renderdoc/driver/d3d8/d3d8_debug.cpp b/renderdoc/driver/d3d8/d3d8_debug.cpp index 147c15e44..74c88a40c 100644 --- a/renderdoc/driver/d3d8/d3d8_debug.cpp +++ b/renderdoc/driver/d3d8/d3d8_debug.cpp @@ -73,7 +73,7 @@ bool D3D8DebugManager::InitFontRendering() if(FAILED(hr)) { - RDCERR("Failed to create font texture %08x", hr); + RDCERR("Failed to create font texture HRESULT: %s", ToStr(hr).c_str()); } D3DLOCKED_RECT lockedRegion; @@ -81,7 +81,7 @@ bool D3D8DebugManager::InitFontRendering() if(FAILED(hr)) { - RDCERR("Failed to lock font texture %08x", hr); + RDCERR("Failed to lock font texture HRESULT: %s", ToStr(hr).c_str()); } else { @@ -103,7 +103,7 @@ bool D3D8DebugManager::InitFontRendering() hr = fontTex->UnlockRect(0); if(hr != S_OK) { - RDCERR("Failed to unlock font texture %08x", hr); + RDCERR("Failed to unlock font texture HRESULT: %s", ToStr(hr).c_str()); } } diff --git a/renderdoc/driver/d3d8/d3d8_device.cpp b/renderdoc/driver/d3d8/d3d8_device.cpp index a6ef9d124..50baaa14f 100644 --- a/renderdoc/driver/d3d8/d3d8_device.cpp +++ b/renderdoc/driver/d3d8/d3d8_device.cpp @@ -149,8 +149,7 @@ HRESULT WrappedD3DDevice8::QueryInterface(REFIID riid, void **ppvObject) } else { - string guid = ToStr::Get(riid); - RDCWARN("Querying IDirect3DDevice8 for interface: %s", guid.c_str()); + RDCWARN("Querying IDirect3DDevice8 for interface: %s", ToStr(riid).c_str()); } return m_device->QueryInterface(riid, ppvObject); diff --git a/renderdoc/driver/d3d8/d3d8_resources.h b/renderdoc/driver/d3d8/d3d8_resources.h index 074b7c6af..3b70fa52c 100644 --- a/renderdoc/driver/d3d8/d3d8_resources.h +++ b/renderdoc/driver/d3d8/d3d8_resources.h @@ -57,7 +57,7 @@ protected: bool ret = m_pDevice->GetResourceManager()->AddWrapper(this, real); if(!ret) - RDCERR("Error adding wrapper for type %s", ToStr::Get(__uuidof(NestedType)).c_str()); + RDCERR("Error adding wrapper for type %s", ToStr(__uuidof(NestedType)).c_str()); m_pDevice->GetResourceManager()->AddCurrentResource(GetResourceID(), this); } diff --git a/renderdoc/driver/d3d9/d3d9_debug.cpp b/renderdoc/driver/d3d9/d3d9_debug.cpp index 95244bfb0..d489f03a1 100644 --- a/renderdoc/driver/d3d9/d3d9_debug.cpp +++ b/renderdoc/driver/d3d9/d3d9_debug.cpp @@ -73,7 +73,7 @@ bool D3D9DebugManager::InitFontRendering() if(FAILED(hr)) { - RDCERR("Failed to create font texture %08x", hr); + RDCERR("Failed to create font texture HRESULT: %s", ToStr(hr).c_str()); } D3DLOCKED_RECT lockedRegion; @@ -81,7 +81,7 @@ bool D3D9DebugManager::InitFontRendering() if(FAILED(hr)) { - RDCERR("Failed to lock font texture %08x", hr); + RDCERR("Failed to lock font texture HRESULT: %s", ToStr(hr).c_str()); } else { @@ -103,7 +103,7 @@ bool D3D9DebugManager::InitFontRendering() hr = fontTex->UnlockRect(0); if(hr != S_OK) { - RDCERR("Failed to unlock font texture %08x", hr); + RDCERR("Failed to unlock font texture HRESULT: %s", ToStr(hr).c_str()); } } diff --git a/renderdoc/driver/d3d9/d3d9_device.cpp b/renderdoc/driver/d3d9/d3d9_device.cpp index 7c72bdb0b..97237e90b 100644 --- a/renderdoc/driver/d3d9/d3d9_device.cpp +++ b/renderdoc/driver/d3d9/d3d9_device.cpp @@ -95,8 +95,7 @@ HRESULT WrappedD3DDevice9::QueryInterface(REFIID riid, void **ppvObject) } else { - string guid = ToStr::Get(riid); - RDCWARN("Querying IDirect3DDevice9 for interface: %s", guid.c_str()); + RDCWARN("Querying IDirect3DDevice9 for interface: %s", ToStr(riid).c_str()); } return m_device->QueryInterface(riid, ppvObject); diff --git a/renderdoc/driver/dxgi/dxgi_common.cpp b/renderdoc/driver/dxgi/dxgi_common.cpp index 5d48b3bdc..967ddaf7e 100644 --- a/renderdoc/driver/dxgi/dxgi_common.cpp +++ b/renderdoc/driver/dxgi/dxgi_common.cpp @@ -1925,205 +1925,22 @@ ResourceFormat MakeResourceFormat(DXGI_FORMAT fmt) return ret; } -string ToStrHelper::Get(const DXGI_SAMPLE_DESC &el) +// shared between D3D11 and D3D12 as D3Dxx_RECT +template <> +std::string DoStringise(const RECT &el) { - char tostrBuf[256] = {0}; - StringFormat::snprintf(tostrBuf, 255, "DXGI_SAMPLE_DESC<%d,%d>", el.Count, el.Quality); - - return tostrBuf; + return StringFormat::Fmt("RECT<%d,%d,%d,%d>", el.left, el.right, el.top, el.bottom); } -string ToStrHelper::Get(const DXGI_FORMAT &el) +template <> +std::string DoStringise(const DXGI_SAMPLE_DESC &el) { - switch(el) - { - TOSTR_CASE_STRINGIZE(DXGI_FORMAT_UNKNOWN) - TOSTR_CASE_STRINGIZE(DXGI_FORMAT_R32G32B32A32_TYPELESS) - TOSTR_CASE_STRINGIZE(DXGI_FORMAT_R32G32B32A32_FLOAT) - TOSTR_CASE_STRINGIZE(DXGI_FORMAT_R32G32B32A32_UINT) - TOSTR_CASE_STRINGIZE(DXGI_FORMAT_R32G32B32A32_SINT) - TOSTR_CASE_STRINGIZE(DXGI_FORMAT_R32G32B32_TYPELESS) - TOSTR_CASE_STRINGIZE(DXGI_FORMAT_R32G32B32_FLOAT) - TOSTR_CASE_STRINGIZE(DXGI_FORMAT_R32G32B32_UINT) - TOSTR_CASE_STRINGIZE(DXGI_FORMAT_R32G32B32_SINT) - TOSTR_CASE_STRINGIZE(DXGI_FORMAT_R16G16B16A16_TYPELESS) - TOSTR_CASE_STRINGIZE(DXGI_FORMAT_R16G16B16A16_FLOAT) - TOSTR_CASE_STRINGIZE(DXGI_FORMAT_R16G16B16A16_UNORM) - TOSTR_CASE_STRINGIZE(DXGI_FORMAT_R16G16B16A16_UINT) - TOSTR_CASE_STRINGIZE(DXGI_FORMAT_R16G16B16A16_SNORM) - TOSTR_CASE_STRINGIZE(DXGI_FORMAT_R16G16B16A16_SINT) - TOSTR_CASE_STRINGIZE(DXGI_FORMAT_R32G32_TYPELESS) - TOSTR_CASE_STRINGIZE(DXGI_FORMAT_R32G32_FLOAT) - TOSTR_CASE_STRINGIZE(DXGI_FORMAT_R32G32_UINT) - TOSTR_CASE_STRINGIZE(DXGI_FORMAT_R32G32_SINT) - TOSTR_CASE_STRINGIZE(DXGI_FORMAT_R32G8X24_TYPELESS) - TOSTR_CASE_STRINGIZE(DXGI_FORMAT_D32_FLOAT_S8X24_UINT) - TOSTR_CASE_STRINGIZE(DXGI_FORMAT_R32_FLOAT_X8X24_TYPELESS) - TOSTR_CASE_STRINGIZE(DXGI_FORMAT_X32_TYPELESS_G8X24_UINT) - TOSTR_CASE_STRINGIZE(DXGI_FORMAT_R10G10B10A2_TYPELESS) - TOSTR_CASE_STRINGIZE(DXGI_FORMAT_R10G10B10A2_UNORM) - TOSTR_CASE_STRINGIZE(DXGI_FORMAT_R10G10B10A2_UINT) - TOSTR_CASE_STRINGIZE(DXGI_FORMAT_R11G11B10_FLOAT) - TOSTR_CASE_STRINGIZE(DXGI_FORMAT_R8G8B8A8_TYPELESS) - TOSTR_CASE_STRINGIZE(DXGI_FORMAT_R8G8B8A8_UNORM) - TOSTR_CASE_STRINGIZE(DXGI_FORMAT_R8G8B8A8_UNORM_SRGB) - TOSTR_CASE_STRINGIZE(DXGI_FORMAT_R8G8B8A8_UINT) - TOSTR_CASE_STRINGIZE(DXGI_FORMAT_R8G8B8A8_SNORM) - TOSTR_CASE_STRINGIZE(DXGI_FORMAT_R8G8B8A8_SINT) - TOSTR_CASE_STRINGIZE(DXGI_FORMAT_R16G16_TYPELESS) - TOSTR_CASE_STRINGIZE(DXGI_FORMAT_R16G16_FLOAT) - TOSTR_CASE_STRINGIZE(DXGI_FORMAT_R16G16_UNORM) - TOSTR_CASE_STRINGIZE(DXGI_FORMAT_R16G16_UINT) - TOSTR_CASE_STRINGIZE(DXGI_FORMAT_R16G16_SNORM) - TOSTR_CASE_STRINGIZE(DXGI_FORMAT_R16G16_SINT) - TOSTR_CASE_STRINGIZE(DXGI_FORMAT_R32_TYPELESS) - TOSTR_CASE_STRINGIZE(DXGI_FORMAT_D32_FLOAT) - TOSTR_CASE_STRINGIZE(DXGI_FORMAT_R32_FLOAT) - TOSTR_CASE_STRINGIZE(DXGI_FORMAT_R32_UINT) - TOSTR_CASE_STRINGIZE(DXGI_FORMAT_R32_SINT) - TOSTR_CASE_STRINGIZE(DXGI_FORMAT_R24G8_TYPELESS) - TOSTR_CASE_STRINGIZE(DXGI_FORMAT_D24_UNORM_S8_UINT) - TOSTR_CASE_STRINGIZE(DXGI_FORMAT_R24_UNORM_X8_TYPELESS) - TOSTR_CASE_STRINGIZE(DXGI_FORMAT_X24_TYPELESS_G8_UINT) - TOSTR_CASE_STRINGIZE(DXGI_FORMAT_R8G8_TYPELESS) - TOSTR_CASE_STRINGIZE(DXGI_FORMAT_R8G8_UNORM) - TOSTR_CASE_STRINGIZE(DXGI_FORMAT_R8G8_UINT) - TOSTR_CASE_STRINGIZE(DXGI_FORMAT_R8G8_SNORM) - TOSTR_CASE_STRINGIZE(DXGI_FORMAT_R8G8_SINT) - TOSTR_CASE_STRINGIZE(DXGI_FORMAT_R16_TYPELESS) - TOSTR_CASE_STRINGIZE(DXGI_FORMAT_R16_FLOAT) - TOSTR_CASE_STRINGIZE(DXGI_FORMAT_D16_UNORM) - TOSTR_CASE_STRINGIZE(DXGI_FORMAT_R16_UNORM) - TOSTR_CASE_STRINGIZE(DXGI_FORMAT_R16_UINT) - TOSTR_CASE_STRINGIZE(DXGI_FORMAT_R16_SNORM) - TOSTR_CASE_STRINGIZE(DXGI_FORMAT_R16_SINT) - TOSTR_CASE_STRINGIZE(DXGI_FORMAT_R8_TYPELESS) - TOSTR_CASE_STRINGIZE(DXGI_FORMAT_R8_UNORM) - TOSTR_CASE_STRINGIZE(DXGI_FORMAT_R8_UINT) - TOSTR_CASE_STRINGIZE(DXGI_FORMAT_R8_SNORM) - TOSTR_CASE_STRINGIZE(DXGI_FORMAT_R8_SINT) - TOSTR_CASE_STRINGIZE(DXGI_FORMAT_A8_UNORM) - TOSTR_CASE_STRINGIZE(DXGI_FORMAT_R1_UNORM) - TOSTR_CASE_STRINGIZE(DXGI_FORMAT_R9G9B9E5_SHAREDEXP) - TOSTR_CASE_STRINGIZE(DXGI_FORMAT_R8G8_B8G8_UNORM) - TOSTR_CASE_STRINGIZE(DXGI_FORMAT_G8R8_G8B8_UNORM) - TOSTR_CASE_STRINGIZE(DXGI_FORMAT_BC1_TYPELESS) - TOSTR_CASE_STRINGIZE(DXGI_FORMAT_BC1_UNORM) - TOSTR_CASE_STRINGIZE(DXGI_FORMAT_BC1_UNORM_SRGB) - TOSTR_CASE_STRINGIZE(DXGI_FORMAT_BC2_TYPELESS) - TOSTR_CASE_STRINGIZE(DXGI_FORMAT_BC2_UNORM) - TOSTR_CASE_STRINGIZE(DXGI_FORMAT_BC2_UNORM_SRGB) - TOSTR_CASE_STRINGIZE(DXGI_FORMAT_BC3_TYPELESS) - TOSTR_CASE_STRINGIZE(DXGI_FORMAT_BC3_UNORM) - TOSTR_CASE_STRINGIZE(DXGI_FORMAT_BC3_UNORM_SRGB) - TOSTR_CASE_STRINGIZE(DXGI_FORMAT_BC4_TYPELESS) - TOSTR_CASE_STRINGIZE(DXGI_FORMAT_BC4_UNORM) - TOSTR_CASE_STRINGIZE(DXGI_FORMAT_BC4_SNORM) - TOSTR_CASE_STRINGIZE(DXGI_FORMAT_BC5_TYPELESS) - TOSTR_CASE_STRINGIZE(DXGI_FORMAT_BC5_UNORM) - TOSTR_CASE_STRINGIZE(DXGI_FORMAT_BC5_SNORM) - TOSTR_CASE_STRINGIZE(DXGI_FORMAT_B5G6R5_UNORM) - TOSTR_CASE_STRINGIZE(DXGI_FORMAT_B5G5R5A1_UNORM) - TOSTR_CASE_STRINGIZE(DXGI_FORMAT_B8G8R8A8_UNORM) - TOSTR_CASE_STRINGIZE(DXGI_FORMAT_B8G8R8X8_UNORM) - TOSTR_CASE_STRINGIZE(DXGI_FORMAT_R10G10B10_XR_BIAS_A2_UNORM) - TOSTR_CASE_STRINGIZE(DXGI_FORMAT_B8G8R8A8_TYPELESS) - TOSTR_CASE_STRINGIZE(DXGI_FORMAT_B8G8R8A8_UNORM_SRGB) - TOSTR_CASE_STRINGIZE(DXGI_FORMAT_B8G8R8X8_TYPELESS) - TOSTR_CASE_STRINGIZE(DXGI_FORMAT_B8G8R8X8_UNORM_SRGB) - TOSTR_CASE_STRINGIZE(DXGI_FORMAT_BC6H_TYPELESS) - TOSTR_CASE_STRINGIZE(DXGI_FORMAT_BC6H_UF16) - TOSTR_CASE_STRINGIZE(DXGI_FORMAT_BC6H_SF16) - TOSTR_CASE_STRINGIZE(DXGI_FORMAT_BC7_TYPELESS) - TOSTR_CASE_STRINGIZE(DXGI_FORMAT_BC7_UNORM) - TOSTR_CASE_STRINGIZE(DXGI_FORMAT_BC7_UNORM_SRGB) - // D3D11.1 formats - TOSTR_CASE_STRINGIZE(DXGI_FORMAT_AYUV) - TOSTR_CASE_STRINGIZE(DXGI_FORMAT_Y410) - TOSTR_CASE_STRINGIZE(DXGI_FORMAT_Y416) - TOSTR_CASE_STRINGIZE(DXGI_FORMAT_NV12) - TOSTR_CASE_STRINGIZE(DXGI_FORMAT_P010) - TOSTR_CASE_STRINGIZE(DXGI_FORMAT_P016) - TOSTR_CASE_STRINGIZE(DXGI_FORMAT_420_OPAQUE) - TOSTR_CASE_STRINGIZE(DXGI_FORMAT_YUY2) - TOSTR_CASE_STRINGIZE(DXGI_FORMAT_Y210) - TOSTR_CASE_STRINGIZE(DXGI_FORMAT_Y216) - TOSTR_CASE_STRINGIZE(DXGI_FORMAT_NV11) - TOSTR_CASE_STRINGIZE(DXGI_FORMAT_AI44) - TOSTR_CASE_STRINGIZE(DXGI_FORMAT_IA44) - TOSTR_CASE_STRINGIZE(DXGI_FORMAT_P8) - TOSTR_CASE_STRINGIZE(DXGI_FORMAT_A8P8) - TOSTR_CASE_STRINGIZE(DXGI_FORMAT_B4G4R4A4_UNORM) - // D3D11.2 formats - TOSTR_CASE_STRINGIZE(DXGI_FORMAT_P208) - TOSTR_CASE_STRINGIZE(DXGI_FORMAT_V208) - TOSTR_CASE_STRINGIZE(DXGI_FORMAT_V408) - default: break; - } - - char tostrBuf[256] = {0}; - StringFormat::snprintf(tostrBuf, 255, "DXGI_FORMAT<%d>", el); - - return tostrBuf; -} - -// not technically DXGI, but makes more sense to have it here common between D3D versions -string ToStrHelper::Get(const D3D_FEATURE_LEVEL &el) -{ - switch(el) - { - TOSTR_CASE_STRINGIZE(D3D_FEATURE_LEVEL_9_1) - TOSTR_CASE_STRINGIZE(D3D_FEATURE_LEVEL_9_2) - TOSTR_CASE_STRINGIZE(D3D_FEATURE_LEVEL_9_3) - TOSTR_CASE_STRINGIZE(D3D_FEATURE_LEVEL_10_0) - TOSTR_CASE_STRINGIZE(D3D_FEATURE_LEVEL_10_1) - TOSTR_CASE_STRINGIZE(D3D_FEATURE_LEVEL_11_0) - TOSTR_CASE_STRINGIZE(D3D_FEATURE_LEVEL_11_1) - TOSTR_CASE_STRINGIZE(D3D_FEATURE_LEVEL_12_0) - TOSTR_CASE_STRINGIZE(D3D_FEATURE_LEVEL_12_1) - default: break; - } - - char tostrBuf[256] = {0}; - StringFormat::snprintf(tostrBuf, 255, "D3D_FEATURE_LEVEL<%d>", el); - - return tostrBuf; -} - -string ToStrHelper::Get(const D3D_DRIVER_TYPE &el) -{ - switch(el) - { - TOSTR_CASE_STRINGIZE(D3D_DRIVER_TYPE_HARDWARE) - TOSTR_CASE_STRINGIZE(D3D_DRIVER_TYPE_REFERENCE) - TOSTR_CASE_STRINGIZE(D3D_DRIVER_TYPE_NULL) - TOSTR_CASE_STRINGIZE(D3D_DRIVER_TYPE_SOFTWARE) - TOSTR_CASE_STRINGIZE(D3D_DRIVER_TYPE_WARP) - default: break; - } - - char tostrBuf[256] = {0}; - StringFormat::snprintf(tostrBuf, 255, "D3D_DRIVER_TYPE<%d>", el); - - return tostrBuf; + return StringFormat::Fmt("DXGI_SAMPLE_DESC<%d,%d>", el.Count, el.Quality); } #if ENABLED(ENABLE_UNIT_TESTS) #include "3rdparty/catch/catch.hpp" -#define CATCH_TOSTR(type) \ - namespace Catch \ - { \ - template <> \ - struct StringMaker \ - { \ - static std::string convert(type const &value) { return ToStr::Get(value); } \ - }; \ - } - -CATCH_TOSTR(DXGI_FORMAT); -CATCH_TOSTR(CompType); - TEST_CASE("DXGI formats", "[format][d3d]") { // must be updated by hand @@ -2193,7 +2010,7 @@ TEST_CASE("DXGI formats", "[format][d3d]") ResourceFormat fmt = MakeResourceFormat(f); - INFO("Format is " << ToStr::Get(f)); + INFO("Format is " << ToStr(f)); if(IsBlockFormat(f)) { @@ -2252,12 +2069,12 @@ TEST_CASE("DXGI formats", "[format][d3d]") ResourceFormat fmt = MakeResourceFormat(f); - INFO("Format is " << ToStr::Get(f)); + INFO("Format is " << ToStr(f)); if(IsSRGBFormat(f)) { DXGI_FORMAT conv = GetNonSRGBFormat(f); - INFO(ToStr::Get(conv)); + INFO(ToStr(conv)); ResourceFormat convfmt = MakeResourceFormat(conv); @@ -2272,7 +2089,7 @@ TEST_CASE("DXGI formats", "[format][d3d]") fmt.compType != CompType::SNorm)) { DXGI_FORMAT conv = GetSRGBFormat(f); - INFO(ToStr::Get(conv)); + INFO(ToStr(conv)); ResourceFormat convfmt = MakeResourceFormat(conv); @@ -2307,7 +2124,7 @@ TEST_CASE("DXGI formats", "[format][d3d]") if(fmt.type != ResourceFormatType::Regular) continue; - INFO("Format is " << ToStr::Get(f)); + INFO("Format is " << ToStr(f)); uint32_t bpp = fmt.compCount * fmt.compByteWidth * 8; CHECK(bpp == GetFormatBPP(f)); diff --git a/renderdoc/driver/dxgi/dxgi_common.h b/renderdoc/driver/dxgi/dxgi_common.h index a28987672..d14f49594 100644 --- a/renderdoc/driver/dxgi/dxgi_common.h +++ b/renderdoc/driver/dxgi/dxgi_common.h @@ -59,3 +59,9 @@ bool IsSRGBFormat(DXGI_FORMAT f); // not technically DXGI, but makes more sense to have it here common between D3D versions Topology MakePrimitiveTopology(D3D_PRIMITIVE_TOPOLOGY Topo); D3D_PRIMITIVE_TOPOLOGY MakeD3DPrimitiveTopology(Topology Topo); + +DECLARE_REFLECTION_STRUCT(DXGI_SAMPLE_DESC); +DECLARE_REFLECTION_STRUCT(IID); +DECLARE_REFLECTION_ENUM(DXGI_FORMAT); +DECLARE_REFLECTION_ENUM(D3D_FEATURE_LEVEL); +DECLARE_REFLECTION_ENUM(D3D_DRIVER_TYPE); diff --git a/renderdoc/driver/dxgi/dxgi_stringise.cpp b/renderdoc/driver/dxgi/dxgi_stringise.cpp new file mode 100644 index 000000000..b89f65d1c --- /dev/null +++ b/renderdoc/driver/dxgi/dxgi_stringise.cpp @@ -0,0 +1,241 @@ +/****************************************************************************** + * The MIT License (MIT) + * + * Copyright (c) 2016-2017 Baldur Karlsson + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ + +#include "common/common.h" +#include "serialise/serialiser.h" +#include "dxgi_common.h" + +template <> +std::string DoStringise(const DXGI_FORMAT &el) +{ + BEGIN_ENUM_STRINGISE(DXGI_FORMAT); + { + STRINGISE_ENUM(DXGI_FORMAT_UNKNOWN) + STRINGISE_ENUM(DXGI_FORMAT_R32G32B32A32_TYPELESS) + STRINGISE_ENUM(DXGI_FORMAT_R32G32B32A32_FLOAT) + STRINGISE_ENUM(DXGI_FORMAT_R32G32B32A32_UINT) + STRINGISE_ENUM(DXGI_FORMAT_R32G32B32A32_SINT) + STRINGISE_ENUM(DXGI_FORMAT_R32G32B32_TYPELESS) + STRINGISE_ENUM(DXGI_FORMAT_R32G32B32_FLOAT) + STRINGISE_ENUM(DXGI_FORMAT_R32G32B32_UINT) + STRINGISE_ENUM(DXGI_FORMAT_R32G32B32_SINT) + STRINGISE_ENUM(DXGI_FORMAT_R16G16B16A16_TYPELESS) + STRINGISE_ENUM(DXGI_FORMAT_R16G16B16A16_FLOAT) + STRINGISE_ENUM(DXGI_FORMAT_R16G16B16A16_UNORM) + STRINGISE_ENUM(DXGI_FORMAT_R16G16B16A16_UINT) + STRINGISE_ENUM(DXGI_FORMAT_R16G16B16A16_SNORM) + STRINGISE_ENUM(DXGI_FORMAT_R16G16B16A16_SINT) + STRINGISE_ENUM(DXGI_FORMAT_R32G32_TYPELESS) + STRINGISE_ENUM(DXGI_FORMAT_R32G32_FLOAT) + STRINGISE_ENUM(DXGI_FORMAT_R32G32_UINT) + STRINGISE_ENUM(DXGI_FORMAT_R32G32_SINT) + STRINGISE_ENUM(DXGI_FORMAT_R32G8X24_TYPELESS) + STRINGISE_ENUM(DXGI_FORMAT_D32_FLOAT_S8X24_UINT) + STRINGISE_ENUM(DXGI_FORMAT_R32_FLOAT_X8X24_TYPELESS) + STRINGISE_ENUM(DXGI_FORMAT_X32_TYPELESS_G8X24_UINT) + STRINGISE_ENUM(DXGI_FORMAT_R10G10B10A2_TYPELESS) + STRINGISE_ENUM(DXGI_FORMAT_R10G10B10A2_UNORM) + STRINGISE_ENUM(DXGI_FORMAT_R10G10B10A2_UINT) + STRINGISE_ENUM(DXGI_FORMAT_R11G11B10_FLOAT) + STRINGISE_ENUM(DXGI_FORMAT_R8G8B8A8_TYPELESS) + STRINGISE_ENUM(DXGI_FORMAT_R8G8B8A8_UNORM) + STRINGISE_ENUM(DXGI_FORMAT_R8G8B8A8_UNORM_SRGB) + STRINGISE_ENUM(DXGI_FORMAT_R8G8B8A8_UINT) + STRINGISE_ENUM(DXGI_FORMAT_R8G8B8A8_SNORM) + STRINGISE_ENUM(DXGI_FORMAT_R8G8B8A8_SINT) + STRINGISE_ENUM(DXGI_FORMAT_R16G16_TYPELESS) + STRINGISE_ENUM(DXGI_FORMAT_R16G16_FLOAT) + STRINGISE_ENUM(DXGI_FORMAT_R16G16_UNORM) + STRINGISE_ENUM(DXGI_FORMAT_R16G16_UINT) + STRINGISE_ENUM(DXGI_FORMAT_R16G16_SNORM) + STRINGISE_ENUM(DXGI_FORMAT_R16G16_SINT) + STRINGISE_ENUM(DXGI_FORMAT_R32_TYPELESS) + STRINGISE_ENUM(DXGI_FORMAT_D32_FLOAT) + STRINGISE_ENUM(DXGI_FORMAT_R32_FLOAT) + STRINGISE_ENUM(DXGI_FORMAT_R32_UINT) + STRINGISE_ENUM(DXGI_FORMAT_R32_SINT) + STRINGISE_ENUM(DXGI_FORMAT_R24G8_TYPELESS) + STRINGISE_ENUM(DXGI_FORMAT_D24_UNORM_S8_UINT) + STRINGISE_ENUM(DXGI_FORMAT_R24_UNORM_X8_TYPELESS) + STRINGISE_ENUM(DXGI_FORMAT_X24_TYPELESS_G8_UINT) + STRINGISE_ENUM(DXGI_FORMAT_R8G8_TYPELESS) + STRINGISE_ENUM(DXGI_FORMAT_R8G8_UNORM) + STRINGISE_ENUM(DXGI_FORMAT_R8G8_UINT) + STRINGISE_ENUM(DXGI_FORMAT_R8G8_SNORM) + STRINGISE_ENUM(DXGI_FORMAT_R8G8_SINT) + STRINGISE_ENUM(DXGI_FORMAT_R16_TYPELESS) + STRINGISE_ENUM(DXGI_FORMAT_R16_FLOAT) + STRINGISE_ENUM(DXGI_FORMAT_D16_UNORM) + STRINGISE_ENUM(DXGI_FORMAT_R16_UNORM) + STRINGISE_ENUM(DXGI_FORMAT_R16_UINT) + STRINGISE_ENUM(DXGI_FORMAT_R16_SNORM) + STRINGISE_ENUM(DXGI_FORMAT_R16_SINT) + STRINGISE_ENUM(DXGI_FORMAT_R8_TYPELESS) + STRINGISE_ENUM(DXGI_FORMAT_R8_UNORM) + STRINGISE_ENUM(DXGI_FORMAT_R8_UINT) + STRINGISE_ENUM(DXGI_FORMAT_R8_SNORM) + STRINGISE_ENUM(DXGI_FORMAT_R8_SINT) + STRINGISE_ENUM(DXGI_FORMAT_A8_UNORM) + STRINGISE_ENUM(DXGI_FORMAT_R1_UNORM) + STRINGISE_ENUM(DXGI_FORMAT_R9G9B9E5_SHAREDEXP) + STRINGISE_ENUM(DXGI_FORMAT_R8G8_B8G8_UNORM) + STRINGISE_ENUM(DXGI_FORMAT_G8R8_G8B8_UNORM) + STRINGISE_ENUM(DXGI_FORMAT_BC1_TYPELESS) + STRINGISE_ENUM(DXGI_FORMAT_BC1_UNORM) + STRINGISE_ENUM(DXGI_FORMAT_BC1_UNORM_SRGB) + STRINGISE_ENUM(DXGI_FORMAT_BC2_TYPELESS) + STRINGISE_ENUM(DXGI_FORMAT_BC2_UNORM) + STRINGISE_ENUM(DXGI_FORMAT_BC2_UNORM_SRGB) + STRINGISE_ENUM(DXGI_FORMAT_BC3_TYPELESS) + STRINGISE_ENUM(DXGI_FORMAT_BC3_UNORM) + STRINGISE_ENUM(DXGI_FORMAT_BC3_UNORM_SRGB) + STRINGISE_ENUM(DXGI_FORMAT_BC4_TYPELESS) + STRINGISE_ENUM(DXGI_FORMAT_BC4_UNORM) + STRINGISE_ENUM(DXGI_FORMAT_BC4_SNORM) + STRINGISE_ENUM(DXGI_FORMAT_BC5_TYPELESS) + STRINGISE_ENUM(DXGI_FORMAT_BC5_UNORM) + STRINGISE_ENUM(DXGI_FORMAT_BC5_SNORM) + STRINGISE_ENUM(DXGI_FORMAT_B5G6R5_UNORM) + STRINGISE_ENUM(DXGI_FORMAT_B5G5R5A1_UNORM) + STRINGISE_ENUM(DXGI_FORMAT_B8G8R8A8_UNORM) + STRINGISE_ENUM(DXGI_FORMAT_B8G8R8X8_UNORM) + STRINGISE_ENUM(DXGI_FORMAT_R10G10B10_XR_BIAS_A2_UNORM) + STRINGISE_ENUM(DXGI_FORMAT_B8G8R8A8_TYPELESS) + STRINGISE_ENUM(DXGI_FORMAT_B8G8R8A8_UNORM_SRGB) + STRINGISE_ENUM(DXGI_FORMAT_B8G8R8X8_TYPELESS) + STRINGISE_ENUM(DXGI_FORMAT_B8G8R8X8_UNORM_SRGB) + STRINGISE_ENUM(DXGI_FORMAT_BC6H_TYPELESS) + STRINGISE_ENUM(DXGI_FORMAT_BC6H_UF16) + STRINGISE_ENUM(DXGI_FORMAT_BC6H_SF16) + STRINGISE_ENUM(DXGI_FORMAT_BC7_TYPELESS) + STRINGISE_ENUM(DXGI_FORMAT_BC7_UNORM) + STRINGISE_ENUM(DXGI_FORMAT_BC7_UNORM_SRGB) + // D3D11.1 formats + STRINGISE_ENUM(DXGI_FORMAT_AYUV) + STRINGISE_ENUM(DXGI_FORMAT_Y410) + STRINGISE_ENUM(DXGI_FORMAT_Y416) + STRINGISE_ENUM(DXGI_FORMAT_NV12) + STRINGISE_ENUM(DXGI_FORMAT_P010) + STRINGISE_ENUM(DXGI_FORMAT_P016) + STRINGISE_ENUM(DXGI_FORMAT_420_OPAQUE) + STRINGISE_ENUM(DXGI_FORMAT_YUY2) + STRINGISE_ENUM(DXGI_FORMAT_Y210) + STRINGISE_ENUM(DXGI_FORMAT_Y216) + STRINGISE_ENUM(DXGI_FORMAT_NV11) + STRINGISE_ENUM(DXGI_FORMAT_AI44) + STRINGISE_ENUM(DXGI_FORMAT_IA44) + STRINGISE_ENUM(DXGI_FORMAT_P8) + STRINGISE_ENUM(DXGI_FORMAT_A8P8) + STRINGISE_ENUM(DXGI_FORMAT_B4G4R4A4_UNORM) + // D3D11.2 formats + STRINGISE_ENUM(DXGI_FORMAT_P208) + STRINGISE_ENUM(DXGI_FORMAT_V208) + STRINGISE_ENUM(DXGI_FORMAT_V408) + } + END_ENUM_STRINGISE(); +} + +// not technically DXGI, but makes more sense to have it here common between D3D versions +template <> +std::string DoStringise(const IID &el) +{ + return StringFormat::Fmt("GUID {%08x-%04hx-%04hx-%02x%02x-%02x%02x%02x%02x%02x%02x}", el.Data1, + el.Data2, el.Data3, el.Data4[0], el.Data4[1], el.Data4[2], el.Data4[3], + el.Data4[4], el.Data4[5], el.Data4[6], el.Data4[7]); +} + +template <> +std::string DoStringise(const D3D_FEATURE_LEVEL &el) +{ + BEGIN_ENUM_STRINGISE(D3D_FEATURE_LEVEL); + { + STRINGISE_ENUM(D3D_FEATURE_LEVEL_9_1) + STRINGISE_ENUM(D3D_FEATURE_LEVEL_9_2) + STRINGISE_ENUM(D3D_FEATURE_LEVEL_9_3) + STRINGISE_ENUM(D3D_FEATURE_LEVEL_10_0) + STRINGISE_ENUM(D3D_FEATURE_LEVEL_10_1) + STRINGISE_ENUM(D3D_FEATURE_LEVEL_11_0) + STRINGISE_ENUM(D3D_FEATURE_LEVEL_11_1) + STRINGISE_ENUM(D3D_FEATURE_LEVEL_12_0) + STRINGISE_ENUM(D3D_FEATURE_LEVEL_12_1) + } + END_ENUM_STRINGISE(); +} + +template <> +std::string DoStringise(const D3D_DRIVER_TYPE &el) +{ + BEGIN_ENUM_STRINGISE(D3D_DRIVER_TYPE); + { + STRINGISE_ENUM(D3D_DRIVER_TYPE_HARDWARE) + STRINGISE_ENUM(D3D_DRIVER_TYPE_REFERENCE) + STRINGISE_ENUM(D3D_DRIVER_TYPE_NULL) + STRINGISE_ENUM(D3D_DRIVER_TYPE_SOFTWARE) + STRINGISE_ENUM(D3D_DRIVER_TYPE_WARP) + } + END_ENUM_STRINGISE(); +} + +// for HRESULT +template <> +std::string DoStringise(const long &el) +{ + HRESULT hr = (HRESULT)el; + + switch(hr) + { + STRINGISE_ENUM(S_OK) + STRINGISE_ENUM(DXGI_ERROR_INVALID_CALL) + STRINGISE_ENUM(DXGI_ERROR_NOT_FOUND) + STRINGISE_ENUM(DXGI_ERROR_DEVICE_REMOVED) + STRINGISE_ENUM(DXGI_ERROR_DEVICE_HUNG) + STRINGISE_ENUM(DXGI_ERROR_DEVICE_RESET) + STRINGISE_ENUM(DXGI_ERROR_WAS_STILL_DRAWING) + STRINGISE_ENUM(E_OUTOFMEMORY) + STRINGISE_ENUM(E_INVALIDARG) + STRINGISE_ENUM(E_NOINTERFACE) + STRINGISE_ENUM(E_ABORT) + STRINGISE_ENUM(E_FAIL) + } + + return "HRESULT<" + ToStr((uint32_t)el) + ">"; +} + +#if ENABLED(ENABLE_UNIT_TESTS) +#include "3rdparty/catch/catch.hpp" + +TEST_CASE("DXGI ToStr", "[tostr][d3d]") +{ + HRESULT hr = DXGI_ERROR_DEVICE_RESET; + + CHECK(ToStr(hr) == "DXGI_ERROR_DEVICE_RESET"); + CHECK(ToStr(E_INVALIDARG) == "E_INVALIDARG"); + + static const GUID guid = { + 0x2dc365d4, 0xc562, 0x411e, {0x9d, 0x34, 0x16, 0x59, 0xa4, 0xf3, 0x1d, 0xdd}}; + + CHECK(ToStr(guid) == "GUID {2dc365d4-c562-411e-9d34-1659a4f31ddd}"); +} + +#endif \ No newline at end of file diff --git a/renderdoc/driver/dxgi/dxgi_wrapped.cpp b/renderdoc/driver/dxgi/dxgi_wrapped.cpp index be985b1b0..87760920b 100644 --- a/renderdoc/driver/dxgi/dxgi_wrapped.cpp +++ b/renderdoc/driver/dxgi/dxgi_wrapped.cpp @@ -29,17 +29,6 @@ #include "core/core.h" #include "serialise/serialiser.h" -string ToStrHelper::Get(const IID &el) -{ - char tostrBuf[256] = {0}; - StringFormat::snprintf(tostrBuf, 255, "GUID {%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x}", - el.Data1, (unsigned int)el.Data2, (unsigned int)el.Data3, el.Data4[0], - el.Data4[1], el.Data4[2], el.Data4[3], el.Data4[4], el.Data4[5], - el.Data4[6], el.Data4[7]); - - return tostrBuf; -} - WRAPPED_POOL_INST(WrappedIDXGIDevice4); std::vector WrappedIDXGISwapChain4::m_D3DCallbacks; @@ -159,7 +148,7 @@ bool RefCountDXGIObject::HandleWrap(REFIID riid, void **ppvObject) if(!printed) { printed = true; - RDCWARN("Querying IDXGIObject for unsupported D3D10 interface: %s", ToStr::Get(riid).c_str()); + RDCWARN("Querying IDXGIObject for unsupported D3D10 interface: %s", ToStr(riid).c_str()); } return false; } @@ -169,12 +158,12 @@ bool RefCountDXGIObject::HandleWrap(REFIID riid, void **ppvObject) if(!printed) { printed = true; - RDCWARN("Querying IDXGIObject for unknown GUID: %s", ToStr::Get(riid).c_str()); + RDCWARN("Querying IDXGIObject for unknown GUID: %s", ToStr(riid).c_str()); } } else { - string guid = ToStr::Get(riid); + string guid = ToStr(riid); RDCWARN("Querying IDXGIObject for interface: %s", guid.c_str()); } @@ -302,7 +291,7 @@ HRESULT STDMETHODCALLTYPE WrappedIDXGISwapChain4::QueryInterface(REFIID riid, vo } else { - string guid = ToStr::Get(riid); + string guid = ToStr(riid); RDCWARN("Querying IDXGISwapChain for interface: %s", guid.c_str()); } @@ -448,7 +437,7 @@ HRESULT WrappedIDXGISwapChain4::GetBuffer( uuid != __uuidof(ID3D12Resource)) { RDCERR("Unsupported or unrecognised UUID passed to IDXGISwapChain::GetBuffer - %s", - ToStr::Get(uuid).c_str()); + ToStr(uuid).c_str()); return E_NOINTERFACE; } @@ -463,7 +452,7 @@ HRESULT WrappedIDXGISwapChain4::GetBuffer( if(FAILED(ret)) { - RDCERR("Failed to get swapchain backbuffer %d: %08x", Buffer, ret); + RDCERR("Failed to get swapchain backbuffer %d: HRESULT: %s", Buffer, ToStr(ret).c_str()); SAFE_RELEASE(realSurface); tex = NULL; } @@ -663,7 +652,7 @@ HRESULT STDMETHODCALLTYPE WrappedIDXGIOutput5::QueryInterface(REFIID riid, void } else { - string guid = ToStr::Get(riid); + string guid = ToStr(riid); RDCWARN("Querying IDXGIOutput for interface: %s", guid.c_str()); } @@ -738,7 +727,7 @@ HRESULT STDMETHODCALLTYPE WrappedIDXGIAdapter3::QueryInterface(REFIID riid, void } else { - string guid = ToStr::Get(riid); + string guid = ToStr(riid); RDCWARN("Querying IDXGIAdapter for interface: %s", guid.c_str()); } @@ -838,7 +827,7 @@ HRESULT STDMETHODCALLTYPE WrappedIDXGIDevice4::QueryInterface(REFIID riid, void } else { - string guid = ToStr::Get(riid); + string guid = ToStr(riid); RDCWARN("Querying IDXGIDevice for interface: %s", guid.c_str()); } @@ -945,7 +934,7 @@ HRESULT STDMETHODCALLTYPE WrappedIDXGIFactory5::QueryInterface(REFIID riid, void } else { - string guid = ToStr::Get(riid); + string guid = ToStr(riid); RDCWARN("Querying IDXGIFactory for interface: %s", guid.c_str()); } diff --git a/renderdoc/driver/dxgi/renderdoc_dxgi.vcxproj b/renderdoc/driver/dxgi/renderdoc_dxgi.vcxproj index de663ef90..66a955b50 100644 --- a/renderdoc/driver/dxgi/renderdoc_dxgi.vcxproj +++ b/renderdoc/driver/dxgi/renderdoc_dxgi.vcxproj @@ -59,7 +59,7 @@ RELEASE;%(PreprocessorDefinitions) - + MultiThreadedDLL false @@ -100,6 +100,7 @@ + Create diff --git a/renderdoc/driver/dxgi/renderdoc_dxgi.vcxproj.filters b/renderdoc/driver/dxgi/renderdoc_dxgi.vcxproj.filters index d9f2d6ddf..b22042e82 100644 --- a/renderdoc/driver/dxgi/renderdoc_dxgi.vcxproj.filters +++ b/renderdoc/driver/dxgi/renderdoc_dxgi.vcxproj.filters @@ -13,6 +13,9 @@ PCH + + Util + diff --git a/renderdoc/driver/gl/gl_common.cpp b/renderdoc/driver/gl/gl_common.cpp index 8793468c8..6b0322a41 100644 --- a/renderdoc/driver/gl/gl_common.cpp +++ b/renderdoc/driver/gl/gl_common.cpp @@ -791,7 +791,7 @@ size_t BufferIdx(GLenum buf) case eGL_TRANSFORM_FEEDBACK_BUFFER: return 12; case eGL_UNIFORM_BUFFER: return 13; case eGL_PARAMETER_BUFFER_ARB: return 14; - default: RDCERR("Unexpected enum as buffer target: %s", ToStr::Get(buf).c_str()); + default: RDCERR("Unexpected enum as buffer target: %s", ToStr(buf).c_str()); } return 0; @@ -847,11 +847,11 @@ size_t QueryIdx(GLenum query) case eGL_FRAGMENT_SHADER_INVOCATIONS_ARB: idx = 15; break; case eGL_COMPUTE_SHADER_INVOCATIONS_ARB: idx = 16; break; - default: RDCERR("Unexpected enum as query target: %s", ToStr::Get(query).c_str()); + default: RDCERR("Unexpected enum as query target: %s", ToStr(query).c_str()); } if(idx >= WrappedOpenGL::MAX_QUERIES) - RDCERR("Query index for enum %s out of range %d", ToStr::Get(query).c_str(), idx); + RDCERR("Query index for enum %s out of range %d", ToStr(query).c_str(), idx); return idx; } @@ -896,7 +896,7 @@ size_t GLTypeSize(GLenum type) case eGL_INT: case eGL_FLOAT: return 4; case eGL_DOUBLE: return 8; - default: RDCWARN("Unhandled element type %s", ToStr::Get(type).c_str()); + default: RDCWARN("Unhandled element type %s", ToStr(type).c_str()); } return 0; } @@ -911,7 +911,7 @@ size_t ShaderIdx(GLenum buf) case eGL_GEOMETRY_SHADER: return 3; case eGL_FRAGMENT_SHADER: return 4; case eGL_COMPUTE_SHADER: return 5; - default: RDCERR("Unexpected enum as shader enum: %s", ToStr::Get(buf).c_str()); + default: RDCERR("Unexpected enum as shader enum: %s", ToStr(buf).c_str()); } return 0; @@ -1172,7 +1172,7 @@ const char *BlendString(GLenum blendenum) default: break; } - static string unknown = ToStr::Get(blendenum).substr(3); // 3 = strlen("GL_"); + static string unknown = ToStr(blendenum).substr(3); // 3 = strlen("GL_"); RDCERR("Unknown blend enum: %s", unknown.c_str()); @@ -1198,7 +1198,7 @@ const char *SamplerString(GLenum smpenum) default: break; } - static string unknown = ToStr::Get(smpenum).substr(3); // 3 = strlen("GL_"); + static string unknown = ToStr(smpenum).substr(3); // 3 = strlen("GL_"); RDCERR("Unknown blend enum: %s", unknown.c_str()); @@ -1430,13 +1430,13 @@ ResourceFormat MakeResourceFormat(const GLHookSet &gl, GLenum target, GLenum fmt if(int32_t(ret.compByteWidth) * 8 != data[0]) { ret.type = ResourceFormatType::Undefined; - RDCERR("Unexpected/unhandled non-uniform format: '%s'", ToStr::Get(fmt).c_str()); + RDCERR("Unexpected/unhandled non-uniform format: '%s'", ToStr(fmt).c_str()); } } else { ret.type = ResourceFormatType::Undefined; - RDCERR("Unexpected/unhandled non-uniform format: '%s'", ToStr::Get(fmt).c_str()); + RDCERR("Unexpected/unhandled non-uniform format: '%s'", ToStr(fmt).c_str()); } gl.glGetInternalformativ(target, fmt, eGL_INTERNALFORMAT_RED_TYPE, sizeof(GLint), &data[0]); @@ -1463,7 +1463,7 @@ ResourceFormat MakeResourceFormat(const GLHookSet &gl, GLenum target, GLenum fmt else { ret.type = ResourceFormatType::Undefined; - RDCERR("Unexpected/unhandled non-uniform format: '%s'", ToStr::Get(fmt).c_str()); + RDCERR("Unexpected/unhandled non-uniform format: '%s'", ToStr(fmt).c_str()); } gl.glGetInternalformativ(target, fmt, eGL_COLOR_ENCODING, sizeof(GLint), &data[0]); @@ -1492,13 +1492,13 @@ ResourceFormat MakeResourceFormat(const GLHookSet &gl, GLenum target, GLenum fmt case eGL_DEPTH24_STENCIL8: ret.type = ResourceFormatType::D24S8; break; case eGL_DEPTH32F_STENCIL8: ret.type = ResourceFormatType::D32S8; break; case eGL_STENCIL_INDEX8: ret.type = ResourceFormatType::S8; break; - default: RDCERR("Unexpected depth or stencil format '%s'", ToStr::Get(fmt).c_str()); + default: RDCERR("Unexpected depth or stencil format '%s'", ToStr(fmt).c_str()); } } else { // not colour or depth! - RDCERR("Unexpected texture type, not colour or depth: '%s'", ToStr::Get(fmt).c_str()); + RDCERR("Unexpected texture type, not colour or depth: '%s'", ToStr(fmt).c_str()); } return ret; @@ -2128,7 +2128,7 @@ static void ForAllProgramUniforms(const GLHookSet &gl, Serialiser *ser, GLuint p case eGL_BOOL_VEC3: gl.glGetUniformuiv(progSrc, srcLocation, uiv); break; case eGL_UNSIGNED_INT_VEC4: case eGL_BOOL_VEC4: gl.glGetUniformuiv(progSrc, srcLocation, uiv); break; - default: RDCERR("Unhandled uniform type '%s'", ToStr::Get(type).c_str()); + default: RDCERR("Unhandled uniform type '%s'", ToStr(type).c_str()); } } @@ -2277,7 +2277,7 @@ static void ForAllProgramUniforms(const GLHookSet &gl, Serialiser *ser, GLuint p case eGL_BOOL_VEC3: gl.glProgramUniform3uiv(progDst, newloc, 1, uiv); break; case eGL_UNSIGNED_INT_VEC4: case eGL_BOOL_VEC4: gl.glProgramUniform4uiv(progDst, newloc, 1, uiv); break; - default: RDCERR("Unhandled uniform type '%s'", ToStr::Get(type).c_str()); + default: RDCERR("Unhandled uniform type '%s'", ToStr(type).c_str()); } } } @@ -2519,7 +2519,7 @@ void SerialiseProgramBindings(const GLHookSet &gl, Serialiser *ser, GLuint prog, } template <> -string ToStrHelper::Get(const WrappedOpenGL::UniformType &el) +std::string DoStringise(const WrappedOpenGL::UniformType &el) { switch(el) { @@ -2577,7 +2577,7 @@ string ToStrHelper::Get(const WrappedOpenGL:: } template <> -string ToStrHelper::Get(const RDCGLenum &el) +std::string DoStringise(const RDCGLenum &el) { #undef GLenum @@ -6470,14 +6470,14 @@ string ToStrHelper::Get(const RDCGLenum &el) #include "3rdparty/catch/catch.hpp" -#define CATCH_TOSTR(type) \ - namespace Catch \ - { \ - template <> \ - struct StringMaker \ - { \ - static std::string convert(type const &value) { return ToStr::Get(value); } \ - }; \ +#define CATCH_TOSTR(type) \ + namespace Catch \ + { \ + template <> \ + struct StringMaker \ + { \ + static std::string convert(type const &value) { return ToStr(value); } \ + }; \ } CATCH_TOSTR(CompType); @@ -6665,7 +6665,7 @@ TEST_CASE("GL formats", "[format][gl]") if(fmt.type != ResourceFormatType::Regular) continue; - INFO("Format is " << ToStr::Get(f)); + INFO("Format is " << ToStr(f)); uint32_t size = fmt.compCount * fmt.compByteWidth * 123 * 456; diff --git a/renderdoc/driver/gl/gl_debug.cpp b/renderdoc/driver/gl/gl_debug.cpp index 01fc7ecec..dcf1d035b 100644 --- a/renderdoc/driver/gl/gl_debug.cpp +++ b/renderdoc/driver/gl/gl_debug.cpp @@ -498,7 +498,7 @@ void GLReplay::InitDebugData() { string defines = extensions; - defines += string("#define SHADER_RESTYPE ") + ToStr::Get(t) + "\n"; + defines += string("#define SHADER_RESTYPE ") + ToStr(t) + "\n"; defines += string("#define UINT_TEX ") + (i == 1 ? "1" : "0") + "\n"; defines += string("#define SINT_TEX ") + (i == 2 ? "1" : "0") + "\n"; @@ -510,7 +510,7 @@ void GLReplay::InitDebugData() { string defines = extensions; - defines += string("#define SHADER_RESTYPE ") + ToStr::Get(t) + "\n"; + defines += string("#define SHADER_RESTYPE ") + ToStr(t) + "\n"; defines += string("#define UINT_TEX ") + (i == 1 ? "1" : "0") + "\n"; defines += string("#define SINT_TEX ") + (i == 2 ? "1" : "0") + "\n"; @@ -523,7 +523,7 @@ void GLReplay::InitDebugData() if(t == 1) { string defines = extensions; - defines += string("#define SHADER_RESTYPE ") + ToStr::Get(t) + "\n"; + defines += string("#define SHADER_RESTYPE ") + ToStr(t) + "\n"; defines += string("#define UINT_TEX ") + (i == 1 ? "1" : "0") + "\n"; defines += string("#define SINT_TEX ") + (i == 2 ? "1" : "0") + "\n"; diff --git a/renderdoc/driver/gl/gl_driver.cpp b/renderdoc/driver/gl/gl_driver.cpp index 948191303..dfff083e2 100644 --- a/renderdoc/driver/gl/gl_driver.cpp +++ b/renderdoc/driver/gl/gl_driver.cpp @@ -1110,7 +1110,7 @@ const char *WrappedOpenGL::GetChunkName(uint32_t idx) } template <> -string ToStrHelper::Get(const GLChunkType &el) +std::string DoStringise(const GLChunkType &el) { return WrappedOpenGL::GetChunkName(el); } @@ -3326,8 +3326,7 @@ void WrappedOpenGL::DebugSnoop(GLenum source, GLenum type, GLuint id, GLenum sev if(type != eGL_DEBUG_TYPE_PERFORMANCE && type != eGL_DEBUG_TYPE_OTHER) { RDCLOG("Got a Debug message from %s, type %s, ID %d, severity %s:\n'%s'", - ToStr::Get(source).c_str(), ToStr::Get(type).c_str(), id, ToStr::Get(severity).c_str(), - message); + ToStr(source).c_str(), ToStr(type).c_str(), id, ToStr(severity).c_str(), message); if(m_DebugMsgContext != "") RDCLOG("Debug Message context: \"%s\"", m_DebugMsgContext.c_str()); } diff --git a/renderdoc/driver/gl/gl_replay.cpp b/renderdoc/driver/gl/gl_replay.cpp index 0d5d9066a..23f7103c0 100644 --- a/renderdoc/driver/gl/gl_replay.cpp +++ b/renderdoc/driver/gl/gl_replay.cpp @@ -598,7 +598,7 @@ void GLReplay::CacheTexture(ResourceId id) default: tex.resType = TextureDim::Unknown; - RDCERR("Unexpected texture enum %s", ToStr::Get(target).c_str()); + RDCERR("Unexpected texture enum %s", ToStr(target).c_str()); } switch(target) @@ -643,7 +643,7 @@ void GLReplay::CacheTexture(ResourceId id) tex.depth = (uint32_t)depth; break; - default: tex.dimension = 2; RDCERR("Unexpected texture enum %s", ToStr::Get(target).c_str()); + default: tex.dimension = 2; RDCERR("Unexpected texture enum %s", ToStr(target).c_str()); } tex.creationFlags = res.creationFlags; @@ -1272,7 +1272,7 @@ void GLReplay::SavePipelineState() else if(binding != t) { RDCWARN("Two uniforms pointing to texture unit %d with types %s and %s", unit, - ToStr::Get(binding).c_str(), ToStr::Get(t).c_str()); + ToStr(binding).c_str(), ToStr(t).c_str()); } } } diff --git a/renderdoc/driver/gl/gl_resources.cpp b/renderdoc/driver/gl/gl_resources.cpp index d82678f6c..5a0de1a0e 100644 --- a/renderdoc/driver/gl/gl_resources.cpp +++ b/renderdoc/driver/gl/gl_resources.cpp @@ -34,7 +34,7 @@ size_t GetCompressedByteSize(GLsizei w, GLsizei h, GLsizei d, GLenum internalfor { if(!IsCompressedFormat(internalformat)) { - RDCERR("Not compressed format %s", ToStr::Get(internalformat).c_str()); + RDCERR("Not compressed format %s", ToStr(internalformat).c_str()); return GetByteSize(w, h, d, GetBaseFormat(internalformat), GetDataType(internalformat)); } @@ -214,7 +214,7 @@ size_t GetCompressedByteSize(GLsizei w, GLsizei h, GLsizei d, GLenum internalfor return blocks[0] * blocks[1] * 16 * d; } - RDCERR("Unrecognised compressed format %s", ToStr::Get(internalformat).c_str()); + RDCERR("Unrecognised compressed format %s", ToStr(internalformat).c_str()); return GetByteSize(w, h, d, GetBaseFormat(internalformat), GetDataType(internalformat)); } @@ -257,7 +257,7 @@ size_t GetByteSize(GLsizei w, GLsizei h, GLsizei d, GLenum format, GLenum type) case eGL_UNSIGNED_INT_24_8: return w * h * d * 4; case eGL_DEPTH32F_STENCIL8: case eGL_FLOAT_32_UNSIGNED_INT_24_8_REV: return w * h * d * 8; - default: RDCERR("Unhandled Byte Size type %s!", ToStr::Get(type).c_str()); break; + default: RDCERR("Unhandled Byte Size type %s!", ToStr(type).c_str()); break; } switch((int)format) @@ -285,7 +285,7 @@ size_t GetByteSize(GLsizei w, GLsizei h, GLsizei d, GLenum format, GLenum type) case eGL_RGBA_INTEGER: case eGL_BGRA: case eGL_BGRA_INTEGER: return w * h * d * elemSize * 4; - default: RDCERR("Unhandled Byte Size format %s!", ToStr::Get(type).c_str()); break; + default: RDCERR("Unhandled Byte Size format %s!", ToStr(type).c_str()); break; } RDCERR("Unhandled Byte Size case!"); @@ -385,7 +385,7 @@ GLenum GetBaseFormat(GLenum internalFormat) default: break; } - RDCERR("Unhandled Base Format case %s!", ToStr::Get(internalFormat).c_str()); + RDCERR("Unhandled Base Format case %s!", ToStr(internalFormat).c_str()); return eGL_NONE; } @@ -476,7 +476,7 @@ GLenum GetDataType(GLenum internalFormat) default: break; } - RDCERR("Unhandled Data Type case %s!", ToStr::Get(internalFormat).c_str()); + RDCERR("Unhandled Data Type case %s!", ToStr(internalFormat).c_str()); return eGL_NONE; } @@ -975,7 +975,7 @@ GLenum TextureBinding(GLenum target) default: break; } - RDCERR("Unexpected target %s", ToStr::Get(target).c_str()); + RDCERR("Unexpected target %s", ToStr(target).c_str()); return eGL_NONE; } @@ -1001,7 +1001,7 @@ GLenum BufferBinding(GLenum target) default: break; } - RDCERR("Unexpected target %s", ToStr::Get(target).c_str()); + RDCERR("Unexpected target %s", ToStr(target).c_str()); return eGL_NONE; } @@ -1015,7 +1015,7 @@ GLenum FramebufferBinding(GLenum target) default: break; } - RDCERR("Unexpected target %s", ToStr::Get(target).c_str()); + RDCERR("Unexpected target %s", ToStr(target).c_str()); return eGL_NONE; } diff --git a/renderdoc/driver/gl/gl_shader_refl.cpp b/renderdoc/driver/gl/gl_shader_refl.cpp index 617009d4c..730b5ac63 100644 --- a/renderdoc/driver/gl/gl_shader_refl.cpp +++ b/renderdoc/driver/gl/gl_shader_refl.cpp @@ -1647,7 +1647,7 @@ void MakeShaderReflection(const GLHookSet &gl, GLenum shadType, GLuint sepProg, case eGL_BOOL_VEC4: sig.compType = CompType::UInt; break; default: sig.compType = CompType::Float; - RDCWARN("Unhandled signature element type %s", ToStr::Get((GLenum)values[1]).c_str()); + RDCWARN("Unhandled signature element type %s", ToStr((GLenum)values[1]).c_str()); } switch(values[1]) @@ -1739,7 +1739,7 @@ void MakeShaderReflection(const GLHookSet &gl, GLenum shadType, GLuint sepProg, sig.regChannelMask = 0x3; break; default: - RDCWARN("Unhandled signature element type %s", ToStr::Get((GLenum)values[1]).c_str()); + RDCWARN("Unhandled signature element type %s", ToStr((GLenum)values[1]).c_str()); sig.compCount = 4; sig.regChannelMask = 0xf; break; diff --git a/renderdoc/driver/gl/wrappers/gl_buffer_funcs.cpp b/renderdoc/driver/gl/wrappers/gl_buffer_funcs.cpp index 5fbb88924..c25d0f67e 100644 --- a/renderdoc/driver/gl/wrappers/gl_buffer_funcs.cpp +++ b/renderdoc/driver/gl/wrappers/gl_buffer_funcs.cpp @@ -241,7 +241,7 @@ void WrappedOpenGL::glBindBuffer(GLenum target, GLuint buffer) if(!r) { - RDCERR("Invalid/unrecognised buffer passed: glBindBuffer(%s, %u)", ToStr::Get(target).c_str(), + RDCERR("Invalid/unrecognised buffer passed: glBindBuffer(%s, %u)", ToStr(target).c_str(), buffer); return; } @@ -2082,7 +2082,7 @@ void *WrappedOpenGL::glMapBuffer(GLenum target, GLenum access) } RDCERR("glMapBuffer: Couldn't get resource record for target %s - no buffer bound?", - ToStr::Get(target).c_str()); + ToStr(target).c_str()); } return m_Real.glMapBuffer(target, access); @@ -2323,7 +2323,7 @@ GLboolean WrappedOpenGL::glUnmapBuffer(GLenum target) return glUnmapNamedBufferEXT(record->Resource.name); RDCERR("glUnmapBuffer: Couldn't get resource record for target %s - no buffer bound?", - ToStr::Get(target).c_str()); + ToStr(target).c_str()); } return m_Real.glUnmapBuffer(target); diff --git a/renderdoc/driver/gl/wrappers/gl_draw_funcs.cpp b/renderdoc/driver/gl/wrappers/gl_draw_funcs.cpp index 5e3d326ff..13cdcae86 100644 --- a/renderdoc/driver/gl/wrappers/gl_draw_funcs.cpp +++ b/renderdoc/driver/gl/wrappers/gl_draw_funcs.cpp @@ -46,8 +46,7 @@ bool WrappedOpenGL::Serialise_glDispatchCompute(GLuint num_groups_x, GLuint num_ if(m_State == READING) { AddEvent(desc); - string name = - "glDispatchCompute(" + ToStr::Get(X) + ", " + ToStr::Get(Y) + ", " + ToStr::Get(Z) + ")"; + string name = "glDispatchCompute(" + ToStr(X) + ", " + ToStr(Y) + ", " + ToStr(Z) + ")"; DrawcallDescription draw; draw.name = name; @@ -126,9 +125,8 @@ bool WrappedOpenGL::Serialise_glDispatchComputeGroupSizeARB(GLuint num_groups_x, if(m_State == READING) { AddEvent(desc); - string name = "glDispatchComputeGroupSizeARB(" + ToStr::Get(X) + ", " + ToStr::Get(Y) + ", " + - ToStr::Get(Z) + ", " + ToStr::Get(sX) + ", " + ToStr::Get(sY) + ", " + - ToStr::Get(sZ) + ")"; + string name = "glDispatchComputeGroupSizeARB(" + ToStr(X) + ", " + ToStr(Y) + ", " + ToStr(Z) + + ", " + ToStr(sX) + ", " + ToStr(sY) + ", " + ToStr(sZ) + ")"; DrawcallDescription draw; draw.name = name; @@ -227,8 +225,8 @@ bool WrappedOpenGL::Serialise_glDispatchComputeIndirect(GLintptr indirect) groupSizes); AddEvent(desc); - string name = "glDispatchComputeIndirect(<" + ToStr::Get(groupSizes[0]) + ", " + - ToStr::Get(groupSizes[1]) + ", " + ToStr::Get(groupSizes[2]) + ">)"; + string name = "glDispatchComputeIndirect(<" + ToStr(groupSizes[0]) + ", " + + ToStr(groupSizes[1]) + ", " + ToStr(groupSizes[2]) + ">)"; DrawcallDescription draw; draw.name = name; @@ -279,44 +277,28 @@ enum MemoryBarrierBitfield }; template <> -string ToStrHelper::Get(const MemoryBarrierBitfield &el) +std::string DoStringise(const MemoryBarrierBitfield &el) { - string ret; + BEGIN_BITFIELD_STRINGISE(MemoryBarrierBitfield); + { + STRINGISE_BITFIELD_VALUE_NAMED((MemoryBarrierBitfield)GL_ALL_BARRIER_BITS, + "GL_ALL_BARRIER_BITS"); - if(el == (MemoryBarrierBitfield)GL_ALL_BARRIER_BITS) - return "GL_ALL_BARRIER_BITS"; - - if(el & GL_VERTEX_ATTRIB_ARRAY_BARRIER_BIT) - ret += " | GL_VERTEX_ATTRIB_ARRAY_BARRIER_BIT"; - if(el & GL_ELEMENT_ARRAY_BARRIER_BIT) - ret += " | GL_ELEMENT_ARRAY_BARRIER_BIT"; - if(el & GL_UNIFORM_BARRIER_BIT) - ret += " | GL_UNIFORM_BARRIER_BIT"; - if(el & GL_TEXTURE_FETCH_BARRIER_BIT) - ret += " | GL_TEXTURE_FETCH_BARRIER_BIT"; - if(el & GL_SHADER_IMAGE_ACCESS_BARRIER_BIT) - ret += " | GL_SHADER_IMAGE_ACCESS_BARRIER_BIT"; - if(el & GL_COMMAND_BARRIER_BIT) - ret += " | GL_COMMAND_BARRIER_BIT"; - if(el & GL_PIXEL_BUFFER_BARRIER_BIT) - ret += " | GL_PIXEL_BUFFER_BARRIER_BIT"; - if(el & GL_TEXTURE_UPDATE_BARRIER_BIT) - ret += " | GL_TEXTURE_UPDATE_BARRIER_BIT"; - if(el & GL_BUFFER_UPDATE_BARRIER_BIT) - ret += " | GL_BUFFER_UPDATE_BARRIER_BIT"; - if(el & GL_FRAMEBUFFER_BARRIER_BIT) - ret += " | GL_FRAMEBUFFER_BARRIER_BIT"; - if(el & GL_TRANSFORM_FEEDBACK_BARRIER_BIT) - ret += " | GL_TRANSFORM_FEEDBACK_BARRIER_BIT"; - if(el & GL_ATOMIC_COUNTER_BARRIER_BIT) - ret += " | GL_ATOMIC_COUNTER_BARRIER_BIT"; - if(el & GL_SHADER_STORAGE_BARRIER_BIT) - ret += " | GL_SHADER_STORAGE_BARRIER_BIT"; - - if(!ret.empty()) - ret = ret.substr(3); - - return ret; + STRINGISE_BITFIELD_BIT(GL_VERTEX_ATTRIB_ARRAY_BARRIER_BIT); + STRINGISE_BITFIELD_BIT(GL_ELEMENT_ARRAY_BARRIER_BIT); + STRINGISE_BITFIELD_BIT(GL_UNIFORM_BARRIER_BIT); + STRINGISE_BITFIELD_BIT(GL_TEXTURE_FETCH_BARRIER_BIT); + STRINGISE_BITFIELD_BIT(GL_SHADER_IMAGE_ACCESS_BARRIER_BIT); + STRINGISE_BITFIELD_BIT(GL_COMMAND_BARRIER_BIT); + STRINGISE_BITFIELD_BIT(GL_PIXEL_BUFFER_BARRIER_BIT); + STRINGISE_BITFIELD_BIT(GL_TEXTURE_UPDATE_BARRIER_BIT); + STRINGISE_BITFIELD_BIT(GL_BUFFER_UPDATE_BARRIER_BIT); + STRINGISE_BITFIELD_BIT(GL_FRAMEBUFFER_BARRIER_BIT); + STRINGISE_BITFIELD_BIT(GL_TRANSFORM_FEEDBACK_BARRIER_BIT); + STRINGISE_BITFIELD_BIT(GL_ATOMIC_COUNTER_BARRIER_BIT); + STRINGISE_BITFIELD_BIT(GL_SHADER_STORAGE_BARRIER_BIT); + } + END_BITFIELD_STRINGISE(); } bool WrappedOpenGL::Serialise_glMemoryBarrier(GLbitfield barriers) @@ -698,7 +680,7 @@ bool WrappedOpenGL::Serialise_glDrawArrays(GLenum mode, GLint first, GLsizei cou if(m_State == READING) { AddEvent(desc); - string name = "glDrawArrays(" + ToStr::Get(Count) + ")"; + string name = "glDrawArrays(" + ToStr(Count) + ")"; DrawcallDescription draw; draw.name = name; @@ -912,8 +894,8 @@ bool WrappedOpenGL::Serialise_glDrawArraysIndirect(GLenum mode, const void *indi m_Real.glGetBufferSubData(eGL_DRAW_INDIRECT_BUFFER, (GLintptr)Offset, sizeof(params), ¶ms); AddEvent(desc); - string name = "glDrawArraysIndirect(" + ToStr::Get(params.count) + ", " + - ToStr::Get(params.instanceCount) + ">)"; + string name = + "glDrawArraysIndirect(" + ToStr(params.count) + ", " + ToStr(params.instanceCount) + ">)"; DrawcallDescription draw; draw.name = name; @@ -982,8 +964,7 @@ bool WrappedOpenGL::Serialise_glDrawArraysInstanced(GLenum mode, GLint first, GL if(m_State == READING) { AddEvent(desc); - string name = - "glDrawArraysInstanced(" + ToStr::Get(Count) + ", " + ToStr::Get(InstanceCount) + ")"; + string name = "glDrawArraysInstanced(" + ToStr(Count) + ", " + ToStr(InstanceCount) + ")"; DrawcallDescription draw; draw.name = name; @@ -1055,8 +1036,8 @@ bool WrappedOpenGL::Serialise_glDrawArraysInstancedBaseInstance(GLenum mode, GLi if(m_State == READING) { AddEvent(desc); - string name = "glDrawArraysInstancedBaseInstance(" + ToStr::Get(Count) + ", " + - ToStr::Get(InstanceCount) + ")"; + string name = + "glDrawArraysInstancedBaseInstance(" + ToStr(Count) + ", " + ToStr(InstanceCount) + ")"; DrawcallDescription draw; draw.name = name; @@ -1174,7 +1155,7 @@ bool WrappedOpenGL::Serialise_glDrawElements(GLenum mode, GLsizei count, GLenum if(m_State == READING) { AddEvent(desc); - string name = "glDrawElements(" + ToStr::Get(Count) + ")"; + string name = "glDrawElements(" + ToStr(Count) + ")"; uint32_t IdxSize = Type == eGL_UNSIGNED_BYTE ? 1 : Type == eGL_UNSIGNED_SHORT ? 2 @@ -1248,8 +1229,8 @@ bool WrappedOpenGL::Serialise_glDrawElementsIndirect(GLenum mode, GLenum type, c m_Real.glGetBufferSubData(eGL_DRAW_INDIRECT_BUFFER, (GLintptr)Offset, sizeof(params), ¶ms); AddEvent(desc); - string name = "glDrawElementsIndirect(" + ToStr::Get(params.count) + ", " + - ToStr::Get(params.instanceCount) + ">)"; + string name = + "glDrawElementsIndirect(" + ToStr(params.count) + ", " + ToStr(params.instanceCount) + ">)"; uint32_t IdxSize = Type == eGL_UNSIGNED_BYTE ? 1 : Type == eGL_UNSIGNED_SHORT ? 2 @@ -1330,7 +1311,7 @@ bool WrappedOpenGL::Serialise_glDrawRangeElements(GLenum mode, GLuint start, GLu if(m_State == READING) { AddEvent(desc); - string name = "glDrawRangeElements(" + ToStr::Get(Count) + ")"; + string name = "glDrawRangeElements(" + ToStr(Count) + ")"; uint32_t IdxSize = Type == eGL_UNSIGNED_BYTE ? 1 : Type == eGL_UNSIGNED_SHORT ? 2 @@ -1412,7 +1393,7 @@ bool WrappedOpenGL::Serialise_glDrawRangeElementsBaseVertex(GLenum mode, GLuint if(m_State == READING) { AddEvent(desc); - string name = "glDrawRangeElementsBaseVertex(" + ToStr::Get(Count) + ")"; + string name = "glDrawRangeElementsBaseVertex(" + ToStr(Count) + ")"; uint32_t IdxSize = Type == eGL_UNSIGNED_BYTE ? 1 : Type == eGL_UNSIGNED_SHORT ? 2 @@ -1491,7 +1472,7 @@ bool WrappedOpenGL::Serialise_glDrawElementsBaseVertex(GLenum mode, GLsizei coun if(m_State == READING) { AddEvent(desc); - string name = "glDrawElementsBaseVertex(" + ToStr::Get(Count) + ")"; + string name = "glDrawElementsBaseVertex(" + ToStr(Count) + ")"; uint32_t IdxSize = Type == eGL_UNSIGNED_BYTE ? 1 : Type == eGL_UNSIGNED_SHORT ? 2 @@ -1569,7 +1550,7 @@ bool WrappedOpenGL::Serialise_glDrawElementsInstanced(GLenum mode, GLsizei count if(m_State == READING) { AddEvent(desc); - string name = "glDrawElementsInstanced(" + ToStr::Get(Count) + ")"; + string name = "glDrawElementsInstanced(" + ToStr(Count) + ")"; uint32_t IdxSize = Type == eGL_UNSIGNED_BYTE ? 1 : Type == eGL_UNSIGNED_SHORT ? 2 @@ -1651,7 +1632,7 @@ bool WrappedOpenGL::Serialise_glDrawElementsInstancedBaseInstance(GLenum mode, G if(m_State == READING) { AddEvent(desc); - string name = "glDrawElementsInstancedBaseInstance(" + ToStr::Get(Count) + ")"; + string name = "glDrawElementsInstancedBaseInstance(" + ToStr(Count) + ")"; uint32_t IdxSize = Type == eGL_UNSIGNED_BYTE ? 1 : Type == eGL_UNSIGNED_SHORT ? 2 @@ -1735,8 +1716,8 @@ bool WrappedOpenGL::Serialise_glDrawElementsInstancedBaseVertex(GLenum mode, GLs if(m_State == READING) { AddEvent(desc); - string name = "glDrawElementsInstancedBaseVertex(" + ToStr::Get(Count) + ", " + - ToStr::Get(InstCount) + ")"; + string name = + "glDrawElementsInstancedBaseVertex(" + ToStr(Count) + ", " + ToStr(InstCount) + ")"; uint32_t IdxSize = Type == eGL_UNSIGNED_BYTE ? 1 : Type == eGL_UNSIGNED_SHORT ? 2 @@ -1820,8 +1801,8 @@ bool WrappedOpenGL::Serialise_glDrawElementsInstancedBaseVertexBaseInstance( if(m_State == READING) { AddEvent(desc); - string name = "glDrawElementsInstancedBaseVertexBaseInstance(" + ToStr::Get(Count) + ", " + - ToStr::Get(InstCount) + ")"; + string name = "glDrawElementsInstancedBaseVertexBaseInstance(" + ToStr(Count) + ", " + + ToStr(InstCount) + ")"; uint32_t IdxSize = Type == eGL_UNSIGNED_BYTE ? 1 : Type == eGL_UNSIGNED_SHORT ? 2 @@ -1941,7 +1922,7 @@ bool WrappedOpenGL::Serialise_glMultiDrawArrays(GLenum mode, const GLint *first, if(m_State == READING) { - string name = "glMultiDrawArrays(" + ToStr::Get(Count) + ")"; + string name = "glMultiDrawArrays(" + ToStr(Count) + ")"; DrawcallDescription draw; draw.name = name; @@ -1961,8 +1942,7 @@ bool WrappedOpenGL::Serialise_glMultiDrawArrays(GLenum mode, const GLint *first, multidraw.numIndices = countArray[i]; multidraw.vertexOffset = firstArray[i]; - multidraw.name = - "glMultiDrawArrays[" + ToStr::Get(i) + "](" + ToStr::Get(multidraw.numIndices) + ")"; + multidraw.name = "glMultiDrawArrays[" + ToStr(i) + "](" + ToStr(multidraw.numIndices) + ")"; multidraw.flags |= DrawFlags::Drawcall; @@ -2092,7 +2072,7 @@ bool WrappedOpenGL::Serialise_glMultiDrawElements(GLenum mode, const GLsizei *co if(m_State == READING) { - string name = "glMultiDrawElements(" + ToStr::Get(Count) + ")"; + string name = "glMultiDrawElements(" + ToStr(Count) + ")"; uint32_t IdxSize = Type == eGL_UNSIGNED_BYTE ? 1 : Type == eGL_UNSIGNED_SHORT ? 2 @@ -2122,8 +2102,7 @@ bool WrappedOpenGL::Serialise_glMultiDrawElements(GLenum mode, const GLsizei *co multidraw.indexOffset /= IdxSize; - multidraw.name = - "glMultiDrawElements[" + ToStr::Get(i) + "](" + ToStr::Get(multidraw.numIndices) + ")"; + multidraw.name = "glMultiDrawElements[" + ToStr(i) + "](" + ToStr(multidraw.numIndices) + ")"; multidraw.flags |= DrawFlags::Drawcall | DrawFlags::UseIBuffer; @@ -2257,7 +2236,7 @@ bool WrappedOpenGL::Serialise_glMultiDrawElementsBaseVertex(GLenum mode, const G if(m_State == READING) { - string name = "glMultiDrawElementsBaseVertex(" + ToStr::Get(Count) + ")"; + string name = "glMultiDrawElementsBaseVertex(" + ToStr(Count) + ")"; uint32_t IdxSize = Type == eGL_UNSIGNED_BYTE ? 1 : Type == eGL_UNSIGNED_SHORT ? 2 @@ -2286,8 +2265,8 @@ bool WrappedOpenGL::Serialise_glMultiDrawElementsBaseVertex(GLenum mode, const G multidraw.indexOffset /= IdxSize; - multidraw.name = "glMultiDrawElementsBaseVertex[" + ToStr::Get(i) + "](" + - ToStr::Get(multidraw.numIndices) + ")"; + multidraw.name = + "glMultiDrawElementsBaseVertex[" + ToStr(i) + "](" + ToStr(multidraw.numIndices) + ")"; multidraw.flags |= DrawFlags::Drawcall | DrawFlags::UseIBuffer; @@ -2409,7 +2388,7 @@ bool WrappedOpenGL::Serialise_glMultiDrawArraysIndirect(GLenum mode, const void if(m_State == READING) { - string name = "glMultiDrawArraysIndirect(" + ToStr::Get(Count) + ")"; + string name = "glMultiDrawArraysIndirect(" + ToStr(Count) + ")"; DrawcallDescription draw; draw.name = name; @@ -2451,9 +2430,8 @@ bool WrappedOpenGL::Serialise_glMultiDrawArraysIndirect(GLenum mode, const void multidraw.vertexOffset = params.first; multidraw.instanceOffset = params.baseInstance; - multidraw.name = "glMultiDrawArraysIndirect[" + ToStr::Get(i) + "](<" + - ToStr::Get(multidraw.numIndices) + ", " + - ToStr::Get(multidraw.numInstances) + ">)"; + multidraw.name = "glMultiDrawArraysIndirect[" + ToStr(i) + "](<" + + ToStr(multidraw.numIndices) + ", " + ToStr(multidraw.numInstances) + ">)"; multidraw.flags |= DrawFlags::Drawcall | DrawFlags::Instanced | DrawFlags::Indirect; @@ -2576,7 +2554,7 @@ bool WrappedOpenGL::Serialise_glMultiDrawElementsIndirect(GLenum mode, GLenum ty if(m_State == READING) { - string name = "glMultiDrawElementsIndirect(" + ToStr::Get(Count) + ")"; + string name = "glMultiDrawElementsIndirect(" + ToStr(Count) + ")"; DrawcallDescription draw; draw.name = name; @@ -2620,9 +2598,8 @@ bool WrappedOpenGL::Serialise_glMultiDrawElementsIndirect(GLenum mode, GLenum ty multidraw.baseVertex = params.baseVertex; multidraw.instanceOffset = params.baseInstance; - multidraw.name = "glMultiDrawElementsIndirect[" + ToStr::Get(i) + "](<" + - ToStr::Get(multidraw.numIndices) + ", " + - ToStr::Get(multidraw.numInstances) + ">)"; + multidraw.name = "glMultiDrawElementsIndirect[" + ToStr(i) + "](<" + + ToStr(multidraw.numIndices) + ", " + ToStr(multidraw.numInstances) + ">)"; multidraw.flags |= DrawFlags::Drawcall | DrawFlags::UseIBuffer | DrawFlags::Instanced | DrawFlags::Indirect; @@ -2753,7 +2730,7 @@ bool WrappedOpenGL::Serialise_glMultiDrawArraysIndirectCountARB(GLenum mode, GLi if(m_State == READING) { - string name = "glMultiDrawArraysIndirectCountARB(<" + ToStr::Get(realdrawcount) + ">)"; + string name = "glMultiDrawArraysIndirectCountARB(<" + ToStr(realdrawcount) + ">)"; DrawcallDescription draw; draw.name = name; @@ -2795,9 +2772,8 @@ bool WrappedOpenGL::Serialise_glMultiDrawArraysIndirectCountARB(GLenum mode, GLi multidraw.vertexOffset = params.first; multidraw.instanceOffset = params.baseInstance; - multidraw.name = "glMultiDrawArraysIndirect[" + ToStr::Get(i) + "](<" + - ToStr::Get(multidraw.numIndices) + ", " + - ToStr::Get(multidraw.numInstances) + ">)"; + multidraw.name = "glMultiDrawArraysIndirect[" + ToStr(i) + "](<" + + ToStr(multidraw.numIndices) + ", " + ToStr(multidraw.numInstances) + ">)"; multidraw.flags |= DrawFlags::Drawcall | DrawFlags::Instanced | DrawFlags::Indirect; @@ -2936,7 +2912,7 @@ bool WrappedOpenGL::Serialise_glMultiDrawElementsIndirectCountARB(GLenum mode, G if(m_State == READING) { - string name = "glMultiDrawElementsIndirectCountARB(<" + ToStr::Get(realdrawcount) + ">)"; + string name = "glMultiDrawElementsIndirectCountARB(<" + ToStr(realdrawcount) + ">)"; DrawcallDescription draw; draw.name = name; @@ -2980,9 +2956,8 @@ bool WrappedOpenGL::Serialise_glMultiDrawElementsIndirectCountARB(GLenum mode, G multidraw.baseVertex = params.baseVertex; multidraw.instanceOffset = params.baseInstance; - multidraw.name = "glMultiDrawElementsIndirect[" + ToStr::Get(i) + "](" + - ToStr::Get(multidraw.numIndices) + ", " + - ToStr::Get(multidraw.numInstances) + ")"; + multidraw.name = "glMultiDrawElementsIndirect[" + ToStr(i) + "](" + + ToStr(multidraw.numIndices) + ", " + ToStr(multidraw.numInstances) + ")"; multidraw.flags |= DrawFlags::Drawcall | DrawFlags::UseIBuffer | DrawFlags::Instanced | DrawFlags::Indirect; @@ -3059,9 +3034,8 @@ bool WrappedOpenGL::Serialise_glClearNamedFramebufferfv(GLuint framebuffer, GLen m_pSerialiser->SerialisePODArray<4>("value", (float *)&v.x); if(m_State == READING) - name = "glClearBufferfv(" + ToStr::Get(buf) + ", " + ToStr::Get(drawbuf) + ", " + - ToStr::Get(v.x) + ", " + ToStr::Get(v.y) + ", " + ToStr::Get(v.z) + ", " + - ToStr::Get(v.w) + ")"; + name = "glClearBufferfv(" + ToStr(buf) + ", " + ToStr(drawbuf) + ", " + ToStr(v.x) + ", " + + ToStr(v.y) + ", " + ToStr(v.z) + ", " + ToStr(v.w) + ")"; // use ARB_direct_state_access functions here as we use EXT_direct_state_access elsewhere. If // we are running without ARB_dsa support, these functions are emulated in the obvious way. This @@ -3077,8 +3051,7 @@ bool WrappedOpenGL::Serialise_glClearNamedFramebufferfv(GLuint framebuffer, GLen SERIALISE_ELEMENT(float, val, *value); if(m_State == READING) - name = "glClearBufferfv(" + ToStr::Get(buf) + ", " + ToStr::Get(drawbuf) + ", " + - ToStr::Get(val) + ")"; + name = "glClearBufferfv(" + ToStr(buf) + ", " + ToStr(drawbuf) + ", " + ToStr(val) + ")"; if(m_State <= EXECUTING) m_Real.glClearNamedFramebufferfv(framebuffer, buf, drawbuf, &val); @@ -3200,9 +3173,8 @@ bool WrappedOpenGL::Serialise_glClearNamedFramebufferiv(GLuint framebuffer, GLen m_pSerialiser->SerialisePODArray<4>("value", v); if(m_State == READING) - name = "glClearBufferiv(" + ToStr::Get(buf) + ", " + ToStr::Get(drawbuf) + ", " + - ToStr::Get(v[0]) + ", " + ToStr::Get(v[1]) + ", " + ToStr::Get(v[2]) + ", " + - ToStr::Get(v[3]) + ")"; + name = "glClearBufferiv(" + ToStr(buf) + ", " + ToStr(drawbuf) + ", " + ToStr(v[0]) + ", " + + ToStr(v[1]) + ", " + ToStr(v[2]) + ", " + ToStr(v[3]) + ")"; // use ARB_direct_state_access functions here as we use EXT_direct_state_access elsewhere. If // we are running without ARB_dsa support, these functions are emulated in the obvious way. This @@ -3218,8 +3190,7 @@ bool WrappedOpenGL::Serialise_glClearNamedFramebufferiv(GLuint framebuffer, GLen SERIALISE_ELEMENT(int32_t, val, *value); if(m_State == READING) - name = "glClearBufferiv(" + ToStr::Get(buf) + ", " + ToStr::Get(drawbuf) + ", " + - ToStr::Get(val) + ")"; + name = "glClearBufferiv(" + ToStr(buf) + ", " + ToStr(drawbuf) + ", " + ToStr(val) + ")"; if(m_State <= EXECUTING) m_Real.glClearNamedFramebufferiv(framebuffer, buf, drawbuf, &val); @@ -3331,9 +3302,8 @@ bool WrappedOpenGL::Serialise_glClearNamedFramebufferuiv(GLuint framebuffer, GLe m_pSerialiser->SerialisePODArray<4>("value", v); if(m_State == READING) - name = "glClearBufferuiv(" + ToStr::Get(buf) + ", " + ToStr::Get(drawbuf) + ", " + - ToStr::Get(v[0]) + ", " + ToStr::Get(v[1]) + ", " + ToStr::Get(v[2]) + ", " + - ToStr::Get(v[3]) + ")"; + name = "glClearBufferuiv(" + ToStr(buf) + ", " + ToStr(drawbuf) + ", " + ToStr(v[0]) + ", " + + ToStr(v[1]) + ", " + ToStr(v[2]) + ", " + ToStr(v[3]) + ")"; // use ARB_direct_state_access functions here as we use EXT_direct_state_access elsewhere. If // we are running without ARB_dsa support, these functions are emulated in the obvious way. This @@ -3452,7 +3422,7 @@ bool WrappedOpenGL::Serialise_glClearNamedFramebufferfi(GLuint framebuffer, GLen if(m_State == READING) { AddEvent(desc); - string name = "glClearBufferfi(" + ToStr::Get(d) + ToStr::Get(s) + ")"; + string name = "glClearBufferfi(" + ToStr(d) + ToStr(s) + ")"; DrawcallDescription draw; draw.name = name; diff --git a/renderdoc/driver/gl/wrappers/gl_emulated.cpp b/renderdoc/driver/gl/wrappers/gl_emulated.cpp index d2bcdee27..784a44fd5 100644 --- a/renderdoc/driver/gl/wrappers/gl_emulated.cpp +++ b/renderdoc/driver/gl/wrappers/gl_emulated.cpp @@ -1041,7 +1041,7 @@ void APIENTRY _glGetInternalformativ(GLenum target, GLenum internalformat, GLenu if(data == NULL) { RDCERR("Format %s not supported by internal glGetInternalformativ, update database", - ToStr::Get(internalformat).c_str()); + ToStr(internalformat).c_str()); return; } @@ -1083,7 +1083,7 @@ void APIENTRY _glGetInternalformativ(GLenum target, GLenum internalformat, GLenu case eGL_INTERNALFORMAT_DEPTH_SIZE: *params = data->depthBits; break; case eGL_INTERNALFORMAT_STENCIL_SIZE: *params = data->stencilBits; break; default: - RDCERR("pname %s not supported by internal glGetInternalformativ", ToStr::Get(pname).c_str()); + RDCERR("pname %s not supported by internal glGetInternalformativ", ToStr(pname).c_str()); break; } } @@ -1311,7 +1311,7 @@ void APIENTRY _glClearBufferSubData(GLenum target, GLenum internalformat, GLintp case GL_RGBA_INTEGER: compCount = 4; break; default: RDCERR("Unexpected format %s, not doing conversion. Update _glClearBufferSubData emulation", - ToStr::Get(format).c_str()); + ToStr(format).c_str()); } uint32_t compByteWidth = 1; @@ -1326,7 +1326,7 @@ void APIENTRY _glClearBufferSubData(GLenum target, GLenum internalformat, GLintp case eGL_FLOAT: compByteWidth = 4; break; default: RDCERR("Unexpected type %s, not doing conversion. Update _glClearBufferSubData emulation", - ToStr::Get(type).c_str()); + ToStr(type).c_str()); } CompType compType = CompType::UInt; diff --git a/renderdoc/driver/gl/wrappers/gl_framebuffer_funcs.cpp b/renderdoc/driver/gl/wrappers/gl_framebuffer_funcs.cpp index 4aca7da14..165f38a0d 100644 --- a/renderdoc/driver/gl/wrappers/gl_framebuffer_funcs.cpp +++ b/renderdoc/driver/gl/wrappers/gl_framebuffer_funcs.cpp @@ -1811,7 +1811,7 @@ bool WrappedOpenGL::Serialise_glBlitNamedFramebuffer(GLuint readFramebuffer, GLu if(m_State == READING) { AddEvent(desc); - string name = "glBlitFramebuffer(" + ToStr::Get(readId) + ", " + ToStr::Get(drawId) + ")"; + string name = "glBlitFramebuffer(" + ToStr(readId) + ", " + ToStr(drawId) + ")"; DrawcallDescription draw; draw.name = name; diff --git a/renderdoc/driver/gl/wrappers/gl_interop_funcs.cpp b/renderdoc/driver/gl/wrappers/gl_interop_funcs.cpp index 16f1b32d4..3d3133d89 100644 --- a/renderdoc/driver/gl/wrappers/gl_interop_funcs.cpp +++ b/renderdoc/driver/gl/wrappers/gl_interop_funcs.cpp @@ -312,7 +312,7 @@ bool WrappedOpenGL::Serialise_wglDXRegisterObjectNV(GLResource res, GLenum type, case eGL_TEXTURE_3D: m_Real.glTextureStorage3DEXT(name, type, mips, internalFormat, width, height, depth); break; - default: RDCERR("Unexpected type of interop texture: %s", ToStr::Get(type).c_str()); break; + default: RDCERR("Unexpected type of interop texture: %s", ToStr(type).c_str()); break; } if(type != eGL_NONE) diff --git a/renderdoc/driver/gl/wrappers/gl_query_funcs.cpp b/renderdoc/driver/gl/wrappers/gl_query_funcs.cpp index ef779931f..1f03ff997 100644 --- a/renderdoc/driver/gl/wrappers/gl_query_funcs.cpp +++ b/renderdoc/driver/gl/wrappers/gl_query_funcs.cpp @@ -277,7 +277,7 @@ void WrappedOpenGL::glBeginQuery(GLenum target, GLuint id) { m_Real.glBeginQuery(target, id); if(m_ActiveQueries[QueryIdx(target)][0]) - RDCLOG("Query already active %s", ToStr::Get(target).c_str()); + RDCLOG("Query already active %s", ToStr(target).c_str()); m_ActiveQueries[QueryIdx(target)][0] = true; if(m_State == WRITING_CAPFRAME) diff --git a/renderdoc/driver/gl/wrappers/gl_texture_funcs.cpp b/renderdoc/driver/gl/wrappers/gl_texture_funcs.cpp index 769dcc26d..11d3ae24c 100644 --- a/renderdoc/driver/gl/wrappers/gl_texture_funcs.cpp +++ b/renderdoc/driver/gl/wrappers/gl_texture_funcs.cpp @@ -721,7 +721,7 @@ bool WrappedOpenGL::Serialise_glGenerateTextureMipmapEXT(GLuint texture, GLenum if(m_State == READING) { AddEvent(desc); - string name = "glGenerateMipmap(" + ToStr::Get(id) + ")"; + string name = "glGenerateMipmap(" + ToStr(id) + ")"; DrawcallDescription draw; draw.name = name; @@ -857,7 +857,7 @@ bool WrappedOpenGL::Serialise_glCopyImageSubData(GLuint srcName, GLenum srcTarge if(m_State == READING) { AddEvent(desc); - string name = "glCopyImageSubData(" + ToStr::Get(srcid) + ", " + ToStr::Get(dstid) + ")"; + string name = "glCopyImageSubData(" + ToStr(srcid) + ", " + ToStr(dstid) + ")"; DrawcallDescription draw; draw.name = name; @@ -2919,12 +2919,12 @@ void WrappedOpenGL::StoreCompressedTexData(ResourceId texId, GLenum target, GLin if(!error.empty()) RDCWARN("StoreCompressedTexData: Unexpected %s (tex:%llu, target:%s)", error.c_str(), texId, - ToStr::Get(target).c_str()); + ToStr(target).c_str()); } else { RDCWARN("StoreCompressedTexData: No source pixels to copy from (tex:%llu, target:%s)", texId, - ToStr::Get(target).c_str()); + ToStr(target).c_str()); } SAFE_DELETE_ARRAY(unpackedPixels); diff --git a/renderdoc/driver/shaders/dxbc/dxbc_debug.cpp b/renderdoc/driver/shaders/dxbc/dxbc_debug.cpp index 02fe9d5be..9748ae063 100644 --- a/renderdoc/driver/shaders/dxbc/dxbc_debug.cpp +++ b/renderdoc/driver/shaders/dxbc/dxbc_debug.cpp @@ -1758,7 +1758,7 @@ State State::GetNext(GlobalState &global, State quad[4]) const if(FAILED(hr)) { - RDCERR("Failed to create constant buf %08x", hr); + RDCERR("Failed to create constant buf HRESULT: %s", ToStr(hr).c_str()); return s; } @@ -1784,7 +1784,7 @@ State State::GetNext(GlobalState &global, State quad[4]) const if(FAILED(hr)) { - RDCERR("Failed to create UAV buf %08x", hr); + RDCERR("Failed to create UAV buf HRESULT: %s", ToStr(hr).c_str()); return s; } @@ -1796,7 +1796,7 @@ State State::GetNext(GlobalState &global, State quad[4]) const if(FAILED(hr)) { - RDCERR("Failed to create copy buf %08x", hr); + RDCERR("Failed to create copy buf HRESULT: %s", ToStr(hr).c_str()); return s; } @@ -1812,7 +1812,7 @@ State State::GetNext(GlobalState &global, State quad[4]) const if(FAILED(hr)) { - RDCERR("Failed to create uav %08x", hr); + RDCERR("Failed to create uav HRESULT: %s", ToStr(hr).c_str()); return s; } @@ -1826,7 +1826,7 @@ State State::GetNext(GlobalState &global, State quad[4]) const if(FAILED(hr)) { - RDCERR("Failed to map results %08x", hr); + RDCERR("Failed to map results HRESULT: %s", ToStr(hr).c_str()); return s; } @@ -4248,7 +4248,7 @@ State State::GetNext(GlobalState &global, State quad[4]) const if(FAILED(hr)) { - RDCERR("Failed to create new sampler state in debugging %08x", hr); + RDCERR("Failed to create new sampler state in debugging HRESULT: %s", ToStr(hr).c_str()); } else { @@ -4299,7 +4299,7 @@ State State::GetNext(GlobalState &global, State quad[4]) const if(FAILED(hr)) { - RDCERR("Failed to create RT tex %08x", hr); + RDCERR("Failed to create RT tex HRESULT: %s", ToStr(hr).c_str()); return s; } @@ -4311,7 +4311,7 @@ State State::GetNext(GlobalState &global, State quad[4]) const if(FAILED(hr)) { - RDCERR("Failed to create copy tex %08x", hr); + RDCERR("Failed to create copy tex HRESULT: %s", ToStr(hr).c_str()); return s; } @@ -4325,7 +4325,7 @@ State State::GetNext(GlobalState &global, State quad[4]) const if(FAILED(hr)) { - RDCERR("Failed to create rt rtv %08x", hr); + RDCERR("Failed to create rt rtv HRESULT: %s", ToStr(hr).c_str()); return s; } @@ -4339,7 +4339,7 @@ State State::GetNext(GlobalState &global, State quad[4]) const if(FAILED(hr)) { - RDCERR("Failed to map results %08x", hr); + RDCERR("Failed to map results HRESULT: %s", ToStr(hr).c_str()); return s; } diff --git a/renderdoc/driver/shaders/dxbc/dxbc_inspect.cpp b/renderdoc/driver/shaders/dxbc/dxbc_inspect.cpp index 27dbc3a44..786ec928d 100644 --- a/renderdoc/driver/shaders/dxbc/dxbc_inspect.cpp +++ b/renderdoc/driver/shaders/dxbc/dxbc_inspect.cpp @@ -1037,7 +1037,7 @@ DXBCFile::DXBCFile(const void *ByteCode, size_t ByteCodeLength) std::string semanticIdxName = a.semanticName; if(a.needSemanticIndex) - semanticIdxName += ToStr::Get(a.semanticIndex); + semanticIdxName += ToStr(a.semanticIndex); a.semanticIdxName = semanticIdxName; } diff --git a/renderdoc/driver/shaders/spirv/CMakeLists.txt b/renderdoc/driver/shaders/spirv/CMakeLists.txt index ef182a533..d0615469a 100644 --- a/renderdoc/driver/shaders/spirv/CMakeLists.txt +++ b/renderdoc/driver/shaders/spirv/CMakeLists.txt @@ -93,6 +93,7 @@ set(sources spirv_common.h spirv_compile.cpp spirv_disassemble.cpp + spirv_stringise.cpp ${glslang_sources}) add_definitions(-DAMD_EXTENSIONS) diff --git a/renderdoc/driver/shaders/spirv/renderdoc_spirv.vcxproj b/renderdoc/driver/shaders/spirv/renderdoc_spirv.vcxproj index 7de4b0ab2..ea5cbffc6 100644 --- a/renderdoc/driver/shaders/spirv/renderdoc_spirv.vcxproj +++ b/renderdoc/driver/shaders/spirv/renderdoc_spirv.vcxproj @@ -59,7 +59,7 @@ RELEASE;%(PreprocessorDefinitions) - + MultiThreadedDLL false @@ -163,6 +163,7 @@ precompiled.h precompiled.h + diff --git a/renderdoc/driver/shaders/spirv/renderdoc_spirv.vcxproj.filters b/renderdoc/driver/shaders/spirv/renderdoc_spirv.vcxproj.filters index b52033865..5a31c1c5c 100644 --- a/renderdoc/driver/shaders/spirv/renderdoc_spirv.vcxproj.filters +++ b/renderdoc/driver/shaders/spirv/renderdoc_spirv.vcxproj.filters @@ -144,6 +144,7 @@ PCH + diff --git a/renderdoc/driver/shaders/spirv/spirv_disassemble.cpp b/renderdoc/driver/shaders/spirv/spirv_disassemble.cpp index abf8f602b..68287204d 100644 --- a/renderdoc/driver/shaders/spirv/spirv_disassemble.cpp +++ b/renderdoc/driver/shaders/spirv/spirv_disassemble.cpp @@ -299,7 +299,7 @@ struct GeneratorID template static string OptionalFlagString(EnumType e) { - return (int)e ? " [" + ToStr::Get(e) + "]" : ""; + return (int)e ? " [" + ToStr(e) + "]" : ""; } static string DefaultIDName(uint32_t ID) @@ -350,7 +350,7 @@ struct SPVDecoration case spv::DecorationAliased: case spv::DecorationCoherent: case spv::DecorationNonWritable: - case spv::DecorationNonReadable: return ToStr::Get(decoration); + case spv::DecorationNonReadable: return ToStr(decoration); case spv::DecorationUniform: return StringFormat::Fmt("DynamicallyUniform", val); case spv::DecorationLocation: return StringFormat::Fmt("Location=%u", val); case spv::DecorationComponent: return StringFormat::Fmt("Location=%u", val); @@ -359,7 +359,7 @@ struct SPVDecoration case spv::DecorationStream: return StringFormat::Fmt("Stream=%u", val); case spv::DecorationDescriptorSet: return StringFormat::Fmt("DescSet=%u", val); case spv::DecorationBuiltIn: - return StringFormat::Fmt("Builtin %s", ToStr::Get((spv::BuiltIn)val).c_str()); + return StringFormat::Fmt("Builtin %s", ToStr((spv::BuiltIn)val).c_str()); case spv::DecorationSpecId: return ""; // handled elsewhere @@ -376,7 +376,7 @@ struct SPVDecoration default: break; } - return StringFormat::Fmt("%s=%u", ToStr::Get(decoration).c_str(), val); + return StringFormat::Fmt("%s=%u", ToStr(decoration).c_str(), val); } }; @@ -497,7 +497,7 @@ struct SPVTypeData } if(builtin) - ret += " = " + ToStr::Get((spv::BuiltIn)builtin->val); + ret += " = " + ToStr((spv::BuiltIn)builtin->val); return ret; } @@ -550,11 +550,10 @@ struct SPVTypeData { string typestring = baseType->GetName(); if(imgformat != spv::ImageFormatUnknown) - typestring += ", " + ToStr::Get(imgformat); + typestring += ", " + ToStr(imgformat); - name = StringFormat::Fmt("%sImage%s%s%s<%s>", depth ? "Depth" : "", - multisampled ? "MS" : "", arrayed ? "Array" : "", - ToStr::Get(texdim).c_str(), typestring.c_str()); + name = StringFormat::Fmt("%sImage%s%s%s<%s>", depth ? "Depth" : "", multisampled ? "MS" : "", + arrayed ? "Array" : "", ToStr(texdim).c_str(), typestring.c_str()); } else if(type == eSampledImage) { @@ -937,7 +936,7 @@ struct SPVInstruction case spv::OpSpecConstantComposite: return GetIDName(); case spv::OpSpecConstantOp: { - string ret = StringFormat::Fmt("SpecOp%s(", ToStr::Get(constant->specOp).c_str()); + string ret = StringFormat::Fmt("SpecOp%s(", ToStr(constant->specOp).c_str()); for(size_t i = 0; i < constant->children.size(); i++) { @@ -1586,7 +1585,7 @@ struct SPVInstruction } else { - ret += ToStr::Get(opcode) + "("; + ret += ToStr(opcode) + "("; } for(size_t i = 0; i < numArgs; i++) @@ -1636,13 +1635,13 @@ struct SPVInstruction case spv::OpAtomicAnd: case spv::OpAtomicOr: case spv::OpAtomicXor: - ret += StringFormat::Fmt(", Scope=%s, Semantics=%s", ToStr::Get(op->scope).c_str(), - ToStr::Get(op->semantics).c_str()); + ret += StringFormat::Fmt(", Scope=%s, Semantics=%s", ToStr(op->scope).c_str(), + ToStr(op->semantics).c_str()); break; case spv::OpAtomicCompareExchange: - ret += StringFormat::Fmt( - ", Scope=%s, Semantics=(equal: %s unequal: %s)", ToStr::Get(op->scope).c_str(), - ToStr::Get(op->semantics).c_str(), ToStr::Get(op->semanticsUnequal).c_str()); + ret += StringFormat::Fmt(", Scope=%s, Semantics=(equal: %s unequal: %s)", + ToStr(op->scope).c_str(), ToStr(op->semantics).c_str(), + ToStr(op->semanticsUnequal).c_str()); break; default: break; } @@ -1654,19 +1653,18 @@ struct SPVInstruction case spv::OpEmitVertex: case spv::OpEmitStreamVertex: case spv::OpEndPrimitive: - case spv::OpEndStreamPrimitive: { return ToStr::Get(opcode) + "()"; + case spv::OpEndStreamPrimitive: { return ToStr(opcode) + "()"; } case spv::OpControlBarrier: { return StringFormat::Fmt("%s(Execution Scope=%s, Memory Scope=%s, Semantics=%s)", - ToStr::Get(opcode).c_str(), ToStr::Get(op->scope).c_str(), - ToStr::Get(op->scopeMemory).c_str(), - ToStr::Get(op->semantics).c_str()); + ToStr(opcode).c_str(), ToStr(op->scope).c_str(), + ToStr(op->scopeMemory).c_str(), ToStr(op->semantics).c_str()); } case spv::OpMemoryBarrier: { - return StringFormat::Fmt("%s(Scope=%s, Semantics=%s)", ToStr::Get(opcode).c_str(), - ToStr::Get(op->scope).c_str(), ToStr::Get(op->semantics).c_str()); + return StringFormat::Fmt("%s(Scope=%s, Semantics=%s)", ToStr(opcode).c_str(), + ToStr(op->scope).c_str(), ToStr(op->semantics).c_str()); } case spv::OpVectorShuffle: { @@ -1954,11 +1952,10 @@ struct SPVInstruction op->GetArg(ids, 1, b, false); if(inlineOp) - return StringFormat::Fmt("%s(%s, %s)", ToStr::Get(opcode).c_str(), a.c_str(), b.c_str()); + return StringFormat::Fmt("%s(%s, %s)", ToStr(opcode).c_str(), a.c_str(), b.c_str()); return StringFormat::Fmt("%s %s = %s(%s, %s)", op->type->GetName().c_str(), - GetIDName().c_str(), ToStr::Get(opcode).c_str(), a.c_str(), - b.c_str()); + GetIDName().c_str(), ToStr(opcode).c_str(), a.c_str(), b.c_str()); } case spv::OpSelect: { @@ -1990,7 +1987,7 @@ struct SPVInstruction if(!str.empty() || id != 0) ret += GetIDName() + " <= "; - ret = ToStr::Get(opcode) + "("; + ret = ToStr(opcode) + "("; for(size_t a = 0; op && a < op->arguments.size(); a++) { ret += op->arguments[a]->GetIDName(); @@ -2189,7 +2186,7 @@ string SPVModule::Disassemble(const string &entryPoint) retDisasm += "\n"; - retDisasm += StringFormat::Fmt("Source is %s %u\n", ToStr::Get(sourceLang).c_str(), sourceVer); + retDisasm += StringFormat::Fmt("Source is %s %u\n", ToStr(sourceLang).c_str(), sourceVer); for(size_t s = 0; s < sourceexts.size(); s++) retDisasm += StringFormat::Fmt(" + %s\n", sourceexts[s]->str.c_str()); @@ -2205,7 +2202,7 @@ string SPVModule::Disassemble(const string &entryPoint) retDisasm += "Capabilities:"; for(size_t c = 0; c < capabilities.size(); c++) - retDisasm += StringFormat::Fmt(" %s", ToStr::Get(capabilities[c]).c_str()); + retDisasm += StringFormat::Fmt(" %s", ToStr(capabilities[c]).c_str()); retDisasm += "\n"; for(size_t i = 0; i < entries.size(); i++) @@ -2214,12 +2211,12 @@ string SPVModule::Disassemble(const string &entryPoint) uint32_t func = entries[i]->entry->func; RDCASSERT(ids[func]); retDisasm += StringFormat::Fmt("Entry point '%s' (%s)\n", ids[func]->str.c_str(), - ToStr::Get(entries[i]->entry->model).c_str()); + ToStr(entries[i]->entry->model).c_str()); for(size_t m = 0; m < entries[i]->entry->modes.size(); m++) { SPVExecutionMode &mode = entries[i]->entry->modes[m]; - retDisasm += StringFormat::Fmt(" %s", ToStr::Get(mode.mode).c_str()); + retDisasm += StringFormat::Fmt(" %s", ToStr(mode.mode).c_str()); if(mode.mode == spv::ExecutionModeInvocations || mode.mode == spv::ExecutionModeOutputVertices) retDisasm += StringFormat::Fmt(" = %u", mode.x); if(mode.mode == spv::ExecutionModeLocalSize || mode.mode == spv::ExecutionModeLocalSizeHint) @@ -2308,7 +2305,7 @@ string SPVModule::Disassemble(const string &entryPoint) string varName = globals[i]->str; retDisasm += StringFormat::Fmt( - "%s %s;\n", ToStr::Get(globals[i]->var->storage).c_str(), + "%s %s;\n", ToStr(globals[i]->var->storage).c_str(), globals[i]->var->type->DeclareVariable(globals[i]->decorations, varName).c_str()); } @@ -4324,7 +4321,7 @@ void SPVModule::MakeReflection(ShaderStage stage, const string &entryPoint, } else { - RDCWARN("Unexpected storage class for global: %s", ToStr::Get(inst->var->storage).c_str()); + RDCWARN("Unexpected storage class for global: %s", ToStr(inst->var->storage).c_str()); } } @@ -5987,7 +5984,7 @@ void ParseSPIRV(uint32_t *spirv, size_t spirvLength, SPVModule &module) { // we should not crash if we don't recognise/handle an opcode - this may happen because of // extended SPIR-V or simply custom instructions we don't recognise. - RDCWARN("Unhandled opcode %s - result ID will be missing", ToStr::Get(op.opcode).c_str()); + RDCWARN("Unhandled opcode %s - result ID will be missing", ToStr(op.opcode).c_str()); if(curBlock) curBlock->instructions.push_back(&op); break; @@ -6112,901 +6109,3 @@ void ParseSPIRV(uint32_t *spirv, size_t spirvLength, SPVModule &module) std::sort(module.globals.begin(), module.globals.end(), SortByVarClass()); } - -template <> -string ToStrHelper::Get(const spv::Op &el) -{ - switch(el) - { - case spv::OpNop: return "Nop"; - case spv::OpUndef: return "Undef"; - case spv::OpSourceContinued: return "SourceContinued"; - case spv::OpSource: return "Source"; - case spv::OpSourceExtension: return "SourceExtension"; - case spv::OpName: return "Name"; - case spv::OpMemberName: return "MemberName"; - case spv::OpString: return "String"; - case spv::OpLine: return "Line"; - case spv::OpExtension: return "Extension"; - case spv::OpExtInstImport: return "ExtInstImport"; - case spv::OpExtInst: return "ExtInst"; - case spv::OpMemoryModel: return "MemoryModel"; - case spv::OpEntryPoint: return "EntryPoint"; - case spv::OpExecutionMode: return "ExecutionMode"; - case spv::OpCapability: return "Capability"; - case spv::OpTypeVoid: return "TypeVoid"; - case spv::OpTypeBool: return "TypeBool"; - case spv::OpTypeInt: return "TypeInt"; - case spv::OpTypeFloat: return "TypeFloat"; - case spv::OpTypeVector: return "TypeVector"; - case spv::OpTypeMatrix: return "TypeMatrix"; - case spv::OpTypeImage: return "TypeImage"; - case spv::OpTypeSampler: return "TypeSampler"; - case spv::OpTypeSampledImage: return "TypeSampledImage"; - case spv::OpTypeArray: return "TypeArray"; - case spv::OpTypeRuntimeArray: return "TypeRuntimeArray"; - case spv::OpTypeStruct: return "TypeStruct"; - case spv::OpTypeOpaque: return "TypeOpaque"; - case spv::OpTypePointer: return "TypePointer"; - case spv::OpTypeFunction: return "TypeFunction"; - case spv::OpTypeEvent: return "TypeEvent"; - case spv::OpTypeDeviceEvent: return "TypeDeviceEvent"; - case spv::OpTypeReserveId: return "TypeReserveId"; - case spv::OpTypeQueue: return "TypeQueue"; - case spv::OpTypePipe: return "TypePipe"; - case spv::OpTypeForwardPointer: return "TypeForwardPointer"; - case spv::OpConstantTrue: return "ConstantTrue"; - case spv::OpConstantFalse: return "ConstantFalse"; - case spv::OpConstant: return "Constant"; - case spv::OpConstantComposite: return "ConstantComposite"; - case spv::OpConstantSampler: return "ConstantSampler"; - case spv::OpConstantNull: return "ConstantNull"; - case spv::OpSpecConstantTrue: return "SpecConstantTrue"; - case spv::OpSpecConstantFalse: return "SpecConstantFalse"; - case spv::OpSpecConstant: return "SpecConstant"; - case spv::OpSpecConstantComposite: return "SpecConstantComposite"; - case spv::OpSpecConstantOp: return "SpecConstantOp"; - case spv::OpFunction: return "Function"; - case spv::OpFunctionParameter: return "FunctionParameter"; - case spv::OpFunctionEnd: return "FunctionEnd"; - case spv::OpFunctionCall: return "FunctionCall"; - case spv::OpVariable: return "Variable"; - case spv::OpImageTexelPointer: return "ImageTexelPointer"; - case spv::OpLoad: return "Load"; - case spv::OpStore: return "Store"; - case spv::OpCopyMemory: return "CopyMemory"; - case spv::OpCopyMemorySized: return "CopyMemorySized"; - case spv::OpAccessChain: return "AccessChain"; - case spv::OpInBoundsAccessChain: return "InBoundsAccessChain"; - case spv::OpPtrAccessChain: return "PtrAccessChain"; - case spv::OpArrayLength: return "ArrayLength"; - case spv::OpGenericPtrMemSemantics: return "GenericPtrMemSemantics"; - case spv::OpInBoundsPtrAccessChain: return "InBoundsPtrAccessChain"; - case spv::OpDecorate: return "Decorate"; - case spv::OpMemberDecorate: return "MemberDecorate"; - case spv::OpDecorationGroup: return "DecorationGroup"; - case spv::OpGroupDecorate: return "GroupDecorate"; - case spv::OpGroupMemberDecorate: return "GroupMemberDecorate"; - case spv::OpVectorExtractDynamic: return "VectorExtractDynamic"; - case spv::OpVectorInsertDynamic: return "VectorInsertDynamic"; - case spv::OpVectorShuffle: return "VectorShuffle"; - case spv::OpCompositeConstruct: return "CompositeConstruct"; - case spv::OpCompositeExtract: return "CompositeExtract"; - case spv::OpCompositeInsert: return "CompositeInsert"; - case spv::OpCopyObject: return "CopyObject"; - case spv::OpTranspose: return "Transpose"; - case spv::OpSampledImage: return "SampledImage"; - case spv::OpImageSampleImplicitLod: return "ImageSampleImplicitLod"; - case spv::OpImageSampleExplicitLod: return "ImageSampleExplicitLod"; - case spv::OpImageSampleDrefImplicitLod: return "ImageSampleDrefImplicitLod"; - case spv::OpImageSampleDrefExplicitLod: return "ImageSampleDrefExplicitLod"; - case spv::OpImageSampleProjImplicitLod: return "ImageSampleProjImplicitLod"; - case spv::OpImageSampleProjExplicitLod: return "ImageSampleProjExplicitLod"; - case spv::OpImageSampleProjDrefImplicitLod: return "ImageSampleProjDrefImplicitLod"; - case spv::OpImageSampleProjDrefExplicitLod: return "ImageSampleProjDrefExplicitLod"; - case spv::OpImageFetch: return "ImageFetch"; - case spv::OpImageGather: return "ImageGather"; - case spv::OpImageDrefGather: return "ImageDrefGather"; - case spv::OpImageRead: return "ImageRead"; - case spv::OpImageWrite: return "ImageWrite"; - case spv::OpImage: return "Image"; - case spv::OpImageQueryFormat: return "ImageQueryFormat"; - case spv::OpImageQueryOrder: return "ImageQueryOrder"; - case spv::OpImageQuerySizeLod: return "ImageQuerySizeLod"; - case spv::OpImageQuerySize: return "ImageQuerySize"; - case spv::OpImageQueryLod: return "ImageQueryLod"; - case spv::OpImageQueryLevels: return "ImageQueryLevels"; - case spv::OpImageQuerySamples: return "ImageQuerySamples"; - case spv::OpConvertFToU: return "ConvertFToU"; - case spv::OpConvertFToS: return "ConvertFToS"; - case spv::OpConvertSToF: return "ConvertSToF"; - case spv::OpConvertUToF: return "ConvertUToF"; - case spv::OpUConvert: return "UConvert"; - case spv::OpSConvert: return "SConvert"; - case spv::OpFConvert: return "FConvert"; - case spv::OpQuantizeToF16: return "QuantizeToF16"; - case spv::OpConvertPtrToU: return "ConvertPtrToU"; - case spv::OpSatConvertSToU: return "SatConvertSToU"; - case spv::OpSatConvertUToS: return "SatConvertUToS"; - case spv::OpConvertUToPtr: return "ConvertUToPtr"; - case spv::OpPtrCastToGeneric: return "PtrCastToGeneric"; - case spv::OpGenericCastToPtr: return "GenericCastToPtr"; - case spv::OpGenericCastToPtrExplicit: return "GenericCastToPtrExplicit"; - case spv::OpBitcast: return "Bitcast"; - case spv::OpSNegate: return "SNegate"; - case spv::OpFNegate: return "FNegate"; - case spv::OpIAdd: return "IAdd"; - case spv::OpFAdd: return "FAdd"; - case spv::OpISub: return "ISub"; - case spv::OpFSub: return "FSub"; - case spv::OpIMul: return "IMul"; - case spv::OpFMul: return "FMul"; - case spv::OpUDiv: return "UDiv"; - case spv::OpSDiv: return "SDiv"; - case spv::OpFDiv: return "FDiv"; - case spv::OpUMod: return "UMod"; - case spv::OpSRem: return "SRem"; - case spv::OpSMod: return "SMod"; - case spv::OpFRem: return "FRem"; - case spv::OpFMod: return "FMod"; - case spv::OpVectorTimesScalar: return "VectorTimesScalar"; - case spv::OpMatrixTimesScalar: return "MatrixTimesScalar"; - case spv::OpVectorTimesMatrix: return "VectorTimesMatrix"; - case spv::OpMatrixTimesVector: return "MatrixTimesVector"; - case spv::OpMatrixTimesMatrix: return "MatrixTimesMatrix"; - case spv::OpOuterProduct: return "OuterProduct"; - case spv::OpDot: return "Dot"; - case spv::OpIAddCarry: return "IAddCarry"; - case spv::OpISubBorrow: return "ISubBorrow"; - case spv::OpUMulExtended: return "UMulExtended"; - case spv::OpSMulExtended: return "SMulExtended"; - case spv::OpAny: return "Any"; - case spv::OpAll: return "All"; - case spv::OpIsNan: return "IsNan"; - case spv::OpIsInf: return "IsInf"; - case spv::OpIsFinite: return "IsFinite"; - case spv::OpIsNormal: return "IsNormal"; - case spv::OpSignBitSet: return "SignBitSet"; - case spv::OpLessOrGreater: return "LessOrGreater"; - case spv::OpOrdered: return "Ordered"; - case spv::OpUnordered: return "Unordered"; - case spv::OpLogicalEqual: return "LogicalEqual"; - case spv::OpLogicalNotEqual: return "LogicalNotEqual"; - case spv::OpLogicalOr: return "LogicalOr"; - case spv::OpLogicalAnd: return "LogicalAnd"; - case spv::OpLogicalNot: return "LogicalNot"; - case spv::OpSelect: return "Select"; - case spv::OpIEqual: return "IEqual"; - case spv::OpINotEqual: return "INotEqual"; - case spv::OpUGreaterThan: return "UGreaterThan"; - case spv::OpSGreaterThan: return "SGreaterThan"; - case spv::OpUGreaterThanEqual: return "UGreaterThanEqual"; - case spv::OpSGreaterThanEqual: return "SGreaterThanEqual"; - case spv::OpULessThan: return "ULessThan"; - case spv::OpSLessThan: return "SLessThan"; - case spv::OpULessThanEqual: return "ULessThanEqual"; - case spv::OpSLessThanEqual: return "SLessThanEqual"; - case spv::OpFOrdEqual: return "FOrdEqual"; - case spv::OpFUnordEqual: return "FUnordEqual"; - case spv::OpFOrdNotEqual: return "FOrdNotEqual"; - case spv::OpFUnordNotEqual: return "FUnordNotEqual"; - case spv::OpFOrdLessThan: return "FOrdLessThan"; - case spv::OpFUnordLessThan: return "FUnordLessThan"; - case spv::OpFOrdGreaterThan: return "FOrdGreaterThan"; - case spv::OpFUnordGreaterThan: return "FUnordGreaterThan"; - case spv::OpFOrdLessThanEqual: return "FOrdLessThanEqual"; - case spv::OpFUnordLessThanEqual: return "FUnordLessThanEqual"; - case spv::OpFOrdGreaterThanEqual: return "FOrdGreaterThanEqual"; - case spv::OpFUnordGreaterThanEqual: return "FUnordGreaterThanEqual"; - case spv::OpShiftRightLogical: return "ShiftRightLogical"; - case spv::OpShiftRightArithmetic: return "ShiftRightArithmetic"; - case spv::OpShiftLeftLogical: return "ShiftLeftLogical"; - case spv::OpBitwiseOr: return "BitwiseOr"; - case spv::OpBitwiseXor: return "BitwiseXor"; - case spv::OpBitwiseAnd: return "BitwiseAnd"; - case spv::OpNot: return "Not"; - case spv::OpBitFieldInsert: return "BitFieldInsert"; - case spv::OpBitFieldSExtract: return "BitFieldSExtract"; - case spv::OpBitFieldUExtract: return "BitFieldUExtract"; - case spv::OpBitReverse: return "BitReverse"; - case spv::OpBitCount: return "BitCount"; - case spv::OpDPdx: return "ddx"; - case spv::OpDPdy: return "ddy"; - case spv::OpFwidth: return "Fwidth"; - case spv::OpDPdxFine: return "ddx_fine"; - case spv::OpDPdyFine: return "ddy_fine"; - case spv::OpFwidthFine: return "Fwidth_fine"; - case spv::OpDPdxCoarse: return "ddx_coarse"; - case spv::OpDPdyCoarse: return "ddy_coarse"; - case spv::OpFwidthCoarse: return "Fwidth_coarse"; - case spv::OpEmitVertex: return "EmitVertex"; - case spv::OpEndPrimitive: return "EndPrimitive"; - case spv::OpEmitStreamVertex: return "EmitStreamVertex"; - case spv::OpEndStreamPrimitive: return "EndStreamPrimitive"; - case spv::OpControlBarrier: return "ControlBarrier"; - case spv::OpMemoryBarrier: return "MemoryBarrier"; - case spv::OpAtomicLoad: return "AtomicLoad"; - case spv::OpAtomicStore: return "AtomicStore"; - case spv::OpAtomicExchange: return "AtomicExchange"; - case spv::OpAtomicCompareExchange: return "AtomicCompareExchange"; - case spv::OpAtomicCompareExchangeWeak: return "AtomicCompareExchangeWeak"; - case spv::OpAtomicIIncrement: return "AtomicIIncrement"; - case spv::OpAtomicIDecrement: return "AtomicIDecrement"; - case spv::OpAtomicIAdd: return "AtomicIAdd"; - case spv::OpAtomicISub: return "AtomicISub"; - case spv::OpAtomicSMin: return "AtomicSMin"; - case spv::OpAtomicUMin: return "AtomicUMin"; - case spv::OpAtomicSMax: return "AtomicSMax"; - case spv::OpAtomicUMax: return "AtomicUMax"; - case spv::OpAtomicAnd: return "AtomicAnd"; - case spv::OpAtomicOr: return "AtomicOr"; - case spv::OpAtomicXor: return "AtomicXor"; - case spv::OpPhi: return "Phi"; - case spv::OpLoopMerge: return "LoopMerge"; - case spv::OpSelectionMerge: return "SelectionMerge"; - case spv::OpLabel: return "Label"; - case spv::OpBranch: return "Branch"; - case spv::OpBranchConditional: return "BranchConditional"; - case spv::OpSwitch: return "Switch"; - case spv::OpKill: return "Kill"; - case spv::OpReturn: return "Return"; - case spv::OpReturnValue: return "ReturnValue"; - case spv::OpUnreachable: return "Unreachable"; - case spv::OpLifetimeStart: return "LifetimeStart"; - case spv::OpLifetimeStop: return "LifetimeStop"; - case spv::OpGroupAsyncCopy: return "GroupAsyncCopy"; - case spv::OpGroupWaitEvents: return "GroupWaitEvents"; - case spv::OpGroupAll: return "GroupAll"; - case spv::OpGroupAny: return "GroupAny"; - case spv::OpGroupBroadcast: return "GroupBroadcast"; - case spv::OpGroupIAdd: return "GroupIAdd"; - case spv::OpGroupFAdd: return "GroupFAdd"; - case spv::OpGroupFMin: return "GroupFMin"; - case spv::OpGroupUMin: return "GroupUMin"; - case spv::OpGroupSMin: return "GroupSMin"; - case spv::OpGroupFMax: return "GroupFMax"; - case spv::OpGroupUMax: return "GroupUMax"; - case spv::OpGroupSMax: return "GroupSMax"; - case spv::OpReadPipe: return "ReadPipe"; - case spv::OpWritePipe: return "WritePipe"; - case spv::OpReservedReadPipe: return "ReservedReadPipe"; - case spv::OpReservedWritePipe: return "ReservedWritePipe"; - case spv::OpReserveReadPipePackets: return "ReserveReadPipePackets"; - case spv::OpReserveWritePipePackets: return "ReserveWritePipePackets"; - case spv::OpCommitReadPipe: return "CommitReadPipe"; - case spv::OpCommitWritePipe: return "CommitWritePipe"; - case spv::OpIsValidReserveId: return "IsValidReserveId"; - case spv::OpGetNumPipePackets: return "GetNumPipePackets"; - case spv::OpGetMaxPipePackets: return "GetMaxPipePackets"; - case spv::OpGroupReserveReadPipePackets: return "GroupReserveReadPipePackets"; - case spv::OpGroupReserveWritePipePackets: return "GroupReserveWritePipePackets"; - case spv::OpGroupCommitReadPipe: return "GroupCommitReadPipe"; - case spv::OpGroupCommitWritePipe: return "GroupCommitWritePipe"; - case spv::OpEnqueueMarker: return "EnqueueMarker"; - case spv::OpEnqueueKernel: return "EnqueueKernel"; - case spv::OpGetKernelNDrangeSubGroupCount: return "GetKernelNDrangeSubGroupCount"; - case spv::OpGetKernelNDrangeMaxSubGroupSize: return "GetKernelNDrangeMaxSubGroupSize"; - case spv::OpGetKernelWorkGroupSize: return "GetKernelWorkGroupSize"; - case spv::OpGetKernelPreferredWorkGroupSizeMultiple: - return "GetKernelPreferredWorkGroupSizeMultiple"; - case spv::OpRetainEvent: return "RetainEvent"; - case spv::OpReleaseEvent: return "ReleaseEvent"; - case spv::OpCreateUserEvent: return "CreateUserEvent"; - case spv::OpIsValidEvent: return "IsValidEvent"; - case spv::OpSetUserEventStatus: return "SetUserEventStatus"; - case spv::OpCaptureEventProfilingInfo: return "CaptureEventProfilingInfo"; - case spv::OpGetDefaultQueue: return "GetDefaultQueue"; - case spv::OpBuildNDRange: return "BuildNDRange"; - case spv::OpImageSparseSampleImplicitLod: return "ImageSparseSampleImplicitLod"; - case spv::OpImageSparseSampleExplicitLod: return "ImageSparseSampleExplicitLod"; - case spv::OpImageSparseSampleDrefImplicitLod: return "ImageSparseSampleDrefImplicitLod"; - case spv::OpImageSparseSampleDrefExplicitLod: return "ImageSparseSampleDrefExplicitLod"; - case spv::OpImageSparseSampleProjImplicitLod: return "ImageSparseSampleProjImplicitLod"; - case spv::OpImageSparseSampleProjExplicitLod: return "ImageSparseSampleProjExplicitLod"; - case spv::OpImageSparseSampleProjDrefImplicitLod: return "ImageSparseSampleProjDrefImplicitLod"; - case spv::OpImageSparseSampleProjDrefExplicitLod: return "ImageSparseSampleProjDrefExplicitLod"; - case spv::OpImageSparseFetch: return "ImageSparseFetch"; - case spv::OpImageSparseGather: return "ImageSparseGather"; - case spv::OpImageSparseDrefGather: return "ImageSparseDrefGather"; - case spv::OpImageSparseTexelsResident: return "ImageSparseTexelsResident"; - case spv::OpNoLine: return "NoLine"; - case spv::OpAtomicFlagTestAndSet: return "AtomicFlagTestAndSet"; - case spv::OpAtomicFlagClear: return "AtomicFlagClear"; - case spv::OpImageSparseRead: return "ImageSparseRead"; - case spv::OpSubgroupBallotKHR: return "ImageSparseRead"; - case spv::OpSubgroupFirstInvocationKHR: return "SubgroupFirstInvocationKHR"; - case spv::OpSubgroupAllKHR: return "SubgroupAllKHR"; - case spv::OpSubgroupAnyKHR: return "SubgroupAnyKHR"; - case spv::OpSubgroupAllEqualKHR: return "SubgroupAllEqualKHR"; - case spv::OpSubgroupReadInvocationKHR: return "SubgroupReadInvocationKHR"; - case spv::OpGroupIAddNonUniformAMD: return "GroupIAddNonUniformAMD"; - case spv::OpGroupFAddNonUniformAMD: return "GroupFAddNonUniformAMD"; - case spv::OpGroupFMinNonUniformAMD: return "GroupFMinNonUniformAMD"; - case spv::OpGroupUMinNonUniformAMD: return "GroupUMinNonUniformAMD"; - case spv::OpGroupSMinNonUniformAMD: return "GroupSMinNonUniformAMD"; - case spv::OpGroupFMaxNonUniformAMD: return "GroupFMaxNonUniformAMD"; - case spv::OpGroupUMaxNonUniformAMD: return "GroupUMaxNonUniformAMD"; - case spv::OpGroupSMaxNonUniformAMD: return "GroupSMaxNonUniformAMD"; - case spv::OpMax: break; - } - - // VS doesn't like case statements for values not declared in the original enum - switch((int)el) - { - case spv::OpGroupIAddNonUniformAMD: return "GroupIAddNonUniformAMD"; - case spv::OpGroupFAddNonUniformAMD: return "GroupFAddNonUniformAMD"; - case spv::OpGroupFMinNonUniformAMD: return "GroupFMinNonUniformAMD"; - case spv::OpGroupUMinNonUniformAMD: return "GroupUMinNonUniformAMD"; - case spv::OpGroupSMinNonUniformAMD: return "GroupSMinNonUniformAMD"; - case spv::OpGroupFMaxNonUniformAMD: return "GroupFMaxNonUniformAMD"; - case spv::OpGroupUMaxNonUniformAMD: return "GroupUMaxNonUniformAMD"; - case spv::OpGroupSMaxNonUniformAMD: return "GroupSMaxNonUniformAMD"; - default: break; - } - - return StringFormat::Fmt("UnrecognisedOp{%u}", (uint32_t)el); -} - -template <> -string ToStrHelper::Get(const spv::SourceLanguage &el) -{ - switch(el) - { - case spv::SourceLanguageUnknown: return "Unknown"; - case spv::SourceLanguageESSL: return "ESSL"; - case spv::SourceLanguageGLSL: return "GLSL"; - case spv::SourceLanguageOpenCL_C: return "OpenCL C"; - case spv::SourceLanguageOpenCL_CPP: return "OpenCL C++"; - case spv::SourceLanguageHLSL: return "HLSL"; - case spv::SourceLanguageMax: break; - } - - return StringFormat::Fmt("UnrecognisedLanguage{%u}", (uint32_t)el); -} - -template <> -string ToStrHelper::Get(const spv::Capability &el) -{ - switch(el) - { - case spv::CapabilityMatrix: return "Matrix"; - case spv::CapabilityShader: return "Shader"; - case spv::CapabilityGeometry: return "Geometry"; - case spv::CapabilityTessellation: return "Tessellation"; - case spv::CapabilityAddresses: return "Addresses"; - case spv::CapabilityLinkage: return "Linkage"; - case spv::CapabilityKernel: return "Kernel"; - case spv::CapabilityVector16: return "Vector16"; - case spv::CapabilityFloat16Buffer: return "Float16Buffer"; - case spv::CapabilityFloat16: return "Float16"; - case spv::CapabilityFloat64: return "Float64"; - case spv::CapabilityInt64: return "Int64"; - case spv::CapabilityInt64Atomics: return "Int64Atomics"; - case spv::CapabilityImageBasic: return "ImageBasic"; - case spv::CapabilityImageReadWrite: return "ImageReadWrite"; - case spv::CapabilityImageMipmap: return "ImageMipmap"; - case spv::CapabilityPipes: return "Pipes"; - case spv::CapabilityGroups: return "Groups"; - case spv::CapabilityDeviceEnqueue: return "DeviceEnqueue"; - case spv::CapabilityLiteralSampler: return "LiteralSampler"; - case spv::CapabilityAtomicStorage: return "AtomicStorage"; - case spv::CapabilityInt16: return "Int16"; - case spv::CapabilityTessellationPointSize: return "TessellationPointSize"; - case spv::CapabilityGeometryPointSize: return "GeometryPointSize"; - case spv::CapabilityImageGatherExtended: return "ImageGatherExtended"; - case spv::CapabilityStorageImageMultisample: return "StorageImageMultisample"; - case spv::CapabilityUniformBufferArrayDynamicIndexing: - return "UniformBufferArrayDynamicIndexing"; - case spv::CapabilitySampledImageArrayDynamicIndexing: return "SampledImageArrayDynamicIndexing"; - case spv::CapabilityStorageBufferArrayDynamicIndexing: - return "StorageBufferArrayDynamicIndexing"; - case spv::CapabilityStorageImageArrayDynamicIndexing: return "StorageImageArrayDynamicIndexing"; - case spv::CapabilityClipDistance: return "ClipDistance"; - case spv::CapabilityCullDistance: return "CullDistance"; - case spv::CapabilityImageCubeArray: return "ImageCubeArray"; - case spv::CapabilitySampleRateShading: return "SampleRateShading"; - case spv::CapabilityImageRect: return "ImageRect"; - case spv::CapabilitySampledRect: return "SampledRect"; - case spv::CapabilityGenericPointer: return "GenericPointer"; - case spv::CapabilityInt8: return "Int8"; - case spv::CapabilityInputAttachment: return "InputAttachment"; - case spv::CapabilitySparseResidency: return "SparseResidency"; - case spv::CapabilityMinLod: return "MinLod"; - case spv::CapabilitySampled1D: return "Sampled1D"; - case spv::CapabilityImage1D: return "Image1D"; - case spv::CapabilitySampledCubeArray: return "SampledCubeArray"; - case spv::CapabilitySampledBuffer: return "SampledBuffer"; - case spv::CapabilityImageBuffer: return "ImageBuffer"; - case spv::CapabilityImageMSArray: return "ImageMSArray"; - case spv::CapabilityStorageImageExtendedFormats: return "StorageImageExtendedFormats"; - case spv::CapabilityImageQuery: return "ImageQuery"; - case spv::CapabilityDerivativeControl: return "DerivativeControl"; - case spv::CapabilityInterpolationFunction: return "InterpolationFunction"; - case spv::CapabilityTransformFeedback: return "TransformFeedback"; - case spv::CapabilityGeometryStreams: return "GeometryStreams"; - case spv::CapabilityStorageImageReadWithoutFormat: return "StorageImageReadWithoutFormat"; - case spv::CapabilityStorageImageWriteWithoutFormat: return "StorageImageWriteWithoutFormat"; - case spv::CapabilityMultiViewport: return "MultiViewport"; - case spv::CapabilitySubgroupBallotKHR: return "SubgroupBallotKHR"; - case spv::CapabilityDrawParameters: return "DrawParameters"; - case spv::CapabilitySubgroupVoteKHR: return "SubgroupVoteKHR"; - case spv::CapabilityStorageUniformBufferBlock16: return "StorageUniformBufferBlock16"; - case spv::CapabilityStorageUniform16: return "StorageUniform16"; - case spv::CapabilityStoragePushConstant16: return "StoragePushConstant16"; - case spv::CapabilityStorageInputOutput16: return "StorageInputOutput16"; - case spv::CapabilityDeviceGroup: return "DeviceGroup"; - case spv::CapabilityMultiView: return "MultiView"; - case spv::CapabilityVariablePointersStorageBuffer: return "VariablePointersStorageBuffer"; - case spv::CapabilityVariablePointers: return "VariablePointers"; - case spv::CapabilityAtomicStorageOps: return "AtomicStorageOps"; - case spv::CapabilitySampleMaskPostDepthCoverage: return "SampleMaskPostDepthCoverage"; - case spv::CapabilityImageGatherBiasLodAMD: return "ImageGatherBiasLodAMD"; - case spv::CapabilityStencilExportEXT: return "StencilExportEXT"; - case spv::CapabilitySampleMaskOverrideCoverageNV: return "SampleMaskOverrideCoverageNV"; - case spv::CapabilityGeometryShaderPassthroughNV: return "GeometryShaderPassthroughNV"; - case spv::CapabilityShaderViewportIndexLayerNV: return "ShaderViewportIndexLayerNV"; - case spv::CapabilityShaderViewportMaskNV: return "ShaderViewportMaskNV"; - case spv::CapabilityShaderStereoViewNV: return "ShaderStereoViewNV"; - case spv::CapabilityPerViewAttributesNV: return "PerViewAttributesNV"; - case spv::CapabilityMax: break; - } - - return StringFormat::Fmt("UnrecognisedCap{%u}", (uint32_t)el); -} - -template <> -string ToStrHelper::Get(const spv::ExecutionMode &el) -{ - switch(el) - { - case spv::ExecutionModeInvocations: return "Invocations"; - case spv::ExecutionModeSpacingEqual: return "SpacingEqual"; - case spv::ExecutionModeSpacingFractionalEven: return "SpacingFractionalEven"; - case spv::ExecutionModeSpacingFractionalOdd: return "SpacingFractionalOdd"; - case spv::ExecutionModeVertexOrderCw: return "VertexOrderCw"; - case spv::ExecutionModeVertexOrderCcw: return "VertexOrderCcw"; - case spv::ExecutionModePixelCenterInteger: return "PixelCenterInteger"; - case spv::ExecutionModeOriginUpperLeft: return "OriginUpperLeft"; - case spv::ExecutionModeOriginLowerLeft: return "OriginLowerLeft"; - case spv::ExecutionModeEarlyFragmentTests: return "EarlyFragmentTests"; - case spv::ExecutionModePointMode: return "PointMode"; - case spv::ExecutionModeXfb: return "Xfb"; - case spv::ExecutionModeDepthReplacing: return "DepthReplacing"; - case spv::ExecutionModeDepthGreater: return "DepthGreater"; - case spv::ExecutionModeDepthLess: return "DepthLess"; - case spv::ExecutionModeDepthUnchanged: return "DepthUnchanged"; - case spv::ExecutionModeLocalSize: return "LocalSize"; - case spv::ExecutionModeLocalSizeHint: return "LocalSizeHint"; - case spv::ExecutionModeInputPoints: return "InputPoints"; - case spv::ExecutionModeInputLines: return "InputLines"; - case spv::ExecutionModeInputLinesAdjacency: return "InputLinesAdjacency"; - case spv::ExecutionModeTriangles: return "Triangles"; - case spv::ExecutionModeInputTrianglesAdjacency: return "InputTrianglesAdjacency"; - case spv::ExecutionModeQuads: return "Quads"; - case spv::ExecutionModeIsolines: return "Isolines"; - case spv::ExecutionModeOutputVertices: return "OutputVertices"; - case spv::ExecutionModeOutputPoints: return "OutputPoints"; - case spv::ExecutionModeOutputLineStrip: return "OutputLineStrip"; - case spv::ExecutionModeOutputTriangleStrip: return "OutputTriangleStrip"; - case spv::ExecutionModeVecTypeHint: return "VecTypeHint"; - case spv::ExecutionModeContractionOff: return "ContractionOff"; - case spv::ExecutionModePostDepthCoverage: return "PostDepthCoverage"; - case spv::ExecutionModeMax: break; - } - - return StringFormat::Fmt("UnrecognisedMode{%u}", (uint32_t)el); -} - -template <> -string ToStrHelper::Get(const spv::AddressingModel &el) -{ - switch(el) - { - case spv::AddressingModelLogical: return "Logical"; - case spv::AddressingModelPhysical32: return "Physical (32-bit)"; - case spv::AddressingModelPhysical64: return "Physical (64-bit)"; - case spv::AddressingModelMax: break; - } - - return StringFormat::Fmt("UnrecognisedModel{%u}", (uint32_t)el); -} - -template <> -string ToStrHelper::Get(const spv::MemoryModel &el) -{ - switch(el) - { - case spv::MemoryModelSimple: return "Simple"; - case spv::MemoryModelGLSL450: return "GLSL450"; - case spv::MemoryModelOpenCL: return "OpenCL"; - case spv::MemoryModelMax: break; - } - - return StringFormat::Fmt("UnrecognisedModel{%u}", (uint32_t)el); -} - -template <> -string ToStrHelper::Get(const spv::ExecutionModel &el) -{ - switch(el) - { - case spv::ExecutionModelVertex: return "Vertex Shader"; - case spv::ExecutionModelTessellationControl: return "Tess. Control Shader"; - case spv::ExecutionModelTessellationEvaluation: return "Tess. Eval Shader"; - case spv::ExecutionModelGeometry: return "Geometry Shader"; - case spv::ExecutionModelFragment: return "Fragment Shader"; - case spv::ExecutionModelGLCompute: return "Compute Shader"; - case spv::ExecutionModelKernel: return "Kernel"; - case spv::ExecutionModelMax: break; - } - - return StringFormat::Fmt("UnrecognisedModel{%u}", (uint32_t)el); -} - -template <> -string ToStrHelper::Get(const spv::Decoration &el) -{ - switch(el) - { - case spv::DecorationRelaxedPrecision: return "RelaxedPrecision"; - case spv::DecorationSpecId: return "SpecId"; - case spv::DecorationBlock: return "Block"; - case spv::DecorationBufferBlock: return "BufferBlock"; - case spv::DecorationRowMajor: return "RowMajor"; - case spv::DecorationColMajor: return "ColMajor"; - case spv::DecorationArrayStride: return "ArrayStride"; - case spv::DecorationMatrixStride: return "MatrixStride"; - case spv::DecorationGLSLShared: return "GLSLShared"; - case spv::DecorationGLSLPacked: return "GLSLPacked"; - case spv::DecorationCPacked: return "CPacked"; - case spv::DecorationBuiltIn: return "BuiltIn"; - case spv::DecorationNoPerspective: return "NoPerspective"; - case spv::DecorationFlat: return "Flat"; - case spv::DecorationPatch: return "Patch"; - case spv::DecorationCentroid: return "Centroid"; - case spv::DecorationSample: return "Sample"; - case spv::DecorationInvariant: return "Invariant"; - case spv::DecorationRestrict: return "Restrict"; - case spv::DecorationAliased: return "Aliased"; - case spv::DecorationVolatile: return "Volatile"; - case spv::DecorationConstant: return "Constant"; - case spv::DecorationCoherent: return "Coherent"; - case spv::DecorationNonWritable: return "NonWritable"; - case spv::DecorationNonReadable: return "NonReadable"; - case spv::DecorationUniform: return "Uniform"; - case spv::DecorationSaturatedConversion: return "SaturatedConversion"; - case spv::DecorationStream: return "Stream"; - case spv::DecorationLocation: return "Location"; - case spv::DecorationComponent: return "Component"; - case spv::DecorationIndex: return "Index"; - case spv::DecorationBinding: return "Binding"; - case spv::DecorationDescriptorSet: return "DescriptorSet"; - case spv::DecorationOffset: return "Offset"; - case spv::DecorationXfbBuffer: return "XfbBuffer"; - case spv::DecorationXfbStride: return "XfbStride"; - case spv::DecorationFuncParamAttr: return "FuncParamAttr"; - case spv::DecorationFPRoundingMode: return "FPRoundingMode"; - case spv::DecorationFPFastMathMode: return "FPFastMathMode"; - case spv::DecorationLinkageAttributes: return "LinkageAttributes"; - case spv::DecorationNoContraction: return "NoContraction"; - case spv::DecorationInputAttachmentIndex: return "InputAttachmentIndex"; - case spv::DecorationAlignment: return "Alignment"; - case spv::DecorationExplicitInterpAMD: return "ExplicitInterpAMD"; - case spv::DecorationOverrideCoverageNV: return "OverrideCoverageNV"; - case spv::DecorationPassthroughNV: return "PassthroughNV"; - case spv::DecorationViewportRelativeNV: return "ViewportRelativeNV"; - case spv::DecorationSecondaryViewportRelativeNV: return "SecondaryViewportRelativeNV"; - case spv::DecorationMax: break; - } - - // VS doesn't like case statements for values not declared in the original enum - switch((int)el) - { - case spv::DecorationExplicitInterpAMD: return "ExplicitInterpAMD"; - default: break; - } - - return StringFormat::Fmt("UnrecognisedDecoration{%u}", (uint32_t)el); -} - -template <> -string ToStrHelper::Get(const spv::Dim &el) -{ - switch(el) - { - case spv::Dim1D: return "1D"; - case spv::Dim2D: return "2D"; - case spv::Dim3D: return "3D"; - case spv::DimCube: return "Cube"; - case spv::DimRect: return "Rect"; - case spv::DimBuffer: return "Buffer"; - case spv::DimSubpassData: return "Subpass Data"; - case spv::DimMax: break; - } - - return StringFormat::Fmt("{%u}D", (uint32_t)el); -} - -template <> -string ToStrHelper::Get(const spv::StorageClass &el) -{ - switch(el) - { - case spv::StorageClassUniformConstant: return "UniformConstant"; - case spv::StorageClassInput: return "Input"; - case spv::StorageClassUniform: return "Uniform"; - case spv::StorageClassOutput: return "Output"; - case spv::StorageClassWorkgroup: return "Workgroup"; - case spv::StorageClassCrossWorkgroup: return "CrossWorkgroup"; - case spv::StorageClassPrivate: return "Private"; - case spv::StorageClassFunction: return "Function"; - case spv::StorageClassGeneric: return "Generic"; - case spv::StorageClassPushConstant: return "PushConstant"; - case spv::StorageClassAtomicCounter: return "AtomicCounter"; - case spv::StorageClassImage: return "Image"; - case spv::StorageClassStorageBuffer: return "StorageBuffer"; - case spv::StorageClassMax: break; - } - - return StringFormat::Fmt("UnrecognisedClass{%u}", (uint32_t)el); -} - -template <> -string ToStrHelper::Get(const spv::ImageFormat &el) -{ - switch(el) - { - case spv::ImageFormatUnknown: return "Unknown"; - case spv::ImageFormatRgba32f: return "RGBA32f"; - case spv::ImageFormatRgba16f: return "RGBA16f"; - case spv::ImageFormatR32f: return "R32f"; - case spv::ImageFormatRgba8: return "RGBA8"; - case spv::ImageFormatRgba8Snorm: return "RGBA8SNORM"; - case spv::ImageFormatRg32f: return "RG32F"; - case spv::ImageFormatRg16f: return "RG16F"; - case spv::ImageFormatR11fG11fB10f: return "R11FG11FB10F"; - case spv::ImageFormatR16f: return "R16F"; - case spv::ImageFormatRgba16: return "RGBA16"; - case spv::ImageFormatRgb10A2: return "RGB10A2"; - case spv::ImageFormatRg16: return "RG16"; - case spv::ImageFormatRg8: return "RG8"; - case spv::ImageFormatR16: return "R16"; - case spv::ImageFormatR8: return "R8"; - case spv::ImageFormatRgba16Snorm: return "RGBA16SNORM"; - case spv::ImageFormatRg16Snorm: return "RG16SNORM"; - case spv::ImageFormatRg8Snorm: return "RG8SNORM"; - case spv::ImageFormatR16Snorm: return "R16SNORM"; - case spv::ImageFormatR8Snorm: return "R8SNORM"; - case spv::ImageFormatRgba32i: return "RGBA32I"; - case spv::ImageFormatRgba16i: return "RGBA16I"; - case spv::ImageFormatRgba8i: return "RGBA8I"; - case spv::ImageFormatR32i: return "R32I"; - case spv::ImageFormatRg32i: return "RG32I"; - case spv::ImageFormatRg16i: return "RG16I"; - case spv::ImageFormatRg8i: return "RG8I"; - case spv::ImageFormatR16i: return "R16I"; - case spv::ImageFormatR8i: return "R8I"; - case spv::ImageFormatRgba32ui: return "RGBA32UI"; - case spv::ImageFormatRgba16ui: return "RGBA16UI"; - case spv::ImageFormatRgba8ui: return "RGBA8UI"; - case spv::ImageFormatR32ui: return "R32UI"; - case spv::ImageFormatRgb10a2ui: return "RGB10A2UI"; - case spv::ImageFormatRg32ui: return "RG32UI"; - case spv::ImageFormatRg16ui: return "RG16UI"; - case spv::ImageFormatRg8ui: return "RG8UI"; - case spv::ImageFormatR16ui: return "R16UI"; - case spv::ImageFormatR8ui: return "R8UI"; - case spv::ImageFormatMax: break; - } - - return StringFormat::Fmt("UnrecognisedFormat{%u}", (uint32_t)el); -} - -template <> -string ToStrHelper::Get(const spv::BuiltIn &el) -{ - switch(el) - { - case spv::BuiltInPosition: return "Position"; - case spv::BuiltInPointSize: return "PointSize"; - case spv::BuiltInClipDistance: return "ClipDistance"; - case spv::BuiltInCullDistance: return "CullDistance"; - case spv::BuiltInVertexId: return "VertexId"; - case spv::BuiltInInstanceId: return "InstanceId"; - case spv::BuiltInPrimitiveId: return "PrimitiveId"; - case spv::BuiltInInvocationId: return "InvocationId"; - case spv::BuiltInLayer: return "Layer"; - case spv::BuiltInViewportIndex: return "ViewportIndex"; - case spv::BuiltInTessLevelOuter: return "TessLevelOuter"; - case spv::BuiltInTessLevelInner: return "TessLevelInner"; - case spv::BuiltInTessCoord: return "TessCoord"; - case spv::BuiltInPatchVertices: return "PatchVertices"; - case spv::BuiltInFragCoord: return "FragCoord"; - case spv::BuiltInPointCoord: return "PointCoord"; - case spv::BuiltInFrontFacing: return "FrontFacing"; - case spv::BuiltInSampleId: return "SampleId"; - case spv::BuiltInSamplePosition: return "SamplePosition"; - case spv::BuiltInSampleMask: return "SampleMask"; - case spv::BuiltInFragDepth: return "FragDepth"; - case spv::BuiltInHelperInvocation: return "HelperInvocation"; - case spv::BuiltInNumWorkgroups: return "NumWorkgroups"; - case spv::BuiltInWorkgroupSize: return "WorkgroupSize"; - case spv::BuiltInWorkgroupId: return "WorkgroupId"; - case spv::BuiltInLocalInvocationId: return "LocalInvocationId"; - case spv::BuiltInGlobalInvocationId: return "GlobalInvocationId"; - case spv::BuiltInLocalInvocationIndex: return "LocalInvocationIndex"; - case spv::BuiltInWorkDim: return "WorkDim"; - case spv::BuiltInGlobalSize: return "GlobalSize"; - case spv::BuiltInEnqueuedWorkgroupSize: return "EnqueuedWorkgroupSize"; - case spv::BuiltInGlobalOffset: return "GlobalOffset"; - case spv::BuiltInGlobalLinearId: return "GlobalLinearId"; - case spv::BuiltInSubgroupSize: return "SubgroupSize"; - case spv::BuiltInSubgroupMaxSize: return "SubgroupMaxSize"; - case spv::BuiltInNumSubgroups: return "NumSubgroups"; - case spv::BuiltInNumEnqueuedSubgroups: return "NumEnqueuedSubgroups"; - case spv::BuiltInSubgroupId: return "SubgroupId"; - case spv::BuiltInSubgroupLocalInvocationId: return "SubgroupLocalInvocationId"; - case spv::BuiltInVertexIndex: return "VertexIndex"; - case spv::BuiltInInstanceIndex: return "InstanceIndex"; - case spv::BuiltInSubgroupEqMaskKHR: return "SubgroupEqMaskKHR"; - case spv::BuiltInSubgroupGeMaskKHR: return "SubgroupGeMaskKHR"; - case spv::BuiltInSubgroupGtMaskKHR: return "SubgroupGtMaskKHR"; - case spv::BuiltInSubgroupLeMaskKHR: return "SubgroupLeMaskKHR"; - case spv::BuiltInSubgroupLtMaskKHR: return "SubgroupLtMaskKHR"; - case spv::BuiltInBaseVertex: return "BaseVertex"; - case spv::BuiltInBaseInstance: return "BaseInstance"; - case spv::BuiltInDrawIndex: return "DrawIndex"; - case spv::BuiltInDeviceIndex: return "DeviceIndex"; - case spv::BuiltInViewIndex: return "ViewIndex"; - case spv::BuiltInBaryCoordNoPerspAMD: return "BaryCoordNoPerspAMD"; - case spv::BuiltInBaryCoordNoPerspCentroidAMD: return "BaryCoordNoPerspCentroidAMD"; - case spv::BuiltInBaryCoordNoPerspSampleAMD: return "BaryCoordNoPerspSampleAMD"; - case spv::BuiltInBaryCoordSmoothAMD: return "BaryCoordSmoothAMD"; - case spv::BuiltInBaryCoordSmoothCentroidAMD: return "BaryCoordSmoothCentroidAMD"; - case spv::BuiltInBaryCoordSmoothSampleAMD: return "BaryCoordSmoothSampleAMD"; - case spv::BuiltInBaryCoordPullModelAMD: return "BaryCoordPullModelAMD"; - case spv::BuiltInFragStencilRefEXT: return "FragStencilRefEXT"; - case spv::BuiltInViewportMaskNV: return "ViewportMaskNV"; - case spv::BuiltInSecondaryPositionNV: return "SecondaryPositionNV"; - case spv::BuiltInSecondaryViewportMaskNV: return "SecondaryViewportMaskNV"; - case spv::BuiltInPositionPerViewNV: return "PositionPerViewNV"; - case spv::BuiltInViewportMaskPerViewNV: return "ViewportMaskPerViewNV"; - case spv::BuiltInMax: break; - } - - // VS doesn't like case statements for values not declared in the original enum - switch((int)el) - { - case spv::BuiltInBaryCoordNoPerspAMD: return "BaryCoordNoPerspAMD"; - case spv::BuiltInBaryCoordNoPerspCentroidAMD: return "BaryCoordNoPerspCentroidAMD"; - case spv::BuiltInBaryCoordNoPerspSampleAMD: return "BaryCoordNoPerspSampleAMD"; - case spv::BuiltInBaryCoordSmoothAMD: return "BaryCoordSmoothAMD"; - case spv::BuiltInBaryCoordSmoothCentroidAMD: return "BaryCoordSmoothCentroidAMD"; - case spv::BuiltInBaryCoordSmoothSampleAMD: return "BaryCoordSmoothSampleAMD"; - case spv::BuiltInBaryCoordPullModelAMD: return "BaryCoordPullModelAMD"; - default: break; - } - - return StringFormat::Fmt("UnrecognisedBuiltIn{%u}", (uint32_t)el); -} - -template <> -string ToStrHelper::Get(const spv::Scope &el) -{ - switch(el) - { - case spv::ScopeCrossDevice: return "CrossDevice"; - case spv::ScopeDevice: return "Device"; - case spv::ScopeWorkgroup: return "Workgroup"; - case spv::ScopeSubgroup: return "Subgroup"; - case spv::ScopeInvocation: return "Invocation"; - case spv::ScopeMax: break; - } - - return StringFormat::Fmt("UnrecognisedScope{%u}", (uint32_t)el); -} - -template <> -string ToStrHelper::Get(const spv::FunctionControlMask &el) -{ - string ret; - - if(el & spv::FunctionControlInlineMask) - ret += ", Inline"; - if(el & spv::FunctionControlDontInlineMask) - ret += ", DontInline"; - if(el & spv::FunctionControlPureMask) - ret += ", Pure"; - if(el & spv::FunctionControlConstMask) - ret += ", Const"; - - if(!ret.empty()) - ret = ret.substr(2); - - return ret; -} - -template <> -string ToStrHelper::Get(const spv::SelectionControlMask &el) -{ - string ret; - - if(el & spv::SelectionControlFlattenMask) - ret += ", Flatten"; - if(el & spv::SelectionControlDontFlattenMask) - ret += ", DontFlatten"; - - if(!ret.empty()) - ret = ret.substr(2); - - return ret; -} - -template <> -string ToStrHelper::Get(const spv::LoopControlMask &el) -{ - string ret; - - if(el & spv::LoopControlUnrollMask) - ret += ", Unroll"; - if(el & spv::LoopControlDontUnrollMask) - ret += ", DontUnroll"; - - if(!ret.empty()) - ret = ret.substr(2); - - return ret; -} - -template <> -string ToStrHelper::Get(const spv::MemoryAccessMask &el) -{ - string ret; - - if(el & spv::MemoryAccessVolatileMask) - ret += ", Volatile"; - if(el & spv::MemoryAccessAlignedMask) - ret += ", Aligned"; - if(el & spv::MemoryAccessNontemporalMask) - ret += ", Nontemporal"; - - if(!ret.empty()) - ret = ret.substr(2); - - return ret; -} - -template <> -string ToStrHelper::Get(const spv::MemorySemanticsMask &el) -{ - string ret; - - if(el == spv::MemorySemanticsMaskNone) - return "None"; - - if(el & spv::MemorySemanticsAcquireMask) - ret += ", Acquire"; - if(el & spv::MemorySemanticsReleaseMask) - ret += ", Release"; - if(el & spv::MemorySemanticsAcquireReleaseMask) - ret += ", Acquire/Release"; - if(el & spv::MemorySemanticsSequentiallyConsistentMask) - ret += ", Sequentially Consistent"; - if(el & spv::MemorySemanticsUniformMemoryMask) - ret += ", Uniform Memory"; - if(el & spv::MemorySemanticsSubgroupMemoryMask) - ret += ", Subgroup Memory"; - if(el & spv::MemorySemanticsWorkgroupMemoryMask) - ret += ", Workgroup Memory"; - if(el & spv::MemorySemanticsCrossWorkgroupMemoryMask) - ret += ", Cross Workgroup Memory"; - if(el & spv::MemorySemanticsAtomicCounterMemoryMask) - ret += ", Atomic Counter Memory"; - if(el & spv::MemorySemanticsImageMemoryMask) - ret += ", Image Memory"; - - if(!ret.empty()) - ret = ret.substr(2); - - return ret; -} diff --git a/renderdoc/driver/shaders/spirv/spirv_stringise.cpp b/renderdoc/driver/shaders/spirv/spirv_stringise.cpp new file mode 100644 index 000000000..344f57abb --- /dev/null +++ b/renderdoc/driver/shaders/spirv/spirv_stringise.cpp @@ -0,0 +1,857 @@ +/****************************************************************************** + * The MIT License (MIT) + * + * Copyright (c) 2015-2017 Baldur Karlsson + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ + +#include "3rdparty/glslang/SPIRV/spirv.hpp" +#include "api/replay/renderdoc_replay.h" +#include "common/common.h" + +template <> +std::string DoStringise(const spv::Op &el) +{ + switch(el) + { + case spv::OpNop: return "Nop"; + case spv::OpUndef: return "Undef"; + case spv::OpSourceContinued: return "SourceContinued"; + case spv::OpSource: return "Source"; + case spv::OpSourceExtension: return "SourceExtension"; + case spv::OpName: return "Name"; + case spv::OpMemberName: return "MemberName"; + case spv::OpString: return "String"; + case spv::OpLine: return "Line"; + case spv::OpExtension: return "Extension"; + case spv::OpExtInstImport: return "ExtInstImport"; + case spv::OpExtInst: return "ExtInst"; + case spv::OpMemoryModel: return "MemoryModel"; + case spv::OpEntryPoint: return "EntryPoint"; + case spv::OpExecutionMode: return "ExecutionMode"; + case spv::OpCapability: return "Capability"; + case spv::OpTypeVoid: return "TypeVoid"; + case spv::OpTypeBool: return "TypeBool"; + case spv::OpTypeInt: return "TypeInt"; + case spv::OpTypeFloat: return "TypeFloat"; + case spv::OpTypeVector: return "TypeVector"; + case spv::OpTypeMatrix: return "TypeMatrix"; + case spv::OpTypeImage: return "TypeImage"; + case spv::OpTypeSampler: return "TypeSampler"; + case spv::OpTypeSampledImage: return "TypeSampledImage"; + case spv::OpTypeArray: return "TypeArray"; + case spv::OpTypeRuntimeArray: return "TypeRuntimeArray"; + case spv::OpTypeStruct: return "TypeStruct"; + case spv::OpTypeOpaque: return "TypeOpaque"; + case spv::OpTypePointer: return "TypePointer"; + case spv::OpTypeFunction: return "TypeFunction"; + case spv::OpTypeEvent: return "TypeEvent"; + case spv::OpTypeDeviceEvent: return "TypeDeviceEvent"; + case spv::OpTypeReserveId: return "TypeReserveId"; + case spv::OpTypeQueue: return "TypeQueue"; + case spv::OpTypePipe: return "TypePipe"; + case spv::OpTypeForwardPointer: return "TypeForwardPointer"; + case spv::OpConstantTrue: return "ConstantTrue"; + case spv::OpConstantFalse: return "ConstantFalse"; + case spv::OpConstant: return "Constant"; + case spv::OpConstantComposite: return "ConstantComposite"; + case spv::OpConstantSampler: return "ConstantSampler"; + case spv::OpConstantNull: return "ConstantNull"; + case spv::OpSpecConstantTrue: return "SpecConstantTrue"; + case spv::OpSpecConstantFalse: return "SpecConstantFalse"; + case spv::OpSpecConstant: return "SpecConstant"; + case spv::OpSpecConstantComposite: return "SpecConstantComposite"; + case spv::OpSpecConstantOp: return "SpecConstantOp"; + case spv::OpFunction: return "Function"; + case spv::OpFunctionParameter: return "FunctionParameter"; + case spv::OpFunctionEnd: return "FunctionEnd"; + case spv::OpFunctionCall: return "FunctionCall"; + case spv::OpVariable: return "Variable"; + case spv::OpImageTexelPointer: return "ImageTexelPointer"; + case spv::OpLoad: return "Load"; + case spv::OpStore: return "Store"; + case spv::OpCopyMemory: return "CopyMemory"; + case spv::OpCopyMemorySized: return "CopyMemorySized"; + case spv::OpAccessChain: return "AccessChain"; + case spv::OpInBoundsAccessChain: return "InBoundsAccessChain"; + case spv::OpPtrAccessChain: return "PtrAccessChain"; + case spv::OpArrayLength: return "ArrayLength"; + case spv::OpGenericPtrMemSemantics: return "GenericPtrMemSemantics"; + case spv::OpInBoundsPtrAccessChain: return "InBoundsPtrAccessChain"; + case spv::OpDecorate: return "Decorate"; + case spv::OpMemberDecorate: return "MemberDecorate"; + case spv::OpDecorationGroup: return "DecorationGroup"; + case spv::OpGroupDecorate: return "GroupDecorate"; + case spv::OpGroupMemberDecorate: return "GroupMemberDecorate"; + case spv::OpVectorExtractDynamic: return "VectorExtractDynamic"; + case spv::OpVectorInsertDynamic: return "VectorInsertDynamic"; + case spv::OpVectorShuffle: return "VectorShuffle"; + case spv::OpCompositeConstruct: return "CompositeConstruct"; + case spv::OpCompositeExtract: return "CompositeExtract"; + case spv::OpCompositeInsert: return "CompositeInsert"; + case spv::OpCopyObject: return "CopyObject"; + case spv::OpTranspose: return "Transpose"; + case spv::OpSampledImage: return "SampledImage"; + case spv::OpImageSampleImplicitLod: return "ImageSampleImplicitLod"; + case spv::OpImageSampleExplicitLod: return "ImageSampleExplicitLod"; + case spv::OpImageSampleDrefImplicitLod: return "ImageSampleDrefImplicitLod"; + case spv::OpImageSampleDrefExplicitLod: return "ImageSampleDrefExplicitLod"; + case spv::OpImageSampleProjImplicitLod: return "ImageSampleProjImplicitLod"; + case spv::OpImageSampleProjExplicitLod: return "ImageSampleProjExplicitLod"; + case spv::OpImageSampleProjDrefImplicitLod: return "ImageSampleProjDrefImplicitLod"; + case spv::OpImageSampleProjDrefExplicitLod: return "ImageSampleProjDrefExplicitLod"; + case spv::OpImageFetch: return "ImageFetch"; + case spv::OpImageGather: return "ImageGather"; + case spv::OpImageDrefGather: return "ImageDrefGather"; + case spv::OpImageRead: return "ImageRead"; + case spv::OpImageWrite: return "ImageWrite"; + case spv::OpImage: return "Image"; + case spv::OpImageQueryFormat: return "ImageQueryFormat"; + case spv::OpImageQueryOrder: return "ImageQueryOrder"; + case spv::OpImageQuerySizeLod: return "ImageQuerySizeLod"; + case spv::OpImageQuerySize: return "ImageQuerySize"; + case spv::OpImageQueryLod: return "ImageQueryLod"; + case spv::OpImageQueryLevels: return "ImageQueryLevels"; + case spv::OpImageQuerySamples: return "ImageQuerySamples"; + case spv::OpConvertFToU: return "ConvertFToU"; + case spv::OpConvertFToS: return "ConvertFToS"; + case spv::OpConvertSToF: return "ConvertSToF"; + case spv::OpConvertUToF: return "ConvertUToF"; + case spv::OpUConvert: return "UConvert"; + case spv::OpSConvert: return "SConvert"; + case spv::OpFConvert: return "FConvert"; + case spv::OpQuantizeToF16: return "QuantizeToF16"; + case spv::OpConvertPtrToU: return "ConvertPtrToU"; + case spv::OpSatConvertSToU: return "SatConvertSToU"; + case spv::OpSatConvertUToS: return "SatConvertUToS"; + case spv::OpConvertUToPtr: return "ConvertUToPtr"; + case spv::OpPtrCastToGeneric: return "PtrCastToGeneric"; + case spv::OpGenericCastToPtr: return "GenericCastToPtr"; + case spv::OpGenericCastToPtrExplicit: return "GenericCastToPtrExplicit"; + case spv::OpBitcast: return "Bitcast"; + case spv::OpSNegate: return "SNegate"; + case spv::OpFNegate: return "FNegate"; + case spv::OpIAdd: return "IAdd"; + case spv::OpFAdd: return "FAdd"; + case spv::OpISub: return "ISub"; + case spv::OpFSub: return "FSub"; + case spv::OpIMul: return "IMul"; + case spv::OpFMul: return "FMul"; + case spv::OpUDiv: return "UDiv"; + case spv::OpSDiv: return "SDiv"; + case spv::OpFDiv: return "FDiv"; + case spv::OpUMod: return "UMod"; + case spv::OpSRem: return "SRem"; + case spv::OpSMod: return "SMod"; + case spv::OpFRem: return "FRem"; + case spv::OpFMod: return "FMod"; + case spv::OpVectorTimesScalar: return "VectorTimesScalar"; + case spv::OpMatrixTimesScalar: return "MatrixTimesScalar"; + case spv::OpVectorTimesMatrix: return "VectorTimesMatrix"; + case spv::OpMatrixTimesVector: return "MatrixTimesVector"; + case spv::OpMatrixTimesMatrix: return "MatrixTimesMatrix"; + case spv::OpOuterProduct: return "OuterProduct"; + case spv::OpDot: return "Dot"; + case spv::OpIAddCarry: return "IAddCarry"; + case spv::OpISubBorrow: return "ISubBorrow"; + case spv::OpUMulExtended: return "UMulExtended"; + case spv::OpSMulExtended: return "SMulExtended"; + case spv::OpAny: return "Any"; + case spv::OpAll: return "All"; + case spv::OpIsNan: return "IsNan"; + case spv::OpIsInf: return "IsInf"; + case spv::OpIsFinite: return "IsFinite"; + case spv::OpIsNormal: return "IsNormal"; + case spv::OpSignBitSet: return "SignBitSet"; + case spv::OpLessOrGreater: return "LessOrGreater"; + case spv::OpOrdered: return "Ordered"; + case spv::OpUnordered: return "Unordered"; + case spv::OpLogicalEqual: return "LogicalEqual"; + case spv::OpLogicalNotEqual: return "LogicalNotEqual"; + case spv::OpLogicalOr: return "LogicalOr"; + case spv::OpLogicalAnd: return "LogicalAnd"; + case spv::OpLogicalNot: return "LogicalNot"; + case spv::OpSelect: return "Select"; + case spv::OpIEqual: return "IEqual"; + case spv::OpINotEqual: return "INotEqual"; + case spv::OpUGreaterThan: return "UGreaterThan"; + case spv::OpSGreaterThan: return "SGreaterThan"; + case spv::OpUGreaterThanEqual: return "UGreaterThanEqual"; + case spv::OpSGreaterThanEqual: return "SGreaterThanEqual"; + case spv::OpULessThan: return "ULessThan"; + case spv::OpSLessThan: return "SLessThan"; + case spv::OpULessThanEqual: return "ULessThanEqual"; + case spv::OpSLessThanEqual: return "SLessThanEqual"; + case spv::OpFOrdEqual: return "FOrdEqual"; + case spv::OpFUnordEqual: return "FUnordEqual"; + case spv::OpFOrdNotEqual: return "FOrdNotEqual"; + case spv::OpFUnordNotEqual: return "FUnordNotEqual"; + case spv::OpFOrdLessThan: return "FOrdLessThan"; + case spv::OpFUnordLessThan: return "FUnordLessThan"; + case spv::OpFOrdGreaterThan: return "FOrdGreaterThan"; + case spv::OpFUnordGreaterThan: return "FUnordGreaterThan"; + case spv::OpFOrdLessThanEqual: return "FOrdLessThanEqual"; + case spv::OpFUnordLessThanEqual: return "FUnordLessThanEqual"; + case spv::OpFOrdGreaterThanEqual: return "FOrdGreaterThanEqual"; + case spv::OpFUnordGreaterThanEqual: return "FUnordGreaterThanEqual"; + case spv::OpShiftRightLogical: return "ShiftRightLogical"; + case spv::OpShiftRightArithmetic: return "ShiftRightArithmetic"; + case spv::OpShiftLeftLogical: return "ShiftLeftLogical"; + case spv::OpBitwiseOr: return "BitwiseOr"; + case spv::OpBitwiseXor: return "BitwiseXor"; + case spv::OpBitwiseAnd: return "BitwiseAnd"; + case spv::OpNot: return "Not"; + case spv::OpBitFieldInsert: return "BitFieldInsert"; + case spv::OpBitFieldSExtract: return "BitFieldSExtract"; + case spv::OpBitFieldUExtract: return "BitFieldUExtract"; + case spv::OpBitReverse: return "BitReverse"; + case spv::OpBitCount: return "BitCount"; + case spv::OpDPdx: return "ddx"; + case spv::OpDPdy: return "ddy"; + case spv::OpFwidth: return "Fwidth"; + case spv::OpDPdxFine: return "ddx_fine"; + case spv::OpDPdyFine: return "ddy_fine"; + case spv::OpFwidthFine: return "Fwidth_fine"; + case spv::OpDPdxCoarse: return "ddx_coarse"; + case spv::OpDPdyCoarse: return "ddy_coarse"; + case spv::OpFwidthCoarse: return "Fwidth_coarse"; + case spv::OpEmitVertex: return "EmitVertex"; + case spv::OpEndPrimitive: return "EndPrimitive"; + case spv::OpEmitStreamVertex: return "EmitStreamVertex"; + case spv::OpEndStreamPrimitive: return "EndStreamPrimitive"; + case spv::OpControlBarrier: return "ControlBarrier"; + case spv::OpMemoryBarrier: return "MemoryBarrier"; + case spv::OpAtomicLoad: return "AtomicLoad"; + case spv::OpAtomicStore: return "AtomicStore"; + case spv::OpAtomicExchange: return "AtomicExchange"; + case spv::OpAtomicCompareExchange: return "AtomicCompareExchange"; + case spv::OpAtomicCompareExchangeWeak: return "AtomicCompareExchangeWeak"; + case spv::OpAtomicIIncrement: return "AtomicIIncrement"; + case spv::OpAtomicIDecrement: return "AtomicIDecrement"; + case spv::OpAtomicIAdd: return "AtomicIAdd"; + case spv::OpAtomicISub: return "AtomicISub"; + case spv::OpAtomicSMin: return "AtomicSMin"; + case spv::OpAtomicUMin: return "AtomicUMin"; + case spv::OpAtomicSMax: return "AtomicSMax"; + case spv::OpAtomicUMax: return "AtomicUMax"; + case spv::OpAtomicAnd: return "AtomicAnd"; + case spv::OpAtomicOr: return "AtomicOr"; + case spv::OpAtomicXor: return "AtomicXor"; + case spv::OpPhi: return "Phi"; + case spv::OpLoopMerge: return "LoopMerge"; + case spv::OpSelectionMerge: return "SelectionMerge"; + case spv::OpLabel: return "Label"; + case spv::OpBranch: return "Branch"; + case spv::OpBranchConditional: return "BranchConditional"; + case spv::OpSwitch: return "Switch"; + case spv::OpKill: return "Kill"; + case spv::OpReturn: return "Return"; + case spv::OpReturnValue: return "ReturnValue"; + case spv::OpUnreachable: return "Unreachable"; + case spv::OpLifetimeStart: return "LifetimeStart"; + case spv::OpLifetimeStop: return "LifetimeStop"; + case spv::OpGroupAsyncCopy: return "GroupAsyncCopy"; + case spv::OpGroupWaitEvents: return "GroupWaitEvents"; + case spv::OpGroupAll: return "GroupAll"; + case spv::OpGroupAny: return "GroupAny"; + case spv::OpGroupBroadcast: return "GroupBroadcast"; + case spv::OpGroupIAdd: return "GroupIAdd"; + case spv::OpGroupFAdd: return "GroupFAdd"; + case spv::OpGroupFMin: return "GroupFMin"; + case spv::OpGroupUMin: return "GroupUMin"; + case spv::OpGroupSMin: return "GroupSMin"; + case spv::OpGroupFMax: return "GroupFMax"; + case spv::OpGroupUMax: return "GroupUMax"; + case spv::OpGroupSMax: return "GroupSMax"; + case spv::OpReadPipe: return "ReadPipe"; + case spv::OpWritePipe: return "WritePipe"; + case spv::OpReservedReadPipe: return "ReservedReadPipe"; + case spv::OpReservedWritePipe: return "ReservedWritePipe"; + case spv::OpReserveReadPipePackets: return "ReserveReadPipePackets"; + case spv::OpReserveWritePipePackets: return "ReserveWritePipePackets"; + case spv::OpCommitReadPipe: return "CommitReadPipe"; + case spv::OpCommitWritePipe: return "CommitWritePipe"; + case spv::OpIsValidReserveId: return "IsValidReserveId"; + case spv::OpGetNumPipePackets: return "GetNumPipePackets"; + case spv::OpGetMaxPipePackets: return "GetMaxPipePackets"; + case spv::OpGroupReserveReadPipePackets: return "GroupReserveReadPipePackets"; + case spv::OpGroupReserveWritePipePackets: return "GroupReserveWritePipePackets"; + case spv::OpGroupCommitReadPipe: return "GroupCommitReadPipe"; + case spv::OpGroupCommitWritePipe: return "GroupCommitWritePipe"; + case spv::OpEnqueueMarker: return "EnqueueMarker"; + case spv::OpEnqueueKernel: return "EnqueueKernel"; + case spv::OpGetKernelNDrangeSubGroupCount: return "GetKernelNDrangeSubGroupCount"; + case spv::OpGetKernelNDrangeMaxSubGroupSize: return "GetKernelNDrangeMaxSubGroupSize"; + case spv::OpGetKernelWorkGroupSize: return "GetKernelWorkGroupSize"; + case spv::OpGetKernelPreferredWorkGroupSizeMultiple: + return "GetKernelPreferredWorkGroupSizeMultiple"; + case spv::OpRetainEvent: return "RetainEvent"; + case spv::OpReleaseEvent: return "ReleaseEvent"; + case spv::OpCreateUserEvent: return "CreateUserEvent"; + case spv::OpIsValidEvent: return "IsValidEvent"; + case spv::OpSetUserEventStatus: return "SetUserEventStatus"; + case spv::OpCaptureEventProfilingInfo: return "CaptureEventProfilingInfo"; + case spv::OpGetDefaultQueue: return "GetDefaultQueue"; + case spv::OpBuildNDRange: return "BuildNDRange"; + case spv::OpImageSparseSampleImplicitLod: return "ImageSparseSampleImplicitLod"; + case spv::OpImageSparseSampleExplicitLod: return "ImageSparseSampleExplicitLod"; + case spv::OpImageSparseSampleDrefImplicitLod: return "ImageSparseSampleDrefImplicitLod"; + case spv::OpImageSparseSampleDrefExplicitLod: return "ImageSparseSampleDrefExplicitLod"; + case spv::OpImageSparseSampleProjImplicitLod: return "ImageSparseSampleProjImplicitLod"; + case spv::OpImageSparseSampleProjExplicitLod: return "ImageSparseSampleProjExplicitLod"; + case spv::OpImageSparseSampleProjDrefImplicitLod: return "ImageSparseSampleProjDrefImplicitLod"; + case spv::OpImageSparseSampleProjDrefExplicitLod: return "ImageSparseSampleProjDrefExplicitLod"; + case spv::OpImageSparseFetch: return "ImageSparseFetch"; + case spv::OpImageSparseGather: return "ImageSparseGather"; + case spv::OpImageSparseDrefGather: return "ImageSparseDrefGather"; + case spv::OpImageSparseTexelsResident: return "ImageSparseTexelsResident"; + case spv::OpNoLine: return "NoLine"; + case spv::OpAtomicFlagTestAndSet: return "AtomicFlagTestAndSet"; + case spv::OpAtomicFlagClear: return "AtomicFlagClear"; + case spv::OpImageSparseRead: return "ImageSparseRead"; + case spv::OpSubgroupBallotKHR: return "ImageSparseRead"; + case spv::OpSubgroupFirstInvocationKHR: return "SubgroupFirstInvocationKHR"; + case spv::OpSubgroupAllKHR: return "SubgroupAllKHR"; + case spv::OpSubgroupAnyKHR: return "SubgroupAnyKHR"; + case spv::OpSubgroupAllEqualKHR: return "SubgroupAllEqualKHR"; + case spv::OpSubgroupReadInvocationKHR: return "SubgroupReadInvocationKHR"; + case spv::OpGroupIAddNonUniformAMD: return "GroupIAddNonUniformAMD"; + case spv::OpGroupFAddNonUniformAMD: return "GroupFAddNonUniformAMD"; + case spv::OpGroupFMinNonUniformAMD: return "GroupFMinNonUniformAMD"; + case spv::OpGroupUMinNonUniformAMD: return "GroupUMinNonUniformAMD"; + case spv::OpGroupSMinNonUniformAMD: return "GroupSMinNonUniformAMD"; + case spv::OpGroupFMaxNonUniformAMD: return "GroupFMaxNonUniformAMD"; + case spv::OpGroupUMaxNonUniformAMD: return "GroupUMaxNonUniformAMD"; + case spv::OpGroupSMaxNonUniformAMD: return "GroupSMaxNonUniformAMD"; + case spv::OpMax: break; + } + + return StringFormat::Fmt("UnrecognisedOp{%u}", (uint32_t)el); +} + +template <> +std::string DoStringise(const spv::SourceLanguage &el) +{ + switch(el) + { + case spv::SourceLanguageUnknown: return "Unknown"; + case spv::SourceLanguageESSL: return "ESSL"; + case spv::SourceLanguageGLSL: return "GLSL"; + case spv::SourceLanguageOpenCL_C: return "OpenCL C"; + case spv::SourceLanguageOpenCL_CPP: return "OpenCL C++"; + case spv::SourceLanguageHLSL: return "HLSL"; + case spv::SourceLanguageMax: break; + } + + return StringFormat::Fmt("UnrecognisedLanguage{%u}", (uint32_t)el); +} + +template <> +std::string DoStringise(const spv::Capability &el) +{ + switch(el) + { + case spv::CapabilityMatrix: return "Matrix"; + case spv::CapabilityShader: return "Shader"; + case spv::CapabilityGeometry: return "Geometry"; + case spv::CapabilityTessellation: return "Tessellation"; + case spv::CapabilityAddresses: return "Addresses"; + case spv::CapabilityLinkage: return "Linkage"; + case spv::CapabilityKernel: return "Kernel"; + case spv::CapabilityVector16: return "Vector16"; + case spv::CapabilityFloat16Buffer: return "Float16Buffer"; + case spv::CapabilityFloat16: return "Float16"; + case spv::CapabilityFloat64: return "Float64"; + case spv::CapabilityInt64: return "Int64"; + case spv::CapabilityInt64Atomics: return "Int64Atomics"; + case spv::CapabilityImageBasic: return "ImageBasic"; + case spv::CapabilityImageReadWrite: return "ImageReadWrite"; + case spv::CapabilityImageMipmap: return "ImageMipmap"; + case spv::CapabilityPipes: return "Pipes"; + case spv::CapabilityGroups: return "Groups"; + case spv::CapabilityDeviceEnqueue: return "DeviceEnqueue"; + case spv::CapabilityLiteralSampler: return "LiteralSampler"; + case spv::CapabilityAtomicStorage: return "AtomicStorage"; + case spv::CapabilityInt16: return "Int16"; + case spv::CapabilityTessellationPointSize: return "TessellationPointSize"; + case spv::CapabilityGeometryPointSize: return "GeometryPointSize"; + case spv::CapabilityImageGatherExtended: return "ImageGatherExtended"; + case spv::CapabilityStorageImageMultisample: return "StorageImageMultisample"; + case spv::CapabilityUniformBufferArrayDynamicIndexing: + return "UniformBufferArrayDynamicIndexing"; + case spv::CapabilitySampledImageArrayDynamicIndexing: return "SampledImageArrayDynamicIndexing"; + case spv::CapabilityStorageBufferArrayDynamicIndexing: + return "StorageBufferArrayDynamicIndexing"; + case spv::CapabilityStorageImageArrayDynamicIndexing: return "StorageImageArrayDynamicIndexing"; + case spv::CapabilityClipDistance: return "ClipDistance"; + case spv::CapabilityCullDistance: return "CullDistance"; + case spv::CapabilityImageCubeArray: return "ImageCubeArray"; + case spv::CapabilitySampleRateShading: return "SampleRateShading"; + case spv::CapabilityImageRect: return "ImageRect"; + case spv::CapabilitySampledRect: return "SampledRect"; + case spv::CapabilityGenericPointer: return "GenericPointer"; + case spv::CapabilityInt8: return "Int8"; + case spv::CapabilityInputAttachment: return "InputAttachment"; + case spv::CapabilitySparseResidency: return "SparseResidency"; + case spv::CapabilityMinLod: return "MinLod"; + case spv::CapabilitySampled1D: return "Sampled1D"; + case spv::CapabilityImage1D: return "Image1D"; + case spv::CapabilitySampledCubeArray: return "SampledCubeArray"; + case spv::CapabilitySampledBuffer: return "SampledBuffer"; + case spv::CapabilityImageBuffer: return "ImageBuffer"; + case spv::CapabilityImageMSArray: return "ImageMSArray"; + case spv::CapabilityStorageImageExtendedFormats: return "StorageImageExtendedFormats"; + case spv::CapabilityImageQuery: return "ImageQuery"; + case spv::CapabilityDerivativeControl: return "DerivativeControl"; + case spv::CapabilityInterpolationFunction: return "InterpolationFunction"; + case spv::CapabilityTransformFeedback: return "TransformFeedback"; + case spv::CapabilityGeometryStreams: return "GeometryStreams"; + case spv::CapabilityStorageImageReadWithoutFormat: return "StorageImageReadWithoutFormat"; + case spv::CapabilityStorageImageWriteWithoutFormat: return "StorageImageWriteWithoutFormat"; + case spv::CapabilityMultiViewport: return "MultiViewport"; + case spv::CapabilitySubgroupBallotKHR: return "SubgroupBallotKHR"; + case spv::CapabilityDrawParameters: return "DrawParameters"; + case spv::CapabilitySubgroupVoteKHR: return "SubgroupVoteKHR"; + case spv::CapabilityStorageUniformBufferBlock16: return "StorageUniformBufferBlock16"; + case spv::CapabilityStorageUniform16: return "StorageUniform16"; + case spv::CapabilityStoragePushConstant16: return "StoragePushConstant16"; + case spv::CapabilityStorageInputOutput16: return "StorageInputOutput16"; + case spv::CapabilityDeviceGroup: return "DeviceGroup"; + case spv::CapabilityMultiView: return "MultiView"; + case spv::CapabilityVariablePointersStorageBuffer: return "VariablePointersStorageBuffer"; + case spv::CapabilityVariablePointers: return "VariablePointers"; + case spv::CapabilityAtomicStorageOps: return "AtomicStorageOps"; + case spv::CapabilitySampleMaskPostDepthCoverage: return "SampleMaskPostDepthCoverage"; + case spv::CapabilityImageGatherBiasLodAMD: return "ImageGatherBiasLodAMD"; + case spv::CapabilityStencilExportEXT: return "StencilExportEXT"; + case spv::CapabilitySampleMaskOverrideCoverageNV: return "SampleMaskOverrideCoverageNV"; + case spv::CapabilityGeometryShaderPassthroughNV: return "GeometryShaderPassthroughNV"; + case spv::CapabilityShaderViewportIndexLayerNV: return "ShaderViewportIndexLayerNV"; + case spv::CapabilityShaderViewportMaskNV: return "ShaderViewportMaskNV"; + case spv::CapabilityShaderStereoViewNV: return "ShaderStereoViewNV"; + case spv::CapabilityPerViewAttributesNV: return "PerViewAttributesNV"; + case spv::CapabilityMax: break; + } + + return StringFormat::Fmt("UnrecognisedCap{%u}", (uint32_t)el); +} + +template <> +std::string DoStringise(const spv::ExecutionMode &el) +{ + switch(el) + { + case spv::ExecutionModeInvocations: return "Invocations"; + case spv::ExecutionModeSpacingEqual: return "SpacingEqual"; + case spv::ExecutionModeSpacingFractionalEven: return "SpacingFractionalEven"; + case spv::ExecutionModeSpacingFractionalOdd: return "SpacingFractionalOdd"; + case spv::ExecutionModeVertexOrderCw: return "VertexOrderCw"; + case spv::ExecutionModeVertexOrderCcw: return "VertexOrderCcw"; + case spv::ExecutionModePixelCenterInteger: return "PixelCenterInteger"; + case spv::ExecutionModeOriginUpperLeft: return "OriginUpperLeft"; + case spv::ExecutionModeOriginLowerLeft: return "OriginLowerLeft"; + case spv::ExecutionModeEarlyFragmentTests: return "EarlyFragmentTests"; + case spv::ExecutionModePointMode: return "PointMode"; + case spv::ExecutionModeXfb: return "Xfb"; + case spv::ExecutionModeDepthReplacing: return "DepthReplacing"; + case spv::ExecutionModeDepthGreater: return "DepthGreater"; + case spv::ExecutionModeDepthLess: return "DepthLess"; + case spv::ExecutionModeDepthUnchanged: return "DepthUnchanged"; + case spv::ExecutionModeLocalSize: return "LocalSize"; + case spv::ExecutionModeLocalSizeHint: return "LocalSizeHint"; + case spv::ExecutionModeInputPoints: return "InputPoints"; + case spv::ExecutionModeInputLines: return "InputLines"; + case spv::ExecutionModeInputLinesAdjacency: return "InputLinesAdjacency"; + case spv::ExecutionModeTriangles: return "Triangles"; + case spv::ExecutionModeInputTrianglesAdjacency: return "InputTrianglesAdjacency"; + case spv::ExecutionModeQuads: return "Quads"; + case spv::ExecutionModeIsolines: return "Isolines"; + case spv::ExecutionModeOutputVertices: return "OutputVertices"; + case spv::ExecutionModeOutputPoints: return "OutputPoints"; + case spv::ExecutionModeOutputLineStrip: return "OutputLineStrip"; + case spv::ExecutionModeOutputTriangleStrip: return "OutputTriangleStrip"; + case spv::ExecutionModeVecTypeHint: return "VecTypeHint"; + case spv::ExecutionModeContractionOff: return "ContractionOff"; + case spv::ExecutionModePostDepthCoverage: return "PostDepthCoverage"; + case spv::ExecutionModeMax: break; + } + + return StringFormat::Fmt("UnrecognisedMode{%u}", (uint32_t)el); +} + +template <> +std::string DoStringise(const spv::AddressingModel &el) +{ + switch(el) + { + case spv::AddressingModelLogical: return "Logical"; + case spv::AddressingModelPhysical32: return "Physical (32-bit)"; + case spv::AddressingModelPhysical64: return "Physical (64-bit)"; + case spv::AddressingModelMax: break; + } + + return StringFormat::Fmt("UnrecognisedModel{%u}", (uint32_t)el); +} + +template <> +std::string DoStringise(const spv::MemoryModel &el) +{ + switch(el) + { + case spv::MemoryModelSimple: return "Simple"; + case spv::MemoryModelGLSL450: return "GLSL450"; + case spv::MemoryModelOpenCL: return "OpenCL"; + case spv::MemoryModelMax: break; + } + + return StringFormat::Fmt("UnrecognisedModel{%u}", (uint32_t)el); +} + +template <> +std::string DoStringise(const spv::ExecutionModel &el) +{ + switch(el) + { + case spv::ExecutionModelVertex: return "Vertex Shader"; + case spv::ExecutionModelTessellationControl: return "Tess. Control Shader"; + case spv::ExecutionModelTessellationEvaluation: return "Tess. Eval Shader"; + case spv::ExecutionModelGeometry: return "Geometry Shader"; + case spv::ExecutionModelFragment: return "Fragment Shader"; + case spv::ExecutionModelGLCompute: return "Compute Shader"; + case spv::ExecutionModelKernel: return "Kernel"; + case spv::ExecutionModelMax: break; + } + + return StringFormat::Fmt("UnrecognisedModel{%u}", (uint32_t)el); +} + +template <> +std::string DoStringise(const spv::Decoration &el) +{ + switch(el) + { + case spv::DecorationRelaxedPrecision: return "RelaxedPrecision"; + case spv::DecorationSpecId: return "SpecId"; + case spv::DecorationBlock: return "Block"; + case spv::DecorationBufferBlock: return "BufferBlock"; + case spv::DecorationRowMajor: return "RowMajor"; + case spv::DecorationColMajor: return "ColMajor"; + case spv::DecorationArrayStride: return "ArrayStride"; + case spv::DecorationMatrixStride: return "MatrixStride"; + case spv::DecorationGLSLShared: return "GLSLShared"; + case spv::DecorationGLSLPacked: return "GLSLPacked"; + case spv::DecorationCPacked: return "CPacked"; + case spv::DecorationBuiltIn: return "BuiltIn"; + case spv::DecorationNoPerspective: return "NoPerspective"; + case spv::DecorationFlat: return "Flat"; + case spv::DecorationPatch: return "Patch"; + case spv::DecorationCentroid: return "Centroid"; + case spv::DecorationSample: return "Sample"; + case spv::DecorationInvariant: return "Invariant"; + case spv::DecorationRestrict: return "Restrict"; + case spv::DecorationAliased: return "Aliased"; + case spv::DecorationVolatile: return "Volatile"; + case spv::DecorationConstant: return "Constant"; + case spv::DecorationCoherent: return "Coherent"; + case spv::DecorationNonWritable: return "NonWritable"; + case spv::DecorationNonReadable: return "NonReadable"; + case spv::DecorationUniform: return "Uniform"; + case spv::DecorationSaturatedConversion: return "SaturatedConversion"; + case spv::DecorationStream: return "Stream"; + case spv::DecorationLocation: return "Location"; + case spv::DecorationComponent: return "Component"; + case spv::DecorationIndex: return "Index"; + case spv::DecorationBinding: return "Binding"; + case spv::DecorationDescriptorSet: return "DescriptorSet"; + case spv::DecorationOffset: return "Offset"; + case spv::DecorationXfbBuffer: return "XfbBuffer"; + case spv::DecorationXfbStride: return "XfbStride"; + case spv::DecorationFuncParamAttr: return "FuncParamAttr"; + case spv::DecorationFPRoundingMode: return "FPRoundingMode"; + case spv::DecorationFPFastMathMode: return "FPFastMathMode"; + case spv::DecorationLinkageAttributes: return "LinkageAttributes"; + case spv::DecorationNoContraction: return "NoContraction"; + case spv::DecorationInputAttachmentIndex: return "InputAttachmentIndex"; + case spv::DecorationAlignment: return "Alignment"; + case spv::DecorationExplicitInterpAMD: return "ExplicitInterpAMD"; + case spv::DecorationOverrideCoverageNV: return "OverrideCoverageNV"; + case spv::DecorationPassthroughNV: return "PassthroughNV"; + case spv::DecorationViewportRelativeNV: return "ViewportRelativeNV"; + case spv::DecorationSecondaryViewportRelativeNV: return "SecondaryViewportRelativeNV"; + case spv::DecorationMax: break; + } + + return StringFormat::Fmt("UnrecognisedDecoration{%u}", (uint32_t)el); +} + +template <> +std::string DoStringise(const spv::Dim &el) +{ + switch(el) + { + case spv::Dim1D: return "1D"; + case spv::Dim2D: return "2D"; + case spv::Dim3D: return "3D"; + case spv::DimCube: return "Cube"; + case spv::DimRect: return "Rect"; + case spv::DimBuffer: return "Buffer"; + case spv::DimSubpassData: return "Subpass Data"; + case spv::DimMax: break; + } + + return StringFormat::Fmt("{%u}D", (uint32_t)el); +} + +template <> +std::string DoStringise(const spv::StorageClass &el) +{ + switch(el) + { + case spv::StorageClassUniformConstant: return "UniformConstant"; + case spv::StorageClassInput: return "Input"; + case spv::StorageClassUniform: return "Uniform"; + case spv::StorageClassOutput: return "Output"; + case spv::StorageClassWorkgroup: return "Workgroup"; + case spv::StorageClassCrossWorkgroup: return "CrossWorkgroup"; + case spv::StorageClassPrivate: return "Private"; + case spv::StorageClassFunction: return "Function"; + case spv::StorageClassGeneric: return "Generic"; + case spv::StorageClassPushConstant: return "PushConstant"; + case spv::StorageClassAtomicCounter: return "AtomicCounter"; + case spv::StorageClassImage: return "Image"; + case spv::StorageClassStorageBuffer: return "StorageBuffer"; + case spv::StorageClassMax: break; + } + + return StringFormat::Fmt("UnrecognisedClass{%u}", (uint32_t)el); +} + +template <> +std::string DoStringise(const spv::ImageFormat &el) +{ + switch(el) + { + case spv::ImageFormatUnknown: return "Unknown"; + case spv::ImageFormatRgba32f: return "RGBA32f"; + case spv::ImageFormatRgba16f: return "RGBA16f"; + case spv::ImageFormatR32f: return "R32f"; + case spv::ImageFormatRgba8: return "RGBA8"; + case spv::ImageFormatRgba8Snorm: return "RGBA8SNORM"; + case spv::ImageFormatRg32f: return "RG32F"; + case spv::ImageFormatRg16f: return "RG16F"; + case spv::ImageFormatR11fG11fB10f: return "R11FG11FB10F"; + case spv::ImageFormatR16f: return "R16F"; + case spv::ImageFormatRgba16: return "RGBA16"; + case spv::ImageFormatRgb10A2: return "RGB10A2"; + case spv::ImageFormatRg16: return "RG16"; + case spv::ImageFormatRg8: return "RG8"; + case spv::ImageFormatR16: return "R16"; + case spv::ImageFormatR8: return "R8"; + case spv::ImageFormatRgba16Snorm: return "RGBA16SNORM"; + case spv::ImageFormatRg16Snorm: return "RG16SNORM"; + case spv::ImageFormatRg8Snorm: return "RG8SNORM"; + case spv::ImageFormatR16Snorm: return "R16SNORM"; + case spv::ImageFormatR8Snorm: return "R8SNORM"; + case spv::ImageFormatRgba32i: return "RGBA32I"; + case spv::ImageFormatRgba16i: return "RGBA16I"; + case spv::ImageFormatRgba8i: return "RGBA8I"; + case spv::ImageFormatR32i: return "R32I"; + case spv::ImageFormatRg32i: return "RG32I"; + case spv::ImageFormatRg16i: return "RG16I"; + case spv::ImageFormatRg8i: return "RG8I"; + case spv::ImageFormatR16i: return "R16I"; + case spv::ImageFormatR8i: return "R8I"; + case spv::ImageFormatRgba32ui: return "RGBA32UI"; + case spv::ImageFormatRgba16ui: return "RGBA16UI"; + case spv::ImageFormatRgba8ui: return "RGBA8UI"; + case spv::ImageFormatR32ui: return "R32UI"; + case spv::ImageFormatRgb10a2ui: return "RGB10A2UI"; + case spv::ImageFormatRg32ui: return "RG32UI"; + case spv::ImageFormatRg16ui: return "RG16UI"; + case spv::ImageFormatRg8ui: return "RG8UI"; + case spv::ImageFormatR16ui: return "R16UI"; + case spv::ImageFormatR8ui: return "R8UI"; + case spv::ImageFormatMax: break; + } + + return StringFormat::Fmt("UnrecognisedFormat{%u}", (uint32_t)el); +} + +template <> +std::string DoStringise(const spv::BuiltIn &el) +{ + switch(el) + { + case spv::BuiltInPosition: return "Position"; + case spv::BuiltInPointSize: return "PointSize"; + case spv::BuiltInClipDistance: return "ClipDistance"; + case spv::BuiltInCullDistance: return "CullDistance"; + case spv::BuiltInVertexId: return "VertexId"; + case spv::BuiltInInstanceId: return "InstanceId"; + case spv::BuiltInPrimitiveId: return "PrimitiveId"; + case spv::BuiltInInvocationId: return "InvocationId"; + case spv::BuiltInLayer: return "Layer"; + case spv::BuiltInViewportIndex: return "ViewportIndex"; + case spv::BuiltInTessLevelOuter: return "TessLevelOuter"; + case spv::BuiltInTessLevelInner: return "TessLevelInner"; + case spv::BuiltInTessCoord: return "TessCoord"; + case spv::BuiltInPatchVertices: return "PatchVertices"; + case spv::BuiltInFragCoord: return "FragCoord"; + case spv::BuiltInPointCoord: return "PointCoord"; + case spv::BuiltInFrontFacing: return "FrontFacing"; + case spv::BuiltInSampleId: return "SampleId"; + case spv::BuiltInSamplePosition: return "SamplePosition"; + case spv::BuiltInSampleMask: return "SampleMask"; + case spv::BuiltInFragDepth: return "FragDepth"; + case spv::BuiltInHelperInvocation: return "HelperInvocation"; + case spv::BuiltInNumWorkgroups: return "NumWorkgroups"; + case spv::BuiltInWorkgroupSize: return "WorkgroupSize"; + case spv::BuiltInWorkgroupId: return "WorkgroupId"; + case spv::BuiltInLocalInvocationId: return "LocalInvocationId"; + case spv::BuiltInGlobalInvocationId: return "GlobalInvocationId"; + case spv::BuiltInLocalInvocationIndex: return "LocalInvocationIndex"; + case spv::BuiltInWorkDim: return "WorkDim"; + case spv::BuiltInGlobalSize: return "GlobalSize"; + case spv::BuiltInEnqueuedWorkgroupSize: return "EnqueuedWorkgroupSize"; + case spv::BuiltInGlobalOffset: return "GlobalOffset"; + case spv::BuiltInGlobalLinearId: return "GlobalLinearId"; + case spv::BuiltInSubgroupSize: return "SubgroupSize"; + case spv::BuiltInSubgroupMaxSize: return "SubgroupMaxSize"; + case spv::BuiltInNumSubgroups: return "NumSubgroups"; + case spv::BuiltInNumEnqueuedSubgroups: return "NumEnqueuedSubgroups"; + case spv::BuiltInSubgroupId: return "SubgroupId"; + case spv::BuiltInSubgroupLocalInvocationId: return "SubgroupLocalInvocationId"; + case spv::BuiltInVertexIndex: return "VertexIndex"; + case spv::BuiltInInstanceIndex: return "InstanceIndex"; + case spv::BuiltInSubgroupEqMaskKHR: return "SubgroupEqMaskKHR"; + case spv::BuiltInSubgroupGeMaskKHR: return "SubgroupGeMaskKHR"; + case spv::BuiltInSubgroupGtMaskKHR: return "SubgroupGtMaskKHR"; + case spv::BuiltInSubgroupLeMaskKHR: return "SubgroupLeMaskKHR"; + case spv::BuiltInSubgroupLtMaskKHR: return "SubgroupLtMaskKHR"; + case spv::BuiltInBaseVertex: return "BaseVertex"; + case spv::BuiltInBaseInstance: return "BaseInstance"; + case spv::BuiltInDrawIndex: return "DrawIndex"; + case spv::BuiltInDeviceIndex: return "DeviceIndex"; + case spv::BuiltInViewIndex: return "ViewIndex"; + case spv::BuiltInBaryCoordNoPerspAMD: return "BaryCoordNoPerspAMD"; + case spv::BuiltInBaryCoordNoPerspCentroidAMD: return "BaryCoordNoPerspCentroidAMD"; + case spv::BuiltInBaryCoordNoPerspSampleAMD: return "BaryCoordNoPerspSampleAMD"; + case spv::BuiltInBaryCoordSmoothAMD: return "BaryCoordSmoothAMD"; + case spv::BuiltInBaryCoordSmoothCentroidAMD: return "BaryCoordSmoothCentroidAMD"; + case spv::BuiltInBaryCoordSmoothSampleAMD: return "BaryCoordSmoothSampleAMD"; + case spv::BuiltInBaryCoordPullModelAMD: return "BaryCoordPullModelAMD"; + case spv::BuiltInFragStencilRefEXT: return "FragStencilRefEXT"; + case spv::BuiltInViewportMaskNV: return "ViewportMaskNV"; + case spv::BuiltInSecondaryPositionNV: return "SecondaryPositionNV"; + case spv::BuiltInSecondaryViewportMaskNV: return "SecondaryViewportMaskNV"; + case spv::BuiltInPositionPerViewNV: return "PositionPerViewNV"; + case spv::BuiltInViewportMaskPerViewNV: return "ViewportMaskPerViewNV"; + case spv::BuiltInMax: break; + } + + return StringFormat::Fmt("UnrecognisedBuiltIn{%u}", (uint32_t)el); +} + +template <> +std::string DoStringise(const spv::Scope &el) +{ + switch(el) + { + case spv::ScopeCrossDevice: return "CrossDevice"; + case spv::ScopeDevice: return "Device"; + case spv::ScopeWorkgroup: return "Workgroup"; + case spv::ScopeSubgroup: return "Subgroup"; + case spv::ScopeInvocation: return "Invocation"; + case spv::ScopeMax: break; + } + + return StringFormat::Fmt("UnrecognisedScope{%u}", (uint32_t)el); +} + +template <> +std::string DoStringise(const spv::FunctionControlMask &el) +{ + BEGIN_BITFIELD_STRINGISE(spv::FunctionControlMask); + { + STRINGISE_BITFIELD_BIT_NAMED(spv::FunctionControlInlineMask, "Inline"); + STRINGISE_BITFIELD_BIT_NAMED(spv::FunctionControlDontInlineMask, "DontInline"); + STRINGISE_BITFIELD_BIT_NAMED(spv::FunctionControlPureMask, "Pure"); + STRINGISE_BITFIELD_BIT_NAMED(spv::FunctionControlConstMask, "Const"); + } + END_BITFIELD_STRINGISE(); +} + +template <> +std::string DoStringise(const spv::SelectionControlMask &el) +{ + BEGIN_BITFIELD_STRINGISE(spv::SelectionControlMask); + { + STRINGISE_BITFIELD_BIT_NAMED(spv::SelectionControlFlattenMask, "Flatten"); + STRINGISE_BITFIELD_BIT_NAMED(spv::SelectionControlDontFlattenMask, "DontFlatten"); + } + END_BITFIELD_STRINGISE(); +} + +template <> +std::string DoStringise(const spv::LoopControlMask &el) +{ + BEGIN_BITFIELD_STRINGISE(spv::LoopControlMask); + { + STRINGISE_BITFIELD_BIT_NAMED(spv::LoopControlUnrollMask, "Unroll"); + STRINGISE_BITFIELD_BIT_NAMED(spv::LoopControlDontUnrollMask, "DontUnroll"); + } + END_BITFIELD_STRINGISE(); +} + +template <> +std::string DoStringise(const spv::MemoryAccessMask &el) +{ + BEGIN_BITFIELD_STRINGISE(spv::MemoryAccessMask); + { + STRINGISE_BITFIELD_BIT_NAMED(spv::MemoryAccessVolatileMask, "Volatile"); + STRINGISE_BITFIELD_BIT_NAMED(spv::MemoryAccessAlignedMask, "Aligned"); + STRINGISE_BITFIELD_BIT_NAMED(spv::MemoryAccessNontemporalMask, "Nontemporal"); + } + END_BITFIELD_STRINGISE(); +} + +template <> +std::string DoStringise(const spv::MemorySemanticsMask &el) +{ + BEGIN_BITFIELD_STRINGISE(spv::MemorySemanticsMask); + { + STRINGISE_BITFIELD_VALUE_NAMED(spv::MemorySemanticsMaskNone, "None"); + + STRINGISE_BITFIELD_BIT_NAMED(spv::MemorySemanticsAcquireMask, "Acquire"); + STRINGISE_BITFIELD_BIT_NAMED(spv::MemorySemanticsReleaseMask, "Release"); + STRINGISE_BITFIELD_BIT_NAMED(spv::MemorySemanticsAcquireReleaseMask, "Acquire/Release"); + STRINGISE_BITFIELD_BIT_NAMED(spv::MemorySemanticsSequentiallyConsistentMask, + "Sequentially Consistent"); + STRINGISE_BITFIELD_BIT_NAMED(spv::MemorySemanticsUniformMemoryMask, "Uniform Memory"); + STRINGISE_BITFIELD_BIT_NAMED(spv::MemorySemanticsSubgroupMemoryMask, "Subgroup Memory"); + STRINGISE_BITFIELD_BIT_NAMED(spv::MemorySemanticsWorkgroupMemoryMask, "Workgroup Memory"); + STRINGISE_BITFIELD_BIT_NAMED(spv::MemorySemanticsCrossWorkgroupMemoryMask, + "Cross Workgroup Memory"); + STRINGISE_BITFIELD_BIT_NAMED(spv::MemorySemanticsAtomicCounterMemoryMask, + "Atomic Counter Memory"); + STRINGISE_BITFIELD_BIT_NAMED(spv::MemorySemanticsImageMemoryMask, "Image Memory"); + } + END_BITFIELD_STRINGISE(); +} diff --git a/renderdoc/driver/vulkan/CMakeLists.txt b/renderdoc/driver/vulkan/CMakeLists.txt index 0c5fc55f1..1932850ef 100644 --- a/renderdoc/driver/vulkan/CMakeLists.txt +++ b/renderdoc/driver/vulkan/CMakeLists.txt @@ -21,6 +21,7 @@ set(sources vk_resources.h vk_state.cpp vk_state.h + vk_stringise.cpp vk_layer.cpp official/vk_layer.h official/vk_platform.h diff --git a/renderdoc/driver/vulkan/renderdoc_vulkan.vcxproj b/renderdoc/driver/vulkan/renderdoc_vulkan.vcxproj index b37e5a172..ba2b98c3e 100644 --- a/renderdoc/driver/vulkan/renderdoc_vulkan.vcxproj +++ b/renderdoc/driver/vulkan/renderdoc_vulkan.vcxproj @@ -59,7 +59,7 @@ RELEASE;%(PreprocessorDefinitions) - + MultiThreadedDLL false @@ -104,6 +104,7 @@ true + @@ -167,12 +168,10 @@ $([System.IO.File]::ReadAllText('$(SolutionDir)renderdoc/api/replay/version.h').Trim()) - $(VersionFile.IndexOf('#define RENDERDOC_VERSION_MAJOR')) - $(VersionFile.Substring($(MajorVersionStart)).Split(' ')[0].Split(' ')[2]) - $(VersionFile.IndexOf('#define RENDERDOC_VERSION_MINOR')) $(VersionFile.Substring($(MinorVersionStart)).Split(' ')[0].Split(' ')[2]) - - - + $([System.IO.File]::ReadAllText('$(ProjectDir)renderdoc.json').Replace('[MAJOR]', '$(MajorVersion)').Replace('[MINOR]', '$(MinorVersion)')) - - + diff --git a/renderdoc/driver/vulkan/renderdoc_vulkan.vcxproj.filters b/renderdoc/driver/vulkan/renderdoc_vulkan.vcxproj.filters index b3ee595fe..88c622fdc 100644 --- a/renderdoc/driver/vulkan/renderdoc_vulkan.vcxproj.filters +++ b/renderdoc/driver/vulkan/renderdoc_vulkan.vcxproj.filters @@ -97,6 +97,9 @@ PCH + + Util + diff --git a/renderdoc/driver/vulkan/vk_common.cpp b/renderdoc/driver/vulkan/vk_common.cpp index 9b46a24d9..51b667760 100644 --- a/renderdoc/driver/vulkan/vk_common.cpp +++ b/renderdoc/driver/vulkan/vk_common.cpp @@ -1440,1748 +1440,6 @@ StencilOp MakeStencilOp(VkStencilOp op) return StencilOp::Keep; } -// we cast to this type when serialising as a placeholder indicating that -// the given flags field doesn't have any bits defined -enum VkFlagWithNoBits -{ - FlagWithNoBits_Dummy_Bit = 1, -}; - -template <> -string ToStrHelper::Get(const VkResourceType &el) -{ - switch(el) - { - TOSTR_CASE_STRINGIZE(eResUnknown) - TOSTR_CASE_STRINGIZE(eResPhysicalDevice) - TOSTR_CASE_STRINGIZE(eResInstance) - TOSTR_CASE_STRINGIZE(eResDevice) - TOSTR_CASE_STRINGIZE(eResQueue) - TOSTR_CASE_STRINGIZE(eResDeviceMemory) - TOSTR_CASE_STRINGIZE(eResBuffer) - TOSTR_CASE_STRINGIZE(eResBufferView) - TOSTR_CASE_STRINGIZE(eResImage) - TOSTR_CASE_STRINGIZE(eResImageView) - TOSTR_CASE_STRINGIZE(eResFramebuffer) - TOSTR_CASE_STRINGIZE(eResRenderPass) - TOSTR_CASE_STRINGIZE(eResShaderModule) - TOSTR_CASE_STRINGIZE(eResPipelineCache) - TOSTR_CASE_STRINGIZE(eResPipelineLayout) - TOSTR_CASE_STRINGIZE(eResPipeline) - TOSTR_CASE_STRINGIZE(eResSampler) - TOSTR_CASE_STRINGIZE(eResDescriptorPool) - TOSTR_CASE_STRINGIZE(eResDescriptorSetLayout) - TOSTR_CASE_STRINGIZE(eResDescriptorSet) - TOSTR_CASE_STRINGIZE(eResCommandPool) - TOSTR_CASE_STRINGIZE(eResCommandBuffer) - TOSTR_CASE_STRINGIZE(eResFence) - TOSTR_CASE_STRINGIZE(eResEvent) - TOSTR_CASE_STRINGIZE(eResQueryPool) - TOSTR_CASE_STRINGIZE(eResSemaphore) - TOSTR_CASE_STRINGIZE(eResSwapchain) - TOSTR_CASE_STRINGIZE(eResSurface) - default: break; - } - - return StringFormat::Fmt("VkResourceType<%d>", el); -} - -template <> -string ToStrHelper::Get(const VkQueueFlagBits &el) -{ - string ret; - - if(el & VK_QUEUE_GRAPHICS_BIT) - ret += " | VK_QUEUE_GRAPHICS_BIT"; - if(el & VK_QUEUE_COMPUTE_BIT) - ret += " | VK_QUEUE_COMPUTE_BIT"; - if(el & VK_QUEUE_TRANSFER_BIT) - ret += " | VK_QUEUE_TRANSFER_BIT"; - if(el & VK_QUEUE_SPARSE_BINDING_BIT) - ret += " | VK_QUEUE_SPARSE_BINDING_BIT"; - - if(!ret.empty()) - ret = ret.substr(3); - - return ret; -} - -template <> -string ToStrHelper::Get(const VkFlagWithNoBits &el) -{ - if(el != 0) - return StringFormat::Fmt("Invalid bits set: %x", el); - return ""; -} - -template <> -string ToStrHelper::Get(const VkPipelineCreateFlagBits &el) -{ - string ret; - - if(el & VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT) - ret += " | VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT"; - if(el & VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT) - ret += " | VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT"; - if(el & VK_PIPELINE_CREATE_DERIVATIVE_BIT) - ret += " | VK_PIPELINE_CREATE_DERIVATIVE_BIT"; - - if(!ret.empty()) - ret = ret.substr(3); - - return ret; -} - -template <> -string ToStrHelper::Get(const VkPipelineStageFlagBits &el) -{ - string ret; - - if(el & VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT) - ret += " | VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT"; - if(el & VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT) - ret += " | VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT"; - if(el & VK_PIPELINE_STAGE_VERTEX_INPUT_BIT) - ret += " | VK_PIPELINE_STAGE_VERTEX_INPUT_BIT"; - if(el & VK_PIPELINE_STAGE_VERTEX_SHADER_BIT) - ret += " | VK_PIPELINE_STAGE_VERTEX_SHADER_BIT"; - if(el & VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT) - ret += " | VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT"; - if(el & VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT) - ret += " | VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT"; - if(el & VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT) - ret += " | VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT"; - if(el & VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT) - ret += " | VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT"; - if(el & VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT) - ret += " | VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT"; - if(el & VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT) - ret += " | VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT"; - if(el & VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT) - ret += " | VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT"; - if(el & VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT) - ret += " | VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT"; - if(el & VK_PIPELINE_STAGE_TRANSFER_BIT) - ret += " | VK_PIPELINE_STAGE_TRANSFER_BIT"; - if(el & VK_PIPELINE_STAGE_HOST_BIT) - ret += " | VK_PIPELINE_STAGE_HOST_BIT"; - if(el & VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT) - ret += " | VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT"; - if(el & VK_PIPELINE_STAGE_ALL_COMMANDS_BIT) - ret += " | VK_PIPELINE_STAGE_ALL_COMMANDS_BIT"; - if(el & VK_PIPELINE_STAGE_COMMAND_PROCESS_BIT_NVX) - ret += " | VK_PIPELINE_STAGE_COMMAND_PROCESS_BIT_NVX"; - - if(!ret.empty()) - ret = ret.substr(3); - - return ret; -} - -template <> -string ToStrHelper::Get(const VkBufferUsageFlagBits &el) -{ - string ret = ""; - - if(el & VK_BUFFER_USAGE_TRANSFER_SRC_BIT) - ret += " | VK_BUFFER_USAGE_TRANSFER_SRC_BIT"; - if(el & VK_BUFFER_USAGE_TRANSFER_DST_BIT) - ret += " | VK_BUFFER_USAGE_TRANSFER_DST_BIT"; - if(el & VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT) - ret += " | VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT"; - if(el & VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT) - ret += " | VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT"; - if(el & VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT) - ret += " | VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT"; - if(el & VK_BUFFER_USAGE_STORAGE_BUFFER_BIT) - ret += " | VK_BUFFER_USAGE_STORAGE_BUFFER_BIT"; - if(el & VK_BUFFER_USAGE_INDEX_BUFFER_BIT) - ret += " | VK_BUFFER_USAGE_INDEX_BUFFER_BIT"; - if(el & VK_BUFFER_USAGE_VERTEX_BUFFER_BIT) - ret += " | VK_BUFFER_USAGE_VERTEX_BUFFER_BIT"; - if(el & VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT) - ret += " | VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT"; - - if(!ret.empty()) - ret = ret.substr(3); - - return ret; -} - -template <> -string ToStrHelper::Get(const VkImageUsageFlagBits &el) -{ - string ret = ""; - - if(el & VK_IMAGE_USAGE_TRANSFER_SRC_BIT) - ret += " | VK_IMAGE_USAGE_TRANSFER_SRC_BIT"; - if(el & VK_IMAGE_USAGE_TRANSFER_DST_BIT) - ret += " | VK_IMAGE_USAGE_TRANSFER_DST_BIT"; - if(el & VK_IMAGE_USAGE_SAMPLED_BIT) - ret += " | VK_IMAGE_USAGE_SAMPLED_BIT"; - if(el & VK_IMAGE_USAGE_STORAGE_BIT) - ret += " | VK_IMAGE_USAGE_STORAGE_BIT"; - if(el & VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT) - ret += " | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT"; - if(el & VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT) - ret += " | VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT"; - if(el & VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT) - ret += " | VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT"; - if(el & VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT) - ret += " | VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT"; - - if(!ret.empty()) - ret = ret.substr(3); - - return ret; -} - -template <> -string ToStrHelper::Get(const VkBufferCreateFlagBits &el) -{ - string ret; - - if(el & VK_BUFFER_CREATE_SPARSE_BINDING_BIT) - ret += " | VK_BUFFER_CREATE_SPARSE_BINDING_BIT"; - if(el & VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT) - ret += " | VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT"; - if(el & VK_BUFFER_CREATE_SPARSE_ALIASED_BIT) - ret += " | VK_BUFFER_CREATE_SPARSE_ALIASED_BIT"; - - if(!ret.empty()) - ret = ret.substr(3); - - return ret; -} - -template <> -string ToStrHelper::Get(const VkImageCreateFlagBits &el) -{ - string ret; - - if(el & VK_IMAGE_CREATE_SPARSE_BINDING_BIT) - ret += " | VK_IMAGE_CREATE_SPARSE_BINDING_BIT"; - if(el & VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT) - ret += " | VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT"; - if(el & VK_IMAGE_CREATE_SPARSE_ALIASED_BIT) - ret += " | VK_IMAGE_CREATE_SPARSE_ALIASED_BIT"; - if(el & VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT) - ret += " | VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT"; - if(el & VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT) - ret += " | VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT"; - if(el & VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT_KHR) - ret += " | VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT_KHR"; - - if(!ret.empty()) - ret = ret.substr(3); - - return ret; -} - -template <> -string ToStrHelper::Get(const VkSparseMemoryBindFlagBits &el) -{ - string ret; - - if(el & VK_SPARSE_MEMORY_BIND_METADATA_BIT) - ret += " | VK_SPARSE_MEMORY_BIND_METADATA_BIT"; - - if(!ret.empty()) - ret = ret.substr(3); - - return ret; -} - -template <> -string ToStrHelper::Get(const VkCommandPoolCreateFlagBits &el) -{ - string ret; - - if(el & VK_COMMAND_POOL_CREATE_TRANSIENT_BIT) - ret += " | VK_COMMAND_POOL_CREATE_TRANSIENT_BIT"; - if(el & VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT) - ret += " | VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT"; - - if(!ret.empty()) - ret = ret.substr(3); - - return ret; -} - -template <> -string ToStrHelper::Get(const VkCommandPoolResetFlagBits &el) -{ - string ret; - - if(el & VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT) - ret += " | VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT"; - - if(!ret.empty()) - ret = ret.substr(3); - - return ret; -} - -template <> -string ToStrHelper::Get(const VkCommandBufferUsageFlagBits &el) -{ - string ret; - - if(el & VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT) - ret += " | VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT"; - if(el & VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT) - ret += " | VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT"; - if(el & VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT) - ret += " | VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT"; - - if(!ret.empty()) - ret = ret.substr(3); - - return ret; -} - -template <> -string ToStrHelper::Get(const VkDescriptorPoolCreateFlagBits &el) -{ - string ret; - - if(el & VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT) - ret += " | VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT"; - - if(!ret.empty()) - ret = ret.substr(3); - - return ret; -} - -template <> -string ToStrHelper::Get(const VkFenceCreateFlagBits &el) -{ - string ret; - - if(el & VK_FENCE_CREATE_SIGNALED_BIT) - ret += " | VK_FENCE_CREATE_SIGNALED_BIT"; - - if(!ret.empty()) - ret = ret.substr(3); - - return ret; -} - -template <> -string ToStrHelper::Get( - const VkQueryPipelineStatisticFlagBits &el) -{ - string ret; - - if(el & VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT) - ret += " | VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT"; - if(el & VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT) - ret += " | VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT"; - if(el & VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT) - ret += " | VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT"; - if(el & VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT) - ret += " | VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT"; - if(el & VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT) - ret += " | VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT"; - if(el & VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT) - ret += " | VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT"; - if(el & VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT) - ret += " | VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT"; - if(el & VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT) - ret += " | VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT"; - if(el & VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT) - ret += " | VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT"; - if(el & VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT) - ret += " | VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT"; - if(el & VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT) - ret += " | VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT"; - - if(!ret.empty()) - ret = ret.substr(3); - - return ret; -} - -template <> -string ToStrHelper::Get(const VkQueryControlFlagBits &el) -{ - string ret; - - if(el & VK_QUERY_CONTROL_PRECISE_BIT) - ret += " | VK_QUERY_CONTROL_PRECISE_BIT"; - - if(!ret.empty()) - ret = ret.substr(3); - - return ret; -} - -template <> -string ToStrHelper::Get(const VkQueryResultFlagBits &el) -{ - string ret; - - if(el & VK_QUERY_RESULT_64_BIT) - ret += " | VK_QUERY_RESULT_64_BIT"; - if(el & VK_QUERY_RESULT_WAIT_BIT) - ret += " | VK_QUERY_RESULT_WAIT_BIT"; - if(el & VK_QUERY_RESULT_WITH_AVAILABILITY_BIT) - ret += " | VK_QUERY_RESULT_WITH_AVAILABILITY_BIT"; - if(el & VK_QUERY_RESULT_PARTIAL_BIT) - ret += " | VK_QUERY_RESULT_PARTIAL_BIT"; - - if(!ret.empty()) - ret = ret.substr(3); - - return ret; -} - -template <> -string ToStrHelper::Get(const VkAttachmentDescriptionFlagBits &el) -{ - string ret; - - if(el & VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT) - ret += " | VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT"; - - if(!ret.empty()) - ret = ret.substr(3); - - return ret; -} - -template <> -string ToStrHelper::Get(const VkSampleCountFlagBits &el) -{ - string ret; - - if(el & VK_SAMPLE_COUNT_1_BIT) - ret += " | VK_SAMPLE_COUNT_1_BIT"; - if(el & VK_SAMPLE_COUNT_2_BIT) - ret += " | VK_SAMPLE_COUNT_2_BIT"; - if(el & VK_SAMPLE_COUNT_4_BIT) - ret += " | VK_SAMPLE_COUNT_4_BIT"; - if(el & VK_SAMPLE_COUNT_8_BIT) - ret += " | VK_SAMPLE_COUNT_8_BIT"; - if(el & VK_SAMPLE_COUNT_16_BIT) - ret += " | VK_SAMPLE_COUNT_16_BIT"; - if(el & VK_SAMPLE_COUNT_32_BIT) - ret += " | VK_SAMPLE_COUNT_32_BIT"; - if(el & VK_SAMPLE_COUNT_64_BIT) - ret += " | VK_SAMPLE_COUNT_64_BIT"; - - if(!ret.empty()) - ret = ret.substr(3); - - return ret; -} - -template <> -string ToStrHelper::Get(const VkImageAspectFlagBits &el) -{ - string ret; - - if(el & VK_IMAGE_ASPECT_COLOR_BIT) - ret += " | VK_IMAGE_ASPECT_COLOR_BIT"; - if(el & VK_IMAGE_ASPECT_DEPTH_BIT) - ret += " | VK_IMAGE_ASPECT_DEPTH_BIT"; - if(el & VK_IMAGE_ASPECT_STENCIL_BIT) - ret += " | VK_IMAGE_ASPECT_STENCIL_BIT"; - if(el & VK_IMAGE_ASPECT_METADATA_BIT) - ret += " | VK_IMAGE_ASPECT_METADATA_BIT"; - - if(!ret.empty()) - ret = ret.substr(3); - - return ret; -} - -template <> -string ToStrHelper::Get(const VkDependencyFlagBits &el) -{ - string ret; - - if(el & VK_DEPENDENCY_BY_REGION_BIT) - ret += " | VK_DEPENDENCY_BY_REGION_BIT"; - - if(!ret.empty()) - ret = ret.substr(3); - - return ret; -} - -template <> -string ToStrHelper::Get(const VkShaderStageFlagBits &el) -{ - string ret; - - if(el == VK_SHADER_STAGE_ALL_GRAPHICS) - return "VK_SHADER_STAGE_ALL_GRAPHICS"; - if(el == VK_SHADER_STAGE_ALL) - return "VK_SHADER_STAGE_ALL"; - - if(el & VK_SHADER_STAGE_VERTEX_BIT) - ret += " | VK_SHADER_STAGE_VERTEX"; - if(el & VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT) - ret += " | VK_SHADER_STAGE_TESSELLATION_CONTROL"; - if(el & VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT) - ret += " | VK_SHADER_STAGE_TESSELLATION_EVALUATION"; - if(el & VK_SHADER_STAGE_GEOMETRY_BIT) - ret += " | VK_SHADER_STAGE_GEOMETRY"; - if(el & VK_SHADER_STAGE_FRAGMENT_BIT) - ret += " | VK_SHADER_STAGE_FRAGMENT"; - if(el & VK_SHADER_STAGE_COMPUTE_BIT) - ret += " | VK_SHADER_STAGE_COMPUTE"; - - if(!ret.empty()) - ret = ret.substr(3); - - return ret; -} - -template <> -string ToStrHelper::Get(const VkStencilFaceFlagBits &el) -{ - // technically a bitfield but each combination has a particular meaning - if(el == VK_STENCIL_FACE_FRONT_BIT) - return "VK_STENCIL_FACE_FRONT"; - if(el == VK_STENCIL_FACE_BACK_BIT) - return "VK_STENCIL_FACE_BACK"; - if(el == VK_STENCIL_FRONT_AND_BACK) - return "VK_STENCIL_FRONT_AND_BACK"; - - if(el == 0) - return "VK_STENCIL_FACE_NONE"; - - return StringFormat::Fmt("VkStencilFaceFlagBits<%d>", el); -} - -template <> -string ToStrHelper::Get(const VkCullModeFlagBits &el) -{ - // technically a bitfield but each combination has a particular meaning - if(el == VK_CULL_MODE_NONE) - return "VK_CULL_MODE_NONE"; - if(el == VK_CULL_MODE_FRONT_BIT) - return "VK_CULL_MODE_FRONT"; - if(el == VK_CULL_MODE_BACK_BIT) - return "VK_CULL_MODE_BACK"; - if(el == VK_CULL_MODE_FRONT_AND_BACK) - return "VK_CULL_MODE_FRONT_AND_BACK"; - - return StringFormat::Fmt("VkCullModeFlagBits<%d>", el); -} - -template <> -string ToStrHelper::Get(const VkPipelineBindPoint &el) -{ - switch(el) - { - TOSTR_CASE_STRINGIZE(VK_PIPELINE_BIND_POINT_COMPUTE) - TOSTR_CASE_STRINGIZE(VK_PIPELINE_BIND_POINT_GRAPHICS) - default: break; - } - - return StringFormat::Fmt("VkPipelineBindPoint<%d>", el); -} - -template <> -string ToStrHelper::Get(const VkIndexType &el) -{ - switch(el) - { - TOSTR_CASE_STRINGIZE(VK_INDEX_TYPE_UINT16) - TOSTR_CASE_STRINGIZE(VK_INDEX_TYPE_UINT32) - default: break; - } - - return StringFormat::Fmt("VkIndexType<%d>", el); -} - -template <> -string ToStrHelper::Get(const VkImageType &el) -{ - switch(el) - { - TOSTR_CASE_STRINGIZE(VK_IMAGE_TYPE_1D) - TOSTR_CASE_STRINGIZE(VK_IMAGE_TYPE_2D) - TOSTR_CASE_STRINGIZE(VK_IMAGE_TYPE_3D) - default: break; - } - - return StringFormat::Fmt("VkImageType<%d>", el); -} - -template <> -string ToStrHelper::Get(const VkImageTiling &el) -{ - switch(el) - { - TOSTR_CASE_STRINGIZE(VK_IMAGE_TILING_LINEAR) - TOSTR_CASE_STRINGIZE(VK_IMAGE_TILING_OPTIMAL) - default: break; - } - - return StringFormat::Fmt("VkImageTiling<%d>", el); -} - -template <> -string ToStrHelper::Get(const VkImageViewType &el) -{ - switch(el) - { - TOSTR_CASE_STRINGIZE(VK_IMAGE_VIEW_TYPE_1D) - TOSTR_CASE_STRINGIZE(VK_IMAGE_VIEW_TYPE_2D) - TOSTR_CASE_STRINGIZE(VK_IMAGE_VIEW_TYPE_3D) - TOSTR_CASE_STRINGIZE(VK_IMAGE_VIEW_TYPE_CUBE) - TOSTR_CASE_STRINGIZE(VK_IMAGE_VIEW_TYPE_1D_ARRAY) - TOSTR_CASE_STRINGIZE(VK_IMAGE_VIEW_TYPE_2D_ARRAY) - TOSTR_CASE_STRINGIZE(VK_IMAGE_VIEW_TYPE_CUBE_ARRAY) - default: break; - } - - return StringFormat::Fmt("VkImageViewType<%d>", el); -} - -template <> -string ToStrHelper::Get(const VkVertexInputRate &el) -{ - switch(el) - { - TOSTR_CASE_STRINGIZE(VK_VERTEX_INPUT_RATE_VERTEX) - TOSTR_CASE_STRINGIZE(VK_VERTEX_INPUT_RATE_INSTANCE) - default: break; - } - - return StringFormat::Fmt("VkVertexInputRate<%d>", el); -} - -template <> -string ToStrHelper::Get(const VkPolygonMode &el) -{ - switch(el) - { - TOSTR_CASE_STRINGIZE(VK_POLYGON_MODE_FILL) - TOSTR_CASE_STRINGIZE(VK_POLYGON_MODE_LINE) - TOSTR_CASE_STRINGIZE(VK_POLYGON_MODE_POINT) - TOSTR_CASE_STRINGIZE(VK_POLYGON_MODE_FILL_RECTANGLE_NV) - default: break; - } - - return StringFormat::Fmt("VkPolygonMode<%d>", el); -} - -template <> -string ToStrHelper::Get(const VkFrontFace &el) -{ - switch(el) - { - TOSTR_CASE_STRINGIZE(VK_FRONT_FACE_COUNTER_CLOCKWISE) - TOSTR_CASE_STRINGIZE(VK_FRONT_FACE_CLOCKWISE) - default: break; - } - - return StringFormat::Fmt("VkFrontFace<%d>", el); -} - -template <> -string ToStrHelper::Get(const VkBlendFactor &el) -{ - switch(el) - { - case VK_BLEND_FACTOR_ZERO: return "ZERO"; - case VK_BLEND_FACTOR_ONE: return "ONE"; - case VK_BLEND_FACTOR_SRC_COLOR: return "SRC_COLOR"; - case VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR: return "INV_SRC_COLOR"; - case VK_BLEND_FACTOR_DST_COLOR: return "DST_COLOR"; - case VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR: return "INV_DST_COLOR"; - case VK_BLEND_FACTOR_SRC_ALPHA: return "SRC_ALPHA"; - case VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA: return "INV_SRC_ALPHA"; - case VK_BLEND_FACTOR_DST_ALPHA: return "DST_ALPHA"; - case VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA: return "INV_DST_ALPHA"; - case VK_BLEND_FACTOR_CONSTANT_COLOR: return "CONST_COLOR"; - case VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR: return "INV_CONST_COLOR"; - case VK_BLEND_FACTOR_CONSTANT_ALPHA: return "CONST_ALPHA"; - case VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA: return "INV_CONST_ALPHA"; - case VK_BLEND_FACTOR_SRC_ALPHA_SATURATE: return "SRC_ALPHA_SAT"; - case VK_BLEND_FACTOR_SRC1_COLOR: return "SRC1_COLOR"; - case VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR: return "INV_SRC1_COLOR"; - case VK_BLEND_FACTOR_SRC1_ALPHA: return "SRC1_ALPHA"; - case VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA: return "INV_SRC1_ALPHA"; - default: break; - } - - return StringFormat::Fmt("VkBlendFactor<%d>", el); -} - -template <> -string ToStrHelper::Get(const VkBlendOp &el) -{ - // Need to update this when we support VK_EXT_blend_operation_advanced - switch(el) - { - case VK_BLEND_OP_ADD: return "ADD"; - case VK_BLEND_OP_SUBTRACT: return "SUB"; - case VK_BLEND_OP_REVERSE_SUBTRACT: return "REV_SUB"; - case VK_BLEND_OP_MIN: return "MIN"; - case VK_BLEND_OP_MAX: return "MAX"; - default: break; - } - - return StringFormat::Fmt("VkBlendOp<%d>", el); -} - -template <> -string ToStrHelper::Get(const VkDynamicState &el) -{ - switch(el) - { - TOSTR_CASE_STRINGIZE(VK_DYNAMIC_STATE_VIEWPORT) - TOSTR_CASE_STRINGIZE(VK_DYNAMIC_STATE_SCISSOR) - TOSTR_CASE_STRINGIZE(VK_DYNAMIC_STATE_LINE_WIDTH) - TOSTR_CASE_STRINGIZE(VK_DYNAMIC_STATE_DEPTH_BIAS) - TOSTR_CASE_STRINGIZE(VK_DYNAMIC_STATE_BLEND_CONSTANTS) - TOSTR_CASE_STRINGIZE(VK_DYNAMIC_STATE_DEPTH_BOUNDS) - TOSTR_CASE_STRINGIZE(VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK) - TOSTR_CASE_STRINGIZE(VK_DYNAMIC_STATE_STENCIL_WRITE_MASK) - TOSTR_CASE_STRINGIZE(VK_DYNAMIC_STATE_STENCIL_REFERENCE) - default: break; - } - - return StringFormat::Fmt("VkDynamicState<%d>", el); -} - -template <> -string ToStrHelper::Get(const VkAttachmentLoadOp &el) -{ - switch(el) - { - case VK_ATTACHMENT_LOAD_OP_LOAD: return "Load"; - case VK_ATTACHMENT_LOAD_OP_CLEAR: return "Clear"; - case VK_ATTACHMENT_LOAD_OP_DONT_CARE: return "Don't Care"; - default: break; - } - - return StringFormat::Fmt("VkAttachmentLoadOp<%d>", el); -} - -template <> -string ToStrHelper::Get(const VkAttachmentStoreOp &el) -{ - switch(el) - { - case VK_ATTACHMENT_STORE_OP_STORE: return "Store"; - case VK_ATTACHMENT_STORE_OP_DONT_CARE: return "Don't Care"; - default: break; - } - - return StringFormat::Fmt("VkAttachmentStoreOp<%d>", el); -} - -template <> -string ToStrHelper::Get(const VkStencilOp &el) -{ - switch(el) - { - case VK_STENCIL_OP_KEEP: return "KEEP"; - case VK_STENCIL_OP_ZERO: return "ZERO"; - case VK_STENCIL_OP_REPLACE: return "REPLACE"; - case VK_STENCIL_OP_INCREMENT_AND_CLAMP: return "INC_SAT"; - case VK_STENCIL_OP_DECREMENT_AND_CLAMP: return "DEC_SAT"; - case VK_STENCIL_OP_INVERT: return "INVERT"; - case VK_STENCIL_OP_INCREMENT_AND_WRAP: return "INC_WRAP"; - case VK_STENCIL_OP_DECREMENT_AND_WRAP: return "DEC_WRAP"; - default: break; - } - - return StringFormat::Fmt("VkStencilOp<%d>", el); -} - -template <> -string ToStrHelper::Get(const VkLogicOp &el) -{ - switch(el) - { - case VK_LOGIC_OP_CLEAR: return "CLEAR"; - case VK_LOGIC_OP_AND: return "AND"; - case VK_LOGIC_OP_AND_REVERSE: return "AND_REV"; - case VK_LOGIC_OP_COPY: return "COPY"; - case VK_LOGIC_OP_AND_INVERTED: return "AND_INV"; - case VK_LOGIC_OP_NO_OP: return "NOOP"; - case VK_LOGIC_OP_XOR: return "XOR"; - case VK_LOGIC_OP_OR: return "OR"; - case VK_LOGIC_OP_NOR: return "NOR"; - case VK_LOGIC_OP_EQUIVALENT: return "EQUIV"; - case VK_LOGIC_OP_INVERT: return "INVERT"; - case VK_LOGIC_OP_OR_REVERSE: return "OR_REV"; - case VK_LOGIC_OP_COPY_INVERTED: return "COPY_INV"; - case VK_LOGIC_OP_OR_INVERTED: return "OR_INV"; - case VK_LOGIC_OP_NAND: return "NAND"; - case VK_LOGIC_OP_SET: return "SET"; - default: break; - } - - return StringFormat::Fmt("VkLogicOp<%d>", el); -} - -template <> -string ToStrHelper::Get(const VkCompareOp &el) -{ - switch(el) - { - case VK_COMPARE_OP_NEVER: return "NEVER"; - case VK_COMPARE_OP_LESS: return "LESS"; - case VK_COMPARE_OP_EQUAL: return "EQUAL"; - case VK_COMPARE_OP_LESS_OR_EQUAL: return "LESS_EQUAL"; - case VK_COMPARE_OP_GREATER: return "GREATER"; - case VK_COMPARE_OP_NOT_EQUAL: return "NOT_EQUAL"; - case VK_COMPARE_OP_GREATER_OR_EQUAL: return "GREATER_EQUAL"; - case VK_COMPARE_OP_ALWAYS: return "ALWAYS"; - default: break; - } - - return StringFormat::Fmt("VkCompareOp<%d>", el); -} - -template <> -string ToStrHelper::Get(const VkFilter &el) -{ - switch(el) - { - case VK_FILTER_NEAREST: return "NEAREST"; - case VK_FILTER_LINEAR: return "LINEAR"; - default: break; - } - - return StringFormat::Fmt("VkFilter<%d>", el); -} - -template <> -string ToStrHelper::Get(const VkSamplerMipmapMode &el) -{ - switch(el) - { - case VK_SAMPLER_MIPMAP_MODE_NEAREST: return "NEAREST"; - case VK_SAMPLER_MIPMAP_MODE_LINEAR: return "LINEAR"; - default: break; - } - - return StringFormat::Fmt("VkTexMipmapMode<%d>", el); -} - -template <> -string ToStrHelper::Get(const VkSamplerAddressMode &el) -{ - switch(el) - { - case VK_SAMPLER_ADDRESS_MODE_REPEAT: return "WRAP"; - case VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT: return "MIRROR_WRAP"; - case VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE: return "CLAMP_EDGE"; - case VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER: return "CLAMP_BORDER"; - case VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE: return "MIRROR_CLAMP"; - default: break; - } - - return StringFormat::Fmt("VkSamplerAddressMode<%d>", el); -} - -template <> -string ToStrHelper::Get(const VkBorderColor &el) -{ - switch(el) - { - case VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK: return "float(0,0,0,0)"; - case VK_BORDER_COLOR_INT_TRANSPARENT_BLACK: return "int(0,0,0,0)"; - case VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK: return "float(0,0,0,1)"; - case VK_BORDER_COLOR_INT_OPAQUE_BLACK: return "int(0,0,0,1)"; - case VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE: return "float(1,1,1,1)"; - case VK_BORDER_COLOR_INT_OPAQUE_WHITE: return "int(1,1,1,1)"; - default: break; - } - - return StringFormat::Fmt("VkBorderColor<%d>", el); -} - -template <> -string ToStrHelper::Get(const VkPrimitiveTopology &el) -{ - switch(el) - { - TOSTR_CASE_STRINGIZE(VK_PRIMITIVE_TOPOLOGY_POINT_LIST) - TOSTR_CASE_STRINGIZE(VK_PRIMITIVE_TOPOLOGY_LINE_LIST) - TOSTR_CASE_STRINGIZE(VK_PRIMITIVE_TOPOLOGY_LINE_STRIP) - TOSTR_CASE_STRINGIZE(VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST) - TOSTR_CASE_STRINGIZE(VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP) - TOSTR_CASE_STRINGIZE(VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN) - TOSTR_CASE_STRINGIZE(VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY) - TOSTR_CASE_STRINGIZE(VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY) - TOSTR_CASE_STRINGIZE(VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY) - TOSTR_CASE_STRINGIZE(VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY) - TOSTR_CASE_STRINGIZE(VK_PRIMITIVE_TOPOLOGY_PATCH_LIST) - default: break; - } - - return StringFormat::Fmt("VkPrimitiveTopology<%d>", el); -} - -template <> -string ToStrHelper::Get(const VkDescriptorType &el) -{ - switch(el) - { - TOSTR_CASE_STRINGIZE(VK_DESCRIPTOR_TYPE_SAMPLER) - TOSTR_CASE_STRINGIZE(VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER) - TOSTR_CASE_STRINGIZE(VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE) - TOSTR_CASE_STRINGIZE(VK_DESCRIPTOR_TYPE_STORAGE_IMAGE) - TOSTR_CASE_STRINGIZE(VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER) - TOSTR_CASE_STRINGIZE(VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER) - TOSTR_CASE_STRINGIZE(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER) - TOSTR_CASE_STRINGIZE(VK_DESCRIPTOR_TYPE_STORAGE_BUFFER) - TOSTR_CASE_STRINGIZE(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC) - TOSTR_CASE_STRINGIZE(VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC) - TOSTR_CASE_STRINGIZE(VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT) - default: break; - } - - return StringFormat::Fmt("VkDescriptorType<%d>", el); -} - -template <> -string ToStrHelper::Get(const VkQueryType &el) -{ - switch(el) - { - TOSTR_CASE_STRINGIZE(VK_QUERY_TYPE_OCCLUSION) - TOSTR_CASE_STRINGIZE(VK_QUERY_TYPE_PIPELINE_STATISTICS) - TOSTR_CASE_STRINGIZE(VK_QUERY_TYPE_TIMESTAMP) - default: break; - } - - return StringFormat::Fmt("VkQueryType<%d>", el); -} - -template <> -string ToStrHelper::Get(const VkPhysicalDeviceType &el) -{ - switch(el) - { - TOSTR_CASE_STRINGIZE(VK_PHYSICAL_DEVICE_TYPE_OTHER) - TOSTR_CASE_STRINGIZE(VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU) - TOSTR_CASE_STRINGIZE(VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU) - TOSTR_CASE_STRINGIZE(VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU) - TOSTR_CASE_STRINGIZE(VK_PHYSICAL_DEVICE_TYPE_CPU) - default: break; - } - - return StringFormat::Fmt("VkPhysicalDeviceType<%d>", el); -} - -template <> -string ToStrHelper::Get(const VkMemoryHeapFlagBits &el) -{ - string ret; - - if(el & VK_MEMORY_HEAP_DEVICE_LOCAL_BIT) - ret += " | VK_MEMORY_HEAP_DEVICE_LOCAL_BIT"; - - if(!ret.empty()) - ret = ret.substr(3); - - if(ret.empty()) - return "-"; - - return ret; -} - -template <> -string ToStrHelper::Get(const VkMemoryPropertyFlagBits &el) -{ - string ret; - - if(el & VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT) - ret += " | VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT"; - if(el & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) - ret += " | VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT"; - if(el & VK_MEMORY_PROPERTY_HOST_COHERENT_BIT) - ret += " | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT"; - if(el & VK_MEMORY_PROPERTY_HOST_CACHED_BIT) - ret += " | VK_MEMORY_PROPERTY_HOST_CACHED_BIT"; - if(el & VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT) - ret += " | VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT"; - - if(!ret.empty()) - ret = ret.substr(3); - else - ret = "-"; - - return ret; -} - -template <> -string ToStrHelper::Get(const VkAccessFlagBits &el) -{ - string ret; - - if(el & VK_ACCESS_INDIRECT_COMMAND_READ_BIT) - ret += " | VK_ACCESS_INDIRECT_COMMAND_READ_BIT"; - if(el & VK_ACCESS_INDEX_READ_BIT) - ret += " | VK_ACCESS_INDEX_READ_BIT"; - if(el & VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT) - ret += " | VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT"; - if(el & VK_ACCESS_UNIFORM_READ_BIT) - ret += " | VK_ACCESS_UNIFORM_READ_BIT"; - if(el & VK_ACCESS_INPUT_ATTACHMENT_READ_BIT) - ret += " | VK_ACCESS_INPUT_ATTACHMENT_READ_BIT"; - if(el & VK_ACCESS_SHADER_READ_BIT) - ret += " | VK_ACCESS_SHADER_READ_BIT"; - if(el & VK_ACCESS_SHADER_WRITE_BIT) - ret += " | VK_ACCESS_SHADER_WRITE_BIT"; - if(el & VK_ACCESS_COLOR_ATTACHMENT_READ_BIT) - ret += " | VK_ACCESS_COLOR_ATTACHMENT_READ_BIT"; - if(el & VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT) - ret += " | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT"; - if(el & VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT) - ret += " | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT"; - if(el & VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT) - ret += " | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT"; - if(el & VK_ACCESS_TRANSFER_READ_BIT) - ret += " | VK_ACCESS_TRANSFER_READ_BIT"; - if(el & VK_ACCESS_TRANSFER_WRITE_BIT) - ret += " | VK_ACCESS_TRANSFER_WRITE_BIT"; - if(el & VK_ACCESS_HOST_READ_BIT) - ret += " | VK_ACCESS_HOST_READ_BIT"; - if(el & VK_ACCESS_HOST_WRITE_BIT) - ret += " | VK_ACCESS_HOST_WRITE_BIT"; - if(el & VK_ACCESS_MEMORY_READ_BIT) - ret += " | VK_ACCESS_MEMORY_READ_BIT"; - if(el & VK_ACCESS_MEMORY_WRITE_BIT) - ret += " | VK_ACCESS_MEMORY_WRITE_BIT"; - if(el & VK_ACCESS_COMMAND_PROCESS_READ_BIT_NVX) - ret += " | VK_ACCESS_COMMAND_PROCESS_READ_BIT_NVX"; - if(el & VK_ACCESS_COMMAND_PROCESS_WRITE_BIT_NVX) - ret += " | VK_ACCESS_COMMAND_PROCESS_WRITE_BIT_NVX"; - if(el & VK_ACCESS_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT) - ret += " | VK_ACCESS_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT"; - - if(!ret.empty()) - ret = ret.substr(3); - - return ret; -} - -template <> -string ToStrHelper::Get(const VkSharingMode &el) -{ - switch(el) - { - TOSTR_CASE_STRINGIZE(VK_SHARING_MODE_EXCLUSIVE) - TOSTR_CASE_STRINGIZE(VK_SHARING_MODE_CONCURRENT) - default: break; - } - - return StringFormat::Fmt("VkSharingMode<%d>", el); -} - -template <> -string ToStrHelper::Get(const VkCommandBufferLevel &el) -{ - switch(el) - { - TOSTR_CASE_STRINGIZE(VK_COMMAND_BUFFER_LEVEL_PRIMARY) - TOSTR_CASE_STRINGIZE(VK_COMMAND_BUFFER_LEVEL_SECONDARY) - default: break; - } - - return StringFormat::Fmt("VkCommandBufferLevel<%d>", el); -} - -template <> -string ToStrHelper::Get(const VkSubpassContents &el) -{ - switch(el) - { - TOSTR_CASE_STRINGIZE(VK_SUBPASS_CONTENTS_INLINE) - TOSTR_CASE_STRINGIZE(VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS) - default: break; - } - - return StringFormat::Fmt("VkSubpassContents<%d>", el); -} - -template <> -string ToStrHelper::Get(const VkImageLayout &el) -{ - switch(el) - { - case VK_IMAGE_LAYOUT_UNDEFINED: return "UNDEFINED"; - case VK_IMAGE_LAYOUT_GENERAL: return "GENERAL"; - case VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL: return "COLOR_ATTACHMENT_OPTIMAL"; - case VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL: - return "DEPTH_STENCIL_ATTACHMENT_OPTIMAL"; - case VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL: return "DEPTH_STENCIL_READ_ONLY_OPTIMAL"; - case VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL: return "SHADER_READ_ONLY_OPTIMAL"; - case VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL: return "TRANSFER_SRC_OPTIMAL"; - case VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL: return "TRANSFER_DST_OPTIMAL"; - case VK_IMAGE_LAYOUT_PREINITIALIZED: return "PREINITIALIZED"; - case VK_IMAGE_LAYOUT_PRESENT_SRC_KHR: return "PRESENT_SRC_KHR"; - case VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR: return "SHARED_PRESENT_SRC_KHR"; - default: break; - } - - return StringFormat::Fmt("VkImageLayout<%d>", el); -} - -template <> -string ToStrHelper::Get(const VkStructureType &el) -{ - switch(el) - { - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_APPLICATION_INFO) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_SUBMIT_INFO) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_BIND_SPARSE_INFO) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_FENCE_CREATE_INFO) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_EVENT_CREATE_INFO) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_MEMORY_BARRIER) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_PRESENT_INFO_KHR) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_MIR_SURFACE_CREATE_INFO_KHR) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO_KHX) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES_KHX) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES_KHX) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2_KHR) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2_KHR) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2_KHR) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2_KHR) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2_KHR) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2_KHR) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO_KHX) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO_KHX) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO_KHX) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO_KHX) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO_KHX) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHX) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO_KHX) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO_KHX) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHX) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHX) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHX) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHX) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHX) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_VI_SURFACE_CREATE_INFO_NN) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES_KHX) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO_KHX) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO_KHR) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES_KHR) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO_KHR) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES_KHR) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES_KHR) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO_KHR) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_KHR) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_KHR) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHR) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHR) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO_KHR) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES_KHR) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO_KHR) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES_KHR) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO_KHR) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_OBJECT_TABLE_CREATE_INFO_NVX) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NVX) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_CMD_PROCESS_COMMANDS_INFO_NVX) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_CMD_RESERVE_SPACE_FOR_COMMANDS_INFO_NVX) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_DEVICE_GENERATED_COMMANDS_LIMITS_NVX) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_DEVICE_GENERATED_COMMANDS_FEATURES_NVX) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_DISPLAY_POWER_INFO_EXT) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_DEVICE_EVENT_INFO_EXT) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_DISPLAY_EVENT_INFO_EXT) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_HDR_METADATA_EXT) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO_KHR) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES_KHR) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO_KHR) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_IMPORT_FENCE_WIN32_HANDLE_INFO_KHR) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_FENCE_GET_WIN32_HANDLE_INFO_KHR) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES_KHR) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO_KHR) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO_KHR) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO_KHR) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES_KHR) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS_KHR) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_KHR) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES_EXT) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO_EXT) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_MULTISAMPLE_PROPERTIES_EXT) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2_KHR) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2_KHR) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2_KHR) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2_KHR) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2_KHR) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO_KHR) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO_KHR) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO_KHR) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO_KHR) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO_KHR) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES_KHR) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES_KHR) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO_KHR) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO_KHR) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_VALIDATION_CACHE_CREATE_INFO_EXT) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT) - TOSTR_CASE_STRINGIZE(VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT) - default: break; - } - - return StringFormat::Fmt("VkStructureType<%d>", el); -} - -template <> -string ToStrHelper::Get(const VkComponentSwizzle &el) -{ - switch(el) - { - TOSTR_CASE_STRINGIZE(VK_COMPONENT_SWIZZLE_IDENTITY) - TOSTR_CASE_STRINGIZE(VK_COMPONENT_SWIZZLE_ZERO) - TOSTR_CASE_STRINGIZE(VK_COMPONENT_SWIZZLE_ONE) - TOSTR_CASE_STRINGIZE(VK_COMPONENT_SWIZZLE_R) - TOSTR_CASE_STRINGIZE(VK_COMPONENT_SWIZZLE_G) - TOSTR_CASE_STRINGIZE(VK_COMPONENT_SWIZZLE_B) - TOSTR_CASE_STRINGIZE(VK_COMPONENT_SWIZZLE_A) - default: break; - } - - return StringFormat::Fmt("VkComponentSwizzle<%d>", el); -} - -template <> -string ToStrHelper::Get(const VkFormat &el) -{ - switch(el) - { - TOSTR_CASE_STRINGIZE(VK_FORMAT_UNDEFINED) - TOSTR_CASE_STRINGIZE(VK_FORMAT_R4G4_UNORM_PACK8) - TOSTR_CASE_STRINGIZE(VK_FORMAT_R4G4B4A4_UNORM_PACK16) - TOSTR_CASE_STRINGIZE(VK_FORMAT_B4G4R4A4_UNORM_PACK16) - TOSTR_CASE_STRINGIZE(VK_FORMAT_R5G6B5_UNORM_PACK16) - TOSTR_CASE_STRINGIZE(VK_FORMAT_B5G6R5_UNORM_PACK16) - TOSTR_CASE_STRINGIZE(VK_FORMAT_R5G5B5A1_UNORM_PACK16) - TOSTR_CASE_STRINGIZE(VK_FORMAT_B5G5R5A1_UNORM_PACK16) - TOSTR_CASE_STRINGIZE(VK_FORMAT_A1R5G5B5_UNORM_PACK16) - TOSTR_CASE_STRINGIZE(VK_FORMAT_R8_UNORM) - TOSTR_CASE_STRINGIZE(VK_FORMAT_R8_SNORM) - TOSTR_CASE_STRINGIZE(VK_FORMAT_R8_USCALED) - TOSTR_CASE_STRINGIZE(VK_FORMAT_R8_SSCALED) - TOSTR_CASE_STRINGIZE(VK_FORMAT_R8_UINT) - TOSTR_CASE_STRINGIZE(VK_FORMAT_R8_SINT) - TOSTR_CASE_STRINGIZE(VK_FORMAT_R8_SRGB) - TOSTR_CASE_STRINGIZE(VK_FORMAT_R8G8_UNORM) - TOSTR_CASE_STRINGIZE(VK_FORMAT_R8G8_SNORM) - TOSTR_CASE_STRINGIZE(VK_FORMAT_R8G8_USCALED) - TOSTR_CASE_STRINGIZE(VK_FORMAT_R8G8_SSCALED) - TOSTR_CASE_STRINGIZE(VK_FORMAT_R8G8_UINT) - TOSTR_CASE_STRINGIZE(VK_FORMAT_R8G8_SINT) - TOSTR_CASE_STRINGIZE(VK_FORMAT_R8G8_SRGB) - TOSTR_CASE_STRINGIZE(VK_FORMAT_R8G8B8_UNORM) - TOSTR_CASE_STRINGIZE(VK_FORMAT_R8G8B8_SNORM) - TOSTR_CASE_STRINGIZE(VK_FORMAT_R8G8B8_USCALED) - TOSTR_CASE_STRINGIZE(VK_FORMAT_R8G8B8_SSCALED) - TOSTR_CASE_STRINGIZE(VK_FORMAT_R8G8B8_UINT) - TOSTR_CASE_STRINGIZE(VK_FORMAT_R8G8B8_SINT) - TOSTR_CASE_STRINGIZE(VK_FORMAT_R8G8B8_SRGB) - TOSTR_CASE_STRINGIZE(VK_FORMAT_B8G8R8_UNORM) - TOSTR_CASE_STRINGIZE(VK_FORMAT_B8G8R8_SNORM) - TOSTR_CASE_STRINGIZE(VK_FORMAT_B8G8R8_USCALED) - TOSTR_CASE_STRINGIZE(VK_FORMAT_B8G8R8_SSCALED) - TOSTR_CASE_STRINGIZE(VK_FORMAT_B8G8R8_UINT) - TOSTR_CASE_STRINGIZE(VK_FORMAT_B8G8R8_SINT) - TOSTR_CASE_STRINGIZE(VK_FORMAT_B8G8R8_SRGB) - TOSTR_CASE_STRINGIZE(VK_FORMAT_R8G8B8A8_UNORM) - TOSTR_CASE_STRINGIZE(VK_FORMAT_R8G8B8A8_SNORM) - TOSTR_CASE_STRINGIZE(VK_FORMAT_R8G8B8A8_USCALED) - TOSTR_CASE_STRINGIZE(VK_FORMAT_R8G8B8A8_SSCALED) - TOSTR_CASE_STRINGIZE(VK_FORMAT_R8G8B8A8_UINT) - TOSTR_CASE_STRINGIZE(VK_FORMAT_R8G8B8A8_SINT) - TOSTR_CASE_STRINGIZE(VK_FORMAT_R8G8B8A8_SRGB) - TOSTR_CASE_STRINGIZE(VK_FORMAT_B8G8R8A8_UNORM) - TOSTR_CASE_STRINGIZE(VK_FORMAT_B8G8R8A8_SNORM) - TOSTR_CASE_STRINGIZE(VK_FORMAT_B8G8R8A8_USCALED) - TOSTR_CASE_STRINGIZE(VK_FORMAT_B8G8R8A8_SSCALED) - TOSTR_CASE_STRINGIZE(VK_FORMAT_B8G8R8A8_UINT) - TOSTR_CASE_STRINGIZE(VK_FORMAT_B8G8R8A8_SINT) - TOSTR_CASE_STRINGIZE(VK_FORMAT_B8G8R8A8_SRGB) - TOSTR_CASE_STRINGIZE(VK_FORMAT_A8B8G8R8_UNORM_PACK32) - TOSTR_CASE_STRINGIZE(VK_FORMAT_A8B8G8R8_SNORM_PACK32) - TOSTR_CASE_STRINGIZE(VK_FORMAT_A8B8G8R8_USCALED_PACK32) - TOSTR_CASE_STRINGIZE(VK_FORMAT_A8B8G8R8_SSCALED_PACK32) - TOSTR_CASE_STRINGIZE(VK_FORMAT_A8B8G8R8_UINT_PACK32) - TOSTR_CASE_STRINGIZE(VK_FORMAT_A8B8G8R8_SINT_PACK32) - TOSTR_CASE_STRINGIZE(VK_FORMAT_A8B8G8R8_SRGB_PACK32) - TOSTR_CASE_STRINGIZE(VK_FORMAT_A2R10G10B10_UNORM_PACK32) - TOSTR_CASE_STRINGIZE(VK_FORMAT_A2R10G10B10_SNORM_PACK32) - TOSTR_CASE_STRINGIZE(VK_FORMAT_A2R10G10B10_USCALED_PACK32) - TOSTR_CASE_STRINGIZE(VK_FORMAT_A2R10G10B10_SSCALED_PACK32) - TOSTR_CASE_STRINGIZE(VK_FORMAT_A2R10G10B10_UINT_PACK32) - TOSTR_CASE_STRINGIZE(VK_FORMAT_A2R10G10B10_SINT_PACK32) - TOSTR_CASE_STRINGIZE(VK_FORMAT_A2B10G10R10_UNORM_PACK32) - TOSTR_CASE_STRINGIZE(VK_FORMAT_A2B10G10R10_SNORM_PACK32) - TOSTR_CASE_STRINGIZE(VK_FORMAT_A2B10G10R10_USCALED_PACK32) - TOSTR_CASE_STRINGIZE(VK_FORMAT_A2B10G10R10_SSCALED_PACK32) - TOSTR_CASE_STRINGIZE(VK_FORMAT_A2B10G10R10_UINT_PACK32) - TOSTR_CASE_STRINGIZE(VK_FORMAT_A2B10G10R10_SINT_PACK32) - TOSTR_CASE_STRINGIZE(VK_FORMAT_R16_UNORM) - TOSTR_CASE_STRINGIZE(VK_FORMAT_R16_SNORM) - TOSTR_CASE_STRINGIZE(VK_FORMAT_R16_USCALED) - TOSTR_CASE_STRINGIZE(VK_FORMAT_R16_SSCALED) - TOSTR_CASE_STRINGIZE(VK_FORMAT_R16_UINT) - TOSTR_CASE_STRINGIZE(VK_FORMAT_R16_SINT) - TOSTR_CASE_STRINGIZE(VK_FORMAT_R16_SFLOAT) - TOSTR_CASE_STRINGIZE(VK_FORMAT_R16G16_UNORM) - TOSTR_CASE_STRINGIZE(VK_FORMAT_R16G16_SNORM) - TOSTR_CASE_STRINGIZE(VK_FORMAT_R16G16_USCALED) - TOSTR_CASE_STRINGIZE(VK_FORMAT_R16G16_SSCALED) - TOSTR_CASE_STRINGIZE(VK_FORMAT_R16G16_UINT) - TOSTR_CASE_STRINGIZE(VK_FORMAT_R16G16_SINT) - TOSTR_CASE_STRINGIZE(VK_FORMAT_R16G16_SFLOAT) - TOSTR_CASE_STRINGIZE(VK_FORMAT_R16G16B16_UNORM) - TOSTR_CASE_STRINGIZE(VK_FORMAT_R16G16B16_SNORM) - TOSTR_CASE_STRINGIZE(VK_FORMAT_R16G16B16_USCALED) - TOSTR_CASE_STRINGIZE(VK_FORMAT_R16G16B16_SSCALED) - TOSTR_CASE_STRINGIZE(VK_FORMAT_R16G16B16_UINT) - TOSTR_CASE_STRINGIZE(VK_FORMAT_R16G16B16_SINT) - TOSTR_CASE_STRINGIZE(VK_FORMAT_R16G16B16_SFLOAT) - TOSTR_CASE_STRINGIZE(VK_FORMAT_R16G16B16A16_UNORM) - TOSTR_CASE_STRINGIZE(VK_FORMAT_R16G16B16A16_SNORM) - TOSTR_CASE_STRINGIZE(VK_FORMAT_R16G16B16A16_USCALED) - TOSTR_CASE_STRINGIZE(VK_FORMAT_R16G16B16A16_SSCALED) - TOSTR_CASE_STRINGIZE(VK_FORMAT_R16G16B16A16_UINT) - TOSTR_CASE_STRINGIZE(VK_FORMAT_R16G16B16A16_SINT) - TOSTR_CASE_STRINGIZE(VK_FORMAT_R16G16B16A16_SFLOAT) - TOSTR_CASE_STRINGIZE(VK_FORMAT_R32_UINT) - TOSTR_CASE_STRINGIZE(VK_FORMAT_R32_SINT) - TOSTR_CASE_STRINGIZE(VK_FORMAT_R32_SFLOAT) - TOSTR_CASE_STRINGIZE(VK_FORMAT_R32G32_UINT) - TOSTR_CASE_STRINGIZE(VK_FORMAT_R32G32_SINT) - TOSTR_CASE_STRINGIZE(VK_FORMAT_R32G32_SFLOAT) - TOSTR_CASE_STRINGIZE(VK_FORMAT_R32G32B32_UINT) - TOSTR_CASE_STRINGIZE(VK_FORMAT_R32G32B32_SINT) - TOSTR_CASE_STRINGIZE(VK_FORMAT_R32G32B32_SFLOAT) - TOSTR_CASE_STRINGIZE(VK_FORMAT_R32G32B32A32_UINT) - TOSTR_CASE_STRINGIZE(VK_FORMAT_R32G32B32A32_SINT) - TOSTR_CASE_STRINGIZE(VK_FORMAT_R32G32B32A32_SFLOAT) - TOSTR_CASE_STRINGIZE(VK_FORMAT_R64_UINT) - TOSTR_CASE_STRINGIZE(VK_FORMAT_R64_SINT) - TOSTR_CASE_STRINGIZE(VK_FORMAT_R64_SFLOAT) - TOSTR_CASE_STRINGIZE(VK_FORMAT_R64G64_UINT) - TOSTR_CASE_STRINGIZE(VK_FORMAT_R64G64_SINT) - TOSTR_CASE_STRINGIZE(VK_FORMAT_R64G64_SFLOAT) - TOSTR_CASE_STRINGIZE(VK_FORMAT_R64G64B64_UINT) - TOSTR_CASE_STRINGIZE(VK_FORMAT_R64G64B64_SINT) - TOSTR_CASE_STRINGIZE(VK_FORMAT_R64G64B64_SFLOAT) - TOSTR_CASE_STRINGIZE(VK_FORMAT_R64G64B64A64_UINT) - TOSTR_CASE_STRINGIZE(VK_FORMAT_R64G64B64A64_SINT) - TOSTR_CASE_STRINGIZE(VK_FORMAT_R64G64B64A64_SFLOAT) - TOSTR_CASE_STRINGIZE(VK_FORMAT_B10G11R11_UFLOAT_PACK32) - TOSTR_CASE_STRINGIZE(VK_FORMAT_E5B9G9R9_UFLOAT_PACK32) - TOSTR_CASE_STRINGIZE(VK_FORMAT_D16_UNORM) - TOSTR_CASE_STRINGIZE(VK_FORMAT_X8_D24_UNORM_PACK32) - TOSTR_CASE_STRINGIZE(VK_FORMAT_D32_SFLOAT) - TOSTR_CASE_STRINGIZE(VK_FORMAT_S8_UINT) - TOSTR_CASE_STRINGIZE(VK_FORMAT_D16_UNORM_S8_UINT) - TOSTR_CASE_STRINGIZE(VK_FORMAT_D24_UNORM_S8_UINT) - TOSTR_CASE_STRINGIZE(VK_FORMAT_D32_SFLOAT_S8_UINT) - TOSTR_CASE_STRINGIZE(VK_FORMAT_BC1_RGB_UNORM_BLOCK) - TOSTR_CASE_STRINGIZE(VK_FORMAT_BC1_RGB_SRGB_BLOCK) - TOSTR_CASE_STRINGIZE(VK_FORMAT_BC1_RGBA_UNORM_BLOCK) - TOSTR_CASE_STRINGIZE(VK_FORMAT_BC1_RGBA_SRGB_BLOCK) - TOSTR_CASE_STRINGIZE(VK_FORMAT_BC2_UNORM_BLOCK) - TOSTR_CASE_STRINGIZE(VK_FORMAT_BC2_SRGB_BLOCK) - TOSTR_CASE_STRINGIZE(VK_FORMAT_BC3_UNORM_BLOCK) - TOSTR_CASE_STRINGIZE(VK_FORMAT_BC3_SRGB_BLOCK) - TOSTR_CASE_STRINGIZE(VK_FORMAT_BC4_UNORM_BLOCK) - TOSTR_CASE_STRINGIZE(VK_FORMAT_BC4_SNORM_BLOCK) - TOSTR_CASE_STRINGIZE(VK_FORMAT_BC5_UNORM_BLOCK) - TOSTR_CASE_STRINGIZE(VK_FORMAT_BC5_SNORM_BLOCK) - TOSTR_CASE_STRINGIZE(VK_FORMAT_BC6H_UFLOAT_BLOCK) - TOSTR_CASE_STRINGIZE(VK_FORMAT_BC6H_SFLOAT_BLOCK) - TOSTR_CASE_STRINGIZE(VK_FORMAT_BC7_UNORM_BLOCK) - TOSTR_CASE_STRINGIZE(VK_FORMAT_BC7_SRGB_BLOCK) - TOSTR_CASE_STRINGIZE(VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK) - TOSTR_CASE_STRINGIZE(VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK) - TOSTR_CASE_STRINGIZE(VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK) - TOSTR_CASE_STRINGIZE(VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK) - TOSTR_CASE_STRINGIZE(VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK) - TOSTR_CASE_STRINGIZE(VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK) - TOSTR_CASE_STRINGIZE(VK_FORMAT_EAC_R11_UNORM_BLOCK) - TOSTR_CASE_STRINGIZE(VK_FORMAT_EAC_R11_SNORM_BLOCK) - TOSTR_CASE_STRINGIZE(VK_FORMAT_EAC_R11G11_UNORM_BLOCK) - TOSTR_CASE_STRINGIZE(VK_FORMAT_EAC_R11G11_SNORM_BLOCK) - TOSTR_CASE_STRINGIZE(VK_FORMAT_ASTC_4x4_UNORM_BLOCK) - TOSTR_CASE_STRINGIZE(VK_FORMAT_ASTC_4x4_SRGB_BLOCK) - TOSTR_CASE_STRINGIZE(VK_FORMAT_ASTC_5x4_UNORM_BLOCK) - TOSTR_CASE_STRINGIZE(VK_FORMAT_ASTC_5x4_SRGB_BLOCK) - TOSTR_CASE_STRINGIZE(VK_FORMAT_ASTC_5x5_UNORM_BLOCK) - TOSTR_CASE_STRINGIZE(VK_FORMAT_ASTC_5x5_SRGB_BLOCK) - TOSTR_CASE_STRINGIZE(VK_FORMAT_ASTC_6x5_UNORM_BLOCK) - TOSTR_CASE_STRINGIZE(VK_FORMAT_ASTC_6x5_SRGB_BLOCK) - TOSTR_CASE_STRINGIZE(VK_FORMAT_ASTC_6x6_UNORM_BLOCK) - TOSTR_CASE_STRINGIZE(VK_FORMAT_ASTC_6x6_SRGB_BLOCK) - TOSTR_CASE_STRINGIZE(VK_FORMAT_ASTC_8x5_UNORM_BLOCK) - TOSTR_CASE_STRINGIZE(VK_FORMAT_ASTC_8x5_SRGB_BLOCK) - TOSTR_CASE_STRINGIZE(VK_FORMAT_ASTC_8x6_UNORM_BLOCK) - TOSTR_CASE_STRINGIZE(VK_FORMAT_ASTC_8x6_SRGB_BLOCK) - TOSTR_CASE_STRINGIZE(VK_FORMAT_ASTC_8x8_UNORM_BLOCK) - TOSTR_CASE_STRINGIZE(VK_FORMAT_ASTC_8x8_SRGB_BLOCK) - TOSTR_CASE_STRINGIZE(VK_FORMAT_ASTC_10x5_UNORM_BLOCK) - TOSTR_CASE_STRINGIZE(VK_FORMAT_ASTC_10x5_SRGB_BLOCK) - TOSTR_CASE_STRINGIZE(VK_FORMAT_ASTC_10x6_UNORM_BLOCK) - TOSTR_CASE_STRINGIZE(VK_FORMAT_ASTC_10x6_SRGB_BLOCK) - TOSTR_CASE_STRINGIZE(VK_FORMAT_ASTC_10x8_UNORM_BLOCK) - TOSTR_CASE_STRINGIZE(VK_FORMAT_ASTC_10x8_SRGB_BLOCK) - TOSTR_CASE_STRINGIZE(VK_FORMAT_ASTC_10x10_UNORM_BLOCK) - TOSTR_CASE_STRINGIZE(VK_FORMAT_ASTC_10x10_SRGB_BLOCK) - TOSTR_CASE_STRINGIZE(VK_FORMAT_ASTC_12x10_UNORM_BLOCK) - TOSTR_CASE_STRINGIZE(VK_FORMAT_ASTC_12x10_SRGB_BLOCK) - TOSTR_CASE_STRINGIZE(VK_FORMAT_ASTC_12x12_UNORM_BLOCK) - TOSTR_CASE_STRINGIZE(VK_FORMAT_ASTC_12x12_SRGB_BLOCK) - TOSTR_CASE_STRINGIZE(VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG) - TOSTR_CASE_STRINGIZE(VK_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG) - TOSTR_CASE_STRINGIZE(VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG) - TOSTR_CASE_STRINGIZE(VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG) - TOSTR_CASE_STRINGIZE(VK_FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG) - TOSTR_CASE_STRINGIZE(VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG) - TOSTR_CASE_STRINGIZE(VK_FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG) - TOSTR_CASE_STRINGIZE(VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG) - default: break; - } - - return StringFormat::Fmt("VkFormat<%d>", el); -} - -template <> -string ToStrHelper::Get(const VkResult &el) -{ - switch(el) - { - TOSTR_CASE_STRINGIZE(VK_SUCCESS) - TOSTR_CASE_STRINGIZE(VK_NOT_READY) - TOSTR_CASE_STRINGIZE(VK_TIMEOUT) - TOSTR_CASE_STRINGIZE(VK_EVENT_SET) - TOSTR_CASE_STRINGIZE(VK_EVENT_RESET) - TOSTR_CASE_STRINGIZE(VK_INCOMPLETE) - TOSTR_CASE_STRINGIZE(VK_ERROR_OUT_OF_HOST_MEMORY) - TOSTR_CASE_STRINGIZE(VK_ERROR_OUT_OF_DEVICE_MEMORY) - TOSTR_CASE_STRINGIZE(VK_ERROR_INITIALIZATION_FAILED) - TOSTR_CASE_STRINGIZE(VK_ERROR_DEVICE_LOST) - TOSTR_CASE_STRINGIZE(VK_ERROR_MEMORY_MAP_FAILED) - TOSTR_CASE_STRINGIZE(VK_ERROR_LAYER_NOT_PRESENT) - TOSTR_CASE_STRINGIZE(VK_ERROR_EXTENSION_NOT_PRESENT) - TOSTR_CASE_STRINGIZE(VK_ERROR_FEATURE_NOT_PRESENT) - TOSTR_CASE_STRINGIZE(VK_ERROR_INCOMPATIBLE_DRIVER) - TOSTR_CASE_STRINGIZE(VK_ERROR_TOO_MANY_OBJECTS) - TOSTR_CASE_STRINGIZE(VK_ERROR_FORMAT_NOT_SUPPORTED) - TOSTR_CASE_STRINGIZE(VK_ERROR_SURFACE_LOST_KHR) - TOSTR_CASE_STRINGIZE(VK_ERROR_NATIVE_WINDOW_IN_USE_KHR) - TOSTR_CASE_STRINGIZE(VK_SUBOPTIMAL_KHR) - TOSTR_CASE_STRINGIZE(VK_ERROR_OUT_OF_DATE_KHR) - TOSTR_CASE_STRINGIZE(VK_ERROR_INCOMPATIBLE_DISPLAY_KHR) - TOSTR_CASE_STRINGIZE(VK_ERROR_VALIDATION_FAILED_EXT) - TOSTR_CASE_STRINGIZE(VK_ERROR_INVALID_SHADER_NV) - TOSTR_CASE_STRINGIZE(VK_ERROR_OUT_OF_POOL_MEMORY_KHR) - TOSTR_CASE_STRINGIZE(VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR) - default: break; - } - - return StringFormat::Fmt("VkResult<%d>", el); -} - -template <> -string ToStrHelper::Get(const VkMemoryType &el) -{ - return StringFormat::Fmt("VkMemoryType", el.heapIndex, - ToStr::Get((VkMemoryPropertyFlagBits)el.propertyFlags).c_str()); -} - -template <> -string ToStrHelper::Get(const VkMemoryHeap &el) -{ - return StringFormat::Fmt("VkMemoryHeap<%.3fMB, %s>", float(el.size) / (1024.0f * 1024.0f), - ToStr::Get((VkMemoryHeapFlagBits)el.flags).c_str()); -} - -template <> -string ToStrHelper::Get(const VkRect2D &el) -{ - return StringFormat::Fmt("VkRect2D<%dx%d+%d+%d>", el.extent.width, el.extent.height, el.offset.x, - el.offset.y); -} - -template <> -string ToStrHelper::Get(const VkClearRect &el) -{ - return StringFormat::Fmt("VkClearRect<%dx%d+%d+%d %u->%u>", el.rect.extent.width, - el.rect.extent.height, el.rect.offset.x, el.rect.offset.y, - el.baseArrayLayer, el.baseArrayLayer + el.layerCount); -} - -template <> -string ToStrHelper::Get(const VkClearAttachment &el) -{ - return StringFormat::Fmt("%s[%u] = %s", ToStr::Get((VkImageAspectFlagBits)el.aspectMask).c_str(), - el.colorAttachment, ToStr::Get(el.clearValue).c_str()); -} - -template <> -string ToStrHelper::Get(const VkQueueFamilyProperties &el) -{ - return StringFormat::Fmt( - "%s x %u, %u bits, %s", ToStr::Get((VkQueueFlagBits)el.queueFlags).c_str(), el.queueCount, - el.timestampValidBits, ToStr::Get(el.minImageTransferGranularity).c_str()); -} - -template <> -string ToStrHelper::Get(const VkExtent2D &el) -{ - return StringFormat::Fmt("VkExtent<%u,%u>", el.width, el.height); -} - -template <> -string ToStrHelper::Get(const VkExtent3D &el) -{ - return StringFormat::Fmt("VkExtent<%u,%u,%u>", el.width, el.height, el.depth); -} - -template <> -string ToStrHelper::Get(const VkOffset2D &el) -{ - return StringFormat::Fmt("VkOffset<%d,%d>", el.x, el.y); -} - -template <> -string ToStrHelper::Get(const VkOffset3D &el) -{ - return StringFormat::Fmt("VkOffset<%d,%d,%d>", el.x, el.y, el.z); -} - -template <> -string ToStrHelper::Get(const VkViewport &el) -{ - return StringFormat::Fmt("VkViewport<%f,%f, %fx%f, %f-%f>", el.x, el.y, el.width, el.height, - el.minDepth, el.maxDepth); -} - -template <> -string ToStrHelper::Get(const VkClearColorValue &el) -{ - return StringFormat::Fmt("VkClearColorValue<%f,%f,%f,%f>", el.float32[0], el.float32[1], - el.float32[2], el.float32[3]); -} -template <> -string ToStrHelper::Get(const VkClearDepthStencilValue &el) -{ - return StringFormat::Fmt("VkClearDepthStencilValue<%f %u>", el.depth, el.stencil); -} -template <> -string ToStrHelper::Get(const VkClearValue &el) -{ - return StringFormat::Fmt("VkClearValue[ col:<%f,%f,%f,%f> / d:%f s:%u ]", el.color.float32[0], - el.color.float32[1], el.color.float32[2], el.color.float32[3], - el.depthStencil.depth, el.depthStencil.stencil); -} - -template <> -string ToStrHelper::Get(const VkAttachmentReference &el) -{ - return StringFormat::Fmt("VkAttachmentReference<%u, %s>", el.attachment, - ToStr::Get(el.layout).c_str()); -} - -//////////////////////////////////////////////////////////// -// VK_KHR_surface -//////////////////////////////////////////////////////////// - -template <> -string ToStrHelper::Get(const VkSurfaceTransformFlagBitsKHR &el) -{ - string ret; - - if(el & VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR) - ret += " | VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR"; - if(el & VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR) - ret += " | VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR"; - if(el & VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR) - ret += " | VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR"; - if(el & VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR) - ret += " | VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR"; - if(el & VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR) - ret += " | VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR"; - if(el & VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR) - ret += " | VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR"; - if(el & VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR) - ret += " | VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR"; - if(el & VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR) - ret += " | VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR"; - - if(!ret.empty()) - ret = ret.substr(3); - - return ret; -} - -template <> -string ToStrHelper::Get(const VkCompositeAlphaFlagBitsKHR &el) -{ - string ret; - - if(el & VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR) - ret += " | VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR"; - if(el & VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR) - ret += " | VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR"; - if(el & VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR) - ret += " | VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR"; - if(el & VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR) - ret += " | VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR"; - - if(!ret.empty()) - ret = ret.substr(3); - - return ret; -} - -template <> -string ToStrHelper::Get(const VkColorSpaceKHR &el) -{ - switch(el) - { - TOSTR_CASE_STRINGIZE(VK_COLORSPACE_SRGB_NONLINEAR_KHR) - default: break; - } - - return StringFormat::Fmt("VkColorSpaceKHR<%d>", el); -} - -template <> -string ToStrHelper::Get(const VkPresentModeKHR &el) -{ - switch(el) - { - TOSTR_CASE_STRINGIZE(VK_PRESENT_MODE_IMMEDIATE_KHR) - TOSTR_CASE_STRINGIZE(VK_PRESENT_MODE_MAILBOX_KHR) - TOSTR_CASE_STRINGIZE(VK_PRESENT_MODE_FIFO_KHR) - TOSTR_CASE_STRINGIZE(VK_PRESENT_MODE_FIFO_RELAXED_KHR) - default: break; - } - - return StringFormat::Fmt("VkPresentModeKHR<%d>", el); -} - // we know the object will be a non-dispatchable object type #define SerialiseObjectInternal(type, name, obj, opt) \ { \ diff --git a/renderdoc/driver/vulkan/vk_common.h b/renderdoc/driver/vulkan/vk_common.h index 82a428560..cdae6f3e9 100644 --- a/renderdoc/driver/vulkan/vk_common.h +++ b/renderdoc/driver/vulkan/vk_common.h @@ -193,6 +193,13 @@ struct VkGenericStruct const VkGenericStruct *pNext; }; +// we cast to this type when serialising as a placeholder indicating that +// the given flags field doesn't have any bits defined +enum VkFlagWithNoBits +{ + FlagWithNoBits_Dummy_Bit = 1, +}; + // utility function for when we're modifying one struct in a pNext chain, this // lets us just copy across a struct unmodified into some temporary memory and // append it onto a pNext chain we're building diff --git a/renderdoc/driver/vulkan/vk_core.cpp b/renderdoc/driver/vulkan/vk_core.cpp index e2810e83b..3343c3e26 100644 --- a/renderdoc/driver/vulkan/vk_core.cpp +++ b/renderdoc/driver/vulkan/vk_core.cpp @@ -584,7 +584,7 @@ const char *WrappedVulkan::GetChunkName(uint32_t idx) } template <> -string ToStrHelper::Get(const VulkanChunkType &el) +std::string DoStringise(const VulkanChunkType &el) { return WrappedVulkan::GetChunkName(el); } diff --git a/renderdoc/driver/vulkan/vk_debug.cpp b/renderdoc/driver/vulkan/vk_debug.cpp index 58bf91abb..2bfbc0c11 100644 --- a/renderdoc/driver/vulkan/vk_debug.cpp +++ b/renderdoc/driver/vulkan/vk_debug.cpp @@ -928,7 +928,7 @@ VulkanDebugManager::VulkanDebugManager(WrappedVulkan *driver, VkDevice dev) VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT)) { RDCDEBUG("Depth copies MSAA -> Array not supported for format %s", - ToStr::Get(attDesc.format).c_str()); + ToStr(attDesc.format).c_str()); continue; } @@ -959,7 +959,7 @@ VulkanDebugManager::VulkanDebugManager(WrappedVulkan *driver, VkDevice dev) (uint32_t)attDesc.samples)) { RDCDEBUG("Depth copies Array -> MSAA not supported for sample count %u on format %s", - attDesc.samples, ToStr::Get(attDesc.format).c_str()); + attDesc.samples, ToStr(attDesc.format).c_str()); continue; } @@ -1962,7 +1962,7 @@ VulkanDebugManager::VulkanDebugManager(WrappedVulkan *driver, VkDevice dev) string defines = ""; if(texelFetchBrokenDriver) defines += "#define NO_TEXEL_FETCH\n"; - defines += string("#define SHADER_RESTYPE ") + ToStr::Get(t) + "\n"; + defines += string("#define SHADER_RESTYPE ") + ToStr(t) + "\n"; defines += string("#define UINT_TEX ") + (f == 1 ? "1" : "0") + "\n"; defines += string("#define SINT_TEX ") + (f == 2 ? "1" : "0") + "\n"; @@ -3289,7 +3289,7 @@ void VulkanDebugManager::CopyTex2DMSToArray(VkImage destArray, VkImage srcMS, Vk if(viewInfo.format == VK_FORMAT_UNDEFINED) { - RDCERR("Can't copy 2D to Array with format %s", ToStr::Get(fmt).c_str()); + RDCERR("Can't copy 2D to Array with format %s", ToStr(fmt).c_str()); return; } @@ -3632,7 +3632,7 @@ void VulkanDebugManager::CopyArrayToTex2DMS(VkImage destMS, VkImage srcArray, Vk if(viewInfo.format == VK_FORMAT_UNDEFINED) { - RDCERR("Can't copy Array to MS with format %s", ToStr::Get(fmt).c_str()); + RDCERR("Can't copy Array to MS with format %s", ToStr(fmt).c_str()); return; } diff --git a/renderdoc/driver/vulkan/vk_manager.cpp b/renderdoc/driver/vulkan/vk_manager.cpp index b4d581dc9..c733661c1 100644 --- a/renderdoc/driver/vulkan/vk_manager.cpp +++ b/renderdoc/driver/vulkan/vk_manager.cpp @@ -415,11 +415,10 @@ void VulkanResourceManager::ApplyBarriers(vector%u, %u->%u) from %s to %s", - ToStr::Get(t.subresourceRange.aspect).c_str(), t.subresourceRange.baseMipLevel, - t.subresourceRange.levelCount, t.subresourceRange.baseArrayLayer, - t.subresourceRange.layerCount, ToStr::Get(t.oldLayout).c_str(), - ToStr::Get(t.newLayout).c_str()); + TRDBG("Barrier of %s (%u->%u, %u->%u) from %s to %s", ToStr(t.subresourceRange.aspect).c_str(), + t.subresourceRange.baseMipLevel, t.subresourceRange.levelCount, + t.subresourceRange.baseArrayLayer, t.subresourceRange.layerCount, + ToStr(t.oldLayout).c_str(), ToStr(t.newLayout).c_str()); bool done = false; @@ -428,10 +427,9 @@ void VulkanResourceManager::ApplyBarriers(vectorsecond.subresourceStates.begin(); for(; it != stit->second.subresourceStates.end(); ++it) { - TRDBG(".. state %s (%u->%u, %u->%u) from %s to %s", - ToStr::Get(it->subresourceRange.aspect).c_str(), it->range.baseMipLevel, - it->range.levelCount, it->range.baseArrayLayer, it->range.layerCount, - ToStr::Get(it->oldLayout).c_str(), ToStr::Get(it->newLayout).c_str()); + TRDBG(".. state %s (%u->%u, %u->%u) from %s to %s", ToStr(it->subresourceRange.aspect).c_str(), + it->range.baseMipLevel, it->range.levelCount, it->range.baseArrayLayer, + it->range.layerCount, ToStr(it->oldLayout).c_str(), ToStr(it->newLayout).c_str()); // image barriers are handled by initially inserting one subresource range for the whole // object, diff --git a/renderdoc/driver/vulkan/vk_replay.cpp b/renderdoc/driver/vulkan/vk_replay.cpp index 868e35403..135b904fe 100644 --- a/renderdoc/driver/vulkan/vk_replay.cpp +++ b/renderdoc/driver/vulkan/vk_replay.cpp @@ -3447,7 +3447,7 @@ void VulkanReplay::SavePipelineState() img.layouts.resize(it->second.subresourceStates.size()); for(size_t l = 0; l < it->second.subresourceStates.size(); l++) { - img.layouts[l].name = ToStr::Get(it->second.subresourceStates[l].newLayout); + img.layouts[l].name = ToStr(it->second.subresourceStates[l].newLayout); img.layouts[l].baseMip = it->second.subresourceStates[l].subresourceRange.baseMipLevel; img.layouts[l].baseLayer = it->second.subresourceStates[l].subresourceRange.baseArrayLayer; img.layouts[l].numLayer = it->second.subresourceStates[l].subresourceRange.layerCount; diff --git a/renderdoc/driver/vulkan/vk_stringise.cpp b/renderdoc/driver/vulkan/vk_stringise.cpp new file mode 100644 index 000000000..1ab231677 --- /dev/null +++ b/renderdoc/driver/vulkan/vk_stringise.cpp @@ -0,0 +1,1486 @@ +/****************************************************************************** + * The MIT License (MIT) + * + * Copyright (c) 2017 Baldur Karlsson + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ + +#include "vk_common.h" +#include "vk_resources.h" + +template <> +std::string DoStringise(const VkResourceType &el) +{ + BEGIN_ENUM_STRINGISE(VkResourceType); + { + STRINGISE_ENUM(eResUnknown) + STRINGISE_ENUM(eResPhysicalDevice) + STRINGISE_ENUM(eResInstance) + STRINGISE_ENUM(eResDevice) + STRINGISE_ENUM(eResQueue) + STRINGISE_ENUM(eResDeviceMemory) + STRINGISE_ENUM(eResBuffer) + STRINGISE_ENUM(eResBufferView) + STRINGISE_ENUM(eResImage) + STRINGISE_ENUM(eResImageView) + STRINGISE_ENUM(eResFramebuffer) + STRINGISE_ENUM(eResRenderPass) + STRINGISE_ENUM(eResShaderModule) + STRINGISE_ENUM(eResPipelineCache) + STRINGISE_ENUM(eResPipelineLayout) + STRINGISE_ENUM(eResPipeline) + STRINGISE_ENUM(eResSampler) + STRINGISE_ENUM(eResDescriptorPool) + STRINGISE_ENUM(eResDescriptorSetLayout) + STRINGISE_ENUM(eResDescriptorSet) + STRINGISE_ENUM(eResCommandPool) + STRINGISE_ENUM(eResCommandBuffer) + STRINGISE_ENUM(eResFence) + STRINGISE_ENUM(eResEvent) + STRINGISE_ENUM(eResQueryPool) + STRINGISE_ENUM(eResSemaphore) + STRINGISE_ENUM(eResSwapchain) + STRINGISE_ENUM(eResSurface) + } + END_ENUM_STRINGISE(); +} + +template <> +std::string DoStringise(const VkFlagWithNoBits &el) +{ + if(el != 0) + return StringFormat::Fmt("Invalid bits set: %x", el); + return ""; +} + +template <> +std::string DoStringise(const VkQueueFlagBits &el) +{ + BEGIN_BITFIELD_STRINGISE(VkQueueFlagBits); + { + STRINGISE_BITFIELD_BIT(VK_QUEUE_GRAPHICS_BIT); + STRINGISE_BITFIELD_BIT(VK_QUEUE_COMPUTE_BIT); + STRINGISE_BITFIELD_BIT(VK_QUEUE_TRANSFER_BIT); + STRINGISE_BITFIELD_BIT(VK_QUEUE_SPARSE_BINDING_BIT); + } + END_BITFIELD_STRINGISE(); +} + +template <> +std::string DoStringise(const VkPipelineCreateFlagBits &el) +{ + BEGIN_BITFIELD_STRINGISE(VkPipelineCreateFlagBits); + { + STRINGISE_BITFIELD_BIT(VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT); + STRINGISE_BITFIELD_BIT(VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT); + STRINGISE_BITFIELD_BIT(VK_PIPELINE_CREATE_DERIVATIVE_BIT); + } + END_BITFIELD_STRINGISE(); +} + +template <> +std::string DoStringise(const VkPipelineStageFlagBits &el) +{ + BEGIN_BITFIELD_STRINGISE(VkPipelineStageFlagBits); + { + STRINGISE_BITFIELD_BIT(VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT); + STRINGISE_BITFIELD_BIT(VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT); + STRINGISE_BITFIELD_BIT(VK_PIPELINE_STAGE_VERTEX_INPUT_BIT); + STRINGISE_BITFIELD_BIT(VK_PIPELINE_STAGE_VERTEX_SHADER_BIT); + STRINGISE_BITFIELD_BIT(VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT); + STRINGISE_BITFIELD_BIT(VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT); + STRINGISE_BITFIELD_BIT(VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT); + STRINGISE_BITFIELD_BIT(VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT); + STRINGISE_BITFIELD_BIT(VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT); + STRINGISE_BITFIELD_BIT(VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT); + STRINGISE_BITFIELD_BIT(VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT); + STRINGISE_BITFIELD_BIT(VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT); + STRINGISE_BITFIELD_BIT(VK_PIPELINE_STAGE_TRANSFER_BIT); + STRINGISE_BITFIELD_BIT(VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT); + STRINGISE_BITFIELD_BIT(VK_PIPELINE_STAGE_HOST_BIT); + STRINGISE_BITFIELD_BIT(VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT); + STRINGISE_BITFIELD_BIT(VK_PIPELINE_STAGE_ALL_COMMANDS_BIT); + STRINGISE_BITFIELD_BIT(VK_PIPELINE_STAGE_COMMAND_PROCESS_BIT_NVX); + } + END_BITFIELD_STRINGISE(); +} + +template <> +std::string DoStringise(const VkBufferUsageFlagBits &el) +{ + BEGIN_BITFIELD_STRINGISE(VkBufferUsageFlagBits); + { + STRINGISE_BITFIELD_BIT(VK_BUFFER_USAGE_TRANSFER_SRC_BIT); + STRINGISE_BITFIELD_BIT(VK_BUFFER_USAGE_TRANSFER_DST_BIT); + STRINGISE_BITFIELD_BIT(VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT); + STRINGISE_BITFIELD_BIT(VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT); + STRINGISE_BITFIELD_BIT(VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT); + STRINGISE_BITFIELD_BIT(VK_BUFFER_USAGE_STORAGE_BUFFER_BIT); + STRINGISE_BITFIELD_BIT(VK_BUFFER_USAGE_INDEX_BUFFER_BIT); + STRINGISE_BITFIELD_BIT(VK_BUFFER_USAGE_VERTEX_BUFFER_BIT); + STRINGISE_BITFIELD_BIT(VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT); + } + END_BITFIELD_STRINGISE(); +} + +template <> +std::string DoStringise(const VkImageUsageFlagBits &el) +{ + BEGIN_BITFIELD_STRINGISE(VkImageUsageFlagBits); + { + STRINGISE_BITFIELD_BIT(VK_IMAGE_USAGE_TRANSFER_SRC_BIT); + STRINGISE_BITFIELD_BIT(VK_IMAGE_USAGE_TRANSFER_DST_BIT); + STRINGISE_BITFIELD_BIT(VK_IMAGE_USAGE_SAMPLED_BIT); + STRINGISE_BITFIELD_BIT(VK_IMAGE_USAGE_STORAGE_BIT); + STRINGISE_BITFIELD_BIT(VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT); + STRINGISE_BITFIELD_BIT(VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT); + STRINGISE_BITFIELD_BIT(VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT); + STRINGISE_BITFIELD_BIT(VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT); + } + END_BITFIELD_STRINGISE(); +} + +template <> +std::string DoStringise(const VkBufferCreateFlagBits &el) +{ + BEGIN_BITFIELD_STRINGISE(VkBufferCreateFlagBits); + { + STRINGISE_BITFIELD_BIT(VK_BUFFER_CREATE_SPARSE_BINDING_BIT); + STRINGISE_BITFIELD_BIT(VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT); + STRINGISE_BITFIELD_BIT(VK_BUFFER_CREATE_SPARSE_ALIASED_BIT); + } + END_BITFIELD_STRINGISE(); +} + +template <> +std::string DoStringise(const VkImageCreateFlagBits &el) +{ + BEGIN_BITFIELD_STRINGISE(VkImageCreateFlagBits); + { + STRINGISE_BITFIELD_BIT(VK_IMAGE_CREATE_SPARSE_BINDING_BIT); + STRINGISE_BITFIELD_BIT(VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT); + STRINGISE_BITFIELD_BIT(VK_IMAGE_CREATE_SPARSE_ALIASED_BIT); + STRINGISE_BITFIELD_BIT(VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT); + STRINGISE_BITFIELD_BIT(VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT); + STRINGISE_BITFIELD_BIT(VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT_KHR); + } + END_BITFIELD_STRINGISE(); +} + +template <> +std::string DoStringise(const VkSparseMemoryBindFlagBits &el) +{ + BEGIN_BITFIELD_STRINGISE(VkSparseMemoryBindFlagBits); + { + STRINGISE_BITFIELD_BIT(VK_SPARSE_MEMORY_BIND_METADATA_BIT); + } + END_BITFIELD_STRINGISE(); +} + +template <> +std::string DoStringise(const VkCommandPoolCreateFlagBits &el) +{ + BEGIN_BITFIELD_STRINGISE(VkCommandPoolCreateFlagBits); + { + STRINGISE_BITFIELD_BIT(VK_COMMAND_POOL_CREATE_TRANSIENT_BIT); + STRINGISE_BITFIELD_BIT(VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT); + } + END_BITFIELD_STRINGISE(); +} + +template <> +std::string DoStringise(const VkCommandPoolResetFlagBits &el) +{ + BEGIN_BITFIELD_STRINGISE(VkCommandPoolResetFlagBits); + { + STRINGISE_BITFIELD_BIT(VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT); + } + END_BITFIELD_STRINGISE(); +} + +template <> +std::string DoStringise(const VkCommandBufferUsageFlagBits &el) +{ + BEGIN_BITFIELD_STRINGISE(VkCommandBufferUsageFlagBits); + { + STRINGISE_BITFIELD_BIT(VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT); + STRINGISE_BITFIELD_BIT(VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT); + STRINGISE_BITFIELD_BIT(VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT); + } + END_BITFIELD_STRINGISE(); +} + +template <> +std::string DoStringise(const VkDescriptorPoolCreateFlagBits &el) +{ + BEGIN_BITFIELD_STRINGISE(VkDescriptorPoolCreateFlagBits); + { + STRINGISE_BITFIELD_BIT(VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT); + } + END_BITFIELD_STRINGISE(); +} + +template <> +std::string DoStringise(const VkFenceCreateFlagBits &el) +{ + BEGIN_BITFIELD_STRINGISE(VkFenceCreateFlagBits); + { + STRINGISE_BITFIELD_BIT(VK_FENCE_CREATE_SIGNALED_BIT); + } + END_BITFIELD_STRINGISE(); +} + +template <> +std::string DoStringise(const VkQueryPipelineStatisticFlagBits &el) +{ + BEGIN_BITFIELD_STRINGISE(VkQueryPipelineStatisticFlagBits); + { + STRINGISE_BITFIELD_BIT(VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT); + STRINGISE_BITFIELD_BIT(VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT); + STRINGISE_BITFIELD_BIT(VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT); + STRINGISE_BITFIELD_BIT(VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT); + STRINGISE_BITFIELD_BIT(VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT); + STRINGISE_BITFIELD_BIT(VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT); + STRINGISE_BITFIELD_BIT(VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT); + STRINGISE_BITFIELD_BIT(VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT); + STRINGISE_BITFIELD_BIT(VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT); + STRINGISE_BITFIELD_BIT(VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT); + STRINGISE_BITFIELD_BIT(VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT); + } + END_BITFIELD_STRINGISE(); +} + +template <> +std::string DoStringise(const VkQueryControlFlagBits &el) +{ + BEGIN_BITFIELD_STRINGISE(VkQueryControlFlagBits); + { + STRINGISE_BITFIELD_BIT(VK_QUERY_CONTROL_PRECISE_BIT); + } + END_BITFIELD_STRINGISE(); +} + +template <> +std::string DoStringise(const VkQueryResultFlagBits &el) +{ + BEGIN_BITFIELD_STRINGISE(VkQueryResultFlagBits); + { + STRINGISE_BITFIELD_BIT(VK_QUERY_RESULT_64_BIT); + STRINGISE_BITFIELD_BIT(VK_QUERY_RESULT_WAIT_BIT); + STRINGISE_BITFIELD_BIT(VK_QUERY_RESULT_WITH_AVAILABILITY_BIT); + STRINGISE_BITFIELD_BIT(VK_QUERY_RESULT_PARTIAL_BIT); + } + END_BITFIELD_STRINGISE(); +} + +template <> +std::string DoStringise(const VkAttachmentDescriptionFlagBits &el) +{ + BEGIN_BITFIELD_STRINGISE(VkAttachmentDescriptionFlagBits); + { + STRINGISE_BITFIELD_BIT(VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT); + } + END_BITFIELD_STRINGISE(); +} + +template <> +std::string DoStringise(const VkSampleCountFlagBits &el) +{ + BEGIN_BITFIELD_STRINGISE(VkSampleCountFlagBits); + { + STRINGISE_BITFIELD_BIT(VK_SAMPLE_COUNT_1_BIT); + STRINGISE_BITFIELD_BIT(VK_SAMPLE_COUNT_2_BIT); + STRINGISE_BITFIELD_BIT(VK_SAMPLE_COUNT_4_BIT); + STRINGISE_BITFIELD_BIT(VK_SAMPLE_COUNT_8_BIT); + STRINGISE_BITFIELD_BIT(VK_SAMPLE_COUNT_16_BIT); + STRINGISE_BITFIELD_BIT(VK_SAMPLE_COUNT_32_BIT); + STRINGISE_BITFIELD_BIT(VK_SAMPLE_COUNT_64_BIT); + } + END_BITFIELD_STRINGISE(); +} + +template <> +std::string DoStringise(const VkImageAspectFlagBits &el) +{ + BEGIN_BITFIELD_STRINGISE(VkImageAspectFlagBits); + { + STRINGISE_BITFIELD_BIT(VK_IMAGE_ASPECT_COLOR_BIT); + STRINGISE_BITFIELD_BIT(VK_IMAGE_ASPECT_DEPTH_BIT); + STRINGISE_BITFIELD_BIT(VK_IMAGE_ASPECT_STENCIL_BIT); + STRINGISE_BITFIELD_BIT(VK_IMAGE_ASPECT_METADATA_BIT); + } + END_BITFIELD_STRINGISE(); +} + +template <> +std::string DoStringise(const VkDependencyFlagBits &el) +{ + BEGIN_BITFIELD_STRINGISE(VkDependencyFlagBits); + { + STRINGISE_BITFIELD_BIT(VK_DEPENDENCY_BY_REGION_BIT); + } + END_BITFIELD_STRINGISE(); +} + +template <> +std::string DoStringise(const VkShaderStageFlagBits &el) +{ + BEGIN_BITFIELD_STRINGISE(VkShaderStageFlagBits); + { + STRINGISE_BITFIELD_VALUE(VK_SHADER_STAGE_ALL_GRAPHICS); + STRINGISE_BITFIELD_VALUE(VK_SHADER_STAGE_ALL); + + STRINGISE_BITFIELD_BIT(VK_SHADER_STAGE_VERTEX_BIT); + STRINGISE_BITFIELD_BIT(VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT); + STRINGISE_BITFIELD_BIT(VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT); + STRINGISE_BITFIELD_BIT(VK_SHADER_STAGE_GEOMETRY_BIT); + STRINGISE_BITFIELD_BIT(VK_SHADER_STAGE_FRAGMENT_BIT); + STRINGISE_BITFIELD_BIT(VK_SHADER_STAGE_COMPUTE_BIT); + } + END_BITFIELD_STRINGISE(); +} + +template <> +std::string DoStringise(const VkMemoryHeapFlagBits &el) +{ + BEGIN_BITFIELD_STRINGISE(VkMemoryHeapFlagBits); + { + STRINGISE_BITFIELD_BIT(VK_MEMORY_HEAP_DEVICE_LOCAL_BIT); + } + END_BITFIELD_STRINGISE(); +} + +template <> +std::string DoStringise(const VkMemoryPropertyFlagBits &el) +{ + BEGIN_BITFIELD_STRINGISE(VkMemoryPropertyFlagBits); + { + STRINGISE_BITFIELD_BIT(VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT); + STRINGISE_BITFIELD_BIT(VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT); + STRINGISE_BITFIELD_BIT(VK_MEMORY_PROPERTY_HOST_COHERENT_BIT); + STRINGISE_BITFIELD_BIT(VK_MEMORY_PROPERTY_HOST_CACHED_BIT); + STRINGISE_BITFIELD_BIT(VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT); + } + END_BITFIELD_STRINGISE(); +} + +template <> +std::string DoStringise(const VkAccessFlagBits &el) +{ + BEGIN_BITFIELD_STRINGISE(VkAccessFlagBits); + { + STRINGISE_BITFIELD_BIT(VK_ACCESS_INDIRECT_COMMAND_READ_BIT); + STRINGISE_BITFIELD_BIT(VK_ACCESS_INDEX_READ_BIT); + STRINGISE_BITFIELD_BIT(VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT); + STRINGISE_BITFIELD_BIT(VK_ACCESS_UNIFORM_READ_BIT); + STRINGISE_BITFIELD_BIT(VK_ACCESS_INPUT_ATTACHMENT_READ_BIT); + STRINGISE_BITFIELD_BIT(VK_ACCESS_SHADER_READ_BIT); + STRINGISE_BITFIELD_BIT(VK_ACCESS_SHADER_WRITE_BIT); + STRINGISE_BITFIELD_BIT(VK_ACCESS_COLOR_ATTACHMENT_READ_BIT); + STRINGISE_BITFIELD_BIT(VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT); + STRINGISE_BITFIELD_BIT(VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT); + STRINGISE_BITFIELD_BIT(VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT); + STRINGISE_BITFIELD_BIT(VK_ACCESS_TRANSFER_READ_BIT); + STRINGISE_BITFIELD_BIT(VK_ACCESS_TRANSFER_WRITE_BIT); + STRINGISE_BITFIELD_BIT(VK_ACCESS_HOST_READ_BIT); + STRINGISE_BITFIELD_BIT(VK_ACCESS_HOST_WRITE_BIT); + STRINGISE_BITFIELD_BIT(VK_ACCESS_MEMORY_READ_BIT); + STRINGISE_BITFIELD_BIT(VK_ACCESS_MEMORY_WRITE_BIT); + STRINGISE_BITFIELD_BIT(VK_ACCESS_COMMAND_PROCESS_READ_BIT_NVX); + STRINGISE_BITFIELD_BIT(VK_ACCESS_COMMAND_PROCESS_WRITE_BIT_NVX); + STRINGISE_BITFIELD_BIT(VK_ACCESS_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT); + } + END_BITFIELD_STRINGISE(); +} + +template <> +std::string DoStringise(const VkStencilFaceFlagBits &el) +{ + // technically a bitfield but each combination has a particular meaning + BEGIN_ENUM_STRINGISE(VkStencilFaceFlagBits); + { + STRINGISE_ENUM(VK_STENCIL_FACE_FRONT_BIT); + STRINGISE_ENUM(VK_STENCIL_FACE_BACK_BIT); + STRINGISE_ENUM(VK_STENCIL_FRONT_AND_BACK); + } + END_ENUM_STRINGISE(); +} + +template <> +std::string DoStringise(const VkCullModeFlagBits &el) +{ + // technically a bitfield but each combination has a particular meaning + BEGIN_ENUM_STRINGISE(VkCullModeFlagBits); + { + STRINGISE_ENUM(VK_CULL_MODE_NONE); + STRINGISE_ENUM(VK_CULL_MODE_FRONT_BIT); + STRINGISE_ENUM(VK_CULL_MODE_BACK_BIT); + STRINGISE_ENUM(VK_CULL_MODE_FRONT_AND_BACK); + } + END_ENUM_STRINGISE(); +} + +template <> +std::string DoStringise(const VkPipelineBindPoint &el) +{ + BEGIN_ENUM_STRINGISE(VkPipelineBindPoint); + { + STRINGISE_ENUM(VK_PIPELINE_BIND_POINT_COMPUTE) + STRINGISE_ENUM(VK_PIPELINE_BIND_POINT_GRAPHICS) + } + END_ENUM_STRINGISE(); +} + +template <> +std::string DoStringise(const VkIndexType &el) +{ + BEGIN_ENUM_STRINGISE(VkIndexType); + { + STRINGISE_ENUM(VK_INDEX_TYPE_UINT16) + STRINGISE_ENUM(VK_INDEX_TYPE_UINT32) + } + END_ENUM_STRINGISE(); +} + +template <> +std::string DoStringise(const VkImageType &el) +{ + BEGIN_ENUM_STRINGISE(VkImageType); + { + STRINGISE_ENUM(VK_IMAGE_TYPE_1D) + STRINGISE_ENUM(VK_IMAGE_TYPE_2D) + STRINGISE_ENUM(VK_IMAGE_TYPE_3D) + } + END_ENUM_STRINGISE(); +} + +template <> +std::string DoStringise(const VkImageTiling &el) +{ + BEGIN_ENUM_STRINGISE(VkImageTiling); + { + STRINGISE_ENUM(VK_IMAGE_TILING_LINEAR) + STRINGISE_ENUM(VK_IMAGE_TILING_OPTIMAL) + } + END_ENUM_STRINGISE(); +} + +template <> +std::string DoStringise(const VkImageViewType &el) +{ + BEGIN_ENUM_STRINGISE(VkImageViewType); + { + STRINGISE_ENUM(VK_IMAGE_VIEW_TYPE_1D) + STRINGISE_ENUM(VK_IMAGE_VIEW_TYPE_2D) + STRINGISE_ENUM(VK_IMAGE_VIEW_TYPE_3D) + STRINGISE_ENUM(VK_IMAGE_VIEW_TYPE_CUBE) + STRINGISE_ENUM(VK_IMAGE_VIEW_TYPE_1D_ARRAY) + STRINGISE_ENUM(VK_IMAGE_VIEW_TYPE_2D_ARRAY) + STRINGISE_ENUM(VK_IMAGE_VIEW_TYPE_CUBE_ARRAY) + } + END_ENUM_STRINGISE(); +} + +template <> +std::string DoStringise(const VkVertexInputRate &el) +{ + BEGIN_ENUM_STRINGISE(VkVertexInputRate); + { + STRINGISE_ENUM(VK_VERTEX_INPUT_RATE_VERTEX) + STRINGISE_ENUM(VK_VERTEX_INPUT_RATE_INSTANCE) + } + END_ENUM_STRINGISE(); +} + +template <> +std::string DoStringise(const VkPolygonMode &el) +{ + BEGIN_ENUM_STRINGISE(VkPolygonMode); + { + STRINGISE_ENUM(VK_POLYGON_MODE_FILL) + STRINGISE_ENUM(VK_POLYGON_MODE_LINE) + STRINGISE_ENUM(VK_POLYGON_MODE_POINT) + STRINGISE_ENUM(VK_POLYGON_MODE_FILL_RECTANGLE_NV) + } + END_ENUM_STRINGISE(); +} + +template <> +std::string DoStringise(const VkFrontFace &el) +{ + BEGIN_ENUM_STRINGISE(VkFrontFace); + { + STRINGISE_ENUM(VK_FRONT_FACE_COUNTER_CLOCKWISE) + STRINGISE_ENUM(VK_FRONT_FACE_CLOCKWISE) + } + END_ENUM_STRINGISE(); +} + +template <> +std::string DoStringise(const VkBlendFactor &el) +{ + BEGIN_ENUM_STRINGISE(VkBlendFactor); + { + STRINGISE_ENUM(VK_BLEND_FACTOR_ZERO); + STRINGISE_ENUM(VK_BLEND_FACTOR_ONE); + STRINGISE_ENUM(VK_BLEND_FACTOR_SRC_COLOR); + STRINGISE_ENUM(VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR); + STRINGISE_ENUM(VK_BLEND_FACTOR_DST_COLOR); + STRINGISE_ENUM(VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR); + STRINGISE_ENUM(VK_BLEND_FACTOR_SRC_ALPHA); + STRINGISE_ENUM(VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA); + STRINGISE_ENUM(VK_BLEND_FACTOR_DST_ALPHA); + STRINGISE_ENUM(VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA); + STRINGISE_ENUM(VK_BLEND_FACTOR_CONSTANT_COLOR); + STRINGISE_ENUM(VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR); + STRINGISE_ENUM(VK_BLEND_FACTOR_CONSTANT_ALPHA); + STRINGISE_ENUM(VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA); + STRINGISE_ENUM(VK_BLEND_FACTOR_SRC_ALPHA_SATURATE); + STRINGISE_ENUM(VK_BLEND_FACTOR_SRC1_COLOR); + STRINGISE_ENUM(VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR); + STRINGISE_ENUM(VK_BLEND_FACTOR_SRC1_ALPHA); + STRINGISE_ENUM(VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA); + } + END_ENUM_STRINGISE(); +} + +template <> +std::string DoStringise(const VkBlendOp &el) +{ + // Need to update this when we support VK_EXT_blend_operation_advanced + BEGIN_ENUM_STRINGISE(VkBlendOp); + { + STRINGISE_ENUM(VK_BLEND_OP_ADD); + STRINGISE_ENUM(VK_BLEND_OP_SUBTRACT); + STRINGISE_ENUM(VK_BLEND_OP_REVERSE_SUBTRACT); + STRINGISE_ENUM(VK_BLEND_OP_MIN); + STRINGISE_ENUM(VK_BLEND_OP_MAX); + } + END_ENUM_STRINGISE(); +} + +template <> +std::string DoStringise(const VkDynamicState &el) +{ + BEGIN_ENUM_STRINGISE(VkDynamicState); + { + STRINGISE_ENUM(VK_DYNAMIC_STATE_VIEWPORT) + STRINGISE_ENUM(VK_DYNAMIC_STATE_SCISSOR) + STRINGISE_ENUM(VK_DYNAMIC_STATE_LINE_WIDTH) + STRINGISE_ENUM(VK_DYNAMIC_STATE_DEPTH_BIAS) + STRINGISE_ENUM(VK_DYNAMIC_STATE_BLEND_CONSTANTS) + STRINGISE_ENUM(VK_DYNAMIC_STATE_DEPTH_BOUNDS) + STRINGISE_ENUM(VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK) + STRINGISE_ENUM(VK_DYNAMIC_STATE_STENCIL_WRITE_MASK) + STRINGISE_ENUM(VK_DYNAMIC_STATE_STENCIL_REFERENCE) + } + END_ENUM_STRINGISE(); +} + +template <> +std::string DoStringise(const VkAttachmentLoadOp &el) +{ + BEGIN_ENUM_STRINGISE(VkAttachmentLoadOp); + { + case VK_ATTACHMENT_LOAD_OP_LOAD: return "Load"; + case VK_ATTACHMENT_LOAD_OP_CLEAR: return "Clear"; + case VK_ATTACHMENT_LOAD_OP_DONT_CARE: return "Don't Care"; + } + END_ENUM_STRINGISE(); +} + +template <> +std::string DoStringise(const VkAttachmentStoreOp &el) +{ + BEGIN_ENUM_STRINGISE(VkAttachmentStoreOp); + { + case VK_ATTACHMENT_STORE_OP_STORE: return "Store"; + case VK_ATTACHMENT_STORE_OP_DONT_CARE: return "Don't Care"; + } + END_ENUM_STRINGISE(); +} + +template <> +std::string DoStringise(const VkStencilOp &el) +{ + BEGIN_ENUM_STRINGISE(VkStencilOp); + { + STRINGISE_ENUM(VK_STENCIL_OP_KEEP); + STRINGISE_ENUM(VK_STENCIL_OP_ZERO); + STRINGISE_ENUM(VK_STENCIL_OP_REPLACE); + STRINGISE_ENUM(VK_STENCIL_OP_INCREMENT_AND_CLAMP); + STRINGISE_ENUM(VK_STENCIL_OP_DECREMENT_AND_CLAMP); + STRINGISE_ENUM(VK_STENCIL_OP_INVERT); + STRINGISE_ENUM(VK_STENCIL_OP_INCREMENT_AND_WRAP); + STRINGISE_ENUM(VK_STENCIL_OP_DECREMENT_AND_WRAP); + } + END_ENUM_STRINGISE(); +} + +template <> +std::string DoStringise(const VkLogicOp &el) +{ + BEGIN_ENUM_STRINGISE(VkLogicOp); + { + STRINGISE_ENUM(VK_LOGIC_OP_CLEAR); + STRINGISE_ENUM(VK_LOGIC_OP_AND); + STRINGISE_ENUM(VK_LOGIC_OP_AND_REVERSE); + STRINGISE_ENUM(VK_LOGIC_OP_COPY); + STRINGISE_ENUM(VK_LOGIC_OP_AND_INVERTED); + STRINGISE_ENUM(VK_LOGIC_OP_NO_OP); + STRINGISE_ENUM(VK_LOGIC_OP_XOR); + STRINGISE_ENUM(VK_LOGIC_OP_OR); + STRINGISE_ENUM(VK_LOGIC_OP_NOR); + STRINGISE_ENUM(VK_LOGIC_OP_EQUIVALENT); + STRINGISE_ENUM(VK_LOGIC_OP_INVERT); + STRINGISE_ENUM(VK_LOGIC_OP_OR_REVERSE); + STRINGISE_ENUM(VK_LOGIC_OP_COPY_INVERTED); + STRINGISE_ENUM(VK_LOGIC_OP_OR_INVERTED); + STRINGISE_ENUM(VK_LOGIC_OP_NAND); + STRINGISE_ENUM(VK_LOGIC_OP_SET); + } + END_ENUM_STRINGISE(); +} + +template <> +std::string DoStringise(const VkCompareOp &el) +{ + BEGIN_ENUM_STRINGISE(VkCompareOp); + { + STRINGISE_ENUM(VK_COMPARE_OP_NEVER); + STRINGISE_ENUM(VK_COMPARE_OP_LESS); + STRINGISE_ENUM(VK_COMPARE_OP_EQUAL); + STRINGISE_ENUM(VK_COMPARE_OP_LESS_OR_EQUAL); + STRINGISE_ENUM(VK_COMPARE_OP_GREATER); + STRINGISE_ENUM(VK_COMPARE_OP_NOT_EQUAL); + STRINGISE_ENUM(VK_COMPARE_OP_GREATER_OR_EQUAL); + STRINGISE_ENUM(VK_COMPARE_OP_ALWAYS); + } + END_ENUM_STRINGISE(); +} + +template <> +std::string DoStringise(const VkFilter &el) +{ + BEGIN_ENUM_STRINGISE(VkFilter); + { + STRINGISE_ENUM(VK_FILTER_NEAREST); + STRINGISE_ENUM(VK_FILTER_LINEAR); + } + END_ENUM_STRINGISE(); +} + +template <> +std::string DoStringise(const VkSamplerMipmapMode &el) +{ + BEGIN_ENUM_STRINGISE(VkSamplerMipmapMode); + { + STRINGISE_ENUM(VK_SAMPLER_MIPMAP_MODE_NEAREST); + STRINGISE_ENUM(VK_SAMPLER_MIPMAP_MODE_LINEAR); + } + END_ENUM_STRINGISE(); +} + +template <> +std::string DoStringise(const VkSamplerAddressMode &el) +{ + BEGIN_ENUM_STRINGISE(VkSamplerAddressMode); + { + STRINGISE_ENUM(VK_SAMPLER_ADDRESS_MODE_REPEAT); + STRINGISE_ENUM(VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT); + STRINGISE_ENUM(VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE); + STRINGISE_ENUM(VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER); + STRINGISE_ENUM(VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE); + } + END_ENUM_STRINGISE(); +} + +template <> +std::string DoStringise(const VkBorderColor &el) +{ + BEGIN_ENUM_STRINGISE(VkBorderColor); + { + STRINGISE_ENUM(VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK); + STRINGISE_ENUM(VK_BORDER_COLOR_INT_TRANSPARENT_BLACK); + STRINGISE_ENUM(VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK); + STRINGISE_ENUM(VK_BORDER_COLOR_INT_OPAQUE_BLACK); + STRINGISE_ENUM(VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE); + STRINGISE_ENUM(VK_BORDER_COLOR_INT_OPAQUE_WHITE); + } + END_ENUM_STRINGISE(); +} + +template <> +std::string DoStringise(const VkPrimitiveTopology &el) +{ + BEGIN_ENUM_STRINGISE(VkPrimitiveTopology); + { + STRINGISE_ENUM(VK_PRIMITIVE_TOPOLOGY_POINT_LIST) + STRINGISE_ENUM(VK_PRIMITIVE_TOPOLOGY_LINE_LIST) + STRINGISE_ENUM(VK_PRIMITIVE_TOPOLOGY_LINE_STRIP) + STRINGISE_ENUM(VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST) + STRINGISE_ENUM(VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP) + STRINGISE_ENUM(VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN) + STRINGISE_ENUM(VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY) + STRINGISE_ENUM(VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY) + STRINGISE_ENUM(VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY) + STRINGISE_ENUM(VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY) + STRINGISE_ENUM(VK_PRIMITIVE_TOPOLOGY_PATCH_LIST) + } + END_ENUM_STRINGISE(); +} + +template <> +std::string DoStringise(const VkDescriptorType &el) +{ + BEGIN_ENUM_STRINGISE(VkDescriptorType); + { + STRINGISE_ENUM(VK_DESCRIPTOR_TYPE_SAMPLER) + STRINGISE_ENUM(VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER) + STRINGISE_ENUM(VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE) + STRINGISE_ENUM(VK_DESCRIPTOR_TYPE_STORAGE_IMAGE) + STRINGISE_ENUM(VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER) + STRINGISE_ENUM(VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER) + STRINGISE_ENUM(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER) + STRINGISE_ENUM(VK_DESCRIPTOR_TYPE_STORAGE_BUFFER) + STRINGISE_ENUM(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC) + STRINGISE_ENUM(VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC) + STRINGISE_ENUM(VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT) + } + END_ENUM_STRINGISE(); +} + +template <> +std::string DoStringise(const VkQueryType &el) +{ + BEGIN_ENUM_STRINGISE(VkQueryType); + { + STRINGISE_ENUM(VK_QUERY_TYPE_OCCLUSION) + STRINGISE_ENUM(VK_QUERY_TYPE_PIPELINE_STATISTICS) + STRINGISE_ENUM(VK_QUERY_TYPE_TIMESTAMP) + } + END_ENUM_STRINGISE(); +} + +template <> +std::string DoStringise(const VkPhysicalDeviceType &el) +{ + BEGIN_ENUM_STRINGISE(VkPhysicalDeviceType); + { + STRINGISE_ENUM(VK_PHYSICAL_DEVICE_TYPE_OTHER) + STRINGISE_ENUM(VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU) + STRINGISE_ENUM(VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU) + STRINGISE_ENUM(VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU) + STRINGISE_ENUM(VK_PHYSICAL_DEVICE_TYPE_CPU) + } + END_ENUM_STRINGISE(); +} + +template <> +std::string DoStringise(const VkSharingMode &el) +{ + BEGIN_ENUM_STRINGISE(VkSharingMode); + { + STRINGISE_ENUM(VK_SHARING_MODE_EXCLUSIVE) + STRINGISE_ENUM(VK_SHARING_MODE_CONCURRENT) + } + END_ENUM_STRINGISE(); +} + +template <> +std::string DoStringise(const VkCommandBufferLevel &el) +{ + BEGIN_ENUM_STRINGISE(VkCommandBufferLevel); + { + STRINGISE_ENUM(VK_COMMAND_BUFFER_LEVEL_PRIMARY) + STRINGISE_ENUM(VK_COMMAND_BUFFER_LEVEL_SECONDARY) + } + END_ENUM_STRINGISE(); +} + +template <> +std::string DoStringise(const VkSubpassContents &el) +{ + BEGIN_ENUM_STRINGISE(VkSubpassContents); + { + STRINGISE_ENUM(VK_SUBPASS_CONTENTS_INLINE) + STRINGISE_ENUM(VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS) + } + END_ENUM_STRINGISE(); +} + +template <> +std::string DoStringise(const VkImageLayout &el) +{ + BEGIN_ENUM_STRINGISE(VkImageLayout); + { + STRINGISE_ENUM_NAMED(VK_IMAGE_LAYOUT_UNDEFINED, "UNDEFINED"); + STRINGISE_ENUM_NAMED(VK_IMAGE_LAYOUT_GENERAL, "GENERAL"); + STRINGISE_ENUM_NAMED(VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, "COLOR_ATTACHMENT_OPTIMAL"); + STRINGISE_ENUM_NAMED(VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, + "DEPTH_STENCIL_ATTACHMENT_OPTIMAL"); + STRINGISE_ENUM_NAMED(VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL, + "DEPTH_STENCIL_READ_ONLY_OPTIMAL"); + STRINGISE_ENUM_NAMED(VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, "SHADER_READ_ONLY_OPTIMAL"); + STRINGISE_ENUM_NAMED(VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, "TRANSFER_SRC_OPTIMAL"); + STRINGISE_ENUM_NAMED(VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, "TRANSFER_DST_OPTIMAL"); + STRINGISE_ENUM_NAMED(VK_IMAGE_LAYOUT_PREINITIALIZED, "PREINITIALIZED"); + STRINGISE_ENUM_NAMED(VK_IMAGE_LAYOUT_PRESENT_SRC_KHR, "PRESENT_SRC_KHR"); + STRINGISE_ENUM_NAMED(VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR, "SHARED_PRESENT_SRC_KHR"); + } + END_ENUM_STRINGISE(); +} + +template <> +std::string DoStringise(const VkStructureType &el) +{ + BEGIN_ENUM_STRINGISE(VkStructureType); + { + STRINGISE_ENUM(VK_STRUCTURE_TYPE_APPLICATION_INFO) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_SUBMIT_INFO) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_BIND_SPARSE_INFO) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_FENCE_CREATE_INFO) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_EVENT_CREATE_INFO) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_MEMORY_BARRIER) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_PRESENT_INFO_KHR) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_MIR_SURFACE_CREATE_INFO_KHR) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO_KHX) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES_KHX) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES_KHX) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2_KHR) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2_KHR) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2_KHR) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2_KHR) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2_KHR) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2_KHR) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO_KHX) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO_KHX) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO_KHX) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO_KHX) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO_KHX) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHX) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO_KHX) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO_KHX) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHX) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHX) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHX) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHX) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHX) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_VI_SURFACE_CREATE_INFO_NN) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES_KHX) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO_KHX) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO_KHR) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES_KHR) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO_KHR) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES_KHR) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES_KHR) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO_KHR) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_KHR) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_KHR) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHR) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHR) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO_KHR) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES_KHR) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO_KHR) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES_KHR) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO_KHR) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_OBJECT_TABLE_CREATE_INFO_NVX) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NVX) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_CMD_PROCESS_COMMANDS_INFO_NVX) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_CMD_RESERVE_SPACE_FOR_COMMANDS_INFO_NVX) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_DEVICE_GENERATED_COMMANDS_LIMITS_NVX) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_DEVICE_GENERATED_COMMANDS_FEATURES_NVX) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_DISPLAY_POWER_INFO_EXT) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_DEVICE_EVENT_INFO_EXT) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_DISPLAY_EVENT_INFO_EXT) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_HDR_METADATA_EXT) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO_KHR) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES_KHR) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO_KHR) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_IMPORT_FENCE_WIN32_HANDLE_INFO_KHR) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_FENCE_GET_WIN32_HANDLE_INFO_KHR) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES_KHR) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO_KHR) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO_KHR) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO_KHR) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES_KHR) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS_KHR) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_KHR) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES_EXT) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO_EXT) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_MULTISAMPLE_PROPERTIES_EXT) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2_KHR) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2_KHR) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2_KHR) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2_KHR) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2_KHR) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO_KHR) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO_KHR) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO_KHR) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO_KHR) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO_KHR) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES_KHR) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES_KHR) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO_KHR) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO_KHR) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_VALIDATION_CACHE_CREATE_INFO_EXT) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT) + STRINGISE_ENUM(VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT) + } + END_ENUM_STRINGISE(); +} + +template <> +std::string DoStringise(const VkComponentSwizzle &el) +{ + BEGIN_ENUM_STRINGISE(VkComponentSwizzle); + { + STRINGISE_ENUM(VK_COMPONENT_SWIZZLE_IDENTITY) + STRINGISE_ENUM(VK_COMPONENT_SWIZZLE_ZERO) + STRINGISE_ENUM(VK_COMPONENT_SWIZZLE_ONE) + STRINGISE_ENUM(VK_COMPONENT_SWIZZLE_R) + STRINGISE_ENUM(VK_COMPONENT_SWIZZLE_G) + STRINGISE_ENUM(VK_COMPONENT_SWIZZLE_B) + STRINGISE_ENUM(VK_COMPONENT_SWIZZLE_A) + } + END_ENUM_STRINGISE(); +} + +template <> +std::string DoStringise(const VkFormat &el) +{ + BEGIN_ENUM_STRINGISE(VkFormat); + { + STRINGISE_ENUM(VK_FORMAT_UNDEFINED) + STRINGISE_ENUM(VK_FORMAT_R4G4_UNORM_PACK8) + STRINGISE_ENUM(VK_FORMAT_R4G4B4A4_UNORM_PACK16) + STRINGISE_ENUM(VK_FORMAT_B4G4R4A4_UNORM_PACK16) + STRINGISE_ENUM(VK_FORMAT_R5G6B5_UNORM_PACK16) + STRINGISE_ENUM(VK_FORMAT_B5G6R5_UNORM_PACK16) + STRINGISE_ENUM(VK_FORMAT_R5G5B5A1_UNORM_PACK16) + STRINGISE_ENUM(VK_FORMAT_B5G5R5A1_UNORM_PACK16) + STRINGISE_ENUM(VK_FORMAT_A1R5G5B5_UNORM_PACK16) + STRINGISE_ENUM(VK_FORMAT_R8_UNORM) + STRINGISE_ENUM(VK_FORMAT_R8_SNORM) + STRINGISE_ENUM(VK_FORMAT_R8_USCALED) + STRINGISE_ENUM(VK_FORMAT_R8_SSCALED) + STRINGISE_ENUM(VK_FORMAT_R8_UINT) + STRINGISE_ENUM(VK_FORMAT_R8_SINT) + STRINGISE_ENUM(VK_FORMAT_R8_SRGB) + STRINGISE_ENUM(VK_FORMAT_R8G8_UNORM) + STRINGISE_ENUM(VK_FORMAT_R8G8_SNORM) + STRINGISE_ENUM(VK_FORMAT_R8G8_USCALED) + STRINGISE_ENUM(VK_FORMAT_R8G8_SSCALED) + STRINGISE_ENUM(VK_FORMAT_R8G8_UINT) + STRINGISE_ENUM(VK_FORMAT_R8G8_SINT) + STRINGISE_ENUM(VK_FORMAT_R8G8_SRGB) + STRINGISE_ENUM(VK_FORMAT_R8G8B8_UNORM) + STRINGISE_ENUM(VK_FORMAT_R8G8B8_SNORM) + STRINGISE_ENUM(VK_FORMAT_R8G8B8_USCALED) + STRINGISE_ENUM(VK_FORMAT_R8G8B8_SSCALED) + STRINGISE_ENUM(VK_FORMAT_R8G8B8_UINT) + STRINGISE_ENUM(VK_FORMAT_R8G8B8_SINT) + STRINGISE_ENUM(VK_FORMAT_R8G8B8_SRGB) + STRINGISE_ENUM(VK_FORMAT_B8G8R8_UNORM) + STRINGISE_ENUM(VK_FORMAT_B8G8R8_SNORM) + STRINGISE_ENUM(VK_FORMAT_B8G8R8_USCALED) + STRINGISE_ENUM(VK_FORMAT_B8G8R8_SSCALED) + STRINGISE_ENUM(VK_FORMAT_B8G8R8_UINT) + STRINGISE_ENUM(VK_FORMAT_B8G8R8_SINT) + STRINGISE_ENUM(VK_FORMAT_B8G8R8_SRGB) + STRINGISE_ENUM(VK_FORMAT_R8G8B8A8_UNORM) + STRINGISE_ENUM(VK_FORMAT_R8G8B8A8_SNORM) + STRINGISE_ENUM(VK_FORMAT_R8G8B8A8_USCALED) + STRINGISE_ENUM(VK_FORMAT_R8G8B8A8_SSCALED) + STRINGISE_ENUM(VK_FORMAT_R8G8B8A8_UINT) + STRINGISE_ENUM(VK_FORMAT_R8G8B8A8_SINT) + STRINGISE_ENUM(VK_FORMAT_R8G8B8A8_SRGB) + STRINGISE_ENUM(VK_FORMAT_B8G8R8A8_UNORM) + STRINGISE_ENUM(VK_FORMAT_B8G8R8A8_SNORM) + STRINGISE_ENUM(VK_FORMAT_B8G8R8A8_USCALED) + STRINGISE_ENUM(VK_FORMAT_B8G8R8A8_SSCALED) + STRINGISE_ENUM(VK_FORMAT_B8G8R8A8_UINT) + STRINGISE_ENUM(VK_FORMAT_B8G8R8A8_SINT) + STRINGISE_ENUM(VK_FORMAT_B8G8R8A8_SRGB) + STRINGISE_ENUM(VK_FORMAT_A8B8G8R8_UNORM_PACK32) + STRINGISE_ENUM(VK_FORMAT_A8B8G8R8_SNORM_PACK32) + STRINGISE_ENUM(VK_FORMAT_A8B8G8R8_USCALED_PACK32) + STRINGISE_ENUM(VK_FORMAT_A8B8G8R8_SSCALED_PACK32) + STRINGISE_ENUM(VK_FORMAT_A8B8G8R8_UINT_PACK32) + STRINGISE_ENUM(VK_FORMAT_A8B8G8R8_SINT_PACK32) + STRINGISE_ENUM(VK_FORMAT_A8B8G8R8_SRGB_PACK32) + STRINGISE_ENUM(VK_FORMAT_A2R10G10B10_UNORM_PACK32) + STRINGISE_ENUM(VK_FORMAT_A2R10G10B10_SNORM_PACK32) + STRINGISE_ENUM(VK_FORMAT_A2R10G10B10_USCALED_PACK32) + STRINGISE_ENUM(VK_FORMAT_A2R10G10B10_SSCALED_PACK32) + STRINGISE_ENUM(VK_FORMAT_A2R10G10B10_UINT_PACK32) + STRINGISE_ENUM(VK_FORMAT_A2R10G10B10_SINT_PACK32) + STRINGISE_ENUM(VK_FORMAT_A2B10G10R10_UNORM_PACK32) + STRINGISE_ENUM(VK_FORMAT_A2B10G10R10_SNORM_PACK32) + STRINGISE_ENUM(VK_FORMAT_A2B10G10R10_USCALED_PACK32) + STRINGISE_ENUM(VK_FORMAT_A2B10G10R10_SSCALED_PACK32) + STRINGISE_ENUM(VK_FORMAT_A2B10G10R10_UINT_PACK32) + STRINGISE_ENUM(VK_FORMAT_A2B10G10R10_SINT_PACK32) + STRINGISE_ENUM(VK_FORMAT_R16_UNORM) + STRINGISE_ENUM(VK_FORMAT_R16_SNORM) + STRINGISE_ENUM(VK_FORMAT_R16_USCALED) + STRINGISE_ENUM(VK_FORMAT_R16_SSCALED) + STRINGISE_ENUM(VK_FORMAT_R16_UINT) + STRINGISE_ENUM(VK_FORMAT_R16_SINT) + STRINGISE_ENUM(VK_FORMAT_R16_SFLOAT) + STRINGISE_ENUM(VK_FORMAT_R16G16_UNORM) + STRINGISE_ENUM(VK_FORMAT_R16G16_SNORM) + STRINGISE_ENUM(VK_FORMAT_R16G16_USCALED) + STRINGISE_ENUM(VK_FORMAT_R16G16_SSCALED) + STRINGISE_ENUM(VK_FORMAT_R16G16_UINT) + STRINGISE_ENUM(VK_FORMAT_R16G16_SINT) + STRINGISE_ENUM(VK_FORMAT_R16G16_SFLOAT) + STRINGISE_ENUM(VK_FORMAT_R16G16B16_UNORM) + STRINGISE_ENUM(VK_FORMAT_R16G16B16_SNORM) + STRINGISE_ENUM(VK_FORMAT_R16G16B16_USCALED) + STRINGISE_ENUM(VK_FORMAT_R16G16B16_SSCALED) + STRINGISE_ENUM(VK_FORMAT_R16G16B16_UINT) + STRINGISE_ENUM(VK_FORMAT_R16G16B16_SINT) + STRINGISE_ENUM(VK_FORMAT_R16G16B16_SFLOAT) + STRINGISE_ENUM(VK_FORMAT_R16G16B16A16_UNORM) + STRINGISE_ENUM(VK_FORMAT_R16G16B16A16_SNORM) + STRINGISE_ENUM(VK_FORMAT_R16G16B16A16_USCALED) + STRINGISE_ENUM(VK_FORMAT_R16G16B16A16_SSCALED) + STRINGISE_ENUM(VK_FORMAT_R16G16B16A16_UINT) + STRINGISE_ENUM(VK_FORMAT_R16G16B16A16_SINT) + STRINGISE_ENUM(VK_FORMAT_R16G16B16A16_SFLOAT) + STRINGISE_ENUM(VK_FORMAT_R32_UINT) + STRINGISE_ENUM(VK_FORMAT_R32_SINT) + STRINGISE_ENUM(VK_FORMAT_R32_SFLOAT) + STRINGISE_ENUM(VK_FORMAT_R32G32_UINT) + STRINGISE_ENUM(VK_FORMAT_R32G32_SINT) + STRINGISE_ENUM(VK_FORMAT_R32G32_SFLOAT) + STRINGISE_ENUM(VK_FORMAT_R32G32B32_UINT) + STRINGISE_ENUM(VK_FORMAT_R32G32B32_SINT) + STRINGISE_ENUM(VK_FORMAT_R32G32B32_SFLOAT) + STRINGISE_ENUM(VK_FORMAT_R32G32B32A32_UINT) + STRINGISE_ENUM(VK_FORMAT_R32G32B32A32_SINT) + STRINGISE_ENUM(VK_FORMAT_R32G32B32A32_SFLOAT) + STRINGISE_ENUM(VK_FORMAT_R64_UINT) + STRINGISE_ENUM(VK_FORMAT_R64_SINT) + STRINGISE_ENUM(VK_FORMAT_R64_SFLOAT) + STRINGISE_ENUM(VK_FORMAT_R64G64_UINT) + STRINGISE_ENUM(VK_FORMAT_R64G64_SINT) + STRINGISE_ENUM(VK_FORMAT_R64G64_SFLOAT) + STRINGISE_ENUM(VK_FORMAT_R64G64B64_UINT) + STRINGISE_ENUM(VK_FORMAT_R64G64B64_SINT) + STRINGISE_ENUM(VK_FORMAT_R64G64B64_SFLOAT) + STRINGISE_ENUM(VK_FORMAT_R64G64B64A64_UINT) + STRINGISE_ENUM(VK_FORMAT_R64G64B64A64_SINT) + STRINGISE_ENUM(VK_FORMAT_R64G64B64A64_SFLOAT) + STRINGISE_ENUM(VK_FORMAT_B10G11R11_UFLOAT_PACK32) + STRINGISE_ENUM(VK_FORMAT_E5B9G9R9_UFLOAT_PACK32) + STRINGISE_ENUM(VK_FORMAT_D16_UNORM) + STRINGISE_ENUM(VK_FORMAT_X8_D24_UNORM_PACK32) + STRINGISE_ENUM(VK_FORMAT_D32_SFLOAT) + STRINGISE_ENUM(VK_FORMAT_S8_UINT) + STRINGISE_ENUM(VK_FORMAT_D16_UNORM_S8_UINT) + STRINGISE_ENUM(VK_FORMAT_D24_UNORM_S8_UINT) + STRINGISE_ENUM(VK_FORMAT_D32_SFLOAT_S8_UINT) + STRINGISE_ENUM(VK_FORMAT_BC1_RGB_UNORM_BLOCK) + STRINGISE_ENUM(VK_FORMAT_BC1_RGB_SRGB_BLOCK) + STRINGISE_ENUM(VK_FORMAT_BC1_RGBA_UNORM_BLOCK) + STRINGISE_ENUM(VK_FORMAT_BC1_RGBA_SRGB_BLOCK) + STRINGISE_ENUM(VK_FORMAT_BC2_UNORM_BLOCK) + STRINGISE_ENUM(VK_FORMAT_BC2_SRGB_BLOCK) + STRINGISE_ENUM(VK_FORMAT_BC3_UNORM_BLOCK) + STRINGISE_ENUM(VK_FORMAT_BC3_SRGB_BLOCK) + STRINGISE_ENUM(VK_FORMAT_BC4_UNORM_BLOCK) + STRINGISE_ENUM(VK_FORMAT_BC4_SNORM_BLOCK) + STRINGISE_ENUM(VK_FORMAT_BC5_UNORM_BLOCK) + STRINGISE_ENUM(VK_FORMAT_BC5_SNORM_BLOCK) + STRINGISE_ENUM(VK_FORMAT_BC6H_UFLOAT_BLOCK) + STRINGISE_ENUM(VK_FORMAT_BC6H_SFLOAT_BLOCK) + STRINGISE_ENUM(VK_FORMAT_BC7_UNORM_BLOCK) + STRINGISE_ENUM(VK_FORMAT_BC7_SRGB_BLOCK) + STRINGISE_ENUM(VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK) + STRINGISE_ENUM(VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK) + STRINGISE_ENUM(VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK) + STRINGISE_ENUM(VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK) + STRINGISE_ENUM(VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK) + STRINGISE_ENUM(VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK) + STRINGISE_ENUM(VK_FORMAT_EAC_R11_UNORM_BLOCK) + STRINGISE_ENUM(VK_FORMAT_EAC_R11_SNORM_BLOCK) + STRINGISE_ENUM(VK_FORMAT_EAC_R11G11_UNORM_BLOCK) + STRINGISE_ENUM(VK_FORMAT_EAC_R11G11_SNORM_BLOCK) + STRINGISE_ENUM(VK_FORMAT_ASTC_4x4_UNORM_BLOCK) + STRINGISE_ENUM(VK_FORMAT_ASTC_4x4_SRGB_BLOCK) + STRINGISE_ENUM(VK_FORMAT_ASTC_5x4_UNORM_BLOCK) + STRINGISE_ENUM(VK_FORMAT_ASTC_5x4_SRGB_BLOCK) + STRINGISE_ENUM(VK_FORMAT_ASTC_5x5_UNORM_BLOCK) + STRINGISE_ENUM(VK_FORMAT_ASTC_5x5_SRGB_BLOCK) + STRINGISE_ENUM(VK_FORMAT_ASTC_6x5_UNORM_BLOCK) + STRINGISE_ENUM(VK_FORMAT_ASTC_6x5_SRGB_BLOCK) + STRINGISE_ENUM(VK_FORMAT_ASTC_6x6_UNORM_BLOCK) + STRINGISE_ENUM(VK_FORMAT_ASTC_6x6_SRGB_BLOCK) + STRINGISE_ENUM(VK_FORMAT_ASTC_8x5_UNORM_BLOCK) + STRINGISE_ENUM(VK_FORMAT_ASTC_8x5_SRGB_BLOCK) + STRINGISE_ENUM(VK_FORMAT_ASTC_8x6_UNORM_BLOCK) + STRINGISE_ENUM(VK_FORMAT_ASTC_8x6_SRGB_BLOCK) + STRINGISE_ENUM(VK_FORMAT_ASTC_8x8_UNORM_BLOCK) + STRINGISE_ENUM(VK_FORMAT_ASTC_8x8_SRGB_BLOCK) + STRINGISE_ENUM(VK_FORMAT_ASTC_10x5_UNORM_BLOCK) + STRINGISE_ENUM(VK_FORMAT_ASTC_10x5_SRGB_BLOCK) + STRINGISE_ENUM(VK_FORMAT_ASTC_10x6_UNORM_BLOCK) + STRINGISE_ENUM(VK_FORMAT_ASTC_10x6_SRGB_BLOCK) + STRINGISE_ENUM(VK_FORMAT_ASTC_10x8_UNORM_BLOCK) + STRINGISE_ENUM(VK_FORMAT_ASTC_10x8_SRGB_BLOCK) + STRINGISE_ENUM(VK_FORMAT_ASTC_10x10_UNORM_BLOCK) + STRINGISE_ENUM(VK_FORMAT_ASTC_10x10_SRGB_BLOCK) + STRINGISE_ENUM(VK_FORMAT_ASTC_12x10_UNORM_BLOCK) + STRINGISE_ENUM(VK_FORMAT_ASTC_12x10_SRGB_BLOCK) + STRINGISE_ENUM(VK_FORMAT_ASTC_12x12_UNORM_BLOCK) + STRINGISE_ENUM(VK_FORMAT_ASTC_12x12_SRGB_BLOCK) + STRINGISE_ENUM(VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG) + STRINGISE_ENUM(VK_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG) + STRINGISE_ENUM(VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG) + STRINGISE_ENUM(VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG) + STRINGISE_ENUM(VK_FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG) + STRINGISE_ENUM(VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG) + STRINGISE_ENUM(VK_FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG) + STRINGISE_ENUM(VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG) + } + END_ENUM_STRINGISE(); +} + +template <> +std::string DoStringise(const VkResult &el) +{ + BEGIN_ENUM_STRINGISE(VkResult); + { + STRINGISE_ENUM(VK_SUCCESS) + STRINGISE_ENUM(VK_NOT_READY) + STRINGISE_ENUM(VK_TIMEOUT) + STRINGISE_ENUM(VK_EVENT_SET) + STRINGISE_ENUM(VK_EVENT_RESET) + STRINGISE_ENUM(VK_INCOMPLETE) + STRINGISE_ENUM(VK_ERROR_OUT_OF_HOST_MEMORY) + STRINGISE_ENUM(VK_ERROR_OUT_OF_DEVICE_MEMORY) + STRINGISE_ENUM(VK_ERROR_INITIALIZATION_FAILED) + STRINGISE_ENUM(VK_ERROR_DEVICE_LOST) + STRINGISE_ENUM(VK_ERROR_MEMORY_MAP_FAILED) + STRINGISE_ENUM(VK_ERROR_LAYER_NOT_PRESENT) + STRINGISE_ENUM(VK_ERROR_EXTENSION_NOT_PRESENT) + STRINGISE_ENUM(VK_ERROR_FEATURE_NOT_PRESENT) + STRINGISE_ENUM(VK_ERROR_INCOMPATIBLE_DRIVER) + STRINGISE_ENUM(VK_ERROR_TOO_MANY_OBJECTS) + STRINGISE_ENUM(VK_ERROR_FORMAT_NOT_SUPPORTED) + STRINGISE_ENUM(VK_ERROR_SURFACE_LOST_KHR) + STRINGISE_ENUM(VK_ERROR_NATIVE_WINDOW_IN_USE_KHR) + STRINGISE_ENUM(VK_SUBOPTIMAL_KHR) + STRINGISE_ENUM(VK_ERROR_OUT_OF_DATE_KHR) + STRINGISE_ENUM(VK_ERROR_INCOMPATIBLE_DISPLAY_KHR) + STRINGISE_ENUM(VK_ERROR_VALIDATION_FAILED_EXT) + STRINGISE_ENUM(VK_ERROR_INVALID_SHADER_NV) + STRINGISE_ENUM(VK_ERROR_OUT_OF_POOL_MEMORY_KHR) + STRINGISE_ENUM(VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR) + } + END_ENUM_STRINGISE(); +} + +template <> +std::string DoStringise(const VkMemoryType &el) +{ + return StringFormat::Fmt("VkMemoryType", el.heapIndex, + ToStr((VkMemoryPropertyFlagBits)el.propertyFlags).c_str()); +} + +template <> +std::string DoStringise(const VkMemoryHeap &el) +{ + return StringFormat::Fmt("VkMemoryHeap<%.3fMB, %s>", float(el.size) / (1024.0f * 1024.0f), + ToStr((VkMemoryHeapFlagBits)el.flags).c_str()); +} + +template <> +std::string DoStringise(const VkRect2D &el) +{ + return StringFormat::Fmt("VkRect2D<%dx%d+%d+%d>", el.extent.width, el.extent.height, el.offset.x, + el.offset.y); +} + +template <> +std::string DoStringise(const VkClearRect &el) +{ + return StringFormat::Fmt("VkClearRect<%dx%d+%d+%d %u->%u>", el.rect.extent.width, + el.rect.extent.height, el.rect.offset.x, el.rect.offset.y, + el.baseArrayLayer, el.baseArrayLayer + el.layerCount); +} + +template <> +std::string DoStringise(const VkClearAttachment &el) +{ + return StringFormat::Fmt("%s[%u] = %s", ToStr((VkImageAspectFlagBits)el.aspectMask).c_str(), + el.colorAttachment, ToStr(el.clearValue).c_str()); +} + +template <> +std::string DoStringise(const VkQueueFamilyProperties &el) +{ + return StringFormat::Fmt("%s x %u, %u bits, %s", ToStr((VkQueueFlagBits)el.queueFlags).c_str(), + el.queueCount, el.timestampValidBits, + ToStr(el.minImageTransferGranularity).c_str()); +} + +template <> +std::string DoStringise(const VkExtent2D &el) +{ + return StringFormat::Fmt("VkExtent<%u,%u>", el.width, el.height); +} + +template <> +std::string DoStringise(const VkExtent3D &el) +{ + return StringFormat::Fmt("VkExtent<%u,%u,%u>", el.width, el.height, el.depth); +} + +template <> +std::string DoStringise(const VkOffset2D &el) +{ + return StringFormat::Fmt("VkOffset<%d,%d>", el.x, el.y); +} + +template <> +std::string DoStringise(const VkOffset3D &el) +{ + return StringFormat::Fmt("VkOffset<%d,%d,%d>", el.x, el.y, el.z); +} + +template <> +std::string DoStringise(const VkViewport &el) +{ + return StringFormat::Fmt("VkViewport<%f,%f, %fx%f, %f-%f>", el.x, el.y, el.width, el.height, + el.minDepth, el.maxDepth); +} + +template <> +std::string DoStringise(const VkClearColorValue &el) +{ + return StringFormat::Fmt("VkClearColorValue<%f,%f,%f,%f>", el.float32[0], el.float32[1], + el.float32[2], el.float32[3]); +} +template <> +std::string DoStringise(const VkClearDepthStencilValue &el) +{ + return StringFormat::Fmt("VkClearDepthStencilValue<%f %u>", el.depth, el.stencil); +} +template <> +std::string DoStringise(const VkClearValue &el) +{ + return StringFormat::Fmt("VkClearValue[ col:<%f,%f,%f,%f> / d:%f s:%u ]", el.color.float32[0], + el.color.float32[1], el.color.float32[2], el.color.float32[3], + el.depthStencil.depth, el.depthStencil.stencil); +} + +template <> +std::string DoStringise(const VkAttachmentReference &el) +{ + return StringFormat::Fmt("VkAttachmentReference<%u, %s>", el.attachment, ToStr(el.layout).c_str()); +} + +//////////////////////////////////////////////////////////// +// VK_KHR_surface +//////////////////////////////////////////////////////////// + +template <> +std::string DoStringise(const VkSurfaceTransformFlagBitsKHR &el) +{ + string ret; + + if(el & VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR) + ret += " | VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR"; + if(el & VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR) + ret += " | VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR"; + if(el & VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR) + ret += " | VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR"; + if(el & VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR) + ret += " | VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR"; + if(el & VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR) + ret += " | VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR"; + if(el & VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR) + ret += " | VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR"; + if(el & VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR) + ret += " | VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR"; + if(el & VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR) + ret += " | VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR"; + + if(!ret.empty()) + ret = ret.substr(3); + + return ret; +} + +template <> +std::string DoStringise(const VkCompositeAlphaFlagBitsKHR &el) +{ + string ret; + + if(el & VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR) + ret += " | VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR"; + if(el & VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR) + ret += " | VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR"; + if(el & VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR) + ret += " | VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR"; + if(el & VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR) + ret += " | VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR"; + + if(!ret.empty()) + ret = ret.substr(3); + + return ret; +} + +template <> +std::string DoStringise(const VkColorSpaceKHR &el) +{ + BEGIN_ENUM_STRINGISE(VkColorSpaceKHR); + { + STRINGISE_ENUM(VK_COLORSPACE_SRGB_NONLINEAR_KHR) + } + END_ENUM_STRINGISE(); +} + +template <> +std::string DoStringise(const VkPresentModeKHR &el) +{ + BEGIN_ENUM_STRINGISE(VkPresentModeKHR); + { + STRINGISE_ENUM(VK_PRESENT_MODE_IMMEDIATE_KHR) + STRINGISE_ENUM(VK_PRESENT_MODE_MAILBOX_KHR) + STRINGISE_ENUM(VK_PRESENT_MODE_FIFO_KHR) + STRINGISE_ENUM(VK_PRESENT_MODE_FIFO_RELAXED_KHR) + } + END_ENUM_STRINGISE(); +} diff --git a/renderdoc/driver/vulkan/wrappers/vk_cmd_funcs.cpp b/renderdoc/driver/vulkan/wrappers/vk_cmd_funcs.cpp index 289cb38f2..83b23432b 100644 --- a/renderdoc/driver/vulkan/wrappers/vk_cmd_funcs.cpp +++ b/renderdoc/driver/vulkan/wrappers/vk_cmd_funcs.cpp @@ -272,7 +272,7 @@ string WrappedVulkan::MakeRenderPassOpString(bool store) else { // all colour ops are the same, print it - opDesc = store ? ToStr::Get(atts[col0].storeOp) : ToStr::Get(atts[col0].loadOp); + opDesc = store ? ToStr(atts[col0].storeOp) : ToStr(atts[col0].loadOp); } // do we have depth? @@ -285,8 +285,7 @@ string WrappedVulkan::MakeRenderPassOpString(bool store) // if there's no stencil, just print depth op if(!hasStencil) { - opDesc += - "D=" + (store ? ToStr::Get(atts[dsAttach].storeOp) : ToStr::Get(atts[dsAttach].loadOp)); + opDesc += "D=" + (store ? ToStr(atts[dsAttach].storeOp) : ToStr(atts[dsAttach].loadOp)); } else { @@ -294,19 +293,19 @@ string WrappedVulkan::MakeRenderPassOpString(bool store) { // if depth and stencil have same op, print together, otherwise separately if(atts[dsAttach].storeOp == atts[dsAttach].stencilStoreOp) - opDesc += "DS=" + ToStr::Get(atts[dsAttach].storeOp); + opDesc += "DS=" + ToStr(atts[dsAttach].storeOp); else - opDesc += "D=" + ToStr::Get(atts[dsAttach].storeOp) + ", S=" + - ToStr::Get(atts[dsAttach].stencilStoreOp); + opDesc += + "D=" + ToStr(atts[dsAttach].storeOp) + ", S=" + ToStr(atts[dsAttach].stencilStoreOp); } else { // if depth and stencil have same op, print together, otherwise separately if(atts[dsAttach].loadOp == atts[dsAttach].stencilLoadOp) - opDesc += "DS=" + ToStr::Get(atts[dsAttach].loadOp); + opDesc += "DS=" + ToStr(atts[dsAttach].loadOp); else - opDesc += "D=" + ToStr::Get(atts[dsAttach].loadOp) + ", S=" + - ToStr::Get(atts[dsAttach].stencilLoadOp); + opDesc += + "D=" + ToStr(atts[dsAttach].loadOp) + ", S=" + ToStr(atts[dsAttach].stencilLoadOp); } } } @@ -2388,7 +2387,7 @@ bool WrappedVulkan::Serialise_vkCmdExecuteCommands(Serialiser *localSerialiser, AddEvent(desc); DrawcallDescription draw; - draw.name = "vkCmdExecuteCommands(" + ToStr::Get(count) + ")"; + draw.name = "vkCmdExecuteCommands(" + ToStr(count) + ")"; draw.flags = DrawFlags::CmdList | DrawFlags::PushMarker; AddDrawcall(draw, true); @@ -2400,7 +2399,7 @@ bool WrappedVulkan::Serialise_vkCmdExecuteCommands(Serialiser *localSerialiser, for(uint32_t c = 0; c < count; c++) { string name = StringFormat::Fmt("=> vkCmdExecuteCommands()[%u]: vkBeginCommandBuffer(%s)", c, - ToStr::Get(cmdids[c]).c_str()); + ToStr(cmdids[c]).c_str()); // add a fake marker DrawcallDescription marker; @@ -2440,7 +2439,7 @@ bool WrappedVulkan::Serialise_vkCmdExecuteCommands(Serialiser *localSerialiser, parentCmdBufInfo.drawCount += cmdBufInfo.drawCount; name = StringFormat::Fmt("=> vkCmdExecuteCommands()[%u]: vkEndCommandBuffer(%s)", c, - ToStr::Get(cmdids[c]).c_str()); + ToStr(cmdids[c]).c_str()); marker.name = name; marker.flags = DrawFlags::PassBoundary | DrawFlags::EndPass; AddEvent(name); diff --git a/renderdoc/driver/vulkan/wrappers/vk_device_funcs.cpp b/renderdoc/driver/vulkan/wrappers/vk_device_funcs.cpp index c4bc0d674..8a30f58b4 100644 --- a/renderdoc/driver/vulkan/wrappers/vk_device_funcs.cpp +++ b/renderdoc/driver/vulkan/wrappers/vk_device_funcs.cpp @@ -1343,7 +1343,7 @@ VkResult WrappedVulkan::vkCreateDevice(VkPhysicalDevice physicalDevice, { RDCASSERT(m_SetDeviceLoaderData == layerCreateInfo->u.pfnSetDeviceLoaderData || m_SetDeviceLoaderData == NULL, - m_SetDeviceLoaderData, layerCreateInfo->u.pfnSetDeviceLoaderData); + (void *)m_SetDeviceLoaderData, (void *)layerCreateInfo->u.pfnSetDeviceLoaderData); m_SetDeviceLoaderData = layerCreateInfo->u.pfnSetDeviceLoaderData; } diff --git a/renderdoc/driver/vulkan/wrappers/vk_draw_funcs.cpp b/renderdoc/driver/vulkan/wrappers/vk_draw_funcs.cpp index cd73c5606..8c988ed32 100644 --- a/renderdoc/driver/vulkan/wrappers/vk_draw_funcs.cpp +++ b/renderdoc/driver/vulkan/wrappers/vk_draw_funcs.cpp @@ -115,7 +115,7 @@ bool WrappedVulkan::Serialise_vkCmdDraw(Serialiser *localSerialiser, VkCommandBu { AddEvent(desc); - string name = "vkCmdDraw(" + ToStr::Get(vtxCount) + "," + ToStr::Get(instCount) + ")"; + string name = "vkCmdDraw(" + ToStr(vtxCount) + "," + ToStr(instCount) + ")"; DrawcallDescription draw; draw.name = name; @@ -212,7 +212,7 @@ bool WrappedVulkan::Serialise_vkCmdDrawIndexed(Serialiser *localSerialiser, { AddEvent(desc); - string name = "vkCmdDrawIndexed(" + ToStr::Get(idxCount) + "," + ToStr::Get(instCount) + ")"; + string name = "vkCmdDrawIndexed(" + ToStr(idxCount) + "," + ToStr(instCount) + ")"; DrawcallDescription draw; draw.name = name; @@ -398,7 +398,7 @@ bool WrappedVulkan::Serialise_vkCmdDrawIndirect(Serialiser *localSerialiser, GetDebugManager()->GetBufferData(GetResID(buffer), offs, sizeof(VkDrawIndirectCommand) + (cnt - 1) * strd, argbuf); - string name = "vkCmdDrawIndirect(" + ToStr::Get(cnt) + ")"; + string name = "vkCmdDrawIndirect(" + ToStr(cnt) + ")"; if(!IsDrawInRenderPass()) { @@ -482,8 +482,8 @@ bool WrappedVulkan::Serialise_vkCmdDrawIndirect(Serialiser *localSerialiser, multi.vertexOffset = params.firstVertex; multi.instanceOffset = params.firstInstance; - multi.name = "vkCmdDrawIndirect[" + ToStr::Get(i) + "](<" + ToStr::Get(multi.numIndices) + - ", " + ToStr::Get(multi.numInstances) + ">)"; + multi.name = "vkCmdDrawIndirect[" + ToStr(i) + "](<" + ToStr(multi.numIndices) + ", " + + ToStr(multi.numInstances) + ">)"; multi.flags |= DrawFlags::Drawcall | DrawFlags::Instanced | DrawFlags::Indirect; @@ -692,7 +692,7 @@ bool WrappedVulkan::Serialise_vkCmdDrawIndexedIndirect(Serialiser *localSerialis GetDebugManager()->GetBufferData( GetResID(buffer), offs, sizeof(VkDrawIndexedIndirectCommand) + (cnt - 1) * strd, argbuf); - string name = "vkCmdDrawIndexedIndirect(" + ToStr::Get(cnt) + ")"; + string name = "vkCmdDrawIndexedIndirect(" + ToStr(cnt) + ")"; if(!IsDrawInRenderPass()) { @@ -778,8 +778,8 @@ bool WrappedVulkan::Serialise_vkCmdDrawIndexedIndirect(Serialiser *localSerialis multi.indexOffset = params.firstIndex; multi.instanceOffset = params.firstInstance; - multi.name = "vkCmdDrawIndexedIndirect[" + ToStr::Get(i) + "](<" + - ToStr::Get(multi.numIndices) + ", " + ToStr::Get(multi.numInstances) + ">)"; + multi.name = "vkCmdDrawIndexedIndirect[" + ToStr(i) + "](<" + ToStr(multi.numIndices) + ", " + + ToStr(multi.numInstances) + ">)"; multi.flags |= DrawFlags::Drawcall | DrawFlags::UseIBuffer | DrawFlags::Instanced | DrawFlags::Indirect; @@ -870,8 +870,7 @@ bool WrappedVulkan::Serialise_vkCmdDispatch(Serialiser *localSerialiser, { AddEvent(desc); - string name = - "vkCmdDispatch(" + ToStr::Get(X) + "," + ToStr::Get(Y) + "," + ToStr::Get(Z) + ")"; + string name = "vkCmdDispatch(" + ToStr(X) + "," + ToStr(Y) + "," + ToStr(Z) + ")"; DrawcallDescription draw; draw.name = name; @@ -962,8 +961,8 @@ bool WrappedVulkan::Serialise_vkCmdDispatchIndirect(Serialiser *localSerialiser, } AddEvent(desc); - string name = "vkCmdDispatchIndirect(<" + ToStr::Get(args->x) + "," + ToStr::Get(args->y) + - "," + ToStr::Get(args->z) + ">)"; + string name = "vkCmdDispatchIndirect(<" + ToStr(args->x) + "," + ToStr(args->y) + "," + + ToStr(args->z) + ">)"; DrawcallDescription draw; draw.name = name; @@ -1071,7 +1070,7 @@ bool WrappedVulkan::Serialise_vkCmdBlitImage(Serialiser *localSerialiser, { AddEvent(desc); - string name = "vkCmdBlitImage(" + ToStr::Get(srcid) + "," + ToStr::Get(dstid) + ")"; + string name = "vkCmdBlitImage(" + ToStr(srcid) + "," + ToStr(dstid) + ")"; DrawcallDescription draw; draw.name = name; @@ -1198,7 +1197,7 @@ bool WrappedVulkan::Serialise_vkCmdResolveImage(Serialiser *localSerialiser, { AddEvent(desc); - string name = "vkCmdResolveImage(" + ToStr::Get(srcid) + "," + ToStr::Get(dstid) + ")"; + string name = "vkCmdResolveImage(" + ToStr(srcid) + "," + ToStr(dstid) + ")"; DrawcallDescription draw; draw.name = name; @@ -1325,7 +1324,7 @@ bool WrappedVulkan::Serialise_vkCmdCopyImage(Serialiser *localSerialiser, { AddEvent(desc); - string name = "vkCmdCopyImage(" + ToStr::Get(srcid) + "," + ToStr::Get(dstid) + ")"; + string name = "vkCmdCopyImage(" + ToStr(srcid) + "," + ToStr(dstid) + ")"; DrawcallDescription draw; draw.name = name; @@ -1452,7 +1451,7 @@ bool WrappedVulkan::Serialise_vkCmdCopyBufferToImage(Serialiser *localSerialiser { AddEvent(desc); - string name = "vkCmdCopyBufferToImage(" + ToStr::Get(bufid) + "," + ToStr::Get(imgid) + ")"; + string name = "vkCmdCopyBufferToImage(" + ToStr(bufid) + "," + ToStr(imgid) + ")"; DrawcallDescription draw; draw.name = name; @@ -1570,7 +1569,7 @@ bool WrappedVulkan::Serialise_vkCmdCopyImageToBuffer(Serialiser *localSerialiser { AddEvent(desc); - string name = "vkCmdCopyImageToBuffer(" + ToStr::Get(imgid) + "," + ToStr::Get(bufid) + ")"; + string name = "vkCmdCopyImageToBuffer(" + ToStr(imgid) + "," + ToStr(bufid) + ")"; DrawcallDescription draw; draw.name = name; @@ -1688,7 +1687,7 @@ bool WrappedVulkan::Serialise_vkCmdCopyBuffer(Serialiser *localSerialiser, { AddEvent(desc); - string name = "vkCmdCopyBuffer(" + ToStr::Get(srcid) + "," + ToStr::Get(dstid) + ")"; + string name = "vkCmdCopyBuffer(" + ToStr(srcid) + "," + ToStr(dstid) + ")"; DrawcallDescription draw; draw.name = name; @@ -1817,7 +1816,7 @@ bool WrappedVulkan::Serialise_vkCmdClearColorImage(Serialiser *localSerialiser, { AddEvent(desc); - string name = "vkCmdClearColorImage(" + ToStr::Get(col) + ")"; + string name = "vkCmdClearColorImage(" + ToStr(col) + ")"; DrawcallDescription draw; draw.name = name; @@ -1921,8 +1920,7 @@ bool WrappedVulkan::Serialise_vkCmdClearDepthStencilImage( { AddEvent(desc); - string name = - "vkCmdClearDepthStencilImage(" + ToStr::Get(ds.depth) + "," + ToStr::Get(ds.stencil) + ")"; + string name = "vkCmdClearDepthStencilImage(" + ToStr(ds.depth) + "," + ToStr(ds.stencil) + ")"; DrawcallDescription draw; draw.name = name; @@ -2022,7 +2020,7 @@ bool WrappedVulkan::Serialise_vkCmdClearAttachments(Serialiser *localSerialiser, AddEvent(desc); string name = "vkCmdClearAttachments("; for(uint32_t a = 0; a < acount; a++) - name += ToStr::Get(atts[a]); + name += ToStr(atts[a]); name += ")"; DrawcallDescription draw; diff --git a/renderdoc/driver/vulkan/wrappers/vk_queue_funcs.cpp b/renderdoc/driver/vulkan/wrappers/vk_queue_funcs.cpp index fcd32d711..d42b8f1da 100644 --- a/renderdoc/driver/vulkan/wrappers/vk_queue_funcs.cpp +++ b/renderdoc/driver/vulkan/wrappers/vk_queue_funcs.cpp @@ -205,12 +205,12 @@ bool WrappedVulkan::Serialise_vkQueueSubmit(Serialiser *localSerialiser, VkQueue // we're adding multiple events, need to increment ourselves m_RootEventID++; - string basename = "vkQueueSubmit(" + ToStr::Get(numCmds) + ")"; + string basename = "vkQueueSubmit(" + ToStr(numCmds) + ")"; for(uint32_t c = 0; c < numCmds; c++) { string name = StringFormat::Fmt("=> %s[%u]: vkBeginCommandBuffer(%s)", basename.c_str(), c, - ToStr::Get(cmdIds[c]).c_str()); + ToStr(cmdIds[c]).c_str()); // add a fake marker DrawcallDescription draw; @@ -254,7 +254,7 @@ bool WrappedVulkan::Serialise_vkQueueSubmit(Serialiser *localSerialiser, VkQueue m_RootDrawcallID += cmdBufInfo.drawCount; name = StringFormat::Fmt("=> %s[%u]: vkEndCommandBuffer(%s)", basename.c_str(), c, - ToStr::Get(cmdIds[c]).c_str()); + ToStr(cmdIds[c]).c_str()); draw.name = name; AddEvent(name); AddDrawcall(draw, true); diff --git a/renderdoc/renderdoc.vcxproj b/renderdoc/renderdoc.vcxproj index 44497729c..5e519510a 100644 --- a/renderdoc/renderdoc.vcxproj +++ b/renderdoc/renderdoc.vcxproj @@ -143,6 +143,7 @@ + @@ -401,6 +402,7 @@ + diff --git a/renderdoc/renderdoc.vcxproj.filters b/renderdoc/renderdoc.vcxproj.filters index cea49c680..e8aa9d19a 100644 --- a/renderdoc/renderdoc.vcxproj.filters +++ b/renderdoc/renderdoc.vcxproj.filters @@ -345,6 +345,9 @@ API\Replay + + API\Replay + @@ -673,6 +676,9 @@ Resources\glsl + + API\Replay + diff --git a/renderdoc/serialise/serialiser.cpp b/renderdoc/serialise/serialiser.cpp index 99a7c9881..4c1bb793b 100644 --- a/renderdoc/serialise/serialiser.cpp +++ b/renderdoc/serialise/serialiser.cpp @@ -1935,22 +1935,15 @@ void Serialiser::ReadInto(float &f) // Basic types template <> -string ToStrHelper::Get(void *const &el) +std::string DoStringise(void *const &el) { - char tostrBuf[256] = {0}; - StringFormat::snprintf(tostrBuf, 255, "0x%p", el); - - return tostrBuf; + return StringFormat::Fmt("%#p", el); } template <> -string ToStrHelper::Get(const int64_t &el) +std::string DoStringise(const int64_t &el) { - char tostrBuf[256] = {0}; - - StringFormat::snprintf(tostrBuf, 255, "%lld", el); - - return tostrBuf; + return StringFormat::Fmt("%lld", el); } // this is super ugly, but I don't see a way around it - on other @@ -1959,109 +1952,74 @@ string ToStrHelper::Get(const int64_t &el) // specific size_t overload #if ENABLED(RDOC_APPLE) template <> -string ToStrHelper::Get(const size_t &el) +std::string DoStringise(const size_t &el) { - char tostrBuf[256] = {0}; - - StringFormat::snprintf(tostrBuf, 255, "%llu", (uint64_t)el); - - return tostrBuf; + return StringFormat::Fmt("%llu", (uint64_t)el); } #endif template <> -string ToStrHelper::Get(const uint64_t &el) +std::string DoStringise(const uint64_t &el) { - char tostrBuf[256] = {0}; - - StringFormat::snprintf(tostrBuf, 255, "%llu", el); - - return tostrBuf; + return StringFormat::Fmt("%llu", el); } template <> -string ToStrHelper::Get(const uint32_t &el) +std::string DoStringise(const uint32_t &el) { - char tostrBuf[256] = {0}; - StringFormat::snprintf(tostrBuf, 255, "%u", el); - - return tostrBuf; + return StringFormat::Fmt("%u", el); } template <> -string ToStrHelper::Get(const char &el) +std::string DoStringise(const char &el) { - char tostrBuf[256] = {0}; - StringFormat::snprintf(tostrBuf, 255, "'%c'", el); - - return tostrBuf; + return StringFormat::Fmt("'%c'", el); } template <> -string ToStrHelper::Get(const wchar_t &el) +std::string DoStringise(const wchar_t &el) { - char tostrBuf[256] = {0}; - StringFormat::snprintf(tostrBuf, 255, "'%lc'", el); - - return tostrBuf; + return StringFormat::Fmt("'%lc'", el); } template <> -string ToStrHelper::Get(const byte &el) +std::string DoStringise(const byte &el) { - char tostrBuf[256] = {0}; - StringFormat::snprintf(tostrBuf, 255, "%08hhb", el); - - return tostrBuf; + return StringFormat::Fmt("%08hhb", el); } template <> -string ToStrHelper::Get(const uint16_t &el) +std::string DoStringise(const uint16_t &el) { - char tostrBuf[256] = {0}; - StringFormat::snprintf(tostrBuf, 255, "%04d", el); - - return tostrBuf; + return StringFormat::Fmt("%04u", el); } template <> -string ToStrHelper::Get(const int &el) +std::string DoStringise(const int32_t &el) { - char tostrBuf[256] = {0}; - StringFormat::snprintf(tostrBuf, 255, "%d", el); - - return tostrBuf; + return StringFormat::Fmt("%d", el); } template <> -string ToStrHelper::Get(const short &el) +std::string DoStringise(const int16_t &el) { - char tostrBuf[256] = {0}; - StringFormat::snprintf(tostrBuf, 255, "%04d", el); - - return tostrBuf; + return StringFormat::Fmt("%04d", el); } template <> -string ToStrHelper::Get(const float &el) +std::string DoStringise(const float &el) { - char tostrBuf[256] = {0}; - StringFormat::snprintf(tostrBuf, 255, "%0.4f", el); - - return tostrBuf; + return StringFormat::Fmt("%0.4f", el); } template <> -string ToStrHelper::Get(const double &el) +std::string DoStringise(const double &el) { - char tostrBuf[256] = {0}; - StringFormat::snprintf(tostrBuf, 255, "%0.4lf", el); - - return tostrBuf; + return StringFormat::Fmt("%0.4lf", el); } template <> -string ToStrHelper::Get(const bool &el) +std::string DoStringise(const bool &el) { if(el) return "True"; diff --git a/renderdoc/serialise/serialiser.h b/renderdoc/serialise/serialiser.h index 3ed83c088..e0057ab63 100644 --- a/renderdoc/serialise/serialiser.h +++ b/renderdoc/serialise/serialiser.h @@ -39,49 +39,6 @@ using std::set; using std::string; -// template helpers -template -struct renderdoc_is_pointer -{ - enum - { - value = false - }; -}; - -template -struct renderdoc_is_pointer -{ - enum - { - value = true - }; -}; - -template -struct renderdoc_is_pointer -{ - enum - { - value = true - }; -}; - -template -struct ToStrHelper -{ - static string Get(const T &el); -}; - -struct ToStr -{ - template - static string Get(const T &el) - { - return ToStrHelper::value, T>::Get(el); - } -}; - typedef const char *(*ChunkLookup)(uint32_t chunkType); class Serialiser; @@ -366,7 +323,7 @@ public: DebugPrint("%s[]\n", name); for(size_t i = 0; i < numElems; i++) - DebugPrint("%s[%d] = %s\n", name, i, ToStr::Get(el[i]).c_str()); + DebugPrint("%s[%d] = %s\n", name, i, ToStr(el[i]).c_str()); } } @@ -444,7 +401,7 @@ public: } if(name != NULL && m_DebugTextWriting) - DebugPrint("%s: %s\n", name, ToStr::Get(el).c_str()); + DebugPrint("%s: %s\n", name, ToStr(el).c_str()); } // function to deallocate members @@ -893,22 +850,3 @@ struct ScopedDeserialise size_t CONCAT(buflen, __LINE__) = Len; \ GET_SERIALISER->SerialiseBuffer(#name, name, CONCAT(buflen, __LINE__)); \ } - -// forward declare generic pointer version to void* -template -struct ToStrHelper -{ - static string Get(const T &el) - { - void *ptr = (void *)el; - return ToStrHelper::Get(ptr); - } -}; - -// stringize the parameter -#define TOSTR_CASE_STRINGIZE(a) \ - case a: return #a; - -// stringize the parameter (class enum version) -#define TOSTR_CASE_STRINGIZE_SCOPED(a, b) \ - case a::b: return #b; diff --git a/renderdoccmd/renderdoccmd.cpp b/renderdoccmd/renderdoccmd.cpp index 3f948a3fe..b6796db34 100644 --- a/renderdoccmd/renderdoccmd.cpp +++ b/renderdoccmd/renderdoccmd.cpp @@ -28,6 +28,19 @@ #include #include +// normally this is in the renderdoc core library, but it's needed for the 'unknown enum' path, +// so we implement it here using ostringstream. It's not great, but this is a very uncommon path - +// either for invalid values or for when a new enum is added and the code isn't updated +template <> +std::string DoStringise(const uint32_t &el) +{ + std::ostringstream oss; + oss << el; + return oss.str(); +} + +#include + using std::string; using std::wstring; @@ -280,13 +293,14 @@ struct ThumbCommand : public Command bytebuf buf; ICaptureFile *file = RENDERDOC_OpenCaptureFile(filename.c_str()); - if(file->OpenStatus() == ReplayStatus::Succeeded) + ReplayStatus st = file->OpenStatus(); + if(st == ReplayStatus::Succeeded) { buf = file->GetThumbnail(type, maxsize); } else { - std::cerr << "Couldn't open '" << filename << "'" << std::endl; + std::cerr << "Couldn't open '" << filename << "': " << ToStr(st) << std::endl; } file->Shutdown(); @@ -540,8 +554,9 @@ struct ReplayCommand : public Command if(remote == NULL || status != ReplayStatus::Succeeded) { - std::cerr << "Error: Couldn't connect to " << parser.get("remote-host") << ":" - << parser.get("remote-port") << "." << std::endl; + std::cerr << "Error: " << ToStr(status) << " - Couldn't connect to " + << parser.get("remote-host") << ":" << parser.get("remote-port") + << "." << std::endl; std::cerr << " Have you run renderdoccmd remoteserver on '" << parser.get("remote-host") << "'?" << std::endl; return 1; @@ -563,7 +578,7 @@ struct ReplayCommand : public Command } else { - std::cerr << "Couldn't load and replay '" << filename << "'." << std::endl; + std::cerr << "Couldn't load and replay '" << filename << "': " << ToStr(status) << std::endl; } remote->ShutdownConnection(); @@ -595,7 +610,7 @@ struct ReplayCommand : public Command } else { - std::cerr << "Couldn't load and replay '" << filename << "'." << std::endl; + std::cerr << "Couldn't load and replay '" << filename << "': " << ToStr(status) << std::endl; return 1; } }