Nutzt Ihr Tools für Chords/Progressions? (Scaler & Co.)

[Solar Chrome]

Ich benutze Scaler um die richtigen Chords zu finden, kopiere sie dann aber als Midi in meine DAW um dann zu optimieren und dann am Anschluss am Hardwaresynth den finalen Sound zu designen. Davor habe ich aber Drums, Bassline usw. oft schon fertig.

Ich benutze auch nur die MIDI-Daten und arbeite in der DAW weiter. Das Plugin haue ich dann wieder raus.

 

[Summa]

Ich würde das nicht verkopft nennen, sondern strukturiert.

Man legt sich damit ja ein Stück weit gefühlsmäßig fest? Denn mit dem Wechsel der Tonleiter ändert sich auch ein Stück weit die emotionale Aussage eines Tracks. Ich sehe das mit der Musik eher wie bei einer Geschichte, die von gelegentlichen emotionale Wendungen profitieren kann bzw. interessanter wird und ich denke wenn selbst Grieg das macht darf ich das auch ohne mich mit ihm vergleichen zu wollen.

Bei Electro beginne ich immer mit den Beats, weil es bei Electro primär um Beats und Groove geht. Bei IDM / Lounge / Synthpop beginne ich mit einem Sound oder eben einer Chord-Progression, weil das für eine Art Songwriting ist.

Auch wenn ich z.B. bei einem Electro Track mit dem Rhythmus beginne, hab' ich mittlerweile ja schon eine Melodie, Bass Line und oft auch schon eine Folge von Akkorde im Kopf, irgendwas was sich beim erstellen der dazugehörigen Sounds schon entwickelt hat.

Manchmal suche ich die Chords auch auf der Gitarre. Da ich aber nur sehr leidlich Keyboard spielen kann, finde ich Scaler o.ä. nützlich.

Wirklich Keyboard spielen kann ich auch nicht, auch wenn sich meine Fähigkeiten über die Jahre hinweg ein klein wenig verbessert haben, spiele ich Melodien und Akkorde häufig in reduzierter Geschwindigkeit ein und muss am Ende trotzdem noch die Lage der Noten (abhängig vom Musikstil) ein wenig korrigieren, bis es so wie in meiner Vorstellung klingt. Für ein paar 3er Akkorde oder zum finden einer Melodie zum bereits vorhandenen Arrangement hats eigentlich immer irgendwie gereicht, selbst als mir die ersten Jahre (ca. 1984 - 86) der Kumpel mit dem ich damals Musik gemacht hab' mir sein altes Casio Minikeyboard geliehen hatte.

Ich könnte mir auch die Chords händisch zusammensuchen und dann die Progressions bauen.

Mittlerweile könnte man natürlich auch eine K.I. bitten Vorschläge für eine passende Akkord Reihe zu machen, bis sich das gesuchte Gefühl entsprechend einstellt. Bei mir ist es dann doch eher so dass ich die Akkorde schon kenne und dann nur noch auf dem Keyboard suchen muss.

Ein völliger "Freigeist" hat es da möglicherweise einfacher und produziert drauf los.

"Freigeist" war ironisch und im Vergleich zu deiner Vorgehensweise gemeint, gefühlt würde es mir bei meiner Arbeitsweise so vorkommen als müsste ich mir kompositorisch eine Hand auf dem Rücken festbinden.
Ganz klar ist jeder Weg der Richtige der für dich funktioniert, aber genauso wenig wie ich davon ausgehe dass es typisch ist dass einem die mögliche Melodien und Akkorde einfach so im Kopf erscheinen, würde ich auch nicht davon ausgehen dass für viele "Musiker" eine festen Tonlage ein Plus an Struktur bedeutet.

 

[einseinsnull]

finde ich Scaler o.ä. nützlich.

Der musikalische Prozess an sich läuft aber völlig intuitiv bei mir

