/******************************************************************************

* The MIT License (MIT)

*

* Copyright (c) 2016-2017 Baldur Karlsson

*

* Permission is hereby granted, free of charge, to any person obtaining a copy

* of this software and associated documentation files (the "Software"), to deal

* in the Software without restriction, including without limitation the rights

* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

* copies of the Software, and to permit persons to whom the Software is

* furnished to do so, subject to the following conditions:

*

* The above copyright notice and this permission notice shall be included in

* all copies or substantial portions of the Software.

*

* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

* THE SOFTWARE.

******************************************************************************/

#include "TextureViewer.h"

#include <float.h>

#include <math.h>

#include <QClipboard>

#include <QColorDialog>

#include <QFileSystemWatcher>

#include <QFontDatabase>

#include <QItemDelegate>

#include <QJsonDocument>

#include <QMenu>

#include <QPainter>

#include <QStyledItemDelegate>

#include "3rdparty/flowlayout/FlowLayout.h"

#include "3rdparty/toolwindowmanager/ToolWindowManagerArea.h"

#include "Code/CaptureContext.h"

#include "Code/QRDUtils.h"

#include "Dialogs/TextureSaveDialog.h"

#include "Widgets/ResourcePreview.h"

#include "Widgets/TextureGoto.h"

#include "BufferViewer.h"

#include "MainWindow.h"

#include "PixelHistoryView.h"

#include "ShaderViewer.h"

#include "ui_TextureViewer.h"

float area(const QSizeF &s)

{

return s.width() * s.height();

}

float aspect(const QSizeF &s)

{

return s.width() / s.height();

}

Q_DECLARE_METATYPE(Following);

Q_DECLARE_METATYPE(ResourceId);

const Following Following::Default = Following();

Following::Following(FollowType t, ShaderStageType s, int i, int a)

{

Type = t;

Stage = s;

index = i;

arrayEl = a;

}

Following::Following()

{

Type = FollowType::OutputColour;

Stage = eShaderStage_Pixel;

index = 0;

arrayEl = 0;

}

bool Following::operator!=(const Following &o)

{

return !(*this == o);

}

bool Following::operator==(const Following &o)

{

return Type == o.Type && Stage == o.Stage && index == o.index;

}

void Following::GetDrawContext(CaptureContext &ctx, bool &copy, bool &compute)

{

const FetchDrawcall *curDraw = ctx.CurDrawcall();

copy = curDraw != NULL && (curDraw->flags & (eDraw_Copy | eDraw_Resolve));

compute = curDraw != NULL && (curDraw->flags & eDraw_Dispatch) &&

ctx.CurPipelineState.GetShader(eShaderStage_Compute) != ResourceId();

}

int Following::GetHighestMip(CaptureContext &ctx)

{

return GetBoundResource(ctx, arrayEl).HighestMip;

}

int Following::GetFirstArraySlice(CaptureContext &ctx)

{

return GetBoundResource(ctx, arrayEl).FirstSlice;

}

FormatComponentType Following::GetTypeHint(CaptureContext &ctx)

{

return GetBoundResource(ctx, arrayEl).typeHint;

}

ResourceId Following::GetResourceId(CaptureContext &ctx)

{

return GetBoundResource(ctx, arrayEl).Id;

}

BoundResource Following::GetBoundResource(CaptureContext &ctx, int arrayIdx)

{

BoundResource ret;

if(Type == FollowType::OutputColour)

{

auto outputs = GetOutputTargets(ctx);

if(index < outputs.size())

ret = outputs[index];

}

else if(Type == FollowType::OutputDepth)

{

ret = GetDepthTarget(ctx);

}

else if(Type == FollowType::ReadWrite)

{

auto rw = GetReadWriteResources(ctx);

ShaderBindpointMapping mapping = GetMapping(ctx);

if(index < mapping.ReadWriteResources.count)

{

BindpointMap &key = mapping.ReadWriteResources[index];

if(rw.contains(key))

ret = rw[key][arrayIdx];

}

}

else if(Type == FollowType::ReadOnly)

{

auto ro = GetReadOnlyResources(ctx);

ShaderBindpointMapping mapping = GetMapping(ctx);

if(index < mapping.ReadOnlyResources.count)

{

BindpointMap &key = mapping.ReadOnlyResources[index];

if(ro.contains(key))

ret = ro[key][arrayIdx];

}

}

return ret;

}

