Beispiel #1
0
void GLAppMain::idle()
{
    float ratio = (float)window_width / (float) window_height;
    projection.perspective(45,ratio,1,10000);

    vec3 lat = vec3(0,1,0)^lookat;
    lat.normalize();

    // keyboard events
    if(keys[KEY_ESC]) exit();
    if(keys[' ']){ 
	    goon = !goon;
	    keys[' '] = 0;
	  }
    if(keys[KEY_UP]) {
        pos += lookat*(50/fps);
        keys[KEY_UP] = 0;
    }
    if(keys[KEY_DOWN]) {
        pos -= lookat*(50/fps);
        keys[KEY_DOWN] = 0;
    }
    if(keys[KEY_LEFT]) {
        pos += lat*(50/fps);
        keys[KEY_LEFT] = 0;
    }
    if(keys[KEY_RIGHT]) {
        pos -= lat*(50/fps);
        keys[KEY_RIGHT] = 0;
    }

    static int look = 0;
    if(!look && mouse_button & BUTTON_LEFT) {
        setCursor(window_width / 2,window_height / 2);
        mouse_x = window_width / 2;
        mouse_y = window_height / 2;
        look = 1;
    }
    if(mouse_button & BUTTON_RIGHT) look = 0;

    if(look) {
        showCursor(0);
        mat3 m;
        m.rotate( lat, (mouse_y - window_height / 2) * 0.2 );
        lookat = m*lookat;
        m.rotate_y( -(mouse_x - window_width / 2) * 0.2 );
        lookat = m*lookat;
        setCursor(window_width / 2,window_height / 2);
    } else showCursor(1);

    vec3 up = lookat^lat;
    up.normalize();
    modelview.look_at(pos,pos+lookat,up);
}
void opengl_display()
{
//	glBindFramebuffer(GL_FRAMEBUFFER, 0);
	glBindFramebuffer(GL_FRAMEBUFFER, frame_buffer);

	if(torus_mesh.program != NULL)
	{
		glViewport(0,0,1024,1024);
		glClearColor(0.004,0.01,0.01,0.01);
		glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);		


		view_matrix.look_at(vec3(0,0,distance_z), vec3(0,0,0), vec3(0,1,0));
		view_proj_matrix = quad_proj_matrix * view_matrix * world_matrix;

		glEnable(GL_BLEND);
		glBlendFunc(GL_ONE, GL_ONE);

		glUseProgram(torus_mesh.program->get_program());
		glUniformMatrix4fv(torus_mesh.loc_view_proj_matrix, 1, GL_FALSE, &view_proj_matrix[0]);

		torus_mesh.draw();
	}

	glBindFramebuffer(GL_FRAMEBUFFER, 0);

	if(quad_mesh.program != NULL)
	{
		glViewport(0,0,width, height);
		glClearColor(0.004,0.01,0.01,0.01);
		glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);	

		glDisable(GL_BLEND);

//		view_proj_matrix = mat4();

		glUseProgram(quad_mesh.program->get_program());
