void CL_RenderBatch3D::flush(CL_GraphicContext &gc) { if (position > 0) { gc.set_modelview(CL_Mat4f::identity()); gc.set_program_object(cl_program_sprite); if (use_glyph_program) { CL_BlendMode old_blend_mode = gc.get_blend_mode(); CL_BlendMode blend_mode; blend_mode.set_blend_color(constant_color); blend_mode.set_blend_function(cl_blend_constant_color, cl_blend_one_minus_src_color, cl_blend_zero, cl_blend_one); gc.set_blend_mode(blend_mode); for (int i = 0; i < num_current_textures; i++) gc.set_texture(i, current_textures[i]); CL_PrimitivesArray prim_array(gc); prim_array.set_attributes(0, &vertices[0].position, sizeof(SpriteVertex)); prim_array.set_attributes(1, &vertices[0].color, sizeof(SpriteVertex)); prim_array.set_attributes(2, &vertices[0].texcoord, sizeof(SpriteVertex)); prim_array.set_attributes(3, &vertices[0].texindex, sizeof(SpriteVertex)); gc.draw_primitives(cl_triangles, position, prim_array); for (int i = 0; i < num_current_textures; i++) gc.reset_texture(i); gc.set_blend_mode(old_blend_mode); } else { for (int i = 0; i < num_current_textures; i++) gc.set_texture(i, current_textures[i]); CL_PrimitivesArray prim_array(gc); prim_array.set_attributes(0, &vertices[0].position, sizeof(SpriteVertex)); prim_array.set_attributes(1, &vertices[0].color, sizeof(SpriteVertex)); prim_array.set_attributes(2, &vertices[0].texcoord, sizeof(SpriteVertex)); prim_array.set_attributes(3, &vertices[0].texindex, sizeof(SpriteVertex)); gc.draw_primitives(cl_triangles, position, prim_array); for (int i = 0; i < num_current_textures; i++) gc.reset_texture(i); } gc.reset_program_object(); gc.set_modelview(modelview); position = 0; for (int i = 0; i < num_current_textures; i++) current_textures[i] = CL_Texture(); num_current_textures = 0; } }
void Model_Impl::Draw(CL_GraphicContext &gc, GraphicStore *gs, const CL_Mat4f &modelview_matrix) { gc.set_modelview(modelview_matrix); CL_PrimitivesArray prim_array(gc); prim_array.set_attributes(0, vbo_positions, 3, cl_type_float, (void *) 0); prim_array.set_attributes(1, vbo_normals, 3, cl_type_float, (void *) 0); if (!vbo_texcoords.is_null()) { prim_array.set_attributes(2, vbo_texcoords, 2, cl_type_float, (void *) 0); gc.set_texture(0, gs->texture_underwater); gc.set_texture(1, gs->texture_background); gs->shader_texture.SetMaterial(material_shininess, material_emission, material_ambient, material_specular); gs->shader_texture.Use(gc); } else { throw CL_Exception("What! no texure coordinates?"); } gc.draw_primitives(cl_triangles, vbo_size, prim_array); gc.reset_texture(0); gc.reset_texture(0); }
void App::render_from_lightsource(CL_GraphicContext &gc, CL_FrameBuffer &framebuffer) { CL_PrimitivesArray prim_array(gc); gc.set_frame_buffer(framebuffer); gc.set_map_mode(cl_user_projection); CL_Rect viewport_rect2(0, 0, CL_Size(scene.gs->texture_shadow.get_width(), scene.gs->texture_shadow.get_height())); gc.set_viewport(viewport_rect2); CL_Mat4f perp = CL_Mat4f::perspective(67.0f, 1.0f, 0.1f, 1000.0f); gc.set_projection(scene.gs->light_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(false); gc.set_buffer_control(buffer_control); gc.clear_depth(1.0f); CL_Mat4f modelview_matrix = scene.gs->light_modelview; scene.Draw(modelview_matrix, gc, true); gc.reset_program_object(); gc.set_modelview(CL_Mat4f::identity()); gc.set_map_mode(CL_MapMode(cl_map_2d_upper_left)); gc.reset_frame_buffer(); }
void App::set_user_projection(CL_GraphicContext &gc, CL_Sizef &area_size, Options *options) { gc.set_viewport(CL_Rectf(0, 0, area_size)); 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; aspect = ( area_size.width * lens_aspect) / area_size.height; fov = (fov * 180.0f) / CL_PI; CL_Mat4f projection_matrix = CL_Mat4f::perspective( fov, aspect, lens_near, lens_far); gc.set_projection(projection_matrix); CL_Mat4f modelview_matrix = CL_Mat4f::identity(); modelview_matrix.scale_self(1.0f, 1.0f, -1.0f); // So positive Z goes into the screen modelview_matrix.translate_self(-1.0f, 1.0, lens_zoom); modelview_matrix = modelview_matrix.multiply(CL_Mat4f::rotate(CL_Angle((float) -options->grid_angle, cl_degrees), 1.0f, 0.0f, 0.0f, false)); modelview_matrix.scale_self(2.0f / area_size.width, -2.0f / area_size.height, 1.0f); modelview_matrix.translate_self(cl_pixelcenter_constant,cl_pixelcenter_constant, 0.0f); gc.set_modelview(modelview_matrix); }
void Model_Impl::Draw(CL_GraphicContext &gc, GraphicStore *gs, const CL_Mat4f &modelview_matrix) { gc.set_modelview(modelview_matrix); CL_PrimitivesArray prim_array(gc); prim_array.set_attributes(0, vbo_positions, 3, cl_type_float, (void *) 0); prim_array.set_attributes(1, vbo_normals, 3, cl_type_float, (void *) 0); gs->shader_color.SetMaterial(material_shininess, material_emission, material_ambient, material_specular); gs->shader_color.Use(gc); gc.draw_primitives(cl_triangles, vbo_size, prim_array); }
void ShaderImpl::end(CL_GraphicContext &p_gc) { G_ASSERT(m_initialized); G_ASSERT(m_began); // detach frame buffer p_gc.reset_frame_buffer(); m_frameBuffer.detach_color_buffer(0, m_texture); // prepare shader m_program.set_uniform1i("tex", 0); m_program.set_uniform1i("textureWidth", m_drawRect.get_width()); m_program.set_uniform1i("textureHeight", m_drawRect.get_height()); m_parent->setUniforms(m_program); // draw texture using shader p_gc.set_modelview(CL_Mat4f::identity()); p_gc.mult_translate(m_drawRect.left, m_drawRect.top); p_gc.mult_scale(m_drawRect.get_width(), m_drawRect.get_height()); p_gc.set_texture(0, m_texture); p_gc.set_program_object(m_program); p_gc.draw_primitives(cl_quads, 4, m_quad); p_gc.reset_program_object(); p_gc.reset_texture(0); #if defined(DRAW_WIREFRAME) CL_Draw::line(p_gc, 0, 0, 1, 0, CL_Colorf::red); CL_Draw::line(p_gc, 1, 0, 1, 1, CL_Colorf::red); CL_Draw::line(p_gc, 1, 1, 0, 1, CL_Colorf::red); CL_Draw::line(p_gc, 0, 1, 0, 0, CL_Colorf::red); #endif // DRAW_WIREFRAME // reset modelview matrix p_gc.pop_modelview(); m_began = false; }
void Model_Impl::Draw(CL_GraphicContext &gc, GraphicStore *gs, const CL_Mat4f &modelview_matrix, bool is_draw_shadow) { gc.set_modelview(modelview_matrix); CL_PrimitivesArray prim_array(gc); prim_array.set_attributes(0, vbo_positions, 3, cl_type_float, (void *) 0); prim_array.set_attributes(1, vbo_normals, 3, cl_type_float, (void *) 0); if (is_draw_shadow) { gs->shader_depth.Use(gc); gc.draw_primitives(cl_triangles, vbo_size, prim_array); } else { if (!vbo_texcoords.is_null()) { prim_array.set_attributes(2, vbo_texcoords, 2, cl_type_float, (void *) 0); gs->shader_texture.SetShadowMatrix(gs->shadow_matrix); gc.set_texture(0, gs->texture_brick); gc.set_texture(1, gs->texture_shadow); gs->shader_texture.SetMaterial(material_shininess, material_emission, material_ambient, material_specular); gs->shader_texture.Use(gc); } else { gs->shader_color.SetMaterial(material_shininess, material_emission, material_ambient, material_specular); gs->shader_color.Use(gc); } gc.draw_primitives(cl_triangles, vbo_size, prim_array); gc.reset_texture(0); gc.reset_texture(1); } }
void Model_Impl::Draw(CL_GraphicContext &gc, GraphicStore *gs, const CL_Mat4f &modelview_matrix, bool use_geometry_shader) { if (!object_positions.size()) return; if (update_vbo) { update_vbo = false; if (object_texcoords.size()) { object_texcoords_vbo = CL_VertexArrayBuffer(gc, &object_texcoords[0], sizeof(CL_Vec2f) * object_texcoords.size()); } object_positions_vbo = CL_VertexArrayBuffer(gc, &object_positions[0], sizeof(CL_Vec3f) * object_positions.size()); object_normals_vbo = CL_VertexArrayBuffer(gc, &object_normals[0], sizeof(CL_Vec3f) * object_normals.size()); } gc.set_modelview(modelview_matrix); CL_PrimitivesArray prim_array(gc); prim_array.set_attributes(0, object_positions_vbo, 3, cl_type_float, (void *) 0); prim_array.set_attributes(1, object_normals_vbo, 3, cl_type_float, (void *) 0); if (!use_geometry_shader) { if (object_texcoords.size()) { prim_array.set_attributes(2, object_texcoords_vbo, 2, cl_type_float, (void *) 0); gc.set_texture(0, gs->texture_brick); gs->shader_texture.SetMaterial(material_shininess, material_emission, material_ambient, material_specular); gs->shader_texture.Use(gc); } else { gs->shader_color.SetMaterial(material_shininess, material_emission, material_ambient, material_specular); gs->shader_color.Use(gc); } } else { if (object_texcoords.size()) throw CL_Exception("Shader not supported"); gs->shader_color_geometry.SetMaterial(material_shininess, material_emission, material_ambient, material_specular); gs->shader_color_geometry.Use(gc); clDisable(CL_CULL_FACE); // For for example, so you can see inside the teapot } gc.draw_primitives(cl_triangles, object_positions.size(), prim_array); if (use_geometry_shader) clEnable(CL_CULL_FACE); if (object_texcoords.size()) { gc.reset_texture(0); } }
// The start of the Application int App::start(const std::vector<CL_String> &args) { quit = false; CL_OpenGLWindowDescription desc; desc.set_title("ClanLib Geometry Shader Example"); desc.set_size(CL_Size(900, 700), true); desc.set_multisampling(0); desc.set_allow_resize(false); desc.set_depth_size(16); desc.set_version(3, 2, false); CL_DisplayWindow window(desc); // Connect the Window close event CL_Slot slot_quit = window.sig_window_close().connect(this, &App::on_window_close); // Connect a keyboard handler to on_key_up() CL_Slot slot_input_up = (window.get_ic().get_keyboard()).sig_key_up().connect(this, &App::on_input_up); // Get the graphic context CL_GraphicContext gc = window.get_gc(); // Setup graphic store GraphicStore graphic_store(gc); scene.gs = &graphic_store; // Prepare the display gc.set_map_mode(cl_user_projection); CL_PolygonRasterizer polygon_rasterizer; polygon_rasterizer.set_culled(false); polygon_rasterizer.set_face_cull_mode(cl_cull_back); polygon_rasterizer.set_front_face(cl_face_side_clockwise); gc.set_polygon_rasterizer(polygon_rasterizer); create_scene(gc); camera_angle = 0.0f; CL_Font font(gc, "tahoma", 24); FramerateCounter framerate_counter; unsigned int time_last = CL_System::get_time(); // Run until someone presses escape while (!quit) { framerate_counter.frame_shown(); unsigned int time_now = CL_System::get_time(); time_delta = time_now - time_last; time_last = time_now; control_camera(); calculate_matricies(gc); gc.set_polygon_rasterizer(polygon_rasterizer); gc.clear_depth(1.0f); // ** If enabling below, change the graphic from alpha_ball2.png to alpha_ball.png in graphic_store.cpp //render_depth_buffer(gc); // Render to depth buffer first, to fake sorting the particles render(gc); // Render scene gc.set_modelview(CL_Mat4f::identity()); gc.set_map_mode(cl_map_2d_upper_left); CL_String fps(cl_format("fps = %1", framerate_counter.get_framerate())); font.draw_text(gc, 16-2, gc.get_height()-16-2, fps, CL_Colorf(0.0f, 0.0f, 0.0f, 1.0f)); font.draw_text(gc, 16, gc.get_height()-16-2, fps, CL_Colorf(1.0f, 1.0f, 1.0f, 1.0f)); CL_String info(cl_format("Drawing %1 particles", ParticleObject::num_points)); font.draw_text(gc, 16, 30, info); // Use flip(1) to lock the fps window.flip(0); // This call processes user input and other events CL_KeepAlive::process(); } return 0; }
// The start of the Application int App::start(const std::vector<CL_String> &args) { CL_DisplayWindowDescription win_desc; win_desc.set_allow_resize(true); win_desc.set_title("MapMode Example"); win_desc.set_size(CL_Size( 800, 480 ), false); CL_DisplayWindow window(win_desc); CL_Slot slot_quit = window.sig_window_close().connect(this, &App::on_window_close); CL_Slot slot_input_up = (window.get_ic().get_keyboard()).sig_key_up().connect(this, &App::on_input_up); CL_String theme; if (CL_FileHelp::file_exists("../../../Resources/GUIThemeAero/theme.css")) theme = "../../../Resources/GUIThemeAero"; else if (CL_FileHelp::file_exists("../../../Resources/GUIThemeBasic/theme.css")) theme = "../../../Resources/GUIThemeBasic"; else throw CL_Exception("No themes found"); CL_GUIWindowManagerTexture wm(window); CL_GUIManager gui(wm, theme); CL_GraphicContext gc = window.get_gc(); // Deleted automatically by the GUI Options *options = new Options(gui, CL_Rect(0, 0, gc.get_size())); CL_Image image_grid(gc, "../Blend/Resources/grid.png"); CL_Image image_ball(gc, "../Blend/Resources/ball.png"); float grid_width = (float) image_grid.get_width(); float grid_height = (float) image_grid.get_height(); grid_space = (float) (image_grid.get_width() - image_ball.get_width()); setup_balls(); options->request_repaint(); unsigned int time_last = CL_System::get_time(); while (!quit) { unsigned int time_now = CL_System::get_time(); float time_diff = (float) (time_now - time_last); time_last = time_now; wm.process(); wm.draw_windows(gc); int num_balls = options->num_balls; if (num_balls > max_balls) num_balls = max_balls; if (options->is_moveballs_set) move_balls(time_diff, num_balls); gc.set_map_mode(options->current_mapmode); const float grid_xpos = 10.0f; const float grid_ypos = 10.0f; if (options->current_mapmode == cl_user_projection) { CL_Sizef area_size(grid_width + (grid_xpos * 2.0f), grid_height + (grid_ypos * 2.0f)); set_user_projection(gc, area_size, options); } // Draw the grid image_grid.draw(gc, grid_xpos, grid_ypos); gc.flush_batcher(); // <--- Fix me, this should not be required for cl_user_projection for (int cnt=0; cnt<num_balls; cnt++) { image_ball.draw(gc, grid_xpos + balls[cnt].xpos, grid_ypos + balls[cnt].ypos); } gc.set_modelview(CL_Mat4f::identity()); gc.set_projection(CL_Mat4f::identity()); gc.set_map_mode(cl_map_2d_upper_left); window.flip(1); CL_KeepAlive::process(); } return 0; }
// The start of the Application int App::start(const std::vector<CL_String> &args) { quit = false; CL_GL1WindowDescription desc; desc.set_title("ClanLib Object 3D Example"); desc.set_size(CL_Size(640, 480), true); desc.set_multisampling(4); desc.set_depth_size(16); CL_DisplayWindow window(desc); #ifdef _DEBUG //struct aiLogStream stream; //stream = aiGetPredefinedLogStream(aiDefaultLogStream_STDOUT,NULL); //aiAttachLogStream(&stream); //stream = aiGetPredefinedLogStream(aiDefaultLogStream_FILE,"assimp_log.txt"); //aiAttachLogStream(&stream); #endif // Connect the Window close event CL_Slot slot_quit = window.sig_window_close().connect(this, &App::on_window_close); // Connect a keyboard handler to on_key_up() CL_Slot slot_input_up = (window.get_ic().get_keyboard()).sig_key_up().connect(this, &App::on_input_up); // Get the graphic context CL_GraphicContext gc = window.get_gc(); #ifdef USE_OPENGL_1 CL_GraphicContext_GL1 gc_gl1 = gc; #endif // Prepare the display gc.set_map_mode(cl_user_projection); CL_PolygonRasterizer polygon_rasterizer; polygon_rasterizer.set_culled(true); polygon_rasterizer.set_face_cull_mode(cl_cull_back); polygon_rasterizer.set_front_face(cl_face_side_clockwise); gc.set_polygon_rasterizer(polygon_rasterizer); CL_BufferControl buffer_control; buffer_control.enable_depth_test(true); buffer_control.set_depth_compare_function(cl_comparefunc_lequal); buffer_control.enable_depth_write(true); gc.set_buffer_control(buffer_control); #ifdef USE_OPENGL_1 // Set the lights CL_LightModel_GL1 light_model; light_model.enable_lighting(true); light_model.set_flat_shading(false); light_model.set_scene_ambient_light(CL_Colorf(0.2f, 0.2f, 0.2f, 1.0f)); gc_gl1.set_light_model(light_model); CL_LightSource_GL1 light_distant; light_distant.set_spot_cutoff(180.0f); light_distant.set_diffuse_intensity(CL_Colorf(1.0f, 1.0f, 1.0f, 1.0f)); light_distant.set_position(CL_Vec4f(0.0f, -2.0f, 30.0f, 0.0f).normalize3()); gc_gl1.set_light(0, light_distant); cl1Enable(GL_NORMALIZE); #endif #ifdef USE_OPENGL_2 Shader shader(gc); #endif // Create the objects aiSetImportPropertyFloat(AI_CONFIG_PP_GSN_MAX_SMOOTHING_ANGLE,89.53f); const struct aiScene* scene_teapot = aiImportFile("../Clan3D/Resources/teapot.dae",aiProcessPreset_TargetRealtime_MaxQuality); if (!scene_teapot) throw CL_Exception("Cannot load the teapot model"); const struct aiScene* scene_clanlib = aiImportFile("../Clan3D/Resources/clanlib.dae",aiProcessPreset_TargetRealtime_MaxQuality); if (!scene_clanlib) throw CL_Exception("Cannot load the clanlib model"); const struct aiScene* scene_tuxball = aiImportFile("../Clan3D/Resources/tux_ball.dae",aiProcessPreset_TargetRealtime_MaxQuality | aiProcess_FlipUVs); if (!scene_tuxball) throw CL_Exception("Cannot load the tux ball model"); // Load the texture CL_Texture tux(gc, "../Clan3D/Resources/tux.png"); float angle = 0.0f; // Run until someone presses escape while (!quit) { CL_Mat4f perp = CL_Mat4f::perspective(45.0f, ((float) gc.get_width()) / ((float) gc.get_height()), 0.1f, 1000.0f); gc.set_projection(perp); gc.clear(CL_Colorf::black); gc.clear_depth(1.0f); angle += 1.0f; if (angle >= 360.0f) angle -= 360.0f; #ifdef USE_OPENGL_2 shader.Set(gc); shader.Use(gc); #else gc.set_program_object(cl_program_color_only); #endif CL_PrimitivesArray prim_array(gc); gc.set_modelview(CL_Mat4f::identity()); gc.mult_scale(1.0f,1.0f, -1.0f); // So +'ve Z goes into the screen gc.mult_translate(0.0f, 0.0f, 2.0f); gc.mult_rotate(CL_Angle(angle, cl_degrees), 0.0f, 1.0f, 0.0f, false); gc.push_modelview(); recursive_render(gc, scene_teapot, scene_teapot->mRootNode, false); gc.pop_modelview(); gc.push_modelview(); gc.mult_scale(0.5f, 0.5f, 0.5f); gc.mult_translate(0.0f, -0.5f, 0.0f); recursive_render(gc, scene_clanlib, scene_clanlib->mRootNode, false); gc.pop_modelview(); #ifdef USE_OPENGL_2 shader.Set(gc, 0); shader.Use(gc); #else gc.set_program_object(cl_program_single_texture); #endif gc.set_texture(0, tux); gc.set_modelview(CL_Mat4f::identity()); gc.mult_scale(1.0f,1.0f, -1.0f); // So +'ve Z goes into the screen gc.mult_translate(0.7f, 0.5f, 2.0f); gc.mult_scale(0.05f, 0.05f, 0.05f); gc.mult_rotate(CL_Angle(angle * 4.0f, cl_degrees), 0.0f, 1.0f, 0.0f, false); recursive_render(gc, scene_tuxball, scene_tuxball->mRootNode, true); gc.reset_texture(0); gc.reset_program_object(); // Flip the display, showing on the screen what we have drawed // since last call to flip() window.flip(1); // This call processes user input and other events CL_KeepAlive::process(); } aiReleaseImport(scene_tuxball); aiReleaseImport(scene_clanlib); aiReleaseImport(scene_teapot); aiDetachAllLogStreams(); return 0; }
// The start of the Application int App::start(const std::vector<CL_String> &args) { // Setup the window CL_DisplayWindowDescription win_desc; win_desc.set_allow_resize(true); win_desc.set_title("Input Example"); win_desc.set_size(CL_Size( 700, 700 ), false); window = CL_DisplayWindow(win_desc); // Connect the slots that we require CL_Slot slot_quit = window.sig_window_close().connect(this, &App::on_window_close); CL_Slot slot_input_down = (window.get_ic().get_keyboard()).sig_key_down().connect(this, &App::on_input_down); CL_Slot slot_mouse_down = (window.get_ic().get_mouse()).sig_key_down().connect(this, &App::on_mouse_down); CL_Slot slot_mouse_dblclick = (window.get_ic().get_mouse()).sig_key_dblclk().connect(this, &App::on_mouse_down); std::vector<CL_Slot> slot_joystick; int max_joysticks = window.get_ic().get_joystick_count(); for (int joystick_number=0; joystick_number < max_joysticks; joystick_number++) { CL_Slot current_joystick = window.get_ic().get_joystick(joystick_number).sig_key_down().connect(this, &App::on_joystick_down, joystick_number); slot_joystick.push_back(current_joystick); } CL_GraphicContext gc = window.get_gc(); font = CL_Font(gc, "tahoma", 16); vector_font = CL_Font_Vector("../../Game/DiceWar/Resources/bitstream_vera_sans/VeraBd.ttf", 256); calculate_matrix(gc); while(!quit) { gc.set_map_mode(cl_map_2d_upper_left); CL_Draw::gradient_fill(gc, CL_Rect(0, 0, gc.get_width(), gc.get_height()/2), CL_Gradient(CL_Colorf(0.2f, 0.2f, 0.8f, 1.0f), CL_Colorf(0.0f, 0.0f, 0.2f, 1.0f))); CL_Draw::gradient_fill(gc, CL_Rect(0, gc.get_height()/2, gc.get_width(), gc.get_height()), CL_Gradient(CL_Colorf(0.0f, 0.0f, 0.2f, 1.0f), CL_Colorf(0.2f, 0.2f, 0.8f, 1.0f))); font.draw_text(gc, 8, 20, "Press any key, mouse button or joystick button to fire text. Use mouse to control direction."); int yoffset = gc.get_height() - 20; const int y_gap = 20; // Draw Keyboard Information draw_keyboard_state(gc, yoffset); yoffset -= y_gap; // Draw Mouse Information draw_mouse_state(gc, yoffset); yoffset -= y_gap; // Draw Joysticks Information for (int joystick_number=0; joystick_number < max_joysticks; joystick_number++) { draw_joystick_state(gc, joystick_number, yoffset); yoffset -= y_gap; } // Draw Tablet Information int max_tablets = window.get_ic().get_tablet_count(); for (int tablet_number=0; tablet_number < max_tablets; tablet_number++) { draw_tablet_state(gc, tablet_number, yoffset); yoffset -= y_gap; } gc.set_map_mode(cl_user_projection); gc.set_projection(projection_matrix); gc.set_modelview(modelview_matrix); draw_text_shooter(gc); window.flip(1); CL_KeepAlive::process(); } return 0; }
// The start of the Application int App::start(const std::vector<CL_String> &args) { CL_DisplayWindowDescription win_desc; win_desc.set_allow_resize(true); win_desc.set_title("Vertex Buffer Object Example"); win_desc.set_depth_size(16); win_desc.set_size(CL_Size( 800, 600 ), false); CL_DisplayWindow window(win_desc); CL_Slot slot_quit = window.sig_window_close().connect(this, &App::on_window_close); CL_Slot slot_input_up = (window.get_ic().get_keyboard()).sig_key_up().connect(this, &App::on_input_up); CL_GraphicContext gc = window.get_gc(); Shader shader(gc); // Prepare the display gc.set_map_mode(cl_user_projection); CL_PolygonRasterizer polygon_rasterizer; polygon_rasterizer.set_culled(true); polygon_rasterizer.set_face_cull_mode(cl_cull_back); polygon_rasterizer.set_front_face(cl_face_side_clockwise); gc.set_polygon_rasterizer(polygon_rasterizer); CL_BufferControl buffer_control; buffer_control.enable_depth_test(true); buffer_control.set_depth_compare_function(cl_comparefunc_lequal); buffer_control.enable_depth_write(true); gc.set_buffer_control(buffer_control); std::vector<CL_Vec3f> object_positions; std::vector<CL_Vec3f> object_normals; std::vector<CL_Vec4f> object_material_ambient; const int num_cubes = 20000; object_positions.reserve(num_cubes * 6 * 6); // 6 faces, and 6 vertices per face object_normals.reserve(num_cubes * 6 * 6); object_material_ambient.reserve(num_cubes * 6 * 6); for (int cnt=0; cnt < num_cubes; cnt++) { create_cube(object_positions, object_normals, object_material_ambient); } CL_VertexArrayBuffer vb_positions(gc, &object_positions[0], sizeof(CL_Vec3f) * object_positions.size()); CL_VertexArrayBuffer vb_normals(gc, &object_normals[0], sizeof(CL_Vec3f) * object_normals.size()); CL_VertexArrayBuffer vb_material_ambient(gc, &object_material_ambient[0], sizeof(CL_Vec4f) * object_material_ambient.size()); // ** Note, at this point "object_positions, object_normals and object_material_ambient" // ** can be destroyed. But for the purpose of this example, is it kept CL_Font fps_font(gc, "tahoma", 20); FramerateCounter frameratecounter; unsigned int time_last = CL_System::get_time(); float angle = 0.0f; is_vertex_buffer_on = true; while (!quit) { unsigned int time_now = CL_System::get_time(); float time_diff = (float) (time_now - time_last); time_last = time_now; gc.clear(CL_Colorf(0.0f, 0.0f, 0.0f, 1.0f)); gc.clear_depth(1.0f); gc.set_map_mode(cl_map_2d_upper_left); CL_String fps = cl_format("%1 fps", frameratecounter.get_framerate()); fps_font.draw_text(gc, gc.get_width() - 100, 30, fps); CL_String info = cl_format("%1 vertices", (int) object_positions.size()); fps_font.draw_text(gc, 30, 30, info); fps_font.draw_text(gc, 30, gc.get_height() - 8, "Press any key to toggle the Vertex Buffer option"); if (is_vertex_buffer_on) { fps_font.draw_text(gc, 200, 30, "Vertex Buffer = ON"); } else { fps_font.draw_text(gc, 200, 30, "Vertex Buffer = OFF"); } gc.set_map_mode(cl_user_projection); CL_Mat4f perp = CL_Mat4f::perspective(45.0f, ((float) gc.get_width()) / ((float) gc.get_height()), 0.1f, 100000.0f); gc.set_projection(perp); angle += time_diff / 20.0f; if (angle >= 360.0f) angle -= 360.0f; gc.push_modelview(); gc.set_modelview(CL_Mat4f::identity()); gc.mult_scale(1.0f,1.0f, -1.0f); // So +'ve Z goes into the screen gc.mult_translate(0.0f, 0.0f, 800.0f); gc.mult_rotate(CL_Angle(angle*2.0f, cl_degrees), 0.0f, 1.0f, 0.0f, false); gc.mult_rotate(CL_Angle(angle, cl_degrees), 1.0f, 0.0f, 0.0f, false); shader.Set(gc); shader.Use(gc); CL_PrimitivesArray prim_array(gc); if (is_vertex_buffer_on) { prim_array.set_attributes(0, vb_positions, 3, cl_type_float, (void *) 0); prim_array.set_attributes(1, vb_normals, 3, cl_type_float, (void *) 0); prim_array.set_attributes(2, vb_material_ambient, 4, cl_type_float, (void *) 0); } else { prim_array.set_attributes(0, &object_positions[0]); prim_array.set_attributes(1, &object_normals[0]); prim_array.set_attributes(2, &object_material_ambient[0]); } gc.draw_primitives(cl_triangles, object_positions.size(), prim_array); gc.pop_modelview(); gc.reset_program_object(); window.flip(0); frameratecounter.frame_shown(); CL_KeepAlive::process(); } return 0; }
// The start of the Application int App::start(const std::vector<CL_String> &args) { // Setup the window CL_DisplayWindowDescription win_desc; win_desc.set_allow_resize(true); win_desc.set_title("3D GUI Example"); win_desc.set_size(CL_Size( 700, 700 ), false); window = CL_DisplayWindow(win_desc); // Connect the slots that we require CL_Slot slot_quit = window.sig_window_close().connect(this, &App::on_window_close); CL_Slot slot_input_down = (window.get_ic().get_keyboard()).sig_key_down().connect(this, &App::on_input_down); CL_GraphicContext gc = window.get_gc(); CL_Font font = CL_Font(gc, "tahoma", 16); // Initialise the GUI system GUI gui(this); // NOTE: The GUI component positions are still in 2D world, therefore // be careful not to overlap windows, else unpredicted results may occur! window1 = new Window1(gui, CL_Rect(0,0, CL_Size(256, 256))); slider_1_xrotation = new Slider(gui, CL_Rect(0, 512, CL_Size(200, 17))); slider_1_xrotation->object_matrix.translate_self(0.0f, 0.8f, 3.0f); slider_1_xrotation->object_matrix.multiply(CL_Mat4f::rotate(CL_Angle(10, cl_degrees), 0.0f, 0.0f, 1.0f)); slider_1_yrotation = new Slider(gui, CL_Rect(256*1, 512, CL_Size(200, 17))); slider_1_yrotation->object_matrix.translate_self(0.0f, 0.7f, 3.0f); slider_1_yrotation->object_matrix.multiply(CL_Mat4f::rotate(CL_Angle(10, cl_degrees), 0.0f, 0.0f, 1.0f)); slider_1_zrotation = new Slider(gui, CL_Rect(256*2, 512, CL_Size(200, 17))); slider_1_zrotation->object_matrix.translate_self(0.0f, 0.6f, 3.0f); slider_1_zrotation->object_matrix.multiply(CL_Mat4f::rotate(CL_Angle(10, cl_degrees), 0.0f, 0.0f, 1.0f)); slider_1_xtranslation = new Slider(gui, CL_Rect(256*3, 512, CL_Size(200, 17))); slider_1_xtranslation->object_matrix.translate_self(0.0f, 0.5f, 3.0f); slider_1_xtranslation->object_matrix.multiply(CL_Mat4f::rotate(CL_Angle(10, cl_degrees), 0.0f, 0.0f, 1.0f)); slider_1_xtranslation->component->set_position(500); slider_1_ytranslation = new Slider(gui, CL_Rect(256*4, 512, CL_Size(200, 17))); slider_1_ytranslation->object_matrix.translate_self(0.0f, 0.4f, 3.0f); slider_1_ytranslation->object_matrix.multiply(CL_Mat4f::rotate(CL_Angle(10, cl_degrees), 0.0f, 0.0f, 1.0f)); slider_1_ytranslation->component->set_position(500); slider_1_ztranslation = new Slider(gui, CL_Rect(256*5, 512, CL_Size(200, 17))); slider_1_ztranslation->object_matrix.translate_self(0.0f, 0.3f, 3.0f); slider_1_ztranslation->object_matrix.multiply(CL_Mat4f::rotate(CL_Angle(10, cl_degrees), 0.0f, 0.0f, 1.0f)); slider_1_ztranslation->component->set_position(500); while(!quit) { calculate_matrix(); gc.set_modelview(CL_Mat4f::identity()); gc.set_map_mode(CL_MapMode(cl_map_2d_upper_left)); // Draw the gradient CL_Draw::gradient_fill(gc, CL_Rect(0, 0, gc.get_width(), gc.get_height()/2), CL_Gradient(CL_Colorf(0.2f, 0.2f, 0.8f, 1.0f), CL_Colorf(0.0f, 0.0f, 0.2f, 1.0f))); CL_Draw::gradient_fill(gc, CL_Rect(0, gc.get_height()/2, gc.get_width(), gc.get_height()), CL_Gradient(CL_Colorf(0.0f, 0.0f, 0.2f, 1.0f), CL_Colorf(0.2f, 0.2f, 0.8f, 1.0f))); font.draw_text(gc, 8, 20, "GUI3D"); int xoffset = 160; int yoffset = 70; const int ygap = 35; font.draw_text(gc, xoffset, yoffset, "X Rotation"); yoffset += ygap; font.draw_text(gc, xoffset, yoffset, "Y Rotation"); yoffset += ygap; font.draw_text(gc, xoffset, yoffset, "Z Rotation"); yoffset += ygap; font.draw_text(gc, xoffset, yoffset, "X Translation"); yoffset += ygap; font.draw_text(gc, xoffset, yoffset, "Y Translation"); yoffset += ygap; font.draw_text(gc, xoffset, yoffset, "Z Translation"); yoffset += ygap; if (!gui.run()) break; gc.set_map_mode(cl_user_projection); gc.set_projection(projection_matrix); gc.set_modelview(modelview_matrix); control_window(); gui.draw(); window.flip(1); CL_KeepAlive::process(); } return 0; }
// The start of the Application int App::start(const std::vector<CL_String> &args) { quit = false; CL_OpenGLWindowDescription desc; desc.set_title("ClanLib Shadow Example"); desc.set_size(CL_Size(640, 640), true); desc.set_multisampling(4); desc.set_depth_size(16); CL_DisplayWindow window(desc); #ifdef _DEBUG //struct aiLogStream stream; //stream = aiGetPredefinedLogStream(aiDefaultLogStream_STDOUT,NULL); //aiAttachLogStream(&stream); //stream = aiGetPredefinedLogStream(aiDefaultLogStream_FILE,"assimp_log.txt"); //aiAttachLogStream(&stream); #endif aiSetImportPropertyFloat(AI_CONFIG_PP_GSN_MAX_SMOOTHING_ANGLE,89.53f); // Connect the Window close event CL_Slot slot_quit = window.sig_window_close().connect(this, &App::on_window_close); // Connect a keyboard handler to on_key_up() CL_Slot slot_input_up = (window.get_ic().get_keyboard()).sig_key_up().connect(this, &App::on_input_up); // Get the graphic context CL_GraphicContext gc = window.get_gc(); GraphicStore graphic_store(gc); scene.gs = &graphic_store; // Prepare the display gc.set_map_mode(cl_user_projection); CL_PolygonRasterizer polygon_rasterizer; polygon_rasterizer.set_culled(true); polygon_rasterizer.set_face_cull_mode(cl_cull_back); polygon_rasterizer.set_front_face(cl_face_side_clockwise); gc.set_polygon_rasterizer(polygon_rasterizer); create_scene(gc); CL_FrameBuffer framebuffer(gc); CL_Texture new_depth_texture(gc, CL_Size(1024, 1024), cl_depth_component); new_depth_texture.set_wrap_mode(cl_wrap_clamp_to_edge, cl_wrap_clamp_to_edge, cl_wrap_clamp_to_edge); framebuffer.attach_depth_buffer(new_depth_texture); scene.gs->texture_shadow = new_depth_texture; camera_angle = 0.0f; CL_Font font(gc, "tahoma", 24); FramerateCounter framerate_counter; unsigned int time_last = CL_System::get_time(); // Run until someone presses escape while (!quit) { framerate_counter.frame_shown(); unsigned int time_now = CL_System::get_time(); time_delta = time_now - time_last; time_last = time_now; rotate_teapot(); control_camera(); update_light(gc); calculate_matricies(gc); render_from_lightsource(gc, framebuffer); render_from_camera(gc, framebuffer); gc.set_modelview(CL_Mat4f::identity()); gc.set_map_mode(cl_map_2d_upper_left); CL_String fps(cl_format("%1 fps", framerate_counter.get_framerate())); font.draw_text(gc, 16-2, gc.get_height()-16-2, fps, CL_Colorf(0.0f, 0.0f, 0.0f, 1.0f)); font.draw_text(gc, 16, gc.get_height()-16-2, fps, CL_Colorf(1.0f, 1.0f, 1.0f, 1.0f)); // Use flip(1) to lock the fps window.flip(0); // This call processes user input and other events CL_KeepAlive::process(); } aiDetachAllLogStreams(); return 0; }
// The start of the Application int App::start(const std::vector<CL_String> &args) { quit = false; CL_OpenGLWindowDescription desc; desc.set_title("ClanLib Light Surface Example"); desc.set_size(CL_Size(900, 700), true); desc.set_multisampling(4); desc.set_allow_resize(true); desc.set_depth_size(16); CL_DisplayWindow window(desc); // Connect the Window close event CL_Slot slot_quit = window.sig_window_close().connect(this, &App::on_window_close); // Connect a keyboard handler to on_key_up() CL_Slot slot_input_up = (window.get_ic().get_keyboard()).sig_key_up().connect(this, &App::on_input_up); // Set up GUI CL_String theme; if (CL_FileHelp::file_exists("../../../Resources/GUIThemeAero/theme.css")) theme = "../../../Resources/GUIThemeAero"; else if (CL_FileHelp::file_exists("../../../Resources/GUIThemeBasic/theme.css")) theme = "../../../Resources/GUIThemeBasic"; else throw CL_Exception("No themes found"); CL_GUIWindowManagerTexture wm(window); CL_GUIManager gui(wm, theme); // Get the graphic context CL_GraphicContext gc = window.get_gc(); // Deleted automatically by the GUI Options *options = new Options(gui, CL_Rect(8, 8, CL_Size(340, 600))); options->request_repaint(); // Setup graphic store GraphicStore graphic_store(gc); scene.gs = &graphic_store; // Prepare the display gc.set_map_mode(cl_user_projection); CL_PolygonRasterizer polygon_rasterizer; polygon_rasterizer.set_culled(true); polygon_rasterizer.set_face_cull_mode(cl_cull_back); polygon_rasterizer.set_front_face(cl_face_side_clockwise); gc.set_polygon_rasterizer(polygon_rasterizer); create_scene(gc); CL_Font font(gc, "tahoma", 24); graphic_store.image_grid = CL_Image(gc, "../../Display_Render/Blend/Resources/grid.png"); FramerateCounter framerate_counter; unsigned int time_last = CL_System::get_time(); // Run until someone presses escape while (!quit) { framerate_counter.frame_shown(); unsigned int time_now = CL_System::get_time(); time_delta = time_now - time_last; time_last = time_now; // Copy direction options light_distant->rotation_y = options->light_direction_heading; light_distant->rotation_x = options->light_direction_pitch; // Set material options float shininess = options->material_shininess; // Convert shininess from a percentage, using Lightwave 3d's method shininess = shininess / 100.0f; shininess = pow(2, (10.0f * shininess) + 2); teapot->model.SetMaterial( shininess, // material_shininess CL_Vec4f(options->material_emission_color.r, options->material_emission_color.g, options->material_emission_color.b, options->material_emission_color.a), // material_emission CL_Vec4f(options->material_ambient_color.r, options->material_ambient_color.g, options->material_ambient_color.b, options->material_ambient_color.a), // material_ambient CL_Vec4f(options->material_specular_color.r, options->material_specular_color.g, options->material_specular_color.b, options->material_specular_color.a) //material_specular ); rotate_teapot(); calculate_matricies(gc); update_light(gc, options); polygon_rasterizer.set_culled(true); gc.set_polygon_rasterizer(polygon_rasterizer); render(gc); gc.set_modelview(CL_Mat4f::identity()); gc.set_map_mode(cl_map_2d_upper_left); polygon_rasterizer.set_culled(false); gc.set_polygon_rasterizer(polygon_rasterizer); CL_String fps(cl_format("%1 fps", framerate_counter.get_framerate())); font.draw_text(gc, 16-2, gc.get_height()-16-2, fps, CL_Colorf(0.0f, 0.0f, 0.0f, 1.0f)); font.draw_text(gc, 16, gc.get_height()-16-2, fps, CL_Colorf(1.0f, 1.0f, 1.0f, 1.0f)); wm.process(); wm.draw_windows(gc); // Use flip(1) to lock the fps window.flip(0); // This call processes user input and other events CL_KeepAlive::process(); } return 0; }
int Application::main(const std::vector<CL_String> &args) { try { #ifdef DEBUG // Crea una ventan en consola para la salida de texto si no está disponible CL_ConsoleWindow console("JATG", 80, 1000); // 1000 permite una barra vertical CL_ConsoleLogger logger; #endif // Crea la ventana CL_DisplayWindowDescription desc; desc.set_title("JATG"); desc.set_size(CL_Size(1024,768), true); // Usa esta resolución desc.set_fullscreen(true); desc.set_decorations(false); CL_DisplayWindow window(desc); CL_GraphicContext gc = window.get_gc(); CL_Mat4f matrix = CL_Mat4f::scale( (float) gc.get_width() / 1024.0f, (float) gc.get_height() / 768.0f, 1.0f); gc.set_modelview(matrix); CL_SoundOutput output(44100); //Inicializa Frecuencia // Crea el mundo Mundo mundo(window); // Corre el bucle del juego mundo.gameloop(); } catch (CL_Exception& exception) { CL_Console::write_line("Excepcion Tomada:"); CL_Console::write_line(exception.message); std::vector<CL_String> stacktrace = exception.get_stack_trace(); int tamaño = stacktrace.size(); if (tamaño > 0) { CL_Console::write_line("Stack Trace:"); for (int i=0; i < tamaño; i++) { CL_Console::write_line(stacktrace[i]); } } CL_Console::wait_for_key(); //Espera por una tecla } return 0; }