From 31feedd16d92eb7564d47e036be24ae071a5c7e1 Mon Sep 17 00:00:00 2001 From: baldurk Date: Tue, 17 May 2022 16:16:01 +0100 Subject: [PATCH] Remove ShaderConstantDescriptor, inline into ShaderConstantType * This struct was redundant isnce it was only ever used in the type and not meaningfully accessed directly. --- qrenderdoc/Code/BufferFormatter.cpp | 530 +++++++++--------- qrenderdoc/Code/QRDUtils.cpp | 12 +- qrenderdoc/Windows/BufferViewer.cpp | 114 ++-- .../D3D11PipelineStateViewer.cpp | 12 +- .../D3D12PipelineStateViewer.cpp | 17 +- .../PipelineState/GLPipelineStateViewer.cpp | 4 +- .../PipelineState/PipelineStateViewer.cpp | 17 +- renderdoc/api/replay/shader_types.h | 78 +-- renderdoc/data/glsl_shaders.cpp | 438 +++++++-------- .../driver/d3d11/d3d11_rendertexture.cpp | 15 +- .../driver/d3d12/d3d12_rendertexture.cpp | 15 +- renderdoc/driver/gl/gl_driver.cpp | 4 +- renderdoc/driver/gl/gl_program_iterate.cpp | 118 ++-- renderdoc/driver/gl/gl_replay.cpp | 4 +- renderdoc/driver/gl/gl_shader_refl.cpp | 527 +++++++++-------- .../driver/shaders/dxbc/dxbc_bytecode.cpp | 28 +- .../driver/shaders/dxbc/dxbc_bytecode_ops.cpp | 14 +- renderdoc/driver/shaders/dxbc/dxbc_common.h | 19 +- .../driver/shaders/dxbc/dxbc_container.cpp | 58 +- renderdoc/driver/shaders/dxbc/dxbc_debug.cpp | 8 +- .../driver/shaders/dxbc/dxbc_reflect.cpp | 88 ++- renderdoc/driver/shaders/dxbc/dxbc_spdb.cpp | 6 +- renderdoc/driver/shaders/dxbc/dxbc_spdb.h | 2 +- .../driver/shaders/dxil/dxil_reflect.cpp | 148 ++--- .../driver/shaders/spirv/spirv_reflect.cpp | 137 +++-- renderdoc/replay/renderdoc_serialise.inl | 12 +- renderdoc/replay/replay_driver.cpp | 26 +- renderdoc/replay/replay_driver.h | 2 +- 28 files changed, 1189 insertions(+), 1264 deletions(-) diff --git a/qrenderdoc/Code/BufferFormatter.cpp b/qrenderdoc/Code/BufferFormatter.cpp index 022d0baab..03fe0885c 100644 --- a/qrenderdoc/Code/BufferFormatter.cpp +++ b/qrenderdoc/Code/BufferFormatter.cpp @@ -54,103 +54,103 @@ static bool MatchBaseTypeDeclaration(QString basetype, const bool isUnsigned, Sh { if(basetype == lit("bool")) { - el.type.descriptor.type = VarType::Bool; + el.type.baseType = VarType::Bool; } else if(basetype == lit("byte") || basetype == lit("char")) { - el.type.descriptor.type = VarType::SByte; + el.type.baseType = VarType::SByte; if(isUnsigned) - el.type.descriptor.type = VarType::UByte; + el.type.baseType = VarType::UByte; } else if(basetype == lit("ubyte") || basetype == lit("xbyte")) { - el.type.descriptor.type = VarType::UByte; + el.type.baseType = VarType::UByte; } else if(basetype == lit("short")) { - el.type.descriptor.type = VarType::SShort; + el.type.baseType = VarType::SShort; if(isUnsigned) - el.type.descriptor.type = VarType::UShort; + el.type.baseType = VarType::UShort; } else if(basetype == lit("ushort") || basetype == lit("xshort")) { - el.type.descriptor.type = VarType::UShort; + el.type.baseType = VarType::UShort; } else if(basetype == lit("long")) { - el.type.descriptor.type = VarType::SLong; + el.type.baseType = VarType::SLong; if(isUnsigned) - el.type.descriptor.type = VarType::ULong; + el.type.baseType = VarType::ULong; } else if(basetype == lit("ulong") || basetype == lit("xlong")) { - el.type.descriptor.type = VarType::ULong; + el.type.baseType = VarType::ULong; } else if(basetype == lit("int") || basetype == lit("ivec") || basetype == lit("imat")) { - el.type.descriptor.type = VarType::SInt; + el.type.baseType = VarType::SInt; if(isUnsigned) - el.type.descriptor.type = VarType::UInt; + el.type.baseType = VarType::UInt; } else if(basetype == lit("uint") || basetype == lit("xint") || basetype == lit("uvec") || basetype == lit("umat")) { - el.type.descriptor.type = VarType::UInt; + el.type.baseType = VarType::UInt; } else if(basetype == lit("half")) { - el.type.descriptor.type = VarType::Half; + el.type.baseType = VarType::Half; } else if(basetype == lit("float") || basetype == lit("vec") || basetype == lit("mat")) { - el.type.descriptor.type = VarType::Float; + el.type.baseType = VarType::Float; } else if(basetype == lit("double") || basetype == lit("dvec") || basetype == lit("dmat")) { - el.type.descriptor.type = VarType::Double; + el.type.baseType = VarType::Double; } else if(basetype == lit("unormh")) { - el.type.descriptor.type = VarType::UShort; - el.type.descriptor.flags |= ShaderVariableFlags::UNorm; + el.type.baseType = VarType::UShort; + el.type.flags |= ShaderVariableFlags::UNorm; } else if(basetype == lit("unormb")) { - el.type.descriptor.type = VarType::UByte; - el.type.descriptor.flags |= ShaderVariableFlags::UNorm; + el.type.baseType = VarType::UByte; + el.type.flags |= ShaderVariableFlags::UNorm; } else if(basetype == lit("snormh")) { - el.type.descriptor.type = VarType::SShort; - el.type.descriptor.flags |= ShaderVariableFlags::SNorm; + el.type.baseType = VarType::SShort; + el.type.flags |= ShaderVariableFlags::SNorm; } else if(basetype == lit("snormb")) { - el.type.descriptor.type = VarType::SByte; - el.type.descriptor.flags |= ShaderVariableFlags::SNorm; + el.type.baseType = VarType::SByte; + el.type.flags |= ShaderVariableFlags::SNorm; } else if(basetype == lit("uintten")) { - el.type.descriptor.type = VarType::UInt; - el.type.descriptor.flags |= ShaderVariableFlags::R10G10B10A2; - el.type.descriptor.columns = 4; + el.type.baseType = VarType::UInt; + el.type.flags |= ShaderVariableFlags::R10G10B10A2; + el.type.columns = 4; } else if(basetype == lit("unormten")) { - el.type.descriptor.type = VarType::UInt; - el.type.descriptor.flags |= ShaderVariableFlags::R10G10B10A2; - el.type.descriptor.flags |= ShaderVariableFlags::UNorm; - el.type.descriptor.columns = 4; + el.type.baseType = VarType::UInt; + el.type.flags |= ShaderVariableFlags::R10G10B10A2; + el.type.flags |= ShaderVariableFlags::UNorm; + el.type.columns = 4; } else if(basetype == lit("floateleven")) { - el.type.descriptor.type = VarType::Float; - el.type.descriptor.flags |= ShaderVariableFlags::R11G11B10; - el.type.descriptor.columns = 3; + el.type.baseType = VarType::Float; + el.type.flags |= ShaderVariableFlags::R11G11B10; + el.type.columns = 3; } else { @@ -172,16 +172,16 @@ void BufferFormatter::EstimatePackingRules(Packing::Rules &pack, const ShaderCon { // column major matrices have vectors that are 'rows' long. Everything else is vectors of // 'columns' long - uint8_t vecSize = constant.type.descriptor.columns; + uint8_t vecSize = constant.type.columns; - if(constant.type.descriptor.rows > 1 && constant.type.descriptor.ColMajor()) - vecSize = constant.type.descriptor.rows; + if(constant.type.rows > 1 && constant.type.ColMajor()) + vecSize = constant.type.rows; if(vecSize > 1) { // is this a vector that's only component aligned and NOT vector aligned. If so, // vector_align_component is true - const uint32_t vec4Size = VarTypeByteSize(constant.type.descriptor.type) * 4; + const uint32_t vec4Size = VarTypeByteSize(constant.type.baseType) * 4; const uint32_t offsModVec = (constant.byteOffset % vec4Size); // if it's a vec3 or vec4 and its offset is not purely aligned, it's only component aligned @@ -197,7 +197,7 @@ void BufferFormatter::EstimatePackingRules(Packing::Rules &pack, const ShaderCon const uint32_t low16b = (constant.byteOffset / 16); const uint32_t high16b = - ((constant.byteOffset + VarTypeByteSize(constant.type.descriptor.type) * vecSize - 1) / 16); + ((constant.byteOffset + VarTypeByteSize(constant.type.baseType) * vecSize - 1) / 16); // if the vector crosses a 16-byte boundary, vectors can straddle them if(low16b != high16b) @@ -205,10 +205,10 @@ void BufferFormatter::EstimatePackingRules(Packing::Rules &pack, const ShaderCon } } - if(!pack.tight_arrays && constant.type.descriptor.elements > 1) + if(!pack.tight_arrays && constant.type.elements > 1) { // if the array has a byte stride less than 16, it must be non-tight packed - if(constant.type.descriptor.arrayByteStride < 16) + if(constant.type.arrayByteStride < 16) pack.tight_arrays = true; } } @@ -277,8 +277,8 @@ Packing::Rules BufferFormatter::EstimatePackingRules(const rdcarray 0) { const uint32_t prevOffset = members[i - 1].byteOffset; - const uint32_t prevArrayCount = members[i - 1].type.descriptor.elements; - const uint32_t prevArrayStride = members[i - 1].type.descriptor.arrayByteStride; + const uint32_t prevArrayCount = members[i - 1].type.elements; + const uint32_t prevArrayStride = members[i - 1].type.arrayByteStride; // if we overlap into the previous element, trailing padding is not reserved // this works for structs too, as the array stride *includes* padding @@ -383,7 +383,7 @@ bool BufferFormatter::ContainsUnbounded(const ShaderConstant &structType, const rdcarray &members = structType.type.members; for(size_t i = 0; i < members.size(); i++) { - if(members[i].type.descriptor.elements == ~0U) + if(members[i].type.elements == ~0U) { if(found) *found = {structType.name, members[i].name}; @@ -408,7 +408,7 @@ bool BufferFormatter::CheckInvalidUnbounded(const StructFormatData &structData, const bool isLast = i == def.type.members.size() - 1; // if it's not the last member and it's unbounded, that's a problem! - if(!isLast && def.type.members[i].type.descriptor.elements == ~0U) + if(!isLast && def.type.members[i].type.elements == ~0U) { int line = structData.lineMemberDefs[(int)i]; errors[line] = tr("Only the last member of a struct can be an unbounded array."); @@ -428,8 +428,7 @@ bool BufferFormatter::CheckInvalidUnbounded(const StructFormatData &structData, return false; } - if(!CheckInvalidUnbounded(structelems[def.type.members[i].type.descriptor.name], structelems, - errors)) + if(!CheckInvalidUnbounded(structelems[def.type.members[i].type.name], structelems, errors)) return false; } @@ -767,9 +766,9 @@ ParsedFormat BufferFormatter::ParseFormatString(const QString &formatString, uin bitfieldCurPos = ~0U; } - if(cur->structDef.type.descriptor.type == VarType::Struct) + if(cur->structDef.type.baseType == VarType::Struct) { - cur->structDef.type.descriptor.arrayByteStride = cur->offset; + cur->structDef.type.arrayByteStride = cur->offset; cur->alignment = GetAlignment(pack, cur->structDef); @@ -779,22 +778,22 @@ ParsedFormat BufferFormatter::ParseFormatString(const QString &formatString, uin cur->alignment = 16; } - cur->structDef.type.descriptor.arrayByteStride = AlignUp(cur->offset, cur->alignment); + cur->structDef.type.arrayByteStride = AlignUp(cur->offset, cur->alignment); if(cur->paddedStride > 0) { // only pad up to the stride, not down - if(cur->paddedStride >= cur->structDef.type.descriptor.arrayByteStride) + if(cur->paddedStride >= cur->structDef.type.arrayByteStride) { - cur->structDef.type.descriptor.arrayByteStride = cur->paddedStride; + cur->structDef.type.arrayByteStride = cur->paddedStride; } else { reportError(tr("Struct %1 declared size %2 bytes is less than derived structure " "size %3 bytes.") - .arg(cur->structDef.type.descriptor.name) + .arg(cur->structDef.type.name) .arg(cur->paddedStride) - .arg(cur->structDef.type.descriptor.arrayByteStride)); + .arg(cur->structDef.type.arrayByteStride)); success = false; break; } @@ -825,13 +824,13 @@ ParsedFormat BufferFormatter::ParseFormatString(const QString &formatString, uin } cur = &structelems[name]; - cur->structDef.type.descriptor.name = name; + cur->structDef.type.name = name; bitfieldCurPos = ~0U; if(typeName == lit("struct")) { lastStruct = name; - cur->structDef.type.descriptor.type = VarType::Struct; + cur->structDef.type.baseType = VarType::Struct; for(const Annotation &annot : annotations) { @@ -871,7 +870,7 @@ ParsedFormat BufferFormatter::ParseFormatString(const QString &formatString, uin } else { - cur->structDef.type.descriptor.type = VarType::Enum; + cur->structDef.type.baseType = VarType::Enum; for(const Annotation &annot : annotations) { @@ -906,8 +905,8 @@ ParsedFormat BufferFormatter::ParseFormatString(const QString &formatString, uin bool matched = MatchBaseTypeDeclaration(baseType, true, tmp); - if(!matched || VarTypeCompType(tmp.type.descriptor.type) != CompType::UInt || - tmp.type.descriptor.flags != ShaderVariableFlags::NoFlags) + if(!matched || VarTypeCompType(tmp.type.baseType) != CompType::UInt || + tmp.type.flags != ShaderVariableFlags::NoFlags) { reportError( tr("Invalid enum base type '%1', must be an unsigned integer type.").arg(baseType)); @@ -915,7 +914,7 @@ ParsedFormat BufferFormatter::ParseFormatString(const QString &formatString, uin break; } - cur->structDef.type.descriptor.arrayByteStride = VarTypeByteSize(tmp.type.descriptor.type); + cur->structDef.type.arrayByteStride = VarTypeByteSize(tmp.type.baseType); } continue; @@ -924,7 +923,7 @@ ParsedFormat BufferFormatter::ParseFormatString(const QString &formatString, uin ShaderConstant el; - if(cur->structDef.type.descriptor.type == VarType::Enum) + if(cur->structDef.type.baseType == VarType::Enum) { QRegularExpressionMatch enumMatch = enumValueRegex.match(decl); @@ -1140,11 +1139,11 @@ ParsedFormat BufferFormatter::ParseFormatString(const QString &formatString, uin el.name = varName; el.byteOffset = cur->offset; - el.type.descriptor.pointerTypeID = structContext.pointerTypeId; - el.type.descriptor.type = VarType::ULong; - el.type.descriptor.flags |= ShaderVariableFlags::HexDisplay; - el.type.descriptor.arrayByteStride = 8; - el.type.descriptor.elements = arrayCount; + el.type.pointerTypeID = structContext.pointerTypeId; + el.type.baseType = VarType::ULong; + el.type.flags |= ShaderVariableFlags::HexDisplay; + el.type.arrayByteStride = 8; + el.type.elements = arrayCount; cur->offset += 8; @@ -1156,7 +1155,7 @@ ParsedFormat BufferFormatter::ParseFormatString(const QString &formatString, uin continue; } - else if(structContext.structDef.type.descriptor.type == VarType::Enum) + else if(structContext.structDef.type.baseType == VarType::Enum) { if(!bitfield.isEmpty() && !arrayDim.isEmpty()) { @@ -1167,7 +1166,7 @@ ParsedFormat BufferFormatter::ParseFormatString(const QString &formatString, uin // align to scalar size (if not bit packing) if(bitfieldCurPos == ~0U) - cur->offset = AlignUp(cur->offset, structContext.structDef.type.descriptor.arrayByteStride); + cur->offset = AlignUp(cur->offset, structContext.structDef.type.arrayByteStride); if(specifiedOffset != ~0U) { @@ -1195,7 +1194,7 @@ ParsedFormat BufferFormatter::ParseFormatString(const QString &formatString, uin el = structContext.structDef; el.name = varName; el.byteOffset = cur->offset; - el.type.descriptor.elements = arrayCount; + el.type.elements = arrayCount; bool ok = false; el.bitFieldSize = qMax(1U, bitfield.toUInt(&ok)); @@ -1236,7 +1235,7 @@ ParsedFormat BufferFormatter::ParseFormatString(const QString &formatString, uin el = structContext.structDef; el.name = varName; el.byteOffset = cur->offset; - el.type.descriptor.elements = arrayCount; + el.type.elements = arrayCount; if(!isPadding) { @@ -1245,11 +1244,11 @@ ParsedFormat BufferFormatter::ParseFormatString(const QString &formatString, uin } // advance by the struct including any trailing padding - cur->offset += el.type.descriptor.elements * el.type.descriptor.arrayByteStride; + cur->offset += el.type.elements * el.type.arrayByteStride; // if we allow trailing overlap, remove the padding if(pack.trailing_overlap) - cur->offset -= el.type.descriptor.arrayByteStride - structContext.offset; + cur->offset -= el.type.arrayByteStride - structContext.offset; continue; } @@ -1299,9 +1298,9 @@ ParsedFormat BufferFormatter::ParseFormatString(const QString &formatString, uin QString basetype = match.captured(lit("type")); if(match.captured(lit("major")).trimmed() == lit("row_major")) - el.type.descriptor.flags |= ShaderVariableFlags::RowMajorMatrix; + el.type.flags |= ShaderVariableFlags::RowMajorMatrix; if(!match.captured(lit("rgb")).isEmpty()) - el.type.descriptor.flags |= ShaderVariableFlags::RGBDisplay; + el.type.flags |= ShaderVariableFlags::RGBDisplay; QString firstDim = !match.captured(lit("vec")).isEmpty() ? match.captured(lit("vec")) : lit("1"); QString secondDim = @@ -1353,7 +1352,7 @@ ParsedFormat BufferFormatter::ParseFormatString(const QString &formatString, uin { bool ok = false; - el.type.descriptor.columns = firstDim.toUInt(&ok); + el.type.columns = firstDim.toUInt(&ok); if(!ok) { reportError(tr("Invalid vector dimension '%1'.").arg(firstDim)); @@ -1361,18 +1360,18 @@ ParsedFormat BufferFormatter::ParseFormatString(const QString &formatString, uin break; } - el.type.descriptor.elements = qMax(1U, arrayDim.toUInt(&ok)); + el.type.elements = qMax(1U, arrayDim.toUInt(&ok)); if(!ok) - el.type.descriptor.elements = 1; + el.type.elements = 1; - if(!bitfield.isEmpty() && el.type.descriptor.elements > 1) + if(!bitfield.isEmpty() && el.type.elements > 1) { reportError(tr("Arrays can't be packed into a bitfield.")); success = false; break; } - el.type.descriptor.rows = qMax(1U, secondDim.toUInt(&ok)); + el.type.rows = qMax(1U, secondDim.toUInt(&ok)); if(!ok) { reportError(tr("Invalid matrix dimension '%1'.").arg(secondDim)); @@ -1385,8 +1384,8 @@ ParsedFormat BufferFormatter::ParseFormatString(const QString &formatString, uin el.bitFieldSize = 0; // vectors are marked as row-major by convention - if(el.type.descriptor.rows == 1) - el.type.descriptor.flags |= ShaderVariableFlags::RowMajorMatrix; + if(el.type.rows == 1) + el.type.flags |= ShaderVariableFlags::RowMajorMatrix; bool matched = MatchBaseTypeDeclaration(basetype, isUnsigned, el); @@ -1398,7 +1397,7 @@ ParsedFormat BufferFormatter::ParseFormatString(const QString &formatString, uin } } - el.type.descriptor.name = ToStr(el.type.descriptor.type) + vecMatSizeSuffix; + el.type.name = ToStr(el.type.baseType) + vecMatSizeSuffix; // process packing annotations first, so we have that information to validate e.g. [[unorm]] for(const Annotation &annot : annotations) @@ -1407,19 +1406,19 @@ ParsedFormat BufferFormatter::ParseFormatString(const QString &formatString, uin { if(annot.param.toLower() == lit("r11g11b10")) { - if(el.type.descriptor.columns != 3 || el.type.descriptor.type != VarType::Float) + if(el.type.columns != 3 || el.type.baseType != VarType::Float) { reportError(tr("R11G11B10 packing must be specified on a 'float3' variable.")); success = false; break; } - el.type.descriptor.flags |= ShaderVariableFlags::R11G11B10; + el.type.flags |= ShaderVariableFlags::R11G11B10; } else if(annot.param.toLower() == lit("r10g10b10a2") || annot.param.toLower() == lit("r10g10b10a2_uint")) { - if(el.type.descriptor.columns != 4 || el.type.descriptor.type != VarType::UInt) + if(el.type.columns != 4 || el.type.baseType != VarType::UInt) { reportError( tr("R10G10B10A2 packing must be specified on a 'uint4' variable " @@ -1428,29 +1427,29 @@ ParsedFormat BufferFormatter::ParseFormatString(const QString &formatString, uin break; } - el.type.descriptor.flags |= ShaderVariableFlags::R10G10B10A2; + el.type.flags |= ShaderVariableFlags::R10G10B10A2; } else if(annot.param.toLower() == lit("r10g10b10a2_unorm")) { - if(el.type.descriptor.columns != 4 || el.type.descriptor.type != VarType::UInt) + if(el.type.columns != 4 || el.type.baseType != VarType::UInt) { reportError(tr("R10G10B10A2_UNORM packing must be specified on a 'uint4' variable.")); success = false; break; } - el.type.descriptor.flags |= ShaderVariableFlags::R10G10B10A2 | ShaderVariableFlags::UNorm; + el.type.flags |= ShaderVariableFlags::R10G10B10A2 | ShaderVariableFlags::UNorm; } else if(annot.param.toLower() == lit("r10g10b10a2_snorm")) { - if(el.type.descriptor.columns != 4 || el.type.descriptor.type != VarType::SInt) + if(el.type.columns != 4 || el.type.baseType != VarType::SInt) { reportError(tr("R10G10B10A2_SNORM packing must be specified on a 'int4' variable.")); success = false; break; } - el.type.descriptor.flags |= ShaderVariableFlags::R10G10B10A2 | ShaderVariableFlags::SNorm; + el.type.flags |= ShaderVariableFlags::R10G10B10A2 | ShaderVariableFlags::SNorm; } else if(annot.param.isEmpty()) { @@ -1476,72 +1475,69 @@ ParsedFormat BufferFormatter::ParseFormatString(const QString &formatString, uin { if(annot.name == lit("rgb")) { - el.type.descriptor.flags |= ShaderVariableFlags::RGBDisplay; + el.type.flags |= ShaderVariableFlags::RGBDisplay; } else if(annot.name == lit("hex") || annot.name == lit("hexadecimal")) { - if(VarTypeCompType(el.type.descriptor.type) == CompType::Float) + if(VarTypeCompType(el.type.baseType) == CompType::Float) { reportError(tr("Hex display is not supported on floating point variables.")); success = false; break; } - if(el.type.descriptor.flags & - (ShaderVariableFlags::R10G10B10A2 | ShaderVariableFlags::R11G11B10)) + if(el.type.flags & (ShaderVariableFlags::R10G10B10A2 | ShaderVariableFlags::R11G11B10)) { reportError(tr("Hex display is not supported on packed formats.")); success = false; break; } - el.type.descriptor.flags |= ShaderVariableFlags::HexDisplay; + el.type.flags |= ShaderVariableFlags::HexDisplay; - if(el.type.descriptor.type == VarType::SLong) - el.type.descriptor.type = VarType::ULong; - else if(el.type.descriptor.type == VarType::SInt) - el.type.descriptor.type = VarType::UInt; - else if(el.type.descriptor.type == VarType::SShort) - el.type.descriptor.type = VarType::UShort; - else if(el.type.descriptor.type == VarType::SByte) - el.type.descriptor.type = VarType::UByte; + if(el.type.baseType == VarType::SLong) + el.type.baseType = VarType::ULong; + else if(el.type.baseType == VarType::SInt) + el.type.baseType = VarType::UInt; + else if(el.type.baseType == VarType::SShort) + el.type.baseType = VarType::UShort; + else if(el.type.baseType == VarType::SByte) + el.type.baseType = VarType::UByte; } else if(annot.name == lit("bin") || annot.name == lit("binary")) { - if(VarTypeCompType(el.type.descriptor.type) == CompType::Float) + if(VarTypeCompType(el.type.baseType) == CompType::Float) { reportError(tr("Binary display is not supported on floating point variables.")); success = false; break; } - if(el.type.descriptor.flags & - (ShaderVariableFlags::R10G10B10A2 | ShaderVariableFlags::R11G11B10)) + if(el.type.flags & (ShaderVariableFlags::R10G10B10A2 | ShaderVariableFlags::R11G11B10)) { reportError(tr("Binary display is not supported on packed formats.")); success = false; break; } - el.type.descriptor.flags |= ShaderVariableFlags::BinaryDisplay; + el.type.flags |= ShaderVariableFlags::BinaryDisplay; - if(el.type.descriptor.type == VarType::SLong) - el.type.descriptor.type = VarType::ULong; - else if(el.type.descriptor.type == VarType::SInt) - el.type.descriptor.type = VarType::UInt; - else if(el.type.descriptor.type == VarType::SShort) - el.type.descriptor.type = VarType::UShort; - else if(el.type.descriptor.type == VarType::SByte) - el.type.descriptor.type = VarType::UByte; + if(el.type.baseType == VarType::SLong) + el.type.baseType = VarType::ULong; + else if(el.type.baseType == VarType::SInt) + el.type.baseType = VarType::UInt; + else if(el.type.baseType == VarType::SShort) + el.type.baseType = VarType::UShort; + else if(el.type.baseType == VarType::SByte) + el.type.baseType = VarType::UByte; } else if(annot.name == lit("unorm")) { - if(!(el.type.descriptor.flags & ShaderVariableFlags::R10G10B10A2)) + if(!(el.type.flags & ShaderVariableFlags::R10G10B10A2)) { // verify that we're integer typed and 1 or 2 bytes - if(el.type.descriptor.type != VarType::UShort && - el.type.descriptor.type != VarType::SShort && - el.type.descriptor.type != VarType::UByte && el.type.descriptor.type != VarType::SByte) + if(el.type.baseType != VarType::UShort && el.type.baseType != VarType::SShort && + el.type.baseType != VarType::UByte && el.type.baseType != VarType::SByte) { reportError(tr("UNORM packing is only supported on [u]byte and [u]short types.")); success = false; @@ -1549,16 +1545,15 @@ ParsedFormat BufferFormatter::ParseFormatString(const QString &formatString, uin } } - el.type.descriptor.flags |= ShaderVariableFlags::UNorm; + el.type.flags |= ShaderVariableFlags::UNorm; } else if(annot.name == lit("snorm")) { - if(!(el.type.descriptor.flags & ShaderVariableFlags::R10G10B10A2)) + if(!(el.type.flags & ShaderVariableFlags::R10G10B10A2)) { // verify that we're integer typed and 1 or 2 bytes - if(el.type.descriptor.type != VarType::UShort && - el.type.descriptor.type != VarType::SShort && - el.type.descriptor.type != VarType::UByte && el.type.descriptor.type != VarType::SByte) + if(el.type.baseType != VarType::UShort && el.type.baseType != VarType::SShort && + el.type.baseType != VarType::UByte && el.type.baseType != VarType::SByte) { reportError(tr("SNORM packing is only supported on [u]byte and [u]short types.")); success = false; @@ -1566,29 +1561,29 @@ ParsedFormat BufferFormatter::ParseFormatString(const QString &formatString, uin } } - el.type.descriptor.flags |= ShaderVariableFlags::SNorm; + el.type.flags |= ShaderVariableFlags::SNorm; } else if(annot.name == lit("row_major")) { - if(el.type.descriptor.rows == 1) + if(el.type.rows == 1) { reportError(tr("Row major can only be specified on matrices.")); success = false; break; } - el.type.descriptor.flags |= ShaderVariableFlags::RowMajorMatrix; + el.type.flags |= ShaderVariableFlags::RowMajorMatrix; } else if(annot.name == lit("col_major")) { - if(el.type.descriptor.rows == 1) + if(el.type.rows == 1) { reportError(tr("Column major can only be specified on matrices.")); success = false; break; } - el.type.descriptor.flags &= ~ShaderVariableFlags::RowMajorMatrix; + el.type.flags &= ~ShaderVariableFlags::RowMajorMatrix; } else if(annot.name == lit("packed")) { @@ -1660,27 +1655,26 @@ ParsedFormat BufferFormatter::ParseFormatString(const QString &formatString, uin // validate that bitfields are only allowed for regular scalars if(el.bitFieldSize > 0) { - if(el.type.descriptor.rows > 1 || el.type.descriptor.columns > 1) + if(el.type.rows > 1 || el.type.columns > 1) { reportError(tr("Vectors and matrices can't be packed into a bitfield.")); success = false; break; } - if(el.type.descriptor.elements > 1) + if(el.type.elements > 1) { reportError(tr("Arrays can't be packed into a bitfield.")); success = false; break; } - if(el.type.descriptor.flags & - (ShaderVariableFlags::R10G10B10A2 | ShaderVariableFlags::R11G11B10 | - ShaderVariableFlags::UNorm | ShaderVariableFlags::SNorm)) + if(el.type.flags & (ShaderVariableFlags::R10G10B10A2 | ShaderVariableFlags::R11G11B10 | + ShaderVariableFlags::UNorm | ShaderVariableFlags::SNorm)) { reportError(tr("Format-packed variables can't be packed into a bitfield.")); success = false; break; } - if(VarTypeCompType(el.type.descriptor.type) == CompType::Float) + if(VarTypeCompType(el.type.baseType) == CompType::Float) { reportError(tr("Floating point variables can't be packed into a bitfield.")); success = false; @@ -1690,62 +1684,60 @@ ParsedFormat BufferFormatter::ParseFormatString(const QString &formatString, uin if(basetype == lit("xlong") || basetype == lit("xint") || basetype == lit("xshort") || basetype == lit("xbyte")) - el.type.descriptor.flags |= ShaderVariableFlags::HexDisplay; + el.type.flags |= ShaderVariableFlags::HexDisplay; } - if(cur->singleMember && el.type.descriptor.elements == ~0U) + if(cur->singleMember && el.type.elements == ~0U) { reportError(tr("[[single]] can't be used on unbounded arrays.")); success = false; break; } - const bool packed32bit = bool(el.type.descriptor.flags & (ShaderVariableFlags::R10G10B10A2 | - ShaderVariableFlags::R11G11B10)); + const bool packed32bit = + bool(el.type.flags & (ShaderVariableFlags::R10G10B10A2 | ShaderVariableFlags::R11G11B10)); // normally the array stride is the size of an element const uint32_t elAlignment = packed32bit ? sizeof(uint32_t) : GetAlignment(pack, el); - const uint8_t vecSize = (el.type.descriptor.rows > 1 && el.type.descriptor.ColMajor()) - ? el.type.descriptor.rows - : el.type.descriptor.columns; + const uint8_t vecSize = (el.type.rows > 1 && el.type.ColMajor()) ? el.type.rows : el.type.columns; const uint32_t elSize = packed32bit ? sizeof(uint32_t) : (pack.vector_align_component ? elAlignment * vecSize : elAlignment); // if we aren't using tight arrays the stride is at least 16 bytes - el.type.descriptor.arrayByteStride = elAlignment; - if(el.type.descriptor.rows > 1 || el.type.descriptor.columns > 1) - el.type.descriptor.arrayByteStride = elSize; + el.type.arrayByteStride = elAlignment; + if(el.type.rows > 1 || el.type.columns > 1) + el.type.arrayByteStride = elSize; if(!pack.tight_arrays) - el.type.descriptor.arrayByteStride = std::max(16U, el.type.descriptor.arrayByteStride); + el.type.arrayByteStride = std::max(16U, el.type.arrayByteStride); // matrices are always aligned like arrays of vectors - if(el.type.descriptor.rows > 1) + if(el.type.rows > 1) { // the alignment calculated above is the alignment of a vector, that's our matrix stride - el.type.descriptor.matrixByteStride = el.type.descriptor.arrayByteStride; + el.type.matrixByteStride = el.type.arrayByteStride; // the array stride is that alignment times the number of rows/columns - if(el.type.descriptor.RowMajor()) - el.type.descriptor.arrayByteStride *= el.type.descriptor.rows; + if(el.type.RowMajor()) + el.type.arrayByteStride *= el.type.rows; else - el.type.descriptor.arrayByteStride *= el.type.descriptor.columns; + el.type.arrayByteStride *= el.type.columns; } if(el.bitFieldSize > 0) { // we can use the arrayByteStride since this is a scalar so no vector/arrays, this is just the // base size. It also works for enums as this is the byte size of the declared underlying type - const uint32_t elemScalarBitSize = el.type.descriptor.arrayByteStride * 8; + const uint32_t elemScalarBitSize = el.type.arrayByteStride * 8; // bitfields can't be larger than the base type if(el.bitFieldSize > elemScalarBitSize) { reportError(tr("Variable type %1 only has %2 bits, can't pack into %3 bits in a bitfield.") - .arg(el.type.descriptor.name) + .arg(el.type.name) .arg(elemScalarBitSize) .arg(el.bitFieldSize)); success = false; @@ -1823,7 +1815,7 @@ ParsedFormat BufferFormatter::ParseFormatString(const QString &formatString, uin cur->offset = AlignUp(cur->offset, elAlignment); // if we have non-tight arrays, arrays (and matrices) always start on a 16-byte boundary - if(!pack.tight_arrays && (el.type.descriptor.elements > 1 || el.type.descriptor.rows > 1)) + if(!pack.tight_arrays && (el.type.elements > 1 || el.type.rows > 1)) cur->offset = AlignUp(cur->offset, 16U); // if vectors can't straddle 16-byte alignment, check to see if we're going to do that @@ -1867,12 +1859,12 @@ ParsedFormat BufferFormatter::ParseFormatString(const QString &formatString, uin root = structelems[lastStruct]; fixed = root.structDef; - fixed.type.descriptor.arrayByteStride = AlignUp(root.offset, GetAlignment(pack, fixed)); + fixed.type.arrayByteStride = AlignUp(root.offset, GetAlignment(pack, fixed)); - if(!fixed.type.members.isEmpty() && fixed.type.members.back().type.descriptor.elements == ~0U) + if(!fixed.type.members.isEmpty() && fixed.type.members.back().type.elements == ~0U) { - fixed.type.descriptor.arrayByteStride = AlignUp( - fixed.type.members.back().type.descriptor.arrayByteStride, GetAlignment(pack, fixed)); + fixed.type.arrayByteStride = + AlignUp(fixed.type.members.back().type.arrayByteStride, GetAlignment(pack, fixed)); } if(success) @@ -1919,14 +1911,14 @@ ParsedFormat BufferFormatter::ParseFormatString(const QString &formatString, uin while(iter) { - if(iter->type.descriptor.elements == ~0U) + if(iter->type.elements == ~0U) { if(foundInfinite) { QString parentName; if(parent) - parentName = parent->type.descriptor.name; + parentName = parent->type.name; success = false; errors[infiniteArrayLine] = tr("Can't declare an unbounded array when child member %1 of " @@ -1939,7 +1931,7 @@ ParsedFormat BufferFormatter::ParseFormatString(const QString &formatString, uin foundInfinite = true; if(parent && parent != &fixed) - infiniteArrayLine = structelems[parent->type.descriptor.name].lineMemberDefs.back(); + infiniteArrayLine = structelems[parent->type.name].lineMemberDefs.back(); else infiniteArrayLine = root.lineMemberDefs.back(); } @@ -1965,7 +1957,7 @@ ParsedFormat BufferFormatter::ParseFormatString(const QString &formatString, uin // if we have an unbounded array somewhere (we know there's only one, from above) ContainsUnbounded(fixed) && // it must be in the root and it must be alone with no siblings - !(fixed.type.members.size() == 1 && fixed.type.members[0].type.descriptor.elements == ~0U)) + !(fixed.type.members.size() == 1 && fixed.type.members[0].type.elements == ~0U)) { errors[root.lineMemberDefs.back()] = tr("On D3D an unbounded array must be only be used alone as the root element.\n" @@ -1983,7 +1975,7 @@ ParsedFormat BufferFormatter::ParseFormatString(const QString &formatString, uin // if there's already only one root member just make it infinite if(fixed.type.members.size() == 1) { - fixed.type.members[0].type.descriptor.elements = ~0U; + fixed.type.members[0].type.elements = ~0U; } else { @@ -1993,9 +1985,9 @@ ParsedFormat BufferFormatter::ParseFormatString(const QString &formatString, uin ShaderConstant el; el.byteOffset = 0; - el.type.descriptor.type = VarType::Struct; - el.type.descriptor.elements = ~0U; - el.type.descriptor.arrayByteStride = fixed.type.descriptor.arrayByteStride; + el.type.baseType = VarType::Struct; + el.type.elements = ~0U; + el.type.arrayByteStride = fixed.type.arrayByteStride; fixed.type.members.push_back(el); inners.swap(fixed.type.members[0].type.members); @@ -2005,26 +1997,26 @@ ParsedFormat BufferFormatter::ParseFormatString(const QString &formatString, uin if(!success || fixed.type.members.isEmpty()) { fixed.type.members.clear(); - fixed.type.descriptor.type = VarType::Struct; + fixed.type.baseType = VarType::Struct; ShaderConstant el; el.byteOffset = 0; - el.type.descriptor.flags |= ShaderVariableFlags::HexDisplay; + el.type.flags |= ShaderVariableFlags::HexDisplay; el.name = "data"; - el.type.descriptor.type = VarType::UInt; - el.type.descriptor.columns = 4; - el.type.descriptor.elements = ~0U; + el.type.baseType = VarType::UInt; + el.type.columns = 4; + el.type.elements = ~0U; if(maxLen > 0 && maxLen < 16) - el.type.descriptor.columns = 1; + el.type.columns = 1; if(maxLen > 0 && maxLen < 4) - el.type.descriptor.type = VarType::UByte; + el.type.baseType = VarType::UByte; - el.type.descriptor.arrayByteStride = el.type.descriptor.matrixByteStride = - el.type.descriptor.columns * VarTypeByteSize(el.type.descriptor.type); + el.type.arrayByteStride = el.type.matrixByteStride = + el.type.columns * VarTypeByteSize(el.type.baseType); fixed.type.members.push_back(el); - fixed.type.descriptor.arrayByteStride = el.type.descriptor.arrayByteStride; + fixed.type.arrayByteStride = el.type.arrayByteStride; } // split the struct definition we have now into fixed and repeating. We've enforced above that @@ -2047,11 +2039,11 @@ ParsedFormat BufferFormatter::ParseFormatString(const QString &formatString, uin addedprefix += iter->name + "."; // we want to search the members so we can remove from the current iter - if(iter->type.members.back().type.descriptor.elements == ~0U) + if(iter->type.members.back().type.elements == ~0U) { ret.repeating = iter->type.members.back(); ret.repeating.name = addedprefix + ret.repeating.name; - ret.repeating.type.descriptor.elements = 1; + ret.repeating.type.elements = 1; iter->type.members.pop_back(); break; } @@ -2195,7 +2187,7 @@ QString BufferFormatter::GetBufferFormatString(Packing::Rules pack, const Shader if(!res.variableType.members.empty()) { - QString structName = res.variableType.descriptor.name; + QString structName = res.variableType.name; if(structName.isEmpty()) structName = lit("el"); @@ -2207,11 +2199,11 @@ QString BufferFormatter::GetBufferFormatString(Packing::Rules pack, const Shader } else { - const auto &desc = res.variableType.descriptor; + const auto &desc = res.variableType; if(viewFormat.type == ResourceFormatType::Undefined) { - if(desc.type == VarType::Unknown) + if(desc.baseType == VarType::Unknown) { format = desc.name; } @@ -2220,7 +2212,7 @@ QString BufferFormatter::GetBufferFormatString(Packing::Rules pack, const Shader if(desc.RowMajor() && desc.rows > 1 && desc.columns > 1) format += lit("[[row_major]] "); - format += ToQStr(desc.type); + format += ToQStr(desc.baseType); if(desc.rows > 1 && desc.columns > 1) format += QFormatStr("%1x%2").arg(desc.rows).arg(desc.columns); else if(desc.columns > 1) @@ -2302,8 +2294,8 @@ QString BufferFormatter::GetBufferFormatString(Packing::Rules pack, const Shader uint32_t BufferFormatter::GetVarStraddleSize(const ShaderConstant &var) { - if(var.type.descriptor.type == VarType::Enum) - return var.type.descriptor.arrayByteStride; + if(var.type.baseType == VarType::Enum) + return var.type.arrayByteStride; // structs don't themselves have a straddle size // this is fine because the struct members itself don't straddle, and the alignment of the max of @@ -2317,32 +2309,32 @@ uint32_t BufferFormatter::GetVarStraddleSize(const ShaderConstant &var) if(!var.type.members.empty()) return 0; - if(var.type.descriptor.rows > 1) - return var.type.descriptor.matrixByteStride; + if(var.type.rows > 1) + return var.type.matrixByteStride; - return VarTypeByteSize(var.type.descriptor.type) * var.type.descriptor.columns; + return VarTypeByteSize(var.type.baseType) * var.type.columns; } uint32_t BufferFormatter::GetVarSizeAndTrail(const ShaderConstant &var) { - if(var.type.descriptor.elements > 1 && var.type.descriptor.elements != ~0U) - return var.type.descriptor.arrayByteStride * var.type.descriptor.elements; + if(var.type.elements > 1 && var.type.elements != ~0U) + return var.type.arrayByteStride * var.type.elements; - if(var.type.descriptor.type == VarType::Enum) - return var.type.descriptor.arrayByteStride; + if(var.type.baseType == VarType::Enum) + return var.type.arrayByteStride; if(!var.type.members.empty()) - return var.type.descriptor.arrayByteStride; + return var.type.arrayByteStride; - if(var.type.descriptor.rows > 1) + if(var.type.rows > 1) { - if(var.type.descriptor.RowMajor()) - return var.type.descriptor.matrixByteStride * var.type.descriptor.rows; + if(var.type.RowMajor()) + return var.type.matrixByteStride * var.type.rows; else - return var.type.descriptor.matrixByteStride * var.type.descriptor.columns; + return var.type.matrixByteStride * var.type.columns; } - return VarTypeByteSize(var.type.descriptor.type) * var.type.descriptor.columns; + return VarTypeByteSize(var.type.baseType) * var.type.columns; } uint32_t BufferFormatter::GetVarAdvance(Packing::Rules pack, const ShaderConstant &var) @@ -2352,16 +2344,16 @@ uint32_t BufferFormatter::GetVarAdvance(Packing::Rules pack, const ShaderConstan // if we allow trailing overlap, remove the padding at the end of the struct/array if(pack.trailing_overlap) { - if(var.type.descriptor.type == VarType::Struct) + if(var.type.baseType == VarType::Struct) { - ret -= (var.type.descriptor.arrayByteStride - GetUnpaddedStructAdvance(pack, var.type.members)); + ret -= (var.type.arrayByteStride - GetUnpaddedStructAdvance(pack, var.type.members)); } - else if((var.type.descriptor.elements > 1 || var.type.descriptor.rows > 1) && !pack.tight_arrays) + else if((var.type.elements > 1 || var.type.rows > 1) && !pack.tight_arrays) { - uint8_t vecSize = var.type.descriptor.columns; + uint8_t vecSize = var.type.columns; - if(var.type.descriptor.rows > 1 && var.type.descriptor.ColMajor()) - vecSize = var.type.descriptor.rows; + if(var.type.rows > 1 && var.type.ColMajor()) + vecSize = var.type.rows; uint32_t elSize = GetAlignment(pack, var); if(pack.vector_align_component) @@ -2380,18 +2372,18 @@ uint32_t BufferFormatter::GetAlignment(Packing::Rules pack, const ShaderConstant { uint32_t ret = 1; - if(c.type.descriptor.type == VarType::Struct) + if(c.type.baseType == VarType::Struct) { for(const ShaderConstant &m : c.type.members) ret = std::max(ret, GetAlignment(pack, m)); } - else if(c.type.descriptor.type == VarType::Enum) + else if(c.type.baseType == VarType::Enum) { - ret = c.type.descriptor.arrayByteStride; + ret = c.type.arrayByteStride; } else if(c.type.members.empty()) { - uint32_t align = VarTypeByteSize(c.type.descriptor.type); + uint32_t align = VarTypeByteSize(c.type.baseType); // if vectors aren't component aligned we need to calculate the alignment based on the size of // the vectors @@ -2399,10 +2391,10 @@ uint32_t BufferFormatter::GetAlignment(Packing::Rules pack, const ShaderConstant { // column major matrices have vectors that are 'rows' long. Everything else is vectors of // 'columns' long - uint8_t vecSize = c.type.descriptor.columns; + uint8_t vecSize = c.type.columns; - if(c.type.descriptor.rows > 1 && c.type.descriptor.ColMajor()) - vecSize = c.type.descriptor.rows; + if(c.type.rows > 1 && c.type.ColMajor()) + vecSize = c.type.rows; // 3- and 4- vectors are 4-component aligned if(vecSize >= 3) @@ -2430,11 +2422,10 @@ uint32_t BufferFormatter::GetUnpaddedStructAdvance(Packing::Rules pack, const ShaderConstant *lastChild = &members.back(); lastMemberStart += lastChild->byteOffset; - while(lastChild->type.descriptor.type != VarType::Enum && !lastChild->type.members.isEmpty()) + while(lastChild->type.baseType != VarType::Enum && !lastChild->type.members.isEmpty()) { - if(lastChild->type.descriptor.elements != ~0U) - lastMemberStart += (qMax(lastChild->type.descriptor.elements, 1U) - 1) * - lastChild->type.descriptor.arrayByteStride; + if(lastChild->type.elements != ~0U) + lastMemberStart += (qMax(lastChild->type.elements, 1U) - 1) * lastChild->type.arrayByteStride; lastChild = &lastChild->type.members.back(); lastMemberStart += lastChild->byteOffset; } @@ -2474,9 +2465,8 @@ QString BufferFormatter::DeclareStruct(Packing::Rules pack, QList &decl } // if we don't have tight arrays, arrays and structs begin at 16-byte boundaries - if(!pack.tight_arrays && - (members[i].type.descriptor.type == VarType::Struct || - members[i].type.descriptor.elements > 1 || members[i].type.descriptor.rows > 1)) + if(!pack.tight_arrays && (members[i].type.baseType == VarType::Struct || + members[i].type.elements > 1 || members[i].type.rows > 1)) { offset = AlignUp(offset, 16U); } @@ -2493,22 +2483,22 @@ QString BufferFormatter::DeclareStruct(Packing::Rules pack, QList &decl offset += GetVarAdvance(pack, members[i]); QString arraySize; - if(members[i].type.descriptor.elements > 1) + if(members[i].type.elements > 1) { - if(members[i].type.descriptor.elements != ~0U) - arraySize = QFormatStr("[%1]").arg(members[i].type.descriptor.elements); + if(members[i].type.elements != ~0U) + arraySize = QFormatStr("[%1]").arg(members[i].type.elements); else arraySize = lit("[]"); } - QString varTypeName = members[i].type.descriptor.name; + QString varTypeName = members[i].type.name; - if(members[i].type.descriptor.pointerTypeID != ~0U) + if(members[i].type.pointerTypeID != ~0U) { const ShaderConstantType &pointeeType = - PointerTypeRegistry::GetTypeDescriptor(members[i].type.descriptor.pointerTypeID); + PointerTypeRegistry::GetTypeDescriptor(members[i].type.pointerTypeID); - varTypeName = pointeeType.descriptor.name; + varTypeName = pointeeType.name; varTypeName = varTypeName.replace(QLatin1Char('['), QLatin1Char('_')).replace(QLatin1Char(']'), QString()); @@ -2517,13 +2507,13 @@ QString BufferFormatter::DeclareStruct(Packing::Rules pack, QList &decl { declaredStructs.push_back(varTypeName); declarations += DeclareStruct(pack, declaredStructs, varTypeName, pointeeType.members, - pointeeType.descriptor.arrayByteStride, QString()) + + pointeeType.arrayByteStride, QString()) + lit("\n"); } varTypeName += lit("*"); } - else if(members[i].type.descriptor.type == VarType::Struct) + else if(members[i].type.baseType == VarType::Struct) { // GL structs don't give us typenames (boo!) so give them unique names. This will mean some // structs get duplicated if they're used in multiple places, but not much we can do about @@ -2538,7 +2528,7 @@ QString BufferFormatter::DeclareStruct(Packing::Rules pack, QList &decl { declaredStructs.push_back(varTypeName); declarations += DeclareStruct(pack, declaredStructs, varTypeName, members[i].type.members, - members[i].type.descriptor.arrayByteStride, QString()) + + members[i].type.arrayByteStride, QString()) + lit("\n"); } } @@ -2552,26 +2542,26 @@ QString BufferFormatter::DeclareStruct(Packing::Rules pack, QList &decl varName = varName.replace(QLatin1Char('['), QLatin1Char('_')).replace(QLatin1Char(']'), QString()); - if(members[i].type.descriptor.rows > 1) + if(members[i].type.rows > 1) { - if(members[i].type.descriptor.RowMajor()) + if(members[i].type.RowMajor()) varTypeName = lit("[[row_major]] ") + varTypeName; uint32_t stride = GetAlignment(pack, members[i]); if(pack.vector_align_component) { - if(members[i].type.descriptor.RowMajor()) - stride *= members[i].type.descriptor.columns; + if(members[i].type.RowMajor()) + stride *= members[i].type.columns; else - stride *= members[i].type.descriptor.rows; + stride *= members[i].type.rows; } if(!pack.tight_arrays) stride = 16; - if(stride != members[i].type.descriptor.matrixByteStride) - ret += lit("// unexpected matrix stride %1").arg(members[i].type.descriptor.matrixByteStride); + if(stride != members[i].type.matrixByteStride) + ret += lit("// unexpected matrix stride %1").arg(members[i].type.matrixByteStride); } ret += QFormatStr(" %1 %2%3;\n").arg(varTypeName).arg(varName).arg(arraySize); @@ -2614,27 +2604,27 @@ ResourceFormat GetInterpretedResourceFormat(const ShaderConstant &elem) ResourceFormat format; format.type = ResourceFormatType::Regular; - if(elem.type.descriptor.flags & ShaderVariableFlags::R10G10B10A2) + if(elem.type.flags & ShaderVariableFlags::R10G10B10A2) format.type = ResourceFormatType::R10G10B10A2; - else if(elem.type.descriptor.flags & ShaderVariableFlags::R11G11B10) + else if(elem.type.flags & ShaderVariableFlags::R11G11B10) format.type = ResourceFormatType::R11G11B10; - format.compType = VarTypeCompType(elem.type.descriptor.type); + format.compType = VarTypeCompType(elem.type.baseType); - if(elem.type.descriptor.flags & ShaderVariableFlags::UNorm) + if(elem.type.flags & ShaderVariableFlags::UNorm) format.compType = CompType::UNorm; - else if(elem.type.descriptor.flags & ShaderVariableFlags::SNorm) + else if(elem.type.flags & ShaderVariableFlags::SNorm) format.compType = CompType::SNorm; - format.compByteWidth = VarTypeByteSize(elem.type.descriptor.type); + format.compByteWidth = VarTypeByteSize(elem.type.baseType); - if(elem.type.descriptor.type == VarType::Enum) - format.compByteWidth = elem.type.descriptor.arrayByteStride; + if(elem.type.baseType == VarType::Enum) + format.compByteWidth = elem.type.arrayByteStride; - if(elem.type.descriptor.RowMajor() || elem.type.descriptor.rows == 1) - format.compCount = elem.type.descriptor.columns; + if(elem.type.RowMajor() || elem.type.rows == 1) + format.compCount = elem.type.columns; else - format.compCount = elem.type.descriptor.rows; + format.compCount = elem.type.rows; return format; } @@ -2644,12 +2634,12 @@ static void FillShaderVarData(ShaderVariable &var, const ShaderConstant &elem, c { int src = 0; - uint32_t outerCount = elem.type.descriptor.rows; - uint32_t innerCount = elem.type.descriptor.columns; + uint32_t outerCount = elem.type.rows; + uint32_t innerCount = elem.type.columns; bool colMajor = false; - if(elem.type.descriptor.ColMajor() && outerCount > 1) + if(elem.type.ColMajor() && outerCount > 1) { colMajor = true; std::swap(outerCount, innerCount); @@ -2717,21 +2707,21 @@ ShaderVariable InterpretShaderVar(const ShaderConstant &elem, const byte *data, ShaderVariable ret; ret.name = elem.name; - ret.type = elem.type.descriptor.type; - ret.columns = qMin(elem.type.descriptor.columns, uint8_t(4)); - ret.rows = qMin(elem.type.descriptor.rows, uint8_t(4)); + ret.type = elem.type.baseType; + ret.columns = qMin(elem.type.columns, uint8_t(4)); + ret.rows = qMin(elem.type.rows, uint8_t(4)); - ret.flags = elem.type.descriptor.flags; + ret.flags = elem.type.flags; - if(elem.type.descriptor.type != VarType::Enum && !elem.type.members.isEmpty()) + if(elem.type.baseType != VarType::Enum && !elem.type.members.isEmpty()) { ret.rows = ret.columns = 0; - if(elem.type.descriptor.elements > 1 && elem.type.descriptor.elements != ~0U) + if(elem.type.elements > 1 && elem.type.elements != ~0U) { rdcarray arrayElements; - for(uint32_t a = 0; a < elem.type.descriptor.elements; a++) + for(uint32_t a = 0; a < elem.type.elements; a++) { rdcarray members; @@ -2746,7 +2736,7 @@ ShaderVariable InterpretShaderVar(const ShaderConstant &elem, const byte *data, arrayElements.back().name = QFormatStr("%1[%2]").arg(ret.name).arg(a); arrayElements.back().members = members; - data += elem.type.descriptor.arrayByteStride; + data += elem.type.arrayByteStride; } ret.members = arrayElements; @@ -2765,19 +2755,19 @@ ShaderVariable InterpretShaderVar(const ShaderConstant &elem, const byte *data, ret.members = members; } } - else if(elem.type.descriptor.type == VarType::Struct && elem.type.members.isEmpty()) + else if(elem.type.baseType == VarType::Struct && elem.type.members.isEmpty()) { } - else if(elem.type.descriptor.elements > 1 && elem.type.descriptor.elements != ~0U) + else if(elem.type.elements > 1 && elem.type.elements != ~0U) { rdcarray arrayElements; - for(uint32_t a = 0; a < elem.type.descriptor.elements; a++) + for(uint32_t a = 0; a < elem.type.elements; a++) { arrayElements.push_back(ret); arrayElements.back().name = QFormatStr("%1[%2]").arg(ret.name).arg(a); FillShaderVarData(arrayElements.back(), elem, data, end); - data += elem.type.descriptor.arrayByteStride; + data += elem.type.arrayByteStride; } ret.rows = ret.columns = 0; @@ -2894,7 +2884,7 @@ inline T readObj(const byte *&data, const byte *end, bool &ok) QVariantList GetVariants(ResourceFormat format, const ShaderConstant &var, const byte *&data, const byte *end) { - const ShaderConstantDescriptor &varDesc = var.type.descriptor; + const ShaderConstantType &varType = var.type; QVariantList ret; @@ -3100,17 +3090,17 @@ QVariantList GetVariants(ResourceFormat format, const ShaderConstant &var, const { const byte *base = data; - uint32_t rowCount = varDesc.rows; - uint32_t colCount = varDesc.columns; + uint32_t rowCount = varType.rows; + uint32_t colCount = varType.columns; for(uint32_t row = 0; row < qMax(rowCount, 1U); row++) { for(uint32_t col = 0; col < qMax(colCount, 1U); col++) { - if(varDesc.RowMajor() || rowCount == 1) - data = base + row * varDesc.matrixByteStride + col * format.compByteWidth; + if(varType.RowMajor() || rowCount == 1) + data = base + row * varType.matrixByteStride + col * format.compByteWidth; else - data = base + col * varDesc.matrixByteStride + row * format.compByteWidth; + data = base + col * varType.matrixByteStride + row * format.compByteWidth; if(format.compType == CompType::Float) { @@ -3222,12 +3212,12 @@ QVariantList GetVariants(ResourceFormat format, const ShaderConstant &var, const ret.push_back(uint8_t(val)); } - if(var.type.descriptor.type == VarType::Enum) + if(var.type.baseType == VarType::Enum) { uint64_t val = ret.back().toULongLong(); QString str = QApplication::translate("BufferFormatter", "Unknown %1 (%2)") - .arg(QString(var.type.descriptor.name)) + .arg(QString(var.type.name)) .arg(val); for(size_t i = 0; i < var.type.members.size(); i++) @@ -3336,7 +3326,7 @@ QString TypeString(const ShaderVariable &v) } if(v.type == VarType::GPUPointer) - return PointerTypeRegistry::GetTypeDescriptor(v.GetPointer()).descriptor.name + "*"; + return PointerTypeRegistry::GetTypeDescriptor(v.GetPointer()).name + "*"; QString typeStr = ToQStr(v.type); @@ -3521,7 +3511,7 @@ QString RowTypeString(const ShaderVariable &v) return lit("-"); if(v.type == VarType::GPUPointer) - return PointerTypeRegistry::GetTypeDescriptor(v.GetPointer()).descriptor.name + "*"; + return PointerTypeRegistry::GetTypeDescriptor(v.GetPointer()).name + "*"; QString typeStr = ToQStr(v.type); diff --git a/qrenderdoc/Code/QRDUtils.cpp b/qrenderdoc/Code/QRDUtils.cpp index 302ed036c..bf04aa17b 100644 --- a/qrenderdoc/Code/QRDUtils.cpp +++ b/qrenderdoc/Code/QRDUtils.cpp @@ -86,7 +86,7 @@ void PointerTypeRegistry::Init() // type ID 0 is reserved as a NULL/empty descriptor typeDescriptions.resize(1); - typeDescriptions[0].descriptor.name = ""; + typeDescriptions[0].name = ""; } uint32_t PointerTypeRegistry::GetTypeID(ResourceId shader, uint32_t pointerTypeId) @@ -120,9 +120,9 @@ const ShaderConstantType &PointerTypeRegistry::GetTypeDescriptor(uint32_t typeId void PointerTypeRegistry::CacheSubTypes(const ShaderReflection *reflection, ShaderConstantType &structDef) { - if((structDef.descriptor.pointerTypeID & TypeIDBit) == 0) - structDef.descriptor.pointerTypeID = - PointerTypeRegistry::GetTypeID(reflection->pointerTypes[structDef.descriptor.pointerTypeID]); + if((structDef.pointerTypeID & TypeIDBit) == 0) + structDef.pointerTypeID = + PointerTypeRegistry::GetTypeID(reflection->pointerTypes[structDef.pointerTypeID]); for(ShaderConstant &member : structDef.members) CacheSubTypes(reflection, member.type); @@ -1070,8 +1070,8 @@ bool RichResourceTextMouseEvent(const QWidget *owner, const QVariant &var, QRect if(!ptrType.members.isEmpty()) formatter = BufferFormatter::DeclareStruct( - BufferFormatter::EstimatePackingRules(ptrType.members), ptrType.descriptor.name, - ptrType.members, ptrType.descriptor.arrayByteStride); + BufferFormatter::EstimatePackingRules(ptrType.members), ptrType.name, + ptrType.members, ptrType.arrayByteStride); IBufferViewer *view = ctx.ViewBuffer(ptr->offset, ~0ULL, ptr->base, formatter); diff --git a/qrenderdoc/Windows/BufferViewer.cpp b/qrenderdoc/Windows/BufferViewer.cpp index 27366e98e..11c481e7a 100644 --- a/qrenderdoc/Windows/BufferViewer.cpp +++ b/qrenderdoc/Windows/BufferViewer.cpp @@ -788,8 +788,8 @@ static QString interpretVariant(const QVariant &v, const ShaderConstant &el, memcpy(&u, &f, sizeof(f)); } - const bool hexDisplay = bool(el.type.descriptor.flags & ShaderVariableFlags::HexDisplay); - const bool binDisplay = bool(el.type.descriptor.flags & ShaderVariableFlags::BinaryDisplay); + const bool hexDisplay = bool(el.type.flags & ShaderVariableFlags::HexDisplay); + const bool binDisplay = bool(el.type.flags & ShaderVariableFlags::BinaryDisplay); if(hexDisplay && prop.format.type == ResourceFormatType::Regular) ret = Formatter::HexFormat(u, prop.format.compByteWidth); @@ -815,8 +815,8 @@ static QString interpretVariant(const QVariant &v, const ShaderConstant &el, } else if(vt == QMetaType::ULongLong) { - const bool hexDisplay = bool(el.type.descriptor.flags & ShaderVariableFlags::HexDisplay); - const bool binDisplay = bool(el.type.descriptor.flags & ShaderVariableFlags::BinaryDisplay); + const bool hexDisplay = bool(el.type.flags & ShaderVariableFlags::HexDisplay); + const bool binDisplay = bool(el.type.flags & ShaderVariableFlags::BinaryDisplay); if(binDisplay) ret = Formatter::BinFormat((uint64_t)v.toULongLong(), 8); @@ -919,7 +919,7 @@ public: { const ShaderConstant &el = elementForColumn(section); - if(el.type.descriptor.columns == 1 || role == columnGroupRole) + if(el.type.columns == 1 || role == columnGroupRole) return el.name; QChar comps[] = {QLatin1Char('x'), QLatin1Char('y'), QLatin1Char('z'), QLatin1Char('w')}; @@ -1030,8 +1030,7 @@ public: const ShaderConstant &el = elementForColumn(col); const BufferElementProperties &prop = propForColumn(col); - if((el.type.descriptor.flags & ShaderVariableFlags::RGBDisplay) && - prop.buffer < config.buffers.size()) + if((el.type.flags & ShaderVariableFlags::RGBDisplay) && prop.buffer < config.buffers.size()) { const byte *data = config.buffers[prop.buffer]->data(); const byte *end = config.buffers[prop.buffer]->end(); @@ -1204,18 +1203,18 @@ public: if(comp < list.count()) { - uint32_t rowdim = el.type.descriptor.rows; - uint32_t coldim = el.type.descriptor.columns; + uint32_t rowdim = el.type.rows; + uint32_t coldim = el.type.columns; if(rowdim == 1) { QVariant v = list[comp]; - if(el.type.descriptor.pointerTypeID != ~0U) + if(el.type.pointerTypeID != ~0U) { PointerVal ptr; ptr.pointer = v.toULongLong(); - ptr.pointerTypeID = el.type.descriptor.pointerTypeID; + ptr.pointerTypeID = el.type.pointerTypeID; v = ToQStr(ptr); } @@ -1393,7 +1392,7 @@ private: for(int i = 0; i < config.columns.count(); i++) { - uint32_t columnCount = config.columns[i].type.descriptor.columns; + uint32_t columnCount = config.columns[i].type.columns; for(uint32_t c = 0; c < columnCount; c++) { @@ -1493,9 +1492,9 @@ void CacheDataForIteration(QVector &cache, const rdcarray 0) d.instIdx = inst / prop.instancerate; @@ -1534,8 +1533,8 @@ static void ConfigureColumnsForShader(ICaptureContext &ctx, const ShaderReflecti BufferElementProperties p; f.name = !sig.varName.isEmpty() ? sig.varName : sig.semanticIdxName; - f.type.descriptor.rows = 1; - f.type.descriptor.columns = sig.compCount; + f.type.rows = 1; + f.type.columns = sig.compCount; p.buffer = 0; p.perinstance = false; @@ -1546,7 +1545,7 @@ static void ConfigureColumnsForShader(ICaptureContext &ctx, const ShaderReflecti p.format.compCount = sig.compCount; p.format.compType = VarTypeCompType(sig.varType); - f.type.descriptor.arrayByteStride = p.format.compByteWidth * p.format.compCount; + f.type.arrayByteStride = p.format.compByteWidth * p.format.compCount; if(sig.systemValue == ShaderBuiltin::Position) posidx = i; @@ -1572,7 +1571,7 @@ static void ConfigureColumnsForShader(ICaptureContext &ctx, const ShaderReflecti BufferElementProperties &prop = props[i]; ShaderConstant &el = columns[i]; - uint numComps = el.type.descriptor.columns; + uint numComps = el.type.columns; uint elemSize = prop.format.compByteWidth > 4 ? 8U : 4U; if(ctx.CurPipelineState().HasAlignedPostVSData( @@ -1613,8 +1612,8 @@ static void ConfigureMeshColumns(ICaptureContext &ctx, PopulateBufferData *bufda ShaderConstant f; f.name = "ERROR"; - f.type.descriptor.columns = 1; - f.type.descriptor.rows = 1; + f.type.columns = 1; + f.type.rows = 1; BufferElementProperties p; p.format.type = ResourceFormatType::Regular; @@ -1652,9 +1651,9 @@ static void ConfigureMeshColumns(ICaptureContext &ctx, PopulateBufferData *bufda ShaderConstant f; f.name = a.name; f.byteOffset = a.byteOffset; - f.type.descriptor.columns = a.format.compCount; - f.type.descriptor.rows = 1; - f.type.descriptor.arrayByteStride = f.type.descriptor.matrixByteStride = a.format.ElementSize(); + f.type.columns = a.format.compCount; + f.type.rows = 1; + f.type.arrayByteStride = f.type.matrixByteStride = a.format.ElementSize(); BufferElementProperties p; p.buffer = a.vertexBuffer; @@ -2040,9 +2039,9 @@ static void RT_FetchMeshData(IReplayController *r, ICaptureContext &ctx, Populat static int MaxNumRows(const ShaderConstant &c) { - int ret = c.type.descriptor.rows; + int ret = c.type.rows; - if(c.type.descriptor.type != VarType::Enum) + if(c.type.baseType != VarType::Enum) { for(const ShaderConstant &child : c.type.members) ret = qMax(ret, MaxNumRows(child)); @@ -2055,14 +2054,14 @@ static void UnrollConstant(rdcstr prefix, uint32_t baseOffset, const ShaderConst rdcarray &columns, rdcarray &props) { - bool isArray = constant.type.descriptor.elements > 1; + bool isArray = constant.type.elements > 1; rdcstr baseName = constant.name; if(!prefix.isEmpty()) baseName = prefix + "." + baseName; - if(constant.type.descriptor.type == VarType::Enum || constant.type.members.isEmpty()) + if(constant.type.baseType == VarType::Enum || constant.type.members.isEmpty()) { BufferElementProperties prop; prop.format = GetInterpretedResourceFormat(constant); @@ -2072,12 +2071,12 @@ static void UnrollConstant(rdcstr prefix, uint32_t baseOffset, const ShaderConst if(isArray) { - for(uint32_t a = 0; a < constant.type.descriptor.elements; a++) + for(uint32_t a = 0; a < constant.type.elements; a++) { c.name = QFormatStr("%1[%2]").arg(baseName).arg(a); columns.push_back(c); props.push_back(prop); - c.byteOffset += constant.type.descriptor.arrayByteStride; + c.byteOffset += constant.type.arrayByteStride; } } else @@ -2091,7 +2090,7 @@ static void UnrollConstant(rdcstr prefix, uint32_t baseOffset, const ShaderConst } // struct, expand by members - uint32_t arraySize = qMax(1U, constant.type.descriptor.elements); + uint32_t arraySize = qMax(1U, constant.type.elements); if(arraySize == ~0U) arraySize = 1U; for(uint32_t a = 0; a < arraySize; a++) @@ -2099,8 +2098,8 @@ static void UnrollConstant(rdcstr prefix, uint32_t baseOffset, const ShaderConst for(const ShaderConstant &child : constant.type.members) { UnrollConstant(isArray ? QFormatStr("%1[%2]").arg(baseName).arg(a) : QString(baseName), - baseOffset + constant.byteOffset + a * constant.type.descriptor.arrayByteStride, - child, columns, props); + baseOffset + constant.byteOffset + a * constant.type.arrayByteStride, child, + columns, props); } } } @@ -2576,8 +2575,7 @@ void BufferViewer::meshHeaderMenu(MeshDataStage stage, const QPoint &pos) m_CurFixed = false; m_ContextColumn = modelForStage(stage)->elementIndexForColumn(col); - m_SelectSecondAlphaColumn->setEnabled( - modelForStage(stage)->elementForColumn(col).type.descriptor.columns == 4); + m_SelectSecondAlphaColumn->setEnabled(modelForStage(stage)->elementForColumn(col).type.columns == 4); m_HeaderMenu->popup(tableForStage(stage)->horizontalHeader()->mapToGlobal(pos)); } @@ -2899,9 +2897,9 @@ void BufferViewer::OnEventChanged(uint32_t eventId) bufdata->vsinConfig.fixedVars = parsed.fixed; bufdata->vsinConfig.packing = parsed.packing; - if(parsed.repeating.type.descriptor.type != VarType::Unknown) + if(parsed.repeating.type.baseType != VarType::Unknown) { - bufdata->vsinConfig.repeatStride = parsed.repeating.type.descriptor.arrayByteStride; + bufdata->vsinConfig.repeatStride = parsed.repeating.type.arrayByteStride; bufdata->vsinConfig.repeatOffset = parsed.repeating.byteOffset; UnrollConstant(parsed.repeating, bufdata->vsinConfig.columns, bufdata->vsinConfig.props); @@ -3372,9 +3370,9 @@ void BufferViewer::UI_FixedAddMatrixRows(RDTreeWidgetItem *n, const ShaderConsta n->addChild(new RDTreeWidgetItem({QFormatStr("%1.row%2").arg(v.name).arg(r), RowString(v, r), QString(), RowTypeString(v)})); - if(showPadding && v.RowMajor() && c.type.descriptor.matrixByteStride > vecSize) + if(showPadding && v.RowMajor() && c.type.matrixByteStride > vecSize) { - uint32_t size = c.type.descriptor.matrixByteStride - vecSize; + uint32_t size = c.type.matrixByteStride - vecSize; RDTreeWidgetItem *pad = new RDTreeWidgetItem( {tr(""), QFormatStr("%1 bytes").arg(size), QString(), tr("Padding")}); @@ -3386,9 +3384,9 @@ void BufferViewer::UI_FixedAddMatrixRows(RDTreeWidgetItem *n, const ShaderConsta } } - if(showPadding && v.ColMajor() && c.type.descriptor.matrixByteStride > vecSize) + if(showPadding && v.ColMajor() && c.type.matrixByteStride > vecSize) { - uint32_t size = c.type.descriptor.matrixByteStride - vecSize; + uint32_t size = c.type.matrixByteStride - vecSize; RDTreeWidgetItem *pad = new RDTreeWidgetItem( {tr(""), QFormatStr("%1 bytes each column").arg(size), QString(), tr("Padding")}); @@ -3443,17 +3441,17 @@ void BufferViewer::UI_AddFixedVariables(RDTreeWidgetItem *root, uint32_t baseOff // if it's an array the value (v) will be expanded with one element in each of v.members, but // the constant (c) will just have the type with a number of elements - if(c.type.descriptor.elements > 1) + if(c.type.elements > 1) { ShaderConstant noarray = c; - noarray.type.descriptor.elements = 1; + noarray.type.elements = 1; // calculate the tight scalar-packed advance, so we can detect padding uint32_t elSize = BufferFormatter::GetVarAdvance(Packing::Scalar, noarray); for(uint32_t e = 0; e < v.members.size(); e++) { - const uint32_t elOffset = baseOffset + c.byteOffset + c.type.descriptor.arrayByteStride * e; + const uint32_t elOffset = baseOffset + c.byteOffset + c.type.arrayByteStride * e; RDTreeWidgetItem *el = new RDTreeWidgetItem( {v.members[e].name, VarString(v.members[e]), elOffset, TypeString(v.members[e])}); @@ -3462,7 +3460,7 @@ void BufferViewer::UI_AddFixedVariables(RDTreeWidgetItem *root, uint32_t baseOff // if it's an array of structs we can recurse, just need to do the outer iteration here // because v.members[...].members will be the actual struct members because of the expansion - if(c.type.descriptor.type == VarType::Struct) + if(c.type.baseType == VarType::Struct) { UI_AddFixedVariables(el, elOffset, c.type.members, v.members[e].members); } @@ -3477,12 +3475,12 @@ void BufferViewer::UI_AddFixedVariables(RDTreeWidgetItem *root, uint32_t baseOff // don't count the padding in the last struct in an array of structs, it will be handled as // padding after the array - if(c.type.descriptor.type == VarType::Struct && e + 1 == v.members.size()) + if(c.type.baseType == VarType::Struct && e + 1 == v.members.size()) break; - if(showPadding && c.type.descriptor.arrayByteStride > elSize) + if(showPadding && c.type.arrayByteStride > elSize) { - uint32_t size = c.type.descriptor.arrayByteStride - elSize; + uint32_t size = c.type.arrayByteStride - elSize; RDTreeWidgetItem *pad = new RDTreeWidgetItem( {QString(), QFormatStr("%1 bytes").arg(size), QString(), tr("Padding")}); @@ -3531,11 +3529,11 @@ void BufferViewer::calcBoundingData(CalcBoundingBoxData &bbox) { FloatVector maxvec(FLT_MAX, FLT_MAX, FLT_MAX, FLT_MAX); - if(s.columns[i].type.descriptor.columns == 1) + if(s.columns[i].type.columns == 1) maxvec.y = maxvec.z = maxvec.w = 0.0; - else if(s.columns[i].type.descriptor.columns == 2) + else if(s.columns[i].type.columns == 2) maxvec.z = maxvec.w = 0.0; - else if(s.columns[i].type.descriptor.columns == 3) + else if(s.columns[i].type.columns == 3) maxvec.w = 0.0; minOutputList.push_back(maxvec); @@ -3635,7 +3633,7 @@ void BufferViewer::UI_UpdateBoundingBoxLabels(int compCount) int posEl = model->posColumn(); if(posEl >= 0 && posEl < model->getConfig().columns.count()) { - compCount = model->getConfig().columns[posEl].type.descriptor.columns; + compCount = model->getConfig().columns[posEl].type.columns; } } } @@ -3848,7 +3846,7 @@ void BufferViewer::UI_CalculateMeshFormats() m_PostVSPosition = m_PostVS; m_PostVSPosition.vertexByteOffset += el.byteOffset; m_PostVSPosition.unproject = prop.systemValue == ShaderBuiltin::Position; - m_PostVSPosition.format.compCount = el.type.descriptor.columns; + m_PostVSPosition.format.compCount = el.type.columns; // if geometry/tessellation is enabled, don't unproject VS output data if(m_Ctx.CurPipelineState().GetShader(ShaderStage::Tess_Eval) != ResourceId() || @@ -4021,7 +4019,7 @@ void BufferViewer::UpdateCurrentMeshConfig() m_Config.maxBounds = bbox.bounds[stage].Max[posEl]; m_Config.showBBox = !isCurrentRasterOut(); - int compCount = model->getConfig().columns[posEl].type.descriptor.columns; + int compCount = model->getConfig().columns[posEl].type.columns; UI_UpdateBoundingBoxLabels(compCount); } @@ -4652,15 +4650,15 @@ void BufferViewer::CalcColumnWidth(int maxNumRows) ShaderConstant elem; elem.name = headerText; elem.byteOffset = 0; - elem.type.descriptor.rows = maxNumRows; - elem.type.descriptor.columns = 1; + elem.type.rows = maxNumRows; + elem.type.columns = 1; bufconfig.columns.clear(); bufconfig.columns.push_back(elem); bufconfig.props.push_back(floatProp); - elem.type.descriptor.rows = 1; + elem.type.rows = 1; elem.byteOffset = 4; bufconfig.columns.push_back(elem); @@ -4963,7 +4961,7 @@ void BufferViewer::processFormat(const QString &format) parsed = BufferFormatter::ParseFormatString(format, m_ByteSize, IsCBufferView()); } - const bool repeatedVars = parsed.repeating.type.descriptor.type != VarType::Unknown; + const bool repeatedVars = parsed.repeating.type.baseType != VarType::Unknown; const bool fixedVars = !parsed.fixed.type.members.empty(); if(fixedVars && repeatedVars) @@ -5075,7 +5073,7 @@ void BufferViewer::processFormat(const QString &format) } else { - qulonglong stride = qMax(1U, parsed.repeating.type.descriptor.arrayByteStride); + qulonglong stride = qMax(1U, parsed.repeating.type.arrayByteStride); byteRangeStart->setSingleStep(stride); byteRangeLength->setSingleStep(stride); diff --git a/qrenderdoc/Windows/PipelineState/D3D11PipelineStateViewer.cpp b/qrenderdoc/Windows/PipelineState/D3D11PipelineStateViewer.cpp index 663837fd7..8d5a7c439 100644 --- a/qrenderdoc/Windows/PipelineState/D3D11PipelineStateViewer.cpp +++ b/qrenderdoc/Windows/PipelineState/D3D11PipelineStateViewer.cpp @@ -796,10 +796,10 @@ void D3D11PipelineStateViewer::addResourceRow(const D3D11ViewTag &view, { if(r.viewFormat.compType == CompType::Typeless) { - if(shaderInput->variableType.descriptor.type == VarType::Struct) - format = lit("struct ") + shaderInput->variableType.descriptor.name; + if(shaderInput->variableType.baseType == VarType::Struct) + format = lit("struct ") + shaderInput->variableType.name; else - format = shaderInput->variableType.descriptor.name; + format = shaderInput->variableType.name; } else { @@ -2498,10 +2498,10 @@ QVariantList D3D11PipelineStateViewer::exportViewHTML(const D3D11Pipe::View &vie { if(view.viewFormat.compType == CompType::Typeless) { - if(shaderInput->variableType.descriptor.type == VarType::Struct) - viewFormat = format = lit("struct ") + shaderInput->variableType.descriptor.name; + if(shaderInput->variableType.baseType == VarType::Struct) + viewFormat = format = lit("struct ") + shaderInput->variableType.name; else - viewFormat = format = shaderInput->variableType.descriptor.name; + viewFormat = format = shaderInput->variableType.name; } else { diff --git a/qrenderdoc/Windows/PipelineState/D3D12PipelineStateViewer.cpp b/qrenderdoc/Windows/PipelineState/D3D12PipelineStateViewer.cpp index 56c80ae5d..3a3deee46 100644 --- a/qrenderdoc/Windows/PipelineState/D3D12PipelineStateViewer.cpp +++ b/qrenderdoc/Windows/PipelineState/D3D12PipelineStateViewer.cpp @@ -832,10 +832,10 @@ void D3D12PipelineStateViewer::addResourceRow(const D3D12ViewTag &view, const Bi // get the buffer type, whether it's just a basic type or a complex struct if(shaderInput && !shaderInput->isTexture) { - if(shaderInput->variableType.descriptor.type == VarType::Struct) - format = lit("struct ") + shaderInput->variableType.descriptor.name; + if(shaderInput->variableType.baseType == VarType::Struct) + format = lit("struct ") + shaderInput->variableType.name; else if(r.viewFormat.compType == CompType::Typeless) - format = shaderInput->variableType.descriptor.name; + format = shaderInput->variableType.name; else format = r.viewFormat.Name(); } @@ -2584,10 +2584,10 @@ QVariantList D3D12PipelineStateViewer::exportViewHTML(const D3D12Pipe::View &vie { if(view.viewFormat.compType == CompType::Typeless) { - if(shaderInput->variableType.descriptor.type == VarType::Struct) - viewFormat = format = lit("struct ") + shaderInput->variableType.descriptor.name; + if(shaderInput->variableType.baseType == VarType::Struct) + viewFormat = format = lit("struct ") + shaderInput->variableType.name; else - viewFormat = format = shaderInput->variableType.descriptor.name; + viewFormat = format = shaderInput->variableType.name; } else { @@ -3376,9 +3376,8 @@ bool D3D12PipelineStateViewer::isByteAddress(const D3D12Pipe::View &r, return true; if(r.viewFormat.type == ResourceFormatType::Undefined && r.elementByteSize == 4 && shaderInput && - shaderInput->variableType.descriptor.type == VarType::UByte && - shaderInput->variableType.descriptor.rows == 1 && - shaderInput->variableType.descriptor.columns == 1) + shaderInput->variableType.baseType == VarType::UByte && shaderInput->variableType.rows == 1 && + shaderInput->variableType.columns == 1) return true; return false; diff --git a/qrenderdoc/Windows/PipelineState/GLPipelineStateViewer.cpp b/qrenderdoc/Windows/PipelineState/GLPipelineStateViewer.cpp index eb8e9068b..adc56e5ee 100644 --- a/qrenderdoc/Windows/PipelineState/GLPipelineStateViewer.cpp +++ b/qrenderdoc/Windows/PipelineState/GLPipelineStateViewer.cpp @@ -1298,8 +1298,8 @@ GLPipelineStateViewer::GLReadWriteType GLPipelineStateViewer::GetGLReadWriteType } else { - if(res.variableType.descriptor.rows == 1 && res.variableType.descriptor.columns == 1 && - res.variableType.descriptor.type == VarType::UInt) + if(res.variableType.rows == 1 && res.variableType.columns == 1 && + res.variableType.baseType == VarType::UInt) { ret = GLReadWriteType::Atomic; } diff --git a/qrenderdoc/Windows/PipelineState/PipelineStateViewer.cpp b/qrenderdoc/Windows/PipelineState/PipelineStateViewer.cpp index 1a74be67e..81ba83363 100644 --- a/qrenderdoc/Windows/PipelineState/PipelineStateViewer.cpp +++ b/qrenderdoc/Windows/PipelineState/PipelineStateViewer.cpp @@ -743,9 +743,9 @@ void PipelineStateViewer::MakeShaderVariablesHLSL(bool cbufferContents, { for(const ShaderConstant &v : vars) { - if(v.type.descriptor.type == VarType::Struct) + if(v.type.baseType == VarType::Struct) { - QString def = lit("struct %1 {\n").arg(v.type.descriptor.name); + QString def = lit("struct %1 {\n").arg(v.type.name); if(!struct_defs.contains(def)) { @@ -756,14 +756,13 @@ void PipelineStateViewer::MakeShaderVariablesHLSL(bool cbufferContents, } } - if(v.type.descriptor.elements > 1) + if(v.type.elements > 1) { - struct_contents += - lit("\t%1 %2[%3]").arg(v.type.descriptor.name).arg(v.name).arg(v.type.descriptor.elements); + struct_contents += lit("\t%1 %2[%3]").arg(v.type.name).arg(v.name).arg(v.type.elements); } else { - struct_contents += lit("\t%1 %2").arg(v.type.descriptor.name).arg(v.name); + struct_contents += lit("\t%1 %2").arg(v.type.name).arg(v.name); } if((v.byteOffset % 4) != 0) @@ -875,18 +874,18 @@ QString PipelineStateViewer::GenerateHLSLStub(const ShaderBindpointMapping &bind { hlsl += lit("%1<%2> %3 : register(%4%5);\n") .arg(textureDim[(size_t)res.resType]) - .arg(res.variableType.descriptor.name) + .arg(res.variableType.name) .arg(res.name) .arg(QLatin1Char(regChar)) .arg(reg); } else { - if(res.variableType.descriptor.rows > 1) + if(res.variableType.rows > 1) hlsl += lit("Structured"); hlsl += lit("Buffer<%1> %2 : register(%3%4);\n") - .arg(res.variableType.descriptor.name) + .arg(res.variableType.name) .arg(res.name) .arg(QLatin1Char(regChar)) .arg(reg); diff --git a/renderdoc/api/replay/shader_types.h b/renderdoc/api/replay/shader_types.h index 6e41dc6db..640966c03 100644 --- a/renderdoc/api/replay/shader_types.h +++ b/renderdoc/api/replay/shader_types.h @@ -920,25 +920,25 @@ DECLARE_REFLECTION_STRUCT(SigParameter); struct ShaderConstant; -DOCUMENT("Describes the storage characteristics for a basic :class:`ShaderConstant` in memory."); -struct ShaderConstantDescriptor +DOCUMENT("Describes the type and members of a :class:`ShaderConstant`."); +struct ShaderConstantType { DOCUMENT(""); - ShaderConstantDescriptor() = default; - ShaderConstantDescriptor(const ShaderConstantDescriptor &) = default; - ShaderConstantDescriptor &operator=(const ShaderConstantDescriptor &) = default; + ShaderConstantType() = default; + ShaderConstantType(const ShaderConstantType &) = default; + ShaderConstantType &operator=(const ShaderConstantType &) = default; - bool operator==(const ShaderConstantDescriptor &o) const + bool operator==(const ShaderConstantType &o) const { - return type == o.type && rows == o.rows && columns == o.columns && flags == o.flags && + return baseType == o.baseType && rows == o.rows && columns == o.columns && flags == o.flags && elements == o.elements && arrayByteStride == o.arrayByteStride && matrixByteStride == o.matrixByteStride && pointerTypeID == o.pointerTypeID && - name == o.name; + name == o.name && members == o.members; } - bool operator<(const ShaderConstantDescriptor &o) const + bool operator<(const ShaderConstantType &o) const { - if(!(type == o.type)) - return type < o.type; + if(!(baseType == o.baseType)) + return baseType < o.baseType; if(!(rows == o.rows)) return rows < o.rows; if(!(columns == o.columns)) @@ -953,29 +953,36 @@ struct ShaderConstantDescriptor return matrixByteStride < o.matrixByteStride; if(!(name == o.name)) return name < o.name; + if(!(members == o.members)) + return members < o.members; return false; } DOCUMENT("The name of the type of this constant, e.g. a ``struct`` name."); rdcstr name; + DOCUMENT(R"(Any members that this constant may contain. + +:type: List[ShaderConstant] +)"); + rdcarray members; + DOCUMENT(R"(The flags controlling how this constant is interpreted and displayed. + +:type: ShaderVariableFlags +)"); + ShaderVariableFlags flags = ShaderVariableFlags::NoFlags; DOCUMENT("The index in :data:`ShaderReflection.pointerTypes` of the pointee type."); uint32_t pointerTypeID = ~0U; DOCUMENT("The number of elements in the array, or 1 if it's not an array."); uint32_t elements = 1; DOCUMENT("The number of bytes between the start of one element in the array and the next."); uint32_t arrayByteStride = 0; - DOCUMENT("The :class:`VarType` that this basic constant stores."); - VarType type = VarType::Unknown; + DOCUMENT("The base :class:`VarType` of this constant."); + VarType baseType = VarType::Unknown; DOCUMENT("The number of rows in this matrix."); uint8_t rows = 1; DOCUMENT("The number of columns in this matrix."); uint8_t columns = 1; DOCUMENT("The number of bytes between the start of one column/row in a matrix and the next."); uint8_t matrixByteStride = 0; - DOCUMENT(R"(The flags controlling how this constant is interpreted and displayed. - -:type: ShaderVariableFlags -)"); - ShaderVariableFlags flags = ShaderVariableFlags::NoFlags; DOCUMENT(R"(Helper function for checking if :data:`flags` has :data:`ShaderVariableFlags.RowMajorMatrix` set. This is entirely equivalent to checking that flag @@ -1001,41 +1008,6 @@ manually, but since it is common this helper is provided. inline bool ColMajor() const { return !(flags & ShaderVariableFlags::RowMajorMatrix); } }; -DECLARE_REFLECTION_STRUCT(ShaderConstantDescriptor); - -DOCUMENT("Describes the type and members of a :class:`ShaderConstant`."); -struct ShaderConstantType -{ - DOCUMENT(""); - ShaderConstantType() = default; - ShaderConstantType(const ShaderConstantType &) = default; - ShaderConstantType &operator=(const ShaderConstantType &) = default; - - bool operator==(const ShaderConstantType &o) const - { - return descriptor == o.descriptor && members == o.members; - } - bool operator<(const ShaderConstantType &o) const - { - if(!(descriptor == o.descriptor)) - return descriptor < o.descriptor; - if(!(members == o.members)) - return members < o.members; - return false; - } - DOCUMENT(R"(The description of this constant. - -:type: ShaderConstantDescriptor -)"); - ShaderConstantDescriptor descriptor; - - DOCUMENT(R"(Any members that this constant may contain. - -:type: List[ShaderConstant] -)"); - rdcarray members; -}; - DECLARE_REFLECTION_STRUCT(ShaderConstantType); DOCUMENT(R"(Contains the detail of a constant within a struct, such as a :class:`ConstantBlock`, diff --git a/renderdoc/data/glsl_shaders.cpp b/renderdoc/data/glsl_shaders.cpp index 650286628..dd79c1f89 100644 --- a/renderdoc/data/glsl_shaders.cpp +++ b/renderdoc/data/glsl_shaders.cpp @@ -320,10 +320,10 @@ void main() { INFO("UBO member: " << member.name.c_str()); CHECK(member.type.members.empty()); - CHECK(member.type.descriptor.type == VarType::Float); - CHECK(member.type.descriptor.rows == 1); - CHECK(member.type.descriptor.columns == 3); - CHECK(member.type.descriptor.elements == 5); + CHECK(member.type.baseType == VarType::Float); + CHECK(member.type.rows == 1); + CHECK(member.type.columns == 3); + CHECK(member.type.elements == 5); } CHECK(cblock.variables[1].name == "global_var2"); @@ -332,11 +332,11 @@ void main() { INFO("UBO member: " << member.name.c_str()); CHECK(member.type.members.empty()); - CHECK(member.type.descriptor.type == VarType::Float); - CHECK(member.type.descriptor.rows == 2); - CHECK(member.type.descriptor.columns == 3); - CHECK(member.type.descriptor.elements == 3); - CHECK(member.type.descriptor.ColMajor()); + CHECK(member.type.baseType == VarType::Float); + CHECK(member.type.rows == 2); + CHECK(member.type.columns == 3); + CHECK(member.type.elements == 3); + CHECK(member.type.ColMajor()); } } } @@ -383,9 +383,9 @@ void main() { CHECK(res.bindPoint == 0); CHECK(res.resType == TextureType::Buffer); CHECK(res.variableType.members.empty()); - CHECK(res.variableType.descriptor.type == VarType::UInt); - CHECK(res.variableType.descriptor.rows == 1); - CHECK(res.variableType.descriptor.columns == 1); + CHECK(res.variableType.baseType == VarType::UInt); + CHECK(res.variableType.rows == 1); + CHECK(res.variableType.columns == 1); } } @@ -462,7 +462,7 @@ void main() { CHECK(res.bindPoint == 0); CHECK(res.resType == TextureType::Texture2D); CHECK(res.variableType.members.empty()); - CHECK(res.variableType.descriptor.type == VarType::Float); + CHECK(res.variableType.baseType == VarType::Float); } CHECK(refl.readOnlyResources[1].name == "ST"); @@ -473,7 +473,7 @@ void main() { CHECK(res.bindPoint == 1); CHECK(res.resType == TextureType::Texture2D); CHECK(res.variableType.members.empty()); - CHECK(res.variableType.descriptor.type == VarType::Float); + CHECK(res.variableType.baseType == VarType::Float); } } @@ -536,10 +536,10 @@ void main() { INFO("UBO member: " << member.name.c_str()); CHECK(member.type.members.empty()); - CHECK(member.type.descriptor.type == VarType::SInt); - CHECK(member.type.descriptor.rows == 1); - CHECK(member.type.descriptor.columns == 1); - CHECK(member.type.descriptor.name == "int"); + CHECK(member.type.baseType == VarType::SInt); + CHECK(member.type.rows == 1); + CHECK(member.type.columns == 1); + CHECK(member.type.name == "int"); CHECK(member.byteOffset == 0); CHECK(member.defaultValue == 12); @@ -551,10 +551,10 @@ void main() { INFO("UBO member: " << member.name.c_str()); CHECK(member.type.members.empty()); - CHECK(member.type.descriptor.type == VarType::Float); - CHECK(member.type.descriptor.rows == 1); - CHECK(member.type.descriptor.columns == 1); - CHECK(member.type.descriptor.name == "float"); + CHECK(member.type.baseType == VarType::Float); + CHECK(member.type.rows == 1); + CHECK(member.type.columns == 1); + CHECK(member.type.name == "float"); CHECK(member.byteOffset == 8); float defaultValueFloat; @@ -623,10 +623,10 @@ void main() { CHECK(member.byteOffset == 0); CHECK(member.type.members.empty()); - CHECK(member.type.descriptor.type == VarType::SInt); - CHECK(member.type.descriptor.rows == 1); - CHECK(member.type.descriptor.columns == 1); - CHECK(member.type.descriptor.name == "int"); + CHECK(member.type.baseType == VarType::SInt); + CHECK(member.type.rows == 1); + CHECK(member.type.columns == 1); + CHECK(member.type.name == "int"); } CHECK(cblock.variables[1].name == "b"); @@ -636,9 +636,9 @@ void main() { CHECK(member.byteOffset == 4); CHECK(member.type.members.empty()); - CHECK(member.type.descriptor.type == VarType::Float); - CHECK(member.type.descriptor.rows == 1); - CHECK(member.type.descriptor.columns == 1); + CHECK(member.type.baseType == VarType::Float); + CHECK(member.type.rows == 1); + CHECK(member.type.columns == 1); } CHECK(cblock.variables[2].name == "c"); @@ -648,9 +648,9 @@ void main() { CHECK(member.byteOffset == 8); CHECK(member.type.members.empty()); - CHECK(member.type.descriptor.type == VarType::UInt); - CHECK(member.type.descriptor.rows == 1); - CHECK(member.type.descriptor.columns == 2); + CHECK(member.type.baseType == VarType::UInt); + CHECK(member.type.rows == 1); + CHECK(member.type.columns == 2); } } } @@ -947,10 +947,10 @@ void main() { CHECK(member.byteOffset == 0); CHECK(member.type.members.empty()); - CHECK(member.type.descriptor.type == VarType::Float); - CHECK(member.type.descriptor.rows == 1); - CHECK(member.type.descriptor.columns == 1); - CHECK(member.type.descriptor.name == "float"); + CHECK(member.type.baseType == VarType::Float); + CHECK(member.type.rows == 1); + CHECK(member.type.columns == 1); + CHECK(member.type.name == "float"); } CHECK(ubo_root[1].name == "ubo_b"); @@ -960,10 +960,10 @@ void main() { CHECK(member.byteOffset == 16); CHECK(member.type.members.empty()); - CHECK(member.type.descriptor.type == VarType::Float); - CHECK(member.type.descriptor.rows == 3); - CHECK(member.type.descriptor.columns == 4); - CHECK(member.type.descriptor.ColMajor()); + CHECK(member.type.baseType == VarType::Float); + CHECK(member.type.rows == 3); + CHECK(member.type.columns == 4); + CHECK(member.type.ColMajor()); } CHECK(ubo_root[2].name == "ubo_c"); @@ -973,10 +973,10 @@ void main() { CHECK(member.byteOffset == 80); CHECK(member.type.members.empty()); - CHECK(member.type.descriptor.type == VarType::Float); - CHECK(member.type.descriptor.rows == 3); - CHECK(member.type.descriptor.columns == 4); - CHECK(member.type.descriptor.RowMajor()); + CHECK(member.type.baseType == VarType::Float); + CHECK(member.type.rows == 3); + CHECK(member.type.columns == 4); + CHECK(member.type.RowMajor()); } CHECK(ubo_root[3].name == "ubo_d"); @@ -986,9 +986,9 @@ void main() { CHECK(member.byteOffset == 128); CHECK(member.type.members.empty()); - CHECK(member.type.descriptor.type == VarType::SInt); - CHECK(member.type.descriptor.rows == 1); - CHECK(member.type.descriptor.columns == 2); + CHECK(member.type.baseType == VarType::SInt); + CHECK(member.type.rows == 1); + CHECK(member.type.columns == 2); } CHECK(ubo_root[4].name == "ubo_e"); @@ -998,11 +998,11 @@ void main() { CHECK(member.byteOffset == 144); CHECK(member.type.members.empty()); - CHECK(member.type.descriptor.type == VarType::Float); - CHECK(member.type.descriptor.rows == 1); - CHECK(member.type.descriptor.columns == 2); - CHECK(member.type.descriptor.elements == 3); - CHECK(member.type.descriptor.arrayByteStride == 16); + CHECK(member.type.baseType == VarType::Float); + CHECK(member.type.rows == 1); + CHECK(member.type.columns == 2); + CHECK(member.type.elements == 3); + CHECK(member.type.arrayByteStride == 16); } CHECK(ubo_root[5].name == "ubo_f"); @@ -1011,8 +1011,8 @@ void main() { INFO("UBO member: " << member.name.c_str()); CHECK(member.byteOffset == 192); - CHECK(member.type.descriptor.type == VarType::Struct); - CHECK(member.type.descriptor.arrayByteStride == 48); + CHECK(member.type.baseType == VarType::Struct); + CHECK(member.type.arrayByteStride == 48); REQUIRE_ARRAY_SIZE(member.type.members.size(), 3); { @@ -1023,10 +1023,10 @@ void main() { CHECK(submember.byteOffset == 0); CHECK(submember.type.members.empty()); - CHECK(submember.type.descriptor.type == VarType::Float); - CHECK(submember.type.descriptor.rows == 1); - CHECK(submember.type.descriptor.columns == 1); - CHECK(submember.type.descriptor.name == "float"); + CHECK(submember.type.baseType == VarType::Float); + CHECK(submember.type.rows == 1); + CHECK(submember.type.columns == 1); + CHECK(submember.type.name == "float"); } CHECK(member.type.members[1].name == "b"); @@ -1036,10 +1036,10 @@ void main() { CHECK(submember.byteOffset == 4); CHECK(submember.type.members.empty()); - CHECK(submember.type.descriptor.type == VarType::SInt); - CHECK(submember.type.descriptor.rows == 1); - CHECK(submember.type.descriptor.columns == 1); - CHECK(submember.type.descriptor.name == "int"); + CHECK(submember.type.baseType == VarType::SInt); + CHECK(submember.type.rows == 1); + CHECK(submember.type.columns == 1); + CHECK(submember.type.name == "int"); } CHECK(member.type.members[2].name == "c"); @@ -1049,10 +1049,10 @@ void main() { CHECK(submember.byteOffset == 16); CHECK(submember.type.members.empty()); - CHECK(submember.type.descriptor.type == VarType::Float); - CHECK(submember.type.descriptor.rows == 2); - CHECK(submember.type.descriptor.columns == 2); - CHECK(submember.type.descriptor.ColMajor()); + CHECK(submember.type.baseType == VarType::Float); + CHECK(submember.type.rows == 2); + CHECK(submember.type.columns == 2); + CHECK(submember.type.ColMajor()); } } } @@ -1064,9 +1064,9 @@ void main() { CHECK(member.byteOffset == 256); CHECK(member.type.members.empty()); - CHECK(member.type.descriptor.type == VarType::Float); - CHECK(member.type.descriptor.rows == 1); - CHECK(member.type.descriptor.columns == 4); + CHECK(member.type.baseType == VarType::Float); + CHECK(member.type.rows == 1); + CHECK(member.type.columns == 4); } } } @@ -1119,7 +1119,7 @@ void main() { CHECK(res.bindPoint == 0); CHECK(res.resType == TextureType::Texture2D); CHECK(res.variableType.members.empty()); - CHECK(res.variableType.descriptor.type == VarType::Float); + CHECK(res.variableType.baseType == VarType::Float); } CHECK(refl.readOnlyResources[1].name == "tex3D"); @@ -1130,7 +1130,7 @@ void main() { CHECK(res.bindPoint == 1); CHECK(res.resType == TextureType::Texture3D); CHECK(res.variableType.members.empty()); - CHECK(res.variableType.descriptor.type == VarType::SInt); + CHECK(res.variableType.baseType == VarType::SInt); } CHECK(refl.readOnlyResources[2].name == "texBuf"); @@ -1141,7 +1141,7 @@ void main() { CHECK(res.bindPoint == 2); CHECK(res.resType == TextureType::Buffer); CHECK(res.variableType.members.empty()); - CHECK(res.variableType.descriptor.type == VarType::Float); + CHECK(res.variableType.baseType == VarType::Float); } } @@ -1292,8 +1292,8 @@ void main() { const ShaderConstant &member = ubo_root[0]; INFO("UBO member: " << member.name.c_str()); - CHECK(member.type.descriptor.type == VarType::Float); - CHECK(member.type.descriptor.elements == 1); + CHECK(member.type.baseType == VarType::Float); + CHECK(member.type.elements == 1); } CHECK(ubo_root[1].name == "normal_array"); @@ -1301,9 +1301,9 @@ void main() { const ShaderConstant &member = ubo_root[1]; INFO("UBO member: " << member.name.c_str()); - CHECK(member.type.descriptor.type == VarType::Float); - CHECK(member.type.descriptor.columns == 4); - CHECK(member.type.descriptor.elements == 3); + CHECK(member.type.baseType == VarType::Float); + CHECK(member.type.columns == 4); + CHECK(member.type.elements == 3); } CHECK(ubo_root[2].name == "infinite_array"); @@ -1311,11 +1311,11 @@ void main() { const ShaderConstant &member = ubo_root[2]; INFO("UBO member: " << member.name.c_str()); - CHECK(member.type.descriptor.type == VarType::Float); - CHECK(member.type.descriptor.columns == 4); + CHECK(member.type.baseType == VarType::Float); + CHECK(member.type.columns == 4); // UBOs don't really support infinite arrays - it will just be declared big enough for // the amount used statically - CHECK(member.type.descriptor.elements == 5); + CHECK(member.type.elements == 5); } } } @@ -1339,8 +1339,8 @@ void main() { const ShaderConstant &member = res.variableType.members[0]; INFO("SSBO member: " << member.name.c_str()); - CHECK(member.type.descriptor.type == VarType::Float); - CHECK(member.type.descriptor.elements == 1); + CHECK(member.type.baseType == VarType::Float); + CHECK(member.type.elements == 1); } CHECK(res.variableType.members[1].name == "normal_array"); @@ -1348,9 +1348,9 @@ void main() { const ShaderConstant &member = res.variableType.members[1]; INFO("SSBO member: " << member.name.c_str()); - CHECK(member.type.descriptor.type == VarType::Float); - CHECK(member.type.descriptor.columns == 4); - CHECK(member.type.descriptor.elements == 3); + CHECK(member.type.baseType == VarType::Float); + CHECK(member.type.columns == 4); + CHECK(member.type.elements == 3); } CHECK(res.variableType.members[2].name == "non_array"); @@ -1358,9 +1358,9 @@ void main() { const ShaderConstant &member = res.variableType.members[2]; INFO("SSBO member: " << member.name.c_str()); - CHECK(member.type.descriptor.type == VarType::Float); - CHECK(member.type.descriptor.columns == 4); - CHECK(member.type.descriptor.elements == 1); + CHECK(member.type.baseType == VarType::Float); + CHECK(member.type.columns == 4); + CHECK(member.type.elements == 1); } } } @@ -1377,8 +1377,8 @@ void main() { const ShaderConstant &member = res.variableType.members[0]; INFO("SSBO member: " << member.name.c_str()); - CHECK(member.type.descriptor.type == VarType::Float); - CHECK(member.type.descriptor.elements == 1); + CHECK(member.type.baseType == VarType::Float); + CHECK(member.type.elements == 1); } CHECK(res.variableType.members[1].name == "normal_array"); @@ -1386,9 +1386,9 @@ void main() { const ShaderConstant &member = res.variableType.members[1]; INFO("SSBO member: " << member.name.c_str()); - CHECK(member.type.descriptor.type == VarType::Float); - CHECK(member.type.descriptor.columns == 4); - CHECK(member.type.descriptor.elements == 3); + CHECK(member.type.baseType == VarType::Float); + CHECK(member.type.columns == 4); + CHECK(member.type.elements == 3); } CHECK(res.variableType.members[2].name == "bounded_array"); @@ -1396,9 +1396,9 @@ void main() { const ShaderConstant &member = res.variableType.members[2]; INFO("SSBO member: " << member.name.c_str()); - CHECK(member.type.descriptor.type == VarType::Float); - CHECK(member.type.descriptor.columns == 4); - CHECK(member.type.descriptor.elements == 5); + CHECK(member.type.baseType == VarType::Float); + CHECK(member.type.columns == 4); + CHECK(member.type.elements == 5); } } } @@ -1415,8 +1415,8 @@ void main() { const ShaderConstant &member = res.variableType.members[0]; INFO("SSBO member: " << member.name.c_str()); - CHECK(member.type.descriptor.type == VarType::Float); - CHECK(member.type.descriptor.elements == 1); + CHECK(member.type.baseType == VarType::Float); + CHECK(member.type.elements == 1); } CHECK(res.variableType.members[1].name == "normal_array"); @@ -1424,9 +1424,9 @@ void main() { const ShaderConstant &member = res.variableType.members[1]; INFO("SSBO member: " << member.name.c_str()); - CHECK(member.type.descriptor.type == VarType::Float); - CHECK(member.type.descriptor.columns == 4); - CHECK(member.type.descriptor.elements == 3); + CHECK(member.type.baseType == VarType::Float); + CHECK(member.type.columns == 4); + CHECK(member.type.elements == 3); } CHECK(res.variableType.members[2].name == "infinite_array"); @@ -1434,9 +1434,9 @@ void main() { const ShaderConstant &member = res.variableType.members[2]; INFO("SSBO member: " << member.name.c_str()); - CHECK(member.type.descriptor.type == VarType::Float); - CHECK(member.type.descriptor.columns == 4); - CHECK(member.type.descriptor.elements == ~0U); + CHECK(member.type.baseType == VarType::Float); + CHECK(member.type.columns == 4); + CHECK(member.type.elements == ~0U); } } } @@ -1453,8 +1453,8 @@ void main() { const ShaderConstant &member = res.variableType.members[0]; INFO("SSBO member: " << member.name.c_str()); - CHECK(member.type.descriptor.type == VarType::Float); - CHECK(member.type.descriptor.elements == 1); + CHECK(member.type.baseType == VarType::Float); + CHECK(member.type.elements == 1); } CHECK(res.variableType.members[1].name == "test"); @@ -1462,8 +1462,8 @@ void main() { const ShaderConstant &member = res.variableType.members[1]; INFO("SSBO member: " << member.name.c_str()); - CHECK(member.type.descriptor.type == VarType::Struct); - CHECK(member.type.descriptor.elements == 1); + CHECK(member.type.baseType == VarType::Struct); + CHECK(member.type.elements == 1); REQUIRE_ARRAY_SIZE(member.type.members.size(), 2); { @@ -1472,9 +1472,9 @@ void main() { const ShaderConstant &submember = member.type.members[0]; INFO("SSBO submember: " << submember.name.c_str()); - CHECK(submember.type.descriptor.type == VarType::Float); - CHECK(submember.type.descriptor.columns == 1); - CHECK(submember.type.descriptor.elements == 2); + CHECK(submember.type.baseType == VarType::Float); + CHECK(submember.type.columns == 1); + CHECK(submember.type.elements == 2); } CHECK(member.type.members[1].name == "b"); @@ -1482,9 +1482,9 @@ void main() { const ShaderConstant &submember = member.type.members[1]; INFO("SSBO submember: " << submember.name.c_str()); - CHECK(submember.type.descriptor.type == VarType::SInt); - CHECK(submember.type.descriptor.columns == 1); - CHECK(submember.type.descriptor.elements == 1); + CHECK(submember.type.baseType == VarType::SInt); + CHECK(submember.type.columns == 1); + CHECK(submember.type.elements == 1); } } } @@ -1494,16 +1494,16 @@ void main() { const ShaderConstant &member = res.variableType.members[2]; INFO("SSBO member: " << member.name.c_str()); - CHECK(member.type.descriptor.type == VarType::Struct); + CHECK(member.type.baseType == VarType::Struct); if(testType == ShaderType::GLSL) { // GL has no way of telling us the fixed size of a trailing array of structs, so we // report that it's infinite - CHECK(member.type.descriptor.elements == ~0U); + CHECK(member.type.elements == ~0U); } else { - CHECK(member.type.descriptor.elements == 2); + CHECK(member.type.elements == 2); } } } @@ -1521,8 +1521,8 @@ void main() { const ShaderConstant &member = res.variableType.members[0]; INFO("SSBO member: " << member.name.c_str()); - CHECK(member.type.descriptor.type == VarType::Float); - CHECK(member.type.descriptor.elements == 1); + CHECK(member.type.baseType == VarType::Float); + CHECK(member.type.elements == 1); } CHECK(res.variableType.members[1].name == "test"); @@ -1530,8 +1530,8 @@ void main() { const ShaderConstant &member = res.variableType.members[1]; INFO("SSBO member: " << member.name.c_str()); - CHECK(member.type.descriptor.type == VarType::Struct); - CHECK(member.type.descriptor.elements == 1); + CHECK(member.type.baseType == VarType::Struct); + CHECK(member.type.elements == 1); REQUIRE_ARRAY_SIZE(member.type.members.size(), 2); { @@ -1540,9 +1540,9 @@ void main() { const ShaderConstant &submember = member.type.members[0]; INFO("SSBO submember: " << submember.name.c_str()); - CHECK(submember.type.descriptor.type == VarType::Float); - CHECK(submember.type.descriptor.columns == 1); - CHECK(submember.type.descriptor.elements == 2); + CHECK(submember.type.baseType == VarType::Float); + CHECK(submember.type.columns == 1); + CHECK(submember.type.elements == 2); } CHECK(member.type.members[1].name == "b"); @@ -1550,9 +1550,9 @@ void main() { const ShaderConstant &submember = member.type.members[1]; INFO("SSBO submember: " << submember.name.c_str()); - CHECK(submember.type.descriptor.type == VarType::SInt); - CHECK(submember.type.descriptor.columns == 1); - CHECK(submember.type.descriptor.elements == 1); + CHECK(submember.type.baseType == VarType::SInt); + CHECK(submember.type.columns == 1); + CHECK(submember.type.elements == 1); } } } @@ -1562,8 +1562,8 @@ void main() { const ShaderConstant &member = res.variableType.members[2]; INFO("SSBO member: " << member.name.c_str()); - CHECK(member.type.descriptor.type == VarType::Struct); - CHECK(member.type.descriptor.elements == ~0U); + CHECK(member.type.baseType == VarType::Struct); + CHECK(member.type.elements == ~0U); } } } @@ -1580,8 +1580,8 @@ void main() { const ShaderConstant &member = res.variableType.members[0]; INFO("SSBO member: " << member.name.c_str()); - CHECK(member.type.descriptor.type == VarType::Float); - CHECK(member.type.descriptor.elements == 1); + CHECK(member.type.baseType == VarType::Float); + CHECK(member.type.elements == 1); } CHECK(res.variableType.members[1].name == "ssbo5_test"); @@ -1589,8 +1589,8 @@ void main() { const ShaderConstant &member = res.variableType.members[1]; INFO("SSBO member: " << member.name.c_str()); - CHECK(member.type.descriptor.type == VarType::Struct); - CHECK(member.type.descriptor.elements == 1); + CHECK(member.type.baseType == VarType::Struct); + CHECK(member.type.elements == 1); REQUIRE_ARRAY_SIZE(member.type.members.size(), 2); { @@ -1599,9 +1599,9 @@ void main() { const ShaderConstant &submember = member.type.members[0]; INFO("SSBO submember: " << submember.name.c_str()); - CHECK(submember.type.descriptor.type == VarType::Float); - CHECK(submember.type.descriptor.columns == 1); - CHECK(submember.type.descriptor.elements == 2); + CHECK(submember.type.baseType == VarType::Float); + CHECK(submember.type.columns == 1); + CHECK(submember.type.elements == 2); } CHECK(member.type.members[1].name == "b"); @@ -1609,9 +1609,9 @@ void main() { const ShaderConstant &submember = member.type.members[1]; INFO("SSBO submember: " << submember.name.c_str()); - CHECK(submember.type.descriptor.type == VarType::SInt); - CHECK(submember.type.descriptor.columns == 1); - CHECK(submember.type.descriptor.elements == 1); + CHECK(submember.type.baseType == VarType::SInt); + CHECK(submember.type.columns == 1); + CHECK(submember.type.elements == 1); } } } @@ -1621,16 +1621,16 @@ void main() { const ShaderConstant &member = res.variableType.members[2]; INFO("SSBO member: " << member.name.c_str()); - CHECK(member.type.descriptor.type == VarType::Struct); + CHECK(member.type.baseType == VarType::Struct); if(testType == ShaderType::GLSL) { // GL has no way of telling us the fixed size of a trailing array of structs, so we // report that it's infinite - CHECK(member.type.descriptor.elements == ~0U); + CHECK(member.type.elements == ~0U); } else { - CHECK(member.type.descriptor.elements == 2); + CHECK(member.type.elements == 2); } } } @@ -1648,8 +1648,8 @@ void main() { const ShaderConstant &member = res.variableType.members[0]; INFO("SSBO member: " << member.name.c_str()); - CHECK(member.type.descriptor.type == VarType::Float); - CHECK(member.type.descriptor.elements == 1); + CHECK(member.type.baseType == VarType::Float); + CHECK(member.type.elements == 1); } CHECK(res.variableType.members[1].name == "ssbo6_test"); @@ -1657,8 +1657,8 @@ void main() { const ShaderConstant &member = res.variableType.members[1]; INFO("SSBO member: " << member.name.c_str()); - CHECK(member.type.descriptor.type == VarType::Struct); - CHECK(member.type.descriptor.elements == 1); + CHECK(member.type.baseType == VarType::Struct); + CHECK(member.type.elements == 1); REQUIRE_ARRAY_SIZE(member.type.members.size(), 2); { @@ -1667,9 +1667,9 @@ void main() { const ShaderConstant &submember = member.type.members[0]; INFO("SSBO submember: " << submember.name.c_str()); - CHECK(submember.type.descriptor.type == VarType::Float); - CHECK(submember.type.descriptor.columns == 1); - CHECK(submember.type.descriptor.elements == 2); + CHECK(submember.type.baseType == VarType::Float); + CHECK(submember.type.columns == 1); + CHECK(submember.type.elements == 2); } CHECK(member.type.members[1].name == "b"); @@ -1677,9 +1677,9 @@ void main() { const ShaderConstant &submember = member.type.members[1]; INFO("SSBO submember: " << submember.name.c_str()); - CHECK(submember.type.descriptor.type == VarType::SInt); - CHECK(submember.type.descriptor.columns == 1); - CHECK(submember.type.descriptor.elements == 1); + CHECK(submember.type.baseType == VarType::SInt); + CHECK(submember.type.columns == 1); + CHECK(submember.type.elements == 1); } } } @@ -1689,8 +1689,8 @@ void main() { const ShaderConstant &member = res.variableType.members[2]; INFO("SSBO member: " << member.name.c_str()); - CHECK(member.type.descriptor.type == VarType::Struct); - CHECK(member.type.descriptor.elements == ~0U); + CHECK(member.type.baseType == VarType::Struct); + CHECK(member.type.elements == ~0U); } } } @@ -1766,12 +1766,12 @@ void main() { CHECK(member.byteOffset == 0); CHECK(member.type.members.empty()); - CHECK(member.type.descriptor.type == VarType::UInt); - CHECK(member.type.descriptor.rows == 1); - CHECK(member.type.descriptor.columns == 1); - CHECK(member.type.descriptor.elements == 10); - CHECK(member.type.descriptor.arrayByteStride == 4); - CHECK(member.type.descriptor.name == "uint"); + CHECK(member.type.baseType == VarType::UInt); + CHECK(member.type.rows == 1); + CHECK(member.type.columns == 1); + CHECK(member.type.elements == 10); + CHECK(member.type.arrayByteStride == 4); + CHECK(member.type.name == "uint"); } CHECK(res.variableType.members[1].name == "ssbo_b"); @@ -1780,9 +1780,9 @@ void main() { INFO("SSBO member: " << member.name.c_str()); CHECK(member.byteOffset == 40); - CHECK(member.type.descriptor.type == VarType::Struct); - CHECK(member.type.descriptor.arrayByteStride == 24); - CHECK(member.type.descriptor.elements == 3); + CHECK(member.type.baseType == VarType::Struct); + CHECK(member.type.arrayByteStride == 24); + CHECK(member.type.elements == 3); REQUIRE_ARRAY_SIZE(member.type.members.size(), 3); { @@ -1793,10 +1793,10 @@ void main() { CHECK(submember.byteOffset == 0); CHECK(submember.type.members.empty()); - CHECK(submember.type.descriptor.type == VarType::Float); - CHECK(submember.type.descriptor.rows == 1); - CHECK(submember.type.descriptor.columns == 1); - CHECK(submember.type.descriptor.name == "float"); + CHECK(submember.type.baseType == VarType::Float); + CHECK(submember.type.rows == 1); + CHECK(submember.type.columns == 1); + CHECK(submember.type.name == "float"); } CHECK(member.type.members[1].name == "b"); @@ -1806,10 +1806,10 @@ void main() { CHECK(submember.byteOffset == 4); CHECK(submember.type.members.empty()); - CHECK(submember.type.descriptor.type == VarType::SInt); - CHECK(submember.type.descriptor.rows == 1); - CHECK(submember.type.descriptor.columns == 1); - CHECK(submember.type.descriptor.name == "int"); + CHECK(submember.type.baseType == VarType::SInt); + CHECK(submember.type.rows == 1); + CHECK(submember.type.columns == 1); + CHECK(submember.type.name == "int"); } CHECK(member.type.members[2].name == "c"); @@ -1819,10 +1819,10 @@ void main() { CHECK(submember.byteOffset == 8); CHECK(submember.type.members.empty()); - CHECK(submember.type.descriptor.type == VarType::Float); - CHECK(submember.type.descriptor.rows == 2); - CHECK(submember.type.descriptor.columns == 2); - CHECK(submember.type.descriptor.ColMajor()); + CHECK(submember.type.baseType == VarType::Float); + CHECK(submember.type.rows == 2); + CHECK(submember.type.columns == 2); + CHECK(submember.type.ColMajor()); } } } @@ -1834,10 +1834,10 @@ void main() { CHECK(member.byteOffset == 112); CHECK(member.type.members.empty()); - CHECK(member.type.descriptor.type == VarType::Float); - CHECK(member.type.descriptor.rows == 1); - CHECK(member.type.descriptor.columns == 1); - CHECK(member.type.descriptor.name == "float"); + CHECK(member.type.baseType == VarType::Float); + CHECK(member.type.rows == 1); + CHECK(member.type.columns == 1); + CHECK(member.type.name == "float"); } } } @@ -1858,9 +1858,9 @@ void main() { INFO("SSBO member: " << member.name.c_str()); CHECK(member.byteOffset == 0); - CHECK(member.type.descriptor.type == VarType::Struct); - CHECK(member.type.descriptor.arrayByteStride == 48); - CHECK(member.type.descriptor.elements == ~0U); + CHECK(member.type.baseType == VarType::Struct); + CHECK(member.type.arrayByteStride == 48); + CHECK(member.type.elements == ~0U); REQUIRE_ARRAY_SIZE(member.type.members.size(), 2); { @@ -1870,8 +1870,8 @@ void main() { INFO("SSBO submember: " << submember.name.c_str()); CHECK(submember.byteOffset == 0); - CHECK(submember.type.descriptor.type == VarType::Struct); - CHECK(submember.type.descriptor.arrayByteStride == 24); + CHECK(submember.type.baseType == VarType::Struct); + CHECK(submember.type.arrayByteStride == 24); REQUIRE_ARRAY_SIZE(submember.type.members.size(), 3); { @@ -1882,10 +1882,10 @@ void main() { CHECK(subsubmember.byteOffset == 0); CHECK(subsubmember.type.members.empty()); - CHECK(subsubmember.type.descriptor.type == VarType::Float); - CHECK(subsubmember.type.descriptor.rows == 1); - CHECK(subsubmember.type.descriptor.columns == 1); - CHECK(subsubmember.type.descriptor.name == "float"); + CHECK(subsubmember.type.baseType == VarType::Float); + CHECK(subsubmember.type.rows == 1); + CHECK(subsubmember.type.columns == 1); + CHECK(subsubmember.type.name == "float"); } CHECK(submember.type.members[1].name == "b"); @@ -1895,10 +1895,10 @@ void main() { CHECK(subsubmember.byteOffset == 4); CHECK(subsubmember.type.members.empty()); - CHECK(subsubmember.type.descriptor.type == VarType::SInt); - CHECK(subsubmember.type.descriptor.rows == 1); - CHECK(subsubmember.type.descriptor.columns == 1); - CHECK(subsubmember.type.descriptor.name == "int"); + CHECK(subsubmember.type.baseType == VarType::SInt); + CHECK(subsubmember.type.rows == 1); + CHECK(subsubmember.type.columns == 1); + CHECK(subsubmember.type.name == "int"); } CHECK(submember.type.members[2].name == "c"); @@ -1908,10 +1908,10 @@ void main() { CHECK(subsubmember.byteOffset == 8); CHECK(subsubmember.type.members.empty()); - CHECK(subsubmember.type.descriptor.type == VarType::Float); - CHECK(subsubmember.type.descriptor.rows == 2); - CHECK(subsubmember.type.descriptor.columns == 2); - CHECK(subsubmember.type.descriptor.ColMajor()); + CHECK(subsubmember.type.baseType == VarType::Float); + CHECK(subsubmember.type.rows == 2); + CHECK(subsubmember.type.columns == 2); + CHECK(subsubmember.type.ColMajor()); } } } @@ -1922,8 +1922,8 @@ void main() { INFO("SSBO submember: " << submember.name.c_str()); CHECK(submember.byteOffset == 24); - CHECK(submember.type.descriptor.type == VarType::Struct); - CHECK(submember.type.descriptor.arrayByteStride == 24); + CHECK(submember.type.baseType == VarType::Struct); + CHECK(submember.type.arrayByteStride == 24); REQUIRE_ARRAY_SIZE(submember.type.members.size(), 3); { @@ -1934,10 +1934,10 @@ void main() { CHECK(subsubmember.byteOffset == 0); CHECK(subsubmember.type.members.empty()); - CHECK(subsubmember.type.descriptor.type == VarType::Float); - CHECK(subsubmember.type.descriptor.rows == 1); - CHECK(subsubmember.type.descriptor.columns == 1); - CHECK(subsubmember.type.descriptor.name == "float"); + CHECK(subsubmember.type.baseType == VarType::Float); + CHECK(subsubmember.type.rows == 1); + CHECK(subsubmember.type.columns == 1); + CHECK(subsubmember.type.name == "float"); } CHECK(submember.type.members[1].name == "b"); @@ -1947,10 +1947,10 @@ void main() { CHECK(subsubmember.byteOffset == 4); CHECK(subsubmember.type.members.empty()); - CHECK(subsubmember.type.descriptor.type == VarType::SInt); - CHECK(subsubmember.type.descriptor.rows == 1); - CHECK(subsubmember.type.descriptor.columns == 1); - CHECK(subsubmember.type.descriptor.name == "int"); + CHECK(subsubmember.type.baseType == VarType::SInt); + CHECK(subsubmember.type.rows == 1); + CHECK(subsubmember.type.columns == 1); + CHECK(subsubmember.type.name == "int"); } CHECK(submember.type.members[2].name == "c"); @@ -1960,10 +1960,10 @@ void main() { CHECK(subsubmember.byteOffset == 8); CHECK(subsubmember.type.members.empty()); - CHECK(subsubmember.type.descriptor.type == VarType::Float); - CHECK(subsubmember.type.descriptor.rows == 2); - CHECK(subsubmember.type.descriptor.columns == 2); - CHECK(subsubmember.type.descriptor.ColMajor()); + CHECK(subsubmember.type.baseType == VarType::Float); + CHECK(subsubmember.type.rows == 2); + CHECK(subsubmember.type.columns == 2); + CHECK(subsubmember.type.ColMajor()); } } } @@ -2698,7 +2698,7 @@ void main() { CHECK(res.bindPoint == (int32_t)i); CHECK(res.resType == TextureType::Texture2D); CHECK(res.variableType.members.empty()); - CHECK(res.variableType.descriptor.type == VarType::Float); + CHECK(res.variableType.baseType == VarType::Float); } } } @@ -2750,10 +2750,10 @@ void main() { CHECK(member.byteOffset == 0); CHECK(member.type.members.empty()); - CHECK(member.type.descriptor.type == VarType::Float); - CHECK(member.type.descriptor.rows == 1); - CHECK(member.type.descriptor.columns == 1); - CHECK(member.type.descriptor.name == "float"); + CHECK(member.type.baseType == VarType::Float); + CHECK(member.type.rows == 1); + CHECK(member.type.columns == 1); + CHECK(member.type.name == "float"); } CHECK(varType->members[1].name == "b"); @@ -2763,10 +2763,10 @@ void main() { CHECK(member.byteOffset == 4); CHECK(member.type.members.empty()); - CHECK(member.type.descriptor.type == VarType::SInt); - CHECK(member.type.descriptor.rows == 1); - CHECK(member.type.descriptor.columns == 1); - CHECK(member.type.descriptor.name == "int"); + CHECK(member.type.baseType == VarType::SInt); + CHECK(member.type.rows == 1); + CHECK(member.type.columns == 1); + CHECK(member.type.name == "int"); } } } diff --git a/renderdoc/driver/d3d11/d3d11_rendertexture.cpp b/renderdoc/driver/d3d11/d3d11_rendertexture.cpp index 1dda0a437..e506d26f9 100644 --- a/renderdoc/driver/d3d11/d3d11_rendertexture.cpp +++ b/renderdoc/driver/d3d11/d3d11_rendertexture.cpp @@ -632,8 +632,7 @@ bool D3D11Replay::RenderTextureInternal(TextureDisplay cfg, TexDisplayFlags flag if(var.name == "RENDERDOC_TexDim") { - if(var.type.descriptor.rows == 1 && var.type.descriptor.cols == 4 && - var.type.descriptor.varType == VarType::UInt) + if(var.type.rows == 1 && var.type.cols == 4 && var.type.varType == VarType::UInt) { uint32_t *d = (uint32_t *)(byteData + var.offset); @@ -662,8 +661,7 @@ bool D3D11Replay::RenderTextureInternal(TextureDisplay cfg, TexDisplayFlags flag } else if(var.name == "RENDERDOC_SelectedMip") { - if(var.type.descriptor.rows == 1 && var.type.descriptor.cols == 1 && - var.type.descriptor.varType == VarType::UInt) + if(var.type.rows == 1 && var.type.cols == 1 && var.type.varType == VarType::UInt) { uint32_t *d = (uint32_t *)(byteData + var.offset); @@ -677,8 +675,7 @@ bool D3D11Replay::RenderTextureInternal(TextureDisplay cfg, TexDisplayFlags flag } else if(var.name == "RENDERDOC_SelectedSliceFace") { - if(var.type.descriptor.rows == 1 && var.type.descriptor.cols == 1 && - var.type.descriptor.varType == VarType::UInt) + if(var.type.rows == 1 && var.type.cols == 1 && var.type.varType == VarType::UInt) { uint32_t *d = (uint32_t *)(byteData + var.offset); @@ -692,8 +689,7 @@ bool D3D11Replay::RenderTextureInternal(TextureDisplay cfg, TexDisplayFlags flag } else if(var.name == "RENDERDOC_SelectedSample") { - if(var.type.descriptor.rows == 1 && var.type.descriptor.cols == 1 && - var.type.descriptor.varType == VarType::SInt) + if(var.type.rows == 1 && var.type.cols == 1 && var.type.varType == VarType::SInt) { int32_t *d = (int32_t *)(byteData + var.offset); @@ -707,8 +703,7 @@ bool D3D11Replay::RenderTextureInternal(TextureDisplay cfg, TexDisplayFlags flag } else if(var.name == "RENDERDOC_TextureType") { - if(var.type.descriptor.rows == 1 && var.type.descriptor.cols == 1 && - var.type.descriptor.varType == VarType::UInt) + if(var.type.rows == 1 && var.type.cols == 1 && var.type.varType == VarType::UInt) { uint32_t *d = (uint32_t *)(byteData + var.offset); diff --git a/renderdoc/driver/d3d12/d3d12_rendertexture.cpp b/renderdoc/driver/d3d12/d3d12_rendertexture.cpp index 214d5f3e2..158936295 100644 --- a/renderdoc/driver/d3d12/d3d12_rendertexture.cpp +++ b/renderdoc/driver/d3d12/d3d12_rendertexture.cpp @@ -583,8 +583,7 @@ bool D3D12Replay::RenderTextureInternal(D3D12_CPU_DESCRIPTOR_HANDLE rtv, Texture if(var.name == "RENDERDOC_TexDim") { - if(var.type.descriptor.rows == 1 && var.type.descriptor.cols == 4 && - var.type.descriptor.varType == VarType::UInt) + if(var.type.rows == 1 && var.type.cols == 4 && var.type.varType == VarType::UInt) { uint32_t *d = (uint32_t *)(byteData + var.offset); @@ -617,8 +616,7 @@ bool D3D12Replay::RenderTextureInternal(D3D12_CPU_DESCRIPTOR_HANDLE rtv, Texture } else if(var.name == "RENDERDOC_SelectedMip") { - if(var.type.descriptor.rows == 1 && var.type.descriptor.cols == 1 && - var.type.descriptor.varType == VarType::UInt) + if(var.type.rows == 1 && var.type.cols == 1 && var.type.varType == VarType::UInt) { uint32_t *d = (uint32_t *)(byteData + var.offset); @@ -632,8 +630,7 @@ bool D3D12Replay::RenderTextureInternal(D3D12_CPU_DESCRIPTOR_HANDLE rtv, Texture } else if(var.name == "RENDERDOC_SelectedSliceFace") { - if(var.type.descriptor.rows == 1 && var.type.descriptor.cols == 1 && - var.type.descriptor.varType == VarType::UInt) + if(var.type.rows == 1 && var.type.cols == 1 && var.type.varType == VarType::UInt) { uint32_t *d = (uint32_t *)(byteData + var.offset); @@ -647,8 +644,7 @@ bool D3D12Replay::RenderTextureInternal(D3D12_CPU_DESCRIPTOR_HANDLE rtv, Texture } else if(var.name == "RENDERDOC_SelectedSample") { - if(var.type.descriptor.rows == 1 && var.type.descriptor.cols == 1 && - var.type.descriptor.varType == VarType::SInt) + if(var.type.rows == 1 && var.type.cols == 1 && var.type.varType == VarType::SInt) { int32_t *d = (int32_t *)(byteData + var.offset); @@ -664,8 +660,7 @@ bool D3D12Replay::RenderTextureInternal(D3D12_CPU_DESCRIPTOR_HANDLE rtv, Texture } else if(var.name == "RENDERDOC_TextureType") { - if(var.type.descriptor.rows == 1 && var.type.descriptor.cols == 1 && - var.type.descriptor.varType == VarType::UInt) + if(var.type.rows == 1 && var.type.cols == 1 && var.type.varType == VarType::UInt) { uint32_t *d = (uint32_t *)(byteData + var.offset); diff --git a/renderdoc/driver/gl/gl_driver.cpp b/renderdoc/driver/gl/gl_driver.cpp index 4ca0d662b..c40278213 100644 --- a/renderdoc/driver/gl/gl_driver.cpp +++ b/renderdoc/driver/gl/gl_driver.cpp @@ -5464,8 +5464,8 @@ void WrappedOpenGL::AddUsage(const ActionDescription &a) } else { - if(res.variableType.descriptor.columns == 1 && res.variableType.descriptor.rows == 1 && - res.variableType.descriptor.type == VarType::UInt) + if(res.variableType.columns == 1 && res.variableType.rows == 1 && + res.variableType.baseType == VarType::UInt) { if(rs.AtomicCounter[bind].res.name) m_ResourceUses[rm->GetResID(rs.AtomicCounter[bind].res)].push_back(rw); diff --git a/renderdoc/driver/gl/gl_program_iterate.cpp b/renderdoc/driver/gl/gl_program_iterate.cpp index e8cd4adac..b152682ab 100644 --- a/renderdoc/driver/gl/gl_program_iterate.cpp +++ b/renderdoc/driver/gl/gl_program_iterate.cpp @@ -88,140 +88,140 @@ struct UnrolledSPIRVConstant static GLenum MakeGLType(const ShaderConstantType &type) { - if(type.descriptor.type == VarType::Double) + if(type.baseType == VarType::Double) { - if(type.descriptor.columns == 4 && type.descriptor.rows == 4) + if(type.columns == 4 && type.rows == 4) return eGL_DOUBLE_MAT4; - if(type.descriptor.columns == 4 && type.descriptor.rows == 3) + if(type.columns == 4 && type.rows == 3) return eGL_DOUBLE_MAT4x3; - if(type.descriptor.columns == 4 && type.descriptor.rows == 2) + if(type.columns == 4 && type.rows == 2) return eGL_DOUBLE_MAT4x2; - if(type.descriptor.columns == 4 && type.descriptor.rows == 1) + if(type.columns == 4 && type.rows == 1) return eGL_DOUBLE_VEC4; - if(type.descriptor.columns == 3 && type.descriptor.rows == 4) + if(type.columns == 3 && type.rows == 4) return eGL_DOUBLE_MAT3x4; - if(type.descriptor.columns == 3 && type.descriptor.rows == 3) + if(type.columns == 3 && type.rows == 3) return eGL_DOUBLE_MAT3; - if(type.descriptor.columns == 3 && type.descriptor.rows == 2) + if(type.columns == 3 && type.rows == 2) return eGL_DOUBLE_MAT3x2; - if(type.descriptor.columns == 3 && type.descriptor.rows == 1) + if(type.columns == 3 && type.rows == 1) return eGL_DOUBLE_VEC3; - if(type.descriptor.columns == 2 && type.descriptor.rows == 4) + if(type.columns == 2 && type.rows == 4) return eGL_DOUBLE_MAT2x4; - if(type.descriptor.columns == 2 && type.descriptor.rows == 3) + if(type.columns == 2 && type.rows == 3) return eGL_DOUBLE_MAT2x4; - if(type.descriptor.columns == 2 && type.descriptor.rows == 2) + if(type.columns == 2 && type.rows == 2) return eGL_DOUBLE_MAT2; - if(type.descriptor.columns == 2 && type.descriptor.rows == 1) + if(type.columns == 2 && type.rows == 1) return eGL_DOUBLE_VEC2; - if(type.descriptor.columns == 1 && type.descriptor.rows == 4) + if(type.columns == 1 && type.rows == 4) return eGL_DOUBLE_VEC4; - if(type.descriptor.columns == 1 && type.descriptor.rows == 3) + if(type.columns == 1 && type.rows == 3) return eGL_DOUBLE_VEC3; - if(type.descriptor.columns == 1 && type.descriptor.rows == 2) + if(type.columns == 1 && type.rows == 2) return eGL_DOUBLE_VEC2; - if(type.descriptor.rows == 1 && type.descriptor.columns == 4) + if(type.rows == 1 && type.columns == 4) return eGL_DOUBLE_VEC4; - if(type.descriptor.rows == 1 && type.descriptor.columns == 3) + if(type.rows == 1 && type.columns == 3) return eGL_DOUBLE_VEC3; - if(type.descriptor.rows == 1 && type.descriptor.columns == 2) + if(type.rows == 1 && type.columns == 2) return eGL_DOUBLE_VEC2; return eGL_DOUBLE; } - else if(type.descriptor.type == VarType::Float) + else if(type.baseType == VarType::Float) { - if(type.descriptor.columns == 4 && type.descriptor.rows == 4) + if(type.columns == 4 && type.rows == 4) return eGL_FLOAT_MAT4; - if(type.descriptor.columns == 4 && type.descriptor.rows == 3) + if(type.columns == 4 && type.rows == 3) return eGL_FLOAT_MAT4x3; - if(type.descriptor.columns == 4 && type.descriptor.rows == 2) + if(type.columns == 4 && type.rows == 2) return eGL_FLOAT_MAT4x2; - if(type.descriptor.columns == 4 && type.descriptor.rows == 1) + if(type.columns == 4 && type.rows == 1) return eGL_FLOAT_VEC4; - if(type.descriptor.columns == 3 && type.descriptor.rows == 4) + if(type.columns == 3 && type.rows == 4) return eGL_FLOAT_MAT3x4; - if(type.descriptor.columns == 3 && type.descriptor.rows == 3) + if(type.columns == 3 && type.rows == 3) return eGL_FLOAT_MAT3; - if(type.descriptor.columns == 3 && type.descriptor.rows == 2) + if(type.columns == 3 && type.rows == 2) return eGL_FLOAT_MAT3x2; - if(type.descriptor.columns == 3 && type.descriptor.rows == 1) + if(type.columns == 3 && type.rows == 1) return eGL_FLOAT_VEC3; - if(type.descriptor.columns == 2 && type.descriptor.rows == 4) + if(type.columns == 2 && type.rows == 4) return eGL_FLOAT_MAT2x4; - if(type.descriptor.columns == 2 && type.descriptor.rows == 3) + if(type.columns == 2 && type.rows == 3) return eGL_FLOAT_MAT2x4; - if(type.descriptor.columns == 2 && type.descriptor.rows == 2) + if(type.columns == 2 && type.rows == 2) return eGL_FLOAT_MAT2; - if(type.descriptor.columns == 2 && type.descriptor.rows == 1) + if(type.columns == 2 && type.rows == 1) return eGL_FLOAT_VEC2; - if(type.descriptor.columns == 1 && type.descriptor.rows == 4) + if(type.columns == 1 && type.rows == 4) return eGL_FLOAT_VEC4; - if(type.descriptor.columns == 1 && type.descriptor.rows == 3) + if(type.columns == 1 && type.rows == 3) return eGL_FLOAT_VEC3; - if(type.descriptor.columns == 1 && type.descriptor.rows == 2) + if(type.columns == 1 && type.rows == 2) return eGL_FLOAT_VEC2; - if(type.descriptor.columns == 1 && type.descriptor.rows == 1) + if(type.columns == 1 && type.rows == 1) return eGL_FLOAT; - if(type.descriptor.rows == 1 && type.descriptor.columns == 4) + if(type.rows == 1 && type.columns == 4) return eGL_FLOAT_VEC4; - if(type.descriptor.rows == 1 && type.descriptor.columns == 3) + if(type.rows == 1 && type.columns == 3) return eGL_FLOAT_VEC3; - if(type.descriptor.rows == 1 && type.descriptor.columns == 2) + if(type.rows == 1 && type.columns == 2) return eGL_FLOAT_VEC2; - if(type.descriptor.rows == 1 && type.descriptor.columns == 1) + if(type.rows == 1 && type.columns == 1) return eGL_FLOAT; return eGL_FLOAT; } - else if(type.descriptor.type == VarType::SInt) + else if(type.baseType == VarType::SInt) { - if(type.descriptor.columns == 1 && type.descriptor.rows == 4) + if(type.columns == 1 && type.rows == 4) return eGL_INT_VEC4; - if(type.descriptor.columns == 1 && type.descriptor.rows == 3) + if(type.columns == 1 && type.rows == 3) return eGL_INT_VEC3; - if(type.descriptor.columns == 1 && type.descriptor.rows == 2) + if(type.columns == 1 && type.rows == 2) return eGL_INT_VEC2; - if(type.descriptor.columns == 1 && type.descriptor.rows == 1) + if(type.columns == 1 && type.rows == 1) return eGL_INT; - if(type.descriptor.rows == 1 && type.descriptor.columns == 4) + if(type.rows == 1 && type.columns == 4) return eGL_INT_VEC4; - if(type.descriptor.rows == 1 && type.descriptor.columns == 3) + if(type.rows == 1 && type.columns == 3) return eGL_INT_VEC3; - if(type.descriptor.rows == 1 && type.descriptor.columns == 2) + if(type.rows == 1 && type.columns == 2) return eGL_INT_VEC2; - if(type.descriptor.rows == 1 && type.descriptor.columns == 1) + if(type.rows == 1 && type.columns == 1) return eGL_INT; return eGL_INT; } - else if(type.descriptor.type == VarType::UInt) + else if(type.baseType == VarType::UInt) { - if(type.descriptor.columns == 1 && type.descriptor.rows == 4) + if(type.columns == 1 && type.rows == 4) return eGL_UNSIGNED_INT_VEC4; - if(type.descriptor.columns == 1 && type.descriptor.rows == 3) + if(type.columns == 1 && type.rows == 3) return eGL_UNSIGNED_INT_VEC3; - if(type.descriptor.columns == 1 && type.descriptor.rows == 2) + if(type.columns == 1 && type.rows == 2) return eGL_UNSIGNED_INT_VEC2; - if(type.descriptor.columns == 1 && type.descriptor.rows == 1) + if(type.columns == 1 && type.rows == 1) return eGL_UNSIGNED_INT; - if(type.descriptor.rows == 1 && type.descriptor.columns == 4) + if(type.rows == 1 && type.columns == 4) return eGL_UNSIGNED_INT_VEC4; - if(type.descriptor.rows == 1 && type.descriptor.columns == 3) + if(type.rows == 1 && type.columns == 3) return eGL_UNSIGNED_INT_VEC3; - if(type.descriptor.rows == 1 && type.descriptor.columns == 2) + if(type.rows == 1 && type.columns == 2) return eGL_UNSIGNED_INT_VEC2; - if(type.descriptor.rows == 1 && type.descriptor.columns == 1) + if(type.rows == 1 && type.columns == 1) return eGL_UNSIGNED_INT; return eGL_UNSIGNED_INT; @@ -249,7 +249,7 @@ static void UnrollConstant(rdcarray &unrolled, const Shad name = var.name; } - const uint32_t arraySize = RDCMAX(1U, var.type.descriptor.elements); + const uint32_t arraySize = RDCMAX(1U, var.type.elements); if(var.type.members.empty()) { diff --git a/renderdoc/driver/gl/gl_replay.cpp b/renderdoc/driver/gl/gl_replay.cpp index 7832894db..dc76919c9 100644 --- a/renderdoc/driver/gl/gl_replay.cpp +++ b/renderdoc/driver/gl/gl_replay.cpp @@ -2083,7 +2083,7 @@ void GLReplay::OpenGLFillCBufferVariables(ResourceId shader, GLuint prog, bool b for(int32_t i = 0; i < variables.count(); i++) { - const ShaderConstantDescriptor &desc = variables[i].type.descriptor; + const ShaderConstantType &desc = variables[i].type; // remove implicit '.' for recursing through "structs" if it's actually a multi-dimensional // array. @@ -2094,7 +2094,7 @@ void GLReplay::OpenGLFillCBufferVariables(ResourceId shader, GLuint prog, bool b var.name = variables[i].name; var.rows = desc.rows; var.columns = desc.columns; - var.type = desc.type; + var.type = desc.baseType; var.flags = desc.flags; const uint32_t matStride = desc.matrixByteStride; diff --git a/renderdoc/driver/gl/gl_shader_refl.cpp b/renderdoc/driver/gl/gl_shader_refl.cpp index 6cf75e1c7..2b53f5471 100644 --- a/renderdoc/driver/gl/gl_shader_refl.cpp +++ b/renderdoc/driver/gl/gl_shader_refl.cpp @@ -567,7 +567,7 @@ void ReconstructVarTree(GLenum query, GLuint sepProg, GLuint varIdx, GLint numPa ShaderConstant var; - var.type.descriptor.elements = RDCMAX(1, values[4]); + var.type.elements = RDCMAX(1, values[4]); // set type (or bail if it's not a variable - sampler or such) switch(values[0]) @@ -584,7 +584,7 @@ void ReconstructVarTree(GLenum query, GLuint sepProg, GLuint varIdx, GLint numPa case eGL_FLOAT_MAT3x4: case eGL_FLOAT_MAT3x2: case eGL_FLOAT_MAT2x4: - case eGL_FLOAT_MAT2x3: var.type.descriptor.type = VarType::Float; break; + case eGL_FLOAT_MAT2x3: var.type.baseType = VarType::Float; break; case eGL_DOUBLE_VEC4: case eGL_DOUBLE_VEC3: case eGL_DOUBLE_VEC2: @@ -597,7 +597,7 @@ void ReconstructVarTree(GLenum query, GLuint sepProg, GLuint varIdx, GLint numPa case eGL_DOUBLE_MAT3x4: case eGL_DOUBLE_MAT3x2: case eGL_DOUBLE_MAT2x4: - case eGL_DOUBLE_MAT2x3: var.type.descriptor.type = VarType::Double; break; + case eGL_DOUBLE_MAT2x3: var.type.baseType = VarType::Double; break; case eGL_UNSIGNED_INT_VEC4: case eGL_UNSIGNED_INT_VEC3: case eGL_UNSIGNED_INT_VEC2: @@ -605,18 +605,18 @@ void ReconstructVarTree(GLenum query, GLuint sepProg, GLuint varIdx, GLint numPa case eGL_BOOL_VEC4: case eGL_BOOL_VEC3: case eGL_BOOL_VEC2: - case eGL_BOOL: var.type.descriptor.type = VarType::UInt; break; + case eGL_BOOL: var.type.baseType = VarType::UInt; break; case eGL_INT_VEC4: case eGL_INT_VEC3: case eGL_INT_VEC2: - case eGL_INT: var.type.descriptor.type = VarType::SInt; break; + case eGL_INT: var.type.baseType = VarType::SInt; break; default: // not a variable (sampler etc) return; } // set # rows if it's a matrix - var.type.descriptor.rows = 1; + var.type.rows = 1; switch(values[0]) { @@ -625,19 +625,19 @@ void ReconstructVarTree(GLenum query, GLuint sepProg, GLuint varIdx, GLint numPa case eGL_FLOAT_MAT2x4: case eGL_DOUBLE_MAT2x4: case eGL_FLOAT_MAT3x4: - case eGL_DOUBLE_MAT3x4: var.type.descriptor.rows = 4; break; + case eGL_DOUBLE_MAT3x4: var.type.rows = 4; break; case eGL_FLOAT_MAT3: case eGL_DOUBLE_MAT3: case eGL_FLOAT_MAT4x3: case eGL_DOUBLE_MAT4x3: case eGL_FLOAT_MAT2x3: - case eGL_DOUBLE_MAT2x3: var.type.descriptor.rows = 3; break; + case eGL_DOUBLE_MAT2x3: var.type.rows = 3; break; case eGL_FLOAT_MAT2: case eGL_DOUBLE_MAT2: case eGL_FLOAT_MAT4x2: case eGL_DOUBLE_MAT4x2: case eGL_FLOAT_MAT3x2: - case eGL_DOUBLE_MAT3x2: var.type.descriptor.rows = 2; break; + case eGL_DOUBLE_MAT3x2: var.type.rows = 2; break; default: break; } @@ -654,7 +654,7 @@ void ReconstructVarTree(GLenum query, GLuint sepProg, GLuint varIdx, GLint numPa case eGL_DOUBLE_MAT4x3: case eGL_UNSIGNED_INT_VEC4: case eGL_BOOL_VEC4: - case eGL_INT_VEC4: var.type.descriptor.columns = 4; break; + case eGL_INT_VEC4: var.type.columns = 4; break; case eGL_FLOAT_VEC3: case eGL_FLOAT_MAT3: case eGL_FLOAT_MAT3x4: @@ -665,7 +665,7 @@ void ReconstructVarTree(GLenum query, GLuint sepProg, GLuint varIdx, GLint numPa case eGL_DOUBLE_MAT3x2: case eGL_UNSIGNED_INT_VEC3: case eGL_BOOL_VEC3: - case eGL_INT_VEC3: var.type.descriptor.columns = 3; break; + case eGL_INT_VEC3: var.type.columns = 3; break; case eGL_FLOAT_VEC2: case eGL_FLOAT_MAT2: case eGL_FLOAT_MAT2x4: @@ -676,56 +676,56 @@ void ReconstructVarTree(GLenum query, GLuint sepProg, GLuint varIdx, GLint numPa case eGL_DOUBLE_MAT2x3: case eGL_UNSIGNED_INT_VEC2: case eGL_BOOL_VEC2: - case eGL_INT_VEC2: var.type.descriptor.columns = 2; break; + case eGL_INT_VEC2: var.type.columns = 2; break; case eGL_FLOAT: case eGL_DOUBLE: case eGL_UNSIGNED_INT: case eGL_INT: - case eGL_BOOL: var.type.descriptor.columns = 1; break; + case eGL_BOOL: var.type.columns = 1; break; default: break; } // set name switch(values[0]) { - case eGL_FLOAT_VEC4: var.type.descriptor.name = "vec4"; break; - case eGL_FLOAT_VEC3: var.type.descriptor.name = "vec3"; break; - case eGL_FLOAT_VEC2: var.type.descriptor.name = "vec2"; break; - case eGL_FLOAT: var.type.descriptor.name = "float"; break; - case eGL_FLOAT_MAT4: var.type.descriptor.name = "mat4"; break; - case eGL_FLOAT_MAT3: var.type.descriptor.name = "mat3"; break; - case eGL_FLOAT_MAT2: var.type.descriptor.name = "mat2"; break; - case eGL_FLOAT_MAT4x2: var.type.descriptor.name = "mat4x2"; break; - case eGL_FLOAT_MAT4x3: var.type.descriptor.name = "mat4x3"; break; - case eGL_FLOAT_MAT3x4: var.type.descriptor.name = "mat3x4"; break; - case eGL_FLOAT_MAT3x2: var.type.descriptor.name = "mat3x2"; break; - case eGL_FLOAT_MAT2x4: var.type.descriptor.name = "mat2x4"; break; - case eGL_FLOAT_MAT2x3: var.type.descriptor.name = "mat2x3"; break; - case eGL_DOUBLE_VEC4: var.type.descriptor.name = "dvec4"; break; - case eGL_DOUBLE_VEC3: var.type.descriptor.name = "dvec3"; break; - case eGL_DOUBLE_VEC2: var.type.descriptor.name = "dvec2"; break; - case eGL_DOUBLE: var.type.descriptor.name = "double"; break; - case eGL_DOUBLE_MAT4: var.type.descriptor.name = "dmat4"; break; - case eGL_DOUBLE_MAT3: var.type.descriptor.name = "dmat3"; break; - case eGL_DOUBLE_MAT2: var.type.descriptor.name = "dmat2"; break; - case eGL_DOUBLE_MAT4x2: var.type.descriptor.name = "dmat4x2"; break; - case eGL_DOUBLE_MAT4x3: var.type.descriptor.name = "dmat4x3"; break; - case eGL_DOUBLE_MAT3x4: var.type.descriptor.name = "dmat3x4"; break; - case eGL_DOUBLE_MAT3x2: var.type.descriptor.name = "dmat3x2"; break; - case eGL_DOUBLE_MAT2x4: var.type.descriptor.name = "dmat2x4"; break; - case eGL_DOUBLE_MAT2x3: var.type.descriptor.name = "dmat2x3"; break; - case eGL_UNSIGNED_INT_VEC4: var.type.descriptor.name = "uvec4"; break; - case eGL_UNSIGNED_INT_VEC3: var.type.descriptor.name = "uvec3"; break; - case eGL_UNSIGNED_INT_VEC2: var.type.descriptor.name = "uvec2"; break; - case eGL_UNSIGNED_INT: var.type.descriptor.name = "uint"; break; - case eGL_BOOL_VEC4: var.type.descriptor.name = "bvec4"; break; - case eGL_BOOL_VEC3: var.type.descriptor.name = "bvec3"; break; - case eGL_BOOL_VEC2: var.type.descriptor.name = "bvec2"; break; - case eGL_BOOL: var.type.descriptor.name = "bool"; break; - case eGL_INT_VEC4: var.type.descriptor.name = "ivec4"; break; - case eGL_INT_VEC3: var.type.descriptor.name = "ivec3"; break; - case eGL_INT_VEC2: var.type.descriptor.name = "ivec2"; break; - case eGL_INT: var.type.descriptor.name = "int"; break; + case eGL_FLOAT_VEC4: var.type.name = "vec4"; break; + case eGL_FLOAT_VEC3: var.type.name = "vec3"; break; + case eGL_FLOAT_VEC2: var.type.name = "vec2"; break; + case eGL_FLOAT: var.type.name = "float"; break; + case eGL_FLOAT_MAT4: var.type.name = "mat4"; break; + case eGL_FLOAT_MAT3: var.type.name = "mat3"; break; + case eGL_FLOAT_MAT2: var.type.name = "mat2"; break; + case eGL_FLOAT_MAT4x2: var.type.name = "mat4x2"; break; + case eGL_FLOAT_MAT4x3: var.type.name = "mat4x3"; break; + case eGL_FLOAT_MAT3x4: var.type.name = "mat3x4"; break; + case eGL_FLOAT_MAT3x2: var.type.name = "mat3x2"; break; + case eGL_FLOAT_MAT2x4: var.type.name = "mat2x4"; break; + case eGL_FLOAT_MAT2x3: var.type.name = "mat2x3"; break; + case eGL_DOUBLE_VEC4: var.type.name = "dvec4"; break; + case eGL_DOUBLE_VEC3: var.type.name = "dvec3"; break; + case eGL_DOUBLE_VEC2: var.type.name = "dvec2"; break; + case eGL_DOUBLE: var.type.name = "double"; break; + case eGL_DOUBLE_MAT4: var.type.name = "dmat4"; break; + case eGL_DOUBLE_MAT3: var.type.name = "dmat3"; break; + case eGL_DOUBLE_MAT2: var.type.name = "dmat2"; break; + case eGL_DOUBLE_MAT4x2: var.type.name = "dmat4x2"; break; + case eGL_DOUBLE_MAT4x3: var.type.name = "dmat4x3"; break; + case eGL_DOUBLE_MAT3x4: var.type.name = "dmat3x4"; break; + case eGL_DOUBLE_MAT3x2: var.type.name = "dmat3x2"; break; + case eGL_DOUBLE_MAT2x4: var.type.name = "dmat2x4"; break; + case eGL_DOUBLE_MAT2x3: var.type.name = "dmat2x3"; break; + case eGL_UNSIGNED_INT_VEC4: var.type.name = "uvec4"; break; + case eGL_UNSIGNED_INT_VEC3: var.type.name = "uvec3"; break; + case eGL_UNSIGNED_INT_VEC2: var.type.name = "uvec2"; break; + case eGL_UNSIGNED_INT: var.type.name = "uint"; break; + case eGL_BOOL_VEC4: var.type.name = "bvec4"; break; + case eGL_BOOL_VEC3: var.type.name = "bvec3"; break; + case eGL_BOOL_VEC2: var.type.name = "bvec2"; break; + case eGL_BOOL: var.type.name = "bool"; break; + case eGL_INT_VEC4: var.type.name = "ivec4"; break; + case eGL_INT_VEC3: var.type.name = "ivec3"; break; + case eGL_INT_VEC2: var.type.name = "ivec2"; break; + case eGL_INT: var.type.name = "int"; break; default: break; } @@ -743,11 +743,11 @@ void ReconstructVarTree(GLenum query, GLuint sepProg, GLuint varIdx, GLint numPa } if(values[6] > 0) - var.type.descriptor.flags |= ShaderVariableFlags::RowMajorMatrix; - var.type.descriptor.matrixByteStride = (uint8_t)values[8]; + var.type.flags |= ShaderVariableFlags::RowMajorMatrix; + var.type.matrixByteStride = (uint8_t)values[8]; RDCASSERTMSG("Stride is too large for uint16_t", values[7] <= 0xffff); - var.type.descriptor.arrayByteStride = RDCMIN((uint32_t)values[7], 0xffffu) & 0xffff; + var.type.arrayByteStride = RDCMIN((uint32_t)values[7], 0xffffu) & 0xffff; bool bareUniform = false; @@ -757,13 +757,13 @@ void ReconstructVarTree(GLenum query, GLuint sepProg, GLuint varIdx, GLint numPa bareUniform = true; // plain matrices are always column major, so this is the size of a column - var.type.descriptor.flags &= ~ShaderVariableFlags::RowMajorMatrix; + var.type.flags &= ~ShaderVariableFlags::RowMajorMatrix; - const uint32_t elemByteStride = (var.type.descriptor.type == VarType::Double) ? 8 : 4; - var.type.descriptor.matrixByteStride = uint8_t(var.type.descriptor.rows * elemByteStride); + const uint32_t elemByteStride = (var.type.baseType == VarType::Double) ? 8 : 4; + var.type.matrixByteStride = uint8_t(var.type.rows * elemByteStride); // arrays are fetched as individual glGetUniform calls - var.type.descriptor.arrayByteStride = 0; + var.type.arrayByteStride = 0; } // set vectors/scalars as row major for convenience, since that's how they're stored in the fv @@ -789,7 +789,7 @@ void ReconstructVarTree(GLenum query, GLuint sepProg, GLuint varIdx, GLint numPa case eGL_INT_VEC4: case eGL_INT_VEC3: case eGL_INT_VEC2: - case eGL_INT: var.type.descriptor.flags |= ShaderVariableFlags::RowMajorMatrix; break; + case eGL_INT: var.type.flags |= ShaderVariableFlags::RowMajorMatrix; break; default: break; } @@ -804,7 +804,7 @@ void ReconstructVarTree(GLenum query, GLuint sepProg, GLuint varIdx, GLint numPa if(var.name[c - 3] == '[' && var.name[c - 2] == '0' && var.name[c - 1] == ']') var.name.resize(c - 3); else - var.type.descriptor.elements = 1; + var.type.elements = 1; GLint topLevelStride = 0; if(query == eGL_BUFFER_VARIABLE) @@ -814,7 +814,7 @@ void ReconstructVarTree(GLenum query, GLuint sepProg, GLuint varIdx, GLint numPa // if ARRAY_SIZE is 0 this is an unbounded array if(values[4] == 0) - var.type.descriptor.elements = ~0U; + var.type.elements = ~0U; } rdcarray *parentmembers = defaultBlock; @@ -885,22 +885,21 @@ void ReconstructVarTree(GLenum query, GLuint sepProg, GLuint varIdx, GLint numPa ShaderConstant parentVar; parentVar.name = base; parentVar.byteOffset = var.byteOffset; - parentVar.type.descriptor.name = "struct"; - parentVar.type.descriptor.rows = 0; - parentVar.type.descriptor.columns = 0; - parentVar.type.descriptor.type = VarType::Struct; - parentVar.type.descriptor.elements = - isarray && !multiDimArray ? RDCMAX(1U, uint32_t(arrayIdx + 1)) : 1; - parentVar.type.descriptor.matrixByteStride = 0; + parentVar.type.name = "struct"; + parentVar.type.rows = 0; + parentVar.type.columns = 0; + parentVar.type.baseType = VarType::Struct; + parentVar.type.elements = isarray && !multiDimArray ? RDCMAX(1U, uint32_t(arrayIdx + 1)) : 1; + parentVar.type.matrixByteStride = 0; RDCASSERTMSG("Stride is too large for uint16_t", topLevelStride <= 0xffff); - parentVar.type.descriptor.arrayByteStride = RDCMIN((uint32_t)topLevelStride, 0xffffu) & 0xffff; + parentVar.type.arrayByteStride = RDCMIN((uint32_t)topLevelStride, 0xffffu) & 0xffff; // consider all block-level SSBO structs to have infinite elements if they are an array at all // for structs that aren't the last struct in a block which can't be infinite, this will be // fixup'd later by looking at the offset of subsequent elements if(blockLevel && topLevelStride && isarray) - parentVar.type.descriptor.elements = ~0U; + parentVar.type.elements = ~0U; if(!blockLevel) topLevelStride = 0; @@ -927,8 +926,8 @@ void ReconstructVarTree(GLenum query, GLuint sepProg, GLuint varIdx, GLint numPa // if we find the variable, update the # elements to account for this new array index // and pick the minimum offset of all of our children as the parent offset. This is mostly // just for sorting - (*parentmembers)[i].type.descriptor.elements = - RDCMAX((*parentmembers)[i].type.descriptor.elements, parentVar.type.descriptor.elements); + (*parentmembers)[i].type.elements = + RDCMAX((*parentmembers)[i].type.elements, parentVar.type.elements); (*parentmembers)[i].byteOffset = RDCMIN((*parentmembers)[i].byteOffset, parentVar.byteOffset); parentmembers = &((*parentmembers)[i].type.members); @@ -1001,7 +1000,7 @@ void ReconstructVarTree(GLenum query, GLuint sepProg, GLuint varIdx, GLint numPa } // the 0th element of each array fills out the actual members, when we - // encounter an index above that we only use it to increase the type.descriptor.elements + // encounter an index above that we only use it to increase the type.elements // member (which we've done by this point) and can stop recursing // // The exception is when we're looking at bare uniforms - there the struct members all have @@ -1037,11 +1036,11 @@ void ReconstructVarTree(GLenum query, GLuint sepProg, GLuint varIdx, GLint numPa { if((*parentmembers)[i].name == var.name) { - ShaderConstantDescriptor &oldtype = (*parentmembers)[i].type.descriptor; - ShaderConstantDescriptor &newtype = var.type.descriptor; + ShaderConstantType &oldtype = (*parentmembers)[i].type; + ShaderConstantType &newtype = var.type; if(oldtype.rows != newtype.rows || oldtype.columns != newtype.columns || - oldtype.type != newtype.type || oldtype.elements != newtype.elements) + oldtype.baseType != newtype.baseType || oldtype.elements != newtype.elements) { RDCERR("When reconstructing %s, found duplicate but different final member %s", fullname.c_str(), (*parentmembers)[i].name.c_str()); @@ -1077,10 +1076,10 @@ static uint32_t GetVarAlignment(bool std140, const ShaderConstant &c) return ret; } - uint8_t vecSize = c.type.descriptor.columns; + uint8_t vecSize = c.type.columns; - if(c.type.descriptor.rows > 1 && c.type.descriptor.ColMajor()) - vecSize = c.type.descriptor.rows; + if(c.type.rows > 1 && c.type.ColMajor()) + vecSize = c.type.rows; if(vecSize <= 1) return 4; @@ -1096,57 +1095,57 @@ static uint32_t GetVarArrayStride(bool std140, const ShaderConstant &c) { const ShaderConstant &lastChild = c.type.members.back(); stride = GetVarArrayStride(std140, lastChild); - if(lastChild.type.descriptor.elements > 1 && lastChild.type.descriptor.elements != ~0U) - stride *= lastChild.type.descriptor.elements; + if(lastChild.type.elements > 1 && lastChild.type.elements != ~0U) + stride *= lastChild.type.elements; stride = AlignUp(lastChild.byteOffset + stride, GetVarAlignment(std140, c)); } else { - if(c.type.descriptor.elements > 1) + if(c.type.elements > 1) { - stride = c.type.descriptor.arrayByteStride; + stride = c.type.arrayByteStride; } else { - stride = VarTypeByteSize(c.type.descriptor.type); + stride = VarTypeByteSize(c.type.baseType); - if(c.type.descriptor.rows > 1) + if(c.type.rows > 1) { if(std140) { stride *= 4; - if(c.type.descriptor.ColMajor()) - stride *= RDCMAX((uint8_t)1, c.type.descriptor.columns); + if(c.type.ColMajor()) + stride *= RDCMAX((uint8_t)1, c.type.columns); else - stride *= RDCMAX((uint8_t)1, c.type.descriptor.rows); + stride *= RDCMAX((uint8_t)1, c.type.rows); } else { - if(c.type.descriptor.ColMajor()) + if(c.type.ColMajor()) { - stride *= RDCMAX((uint8_t)1, c.type.descriptor.columns); - if(c.type.descriptor.rows == 3) + stride *= RDCMAX((uint8_t)1, c.type.columns); + if(c.type.rows == 3) stride *= 4; else - stride *= RDCMAX((uint8_t)1, c.type.descriptor.rows); + stride *= RDCMAX((uint8_t)1, c.type.rows); } else { - stride *= RDCMAX((uint8_t)1, c.type.descriptor.rows); - if(c.type.descriptor.columns == 3) + stride *= RDCMAX((uint8_t)1, c.type.rows); + if(c.type.columns == 3) stride *= 4; else - stride *= RDCMAX((uint8_t)1, c.type.descriptor.columns); + stride *= RDCMAX((uint8_t)1, c.type.columns); } } } else { - if(c.type.descriptor.columns == 3 && std140) + if(c.type.columns == 3 && std140) stride *= 4; else - stride *= RDCMAX((uint8_t)1, c.type.descriptor.columns); + stride *= RDCMAX((uint8_t)1, c.type.columns); } } } @@ -1164,7 +1163,7 @@ void FixupStructOffsetsAndSize(bool std140, ShaderConstant &member) if(!member.type.members.empty()) { - member.type.descriptor.arrayByteStride = GetVarArrayStride(std140, member); + member.type.arrayByteStride = GetVarArrayStride(std140, member); } } @@ -1267,492 +1266,492 @@ void MakeShaderReflection(GLenum shadType, GLuint sepProg, ShaderReflection &ref ShaderResource res; res.isReadOnly = true; res.isTexture = true; - res.variableType.descriptor.rows = 1; - res.variableType.descriptor.columns = 4; - res.variableType.descriptor.elements = 1; - res.variableType.descriptor.arrayByteStride = 0; - res.variableType.descriptor.matrixByteStride = 0; + res.variableType.rows = 1; + res.variableType.columns = 4; + res.variableType.elements = 1; + res.variableType.arrayByteStride = 0; + res.variableType.matrixByteStride = 0; // float samplers if(values[0] == eGL_SAMPLER_BUFFER) { res.resType = TextureType::Buffer; - res.variableType.descriptor.name = "samplerBuffer"; - res.variableType.descriptor.type = VarType::Float; + res.variableType.name = "samplerBuffer"; + res.variableType.baseType = VarType::Float; } else if(values[0] == eGL_SAMPLER_1D) { res.resType = TextureType::Texture1D; - res.variableType.descriptor.name = "sampler1D"; - res.variableType.descriptor.type = VarType::Float; + res.variableType.name = "sampler1D"; + res.variableType.baseType = VarType::Float; } else if(values[0] == eGL_SAMPLER_1D_ARRAY) { res.resType = TextureType::Texture1DArray; - res.variableType.descriptor.name = "sampler1DArray"; - res.variableType.descriptor.type = VarType::Float; + res.variableType.name = "sampler1DArray"; + res.variableType.baseType = VarType::Float; } else if(values[0] == eGL_SAMPLER_1D_SHADOW) { res.resType = TextureType::Texture1D; - res.variableType.descriptor.name = "sampler1DShadow"; - res.variableType.descriptor.type = VarType::Float; + res.variableType.name = "sampler1DShadow"; + res.variableType.baseType = VarType::Float; } else if(values[0] == eGL_SAMPLER_1D_ARRAY_SHADOW) { res.resType = TextureType::Texture1DArray; - res.variableType.descriptor.name = "sampler1DArrayShadow"; - res.variableType.descriptor.type = VarType::Float; + res.variableType.name = "sampler1DArrayShadow"; + res.variableType.baseType = VarType::Float; } else if(values[0] == eGL_SAMPLER_2D) { res.resType = TextureType::Texture2D; - res.variableType.descriptor.name = "sampler2D"; - res.variableType.descriptor.type = VarType::Float; + res.variableType.name = "sampler2D"; + res.variableType.baseType = VarType::Float; } else if(values[0] == eGL_SAMPLER_2D_ARRAY) { res.resType = TextureType::Texture2DArray; - res.variableType.descriptor.name = "sampler2DArray"; - res.variableType.descriptor.type = VarType::Float; + res.variableType.name = "sampler2DArray"; + res.variableType.baseType = VarType::Float; } else if(values[0] == eGL_SAMPLER_2D_SHADOW) { res.resType = TextureType::Texture2D; - res.variableType.descriptor.name = "sampler2DShadow"; - res.variableType.descriptor.type = VarType::Float; + res.variableType.name = "sampler2DShadow"; + res.variableType.baseType = VarType::Float; } else if(values[0] == eGL_SAMPLER_2D_ARRAY_SHADOW) { res.resType = TextureType::Texture2DArray; - res.variableType.descriptor.name = "sampler2DArrayShadow"; - res.variableType.descriptor.type = VarType::Float; + res.variableType.name = "sampler2DArrayShadow"; + res.variableType.baseType = VarType::Float; } else if(values[0] == eGL_SAMPLER_2D_RECT) { res.resType = TextureType::TextureRect; - res.variableType.descriptor.name = "sampler2DRect"; - res.variableType.descriptor.type = VarType::Float; + res.variableType.name = "sampler2DRect"; + res.variableType.baseType = VarType::Float; } else if(values[0] == eGL_SAMPLER_2D_RECT_SHADOW) { res.resType = TextureType::TextureRect; - res.variableType.descriptor.name = "sampler2DRectShadow"; - res.variableType.descriptor.type = VarType::Float; + res.variableType.name = "sampler2DRectShadow"; + res.variableType.baseType = VarType::Float; } else if(values[0] == eGL_SAMPLER_3D) { res.resType = TextureType::Texture3D; - res.variableType.descriptor.name = "sampler3D"; - res.variableType.descriptor.type = VarType::Float; + res.variableType.name = "sampler3D"; + res.variableType.baseType = VarType::Float; } else if(values[0] == eGL_SAMPLER_CUBE) { res.resType = TextureType::TextureCube; - res.variableType.descriptor.name = "samplerCube"; - res.variableType.descriptor.type = VarType::Float; + res.variableType.name = "samplerCube"; + res.variableType.baseType = VarType::Float; } else if(values[0] == eGL_SAMPLER_CUBE_SHADOW) { res.resType = TextureType::TextureCube; - res.variableType.descriptor.name = "samplerCubeShadow"; - res.variableType.descriptor.type = VarType::Float; + res.variableType.name = "samplerCubeShadow"; + res.variableType.baseType = VarType::Float; } else if(values[0] == eGL_SAMPLER_CUBE_MAP_ARRAY) { res.resType = TextureType::TextureCubeArray; - res.variableType.descriptor.name = "samplerCubeArray"; - res.variableType.descriptor.type = VarType::Float; + res.variableType.name = "samplerCubeArray"; + res.variableType.baseType = VarType::Float; } else if(values[0] == eGL_SAMPLER_2D_MULTISAMPLE) { res.resType = TextureType::Texture2DMS; - res.variableType.descriptor.name = "sampler2DMS"; - res.variableType.descriptor.type = VarType::Float; + res.variableType.name = "sampler2DMS"; + res.variableType.baseType = VarType::Float; } else if(values[0] == eGL_SAMPLER_2D_MULTISAMPLE_ARRAY) { res.resType = TextureType::Texture2DMSArray; - res.variableType.descriptor.name = "sampler2DMSArray"; - res.variableType.descriptor.type = VarType::Float; + res.variableType.name = "sampler2DMSArray"; + res.variableType.baseType = VarType::Float; } // int samplers else if(values[0] == eGL_INT_SAMPLER_BUFFER) { res.resType = TextureType::Buffer; - res.variableType.descriptor.name = "isamplerBuffer"; - res.variableType.descriptor.type = VarType::SInt; + res.variableType.name = "isamplerBuffer"; + res.variableType.baseType = VarType::SInt; } else if(values[0] == eGL_INT_SAMPLER_1D) { res.resType = TextureType::Texture1D; - res.variableType.descriptor.name = "isampler1D"; - res.variableType.descriptor.type = VarType::SInt; + res.variableType.name = "isampler1D"; + res.variableType.baseType = VarType::SInt; } else if(values[0] == eGL_INT_SAMPLER_1D_ARRAY) { res.resType = TextureType::Texture1DArray; - res.variableType.descriptor.name = "isampler1DArray"; - res.variableType.descriptor.type = VarType::SInt; + res.variableType.name = "isampler1DArray"; + res.variableType.baseType = VarType::SInt; } else if(values[0] == eGL_INT_SAMPLER_2D) { res.resType = TextureType::Texture2D; - res.variableType.descriptor.name = "isampler2D"; - res.variableType.descriptor.type = VarType::SInt; + res.variableType.name = "isampler2D"; + res.variableType.baseType = VarType::SInt; } else if(values[0] == eGL_INT_SAMPLER_2D_ARRAY) { res.resType = TextureType::Texture2DArray; - res.variableType.descriptor.name = "isampler2DArray"; - res.variableType.descriptor.type = VarType::SInt; + res.variableType.name = "isampler2DArray"; + res.variableType.baseType = VarType::SInt; } else if(values[0] == eGL_INT_SAMPLER_2D_RECT) { res.resType = TextureType::TextureRect; - res.variableType.descriptor.name = "isampler2DRect"; - res.variableType.descriptor.type = VarType::SInt; + res.variableType.name = "isampler2DRect"; + res.variableType.baseType = VarType::SInt; } else if(values[0] == eGL_INT_SAMPLER_3D) { res.resType = TextureType::Texture3D; - res.variableType.descriptor.name = "isampler3D"; - res.variableType.descriptor.type = VarType::SInt; + res.variableType.name = "isampler3D"; + res.variableType.baseType = VarType::SInt; } else if(values[0] == eGL_INT_SAMPLER_CUBE) { res.resType = TextureType::TextureCube; - res.variableType.descriptor.name = "isamplerCube"; - res.variableType.descriptor.type = VarType::SInt; + res.variableType.name = "isamplerCube"; + res.variableType.baseType = VarType::SInt; } else if(values[0] == eGL_INT_SAMPLER_CUBE_MAP_ARRAY) { res.resType = TextureType::TextureCubeArray; - res.variableType.descriptor.name = "isamplerCubeArray"; - res.variableType.descriptor.type = VarType::SInt; + res.variableType.name = "isamplerCubeArray"; + res.variableType.baseType = VarType::SInt; } else if(values[0] == eGL_INT_SAMPLER_2D_MULTISAMPLE) { res.resType = TextureType::Texture2DMS; - res.variableType.descriptor.name = "isampler2DMS"; - res.variableType.descriptor.type = VarType::SInt; + res.variableType.name = "isampler2DMS"; + res.variableType.baseType = VarType::SInt; } else if(values[0] == eGL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY) { res.resType = TextureType::Texture2DMSArray; - res.variableType.descriptor.name = "isampler2DMSArray"; - res.variableType.descriptor.type = VarType::SInt; + res.variableType.name = "isampler2DMSArray"; + res.variableType.baseType = VarType::SInt; } // unsigned int samplers else if(values[0] == eGL_UNSIGNED_INT_SAMPLER_BUFFER) { res.resType = TextureType::Buffer; - res.variableType.descriptor.name = "usamplerBuffer"; - res.variableType.descriptor.type = VarType::UInt; + res.variableType.name = "usamplerBuffer"; + res.variableType.baseType = VarType::UInt; } else if(values[0] == eGL_UNSIGNED_INT_SAMPLER_1D) { res.resType = TextureType::Texture1D; - res.variableType.descriptor.name = "usampler1D"; - res.variableType.descriptor.type = VarType::UInt; + res.variableType.name = "usampler1D"; + res.variableType.baseType = VarType::UInt; } else if(values[0] == eGL_UNSIGNED_INT_SAMPLER_1D_ARRAY) { res.resType = TextureType::Texture1DArray; - res.variableType.descriptor.name = "usampler1DArray"; - res.variableType.descriptor.type = VarType::UInt; + res.variableType.name = "usampler1DArray"; + res.variableType.baseType = VarType::UInt; } else if(values[0] == eGL_UNSIGNED_INT_SAMPLER_2D) { res.resType = TextureType::Texture2D; - res.variableType.descriptor.name = "usampler2D"; - res.variableType.descriptor.type = VarType::UInt; + res.variableType.name = "usampler2D"; + res.variableType.baseType = VarType::UInt; } else if(values[0] == eGL_UNSIGNED_INT_SAMPLER_2D_ARRAY) { res.resType = TextureType::Texture2DArray; - res.variableType.descriptor.name = "usampler2DArray"; - res.variableType.descriptor.type = VarType::UInt; + res.variableType.name = "usampler2DArray"; + res.variableType.baseType = VarType::UInt; } else if(values[0] == eGL_UNSIGNED_INT_SAMPLER_2D_RECT) { res.resType = TextureType::TextureRect; - res.variableType.descriptor.name = "usampler2DRect"; - res.variableType.descriptor.type = VarType::UInt; + res.variableType.name = "usampler2DRect"; + res.variableType.baseType = VarType::UInt; } else if(values[0] == eGL_UNSIGNED_INT_SAMPLER_3D) { res.resType = TextureType::Texture3D; - res.variableType.descriptor.name = "usampler3D"; - res.variableType.descriptor.type = VarType::UInt; + res.variableType.name = "usampler3D"; + res.variableType.baseType = VarType::UInt; } else if(values[0] == eGL_UNSIGNED_INT_SAMPLER_CUBE) { res.resType = TextureType::TextureCube; - res.variableType.descriptor.name = "usamplerCube"; - res.variableType.descriptor.type = VarType::UInt; + res.variableType.name = "usamplerCube"; + res.variableType.baseType = VarType::UInt; } else if(values[0] == eGL_UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY) { res.resType = TextureType::TextureCubeArray; - res.variableType.descriptor.name = "usamplerCubeArray"; - res.variableType.descriptor.type = VarType::UInt; + res.variableType.name = "usamplerCubeArray"; + res.variableType.baseType = VarType::UInt; } else if(values[0] == eGL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE) { res.resType = TextureType::Texture2DMS; - res.variableType.descriptor.name = "usampler2DMS"; - res.variableType.descriptor.type = VarType::UInt; + res.variableType.name = "usampler2DMS"; + res.variableType.baseType = VarType::UInt; } else if(values[0] == eGL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY) { res.resType = TextureType::Texture2DMSArray; - res.variableType.descriptor.name = "usampler2DMSArray"; - res.variableType.descriptor.type = VarType::UInt; + res.variableType.name = "usampler2DMSArray"; + res.variableType.baseType = VarType::UInt; } // float images else if(values[0] == eGL_IMAGE_BUFFER) { res.resType = TextureType::Buffer; - res.variableType.descriptor.name = "imageBuffer"; - res.variableType.descriptor.type = VarType::Float; + res.variableType.name = "imageBuffer"; + res.variableType.baseType = VarType::Float; res.isReadOnly = false; } else if(values[0] == eGL_IMAGE_1D) { res.resType = TextureType::Texture1D; - res.variableType.descriptor.name = "image1D"; - res.variableType.descriptor.type = VarType::Float; + res.variableType.name = "image1D"; + res.variableType.baseType = VarType::Float; res.isReadOnly = false; } else if(values[0] == eGL_IMAGE_1D_ARRAY) { res.resType = TextureType::Texture1DArray; - res.variableType.descriptor.name = "image1DArray"; - res.variableType.descriptor.type = VarType::Float; + res.variableType.name = "image1DArray"; + res.variableType.baseType = VarType::Float; res.isReadOnly = false; } else if(values[0] == eGL_IMAGE_2D) { res.resType = TextureType::Texture2D; - res.variableType.descriptor.name = "image2D"; - res.variableType.descriptor.type = VarType::Float; + res.variableType.name = "image2D"; + res.variableType.baseType = VarType::Float; res.isReadOnly = false; } else if(values[0] == eGL_IMAGE_2D_ARRAY) { res.resType = TextureType::Texture2DArray; - res.variableType.descriptor.name = "image2DArray"; - res.variableType.descriptor.type = VarType::Float; + res.variableType.name = "image2DArray"; + res.variableType.baseType = VarType::Float; res.isReadOnly = false; } else if(values[0] == eGL_IMAGE_2D_RECT) { res.resType = TextureType::TextureRect; - res.variableType.descriptor.name = "image2DRect"; - res.variableType.descriptor.type = VarType::Float; + res.variableType.name = "image2DRect"; + res.variableType.baseType = VarType::Float; res.isReadOnly = false; } else if(values[0] == eGL_IMAGE_3D) { res.resType = TextureType::Texture3D; - res.variableType.descriptor.name = "image3D"; - res.variableType.descriptor.type = VarType::Float; + res.variableType.name = "image3D"; + res.variableType.baseType = VarType::Float; res.isReadOnly = false; } else if(values[0] == eGL_IMAGE_CUBE) { res.resType = TextureType::TextureCube; - res.variableType.descriptor.name = "imageCube"; - res.variableType.descriptor.type = VarType::Float; + res.variableType.name = "imageCube"; + res.variableType.baseType = VarType::Float; res.isReadOnly = false; } else if(values[0] == eGL_IMAGE_CUBE_MAP_ARRAY) { res.resType = TextureType::TextureCubeArray; - res.variableType.descriptor.name = "imageCubeArray"; - res.variableType.descriptor.type = VarType::Float; + res.variableType.name = "imageCubeArray"; + res.variableType.baseType = VarType::Float; res.isReadOnly = false; } else if(values[0] == eGL_IMAGE_2D_MULTISAMPLE) { res.resType = TextureType::Texture2DMS; - res.variableType.descriptor.name = "image2DMS"; - res.variableType.descriptor.type = VarType::Float; + res.variableType.name = "image2DMS"; + res.variableType.baseType = VarType::Float; res.isReadOnly = false; } else if(values[0] == eGL_IMAGE_2D_MULTISAMPLE_ARRAY) { res.resType = TextureType::Texture2DMSArray; - res.variableType.descriptor.name = "image2DMSArray"; - res.variableType.descriptor.type = VarType::Float; + res.variableType.name = "image2DMSArray"; + res.variableType.baseType = VarType::Float; res.isReadOnly = false; } // int images else if(values[0] == eGL_INT_IMAGE_BUFFER) { res.resType = TextureType::Buffer; - res.variableType.descriptor.name = "iimageBuffer"; - res.variableType.descriptor.type = VarType::SInt; + res.variableType.name = "iimageBuffer"; + res.variableType.baseType = VarType::SInt; res.isReadOnly = false; } else if(values[0] == eGL_INT_IMAGE_1D) { res.resType = TextureType::Texture1D; - res.variableType.descriptor.name = "iimage1D"; - res.variableType.descriptor.type = VarType::SInt; + res.variableType.name = "iimage1D"; + res.variableType.baseType = VarType::SInt; res.isReadOnly = false; } else if(values[0] == eGL_INT_IMAGE_1D_ARRAY) { res.resType = TextureType::Texture1DArray; - res.variableType.descriptor.name = "iimage1DArray"; - res.variableType.descriptor.type = VarType::SInt; + res.variableType.name = "iimage1DArray"; + res.variableType.baseType = VarType::SInt; res.isReadOnly = false; } else if(values[0] == eGL_INT_IMAGE_2D) { res.resType = TextureType::Texture2D; - res.variableType.descriptor.name = "iimage2D"; - res.variableType.descriptor.type = VarType::SInt; + res.variableType.name = "iimage2D"; + res.variableType.baseType = VarType::SInt; res.isReadOnly = false; } else if(values[0] == eGL_INT_IMAGE_2D_ARRAY) { res.resType = TextureType::Texture2DArray; - res.variableType.descriptor.name = "iimage2DArray"; - res.variableType.descriptor.type = VarType::SInt; + res.variableType.name = "iimage2DArray"; + res.variableType.baseType = VarType::SInt; res.isReadOnly = false; } else if(values[0] == eGL_INT_IMAGE_2D_RECT) { res.resType = TextureType::TextureRect; - res.variableType.descriptor.name = "iimage2DRect"; - res.variableType.descriptor.type = VarType::SInt; + res.variableType.name = "iimage2DRect"; + res.variableType.baseType = VarType::SInt; res.isReadOnly = false; } else if(values[0] == eGL_INT_IMAGE_3D) { res.resType = TextureType::Texture3D; - res.variableType.descriptor.name = "iimage3D"; - res.variableType.descriptor.type = VarType::SInt; + res.variableType.name = "iimage3D"; + res.variableType.baseType = VarType::SInt; res.isReadOnly = false; } else if(values[0] == eGL_INT_IMAGE_CUBE) { res.resType = TextureType::TextureCube; - res.variableType.descriptor.name = "iimageCube"; - res.variableType.descriptor.type = VarType::SInt; + res.variableType.name = "iimageCube"; + res.variableType.baseType = VarType::SInt; res.isReadOnly = false; } else if(values[0] == eGL_INT_IMAGE_CUBE_MAP_ARRAY) { res.resType = TextureType::TextureCubeArray; - res.variableType.descriptor.name = "iimageCubeArray"; - res.variableType.descriptor.type = VarType::SInt; + res.variableType.name = "iimageCubeArray"; + res.variableType.baseType = VarType::SInt; res.isReadOnly = false; } else if(values[0] == eGL_INT_IMAGE_2D_MULTISAMPLE) { res.resType = TextureType::Texture2DMS; - res.variableType.descriptor.name = "iimage2DMS"; - res.variableType.descriptor.type = VarType::SInt; + res.variableType.name = "iimage2DMS"; + res.variableType.baseType = VarType::SInt; res.isReadOnly = false; } else if(values[0] == eGL_INT_IMAGE_2D_MULTISAMPLE_ARRAY) { res.resType = TextureType::Texture2DMSArray; - res.variableType.descriptor.name = "iimage2DMSArray"; - res.variableType.descriptor.type = VarType::SInt; + res.variableType.name = "iimage2DMSArray"; + res.variableType.baseType = VarType::SInt; res.isReadOnly = false; } // unsigned int images else if(values[0] == eGL_UNSIGNED_INT_IMAGE_BUFFER) { res.resType = TextureType::Buffer; - res.variableType.descriptor.name = "uimageBuffer"; - res.variableType.descriptor.type = VarType::UInt; + res.variableType.name = "uimageBuffer"; + res.variableType.baseType = VarType::UInt; res.isReadOnly = false; } else if(values[0] == eGL_UNSIGNED_INT_IMAGE_1D) { res.resType = TextureType::Texture1D; - res.variableType.descriptor.name = "uimage1D"; - res.variableType.descriptor.type = VarType::UInt; + res.variableType.name = "uimage1D"; + res.variableType.baseType = VarType::UInt; res.isReadOnly = false; } else if(values[0] == eGL_UNSIGNED_INT_IMAGE_1D_ARRAY) { res.resType = TextureType::Texture1DArray; - res.variableType.descriptor.name = "uimage1DArray"; - res.variableType.descriptor.type = VarType::UInt; + res.variableType.name = "uimage1DArray"; + res.variableType.baseType = VarType::UInt; res.isReadOnly = false; } else if(values[0] == eGL_UNSIGNED_INT_IMAGE_2D) { res.resType = TextureType::Texture2D; - res.variableType.descriptor.name = "uimage2D"; - res.variableType.descriptor.type = VarType::UInt; + res.variableType.name = "uimage2D"; + res.variableType.baseType = VarType::UInt; res.isReadOnly = false; } else if(values[0] == eGL_UNSIGNED_INT_IMAGE_2D_ARRAY) { res.resType = TextureType::Texture2DArray; - res.variableType.descriptor.name = "uimage2DArray"; - res.variableType.descriptor.type = VarType::UInt; + res.variableType.name = "uimage2DArray"; + res.variableType.baseType = VarType::UInt; res.isReadOnly = false; } else if(values[0] == eGL_UNSIGNED_INT_IMAGE_2D_RECT) { res.resType = TextureType::TextureRect; - res.variableType.descriptor.name = "uimage2DRect"; - res.variableType.descriptor.type = VarType::UInt; + res.variableType.name = "uimage2DRect"; + res.variableType.baseType = VarType::UInt; res.isReadOnly = false; } else if(values[0] == eGL_UNSIGNED_INT_IMAGE_3D) { res.resType = TextureType::Texture3D; - res.variableType.descriptor.name = "uimage3D"; - res.variableType.descriptor.type = VarType::UInt; + res.variableType.name = "uimage3D"; + res.variableType.baseType = VarType::UInt; res.isReadOnly = false; } else if(values[0] == eGL_UNSIGNED_INT_IMAGE_CUBE) { res.resType = TextureType::TextureCube; - res.variableType.descriptor.name = "uimageCube"; - res.variableType.descriptor.type = VarType::UInt; + res.variableType.name = "uimageCube"; + res.variableType.baseType = VarType::UInt; res.isReadOnly = false; } else if(values[0] == eGL_UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY) { res.resType = TextureType::TextureCubeArray; - res.variableType.descriptor.name = "uimageCubeArray"; - res.variableType.descriptor.type = VarType::UInt; + res.variableType.name = "uimageCubeArray"; + res.variableType.baseType = VarType::UInt; res.isReadOnly = false; } else if(values[0] == eGL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE) { res.resType = TextureType::Texture2DMS; - res.variableType.descriptor.name = "uimage2DMS"; - res.variableType.descriptor.type = VarType::UInt; + res.variableType.name = "uimage2DMS"; + res.variableType.baseType = VarType::UInt; res.isReadOnly = false; } else if(values[0] == eGL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_ARRAY) { res.resType = TextureType::Texture2DMSArray; - res.variableType.descriptor.name = "uimage2DMSArray"; - res.variableType.descriptor.type = VarType::UInt; + res.variableType.name = "uimage2DMSArray"; + res.variableType.baseType = VarType::UInt; res.isReadOnly = false; } // atomic counter else if(values[0] == eGL_UNSIGNED_INT_ATOMIC_COUNTER) { res.resType = TextureType::Buffer; - res.variableType.descriptor.name = "atomic_uint"; - res.variableType.descriptor.type = VarType::UInt; + res.variableType.name = "atomic_uint"; + res.variableType.baseType = VarType::UInt; res.isReadOnly = false; res.isTexture = false; - res.variableType.descriptor.columns = 1; + res.variableType.columns = 1; } else { @@ -1812,13 +1811,13 @@ void MakeShaderReflection(GLenum shadType, GLuint sepProg, ShaderReflection &ref res.isReadOnly = false; res.isTexture = false; res.resType = TextureType::Buffer; - res.variableType.descriptor.rows = 0; - res.variableType.descriptor.columns = 0; - res.variableType.descriptor.elements = 1; - res.variableType.descriptor.arrayByteStride = 0; - res.variableType.descriptor.matrixByteStride = 0; - res.variableType.descriptor.name = "buffer"; - res.variableType.descriptor.type = VarType::UInt; + res.variableType.rows = 0; + res.variableType.columns = 0; + res.variableType.elements = 1; + res.variableType.arrayByteStride = 0; + res.variableType.matrixByteStride = 0; + res.variableType.name = "buffer"; + res.variableType.baseType = VarType::UInt; res.bindPoint = (int32_t)rwresources.size(); res.name = nm; @@ -1925,14 +1924,14 @@ void MakeShaderReflection(GLenum shadType, GLuint sepProg, ShaderReflection &ref ShaderConstant &member = ssboVars[rootMember]; const uint32_t memberSizeBound = ssboVars[rootMember + 1].byteOffset - member.byteOffset; - const uint32_t stride = member.type.descriptor.arrayByteStride; + const uint32_t stride = member.type.arrayByteStride; - if(stride != 0 && member.type.descriptor.elements == ~0U) + if(stride != 0 && member.type.elements == ~0U) { if(memberSizeBound >= 2 * stride) - member.type.descriptor.elements = memberSizeBound / stride; + member.type.elements = memberSizeBound / stride; else - member.type.descriptor.elements = 1; + member.type.elements = 1; } } } @@ -2509,9 +2508,9 @@ void GetBindpointMapping(GLuint curProg, int shadIdx, const ShaderReflection *re } else if(!refl->readWriteResources[i].isTexture) { - if(refl->readWriteResources[i].variableType.descriptor.columns == 1 && - refl->readWriteResources[i].variableType.descriptor.rows == 1 && - refl->readWriteResources[i].variableType.descriptor.type == VarType::UInt) + if(refl->readWriteResources[i].variableType.columns == 1 && + refl->readWriteResources[i].variableType.rows == 1 && + refl->readWriteResources[i].variableType.baseType == VarType::UInt) { // atomic uint GLuint idx = GL.glGetProgramResourceIndex(curProg, eGL_UNIFORM, diff --git a/renderdoc/driver/shaders/dxbc/dxbc_bytecode.cpp b/renderdoc/driver/shaders/dxbc/dxbc_bytecode.cpp index 8fe2803a1..7fcffe903 100644 --- a/renderdoc/driver/shaders/dxbc/dxbc_bytecode.cpp +++ b/renderdoc/driver/shaders/dxbc/dxbc_bytecode.cpp @@ -489,13 +489,13 @@ DXBC::Reflection *Program::GuessReflection() DXBC::CBufferVariable var; var.name = cb.name; var.offset = 0; - var.type.descriptor.varClass = DXBC::VariableClass::CLASS_STRUCT; - var.type.descriptor.varType = VarType::Unknown; - var.type.descriptor.rows = 1; - var.type.descriptor.cols = 4; - var.type.descriptor.elements = 1; - var.type.descriptor.bytesize = 4 * sizeof(float); - var.type.descriptor.name = "struct"; + var.type.varClass = DXBC::VariableClass::CLASS_STRUCT; + var.type.varType = VarType::Unknown; + var.type.rows = 1; + var.type.cols = 4; + var.type.elements = 1; + var.type.bytesize = 4 * sizeof(float); + var.type.name = "struct"; cb.variables.push_back(var); } rdcarray &fillVars = @@ -510,13 +510,13 @@ DXBC::Reflection *Program::GuessReflection() var.offset = 4 * sizeof(float) * v; - var.type.descriptor.bytesize = 4 * sizeof(float); - var.type.descriptor.rows = 1; - var.type.descriptor.cols = 4; - var.type.descriptor.elements = 0; - var.type.descriptor.varType = VarType::Float; - var.type.descriptor.varClass = DXBC::CLASS_VECTOR; - var.type.descriptor.name = TypeName(var.type.descriptor); + var.type.bytesize = 4 * sizeof(float); + var.type.rows = 1; + var.type.cols = 4; + var.type.elements = 0; + var.type.varType = VarType::Float; + var.type.varClass = DXBC::CLASS_VECTOR; + var.type.name = TypeName(var.type); fillVars.push_back(var); } diff --git a/renderdoc/driver/shaders/dxbc/dxbc_bytecode_ops.cpp b/renderdoc/driver/shaders/dxbc/dxbc_bytecode_ops.cpp index c0b3adbd5..1f56ec150 100644 --- a/renderdoc/driver/shaders/dxbc/dxbc_bytecode_ops.cpp +++ b/renderdoc/driver/shaders/dxbc/dxbc_bytecode_ops.cpp @@ -57,7 +57,7 @@ const DXBC::CBufferVariable *FindCBufferVar(const uint32_t minOffset, const uint // does minOffset-maxOffset reside in this variable? We don't handle the case where the range // crosses a variable (and I don't think FXC emits that anyway). - if(voffs <= minOffset && voffs + v.type.descriptor.bytesize > maxOffset) + if(voffs <= minOffset && voffs + v.type.bytesize > maxOffset) { byteOffset = voffs; @@ -416,14 +416,14 @@ rdcstr Operand::toString(const DXBC::Reflection *reflection, ToString toStrFlags uint32_t varOffset = minOffset - baseOffset; // if it's an array, add the index based on the relative index to the base offset - if(var->type.descriptor.elements > 1) + if(var->type.elements > 1) { - uint32_t byteSize = var->type.descriptor.bytesize; + uint32_t byteSize = var->type.bytesize; // round up the byte size to a the nearest vec4 in case it's not quite a multiple byteSize = AlignUp16(byteSize); - const uint32_t elementSize = byteSize / var->type.descriptor.elements; + const uint32_t elementSize = byteSize / var->type.elements; const uint32_t elementIndex = varOffset / elementSize; @@ -434,10 +434,8 @@ rdcstr Operand::toString(const DXBC::Reflection *reflection, ToString toStrFlags } // or if it's a matrix - if((var->type.descriptor.varClass == DXBC::CLASS_MATRIX_ROWS && - var->type.descriptor.cols > 1) || - (var->type.descriptor.varClass == DXBC::CLASS_MATRIX_COLUMNS && - var->type.descriptor.rows > 1)) + if((var->type.varClass == DXBC::CLASS_MATRIX_ROWS && var->type.cols > 1) || + (var->type.varClass == DXBC::CLASS_MATRIX_COLUMNS && var->type.rows > 1)) { str += StringFormat::Fmt("[%u]", varOffset / 16); } diff --git a/renderdoc/driver/shaders/dxbc/dxbc_common.h b/renderdoc/driver/shaders/dxbc/dxbc_common.h index a15db9ae6..ca8fa9939 100644 --- a/renderdoc/driver/shaders/dxbc/dxbc_common.h +++ b/renderdoc/driver/shaders/dxbc/dxbc_common.h @@ -299,16 +299,13 @@ enum VariableClass struct CBufferVariableType { - struct Descriptor - { - VariableClass varClass; - VarType varType; - uint32_t rows; - uint32_t cols; - uint32_t elements; - uint32_t bytesize; - rdcstr name; - } descriptor; + VariableClass varClass; + VarType varType; + uint32_t rows; + uint32_t cols; + uint32_t elements; + uint32_t bytesize; + rdcstr name; // if a struct, these are variables for each member (this can obviously nest). Not all // elements of the nested member descriptor are valid, as this might not be in a cbuffer, @@ -316,7 +313,7 @@ struct CBufferVariableType rdcarray members; }; -rdcstr TypeName(CBufferVariableType::Descriptor desc); +rdcstr TypeName(CBufferVariableType desc); struct CBufferVariable { diff --git a/renderdoc/driver/shaders/dxbc/dxbc_container.cpp b/renderdoc/driver/shaders/dxbc/dxbc_container.cpp index 2ce8ec1b4..ac7f03d03 100644 --- a/renderdoc/driver/shaders/dxbc/dxbc_container.cpp +++ b/renderdoc/driver/shaders/dxbc/dxbc_container.cpp @@ -290,7 +290,7 @@ ShaderBuiltin GetSystemValue(SVSemantic systemValue) return ShaderBuiltin::Undefined; } -rdcstr TypeName(CBufferVariableType::Descriptor desc) +rdcstr TypeName(CBufferVariableType desc) { rdcstr ret; @@ -344,52 +344,52 @@ CBufferVariableType DXBCContainer::ParseRDEFType(const RDEFHeader *h, const byte CBufferVariableType ret; - ret.descriptor.varClass = (VariableClass)type->varClass; - ret.descriptor.cols = RDCMAX(1U, (uint32_t)type->cols); - ret.descriptor.elements = RDCMAX(1U, (uint32_t)type->numElems); - ret.descriptor.rows = RDCMAX(1U, (uint32_t)type->rows); + ret.varClass = (VariableClass)type->varClass; + ret.cols = RDCMAX(1U, (uint32_t)type->cols); + ret.elements = RDCMAX(1U, (uint32_t)type->numElems); + ret.rows = RDCMAX(1U, (uint32_t)type->rows); switch((VariableType)type->varType) { // DXBC treats all cbuffer variables as 32-bit regardless of declaration case DXBC::VARTYPE_MIN12INT: case DXBC::VARTYPE_MIN16INT: - case DXBC::VARTYPE_INT: ret.descriptor.varType = VarType::SInt; break; - case DXBC::VARTYPE_BOOL: ret.descriptor.varType = VarType::Bool; break; + case DXBC::VARTYPE_INT: ret.varType = VarType::SInt; break; + case DXBC::VARTYPE_BOOL: ret.varType = VarType::Bool; break; case DXBC::VARTYPE_MIN16UINT: - case DXBC::VARTYPE_UINT: ret.descriptor.varType = VarType::UInt; break; - case DXBC::VARTYPE_DOUBLE: ret.descriptor.varType = VarType::Double; break; + case DXBC::VARTYPE_UINT: ret.varType = VarType::UInt; break; + case DXBC::VARTYPE_DOUBLE: ret.varType = VarType::Double; break; case DXBC::VARTYPE_FLOAT: case DXBC::VARTYPE_MIN8FLOAT: case DXBC::VARTYPE_MIN10FLOAT: case DXBC::VARTYPE_MIN16FLOAT: - default: ret.descriptor.varType = VarType::Float; break; + default: ret.varType = VarType::Float; break; } - ret.descriptor.name = TypeName(ret.descriptor); + ret.name = TypeName(ret); - if(ret.descriptor.name == "interface") + if(ret.name == "interface") { if(h->targetVersion >= 0x500 && type->nameOffset > 0) { - ret.descriptor.name += " " + rdcstr((const char *)chunkContents + type->nameOffset); + ret.name += " " + rdcstr((const char *)chunkContents + type->nameOffset); } else { - ret.descriptor.name += StringFormat::Fmt(" unnamed_iface_0x%08x", typeOffset); + ret.name += StringFormat::Fmt(" unnamed_iface_0x%08x", typeOffset); } } // rename unnamed structs to have valid identifiers as type name - if(ret.descriptor.name.contains("")) + if(ret.name.contains("")) { if(h->targetVersion >= 0x500 && type->nameOffset > 0) { - ret.descriptor.name = (const char *)chunkContents + type->nameOffset; + ret.name = (const char *)chunkContents + type->nameOffset; } else { - ret.descriptor.name = StringFormat::Fmt("unnamed_struct_0x%08x", typeOffset); + ret.name = StringFormat::Fmt("unnamed_struct_0x%08x", typeOffset); } } @@ -400,7 +400,7 @@ CBufferVariableType DXBCContainer::ParseRDEFType(const RDEFHeader *h, const byte ret.members.reserve(type->numMembers); - ret.descriptor.bytesize = 0; + ret.bytesize = 0; for(int32_t j = 0; j < type->numMembers; j++) { @@ -410,36 +410,32 @@ CBufferVariableType DXBCContainer::ParseRDEFType(const RDEFHeader *h, const byte v.type = ParseRDEFType(h, chunkContents, members[j].typeOffset); v.offset = members[j].memberOffset; - ret.descriptor.bytesize = v.offset + v.type.descriptor.bytesize; + ret.bytesize = v.offset + v.type.bytesize; ret.members.push_back(v); } - ret.descriptor.bytesize *= RDCMAX(1U, ret.descriptor.elements); + ret.bytesize *= RDCMAX(1U, ret.elements); } else { // matrices take up a full vector for each column or row depending which is major, regardless of // the other dimension - if(ret.descriptor.varClass == CLASS_MATRIX_COLUMNS) + if(ret.varClass == CLASS_MATRIX_COLUMNS) { - ret.descriptor.bytesize = VarTypeByteSize(ret.descriptor.varType) * ret.descriptor.cols * 4 * - RDCMAX(1U, ret.descriptor.elements); + ret.bytesize = VarTypeByteSize(ret.varType) * ret.cols * 4 * RDCMAX(1U, ret.elements); } - else if(ret.descriptor.varClass == CLASS_MATRIX_ROWS) + else if(ret.varClass == CLASS_MATRIX_ROWS) { - ret.descriptor.bytesize = VarTypeByteSize(ret.descriptor.varType) * ret.descriptor.rows * 4 * - RDCMAX(1U, ret.descriptor.elements); + ret.bytesize = VarTypeByteSize(ret.varType) * ret.rows * 4 * RDCMAX(1U, ret.elements); } else { // arrays also take up a full vector for each element - if(ret.descriptor.elements > 1) - ret.descriptor.bytesize = - VarTypeByteSize(ret.descriptor.varType) * 4 * RDCMAX(1U, ret.descriptor.elements); + if(ret.elements > 1) + ret.bytesize = VarTypeByteSize(ret.varType) * 4 * RDCMAX(1U, ret.elements); else - ret.descriptor.bytesize = - VarTypeByteSize(ret.descriptor.varType) * ret.descriptor.rows * ret.descriptor.cols; + ret.bytesize = VarTypeByteSize(ret.varType) * ret.rows * ret.cols; } } diff --git a/renderdoc/driver/shaders/dxbc/dxbc_debug.cpp b/renderdoc/driver/shaders/dxbc/dxbc_debug.cpp index ecdb7710f..bcee58702 100644 --- a/renderdoc/driver/shaders/dxbc/dxbc_debug.cpp +++ b/renderdoc/driver/shaders/dxbc/dxbc_debug.cpp @@ -1849,7 +1849,7 @@ void FlattenVariables(const rdcstr &cbufferName, const rdcarray if(v.type == VarType::Struct) { // check if this is an array of structs or not - if(c.type.descriptor.elements == 1) + if(c.type.elements == 1) { FlattenVariables(cbufferName, c.type.members, v.members, outvars, basename + ".", byteOffset, sourceVars); @@ -1860,15 +1860,15 @@ void FlattenVariables(const rdcstr &cbufferName, const rdcarray { FlattenVariables(cbufferName, c.type.members, v.members[m].members, outvars, StringFormat::Fmt("%s[%zu].", basename.c_str(), m), - byteOffset + m * c.type.descriptor.arrayByteStride, sourceVars); + byteOffset + m * c.type.arrayByteStride, sourceVars); } } } - else if(c.type.descriptor.elements > 1 || (v.rows == 0 && v.columns == 0) || !v.members.empty()) + else if(c.type.elements > 1 || (v.rows == 0 && v.columns == 0) || !v.members.empty()) { for(int m = 0; m < v.members.count(); m++) { - FlattenSingleVariable(cbufferName, byteOffset + m * c.type.descriptor.arrayByteStride, + FlattenSingleVariable(cbufferName, byteOffset + m * c.type.arrayByteStride, StringFormat::Fmt("%s[%zu]", basename.c_str(), m), v.members[m], outvars, sourceVars); } diff --git a/renderdoc/driver/shaders/dxbc/dxbc_reflect.cpp b/renderdoc/driver/shaders/dxbc/dxbc_reflect.cpp index c81b25256..84e27fdf5 100644 --- a/renderdoc/driver/shaders/dxbc/dxbc_reflect.cpp +++ b/renderdoc/driver/shaders/dxbc/dxbc_reflect.cpp @@ -51,26 +51,25 @@ static ShaderConstantType MakeShaderConstantType(bool cbufferPacking, DXBC::CBuf { ShaderConstantType ret; - ret.descriptor.type = type.descriptor.varType; - ret.descriptor.rows = (uint8_t)type.descriptor.rows; - ret.descriptor.columns = (uint8_t)type.descriptor.cols; - ret.descriptor.elements = type.descriptor.elements; - ret.descriptor.name = type.descriptor.name; - if(type.descriptor.varClass == DXBC::CLASS_MATRIX_ROWS || - type.descriptor.varClass == DXBC::CLASS_VECTOR || type.descriptor.varClass == DXBC::CLASS_SCALAR) - ret.descriptor.flags |= ShaderVariableFlags::RowMajorMatrix; + ret.baseType = type.varType; + ret.rows = (uint8_t)type.rows; + ret.columns = (uint8_t)type.cols; + ret.elements = type.elements; + ret.name = type.name; + if(type.varClass == DXBC::CLASS_MATRIX_ROWS || type.varClass == DXBC::CLASS_VECTOR || + type.varClass == DXBC::CLASS_SCALAR) + ret.flags |= ShaderVariableFlags::RowMajorMatrix; - uint32_t baseElemSize = (ret.descriptor.type == VarType::Double) ? 8 : 4; + uint32_t baseElemSize = (ret.baseType == VarType::Double) ? 8 : 4; // in D3D matrices in cbuffers always take up a float4 per row/column. Structured buffers in // SRVs/UAVs are tightly packed if(cbufferPacking) - ret.descriptor.matrixByteStride = uint8_t(baseElemSize * 4); + ret.matrixByteStride = uint8_t(baseElemSize * 4); else - ret.descriptor.matrixByteStride = uint8_t( - baseElemSize * (ret.descriptor.RowMajor() ? ret.descriptor.columns : ret.descriptor.rows)); + ret.matrixByteStride = uint8_t(baseElemSize * (ret.RowMajor() ? ret.columns : ret.rows)); - if(type.descriptor.varClass == DXBC::CLASS_STRUCT) + if(type.varClass == DXBC::CLASS_STRUCT) { // fxc's reported byte size for UAV structs is not reliable (booo). It seems to assume some // padding that doesn't exist, especially in arrays. So e.g.: @@ -83,32 +82,32 @@ static ShaderConstantType MakeShaderConstantType(bool cbufferPacking, DXBC::CBuf // // fortunately, since packing is tight we can look at the 'columns' field which is the number of // floats in the struct, and multiply that - uint32_t stride = type.descriptor.bytesize / RDCMAX(1U, type.descriptor.elements); + uint32_t stride = type.bytesize / RDCMAX(1U, type.elements); if(!cbufferPacking) { - stride = type.descriptor.cols * sizeof(float); + stride = type.cols * sizeof(float); // the exception is empty structs have 1 cols, probably because of a max(1,...) somewhere - if(type.descriptor.bytesize == 0) + if(type.bytesize == 0) stride = 0; } RDCASSERTMSG("Stride is too large for uint16_t", stride <= 0xffff); - ret.descriptor.arrayByteStride = RDCMIN(stride, 0xffffu) & 0xffff; + ret.arrayByteStride = RDCMIN(stride, 0xffffu) & 0xffff; // in D3D only cbuffers have 16-byte aligned structs if(cbufferPacking) - ret.descriptor.arrayByteStride = AlignUp16(ret.descriptor.arrayByteStride); + ret.arrayByteStride = AlignUp16(ret.arrayByteStride); - ret.descriptor.rows = ret.descriptor.columns = 0; + ret.rows = ret.columns = 0; - ret.descriptor.type = VarType::Struct; + ret.baseType = VarType::Struct; } else { - if(ret.descriptor.RowMajor()) - ret.descriptor.arrayByteStride = ret.descriptor.matrixByteStride * ret.descriptor.rows; + if(ret.RowMajor()) + ret.arrayByteStride = ret.matrixByteStride * ret.rows; else - ret.descriptor.arrayByteStride = ret.descriptor.matrixByteStride * ret.descriptor.columns; + ret.arrayByteStride = ret.matrixByteStride * ret.columns; } ret.members.reserve(type.members.size()); @@ -119,8 +118,8 @@ static ShaderConstantType MakeShaderConstantType(bool cbufferPacking, DXBC::CBuf if(!ret.members.empty()) { - ret.descriptor.rows = 0; - ret.descriptor.columns = 0; + ret.rows = 0; + ret.columns = 0; } return ret; @@ -137,8 +136,7 @@ static ShaderConstant MakeConstantBufferVariable(bool cbufferPacking, const DXBC // fxc emits negative values for offsets of empty structs sometimes. Replace that with a single // value so we can say 'use the previous value' - if(ret.type.descriptor.type == VarType::Struct && ret.type.members.empty() && - ret.byteOffset > 0xF0000000) + if(ret.type.baseType == VarType::Struct && ret.type.members.empty() && ret.byteOffset > 0xF0000000) ret.byteOffset = ~0U; return ret; @@ -190,17 +188,17 @@ static void MakeResourceList(bool srv, DXBC::DXBCContainer *dxbc, if(r.type == DXBC::ShaderInputBind::TYPE_BYTEADDRESS || r.type == DXBC::ShaderInputBind::TYPE_UAV_RWBYTEADDRESS) { - res.variableType.descriptor.rows = res.variableType.descriptor.columns = 1; - res.variableType.descriptor.elements = 1; - res.variableType.descriptor.type = VarType::UByte; - res.variableType.descriptor.name = "byte"; + res.variableType.rows = res.variableType.columns = 1; + res.variableType.elements = 1; + res.variableType.baseType = VarType::UByte; + res.variableType.name = "byte"; } else if(r.retType != DXBC::RETURN_TYPE_UNKNOWN && r.retType != DXBC::RETURN_TYPE_MIXED && r.retType != DXBC::RETURN_TYPE_CONTINUED) { - res.variableType.descriptor.rows = 1; - res.variableType.descriptor.columns = (uint8_t)r.numComps; - res.variableType.descriptor.elements = 1; + res.variableType.rows = 1; + res.variableType.columns = (uint8_t)r.numComps; + res.variableType.elements = 1; rdcstr name; @@ -208,27 +206,27 @@ static void MakeResourceList(bool srv, DXBC::DXBCContainer *dxbc, { case DXBC::RETURN_TYPE_UNORM: name = "unorm float"; - res.variableType.descriptor.type = VarType::Float; + res.variableType.baseType = VarType::Float; break; case DXBC::RETURN_TYPE_SNORM: name = "snorm float"; - res.variableType.descriptor.type = VarType::Float; + res.variableType.baseType = VarType::Float; break; case DXBC::RETURN_TYPE_SINT: name = "int"; - res.variableType.descriptor.type = VarType::SInt; + res.variableType.baseType = VarType::SInt; break; case DXBC::RETURN_TYPE_UINT: name = "uint"; - res.variableType.descriptor.type = VarType::UInt; + res.variableType.baseType = VarType::UInt; break; case DXBC::RETURN_TYPE_FLOAT: name = "float"; - res.variableType.descriptor.type = VarType::Float; + res.variableType.baseType = VarType::Float; break; case DXBC::RETURN_TYPE_DOUBLE: name = "double"; - res.variableType.descriptor.type = VarType::Double; + res.variableType.baseType = VarType::Double; break; default: name = "unknown"; break; } @@ -236,7 +234,7 @@ static void MakeResourceList(bool srv, DXBC::DXBCContainer *dxbc, if(r.numComps > 1) name += StringFormat::Fmt("%u", r.numComps); - res.variableType.descriptor.name = name; + res.variableType.name = name; } else { @@ -247,10 +245,10 @@ static void MakeResourceList(bool srv, DXBC::DXBCContainer *dxbc, } else { - res.variableType.descriptor.rows = 0; - res.variableType.descriptor.columns = 0; - res.variableType.descriptor.elements = 0; - res.variableType.descriptor.name = ""; + res.variableType.rows = 0; + res.variableType.columns = 0; + res.variableType.elements = 0; + res.variableType.name = ""; } } diff --git a/renderdoc/driver/shaders/dxbc/dxbc_spdb.cpp b/renderdoc/driver/shaders/dxbc/dxbc_spdb.cpp index 6fc7057cc..c62799401 100644 --- a/renderdoc/driver/shaders/dxbc/dxbc_spdb.cpp +++ b/renderdoc/driver/shaders/dxbc/dxbc_spdb.cpp @@ -1260,7 +1260,7 @@ SPDBChunk::SPDBChunk(byte *data, uint32_t spdblength) } } - mapping.var.type = vartype->baseType; + mapping.var.baseType = vartype->baseType; mapping.var.rows = 1; mapping.var.columns = uint8_t(vartype->vecSize); mapping.var.elements = 1; @@ -1778,7 +1778,7 @@ void SPDBChunk::GetLocals(const DXBC::DXBCContainer *dxbc, size_t, uintptr_t off // check if we already have a mapping for this variable for(SourceVariableMapping &a : locals) { - const ShaderConstantDescriptor &b = it->var; + const ShaderConstantType &b = it->var; if(a.name == b.name) { @@ -1802,7 +1802,7 @@ void SPDBChunk::GetLocals(const DXBC::DXBCContainer *dxbc, size_t, uintptr_t off SourceVariableMapping a; a.name = it->var.name; - a.type = it->var.type; + a.type = it->var.baseType; a.rows = it->var.rows; a.columns = it->var.columns; a.offset = it->varOffset; diff --git a/renderdoc/driver/shaders/dxbc/dxbc_spdb.h b/renderdoc/driver/shaders/dxbc/dxbc_spdb.h index 07154080f..547241343 100644 --- a/renderdoc/driver/shaders/dxbc/dxbc_spdb.h +++ b/renderdoc/driver/shaders/dxbc/dxbc_spdb.h @@ -253,7 +253,7 @@ struct LocalMapping uint32_t numComps; rdcarray gaps; - ShaderConstantDescriptor var; + ShaderConstantType var; // stored here so that we don't need to have the register mapping at the time we parse the SPDB // chunk diff --git a/renderdoc/driver/shaders/dxil/dxil_reflect.cpp b/renderdoc/driver/shaders/dxil/dxil_reflect.cpp index 2e8e17f1f..869b5994c 100644 --- a/renderdoc/driver/shaders/dxil/dxil_reflect.cpp +++ b/renderdoc/driver/shaders/dxil/dxil_reflect.cpp @@ -349,52 +349,52 @@ static DXBC::CBufferVariableType MakeCBufferVariableType(const TypeInfo &typeInf CBufferVariableType ret = {}; - ret.descriptor.elements = 1; + ret.elements = 1; if(t->type == Type::Scalar || t->type == Type::Vector) { - ret.descriptor.rows = ret.descriptor.cols = 1; + ret.rows = ret.cols = 1; if(t->type == Type::Vector) - ret.descriptor.cols = t->elemCount; - ret.descriptor.bytesize = (t->bitWidth / 8) * ret.descriptor.cols; - ret.descriptor.varClass = CLASS_SCALAR; + ret.cols = t->elemCount; + ret.bytesize = (t->bitWidth / 8) * ret.cols; + ret.varClass = CLASS_SCALAR; if(t->scalarType == Type::Float) { if(t->bitWidth > 32) - ret.descriptor.varType = VarType::Double; + ret.varType = VarType::Double; else if(t->bitWidth == 16) - ret.descriptor.varType = VarType::Half; + ret.varType = VarType::Half; else - ret.descriptor.varType = VarType::Float; + ret.varType = VarType::Float; } else { // can't distinguish int/uint here, default to signed if(t->bitWidth > 32) - ret.descriptor.varType = VarType::SLong; + ret.varType = VarType::SLong; else if(t->bitWidth == 32) - ret.descriptor.varType = VarType::SInt; + ret.varType = VarType::SInt; else if(t->bitWidth == 16) - ret.descriptor.varType = VarType::SShort; + ret.varType = VarType::SShort; else if(t->bitWidth == 8) - ret.descriptor.varType = VarType::SByte; + ret.varType = VarType::SByte; else if(t->bitWidth == 1) - ret.descriptor.varType = VarType::Bool; + ret.varType = VarType::Bool; } - ret.descriptor.name = ToStr(ret.descriptor.varType); + ret.name = ToStr(ret.varType); if(t->type == Type::Vector) - ret.descriptor.name += ToStr(ret.descriptor.cols); + ret.name += ToStr(ret.cols); return ret; } else if(t->type == Type::Array) { ret = MakeCBufferVariableType(typeInfo, t->inner); - ret.descriptor.elements *= RDCMAX(1U, t->elemCount); + ret.elements *= RDCMAX(1U, t->elemCount); // assume normal D3D array packing with each element on float4 boundary - ret.descriptor.bytesize += (ret.descriptor.elements - 1) * AlignUp16(ret.descriptor.bytesize); + ret.bytesize += (ret.elements - 1) * AlignUp16(ret.bytesize); return ret; } else if(t->type == Type::Struct) @@ -407,21 +407,21 @@ static DXBC::CBufferVariableType MakeCBufferVariableType(const TypeInfo &typeInf return ret; } - ret.descriptor.name = t->name; - ret.descriptor.varType = VarType::Unknown; - ret.descriptor.varClass = CLASS_STRUCT; + ret.name = t->name; + ret.varType = VarType::Unknown; + ret.varClass = CLASS_STRUCT; char alignmentPrefix[] = "dx.alignment.legacy."; - if(ret.descriptor.name.beginsWith(alignmentPrefix)) - ret.descriptor.name.erase(0, sizeof(alignmentPrefix) - 1); + if(ret.name.beginsWith(alignmentPrefix)) + ret.name.erase(0, sizeof(alignmentPrefix) - 1); char structPrefix[] = "struct."; - if(ret.descriptor.name.beginsWith(structPrefix)) - ret.descriptor.name.erase(0, sizeof(structPrefix) - 1); + if(ret.name.beginsWith(structPrefix)) + ret.name.erase(0, sizeof(structPrefix) - 1); char classPrefix[] = "class."; - if(ret.descriptor.name.beginsWith(classPrefix)) - ret.descriptor.name.erase(0, sizeof(classPrefix) - 1); + if(ret.name.beginsWith(classPrefix)) + ret.name.erase(0, sizeof(classPrefix) - 1); // if there are no members, return straight away if(t->members.empty()) @@ -431,7 +431,7 @@ static DXBC::CBufferVariableType MakeCBufferVariableType(const TypeInfo &typeInf if(it != typeInfo.structData.end()) { - ret.descriptor.bytesize = it->second.byteSize; + ret.bytesize = it->second.byteSize; } else { @@ -440,7 +440,7 @@ static DXBC::CBufferVariableType MakeCBufferVariableType(const TypeInfo &typeInf return ret; } - if(ret.descriptor.name.contains("StructuredBuffer<")) + if(ret.name.contains("StructuredBuffer<")) { // silently go into the inner member that's declared in this type as we only care about // reflecting that actual structure @@ -451,16 +451,16 @@ static DXBC::CBufferVariableType MakeCBufferVariableType(const TypeInfo &typeInf // otherwise use it as-is and trim off the name in an attempt to make it look normal - ret.descriptor.name.trim(); + ret.name.trim(); // remove any outer definition of the type - if(ret.descriptor.name.back() == '>') - ret.descriptor.name.pop_back(); + if(ret.name.back() == '>') + ret.name.pop_back(); else RDCERR("Expected closing > in StructuredBuffer type name"); - int idx = ret.descriptor.name.indexOf('<'); - ret.descriptor.name.erase(0, idx + 1); + int idx = ret.name.indexOf('<'); + ret.name.erase(0, idx + 1); } for(size_t i = 0; i < t->members.size(); i++) @@ -474,17 +474,17 @@ static DXBC::CBufferVariableType MakeCBufferVariableType(const TypeInfo &typeInf if(it->second.members[i].flags & TypeInfo::MemberData::Matrix) { - var.type.descriptor.rows = it->second.members[i].rows; - var.type.descriptor.cols = it->second.members[i].cols; - var.type.descriptor.varClass = (it->second.members[i].flags & TypeInfo::MemberData::RowMajor) - ? CLASS_MATRIX_ROWS - : CLASS_MATRIX_COLUMNS; + var.type.rows = it->second.members[i].rows; + var.type.cols = it->second.members[i].cols; + var.type.varClass = (it->second.members[i].flags & TypeInfo::MemberData::RowMajor) + ? CLASS_MATRIX_ROWS + : CLASS_MATRIX_COLUMNS; // the array was expanded out like float[4][3] would be, so divide by the matrix dimension // to get the real array size - var.type.descriptor.elements /= (it->second.members[i].flags & TypeInfo::MemberData::RowMajor) - ? var.type.descriptor.rows - : var.type.descriptor.cols; + var.type.elements /= (it->second.members[i].flags & TypeInfo::MemberData::RowMajor) + ? var.type.rows + : var.type.cols; } if(var.type.members.empty() && t->members[i]->type != Type::Struct) @@ -492,41 +492,41 @@ static DXBC::CBufferVariableType MakeCBufferVariableType(const TypeInfo &typeInf switch(it->second.members[i].type) { case ComponentType::Invalid: - var.type.descriptor.varType = VarType::Unknown; + var.type.varType = VarType::Unknown; RDCERR("Unexpected type in cbuffer annotations"); break; - case ComponentType::I1: var.type.descriptor.varType = VarType::Bool; break; - case ComponentType::I16: var.type.descriptor.varType = VarType::SShort; break; - case ComponentType::U16: var.type.descriptor.varType = VarType::UShort; break; - case ComponentType::I32: var.type.descriptor.varType = VarType::SInt; break; - case ComponentType::U32: var.type.descriptor.varType = VarType::UInt; break; - case ComponentType::I64: var.type.descriptor.varType = VarType::SLong; break; - case ComponentType::U64: var.type.descriptor.varType = VarType::ULong; break; - case ComponentType::F16: var.type.descriptor.varType = VarType::Half; break; - case ComponentType::F32: var.type.descriptor.varType = VarType::Float; break; - case ComponentType::F64: var.type.descriptor.varType = VarType::Double; break; + case ComponentType::I1: var.type.varType = VarType::Bool; break; + case ComponentType::I16: var.type.varType = VarType::SShort; break; + case ComponentType::U16: var.type.varType = VarType::UShort; break; + case ComponentType::I32: var.type.varType = VarType::SInt; break; + case ComponentType::U32: var.type.varType = VarType::UInt; break; + case ComponentType::I64: var.type.varType = VarType::SLong; break; + case ComponentType::U64: var.type.varType = VarType::ULong; break; + case ComponentType::F16: var.type.varType = VarType::Half; break; + case ComponentType::F32: var.type.varType = VarType::Float; break; + case ComponentType::F64: var.type.varType = VarType::Double; break; case ComponentType::SNormF16: - var.type.descriptor.varType = VarType::Half; + var.type.varType = VarType::Half; RDCERR("Unexpected type in cbuffer annotations"); break; case ComponentType::UNormF16: - var.type.descriptor.varType = VarType::Half; + var.type.varType = VarType::Half; RDCERR("Unexpected type in cbuffer annotations"); break; case ComponentType::SNormF32: - var.type.descriptor.varType = VarType::Float; + var.type.varType = VarType::Float; RDCERR("Unexpected type in cbuffer annotations"); break; case ComponentType::UNormF32: - var.type.descriptor.varType = VarType::Float; + var.type.varType = VarType::Float; RDCERR("Unexpected type in cbuffer annotations"); break; case ComponentType::SNormF64: - var.type.descriptor.varType = VarType::Double; + var.type.varType = VarType::Double; RDCERR("Unexpected type in cbuffer annotations"); break; case ComponentType::UNormF64: - var.type.descriptor.varType = VarType::Double; + var.type.varType = VarType::Double; RDCERR("Unexpected type in cbuffer annotations"); break; } @@ -738,12 +738,12 @@ static void AddResourceBind(DXBC::Reflection *refl, const TypeInfo &typeInfo, co else { // if we don't have type annotations, create a dummy byte-array struct member - refl->ResourceBinds[bind.name].descriptor.bytesize = structStride; - refl->ResourceBinds[bind.name].descriptor.cols = 1; - refl->ResourceBinds[bind.name].descriptor.rows = 1; - refl->ResourceBinds[bind.name].descriptor.elements = structStride; - refl->ResourceBinds[bind.name].descriptor.varClass = DXBC::CLASS_SCALAR; - refl->ResourceBinds[bind.name].descriptor.varType = VarType::UByte; + refl->ResourceBinds[bind.name].bytesize = structStride; + refl->ResourceBinds[bind.name].cols = 1; + refl->ResourceBinds[bind.name].rows = 1; + refl->ResourceBinds[bind.name].elements = structStride; + refl->ResourceBinds[bind.name].varClass = DXBC::CLASS_SCALAR; + refl->ResourceBinds[bind.name].varType = VarType::UByte; } } default: break; @@ -937,21 +937,21 @@ DXBC::Reflection *Program::GetReflection() var.offset = 0; // if we don't have type annotations, create a dummy struct member - var.type.descriptor.bytesize = bind.descriptor.byteSize / 16; - var.type.descriptor.cols = 4; - var.type.descriptor.rows = 1; - var.type.descriptor.elements = bind.descriptor.byteSize / 16; - var.type.descriptor.varClass = DXBC::CLASS_SCALAR; - var.type.descriptor.varType = VarType::UInt; + var.type.bytesize = bind.descriptor.byteSize / 16; + var.type.cols = 4; + var.type.rows = 1; + var.type.elements = bind.descriptor.byteSize / 16; + var.type.varClass = DXBC::CLASS_SCALAR; + var.type.varType = VarType::UInt; - uint32_t remainingBytes = var.type.descriptor.bytesize * 16; + uint32_t remainingBytes = var.type.bytesize * 16; bind.variables.push_back(var); // add any remaining bytes if the struct isn't a multiple of float4 size - var.type.descriptor.cols = 1; - var.type.descriptor.bytesize = var.type.descriptor.elements = 1; - var.type.descriptor.varType = VarType::UByte; + var.type.cols = 1; + var.type.bytesize = var.type.elements = 1; + var.type.varType = VarType::UByte; for(; remainingBytes < bind.descriptor.byteSize; remainingBytes++) { diff --git a/renderdoc/driver/shaders/spirv/spirv_reflect.cpp b/renderdoc/driver/shaders/spirv/spirv_reflect.cpp index 25fa2fa25..6e39e23eb 100644 --- a/renderdoc/driver/shaders/spirv/spirv_reflect.cpp +++ b/renderdoc/driver/shaders/spirv/spirv_reflect.cpp @@ -262,22 +262,22 @@ static uint32_t CalculateMinimumByteSize(const rdcarray &variabl uint32_t byteOffset = last.byteOffset; // arrays are easy - if(last.type.descriptor.arrayByteStride > 0) - return byteOffset + last.type.descriptor.arrayByteStride * last.type.descriptor.elements; + if(last.type.arrayByteStride > 0) + return byteOffset + last.type.arrayByteStride * last.type.elements; if(last.type.members.empty()) { // this is the last basic member // now calculate its size and return offset + size - RDCASSERT(last.type.descriptor.elements <= 1); + RDCASSERT(last.type.elements <= 1); uint32_t basicTypeSize = 4; - if(last.type.descriptor.type == VarType::Double) + if(last.type.baseType == VarType::Double) basicTypeSize = 8; - uint32_t rows = last.type.descriptor.rows; - uint32_t cols = last.type.descriptor.columns; + uint32_t rows = last.type.rows; + uint32_t cols = last.type.columns; // vectors are also easy if(rows == 1) @@ -286,11 +286,11 @@ static uint32_t CalculateMinimumByteSize(const rdcarray &variabl return byteOffset + rows * basicTypeSize; // for matrices we need to pad 3-column or 3-row up to 4 - if(cols == 3 && last.type.descriptor.RowMajor()) + if(cols == 3 && last.type.RowMajor()) { return byteOffset + rows * 4 * basicTypeSize; } - else if(rows == 3 && last.type.descriptor.ColMajor()) + else if(rows == 3 && last.type.ColMajor()) { return byteOffset + cols * 4 * basicTypeSize; } @@ -329,27 +329,27 @@ StructSizes CalculateStructProps(uint32_t emptyStructSize, const ShaderConstant { StructSizes ret; - if(c.type.descriptor.type != VarType::Struct) + if(c.type.baseType != VarType::Struct) { // A scalar of size N has a scalar alignment of N. // A vector or matrix type has a scalar alignment equal to that of its component type. // An array type has a scalar alignment equal to that of its element type. - ret.scalarAlign = VarTypeByteSize(c.type.descriptor.type); + ret.scalarAlign = VarTypeByteSize(c.type.baseType); // A scalar has a base alignment equal to its scalar alignment. ret.baseAlign = ret.scalarAlign; // A row-major matrix of C columns has a base alignment equal to the base alignment of a vector // of C matrix components. - uint8_t vecSize = c.type.descriptor.columns; - uint8_t matSize = c.type.descriptor.rows; + uint8_t vecSize = c.type.columns; + uint8_t matSize = c.type.rows; // A column-major matrix has a base alignment equal to the base alignment of the matrix column // type. - if(c.type.descriptor.rows > 1 && c.type.descriptor.ColMajor()) + if(c.type.rows > 1 && c.type.ColMajor()) { - vecSize = c.type.descriptor.rows; - matSize = c.type.descriptor.columns; + vecSize = c.type.rows; + matSize = c.type.columns; } // A two-component vector has a base alignment equal to twice its scalar alignment. @@ -368,17 +368,16 @@ StructSizes CalculateStructProps(uint32_t emptyStructSize, const ShaderConstant // An array or structure type has an extended alignment equal to the largest extended alignment // of any of its members, rounded up to a multiple of 16. - if(c.type.descriptor.elements > 1) + if(c.type.elements > 1) ret.extendedAlign = AlignUp16(ret.extendedAlign); if(matSize > 1) - ret.extendedAlign = ret.baseAlign = c.type.descriptor.matrixByteStride; + ret.extendedAlign = ret.baseAlign = c.type.matrixByteStride; - ret.scalarSize = ret.scalarAlign * RDCMAX(c.type.descriptor.rows, (uint8_t)1) * - RDCMAX(c.type.descriptor.columns, (uint8_t)1) * - RDCMAX(c.type.descriptor.elements, 1U); - ret.baseSize = ret.baseAlign * matSize * RDCMAX(c.type.descriptor.elements, 1U); - ret.extendedSize = ret.extendedAlign * matSize * RDCMAX(c.type.descriptor.elements, 1U); + ret.scalarSize = ret.scalarAlign * RDCMAX(c.type.rows, (uint8_t)1) * + RDCMAX(c.type.columns, (uint8_t)1) * RDCMAX(c.type.elements, 1U); + ret.baseSize = ret.baseAlign * matSize * RDCMAX(c.type.elements, 1U); + ret.extendedSize = ret.extendedAlign * matSize * RDCMAX(c.type.elements, 1U); } else { @@ -1108,10 +1107,10 @@ void Reflector::MakeReflection(const GraphicsAPI sourceAPI, const ShaderStage st res.name = StringFormat::Fmt("atomic%u", global.id.value()); res.resType = TextureType::Buffer; - res.variableType.descriptor.columns = 1; - res.variableType.descriptor.rows = 1; - res.variableType.descriptor.type = VarType::UInt; - res.variableType.descriptor.name = varType->name; + res.variableType.columns = 1; + res.variableType.rows = 1; + res.variableType.baseType = VarType::UInt; + res.variableType.name = varType->name; bindmap.bindset = 0; bindmap.bind = GetBinding(decorations[global.id].binding); @@ -1172,7 +1171,7 @@ void Reflector::MakeReflection(const GraphicsAPI sourceAPI, const ShaderStage st res.isTexture = res.resType != TextureType::Buffer; res.isReadOnly = imageType.sampled != 2 || imageType.dim == rdcspv::Dim::SubpassData; - res.variableType.descriptor.type = imageType.retType.Type(); + res.variableType.baseType = imageType.retType.Type(); if(res.isReadOnly) roresources.push_back(shaderrespair(bindmap, res)); @@ -1195,9 +1194,9 @@ void Reflector::MakeReflection(const GraphicsAPI sourceAPI, const ShaderStage st strings[global.id], decorations[global.id], specInfo); if(isArray) - constant.type.descriptor.elements = arraySize; + constant.type.elements = arraySize; else - constant.type.descriptor.elements = 0; + constant.type.elements = 0; constant.byteOffset = decorations[global.id].location; @@ -1222,10 +1221,10 @@ void Reflector::MakeReflection(const GraphicsAPI sourceAPI, const ShaderStage st res.name = StringFormat::Fmt("ssbo%u", global.id.value()); res.resType = TextureType::Buffer; - res.variableType.descriptor.columns = 0; - res.variableType.descriptor.rows = 0; - res.variableType.descriptor.type = VarType::Float; - res.variableType.descriptor.name = varType->name; + res.variableType.columns = 0; + res.variableType.rows = 0; + res.variableType.baseType = VarType::Float; + res.variableType.name = varType->name; MakeConstantBlockVariables(effectiveStorage, *varType, 0, 0, res.variableType.members, pointerTypes, specInfo); @@ -1600,12 +1599,11 @@ void Reflector::MakeConstantBlockVariables(rdcspv::StorageClass storage, const D // unnecessary (if e.g. somewhere else the shader demonstrates scalar packing so the padded size // is larger than the scalar calculated size) but that's only present in one place. - if(cblock[i].type.descriptor.type == VarType::Struct && - cblock[i].type.descriptor.arrayByteStride == 0) + if(cblock[i].type.baseType == VarType::Struct && cblock[i].type.arrayByteStride == 0) { // this should not be an array - if it is SPIR-V requires an array byte stride, and this // calculation below is also invalid. - RDCASSERTEQUAL(cblock[i].type.descriptor.elements, 1); + RDCASSERTEQUAL(cblock[i].type.elements, 1); StructSizes sizes = CalculateStructProps(emptyStructSize, cblock[i]); @@ -1619,11 +1617,11 @@ void Reflector::MakeConstantBlockVariables(rdcspv::StorageClass storage, const D RDCASSERT(sizes.scalarSize <= availSize, sizes.scalarSize, availSize); if(sizes.extendedSize <= availSize) - cblock[i].type.descriptor.arrayByteStride = sizes.extendedSize; + cblock[i].type.arrayByteStride = sizes.extendedSize; else if(sizes.baseSize <= availSize) - cblock[i].type.descriptor.arrayByteStride = sizes.baseSize; + cblock[i].type.arrayByteStride = sizes.baseSize; else - cblock[i].type.descriptor.arrayByteStride = sizes.scalarSize; + cblock[i].type.arrayByteStride = sizes.scalarSize; } } } @@ -1645,97 +1643,96 @@ void Reflector::MakeConstantBlockVariable(ShaderConstant &outConst, // if the type is an array, set array size and strides then unpeel the array if(curType->type == DataType::ArrayType) { - outConst.type.descriptor.elements = + outConst.type.elements = curType->length != Id() ? EvaluateConstant(curType->length, specInfo).value.u32v[0] : ~0U; if(varDecorations.arrayStride != ~0U) { RDCASSERTMSG("Stride is too large for uint16_t", varDecorations.arrayStride <= 0xffff); - outConst.type.descriptor.arrayByteStride = RDCMIN(varDecorations.arrayStride, 0xffffu) & 0xffff; + outConst.type.arrayByteStride = RDCMIN(varDecorations.arrayStride, 0xffffu) & 0xffff; } else if(decorations[curType->id].arrayStride != ~0U) { RDCASSERTMSG("Stride is too large for uint16_t", decorations[curType->id].arrayStride <= 0xffff); - outConst.type.descriptor.arrayByteStride = - RDCMIN(decorations[curType->id].arrayStride, 0xffffu) & 0xffff; + outConst.type.arrayByteStride = RDCMIN(decorations[curType->id].arrayStride, 0xffffu) & 0xffff; } if(varDecorations.matrixStride != ~0U) - outConst.type.descriptor.matrixByteStride = varDecorations.matrixStride & 0xff; + outConst.type.matrixByteStride = varDecorations.matrixStride & 0xff; else if(decorations[curType->id].matrixStride != ~0U) - outConst.type.descriptor.matrixByteStride = decorations[curType->id].matrixStride & 0xff; + outConst.type.matrixByteStride = decorations[curType->id].matrixStride & 0xff; curType = &dataTypes[curType->InnerType()]; } if(curType->type == DataType::VectorType || curType->type == DataType::MatrixType) { - outConst.type.descriptor.type = curType->scalar().Type(); + outConst.type.baseType = curType->scalar().Type(); if(curType->type == DataType::VectorType || (varDecorations.flags & Decorations::RowMajor)) - outConst.type.descriptor.flags |= ShaderVariableFlags::RowMajorMatrix; + outConst.type.flags |= ShaderVariableFlags::RowMajorMatrix; if(varDecorations.matrixStride != ~0U) - outConst.type.descriptor.matrixByteStride = varDecorations.matrixStride & 0xff; + outConst.type.matrixByteStride = varDecorations.matrixStride & 0xff; if(curType->type == DataType::MatrixType) { - outConst.type.descriptor.rows = (uint8_t)curType->vector().count; - outConst.type.descriptor.columns = (uint8_t)curType->matrix().count; + outConst.type.rows = (uint8_t)curType->vector().count; + outConst.type.columns = (uint8_t)curType->matrix().count; } else { - outConst.type.descriptor.columns = (uint8_t)curType->vector().count; + outConst.type.columns = (uint8_t)curType->vector().count; } - outConst.type.descriptor.name = curType->name; + outConst.type.name = curType->name; } else if(curType->type == DataType::ScalarType) { - outConst.type.descriptor.type = curType->scalar().Type(); - outConst.type.descriptor.flags |= ShaderVariableFlags::RowMajorMatrix; + outConst.type.baseType = curType->scalar().Type(); + outConst.type.flags |= ShaderVariableFlags::RowMajorMatrix; - outConst.type.descriptor.name = curType->name; + outConst.type.name = curType->name; } else { if(curType->type == DataType::PointerType) { - outConst.type.descriptor.type = VarType::ULong; - outConst.type.descriptor.rows = 1; - outConst.type.descriptor.columns = 1; - outConst.type.descriptor.name = curType->name; + outConst.type.baseType = VarType::ULong; + outConst.type.rows = 1; + outConst.type.columns = 1; + outConst.type.name = curType->name; // try to insert the inner type ID into the map. If it succeeds, it gets the next available // pointer type index (size of the map), if not then we just get the previously added index auto it = pointerTypes.insert(std::make_pair(curType->InnerType(), (uint16_t)pointerTypes.size())); - outConst.type.descriptor.pointerTypeID = it.first->second; + outConst.type.pointerTypeID = it.first->second; return; } RDCASSERT(curType->type == DataType::StructType || curType->type == DataType::ArrayType); - outConst.type.descriptor.type = VarType::Struct; - outConst.type.descriptor.rows = 0; - outConst.type.descriptor.columns = 0; + outConst.type.baseType = VarType::Struct; + outConst.type.rows = 0; + outConst.type.columns = 0; - outConst.type.descriptor.name = curType->name; + outConst.type.name = curType->name; - MakeConstantBlockVariables(storage, *curType, outConst.type.descriptor.elements, - outConst.type.descriptor.arrayByteStride, outConst.type.members, - pointerTypes, specInfo); + MakeConstantBlockVariables(storage, *curType, outConst.type.elements, + outConst.type.arrayByteStride, outConst.type.members, pointerTypes, + specInfo); if(curType->type == DataType::ArrayType) { - outConst.type.descriptor.name = type.name; + outConst.type.name = type.name; // if the inner type is an array, it will be expanded in our members list. So don't also // redundantly keep the element count - outConst.type.descriptor.arrayByteStride *= outConst.type.descriptor.elements; - outConst.type.descriptor.elements = 1; + outConst.type.arrayByteStride *= outConst.type.elements; + outConst.type.elements = 1; } } } diff --git a/renderdoc/replay/renderdoc_serialise.inl b/renderdoc/replay/renderdoc_serialise.inl index ee4fb76eb..42b241838 100644 --- a/renderdoc/replay/renderdoc_serialise.inl +++ b/renderdoc/replay/renderdoc_serialise.inl @@ -161,9 +161,9 @@ void DoSerialise(SerialiserType &ser, SigParameter &el) } template -void DoSerialise(SerialiserType &ser, ShaderConstantDescriptor &el) +void DoSerialise(SerialiserType &ser, ShaderConstantType &el) { - SERIALISE_MEMBER(type); + SERIALISE_MEMBER(baseType); SERIALISE_MEMBER(rows); SERIALISE_MEMBER(columns); SERIALISE_MEMBER(matrixByteStride); @@ -172,14 +172,6 @@ void DoSerialise(SerialiserType &ser, ShaderConstantDescriptor &el) SERIALISE_MEMBER(name); SERIALISE_MEMBER(flags); SERIALISE_MEMBER(pointerTypeID); - - SIZE_CHECK(48); -} - -template -void DoSerialise(SerialiserType &ser, ShaderConstantType &el) -{ - SERIALISE_MEMBER(descriptor); SERIALISE_MEMBER(members); SIZE_CHECK(72); diff --git a/renderdoc/replay/replay_driver.cpp b/renderdoc/replay/replay_driver.cpp index 941249106..4b2856483 100644 --- a/renderdoc/replay/replay_driver.cpp +++ b/renderdoc/replay/replay_driver.cpp @@ -341,7 +341,7 @@ void PatchTriangleFanRestartIndexBufer(rdcarray &patchedIndices, uint3 newIndices.swap(patchedIndices); } -void StandardFillCBufferVariable(ResourceId shader, const ShaderConstantDescriptor &desc, +void StandardFillCBufferVariable(ResourceId shader, const ShaderConstantType &desc, uint32_t dataOffset, const bytebuf &data, ShaderVariable &outvar, uint32_t matStride) { @@ -433,13 +433,13 @@ static void StandardFillCBufferVariables(ResourceId shader, const rdcarray 1; - const uint32_t matStride = invars[v].type.descriptor.matrixByteStride; + const uint32_t matStride = invars[v].type.matrixByteStride; uint32_t dataOffset = baseOffset + invars[v].byteOffset; @@ -468,7 +468,7 @@ static void StandardFillCBufferVariables(ResourceId shader, const rdcarray &patchedIndices, uint3 uint64_t CalcMeshOutputSize(uint64_t curSize, uint64_t requiredOutput); -void StandardFillCBufferVariable(ResourceId shader, const ShaderConstantDescriptor &desc, +void StandardFillCBufferVariable(ResourceId shader, const ShaderConstantType &desc, uint32_t dataOffset, const bytebuf &data, ShaderVariable &outvar, uint32_t matStride); void StandardFillCBufferVariables(ResourceId shader, const rdcarray &invars,