void ClipRectManager::clamp(const CL_Vec2f& topleftBase, const CL_Size& sizeBase) { if (forceRepaint_) { CL_Rectf rect(topleftBase.x, topleftBase.y, CL_Sizef(sizeBase.width, sizeBase.height)); rectangles_.clear(); rectangles_.push_back(rect); } else if (rectangles_.empty()) { return; } std::vector<CL_Rectf> clamped; CL_Rectf clampRect(topleftBase.x, topleftBase.y, CL_Sizef(sizeBase.width, sizeBase.height)); std::vector<CL_Rectf>::iterator iter = rectangles_.begin(); std::vector<CL_Rectf>::iterator end = rectangles_.end(); for (; iter != end; ++iter) { if (clampRect.is_overlapped(*iter)) { bool addedWithExpand = false; CL_Rectf curClamped = iter->clip(clampRect); float curClampedArea = curClamped.get_width() * curClamped.get_height(); // check for overlaps to keep number of rectangles as small as possible std::vector<CL_Rectf>::iterator mergeIter = clamped.begin(); std::vector<CL_Rectf>::iterator mergeEnd = clamped.end(); for (; mergeIter != mergeEnd; ++mergeIter) { if (mergeIter->is_overlapped(curClamped)) { CL_Rectf bounding = CL_Rectf(*mergeIter).bounding_rect(curClamped); CL_Rectf overlap = CL_Rectf(*mergeIter).overlap(curClamped); // area of the bounding rectangle should not be too big. keep the rects seperate if joining them does not give a significant advantage float unnecessaryIncluded = (bounding.get_width() * bounding.get_height()) - (mergeIter->get_width() * mergeIter->get_height() + curClampedArea) + (overlap.get_width() * overlap.get_height()); if (unnecessaryIncluded <= curClampedArea * 3) { mergeIter->bounding_rect(curClamped); addedWithExpand = true; break; } } } if (!addedWithExpand) { clamped.push_back(curClamped); } } } rectangles_ = clamped; }
CL_Rectf ObjMapSpriteObjectImpl::get_bound_rect() const { CL_Point align = CL_Point(0, 0); CL_Origin origin_e; sprite.get_alignment(origin_e, align.x, align.y); CL_Point origin = calc_origin(origin_e, CL_Size(sprite.get_width(), sprite.get_height())); align.x = -align.x; // FIXME: This looks a bit hacky float scale_x, scale_y; sprite.get_scale(scale_x, scale_y); if (scale_x < 0) align.x += sprite.get_width(); if (scale_y < 0) align.y += sprite.get_height(); // if (scale_x > 1.0f && scale_y > 1.0f) // return CL_Rectf(pos - origin - align, // CL_Sizef(sprite.get_width() * scale_x, sprite.get_height() * scale_y)); // else return CL_Rectf(pos - origin - align, CL_Sizef(sprite.get_width(), sprite.get_height())); }
int CL_RenderBatch3D::set_batcher_active(CL_GraphicContext &gc, const CL_Texture &texture, bool glyph_program, const CL_Colorf &new_constant_color) { if (use_glyph_program != glyph_program || constant_color != new_constant_color) { gc.flush_batcher(); use_glyph_program = glyph_program; constant_color = new_constant_color; } int texindex = -1; for (int i = 0; i < num_current_textures; i++) { if (current_textures[i] == texture) { texindex = i; break; } } if (texindex == -1 && num_current_textures < max_textures) { texindex = num_current_textures; current_textures[num_current_textures++] = texture; tex_sizes[texindex] = CL_Sizef((float)current_textures[texindex].get_width(), (float)current_textures[texindex].get_height()); } if (position == 0 || position+6 > max_vertices || texindex == -1) { gc.flush_batcher(); texindex = 0; current_textures[texindex] = texture; num_current_textures = 1; tex_sizes[texindex] = CL_Sizef((float)current_textures[texindex].get_width(), (float)current_textures[texindex].get_height()); } gc.set_batcher(this); return texindex; }
void CL_GlyphCache::draw_text(CL_FontEngine *font_engine, CL_GraphicContext &gc, float xpos, float ypos, const CL_StringRef &text, const CL_Colorf &color) { CL_String::size_type string_length = text.length(); if (string_length==0) { return; } CL_RenderBatcherSprite *batcher = gc.impl->current_internal_batcher; // Scan the string CL_UTF8_Reader reader(text); while(!reader.is_end()) { unsigned int glyph = reader.get_char(); reader.next(); CL_Font_TextureGlyph *gptr = get_glyph(font_engine, gc, glyph); if (gptr == NULL) continue; if (!gptr->empty_buffer) { float xp = xpos + gptr->offset.x; float yp = ypos + gptr->offset.y; CL_Rectf dest_size(xp, yp, CL_Sizef(gptr->geometry.get_size())); if (enable_subpixel) { batcher->draw_glyph_subpixel(gc, gptr->geometry, dest_size, color, gptr->subtexture.get_texture()); }else { batcher->draw_image(gc, gptr->geometry, dest_size, color, gptr->subtexture.get_texture()); } } xpos += gptr->increment.x; ypos += gptr->increment.y; } }
// 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_stencil_size(8); // For simplicity this example does not use the depth components //win_desc.set_depth_size(16); win_desc.set_title("Stencil Example"); win_desc.set_size(CL_Size( 900, 570 ), 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"); grid_space = (float) (image_grid.get_width() - image_ball.get_width()); setup_balls(); CL_BufferControl buffer_control; CL_BufferControl default_buffer_control; options->request_repaint(); CL_Font font(gc, "Tahoma", 24); 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.clear_stencil(0); // Draw the grid const float grid_xpos = 10.0f; const float grid_ypos = 10.0f; image_grid.draw(gc, grid_xpos, grid_ypos); // Draw the circle onto the stencil if (options->is_circle_set) { buffer_control.enable_logic_op(false); buffer_control.enable_stencil_test(true); buffer_control.set_stencil_compare_func(cl_comparefunc_always, cl_comparefunc_always); buffer_control.set_stencil_fail(cl_stencil_incr_wrap, cl_stencil_incr_wrap); buffer_control.set_stencil_pass_depth_fail(cl_stencil_incr_wrap, cl_stencil_incr_wrap); buffer_control.set_stencil_pass_depth_pass(cl_stencil_incr_wrap, cl_stencil_incr_wrap); buffer_control.enable_color_write(false); buffer_control.enable_depth_write(false); buffer_control.enable_depth_test(false); gc.set_buffer_control(buffer_control); CL_Draw::circle(gc, grid_xpos + image_grid.get_width()/2, grid_ypos + image_grid.get_height()/2, 100, CL_Colorf::white); } buffer_control.enable_color_write(true); buffer_control.enable_logic_op(false); buffer_control.enable_stencil_test(true); buffer_control.set_stencil_compare_func(options->compare_function, options->compare_function); buffer_control.set_stencil_compare_reference(options->compare_reference, options->compare_reference); buffer_control.set_stencil_write_mask(255, 255); buffer_control.set_stencil_compare_mask(255, 255); buffer_control.set_stencil_fail(options->stencil_fail, options->stencil_fail);; // Note, depth testing disabled for this example buffer_control.set_stencil_pass_depth_fail(options->stencil_pass, options->stencil_pass); buffer_control.set_stencil_pass_depth_pass(options->stencil_pass, options->stencil_pass); buffer_control.enable_depth_write(false); buffer_control.enable_depth_test(false); gc.set_buffer_control(buffer_control); for (int cnt=0; cnt<num_balls; cnt++) { image_ball.draw(gc, grid_xpos + balls[cnt].xpos, grid_ypos + balls[cnt].ypos); } gc.set_buffer_control(default_buffer_control); CL_Image stencil_image = get_stencil(gc, CL_Rect(grid_xpos, grid_ypos, image_grid.get_width(), image_grid.get_height())); const float stencil_image_xpos = 400.0f; const float stencil_image_ypos = 30.0f; const float stencil_image_scale = 0.5f; stencil_image.set_scale(stencil_image_scale, stencil_image_scale); stencil_image.draw(gc, stencil_image_xpos, stencil_image_ypos); CL_Draw::box(gc, CL_Rectf(stencil_image_xpos, stencil_image_ypos, CL_Sizef(stencil_image.get_width() * stencil_image_scale, stencil_image.get_height() * stencil_image_scale)), CL_Colorf::white); font.draw_text(gc, stencil_image_xpos, stencil_image_ypos - 4.0f, "Stencil", CL_Colorf::black); // Add a note to avoid confusion font.draw_text(gc, 10.0f, 500.0, "(This example does not use the stencil depth buffer comparison or the stencil bitmask)", CL_Colorf::black); window.flip(1); CL_KeepAlive::process(); } 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_); } }
void TouchDragComponent::OnInput( VariantList *pVList ) { //0 = message type, 1 = parent coordinate offset CL_Vec2f pt = pVList->Get(1).GetVector2(); uint32 fingerID = 0; if (pVList->Get(2).GetType() == Variant::TYPE_UINT32) { fingerID = pVList->Get(2).GetUINT32(); } //LogMsg("Detected finger %d at %s", fingerID, PrintVector2(pt).c_str()); switch (eMessageType( int(pVList->Get(0).GetFloat()))) { case MESSAGE_TYPE_GUI_CLICK_START: //first, determine if the click is on our area { if (*m_pDisabled != 0) return; CL_Rectf r(*m_pPos2d, CL_Sizef(m_pSize2d->x, m_pSize2d->y)); ApplyPadding(&r, *m_pTouchPadding); if (r.contains(pt)) { if (m_activeFingerID != -1) { //LogMsg("Ignoring new finger.."); return; } TouchTrackInfo *pTouch = BaseApp::GetBaseApp()->GetTouch(pVList->Get(2).GetUINT32()); if (pTouch->WasHandled()) return; pTouch->SetWasHandled(true); VariantList vList(pt, GetParent(), uint32(fingerID)); GetParent()->GetFunction("OnOverStart")->m_sig_function(&vList); m_lastPos = pt; m_activeFingerID = fingerID; } } break; case MESSAGE_TYPE_GUI_CLICK_END: EndDrag(fingerID, pt); break; case MESSAGE_TYPE_GUI_CLICK_MOVE: if (*m_pDisabled != 0) { EndDrag(fingerID, pt); return; } if (m_activeFingerID == fingerID) { SetPosition(pt); } break; default: ; } }
// 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; }
void FilterInputComponent::FilterOnInput(VariantList *pVList) { if (pVList->m_variant[Entity::FILTER_INDEX].GetUINT32() == Entity::FILTER_REFUSE_ALL) return; switch (*m_pMode) { case MODE_CLIP_INPUT_TO_SIZE: //let's only apply this to some messages switch (eMessageType( int(pVList->Get(0).GetFloat()))) { case MESSAGE_TYPE_GUI_CLICK_START: case MESSAGE_TYPE_GUI_CLICK_MOVE: CL_Vec2f pt = pVList->Get(1).GetVector2(); pt += GetAlignmentOffset(*m_pSize2d, eAlignment(*m_pAlignment)); CL_Rectf r(*m_pPos2d, CL_Sizef(m_pSize2d->x, m_pSize2d->y)); if (!r.contains(pt)) { pVList->m_variant[Entity::FILTER_INDEX].Set(uint32(Entity::FILTER_REFUSE_ALL)); return; } else { //fine, you may pass } break; } break; case MODE_CLIP_INPUT_TO_SIZE_STRICT: //let's only apply this to some messages switch (eMessageType( int(pVList->Get(0).GetFloat()))) { case MESSAGE_TYPE_GUI_CLICK_START: case MESSAGE_TYPE_GUI_CLICK_MOVE: case MESSAGE_TYPE_GUI_CLICK_END: CL_Vec2f pt = pVList->Get(1).GetVector2(); pt += GetAlignmentOffset(*m_pSize2d, eAlignment(*m_pAlignment)); CL_Rectf r(*m_pPos2d, CL_Sizef(m_pSize2d->x, m_pSize2d->y)); if (!r.contains(pt)) { pVList->m_variant[Entity::FILTER_INDEX].Set(uint32(Entity::FILTER_REFUSE_ALL)); return; } else { //fine, you may pass } } break; case MODE_DISABLE_INPUT_ALL: pVList->m_variant[Entity::FILTER_INDEX].Set(uint32(Entity::FILTER_REFUSE_ALL)); break; case MODE_DISABLE_INPUT_CHILDREN: pVList->m_variant[Entity::FILTER_INDEX].Set(uint32(Entity::FILTER_REFUSE_CHILDREN)); break; case MODE_IDLE: //let it know it can process this message like normal //pVList->m_variant[Entity::FILTER_INDEX].Set(uint32(Entity::FILTER_ALLOW)); break; case MODE_CLIP_INPUT_TO_ABSOLUTE_CLIP_RECT_AND_DISABLE_INPUT_CHILDREN: //let's only apply this to some messages switch (eMessageType( int(pVList->Get(0).GetFloat()))) { case MESSAGE_TYPE_GUI_CLICK_START: case MESSAGE_TYPE_GUI_CLICK_MOVE: case MESSAGE_TYPE_GUI_CLICK_END: CL_Vec2f pt = pVList->Get(1).GetVector2(); //pt -= GetAlignmentOffset(*m_pSize2d, eAlignment(*m_pAlignment)); if (!m_pClipRect->contains(pt)) { pVList->m_variant[Entity::FILTER_INDEX].Set(uint32(Entity::FILTER_REFUSE_ALL)); return; } else { //fine, you may pass } } //let it know it can process this message like normal pVList->m_variant[Entity::FILTER_INDEX].Set(uint32(Entity::FILTER_REFUSE_CHILDREN)); break; case MODE_CLIP_INPUT_TO_ABSOLUTE_CLIP_RECT: //let's only apply this to some messages switch (eMessageType( int(pVList->Get(0).GetFloat()))) { case MESSAGE_TYPE_GUI_CLICK_START: case MESSAGE_TYPE_GUI_CLICK_MOVE: case MESSAGE_TYPE_GUI_CLICK_END: CL_Vec2f pt = pVList->Get(1).GetVector2(); if (!m_pClipRect->contains(pt)) { pVList->m_variant[Entity::FILTER_INDEX].Set(uint32(Entity::FILTER_REFUSE_ALL)); return; } else { //fine, you may pass } } break; case MODE_IGNORE_ABSOLUTE_CLIP_RECT: //let's only apply this to some messages switch (eMessageType( int(pVList->Get(0).GetFloat()))) { case MESSAGE_TYPE_GUI_CLICK_START: case MESSAGE_TYPE_GUI_CLICK_MOVE: case MESSAGE_TYPE_GUI_CLICK_END: CL_Vec2f pt = pVList->Get(1).GetVector2(); if (m_pClipRect->contains(pt)) { pVList->m_variant[Entity::FILTER_INDEX].Set(uint32(Entity::FILTER_REFUSE_ALL)); return; } else { //fine, you may pass } } break; case MODE_CLIP_INPUT_TO_CLIP_RECT: //let's only apply this to some messages switch (eMessageType( int(pVList->Get(0).GetFloat()))) { case MESSAGE_TYPE_GUI_CLICK_START: case MESSAGE_TYPE_GUI_CLICK_MOVE: case MESSAGE_TYPE_GUI_CLICK_END: CL_Vec2f pt = pVList->Get(1).GetVector2(); pt += GetAlignmentOffset(CL_Vec2f(m_pClipRect->get_width(), m_pClipRect->get_height()), eAlignment(*m_pAlignment)); CL_Rectf r(*m_pPos2d, m_pClipRect->get_size()); if (!r.contains(pt)) { pVList->m_variant[Entity::FILTER_INDEX].Set(uint32(Entity::FILTER_REFUSE_ALL)); return; } else { //fine, you may pass } } break; default: LogError("FilterInputComponent: Unknown mode %d", *m_pMode); } }
void CursorManager::drawDragObject(CL_GraphicContext& gc, const CL_Point& mousePos) const { if (isDragging_ && dragCandidate_) { boost::shared_ptr<ui::Texture> dragTex = dragCandidate_->getIngameTexture(); if (dragTex && dragTex->isReadComplete()) { // TODO: load shader here for correct hueing CL_Draw::texture(gc, dragTex->getTexture(), CL_Quadf(CL_Rectf(mousePos.x - dragTex->getWidth() / 2, mousePos.y - dragTex->getHeight() / 2, CL_Sizef(dragTex->getWidth(), dragTex->getHeight()))), CL_Colorf::white, dragTex->getNormalizedTextureCoords() ); } else { dragCandidate_->updateRenderData(0); } } }