conesound.java

JAVA3D矩陈的相关类

                     float[] frontDistance,
                     float[] frontDistanceGain,
                     float[] backDistance,
                     float[] backDistanceGain,
                     float dirX, float dirY, float dirZ ) {
        super(soundData, initialGain, loopCount, release, continuous, enable,
                     region, priority, posX, posY, posZ, 
                     frontDistance, frontDistanceGain );

        // set default read capabilities
        setDefaultReadCapabilities(readCapabilities);

        ((ConeSoundRetained)this.retained).setDirection(dirX, dirY, dirZ);
        ((ConeSoundRetained)this.retained).setBackDistanceGain(
                     backDistance, backDistanceGain );
    }

    /**
     * Constructs a ConeSound node object using all the provided PointSound
     * parameter values, which include a single spherical distance attenuation
     * array, but includes an angular attenuation array. 
     * This form uses points and vectors as input for its position, direction,
     * single spherical distanceAttenuation array, and angularAttenuation array.
     * It also accepts arrays of points for the distance attenuation and angular
     * values. Each Point2f in the distanceAttenuation array contains a distance
     * and a gain scale factor. Each Point3f in the angularAttenuation array
     * contains an angular distance, a gain scale factor, and a filtering value
     * (which is currently defined as a simple cutoff frequency).
     * @param soundData sound source data associated with this node
     * @param initialGain amplitude scale factor applied to sound
     * @param loopCount number of times sound is looped
     * @param release flag denoting playing sound to end
     * @param continuous denotes that sound silently plays when disabled
     * @param enable sound switched on/off
     * @param region scheduling bounds
     * @param priority playback ranking value
     * @param position 3D location of source
     * @param distanceAttenuation array of (distance,gain) pairs controlling 
     * attenuation values along the positive direction axis
     * @param direction vector defining cones' axii
     * @param angularAttenuation array of tuples defining angular gain/filtering
     */
     public ConeSound(MediaContainer soundData,
                      float initialGain,
                      int loopCount,
                      boolean release,
                      boolean continuous,
                      boolean enable,
                      Bounds  region,
                      float   priority,
                      Point3f position,
                      Point2f[] distanceAttenuation,
                      Vector3f direction,
                      Point3f[] angularAttenuation ) {

        super(soundData, initialGain, loopCount, release, continuous, enable,
                      region, priority, position, distanceAttenuation );

        // set default read capabilities
        setDefaultReadCapabilities(readCapabilities);

        ((ConeSoundRetained)this.retained).setDirection(direction);
        ((ConeSoundRetained)this.retained).setAngularAttenuation(
                      angularAttenuation);
    }

    /**
     * Constructs a ConeSound node object using all the provided PointSound
     * parameter values, which include a single spherical distance attenuation
     * array, but includes an angular attenuation array.
     * This form uses individual float parameters for elements of position,
     * direction, distanceAttenuation array, and angularAttenuation array.
     * It also accepts separate arrays for the distance and gain scale factors
     * components of distance attenuation, and separate arrays for the angular
     * distance, angular gain, and filtering components of angular attenuation.
     * See the setDistanceGain ConeSound method for details on how the separate
     * distance and distanceGain arrays are interpreted. See the 
     * setAngularAttenuation ConeSound method for details on how the separate
     * angularDistance, angularGain, and filter arrays are interpreted.
     * @param soundData sound source data associated with this node
     * @param initialGain amplitude scale factor applied to sound
     * @param loopCount number of times sound is looped
     * @param release flag denoting playing sound to end
     * @param continuous denotes that sound silently plays when disabled
     * @param enable sound switched on/off
     * @param region scheduling bounds
     * @param priority playback ranking value
     * @param posX x coordinate of location of source
     * @param posY y coordinate of location of source
     * @param posZ z coordinate of location of source
     * @param distance array of front distance values used for attenuation
     * @param distanceGain array of front gain scale factors used for attenuation
     * @param dirX x coordinate cones' axii vector
     * @param dirY y coordinate cones' axii vector
     * @param dirZ z coordinate cones' axii vector
     * @param angle array of angle radians for angularAttenuation
     * @param angularGain array of gain scale factors for angularAttenuation
     * @param frequencyCutoff array of lowpass filter values in Hertz
     */
    public ConeSound(MediaContainer soundData,
                     float initialGain,
                     int loopCount,
                     boolean release,
                     boolean continuous,
                     boolean enable,
                     Bounds  region,
                     float   priority,
                     float posX, float posY, float posZ,
                     float[] distance,
                     float[] distanceGain,
                     float dirX, float dirY, float dirZ,
                     float[] angle,
                     float[] angularGain,
                     float[] frequencyCutoff) {
        super(soundData, initialGain, loopCount, release, continuous, enable,
                     region, priority, posX, posY, posZ, 
                     distance, distanceGain );

        // set default read capabilities
        setDefaultReadCapabilities(readCapabilities);

        ((ConeSoundRetained)this.retained).setDirection(dirX, dirY, dirZ);
        ((ConeSoundRetained)this.retained).setAngularAttenuation(angle,
                     angularGain, frequencyCutoff);
    }

    /**
     * Constructs and initializes a new Cone Sound node explicitly setting all
     * PointSound and ConeSound fields as arguments: the PointSound position,
     * front and back distance attenuation Point2f array, and ConeSound
     * direction vector and Point3f angular attenuation.
     * @param soundData sound source data associated with this node
     * @param initialGain amplitude scale factor applied to sound
     * @param loopCount number of times sound is looped
     * @param release flag denoting playing sound to end
     * @param continuous denotes that sound silently plays when disabled
     * @param enable sound switched on/off
     * @param region scheduling bounds
     * @param priority playback ranking value
     * @param position 3D location of source
     * @param frontDistanceAttenuation array of (distance,gain) pairs controlling 
     * attenuation values along the positive direction axis
     * @param backDistanceAttenuation array of (distance,gain) pairs controlling 
     * attenuation values along the negative direction axis
     * @param direction vector defining cones' axii
     * @param angularAttenuation array of tuples defining angular gain/filtering
     */
     public ConeSound(MediaContainer soundData,
                      float initialGain,
                      int loopCount,
                      boolean release,
                      boolean continuous,
                      boolean enable,
                      Bounds  region,
                      float   priority,
                      Point3f position,
                      Point2f[] frontDistanceAttenuation,
                      Point2f[] backDistanceAttenuation,
                      Vector3f direction,
                      Point3f[] angularAttenuation ) {

        super(soundData, initialGain, loopCount, release, continuous, enable,
                      region, priority, position, frontDistanceAttenuation );

        // set default read capabilities
        setDefaultReadCapabilities(readCapabilities);

        ((ConeSoundRetained)this.retained).setBackDistanceGain(
                      backDistanceAttenuation);
        ((ConeSoundRetained)this.retained).setDirection(direction);
        ((ConeSoundRetained)this.retained).setAngularAttenuation(
                      angularAttenuation);
    }

    /**
     * Constructs and initializes a new Cone Sound node explicitly setting all
     * PointSound and ConeSound fields as arguments but all the vector and point
     * arguments are broken into individual float array components.
     * @param soundData sound source data associated with this node
     * @param initialGain amplitude scale factor applied to sound
     * @param loopCount number of times sound is looped
     * @param release flag denoting playing sound to end
     * @param continuous denotes that sound silently plays when disabled
     * @param enable sound switched on/off
     * @param region scheduling bounds
     * @param priority playback ranking value
     * @param posX x coordinate of location of source
     * @param posY y coordinate of location of source
     * @param posZ z coordinate of location of source
     * @param frontDistance array of front distance values used for attenuation
     * @param frontDistanceGain array of front gain scale factors used for attenuation
     * @param backDistance array of back distance values used for attenuation
     * @param backDistanceGain array of back gain scale factors used for attenuation
     * @param dirX x coordinate cones' axii vector
     * @param dirY y coordinate cones' axii vector
     * @param dirZ z coordinate cones' axii vector
     * @param angle array of angle radians for angularAttenuation
     * @param angularGain array of gain scale factors for angularAttenuation
     * @param frequencyCutoff array of lowpass filter values in Hertz
     */
    public ConeSound(MediaContainer soundData,
                     float initialGain,
                     int loopCount,
                     boolean release,
                     boolean continuous,
                     boolean enable,
                     Bounds  region,
                     float   priority,
                     float posX, float posY, float posZ,
                     float[] frontDistance,
                     float[] frontDistanceGain,
                     float[] backDistance,
                     float[] backDistanceGain,
                     float dirX, float dirY, float dirZ,
                     float[] angle,
                     float[] angularGain,
                     float[] frequencyCutoff) {
        super(soundData, initialGain, loopCount, release, continuous, enable,
                     region, priority, posX, posY, posZ, 
                     frontDistance, frontDistanceGain );

        // set default read capabilities
        setDefaultReadCapabilities(readCapabilities);

        ((ConeSoundRetained)this.retained).setBackDistanceGain(
                     backDistance, backDistanceGain );
        ((ConeSoundRetained)this.retained).setDirection(dirX, dirY, dirZ);
        ((ConeSoundRetained)this.retained).setAngularAttenuation(angle,
                     angularGain, frequencyCutoff);
    }

    /**
     * Creates the retained mode ConeSoundRetained object that this
     * ConeSound object will point to.
     */
    void createRetained() {
	this.retained = new ConeSoundRetained();
	this.retained.setSource(this);
    }

    //
    // OVERLOADED Sound methods
    //
    /**
     * Sets this sound's distance gain elliptical attenuation - 
     * where gain scale factor is applied to sound based on distance listener
     * is from sound source.
     * @param frontAttenuation defined by pairs of (distance,gain-scale-factor)
     * @param backAttenuation defined by pairs of (distance,gain-scale-factor)
     * @exception CapabilityNotSetException if appropriate capability is
     * not set and this object is part of live or compiled scene graph
     */  
    public void setDistanceGain(Point2f[] frontAttenuation,
                                      Point2f[] backAttenuation ) {
        if (isLiveOrCompiled())
            if(!this.getCapability(ALLOW_DISTANCE_GAIN_WRITE))
                throw new CapabilityNotSetException(J3dI18N.getString("ConeSound0"));
  
        ((ConeSoundRetained)this.retained).setDistanceGain(frontAttenuation,
                             backAttenuation);
    }

    /**
     * Sets this sound's distance gain attenuation as an array of Point2fs.
     * @param frontDistance array of monotonically-increasing floats
     * @param frontGain array of non-negative scale factors
     * @param backDistance array of monotonically-increasing floats
     * @param backGain array of non-negative scale factors
     * @exception CapabilityNotSetException if appropriate capability is
     * not set and this object is part of live or compiled scene graph
     */  
    public void setDistanceGain(float[] frontDistance, float[] frontGain,
                                      float[] backDistance, float[] backGain) {
        if (isLiveOrCompiled())
            if(!this.getCapability(ALLOW_DISTANCE_GAIN_WRITE))
                throw new CapabilityNotSetException(J3dI18N.getString("ConeSound0"));
  
        ((ConeSoundRetained)this.retained).setDistanceGain(
                 frontDistance, frontGain, backDistance, backGain);
    }

    /**
     * Sets this sound's back distance gain attenuation - where gain scale 
     * factor is applied to sound based on distance listener along the negative
     * sound direction axis from sound source.
     * @param attenuation defined by pairs of (distance,gain-scale-factor)
     * @exception CapabilityNotSetException if appropriate capability is
     * not set and this object is part of live or compiled scene graph
     */  
    public void setBackDistanceGain(Point2f[] attenuation) {
        if (isLiveOrCompiled())
            if(!this.getCapability(ALLOW_DISTANCE_GAIN_WRITE))
                throw new CapabilityNotSetException(J3dI18N.getString("ConeSound0"));
  
        ((ConeSoundRetained)this.retained).setBackDistanceGain(attenuation);
    }

    /**
     * Sets this sound's back distance gain attenuation as separate arrays.
     * @param distance array of monotonically-increasing floats
     * @param gain array of non-negative scale factors
     * @exception CapabilityNotSetException if appropriate capability is
     * not set and this object is part of live or compiled scene graph
     */  
    public void setBackDistanceGain(float[] distance, float[] gain) {
        if (isLiveOrCompiled())
            if(!this.getCapability(ALLOW_DISTANCE_GAIN_WRITE))
                throw new CapabilityNotSetException(J3dI18N.getString("ConeSound0"));
  
        ((ConeSoundRetained)this.retained).setBackDistanceGain(distance, gain);
    }

    /**
     * Gets this sound's elliptical distance attenuation. The
     * attenuation values are copied into the specified arrays.