C++ (Cpp) light_view_matrix Examples

Example #1

File: shadow_mapper.c Project: Bevilacqua/Corange

static void shadow_mapper_setup_camera() {
  
  matrix_4x4 viewm = light_view_matrix(LIGHT);
  matrix_4x4 projm = light_proj_matrix(LIGHT);
  
  m44_to_array(viewm, view_matrix);
  m44_to_array(projm, proj_matrix);
  
  glMatrixMode(GL_MODELVIEW);
  glLoadMatrixf(view_matrix);
  
  glMatrixMode(GL_PROJECTION);
  glLoadMatrixf(proj_matrix);
  
}

Example #2

File: marching_cubes.c Project: AntonioCS/Corange

void marching_cubes_render_shadows(light* l) {
  
  mat4 viewm = light_view_matrix(l);
  mat4 projm = light_proj_matrix(l);
  
  mat4_to_array(viewm, view_matrix);
  mat4_to_array(projm, proj_matrix);
  
  glMatrixMode(GL_MODELVIEW);
  glLoadMatrixf(view_matrix);
  
  glMatrixMode(GL_PROJECTION);
  glLoadMatrixf(proj_matrix);    
  
  mat4_to_array(mat4_id(), world_matrix);
  
  material* depth_mat = asset_get_load(P("$CORANGE/shaders/depth.mat"));
  
  shader_program* depth_shader = material_get_entry(depth_mat, 0)->program;
  glUseProgram(*depth_shader);
  
  GLint world_matrix_u = glGetUniformLocation(*depth_shader, "world_matrix");
  glUniformMatrix4fv(world_matrix_u, 1, 0, world_matrix);
  
  GLint proj_matrix_u = glGetUniformLocation(*depth_shader, "proj_matrix");
  glUniformMatrix4fv(proj_matrix_u, 1, 0, proj_matrix);
  
  GLint view_matrix_u = glGetUniformLocation(*depth_shader, "view_matrix");
  glUniformMatrix4fv(view_matrix_u, 1, 0, view_matrix);
  
  glBindBuffer(GL_ARRAY_BUFFER, vertex_positions);
  glVertexPointer(4, GL_FLOAT, 0, (void*)0);
  glEnableClientState(GL_VERTEX_ARRAY);
  
    glDrawArrays(GL_TRIANGLES, 0, num_verts);
  
  glDisableClientState(GL_VERTEX_ARRAY);
  
  glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
  glBindBuffer(GL_ARRAY_BUFFER, 0);
  
  glUseProgram(0);

}

Example #3

File: deferred_renderer.c Project: Bevilacqua/Corange

static void deferred_renderer_setup_camera() {

  matrix_4x4 viewm = camera_view_matrix(CAMERA);
  matrix_4x4 projm = camera_proj_matrix(CAMERA, 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);
  
  matrix_4x4 lviewm = light_view_matrix(SHADOW_LIGHT);
  matrix_4x4 lprojm = light_proj_matrix(SHADOW_LIGHT);
  
  m44_to_array(lviewm, LIGHT_VIEW_MATRIX);
  m44_to_array(lprojm, LIGHT_PROJ_MATRIX);

}

Example #4

File: marching_cubes.c Project: AntonioCS/Corange

void marching_cubes_render(bool wireframe, camera* c, light* l) {
  
  const int full_size = width * height * depth;
  
  kernel_memory_gl_aquire(point_color_buffer);
  kernel_run(write_point_color_back, full_size);
  kernel_memory_gl_release(point_color_buffer);
  
  /* Before we do the metaballs lets just do a rendering based upon volume data */
  
  /*
  
  glPointSize(1.0f);
  
  glBindBuffer(GL_ARRAY_BUFFER, point_positions);
  glVertexPointer(4, GL_FLOAT, 0, (void*)0);
  glEnableClientState(GL_VERTEX_ARRAY);
  
  glBindBuffer(GL_ARRAY_BUFFER, point_colors);
  glColorPointer(4, GL_FLOAT, 0, (void*)0);
  glEnableClientState(GL_COLOR_ARRAY);
  
  glDrawArrays(GL_POINTS, 0, full_size);
  
  glBindBuffer(GL_ARRAY_BUFFER, 0);
  glDisableClientState(GL_VERTEX_ARRAY);
  glDisableClientState(GL_COLOR_ARRAY);
  glPointSize(1.0f);
  
  */
  
  /* Then Draw Triangles */
  if (wireframe) {
    glPolygonMode( GL_FRONT_AND_BACK, GL_LINE );
  }
  
  
  material* metaballs_mat = asset_get_load(P("./shaders/metaballs.mat"));
  
  shader_program* metaballs = material_get_entry(metaballs_mat, 0)->program;
  GLuint NORMALS = glGetAttribLocation(*metaballs, "normals");
  
  glUseProgram(*metaballs);
  
  GLint light_position_u = glGetUniformLocation(*metaballs, "light_position");
  glUniform3f(light_position_u, l->position.x, l->position.y, l->position.z);
  
  GLint camera_position_u = glGetUniformLocation(*metaballs, "camera_position");
  glUniform3f(camera_position_u, c->position.x, c->position.y, c->position.z);
  
  mat4 lviewm = light_view_matrix(l);
  mat4 lprojm = light_proj_matrix(l);
  
  mat4_to_array(lviewm, lview_matrix);
  mat4_to_array(lprojm, lproj_matrix);
  
  GLint lproj_matrix_u = glGetUniformLocation(*metaballs, "light_proj");
  glUniformMatrix4fv(lproj_matrix_u, 1, 0, lproj_matrix);
  
  GLint lview_matrix_u = glGetUniformLocation(*metaballs, "light_view");
  glUniformMatrix4fv(lview_matrix_u, 1, 0, lview_matrix);
  
  
  texture* env_map = asset_get_load(P("./resources/metaballs_env.dds"));
  glActiveTexture(GL_TEXTURE0 + 0 );
  glBindTexture(GL_TEXTURE_2D, *env_map);
  glEnable(GL_TEXTURE_2D);
  glUniform1i(glGetUniformLocation(*metaballs, "env_map"), 0);
  
  texture* shadow_map = shadow_mapper_depth_texture();
  glActiveTexture(GL_TEXTURE0 + 1);
  glBindTexture(GL_TEXTURE_2D, *shadow_map);
  glEnable(GL_TEXTURE_2D);
  glUniform1i(glGetUniformLocation(*metaballs, "shadow_map"), 1);
  
  glBindBuffer(GL_ARRAY_BUFFER, vertex_positions);
  glVertexPointer(4, GL_FLOAT, 0, (void*)0);
  glEnableClientState(GL_VERTEX_ARRAY);
  
  glBindBuffer(GL_ARRAY_BUFFER, vertex_normals);
  glVertexAttribPointer(NORMALS, 4, GL_FLOAT, GL_FALSE, 0, (void*)0);
  glEnableVertexAttribArray(NORMALS);
  
    glDrawArrays(GL_TRIANGLES, 0, num_verts);
  
  glDisableClientState(GL_VERTEX_ARRAY);
  glDisableVertexAttribArray(NORMALS);
  
  glActiveTexture(GL_TEXTURE0 + 1 );
  glDisable(GL_TEXTURE_2D);
  
  glActiveTexture(GL_TEXTURE0 + 0 );
  glDisable(GL_TEXTURE_2D);
  
  glUseProgram(0);
  
  if (wireframe) {
    glPolygonMode( GL_FRONT_AND_BACK, GL_FILL );
  }
  
}