1041 lines
36 KiB
C
1041 lines
36 KiB
C
|
/* irrKlang.h -- interface of the 'irrKlang' library
|
||
|
|
||
|
Copyright (C) 2002-2018 Nikolaus Gebhardt
|
||
|
|
||
|
This software is provided 'as-is', without any express or implied
|
||
|
warranty. In no event will the authors be held liable for any damages
|
||
|
arising from the use of this software.
|
||
|
*/
|
||
|
|
||
|
#ifndef __IRR_KLANG_H_INCLUDED__
|
||
|
#define __IRR_KLANG_H_INCLUDED__
|
||
|
|
||
|
#include "ik_irrKlangTypes.h"
|
||
|
#include "ik_vec3d.h"
|
||
|
|
||
|
#include "ik_IRefCounted.h"
|
||
|
#include "ik_IVirtualRefCounted.h"
|
||
|
|
||
|
#include "ik_ESoundOutputDrivers.h"
|
||
|
#include "ik_ESoundEngineOptions.h"
|
||
|
#include "ik_EStreamModes.h"
|
||
|
#include "ik_SAudioStreamFormat.h"
|
||
|
#include "ik_ISoundEngine.h"
|
||
|
#include "ik_ISoundSource.h"
|
||
|
#include "ik_ISound.h"
|
||
|
#include "ik_IAudioStream.h"
|
||
|
#include "ik_IAudioStreamLoader.h"
|
||
|
#include "ik_ISoundEffectControl.h"
|
||
|
#include "ik_ISoundStopEventReceiver.h"
|
||
|
#include "ik_IFileFactory.h"
|
||
|
#include "ik_IFileReader.h"
|
||
|
#include "ik_ISoundDeviceList.h"
|
||
|
#include "ik_IAudioRecorder.h"
|
||
|
#include "ik_ISoundMixedOutputReceiver.h"
|
||
|
|
||
|
//! irrKlang Version
|
||
|
#define IRR_KLANG_VERSION "1.6.0"
|
||
|
|
||
|
/*! \mainpage irrKlang 1.6.0 API documentation
|
||
|
*
|
||
|
* <div align="center"><img src="logobig.png" ></div>
|
||
|
|
||
|
* \section contents Contents
|
||
|
* General:<br/>
|
||
|
* @ref intro <br/>
|
||
|
* @ref features <br/>
|
||
|
* @ref links <br/>
|
||
|
* @ref tipsandtricks <br/>
|
||
|
* <br/>
|
||
|
* Programming irrKlang:<br/>
|
||
|
* @ref concept <br/>
|
||
|
* @ref playingSounds <br/>
|
||
|
* @ref changingSounds <br/>
|
||
|
* @ref soundSources <br/>
|
||
|
* @ref sound3d <br/>
|
||
|
* @ref removingSounds <br/>
|
||
|
* @ref events <br/>
|
||
|
* @ref memoryPlayback <br/>
|
||
|
* @ref effects <br/>
|
||
|
* @ref fileOverriding <br/>
|
||
|
* @ref audioDecoders <br/>
|
||
|
* @ref plugins <br/>
|
||
|
* @ref staticLib <br/>
|
||
|
* @ref enumeratingDevices <br/>
|
||
|
* @ref recordingAudio <br/>
|
||
|
* @ref unicode <br/>
|
||
|
* <br/>
|
||
|
* Short full examples:<br/>
|
||
|
* @ref quickstartexample <br/>
|
||
|
* @ref quickstartexample2 <br/>
|
||
|
* <br/>
|
||
|
* <br/>
|
||
|
*
|
||
|
* \section intro Introduction
|
||
|
*
|
||
|
* Welcome to the irrKlang API documentation. This page should give you a short overview
|
||
|
* over irrKlang, the high level audio library.
|
||
|
* In this documentation files you'll find any information you'll need to develop applications with
|
||
|
* irrKlang using C++. If you are looking for a tutorial on how to start, you'll
|
||
|
* find some on the homepage of irrKlang at
|
||
|
* <A HREF="http://www.ambiera.com/irrklang" >http://www.ambiera.com/irrklang</A>
|
||
|
* or inside the SDK in the directory \examples.
|
||
|
*
|
||
|
* The irrKlang library is intended to be an easy-to-use 3d and 2d sound engine, so
|
||
|
* this documentation is an important part of it. If you have any questions or
|
||
|
* suggestions, please take a look into the ambiera.com forum or just send a mail.
|
||
|
*
|
||
|
* <br/>
|
||
|
* <br/>
|
||
|
*
|
||
|
*
|
||
|
* \section features Features of irrKlang
|
||
|
*
|
||
|
* irrKlang is a high level 2D and 3D
|
||
|
* cross platform sound engine and audio library.
|
||
|
* It has a very simply object orientated interface and was designed to be used
|
||
|
* in games, scientific simulations, architectural visualizations and similar.
|
||
|
* irrKlang plays several file formats such as
|
||
|
* <ul>
|
||
|
* <li>RIFF WAVE (*.wav)</li>
|
||
|
* <li>Ogg Vorbis (*.ogg)</li>
|
||
|
* <li>MPEG-1 Audio Layer 3 (*.mp3)</li>
|
||
|
* <li>Free Lossless Audio Codec (*.flac)</li>
|
||
|
* <li>Amiga Modules (*.mod)</li>
|
||
|
* <li>Impulse Tracker (*.it)</li>
|
||
|
* <li>Scream Tracker 3 (*.s3d)</li>
|
||
|
* <li>Fast Tracker 2 (*.xm)</li>
|
||
|
* </ul>
|
||
|
* It is also able to run on different operating systems and use several output drivers:
|
||
|
*<ul>
|
||
|
* <li>Windows 98, ME, NT 4, 2000, XP, Vista, Windows 7, Windows 8</li>
|
||
|
* <ul>
|
||
|
* <li>DirectSound</li>
|
||
|
* <li>DirectSound8</li>
|
||
|
* <li>WinMM</li>
|
||
|
* </ul>
|
||
|
* <li>Linux / *nix</li>
|
||
|
* <ul>
|
||
|
* <li>ALSA</li>
|
||
|
* </ul>
|
||
|
* <li>MacOSX (x86 and PPC)</li>
|
||
|
* <ul>
|
||
|
* <li>CoreAudio</li>
|
||
|
* </ul>
|
||
|
* </ul>
|
||
|
* <br/>
|
||
|
* <br/>
|
||
|
* <br/>
|
||
|
*
|
||
|
*
|
||
|
*
|
||
|
* \section links Links into the API documentation
|
||
|
*
|
||
|
* irrklang::ISoundEngine: The main class of irrKlang.<br/>
|
||
|
* <A HREF="annotated.html">Class list</A>: List of all classes with descriptions.<BR/>
|
||
|
* <A HREF="functions.html">Class members</A>: Good place to find forgotten features.<BR/>
|
||
|
* <br/>
|
||
|
* <br/>
|
||
|
* <br/>
|
||
|
*
|
||
|
*
|
||
|
*
|
||
|
* \section tipsandtricks Tips and Tricks
|
||
|
*
|
||
|
* This section lists a few tips you might consider when implementing the sound part of your application
|
||
|
* using irrKlang:
|
||
|
*
|
||
|
* <ul>
|
||
|
* <li>If you can choose which audio file format is the primary one for your application,
|
||
|
* use .OGG files, instead of for example .MP3 files. irrKlang uses a lot less memory
|
||
|
* and CPU power when playing .OGGs.</li>
|
||
|
* <li>To keep your application simple, each time you play a sound, you can use for example
|
||
|
* play2D("filename.mp3") and let irrKlang handle the rest. There is no need to implement
|
||
|
* a preloading/caching/file management system for the audio playback. irrKlang will handle
|
||
|
* all this by itself and will never load a file twice. </li>
|
||
|
* <li>irrKlang is crashing in your application? This should not happen, irrKlang is pretty stable,
|
||
|
* and in most cases, this is a problem in your code: In a lot of cases the reason is simply
|
||
|
* a wrong call to irrklang::IRefCounted::drop(). Be sure you are doing it correctly. (If you are unsure,
|
||
|
* tempoarily remove all calls to irrklang::IRefCounted::drop() and see if this helps.)</li>
|
||
|
* </ul>
|
||
|
*
|
||
|
* <br/>
|
||
|
* <br/>
|
||
|
* <br/>
|
||
|
* <br/>
|
||
|
*
|
||
|
*
|
||
|
*
|
||
|
* \section concept Starting up the Engine
|
||
|
*
|
||
|
* irrKlang is designed so that it is very easy to achieve everything, its interface should
|
||
|
* be very simple to use. The @ref quickstartexample shows how to play and mp3 file, and there
|
||
|
* is another example, @ref quickstartexample2, showing some few more details.<br/>
|
||
|
* To start up the sound engine, you simply need to call createIrrKlangDevice(). To shut it down,
|
||
|
* call IRefCounted::drop():
|
||
|
*
|
||
|
* \code
|
||
|
* #include <irrKlang.h>
|
||
|
*
|
||
|
* // ...
|
||
|
*
|
||
|
* // start up the engine
|
||
|
* irrklang::ISoundEngine* engine = irrklang::createIrrKlangDevice();
|
||
|
*
|
||
|
* // ...
|
||
|
*
|
||
|
* // after finished,
|
||
|
* // close the engine again, similar as calling 'delete'
|
||
|
* engine->drop();
|
||
|
* \endcode
|
||
|
*
|
||
|
* The createIrrKlangDevice() function also accepts several parameters, so that you can
|
||
|
* specify which sound driver should be used, if plugins should be used, if irrKlang
|
||
|
* should run in multithreaded mode, and similar.
|
||
|
* <br/>
|
||
|
* <br/>
|
||
|
* <br/>
|
||
|
* <br/>
|
||
|
*
|
||
|
*
|
||
|
*
|
||
|
* \section playingSounds Playing Sounds
|
||
|
*
|
||
|
* Once you have irrKlang running (like in @ref concept), you can start playing sounds:
|
||
|
*
|
||
|
* \code
|
||
|
* engine->play2D("someSoundFile.wav");
|
||
|
* \endcode
|
||
|
*
|
||
|
* This works with all supported file types. You can replace "someSoundFile.wav" with
|
||
|
* "someSoundFile.mp3", or "someSoundFile.ogg", for example.<br/>
|
||
|
* To play a sound looped, set the second parameter to 'true':
|
||
|
*
|
||
|
* \code
|
||
|
* engine->play2D("myMusic.mp3", true);
|
||
|
* \endcode
|
||
|
*
|
||
|
* To stop this looping sound again, use engine->\link irrklang::ISoundEngine::stopAllSounds stopAllSounds()\endlink to stop all sounds, or
|
||
|
* irrklang::ISound::stop() if you only want to stop that single sound. @ref changingSounds
|
||
|
* shows how to get to that ISound interface.
|
||
|
* <br/>
|
||
|
* <br/>
|
||
|
* <br/>
|
||
|
* <br/>
|
||
|
*
|
||
|
*
|
||
|
* \section changingSounds Influencing Sounds during Playback
|
||
|
* To influence parameters of the sound such as pan, volume or playback speed during runtime,
|
||
|
* to get the play position or stop playback of single playing sounds,
|
||
|
* you can use the irrklang::ISound interface.
|
||
|
* irrklang::ISoundEngine::play2D (but also play3D) returns
|
||
|
* a pointer to this interface when its third ('startPaused') or fourth ('track') parameter
|
||
|
* was set to true:
|
||
|
*
|
||
|
* \code
|
||
|
* irrklang::ISound* snd = engine->play2D("myMusic.mp3", true, false, true);
|
||
|
*
|
||
|
* // ...
|
||
|
*
|
||
|
* if (snd)
|
||
|
* snd->setVolume(someNewValue);
|
||
|
*
|
||
|
* // ...
|
||
|
*
|
||
|
* if (snd)
|
||
|
* {
|
||
|
* snd->drop(); // don't forget to release the pointer once it is no longer needed by you
|
||
|
* snd = 0;
|
||
|
* }
|
||
|
* \endcode
|
||
|
*
|
||
|
* The irrklang::ISound interface can also be used to test if the sound has been finished,
|
||
|
* set event receivers, pause and unpause sounds and similar.
|
||
|
* <br/>
|
||
|
* <br/>
|
||
|
* <br/>
|
||
|
* <br/>
|
||
|
*
|
||
|
*
|
||
|
* \section soundSources Using Sound Sources
|
||
|
*
|
||
|
* To be more flexible playing back sounds, irrKlang uses the concept of sound sources.
|
||
|
* A sound source can be simply the name of a sound file, such as "sound.wav". It is possible
|
||
|
* to add "sound.wav" as sound source to irrKlang, and play it using the sound source pointer:
|
||
|
*
|
||
|
* \code
|
||
|
* irrklang::ISoundSource* shootSound = engine->addSoundSourceFromFile("shoot.wav");
|
||
|
*
|
||
|
* engine->play2D(shootSound);
|
||
|
*
|
||
|
* // note: you don't need to drop() the shootSound if you don't use it anymore
|
||
|
* \endcode
|
||
|
*
|
||
|
* The advantage of using irrklang::ISoundSource is that it is possible to set
|
||
|
* default values for this source, such
|
||
|
* as volume or distances if it should be used as 3D sound:
|
||
|
*
|
||
|
* \code
|
||
|
* irrklang::ISoundSource* shootSound = engine->addSoundSourceFromFile("shoot.wav");
|
||
|
*
|
||
|
* shootSound->setDefaultVolume(0.5f);
|
||
|
*
|
||
|
* // shootSound will now be played with half its sound volume by default:
|
||
|
* engine->play2D(shootSound);
|
||
|
* \endcode
|
||
|
*
|
||
|
* It is also possible to have multiple settings for the same sound file:
|
||
|
*
|
||
|
* \code
|
||
|
* irrklang::ISoundSource* shootSound = engine->addSoundSourceFromFile("shoot.wav");
|
||
|
* irrklang::ISoundSource* shootSound2 = engine->addSoundSourceAlias(shootSound, "silentShoot");
|
||
|
*
|
||
|
* shootSound2->setDefaultVolume(0.1f);
|
||
|
*
|
||
|
* // shootSound will now be played with 100% of its sound volume by default,
|
||
|
* // shootSound2 will now be played 10% of its sound volume by default. It is
|
||
|
* // also possible to play it using engine->play("silentShoot"), now.
|
||
|
* \endcode
|
||
|
*
|
||
|
* Using addSoundSourceFromMemory(), it is also possible to play sounds back directly from memory,
|
||
|
* without files.
|
||
|
* Of course, it is not necessary to use sound sources. Using irrklang::ISound, it is
|
||
|
* possible to change the settings of all sounds, too. But using sound sources, it is
|
||
|
* not necessary to do this every time a sound is played.
|
||
|
* <br/>
|
||
|
* <br/>
|
||
|
* <br/>
|
||
|
* <br/>
|
||
|
*
|
||
|
*
|
||
|
*
|
||
|
* \section sound3d 3D Sound
|
||
|
*
|
||
|
* There is nothing difficult in playing sounds in 3D using irrKlang: Instead of using
|
||
|
* irrklang::ISoundEngine::play2D(), just use irrklang::ISoundEngine::play3D(), which
|
||
|
* takes a 3D position as additional parameter:
|
||
|
*
|
||
|
* \code
|
||
|
* irrklang::vec3df position(23,70,90);
|
||
|
* engine->play3D("yourSound.wav", position);
|
||
|
* \endcode
|
||
|
*
|
||
|
* But to make it sound realistic, you need to set a minimal sound
|
||
|
* distance: If your sound is caused by a bee, it will usually have a smaller
|
||
|
* sound radius than for example a jet engine. You can set default values using sound sources
|
||
|
* (see @ref soundSources) or set these values after you have started the sound paused:
|
||
|
*
|
||
|
* \code
|
||
|
* irrklang::vec3df position(23,70,90);
|
||
|
*
|
||
|
* // start the sound paused:
|
||
|
* irrklang::ISound* snd = engine->play3D("yourSound.wav", position, false, true);
|
||
|
*
|
||
|
* if (snd)
|
||
|
* {
|
||
|
* snd->setMinDistance(30.0f); // a loud sound
|
||
|
* snd->setIsPaused(false); // unpause the sound
|
||
|
* }
|
||
|
* \endcode
|
||
|
*
|
||
|
* There is also the possibility to change the maxDistance, but it is only necessary to change this
|
||
|
* in very rare cicumstances.
|
||
|
* If the sound moves, it is also a good idea to update its position from time to time:
|
||
|
*
|
||
|
* \code
|
||
|
* if (snd)
|
||
|
* snd->setPosition(newPosition);
|
||
|
* \endcode
|
||
|
*
|
||
|
* And don't forget to drop() the sound after you don't need it anymore. If you do, it's
|
||
|
* nothing severe because irrKlang will still clean up the sounds resources after it has
|
||
|
* finished, but you still would waste some few bytes of memory:
|
||
|
*
|
||
|
* \code
|
||
|
* if (snd)
|
||
|
* {
|
||
|
* snd->drop();
|
||
|
* snd = 0;
|
||
|
* }
|
||
|
* \endcode
|
||
|
*
|
||
|
* To update the position of yourself, the listener of the 3D sounds, use this from
|
||
|
* time to time:
|
||
|
*
|
||
|
* \code
|
||
|
* irrklang::vec3df position(0,0,0); // position of the listener
|
||
|
* irrklang::vec3df lookDirection(10,0,10); // the direction the listener looks into
|
||
|
* irrklang::vec3df velPerSecond(0,0,0); // only relevant for doppler effects
|
||
|
* irrklang::vec3df upVector(0,1,0); // where 'up' is in your 3D scene
|
||
|
*
|
||
|
* engine->setListenerPosition(position, lookDirection, velPerSecond, upVector);
|
||
|
* \endcode
|
||
|
*
|
||
|
* <br/>
|
||
|
* <br/>
|
||
|
* <br/>
|
||
|
* <br/>
|
||
|
*
|
||
|
*
|
||
|
* \section removingSounds Removing Sounds
|
||
|
*
|
||
|
* irrKlang manages the memory usage of sounds by itself, so usually, you don't have
|
||
|
* to care about memory management. But if you know you need to reduce the
|
||
|
* amount of used memory at a certain point in your program, you can do this:
|
||
|
*
|
||
|
* \code
|
||
|
* engine->removeAllSoundSources();
|
||
|
* \endcode
|
||
|
*
|
||
|
* This will remove all sounds and also cause all sounds to be stopped. To remove single
|
||
|
* sounds from the engine, use:
|
||
|
*
|
||
|
* \code
|
||
|
* engine->removeSoundSource(pointerToSomeSoundSource);
|
||
|
* // or:
|
||
|
* engine->removeSoundSource("nameOfASoundFile.wav");
|
||
|
* \endcode
|
||
|
*
|
||
|
* Note: Only removing buffered sounds will reduce the amount of memory used by irrKlang, streamed
|
||
|
* sounds don't occupy a lot of memory when they are not played.
|
||
|
* <br/>
|
||
|
* <br/>
|
||
|
* <br/>
|
||
|
* <br/>
|
||
|
*
|
||
|
*
|
||
|
*
|
||
|
* \section events Using Sound Events
|
||
|
*
|
||
|
* In order to wait for a sound to be finished, it is simply possible to
|
||
|
* poll irrklang::ISound::isFinished(). Another way would be to constantly use
|
||
|
* irrklang::ISoundEngine::isCurrentlyPlaying to test wether a sound with that name or source
|
||
|
* is currently playing. But of course, an event based approach is a lot nicer. That's why irrKlang
|
||
|
* supports sound events.<br/>
|
||
|
* The key to sound events is the method
|
||
|
* \link irrklang::ISound::setSoundStopEventReceiver setSoundStopEventReceiver \endlink
|
||
|
* of the irrklang::ISound interface
|
||
|
* (See @ref changingSounds on how to get the ISound interface):
|
||
|
*
|
||
|
* \code
|
||
|
* irrklang::ISound* snd = engine->play2D("speech.mp3", false, false, true);
|
||
|
* if (snd)
|
||
|
* snd->setSoundStopEventReceiver(yourEventReceiver, 0);
|
||
|
* \endcode
|
||
|
*
|
||
|
* The optional second parameter of setSoundStopEventReceiver is a user pointer, set it to whatever you like.
|
||
|
* 'yourEventReceiver' must be an implementation of the irrklang::ISoundStopEventReceiver interface.<br/>
|
||
|
* A whole implementation could look like this:
|
||
|
*
|
||
|
* \code
|
||
|
* class MySoundEndReceiver : public irrklang::ISoundStopEventReceiver
|
||
|
* {
|
||
|
* public:
|
||
|
* virtual void OnSoundStopped (irrklang::ISound* sound, irrklang::E_STOP_EVENT_CAUSE reason, void* userData)
|
||
|
* {
|
||
|
* // called when the sound has ended playing
|
||
|
* printf("sound has ended");
|
||
|
* }
|
||
|
* }
|
||
|
*
|
||
|
* // ...
|
||
|
*
|
||
|
* MySoundEndReceiver* myReceiver = new MySoundEndReceiver();
|
||
|
* irrklang::ISound* snd = engine->play2D("speech.mp3", false, false, true);
|
||
|
* if (snd)
|
||
|
* snd->setSoundStopEventReceiver(myReceiver);
|
||
|
*
|
||
|
* myReceiver->drop(); // similar to delete
|
||
|
* \endcode
|
||
|
*
|
||
|
* The irrklang::ISoundStopEventReceiver::OnSoundStopped() method is guaranteed to be called when a sound or sound stream has stopped,
|
||
|
* either because the sound reached its playback end, its sound source was removed,
|
||
|
* ISoundEngine::stopAllSounds() has been called or the whole engine was deleted.
|
||
|
* <br/>
|
||
|
* <br/>
|
||
|
* <br/>
|
||
|
* <br/>
|
||
|
*
|
||
|
*
|
||
|
*
|
||
|
* \section memoryPlayback Memory Playback
|
||
|
*
|
||
|
* Using irrKlang, it is easily possible to play sounds directly from memory instead out of
|
||
|
* files. There is an example project showing this: In the SDK, in /examples/03.MemoryPlayback.
|
||
|
* But in short, it simply works by adding the memory as sound source (See @ref soundSources for
|
||
|
* details about sound sources):
|
||
|
*
|
||
|
* \code
|
||
|
* engine->addSoundSourceFromMemory(pointerToMemory, memorySize, "nameforthesound.wav");
|
||
|
*
|
||
|
* // play sound now
|
||
|
* engine->play2D("nameforthesound.wav");
|
||
|
* \endcode
|
||
|
*
|
||
|
* Or using a sound source pointer:
|
||
|
*
|
||
|
* \code
|
||
|
* irrklang::ISoundSource* snd =
|
||
|
* engine->addSoundSourceFromMemory(pointerToMemory, memorySize, "nameforthesound.wav");
|
||
|
*
|
||
|
* // play sound now
|
||
|
* engine->play2D(snd);
|
||
|
* \endcode
|
||
|
*
|
||
|
* Note: It is also possible to overwrite the file access directly, don't use this Memory Playback
|
||
|
* feature for this. See @ref fileOverriding for details.
|
||
|
* <br/>
|
||
|
* <br/>
|
||
|
* <br/>
|
||
|
* <br/>
|
||
|
*
|
||
|
*
|
||
|
*
|
||
|
* \section effects Sound Effects
|
||
|
*
|
||
|
* irrKlang supports the effects Chorus, Compressor, Distortion, Echo, Flanger
|
||
|
* Gargle, 3DL2Reverb, ParamEq and WavesReverb, when using the sound driver
|
||
|
* irrklang::ESOD_DIRECT_SOUND_8, which selected by default when using Windows.<br/>
|
||
|
*
|
||
|
* Using the irrklang::ISound interface, you can optain the irrklang::ISoundEffectControl
|
||
|
* interface if the sound device supports sound effects and the last parameter ('enableSoundEffects')
|
||
|
* was set to true when calling play2D():
|
||
|
*
|
||
|
* \code
|
||
|
* irrklang::ISound* snd = engine->play2D("sound.wav", true, false, true, ESM_AUTO_DETECT, true);
|
||
|
*
|
||
|
* if (snd)
|
||
|
* {
|
||
|
* irrklang::ISoundEffectControl* fx = snd->getSoundEffectControl();
|
||
|
* if (fx)
|
||
|
* {
|
||
|
* // enable the echo sound effect for this sound
|
||
|
* fx->enableEchoSoundEffect();
|
||
|
* }
|
||
|
* }
|
||
|
*
|
||
|
* snd->drop();
|
||
|
* \endcode
|
||
|
*
|
||
|
* This enabled the echo sound effect for this sound. The method also supports a lot of
|
||
|
* parameters, and can be called multiple times to change those parameters over time if wished.
|
||
|
* There are a lot of other sound effects, see irrklang::ISoundEffectControl for details.
|
||
|
* <br/>
|
||
|
* <br/>
|
||
|
* <br/>
|
||
|
* <br/>
|
||
|
*
|
||
|
*
|
||
|
*
|
||
|
* \section fileOverriding Overriding File Access
|
||
|
*
|
||
|
* It is possible to let irrKlang use your own file access functions.
|
||
|
* This is useful if you want to read sounds from other sources than
|
||
|
* just files, for example from custom internet streams or
|
||
|
* an own encypted archive format. There is an example in the SDK in
|
||
|
* examples/04.OverrideFileAccess which shows this as well.<br/>
|
||
|
*
|
||
|
* The only thing to do for this is to implement your own irrklang::IFileFactory,
|
||
|
* and set it in irrKlang using irrklang::ISoundEngine::addFileFactory():
|
||
|
*
|
||
|
* \code
|
||
|
* // a class implementing the IFileFactory interface to override irrklang file access
|
||
|
* class CMyFileFactory : public irrklang::IFileFactory
|
||
|
* {
|
||
|
* public:
|
||
|
*
|
||
|
* // Opens a file for read access. Simply return 0 if file not found.
|
||
|
* virtual irrklang::IFileReader* createFileReader(const ik_c8* filename)
|
||
|
* {
|
||
|
* // return your own irrklang::IFileReader implementation here, for example like that:
|
||
|
* return new CMyReadFile(filename);
|
||
|
* }
|
||
|
* };
|
||
|
*
|
||
|
* // ...
|
||
|
*
|
||
|
* CMyFileFactory* myFactory = new CMyFileFactory();
|
||
|
* engine->addFileFactory(myFactory);
|
||
|
* myFactory->drop();
|
||
|
* \endcode
|
||
|
*
|
||
|
* For a full example implementation, just take a look into the SDK in examples/04.OverrideFileAccess.
|
||
|
* <br/>
|
||
|
* <br/>
|
||
|
* <br/>
|
||
|
* <br/>
|
||
|
*
|
||
|
*
|
||
|
*
|
||
|
* \section audioDecoders Adding Audio Decoders
|
||
|
*
|
||
|
* To add support for new file formats, it is possible to add new audio decoders
|
||
|
* to irrKlang.
|
||
|
* The only thing to do for this is to implement your own irrklang::IAudioStreamLoader,
|
||
|
* and irrklang::IAudioStream, and set it in irrKlang using
|
||
|
* irrklang::ISoundEngine::registerAudioStreamLoader():
|
||
|
*
|
||
|
* \code
|
||
|
* class NewAudioStreamLoader : public irrklang::IAudioStreamLoader
|
||
|
* {
|
||
|
* // ... returns NewAudioDecoder and the used file name suffices.
|
||
|
* };
|
||
|
*
|
||
|
* class NewAudioDecoder : public irrklang::IAudioStream
|
||
|
* {
|
||
|
* public:
|
||
|
* // ... decodes the new file format
|
||
|
* };
|
||
|
*
|
||
|
* // ...
|
||
|
*
|
||
|
* NewAudioDecoder* loader = new NewAudioDecoder();
|
||
|
* engine->registerAudioStreamLoader(loader);
|
||
|
* loader->drop();
|
||
|
* \endcode
|
||
|
*
|
||
|
* There is an example audio decoder and loader with full source in plugins/ikpMP3, which
|
||
|
* adds MP3 audio decoding capabilities to irrKlang.
|
||
|
* <br/>
|
||
|
* <br/>
|
||
|
* <br/>
|
||
|
* <br/>
|
||
|
*
|
||
|
*
|
||
|
*
|
||
|
* \section plugins Creating irrKlang Plugins
|
||
|
*
|
||
|
* irrKlang plugins are ikp*.dll (Windows), ikp*.so (Unix) or ikp*.dylib (MacOS)
|
||
|
* files which are loaded by irrKlang at startup when the
|
||
|
* irrklang::ESEO_LOAD_PLUGINS was set (which is default) or
|
||
|
* irrklang::ISoundEngine::loadPlugins() was called. <br/>
|
||
|
*
|
||
|
* The plugin only needs to contain the following function which will be called by irrKlang:
|
||
|
*
|
||
|
* \code
|
||
|
* #ifdef WIN32
|
||
|
* // Windows version
|
||
|
* __declspec(dllexport) void __stdcall irrKlangPluginInit(ISoundEngine* engine, const char* version)
|
||
|
* #else
|
||
|
* // Linux and Mac OS version
|
||
|
* void irrKlangPluginInit(ISoundEngine* engine, const char* version)
|
||
|
* #endif
|
||
|
* {
|
||
|
* // your implementation here
|
||
|
* }
|
||
|
* \endcode
|
||
|
*
|
||
|
* In there, it is for example possible to extend irrKlang with new audio decoders,
|
||
|
* see @ref audioDecoders for details. <br/>
|
||
|
*
|
||
|
* There is an example plugin with full source in plugins/ikpMP3, which
|
||
|
* adds MP3 audio decoding capabilities to irrKlang.
|
||
|
* <br/>
|
||
|
* <br/>
|
||
|
* <br/>
|
||
|
* <br/>
|
||
|
*
|
||
|
*
|
||
|
*
|
||
|
* \section staticLib Using irrKlang as static Lib
|
||
|
*
|
||
|
* If you don't want to use the irrKlang.DLL file and link irrKlang statically, you can do this
|
||
|
* by simply linking to the irrKlang.lib in the bin/win32-visualstudio_lib folder. This folder
|
||
|
* will only available in the pro versions of irrKlang, which you get when purchasing an irrKlang
|
||
|
* license.
|
||
|
*
|
||
|
* To use irrKlang in this way, just define IRRKLANG_STATIC before including irrklang.h, like this:
|
||
|
*
|
||
|
* \code
|
||
|
* #define IRRKLANG_STATIC
|
||
|
* #include <irrKlang.h>
|
||
|
* \endcode
|
||
|
*
|
||
|
* Of course, IRRKLANG_STATIC can also simply be defined in the project/compiler settings instead of
|
||
|
* in the source file.
|
||
|
* <br/>
|
||
|
* <br/>
|
||
|
* <br/>
|
||
|
* <br/>
|
||
|
*
|
||
|
*
|
||
|
*
|
||
|
* \section enumeratingDevices Enumerating sound devices
|
||
|
*
|
||
|
* irrKlang uses the default sound device when playing sound when started without parameters. But if you want
|
||
|
* irrKlang to playback sound on one specific sound device, you may want to enumerate the available
|
||
|
* sound devices on your system and select one of them. Use irrklang::createSoundDeviceList() for this.
|
||
|
* This example code shows how to print a list of all available sound devices on the current system and lets
|
||
|
* the user choose one of them:
|
||
|
*
|
||
|
* \code
|
||
|
* int main(int argc, const char** argv)
|
||
|
* {
|
||
|
* // enumerate devices
|
||
|
*
|
||
|
* irrklang::ISoundDeviceList* deviceList = createSoundDeviceList();
|
||
|
*
|
||
|
* // ask user for a sound device
|
||
|
*
|
||
|
* printf("Devices available:\n\n");
|
||
|
*
|
||
|
* for (int i=0; i<deviceList->getDeviceCount(); ++i)
|
||
|
* printf("%d: %s\n", i, deviceList->getDeviceDescription(i));
|
||
|
*
|
||
|
* printf("\nselect a device using the number (or press any key to use default):\n\n");
|
||
|
* int deviceNumber = getch() - '0';
|
||
|
*
|
||
|
* // create device with the selected driver
|
||
|
*
|
||
|
* const char* deviceID = deviceList->getDeviceID(deviceNumber);
|
||
|
*
|
||
|
* ISoundEngine* engine = createIrrKlangDevice(irrklang::ESOD_AUTO_DETECT,
|
||
|
* irrklang::ESEO_DEFAULT_OPTIONS,
|
||
|
* deviceID);
|
||
|
*
|
||
|
* deviceList->drop(); // delete device list
|
||
|
*
|
||
|
* // ... use engine now
|
||
|
* }
|
||
|
* \endcode
|
||
|
*
|
||
|
* In this way, it is also possible to play back sound using two devices at the same time: Simply
|
||
|
* create two irrKlang devices with each a different deviceID.<br/>
|
||
|
* Note: createSoundDeviceList() takes a driver type parameter (such as irrklang::ESOD_DIRECT_SOUND8), which you
|
||
|
* have to set to the same value as the first parameter you want to use with createIrrKlangDevice(), if it is
|
||
|
* other than irrklang::ESOD_AUTO_DETECT.
|
||
|
* <br/>
|
||
|
* <br/>
|
||
|
* <br/>
|
||
|
* <br/>
|
||
|
*
|
||
|
*
|
||
|
*
|
||
|
* \section recordingAudio Recording Audio
|
||
|
*
|
||
|
* irrKlang is able to record audio from sound capturing devices such as microphones (currently only
|
||
|
* supported in windows). Use the irrklang::IAudioRecorder interface to do this. The following example shows how
|
||
|
* to record some audio and play it back again using the engine:
|
||
|
*
|
||
|
* \code
|
||
|
* int main(int argc, const char** argv)
|
||
|
* {
|
||
|
* irrklang::ISoundEngine* engine = irrklang::createIrrKlangDevice();
|
||
|
* irrklang::IAudioRecorder* recorder = irrklang::createIrrKlangAudioRecorder(engine);
|
||
|
*
|
||
|
* if (!engine || !recorder)
|
||
|
* {
|
||
|
* printf("Could not create audio engine or audio recoder\n");
|
||
|
* return 1;
|
||
|
* }
|
||
|
*
|
||
|
* printf("\nPress any key to start recording audio...\n");
|
||
|
* getch();
|
||
|
*
|
||
|
* // record some audio
|
||
|
*
|
||
|
* recorder->startRecordingBufferedAudio();
|
||
|
*
|
||
|
* printf("\nRECORDING. Press any key to stop...\n");
|
||
|
* getch();
|
||
|
*
|
||
|
* recorder->stopRecordingAudio();
|
||
|
*
|
||
|
* printf("\nRecording done, recorded %dms of audio.\n",
|
||
|
* recorder->getAudioFormat().FrameCount * 1000 / recorder->getAudioFormat().SampleRate );
|
||
|
* printf("Press any key to play back recorded audio...\n");
|
||
|
* getch();
|
||
|
*
|
||
|
* // play the recorded audio
|
||
|
* recorder->addSoundSourceFromRecordedAudio("myRecordedVoice");
|
||
|
* engine->play2D("myRecordedVoice", true);
|
||
|
*
|
||
|
* // wait until user presses a key
|
||
|
* printf("\nPress any key to quit...");
|
||
|
* getch();
|
||
|
*
|
||
|
* recorder->drop();
|
||
|
* engine->drop(); // delete engine
|
||
|
*
|
||
|
* return 0;
|
||
|
* }
|
||
|
* \endcode
|
||
|
*
|
||
|
* In order to select a specific audio capturing device for recording, it is necessary to enumerate
|
||
|
* the available devices. Simply replace the first to lines of code of the example above with code
|
||
|
* like this to list all devices and select one:
|
||
|
*
|
||
|
* \code
|
||
|
* // enumerate recording devices and ask user to select one
|
||
|
*
|
||
|
* irrklang::ISoundDeviceList* deviceList = irrklang::createAudioRecorderDeviceList();
|
||
|
*
|
||
|
* printf("Devices available:\n\n");
|
||
|
*
|
||
|
* for (int i=0; i<deviceList->getDeviceCount(); ++i)
|
||
|
* printf("%d: %s\n", i, deviceList->getDeviceDescription(i));
|
||
|
*
|
||
|
* printf("\nselect a device using the number (or press any key to use default):\n\n");
|
||
|
* int deviceNumber = getch() - '0';
|
||
|
*
|
||
|
* // create recording device with the selected driver
|
||
|
*
|
||
|
* const char* deviceID = deviceList->getDeviceID(deviceNumber);
|
||
|
* irrklang::ISoundEngine* engine = irrklang::createIrrKlangDevice();
|
||
|
* irrklang::IAudioRecorder* recorder =
|
||
|
* irrklang::createIrrKlangAudioRecorder(engine, irrklang::ESOD_AUTO_DETECT, deviceID);
|
||
|
*
|
||
|
* \endcode
|
||
|
*
|
||
|
* <br/>
|
||
|
* <br/>
|
||
|
* <br/>
|
||
|
* <br/>
|
||
|
*
|
||
|
*
|
||
|
* \section unicode Unicode support
|
||
|
*
|
||
|
* irrKlang supports unicode on all operating systems. Internally, it uses UTF8, and all functions accepting strings
|
||
|
* and file names take UTF8 strings. If you are running irrKlang on Windows, and are using the UNICODE define or using
|
||
|
* wchar_t* strings directly, you can do this as well. Use the irrKlang provided function makeUTF8fromUTF16string() to
|
||
|
* convert your wchar_t* string to a char* string.
|
||
|
*
|
||
|
* This example shows how:
|
||
|
*
|
||
|
* \code
|
||
|
* const wchar_t* yourFilename = L"SomeUnicodeFilename.wav"; // assuming this is the file name you get from some of your functions
|
||
|
*
|
||
|
* const int nBufferSize = 2048; // large enough, but best would be wcslen(yourFilename)*3.
|
||
|
* char strBuffer[nBufferSize];
|
||
|
* irrklang::makeUTF8fromUTF16string(yourFilename, strBuffer, nBufferSize);
|
||
|
*
|
||
|
* // now the converted file name is in strBuffer. We can play it for example now:
|
||
|
* engine->play2D(strBuffer);
|
||
|
* \endcode
|
||
|
*
|
||
|
* Of course, you can use any other unicode converion function for this. makeUTF8fromUTF16string() is only provided
|
||
|
* for convenience.
|
||
|
* <br/>
|
||
|
* <br/>
|
||
|
* <br/>
|
||
|
* <br/>
|
||
|
*
|
||
|
*
|
||
|
*
|
||
|
*
|
||
|
*
|
||
|
* \section quickstartexample Quick Start Example
|
||
|
*
|
||
|
* To simply start the engine and play a mp3 file, use code like this:
|
||
|
*
|
||
|
* \code
|
||
|
* #include <iostream>
|
||
|
* #include <irrKlang.h>
|
||
|
* #pragma comment(lib, "irrKlang.lib") // link with irrKlang.dll
|
||
|
*
|
||
|
* int main(int argc, const char** argv)
|
||
|
* {
|
||
|
* irrklang::ISoundEngine* engine = irrklang::createIrrKlangDevice();
|
||
|
* if (!engine) return 1; // could not start engine
|
||
|
*
|
||
|
* engine->play2D("someMusic.mp3", true); // play some mp3 file, looped
|
||
|
*
|
||
|
* std::cin.get(); // wait until user presses a key
|
||
|
*
|
||
|
* engine->drop(); // delete engine
|
||
|
* return 0;
|
||
|
* }
|
||
|
* \endcode
|
||
|
*
|
||
|
* A mp3 file is being played until the user presses enter in this example.
|
||
|
* As you can see, irrKlang uses <A HREF="namespaces.html">namespaces</A>, all of
|
||
|
* the classes are located in the namespace irrklang. If you don't want to write
|
||
|
* this in front of every class and function you are using, simply write
|
||
|
*
|
||
|
* \code
|
||
|
* using namespace irrklang;
|
||
|
* \endcode
|
||
|
* in front of your code, as also shown in the next example.
|
||
|
* <br/>
|
||
|
* <br/>
|
||
|
* <br/>
|
||
|
* <br/>
|
||
|
*
|
||
|
*
|
||
|
*
|
||
|
* \section quickstartexample2 Quick Start Example 2
|
||
|
*
|
||
|
* The following is a simple interactive application, starting up the sound engine and
|
||
|
* playing some streaming .ogg music file and a .wav sound effect every time the user
|
||
|
* presses a key.
|
||
|
*
|
||
|
* \code
|
||
|
* #include <iostream>
|
||
|
* #include <irrKlang.h>
|
||
|
* using namespace irrklang;
|
||
|
*
|
||
|
* #pragma comment(lib, "irrKlang.lib") // link with irrKlang.dll
|
||
|
*
|
||
|
*
|
||
|
* int main(int argc, const char** argv)
|
||
|
* {
|
||
|
* // start the sound engine with default parameters
|
||
|
* ISoundEngine* engine = createIrrKlangDevice();
|
||
|
*
|
||
|
* if (!engine)
|
||
|
* return 0; // error starting up the engine
|
||
|
*
|
||
|
* // play some sound stream, looped
|
||
|
* engine->play2D("../../media/helltroopers.ogg", true);
|
||
|
*
|
||
|
* std::cout << "\nHello World!\n";
|
||
|
*
|
||
|
* char i = 0;
|
||
|
*
|
||
|
* while(i != 'q')
|
||
|
* {
|
||
|
* std::cout << "Press any key to play some sound, press 'q' to quit.\n";
|
||
|
*
|
||
|
* // play a single sound
|
||
|
* engine->play2D("../../media/bell.wav");
|
||
|
*
|
||
|
* std::cin >> i; // wait for user to press some key
|
||
|
* }
|
||
|
*
|
||
|
* engine->drop(); // delete engine
|
||
|
* return 0;
|
||
|
* }
|
||
|
*
|
||
|
* \endcode
|
||
|
*/
|
||
|
|
||
|
#if defined(IRRKLANG_STATIC)
|
||
|
#define IRRKLANG_API
|
||
|
#else
|
||
|
#if (defined(WIN32) || defined(WIN64) || defined(_MSC_VER))
|
||
|
#ifdef IRRKLANG_EXPORTS
|
||
|
#define IRRKLANG_API __declspec(dllexport)
|
||
|
#else
|
||
|
#define IRRKLANG_API __declspec(dllimport)
|
||
|
#endif // IRRKLANG_EXPORT
|
||
|
#else
|
||
|
#define IRRKLANG_API __attribute__((visibility("default")))
|
||
|
#endif // defined(WIN32) || defined(WIN64)
|
||
|
#endif // IRRKLANG_STATIC
|
||
|
|
||
|
#if defined(_STDCALL_SUPPORTED)
|
||
|
#define IRRKLANGCALLCONV __stdcall // Declare the calling convention.
|
||
|
#else
|
||
|
#define IRRKLANGCALLCONV
|
||
|
#endif // STDCALL_SUPPORTED
|
||
|
|
||
|
//! Everything in the irrKlang Sound Engine can be found in this namespace.
|
||
|
namespace irrklang
|
||
|
{
|
||
|
//! Creates an irrKlang device. The irrKlang device is the root object for using the sound engine.
|
||
|
/** \param driver The sound output driver to be used for sound output. Use irrklang::ESOD_AUTO_DETECT
|
||
|
to let irrKlang decide which driver will be best.
|
||
|
\param options A combination of irrklang::E_SOUND_ENGINE_OPTIONS literals. Default value is
|
||
|
irrklang::ESEO_DEFAULT_OPTIONS.
|
||
|
\param deviceID Some additional optional deviceID for the audio driver. If not needed, simple
|
||
|
set this to 0.
|
||
|
This can be used for example to set a specific ALSA output pcm device for output
|
||
|
("default" or "hw", for example). For most driver types, available deviceIDs can be
|
||
|
enumerated using createSoundDeviceList().
|
||
|
See @ref enumeratingDevices for an example or ISoundDeviceList or details.
|
||
|
\param sdk_version_do_not_use Don't use or change this parameter. Always set it to
|
||
|
IRRKLANG_SDK_VERSION, which is done by default. This is needed for sdk version checks.
|
||
|
\return Returns pointer to the created irrKlang device or null if the
|
||
|
device could not be created. If you don't need the device, use ISoundEngine::drop() to
|
||
|
delete it. See IRefCounted::drop() for details.
|
||
|
*/
|
||
|
IRRKLANG_API ISoundEngine* IRRKLANGCALLCONV createIrrKlangDevice(
|
||
|
E_SOUND_OUTPUT_DRIVER driver = ESOD_AUTO_DETECT,
|
||
|
int options = ESEO_DEFAULT_OPTIONS,
|
||
|
const char* deviceID = 0,
|
||
|
const char* sdk_version_do_not_use = IRR_KLANG_VERSION);
|
||
|
|
||
|
|
||
|
//! Creates a list of available sound devices for the driver type.
|
||
|
/** The device IDs in this list can be used as parameter to createIrrKlangDevice() to
|
||
|
make irrKlang use a special sound device. See @ref enumeratingDevices for an example on how
|
||
|
to use this.
|
||
|
\param driver The sound output driver of which the list is generated. Set it irrklang::ESOD_AUTO_DETECT
|
||
|
to let this function use the same device as createIrrKlangDevice() would choose.
|
||
|
\param sdk_version_do_not_use Don't use or change this parameter. Always set it to
|
||
|
IRRKLANG_SDK_VERSION, which is done by default. This is needed for sdk version checks.
|
||
|
\return Returns a pointer to the list of enumerated sound devices for the selected sound driver.
|
||
|
The device IDs in this list can be used as parameter to createIrrKlangDevice() to
|
||
|
make irrKlang use a special sound device.
|
||
|
After you don't need the list anymore, call ISoundDeviceList::drop() in order to free its memory. */
|
||
|
IRRKLANG_API ISoundDeviceList* IRRKLANGCALLCONV createSoundDeviceList(
|
||
|
E_SOUND_OUTPUT_DRIVER driver = ESOD_AUTO_DETECT,
|
||
|
const char* sdk_version_do_not_use = IRR_KLANG_VERSION);
|
||
|
|
||
|
|
||
|
//! Creates an irrKlang audio recording device. The IAudioRecorder is the root object for recording audio.
|
||
|
/** If you want to play back recorded audio as well, create the ISoundEngine first using
|
||
|
createIrrKlangDevice() and then the IAudioRecorder using createIrrKlangAudioRecorder(), where
|
||
|
you set the ISoundEngine as first parameter. See @ref recordingAudio for an example on how to use this.
|
||
|
Note: audio recording is a very new feature a still beta in irrKlang. It currently only works in Windows
|
||
|
and with DirectSound (subject to change).
|
||
|
\param irrKlangDeviceForPlayback A pointer to the already existing sound device used for playback
|
||
|
of audio. Sound sources recorded with the IAudioRecorder will be added into that device so that
|
||
|
they can be played back there.
|
||
|
\param driver The sound output driver to be used for recording audio. Use irrklang::ESOD_AUTO_DETECT
|
||
|
to let irrKlang decide which driver will be best.
|
||
|
\param deviceID Some additional optional deviceID for the audio driver. If not needed, simple
|
||
|
set this to 0. Use createAudioRecorderDeviceList() to get a list of all deviceIDs.
|
||
|
\param sdk_version_do_not_use Don't use or change this parameter. Always set it to
|
||
|
IRRKLANG_SDK_VERSION, which is done by default. This is needed for sdk version checks.
|
||
|
\return Returns pointer to the created irrKlang device or null if the
|
||
|
device could not be created. If you don't need the device, use ISoundEngine::drop() to
|
||
|
delete it. See IRefCounted::drop() for details.
|
||
|
*/
|
||
|
IRRKLANG_API IAudioRecorder* IRRKLANGCALLCONV createIrrKlangAudioRecorder(
|
||
|
ISoundEngine* irrKlangDeviceForPlayback,
|
||
|
E_SOUND_OUTPUT_DRIVER driver = ESOD_AUTO_DETECT,
|
||
|
const char* deviceID = 0,
|
||
|
const char* sdk_version_do_not_use = IRR_KLANG_VERSION);
|
||
|
|
||
|
//! Creates a list of available recording devices for the driver type.
|
||
|
/** The device IDs in this list can be used as parameter to createIrrKlangAudioRecorder() to
|
||
|
make irrKlang use a special recording device.
|
||
|
\param driver The sound output driver of which the list is generated. Set it irrklang::ESOD_AUTO_DETECT
|
||
|
to let this function use the same device as createIrrKlangDevice() would choose.
|
||
|
\param sdk_version_do_not_use Don't use or change this parameter. Always set it to
|
||
|
IRRKLANG_SDK_VERSION, which is done by default. This is needed for sdk version checks.
|
||
|
\return Returns a pointer to the list of enumerated recording devices for the selected sound driver.
|
||
|
The device IDs in this list can be used as parameter to createIrrKlangAudioRecorder() to
|
||
|
make irrKlang use a special sound device.
|
||
|
After you don't need the list anymore, call ISoundDeviceList::drop() in order to free its memory. */
|
||
|
IRRKLANG_API ISoundDeviceList* IRRKLANGCALLCONV createAudioRecorderDeviceList(
|
||
|
E_SOUND_OUTPUT_DRIVER driver = ESOD_AUTO_DETECT,
|
||
|
const char* sdk_version_do_not_use = IRR_KLANG_VERSION);
|
||
|
|
||
|
|
||
|
//! Converts a wchar_t string to an utf8 string, useful when using Windows in unicode mode.
|
||
|
/** irrKlang works with unicode file names, and accepts char* strings as parameters for names and filenames.
|
||
|
If you are running irrKlang in Windows, and working with wchar_t* pointers instead of char* ones,
|
||
|
you can use this function to create a char* (UTF8) representation of your wchar_t* (UTF16) string.
|
||
|
Works for filenames and other strings.
|
||
|
\param pInputString zero terminated input string.
|
||
|
\param pOutputBuffer the buffer where the converted string is written to. Be sure that this buffer
|
||
|
has a big enough size. A good size would be three times the string length of your input buffer, like
|
||
|
wcslen(yourInputBuffer)*3. Because each wchar_t can be represented by up to 3 chars.
|
||
|
\param outputBufferSize size of your output buffer.
|
||
|
\return Returns true if successful, and false if not. If 'false' is returned, maybe your buffer was too small. */
|
||
|
IRRKLANG_API bool IRRKLANGCALLCONV makeUTF8fromUTF16string(
|
||
|
const wchar_t* pInputString, char* pOutputBuffer, int outputBufferSize);
|
||
|
|
||
|
|
||
|
} // end namespace irrklang
|
||
|
|
||
|
|
||
|
/*! \file irrKlang.h
|
||
|
\brief Main header file of the irrKlang sound library, the only file needed to include.
|
||
|
*/
|
||
|
|
||
|
#endif
|
||
|
|