X3DSoundSourceNode.h

Go to the documentation of this file.

//    Copyright 2004-2019, SenseGraphics AB
//
//    This file is part of H3D API.
//
//    H3D API is free software; you can redistribute it and/or modify
//    it under the terms of the GNU General Public License as published by
//    the Free Software Foundation; either version 2 of the License, or
//    (at your option) any later version.
//
//    H3D API is distributed in the hope that it will be useful,
//    but WITHOUT ANY WARRANTY; without even the implied warranty of
//    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//    GNU General Public License for more details.
//
//    You should have received a copy of the GNU General Public License
//    along with H3D API; if not, write to the Free Software
//    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
//
//    A commercial license is also available. Please contact us at 
//    www.sensegraphics.com for more information.
//
//
//
#ifndef __X3DSOUNDSOURCENODE_H__
#define __X3DSOUNDSOURCENODE_H__
 
#include <H3D/X3DTimeDependentNode.h>
#include <H3D/X3DSoundNode.h>
#include <H3D/PeriodicUpdate.h>
#include <H3D/H3DSoundStreamNode.h>
#include <list>
#include <fstream>
 
#ifdef HAVE_OPENAL
#if defined( MACOSX )
#include <OpenAL/al.h>
#include <OpenAL/alc.h>
#else
#include <AL/al.h>
#include <AL/alc.h>
#endif
#endif 
 
#define NR_STREAM_BUFFERS 3
#define STREAM_BUFFER_SIZE (4096*8)
 
namespace H3D {
 
  class H3DAPI_API X3DSoundSourceNode : public X3DTimeDependentNode {
  public:
    class H3DAPI_API TimeHandler: public X3DTimeDependentNode::TimeHandler {
    public:
      TimeHandler() {}
    protected:
      virtual void update();
    };
#ifdef __BORLANDC__
    friend class TimeHandler;
#endif
 
    class H3DAPI_API ALSoundBuffer: 
      public PeriodicUpdate< Field > {
    protected:
      virtual void update() {
        X3DSoundSourceNode *s = 
          static_cast< X3DSoundSourceNode * >( getOwner());
        s->ALrender();
        event_fields.clear();
      }
 
      virtual void propagateEvent( Event e ) {
        Field::propagateEvent( e );
        event_fields.insert( e.ptr );
      }
    public:
 
      inline bool hasCausedEvent( Field *f ) {
        return event_fields.find( f ) != event_fields.end();
      }
 
      template< class FieldType >
      inline bool hasCausedEvent( H3DUniquePtr< FieldType > &f ) {
        return hasCausedEvent( f.get() );
      }
 
    protected:
      set< Field * > event_fields;
    };
 
 
    X3DSoundSourceNode( Inst< SFNode   > _metadata         = 0,
                        Inst< SFString > _description      = 0,
                        Inst< SFBool   > _loop             = 0,
                        Inst< SFTime   > _pauseTime        = 0,
                        Inst< SFFloat  > _pitch            = 0,
                        Inst< SFTime   > _resumeTime       = 0,
                        Inst< StartTime   > _startTime        = 0,
                        Inst< StopTime   > _stopTime         = 0,
                        Inst< SFTime   > _duration_changed = 0,
                        Inst< SFTime   > _elapsedTime      = 0,
                        Inst< SFBool   > _isActive         = 0,
                        Inst< SFBool   > _isPaused         = 0,
                        Inst< TimeHandler > _timeHandler   = 0 );
 
    virtual ~X3DSoundSourceNode();
 
    virtual bool initALBuffers( bool stream );
 
    virtual void ALrender();
 
    virtual string defaultXMLContainerField() {
      return "source";
    }
 
    virtual void registerSoundNode( X3DSoundNode *n );
 
    virtual void unregisterSoundNode( X3DSoundNode *n );
 
    virtual void onPause();
 
    virtual void onResume();
 
    virtual void onStart();
 
    virtual void onStop();
 
    H3DUniquePtr< SFString > description;
 
    H3DUniquePtr< SFFloat  > pitch;
 
    H3DUniquePtr< SFTime   > duration_changed;
 
    static H3DNodeDatabase database;
  protected:
    list< X3DSoundNode * > parent_sound_nodes;
 
#ifdef HAVE_OPENAL
    ALuint al_buffers[NR_STREAM_BUFFERS];
 
    ALenum al_format;
#endif
 
    AutoRef< H3DSoundStreamNode > reader;
 
    bool sound_as_stream;
 
    H3DUniquePtr< ALSoundBuffer > soundBuffer;
 };
}
 
#endif