// ---------------------------------------------------------------------------- void RaceResultGUI::displayGPProgress() { video::SColor color = video::SColor(255,255,0,0); core::recti dest_rect(m_gp_progress_x, m_top, 0, 0); m_font->draw(_("Grand Prix progress:"), dest_rect, color, false, false, NULL, true); } // displayGPProgress
BBitmap* Scaler::CreateDestImage(BBitmap* srcImage) { if (srcImage == NULL || (srcImage->ColorSpace() != B_RGB32 && srcImage->ColorSpace() != B_RGBA32)) return NULL; BRect dest(0, 0, fRect.IntegerWidth(), fRect.IntegerHeight()); BBitmap* destImage = new BBitmap(dest, fDither ? B_CMAP8 : srcImage->ColorSpace()); if (!IsBitmapValid(destImage)) { delete destImage; return NULL; } if (fDither) { BRect dest_rect(0, 0, fRect.IntegerWidth(), fRect.IntegerHeight()); fScaledImage = new BBitmap(dest_rect, srcImage->ColorSpace()); if (!IsBitmapValid(fScaledImage)) { delete destImage; delete fScaledImage; fScaledImage = NULL; return NULL; } } else { fScaledImage = destImage; } return destImage; }
/**************************************************************************** Create a new sprite by cropping and taking only the given portion of the image. source gives the sprite that is to be cropped. x,y, width, height gives the rectangle to be cropped. The pixel at position of the source sprite will be at (0,0) in the new sprite, and the new sprite will have dimensions (width, height). mask gives an additional mask to be used for clipping the new sprite. Only the transparency value of the mask is used in crop_sprite. The formula is: dest_trans = src_trans * mask_trans. Note that because the transparency is expressed as an integer it is common to divide it by 256 afterwards. mask_offset_x, mask_offset_y is the offset of the mask relative to the origin of the source image. The pixel at (mask_offset_x,mask_offset_y) in the mask image will be used to clip pixel (0,0) in the source image which is pixel (-x,-y) in the new image. ****************************************************************************/ struct sprite *qtg_crop_sprite(struct sprite *source, int x, int y, int width, int height, struct sprite *mask, int mask_offset_x, int mask_offset_y) { if (!width || !height) { return NULL; } sprite *cropped = new sprite; cropped->pm = new QPixmap(width, height); cropped->pm->fill(Qt::transparent); QRectF source_rect(x,y,width, height); QRectF dest_rect(0,0,width, height); QPainter p; p.begin(cropped->pm); p.drawPixmap(dest_rect, *source->pm,source_rect); p.end(); if(mask) { p.begin(cropped->pm); p.setCompositionMode(QPainter::CompositionMode_DestinationIn); p.drawPixmap(mask_offset_x-x,mask_offset_y-y,*mask->pm); p.end(); } return cropped; }
void create_bus_text_layers() { for( int i = 0; i < NUM_BUSES_PER_PAGE; ++i ) { common_create_text_layer( &s_bus_display_lines[ i ].line, s_bus_display_wnd, line_rect( i ), GColorWhite, GColorBlack, FONT_KEY_GOTHIC_14_BOLD, GTextAlignmentCenter ); common_create_text_layer( &s_bus_display_lines[ i ].dest, s_bus_display_wnd, dest_rect( i ), GColorWhite, GColorBlack, FONT_KEY_GOTHIC_14, GTextAlignmentLeft ); common_create_text_layer( &s_bus_display_lines[ i ].eta, s_bus_display_wnd, eta_rect( i ), GColorWhite, GColorBlack, FONT_KEY_GOTHIC_14_BOLD, GTextAlignmentRight ); } }
//----------------------------------------------------------------------------// void FalagardComponentBase::render(Window& srcWindow, const CEGUI::ColourRect* modColours, const Rectf* clipper, bool clipToDisplay) const { Rectf dest_rect(d_area.getPixelRect(srcWindow)); if (!clipper) clipper = &dest_rect; const Rectf final_clip_rect(dest_rect.getIntersection(*clipper)); render_impl(srcWindow, dest_rect, modColours, &final_clip_rect, clipToDisplay); }
// ---------------------------------------------------------------------------- void draw2DImage(const video::ITexture* texture, const core::rect<float>& destRect, const core::rect<s32>& sourceRect, const core::rect<s32>* clip_rect, const video::SColor* const colors, bool use_alpha_channel_of_texture, bool draw_translucently) { if (!CVS->isGLSL()) { core::rect<irr::s32> dest_rect (irr::s32(destRect.UpperLeftCorner.X), irr::s32(destRect.UpperLeftCorner.Y), irr::s32(destRect.LowerRightCorner.X), irr::s32(destRect.LowerRightCorner.Y)); irr_driver->getVideoDriver()->draw2DImage(texture, dest_rect, sourceRect, clip_rect, colors, use_alpha_channel_of_texture); return; } float width, height, center_pos_x, center_pos_y, tex_width, tex_height; float tex_center_pos_x, tex_center_pos_y; getSize(texture->getSize().Width, texture->getSize().Height, texture->isRenderTarget(), destRect, sourceRect, width, height, center_pos_x, center_pos_y, tex_width, tex_height, tex_center_pos_x, tex_center_pos_y); if (draw_translucently) { glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA, GL_ONE); } else if (use_alpha_channel_of_texture) { glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); } else { glDisable(GL_BLEND); } if (clip_rect) { if (!clip_rect->isValid()) return; glEnable(GL_SCISSOR_TEST); const core::dimension2d<u32>& render_target_size = irr_driver->getActualScreenSize(); glScissor(clip_rect->UpperLeftCorner.X, render_target_size.Height - clip_rect->LowerRightCorner.Y, clip_rect->getWidth(), clip_rect->getHeight()); } if (colors) { drawTexColoredQuad(texture, colors, width, height, center_pos_x, center_pos_y, tex_center_pos_x, tex_center_pos_y, tex_width, tex_height); } else { drawTexQuad(texture->getOpenGLTextureName(), width, height, center_pos_x, center_pos_y, tex_center_pos_x, tex_center_pos_y, tex_width, tex_height); } if (clip_rect) glDisable(GL_SCISSOR_TEST); glUseProgram(0); glGetError(); } // draw2DImage
// ---------------------------------------------------------------------------- void draw2DImage(const video::ITexture* texture, const core::rect<float>& destRect, const core::rect<s32>& sourceRect, const core::rect<s32>* clip_rect, const video::SColor &colors, bool use_alpha_channel_of_texture) { if (!CVS->isGLSL()) { core::rect<irr::s32> dest_rect (irr::s32(destRect.UpperLeftCorner.X), irr::s32(destRect.UpperLeftCorner.Y), irr::s32(destRect.LowerRightCorner.X), irr::s32(destRect.LowerRightCorner.Y)); video::SColor duplicatedArray[4] = { colors, colors, colors, colors }; draw2DImage(texture, dest_rect, sourceRect, clip_rect, duplicatedArray, use_alpha_channel_of_texture); return; } float width, height, center_pos_x, center_pos_y; float tex_width, tex_height, tex_center_pos_x, tex_center_pos_y; getSize(texture->getSize().Width, texture->getSize().Height, texture->isRenderTarget(), destRect, sourceRect, width, height, center_pos_x, center_pos_y, tex_width, tex_height, tex_center_pos_x, tex_center_pos_y); if (use_alpha_channel_of_texture) { glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); } else { glDisable(GL_BLEND); } if (clip_rect) { if (!clip_rect->isValid()) return; glEnable(GL_SCISSOR_TEST); const core::dimension2d<u32>& render_target_size = irr_driver->getActualScreenSize(); glScissor(clip_rect->UpperLeftCorner.X, render_target_size.Height - clip_rect->LowerRightCorner.Y, clip_rect->getWidth(), clip_rect->getHeight()); } UniformColoredTextureRectShader::getInstance()->use(); glBindVertexArray(SharedGPUObjects::getUI_VAO()); UniformColoredTextureRectShader::getInstance() ->setTextureUnits(texture->getOpenGLTextureName()); UniformColoredTextureRectShader::getInstance() ->setUniforms(core::vector2df(center_pos_x, center_pos_y), core::vector2df(width, height), core::vector2df(tex_center_pos_x, tex_center_pos_y), core::vector2df(tex_width, tex_height), colors); glDrawArrays(GL_TRIANGLE_STRIP, 0, 4); glBindVertexArray(0); glBindBuffer(GL_ARRAY_BUFFER, 0); if (clip_rect) glDisable(GL_SCISSOR_TEST); glUseProgram(0); glGetError(); } // draw2DImage
void Sprite::draw(Surface *dest, int x, int y, int index, int clip_x, int clip_y, int clip_w, int clip_h) const { int tx, ty; int bx, by, bw, bh; // Check if loaded if (!m_loaded) { return; } // Cache and precalculate variables tx = x; ty = y; bx = 0; by = 0; bw = m_w; bh = m_h; // Test if sprite is complete outside clipping box if((tx + m_w <= clip_x) || (tx >= clip_w) || (ty + m_h <= clip_y) || (ty >= clip_h)) { return; } // Get starting position in pixels of indexed tile int col = index % m_stride; int row = index / m_stride; int sx = m_margin + (m_spacing + m_w) * col; int sy = m_margin + (m_spacing + m_h) * row; // Test if clipping is needed if(tx >= clip_x || tx + m_w <= clip_w || ty >= clip_y || ty + m_h <= clip_h ) { // x left of clipping box if(tx < clip_x) { bx = clip_x - tx; bw = m_w - bx; tx = clip_x; } // x+w right of clipping box else if(tx + m_w > clip_w) { bx = 0; bw = clip_w - tx; } // y over of clipping box if(ty < clip_y) { by = clip_y - ty; bh = m_h - by; ty = clip_y; } // y+h under clipping box else if(ty + m_h > clip_h) { by = 0; bh = clip_h - ty; } } // Draw sprite Rect dest_rect(tx, ty, 0, 0); Rect src_rect(sx + bx, sy + by, bw, bh); m_img->draw(&src_rect, dest, &dest_rect); }
/** Displays the race results for a single kart. * \param n Index of the kart to be displayed. * \param display_points True if GP points should be displayed, too */ void RaceResultGUI::displayOneEntry(unsigned int x, unsigned int y, unsigned int n, bool display_points) { RowInfo *ri = &(m_all_row_infos[n]); video::SColor color = ri->m_is_player_kart ? video::SColor(255,255,0, 0 ) : video::SColor(255,255,255,255); #ifdef USE_PER_LINE_BACKGROUND // Draw the background image core::rect<s32> dest(x-50, y, x+50+m_table_width, (int)(y+m_distance_between_rows)); ri->m_box_params.setTexture(irr_driver->getTexture( (file_manager->getGUIDir() + "skins/glass/glassbutton_focused.png").c_str() ) ); GUIEngine::getSkin()->drawBoxFromStretchableTexture(&(ri->m_widget_container), dest, ri->m_box_params); #endif unsigned int current_x = x; // First draw the icon // ------------------- if(ri->m_kart_icon) { core::recti source_rect(core::vector2di(0,0), ri->m_kart_icon->getSize()); core::recti dest_rect(current_x, y, current_x+m_width_icon, y+m_width_icon); irr_driver->getVideoDriver()->draw2DImage(ri->m_kart_icon, dest_rect, source_rect, NULL, NULL, true); current_x += m_width_icon + m_width_column_space; } // Draw the name // ------------- core::recti pos_name(current_x, y, UserConfigParams::m_width, y+m_distance_between_rows); m_font->draw(ri->m_kart_name, pos_name, color); current_x += m_width_kart_name + m_width_column_space; // Draw the time except in FTL mode // -------------------------------- if(race_manager->getMinorMode()!=RaceManager::MINOR_MODE_FOLLOW_LEADER) { core::recti dest_rect = core::recti(current_x, y, current_x+100, y+10); m_font->draw(ri->m_finish_time_string, dest_rect, color); current_x += m_width_finish_time + m_width_column_space; } // Only display points in GP mode and when the GP results are displayed. // ===================================================================== if(race_manager->getMajorMode()!=RaceManager::MAJOR_MODE_GRAND_PRIX || m_animation_state == RR_RACE_RESULT) return; // Draw the new points // ------------------- if(ri->m_new_points>0) { core::recti dest_rect = core::recti(current_x, y, current_x+100, y+10); core::stringw point_string = core::stringw("+") + core::stringw((int)ri->m_new_points); // With mono-space digits space has the same width as each digit, so // we can simply fill up the string with spaces to get the right // aligned. while(point_string.size()<3) point_string = core::stringw(" ")+point_string; m_font->draw(point_string, dest_rect, color); } current_x += m_width_new_points +m_width_column_space; // Draw the old_points plus increase value // --------------------------------------- core::recti dest_rect = core::recti(current_x, y, current_x+100, y+10); core::stringw point_inc_string = core::stringw((int)(ri->m_current_displayed_points)); while(point_inc_string.size()<3) point_inc_string = core::stringw(" ")+point_inc_string; m_font->draw(point_inc_string, dest_rect, color); } // displayOneEntry
void Mapper::drawMinimap() { video::ITexture *minimap_texture = getMinimapTexture(); if (!minimap_texture) return; updateActiveMarkers(); v2u32 screensize = porting::getWindowSize(); const u32 size = 0.25 * screensize.Y; core::rect<s32> oldViewPort = driver->getViewPort(); core::matrix4 oldProjMat = driver->getTransform(video::ETS_PROJECTION); core::matrix4 oldViewMat = driver->getTransform(video::ETS_VIEW); driver->setViewPort(core::rect<s32>( screensize.X - size - 10, 10, screensize.X - 10, size + 10)); driver->setTransform(video::ETS_PROJECTION, core::matrix4()); driver->setTransform(video::ETS_VIEW, core::matrix4()); core::matrix4 matrix; matrix.makeIdentity(); video::SMaterial &material = m_meshbuffer->getMaterial(); material.setFlag(video::EMF_TRILINEAR_FILTER, true); material.Lighting = false; material.TextureLayer[0].Texture = minimap_texture; material.TextureLayer[1].Texture = data->heightmap_texture; if (m_enable_shaders && !data->is_radar) { u16 sid = m_shdrsrc->getShader("minimap_shader", 1, 1); material.MaterialType = m_shdrsrc->getShaderInfo(sid).material; } else { material.MaterialType = video::EMT_TRANSPARENT_ALPHA_CHANNEL; } if (data->minimap_shape_round) matrix.setRotationDegrees(core::vector3df(0, 0, 360 - m_angle)); // Draw minimap driver->setTransform(video::ETS_WORLD, matrix); driver->setMaterial(material); driver->drawMeshBuffer(m_meshbuffer); // Draw overlay video::ITexture *minimap_overlay = data->minimap_shape_round ? data->minimap_overlay_round : data->minimap_overlay_square; material.TextureLayer[0].Texture = minimap_overlay; material.MaterialType = video::EMT_TRANSPARENT_ALPHA_CHANNEL; driver->setMaterial(material); driver->drawMeshBuffer(m_meshbuffer); // If round minimap, draw player marker if (!data->minimap_shape_round) { matrix.setRotationDegrees(core::vector3df(0, 0, m_angle)); material.TextureLayer[0].Texture = data->player_marker; driver->setTransform(video::ETS_WORLD, matrix); driver->setMaterial(material); driver->drawMeshBuffer(m_meshbuffer); } // Reset transformations driver->setTransform(video::ETS_VIEW, oldViewMat); driver->setTransform(video::ETS_PROJECTION, oldProjMat); driver->setViewPort(oldViewPort); // Draw player markers v2s32 s_pos(screensize.X - size - 10, 10); core::dimension2di imgsize(data->object_marker_red->getOriginalSize()); core::rect<s32> img_rect(0, 0, imgsize.Width, imgsize.Height); static const video::SColor col(255, 255, 255, 255); static const video::SColor c[4] = {col, col, col, col}; f32 sin_angle = sin(m_angle * core::DEGTORAD); f32 cos_angle = cos(m_angle * core::DEGTORAD); s32 marker_size2 = 0.025 * (float)size; for (std::list<v2f>::const_iterator i = m_active_markers.begin(); i != m_active_markers.end(); ++i) { v2f posf = *i; if (data->minimap_shape_round) { f32 t1 = posf.X * cos_angle - posf.Y * sin_angle; f32 t2 = posf.X * sin_angle + posf.Y * cos_angle; posf.X = t1; posf.Y = t2; } posf.X = (posf.X + 0.5) * (float)size; posf.Y = (posf.Y + 0.5) * (float)size; core::rect<s32> dest_rect( s_pos.X + posf.X - marker_size2, s_pos.Y + posf.Y - marker_size2, s_pos.X + posf.X + marker_size2, s_pos.Y + posf.Y + marker_size2); driver->draw2DImage(data->object_marker_red, dest_rect, img_rect, &dest_rect, &c[0], true); } }
bool Warp::accelerated_cairorender(Context context, cairo_t *cr, int quality, const RendDesc &renddesc_, ProgressCallback *cb)const { Point src_tl=param_src_tl.get(Point()); Point src_br=param_src_br.get(Point()); Point dest_tl=param_dest_tl.get(Point()); Point dest_tr=param_dest_tr.get(Point()); Point dest_bl=param_dest_bl.get(Point()); Point dest_br=param_dest_br.get(Point()); Real horizon=param_horizon.get(Real()); bool clip=param_clip.get(bool()); SuperCallback stageone(cb,0,9000,10000); SuperCallback stagetwo(cb,9000,10000,10000); RendDesc renddesc(renddesc_); // Untransform the render desc if(!cairo_renddesc_untransform(cr, renddesc)) return false; Real pw=(renddesc.get_w())/(renddesc.get_br()[0]-renddesc.get_tl()[0]); Real ph=(renddesc.get_h())/(renddesc.get_br()[1]-renddesc.get_tl()[1]); if(cb && !cb->amount_complete(0,10000)) return false; Point tl(renddesc.get_tl()); Point br(renddesc.get_br()); Rect bounding_rect; Rect render_rect(tl,br); Rect clip_rect(Rect::full_plane()); Rect dest_rect(dest_tl,dest_br); dest_rect.expand(dest_tr).expand(dest_bl); Real zoom_factor(1.0); // Quick exclusion clip, if necessary if(clip && !intersect(render_rect,dest_rect)) { cairo_save(cr); cairo_set_operator(cr, CAIRO_OPERATOR_CLEAR); cairo_paint(cr); cairo_restore(cr); return true; } { Rect other(render_rect); if(clip) other&=dest_rect; Point min(other.get_min()); Point max(other.get_max()); bool init_point_set=false; // Point trans_point[4]; Point p; // Real trans_z[4]; Real z,minz(10000000000000.0f),maxz(0); //! \todo checking the 4 corners for 0<=z<horizon*2 and using //! only 4 corners which satisfy this condition isn't the //! right thing to do. It's possible that none of the 4 //! corners fall within that range, and yet content of the //! tile does. p=transform_forward(min); z=transform_backward_z(p); if(z>0 && z<horizon*2) { if(init_point_set) bounding_rect.expand(p); else bounding_rect=Rect(p); init_point_set=true; maxz=std::max(maxz,z); minz=std::min(minz,z); } p=transform_forward(max); z=transform_backward_z(p); if(z>0 && z<horizon*2) { if(init_point_set) bounding_rect.expand(p); else bounding_rect=Rect(p); init_point_set=true; maxz=std::max(maxz,z); minz=std::min(minz,z); } swap(min[1],max[1]); p=transform_forward(min); z=transform_backward_z(p); if(z>0 && z<horizon*2) { if(init_point_set) bounding_rect.expand(p); else bounding_rect=Rect(p); init_point_set=true; maxz=std::max(maxz,z); minz=std::min(minz,z); } p=transform_forward(max); z=transform_backward_z(p); if(z>0 && z<horizon*2) { if(init_point_set) bounding_rect.expand(p); else bounding_rect=Rect(p); init_point_set=true; maxz=std::max(maxz,z); minz=std::min(minz,z); } if(!init_point_set) { cairo_save(cr); cairo_set_operator(cr, CAIRO_OPERATOR_CLEAR); cairo_paint(cr); cairo_restore(cr); return true; } zoom_factor=(1+(maxz-minz)); } #ifdef ACCEL_WARP_IS_BROKEN return Layer::accelerated_cairorender(context,cr,quality,renddesc, cb); #else /*swap(tl[1],br[1]); bounding_rect .expand(transform_forward(tl)) .expand(transform_forward(br)) ; swap(tl[1],br[1]);*/ //synfig::warning("given window: [%f,%f]-[%f,%f] %dx%d",tl[0],tl[1],br[0],br[1],renddesc.get_w(),renddesc.get_h()); //synfig::warning("Projected: [%f,%f]-[%f,%f]",bounding_rect.get_min()[0],bounding_rect.get_min()[1],bounding_rect.get_max()[0],bounding_rect.get_max()[1]); // If we are clipping, then go ahead and clip to the // source rectangle if(clip) clip_rect&=Rect(src_tl,src_br); // Bound ourselves to the bounding rectangle of // what is under us clip_rect&=context.get_full_bounding_rect();//.expand_x(abs(zoom_factor/pw)).expand_y(abs(zoom_factor/ph)); bounding_rect&=clip_rect; Point min_point(bounding_rect.get_min()); Point max_point(bounding_rect.get_max()); // we're going to divide by the difference of these pairs soon; // if they're the same, we'll be dividing by zero, and we don't // want to do that! // \todo what should we do in this case? if (min_point[0] == max_point[0]) max_point[0] += 0.001; if (min_point[1] == max_point[1]) max_point[1] += 0.001; if(tl[0]>br[0]) { tl[0]=max_point[0]; br[0]=min_point[0]; } else { br[0]=max_point[0]; tl[0]=min_point[0]; } if(tl[1]>br[1]) { tl[1]=max_point[1]; br[1]=min_point[1]; } else { br[1]=max_point[1]; tl[1]=min_point[1]; } const int tmp_d(max(renddesc.get_w(),renddesc.get_h())); Real src_pw=(tmp_d*zoom_factor)/(br[0]-tl[0]); Real src_ph=(tmp_d*zoom_factor)/(br[1]-tl[1]); RendDesc desc(renddesc); desc.clear_flags(); //desc.set_flags(RendDesc::PX_ASPECT); desc.set_tl(tl); desc.set_br(br); desc.set_wh(ceil_to_int(src_pw*(br[0]-tl[0])),ceil_to_int(src_ph*(br[1]-tl[1]))); //synfig::warning("surface to render: [%f,%f]-[%f,%f] %dx%d",desc.get_tl()[0],desc.get_tl()[1],desc.get_br()[0],desc.get_br()[1],desc.get_w(),desc.get_h()); if(desc.get_w()==0 && desc.get_h()==0) { cairo_save(cr); cairo_set_operator(cr, CAIRO_OPERATOR_CLEAR); cairo_paint(cr); cairo_restore(cr); return true; } // Recalculate the pixel widths for the src renddesc src_pw=(desc.get_w())/(desc.get_br()[0]-desc.get_tl()[0]); src_ph=(desc.get_h())/(desc.get_br()[1]-desc.get_tl()[1]); cairo_surface_t* source=cairo_surface_create_similar(cairo_get_target(cr), CAIRO_CONTENT_COLOR_ALPHA, desc.get_w(),desc.get_h()); cairo_surface_t* surface=cairo_surface_create_similar(cairo_get_target(cr), CAIRO_CONTENT_COLOR_ALPHA,renddesc.get_w(), renddesc.get_h()); cairo_t* subcr=cairo_create(source); cairo_scale(subcr, 1/desc.get_pw(), 1/desc.get_ph()); cairo_translate(subcr, -desc.get_tl()[0], -desc.get_tl()[1]); if(!context.accelerated_cairorender(subcr,quality,desc,&stageone)) return false; cairo_destroy(subcr); int surfacew, surfaceh, sourcew, sourceh; CairoSurface csurface(surface); CairoSurface csource(source); csurface.map_cairo_image(); csource.map_cairo_image(); surfacew=csurface.get_w(); surfaceh=csurface.get_h(); sourcew=csource.get_w(); sourceh=csource.get_h(); CairoSurface::pen pen(csurface.begin()); // Do the warp { int x,y; float u,v; Point point,tmp; for(y=0,point[1]=renddesc.get_tl()[1];y<surfaceh;y++,pen.inc_y(),pen.dec_x(x),point[1]+=1.0/ph) { for(x=0,point[0]=renddesc.get_tl()[0];x<surfacew;x++,pen.inc_x(),point[0]+=1.0/pw) { tmp=transform_forward(point); const float z(transform_backward_z(tmp)); if(!clip_rect.is_inside(tmp) || !(z>0 && z<horizon)) { csurface[y][x]=Color::alpha(); continue; } u=(tmp[0]-tl[0])*src_pw; v=(tmp[1]-tl[1])*src_ph; if(u<0 || v<0 || u>=sourcew || v>=sourceh || isnan(u) || isnan(v)) csurface[y][x]=context.get_cairocolor(tmp); else { // CUBIC if(quality<=4) csurface[y][x]=csource.cubic_sample_cooked(u,v); // INTEPOLATION_LINEAR else if(quality<=6) csurface[y][x]=csource.linear_sample_cooked(u,v); else // NEAREST_NEIGHBOR csurface[y][x]=csource[floor_to_int(v)][floor_to_int(u)]; } } if((y&31)==0 && cb) { if(!stagetwo.amount_complete(y,surfaceh)) return false; } } } #endif if(cb && !cb->amount_complete(10000,10000)) return false; csurface.unmap_cairo_image(); csource.unmap_cairo_image(); cairo_surface_destroy(source); cairo_save(cr); cairo_translate(cr, renddesc.get_tl()[0], renddesc.get_tl()[1]); cairo_scale(cr, renddesc.get_pw(), renddesc.get_ph()); cairo_set_source_surface(cr, surface, 0, 0); cairo_set_operator(cr, CAIRO_OPERATOR_SOURCE); cairo_paint(cr); cairo_restore(cr); cairo_surface_destroy(surface); return true; }
/** Displays the race results for a single kart. * \param n Index of the kart to be displayed. * \param display_points True if GP points should be displayed, too */ void RaceResultGUI::displayOneEntry(unsigned int x, unsigned int y, unsigned int n, bool display_points) { RowInfo *ri = &(m_all_row_infos[n]); video::SColor color = ri->m_is_player_kart ? video::SColor(255,255,0, 0 ) : video::SColor(255,255,255,255); unsigned int current_x = x; // First draw the icon // ------------------- if(ri->m_kart_icon) { core::recti source_rect(core::vector2di(0,0), ri->m_kart_icon->getSize()); core::recti dest_rect(current_x, y, current_x+m_width_icon, y+m_width_icon); draw2DImage(ri->m_kart_icon, dest_rect, source_rect, NULL, NULL, true); } current_x += m_width_icon + m_width_column_space; // Draw the name // ------------- core::recti pos_name(current_x, y, UserConfigParams::m_width, y+m_distance_between_rows); m_font->draw(ri->m_kart_name, pos_name, color, false, false, NULL, true /* ignoreRTL */); current_x += m_width_kart_name + m_width_column_space; // Draw the time except in FTL mode // -------------------------------- if(race_manager->getMinorMode()!=RaceManager::MINOR_MODE_FOLLOW_LEADER) { core::recti dest_rect = core::recti(current_x, y, current_x+100, y+10); m_font->draw(ri->m_finish_time_string, dest_rect, color, false, false, NULL, true /* ignoreRTL */); current_x += m_width_finish_time + m_width_column_space; } // Only display points in GP mode and when the GP results are displayed. // ===================================================================== if (race_manager->getMajorMode() == RaceManager::MAJOR_MODE_GRAND_PRIX && m_animation_state != RR_RACE_RESULT) { // Draw the new points // ------------------- if(ri->m_new_points > 0) { core::recti dest_rect = core::recti(current_x, y, current_x+100, y+10); core::stringw point_string = core::stringw("+") + core::stringw((int)ri->m_new_points); // With mono-space digits space has the same width as each digit, // so we can simply fill up the string with spaces to get the // right aligned. while(point_string.size()<3) point_string = core::stringw(" ")+point_string; m_font->draw(point_string, dest_rect, color, false, false, NULL, true /* ignoreRTL */); } current_x += m_width_new_points + m_width_column_space; // Draw the old_points plus increase value // --------------------------------------- core::recti dest_rect = core::recti(current_x, y, current_x+100, y+10); core::stringw point_inc_string = core::stringw((int)(ri->m_current_displayed_points)); while(point_inc_string.size()<3) point_inc_string = core::stringw(" ")+point_inc_string; m_font->draw(point_inc_string, dest_rect, color, false, false, NULL, true /* ignoreRTL */); } } // displayOneEntry
// ---------------------------------------------------------------------------- void RaceResultGUI::displayHighScores() { // This happens in demo world if(!World::getWorld()) return; Highscores* scores = World::getWorld()->getHighscores(); // In some case for exemple FTL they will be no highscores if (scores != NULL) { video::SColor white_color = video::SColor(255,255,255,255); int x = (int)(UserConfigParams::m_width*0.55f); int y = m_top; // First draw title GUIEngine::getFont()->draw(_("Highscores"), core::recti(x, y, 0, 0), white_color, false, false, NULL, true /* ignoreRTL */); std::string kart_name; irr::core::stringw player_name; // prevent excessive long name unsigned int max_characters = 15; float time; for (int i = 0; i < scores->getNumberEntries(); i++) { scores->getEntry(i,kart_name,player_name, &time); if (player_name.size() > max_characters) { int begin = (int(m_timer/0.4f)) % ( player_name.size() - max_characters ); player_name = player_name.subString(begin,max_characters,false); } video::SColor text_color = white_color; if (m_highscore_rank-1 == i) { text_color = video::SColor(255,255,0, 0 ); } int current_x = x; int current_y = y+(i+1)*50; const KartProperties* prop = kart_properties_manager->getKart(kart_name); if (prop != NULL) { const std::string &icon_path = prop->getAbsoluteIconFile(); video::ITexture* kart_icon_texture = irr_driver->getTexture( icon_path ); if (kart_icon_texture != NULL) { core::recti source_rect(core::vector2di(0,0), kart_icon_texture->getSize()); core::recti dest_rect(current_x, current_y, current_x+m_width_icon, current_y+m_width_icon); draw2DImage( kart_icon_texture, dest_rect, source_rect, NULL, NULL, true); current_x += m_width_icon + m_width_column_space; } } // draw the player name GUIEngine::getSmallFont()->draw(player_name.c_str(), core::recti(current_x, current_y, current_x+150, current_y+10), text_color, false, false, NULL, true /* ignoreRTL */); current_x += 180; // Finally draw the time std::string time_string = StringUtils::timeToString(time); GUIEngine::getSmallFont()->draw(time_string.c_str(), core::recti(current_x, current_y, current_x+100, current_y+10), text_color, false, false, NULL, true /* ignoreRTL */); } } }