QVector<BoundResource> Following::GetOutputTargets(CaptureContext &ctx)

{

const FetchDrawcall *curDraw = ctx.CurDrawcall();

bool copy = false, compute = false;

GetDrawContext(ctx, copy, compute);

if(copy)

{

return {BoundResource(curDraw->copyDestination)};

}

else if(compute)

{

return {};

}

else

{

QVector<BoundResource> ret = ctx.CurPipelineState.GetOutputTargets();

if(ret.isEmpty() && curDraw != NULL && (curDraw->flags & eDraw_Present))

{

if(curDraw->copyDestination != ResourceId())

return {BoundResource(curDraw->copyDestination)};

for(const FetchTexture &tex : ctx.GetTextures())

{

if(tex.creationFlags & eTextureCreate_SwapBuffer)

return {BoundResource(tex.ID)};

}

}

return ret;

}

}

BoundResource Following::GetDepthTarget(CaptureContext &ctx)

{

bool copy = false, compute = false;

GetDrawContext(ctx, copy, compute);

if(copy || compute)

return BoundResource(ResourceId());

else

return ctx.CurPipelineState.GetDepthTarget();

}

QMap<BindpointMap, QVector<BoundResource>> Following::GetReadWriteResources(CaptureContext &ctx,

ShaderStageType stage)

{

bool copy = false, compute = false;

GetDrawContext(ctx, copy, compute);

if(copy)

{

return QMap<BindpointMap, QVector<BoundResource>>();

}

else if(compute)

{

// only return compute resources for one stage

if(stage == eShaderStage_Pixel || stage == eShaderStage_Compute)

return ctx.CurPipelineState.GetReadWriteResources(eShaderStage_Compute);

else

return QMap<BindpointMap, QVector<BoundResource>>();

}

else

{

return ctx.CurPipelineState.GetReadWriteResources(stage);

}

}

QMap<BindpointMap, QVector<BoundResource>> Following::GetReadWriteResources(CaptureContext &ctx)

{

return GetReadWriteResources(ctx, Stage);

}

QMap<BindpointMap, QVector<BoundResource>> Following::GetReadOnlyResources(CaptureContext &ctx,

ShaderStageType stage)

{

const FetchDrawcall *curDraw = ctx.CurDrawcall();

bool copy = false, compute = false;

GetDrawContext(ctx, copy, compute);

if(copy)

{

QMap<BindpointMap, QVector<BoundResource>> ret;

// only return copy source for one stage

if(stage == eShaderStage_Pixel)

ret[BindpointMap(0, 0)] = {BoundResource(curDraw->copySource)};

return ret;

}

else if(compute)

{

// only return compute resources for one stage

if(stage == eShaderStage_Pixel || stage == eShaderStage_Compute)

return ctx.CurPipelineState.GetReadOnlyResources(eShaderStage_Compute);

else

return QMap<BindpointMap, QVector<BoundResource>>();

}

else

{

return ctx.CurPipelineState.GetReadOnlyResources(stage);

}

}

QMap<BindpointMap, QVector<BoundResource>> Following::GetReadOnlyResources(CaptureContext &ctx)

{

return GetReadOnlyResources(ctx, Stage);

}

const ShaderReflection *Following::GetReflection(CaptureContext &ctx, ShaderStageType stage)

{

bool copy = false, compute = false;

GetDrawContext(ctx, copy, compute);

if(copy)

return NULL;

else if(compute)

return ctx.CurPipelineState.GetShaderReflection(eShaderStage_Compute);

else

return ctx.CurPipelineState.GetShaderReflection(stage);

}

const ShaderReflection *Following::GetReflection(CaptureContext &ctx)

{

return GetReflection(ctx, Stage);

}

const ShaderBindpointMapping &Following::GetMapping(CaptureContext &ctx, ShaderStageType stage)