das klingt ja schon erst mal in sich widersprüchlich, aber letztlich kann auch niemand beweisen, dass man nicht mit scaler o.ä. letztlich doch wieder auch intuitiv arbeitet, genau wie man es auch mit samplelibraries, preset patches, oder literatur zur korrekten mirkophonaufstellung macht - sobald man irgendwas daran ändert oder etwas daraus auswählt, wird es wieder langsam zu deinem eigenen ding.

 

[2bit]

Ich hab vor zwei Jahren ein experimentelles node.js-Tool geschrieben, das MIDI-Daten vom Keyboard abfängt, modifiziert und weiter an die DAW schickt.

Dabei wurde das 61-Tasten-Keyboard gesplittet: Die linke Hand hat den Akkord gegriffen und die rechte Hand bestimmte die Tonhöhe, quasi ein Zwitter aus den Konzepten hinter Gitarre und Piano. Die Inspiration dafür war "Vienna Instruments Pro", bei dem ein kleiner Teil am linken Rand der Klaviatur für die Auswahl der Artikulation reserviert ist.

Meine Idee war hier, dass ich für jede Kirchentonart nur noch eine einzige, und zwar die am leichtesten zu greifende, Tastenkombination nutzen kann und der Rest kommt von ganz alleine.

EDIT: ------------------------------------------

main.ts

//execute:
//npx tsx main.ts


//npm install config
//npm i --save-dev @types/config
import config from 'config';
const csvList : string = config.get('Init.externalFiles.csvList');

import {MyCSV} from './MyCSV';
// let csv = new MyCSV;
// csv.printCsvToConsole(csvList, "\t", "");


//async
import async from 'async';

let q = async.queue((task: any, callback:any)=>{
    console.log('taskname ' + task.name);
    setTimeout(()=>{callback();}, 10);
   
}, 1);


import midi from 'midi';
class MidiFilter
{
    public getTypeGroup(message : midi.MidiMessage) : string
    {
        let msgType : string = "";
        let typeGroup : number = -1;

        typeGroup = parseInt(message[0].toString(16).charAt(0),16);

        switch (typeGroup)
            {
                case 0x8: msgType = "note off"; break;
                case 0x9: msgType = "note on"; break;
                case 0xa: msgType = "polyphonic aftertouch"; break;
                case 0xb: msgType = "control / mode change"; break;
                case 0xc: msgType = "program change"; break;
                case 0xd: msgType = "channel aftertouch"; break;
                case 0xe: msgType = "pitch bend change"; break;
               
                default: msgType = "unknown"; break;
            }

            return msgType;
    }

    public getType(message : midi.MidiMessage): string
    {
        // see https://www.midi.org/specifications-old/item/table-2-expanded-messages-list-status-bytes
        // and https://www.midi.org/specifications-old/item/table-3-control-change-messages-data-bytes-2

        let msgType : string = "";
        let channel : number = -1;
        let typeGroup : number = -1;

        if(message[0] < 0xF0)
        {
            //midi status byte LEFT side:
            typeGroup = parseInt(message[0].toString(16).charAt(0),16);
           
            //midi status byte RIGHT side PLUS one:
            channel   = parseInt(message[0].toString(16).charAt(1),16)+1;

            switch (typeGroup)
            {
                case 0x8: msgType = "channel " + channel + " note off"; break;
                case 0x9: msgType = "channel " + channel + " note on"; break;
                case 0xa: msgType = "channel " + channel + " polyphonic aftertouch"; break;
                case 0xb: msgType = "channel " + channel + " control / mode change"; break;
                case 0xc: msgType = "channel " + channel + " program change"; break;
                case 0xd: msgType = "channel " + channel + " channel aftertouch"; break;
                case 0xe: msgType = "channel " + channel + " pitch bend change"; break;
               
                default: msgType = "unknown"; break;
            }
        }
        else
        {
            switch(message[0])
            {
                case 0xf0 : msgType = "system exclusive"; break;
                case 0xf1 : msgType = "MIDI time code qtr. frame"; break;
                case 0xf2 : msgType = "song position pointer"; break;
                case 0xf3 : msgType = "song select"; break;
                case 0xf4 : msgType = "undefined"; break;
                case 0xf5 : msgType = "undefined"; break;
                case 0xf6 : msgType = "tune request"; break;
                case 0xf7 : msgType = "end of sysex (EOX)"; break;
                case 0xf8 : msgType = "timing clock"; break;
                case 0xf9 : msgType = "undefined"; break;
                case 0xfa : msgType = "start"; break;
                case 0xfb : msgType = "continue"; break;
                case 0xfc : msgType = "stop"; break;
                case 0xfd : msgType = "undefined"; break;
                case 0xfe : msgType = "active sensing"; break;
                case 0xff : msgType = "system reset"; break;

                default: msgType = "unknown"; break;
            }
        }
        // console.log(msgType);
        return msgType;
    }


