TheCloud/panda3d
1
0
Fork 0
mirror of https://github.com/panda3d/panda3d.git synced 2025-09-27 23:34:57 -04:00
Code Issues Packages Projects Releases Wiki Activity

all gone

Browse Source
This commit is contained in:
Cary Sandvig 2000-10-30 19:19:03 +00:00
parent 0d238d06ab
commit 6c4cd0b620
6 changed files with 0 additions and 380 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

80
panda/src/audio/audio_music.I
View File

@ -1,80 +0,0 @@
// Filename: audio_music.I
// Created by: cary (26Sep00)
//
////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
// Function: AudioMusic::constructor
// Access: Protected
// Description: initialize a new music
////////////////////////////////////////////////////////////////////
INLINE AudioMusic::AudioMusic(AudioTraits::MusicClass* music,
AudioTraits::PlayingClass* state,
AudioTraits::PlayerClass* player,
AudioTraits::DeleteMusicFunc* destroy,
const string& filename) : Namable(filename),
_music(music),
_state(state),
_player(player),
_destroy(destroy) {}
////////////////////////////////////////////////////////////////////
// Function: AudioMusic::copy constructor
// Access: Protected
// Description: copy a music, but we don't really want to allow this
////////////////////////////////////////////////////////////////////
INLINE AudioMusic::AudioMusic(const AudioMusic& c) : Namable(c.get_name()),
_music(c._music),
_state(c._state),
_player(c._player),
_destroy(c._destroy) {}
////////////////////////////////////////////////////////////////////
// Function: AudioMusic::assignment operator
// Access: Protected
// Description: copy a music, but we don't really want to allow this
////////////////////////////////////////////////////////////////////
INLINE AudioMusic& AudioMusic::operator=(const AudioMusic& c) {
this->set_name(c.get_name());
this->_music = c._music;
this->_state = c._state;
this->_player = c._player;
this->_destroy = c._destroy;
return *this;
}
////////////////////////////////////////////////////////////////////
// Function: AudioMusic::get_player
// Access: Protected
// Description: return the player for this music
////////////////////////////////////////////////////////////////////
INLINE AudioTraits::PlayerClass* AudioMusic::get_player(void) {
return _player;
}
////////////////////////////////////////////////////////////////////
// Function: AudioMusic::get_music
// Access: Protected
// Description: return the trait music class for this music
////////////////////////////////////////////////////////////////////
INLINE AudioTraits::MusicClass* AudioMusic::get_music(void) {
return _music;
}
////////////////////////////////////////////////////////////////////
// Function: AudioMusic::get_playing
// Access: Protected
// Description: return the trait playing class for this music
////////////////////////////////////////////////////////////////////
INLINE AudioTraits::PlayingClass* AudioMusic::get_playing(void) {
return _state;
}
////////////////////////////////////////////////////////////////////
// Function: AudioMusic::equality operator
// Access: Public
// Description: test to see if two musics are the same
////////////////////////////////////////////////////////////////////
INLINE bool AudioMusic::operator==(const AudioMusic& c) const {
return (_music == c._music);
}

42
panda/src/audio/audio_music.cxx
View File

@ -1,42 +0,0 @@
// Filename: audio_music.cxx
// Created by: cary (26Sep00)
//
////////////////////////////////////////////////////////////////////
#include "audio_music.h"
#include "config_audio.h"
TypeHandle AudioMusic::_type_handle;
////////////////////////////////////////////////////////////////////
// Function: AudioMusic::destructor
// Access: Public
// Description: deletes the music data and then lets the system
// destroy this structure
////////////////////////////////////////////////////////////////////
AudioMusic::~AudioMusic(void) {
(*_destroy)(_music);
}
////////////////////////////////////////////////////////////////////
// Function: AudioMusic::status
// Access: Public
// Description: return the current play status of this music
////////////////////////////////////////////////////////////////////
AudioMusic::MusicStatus AudioMusic::status(void) {
// AudioTraits::PlayingClass::PlayingStatus stat = _state->status();
AudioTraits::MusicClass::MusicStatus stat = _music->status();
switch (stat) {
// case AudioTraits::PlayingClass::BAD:
case AudioTraits::MusicClass::BAD:
return BAD;
// case AudioTraits::PlayingClass::READY:
case AudioTraits::MusicClass::READY:
return READY;
// case AudioTraits::PlayingClass::PLAYING:
case AudioTraits::MusicClass::PLAYING:
return PLAYING;
}
audio_cat->error() << "unknown status for music" << endl;
return BAD;
}

