mirror of
https://github.com/encounter/dawn-cmake.git
synced 2025-08-05 11:45:54 +00:00
744d0eb4aa
Discard statements no longer affect the behavior or uniformity analysis. Update the resolver, validator, and several tests to reflect this. Some E2E tests were removed as they had loops that are now considered to be infinite. Use the DemoteToHelper transform to emulate the correct semantics on platforms where discard is (or may) terminate the invocation in a manner that would affect derivative operations. We no longer need the UnwindDiscardFunctions transform for HLSL, which already implements the correct semantics. However, we still run the DemoteToHelper transform for the HLSL backend due to issues with FXC's handling of discard statements (see crbug.com/tint/1118). Fixed: tint:1723 Change-Id: Ib49ff187919ae81c4af8675e1b66acd57e2ff7d2 Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/109003 Reviewed-by: Ben Clayton <bclayton@google.com> Kokoro: Kokoro <noreply+kokoro@google.com> Commit-Queue: James Price <jrprice@google.com>
81 lines
2.7 KiB
Plaintext
81 lines
2.7 KiB
Plaintext
#include <metal_stdlib>
|
|
|
|
using namespace metal;
|
|
|
|
template<typename T, size_t N>
|
|
struct tint_array {
|
|
const constant T& operator[](size_t i) const constant { return elements[i]; }
|
|
device T& operator[](size_t i) device { return elements[i]; }
|
|
const device T& operator[](size_t i) const device { return elements[i]; }
|
|
thread T& operator[](size_t i) thread { return elements[i]; }
|
|
const thread T& operator[](size_t i) const thread { return elements[i]; }
|
|
threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
|
|
const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
|
|
T elements[N];
|
|
};
|
|
|
|
struct Uniforms {
|
|
/* 0x0000 */ float2 u_scale;
|
|
/* 0x0008 */ float2 u_offset;
|
|
};
|
|
|
|
struct VertexOutputs {
|
|
float2 texcoords;
|
|
float4 position;
|
|
};
|
|
|
|
struct tint_symbol {
|
|
float2 texcoords [[user(locn0)]];
|
|
float4 position [[position]];
|
|
};
|
|
|
|
VertexOutputs vs_main_inner(uint VertexIndex, const constant Uniforms* const tint_symbol_4) {
|
|
tint_array<float2, 3> texcoord = tint_array<float2, 3>{float2(-0.5f, 0.0f), float2(1.5f, 0.0f), float2(0.5f, 2.0f)};
|
|
VertexOutputs output = {};
|
|
output.position = float4(((texcoord[VertexIndex] * 2.0f) - float2(1.0f)), 0.0f, 1.0f);
|
|
bool flipY = ((*(tint_symbol_4)).u_scale[1] < 0.0f);
|
|
if (flipY) {
|
|
output.texcoords = ((((texcoord[VertexIndex] * (*(tint_symbol_4)).u_scale) + (*(tint_symbol_4)).u_offset) * float2(1.0f, -1.0f)) + float2(0.0f, 1.0f));
|
|
} else {
|
|
output.texcoords = ((((texcoord[VertexIndex] * float2(1.0f, -1.0f)) + float2(0.0f, 1.0f)) * (*(tint_symbol_4)).u_scale) + (*(tint_symbol_4)).u_offset);
|
|
}
|
|
return output;
|
|
}
|
|
|
|
vertex tint_symbol vs_main(const constant Uniforms* tint_symbol_5 [[buffer(0)]], uint VertexIndex [[vertex_id]]) {
|
|
VertexOutputs const inner_result = vs_main_inner(VertexIndex, tint_symbol_5);
|
|
tint_symbol wrapper_result = {};
|
|
wrapper_result.texcoords = inner_result.texcoords;
|
|
wrapper_result.position = inner_result.position;
|
|
return wrapper_result;
|
|
}
|
|
|
|
struct tint_symbol_2 {
|
|
float2 texcoord [[user(locn0)]];
|
|
};
|
|
|
|
struct tint_symbol_3 {
|
|
float4 value [[color(0)]];
|
|
};
|
|
|
|
float4 fs_main_inner(float2 texcoord, thread bool* const tint_symbol_6) {
|
|
float2 clampedTexcoord = clamp(texcoord, float2(0.0f), float2(1.0f));
|
|
if (!(all((clampedTexcoord == texcoord)))) {
|
|
*(tint_symbol_6) = true;
|
|
}
|
|
float4 srcColor = float4(0.0f);
|
|
return srcColor;
|
|
}
|
|
|
|
fragment tint_symbol_3 fs_main(tint_symbol_2 tint_symbol_1 [[stage_in]]) {
|
|
thread bool tint_symbol_7 = false;
|
|
float4 const inner_result_1 = fs_main_inner(tint_symbol_1.texcoord, &(tint_symbol_7));
|
|
tint_symbol_3 wrapper_result_1 = {};
|
|
wrapper_result_1.value = inner_result_1;
|
|
if (tint_symbol_7) {
|
|
discard_fragment();
|
|
}
|
|
return wrapper_result_1;
|
|
}
|
|
|