    public getNote (message : midi.MidiMessage) : string | undefined
    {
        let note : string[] = [];

        note[0] = 'C-1';
        note[1] = 'C#-1';
        note[2] = 'D-1';
        note[3] = 'D#-1';
        note[4] = 'E-1';
        note[5] = 'F-1';
        note[6] = 'F#-1';
        note[7] = 'G-1';
        note[8] = 'G#-1';
        note[9] = 'A-1';
        note[10] = 'A#-1';
        note[11] = 'B-1';
       
        note[12] = 'C-2';
        note[13] = 'C#-2';
        note[14] = 'D-2';
        note[15] = 'D#-2';
        note[16] = 'E-2';
        note[17] = 'F-2';
        note[18] = 'F#-2';
        note[19] = 'G-2';
        note[20] = 'G#-2';
        note[21] = 'A-2';
        note[22] = 'A#-22';
        note[23] = 'B-2';

        note[24] = 'C-3';
        note[25] = 'C#-3';
        note[26] = 'D-3';
        note[27] = 'D#-3';
        note[28] = 'E-3';
        note[29] = 'F-3';
        note[30] = 'F#-3';
        note[31] = 'G-3';
        note[32] = 'G#-3';
        note[33] = 'A-3';
        note[34] = 'A#-3';
        note[35] = 'B-3';

        note[36] = 'C-4';
        note[37] = 'C#-4';
        note[38] = 'D-4';
        note[39] = 'D#-4';
        note[40] = 'E-4';
        note[41] = 'F-4';
        note[42] = 'F#-4';
        note[43] = 'G-4';
        note[44] = 'G#-4';
        note[45] = 'A-4';
        note[46] = 'A#-4';
        note[47] = 'B-4';

        note[48] = 'C-5';
        note[49] = 'C#-5';
        note[50] = 'D-5';
        note[51] = 'D#-5';
        note[52] = 'E-5';
        note[53] = 'F-5';
        note[54] = 'F#-5';
        note[55] = 'G-5';
        note[56] = 'G#-5';
        note[57] = 'A-5';
        note[58] = 'A#-5';
        note[59] = 'B-5';
       
        note[60] = 'C-6';
        note[61] = 'C#-6';
        note[62] = 'D-6';
        note[63] = 'D#-6';
        note[64] = 'E-6';
        note[65] = 'F-6';
        note[66] = 'F#-6';
        note[67] = 'G-6';
        note[68] = 'G#-6';
        note[69] = 'A-6';
        note[70] = 'A#-6';
        note[71] = 'B-6';

        note[72] = 'C-7';
        note[73] = 'C#-7';
        note[74] = 'D-7';
        note[75] = 'D#-7';
        note[76] = 'E-7';
        note[77] = 'F-7';
        note[78] = 'F#-7';
        note[79] = 'G-7';
        note[80] = 'G#-7';
        note[81] = 'A-7';
        note[82] = 'A#-7';
        note[83] = 'B-7';

        note[84] = 'C-8';
        note[85] = 'C#-8';
        note[86] = 'D-8';
        note[87] = 'D#-8';
        note[88] = 'E-8';
        note[89] = 'F-8';
        note[90] = 'F#-8';
        note[91] = 'G-8';
        note[92] = 'G#-8';
        note[93] = 'A-8';
        note[94] = 'A#-8';
        note[95] = 'B-8';

        note[96] = 'C-9';
        note[97] = 'C#-9';
        note[98] = 'D-9';
        note[99] = 'D#-9';
        note[100] = 'E-9';
        note[101] = 'F-9';
        note[102] = 'F#-9';
        note[103] = 'G-9';
        note[104] = 'G#-9';
        note[105] = 'A-9';
        note[106] = 'A#-9';
        note[107] = 'B-9';

        if(this.getTypeGroup(message) == "note on" || this.getTypeGroup(message) == "note off")
        {
            return note[message[1]];  
        }
        else
        {
            return undefined;
        }
       
    }
}

