def check_capture(self): # Make an output so we can pick pixels out: rd.ReplayOutput = self.controller.CreateOutput( rd.CreateHeadlessWindowingData(100, 100), rd.ReplayOutputType.Texture) self.check(out is not None) # find the first draw draw = self.find_draw("Draw") # check the centre pixel of the viewport is white self.controller.SetFrameEvent(draw.eventId, False) pipe: rd.PipeState = self.controller.GetPipelineState() tex = rd.TextureDisplay() tex.resourceId = pipe.GetOutputTargets()[0].resourceId out.SetTextureDisplay(tex) view: rd.Viewport = pipe.GetViewport(0) picked: rd.PixelValue = out.PickPixel(tex.resourceId, False, int(view.width / 2), int(view.height / 2), 0, 0, 0) if not rdtest.value_compare(picked.floatValue, [1.0, 1.0, 1.0, 1.0]): raise rdtest.TestFailureException( "Picked value {} doesn't match expectation".format( picked.floatValue)) rdtest.log.success("Picked value for first draw is as expected") # find the second draw draw = self.find_draw("Draw", draw.eventId + 1) pipe: rd.PipeState = self.controller.GetPipelineState() tex.resourceId = pipe.GetOutputTargets()[0].resourceId out.SetTextureDisplay(tex) view: rd.Viewport = pipe.GetViewport(0) picked: rd.PixelValue = out.PickPixel(tex.resourceId, False, int(view.width / 2), int(view.height / 2), 0, 0, 0) if not rdtest.value_compare(picked.floatValue, [1.0, 1.0, 1.0, 1.0]): raise rdtest.TestFailureException( "Picked value {} doesn't match expectation".format( picked.floatValue)) rdtest.log.success("Picked value for second draw is as expected")
def check_debug(self, vtx, idx, inst, postvs): trace: rd.ShaderDebugTrace = self.controller.DebugVertex(vtx, inst, idx, 0) if trace.debugger is None: self.controller.FreeTrace(trace) raise rdtest.TestFailureException("Couldn't debug vertex {} in instance {}".format(vtx, inst)) cycles, variables = self.process_trace(trace) 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[vtx].keys(): raise rdtest.TestFailureException("Don't have expected output for {}".format(name)) expect = postvs[vtx][name] value = self.evaluate_source_var(var, variables) if len(expect) != value.columns: raise rdtest.TestFailureException( "Output {} at vert {} (idx {}) instance {} has different size ({} values) to expectation ({} values)" .format(name, vtx, idx, inst, value.columns, len(expect))) debugged = value.value.f32v[0:value.columns] if not rdtest.value_compare(expect, debugged): raise rdtest.TestFailureException( "Debugged value {} at vert {} (idx {}) instance {}: {} doesn't exactly match postvs output {}".format( name, vtx, idx, inst, debugged, expect)) rdtest.log.success('Successfully debugged vertex {} in instance {}' .format(vtx, inst))
def check_vertex(self, x, y, result): pick = self.out.PickVertex(x, y) if not rdtest.value_compare(result, pick): raise rdtest.TestFailureException("When picking ({},{}) expected vertex {} in instance {}, but found {} in {}".format(x, y, result[0], result[1], pick[0], pick[1])) rdtest.log.success("Picking {},{} returns vertex {} in instance {} as expected".format(x, y, result[0], result[1]))
def check_capture(self): draw = self.find_draw("Draw") self.check(draw is not None) self.controller.SetFrameEvent(draw.eventId, False) pipe: rd.PipeState = self.controller.GetPipelineState() stage = rd.ShaderStage.Pixel cbuf: rd.BoundCBuffer = pipe.GetConstantBuffer(stage, 0, 0) variables = self.controller.GetCBufferVariableContents( pipe.GetGraphicsPipelineObject(), pipe.GetShader(stage), pipe.GetShaderEntryPoint(stage), 0, cbuf.resourceId, cbuf.byteOffset, cbuf.byteSize) outcol: rd.ShaderVariable = variables[1] self.check(outcol.name == "outcol") if not rdtest.value_compare(outcol.value.fv[0:4], [0.0, 0.0, 0.0, 0.0]): raise rdtest.TestFailureException( "expected outcol to be 0s, but got {}".format( outcol.value.fv[0:4])) rdtest.log.success("CBuffer value was truncated as expected")
def check_capture(self): draw = self.find_draw("Draw") self.check(draw is not None) self.controller.SetFrameEvent(draw.eventId, False) # Make an output so we can pick pixels out: rd.ReplayOutput = self.controller.CreateOutput(rd.CreateHeadlessWindowingData(100, 100), rd.ReplayOutputType.Texture) pipe: rd.PipeState = self.controller.GetPipelineState() tex = rd.TextureDisplay() tex.resourceId = pipe.GetOutputTargets()[0].resourceId out.SetTextureDisplay(tex) texdetails = self.get_texture(tex.resourceId) picked: rd.PixelValue = out.PickPixel(tex.resourceId, False, int(texdetails.width / 2), int(texdetails.height / 2), 0, 0, 0) if not rdtest.value_compare(picked.floatValue, [1.0, 0.0, 0.0, 1.0]): raise rdtest.TestFailureException("Picked value {} doesn't match expectation".format(picked.floatValue)) rdtest.log.success("picked value is as expected") out.Shutdown()
def check_modifs_consistent(self, modifs): # postmod of each should match premod of the next for i in range(len(modifs) - 1): a = value_selector(modifs[i].postMod.col) b = value_selector(modifs[i + 1].preMod.col) if self.is_depth: a = (modifs[i].postMod.depth, modifs[i].postMod.stencil) b = (modifs[i + 1].preMod.depth, modifs[i + 1].preMod.stencil) if a != b: raise rdtest.TestFailureException( "postmod at {} primitive {}: {} doesn't match premod at {} primitive {}: {}" .format(modifs[i].eventId, modifs[i].primitiveID, a, modifs[i + 1].eventId, modifs[i + 1].primitiveID, b)) # Check that if the test failed, its postmod is the same as premod for i in range(len(modifs)): if not modifs[i].Passed(): a = value_selector(modifs[i].preMod.col) b = value_selector(modifs[i].postMod.col) if self.is_depth: a = (modifs[i].preMod.depth, modifs[i].preMod.stencil) b = (modifs[i].postMod.depth, modifs[i].postMod.stencil) if not rdtest.value_compare(a, b): raise rdtest.TestFailureException( "postmod at {} primitive {}: {} doesn't match premod: {}" .format(modifs[i].eventId, modifs[i].primitiveID, b, a))
def check_val(self, picked, val, fmt): if type(val) != list: val = [val, val, val, val] if fmt.compType == rd.CompType.UInt or fmt.compType == rd.CompType.SInt: val = [int(a) for a in val] return rdtest.value_compare(picked.intValue[0:fmt.compCount], val[0:fmt.compCount]) else: comp_val = picked.floatValue[0:fmt.compCount] if fmt.compType == rd.CompType.Depth or fmt.type in [ rd.ResourceFormatType.D16S8, rd.ResourceFormatType.D24S8, rd.ResourceFormatType.D32S8 ]: comp_val = [min(1.0, a) for a in comp_val] return rdtest.value_compare(comp_val, val[0:fmt.compCount])
def check_capture(self): last_action: rd.ActionDescription = self.get_last_action() self.controller.SetFrameEvent(last_action.eventId, True) action: rd.ActionDescription = self.find_action('Duration') min_duration = float(action.customName.split(' = ')[1]) if rd.IsReleaseBuild(): if min_duration >= 15.0: raise rdtest.TestFailureException( "Minimum duration noted {} ms is too high".format( min_duration)) rdtest.log.success( "Minimum duration ({}) is OK".format(min_duration)) else: rdtest.log.print( "Not checking duration ({}) in non-release build".format( min_duration)) resources = self.controller.GetResources() for i in range(8): res: rd.ResourceDescription = [ r for r in resources if r.name == 'Offscreen{}'.format(i) ][0] tex: rd.TextureDescription = self.get_texture(res.resourceId) data = self.controller.GetTextureData(res.resourceId, rd.Subresource(0, 0, 0)) pixels = [ struct.unpack_from("4f", data, 16 * p) for p in range(tex.width * tex.height) ] unique_pixels = list(set(pixels)) if len(unique_pixels) > 2: raise rdtest.TestFailureException( "Too many pixel values found ({})".format( len(unique_pixels))) if (0.0, 0.0, 0.0, 1.0) not in unique_pixels: raise rdtest.TestFailureException( "Didn't find background colour in unique pixels list") unique_pixels.remove((0.0, 0.0, 0.0, 1.0)) if not rdtest.value_compare( (0.8, 0.8, 0.8, 0.4), unique_pixels[0]): raise rdtest.TestFailureException( "Didn't find foreground colour in unique pixels list") rdtest.log.success("{} has correct contents".format(res.name))
def sample(self, row, col): ret = [] for p in self.points: x = self.view[0] * col + p[0] y = self.view[1] * row + p[1] picked: rd.PixelValue = self.out.PickPixel(self.tex.resourceId, False, x, y, 0, 0, 0) ret.append( rdtest.value_compare(picked.floatValue, [0.0, 1.0, 1.0, 1.0])) return ret
def sample(self, row, col): ret = [] for p in self.points: x = self.view[0] * col + p[0] y = self.view[1] * row + p[1] picked: rd.PixelValue = self.controller.PickPixel( self.tex, x, y, rd.Subresource(0, 0, 0), rd.CompType.Typeless) ret.append( rdtest.value_compare(picked.floatValue, [0.0, 1.0, 1.0, 1.0])) return ret
def check_events(self, events, modifs): self.check(len(modifs) == len(events)) # Check for consistency first self.check_modifs_consistent(modifs) for i in range(len(modifs)): for c in range(len(events[i])): expected = events[i][c][1] actual = events[i][c][0](modifs[i]) if not rdtest.value_compare(actual, expected): raise rdtest.TestFailureException( "eventId {}, testing {} expected {}, got {}".format( modifs[i].eventId, events[i][c][0].__name__, expected, actual))
def check_events(self, events, modifs, hasSecondary): self.check(len(modifs) == len(events), "Expected {} events, got {}".format(len(events), len(modifs))) # Check for consistency first. For secondary command buffers, # might not have all information, so don't check for consistency if not hasSecondary: self.check_modifs_consistent(modifs) for i in range(len(modifs)): for c in range(len(events[i])): expected = events[i][c][1] actual = events[i][c][0](modifs[i]) if not rdtest.value_compare(actual, expected, eps=1.0/256.0): raise rdtest.TestFailureException( "eventId {}, primitiveID {}: testing {} expected {}, got {}".format(modifs[i].eventId, modifs[i].primitiveID, events[i][c][0].__name__, expected, actual))
def check_capture(self): # Jump to the draw draw = self.find_draw("Draw") self.controller.SetFrameEvent(draw.eventId, False) # Make an output so we can pick pixels out: rd.ReplayOutput = self.controller.CreateOutput( rd.CreateHeadlessWindowingData(100, 100), rd.ReplayOutputType.Texture) self.check(out is not None) pipe: rd.PipeState = self.controller.GetPipelineState() tex = rd.TextureDisplay() tex.resourceId = pipe.GetOutputTargets()[0].resourceId out.SetTextureDisplay(tex) # Loop over every test for test in range(draw.numInstances): # Pick the pixel picked: rd.PixelValue = out.PickPixel(tex.resourceId, False, 4 * test, 0, 0, 0, 0) # Debug the shader trace: rd.ShaderDebugTrace = self.controller.DebugPixel( 4 * test, 0, rd.ReplayController.NoPreference, rd.ReplayController.NoPreference) last_state: rd.ShaderDebugState = trace.states[-1] if not rdtest.value_compare(picked.floatValue, last_state.outputs[0].value.fv[0:4]): raise rdtest.TestFailureException( "Test {}: debugged output {} doesn't match actual output {}" .format(test, last_state.outputs[0].value.fv[0:4], picked.floatValue)) rdtest.log.success("Test {} matched as expected".format(test)) rdtest.log.success("All tests matched")
def check_modifs_consistent(self, modifs): # postmod of each should match premod of the next for i in range(len(modifs) - 1): if value_selector(modifs[i].postMod.col) != value_selector( modifs[i + 1].preMod.col): raise rdtest.TestFailureException( "postmod at {}: {} doesn't match premod at {}: {}".format( modifs[i].eventId, value_selector(modifs[i].postMod.col), modifs[i + 1].eventId, value_selector(modifs[i].preMod.col))) # Check that if the test failed, its postmod is the same as premod for i in range(len(modifs)): if not modifs[i].Passed(): if not rdtest.value_compare( value_selector(modifs[i].preMod.col), value_selector(modifs[i].postMod.col)): raise rdtest.TestFailureException( "postmod at {}: {} doesn't match premod: {}".format( modifs[i].eventId, value_selector(modifs[i].postMod.col), value_selector(modifs[i].preMod.col)))
def check_capture(self): draw = self.find_draw("vkCmdEndRenderPass") self.check(draw is not None) draw = draw.previous self.controller.SetFrameEvent(draw.eventId, False) pipe: rd.PipeState = self.controller.GetPipelineState() self.tex = pipe.GetOutputTargets()[0].resourceId texdetails = self.get_texture(self.tex) # Top left we expect a regular line segment. s = self.sample(0, 0) # All points should be the line color if not rdtest.value_compare(s, [True, True, True]): raise rdtest.TestFailureException( "Normal line picked values {} doesn't match expectation". format(s)) # Next row is unstippled. The lines should either be all present, or not present names = ["Rectangle", "Bresenham", "Rectangle Round"] for col in [0, 1, 2]: s = self.sample(1, col) n = "Unstippled {}".format(names[col]) if s[0]: if not rdtest.value_compare(s, [True, True, True]): raise rdtest.TestFailureException( "{} picked values {} doesn't match expectation".format( n, s)) rdtest.log.success("{} line looks as expected".format(n)) else: if not rdtest.value_compare(s, [False, False, False]): raise rdtest.TestFailureException( "{} picked values {} doesn't match expectation".format( n, s)) rdtest.log.success("{} line not supported".format(n)) # Final row is stippled. The lines should be present on each end, and not present in the middle # (or not present at all) for col in [0, 1, 2]: s = self.sample(2, col) n = "Stippled {}".format(names[col]) if s[0]: if not rdtest.value_compare(s, [True, False, True]): raise rdtest.TestFailureException( "{} picked values {} doesn't match expectation".format( n, s)) rdtest.log.success("{} line looks as expected".format(n)) else: if not rdtest.value_compare(s, [False, False, False]): raise rdtest.TestFailureException( "{} picked values {} doesn't match expectation".format( n, s)) rdtest.log.success("{} line not supported".format(n)) rdtest.log.success("All lines look as expected")
def pixel_debug(self, draw: rd.DrawcallDescription): pipe: rd.PipeState = self.controller.GetPipelineState() if pipe.GetShader(rd.ShaderStage.Pixel) == rd.ResourceId.Null(): rdtest.log.print("No pixel shader bound at {}: {}".format( draw.eventId, draw.name)) return if len(pipe.GetOutputTargets()) == 0 and pipe.GetDepthTarget( ).resourceId == rd.ResourceId.Null(): rdtest.log.print("No render targets 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 viewport = pipe.GetViewport(0) # TODO, query for some pixel this drawcall actually touched. x = int(random.random() * viewport.width + viewport.x) y = int(random.random() * viewport.height + viewport.y) target = rd.ResourceId.Null() if len(pipe.GetOutputTargets()) > 0: target = pipe.GetOutputTargets()[0].resourceId if target == rd.ResourceId.Null(): target = pipe.GetDepthTarget().resourceId if target == rd.ResourceId.Null(): rdtest.log.print( "No targets bound! Can't fetch history at {}".format( draw.eventId)) return rdtest.log.print("Fetching history for %d,%d on target %s" % (x, y, str(target))) history = self.controller.PixelHistory(target, x, y, 0, 0, 0, rd.CompType.Typeless) rdtest.log.success("Pixel %d,%d has %d history events" % (x, y, len(history))) lastmod: rd.PixelModification = None for i in range(len(history) - 1, 0, -1): mod = history[i] draw = self.find_draw('', mod.eventId) rdtest.log.print(" hit %d at %d is %s (%s)" % (i, mod.eventId, draw.name, str(draw.flags))) if draw is None or not (draw.flags & rd.DrawFlags.Drawcall): continue lastmod = history[i] rdtest.log.print("Got a hit on a drawcall at event %d" % lastmod.eventId) if mod.sampleMasked or mod.backfaceCulled or mod.depthClipped or mod.viewClipped or mod.scissorClipped or mod.depthTestFailed or mod.stencilTestFailed: rdtest.log.print( "This hit failed, looking for one that passed....") lastmod = None continue break if lastmod is not None: rdtest.log.print("Debugging pixel {},{} @ {}, primitve {}".format( x, y, lastmod.eventId, lastmod.primitiveID)) self.controller.SetFrameEvent(lastmod.eventId, True) trace = self.controller.DebugPixel(x, y, 0, lastmod.primitiveID) if draw.outputs[0] == rd.ResourceId.Null(): rdtest.log.success( 'Successfully debugged pixel in {} cycles, skipping result check due to no output' .format(len(trace.states))) elif draw.numInstances == 1: lastState: rd.ShaderDebugState = trace.states[-1] debugged: rd.ShaderVariable = lastState.outputs[0] debuggedValue = [ debugged.value.f.x, debugged.value.f.y, debugged.value.f.z, debugged.value.f.w ] if not rdtest.value_compare(lastmod.shaderOut.col.floatValue, [ debugged.value.f.x, debugged.value.f.y, debugged.value.f.z, debugged.value.f.w ]): raise rdtest.TestFailureException( "Debugged value {} doesn't match picked value {}". format(debuggedValue, lastmod.shaderOut.col.floatValue)) rdtest.log.success( 'Successfully debugged pixel in {} cycles, result matches'. format(len(trace.states))) else: rdtest.log.success( 'Successfully debugged pixel in {} cycles, skipping result check due to instancing' .format(len(trace.states))) self.controller.SetFrameEvent(draw.eventId, True)
def check_capture(self): draw = self.find_draw("Draw") self.check(draw is not None) self.controller.SetFrameEvent(draw.eventId, False) # Make an output so we can pick pixels out: rd.ReplayOutput = self.controller.CreateOutput(rd.CreateHeadlessWindowingData(100, 100), rd.ReplayOutputType.Texture) self.check(out is not None) ref = { 0: { 'SNorm': [1.0, -1.0, 1.0, -1.0], 'UNorm': [12345.0/65535.0, 6789.0/65535.0, 1234.0/65535.0, 567.0/65535.0], 'UScaled': [12345.0, 6789.0, 1234.0, 567.0], 'UInt': [12345, 6789, 1234, 567], 'Double': [9.8765432109, -5.6789012345], 'Array[0]': [1.0, 2.0], 'Array[1]': [3.0, 4.0], 'Array[2]': [5.0, 6.0], 'Matrix:row0': [7.0, 8.0], 'Matrix:row1': [9.0, 10.0], }, 1: { 'SNorm': [32766.0/32767.0, -32766.0/32767.0, 16000.0/32767.0, -16000.0/32767.0], 'UNorm': [56.0/65535.0, 7890.0/65535.0, 123.0/65535.0, 4567.0/65535.0], 'UScaled': [56.0, 7890.0, 123.0, 4567.0], 'UInt': [56, 7890, 123, 4567], 'Double': [-7.89012345678, 6.54321098765], 'Array[0]': [11.0, 12.0], 'Array[1]': [13.0, 14.0], 'Array[2]': [15.0, 16.0], 'Matrix:row0': [17.0, 18.0], 'Matrix:row1': [19.0, 20.0], }, 2: { 'SNorm': [5.0/32767.0, -5.0/32767.0, 0.0, 0.0], 'UNorm': [8765.0/65535.0, 43210.0/65535.0, 987.0/65535.0, 65432.0/65535.0], 'UScaled': [8765.0, 43210.0, 987.0, 65432.0], 'UInt': [8765, 43210, 987, 65432], 'Double': [0.1234567890123, 4.5678901234], 'Array[0]': [21.0, 22.0], 'Array[1]': [23.0, 24.0], 'Array[2]': [25.0, 26.0], 'Matrix:row0': [27.0, 28.0], 'Matrix:row1': [29.0, 30.0], }, } # Copy the ref values and prepend 'In' in_ref = {} for idx in ref: in_ref[idx] = {} for key in ref[idx]: in_ref[idx]['In' + key] = ref[idx][key] # Copy the ref values and prepend 'Out' out_ref = {} for idx in ref: out_ref[idx] = {} for key in ref[idx]: out_ref[idx]['Out' + key] = ref[idx][key] vsout_ref = copy.deepcopy(out_ref) gsout_ref = out_ref vsout_ref[0]['gl_PerVertex.gl_Position'] = [-0.5, 0.5, 0.0, 1.0] gsout_ref[0]['gl_PerVertex.gl_Position'] = [0.5, -0.5, 0.4, 1.2] vsout_ref[1]['gl_PerVertex.gl_Position'] = [0.0, -0.5, 0.0, 1.0] gsout_ref[1]['gl_PerVertex.gl_Position'] = [-0.5, 0.0, 0.4, 1.2] vsout_ref[2]['gl_PerVertex.gl_Position'] = [0.5, 0.5, 0.0, 1.0] gsout_ref[2]['gl_PerVertex.gl_Position'] = [0.5, 0.5, 0.4, 1.2] self.check_mesh_data(in_ref, self.get_vsin(draw)) rdtest.log.success("Vertex input data is as expected") self.check_mesh_data(vsout_ref, self.get_postvs(rd.MeshDataStage.VSOut)) rdtest.log.success("Vertex output data is as expected") # This is optional to account for drivers without XFB postgs_data = self.get_postvs(rd.MeshDataStage.GSOut) if len(postgs_data) > 0: self.check_mesh_data(gsout_ref, postgs_data) rdtest.log.success("Geometry output data is as expected") else: rdtest.log.print("Geometry output not tested") pipe: rd.PipeState = self.controller.GetPipelineState() tex = rd.TextureDisplay() tex.resourceId = pipe.GetOutputTargets()[0].resourceId out.SetTextureDisplay(tex) texdetails = self.get_texture(tex.resourceId) picked: rd.PixelValue = out.PickPixel(tex.resourceId, False, int(texdetails.width / 2), int(texdetails.height / 2), 0, 0, 0) if not rdtest.value_compare(picked.floatValue, [0.0, 1.0, 0.0, 1.0]): raise rdtest.TestFailureException("Picked value {} doesn't match expectation".format(picked.floatValue)) rdtest.log.success("Triangle picked value is as expected") out.Shutdown()
def check_capture(self): draw = self.find_draw("Draw") self.check(draw is not None) self.controller.SetFrameEvent(draw.eventId, False) # Make an output so we can pick pixels out: rd.ReplayOutput = self.controller.CreateOutput( rd.CreateHeadlessWindowingData(100, 100), rd.ReplayOutputType.Texture) self.check(out is not None) pipe: rd.PipeState = self.controller.GetPipelineState() stage = rd.ShaderStage.Pixel # Verify that the GLSL draw is first disasm = self.controller.DisassembleShader( pipe.GetGraphicsPipelineObject(), pipe.GetShaderReflection(stage), '') self.check('GLSL' in disasm) cbuf: rd.BoundCBuffer = pipe.GetConstantBuffer(stage, 0, 0) var_check = rdtest.ConstantBufferChecker( self.controller.GetCBufferVariableContents( pipe.GetShader(stage), pipe.GetShaderEntryPoint(stage), 0, cbuf.resourceId, cbuf.byteOffset)) # For more detailed reference for the below checks, see the commented definition of the cbuffer # in the shader source code in the demo itself # vec4 a; var_check.check('a').cols(4).rows(1).value([0.0, 1.0, 2.0, 3.0]) # vec3 b; var_check.check('b').cols(3).rows(1).value([4.0, 5.0, 6.0]) # vec2 c; vec2 d; var_check.check('c').cols(2).rows(1).value([8.0, 9.0]) var_check.check('d').cols(2).rows(1).value([10.0, 11.0]) # float e; vec3 f; var_check.check('e').cols(1).rows(1).value([12.0]) var_check.check('f').cols(3).rows(1).value([16.0, 17.0, 18.0]) # vec4 dummy0; var_check.check('dummy0') # float j; vec2 k; var_check.check('j').cols(1).rows(1).value([24.0]) var_check.check('k').cols(2).rows(1).value([26.0, 27.0]) # vec2 l; float m; var_check.check('l').cols(2).rows(1).value([28.0, 29.0]) var_check.check('m').cols(1).rows(1).value([30.0]) # float n[4]; var_check.check('n').cols(0).rows(0).arraySize(4).members({ 0: lambda x: x.cols(1).rows(1).value([32.0]), 1: lambda x: x.cols(1).rows(1).value([36.0]), 2: lambda x: x.cols(1).rows(1).value([40.0]), 3: lambda x: x.cols(1).rows(1).value([44.0]), }) # vec4 dummy1; var_check.check('dummy1') # float o[4]; var_check.check('o').cols(0).rows(0).arraySize(4).members({ 0: lambda x: x.cols(1).rows(1).value([52.0]), 1: lambda x: x.cols(1).rows(1).value([56.0]), 2: lambda x: x.cols(1).rows(1).value([60.0]), 3: lambda x: x.cols(1).rows(1).value([64.0]), }) # float p; var_check.check('p').cols(1).rows(1).value([68.0]) # vec4 dummy2; var_check.check('dummy2') # column_major vec4x4 q; var_check.check('q').cols(4).rows(4).column_major().value([ 76.0, 80.0, 84.0, 88.0, 77.0, 81.0, 85.0, 89.0, 78.0, 82.0, 86.0, 90.0, 79.0, 83.0, 87.0, 91.0 ]) # row_major vec4x4 r; var_check.check('r').cols(4).rows(4).row_major().value([ 92.0, 93.0, 94.0, 95.0, 96.0, 97.0, 98.0, 99.0, 100.0, 101.0, 102.0, 103.0 ]) # column_major vec4x3 s; var_check.check('s').cols(4).rows(3).column_major().value([ 108.0, 112.0, 116.0, 120.0, 109.0, 113.0, 117.0, 121.0, 110.0, 114.0, 118.0, 122.0 ]) # vec4 dummy3; var_check.check('dummy3') # row_major vec4x3 t; var_check.check('t').cols(4).rows(3).row_major().value([ 128.0, 129.0, 130.0, 131.0, 132.0, 133.0, 134.0, 135.0, 136.0, 137.0, 138.0, 139.0 ]) # vec4 dummy4; var_check.check('dummy4') # column_major vec2x3 u; var_check.check('u').cols(3).rows(2).column_major().value( [144.0, 148.0, 152.0, 145.0, 149.0, 153.0]) # vec4 dummy5; var_check.check('dummy5') # row_major vec3x2 v; var_check.check('v').cols(3).rows(2).row_major().value( [160.0, 161.0, 162.0, 164.0, 165.0, 166.0]) # vec4 dummy6; var_check.check('dummy6') # column_major vec3x2 w; var_check.check('w').cols(2).rows(2).column_major().value( [172.0, 176.0, 173.0, 177.0]) # vec4 dummy7; var_check.check('dummy7') # row_major vec3x2 x; var_check.check('x').cols(2).rows(2).row_major().value( [184.0, 185.0, 188.0, 189.0]) # vec4 dummy8; var_check.check('dummy8') # row_major vec2x2 y; var_check.check('y').cols(2).rows(2).row_major().value( [196.0, 197.0, 200.0, 201.0]) # float z; var_check.check('z').cols(1).rows(1).value([204.0]) # vec4 dummy9; var_check.check('dummy9') # vec4 multiarray[3][2]; var_check.check('multiarray').cols(0).rows(0).arraySize(3).members({ 0: lambda x: x.cols(0).rows(0).arraySize(2).members({ 0: lambda y: y.cols(4).rows(1).value([228.0, 229.0, 230.0, 231.0] ), 1: lambda y: y.cols(4).rows(1).value([232.0, 233.0, 234.0, 235.0] ), }), 1: lambda x: x.cols(0).rows(0).arraySize(2).members({ 0: lambda y: y.cols(4).rows(1).value([236.0, 237.0, 238.0, 239.0] ), 1: lambda y: y.cols(4).rows(1).value([240.0, 241.0, 242.0, 243.0] ), }), 2: lambda x: x.cols(0).rows(0).arraySize(2).members({ 0: lambda y: y.cols(4).rows(1).value([244.0, 245.0, 246.0, 247.0] ), 1: lambda y: y.cols(4).rows(1).value([248.0, 249.0, 250.0, 251.0] ), }), }) # struct vec3_1 { vec3 a; float b; }; # struct nested { vec3_1 a; vec4 b[4]; vec3_1 c[4]; }; # nested structa[2]; var_check.check('structa').cols(0).rows(0).arraySize(2).members({ # structa[0] 0: lambda s: s.cols(0).rows(0).structSize(3).members({ 'a': lambda x: x.cols(0).rows(0).structSize(2).members({ 'a': lambda y: y.cols(3).rows(1).value([252.0, 253.0, 254.0]), 'b': lambda y: y.cols(1).rows(1).value([255.0]), }), 'b': lambda x: x.cols(0).rows(0).arraySize(4).members({ 0: lambda y: y.cols(4).rows(1).value( [256.0, 257.0, 258.0, 259.0]), 1: lambda y: y.cols(4).rows(1).value( [260.0, 261.0, 262.0, 263.0]), 2: lambda y: y.cols(4).rows(1).value( [264.0, 265.0, 266.0, 267.0]), 3: lambda y: y.cols(4).rows(1).value( [268.0, 269.0, 270.0, 271.0]), }), 'c': lambda x: x.cols(0).rows(0).arraySize(4).members({ 0: lambda y: y.cols(0).rows(0).structSize(2).members({ 'a': lambda z: z.cols(3).rows(1).value( [272.0, 273.0, 274.0]), 'b': lambda z: z.cols(1).rows(1).value([275.0]), }), 1: lambda y: y.cols(0).rows(0).structSize(2).members({ 'a': lambda z: z.cols(3).rows(1).value( [276.0, 277.0, 278.0]), 'b': lambda z: z.cols(1).rows(1).value([279.0]), }), 2: lambda y: y.cols(0).rows(0).structSize(2).members({ 'a': lambda z: z.cols(3).rows(1).value( [280.0, 281.0, 282.0]), 'b': lambda z: z.cols(1).rows(1).value([283.0]), }), 3: lambda y: y.cols(0).rows(0).structSize(2).members({ 'a': lambda z: z.cols(3).rows(1).value( [284.0, 285.0, 286.0]), 'b': lambda z: z.cols(1).rows(1).value([287.0]), }), }), }), # structa[1] 1: lambda s: s.cols(0).rows(0).structSize(3).members({ 'a': lambda x: x.cols(0).rows(0).structSize(2).members({ 'a': lambda y: y.cols(3).rows(1).value([288.0, 289.0, 290.0]), 'b': lambda y: y.cols(1).rows(1).value([291.0]), }), 'b': lambda x: x.cols(0).rows(0).arraySize(4).members({ 0: lambda y: y.cols(4).rows(1).value( [292.0, 293.0, 294.0, 295.0]), 1: lambda y: y.cols(4).rows(1).value( [296.0, 297.0, 298.0, 299.0]), 2: lambda y: y.cols(4).rows(1).value( [300.0, 301.0, 302.0, 303.0]), 3: lambda y: y.cols(4).rows(1).value( [304.0, 305.0, 306.0, 307.0]), }), 'c': lambda x: x.cols(0).rows(0).arraySize(4).members({ 0: lambda y: y.cols(0).rows(0).structSize(2).members({ 'a': lambda z: z.cols(3).rows(1).value( [308.0, 309.0, 310.0]), 'b': lambda z: z.cols(1).rows(1).value([311.0]), }), 1: lambda y: y.cols(0).rows(0).structSize(2).members({ 'a': lambda z: z.cols(3).rows(1).value( [312.0, 313.0, 314.0]), 'b': lambda z: z.cols(1).rows(1).value([315.0]), }), 2: lambda y: y.cols(0).rows(0).structSize(2).members({ 'a': lambda z: z.cols(3).rows(1).value( [316.0, 317.0, 318.0]), 'b': lambda z: z.cols(1).rows(1).value([319.0]), }), 3: lambda y: y.cols(0).rows(0).structSize(2).members({ 'a': lambda z: z.cols(3).rows(1).value( [320.0, 321.0, 322.0]), 'b': lambda z: z.cols(1).rows(1).value([323.0]), }), }), }), }) # column_major mat2x3 ac; var_check.check('ac').cols(2).rows(3).column_major().value( [324.0, 328.0, 325.0, 329.0, 326.0, 330.0]) # row_major mat2x3 ad; var_check.check('ad').cols(2).rows(3).row_major().value( [332.0, 333.0, 336.0, 337.0, 340.0, 341.0]) # column_major mat2x3 ae[2]; var_check.check('ae').cols(0).rows(0).arraySize(2).members({ 0: lambda x: x.cols(2).rows(3).column_major().value( [344.0, 348.0, 345.0, 349.0, 346.0, 350.0]), 1: lambda x: x.cols(2).rows(3).column_major().value( [352.0, 356.0, 353.0, 357.0, 354.0, 358.0]), }) # row_major mat2x3 af[2]; var_check.check('af').cols(0).rows(0).arraySize(2).members({ 0: lambda x: x.cols(2).rows(3).row_major().value( [360.0, 361.0, 364.0, 365.0, 368.0, 369.0]), 1: lambda x: x.cols(2).rows(3).row_major().value( [372.0, 373.0, 376.0, 377.0, 380.0, 381.0]), }) # vec2 dummy10; var_check.check('dummy10') # row_major mat2x2 ag; var_check.check('ag').cols(2).rows(2).row_major().value( [388.0, 389.0, 392.0, 393.0]) # vec2 dummy11; var_check.check('dummy11') # column_major mat2x2 ah; var_check.check('ah').cols(2).rows(2).column_major().value( [400.0, 404.0, 401.0, 405.0]) # row_major mat2x2 ai[2]; var_check.check('ai').rows(0).cols(0).arraySize(2).members({ 0: lambda x: x.cols(2).rows(2).row_major().value( [408.0, 409.0, 412.0, 413.0]), 1: lambda x: x.cols(2).rows(2).row_major().value( [416.0, 417.0, 420.0, 421.0]), }) # column_major mat2x2 aj[2]; var_check.check('aj').rows(0).cols(0).arraySize(2).members({ 0: lambda x: x.cols(2).rows(2).column_major().value( [424.0, 428.0, 425.0, 429.0]), 1: lambda x: x.cols(2).rows(2).column_major().value( [432.0, 436.0, 433.0, 437.0]), }) # vec4 test; var_check.check('test').rows(1).cols(4).value( [440.0, 441.0, 442.0, 443.0]) var_check.done() rdtest.log.success("GLSL CBuffer variables are as expected") tex = rd.TextureDisplay() tex.resourceId = pipe.GetOutputTargets()[0].resourceId out.SetTextureDisplay(tex) texdetails = self.get_texture(tex.resourceId) picked: rd.PixelValue = out.PickPixel(tex.resourceId, False, int(texdetails.width / 2), int(texdetails.height / 2), 0, 0, 0) if not rdtest.value_compare(picked.floatValue, [440.1, 441.0, 442.0, 443.0]): raise rdtest.TestFailureException( "Picked value {} doesn't match expectation".format( picked.floatValue)) rdtest.log.success("GLSL picked value is as expected") # Check the specialization constants cbuf: rd.BoundCBuffer = pipe.GetConstantBuffer(stage, 1, 0) var_check = rdtest.ConstantBufferChecker( self.controller.GetCBufferVariableContents( pipe.GetShader(stage), pipe.GetShaderEntryPoint(stage), 1, cbuf.resourceId, cbuf.byteOffset)) # int A; # Default value 10, untouched var_check.check('A').type(rd.VarType.SInt).rows(1).cols(1).value([10]) # float B; # Value 20 from spec constants var_check.check('B').type(rd.VarType.Float).rows(1).cols(1).value( [20.0]) # bool C; # Value True from spec constants var_check.check('C').type(rd.VarType.UInt).rows(1).cols(1).value([1]) var_check.done() rdtest.log.success("Specialization constants are as expected") # Move to the HLSL draw draw = draw.next self.check(draw is not None) self.controller.SetFrameEvent(draw.eventId, False) pipe: rd.PipeState = self.controller.GetPipelineState() # Verify that this is the HLSL draw disasm = self.controller.DisassembleShader( pipe.GetGraphicsPipelineObject(), pipe.GetShaderReflection(stage), '') self.check('HLSL' in disasm) cbuf: rd.BoundCBuffer = pipe.GetConstantBuffer(stage, 0, 0) var_check = rdtest.ConstantBufferChecker( self.controller.GetCBufferVariableContents( pipe.GetShader(stage), pipe.GetShaderEntryPoint(stage), 0, cbuf.resourceId, cbuf.byteOffset)) # For more detailed reference for the below checks, see the commented definition of the cbuffer # in the shader source code in the demo itself # float4 a; var_check.check('a').rows(1).cols(4).value([0.0, 1.0, 2.0, 3.0]) # float3 b; var_check.check('b').rows(1).cols(3).value([4.0, 5.0, 6.0]) # float2 c; float2 d; var_check.check('c').rows(1).cols(2).value([8.0, 9.0]) var_check.check('d').rows(1).cols(2).value([10.0, 11.0]) # float e; float3 f; var_check.check('e').rows(1).cols(1).value([12.0]) var_check.check('f').rows(1).cols(3).value([13.0, 14.0, 15.0]) # float g; float2 h; float i; var_check.check('g').rows(1).cols(1).value([16.0]) var_check.check('h').rows(1).cols(2).value([17.0, 18.0]) var_check.check('i').rows(1).cols(1).value([19.0]) # float j; float2 k; var_check.check('j').rows(1).cols(1).value([20.0]) var_check.check('k').rows(1).cols(2).value([21.0, 22.0]) # float2 l; float m; var_check.check('l').rows(1).cols(2).value([24.0, 25.0]) var_check.check('m').rows(1).cols(1).value([26.0]) # float n[4]; var_check.check('n').rows(0).cols(0).arraySize(4).members({ 0: lambda x: x.rows(1).cols(1).value([28.0]), 1: lambda x: x.rows(1).cols(1).value([32.0]), 2: lambda x: x.rows(1).cols(1).value([36.0]), 3: lambda x: x.rows(1).cols(1).value([40.0]), }) # float4 dummy1; var_check.check('dummy1') # float o[4]; var_check.check('o').rows(0).cols(0).arraySize(4).members({ 0: lambda x: x.rows(1).cols(1).value([48.0]), 1: lambda x: x.rows(1).cols(1).value([52.0]), 2: lambda x: x.rows(1).cols(1).value([56.0]), 3: lambda x: x.rows(1).cols(1).value([60.0]), }) # float p; with std140 vulkan packing var_check.check('p').rows(1).cols(1).value([64.0]) # float4 dummy2; var_check.check('dummy2') # float4 gldummy; var_check.check('gldummy') # HLSL majorness is flipped to match column-major SPIR-V with row-major HLSL. # This means column major declared matrices will show up as row major in any reflection and SPIR-V # it also means that dimensions are flipped, so a float3x4 is declared as a float4x3, and a 'row' # is really a column, and vice-versa a 'column' is really a row. # column_major float4x4 q; var_check.check('q').rows(4).cols(4).row_major().value([ 76.0, 77.0, 78.0, 79.0, 80.0, 81.0, 82.0, 83.0, 84.0, 85.0, 86.0, 87.0, 88.0, 89.0, 90.0, 91.0 ]) # row_major float4x4 r; var_check.check('r').rows(4).cols(4).column_major().value([ 92.0, 96.0, 100.0, 104.0, 93.0, 97.0, 101.0, 105.0, 94.0, 98.0, 102.0, 106.0, 95.0, 99.0, 103.0, 107.0 ]) # column_major float3x4 s; var_check.check('s').rows(4).cols(3).row_major().value([ 108.0, 109.0, 110.0, 112.0, 113.0, 114.0, 116.0, 117.0, 118.0, 120.0, 121.0, 122.0 ]) # float4 dummy3; var_check.check('dummy3') # row_major float3x4 t; var_check.check('t').rows(4).cols(3).column_major().value([ 128.0, 132.0, 136.0, 129.0, 133.0, 137.0, 130.0, 134.0, 138.0, 131.0, 135.0, 139.0 ]) # float4 dummy4; var_check.check('dummy4') # column_major float2x3 u; var_check.check('u').rows(3).cols(2).row_major().value( [144.0, 145.0, 148.0, 149.0, 152.0, 153.0]) # float4 dummy5; var_check.check('dummy5') # row_major float2x3 v; var_check.check('v').rows(3).cols(2).column_major().value( [160.0, 164.0, 161.0, 165.0, 162.0, 166.0]) # float4 dummy6; var_check.check('dummy6') # column_major float2x2 w; var_check.check('w').rows(2).cols(2).row_major().value( [172.0, 173.0, 176.0, 177.0]) # float4 dummy7; var_check.check('dummy7') # row_major float2x2 x; var_check.check('x').rows(2).cols(2).column_major().value( [184.0, 188.0, 185.0, 189.0]) # float4 dummy8; var_check.check('dummy8') # row_major float2x2 y; var_check.check('y').rows(2).cols(2).column_major().value( [196.0, 200.0, 197.0, 201.0]) # float z; var_check.check('z').rows(1).cols(1).value([204.0]) # Temporarily until SPIR-V support for degenerate HLSL matrices is determined var_check.check('dummy9') # row_major float4x1 aa; #var_check.check('aa').rows(1).cols(4).value([208.0, 212.0, 216.0, 220.0]) # column_major float4x1 ab; #var_check.check('ab').rows(1).cols(4).value([224.0, 225.0, 226.0, 227.0]) # float4 multiarray[3][2]; var_check.check('multiarray').cols(0).rows(0).arraySize(3).members({ 0: lambda x: x.cols(0).rows(0).arraySize(2).members({ 0: lambda y: y.cols(4).rows(1).value([228.0, 229.0, 230.0, 231.0] ), 1: lambda y: y.cols(4).rows(1).value([232.0, 233.0, 234.0, 235.0] ), }), 1: lambda x: x.cols(0).rows(0).arraySize(2).members({ 0: lambda y: y.cols(4).rows(1).value([236.0, 237.0, 238.0, 239.0] ), 1: lambda y: y.cols(4).rows(1).value([240.0, 241.0, 242.0, 243.0] ), }), 2: lambda x: x.cols(0).rows(0).arraySize(2).members({ 0: lambda y: y.cols(4).rows(1).value([244.0, 245.0, 246.0, 247.0] ), 1: lambda y: y.cols(4).rows(1).value([248.0, 249.0, 250.0, 251.0] ), }), }) # struct float3_1 { float3 a; float b; }; # struct nested { float3_1 a; float4 b[4]; float3_1 c[4]; }; # nested structa[2]; var_check.check('structa').rows(0).cols(0).arraySize(2).members({ # structa[0] 0: lambda s: s.rows(0).cols(0).structSize(3).members({ 'a': lambda x: x.rows(0).cols(0).structSize(2).members({ 'a': lambda y: y.rows(1).cols(3).value([252.0, 253.0, 254.0]), 'b': lambda y: y.rows(1).cols(1).value([255.0]), }), 'b': lambda x: x.rows(0).cols(0).arraySize(4).members({ 0: lambda y: y.rows(1).cols(4).value( [256.0, 257.0, 258.0, 259.0]), 1: lambda y: y.rows(1).cols(4).value( [260.0, 261.0, 262.0, 263.0]), 2: lambda y: y.rows(1).cols(4).value( [264.0, 265.0, 266.0, 267.0]), 3: lambda y: y.rows(1).cols(4).value( [268.0, 269.0, 270.0, 271.0]), }), 'c': lambda x: x.rows(0).cols(0).arraySize(4).members({ 0: lambda y: y.rows(0).cols(0).structSize(2).members({ 'a': lambda z: z.rows(1).cols(3).value( [272.0, 273.0, 274.0]), 'b': lambda z: z.rows(1).cols(1).value([275.0]), }), 1: lambda y: y.rows(0).cols(0).structSize(2).members({ 'a': lambda z: z.rows(1).cols(3).value( [276.0, 277.0, 278.0]), 'b': lambda z: z.rows(1).cols(1).value([279.0]), }), 2: lambda y: y.rows(0).cols(0).structSize(2).members({ 'a': lambda z: z.rows(1).cols(3).value( [280.0, 281.0, 282.0]), 'b': lambda z: z.rows(1).cols(1).value([283.0]), }), 3: lambda y: y.rows(0).cols(0).structSize(2).members({ 'a': lambda z: z.rows(1).cols(3).value( [284.0, 285.0, 286.0]), 'b': lambda z: z.rows(1).cols(1).value([287.0]), }), }), }), # structa[1] 1: lambda s: s.rows(0).cols(0).structSize(3).members({ 'a': lambda x: x.rows(0).cols(0).structSize(2).members({ 'a': lambda y: y.rows(1).cols(3).value([288.0, 289.0, 290.0]), 'b': lambda y: y.rows(1).cols(1).value([291.0]), }), 'b': lambda x: x.rows(0).cols(0).arraySize(4).members({ 0: lambda y: y.rows(1).cols(4).value( [292.0, 293.0, 294.0, 295.0]), 1: lambda y: y.rows(1).cols(4).value( [296.0, 297.0, 298.0, 299.0]), 2: lambda y: y.rows(1).cols(4).value( [300.0, 301.0, 302.0, 303.0]), 3: lambda y: y.rows(1).cols(4).value( [304.0, 305.0, 306.0, 307.0]), }), 'c': lambda x: x.rows(0).cols(0).arraySize(4).members({ 0: lambda y: y.rows(0).cols(0).structSize(2).members({ 'a': lambda z: z.rows(1).cols(3).value( [308.0, 309.0, 310.0]), 'b': lambda z: z.rows(1).cols(1).value([311.0]), }), 1: lambda y: y.rows(0).cols(0).structSize(2).members({ 'a': lambda z: z.rows(1).cols(3).value( [312.0, 313.0, 314.0]), 'b': lambda z: z.rows(1).cols(1).value([315.0]), }), 2: lambda y: y.rows(0).cols(0).structSize(2).members({ 'a': lambda z: z.rows(1).cols(3).value( [316.0, 317.0, 318.0]), 'b': lambda z: z.rows(1).cols(1).value([319.0]), }), 3: lambda y: y.rows(0).cols(0).structSize(2).members({ 'a': lambda z: z.rows(1).cols(3).value( [320.0, 321.0, 322.0]), 'b': lambda z: z.rows(1).cols(1).value([323.0]), }), }), }), }) # column_major float3x2 ac; var_check.check('ac').rows(2).cols(3).row_major().value( [324.0, 325.0, 326.0, 328.0, 329.0, 330.0]) # row_major float3x2 ad; var_check.check('ad').rows(2).cols(3).column_major().value( [332.0, 336.0, 340.0, 333.0, 337.0, 341.0]) # column_major float3x2 ae[2]; var_check.check('ae').rows(0).cols(0).arraySize(2).members({ 0: lambda x: x.rows(2).cols(3).row_major().value( [344.0, 345.0, 346.0, 348.0, 349.0, 350.0]), 1: lambda x: x.rows(2).cols(3).row_major().value( [352.0, 353.0, 354.0, 356.0, 357.0, 358.0]), }) # row_major float3x2 af[2]; var_check.check('af').rows(0).cols(0).arraySize(2).members({ 0: lambda x: x.rows(2).cols(3).column_major().value( [360.0, 364.0, 368.0, 361.0, 365.0, 369.0]), 1: lambda x: x.rows(2).cols(3).column_major().value( [372.0, 376.0, 380.0, 373.0, 377.0, 381.0]), }) # float2 dummy10; var_check.check('dummy10') # float2 dummy11; var_check.check('dummy11') # row_major float2x2 ag; var_check.check('ag').rows(2).cols(2).column_major().value( [388.0, 392.0, 389.0, 393.0]) # float2 dummy12; var_check.check('dummy12') # float2 dummy13; var_check.check('dummy13') # column_major float2x2 ah; var_check.check('ah').rows(2).cols(2).row_major().value( [400.0, 401.0, 404.0, 405.0]) # row_major float2x2 ai[2]; var_check.check('ai').rows(0).cols(0).arraySize(2).members({ 0: lambda x: x.rows(2).cols(2).column_major().value( [408.0, 412.0, 409.0, 413.0]), 1: lambda x: x.rows(2).cols(2).column_major().value( [416.0, 420.0, 417.0, 421.0]), }) # column_major float2x2 aj[2]; var_check.check('aj').rows(0).cols(0).arraySize(2).members({ 0: lambda x: x.rows(2).cols(2).row_major().value( [424.0, 425.0, 428.0, 429.0]), 1: lambda x: x.rows(2).cols(2).row_major().value( [432.0, 433.0, 436.0, 437.0]), }) # float4 test; var_check.check('test').rows(1).cols(4).value( [440.0, 441.0, 442.0, 443.0]) var_check.done() rdtest.log.success("HLSL CBuffer variables are as expected") picked: rd.PixelValue = out.PickPixel(tex.resourceId, False, int(texdetails.width / 2), int(texdetails.height / 2), 0, 0, 0) if not rdtest.value_compare(picked.floatValue, [440.1, 441.0, 442.0, 443.0]): raise rdtest.TestFailureException( "Picked value {} doesn't match expectation".format( picked.floatValue)) rdtest.log.success("HLSL picked value is as expected") out.Shutdown()
def check_capture(self): # find the first draw draw = self.find_draw("Draw") # We should have 4 draws, with spec constant values 0, 1, 2, 3 for num_colors in range(4): self.check(draw is not None) self.controller.SetFrameEvent(draw.eventId, False) pipe: rd.PipeState = self.controller.GetPipelineState() shader: rd.ShaderReflection = pipe.GetShaderReflection(rd.ShaderStage.Pixel) # uniform buffer and spec constants self.check(len(shader.constantBlocks) == 2) self.check(shader.constantBlocks[0].bufferBacked) self.check(not shader.constantBlocks[1].bufferBacked) self.check(len(shader.constantBlocks[1].variables) == 1) # should be an array of num_colors+1 elements array_len = shader.constantBlocks[0].variables[0].type.descriptor.elements if not rdtest.value_compare(array_len, num_colors+1): raise rdtest.TestFailureException("CBuffer variable is array of {}, not {}".format(array_len, num_colors+1)) if num_colors > 0: cbuf: rd.BoundCBuffer = pipe.GetConstantBuffer(rd.ShaderStage.Pixel, 0, 0) cb_vars = self.controller.GetCBufferVariableContents(pipe.GetGraphicsPipelineObject(), pipe.GetShader(rd.ShaderStage.Pixel), pipe.GetShaderEntryPoint(rd.ShaderStage.Pixel), 0, cbuf.resourceId, cbuf.byteOffset) self.check(len(cb_vars) == 1) if not rdtest.value_compare(len(cb_vars[0].members), num_colors+1): raise rdtest.TestFailureException("CBuffer variable is array of {}, not {}".format(len(cb_vars[0].members), num_colors+1)) for col in range(num_colors): expected = [0.0, 0.0, 0.0, 0.0] expected[col] = 1.0 val = [i for i in cb_vars[0].members[col].value.fv[0:4]] if not rdtest.value_compare(val, expected): raise rdtest.TestFailureException("Cbuffer[{}] value {} doesn't match expectation {}".format(col, val, expected)) rdtest.log.success("Draw with {} colors uniform buffer is as expected".format(num_colors)) cbuf: rd.BoundCBuffer = pipe.GetConstantBuffer(rd.ShaderStage.Pixel, 1, 0) cb_vars = self.controller.GetCBufferVariableContents(pipe.GetGraphicsPipelineObject(), pipe.GetShader(rd.ShaderStage.Pixel), pipe.GetShaderEntryPoint(rd.ShaderStage.Pixel), 1, cbuf.resourceId, cbuf.byteOffset) self.check(len(cb_vars) == 1) if not rdtest.value_compare(cb_vars[0].value.i.x, num_colors): raise rdtest.TestFailureException("Spec constant is {}, not {}".format(cb_vars[0].value.i.x, num_colors)) rdtest.log.success("Draw with {} colors specialisation constant is as expected".format(num_colors)) view = pipe.GetViewport(0) # the first num_colors components should be 0.6, the rest should be 0.1 (alpha is always 1.0) expected = [0.0, 0.0, 0.0, 1.0] for col in range(num_colors): expected[col] += 1.0 # Sample the centre of the viewport self.check_pixel_value(pipe.GetOutputTargets()[0].resourceId, int(view.x) + int(view.width / 2), int(view.height / 2), expected) rdtest.log.success("Draw with {} colors picked value is as expected".format(num_colors)) draw = draw.next
def check_capture(self): draw = self.find_draw("Draw") self.check(draw is not None) self.controller.SetFrameEvent(draw.eventId, False) # Make an output so we can pick pixels out: rd.ReplayOutput = self.controller.CreateOutput( rd.CreateHeadlessWindowingData(100, 100), rd.ReplayOutputType.Texture) self.check(out is not None) pipe: rd.PipeState = self.controller.GetPipelineState() stage = rd.ShaderStage.Vertex cbuf: rd.BoundCBuffer = pipe.GetConstantBuffer(stage, 0, 0) var_check = rdtest.ConstantBufferChecker( self.controller.GetCBufferVariableContents( pipe.GetShader(stage), pipe.GetShaderEntryPoint(stage), 0, cbuf.resourceId, cbuf.byteOffset)) # For more detailed reference for the below checks, see the commented definition of the cbuffer # in the shader source code in the demo itself # float a; var_check.check('a').cols(1).rows(1).type(rd.VarType.Float).value( [1.0]) # vec2 b; var_check.check('b').cols(2).rows(1).type(rd.VarType.Float).value( [2.0, 0.0]) # vec3 c; var_check.check('c').cols(3).rows(1).type(rd.VarType.Float).value( [0.0, 3.0]) # float d[2]; var_check.check('d').cols(0).rows(0).arraySize(2).members({ 0: lambda x: x.cols(1).rows(1).type(rd.VarType.Float).value([4.0]), 1: lambda x: x.cols(1).rows(1).type(rd.VarType.Float).value([5.0]), }) # mat2x3 e; var_check.check('e').cols(2).rows(3).column_major().type( rd.VarType.Float).value([6.0, 999.0, 7.0, 0.0, 0.0, 0.0]) # mat2x3 f[2]; var_check.check('f').cols(0).rows(0).arraySize(2).members({ 0: lambda x: x.cols(2).rows(3).column_major().type( rd.VarType.Float).value([8.0, 999.0, 9.0, 0.0, 0.0, 0.0]), 1: lambda x: x.cols(2).rows(3).column_major().type(rd.VarType.Float). value([10.0, 999.0, 11.0, 0.0, 0.0, 0.0]), }) # float g; var_check.check('g').cols(1).rows(1).type(rd.VarType.Float).value( [12.0]) # struct S # { # float a; # vec2 b; # double c; # float d; # vec3 e; # float f; # }; # S h; var_check.check('h').cols(0).rows(0).structSize(6).members({ 'a': lambda x: x.cols(1).rows(1).type(rd.VarType.Float).value([0.0]), 'b': lambda x: x.cols(2).rows(1).type(rd.VarType.Float).value([0.0]), 'c': lambda x: x.cols(1).rows(1).type(rd.VarType.Double).longvalue( [13.0]), 'd': lambda x: x.cols(1).rows(1).type(rd.VarType.Float).value([14.0]), 'e': lambda x: x.cols(3).rows(1).type(rd.VarType.Float).value([0.0]), 'f': lambda x: x.cols(1).rows(1).type(rd.VarType.Float).value([0.0]), }) # S i[2]; var_check.check('i').cols(0).rows(0).arraySize(2).members({ 0: lambda x: x.cols(0).rows(0).structSize(6).members({ 'a': lambda x: x.cols(1).rows(1).type(rd.VarType.Float).value([0.0] ), 'b': lambda x: x.cols(2).rows(1).type(rd.VarType.Float).value([0.0] ), 'c': lambda x: x.cols(1).rows(1).type(rd.VarType.Double).longvalue( [15.0]), 'd': lambda x: x.cols(1).rows(1).type(rd.VarType.Float).value([0.0] ), 'e': lambda x: x.cols(3).rows(1).type(rd.VarType.Float).value([0.0] ), 'f': lambda x: x.cols(1).rows(1).type(rd.VarType.Float).value([0.0] ), }), 1: lambda x: x.cols(0).rows(0).structSize(6).members({ 'a': lambda x: x.cols(1).rows(1).type(rd.VarType.Float).value([0.0] ), 'b': lambda x: x.cols(2).rows(1).type(rd.VarType.Float).value([0.0] ), 'c': lambda x: x.cols(1).rows(1).type(rd.VarType.Double).longvalue( [0.0]), 'd': lambda x: x.cols(1).rows(1).type(rd.VarType.Float).value( [16.0]), 'e': lambda x: x.cols(3).rows(1).type(rd.VarType.Float).value([0.0] ), 'f': lambda x: x.cols(1).rows(1).type(rd.VarType.Float).value([0.0] ), }), }) # i8vec4 pad1; var_check.check('pad1') # int8_t j; var_check.check('j').cols(1).rows(1).type(rd.VarType.SByte).value([17]) # struct S8 # { # int8_t a; # i8vec4 b; # i8vec2 c[4]; # }; # S8 k; var_check.check('k').cols(0).rows(0).structSize(3).members({ 'a': lambda x: x.cols(1).rows(1).type(rd.VarType.SByte).value([0]), 'b': lambda x: x.cols(4).rows(1).type(rd.VarType.SByte).value( [0, 0, 0, 0]), 'c': lambda x: x.cols(0).rows(0).arraySize(4).members({ 0: lambda x: x.cols(2).rows(1).type(rd.VarType.SByte).value( [0, 0]), 1: lambda x: x.cols(2).rows(1).type(rd.VarType.SByte).value( [0, 18]), 2: lambda x: x.cols(2).rows(1).type(rd.VarType.SByte).value( [0, 0]), 3: lambda x: x.cols(2).rows(1).type(rd.VarType.SByte).value( [0, 0]), }), }) # S8 l[2]; var_check.check('l').cols(0).rows(0).arraySize(2).members({ 0: lambda x: x.cols(0).rows(0).structSize(3).members({ 'a': lambda x: x.cols(1).rows(1).type(rd.VarType.SByte).value([19]), 'b': lambda x: x.cols(4).rows(1).type(rd.VarType.SByte).value( [0, 0, 0, 0]), 'c': lambda x: x.cols(0).rows(0).arraySize(4).members({ 0: lambda x: x.cols(2).rows(1).type(rd.VarType.SByte).value( [0, 0]), 1: lambda x: x.cols(2).rows(1).type(rd.VarType.SByte).value( [0, 20]), 2: lambda x: x.cols(2).rows(1).type(rd.VarType.SByte).value( [0, 0]), 3: lambda x: x.cols(2).rows(1).type(rd.VarType.SByte).value( [0, 0]), }), }), 1: lambda x: x.cols(0).rows(0).structSize(3).members({ 'a': lambda x: x.cols(1).rows(1).type(rd.VarType.SByte).value([21]), 'b': lambda x: x.cols(4).rows(1).type(rd.VarType.SByte).value( [0, 0, 0, 0]), 'c': lambda x: x.cols(0).rows(0).arraySize(4).members({ 0: lambda x: x.cols(2).rows(1).type(rd.VarType.SByte).value( [0, 22]), 1: lambda x: x.cols(2).rows(1).type(rd.VarType.SByte).value( [0, 0]), 2: lambda x: x.cols(2).rows(1).type(rd.VarType.SByte).value( [0, 0]), 3: lambda x: x.cols(2).rows(1).type(rd.VarType.SByte).value( [0, 0]), }), }) }) # int8_t m; var_check.check('m').cols(1).rows(1).type(rd.VarType.SByte).value( [-23]) # struct S16 # { # uint16_t a; # i16vec4 b; # i16vec2 c[4]; # int8_t d; # }; # S16 n; var_check.check('n').cols(0).rows(0).structSize(4).members({ 'a': lambda x: x.cols(1).rows(1).type(rd.VarType.UShort).value([65524]), 'b': lambda x: x.cols(4).rows(1).type(rd.VarType.SShort).value( [0, 0, 0, -2424]), 'c': lambda x: x.cols(0).rows(0).arraySize(4).members({ 0: lambda x: x.cols(2).rows(1).type(rd.VarType.SShort).value( [0, 0]), 1: lambda x: x.cols(2).rows(1).type(rd.VarType.SShort).value( [0, 0]), 2: lambda x: x.cols(2).rows(1).type(rd.VarType.SShort).value( [0, 0]), 3: lambda x: x.cols(2).rows(1).type(rd.VarType.SShort).value( [0, 0]), }), 'd': lambda x: x.cols(1).rows(1).type(rd.VarType.SByte).value([25]), }) # i8vec4 pad2; var_check.check('pad2') # uint8_t o; var_check.check('o').cols(1).rows(1).type(rd.VarType.UByte).value( [226]) # S16 p[2]; var_check.check('p').cols(0).rows(0).arraySize(2).members({ 0: lambda x: x.cols(0).rows(0).structSize(4).members({ 'a': lambda x: x.cols(1).rows(1).type(rd.VarType.UShort).value([0]), 'b': lambda x: x.cols(4).rows(1).type(rd.VarType.SShort).value( [0, 0, 2727, 0]), 'c': lambda x: x.cols(0).rows(0).arraySize(4).members({ 0: lambda x: x.cols(2).rows(1).type(rd.VarType.SShort).value( [0, 0]), 1: lambda x: x.cols(2).rows(1).type(rd.VarType.SShort).value( [0, 0]), 2: lambda x: x.cols(2).rows(1).type(rd.VarType.SShort).value( [0, 0]), 3: lambda x: x.cols(2).rows(1).type(rd.VarType.SShort).value( [0, 0]), }), 'd': lambda x: x.cols(1).rows(1).type(rd.VarType.SByte).value([28]), }), 1: lambda x: x.cols(0).rows(0).structSize(4).members({ 'a': lambda x: x.cols(1).rows(1).type(rd.VarType.UShort).value([0]), 'b': lambda x: x.cols(4).rows(1).type(rd.VarType.SShort).value( [0, 0, 0, 2929]), 'c': lambda x: x.cols(0).rows(0).arraySize(4).members({ 0: lambda x: x.cols(2).rows(1).type(rd.VarType.SShort).value( [0, 0]), 1: lambda x: x.cols(2).rows(1).type(rd.VarType.SShort).value( [0, 0]), 2: lambda x: x.cols(2).rows(1).type(rd.VarType.SShort).value( [0, 0]), 3: lambda x: x.cols(2).rows(1).type(rd.VarType.SShort).value( [0, 0]), }), 'd': lambda x: x.cols(1).rows(1).type(rd.VarType.SByte).value([0]), }) }) # i8vec4 pad3; var_check.check('pad3') # uint64_t q; var_check.check('q').cols(1).rows(1).type(rd.VarType.ULong).longvalue( [30303030303030]) # int64_t r; var_check.check('r').cols(1).rows(1).type(rd.VarType.SLong).longvalue( [-31313131313131]) # half s; var_check.check('s').cols(1).rows(1).type(rd.VarType.Half).value( [16.25]) # int8_t test; var_check.check('test').cols(1).rows(1).type(rd.VarType.SByte).value( [42]) var_check.done() rdtest.log.success("CBuffer variables are as expected") tex = rd.TextureDisplay() tex.resourceId = pipe.GetOutputTargets()[0].resourceId out.SetTextureDisplay(tex) texdetails = self.get_texture(tex.resourceId) picked: rd.PixelValue = out.PickPixel(tex.resourceId, False, int(texdetails.width / 2), int(texdetails.height / 2), 0, 0, 0) # We just output green from the shader when the value is as expected if not rdtest.value_compare(picked.floatValue, [0.0, 1.0, 0.0, 0.0]): raise rdtest.TestFailureException( "Picked value {} doesn't match expectation".format( picked.floatValue)) rdtest.log.success("Picked value is as expected") out.Shutdown()
def check_test(self, fmt_name: str, name: str, test_mode: int): pipe: rd.PipeState = self.controller.GetPipelineState() image_view = (test_mode != Texture_Zoo.TEST_CAPTURE) if image_view: bound_res: rd.BoundResource = pipe.GetOutputTargets()[0] else: bound_res: rd.BoundResource = pipe.GetReadOnlyResources( rd.ShaderStage.Pixel)[0].resources[0] texs = self.controller.GetTextures() for t in texs: self.textures[t.resourceId] = t tex_id: rd.ResourceId = bound_res.resourceId tex: rd.TextureDescription = self.textures[tex_id] comp_type: rd.CompType = tex.format.compType if bound_res.typeCast != rd.CompType.Typeless: comp_type = bound_res.typeCast # When not running proxied, save non-typecasted textures to disk if not image_view and not self.proxied and ( tex.format.compType == comp_type or tex.format.type == rd.ResourceFormatType.D24S8 or tex.format.type == rd.ResourceFormatType.D32S8): save_data = rd.TextureSave() save_data.resourceId = tex_id save_data.destType = rd.FileType.DDS save_data.sample.mapToArray = True self.textures[self.filename] = tex path = rdtest.get_tmp_path(self.filename + '.dds') success: bool = self.controller.SaveTexture(save_data, path) if not success: try: os.remove(path) except Exception: pass save_data.destType = rd.FileType.PNG save_data.slice.sliceIndex = 0 save_data.sample.sampleIndex = 0 path = path.replace('.dds', '.png') if comp_type == rd.CompType.UInt: save_data.comp.blackPoint = 0.0 save_data.comp.whitePoint = 255.0 elif comp_type == rd.CompType.SInt: save_data.comp.blackPoint = -255.0 save_data.comp.whitePoint = 0.0 elif comp_type == rd.CompType.SNorm: save_data.comp.blackPoint = -1.0 save_data.comp.whitePoint = 0.0 success: bool = self.controller.SaveTexture(save_data, path) if not success: try: os.remove(path) except Exception: pass value0 = [] comp_count = tex.format.compCount # When viewing PNGs only compare the components that the original texture had if test_mode == Texture_Zoo.TEST_PNG: comp_count = self.textures[self.filename] tex.msSamp = 0 tex.arraysize = 1 tex.depth = 1 self.fake_msaa = 'MSAA' in name elif test_mode == Texture_Zoo.TEST_DDS: tex.arraysize = self.textures[self.filename].arraysize tex.msSamp = self.textures[self.filename].msSamp self.fake_msaa = 'MSAA' in name # HACK: We don't properly support BGRX, so just drop the alpha channel. We can't set this to compCount = 3 # internally because that's a 24-bit format with no padding... if 'B8G8R8X8' in fmt_name: comp_count = 3 # Completely ignore the alpha for BC1, our encoder doesn't pay attention to it if tex.format.type == rd.ResourceFormatType.BC1: comp_count = 3 # Calculate format-appropriate epsilon eps_significand = 1.0 # Account for the sRGB curve by more generous epsilon if comp_type == rd.CompType.UNormSRGB: eps_significand = 2.5 # Similarly SNorm essentially loses a bit of accuracy due to us only using negative values elif comp_type == rd.CompType.SNorm: eps_significand = 2.0 if tex.format.type == rd.ResourceFormatType.R4G4B4A4 or tex.format.type == rd.ResourceFormatType.R4G4: eps = (eps_significand / 15.0) elif rd.ResourceFormatType.BC1 <= tex.format.type <= rd.ResourceFormatType.BC3: eps = (eps_significand / 15.0) # 4-bit precision in some channels elif tex.format.type == rd.ResourceFormatType.R5G5B5A1 or tex.format.type == rd.ResourceFormatType.R5G6B5: eps = (eps_significand / 31.0) elif tex.format.type == rd.ResourceFormatType.R11G11B10: eps = (eps_significand / 31.0) # 5-bit mantissa in blue elif tex.format.type == rd.ResourceFormatType.R9G9B9E5: eps = ( eps_significand / 63.0 ) # we have 9 bits of data, but might lose 2-3 due to shared exponent elif tex.format.type == rd.ResourceFormatType.BC6 and tex.format.compType == rd.CompType.SNorm: eps = (eps_significand / 63.0 ) # Lose a bit worth of precision for the signed version elif rd.ResourceFormatType.BC4 <= tex.format.type <= rd.ResourceFormatType.BC7: eps = (eps_significand / 127.0) elif tex.format.compByteWidth == 1: eps = (eps_significand / 255.0) elif comp_type == rd.CompType.Depth and tex.format.compCount == 2: eps = (eps_significand / 255.0) # stencil is only 8-bit elif tex.format.type == rd.ResourceFormatType.A8: eps = (eps_significand / 255.0) elif tex.format.type == rd.ResourceFormatType.R10G10B10A2: eps = (eps_significand / 1023.0) else: # half-floats have 11-bit mantissa. This epsilon is tight enough that we can be sure # any remaining errors are implementation inaccuracy and not our bug eps = (eps_significand / 2047.0) for mp in range(tex.mips): for sl in range(max(tex.arraysize, max(1, tex.depth >> mp))): z = 0 if tex.depth > 1: z = sl for sm in range(tex.msSamp): for x in range(max(1, tex.width >> mp)): for y in range(max(1, tex.height >> mp)): picked: rd.PixelValue = self.pick( tex_id, x, y, self.sub(mp, sl, sm), comp_type) # each 3D slice cycles the x. This only affects the primary diagonal offs_x = (x + z) % max(1, tex.width >> mp) # The diagonal inverts the colors inverted = (offs_x != y) # second slice adds a coarse checkerboard pattern of inversion if tex.arraysize > 1 and sl == 1 and ( (int(x / 2) % 2) != (int(y / 2) % 2)): inverted = not inverted if comp_type == rd.CompType.UInt or comp_type == rd.CompType.SInt: expected = [10, 40, 70, 100] if inverted: expected = list(reversed(expected)) expected = [ c + 10 * (sm + mp) for c in expected ] if comp_type == rd.CompType.SInt: picked = picked.intValue else: picked = picked.uintValue elif (tex.format.type == rd.ResourceFormatType.D16S8 or tex.format.type == rd.ResourceFormatType.D24S8 or tex.format.type == rd.ResourceFormatType.D32S8): # depth/stencil is a bit special expected = [0.1, 10, 100, 0.85] if inverted: expected = list(reversed(expected)) expected[0] += 0.075 * (sm + mp) expected[1] += 10 * (sm + mp) # Normalise stencil value expected[1] = expected[1] / 255.0 picked = picked.floatValue else: expected = [0.1, 0.35, 0.6, 0.85] if inverted: expected = list(reversed(expected)) expected = [ c + 0.075 * (sm + mp) for c in expected ] picked = picked.floatValue # SNorm/SInt is negative if comp_type == rd.CompType.SNorm or comp_type == rd.CompType.SInt: expected = [-c for c in expected] # BGRA textures have a swizzle applied if tex.format.BGRAOrder(): expected[0:3] = reversed(expected[0:3]) # alpha channel in 10:10:10:2 has extremely low precision, and the ULP requirements mean # we basically can't trust anything between 0 and 1 on float formats. Just round in that # case as it still lets us differentiate between alpha 0.0-0.5 and 0.5-1.0 if tex.format.type == rd.ResourceFormatType.R10G10B10A2: if comp_type == rd.CompType.UInt: expected[3] = min(3, expected[3]) else: expected[3] = round(expected[3]) * 1.0 picked[3] = round(picked[3]) * 1.0 # Handle 1-bit alpha if tex.format.type == rd.ResourceFormatType.R5G5B5A1: expected[ 3] = 1.0 if expected[3] >= 0.5 else 0.0 picked[3] = 1.0 if picked[3] >= 0.5 else 0.0 # A8 picked values come out in alpha, but we want to compare against the single channel if tex.format.type == rd.ResourceFormatType.A8: picked[0] = picked[3] # Clamp to number of components in the texture expected = expected[0:comp_count] picked = picked[0:comp_count] if mp == 0 and sl == 0 and sm == 0 and x == 0 and y == 0: value0 = picked # For SRGB textures picked values will come out as linear def srgb2linear(f): if f <= 0.04045: return f / 12.92 else: return ((f + 0.055) / 1.055)**2.4 if comp_type == rd.CompType.UNormSRGB: expected[0:3] = [ srgb2linear(x) for x in expected[0:3] ] if test_mode == Texture_Zoo.TEST_PNG: orig_comp = self.textures[ self.filename].format.compType if orig_comp == rd.CompType.SNorm or orig_comp == rd.CompType.SInt: expected = [1.0 - x for x in expected] if not rdtest.value_compare(picked, expected, eps): raise rdtest.TestFailureException( "At ({},{}) of slice {}, mip {}, sample {} of {} {} got {}. Expected {}" .format(x, y, sl, mp, sm, name, fmt_name, picked, expected)) if not image_view: output_tex = pipe.GetOutputTargets()[0].resourceId # in the test captures pick the output texture, it should be identical to the # (0,0) pixel in slice 0, mip 0, sample 0 view: rd.Viewport = pipe.GetViewport(0) val: rd.PixelValue = self.pick( pipe.GetOutputTargets()[0].resourceId, int(view.x + view.width / 2), int(view.y + view.height / 2), rd.Subresource(), rd.CompType.Typeless) picked = val.floatValue # A8 picked values come out in alpha, but we want to compare against the single channel if tex.format.type == rd.ResourceFormatType.A8: picked[0] = picked[3] # Clamp to number of components in the texture picked = picked[0:comp_count] # Up-convert any non-float expected values to floats value0 = [float(x) for x in value0] # For depth/stencil images, one of either depth or stencil should match if comp_type == rd.CompType.Depth and len(value0) == 2: if picked[0] == 0.0: value0[0] = 0.0 # normalise stencil value if it isn't already if picked[1] > 1.0: picked[1] /= 255.0 elif picked[0] > 1.0: # un-normalised stencil being rendered in red, match against our stencil expectation picked[0] /= 255.0 value0[0] = value0[1] value0[1] = 0.0 else: value0[1] = 0.0 if not rdtest.value_compare(picked, value0, eps): raise rdtest.TestFailureException( "In {} {} Top-left pixel as rendered is {}. Expected {}". format(name, fmt_name, picked, value0))
def check_capture(self): draw = self.find_draw("Draw") self.check(draw is not None) self.controller.SetFrameEvent(draw.eventId, False) vsin_ref = { 0: { 'vtx': 0, 'idx': 1, 'POSITION': [-0.5, -0.5, 0.0], 'COLOR': [0.0, 1.0, 0.0, 1.0], }, 1: { 'vtx': 1, 'idx': 2, 'POSITION': [0.0, 0.5, 0.0], 'COLOR': [0.0, 1.0, 0.0, 1.0], }, 2: { 'vtx': 2, 'idx': 3, 'POSITION': [0.5, -0.5, 0.0], 'COLOR': [0.0, 1.0, 0.0, 1.0], }, 3: { 'vtx': 3, 'idx': 4, 'POSITION': [8.8, 0.0, 0.0], 'COLOR': [0.0, 0.0, 0.0, 1.0], }, 4: { 'vtx': 4, 'idx': 5, 'POSITION': None, 'COLOR': None, }, 5: { 'vtx': 5, 'idx': None, 'POSITION': None, 'COLOR': None, }, } self.check_mesh_data(vsin_ref, self.get_vsin(draw)) postvs_data = self.get_postvs(draw, rd.MeshDataStage.VSOut, 0, draw.numIndices) postvs_ref = { 0: { 'vtx': 0, 'idx': 1, 'OUTPOSITION': [-0.5, -0.5, 0.0, 1.0], 'OUTCOLOR': [0.0, 1.0, 0.0, 1.0], }, 1: { 'vtx': 1, 'idx': 2, 'OUTPOSITION': [0.0, 0.5, 0.0, 1.0], 'OUTCOLOR': [0.0, 1.0, 0.0, 1.0], }, 2: { 'vtx': 2, 'idx': 3, 'OUTPOSITION': [0.5, -0.5, 0.0, 1.0], 'OUTCOLOR': [0.0, 1.0, 0.0, 1.0], }, 3: { 'vtx': 3, 'idx': 4, 'OUTPOSITION': [8.8, 0.0, 0.0, 1.0], 'OUTCOLOR': [0.0, 0.0, 0.0, 1.0], }, 4: { 'vtx': 4, 'idx': 5, # don't rely on any particular OOB behaviour for postvs, as this may come from the driver/API }, 5: { 'vtx': 5, 'idx': None, # don't rely on any particular OOB behaviour for postvs, as this may come from the driver/API }, } self.check_mesh_data(postvs_ref, postvs_data) rdtest.log.success("vertex/index buffers were truncated as expected") pipe: rd.PipeState = self.controller.GetPipelineState() stage = rd.ShaderStage.Pixel cbuf: rd.BoundCBuffer = pipe.GetConstantBuffer(stage, 0, 0) if self.find_draw('NoCBufferRange') == None: self.check(cbuf.byteSize == 256) variables = self.controller.GetCBufferVariableContents( pipe.GetGraphicsPipelineObject(), pipe.GetShader(stage), pipe.GetShaderEntryPoint(stage), 0, cbuf.resourceId, cbuf.byteOffset, cbuf.byteSize) outcol: rd.ShaderVariable = variables[1] self.check(outcol.name == "outcol") if not rdtest.value_compare(outcol.value.f32v[0:4], [0.0, 0.0, 0.0, 0.0]): raise rdtest.TestFailureException( "expected outcol to be 0s, but got {}".format( outcol.value.f32v[0:4])) if self.controller.GetAPIProperties( ).shaderDebugging and pipe.GetShaderReflection( rd.ShaderStage.Pixel).debugInfo.debuggable: # Debug the shader trace: rd.ShaderDebugTrace = self.controller.DebugPixel( int(pipe.GetViewport(0).width / 2), int(pipe.GetViewport(0).height / 2), rd.ReplayController.NoPreference, rd.ReplayController.NoPreference) if trace.debugger is None: self.controller.FreeTrace(trace) raise rdtest.TestFailureException( "Shader did not debug at all") else: cycles, variables = self.process_trace(trace) cbuf_sourceVars = [ s for s in trace.sourceVars if s.variables[0].type == rd.DebugVariableType.Constant and s.rows > 0 ] # Vulkan style, one source var for the cbuffer if len(cbuf_sourceVars) == 1: debugged_cb = trace.constantBlocks[0] self.check(debugged_cb.members[0].name == 'padding') self.check(debugged_cb.members[1].name == 'outcol') if not rdtest.value_compare( debugged_cb.members[1].value.f32v[0:4], [0.0, 0.0, 0.0, 0.0]): raise rdtest.TestFailureException( "expected outcol to be 0s, but got {}".format( debugged_cb.members[1].value.f32v[0:4])) # D3D style, one source var for each member mapping to a register elif len(cbuf_sourceVars) == 17: debugged_cb = trace.constantBlocks[0].members[16] self.check( all([ 'consts.padding[' in c.name for c in cbuf_sourceVars[0:16] ])) self.check(cbuf_sourceVars[16].name == 'consts.outcol') self.check( cbuf_sourceVars[16].variables[0].name == 'cb0[16]') if not rdtest.value_compare(debugged_cb.value.f32v[0:4], [0.0, 0.0, 0.0, 0.0]): raise rdtest.TestFailureException( "expected outcol to be 0s, but got {}".format( debugged_cb.members[1].value.f32v[0:4])) else: raise rdtest.TestFailureException( "Unexpected number of constant buffer source vars {}". format(len(cbuf_sourceVars))) rdtest.log.success("CBuffer value was truncated as expected")
def check_test(self, fmt_name: str, name: str, test_mode: int): pipe: rd.PipeState = self.controller.GetPipelineState() image_view = (test_mode != Texture_Zoo.TEST_CAPTURE) if image_view: bound_res: rd.BoundResource = pipe.GetOutputTargets()[0] else: bound_res: rd.BoundResource = pipe.GetReadOnlyResources( rd.ShaderStage.Pixel)[0].resources[0] texs = self.controller.GetTextures() for t in texs: self.textures[t.resourceId] = t tex_id: rd.ResourceId = bound_res.resourceId tex: rd.TextureDescription = self.textures[tex_id] comp_type: rd.CompType = tex.format.compType if bound_res.typeCast != rd.CompType.Typeless: comp_type = bound_res.typeCast # When not running proxied, save non-typecasted textures to disk if not image_view and not self.proxied and ( tex.format.compType == comp_type or tex.format.type == rd.ResourceFormatType.D24S8 or tex.format.type == rd.ResourceFormatType.D32S8): save_data = rd.TextureSave() save_data.resourceId = tex_id save_data.destType = rd.FileType.DDS save_data.sample.mapToArray = True self.textures[self.filename] = tex path = rdtest.get_tmp_path(self.filename + '.dds') success: bool = self.controller.SaveTexture(save_data, path) if not success: if self.d3d_mode: raise rdtest.TestFailureException( "Couldn't save DDS to {} on D3D.".format( self.filename)) try: os.remove(path) except Exception: pass save_data.destType = rd.FileType.PNG save_data.slice.sliceIndex = 0 save_data.sample.sampleIndex = 0 path = path.replace('.dds', '.png') if comp_type == rd.CompType.UInt: save_data.comp.blackPoint = 0.0 save_data.comp.whitePoint = 255.0 elif comp_type == rd.CompType.SInt: save_data.comp.blackPoint = -255.0 save_data.comp.whitePoint = 0.0 elif comp_type == rd.CompType.SNorm: save_data.comp.blackPoint = -1.0 save_data.comp.whitePoint = 0.0 success: bool = self.controller.SaveTexture(save_data, path) if not success: try: os.remove(path) except Exception: pass value0 = [] comp_count = tex.format.compCount # When viewing PNGs only compare the components that the original texture had if test_mode == Texture_Zoo.TEST_PNG: comp_count = self.textures[self.filename] tex.msSamp = 0 tex.arraysize = 1 tex.depth = 1 self.fake_msaa = 'MSAA' in name elif test_mode == Texture_Zoo.TEST_DDS: tex.arraysize = self.textures[self.filename].arraysize tex.msSamp = self.textures[self.filename].msSamp self.fake_msaa = 'MSAA' in name # HACK: We don't properly support BGRX, so just drop the alpha channel. We can't set this to compCount = 3 # internally because that's a 24-bit format with no padding... if 'B8G8R8X8' in fmt_name: comp_count = 3 # Completely ignore the alpha for BC1, our encoder doesn't pay attention to it if tex.format.type == rd.ResourceFormatType.BC1: comp_count = 3 # Calculate format-appropriate epsilon eps_significand = 1.0 # Account for the sRGB curve by more generous epsilon if comp_type == rd.CompType.UNormSRGB: eps_significand = 2.5 # Similarly SNorm essentially loses a bit of accuracy due to us only using negative values elif comp_type == rd.CompType.SNorm: eps_significand = 2.0 if tex.format.type == rd.ResourceFormatType.R4G4B4A4 or tex.format.type == rd.ResourceFormatType.R4G4: eps = (eps_significand / 15.0) elif rd.ResourceFormatType.BC1 <= tex.format.type <= rd.ResourceFormatType.BC3: eps = (eps_significand / 15.0) # 4-bit precision in some channels elif tex.format.type == rd.ResourceFormatType.R5G5B5A1 or tex.format.type == rd.ResourceFormatType.R5G6B5: eps = (eps_significand / 31.0) elif tex.format.type == rd.ResourceFormatType.R11G11B10: eps = (eps_significand / 31.0) # 5-bit mantissa in blue elif tex.format.type == rd.ResourceFormatType.R9G9B9E5: eps = ( eps_significand / 63.0 ) # we have 9 bits of data, but might lose 2-3 due to shared exponent elif tex.format.type == rd.ResourceFormatType.BC6 and tex.format.compType == rd.CompType.SNorm: eps = (eps_significand / 63.0 ) # Lose a bit worth of precision for the signed version elif rd.ResourceFormatType.BC4 <= tex.format.type <= rd.ResourceFormatType.BC7: eps = (eps_significand / 127.0) elif tex.format.compByteWidth == 1: eps = (eps_significand / 255.0) elif comp_type == rd.CompType.Depth and tex.format.compCount == 2: eps = (eps_significand / 255.0) # stencil is only 8-bit elif tex.format.type == rd.ResourceFormatType.A8: eps = (eps_significand / 255.0) elif tex.format.type == rd.ResourceFormatType.R10G10B10A2: eps = (eps_significand / 1023.0) else: # half-floats have 11-bit mantissa. This epsilon is tight enough that we can be sure # any remaining errors are implementation inaccuracy and not our bug eps = (eps_significand / 2047.0) for mp in range(tex.mips): for sl in range(max(tex.arraysize, max(1, tex.depth >> mp))): z = 0 if tex.depth > 1: z = sl for sm in range(tex.msSamp): cur_sub = self.sub(mp, sl, sm) tex_display = rd.TextureDisplay() tex_display.resourceId = tex_id tex_display.subresource = cur_sub tex_display.flipY = self.opengl_mode tex_display.typeCast = comp_type tex_display.alpha = False tex_display.scale = 1.0 / float(1 << mp) tex_display.backgroundColor = rd.FloatVector( 0.0, 0.0, 0.0, 1.0) if comp_type == rd.CompType.UInt: tex_display.rangeMin = 0.0 tex_display.rangeMax = 255.0 elif comp_type == rd.CompType.SInt: tex_display.rangeMin = -255.0 tex_display.rangeMax = 0.0 elif comp_type == rd.CompType.SNorm: tex_display.rangeMin = -1.0 tex_display.rangeMax = 0.0 self.out.SetTextureDisplay(tex_display) self.out.Display() pixels: bytes = self.out.ReadbackOutputTexture() dim = self.out.GetDimensions() stencilpixels = None # Grab stencil separately if tex.format.type == rd.ResourceFormatType.D16S8 or tex.format.type == rd.ResourceFormatType.D24S8 or tex.format.type == rd.ResourceFormatType.D32S8: tex_display.red = False tex_display.green = True tex_display.blue = False tex_display.alpha = False self.out.SetTextureDisplay(tex_display) self.out.Display() stencilpixels: bytes = self.out.ReadbackOutputTexture() # Grab alpha if needed (since the readback output is RGB only) if comp_count == 4 or tex.format.type == rd.ResourceFormatType.A8: tex_display.red = False tex_display.green = False tex_display.blue = False tex_display.alpha = True self.out.SetTextureDisplay(tex_display) self.out.Display() alphapixels: bytes = self.out.ReadbackOutputTexture() all_good = True for x in range(max(1, tex.width >> mp)): if not all_good: break for y in range(max(1, tex.height >> mp)): expected = self.get_expected_value( comp_count, comp_type, cur_sub, test_mode, tex, x, y, z) # for this test to work the expected values have to be within the range we selected for # display above for i in expected: if i < tex_display.rangeMin or tex_display.rangeMax < i: raise rdtest.TestFailureException( "expected value {} is outside of texture display range! {} - {}" .format(i, tex_display.rangeMin, tex_display.rangeMax)) # convert the expected values to range-adapted values for i in range(len(expected)): expected[i] = (expected[i] - tex_display.rangeMin) / ( tex_display.rangeMax - tex_display.rangeMin) # get the bytes from the displayed pixel offs = y * dim[0] * 3 + x * 3 displayed = [ int(a) for a in pixels[offs:offs + comp_count] ] if comp_count == 4: del displayed[3] displayed.append(int(alphapixels[offs])) if stencilpixels is not None: del displayed[1:] displayed.append(int(stencilpixels[offs])) if tex.format.type == rd.ResourceFormatType.A8: displayed = [int(alphapixels[offs])] # normalise the displayed values for i in range(len(displayed)): displayed[i] = float(displayed[i]) / 255.0 # For SRGB textures match linear picked values. We do this for alpha too since it's rendered # via RGB if comp_type == rd.CompType.UNormSRGB: displayed[0:4] = [ srgb2linear(x) for x in displayed[0:4] ] # alpha channel in 10:10:10:2 has extremely low precision, and the ULP requirements mean # we basically can't trust anything between 0 and 1 on float formats. Just round in that # case as it still lets us differentiate between alpha 0.0-0.5 and 0.5-1.0 if tex.format.type == rd.ResourceFormatType.R10G10B10A2 and comp_type != rd.CompType.UInt: displayed[3] = round(displayed[3]) * 1.0 # Handle 1-bit alpha if tex.format.type == rd.ResourceFormatType.R5G5B5A1: displayed[ 3] = 1.0 if displayed[3] >= 0.5 else 0.0 # Need an additional 1/255 epsilon to account for us going via a 8-bit backbuffer for display if not rdtest.value_compare( displayed, expected, 1.0 / 255.0 + eps): #rdtest.log.print( # "Quick-checking ({},{}) of slice {}, mip {}, sample {} of {} {} got {}. Expected {}.".format( # x, y, sl, mp, sm, name, fmt_name, displayed, expected) + # "Falling back to pixel picking tests.") # Currently this seems to fail in some proxy scenarios with sRGB, but since it's not a # real error we just silently swallow it all_good = False break if all_good: continue for x in range(max(1, tex.width >> mp)): for y in range(max(1, tex.height >> mp)): expected = self.get_expected_value( comp_count, comp_type, cur_sub, test_mode, tex, x, y, z) picked = self.get_picked_pixel_value( comp_count, comp_type, cur_sub, tex, tex_id, x, y) if mp == 0 and sl == 0 and sm == 0 and x == 0 and y == 0: value0 = picked if not rdtest.value_compare(picked, expected, eps): raise rdtest.TestFailureException( "At ({},{}) of slice {}, mip {}, sample {} of {} {} got {}. Expected {}" .format(x, y, sl, mp, sm, name, fmt_name, picked, expected)) if not image_view: output_tex = pipe.GetOutputTargets()[0].resourceId # in the test captures pick the output texture, it should be identical to the # (0,0) pixel in slice 0, mip 0, sample 0 view: rd.Viewport = pipe.GetViewport(0) val: rd.PixelValue = self.pick( pipe.GetOutputTargets()[0].resourceId, int(view.x + view.width / 2), int(view.y + view.height / 2), rd.Subresource(), rd.CompType.Typeless) picked = list(val.floatValue) # A8 picked values come out in alpha, but we want to compare against the single channel if tex.format.type == rd.ResourceFormatType.A8: picked[0] = picked[3] # Clamp to number of components in the texture picked = picked[0:comp_count] # If we didn't get a value0 (because we did all texture render compares) then fetch it here if len(value0) == 0: value0 = self.get_picked_pixel_value(comp_count, comp_type, rd.Subresource(), tex, tex_id, 0, 0) # Up-convert any non-float expected values to floats value0 = [float(x) for x in value0] # For depth/stencil images, one of either depth or stencil should match if comp_type == rd.CompType.Depth and len(value0) == 2: if picked[0] == 0.0: value0[0] = 0.0 # normalise stencil value if it isn't already if picked[1] > 1.0: picked[1] /= 255.0 elif picked[0] > 1.0: # un-normalised stencil being rendered in red, match against our stencil expectation picked[0] /= 255.0 value0[0] = value0[1] value0[1] = 0.0 else: if picked[1] == 0.0: value0[1] = 0.0 if picked[1] > 1.0: picked[1] /= 255.0 if not rdtest.value_compare(picked, value0, eps): raise rdtest.TestFailureException( "In {} {} Top-left pixel as rendered is {}. Expected {}". format(name, fmt_name, picked, value0))
def check_capture(self): draw = self.find_draw("Draw") self.check(draw is not None) self.controller.SetFrameEvent(draw.eventId, False) # Make an output so we can pick pixels out: rd.ReplayOutput = self.controller.CreateOutput( rd.CreateHeadlessWindowingData(100, 100), rd.ReplayOutputType.Texture) self.check(out is not None) pipe: rd.PipeState = self.controller.GetPipelineState() stage = rd.ShaderStage.Pixel cbuf: rd.BoundCBuffer = pipe.GetConstantBuffer(stage, 0, 0) var_check = rdtest.ConstantBufferChecker( self.controller.GetCBufferVariableContents( pipe.GetGraphicsPipelineObject(), pipe.GetShader(stage), pipe.GetShaderEntryPoint(stage), 0, cbuf.resourceId, cbuf.byteOffset)) # For more detailed reference for the below checks, see the commented definition of the cbuffer # in the shader source code in the demo itself # float4 a; var_check.check('a').rows(1).cols(4).value([0.0, 1.0, 2.0, 3.0]) # float3 b; var_check.check('b').rows(1).cols(3).value([4.0, 5.0, 6.0]) # float2 c; float2 d; var_check.check('c').rows(1).cols(2).value([8.0, 9.0]) var_check.check('d').rows(1).cols(2).value([10.0, 11.0]) # float e; float3 f; var_check.check('e').rows(1).cols(1).value([12.0]) var_check.check('f').rows(1).cols(3).value([13.0, 14.0, 15.0]) # float g; float2 h; float i; var_check.check('g').rows(1).cols(1).value([16.0]) var_check.check('h').rows(1).cols(2).value([17.0, 18.0]) var_check.check('i').rows(1).cols(1).value([19.0]) # float j; float2 k; var_check.check('j').rows(1).cols(1).value([20.0]) var_check.check('k').rows(1).cols(2).value([21.0, 22.0]) # float2 l; float m; var_check.check('l').rows(1).cols(2).value([24.0, 25.0]) var_check.check('m').rows(1).cols(1).value([26.0]) # float n[4]; var_check.check('n').rows(0).cols(0).arraySize(4).members({ 0: lambda x: x.rows(1).cols(1).value([28.0]), 1: lambda x: x.rows(1).cols(1).value([32.0]), 2: lambda x: x.rows(1).cols(1).value([36.0]), 3: lambda x: x.rows(1).cols(1).value([40.0]), }) # float4 dummy1; var_check.check('dummy1') # float o[4]; var_check.check('o').rows(0).cols(0).arraySize(4).members({ 0: lambda x: x.rows(1).cols(1).value([48.0]), 1: lambda x: x.rows(1).cols(1).value([52.0]), 2: lambda x: x.rows(1).cols(1).value([56.0]), 3: lambda x: x.rows(1).cols(1).value([60.0]), }) # float p; var_check.check('p').rows(1).cols(1).value([61.0]) # float4 dummy2; var_check.check('dummy2') # float4 dummygl1; # float4 dummygl2; var_check.check('dummygl1') var_check.check('dummygl2') # column_major float4x4 q; var_check.check('q').rows(4).cols(4).column_major().value([ 76.0, 80.0, 84.0, 88.0, 77.0, 81.0, 85.0, 89.0, 78.0, 82.0, 86.0, 90.0, 79.0, 83.0, 87.0, 91.0 ]) # row_major float4x4 r; var_check.check('r').rows(4).cols(4).row_major().value([ 92.0, 93.0, 94.0, 95.0, 96.0, 97.0, 98.0, 99.0, 100.0, 101.0, 102.0, 103.0, 104.0, 105.0, 106.0, 107.0 ]) # column_major float3x4 s; var_check.check('s').rows(3).cols(4).column_major().value([ 108.0, 112.0, 116.0, 120.0, 109.0, 113.0, 117.0, 121.0, 110.0, 114.0, 118.0, 122.0 ]) # float4 dummy3; var_check.check('dummy3') # row_major float3x4 t; var_check.check('t').rows(3).cols(4).row_major().value([ 128.0, 129.0, 130.0, 131.0, 132.0, 133.0, 134.0, 135.0, 136.0, 137.0, 138.0, 139.0 ]) # float4 dummy4; var_check.check('dummy4') # column_major float2x3 u; var_check.check('u').rows(2).cols(3).column_major().value( [144.0, 148.0, 152.0, 145.0, 149.0, 153.0]) # float4 dummy5; var_check.check('dummy5') # row_major float2x3 v; var_check.check('v').rows(2).cols(3).row_major().value( [160.0, 161.0, 162.0, 164.0, 165.0, 166.0]) # float4 dummy6; var_check.check('dummy6') # column_major float2x2 w; var_check.check('w').rows(2).cols(2).column_major().value( [172.0, 176.0, 173.0, 177.0]) # float4 dummy7; var_check.check('dummy7') # row_major float2x2 x; var_check.check('x').rows(2).cols(2).row_major().value( [184.0, 185.0, 188.0, 189.0]) # float4 dummy8; var_check.check('dummy8') # row_major float2x2 y; var_check.check('y').rows(2).cols(2).row_major().value( [196.0, 197.0, 200.0, 201.0]) # float z; var_check.check('z').rows(1).cols(1).value([202.0]) # float4 gldummy3; var_check.check('gldummy3') # row_major float4x1 aa; var_check.check('aa').rows(4).cols(1).value( [208.0, 212.0, 216.0, 220.0]) # column_major float4x1 ab; var_check.check('ab').rows(4).cols(1).value( [224.0, 225.0, 226.0, 227.0]) # float4 multiarray[3][2]; # this is flattened to just multiarray[6] var_check.check('multiarray').rows(0).cols(0).arraySize(6).members({ 0: lambda x: x.rows(1).cols(4).value([228.0, 229.0, 230.0, 231.0]), 1: lambda x: x.rows(1).cols(4).value([232.0, 233.0, 234.0, 235.0]), 2: lambda x: x.rows(1).cols(4).value([236.0, 237.0, 238.0, 239.0]), 3: lambda x: x.rows(1).cols(4).value([240.0, 241.0, 242.0, 243.0]), 4: lambda x: x.rows(1).cols(4).value([244.0, 245.0, 246.0, 247.0]), 5: lambda x: x.rows(1).cols(4).value([248.0, 249.0, 250.0, 251.0]), }) # struct float3_1 { float3 a; float b; }; # struct nested { float3_1 a; float4 b[4]; float3_1 c[4]; }; # nested structa[2]; var_check.check('structa').rows(0).cols(0).arraySize(2).members({ # structa[0] 0: lambda s: s.rows(0).cols(0).structSize(3).members({ 'a': lambda x: x.rows(0).cols(0).structSize(2).members({ 'a': lambda y: y.rows(1).cols(3).value([252.0, 253.0, 254.0]), 'b': lambda y: y.rows(1).cols(1).value([255.0]), }), 'b': lambda x: x.rows(0).cols(0).arraySize(4).members({ 0: lambda y: y.rows(1).cols(4).value( [256.0, 257.0, 258.0, 259.0]), 1: lambda y: y.rows(1).cols(4).value( [260.0, 261.0, 262.0, 263.0]), 2: lambda y: y.rows(1).cols(4).value( [264.0, 265.0, 266.0, 267.0]), 3: lambda y: y.rows(1).cols(4).value( [268.0, 269.0, 270.0, 271.0]), }), 'c': lambda x: x.rows(0).cols(0).arraySize(4).members({ 0: lambda y: y.rows(0).cols(0).structSize(2).members({ 'a': lambda z: z.rows(1).cols(3).value( [272.0, 273.0, 274.0]), 'b': lambda z: z.rows(1).cols(1).value([275.0]), }), 1: lambda y: y.rows(0).cols(0).structSize(2).members({ 'a': lambda z: z.rows(1).cols(3).value( [276.0, 277.0, 278.0]), 'b': lambda z: z.rows(1).cols(1).value([279.0]), }), 2: lambda y: y.rows(0).cols(0).structSize(2).members({ 'a': lambda z: z.rows(1).cols(3).value( [280.0, 281.0, 282.0]), 'b': lambda z: z.rows(1).cols(1).value([283.0]), }), 3: lambda y: y.rows(0).cols(0).structSize(2).members({ 'a': lambda z: z.rows(1).cols(3).value( [284.0, 285.0, 286.0]), 'b': lambda z: z.rows(1).cols(1).value([287.0]), }), }), }), # structa[1] 1: lambda s: s.rows(0).cols(0).structSize(3).members({ 'a': lambda x: x.rows(0).cols(0).structSize(2).members({ 'a': lambda y: y.rows(1).cols(3).value([288.0, 289.0, 290.0]), 'b': lambda y: y.rows(1).cols(1).value([291.0]), }), 'b': lambda x: x.rows(0).cols(0).arraySize(4).members({ 0: lambda y: y.rows(1).cols(4).value( [292.0, 293.0, 294.0, 295.0]), 1: lambda y: y.rows(1).cols(4).value( [296.0, 297.0, 298.0, 299.0]), 2: lambda y: y.rows(1).cols(4).value( [300.0, 301.0, 302.0, 303.0]), 3: lambda y: y.rows(1).cols(4).value( [304.0, 305.0, 306.0, 307.0]), }), 'c': lambda x: x.rows(0).cols(0).arraySize(4).members({ 0: lambda y: y.rows(0).cols(0).structSize(2).members({ 'a': lambda z: z.rows(1).cols(3).value( [308.0, 309.0, 310.0]), 'b': lambda z: z.rows(1).cols(1).value([311.0]), }), 1: lambda y: y.rows(0).cols(0).structSize(2).members({ 'a': lambda z: z.rows(1).cols(3).value( [312.0, 313.0, 314.0]), 'b': lambda z: z.rows(1).cols(1).value([315.0]), }), 2: lambda y: y.rows(0).cols(0).structSize(2).members({ 'a': lambda z: z.rows(1).cols(3).value( [316.0, 317.0, 318.0]), 'b': lambda z: z.rows(1).cols(1).value([319.0]), }), 3: lambda y: y.rows(0).cols(0).structSize(2).members({ 'a': lambda z: z.rows(1).cols(3).value( [320.0, 321.0, 322.0]), 'b': lambda z: z.rows(1).cols(1).value([323.0]), }), }), }), }) # column_major float3x2 ac; var_check.check('ac').rows(3).cols(2).column_major().value( [324.0, 328.0, 325.0, 329.0, 326.0, 330.0]) # row_major float3x2 ad; var_check.check('ad').rows(3).cols(2).row_major().value( [332.0, 333.0, 336.0, 337.0, 340.0, 341.0]) # column_major float3x2 ae[2]; var_check.check('ae').rows(0).cols(0).arraySize(2).members({ 0: lambda x: x.rows(3).cols(2).column_major().value( [344.0, 348.0, 345.0, 349.0, 346.0, 350.0]), 1: lambda x: x.rows(3).cols(2).column_major().value( [352.0, 356.0, 353.0, 357.0, 354.0, 358.0]), }) # row_major float3x2 af[2]; var_check.check('af').rows(0).cols(0).arraySize(2).members({ 0: lambda x: x.rows(3).cols(2).row_major().value( [360.0, 361.0, 364.0, 365.0, 368.0, 369.0]), 1: lambda x: x.rows(3).cols(2).row_major().value( [372.0, 373.0, 376.0, 377.0, 380.0, 381.0]), }) # float2 dummy9; var_check.check('dummy9') # float2 dummy10; var_check.check('dummy10') # row_major float2x2 ag; var_check.check('ag').rows(2).cols(2).row_major().value( [388.0, 389.0, 392.0, 393.0]) # float2 dummy11; var_check.check('dummy11') # float2 dummy12; var_check.check('dummy12') # column_major float2x2 ah; var_check.check('ah').rows(2).cols(2).column_major().value( [400.0, 404.0, 401.0, 405.0]) # row_major float2x2 ai[2]; var_check.check('ai').rows(0).cols(0).arraySize(2).members({ 0: lambda x: x.rows(2).cols(2).row_major().value( [408.0, 409.0, 412.0, 413.0]), 1: lambda x: x.rows(2).cols(2).row_major().value( [416.0, 417.0, 420.0, 421.0]), }) # column_major float2x2 aj[2]; var_check.check('aj').rows(0).cols(0).arraySize(2).members({ 0: lambda x: x.rows(2).cols(2).column_major().value( [424.0, 428.0, 425.0, 429.0]), 1: lambda x: x.rows(2).cols(2).column_major().value( [432.0, 436.0, 433.0, 437.0]), }) # float4 test; var_check.check('test').rows(1).cols(4).value( [440.0, 441.0, 442.0, 443.0]) var_check.done() rdtest.log.success("CBuffer variables are as expected") tex = rd.TextureDisplay() tex.resourceId = pipe.GetOutputTargets()[0].resourceId out.SetTextureDisplay(tex) texdetails = self.get_texture(tex.resourceId) picked: rd.PixelValue = out.PickPixel(tex.resourceId, False, int(texdetails.width / 2), int(texdetails.height / 2), 0, 0, 0) if not rdtest.value_compare(picked.floatValue, [440.1, 441.0, 442.0, 443.0]): raise rdtest.TestFailureException( "Picked value {} doesn't match expectation".format( picked.floatValue)) rdtest.log.success("Picked value is as expected") cbuf: rd.BoundCBuffer = pipe.GetConstantBuffer(stage, 1, 0) var_check = rdtest.ConstantBufferChecker( self.controller.GetCBufferVariableContents( pipe.GetGraphicsPipelineObject(), pipe.GetShader(stage), pipe.GetShaderEntryPoint(stage), 1, cbuf.resourceId, cbuf.byteOffset)) # float4 zero; var_check.check('root_zero').rows(1).cols(4).value( [0.0, 0.0, 0.0, 0.0]) # float4 a; var_check.check('root_a').rows(1).cols(4).value( [10.0, 20.0, 30.0, 40.0]) # float2 b; var_check.check('root_b').rows(1).cols(2).value([50.0, 60.0]) # float2 c; var_check.check('root_c').rows(1).cols(2).value([70.0, 80.0]) # float3_1 d; var_check.check('root_d').rows(0).cols(0).structSize(2).members({ 'a': lambda y: y.rows(1).cols(3).value([90.0, 100.0, 110.0]), 'b': lambda y: y.rows(1).cols(1).value([120.0]), }) var_check.done() rdtest.log.success("Root signature variables are as expected") out.Shutdown()
def check_capture(self): actions = self.controller.GetRootActions() for d in self.controller.GetRootActions(): # Only process test actions if not d.customName.startswith('Test'): continue # Go to the last child action self.controller.SetFrameEvent(d.children[-1].eventId, True) if any(['UInt tex' in d.customName for d in d.children]): value_selector = lambda x: x.uintValue shader_out = (0, 1, 1234, 5) elif any(['SInt tex' in d.customName for d in d.children]): value_selector = lambda x: x.intValue shader_out = (0, 1, -1234, 5) else: value_selector = lambda x: x.floatValue shader_out = (0.0, 1.0, 0.1234, 0.5) pipe: rd.PipeState = self.controller.GetPipelineState() rt: rd.BoundResource = pipe.GetOutputTargets()[0] vp: rd.Viewport = pipe.GetViewport(0) tex = rt.resourceId x, y = (int(vp.width / 2), int(vp.height / 2)) tex_details = self.get_texture(tex) sub = rd.Subresource() if tex_details.arraysize > 1: sub.slice = rt.firstSlice if tex_details.mips > 1: sub.mip = rt.firstMip modifs: List[rd.PixelModification] = self.controller.PixelHistory(tex, x, y, sub, rt.typeCast) # Should be at least two modifications in every test - clear and action self.check(len(modifs) >= 2) # Check that the modifications are self consistent - postmod of each should match premod of the next for i in range(len(modifs) - 1): if value_selector(modifs[i].postMod.col) != value_selector(modifs[i + 1].preMod.col): raise rdtest.TestFailureException( "postmod at {}: {} doesn't match premod at {}: {}".format(modifs[i].eventId, value_selector(modifs[i].postMod.col), modifs[i + 1].eventId, value_selector(modifs[i].preMod.col))) if self.get_action(modifs[i].eventId).flags & rd.ActionFlags.Drawcall: if not rdtest.value_compare(value_selector(modifs[i].shaderOut.col), shader_out): raise rdtest.TestFailureException( "Shader output {} isn't as expected {}".format(value_selector(modifs[i].shaderOut.col), shader_out)) rdtest.log.success("shader output and premod/postmod is consistent") # The current pixel value should match the last postMod self.check_pixel_value(tex, x, y, value_selector(modifs[-1].postMod.col), sub=sub, cast=rt.typeCast) # Also the red channel should be zero, as it indicates errors self.check(float(value_selector(modifs[-1].postMod.col)[0]) == 0.0)
def check_capture(self): id = self.get_last_draw().copyDestination tex_details = self.get_texture(id) self.controller.SetFrameEvent(self.get_last_draw().eventId, True) data = self.controller.GetTextureData(id, rd.Subresource(0, 0, 0)) first_pixel = struct.unpack_from("BBBB", data, 0) val = [255, 0, 255, 255] if not rdtest.value_compare(first_pixel, val): raise rdtest.TestFailureException( "First pixel should be clear color {}, not {}".format( val, first_pixel)) magic_pixel = struct.unpack_from("BBBB", data, (50 * tex_details.width + 320) * 4) # allow 127 or 128 for alpha val = [0, 0, 255, magic_pixel[3]] if not rdtest.value_compare(magic_pixel, val) or magic_pixel[3] not in [127, 128]: raise rdtest.TestFailureException( "Pixel @ 320,50 should be blue: {}, not {}".format( val, magic_pixel)) rdtest.log.success("Decoded pixels from texture data are correct") img_path = rdtest.get_tmp_path('preserved_alpha.png') self.controller.SetFrameEvent(self.get_last_draw().eventId, True) save_data = rd.TextureSave() save_data.resourceId = id save_data.destType = rd.FileType.PNG save_data.alpha = rd.AlphaMapping.Discard # this should not discard the alpha self.controller.SaveTexture(save_data, img_path) data = rdtest.png_load_data(img_path) magic_pixel = struct.unpack_from("BBBB", data[-1 - 50], 320 * 4) val = [0, 0, 255, magic_pixel[3]] if not rdtest.value_compare(magic_pixel, val) or magic_pixel[3] not in [127, 128]: raise rdtest.TestFailureException( "Pixel @ 320,50 should be blue: {}, not {}".format( val, magic_pixel)) draw = self.find_draw("Draw") self.controller.SetFrameEvent(draw.eventId, False) postvs_data = self.get_postvs(rd.MeshDataStage.VSOut, 0, draw.numIndices) postvs_ref = { 0: { 'vtx': 0, 'idx': 0, 'gl_Position': [-0.5, -0.5, 0.0, 1.0], 'v2fcol': [1.0, 0.0, 0.0, 1.0], }, 1: { 'vtx': 1, 'idx': 1, 'gl_Position': [0.0, 0.5, 0.0, 1.0], 'v2fcol': [0.0, 1.0, 0.0, 1.0], }, 2: { 'vtx': 2, 'idx': 2, 'gl_Position': [0.5, -0.5, 0.0, 1.0], 'v2fcol': [0.0, 0.0, 1.0, 1.0], }, } self.check_mesh_data(postvs_ref, postvs_data) results = self.controller.FetchCounters([ rd.GPUCounter.RasterizedPrimitives, rd.GPUCounter.VSInvocations, rd.GPUCounter.FSInvocations ]) results = [r for r in results if r.eventId == draw.eventId] if len(results) != 3: raise rdtest.TestFailureException( "Expected 3 results, got {} results".format(len(results))) for r in results: r: rd.CounterResult val = r.value.u32 if r.counter == rd.GPUCounter.RasterizedPrimitives: if not rdtest.value_compare(val, 1): raise rdtest.TestFailureException( "RasterizedPrimitives result {} is not as expected". format(val)) else: rdtest.log.success( "RasterizedPrimitives result is as expected") elif r.counter == rd.GPUCounter.VSInvocations: if not rdtest.value_compare(val, 3): raise rdtest.TestFailureException( "VSInvocations result {} is not as expected".format( val)) else: rdtest.log.success("VSInvocations result is as expected") elif r.counter == rd.GPUCounter.FSInvocations: if val < int(0.1 * tex_details.width * tex_details.height): raise rdtest.TestFailureException( "FSInvocations result {} is not as expected".format( val)) else: rdtest.log.success("FSInvocations result is as expected") else: raise rdtest.TestFailureException( "Unexpected counter result {}".format(r.counter)) rdtest.log.success("Counter data retrieved successfully")
def check_capture(self): draw = self.find_draw("Draw") self.check(draw is not None) self.controller.SetFrameEvent(draw.eventId, False) # Make an output so we can pick pixels out: rd.ReplayOutput = self.controller.CreateOutput( rd.CreateHeadlessWindowingData(100, 100), rd.ReplayOutputType.Texture) self.check(out is not None) ref = { 0: { 'SNORM': [1.0, -1.0, 1.0, -1.0], 'UNORM': [ 12345.0 / 65535.0, 6789.0 / 65535.0, 1234.0 / 65535.0, 567.0 / 65535.0 ], 'UINT': [12345, 6789, 1234, 567], 'ARRAY0': [1.0, 2.0], 'ARRAY1': [3.0, 4.0], 'ARRAY2': [5.0, 6.0], 'MATRIX0': [7.0, 8.0], 'MATRIX1': [9.0, 10.0], }, 1: { 'SNORM': [ 32766.0 / 32767.0, -32766.0 / 32767.0, 16000.0 / 32767.0, -16000.0 / 32767.0 ], 'UNORM': [ 56.0 / 65535.0, 7890.0 / 65535.0, 123.0 / 65535.0, 4567.0 / 65535.0 ], 'UINT': [56, 7890, 123, 4567], 'ARRAY0': [11.0, 12.0], 'ARRAY1': [13.0, 14.0], 'ARRAY2': [15.0, 16.0], 'MATRIX0': [17.0, 18.0], 'MATRIX1': [19.0, 20.0], }, 2: { 'SNORM': [5.0 / 32767.0, -5.0 / 32767.0, 0.0, 0.0], 'UNORM': [ 8765.0 / 65535.0, 43210.0 / 65535.0, 987.0 / 65535.0, 65432.0 / 65535.0 ], 'UINT': [8765, 43210, 987, 65432], 'ARRAY0': [21.0, 22.0], 'ARRAY1': [23.0, 24.0], 'ARRAY2': [25.0, 26.0], 'MATRIX0': [27.0, 28.0], 'MATRIX1': [29.0, 30.0], }, } in_ref = copy.deepcopy(ref) vsout_ref = copy.deepcopy(ref) gsout_ref = ref vsout_ref[0]['SV_Position'] = [-0.5, 0.5, 0.0, 1.0] gsout_ref[0]['SV_Position'] = [0.5, -0.5, 0.4, 1.2] vsout_ref[1]['SV_Position'] = [0.0, -0.5, 0.0, 1.0] gsout_ref[1]['SV_Position'] = [-0.5, 0.0, 0.4, 1.2] vsout_ref[2]['SV_Position'] = [0.5, 0.5, 0.0, 1.0] gsout_ref[2]['SV_Position'] = [0.5, 0.5, 0.4, 1.2] self.check_mesh_data(in_ref, self.get_vsin(draw)) rdtest.log.success("Vertex input data is as expected") self.check_mesh_data(vsout_ref, self.get_postvs(rd.MeshDataStage.VSOut)) rdtest.log.success("Vertex output data is as expected") self.check_mesh_data(gsout_ref, self.get_postvs(rd.MeshDataStage.GSOut)) rdtest.log.success("Geometry output data is as expected") pipe: rd.PipeState = self.controller.GetPipelineState() tex = rd.TextureDisplay() tex.resourceId = pipe.GetOutputTargets()[0].resourceId out.SetTextureDisplay(tex) texdetails = self.get_texture(tex.resourceId) picked: rd.PixelValue = out.PickPixel(tex.resourceId, False, int(texdetails.width / 2), int(texdetails.height / 2), 0, 0, 0) if not rdtest.value_compare(picked.floatValue, [0.0, 1.0, 0.0, 1.0]): raise rdtest.TestFailureException( "Picked value {} doesn't match expectation".format( picked.floatValue)) rdtest.log.success("Triangle picked value is as expected") out.Shutdown()
def check_capture(self): self.check_final_backbuffer() for level in ["Primary", "Secondary"]: rdtest.log.print("Checking {} indirect calls".format(level)) dispatches = self.find_draw("{}: Dispatches".format(level)) # Set up a ReplayOutput and TextureSave for quickly testing the drawcall highlight overlay out: rd.ReplayOutput = self.controller.CreateOutput( rd.CreateHeadlessWindowingData(), rd.ReplayOutputType.Texture) self.check(out is not None) out.SetDimensions(100, 100) tex = rd.TextureDisplay() tex.overlay = rd.DebugOverlay.Drawcall save_data = rd.TextureSave() save_data.destType = rd.FileType.PNG # Rewind to the start of the capture draw: rd.DrawcallDescription = dispatches.children[0] while draw.previous is not None: draw = draw.previous # Ensure we can select all draws while draw is not None: self.controller.SetFrameEvent(draw.eventId, False) draw = draw.next rdtest.log.success("Selected all {} draws".format(level)) self.check(dispatches and len(dispatches.children) == 3) self.check(dispatches.children[0].dispatchDimension == [0, 0, 0]) self.check(dispatches.children[1].dispatchDimension == [1, 1, 1]) self.check(dispatches.children[2].dispatchDimension == [3, 4, 5]) rdtest.log.success( "{} Indirect dispatches are the correct dimensions".format( level)) self.controller.SetFrameEvent(dispatches.children[2].eventId, False) pipe: rd.PipeState = self.controller.GetPipelineState() ssbo: rd.BoundResource = pipe.GetReadWriteResources( rd.ShaderStage.Compute)[0].resources[0] data: bytes = self.controller.GetBufferData(ssbo.resourceId, 0, 0) rdtest.log.print("Got {} bytes of uints".format(len(data))) uints = [ struct.unpack_from('=4L', data, offs) for offs in range(0, len(data), 16) ] for x in range(0, 6): # 3 groups of 2 threads each for y in range(0, 8): # 3 groups of 2 threads each for z in range(0, 5): # 5 groups of 1 thread each idx = 100 + z * 8 * 6 + y * 6 + x if not rdtest.value_compare(uints[idx], [x, y, z, 12345]): raise rdtest.TestFailureException( 'expected thread index data @ {},{},{}: {} is not as expected: {}' .format(x, y, z, uints[idx], [x, y, z, 12345])) rdtest.log.success( "Dispatched buffer contents are as expected for {}".format( level)) empties = self.find_draw("{}: Empty draws".format(level)) self.check(empties and len(empties.children) == 2) draw: rd.DrawcallDescription for draw in empties.children: self.check(draw.numIndices == 0) self.check(draw.numInstances == 0) self.controller.SetFrameEvent(draw.eventId, False) # Check that we have empty PostVS postvs_data = self.get_postvs(rd.MeshDataStage.VSOut, 0, 1) self.check(len(postvs_data) == 0) self.check_overlay(draw.eventId, out, tex, save_data) rdtest.log.success("{} empty draws are empty".format(level)) indirects = self.find_draw("{}: Indirect draws".format(level)) self.check('vkCmdDrawIndirect' in indirects.children[0].name) self.check( 'vkCmdDrawIndexedIndirect' in indirects.children[1].name) self.check(len(indirects.children[1].children) == 2) rdtest.log.success( "Correct number of {} indirect draws".format(level)) # vkCmdDrawIndirect(...) draw = indirects.children[0] self.check(draw.numIndices == 3) self.check(draw.numInstances == 2) self.controller.SetFrameEvent(draw.eventId, False) # Check that we have PostVS as expected postvs_data = self.get_postvs(rd.MeshDataStage.VSOut) postvs_ref = { 0: { 'vtx': 0, 'idx': 0, 'gl_PerVertex.gl_Position': [-0.8, -0.5, 0.0, 1.0] }, 1: { 'vtx': 1, 'idx': 1, 'gl_PerVertex.gl_Position': [-0.7, -0.8, 0.0, 1.0] }, 2: { 'vtx': 2, 'idx': 2, 'gl_PerVertex.gl_Position': [-0.6, -0.5, 0.0, 1.0] }, } self.check_mesh_data(postvs_ref, postvs_data) self.check(len(postvs_data) == len( postvs_ref)) # We shouldn't have any extra vertices self.check_overlay(draw.eventId, out, tex, save_data) rdtest.log.success("{} {} is as expected".format(level, draw.name)) # vkCmdDrawIndexedIndirect[0](...) draw = indirects.children[1].children[0] self.check(draw.numIndices == 3) self.check(draw.numInstances == 3) self.controller.SetFrameEvent(draw.eventId, False) # Check that we have PostVS as expected postvs_data = self.get_postvs(rd.MeshDataStage.VSOut) # These indices are the *output* indices, which have been rebased/remapped, so are not the same as the input # indices postvs_ref = { 0: { 'vtx': 0, 'idx': 0, 'gl_PerVertex.gl_Position': [-0.6, -0.5, 0.0, 1.0] }, 1: { 'vtx': 1, 'idx': 1, 'gl_PerVertex.gl_Position': [-0.5, -0.8, 0.0, 1.0] }, 2: { 'vtx': 2, 'idx': 2, 'gl_PerVertex.gl_Position': [-0.4, -0.5, 0.0, 1.0] }, } self.check_mesh_data(postvs_ref, postvs_data) self.check(len(postvs_data) == len( postvs_ref)) # We shouldn't have any extra vertices self.check_overlay(draw.eventId, out, tex, save_data) rdtest.log.success("{} {} is as expected".format(level, draw.name)) # vkCmdDrawIndexedIndirect[1](...) draw = indirects.children[1].children[1] self.check(draw.numIndices == 6) self.check(draw.numInstances == 2) self.controller.SetFrameEvent(draw.eventId, False) # Check that we have PostVS as expected postvs_data = self.get_postvs(rd.MeshDataStage.VSOut) postvs_ref = { 0: { 'vtx': 0, 'idx': 0, 'gl_PerVertex.gl_Position': [-0.4, -0.5, 0.0, 1.0] }, 1: { 'vtx': 1, 'idx': 1, 'gl_PerVertex.gl_Position': [-0.3, -0.8, 0.0, 1.0] }, 2: { 'vtx': 2, 'idx': 2, 'gl_PerVertex.gl_Position': [-0.2, -0.8, 0.0, 1.0] }, 3: { 'vtx': 3, 'idx': 3, 'gl_PerVertex.gl_Position': [-0.1, -0.5, 0.0, 1.0] }, 4: { 'vtx': 4, 'idx': 4, 'gl_PerVertex.gl_Position': [0.0, -0.8, 0.0, 1.0] }, 5: { 'vtx': 5, 'idx': 5, 'gl_PerVertex.gl_Position': [0.1, -0.8, 0.0, 1.0] }, } self.check_mesh_data(postvs_ref, postvs_data) self.check(len(postvs_data) == len( postvs_ref)) # We shouldn't have any extra vertices self.check_overlay(draw.eventId, out, tex, save_data) rdtest.log.success("{} {} is as expected".format(level, draw.name)) indirect_count_root = self.find_draw( "{}: KHR_draw_indirect_count".format(level)) if indirect_count_root is not None: self.check(indirect_count_root.children[0].name == '{}: Empty count draws'.format(level)) self.check(indirect_count_root.children[1].name == '{}: Indirect count draws'.format(level)) empties = indirect_count_root.children[0] self.check(empties and len(empties.children) == 2) draw: rd.DrawcallDescription for draw in empties.children: self.check(draw.numIndices == 0) self.check(draw.numInstances == 0) self.controller.SetFrameEvent(draw.eventId, False) # Check that we have empty PostVS postvs_data = self.get_postvs(rd.MeshDataStage.VSOut, 0, 1) self.check(len(postvs_data) == 0) self.check_overlay(draw.eventId, out, tex, save_data) # vkCmdDrawIndirectCountKHR draw_indirect = indirect_count_root.children[1].children[0] self.check(draw_indirect and len(draw_indirect.children) == 1) # vkCmdDrawIndirectCountKHR[0] draw = draw_indirect.children[0] self.check(draw.numIndices == 3) self.check(draw.numInstances == 4) self.controller.SetFrameEvent(draw.eventId, False) # Check that we have PostVS as expected postvs_data = self.get_postvs(rd.MeshDataStage.VSOut) # These indices are the *output* indices, which have been rebased/remapped, so are not the same as the input # indices postvs_ref = { 0: { 'vtx': 0, 'idx': 0, 'gl_PerVertex.gl_Position': [-0.8, 0.5, 0.0, 1.0] }, 1: { 'vtx': 1, 'idx': 1, 'gl_PerVertex.gl_Position': [-0.7, 0.2, 0.0, 1.0] }, 2: { 'vtx': 2, 'idx': 2, 'gl_PerVertex.gl_Position': [-0.6, 0.5, 0.0, 1.0] }, } self.check_mesh_data(postvs_ref, postvs_data) self.check(len(postvs_data) == len( postvs_ref)) # We shouldn't have any extra vertices self.check_overlay(draw.eventId, out, tex, save_data) rdtest.log.success("{} {} is as expected".format( level, draw.name)) # vkCmdDrawIndexedIndirectCountKHR draw_indirect = indirect_count_root.children[1].children[1] self.check(draw_indirect and len(draw_indirect.children) == 3) # vkCmdDrawIndirectCountKHR[0] draw = draw_indirect.children[0] self.check(draw.numIndices == 3) self.check(draw.numInstances == 1) self.controller.SetFrameEvent(draw.eventId, False) # Check that we have PostVS as expected postvs_data = self.get_postvs(rd.MeshDataStage.VSOut) # These indices are the *output* indices, which have been rebased/remapped, so are not the same as the input # indices postvs_ref = { 0: { 'vtx': 0, 'idx': 0, 'gl_PerVertex.gl_Position': [-0.6, 0.5, 0.0, 1.0] }, 1: { 'vtx': 1, 'idx': 1, 'gl_PerVertex.gl_Position': [-0.5, 0.2, 0.0, 1.0] }, 2: { 'vtx': 2, 'idx': 2, 'gl_PerVertex.gl_Position': [-0.4, 0.5, 0.0, 1.0] }, } self.check_mesh_data(postvs_ref, postvs_data) self.check(len(postvs_data) == len( postvs_ref)) # We shouldn't have any extra vertices self.check_overlay(draw.eventId, out, tex, save_data) rdtest.log.success("{} {} is as expected".format( level, draw.name)) # vkCmdDrawIndirectCountKHR[1] draw = draw_indirect.children[1] self.check(draw.numIndices == 0) self.check(draw.numInstances == 0) self.controller.SetFrameEvent(draw.eventId, False) postvs_data = self.get_postvs(rd.MeshDataStage.VSOut) self.check(len(postvs_data) == 0) self.check_overlay(draw.eventId, out, tex, save_data) rdtest.log.success("{} {} is as expected".format( level, draw.name)) # vkCmdDrawIndirectCountKHR[2] draw = draw_indirect.children[2] self.check(draw.numIndices == 6) self.check(draw.numInstances == 2) self.controller.SetFrameEvent(draw.eventId, False) # Check that we have PostVS as expected postvs_data = self.get_postvs(rd.MeshDataStage.VSOut) # These indices are the *output* indices, which have been rebased/remapped, so are not the same as the input # indices postvs_ref = { 0: { 'vtx': 0, 'idx': 0, 'gl_PerVertex.gl_Position': [-0.4, 0.5, 0.0, 1.0] }, 1: { 'vtx': 1, 'idx': 1, 'gl_PerVertex.gl_Position': [-0.3, 0.2, 0.0, 1.0] }, 2: { 'vtx': 2, 'idx': 2, 'gl_PerVertex.gl_Position': [-0.2, 0.2, 0.0, 1.0] }, 3: { 'vtx': 3, 'idx': 3, 'gl_PerVertex.gl_Position': [-0.1, 0.5, 0.0, 1.0] }, 4: { 'vtx': 4, 'idx': 4, 'gl_PerVertex.gl_Position': [0.0, 0.2, 0.0, 1.0] }, 5: { 'vtx': 5, 'idx': 5, 'gl_PerVertex.gl_Position': [0.1, 0.2, 0.0, 1.0] }, } self.check_mesh_data(postvs_ref, postvs_data) self.check(len(postvs_data) == len( postvs_ref)) # We shouldn't have any extra vertices self.check_overlay(draw.eventId, out, tex, save_data) rdtest.log.success("{} {} is as expected".format( level, draw.name)) else: rdtest.log.print("KHR_draw_indirect_count not tested")
def check_capture(self): fill = self.find_action("vkCmdFillBuffer") self.check(fill is not None) buffer_usage = {} for usage in self.controller.GetUsage(fill.copyDestination): usage: rd.EventUsage if usage.eventId not in buffer_usage: buffer_usage[usage.eventId] = [] buffer_usage[usage.eventId].append(usage.usage) # The texture is the backbuffer tex = self.get_last_action().copyDestination for level in ["Primary", "Secondary"]: rdtest.log.print("Checking {} indirect calls".format(level)) final = self.find_action("{}: Final".format(level)) indirect_count_root = self.find_action( "{}: KHR_action_indirect_count".format(level)) self.controller.SetFrameEvent(final.eventId, False) # Check the top row, non indirect count and always present self.check_pixel_value(tex, 60, 60, [1.0, 0.0, 0.0, 1.0]) self.check_pixel_value(tex, 100, 60, [0.0, 0.0, 1.0, 1.0]) self.check_pixel_value(tex, 145, 35, [1.0, 1.0, 0.0, 1.0]) self.check_pixel_value(tex, 205, 35, [0.0, 1.0, 1.0, 1.0]) # if present, check bottom row of indirect count as well as post-count calls if indirect_count_root is not None: self.check_pixel_value(tex, 60, 220, [0.0, 1.0, 0.0, 1.0]) self.check_pixel_value(tex, 100, 220, [1.0, 0.0, 1.0, 1.0]) self.check_pixel_value(tex, 145, 185, [0.5, 1.0, 0.0, 1.0]) self.check_pixel_value(tex, 205, 185, [0.5, 0.0, 1.0, 1.0]) self.check_pixel_value(tex, 340, 40, [1.0, 0.5, 0.0, 1.0]) self.check_pixel_value(tex, 340, 115, [1.0, 0.5, 0.5, 1.0]) self.check_pixel_value(tex, 340, 190, [1.0, 0.0, 0.5, 1.0]) dispatches = self.find_action("{}: Dispatches".format(level)) # Set up a ReplayOutput and TextureSave for quickly testing the action highlight overlay self.out: rd.ReplayOutput = self.controller.CreateOutput( rd.CreateHeadlessWindowingData(100, 100), rd.ReplayOutputType.Texture) self.check(self.out is not None) # Rewind to the start of the capture action: rd.ActionDescription = dispatches.children[0] while action.previous is not None: action = action.previous # Ensure we can select all actions while action is not None: self.controller.SetFrameEvent(action.eventId, False) action = action.next rdtest.log.success("Selected all {} actions".format(level)) self.check(dispatches and len(real_action_children(dispatches)) == 3) self.check(dispatches.children[0].dispatchDimension == (0, 0, 0)) self.check(dispatches.children[1].dispatchDimension == (1, 1, 1)) self.check(dispatches.children[2].dispatchDimension == (3, 4, 5)) rdtest.log.success( "{} Indirect dispatches are the correct dimensions".format( level)) self.controller.SetFrameEvent(dispatches.children[2].eventId, False) pipe: rd.PipeState = self.controller.GetPipelineState() ssbo: rd.BoundResource = pipe.GetReadWriteResources( rd.ShaderStage.Compute)[0].resources[0] data: bytes = self.controller.GetBufferData(ssbo.resourceId, 0, 0) rdtest.log.print("Got {} bytes of uints".format(len(data))) uints = [ struct.unpack_from('=4L', data, offs) for offs in range(0, len(data), 16) ] for x in range(0, 6): # 3 groups of 2 threads each for y in range(0, 8): # 3 groups of 2 threads each for z in range(0, 5): # 5 groups of 1 thread each idx = 100 + z * 8 * 6 + y * 6 + x if not rdtest.value_compare(uints[idx], [x, y, z, 12345]): raise rdtest.TestFailureException( 'expected thread index data @ {},{},{}: {} is not as expected: {}' .format(x, y, z, uints[idx], [x, y, z, 12345])) rdtest.log.success( "Dispatched buffer contents are as expected for {}".format( level)) empties = self.find_action("{}: Empty draws".format(level)) self.check(empties and len(real_action_children(empties)) == 2) action: rd.ActionDescription for action in real_action_children(empties): self.check(action.numIndices == 0) self.check(action.numInstances == 0) self.controller.SetFrameEvent(action.eventId, False) # Check that we have empty PostVS postvs_data = self.get_postvs(action, rd.MeshDataStage.VSOut, 0, 1) self.check(len(postvs_data) == 0) # No samples should be passing in the empties self.check_overlay([]) rdtest.log.success("{} empty actions are empty".format(level)) indirects = self.find_action("{}: Indirect draws".format(level)) self.check('vkCmdDrawIndirect' in indirects.children[0].customName) self.check( 'vkCmdDrawIndexedIndirect' in indirects.children[1].customName) self.check(len(real_action_children(indirects.children[1])) == 2) rdtest.log.success( "Correct number of {} indirect draws".format(level)) # vkCmdDrawIndirect(...) action = indirects.children[0] self.check(action.numIndices == 3) self.check(action.numInstances == 2) self.controller.SetFrameEvent(action.eventId, False) self.check( rd.ResourceUsage.Indirect in buffer_usage[action.eventId]) # Check that we have PostVS as expected postvs_data = self.get_postvs(action, rd.MeshDataStage.VSOut) postvs_ref = { 0: { 'vtx': 0, 'idx': 0, 'gl_PerVertex_var.gl_Position': [-0.8, -0.5, 0.0, 1.0] }, 1: { 'vtx': 1, 'idx': 1, 'gl_PerVertex_var.gl_Position': [-0.7, -0.8, 0.0, 1.0] }, 2: { 'vtx': 2, 'idx': 2, 'gl_PerVertex_var.gl_Position': [-0.6, -0.5, 0.0, 1.0] }, } self.check_mesh_data(postvs_ref, postvs_data) self.check(len(postvs_data) == len( postvs_ref)) # We shouldn't have any extra vertices self.check_overlay([(60, 40)]) rdtest.log.success("{} {} is as expected".format( level, action.customName)) self.check(rd.ResourceUsage.Indirect in buffer_usage[ indirects.children[1].eventId]) # vkCmdDrawIndexedIndirect[0](...) action = indirects.children[1].children[0] self.check(action.numIndices == 3) self.check(action.numInstances == 3) self.controller.SetFrameEvent(action.eventId, False) # Check that we have PostVS as expected postvs_data = self.get_postvs(action, rd.MeshDataStage.VSOut) # These indices are the *output* indices, which have been rebased/remapped, so are not the same as the input # indices postvs_ref = { 0: { 'vtx': 0, 'idx': 6, 'gl_PerVertex_var.gl_Position': [-0.6, -0.5, 0.0, 1.0] }, 1: { 'vtx': 1, 'idx': 7, 'gl_PerVertex_var.gl_Position': [-0.5, -0.8, 0.0, 1.0] }, 2: { 'vtx': 2, 'idx': 8, 'gl_PerVertex_var.gl_Position': [-0.4, -0.5, 0.0, 1.0] }, } self.check_mesh_data(postvs_ref, postvs_data) self.check(len(postvs_data) == len( postvs_ref)) # We shouldn't have any extra vertices self.check_overlay([(100, 40)]) rdtest.log.success("{} {} is as expected".format( level, action.customName)) # vkCmdDrawIndexedIndirect[1](...) action = indirects.children[1].children[1] self.check(action.numIndices == 6) self.check(action.numInstances == 2) self.controller.SetFrameEvent(action.eventId, False) # Check that we have PostVS as expected postvs_data = self.get_postvs(action, rd.MeshDataStage.VSOut) postvs_ref = { 0: { 'vtx': 0, 'idx': 9, 'gl_PerVertex_var.gl_Position': [-0.4, -0.5, 0.0, 1.0] }, 1: { 'vtx': 1, 'idx': 10, 'gl_PerVertex_var.gl_Position': [-0.3, -0.8, 0.0, 1.0] }, 2: { 'vtx': 2, 'idx': 11, 'gl_PerVertex_var.gl_Position': [-0.2, -0.8, 0.0, 1.0] }, 3: { 'vtx': 3, 'idx': 12, 'gl_PerVertex_var.gl_Position': [-0.1, -0.5, 0.0, 1.0] }, 4: { 'vtx': 4, 'idx': 13, 'gl_PerVertex_var.gl_Position': [0.0, -0.8, 0.0, 1.0] }, 5: { 'vtx': 5, 'idx': 14, 'gl_PerVertex_var.gl_Position': [0.1, -0.8, 0.0, 1.0] }, } self.check_mesh_data(postvs_ref, postvs_data) self.check(len(postvs_data) == len( postvs_ref)) # We shouldn't have any extra vertices self.check_overlay([(140, 40), (200, 40)]) rdtest.log.success("{} {} is as expected".format( level, action.customName)) if indirect_count_root is not None: self.check(indirect_count_root.children[0].customName == '{}: Empty count draws'.format(level)) self.check(indirect_count_root.children[1].customName == '{}: Indirect count draws'.format(level)) empties = indirect_count_root.children[0] self.check(empties and len(real_action_children(empties)) == 3) action: rd.ActionDescription for action in real_action_children(empties.children): self.check(action.numIndices == 0) self.check(action.numInstances == 0) self.controller.SetFrameEvent(action.eventId, False) # Check that we have empty PostVS postvs_data = self.get_postvs(action, rd.MeshDataStage.VSOut, 0, 1) self.check(len(postvs_data) == 0) self.check_overlay([], no_overlay=True) # vkCmdDrawIndirectCountKHR action_indirect = indirect_count_root.children[1].children[0] self.check(rd.ResourceUsage.Indirect in buffer_usage[ action_indirect.eventId]) self.check(action_indirect and len(real_action_children(action_indirect)) == 1) # vkCmdDrawIndirectCountKHR[0] action = action_indirect.children[0] self.check(action.numIndices == 3) self.check(action.numInstances == 4) self.controller.SetFrameEvent(action.eventId, False) # Check that we have PostVS as expected postvs_data = self.get_postvs(action, rd.MeshDataStage.VSOut) # These indices are the *output* indices, which have been rebased/remapped, so are not the same as the input # indices postvs_ref = { 0: { 'vtx': 0, 'idx': 0, 'gl_PerVertex_var.gl_Position': [-0.8, 0.5, 0.0, 1.0] }, 1: { 'vtx': 1, 'idx': 1, 'gl_PerVertex_var.gl_Position': [-0.7, 0.2, 0.0, 1.0] }, 2: { 'vtx': 2, 'idx': 2, 'gl_PerVertex_var.gl_Position': [-0.6, 0.5, 0.0, 1.0] }, } self.check_mesh_data(postvs_ref, postvs_data) self.check(len(postvs_data) == len( postvs_ref)) # We shouldn't have any extra vertices self.check_overlay([(60, 190)]) rdtest.log.success("{} {} is as expected".format( level, action.customName)) # vkCmdDrawIndexedIndirectCountKHR action_indirect = indirect_count_root.children[1].children[1] self.check(action_indirect and len(real_action_children(action_indirect)) == 3) # vkCmdDrawIndirectCountKHR[0] action = action_indirect.children[0] self.check(action.numIndices == 3) self.check(action.numInstances == 1) self.controller.SetFrameEvent(action.eventId, False) # Check that we have PostVS as expected postvs_data = self.get_postvs(action, rd.MeshDataStage.VSOut) # These indices are the *output* indices, which have been rebased/remapped, so are not the same as the input # indices postvs_ref = { 0: { 'vtx': 0, 'idx': 15, 'gl_PerVertex_var.gl_Position': [-0.6, 0.5, 0.0, 1.0] }, 1: { 'vtx': 1, 'idx': 16, 'gl_PerVertex_var.gl_Position': [-0.5, 0.2, 0.0, 1.0] }, 2: { 'vtx': 2, 'idx': 17, 'gl_PerVertex_var.gl_Position': [-0.4, 0.5, 0.0, 1.0] }, } self.check_mesh_data(postvs_ref, postvs_data) self.check(len(postvs_data) == len( postvs_ref)) # We shouldn't have any extra vertices self.check_overlay([(100, 190)]) rdtest.log.success("{} {} is as expected".format( level, action.customName)) # vkCmdDrawIndirectCountKHR[1] action = action_indirect.children[1] self.check(action.numIndices == 0) self.check(action.numInstances == 0) self.controller.SetFrameEvent(action.eventId, False) postvs_data = self.get_postvs(action, rd.MeshDataStage.VSOut) self.check(len(postvs_data) == 0) self.check_overlay([]) rdtest.log.success("{} {} is as expected".format( level, action.customName)) # vkCmdDrawIndirectCountKHR[2] action = action_indirect.children[2] self.check(action.numIndices == 6) self.check(action.numInstances == 2) self.controller.SetFrameEvent(action.eventId, False) # Check that we have PostVS as expected postvs_data = self.get_postvs(action, rd.MeshDataStage.VSOut) # These indices are the *output* indices, which have been rebased/remapped, so are not the same as the input # indices postvs_ref = { 0: { 'vtx': 0, 'idx': 18, 'gl_PerVertex_var.gl_Position': [-0.4, 0.5, 0.0, 1.0] }, 1: { 'vtx': 1, 'idx': 19, 'gl_PerVertex_var.gl_Position': [-0.3, 0.2, 0.0, 1.0] }, 2: { 'vtx': 2, 'idx': 20, 'gl_PerVertex_var.gl_Position': [-0.2, 0.2, 0.0, 1.0] }, 3: { 'vtx': 3, 'idx': 21, 'gl_PerVertex_var.gl_Position': [-0.1, 0.5, 0.0, 1.0] }, 4: { 'vtx': 4, 'idx': 22, 'gl_PerVertex_var.gl_Position': [0.0, 0.2, 0.0, 1.0] }, 5: { 'vtx': 5, 'idx': 23, 'gl_PerVertex_var.gl_Position': [0.1, 0.2, 0.0, 1.0] }, } self.check_mesh_data(postvs_ref, postvs_data) self.check(len(postvs_data) == len( postvs_ref)) # We shouldn't have any extra vertices self.check_overlay([(140, 190), (200, 190)]) rdtest.log.success("{} {} is as expected".format( level, action.customName)) # Now check that the draws post-count are correctly highlighted self.controller.SetFrameEvent( self.find_action( "{}: Post-count 1".format(level)).children[0].eventId, False) self.check_overlay([(340, 40)]) self.controller.SetFrameEvent( self.find_action( "{}: Post-count 2".format(level)).children[0].eventId, False) self.check_overlay([(340, 190)]) self.controller.SetFrameEvent( self.find_action( "{}: Post-count 3".format(level)).children[0].eventId, False) self.check_overlay([(340, 115)]) else: rdtest.log.print("KHR_action_indirect_count not tested")
def check_capture_with_controller(self, proxy_api: str): self.controller: rd.ReplayController any_failed = False if proxy_api != '': rdtest.log.print('Running with {} local proxy'.format(proxy_api)) self.proxied = True else: rdtest.log.print('Running on direct replay') self.proxied = False self.out: rd.ReplayOutput = self.controller.CreateOutput( rd.CreateHeadlessWindowingData(100, 100), rd.ReplayOutputType.Texture) for d in self.controller.GetRootActions(): if 'slice tests' in d.customName: for sub in d.children: if sub.flags & rd.ActionFlags.Drawcall: self.controller.SetFrameEvent(sub.eventId, True) pipe = self.controller.GetPipelineState() tex_id = pipe.GetReadOnlyResources( rd.ShaderStage.Pixel)[0].resources[0].resourceId for mip in [0, 1]: for sl in [16, 17, 18]: expected = [0.0, 0.0, 1.0, 1.0] if sl == 17: expected = [0.0, 1.0, 0.0, 1.0] cur_sub = rd.Subresource(mip, sl) comp_type = rd.CompType.Typeless # test that pixel picking sees the right things picked = self.controller.PickPixel( tex_id, 15, 15, cur_sub, comp_type) if not rdtest.value_compare( picked.floatValue, expected): raise rdtest.TestFailureException( "Expected to pick {} at slice {} mip {}, got {}" .format(expected, sl, mip, picked.floatValue)) rdtest.log.success( 'Picked pixel is correct at slice {} mip {}' .format(sl, mip)) # Render output texture a three scales - below 100%, 100%, above 100% tex_display = rd.TextureDisplay() tex_display.resourceId = tex_id tex_display.subresource = cur_sub tex_display.typeCast = comp_type # convert the unorm values to byte values for comparison expected = [ int(a * 255) for a in expected[0:3] ] for scale in [0.9, 1.0, 1.1]: tex_display.scale = scale self.out.SetTextureDisplay(tex_display) self.out.Display() pixels: bytes = self.out.ReadbackOutputTexture( ) actual = [int(a) for a in pixels[0:3]] if not rdtest.value_compare( actual, expected): raise rdtest.TestFailureException( "Expected to display {} at slice {} mip {} scale {}%, got {}" .format(expected, sl, mip, int(scale * 100), actual)) rdtest.log.success( 'Displayed pixel is correct at scale {}% in slice {} mip {}' .format(int(scale * 100), sl, mip)) elif sub.flags & rd.ActionFlags.SetMarker: rdtest.log.print( 'Checking {} for slice display'.format( sub.customName)) continue # Check each region for the tests within if d.flags & rd.ActionFlags.PushMarker: name = '' tests_run = 0 failed = False # Iterate over actions in this region for sub in d.children: sub: rd.ActionDescription if sub.flags & rd.ActionFlags.SetMarker: name = sub.customName # Check this action if sub.flags & rd.ActionFlags.Drawcall: tests_run = tests_run + 1 try: # Set this event as current self.controller.SetFrameEvent(sub.eventId, True) self.filename = (d.customName + '@' + name).replace('->', '_') self.check_test(d.customName, name, Texture_Zoo.TEST_CAPTURE) except rdtest.TestFailureException as ex: failed = any_failed = True rdtest.log.error(str(ex)) if not failed: rdtest.log.success( "All {} texture tests for {} are OK".format( tests_run, d.customName)) self.out.Shutdown() self.out = None if not any_failed: if proxy_api != '': rdtest.log.success( 'All textures are OK with {} as local proxy'.format( proxy_api)) else: rdtest.log.success("All textures are OK on direct replay") else: raise rdtest.TestFailureException( "Some tests were not as expected")