CanvasLineSegmentStage Class Reference

Inheritance diagram for CanvasLineSegmentStage:

Public Member Functions
	CanvasLineSegmentStage (SkSize size)
	~CanvasLineSegmentStage () override=default
void	draw (SkCanvas *canvas) override
bool	animate (double nanos) override
std::unique_ptr< MMObject >	createObject () override
Public Member Functions inherited from Stage
	Stage (SkSize size, int startingObjectCount, int objectIncrement)
virtual	~Stage ()=default
virtual bool	onChar (SkUnichar uni)

Additional Inherited Members
Protected Member Functions inherited from Stage
void	initializeObjects ()
Protected Attributes inherited from Stage
SkSize	fSize
int	fStartingObjectCount
int	fObjectIncrement
std::vector< std::unique_ptr< MMObject > >	fObjects
SkRandom	fRandom

Detailed Description

Definition at line 220 of file MotionMarkSlide.cpp.

Constructor & Destructor Documentation

CanvasLineSegmentStage()

CanvasLineSegmentStage::CanvasLineSegmentStage ( SkSize  size )

inline

Definition at line 222 of file MotionMarkSlide.cpp.

            : Stage(size, /*startingObjectCount=*/5000, /*objectIncrement*/1000) {
        fParams.fLineMinimum = 20;
        fParams.fLineLengthMaximum = 40;
        fParams.fCircleRadius = fSize.fWidth/8 - .4 * (fParams.fLineMinimum +
                                                       fParams.fLineLengthMaximum);
        fParams.fCircleCenters[0] = SkPoint::Make(5.5 / 32 * fSize.fWidth, 2.1 / 3*fSize.fHeight);
        fParams.fCircleCenters[1] = SkPoint::Make(12.5 / 32 * fSize.fWidth, .9 / 3*fSize.fHeight);
        fParams.fCircleCenters[2] = SkPoint::Make(19.5 / 32 * fSize.fWidth, 2.1 / 3*fSize.fHeight);
        fParams.fCircleCenters[3] = SkPoint::Make(26.5 / 32 * fSize.fWidth, .9 / 3*fSize.fHeight);
        fHalfSize = SkSize::Make(fSize.fWidth * 0.5f, fSize.fHeight * 0.5f);
        fTwoFifthsSizeX = fSize.fWidth * .4;
 
        this->initializeObjects();
    }

~CanvasLineSegmentStage()

CanvasLineSegmentStage::~CanvasLineSegmentStage ( )

overridedefault

Member Function Documentation

animate()

bool CanvasLineSegmentStage::animate ( double  nanos )

inlineoverridevirtual

Reimplemented from Stage.

Definition at line 304 of file MotionMarkSlide.cpp.

                                        {
        fCurrentAngle = time_fractional_value(nanos, 3000) * SK_ScalarPI * 2;
        fCurrentGradientStep = 0.5f + 0.5f * std::sin(
                                       time_fractional_value(nanos, 5000) * SK_ScalarPI * 2);
 
        this->Stage::animate(nanos);
        return true;
    }

createObject()

std::unique_ptr< MMObject > CanvasLineSegmentStage::createObject ( )

inlineoverridevirtual

Implements Stage.

Definition at line 313 of file MotionMarkSlide.cpp.

                                                    {
        return std::make_unique<CanvasLineSegment>(&fRandom,fParams);
    }

draw()

void CanvasLineSegmentStage::draw ( SkCanvas *  canvas )

inlineoverridevirtual

Reimplemented from Stage.

Definition at line 240 of file MotionMarkSlide.cpp.

                                         {
        canvas->clear(SK_ColorWHITE);
 
        float dx = fTwoFifthsSizeX * std::cos(fCurrentAngle);
        float dy = fTwoFifthsSizeX * std::sin(fCurrentAngle);
 
        float colorStopStep = SkScalarInterp(-.1f, .1f, fCurrentGradientStep);
        int brightnessStep = SkScalarRoundToInt(SkScalarInterp(32, 64, fCurrentGradientStep));
 
        SkColor color1Step = SkColorSetARGB(brightnessStep,
                                            brightnessStep,
                                            (brightnessStep << 1),
                                            102);
        SkColor color2Step = SkColorSetARGB((brightnessStep << 1),
                                            (brightnessStep << 1),
                                            brightnessStep,
                                            102);
        SkPoint pts[2] = {
            {fHalfSize.fWidth + dx, fHalfSize.fHeight + dy},
            {fHalfSize.fWidth - dx, fHalfSize.fHeight - dy}
        };
        SkColor colors[] = {
            color1Step,
            color1Step,
            color2Step,
            color2Step
        };
        float pos[] = {
            0,
            0.2f + colorStopStep,
            0.8f - colorStopStep,
            1
        };
        sk_sp<SkShader> gradientShader = SkGradientShader::MakeLinear(pts, colors, pos, 4,
                                                                      SkTileMode::kClamp, 0);
 
        SkPaint paint;
        paint.setAntiAlias(true);
        paint.setStrokeWidth(15);
        for (int i = 0; i < 4; i++) {
            const SkColor strokeColors[] = {
                0xffe01040, 0xff10c030, 0xff744cba, 0xffe05010
            };
            const SkColor fillColors[] = {
                0xff70051d, 0xff016112, 0xff2F0C6E, 0xff702701
            };
            paint.setColor(strokeColors[i]);
            paint.setStyle(SkPaint::kStroke_Style);
            SkRect arcRect = SkRect::MakeXYWH(fParams.fCircleCenters[i].fX - fParams.fCircleRadius,
                                              fParams.fCircleCenters[i].fY- fParams.fCircleRadius,
                                              2*fParams.fCircleRadius,
                                              2*fParams.fCircleRadius);
            canvas->drawArc(arcRect, 0, 360, false, paint);
            paint.setColor(fillColors[i]);
            paint.setStyle(SkPaint::kFill_Style);
            canvas->drawArc(arcRect, 0, 360, false, paint);
            paint.setShader(gradientShader);
            canvas->drawArc(arcRect, 0, 360, false, paint);
            paint.setShader(nullptr);
        }
 
        this->Stage::draw(canvas);
    }

---

The documentation for this class was generated from the following file:

• third_party/skia/tools/viewer/MotionMarkSlide.cpp