class MidiComm
{
    private input = new midi.Input();
    private output = new midi.Output();
   
    private filter = new MidiFilter();
   
    constructor()
    {  
    }

    public inputMonitorOn(deviceName : string) : void
    {
        this.input.openPort(this.getInputPortByName(deviceName));
        this.input.on('message', (deltaTime : number, message : midi.MidiMessage) =>
            {
                console.log(`t: ${this.filter.getType(message)}\tm: ${message}\td: ${deltaTime}`);
            }
        );
    }

    private getInputPortByName(deviceName : string): number
    {
        let portNumber : number = -1;
        for(let i : number = 0; i < this.input.getPortCount(); i++ )
        {
            if(this.input.getPortName(i) == deviceName)
            {
                portNumber = i;
            }
        }
        return portNumber;
    }

    private chord : number [] = new Array();
    private interval : number []  = new Array();
    private intercecptedInterval : number[] = [36,48];
    private setInterval()
    {
        this.chord = this.chord.sort((a,b) => a-b);
        this.interval = this.chord;
        let tempInterval : number[] = new Array();
        for(let i: number=0;i<this.interval.length;i++)
        {
            // console.log(this.interval[i] - this.chord[0]);
            tempInterval.push(this.interval[i] - this.chord[0]);
        }
        // console.log(tempInterval);
        this.interval = tempInterval;
    }
    private intercept(msg: midi.MidiMessage) : void
    {
       
        if(msg[1] >= this.intercecptedInterval[0] && msg[1] <= this.intercecptedInterval[1])
        {
            if(this.filter.getTypeGroup(msg) == "note on")
            {
                this.chord.push(msg[1]);
               
            }
            if(this.filter.getTypeGroup(msg) == "note off")
            {
                this.chord = this.chord.filter(function(e) { return e !== msg[1] });
            }
            this.setInterval()
            console.log(this.interval);
        }
        else
        {  
            for(let i : number = 0; i < this.interval.length; i++)
            {
                // this.output.send([msg[0], msg[1] + this.interval[i] ,msg[2]]);
                q.push({name: this.filter.getNote([msg[0], msg[1] + this.interval[i] ,msg[2]])}, () => this.output.send([msg[0], msg[1] + this.interval[i] ,msg[2]]));
            }
            this.setInterval()
            console.log(this.interval);
        }
        // return msg;
    }

    public sendMidi ():void
    {
        this.input.openPort(this.getInputPortByName('The Laboratory'));
        this.output.openPort(this.getOutputPortByName('fromNode'));

        this.input.on('message', (deltaTime : number, message : midi.MidiMessage) =>
            {
                console.log(`t: ${this.filter.getType(message)}\tm: ${message}\td: ${deltaTime}`);
               
                this.intercept(message);
                // this.output.send(this.intercept(message));
                // this.output.closePort();
            }
        );
       
    }

    private getOutputPortByName(deviceName : string): number
    {
        let portNumber : number = -1;
        for(let i : number = 0; i < this.output.getPortCount(); i++ )
        {
            if(this.output.getPortName(i) == deviceName)
            {
                portNumber = i;
            }
        }
        return portNumber;
    }
}

