void GrAtlasTextBlob::Run::SubRunInfo::computeTranslation(const SkMatrix& viewMatrix, SkScalar x, SkScalar y, SkScalar* transX, SkScalar* transY) { calculate_translation(!this->drawAsDistanceFields(), viewMatrix, x, y, fCurrentViewMatrix, fX, fY, transX, transY); fCurrentViewMatrix = viewMatrix; fX = x; fY = y; }
void GrAtlasTextBlob::flushBigGlyphs(GrContext* context, GrDrawContext* dc, const GrClip& clip, const SkPaint& skPaint, const SkMatrix& viewMatrix, SkScalar x, SkScalar y, const SkIRect& clipBounds) { SkScalar transX, transY; for (int i = 0; i < fBigGlyphs.count(); i++) { GrAtlasTextBlob::BigGlyph& bigGlyph = fBigGlyphs[i]; calculate_translation(bigGlyph.fApplyVM, viewMatrix, x, y, fInitialViewMatrix, fInitialX, fInitialY, &transX, &transY); SkMatrix ctm; ctm.setScale(bigGlyph.fScale, bigGlyph.fScale); ctm.postTranslate(bigGlyph.fX + transX, bigGlyph.fY + transY); if (bigGlyph.fApplyVM) { ctm.postConcat(viewMatrix); } GrBlurUtils::drawPathWithMaskFilter(context, dc, clip, bigGlyph.fPath, skPaint, ctm, nullptr, clipBounds, false); } }
/** Calculate here your desired settings. What you desire is checked afterwards to the current * settings of the physical boundaries, but take care also. * * How you do this is up to you, but be careful, our hardware is expensive!!!! * * Available are: * * target_ --> current target coordinates to drive to * robot_ --> current robot coordinates * robot_vel_ --> current Motor velocities * * local_target_ --> our local target found by the search component we want to reach * local_trajec_ --> The point we would collide with, if we would drive WITHOUT Rotation * * orient_at_target_ --> Do we have to orient ourself at the target? * stop_at_target_ --> Do we have to stop really ON the target? * * Afterwards filled should be: * * proposed_ --> Desired translation and rotation speed * * Those values are questioned after an update() was called. */ void ForwardOmniDriveModule::update() { proposed_.x = 0.f; proposed_.rot = 0.f; float dist_to_target = sqrt( sqr(local_target_.x) + sqr(local_target_.y) ); float alpha_target = normalize_mirror_rad( atan2( local_target_.y, local_target_.x ) ); float alpha_next_target = angle_distance_signed(robot_.ori, target_.ori); // last time border check............. IMPORTANT!!! // because the motorinstructor just tests robots physical borders. if ( dist_to_target < 0.04 ) { proposed_.x = proposed_.y = proposed_.rot = 0.f; } else { float angle_tollerance = M_PI_4; calculate_rotation(alpha_target, alpha_next_target, dist_to_target, angle_tollerance / 2.); float dec_factor = 1; if ( fabs(alpha_target) >= angle_tollerance ) { // if we need to turn a lot => drive slower dec_factor = 0.5; } calculate_translation(dist_to_target, alpha_target, dec_factor); if ( stop_at_target_ ) { float target_rel = std::sqrt( sqr(target_.x - robot_.x) + sqr(target_.y - robot_.y) ); float robo_trans = std::sqrt( sqr(robot_vel_.x) + sqr(robot_vel_.y) ); float proposed_trans = std::sqrt( sqr(proposed_.x) + sqr(proposed_.y) ); float target_trans = guarantee_trans_stop(target_rel, robo_trans, proposed_trans); float des = fabs(target_trans / proposed_trans); if ( proposed_trans == 0 ) { des = 0; } proposed_.x *= des; proposed_.y *= des; } } }