Exemplos de kernel_memory_read em C++ (Cpp)

Exemplo n.º 1

Arquivo: particles.c Projeto: Bevilacqua/Corange

void particles_render() {
  
#ifdef OPEN_GL_CPU
  
  #ifndef CPU_ONLY
    kernel_memory_read(k_particle_positions, sizeof(vector4) * particle_count, particle_positions);
  #endif
  glBindBuffer(GL_ARRAY_BUFFER, positions_buffer);
  glBufferData(GL_ARRAY_BUFFER, sizeof(vector4) * particle_count, particle_positions, GL_DYNAMIC_COPY);
  
  #ifndef CPU_ONLY
    kernel_memory_read(k_particle_randoms, sizeof(vector4) * particle_count, particle_randoms);
  #endif
  glBindBuffer(GL_ARRAY_BUFFER, randoms_buffer);
  glBufferData(GL_ARRAY_BUFFER, sizeof(vector4) * particle_count, particle_randoms, GL_DYNAMIC_COPY);

#endif
  
  camera* cam = entity_get("camera");
  
  matrix_4x4 viewm = camera_view_matrix(cam);
  matrix_4x4 projm = camera_proj_matrix(cam, graphics_viewport_ratio() );
  
  m44_to_array(viewm, view_matrix);
  m44_to_array(projm, proj_matrix);

  glMatrixMode(GL_MODELVIEW);
  glLoadMatrixf(view_matrix);
  
  glMatrixMode(GL_PROJECTION);
  glLoadMatrixf(proj_matrix);
  
  glBindBuffer(GL_ARRAY_BUFFER, positions_buffer);
  glVertexPointer(4, GL_FLOAT, 0, (void*)0);
  glEnableClientState(GL_VERTEX_ARRAY);
  
  glBindBuffer(GL_ARRAY_BUFFER, randoms_buffer);
  glColorPointer(4, GL_FLOAT, 0, (void*)0);
  glEnableClientState(GL_COLOR_ARRAY);
  
    glDrawArrays(GL_POINTS, 0, particle_count);
  
  glDisableClientState(GL_VERTEX_ARRAY);
  glDisableClientState(GL_COLOR_ARRAY);
  
}

Exemplo n.º 2

Arquivo: marching_cubes.c Projeto: AntonioCS/Corange

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();
  
}