def check_capture(self, capture_filename: str,
controller: rd.ReplayController):
self.controller = controller
self.controller.SetFrameEvent(
self.find_draw("Quad").next.eventId, False)
self.out: rd.ReplayOutput = self.controller.CreateOutput(
rd.CreateHeadlessWindowingData(200, 200), rd.ReplayOutputType.Mesh)
pipe: rd.PipeState = self.controller.GetPipelineState()
self.cfg = rd.MeshDisplay()
cam: rd.Camera = rd.InitCamera(rd.CameraType.FPSLook)
cam.SetPosition(0, 0, 0)
cam.SetFPSRotation(0, 0, 0)
self.cfg.type = rd.MeshDataStage.VSOut
self.cfg.cam = cam
# Position is always first, so getting the postvs data will give us
inst0: rd.MeshFormat = self.controller.GetPostVSData(
0, 0, self.cfg.type)
self.cfg.position = inst0
# after position we have float2 Color2 then float4 Color4
self.cfg.second = self.cfg.position
self.cfg.second.vertexByteOffset += 16
self.cfg.second.vertexByteOffset += 8
if pipe.HasAlignedPostVSData(self.cfg.type):
self.cfg.second.vertexByteOffset += 8
# Configure an ortho camera, even though we don't really have a camera
self.cfg.ortho = True
self.cfg.position.nearPlane = 1.0
self.cfg.position.farPlane = 100.0
self.cfg.aspect = 1.0
self.cfg.wireframeDraw = True
self.cfg.position.meshColor = rd.FloatVector(1.0, 0.0, 1.0, 1.0)
self.cache_output()
# We should have a single quad, check each outside edge and the inside diagonal.
# All these line segments should have some colors (not including the background checkerboard or the frustum)
self.check_region((55, 95, 65, 95), lambda x: x != []) # Left edge
self.check_region((85, 60, 85, 70), lambda x: x != []) # Top edge
self.check_region((105, 100, 115, 100),
lambda x: x != []) # Right edge
self.check_region((90, 130, 90, 140), lambda x: x != []) # Bottom edge
self.check_region((65, 120, 75, 120),
lambda x: x != []) # Bottom-Left of diagonal
self.check_region((105, 70, 110, 70),
lambda x: x != []) # Top-right of diagonal
rdtest.log.success("Base rendering is as expected")
self.cfg.solidShadeMode = rd.SolidShade.Secondary
self.cfg.wireframeDraw = False
# allow for blending with white for the frustum
isred = lambda col: col[0] > col[1] and col[1] == col[2]
isgreen = lambda col: col[1] > col[0] and col[0] == col[2]
isblue = lambda col: col[2] > col[0] and col[0] == col[1]
isredgreen = lambda col: isred(col) or isgreen(col) or col[2] == 0
isyellow = lambda col: col[0] == col[1] and col[2] < col[1]
self.cache_output()
# The secondary color should be completely green
self.check_region((85, 70, 85, 125),
lambda x: all([isgreen(i) for i in x]))
self.check_region((65, 100, 105, 100),
lambda x: all([isgreen(i) for i in x]))
# this line segment isn't in the first instance
self.check_region((65, 55, 105, 55), lambda x: x == [])
# this line segment isn't in the second instance
self.check_region((65, 125, 105, 125),
lambda x: all([isgreen(i) for i in x]))
rdtest.log.success("Secondary rendering of instance 0 is as expected")
# Out of bounds should look the same as without highlighting at all, check the corners are all still green
self.cfg.highlightVert = 9
self.cache_output()
self.check_region((55, 60, 65, 70),
lambda x: all([isgreen(i) for i in x]))
self.check_region((105, 60, 115, 70),
lambda x: all([isgreen(i) for i in x]))
self.check_region((55, 130, 65, 140),
lambda x: all([isgreen(i) for i in x]))
self.check_region((105, 130, 115, 140),
lambda x: all([isgreen(i) for i in x]))
vert_regions = [
(55, 60, 65, 70),
(110, 60, 120, 70),
(55, 130, 65, 140),
(110, 60, 120, 70),
(110, 130, 120, 140),
(55, 130, 65, 140),
]
for vert in range(6):
self.cfg.highlightVert = vert
self.cache_output()
tri = int(vert / 3)
# Check that the triangle we're highlighting is red and the other is green
if tri == 0:
self.check_region((65, 75, 75, 85),
lambda x: all([isred(i) for i in x]))
self.check_region((100, 115, 110, 125),
lambda x: all([isgreen(i) for i in x]))
else:
self.check_region((65, 75, 75, 85),
lambda x: all([isgreen(i) for i in x]))
self.check_region((100, 115, 110, 125),
lambda x: all([isred(i) for i in x]))
# The corners that touch should be red and green - that is no other colours but red and green, but at least
# some red and some green
self.check_region(
(65, 115, 75, 125),
lambda x: all([isredgreen(i) for i in x]) and any(
[isred(i) for i in x]) and any([isgreen(i) for i in x]))
# check that there's blue in this vertex's region
self.check_region(vert_regions[vert],
lambda x: any([isblue(i) for i in x]))
rdtest.log.success("Rendering of highlighted vertices is as expected")
self.cfg.highlightVert = rd.MeshDisplay.NoHighlight
# If we render from the float2 color we shouldn't get any blue
self.cfg.second.vertexByteOffset = self.cfg.position.vertexByteOffset = inst0.vertexByteOffset
self.cfg.second.vertexByteOffset += 16
self.cfg.second.format.compCount = 2
self.cache_output()
# If we render from the float2 color we shouldn't get any blue since it's only a two-component value
self.check_region((85, 70, 85, 125),
lambda x: all([isredgreen(i) for i in x]))
self.check_region((65, 100, 105, 100),
lambda x: all([isredgreen(i) for i in x]))
self.check_region((65, 55, 105, 55), lambda x: x == [])
self.check_region((65, 125, 105, 125),
lambda x: all([isredgreen(i) for i in x]))
rdtest.log.success(
"Rendering of float2 color secondary in instance 0 is as expected")
self.cfg.highlightVert = rd.MeshDisplay.NoHighlight
inst1: rd.MeshFormat = self.controller.GetPostVSData(
1, 0, self.cfg.type)
self.cfg.curInstance = 1
self.cfg.second.vertexResourceId = self.cfg.position.vertexResourceId = inst1.vertexResourceId
self.cfg.second.vertexByteOffset = self.cfg.position.vertexByteOffset = inst1.vertexByteOffset
self.cfg.second.vertexByteOffset += 16
self.cfg.second.vertexByteOffset += 8
if pipe.HasAlignedPostVSData(self.cfg.type):
self.cfg.second.vertexByteOffset += 8
self.cache_output()
# The secondary color should be completely yellow
self.check_region((85, 70, 85, 125),
lambda x: all([isyellow(i) for i in x]))
self.check_region((65, 100, 105, 100),
lambda x: all([isyellow(i) for i in x]))
# this line segment isn't in the first instance
self.check_region((65, 55, 105, 55),
lambda x: all([isyellow(i) for i in x]))
# this line segment isn't in the second instance
self.check_region((65, 125, 105, 125), lambda x: x == [])
rdtest.log.success("Secondary rendering of instance 1 is as expected")
# If we render from the float2 color we shouldn't get any blue
self.cfg.second.vertexByteOffset = self.cfg.position.vertexByteOffset = inst1.vertexByteOffset
self.cfg.second.vertexByteOffset += 16
self.cfg.second.format.compCount = 2
self.cache_output()
# If we render from the float2 color we shouldn't get any blue since it's only a two-component value
self.check_region((85, 70, 85, 125),
lambda x: all([isredgreen(i) for i in x]))
self.check_region((65, 100, 105, 100),
lambda x: all([isredgreen(i) for i in x]))
self.check_region((65, 55, 105, 55),
lambda x: all([isredgreen(i) for i in x]))
self.check_region((65, 125, 105, 125), lambda x: x == [])
rdtest.log.success(
"Rendering of float2 color secondary in instance 1 is as expected")
self.cfg.solidShadeMode = rd.SolidShade.NoSolid
self.cfg.showAllInstances = True
self.cache_output()
# wireframe for original quad should still be present
self.check_region((55, 95, 65, 95), lambda x: x != [])
self.check_region((85, 60, 85, 70), lambda x: x != [])
self.check_region((105, 100, 115, 100), lambda x: x != [])
self.check_region((90, 130, 90, 140), lambda x: x != [])
self.check_region((65, 120, 75, 120), lambda x: x != [])
self.check_region((105, 70, 110, 70), lambda x: x != [])
# But now we'll have an additional instance
self.check_region((75, 55, 85, 55), lambda x: x != [])
self.check_region((125, 85, 135, 85), lambda x: x != [])
self.check_region((105, 110, 105, 120), lambda x: x != [])
self.cfg.showWholePass = True
self.cache_output()
# same again
self.check_region((55, 95, 65, 95), lambda x: x != [])
self.check_region((85, 60, 85, 70), lambda x: x != [])
self.check_region((105, 100, 115, 100), lambda x: x != [])
self.check_region((90, 130, 90, 140), lambda x: x != [])
self.check_region((65, 120, 75, 120), lambda x: x != [])
self.check_region((105, 70, 110, 70), lambda x: x != [])
self.check_region((75, 55, 85, 55), lambda x: x != [])
self.check_region((125, 85, 135, 85), lambda x: x != [])
self.check_region((105, 110, 105, 120), lambda x: x != [])
# But now an extra previous draw
self.check_region((30, 105, 40, 105), lambda x: x != [])
self.check_region((50, 80, 50, 90), lambda x: x != [])
self.check_region((45, 130, 55, 130), lambda x: x != [])
self.check_region((30, 150, 40, 150), lambda x: x != [])
rdtest.log.success("Mesh rendering is as expected")
self.cfg.showWholePass = False
self.cfg.showAllInstances = False
# Go back to instance 0. We can ignore cfg.second now
self.cfg.curInstance = 0
self.cfg.position.vertexResourceId = inst0.vertexResourceId
self.cfg.position.vertexByteOffset = inst0.vertexByteOffset
self.cache_output()
# Just above top-left, no result
self.check_vertex(55, 60,
(rd.ReplayOutput.NoResult, rd.ReplayOutput.NoResult))
# Just inside top-left, first vertex
self.check_vertex(65, 70, (0, 0))
# Outside top-right, inside the second instance, but because we only have one instance showing should return
# no result
self.check_vertex(115, 60,
(rd.ReplayOutput.NoResult, rd.ReplayOutput.NoResult))
self.check_vertex(80, 60,
(rd.ReplayOutput.NoResult, rd.ReplayOutput.NoResult))
# In the first triangle near the top right
self.check_vertex(105, 70, (1, 0))
# In the second triangle near the top right
self.check_vertex(110, 70, (3, 0))
# In the second triangle near the middle, would be in the second instance
self.check_vertex(95, 110, (4, 0))
# In the second triangle near the bottom right
self.check_vertex(110, 130, (4, 0))
rdtest.log.success("Instance 0 picking is as expected")
# if we look at only instance 1, the results should change
self.cfg.curInstance = 1
self.cfg.position.vertexResourceId = inst1.vertexResourceId
self.cfg.position.vertexByteOffset = inst1.vertexByteOffset
self.cache_output()
self.check_vertex(55, 60,
(rd.ReplayOutput.NoResult, rd.ReplayOutput.NoResult))
self.check_vertex(65, 70,
(rd.ReplayOutput.NoResult, rd.ReplayOutput.NoResult))
self.check_vertex(115, 60, (1, 1))
self.check_vertex(80, 60, (0, 1))
self.check_vertex(105, 70, (1, 1))
self.check_vertex(110, 70, (1, 1))
self.check_vertex(95, 110, (5, 1))
self.check_vertex(110, 130,
(rd.ReplayOutput.NoResult, rd.ReplayOutput.NoResult))
rdtest.log.success("Instance 1 picking is as expected")
# Now look at both instances together, this goes 'in order' so if there is overlap the first instance wins
self.cfg.showAllInstances = True
self.cache_output()
self.check_vertex(55, 60,
(rd.ReplayOutput.NoResult, rd.ReplayOutput.NoResult))
self.check_vertex(65, 70, (0, 0))
self.check_vertex(115, 60, (1, 1))
self.check_vertex(80, 60, (0, 1))
self.check_vertex(105, 70, (1, 0))
self.check_vertex(110, 70, (3, 0))
self.check_vertex(95, 110, (4, 0))
self.check_vertex(110, 130, (4, 0))
rdtest.log.success("Both instance picking is as expected")
self.controller.SetFrameEvent(
self.find_draw("Points").next.eventId, False)
# Only one instance, just check we can see the points
self.cfg.curInstance = 0
self.cfg.position = self.controller.GetPostVSData(0, 0, self.cfg.type)
self.cfg.position.nearPlane = 1.0
self.cfg.position.farPlane = 100.0
self.cache_output()
# Picking points doesn't have any primitive, it should pick as long as it's close to the point
self.check_vertex(55, 60, (0, 0))
self.check_vertex(65, 70, (0, 0))
self.check_vertex(105, 65, (1, 0))
self.check_vertex(115, 135, (2, 0))
self.check_vertex(65, 130, (3, 0))
self.check_vertex(60, 125, (3, 0))
rdtest.log.success("Point picking is as expected")
self.controller.SetFrameEvent(
self.find_draw("Stride 0").next.eventId, False)
self.cfg.position = self.controller.GetPostVSData(0, 0, self.cfg.type)
self.cfg.position.nearPlane = 1.0
self.cfg.position.farPlane = 100.0
self.cache_output()
# Stride of 0 is unusual but valid, ensure vertex picking still works
self.check_vertex(55, 60, (0, 0))
self.check_vertex(65, 70, (0, 0))
self.check_vertex(105, 65,
(rd.ReplayOutput.NoResult, rd.ReplayOutput.NoResult))
self.check_vertex(115, 135,
(rd.ReplayOutput.NoResult, rd.ReplayOutput.NoResult))
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))