#[compute]

#version 450

#VERSION_DEFINES

layout(local_size_x = 64, local_size_y = 1, local_size_z = 1) in;

#define PARTICLE_FLAG_ACTIVE uint(1)
#define PARTICLE_FLAG_STARTED uint(2)
#define PARTICLE_FLAG_TRAILED uint(4)

struct ParticleData {
	mat4 xform;
	vec3 velocity;
	uint flags;
	vec4 color;
	vec4 custom;
#ifdef USERDATA_COUNT
	vec4 userdata[USERDATA_COUNT];
#endif
};

layout(set = 0, binding = 1, std430) restrict readonly buffer Particles {
	ParticleData data[];
}
particles;

layout(set = 0, binding = 2, std430) restrict writeonly buffer Transforms {
	vec4 data[];
}
instances;

#ifdef USE_SORT_BUFFER

layout(set = 1, binding = 0, std430) restrict buffer SortBuffer {
	vec2 data[];
}
sort_buffer;

#endif // USE_SORT_BUFFER

layout(set = 2, binding = 0, std430) restrict readonly buffer TrailBindPoses {
	mat4 data[];
}
trail_bind_poses;

#define PARAMS_FLAG_ORDER_BY_LIFETIME 1
#define PARAMS_FLAG_COPY_MODE_2D 2

layout(push_constant, std430) uniform Params {
	vec3 sort_direction;
	uint total_particles;

	uint trail_size;
	uint trail_total;
	float frame_delta;
	float frame_remainder;

	vec3 align_up;
	uint align_mode;

	uint lifetime_split;
	bool lifetime_reverse;
	uint motion_vectors_current_offset;
	uint flags;

	float inv_emission_transform[12];

	uint align_channel_filter;
	uint align_axis;
	uint pad1;
	uint pad2;
}
params;

#define ALIGN_DISABLED 0
#define ALIGN_BILLBOARD 1
#define ALIGN_Y_TO_VELOCITY 2
#define ALIGN_Z_BILLBOARD_Y_TO_VELOCITY 3
#define ALIGN_LOCAL_BILLBOARD 4

#define CHANNEL_FILTER_NONE 0
#define CHANNEL_FILTER_X 1
#define CHANNEL_FILTER_Y 2
#define CHANNEL_FILTER_Z 3
#define CHANNEL_FILTER_W 4

#define ALIGN_AXIS_X 0
#define ALIGN_AXIS_Y 1
#define ALIGN_AXIS_Z 2

