200 lines
6.6 KiB
Plaintext
200 lines
6.6 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 tint_private_vars_struct {
|
|
float2 rand_seed;
|
|
};
|
|
|
|
struct RenderParams_tint_packed_vec3 {
|
|
/* 0x0000 */ float4x4 modelViewProjectionMatrix;
|
|
/* 0x0040 */ packed_float3 right;
|
|
/* 0x004c */ tint_array<int8_t, 4> tint_pad;
|
|
/* 0x0050 */ packed_float3 up;
|
|
/* 0x005c */ tint_array<int8_t, 4> tint_pad_1;
|
|
};
|
|
|
|
struct Particle_tint_packed_vec3 {
|
|
/* 0x0000 */ packed_float3 position;
|
|
/* 0x000c */ float lifetime;
|
|
/* 0x0010 */ float4 color;
|
|
/* 0x0020 */ float2 velocity;
|
|
/* 0x0028 */ tint_array<int8_t, 8> tint_pad_2;
|
|
};
|
|
|
|
struct Particles_tint_packed_vec3 {
|
|
/* 0x0000 */ tint_array<Particle_tint_packed_vec3, 1> particles;
|
|
};
|
|
|
|
struct Particle {
|
|
float3 position;
|
|
float lifetime;
|
|
float4 color;
|
|
float2 velocity;
|
|
};
|
|
|
|
Particle tint_unpack_vec3_in_composite(Particle_tint_packed_vec3 in) {
|
|
Particle result = {};
|
|
result.position = float3(in.position);
|
|
result.lifetime = in.lifetime;
|
|
result.color = in.color;
|
|
result.velocity = in.velocity;
|
|
return result;
|
|
}
|
|
|
|
void asinh_468a48() {
|
|
half arg_0 = 0.0h;
|
|
half res = asinh(arg_0);
|
|
}
|
|
|
|
struct tint_symbol_1 {
|
|
float4 value [[position]];
|
|
};
|
|
|
|
float4 vertex_main_inner() {
|
|
asinh_468a48();
|
|
return float4(0.0f);
|
|
}
|
|
|
|
vertex tint_symbol_1 vertex_main() {
|
|
float4 const inner_result = vertex_main_inner();
|
|
tint_symbol_1 wrapper_result = {};
|
|
wrapper_result.value = inner_result;
|
|
return wrapper_result;
|
|
}
|
|
|
|
fragment void fragment_main() {
|
|
asinh_468a48();
|
|
return;
|
|
}
|
|
|
|
kernel void rgba32uintin() {
|
|
asinh_468a48();
|
|
return;
|
|
}
|
|
|
|
struct TestData {
|
|
tint_array<atomic_int, 4> dmat2atxa2;
|
|
};
|
|
|
|
struct RenderParams {
|
|
float4x4 modelViewProjectionMatrix;
|
|
float3 right;
|
|
float3 up;
|
|
};
|
|
|
|
struct VertexInput {
|
|
float3 position;
|
|
float4 color;
|
|
float2 quad_pos;
|
|
};
|
|
|
|
struct VertexOutput {
|
|
float4 position;
|
|
float4 color;
|
|
float2 quad_pos;
|
|
};
|
|
|
|
struct tint_symbol_3 {
|
|
float3 position [[attribute(0)]];
|
|
float4 color [[attribute(1)]];
|
|
float2 quad_pos [[attribute(2)]];
|
|
};
|
|
|
|
struct tint_symbol_4 {
|
|
float4 color [[user(locn0)]];
|
|
float2 quad_pos [[user(locn1)]];
|
|
float4 position [[position]];
|
|
};
|
|
|
|
VertexOutput vs_main_inner(VertexInput in, const constant RenderParams_tint_packed_vec3* const tint_symbol_6) {
|
|
float3 quad_pos = (float2x3(float3((*(tint_symbol_6)).right), float3((*(tint_symbol_6)).up)) * in.quad_pos);
|
|
float3 position = (in.position - (quad_pos + 0.00999999977648258209f));
|
|
VertexOutput out = {};
|
|
out.position = ((*(tint_symbol_6)).modelViewProjectionMatrix * float4(position, 1.0f));
|
|
out.color = in.color;
|
|
out.quad_pos = in.quad_pos;
|
|
return out;
|
|
}
|
|
|
|
vertex tint_symbol_4 vs_main(const constant RenderParams_tint_packed_vec3* tint_symbol_7 [[buffer(0)]], tint_symbol_3 tint_symbol_2 [[stage_in]]) {
|
|
VertexInput const tint_symbol_5 = {.position=tint_symbol_2.position, .color=tint_symbol_2.color, .quad_pos=tint_symbol_2.quad_pos};
|
|
VertexOutput const inner_result_1 = vs_main_inner(tint_symbol_5, tint_symbol_7);
|
|
tint_symbol_4 wrapper_result_1 = {};
|
|
wrapper_result_1.position = inner_result_1.position;
|
|
wrapper_result_1.color = inner_result_1.color;
|
|
wrapper_result_1.quad_pos = inner_result_1.quad_pos;
|
|
return wrapper_result_1;
|
|
}
|
|
|
|
struct SimulationParams {
|
|
/* 0x0000 */ float deltaTime;
|
|
/* 0x0004 */ tint_array<int8_t, 12> tint_pad_3;
|
|
/* 0x0010 */ float4 seed;
|
|
};
|
|
|
|
struct Particles {
|
|
tint_array<Particle, 1> particles;
|
|
};
|
|
|
|
void assign_and_preserve_padding(device Particle_tint_packed_vec3* const dest, Particle value) {
|
|
(*(dest)).position = packed_float3(value.position);
|
|
(*(dest)).lifetime = value.lifetime;
|
|
(*(dest)).color = value.color;
|
|
(*(dest)).velocity = value.velocity;
|
|
}
|
|
|
|
void simulate_inner(uint3 GlobalInvocationID, thread tint_private_vars_struct* const tint_private_vars, const constant SimulationParams* const tint_symbol_8, device Particles_tint_packed_vec3* const tint_symbol_9) {
|
|
(*(tint_private_vars)).rand_seed = (((*(tint_symbol_8)).seed.xy * float2(GlobalInvocationID.xy)) * (*(tint_symbol_8)).seed.zw);
|
|
uint const idx = GlobalInvocationID[0];
|
|
Particle particle = tint_unpack_vec3_in_composite((*(tint_symbol_9)).particles[idx]);
|
|
assign_and_preserve_padding(&((*(tint_symbol_9)).particles[idx]), particle);
|
|
}
|
|
|
|
kernel void simulate(const constant SimulationParams* tint_symbol_10 [[buffer(1)]], device Particles_tint_packed_vec3* tint_symbol_11 [[buffer(2)]], uint3 GlobalInvocationID [[thread_position_in_grid]]) {
|
|
thread tint_private_vars_struct tint_private_vars = {};
|
|
simulate_inner(GlobalInvocationID, &(tint_private_vars), tint_symbol_10, tint_symbol_11);
|
|
return;
|
|
}
|
|
|
|
struct UBO {
|
|
/* 0x0000 */ uint width;
|
|
};
|
|
|
|
struct Buffer {
|
|
/* 0x0000 */ tint_array<float, 1> weights;
|
|
};
|
|
|
|
void export_level_inner(uint3 coord, texture2d<float, access::write> tint_symbol_12, const constant UBO* const tint_symbol_13, const device Buffer* const tint_symbol_14, device Buffer* const tint_symbol_15) {
|
|
if (all((coord.xy < uint2(uint2(tint_symbol_12.get_width(), tint_symbol_12.get_height()))))) {
|
|
uint const dst_offset = (coord[0] << ((coord[1] * (*(tint_symbol_13)).width) & 31u));
|
|
uint const src_offset = ((coord[0] - 2u) + ((coord[1] >> 2u) * (*(tint_symbol_13)).width));
|
|
float const a = (*(tint_symbol_14)).weights[(src_offset << 0u)];
|
|
float const b = (*(tint_symbol_14)).weights[(src_offset + 1u)];
|
|
float const c = (*(tint_symbol_14)).weights[((src_offset + 1u) + (*(tint_symbol_13)).width)];
|
|
float const d = (*(tint_symbol_14)).weights[((src_offset + 1u) + (*(tint_symbol_13)).width)];
|
|
float const sum = dot(float4(a, b, c, d), float4(1.0f));
|
|
(*(tint_symbol_15)).weights[dst_offset] = fmod(sum, 4.0f);
|
|
float4 const probabilities = (float4(a, (a * b), ((a / b) + c), sum) + fmax(sum, 0.0f));
|
|
tint_symbol_12.write(probabilities, uint2(int2(coord.xy)));
|
|
}
|
|
}
|
|
|
|
kernel void export_level(texture2d<float, access::write> tint_symbol_16 [[texture(0)]], const constant UBO* tint_symbol_17 [[buffer(3)]], const device Buffer* tint_symbol_18 [[buffer(4)]], device Buffer* tint_symbol_19 [[buffer(0)]], uint3 coord [[thread_position_in_grid]]) {
|
|
export_level_inner(coord, tint_symbol_16, tint_symbol_17, tint_symbol_18, tint_symbol_19);
|
|
return;
|
|
}
|
|
|