/[svn]/linuxsampler/trunk/src/engines/sfz/SfzSignalUnitRack.h
ViewVC logotype

Diff of /linuxsampler/trunk/src/engines/sfz/SfzSignalUnitRack.h

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 2218 by iliev, Thu Jul 28 08:05:57 2011 UTC revision 2222 by iliev, Thu Jul 28 18:24:12 2011 UTC
# Line 26  Line 26 
26  #include "../common/SignalUnitRack.h"  #include "../common/SignalUnitRack.h"
27  #include "EG.h"  #include "EG.h"
28  #include "EGADSR.h"  #include "EGADSR.h"
29    #include "../common/AbstractVoice.h"
30    
31  namespace LinuxSampler { namespace sfz {  namespace LinuxSampler { namespace sfz {
32      const int MaxUnitCount = 1000;      const int MaxUnitCount = 1000;
# Line 52  namespace LinuxSampler { namespace sfz { Line 53  namespace LinuxSampler { namespace sfz {
53      };      };
54            
55      template <class T>      template <class T>
56      class EGUnit : public SfzSignalUnit {      class EGUnit: public SfzSignalUnit {
57          public:          public:
58              ::sfz::EG* pEGInfo;              ::sfz::EG* pEGInfo;
59              T EG;              T EG;
60    
61              EGUnit(SfzSignalUnitRack* rack): SfzSignalUnit(rack), pEGInfo(NULL) { }              EGUnit(SfzSignalUnitRack* rack): SfzSignalUnit(rack), pEGInfo(NULL) { }
62              EGUnit(const EGUnit& Unit): SfzSignalUnit(Unit.pRack) { Copy(Unit); }              EGUnit(const EGUnit& Unit): SfzSignalUnit(Unit) { Copy(Unit); }
63              void operator=(const EGUnit& Unit) { Copy(Unit); }              void operator=(const EGUnit& Unit) { Copy(Unit); }
64                            
65              void Copy(const EGUnit& Unit) {              void Copy(const EGUnit& Unit) {
# Line 68  namespace LinuxSampler { namespace sfz { Line 69  namespace LinuxSampler { namespace sfz {
69              }              }
70    
71              virtual bool  Active() { return EG.active(); }              virtual bool  Active() { return EG.active(); }
72              virtual float GetLevel() { return EG.getLevel(); }              virtual float GetLevel() { return DelayStage() ? 0 : EG.getLevel(); }
73                            
74              virtual void EnterReleaseStage() { EG.update(EG::event_release, GetSampleRate()); }              virtual void EnterReleaseStage() { EG.update(EG::event_release, GetSampleRate()); }
75              virtual void CancelRelease() { EG.update(EG::event_cancel_release, GetSampleRate()); }              virtual void CancelRelease() { EG.update(EG::event_cancel_release, GetSampleRate()); }
# Line 103  namespace LinuxSampler { namespace sfz { Line 104  namespace LinuxSampler { namespace sfz {
104            
105      class EGv1Unit: public EGUnit<EGADSR> {      class EGv1Unit: public EGUnit<EGADSR> {
106          public:          public:
107              EGv1Unit(SfzSignalUnitRack* rack): EGUnit<EGADSR>(rack) { }              int depth;
108                EGv1Unit(SfzSignalUnitRack* rack): EGUnit<EGADSR>(rack), depth(0) { }
109              virtual void Trigger();              virtual void Trigger();
110      };      };
111            
# Line 113  namespace LinuxSampler { namespace sfz { Line 115  namespace LinuxSampler { namespace sfz {
115              virtual void Trigger();              virtual void Trigger();
116      };      };
117            
118        class PitchEGUnit: public EGv1Unit {
119            public:
120                PitchEGUnit(SfzSignalUnitRack* rack): EGv1Unit(rack) { }
121                virtual void Trigger();
122        };
123        
124        class FilEGUnit: public EGv1Unit {
125            public:
126                FilEGUnit(SfzSignalUnitRack* rack): EGv1Unit(rack) { }
127                virtual void Trigger();
128        };
129        
130        class LFOUnit: public SfzSignalUnit {
131            public:
132                ::sfz::LFO* pLfoInfo;
133                LFOSigned lfo;
134                
135                LFOUnit(SfzSignalUnitRack* rack): SfzSignalUnit(rack), pLfoInfo(NULL), lfo(1200.0f) { }
136                LFOUnit(const LFOUnit& Unit): SfzSignalUnit(Unit), lfo(1200.0f) { Copy(Unit); }
137                void operator=(const LFOUnit& Unit) { Copy(Unit); }
138                
139                void Copy(const LFOUnit& Unit) {
140                    pLfoInfo = Unit.pLfoInfo;
141                    
142                    SfzSignalUnit::Copy(Unit);
143                }
144                
145                virtual bool  Active() { return true; }
146                virtual void  Trigger();
147                virtual void  Increment();
148                virtual float GetLevel() { return Level; }
149        };
150        
151        class LFOv1Unit: public LFOUnit {
152            public:
153                ::sfz::LFO lfoInfo;
154                
155                LFOv1Unit(SfzSignalUnitRack* rack): LFOUnit(rack) { pLfoInfo = &lfoInfo; }
156                
157                virtual void Trigger();
158        };
159        
160        class LFOv2Unit: public LFOUnit {
161            public:
162                LFOv2Unit(SfzSignalUnitRack* rack): LFOUnit(rack) { }
163                
164                virtual void Trigger();
165        };
166        
167        class AmpLFOUnit: public LFOv1Unit {
168            public:
169                AmpLFOUnit(SfzSignalUnitRack* rack): LFOv1Unit(rack) { }
170                
171                virtual void Trigger();
172        };
173        
174        class PitchLFOUnit: public LFOv1Unit {
175            public:
176                PitchLFOUnit(SfzSignalUnitRack* rack): LFOv1Unit(rack) { }
177                
178                virtual void Trigger();
179        };
180        
181        class FilLFOUnit: public LFOv1Unit {
182            public:
183                FilLFOUnit(SfzSignalUnitRack* rack): LFOv1Unit(rack) { }
184                
185                virtual void Trigger();
186        };
187        
188            
189            
190      class EndpointUnit : public EndpointSignalUnit {      class EndpointUnit : public EndpointSignalUnit {
# Line 130  namespace LinuxSampler { namespace sfz { Line 202  namespace LinuxSampler { namespace sfz {
202              virtual float GetFilterCutoff();              virtual float GetFilterCutoff();
203              virtual float GetPitch();              virtual float GetPitch();
204              virtual float GetResonance();              virtual float GetResonance();
205                virtual float GetPan();
206                            
207              SfzSignalUnitRack* const GetRack();              SfzSignalUnitRack* const GetRack();
208                
209                virtual float CalculateResonance(float res) {
210                    return GetResonance() + res;
211                }
212      };      };
213            
214            
# Line 139  namespace LinuxSampler { namespace sfz { Line 216  namespace LinuxSampler { namespace sfz {
216          private:          private:
217              EndpointUnit  suEndpoint;              EndpointUnit  suEndpoint;
218              EGv1Unit      suVolEG;              EGv1Unit      suVolEG;
219                FilEGUnit     suFilEG;
220                PitchEGUnit   suPitchEG;
221                
222                AmpLFOUnit   suAmpLFO;
223                PitchLFOUnit suPitchLFO;
224                FilLFOUnit   suFilLFO;
225                            
226              FixedArray<EGv2Unit*> EGs;              FixedArray<EGv2Unit*> EGs;
227                            
# Line 148  namespace LinuxSampler { namespace sfz { Line 231  namespace LinuxSampler { namespace sfz {
231              // used for optimization - contains only the ones that are modulating pitch              // used for optimization - contains only the ones that are modulating pitch
232              FixedArray<EGv2Unit*> pitchEGs;              FixedArray<EGv2Unit*> pitchEGs;
233                            
234                
235                FixedArray<LFOv2Unit*> LFOs;
236                
237                // used for optimization - contains only the ones that are modulating filter cutoff
238                FixedArray<LFOv2Unit*> filLFOs;
239                
240                // used for optimization - contains only the ones that are modulating resonance
241                FixedArray<LFOv2Unit*> resLFOs;
242                
243                // used for optimization - contains only the ones that are modulating pan
244                FixedArray<LFOv2Unit*> panLFOs;
245                
246    
247          public:          public:
248              Voice* const pVoice;              Voice* const pVoice;
Legend:
Removed from v.2218  
changed lines
  Added in v.2222
  ViewVC Help
Powered by ViewVC