test/tint/benchmark/particles.wgsl.expected.ir.msl - dawn - Git at Google

 SKIP: FAILED

 #include <metal_stdlib>
 using namespace metal;

 struct RenderParams {
   float4x4 modelViewProjectionMatrix;
   float3 right;
   float3 up;
 };

 struct SimulationParams {
   float deltaTime;
   float4 seed;
 };

 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 Particle {
   float3 position;
   float lifetime;
   float4 color;
   float3 velocity;
 };

 struct Particles {
   tint_array<Particle, 1> particles;
 };

 struct UBO {
   uint width;
 };

 struct Buffer {
   tint_array<float, 1> weights;
 };

 struct tint_module_vars_struct {
   thread float2* rand_seed;
   const constant RenderParams* render_params;
   const constant SimulationParams* sim_params;
   device Particles* data;
   texture2d<float, access::sample> tint_symbol;
   const constant UBO* ubo;
   const device Buffer* buf_in;
   device Buffer* buf_out;
   texture2d<float, access::sample> tex_in;
   texture2d<float, access::write> tex_out;
 };

 struct VertexOutput {
   float4 position;
   float4 color;
   float2 quad_pos;
 };

 struct VertexInput {
   float3 position;
   float4 color;
   float2 quad_pos;
 };

 struct vs_main_outputs {
   float4 VertexOutput_position [[position]];
   float4 VertexOutput_color [[user(locn0)]];
   float2 VertexOutput_quad_pos [[user(locn1)]];
 };

 struct vs_main_inputs {
   float3 VertexInput_position [[attribute(0)]];
   float4 VertexInput_color [[attribute(1)]];
   float2 VertexInput_quad_pos [[attribute(2)]];
 };

 struct fs_main_outputs {
   float4 tint_symbol_1 [[color(0)]];
 };

 struct fs_main_inputs {
   float4 VertexOutput_color [[user(locn0)]];
   float2 VertexOutput_quad_pos [[user(locn1)]];
 };

 float rand(tint_module_vars_struct tint_module_vars) {
   (*tint_module_vars.rand_seed)[0u] = fract((cos(dot((*tint_module_vars.rand_seed), float2(23.1407794952392578125f, 232.6168975830078125f))) * 136.816802978515625f));
   (*tint_module_vars.rand_seed)[1u] = fract((cos(dot((*tint_module_vars.rand_seed), float2(54.478565216064453125f, 345.841522216796875f))) * 534.7645263671875f));
   return (*tint_module_vars.rand_seed)[1u];
 }

 VertexOutput vs_main_inner(VertexInput in, tint_module_vars_struct tint_module_vars) {
   float3 quad_pos = (float2x3((*tint_module_vars.render_params).right, (*tint_module_vars.render_params).up) * in.quad_pos);
   float3 position = (in.position + (quad_pos * 0.00999999977648258209f));
   VertexOutput out = {};
   float4x4 const v = (*tint_module_vars.render_params).modelViewProjectionMatrix;
   out.position = (v * float4(position, 1.0f));
   out.color = in.color;
   out.quad_pos = in.quad_pos;
   return out;
 }

 float4 fs_main_inner(VertexOutput in) {
   float4 color = in.color;
   float const v_1 = color[3u];
   color[3u] = (v_1 * max((1.0f - length(in.quad_pos)), 0.0f));
   return color;
 }

 void tint_store_and_preserve_padding(device Particle* const target, Particle value_param) {
   (*target).position = value_param.position;
   (*target).lifetime = value_param.lifetime;
   (*target).color = value_param.color;
   (*target).velocity = value_param.velocity;
 }

 void simulate_inner(uint3 GlobalInvocationID, tint_module_vars_struct tint_module_vars) {
   float2 const v_2 = (*tint_module_vars.sim_params).seed.xy;
   float2 const v_3 = (v_2 + float2(GlobalInvocationID.xy));
   (*tint_module_vars.rand_seed) = (v_3 * (*tint_module_vars.sim_params).seed.zw);
   uint const idx = GlobalInvocationID[0u];
   Particle particle = (*tint_module_vars.data).particles[idx];
   particle.velocity[2u] = (particle.velocity[2u] - ((*tint_module_vars.sim_params).deltaTime * 0.5f));
   particle.position = (particle.position + ((*tint_module_vars.sim_params).deltaTime * particle.velocity));
   particle.lifetime = (particle.lifetime - (*tint_module_vars.sim_params).deltaTime);
   particle.color[3u] = smoothstep(0.0f, 0.5f, particle.lifetime);
   if ((particle.lifetime < 0.0f)) {
     uint2 coord = uint2(0u);
     {
       uint level = (tint_module_vars.tint_symbol.get_num_mip_levels() - 1u);
       while(true) {
         if ((level > 0u)) {
         } else {
           break;
         }
         float4 const probabilites = tint_module_vars.tint_symbol.read(coord, level);
         float4 const value = float4(rand(tint_module_vars));
         bool4 const mask = ((value >= float4(0.0f, probabilites.xyz)) & (value < probabilites));
         coord = (coord * 2u);
         uint const v_4 = select(0u, 1u, any(mask.yw));
         coord[0u] = (coord[0u] + v_4);
         uint const v_5 = select(0u, 1u, any(mask.zw));
         coord[1u] = (coord[1u] + v_5);
         {
           level = (level - 1u);
         }
         continue;
       }
     }
     float2 const v_6 = float2(coord);
     uint const v_7 = tint_module_vars.tint_symbol.get_width(0u);
     float2 const uv = (v_6 / float2(uint2(v_7, tint_module_vars.tint_symbol.get_height(0u))));
     particle.position = float3((((uv - 0.5f) * 3.0f) * float2(1.0f, -1.0f)), 0.0f);
     particle.color = tint_module_vars.tint_symbol.read(coord, 0);
     particle.velocity[0u] = ((rand(tint_module_vars) - 0.5f) * 0.10000000149011611938f);
     particle.velocity[1u] = ((rand(tint_module_vars) - 0.5f) * 0.10000000149011611938f);
     particle.velocity[2u] = (rand(tint_module_vars) * 0.30000001192092895508f);
     particle.lifetime = (0.5f + (rand(tint_module_vars) * 2.0f));
   }
   tint_store_and_preserve_padding((&(*tint_module_vars.data).particles[idx]), particle);
 }

 void import_level_inner(uint3 coord, tint_module_vars_struct tint_module_vars) {
   uint const offset = (coord[0u] + (coord[1u] * (*tint_module_vars.ubo).width));
   (*tint_module_vars.buf_out).weights[offset] = tint_module_vars.tex_in.read(uint2(int2(coord.xy)), 0)[3u];
 }

 void export_level_inner(uint3 coord, tint_module_vars_struct tint_module_vars) {
   uint const v_8 = tint_module_vars.tex_out.get_width(0u);
   if (all((coord.xy < uint2(uint2(v_8, tint_module_vars.tex_out.get_height(0u)))))) {
     uint const dst_offset = (coord[0u] + (coord[1u] * (*tint_module_vars.ubo).width));
     uint const src_offset = ((coord[0u] * 2u) + ((coord[1u] * 2u) * (*tint_module_vars.ubo).width));
     float const a = (*tint_module_vars.buf_in).weights[(src_offset + 0u)];
     float const b = (*tint_module_vars.buf_in).weights[(src_offset + 1u)];
     float const c = (*tint_module_vars.buf_in).weights[((src_offset + 0u) + (*tint_module_vars.ubo).width)];
     float const d = (*tint_module_vars.buf_in).weights[((src_offset + 1u) + (*tint_module_vars.ubo).width)];
     float const sum = dot(float4(a, b, c, d), float4(1.0f));
     (*tint_module_vars.buf_out).weights[dst_offset] = (sum / 4.0f);
     float4 const v_9 = float4(a, (a + b), ((a + b) + c), sum);
     float4 const probabilities = (v_9 / max(sum, 0.00009999999747378752f));
     tint_module_vars.tex_out.write(probabilities, uint2(int2(coord.xy)));
   }
 }

 vertex vs_main_outputs vs_main(vs_main_inputs inputs [[stage_in]], const constant RenderParams* render_params [[buffer(0)]]) {
   tint_module_vars_struct const tint_module_vars = tint_module_vars_struct{.render_params=render_params};
   VertexOutput const v_10 = vs_main_inner(VertexInput{.position=inputs.VertexInput_position, .color=inputs.VertexInput_color, .quad_pos=inputs.VertexInput_quad_pos}, tint_module_vars);
   return vs_main_outputs{.VertexOutput_position=v_10.position, .VertexOutput_color=v_10.color, .VertexOutput_quad_pos=v_10.quad_pos};
 }

 fragment fs_main_outputs fs_main(float4 VertexOutput_position [[position]], fs_main_inputs inputs [[stage_in]]) {
   return fs_main_outputs{.tint_symbol_1=fs_main_inner(VertexOutput{.position=VertexOutput_position, .color=inputs.VertexOutput_color, .quad_pos=inputs.VertexOutput_quad_pos})};
 }

 kernel void simulate(uint3 GlobalInvocationID [[thread_position_in_grid]], const constant SimulationParams* sim_params [[buffer(0)]], device Particles* data [[buffer(1)]], texture2d<float, access::sample> tint_symbol [[texture(0)]]) {
   thread float2 rand_seed = 0.0f;
   tint_module_vars_struct const tint_module_vars = tint_module_vars_struct{.rand_seed=(&rand_seed), .sim_params=sim_params, .data=data, .tint_symbol=tint_symbol};
   simulate_inner(GlobalInvocationID, tint_module_vars);
 }

 kernel void import_level(uint3 coord [[thread_position_in_grid]], const constant UBO* ubo [[buffer(2)]], device Buffer* buf_out [[buffer(3)]], texture2d<float, access::sample> tex_in [[texture(1)]]) {
   tint_module_vars_struct const tint_module_vars = tint_module_vars_struct{.ubo=ubo, .buf_out=buf_out, .tex_in=tex_in};
   import_level_inner(coord, tint_module_vars);
 }

 kernel void export_level(uint3 coord [[thread_position_in_grid]], const constant UBO* ubo [[buffer(2)]], const device Buffer* buf_in [[buffer(4)]], device Buffer* buf_out [[buffer(3)]], texture2d<float, access::write> tex_out [[texture(2)]]) {
   tint_module_vars_struct const tint_module_vars = tint_module_vars_struct{.ubo=ubo, .buf_in=buf_in, .buf_out=buf_out, .tex_out=tex_out};
   export_level_inner(coord, tint_module_vars);
 }
 program_source:192:104: error: call to deleted constructor of 'texture2d<float, access::sample>'
   tint_module_vars_struct const tint_module_vars = tint_module_vars_struct{.render_params=render_params};
                                                                                                        ^
 /System/Library/PrivateFrameworks/GPUCompiler.framework/Versions/32023/Libraries/lib/clang/32023.194/include/metal/metal_texture:6083:3: note: 'texture2d' has been explicitly marked deleted here
   texture2d() thread = delete;
   ^
 program_source:51:36: note: in implicit initialization of field 'tint_symbol' with omitted initializer
   texture2d<float, access::sample> tint_symbol;
                                    ^
 program_source:203:161: error: call to deleted constructor of 'texture2d<float, access::sample>'
   tint_module_vars_struct const tint_module_vars = tint_module_vars_struct{.rand_seed=(&rand_seed), .sim_params=sim_params, .data=data, .tint_symbol=tint_symbol};
                                                                                                                                                                 ^
 /System/Library/PrivateFrameworks/GPUCompiler.framework/Versions/32023/Libraries/lib/clang/32023.194/include/metal/metal_texture:6083:3: note: 'texture2d' has been explicitly marked deleted here
   texture2d() thread = delete;
   ^
 program_source:55:36: note: in implicit initialization of field 'tex_in' with omitted initializer
   texture2d<float, access::sample> tex_in;
                                    ^
 program_source:208:118: error: call to deleted constructor of 'texture2d<float, access::sample>'
   tint_module_vars_struct const tint_module_vars = tint_module_vars_struct{.ubo=ubo, .buf_out=buf_out, .tex_in=tex_in};
                                                                                                                      ^
 /System/Library/PrivateFrameworks/GPUCompiler.framework/Versions/32023/Libraries/lib/clang/32023.194/include/metal/metal_texture:6083:3: note: 'texture2d' has been explicitly marked deleted here
   texture2d() thread = delete;
   ^
 program_source:51:36: note: in implicit initialization of field 'tint_symbol' with omitted initializer
   texture2d<float, access::sample> tint_symbol;
                                    ^
 program_source:213:136: error: call to deleted constructor of 'texture2d<float, access::sample>'
   tint_module_vars_struct const tint_module_vars = tint_module_vars_struct{.ubo=ubo, .buf_in=buf_in, .buf_out=buf_out, .tex_out=tex_out};
                                                                                                                                        ^
 /System/Library/PrivateFrameworks/GPUCompiler.framework/Versions/32023/Libraries/lib/clang/32023.194/include/metal/metal_texture:6083:3: note: 'texture2d' has been explicitly marked deleted here
   texture2d() thread = delete;
   ^
 program_source:51:36: note: in implicit initialization of field 'tint_symbol' with omitted initializer
   texture2d<float, access::sample> tint_symbol;
                                    ^
	SKIP: FAILED

	#include <metal_stdlib>
	using namespace metal;

	struct RenderParams {
	float4x4 modelViewProjectionMatrix;
	float3 right;
	float3 up;
	};

	struct SimulationParams {
	float deltaTime;
	float4 seed;
	};

	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 Particle {
	float3 position;
	float lifetime;
	float4 color;
	float3 velocity;
	};

	struct Particles {
	tint_array<Particle, 1> particles;
	};

	struct UBO {
	uint width;
	};

	struct Buffer {
	tint_array<float, 1> weights;
	};

	struct tint_module_vars_struct {
	thread float2* rand_seed;
	const constant RenderParams* render_params;
	const constant SimulationParams* sim_params;
	device Particles* data;
	texture2d<float, access::sample> tint_symbol;
	const constant UBO* ubo;
	const device Buffer* buf_in;
	device Buffer* buf_out;
	texture2d<float, access::sample> tex_in;
	texture2d<float, access::write> tex_out;
	};

	struct VertexOutput {
	float4 position;
	float4 color;
	float2 quad_pos;
	};

	struct VertexInput {
	float3 position;
	float4 color;
	float2 quad_pos;
	};

	struct vs_main_outputs {
	float4 VertexOutput_position [[position]];
	float4 VertexOutput_color [[user(locn0)]];
	float2 VertexOutput_quad_pos [[user(locn1)]];
	};

	struct vs_main_inputs {
	float3 VertexInput_position [[attribute(0)]];
	float4 VertexInput_color [[attribute(1)]];
	float2 VertexInput_quad_pos [[attribute(2)]];
	};

	struct fs_main_outputs {
	float4 tint_symbol_1 [[color(0)]];
	};

	struct fs_main_inputs {
	float4 VertexOutput_color [[user(locn0)]];
	float2 VertexOutput_quad_pos [[user(locn1)]];
	};

	float rand(tint_module_vars_struct tint_module_vars) {
	(tint_module_vars.rand_seed)[0u] = fract((cos(dot((tint_module_vars.rand_seed), float2(23.1407794952392578125f, 232.6168975830078125f))) * 136.816802978515625f));
	(tint_module_vars.rand_seed)[1u] = fract((cos(dot((tint_module_vars.rand_seed), float2(54.478565216064453125f, 345.841522216796875f))) * 534.7645263671875f));
	return (*tint_module_vars.rand_seed)[1u];
	}

	VertexOutput vs_main_inner(VertexInput in, tint_module_vars_struct tint_module_vars) {
	float3 quad_pos = (float2x3((tint_module_vars.render_params).right, (tint_module_vars.render_params).up) * in.quad_pos);
	float3 position = (in.position + (quad_pos * 0.00999999977648258209f));
	VertexOutput out = {};
	float4x4 const v = (*tint_module_vars.render_params).modelViewProjectionMatrix;
	out.position = (v * float4(position, 1.0f));
	out.color = in.color;
	out.quad_pos = in.quad_pos;
	return out;
	}

	float4 fs_main_inner(VertexOutput in) {
	float4 color = in.color;
	float const v_1 = color[3u];
	color[3u] = (v_1 * max((1.0f - length(in.quad_pos)), 0.0f));
	return color;
	}

	void tint_store_and_preserve_padding(device Particle* const target, Particle value_param) {
	(*target).position = value_param.position;
	(*target).lifetime = value_param.lifetime;
	(*target).color = value_param.color;
	(*target).velocity = value_param.velocity;
	}

	void simulate_inner(uint3 GlobalInvocationID, tint_module_vars_struct tint_module_vars) {
	float2 const v_2 = (*tint_module_vars.sim_params).seed.xy;
	float2 const v_3 = (v_2 + float2(GlobalInvocationID.xy));
	(tint_module_vars.rand_seed) = (v_3 (*tint_module_vars.sim_params).seed.zw);
	uint const idx = GlobalInvocationID[0u];
	Particle particle = (*tint_module_vars.data).particles[idx];
	particle.velocity[2u] = (particle.velocity[2u] - ((tint_module_vars.sim_params).deltaTime 0.5f));
	particle.position = (particle.position + ((tint_module_vars.sim_params).deltaTime particle.velocity));
	particle.lifetime = (particle.lifetime - (*tint_module_vars.sim_params).deltaTime);
	particle.color[3u] = smoothstep(0.0f, 0.5f, particle.lifetime);
	if ((particle.lifetime < 0.0f)) {
	uint2 coord = uint2(0u);
	{
	uint level = (tint_module_vars.tint_symbol.get_num_mip_levels() - 1u);
	while(true) {
	if ((level > 0u)) {
	} else {
	break;
	}
	float4 const probabilites = tint_module_vars.tint_symbol.read(coord, level);
	float4 const value = float4(rand(tint_module_vars));
	bool4 const mask = ((value >= float4(0.0f, probabilites.xyz)) & (value < probabilites));
	coord = (coord * 2u);
	uint const v_4 = select(0u, 1u, any(mask.yw));
	coord[0u] = (coord[0u] + v_4);
	uint const v_5 = select(0u, 1u, any(mask.zw));
	coord[1u] = (coord[1u] + v_5);
	{
	level = (level - 1u);
	}
	continue;
	}
	}
	float2 const v_6 = float2(coord);
	uint const v_7 = tint_module_vars.tint_symbol.get_width(0u);
	float2 const uv = (v_6 / float2(uint2(v_7, tint_module_vars.tint_symbol.get_height(0u))));
	particle.position = float3((((uv - 0.5f) * 3.0f) * float2(1.0f, -1.0f)), 0.0f);
	particle.color = tint_module_vars.tint_symbol.read(coord, 0);
	particle.velocity[0u] = ((rand(tint_module_vars) - 0.5f) * 0.10000000149011611938f);
	particle.velocity[1u] = ((rand(tint_module_vars) - 0.5f) * 0.10000000149011611938f);
	particle.velocity[2u] = (rand(tint_module_vars) * 0.30000001192092895508f);
	particle.lifetime = (0.5f + (rand(tint_module_vars) * 2.0f));
	}
	tint_store_and_preserve_padding((&(*tint_module_vars.data).particles[idx]), particle);
	}

	void import_level_inner(uint3 coord, tint_module_vars_struct tint_module_vars) {
	uint const offset = (coord[0u] + (coord[1u] * (*tint_module_vars.ubo).width));
	(*tint_module_vars.buf_out).weights[offset] = tint_module_vars.tex_in.read(uint2(int2(coord.xy)), 0)[3u];
	}

	void export_level_inner(uint3 coord, tint_module_vars_struct tint_module_vars) {
	uint const v_8 = tint_module_vars.tex_out.get_width(0u);
	if (all((coord.xy < uint2(uint2(v_8, tint_module_vars.tex_out.get_height(0u)))))) {
	uint const dst_offset = (coord[0u] + (coord[1u] * (*tint_module_vars.ubo).width));
	uint const src_offset = ((coord[0u] * 2u) + ((coord[1u] * 2u) * (*tint_module_vars.ubo).width));
	float const a = (*tint_module_vars.buf_in).weights[(src_offset + 0u)];
	float const b = (*tint_module_vars.buf_in).weights[(src_offset + 1u)];
	float const c = (tint_module_vars.buf_in).weights[((src_offset + 0u) + (tint_module_vars.ubo).width)];
	float const d = (tint_module_vars.buf_in).weights[((src_offset + 1u) + (tint_module_vars.ubo).width)];
	float const sum = dot(float4(a, b, c, d), float4(1.0f));
	(*tint_module_vars.buf_out).weights[dst_offset] = (sum / 4.0f);
	float4 const v_9 = float4(a, (a + b), ((a + b) + c), sum);
	float4 const probabilities = (v_9 / max(sum, 0.00009999999747378752f));
	tint_module_vars.tex_out.write(probabilities, uint2(int2(coord.xy)));
	}
	}

	vertex vs_main_outputs vs_main(vs_main_inputs inputs [[stage_in]], const constant RenderParams* render_params [[buffer(0)]]) {
	tint_module_vars_struct const tint_module_vars = tint_module_vars_struct{.render_params=render_params};
	VertexOutput const v_10 = vs_main_inner(VertexInput{.position=inputs.VertexInput_position, .color=inputs.VertexInput_color, .quad_pos=inputs.VertexInput_quad_pos}, tint_module_vars);
	return vs_main_outputs{.VertexOutput_position=v_10.position, .VertexOutput_color=v_10.color, .VertexOutput_quad_pos=v_10.quad_pos};
	}

	fragment fs_main_outputs fs_main(float4 VertexOutput_position [[position]], fs_main_inputs inputs [[stage_in]]) {
	return fs_main_outputs{.tint_symbol_1=fs_main_inner(VertexOutput{.position=VertexOutput_position, .color=inputs.VertexOutput_color, .quad_pos=inputs.VertexOutput_quad_pos})};
	}

	kernel void simulate(uint3 GlobalInvocationID [[thread_position_in_grid]], const constant SimulationParams* sim_params [[buffer(0)]], device Particles* data [[buffer(1)]], texture2d<float, access::sample> tint_symbol [[texture(0)]]) {
	thread float2 rand_seed = 0.0f;
	tint_module_vars_struct const tint_module_vars = tint_module_vars_struct{.rand_seed=(&rand_seed), .sim_params=sim_params, .data=data, .tint_symbol=tint_symbol};
	simulate_inner(GlobalInvocationID, tint_module_vars);
	}

	kernel void import_level(uint3 coord [[thread_position_in_grid]], const constant UBO* ubo [[buffer(2)]], device Buffer* buf_out [[buffer(3)]], texture2d<float, access::sample> tex_in [[texture(1)]]) {
	tint_module_vars_struct const tint_module_vars = tint_module_vars_struct{.ubo=ubo, .buf_out=buf_out, .tex_in=tex_in};
	import_level_inner(coord, tint_module_vars);
	}

	kernel void export_level(uint3 coord [[thread_position_in_grid]], const constant UBO* ubo [[buffer(2)]], const device Buffer* buf_in [[buffer(4)]], device Buffer* buf_out [[buffer(3)]], texture2d<float, access::write> tex_out [[texture(2)]]) {
	tint_module_vars_struct const tint_module_vars = tint_module_vars_struct{.ubo=ubo, .buf_in=buf_in, .buf_out=buf_out, .tex_out=tex_out};
	export_level_inner(coord, tint_module_vars);
	}
	program_source:192:104: error: call to deleted constructor of 'texture2d<float, access::sample>'
	tint_module_vars_struct const tint_module_vars = tint_module_vars_struct{.render_params=render_params};
	^
	/System/Library/PrivateFrameworks/GPUCompiler.framework/Versions/32023/Libraries/lib/clang/32023.194/include/metal/metal_texture:6083:3: note: 'texture2d' has been explicitly marked deleted here
	texture2d() thread = delete;
	^
	program_source:51:36: note: in implicit initialization of field 'tint_symbol' with omitted initializer
	texture2d<float, access::sample> tint_symbol;
	^
	program_source:203:161: error: call to deleted constructor of 'texture2d<float, access::sample>'
	tint_module_vars_struct const tint_module_vars = tint_module_vars_struct{.rand_seed=(&rand_seed), .sim_params=sim_params, .data=data, .tint_symbol=tint_symbol};
	^
	/System/Library/PrivateFrameworks/GPUCompiler.framework/Versions/32023/Libraries/lib/clang/32023.194/include/metal/metal_texture:6083:3: note: 'texture2d' has been explicitly marked deleted here
	texture2d() thread = delete;
	^
	program_source:55:36: note: in implicit initialization of field 'tex_in' with omitted initializer
	texture2d<float, access::sample> tex_in;
	^
	program_source:208:118: error: call to deleted constructor of 'texture2d<float, access::sample>'
	tint_module_vars_struct const tint_module_vars = tint_module_vars_struct{.ubo=ubo, .buf_out=buf_out, .tex_in=tex_in};
	^
	/System/Library/PrivateFrameworks/GPUCompiler.framework/Versions/32023/Libraries/lib/clang/32023.194/include/metal/metal_texture:6083:3: note: 'texture2d' has been explicitly marked deleted here
	texture2d() thread = delete;
	^
	program_source:51:36: note: in implicit initialization of field 'tint_symbol' with omitted initializer
	texture2d<float, access::sample> tint_symbol;
	^
	program_source:213:136: error: call to deleted constructor of 'texture2d<float, access::sample>'
	tint_module_vars_struct const tint_module_vars = tint_module_vars_struct{.ubo=ubo, .buf_in=buf_in, .buf_out=buf_out, .tex_out=tex_out};
	^
	/System/Library/PrivateFrameworks/GPUCompiler.framework/Versions/32023/Libraries/lib/clang/32023.194/include/metal/metal_texture:6083:3: note: 'texture2d' has been explicitly marked deleted here
	texture2d() thread = delete;
	^
	program_source:51:36: note: in implicit initialization of field 'tint_symbol' with omitted initializer
	texture2d<float, access::sample> tint_symbol;
	^