/[svn]/libgig/trunk/src/gig.h
ViewVC logotype

Diff of /libgig/trunk/src/gig.h

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

revision 2394 by schoenebeck, Mon Jan 7 23:23:58 2013 UTC revision 2450 by persson, Wed May 8 17:53:07 2013 UTC
# Line 643  namespace gig { Line 643  namespace gig {
643      class MidiRule {      class MidiRule {
644          public:          public:
645              virtual ~MidiRule() { }              virtual ~MidiRule() { }
646            protected:
647                virtual void UpdateChunks(uint8_t* pData) const = 0;
648                friend class Instrument;
649      };      };
650    
651      /** MIDI rule for triggering notes by control change events. */      /** MIDI rule for triggering notes by control change events. */
# Line 662  namespace gig { Line 665  namespace gig {
665    
666          protected:          protected:
667              MidiRuleCtrlTrigger(RIFF::Chunk* _3ewg);              MidiRuleCtrlTrigger(RIFF::Chunk* _3ewg);
668                MidiRuleCtrlTrigger();
669                void UpdateChunks(uint8_t* pData) const;
670                friend class Instrument;
671        };
672    
673        /** MIDI rule for instruments with legato samples. */
674        class MidiRuleLegato : public MidiRule {
675            public:
676                uint8_t LegatoSamples;     ///< Number of legato samples per key in each direction (always 12)
677                bool BypassUseController;  ///< If a controller should be used to bypass the sustain note
678                uint8_t BypassKey;         ///< Key to be used to bypass the sustain note
679                uint8_t BypassController;  ///< Controller to be used to bypass the sustain note
680                uint16_t ThresholdTime;    ///< Maximum time (ms) between two notes that should be played legato
681                uint16_t ReleaseTime;      ///< Release time
682                range_t KeyRange;          ///< Key range for legato notes
683                uint8_t ReleaseTriggerKey; ///< Key triggering release samples
684                uint8_t AltSustain1Key;    ///< Key triggering alternate sustain samples
685                uint8_t AltSustain2Key;    ///< Key triggering a second set of alternate sustain samples
686    
687            protected:
688                MidiRuleLegato(RIFF::Chunk* _3ewg);
689                MidiRuleLegato();
690                void UpdateChunks(uint8_t* pData) const;
691                friend class Instrument;
692        };
693    
694        /** MIDI rule to automatically cycle through specified sequences of different articulations. The instrument must be using the smartmidi dimension. */
695        class MidiRuleAlternator : public MidiRule {
696            public:
697                uint8_t Articulations;     ///< Number of articulations in the instrument
698                String pArticulations[32]; ///< Names of the articulations
699    
700                range_t PlayRange;         ///< Key range of the playable keys in the instrument
701    
702                uint8_t Patterns;          ///< Number of alternator patterns
703                struct pattern_t {
704                    String Name;           ///< Name of the pattern
705                    int Size;              ///< Number of steps in the pattern
706                    const uint8_t& operator[](int i) const { /// Articulation to play
707                        return data[i];
708                    }
709                    uint8_t& operator[](int i) {
710                        return data[i];
711                    }
712                private:
713                    uint8_t data[32];
714                } pPatterns[32];           ///< A pattern is a sequence of articulation numbers
715    
716                typedef enum {
717                    selector_none,
718                    selector_key_switch,
719                    selector_controller
720                } selector_t;
721                selector_t Selector;       ///< Method by which pattern is chosen
722                range_t KeySwitchRange;    ///< Key range for key switch selector
723                uint8_t Controller;        ///< CC number for controller selector
724    
725                bool Polyphonic;           ///< If alternator should step forward only when all notes are off
726                bool Chained;              ///< If all patterns should be chained together
727    
728            protected:
729                MidiRuleAlternator(RIFF::Chunk* _3ewg);
730                MidiRuleAlternator();
731                void UpdateChunks(uint8_t* pData) const;
732                friend class Instrument;
733        };
734    
735        /** A MIDI rule not yet implemented by libgig. */
736        class MidiRuleUnknown : public MidiRule {
737            protected:
738                MidiRuleUnknown() { }
739                void UpdateChunks(uint8_t* pData) const { }
740              friend class Instrument;              friend class Instrument;
741      };      };
742    
# Line 699  namespace gig { Line 774  namespace gig {
774              // own methods              // own methods
775              Region*   GetRegion(unsigned int Key);              Region*   GetRegion(unsigned int Key);
776              MidiRule* GetMidiRule(int i);              MidiRule* GetMidiRule(int i);
777                MidiRuleCtrlTrigger* AddMidiRuleCtrlTrigger();
778                MidiRuleLegato*      AddMidiRuleLegato();
779                MidiRuleAlternator*  AddMidiRuleAlternator();
780                void      DeleteMidiRule(int i);
781          protected:          protected:
782              Region*   RegionKeyTable[128]; ///< fast lookup for the corresponding Region of a MIDI key              Region*   RegionKeyTable[128]; ///< fast lookup for the corresponding Region of a MIDI key
783    

Legend:
Removed from v.2394  
changed lines
  Added in v.2450

  ViewVC Help
Powered by ViewVC