org.distorted.library.type

Class Dynamic

java.lang.Object

org.distorted.library.type.Dynamic

Direct Known Subclasses:

Dynamic1D, Dynamic2D, Dynamic3D, Dynamic4D, Dynamic5D, DynamicQuat

public abstract class Dynamic
extends java.lang.Object

A class to interpolate between a list of Statics.

• if there is only one Point, just return it.
• if there are two Points, linearly bounce between them
• if there are more, interpolate a path between them. Exact way we interpolate depends on the MODE.

Field Summary

Fields

Modifier and Type	Field and Description
static int	ACCESS_TYPE_RANDOM The default mode of access.
static int	ACCESS_TYPE_SEQUENTIAL Set the mode to ACCESS_SEQUENTIAL if you need to change mDuration and you would rather have the Dynamic keep on smoothly interpolating.
static int	MODE_JUMP One revolution takes us from the first point to the last and jumps straight back to the first point.
static int	MODE_LOOP One revolution takes us from the first point to the last and back to first through the shortest path.
static int	MODE_PATH One revolution takes us from the first point to the last and back to first through the same path.

Method Summary

Methods

Modifier and Type	Method and Description
boolean	get(float[] buffer, int offset, long time, long step) Writes the results of interpolation between the Points at time 'time' to the passed float buffer.
float	getConvexity()
float	getCount() Return the number of revolutions this Dynamic will make.
int	getDimension() Return the Dimension, ie number of floats in a single Point this Dynamic interpolates through.
long	getDuration()
int	getNumPoints() Returns the number of Points this Dynamic has been fed with.
static void	onPause()
void	resetToBeginning() Start running from the beginning again.
void	setAccessType(int type) Sets the access type this Dynamic will be working in.
void	setConvexity(float convexity)
void	setCount(float count) Sets how many revolutions we want to do.
void	setDuration(long duration)
void	setMode(int mode) Sets the mode of the interpolation to Loop, Path or Jump.

Methods inherited from class java.lang.Object

equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

MODE_LOOP

public static final int MODE_LOOP

One revolution takes us from the first point to the last and back to first through the shortest path.

See Also:

Constant Field Values

MODE_PATH

public static final int MODE_PATH

One revolution takes us from the first point to the last and back to first through the same path.

See Also:

Constant Field Values

MODE_JUMP

public static final int MODE_JUMP

One revolution takes us from the first point to the last and jumps straight back to the first point.

See Also:

Constant Field Values

ACCESS_TYPE_RANDOM

public static final int ACCESS_TYPE_RANDOM

The default mode of access. When in this mode, we are able to call interpolate() with points in time in any random order. This means one single Dynamic can be used in many effects simultaneously. On the other hand, when in this mode, it is not possible to smoothly interpolate when mDuration suddenly changes.

See Also:

Constant Field Values

ACCESS_TYPE_SEQUENTIAL

public static final int ACCESS_TYPE_SEQUENTIAL

Set the mode to ACCESS_SEQUENTIAL if you need to change mDuration and you would rather have the Dynamic keep on smoothly interpolating. On the other hand, in this mode, a Dynamic can only be accessed in sequential manner, which means one Dynamic can only be used in one effect at a time.

See Also:

Constant Field Values

Method Detail

onPause

public static void onPause()

setMode

public void setMode(int mode)

Sets the mode of the interpolation to Loop, Path or Jump.

• Loop is when we go from the first point all the way to the last, and the back to the first through the shortest way.
• Path is when we come back from the last point back to the first the same way we got there.
• Jump is when we go from first to last and then jump straight back to the first.

Parameters:

mode - MODE_LOOP, MODE_PATH or MODE_JUMP.

getNumPoints

public int getNumPoints()

Returns the number of Points this Dynamic has been fed with.

Returns:

the number of Points we are currently interpolating through.

setCount

public void setCount(float count)

Sets how many revolutions we want to do.

Does not have to be an integer. What constitutes 'one revolution' depends on the MODE: MODE_LOOP, MODE_PATH or MODE_JUMP. Count<=0 means 'go on interpolating indefinitely'.

Parameters:

count - the number of times we want to interpolate between our collection of Points.

getCount

public float getCount()

Return the number of revolutions this Dynamic will make. What constitutes 'one revolution' depends on the MODE: MODE_LOOP, MODE_PATH or MODE_JUMP.

Returns:

the number revolutions this Dynamic will make.

resetToBeginning

public void resetToBeginning()

Start running from the beginning again. If a Dynamic has been used already, and we want to use it again and start interpolating from the first Point, first we need to reset it using this method.

setDuration

public void setDuration(long duration)

Parameters:

duration - Number of milliseconds one revolution will take. What constitutes 'one revolution' depends on the MODE: MODE_LOOP, MODE_PATH or MODE_JUMP.

getDuration

public long getDuration()

Returns:

Number of milliseconds one revolution will take.

setConvexity

public void setConvexity(float convexity)

Parameters:

convexity - If set to the default (1.0f) then interpolation between 4 points (1,0) (0,1) (-1,0) (0,-1) will be the natural circle centered at (0,0) with radius 1. The less it is, the less convex the circle becomes, ultimately when convexity=0.0f then the interpolation shape will be straight lines connecting the four points. Further setting this to negative values will make the shape concave. Valid values: all floats. (although probably only something around (0,2) actually makes sense)

getConvexity

public float getConvexity()

Returns:

See setConvexity(float)

setAccessType

public void setAccessType(int type)

Sets the access type this Dynamic will be working in.

Parameters:

type - ACCESS_TYPE_RANDOM or ACCESS_TYPE_SEQUENTIAL.

getDimension

public int getDimension()

Return the Dimension, ie number of floats in a single Point this Dynamic interpolates through.

Returns:

number of floats in a single Point (ie its dimension) contained in the Dynamic.

get

public boolean get(float[] buffer,
          int offset,
          long time,
          long step)

Writes the results of interpolation between the Points at time 'time' to the passed float buffer.

This version differs from the previous in that it returns a boolean value which indicates whether the interpolation is finished.

Parameters:

buffer - Float buffer we will write the results to.

offset - Offset in the buffer where to write the result.

time - Time of interpolation. Time=0.0 is the beginning of the first revolution, time=1.0 - the end of the first revolution, time=2.5 - the middle of the third revolution. What constitutes 'one revolution' depends on the MODE: MODE_LOOP, MODE_PATH or MODE_JUMP.

step - Time difference between now and the last time we called this function. Needed to figure out if the previous time we were called the effect wasn't finished yet, but now it is.

Returns:

true if the interpolation reached its end.