void marching_cubes_update() {
int size[3] = {width, height, depth};
/* Update volumes */
kernel_memory_gl_aquire(metaball_positions);
kernel_memory_gl_aquire(vertex_positions_buffer);
kernel_memory_gl_aquire(vertex_normals_buffer);
kernel_set_argument(write_metaballs, 1, sizeof(cl_int3), &size);
kernel_set_argument(write_metaballs, 2, sizeof(kernel_memory), &metaball_positions);
kernel_set_argument(write_metaballs, 3, sizeof(cl_int), &num_metaballs);
kernel_run(write_metaballs, width * height * depth);
/* End */
int zero = 0;
kernel_memory_write(vertex_index, sizeof(int), &zero);
const int num_workers = (width-1) * (height-1) * (depth-1);
kernel_set_argument(construct_surface, 0, sizeof(kernel_memory), &volume);
kernel_set_argument(construct_surface, 1, sizeof(cl_int3), &size);
kernel_set_argument(construct_surface, 2, sizeof(kernel_memory), &vertex_positions_buffer);
kernel_set_argument(construct_surface, 3, sizeof(kernel_memory), &vertex_index);
kernel_run(construct_surface, num_workers);
kernel_memory_read(vertex_index, sizeof(cl_int), &num_verts);
/* Generate Normals */
if (num_verts > 0) {
kernel_set_argument(generate_normals_smooth, 0, sizeof(kernel_memory), &vertex_positions_buffer);
kernel_set_argument(generate_normals_smooth, 1, sizeof(kernel_memory), &vertex_normals_buffer);
kernel_set_argument(generate_normals_smooth, 2, sizeof(kernel_memory), &metaball_positions);
kernel_set_argument(generate_normals_smooth, 3, sizeof(cl_int), &num_metaballs);
kernel_run(generate_normals_smooth, num_verts);
}
/*
kernel_set_argument(generate_normals, 0, sizeof(kernel_memory), &vertex_positions_buffer);
kernel_set_argument(generate_normals, 1, sizeof(kernel_memory), &vertex_normals_buffer);
kernel_run(generate_normals, num_verts/3);
*/
kernel_memory_gl_release(vertex_positions_buffer);
kernel_memory_gl_release(vertex_normals_buffer);
kernel_memory_gl_release(metaball_positions);
kernel_run_finish();
}
void particles_update(float timestep) {
int random = rand();
#ifndef CPU_ONLY
#ifndef OPEN_GL_CPU
kernel_memory_gl_aquire(k_particle_positions);
kernel_memory_gl_aquire(k_particle_velocities);
kernel_memory_gl_aquire(k_particle_lifetimes);
kernel_memory_gl_aquire(k_particle_randoms);
#endif
kernel_set_argument(k_update, 6, sizeof(cl_float), ×tep);
kernel_set_argument(k_update, 7, sizeof(cl_int), &reset);
kernel_set_argument(k_update, 8, sizeof(cl_int), &random);
kernel_run(k_update, particle_count);
reset = 0;
#ifndef OPEN_GL_CPU
kernel_memory_gl_release(k_particle_positions);
kernel_memory_gl_release(k_particle_velocities);
kernel_memory_gl_release(k_particle_lifetimes);
kernel_memory_gl_release(k_particle_randoms);
#endif
kernel_run_finish();
#else
for(int i = 0; i < particle_count; i++) {
particle_lifetimes[i] = particle_lifetimes[i] + timestep;
if ((particle_lifetimes[i] > 60.0) || ( v4_length(particle_velocities[i]) < 0.5 )) {
particle_lifetimes[i] = 0.0;
particle_positions[i] = v4(32,15,32,1);
int random_index = (random + i) % particle_count;
float rx = particle_randoms[random_index].x;
float ry = particle_randoms[random_index].y;
float rz = particle_randoms[random_index].z;
particle_velocities[i] = v4_mul(v4(rx, ry, rz, 0), 5);
} else {
/* Update positions and velocity */
particle_positions[i].x = particle_positions[i].x + (particle_velocities[i].x * timestep);
particle_positions[i].y = particle_positions[i].y + (particle_velocities[i].y * timestep);
particle_positions[i].z = particle_positions[i].z + (particle_velocities[i].z * timestep);
particle_velocities[i].y = particle_velocities[i].y - (9.81 * timestep);
/* Bounce on floors */
if (particle_positions[i].y < 15.0) {
particle_velocities[i].x = particle_velocities[i].x * 0.75;
particle_velocities[i].y = particle_velocities[i].y * 0.75;
particle_velocities[i].z = particle_velocities[i].z * 0.75;
particle_velocities[i].y = -particle_velocities[i].y;
}
}
}
#endif
}