{

bool copy = false, compute = false;

GetDrawContext(ctx, copy, compute);

if(copy)

{

static ShaderBindpointMapping mapping;

// for PS only add a single mapping to get the copy source

if(stage == eShaderStage_Pixel)

mapping.ReadOnlyResources = {BindpointMap(0, 0)};

else

mapping.ReadOnlyResources.clear();

return mapping;

}

else if(compute)

{

return ctx.CurPipelineState.GetBindpointMapping(eShaderStage_Compute);

}

else

{

return ctx.CurPipelineState.GetBindpointMapping(stage);

}

}

const ShaderBindpointMapping &Following::GetMapping(CaptureContext &ctx)

{

return GetMapping(ctx, Stage);

}

class TextureListItemModel : public QAbstractItemModel

{

public:

enum FilterType

{

Textures,

RenderTargets,

String

};

TextureListItemModel(QObject *parent) : QAbstractItemModel(parent) {}

void reset(FilterType type, const QString &filter, CaptureContext &ctx)

{

const rdctype::array<FetchTexture> src = ctx.GetTextures();

texs.clear();

texs.reserve(src.count);

emit beginResetModel();

int rtFlags = eTextureCreate_RTV | eTextureCreate_DSV;

for(const FetchTexture &t : src)

{

if(type == Textures)

{

if((t.creationFlags & rtFlags) == 0)

texs.push_back(t);

}

else if(type == RenderTargets)

{

if((t.creationFlags & rtFlags))

texs.push_back(t);

}

else

{

if(filter.isEmpty())

texs.push_back(t);

else if(QString(t.name).contains(filter, Qt::CaseInsensitive))

texs.push_back(t);

}

}

emit endResetModel();

}

QModelIndex index(int row, int column, const QModelIndex &parent = QModelIndex()) const override

{

if(row < 0 || row >= rowCount())

return QModelIndex();

return createIndex(row, 0);

}

QModelIndex parent(const QModelIndex &index) const override { return QModelIndex(); }

int rowCount(const QModelIndex &parent = QModelIndex()) const override { return texs.count(); }

int columnCount(const QModelIndex &parent = QModelIndex()) const override { return 1; }

Qt::ItemFlags flags(const QModelIndex &index) const override

{

if(!index.isValid())

return 0;

return QAbstractItemModel::flags(index);

}

QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const override

{

if(index.isValid())

{

if(role == Qt::DisplayRole)

{

if(index.row() >= 0 && index.row() < texs.count())

return QVariant(texs[index.row()].name);

}

if(role == Qt::UserRole)

{

return QVariant::fromValue(texs[index.row()].ID);

}

if(role == Qt::DecorationRole)

{

QIcon goArrow;

goArrow.addFile(QStringLiteral(":/action.png"), QSize(), QIcon::Normal, QIcon::Off);

goArrow.addFile(QStringLiteral(":/action_hover.png"), QSize(), QIcon::Active, QIcon::Off);

return QVariant(goArrow);

}

}

return QVariant();

}

private:

QVector<FetchTexture> texs;

};

class TextureListItemDelegate : public QItemDelegate

{

public:

TextureListItemDelegate(QObject *parent = 0) : QItemDelegate(parent) {}

void paint(QPainter *painter, const QStyleOptionViewItem &opt, const QModelIndex &index) const override

{

if(index.isValid())

{

QStyleOptionViewItem option = opt;

option.decorationAlignment = Qt::AlignBaseline | Qt::AlignRight;

painter->eraseRect(option.rect);

QIcon icon = index.model()->data(index, Qt::DecorationRole).value<QIcon>();

drawBackground(painter, option, index);

if(option.state & QStyle::State_MouseOver)

drawDecoration(painter, option, option.rect,

icon.pixmap(option.decorationSize, QIcon::Active));

else

drawDecoration(painter, option, option.rect,

icon.pixmap(option.decorationSize, QIcon::Normal));

drawDisplay(painter, option, option.rect,

index.model()->data(index, Qt::DisplayRole).toString());

drawFocus(painter, option, option.rect);

if(option.state & QStyle::State_MouseOver)

{

QRect r = option.rect;

r.adjust(0, 0, -1, -1);

painter->drawRect(r);

}

}

}

};

