godotengine
/
godot
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
godot/drivers/chibi/event_stream_chibi.cpp

860 lines
20 KiB
C++
Raw Normal View History

GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
/*************************************************************************/
/* event_stream_chibi.cpp */
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* http://www.godotengine.org */
/*************************************************************************/
/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */
/* */
/* 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 "event_stream_chibi.h"
#include "cp_loader_it.h"
#include "cp_loader_xm.h"
#include "cp_loader_s3m.h"
#include "cp_loader_mod.h"
static CPSampleManagerImpl *sample_manager;
static ResourceFormatLoaderChibi *resource_loader;
CPSample_ID CPSampleManagerImpl::create(bool p_16bits,bool p_stereo,int32_t p_len) {
AudioServer::SampleFormat sf=p_16bits?AudioServer::SAMPLE_FORMAT_PCM16:AudioServer::SAMPLE_FORMAT_PCM8;
SampleData *sd = memnew( SampleData );
sd->rid = AudioServer::get_singleton()->sample_create(sf,p_stereo,p_len);
sd->stereo=p_stereo;
sd->len=p_len;
sd->is16=p_16bits;
sd->mixfreq=44100;
sd->loop_begin=0;
sd->loop_end=0;
sd->loop_type=CP_LOOP_NONE;
sd->locks=0;
#ifdef DEBUG_ENABLED
valid.insert(sd);
#endif
CPSample_ID sid;
sid._private=sd;
return sid;
}
void CPSampleManagerImpl::recreate(CPSample_ID p_id,bool p_16bits,bool p_stereo,int32_t p_len){
AudioServer::SampleFormat sf=p_16bits?AudioServer::SAMPLE_FORMAT_PCM16:AudioServer::SAMPLE_FORMAT_PCM8;
SampleData *sd=_getsd(p_id);
#ifdef DEBUG_ENABLED
ERR_FAIL_COND(!valid.has(sd));
#endif
AudioServer::get_singleton()->free(sd->rid);
sd->rid = AudioServer::get_singleton()->sample_create(sf,p_stereo,p_len);
sd->stereo=p_stereo;
sd->len=p_len;
sd->is16=p_16bits;
sd->mixfreq=44100;
sd->loop_begin=0;
sd->loop_end=0;
sd->loop_type=CP_LOOP_NONE;
}
void CPSampleManagerImpl::destroy(CPSample_ID p_id){
SampleData *sd=_getsd(p_id);
#ifdef DEBUG_ENABLED
ERR_FAIL_COND(!valid.has(sd));
valid.erase(sd);
#endif
AudioServer::get_singleton()->free(sd->rid);
memdelete(sd);
}
bool CPSampleManagerImpl::check(CPSample_ID p_id){
SampleData *sd=_getsd(p_id);
#ifdef DEBUG_ENABLED
return valid.has(sd);
#else
return _getsd(p_id)!=NULL;
#endif
}
void CPSampleManagerImpl::set_c5_freq(CPSample_ID p_id,int32_t p_freq){
SampleData *sd=_getsd(p_id);
#ifdef DEBUG_ENABLED
ERR_FAIL_COND(!valid.has(sd));
#endif
sd->mixfreq=p_freq;
AudioServer::get_singleton()->sample_set_mix_rate(sd->rid,p_freq);
}
void CPSampleManagerImpl::set_loop_begin(CPSample_ID p_id,int32_t p_begin){
SampleData *sd=_getsd(p_id);
#ifdef DEBUG_ENABLED
ERR_FAIL_COND(!valid.has(sd));
#endif
sd->loop_begin=p_begin;
AudioServer::get_singleton()->sample_set_loop_begin(sd->rid,p_begin);
}
void CPSampleManagerImpl::set_loop_end(CPSample_ID p_id,int32_t p_end){
SampleData *sd=_getsd(p_id);
#ifdef DEBUG_ENABLED
ERR_FAIL_COND(!valid.has(sd));
#endif
sd->loop_end=p_end;
AudioServer::get_singleton()->sample_set_loop_end(sd->rid,p_end);
}
void CPSampleManagerImpl::set_loop_type(CPSample_ID p_id,CPSample_Loop_Type p_type){
SampleData *sd=_getsd(p_id);
#ifdef DEBUG_ENABLED
ERR_FAIL_COND(!valid.has(sd));
#endif
sd->loop_type=p_type;
AudioServer::get_singleton()->sample_set_loop_format(sd->rid,AudioServer::SampleLoopFormat(p_type));
}
void CPSampleManagerImpl::set_chunk(CPSample_ID p_id,int32_t p_index,void *p_data,int p_data_len){
SampleData *sd=_getsd(p_id);
#ifdef DEBUG_ENABLED
ERR_FAIL_COND(!valid.has(sd));
#endif
ERR_FAIL();
}
int32_t CPSampleManagerImpl::get_loop_begin(CPSample_ID p_id){
SampleData *sd=_getsd(p_id);
#ifdef DEBUG_ENABLED
ERR_FAIL_COND_V(!valid.has(sd),0);
#endif
return sd->loop_begin;
}
int32_t CPSampleManagerImpl::get_loop_end(CPSample_ID p_id){
SampleData *sd=_getsd(p_id);
#ifdef DEBUG_ENABLED
ERR_FAIL_COND_V(!valid.has(sd),0);
#endif
return sd->loop_end;
}
CPSample_Loop_Type CPSampleManagerImpl::get_loop_type(CPSample_ID p_id){
SampleData *sd=_getsd(p_id);
#ifdef DEBUG_ENABLED
ERR_FAIL_COND_V(!valid.has(sd),CP_LOOP_NONE);
#endif
return sd->loop_type;
}
int32_t CPSampleManagerImpl::get_c5_freq(CPSample_ID p_id){
SampleData *sd=_getsd(p_id);
#ifdef DEBUG_ENABLED
ERR_FAIL_COND_V(!valid.has(sd),0);
#endif
return sd->mixfreq;
}
int32_t CPSampleManagerImpl::get_size(CPSample_ID p_id){
SampleData *sd=_getsd(p_id);
#ifdef DEBUG_ENABLED
ERR_FAIL_COND_V(!valid.has(sd),0);
#endif
return sd->len;
}
bool CPSampleManagerImpl::is_16bits(CPSample_ID p_id){
SampleData *sd=_getsd(p_id);
#ifdef DEBUG_ENABLED
ERR_FAIL_COND_V(!valid.has(sd),false);
#endif
return sd->is16;
}
bool CPSampleManagerImpl::is_stereo(CPSample_ID p_id){
SampleData *sd=_getsd(p_id);
#ifdef DEBUG_ENABLED
ERR_FAIL_COND_V(!valid.has(sd),false);
#endif
return sd->stereo;
}
bool CPSampleManagerImpl::lock_data(CPSample_ID p_id){
SampleData *sd=_getsd(p_id);
#ifdef DEBUG_ENABLED
ERR_FAIL_COND_V(!valid.has(sd),0);
#endif
sd->locks++;
if (sd->locks==1) {
sd->lock=AudioServer::get_singleton()->sample_get_data(sd->rid);
sd->w=sd->lock.write();
}
return true;
}
void *CPSampleManagerImpl::get_data(CPSample_ID p_id){
SampleData *sd=_getsd(p_id);
#ifdef DEBUG_ENABLED
ERR_FAIL_COND_V(!valid.has(sd),0);
#endif
ERR_FAIL_COND_V(sd->locks==0,0);
return sd->w.ptr();
}
int16_t CPSampleManagerImpl::get_data(CPSample_ID p_id, int p_sample, int p_channel){
SampleData *sd=_getsd(p_id);
#ifdef DEBUG_ENABLED
ERR_FAIL_COND_V(!valid.has(sd),0);
#endif
ERR_FAIL_V(0);
lock_data(p_id);
int sofs = sd->stereo ? 2:1;
uint16_t v=0;
if (sd->is16) {
int16_t *p=(int16_t*)sd->w.ptr();
v=p[p_sample*sofs+p_channel];
} else {
int8_t *p=(int8_t*)sd->w.ptr();
v=p[p_sample*sofs+p_channel];
}
unlock_data(p_id);
return v;
}
void CPSampleManagerImpl::set_data(CPSample_ID p_id, int p_sample, int16_t p_data,int p_channel){
SampleData *sd=_getsd(p_id);
#ifdef DEBUG_ENABLED
ERR_FAIL_COND(!valid.has(sd));
#endif
ERR_FAIL();
lock_data(p_id);
int sofs = sd->stereo ? 2:1;
if (sd->is16) {
int16_t *p=(int16_t*)sd->w.ptr();
p[p_sample*sofs+p_channel]=p_data;
} else {
int8_t *p=(int8_t*)sd->w.ptr();
p[p_sample*sofs+p_channel]=p_data;
}
unlock_data(p_id);
}
void CPSampleManagerImpl::unlock_data(CPSample_ID p_id){
SampleData *sd=_getsd(p_id);
#ifdef DEBUG_ENABLED
ERR_FAIL_COND(!valid.has(sd));
#endif
ERR_FAIL_COND(sd->locks==0);
sd->locks--;
if (sd->locks==0) {
sd->w=DVector<uint8_t>::Write();
AudioServer::get_singleton()->sample_set_data(sd->rid,sd->lock);
sd->lock=DVector<uint8_t>();
}
}
void CPSampleManagerImpl::get_chunk(CPSample_ID p_id,int32_t p_index,void *p_data,int p_data_len) {
SampleData *sd=_getsd(p_id);
#ifdef DEBUG_ENABLED
ERR_FAIL_COND(!valid.has(sd));
#endif
ERR_FAIL();
}
/** MIXER **/
void CPMixerImpl::set_callback_interval(int p_interval_us) {
callback_interval=p_interval_us;
}
void CPMixerImpl::set_callback(void (*p_callback)(void*),void *p_userdata) {
callback=p_callback;
userdata=p_userdata;
}
void CPMixerImpl::setup_voice(int p_voice_index,CPSample_ID p_sample_id,int32_t p_start_index) {
Voice &v=voices[p_voice_index];
if (v.channel!=AudioMixer::INVALID_CHANNEL) {
mixer->channel_free(v.channel);
}
v.channel=mixer->channel_alloc(sample_manager->get_rid(p_sample_id));
v.freq_mult = sample_manager->get_c5_freq(p_sample_id)/261.6255653006;
v.sample = p_sample_id;
}
void CPMixerImpl::stop_voice(int p_voice_index) {
Voice &v=voices[p_voice_index];
if (v.channel==AudioMixer::INVALID_CHANNEL)
return;
mixer->channel_free(v.channel);
v.channel=AudioMixer::INVALID_CHANNEL;
}
void CPMixerImpl::set_voice_frequency(int p_voice_index,int32_t p_freq) {
Voice &v=voices[p_voice_index];
ERR_FAIL_COND(v.channel==AudioMixer::INVALID_CHANNEL);
float f = p_freq / 256.0;
f*=pitch_scale;
mixer->channel_set_mix_rate(v.channel,f * v.freq_mult );
}
void CPMixerImpl::set_voice_panning(int p_voice_index,int p_pan) {
Voice &v=voices[p_voice_index];
ERR_FAIL_COND(v.channel==AudioMixer::INVALID_CHANNEL);
if (p_pan==CP_PAN_SURROUND)
p_pan=CP_PAN_CENTER;
float p = p_pan / 256.0;
mixer->channel_set_pan(v.channel,p);
}
void CPMixerImpl::set_voice_volume(int p_voice_index,int p_vol) {
More Bug Fixes -=-=-=-=-=-=- -Fixed a few bugs in Mixer, now playback of chiptunes works great :) -Changed how visibility AABB generation from skeletons work, it's fully automatic and real-time now, generated from current skeleton pose for the frame. -Fixed camera in 3D kinematic character demo.
2014-09-17 23:03:10 +00:00
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
Voice &v=voices[p_voice_index];
ERR_FAIL_COND(v.channel==AudioMixer::INVALID_CHANNEL);
float vol = p_vol/512.0;
vol*=voice_scale;
mixer->channel_set_volume(v.channel,vol);
mixer->channel_set_reverb(v.channel,reverb_type,vol*v.reverb);
}
void CPMixerImpl::set_voice_filter(int p_voice_index,bool p_enabled,uint8_t p_cutoff, uint8_t p_resonance ){
Voice &v=voices[p_voice_index];
ERR_FAIL_COND(v.channel==AudioMixer::INVALID_CHANNEL);
}
void CPMixerImpl::set_voice_reverb_send(int p_voice_index,int p_reverb){
Voice &v=voices[p_voice_index];
ERR_FAIL_COND(v.channel==AudioMixer::INVALID_CHANNEL);
v.reverb=p_reverb/255.0;
//mixer->channel_set_reverb(v.channel,reverb_type,p_reverb/255.0);
}
void CPMixerImpl::set_voice_chorus_send(int p_voice_index,int p_chorus){
Voice &v=voices[p_voice_index];
ERR_FAIL_COND(v.channel==AudioMixer::INVALID_CHANNEL);
mixer->channel_set_chorus(v.channel,p_chorus/255.0);
}
void CPMixerImpl::set_reverb_mode(ReverbMode p_mode){
// Voice &v=voices[p_voice_index];
// ERR_FAIL_COND(v.channel==AudioMixer::INVALID_CHANNEL);
switch(p_mode) {
case CPMixer::REVERB_MODE_STUDIO_SMALL: reverb_type=AudioMixer::REVERB_SMALL; break;
case CPMixer::REVERB_MODE_STUDIO_MEDIUM: reverb_type=AudioMixer::REVERB_MEDIUM; break;
case CPMixer::REVERB_MODE_STUDIO_LARGE: reverb_type=AudioMixer::REVERB_LARGE; break;
case CPMixer::REVERB_MODE_HALL: reverb_type=AudioMixer::REVERB_HALL; break;
default: reverb_type=AudioMixer::REVERB_SMALL; break;
}
}
void CPMixerImpl::set_chorus_params(unsigned int p_delay_ms,unsigned int p_separation_ms,unsigned int p_depth_ms10,unsigned int p_speed_hz10){
// Voice &v=voices[p_voice_index];
// ERR_FAIL_COND(v.channel==AudioMixer::INVALID_CHANNEL);
}
/* Info retrieving */
int32_t CPMixerImpl::get_voice_sample_pos_index(int p_voice_index) {
Voice &v=voices[p_voice_index];
ERR_FAIL_COND_V(v.channel==AudioMixer::INVALID_CHANNEL,0);
return 0;
}
int CPMixerImpl::get_voice_panning(int p_voice_index) {
Voice &v=voices[p_voice_index];
ERR_FAIL_COND_V(!is_voice_active(p_voice_index),0);
return mixer->channel_get_pan(v.channel)*CP_PAN_RIGHT;
}
int CPMixerImpl::get_voice_volume(int p_voice_index) {
Voice &v=voices[p_voice_index];
ERR_FAIL_COND_V(!is_voice_active(p_voice_index),0);
return mixer->channel_get_volume(v.channel);
}
CPSample_ID CPMixerImpl::get_voice_sample_id(int p_voice_index) {
Voice &v=voices[p_voice_index];
ERR_FAIL_COND_V(v.channel==AudioMixer::INVALID_CHANNEL,CPSample_ID());
return v.sample;
}
bool CPMixerImpl::is_voice_active(int p_voice_index){
Voice &v=voices[p_voice_index];
if (v.channel==AudioMixer::INVALID_CHANNEL)
return false;
if (!mixer->channel_is_valid(v.channel))
v.channel=AudioMixer::INVALID_CHANNEL;
return v.channel!=AudioMixer::INVALID_CHANNEL;
}
void CPMixerImpl::process_usecs(int p_usec,float p_volume,float p_pitch_scale,float p_tempo_scale) {
ERR_FAIL_COND(callback_interval==0);
//update this somewhere
pitch_scale=p_pitch_scale;
tempo_scale=p_tempo_scale;
voice_scale = AudioServer::get_singleton()->get_event_voice_global_volume_scale()*p_volume;
while(p_usec) {
if (p_usec>=callback_timeout) {
p_usec-=callback_timeout;
callback_timeout=0;
More Bug Fixes -=-=-=-=-=-=- -Fixed a few bugs in Mixer, now playback of chiptunes works great :) -Changed how visibility AABB generation from skeletons work, it's fully automatic and real-time now, generated from current skeleton pose for the frame. -Fixed camera in 3D kinematic character demo.
2014-09-17 23:03:10 +00:00
if (callback) {
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
callback(userdata);
More Bug Fixes -=-=-=-=-=-=- -Fixed a few bugs in Mixer, now playback of chiptunes works great :) -Changed how visibility AABB generation from skeletons work, it's fully automatic and real-time now, generated from current skeleton pose for the frame. -Fixed camera in 3D kinematic character demo.
2014-09-17 23:03:10 +00:00
}
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
callback_timeout=callback_interval*(1.0/p_tempo_scale);
} else {
callback_timeout-=p_usec;
p_usec=0;
}
}
}
CPMixerImpl::CPMixerImpl(AudioMixer *p_mixer) {
callback_interval=1;
callback_timeout=0;
userdata=0;
callback=0;
tempo_scale=1.0;
pitch_scale=1.0;
mixer=p_mixer;
voice_scale = AudioServer::get_singleton()->get_event_voice_global_volume_scale();
reverb_type = AudioMixer::REVERB_SMALL;
}
/** FILE ACCESS WRAPPER **/
CPFileAccessWrapperImpl::Error CPFileAccessWrapperImpl::open(const char *p_filename, int p_mode_flags) {
ERR_FAIL_COND_V(p_mode_flags&WRITE,ERROR_WRITING_FILE);
close();
f = FileAccess::open(String::utf8(p_filename),p_mode_flags);
if (!f)
return ERROR_FILE_NOT_FOUND;
return OK;
}
void CPFileAccessWrapperImpl::close(){
if (f)
memdelete(f);
f=NULL;
}
void CPFileAccessWrapperImpl::seek(uint32_t p_position){
f->seek(p_position);
}
void CPFileAccessWrapperImpl::seek_end(){
f->seek_end();
}
uint32_t CPFileAccessWrapperImpl::get_pos(){
return f->get_pos();
}
bool CPFileAccessWrapperImpl::eof_reached(){
return f->eof_reached();
}
uint8_t CPFileAccessWrapperImpl::get_byte(){
return f->get_8();
}
void CPFileAccessWrapperImpl::get_byte_array(uint8_t *p_dest,int p_elements){
f->get_buffer(p_dest,p_elements);
}
void CPFileAccessWrapperImpl::get_word_array(uint16_t *p_dest,int p_elements){
for(int i=0;i<p_elements;i++) {
p_dest[i]=f->get_16();
}
}
uint16_t CPFileAccessWrapperImpl::get_word(){
return f->get_16();
}
uint32_t CPFileAccessWrapperImpl::get_dword(){
return f->get_32();
}
void CPFileAccessWrapperImpl::set_endian_conversion(bool p_swap){
f->set_endian_swap(p_swap);
}
bool CPFileAccessWrapperImpl::is_open(){
return f!=NULL;
}
CPFileAccessWrapperImpl::Error CPFileAccessWrapperImpl::get_error(){
return (f->get_error()!=::OK)?ERROR_READING_FILE:OK;
}
void CPFileAccessWrapperImpl::store_byte(uint8_t p_dest){
}
void CPFileAccessWrapperImpl::store_byte_array(const uint8_t *p_dest,int p_elements){
}
void CPFileAccessWrapperImpl::store_word(uint16_t p_dest){
}
void CPFileAccessWrapperImpl::store_dword(uint32_t p_dest){
}
////////////////////////////////////////////////
Error EventStreamPlaybackChibi::_play() {
last_order=0;
loops++;
player->play_start_song();
total_usec=0;
return OK;
}
bool EventStreamPlaybackChibi::_update(AudioMixer* p_mixer, uint64_t p_usec){
total_usec+=p_usec;
mixer.process_usecs(p_usec,volume,pitch_scale,tempo_scale);
int order=player->get_current_order();
if (order<last_order && !loop) {
stop();
} else {
loops++;
}
last_order=order;
return false;
}
void EventStreamPlaybackChibi::_stop(){
player->play_stop();
}
void EventStreamPlaybackChibi::set_paused(bool p_paused){
}
bool EventStreamPlaybackChibi::is_paused() const{
return false;
}
void EventStreamPlaybackChibi::set_loop(bool p_loop){
loop=p_loop;
}
bool EventStreamPlaybackChibi::is_loop_enabled() const{
return loop;
}
int EventStreamPlaybackChibi::get_loop_count() const{
//return player->is
return loops;
}
float EventStreamPlaybackChibi::get_pos() const{
return double(total_usec)/1000000.0;
}
void EventStreamPlaybackChibi::seek_pos(float p_time){
WARN_PRINT("seek_pos unimplemented.");
}
void EventStreamPlaybackChibi::set_volume(float p_volume) {
volume=p_volume;
}
float EventStreamPlaybackChibi::get_volume() const{
return volume;
}
void EventStreamPlaybackChibi::set_pitch_scale(float p_pitch_scale) {
pitch_scale=p_pitch_scale;
}
float EventStreamPlaybackChibi::get_pitch_scale() const{
return pitch_scale;
}
void EventStreamPlaybackChibi::set_tempo_scale(float p_tempo_scale) {
tempo_scale=p_tempo_scale;
}
float EventStreamPlaybackChibi::get_tempo_scale() const{
return tempo_scale;
}
void EventStreamPlaybackChibi::set_channel_volume(int p_channel,float p_volume) {
More Bug Fixes -=-=-=-=-=-=- -Fixed a few bugs in Mixer, now playback of chiptunes works great :) -Changed how visibility AABB generation from skeletons work, it's fully automatic and real-time now, generated from current skeleton pose for the frame. -Fixed camera in 3D kinematic character demo.
2014-09-17 23:03:10 +00:00
if (p_channel>=64)
return;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
player->set_channel_global_volume(p_channel,p_volume*256);
}
float EventStreamPlaybackChibi::get_channel_volume(int p_channel) const{
return player->get_channel_global_volume(p_channel)/256.0;
}
float EventStreamPlaybackChibi::get_last_note_time(int p_channel) const {
double v = (player->get_channel_last_note_time_usec(p_channel))/1000000.0;
if (v<0)
v=-1;
return v;
}
EventStreamPlaybackChibi::EventStreamPlaybackChibi(Ref<EventStreamChibi> p_stream) : mixer(_get_mixer()) {
stream=p_stream;
player = memnew( CPPlayer(&mixer,&p_stream->song) );
loop=false;
last_order=0;
loops=0;
volume=1.0;
pitch_scale=1.0;
tempo_scale=1.0;
}
EventStreamPlaybackChibi::~EventStreamPlaybackChibi(){
player->play_stop();
memdelete(player);
}
////////////////////////////////////////////////////
Ref<EventStreamPlayback> EventStreamChibi::instance_playback() {
return Ref<EventStreamPlayback>( memnew(EventStreamPlaybackChibi(Ref<EventStreamChibi>(this))) );
}
String EventStreamChibi::get_stream_name() const{
return song.get_name();
}
float EventStreamChibi::get_length() const{
return 1;
}
EventStreamChibi::EventStreamChibi() {
}
//////////////////////////////////////////////////////////////////
RES ResourceFormatLoaderChibi::load(const String &p_path,const String& p_original_path) {
String el = p_path.extension().to_lower();
CPFileAccessWrapperImpl f;
if (el=="it") {
Ref<EventStreamChibi> esc( memnew( EventStreamChibi ) );
CPLoader_IT loader(&f);
More Bug Fixes -=-=-=-=-=-=- -Fixed a few bugs in Mixer, now playback of chiptunes works great :) -Changed how visibility AABB generation from skeletons work, it's fully automatic and real-time now, generated from current skeleton pose for the frame. -Fixed camera in 3D kinematic character demo.
2014-09-17 23:03:10 +00:00
CPLoader::Error err = loader.load_song(p_path.utf8().get_data(),&esc->song,false);
ERR_FAIL_COND_V(err!=CPLoader::FILE_OK,RES());
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return esc;
} else if (el=="xm") {
Ref<EventStreamChibi> esc( memnew( EventStreamChibi ) );
CPLoader_XM loader(&f);
More Bug Fixes -=-=-=-=-=-=- -Fixed a few bugs in Mixer, now playback of chiptunes works great :) -Changed how visibility AABB generation from skeletons work, it's fully automatic and real-time now, generated from current skeleton pose for the frame. -Fixed camera in 3D kinematic character demo.
2014-09-17 23:03:10 +00:00
CPLoader::Error err=loader.load_song(p_path.utf8().get_data(),&esc->song,false);
ERR_FAIL_COND_V(err!=CPLoader::FILE_OK,RES());
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return esc;
} else if (el=="s3m") {
Ref<EventStreamChibi> esc( memnew( EventStreamChibi ) );
CPLoader_S3M loader(&f);
More Bug Fixes -=-=-=-=-=-=- -Fixed a few bugs in Mixer, now playback of chiptunes works great :) -Changed how visibility AABB generation from skeletons work, it's fully automatic and real-time now, generated from current skeleton pose for the frame. -Fixed camera in 3D kinematic character demo.
2014-09-17 23:03:10 +00:00
CPLoader::Error err=loader.load_song(p_path.utf8().get_data(),&esc->song,false);
ERR_FAIL_COND_V(err!=CPLoader::FILE_OK,RES());
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return esc;
} else if (el=="mod") {
Ref<EventStreamChibi> esc( memnew( EventStreamChibi ) );
CPLoader_MOD loader(&f);
More Bug Fixes -=-=-=-=-=-=- -Fixed a few bugs in Mixer, now playback of chiptunes works great :) -Changed how visibility AABB generation from skeletons work, it's fully automatic and real-time now, generated from current skeleton pose for the frame. -Fixed camera in 3D kinematic character demo.
2014-09-17 23:03:10 +00:00
CPLoader::Error err=loader.load_song(p_path.utf8().get_data(),&esc->song,false);
ERR_FAIL_COND_V(err!=CPLoader::FILE_OK,RES());
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return esc;
}
return RES();
}
void ResourceFormatLoaderChibi::get_recognized_extensions(List<String> *p_extensions) const {
p_extensions->push_back("it");
p_extensions->push_back("xm");
p_extensions->push_back("s3m");
p_extensions->push_back("mod");
}
bool ResourceFormatLoaderChibi::handles_type(const String& p_type) const {
return (p_type=="EventStreamChibi" || p_type=="EventStream");
}
String ResourceFormatLoaderChibi::get_resource_type(const String &p_path) const {
String el = p_path.extension().to_lower();
if (el=="it" || el=="s3m" || el=="xm" || el=="mod")
return "EventStreamChibi";
return "";
}
/////////////////////////////////////////////////////////////////
void initialize_chibi() {
sample_manager = memnew( CPSampleManagerImpl );
resource_loader = memnew( ResourceFormatLoaderChibi );
ObjectTypeDB::register_type<EventStreamChibi>();
ResourceLoader::add_resource_format_loader( resource_loader );
}
void finalize_chibi() {
memdelete( sample_manager );
memdelete( resource_loader );
}