int EnumValueToPopupIndex(Phonon.AudioEngine enumValue)
{
switch (enumValue)
{
case Phonon.AudioEngine.Unity:
return 0;
case Phonon.AudioEngine.Unity5:
return 1;
case Phonon.AudioEngine.Wwise:
return 2;
case Phonon.AudioEngine.FMODStudio:
return 3;
default:
return -1;
}
}
// bool setOutputDevice(const Phonon::ObjectDescription<Phonon::AudioOutputDeviceType>& arg1); >>>> NOT CONVERTED
/// <remarks>
/// Creates a new AudioOutput that defines output to a physical
/// device.
/// \param category The category can be used by mixer applications to group volume
/// controls of applications into categories. That makes it easier for
/// the user to identify the programs.
/// The category is also used for the default output device that is
/// configured centrally. As an example: often users want to have the
/// audio signal of a VoIP application go to their USB headset while
/// all other sounds should go to the internal soundcard.
/// \param parent QObject parent
/// \see Phonon.CategoryToString
/// \see outputDevice
/// </remarks> <short> Creates a new AudioOutput that defines output to a physical device.</short>
public AudioOutput(Phonon.Category category, QObject parent)
: this((Type) null)
{
CreateProxy();
interceptor.Invoke("AudioOutput$#", "AudioOutput(Phonon::Category, QObject*)", typeof(void), typeof(Phonon.Category), category, typeof(QObject), parent);
}
public static extern void iplFMODInitialize(Phonon.ReverbSettings settings);
/// <remarks>
/// Returns the strings associated with the given <pre>key</pre>.
/// Same as above except that the keys are defined in the
/// Phonon.MetaData enum.
/// </remarks> <short> Returns the strings associated with the given \p key.</short>
public List<string> metaData(Phonon.MetaData key)
{
return (List<string>) interceptor.Invoke("metaData$", "metaData(Phonon::MetaData) const", typeof(List<string>), typeof(Phonon.MetaData), key);
}
public EffectParameter(Phonon.EffectParameter rhs)
: this((Type) null)
{
CreateProxy();
interceptor.Invoke("EffectParameter#", "EffectParameter(const Phonon::EffectParameter&)", typeof(void), typeof(Phonon.EffectParameter), rhs);
}
/// <remarks>
/// Removes an effect from the path.
/// If the effect gets deleted while it is still connected the effect
/// will be removed automatically.
/// \param effect The effect to be removed.
/// \return Returns whether the call was successful. If it returns
/// <code>false</code> the effect could not be found in the path, meaning it
/// has not been inserted before.
/// \see insertEffect
/// \see effects
/// </remarks> <short> Removes an effect from the path.</short>
public bool RemoveEffect(Phonon.Effect effect)
{
return (bool) interceptor.Invoke("removeEffect#", "removeEffect(Phonon::Effect*)", typeof(bool), typeof(Phonon.Effect), effect);
}
public bool InsertEffect(Phonon.Effect newEffect)
{
return (bool) interceptor.Invoke("insertEffect#", "insertEffect(Phonon::Effect*)", typeof(bool), typeof(Phonon.Effect), newEffect);
}
/// <remarks>
/// Creates a MediaSource object for discs.
/// \param discType See \ref DiscType
/// \param deviceName A platform dependent device name. This can be useful if the computer
/// has more than one CD drive. It is recommended to use Solid to retrieve the device name in
/// a portable way.
/// </remarks> <short> Creates a MediaSource object for discs.</short>
public MediaSource(Phonon.DiscType discType, string deviceName)
: this((Type) null)
{
CreateProxy();
interceptor.Invoke("MediaSource$$", "MediaSource(Phonon::DiscType, const QString&)", typeof(void), typeof(Phonon.DiscType), discType, typeof(string), deviceName);
}
public void Play(Phonon.MediaSource source)
{
interceptor.Invoke("play#", "play(const Phonon::MediaSource&)", typeof(void), typeof(Phonon.MediaSource), source);
}
public void Load(Phonon.MediaSource source)
{
interceptor.Invoke("load#", "load(const Phonon::MediaSource&)", typeof(void), typeof(Phonon.MediaSource), source);
}
// Phonon::ObjectDescription<Phonon::AudioChannelType> currentAudioChannel(); >>>> NOT CONVERTED
// Phonon::ObjectDescription<Phonon::SubtitleType> currentSubtitle(); >>>> NOT CONVERTED
// QList<Phonon::ObjectDescription<Phonon::AudioChannelType> > availableAudioChannels(); >>>> NOT CONVERTED
// QList<Phonon::ObjectDescription<Phonon::SubtitleType> > availableSubtitles(); >>>> NOT CONVERTED
// void setCurrentAudioChannel(const Phonon::ObjectDescription<Phonon::AudioChannelType>& arg1); >>>> NOT CONVERTED
// void setCurrentSubtitle(const Phonon::ObjectDescription<Phonon::SubtitleType>& arg1); >>>> NOT CONVERTED
public MediaController(Phonon.MediaObject parent)
: this((Type) null)
{
CreateProxy();
interceptor.Invoke("MediaController#", "MediaController(Phonon::MediaObject*)", typeof(void), typeof(Phonon.MediaObject), parent);
}
public List<string> MimeTypes(Phonon.ObjectDescriptionType type)
{
return (List<string>) interceptor.Invoke("mimeTypes$", "mimeTypes(Phonon::ObjectDescriptionType) const", typeof(List<string>), typeof(Phonon.ObjectDescriptionType), type);
}
/// <remarks>
/// Returns the MIME data that dropMimeData() can use to create new
/// items.
/// </remarks> <short> Returns the MIME data that dropMimeData() can use to create new items.</short>
public QMimeData MimeData(Phonon.ObjectDescriptionType type, List<QModelIndex> indexes)
{
return (QMimeData) interceptor.Invoke("mimeData$?", "mimeData(Phonon::ObjectDescriptionType, const QList<QModelIndex>&) const", typeof(QMimeData), typeof(Phonon.ObjectDescriptionType), type, typeof(List<QModelIndex>), indexes);
}
public bool DropMimeData(Phonon.ObjectDescriptionType type, QMimeData data, Qt.DropAction action, int row, int column, QModelIndex parent)
{
return (bool) interceptor.Invoke("dropMimeData$#$$$#", "dropMimeData(Phonon::ObjectDescriptionType, const QMimeData*, Qt::DropAction, int, int, const QModelIndex&)", typeof(bool), typeof(Phonon.ObjectDescriptionType), type, typeof(QMimeData), data, typeof(Qt.DropAction), action, typeof(int), row, typeof(int), column, typeof(QModelIndex), parent);
}
public AudioOutput(Phonon.Category category)
: this((Type) null)
{
CreateProxy();
interceptor.Invoke("AudioOutput$", "AudioOutput(Phonon::Category)", typeof(void), typeof(Phonon.Category), category);
}
/// <remarks>
/// Creates a MediaSource object for a data stream.
/// Your application can provide the media data by subclassing AbstractMediaStream and
/// passing a pointer to that object. %Phonon will never delete the <pre>stream</pre>.
/// \param stream The AbstractMediaStream subclass to provide the media data.
/// \see setAutoDelete
/// </remarks> <short> Creates a MediaSource object for a data stream.</short>
public MediaSource(Phonon.AbstractMediaStream stream)
: this((Type) null)
{
CreateProxy();
interceptor.Invoke("MediaSource#", "MediaSource(Phonon::AbstractMediaStream*)", typeof(void), typeof(Phonon.AbstractMediaStream), stream);
}
/// <remarks>
/// Constructs a copy of <pre>rhs</pre>.
/// This constructor is fast thanks to explicit sharing.
/// </remarks> <short> Constructs a copy of \p rhs.</short>
public MediaSource(Phonon.MediaSource rhs)
: this((Type) null)
{
CreateProxy();
interceptor.Invoke("MediaSource#", "MediaSource(const Phonon::MediaSource&)", typeof(void), typeof(Phonon.MediaSource), rhs);
}
/// <remarks>
/// Constructs a new %VideoPlayer instance.
/// \param category The category used for the audio output device.
/// \param parent The QObject parent.
/// </remarks> <short> Constructs a new %VideoPlayer instance.</short>
public VideoPlayer(Phonon.Category category, QWidget parent)
: this((Type) null)
{
CreateProxy();
interceptor.Invoke("VideoPlayer$#", "VideoPlayer(Phonon::Category, QWidget*)", typeof(void), typeof(Phonon.Category), category, typeof(QWidget), parent);
}
public MediaSource(Phonon.DiscType discType)
: this((Type) null)
{
CreateProxy();
interceptor.Invoke("MediaSource$", "MediaSource(Phonon::DiscType)", typeof(void), typeof(Phonon.DiscType), discType);
}
public VideoPlayer(Phonon.Category category)
: this((Type) null)
{
CreateProxy();
interceptor.Invoke("VideoPlayer$", "VideoPlayer(Phonon::Category)", typeof(void), typeof(Phonon.Category), category);
}
/// <remarks>
/// Tries to change the MediaNodes the path is connected to.
/// If reconnect fails the old connection is kept.
/// </remarks> <short> Tries to change the MediaNodes the path is connected to.</short>
public bool Reconnect(Phonon.IMediaNode source, Phonon.IMediaNode sink)
{
return (bool) interceptor.Invoke("reconnect##", "reconnect(Phonon::MediaNode*, Phonon::MediaNode*)", typeof(bool), typeof(Phonon.IMediaNode), source, typeof(Phonon.IMediaNode), sink);
}
public void SetAspectRatio(Phonon.VideoWidget.AspectRatio arg1)
{
interceptor.Invoke("setAspectRatio$", "setAspectRatio(Phonon::VideoWidget::AspectRatio)", typeof(void), typeof(Phonon.VideoWidget.AspectRatio), arg1);
}
/// <remarks>
/// Constructs a copy of the given path.
/// This constructor is fast thanks to explicit sharing.
/// </remarks> <short> Constructs a copy of the given path.</short>
public Path(Phonon.Path arg1)
: this((Type) null)
{
CreateProxy();
interceptor.Invoke("Path#", "Path(const Phonon::Path&)", typeof(void), typeof(Phonon.Path), arg1);
}
public void SetScaleMode(Phonon.VideoWidget.ScaleMode arg1)
{
interceptor.Invoke("setScaleMode$", "setScaleMode(Phonon::VideoWidget::ScaleMode)", typeof(void), typeof(Phonon.VideoWidget.ScaleMode), arg1);
}
/// <remarks>
/// Appends one source to the queue. Use this function to provide
/// the next source just in time after the aboutToFinish signal was
/// emitted.
/// \see aboutToFinish
/// \see setQueue
/// \see clearQueue
/// </remarks> <short> Appends one source to the queue.</short>
public void Enqueue(Phonon.MediaSource source)
{
interceptor.Invoke("enqueue#", "enqueue(const Phonon::MediaSource&)", typeof(void), typeof(Phonon.MediaSource), source);
}
/// <remarks>
/// Call this function from the constructor of your StreamInterface implementation (or as
/// soon as you get the MediaSource object). This will connect your object to the
/// AbstractMediaStream object. Only after the connection is done will the following
/// functions have an effect.
/// </remarks> <short> Call this function from the constructor of your StreamInterface implementation (or as soon as you get the MediaSource object).</short>
public void ConnectToSource(Phonon.MediaSource mediaSource)
{
interceptor.Invoke("connectToSource#", "connectToSource(const Phonon::MediaSource&)", typeof(void), typeof(Phonon.MediaSource), mediaSource);
}
/// <remarks>
/// Set the media source the MediaObject should use.
/// \param source The MediaSource object to the media data. You can
/// just as well use a QUrl or string (for a local file) here.
/// Setting an empty (invalid) source, will stop and remove the
/// current source.
/// <pre>
/// QUrl url("http://www.example.com/music.ogg");
/// media.SetCurrentSource(url);
/// </pre>
/// \see currentSource
/// </remarks> <short> Set the media source the MediaObject should use.</short>
public void SetCurrentSource(Phonon.MediaSource source)
{
interceptor.Invoke("setCurrentSource#", "setCurrentSource(const Phonon::MediaSource&)", typeof(void), typeof(Phonon.MediaSource), source);
}
/// <remarks>
/// If an I/O error occurs you should call this function to make MediaObject go into
/// ErrorState.
/// \see MediaObject.ErrorType()
/// \see MediaObject.ErrorString()
/// </remarks> <short> If an I/O error occurs you should call this function to make MediaObject go into ErrorState.</short>
protected void Error(Phonon.ErrorType errorType, string errorString)
{
interceptor.Invoke("error$$", "error(Phonon::ErrorType, const QString&)", typeof(void), typeof(Phonon.ErrorType), errorType, typeof(string), errorString);
}
public static extern void iplFMODDestroy(Phonon.ReverbSettings settings);
//
// Exports a terrain.
//
void ExportTerrain(Phonon.Vector3[] vertices, Phonon.Triangle[] triangles)
{
int w = AttachedTerrain.terrainData.heightmapWidth;
int h = AttachedTerrain.terrainData.heightmapHeight;
int s = Mathf.Min(w - 1, Mathf.Min(h - 1, (int)Mathf.Pow(2.0f, (float)TerrainSimplificationLevel)));
if (s == 0)
s = 1;
w = ((w - 1) / s) + 1;
h = ((h - 1) / s) + 1;
Vector3 position = AttachedTerrain.transform.position;
float[,] heights = AttachedTerrain.terrainData.GetHeights(0, 0, AttachedTerrain.terrainData.heightmapWidth, AttachedTerrain.terrainData.heightmapHeight);
int vertexIndex = 0;
for (int v = 0; v < AttachedTerrain.terrainData.heightmapHeight; v += s)
{
for (int u = 0; u < AttachedTerrain.terrainData.heightmapWidth; u += s)
{
float height = heights[v, u];
float x = position.x + (((float) u / AttachedTerrain.terrainData.heightmapWidth) * AttachedTerrain.terrainData.size.x);
float y = position.y + (height * AttachedTerrain.terrainData.size.y);
float z = position.z + (((float) v / AttachedTerrain.terrainData.heightmapHeight) * AttachedTerrain.terrainData.size.z);
vertices[vertexIndex++] = Phonon.Common.ConvertVector(new Vector3 { x = x, y = y, z = z });
}
}
int triangleIndex = 0;
for (int v = 0; v < h - 1; ++v)
{
for (int u = 0; u < w - 1; ++u)
{
int i0 = v * w + u;
int i1 = (v + 1) * w + u;
int i2 = v * w + (u + 1);
triangles[triangleIndex++] = new Phonon.Triangle { index0 = i0, index1 = i1, index2 = i2 };
i0 = v * w + (u + 1);
i1 = (v + 1) * w + u;
i2 = (v + 1) * w + (u + 1);
triangles[triangleIndex++] = new Phonon.Triangle { index0 = i0, index1 = i1, index2 = i2 };
}
}
}
