commit 814cfbc666aba78201baba51a013e1de682e2751 Author: leszek Date: Tue Apr 22 13:12:09 2025 +0200 Rename .java to .kt diff --git a/src/main/java/org/distorted/library/type/Data1D.java b/src/main/java/org/distorted/library/type/Data1D.java deleted file mode 100644 index b590475..0000000 --- a/src/main/java/org/distorted/library/type/Data1D.java +++ /dev/null @@ -1,32 +0,0 @@ -//////////////////////////////////////////////////////////////////////////////////////////////////// -// Copyright 2016 Leszek Koltunski leszek@koltunski.pl // -// // -// This file is part of Distorted. // -// // -// This library is free software; you can redistribute it and/or // -// modify it under the terms of the GNU Lesser General Public // -// License as published by the Free Software Foundation; either // -// version 2.1 of the License, or (at your option) any later version. // -// // -// This library is distributed in the hope that it will be useful, // -// but WITHOUT ANY WARRANTY; without even the implied warranty of // -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // -// Lesser General Public License for more details. // -// // -// You should have received a copy of the GNU Lesser General Public // -// License along with this library; if not, write to the Free Software // -// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA // -/////////////////////////////////////////////////////////////////////////////////////////////////// - -package org.distorted.library.type; - -/////////////////////////////////////////////////////////////////////////////////////////////////// -/** - * Marker Interface implemented by Static1D and Dynamic1D. - *

- * The point: so we can pass either Static and Dynamic to EffectQueues in a single parameter. - */ -public interface Data1D - { - boolean get(float[] buffer, int offset, long time, long step); - } diff --git a/src/main/java/org/distorted/library/type/Data1D.kt b/src/main/java/org/distorted/library/type/Data1D.kt new file mode 100644 index 0000000..b590475 --- /dev/null +++ b/src/main/java/org/distorted/library/type/Data1D.kt @@ -0,0 +1,32 @@ +//////////////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2016 Leszek Koltunski leszek@koltunski.pl // +// // +// This file is part of Distorted. // +// // +// This library is free software; you can redistribute it and/or // +// modify it under the terms of the GNU Lesser General Public // +// License as published by the Free Software Foundation; either // +// version 2.1 of the License, or (at your option) any later version. // +// // +// This library is distributed in the hope that it will be useful, // +// but WITHOUT ANY WARRANTY; without even the implied warranty of // +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // +// Lesser General Public License for more details. // +// // +// You should have received a copy of the GNU Lesser General Public // +// License along with this library; if not, write to the Free Software // +// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA // +/////////////////////////////////////////////////////////////////////////////////////////////////// + +package org.distorted.library.type; + +/////////////////////////////////////////////////////////////////////////////////////////////////// +/** + * Marker Interface implemented by Static1D and Dynamic1D. + *

+ * The point: so we can pass either Static and Dynamic to EffectQueues in a single parameter. + */ +public interface Data1D + { + boolean get(float[] buffer, int offset, long time, long step); + } diff --git a/src/main/java/org/distorted/library/type/Data2D.java b/src/main/java/org/distorted/library/type/Data2D.java deleted file mode 100644 index eab6d38..0000000 --- a/src/main/java/org/distorted/library/type/Data2D.java +++ /dev/null @@ -1,32 +0,0 @@ -//////////////////////////////////////////////////////////////////////////////////////////////////// -// Copyright 2016 Leszek Koltunski leszek@koltunski.pl // -// // -// This file is part of Distorted. // -// // -// This library is free software; you can redistribute it and/or // -// modify it under the terms of the GNU Lesser General Public // -// License as published by the Free Software Foundation; either // -// version 2.1 of the License, or (at your option) any later version. // -// // -// This library is distributed in the hope that it will be useful, // -// but WITHOUT ANY WARRANTY; without even the implied warranty of // -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // -// Lesser General Public License for more details. // -// // -// You should have received a copy of the GNU Lesser General Public // -// License along with this library; if not, write to the Free Software // -// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA // -/////////////////////////////////////////////////////////////////////////////////////////////////// - -package org.distorted.library.type; - -/////////////////////////////////////////////////////////////////////////////////////////////////// -/** - * Marker Interface implemented by Static2D and Dynamic2D. - *

- * The point: so we can pass either Static and Dynamic to EffectQueues in a single parameter. - */ -public interface Data2D - { - boolean get(float[] buffer, int offset, long time, long step); - } diff --git a/src/main/java/org/distorted/library/type/Data2D.kt b/src/main/java/org/distorted/library/type/Data2D.kt new file mode 100644 index 0000000..eab6d38 --- /dev/null +++ b/src/main/java/org/distorted/library/type/Data2D.kt @@ -0,0 +1,32 @@ +//////////////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2016 Leszek Koltunski leszek@koltunski.pl // +// // +// This file is part of Distorted. // +// // +// This library is free software; you can redistribute it and/or // +// modify it under the terms of the GNU Lesser General Public // +// License as published by the Free Software Foundation; either // +// version 2.1 of the License, or (at your option) any later version. // +// // +// This library is distributed in the hope that it will be useful, // +// but WITHOUT ANY WARRANTY; without even the implied warranty of // +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // +// Lesser General Public License for more details. // +// // +// You should have received a copy of the GNU Lesser General Public // +// License along with this library; if not, write to the Free Software // +// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA // +/////////////////////////////////////////////////////////////////////////////////////////////////// + +package org.distorted.library.type; + +/////////////////////////////////////////////////////////////////////////////////////////////////// +/** + * Marker Interface implemented by Static2D and Dynamic2D. + *

+ * The point: so we can pass either Static and Dynamic to EffectQueues in a single parameter. + */ +public interface Data2D + { + boolean get(float[] buffer, int offset, long time, long step); + } diff --git a/src/main/java/org/distorted/library/type/Data3D.java b/src/main/java/org/distorted/library/type/Data3D.java deleted file mode 100644 index aaf1178..0000000 --- a/src/main/java/org/distorted/library/type/Data3D.java +++ /dev/null @@ -1,32 +0,0 @@ -//////////////////////////////////////////////////////////////////////////////////////////////////// -// Copyright 2016 Leszek Koltunski leszek@koltunski.pl // -// // -// This file is part of Distorted. // -// // -// This library is free software; you can redistribute it and/or // -// modify it under the terms of the GNU Lesser General Public // -// License as published by the Free Software Foundation; either // -// version 2.1 of the License, or (at your option) any later version. // -// // -// This library is distributed in the hope that it will be useful, // -// but WITHOUT ANY WARRANTY; without even the implied warranty of // -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // -// Lesser General Public License for more details. // -// // -// You should have received a copy of the GNU Lesser General Public // -// License along with this library; if not, write to the Free Software // -// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA // -/////////////////////////////////////////////////////////////////////////////////////////////////// - -package org.distorted.library.type; - -/////////////////////////////////////////////////////////////////////////////////////////////////// -/** - * Marker Interface implemented by Static3D and Dynamic3D. - *

- * The point: so we can pass either Static and Dynamic to EffectQueues in a single parameter. - */ -public interface Data3D - { - boolean get(float[] buffer, int offset, long time, long step); - } diff --git a/src/main/java/org/distorted/library/type/Data3D.kt b/src/main/java/org/distorted/library/type/Data3D.kt new file mode 100644 index 0000000..aaf1178 --- /dev/null +++ b/src/main/java/org/distorted/library/type/Data3D.kt @@ -0,0 +1,32 @@ +//////////////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2016 Leszek Koltunski leszek@koltunski.pl // +// // +// This file is part of Distorted. // +// // +// This library is free software; you can redistribute it and/or // +// modify it under the terms of the GNU Lesser General Public // +// License as published by the Free Software Foundation; either // +// version 2.1 of the License, or (at your option) any later version. // +// // +// This library is distributed in the hope that it will be useful, // +// but WITHOUT ANY WARRANTY; without even the implied warranty of // +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // +// Lesser General Public License for more details. // +// // +// You should have received a copy of the GNU Lesser General Public // +// License along with this library; if not, write to the Free Software // +// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA // +/////////////////////////////////////////////////////////////////////////////////////////////////// + +package org.distorted.library.type; + +/////////////////////////////////////////////////////////////////////////////////////////////////// +/** + * Marker Interface implemented by Static3D and Dynamic3D. + *

+ * The point: so we can pass either Static and Dynamic to EffectQueues in a single parameter. + */ +public interface Data3D + { + boolean get(float[] buffer, int offset, long time, long step); + } diff --git a/src/main/java/org/distorted/library/type/Data4D.java b/src/main/java/org/distorted/library/type/Data4D.java deleted file mode 100644 index 7539508..0000000 --- a/src/main/java/org/distorted/library/type/Data4D.java +++ /dev/null @@ -1,32 +0,0 @@ -//////////////////////////////////////////////////////////////////////////////////////////////////// -// Copyright 2016 Leszek Koltunski leszek@koltunski.pl // -// // -// This file is part of Distorted. // -// // -// This library is free software; you can redistribute it and/or // -// modify it under the terms of the GNU Lesser General Public // -// License as published by the Free Software Foundation; either // -// version 2.1 of the License, or (at your option) any later version. // -// // -// This library is distributed in the hope that it will be useful, // -// but WITHOUT ANY WARRANTY; without even the implied warranty of // -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // -// Lesser General Public License for more details. // -// // -// You should have received a copy of the GNU Lesser General Public // -// License along with this library; if not, write to the Free Software // -// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA // -/////////////////////////////////////////////////////////////////////////////////////////////////// - -package org.distorted.library.type; - -/////////////////////////////////////////////////////////////////////////////////////////////////// -/** - * Marker Interface implemented by Static4D, Dynamic4D and DynamicQuat. - *

- * The point: so we can pass either Static and Dynamic to EffectQueues in a single parameter. - */ -public interface Data4D - { - boolean get(float[] buffer, int offset, long time, long step); - } diff --git a/src/main/java/org/distorted/library/type/Data4D.kt b/src/main/java/org/distorted/library/type/Data4D.kt new file mode 100644 index 0000000..7539508 --- /dev/null +++ b/src/main/java/org/distorted/library/type/Data4D.kt @@ -0,0 +1,32 @@ +//////////////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2016 Leszek Koltunski leszek@koltunski.pl // +// // +// This file is part of Distorted. // +// // +// This library is free software; you can redistribute it and/or // +// modify it under the terms of the GNU Lesser General Public // +// License as published by the Free Software Foundation; either // +// version 2.1 of the License, or (at your option) any later version. // +// // +// This library is distributed in the hope that it will be useful, // +// but WITHOUT ANY WARRANTY; without even the implied warranty of // +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // +// Lesser General Public License for more details. // +// // +// You should have received a copy of the GNU Lesser General Public // +// License along with this library; if not, write to the Free Software // +// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA // +/////////////////////////////////////////////////////////////////////////////////////////////////// + +package org.distorted.library.type; + +/////////////////////////////////////////////////////////////////////////////////////////////////// +/** + * Marker Interface implemented by Static4D, Dynamic4D and DynamicQuat. + *

+ * The point: so we can pass either Static and Dynamic to EffectQueues in a single parameter. + */ +public interface Data4D + { + boolean get(float[] buffer, int offset, long time, long step); + } diff --git a/src/main/java/org/distorted/library/type/Data5D.java b/src/main/java/org/distorted/library/type/Data5D.java deleted file mode 100644 index 2905e17..0000000 --- a/src/main/java/org/distorted/library/type/Data5D.java +++ /dev/null @@ -1,32 +0,0 @@ -//////////////////////////////////////////////////////////////////////////////////////////////////// -// Copyright 2016 Leszek Koltunski leszek@koltunski.pl // -// // -// This file is part of Distorted. // -// // -// This library is free software; you can redistribute it and/or // -// modify it under the terms of the GNU Lesser General Public // -// License as published by the Free Software Foundation; either // -// version 2.1 of the License, or (at your option) any later version. // -// // -// This library is distributed in the hope that it will be useful, // -// but WITHOUT ANY WARRANTY; without even the implied warranty of // -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // -// Lesser General Public License for more details. // -// // -// You should have received a copy of the GNU Lesser General Public // -// License along with this library; if not, write to the Free Software // -// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA // -/////////////////////////////////////////////////////////////////////////////////////////////////// - -package org.distorted.library.type; - -/////////////////////////////////////////////////////////////////////////////////////////////////// -/** - * Marker Interface implemented by Static5D and Dynamic5D. - *

- * The point: so we can pass either Static and Dynamic to EffectQueues in a single parameter. - */ -public interface Data5D - { - boolean get(float[] buffer, int offset, long time, long step); - } diff --git a/src/main/java/org/distorted/library/type/Data5D.kt b/src/main/java/org/distorted/library/type/Data5D.kt new file mode 100644 index 0000000..2905e17 --- /dev/null +++ b/src/main/java/org/distorted/library/type/Data5D.kt @@ -0,0 +1,32 @@ +//////////////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2016 Leszek Koltunski leszek@koltunski.pl // +// // +// This file is part of Distorted. // +// // +// This library is free software; you can redistribute it and/or // +// modify it under the terms of the GNU Lesser General Public // +// License as published by the Free Software Foundation; either // +// version 2.1 of the License, or (at your option) any later version. // +// // +// This library is distributed in the hope that it will be useful, // +// but WITHOUT ANY WARRANTY; without even the implied warranty of // +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // +// Lesser General Public License for more details. // +// // +// You should have received a copy of the GNU Lesser General Public // +// License along with this library; if not, write to the Free Software // +// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA // +/////////////////////////////////////////////////////////////////////////////////////////////////// + +package org.distorted.library.type; + +/////////////////////////////////////////////////////////////////////////////////////////////////// +/** + * Marker Interface implemented by Static5D and Dynamic5D. + *

+ * The point: so we can pass either Static and Dynamic to EffectQueues in a single parameter. + */ +public interface Data5D + { + boolean get(float[] buffer, int offset, long time, long step); + } diff --git a/src/main/java/org/distorted/library/type/Dynamic.java b/src/main/java/org/distorted/library/type/Dynamic.java deleted file mode 100644 index 124cdb7..0000000 --- a/src/main/java/org/distorted/library/type/Dynamic.java +++ /dev/null @@ -1,888 +0,0 @@ -//////////////////////////////////////////////////////////////////////////////////////////////////// -// Copyright 2016 Leszek Koltunski leszek@koltunski.pl // -// // -// This file is part of Distorted. // -// // -// This library is free software; you can redistribute it and/or // -// modify it under the terms of the GNU Lesser General Public // -// License as published by the Free Software Foundation; either // -// version 2.1 of the License, or (at your option) any later version. // -// // -// This library is distributed in the hope that it will be useful, // -// but WITHOUT ANY WARRANTY; without even the implied warranty of // -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // -// Lesser General Public License for more details. // -// // -// You should have received a copy of the GNU Lesser General Public // -// License along with this library; if not, write to the Free Software // -// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA // -/////////////////////////////////////////////////////////////////////////////////////////////////// - -package org.distorted.library.type; - -import org.distorted.library.main.DistortedLibrary; - -import java.util.Random; -import java.util.Vector; - -/////////////////////////////////////////////////////////////////////////////////////////////////// -/** A class to interpolate between a list of Statics. -*

