godotengine
/
godot
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
godot/scene/audio/sample_player.cpp

705 lines
23 KiB
C++
Raw Blame History

/*************************************************************************/
/* sample_player.cpp */
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* https://godotengine.org */
/*************************************************************************/
/* Copyright (c) 2007-2018 Juan Linietsky, Ariel Manzur. */
/* Copyright (c) 2014-2018 Godot Engine contributors (cf. AUTHORS.md) */
/* */
/* Permission is hereby granted, free of charge, to any person obtaining */
/* a copy of this software and associated documentation files (the */
/* "Software"), to deal in the Software without restriction, including */
/* without limitation the rights to use, copy, modify, merge, publish, */
/* distribute, sublicense, and/or sell copies of the Software, and to */
/* permit persons to whom the Software is furnished to do so, subject to */
/* the following conditions: */
/* */
/* The above copyright notice and this permission notice shall be */
/* included in all copies or substantial portions of the Software. */
/* */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/*************************************************************************/
#include "sample_player.h"
#include "servers/audio_server.h"
bool SamplePlayer::_set(const StringName &p_name, const Variant &p_value) {
String name = p_name;
if (name == "play/play") {
if (library.is_valid()) {
String what = p_value;
if (what == "")
stop_all();
else
play(what);
played_back = what;
}
} else if (name == "config/samples")
set_sample_library(p_value);
else if (name == "config/polyphony")
set_polyphony(p_value);
else if (name.begins_with("default/")) {
String what = name.right(8);
if (what == "volume_db")
set_default_volume_db(p_value);
else if (what == "pitch_scale")
set_default_pitch_scale(p_value);
else if (what == "pan")
_default.pan = p_value;
else if (what == "depth")
_default.depth = p_value;
else if (what == "height")
_default.height = p_value;
else if (what == "filter/type")
_default.filter_type = FilterType(p_value.operator int());
else if (what == "filter/cutoff")
_default.filter_cutoff = p_value;
else if (what == "filter/resonance")
_default.filter_resonance = p_value;
else if (what == "filter/gain")
_default.filter_gain = p_value;
else if (what == "reverb_room")
_default.reverb_room = ReverbRoomType(p_value.operator int());
else if (what == "reverb_send")
_default.reverb_send = p_value;
else if (what == "chorus_send")
_default.chorus_send = p_value;
else
return false;
} else
return false;
return true;
}
bool SamplePlayer::_get(const StringName &p_name, Variant &r_ret) const {
String name = p_name;
if (name == "play/play") {
r_ret = played_back;
} else if (name == "config/polyphony") {
r_ret = get_polyphony();
} else if (name == "config/samples") {
r_ret = get_sample_library();
} else if (name.begins_with("default/")) {
String what = name.right(8);
if (what == "volume_db")
r_ret = get_default_volume_db();
else if (what == "pitch_scale")
r_ret = get_default_pitch_scale();
else if (what == "pan")
r_ret = _default.pan;
else if (what == "depth")
r_ret = _default.depth;
else if (what == "height")
r_ret = _default.height;
else if (what == "filter/type")
r_ret = _default.filter_type;
else if (what == "filter/cutoff")
r_ret = _default.filter_cutoff;
else if (what == "filter/resonance")
r_ret = _default.filter_resonance;
else if (what == "filter/gain")
r_ret = _default.filter_gain;
else if (what == "reverb_room")
r_ret = _default.reverb_room;
else if (what == "reverb_send")
r_ret = _default.reverb_send;
else if (what == "chorus_send")
r_ret = _default.chorus_send;
else
return false;
} else
return false;
return true;
}
void SamplePlayer::_get_property_list(List<PropertyInfo> *p_list) const {
String en = "";
if (library.is_valid()) {
List<StringName> samples;
Ref<SampleLibrary> ncl = library;
ncl->get_sample_list(&samples);
for (List<StringName>::Element *E = samples.front(); E; E = E->next()) {
en += ",";
en += E->get();
}
}
p_list->push_back(PropertyInfo(Variant::STRING, "play/play", PROPERTY_HINT_ENUM, en, PROPERTY_USAGE_EDITOR | PROPERTY_USAGE_ANIMATE_AS_TRIGGER));
p_list->push_back(PropertyInfo(Variant::INT, "config/polyphony", PROPERTY_HINT_RANGE, "1,256,1"));
p_list->push_back(PropertyInfo(Variant::OBJECT, "config/samples", PROPERTY_HINT_RESOURCE_TYPE, "SampleLibrary"));
p_list->push_back(PropertyInfo(Variant::REAL, "default/volume_db", PROPERTY_HINT_RANGE, "-80,24,0.01"));
p_list->push_back(PropertyInfo(Variant::REAL, "default/pitch_scale", PROPERTY_HINT_RANGE, "0.01,48,0.01"));
p_list->push_back(PropertyInfo(Variant::REAL, "default/pan", PROPERTY_HINT_RANGE, "-1,1,0.01"));
p_list->push_back(PropertyInfo(Variant::REAL, "default/depth", PROPERTY_HINT_RANGE, "-1,1,0.01"));
p_list->push_back(PropertyInfo(Variant::REAL, "default/height", PROPERTY_HINT_RANGE, "-1,1,0.01"));
p_list->push_back(PropertyInfo(Variant::INT, "default/filter/type", PROPERTY_HINT_ENUM, "Disabled,Lowpass,Bandpass,Highpass,Notch,Peak,BandLimit,LowShelf,HighShelf"));
p_list->push_back(PropertyInfo(Variant::REAL, "default/filter/cutoff", PROPERTY_HINT_RANGE, "20,16384.0,0.01"));
p_list->push_back(PropertyInfo(Variant::REAL, "default/filter/resonance", PROPERTY_HINT_RANGE, "0,4,0.01"));
p_list->push_back(PropertyInfo(Variant::REAL, "default/filter/gain", PROPERTY_HINT_RANGE, "0,2,0.01"));
p_list->push_back(PropertyInfo(Variant::INT, "default/reverb_room", PROPERTY_HINT_ENUM, "Small,Medium,Large,Hall"));
p_list->push_back(PropertyInfo(Variant::REAL, "default/reverb_send", PROPERTY_HINT_RANGE, "0,1,0.01"));
p_list->push_back(PropertyInfo(Variant::REAL, "default/chorus_send", PROPERTY_HINT_RANGE, "0,1,0.01"));
}
SamplePlayer::Voice::Voice() {
voice = AudioServer::get_singleton()->voice_create();
clear();
}
void SamplePlayer::Voice::clear() {
check = 0;
mix_rate = 44100;
volume = 1;
pan = 0;
pan_depth = 0;
pan_height = 0;
filter_type = FILTER_NONE;
filter_cutoff = 0;
filter_resonance = 0;
chorus_send = 0;
reverb_room = REVERB_HALL;
reverb_send = 0;
active = false;
priority = 0;
}
SamplePlayer::Voice::~Voice() {
AudioServer::get_singleton()->free(voice);
}
void SamplePlayer::set_polyphony(int p_voice_count) {
ERR_FAIL_COND(p_voice_count < 1 || p_voice_count > 0xFFFE);
voices.resize(p_voice_count);
}
int SamplePlayer::get_polyphony() const {
return voices.size();
}
SamplePlayer::VoiceID SamplePlayer::play(const String &p_name, bool unique) {
if (library.is_null())
return INVALID_VOICE_ID;
ERR_FAIL_COND_V(!library->has_sample(p_name), INVALID_VOICE_ID);
Ref<Sample> sample = library->get_sample(p_name);
float vol_change = library->sample_get_volume_db(p_name);
float pitch_change = library->sample_get_pitch_scale(p_name);
int priority = library->sample_get_priority(p_name);
last_check++;
const int num_voices = voices.size();
bool free_found = false;
int lowest_priority_voice = -1;
int lowest_priority = 0x7FFFFFFF;
for (int i = 0; i < num_voices; i++) {
const int candidate = (last_id + 1 + i) % num_voices;
const Voice &v = voices[candidate];
if (!(v.active && AudioServer::get_singleton()->voice_is_active(v.voice))) {
free_found = true;
last_id = candidate;
break;
}
if (v.priority <= lowest_priority) {
lowest_priority = v.priority;
lowest_priority_voice = candidate;
}
}
if (!free_found) {
if (lowest_priority > priority) {
return INVALID_VOICE_ID;
} else {
last_id = lowest_priority_voice;
}
}
Voice &v = voices[last_id];
v.clear();
v.priority = priority;
v.mix_rate = sample->get_mix_rate() * (_default.pitch_scale * pitch_change);
v.sample_mix_rate = sample->get_mix_rate();
v.check = last_check;
v.volume = Math::db2linear(_default.volume_db + vol_change);
v.pan = _default.pan;
v.pan_depth = _default.depth;
v.pan_height = _default.height;
v.filter_type = _default.filter_type;
v.filter_cutoff = _default.filter_cutoff;
v.filter_resonance = _default.filter_resonance;
v.filter_gain = _default.filter_gain;
v.chorus_send = _default.chorus_send;
v.reverb_room = _default.reverb_room;
v.reverb_send = _default.reverb_send;
AudioServer::get_singleton()->voice_play(v.voice, sample->get_rid());
AudioServer::get_singleton()->voice_set_mix_rate(v.voice, v.mix_rate);
AudioServer::get_singleton()->voice_set_volume(v.voice, v.volume);
AudioServer::get_singleton()->voice_set_pan(v.voice, v.pan, v.pan_depth, v.pan_height);
AudioServer::get_singleton()->voice_set_filter(v.voice, (AudioServer::FilterType)v.filter_type, v.filter_cutoff, v.filter_resonance, v.filter_gain);
AudioServer::get_singleton()->voice_set_chorus(v.voice, v.chorus_send);
AudioServer::get_singleton()->voice_set_reverb(v.voice, (AudioServer::ReverbRoomType)v.reverb_room, v.reverb_send);
v.active = true;
if (unique) {
for (int i = 0; i < voices.size(); i++) {
if (!voices[i].active || uint32_t(i) == last_id)
continue;
AudioServer::get_singleton()->voice_stop(voices[i].voice);
voices[i].clear();
}
}
return last_id | (last_check << 16);
}
void SamplePlayer::stop_all() {
for (int i = 0; i < voices.size(); i++) {
if (!voices[i].active)
continue;
AudioServer::get_singleton()->voice_stop(voices[i].voice);
voices[i].clear();
}
}
#define _GET_VOICE \
uint32_t voice = p_voice & 0xFFFF; \
ERR_FAIL_COND(voice >= (uint32_t)voices.size()); \
Voice &v = voices[voice]; \
if (v.check != uint32_t(p_voice >> 16)) \
return; \
ERR_FAIL_COND(!v.active);
void SamplePlayer::stop(VoiceID p_voice) {
_GET_VOICE
AudioServer::get_singleton()->voice_stop(v.voice);
v.active = false;
}
void SamplePlayer::set_mix_rate(VoiceID p_voice, int p_mix_rate) {
_GET_VOICE
v.mix_rate = p_mix_rate;
AudioServer::get_singleton()->voice_set_mix_rate(v.voice, v.mix_rate);
}
void SamplePlayer::set_pitch_scale(VoiceID p_voice, float p_pitch_scale) {
_GET_VOICE
v.mix_rate = v.sample_mix_rate * p_pitch_scale;
AudioServer::get_singleton()->voice_set_mix_rate(v.voice, v.mix_rate);
}
void SamplePlayer::set_volume(VoiceID p_voice, float p_volume) {
_GET_VOICE
v.volume = p_volume;
AudioServer::get_singleton()->voice_set_volume(v.voice, v.volume);
}
void SamplePlayer::set_volume_db(VoiceID p_voice, float p_db) {
//@TODO handle 0 volume as -80db or something
_GET_VOICE
v.volume = Math::db2linear(p_db);
AudioServer::get_singleton()->voice_set_volume(v.voice, v.volume);
}
void SamplePlayer::set_pan(VoiceID p_voice, float p_pan, float p_pan_depth, float p_pan_height) {
_GET_VOICE
v.pan = p_pan;
v.pan_depth = p_pan_depth;
v.pan_height = p_pan_height;
AudioServer::get_singleton()->voice_set_pan(v.voice, v.pan, v.pan_depth, v.pan_height);
}
void SamplePlayer::set_filter(VoiceID p_voice, FilterType p_filter, float p_cutoff, float p_resonance, float p_gain) {
_GET_VOICE
v.filter_type = p_filter;
v.filter_cutoff = p_cutoff;
v.filter_resonance = p_resonance;
v.filter_gain = p_gain;
AudioServer::get_singleton()->voice_set_filter(v.voice, (AudioServer::FilterType)p_filter, p_cutoff, p_resonance);
}
void SamplePlayer::set_chorus(VoiceID p_voice, float p_send) {
_GET_VOICE
v.chorus_send = p_send;
AudioServer::get_singleton()->voice_set_chorus(v.voice, p_send);
}
void SamplePlayer::set_reverb(VoiceID p_voice, ReverbRoomType p_room, float p_send) {
_GET_VOICE
v.reverb_room = p_room;
v.reverb_send = p_send;
AudioServer::get_singleton()->voice_set_reverb(v.voice, (AudioServer::ReverbRoomType)p_room, p_send);
}
#define _GET_VOICE_V(m_ret) \
uint32_t voice = p_voice & 0xFFFF; \
ERR_FAIL_COND_V(voice >= (uint32_t)voices.size(), m_ret); \
const Voice &v = voices[voice]; \
if (v.check != (p_voice >> 16)) \
return m_ret; \
ERR_FAIL_COND_V(!v.active, m_ret);
int SamplePlayer::get_mix_rate(VoiceID p_voice) const {
_GET_VOICE_V(0);
return v.mix_rate;
}
float SamplePlayer::get_pitch_scale(VoiceID p_voice) const {
_GET_VOICE_V(0);
return v.sample_mix_rate / (float)v.mix_rate;
}
float SamplePlayer::get_volume(VoiceID p_voice) const {
_GET_VOICE_V(0);
return v.volume;
}
float SamplePlayer::get_volume_db(VoiceID p_voice) const {
_GET_VOICE_V(0);
return Math::linear2db(v.volume);
}
float SamplePlayer::get_pan(VoiceID p_voice) const {
_GET_VOICE_V(0);
return v.pan;
}
float SamplePlayer::get_pan_depth(VoiceID p_voice) const {
_GET_VOICE_V(0);
return v.pan_depth;
}
float SamplePlayer::get_pan_height(VoiceID p_voice) const {
_GET_VOICE_V(0);
return v.pan_height;
}
SamplePlayer::FilterType SamplePlayer::get_filter_type(VoiceID p_voice) const {
_GET_VOICE_V(FILTER_NONE);
return v.filter_type;
}
float SamplePlayer::get_filter_cutoff(VoiceID p_voice) const {
_GET_VOICE_V(0);
return v.filter_cutoff;
}
float SamplePlayer::get_filter_resonance(VoiceID p_voice) const {
_GET_VOICE_V(0);
return v.filter_resonance;
}
float SamplePlayer::get_filter_gain(VoiceID p_voice) const {
_GET_VOICE_V(0);
return v.filter_gain;
}
float SamplePlayer::get_chorus(VoiceID p_voice) const {
_GET_VOICE_V(0);
return v.chorus_send;
}
SamplePlayer::ReverbRoomType SamplePlayer::get_reverb_room(VoiceID p_voice) const {
_GET_VOICE_V(REVERB_SMALL);
return v.reverb_room;
}
float SamplePlayer::get_reverb(VoiceID p_voice) const {
_GET_VOICE_V(0);
return v.reverb_send;
}
bool SamplePlayer::is_voice_active(VoiceID p_voice) const {
_GET_VOICE_V(false);
return v.active && AudioServer::get_singleton()->voice_is_active(v.voice);
}
bool SamplePlayer::is_active() const {
for (int i = 0; i < voices.size(); i++) {
if (voices[i].active && AudioServer::get_singleton()->voice_is_active(voices[i].voice))
return true;
}
return false;
}
void SamplePlayer::set_sample_library(const Ref<SampleLibrary> &p_library) {
library = p_library;
_change_notify();
}
Ref<SampleLibrary> SamplePlayer::get_sample_library() const {
return library;
}
void SamplePlayer::set_default_pitch_scale(float p_pitch_scale) {
_default.pitch_scale = p_pitch_scale;
}
void SamplePlayer::set_default_volume(float p_volume) {
_default.volume_db = Math::linear2db(p_volume);
}
void SamplePlayer::set_default_volume_db(float p_db) {
_default.volume_db = p_db;
}
void SamplePlayer::set_default_pan(float p_pan, float p_pan_depth, float p_pan_height) {
_default.pan = p_pan;
_default.depth = p_pan_depth;
_default.height = p_pan_height;
}
void SamplePlayer::set_default_filter(FilterType p_filter, float p_cutoff, float p_resonance, float p_gain) {
_default.filter_type = p_filter;
_default.filter_cutoff = p_cutoff;
_default.filter_resonance = p_resonance;
_default.filter_gain = p_gain;
}
void SamplePlayer::set_default_chorus(float p_send) {
_default.chorus_send = p_send;
}
void SamplePlayer::set_default_reverb(ReverbRoomType p_room, float p_send) {
_default.reverb_room = p_room;
_default.reverb_send = p_send;
}
float SamplePlayer::get_default_volume() const {
return Math::db2linear(_default.volume_db);
}
float SamplePlayer::get_default_volume_db() const {
return _default.volume_db;
}
float SamplePlayer::get_default_pitch_scale() const {
return _default.pitch_scale;
}
float SamplePlayer::get_default_pan() const {
return _default.pan;
}
float SamplePlayer::get_default_pan_depth() const {
return _default.depth;
}
float SamplePlayer::get_default_pan_height() const {
return _default.height;
}
SamplePlayer::FilterType SamplePlayer::get_default_filter_type() const {
return _default.filter_type;
}
float SamplePlayer::get_default_filter_cutoff() const {
return _default.filter_cutoff;
}
float SamplePlayer::get_default_filter_resonance() const {
return _default.filter_resonance;
}
float SamplePlayer::get_default_filter_gain() const {
return _default.filter_gain;
}
float SamplePlayer::get_default_chorus() const {
return _default.chorus_send;
}
SamplePlayer::ReverbRoomType SamplePlayer::get_default_reverb_room() const {
return _default.reverb_room;
}
float SamplePlayer::get_default_reverb() const {
return _default.reverb_send;
}
String SamplePlayer::get_configuration_warning() const {
if (library.is_null()) {
return TTR("A SampleLibrary resource must be created or set in the 'samples' property in order for SamplePlayer to play sound.");
}
return String();
}
void SamplePlayer::_bind_methods() {
ObjectTypeDB::bind_method(_MD("set_sample_library", "library:SampleLibrary"), &SamplePlayer::set_sample_library);
ObjectTypeDB::bind_method(_MD("get_sample_library:SampleLibrary"), &SamplePlayer::get_sample_library);
ObjectTypeDB::bind_method(_MD("set_polyphony", "max_voices"), &SamplePlayer::set_polyphony);
ObjectTypeDB::bind_method(_MD("get_polyphony"), &SamplePlayer::get_polyphony);
ObjectTypeDB::bind_method(_MD("play", "name", "unique"), &SamplePlayer::play, DEFVAL(false));
ObjectTypeDB::bind_method(_MD("stop", "voice"), &SamplePlayer::stop);
ObjectTypeDB::bind_method(_MD("stop_all"), &SamplePlayer::stop_all);
ObjectTypeDB::bind_method(_MD("set_mix_rate", "voice", "hz"), &SamplePlayer::set_mix_rate);
ObjectTypeDB::bind_method(_MD("set_pitch_scale", "voice", "ratio"), &SamplePlayer::set_pitch_scale);
ObjectTypeDB::bind_method(_MD("set_volume", "voice", "volume"), &SamplePlayer::set_volume);
ObjectTypeDB::bind_method(_MD("set_volume_db", "voice", "db"), &SamplePlayer::set_volume_db);
ObjectTypeDB::bind_method(_MD("set_pan", "voice", "pan", "depth", "height"), &SamplePlayer::set_pan, DEFVAL(0), DEFVAL(0));
ObjectTypeDB::bind_method(_MD("set_filter", "voice", "type", "cutoff_hz", "resonance", "gain"), &SamplePlayer::set_filter, DEFVAL(0));
ObjectTypeDB::bind_method(_MD("set_chorus", "voice", "send"), &SamplePlayer::set_chorus);
ObjectTypeDB::bind_method(_MD("set_reverb", "voice", "room_type", "send"), &SamplePlayer::set_reverb);
ObjectTypeDB::bind_method(_MD("get_mix_rate", "voice"), &SamplePlayer::get_mix_rate);
ObjectTypeDB::bind_method(_MD("get_pitch_scale", "voice"), &SamplePlayer::get_pitch_scale);
ObjectTypeDB::bind_method(_MD("get_volume", "voice"), &SamplePlayer::get_volume);
ObjectTypeDB::bind_method(_MD("get_volume_db", "voice"), &SamplePlayer::get_volume_db);
ObjectTypeDB::bind_method(_MD("get_pan", "voice"), &SamplePlayer::get_pan);
ObjectTypeDB::bind_method(_MD("get_pan_depth", "voice"), &SamplePlayer::get_pan_depth);
ObjectTypeDB::bind_method(_MD("get_pan_height", "voice"), &SamplePlayer::get_pan_height);
ObjectTypeDB::bind_method(_MD("get_filter_type", "voice"), &SamplePlayer::get_filter_type);
ObjectTypeDB::bind_method(_MD("get_filter_cutoff", "voice"), &SamplePlayer::get_filter_cutoff);
ObjectTypeDB::bind_method(_MD("get_filter_resonance", "voice"), &SamplePlayer::get_filter_resonance);
ObjectTypeDB::bind_method(_MD("get_filter_gain", "voice"), &SamplePlayer::get_filter_gain);
ObjectTypeDB::bind_method(_MD("get_chorus", "voice"), &SamplePlayer::get_chorus);
ObjectTypeDB::bind_method(_MD("get_reverb_room", "voice"), &SamplePlayer::get_reverb_room);
ObjectTypeDB::bind_method(_MD("get_reverb", "voice"), &SamplePlayer::get_reverb);
ObjectTypeDB::bind_method(_MD("set_default_pitch_scale", "ratio"), &SamplePlayer::set_default_pitch_scale);
ObjectTypeDB::bind_method(_MD("set_default_volume", "volume"), &SamplePlayer::set_default_volume);
ObjectTypeDB::bind_method(_MD("set_default_volume_db", "db"), &SamplePlayer::set_default_volume_db);
ObjectTypeDB::bind_method(_MD("set_default_pan", "pan", "depth", "height"), &SamplePlayer::set_default_pan, DEFVAL(0), DEFVAL(0));
ObjectTypeDB::bind_method(_MD("set_default_filter", "type", "cutoff_hz", "resonance", "gain"), &SamplePlayer::set_default_filter, DEFVAL(0));
ObjectTypeDB::bind_method(_MD("set_default_chorus", "send"), &SamplePlayer::set_default_chorus);
ObjectTypeDB::bind_method(_MD("set_default_reverb", "room_type", "send"), &SamplePlayer::set_default_reverb);
ObjectTypeDB::bind_method(_MD("get_default_pitch_scale"), &SamplePlayer::get_default_pitch_scale);
ObjectTypeDB::bind_method(_MD("get_default_volume"), &SamplePlayer::get_default_volume);
ObjectTypeDB::bind_method(_MD("get_default_volume_db"), &SamplePlayer::get_default_volume_db);
ObjectTypeDB::bind_method(_MD("get_default_pan"), &SamplePlayer::get_default_pan);
ObjectTypeDB::bind_method(_MD("get_default_pan_depth"), &SamplePlayer::get_default_pan_depth);
ObjectTypeDB::bind_method(_MD("get_default_pan_height"), &SamplePlayer::get_default_pan_height);
ObjectTypeDB::bind_method(_MD("get_default_filter_type"), &SamplePlayer::get_default_filter_type);
ObjectTypeDB::bind_method(_MD("get_default_filter_cutoff"), &SamplePlayer::get_default_filter_cutoff);
ObjectTypeDB::bind_method(_MD("get_default_filter_resonance"), &SamplePlayer::get_default_filter_resonance);
ObjectTypeDB::bind_method(_MD("get_default_filter_gain"), &SamplePlayer::get_default_filter_gain);
ObjectTypeDB::bind_method(_MD("get_default_chorus"), &SamplePlayer::get_default_chorus);
ObjectTypeDB::bind_method(_MD("get_default_reverb_room"), &SamplePlayer::get_default_reverb_room);
ObjectTypeDB::bind_method(_MD("get_default_reverb"), &SamplePlayer::get_default_reverb);
ObjectTypeDB::bind_method(_MD("is_active"), &SamplePlayer::is_active);
ObjectTypeDB::bind_method(_MD("is_voice_active", "voice"), &SamplePlayer::is_voice_active);
BIND_CONSTANT(FILTER_NONE);
BIND_CONSTANT(FILTER_LOWPASS);
BIND_CONSTANT(FILTER_BANDPASS);
BIND_CONSTANT(FILTER_HIPASS);
BIND_CONSTANT(FILTER_NOTCH);
BIND_CONSTANT(FILTER_PEAK);
BIND_CONSTANT(FILTER_BANDLIMIT); ///< cutoff is LP resonace is HP
BIND_CONSTANT(FILTER_LOW_SHELF);
BIND_CONSTANT(FILTER_HIGH_SHELF);
BIND_CONSTANT(REVERB_SMALL);
BIND_CONSTANT(REVERB_MEDIUM);
BIND_CONSTANT(REVERB_LARGE);
BIND_CONSTANT(REVERB_HALL);
BIND_CONSTANT(INVALID_VOICE_ID);
}
SamplePlayer::SamplePlayer() {
voices.resize(1);
_default.pitch_scale = 1;
_default.volume_db = 0;
_default.pan = 0;
_default.depth = 0;
_default.height = 0;
_default.filter_type = FILTER_NONE;
_default.filter_cutoff = 5000;
_default.filter_resonance = 1;
_default.filter_gain = 1;
_default.chorus_send = 0;
_default.reverb_room = REVERB_LARGE;
_default.reverb_send = 0;
last_id = 0;
last_check = 0;
}
SamplePlayer::~SamplePlayer() {
}
Reference in New Issue View Git Blame Copy Permalink