25 #ifndef AAX_CRANGETAPERDELEGATE_H
26 #define AAX_CRANGETAPERDELEGATE_H
82 template <
typename T,
int32_t RealPrecision=1000>
112 T
Round(
double iValue)
const;
119 std::vector<T> mRanges;
120 std::vector<double> mRangesSteps;
121 std::vector<double> mRangesPercents;
122 std::vector<double> mRangesStepsCount;
123 bool mUseSmartRounding;
126 template <
typename T,
int32_t RealPrecision>
130 mMaxValue(*(ranges + numRanges)),
131 mNumRanges(numRanges),
132 mRanges( ranges, ranges + numRanges + 1),
133 mRangesSteps( rangesSteps, rangesSteps + numRanges),
134 mUseSmartRounding( useSmartRounding )
136 mRangesStepsCount.reserve(numRanges);
137 mRangesPercents.reserve(numRanges);
139 for (; i < mNumRanges; i++)
141 mRangesStepsCount.push_back( (mRanges.at(i + 1) - mRanges.at(i)) / mRangesSteps.at(i));
144 for (i = 0; i < mNumRanges; i++)
146 numSteps += mRangesStepsCount.at(i);
148 for (i = 0; i < mNumRanges; i++)
150 mRangesPercents.push_back( mRangesStepsCount.at(i) / numSteps );
154 template <
typename T,
int32_t RealPrecision>
156 mMinValue(rhs.mMinValue),
157 mMaxValue(rhs.mMaxValue),
158 mNumRanges(rhs.mNumRanges),
159 mRanges( rhs.mRanges.begin(), rhs.mRanges.end()),
160 mRangesSteps( rhs.mRangesSteps.begin(), rhs.mRangesSteps.end()),
161 mRangesPercents( rhs.mRangesPercents.begin(), rhs.mRangesPercents.end()),
162 mRangesStepsCount( rhs.mRangesStepsCount.begin(), rhs.mRangesStepsCount.end()),
163 mUseSmartRounding( rhs.mUseSmartRounding )
167 template <
typename T,
int32_t RealPrecision>
173 this->mMinValue = rhs.mMinValue;
174 this->mMaxValue = rhs.mMaxValue;
175 this->mNumRanges = rhs.mNumRanges;
176 this->mRanges.assign( rhs.mRanges.begin(), rhs.mRanges.end());
177 this->mRangesSteps.assign( rhs.mRangesSteps.begin(), rhs.mRangesSteps.end());
178 this->mRangesPercents.assign( rhs.mRangesPercents.begin(), rhs.mRangesPercents.end());
179 this->mRangesStepsCount.assign( rhs.mRangesStepsCount.begin(), rhs.mRangesStepsCount.end());
184 template <
typename T,
int32_t RealPrecision>
187 return ((0 >= RealPrecision) ?
static_cast<T
>(iValue) :
188 (0 <= iValue) ? floor( iValue*RealPrecision + 0.5f ) / RealPrecision :
189 ceil( iValue*RealPrecision - 0.5f ) / RealPrecision
193 template <
typename T,
int32_t RealPrecision>
199 template <
typename T,
int32_t RealPrecision>
202 if (mMinValue == mMaxValue)
206 value = Round(value);
208 const T& highValue = mMaxValue > mMinValue ? mMaxValue : mMinValue;
209 const T& lowValue = mMaxValue > mMinValue ? mMinValue : mMaxValue;
211 if (value > highValue)
213 if (value < lowValue)
219 template <
typename T,
int32_t RealPrecision>
222 double percentTotal = normalizedValue;
224 double percent = 0.0;
226 for (; i < mNumRanges; i++)
228 if ((percentTotal >= percent) && (percentTotal < (percent + mRangesPercents.at( i ) )))
230 percent += mRangesPercents.at( i );
235 extValue = mMaxValue;
237 extValue = mRanges.at(i) + ((mRanges.at(i+1) - mRanges.at(i))*(percentTotal - percent)) / (mRangesPercents.at(i));
239 T realValue = T(extValue);
240 if ( mUseSmartRounding )
241 realValue = SmartRound(extValue);
243 return ConstrainRealValue(realValue);
246 template <
typename T,
int32_t RealPrecision>
249 realValue = ConstrainRealValue(realValue);
251 double percentTotal = 0.0;
253 for (; i < mNumRanges; i++)
255 if ((realValue >= mRanges[i]) && (realValue < mRanges[i+1]))
257 percentTotal += mRangesPercents[i];
262 else if (mRanges.at(i + 1) == mRanges.at(i))
265 percentTotal += (realValue - mRanges.at(i))/(mRanges.at(i + 1) - mRanges.at(i)) * mRangesPercents.at(i);
267 double normalizedValue = percentTotal;
268 return normalizedValue;
271 template <
typename T,
int32_t RealPrecision>
275 for (; i < mNumRanges; i++)
277 if ((value >= mRanges.at(i)) && (value < mRanges.at(i + 1) ))
279 if ( i == mNumRanges - 1 )
285 longVal = int32_t(floor(value / mRangesSteps.at(i) + 0.5));
287 longVal = int32_t(ceil(value / mRangesSteps.at(i) - 0.5));
289 return static_cast<double>(longVal) * mRangesSteps.at(i);
293 #endif AAX_CRANGETAPERDELEGATE_H
Various utility definitions for AAX.
#define AAX_OVERRIDE
override keyword macro
Definition: AAX.h:141
Defines the taper conversion behavior for a parameter.
A piecewise-linear taper conforming to AAX_ITaperDelegate.
Definition: AAX_CRangeTaperDelegate.h:84
AAX_CRangeTaperDelegate(T *range, double *rangesSteps, long numRanges, bool useSmartRounding=true)
Constructs a Range Taper with specified minimum and maximum values.
Definition: AAX_CRangeTaperDelegate.h:127
T GetMaximumValue() const AAX_OVERRIDE
Returns the taper's maximum real value.
Definition: AAX_CRangeTaperDelegate.h:106
double RealToNormalized(T realValue) const AAX_OVERRIDE
Normalizes a real parameter value.
Definition: AAX_CRangeTaperDelegate.h:247
T SmartRound(double value) const
Definition: AAX_CRangeTaperDelegate.h:272
T NormalizedToReal(double normalizedValue) const AAX_OVERRIDE
Converts a normalized value to a real value.
Definition: AAX_CRangeTaperDelegate.h:220
T Round(double iValue) const
Definition: AAX_CRangeTaperDelegate.h:185
AAX_CRangeTaperDelegate< T, RealPrecision > * Clone() const AAX_OVERRIDE
Constructs and returns a copy of the taper delegate.
Definition: AAX_CRangeTaperDelegate.h:194
T GetMinimumValue() const AAX_OVERRIDE
Returns the taper's minimum real value.
Definition: AAX_CRangeTaperDelegate.h:105
AAX_CRangeTaperDelegate & operator=(AAX_CRangeTaperDelegate &rhs)
Definition: AAX_CRangeTaperDelegate.h:168
T ConstrainRealValue(T value) const AAX_OVERRIDE
Applies a contraint to the value and returns the constrained value.
Definition: AAX_CRangeTaperDelegate.h:200
Classes for conversion to and from normalized parameter values.
Definition: AAX_ITaperDelegate.h:89