Line data Source code
1 : /*
2 : * SPDX-License-Identifier: GPL-3.0-only
3 : * MuseScore-Studio-CLA-applies
4 : *
5 : * MuseScore Studio
6 : * Music Composition & Notation
7 : *
8 : * Copyright (C) 2021 MuseScore Limited and others
9 : *
10 : * This program is free software: you can redistribute it and/or modify
11 : * it under the terms of the GNU General Public License version 3 as
12 : * published by the Free Software Foundation.
13 : *
14 : * This program is distributed in the hope that it will be useful,
15 : * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 : * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 : * GNU General Public License for more details.
18 : *
19 : * You should have received a copy of the GNU General Public License
20 : * along with this program. If not, see <https://www.gnu.org/licenses/>.
21 : */
22 :
23 : #include "drumset.h"
24 :
25 : #include "translation.h"
26 :
27 : #include "types/typesconv.h"
28 : #include "types/symnames.h"
29 :
30 : #include "rw/xmlwriter.h"
31 : #include "rw/xmlreader.h"
32 :
33 : #include "articulation.h"
34 :
35 : #include "log.h"
36 :
37 : using namespace mu;
38 : using namespace mu::engraving;
39 :
40 : namespace mu::engraving {
41 : Drumset* smDrumset = nullptr; // standard midi drumset
42 :
43 10881 : bool Drumset::isValid(int pitch) const
44 : {
45 10881 : return pitch >= 0 && pitch < DRUM_INSTRUMENTS && !m_drums[pitch].name.empty();
46 : }
47 :
48 0 : String Drumset::translatedName(int pitch) const
49 : {
50 0 : return muse::mtrc("engraving/drumset", name(pitch));
51 : }
52 :
53 0 : int Drumset::pitchForShortcut(const String& shortcut) const
54 : {
55 0 : if (shortcut.isEmpty()) {
56 0 : return -1;
57 : }
58 :
59 0 : for (int pitch = 0; pitch < DRUM_INSTRUMENTS; ++pitch) {
60 0 : if (!isValid(pitch)) {
61 0 : continue;
62 : }
63 :
64 0 : if (drum(pitch).shortcut != shortcut) {
65 0 : continue;
66 : }
67 :
68 0 : return pitch;
69 : }
70 :
71 0 : return -1;
72 : }
73 :
74 0 : int Drumset::defaultPitchForLine(int val) const
75 : {
76 0 : int firstValidPitch = -1;
77 0 : for (int pitch = 0; pitch < DRUM_INSTRUMENTS; ++pitch) {
78 0 : if (!isValid(pitch) || line(pitch) != val) {
79 0 : continue;
80 : }
81 :
82 0 : if (firstValidPitch < 0) {
83 0 : firstValidPitch = pitch;
84 : }
85 :
86 0 : const NoteHeadGroup headGroup = noteHead(pitch);
87 0 : if (headGroup == NoteHeadGroup::HEAD_NORMAL) {
88 0 : return pitch;
89 : }
90 : }
91 0 : return firstValidPitch;
92 : }
93 :
94 : //---------------------------------------------------------
95 : // save
96 : //---------------------------------------------------------
97 :
98 39 : void Drumset::save(XmlWriter& xml) const
99 : {
100 39 : xml.tag("percussionPanelColumns", m_percussionPanelColumns);
101 5031 : for (int i = 0; i < DRUM_INSTRUMENTS; ++i) {
102 4992 : if (!isValid(i)) {
103 3984 : continue;
104 : }
105 3024 : xml.startElement("Drum", { { "pitch", i } });
106 1008 : const NoteHeadGroup nh = noteHead(i);
107 : //write custom as Normal notehead group + noteheads tag to keep compatibility with 2.X versions
108 1008 : const NoteHeadGroup saveNHValue = (nh == NoteHeadGroup::HEAD_CUSTOM) ? NoteHeadGroup::HEAD_NORMAL : nh;
109 1008 : xml.tag("head", TConv::toXml(saveNHValue));
110 1008 : if (nh == NoteHeadGroup::HEAD_CUSTOM) {
111 23 : xml.startElement("noteheads");
112 115 : for (int j = 0; j < int(NoteHeadType::HEAD_TYPES); j++) {
113 92 : xml.tag(TConv::toXml(NoteHeadType(j)), SymNames::nameForSymId(noteHeads(i, NoteHeadType(j))));
114 : }
115 23 : xml.endElement();
116 : }
117 1008 : xml.tag("line", line(i));
118 1008 : xml.tag("voice", voice(i));
119 1008 : xml.tag("name", name(i));
120 1008 : xml.tag("stem", int(stemDirection(i)));
121 1008 : if (!shortcut(i).empty()) {
122 146 : xml.tag("shortcut", shortcut(i));
123 : }
124 1008 : const std::vector<DrumInstrumentVariant>& vs = variants(i);
125 1008 : if (!vs.empty()) {
126 0 : xml.startElement("variants");
127 0 : for (const auto& v : vs) {
128 0 : xml.startElement("variant", { { "pitch", v.pitch } });
129 0 : if (!v.articulationName.empty()) {
130 0 : xml.tag("articulation", v.articulationName);
131 : }
132 0 : if (v.tremolo != TremoloType::INVALID_TREMOLO) {
133 0 : xml.tag("tremolo", TConv::toXml(v.tremolo));
134 : }
135 0 : xml.endElement();
136 : }
137 0 : xml.endElement();
138 : }
139 1008 : if (panelRow(i) > -1 && panelColumn(i) > -1) {
140 459 : xml.tag("panelRow", panelRow(i));
141 459 : xml.tag("panelColumn", panelColumn(i));
142 : }
143 1008 : xml.endElement();
144 : }
145 1047 : }
146 :
147 58392 : bool Drumset::readDrumProperties(XmlReader& e, int pitch)
148 : {
149 58392 : if (pitch < 0 || pitch > DRUM_INSTRUMENTS - 1) {
150 0 : return false;
151 : }
152 :
153 58392 : const AsciiStringView tag(e.name());
154 58392 : if (tag == "head") {
155 8938 : m_drums[pitch].notehead = TConv::fromXml(e.readAsciiText(), NoteHeadGroup::HEAD_NORMAL);
156 49454 : } else if (tag == "noteheads") {
157 145 : m_drums[pitch].notehead = NoteHeadGroup::HEAD_CUSTOM;
158 725 : while (e.readNextStartElement()) {
159 580 : const AsciiStringView nhTag(e.name());
160 580 : int noteType = int(TConv::fromXml(nhTag, NoteHeadType::HEAD_AUTO));
161 580 : if (noteType > int(NoteHeadType::HEAD_TYPES) - 1 || noteType < 0) {
162 0 : return false;
163 : }
164 :
165 580 : m_drums[pitch].noteheads[noteType] = SymNames::symIdByName(e.readAsciiText());
166 : }
167 49309 : } else if (tag == "line") {
168 9032 : m_drums[pitch].line = e.readInt();
169 40277 : } else if (tag == "voice") {
170 9032 : m_drums[pitch].voice = e.readInt();
171 31245 : } else if (tag == "name") {
172 9032 : m_drums[pitch].name = e.readText();
173 22213 : } else if (tag == "stem") {
174 8648 : m_drums[pitch].stemDirection = DirectionV(e.readInt());
175 13565 : } else if (tag == "shortcut") {
176 4335 : m_drums[pitch].shortcut = e.readText();
177 9230 : } else if (tag == "variants") {
178 0 : while (e.readNextStartElement()) {
179 0 : const AsciiStringView tagv(e.name());
180 0 : if (tagv == "variant") {
181 0 : DrumInstrumentVariant div;
182 0 : div.pitch = e.attribute("pitch").toInt();
183 0 : while (e.readNextStartElement()) {
184 0 : const AsciiStringView taga(e.name());
185 0 : if (taga == "articulation") {
186 0 : div.articulationName = e.readText();
187 0 : } else if (taga == "tremolo") {
188 0 : div.tremolo = TConv::fromXml(e.readAsciiText(), TremoloType::INVALID_TREMOLO);
189 : }
190 : }
191 0 : m_drums[pitch].addVariant(div);
192 0 : }
193 : }
194 9230 : } else if (tag == "panelRow") {
195 4615 : m_drums[pitch].panelRow = e.readInt();
196 4615 : } else if (tag == "panelColumn") {
197 4615 : m_drums[pitch].panelColumn = e.readInt();
198 : } else {
199 0 : return false;
200 : }
201 58392 : return true;
202 : }
203 :
204 : //---------------------------------------------------------
205 : // load
206 : //---------------------------------------------------------
207 :
208 8938 : void Drumset::loadDrum(XmlReader& e)
209 : {
210 8938 : int pitch = e.intAttribute("pitch", -1);
211 8938 : if (pitch < 0 || pitch > DRUM_INSTRUMENTS - 1) {
212 0 : LOGD("load drumset: invalid pitch %d", pitch);
213 0 : return;
214 : }
215 75883 : while (e.readNextStartElement()) {
216 58007 : if (readDrumProperties(e, pitch)) {
217 : } else {
218 0 : e.unknown();
219 : }
220 : }
221 : }
222 :
223 : //---------------------------------------------------------
224 : // clear
225 : //---------------------------------------------------------
226 :
227 1904 : void Drumset::clear()
228 : {
229 245616 : for (int i = 0; i < DRUM_INSTRUMENTS; ++i) {
230 243712 : m_drums[i].name.clear();
231 243712 : m_drums[i].notehead = NoteHeadGroup::HEAD_INVALID;
232 243712 : m_drums[i].shortcut.clear();
233 243712 : m_drums[i].variants.clear();
234 243712 : m_drums[i].panelRow = -1;
235 243712 : m_drums[i].panelColumn = -1;
236 : }
237 1904 : }
238 :
239 : //---------------------------------------------------------
240 : // nextPitch
241 : //---------------------------------------------------------
242 :
243 702 : int Drumset::nextPitch(int ii) const
244 : {
245 2967 : for (int i = ii + 1; i < DRUM_INSTRUMENTS - 1; ++i) {
246 2965 : if (isValid(i)) {
247 700 : return i;
248 : }
249 : }
250 72 : for (int i = 0; i <= ii; ++i) {
251 72 : if (isValid(i)) {
252 2 : return i;
253 : }
254 : }
255 0 : return 0;
256 : }
257 :
258 : //---------------------------------------------------------
259 : // prevPitch
260 : //---------------------------------------------------------
261 :
262 0 : int Drumset::prevPitch(int ii) const
263 : {
264 0 : for (int i = ii - 1; i >= 0; --i) {
265 0 : if (isValid(i)) {
266 0 : return i;
267 : }
268 : }
269 0 : for (int i = DRUM_INSTRUMENTS - 1; i >= ii; --i) {
270 0 : if (isValid(i)) {
271 0 : return i;
272 : }
273 : }
274 0 : return 0;
275 : }
276 :
277 : //---------------------------------------------------------
278 : // findVariant
279 : /// find a variant for the given pitch with matching chord articulation and tremolo
280 : //---------------------------------------------------------
281 :
282 105 : DrumInstrumentVariant Drumset::findVariant(int p, const std::vector<Articulation*>& articulations, TremoloType tremType) const
283 : {
284 105 : DrumInstrumentVariant div;
285 105 : const std::vector<DrumInstrumentVariant>& vs = variants(p);
286 105 : for (const DrumInstrumentVariant& v : vs) {
287 0 : bool matchTremolo = ((tremType == TremoloType::INVALID_TREMOLO) && (v.tremolo == TremoloType::INVALID_TREMOLO))
288 0 : || (v.tremolo == tremType);
289 0 : bool matchArticulation = v.articulationName.empty() && articulations.empty();
290 0 : for (const Articulation* a : articulations) {
291 0 : matchArticulation = a->articulationName() == v.articulationName;
292 0 : if (!matchArticulation) {
293 0 : break;
294 : }
295 : }
296 0 : if (matchArticulation && matchTremolo) {
297 0 : div = v;
298 0 : break;
299 : }
300 : }
301 105 : return div;
302 0 : }
303 :
304 : //---------------------------------------------------------
305 : // initDrumset
306 : // initialize standard midi drumset
307 : //---------------------------------------------------------
308 :
309 16 : void Drumset::initDrumset()
310 : {
311 16 : smDrumset = new Drumset;
312 2064 : for (int i = 0; i < DRUM_INSTRUMENTS; ++i) {
313 2048 : smDrumset->drum(i).name.clear();
314 2048 : smDrumset->drum(i).notehead = NoteHeadGroup::HEAD_INVALID;
315 2048 : smDrumset->drum(i).line = 0;
316 2048 : smDrumset->drum(i).shortcut.clear();
317 2048 : smDrumset->drum(i).voice = 0;
318 2048 : smDrumset->drum(i).stemDirection = DirectionV::UP;
319 2048 : smDrumset->drum(i).panelRow = -1;
320 2048 : smDrumset->drum(i).panelColumn = -1;
321 : }
322 :
323 : // Code generated by share/instruments/update_instruments_xml.py. To edit this code:
324 : // 1. Make your changes in the proper place:
325 : // * To change instrument data, edit the online spreadsheet.
326 : // * For other code changes, edit the Python script.
327 : // 2. Run the Python script to generate the changes here.
328 : // 3. Run Uncrustify and update the Python script if necessary to match Uncrustify's formatting.
329 :
330 : // BEGIN GENERATED CODE
331 :
332 : // Laser (High Q)
333 32 : smDrumset->drum(27) = DrumInstrument(
334 : TConv::userName(DrumNum(27)),
335 : NoteHeadGroup::HEAD_SLASH,
336 : /*line*/ 8,
337 : DirectionV::UP,
338 : /*panelRow*/ 0,
339 : /*panelColumn*/ 0,
340 : /*voice*/ 0,
341 48 : /*shortcut*/ String());
342 :
343 : // Slap
344 32 : smDrumset->drum(28) = DrumInstrument(
345 : TConv::userName(DrumNum(28)),
346 : NoteHeadGroup::HEAD_CUSTOM,
347 : /*line*/ 4,
348 : DirectionV::UP,
349 : /*panelRow*/ 0,
350 : /*panelColumn*/ 1,
351 : /*voice*/ 0,
352 48 : /*shortcut*/ String());
353 :
354 16 : smDrumset->drum(28).noteheads[static_cast<int>(NoteHeadType::HEAD_WHOLE)] = SymNames::symIdByName("noteheadSlashX");
355 16 : smDrumset->drum(28).noteheads[static_cast<int>(NoteHeadType::HEAD_HALF)] = SymNames::symIdByName("noteheadSlashX");
356 16 : smDrumset->drum(28).noteheads[static_cast<int>(NoteHeadType::HEAD_QUARTER)] = SymNames::symIdByName("noteheadSlashX");
357 16 : smDrumset->drum(28).noteheads[static_cast<int>(NoteHeadType::HEAD_BREVIS)] = SymNames::symIdByName("noteheadSlashX");
358 :
359 : // Scratch Push
360 32 : smDrumset->drum(29) = DrumInstrument(
361 : TConv::userName(DrumNum(29)),
362 : NoteHeadGroup::HEAD_SLASH,
363 : /*line*/ 6,
364 : DirectionV::UP,
365 : /*panelRow*/ 0,
366 : /*panelColumn*/ 2,
367 : /*voice*/ 0,
368 48 : /*shortcut*/ String());
369 :
370 : // Scratch Pull
371 32 : smDrumset->drum(30) = DrumInstrument(
372 : TConv::userName(DrumNum(30)),
373 : NoteHeadGroup::HEAD_SLASH,
374 : /*line*/ 6,
375 : DirectionV::UP,
376 : /*panelRow*/ 0,
377 : /*panelColumn*/ 3,
378 : /*voice*/ 0,
379 48 : /*shortcut*/ String());
380 :
381 : // Sticks
382 32 : smDrumset->drum(31) = DrumInstrument(
383 : TConv::userName(DrumNum(31)),
384 : NoteHeadGroup::HEAD_PLUS,
385 : /*line*/ -1,
386 : DirectionV::UP,
387 : /*panelRow*/ 0,
388 : /*panelColumn*/ 4,
389 : /*voice*/ 0,
390 48 : /*shortcut*/ String());
391 :
392 : // Square Click
393 32 : smDrumset->drum(32) = DrumInstrument(
394 : TConv::userName(DrumNum(32)),
395 : NoteHeadGroup::HEAD_PLUS,
396 : /*line*/ 10,
397 : DirectionV::UP,
398 : /*panelRow*/ 0,
399 : /*panelColumn*/ 5,
400 : /*voice*/ 0,
401 48 : /*shortcut*/ String());
402 :
403 : // Metronome Click
404 32 : smDrumset->drum(33) = DrumInstrument(
405 : TConv::userName(DrumNum(33)),
406 : NoteHeadGroup::HEAD_CROSS,
407 : /*line*/ 10,
408 : DirectionV::UP,
409 : /*panelRow*/ 0,
410 : /*panelColumn*/ 6,
411 : /*voice*/ 0,
412 48 : /*shortcut*/ String());
413 :
414 : // Metronome Bell
415 32 : smDrumset->drum(34) = DrumInstrument(
416 : TConv::userName(DrumNum(34)),
417 : NoteHeadGroup::HEAD_TRIANGLE_UP,
418 : /*line*/ 10,
419 : DirectionV::UP,
420 : /*panelRow*/ 0,
421 : /*panelColumn*/ 7,
422 : /*voice*/ 0,
423 48 : /*shortcut*/ String());
424 :
425 : // Acoustic Bass Drum
426 32 : smDrumset->drum(35) = DrumInstrument(
427 : TConv::userName(DrumNum(35)),
428 : NoteHeadGroup::HEAD_NORMAL,
429 : /*line*/ 8,
430 : DirectionV::UP,
431 : /*panelRow*/ 1,
432 : /*panelColumn*/ 0,
433 : /*voice*/ 1,
434 48 : /*shortcut*/ String());
435 :
436 : // Electric Bass Drum
437 32 : smDrumset->drum(36) = DrumInstrument(
438 : TConv::userName(DrumNum(36)),
439 : NoteHeadGroup::HEAD_NORMAL,
440 : /*line*/ 7,
441 : DirectionV::DOWN,
442 : /*panelRow*/ 1,
443 : /*panelColumn*/ 1,
444 : /*voice*/ 1,
445 48 : /*shortcut*/ String());
446 :
447 : // Side Stick
448 32 : smDrumset->drum(37) = DrumInstrument(
449 : TConv::userName(DrumNum(37)),
450 : NoteHeadGroup::HEAD_SLASHED1,
451 : /*line*/ 3,
452 : DirectionV::UP,
453 : /*panelRow*/ 1,
454 : /*panelColumn*/ 2,
455 : /*voice*/ 0,
456 48 : /*shortcut*/ String());
457 :
458 : // Acoustic Snare
459 32 : smDrumset->drum(38) = DrumInstrument(
460 : TConv::userName(DrumNum(38)),
461 : NoteHeadGroup::HEAD_NORMAL,
462 : /*line*/ 3,
463 : DirectionV::UP,
464 : /*panelRow*/ 1,
465 : /*panelColumn*/ 3,
466 : /*voice*/ 0,
467 48 : /*shortcut*/ String());
468 :
469 : // Hand Clap
470 32 : smDrumset->drum(39) = DrumInstrument(
471 : TConv::userName(DrumNum(39)),
472 : NoteHeadGroup::HEAD_PLUS,
473 : /*line*/ -2,
474 : DirectionV::UP,
475 : /*panelRow*/ 1,
476 : /*panelColumn*/ 4,
477 : /*voice*/ 0,
478 48 : /*shortcut*/ String());
479 :
480 : // Electric Snare
481 32 : smDrumset->drum(40) = DrumInstrument(
482 : TConv::userName(DrumNum(40)),
483 : NoteHeadGroup::HEAD_SLASH,
484 : /*line*/ 3,
485 : DirectionV::UP,
486 : /*panelRow*/ 1,
487 : /*panelColumn*/ 5,
488 : /*voice*/ 0,
489 48 : /*shortcut*/ String());
490 :
491 : // Low Floor Tom
492 32 : smDrumset->drum(41) = DrumInstrument(
493 : TConv::userName(DrumNum(41)),
494 : NoteHeadGroup::HEAD_NORMAL,
495 : /*line*/ 6,
496 : DirectionV::UP,
497 : /*panelRow*/ 1,
498 : /*panelColumn*/ 6,
499 : /*voice*/ 0,
500 48 : /*shortcut*/ String());
501 :
502 : // Closed Hi-hat
503 32 : smDrumset->drum(42) = DrumInstrument(
504 : TConv::userName(DrumNum(42)),
505 : NoteHeadGroup::HEAD_CROSS,
506 : /*line*/ -1,
507 : DirectionV::UP,
508 : /*panelRow*/ 1,
509 : /*panelColumn*/ 7,
510 : /*voice*/ 0,
511 48 : /*shortcut*/ String());
512 :
513 : // High Floor Tom
514 32 : smDrumset->drum(43) = DrumInstrument(
515 : TConv::userName(DrumNum(43)),
516 : NoteHeadGroup::HEAD_NORMAL,
517 : /*line*/ 5,
518 : DirectionV::UP,
519 : /*panelRow*/ 2,
520 : /*panelColumn*/ 0,
521 : /*voice*/ 0,
522 48 : /*shortcut*/ String());
523 :
524 : // Pedal Hi-hat
525 32 : smDrumset->drum(44) = DrumInstrument(
526 : TConv::userName(DrumNum(44)),
527 : NoteHeadGroup::HEAD_CROSS,
528 : /*line*/ 9,
529 : DirectionV::UP,
530 : /*panelRow*/ 2,
531 : /*panelColumn*/ 1,
532 : /*voice*/ 1,
533 48 : /*shortcut*/ String());
534 :
535 : // Low Tom
536 32 : smDrumset->drum(45) = DrumInstrument(
537 : TConv::userName(DrumNum(45)),
538 : NoteHeadGroup::HEAD_NORMAL,
539 : /*line*/ 4,
540 : DirectionV::UP,
541 : /*panelRow*/ 2,
542 : /*panelColumn*/ 2,
543 : /*voice*/ 0,
544 48 : /*shortcut*/ String());
545 :
546 : // Open Hi-hat
547 32 : smDrumset->drum(46) = DrumInstrument(
548 : TConv::userName(DrumNum(46)),
549 : NoteHeadGroup::HEAD_XCIRCLE,
550 : /*line*/ -1,
551 : DirectionV::UP,
552 : /*panelRow*/ 2,
553 : /*panelColumn*/ 3,
554 : /*voice*/ 0,
555 48 : /*shortcut*/ String());
556 :
557 : // Low-Mid Tom
558 32 : smDrumset->drum(47) = DrumInstrument(
559 : TConv::userName(DrumNum(47)),
560 : NoteHeadGroup::HEAD_NORMAL,
561 : /*line*/ 2,
562 : DirectionV::UP,
563 : /*panelRow*/ 2,
564 : /*panelColumn*/ 4,
565 : /*voice*/ 0,
566 48 : /*shortcut*/ String());
567 :
568 : // Hi-Mid Tom
569 32 : smDrumset->drum(48) = DrumInstrument(
570 : TConv::userName(DrumNum(48)),
571 : NoteHeadGroup::HEAD_NORMAL,
572 : /*line*/ 1,
573 : DirectionV::UP,
574 : /*panelRow*/ 2,
575 : /*panelColumn*/ 5,
576 : /*voice*/ 0,
577 48 : /*shortcut*/ String());
578 :
579 : // Crash Cymbal 1
580 32 : smDrumset->drum(49) = DrumInstrument(
581 : TConv::userName(DrumNum(49)),
582 : NoteHeadGroup::HEAD_CROSS,
583 : /*line*/ -2,
584 : DirectionV::UP,
585 : /*panelRow*/ 2,
586 : /*panelColumn*/ 6,
587 : /*voice*/ 0,
588 48 : /*shortcut*/ String());
589 :
590 : // High Tom
591 32 : smDrumset->drum(50) = DrumInstrument(
592 : TConv::userName(DrumNum(50)),
593 : NoteHeadGroup::HEAD_NORMAL,
594 : /*line*/ 0,
595 : DirectionV::UP,
596 : /*panelRow*/ 2,
597 : /*panelColumn*/ 7,
598 : /*voice*/ 0,
599 48 : /*shortcut*/ String());
600 :
601 : // Ride Cymbal 1
602 32 : smDrumset->drum(51) = DrumInstrument(
603 : TConv::userName(DrumNum(51)),
604 : NoteHeadGroup::HEAD_CROSS,
605 : /*line*/ 0,
606 : DirectionV::UP,
607 : /*panelRow*/ 3,
608 : /*panelColumn*/ 0,
609 : /*voice*/ 0,
610 48 : /*shortcut*/ String());
611 :
612 : // China Cymbal
613 32 : smDrumset->drum(52) = DrumInstrument(
614 : TConv::userName(DrumNum(52)),
615 : NoteHeadGroup::HEAD_CUSTOM,
616 : /*line*/ -3,
617 : DirectionV::UP,
618 : /*panelRow*/ 3,
619 : /*panelColumn*/ 1,
620 : /*voice*/ 0,
621 48 : /*shortcut*/ String());
622 :
623 16 : smDrumset->drum(52).noteheads[static_cast<int>(NoteHeadType::HEAD_WHOLE)] = SymNames::symIdByName("noteheadHeavyXHat");
624 16 : smDrumset->drum(52).noteheads[static_cast<int>(NoteHeadType::HEAD_HALF)] = SymNames::symIdByName("noteheadHeavyXHat");
625 16 : smDrumset->drum(52).noteheads[static_cast<int>(NoteHeadType::HEAD_QUARTER)] = SymNames::symIdByName("noteheadHeavyXHat");
626 16 : smDrumset->drum(52).noteheads[static_cast<int>(NoteHeadType::HEAD_BREVIS)] = SymNames::symIdByName("noteheadHeavyXHat");
627 :
628 : // Ride Bell
629 32 : smDrumset->drum(53) = DrumInstrument(
630 : TConv::userName(DrumNum(53)),
631 : NoteHeadGroup::HEAD_DIAMOND,
632 : /*line*/ 0,
633 : DirectionV::UP,
634 : /*panelRow*/ 3,
635 : /*panelColumn*/ 2,
636 : /*voice*/ 0,
637 48 : /*shortcut*/ String());
638 :
639 : // Tambourine
640 32 : smDrumset->drum(54) = DrumInstrument(
641 : TConv::userName(DrumNum(54)),
642 : NoteHeadGroup::HEAD_DIAMOND,
643 : /*line*/ 6,
644 : DirectionV::UP,
645 : /*panelRow*/ 3,
646 : /*panelColumn*/ 3,
647 : /*voice*/ 0,
648 48 : /*shortcut*/ String());
649 :
650 : // Splash Cymbal
651 32 : smDrumset->drum(55) = DrumInstrument(
652 : TConv::userName(DrumNum(55)),
653 : NoteHeadGroup::HEAD_CROSS,
654 : /*line*/ -4,
655 : DirectionV::UP,
656 : /*panelRow*/ 3,
657 : /*panelColumn*/ 4,
658 : /*voice*/ 0,
659 48 : /*shortcut*/ String());
660 :
661 : // Cowbell
662 32 : smDrumset->drum(56) = DrumInstrument(
663 : TConv::userName(DrumNum(56)),
664 : NoteHeadGroup::HEAD_TRIANGLE_DOWN,
665 : /*line*/ 0,
666 : DirectionV::UP,
667 : /*panelRow*/ 3,
668 : /*panelColumn*/ 5,
669 : /*voice*/ 0,
670 48 : /*shortcut*/ String());
671 :
672 : // Crash Cymbal 2
673 32 : smDrumset->drum(57) = DrumInstrument(
674 : TConv::userName(DrumNum(57)),
675 : NoteHeadGroup::HEAD_CROSS,
676 : /*line*/ -3,
677 : DirectionV::UP,
678 : /*panelRow*/ 3,
679 : /*panelColumn*/ 6,
680 : /*voice*/ 0,
681 48 : /*shortcut*/ String());
682 :
683 : // Vibraslap
684 32 : smDrumset->drum(58) = DrumInstrument(
685 : TConv::userName(DrumNum(58)),
686 : NoteHeadGroup::HEAD_TI,
687 : /*line*/ 0,
688 : DirectionV::UP,
689 : /*panelRow*/ 3,
690 : /*panelColumn*/ 7,
691 : /*voice*/ 0,
692 48 : /*shortcut*/ String());
693 :
694 : // Ride Cymbal 2
695 32 : smDrumset->drum(59) = DrumInstrument(
696 : TConv::userName(DrumNum(59)),
697 : NoteHeadGroup::HEAD_CROSS,
698 : /*line*/ 2,
699 : DirectionV::UP,
700 : /*panelRow*/ 4,
701 : /*panelColumn*/ 0,
702 : /*voice*/ 0,
703 48 : /*shortcut*/ String());
704 :
705 : // High Bongo
706 32 : smDrumset->drum(60) = DrumInstrument(
707 : TConv::userName(DrumNum(60)),
708 : NoteHeadGroup::HEAD_NORMAL,
709 : /*line*/ -1,
710 : DirectionV::UP,
711 : /*panelRow*/ 4,
712 : /*panelColumn*/ 1,
713 : /*voice*/ 0,
714 48 : /*shortcut*/ String());
715 :
716 : // Low Bongo
717 32 : smDrumset->drum(61) = DrumInstrument(
718 : TConv::userName(DrumNum(61)),
719 : NoteHeadGroup::HEAD_NORMAL,
720 : /*line*/ 0,
721 : DirectionV::UP,
722 : /*panelRow*/ 4,
723 : /*panelColumn*/ 2,
724 : /*voice*/ 0,
725 48 : /*shortcut*/ String());
726 :
727 : // Mute High Conga
728 32 : smDrumset->drum(62) = DrumInstrument(
729 : TConv::userName(DrumNum(62)),
730 : NoteHeadGroup::HEAD_CUSTOM,
731 : /*line*/ 1,
732 : DirectionV::UP,
733 : /*panelRow*/ 4,
734 : /*panelColumn*/ 3,
735 : /*voice*/ 0,
736 48 : /*shortcut*/ String());
737 :
738 16 : smDrumset->drum(62).noteheads[static_cast<int>(NoteHeadType::HEAD_WHOLE)] = SymNames::symIdByName("noteheadXOrnate");
739 16 : smDrumset->drum(62).noteheads[static_cast<int>(NoteHeadType::HEAD_HALF)] = SymNames::symIdByName("noteheadXOrnate");
740 16 : smDrumset->drum(62).noteheads[static_cast<int>(NoteHeadType::HEAD_QUARTER)] = SymNames::symIdByName("noteheadXOrnate");
741 16 : smDrumset->drum(62).noteheads[static_cast<int>(NoteHeadType::HEAD_BREVIS)] = SymNames::symIdByName("noteheadXOrnate");
742 :
743 : // Open High Conga
744 32 : smDrumset->drum(63) = DrumInstrument(
745 : TConv::userName(DrumNum(63)),
746 : NoteHeadGroup::HEAD_NORMAL,
747 : /*line*/ 1,
748 : DirectionV::UP,
749 : /*panelRow*/ 4,
750 : /*panelColumn*/ 4,
751 : /*voice*/ 0,
752 48 : /*shortcut*/ String());
753 :
754 : // Low Conga
755 32 : smDrumset->drum(64) = DrumInstrument(
756 : TConv::userName(DrumNum(64)),
757 : NoteHeadGroup::HEAD_NORMAL,
758 : /*line*/ 2,
759 : DirectionV::UP,
760 : /*panelRow*/ 4,
761 : /*panelColumn*/ 5,
762 : /*voice*/ 0,
763 48 : /*shortcut*/ String());
764 :
765 : // High Timbale
766 32 : smDrumset->drum(65) = DrumInstrument(
767 : TConv::userName(DrumNum(65)),
768 : NoteHeadGroup::HEAD_NORMAL,
769 : /*line*/ 5,
770 : DirectionV::UP,
771 : /*panelRow*/ 4,
772 : /*panelColumn*/ 6,
773 : /*voice*/ 0,
774 48 : /*shortcut*/ String());
775 :
776 : // Low Timbale
777 32 : smDrumset->drum(66) = DrumInstrument(
778 : TConv::userName(DrumNum(66)),
779 : NoteHeadGroup::HEAD_NORMAL,
780 : /*line*/ 7,
781 : DirectionV::UP,
782 : /*panelRow*/ 4,
783 : /*panelColumn*/ 7,
784 : /*voice*/ 0,
785 48 : /*shortcut*/ String());
786 :
787 : // High Agogô
788 32 : smDrumset->drum(67) = DrumInstrument(
789 : TConv::userName(DrumNum(67)),
790 : NoteHeadGroup::HEAD_TRIANGLE_DOWN,
791 : /*line*/ -2,
792 : DirectionV::UP,
793 : /*panelRow*/ 5,
794 : /*panelColumn*/ 0,
795 : /*voice*/ 0,
796 48 : /*shortcut*/ String());
797 :
798 : // Low Agogô
799 32 : smDrumset->drum(68) = DrumInstrument(
800 : TConv::userName(DrumNum(68)),
801 : NoteHeadGroup::HEAD_TRIANGLE_DOWN,
802 : /*line*/ -1,
803 : DirectionV::UP,
804 : /*panelRow*/ 5,
805 : /*panelColumn*/ 1,
806 : /*voice*/ 0,
807 48 : /*shortcut*/ String());
808 :
809 : // Cabasa
810 32 : smDrumset->drum(69) = DrumInstrument(
811 : TConv::userName(DrumNum(69)),
812 : NoteHeadGroup::HEAD_DIAMOND,
813 : /*line*/ 2,
814 : DirectionV::UP,
815 : /*panelRow*/ 5,
816 : /*panelColumn*/ 2,
817 : /*voice*/ 0,
818 48 : /*shortcut*/ String());
819 :
820 : // Maracas
821 32 : smDrumset->drum(70) = DrumInstrument(
822 : TConv::userName(DrumNum(70)),
823 : NoteHeadGroup::HEAD_DIAMOND,
824 : /*line*/ 4,
825 : DirectionV::UP,
826 : /*panelRow*/ 5,
827 : /*panelColumn*/ 3,
828 : /*voice*/ 0,
829 48 : /*shortcut*/ String());
830 :
831 : // Short Whistle
832 32 : smDrumset->drum(71) = DrumInstrument(
833 : TConv::userName(DrumNum(71)),
834 : NoteHeadGroup::HEAD_CROSS,
835 : /*line*/ -3,
836 : DirectionV::UP,
837 : /*panelRow*/ 5,
838 : /*panelColumn*/ 4,
839 : /*voice*/ 0,
840 48 : /*shortcut*/ String());
841 :
842 : // Long Whistle
843 32 : smDrumset->drum(72) = DrumInstrument(
844 : TConv::userName(DrumNum(72)),
845 : NoteHeadGroup::HEAD_TI,
846 : /*line*/ -3,
847 : DirectionV::UP,
848 : /*panelRow*/ 5,
849 : /*panelColumn*/ 5,
850 : /*voice*/ 0,
851 48 : /*shortcut*/ String());
852 :
853 : // Short Güiro
854 32 : smDrumset->drum(73) = DrumInstrument(
855 : TConv::userName(DrumNum(73)),
856 : NoteHeadGroup::HEAD_CROSS,
857 : /*line*/ -1,
858 : DirectionV::UP,
859 : /*panelRow*/ 5,
860 : /*panelColumn*/ 6,
861 : /*voice*/ 0,
862 48 : /*shortcut*/ String());
863 :
864 : // Long Güiro
865 32 : smDrumset->drum(74) = DrumInstrument(
866 : TConv::userName(DrumNum(74)),
867 : NoteHeadGroup::HEAD_SLASHED1,
868 : /*line*/ -1,
869 : DirectionV::UP,
870 : /*panelRow*/ 5,
871 : /*panelColumn*/ 7,
872 : /*voice*/ 0,
873 48 : /*shortcut*/ String());
874 :
875 : // Claves
876 32 : smDrumset->drum(75) = DrumInstrument(
877 : TConv::userName(DrumNum(75)),
878 : NoteHeadGroup::HEAD_LA,
879 : /*line*/ 0,
880 : DirectionV::UP,
881 : /*panelRow*/ 6,
882 : /*panelColumn*/ 0,
883 : /*voice*/ 0,
884 48 : /*shortcut*/ String());
885 :
886 : // High Woodblock
887 32 : smDrumset->drum(76) = DrumInstrument(
888 : TConv::userName(DrumNum(76)),
889 : NoteHeadGroup::HEAD_LA,
890 : /*line*/ 5,
891 : DirectionV::UP,
892 : /*panelRow*/ 6,
893 : /*panelColumn*/ 1,
894 : /*voice*/ 0,
895 48 : /*shortcut*/ String());
896 :
897 : // Low Woodblock
898 32 : smDrumset->drum(77) = DrumInstrument(
899 : TConv::userName(DrumNum(77)),
900 : NoteHeadGroup::HEAD_LA,
901 : /*line*/ 7,
902 : DirectionV::UP,
903 : /*panelRow*/ 6,
904 : /*panelColumn*/ 2,
905 : /*voice*/ 0,
906 48 : /*shortcut*/ String());
907 :
908 : // Mute Cuica
909 32 : smDrumset->drum(78) = DrumInstrument(
910 : TConv::userName(DrumNum(78)),
911 : NoteHeadGroup::HEAD_CROSS,
912 : /*line*/ 8,
913 : DirectionV::UP,
914 : /*panelRow*/ 6,
915 : /*panelColumn*/ 3,
916 : /*voice*/ 0,
917 48 : /*shortcut*/ String());
918 :
919 : // Open Cuica
920 32 : smDrumset->drum(79) = DrumInstrument(
921 : TConv::userName(DrumNum(79)),
922 : NoteHeadGroup::HEAD_SLASHED2,
923 : /*line*/ 8,
924 : DirectionV::UP,
925 : /*panelRow*/ 6,
926 : /*panelColumn*/ 4,
927 : /*voice*/ 0,
928 48 : /*shortcut*/ String());
929 :
930 : // Mute Triangle
931 32 : smDrumset->drum(80) = DrumInstrument(
932 : TConv::userName(DrumNum(80)),
933 : NoteHeadGroup::HEAD_CROSS,
934 : /*line*/ 0,
935 : DirectionV::UP,
936 : /*panelRow*/ 6,
937 : /*panelColumn*/ 5,
938 : /*voice*/ 0,
939 48 : /*shortcut*/ String());
940 :
941 : // Open Triangle
942 32 : smDrumset->drum(81) = DrumInstrument(
943 : TConv::userName(DrumNum(81)),
944 : NoteHeadGroup::HEAD_TRIANGLE_UP,
945 : /*line*/ 0,
946 : DirectionV::UP,
947 : /*panelRow*/ 6,
948 : /*panelColumn*/ 6,
949 : /*voice*/ 0,
950 48 : /*shortcut*/ String());
951 :
952 : // Shaker
953 32 : smDrumset->drum(82) = DrumInstrument(
954 : TConv::userName(DrumNum(82)),
955 : NoteHeadGroup::HEAD_DIAMOND,
956 : /*line*/ 5,
957 : DirectionV::UP,
958 : /*panelRow*/ 6,
959 : /*panelColumn*/ 7,
960 : /*voice*/ 0,
961 48 : /*shortcut*/ String());
962 :
963 : // Jingle Bell
964 32 : smDrumset->drum(83) = DrumInstrument(
965 : TConv::userName(DrumNum(83)),
966 : NoteHeadGroup::HEAD_TRIANGLE_DOWN,
967 : /*line*/ 3,
968 : DirectionV::UP,
969 : /*panelRow*/ 7,
970 : /*panelColumn*/ 0,
971 : /*voice*/ 0,
972 48 : /*shortcut*/ String());
973 :
974 : // Belltree
975 32 : smDrumset->drum(84) = DrumInstrument(
976 : TConv::userName(DrumNum(84)),
977 : NoteHeadGroup::HEAD_TI,
978 : /*line*/ 2,
979 : DirectionV::UP,
980 : /*panelRow*/ 7,
981 : /*panelColumn*/ 1,
982 : /*voice*/ 0,
983 48 : /*shortcut*/ String());
984 :
985 : // Castanets
986 32 : smDrumset->drum(85) = DrumInstrument(
987 : TConv::userName(DrumNum(85)),
988 : NoteHeadGroup::HEAD_LA,
989 : /*line*/ 2,
990 : DirectionV::UP,
991 : /*panelRow*/ 7,
992 : /*panelColumn*/ 2,
993 : /*voice*/ 0,
994 48 : /*shortcut*/ String());
995 :
996 : // Mute Surdo
997 32 : smDrumset->drum(86) = DrumInstrument(
998 : TConv::userName(DrumNum(86)),
999 : NoteHeadGroup::HEAD_CUSTOM,
1000 : /*line*/ 4,
1001 : DirectionV::UP,
1002 : /*panelRow*/ 7,
1003 : /*panelColumn*/ 3,
1004 : /*voice*/ 0,
1005 48 : /*shortcut*/ String());
1006 :
1007 16 : smDrumset->drum(86).noteheads[static_cast<int>(NoteHeadType::HEAD_WHOLE)] = SymNames::symIdByName("noteheadSlashX");
1008 16 : smDrumset->drum(86).noteheads[static_cast<int>(NoteHeadType::HEAD_HALF)] = SymNames::symIdByName("noteheadSlashX");
1009 16 : smDrumset->drum(86).noteheads[static_cast<int>(NoteHeadType::HEAD_QUARTER)] = SymNames::symIdByName("noteheadSlashX");
1010 16 : smDrumset->drum(86).noteheads[static_cast<int>(NoteHeadType::HEAD_BREVIS)] = SymNames::symIdByName("noteheadSlashX");
1011 :
1012 : // Open Surdo
1013 32 : smDrumset->drum(87) = DrumInstrument(
1014 : TConv::userName(DrumNum(87)),
1015 : NoteHeadGroup::HEAD_SLASH,
1016 : /*line*/ 4,
1017 : DirectionV::UP,
1018 : /*panelRow*/ 7,
1019 : /*panelColumn*/ 4,
1020 : /*voice*/ 0,
1021 48 : /*shortcut*/ String());
1022 :
1023 : // END GENERATED CODE
1024 16 : }
1025 : }
|
