void RGBMatrix::setAlgorithm(RGBAlgorithm* algo)
{
{
QMutexLocker algorithmLocker(&m_algorithmMutex);
delete m_algorithm;
m_algorithm = algo;
/** If there's been a change of Script algorithm "on the fly",
* then re-apply the properties currently set in this RGBMatrix */
if (m_algorithm != NULL && m_algorithm->type() == RGBAlgorithm::Script)
{
RGBScript *script = static_cast<RGBScript*> (m_algorithm);
QHashIterator<QString, QString> it(m_properties);
while(it.hasNext())
{
it.next();
if (script->setProperty(it.key(), it.value()) == false)
{
/** If the new algorithm doesn't expose a property,
* then remove it from the cached list, otherwise
* it would be carried around forever (and saved on XML) */
m_properties.take(it.key());
}
}
}
}
m_stepsCount = stepsCount();
emit changed(id());
}
void RGBMatrix::setEndColor(const QColor &c)
{
m_endColor = c;
QMutexLocker algorithmLocker(&m_algorithmMutex);
if (m_algorithm != NULL)
m_algorithm->setColors(m_startColor, m_endColor);
}
void RGBMatrix::calculateColorDelta()
{
m_crDelta = 0;
m_cgDelta = 0;
m_cbDelta = 0;
m_stepCount = 0;
if (m_endColor.isValid())
{
if (doc() == NULL)
return;
FixtureGroup* grp = doc()->fixtureGroup(fixtureGroup());
QMutexLocker algorithmLocker(&m_algorithmMutex);
if (grp != NULL && m_algorithm != NULL)
{
m_stepCount = m_algorithm->rgbMapStepCount(grp->size()) - 1;
if (m_stepCount > 0)
{
m_crDelta = m_endColor.red() - m_startColor.red();
m_cgDelta = m_endColor.green() - m_startColor.green();
m_cbDelta = m_endColor.blue() - m_startColor.blue();
}
}
}
}
void RGBMatrix::preRun(MasterTimer* timer)
{
Q_UNUSED(timer);
{
QMutexLocker algorithmLocker(&m_algorithmMutex);
m_group = doc()->fixtureGroup(m_fixtureGroupID);
if (m_group == NULL)
{
// No fixture group to control
stop();
return;
}
if (m_algorithm != NULL)
{
Q_ASSERT(m_fader == NULL);
m_fader = new GenericFader(doc());
m_fader->adjustIntensity(getAttributeValue(Intensity));
m_fader->setBlendMode(blendMode());
// Copy direction from parent class direction
m_direction = direction();
if (m_direction == Forward)
{
m_step = 0;
m_stepColor = m_startColor.rgb();
}
else
{
m_step = m_algorithm->rgbMapStepCount(m_group->size()) - 1;
if (m_endColor.isValid())
{
m_stepColor = m_endColor.rgb();
}
else
{
m_stepColor = m_startColor.rgb();
}
}
calculateColorDelta();
if (m_algorithm->type() == RGBAlgorithm::Script)
{
RGBScript *script = static_cast<RGBScript*> (m_algorithm);
QHashIterator<QString, QString> it(m_properties);
while(it.hasNext())
{
it.next();
script->setProperty(it.key(), it.value());
}
}
}
}
m_roundTime->start();
Function::preRun(timer);
}
void RGBMatrix::setAlgorithm(RGBAlgorithm* algo)
{
{
QMutexLocker algorithmLocker(&m_algorithmMutex);
delete m_algorithm;
m_algorithm = algo;
}
emit changed(id());
}
void RGBMatrix::setStartColor(const QColor& c)
{
m_startColor = c;
{
QMutexLocker algorithmLocker(&m_algorithmMutex);
if (m_algorithm != NULL)
m_algorithm->setColors(m_startColor, m_endColor);
}
emit changed(id());
}
void RGBMatrix::setAlgorithm(RGBAlgorithm* algo)
{
QMutexLocker algorithmLocker(&m_algorithmMutex);
delete m_algorithm;
m_algorithm = algo;
if (m_algorithm != NULL && m_algorithm->type() == RGBAlgorithm::Audio)
{
RGBAudio *audio = static_cast<RGBAudio*>(m_algorithm);
audio->setAudioCapture(doc()->audioInputCapture());
}
}
RGBMap RGBMatrix::previewMap(int step)
{
RGBMap map;
QMutexLocker algorithmLocker(&m_algorithmMutex);
if (m_algorithm == NULL)
return map;
FixtureGroup* grp = doc()->fixtureGroup(fixtureGroup());
if (grp != NULL)
{
map = m_algorithm->rgbMap(grp->size(), m_stepColor.rgb(), step);
}
return map;
}
int RGBMatrix::stepsCount()
{
QMutexLocker algorithmLocker(&m_algorithmMutex);
if (m_algorithm == NULL)
return 0;
FixtureGroup* grp = doc()->fixtureGroup(fixtureGroup());
if (grp != NULL)
return m_algorithm->rgbMapStepCount(grp->size());
return 0;
}
void RGBMatrixEditor::setAlgoText(QString text)
{
if (m_matrix != NULL && m_matrix->algorithm() != NULL &&
m_matrix->algorithm()->type() == RGBAlgorithm::Text)
{
RGBText* algo = static_cast<RGBText*> (m_matrix->algorithm());
if (algo->text() == text)
return;
QMutexLocker algorithmLocker(&m_matrix->algorithmMutex());
algo->setText(text);
emit algoTextChanged(text);
}
}
void RGBMatrix::setTotalDuration(quint32 msec)
{
QMutexLocker algorithmLocker(&m_algorithmMutex);
if (m_algorithm == NULL)
return;
FixtureGroup* grp = doc()->fixtureGroup(fixtureGroup());
if (grp == NULL)
return;
int steps = m_algorithm->rgbMapStepCount(grp->size());
setDuration(msec / steps);
}
void RGBMatrix::postRun(MasterTimer* timer, QList<Universe *> universes)
{
if (m_fader != NULL)
{
QHashIterator <FadeChannel,FadeChannel> it(m_fader->channels());
while (it.hasNext() == true)
{
it.next();
FadeChannel fc = it.value();
// fade out only intensity channels
if (fc.group(doc()) != QLCChannel::Intensity)
continue;
bool canFade = true;
Fixture *fixture = doc()->fixture(fc.fixture());
if (fixture != NULL)
canFade = fixture->channelCanFade(fc.channel());
fc.setStart(fc.current(getAttributeValue(Intensity)));
fc.setCurrent(fc.current(getAttributeValue(Intensity)));
fc.setElapsed(0);
fc.setReady(false);
if (canFade == false)
{
fc.setFadeTime(0);
fc.setTarget(fc.current(getAttributeValue(Intensity)));
}
else
{
if (overrideFadeOutSpeed() == defaultSpeed())
fc.setFadeTime(fadeOutSpeed());
else
fc.setFadeTime(overrideFadeOutSpeed());
fc.setTarget(0);
}
timer->faderAdd(fc);
}
delete m_fader;
m_fader = NULL;
}
{
QMutexLocker algorithmLocker(&m_algorithmMutex);
if (m_algorithm != NULL)
m_algorithm->postRun();
}
Function::postRun(timer, universes);
}
quint32 RGBMatrix::totalDuration()
{
QMutexLocker algorithmLocker(&m_algorithmMutex);
if (m_algorithm == NULL)
return 0;
FixtureGroup* grp = doc()->fixtureGroup(fixtureGroup());
if (grp == NULL)
return 0;
qDebug () << "Algorithm steps:" << m_algorithm->rgbMapStepCount(grp->size());
return m_algorithm->rgbMapStepCount(grp->size()) * duration();
}
RGBMap RGBMatrix::previewMap(int step, RGBMatrixStep *handler)
{
RGBMap map;
QMutexLocker algorithmLocker(&m_algorithmMutex);
if (m_algorithm == NULL || handler == NULL)
return map;
if (m_group == NULL)
m_group = doc()->fixtureGroup(fixtureGroup());
if (m_group != NULL)
map = m_algorithm->rgbMap(m_group->size(), handler->stepColor().rgb(), step);
return map;
}
void RGBMatrix::roundCheck()
{
QMutexLocker algorithmLocker(&m_algorithmMutex);
if (m_algorithm == NULL)
return;
if (m_stepHandler->checkNextStep(runOrder(), m_startColor, m_endColor, m_stepsCount) == false)
stop(FunctionParent::master());
m_roundTime->restart();
if (tempoType() == Beats)
roundElapsed(m_stepBeatDuration);
else
roundElapsed(duration());
}
void RGBMatrixEditor::setAlgoImagePath(QString path)
{
if (m_matrix != NULL && m_matrix->algorithm() != NULL &&
m_matrix->algorithm()->type() == RGBAlgorithm::Image)
{
RGBImage* algo = static_cast<RGBImage*> (m_matrix->algorithm());
if (path.startsWith("file:"))
path = QUrl(path).toLocalFile();
if (algo->filename() == path)
return;
QMutexLocker algorithmLocker(&m_matrix->algorithmMutex());
algo->setFilename(path);
emit algoImagePathChanged(path);
}
}
QList <RGBMap> RGBMatrix::previewMaps()
{
QList <RGBMap> steps;
QMutexLocker algorithmLocker(&m_algorithmMutex);
if (m_algorithm == NULL)
return steps;
FixtureGroup* grp = doc()->fixtureGroup(fixtureGroup());
if (grp != NULL)
{
int stepCount = m_algorithm->rgbMapStepCount(grp->size());
for (int i = 0; i < stepCount; i++)
steps << m_algorithm->rgbMap(grp->size(), m_stepColor.rgb(), i);
}
return steps;
}
void RGBMatrix::write(MasterTimer* timer, QList<Universe *> universes)
{
Q_UNUSED(timer);
Q_UNUSED(universes);
FixtureGroup* grp = doc()->fixtureGroup(fixtureGroup());
if (grp == NULL)
{
// No fixture group to control
stop();
return;
}
// No time to do anything.
if (duration() == 0)
return;
// Invalid/nonexistent script
{
QMutexLocker algorithmLocker(&m_algorithmMutex);
if (m_algorithm == NULL || m_algorithm->apiVersion() == 0)
return;
// Get new map every time when elapsed is reset to zero
if (elapsed() == 0)
{
qDebug() << "RGBMatrix stepColor:" << QString::number(m_stepColor.rgb(), 16);
RGBMap map = m_algorithm->rgbMap(grp->size(), m_stepColor.rgb(), m_step);
updateMapChannels(map, grp);
}
}
// Run the generic fader that takes care of fading in/out individual channels
m_fader->write(universes);
// Increment elapsed time
incrementElapsed();
// Check if we need to change direction, stop completely or go to next step
if (elapsed() >= duration())
roundCheck(grp->size());
}
void RGBMatrix::preRun(MasterTimer* timer)
{
{
QMutexLocker algorithmLocker(&m_algorithmMutex);
m_group = doc()->fixtureGroup(m_fixtureGroupID);
if (m_group == NULL)
{
// No fixture group to control
stop(FunctionParent::master());
return;
}
if (m_algorithm != NULL)
{
Q_ASSERT(m_fader == NULL);
m_fader = new GenericFader(doc());
m_fader->adjustIntensity(getAttributeValue(Intensity));
m_fader->setBlendMode(blendMode());
// Copy direction from parent class direction
m_stepHandler->initializeDirection(direction(), m_startColor, m_endColor, m_stepsCount);
if (m_algorithm->type() == RGBAlgorithm::Script)
{
RGBScript *script = static_cast<RGBScript*> (m_algorithm);
QHashIterator<QString, QString> it(m_properties);
while(it.hasNext())
{
it.next();
script->setProperty(it.key(), it.value());
}
}
}
}
m_roundTime->restart();
Function::preRun(timer);
}
void RGBMatrix::preRun(MasterTimer* timer)
{
Q_UNUSED(timer);
FixtureGroup* grp = doc()->fixtureGroup(fixtureGroup());
{
QMutexLocker algorithmLocker(&m_algorithmMutex);
if (grp != NULL && m_algorithm != NULL)
{
m_direction = direction();
Q_ASSERT(m_fader == NULL);
m_fader = new GenericFader(doc());
m_fader->adjustIntensity(getAttributeValue(Intensity));
if (m_direction == Forward)
{
m_step = 0;
m_stepColor = m_startColor.rgb();
}
else
{
m_step = m_algorithm->rgbMapStepCount(grp->size()) - 1;
if (m_endColor.isValid())
{
m_stepColor = m_endColor.rgb();
}
else
{
m_stepColor = m_startColor.rgb();
}
}
calculateColorDelta();
}
}
m_roundTime->start();
Function::preRun(timer);
}
void RGBMatrix::roundCheck(const QSize& size)
{
QMutexLocker algorithmLocker(&m_algorithmMutex);
if (m_algorithm == NULL)
return;
if (runOrder() == PingPong)
{
if (m_direction == Forward && (m_step + 1) == m_algorithm->rgbMapStepCount(size))
{
m_direction = Backward;
m_step = m_algorithm->rgbMapStepCount(size) - 2;
if (m_endColor.isValid())
m_stepColor = m_endColor;
updateStepColor(m_step);
}
else if (m_direction == Backward && (m_step - 1) < 0)
{
m_direction = Forward;
m_step = 1;
m_stepColor = m_startColor;
updateStepColor(m_step);
}
else
{
if (m_direction == Forward)
m_step++;
else
m_step--;
updateStepColor(m_step);
}
}
else if (runOrder() == SingleShot)
{
if (m_direction == Forward)
{
if (m_step >= m_algorithm->rgbMapStepCount(size) - 1)
stop();
else
{
m_step++;
updateStepColor(m_step);
}
}
else
{
if (m_step <= 0)
stop();
else
{
m_step--;
updateStepColor(m_step);
}
}
}
else
{
if (m_direction == Forward)
{
if (m_step >= m_algorithm->rgbMapStepCount(size) - 1)
{
m_step = 0;
m_stepColor = m_startColor;
}
else
{
m_step++;
updateStepColor(m_step);
}
}
else
{
if (m_step <= 0)
{
m_step = m_algorithm->rgbMapStepCount(size) - 1;
if (m_endColor.isValid())
m_stepColor = m_endColor;
}
else
{
m_step--;
updateStepColor(m_step);
}
}
}
m_roundTime->restart();
roundElapsed(duration());
}
void RGBMatrix::write(MasterTimer* timer, QList<Universe *> universes)
{
Q_UNUSED(timer);
{
QMutexLocker algorithmLocker(&m_algorithmMutex);
if (m_group == NULL)
{
// No fixture group to control
stop(FunctionParent::master());
return;
}
// No time to do anything.
if (duration() == 0)
return;
// Invalid/nonexistent script
if (m_algorithm == NULL || m_algorithm->apiVersion() == 0)
return;
if (isPaused() == false)
{
// Get a new map every time elapsed is reset to zero
if (elapsed() < MasterTimer::tick())
{
if (tempoType() == Beats)
m_stepBeatDuration = beatsToTime(duration(), timer->beatTimeDuration());
//qDebug() << "RGBMatrix step" << m_stepHandler->currentStepIndex() << ", color:" << QString::number(m_stepHandler->stepColor().rgb(), 16);
RGBMap map = m_algorithm->rgbMap(m_group->size(), m_stepHandler->stepColor().rgb(), m_stepHandler->currentStepIndex());
updateMapChannels(map, m_group);
}
}
}
// Run the generic fader that takes care of fading in/out individual channels
m_fader->write(universes, isPaused());
if (isPaused() == false)
{
// Increment the ms elapsed time
incrementElapsed();
/* Check if we need to change direction, stop completely or go to next step
* The cases are:
* 1- time tempo type: act normally, on ms elapsed time
* 2- beat tempo type, beat occurred: check if the elapsed beats is a multiple of
* the step beat duration. If so, proceed to the next step
* 3- beat tempo type, not beat: if the ms elapsed time reached the step beat
* duration in ms, and the ms time to the next beat is not less than 1/16 of
* the step beat duration in ms, then proceed to the next step. If the ms time to the
* next beat is less than 1/16 of the step beat duration in ms, then defer the step
* change to case #2, to resync the matrix to the next beat
*/
if (tempoType() == Time && elapsed() >= duration())
{
roundCheck();
}
else if (tempoType() == Beats)
{
if (timer->isBeat())
{
incrementElapsedBeats();
qDebug() << "Elapsed beats:" << elapsedBeats() << ", time elapsed:" << elapsed() << ", step time:" << m_stepBeatDuration;
if (elapsedBeats() % duration() == 0)
{
roundCheck();
resetElapsed();
}
}
else if (elapsed() >= m_stepBeatDuration && (uint)timer->timeToNextBeat() > m_stepBeatDuration / 16)
{
qDebug() << "Elapsed exceeded";
roundCheck();
}
}
}
}
