com.threerings.openal.Source Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of nenya Show documentation
Facilities for making networked multiplayer games.
The newest version!
//
// Nenya library - tools for developing networked games
// Copyright (C) 2002-2012 Three Rings Design, Inc., All Rights Reserved
// https://github.com/threerings/nenya
//
// This library is free software; you can redistribute it and/or modify it
// under the terms of the GNU Lesser General Public License as published
// by the Free Software Foundation; either version 2.1 of the License, or
// (at your option) any later version.
//
// This library 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
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

package com.threerings.openal;

import java.util.ArrayList;

import java.nio.IntBuffer;

import org.lwjgl.BufferUtils;
import org.lwjgl.openal.AL10;
import org.lwjgl.openal.AL11;

import com.google.common.collect.Lists;

/**
 * Represents an OpenAL source object.
 */
public class Source
{
    /**
     * Creates a new source for the specified sound manager.
     */
    public Source (SoundManager soundmgr)
    {
        _soundmgr = soundmgr;
        IntBuffer idbuf = BufferUtils.createIntBuffer(1);
        AL10.alGenSources(idbuf);
        _id = idbuf.get(0);
    }

    /**
     * Returns this source's OpenAL identifier.
     */
    public final int getId ()
    {
        return _id;
    }

    /**
     * Sets the position of the source.
     */
    public void setPosition (float x, float y, float z)
    {
        if (_px != x || _py != y || _pz != z) {
            AL10.alSource3f(_id, AL10.AL_POSITION, _px = x, _py = y, _pz = z);
        }
    }

    /**
     * Sets the velocity of the source.
     */
    public void setVelocity (float x, float y, float z)
    {
        if (_vx != x || _vy != y || _vz != z) {
            AL10.alSource3f(_id, AL10.AL_VELOCITY, _vx = x, _vy = y, _vz = z);
        }
    }

    /**
     * Sets the gain of the source.
     */
    public void setGain (float gain)
    {
        if (_gain != gain) {
            AL10.alSourcef(_id, AL10.AL_GAIN, _gain = gain);
        }
    }

    /**
     * Sets whether or not the position, velocity, etc., of the source are relative to the
     * listener.
     */
    public void setSourceRelative (boolean relative)
    {
        if (_sourceRelative != relative) {
            _sourceRelative = relative;
            AL10.alSourcei(_id, AL10.AL_SOURCE_RELATIVE, relative ? AL10.AL_TRUE : AL10.AL_FALSE);
        }
    }

    /**
     * Sets whether or not the source is looping.
     */
    public void setLooping (boolean looping)
    {
        if (_looping != looping) {
            _looping = looping;
            AL10.alSourcei(_id, AL10.AL_LOOPING, looping ? AL10.AL_TRUE : AL10.AL_FALSE);
        }
    }

    /**
     * Sets the minimum gain.
     */
    public void setMinGain (float gain)
    {
        if (_minGain != gain) {
            AL10.alSourcef(_id, AL10.AL_MIN_GAIN, _minGain = gain);
        }
    }

    /**
     * Sets the maximum gain.
     */
    public void setMaxGain (float gain)
    {
        if (_maxGain != gain) {
            AL10.alSourcef(_id, AL10.AL_MAX_GAIN, _maxGain = gain);
        }
    }

    /**
     * Sets the reference distance for attenuation.
     */
    public void setReferenceDistance (float distance)
    {
        if (_referenceDistance != distance) {
            AL10.alSourcef(_id, AL10.AL_REFERENCE_DISTANCE, _referenceDistance = distance);
        }
    }

    /**
     * Sets the rolloff factor for attenuation.
     */
    public void setRolloffFactor (float rolloff)
    {
        if (_rolloffFactor != rolloff) {
            AL10.alSourcef(_id, AL10.AL_ROLLOFF_FACTOR, _rolloffFactor = rolloff);
        }
    }

    /**
     * Sets the maximum distance for attenuation.
     */
    public void setMaxDistance (float distance)
    {
        if (_maxDistance != distance) {
            AL10.alSourcef(_id, AL10.AL_MAX_DISTANCE, _maxDistance = distance);
        }
    }

    /**
     * Sets the pitch multiplier.
     */
    public void setPitch (float pitch)
    {
        if (_pitch != pitch) {
            AL10.alSourcef(_id, AL10.AL_PITCH, _pitch = pitch);
        }
    }

    /**
     * Sets the direction of the source.
     */
    public void setDirection (float x, float y, float z)
    {
        if (_dx != x || _dy != y || _dz != z) {
            AL10.alSource3f(_id, AL10.AL_DIRECTION, _dx = x, _dy = y, _dz = z);
        }
    }

    /**
     * Sets the inside angle of the sound cone.
     */
    public void setConeInnerAngle (float angle)
    {
        if (_coneInnerAngle != angle) {
            AL10.alSourcef(_id, AL10.AL_CONE_INNER_ANGLE, _coneInnerAngle = angle);
        }
    }

    /**
     * Sets the outside angle of the sound cone.
     */
    public void setConeOuterAngle (float angle)
    {
        if (_coneOuterAngle != angle) {
            AL10.alSourcef(_id, AL10.AL_CONE_OUTER_ANGLE, _coneOuterAngle = angle);
        }
    }

    /**
     * Sets the gain outside of the sound cone.
     */
    public void setConeOuterGain (float gain)
    {
        if (_coneOuterGain != gain) {
            AL10.alSourcef(_id, AL10.AL_CONE_OUTER_GAIN, _coneOuterGain = gain);
        }
    }