//		glUniformMatrix4fv(quad_mesh.loc_view_proj_matrix, 1, GL_FALSE, &view_proj_matrix[0]);

		glActiveTexture(GL_TEXTURE0);
		glBindTexture(GL_TEXTURE_2D, quad_mesh.texs_idxs[0]);
		glUniform1i(quad_mesh.texs_locs[0], 0);

		glActiveTexture(GL_TEXTURE1);
		glBindTexture(GL_TEXTURE_2D, quad_mesh.texs_idxs[1]);
		glUniform1i(quad_mesh.texs_locs[1], 1);

		quad_mesh.draw();

	}
}
void opengl_display()
{
	static double start = get_time();
	float current_time = get_time()-start;

	light_dir.x = sin(current_time * 0.6f);
	light_dir.z = cos(current_time * 0.6f);

	light_pos.x = -light_dir.x * 100.f;
	light_pos.z = -light_dir.z * 100.f;
	light_pos.y = 10.f * sin(current_time * 0.5f);

	/* background and object ******************************************************************/

	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);	

	//-------------------------------------------------------------------
	view_matrix.look_at(vec3(0,0,distance_z), vec3(0,0,0), vec3(0,1,0));
	world_view_matrix = view_matrix * world_matrix;
	world_view_proj_matrix = proj_matrix * world_view_matrix;

	vec3 viewpos  = world_view_matrix.inverse() * vec3(0,0,0);
	view_pos = vec4(viewpos.x, viewpos.y, viewpos.z, 1.0);

	glUseProgram(object_program.p_program->get_program());

	glActiveTexture(GL_TEXTURE0);
	glBindTexture(GL_TEXTURE_2D, texture_bump);
	glUniform1i(object_program.texs_locs[0], 0);

	glActiveTexture(GL_TEXTURE1);
	glBindTexture(GL_TEXTURE_2D, texture_obj);
	glUniform1i(object_program.texs_locs[1], 1);

	glUniformMatrix4fv(object_program.loc_world_view_proj, 1, GL_FALSE, &world_view_proj_matrix[0]);
	glUniform4fv(object_program.loc_light_pos, 1, &light_pos.x);
	glUniform4fv(object_program.loc_light_dir, 1, &light_dir.x);
	glUniform4fv(object_program.loc_view_pos, 1, &view_pos.x);

	draw(&object_program, &object_mesh);
}
void opengl_display()
{
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);	

	static double start = get_time();
	float t = get_time()-start;

	cos_time = cos(t)*0.2f;
	sin_time = sin(t)*0.2f;

	view_matrix.look_at(vec3(0,0,distance_z), vec3(0,0,0), vec3(0,1,0));
	world_view_matrix = view_matrix * world_matrix;
	world_view_proj_matrix = projection_matrix * world_view_matrix;


	if(earth_mesh.program != NULL)
	{
		glUseProgram(earth_mesh.program->get_program());
		glUniformMatrix4fv(earth_mesh.loc_world_view_matrix, 1, GL_FALSE, &world_view_matrix[0]);
		glUniformMatrix4fv(earth_mesh.loc_world_view_proj_matrix, 1, GL_FALSE, &world_view_proj_matrix[0]);
		glUniform1f(earth_mesh.loc_cos_time, cos_time);
		glUniform1f(earth_mesh.loc_sin_time, sin_time);

		glActiveTexture(GL_TEXTURE0);
		glBindTexture(GL_TEXTURE_2D, earth_mesh.texs_idxs[0]);
		glUniform1i(earth_mesh.texs_locs[0], 0);

		glActiveTexture(GL_TEXTURE1);
		glBindTexture(GL_TEXTURE_2D, earth_mesh.texs_idxs[1]);
		glUniform1i(earth_mesh.texs_locs[1], 1);

		glActiveTexture(GL_TEXTURE2);
		glBindTexture(GL_TEXTURE_2D, earth_mesh.texs_idxs[2]);
		glUniform1i(earth_mesh.texs_locs[2], 2);

		earth_mesh.draw();
	}
	
}
void opengl_display()
{
	
	glBindFramebuffer(GL_FRAMEBUFFER, render_fbo);

	if(model_mesh.program != NULL)
	{
		glViewport(0,0,512,512);
		glClearColor(0,0,0,0);
		glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);		

		glEnable(GL_DEPTH_TEST);


		world_view_matrix.look_at(vec3(0,0,distance_z), vec3(0,0,0), vec3(0,1,0));
		world_view_matrix *= world_matrix;
		view_proj_matrix = quad_proj_matrix * world_view_matrix;

		glUseProgram(model_mesh.program->get_program());

		glActiveTexture(GL_TEXTURE0);
		glBindTexture(GL_TEXTURE_2D, model_mesh.texs_idxs[0]);
		glUniform1i(model_mesh.texs_locs[0], 0);

		glUniformMatrix4fv(model_mesh.loc_view_proj_matrix, 1, GL_FALSE, &view_proj_matrix[0]);
		glUniformMatrix4fv(model_mesh.loc_view_matrix, 1, GL_FALSE, &world_view_matrix[0]);

		model_mesh.draw();
	}

	glBindFramebuffer(GL_FRAMEBUFFER, blur_fbo);

	if(blur_mesh.program != NULL)
	{
		glViewport(0,0,512, 512);
		glClearColor(0,0,0,0);
		glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);	

		glDisable(GL_DEPTH_TEST);

		glUseProgram(blur_mesh.program->get_program());

		glActiveTexture(GL_TEXTURE0);
		glBindTexture(GL_TEXTURE_2D, blur_mesh.texs_idxs[0]);
		glUniform1i(blur_mesh.texs_locs[0], 0);

		blur_mesh.draw();

	}

	glBindFramebuffer(GL_FRAMEBUFFER, 0);

	if(combine_mesh.program != NULL)
	{
		glViewport(0,0,width, height);
		glClearColor(0,0,0,0);
		glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);	

		glDisable(GL_DEPTH_TEST);

		glUseProgram(combine_mesh.program->get_program());

		glActiveTexture(GL_TEXTURE0);
		glBindTexture(GL_TEXTURE_2D, combine_mesh.texs_idxs[0]);
		glUniform1i(combine_mesh.texs_locs[0], 0);

		glActiveTexture(GL_TEXTURE1);
		glBindTexture(GL_TEXTURE_2D, combine_mesh.texs_idxs[1]);
		glUniform1i(combine_mesh.texs_locs[1], 1);

		combine_mesh.draw();
	}
	
}
void opengl_display()
{
	static double start = get_time();
	float t = get_time()-start;

	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);	

	
	t *= 25.f;


	
	background_world.rotate_y(t);

	vec3 eye = vec3(0,0,distance_z);
	view.look_at(eye, vec3(0,0,0), vec3(0,1,0));

	
	//render background
	wvp = projection * background_world;

	if(background_mesh.program != NULL)
	{
		glDisable(GL_CULL_FACE);
		glUseProgram(background_mesh.program->get_program());
		glUniformMatrix4fv(background_mesh.wvp_loc, 1, GL_FALSE, &wvp[0]);

		glActiveTexture(GL_TEXTURE0);
		glBindTexture(GL_TEXTURE_CUBE_MAP, background_mesh.texs_idxs[0]);
		glUniform1i(background_mesh.texs_locs[0], 0);

		glUniformMatrix4fv(background_mesh.wvp_loc, 1, GL_FALSE, &wvp[0]);

		background_mesh.draw();
	}

	//render statue

	env_inv_world = background_world.inverse();
	wvp = projection * view;
	wvp *= statue_world;
	eye = env_inv_world * eye;


	if(statue_mesh.program != NULL)
	{
		glEnable(GL_CULL_FACE);
		glUseProgram(statue_mesh.program->get_program());
		glUniformMatrix4fv(statue_mesh.wvp_loc, 1, GL_FALSE, &wvp[0]);
		glUniformMatrix4fv(statue_mesh.world_loc, 1, GL_FALSE, &statue_world[0]);
		glUniformMatrix4fv(statue_mesh.env_inv_world_loc, 1,GL_FALSE, &env_inv_world[0]);
		glUniform3fv(statue_mesh.eye_loc, 1, &eye.x);

		glActiveTexture(GL_TEXTURE0);
		glBindTexture(GL_TEXTURE_2D, statue_mesh.texs_idxs[0]);
		glUniform1i(statue_mesh.texs_locs[0], 0);

		glActiveTexture(GL_TEXTURE1);
		glBindTexture(GL_TEXTURE_CUBE_MAP, statue_mesh.texs_idxs[1]);
		glUniform1i(statue_mesh.texs_locs[1], 1);

		statue_mesh.draw();

	}
}