X3DSoundSourceNode.h

Go to the documentation of this file.

//    Copyright 2004, 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 "X3DTimeDependentNode.h"
#include "X3DSoundNode.h"
#include "PeriodicUpdate.h"
#include "H3DSoundStreamNode.h"
#include <list>
#include <fstream>

#ifdef HAVE_OPENAL
#ifdef WIN32
#include <al.h>
#include <alc.h>
#ifdef _MSC_VER
#pragma comment( lib, "OpenAL32.lib" )
#endif
#elif 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();
    };

    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( auto_ptr< 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 void 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();

    auto_ptr< SFString > description;

    auto_ptr< SFFloat  > pitch;

    auto_ptr< 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;

    auto_ptr< ALSoundBuffer > sound_buffer;
 };
}

#endif

---