--- linuxsampler/trunk/src/engines/sfz/SfzSignalUnitRack.h	2011/07/28 08:05:57	2218
+++ linuxsampler/trunk/src/engines/sfz/SfzSignalUnitRack.h	2011/07/28 17:17:42	2221
@@ -26,6 +26,7 @@
 #include "../common/SignalUnitRack.h"
 #include "EG.h"
 #include "EGADSR.h"
+#include "../common/AbstractVoice.h"
 
 namespace LinuxSampler { namespace sfz {
     const int MaxUnitCount = 1000;
@@ -52,13 +53,13 @@
     };
     
     template <class T>
-    class EGUnit : public SfzSignalUnit {
+    class EGUnit: public SfzSignalUnit {
         public:
             ::sfz::EG* pEGInfo;
             T EG;
 
             EGUnit(SfzSignalUnitRack* rack): SfzSignalUnit(rack), pEGInfo(NULL) { }
-            EGUnit(const EGUnit& Unit): SfzSignalUnit(Unit.pRack) { Copy(Unit); }
+            EGUnit(const EGUnit& Unit): SfzSignalUnit(Unit) { Copy(Unit); }
             void operator=(const EGUnit& Unit) { Copy(Unit); }
             
             void Copy(const EGUnit& Unit) {
@@ -68,7 +69,7 @@
             }
 
             virtual bool  Active() { return EG.active(); }
-            virtual float GetLevel() { return EG.getLevel(); }
+            virtual float GetLevel() { return DelayStage() ? 0 : EG.getLevel(); }
             
             virtual void EnterReleaseStage() { EG.update(EG::event_release, GetSampleRate()); }
             virtual void CancelRelease() { EG.update(EG::event_cancel_release, GetSampleRate()); }
@@ -103,7 +104,8 @@
     
     class EGv1Unit: public EGUnit<EGADSR> {
         public:
-            EGv1Unit(SfzSignalUnitRack* rack): EGUnit<EGADSR>(rack) { }
+            int depth;
+            EGv1Unit(SfzSignalUnitRack* rack): EGUnit<EGADSR>(rack), depth(0) { }
             virtual void Trigger();
     };
     
@@ -113,6 +115,70 @@
             virtual void Trigger();
     };
     
+    class PitchEGUnit: public EGv1Unit {
+        public:
+            PitchEGUnit(SfzSignalUnitRack* rack): EGv1Unit(rack) { }
+            virtual void Trigger();
+    };
+    
+    class LFOUnit: public SfzSignalUnit {
+        public:
+            ::sfz::LFO* pLfoInfo;
+            LFOSigned lfo;
+            
+            LFOUnit(SfzSignalUnitRack* rack): SfzSignalUnit(rack), pLfoInfo(NULL), lfo(1200.0f) { }
+            LFOUnit(const LFOUnit& Unit): SfzSignalUnit(Unit), lfo(1200.0f) { Copy(Unit); }
+            void operator=(const LFOUnit& Unit) { Copy(Unit); }
+            
+            void Copy(const LFOUnit& Unit) {
+                pLfoInfo = Unit.pLfoInfo;
+                
+                SfzSignalUnit::Copy(Unit);
+            }
+            
+            virtual bool  Active() { return true; }
+            virtual void  Trigger();
+            virtual void  Increment();
+            virtual float GetLevel() { return Level; }
+    };
+    
+    class LFOv1Unit: public LFOUnit {
+        public:
+            ::sfz::LFO lfoInfo;
+            
+            LFOv1Unit(SfzSignalUnitRack* rack): LFOUnit(rack) { pLfoInfo = &lfoInfo; }
+            
+            virtual void Trigger();
+    };
+    
+    class LFOv2Unit: public LFOUnit {
+        public:
+            LFOv2Unit(SfzSignalUnitRack* rack): LFOUnit(rack) { }
+            
+            virtual void Trigger();
+    };
+    
+    class AmpLFOUnit: public LFOv1Unit {
+        public:
+            AmpLFOUnit(SfzSignalUnitRack* rack): LFOv1Unit(rack) { }
+            
+            virtual void Trigger();
+    };
+    
+    class PitchLFOUnit: public LFOv1Unit {
+        public:
+            PitchLFOUnit(SfzSignalUnitRack* rack): LFOv1Unit(rack) { }
+            
+            virtual void Trigger();
+    };
+    
+    class FilLFOUnit: public LFOv1Unit {
+        public:
+            FilLFOUnit(SfzSignalUnitRack* rack): LFOv1Unit(rack) { }
+            
+            virtual void Trigger();
+    };
+    
     
     
     class EndpointUnit : public EndpointSignalUnit {
@@ -130,8 +196,13 @@
             virtual float GetFilterCutoff();
             virtual float GetPitch();
             virtual float GetResonance();
+            virtual float GetPan();
             
             SfzSignalUnitRack* const GetRack();
+            
+            virtual float CalculateResonance(float res) {
+                return GetResonance() + res;
+            }
     };
     
     
@@ -139,6 +210,11 @@
         private:
             EndpointUnit  suEndpoint;
             EGv1Unit      suVolEG;
+            PitchEGUnit   suPitchEG;
+            
+            AmpLFOUnit   suAmpLFO;
+            PitchLFOUnit suPitchLFO;
+            FilLFOUnit   suFilLFO;
             
             FixedArray<EGv2Unit*> EGs;
             
@@ -148,6 +224,18 @@
             // used for optimization - contains only the ones that are modulating pitch
             FixedArray<EGv2Unit*> pitchEGs;
             
+            
+            FixedArray<LFOv2Unit*> LFOs;
+            
+            // used for optimization - contains only the ones that are modulating filter cutoff
+            FixedArray<LFOv2Unit*> filLFOs;
+            
+            // used for optimization - contains only the ones that are modulating resonance
+            FixedArray<LFOv2Unit*> resLFOs;
+            
+            // used for optimization - contains only the ones that are modulating pan
+            FixedArray<LFOv2Unit*> panLFOs;
+            
 
         public:
             Voice* const pVoice;