Debian Codegraph @

BambooTracker/instrument/effect_iterator.cpp

raw
1 /*
2 * Copyright (C) 2018-2023 Rerrah
3 *
4 * Permission is hereby granted, free of charge, to any person
5 * obtaining a copy of this software and associated documentation
6 * files (the "Software"), to deal in the Software without
7 * restriction, including without limitation the rights to use,
8 * copy, modify, merge, publish, distribute, sublicense, and/or sell
9 * copies of the Software, and to permit persons to whom the
10 * Software is furnished to do so, subject to the following
11 * conditions:
12 *
13 * The above copyright notice and this permission notice shall be
14 * included in all copies or substantial portions of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
17 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
18 * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
19 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
20 * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
21 * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
22 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
23 * OTHER DEALINGS IN THE SOFTWARE.
24 */
25
26 #include "effect_iterator.hpp"
27 #include "note.hpp"
28 #include <cstddef>
29 #include "utils.hpp"
30
31 namespace
32 {
33 const InstrumentSequenceBaseUnit ARP_CENTER(Note::DEFAULT_NOTE_NUM);
34 }
35
36 ArpeggioEffectIterator::ArpeggioEffectIterator(int second, int third)
37 : SequenceIteratorInterface<InstrumentSequenceBaseUnit>(2),
38 second_(second + ARP_CENTER.data),
39 third_(third + ARP_CENTER.data)
40 {
41 }
42
43 InstrumentSequenceBaseUnit ArpeggioEffectIterator::data() const noexcept
44 {
45 switch (pos_) {
46 case 0: return ARP_CENTER;
47 case 1: return second_;
48 case 2: return third_;
49 default: return InstrumentSequenceBaseUnit();
50 }
51 }
52
53 int ArpeggioEffectIterator::next()
54 {
55 state_ = SequenceIteratorState::Run;
56 pos_ = (pos_ + 1) % 3;
57 return pos_;
58 }
59
60 int ArpeggioEffectIterator::front()
61 {
62 state_ = SequenceIteratorState::Run;
63 pos_ = 0;
64 return 0;
65 }
66
67 int ArpeggioEffectIterator::end()
68 {
69 state_ = SequenceIteratorState::End;
70 pos_ = END_SEQ_POS;
71 return END_SEQ_POS;
72 }
73
74 WavingEffectIterator::WavingEffectIterator(int period, int depth)
75 {
76 for (int i = 0; i <= period; ++i) {
77 seq_.emplace_back(i * depth);
78 }
79 for (size_t i = static_cast<size_t>(period - 1); i > 0; --i) {
80 seq_.push_back(seq_.at(i));
81 }
82 size_t p2 = static_cast<size_t>(period) << 1;
83 for (size_t i = 0; i < p2; ++i) {
84 seq_.emplace_back(-seq_.at(i).data);
85 }
86
87 pos_ = static_cast<int>(seq_.size()) - 1;
88 }
89
90 InstrumentSequenceBaseUnit WavingEffectIterator::data() const
91 {
92 return (hasEnded() ? InstrumentSequenceBaseUnit() : seq_.at(static_cast<size_t>(pos_)));
93 }
94
95 int WavingEffectIterator::next()
96 {
97 state_ = SequenceIteratorState::Run;
98 pos_ = (pos_ + 1) % static_cast<int>(seq_.size());
99 return pos_;
100 }
101
102 int WavingEffectIterator::front()
103 {
104 state_ = SequenceIteratorState::Run;
105 pos_ = 0;
106 return 0;
107 }
108
109 int WavingEffectIterator::end()
110 {
111 state_ = SequenceIteratorState::End;
112 pos_ = END_SEQ_POS;
113 return END_SEQ_POS;
114 }
115
116 NoteSlideEffectIterator::NoteSlideEffectIterator(int speed, int semitone)
117 : SequenceIteratorInterface<InstrumentSequenceBaseUnit>(0)
118 {
119 int d = semitone * Note::SEMITONE_PITCH;
120 if (speed) {
121 int prev = 0;
122 for (int i = 0; i <= speed; ++i) {
123 int dif = d * i / speed - prev;
124 seq_.emplace_back(dif);
125 prev += dif;
126 }
127 }
128 else {
129 seq_.emplace_back(d);
130 }
131 }
132
133 InstrumentSequenceBaseUnit NoteSlideEffectIterator::data() const
134 {
135 return (hasEnded() ? InstrumentSequenceBaseUnit() : seq_.at(static_cast<size_t>(pos_)));
136 }
137
138 int NoteSlideEffectIterator::next()
139 {
140 if (!hasEnded()) {
141 if (state_ == SequenceIteratorState::NotBegin || ++pos_ < static_cast<int>(seq_.size())) {
142 state_ = SequenceIteratorState::Run;
143 }
144 else {
145 state_ = SequenceIteratorState::End;
146 pos_ = END_SEQ_POS;
147 }
148 }
149
150 return pos_;
151 }
152
153 int NoteSlideEffectIterator::front()
154 {
155 state_ = SequenceIteratorState::Run;
156 pos_ = 0;
157 return 0;
158 }
159
160 int NoteSlideEffectIterator::end()
161 {
162 state_ = SequenceIteratorState::End;
163 pos_ = END_SEQ_POS;
164 return END_SEQ_POS;
165 }
166
167 XVolumeSlideEffectIterator::XVolumeSlideEffectIterator(int factor, int cycleCount)
168 : SequenceIteratorInterface<InstrumentSequenceBaseUnit>(END_SEQ_POS),
169 mem_(0),
170 sum_(0),
171 factor_(factor),
172 cycleCount_(cycleCount)
173 {
174 }
175
176 InstrumentSequenceBaseUnit XVolumeSlideEffectIterator::data() const noexcept
177 {
178 return InstrumentSequenceBaseUnit(mem_);
179 }
180
181 int XVolumeSlideEffectIterator::next()
182 {
183 if (state_ != SequenceIteratorState::Run) {
184 state_ = SequenceIteratorState::Run;
185 pos_ = 0;
186 mem_ = 0;
187 sum_ = 0;
188 }
189 else {
190 int prevSum = std::exchange(sum_, ++pos_ * factor_ / cycleCount_);
191 mem_ = sum_ - prevSum;
192 pos_ %= cycleCount_;
193 sum_ %= factor_;
194 }
195
196 return pos_;
197 }
198
199 int XVolumeSlideEffectIterator::front()
200 {
201 state_ = SequenceIteratorState::Run;
202 pos_ = 0;
203 mem_ = 0;
204 sum_ = 0;
205 return 0;
206 }
207
208 int XVolumeSlideEffectIterator::end()
209 {
210 state_ = SequenceIteratorState::End;
211 pos_ = END_SEQ_POS;
212 mem_ = 0;
213 sum_ = 0;
214 return pos_;
215 }