public ConstantBufferPreviewer(Core c, ShaderStageType stage, UInt32 slot, UInt32 idx)
{
InitializeComponent();
if (SystemInformation.HighContrast)
{
toolStrip1.Renderer = new ToolStripSystemRenderer();
}
m_Core = c;
Stage = stage;
Slot = slot;
ArrayIdx = idx;
shader = m_Core.CurPipelineState.GetShader(stage);
entryPoint = m_Core.CurPipelineState.GetShaderEntryPoint(stage);
UpdateLabels();
ulong offs = 0;
ulong size = 0;
m_Core.CurPipelineState.GetConstantBuffer(Stage, Slot, ArrayIdx, out cbuffer, out offs, out size);
m_Core.Renderer.BeginInvoke((ReplayRenderer r) =>
{
SetVariables(r.GetCBufferVariableContents(shader, entryPoint, Slot, cbuffer, offs));
});
m_Core.AddLogViewer(this);
}
public ConstantBufferPreviewer(Core c, ShaderStageType stage, UInt32 slot, UInt32 idx)
{
InitializeComponent();
if (SystemInformation.HighContrast)
toolStrip1.Renderer = new ToolStripSystemRenderer();
m_Core = c;
Stage = stage;
Slot = slot;
ArrayIdx = idx;
shader = m_Core.CurPipelineState.GetShader(stage);
entryPoint = m_Core.CurPipelineState.GetShaderEntryPoint(stage);
UpdateLabels();
ulong offs = 0;
ulong size = 0;
m_Core.CurPipelineState.GetConstantBuffer(Stage, Slot, ArrayIdx, out cbuffer, out offs, out size);
m_Core.Renderer.BeginInvoke((ReplayRenderer r) =>
{
SetVariables(r.GetCBufferVariableContents(shader, entryPoint, Slot, cbuffer, offs));
});
m_Core.AddLogViewer(this);
}
public ShaderBindpointMapping GetBindpointMapping(ShaderStageType stage)
{
if (LogLoaded)
{
if (IsLogD3D11)
{
switch (stage)
{
case ShaderStageType.Vertex: return(m_D3D11.m_VS.BindpointMapping);
case ShaderStageType.Domain: return(m_D3D11.m_DS.BindpointMapping);
case ShaderStageType.Hull: return(m_D3D11.m_HS.BindpointMapping);
case ShaderStageType.Geometry: return(m_D3D11.m_GS.BindpointMapping);
case ShaderStageType.Pixel: return(m_D3D11.m_PS.BindpointMapping);
case ShaderStageType.Compute: return(m_D3D11.m_CS.BindpointMapping);
}
}
else if (IsLogGL)
{
switch (stage)
{
case ShaderStageType.Vertex: return(m_GL.m_VS.BindpointMapping);
case ShaderStageType.Tess_Control: return(m_GL.m_TCS.BindpointMapping);
case ShaderStageType.Tess_Eval: return(m_GL.m_TES.BindpointMapping);
case ShaderStageType.Geometry: return(m_GL.m_GS.BindpointMapping);
case ShaderStageType.Fragment: return(m_GL.m_FS.BindpointMapping);
case ShaderStageType.Compute: return(m_GL.m_CS.BindpointMapping);
}
}
else if (IsLogVK)
{
switch (stage)
{
case ShaderStageType.Vertex: return(m_Vulkan.VS.BindpointMapping);
case ShaderStageType.Tess_Control: return(m_Vulkan.TCS.BindpointMapping);
case ShaderStageType.Tess_Eval: return(m_Vulkan.TES.BindpointMapping);
case ShaderStageType.Geometry: return(m_Vulkan.GS.BindpointMapping);
case ShaderStageType.Fragment: return(m_Vulkan.FS.BindpointMapping);
case ShaderStageType.Compute: return(m_Vulkan.CS.BindpointMapping);
}
}
}
return(null);
}
public ResourceId GetShader(ShaderStageType stage)
{
if (LogLoaded)
{
if (IsLogD3D11)
{
switch (stage)
{
case ShaderStageType.Vertex: return(m_D3D11.m_VS.Shader);
case ShaderStageType.Domain: return(m_D3D11.m_DS.Shader);
case ShaderStageType.Hull: return(m_D3D11.m_HS.Shader);
case ShaderStageType.Geometry: return(m_D3D11.m_GS.Shader);
case ShaderStageType.Pixel: return(m_D3D11.m_PS.Shader);
case ShaderStageType.Compute: return(m_D3D11.m_CS.Shader);
}
}
else if (IsLogGL)
{
switch (stage)
{
case ShaderStageType.Vertex: return(m_GL.m_VS.Shader);
case ShaderStageType.Tess_Control: return(m_GL.m_TCS.Shader);
case ShaderStageType.Tess_Eval: return(m_GL.m_TES.Shader);
case ShaderStageType.Geometry: return(m_GL.m_GS.Shader);
case ShaderStageType.Fragment: return(m_GL.m_FS.Shader);
case ShaderStageType.Compute: return(m_GL.m_CS.Shader);
}
}
else if (IsLogVK)
{
switch (stage)
{
case ShaderStageType.Vertex: return(m_Vulkan.VS.Shader);
case ShaderStageType.Tess_Control: return(m_Vulkan.TCS.Shader);
case ShaderStageType.Tess_Eval: return(m_Vulkan.TES.Shader);
case ShaderStageType.Geometry: return(m_Vulkan.GS.Shader);
case ShaderStageType.Fragment: return(m_Vulkan.FS.Shader);
case ShaderStageType.Compute: return(m_Vulkan.CS.Shader);
}
}
}
return(ResourceId.Null);
}
public string GetShaderName(ShaderStageType stage)
{
if (LogLoaded)
{
if (IsLogD3D11)
{
switch (stage)
{
case ShaderStageType.Vertex: return(m_D3D11.m_VS.ShaderName);
case ShaderStageType.Domain: return(m_D3D11.m_DS.ShaderName);
case ShaderStageType.Hull: return(m_D3D11.m_HS.ShaderName);
case ShaderStageType.Geometry: return(m_D3D11.m_GS.ShaderName);
case ShaderStageType.Pixel: return(m_D3D11.m_PS.ShaderName);
case ShaderStageType.Compute: return(m_D3D11.m_CS.ShaderName);
}
}
else if (IsLogGL)
{
switch (stage)
{
case ShaderStageType.Vertex: return(String.Format("Shader {0}", m_GL.m_VS.Shader));
case ShaderStageType.Tess_Control: return(String.Format("Shader {0}", m_GL.m_TCS.Shader));
case ShaderStageType.Tess_Eval: return(String.Format("Shader {0}", m_GL.m_TES.Shader));
case ShaderStageType.Geometry: return(String.Format("Shader {0}", m_GL.m_GS.Shader));
case ShaderStageType.Fragment: return(String.Format("Shader {0}", m_GL.m_FS.Shader));
case ShaderStageType.Compute: return(String.Format("Shader {0}", m_GL.m_CS.Shader));
}
}
else if (IsLogVK)
{
switch (stage)
{
case ShaderStageType.Vertex: return(m_Vulkan.VS.ShaderName);
case ShaderStageType.Domain: return(m_Vulkan.TCS.ShaderName);
case ShaderStageType.Hull: return(m_Vulkan.TES.ShaderName);
case ShaderStageType.Geometry: return(m_Vulkan.GS.ShaderName);
case ShaderStageType.Pixel: return(m_Vulkan.FS.ShaderName);
case ShaderStageType.Compute: return(m_Vulkan.CS.ShaderName);
}
}
}
return("");
}
public static DockContent Has(ShaderStageType stage, UInt32 slot)
{
foreach (var cb in m_Docks)
{
if(cb.Stage == stage && cb.Slot == slot)
return cb as DockContent;
}
return null;
}
public static DockContent Has(ShaderStageType stage, UInt32 slot, UInt32 idx)
{
foreach (var cb in m_Docks)
{
if (cb.Stage == stage && cb.Slot == slot && cb.ArrayIdx == idx)
{
return(cb as DockContent);
}
}
return(null);
}
public static DockContent Has(ShaderStageType stage, UInt32 slot)
{
foreach (var d in m_Docks)
{
ConstantBufferPreviewer cb = d.Controls[0] as ConstantBufferPreviewer;
if (cb.Stage == stage && cb.Slot == slot)
{
return(cb.Parent as DockContent);
}
}
return(null);
}
public ConstantBufferPreviewer(Core c, ShaderStageType stage, UInt32 slot, UInt32 idx)
{
InitializeComponent();
if (SystemInformation.HighContrast)
toolStrip1.Renderer = new ToolStripSystemRenderer();
m_Core = c;
Stage = stage;
Slot = slot;
ArrayIdx = idx;
shader = m_Core.CurPipelineState.GetShader(stage);
entryPoint = m_Core.CurPipelineState.GetShaderEntryPoint(stage);
UpdateLabels();
}
public ConstantBufferPreviewer(Core c, ShaderStageType stage, UInt32 slot, UInt32 idx)
{
InitializeComponent();
if (SystemInformation.HighContrast)
{
toolStrip1.Renderer = new ToolStripSystemRenderer();
}
m_Core = c;
Stage = stage;
Slot = slot;
ArrayIdx = idx;
shader = m_Core.CurPipelineState.GetShader(stage);
entryPoint = m_Core.CurPipelineState.GetShaderEntryPoint(stage);
UpdateLabels();
}
public ResourceId[] GetResources(ShaderStageType stage)
{
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;
}
ResourceId[] ret = new ResourceId[s.SRVs.Length];
for (int i = 0; i < s.SRVs.Length; i++)
{
ret[i] = s.SRVs[i].Resource;
}
return(ret);
}
else if (IsLogGL)
{
ResourceId[] ret = new ResourceId[m_GL.Textures.Length];
for (int i = 0; i < m_GL.Textures.Length; i++)
{
ret[i] = m_GL.Textures[i].Resource;
}
return(ret);
}
}
return(null);
}
public ShaderReflection GetShaderReflection(ShaderStageType stage)
{
if (LogLoaded)
{
if (IsLogD3D11)
{
switch (stage)
{
case ShaderStageType.Vertex: return(m_D3D11.m_VS.ShaderDetails);
case ShaderStageType.Domain: return(m_D3D11.m_DS.ShaderDetails);
case ShaderStageType.Hull: return(m_D3D11.m_HS.ShaderDetails);
case ShaderStageType.Geometry: return(m_D3D11.m_GS.ShaderDetails);
case ShaderStageType.Pixel: return(m_D3D11.m_PS.ShaderDetails);
case ShaderStageType.Compute: return(m_D3D11.m_CS.ShaderDetails);
}
}
else if (IsLogGL)
{
switch (stage)
{
case ShaderStageType.Vertex: return(m_GL.m_VS.ShaderDetails);
case ShaderStageType.Tess_Control: return(m_GL.m_TCS.ShaderDetails);
case ShaderStageType.Tess_Eval: return(m_GL.m_TES.ShaderDetails);
case ShaderStageType.Geometry: return(m_GL.m_GS.ShaderDetails);
case ShaderStageType.Fragment: return(m_GL.m_FS.ShaderDetails);
case ShaderStageType.Compute: return(m_GL.m_CS.ShaderDetails);
}
}
}
return(null);
}
public ConstantBufferPreviewer(Core c, ShaderStageType stage, UInt32 slot)
{
InitializeComponent();
m_Core = c;
Stage = stage;
Slot = slot;
shader = m_Core.CurPipelineState.GetShader(stage);
UpdateLabels();
uint offs = 0;
m_Core.CurPipelineState.GetConstantBuffer(Stage, Slot, out cbuffer, out offs);
m_Core.Renderer.BeginInvoke((ReplayRenderer r) =>
{
SetVariables(r.GetCBufferVariableContents(shader, Slot, cbuffer, offs));
});
m_Core.AddLogViewer(this);
}
public ResourceId[] GetReadWriteResources(ShaderStageType stage)
{
if (LogLoaded)
{
if (IsLogD3D11)
{
if (stage == ShaderStageType.Compute)
{
ResourceId[] ret = new ResourceId[m_D3D11.m_CS.UAVs.Length];
for (int i = 0; i < m_D3D11.m_CS.UAVs.Length; i++)
{
ret[i] = m_D3D11.m_CS.UAVs[i].Resource;
}
return(ret);
}
else
{
ResourceId[] ret = new ResourceId[m_D3D11.m_OM.UAVs.Length];
for (int i = 0; i < m_D3D11.m_OM.UAVs.Length; i++)
{
ret[i] = m_D3D11.m_OM.UAVs[i].Resource;
}
return(ret);
}
}
else if (IsLogGL)
{
ResourceId[] ret = new ResourceId[m_GL.Images.Length];
for (int i = 0; i < m_GL.Images.Length; i++)
{
ret[i] = m_GL.Images[i].Resource;
}
return(ret);
}
}
return(new ResourceId[0]);
}
public ConstantBufferPreviewer(Core c, ShaderStageType stage, UInt32 slot)
{
InitializeComponent();
m_Core = c;
Stage = stage;
Slot = slot;
shader = m_Core.CurPipelineState.GetShader(stage);
UpdateLabels();
uint offs = 0;
m_Core.CurPipelineState.GetConstantBuffer(Stage, Slot, out cbuffer, out offs);
m_Core.Renderer.BeginInvoke((ReplayRenderer r) =>
{
SetVariables(r.GetCBufferVariableContents(shader, Slot, cbuffer, offs));
});
m_Core.AddLogViewer(this);
}
public string Abbrev(ShaderStageType stage)
{
if (IsLogD3D11 || (!LogLoaded && DefaultType == APIPipelineStateType.D3D11))
{
switch (stage)
{
case ShaderStageType.Vertex: return("VS");
case ShaderStageType.Hull: return("HS");
case ShaderStageType.Domain: return("DS");
case ShaderStageType.Geometry: return("GS");
case ShaderStageType.Pixel: return("PS");
case ShaderStageType.Compute: return("CS");
}
}
else if (IsLogGL || (!LogLoaded && DefaultType == APIPipelineStateType.OpenGL) ||
IsLogVK || (!LogLoaded && DefaultType == APIPipelineStateType.Vulkan))
{
switch (stage)
{
case ShaderStageType.Vertex: return("VS");
case ShaderStageType.Tess_Control: return("TCS");
case ShaderStageType.Tess_Eval: return("TES");
case ShaderStageType.Geometry: return("GS");
case ShaderStageType.Fragment: return("FS");
case ShaderStageType.Compute: return("CS");
}
}
return("?S");
}
public void GetConstantBuffer(ShaderStageType stage, uint BindPoint, out ResourceId buf, out uint ByteOffset)
{
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;
}
buf = s.ConstantBuffers[BindPoint].Buffer;
ByteOffset = s.ConstantBuffers[BindPoint].VecOffset * 4 * sizeof(float);
return;
}
else if (IsLogGL)
{
buf = ResourceId.Null;
ByteOffset = 0;
return;
}
}
buf = ResourceId.Null;
ByteOffset = 0;
}
public static string Str(this ShaderStageType stage, GraphicsAPI apitype)
{
if (apitype.IsD3D())
{
switch (stage)
{
case ShaderStageType.Vertex: return("Vertex");
case ShaderStageType.Hull: return("Hull");
case ShaderStageType.Domain: return("Domain");
case ShaderStageType.Geometry: return("Geometry");
case ShaderStageType.Pixel: return("Pixel");
case ShaderStageType.Compute: return("Compute");
}
}
else if (apitype == GraphicsAPI.OpenGL || apitype == GraphicsAPI.Vulkan)
{
switch (stage)
{
case ShaderStageType.Vertex: return("Vertex");
case ShaderStageType.Tess_Control: return("Tess. Control");
case ShaderStageType.Tess_Eval: return("Tess. Eval");
case ShaderStageType.Geometry: return("Geometry");
case ShaderStageType.Fragment: return("Fragment");
case ShaderStageType.Compute: return("Compute");
}
}
return(stage.ToString());
}
public String GetShaderEntryPoint(ShaderStageType stage)
{
if (LogLoaded && IsLogVK)
{
switch (stage)
{
case ShaderStageType.Vertex: return(m_Vulkan.VS.entryPoint);
case ShaderStageType.Tess_Control: return(m_Vulkan.TCS.entryPoint);
case ShaderStageType.Tess_Eval: return(m_Vulkan.TES.entryPoint);
case ShaderStageType.Geometry: return(m_Vulkan.GS.entryPoint);
case ShaderStageType.Fragment: return(m_Vulkan.FS.entryPoint);
case ShaderStageType.Compute: return(m_Vulkan.CS.entryPoint);
}
}
return("");
}
public static string Str(this ShaderStageType stage, APIPipelineStateType apitype)
{
if (apitype == APIPipelineStateType.D3D11)
{
switch (stage)
{
case ShaderStageType.Vertex: return("Vertex");
case ShaderStageType.Hull: return("Hull");
case ShaderStageType.Domain: return("Domain");
case ShaderStageType.Geometry: return("Geometry");
case ShaderStageType.Pixel: return("Pixel");
case ShaderStageType.Compute: return("Compute");
}
}
else if (apitype == APIPipelineStateType.OpenGL)
{
switch (stage)
{
case ShaderStageType.Vertex: return("Vertex");
case ShaderStageType.Tess_Control: return("Tess. Control");
case ShaderStageType.Tess_Eval: return("Tess. Eval");
case ShaderStageType.Geometry: return("Geometry");
case ShaderStageType.Fragment: return("Fragment");
case ShaderStageType.Compute: return("Compute");
}
}
return(stage.ToString());
}
public static string Abbrev(this ShaderStageType stage, APIPipelineStateType apitype)
{
if (apitype == APIPipelineStateType.D3D11)
{
switch (stage)
{
case ShaderStageType.Vertex: return("VS");
case ShaderStageType.Hull: return("HS");
case ShaderStageType.Domain: return("DS");
case ShaderStageType.Geometry: return("GS");
case ShaderStageType.Pixel: return("PS");
case ShaderStageType.Compute: return("CS");
}
}
else if (apitype == APIPipelineStateType.OpenGL)
{
switch (stage)
{
case ShaderStageType.Vertex: return("VS");
case ShaderStageType.Tess_Control: return("TCS");
case ShaderStageType.Tess_Eval: return("TES");
case ShaderStageType.Geometry: return("GS");
case ShaderStageType.Fragment: return("FS");
case ShaderStageType.Compute: return("CS");
}
}
return("?S");
}
public static ShaderReflection GetReflection(Core core, ShaderStageType stage)
{
var curDraw = core.CurDrawcall;
bool copy, compute;
GetDrawContext(core, out copy, out compute);
if (copy)
return null;
else if (compute)
return core.CurPipelineState.GetShaderReflection(ShaderStageType.Compute);
else
return core.CurPipelineState.GetShaderReflection(stage);
}
public static Dictionary<BindpointMap, BoundResource[]> GetReadOnlyResources(Core core, ShaderStageType stage)
{
var curDraw = core.CurDrawcall;
bool copy, compute;
GetDrawContext(core, out copy, out compute);
if (copy)
{
var ret = new Dictionary<BindpointMap, BoundResource[]>();
// only return copy source for one stage
if(stage == ShaderStageType.Pixel)
ret.Add(new BindpointMap(0, 0), new BoundResource[] { new BoundResource(curDraw.copySource) });
return ret;
}
else if (compute)
{
// only return compute resources for one stage
if (stage == ShaderStageType.Pixel || stage == ShaderStageType.Compute)
return core.CurPipelineState.GetReadOnlyResources(ShaderStageType.Compute);
else
return new Dictionary<BindpointMap, BoundResource[]>();
}
else
{
return core.CurPipelineState.GetReadOnlyResources(stage);
}
}
public Following(FollowType t, ShaderStageType s, int i, int a)
{
Type = t; Stage = s; index = i; arrayEl = a;
}
public string GetShaderName(ShaderStageType stage)
{
if (LogLoaded)
{
if (IsLogD3D11)
{
switch (stage)
{
case ShaderStageType.Vertex: return m_D3D11.m_VS.ShaderName;
case ShaderStageType.Domain: return m_D3D11.m_DS.ShaderName;
case ShaderStageType.Hull: return m_D3D11.m_HS.ShaderName;
case ShaderStageType.Geometry: return m_D3D11.m_GS.ShaderName;
case ShaderStageType.Pixel: return m_D3D11.m_PS.ShaderName;
case ShaderStageType.Compute: return m_D3D11.m_CS.ShaderName;
}
}
else if (IsLogGL)
{
switch (stage)
{
case ShaderStageType.Vertex: return String.Format("Shader {0}", m_GL.m_VS.Shader);
case ShaderStageType.Tess_Control: return String.Format("Shader {0}", m_GL.m_TCS.Shader);
case ShaderStageType.Tess_Eval: return String.Format("Shader {0}", m_GL.m_TES.Shader);
case ShaderStageType.Geometry: return String.Format("Shader {0}", m_GL.m_GS.Shader);
case ShaderStageType.Fragment: return String.Format("Shader {0}", m_GL.m_FS.Shader);
case ShaderStageType.Compute: return String.Format("Shader {0}", m_GL.m_CS.Shader);
}
}
}
return "";
}
public string GetShaderName(ShaderStageType stage)
{
if (LogLoaded)
{
if (IsLogD3D11)
{
switch (stage)
{
case ShaderStageType.Vertex: return m_D3D11.m_VS.ShaderName;
case ShaderStageType.Domain: return m_D3D11.m_DS.ShaderName;
case ShaderStageType.Hull: return m_D3D11.m_HS.ShaderName;
case ShaderStageType.Geometry: return m_D3D11.m_GS.ShaderName;
case ShaderStageType.Pixel: return m_D3D11.m_PS.ShaderName;
case ShaderStageType.Compute: return m_D3D11.m_CS.ShaderName;
}
}
else if (IsLogD3D12)
{
switch (stage)
{
case ShaderStageType.Vertex: return m_D3D12.PipelineName + " VS";
case ShaderStageType.Domain: return m_D3D12.PipelineName + " DS";
case ShaderStageType.Hull: return m_D3D12.PipelineName + " HS";
case ShaderStageType.Geometry: return m_D3D12.PipelineName + " GS";
case ShaderStageType.Pixel: return m_D3D12.PipelineName + " PS";
case ShaderStageType.Compute: return m_D3D12.PipelineName + " CS";
}
}
else if (IsLogGL)
{
switch (stage)
{
case ShaderStageType.Vertex: return m_GL.m_VS.ShaderName;
case ShaderStageType.Tess_Control: return m_GL.m_TCS.ShaderName;
case ShaderStageType.Tess_Eval: return m_GL.m_TES.ShaderName;
case ShaderStageType.Geometry: return m_GL.m_GS.ShaderName;
case ShaderStageType.Fragment: return m_GL.m_FS.ShaderName;
case ShaderStageType.Compute: return m_GL.m_CS.ShaderName;
}
}
else if (IsLogVK)
{
switch (stage)
{
case ShaderStageType.Vertex: return m_Vulkan.VS.ShaderName;
case ShaderStageType.Domain: return m_Vulkan.TCS.ShaderName;
case ShaderStageType.Hull: return m_Vulkan.TES.ShaderName;
case ShaderStageType.Geometry: return m_Vulkan.GS.ShaderName;
case ShaderStageType.Pixel: return m_Vulkan.FS.ShaderName;
case ShaderStageType.Compute: return m_Vulkan.CS.ShaderName;
}
}
}
return "";
}
public Dictionary <BindpointMap, BoundResource[]> GetReadWriteResources(ShaderStageType stage)
{
var ret = new Dictionary <BindpointMap, BoundResource[]>();
if (LogLoaded)
{
if (IsLogD3D11)
{
if (stage == ShaderStageType.Compute)
{
for (int i = 0; i < m_D3D11.m_CS.UAVs.Length; i++)
{
var key = new BindpointMap(0, i);
var val = new BoundResource();
val.Id = m_D3D11.m_CS.UAVs[i].Resource;
val.HighestMip = (int)m_D3D11.m_CS.UAVs[i].HighestMip;
val.FirstSlice = (int)m_D3D11.m_CS.UAVs[i].FirstArraySlice;
ret.Add(key, new BoundResource[] { val });
}
}
else
{
for (int i = 0; i < m_D3D11.m_OM.UAVs.Length; i++)
{
var key = new BindpointMap(0, i);
var val = new BoundResource();
val.Id = m_D3D11.m_OM.UAVs[i].Resource;
val.HighestMip = (int)m_D3D11.m_OM.UAVs[i].HighestMip;
val.FirstSlice = (int)m_D3D11.m_OM.UAVs[i].FirstArraySlice;
ret.Add(key, new BoundResource[] { val });
}
}
return(ret);
}
else if (IsLogGL)
{
for (int i = 0; i < m_GL.Images.Length; i++)
{
var key = new BindpointMap(0, i);
var val = new BoundResource();
val.Id = m_GL.Images[i].Resource;
val.HighestMip = (int)m_GL.Images[i].Level;
val.FirstSlice = (int)m_GL.Images[i].Layer;
ret.Add(key, new BoundResource[] { val });
}
return(ret);
}
else if (IsLogVK)
{
VulkanPipelineState.Pipeline.DescriptorSet[] descsets = m_Vulkan.graphics.DescSets;
if (stage == ShaderStageType.Compute)
{
descsets = m_Vulkan.compute.DescSets;
}
ShaderStageBits mask = (ShaderStageBits)(1 << (int)stage);
for (int set = 0; set < descsets.Length; set++)
{
var descset = descsets[set];
for (int slot = 0; slot < descset.bindings.Length; slot++)
{
var bind = descset.bindings[slot];
if ((bind.type == ShaderBindType.ReadWriteBuffer ||
bind.type == ShaderBindType.ReadWriteImage ||
bind.type == ShaderBindType.ReadWriteTBuffer
) && (bind.stageFlags & mask) == mask)
{
var key = new BindpointMap(set, slot);
var val = new BoundResource[bind.descriptorCount];
for (UInt32 i = 0; i < bind.descriptorCount; i++)
{
val[i] = new BoundResource();
val[i].Id = bind.binds[i].res;
val[i].HighestMip = (int)bind.binds[i].baseMip;
val[i].FirstSlice = (int)bind.binds[i].baseLayer;
}
ret.Add(key, val);
}
}
}
return(ret);
}
}
return(ret);
}
public ResourceId BuildTargetShader(string entry, string source, UInt32 compileFlags, ShaderStageType type, out string errors)
{
IntPtr mem = CustomMarshal.Alloc(typeof(templated_array));
ResourceId ret = ResourceId.Null;
IntPtr entry_mem = CustomMarshal.MakeUTF8String(entry);
IntPtr source_mem = CustomMarshal.MakeUTF8String(source);
bool success = ReplayRenderer_BuildTargetShader(m_Real, entry_mem, source_mem, compileFlags, type, ref ret, mem);
CustomMarshal.Free(entry_mem);
CustomMarshal.Free(source_mem);
if (!success)
{
ret = ResourceId.Null;
}
errors = CustomMarshal.TemplatedArrayToString(mem, true);
CustomMarshal.Free(mem);
return(ret);
}
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 Dictionary<BindpointMap, BoundResource[]> GetReadOnlyResources(ShaderStageType stage)
{
var ret = new Dictionary<BindpointMap, BoundResource[]>();
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;
}
for (int i = 0; i < s.SRVs.Length; i++)
{
var key = new BindpointMap(0, i);
var val = new BoundResource();
val.Id = s.SRVs[i].Resource;
val.HighestMip = (int)s.SRVs[i].HighestMip;
val.FirstSlice = (int)s.SRVs[i].FirstArraySlice;
val.typeHint = s.SRVs[i].Format.compType;
ret.Add(key, new BoundResource[] { val });
}
return ret;
}
else if (IsLogGL)
{
for (int i = 0; i < m_GL.Textures.Length; i++)
{
var key = new BindpointMap(0, i);
var val = new BoundResource();
val.Id = m_GL.Textures[i].Resource;
val.HighestMip = (int)m_GL.Textures[i].HighestMip;
val.FirstSlice = (int)m_GL.Textures[i].FirstSlice;
val.typeHint = FormatComponentType.None;
ret.Add(key, new BoundResource[] { val });
}
return ret;
}
else if (IsLogVK)
{
VulkanPipelineState.Pipeline.DescriptorSet[] descsets = m_Vulkan.graphics.DescSets;
if (stage == ShaderStageType.Compute)
descsets = m_Vulkan.compute.DescSets;
ShaderStageBits mask = (ShaderStageBits)(1 << (int)stage);
for (int set = 0; set < descsets.Length; set++)
{
var descset = descsets[set];
for (int slot = 0; slot < descset.bindings.Length; slot++)
{
var bind = descset.bindings[slot];
if ((bind.type == ShaderBindType.ImageSampler ||
bind.type == ShaderBindType.InputAttachment ||
bind.type == ShaderBindType.ReadOnlyImage ||
bind.type == ShaderBindType.ReadOnlyTBuffer
) && (bind.stageFlags & mask) == mask)
{
var key = new BindpointMap(set, slot);
var val = new BoundResource[bind.descriptorCount];
for (UInt32 i = 0; i < bind.descriptorCount; i++)
{
val[i] = new BoundResource();
val[i].Id = bind.binds[i].res;
val[i].HighestMip = (int)bind.binds[i].baseMip;
val[i].FirstSlice = (int)bind.binds[i].baseLayer;
val[i].typeHint = bind.binds[i].viewfmt.compType;
}
ret.Add(key, val);
}
}
}
return ret;
}
}
return ret;
}
// there's a lot of redundancy in these functions
public ShaderReflection GetShaderReflection(ShaderStageType stage)
{
if (LogLoaded)
{
if (IsLogD3D11)
{
switch (stage)
{
case ShaderStageType.Vertex: return m_D3D11.m_VS.ShaderDetails;
case ShaderStageType.Domain: return m_D3D11.m_DS.ShaderDetails;
case ShaderStageType.Hull: return m_D3D11.m_HS.ShaderDetails;
case ShaderStageType.Geometry: return m_D3D11.m_GS.ShaderDetails;
case ShaderStageType.Pixel: return m_D3D11.m_PS.ShaderDetails;
case ShaderStageType.Compute: return m_D3D11.m_CS.ShaderDetails;
}
}
else if (IsLogGL)
{
switch (stage)
{
case ShaderStageType.Vertex: return m_GL.m_VS.ShaderDetails;
case ShaderStageType.Tess_Control: return m_GL.m_TCS.ShaderDetails;
case ShaderStageType.Tess_Eval: return m_GL.m_TES.ShaderDetails;
case ShaderStageType.Geometry: return m_GL.m_GS.ShaderDetails;
case ShaderStageType.Fragment: return m_GL.m_FS.ShaderDetails;
case ShaderStageType.Compute: return m_GL.m_CS.ShaderDetails;
}
}
}
return null;
}
public ResourceId GetShader(ShaderStageType stage)
{
if (LogLoaded)
{
if (IsLogD3D11)
{
switch (stage)
{
case ShaderStageType.Vertex: return m_D3D11.m_VS.Shader;
case ShaderStageType.Domain: return m_D3D11.m_DS.Shader;
case ShaderStageType.Hull: return m_D3D11.m_HS.Shader;
case ShaderStageType.Geometry: return m_D3D11.m_GS.Shader;
case ShaderStageType.Pixel: return m_D3D11.m_PS.Shader;
case ShaderStageType.Compute: return m_D3D11.m_CS.Shader;
}
}
else if (IsLogGL)
{
switch (stage)
{
case ShaderStageType.Vertex: return m_GL.m_VS.Shader;
case ShaderStageType.Tess_Control: return m_GL.m_TCS.Shader;
case ShaderStageType.Tess_Eval: return m_GL.m_TES.Shader;
case ShaderStageType.Geometry: return m_GL.m_GS.Shader;
case ShaderStageType.Fragment: return m_GL.m_FS.Shader;
case ShaderStageType.Compute: return m_GL.m_CS.Shader;
}
}
}
return ResourceId.Null;
}
public ResourceId[] GetResources(ShaderStageType stage)
{
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;
}
ResourceId[] ret = new ResourceId[s.SRVs.Length];
for (int i = 0; i < s.SRVs.Length; i++)
ret[i] = s.SRVs[i].Resource;
return ret;
}
else if (IsLogGL)
{
ResourceId[] ret = new ResourceId[m_GL.Textures.Length];
for (int i = 0; i < m_GL.Textures.Length; i++)
ret[i] = m_GL.Textures[i].Resource;
return ret;
}
}
return null;
}
public void GetConstantBuffer(ShaderStageType stage, uint BindPoint, out ResourceId buf, out uint ByteOffset)
{
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;
}
buf = s.ConstantBuffers[BindPoint].Buffer;
ByteOffset = s.ConstantBuffers[BindPoint].VecOffset * 4 * sizeof(float);
return;
}
else if (IsLogGL)
{
buf = ResourceId.Null;
ByteOffset = 0;
return;
}
}
buf = ResourceId.Null;
ByteOffset = 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;
}
public ShaderViewer(Core core, ShaderReflection shader, ShaderStageType stage, ShaderDebugTrace trace, string debugContext)
{
InitializeComponent();
constantRegs.Font =
variableRegs.Font =
watchRegs.Font =
inSig.Font =
outSig.Font =
core.Config.PreferredFont;
Icon = global::renderdocui.Properties.Resources.icon;
this.SuspendLayout();
mainLayout.Dock = DockStyle.Fill;
constantRegs.Font =
variableRegs.Font =
watchRegs.Font =
inSig.Font =
outSig.Font =
core.Config.PreferredFont;
m_Core = core;
m_ShaderDetails = shader;
m_Trace = trace;
m_Stage = null;
switch (stage)
{
case ShaderStageType.Vertex: m_Stage = m_Core.CurD3D11PipelineState.m_VS; break;
case ShaderStageType.Domain: m_Stage = m_Core.CurD3D11PipelineState.m_DS; break;
case ShaderStageType.Hull: m_Stage = m_Core.CurD3D11PipelineState.m_HS; break;
case ShaderStageType.Geometry: m_Stage = m_Core.CurD3D11PipelineState.m_GS; break;
case ShaderStageType.Pixel: m_Stage = m_Core.CurD3D11PipelineState.m_PS; break;
case ShaderStageType.Compute: m_Stage = m_Core.CurD3D11PipelineState.m_CS; break;
}
if (trace != null)
Text = String.Format("Debugging {0} - {1}", m_Core.CurPipelineState.GetShaderName(stage), debugContext);
else
Text = m_Core.CurPipelineState.GetShaderName(stage);
var disasm = shader.Disassembly;
if (m_Core.Config.ShaderViewer_FriendlyNaming)
{
for (int i = 0; i < m_ShaderDetails.ConstantBlocks.Length; i++)
{
var stem = string.Format("cb{0}", i);
var cbuf = m_ShaderDetails.ConstantBlocks[i];
if (cbuf.variables.Length == 0)
continue;
disasm = FriendlyName(disasm, stem, "", cbuf.variables);
}
foreach (var r in m_ShaderDetails.Resources)
{
if (r.IsSRV)
{
var needle = string.Format(", t{0}([^0-9])", r.bindPoint);
var replacement = string.Format(", {0}$1", r.name);
Regex rgx = new Regex(needle);
disasm = rgx.Replace(disasm, replacement);
}
if (r.IsSampler)
{
var needle = string.Format(", s{0}([^0-9])", r.bindPoint);
var replacement = string.Format(", {0}$1", r.name);
Regex rgx = new Regex(needle);
disasm = rgx.Replace(disasm, replacement);
}
if (r.IsReadWrite)
{
var needle = string.Format(", u{0}([^0-9])", r.bindPoint);
var replacement = string.Format(", {0}$1", r.name);
Regex rgx = new Regex(needle);
disasm = rgx.Replace(disasm, replacement);
}
}
}
{
m_DisassemblyView = MakeEditor("scintillaDisassem", disasm, false);
m_DisassemblyView.IsReadOnly = true;
m_DisassemblyView.TabIndex = 0;
m_DisassemblyView.KeyDown += new KeyEventHandler(m_DisassemblyView_KeyDown);
m_DisassemblyView.KeyDown += new KeyEventHandler(readonlyScintilla_KeyDown);
m_DisassemblyView.Markers[CURRENT_MARKER].BackColor = System.Drawing.Color.LightCoral;
m_DisassemblyView.Markers[CURRENT_MARKER].Symbol = ScintillaNET.MarkerSymbol.Background;
m_DisassemblyView.Markers[CURRENT_MARKER+1].BackColor = System.Drawing.Color.LightCoral;
m_DisassemblyView.Markers[CURRENT_MARKER+1].Symbol = ScintillaNET.MarkerSymbol.ShortArrow;
CurrentLineMarkers.Add(CURRENT_MARKER);
CurrentLineMarkers.Add(CURRENT_MARKER+1);
m_DisassemblyView.Markers[FINISHED_MARKER].BackColor = System.Drawing.Color.LightSlateGray;
m_DisassemblyView.Markers[FINISHED_MARKER].Symbol = ScintillaNET.MarkerSymbol.Background;
m_DisassemblyView.Markers[FINISHED_MARKER + 1].BackColor = System.Drawing.Color.LightSlateGray;
m_DisassemblyView.Markers[FINISHED_MARKER + 1].Symbol = ScintillaNET.MarkerSymbol.RoundRectangle;
FinishedMarkers.Add(FINISHED_MARKER);
FinishedMarkers.Add(FINISHED_MARKER + 1);
m_DisassemblyView.Markers[BREAKPOINT_MARKER].BackColor = System.Drawing.Color.Red;
m_DisassemblyView.Markers[BREAKPOINT_MARKER].Symbol = ScintillaNET.MarkerSymbol.Background;
m_DisassemblyView.Markers[BREAKPOINT_MARKER+1].BackColor = System.Drawing.Color.Red;
m_DisassemblyView.Markers[BREAKPOINT_MARKER+1].Symbol = ScintillaNET.MarkerSymbol.Circle;
BreakpointMarkers.Add(BREAKPOINT_MARKER);
BreakpointMarkers.Add(BREAKPOINT_MARKER + 1);
if (trace != null)
{
m_DisassemblyView.ContextMenu = AssemblyContextMenu();
m_DisassemblyView.MouseDown += new MouseEventHandler(contextMouseDown);
}
m_Scintillas.Add(m_DisassemblyView);
var w = Helpers.WrapDockContent(dockPanel, m_DisassemblyView, "Disassembly");
w.DockState = DockState.Document;
w.Show();
w.CloseButton = false;
w.CloseButtonVisible = false;
}
if (shader.DebugInfo.entryFunc.Length > 0 && shader.DebugInfo.files.Length > 0)
{
if(trace != null)
Text = String.Format("Debug {0}() - {1}", shader.DebugInfo.entryFunc, debugContext);
else
Text = String.Format("{0}()", shader.DebugInfo.entryFunc);
int fileIdx = 0;
DockContent sel = null;
foreach (var f in shader.DebugInfo.files)
{
var name = f.BaseFilename;
ScintillaNET.Scintilla scintilla1 = MakeEditor("scintilla" + name, f.filetext, true);
scintilla1.IsReadOnly = true;
scintilla1.Tag = name;
scintilla1.KeyDown += new KeyEventHandler(readonlyScintilla_KeyDown);
var w = Helpers.WrapDockContent(dockPanel, scintilla1, name);
w.CloseButton = false;
w.CloseButtonVisible = false;
w.Show(dockPanel);
m_Scintillas.Add(scintilla1);
if (shader.DebugInfo.entryFile >= 0 && shader.DebugInfo.entryFile < shader.DebugInfo.files.Length)
{
if (fileIdx == shader.DebugInfo.entryFile)
sel = w;
}
else if (f.filetext.Contains(shader.DebugInfo.entryFunc))
{
sel = w;
}
fileIdx++;
}
if (shader.DebugInfo.files.Length > 2)
AddFileList();
if (trace != null || sel == null)
sel = (DockContent)m_DisassemblyView.Parent;
sel.Show();
}
m_FindAll = new FindAllDialog(FindAllFiles);
m_FindAll.Hide();
ShowConstants();
ShowVariables();
ShowWatch();
ShowErrors();
editStrip.Visible = false;
m_ErrorsDock.Hide();
if (trace == null)
{
debuggingStrip.Visible = false;
m_ConstantsDock.Hide();
m_VariablesDock.Hide();
m_WatchDock.Hide();
var insig = Helpers.WrapDockContent(dockPanel, inSigBox);
insig.CloseButton = insig.CloseButtonVisible = false;
var outsig = Helpers.WrapDockContent(dockPanel, outSigBox);
outsig.CloseButton = outsig.CloseButtonVisible = false;
insig.Show(dockPanel, DockState.DockBottom);
outsig.Show(insig.Pane, DockAlignment.Right, 0.5);
foreach (var s in m_ShaderDetails.InputSig)
{
string name = s.varName.Length == 0 ? s.semanticName : String.Format("{0} ({1})", s.varName, s.semanticName);
if (s.semanticName.Length == 0) name = s.varName;
inSig.Nodes.Add(new object[] { name, s.semanticIndex, s.regIndex, s.TypeString, s.systemValue.ToString(),
SigParameter.GetComponentString(s.regChannelMask), SigParameter.GetComponentString(s.channelUsedMask) });
}
bool multipleStreams = false;
for (int i = 0; i < m_ShaderDetails.OutputSig.Length; i++)
{
if (m_ShaderDetails.OutputSig[i].stream > 0)
{
multipleStreams = true;
break;
}
}
foreach (var s in m_ShaderDetails.OutputSig)
{
string name = s.varName.Length == 0 ? s.semanticName : String.Format("{0} ({1})", s.varName, s.semanticName);
if (s.semanticName.Length == 0) name = s.varName;
if(multipleStreams)
name = String.Format("Stream {0} : {1}", s.stream, name);
outSig.Nodes.Add(new object[] { name, s.semanticIndex, s.regIndex, s.TypeString, s.systemValue.ToString(),
SigParameter.GetComponentString(s.regChannelMask), SigParameter.GetComponentString(s.channelUsedMask) });
}
}
else
{
inSigBox.Visible = false;
outSigBox.Visible = false;
m_DisassemblyView.Margins.Margin1.Width = 20;
m_DisassemblyView.Margins.Margin2.Width = 0;
m_DisassemblyView.Margins.Margin3.Width = 20;
m_DisassemblyView.Margins.Margin3.IsMarkerMargin = true;
m_DisassemblyView.Margins.Margin3.IsFoldMargin = false;
m_DisassemblyView.Margins.Margin3.Type = ScintillaNET.MarginType.Symbol;
m_DisassemblyView.Margins.Margin1.Mask = (int)m_DisassemblyView.Markers[BREAKPOINT_MARKER + 1].Mask;
m_DisassemblyView.Margins.Margin3.Mask &= ~((int)m_DisassemblyView.Markers[BREAKPOINT_MARKER + 1].Mask);
m_DisassemblyView.MouseMove += new MouseEventHandler(scintilla1_MouseMove);
m_DisassemblyView.Leave += new EventHandler(scintilla1_Leave);
m_DisassemblyView.KeyDown += new KeyEventHandler(scintilla1_DebuggingKeyDown);
watchRegs.Items.Add(new ListViewItem(new string[] { "", "", "" }));
}
CurrentStep = 0;
this.ResumeLayout(false);
}
private static extern bool ReplayRenderer_BuildTargetShader(IntPtr real, IntPtr entry, IntPtr source, UInt32 compileFlags, ShaderStageType type, ref ResourceId shaderID, IntPtr errorMem);
public string Abbrev(ShaderStageType stage)
{
if (IsLogD3D11 || (!LogLoaded && DefaultType == APIPipelineStateType.D3D11))
{
switch (stage)
{
case ShaderStageType.Vertex: return "VS";
case ShaderStageType.Hull: return "HS";
case ShaderStageType.Domain: return "DS";
case ShaderStageType.Geometry: return "GS";
case ShaderStageType.Pixel: return "PS";
case ShaderStageType.Compute: return "CS";
}
}
else if (IsLogGL || (!LogLoaded && DefaultType == APIPipelineStateType.OpenGL) ||
IsLogVK || (!LogLoaded && DefaultType == APIPipelineStateType.Vulkan))
{
switch (stage)
{
case ShaderStageType.Vertex: return "VS";
case ShaderStageType.Tess_Control: return "TCS";
case ShaderStageType.Tess_Eval: return "TES";
case ShaderStageType.Geometry: return "GS";
case ShaderStageType.Fragment: return "FS";
case ShaderStageType.Compute: return "CS";
}
}
return "?S";
}
public Dictionary <BindpointMap, BoundResource[]> GetReadOnlyResources(ShaderStageType stage)
{
var ret = new Dictionary <BindpointMap, BoundResource[]>();
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;
}
for (int i = 0; i < s.SRVs.Length; i++)
{
var key = new BindpointMap(0, i);
var val = new BoundResource();
val.Id = s.SRVs[i].Resource;
val.HighestMip = (int)s.SRVs[i].HighestMip;
val.FirstSlice = (int)s.SRVs[i].FirstArraySlice;
ret.Add(key, new BoundResource[] { val });
}
return(ret);
}
else if (IsLogGL)
{
for (int i = 0; i < m_GL.Textures.Length; i++)
{
var key = new BindpointMap(0, i);
var val = new BoundResource();
val.Id = m_GL.Textures[i].Resource;
val.HighestMip = (int)m_GL.Textures[i].HighestMip;
val.FirstSlice = (int)m_GL.Textures[i].FirstSlice;
ret.Add(key, new BoundResource[] { val });
}
return(ret);
}
else if (IsLogVK)
{
VulkanPipelineState.Pipeline.DescriptorSet[] descsets = m_Vulkan.graphics.DescSets;
if (stage == ShaderStageType.Compute)
{
descsets = m_Vulkan.compute.DescSets;
}
ShaderStageBits mask = (ShaderStageBits)(1 << (int)stage);
for (int set = 0; set < m_Vulkan.graphics.DescSets.Length; set++)
{
var descset = m_Vulkan.graphics.DescSets[set];
for (int slot = 0; slot < descset.bindings.Length; slot++)
{
var bind = descset.bindings[slot];
if ((bind.type == ShaderBindType.ImageSampler ||
bind.type == ShaderBindType.InputAttachment ||
bind.type == ShaderBindType.ReadOnlyImage ||
bind.type == ShaderBindType.ReadOnlyTBuffer
) && (bind.stageFlags & mask) == mask)
{
var key = new BindpointMap(set, slot);
var val = new BoundResource[bind.descriptorCount];
for (UInt32 i = 0; i < bind.descriptorCount; i++)
{
val[i] = new BoundResource();
val[i].Id = bind.binds[i].res;
val[i].HighestMip = (int)bind.binds[i].baseMip;
val[i].FirstSlice = (int)bind.binds[i].baseLayer;
}
ret.Add(key, val);
}
}
}
return(ret);
}
}
return(ret);
}
public ResourceId BuildTargetShader(string entry, string source, UInt32 compileFlags, ShaderStageType type, out string errors)
{
IntPtr mem = CustomMarshal.Alloc(typeof(templated_array));
ResourceId ret = ResourceId.Null;
bool success = ReplayRenderer_BuildTargetShader(m_Real, entry, source, compileFlags, type, ref ret, mem);
if (!success)
ret = ResourceId.Null;
errors = CustomMarshal.TemplatedArrayToUniString(mem, true);
CustomMarshal.Free(mem);
return ret;
}
public ResourceId BuildTargetShader(string entry, string source, UInt32 compileFlags, ShaderStageType type, out string errors)
{
IntPtr mem = CustomMarshal.Alloc(typeof(templated_array));
ResourceId ret = ResourceId.Null;
IntPtr entry_mem = CustomMarshal.MakeUTF8String(entry);
IntPtr source_mem = CustomMarshal.MakeUTF8String(source);
ReplayRenderer_BuildTargetShader(m_Real, entry_mem, source_mem, compileFlags, type, ref ret, mem);
CustomMarshal.Free(entry_mem);
CustomMarshal.Free(source_mem);
errors = CustomMarshal.TemplatedArrayToString(mem, true);
CustomMarshal.Free(mem);
return ret;
}
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;
}
// there's a lot of redundancy in these functions
public ShaderBindpointMapping GetBindpointMapping(ShaderStageType stage)
{
if (LogLoaded)
{
if (IsLogD3D11)
{
switch (stage)
{
case ShaderStageType.Vertex: return m_D3D11.m_VS.BindpointMapping;
case ShaderStageType.Domain: return m_D3D11.m_DS.BindpointMapping;
case ShaderStageType.Hull: return m_D3D11.m_HS.BindpointMapping;
case ShaderStageType.Geometry: return m_D3D11.m_GS.BindpointMapping;
case ShaderStageType.Pixel: return m_D3D11.m_PS.BindpointMapping;
case ShaderStageType.Compute: return m_D3D11.m_CS.BindpointMapping;
}
}
else if (IsLogGL)
{
switch (stage)
{
case ShaderStageType.Vertex: return m_GL.m_VS.BindpointMapping;
case ShaderStageType.Tess_Control: return m_GL.m_TCS.BindpointMapping;
case ShaderStageType.Tess_Eval: return m_GL.m_TES.BindpointMapping;
case ShaderStageType.Geometry: return m_GL.m_GS.BindpointMapping;
case ShaderStageType.Fragment: return m_GL.m_FS.BindpointMapping;
case ShaderStageType.Compute: return m_GL.m_CS.BindpointMapping;
}
}
}
return null;
}
private static extern bool ReplayRenderer_BuildCustomShader(IntPtr real, string entry, string source, UInt32 compileFlags, ShaderStageType type, ref ResourceId shaderID, IntPtr errorMem);
private static extern bool ReplayRenderer_BuildCustomShader(IntPtr real, string entry, string source, UInt32 compileFlags, ShaderStageType type, ref ResourceId shaderID, IntPtr errorMem);
private void InitStageResourcePreviews(ShaderStageType stage, ShaderResource[] resourceDetails, BindpointMap[] mapping,
Dictionary<BindpointMap, BoundResource[]> ResList,
ThumbnailStrip prevs, ref int prevIndex,
bool copy, bool rw)
{
for (int idx = 0; idx < mapping.Length; idx++)
{
var key = mapping[idx];
BoundResource[] resArray = null;
if (ResList.ContainsKey(key))
resArray = ResList[key];
int arrayLen = resArray != null ? resArray.Length : 1;
for (int arrayIdx = 0; arrayIdx < arrayLen; arrayIdx++)
{
ResourceId id = resArray != null ? resArray[arrayIdx].Id : ResourceId.Null;
FormatComponentType typeHint = resArray != null ? resArray[arrayIdx].typeHint : FormatComponentType.None;
bool used = key.used;
bool samplerBind = false;
bool otherBind = false;
string bindName = "";
foreach (var bind in resourceDetails)
{
if (bind.bindPoint == idx && bind.IsSRV)
{
bindName = bind.name;
otherBind = true;
break;
}
if (bind.bindPoint == idx)
{
if(bind.IsSampler && !bind.IsSRV)
samplerBind = true;
else
otherBind = true;
}
}
if (samplerBind && !otherBind)
continue;
if (copy)
{
used = true;
bindName = "Source";
}
Following follow = new Following(rw ? FollowType.ReadWrite : FollowType.ReadOnly, stage, idx, arrayIdx);
string slotName = String.Format("{0} {1}{2}", m_Core.CurPipelineState.Abbrev(stage), rw ? "RW " : "", idx);
if (arrayLen > 1)
slotName += String.Format("[{0}]", arrayIdx);
if (copy)
slotName = "SRC";
// show if
bool show = (used || // it's referenced by the shader - regardless of empty or not
(showDisabled.Checked && !used && id != ResourceId.Null) || // it's bound, but not referenced, and we have "show disabled"
(showEmpty.Checked && id == ResourceId.Null) // it's empty, and we have "show empty"
);
ResourcePreview prev;
if (prevIndex < prevs.Thumbnails.Length)
{
prev = prevs.Thumbnails[prevIndex];
}
else
{
// don't create it if we're not actually going to show it
if (!show)
continue;
prev = UI_CreateThumbnail(prevs);
}
prevIndex++;
InitResourcePreview(prev, show ? id : ResourceId.Null, typeHint, show, follow, bindName, slotName);
}
}
}
public static extern void sg_apply_uniforms(ShaderStageType stage, int ub_index, IntPtr data, int num_bytes);
public static ShaderBindpointMapping GetMapping(Core core, ShaderStageType stage)
{
var curDraw = core.CurDrawcall;
bool copy, compute;
GetDrawContext(core, out copy, out compute);
if (copy)
{
ShaderBindpointMapping mapping = new ShaderBindpointMapping();
mapping.ConstantBlocks = new BindpointMap[0];
mapping.ReadWriteResources = new BindpointMap[0];
mapping.InputAttributes = new int[0];
// for PS only add a single mapping to get the copy source
if (stage == ShaderStageType.Pixel)
mapping.ReadOnlyResources = new BindpointMap[] { new BindpointMap(0, 0) };
else
mapping.ReadOnlyResources = new BindpointMap[0];
return mapping;
}
else if (compute)
{
return core.CurPipelineState.GetBindpointMapping(ShaderStageType.Compute);
}
else
{
return core.CurPipelineState.GetBindpointMapping(stage);
}
}
private static extern void ReplayRenderer_BuildTargetShader(IntPtr real, IntPtr entry, IntPtr source, UInt32 compileFlags, ShaderStageType type, ref ResourceId shaderID, IntPtr errorMem);
public static Dictionary<BindpointMap, BoundResource[]> GetReadWriteResources(Core core, ShaderStageType stage)
{
var curDraw = core.CurDrawcall;
bool copy, compute;
GetDrawContext(core, out copy, out compute);
if (copy)
{
return new Dictionary<BindpointMap, BoundResource[]>();
}
else if (compute)
{
// only return compute resources for one stage
if (stage == ShaderStageType.Pixel || stage == ShaderStageType.Compute)
return core.CurPipelineState.GetReadWriteResources(ShaderStageType.Compute);
else
return new Dictionary<BindpointMap, BoundResource[]>();
}
else
{
return core.CurPipelineState.GetReadWriteResources(stage);
}
}
public static DockContent Has(ShaderStageType stage, UInt32 slot)
{
foreach (var d in m_Docks)
{
ConstantBufferPreviewer cb = d.Controls[0] as ConstantBufferPreviewer;
if(cb.Stage == stage && cb.Slot == slot)
return cb.Parent as DockContent;
}
return null;
}
public void OnEventSelected(UInt32 eventID)
{
if (IsDisposed) return;
if (!CurrentTextureIsLocked || (CurrentTexture != null && m_TexDisplay.texid != CurrentTexture.ID))
UI_OnTextureSelectionChanged(true);
if (m_Output == null) return;
UI_CreateThumbnails();
BoundResource[] RTs = Following.GetOutputTargets(m_Core);
BoundResource Depth = Following.GetDepthTarget(m_Core);
int rwIndex = 0;
int roIndex = 0;
var curDraw = m_Core.GetDrawcall(eventID);
bool copy = curDraw != null && (curDraw.flags & (DrawcallFlags.Copy|DrawcallFlags.Resolve)) != 0;
bool compute = curDraw != null && (curDraw.flags & (DrawcallFlags.Dispatch)) != 0;
for(int rt=0; rt < RTs.Length; rt++)
{
ResourcePreview prev;
if (rwIndex < rwPanel.Thumbnails.Length)
prev = rwPanel.Thumbnails[rwIndex];
else
prev = UI_CreateThumbnail(rwPanel);
rwIndex++;
Following follow = new Following(FollowType.OutputColour, ShaderStageType.Pixel, rt, 0);
string bindName = copy ? "Destination" : "";
string slotName = copy ? "DST" : String.Format("{0}{1}", m_Core.CurPipelineState.OutputAbbrev(), rt);
InitResourcePreview(prev, RTs[rt].Id, RTs[rt].typeHint, false, follow, bindName, slotName);
}
// depth
{
ResourcePreview prev;
if (rwIndex < rwPanel.Thumbnails.Length)
prev = rwPanel.Thumbnails[rwIndex];
else
prev = UI_CreateThumbnail(rwPanel);
rwIndex++;
Following follow = new Following(FollowType.OutputDepth, ShaderStageType.Pixel, 0, 0);
InitResourcePreview(prev, Depth.Id, Depth.typeHint, false, follow, "", "DS");
}
ShaderStageType[] stages = new ShaderStageType[] {
ShaderStageType.Vertex,
ShaderStageType.Hull,
ShaderStageType.Domain,
ShaderStageType.Geometry,
ShaderStageType.Pixel
};
if (compute) stages = new ShaderStageType[] { ShaderStageType.Compute };
// display resources used for all stages
foreach (ShaderStageType stage in stages)
{
Dictionary<BindpointMap, BoundResource[]> RWs = Following.GetReadWriteResources(m_Core, stage);
Dictionary<BindpointMap, BoundResource[]> ROs = Following.GetReadOnlyResources(m_Core, stage);
ShaderReflection details = Following.GetReflection(m_Core, stage);
ShaderBindpointMapping mapping = Following.GetMapping(m_Core, stage);
if (mapping == null)
continue;
InitStageResourcePreviews(stage,
details != null ? details.ReadWriteResources : new ShaderResource[0],
mapping.ReadWriteResources,
RWs, rwPanel, ref rwIndex, copy, true);
InitStageResourcePreviews(stage,
details != null ? details.ReadOnlyResources : new ShaderResource[0],
mapping.ReadOnlyResources,
ROs, roPanel, ref roIndex, copy, false);
}
// hide others
for (; rwIndex < rwPanel.Thumbnails.Length; rwIndex++)
{
rwPanel.Thumbnails[rwIndex].Init();
rwPanel.Thumbnails[rwIndex].Visible = false;
}
rwPanel.RefreshLayout();
for (; roIndex < roPanel.Thumbnails.Length; roIndex++)
{
roPanel.Thumbnails[roIndex].Init();
roPanel.Thumbnails[roIndex].Visible = false;
}
roPanel.RefreshLayout();
m_Core.Renderer.BeginInvoke(RT_UpdateAndDisplay);
if(autoFit.Checked)
AutoFitRange();
}
public Dictionary<BindpointMap, BoundResource[]> GetReadWriteResources(ShaderStageType stage)
{
var ret = new Dictionary<BindpointMap, BoundResource[]>();
if (LogLoaded)
{
if (IsLogD3D11)
{
if (stage == ShaderStageType.Compute)
{
for (int i = 0; i < m_D3D11.m_CS.UAVs.Length; i++)
{
var key = new BindpointMap(0, i);
var val = new BoundResource();
val.Id = m_D3D11.m_CS.UAVs[i].Resource;
val.HighestMip = (int)m_D3D11.m_CS.UAVs[i].HighestMip;
val.FirstSlice = (int)m_D3D11.m_CS.UAVs[i].FirstArraySlice;
val.typeHint = m_D3D11.m_CS.UAVs[i].Format.compType;
ret.Add(key, new BoundResource[] { val });
}
}
else
{
for (int i = 0; i < m_D3D11.m_OM.UAVs.Length; i++)
{
var key = new BindpointMap(0, i);
var val = new BoundResource();
val.Id = m_D3D11.m_OM.UAVs[i].Resource;
val.HighestMip = (int)m_D3D11.m_OM.UAVs[i].HighestMip;
val.FirstSlice = (int)m_D3D11.m_OM.UAVs[i].FirstArraySlice;
val.typeHint = FormatComponentType.None;
ret.Add(key, new BoundResource[] { val });
}
}
return ret;
}
else if (IsLogGL)
{
for (int i = 0; i < m_GL.Images.Length; i++)
{
var key = new BindpointMap(0, i);
var val = new BoundResource();
val.Id = m_GL.Images[i].Resource;
val.HighestMip = (int)m_GL.Images[i].Level;
val.FirstSlice = (int)m_GL.Images[i].Layer;
val.typeHint = m_GL.Images[i].Format.compType;
ret.Add(key, new BoundResource[] { val });
}
return ret;
}
else if (IsLogVK)
{
VulkanPipelineState.Pipeline.DescriptorSet[] descsets = m_Vulkan.graphics.DescSets;
if (stage == ShaderStageType.Compute)
descsets = m_Vulkan.compute.DescSets;
ShaderStageBits mask = (ShaderStageBits)(1 << (int)stage);
for (int set = 0; set < descsets.Length; set++)
{
var descset = descsets[set];
for (int slot = 0; slot < descset.bindings.Length; slot++)
{
var bind = descset.bindings[slot];
if ((bind.type == ShaderBindType.ReadWriteBuffer ||
bind.type == ShaderBindType.ReadWriteImage ||
bind.type == ShaderBindType.ReadWriteTBuffer
) && (bind.stageFlags & mask) == mask)
{
var key = new BindpointMap(set, slot);
var val = new BoundResource[bind.descriptorCount];
for (UInt32 i = 0; i < bind.descriptorCount; i++)
{
val[i] = new BoundResource();
val[i].Id = bind.binds[i].res;
val[i].HighestMip = (int)bind.binds[i].baseMip;
val[i].FirstSlice = (int)bind.binds[i].baseLayer;
val[i].typeHint = bind.binds[i].viewfmt.compType;
}
ret.Add(key, val);
}
}
}
return ret;
}
}
return ret;
}
public ShaderViewer(Core core, ShaderReflection shader, ShaderStageType stage, ShaderDebugTrace trace)
{
InitializeComponent();
Icon = global::renderdocui.Properties.Resources.icon;
this.SuspendLayout();
mainLayout.Dock = DockStyle.Fill;
m_Core = core;
m_ShaderDetails = shader;
m_Trace = trace;
m_Stage = null;
switch (stage)
{
case ShaderStageType.Vertex: m_Stage = m_Core.CurD3D11PipelineState.m_VS; break;
case ShaderStageType.Domain: m_Stage = m_Core.CurD3D11PipelineState.m_DS; break;
case ShaderStageType.Hull: m_Stage = m_Core.CurD3D11PipelineState.m_HS; break;
case ShaderStageType.Geometry: m_Stage = m_Core.CurD3D11PipelineState.m_GS; break;
case ShaderStageType.Pixel: m_Stage = m_Core.CurD3D11PipelineState.m_PS; break;
case ShaderStageType.Compute: m_Stage = m_Core.CurD3D11PipelineState.m_CS; break;
}
var disasm = shader.Disassembly;
if (m_Core.Config.ShaderViewer_FriendlyNaming)
{
for (int i = 0; i < m_ShaderDetails.ConstantBlocks.Length; i++)
{
var stem = string.Format("cb{0}", i);
var cbuf = m_ShaderDetails.ConstantBlocks[i];
if (cbuf.variables.Length == 0)
{
continue;
}
disasm = FriendlyName(disasm, stem, cbuf.variables);
}
foreach (var r in m_ShaderDetails.Resources)
{
if (r.IsSRV)
{
var needle = string.Format(", t{0}([^0-9])", r.bindPoint);
var replacement = string.Format(", {0}$1", r.name);
Regex rgx = new Regex(needle);
disasm = rgx.Replace(disasm, replacement);
}
if (r.IsSampler)
{
var needle = string.Format(", s{0}([^0-9])", r.bindPoint);
var replacement = string.Format(", {0}$1", r.name);
Regex rgx = new Regex(needle);
disasm = rgx.Replace(disasm, replacement);
}
if (r.IsUAV)
{
var needle = string.Format(", u{0}([^0-9])", r.bindPoint);
var replacement = string.Format(", {0}$1", r.name);
Regex rgx = new Regex(needle);
disasm = rgx.Replace(disasm, replacement);
}
}
}
{
m_DisassemblyView = MakeEditor("scintillaDisassem", disasm, false);
m_DisassemblyView.IsReadOnly = true;
m_DisassemblyView.TabIndex = 0;
m_DisassemblyView.KeyDown += new KeyEventHandler(m_DisassemblyView_KeyDown);
m_DisassemblyView.Markers[CURRENT_MARKER].BackColor = System.Drawing.Color.LightCoral;
m_DisassemblyView.Markers[CURRENT_MARKER].Symbol = ScintillaNET.MarkerSymbol.Background;
m_DisassemblyView.Markers[CURRENT_MARKER + 1].BackColor = System.Drawing.Color.LightCoral;
m_DisassemblyView.Markers[CURRENT_MARKER + 1].Symbol = ScintillaNET.MarkerSymbol.ShortArrow;
CurrentLineMarkers.Add(CURRENT_MARKER);
CurrentLineMarkers.Add(CURRENT_MARKER + 1);
m_DisassemblyView.Markers[FINISHED_MARKER].BackColor = System.Drawing.Color.LightSlateGray;
m_DisassemblyView.Markers[FINISHED_MARKER].Symbol = ScintillaNET.MarkerSymbol.Background;
m_DisassemblyView.Markers[FINISHED_MARKER + 1].BackColor = System.Drawing.Color.LightSlateGray;
m_DisassemblyView.Markers[FINISHED_MARKER + 1].Symbol = ScintillaNET.MarkerSymbol.RoundRectangle;
FinishedMarkers.Add(FINISHED_MARKER);
FinishedMarkers.Add(FINISHED_MARKER + 1);
m_DisassemblyView.Markers[BREAKPOINT_MARKER].BackColor = System.Drawing.Color.Red;
m_DisassemblyView.Markers[BREAKPOINT_MARKER].Symbol = ScintillaNET.MarkerSymbol.Background;
m_DisassemblyView.Markers[BREAKPOINT_MARKER + 1].BackColor = System.Drawing.Color.Red;
m_DisassemblyView.Markers[BREAKPOINT_MARKER + 1].Symbol = ScintillaNET.MarkerSymbol.Circle;
BreakpointMarkers.Add(BREAKPOINT_MARKER);
BreakpointMarkers.Add(BREAKPOINT_MARKER + 1);
m_Scintillas.Add(m_DisassemblyView);
var w = Helpers.WrapDockContent(dockPanel, m_DisassemblyView, "Disassembly");
w.DockState = DockState.Document;
w.Show();
w.CloseButton = false;
w.CloseButtonVisible = false;
}
if (shader.DebugInfo.entryFunc != "" && shader.DebugInfo.files.Length > 0)
{
Text = shader.DebugInfo.entryFunc + "()";
DockContent sel = null;
foreach (var f in shader.DebugInfo.files)
{
var name = Path.GetFileName(f.filename);
ScintillaNET.Scintilla scintilla1 = MakeEditor("scintilla" + name, f.filetext, true);
scintilla1.IsReadOnly = true;
scintilla1.Tag = name;
var w = Helpers.WrapDockContent(dockPanel, scintilla1, name);
w.CloseButton = false;
w.CloseButtonVisible = false;
w.Show(dockPanel);
m_Scintillas.Add(scintilla1);
if (f.filetext.Contains(shader.DebugInfo.entryFunc))
{
sel = w;
}
}
if (trace != null || sel == null)
{
sel = (DockContent)m_DisassemblyView.Parent;
}
sel.Show();
}
ShowConstants();
ShowVariables();
ShowWatch();
ShowErrors();
editStrip.Visible = false;
m_ErrorsDock.Hide();
if (trace == null)
{
debuggingStrip.Visible = false;
m_ConstantsDock.Hide();
m_VariablesDock.Hide();
m_WatchDock.Hide();
var insig = Helpers.WrapDockContent(dockPanel, inSigBox);
insig.CloseButton = insig.CloseButtonVisible = false;
var outsig = Helpers.WrapDockContent(dockPanel, outSigBox);
outsig.CloseButton = outsig.CloseButtonVisible = false;
insig.Show(dockPanel, DockState.DockBottom);
outsig.Show(insig.Pane, DockAlignment.Right, 0.5);
foreach (var s in m_ShaderDetails.InputSig)
{
string name = s.varName == "" ? s.semanticName : String.Format("{0} ({1})", s.varName, s.semanticName);
var node = inSig.Nodes.Add(new object[] { name, s.semanticIndex, s.regIndex, s.TypeString, s.systemValue.ToString(),
SigParameter.GetComponentString(s.regChannelMask), SigParameter.GetComponentString(s.channelUsedMask) });
}
bool multipleStreams = false;
for (int i = 0; i < m_ShaderDetails.OutputSig.Length; i++)
{
if (m_ShaderDetails.OutputSig[i].stream > 0)
{
multipleStreams = true;
break;
}
}
foreach (var s in m_ShaderDetails.OutputSig)
{
string name = s.varName == "" ? s.semanticName : String.Format("{0} ({1})", s.varName, s.semanticName);
if (multipleStreams)
{
name = String.Format("Stream {0} : {1}", s.stream, name);
}
var node = outSig.Nodes.Add(new object[] { name, s.semanticIndex, s.regIndex, s.TypeString, s.systemValue.ToString(),
SigParameter.GetComponentString(s.regChannelMask), SigParameter.GetComponentString(s.channelUsedMask) });
}
}
else
{
inSigBox.Visible = false;
outSigBox.Visible = false;
m_DisassemblyView.Margins.Margin1.Width = 20;
m_DisassemblyView.Margins.Margin2.Width = 0;
m_DisassemblyView.Margins.Margin3.Width = 20;
m_DisassemblyView.Margins.Margin3.IsMarkerMargin = true;
m_DisassemblyView.Margins.Margin3.IsFoldMargin = false;
m_DisassemblyView.Margins.Margin3.Type = ScintillaNET.MarginType.Symbol;
m_DisassemblyView.Margins.Margin1.Mask = (int)m_DisassemblyView.Markers[BREAKPOINT_MARKER + 1].Mask;
m_DisassemblyView.Margins.Margin3.Mask &= ~((int)m_DisassemblyView.Markers[BREAKPOINT_MARKER + 1].Mask);
m_DisassemblyView.KeyDown += new KeyEventHandler(scintilla1_DebuggingKeyDown);
watchRegs.Items.Add(new ListViewItem(new string[] { "", "", "" }));
}
CurrentStep = 0;
this.ResumeLayout(false);
}
public String GetShaderEntryPoint(ShaderStageType stage)
{
if (LogLoaded && IsLogVK)
{
switch (stage)
{
case ShaderStageType.Vertex: return m_Vulkan.VS.entryPoint;
case ShaderStageType.Tess_Control: return m_Vulkan.TCS.entryPoint;
case ShaderStageType.Tess_Eval: return m_Vulkan.TES.entryPoint;
case ShaderStageType.Geometry: return m_Vulkan.GS.entryPoint;
case ShaderStageType.Fragment: return m_Vulkan.FS.entryPoint;
case ShaderStageType.Compute: return m_Vulkan.CS.entryPoint;
}
}
return "";
}
