SpatialSource.h

Go to the documentation of this file.

/*
 *  SpatialSource.h
 *  CSL
 *
 *  Created by Jorge Castellanos on 6/16/06.
 *  Copyright 2006 Jorge Castellanos. All rights reserved.
 *
 */


#ifndef SOUND_SOURCE_H
#define SOUND_SOURCE_H

#include "CSL_Core.h"
#include "CPoint.h"

namespace csl {

//class SpatialProperties {
//public:
//  SpatialProperties() : mPosition(0.f), mRoot(NULL), mPositionChanged(true) {};
//  ~SpatialProperties() {};
//
//  float mPosition;
//  UnitGenerator *mRoot;
//  bool mPositionChanged;      //< true if this source's position has changed
//  
//};

class SpatSource : public UnitGenerator, public virtual Scalable {
public:
    SpatSource();
    SpatSource(UnitGenerator &input, float azi = 0.0, float ele = 0.0, float dist = 1.0);
    virtual ~SpatSource();

    virtual void setPosition(float x = 0., float y = 0., float z = 0.); 
    virtual void setPosition(char s, float azi = 0, float ele = 0, float dist = 1.0) ;

//  void setOrientation(float horizontalAngle, float verticalAngle); // Specify what direction is the object facing
//  void setDirectivity(float innerConeAngle, float outerConeAngle); // This is the actual sound radiation pattern of the sound object.
    
        
    float azimuth()     { return mPosition->theta(); }; 
    float elevation()   { return mPosition->ele(); };   
    float distance()    { return mPosition->r(); };     

    CPoint *position(unsigned channelNum = 0);

    bool positionChanged() { return mPositionChanged; };

    virtual void nextBuffer(Buffer & outputBuffer, unsigned outBufNum) throw (CException);
    virtual void nextBuffer(Buffer & outputBuffer) throw (CException);

    void dump();

protected:
    CPoint *mPosition;
//  float mInnerCone;
//  float mOuterCone;
//  float mHorizontalOrientation;
//  float mVerticalOrientation;
    
    bool mPositionChanged;      //< true if this source's position has changed
    
};

    /*
    DESIGN THOUGHTS:
    Possibly Source could be called PositionableSource and be the base class of other Spatial Sources.
    For example, a subclass could include directivity and radiation pattern, wich is less common than position
    Also, different ways of sound radiation could be implemented by subclasses. 
    
    A second option is to specify sound radiation directly to the object that does the actual computation.
    This way the different processors could accept their very particular way of doing things.
    This approach would break with the concept of having the sound source KNOW its own characteristics.
    Cons: not only the processors of directivity, but also procesors of room acoustics would make use of 
    such info, so user would have to specify it twice (this could be a feature, as it would allow different
    types, one simpler for reflections, and a possibly complex one for the direct sound. 
    
    Maybe the answer is that sound radiation is not just a record class, but it responds with an actual value
    (or filter?) when asked for the value at x angle. That way the different types of pattern would know how to
    do their shit, but mantaining a common interface and return type, so it can be processed.
    
    Or.. should I just decide for one method and stick to it? That would defeat the purpose of an extensible
    framework made to be used for research, as well as for making content.
    
    */


}

#endif

---