Merge 3188c91 into 3bc67b9

engine/src/efx.cpp

@@ -272,7 +272,7 @@ void EFX::preview(QPolygonF &polygon, Function::Direction direction, int startOf
     }
 }
 
-void EFX::calculatePoint(Function::Direction direction, int startOffset, float iterator, float* x, float* y) const
+void EFX::calculatePoint(Function::Direction direction, int startOffset, float iterator, float *x, float *y) const
 {
     iterator = calculateDirection(direction, iterator);
     iterator += convertOffset(startOffset + getAttributeValue(StartOffset));
@@ -283,7 +283,7 @@ void EFX::calculatePoint(Function::Direction direction, int startOffset, float i
     calculatePoint(iterator, x, y);
 }
 
-void EFX::rotateAndScale(float* x, float* y) const
+void EFX::rotateAndScale(float *x, float *y) const
 {
     float xx = *x;
     float yy = *y;
@@ -330,7 +330,7 @@ float EFX::calculateDirection(Function::Direction direction, float iterator) con
 }
 
 // this function should map from 0..M_PI * 2 -> -1..1
-void EFX::calculatePoint(float iterator, float* x, float* y) const
+void EFX::calculatePoint(float iterator, float *x, float *y) const
 {
     switch (algorithm())
     {

engine/src/efx.h

@@ -183,7 +183,7 @@ class EFX : public Function
      * @param x Used to store the calculated X coordinate (output)
      * @param y Used to store the calculated Y coordinate (output)
      */
-    void calculatePoint(Function::Direction direction, int startOffset, float iterator, float* x, float* y) const;
+    void calculatePoint(Function::Direction direction, int startOffset, float iterator, float *x, float *y) const;
 
 private:
 

engine/src/efxfixture.cpp

@@ -475,7 +475,7 @@ void EFXFixture::updateFaderValues(FadeChannel *fc, uchar value)
 void EFXFixture::setPointPanTilt(QList<Universe *> universes, QSharedPointer<GenericFader> fader,
                                  float pan, float tilt)
 {
-    Fixture* fxi = doc()->fixture(head().fxi);
+    Fixture *fxi = doc()->fixture(head().fxi);
     Q_ASSERT(fxi != NULL);
     Universe *uni = universes[universe()];
 
@@ -486,6 +486,12 @@ void EFXFixture::setPointPanTilt(QList<Universe *> universes, QSharedPointer<Gen
     quint32 tiltMsbChannel = fxi->channelNumber(QLCChannel::Tilt, QLCChannel::MSB, head().head);
     quint32 tiltLsbChannel = fxi->channelNumber(QLCChannel::Tilt, QLCChannel::LSB, head().head);
 
+    if (pan < 0)
+        pan = 0;
+
+    if (tilt < 0)
+        tilt = 0;
+
     /* Write coarse point data to universes */
     if (panMsbChannel != QLCChannel::invalid() && !fader.isNull())
     {

engine/src/fadechannel.cpp

@@ -20,6 +20,7 @@
 #include <QDebug>
 #include <cmath>
 
+#include "qlcfixturemode.h"
 #include "fadechannel.h"
 #include "qlcchannel.h"
 #include "universe.h"
@@ -29,8 +30,9 @@ FadeChannel::FadeChannel()
     : m_flags(0)
     , m_fixture(Fixture::invalidId())
     , m_universe(Universe::invalid())
-    , m_channel(QLCChannel::invalid())
+    , m_primaryChannel(QLCChannel::invalid())
     , m_address(QLCChannel::invalid())
+    , m_channelRef(NULL)
     , m_start(0)
     , m_target(0)
     , m_current(0)
@@ -44,8 +46,10 @@ FadeChannel::FadeChannel(const FadeChannel& ch)
     : m_flags(ch.m_flags)
     , m_fixture(ch.m_fixture)
     , m_universe(ch.m_universe)
-    , m_channel(ch.m_channel)
+    , m_primaryChannel(ch.m_primaryChannel)
+    , m_channels(ch.m_channels)
     , m_address(ch.m_address)
+    , m_channelRef(ch.m_channelRef)
     , m_start(ch.m_start)
     , m_target(ch.m_target)
     , m_current(ch.m_current)
@@ -59,14 +63,15 @@ FadeChannel::FadeChannel(const FadeChannel& ch)
 FadeChannel::FadeChannel(const Doc *doc, quint32 fxi, quint32 channel)
     : m_flags(0)
     , m_fixture(fxi)
-    , m_channel(channel)
+    , m_channelRef(NULL)
     , m_start(0)
     , m_target(0)
     , m_current(0)
     , m_ready(false)
     , m_fadeTime(0)
     , m_elapsed(0)
 {
+    m_channels.append(channel);
     autoDetect(doc);
 }
 
@@ -81,7 +86,9 @@ FadeChannel &FadeChannel::operator=(const FadeChannel &fc)
         m_flags = fc.m_flags;
         m_fixture = fc.m_fixture;
         m_universe = fc.m_universe;
-        m_channel = fc.m_channel;
+        m_primaryChannel = fc.m_primaryChannel;
+        m_channels = fc.m_channels;
+        m_channelRef = fc.m_channelRef;
         m_address = fc.m_address;
         m_start = fc.m_start;
         m_target = fc.m_target;
@@ -96,7 +103,7 @@ FadeChannel &FadeChannel::operator=(const FadeChannel &fc)
 
 bool FadeChannel::operator==(const FadeChannel& ch) const
 {
-    return (m_fixture == ch.m_fixture && m_channel == ch.m_channel);
+    return (m_fixture == ch.m_fixture && channel() == ch.channel());
 }
 
 int FadeChannel::flags() const
@@ -143,54 +150,48 @@ void FadeChannel::autoDetect(const Doc *doc)
     }
     else
     {
+        QLCFixtureMode *mode = fixture->fixtureMode();
         m_universe = fixture->universe();
         m_address = fixture->address();
 
         // if the fixture was invalid at the beginning of this method
         // it means channel was an absolute address, so, fix it
         if (fixtureWasInvalid)
-            m_channel -= fixture->address();
+            m_channels[0] -= fixture->address();
 
-        const QLCChannel *channel = fixture->channel(m_channel);
+        quint32 chIndex = channel();
+        m_primaryChannel = mode ? mode->primaryChannel(chIndex) : QLCChannel::invalid();
+        m_channelRef = fixture->channel(chIndex);
 
         // non existing channel within fixture
-        if (channel == NULL)
+        if (m_channelRef == NULL)
         {
             addFlag(FadeChannel::HTP | FadeChannel::Intensity | FadeChannel::CanFade);
             return;
         }
 
         // autodetect the channel type
-        if (fixture->channelCanFade(m_channel))
+        if (fixture->channelCanFade(chIndex))
             addFlag(FadeChannel::CanFade);
 
-        if (channel != NULL && channel->group() == QLCChannel::Intensity)
+        if (m_channelRef != NULL && m_channelRef->group() == QLCChannel::Intensity)
             addFlag(FadeChannel::HTP | FadeChannel::Intensity);
         else
             addFlag(FadeChannel::LTP);
 
-        if (fixture->forcedHTPChannels().contains(int(m_channel)))
+        if (fixture->forcedHTPChannels().contains(int(chIndex)))
         {
             removeFlag(FadeChannel::LTP);
             addFlag(FadeChannel::HTP);
         }
-        else if (fixture->forcedLTPChannels().contains(int(m_channel)))
+        else if (fixture->forcedLTPChannels().contains(int(chIndex)))
         {
             removeFlag(FadeChannel::HTP);
             addFlag(FadeChannel::LTP);
         }
-
-        if (channel != NULL && channel->controlByte() == QLCChannel::LSB)
-            addFlag(FadeChannel::Fine);
     }
 }
 
-void FadeChannel::setFixture(const Doc *doc, quint32 id)
-{
-    m_fixture = id;
-    autoDetect(doc);
-}
-
 quint32 FadeChannel::fixture() const
 {
     return m_fixture;
@@ -203,15 +204,42 @@ quint32 FadeChannel::universe() const
     return m_universe;
 }
 
-void FadeChannel::setChannel(const Doc *doc, quint32 num)
+void FadeChannel::addChannel(quint32 num)
 {
-    m_channel = num;
-    autoDetect(doc);
+    m_channels.append(num);
+    qDebug() << "[FadeChannel] ADD channel" << num << "count:" << m_channels.count();
+
+    // on secondary channel, shift values 8bits up
+    if (m_channels.count() > 1)
+    {
+        m_start = m_start << 8;
+        m_target = m_target << 8;
+        m_current = m_current << 8;
+    }
+}
+
+int FadeChannel::channelCount() const
+{
+    if (m_channels.isEmpty())
+        return 1;
+
+    return m_channels.count();
 }
 
 quint32 FadeChannel::channel() const
 {
-    return m_channel;
+    return m_channels.isEmpty() ? QLCChannel::invalid() : m_channels.first();
+}
+
+int FadeChannel::channelIndex(quint32 channel)
+{
+    int idx = m_channels.indexOf(channel);
+    return idx < 0 ? 0 : idx;
+}
+
+quint32 FadeChannel::primaryChannel() const
+{
+    return m_primaryChannel;
 }
 
 quint32 FadeChannel::address() const
@@ -224,42 +252,85 @@ quint32 FadeChannel::address() const
 
 quint32 FadeChannel::addressInUniverse() const
 {
-    return address() % UNIVERSE_SIZE;
+    quint32 addr = address();
+    if (addr == QLCChannel::invalid())
+        return QLCChannel::invalid();
+
+    return addr % UNIVERSE_SIZE;
 }
 
-void FadeChannel::setStart(uchar value)
+/************************************************************************
+ * Values
+ ************************************************************************/
+
+void FadeChannel::setStart(uchar value, int index)
+{
+    ((uchar *)&m_start)[channelCount() - 1 - index] = value;
+}
+
+void FadeChannel::setStart(quint32 value)
 {
     m_start = value;
 }
 
-uchar FadeChannel::start() const
+uchar FadeChannel::start(int index) const
+{
+    return ((uchar *)&m_start)[channelCount() - 1 - index];
+}
+
+quint32 FadeChannel::start() const
 {
-    return uchar(m_start);
+    return m_start;
 }
 
-void FadeChannel::setTarget(uchar value)
+void FadeChannel::setTarget(uchar value, int index)
+{
+    ((uchar *)&m_target)[channelCount() - 1 - index] = value;
+}
+
+void FadeChannel::setTarget(quint32 value)
 {
     m_target = value;
 }
 
-uchar FadeChannel::target() const
+uchar FadeChannel::target(int index) const
+{
+    return ((uchar *)&m_target)[channelCount() - 1 - index];
+}
+
+quint32 FadeChannel::target() const
+{
+    return m_target;
+}
+
+void FadeChannel::setCurrent(uchar value, int index)
 {
-    return uchar(m_target);
+    ((uchar *)&m_current)[channelCount() - 1 - index] = value;
 }
 
-void FadeChannel::setCurrent(uchar value)
+void FadeChannel::setCurrent(quint32 value)
 {
     m_current = value;
 }
 
-uchar FadeChannel::current() const
+uchar FadeChannel::current(int index) const
 {
-    return uchar(m_current);
+    return ((uchar *)&m_current)[channelCount() - 1 - index];
+}
+
+quint32 FadeChannel::current() const
+{
+    return m_current;
 }
 
-uchar FadeChannel::current(qreal intensity) const
+uchar FadeChannel::current(qreal intensity, int index) const
 {
-    return uchar(floor((qreal(m_current) * intensity) + 0.5));
+    return uchar(floor((qreal(current(index)) * intensity) + 0.5));
+}
+
+quint32 FadeChannel::current(qreal intensity) const
+{
+    return quint32(floor((qreal(m_current) * intensity) + 0.5));
 }
 
 void FadeChannel::setReady(bool rdy)
@@ -301,6 +372,7 @@ uchar FadeChannel::nextStep(uint ms)
 {
     if (elapsed() < UINT_MAX)
         setElapsed(elapsed() + ms);
+
     return calculateCurrent(fadeTime(), elapsed());
 }
 
@@ -319,14 +391,11 @@ uchar FadeChannel::calculateCurrent(uint fadeTime, uint elapsedTime)
     }
     else
     {
-        // 16 bit fading works as long as MSB and LSB channels
-        // are targeting the same value. E.g. Red and Red Fine both at 158
-        float val = (float(m_target - m_start) * (float(elapsedTime) / float(fadeTime))) + float(m_start);
-        long rval = lrintf(val * 256);
-        if (m_flags & Fine)
-            m_current = rval & 0xff;
-        else
-            m_current = rval / 256;
+        bool rampUp = m_target > m_start ? true : false;
+        m_current = rampUp ? m_target - m_start : m_start - m_target;
+        m_current = m_current * (qreal(elapsedTime) / qreal(fadeTime));
+        m_current = rampUp ? m_start + m_current : m_start - m_current;
+        //qDebug() << "channel" << channel() << "start" << m_start << "target" << m_target << "current" << m_current << "fade" << fadeTime << "elapsed" << elapsedTime ;
     }
 
     return uchar(m_current);