Attention: Here be dragons

This is the latest (unstable) version of this documentation, which may document features not available in or compatible with released stable versions of Godot.

Checking the stable version of the documentation...

InputEventMIDI

Eredita: InputEvent < Resource < RefCounted < Object

Rappresenta un messaggio MIDI proveniente da un dispositivo MIDI, ad esempio una tastiera musicale.

Descrizione

InputEventMIDI memorizza informazioni sui messaggi provenienti da dispositivi MIDI (Musical Instrument Digital Interface). Questi possono includere tastiere musicali, sintetizzatori e batterie elettroniche.

I messaggi MIDI possono essere ricevuti tramite un connettore MIDI a 5 pin o tramite USB. Se il tuo dispositivo supporta entrambi, assicurati di controllare le impostazioni nel dispositivo per vedere quale output sta utilizzando.

Come predefinito, Godot non rileva i dispositivi MIDI. È necessario prima chiamare OS.open_midi_inputs(). È possibile controllare quali dispositivi sono rilevati con OS.get_connected_midi_inputs() e chiudere la connessione con OS.close_midi_inputs().

func _ready():
    OS.open_midi_inputs()
    print(OS.get_connected_midi_inputs())

func _input(input_event):
    if input_event is InputEventMIDI:
        _print_midi_info(input_event)

func _print_midi_info(midi_event):
    print(midi_event)
    print("Canale", midi_event.channel)
    print("Messaggio ", midi_event.message)
    print("Tono", midi_event.pitch)
    print("Velocità ", midi_event.velocity)
    print("Strumento ", midi_event.instrument)
    print("Pressione ", midi_event.pressure)
    print("Numero controller: ", midi_event.controller_number)
    print("Valore controller: ", midi_event.controller_value)

public override void _Ready()
{
    OS.OpenMidiInputs();
    GD.Print(OS.GetConnectedMidiInputs());
}

public override void _Input(InputEvent inputEvent)
{
    if (inputEvent is InputEventMidi midiEvent)
    {
        PrintMIDIInfo(midiEvent);
    }
}

private void PrintMIDIInfo(InputEventMidi midiEvent)
{
    GD.Print(midiEvent);
    GD.Print($"Canale {midiEvent.Channel}");
    GD.Print($"Messaggio {midiEvent.Message}");
    GD.Print($"Tono {midiEvent.Pitch}");
    GD.Print($"Velocità {midiEvent.Velocity}");
    GD.Print($"Strumento {midiEvent.Instrument}");
    GD.Print($"Pressione {midiEvent.Pressure}");
    GD.Print($"Numero controller: {midiEvent.ControllerNumber}");
    GD.Print($"Valore controller: {midiEvent.ControllerValue}");
}

Nota: Godot non supporta l'output MIDI, quindi non c'è modo di emettere messaggi MIDI da Godot. Solo l'input MIDI è supportato.

Nota: Sulla piattaforma Web, l'utilizzo dell'input MIDI richiede prima l'autorizzazione del browser. Questa richiesta di autorizzazione viene eseguita quando viene chiamato OS.open_midi_inputs(). L'input MIDI non funzionerà finché l'utente non accetta la richiesta di autorizzazione.

Tutorial

Proprietà

int	channel	`0`
int	controller_number	`0`
int	controller_value	`0`
int	instrument	`0`
MIDIMessage	message	`0`
int	pitch	`0`
int	pressure	`0`
int	velocity	`0`

Descrizioni delle proprietà

int channel = 0 🔗

void set_channel(value: int)
int get_channel()

Il canale MIDI di questo messaggio, compreso tra 0 a 15. Il canale MIDI 9 è riservato agli strumenti a percussione.

int controller_number = 0 🔗

void set_controller_number(value: int)
int get_controller_number()

Il numero univoco del controller, se message è @GlobalScope.MIDI_MESSAGE_CONTROL_CHANGE, altrimenti è 0. Questo valore può essere utilizzato per identificare gli slider per volume, bilanciamento e panning, così come gli interruttori e i pedali sul dispositivo MIDI. Consultare la specifica generale MIDI per un piccolo elenco.

int controller_value = 0 🔗

void set_controller_value(value: int)
int get_controller_value()

Il valore applicato al controller. Se message è @GlobalScope.MIDI_MESSAGE_CONTROL_CHANGE, questo valore varia da 0 a 127, altrimenti è 0. Vedi anche controller_value.

int instrument = 0 🔗

void set_instrument(value: int)
int get_instrument()

Lo strumento (chiamato anche programma o preset) utilizzato in questo messaggio MIDI. Questo valore varia da 0 a 127.

Per vedere cosa significa ogni valore, fare riferimento all'elenco degli strumenti General MIDI. Tieni presente che l'elenco è sbagliato di 1 perché non inizia da 0. Un valore di 0 corrisponde al pianoforte a coda acustico.

MIDIMessage message = 0 🔗

void set_message(value: MIDIMessage)
MIDIMessage get_message()

Rappresenta il tipo di messaggio MIDI (vedi l'enumerazione MIDIMessage).

Per maggiori informazioni, consulta la tabella dell'elenco dei byte di stato dei messaggi MIDI.

int pitch = 0 🔗

void set_pitch(value: int)
int get_pitch()

Il l'indice di intonazione di questo messaggio MIDI. Questo valore varia da 0 a 127.

Su un pianoforte, il Do centrale è 60, seguito da un Do diesis (61), quindi un Re (62) e così via. Ogni ottava è divisa in offset di 12. Consulta la colonna "Numero di note MIDI" della tabella delle frequenze dei tasti del pianoforte per un elenco completo.

int pressure = 0 🔗

void set_pressure(value: int)
int get_pressure()

L'intensità del tasto premuto. Questo valore varia da 0 a 127.

Nota: Per molti dispositivi, questo valore è sempre 0. Altri dispositivi, come le tastiere musicali, potrebbero invece simulare la pressione modificando la loro velocity.

int velocity = 0 🔗

void set_velocity(value: int)
int get_velocity()

La velocità del messaggio MIDI. Questo valore varia da 0 a 127. Per una tastiera musicale, corrisponde alla velocità con cui è stato premuto il tasto e raramente supera 110 in pratica.

Nota: Alcuni dispositivi MIDI possono inviare un messaggio @GlobalScope.MIDI_MESSAGE_NOTE_ON con velocità 0 e aspettarsi che sia trattato come un messaggio @GlobalScope.MIDI_MESSAGE_NOTE_OFF. Se necessario, questo può essere gestito con poche righe di codice:

func _input(event):
    if event is InputEventMIDI:
        if event.message == MIDI_MESSAGE_NOTE_ON and event.velocity > 0:
            print("Note pressed!")