C++ CL_GraphicContext::get_width方法代码示例

void TileMap::set_cur_x(CL_GraphicContext& gc, int x) {
    if (x < 0)
        x = 0;
    else if (get_width() - x < gc.get_width())
        x = get_width() - gc.get_width();
    cur_map_x = x;
}

//Fonction à appeller à chaque changement de résolution
void Game::resizeGLScene()
{
	CL_GraphicContext *gc = CL_Display::get_current_window()->get_gc();
	glViewport(0, 0, (GLsizei) gc->get_width(), (GLsizei) gc->get_height());
	glMatrixMode(GL_PROJECTION);
	glLoadIdentity();
	gluPerspective(45.0f, (GLfloat) gc->get_width() / (GLfloat) gc->get_height(), 0.1f, 500.f);
	glMatrixMode(GL_MODELVIEW);
}

void App::render(CL_GraphicContext &gc)
{
	gc.clear(CL_Colorf(0.0f, 0.0f, 0.0f, 1.0f));

	scene.gs->image_grid.draw(gc, 420.0f, 120.0f);	// Draw a grid in the backgound

	gc.set_map_mode(cl_user_projection);
	CL_Rect viewport_rect(0, 0, CL_Size(gc.get_width(), gc.get_height()));
	gc.set_viewport(viewport_rect);

	gc.set_projection(scene.gs->camera_projection);

	CL_BufferControl buffer_control;
	buffer_control.set_depth_compare_function(cl_comparefunc_lequal);
	buffer_control.enable_depth_write(true);
	buffer_control.enable_depth_test(true);
	buffer_control.enable_stencil_test(false);
	buffer_control.enable_color_write(true);
	gc.set_buffer_control(buffer_control);

	gc.clear_depth(1.0f);

	CL_Mat4f modelview_matrix = scene.gs->camera_modelview;
	scene.Draw(modelview_matrix, gc);
	gc.reset_program_object();
}

void Viewport::prepareGC(CL_GraphicContext &p_gc) {
	p_gc.push_modelview();

	if (m_impl->m_attachPoint != NULL) {
		// calculate world clip rect
		const int stageWidth = Gfx::Stage::getWidth();
		const int stageHeight = Gfx::Stage::getHeight();

		m_impl->m_worldClipRect.left =
				m_impl->m_attachPoint->x - stageWidth / 2 / m_impl->m_scale;
		m_impl->m_worldClipRect.top =
				m_impl->m_attachPoint->y - stageHeight / 2 / m_impl->m_scale;
		m_impl->m_worldClipRect.right =
				m_impl->m_worldClipRect.left + stageWidth / m_impl->m_scale;
		m_impl->m_worldClipRect.bottom =
				m_impl->m_worldClipRect.top + stageHeight / m_impl->m_scale;
	}

	// apply new scale
	const float horizScale = p_gc.get_width() / m_impl->m_worldClipRect.get_width();
	const float vertScale = p_gc.get_height() / m_impl->m_worldClipRect.get_height();

	p_gc.mult_scale(horizScale, vertScale);

	// apply translations
	p_gc.mult_translate(-m_impl->m_worldClipRect.left, -m_impl->m_worldClipRect.top);
}

void App::calculate_matricies(CL_GraphicContext &gc)
{
	scene.gs->camera_projection = CL_Mat4f::perspective(45.0f, ((float) gc.get_width()) / ((float) gc.get_height()), 0.1f, 1000.0f);

	scene.gs->camera_modelview = CL_Mat4f::identity();
	camera->GetWorldMatrix(scene.gs->camera_modelview);
	scene.gs->camera_modelview.scale_self(1.0f, 1.0f, -1.0f);
	scene.gs->camera_modelview.inverse();

}

GSLobby::GSLobby(CL_GraphicContext& gc, CL_ResourceManager& resources)
: m_gsgame(new GSGame(gc, resources)){
	CL_FontDescription desc;
	desc.set_typeface_name("tahoma");
	desc.set_height(32);
	m_font.reset(new CL_Font_System(gc, desc));
	m_xpos = gc.get_width()/2-100;
	m_ypos = gc.get_height()/4;
	m_playbtn.initialize(gc, resources, "game_lobby/play_btn",
						 CL_Vec2<float>(m_xpos, m_ypos+100));
	m_backbtn.initialize(gc, resources, "game_lobby/back_btn",
						 CL_Vec2<float>(m_xpos, m_ypos+200));
}

void ExampleText::draw_text(CL_GraphicContext &gc, CL_Texture &texture, CL_Angle angle)
{
	gc.set_texture(0, texture);

	gc.push_modelview();

	gc.mult_translate(gc.get_width()/2.0f, gc.get_height()/2.0f);
	gc.mult_rotate(angle, 0.0f, 0.0f, 1.0f);

	CL_Draw::texture(gc, CL_Rectf(-300.0f, -300.0f, 300.0f, 300.0f), CL_Colorf(1.0f, 1.0f, 1.0f, 0.7f));

	gc.pop_modelview();

	gc.reset_texture(0);
}