// "toNode" & "fromNode" are virtual midi devices, managed by the windows-app "loopMIDI" written by Tobias Erichsen
// new MidiComm().inputMonitorOn('The Laboratory');
new MidiComm().sendMidi();

 

[Feinstrom]

Statt einander die Köppe einzuhauen darüber, wessen Akkordfindungsmethode nun die einzig heilsbringende ist, könnten wir doch mal Kurzbeschreibungen unserer persönlichen Methoden (die ja manchmal sehr speziell sind) posten und eventuell sogar mal mit einem "Hey, gute Idee, probier ich auch mal!" quittieren, oder?

Ich fang mal an (obwohl: ein paar Tipps gab's ja schon):

1.) Früher hab ich einfach Oszillatoren auf eine Quinte gestimmt und Zwei-Finger-Akkorde gespielt (vornehmlich große und kleine Terzen), das gab schöne Instant-Detroit-Akkorde.

2.) Und meine Trial-and-Error-Versuche, Akkordfolgen auf dem Omnichord zu finden, hatte ich glaub ich schon erwähnt.

3.) Eine etwas strange (zumindest spezielle), für mich aber oft zielführende Methode der Akkordfindung ist die Arbeit mit der Nintendo-DS-Software "Electroplankton", besonders mit dem Spiel "Hanenbow" (Disclaimer: Meine Musik ist weitestgehend Ambient/Soundscapes).
Hier hüpfen Kaulquappen auf einer Pflanze herum und springen zuletzt ins Wasser. Bei jedem Sprung wird ein Ton erzeugt. Wenn man mit dem ersten Ton anfängt und dann (halbwegs) gezielt die nächsten Töne durch Ausrichten der Blätter sucht und findet, kann man sich einen Akkord aufbauen und landet meistens woanders, als man hinwollte.
Auf diese Weise baue ich mir oft eine unrhythmische Quasi-Sequenz, aufbauend auf einem Akkord, die sich dann durch das ganze Stück zieht, aber von Fall zu Fall auch mal andere Basstöne oder Flächen obendrüber erlaubt. Und da man sich die jeweiligen Winkel der Blätter anzeigen lassen (und folglich aufschreiben) kann, ist das Ganze auch reproduzierbar.


Schöne Grüße
Bert

 

[einseinsnull]

Statt einander die Köppe einzuhauen darüber, wessen Akkordfindungsmethode nun die einzig heilsbringende ist, könnten wir doch mal Kurzbeschreibungen unserer persönlichen Methoden

damit unterminieren wir doch auch nur die unantastbarkeit der allheilmethoden scaler und improvisation. :)

bei mir ist z.b. das wie folgt:
ich benutze überhaupt nur dann und deswegen andere tools als "was ich schon weiß", "was ich im kopf habe" und "improvisation", um damit zu ganz anderen ergebnissen zu kommen.
(denn ich kann mich problemlos ans klavier setzen und in unter 1 stunde einen pop song schreiben - pop songs interessieren mich aber leider einen scheiß.)

am anfang steht dabei die idee zu einer form und/oder eines konzepts.
dann habe ich hunderte kleiner algorithmen am start, die bestehende daten analysieren, neue daten generieren oder beides miteinander verbinden können.
das ganze passiert in echtzeit, kann für automatische massenproduktion bei bedarf aber auch offline laufen.

für das "ostinato" (nach interner nomenklatur), also welche akkorde benutzt werden, gibt es eigentich nur 2 quellen: 1. die analyse bestehener stücke oder 2. bewusstes setzen durch mich selbst. das mit den "akkorden" ist bei mir also sozusagen das einzige, was ich selbst steuere (eine ausführliche begrüngung dafür lassen wir hier mal lieber weg)