65
panda/src/audio/audio_music.h
View File

@ -1,65 +0,0 @@
// Filename: audio_music.h
// Created by: cary (22Sep00)
//
////////////////////////////////////////////////////////////////////
#ifndef __AUDIO_MUSIC_H__
#define __AUDIO_MUSIC_H__
#include "audio_trait.h"
#include "typedReferenceCount.h"
#include "namable.h"
class AudioPool;
class AudioManager;
class EXPCL_PANDA AudioMusic : public TypedReferenceCount, public Namable {
private:
AudioTraits::MusicClass *_music;
AudioTraits::PlayingClass *_state;
AudioTraits::PlayerClass *_player;
AudioTraits::DeleteMusicFunc *_destroy;
protected:
INLINE AudioMusic(AudioTraits::MusicClass*, AudioTraits::PlayingClass*,
AudioTraits::PlayerClass*, AudioTraits::DeleteMusicFunc*,
const string&);
INLINE AudioMusic(const AudioMusic&);
INLINE AudioMusic& operator=(const AudioMusic&);
INLINE AudioTraits::PlayerClass* get_player(void);
INLINE AudioTraits::MusicClass* get_music(void);
INLINE AudioTraits::PlayingClass* get_playing(void);
friend class AudioPool;
friend class AudioManager;
public:
virtual ~AudioMusic(void);
INLINE bool operator==(const AudioMusic&) const;
enum MusicStatus { BAD, READY, PLAYING };
MusicStatus status(void);
public:
// type stuff
static TypeHandle get_class_type(void) {
return _type_handle;
}
static void init_type(void) {
TypedReferenceCount::init_type();
register_type(_type_handle, "AudioMusic",
TypedReferenceCount::get_class_type());
}
virtual TypeHandle get_type(void) const {
return get_class_type();
}
virtual TypeHandle force_init_type(void) {
init_type();
return get_class_type();
}
private:
static TypeHandle _type_handle;
};
#include "audio_music.I"
#endif /* __AUDIO_MUSIC_H__ */

80
panda/src/audio/audio_sample.I
View File

@ -1,80 +0,0 @@
// Filename: audio_sample.I
// Created by: cary (23Sep00)
//
////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
// Function: AudioSample::constructor
// Access: Protected
// Description: initialize a new sample
////////////////////////////////////////////////////////////////////
INLINE AudioSample::AudioSample(AudioTraits::SampleClass* sample,
AudioTraits::PlayingClass* state,
AudioTraits::PlayerClass* player,
AudioTraits::DeleteSampleFunc* destroy,
const string& filename) : Namable(filename),
_sample(sample),
_state(state),
_player(player),
_destroy(destroy) {}
////////////////////////////////////////////////////////////////////
// Function: AudioSample::copy constructor
// Access: Protected
// Description: copy a sample, but we don't really want to allow this
////////////////////////////////////////////////////////////////////
INLINE AudioSample::AudioSample(const AudioSample& c) : Namable(c.get_name()),
_sample(c._sample),
_state(c._state),
_player(c._player),
_destroy(c._destroy) {}
////////////////////////////////////////////////////////////////////
// Function: AudioSample::assignment operator
// Access: Protected
// Description: copy a sample, but we don't really want to allow this
////////////////////////////////////////////////////////////////////
INLINE AudioSample& AudioSample::operator=(const AudioSample& c) {
this->set_name(c.get_name());
this->_sample = c._sample;
this->_state = c._state;
this->_player = c._player;
this->_destroy = c._destroy;
return *this;
}
////////////////////////////////////////////////////////////////////
// Function: AudioSample::get_player
// Access: Protected
// Description: return the player for this sample
////////////////////////////////////////////////////////////////////
INLINE AudioTraits::PlayerClass* AudioSample::get_player(void) {
return _player;
}
////////////////////////////////////////////////////////////////////
// Function: AudioSample::get_sample
// Access: Protected
// Description: return the trait sample class for this sample
////////////////////////////////////////////////////////////////////
INLINE AudioTraits::SampleClass* AudioSample::get_sample(void) {
return _sample;
}
////////////////////////////////////////////////////////////////////
// Function: AudioSample::get_playing
// Access: Protected
// Description: return the trait playing class for this sample
////////////////////////////////////////////////////////////////////
INLINE AudioTraits::PlayingClass* AudioSample::get_playing(void) {
return _state;
}
////////////////////////////////////////////////////////////////////
// Function: AudioSample::equality operator
// Access: Public
// Description: test to see if two samples are the same
////////////////////////////////////////////////////////////////////
INLINE bool AudioSample::operator==(const AudioSample& c) const {
return (_sample == c._sample);
}