void main() {
#ifdef MODE_FILL_SORT_BUFFER

	uint particle = gl_GlobalInvocationID.x;
	if (particle >= params.total_particles) {
		return; //discard
	}

	uint src_particle = particle;
	if (params.trail_size > 1) {
		src_particle = src_particle * params.trail_size + params.trail_size / 2; //use trail center for sorting
	}
	sort_buffer.data[particle].x = dot(params.sort_direction, particles.data[src_particle].xform[3].xyz);
	sort_buffer.data[particle].y = float(particle);
#endif

#ifdef MODE_FILL_INSTANCES

	uint particle = gl_GlobalInvocationID.x;

	if (particle >= params.total_particles) {
		return; //discard
	}

#ifdef USE_SORT_BUFFER

	if (params.trail_size > 1) {
		particle = uint(sort_buffer.data[particle / params.trail_size].y) + (particle % params.trail_size);
	} else {
		particle = uint(sort_buffer.data[particle].y); //use index from sort buffer
	}
#else
	if (bool(params.flags & PARAMS_FLAG_ORDER_BY_LIFETIME)) {
		if (params.trail_size > 1) {
			uint limit = (params.total_particles / params.trail_size) - params.lifetime_split;

			uint base_index = particle / params.trail_size;
			uint base_offset = particle % params.trail_size;

			if (params.lifetime_reverse) {
				base_index = (params.total_particles / params.trail_size) - base_index - 1;
			}

			if (base_index < limit) {
				base_index = params.lifetime_split + base_index;
			} else {
				base_index -= limit;
			}

			particle = base_index * params.trail_size + base_offset;

		} else {
			uint limit = params.total_particles - params.lifetime_split;

			if (params.lifetime_reverse) {
				particle = params.total_particles - particle - 1;
			}

			if (particle < limit) {
				particle = params.lifetime_split + particle;
			} else {
				particle -= limit;
			}
		}
	}
#endif // USE_SORT_BUFFER

	mat4 txform;

	if (bool(particles.data[particle].flags & PARTICLE_FLAG_ACTIVE) || bool(particles.data[particle].flags & PARTICLE_FLAG_TRAILED)) {
		txform = particles.data[particle].xform;
		if (params.trail_size > 1) {
			// Since the steps don't fit precisely in the history frames, must do a tiny bit of
			// interpolation to get them close to their intended location.
			uint part_ofs = particle % params.trail_size;
			float natural_ofs = fract((float(part_ofs) / float(params.trail_size)) * float(params.trail_total)) * params.frame_delta;

			txform[3].xyz -= particles.data[particle].velocity * natural_ofs;
		}

		switch (params.align_mode) {
			case ALIGN_DISABLED: {
			} break; //nothing
			case ALIGN_BILLBOARD: {
				float angle = 0.;
				switch (params.align_channel_filter) {
					case CHANNEL_FILTER_X: {
						angle = particles.data[particle].custom.x;
					} break;
					case CHANNEL_FILTER_Y: {
						angle = particles.data[particle].custom.y;
					} break;
					case CHANNEL_FILTER_Z: {
						angle = particles.data[particle].custom.z;
					} break;
					case CHANNEL_FILTER_W: {
						angle = particles.data[particle].custom.w;
					} break;
				}
				vec3 axis = normalize(params.sort_direction);
				float s = sin(angle);
				float c = cos(angle);
				float oc = 1.0 - c;
				mat3 rotated = mat3(
						oc * axis.x * axis.x + c, oc * axis.x * axis.y - axis.z * s, oc * axis.z * axis.x + axis.y * s,
						oc * axis.x * axis.y + axis.z * s, oc * axis.y * axis.y + c, oc * axis.y * axis.z - axis.x * s,
						oc * axis.z * axis.x - axis.y * s, oc * axis.y * axis.z + axis.x * s, oc * axis.z * axis.z + c);
				vec3 new_up = rotated * params.align_up;
				mat3 local = mat3(normalize(cross(new_up, params.sort_direction)), new_up, params.sort_direction);
				local = local * mat3(txform);
				txform[0].xyz = local[0];
				txform[1].xyz = local[1];
				txform[2].xyz = local[2];

			} break;
			case ALIGN_Y_TO_VELOCITY: {
				vec3 v = particles.data[particle].velocity;
				v = normalize(v);
				switch (params.align_axis) {
					case ALIGN_AXIS_X: {
						vec3 len = vec3(
								length(txform[0].xyz),
								length(txform[1].xyz),
								length(txform[2].xyz));

						txform[0].xyz = v;
						txform[1].xyz = normalize(cross(txform[2].xyz / len.z, txform[0].xyz));
						txform[2].xyz = cross(txform[0].xyz, txform[1].xyz);

						txform[0].xyz *= len.x;
						txform[1].xyz *= len.y;
						txform[2].xyz *= len.z;
					} break;
					case ALIGN_AXIS_Y: {
						vec3 len = vec3(
								length(txform[0].xyz),
								length(txform[1].xyz),
								length(txform[2].xyz));

						txform[0].xyz = normalize(cross(v, txform[2].xyz / len.z));
						txform[1].xyz = v;
						txform[2].xyz = cross(txform[0].xyz, txform[1].xyz);

						txform[0].xyz *= len.x;
						txform[1].xyz *= len.y;
						txform[2].xyz *= len.z;
					} break;
					case ALIGN_AXIS_Z: {
						vec3 len = vec3(
								length(txform[0].xyz),
								length(txform[1].xyz),
								length(txform[2].xyz));

						txform[0].xyz = normalize(cross(txform[1].xyz / len.y, v));
						txform[2].xyz = v;
						txform[1].xyz = normalize(cross(txform[2].xyz, txform[0].xyz));

						txform[0].xyz *= len.x;
						txform[1].xyz *= len.y;
						txform[2].xyz *= len.z;
					} break;
				}
			} break;
			case ALIGN_Z_BILLBOARD_Y_TO_VELOCITY: {
				vec3 v = particles.data[particle].velocity;
				vec3 sv = v - params.sort_direction * dot(params.sort_direction, v); //screen velocity

				if (length(sv) == 0) {
					sv = params.align_up;
				}

				sv = normalize(sv);

				txform[0].xyz = normalize(cross(sv, params.sort_direction)) * length(txform[0]);
				txform[1].xyz = sv * length(txform[1]);
				txform[2].xyz = params.sort_direction * length(txform[2]);

			} break;
			case ALIGN_LOCAL_BILLBOARD: {
				switch (params.align_axis) {
					case ALIGN_AXIS_X: {
						vec3 len = vec3(
								length(txform[0].xyz),
								length(txform[1].xyz),
								length(txform[2].xyz));

						txform[0].xyz = normalize(txform[0].xyz);
						txform[1].xyz = normalize(cross(params.sort_direction, txform[0].xyz));
						txform[2].xyz = cross(txform[0].xyz, txform[1].xyz);

						txform[0].xyz *= len.x;
						txform[1].xyz *= len.y;
						txform[2].xyz *= len.z;
					} break;
					case ALIGN_AXIS_Y: {
						vec3 len = vec3(
								length(txform[0].xyz),
								length(txform[1].xyz),
								length(txform[2].xyz));

						txform[1].xyz = normalize(txform[1].xyz);
						txform[0].xyz = normalize(cross(txform[1].xyz, params.sort_direction));
						txform[2].xyz = cross(txform[0].xyz, txform[1].xyz);

						txform[0].xyz *= len.x;
						txform[1].xyz *= len.y;
						txform[2].xyz *= len.z;
					} break;
				}

			} break;
		}

		txform[3].xyz += particles.data[particle].velocity * params.frame_remainder;

		if (params.trail_size > 1) {
			uint part_ofs = particle % params.trail_size;
			txform = txform * trail_bind_poses.data[part_ofs];
		}

		if (bool(params.flags & PARAMS_FLAG_COPY_MODE_2D)) {
			// In global mode, bring 2D particles to local coordinates
			// as they will be drawn with the node position as origin.
			mat4 inv_emission_transform;
			inv_emission_transform[0] = vec4(params.inv_emission_transform[0], params.inv_emission_transform[1], params.inv_emission_transform[2], 0.0);
			inv_emission_transform[1] = vec4(params.inv_emission_transform[3], params.inv_emission_transform[4], params.inv_emission_transform[5], 0.0);
			inv_emission_transform[2] = vec4(params.inv_emission_transform[6], params.inv_emission_transform[7], params.inv_emission_transform[8], 0.0);
			inv_emission_transform[3] = vec4(params.inv_emission_transform[9], params.inv_emission_transform[10], params.inv_emission_transform[11], 1.0);

			txform = inv_emission_transform * txform;
		}
	} else {
		// Set scale to zero and translate to -INF so particle will be invisible
		// even for materials that ignore rotation/scale (i.e. billboards).
		txform = mat4(vec4(0.0), vec4(0.0), vec4(0.0), vec4(-1.0 / 0.0, -1.0 / 0.0, -1.0 / 0.0, 0.0));
	}
	txform = transpose(txform);

	uint instance_index = gl_GlobalInvocationID.x + params.motion_vectors_current_offset;
	if (bool(params.flags & PARAMS_FLAG_COPY_MODE_2D)) {
		uint write_offset = instance_index * (2 + 1 + 1); //xform + color + custom

		instances.data[write_offset + 0] = txform[0];
		instances.data[write_offset + 1] = txform[1];
		instances.data[write_offset + 2] = particles.data[particle].color;
		instances.data[write_offset + 3] = particles.data[particle].custom;
	} else {
		uint write_offset = instance_index * (3 + 1 + 1); //xform + color + custom

		instances.data[write_offset + 0] = txform[0];
		instances.data[write_offset + 1] = txform[1];
		instances.data[write_offset + 2] = txform[2];
		instances.data[write_offset + 3] = particles.data[particle].color;
		instances.data[write_offset + 4] = particles.data[particle].custom;
	}

#endif
}