FetchTexture *TextureViewer::GetCurrentTexture()

{

return m_CachedTexture;

}

void TextureViewer::UI_UpdateCachedTexture()

{

if(!m_Ctx.LogLoaded())

{

m_CachedTexture = NULL;

return;

}

ResourceId id = m_LockedId;

if(id == ResourceId())

id = m_Following.GetResourceId(m_Ctx);

if(id == ResourceId())

id = m_TexDisplay.texid;

m_CachedTexture = m_Ctx.GetTexture(id);

}

TextureViewer::TextureViewer(CaptureContext &ctx, QWidget *parent)

: QFrame(parent), ui(new Ui::TextureViewer), m_Ctx(ctx)

{

ui->setupUi(this);

m_Ctx.AddLogViewer(this);

Reset();

on_checkerBack_clicked();

QObject::connect(ui->zoomOption->lineEdit(), &QLineEdit::returnPressed, this,

&TextureViewer::zoomOption_returnPressed);

QObject::connect(ui->depthDisplay, &QToolButton::toggled, this,

&TextureViewer::channelsWidget_toggled);

QObject::connect(ui->stencilDisplay, &QToolButton::toggled, this,

&TextureViewer::channelsWidget_toggled);

QObject::connect(ui->flip_y, &QToolButton::toggled, this, &TextureViewer::channelsWidget_toggled);

QObject::connect(ui->channelRed, &QToolButton::toggled, this,

&TextureViewer::channelsWidget_toggled);

QObject::connect(ui->channelGreen, &QToolButton::toggled, this,

&TextureViewer::channelsWidget_toggled);

QObject::connect(ui->channelBlue, &QToolButton::toggled, this,

&TextureViewer::channelsWidget_toggled);

QObject::connect(ui->channelAlpha, &QToolButton::toggled, this,

&TextureViewer::channelsWidget_toggled);

QObject::connect(ui->gammaDisplay, &QToolButton::toggled, this,

&TextureViewer::channelsWidget_toggled);

QObject::connect(ui->channels, OverloadedSlot<int>::of(&QComboBox::currentIndexChanged), this,

&TextureViewer::channelsWidget_selected);

QObject::connect(ui->hdrMul, OverloadedSlot<int>::of(&QComboBox::currentIndexChanged), this,

&TextureViewer::channelsWidget_selected);

QObject::connect(ui->customShader, OverloadedSlot<int>::of(&QComboBox::currentIndexChanged), this,

&TextureViewer::channelsWidget_selected);

QObject::connect(ui->customShader, &QComboBox::currentTextChanged, [this] { UI_UpdateChannels(); });

QObject::connect(ui->rangeHistogram, &RangeHistogram::rangeUpdated, this,

&TextureViewer::range_rangeUpdated);

QObject::connect(ui->rangeBlack, &RDLineEdit::textChanged, this,

&TextureViewer::rangePoint_textChanged);

QObject::connect(ui->rangeBlack, &RDLineEdit::leave, this, &TextureViewer::rangePoint_leave);

QObject::connect(ui->rangeBlack, &RDLineEdit::keyPress, this, &TextureViewer::rangePoint_keyPress);

QObject::connect(ui->rangeWhite, &RDLineEdit::textChanged, this,

&TextureViewer::rangePoint_textChanged);

QObject::connect(ui->rangeWhite, &RDLineEdit::leave, this, &TextureViewer::rangePoint_leave);

QObject::connect(ui->rangeWhite, &RDLineEdit::keyPress, this, &TextureViewer::rangePoint_keyPress);

QWidget *renderContainer = ui->renderContainer;

ui->dockarea->addToolWindow(ui->renderContainer, ToolWindowManager::EmptySpace);

ui->dockarea->setToolWindowProperties(renderContainer, ToolWindowManager::DisallowUserDocking |

ToolWindowManager::HideCloseButton |

ToolWindowManager::DisableDraggableTab);

ui->dockarea->addToolWindow(ui->inputThumbs, ToolWindowManager::AreaReference(

ToolWindowManager::RightOf,

ui->dockarea->areaOf(renderContainer), 0.25f));

ui->dockarea->setToolWindowProperties(ui->inputThumbs, ToolWindowManager::HideCloseButton);

ui->dockarea->addToolWindow(

ui->outputThumbs, ToolWindowManager::AreaReference(ToolWindowManager::AddTo,

ui->dockarea->areaOf(ui->inputThumbs)));

ui->dockarea->setToolWindowProperties(ui->outputThumbs, ToolWindowManager::HideCloseButton);

ui->dockarea->addToolWindow(

ui->pixelContextLayout,

ToolWindowManager::AreaReference(ToolWindowManager::BottomOf,

ui->dockarea->areaOf(ui->outputThumbs), 0.25f));

ui->dockarea->setToolWindowProperties(ui->pixelContextLayout, ToolWindowManager::HideCloseButton);

ui->dockarea->addToolWindow(ui->textureListFrame, ToolWindowManager::NoArea);

ui->dockarea->setToolWindowProperties(ui->textureListFrame, ToolWindowManager::HideOnClose);

ui->dockarea->setAllowFloatingWindow(false);

ui->dockarea->setRubberBandLineWidth(50);

renderContainer->setWindowTitle(tr("Unbound"));

ui->pixelContextLayout->setWindowTitle(tr("Pixel Context"));

ui->outputThumbs->setWindowTitle(tr("Outputs"));

ui->inputThumbs->setWindowTitle(tr("Inputs"));

ui->textureListFrame->setWindowTitle(tr("Texture List"));

ui->textureList->setHoverCursor(Qt::PointingHandCursor);

m_Goto = new TextureGoto(this, [this](QPoint p) { GotoLocation(p.x(), p.y()); });

QVBoxLayout *vertical = new QVBoxLayout(this);

vertical->setSpacing(3);

vertical->setContentsMargins(0, 0, 0, 0);

QWidget *flow1widget = new QWidget(this);

QWidget *flow2widget = new QWidget(this);

FlowLayout *flow1 = new FlowLayout(flow1widget, 0, 3, 3);

FlowLayout *flow2 = new FlowLayout(flow2widget, 0, 3, 3);

flow1widget->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Minimum);

