InProgressStroke

public final void enqueueInputs(
    @NonNull StrokeInputBatch realInputs,
    @NonNull StrokeInputBatch predictedInputs
)

Enqueues the incremental realInputs and sets the prediction to predictedInputs, overwriting any previous prediction. Queued inputs will be processed on the next call to updateShape.

This method requires that:

• start has been previously called to set the current Brush.

• finishInput has not been called since the last call to start.

• realInputs and predictedInputs must form a valid stroke input sequence together with previously added real input. In particular, this means that the first input in realInputs must be valid following the last input in previously added real inputs, and the first input in predictedInputs must be valid following the last input in realInputs: They must have the same InputToolType, their StrokeInput.elapsedTimeMillis values must be monotonically non-decreasing, and they can not duplicate the previous input.

Either one or both of realInputs and predictedInputs may be empty.

public final void finishInput()

Indicates that the inputs for the current stroke are finished. After calling this, it is an error to call enqueueInputs until start is called again to start a new stroke. This method is idempotent; it has no effect if start was never called, or if this method has already been called since the last call to start. This method is synchronous, but the stroke may not be fully finished changing shape due to brush shape animations until isUpdateNeeded returns false. Until that condition is met, keep calling updateShape periodically and rendering the result.

public final Brush getBrush()

The Brush currently being used to generate the stroke content. To set this, call start.

public final @IntRange(from = 0) int getBrushCoatCount()

Returns the number of BrushCoats for the current brush, or zero if start has not been called.

public final @IntRange(from = 0) int getInputCount()

Returns the number of StrokeInputs in the stroke so far. This counts all of the real inputs and the most-recently-processed sequence of predicted inputs.

public final @IntRange(from = 0) int getOutlineCount(@IntRange(from = 0) int coatIndex)

Returns the number of outlines for the specified brush coat.

Calls to functions that accept an outlineIndex must treat the result of this function as an upper bound. Coats with discontinuous geometry will always have multiple outlines, but even continuous geometry may be drawn with multiple overlapping outlines when this improves rendering quality or performance.

public final @IntRange(from = 0) int getOutlineVertexCount(
    @IntRange(from = 0) int coatIndex,
    @IntRange(from = 0) int outlineIndex
)

Returns the number of outline points for the specified outline and brush coat. populateOutlinePosition must treat the result of this as the upper bound of its outlineVertexIndex parameter.

public final @IntRange(from = 0) int getPredictedInputCount()

Returns the number of inputs in the current stroke prediction.

public final boolean isInputFinished()

Returns true if finishInput has been called since the last call to start, or if start hasn't been called yet. If this returns true, it is an error to call enqueueInputs.

public final boolean isUpdateNeeded()

Returns true if calling updateShape would have any effect on the stroke (and should thus be called before the next render), or false if no calls to updateShape are currently needed. Specifically:

• If the brush has one or more timed shape animation behavior that are still active (which can be true even after inputs are finished), returns true.

• If there are no active shape animation behaviors, but there are pending inputs from an enqueueInputs call that have not yet been consumed by a call to updateShape, returns true.

• Otherwise, returns false.

Once isInputFinished returns true and this method returns false, the stroke is considered "dry", and will not change any further until the next call to start.

public final @NonNull StrokeInput populateInput(@NonNull StrokeInput out, @IntRange(from = 0) int index)

Gets the value of the i-th input and overwrites out. Requires that index is positive and less than getInputCount.

Returns the passed-in StrokeInput to make it easier to chain calls.

public final @NonNull MutableStrokeInputBatch populateInputs(
    @NonNull MutableStrokeInputBatch out,
    @IntRange(from = 0) int from,
    @IntRange(from = 0) int to
)

Replace the contents of the MutableStrokeInputBatch with the specified range of inputs from the this InProgressStroke. By default, all inputs are copied.

Returns the passed-in MutableStrokeInputBatch to make it easier to chain calls.

public final @NonNull BoxAccumulator populateMeshBounds(
    @IntRange(from = 0) int coatIndex,
    @NonNull BoxAccumulator outMeshBounds
)

Writes to outBoxAccumulator the bounding box of the vertex positions of the mesh for brush coat coatIndex.

Returns the passed in BoxAccumulator to make it easier to chain calls.

public final @NonNull MutableVec populateOutlinePosition(
    @IntRange(from = 0) int coatIndex,
    @IntRange(from = 0) int outlineIndex,
    @IntRange(from = 0) int outlineVertexIndex,
    @NonNull MutableVec outPosition
)

Fills outPosition with the x and y coordinates of the specified outline vertex.

Returns the passed-in MutableVec to make it easier to chain calls.

public final @NonNull BoxAccumulator populateUpdatedRegion(@NonNull BoxAccumulator outUpdatedRegion)

Returns the bounding rectangle of mesh positions added, modified, or removed by calls to updateShape since the most recent call to start or resetUpdatedRegion.

Returns the passed in BoxAccumulator to make it easier to chain calls.

public final void resetUpdatedRegion()

Call after making use of a value from populateUpdatedRegion to reset the accumulation.

public final void start(@NonNull Brush brush)

Clears and starts a new stroke with the given brush.

This includes clearing or resetting any existing inputs, mesh data, and updated region. This method must be called at least once after construction before making any calls to enqueueInputs or updateShape.

public final @NonNull Stroke toImmutable()

Copies the current input, brush, and geometry as of the last call to start or updateShape to a new Stroke.

The resulting Stroke will not be modified if further inputs are added to this InProgressStroke, and a Stroke created by another call to this method will not modify or be connected in any way to the prior Stroke.

public final void updateShape(long currentElapsedTimeMillis)

Updates the stroke geometry up to the given duration since the start of the stroke. This will consume any inputs queued up by calls to enqueueInputs, and cause brush shape animations (if any) to progress up to the specified time. Any stroke geometry resulting from previously-predicted input from before the previous call to this method will be cleared.

This method requires that:

• start has been previously called to set the current brush.

• If passed, the value of currentElapsedTimeMillis passed into this method over the course of a single stroke must be non-decreasing and non-negative. To have shape animations progress at their intended rate, pass in values for this field that are in the same time base as the StrokeInput.elapsedTimeMillis values being passed to enqueueInputs, repeatedly until isInputFinished returns true.

Clients that do not use brushes with shape animation behaviors can omit currentElapsedTimeMillis. Doing so when using brushes with shape animation beaviors will cause the animation to be completed immediately.