void ShaderImpl::begin(CL_GraphicContext &p_gc) { G_ASSERT(m_initialized); G_ASSERT(!m_began); // new texture m_drawRect = m_parent->getDrawRect(m_boundRect); m_texture = CL_Texture(p_gc, m_drawRect.get_width(), m_drawRect.get_height()); // attach frame buffer m_frameBuffer.attach_color_buffer(0, m_texture); p_gc.set_frame_buffer(m_frameBuffer); // clear to transparent p_gc.clear(CL_Colorf::transparent); // set proper matrix p_gc.push_modelview(); // get scaling in count const CL_Mat4f &matrix = p_gc.get_modelview(); const float scaleX = matrix[0]; const float scaleY = matrix[5]; p_gc.mult_translate(-m_drawRect.left / scaleX, -m_drawRect.top / scaleY); m_began = true; }
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(); }
static int main(const std::vector<CL_String> &args) { try { CL_SetupCore setup_core; CL_SetupDisplay setup_disp; CL_SetupGL setup_gl; CL_DisplayWindow window("Viewport Grid Test", 640, 480, false, true); CL_GraphicContext gc = window.get_gc(); CL_BlendMode blend_mode1; blend_mode1.enable_blending(true); gc.set_blend_mode(blend_mode1); gc.set_map_mode(cl_map_2d_upper_left); while(!window.get_ic().get_keyboard().get_keycode(CL_KEY_ESCAPE)) { gc.clear(CL_Colorf::white); CL_Rect viewport = window.get_viewport(); for (int y = viewport.top; y < viewport.bottom; y+=2) { CL_Draw::line(gc, viewport.left, y, viewport.right, y, CL_Colorf::black); } for (int x = viewport.left; x < viewport.right; x+=2) { CL_Draw::line(gc, x, viewport.top, x, viewport.bottom, CL_Colorf::black); } window.flip(1); CL_KeepAlive::process(); CL_System::sleep(10); } return 0; } catch(CL_Exception error) { CL_ConsoleWindow console("Console"); CL_Console::write_line("Exception caught:"); CL_Console::write_line(error.message); console.display_close_message(); return -1; } 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("ColorWheel Example"); 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_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 new ColorWheel(gc, gui, CL_Rect(32, 32, CL_Size(512, 512))); 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; gc.clear(CL_Colorf(0.0f,0.0f,0.0f)); wm.process(); wm.draw_windows(gc); window.flip(1); CL_KeepAlive::process(); } return 0; }
void WorkerGC::worker_thread_loop() { CL_DisplayWindowDescription desc; desc.set_title("ClanLib Worker Thread"); desc.set_size(CL_Size(320, 320), true); //desc.set_visible(false); window = CL_DisplayWindow(desc); while (true) { int wakeup_reason = CL_Event::wait(event_start, event_stop); if (wakeup_reason != 0) break; event_start.reset(); try { CL_GraphicContext gc = window.get_gc(); // Test code unsigned int time_ms = CL_System::get_time(); while((CL_System::get_time() - time_ms) < 2000) { gc.clear(CL_Colorf(1.0f,0.0f,0.2f)); CL_KeepAlive::process(); window.flip(0); } window.set_visible(false, false); retrieved_sprite = CL_Sprite(gc, sprite_name); CL_OpenGL::set_active(gc); glFlush(); } catch (CL_Exception &error) { exception_set = true; exception = error; } event_completed.set(); } window = CL_DisplayWindow(); }
int App::start(const std::vector<CL_String> &args) { CL_OpenGLWindowDescription description; description.set_title("NightVision Shader"); description.set_size(CL_Size(1024, 768), true); CL_DisplayWindow window(description); CL_InputDevice keyboard = window.get_ic().get_keyboard(); CL_GraphicContext gc = window.get_gc(); CL_Slot slot_input_up = (window.get_ic().get_keyboard()).sig_key_up().connect(this, &App::on_input_up); CL_Slot slot_window_close = window.sig_window_close().connect(this, &App::window_close); // Create offscreen texture CL_Texture texture_offscreen(gc, gc.get_width(), gc.get_height()); texture_offscreen.set_min_filter(cl_filter_nearest); texture_offscreen.set_mag_filter(cl_filter_nearest); CL_Texture texture_mask(gc, gc.get_width(), gc.get_height()); texture_mask.set_min_filter(cl_filter_nearest); texture_mask.set_mag_filter(cl_filter_nearest); // Create offscreen framebuffer CL_FrameBuffer framebuffer_offscreen(gc); framebuffer_offscreen.attach_color_buffer(0, texture_offscreen); CL_FrameBuffer framebuffer_mask(gc); framebuffer_mask.attach_color_buffer(0, texture_mask); CL_Image background(gc, "../PostProcessing/Resources/background.png"); CL_Image ball(gc, "../PostProcessing/Resources/ball.png"); ball.set_alignment(origin_center); CL_Texture noise_texture(gc, "Resources/noise_texture_0001.png"); noise_texture.set_wrap_mode(cl_wrap_repeat, cl_wrap_repeat); // Load and link shaders CL_ProgramObject shader = CL_ProgramObject::load(gc, "Resources/vertex_shader.glsl", "Resources/fragment_shader.glsl"); shader.bind_attribute_location(0, "Position"); shader.bind_attribute_location(2, "TexCoord0"); if (!shader.link()) throw CL_Exception("Unable to link shader program: Error:" + shader.get_info_log()); quit = false; float amount = 0.0f; float timer = 0.0f; float scale = 1.0f; CL_Font font(gc, "tahoma", 32); // Shader based on: http://www.geeks3d.com/20091009/shader-library-night-vision-post-processing-filter-glsl/ elapsedTime = 0.0f; // seconds luminanceThreshold = 0.2f; colorAmplification = 4.0f; effectCoverage = 0.65f; // Render the mask gc.set_frame_buffer(framebuffer_mask); gc.clear(); for (float offset=0.0f; offset<=1.0f; offset+=0.01f) { CL_Draw::circle(gc, gc.get_width() / 2.0f, gc.get_height() / 2.0f, 400.0f - offset * 64.0f, CL_Colorf(offset, offset, offset, 1.0f)); } gc.reset_frame_buffer(); unsigned int startTime = CL_System::get_time(); while (!quit) { timer = (CL_System::get_time() - startTime) / 1000.0f; elapsedTime = timer; // Render standard image to offscreen buffer gc.set_frame_buffer(framebuffer_offscreen); background.draw(gc, 0, 0); ball.draw(gc, gc.get_width() / 2 + 200 * sinf(timer / 2.0f), gc.get_height() / 2 + 200 * cosf(timer / 2.0f)); gc.reset_frame_buffer(); render_night_vision(gc, texture_offscreen, texture_mask, noise_texture, shader); const int gap = 32; font.draw_text(gc, 10, 64+gap*0, CL_String("luminanceThreshold : " + CL_StringHelp::float_to_text(luminanceThreshold) + " (Press Q,W)" )); font.draw_text(gc, 10, 64+gap*1, CL_String("colorAmplification : " + CL_StringHelp::float_to_text(colorAmplification) + " (Press A,S)" )); font.draw_text(gc, 10, 64+gap*2, CL_String("effectCoverage : " + CL_StringHelp::float_to_text(effectCoverage) + " (Press Z,X)" )); window.flip(); CL_System::sleep(10); CL_KeepAlive::process(); } return 0; }
// The start of the Application int App::start(const std::vector<CL_String> &args) { quit = false; running_test = 0; // Create a console window for text-output if not available CL_ConsoleWindow console("Console", 80, 200); CL_Console::write_line("Press 1-5 for different tests! (Test 3 and 5 not applicable for ClanLib 0.8)"); try { // This opens a window, including the frame size // If you want more control over the window, pass CL_DisplayWindowDescription to CL_DisplayWindow // (This is useful to create a borderless window of a specific size) // If you require target specific control over the window, use the derived CL_OpenGLWindowDescription // (This contains the multisampling options) CL_DisplayWindow window("ClanLib SpriteSpeed Test", 1000, 1000); // 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(); CL_ResourceManager resources("resources.xml"); explosion1 = CL_Sprite(gc, "Explosion1", &resources); explosion2 = CL_Sprite(gc, "Explosion2", &resources); explosions_same_tex.reserve(10000); for(int i=0; i<10000; i++) { explosions_same_tex.push_back(CL_Sprite(explosion1)); if(i % 2 == 0) explosions_diff_tex.push_back(CL_Sprite(explosion1)); else explosions_diff_tex.push_back(CL_Sprite(explosion2)); } // Run until someone presses escape while (!quit) { float delta_time = dump_fps() / 1000.0f; gc.clear(CL_Colorf(0.0f,0.0f,0.2f)); if(running_test == 0) CL_System::sleep(100); if(running_test == 1) draw_equal_tex_equal_sprites(gc, 10000, delta_time); if(running_test == 2) draw_equal_tex_diff_sprites(gc, 10000, delta_time); if(running_test == 3) draw_equal_tex_diff_sprites_batch(gc, 10000, delta_time); if(running_test == 4) draw_diff_tex_diff_sprites(gc, 10000, delta_time); if(running_test == 5) draw_diff_tex_diff_sprites_batch(gc, 10000, delta_time); // Flip the display, showing on the screen what we have drawed since last call to flip() window.flip(); // This call processes user input and other events CL_KeepAlive::process(); } explosions_same_tex.clear(); explosions_diff_tex.clear(); explosion1 = CL_Sprite(); explosion2 = CL_Sprite(); } catch(CL_Exception& exception) { CL_Console::write_line("Exception caught:"); CL_Console::write_line(exception.message); // Display the stack trace (if available) std::vector<CL_String> stacktrace = exception.get_stack_trace(); int size = stacktrace.size(); if (size > 0) { CL_Console::write_line("Stack Trace:"); for (int cnt=0; cnt < size; cnt++) { CL_Console::write_line(stacktrace[cnt]); } } console.display_close_message(); return -1; } return 0; }
// The start of the Application int App::start(const std::vector<CL_String> &args) { quit = false; // Set the window CL_DisplayWindowDescription desc; desc.set_title("ClanLib App Example"); desc.set_size(CL_Size(1200, 500), true); desc.set_allow_resize(true); 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(); // Load a sprite from a png-file tux = CL_PixelBuffer("Resources/tux.png"); tux_original = CL_Image(gc, tux, tux.get_size()); current_format = cl_rgba8; //current_format = cl_rgba8; //current_format = cl_rgb8; //current_format = cl_bgra8; //current_format = cl_bgr8; //current_format = cl_r8; //current_format = cl_r8_snorm; //current_format = cl_r16; //current_format = cl_r16_snorm; //current_format = cl_rg8; //current_format = cl_rg8_snorm; //current_format = cl_rg16; //current_format = cl_rg16_snorm; //current_format = cl_r3_g3_b2; //current_format = cl_rgb4; //current_format = cl_rgb5; //current_format = cl_rgb8_snorm; //current_format = cl_rgb10; //current_format = cl_rgb12; // XX //current_format = cl_rgb16; //current_format = cl_rgb16_snorm; //current_format = cl_rgba2; // XX //current_format = cl_rgba4; //current_format = cl_rgb5_a1; //current_format = cl_rgba8_snorm; //current_format = cl_rgb10_a2; //current_format = cl_rgba12; // X //current_format = cl_rgba16; //current_format = cl_rgba16_snorm; //current_format = cl_srgb8; //current_format = cl_srgb8_alpha8; //current_format = cl_r16f; //current_format = cl_rg16f; //current_format = cl_rgb16f; //current_format = cl_rgba16f; //current_format = cl_r32f; current_format = cl_rg32f; //current_format = cl_rgb32f; //current_format = cl_rgba32f; //current_format = cl_r11f_g11f_b10f; // X //current_format = cl_rgb9_e5; // X //current_format = cl_r8i; //current_format = cl_r8ui; //current_format = cl_r16i; //current_format = cl_r16ui; //current_format = cl_r32i; //current_format = cl_r32ui; //current_format = cl_rg8i; //current_format = cl_rg8ui; //current_format = cl_rg16i; //current_format = cl_rg16ui; //current_format = cl_rg32i; //current_format = cl_rg32ui; //current_format = cl_rgb8i; //current_format = cl_rgb8ui; //current_format = cl_rgb16i; //current_format = cl_rgb16ui; //current_format = cl_rgb32i; //current_format = cl_rgb32ui; //current_format = cl_rgba8i; //current_format = cl_rgba8ui; //current_format = cl_rgba16i; //current_format = cl_rgba16ui; //current_format = cl_rgba32i; //current_format = cl_rgba32ui; //current_format = cl_depth_component16; //current_format = cl_depth_component24; //current_format = cl_depth_component32; //current_format = cl_depth_component32f; //current_format = cl_depth24_stencil8; //current_format = cl_depth32f_stencil8; //current_format = cl_compressed_red; //current_format = cl_compressed_rg; //current_format = cl_compressed_rgb; //current_format = cl_compressed_rgba; //current_format = cl_compressed_srgb; //current_format = cl_compressed_srgb_alpha; //current_format = cl_compressed_red_rgtc1; //current_format = cl_compressed_signed_red_rgtc1; //current_format = cl_compressed_rg_rgtc2; //current_format = cl_compressed_signed_rg_rgtc2; //current_format = cl_compressed_rgb_s3tc_dxt1; //current_format = cl_compressed_rgba_s3tc_dxt1; //current_format = cl_compressed_rgba_s3tc_dxt3; //current_format = cl_compressed_rgba_s3tc_dxt5; //current_format = cl_compressed_srgb_s3tc_dxt1; //current_format = cl_compressed_srgb_alpha_s3tc_dxt1; //current_format = cl_compressed_srgb_alpha_s3tc_dxt3; //current_format = cl_compressed_srgb_alpha_s3tc_dxt5; display_gc = &gc; update_images(); CL_Font font(gc, "tahoma", 24); // Run until someone presses escape while (!quit) { gc.clear(CL_Colorf(0.0f,0.0f,0.2f)); tux_original.draw(gc, 0, 0); tux_convert.draw(gc, 400, 0); tux_unconvert.draw(gc, 800, 0); font.draw_text(gc, 10, 400, "cl_rgba8"); if (gl_supported) { font.draw_text(gc, 410, 400, "converted"); } else { font.draw_text(gc, 410, 400, "NOT SUPPORTED BY clanGL"); } font.draw_text(gc, 810, 400, "converted back to cl_rgba8"); window.flip(1); // This call processes user input and other events CL_KeepAlive::process(0); } return 0; }
void ContainerRenderer::render(CL_GraphicContext& gc) { renderQueue_->preRender(); gc.clear(CL_Colorf(0.f, 0.f, 0.f, 0.f)); boost::shared_ptr<CL_ProgramObject> shader = ui::Manager::getShaderManager()->getGumpShader(); gc.set_program_object(*shader, cl_program_matrix_modelview_projection); CL_Texture huesTexture = data::Manager::getHuesLoader()->getHuesTexture(); gc.set_texture(0, huesTexture); // set texture unit 1 active to avoid overriding the hue texture with newly loaded object textures gc.set_texture(1, huesTexture); shader->set_uniform1i("HueTexture", 0); shader->set_uniform1i("ObjectTexture", 1); RenderQueue::const_iterator igIter = renderQueue_->begin(); RenderQueue::const_iterator igEnd = renderQueue_->end(); CL_Vec2f vertexCoords[6]; bool renderingComplete = true; // draw background container texture boost::shared_ptr<ui::Texture> bgTex = containerView_->getBackgroundTexture(); if (bgTex && bgTex->isReadComplete()) { CL_Vec3f hueInfo(0, 0, 1); CL_Rectf rect(0, 0, CL_Sizef(bgTex->getWidth(), bgTex->getHeight())); vertexCoords[0] = CL_Vec2f(rect.left, rect.top); vertexCoords[1] = CL_Vec2f(rect.right, rect.top); vertexCoords[2] = CL_Vec2f(rect.left, rect.bottom); vertexCoords[3] = CL_Vec2f(rect.right, rect.top); vertexCoords[4] = CL_Vec2f(rect.left, rect.bottom); vertexCoords[5] = CL_Vec2f(rect.right, rect.bottom); CL_Rectf texCoordHelper = bgTex->getNormalizedTextureCoords(); CL_Vec2f texCoords[6] = { CL_Vec2f(texCoordHelper.left, texCoordHelper.top), CL_Vec2f(texCoordHelper.right, texCoordHelper.top), CL_Vec2f(texCoordHelper.left, texCoordHelper.bottom), CL_Vec2f(texCoordHelper.right, texCoordHelper.top), CL_Vec2f(texCoordHelper.left, texCoordHelper.bottom), CL_Vec2f(texCoordHelper.right, texCoordHelper.bottom) }; CL_PrimitivesArray primarray(gc); primarray.set_attributes(0, vertexCoords); primarray.set_attributes(1, texCoords); primarray.set_attribute(2, hueInfo); gc.set_texture(1, bgTex->getTexture()); gc.draw_primitives(cl_triangles, 6, primarray); } else { renderingComplete = false; } for (; igIter != igEnd; ++igIter) { boost::shared_ptr<world::IngameObject> curObj = *igIter; // just items in a container if (!curObj->isDynamicItem()) { continue; } // check if texture is ready to be drawn boost::shared_ptr<ui::Texture> tex = curObj->getIngameTexture(); if (!tex) { continue; } if (!tex->isReadComplete()) { renderingComplete = false; continue; } CL_Rectf rect(curObj->getLocXDraw(), curObj->getLocYDraw(), CL_Sizef(tex->getWidth(), tex->getHeight())); vertexCoords[0] = CL_Vec2f(rect.left, rect.top); vertexCoords[1] = CL_Vec2f(rect.right, rect.top); vertexCoords[2] = CL_Vec2f(rect.left, rect.bottom); vertexCoords[3] = CL_Vec2f(rect.right, rect.top); vertexCoords[4] = CL_Vec2f(rect.left, rect.bottom); vertexCoords[5] = CL_Vec2f(rect.right, rect.bottom); CL_Rectf texCoordHelper = tex->getNormalizedTextureCoords(); CL_Vec2f texCoords[6] = { CL_Vec2f(texCoordHelper.left, texCoordHelper.top), CL_Vec2f(texCoordHelper.right, texCoordHelper.top), CL_Vec2f(texCoordHelper.left, texCoordHelper.bottom), CL_Vec2f(texCoordHelper.right, texCoordHelper.top), CL_Vec2f(texCoordHelper.left, texCoordHelper.bottom), CL_Vec2f(texCoordHelper.right, texCoordHelper.bottom) }; CL_PrimitivesArray primarray(gc); primarray.set_attributes(0, vertexCoords); primarray.set_attributes(1, texCoords); primarray.set_attribute(2, curObj->getHueInfo(false)); gc.set_texture(1, tex->getTexture()); gc.draw_primitives(cl_triangles, 6, primarray); } gc.reset_textures(); gc.reset_program_object(); renderQueue_->postRender(renderingComplete); if (!renderingComplete) { ui::Manager::getSingleton()->queueComponentRepaint(containerView_); } }
int App::start(const std::vector<CL_String> &args) { CL_OpenGLWindowDescription description; description.set_title("GLSL Test"); description.set_size(CL_Size(1024, 768), true); CL_DisplayWindow window(description); CL_InputDevice keyboard = window.get_ic().get_keyboard(); CL_GraphicContext gc = window.get_gc(); CL_Slot slot_window_close = window.sig_window_close().connect(this, &App::window_close); // Load and link shaders CL_ProgramObject shader = CL_ProgramObject::load(gc, "Resources/vertex_shader.glsl", "Resources/fragment_shader.glsl"); shader.bind_attribute_location(0, "Position"); if (!shader.link()) throw CL_Exception("Unable to link shader program: Error:" + shader.get_info_log()); quit = false; while (!keyboard.get_keycode(CL_KEY_ESCAPE) && !quit ) { gc.clear(); gc.set_program_object(shader, cl_program_matrix_modelview_projection); //shader.set_uniform1i("SourceTexture", 0); int xpos = 0; int size = 16; int gap = size + 2; //-------- Test 1 CL_Mat2f matrix2_a = CL_Mat2f(3, 1, 2, 4); CL_Mat2f matrix2_b = CL_Mat2f(-3, 7, 2, 5); CL_Mat2f matrix2_result = CL_Mat2f::multiply(matrix2_a, matrix2_b); CL_Mat2f matrix2_a_temp = matrix2_a; if (CL_Mat2i(matrix2_result) != CL_Mat2i(matrix2_a * matrix2_b)) throw CL_Exception("Failure"); shader.set_uniform1i("test_id", 1); shader.set_uniform_matrix("matrix2_a", matrix2_a); shader.set_uniform_matrix("matrix2_b", matrix2_b); shader.set_uniform_matrix("matrix2_result", matrix2_result); draw(gc, CL_Rect(xpos, 0, CL_Size(size, size))); xpos+=gap; //-------- Test 2 CL_Mat3f matrix3_a = CL_Mat3f(3, 1, 2, 4, 5 ,6, 4, 2, 1); CL_Mat3f matrix3_b = CL_Mat3f(4, 7, 2, 5, 3, 5, 2, 9, 3); CL_Mat3f matrix3_result = CL_Mat3f::multiply(matrix3_a, matrix3_b); CL_Mat3f matrix3_a_temp = matrix3_a; if (CL_Mat3i(matrix3_result) != CL_Mat3i(matrix3_a * matrix3_b)) throw CL_Exception("Failure"); shader.set_uniform1i("test_id", 2); shader.set_uniform_matrix("matrix3_a", matrix3_a); shader.set_uniform_matrix("matrix3_b", matrix3_b); shader.set_uniform_matrix("matrix3_result", matrix3_result); draw(gc, CL_Rect(xpos, 0, CL_Size(size, size))); xpos+=gap; //-------- Test 3 static float test_a_values[] = {3, 1, 2, 4, 5 ,6, 4, 2, 1, 4, 6, 7, 6, 3, 7, 2}; static float test_b_values[] = {4, 7, 2, 5, 3, 5, 2, 9, 3, 3, 6, 9, 2, 4, 6, 2}; CL_Mat4f matrix4_a = CL_Mat4f(test_a_values); CL_Mat4f matrix4_b = CL_Mat4f(test_b_values); CL_Mat4f matrix4_result = CL_Mat4f::multiply(matrix4_a, matrix4_b); CL_Mat4f matrix4_a_temp = matrix4_a; if (CL_Mat4i(matrix4_result) != CL_Mat4i(matrix4_a * matrix4_b)) throw CL_Exception("Failure"); shader.set_uniform1i("test_id", 3); shader.set_uniform_matrix("matrix4_a", matrix4_a); shader.set_uniform_matrix("matrix4_b", matrix4_b); shader.set_uniform_matrix("matrix4_result", matrix4_result); draw(gc, CL_Rect(xpos, 0, CL_Size(size, size))); xpos+=gap; //-------- Test 4 matrix2_result = CL_Mat2f::subtract(matrix2_a, matrix2_b); matrix2_a_temp = matrix2_a; if (CL_Mat2i(matrix2_result) != CL_Mat2i(matrix2_a - matrix2_b)) throw CL_Exception("Failure"); shader.set_uniform1i("test_id", 4); shader.set_uniform_matrix("matrix2_a", matrix2_a); shader.set_uniform_matrix("matrix2_b", matrix2_b); shader.set_uniform_matrix("matrix2_result", matrix2_result); draw(gc, CL_Rect(xpos, 0, CL_Size(size, size))); xpos+=gap; //-------- Test 5 matrix3_result = CL_Mat3f::subtract(matrix3_a, matrix3_b); matrix3_a_temp = matrix3_a; if (CL_Mat3i(matrix3_result) != CL_Mat3i(matrix3_a - matrix3_b)) throw CL_Exception("Failure"); shader.set_uniform1i("test_id", 5); shader.set_uniform_matrix("matrix3_a", matrix3_a); shader.set_uniform_matrix("matrix3_b", matrix3_b); shader.set_uniform_matrix("matrix3_result", matrix3_result); draw(gc, CL_Rect(xpos, 0, CL_Size(size, size))); xpos+=gap; //-------- Test 6 matrix4_result = CL_Mat4f::subtract(matrix4_a, matrix4_b); matrix4_a_temp = matrix4_a; if (CL_Mat4i(matrix4_result) != CL_Mat4i(matrix4_a - matrix4_b)) throw CL_Exception("Failure"); shader.set_uniform1i("test_id", 6); shader.set_uniform_matrix("matrix4_a", matrix4_a); shader.set_uniform_matrix("matrix4_b", matrix4_b); shader.set_uniform_matrix("matrix4_result", matrix4_result); draw(gc, CL_Rect(xpos, 0, CL_Size(size, size))); xpos+=gap; //-------- Test 7 CL_Vec2f vector2_a(2,3); CL_Vec2f vector2_result = vector2_a * matrix2_a; shader.set_uniform1i("test_id", 7); shader.set_uniform_matrix("matrix2_a", matrix2_a); shader.set_uniform2f("vector2_a", vector2_a); shader.set_uniform2f("vector2_result", vector2_result); draw(gc, CL_Rect(xpos, 0, CL_Size(size, size))); xpos+=gap; //-------- Test 8 vector2_result = matrix2_a * vector2_a; shader.set_uniform1i("test_id", 8); shader.set_uniform_matrix("matrix2_a", matrix2_a); shader.set_uniform2f("vector2_a", vector2_a); shader.set_uniform2f("vector2_result", vector2_result); draw(gc, CL_Rect(xpos, 0, CL_Size(size, size))); xpos+=gap; //-------- Test 9 CL_Vec3f vector3_a(3,5,6); CL_Vec3f vector3_result = vector3_a * matrix3_a; shader.set_uniform1i("test_id", 9); shader.set_uniform_matrix("matrix3_a", matrix3_a); shader.set_uniform3f("vector3_a", vector3_a); shader.set_uniform3f("vector3_result", vector3_result); draw(gc, CL_Rect(xpos, 0, CL_Size(size, size))); xpos+=gap; //-------- Test 10 vector3_result = matrix3_a * vector3_a; shader.set_uniform1i("test_id", 10); shader.set_uniform_matrix("matrix3_a", matrix3_a); shader.set_uniform3f("vector3_a", vector3_a); shader.set_uniform3f("vector3_result", vector3_result); draw(gc, CL_Rect(xpos, 0, CL_Size(size, size))); xpos+=gap; //-------- Test 11 CL_Vec4f vector4_a(4,3,5,6); CL_Vec4f vector4_result = vector4_a * matrix4_a; shader.set_uniform1i("test_id", 11); shader.set_uniform_matrix("matrix4_a", matrix4_a); shader.set_uniform4f("vector4_a", vector4_a); shader.set_uniform4f("vector4_result", vector4_result); draw(gc, CL_Rect(xpos, 0, CL_Size(size, size))); xpos+=gap; //-------- Test 12 vector4_result = matrix4_a * vector4_a; shader.set_uniform1i("test_id", 12); shader.set_uniform_matrix("matrix4_a", matrix4_a); shader.set_uniform4f("vector4_a", vector4_a); shader.set_uniform4f("vector4_result", vector4_result); draw(gc, CL_Rect(xpos, 0, CL_Size(size, size))); xpos+=gap; gc.reset_program_object(); window.flip(); CL_System::sleep(10); CL_KeepAlive::process(); } return 0; }
// The start of the Application int App::start(const std::vector<CL_String> &args) { quit = false; // Create a console window for text-output if not available CL_ConsoleWindow console("Console", 80, 200); try { // Set the window // This opens a 640 x 480 window, including the frame size // If you want more control over the window, pass CL_DisplayWindowDescription to CL_DisplayWindow // (This is useful to create a borderless window of a specific size) // If you require target specific control over the window, use the derived CL_OpenGLWindowDescription // (This contains the multisampling options) #ifdef USE_SWRENDER CL_DisplayWindowDescription desc; #else CL_OpenGLWindowDescription desc; // desc.set_multisampling(4); #endif desc.set_title("ClanLib 2D Test"); desc.set_size(CL_Size(800, 600), true); 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(); CL_Texture texture_image(gc, "tux.png"); texture_image.set_wrap_mode(cl_wrap_repeat, cl_wrap_repeat, cl_wrap_repeat); texture_image.set_min_filter(cl_filter_linear); texture_image.set_mag_filter(cl_filter_linear); CL_ResourceManager resources("resources.xml"); CL_Sprite sprite(gc, "test", &resources); //sprite.set_linear_filter(true); CL_Font small_font = CL_Font(gc, "Tahoma", 12); float test_base_angle = 0.0f; float test_angle = 0.0f; float test_angle_pitch = 0.0f; float test_angle_yaw = 0.0f; float test_scale = 1.0f; bool test_scale_dir = false; // Run until someone presses escape while (!quit) { gc.clear(CL_Colorf(0.0f,0.0f,0.2f)); gc.set_map_mode(CL_MapMode(cl_map_2d_upper_left)); // CL_Draw::point() for (int xcnt=0; xcnt<8; xcnt++) { for (int ycnt=0; ycnt<6; ycnt++) { CL_Draw::point(gc, xcnt*2, ycnt*2, CL_Colorf(1.0f, 1.0f, 1.0f, 1.0f)); } } small_font.draw_text(gc, 32, 10, "8*6 Points (0 + 2x), (0 + 2y)"); // CL_Draw::line() for (int xcnt=0; xcnt<4; xcnt++) { for (int ycnt=0; ycnt<3; ycnt++) { const int offset_y = 16; const int line_length = 6; const int spacing = 8; CL_Draw::line(gc, xcnt*spacing, (ycnt*spacing) + offset_y, line_length + (xcnt*spacing), (line_length + (ycnt*spacing)) + offset_y, CL_Colorf(1.0f, 1.0f, 1.0f, 1.0f)); } } small_font.draw_text(gc, 48, 30, "4*3 Lines (0 + 8x), (32 + 8y), (6 + 8x), (38 + 8y)"); // CL_Draw::box() for (int xcnt=0; xcnt<4; xcnt++) { for (int ycnt=0; ycnt<3; ycnt++) { const int offset_y = 48; const int line_length = 6; const int spacing = 8; CL_Draw::box(gc, xcnt*spacing, (ycnt*spacing) + offset_y, line_length + (xcnt*spacing), (line_length + (ycnt*spacing)) + offset_y, CL_Colorf(1.0f, 1.0f, 1.0f, 1.0f)); } } small_font.draw_text(gc, 48, 66, "4*3 Box (0 + 8x), (32 + 8y), (6 + 8x), (38 + 8y)"); // CL_Draw::fill() for (int xcnt=0; xcnt<4; xcnt++) { for (int ycnt=0; ycnt<3; ycnt++) { const int offset_y = 80; const int line_length = 6; const int spacing = 8; CL_Draw::fill(gc, xcnt*spacing, (ycnt*spacing) + offset_y, line_length + (xcnt*spacing), (line_length + (ycnt*spacing)) + offset_y, CL_Colorf(1.0f, 1.0f, 1.0f, 1.0f)); } } small_font.draw_text(gc, 48, 90, "4*3 Fill (0 + 8x), (32 + 8y), (6 + 8x), (38 + 8y)"); // CL_Draw::gradient_fill() CL_Gradient gradient; gradient.top_left = CL_Colorf(1.0f, 1.0f, 1.0f, 1.0f); gradient.top_right = CL_Colorf(1.0f, 0.0f, 0.0f, 1.0f); gradient.bottom_left = CL_Colorf(0.0f, 0.0f, 1.0f, 1.0f); gradient.bottom_right = CL_Colorf(0.0f, 1.0f, 0.0f, 1.0f); for (int xcnt=0; xcnt<4; xcnt++) { for (int ycnt=0; ycnt<3; ycnt++) { const int offset_y = 110; const int line_length = 6; const int spacing = 8; CL_Draw::gradient_fill(gc, xcnt*spacing, (ycnt*spacing) + offset_y, line_length + (xcnt*spacing), (line_length + (ycnt*spacing)) + offset_y, gradient); } } small_font.draw_text(gc, 48, 115, "4*3 GradientFill (0 + 8x), (32 + 8y), (6 + 8x), (38 + 8y)"); small_font.draw_text(gc, 48, 125, "top left = white. top right = red"); small_font.draw_text(gc, 48, 135, "bottom left = blue. bottom right = green"); // CL_Draw::circle() { const int offset_y = 140; int radius = 5; CL_Draw::circle(gc, radius, offset_y + radius, radius, CL_Colorf(1.0f, 1.0f, 1.0f, 1.0f)); const int offset_x = 16; radius = 16; CL_Draw::circle(gc, offset_x + radius, offset_y + radius, radius, CL_Colorf(1.0f, 1.0f, 1.0f, 1.0f)); } small_font.draw_text(gc, 54, 149, "Circle (5, 145) Radius = 5"); small_font.draw_text(gc, 54, 159, "Circle (32, 156) Radius = 16"); // CL_Draw::gradient_circle() { CL_Gradient gradient; gradient.top_left = CL_Colorf(1.0f, 1.0f, 1.0f, 1.0f); gradient.top_right = CL_Colorf(0.0f, 0.0f, 0.0f, 1.0f); gradient.bottom_left = CL_Colorf(0.0f, 0.0f, 0.0f, 1.0f); gradient.bottom_right = CL_Colorf(1.0f, 0.0f, 0.0f, 1.0f); const int offset_y = 180; float radius = 17.0; float xpos = radius; float ypos = offset_y + radius; CL_Draw::gradient_circle(gc, CL_Pointf( xpos, ypos ), CL_Pointf(radius/2.0, 0.0f), radius, gradient); const int offset_x = 40; radius = 17.0; xpos = offset_x + radius; ypos = offset_y + radius; CL_Draw::gradient_circle(gc, CL_Pointf( xpos, ypos), CL_Pointf(0.0f, radius/2.0), radius, gradient); } small_font.draw_text(gc, 80, 189, "Gradient Circle (16, 196) Radius = 17. Gradient right"); small_font.draw_text(gc, 80, 199, "Gradient Circle (56, 196) Radius = 17. Gradient up"); small_font.draw_text(gc, 80, 209, "centre = white, outer = red"); // CL_Draw::triangle() { const float offset_y = 220.0f; const float size = 12.0f; CL_Draw::triangle(gc, CL_Pointf(0.0f, offset_y), CL_Pointf(0.0f, offset_y + size), CL_Pointf(size, offset_y + size), CL_Colorf(1.0f, 1.0f, 1.0f, 1.0f)); float offset_x = 16.0f; CL_Draw::triangle(gc, CL_Pointf(offset_x + 0.0f, offset_y + size), CL_Pointf(offset_x + size, offset_y + size), CL_Pointf(offset_x + 0.0f, offset_y), CL_Colorf(1.0f, 1.0f, 1.0f, 1.0f)); offset_x = 32.0f; CL_Draw::triangle(gc, CL_Pointf(offset_x + size, offset_y + size), CL_Pointf(offset_x + 0.0f, offset_y), CL_Pointf(offset_x + 0.0f, offset_y + size), CL_Colorf(1.0f, 1.0f, 1.0f, 1.0f)); } small_font.draw_text(gc, 48, 229, "3 Triangles (12 pixel size) (Left vertical edge)."); small_font.draw_text(gc, 48, 239, "Top Left: (0,220) (16,220) (32,220)"); // CL_Draw::texture() gc.set_texture(0, texture_image); { float offset_x = 0.0f; float offset_y = 250.0f; CL_Rectf src_rect(offset_x, offset_y, CL_Sizef(31, 47)); CL_Rectf texture_coords(0.0, 0.0, 1.0f, 1.0f); CL_Colorf color(1.0f, 1.0f, 1.0f, 1.0f); CL_Draw::texture(gc, src_rect, color, texture_coords); offset_x = 33.0f; src_rect = CL_Rectf(offset_x, offset_y, CL_Sizef(31, 47)); texture_coords = CL_Rectf(0.25f, 0.25f, 0.75f, 0.75f); color = CL_Colorf(1.0f, 0.0f, 0.0f, 1.0f); CL_Draw::texture(gc, src_rect, color, texture_coords); } gc.reset_texture(0); small_font.draw_text(gc, 76, 260, "Texture (0, 250) size=(31,47)"); small_font.draw_text(gc, 76, 275, "Texture (33, 250) size=(31,47) (red, magnify*2)"); // CL_RoundedRect { CL_RoundedRect roundedrect(CL_Sizef(64.0f, 32.0f), 15.0f); float offset_x = 0.0f; float offset_y = 300.0f; CL_Origin origin = origin_top_left; roundedrect.draw(gc, CL_Pointf(offset_x, offset_y), CL_Colorf(1.0f, 1.0f, 1.0f, 1.0f), origin); offset_y = 340.0f; roundedrect.fill(gc, CL_Pointf(offset_x, offset_y), CL_Colorf(1.0f, 1.0f, 1.0f, 1.0f), origin); offset_y = 380.0f; CL_Gradient gradient; gradient.top_left = CL_Colorf(1.0f, 1.0f, 1.0f, 1.0f); gradient.top_right = CL_Colorf(1.0f, 0.0f, 0.0f, 1.0f); gradient.bottom_left = CL_Colorf(0.0f, 0.0f, 1.0f, 1.0f); gradient.bottom_right = CL_Colorf(0.0f, 1.0f, 0.0f, 1.0f); roundedrect.fill(gc, CL_Pointf(offset_x, offset_y), gradient, origin); offset_y = 420.0f; roundedrect.set_control_point_bl(CL_Pointf(0.4f, 0.8f)); roundedrect.set_rounding_bottom_left(CL_Sizef(0.2f, 0.6f)); roundedrect.set_control_point_tl(CL_Pointf(0.2f, 0.4f)); roundedrect.set_rounding_top_left(CL_Sizef(0.4f, 0.2f)); roundedrect.set_control_point_tr(CL_Pointf(0.6f, 0.2f)); roundedrect.set_rounding_top_right(CL_Sizef(0.8f, 0.4f)); roundedrect.set_control_point_br(CL_Pointf(0.6f, 0.8f)); roundedrect.set_rounding_bottom_right(CL_Sizef(0.8f, 0.6f)); roundedrect.fill(gc, CL_Pointf(offset_x, offset_y), gradient, origin); } small_font.draw_text(gc, 76, 310, "RoundedRect - draw (0, 300) size=(64,32)"); small_font.draw_text(gc, 76, 325, "(RoundedRect - draw gradient - is not implemented)"); small_font.draw_text(gc, 76, 350, "RoundedRect - fill (0, 340) size=(64,32)"); small_font.draw_text(gc, 76, 390, "RoundedRect - fill gradient (0, 380) size=(64,32)"); small_font.draw_text(gc, 76, 400, "top left = white. top right = red"); small_font.draw_text(gc, 76, 410, "bottom left = blue. bottom right = green"); small_font.draw_text(gc, 76, 430, "RoundedRect - fill gradient (0, 420) size=(64,32)"); small_font.draw_text(gc, 76, 440, "Controling control / rounding points"); // CL_Sprite { test_base_angle+=5.0f; if (test_base_angle >= 360.0f) { test_base_angle = 0.0f; } #ifndef USE_SWRENDER clEnable(GL_MULTISAMPLE); #endif sprite.set_base_angle(CL_Angle(test_base_angle, cl_degrees)); sprite.draw(gc, 350, 20); sprite.set_base_angle(CL_Angle(0, cl_degrees)); #ifndef USE_SWRENDER clDisable(GL_MULTISAMPLE); #endif } small_font.draw_text(gc, 370, 20, "Sprite - Base angle"); small_font.draw_text(gc, 370, 35, "Multisampling enabled"); { test_angle+=5.0f; if (test_angle >= 360.0f) { test_angle = 0.0f; } sprite.set_angle(CL_Angle(test_angle, cl_degrees)); sprite.draw(gc, 350, 60); sprite.set_angle(CL_Angle(0, cl_degrees)); } small_font.draw_text(gc, 370, 60, "Sprite - Angle"); { test_angle_pitch+=5.0f; if (test_angle_pitch >= 360.0f) { test_angle_pitch = 0.0f; } sprite.set_angle_pitch(CL_Angle(test_angle_pitch, cl_degrees)); sprite.draw(gc, 350, 100); sprite.set_angle_pitch(CL_Angle(0, cl_degrees)); } small_font.draw_text(gc, 370, 100, "Sprite - Angle Pitch"); { test_angle_yaw+=5.0f; if (test_angle_yaw >= 360.0f) { test_angle_yaw = 0.0f; } sprite.set_angle_yaw(CL_Angle(test_angle_yaw, cl_degrees)); sprite.draw(gc, 350, 140); sprite.set_angle_yaw(CL_Angle(0, cl_degrees)); } small_font.draw_text(gc, 370, 140, "Sprite - Angle Yaw"); { if (test_scale_dir) { test_scale += 0.1f; if (test_scale >= 2.0f) { test_scale = 2.0f; test_scale_dir = false; } }else { test_scale -= 0.1f; if (test_scale <= -2.0f) { test_scale = -2.0f; test_scale_dir = true; } } sprite.set_scale(test_scale, 1.0f); sprite.draw(gc, 350, 180); sprite.set_scale(1.0f, test_scale); sprite.draw(gc, 390, 180); sprite.set_scale(1.0f, 1.0f); } small_font.draw_text(gc, 420, 180, "Sprite - Set Scale (x), (y)"); // 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(); } small_font = CL_Font(); } catch(CL_Exception& exception) { CL_Console::write_line("Exception caught:"); CL_Console::write_line(exception.message); // Display the stack trace (if available) std::vector<CL_String> stacktrace = exception.get_stack_trace(); int size = stacktrace.size(); if (size > 0) { CL_Console::write_line("Stack Trace:"); for (int cnt=0; cnt < size; cnt++) { CL_Console::write_line(stacktrace[cnt]); } } console.display_close_message(); return -1; } return 0; }
// The start of the Application int Basic::start(const std::vector<CL_String> &args) { quit = false; // Set the window CL_DisplayWindowDescription desc; desc.set_title("ClanLib OpenCL Basic Example"); desc.set_size(CL_Size(640, 480), true); desc.set_allow_resize(true); CL_DisplayWindow window(desc); // Connect the Window close event CL_Slot slot_quit = window.sig_window_close().connect(this, &Basic::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, &Basic::on_input_up); // Get the graphic context CL_GraphicContext gc = window.get_gc(); cl_int error; cl_platform_id platform; cl_uint platforms; error = clGetPlatformIDs(1, &platform, &platforms); if (error != CL_SUCCESS) throw CL_Exception("clGetPlatformIDs failed"); cl_device_id device; cl_uint devices; error = clGetDeviceIDs(platform, CL_DEVICE_TYPE_GPU, 1, &device, &devices); if (error != CL_SUCCESS) throw CL_Exception("clGetDeviceIDs failed"); cl_context_properties properties[]={CL_CONTEXT_PLATFORM, (cl_context_properties)platform, 0}; cl_context context; context = clCreateContext(properties, 1, &device, NULL, NULL, &error); if (error != CL_SUCCESS) throw CL_Exception("clCreateContext failed"); cl_command_queue cq; cq = clCreateCommandQueue(context, device, 0, &error); if (error != CL_SUCCESS) throw CL_Exception("clCreateCommandQueue failed"); static const char source_code[] = "" "__kernel void simple_test(__global float *vals)" "{" " const uint i = get_global_id(0);" "" "vals[i] = 1.23;" "}" ""; const char *src[] = {source_code}; cl_program prog; prog = clCreateProgramWithSource(context, 1, src, NULL, &error); if (error != CL_SUCCESS) throw CL_Exception("clCreateProgramWithSource failed"); error = clBuildProgram(prog, 0, NULL, "", NULL, NULL); if (error != CL_SUCCESS) throw CL_Exception("clBuildProgram failed"); cl_kernel k_simple_test; k_simple_test = clCreateKernel(prog, "simple_test", &error); if (error != CL_SUCCESS) throw CL_Exception("clCreateKernel failed"); static const int buffer_length = 64; cl_mem ref_buffer; ref_buffer = clCreateBuffer(context, CL_MEM_READ_WRITE, sizeof(float) * buffer_length, NULL, &error); if (error != CL_SUCCESS) throw CL_Exception("clCreateBuffer failed"); error = clSetKernelArg(k_simple_test, 0, sizeof(ref_buffer), &ref_buffer); if (error != CL_SUCCESS) throw CL_Exception("clSetKernelArg failed"); const size_t worksize = buffer_length; error = clEnqueueNDRangeKernel(cq, k_simple_test, 1, NULL, &worksize, NULL, 0, NULL, NULL); if (error != CL_SUCCESS) throw CL_Exception("clEnqueueNDRangeKernel failed"); error = clFinish(cq); if (error != CL_SUCCESS) throw CL_Exception("clFinish failed"); float ram_buffer[buffer_length]; error=clEnqueueReadBuffer(cq, ref_buffer, CL_TRUE, 0, sizeof(float) * buffer_length, ram_buffer, 0, NULL, NULL); if (error != CL_SUCCESS) throw CL_Exception("clEnqueueReadBuffer failed"); error=clFinish(cq); if (error != CL_SUCCESS) throw CL_Exception("clFinish failed"); // Clean up clReleaseKernel(k_simple_test); clReleaseProgram(prog); clReleaseCommandQueue(cq); clReleaseContext(context); clReleaseMemObject(ref_buffer); // Test output for (int cnt=0;cnt < buffer_length; cnt++) { if (ram_buffer[cnt] != 1.23f) throw CL_Exception("It did not work!"); } CL_Font font(gc, "tahoma", 24); // Run until someone presses escape while (!quit) { gc.clear(CL_Colorf(0.0f,0.0f,0.2f)); font.draw_text(gc, 32, 32, "Success"); window.flip(1); CL_KeepAlive::process(0); } 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) { 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 Tetris::start(const std::vector<CL_String> &args) { quit = false; finish = false; // leftborderlist = new LeftBordeList(); // rightbordelist = new RightBordeList(); // Set the window CL_DisplayWindowDescription desc; desc.set_title("Tetris"); desc.set_size(CL_Size(320, 640), true); desc.set_allow_resize(true); CL_DisplayWindow window(desc); // Connect the Window close event CL_Slot slot_quit = window.sig_window_close().connect(this, &Tetris::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, &Tetris::on_input_up); // Get the graphic context CL_GraphicContext gc = window.get_gc(); // Load a sprite from a png-file //CL_Sprite spr_logo(gc, "Resources/logo.png"); float sin_count = 0.0f; float ypos = 0.0f; float ydir = 0.3f; unsigned int last_time = CL_System::get_time(); CL_Font font(gc, "Utopia", 40); linesRemoved = 0; // Run until someone presses escape while (!quit) { unsigned int current_time = CL_System::get_time(); float time_delta_ms = static_cast<float> (current_time - last_time); last_time = current_time; float shift = time_delta_ms/20; shift = 1.0f; //std::cout << "shift = " << shift << std::endl; // Clear the display in a dark blue nuance // The four arguments are red, green, blue and alpha gc.clear(CL_Colorf(25.0f,25.0f,25.0f)); std::string s; std::stringstream out; out << linesRemoved; s = out.str(); font.draw_text(gc, 250,40, s.c_str(), CL_Colorf::blue); int l = bottomborderlist.getLineNumberToDelete(); while (l != -1) { l = bottomborderlist.getLineNumberToDelete(); if (l!= -1) { if (!bottomborderlist.isFullHeight()) { linesRemoved++; } } bottomborderlist.removeLine(l); } if (!figlist.checkCollisionDown(bottomborderlist)) { figlist.moveDown(shift); } else { FigureList newfl = figlist; newfl.setStablePosition(); if (!finish) { bottomborderlist.addList(newfl.getFigureList()); if (figlist.checkCollisionDown(bottomborderlist)) { figlist.reset(); } else { figlist.reset(); figlist.clearFigureList(); } } if (figlist.checkCollisionDown(bottomborderlist)) { finish = true; } } leftborderlist.draw(gc); rightborderlist.draw(gc); bottomborderlist.draw(gc); if (finish == false && !figlist.checkCollisionDown(bottomborderlist)) { figlist.draw(gc); } else { if (linesRemoved < 5) { font.draw_text(gc, 10,40, "You Lost", CL_Colorf::black); } else { font.draw_text(gc, 10,40, "You Won", CL_Colorf::black); } } // 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(0); } return 0; }
void run() { quit = false; CL_DisplayWindowDescription window_desc; window_desc.set_size(CL_Size(1920, 1080), true); window_desc.set_title("Luna"); CL_DisplayWindow window(window_desc); CL_Slot slot_quit = window.sig_window_close().connect(this, &RootWindow::on_window_close); CL_GraphicContext gc = window.get_gc(); CL_InputDevice keyboard = window.get_ic().get_keyboard(); CL_FontDescription font_desc; font_desc.set_typeface_name("Monospace"); font_desc.set_height(16); CL_Font_System font(gc, font_desc); CL_FontMetrics fmetrics = font.get_font_metrics(); int fntWidth = fmetrics.get_max_character_width(); CL_SpriteDescription spr_desc; spr_desc.add_frame(CL_ImageProviderFactory::load("spaceship.png")); CL_Sprite node(gc, spr_desc); node.set_play_loop(true); node.set_play_pingpong(false); node.set_frame(0); CL_Image pict(gc,"stars.jpg"); x = gc.get_width() / 2 ; y = gc.get_height() / 2 ; U = 0; W = 0; V = 0; H = 0; step = 0.2; while (!quit) { if(keyboard.get_keycode(CL_KEY_ESCAPE) == true) quit = true; if(keyboard.get_keycode(CL_KEY_LEFT) == true) U -= step ; if(keyboard.get_keycode(CL_KEY_RIGHT) == true) U += step ; if(keyboard.get_keycode(CL_KEY_UP) == true) V -= step ; if(keyboard.get_keycode(CL_KEY_DOWN) == true) V += step ; if(x < -node.get_width()) { x = gc.get_width(); } else if(x > gc.get_width()) { x = -node.get_width(); } else x += U ; if(y < step) { y = step; V = 0; } else if(y > gc.get_height()-node.get_height()) { y = gc.get_height()-node.get_height(); V = 0; } else y += V; gc.clear(); pict.draw(gc,W,H); pict.draw(gc,W,H-gc.get_height() ); pict.draw(gc,W-gc.get_width(),H ); H++ ; if( H > gc.get_height() ) H = 0; node.draw(gc, x, y); CL_String velocity = cl_format("Velocity U[%1] V[%2] --- Coordinate X[%3] Y[%4] --- Origin W[%5] H[%6]",U,V,x,y,W,H); font.draw_text(gc, gc.get_width()/2 - (velocity.length() * fntWidth)/2, 16, velocity); window.flip(); CL_KeepAlive::process(); CL_System::sleep(10); } }
// The start of the Application int App::start(const std::vector<CL_String> &args) { quit = false; try { CL_OpenGLWindowDescription desc; desc.set_title("ClanLib AnimCursor Test"); desc.set_size(CL_Size(800, 600), true); 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(); CL_Font font = CL_Font(gc, "Tahoma", 20); CL_PixelBuffer pacman("pacman.png"); CL_SpriteDescription description; CL_Size size(22, 22); for (int frame_cnt=0; frame_cnt < 6; frame_cnt++) { CL_PixelBuffer frame(size.width, size.height, cl_rgba8); pacman.convert(frame, size, CL_Rect((frame_cnt * 28) + 4, 4, size)); description.add_frame(frame); description.set_frame_delay(frame_cnt, 0.1); } CL_Point hotspot(0,0); CL_Cursor cursor(window, description, hotspot); window.set_cursor(cursor); // Run until someone presses escape while (!quit) { gc.clear(CL_Colorf(0.0f,0.0f,0.5f)); font.draw_text(gc, 32, 32, "Observe the animated cursor"); // 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(); } } catch(CL_Exception& exception) { // Create a console window for text-output if not available CL_ConsoleWindow console("Console", 80, 200); CL_Console::write_line("Exception caught:"); CL_Console::write_line(exception.message); // Display the stack trace (if available) std::vector<CL_String> stacktrace = exception.get_stack_trace(); int size = stacktrace.size(); if (size > 0) { CL_Console::write_line("Stack Trace:"); for (int cnt=0; cnt < size; cnt++) { CL_Console::write_line(stacktrace[cnt]); } } console.display_close_message(); return -1; } return 0; }
// The start of the Application int App::start(const std::vector<CL_String> &args) { quit = false; // Create a console window for text-output if not available CL_ConsoleWindow console("Console"); try { CL_DisplayWindow window("ClanLib Font Sprite Test", 1024, 480); // 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(); // Load some fonts from the resource file CL_ResourceManager resources("font.xml"); CL_Font_Sprite font1(gc, "Font1", &resources); CL_Font_Sprite font2(gc, "Font2", &resources); // Run until someone presses escape while (!quit) { gc.set_map_mode(CL_MapMode(cl_map_2d_upper_left)); gc.clear(CL_Colorf::red); font1.draw_text(gc, 25, 25, "ClanLib: Phear the Power!"); font2.draw_text(gc, 3, 155, "AaBbCcDdEeFfGgHhIiJjKkLlMmNnOoPpQqRrSsTtUuVvWwXxYyZzÆæØøÅå0123456789[]()!#$&%/\\=-+~'`\".,:;*?"); font2.draw_text(gc, 10.0f, 200.0f, 2.0f, 2.0f, "Hello World\nMy Message"); // 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(); } } catch(CL_Exception& exception) { CL_Console::write_line("Exception caught:"); CL_Console::write_line(exception.message); // Display the stack trace (if available) std::vector<CL_String> stacktrace = exception.get_stack_trace(); int size = stacktrace.size(); if (size > 0) { CL_Console::write_line("Stack Trace:"); for (int cnt=0; cnt < size; cnt++) { CL_Console::write_line(stacktrace[cnt]); } } console.display_close_message(); return -1; } return 0; }
// The start of the Application int App::start(const std::vector<CL_String> &args) { quit = false; // Set the window CL_DisplayWindowDescription desc; desc.set_title("ClanLib Worker GC Example"); desc.set_size(CL_Size(640, 480), true); desc.set_allow_resize(true); CL_DisplayWindow window(desc); CL_OpenGL::set_active(NULL); // wglCreateContextAttribsARB will fail if the shared context is current in a different thread. WorkerGC worker_gc; CL_System::sleep(200); // Fixme // 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(); worker_gc.Start("../../../Examples/Game/DiceWar/Resources/lobby_background1.png"); CL_Sprite spr_logo; float sin_count = 0.0f; float ypos = 0.0f; float ydir = 0.3f; unsigned int last_time = CL_System::get_time(); // Run until someone presses escape while (!quit) { unsigned int current_time = CL_System::get_time(); float time_delta_ms = static_cast<float> (current_time - last_time); last_time = current_time; if (!spr_logo.is_null()) { gc.clear(CL_Colorf(0.0f,0.0f,0.2f)); spr_logo.draw(gc, (float) gc.get_width()-spr_logo.get_width(), (float) gc.get_height()-spr_logo.get_height()); } else { gc.clear(CL_Colorf(0.5f,0.0f,0.0f)); } // Move the lines ypos += ydir * time_delta_ms; if (ydir > 0.0f) { if ((ypos+200.0f) >= gc.get_height()) { ypos = (float) (gc.get_height() - 200); ydir *= -1.0f; } } else { if (ypos <= 0.0f) { ypos = 0.0f; ydir *= -1.0f; } } CL_Draw::fill(gc, 0, ypos-1.0f, (float) gc.get_width(), ypos-8.0f,CL_Colorf(1.0f, 1.0f, 1.0f)); CL_Draw::fill(gc, 0, ypos+198.0f, (float) gc.get_width(), ypos+190.0f, CL_Colorf(1.0f, 1.0f, 1.0f)); // Flip the display, showing on the screen what we have drawed // since last call to flip() window.flip(1); if (worker_gc.IsReady()) { spr_logo = worker_gc.Get(); } // This call processes user input and other events CL_KeepAlive::process(0); } return 0; }
int GameRunner::main(const std::vector<CL_String> &args) { // Initialise clanlib by instanciating these classes. // when the get destroyed after scope goes away, they clean // themselves up (I think) so no need to deinitialise. // We never actually use these variables again. CL_SetupCore setup_core; CL_SetupDisplay setup_display; std::vector<CL_String> my_args = args; CL_String device = "GL"; for(std::vector<CL_String>::iterator arg = my_args.begin(); arg != my_args.end(); ++arg) { CL_Console::write_line(*arg); if(*arg == "-d") { device = *++arg; } } CL_Console::write_line(device); // setup clanlib correctly (doesn't work) CL_SetupGL* setup_gl = 0; CL_SetupGL1* setup_gl1 = 0; CL_SetupSDL* setup_sdl = 0; CL_SetupGDI* setup_gdi = 0; if(device == "GL") { setup_gl = new CL_SetupGL(); } if(device == "GL1") { setup_gl1 = new CL_SetupGL1(); } if(device == "SDL") { setup_sdl = new CL_SetupSDL(); } if(device == "GDI") { setup_gdi = new CL_SetupGDI(); } // command line argument handling //CL_CommandLine argp; //argp.add_doc("Play Drillboy!"); //argp.add_option('d', "device", "DEVICE", "Choose a device from GL1, GL, SDL or GDI"); //argp.parse_args(args); //CL_SetupGL1 setup_gl1; // use gl1 as opengl2 target breaks for me // CL_SetupSDL setup_sdl; // use sdl as render target //CL_SetupGDI setup_gdi; // use gdi as render target //CL_SetupGL setup_gl; try { // Set the window description CL_DisplayWindowDescription desc; desc.set_title("Drillboy"); desc.set_size(CL_Size(800, 600), true); // Lets actually make a window now called Drillboy 800x600 CL_DisplayWindow window(desc); // Grab the graphics context so we have a handle to call // drawing functions on CL_GraphicContext graphics = window.get_gc(); // Grab the keyboard so we can ask it about key presses CL_InputDevice keyboard = window.get_ic().get_keyboard(); // Tell console (as in, text-based debug output) we are good to go CL_Console::write_line("ClanLib init complete..."); // Before game loop begins, set screen to black via graphics context graphics.clear(CL_Colorf::black); // shortcut for CL_Colorf c(0,0,0) GameEngine engine(window, graphics, keyboard); bool running = true; // infinite loop to run the game while(running) { // Run the game engine running = engine.run(); } if(setup_gl) delete setup_gl; if(setup_gl1) delete setup_gl1; if(setup_sdl) delete setup_sdl; if(setup_gdi) delete setup_gdi; // if we're this far, game finished running successfully, bye bye return 0; } catch(CL_Exception exception) { // output the exception's message CL_Console::write_line("ClanLib Exception caught:"); CL_Console::write_line(exception.message); // Display the stack trace associated with the exception (it's an array of strings) std::vector<CL_String> stacktrace = exception.get_stack_trace(); // if there is a stacktrace (because it has at least 1 line) // then iterate through the vector and output each line if (stacktrace.size() > 0) { CL_Console::write_line("Stack Trace:"); for(std::vector<CL_String>::iterator line = stacktrace.begin(); line != stacktrace.end(); ++line) { CL_Console::write_line(*line); } } return -1; } }
int DemoSimple::run(CL_DisplayWindow &window) { quit = false; // Set the window window.set_title("LinearParticle Example - Simple "); // Connect the Window close event CL_Slot slot_quit = window.sig_window_close().connect(this, &DemoSimple::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, &DemoSimple::on_input_up); // Get the graphic context CL_GraphicContext gc = window.get_gc(); // initialize LinearParticle L_ParticleSystem::init(); // create surface to be used for particle and set the alignment CL_Sprite surface(gc,"Resources/light16p.png"); surface.set_alignment(origin_center); // create a sample of particle with life of 5000 L_Particle particle(&surface,5000); // create dropping effect with period of 16 L_DroppingEffect dropper(0,0,16); // add the particle to dropper effect dropper.add(&particle); // initialize particle effect dropper.initialize(); float x_pos = 320; float y_pos = 240; float x_vel = 3.0f; float y_vel = 3.0f; CL_Font font(gc, "tahoma", 16 ); FramerateCounter frameratecounter; // Run until someone presses escape while (!quit) { gc.clear(); x_pos += x_vel; y_pos += y_vel; if( x_pos > 640 || x_pos < 0 ) x_vel = -x_vel; if( y_pos > 480 || y_pos < 0 ) y_vel = -y_vel; dropper.set_position(x_pos, y_pos); dropper.trigger(); /* pass frame time to L_ParticleEffect::run(int) for time based system, a constant number would be a reference time unit for frame based system. */ dropper.run(16); // draw dropping effect L_DrawParticle(gc,dropper); frameratecounter.show_fps(gc, font); window.flip(0); // Set to "1" to lock to screen refresh rate frameratecounter.frame_shown(); CL_KeepAlive::process(0); } // deinitialize LinearParticle L_ParticleSystem::deinit(); return 0; }
int start(const std::vector<CL_String> &args) { CL_ConsoleWindow console("Console"); try { CL_DisplayWindow window("Image test", 1024, 768); CL_GraphicContext gc = window.get_gc(); // Connect the Window close event CL_Slot slot_quit = window.sig_window_close().connect(this, &App::on_window_close); CL_BlendMode blend_mode1; blend_mode1.enable_blending(true); gc.set_blend_mode(blend_mode1); quit = false; CL_ResourceManager resources("resources.xml"); CL_Texture texture(gc, "Images/square.png"); CL_Image image_texture(gc, texture, CL_Rect(0, 0, texture.get_size())); CL_Image image_loaded(gc, "Images/square.png"); CL_Image image_resources(gc, "entire_image", &resources); CL_Image image_copy(image_texture); CL_Image image_top_right(gc, "image_top_right", &resources); CL_Image image_bottom_right(gc, "image_bottom_right", &resources); CL_Image image_black(gc, "image_black", &resources); CL_Font small_font = CL_Font(gc, "Tahoma", 12); //CL_Console::write_line("Color: %1,%2,%3,%4", image_resources.get_color().r, image_resources.get_color().g, image_resources.get_color().b, image_resources.get_color().a); //CL_Console::write_line("Scale: %1,%2", image_resources.get_scale_x(), image_resources.get_scale_y()); //CL_Console::write_line("Translation: %1,%2,%3", image_resources.get_alignment()); while((!quit) && (!window.get_ic().get_keyboard().get_keycode(CL_KEY_ESCAPE))) { gc.clear(CL_Colorf(0.5f,0.5f,0.5f)); small_font.draw_text(gc, 10, 40, "Image From Texture (10,60)"); image_texture.draw(gc, 10, 60); small_font.draw_text(gc, 150, 40, "Image From Load (150,60)"); image_loaded.draw(gc, 150, 60); small_font.draw_text(gc, 300, 40, "Image From Resources (300,60)"); image_resources.draw(gc, 300, 60); small_font.draw_text(gc, 450, 40, "Image Copied (450,60)"); image_copy.draw(gc, 450, 60); small_font.draw_text(gc, 10, 190, "Image - Top Right (10,200)"); image_top_right.draw(gc, 10, 200); small_font.draw_text(gc, 150, 190, "Image - Top Right (150,200)"); image_texture.draw(gc, CL_Rect(32, 0, CL_Size(32, 32)), CL_Rect(150, 200, CL_Size(32, 32))); small_font.draw_text(gc, 300, 190, "Image - Bottom Right (300,200)"); image_bottom_right.draw(gc, 300, 200); small_font.draw_text(gc, 450, 190, "Image - Bottom Right (450,200)"); image_texture.draw(gc, CL_Rect(32, 32, CL_Size(32, 32)), CL_Rect(450, 200, CL_Size(32, 32))); small_font.draw_text(gc, 10, 290, "700 Images (10,300)"); for(int i=0;i<700;i++) image_texture.draw(gc, 10, 300); small_font.draw_text(gc, 150, 290, "br image (150,400) Size(128,256)"); image_bottom_right.draw(gc, CL_Rect(150, 300, CL_Size(128, 256))); small_font.draw_text(gc, 300, 290, "Image - black"); image_black.draw(gc, 300, 300); small_font.draw_text(gc, 300, 490, "Image - Scale (1.5, 2.5)"); image_texture.set_scale(1.5f, 2.5f); image_texture.draw(gc, 300, 500); image_texture.set_scale(1.0f, 1.0f); small_font.draw_text(gc, 450, 460, "Image - Alignment (4 images with 8 pixel offset)"); small_font.draw_text(gc, 450, 475, "(top left, top right, bottom left, bottom right)"); small_font.draw_text(gc, 450, 490, "(Circle denotes the draw origin)"); const int offset = 96; image_texture.set_alignment(origin_top_left, 8, 8); image_texture.draw(gc, 450+offset, 500+offset); image_texture.set_alignment(origin_top_right, -8, 8); image_texture.draw(gc, 450+offset, 500+offset); image_texture.set_alignment(origin_bottom_left, 8, -8); image_texture.draw(gc, 450+offset, 500+offset); image_texture.set_alignment(origin_bottom_right, -8, -8); image_texture.draw(gc, 450+offset, 500+offset); CL_Draw::circle(gc, 450+offset, 500+offset, 4, CL_Colorf(1.0f, 1.0f, 1.0f, 0.9f)); small_font.draw_text(gc, 700, 460, "Image - Center Alignment (4 images with 8 pixel offset)"); small_font.draw_text(gc, 700, 475, "(top center, right center, bottom center, left center)"); small_font.draw_text(gc, 700, 490, "(Circle denotes the draw origin)"); image_texture.set_alignment(origin_top_center, 0, 8); image_texture.draw(gc, 700+offset, 500+offset); image_texture.set_alignment(origin_bottom_center, 0, -8); image_texture.draw(gc, 700+offset, 500+offset); image_texture.set_alignment(origin_center_left, 8, 0); image_texture.draw(gc, 700+offset, 500+offset); image_texture.set_alignment(origin_center_right, -8, 0); image_texture.draw(gc, 700+offset, 500+offset); CL_Draw::circle(gc, 700+offset, 500+offset, 4, CL_Colorf(1.0f, 1.0f, 1.0f, 0.9f)); small_font.draw_text(gc, 700, 160, "Image - Center Align (4 images with 64 pixel offset)"); small_font.draw_text(gc, 700, 175, "Also Includes a centered image (Without offset)"); small_font.draw_text(gc, 700, 190, "(Circle denotes the draw origin)"); const int center_image_offset = 64; image_texture.set_alignment(origin_center, 0, 0); image_texture.draw(gc, 700+offset, 200+offset); image_texture.set_alignment(origin_center, 0, center_image_offset); image_texture.draw(gc, 700+offset, 200+offset); image_texture.set_alignment(origin_center, 0, -center_image_offset); image_texture.draw(gc, 700+offset, 200+offset); image_texture.set_alignment(origin_center, center_image_offset, 0); image_texture.draw(gc, 700+offset, 200+offset); image_texture.set_alignment(origin_center, -center_image_offset, 0); image_texture.draw(gc, 700+offset, 200+offset); CL_Draw::circle(gc, 700+offset, 200+offset, 4, CL_Colorf(1.0f, 1.0f, 1.0f, 0.9f)); // Restore alignment image_texture.set_alignment(origin_top_left, 0, 0); dump_fps(); window.flip(1); CL_KeepAlive::process(); } return 0; } catch(CL_Exception error) { CL_Console::write_line("Exception caught:"); CL_Console::write_line(error.message); console.display_close_message(); return -1; } return 0; }