double* Oscillator::fillOscillatorBuffer(Type osc, double freq, double sampleRate, int bufferLength)
{
_currentPhase = 0.0;
_bufferLength = bufferLength;
if(_buffer != nullptr)
delete _buffer;
_buffer = new double[bufferLength];
for(int i = 0; i < bufferLength; ++i)
{
switch (osc)
{
case SINE:
_buffer[i] = generateSineWave(freq, sampleRate);
break;
case UPWARD_SAWTOOTH:
_buffer[i] = generateUpSawtooth(freq, sampleRate);
case DOWNWARD_SAWTOOTH:
_buffer[i] = generateDownSawtooth(freq, sampleRate);
case SQUARE:
_buffer[i] = generateSquareWave(freq, sampleRate);
break;
case TRIANGLE:
_buffer[i] = generateTriangleWave(freq, sampleRate);
break;
}
}
return _buffer;
}
// ----------------------------------------------------------------------------
//
void SceneChannelFilter::initAnimation( AnimationTask* task, DWORD time_ms, BYTE* dmx_packet )
{
m_animation_task = task;
m_channel_animations.clear();
double start_angle = 0.0;
// Determine which channels will be participating
for ( UID actor_uid : populateActors() ) {
Fixture* pf = m_animation_task->getActorRepresentative( actor_uid );
if ( !pf )
continue;
for ( channel_t channel : m_channels ) {
if ( pf->getNumChannels() <= channel )
continue;
// Each fixture may have a different start value so do independantly (and for random)
ChannelValueArray value_array;
// Get unmodified initial value
SceneActor* actor = m_animation_task->getActor( actor_uid );
BYTE start_value = actor->getChannelValue( channel );
switch ( m_filter ) {
case CF_SINE_WAVE:
start_angle += m_offset; // We want this first to be able to offset multiple filters
value_array = generateSineWave( start_value, start_angle, m_amplitude, m_step );
break;
case CF_STEP_WAVE:
value_array = generateStepWave( start_value, m_step );
break;
case CF_RAMP_UP:
value_array = generateRampUp( start_value, m_step, m_amplitude );
break;
case CF_RAMP_DOWN:
value_array = generateRampDown( start_value, m_step, m_amplitude );
break;
case CF_RANDOM:
value_array = generateRandom( start_value, m_amplitude );
break;
}
m_channel_animations.push_back(
ChannelAnimation( actor_uid, channel, CAM_LIST, value_array ) );
}
}
return SceneChannelAnimator::initAnimation( task, time_ms, dmx_packet );
}
// ----------------------------------------------------------------------------
//
void SceneChannelFilterTask::generateProgram( AnimationDefinition* definition )
{
double start_angle = 0.0;
SceneChannelFilter* config = dynamic_cast<SceneChannelFilter *>( definition );
// Determine which channels will be participating
for ( SceneActor& actor : getActors() ) {
Fixture* pf = getActorRepresentative( actor.getActorUID() );
if ( !pf )
continue;
for ( channel_address channel : config->getChannels() ) {
if ( pf->getNumChannels() <= channel )
continue;
// Each fixture may have a different start value so do independantly (and for random)
ChannelValueArray value_array;
// Get unmodified initial value
BYTE start_value = actor.getFinalChannelValue( pf->getUID(), channel );
switch ( config->getFilter() ) {
case CF_SINE_WAVE:
start_angle += config->getOffset(); // We want this first to be able to offset multiple filters
value_array = generateSineWave( start_value, start_angle, config->getAmplitude(), config->getStep() );
break;
case CF_STEP_WAVE:
value_array = generateStepWave( start_value, config->getStep() );
break;
case CF_RAMP_UP:
value_array = generateRampUp( start_value, config->getStep(), config->getAmplitude() );
break;
case CF_RAMP_DOWN:
value_array = generateRampDown( start_value, config->getStep(), config->getAmplitude() );
break;
case CF_RANDOM:
value_array = generateRandom( start_value, config->getAmplitude() );
break;
}
add( actor.getActorUID(), channel, CAM_LIST, value_array );
}
}
}