-*/ - -// The way Interpolation between more than 2 Points is done: -// -// Def: let V[i] = (V[i](x), V[i](y), V[i](z)) be the direction and speed (i.e. velocity) we have to -// be flying at Point P[i] -// -// Time it takes to fly though one segment P[i] --> P[i+1] : 0.0 --> 1.0 -// -// We arbitrarily decide that V[i] should be equal to (|curr|*prev + |prev|*curr) / min(|prev|,|curr|) -// where prev = P[i]-P[i-1] and curr = P[i+1]-P[i] -// -// Given that the flight route (X(t), Y(t), Z(t)) from P(i) to P(i+1) (0<=t<=1) has to satisfy -// X(0) = P[i ](x), Y(0)=P[i ](y), Z(0)=P[i ](z), X'(0) = V[i ](x), Y'(0) = V[i ](y), Z'(0) = V[i ](z) -// X(1) = P[i+1](x), Y(1)=P[i+1](y), Z(1)=P[i+1](z), X'(1) = V[i+1](x), Y'(1) = V[i+1](y), Z'(1) = V[i+1](z) -// -// we have the solution: X(t) = at^3 + bt^2 + ct + d where -// a = 2*P[i](x) + V[i](x) - 2*P[i+1](x) + V[i+1](x) -// b = -3*P[i](x) - 2*V[i](x) + 3*P[i+1](x) - V[i+1](x) -// c = V[i](x) -// d = P[i](x) -// -// and similarly Y(t) and Z(t). - -public abstract class Dynamic - { - /** - * Keep the speed of interpolation always changing. Time to cover one segment (distance between - * two consecutive points) always the same. Smoothly interpolate the speed between two segments. - */ - public static final int SPEED_MODE_SMOOTH = 0; - /** - * Make each segment have constant speed. Time to cover each segment is still the same, thus the - * speed will jump when passing through a point and then keep constant. - */ - public static final int SPEED_MODE_SEGMENT_CONSTANT = 1; - /** - * Have the speed be always, globally the same across all segments. Time to cover one segment will - * thus generally no longer be the same. - */ - public static final int SPEED_MODE_GLOBALLY_CONSTANT = 2; // TODO: not supported yet - - /** - * One revolution takes us from the first point to the last and back to first through the shortest path. - */ - public static final int MODE_LOOP = 0; - /** - * One revolution takes us from the first point to the last and back to first through the same path. - */ - public static final int MODE_PATH = 1; - /** - * One revolution takes us from the first point to the last and jumps straight back to the first point. - */ - public static final int MODE_JUMP = 2; - - /** - * 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. - */ - public static final int ACCESS_TYPE_RANDOM = 0; - /** - * 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. - */ - public static final int ACCESS_TYPE_SEQUENTIAL = 1; - - protected int mDimension; - protected int numPoints; - protected int mSegment; // between which pair of points are we currently? (in case of PATH this is a bit complicated!) - protected boolean cacheDirty; // VectorCache not up to date - protected int mMode; // LOOP, PATH or JUMP - protected long mDuration; // number of milliseconds it takes to do a full loop/path from first vector to the last and back to the first - protected float mCount; // number of loops/paths we will do; mCount = 1.5 means we go from the first vector to the last, back to first, and to the last again. - protected double mLastPos; - protected int mAccessType; - protected int mSpeedMode; - protected float mTmpTime; - protected int mTmpVec, mTmpSeg; - - protected class VectorNoise - { - float[][] n; - - VectorNoise() - { - n = new float[mDimension][NUM_NOISE]; - } - - void computeNoise() - { - n[0][0] = mRnd.nextFloat(); - for(int i=1; i vn; - protected float[] mFactor; - protected float[] mNoise; - protected float[][] baseV; - - /////////////////////////////////////////////////////////////////////////////////////////////////// - // the coefficients of the X(t), Y(t) and Z(t) polynomials: X(t) = a[0]*T^3 + b[0]*T^2 + c[0]*t + d[0] etc. - // (velocity) is the velocity vector. - // (cached) is the original vector from vv (copied here so when interpolating we can see if it is - // still valid and if not - rebuild the Cache - - protected class VectorCache - { - float[] a; - float[] b; - float[] c; - float[] d; - float[] velocity; - float[] cached; - float[] path_ratio; - - VectorCache() - { - a = new float[mDimension]; - b = new float[mDimension]; - c = new float[mDimension]; - d = new float[mDimension]; - - velocity = new float[mDimension]; - cached = new float[mDimension]; - path_ratio = new float[NUM_RATIO]; - } - } - - protected Vector vc; - protected VectorCache tmpCache1, tmpCache2; - protected float mConvexity; - - private static final int NUM_RATIO = 10; // we attempt to 'smooth out' the speed in each segment - - // remember this many 'points' inside the Cache for each segment. - - protected static final float[] mTmpRatio = new float[NUM_RATIO]; - - private float[] buf; - private float[] old; - private static final Random mRnd = new Random(); - private static final int NUM_NOISE = 5; // used iff mNoise>0.0. Number of intermediary points between each pair of adjacent vectors - // where we randomize noise factors to make the way between the two vectors not so smooth. - private long mStartTime; - private long mCorrectedTime; - private static long mPausedTime; - -/////////////////////////////////////////////////////////////////////////////////////////////////// -// hide this from Javadoc - - protected Dynamic() - { - - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - protected Dynamic(int duration, float count, int dimension) - { - vc = new Vector<>(); - vn = null; - numPoints = 0; - cacheDirty = false; - mMode = MODE_LOOP; - mDuration = duration; - mCount = count; - mDimension = dimension; - mSegment = -1; - mLastPos = -1; - mAccessType= ACCESS_TYPE_RANDOM; - mSpeedMode = SPEED_MODE_SMOOTH; - mConvexity = 1.0f; - mStartTime = -1; - mCorrectedTime = 0; - - baseV = new float[mDimension][mDimension]; - buf = new float[mDimension]; - old = new float[mDimension]; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - void initDynamic() - { - mStartTime = -1; - mCorrectedTime = 0; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - public static void onPause() - { - mPausedTime = System.currentTimeMillis(); - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - protected void computeSegmentAndTime(float time) - { - switch(mMode) - { - case MODE_LOOP: mTmpTime= time*numPoints; - mTmpSeg = (int)mTmpTime; - mTmpVec = mTmpSeg; - break; - case MODE_PATH: mTmpSeg = (int)(2*time*(numPoints-1)); - - if( time<=0.5f ) // this has to be <= (otherwise when effect ends at t=0.5, then time=1.0 - { // and end position is slightly not equal to the end point => might not get autodeleted! - mTmpTime = 2*time*(numPoints-1); - mTmpVec = mTmpSeg; - } - else - { - mTmpTime = 2*(1-time)*(numPoints-1); - mTmpVec = 2*numPoints-3-mTmpSeg; - } - break; - case MODE_JUMP: mTmpTime= time*(numPoints-1); - mTmpSeg = (int)mTmpTime; - mTmpVec = mTmpSeg; - break; - default : mTmpVec = 0; - mTmpSeg = 0; - } - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - private float valueAtPoint(float t, VectorCache cache) - { - float tmp,sum = 0.0f; - - for(int d=0; d=NUM_NOISE+1 ) index=NUM_NOISE; - VectorNoise tmpN = vn.elementAt(vecNum); - - float t = d-index; - t = t*t*(3-2*t); - - switch(index) - { - case 0 : for(int i=0;i1.05f ) - { - DistortedLibrary.logMessage("Dynamic: length of vector "+i+" : "+Math.sqrt(len[i])); - error = true; - } - } - - for(int i=0; i 0.05f || cosA < -0.05f ) - { - DistortedLibrary.logMessage("Dynamic: cos angle between vectors "+i+" and "+j+" : "+cosA); - error = true; - } - } - - if( error ) printBase(""); - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - int getNext(int curr, float time) - { - switch(mMode) - { - case MODE_LOOP: return curr==numPoints-1 ? 0:curr+1; - case MODE_PATH: return time<0.5f ? (curr+1) : (curr==0 ? 1 : curr-1); - case MODE_JUMP: return curr==numPoints-1 ? 1:curr+1; - default : return 0; - } - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - private void checkAngle(int index) - { - float cosA = 0.0f; - - for(int k=0;k2 (sad corollary from the Hairy Ball Theorem) -// but we don't care - we are travelling along a straight line, so velocity (aka baseV[0]!) does -// not change. -// c) we may be interpolating through more than 2 points. Then interpolation formulas ensure the path -// will never be a straight line, even locally -> we can pass in baseV[0] and baseV[1] the velocity -// and the acceleration (first and second derivatives of the path) which are then guaranteed to be -// linearly independent. Then we can ensure this is continuous in dimensions <=4. This leaves -// dimension 5 (ATM WAVE is 5-dimensional) discontinuous -> WAVE will suffer from chaotic noise. -// -// Bear in mind here the 'normal' in 'orthonormal' means 'length equal to the length of the original -// velocity vector' (rather than the standard 1) - - protected void computeOrthonormalBase() - { - int last_non_zero=-1; - float tmp; - - for(int i=0; i two - for(int i=0; i no noise, - baseV[i+1][j]= 0.0f; // set the base to 0 vectors. - } /// - else - { - for(int i=1; i=2 ) // b[0] = b[0] - { // b[1] = b[1] - (/)*b[0] - old[k] = baseV[i][k]; // b[2] = b[2] - (/)*b[0] - (/)*b[1] - baseV[i][k]= (k==i-(last_non_zero>=i?1:0)) ? 1.0f : 0.0f; // b[3] = b[3] - (/)*b[0] - (/)*b[1] - (/)*b[2] - } // (...) - // then b[i] = b[i] / |b[i]| ( Here really b[i] = b[i] / (|b[0]|/|b[i]|) - tmp = baseV[i-1][k]; // - buf[i-1] += tmp*tmp; // - } // - // - for(int j=0; j - *
  • 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. - * - * - * @param mode {@link Dynamic#MODE_LOOP}, {@link Dynamic#MODE_PATH} or {@link Dynamic#MODE_JUMP}. - */ - public void setMode(int mode) - { - mMode = mode; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// -/** - * Returns the number of Points this Dynamic has been fed with. - * - * @return the number of Points we are currently interpolating through. - */ - public synchronized int getNumPoints() - { - return numPoints; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// -/** - * Sets how many revolutions we want to do. - *

    - * Does not have to be an integer. What constitutes 'one revolution' depends on the MODE: - * {@link Dynamic#MODE_LOOP}, {@link Dynamic#MODE_PATH} or {@link Dynamic#MODE_JUMP}. - * Count<=0 means 'go on interpolating indefinitely'. - * - * @param count the number of times we want to interpolate between our collection of Points. - */ - public void setCount(float count) - { - mCount = count; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// -/** - * Return the number of revolutions this Dynamic will make. - * What constitutes 'one revolution' depends on the MODE: - * {@link Dynamic#MODE_LOOP}, {@link Dynamic#MODE_PATH} or {@link Dynamic#MODE_JUMP}. - * - * @return the number revolutions this Dynamic will make. - */ - public float getCount() - { - return mCount; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// -/** - * 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. - */ - public void resetToBeginning() - { - mStartTime = -1; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// -/** - * @param duration Number of milliseconds one revolution will take. - * What constitutes 'one revolution' depends on the MODE: - * {@link Dynamic#MODE_LOOP}, {@link Dynamic#MODE_PATH} or {@link Dynamic#MODE_JUMP}. - */ - public void setDuration(long duration) - { - mDuration = duration; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// -/** - * @return Number of milliseconds one revolution will take. - */ - public long getDuration() - { - return mDuration; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// -/** - * @param 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) - */ - public void setConvexity(float convexity) - { - if( mConvexity!=convexity ) - { - mConvexity = convexity; - cacheDirty = true; - } - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// -/** - * @return See {@link Dynamic#setConvexity(float)} - */ - public float getConvexity() - { - return mConvexity; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// -/** - * Sets the access type this Dynamic will be working in. - * - * @param type {@link Dynamic#ACCESS_TYPE_RANDOM} or {@link Dynamic#ACCESS_TYPE_SEQUENTIAL}. - */ - public void setAccessType(int type) - { - mAccessType = type; - mLastPos = -1; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// -/** - * @return See {@link Dynamic#setSpeedMode(int)} - */ - public float getSpeedMode() - { - return mSpeedMode; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// -/** - * Sets the way we compute the interpolation speed. - * - * @param mode {@link Dynamic#SPEED_MODE_SMOOTH} or {@link Dynamic#SPEED_MODE_SEGMENT_CONSTANT} or - * {@link Dynamic#SPEED_MODE_GLOBALLY_CONSTANT} - */ - public void setSpeedMode(int mode) - { - if( mSpeedMode!=mode ) - { - if( mSpeedMode==SPEED_MODE_SMOOTH ) - { - for(int i=0; i - * This version differs from the previous in that it returns a boolean value which indicates whether - * the interpolation is finished. - * - * @param buffer Float buffer we will write the results to. - * @param offset Offset in the buffer where to write the result. - * @param 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: - * {@link Dynamic#MODE_LOOP}, {@link Dynamic#MODE_PATH} or {@link Dynamic#MODE_JUMP}. - * @param 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. - * @return true if the interpolation reached its end. - */ - public boolean get(float[] buffer, int offset, long time, long step) - { - if( mDuration<=0.0f ) - { - interpolate(buffer,offset,mCount-(int)mCount); - return false; - } - - if( mStartTime==-1 ) - { - mStartTime = time; - mLastPos = -1; - } - - long diff = time-mPausedTime; - - if( mStartTime=0 && diff<=step ) - { - mCorrectedTime = mPausedTime; - mStartTime += diff; - step -= diff; - } - - time -= mStartTime; - - if( time+step > mDuration*mCount && mCount>0.0f ) - { - interpolate(buffer,offset,mCount-(int)mCount); - return true; - } - - double pos; - - if( mAccessType ==ACCESS_TYPE_SEQUENTIAL ) - { - pos = mLastPos<0 ? (double)time/mDuration : (double)step/mDuration + mLastPos; - mLastPos = pos; - } - else - { - pos = (double)time/mDuration; - } - - interpolate(buffer,offset, (float)(pos-(int)pos) ); - return false; - } - } diff --git a/src/main/java/org/distorted/library/type/Dynamic.kt b/src/main/java/org/distorted/library/type/Dynamic.kt new file mode 100644 index 0000000..124cdb7 --- /dev/null +++ b/src/main/java/org/distorted/library/type/Dynamic.kt @@ -0,0 +1,888 @@ +//////////////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2016 Leszek Koltunski leszek@koltunski.pl // +// // +// This file is part of Distorted. // +// // +// This library is free software; you can redistribute it and/or // +// modify it under the terms of the GNU Lesser General Public // +// License as published by the Free Software Foundation; either // +// version 2.1 of the License, or (at your option) any later version. // +// // +// This library is distributed in the hope that it will be useful, // +// but WITHOUT ANY WARRANTY; without even the implied warranty of // +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // +// Lesser General Public License for more details. // +// // +// You should have received a copy of the GNU Lesser General Public // +// License along with this library; if not, write to the Free Software // +// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA // +/////////////////////////////////////////////////////////////////////////////////////////////////// + +package org.distorted.library.type; + +import org.distorted.library.main.DistortedLibrary; + +import java.util.Random; +import java.util.Vector; + +/////////////////////////////////////////////////////////////////////////////////////////////////// +/** 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. +*
    +*/ + +// The way Interpolation between more than 2 Points is done: +// +// Def: let V[i] = (V[i](x), V[i](y), V[i](z)) be the direction and speed (i.e. velocity) we have to +// be flying at Point P[i] +// +// Time it takes to fly though one segment P[i] --> P[i+1] : 0.0 --> 1.0 +// +// We arbitrarily decide that V[i] should be equal to (|curr|*prev + |prev|*curr) / min(|prev|,|curr|) +// where prev = P[i]-P[i-1] and curr = P[i+1]-P[i] +// +// Given that the flight route (X(t), Y(t), Z(t)) from P(i) to P(i+1) (0<=t<=1) has to satisfy +// X(0) = P[i ](x), Y(0)=P[i ](y), Z(0)=P[i ](z), X'(0) = V[i ](x), Y'(0) = V[i ](y), Z'(0) = V[i ](z) +// X(1) = P[i+1](x), Y(1)=P[i+1](y), Z(1)=P[i+1](z), X'(1) = V[i+1](x), Y'(1) = V[i+1](y), Z'(1) = V[i+1](z) +// +// we have the solution: X(t) = at^3 + bt^2 + ct + d where +// a = 2*P[i](x) + V[i](x) - 2*P[i+1](x) + V[i+1](x) +// b = -3*P[i](x) - 2*V[i](x) + 3*P[i+1](x) - V[i+1](x) +// c = V[i](x) +// d = P[i](x) +// +// and similarly Y(t) and Z(t). + +public abstract class Dynamic + { + /** + * Keep the speed of interpolation always changing. Time to cover one segment (distance between + * two consecutive points) always the same. Smoothly interpolate the speed between two segments. + */ + public static final int SPEED_MODE_SMOOTH = 0; + /** + * Make each segment have constant speed. Time to cover each segment is still the same, thus the + * speed will jump when passing through a point and then keep constant. + */ + public static final int SPEED_MODE_SEGMENT_CONSTANT = 1; + /** + * Have the speed be always, globally the same across all segments. Time to cover one segment will + * thus generally no longer be the same. + */ + public static final int SPEED_MODE_GLOBALLY_CONSTANT = 2; // TODO: not supported yet + + /** + * One revolution takes us from the first point to the last and back to first through the shortest path. + */ + public static final int MODE_LOOP = 0; + /** + * One revolution takes us from the first point to the last and back to first through the same path. + */ + public static final int MODE_PATH = 1; + /** + * One revolution takes us from the first point to the last and jumps straight back to the first point. + */ + public static final int MODE_JUMP = 2; + + /** + * 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. + */ + public static final int ACCESS_TYPE_RANDOM = 0; + /** + * 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. + */ + public static final int ACCESS_TYPE_SEQUENTIAL = 1; + + protected int mDimension; + protected int numPoints; + protected int mSegment; // between which pair of points are we currently? (in case of PATH this is a bit complicated!) + protected boolean cacheDirty; // VectorCache not up to date + protected int mMode; // LOOP, PATH or JUMP + protected long mDuration; // number of milliseconds it takes to do a full loop/path from first vector to the last and back to the first + protected float mCount; // number of loops/paths we will do; mCount = 1.5 means we go from the first vector to the last, back to first, and to the last again. + protected double mLastPos; + protected int mAccessType; + protected int mSpeedMode; + protected float mTmpTime; + protected int mTmpVec, mTmpSeg; + + protected class VectorNoise + { + float[][] n; + + VectorNoise() + { + n = new float[mDimension][NUM_NOISE]; + } + + void computeNoise() + { + n[0][0] = mRnd.nextFloat(); + for(int i=1; i vn; + protected float[] mFactor; + protected float[] mNoise; + protected float[][] baseV; + + /////////////////////////////////////////////////////////////////////////////////////////////////// + // the coefficients of the X(t), Y(t) and Z(t) polynomials: X(t) = a[0]*T^3 + b[0]*T^2 + c[0]*t + d[0] etc. + // (velocity) is the velocity vector. + // (cached) is the original vector from vv (copied here so when interpolating we can see if it is + // still valid and if not - rebuild the Cache + + protected class VectorCache + { + float[] a; + float[] b; + float[] c; + float[] d; + float[] velocity; + float[] cached; + float[] path_ratio; + + VectorCache() + { + a = new float[mDimension]; + b = new float[mDimension]; + c = new float[mDimension]; + d = new float[mDimension]; + + velocity = new float[mDimension]; + cached = new float[mDimension]; + path_ratio = new float[NUM_RATIO]; + } + } + + protected Vector vc; + protected VectorCache tmpCache1, tmpCache2; + protected float mConvexity; + + private static final int NUM_RATIO = 10; // we attempt to 'smooth out' the speed in each segment - + // remember this many 'points' inside the Cache for each segment. + + protected static final float[] mTmpRatio = new float[NUM_RATIO]; + + private float[] buf; + private float[] old; + private static final Random mRnd = new Random(); + private static final int NUM_NOISE = 5; // used iff mNoise>0.0. Number of intermediary points between each pair of adjacent vectors + // where we randomize noise factors to make the way between the two vectors not so smooth. + private long mStartTime; + private long mCorrectedTime; + private static long mPausedTime; + +/////////////////////////////////////////////////////////////////////////////////////////////////// +// hide this from Javadoc + + protected Dynamic() + { + + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + protected Dynamic(int duration, float count, int dimension) + { + vc = new Vector<>(); + vn = null; + numPoints = 0; + cacheDirty = false; + mMode = MODE_LOOP; + mDuration = duration; + mCount = count; + mDimension = dimension; + mSegment = -1; + mLastPos = -1; + mAccessType= ACCESS_TYPE_RANDOM; + mSpeedMode = SPEED_MODE_SMOOTH; + mConvexity = 1.0f; + mStartTime = -1; + mCorrectedTime = 0; + + baseV = new float[mDimension][mDimension]; + buf = new float[mDimension]; + old = new float[mDimension]; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + void initDynamic() + { + mStartTime = -1; + mCorrectedTime = 0; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + public static void onPause() + { + mPausedTime = System.currentTimeMillis(); + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + protected void computeSegmentAndTime(float time) + { + switch(mMode) + { + case MODE_LOOP: mTmpTime= time*numPoints; + mTmpSeg = (int)mTmpTime; + mTmpVec = mTmpSeg; + break; + case MODE_PATH: mTmpSeg = (int)(2*time*(numPoints-1)); + + if( time<=0.5f ) // this has to be <= (otherwise when effect ends at t=0.5, then time=1.0 + { // and end position is slightly not equal to the end point => might not get autodeleted! + mTmpTime = 2*time*(numPoints-1); + mTmpVec = mTmpSeg; + } + else + { + mTmpTime = 2*(1-time)*(numPoints-1); + mTmpVec = 2*numPoints-3-mTmpSeg; + } + break; + case MODE_JUMP: mTmpTime= time*(numPoints-1); + mTmpSeg = (int)mTmpTime; + mTmpVec = mTmpSeg; + break; + default : mTmpVec = 0; + mTmpSeg = 0; + } + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + private float valueAtPoint(float t, VectorCache cache) + { + float tmp,sum = 0.0f; + + for(int d=0; d=NUM_NOISE+1 ) index=NUM_NOISE; + VectorNoise tmpN = vn.elementAt(vecNum); + + float t = d-index; + t = t*t*(3-2*t); + + switch(index) + { + case 0 : for(int i=0;i1.05f ) + { + DistortedLibrary.logMessage("Dynamic: length of vector "+i+" : "+Math.sqrt(len[i])); + error = true; + } + } + + for(int i=0; i 0.05f || cosA < -0.05f ) + { + DistortedLibrary.logMessage("Dynamic: cos angle between vectors "+i+" and "+j+" : "+cosA); + error = true; + } + } + + if( error ) printBase(""); + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + int getNext(int curr, float time) + { + switch(mMode) + { + case MODE_LOOP: return curr==numPoints-1 ? 0:curr+1; + case MODE_PATH: return time<0.5f ? (curr+1) : (curr==0 ? 1 : curr-1); + case MODE_JUMP: return curr==numPoints-1 ? 1:curr+1; + default : return 0; + } + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + private void checkAngle(int index) + { + float cosA = 0.0f; + + for(int k=0;k2 (sad corollary from the Hairy Ball Theorem) +// but we don't care - we are travelling along a straight line, so velocity (aka baseV[0]!) does +// not change. +// c) we may be interpolating through more than 2 points. Then interpolation formulas ensure the path +// will never be a straight line, even locally -> we can pass in baseV[0] and baseV[1] the velocity +// and the acceleration (first and second derivatives of the path) which are then guaranteed to be +// linearly independent. Then we can ensure this is continuous in dimensions <=4. This leaves +// dimension 5 (ATM WAVE is 5-dimensional) discontinuous -> WAVE will suffer from chaotic noise. +// +// Bear in mind here the 'normal' in 'orthonormal' means 'length equal to the length of the original +// velocity vector' (rather than the standard 1) + + protected void computeOrthonormalBase() + { + int last_non_zero=-1; + float tmp; + + for(int i=0; i two + for(int i=0; i no noise, + baseV[i+1][j]= 0.0f; // set the base to 0 vectors. + } /// + else + { + for(int i=1; i=2 ) // b[0] = b[0] + { // b[1] = b[1] - (/)*b[0] + old[k] = baseV[i][k]; // b[2] = b[2] - (/)*b[0] - (/)*b[1] + baseV[i][k]= (k==i-(last_non_zero>=i?1:0)) ? 1.0f : 0.0f; // b[3] = b[3] - (/)*b[0] - (/)*b[1] - (/)*b[2] + } // (...) + // then b[i] = b[i] / |b[i]| ( Here really b[i] = b[i] / (|b[0]|/|b[i]|) + tmp = baseV[i-1][k]; // + buf[i-1] += tmp*tmp; // + } // + // + for(int j=0; j + *
  • 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. + * + * + * @param mode {@link Dynamic#MODE_LOOP}, {@link Dynamic#MODE_PATH} or {@link Dynamic#MODE_JUMP}. + */ + public void setMode(int mode) + { + mMode = mode; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// +/** + * Returns the number of Points this Dynamic has been fed with. + * + * @return the number of Points we are currently interpolating through. + */ + public synchronized int getNumPoints() + { + return numPoints; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// +/** + * Sets how many revolutions we want to do. + *

    + * Does not have to be an integer. What constitutes 'one revolution' depends on the MODE: + * {@link Dynamic#MODE_LOOP}, {@link Dynamic#MODE_PATH} or {@link Dynamic#MODE_JUMP}. + * Count<=0 means 'go on interpolating indefinitely'. + * + * @param count the number of times we want to interpolate between our collection of Points. + */ + public void setCount(float count) + { + mCount = count; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// +/** + * Return the number of revolutions this Dynamic will make. + * What constitutes 'one revolution' depends on the MODE: + * {@link Dynamic#MODE_LOOP}, {@link Dynamic#MODE_PATH} or {@link Dynamic#MODE_JUMP}. + * + * @return the number revolutions this Dynamic will make. + */ + public float getCount() + { + return mCount; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// +/** + * 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. + */ + public void resetToBeginning() + { + mStartTime = -1; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// +/** + * @param duration Number of milliseconds one revolution will take. + * What constitutes 'one revolution' depends on the MODE: + * {@link Dynamic#MODE_LOOP}, {@link Dynamic#MODE_PATH} or {@link Dynamic#MODE_JUMP}. + */ + public void setDuration(long duration) + { + mDuration = duration; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// +/** + * @return Number of milliseconds one revolution will take. + */ + public long getDuration() + { + return mDuration; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// +/** + * @param 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) + */ + public void setConvexity(float convexity) + { + if( mConvexity!=convexity ) + { + mConvexity = convexity; + cacheDirty = true; + } + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// +/** + * @return See {@link Dynamic#setConvexity(float)} + */ + public float getConvexity() + { + return mConvexity; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// +/** + * Sets the access type this Dynamic will be working in. + * + * @param type {@link Dynamic#ACCESS_TYPE_RANDOM} or {@link Dynamic#ACCESS_TYPE_SEQUENTIAL}. + */ + public void setAccessType(int type) + { + mAccessType = type; + mLastPos = -1; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// +/** + * @return See {@link Dynamic#setSpeedMode(int)} + */ + public float getSpeedMode() + { + return mSpeedMode; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// +/** + * Sets the way we compute the interpolation speed. + * + * @param mode {@link Dynamic#SPEED_MODE_SMOOTH} or {@link Dynamic#SPEED_MODE_SEGMENT_CONSTANT} or + * {@link Dynamic#SPEED_MODE_GLOBALLY_CONSTANT} + */ + public void setSpeedMode(int mode) + { + if( mSpeedMode!=mode ) + { + if( mSpeedMode==SPEED_MODE_SMOOTH ) + { + for(int i=0; i + * This version differs from the previous in that it returns a boolean value which indicates whether + * the interpolation is finished. + * + * @param buffer Float buffer we will write the results to. + * @param offset Offset in the buffer where to write the result. + * @param 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: + * {@link Dynamic#MODE_LOOP}, {@link Dynamic#MODE_PATH} or {@link Dynamic#MODE_JUMP}. + * @param 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. + * @return true if the interpolation reached its end. + */ + public boolean get(float[] buffer, int offset, long time, long step) + { + if( mDuration<=0.0f ) + { + interpolate(buffer,offset,mCount-(int)mCount); + return false; + } + + if( mStartTime==-1 ) + { + mStartTime = time; + mLastPos = -1; + } + + long diff = time-mPausedTime; + + if( mStartTime=0 && diff<=step ) + { + mCorrectedTime = mPausedTime; + mStartTime += diff; + step -= diff; + } + + time -= mStartTime; + + if( time+step > mDuration*mCount && mCount>0.0f ) + { + interpolate(buffer,offset,mCount-(int)mCount); + return true; + } + + double pos; + + if( mAccessType ==ACCESS_TYPE_SEQUENTIAL ) + { + pos = mLastPos<0 ? (double)time/mDuration : (double)step/mDuration + mLastPos; + mLastPos = pos; + } + else + { + pos = (double)time/mDuration; + } + + interpolate(buffer,offset, (float)(pos-(int)pos) ); + return false; + } + } diff --git a/src/main/java/org/distorted/library/type/Dynamic1D.java b/src/main/java/org/distorted/library/type/Dynamic1D.java deleted file mode 100644 index 7f7a7e7..0000000 --- a/src/main/java/org/distorted/library/type/Dynamic1D.java +++ /dev/null @@ -1,445 +0,0 @@ -//////////////////////////////////////////////////////////////////////////////////////////////////// -// Copyright 2016 Leszek Koltunski leszek@koltunski.pl // -// // -// This file is part of Distorted. // -// // -// This library is free software; you can redistribute it and/or // -// modify it under the terms of the GNU Lesser General Public // -// License as published by the Free Software Foundation; either // -// version 2.1 of the License, or (at your option) any later version. // -// // -// This library is distributed in the hope that it will be useful, // -// but WITHOUT ANY WARRANTY; without even the implied warranty of // -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // -// Lesser General Public License for more details. // -// // -// You should have received a copy of the GNU Lesser General Public // -// License along with this library; if not, write to the Free Software // -// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA // -/////////////////////////////////////////////////////////////////////////////////////////////////// - -package org.distorted.library.type; - -import java.util.Vector; - -/////////////////////////////////////////////////////////////////////////////////////////////////// -/** -* A 1-dimensional implementation of the Dynamic class to interpolate between a list -* of Static1Ds. -*/ - -public class Dynamic1D extends Dynamic implements Data1D - { - private final Vector vv; - private Static1D prev, curr, next; - -/////////////////////////////////////////////////////////////////////////////////////////////////// -// no array bounds checking! - - private void computeVelocity(int c) - { - int p = c>0 ? c-1: numPoints-1; - int n = c0 ) - { - float q = (float)Math.sqrt((px*px)/d); - - if( q>1 ) - { - tmpCache1.velocity[0] = nx+px/q; - } - else - { - tmpCache1.velocity[0] = px+nx*q; - } - } - else - { - tmpCache1.velocity[0] = 0.0f; - } - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - private void recomputeCache() - { - if( numPoints==1 ) - { - tmpCache1 = vc.elementAt(0); - curr= vv.elementAt(0); - - tmpCache1.a[0] = 0.0f; - tmpCache1.b[0] = 0.0f; - tmpCache1.c[0] = curr.x; - tmpCache1.d[0] = 0.0f; - } - else if( numPoints==2 ) - { - tmpCache1 = vc.elementAt(0); - tmpCache2 = vc.elementAt(1); - curr= vv.elementAt(0); - next= vv.elementAt(1); - - tmpCache1.a[0] = 0.0f; - tmpCache1.b[0] = 0.0f; - tmpCache1.c[0] = next.x - curr.x; - tmpCache1.d[0] = curr.x; - - tmpCache2.a[0] = 0.0f; - tmpCache2.b[0] = 0.0f; - tmpCache2.c[0] = curr.x - next.x; - tmpCache2.d[0] = next.x; - } - else - { - int i, n; - - for(i=0; i(); - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// -/** - * Constructor setting the speed of interpolation and the number of revolutions. - * - * What constitutes 'one revolution' depends on the MODE: - * {@link Dynamic#MODE_LOOP}, {@link Dynamic#MODE_PATH} or {@link Dynamic#MODE_JUMP}. - * - * @param duration number of milliseconds it takes to do one revolution. - * @param count number of revolutions we will do. Count<=0 means 'infinite'. - */ - public Dynamic1D(int duration, float count) - { - super(duration,count,1); - vv = new Vector<>(); - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// -/** - * Returns the location'th Static1D. - * - * @param location the index of the Point we are interested in. - * @return The Static1D, if 0<=location<getNumPoints(), or null otherwise. - */ - public synchronized Static1D getPoint(int location) - { - return (location>=0 && location=0 && location - * Only a reference to the Point gets added to the List; this means that one can add a Point - * here, and later on {@link Static1D#set(float)} it to some new value and the change will - * be seamlessly reflected in the interpolated path. - *

    - * A Point can be added multiple times. - * - * @param v The Point to add. - */ - public synchronized void add(Static1D v) - { - if( v!=null ) - { - vv.add(v); - - if( vn!=null ) vn.add(new VectorNoise()); - - switch(numPoints) - { - case 0: - case 1: break; - case 2: vc.add(new VectorCache()); - vc.add(new VectorCache()); - vc.add(new VectorCache()); - cacheDirty = true; - break; - default:vc.add(new VectorCache()); - cacheDirty = true; - } - - numPoints++; - } - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// -/** - * Adds a new Static1D to the location'th place in our List of Points to interpolate through. - * - * @param location Index in our List to add the new Point at. - * @param v The Point to add. - */ - public synchronized void add(int location, Static1D v) - { - if( v!=null ) - { - vv.add(location, v); - - if( vn!=null ) vn.add(new VectorNoise()); - - switch(numPoints) - { - case 0: - case 1: break; - case 2: vc.add(new VectorCache()); - vc.add(new VectorCache()); - vc.add(new VectorCache()); - cacheDirty = true; - break; - default:vc.add(location,new VectorCache()); - cacheDirty = true; - } - - numPoints++; - } - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// -/** - * Removes all occurrences of Point v from the List of Points to interpolate through. - * - * @param v The Point to remove. - * @return true if we have removed at least one Point. - */ - public synchronized boolean remove(Static1D v) - { - int n = vv.indexOf(v); - boolean found = false; - - while( n>=0 ) - { - vv.remove(n); - - if( vn!=null ) vn.remove(0); - - switch(numPoints) - { - case 0: - case 1: - case 2: break; - case 3: vc.removeAllElements(); - break; - default:vc.remove(n); - cacheDirty=true; - } - - numPoints--; - found = true; - n = vv.indexOf(v); - } - - return found; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// -/** - * Removes a location'th Point from the List of Points we interpolate through. - * - * @param location index of the Point we want to remove. - * @return true if location is valid, i.e. if 0<=location<getNumPoints(). - */ - public synchronized boolean remove(int location) - { - if( location>=0 && location - * When Noise=0 (the default), we interpolate between our Points through the most smooth path possible. - * Increasing noise makes the Dynamic increasingly deviate from this path, pseudo-randomly speeding - * up and slowing down, etc. - * - * @param noise The noise level. Permitted range: 0 <= noise <= 1. - */ - - public synchronized void setNoise(Static1D noise) - { - if( vn==null ) - { - vn = new Vector<>(); - for(int i=0; i=2 ) - { - mFactor = new float[mDimension-1]; - } - - mNoise = new float[mDimension]; - } - - if( noise.x<0.0f ) noise.x = 0.0f; - if( noise.x>1.0f ) noise.x = 1.0f; - - mNoise[0] = noise.x; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - synchronized void interpolate(float[] buffer, int offset, float time) - { - switch(numPoints) - { - case 0: buffer[offset] = 0.0f; - break; - case 1: curr = vv.elementAt(0); - buffer[offset] = curr.x; - break; - case 2: curr = vv.elementAt(0); - next = vv.elementAt(1); - - int segment= (int)(2*time); - - if( mMode==MODE_LOOP || mMode==MODE_PATH ) time = (time>0.5f ? 2-2*time : 2*time); - - if( vn!=null ) - { - if( segment != mSegment ) - { - if(mMode!=MODE_JUMP || mSegment==1) vn.elementAt(0).computeNoise(); - mSegment = segment; - } - - time = noise(time,0); - } - - buffer[offset] = (next.x-curr.x)*time + curr.x; - break; - default:computeSegmentAndTime(time); - - if( mTmpVec>=0 && mTmpVec vv; + private Static1D prev, curr, next; + +/////////////////////////////////////////////////////////////////////////////////////////////////// +// no array bounds checking! + + private void computeVelocity(int c) + { + int p = c>0 ? c-1: numPoints-1; + int n = c0 ) + { + float q = (float)Math.sqrt((px*px)/d); + + if( q>1 ) + { + tmpCache1.velocity[0] = nx+px/q; + } + else + { + tmpCache1.velocity[0] = px+nx*q; + } + } + else + { + tmpCache1.velocity[0] = 0.0f; + } + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + private void recomputeCache() + { + if( numPoints==1 ) + { + tmpCache1 = vc.elementAt(0); + curr= vv.elementAt(0); + + tmpCache1.a[0] = 0.0f; + tmpCache1.b[0] = 0.0f; + tmpCache1.c[0] = curr.x; + tmpCache1.d[0] = 0.0f; + } + else if( numPoints==2 ) + { + tmpCache1 = vc.elementAt(0); + tmpCache2 = vc.elementAt(1); + curr= vv.elementAt(0); + next= vv.elementAt(1); + + tmpCache1.a[0] = 0.0f; + tmpCache1.b[0] = 0.0f; + tmpCache1.c[0] = next.x - curr.x; + tmpCache1.d[0] = curr.x; + + tmpCache2.a[0] = 0.0f; + tmpCache2.b[0] = 0.0f; + tmpCache2.c[0] = curr.x - next.x; + tmpCache2.d[0] = next.x; + } + else + { + int i, n; + + for(i=0; i(); + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// +/** + * Constructor setting the speed of interpolation and the number of revolutions. + * + * What constitutes 'one revolution' depends on the MODE: + * {@link Dynamic#MODE_LOOP}, {@link Dynamic#MODE_PATH} or {@link Dynamic#MODE_JUMP}. + * + * @param duration number of milliseconds it takes to do one revolution. + * @param count number of revolutions we will do. Count<=0 means 'infinite'. + */ + public Dynamic1D(int duration, float count) + { + super(duration,count,1); + vv = new Vector<>(); + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// +/** + * Returns the location'th Static1D. + * + * @param location the index of the Point we are interested in. + * @return The Static1D, if 0<=location<getNumPoints(), or null otherwise. + */ + public synchronized Static1D getPoint(int location) + { + return (location>=0 && location=0 && location + * Only a reference to the Point gets added to the List; this means that one can add a Point + * here, and later on {@link Static1D#set(float)} it to some new value and the change will + * be seamlessly reflected in the interpolated path. + *

    + * A Point can be added multiple times. + * + * @param v The Point to add. + */ + public synchronized void add(Static1D v) + { + if( v!=null ) + { + vv.add(v); + + if( vn!=null ) vn.add(new VectorNoise()); + + switch(numPoints) + { + case 0: + case 1: break; + case 2: vc.add(new VectorCache()); + vc.add(new VectorCache()); + vc.add(new VectorCache()); + cacheDirty = true; + break; + default:vc.add(new VectorCache()); + cacheDirty = true; + } + + numPoints++; + } + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// +/** + * Adds a new Static1D to the location'th place in our List of Points to interpolate through. + * + * @param location Index in our List to add the new Point at. + * @param v The Point to add. + */ + public synchronized void add(int location, Static1D v) + { + if( v!=null ) + { + vv.add(location, v); + + if( vn!=null ) vn.add(new VectorNoise()); + + switch(numPoints) + { + case 0: + case 1: break; + case 2: vc.add(new VectorCache()); + vc.add(new VectorCache()); + vc.add(new VectorCache()); + cacheDirty = true; + break; + default:vc.add(location,new VectorCache()); + cacheDirty = true; + } + + numPoints++; + } + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// +/** + * Removes all occurrences of Point v from the List of Points to interpolate through. + * + * @param v The Point to remove. + * @return true if we have removed at least one Point. + */ + public synchronized boolean remove(Static1D v) + { + int n = vv.indexOf(v); + boolean found = false; + + while( n>=0 ) + { + vv.remove(n); + + if( vn!=null ) vn.remove(0); + + switch(numPoints) + { + case 0: + case 1: + case 2: break; + case 3: vc.removeAllElements(); + break; + default:vc.remove(n); + cacheDirty=true; + } + + numPoints--; + found = true; + n = vv.indexOf(v); + } + + return found; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// +/** + * Removes a location'th Point from the List of Points we interpolate through. + * + * @param location index of the Point we want to remove. + * @return true if location is valid, i.e. if 0<=location<getNumPoints(). + */ + public synchronized boolean remove(int location) + { + if( location>=0 && location + * When Noise=0 (the default), we interpolate between our Points through the most smooth path possible. + * Increasing noise makes the Dynamic increasingly deviate from this path, pseudo-randomly speeding + * up and slowing down, etc. + * + * @param noise The noise level. Permitted range: 0 <= noise <= 1. + */ + + public synchronized void setNoise(Static1D noise) + { + if( vn==null ) + { + vn = new Vector<>(); + for(int i=0; i=2 ) + { + mFactor = new float[mDimension-1]; + } + + mNoise = new float[mDimension]; + } + + if( noise.x<0.0f ) noise.x = 0.0f; + if( noise.x>1.0f ) noise.x = 1.0f; + + mNoise[0] = noise.x; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + synchronized void interpolate(float[] buffer, int offset, float time) + { + switch(numPoints) + { + case 0: buffer[offset] = 0.0f; + break; + case 1: curr = vv.elementAt(0); + buffer[offset] = curr.x; + break; + case 2: curr = vv.elementAt(0); + next = vv.elementAt(1); + + int segment= (int)(2*time); + + if( mMode==MODE_LOOP || mMode==MODE_PATH ) time = (time>0.5f ? 2-2*time : 2*time); + + if( vn!=null ) + { + if( segment != mSegment ) + { + if(mMode!=MODE_JUMP || mSegment==1) vn.elementAt(0).computeNoise(); + mSegment = segment; + } + + time = noise(time,0); + } + + buffer[offset] = (next.x-curr.x)*time + curr.x; + break; + default:computeSegmentAndTime(time); + + if( mTmpVec>=0 && mTmpVec vv; - private Static2D prev, curr, next; - -/////////////////////////////////////////////////////////////////////////////////////////////////// -// no array bounds checking! - - private void computeVelocity(int c) - { - int p = c>0 ? c-1: numPoints-1; - int n = c0 ) - { - float q = (float)Math.sqrt((px*px+py*py)/d); - - if( q>1 ) - { - tmpCache1.velocity[0] = nx+px/q; - tmpCache1.velocity[1] = ny+py/q; - } - else - { - tmpCache1.velocity[0] = px+nx*q; - tmpCache1.velocity[1] = py+ny*q; - } - } - else - { - tmpCache1.velocity[0] = 0.0f; - tmpCache1.velocity[1] = 0.0f; - } - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - private void recomputeCache() - { - if( numPoints==1 ) - { - tmpCache1 = vc.elementAt(0); - curr= vv.elementAt(0); - - tmpCache1.a[0] = tmpCache1.a[1] = 0.0f; - tmpCache1.b[0] = tmpCache1.b[1] = 0.0f; - tmpCache1.c[0] = curr.x; - tmpCache1.c[1] = curr.y; - tmpCache1.d[0] = tmpCache1.d[1] = 0.0f; - } - else if( numPoints==2 ) - { - tmpCache1 = vc.elementAt(0); - tmpCache2 = vc.elementAt(1); - curr= vv.elementAt(0); - next= vv.elementAt(1); - - tmpCache1.a[0] = tmpCache1.a[1] = 0.0f; - tmpCache1.b[0] = tmpCache1.b[1] = 0.0f; - tmpCache1.c[0] = next.x - curr.x; - tmpCache1.c[1] = next.y - curr.y; - tmpCache1.d[0] = curr.x; - tmpCache1.d[1] = curr.y; - - tmpCache2.a[0] = tmpCache2.a[1] = 0.0f; - tmpCache2.b[0] = tmpCache2.b[1] = 0.0f; - tmpCache2.c[0] = curr.x - next.x; - tmpCache2.c[1] = curr.y - next.y; - tmpCache2.d[0] = next.x; - tmpCache2.d[1] = next.y; - } - else - { - int i, n; - - for(i=0; i(); - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// -/** - * Constructor setting the speed of interpolation and the number of revolutions. - * - * What constitutes 'one revolution' depends on the MODE: - * {@link Dynamic#MODE_LOOP}, {@link Dynamic#MODE_PATH} or {@link Dynamic#MODE_JUMP}. - * - * @param duration number of milliseconds it takes to do one revolution. - * @param count number of revolutions we will do. Count<=0 means 'infinite'. - */ - public Dynamic2D(int duration, float count) - { - super(duration,count,2); - vv = new Vector<>(); - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// -/** - * Returns the location'th Static2D. - * - * @param location the index of the Point we are interested in. - * @return The Static2D, if 0<=location<getNumPoints(), or null otherwise. - */ - public synchronized Static2D getPoint(int location) - { - return (location>=0 && location=0 && location - * Only a reference to the Point gets added to the List; this means that one can add a Point - * here, and later on {@link Static2D#set(float,float)} it to some new value and the change - * will be seamlessly reflected in the interpolated path. - *

    - * A Point can be added multiple times. - * - * @param v The Point to add. - */ - public synchronized void add(Static2D v) - { - if( v!=null ) - { - vv.add(v); - - if( vn!=null ) vn.add(new VectorNoise()); - - switch(numPoints) - { - case 0: - case 1: break; - case 2: vc.add(new VectorCache()); - vc.add(new VectorCache()); - vc.add(new VectorCache()); - break; - default:vc.add(new VectorCache()); - } - - numPoints++; - cacheDirty = true; - } - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// -/** - * Adds a new Static2D to the location'th place in our List of Points to interpolate through. - * - * @param location Index in our List to add the new Point at. - * @param v The Point to add. - */ - public synchronized void add(int location, Static2D v) - { - if( v!=null ) - { - vv.add(location, v); - - if( vn!=null ) vn.add(new VectorNoise()); - - switch(numPoints) - { - case 0: - case 1: break; - case 2: vc.add(new VectorCache()); - vc.add(new VectorCache()); - vc.add(new VectorCache()); - break; - default:vc.add(location,new VectorCache()); - } - - numPoints++; - cacheDirty = true; - } - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// -/** - * Removes all occurrences of Point v from the List of Points to interpolate through. - * - * @param v The Point to remove. - * @return true if we have removed at least one Point. - */ - public synchronized boolean remove(Static2D v) - { - int n = vv.indexOf(v); - boolean found = false; - - while( n>=0 ) - { - vv.remove(n); - - if( vn!=null ) vn.remove(0); - - switch(numPoints) - { - case 0: - case 1: - case 2: break; - case 3: vc.removeAllElements(); - break; - default:vc.remove(n); - } - - numPoints--; - found = true; - n = vv.indexOf(v); - } - - if( found ) - { - cacheDirty=true; - } - - return found; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// -/** - * Removes a location'th Point from the List of Points we interpolate through. - * - * @param location index of the Point we want to remove. - * @return true if location is valid, i.e. if 0<=location<getNumPoints(). - */ - public synchronized boolean remove(int location) - { - if( location>=0 && location - * When Noise=0 (the default), we interpolate between our Points through the most smooth path possible. - * Increasing noise makes the Dynamic increasingly deviate from this path, pseudo-randomly speeding - * up and slowing down, etc. - * - * @param noise The noise level. Permitted range: 0 <= noise <= 1. - */ - - public synchronized void setNoise(Static2D noise) - { - if( vn==null ) - { - vn = new Vector<>(); - for(int i=0; i=2 ) - { - mFactor = new float[mDimension-1]; - } - - mNoise = new float[mDimension]; - } - - if( noise.x<0.0f ) noise.x = 0.0f; - if( noise.x>1.0f ) noise.x = 1.0f; - if( noise.y<0.0f ) noise.y = 0.0f; - if( noise.y>1.0f ) noise.y = 1.0f; - - mNoise[0] = noise.x; - mNoise[1] = noise.y; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - synchronized void interpolate(float[] buffer, int offset, float time) - { - switch(numPoints) - { - case 0: buffer[offset ] = 0.0f; - buffer[offset+1] = 0.0f; - break; - case 1: curr = vv.elementAt(0); - buffer[offset ] = curr.x; - buffer[offset+1] = curr.y; - break; - case 2: curr = vv.elementAt(0); - next = vv.elementAt(1); - - int segment= (int)(2*time); - - if( mMode==MODE_LOOP || mMode==MODE_PATH ) time = (time>0.5f ? 2-2*time : 2*time); - - if( vn!=null ) - { - if( segment != mSegment ) - { - if(mMode!=MODE_JUMP || mSegment==1) vn.elementAt(0).computeNoise(); - mSegment = segment; - } - - time = noise(time,0); - - baseV[1][0] = next.x-curr.x; - baseV[1][1] = next.y-curr.y; - - buffer[offset ] = baseV[1][0]*time + curr.x +baseV[1][1]*mFactor[0]; - buffer[offset+1] = baseV[1][1]*time + curr.y -baseV[1][0]*mFactor[0]; - } - else - { - buffer[offset ] = (next.x-curr.x)*time + curr.x; - buffer[offset+1] = (next.y-curr.y)*time + curr.y; - } - - break; - default:computeSegmentAndTime(time); - - if( mTmpVec>=0 && mTmpVec vv; + private Static2D prev, curr, next; + +/////////////////////////////////////////////////////////////////////////////////////////////////// +// no array bounds checking! + + private void computeVelocity(int c) + { + int p = c>0 ? c-1: numPoints-1; + int n = c0 ) + { + float q = (float)Math.sqrt((px*px+py*py)/d); + + if( q>1 ) + { + tmpCache1.velocity[0] = nx+px/q; + tmpCache1.velocity[1] = ny+py/q; + } + else + { + tmpCache1.velocity[0] = px+nx*q; + tmpCache1.velocity[1] = py+ny*q; + } + } + else + { + tmpCache1.velocity[0] = 0.0f; + tmpCache1.velocity[1] = 0.0f; + } + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + private void recomputeCache() + { + if( numPoints==1 ) + { + tmpCache1 = vc.elementAt(0); + curr= vv.elementAt(0); + + tmpCache1.a[0] = tmpCache1.a[1] = 0.0f; + tmpCache1.b[0] = tmpCache1.b[1] = 0.0f; + tmpCache1.c[0] = curr.x; + tmpCache1.c[1] = curr.y; + tmpCache1.d[0] = tmpCache1.d[1] = 0.0f; + } + else if( numPoints==2 ) + { + tmpCache1 = vc.elementAt(0); + tmpCache2 = vc.elementAt(1); + curr= vv.elementAt(0); + next= vv.elementAt(1); + + tmpCache1.a[0] = tmpCache1.a[1] = 0.0f; + tmpCache1.b[0] = tmpCache1.b[1] = 0.0f; + tmpCache1.c[0] = next.x - curr.x; + tmpCache1.c[1] = next.y - curr.y; + tmpCache1.d[0] = curr.x; + tmpCache1.d[1] = curr.y; + + tmpCache2.a[0] = tmpCache2.a[1] = 0.0f; + tmpCache2.b[0] = tmpCache2.b[1] = 0.0f; + tmpCache2.c[0] = curr.x - next.x; + tmpCache2.c[1] = curr.y - next.y; + tmpCache2.d[0] = next.x; + tmpCache2.d[1] = next.y; + } + else + { + int i, n; + + for(i=0; i(); + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// +/** + * Constructor setting the speed of interpolation and the number of revolutions. + * + * What constitutes 'one revolution' depends on the MODE: + * {@link Dynamic#MODE_LOOP}, {@link Dynamic#MODE_PATH} or {@link Dynamic#MODE_JUMP}. + * + * @param duration number of milliseconds it takes to do one revolution. + * @param count number of revolutions we will do. Count<=0 means 'infinite'. + */ + public Dynamic2D(int duration, float count) + { + super(duration,count,2); + vv = new Vector<>(); + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// +/** + * Returns the location'th Static2D. + * + * @param location the index of the Point we are interested in. + * @return The Static2D, if 0<=location<getNumPoints(), or null otherwise. + */ + public synchronized Static2D getPoint(int location) + { + return (location>=0 && location=0 && location + * Only a reference to the Point gets added to the List; this means that one can add a Point + * here, and later on {@link Static2D#set(float,float)} it to some new value and the change + * will be seamlessly reflected in the interpolated path. + *

    + * A Point can be added multiple times. + * + * @param v The Point to add. + */ + public synchronized void add(Static2D v) + { + if( v!=null ) + { + vv.add(v); + + if( vn!=null ) vn.add(new VectorNoise()); + + switch(numPoints) + { + case 0: + case 1: break; + case 2: vc.add(new VectorCache()); + vc.add(new VectorCache()); + vc.add(new VectorCache()); + break; + default:vc.add(new VectorCache()); + } + + numPoints++; + cacheDirty = true; + } + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// +/** + * Adds a new Static2D to the location'th place in our List of Points to interpolate through. + * + * @param location Index in our List to add the new Point at. + * @param v The Point to add. + */ + public synchronized void add(int location, Static2D v) + { + if( v!=null ) + { + vv.add(location, v); + + if( vn!=null ) vn.add(new VectorNoise()); + + switch(numPoints) + { + case 0: + case 1: break; + case 2: vc.add(new VectorCache()); + vc.add(new VectorCache()); + vc.add(new VectorCache()); + break; + default:vc.add(location,new VectorCache()); + } + + numPoints++; + cacheDirty = true; + } + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// +/** + * Removes all occurrences of Point v from the List of Points to interpolate through. + * + * @param v The Point to remove. + * @return true if we have removed at least one Point. + */ + public synchronized boolean remove(Static2D v) + { + int n = vv.indexOf(v); + boolean found = false; + + while( n>=0 ) + { + vv.remove(n); + + if( vn!=null ) vn.remove(0); + + switch(numPoints) + { + case 0: + case 1: + case 2: break; + case 3: vc.removeAllElements(); + break; + default:vc.remove(n); + } + + numPoints--; + found = true; + n = vv.indexOf(v); + } + + if( found ) + { + cacheDirty=true; + } + + return found; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// +/** + * Removes a location'th Point from the List of Points we interpolate through. + * + * @param location index of the Point we want to remove. + * @return true if location is valid, i.e. if 0<=location<getNumPoints(). + */ + public synchronized boolean remove(int location) + { + if( location>=0 && location + * When Noise=0 (the default), we interpolate between our Points through the most smooth path possible. + * Increasing noise makes the Dynamic increasingly deviate from this path, pseudo-randomly speeding + * up and slowing down, etc. + * + * @param noise The noise level. Permitted range: 0 <= noise <= 1. + */ + + public synchronized void setNoise(Static2D noise) + { + if( vn==null ) + { + vn = new Vector<>(); + for(int i=0; i=2 ) + { + mFactor = new float[mDimension-1]; + } + + mNoise = new float[mDimension]; + } + + if( noise.x<0.0f ) noise.x = 0.0f; + if( noise.x>1.0f ) noise.x = 1.0f; + if( noise.y<0.0f ) noise.y = 0.0f; + if( noise.y>1.0f ) noise.y = 1.0f; + + mNoise[0] = noise.x; + mNoise[1] = noise.y; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + synchronized void interpolate(float[] buffer, int offset, float time) + { + switch(numPoints) + { + case 0: buffer[offset ] = 0.0f; + buffer[offset+1] = 0.0f; + break; + case 1: curr = vv.elementAt(0); + buffer[offset ] = curr.x; + buffer[offset+1] = curr.y; + break; + case 2: curr = vv.elementAt(0); + next = vv.elementAt(1); + + int segment= (int)(2*time); + + if( mMode==MODE_LOOP || mMode==MODE_PATH ) time = (time>0.5f ? 2-2*time : 2*time); + + if( vn!=null ) + { + if( segment != mSegment ) + { + if(mMode!=MODE_JUMP || mSegment==1) vn.elementAt(0).computeNoise(); + mSegment = segment; + } + + time = noise(time,0); + + baseV[1][0] = next.x-curr.x; + baseV[1][1] = next.y-curr.y; + + buffer[offset ] = baseV[1][0]*time + curr.x +baseV[1][1]*mFactor[0]; + buffer[offset+1] = baseV[1][1]*time + curr.y -baseV[1][0]*mFactor[0]; + } + else + { + buffer[offset ] = (next.x-curr.x)*time + curr.x; + buffer[offset+1] = (next.y-curr.y)*time + curr.y; + } + + break; + default:computeSegmentAndTime(time); + + if( mTmpVec>=0 && mTmpVec vv; - private Static3D prev, curr, next; - -/////////////////////////////////////////////////////////////////////////////////////////////////// -// no array bounds checking! - - private void computeVelocity(int c) - { - int p = c>0 ? c-1: numPoints-1; - int n = c0 ) - { - float q = (float)Math.sqrt((px*px+py*py+pz*pz)/d); - - if( q>1 ) - { - tmpCache1.velocity[0] = nx+px/q; - tmpCache1.velocity[1] = ny+py/q; - tmpCache1.velocity[2] = nz+pz/q; - } - else - { - tmpCache1.velocity[0] = px+nx*q; - tmpCache1.velocity[1] = py+ny*q; - tmpCache1.velocity[2] = pz+nz*q; - } - } - else - { - tmpCache1.velocity[0] = 0.0f; - tmpCache1.velocity[1] = 0.0f; - tmpCache1.velocity[2] = 0.0f; - } - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - private void recomputeCache() - { - if( numPoints==1 ) - { - tmpCache1 = vc.elementAt(0); - curr= vv.elementAt(0); - - tmpCache1.a[0] = tmpCache1.a[1] = tmpCache1.a[2] = 0.0f; - tmpCache1.b[0] = tmpCache1.b[1] = tmpCache1.b[2] = 0.0f; - tmpCache1.c[0] = curr.x; - tmpCache1.c[1] = curr.y; - tmpCache1.c[2] = curr.z; - tmpCache1.d[0] = tmpCache1.d[1] = tmpCache1.d[2] = 0.0f; - } - else if( numPoints==2 ) - { - tmpCache1 = vc.elementAt(0); - tmpCache2 = vc.elementAt(1); - curr= vv.elementAt(0); - next= vv.elementAt(1); - - tmpCache1.a[0] = tmpCache1.a[1] = tmpCache1.a[2] = 0.0f; - tmpCache1.b[0] = tmpCache1.b[1] = tmpCache1.b[2] = 0.0f; - tmpCache1.c[0] = next.x - curr.x; - tmpCache1.c[1] = next.y - curr.y; - tmpCache1.c[2] = next.z - curr.z; - tmpCache1.d[0] = curr.x; - tmpCache1.d[1] = curr.y; - tmpCache1.d[2] = curr.z; - - tmpCache2.a[0] = tmpCache2.a[1] = tmpCache2.a[2] = 0.0f; - tmpCache2.b[0] = tmpCache2.b[1] = tmpCache2.b[2] = 0.0f; - tmpCache2.c[0] = curr.x - next.x; - tmpCache2.c[1] = curr.y - next.y; - tmpCache2.c[2] = curr.z - next.z; - tmpCache2.d[0] = next.x; - tmpCache2.d[1] = next.y; - tmpCache2.d[2] = next.z; - } - else - { - int i, n; - - for(i=0; i(); - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// -/** - * Constructor setting the speed of interpolation and the number of revolutions. - * - * What constitutes 'one revolution' depends on the MODE: - * {@link Dynamic#MODE_LOOP}, {@link Dynamic#MODE_PATH} or {@link Dynamic#MODE_JUMP}. - * - * @param duration number of milliseconds it takes to do one revolution. - * @param count number of revolutions we will do. Count<=0 means 'infinite'. - */ - public Dynamic3D(int duration, float count) - { - super(duration,count,3); - vv = new Vector<>(); - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// -/** - * Returns the location'th Static3D. - * - * @param location the index of the Point we are interested in. - * @return The Static3D, if 0<=location<getNumPoints(), or null otherwise. - */ - public synchronized Static3D getPoint(int location) - { - return (location>=0 && location=0 && location - * Only a reference to the Point gets added to the List; this means that one can add a Point - * here, and later on {@link Static3D#set(float,float,float)} it to some new value and the - * change will be seamlessly reflected in the interpolated path. - *

    - * A Point can be added multiple times. - * - * @param v The Point to add. - */ - public synchronized void add(Static3D v) - { - if( v!=null ) - { - vv.add(v); - - if( vn!=null ) vn.add(new VectorNoise()); - - switch(numPoints) - { - case 0: break; - case 1: computeOrthonormalBase2(vv.elementAt(0),v); - break; - case 2: vc.add(new VectorCache()); - vc.add(new VectorCache()); - vc.add(new VectorCache()); - break; - default:vc.add(new VectorCache()); - } - - numPoints++; - cacheDirty = true; - } - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// -/** - * Adds a new Static3D to the location'th place in our List of Points to interpolate through. - * - * @param location Index in our List to add the new Point at. - * @param v The Point to add. - */ - public synchronized void add(int location, Static3D v) - { - if( v!=null ) - { - vv.add(location, v); - - if( vn!=null ) vn.add(new VectorNoise()); - - switch(numPoints) - { - case 0: break; - case 1: computeOrthonormalBase2(vv.elementAt(0),v); - break; - case 2: vc.add(new VectorCache()); - vc.add(new VectorCache()); - vc.add(new VectorCache()); - break; - default:vc.add(location,new VectorCache()); - } - - numPoints++; - cacheDirty = true; - } - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// -/** - * Removes all occurrences of Point v from the List of Points to interpolate through. - * - * @param v The Point to remove. - * @return true if we have removed at least one Point. - */ - public synchronized boolean remove(Static3D v) - { - int n = vv.indexOf(v); - boolean found = false; - - while( n>=0 ) - { - vv.remove(n); - - if( vn!=null ) vn.remove(0); - - switch(numPoints) - { - case 0: - case 1: - case 2: break; - case 3: vc.removeAllElements(); - computeOrthonormalBase2(vv.elementAt(0),vv.elementAt(1)); - break; - default:vc.remove(n); - } - - numPoints--; - found = true; - n = vv.indexOf(v); - } - - if( found ) - { - cacheDirty=true; - } - - return found; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// -/** - * Removes a location'th Point from the List of Points we interpolate through. - * - * @param location index of the Point we want to remove. - * @return true if location is valid, i.e. if 0<=location<getNumPoints(). - */ - public synchronized boolean remove(int location) - { - if( location>=0 && location - * When Noise=0 (the default), we interpolate between our Points through the most smooth path possible. - * Increasing noise makes the Dynamic increasingly deviate from this path, pseudo-randomly speeding - * up and slowing down, etc. - * - * @param noise The noise level. Permitted range: 0 <= noise <= 1. - */ - - public synchronized void setNoise(Static3D noise) - { - if( vn==null ) - { - vn = new Vector<>(); - for(int i=0; i=2 ) - { - mFactor = new float[mDimension-1]; - } - - mNoise = new float[mDimension]; - } - - if( noise.x<0.0f ) noise.x = 0.0f; - if( noise.x>1.0f ) noise.x = 1.0f; - if( noise.y<0.0f ) noise.y = 0.0f; - if( noise.y>1.0f ) noise.y = 1.0f; - if( noise.z<0.0f ) noise.z = 0.0f; - if( noise.z>1.0f ) noise.z = 1.0f; - - mNoise[0] = noise.x; - mNoise[1] = noise.y; - mNoise[2] = noise.z; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - synchronized void interpolate(float[] buffer, int offset, float time) - { - switch(numPoints) - { - case 0: buffer[offset ] = 0.0f; - buffer[offset+1] = 0.0f; - buffer[offset+2] = 0.0f; - break; - case 1: curr = vv.elementAt(0); - buffer[offset ] = curr.x; - buffer[offset+1] = curr.y; - buffer[offset+2] = curr.z; - break; - case 2: curr = vv.elementAt(0); - next = vv.elementAt(1); - - int segment= (int)(2*time); - - if( mMode==MODE_LOOP || mMode==MODE_PATH ) time = (time>0.5f ? 2-2*time : 2*time); - - if( vn!=null ) - { - if( segment != mSegment ) - { - if(mMode!=MODE_JUMP || mSegment==1) vn.elementAt(0).computeNoise(); - mSegment = segment; - } - - time = noise(time,0); - - buffer[offset ] = (next.x-curr.x)*time + curr.x + (baseV[1][0]*mFactor[0] + baseV[2][0]*mFactor[1]); - buffer[offset+1] = (next.y-curr.y)*time + curr.y + (baseV[1][1]*mFactor[0] + baseV[2][1]*mFactor[1]); - buffer[offset+2] = (next.z-curr.z)*time + curr.z + (baseV[1][2]*mFactor[0] + baseV[2][2]*mFactor[1]); - } - else - { - buffer[offset ] = (next.x-curr.x)*time + curr.x; - buffer[offset+1] = (next.y-curr.y)*time + curr.y; - buffer[offset+2] = (next.z-curr.z)*time + curr.z; - } - - break; - default:computeSegmentAndTime(time); - - if( mTmpVec>=0 && mTmpVec vv; + private Static3D prev, curr, next; + +/////////////////////////////////////////////////////////////////////////////////////////////////// +// no array bounds checking! + + private void computeVelocity(int c) + { + int p = c>0 ? c-1: numPoints-1; + int n = c0 ) + { + float q = (float)Math.sqrt((px*px+py*py+pz*pz)/d); + + if( q>1 ) + { + tmpCache1.velocity[0] = nx+px/q; + tmpCache1.velocity[1] = ny+py/q; + tmpCache1.velocity[2] = nz+pz/q; + } + else + { + tmpCache1.velocity[0] = px+nx*q; + tmpCache1.velocity[1] = py+ny*q; + tmpCache1.velocity[2] = pz+nz*q; + } + } + else + { + tmpCache1.velocity[0] = 0.0f; + tmpCache1.velocity[1] = 0.0f; + tmpCache1.velocity[2] = 0.0f; + } + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + private void recomputeCache() + { + if( numPoints==1 ) + { + tmpCache1 = vc.elementAt(0); + curr= vv.elementAt(0); + + tmpCache1.a[0] = tmpCache1.a[1] = tmpCache1.a[2] = 0.0f; + tmpCache1.b[0] = tmpCache1.b[1] = tmpCache1.b[2] = 0.0f; + tmpCache1.c[0] = curr.x; + tmpCache1.c[1] = curr.y; + tmpCache1.c[2] = curr.z; + tmpCache1.d[0] = tmpCache1.d[1] = tmpCache1.d[2] = 0.0f; + } + else if( numPoints==2 ) + { + tmpCache1 = vc.elementAt(0); + tmpCache2 = vc.elementAt(1); + curr= vv.elementAt(0); + next= vv.elementAt(1); + + tmpCache1.a[0] = tmpCache1.a[1] = tmpCache1.a[2] = 0.0f; + tmpCache1.b[0] = tmpCache1.b[1] = tmpCache1.b[2] = 0.0f; + tmpCache1.c[0] = next.x - curr.x; + tmpCache1.c[1] = next.y - curr.y; + tmpCache1.c[2] = next.z - curr.z; + tmpCache1.d[0] = curr.x; + tmpCache1.d[1] = curr.y; + tmpCache1.d[2] = curr.z; + + tmpCache2.a[0] = tmpCache2.a[1] = tmpCache2.a[2] = 0.0f; + tmpCache2.b[0] = tmpCache2.b[1] = tmpCache2.b[2] = 0.0f; + tmpCache2.c[0] = curr.x - next.x; + tmpCache2.c[1] = curr.y - next.y; + tmpCache2.c[2] = curr.z - next.z; + tmpCache2.d[0] = next.x; + tmpCache2.d[1] = next.y; + tmpCache2.d[2] = next.z; + } + else + { + int i, n; + + for(i=0; i(); + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// +/** + * Constructor setting the speed of interpolation and the number of revolutions. + * + * What constitutes 'one revolution' depends on the MODE: + * {@link Dynamic#MODE_LOOP}, {@link Dynamic#MODE_PATH} or {@link Dynamic#MODE_JUMP}. + * + * @param duration number of milliseconds it takes to do one revolution. + * @param count number of revolutions we will do. Count<=0 means 'infinite'. + */ + public Dynamic3D(int duration, float count) + { + super(duration,count,3); + vv = new Vector<>(); + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// +/** + * Returns the location'th Static3D. + * + * @param location the index of the Point we are interested in. + * @return The Static3D, if 0<=location<getNumPoints(), or null otherwise. + */ + public synchronized Static3D getPoint(int location) + { + return (location>=0 && location=0 && location + * Only a reference to the Point gets added to the List; this means that one can add a Point + * here, and later on {@link Static3D#set(float,float,float)} it to some new value and the + * change will be seamlessly reflected in the interpolated path. + *

    + * A Point can be added multiple times. + * + * @param v The Point to add. + */ + public synchronized void add(Static3D v) + { + if( v!=null ) + { + vv.add(v); + + if( vn!=null ) vn.add(new VectorNoise()); + + switch(numPoints) + { + case 0: break; + case 1: computeOrthonormalBase2(vv.elementAt(0),v); + break; + case 2: vc.add(new VectorCache()); + vc.add(new VectorCache()); + vc.add(new VectorCache()); + break; + default:vc.add(new VectorCache()); + } + + numPoints++; + cacheDirty = true; + } + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// +/** + * Adds a new Static3D to the location'th place in our List of Points to interpolate through. + * + * @param location Index in our List to add the new Point at. + * @param v The Point to add. + */ + public synchronized void add(int location, Static3D v) + { + if( v!=null ) + { + vv.add(location, v); + + if( vn!=null ) vn.add(new VectorNoise()); + + switch(numPoints) + { + case 0: break; + case 1: computeOrthonormalBase2(vv.elementAt(0),v); + break; + case 2: vc.add(new VectorCache()); + vc.add(new VectorCache()); + vc.add(new VectorCache()); + break; + default:vc.add(location,new VectorCache()); + } + + numPoints++; + cacheDirty = true; + } + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// +/** + * Removes all occurrences of Point v from the List of Points to interpolate through. + * + * @param v The Point to remove. + * @return true if we have removed at least one Point. + */ + public synchronized boolean remove(Static3D v) + { + int n = vv.indexOf(v); + boolean found = false; + + while( n>=0 ) + { + vv.remove(n); + + if( vn!=null ) vn.remove(0); + + switch(numPoints) + { + case 0: + case 1: + case 2: break; + case 3: vc.removeAllElements(); + computeOrthonormalBase2(vv.elementAt(0),vv.elementAt(1)); + break; + default:vc.remove(n); + } + + numPoints--; + found = true; + n = vv.indexOf(v); + } + + if( found ) + { + cacheDirty=true; + } + + return found; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// +/** + * Removes a location'th Point from the List of Points we interpolate through. + * + * @param location index of the Point we want to remove. + * @return true if location is valid, i.e. if 0<=location<getNumPoints(). + */ + public synchronized boolean remove(int location) + { + if( location>=0 && location + * When Noise=0 (the default), we interpolate between our Points through the most smooth path possible. + * Increasing noise makes the Dynamic increasingly deviate from this path, pseudo-randomly speeding + * up and slowing down, etc. + * + * @param noise The noise level. Permitted range: 0 <= noise <= 1. + */ + + public synchronized void setNoise(Static3D noise) + { + if( vn==null ) + { + vn = new Vector<>(); + for(int i=0; i=2 ) + { + mFactor = new float[mDimension-1]; + } + + mNoise = new float[mDimension]; + } + + if( noise.x<0.0f ) noise.x = 0.0f; + if( noise.x>1.0f ) noise.x = 1.0f; + if( noise.y<0.0f ) noise.y = 0.0f; + if( noise.y>1.0f ) noise.y = 1.0f; + if( noise.z<0.0f ) noise.z = 0.0f; + if( noise.z>1.0f ) noise.z = 1.0f; + + mNoise[0] = noise.x; + mNoise[1] = noise.y; + mNoise[2] = noise.z; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + synchronized void interpolate(float[] buffer, int offset, float time) + { + switch(numPoints) + { + case 0: buffer[offset ] = 0.0f; + buffer[offset+1] = 0.0f; + buffer[offset+2] = 0.0f; + break; + case 1: curr = vv.elementAt(0); + buffer[offset ] = curr.x; + buffer[offset+1] = curr.y; + buffer[offset+2] = curr.z; + break; + case 2: curr = vv.elementAt(0); + next = vv.elementAt(1); + + int segment= (int)(2*time); + + if( mMode==MODE_LOOP || mMode==MODE_PATH ) time = (time>0.5f ? 2-2*time : 2*time); + + if( vn!=null ) + { + if( segment != mSegment ) + { + if(mMode!=MODE_JUMP || mSegment==1) vn.elementAt(0).computeNoise(); + mSegment = segment; + } + + time = noise(time,0); + + buffer[offset ] = (next.x-curr.x)*time + curr.x + (baseV[1][0]*mFactor[0] + baseV[2][0]*mFactor[1]); + buffer[offset+1] = (next.y-curr.y)*time + curr.y + (baseV[1][1]*mFactor[0] + baseV[2][1]*mFactor[1]); + buffer[offset+2] = (next.z-curr.z)*time + curr.z + (baseV[1][2]*mFactor[0] + baseV[2][2]*mFactor[1]); + } + else + { + buffer[offset ] = (next.x-curr.x)*time + curr.x; + buffer[offset+1] = (next.y-curr.y)*time + curr.y; + buffer[offset+2] = (next.z-curr.z)*time + curr.z; + } + + break; + default:computeSegmentAndTime(time); + + if( mTmpVec>=0 && mTmpVec vv; - private Static4D prev, curr, next; - -/////////////////////////////////////////////////////////////////////////////////////////////////// -// no array bounds checking! - - private void computeVelocity(int c) - { - int p = c>0 ? c-1: numPoints-1; - int n = c0 ) - { - float q = (float)Math.sqrt((px*px+py*py+pz*pz+pw*pw)/d); - - if( q>1 ) - { - tmpCache1.velocity[0] = nx+px/q; - tmpCache1.velocity[1] = ny+py/q; - tmpCache1.velocity[2] = nz+pz/q; - tmpCache1.velocity[3] = nw+pw/q; - } - else - { - tmpCache1.velocity[0] = px+nx*q; - tmpCache1.velocity[1] = py+ny*q; - tmpCache1.velocity[2] = pz+nz*q; - tmpCache1.velocity[3] = pw+nw*q; - } - } - else - { - tmpCache1.velocity[0] = 0.0f; - tmpCache1.velocity[1] = 0.0f; - tmpCache1.velocity[2] = 0.0f; - tmpCache1.velocity[3] = 0.0f; - } - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - private void recomputeCache() - { - if( numPoints==1 ) - { - tmpCache1 = vc.elementAt(0); - curr= vv.elementAt(0); - - tmpCache1.a[0] = tmpCache1.a[1] = tmpCache1.a[2] = tmpCache1.a[3] = 0.0f; - tmpCache1.b[0] = tmpCache1.b[1] = tmpCache1.b[2] = tmpCache1.b[3] = 0.0f; - tmpCache1.c[0] = curr.x; - tmpCache1.c[1] = curr.y; - tmpCache1.c[2] = curr.z; - tmpCache1.c[3] = curr.w; - tmpCache1.d[0] = tmpCache1.d[1] = tmpCache1.d[3] = tmpCache1.d[3] = 0.0f; - } - else if( numPoints==2 ) - { - tmpCache1 = vc.elementAt(0); - tmpCache2 = vc.elementAt(1); - curr= vv.elementAt(0); - next= vv.elementAt(1); - - tmpCache1.a[0] = tmpCache1.a[1] = tmpCache1.a[2] = tmpCache1.a[3] = 0.0f; - tmpCache1.b[0] = tmpCache1.b[1] = tmpCache1.b[2] = tmpCache1.b[3] = 0.0f; - tmpCache1.c[0] = next.x - curr.x; - tmpCache1.c[1] = next.y - curr.y; - tmpCache1.c[2] = next.z - curr.z; - tmpCache1.c[3] = next.w - curr.w; - tmpCache1.d[0] = curr.x; - tmpCache1.d[1] = curr.y; - tmpCache1.d[2] = curr.z; - tmpCache1.d[3] = curr.w; - - tmpCache2.a[0] = tmpCache2.a[1] = tmpCache2.a[2] = tmpCache2.a[3] = 0.0f; - tmpCache2.b[0] = tmpCache2.b[1] = tmpCache2.b[2] = tmpCache2.b[3] = 0.0f; - tmpCache2.c[0] = curr.x - next.x; - tmpCache2.c[1] = curr.y - next.y; - tmpCache2.c[2] = curr.z - next.z; - tmpCache2.c[3] = curr.w - next.w; - tmpCache2.d[0] = next.x; - tmpCache2.d[1] = next.y; - tmpCache2.d[2] = next.z; - tmpCache2.d[3] = next.w; - } - else - { - int i, n; - - for(i=0; i(); - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// -/** - * Constructor setting the speed of interpolation and the number of revolutions. - * - * What constitutes 'one revolution' depends on the MODE: - * {@link Dynamic#MODE_LOOP}, {@link Dynamic#MODE_PATH} or {@link Dynamic#MODE_JUMP}. - * - * @param duration number of milliseconds it takes to do one revolution. - * @param count number of revolutions we will do. Count<=0 means 'infinite'. - */ - public Dynamic4D(int duration, float count) - { - super(duration,count,4); - vv = new Vector<>(); - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// -/** - * Returns the location'th Static4D. - * - * @param location the index of the Point we are interested in. - * @return The Static4D, if 0<=location<getNumPoints(), or null otherwise. - */ - public synchronized Static4D getPoint(int location) - { - return (location>=0 && location=0 && location - * Only a reference to the Point gets added to the List; this means that one can add a Point - * here, and later on {@link Static4D#set(float,float,float,float)} it to some new value and - * the change will be seamlessly reflected in the interpolated path. - *

    - * A Point can be added multiple times. - * - * @param v The Point to add. - */ - public synchronized void add(Static4D v) - { - if( v!=null ) - { - vv.add(v); - - if( vn!=null ) vn.add(new VectorNoise()); - - switch(numPoints) - { - case 0: break; - case 1: computeOrthonormalBase2(vv.elementAt(0),v); - break; - case 2: vc.add(new VectorCache()); - vc.add(new VectorCache()); - vc.add(new VectorCache()); - break; - default:vc.add(new VectorCache()); - } - - numPoints++; - cacheDirty = true; - } - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// -/** - * Adds a new Static4D to the location'th place in our List of Points to interpolate through. - * - * @param location Index in our List to add the new Point at. - * @param v The Static4D to add. - */ - public synchronized void add(int location, Static4D v) - { - if( v!=null ) - { - vv.add(location, v); - - if( vn!=null ) vn.add(new VectorNoise()); - - switch(numPoints) - { - case 0: break; - case 1: computeOrthonormalBase2(vv.elementAt(0),v); - break; - case 2: vc.add(new VectorCache()); - vc.add(new VectorCache()); - vc.add(new VectorCache()); - break; - default:vc.add(location,new VectorCache()); - } - - numPoints++; - cacheDirty = true; - } - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// -/** - * Removes all occurrences of Point v from the List of Points to interpolate through. - * - * @param v The Point to remove. - * @return true if we have removed at least one Point. - */ - public synchronized boolean remove(Static4D v) - { - int n = vv.indexOf(v); - boolean found = false; - - while( n>=0 ) - { - vv.remove(n); - - if( vn!=null ) vn.remove(0); - - switch(numPoints) - { - case 0: - case 1: - case 2: break; - case 3: vc.removeAllElements(); - computeOrthonormalBase2(vv.elementAt(0),vv.elementAt(1)); - break; - default:vc.remove(n); - } - - numPoints--; - found = true; - n = vv.indexOf(v); - } - - if( found ) - { - cacheDirty=true; - } - - return found; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// -/** - * Removes a location'th Point from the List of Points we interpolate through. - * - * @param location index of the Point we want to remove. - * @return true if location is valid, i.e. if 0<=location<getNumPoints(). - */ - public synchronized boolean remove(int location) - { - if( location>=0 && location - * When Noise=0 (the default), we interpolate between our Points through the most smooth path possible. - * Increasing noise makes the Dynamic increasingly deviate from this path, pseudo-randomly speeding - * up and slowing down, etc. - * - * @param noise The noise level. Permitted range: 0 <= noise <= 1. - */ - - public synchronized void setNoise(Static4D noise) - { - if( vn==null ) - { - vn = new Vector<>(); - for(int i=0; i=2 ) - { - mFactor = new float[mDimension-1]; - } - - mNoise = new float[mDimension]; - } - - if( noise.x<0.0f ) noise.x = 0.0f; - if( noise.x>1.0f ) noise.x = 1.0f; - if( noise.y<0.0f ) noise.y = 0.0f; - if( noise.y>1.0f ) noise.y = 1.0f; - if( noise.z<0.0f ) noise.z = 0.0f; - if( noise.z>1.0f ) noise.z = 1.0f; - if( noise.w<0.0f ) noise.w = 0.0f; - if( noise.w>1.0f ) noise.w = 1.0f; - - mNoise[0] = noise.x; - mNoise[1] = noise.y; - mNoise[2] = noise.z; - mNoise[3] = noise.w; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - synchronized void interpolate(float[] buffer, int offset, float time) - { - switch(numPoints) - { - case 0: buffer[offset ] = 0.0f; - buffer[offset+1] = 0.0f; - buffer[offset+2] = 0.0f; - buffer[offset+3] = 0.0f; - break; - case 1: curr = vv.elementAt(0); - buffer[offset ] = curr.x; - buffer[offset+1] = curr.y; - buffer[offset+2] = curr.z; - buffer[offset+3] = curr.w; - break; - case 2: curr = vv.elementAt(0); - next = vv.elementAt(1); - - int segment= (int)(2*time); - - if( mMode==MODE_LOOP || mMode==MODE_PATH ) time = (time>0.5f ? 2-2*time : 2*time); - - if( vn!=null ) - { - if( segment != mSegment ) - { - if(mMode!=MODE_JUMP || mSegment==1) vn.elementAt(0).computeNoise(); - mSegment = segment; - } - - time = noise(time,0); - - buffer[offset ] = (next.x-curr.x)*time + curr.x + (baseV[1][0]*mFactor[0] + baseV[2][0]*mFactor[1] + baseV[3][0]*mFactor[2]); - buffer[offset+1] = (next.y-curr.y)*time + curr.y + (baseV[1][1]*mFactor[0] + baseV[2][1]*mFactor[1] + baseV[3][1]*mFactor[2]); - buffer[offset+2] = (next.z-curr.z)*time + curr.z + (baseV[1][2]*mFactor[0] + baseV[2][2]*mFactor[1] + baseV[3][2]*mFactor[2]); - buffer[offset+3] = (next.w-curr.w)*time + curr.w + (baseV[1][3]*mFactor[0] + baseV[2][3]*mFactor[1] + baseV[3][3]*mFactor[2]); - } - else - { - buffer[offset ] = (next.x-curr.x)*time + curr.x; - buffer[offset+1] = (next.y-curr.y)*time + curr.y; - buffer[offset+2] = (next.z-curr.z)*time + curr.z; - buffer[offset+3] = (next.w-curr.w)*time + curr.w; - } - - break; - default:computeSegmentAndTime(time); - - if( mTmpVec>=0 && mTmpVec vv; + private Static4D prev, curr, next; + +/////////////////////////////////////////////////////////////////////////////////////////////////// +// no array bounds checking! + + private void computeVelocity(int c) + { + int p = c>0 ? c-1: numPoints-1; + int n = c0 ) + { + float q = (float)Math.sqrt((px*px+py*py+pz*pz+pw*pw)/d); + + if( q>1 ) + { + tmpCache1.velocity[0] = nx+px/q; + tmpCache1.velocity[1] = ny+py/q; + tmpCache1.velocity[2] = nz+pz/q; + tmpCache1.velocity[3] = nw+pw/q; + } + else + { + tmpCache1.velocity[0] = px+nx*q; + tmpCache1.velocity[1] = py+ny*q; + tmpCache1.velocity[2] = pz+nz*q; + tmpCache1.velocity[3] = pw+nw*q; + } + } + else + { + tmpCache1.velocity[0] = 0.0f; + tmpCache1.velocity[1] = 0.0f; + tmpCache1.velocity[2] = 0.0f; + tmpCache1.velocity[3] = 0.0f; + } + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + private void recomputeCache() + { + if( numPoints==1 ) + { + tmpCache1 = vc.elementAt(0); + curr= vv.elementAt(0); + + tmpCache1.a[0] = tmpCache1.a[1] = tmpCache1.a[2] = tmpCache1.a[3] = 0.0f; + tmpCache1.b[0] = tmpCache1.b[1] = tmpCache1.b[2] = tmpCache1.b[3] = 0.0f; + tmpCache1.c[0] = curr.x; + tmpCache1.c[1] = curr.y; + tmpCache1.c[2] = curr.z; + tmpCache1.c[3] = curr.w; + tmpCache1.d[0] = tmpCache1.d[1] = tmpCache1.d[3] = tmpCache1.d[3] = 0.0f; + } + else if( numPoints==2 ) + { + tmpCache1 = vc.elementAt(0); + tmpCache2 = vc.elementAt(1); + curr= vv.elementAt(0); + next= vv.elementAt(1); + + tmpCache1.a[0] = tmpCache1.a[1] = tmpCache1.a[2] = tmpCache1.a[3] = 0.0f; + tmpCache1.b[0] = tmpCache1.b[1] = tmpCache1.b[2] = tmpCache1.b[3] = 0.0f; + tmpCache1.c[0] = next.x - curr.x; + tmpCache1.c[1] = next.y - curr.y; + tmpCache1.c[2] = next.z - curr.z; + tmpCache1.c[3] = next.w - curr.w; + tmpCache1.d[0] = curr.x; + tmpCache1.d[1] = curr.y; + tmpCache1.d[2] = curr.z; + tmpCache1.d[3] = curr.w; + + tmpCache2.a[0] = tmpCache2.a[1] = tmpCache2.a[2] = tmpCache2.a[3] = 0.0f; + tmpCache2.b[0] = tmpCache2.b[1] = tmpCache2.b[2] = tmpCache2.b[3] = 0.0f; + tmpCache2.c[0] = curr.x - next.x; + tmpCache2.c[1] = curr.y - next.y; + tmpCache2.c[2] = curr.z - next.z; + tmpCache2.c[3] = curr.w - next.w; + tmpCache2.d[0] = next.x; + tmpCache2.d[1] = next.y; + tmpCache2.d[2] = next.z; + tmpCache2.d[3] = next.w; + } + else + { + int i, n; + + for(i=0; i(); + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// +/** + * Constructor setting the speed of interpolation and the number of revolutions. + * + * What constitutes 'one revolution' depends on the MODE: + * {@link Dynamic#MODE_LOOP}, {@link Dynamic#MODE_PATH} or {@link Dynamic#MODE_JUMP}. + * + * @param duration number of milliseconds it takes to do one revolution. + * @param count number of revolutions we will do. Count<=0 means 'infinite'. + */ + public Dynamic4D(int duration, float count) + { + super(duration,count,4); + vv = new Vector<>(); + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// +/** + * Returns the location'th Static4D. + * + * @param location the index of the Point we are interested in. + * @return The Static4D, if 0<=location<getNumPoints(), or null otherwise. + */ + public synchronized Static4D getPoint(int location) + { + return (location>=0 && location=0 && location + * Only a reference to the Point gets added to the List; this means that one can add a Point + * here, and later on {@link Static4D#set(float,float,float,float)} it to some new value and + * the change will be seamlessly reflected in the interpolated path. + *

    + * A Point can be added multiple times. + * + * @param v The Point to add. + */ + public synchronized void add(Static4D v) + { + if( v!=null ) + { + vv.add(v); + + if( vn!=null ) vn.add(new VectorNoise()); + + switch(numPoints) + { + case 0: break; + case 1: computeOrthonormalBase2(vv.elementAt(0),v); + break; + case 2: vc.add(new VectorCache()); + vc.add(new VectorCache()); + vc.add(new VectorCache()); + break; + default:vc.add(new VectorCache()); + } + + numPoints++; + cacheDirty = true; + } + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// +/** + * Adds a new Static4D to the location'th place in our List of Points to interpolate through. + * + * @param location Index in our List to add the new Point at. + * @param v The Static4D to add. + */ + public synchronized void add(int location, Static4D v) + { + if( v!=null ) + { + vv.add(location, v); + + if( vn!=null ) vn.add(new VectorNoise()); + + switch(numPoints) + { + case 0: break; + case 1: computeOrthonormalBase2(vv.elementAt(0),v); + break; + case 2: vc.add(new VectorCache()); + vc.add(new VectorCache()); + vc.add(new VectorCache()); + break; + default:vc.add(location,new VectorCache()); + } + + numPoints++; + cacheDirty = true; + } + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// +/** + * Removes all occurrences of Point v from the List of Points to interpolate through. + * + * @param v The Point to remove. + * @return true if we have removed at least one Point. + */ + public synchronized boolean remove(Static4D v) + { + int n = vv.indexOf(v); + boolean found = false; + + while( n>=0 ) + { + vv.remove(n); + + if( vn!=null ) vn.remove(0); + + switch(numPoints) + { + case 0: + case 1: + case 2: break; + case 3: vc.removeAllElements(); + computeOrthonormalBase2(vv.elementAt(0),vv.elementAt(1)); + break; + default:vc.remove(n); + } + + numPoints--; + found = true; + n = vv.indexOf(v); + } + + if( found ) + { + cacheDirty=true; + } + + return found; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// +/** + * Removes a location'th Point from the List of Points we interpolate through. + * + * @param location index of the Point we want to remove. + * @return true if location is valid, i.e. if 0<=location<getNumPoints(). + */ + public synchronized boolean remove(int location) + { + if( location>=0 && location + * When Noise=0 (the default), we interpolate between our Points through the most smooth path possible. + * Increasing noise makes the Dynamic increasingly deviate from this path, pseudo-randomly speeding + * up and slowing down, etc. + * + * @param noise The noise level. Permitted range: 0 <= noise <= 1. + */ + + public synchronized void setNoise(Static4D noise) + { + if( vn==null ) + { + vn = new Vector<>(); + for(int i=0; i=2 ) + { + mFactor = new float[mDimension-1]; + } + + mNoise = new float[mDimension]; + } + + if( noise.x<0.0f ) noise.x = 0.0f; + if( noise.x>1.0f ) noise.x = 1.0f; + if( noise.y<0.0f ) noise.y = 0.0f; + if( noise.y>1.0f ) noise.y = 1.0f; + if( noise.z<0.0f ) noise.z = 0.0f; + if( noise.z>1.0f ) noise.z = 1.0f; + if( noise.w<0.0f ) noise.w = 0.0f; + if( noise.w>1.0f ) noise.w = 1.0f; + + mNoise[0] = noise.x; + mNoise[1] = noise.y; + mNoise[2] = noise.z; + mNoise[3] = noise.w; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + synchronized void interpolate(float[] buffer, int offset, float time) + { + switch(numPoints) + { + case 0: buffer[offset ] = 0.0f; + buffer[offset+1] = 0.0f; + buffer[offset+2] = 0.0f; + buffer[offset+3] = 0.0f; + break; + case 1: curr = vv.elementAt(0); + buffer[offset ] = curr.x; + buffer[offset+1] = curr.y; + buffer[offset+2] = curr.z; + buffer[offset+3] = curr.w; + break; + case 2: curr = vv.elementAt(0); + next = vv.elementAt(1); + + int segment= (int)(2*time); + + if( mMode==MODE_LOOP || mMode==MODE_PATH ) time = (time>0.5f ? 2-2*time : 2*time); + + if( vn!=null ) + { + if( segment != mSegment ) + { + if(mMode!=MODE_JUMP || mSegment==1) vn.elementAt(0).computeNoise(); + mSegment = segment; + } + + time = noise(time,0); + + buffer[offset ] = (next.x-curr.x)*time + curr.x + (baseV[1][0]*mFactor[0] + baseV[2][0]*mFactor[1] + baseV[3][0]*mFactor[2]); + buffer[offset+1] = (next.y-curr.y)*time + curr.y + (baseV[1][1]*mFactor[0] + baseV[2][1]*mFactor[1] + baseV[3][1]*mFactor[2]); + buffer[offset+2] = (next.z-curr.z)*time + curr.z + (baseV[1][2]*mFactor[0] + baseV[2][2]*mFactor[1] + baseV[3][2]*mFactor[2]); + buffer[offset+3] = (next.w-curr.w)*time + curr.w + (baseV[1][3]*mFactor[0] + baseV[2][3]*mFactor[1] + baseV[3][3]*mFactor[2]); + } + else + { + buffer[offset ] = (next.x-curr.x)*time + curr.x; + buffer[offset+1] = (next.y-curr.y)*time + curr.y; + buffer[offset+2] = (next.z-curr.z)*time + curr.z; + buffer[offset+3] = (next.w-curr.w)*time + curr.w; + } + + break; + default:computeSegmentAndTime(time); + + if( mTmpVec>=0 && mTmpVec vv; - private Static5D prev, curr, next; - -/////////////////////////////////////////////////////////////////////////////////////////////////// -// no array bounds checking! - - private void computeVelocity(int c) - { - int p = c>0 ? c-1: numPoints-1; - int n = c0 ) - { - float q = (float)Math.sqrt((px*px+py*py+pz*pz+pw*pw+pv*pv)/d); - - if( q>1 ) - { - tmpCache1.velocity[0] = nx+px/q; - tmpCache1.velocity[1] = ny+py/q; - tmpCache1.velocity[2] = nz+pz/q; - tmpCache1.velocity[3] = nw+pw/q; - tmpCache1.velocity[4] = nv+pv/q; - } - else - { - tmpCache1.velocity[0] = px+nx*q; - tmpCache1.velocity[1] = py+ny*q; - tmpCache1.velocity[2] = pz+nz*q; - tmpCache1.velocity[3] = pw+nw*q; - tmpCache1.velocity[4] = pv+nv*q; - } - } - else - { - tmpCache1.velocity[0] = 0.0f; - tmpCache1.velocity[1] = 0.0f; - tmpCache1.velocity[2] = 0.0f; - tmpCache1.velocity[3] = 0.0f; - tmpCache1.velocity[4] = 0.0f; - } - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - private void recomputeCache() - { - if( numPoints==1 ) - { - tmpCache1 = vc.elementAt(0); - curr= vv.elementAt(0); - - tmpCache1.a[0] = tmpCache1.a[1] = tmpCache1.a[2] = tmpCache1.a[3] = tmpCache1.a[4] = 0.0f; - tmpCache1.b[0] = tmpCache1.b[1] = tmpCache1.b[2] = tmpCache1.b[3] = tmpCache1.b[4] = 0.0f; - tmpCache1.c[0] = curr.x; - tmpCache1.c[1] = curr.y; - tmpCache1.c[2] = curr.z; - tmpCache1.c[3] = curr.w; - tmpCache1.c[4] = curr.v; - tmpCache1.d[0] = tmpCache1.d[1] = tmpCache1.d[2] = tmpCache1.d[3] = tmpCache1.d[4] = 0.0f; - } - else if( numPoints==2 ) - { - tmpCache1 = vc.elementAt(0); - tmpCache2 = vc.elementAt(1); - curr= vv.elementAt(0); - next= vv.elementAt(1); - - tmpCache1.a[0] = tmpCache1.a[1] = tmpCache1.a[2] = tmpCache1.a[3] = tmpCache1.a[4] = 0.0f; - tmpCache1.b[0] = tmpCache1.b[1] = tmpCache1.b[2] = tmpCache1.b[3] = tmpCache1.b[4] = 0.0f; - tmpCache1.c[0] = next.x - curr.x; - tmpCache1.c[1] = next.y - curr.y; - tmpCache1.c[2] = next.z - curr.z; - tmpCache1.c[3] = next.w - curr.w; - tmpCache1.c[4] = next.v - curr.v; - tmpCache1.d[0] = curr.x; - tmpCache1.d[1] = curr.y; - tmpCache1.d[2] = curr.z; - tmpCache1.d[3] = curr.w; - tmpCache1.d[4] = curr.v; - - tmpCache2.a[0] = tmpCache2.a[1] = tmpCache2.a[2] = tmpCache2.a[3] = tmpCache2.a[4] = 0.0f; - tmpCache2.b[0] = tmpCache2.b[1] = tmpCache2.b[2] = tmpCache2.b[3] = tmpCache2.b[4] = 0.0f; - tmpCache2.c[0] = curr.x - next.x; - tmpCache2.c[1] = curr.y - next.y; - tmpCache2.c[2] = curr.z - next.z; - tmpCache2.c[3] = curr.w - next.w; - tmpCache2.c[4] = curr.v - next.v; - tmpCache2.d[0] = next.x; - tmpCache2.d[1] = next.y; - tmpCache2.d[2] = next.z; - tmpCache2.d[3] = next.w; - tmpCache2.d[4] = next.v; - } - else - { - int i, n; - - for(i=0; i(); - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// -/** - * Constructor setting the speed of interpolation and the number of revolutions. - * - * What constitutes 'one revolution' depends on the MODE: - * {@link Dynamic#MODE_LOOP}, {@link Dynamic#MODE_PATH} or {@link Dynamic#MODE_JUMP}. - * - * @param duration number of milliseconds it takes to do one revolution. - * @param count number of revolutions we will do. Count<=0 means 'infinite'. - */ - public Dynamic5D(int duration, float count) - { - super(duration,count,5); - vv = new Vector<>(); - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// -/** - * Returns the location'th Static5D. - * - * @param location the index of the Point we are interested in. - * @return The Static5D, if 0<=location<getNumPoints(), or null otherwise. - */ - public synchronized Static5D getPoint(int location) - { - return (location>=0 && location=0 && location - * Only a reference to the Point gets added to the List; this means that one can add a Point - * here, and later on {@link Static5D#set(float,float,float,float,float)} it to some new value and - * the change will be seamlessly reflected in the interpolated path. - *

    - * A Point can be added multiple times. - * - * @param v The Point to add. - */ - public synchronized void add(Static5D v) - { - if( v!=null ) - { - vv.add(v); - - if( vn!=null ) vn.add(new VectorNoise()); - - switch(numPoints) - { - case 0: break; - case 1: computeOrthonormalBase2(vv.elementAt(0),v); - break; - case 2: vc.add(new VectorCache()); - vc.add(new VectorCache()); - vc.add(new VectorCache()); - break; - default:vc.add(new VectorCache()); - } - - numPoints++; - cacheDirty = true; - } - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// -/** - * Adds a new Static5D to the location'th place in our List of Points to interpolate through. - * - * @param location Index in our List to add the new Point at. - * @param v The Static5D to add. - */ - public synchronized void add(int location, Static5D v) - { - if( v!=null ) - { - vv.add(location, v); - - if( vn!=null ) vn.add(new VectorNoise()); - - switch(numPoints) - { - case 0: break; - case 1: computeOrthonormalBase2(vv.elementAt(0),v); - break; - case 2: vc.add(new VectorCache()); - vc.add(new VectorCache()); - vc.add(new VectorCache()); - break; - default:vc.add(location,new VectorCache()); - } - - numPoints++; - cacheDirty = true; - } - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// -/** - * Removes all occurrences of Point v from the List of Points to interpolate through. - * - * @param v The Point to remove. - * @return true if we have removed at least one Point. - */ - public synchronized boolean remove(Static5D v) - { - int n = vv.indexOf(v); - boolean found = false; - - while( n>=0 ) - { - vv.remove(n); - - if( vn!=null ) vn.remove(0); - - switch(numPoints) - { - case 0: - case 1: - case 2: break; - case 3: vc.removeAllElements(); - computeOrthonormalBase2(vv.elementAt(0),vv.elementAt(1)); - break; - default:vc.remove(n); - } - - numPoints--; - found = true; - n = vv.indexOf(v); - } - - if( found ) - { - cacheDirty=true; - } - - return found; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// -/** - * Removes a location'th Point from the List of Points we interpolate through. - * - * @param location index of the Point we want to remove. - * @return true if location is valid, i.e. if 0<=location<getNumPoints(). - */ - public synchronized boolean remove(int location) - { - if( location>=0 && location - * When Noise=0 (the default), we interpolate between our Points through the most smooth path possible. - * Increasing noise makes the Dynamic increasingly deviate from this path, pseudo-randomly speeding - * up and slowing down, etc. - * - * @param noise The noise level. Permitted range: 0 <= noise <= 1. - */ - - public synchronized void setNoise(Static5D noise) - { - if( vn==null ) - { - vn = new Vector<>(); - for(int i=0; i=2 ) - { - mFactor = new float[mDimension-1]; - } - - mNoise = new float[mDimension]; - } - - if( noise.x<0.0f ) noise.x = 0.0f; - if( noise.x>1.0f ) noise.x = 1.0f; - if( noise.y<0.0f ) noise.y = 0.0f; - if( noise.y>1.0f ) noise.y = 1.0f; - if( noise.z<0.0f ) noise.z = 0.0f; - if( noise.z>1.0f ) noise.z = 1.0f; - if( noise.w<0.0f ) noise.w = 0.0f; - if( noise.w>1.0f ) noise.w = 1.0f; - if( noise.v<0.0f ) noise.v = 0.0f; - if( noise.v>1.0f ) noise.v = 1.0f; - - mNoise[0] = noise.x; - mNoise[1] = noise.y; - mNoise[2] = noise.z; - mNoise[3] = noise.w; - mNoise[4] = noise.v; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - synchronized void interpolate(float[] buffer, int offset, float time) - { - switch(numPoints) - { - case 0: buffer[offset ] = 0.0f; - buffer[offset+1] = 0.0f; - buffer[offset+2] = 0.0f; - buffer[offset+3] = 0.0f; - buffer[offset+4] = 0.0f; - break; - case 1: curr = vv.elementAt(0); - buffer[offset ] = curr.x; - buffer[offset+1] = curr.y; - buffer[offset+2] = curr.z; - buffer[offset+3] = curr.w; - buffer[offset+4] = curr.v; - break; - case 2: curr = vv.elementAt(0); - next = vv.elementAt(1); - - int segment= (int)(2*time); - - if( mMode==MODE_LOOP || mMode==MODE_PATH ) time = (time>0.5f ? 2-2*time : 2*time); - - if( vn!=null ) - { - if( segment != mSegment ) - { - if(mMode!=MODE_JUMP || mSegment==1) vn.elementAt(0).computeNoise(); - mSegment = segment; - } - - time = noise(time,0); - - buffer[offset ] = (next.x-curr.x)*time + curr.x + (baseV[1][0]*mFactor[0] + baseV[2][0]*mFactor[1] + baseV[3][0]*mFactor[2] + baseV[4][0]*mFactor[3]); - buffer[offset+1] = (next.y-curr.y)*time + curr.y + (baseV[1][1]*mFactor[0] + baseV[2][1]*mFactor[1] + baseV[3][1]*mFactor[2] + baseV[4][1]*mFactor[3]); - buffer[offset+2] = (next.z-curr.z)*time + curr.z + (baseV[1][2]*mFactor[0] + baseV[2][2]*mFactor[1] + baseV[3][2]*mFactor[2] + baseV[4][2]*mFactor[3]); - buffer[offset+3] = (next.w-curr.w)*time + curr.w + (baseV[1][3]*mFactor[0] + baseV[2][3]*mFactor[1] + baseV[3][3]*mFactor[2] + baseV[4][3]*mFactor[3]); - buffer[offset+4] = (next.v-curr.v)*time + curr.v + (baseV[1][4]*mFactor[0] + baseV[2][4]*mFactor[1] + baseV[3][4]*mFactor[2] + baseV[4][4]*mFactor[3]); - } - else - { - buffer[offset ] = (next.x-curr.x)*time + curr.x; - buffer[offset+1] = (next.y-curr.y)*time + curr.y; - buffer[offset+2] = (next.z-curr.z)*time + curr.z; - buffer[offset+3] = (next.w-curr.w)*time + curr.w; - buffer[offset+4] = (next.v-curr.v)*time + curr.v; - } - - break; - default:computeSegmentAndTime(time); - - if( mTmpVec>=0 && mTmpVec vv; + private Static5D prev, curr, next; + +/////////////////////////////////////////////////////////////////////////////////////////////////// +// no array bounds checking! + + private void computeVelocity(int c) + { + int p = c>0 ? c-1: numPoints-1; + int n = c0 ) + { + float q = (float)Math.sqrt((px*px+py*py+pz*pz+pw*pw+pv*pv)/d); + + if( q>1 ) + { + tmpCache1.velocity[0] = nx+px/q; + tmpCache1.velocity[1] = ny+py/q; + tmpCache1.velocity[2] = nz+pz/q; + tmpCache1.velocity[3] = nw+pw/q; + tmpCache1.velocity[4] = nv+pv/q; + } + else + { + tmpCache1.velocity[0] = px+nx*q; + tmpCache1.velocity[1] = py+ny*q; + tmpCache1.velocity[2] = pz+nz*q; + tmpCache1.velocity[3] = pw+nw*q; + tmpCache1.velocity[4] = pv+nv*q; + } + } + else + { + tmpCache1.velocity[0] = 0.0f; + tmpCache1.velocity[1] = 0.0f; + tmpCache1.velocity[2] = 0.0f; + tmpCache1.velocity[3] = 0.0f; + tmpCache1.velocity[4] = 0.0f; + } + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + private void recomputeCache() + { + if( numPoints==1 ) + { + tmpCache1 = vc.elementAt(0); + curr= vv.elementAt(0); + + tmpCache1.a[0] = tmpCache1.a[1] = tmpCache1.a[2] = tmpCache1.a[3] = tmpCache1.a[4] = 0.0f; + tmpCache1.b[0] = tmpCache1.b[1] = tmpCache1.b[2] = tmpCache1.b[3] = tmpCache1.b[4] = 0.0f; + tmpCache1.c[0] = curr.x; + tmpCache1.c[1] = curr.y; + tmpCache1.c[2] = curr.z; + tmpCache1.c[3] = curr.w; + tmpCache1.c[4] = curr.v; + tmpCache1.d[0] = tmpCache1.d[1] = tmpCache1.d[2] = tmpCache1.d[3] = tmpCache1.d[4] = 0.0f; + } + else if( numPoints==2 ) + { + tmpCache1 = vc.elementAt(0); + tmpCache2 = vc.elementAt(1); + curr= vv.elementAt(0); + next= vv.elementAt(1); + + tmpCache1.a[0] = tmpCache1.a[1] = tmpCache1.a[2] = tmpCache1.a[3] = tmpCache1.a[4] = 0.0f; + tmpCache1.b[0] = tmpCache1.b[1] = tmpCache1.b[2] = tmpCache1.b[3] = tmpCache1.b[4] = 0.0f; + tmpCache1.c[0] = next.x - curr.x; + tmpCache1.c[1] = next.y - curr.y; + tmpCache1.c[2] = next.z - curr.z; + tmpCache1.c[3] = next.w - curr.w; + tmpCache1.c[4] = next.v - curr.v; + tmpCache1.d[0] = curr.x; + tmpCache1.d[1] = curr.y; + tmpCache1.d[2] = curr.z; + tmpCache1.d[3] = curr.w; + tmpCache1.d[4] = curr.v; + + tmpCache2.a[0] = tmpCache2.a[1] = tmpCache2.a[2] = tmpCache2.a[3] = tmpCache2.a[4] = 0.0f; + tmpCache2.b[0] = tmpCache2.b[1] = tmpCache2.b[2] = tmpCache2.b[3] = tmpCache2.b[4] = 0.0f; + tmpCache2.c[0] = curr.x - next.x; + tmpCache2.c[1] = curr.y - next.y; + tmpCache2.c[2] = curr.z - next.z; + tmpCache2.c[3] = curr.w - next.w; + tmpCache2.c[4] = curr.v - next.v; + tmpCache2.d[0] = next.x; + tmpCache2.d[1] = next.y; + tmpCache2.d[2] = next.z; + tmpCache2.d[3] = next.w; + tmpCache2.d[4] = next.v; + } + else + { + int i, n; + + for(i=0; i(); + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// +/** + * Constructor setting the speed of interpolation and the number of revolutions. + * + * What constitutes 'one revolution' depends on the MODE: + * {@link Dynamic#MODE_LOOP}, {@link Dynamic#MODE_PATH} or {@link Dynamic#MODE_JUMP}. + * + * @param duration number of milliseconds it takes to do one revolution. + * @param count number of revolutions we will do. Count<=0 means 'infinite'. + */ + public Dynamic5D(int duration, float count) + { + super(duration,count,5); + vv = new Vector<>(); + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// +/** + * Returns the location'th Static5D. + * + * @param location the index of the Point we are interested in. + * @return The Static5D, if 0<=location<getNumPoints(), or null otherwise. + */ + public synchronized Static5D getPoint(int location) + { + return (location>=0 && location=0 && location + * Only a reference to the Point gets added to the List; this means that one can add a Point + * here, and later on {@link Static5D#set(float,float,float,float,float)} it to some new value and + * the change will be seamlessly reflected in the interpolated path. + *

    + * A Point can be added multiple times. + * + * @param v The Point to add. + */ + public synchronized void add(Static5D v) + { + if( v!=null ) + { + vv.add(v); + + if( vn!=null ) vn.add(new VectorNoise()); + + switch(numPoints) + { + case 0: break; + case 1: computeOrthonormalBase2(vv.elementAt(0),v); + break; + case 2: vc.add(new VectorCache()); + vc.add(new VectorCache()); + vc.add(new VectorCache()); + break; + default:vc.add(new VectorCache()); + } + + numPoints++; + cacheDirty = true; + } + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// +/** + * Adds a new Static5D to the location'th place in our List of Points to interpolate through. + * + * @param location Index in our List to add the new Point at. + * @param v The Static5D to add. + */ + public synchronized void add(int location, Static5D v) + { + if( v!=null ) + { + vv.add(location, v); + + if( vn!=null ) vn.add(new VectorNoise()); + + switch(numPoints) + { + case 0: break; + case 1: computeOrthonormalBase2(vv.elementAt(0),v); + break; + case 2: vc.add(new VectorCache()); + vc.add(new VectorCache()); + vc.add(new VectorCache()); + break; + default:vc.add(location,new VectorCache()); + } + + numPoints++; + cacheDirty = true; + } + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// +/** + * Removes all occurrences of Point v from the List of Points to interpolate through. + * + * @param v The Point to remove. + * @return true if we have removed at least one Point. + */ + public synchronized boolean remove(Static5D v) + { + int n = vv.indexOf(v); + boolean found = false; + + while( n>=0 ) + { + vv.remove(n); + + if( vn!=null ) vn.remove(0); + + switch(numPoints) + { + case 0: + case 1: + case 2: break; + case 3: vc.removeAllElements(); + computeOrthonormalBase2(vv.elementAt(0),vv.elementAt(1)); + break; + default:vc.remove(n); + } + + numPoints--; + found = true; + n = vv.indexOf(v); + } + + if( found ) + { + cacheDirty=true; + } + + return found; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// +/** + * Removes a location'th Point from the List of Points we interpolate through. + * + * @param location index of the Point we want to remove. + * @return true if location is valid, i.e. if 0<=location<getNumPoints(). + */ + public synchronized boolean remove(int location) + { + if( location>=0 && location + * When Noise=0 (the default), we interpolate between our Points through the most smooth path possible. + * Increasing noise makes the Dynamic increasingly deviate from this path, pseudo-randomly speeding + * up and slowing down, etc. + * + * @param noise The noise level. Permitted range: 0 <= noise <= 1. + */ + + public synchronized void setNoise(Static5D noise) + { + if( vn==null ) + { + vn = new Vector<>(); + for(int i=0; i=2 ) + { + mFactor = new float[mDimension-1]; + } + + mNoise = new float[mDimension]; + } + + if( noise.x<0.0f ) noise.x = 0.0f; + if( noise.x>1.0f ) noise.x = 1.0f; + if( noise.y<0.0f ) noise.y = 0.0f; + if( noise.y>1.0f ) noise.y = 1.0f; + if( noise.z<0.0f ) noise.z = 0.0f; + if( noise.z>1.0f ) noise.z = 1.0f; + if( noise.w<0.0f ) noise.w = 0.0f; + if( noise.w>1.0f ) noise.w = 1.0f; + if( noise.v<0.0f ) noise.v = 0.0f; + if( noise.v>1.0f ) noise.v = 1.0f; + + mNoise[0] = noise.x; + mNoise[1] = noise.y; + mNoise[2] = noise.z; + mNoise[3] = noise.w; + mNoise[4] = noise.v; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + synchronized void interpolate(float[] buffer, int offset, float time) + { + switch(numPoints) + { + case 0: buffer[offset ] = 0.0f; + buffer[offset+1] = 0.0f; + buffer[offset+2] = 0.0f; + buffer[offset+3] = 0.0f; + buffer[offset+4] = 0.0f; + break; + case 1: curr = vv.elementAt(0); + buffer[offset ] = curr.x; + buffer[offset+1] = curr.y; + buffer[offset+2] = curr.z; + buffer[offset+3] = curr.w; + buffer[offset+4] = curr.v; + break; + case 2: curr = vv.elementAt(0); + next = vv.elementAt(1); + + int segment= (int)(2*time); + + if( mMode==MODE_LOOP || mMode==MODE_PATH ) time = (time>0.5f ? 2-2*time : 2*time); + + if( vn!=null ) + { + if( segment != mSegment ) + { + if(mMode!=MODE_JUMP || mSegment==1) vn.elementAt(0).computeNoise(); + mSegment = segment; + } + + time = noise(time,0); + + buffer[offset ] = (next.x-curr.x)*time + curr.x + (baseV[1][0]*mFactor[0] + baseV[2][0]*mFactor[1] + baseV[3][0]*mFactor[2] + baseV[4][0]*mFactor[3]); + buffer[offset+1] = (next.y-curr.y)*time + curr.y + (baseV[1][1]*mFactor[0] + baseV[2][1]*mFactor[1] + baseV[3][1]*mFactor[2] + baseV[4][1]*mFactor[3]); + buffer[offset+2] = (next.z-curr.z)*time + curr.z + (baseV[1][2]*mFactor[0] + baseV[2][2]*mFactor[1] + baseV[3][2]*mFactor[2] + baseV[4][2]*mFactor[3]); + buffer[offset+3] = (next.w-curr.w)*time + curr.w + (baseV[1][3]*mFactor[0] + baseV[2][3]*mFactor[1] + baseV[3][3]*mFactor[2] + baseV[4][3]*mFactor[3]); + buffer[offset+4] = (next.v-curr.v)*time + curr.v + (baseV[1][4]*mFactor[0] + baseV[2][4]*mFactor[1] + baseV[3][4]*mFactor[2] + baseV[4][4]*mFactor[3]); + } + else + { + buffer[offset ] = (next.x-curr.x)*time + curr.x; + buffer[offset+1] = (next.y-curr.y)*time + curr.y; + buffer[offset+2] = (next.z-curr.z)*time + curr.z; + buffer[offset+3] = (next.w-curr.w)*time + curr.w; + buffer[offset+4] = (next.v-curr.v)*time + curr.v; + } + + break; + default:computeSegmentAndTime(time); + + if( mTmpVec>=0 && mTmpVec vc; - private VectorCacheQuat tmp1, tmp2; - - private final Vector vv; - private Static4D curr, next; - -/////////////////////////////////////////////////////////////////////////////////////////////////// -// Abramowitz / Stegun - - private static float arcCos(float x) - { - if( x<0 ) - return 3.14159265358979f - (float)Math.sqrt(1+x)*(1.5707288f + 0.2121144f*x + 0.074261f*x*x + 0.0187293f*x*x*x); - - return (float)Math.sqrt(1-x)*(1.5707288f - 0.2121144f*x + 0.074261f*x*x - 0.0187293f*x*x*x); - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// - - private void recomputeCache() - { - if( numPoints>=2 ) - { - int i, n; - Static4D cu,ne; - VectorCacheQuat vq; - - for(i=0; i(); - vc = new Vector<>(); - numPoints = 0; - cacheDirty = false; - mMode = MODE_LOOP; - mDuration = duration; - mCount = count; - mLastPos =-1; - mAccessType= ACCESS_TYPE_RANDOM; - mDimension = 4; - mSegment =-1; - - initDynamic(); - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// -/** - * Returns the location'th Static4D. - * - * @param location the index of the Point we are interested in. - * @return The Static4D, if 0<=location<getNumPoints(), or null otherwise. - */ - public synchronized Static4D getPoint(int location) - { - return (location>=0 && location - * Rotation Quaternion is assumed to be in the form ( axisX*sinT, axisY*sinT, axisZ*sinT, cosT ). - * - * @param location the index of the Point we are setting. - * @param x New value of its first float. - */ - public synchronized void setPoint(int location, float x, float y, float z, float w) - { - if( location>=0 && location - * Only a reference to the Point gets added to the List; this means that one can add a Point - * here, and later on {@link Static4D#set(float,float,float,float)} it to some new value and - * the change will be seamlessly reflected in the interpolated path. - *

    - * A Point can be added multiple times. - * - * @param v The Point to add. - */ - public synchronized void add(Static4D v) - { - if( v!=null ) - { - vv.add(v); - - switch(numPoints) - { - case 0: - case 1: vc.add(new VectorCacheQuat()); - vc.add(new VectorCacheQuat()); - break; - default:vc.add(new VectorCacheQuat()); - } - - numPoints++; - cacheDirty = true; - } - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// -/** - * Adds a new Static4D to the location'th place in our List of Points to interpolate through. - * - * @param location Index in our List to add the new Point at. - * @param v The Static4D to add. - */ - public synchronized void add(int location, Static4D v) - { - if( v!=null ) - { - vv.add(location, v); - - switch(numPoints) - { - case 0: - case 1: vc.add(new VectorCacheQuat()); - vc.add(new VectorCacheQuat()); - break; - default:vc.add(location,new VectorCacheQuat()); - } - - numPoints++; - cacheDirty = true; - } - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// -/** - * Removes all occurrences of Point v from the List of Points to interpolate through. - * - * @param v The Point to remove. - * @return true if we have removed at least one Point. - */ - public synchronized boolean remove(Static4D v) - { - int n = vv.indexOf(v); - boolean found = false; - - while( n>=0 ) - { - vv.remove(n); - - switch(numPoints) - { - case 0: - case 1: break; - case 2: vc.removeAllElements(); - break; - default:vc.remove(n); - } - - numPoints--; - found = true; - n = vv.indexOf(v); - } - - if( found ) - { - cacheDirty=true; - } - - return found; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// -/** - * Removes a location'th Point from the List of Points we interpolate through. - * - * @param location index of the Point we want to remove. - * @return true if location is valid, i.e. if 0<=location<getNumPoints(). - */ - public synchronized boolean remove(int location) - { - if( location>=0 && location - * Since this is a 4-dimensional Dynamic, the resulting interpolated Static4D gets written - * to four locations in the buffer: buffer[offset], buffer[offset+1], buffer[offset+2] and buffer[offset+3]. - * - * @param buffer Float buffer we will write the resulting Static4D to. - * @param offset Offset in the buffer where to write the result. - * @param 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: - * {@link Dynamic#MODE_LOOP}, {@link Dynamic#MODE_PATH} or {@link Dynamic#MODE_JUMP}. - **/ - synchronized void interpolate(float[] buffer, int offset, float time) - { - switch(numPoints) - { - case 0: buffer[offset ] = 0.0f; - buffer[offset+1] = 0.0f; - buffer[offset+2] = 0.0f; - buffer[offset+3] = 0.0f; - break; - case 1: curr = vv.elementAt(0); - buffer[offset ] = curr.x; - buffer[offset+1] = curr.y; - buffer[offset+2] = curr.z; - buffer[offset+3] = curr.w; - break; - default:float t = time; - int vecCurr, segment; - float scale0, scale1; - - switch(mMode) - { - case MODE_LOOP: time = time*numPoints; - segment = (int)time; - vecCurr = segment; - break; - case MODE_PATH: if( t>0.5f ) t = 1.0f-t; - time = 2*t*(numPoints-1); - segment = (int)(2*t*(numPoints-1)); - vecCurr = segment; - break; - case MODE_JUMP: time = time*(numPoints-1); - segment = (int)time; - vecCurr = segment; - break; - default : vecCurr = 0; - segment = 0; - } - - if( vecCurr>=0 && vecCurr vc; + private VectorCacheQuat tmp1, tmp2; + + private final Vector vv; + private Static4D curr, next; + +/////////////////////////////////////////////////////////////////////////////////////////////////// +// Abramowitz / Stegun + + private static float arcCos(float x) + { + if( x<0 ) + return 3.14159265358979f - (float)Math.sqrt(1+x)*(1.5707288f + 0.2121144f*x + 0.074261f*x*x + 0.0187293f*x*x*x); + + return (float)Math.sqrt(1-x)*(1.5707288f - 0.2121144f*x + 0.074261f*x*x - 0.0187293f*x*x*x); + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + private void recomputeCache() + { + if( numPoints>=2 ) + { + int i, n; + Static4D cu,ne; + VectorCacheQuat vq; + + for(i=0; i(); + vc = new Vector<>(); + numPoints = 0; + cacheDirty = false; + mMode = MODE_LOOP; + mDuration = duration; + mCount = count; + mLastPos =-1; + mAccessType= ACCESS_TYPE_RANDOM; + mDimension = 4; + mSegment =-1; + + initDynamic(); + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// +/** + * Returns the location'th Static4D. + * + * @param location the index of the Point we are interested in. + * @return The Static4D, if 0<=location<getNumPoints(), or null otherwise. + */ + public synchronized Static4D getPoint(int location) + { + return (location>=0 && location + * Rotation Quaternion is assumed to be in the form ( axisX*sinT, axisY*sinT, axisZ*sinT, cosT ). + * + * @param location the index of the Point we are setting. + * @param x New value of its first float. + */ + public synchronized void setPoint(int location, float x, float y, float z, float w) + { + if( location>=0 && location + * Only a reference to the Point gets added to the List; this means that one can add a Point + * here, and later on {@link Static4D#set(float,float,float,float)} it to some new value and + * the change will be seamlessly reflected in the interpolated path. + *

    + * A Point can be added multiple times. + * + * @param v The Point to add. + */ + public synchronized void add(Static4D v) + { + if( v!=null ) + { + vv.add(v); + + switch(numPoints) + { + case 0: + case 1: vc.add(new VectorCacheQuat()); + vc.add(new VectorCacheQuat()); + break; + default:vc.add(new VectorCacheQuat()); + } + + numPoints++; + cacheDirty = true; + } + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// +/** + * Adds a new Static4D to the location'th place in our List of Points to interpolate through. + * + * @param location Index in our List to add the new Point at. + * @param v The Static4D to add. + */ + public synchronized void add(int location, Static4D v) + { + if( v!=null ) + { + vv.add(location, v); + + switch(numPoints) + { + case 0: + case 1: vc.add(new VectorCacheQuat()); + vc.add(new VectorCacheQuat()); + break; + default:vc.add(location,new VectorCacheQuat()); + } + + numPoints++; + cacheDirty = true; + } + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// +/** + * Removes all occurrences of Point v from the List of Points to interpolate through. + * + * @param v The Point to remove. + * @return true if we have removed at least one Point. + */ + public synchronized boolean remove(Static4D v) + { + int n = vv.indexOf(v); + boolean found = false; + + while( n>=0 ) + { + vv.remove(n); + + switch(numPoints) + { + case 0: + case 1: break; + case 2: vc.removeAllElements(); + break; + default:vc.remove(n); + } + + numPoints--; + found = true; + n = vv.indexOf(v); + } + + if( found ) + { + cacheDirty=true; + } + + return found; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// +/** + * Removes a location'th Point from the List of Points we interpolate through. + * + * @param location index of the Point we want to remove. + * @return true if location is valid, i.e. if 0<=location<getNumPoints(). + */ + public synchronized boolean remove(int location) + { + if( location>=0 && location + * Since this is a 4-dimensional Dynamic, the resulting interpolated Static4D gets written + * to four locations in the buffer: buffer[offset], buffer[offset+1], buffer[offset+2] and buffer[offset+3]. + * + * @param buffer Float buffer we will write the resulting Static4D to. + * @param offset Offset in the buffer where to write the result. + * @param 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: + * {@link Dynamic#MODE_LOOP}, {@link Dynamic#MODE_PATH} or {@link Dynamic#MODE_JUMP}. + **/ + synchronized void interpolate(float[] buffer, int offset, float time) + { + switch(numPoints) + { + case 0: buffer[offset ] = 0.0f; + buffer[offset+1] = 0.0f; + buffer[offset+2] = 0.0f; + buffer[offset+3] = 0.0f; + break; + case 1: curr = vv.elementAt(0); + buffer[offset ] = curr.x; + buffer[offset+1] = curr.y; + buffer[offset+2] = curr.z; + buffer[offset+3] = curr.w; + break; + default:float t = time; + int vecCurr, segment; + float scale0, scale1; + + switch(mMode) + { + case MODE_LOOP: time = time*numPoints; + segment = (int)time; + vecCurr = segment; + break; + case MODE_PATH: if( t>0.5f ) t = 1.0f-t; + time = 2*t*(numPoints-1); + segment = (int)(2*t*(numPoints-1)); + vecCurr = segment; + break; + case MODE_JUMP: time = time*(numPoints-1); + segment = (int)time; + vecCurr = segment; + break; + default : vecCurr = 0; + segment = 0; + } + + if( vecCurr>=0 && vecCurrfalse - */ - public boolean get(float[] buffer, int offset, long time, long step) - { - buffer[offset] = x; - return false; - } - } diff --git a/src/main/java/org/distorted/library/type/Static1D.kt b/src/main/java/org/distorted/library/type/Static1D.kt new file mode 100644 index 0000000..0da4380 --- /dev/null +++ b/src/main/java/org/distorted/library/type/Static1D.kt @@ -0,0 +1,113 @@ +//////////////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2016 Leszek Koltunski leszek@koltunski.pl // +// // +// This file is part of Distorted. // +// // +// This library is free software; you can redistribute it and/or // +// modify it under the terms of the GNU Lesser General Public // +// License as published by the Free Software Foundation; either // +// version 2.1 of the License, or (at your option) any later version. // +// // +// This library is distributed in the hope that it will be useful, // +// but WITHOUT ANY WARRANTY; without even the implied warranty of // +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // +// Lesser General Public License for more details. // +// // +// You should have received a copy of the GNU Lesser General Public // +// License along with this library; if not, write to the Free Software // +// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA // +/////////////////////////////////////////////////////////////////////////////////////////////////// + +package org.distorted.library.type; + +/////////////////////////////////////////////////////////////////////////////////////////////////// +/** + * A 1-dimensional data structure containing a single float. The float has no particular meaning; + * when this data structure is used in Dynamics, we can think of it as a 1-dimensional Point + * a few of which the Dynamic interpolates between. + */ + +public class Static1D extends Static implements Data1D + { + float x; + +/////////////////////////////////////////////////////////////////////////////////////////////////// +/** + * Constructor that initialises the value of the single float to ox. + * + * @param ox value of the single float. + */ + public Static1D(float ox) + { + super(1); + x = ox; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// +/** + * Copy constructor. + */ + public Static1D(Static1D sta) + { + super(1); + x = sta.x; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// +/** + * Resets the value of the single float. + * + * @param ox new value of the single float. + */ + public void set(float ox) + { + x = ox; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// +/** + * Copy a Static1D. + */ + public void set(Static1D s) + { + x = s.x; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// +/** + * Resets the value of the first float. + * + * @param ox new value of the first float. + */ + public void set0(float ox) + { + x = ox; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// +/** + * Return the value of the float contained. + * + * @return The single float. + */ + public float get0() + { + return x; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// +/** + * 'Interpolation' between the single Point (i.e. always this very value) returned to the buffer. + * + * @param buffer Float buffer we will write the results to. + * @param offset Offset in the buffer where to write the result. + * @param time not used + * @param step not used + * @return false + */ + public boolean get(float[] buffer, int offset, long time, long step) + { + buffer[offset] = x; + return false; + } + } diff --git a/src/main/java/org/distorted/library/type/Static2D.java b/src/main/java/org/distorted/library/type/Static2D.java deleted file mode 100644 index 2d827ac..0000000 --- a/src/main/java/org/distorted/library/type/Static2D.java +++ /dev/null @@ -1,142 +0,0 @@ -//////////////////////////////////////////////////////////////////////////////////////////////////// -// Copyright 2016 Leszek Koltunski leszek@koltunski.pl // -// // -// This file is part of Distorted. // -// // -// This library is free software; you can redistribute it and/or // -// modify it under the terms of the GNU Lesser General Public // -// License as published by the Free Software Foundation; either // -// version 2.1 of the License, or (at your option) any later version. // -// // -// This library is distributed in the hope that it will be useful, // -// but WITHOUT ANY WARRANTY; without even the implied warranty of // -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // -// Lesser General Public License for more details. // -// // -// You should have received a copy of the GNU Lesser General Public // -// License along with this library; if not, write to the Free Software // -// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA // -/////////////////////////////////////////////////////////////////////////////////////////////////// - -package org.distorted.library.type; - -/////////////////////////////////////////////////////////////////////////////////////////////////// -/** - * A 2-dimensional data structure containing two floats. The floats have no particular meaning; - * when this data structure is used in Dynamics, we can think of it as a 2-dimensional Point - * a few of which the Dynamic interpolates between. - */ - -public class Static2D extends Static implements Data2D - { - float x,y; - -/////////////////////////////////////////////////////////////////////////////////////////////////// -/** - * Constructor that initialises the value of the two floats to (ox,oy). - * - * @param ox value of the first float. - * @param oy value of the second float. - */ - public Static2D(float ox, float oy) - { - super(2); - x = ox; - y = oy; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// -/** - * Copy constructor. - */ - public Static2D(Static2D sta) - { - super(2); - x = sta.x; - y = sta.y; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// -/** - * Reset the value of the floats to (ox,oy). - * - * @param ox new value of the first float - * @param oy new value of the seond float - */ - public void set(float ox, float oy) - { - x = ox; - y = oy; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// -/** - * Copy a Static2D. - */ - public void set(Static2D s) - { - x = s.x; - y = s.y; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// -/** - * Resets the value of the first float. - * - * @param ox new value of the first float. - */ - public void set0(float ox) - { - x = ox; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// -/** - * Resets the value of the second float. - * - * @param oy new value of the second float. - */ - public void set1(float oy) - { - y = oy; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// -/** - * Return the value of the first float contained. - * - * @return The first float. - */ - public float get0() - { - return x; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// -/** - * Return the value of the second float contained. - * - * @return The second float. - */ - public float get1() - { - return y; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// -/** - * 'Interpolation' between the single Point (i.e. always this very value) returned to the buffer. - * - * @param buffer Float buffer we will write the results to. - * @param offset Offset in the buffer where to write the result. - * @param time not used - * @param step not used - * @return false - */ - public boolean get(float[] buffer, int offset, long time, long step) - { - buffer[offset ] = x; - buffer[offset+1] = y; - return false; - } - } diff --git a/src/main/java/org/distorted/library/type/Static2D.kt b/src/main/java/org/distorted/library/type/Static2D.kt new file mode 100644 index 0000000..2d827ac --- /dev/null +++ b/src/main/java/org/distorted/library/type/Static2D.kt @@ -0,0 +1,142 @@ +//////////////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2016 Leszek Koltunski leszek@koltunski.pl // +// // +// This file is part of Distorted. // +// // +// This library is free software; you can redistribute it and/or // +// modify it under the terms of the GNU Lesser General Public // +// License as published by the Free Software Foundation; either // +// version 2.1 of the License, or (at your option) any later version. // +// // +// This library is distributed in the hope that it will be useful, // +// but WITHOUT ANY WARRANTY; without even the implied warranty of // +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // +// Lesser General Public License for more details. // +// // +// You should have received a copy of the GNU Lesser General Public // +// License along with this library; if not, write to the Free Software // +// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA // +/////////////////////////////////////////////////////////////////////////////////////////////////// + +package org.distorted.library.type; + +/////////////////////////////////////////////////////////////////////////////////////////////////// +/** + * A 2-dimensional data structure containing two floats. The floats have no particular meaning; + * when this data structure is used in Dynamics, we can think of it as a 2-dimensional Point + * a few of which the Dynamic interpolates between. + */ + +public class Static2D extends Static implements Data2D + { + float x,y; + +/////////////////////////////////////////////////////////////////////////////////////////////////// +/** + * Constructor that initialises the value of the two floats to (ox,oy). + * + * @param ox value of the first float. + * @param oy value of the second float. + */ + public Static2D(float ox, float oy) + { + super(2); + x = ox; + y = oy; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// +/** + * Copy constructor. + */ + public Static2D(Static2D sta) + { + super(2); + x = sta.x; + y = sta.y; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// +/** + * Reset the value of the floats to (ox,oy). + * + * @param ox new value of the first float + * @param oy new value of the seond float + */ + public void set(float ox, float oy) + { + x = ox; + y = oy; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// +/** + * Copy a Static2D. + */ + public void set(Static2D s) + { + x = s.x; + y = s.y; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// +/** + * Resets the value of the first float. + * + * @param ox new value of the first float. + */ + public void set0(float ox) + { + x = ox; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// +/** + * Resets the value of the second float. + * + * @param oy new value of the second float. + */ + public void set1(float oy) + { + y = oy; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// +/** + * Return the value of the first float contained. + * + * @return The first float. + */ + public float get0() + { + return x; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// +/** + * Return the value of the second float contained. + * + * @return The second float. + */ + public float get1() + { + return y; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// +/** + * 'Interpolation' between the single Point (i.e. always this very value) returned to the buffer. + * + * @param buffer Float buffer we will write the results to. + * @param offset Offset in the buffer where to write the result. + * @param time not used + * @param step not used + * @return false + */ + public boolean get(float[] buffer, int offset, long time, long step) + { + buffer[offset ] = x; + buffer[offset+1] = y; + return false; + } + } diff --git a/src/main/java/org/distorted/library/type/Static3D.java b/src/main/java/org/distorted/library/type/Static3D.java deleted file mode 100644 index c7dc291..0000000 --- a/src/main/java/org/distorted/library/type/Static3D.java +++ /dev/null @@ -1,171 +0,0 @@ -//////////////////////////////////////////////////////////////////////////////////////////////////// -// Copyright 2016 Leszek Koltunski leszek@koltunski.pl // -// // -// This file is part of Distorted. // -// // -// This library is free software; you can redistribute it and/or // -// modify it under the terms of the GNU Lesser General Public // -// License as published by the Free Software Foundation; either // -// version 2.1 of the License, or (at your option) any later version. // -// // -// This library is distributed in the hope that it will be useful, // -// but WITHOUT ANY WARRANTY; without even the implied warranty of // -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // -// Lesser General Public License for more details. // -// // -// You should have received a copy of the GNU Lesser General Public // -// License along with this library; if not, write to the Free Software // -// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA // -/////////////////////////////////////////////////////////////////////////////////////////////////// - -package org.distorted.library.type; - -/////////////////////////////////////////////////////////////////////////////////////////////////// -/** - * A 3-dimensional data structure containing three floats. The floats have no particular meaning; - * when this data structure is used in Dynamics, we can think of it as a 3-dimensional Point - * a few of which the Dynamic interpolates between. - */ - -public class Static3D extends Static implements Data3D - { - float x,y,z; - -/////////////////////////////////////////////////////////////////////////////////////////////////// -/** - * Constructor that initialises the value of the three floats to (vx,vy,vz). - * - * @param vx value of the first float. - * @param vy value of the second float. - * @param vz value of the third float. - */ - public Static3D(float vx, float vy, float vz) - { - super(3); - x = vx; - y = vy; - z = vz; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// -/** - * Copy constructor. - */ - public Static3D(Static3D sta) - { - super(3); - x = sta.x; - y = sta.y; - z = sta.z; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// -/** - * Reset the value of the floats to (vx,vy,vz). - * - * @param vx new value of the first float - * @param vy new value of the second float - * @param vz new value of the third float - */ - public void set(float vx, float vy, float vz) - { - x = vx; - y = vy; - z = vz; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// -/** - * Copy a Static3D. - */ - public void set(Static3D s) - { - x = s.x; - y = s.y; - z = s.z; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// -/** - * Resets the value of the first float. - * - * @param ox new value of the first float. - */ - public void set0(float ox) - { - x = ox; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// -/** - * Resets the value of the second float. - * - * @param oy new value of the second float. - */ - public void set1(float oy) - { - y = oy; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// -/** - * Resets the value of the third float. - * - * @param oz new value of the third float. - */ - public void set2(float oz) - { - z = oz; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// -/** - * Return the value of the first float contained. - * - * @return The first float. - */ - public float get0() - { - return x; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// -/** - * Return the value of the second float contained. - * - * @return The second float. - */ - public float get1() - { - return y; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// -/** - * Return the value of the third float contained. - * - * @return The third float. - */ - public float get2() - { - return z; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// -/** - * 'Interpolation' between the single Point (i.e. always this very value) returned to the buffer. - * - * @param buffer Float buffer we will write the results to. - * @param offset Offset in the buffer where to write the result. - * @param time not used - * @param step not used - * @return false - */ - public boolean get(float[] buffer, int offset, long time, long step) - { - buffer[offset ] = x; - buffer[offset+1] = y; - buffer[offset+2] = z; - return false; - } - } diff --git a/src/main/java/org/distorted/library/type/Static3D.kt b/src/main/java/org/distorted/library/type/Static3D.kt new file mode 100644 index 0000000..c7dc291 --- /dev/null +++ b/src/main/java/org/distorted/library/type/Static3D.kt @@ -0,0 +1,171 @@ +//////////////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2016 Leszek Koltunski leszek@koltunski.pl // +// // +// This file is part of Distorted. // +// // +// This library is free software; you can redistribute it and/or // +// modify it under the terms of the GNU Lesser General Public // +// License as published by the Free Software Foundation; either // +// version 2.1 of the License, or (at your option) any later version. // +// // +// This library is distributed in the hope that it will be useful, // +// but WITHOUT ANY WARRANTY; without even the implied warranty of // +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // +// Lesser General Public License for more details. // +// // +// You should have received a copy of the GNU Lesser General Public // +// License along with this library; if not, write to the Free Software // +// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA // +/////////////////////////////////////////////////////////////////////////////////////////////////// + +package org.distorted.library.type; + +/////////////////////////////////////////////////////////////////////////////////////////////////// +/** + * A 3-dimensional data structure containing three floats. The floats have no particular meaning; + * when this data structure is used in Dynamics, we can think of it as a 3-dimensional Point + * a few of which the Dynamic interpolates between. + */ + +public class Static3D extends Static implements Data3D + { + float x,y,z; + +/////////////////////////////////////////////////////////////////////////////////////////////////// +/** + * Constructor that initialises the value of the three floats to (vx,vy,vz). + * + * @param vx value of the first float. + * @param vy value of the second float. + * @param vz value of the third float. + */ + public Static3D(float vx, float vy, float vz) + { + super(3); + x = vx; + y = vy; + z = vz; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// +/** + * Copy constructor. + */ + public Static3D(Static3D sta) + { + super(3); + x = sta.x; + y = sta.y; + z = sta.z; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// +/** + * Reset the value of the floats to (vx,vy,vz). + * + * @param vx new value of the first float + * @param vy new value of the second float + * @param vz new value of the third float + */ + public void set(float vx, float vy, float vz) + { + x = vx; + y = vy; + z = vz; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// +/** + * Copy a Static3D. + */ + public void set(Static3D s) + { + x = s.x; + y = s.y; + z = s.z; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// +/** + * Resets the value of the first float. + * + * @param ox new value of the first float. + */ + public void set0(float ox) + { + x = ox; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// +/** + * Resets the value of the second float. + * + * @param oy new value of the second float. + */ + public void set1(float oy) + { + y = oy; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// +/** + * Resets the value of the third float. + * + * @param oz new value of the third float. + */ + public void set2(float oz) + { + z = oz; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// +/** + * Return the value of the first float contained. + * + * @return The first float. + */ + public float get0() + { + return x; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// +/** + * Return the value of the second float contained. + * + * @return The second float. + */ + public float get1() + { + return y; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// +/** + * Return the value of the third float contained. + * + * @return The third float. + */ + public float get2() + { + return z; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// +/** + * 'Interpolation' between the single Point (i.e. always this very value) returned to the buffer. + * + * @param buffer Float buffer we will write the results to. + * @param offset Offset in the buffer where to write the result. + * @param time not used + * @param step not used + * @return false + */ + public boolean get(float[] buffer, int offset, long time, long step) + { + buffer[offset ] = x; + buffer[offset+1] = y; + buffer[offset+2] = z; + return false; + } + } diff --git a/src/main/java/org/distorted/library/type/Static4D.java b/src/main/java/org/distorted/library/type/Static4D.java deleted file mode 100644 index 3ffbedb..0000000 --- a/src/main/java/org/distorted/library/type/Static4D.java +++ /dev/null @@ -1,200 +0,0 @@ -//////////////////////////////////////////////////////////////////////////////////////////////////// -// Copyright 2016 Leszek Koltunski leszek@koltunski.pl // -// // -// This file is part of Distorted. // -// // -// This library is free software; you can redistribute it and/or // -// modify it under the terms of the GNU Lesser General Public // -// License as published by the Free Software Foundation; either // -// version 2.1 of the License, or (at your option) any later version. // -// // -// This library is distributed in the hope that it will be useful, // -// but WITHOUT ANY WARRANTY; without even the implied warranty of // -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // -// Lesser General Public License for more details. // -// // -// You should have received a copy of the GNU Lesser General Public // -// License along with this library; if not, write to the Free Software // -// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA // -/////////////////////////////////////////////////////////////////////////////////////////////////// - -package org.distorted.library.type; - -/////////////////////////////////////////////////////////////////////////////////////////////////// -/** - * A 4-dimensional data structure containing four floats. The floats have no particular meaning; - * when this data structure is used in Dynamics, we can think of it as a 4-dimensional Point - * a few of which the Dynamic interpolates between. - */ - -public class Static4D extends Static implements Data4D - { - float x,y,z,w; - -/////////////////////////////////////////////////////////////////////////////////////////////////// -/** - * Constructor that initialises the value of the four floats to (vx,vy,vz,vw). - * - * @param vx value of the first float. - * @param vy value of the second float. - * @param vz value of the third float. - * @param vw value of the fourth float. - */ - public Static4D(float vx, float vy, float vz, float vw) - { - super(4); - x = vx; - y = vy; - z = vz; - w = vw; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// -/** - * Copy constructor. - */ - public Static4D(Static4D sta) - { - super(4); - x = sta.x; - y = sta.y; - z = sta.z; - w = sta.w; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// -/** - * Reset the value of the floats to (vx,vy,vz,vw). - * - * @param vx new value of the first float - * @param vy new value of the second float - * @param vz new value of the third float - * @param vw new value of the fourth float - */ - public void set(float vx, float vy, float vz, float vw) - { - x = vx; - y = vy; - z = vz; - w = vw; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// -/** - * Copy a Static4D. - */ - public void set(Static4D s) - { - x = s.x; - y = s.y; - z = s.z; - w = s.w; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// -/** - * Resets the value of the first float. - * - * @param ox new value of the first float. - */ - public void set0(float ox) - { - x = ox; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// -/** - * Resets the value of the second float. - * - * @param oy new value of the second float. - */ - public void set1(float oy) - { - y = oy; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// -/** - * Resets the value of the third float. - * - * @param oz new value of the third float. - */ - public void set2(float oz) - { - z = oz; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// -/** - * Resets the value of the fourth float. - * - * @param ow new value of the fourth float. - */ - public void set3(float ow) - { - w = ow; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// -/** - * Return the value of the first float contained. - * - * @return The first float. - */ - public float get0() - { - return x; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// -/** - * Return the value of the second float contained. - * - * @return The second float. - */ - public float get1() - { - return y; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// -/** - * Return the value of the third float contained. - * - * @return The third float. - */ - public float get2() - { - return z; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// -/** - * Return the value of the fourth float contained. - * - * @return The fourth float. - */ - public float get3() - { - return w; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// -/** - * 'Interpolation' between the single Point (i.e. always this very value) returned to the buffer. - * - * @param buffer Float buffer we will write the results to. - * @param offset Offset in the buffer where to write the result. - * @param time not used - * @param step not used - * @return false - */ - public boolean get(float[] buffer, int offset, long time, long step) - { - buffer[offset ] = x; - buffer[offset+1] = y; - buffer[offset+2] = z; - buffer[offset+3] = w; - return false; - } - } diff --git a/src/main/java/org/distorted/library/type/Static4D.kt b/src/main/java/org/distorted/library/type/Static4D.kt new file mode 100644 index 0000000..3ffbedb --- /dev/null +++ b/src/main/java/org/distorted/library/type/Static4D.kt @@ -0,0 +1,200 @@ +//////////////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2016 Leszek Koltunski leszek@koltunski.pl // +// // +// This file is part of Distorted. // +// // +// This library is free software; you can redistribute it and/or // +// modify it under the terms of the GNU Lesser General Public // +// License as published by the Free Software Foundation; either // +// version 2.1 of the License, or (at your option) any later version. // +// // +// This library is distributed in the hope that it will be useful, // +// but WITHOUT ANY WARRANTY; without even the implied warranty of // +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // +// Lesser General Public License for more details. // +// // +// You should have received a copy of the GNU Lesser General Public // +// License along with this library; if not, write to the Free Software // +// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA // +/////////////////////////////////////////////////////////////////////////////////////////////////// + +package org.distorted.library.type; + +/////////////////////////////////////////////////////////////////////////////////////////////////// +/** + * A 4-dimensional data structure containing four floats. The floats have no particular meaning; + * when this data structure is used in Dynamics, we can think of it as a 4-dimensional Point + * a few of which the Dynamic interpolates between. + */ + +public class Static4D extends Static implements Data4D + { + float x,y,z,w; + +/////////////////////////////////////////////////////////////////////////////////////////////////// +/** + * Constructor that initialises the value of the four floats to (vx,vy,vz,vw). + * + * @param vx value of the first float. + * @param vy value of the second float. + * @param vz value of the third float. + * @param vw value of the fourth float. + */ + public Static4D(float vx, float vy, float vz, float vw) + { + super(4); + x = vx; + y = vy; + z = vz; + w = vw; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// +/** + * Copy constructor. + */ + public Static4D(Static4D sta) + { + super(4); + x = sta.x; + y = sta.y; + z = sta.z; + w = sta.w; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// +/** + * Reset the value of the floats to (vx,vy,vz,vw). + * + * @param vx new value of the first float + * @param vy new value of the second float + * @param vz new value of the third float + * @param vw new value of the fourth float + */ + public void set(float vx, float vy, float vz, float vw) + { + x = vx; + y = vy; + z = vz; + w = vw; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// +/** + * Copy a Static4D. + */ + public void set(Static4D s) + { + x = s.x; + y = s.y; + z = s.z; + w = s.w; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// +/** + * Resets the value of the first float. + * + * @param ox new value of the first float. + */ + public void set0(float ox) + { + x = ox; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// +/** + * Resets the value of the second float. + * + * @param oy new value of the second float. + */ + public void set1(float oy) + { + y = oy; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// +/** + * Resets the value of the third float. + * + * @param oz new value of the third float. + */ + public void set2(float oz) + { + z = oz; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// +/** + * Resets the value of the fourth float. + * + * @param ow new value of the fourth float. + */ + public void set3(float ow) + { + w = ow; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// +/** + * Return the value of the first float contained. + * + * @return The first float. + */ + public float get0() + { + return x; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// +/** + * Return the value of the second float contained. + * + * @return The second float. + */ + public float get1() + { + return y; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// +/** + * Return the value of the third float contained. + * + * @return The third float. + */ + public float get2() + { + return z; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// +/** + * Return the value of the fourth float contained. + * + * @return The fourth float. + */ + public float get3() + { + return w; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// +/** + * 'Interpolation' between the single Point (i.e. always this very value) returned to the buffer. + * + * @param buffer Float buffer we will write the results to. + * @param offset Offset in the buffer where to write the result. + * @param time not used + * @param step not used + * @return false + */ + public boolean get(float[] buffer, int offset, long time, long step) + { + buffer[offset ] = x; + buffer[offset+1] = y; + buffer[offset+2] = z; + buffer[offset+3] = w; + return false; + } + } diff --git a/src/main/java/org/distorted/library/type/Static5D.java b/src/main/java/org/distorted/library/type/Static5D.java deleted file mode 100644 index 8d6d247..0000000 --- a/src/main/java/org/distorted/library/type/Static5D.java +++ /dev/null @@ -1,229 +0,0 @@ -//////////////////////////////////////////////////////////////////////////////////////////////////// -// Copyright 2016 Leszek Koltunski leszek@koltunski.pl // -// // -// This file is part of Distorted. // -// // -// This library is free software; you can redistribute it and/or // -// modify it under the terms of the GNU Lesser General Public // -// License as published by the Free Software Foundation; either // -// version 2.1 of the License, or (at your option) any later version. // -// // -// This library is distributed in the hope that it will be useful, // -// but WITHOUT ANY WARRANTY; without even the implied warranty of // -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // -// Lesser General Public License for more details. // -// // -// You should have received a copy of the GNU Lesser General Public // -// License along with this library; if not, write to the Free Software // -// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA // -/////////////////////////////////////////////////////////////////////////////////////////////////// - -package org.distorted.library.type; - -/////////////////////////////////////////////////////////////////////////////////////////////////// -/** - * A 5-dimensional data structure containing five floats. The floats have no particular meaning; - * when this data structure is used in Dynamics, we can think of it as a 5-dimensional Point - * a few of which the Dynamic interpolates between. - */ - -public class Static5D extends Static implements Data5D - { - float x,y,z,w,v; - -/////////////////////////////////////////////////////////////////////////////////////////////////// -/** - * Constructor that initialises the value of the five floats to (vx,vy,vz,vw,vv). - * - * @param vx value of the first float. - * @param vy value of the second float. - * @param vz value of the third float. - * @param vw value of the fourth float. - * @param vv value of the fifth float. - */ - public Static5D(float vx, float vy, float vz, float vw, float vv) - { - super(5); - x = vx; - y = vy; - z = vz; - w = vw; - v = vv; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// -/** - * Copy constructor. - */ - public Static5D(Static5D sta) - { - super(5); - x = sta.x; - y = sta.y; - z = sta.z; - w = sta.w; - v = sta.v; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// -/** - * Reset the value of the floats to (vx,vy,vz,vw,vv). - * - * @param vx new value of the first float - * @param vy new value of the second float - * @param vz new value of the third float - * @param vw new value of the fourth float - * @param vv new value of the fifth float - */ - public void set(float vx, float vy, float vz, float vw, float vv) - { - x = vx; - y = vy; - z = vz; - w = vw; - v = vv; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// -/** - * Copy a Static5D. - */ - public void set(Static5D s) - { - x = s.x; - y = s.y; - z = s.z; - w = s.w; - v = s.v; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// -/** - * Resets the value of the first float. - * - * @param ox new value of the first float. - */ - public void set0(float ox) - { - x = ox; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// -/** - * Resets the value of the second float. - * - * @param oy new value of the second float. - */ - public void set1(float oy) - { - y = oy; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// -/** - * Resets the value of the third float. - * - * @param oz new value of the third float. - */ - public void set2(float oz) - { - z = oz; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// -/** - * Resets the value of the fourth float. - * - * @param ow new value of the fourth float. - */ - public void set3(float ow) - { - w = ow; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// -/** - * Resets the value of the fifth float. - * - * @param ov new value of the fifth float. - */ - public void set4(float ov) - { - v = ov; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// -/** - * Return the value of the first float contained. - * - * @return The first float. - */ - public float get0() - { - return x; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// -/** - * Return the value of the second float contained. - * - * @return The second float. - */ - public float get1() - { - return y; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// -/** - * Return the value of the third float contained. - * - * @return The third float. - */ - public float get2() - { - return z; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// -/** - * Return the value of the fourth float contained. - * - * @return The fourth float. - */ - public float get3() - { - return w; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// -/** - * Return the value of the fifth float contained. - * - * @return The fifth float. - */ - public float get4() - { - return v; - } - -/////////////////////////////////////////////////////////////////////////////////////////////////// -/** - * 'Interpolation' between the single Point (i.e. always this very value) returned to the buffer. - * - * @param buffer Float buffer we will write the results to. - * @param offset Offset in the buffer where to write the result. - * @param time not used - * @param step not used - * @return false - */ - public boolean get(float[] buffer, int offset, long time, long step) - { - buffer[offset ] = x; - buffer[offset+1] = y; - buffer[offset+2] = z; - buffer[offset+3] = w; - buffer[offset+4] = v; - return false; - } - } diff --git a/src/main/java/org/distorted/library/type/Static5D.kt b/src/main/java/org/distorted/library/type/Static5D.kt new file mode 100644 index 0000000..8d6d247 --- /dev/null +++ b/src/main/java/org/distorted/library/type/Static5D.kt @@ -0,0 +1,229 @@ +//////////////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2016 Leszek Koltunski leszek@koltunski.pl // +// // +// This file is part of Distorted. // +// // +// This library is free software; you can redistribute it and/or // +// modify it under the terms of the GNU Lesser General Public // +// License as published by the Free Software Foundation; either // +// version 2.1 of the License, or (at your option) any later version. // +// // +// This library is distributed in the hope that it will be useful, // +// but WITHOUT ANY WARRANTY; without even the implied warranty of // +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // +// Lesser General Public License for more details. // +// // +// You should have received a copy of the GNU Lesser General Public // +// License along with this library; if not, write to the Free Software // +// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA // +/////////////////////////////////////////////////////////////////////////////////////////////////// + +package org.distorted.library.type; + +/////////////////////////////////////////////////////////////////////////////////////////////////// +/** + * A 5-dimensional data structure containing five floats. The floats have no particular meaning; + * when this data structure is used in Dynamics, we can think of it as a 5-dimensional Point + * a few of which the Dynamic interpolates between. + */ + +public class Static5D extends Static implements Data5D + { + float x,y,z,w,v; + +/////////////////////////////////////////////////////////////////////////////////////////////////// +/** + * Constructor that initialises the value of the five floats to (vx,vy,vz,vw,vv). + * + * @param vx value of the first float. + * @param vy value of the second float. + * @param vz value of the third float. + * @param vw value of the fourth float. + * @param vv value of the fifth float. + */ + public Static5D(float vx, float vy, float vz, float vw, float vv) + { + super(5); + x = vx; + y = vy; + z = vz; + w = vw; + v = vv; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// +/** + * Copy constructor. + */ + public Static5D(Static5D sta) + { + super(5); + x = sta.x; + y = sta.y; + z = sta.z; + w = sta.w; + v = sta.v; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// +/** + * Reset the value of the floats to (vx,vy,vz,vw,vv). + * + * @param vx new value of the first float + * @param vy new value of the second float + * @param vz new value of the third float + * @param vw new value of the fourth float + * @param vv new value of the fifth float + */ + public void set(float vx, float vy, float vz, float vw, float vv) + { + x = vx; + y = vy; + z = vz; + w = vw; + v = vv; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// +/** + * Copy a Static5D. + */ + public void set(Static5D s) + { + x = s.x; + y = s.y; + z = s.z; + w = s.w; + v = s.v; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// +/** + * Resets the value of the first float. + * + * @param ox new value of the first float. + */ + public void set0(float ox) + { + x = ox; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// +/** + * Resets the value of the second float. + * + * @param oy new value of the second float. + */ + public void set1(float oy) + { + y = oy; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// +/** + * Resets the value of the third float. + * + * @param oz new value of the third float. + */ + public void set2(float oz) + { + z = oz; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// +/** + * Resets the value of the fourth float. + * + * @param ow new value of the fourth float. + */ + public void set3(float ow) + { + w = ow; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// +/** + * Resets the value of the fifth float. + * + * @param ov new value of the fifth float. + */ + public void set4(float ov) + { + v = ov; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// +/** + * Return the value of the first float contained. + * + * @return The first float. + */ + public float get0() + { + return x; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// +/** + * Return the value of the second float contained. + * + * @return The second float. + */ + public float get1() + { + return y; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// +/** + * Return the value of the third float contained. + * + * @return The third float. + */ + public float get2() + { + return z; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// +/** + * Return the value of the fourth float contained. + * + * @return The fourth float. + */ + public float get3() + { + return w; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// +/** + * Return the value of the fifth float contained. + * + * @return The fifth float. + */ + public float get4() + { + return v; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// +/** + * 'Interpolation' between the single Point (i.e. always this very value) returned to the buffer. + * + * @param buffer Float buffer we will write the results to. + * @param offset Offset in the buffer where to write the result. + * @param time not used + * @param step not used + * @return false + */ + public boolean get(float[] buffer, int offset, long time, long step) + { + buffer[offset ] = x; + buffer[offset+1] = y; + buffer[offset+2] = z; + buffer[offset+3] = w; + buffer[offset+4] = v; + return false; + } + }