47
panda/src/audio/audio_sample.cxx
View File

@ -1,47 +0,0 @@
// Filename: audio_sample.cxx
// Created by: cary (23Sep00)
//
////////////////////////////////////////////////////////////////////
#include "audio_sample.h"
#include "config_audio.h"
TypeHandle AudioSample::_type_handle;
////////////////////////////////////////////////////////////////////
// Function: AudioSample::destructor
// Access: Public
// Description: deletes the sample data and then lets the system
// destroy this structure
////////////////////////////////////////////////////////////////////
AudioSample::~AudioSample(void) {
(*_destroy)(_sample);
}
////////////////////////////////////////////////////////////////////
// Function: AudioSample::length
// Access: Public
// Description: return the length (in seconds) of the sample
////////////////////////////////////////////////////////////////////
float AudioSample::length(void) {
return _sample->length();
}
////////////////////////////////////////////////////////////////////
// Function: AudioSample::status
// Access: Public
// Description: return the current play status of this sample
////////////////////////////////////////////////////////////////////
AudioSample::SampleStatus AudioSample::status(void) {
AudioTraits::PlayingClass::PlayingStatus stat = _state->status();
switch (stat) {
case AudioTraits::PlayingClass::BAD:
return BAD;
case AudioTraits::PlayingClass::READY:
return READY;
case AudioTraits::PlayingClass::PLAYING:
return PLAYING;
}
audio_cat->error() << "unknown status for sample" << endl;
return BAD;
}

66
panda/src/audio/audio_sample.h
View File

@ -1,66 +0,0 @@
// Filename: audio_sample.h
// Created by: cary (22Sep00)
//
////////////////////////////////////////////////////////////////////
#ifndef __AUDIO_SAMPLE_H__
#define __AUDIO_SAMPLE_H__
#include "audio_trait.h"
#include "typedReferenceCount.h"
#include "namable.h"
class AudioPool;
class AudioManager;
class EXPCL_PANDA AudioSample : public TypedReferenceCount, public Namable {
private:
AudioTraits::SampleClass *_sample;
AudioTraits::PlayingClass *_state;
AudioTraits::PlayerClass *_player;
AudioTraits::DeleteSampleFunc *_destroy;
protected:
INLINE AudioSample(AudioTraits::SampleClass*, AudioTraits::PlayingClass*,
AudioTraits::PlayerClass*, AudioTraits::DeleteSampleFunc*,
const string&);
INLINE AudioSample(const AudioSample&);
INLINE AudioSample& operator=(const AudioSample&);
INLINE AudioTraits::PlayerClass* get_player(void);
INLINE AudioTraits::SampleClass* get_sample(void);
INLINE AudioTraits::PlayingClass* get_playing(void);
friend class AudioPool;
friend class AudioManager;
public:
virtual ~AudioSample(void);
INLINE bool operator==(const AudioSample&) const;
enum SampleStatus { BAD, READY, PLAYING } ;
float length(void);
SampleStatus status(void);
public:
// type stuff
static TypeHandle get_class_type(void) {
return _type_handle;
}
static void init_type(void) {
TypedReferenceCount::init_type();
register_type(_type_handle, "AudioSample",
TypedReferenceCount::get_class_type());
}
virtual TypeHandle get_type(void) const {
return get_class_type();
}
virtual TypeHandle force_init_type(void) {
init_type();
return get_class_type();
}
private:
static TypeHandle _type_handle;
};
#include "audio_sample.I"
#endif /* __AUDIO_SAMPLE_H__ */