die erzeugten daten sind dann (hoffentlich) bereits die komplette komposition, diese nehme ich dann in einem eigenformat auf und kann wo nötig mit gewissen einschränkungen das ganze aber auch als midi dateien exportieren.
das eigenformat kann ansonsten mit einem plug-in auch in einer DAW abgespielt werden (wo es natürlich MIDI ausgibt, die daten also damit kompatibel sein müssen)

 

[Tanja]

Das ist wie ein Taschenrechner - der hilft beim Rechnen, aber den Lösungsweg muss man schon allein entwickeln. Das macht ja niemanden zu einem schlechten Mathematiker.

Das ist ein schöner Vergleich . Ich finde es auch nicht verwerflich, Hilfsmittel einzusetzen. Jeder hat seine Vorlieben und Stärken/Schwächen. Mache verwenden auch nur Presets, weil sie mit ihren Synthesizern überfordert sind. Oder fertige Loops und Samples. Trotzdem kann gute Musik dabei herauskommen. Nur bei KI hört bei mir der Spaß auf.

Ich bin gestern über LUNA 2.0 von Universal Audio auf das Plugin ChordAXE gestoßen. Das macht einen guten Eindruck. Keine KI!

 

[Solar Chrome]

Statt einander die Köppe einzuhauen darüber, wessen Akkordfindungsmethode nun die einzig heilsbringende ist, könnten wir doch mal Kurzbeschreibungen unserer persönlichen Methoden (die ja manchmal sehr speziell sind) posten und eventuell sogar mal mit einem "Hey, gute Idee, probier ich auch mal!" quittieren, oder?

Ich denke, dass sich hier niemand die Köpfe einschlägt. Die einen sagen so, die anderen so.
Sowas kann durchaus zivilisiert ablaufen, ohne Streit.

Jeder hat natürlich seine Überzeugungen, Standpunkte und Arbeitsweisen. Es wäre ja fatal, wenn alle gleichgeschaltet der selben Meinungen wären, den selben Geschmack hätten und die gleichen Instrumente. Meine Erfahrung ist, dass man von konträren Haltungen eher etwas mitnehmen kann, als aus einer nickenden Runde. Natürlich gibt es auch ständig wiederkehrende und sehr unproduktive Gesprächsthemen: Röhren vs. Transistor, Software vs. Hardware o.ä. ...

Auffallend ist, dass es vor allem bei letzteren Themen gar nicht um Resultate geht, sondern um das Prinzip selbst. Ich habe noch nie einen Thread erlebt, wo man tatsächlich den Klang gegenüber gestellt hat. Wahrscheinlich würde das auch gar nicht immer gut ausgehen. Aber Musik ist ja auch etwas, bei dem der Entstehungsprozess wichtig ist und ich verstehe, wenn Leute Hilfsmittel ablehnen, die den Prozess vereinfachen oder beschleunigen. Im neuen BEAT-Magazin werden passenderweise solche Kompositionstools vorgestellt: Scaler, Riffer oder Instacomposer. Gerade auch im BEAT-Magazin lese ich allerdings sehr oft Schlagwörter wie "Schneller zum Hit", "schneller dies", "schneller jenes" ... damit kann ich tatsächlich gar nichts anfangen. Musikproduktion ist für mich kein Prozess, der nach ökonomischen Regeln optimiert werden muss!

Scaler ist für mich daher kein Tool zur Optimierung, sondern wie erwähnt eine interaktive Grifftabelle mit der ich komplexere Progressions entwickeln kann. Die Symbiose aus Sound und Melodieführung kann manchmal viel Zeit in Anspruch nehmen, da ich gern nach Dingen suche, die einerseits vertraut wirken, aber es nicht sind. Viele meiner Idee scheitern dann bereits am eigenen Anspruch.

Um aber auf die Frage zurückzukommen:
Für die Chordfindung und den Progressions nutze ich:

1.) Gitarre
2.) Masterkeyboard + Synth und Scaler

 

[dhinda]

Für die Chordfindung und den Progressions nutze ich:

1.) Gitarre

