def get_vsin(self,
draw: rd.DrawcallDescription,
first_index: int = 0,
num_indices: int = 0,
instance: int = 0,
view: int = 0):
ib: rd.BoundVBuffer = self.controller.GetPipelineState().GetIBuffer()
if num_indices == 0:
num_indices = draw.numIndices
else:
num_indices = min(num_indices, draw.numIndices)
mesh = rd.MeshFormat()
mesh.numIndices = num_indices
mesh.indexByteOffset = ib.byteOffset + draw.indexOffset * draw.indexByteWidth
mesh.indexByteStride = draw.indexByteWidth
mesh.indexResourceId = ib.resourceId
mesh.baseVertex = draw.baseVertex
attrs = analyse.get_vsin_attrs(self.controller, mesh)
first_index = min(first_index, draw.numIndices - 1)
indices = analyse.fetch_indices(self.controller, mesh, 0, first_index,
num_indices)
return analyse.decode_mesh_data(self.controller, indices, attrs, 0)
def get_vsin(self, action: rd.ActionDescription, first_index: int=0, num_indices: int=0, instance: int=0, view: int=0):
ib: rd.BoundVBuffer = self.controller.GetPipelineState().GetIBuffer()
if num_indices == 0:
num_indices = action.numIndices
else:
num_indices = min(num_indices, action.numIndices)
ioffs = action.indexOffset * ib.byteStride
mesh = rd.MeshFormat()
mesh.numIndices = num_indices
mesh.indexByteOffset = ib.byteOffset + ioffs
mesh.indexByteStride = ib.byteStride
mesh.indexResourceId = ib.resourceId
mesh.baseVertex = action.baseVertex
if ib.byteSize > ioffs:
mesh.indexByteSize = ib.byteSize - ioffs
else:
mesh.indexByteSize = 0
if not (action.flags & rd.ActionFlags.Indexed):
mesh.indexByteOffset = 0
mesh.indexByteStride = 0
mesh.indexResourceId = rd.ResourceId.Null()
attrs = analyse.get_vsin_attrs(self.controller, action.vertexOffset, mesh)
first_index = min(first_index, action.numIndices-1)
indices = analyse.fetch_indices(self.controller, action, mesh, 0, first_index, num_indices)
return analyse.decode_mesh_data(self.controller, indices, indices, attrs, 0, 0)
def vert_debug(self, draw: rd.DrawcallDescription):
pipe: rd.PipeState = self.controller.GetPipelineState()
if pipe.GetShader(rd.ShaderStage.Vertex) == rd.ResourceId.Null():
rdtest.log.print("No vertex shader bound at {}: {}".format(
draw.eventId, draw.name))
return
if not (draw.flags & rd.DrawFlags.Drawcall):
rdtest.log.print("{}: {} is not a debuggable drawcall".format(
draw.eventId, draw.name))
return
vtx = int(random.random() * draw.numIndices)
inst = 0
idx = vtx
if draw.numIndices == 0:
rdtest.log.print("Empty drawcall (0 vertices), skipping")
return
if draw.flags & rd.DrawFlags.Instanced:
inst = int(random.random() * draw.numInstances)
if draw.numInstances == 0:
rdtest.log.print("Empty drawcall (0 instances), skipping")
return
if draw.flags & rd.DrawFlags.Indexed:
ib = pipe.GetIBuffer()
mesh = rd.MeshFormat()
mesh.indexResourceId = ib.resourceId
mesh.indexByteStride = draw.indexByteWidth
mesh.indexByteOffset = ib.byteOffset + draw.indexOffset * draw.indexByteWidth
mesh.baseVertex = draw.baseVertex
indices = rdtest.fetch_indices(self.controller, mesh, 0, vtx, 1)
if len(indices) < 1:
rdtest.log.print("No index buffer, skipping")
return
idx = indices[0]
rdtest.log.print("Debugging vtx %d idx %d (inst %d)" %
(vtx, idx, inst))
trace = self.controller.DebugVertex(vtx, inst, idx,
draw.instanceOffset,
draw.vertexOffset)
rdtest.log.success('Successfully debugged vertex in {} cycles'.format(
len(trace.states)))
def get_postvs(self,
action: rd.ActionDescription,
data_stage: rd.MeshDataStage,
first_index: int = 0,
num_indices: int = 0,
instance: int = 0,
view: int = 0):
mesh: rd.MeshFormat = self.controller.GetPostVSData(
instance, view, data_stage)
if mesh.numIndices == 0:
return []
if num_indices == 0:
num_indices = mesh.numIndices
else:
num_indices = min(num_indices, mesh.numIndices)
first_index = min(first_index, mesh.numIndices - 1)
ib: rd.BoundVBuffer = self.controller.GetPipelineState().GetIBuffer()
ioffs = action.indexOffset * ib.byteStride
in_mesh = rd.MeshFormat()
in_mesh.numIndices = num_indices
in_mesh.indexByteOffset = ib.byteOffset + ioffs
in_mesh.indexByteStride = ib.byteStride
in_mesh.indexResourceId = ib.resourceId
in_mesh.baseVertex = action.baseVertex
if ib.byteSize > ioffs:
in_mesh.indexByteSize = ib.byteSize - ioffs
else:
in_mesh.indexByteSize = 0
if not (action.flags & rd.ActionFlags.Indexed):
in_mesh.indexByteOffset = 0
in_mesh.indexByteStride = 0
in_mesh.indexResourceId = rd.ResourceId.Null()
indices = analyse.fetch_indices(self.controller, action, mesh, 0,
first_index, num_indices)
in_indices = analyse.fetch_indices(self.controller, action, in_mesh, 0,
first_index, num_indices)
attrs = analyse.get_postvs_attrs(self.controller, mesh, data_stage)
return analyse.decode_mesh_data(self.controller, indices, in_indices,
attrs, 0, mesh.baseVertex)
def vert_debug(self, draw: rd.DrawcallDescription):
pipe: rd.PipeState = self.controller.GetPipelineState()
refl: rd.ShaderReflection = pipe.GetShaderReflection(rd.ShaderStage.Vertex)
if pipe.GetShader(rd.ShaderStage.Vertex) == rd.ResourceId.Null():
rdtest.log.print("No vertex shader bound at {}: {}".format(draw.eventId, draw.name))
return
if not (draw.flags & rd.DrawFlags.Drawcall):
rdtest.log.print("{}: {} is not a debuggable drawcall".format(draw.eventId, draw.name))
return
vtx = int(random.random()*draw.numIndices)
inst = 0
idx = vtx
if draw.numIndices == 0:
rdtest.log.print("Empty drawcall (0 vertices), skipping")
return
if draw.flags & rd.DrawFlags.Instanced:
inst = int(random.random()*draw.numInstances)
if draw.numInstances == 0:
rdtest.log.print("Empty drawcall (0 instances), skipping")
return
if draw.flags & rd.DrawFlags.Indexed:
ib = pipe.GetIBuffer()
mesh = rd.MeshFormat()
mesh.indexResourceId = ib.resourceId
mesh.indexByteStride = ib.byteStride
mesh.indexByteOffset = ib.byteOffset + draw.indexOffset * ib.byteStride
mesh.indexByteSize = ib.byteSize
mesh.baseVertex = draw.baseVertex
indices = rdtest.fetch_indices(self.controller, draw, mesh, 0, vtx, 1)
if len(indices) < 1:
rdtest.log.print("No index buffer, skipping")
return
idx = indices[0]
striprestart_index = pipe.GetStripRestartIndex() & ((1 << (ib.byteStride*8)) - 1)
if pipe.IsStripRestartEnabled() and idx == striprestart_index:
return
rdtest.log.print("Debugging vtx %d idx %d (inst %d)" % (vtx, idx, inst))
postvs = self.get_postvs(draw, rd.MeshDataStage.VSOut, first_index=vtx, num_indices=1, instance=inst)
trace: rd.ShaderDebugTrace = self.controller.DebugVertex(vtx, inst, idx, 0)
if trace.debugger is None:
self.controller.FreeTrace(trace)
rdtest.log.print("No debug result")
return
cycles, variables = self.process_trace(trace)
outputs = 0
for var in trace.sourceVars:
var: rd.SourceVariableMapping
if var.variables[0].type == rd.DebugVariableType.Variable and var.signatureIndex >= 0:
name = var.name
if name not in postvs[0].keys():
raise rdtest.TestFailureException("Don't have expected output for {}".format(name))
expect = postvs[0][name]
value = self.evaluate_source_var(var, variables)
if len(expect) != value.columns:
raise rdtest.TestFailureException(
"Output {} at EID {} has different size ({} values) to expectation ({} values)"
.format(name, draw.eventId, value.columns, len(expect)))
compType = rd.VarTypeCompType(value.type)
if compType == rd.CompType.UInt:
debugged = list(value.value.u32v[0:value.columns])
elif compType == rd.CompType.SInt:
debugged = list(value.value.s32v[0:value.columns])
else:
debugged = list(value.value.f32v[0:value.columns])
# For now, ignore debugged values that are uninitialised. This is an application bug but it causes false
# reports of problems
for comp in range(4):
if value.value.u32v[comp] == 0xcccccccc:
debugged[comp] = expect[comp]
# Unfortunately we can't ever trust that we should get back a matching results, because some shaders
# rely on undefined/inaccurate maths that we don't emulate.
# So the best we can do is log an error for manual verification
is_eq, diff_amt = rdtest.value_compare_diff(expect, debugged, eps=5.0E-06)
if not is_eq:
rdtest.log.error(
"Debugged value {} at EID {} vert {} (idx {}) instance {}: {} difference. {} doesn't exactly match postvs output {}".format(
name, draw.eventId, vtx, idx, inst, diff_amt, debugged, expect))
outputs = outputs + 1
rdtest.log.success('Successfully debugged vertex in {} cycles, {}/{} outputs match'
.format(cycles, outputs, len(refl.outputSignature)))
self.controller.FreeTrace(trace)