flow2widget->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Minimum);

flow1->addWidget(ui->channelsToolbar);

flow1->addWidget(ui->subresourceToolbar);

flow1->addWidget(ui->actionToolbar);

flow2->addWidget(ui->zoomToolbar);

flow2->addWidget(ui->overlayToolbar);

flow2->addWidget(ui->rangeToolbar);

vertical->addWidget(flow1widget);

vertical->addWidget(flow2widget);

vertical->addWidget(ui->dockarea);

Ui_TextureViewer *u = ui;

u->pixelcontextgrid->setAlignment(u->pixelHistory, Qt::AlignCenter);

u->pixelcontextgrid->setAlignment(u->debugPixelContext, Qt::AlignCenter);

QWidget *statusflowWidget = new QWidget(this);

FlowLayout *statusflow = new FlowLayout(statusflowWidget, 0, 3, 0);

statusflowWidget->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Minimum);

ui->statusbar->removeWidget(ui->texStatusDim);

ui->statusbar->removeWidget(ui->pickSwatch);

ui->statusbar->removeWidget(ui->statusText);

statusflow->addWidget(ui->texStatusDim);

statusflow->addWidget(ui->pickSwatch);

statusflow->addWidget(ui->statusText);

ui->texStatusDim->setFont(QFontDatabase::systemFont(QFontDatabase::FixedFont));

ui->statusText->setFont(QFontDatabase::systemFont(QFontDatabase::FixedFont));

ui->statusbar->addWidget(statusflowWidget);

ui->channels->addItems({tr("RGBA"), tr("RGBM"), tr("Custom")});

ui->zoomOption->addItems({"10%", "25%", "50%", "75%", "100%", "200%", "400%", "800%"});

ui->hdrMul->addItems({"2", "4", "8", "16", "32", "128"});

