// launch the appropriate kind of viewer, depending on the type of resource that's in this node
private void textureCell_CellDoubleClick(TreelistView.Node node)
{
object tag = node.Tag;
GLPipelineState.ShaderStage stage = GetStageForSender(node.OwnerView);
if (stage == null)
{
return;
}
if (tag is FetchTexture)
{
FetchTexture tex = (FetchTexture)tag;
var viewer = m_Core.GetTextureViewer();
viewer.Show(m_DockContent.DockPanel);
if (!viewer.IsDisposed)
{
viewer.ViewTexture(tex.ID, true);
}
}
else if (tag is FetchBuffer)
{
}
}
private void cbuffers_NodeDoubleClicked(TreelistView.Node node)
{
GLPipelineState.ShaderStage stage = GetStageForSender(node.OwnerView);
if (stage != null && node.Tag is UInt32)
{
ShowCBuffer(stage, (UInt32)node.Tag);
}
}
private void CBuffers_CellDoubleClick(object sender, DataGridViewCellEventArgs e)
{
GLPipelineState.ShaderStage stage = GetStageForSender(sender);
object tag = ((DataGridView)sender).Rows[e.RowIndex].Tag;
if (stage != null && tag is UInt32)
{
ShowCBuffer(stage, (UInt32)tag);
}
}
private void ShowCBuffer(GLPipelineState.ShaderStage stage, UInt32 slot)
{
var existing = ConstantBufferPreviewer.Has(stage.stage, slot);
if (existing != null)
{
existing.Show();
return;
}
var prev = new ConstantBufferPreviewer(m_Core, stage.stage, slot);
prev.ShowDock(m_DockContent.Pane, DockAlignment.Right, 0.3);
}
private void shaderCog_MouseEnter(object sender, EventArgs e)
{
if (sender is PictureBox)
{
GLPipelineState.ShaderStage stage = GetStageForSender(sender);
if (stage != null && stage.Shader != ResourceId.Null)
{
(sender as PictureBox).Image = global::renderdocui.Properties.Resources.action_hover;
}
}
if (sender is Label)
{
GLPipelineState.ShaderStage stage = GetStageForSender(sender);
if (stage == null)
{
return;
}
if (stage.stage == ShaderStageType.Vertex)
{
shaderCog_MouseEnter(vsShaderCog, e);
}
if (stage.stage == ShaderStageType.Tess_Control)
{
shaderCog_MouseEnter(tcsShaderCog, e);
}
if (stage.stage == ShaderStageType.Tess_Eval)
{
shaderCog_MouseEnter(tesShaderCog, e);
}
if (stage.stage == ShaderStageType.Geometry)
{
shaderCog_MouseEnter(gsShaderCog, e);
}
if (stage.stage == ShaderStageType.Fragment)
{
shaderCog_MouseEnter(fsShaderCog, e);
}
if (stage.stage == ShaderStageType.Compute)
{
shaderCog_MouseEnter(csShaderCog, e);
}
}
}
// Set a shader stage's resources and values
private void SetShaderState(FetchTexture[] texs, FetchBuffer[] bufs,
GLPipelineState.ShaderStage stage,
Label shader, TreelistView.TreeListView resources, TreelistView.TreeListView samplers,
TreelistView.TreeListView cbuffers, TreelistView.TreeListView classes)
{
ShaderReflection shaderDetails = stage.ShaderDetails;
if (stage.Shader == ResourceId.Null)
{
shader.Text = "Unbound";
}
else
{
shader.Text = "Shader " + stage.Shader.ToString();
}
if (shaderDetails != null && shaderDetails.DebugInfo.entryFunc != "" && shaderDetails.DebugInfo.files.Length > 0)
{
shader.Text = shaderDetails.DebugInfo.entryFunc + "()" + " - " +
Path.GetFileName(shaderDetails.DebugInfo.files[0].filename);
}
cbuffers.BeginUpdate();
cbuffers.Nodes.Clear();
if (shaderDetails != null)
{
UInt32 i = 0;
foreach (var shaderCBuf in shaderDetails.ConstantBlocks)
{
{
string name = shaderCBuf.name;
int numvars = shaderCBuf.variables.Length;
string slotname = i.ToString();
var node = cbuffers.Nodes.Add(new object[] { slotname, name, "", "", numvars, "" });
node.Image = global::renderdocui.Properties.Resources.action;
node.HoverImage = global::renderdocui.Properties.Resources.action_hover;
node.Tag = i;
}
i++;
}
}
cbuffers.EndUpdate();
cbuffers.NodesSelection.Clear();
}
private void ShowCBuffer(GLPipelineState.ShaderStage stage, UInt32 slot)
{
var existing = ConstantBufferPreviewer.Has(stage.stage, slot);
if (existing != null)
{
existing.Show();
return;
}
var prev = new ConstantBufferPreviewer(m_Core, stage.stage, slot);
var dock = Helpers.WrapDockContent(m_DockContent.DockPanel, prev);
dock.DockState = DockState.DockRight;
dock.DockAreas |= DockAreas.Float;
ConstantBufferPreviewer.ShowDock(dock, m_DockContent.Pane, DockAlignment.Right, 0.3);
}
private void shader_Click(object sender, EventArgs e)
{
GLPipelineState.ShaderStage stage = GetStageForSender(sender);
if (stage == null)
{
return;
}
ShaderReflection shaderDetails = stage.ShaderDetails;
if (stage.Shader == ResourceId.Null)
{
return;
}
ShaderViewer s = new ShaderViewer(m_Core, shaderDetails, stage.stage, null, "");
s.Show(m_DockContent.DockPanel);
}
public void GetConstantBuffer(ShaderStageType stage, uint BufIdx, uint ArrayIdx, out ResourceId buf, out ulong ByteOffset, out ulong ByteSize)
{
if (LogLoaded)
{
if (IsLogD3D11)
{
D3D11PipelineState.ShaderStage s = null;
switch (stage)
{
case ShaderStageType.Vertex: s = m_D3D11.m_VS; break;
case ShaderStageType.Domain: s = m_D3D11.m_DS; break;
case ShaderStageType.Hull: s = m_D3D11.m_HS; break;
case ShaderStageType.Geometry: s = m_D3D11.m_GS; break;
case ShaderStageType.Pixel: s = m_D3D11.m_PS; break;
case ShaderStageType.Compute: s = m_D3D11.m_CS; break;
}
if (BufIdx < s.ConstantBuffers.Length)
{
buf = s.ConstantBuffers[BufIdx].Buffer;
ByteOffset = (ulong)(s.ConstantBuffers[BufIdx].VecOffset * 4 * sizeof(float));
ByteSize = (ulong)(s.ConstantBuffers[BufIdx].VecCount * 4 * sizeof(float));
return;
}
}
else if (IsLogGL)
{
GLPipelineState.ShaderStage s = null;
switch (stage)
{
case ShaderStageType.Vertex: s = m_GL.m_VS; break;
case ShaderStageType.Tess_Control: s = m_GL.m_TCS; break;
case ShaderStageType.Tess_Eval: s = m_GL.m_TES; break;
case ShaderStageType.Geometry: s = m_GL.m_GS; break;
case ShaderStageType.Fragment: s = m_GL.m_FS; break;
case ShaderStageType.Compute: s = m_GL.m_CS; break;
}
if (s.ShaderDetails != null && BufIdx < s.ShaderDetails.ConstantBlocks.Length)
{
if (s.ShaderDetails.ConstantBlocks[BufIdx].bindPoint >= 0)
{
int uboIdx = s.BindpointMapping.ConstantBlocks[s.ShaderDetails.ConstantBlocks[BufIdx].bindPoint].bind;
if (uboIdx >= 0 && uboIdx < m_GL.UniformBuffers.Length)
{
var b = m_GL.UniformBuffers[uboIdx];
buf = b.Resource;
ByteOffset = b.Offset;
ByteSize = b.Size;
return;
}
}
}
}
else if (IsLogVK)
{
VulkanPipelineState.Pipeline pipe = m_Vulkan.graphics;
if (stage == ShaderStageType.Compute)
{
pipe = m_Vulkan.compute;
}
VulkanPipelineState.ShaderStage s = null;
switch (stage)
{
case ShaderStageType.Vertex: s = m_Vulkan.VS; break;
case ShaderStageType.Tess_Control: s = m_Vulkan.TCS; break;
case ShaderStageType.Tess_Eval: s = m_Vulkan.TES; break;
case ShaderStageType.Geometry: s = m_Vulkan.GS; break;
case ShaderStageType.Fragment: s = m_Vulkan.FS; break;
case ShaderStageType.Compute: s = m_Vulkan.CS; break;
}
if (s.ShaderDetails != null && BufIdx < s.ShaderDetails.ConstantBlocks.Length)
{
var bind = s.BindpointMapping.ConstantBlocks[s.ShaderDetails.ConstantBlocks[BufIdx].bindPoint];
if (s.ShaderDetails.ConstantBlocks[BufIdx].bufferBacked == false)
{
// dummy values, it would be nice to fetch these properly
buf = ResourceId.Null;
ByteOffset = 0;
ByteSize = 1024;
return;
}
var descriptorBind = pipe.DescSets[bind.bindset].bindings[bind.bind].binds[ArrayIdx];
buf = descriptorBind.res;
ByteOffset = descriptorBind.offset;
ByteSize = descriptorBind.size;
return;
}
}
}
buf = ResourceId.Null;
ByteOffset = 0;
ByteSize = 0;
}
public void GetConstantBuffer(ShaderStageType stage, uint BufIdx, out ResourceId buf, out uint ByteOffset, out uint ByteSize)
{
if (LogLoaded)
{
if (IsLogD3D11)
{
D3D11PipelineState.ShaderStage s = null;
switch (stage)
{
case ShaderStageType.Vertex: s = m_D3D11.m_VS; break;
case ShaderStageType.Domain: s = m_D3D11.m_DS; break;
case ShaderStageType.Hull: s = m_D3D11.m_HS; break;
case ShaderStageType.Geometry: s = m_D3D11.m_GS; break;
case ShaderStageType.Pixel: s = m_D3D11.m_PS; break;
case ShaderStageType.Compute: s = m_D3D11.m_CS; break;
}
if (BufIdx < s.ConstantBuffers.Length)
{
buf = s.ConstantBuffers[BufIdx].Buffer;
ByteOffset = s.ConstantBuffers[BufIdx].VecOffset * 4 * sizeof(float);
ByteSize = s.ConstantBuffers[BufIdx].VecCount * 4 * sizeof(float);
return;
}
}
else if (IsLogGL)
{
GLPipelineState.ShaderStage s = null;
switch (stage)
{
case ShaderStageType.Vertex: s = m_GL.m_VS; break;
case ShaderStageType.Tess_Control: s = m_GL.m_TCS; break;
case ShaderStageType.Tess_Eval: s = m_GL.m_TES; break;
case ShaderStageType.Geometry: s = m_GL.m_GS; break;
case ShaderStageType.Fragment: s = m_GL.m_FS; break;
case ShaderStageType.Compute: s = m_GL.m_CS; break;
}
if (s.ShaderDetails != null && BufIdx < s.ShaderDetails.ConstantBlocks.Length)
{
if (s.ShaderDetails.ConstantBlocks[BufIdx].bindPoint >= 0)
{
int uboIdx = s.BindpointMapping.ConstantBlocks[s.ShaderDetails.ConstantBlocks[BufIdx].bindPoint].bind;
if (uboIdx >= 0 && uboIdx < m_GL.UniformBuffers.Length)
{
var b = m_GL.UniformBuffers[uboIdx];
buf = b.Resource;
ByteOffset = (uint)b.Offset;
ByteSize = (uint)b.Size;
return;
}
}
}
}
}
buf = ResourceId.Null;
ByteOffset = 0;
ByteSize = 0;
}
private GLPipelineState.ShaderStage GetStageForSender(object sender)
{
GLPipelineState.ShaderStage stage = null;
if (!m_Core.LogLoaded)
{
return(null);
}
object cur = sender;
while (cur is Control)
{
if (cur == tabVS)
{
stage = m_Core.CurGLPipelineState.m_VS;
}
else if (cur == tabGS)
{
stage = m_Core.CurGLPipelineState.m_GS;
}
else if (cur == tabTCS)
{
stage = m_Core.CurGLPipelineState.m_TCS;
}
else if (cur == tabTES)
{
stage = m_Core.CurGLPipelineState.m_TES;
}
else if (cur == tabFS)
{
stage = m_Core.CurGLPipelineState.m_FS;
}
else if (cur == tabCS)
{
stage = m_Core.CurGLPipelineState.m_CS;
}
else if (cur == tabFB)
{
stage = m_Core.CurGLPipelineState.m_FS;
}
if (stage != null)
{
return(stage);
}
Control c = (Control)cur;
if (c.Parent == null)
{
break;
}
cur = ((Control)cur).Parent;
}
System.Diagnostics.Debug.Fail("Unrecognised control calling event handler");
return(null);
}
// Set a shader stage's resources and values
private void SetShaderState(FetchTexture[] texs, FetchBuffer[] bufs,
GLPipelineState state, GLPipelineState.ShaderStage stage,
Label shader, TreelistView.TreeListView resources, TreelistView.TreeListView samplers,
TreelistView.TreeListView cbuffers, TreelistView.TreeListView classes)
{
ShaderReflection shaderDetails = stage.ShaderDetails;
if (stage.Shader == ResourceId.Null)
{
shader.Text = "Unbound";
}
else
{
shader.Text = "Shader " + stage.Shader.ToString();
}
if (shaderDetails != null && shaderDetails.DebugInfo.entryFunc != "" && shaderDetails.DebugInfo.files.Length > 0)
{
shader.Text = shaderDetails.DebugInfo.entryFunc + "()" + " - " +
Path.GetFileName(shaderDetails.DebugInfo.files[0].filename);
}
cbuffers.BeginUpdate();
cbuffers.Nodes.Clear();
if (shaderDetails != null)
{
UInt32 i = 0;
foreach (var shaderCBuf in shaderDetails.ConstantBlocks)
{
int bindPoint = stage.BindpointMapping.ConstantBlocks[i].bind;
bool filledSlot = !shaderCBuf.bufferBacked ||
(bindPoint >= 0 && bindPoint < state.UniformBuffers.Length && state.UniformBuffers[bindPoint].Resource != ResourceId.Null);
bool usedSlot = stage.BindpointMapping.ConstantBlocks[i].used;
// show if
if (usedSlot || // it's referenced by the shader - regardless of empty or not
(showDisabled.Checked && !usedSlot && filledSlot) || // it's bound, but not referenced, and we have "show disabled"
(showEmpty.Checked && !filledSlot) // it's empty, and we have "show empty"
)
{
string name = shaderCBuf.name;
int numvars = shaderCBuf.variables.Length;
string slotname = i.ToString();
var node = cbuffers.Nodes.Add(new object[] { slotname, name, bindPoint, "", numvars, "" });
node.Image = global::renderdocui.Properties.Resources.action;
node.HoverImage = global::renderdocui.Properties.Resources.action_hover;
node.Tag = i;
if (!filledSlot)
{
EmptyRow(node);
}
if (!usedSlot)
{
InactiveRow(node);
}
}
i++;
}
}
cbuffers.EndUpdate();
cbuffers.NodesSelection.Clear();
}