    /**
     * Sets the source buffer.  Equivalent to unqueueing all buffers, then queuing the provided
     * buffer.  Cannot be called when the source is playing or paused.
     *
     * @param buffer the buffer to set, or null to clear.
     */
    public void setBuffer (Buffer buffer)
    {
        _queue.clear();
        if (buffer != null) {
            _queue.add(buffer);
        }
        AL10.alSourcei(_id, AL10.AL_BUFFER, buffer == null ? AL10.AL_NONE : buffer.getId());
    }

    /**
     * Enqueues the specified buffers.
     */
    public void queueBuffers (Buffer... buffers)
    {
        IntBuffer idbuf = BufferUtils.createIntBuffer(buffers.length);
        for (int ii = 0; ii < buffers.length; ii++) {
            Buffer buffer = buffers[ii];
            _queue.add(buffer);
            idbuf.put(ii, buffer.getId());
        }
        AL10.alSourceQueueBuffers(_id, idbuf);
    }

    /**
     * Removes the specified buffers from the queue.
     */
    public void unqueueBuffers (Buffer... buffers)
    {
        IntBuffer idbuf = BufferUtils.createIntBuffer(buffers.length);
        for (int ii = 0; ii < buffers.length; ii++) {
            Buffer buffer = buffers[ii];
            _queue.remove(buffer);
            idbuf.put(ii, buffer.getId());
        }
        AL10.alSourceUnqueueBuffers(_id, idbuf);
    }

    /**
     * Determines whether the source is playing.
     */
    public boolean isPlaying ()
    {
        return getSourceState() == AL10.AL_PLAYING;
    }

    /**
     * Determines whether the source is paused.
     */
    public boolean isPaused ()
    {
        return getSourceState() == AL10.AL_PAUSED;
    }

    /**
     * Determines whether the source is stopped.
     */
    public boolean isStopped ()
    {
        return getSourceState() == AL10.AL_STOPPED;
    }

    /**
     * Returns the state of the source: {@link AL10#AL_INITIAL}, {@link AL10#AL_PLAYING},
     * {@link AL10#AL_PAUSED}, or {@link AL10#AL_STOPPED}.
     */
    public int getSourceState ()
    {
        return AL10.alGetSourcei(_id, AL10.AL_SOURCE_STATE);
    }

    /**
     * Returns the number of buffers that have been processed.
     */
    public int getBuffersProcessed ()
    {
        return AL10.alGetSourcei(_id, AL10.AL_BUFFERS_PROCESSED);
    }

    /**
     * Returns the position offset of the source within the queued buffers, in seconds.
     */
    public float getSecOffset ()
    {
        return AL10.alGetSourcef(_id, AL11.AL_SEC_OFFSET);
    }

    /**
     * Returns the position offset of the source within the queued buffers, in samples.
     */
    public int getSampleOffset ()
    {
        return AL10.alGetSourcei(_id, AL11.AL_SAMPLE_OFFSET);
    }

    /**
     * Returns the position offset of the source within the queued buffers, in bytes.
     */
    public int getByteOffset ()
    {
        return AL10.alGetSourcei(_id, AL11.AL_BYTE_OFFSET);
    }

    /**
     * Starts playing the source.
     */
    public void play ()
    {
        AL10.alSourcePlay(_id);
    }

    /**
     * Pauses the source.
     */
    public void pause ()
    {
        AL10.alSourcePause(_id);
    }

    /**
     * Stops the source.
     */
    public void stop ()
    {
        AL10.alSourceStop(_id);
    }

    /**
     * Rewinds the source.
     */
    public void rewind ()
    {
        AL10.alSourceRewind(_id);
    }

    /**
     * Deletes this source, rendering it unusable.
     */
    public void delete ()
    {
        IntBuffer idbuf = BufferUtils.createIntBuffer(1);
        idbuf.put(_id).rewind();
        AL10.alDeleteSources(idbuf);
        _id = 0;
        _queue.clear();
    }

    @Override
    protected void finalize ()
        throws Throwable
    {
        super.finalize();
        if (_id > 0) {
            _soundmgr.sourceFinalized(_id);
        }
    }

    /** The sound manager responsible for this source. */
    protected SoundManager _soundmgr;

    /** The OpenAL identifier for this source. */
    protected int _id;

    /** The position of the source. */
    protected float _px, _py, _pz;

    /** The velocity of the source. */
    protected float _vx, _vy, _vz;

    /** The gain of the source. */
    protected float _gain = 1f;

    /** Whether or not the source's position, velocity, etc. are relative to the listener. */
    protected boolean _sourceRelative;

    /** Whether or not the source is looping. */
    protected boolean _looping;

    /** The minimum gain. */
    protected float _minGain;

    /** The maximum gain. */
    protected float _maxGain = 1f;

    /** The reference distance for attenuation. */
    protected float _referenceDistance = 1f;

    /** The attenuation rolloff factor. */
    protected float _rolloffFactor = 1f;

    /** The maximum distance for attenuation. */
    protected float _maxDistance = Float.MAX_VALUE;

    /** The pitch multiplier. */
    protected float _pitch = 1f;

    /** The direction of the source. */
    protected float _dx, _dy, _dz;

    /** The inside angle of the sound cone. */
    protected float _coneInnerAngle = 360f;

    /** The outside angle of the sound cone. */
    protected float _coneOuterAngle = 360f;

    /** The gain outside the sound cone. */
    protected float _coneOuterGain;

    /** The source's queue of buffers (storing them keeps them from being garbage-collected). */
    protected ArrayList _queue = Lists.newArrayList();
}