ui->overlay->addItems({tr("None"), tr("Highlight Drawcall"), tr("Wireframe Mesh"),

tr("Depth Test"), tr("Stencil Test"), tr("Backface Cull"),

tr("Viewport/Scissor Region"), tr("NaN/INF/-ve Display"), tr("Clipping"),

tr("Clear Before Pass"), tr("Clear Before Draw"),

tr("Quad Overdraw (Pass)"), tr("Quad Overdraw (Draw)"),

tr("Triangle Size (Pass)"), tr("Triangle Size (Draw)")});

ui->textureListFilter->addItems({"", "Textures", "Render Targets"});

ui->textureList->setModel(new TextureListItemModel(this));

ui->textureList->setItemDelegate(new TextureListItemDelegate(ui->textureList));

ui->textureList->viewport()->setAttribute(Qt::WA_Hover);

ui->zoomOption->setCurrentText("");

ui->fitToWindow->toggle();

SetupTextureTabs();

}

TextureViewer::~TextureViewer()

{

m_Ctx.windowClosed(this);

m_Ctx.RemoveLogViewer(this);

delete ui;

}

void TextureViewer::RT_FetchCurrentPixel(uint32_t x, uint32_t y, PixelValue &pickValue,

PixelValue &realValue)

{

FetchTexture *texptr = GetCurrentTexture();

if(texptr == NULL)

return;

if(m_TexDisplay.FlipY)

y = (texptr->height - 1) - y;

m_Output->PickPixel(m_TexDisplay.texid, true, x, y, m_TexDisplay.sliceFace, m_TexDisplay.mip,

m_TexDisplay.sampleIdx, &pickValue);

if(m_TexDisplay.CustomShader != ResourceId())

m_Output->PickPixel(m_TexDisplay.texid, false, x, y, m_TexDisplay.sliceFace, m_TexDisplay.mip,

m_TexDisplay.sampleIdx, &realValue);

}

void TextureViewer::RT_PickPixelsAndUpdate(IReplayRenderer *)

{

PixelValue pickValue, realValue;

uint32_t x = (uint32_t)m_PickedPoint.x();

uint32_t y = (uint32_t)m_PickedPoint.y();

RT_FetchCurrentPixel(x, y, pickValue, realValue);

m_Output->SetPixelContextLocation(x, y);

m_CurHoverValue = pickValue;

m_CurPixelValue = pickValue;

m_CurRealValue = realValue;

GUIInvoke::call([this]() { UI_UpdateStatusText(); });

}

void TextureViewer::RT_PickHoverAndUpdate(IReplayRenderer *)

{

PixelValue pickValue, realValue;

uint32_t x = (uint32_t)m_CurHoverPixel.x();

uint32_t y = (uint32_t)m_CurHoverPixel.y();

RT_FetchCurrentPixel(x, y, pickValue, realValue);

m_CurHoverValue = pickValue;

GUIInvoke::call([this]() { UI_UpdateStatusText(); });

}

void TextureViewer::RT_UpdateAndDisplay(IReplayRenderer *)

{

if(m_Output != NULL)

m_Output->SetTextureDisplay(m_TexDisplay);

GUIInvoke::call([this]() { ui->render->update(); });

}

void TextureViewer::RT_UpdateVisualRange(IReplayRenderer *)

{

FetchTexture *texptr = GetCurrentTexture();

if(!m_Visualise || texptr == NULL || m_Output == NULL)

return;

ResourceFormat fmt = texptr->format;

if(m_TexDisplay.CustomShader != ResourceId())

fmt.compCount = 4;

bool success = true;

bool channels[] = {

m_TexDisplay.Red ? true : false, m_TexDisplay.Green && fmt.compCount > 1,

m_TexDisplay.Blue && fmt.compCount > 2, m_TexDisplay.Alpha && fmt.compCount > 3,

};

rdctype::array<uint32_t> histogram;

success = m_Output->GetHistogram(ui->rangeHistogram->rangeMin(), ui->rangeHistogram->rangeMax(),

channels, &histogram);

if(success)

{

QVector<uint32_t> histogramVec(histogram.count);

if(histogram.count > 0)

memcpy(histogramVec.data(), histogram.elems, histogram.count * sizeof(uint32_t));

GUIInvoke::call([this, histogramVec]() {

ui->rangeHistogram->setHistogramRange(ui->rangeHistogram->rangeMin(),

ui->rangeHistogram->rangeMax());

ui->rangeHistogram->setHistogramData(histogramVec);

});

}

}

