lee/renderdoc
1
0 Fork 0
mirror of https://github.com/baldurk/renderdoc.git synced 2026-10-16 00:59:22 +00:00
Code Issues Packages Projects Releases Wiki Activity

Refactor ShaderVariable use and non-32-bit precision. Closes #2466

Browse Source
This commit is contained in:
baldurk committed 2022-02-02 15:00:43 +00:00
1 parent 4b748c6368
commit e42b0ff2ca
18 files changed
+508 -351
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

qrenderdoc/Code/BufferFormatter.cpp
+96 -47
View File
@@ -1044,22 +1044,40 @@ static void FillShaderVarData(ShaderVariable &var, const ShaderConstant &elem, c
src++;
if(var.type == VarType::Double)
var.value.f64v[dst] = o.toDouble();
if(var.type == VarType::Float || var.type == VarType::Half)
var.value.f32v[dst] = o.toFloat();
else if(var.type == VarType::ULong)
var.value.u64v[dst] = o.toULongLong();
else if(var.type == VarType::SLong)
var.value.s64v[dst] = o.toLongLong();
else if(var.type == VarType::Bool)
var.value.u32v[dst] = o.toBool() ? 1 : 0;
else if(var.type == VarType::UInt || var.type == VarType::UShort || var.type == VarType::UByte)
var.value.u32v[dst] = o.toUInt();
else if(var.type == VarType::SInt || var.type == VarType::SShort || var.type == VarType::SByte)
var.value.s32v[dst] = o.toInt();
else
var.value.f32v[dst] = o.toFloat();
switch(var.type)
{
case VarType::Float: var.value.f32v[dst] = o.toFloat(); break;
case VarType::Double: var.value.f64v[dst] = o.toDouble(); break;
case VarType::Half: var.value.f16v[dst] = rdhalf::make(o.toFloat()); break;
case VarType::Bool: var.value.u32v[dst] = o.toBool() ? 1 : 0; break;
case VarType::ULong: var.value.u64v[dst] = o.toULongLong(); break;
case VarType::UInt: var.value.u32v[dst] = o.toUInt(); break;
case VarType::UShort: var.value.u16v[dst] = o.toUInt() & 0xffff; break;
case VarType::UByte: var.value.u8v[dst] = o.toUInt() & 0xff; break;
case VarType::SLong: var.value.s64v[dst] = o.toLongLong(); break;
case VarType::SInt:
var.value.s32v[dst] = o.toInt();
break;
break;
case VarType::SShort:
var.value.u16v[dst] = (int16_t)qBound((int)INT16_MIN, o.toInt(), (int)INT16_MAX);
break;
case VarType::SByte:
var.value.u8v[dst] = (int8_t)qBound((int)INT8_MIN, o.toInt(), (int)INT8_MAX);
break;
case VarType::GPUPointer:
// treat this as a 64-bit unsigned integer
var.value.u64v[dst] = o.toULongLong();
break;
case VarType::ConstantBlock:
case VarType::ReadOnlyResource:
case VarType::ReadWriteResource:
case VarType::Sampler:
case VarType::Unknown:
qCritical() << "Unexpected variable type" << ToQStr(var.type) << "in variable"
<< (QString)var.name;
break;
}
}
}
}
@@ -1469,7 +1487,7 @@ QVariantList GetVariants(ResourceFormat format, const ShaderConstantDescriptor &
else if(format.compByteWidth == 4)
ret.push_back(readObj<float>(data, end, ok));
else if(format.compByteWidth == 2)
ret.push_back(RENDERDOC_HalfToFloat(readObj<uint16_t>(data, end, ok)));
ret.push_back((float)rdhalf::make(readObj<uint16_t>(data, end, ok)));
}
else if(format.compType == CompType::SInt)
{
@@ -1638,36 +1656,67 @@ QString RowString(const ShaderVariable &v, uint32_t row, VarType type)
if(v.type == VarType::GPUPointer)
return ToQStr(v.GetPointer());
if(type == VarType::Double)
return RowValuesToString((int)v.columns, v.displayAsHex, v.value.f64v[row * v.columns + 0],
v.value.f64v[row * v.columns + 1], v.value.f64v[row * v.columns + 2],
v.value.f64v[row * v.columns + 3]);
else if(type == VarType::SLong)
return RowValuesToString((int)v.columns, v.displayAsHex, v.value.s64v[row * v.columns + 0],
v.value.s64v[row * v.columns + 1], v.value.s64v[row * v.columns + 2],
v.value.s64v[row * v.columns + 3]);
else if(type == VarType::ULong)
return RowValuesToString((int)v.columns, v.displayAsHex, v.value.u64v[row * v.columns + 0],
v.value.u64v[row * v.columns + 1], v.value.u64v[row * v.columns + 2],
v.value.u64v[row * v.columns + 3]);
else if(type == VarType::SInt || type == VarType::SShort || type == VarType::SByte)
return RowValuesToString((int)v.columns, v.displayAsHex, v.value.s32v[row * v.columns + 0],
v.value.s32v[row * v.columns + 1], v.value.s32v[row * v.columns + 2],
v.value.s32v[row * v.columns + 3]);
else if(type == VarType::UInt || type == VarType::UShort || type == VarType::UByte)
return RowValuesToString((int)v.columns, v.displayAsHex, v.value.u32v[row * v.columns + 0],
v.value.u32v[row * v.columns + 1], v.value.u32v[row * v.columns + 2],
v.value.u32v[row * v.columns + 3]);
else if(type == VarType::Bool)
return RowValuesToString((int)v.columns, v.displayAsHex,
v.value.u32v[row * v.columns + 0] ? true : false,
v.value.u32v[row * v.columns + 1] ? true : false,
v.value.u32v[row * v.columns + 2] ? true : false,
v.value.u32v[row * v.columns + 3] ? true : false);
else
return RowValuesToString((int)v.columns, v.displayAsHex, v.value.f32v[row * v.columns + 0],
v.value.f32v[row * v.columns + 1], v.value.f32v[row * v.columns + 2],
v.value.f32v[row * v.columns + 3]);
switch(type)
{
case VarType::Float:
return RowValuesToString((int)v.columns, v.displayAsHex, v.value.f32v[row * v.columns + 0],
v.value.f32v[row * v.columns + 1], v.value.f32v[row * v.columns + 2],
v.value.f32v[row * v.columns + 3]);
case VarType::Double:
return RowValuesToString((int)v.columns, v.displayAsHex, v.value.f64v[row * v.columns + 0],
v.value.f64v[row * v.columns + 1], v.value.f64v[row * v.columns + 2],
v.value.f64v[row * v.columns + 3]);
case VarType::Half:
return RowValuesToString((int)v.columns, v.displayAsHex, v.value.f16v[row * v.columns + 0],
v.value.f16v[row * v.columns + 1], v.value.f16v[row * v.columns + 2],
v.value.f16v[row * v.columns + 3]);
case VarType::Bool:
return RowValuesToString((int)v.columns, v.displayAsHex,
v.value.u32v[row * v.columns + 0] ? true : false,
v.value.u32v[row * v.columns + 1] ? true : false,
v.value.u32v[row * v.columns + 2] ? true : false,
v.value.u32v[row * v.columns + 3] ? true : false);
case VarType::ULong:
return RowValuesToString((int)v.columns, v.displayAsHex, v.value.u64v[row * v.columns + 0],
v.value.u64v[row * v.columns + 1], v.value.u64v[row * v.columns + 2],
v.value.u64v[row * v.columns + 3]);
case VarType::UInt:
return RowValuesToString((int)v.columns, v.displayAsHex, v.value.u32v[row * v.columns + 0],
v.value.u32v[row * v.columns + 1], v.value.u32v[row * v.columns + 2],
v.value.u32v[row * v.columns + 3]);
case VarType::UShort:
return RowValuesToString((int)v.columns, v.displayAsHex, v.value.u16v[row * v.columns + 0],
v.value.u16v[row * v.columns + 1], v.value.u16v[row * v.columns + 2],
v.value.u16v[row * v.columns + 3]);
case VarType::UByte:
return RowValuesToString((int)v.columns, v.displayAsHex, v.value.u8v[row * v.columns + 0],
v.value.u8v[row * v.columns + 1], v.value.u8v[row * v.columns + 2],
v.value.u8v[row * v.columns + 3]);
case VarType::SLong:
return RowValuesToString((int)v.columns, v.displayAsHex, v.value.s64v[row * v.columns + 0],
v.value.s64v[row * v.columns + 1], v.value.s64v[row * v.columns + 2],
v.value.s64v[row * v.columns + 3]);
case VarType::SInt:
return RowValuesToString((int)v.columns, v.displayAsHex, v.value.s32v[row * v.columns + 0],
v.value.s32v[row * v.columns + 1], v.value.s32v[row * v.columns + 2],
v.value.s32v[row * v.columns + 3]);
case VarType::SShort:
return RowValuesToString((int)v.columns, v.displayAsHex, v.value.s16v[row * v.columns + 0],
v.value.s16v[row * v.columns + 1], v.value.s16v[row * v.columns + 2],
v.value.s16v[row * v.columns + 3]);
case VarType::SByte:
return RowValuesToString((int)v.columns, v.displayAsHex, v.value.s8v[row * v.columns + 0],
v.value.s8v[row * v.columns + 1], v.value.s8v[row * v.columns + 2],
v.value.s8v[row * v.columns + 3]);
case VarType::GPUPointer: return ToQStr(v.GetPointer());
case VarType::ConstantBlock:
case VarType::ReadOnlyResource:
case VarType::ReadWriteResource:
case VarType::Sampler:
case VarType::Unknown: break;
}
return lit("???");
}
QString VarString(const ShaderVariable &v)
qrenderdoc/Code/QRDUtils.h
+1
View File
@@ -228,6 +228,7 @@ struct Formatter
static void shutdown();
static QString Format(double f, bool hex = false);
static QString Format(rdhalf f, bool hex = false) { return Format((float)f, hex); }
static QString HumanFormat(uint64_t u);
static QString Format(uint64_t u, bool hex = false)
{
qrenderdoc/Code/pyrenderdoc/pyconversion.h
+19
View File
@@ -364,6 +364,25 @@ struct TypeConversion<double, false>
static PyObject *ConvertToPy(const double &in) { return PyFloat_FromDouble(in); }
};
template <>
struct TypeConversion<rdhalf, false>
{
static int ConvertFromPy(PyObject *in, rdhalf &out)
{
if(!PyFloat_Check(in))
return SWIG_TypeError;
out.set(float(PyFloat_AsDouble(in)));
if(PyErr_Occurred())
return SWIG_OverflowError;
return SWIG_OK;
}
static PyObject *ConvertToPy(const rdhalf &in) { return PyFloat_FromDouble((float)in); }
};
// partial specialisation for enums, we just convert as their underlying type,
// whatever integer size that happens to be
template <typename T>
qrenderdoc/Code/pyrenderdoc/renderdoc.i
+2
View File
@@ -100,6 +100,7 @@ VA_IGNORE_REST_OF_FILE
%ignore rdcfixedarray::operator[];
%ignore rdcliteral;
%ignore rdcpair;
%ignore rdhalf;
%ignore bytebuf;
// special handling for RENDERDOC_GetDefaultCaptureOptions to transform output parameter to a return value
@@ -331,6 +332,7 @@ TEMPLATE_FIXEDARRAY_INSTANTIATE(rdcfixedarray, ResourceId, 8)
TEMPLATE_FIXEDARRAY_INSTANTIATE(rdcfixedarray, bool, 4)
TEMPLATE_FIXEDARRAY_INSTANTIATE(rdcfixedarray, bool, 8)
TEMPLATE_FIXEDARRAY_INSTANTIATE(rdcfixedarray, float, 16)
TEMPLATE_FIXEDARRAY_INSTANTIATE(rdcfixedarray, rdhalf, 16)
TEMPLATE_FIXEDARRAY_INSTANTIATE(rdcfixedarray, int32_t, 16)
TEMPLATE_FIXEDARRAY_INSTANTIATE(rdcfixedarray, uint32_t, 16)
TEMPLATE_FIXEDARRAY_INSTANTIATE(rdcfixedarray, double, 16)
qrenderdoc/Windows/ShaderViewer.cpp
+109 -56
View File
@@ -2593,6 +2593,10 @@ bool ShaderViewer::getVar(RDTreeWidgetItem *item, ShaderVariable *var, QString *
const QString xyzw = lit("xyzw");
size_t dataSize = VarTypeByteSize(ret.type);
if(dataSize == 0)
dataSize = 4;
for(uint32_t i = 0; i < mapping.variables.size(); i++)
{
const DebugVariableReference &r = mapping.variables[i];
@@ -2628,10 +2632,14 @@ bool ShaderViewer::getVar(RDTreeWidgetItem *item, ShaderVariable *var, QString *
}
}
if(mapping.type == VarType::Double || mapping.type == VarType::ULong)
if(dataSize == 8)
ret.value.u64v[i] = reg->value.u64v[r.component];
else
else if(dataSize == 4)
ret.value.u32v[i] = reg->value.u32v[r.component];
else if(dataSize == 2)
ret.value.u16v[i] = reg->value.u16v[r.component];
else
ret.value.u8v[i] = reg->value.u8v[r.component];
}
else
{
@@ -3393,7 +3401,7 @@ void ShaderViewer::updateWatchVariables()
"(\\[[0-9]+\\])?" // a literal-indexed array expression
"\\.?" // optional struct dot
")+)" // 1 or more chained identifiers
"(,[xfiudb])?" // optional typecast
"(,[iduxbof])?" // optional typecast
"$")); // end of the line
QRegularExpression identifierSliceRE(
@@ -3404,7 +3412,7 @@ void ShaderViewer::updateWatchVariables()
"(\\[[0-9]+\\])" // or a literal-indexed array expression
")")); // end capture
QRegularExpression swizzleRE(lit("^\\.[xyzwrgba]+$"));
QRegularExpression swizzleRE(lit("^\\.?[xyzwrgba]+$"));
QRegularExpressionMatch match = exprRE.match(expr);
@@ -3475,7 +3483,9 @@ void ShaderViewer::updateWatchVariables()
// member
if(swizzleRE.match(identifier).hasMatch() && identifiers.isEmpty())
{
swizzle = identifier.mid(1);
swizzle = identifier;
if(swizzle[0] == QLatin1Char('.'))
swizzle = swizzle.mid(1);
break;
}
@@ -3500,21 +3510,40 @@ void ShaderViewer::updateWatchVariables()
if(swizzle.isEmpty())
swizzle = lit("xyzw").left((int)var.columns);
size_t dataSize = VarTypeByteSize(var.type);
if(regcast == QLatin1Char(' '))
{
if(var.type == VarType::Double)
regcast = QLatin1Char('d');
else if(var.type == VarType::Float || var.type == VarType::Half)
regcast = QLatin1Char('f');
else if(var.type == VarType::ULong || var.type == VarType::UInt ||
var.type == VarType::UShort || var.type == VarType::UByte)
regcast = QLatin1Char('u');
else if(var.type == VarType::SLong || var.type == VarType::SInt ||
var.type == VarType::SShort || var.type == VarType::SByte ||
var.type == VarType::Bool)
regcast = QLatin1Char('i');
else if(var.type == VarType::Unknown)
regcast = ui->intView->isChecked() ? QLatin1Char('i') : QLatin1Char('f');
switch(var.type)
{
case VarType::Float:
case VarType::Double:
case VarType::Half: regcast = QLatin1Char('f'); break;
case VarType::Bool:
case VarType::ULong:
case VarType::UInt:
case VarType::UShort:
case VarType::UByte: regcast = QLatin1Char('u'); break;
case VarType::SLong:
case VarType::SInt:
case VarType::SShort:
case VarType::SByte: regcast = QLatin1Char('i'); break;
case VarType::GPUPointer:
regcast = QLatin1Char('#');
dataSize = 8;
break;
case VarType::ConstantBlock:
case VarType::ReadOnlyResource:
case VarType::ReadWriteResource:
case VarType::Sampler:
regcast = QLatin1Char('#');
dataSize = 4;
break;
case VarType::Unknown:
regcast = ui->intView->isChecked() ? QLatin1Char('i') : QLatin1Char('f');
dataSize = 4;
break;
}
}
QString val;
@@ -3533,29 +3562,58 @@ void ShaderViewer::updateWatchVariables()
if(swiz == QLatin1Char('w') || swiz == QLatin1Char('a'))
elindex = 3;
if(regcast == QLatin1Char('i'))
ShaderValue value = {};
memcpy(&value, var.value.u8v.data() + elindex * dataSize, dataSize);
if(regcast == QLatin1Char('#'))
{
val += Formatter::Format(var.value.s32v[elindex]);
if(var.type == VarType::GPUPointer)
val += ToQStr(var.GetPointer());
else
val += stringRep(var, 0);
}
else if(regcast == QLatin1Char('i') || regcast == QLatin1Char('d'))
{
if(dataSize == 8)
val += Formatter::Format(value.s64v[0]);
else if(dataSize == 4)
val += Formatter::Format(value.s32v[0]);
else if(dataSize == 2)
val += Formatter::Format(value.s16v[0]);
else
val += Formatter::Format(value.s8v[0]);
}
else if(regcast == QLatin1Char('f'))
{
val += Formatter::Format(var.value.f32v[elindex]);
if(dataSize == 8)
val += Formatter::Format(value.f64v[0]);
else if(dataSize == 4)
val += Formatter::Format(value.f32v[0]);
else
val += Formatter::Format(value.f16v[0]);
}
else if(regcast == QLatin1Char('u'))
{
val += Formatter::Format(var.value.u32v[elindex]);
val += Formatter::Format(value.u64v[0]);
}
else if(regcast == QLatin1Char('x'))
{
val += Formatter::Format(var.value.u32v[elindex], true);
if(dataSize == 8)
val += Formatter::Format(value.u64v[0], true);
else if(dataSize == 4)
val += Formatter::Format(value.u32v[0], true);
else if(dataSize == 2)
val += Formatter::Format(value.u16v[0], true);
else
val += Formatter::Format(value.u8v[0], true);
}
else if(regcast == QLatin1Char('b'))
{
val += QFormatStr("%1").arg(var.value.u32v[elindex], 32, 2, QLatin1Char('0'));
val += QFormatStr("%1").arg(value.u64v[0], (int)dataSize * 8, 2, QLatin1Char('0'));
}
else if(regcast == QLatin1Char('d'))
else if(regcast == QLatin1Char('o'))
{
val += Formatter::Format(var.value.f64v[elindex]);
val += QFormatStr("0%1").arg(value.u64v[0], 0, 8, QLatin1Char('0'));
}
if(s < swizzle.count() - 1)
@@ -3610,16 +3668,7 @@ RDTreeWidgetItem *ShaderViewer::makeSourceVariableNode(const ShaderVariable &var
{
QString typeName;
if(var.type == VarType::UInt)
typeName = lit("uint");
else if(var.type == VarType::SInt)
typeName = lit("int");
else if(var.type == VarType::Float)
typeName = lit("float");
else if(var.type == VarType::Double)
typeName = lit("double");
else if(var.type == VarType::Bool)
typeName = lit("bool");
typeName = ToQStr(var.type);
QString rowTypeName = typeName;
@@ -3673,16 +3722,7 @@ RDTreeWidgetItem *ShaderViewer::makeSourceVariableNode(const SourceVariableMappi
QString regNames, typeName;
QString value;
if(l.type == VarType::UInt)
typeName = lit("uint");
else if(l.type == VarType::SInt)
typeName = lit("int");
else if(l.type == VarType::Float)
typeName = lit("float");
else if(l.type == VarType::Double)
typeName = lit("double");
else if(l.type == VarType::Bool)
typeName = lit("bool");
typeName = ToQStr(l.type);
QList<RDTreeWidgetItem *> children;
@@ -3852,16 +3892,29 @@ RDTreeWidgetItem *ShaderViewer::makeSourceVariableNode(const SourceVariableMappi
regNames += QFormatStr("%1.%2").arg(r.name).arg(xyzw[r.component % 4]);
}
if(l.type == VarType::UInt)
value += Formatter::Format(reg->value.u32v[r.component]);
else if(l.type == VarType::SInt)
value += Formatter::Format(reg->value.s32v[r.component]);
else if(l.type == VarType::Bool)
value += Formatter::Format(reg->value.u32v[r.component] ? true : false);
else if(l.type == VarType::Float)
value += Formatter::Format(reg->value.f32v[r.component]);
else if(l.type == VarType::Double)
value += Formatter::Format(reg->value.f64v[r.component]);
switch(l.type)
{
case VarType::Float: value += Formatter::Format(reg->value.f32v[r.component]); break;
case VarType::Double: value += Formatter::Format(reg->value.f64v[r.component]); break;
case VarType::Half: value += Formatter::Format(reg->value.f16v[r.component]); break;
case VarType::Bool: Formatter::Format(reg->value.u32v[r.component] ? true : false);
case VarType::ULong: value += Formatter::Format(reg->value.u64v[r.component]); break;
case VarType::UInt: value += Formatter::Format(reg->value.u32v[r.component]); break;
case VarType::UShort: value += Formatter::Format(reg->value.u16v[r.component]); break;
case VarType::UByte: value += Formatter::Format(reg->value.u8v[r.component]); break;
case VarType::SLong: value += Formatter::Format(reg->value.s64v[r.component]); break;
case VarType::SInt: value += Formatter::Format(reg->value.s32v[r.component]); break;
case VarType::SShort: value += Formatter::Format(reg->value.s16v[r.component]); break;
case VarType::SByte: value += Formatter::Format(reg->value.s8v[r.component]); break;
case VarType::GPUPointer: value += ToQStr(reg->GetPointer()); break;
case VarType::ConstantBlock:
case VarType::ReadOnlyResource:
case VarType::ReadWriteResource:
case VarType::Sampler: value += stringRep(*reg, 0); break;
case VarType::Unknown:
qCritical() << "Unexpected unknown variable" << (QString)l.name;
break;
}
}
else
{
renderdoc/api/replay/pipestate.inl
+2 -2
View File
@@ -820,9 +820,9 @@ rdcarray<VertexInputAttribute> PipeState::GetVertexInputs() const
for(uint32_t c = 0; c < compCount; c++)
{
if(varType == VarType::Float)
if(varType == VarType::Float || varType == VarType::Double)
ret[a].genericValue.floatValue[c] = attrs[i].genericValue.floatValue[c];
else if(varType == VarType::UInt)
else if(varType == VarType::UInt || varType == VarType::Bool)
ret[a].genericValue.uintValue[c] = attrs[i].genericValue.uintValue[c];
else if(varType == VarType::SInt)
ret[a].genericValue.intValue[c] = attrs[i].genericValue.intValue[c];
renderdoc/api/replay/renderdoc_replay.h
+4
View File
@@ -47,6 +47,10 @@ typedef void(RENDERDOC_CC *pRENDERDOC_FreeArrayMem)(void *mem);
extern "C" RENDERDOC_API void *RENDERDOC_CC RENDERDOC_AllocArrayMem(uint64_t sz);
typedef void *(RENDERDOC_CC *pRENDERDOC_AllocArrayMem)(uint64_t sz);
// similarly these need to be pre-declared for use in rdhalf
extern "C" RENDERDOC_API float RENDERDOC_CC RENDERDOC_HalfToFloat(uint16_t half);
extern "C" RENDERDOC_API uint16_t RENDERDOC_CC RENDERDOC_FloatToHalf(float flt);
#endif
// declare base types and stringise interface
renderdoc/api/replay/shader_types.h
+31
View File
@@ -109,6 +109,31 @@ struct BindpointIndex
DECLARE_REFLECTION_STRUCT(BindpointIndex);
struct rdhalf
{
#if !defined(SWIG)
static rdhalf make(const uint16_t &u)
{
rdhalf ret;
ret.storage = u;
return ret;
}
static rdhalf make(const float &f)
{
rdhalf ret;
ret.storage = RENDERDOC_FloatToHalf(f);
return ret;
}
void set(const uint16_t &u) { storage = u; }
void set(const float &f) { storage = RENDERDOC_FloatToHalf(f); }
#endif
explicit operator float() const { return RENDERDOC_HalfToFloat(storage); }
explicit operator uint16_t() const { return storage; }
private:
uint16_t storage;
};
DECLARE_STRINGISE_TYPE(rdhalf);
DOCUMENT("A C union that holds 16 values, with each different basic variable type.");
union ShaderValue
{
@@ -136,6 +161,12 @@ union ShaderValue
)");
rdcfixedarray<double, 16> f64v;
DOCUMENT(R"(16-tuple of 16-bit half-precision float values.
:type: Tuple[int,...]
)");
rdcfixedarray<rdhalf, 16> f16v;
DOCUMENT(R"(16-tuple of 64-bit unsigned integer values.
:type: Tuple[int,...]
renderdoc/driver/shaders/dxil/dxil_disassemble.cpp
+1 -1
View File
@@ -1736,7 +1736,7 @@ static void floatAppendToString(const Type *t, const ShaderValue &val, uint32_t
// dxc/llvm always prints half floats as their 16-bit hex representation.
if(t->bitWidth == 16)
{
ret += StringFormat::Fmt("0xH%04X", val.u64v[i]);
ret += StringFormat::Fmt("0xH%04X", val.u32v[i]);
return;
}
#endif
renderdoc/driver/shaders/spirv/spirv_debug_glsl450.cpp
+2 -2
View File
@@ -295,7 +295,7 @@ ShaderVariable Determinant(ThreadState &state, uint32_t, const rdcarray<Id> &par
if(!warned)
{
warned = true;
RDCLOG("Calculating determinant in floats instead of %s", ToStr(m.type).c_str());
RDCLOG("Calculating determinant at float precision instead of %s", ToStr(m.type).c_str());
}
for(uint8_t c = 0; c < m.rows * m.columns; c++)
@@ -346,7 +346,7 @@ ShaderVariable MatrixInverse(ThreadState &state, uint32_t, const rdcarray<Id> &p
if(!warned)
{
warned = true;
RDCLOG("Calculating determinant in floats instead of %s", ToStr(m.type).c_str());
RDCLOG("Calculating matrix inverse at float precision instead of %s", ToStr(m.type).c_str());
}
for(uint8_t c = 0; c < m.rows * m.columns; c++)
renderdoc/driver/shaders/spirv/spirv_debug_setup.cpp
+1 -1
View File
@@ -2366,7 +2366,7 @@ uint32_t Debugger::ApplyDerivatives(uint32_t quadIndex, const Decorations &curDe
ApplyDerivative<float>(activeLaneIndex, quadIndex, outVar.value.f32v.data(), derivs);
else if(outVar.type == VarType::Half)
ApplyDerivative<half_float::half>(activeLaneIndex, quadIndex,
(half_float::half *)outVar.value.u16v.data(), derivs);
(half_float::half *)outVar.value.f16v.data(), derivs);
else if(outVar.type == VarType::Double)
ApplyDerivative<double>(activeLaneIndex, quadIndex, outVar.value.f64v.data(), derivs);
}
renderdoc/driver/shaders/spirv/spirv_disassemble.cpp
+30 -29
View File
@@ -23,6 +23,7 @@
******************************************************************************/
#include "common/formatting.h"
#include "maths/half_convert.h"
#include "spirv_op_helpers.h"
#include "spirv_reflect.h"
@@ -434,16 +435,16 @@ rdcstr Reflector::Disassemble(const rdcstr &entryPoint,
switch(type.scalar().Type())
{
case VarType::Float:
case VarType::Half: ret += ToStr(value.f32v[0]); break;
case VarType::Half: ret += ToStr(value.f16v[0]); break;
case VarType::Float: ret += ToStr(value.f32v[0]); break;
case VarType::Double: ret += ToStr(value.f64v[0]); break;
case VarType::SInt:
case VarType::SShort:
case VarType::SByte: ret += ToStr(value.s32v[0]); break;
case VarType::SInt: ret += ToStr(value.s32v[0]); break;
case VarType::SShort: ret += ToStr(value.s16v[0]); break;
case VarType::SByte: ret += ToStr(value.s8v[0]); break;
case VarType::Bool: ret += value.u32v[0] ? "true" : "false"; break;
case VarType::UInt:
case VarType::UShort:
case VarType::UByte: ret += ToStr(value.u32v[0]); break;
case VarType::UInt: ret += ToStr(value.u32v[0]); break;
case VarType::UShort: ret += ToStr(value.u16v[0]); break;
case VarType::UByte: ret += ToStr(value.u8v[0]); break;
case VarType::SLong: ret += ToStr(value.s64v[0]); break;
case VarType::Unknown:
case VarType::GPUPointer:
@@ -1632,24 +1633,24 @@ rdcstr Reflector::StringiseConstant(rdcspv::Id id) const
switch(value.type)
{
case VarType::Float:
case VarType::Half: return ToStr(value.value.f32v[0]);
case VarType::Half: return ToStr(value.value.f16v[0]); break;
case VarType::Float: return ToStr(value.value.f32v[0]);
case VarType::Double: return ToStr(value.value.f64v[0]);
case VarType::SInt:
case VarType::SShort:
case VarType::SByte: return ToStr(value.value.s32v[0]);
case VarType::SInt: return ToStr(value.value.s32v[0]);
case VarType::SShort: return ToStr(value.value.s16v[0]);
case VarType::SByte: return ToStr(value.value.s8v[0]);
case VarType::Bool: return value.value.u32v[0] ? "true" : "false";
case VarType::UInt:
case VarType::UShort:
case VarType::UByte: return ToStr(value.value.u32v[0]);
case VarType::UInt: return ToStr(value.value.u32v[0]);
case VarType::UShort: return ToStr(value.value.u16v[0]);
case VarType::UByte: return ToStr(value.value.u8v[0]);
case VarType::SLong: return ToStr(value.value.s64v[0]);
case VarType::ULong: return ToStr(value.value.u64v[0]);
case VarType::Unknown:
case VarType::GPUPointer:
case VarType::ConstantBlock:
case VarType::ReadOnlyResource:
case VarType::ReadWriteResource:
case VarType::Sampler:
case VarType::ULong: return ToStr(value.value.u64v[0]);
case VarType::Sampler: return "???";
}
}
else if(type.type == DataType::VectorType)
@@ -1659,24 +1660,24 @@ rdcstr Reflector::StringiseConstant(rdcspv::Id id) const
{
switch(value.type)
{
case VarType::Float:
case VarType::Half: ret += ToStr(value.value.f32v[i]); break;
case VarType::Half: ret += ToStr(value.value.f16v[i]); break;
case VarType::Float: ret += ToStr(value.value.f32v[i]); break;
case VarType::Double: ret += ToStr(value.value.f64v[i]); break;
case VarType::SInt:
case VarType::SShort:
case VarType::SByte: ret += ToStr(value.value.s32v[i]); break;
case VarType::UInt:
case VarType::UShort:
case VarType::UByte: ret += ToStr(value.value.u32v[i]); break;
case VarType::SInt: ret += ToStr(value.value.s32v[i]); break;
case VarType::SShort: ret += ToStr(value.value.s16v[i]); break;
case VarType::SByte: ret += ToStr(value.value.s8v[i]); break;
case VarType::Bool: ret += value.value.u32v[i] ? "true" : "false"; break;
case VarType::UInt: ret += ToStr(value.value.u32v[i]); break;
case VarType::UShort: ret += ToStr(value.value.u16v[i]); break;
case VarType::UByte: ret += ToStr(value.value.u8v[i]); break;
case VarType::SLong: ret += ToStr(value.value.s64v[i]); break;
case VarType::Bool: return value.value.u32v[0] ? "true" : "false";
case VarType::ULong: ret += ToStr(value.value.u64v[i]); break;
case VarType::Unknown:
case VarType::GPUPointer:
case VarType::ConstantBlock:
case VarType::ReadOnlyResource:
case VarType::ReadWriteResource:
case VarType::Sampler:
case VarType::ULong: ret += ToStr(value.value.u64v[i]); break;
case VarType::Sampler: ret += "???"; break;
}
if(i + 1 < value.columns)
ret += ", ";
renderdoc/driver/shaders/spirv/spirv_processor.cpp
+133 -60
View File
@@ -26,6 +26,7 @@
#include "common/formatting.h"
#include "maths/half_convert.h"
#include "spirv_op_helpers.h"
#include "var_dispatch_helpers.h"
namespace rdcspv
{
@@ -39,15 +40,20 @@ static void ConstructCompositeConstant(ShaderVariable &v, const rdcarray<ShaderV
}
else
{
size_t sz = VarTypeByteSize(v.type);
for(uint32_t c = 0; c < v.columns; c++)
{
// if this is a vector, v.rows is 1 so r is always 0, meaning that it is irrelevant
for(uint32_t r = 0; r < v.rows; r++)
{
if(VarTypeByteSize(v.type) == 8)
if(sz == 8)
v.value.u64v[r * v.columns + c] = members[c].value.u64v[r];
else
else if(sz == 4)
v.value.u32v[r * v.columns + c] = members[c].value.u32v[r];
else if(sz == 2)
v.value.u16v[r * v.columns + c] = members[c].value.u16v[r];
else
v.value.u8v[r * v.columns + c] = members[c].value.u8v[r];
}
}
}
@@ -59,7 +65,7 @@ Scalar scalar(VarType type)
{
case VarType::Float: return scalar<float>();
case VarType::Double: return scalar<double>();
case VarType::Half: return Scalar(Op::TypeFloat, 16, false);
case VarType::Half: return scalar<half_float::half>();
case VarType::SInt: return scalar<int32_t>();
case VarType::UInt: return scalar<uint32_t>();
case VarType::SShort: return scalar<int16_t>();
@@ -667,7 +673,7 @@ void Processor::RegisterOp(Iter it)
else
{
// if it's signed, sign extend
if(type.scalar().signedness && type.scalar().width < 16)
if(type.scalar().signedness && type.scalar().width <= 16)
{
// is the top bit set?
if(v.value.u32v[0] & (1 << (type.scalar().width - 1)))
@@ -1009,6 +1015,8 @@ ShaderVariable Processor::EvaluateConstant(Id constID, const rdcarray<SpecConsta
const DataType &retType = dataTypes[specop.type];
ret.type = retType.scalar().Type();
if(specop.params.empty())
{
RDCERR("Expected paramaters for SpecConstantOp %s", ToStr(specop.op).c_str());
@@ -1043,9 +1051,14 @@ ShaderVariable Processor::EvaluateConstant(Id constID, const rdcarray<SpecConsta
if(retType.scalar().width == 64)
ret.value.u64v[i] =
params[0].value.u32v[i] ? params[1].value.u64v[i] : params[2].value.u64v[i];
else
else if(retType.scalar().width == 32)
ret.value.u32v[i] =
params[0].value.u32v[i] ? params[1].value.u32v[i] : params[2].value.u32v[i];
else if(retType.scalar().width == 16)
ret.value.u16v[i] =
params[0].value.u32v[i] ? params[1].value.u16v[i] : params[2].value.u16v[i];
else
ret.value.u8v[i] = params[0].value.u8v[i] ? params[1].value.u8v[i] : params[2].value.u8v[i];
}
}
else if(specop.op == Op::CompositeExtract)
@@ -1074,8 +1087,12 @@ ShaderVariable Processor::EvaluateConstant(Id constID, const rdcarray<SpecConsta
{
if(retType.scalar().width == 64)
ret.value.u64v[c] = composite.value.u64v[row * composite.columns + c];
else
else if(retType.scalar().width == 32)
ret.value.u32v[c] = composite.value.u32v[row * composite.columns + c];
else if(retType.scalar().width == 16)
ret.value.u16v[c] = composite.value.u16v[row * composite.columns + c];
else
ret.value.u8v[c] = composite.value.u8v[row * composite.columns + c];
}
}
else if(indices.size() == 2)
@@ -1086,8 +1103,12 @@ ShaderVariable Processor::EvaluateConstant(Id constID, const rdcarray<SpecConsta
if(retType.scalar().width == 64)
ret.value.u64v[0] = composite.value.u64v[row * composite.columns + col];
else
else if(retType.scalar().width == 32)
ret.value.u32v[0] = composite.value.u32v[row * composite.columns + col];
else if(retType.scalar().width == 16)
ret.value.u16v[0] = composite.value.u16v[row * composite.columns + col];
else
ret.value.u8v[0] = composite.value.u8v[row * composite.columns + col];
}
else
{
@@ -1106,8 +1127,12 @@ ShaderVariable Processor::EvaluateConstant(Id constID, const rdcarray<SpecConsta
// vector returning a scalar
if(retType.scalar().width == 64)
ret.value.u64v[0] = composite.value.u64v[col];
else
else if(retType.scalar().width == 32)
ret.value.u32v[0] = composite.value.u32v[col];
else if(retType.scalar().width == 16)
ret.value.u16v[0] = composite.value.u16v[col];
else
ret.value.u8v[0] = composite.value.u8v[col];
}
else
{
@@ -1147,8 +1172,12 @@ ShaderVariable Processor::EvaluateConstant(Id constID, const rdcarray<SpecConsta
{
if(retType.scalar().width == 64)
composite.value.u64v[row * composite.columns + c] = object.value.u64v[c];
else
else if(retType.scalar().width == 32)
composite.value.u32v[row * composite.columns + c] = object.value.u32v[c];
else if(retType.scalar().width == 16)
composite.value.u16v[row * composite.columns + c] = object.value.u16v[c];
else if(retType.scalar().width == 8)
composite.value.u8v[row * composite.columns + c] = object.value.u8v[c];
}
}
else if(indices.size() == 2)
@@ -1159,8 +1188,12 @@ ShaderVariable Processor::EvaluateConstant(Id constID, const rdcarray<SpecConsta
if(retType.scalar().width == 64)
composite.value.u64v[row * composite.columns + col] = object.value.u64v[0];
else
else if(retType.scalar().width == 32)
composite.value.u32v[row * composite.columns + col] = object.value.u32v[0];
else if(retType.scalar().width == 16)
composite.value.u16v[row * composite.columns + col] = object.value.u16v[0];
else
composite.value.u8v[row * composite.columns + col] = object.value.u8v[0];
}
else
{
@@ -1175,8 +1208,12 @@ ShaderVariable Processor::EvaluateConstant(Id constID, const rdcarray<SpecConsta
// vector inserting a scalar
if(retType.scalar().width == 64)
composite.value.u64v[indices[0]] = object.value.u64v[0];
else
else if(retType.scalar().width == 32)
composite.value.u32v[indices[0]] = object.value.u32v[0];
else if(retType.scalar().width == 16)
composite.value.u16v[indices[0]] = object.value.u16v[0];
else
composite.value.u8v[indices[0]] = object.value.u8v[0];
}
else
{
@@ -1204,6 +1241,7 @@ ShaderVariable Processor::EvaluateConstant(Id constID, const rdcarray<SpecConsta
indices.push_back(specop.params[i].value());
ret = ShaderVariable("derived", 0, 0, 0, 0);
ret.type = retType.scalar().Type();
ret.columns = (uint8_t)indices.size();
for(size_t i = 0; i < indices.size(); i++)
@@ -1213,8 +1251,12 @@ ShaderVariable Processor::EvaluateConstant(Id constID, const rdcarray<SpecConsta
{
if(retType.scalar().width == 64)
ret.value.u64v[i] = vec1.value.u64v[idx];
else
else if(retType.scalar().width == 32)
ret.value.u32v[i] = vec1.value.u32v[idx];
else if(retType.scalar().width == 16)
ret.value.u16v[i] = vec1.value.u16v[idx];
else
ret.value.u8v[i] = vec1.value.u8v[idx];
}
else
{
@@ -1222,8 +1264,12 @@ ShaderVariable Processor::EvaluateConstant(Id constID, const rdcarray<SpecConsta
if(retType.scalar().width == 64)
ret.value.u64v[i] = vec2.value.u64v[idx];
else
else if(retType.scalar().width == 32)
ret.value.u32v[i] = vec2.value.u32v[idx];
else if(retType.scalar().width == 16)
ret.value.u16v[i] = vec2.value.u16v[idx];
else
ret.value.u8v[i] = vec2.value.u8v[idx];
}
}
@@ -1234,57 +1280,54 @@ ShaderVariable Processor::EvaluateConstant(Id constID, const rdcarray<SpecConsta
ShaderVariable param = EvaluateConstant(specop.params[0], specInfo);
ret = param;
const DataType &paramType = dataTypes[idTypes[specop.params[0]]];
ret.name = "converted";
RDCEraseEl(ret.value);
ret.type = retType.scalar().Type();
if(specop.op == Op::UConvert)
for(uint8_t i = 0; i < param.columns; i++)
{
if(paramType.scalar().width == 8)
ret.value.u64v[0] = param.value.u32v[0] & 0xFFU;
else if(paramType.scalar().width == 16)
ret.value.u64v[0] = param.value.u32v[0] & 0xFFFFU;
else if(paramType.scalar().width == 32)
ret.value.u64v[0] = param.value.u32v[0];
else
ret.value.u64v[0] = param.value.u64v[0];
}
else if(specop.op == Op::SConvert)
{
if(paramType.scalar().width == 8)
ret.value.s64v[0] =
(int8_t)RDCCLAMP(param.value.s32v[0], (int32_t)INT8_MIN, (int32_t)INT8_MAX);
else if(paramType.scalar().width == 16)
ret.value.s64v[0] =
(int16_t)RDCCLAMP(param.value.s32v[0], (int32_t)INT16_MIN, (int32_t)INT16_MAX);
else if(paramType.scalar().width == 32)
ret.value.s64v[0] = param.value.s32v[0];
else
ret.value.s64v[0] = param.value.s64v[0];
}
else if(specop.op == Op::FConvert)
{
if(paramType.scalar().width == 16)
if(specop.op == Op::UConvert)
{
if(retType.scalar().width == 64)
ret.value.f64v[0] = ConvertFromHalf(ConvertToHalf(param.value.f32v[0]));
else
ret.value.f32v[0] = ConvertFromHalf(ConvertToHalf(param.value.f32v[0]));
uint64_t x = 0;
#undef _IMPL
#define _IMPL(I, S, U) x = comp<U>(param, i);
IMPL_FOR_INT_TYPES_FOR_TYPE(_IMPL, param.type);
#undef _IMPL
#define _IMPL(I, S, U) comp<U>(ret, i) = (U)x;
IMPL_FOR_INT_TYPES_FOR_TYPE(_IMPL, ret.type);
}
else if(paramType.scalar().width == 32)
else if(specop.op == Op::SConvert)
{
if(retType.scalar().width == 64)
ret.value.f64v[0] = param.value.f32v[0];
else
ret.value.f32v[0] = param.value.f32v[0];
int64_t x = 0;
#undef _IMPL
#define _IMPL(I, S, U) x = comp<S>(param, i);
IMPL_FOR_INT_TYPES_FOR_TYPE(_IMPL, param.type);
#undef _IMPL
#define _IMPL(I, S, U) comp<S>(ret, i) = (S)x;
IMPL_FOR_INT_TYPES_FOR_TYPE(_IMPL, ret.type);
}
else
else if(specop.op == Op::FConvert)
{
if(retType.scalar().width == 64)
ret.value.f64v[0] = param.value.f64v[0];
else
ret.value.f32v[0] = (float)param.value.f64v[0];
double x = 0.0;
#undef _IMPL
#define _IMPL(T) x = comp<T>(param, i);
IMPL_FOR_FLOAT_TYPES_FOR_TYPE(_IMPL, param.type);
#undef _IMPL
#define _IMPL(T) comp<T>(ret, i) = (T)x;
// IMPL_FOR_FLOAT_TYPES_FOR_TYPE(_IMPL, ret.type);
if(ret.type == VarType::Float)
comp<float>(ret, i) = (float)x;
else if(ret.type == VarType::Half)
comp<half_float::half>(ret, i) = (float)x;
else if(ret.type == VarType::Double)
comp<double>(ret, i) = (double)x;
}
}
@@ -1379,8 +1422,10 @@ ShaderVariable Processor::EvaluateConstant(Id constID, const rdcarray<SpecConsta
{
if(paramType.scalar().width == 64)
val.f64v[0] = params[p].value.f64v[col];
else
else if(paramType.scalar().width == 32)
val.f64v[0] = params[p].value.f32v[col];
else
val.f64v[0] = (float)params[p].value.f16v[col];
}
else
{
@@ -1388,15 +1433,23 @@ ShaderVariable Processor::EvaluateConstant(Id constID, const rdcarray<SpecConsta
{
if(paramType.scalar().width == 64)
val.s64v[0] = params[p].value.s64v[col];
else
else if(paramType.scalar().width == 32)
val.s64v[0] = params[p].value.s32v[col];
else if(paramType.scalar().width == 16)
val.s64v[0] = params[p].value.s16v[col];
else
val.s64v[0] = params[p].value.s8v[col];
}
else
{
if(paramType.scalar().width == 64)
val.u64v[0] = params[p].value.u64v[col];
else
else if(paramType.scalar().width == 32)
val.u64v[0] = params[p].value.u32v[col];
else if(paramType.scalar().width == 16)
val.u64v[0] = params[p].value.u16v[col];
else
val.u64v[0] = params[p].value.u8v[col];
}
}
}
@@ -1471,15 +1524,34 @@ ShaderVariable Processor::EvaluateConstant(Id constID, const rdcarray<SpecConsta
{
if(retType.scalar().width == 64)
ret.value.f64v[col] = a.f64v[0];
else
else if(retType.scalar().width == 32)
ret.value.f32v[col] = (float)a.f64v[0];
else
ret.value.f16v[col].set((float)a.f64v[0]);
}
else if(signedness)
{
if(retType.scalar().width == 64)
ret.value.s64v[col] = a.s64v[0];
else if(retType.scalar().width == 32)
ret.value.s32v[col] =
(int32_t)RDCCLAMP(a.s64v[col], (int64_t)INT32_MIN, (int64_t)INT32_MAX);
else if(retType.scalar().width == 16)
ret.value.s16v[col] =
(int16_t)RDCCLAMP(a.s64v[col], (int64_t)INT16_MIN, (int64_t)INT16_MAX);
else
ret.value.s8v[col] = (int8_t)RDCCLAMP(a.s64v[col], (int64_t)INT8_MIN, (int64_t)INT8_MAX);
}
else
{
if(retType.scalar().width == 64)
ret.value.u64v[col] = a.u64v[0];
else
else if(retType.scalar().width == 32)
ret.value.u32v[col] = a.u64v[0] & 0xFFFFFFFF;
else if(retType.scalar().width == 16)
ret.value.u16v[col] = a.u64v[0] & 0xFFFF;
else
ret.value.u8v[col] = a.u64v[0] & 0xFF;
}
}
@@ -1497,6 +1569,7 @@ ShaderVariable Processor::EvaluateConstant(Id constID, const rdcarray<SpecConsta
{
ShaderVariable ret = c.value;
// we can always just read into u64v - if the type is smaller the LSB maps nicely.
ret.value.u64v[0] = spec.value;
return ret;
renderdoc/driver/shaders/spirv/var_dispatch_helpers.h
+5 -5
View File
@@ -48,7 +48,7 @@ template <>
inline half_float::half &comp<half_float::half>(ShaderVariable &var, uint32_t c)
{
half_float::half *ret;
uint16_t *comp = &var.value.u16v[c];
rdhalf *comp = &var.value.f16v[c];
memcpy(&ret, &comp, sizeof(ret));
return *ret;
}
@@ -72,7 +72,7 @@ template <>
inline half_float::half comp<half_float::half>(const ShaderVariable &var, uint32_t c)
{
half_float::half ret;
uint16_t comp = var.value.u16v[c];
rdhalf comp = var.value.f16v[c];
memcpy(&ret, &comp, sizeof(ret));
return ret;
}
@@ -116,7 +116,7 @@ inline float floatComp(const ShaderVariable &var, uint32_t c)
if(var.type == VarType::Float)
return var.value.f32v[c];
else if(var.type == VarType::Half)
return ConvertFromHalf(var.value.u16v[c]);
return (float)var.value.f16v[c];
else if(var.type == VarType::Double)
return (float)var.value.f64v[c];
else
@@ -158,7 +158,7 @@ inline void setFloatComp(ShaderVariable &var, uint32_t c, float f)
if(var.type == VarType::Float)
var.value.f32v[c] = f;
else if(var.type == VarType::Half)
var.value.u16v[c] = ConvertToHalf(f);
var.value.f16v[c].set(f);
else if(var.type == VarType::Double)
var.value.f64v[c] = f;
}
@@ -196,7 +196,7 @@ inline void set0001(ShaderVariable &result)
if(result.type == VarType::Float)
result.value.f32v[3] = 1.0f;
else if(result.type == VarType::Half)
result.value.u16v[3] = ConvertToHalf(1.0f);
result.value.f16v[3].set(1.0f);
else if(result.type == VarType::Double)
result.value.f64v[3] = 1.0;
else
renderdoc/driver/vulkan/vk_shaderdebug.cpp
+18 -114
View File
@@ -831,12 +831,8 @@ public:
{
const ShaderVariable &biasVar = lane.GetSrc(operands.bias);
float bias = biasVar.value.f32v[0];
// silently cast parameters to 32-bit floats
if(biasVar.type == VarType::Half)
bias = ConvertFromHalf(biasVar.value.u16v[0]);
else if(biasVar.type == VarType::Double)
bias = (float)biasVar.value.f64v[0];
float bias = floatComp(biasVar, 0);
if(bias != 0.0f)
{
@@ -1001,24 +997,11 @@ public:
case rdcspv::Op::ImageDrefGather:
{
// silently cast parameters to 32-bit floats
if(uv.type == VarType::Float)
{
for(int i = 0; i < coords; i++)
uniformParams.uvwa[i] = uv.value.f32v[i];
}
else if(uv.type == VarType::Half)
{
for(int i = 0; i < coords; i++)
uniformParams.uvwa[i] = ConvertFromHalf(uv.value.u16v[i]);
}
else if(uv.type == VarType::Double)
{
for(int i = 0; i < coords; i++)
uniformParams.uvwa[i] = (float)uv.value.f64v[i];
}
for(int i = 0; i < coords; i++)
uniformParams.uvwa[i] = floatComp(uv, i);
if(useCompare)
uniformParams.compare = compare.value.f32v[0];
uniformParams.compare = floatComp(compare, 0);
constParams.gatherChannel = gatherChannel;
@@ -1108,21 +1091,8 @@ public:
case rdcspv::Op::ImageSampleProjDrefImplicitLod:
{
// silently cast parameters to 32-bit floats
if(uv.type == VarType::Float)
{
for(int i = 0; i < coords; i++)
uniformParams.uvwa[i] = uv.value.f32v[i];
}
else if(uv.type == VarType::Half)
{
for(int i = 0; i < coords; i++)
uniformParams.uvwa[i] = ConvertFromHalf(uv.value.u16v[i]);
}
else if(uv.type == VarType::Double)
{
for(int i = 0; i < coords; i++)
uniformParams.uvwa[i] = (float)uv.value.f64v[i];
}
for(int i = 0; i < coords; i++)
uniformParams.uvwa[i] = floatComp(uv, i);
if(proj)
{
@@ -1132,11 +1102,7 @@ public:
// do the divide ourselves rather than severely complicating the sample shader (as proj
// variants need non-arrayed textures)
float q = uv.value.f32v[coords];
if(uv.type == VarType::Half)
q = ConvertFromHalf(uv.value.u16v[coords]);
else if(uv.type == VarType::Double)
q = (float)uv.value.f64v[coords];
float q = floatComp(uv, coords);
uniformParams.uvwa[0] /= q;
uniformParams.uvwa[1] /= q;
@@ -1147,34 +1113,22 @@ public:
{
const ShaderVariable &minLodVar = lane.GetSrc(operands.minLod);
uniformParams.minlod = minLodVar.value.f32v[0];
// silently cast parameters to 32-bit floats
if(minLodVar.type == VarType::Half)
uniformParams.minlod = ConvertFromHalf(minLodVar.value.u16v[0]);
else if(minLodVar.type == VarType::Double)
uniformParams.minlod = (float)minLodVar.value.f64v[0];
uniformParams.minlod = floatComp(minLodVar, 0);
}
if(useCompare)
{
uniformParams.compare = compare.value.f32v[0];
// silently cast parameters to 32-bit floats
if(compare.type == VarType::Half)
uniformParams.compare = ConvertFromHalf(compare.value.u16v[0]);
else if(compare.type == VarType::Double)
uniformParams.compare = (float)compare.value.f64v[0];
uniformParams.compare = floatComp(compare, 0);
}
if(operands.flags & rdcspv::ImageOperands::Lod)
{
const ShaderVariable &lodVar = lane.GetSrc(operands.lod);
uniformParams.lod = lodVar.value.f32v[0];
// silently cast parameters to 32-bit floats
if(lodVar.type == VarType::Half)
uniformParams.lod = ConvertFromHalf(lodVar.value.u16v[0]);
else if(lodVar.type == VarType::Double)
uniformParams.lod = (float)lodVar.value.f64v[0];
uniformParams.lod = floatComp(lodVar, 0);
constParams.useGradOrGatherOffsets = VK_FALSE;
}
else if(operands.flags & rdcspv::ImageOperands::Grad)
@@ -1186,29 +1140,10 @@ public:
// silently cast parameters to 32-bit floats
RDCASSERTEQUAL(ddx.type, ddy.type);
if(ddx.type == VarType::Float)
for(int i = 0; i < gradCoords; i++)
{
for(int i = 0; i < gradCoords; i++)
{
uniformParams.ddx[i] = ddx.value.f32v[i];
uniformParams.ddy[i] = ddy.value.f32v[i];
}
}
else if(ddx.type == VarType::Half)
{
for(int i = 0; i < gradCoords; i++)
{
uniformParams.ddx[i] = ConvertFromHalf(ddx.value.u16v[i]);
uniformParams.ddy[i] = ConvertFromHalf(ddy.value.u16v[i]);
}
}
else if(ddx.type == VarType::Double)
{
for(int i = 0; i < gradCoords; i++)
{
uniformParams.ddx[i] = (float)ddx.value.f64v[i];
uniformParams.ddy[i] = (float)ddy.value.f64v[i];
}
uniformParams.ddx[i] = floatComp(ddx, i);
uniformParams.ddy[i] = floatComp(ddy, i);
}
}
@@ -1220,29 +1155,10 @@ public:
// silently cast parameters to 32-bit floats
RDCASSERTEQUAL(ddxCalc.type, ddyCalc.type);
if(ddxCalc.type == VarType::Float)
for(int i = 0; i < gradCoords; i++)
{
for(int i = 0; i < gradCoords; i++)
{
uniformParams.ddx[i] = ddxCalc.value.f32v[i];
uniformParams.ddy[i] = ddyCalc.value.f32v[i];
}
}
else if(ddxCalc.type == VarType::Half)
{
for(int i = 0; i < gradCoords; i++)
{
uniformParams.ddx[i] = ConvertFromHalf(ddxCalc.value.u16v[i]);
uniformParams.ddy[i] = ConvertFromHalf(ddyCalc.value.u16v[i]);
}
}
else if(ddxCalc.type == VarType::Double)
{
for(int i = 0; i < gradCoords; i++)
{
uniformParams.ddx[i] = (float)ddxCalc.value.f64v[i];
uniformParams.ddy[i] = (float)ddyCalc.value.f64v[i];
}
uniformParams.ddx[i] = floatComp(ddxCalc, i);
uniformParams.ddy[i] = floatComp(ddyCalc, i);
}
}
@@ -1446,20 +1362,8 @@ public:
return false;
// convert float results, we did all sampling at 32-bit precision
if(output.type == VarType::Half)
{
for(uint8_t c = 0; c < 4; c++)
output.value.u16v[c] = ConvertToHalf(ret[c]);
}
else if(output.type == VarType::Double)
{
for(uint8_t c = 0; c < 4; c++)
output.value.f64v[c] = ret[c];
}
else
{
memcpy(output.value.u32v.data(), ret, sizeof(Vec4f));
}
for(uint8_t c = 0; c < 4; c++)
setFloatComp(output, c, ret[c]);
m_DebugData.ReadbackBuffer.Unmap();
renderdoc/replay/replay_driver.cpp
+12 -28
View File
@@ -373,7 +373,6 @@ void StandardFillCBufferVariable(ResourceId shader, const ShaderConstantDescript
const size_t avail = data.size() - dataOffset;
byte *dstData = outvar.value.u8v.data();
const size_t dstStride = elemByteSize == 8 ? 8 : 4;
// each secondaryDim element (row or column) is stored in a primaryDim-vector.
// We copy each vector member individually to account for smaller than uint32 sized types.
@@ -382,7 +381,7 @@ void StandardFillCBufferVariable(ResourceId shader, const ShaderConstantDescript
for(uint32_t p = 0; p < primaryDim; p++)
{
const size_t srcOffset = matStride * s + p * elemByteSize;
const size_t dstOffset = (primaryDim * s + p) * dstStride;
const size_t dstOffset = (primaryDim * s + p) * elemByteSize;
if(srcOffset + elemByteSize <= avail)
memcpy(dstData + dstOffset, srcData + srcOffset, elemByteSize);
@@ -400,40 +399,23 @@ void StandardFillCBufferVariable(ResourceId shader, const ShaderConstantDescript
for(size_t ci = 0; ci < cols; ci++)
outvar.value.u64v[ri * cols + ci] = tmp.value.u64v[ci * rows + ri];
}
else
else if(elemByteSize == 4)
{
for(size_t ri = 0; ri < rows; ri++)
for(size_t ci = 0; ci < cols; ci++)
outvar.value.u32v[ri * cols + ci] = tmp.value.u32v[ci * rows + ri];
}
}
// special case - decode halfs in-place, sign extend signed < 4 byte integers
if(type == VarType::Half)
{
for(size_t ri = 0; ri < rows; ri++)
else if(elemByteSize == 2)
{
for(size_t ci = 0; ci < cols; ci++)
{
outvar.value.f32v[ri * cols + ci] =
ConvertFromHalf((uint16_t)outvar.value.u32v[ri * cols + ci]);
}
for(size_t ri = 0; ri < rows; ri++)
for(size_t ci = 0; ci < cols; ci++)
outvar.value.u16v[ri * cols + ci] = tmp.value.u16v[ci * rows + ri];
}
}
else if(type == VarType::SShort || type == VarType::SByte)
{
const uint32_t testMask = (type == VarType::SShort ? 0x8000 : 0x80);
const uint32_t extendMask = (type == VarType::SShort ? 0xffff0000 : 0xffffff00);
for(size_t ri = 0; ri < rows; ri++)
else if(elemByteSize == 1)
{
for(size_t ci = 0; ci < cols; ci++)
{
uint32_t &u = outvar.value.u32v[ri * cols + ci];
if(u & testMask)
u |= extendMask;
}
for(size_t ri = 0; ri < rows; ri++)
for(size_t ci = 0; ci < cols; ci++)
outvar.value.u8v[ri * cols + ci] = tmp.value.u8v[ci * rows + ri];
}
}
}
@@ -483,6 +465,8 @@ static void StandardFillCBufferVariables(ResourceId shader, const rdcarray<Shade
StandardFillCBufferVariables(shader, invars[v].type.members, vr.members, data, dataOffset);
var.type = vr.type;
dataOffset += invars[v].type.descriptor.arrayByteStride;
vr.isStruct = true;
renderdoc/serialise/serialiser.cpp
+12
View File
@@ -960,6 +960,12 @@ rdcstr DoStringise(const byte &el)
return StringFormat::Fmt("%hhu", el);
}
template <>
rdcstr DoStringise(const int8_t &el)
{
return StringFormat::Fmt("%hhd", el);
}
template <>
rdcstr DoStringise(const uint16_t &el)
{
@@ -984,6 +990,12 @@ rdcstr DoStringise(const float &el)
return StringFormat::Fmt("%0.4f", el);
}
template <>
rdcstr DoStringise(const rdhalf &el)
{
return StringFormat::Fmt("%0.4f", (float)el);
}
template <>
rdcstr DoStringise(const double &el)
{
util/test/rdtest/testcase.py
+30 -6
View File
@@ -42,15 +42,39 @@ class ShaderVariableCheck:
def value(self, value_: list):
count = len(value_)
if isinstance(value_[0], float):
if list(self.var.value.f32v[0:count]) != list(value_):
vals = []
if self.var.type == rd.VarType.Float:
vals = list(self.var.value.f32v[0:count])
elif self.var.type == rd.VarType.Double:
vals = list(self.var.value.f64v[0:count])
elif self.var.type == rd.VarType.Half:
vals = list(self.var.value.f16v[0:count])
if vals != list(value_):
raise TestFailureException("Float variable {} value mismatch, expected {} but got {}"
.format(self.var.name, value_, self.var.value.f32v[0:count]))
else:
# hack - check signed and unsigned values
if list(self.var.value.s32v[0:count] ) != list(value_) and list(self.var.value.u32v[0:count]) != list(value_):
raise TestFailureException("Int variable {} value mismatch, expected {} but got {} / {}"
.format(self.var.name, value_, self.var.value.s32v[0:count],
self.var.value.u32v[0:count]))
vals = []
if self.var.type == rd.VarType.UInt or self.var.type == rd.VarType.Bool:
vals = list(self.var.value.u32v[0:count])
elif self.var.type == rd.VarType.ULong:
vals = list(self.var.value.u64v[0:count])
elif self.var.type == rd.VarType.UShort:
vals = list(self.var.value.u16v[0:count])
elif self.var.type == rd.VarType.UByte:
vals = list(self.var.value.u8v[0:count])
elif self.var.type == rd.VarType.SInt:
vals = list(self.var.value.s32v[0:count])
elif self.var.type == rd.VarType.SLong:
vals = list(self.var.value.s64v[0:count])
elif self.var.type == rd.VarType.SShort:
vals = list(self.var.value.s16v[0:count])
elif self.var.type == rd.VarType.SByte:
vals = list(self.var.value.s8v[0:count])
if vals != list(value_):
raise TestFailureException("Int variable {} value mismatch, expected {} but got {}"
.format(self.var.name, value_, vals))
return self