void App::render_gaussian_blur(CL_GraphicContext &gc, float blur_amount, CL_Texture &source_texture, CL_ProgramObject &program_object, float dx, float dy)
{
	int sampleCount = 15;

	float *sampleWeights = new float[sampleCount];
	CL_Vec2f *sampleOffsets = new CL_Vec2f[sampleCount];

	sampleWeights[0] = compute_gaussian(0, blur_amount);
	sampleOffsets[0] = CL_Vec2f(0.0, 0.0);

	float totalWeights = sampleWeights[0];

	for (int i = 0; i < sampleCount / 2; i++)
	{
		float weight = compute_gaussian(i + 1.0f, blur_amount);

		sampleWeights[i * 2 + 1] = weight;
		sampleWeights[i * 2 + 2] = weight;

		totalWeights += weight * 2;

		float sampleOffset = i * 2 + 1.5f;

		CL_Vec2f delta = CL_Vec2f(dx * sampleOffset, dy * sampleOffset);

		sampleOffsets[i * 2 + 1] = delta;
		sampleOffsets[i * 2 + 2] = CL_Vec2f(-delta.x, -delta.y);
	}

	for (int i = 0; i < sampleCount; i++)
	{
		sampleWeights[i] /= totalWeights;
	}

	program_object.set_uniform1i("SourceTexture", 0);
	program_object.set_uniformfv("SampleOffsets", 2, sampleCount, (float *)sampleOffsets);
	program_object.set_uniformfv("SampleWeights", 1, sampleCount, sampleWeights);

	gc.set_texture(0, source_texture);
	gc.set_program_object(program_object, cl_program_matrix_modelview_projection);

	draw_texture(gc, CL_Rectf(0,0,gc.get_width(),gc.get_height()), CL_Colorf::white, CL_Rectf(0.0f, 0.0f, 1.0f, 1.0f));

	gc.reset_program_object();
	gc.reset_texture(0);
}

void TileMap::draw(CL_GraphicContext &gc)
{
	int screen_width = gc.get_width();
	int screen_height = gc.get_height();

	int start_tile_x = cl_max(0, current_map_position_x / tile_width); 
	int start_tile_y = cl_max(0, current_map_position_y / tile_height); 

	int scrolling_pixel_offset_x = current_map_position_x - start_tile_x * tile_width;
	int scrolling_pixel_offset_y = current_map_position_y - start_tile_y * tile_height;

	int tiles_on_screen_horizontally = screen_width / tile_width + 1;
	int tiles_on_screen_vertically = screen_height / tile_height + 1; 

	// since we might show half tiles on edges, make sure we display one more tile to fill screen
	tiles_on_screen_horizontally++;
	tiles_on_screen_vertically++;

	// make sure we don't draw more than the level size
	if(tiles_on_screen_horizontally + start_tile_x > map_width)
		tiles_on_screen_horizontally = map_width - start_tile_x;
	if(tiles_on_screen_vertically + start_tile_y > map_height)
		tiles_on_screen_vertically = map_height - start_tile_y;

	for(size_t l = 0; l < layers.size(); ++l)
	{
		for(int current_tile_y = 0; current_tile_y < tiles_on_screen_vertically; ++current_tile_y)
		{
			for(int current_tile_x = 0; current_tile_x < tiles_on_screen_horizontally; ++current_tile_x)
			{
				int index = (start_tile_y + current_tile_y) * map_width + (start_tile_x + current_tile_x);

				int sprite_index = layers[l].map[index];

				int tile_position_screen_x = current_tile_x * tile_width - scrolling_pixel_offset_x;
				int tile_position_screen_y = current_tile_y * tile_height - scrolling_pixel_offset_y;

				sprite_tiles.set_frame(sprite_index);
				sprite_tiles.draw(gc, tile_position_screen_x, tile_position_screen_y); 
			}
		}
	}
}

void App::calculate_matricies(CL_GraphicContext &gc)
{
	scene.gs->camera_projection = CL_Mat4f::perspective(45.0f, ((float) gc.get_width()) / ((float) gc.get_height()), 0.1f, 1000.0f);

	float ortho_size = 60.0f / 2.0f;
	scene.gs->light_projection = CL_Mat4f::ortho(-ortho_size, ortho_size, -ortho_size, ortho_size, 0.1f, 1000.0f);

	scene.gs->camera_modelview = CL_Mat4f::identity();
	camera->GetWorldMatrix(scene.gs->camera_modelview);
	scene.gs->camera_modelview.scale_self(1.0f, 1.0f, -1.0f);
	scene.gs->camera_modelview.inverse();

	scene.gs->light_modelview = CL_Mat4f::identity();
	light->GetWorldMatrix(scene.gs->light_modelview);
	scene.gs->light_modelview.scale_self(1.0f, 1.0f, -1.0f);
	scene.gs->light_modelview.inverse();

	scene.gs->shadow_matrix = scene.gs->light_modelview * scene.gs->light_projection;
}