void TextureViewer::UI_UpdateStatusText()

{

FetchTexture *texptr = GetCurrentTexture();

if(texptr == NULL)

return;

FetchTexture &tex = *texptr;

bool dsv =

((tex.creationFlags & eTextureCreate_DSV) != 0) || (tex.format.compType == eCompType_Depth);

bool uintTex = (tex.format.compType == eCompType_UInt);

bool sintTex = (tex.format.compType == eCompType_SInt);

if(m_TexDisplay.overlay == eTexOverlay_QuadOverdrawPass ||

m_TexDisplay.overlay == eTexOverlay_QuadOverdrawDraw)

{

dsv = false;

uintTex = false;

sintTex = true;

}

QColor swatchColor;

if(dsv || uintTex || sintTex)

{

swatchColor = QColor(0, 0, 0);

}

else

{

float r = qBound(0.0f, m_CurHoverValue.value_f[0], 1.0f);

float g = qBound(0.0f, m_CurHoverValue.value_f[1], 1.0f);

float b = qBound(0.0f, m_CurHoverValue.value_f[2], 1.0f);

if(tex.format.srgbCorrected || (tex.creationFlags & eTextureCreate_SwapBuffer) > 0)

{

r = powf(r, 1.0f / 2.2f);

g = powf(g, 1.0f / 2.2f);

b = powf(b, 1.0f / 2.2f);

}

swatchColor = QColor(int(255.0f * r), int(255.0f * g), int(255.0f * b));

}

{

QPalette Pal(palette());

Pal.setColor(QPalette::Background, swatchColor);

ui->pickSwatch->setAutoFillBackground(true);

ui->pickSwatch->setPalette(Pal);

}

int y = m_CurHoverPixel.y() >> (int)m_TexDisplay.mip;

uint32_t mipWidth = qMax(1U, tex.width >> (int)m_TexDisplay.mip);

uint32_t mipHeight = qMax(1U, tex.height >> (int)m_TexDisplay.mip);

if(m_Ctx.APIProps().pipelineType == eGraphicsAPI_OpenGL)

y = (int)(mipHeight - 1) - y;

if(m_TexDisplay.FlipY)

y = (int)(mipHeight - 1) - y;

y = qMax(0, y);

int x = m_CurHoverPixel.x() >> (int)m_TexDisplay.mip;

float invWidth = mipWidth > 0 ? 1.0f / mipWidth : 0.0f;

float invHeight = mipHeight > 0 ? 1.0f / mipHeight : 0.0f;

QString hoverCoords = QString("%1, %2 (%3, %4)")

.arg(x, 4)

.arg(y, 4)

.arg((x * invWidth), 5, 'f', 4)

.arg((y * invHeight), 5, 'f', 4);

QString statusText = tr("Hover - ") + hoverCoords;

uint32_t hoverX = (uint32_t)m_CurHoverPixel.x();

uint32_t hoverY = (uint32_t)m_CurHoverPixel.y();

if(hoverX > tex.width || hoverY > tex.height)

statusText = tr("Hover - ") + "[" + hoverCoords + "]";

if(m_PickedPoint.x() >= 0)

{

x = m_PickedPoint.x() >> (int)m_TexDisplay.mip;

y = m_PickedPoint.y() >> (int)m_TexDisplay.mip;

if(m_Ctx.APIProps().pipelineType == eGraphicsAPI_OpenGL)

y = (int)(mipHeight - 1) - y;

if(m_TexDisplay.FlipY)

y = (int)(mipHeight - 1) - y;

y = qMax(0, y);

statusText += tr(" - Right click - ") + QString("%1, %2: ").arg(x, 4).arg(y, 4);

PixelValue val = m_CurPixelValue;

if(m_TexDisplay.CustomShader != ResourceId())

{

statusText += Formatter::Format(val.value_f[0]) + ", " + Formatter::Format(val.value_f[1]) +

", " + Formatter::Format(val.value_f[2]) + ", " +

Formatter::Format(val.value_f[3]);

val = m_CurRealValue;

statusText += tr(" (Real: ");

}

if(dsv)

{

statusText += tr("Depth ");

if(uintTex)

{

if(tex.format.compByteWidth == 2)

statusText += Formatter::Format(val.value_u16[0]);

else

statusText += Formatter::Format(val.value_u[0]);

}

else

{

statusText += Formatter::Format(val.value_f[0]);

}

int stencil = (int)(255.0f * val.value_f[1]);

statusText += tr(", Stencil %1 / 0x%2").arg(stencil).arg(stencil, 0, 16);

}

else

{

if(uintTex)

{

statusText += Formatter::Format(val.value_u[0]) + ", " + Formatter::Format(val.value_u[1]) +

", " + Formatter::Format(val.value_u[2]) + ", " +

Formatter::Format(val.value_u[3]);

}

else if(sintTex)

{

statusText += Formatter::Format(val.value_i[0]) + ", " + Formatter::Format(val.value_i[1]) +

", " + Formatter::Format(val.value_i[2]) + ", " +

Formatter::Format(val.value_i[3]);

}

else

{

statusText += Formatter::Format(val.value_f[0]) + ", " + Formatter::Format(val.value_f[1]) +

", " + Formatter::Format(val.value_f[2]) + ", " +

Formatter::Format(val.value_f[3]);

}

}

if(m_TexDisplay.CustomShader != ResourceId())

statusText += ")";

// PixelPicked = true;

}

else

{

statusText += tr(" - Right click to pick a pixel");

if(m_Output != NULL)

{

m_Ctx.Renderer().AsyncInvoke([this](IReplayRenderer *) { m_Output->DisablePixelContext(); });

}

// PixelPicked = false;

}

// try and keep status text consistent by sticking to the high water mark

// of length (prevents nasty oscillation when the length of the string is

// just popping over/under enough to overflow onto the next line).

if(statusText.length() > m_HighWaterStatusLength)

m_HighWaterStatusLength = statusText.length();

if(statusText.length() < m_HighWaterStatusLength)

statusText += QString(m_HighWaterStatusLength - statusText.length(), ' ');

ui->statusText->setText(statusText);

}