Diesen Ansatz finde ich sehr interessant. Ist bestimmt auch cool, wenn später mal eine reale Gitarre in einer Produktion mit einfliesst..

 

[Dagalos]

Es ist schon sehr viel tolle und auch neue Musik dadurch entstanden, dass die Protagonisten eigentlich keine Ahnung von Grundlagen hatten, oder die Regeln bewusst oder unbewusst gebrochen haben.

Sehr wichtiger Punkt bei mir, als ich so Anfang der 90er Anfing mit dem Musikmachen hatte ich, bis auf 2 Seiten Harmonielehre in so einem Keyboard Spiele Lehrbuch keine Ahnung. Ich war sowas von kreativer als heute. Jedes weitere Wissen hat sich nach einer Weile wie ein Korsett angefühlt. Das Problem ist, weißt du es einmal kannst du es nicht mehr nichtwissen.
Verkopft ans Musikmachen rangehen ist das schlimmste was passieren kann.

 

[Golden-Moon]

Jedes weitere Wissen hat sich nach einer Weile wie ein Korsett angefühlt.

Da bin ich ja froh keine Ahnung von der ganzen Theorie zu haben

 

[claudio]

Um aber auf die Frage zurückzukommen:
Für die Chordfindung und den Progressions nutze ich:

1.) Gitarre
2.) Masterkeyboard + Synth und Scaler

da bin ich ganz ähnlich unterwegs. Ich klimper'/klimperte zur Akkordfindung gerne auf meinem Rhodes und als ich noch ein Upright Klavier hatte auf diesem rum. Falls ich direkt Mididaten brauche bzw. aufnehmen will, klimpere ich auf dem Kurzweil.

Als ich während des Covid Lockdowns eine Gittenstimme für einen meiner Songs geschrieben hatte, dem (sehr guten) Gitarristen per Email sendete, antwortete dieser mit "kann man so nicht greifen". Da habe ich mir eine Klampfe gekauft und Akkorde auf der Gitte gelernt und geübt. So kann ich nun Gitarrenstimmen schreiben, welche auch spielbar sind.

 

[einseinsnull]

Verkopft ans Musikmachen rangehen ist das schlimmste was passieren kann.

und dennoch gibt es praktisch keine komponisten, die es nicht genau so tun. sei es akademisch, sei es autodidaktisch erlernt, aber ohne theorie wird es schwierig, und lebende beispiele wären noch zu finden.

 

[Speedy75]

Also bezüglich Theoriekenntnisse….da gibt es ja wohl sehr viele Abstufungen. Warum immer dieses Schwarz\Weiss?

Wenn beispielsweise jemand hören kann was passt, oder aufgrund vom Anschauen des Griffbretts beim Gegenüber etwas begleiten kann….dann kann er vielleicht kein Noten lesen oder Harmonielehre, aber hat doch Theoriekenntnisse im Sinne der Gehörbildung. Hören und spielen können was passt oder was man fühlt ist doch einer der wichtigsten Bausteine beim Musikmachen.

 

[Summa]

Klar. Dass du dir eine Richtigstellung gespart hast, zeugt von ...

Der Erkenntnis das weitere Diskussionen mit dir Zeitverschwendung sind.

 

[Sulitjelma]

Kürzlich habe ich für ein Ambient-Stück in Cubase die "Midi Modifier" mit diversen Random-Funktionen genutzt. Ich wollte eine lange "Melodie-Linie" im Stiel von früheren Brian Eno - Stücken erzeugen. Abgesehen davon, das das Finden der richtigen Einstellungen relativ lange gedauert hat, bin ich mit dem Ergebnis sehr zufrieden. Der Ambient-Effekt basiert hier gerade darauf, dass Melodie / Velocity etc. nicht vorhersehbar sind.

Kurze Melodien werde ich aber eher weiterhin eher einspielen/ einzeichnen ebenso wie die Akkorde. Hat mich aber gefreut dass ein so nützliches Tool schon in den Bordmitteln vorhanden ist.