bool GUI::run()
{
	static int total_time = 0, fps_count = 0, last_fps= 0;
	static int start_time = 0;

	if (start_time == 0)
	{
		start_time = CL_System::get_time();
	}

	CL_GraphicContext gc = app->get_window()->get_gc();

	gc.set_map_mode(CL_MapMode(cl_map_2d_upper_left));

	CL_Draw::gradient_fill(gc, app->get_window()->get_viewport(), CL_Gradient(CL_Colorf(0.4f, 0.4f, 0.4f, 1.0f), CL_Colorf(0.0f, 0.0f, 0.0f, 1.0f)));

	run_manager(gc);

	CL_String fps = cl_format("FPS: %1", last_fps);
	fps_font.draw_text(gc, gc.get_width() - 100 - 2, 24 - 2, fps, CL_Colorf(0.0f, 0.0f, 0.0f, 1.0f));
	fps_font.draw_text(gc, gc.get_width() - 100, 24, fps, CL_Colorf::white);

	fps_font.draw_text(gc, 24, gc.get_height() - 16, "Rendering GUI onto a CL_Texture, then onto the display window.", CL_Colorf(1.0f, 1.0f, 1.0f, 1.0f));

	fps_count++;
	int time = CL_System::get_time();
	total_time += time - start_time;
	start_time = time;
	if(total_time >= 1000)
	{
		last_fps = fps_count;
		total_time -= 1000;
		fps_count = 0;
	}

	balls.Run(gc);

	CL_KeepAlive::process();
	app->get_window()->flip(0);

	return true;
}

void App::calculate_matrix(CL_GraphicContext &gc)
{
	float lens_zoom = 3.2f;
	float lens_near = 0.1f;
	float lens_far = 10000.0f;
	float lens_aspect = 1.0f;

	float fov = 2.0f * atan2(1.0f, lens_zoom);
	float aspect = 1.0f;
	float width = (float) gc.get_width();
	float height = (float) gc.get_height();

	if (height)
		aspect = ( width * lens_aspect) / height;

	fov = (fov * 180.0f) / CL_PI;
	projection_matrix = CL_Mat4f::perspective( fov, aspect, lens_near, lens_far);

	modelview_matrix = CL_Mat4f::identity();
	modelview_matrix.matrix[2 + (4*2)] = -1.0f;
}

void Viewport::prepareGC(CL_GraphicContext &p_gc) {
    p_gc.push_modelview();

    if (m_attachPoint != NULL) {
        const int stageWidth = Gfx::Stage::getWidth();
        const int stageHeight = Gfx::Stage::getHeight();

        m_x = m_attachPoint->x - stageWidth / 2 / m_scale;
        m_y = m_attachPoint->y - stageHeight / 2 / m_scale;
        m_width = stageWidth / m_scale;
        m_height = stageHeight / m_scale;
    }

    const float horizScale = p_gc.get_width() / m_width;
    const float vertScale = p_gc.get_height() / m_height;

    p_gc.mult_scale(horizScale, vertScale);

    p_gc.mult_translate(-m_x, -m_y);


}

void App::create_shooter( const CL_InputEvent &key, const CL_StringRef &str, bool use_red, bool use_green, bool use_blue)
{
	// Set the firing line
	CL_Vec3f vector(0.0f, 0.0f, 20.0f);
	CL_GraphicContext gc = window.get_gc();
	float width = (float) gc.get_width();
	float height = (float) gc.get_height();

	vector.x = ((key.mouse_pos.x - width/2)* 10.0f) / width;
	vector.y = -((key.mouse_pos.y - height/2) * 10.0f) / height;

	// Create the text offset
	TextShooter shooter(vector_font, str);
	shooter.set_start_time(CL_System::get_time());
	shooter.set_duration(2 * 1000);
	shooter.set_initial_white_time(1000);
	shooter.set_end_fade_time(1000);
	shooter.set_start_position(CL_Vec3f(0.0f, 0.0f, 0.2f));
	shooter.set_end_position(vector);
	shooter.set_color_component(use_red, use_green, use_blue);
	text_shooter.push_back(shooter);
}

void App::render_night_vision(CL_GraphicContext &gc, CL_Texture &source_texture, CL_Texture &mask_texture, CL_Texture &noise_texture, CL_ProgramObject &program_object)
{
	program_object.set_uniform1i("sceneBuffer", 0);
	program_object.set_uniform1i("noiseTex", 1);
	program_object.set_uniform1i("maskTex", 2);

	program_object.set_uniform1f("elapsedTime", elapsedTime);
	program_object.set_uniform1f("luminanceThreshold", luminanceThreshold);
	program_object.set_uniform1f("colorAmplification", colorAmplification);
	program_object.set_uniform1f("effectCoverage", effectCoverage);

	gc.set_texture(0, source_texture);
	gc.set_texture(1, noise_texture);
	gc.set_texture(2, mask_texture);
	
	gc.set_program_object(program_object, cl_program_matrix_modelview_projection);

	draw_texture(gc, CL_Rectf(0,0,gc.get_width(),gc.get_height()), CL_Colorf::white, CL_Rectf(0.0f, 0.0f, 1.0f, 1.0f));

	gc.reset_program_object();
	gc.reset_texture(2);
	gc.reset_texture(1);
	gc.reset_texture(0);
}