void TextureViewer::UI_UpdateTextureDetails()

{

QString status;

FetchTexture *texptr = GetCurrentTexture();

if(texptr == NULL)

{

ui->texStatusDim->setText(status);

ui->renderContainer->setWindowTitle(tr("Unbound"));

return;

}

FetchTexture &current = *texptr;

ResourceId followID = m_Following.GetResourceId(m_Ctx);

{

FetchTexture *followtex = m_Ctx.GetTexture(followID);

FetchBuffer *followbuf = m_Ctx.GetBuffer(followID);

QString title;

if(followID == ResourceId())

{

title = tr("Unbound");

}

else if(followtex || followbuf)

{

QString name;

if(followtex)

name = followtex->name;

else

name = followbuf->name;

switch(m_Following.Type)

{

case FollowType::OutputColour:

title = QString(tr("Cur Output %1 - %2")).arg(m_Following.index).arg(name);

break;

case FollowType::OutputDepth: title = QString(tr("Cur Depth Output - %1")).arg(name); break;

case FollowType::ReadWrite:

title = QString(tr("Cur RW Output %1 - %2")).arg(m_Following.index).arg(name);

break;

case FollowType::ReadOnly:

title = QString(tr("Cur Input %1 - %2")).arg(m_Following.index).arg(name);

break;

}

}

else

{

switch(m_Following.Type)

{

case FollowType::OutputColour:

title = QString(tr("Cur Output %1")).arg(m_Following.index);

break;

case FollowType::OutputDepth: title = QString(tr("Cur Depth Output")); break;

case FollowType::ReadWrite:

title = QString(tr("Cur RW Output %1")).arg(m_Following.index);

break;

case FollowType::ReadOnly:

title = QString(tr("Cur Input %1")).arg(m_Following.index);

break;

}

}

ui->renderContainer->setWindowTitle(title);

}

status = QString(current.name) + " - ";

if(current.dimension >= 1)

status += QString::number(current.width);

if(current.dimension >= 2)

status += "x" + QString::number(current.height);

if(current.dimension >= 3)