mirror of
https://github.com/baldurk/renderdoc.git
synced 2026-05-04 17:10:47 +00:00
baldurk
1031 lines
29 KiB
C++
1031 lines
29 KiB
C++
/******************************************************************************
|
|
* The MIT License (MIT)
|
|
*
|
|
* Copyright (c) 2016-2018 Baldur Karlsson
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
* of this software and associated documentation files (the "Software"), to deal
|
|
* in the Software without restriction, including without limitation the rights
|
|
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
* copies of the Software, and to permit persons to whom the Software is
|
|
* furnished to do so, subject to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be included in
|
|
* all copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
|
* THE SOFTWARE.
|
|
******************************************************************************/
|
|
|
|
#include <QApplication>
|
|
#include <QRegularExpression>
|
|
#include <QtMath>
|
|
#include "QRDUtils.h"
|
|
|
|
static QVariant interpret(const ResourceFormat &f, uint16_t comp)
|
|
{
|
|
if(f.compByteWidth != 2 || f.compType == CompType::Float)
|
|
return QVariant();
|
|
|
|
if(f.compType == CompType::SInt)
|
|
{
|
|
return (int16_t)comp;
|
|
}
|
|
else if(f.compType == CompType::UInt)
|
|
{
|
|
return comp;
|
|
}
|
|
else if(f.compType == CompType::SScaled)
|
|
{
|
|
return (float)((int16_t)comp);
|
|
}
|
|
else if(f.compType == CompType::UScaled)
|
|
{
|
|
return (float)comp;
|
|
}
|
|
else if(f.compType == CompType::UNorm)
|
|
{
|
|
return (float)comp / (float)0xffff;
|
|
}
|
|
else if(f.compType == CompType::SNorm)
|
|
{
|
|
int16_t cast = (int16_t)comp;
|
|
|
|
float ret = -1.0f;
|
|
|
|
if(cast == -32768)
|
|
ret = -1.0f;
|
|
else
|
|
ret = ((float)cast) / 32767.0f;
|
|
|
|
return ret;
|
|
}
|
|
|
|
return QVariant();
|
|
}
|
|
|
|
static QVariant interpret(const ResourceFormat &f, byte comp)
|
|
{
|
|
if(f.compByteWidth != 1 || f.compType == CompType::Float)
|
|
return QVariant();
|
|
|
|
if(f.compType == CompType::SInt)
|
|
{
|
|
return (int8_t)comp;
|
|
}
|
|
else if(f.compType == CompType::UInt)
|
|
{
|
|
return comp;
|
|
}
|
|
else if(f.compType == CompType::SScaled)
|
|
{
|
|
return (float)((int8_t)comp);
|
|
}
|
|
else if(f.compType == CompType::UScaled)
|
|
{
|
|
return (float)comp;
|
|
}
|
|
else if(f.compType == CompType::UNorm)
|
|
{
|
|
return ((float)comp) / 255.0f;
|
|
}
|
|
else if(f.compType == CompType::SNorm)
|
|
{
|
|
int8_t cast = (int8_t)comp;
|
|
|
|
float ret = -1.0f;
|
|
|
|
if(cast == -128)
|
|
ret = -1.0f;
|
|
else
|
|
ret = ((float)cast) / 127.0f;
|
|
|
|
return ret;
|
|
}
|
|
|
|
return QVariant();
|
|
}
|
|
|
|
FormatElement::FormatElement()
|
|
{
|
|
buffer = 0;
|
|
offset = 0;
|
|
perinstance = false;
|
|
instancerate = 1;
|
|
rowmajor = false;
|
|
matrixdim = 0;
|
|
hex = false;
|
|
rgb = false;
|
|
systemValue = ShaderBuiltin::Undefined;
|
|
}
|
|
|
|
FormatElement::FormatElement(const QString &Name, int buf, uint offs, bool perInst, int instRate,
|
|
bool rowMat, uint matDim, ResourceFormat f, bool hexDisplay,
|
|
bool rgbDisplay)
|
|
{
|
|
name = Name;
|
|
buffer = buf;
|
|
offset = offs;
|
|
format = f;
|
|
perinstance = perInst;
|
|
instancerate = instRate;
|
|
rowmajor = rowMat;
|
|
matrixdim = matDim;
|
|
hex = hexDisplay;
|
|
rgb = rgbDisplay;
|
|
systemValue = ShaderBuiltin::Undefined;
|
|
}
|
|
|
|
QList<FormatElement> FormatElement::ParseFormatString(const QString &formatString, uint64_t maxLen,
|
|
bool tightPacking, QString &errors)
|
|
{
|
|
QList<FormatElement> elems;
|
|
|
|
// regex doesn't account for trailing or preceeding whitespace, or comments
|
|
|
|
QRegularExpression regExpr(
|
|
lit("^" // start of the line
|
|
"(row_major\\s+)?" // row_major matrix
|
|
"(rgb\\s+)?" // rgb element colourising
|
|
"(" // group the options for the type
|
|
"uintten|unormten" // R10G10B10A2 types
|
|
"|floateleven" // R11G11B10 special type
|
|
"|unormh|unormb" // UNORM 16-bit and 8-bit types
|
|
"|snormh|snormb" // SNORM 16-bit and 8-bit types
|
|
"|bool" // bool is stored as 4-byte int
|
|
"|byte|short|int" // signed ints
|
|
"|ubyte|ushort|uint" // unsigned ints
|
|
"|xbyte|xshort|xint" // hex ints
|
|
"|half|float|double" // float types
|
|
"|vec|uvec|ivec" // OpenGL vector types
|
|
"|mat|umat|imat" // OpenGL matrix types
|
|
")" // end of the type group
|
|
"([1-9])?" // might be a vector
|
|
"(x[1-9])?" // or a matrix
|
|
"(\\s+[A-Za-z_][A-Za-z0-9_]*)?" // get identifier name
|
|
"(\\[[0-9]+\\])?" // optional array dimension
|
|
"(\\s*:\\s*[A-Za-z_][A-Za-z0-9_]*)?" // optional semantic
|
|
"$"));
|
|
|
|
bool success = true;
|
|
errors = QString();
|
|
|
|
QString text = formatString;
|
|
|
|
text = text.replace(lit("{"), QString()).replace(lit("}"), QString());
|
|
|
|
QRegularExpression c_comments(lit("/\\*[^*]*\\*+(?:[^*/][^*]*\\*+)*/"));
|
|
QRegularExpression cpp_comments(lit("//.*"));
|
|
text = text.replace(c_comments, QString()).replace(cpp_comments, QString());
|
|
|
|
uint32_t offset = 0;
|
|
|
|
// get each line and parse it to determine the format the user wanted
|
|
for(QString &l : text.split(QLatin1Char(';')))
|
|
{
|
|
QString line = l.trimmed();
|
|
|
|
if(line.isEmpty())
|
|
continue;
|
|
|
|
QRegularExpressionMatch match = regExpr.match(line);
|
|
|
|
if(!match.hasMatch())
|
|
{
|
|
errors = tr("Couldn't parse line: %1\n").arg(line);
|
|
success = false;
|
|
break;
|
|
}
|
|
|
|
QString basetype = match.captured(3);
|
|
bool row_major = !match.captured(1).isEmpty();
|
|
bool rgb = !match.captured(2).isEmpty();
|
|
QString vectorDim = !match.captured(4).isEmpty() ? match.captured(4) : lit("1");
|
|
QString matrixDim = !match.captured(5).isEmpty() ? match.captured(5).mid(1) : lit("1");
|
|
QString name = !match.captured(6).isEmpty() ? match.captured(6).trimmed() : lit("data");
|
|
QString arrayDim = !match.captured(7).isEmpty() ? match.captured(7).trimmed() : lit("[1]");
|
|
arrayDim = arrayDim.mid(1, arrayDim.count() - 2);
|
|
|
|
if(!match.captured(5).isEmpty())
|
|
{
|
|
vectorDim.swap(matrixDim);
|
|
}
|
|
|
|
ResourceFormat fmt;
|
|
fmt.compType = CompType::Typeless;
|
|
|
|
bool hex = false;
|
|
|
|
CompType type = CompType::Float;
|
|
uint32_t count = 0;
|
|
uint32_t arrayCount = 1;
|
|
uint32_t matrixCount = 0;
|
|
uint32_t width = 0;
|
|
|
|
// check for square matrix declarations like 'mat4' and 'mat3'
|
|
if(basetype == lit("mat") && match.captured(5).isEmpty())
|
|
matrixDim = vectorDim;
|
|
|
|
// calculate format
|
|
{
|
|
bool ok = false;
|
|
|
|
count = vectorDim.toUInt(&ok);
|
|
if(!ok)
|
|
{
|
|
errors = tr("Invalid vector dimension on line: %1\n").arg(line);
|
|
success = false;
|
|
break;
|
|
}
|
|
|
|
arrayCount = arrayDim.toUInt(&ok);
|
|
if(!ok)
|
|
{
|
|
arrayCount = 1;
|
|
}
|
|
arrayCount = qMax(0U, arrayCount);
|
|
|
|
matrixCount = matrixDim.toUInt(&ok);
|
|
if(!ok)
|
|
{
|
|
errors = tr("Invalid matrix second dimension on line: %1\n").arg(line);
|
|
success = false;
|
|
break;
|
|
}
|
|
|
|
if(basetype == lit("bool"))
|
|
{
|
|
type = CompType::UInt;
|
|
width = 4;
|
|
}
|
|
else if(basetype == lit("byte"))
|
|
{
|
|
type = CompType::SInt;
|
|
width = 1;
|
|
}
|
|
else if(basetype == lit("ubyte") || basetype == lit("xbyte"))
|
|
{
|
|
type = CompType::UInt;
|
|
width = 1;
|
|
}
|
|
else if(basetype == lit("short"))
|
|
{
|
|
type = CompType::SInt;
|
|
width = 2;
|
|
}
|
|
else if(basetype == lit("ushort") || basetype == lit("xshort"))
|
|
{
|
|
type = CompType::UInt;
|
|
width = 2;
|
|
}
|
|
else if(basetype == lit("int") || basetype == lit("ivec") || basetype == lit("imat"))
|
|
{
|
|
type = CompType::SInt;
|
|
width = 4;
|
|
}
|
|
else if(basetype == lit("uint") || basetype == lit("xint") || basetype == lit("uvec") ||
|
|
basetype == lit("umat"))
|
|
{
|
|
type = CompType::UInt;
|
|
width = 4;
|
|
}
|
|
else if(basetype == lit("half"))
|
|
{
|
|
type = CompType::Float;
|
|
width = 2;
|
|
}
|
|
else if(basetype == lit("float") || basetype == lit("vec") || basetype == lit("mat"))
|
|
{
|
|
type = CompType::Float;
|
|
width = 4;
|
|
}
|
|
else if(basetype == lit("double"))
|
|
{
|
|
type = CompType::Double;
|
|
width = 8;
|
|
}
|
|
else if(basetype == lit("unormh"))
|
|
{
|
|
type = CompType::UNorm;
|
|
width = 2;
|
|
}
|
|
else if(basetype == lit("unormb"))
|
|
{
|
|
type = CompType::UNorm;
|
|
width = 1;
|
|
}
|
|
else if(basetype == lit("snormh"))
|
|
{
|
|
type = CompType::SNorm;
|
|
width = 2;
|
|
}
|
|
else if(basetype == lit("snormb"))
|
|
{
|
|
type = CompType::SNorm;
|
|
width = 1;
|
|
}
|
|
else if(basetype == lit("uintten"))
|
|
{
|
|
fmt.compType = CompType::UInt;
|
|
fmt.compCount = 4 * count;
|
|
fmt.compByteWidth = 1;
|
|
fmt.type = ResourceFormatType::R10G10B10A2;
|
|
}
|
|
else if(basetype == lit("unormten"))
|
|
{
|
|
fmt.compType = CompType::UInt;
|
|
fmt.compCount = 4 * count;
|
|
fmt.compByteWidth = 1;
|
|
fmt.type = ResourceFormatType::R10G10B10A2;
|
|
}
|
|
else if(basetype == lit("floateleven"))
|
|
{
|
|
fmt.compType = CompType::Float;
|
|
fmt.compCount = 3 * count;
|
|
fmt.compByteWidth = 1;
|
|
fmt.type = ResourceFormatType::R11G11B10;
|
|
}
|
|
else
|
|
{
|
|
errors = tr("Unrecognised basic type on line: %1\n").arg(line);
|
|
success = false;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if(basetype == lit("xint") || basetype == lit("xshort") || basetype == lit("xbyte"))
|
|
hex = true;
|
|
|
|
if(fmt.compType == CompType::Typeless)
|
|
{
|
|
fmt.compType = type;
|
|
fmt.compCount = count;
|
|
fmt.compByteWidth = width;
|
|
}
|
|
|
|
if(arrayCount == 1)
|
|
{
|
|
FormatElement elem(name, 0, offset, false, 1, row_major, matrixCount, fmt, hex, rgb);
|
|
|
|
uint32_t advance = elem.byteSize();
|
|
|
|
if(!tightPacking)
|
|
{
|
|
// cbuffer packing always works in floats
|
|
advance = (advance + 3U) & (~3U);
|
|
|
|
// cbuffer packing doesn't allow elements to cross float4 boundaries, nudge up if this was
|
|
// the case
|
|
if(offset / 16 != (offset + elem.byteSize() - 1) / 16)
|
|
{
|
|
elem.offset = offset = (offset + 0xFU) & (~0xFU);
|
|
}
|
|
}
|
|
|
|
elems.push_back(elem);
|
|
|
|
offset += advance;
|
|
}
|
|
else
|
|
{
|
|
// when cbuffer packing, arrays are always aligned at float4 boundary
|
|
if(!tightPacking)
|
|
{
|
|
if(offset % 16 != 0)
|
|
{
|
|
offset = (offset + 0xFU) & (~0xFU);
|
|
}
|
|
}
|
|
|
|
for(uint a = 0; a < arrayCount; a++)
|
|
{
|
|
FormatElement elem(QFormatStr("%1[%2]").arg(name).arg(a), 0, offset, false, 1, row_major,
|
|
matrixCount, fmt, hex, rgb);
|
|
|
|
elems.push_back(elem);
|
|
|
|
uint32_t advance = elem.byteSize();
|
|
|
|
// cbuffer packing each array element is always float4 aligned
|
|
if(!tightPacking)
|
|
{
|
|
advance = (advance + 0xFU) & (~0xFU);
|
|
}
|
|
|
|
offset += advance;
|
|
}
|
|
}
|
|
}
|
|
|
|
if(!success || elems.isEmpty())
|
|
{
|
|
elems.clear();
|
|
|
|
ResourceFormat fmt;
|
|
fmt.compType = CompType::UInt;
|
|
fmt.compByteWidth = 4;
|
|
fmt.compCount = 4;
|
|
|
|
if(maxLen > 0 && maxLen < 16)
|
|
fmt.compCount = 1;
|
|
if(maxLen > 0 && maxLen < 4)
|
|
fmt.compByteWidth = 1;
|
|
|
|
elems.push_back(FormatElement(lit("data"), 0, 0, false, 1, false, 1, fmt, true, false));
|
|
}
|
|
|
|
return elems;
|
|
}
|
|
|
|
QString FormatElement::GenerateTextureBufferFormat(const TextureDescription &tex)
|
|
{
|
|
QString baseType;
|
|
|
|
QString varName = lit("pixels");
|
|
|
|
uint32_t w = tex.width;
|
|
|
|
switch(tex.format.type)
|
|
{
|
|
case ResourceFormatType::BC1:
|
|
case ResourceFormatType::BC2:
|
|
case ResourceFormatType::BC3:
|
|
case ResourceFormatType::BC4:
|
|
case ResourceFormatType::BC5:
|
|
case ResourceFormatType::BC6:
|
|
case ResourceFormatType::BC7:
|
|
case ResourceFormatType::ETC2:
|
|
case ResourceFormatType::EAC:
|
|
case ResourceFormatType::ASTC:
|
|
case ResourceFormatType::PVRTC:
|
|
varName = lit("block");
|
|
// display a 4x4 block at a time
|
|
w /= 4;
|
|
default: break;
|
|
}
|
|
|
|
switch(tex.format.type)
|
|
{
|
|
case ResourceFormatType::Regular:
|
|
{
|
|
if(tex.format.compByteWidth == 1)
|
|
baseType = lit("byte");
|
|
else if(tex.format.compByteWidth == 2)
|
|
baseType = lit("short");
|
|
else
|
|
baseType = lit("int");
|
|
|
|
baseType = QFormatStr("rgb x%1%2").arg(baseType).arg(tex.format.compCount);
|
|
|
|
break;
|
|
}
|
|
// 2x4 byte block, for 64-bit block formats
|
|
case ResourceFormatType::BC1:
|
|
case ResourceFormatType::BC4:
|
|
case ResourceFormatType::ETC2:
|
|
case ResourceFormatType::EAC:
|
|
case ResourceFormatType::PVRTC:
|
|
baseType = lit("row_major xint2x1");
|
|
break;
|
|
// 4x4 byte block, for 128-bit block formats
|
|
case ResourceFormatType::BC2:
|
|
case ResourceFormatType::BC3:
|
|
case ResourceFormatType::BC5:
|
|
case ResourceFormatType::BC6:
|
|
case ResourceFormatType::BC7:
|
|
case ResourceFormatType::ASTC: baseType = lit("row_major xint4x1"); break;
|
|
case ResourceFormatType::R10G10B10A2: baseType = lit("uintten"); break;
|
|
case ResourceFormatType::R11G11B10: baseType = lit("rgb floateleven"); break;
|
|
case ResourceFormatType::R5G6B5:
|
|
case ResourceFormatType::R5G5B5A1: baseType = lit("xshort"); break;
|
|
case ResourceFormatType::R9G9B9E5: baseType = lit("xint"); break;
|
|
case ResourceFormatType::R4G4B4A4: baseType = lit("xbyte2"); break;
|
|
case ResourceFormatType::R4G4: baseType = lit("xbyte"); break;
|
|
case ResourceFormatType::D16S8:
|
|
case ResourceFormatType::D24S8:
|
|
case ResourceFormatType::D32S8:
|
|
case ResourceFormatType::YUV: baseType = lit("xint4"); break;
|
|
case ResourceFormatType::S8:
|
|
case ResourceFormatType::Undefined: baseType = lit("xbyte"); break;
|
|
}
|
|
|
|
if(tex.type == TextureType::Buffer)
|
|
return QFormatStr("%1 %2;").arg(baseType).arg(varName);
|
|
|
|
return QFormatStr("%1 %2[%3];").arg(baseType).arg(varName).arg(w);
|
|
}
|
|
|
|
template <typename T>
|
|
inline T readObj(const byte *&data, const byte *end, bool &ok)
|
|
{
|
|
if(data + sizeof(T) > end)
|
|
{
|
|
ok = false;
|
|
return T();
|
|
}
|
|
|
|
T ret = *(T *)data;
|
|
|
|
data += sizeof(T);
|
|
|
|
return ret;
|
|
}
|
|
|
|
QVariantList FormatElement::GetVariants(const byte *&data, const byte *end) const
|
|
{
|
|
QVariantList ret;
|
|
|
|
bool ok = true;
|
|
|
|
if(format.type == ResourceFormatType::R5G5B5A1)
|
|
{
|
|
uint16_t packed = readObj<uint16_t>(data, end, ok);
|
|
|
|
ret.push_back((float)((packed >> 0) & 0x1f) / 31.0f);
|
|
ret.push_back((float)((packed >> 5) & 0x1f) / 31.0f);
|
|
ret.push_back((float)((packed >> 10) & 0x1f) / 31.0f);
|
|
ret.push_back(((packed & 0x8000) > 0) ? 1.0f : 0.0f);
|
|
|
|
if(format.bgraOrder)
|
|
{
|
|
QVariant tmp = ret[2];
|
|
ret[2] = ret[0];
|
|
ret[0] = tmp;
|
|
}
|
|
}
|
|
else if(format.type == ResourceFormatType::R5G6B5)
|
|
{
|
|
uint16_t packed = readObj<uint16_t>(data, end, ok);
|
|
|
|
ret.push_back((float)((packed >> 0) & 0x1f) / 31.0f);
|
|
ret.push_back((float)((packed >> 5) & 0x3f) / 63.0f);
|
|
ret.push_back((float)((packed >> 11) & 0x1f) / 31.0f);
|
|
|
|
if(format.bgraOrder)
|
|
{
|
|
QVariant tmp = ret[2];
|
|
ret[2] = ret[0];
|
|
ret[0] = tmp;
|
|
}
|
|
}
|
|
else if(format.type == ResourceFormatType::R4G4B4A4)
|
|
{
|
|
uint16_t packed = readObj<uint16_t>(data, end, ok);
|
|
|
|
ret.push_back((float)((packed >> 0) & 0xf) / 15.0f);
|
|
ret.push_back((float)((packed >> 4) & 0xf) / 15.0f);
|
|
ret.push_back((float)((packed >> 8) & 0xf) / 15.0f);
|
|
ret.push_back((float)((packed >> 12) & 0xf) / 15.0f);
|
|
|
|
if(format.bgraOrder)
|
|
{
|
|
QVariant tmp = ret[2];
|
|
ret[2] = ret[0];
|
|
ret[0] = tmp;
|
|
}
|
|
}
|
|
else if(format.type == ResourceFormatType::R10G10B10A2)
|
|
{
|
|
// allow for vectors of this format - for raw buffer viewer
|
|
for(int i = 0; i < int(format.compCount / 4); i++)
|
|
{
|
|
uint32_t packed = readObj<uint32_t>(data, end, ok);
|
|
|
|
uint32_t r = (packed >> 0) & 0x3ff;
|
|
uint32_t g = (packed >> 10) & 0x3ff;
|
|
uint32_t b = (packed >> 20) & 0x3ff;
|
|
uint32_t a = (packed >> 30) & 0x003;
|
|
|
|
if(format.bgraOrder)
|
|
{
|
|
uint32_t tmp = b;
|
|
b = r;
|
|
r = tmp;
|
|
}
|
|
|
|
if(format.compType == CompType::UInt)
|
|
{
|
|
ret.push_back(r);
|
|
ret.push_back(g);
|
|
ret.push_back(b);
|
|
ret.push_back(a);
|
|
}
|
|
else if(format.compType == CompType::UScaled)
|
|
{
|
|
ret.push_back((float)r);
|
|
ret.push_back((float)g);
|
|
ret.push_back((float)b);
|
|
ret.push_back((float)a);
|
|
}
|
|
else if(format.compType == CompType::SInt || format.compType == CompType::SScaled ||
|
|
format.compType == CompType::SNorm)
|
|
{
|
|
int ir, ig, ib, ia;
|
|
|
|
// interpret RGB as 10-bit signed integers
|
|
if(r <= 511)
|
|
ir = (int)r;
|
|
else
|
|
ir = ((int)r) - 1024;
|
|
|
|
if(g <= 511)
|
|
ig = (int)g;
|
|
else
|
|
ig = ((int)g) - 1024;
|
|
|
|
if(b <= 511)
|
|
ib = (int)b;
|
|
else
|
|
ib = ((int)b) - 1024;
|
|
|
|
// 2-bit signed integer
|
|
if(a <= 1)
|
|
ia = (int)a;
|
|
else
|
|
ia = ((int)a) - 4;
|
|
|
|
if(format.compType == CompType::SInt)
|
|
{
|
|
ret.push_back(ir);
|
|
ret.push_back(ig);
|
|
ret.push_back(ib);
|
|
ret.push_back(ia);
|
|
}
|
|
else if(format.compType == CompType::SScaled)
|
|
{
|
|
ret.push_back((float)ir);
|
|
ret.push_back((float)ig);
|
|
ret.push_back((float)ib);
|
|
ret.push_back((float)ia);
|
|
}
|
|
else if(format.compType == CompType::SNorm)
|
|
{
|
|
if(ir == -512)
|
|
ir = -511;
|
|
if(ig == -512)
|
|
ig = -511;
|
|
if(ib == -512)
|
|
ib = -511;
|
|
if(ia == -2)
|
|
ia = -1;
|
|
|
|
ret.push_back((float)ir / 511.0f);
|
|
ret.push_back((float)ig / 511.0f);
|
|
ret.push_back((float)ib / 511.0f);
|
|
ret.push_back((float)ia / 1.0f);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ret.push_back((float)r / 1023.0f);
|
|
ret.push_back((float)g / 1023.0f);
|
|
ret.push_back((float)b / 1023.0f);
|
|
ret.push_back((float)a / 3.0f);
|
|
}
|
|
}
|
|
}
|
|
else if(format.type == ResourceFormatType::R11G11B10)
|
|
{
|
|
uint32_t packed = readObj<uint32_t>(data, end, ok);
|
|
|
|
uint32_t mantissas[] = {
|
|
(packed >> 0) & 0x3f, (packed >> 11) & 0x3f, (packed >> 22) & 0x1f,
|
|
};
|
|
int32_t exponents[] = {
|
|
int32_t(packed >> 6) & 0x1f, int32_t(packed >> 17) & 0x1f, int32_t(packed >> 27) & 0x1f,
|
|
};
|
|
static const uint32_t leadbit[] = {
|
|
0x40, 0x40, 0x20,
|
|
};
|
|
|
|
for(int i = 0; i < 3; i++)
|
|
{
|
|
if(mantissas[i] == 0 && exponents[i] == 0)
|
|
{
|
|
ret.push_back((float)0.0f);
|
|
}
|
|
else
|
|
{
|
|
if(exponents[i] == 0x1f)
|
|
{
|
|
// no sign bit, can't be negative infinity
|
|
if(mantissas[i] == 0)
|
|
ret.push_back((float)qInf());
|
|
else
|
|
ret.push_back((float)qQNaN());
|
|
}
|
|
else if(exponents[i] != 0)
|
|
{
|
|
// normal value, add leading bit
|
|
uint32_t combined = leadbit[i] | mantissas[i];
|
|
|
|
// calculate value
|
|
ret.push_back(((float)combined / (float)leadbit[i]) *
|
|
qPow(2.0f, (float)exponents[i] - 15.0f));
|
|
}
|
|
else if(exponents[i] == 0)
|
|
{
|
|
// we know xMantissa isn't 0 also, or it would have been caught above so
|
|
// this is a subnormal value, pretend exponent is 1 and don't add leading bit
|
|
|
|
ret.push_back(((float)mantissas[i] / (float)leadbit[i]) * qPow(2.0f, (float)1.0f - 15.0f));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
int dim = (int)(qMax(matrixdim, 1U) * format.compCount);
|
|
|
|
for(int i = 0; i < dim; i++)
|
|
{
|
|
if(format.compType == CompType::Float)
|
|
{
|
|
if(format.compByteWidth == 8)
|
|
ret.push_back(readObj<double>(data, end, ok));
|
|
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)));
|
|
}
|
|
else if(format.compType == CompType::SInt)
|
|
{
|
|
if(format.compByteWidth == 4)
|
|
ret.push_back((int)readObj<int32_t>(data, end, ok));
|
|
else if(format.compByteWidth == 2)
|
|
ret.push_back((int)readObj<int16_t>(data, end, ok));
|
|
else if(format.compByteWidth == 1)
|
|
ret.push_back((int)readObj<int8_t>(data, end, ok));
|
|
}
|
|
else if(format.compType == CompType::UInt)
|
|
{
|
|
if(format.compByteWidth == 4)
|
|
ret.push_back((uint32_t)readObj<uint32_t>(data, end, ok));
|
|
else if(format.compByteWidth == 2)
|
|
ret.push_back((uint32_t)readObj<uint16_t>(data, end, ok));
|
|
else if(format.compByteWidth == 1)
|
|
ret.push_back((uint32_t)readObj<uint8_t>(data, end, ok));
|
|
}
|
|
else if(format.compType == CompType::UScaled)
|
|
{
|
|
if(format.compByteWidth == 4)
|
|
ret.push_back((float)readObj<uint32_t>(data, end, ok));
|
|
else if(format.compByteWidth == 2)
|
|
ret.push_back((float)readObj<uint16_t>(data, end, ok));
|
|
else if(format.compByteWidth == 1)
|
|
ret.push_back((float)readObj<uint8_t>(data, end, ok));
|
|
}
|
|
else if(format.compType == CompType::SScaled)
|
|
{
|
|
if(format.compByteWidth == 4)
|
|
ret.push_back((float)readObj<int32_t>(data, end, ok));
|
|
else if(format.compByteWidth == 2)
|
|
ret.push_back((float)readObj<int16_t>(data, end, ok));
|
|
else if(format.compByteWidth == 1)
|
|
ret.push_back((float)readObj<int8_t>(data, end, ok));
|
|
}
|
|
else if(format.compType == CompType::Depth)
|
|
{
|
|
if(format.compByteWidth == 4)
|
|
{
|
|
// 32-bit depth is native floats
|
|
ret.push_back(readObj<float>(data, end, ok));
|
|
}
|
|
else if(format.compByteWidth == 3)
|
|
{
|
|
// 32-bit depth is normalised, masked against non-stencil bits
|
|
uint32_t f = readObj<uint32_t>(data, end, ok);
|
|
f &= 0x00ffffff;
|
|
ret.push_back((float)f / (float)0x00ffffff);
|
|
}
|
|
else if(format.compByteWidth == 2)
|
|
{
|
|
// 16-bit depth is normalised
|
|
float f = (float)readObj<uint16_t>(data, end, ok);
|
|
ret.push_back(f / (float)0x0000ffff);
|
|
}
|
|
}
|
|
else if(format.compType == CompType::Double)
|
|
{
|
|
ret.push_back(readObj<double>(data, end, ok));
|
|
}
|
|
else
|
|
{
|
|
// unorm/snorm
|
|
|
|
if(format.compByteWidth == 4)
|
|
{
|
|
// should never hit this - no 32bit unorm/snorm type
|
|
qCritical() << "Unexpected 4-byte unorm/snorm value";
|
|
ret.push_back((float)readObj<uint32_t>(data, end, ok) / (float)0xffffffff);
|
|
}
|
|
else if(format.compByteWidth == 2)
|
|
{
|
|
ret.push_back(interpret(format, readObj<uint16_t>(data, end, ok)));
|
|
}
|
|
else if(format.compByteWidth == 1)
|
|
{
|
|
ret.push_back(interpret(format, readObj<uint8_t>(data, end, ok)));
|
|
}
|
|
}
|
|
}
|
|
|
|
if(format.bgraOrder)
|
|
{
|
|
QVariant tmp = ret[2];
|
|
ret[2] = ret[0];
|
|
ret[0] = tmp;
|
|
}
|
|
}
|
|
|
|
// we read off the end, return empty set
|
|
if(!ok)
|
|
ret.clear();
|
|
|
|
return ret;
|
|
}
|
|
|
|
ShaderVariable FormatElement::GetShaderVar(const byte *&data, const byte *end) const
|
|
{
|
|
QVariantList objs = GetVariants(data, end);
|
|
|
|
ShaderVariable ret;
|
|
|
|
ret.name = name.toUtf8().data();
|
|
ret.type = VarType::Float;
|
|
if(format.compType == CompType::UInt)
|
|
ret.type = VarType::UInt;
|
|
if(format.compType == CompType::SInt)
|
|
ret.type = VarType::Int;
|
|
if(format.compType == CompType::Double)
|
|
ret.type = VarType::Double;
|
|
|
|
ret.columns = qMin(format.compCount, uint8_t(4));
|
|
ret.rows = qMin(matrixdim, 4U);
|
|
|
|
ret.displayAsHex = hex;
|
|
|
|
for(uint32_t row = 0; row < ret.rows; row++)
|
|
{
|
|
for(uint32_t col = 0; col < ret.columns; col++)
|
|
{
|
|
uint32_t dst = row * ret.columns + col;
|
|
uint32_t src = row * format.compCount + col;
|
|
|
|
// if we partially read a failure, reset the variable and return
|
|
if((int)src >= objs.size())
|
|
{
|
|
ret.name = "-";
|
|
memset(ret.value.dv, 0, sizeof(ret.value.dv));
|
|
return ret;
|
|
}
|
|
|
|
const QVariant &o = objs[src];
|
|
|
|
if(ret.type == VarType::Double)
|
|
ret.value.dv[dst] = o.toDouble();
|
|
else if(ret.type == VarType::UInt)
|
|
ret.value.uv[dst] = o.toUInt();
|
|
else if(ret.type == VarType::Int)
|
|
ret.value.iv[dst] = o.toInt();
|
|
else
|
|
ret.value.fv[dst] = o.toFloat();
|
|
}
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
uint32_t FormatElement::byteSize() const
|
|
{
|
|
uint32_t vecSize = format.compByteWidth * format.compCount;
|
|
|
|
if(format.type == ResourceFormatType::R5G5B5A1 || format.type == ResourceFormatType::R5G6B5 ||
|
|
format.type == ResourceFormatType::R4G4B4A4)
|
|
vecSize = 2;
|
|
|
|
if(format.type == ResourceFormatType::R10G10B10A2 || format.type == ResourceFormatType::R11G11B10)
|
|
vecSize = 4;
|
|
|
|
return vecSize * matrixdim;
|
|
}
|
|
|
|
QString TypeString(const ShaderVariable &v)
|
|
{
|
|
if(!v.members.isEmpty() || v.isStruct)
|
|
{
|
|
if(v.isStruct)
|
|
return lit("struct");
|
|
else
|
|
return QFormatStr("%1[%2]").arg(TypeString(v.members[0])).arg(v.members.count());
|
|
}
|
|
|
|
QString typeStr = ToQStr(v.type);
|
|
|
|
if(v.displayAsHex && v.type == VarType::UInt)
|
|
typeStr = lit("xint");
|
|
|
|
if(v.rows == 1 && v.columns == 1)
|
|
return typeStr;
|
|
if(v.rows == 1)
|
|
return QFormatStr("%1%2").arg(typeStr).arg(v.columns);
|
|
else
|
|
return QFormatStr("%1%2x%3 (%4)")
|
|
.arg(typeStr)
|
|
.arg(v.rows)
|
|
.arg(v.columns)
|
|
.arg(v.rowMajor ? QApplication::tr("row major", "FormatElement")
|
|
: QApplication::tr("column major", "FormatElement"));
|
|
}
|
|
|
|
template <typename el>
|
|
static QString RowValuesToString(int cols, el x, el y, el z, el w)
|
|
{
|
|
if(cols == 1)
|
|
return Formatter::Format(x);
|
|
else if(cols == 2)
|
|
return QFormatStr("%1, %2").arg(Formatter::Format(x)).arg(Formatter::Format(y));
|
|
else if(cols == 3)
|
|
return QFormatStr("%1, %2, %3")
|
|
.arg(Formatter::Format(x))
|
|
.arg(Formatter::Format(y))
|
|
.arg(Formatter::Format(z));
|
|
else
|
|
return QFormatStr("%1, %2, %3, %4")
|
|
.arg(Formatter::Format(x))
|
|
.arg(Formatter::Format(y))
|
|
.arg(Formatter::Format(z))
|
|
.arg(Formatter::Format(w));
|
|
}
|
|
|
|
QString RowString(const ShaderVariable &v, uint32_t row, VarType type)
|
|
{
|
|
if(type == VarType::Unknown)
|
|
type = v.type;
|
|
|
|
if(type == VarType::Double)
|
|
return RowValuesToString((int)v.columns, v.value.dv[row * v.columns + 0],
|
|
v.value.dv[row * v.columns + 1], v.value.dv[row * v.columns + 2],
|
|
v.value.dv[row * v.columns + 3]);
|
|
else if(type == VarType::Int)
|
|
return RowValuesToString((int)v.columns, v.value.iv[row * v.columns + 0],
|
|
v.value.iv[row * v.columns + 1], v.value.iv[row * v.columns + 2],
|
|
v.value.iv[row * v.columns + 3]);
|
|
else if(type == VarType::UInt)
|
|
return RowValuesToString((int)v.columns, v.value.uv[row * v.columns + 0],
|
|
v.value.uv[row * v.columns + 1], v.value.uv[row * v.columns + 2],
|
|
v.value.uv[row * v.columns + 3]);
|
|
else
|
|
return RowValuesToString((int)v.columns, v.value.fv[row * v.columns + 0],
|
|
v.value.fv[row * v.columns + 1], v.value.fv[row * v.columns + 2],
|
|
v.value.fv[row * v.columns + 3]);
|
|
}
|
|
|
|
QString VarString(const ShaderVariable &v)
|
|
{
|
|
if(!v.members.isEmpty())
|
|
return QString();
|
|
|
|
if(v.rows == 1)
|
|
return RowString(v, 0);
|
|
|
|
QString ret;
|
|
for(int i = 0; i < (int)v.rows; i++)
|
|
{
|
|
if(i > 0)
|
|
ret += lit("\n");
|
|
ret += lit("{") + RowString(v, i) + lit("}");
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
QString RowTypeString(const ShaderVariable &v)
|
|
{
|
|
if(!v.members.isEmpty() || v.isStruct)
|
|
{
|
|
if(v.isStruct)
|
|
return lit("struct");
|
|
else
|
|
return lit("flibbertygibbet");
|
|
}
|
|
|
|
if(v.rows == 0 && v.columns == 0)
|
|
return lit("-");
|
|
|
|
QString typeStr = ToQStr(v.type);
|
|
|
|
if(v.displayAsHex && v.type == VarType::UInt)
|
|
typeStr = lit("xint");
|
|
|
|
if(v.columns == 1)
|
|
return typeStr;
|
|
|
|
return QFormatStr("%1%2").arg(typeStr).arg(v.columns);
|
|
}
|