//inNormValue expected to be normalized
void ZenDecibelParameter::setValueNotifyingHost(float inNormValue)
{
float clampedValue = getClamped(inNormValue, 0.0f, 1.0f);
//clampedValue = DecibelConversions::mapDecibelsToProperNormalizedValue(clampedValue, range.start, range.end, midValue);
//DBG("In ZenDecibelParameter::setValueNotifyingHost(inValue) of " << this->paramID << " with invalue: " << inNormValue << " and setParameterNotifyingHost with: " << clampedValue);
processor->setParameterNotifyingHost(getParameterIndex(), clampedValue);
if (shouldBeSmoothed) setTargetValue(clampedValue);
listeners.call(&ZenAudioProcessorValueTreeState::Listener::parameterChanged, paramID, clampedValue);
listenersNeedCalling = false;
setValueInGainFromNormalised(value.load());
needsUpdate.set(1);
}
EvolutionaryAlgorithm::EvolutionaryAlgorithm(vector<CoinType> & newCoinTypes, int newPopulationSize,
int newTargetValue, int newNumberOfGenerations, double newElitismBias, int newNumberOfGenes, double newMutationRate, bool newStopAtGoal, int newAgeLimit,int newTournamentSize)
{
setStopAtGoal(newStopAtGoal);
setMutationRate(newMutationRate);
setNumberOfGenes(newNumberOfGenes);
setEilitismBias(newElitismBias);
setNumberOfGenerations(newNumberOfGenerations);
setPopulationSize(newPopulationSize);
setTargetValue(newTargetValue);
setCoinTypes(newCoinTypes);
setAgeLimit(newAgeLimit);
setTournamentSize(newTournamentSize);
setNumberOfChildren();
}
void ZenDecibelParameter::setValueFromGain(float inGainValue)
{
float newValue = getClamped(Decibels::gainToDecibels(inGainValue), range.start, range.end);
float newNormValue = DecibelConversions::mapDecibelsToProperNormalizedValue(
newValue, range.start, range.end, midValue);
//DBG("In ZenDecibelParameter::setValueFromGain(inValue) of " << this->paramID << " with inValue: " << inGainValue << " and storing value: " << newNormValue);
value.store(newNormValue);
if (shouldBeSmoothed) setTargetValue(newNormValue);
listeners.call(&ZenAudioProcessorValueTreeState::Listener::parameterChanged, paramID, value.load());
listenersNeedCalling = false;
setGainValue(inGainValue);
needsUpdate.set(1);
UIUpdate.store(true);
}
void rspfPixelFlipper::setProperty(rspfRefPtr<rspfProperty> property)
{
if (!property) return;
rspfString os = property->valueToString();
rspfString name = property->getName();
if (name == PF_TARGET_VALUE_KW)
{
setTargetValue(os.toDouble());
}
if (name == TARGET_LOWER_LIMIT_PROP_NAME)
{
setTargetRange(os.toDouble(), theTargetValueHi);
}
if (name == TARGET_UPPER_LIMIT_PROP_NAME)
{
setTargetRange(theTargetValueLo, os.toDouble());
}
else if (name == PF_REPLACEMENT_VALUE_KW)
{
setReplacementValue(os.toDouble());
}
else if (name == PF_REPLACEMENT_MODE_KW)
{
setReplacementMode(os);
}
else if (name == PF_CLAMP_VALUE_LO_KW)
{
setClampValue(os.toDouble(), false);
}
else if (name == PF_CLAMP_VALUE_HI_KW)
{
setClampValue(os.toDouble(), true);
}
else if (name == PF_CLIP_MODE_KW)
{
setClipMode(os);
}
else
{
rspfImageSourceFilter::setProperty(property);
}
}
//Set from normalized invalue
void ZenDecibelParameter::setValue(float inNormValue)
{
//float newValue = DecibelConversions::mapProperNormalizedValueToDecibels(getClamped(inNormValue, 0.0f, 1.0f), range.start, range.end);
//DBG("In ZenDecibelParameter::setValue(inValue) of " << this->paramID << " and storing: " << inNormValue);
//jassert(inNormValue >= 0 && inNormValue <= 1);
if(inNormValue > 1 || inNormValue < 0)
DBG("In ZenDecibelParameter::setValue(inNormValue) and input value is not normalized properly");
if (inNormValue != value.load() || listenersNeedCalling)
{
value.store(inNormValue);
listeners.call(&ZenAudioProcessorValueTreeState::Listener::parameterChanged, paramID, value.load());
listenersNeedCalling = false;
needsUpdate.set(1);
UIUpdate.store(true);
if (shouldBeSmoothed) setTargetValue(inNormValue);
setValueInGainFromNormalised(inNormValue);
}
}
bool rspfPixelFlipper::loadState(const rspfKeywordlist& kwl,
const char* prefix)
{
const char* lookupReturn;
lookupReturn = kwl.find(prefix, PF_TARGET_VALUE_KW);
if(lookupReturn)
{
setTargetValue(atof(lookupReturn));
}
lookupReturn = kwl.find(prefix, PF_TARGET_RANGE_KW);
if(lookupReturn)
{
rspfString min_max_string (lookupReturn);
rspfString separator (" ");
rspf_float64 min_target = min_max_string.before(separator).toFloat64();
rspf_float64 max_target = min_max_string.after(separator).toFloat64();
setTargetRange(min_target, max_target);
}
lookupReturn = kwl.find(prefix, PF_REPLACEMENT_VALUE_KW);
if(lookupReturn)
{
setReplacementValue(atof(lookupReturn));
}
lookupReturn = kwl.find(prefix, PF_REPLACEMENT_MODE_KW);
if(lookupReturn)
{
rspfString modeString = lookupReturn;
setReplacementMode(modeString);
}
lookupReturn = kwl.find(prefix, PF_CLAMP_VALUE_KW);
if(lookupReturn)
{
setClampValue(atof(lookupReturn), true);
}
lookupReturn = kwl.find(prefix, PF_CLAMP_VALUE_LO_KW);
if(lookupReturn)
{
setClampValue(atof(lookupReturn), false);
}
lookupReturn = kwl.find(prefix, PF_CLAMP_VALUE_HI_KW);
if(lookupReturn)
{
setClampValue(atof(lookupReturn), true);
}
lookupReturn = kwl.find(prefix, PF_CLIP_MODE_KW);
if(lookupReturn)
{
rspfString modeString = lookupReturn;
setClipMode(modeString);
}
bool status = rspfImageSourceFilter::loadState(kwl, prefix);
if (traceDebug())
{
print(rspfNotify(rspfNotifyLevel_DEBUG));
}
return status;
}
void ofxSimpleGuiSliderBase<Type>::increase(float incrementFactor) {
//if(increment == 0) setIncrement((max - min) * incrementFactor);
// oldValue = *value; // save oldValue (so the draw doesn't update target but uses it)
setIncrement((max - min) * incrementFactor);
setTargetValue(*value + increment);
}
void ofxSimpleGuiSliderBase<Type>::setValue(Type f) {
setTargetValue(f);
oldValue = *value = targetValue;
}
void ofxSimpleGuiSliderInt::decrease(float incrementFactor) {
setIncrement((max - min) * incrementFactor);
if(increment < 1)
increment = 1;
setTargetValue(*value - increment);
}
