Beispiel #1
0
 void MakeClient()
 {
     if (!m_client)
     {
         m_client = rtHTTPClient.Create();
         m_client.Setup(m_serverAddress, m_serverPort);
         m_asyncStats = m_client.UpdateServerStatus();
     }
 }
Beispiel #2
0
 public override void Stop()
 {
     if (isPlaying)
     {
         UseOutput(audio => { audio.Stop(); });
     }
     if (isServerTalking)
     {
         m_asyncStop = m_client.Stop();
     }
     m_asyncTalk.Release();
 }
Beispiel #3
0
        public bool Play()
        {
            if (!isReady)
            {
                return(false);
            }
            if ((m_castID < 0 || m_castID >= m_casts.Length) ||
                (m_talkText == null || m_talkText.Length == 0))
            {
                return(false);
            }

            m_currentTalk.castName = castName;
            m_currentTalk.text     = m_talkText;
            m_currentTalk.param    = m_talkParams;

            if (m_exportAudio || m_useExportedClips)
            {
                m_cacheFileName = GenCacheFileName();
#if UNITY_EDITOR
                if (m_useExportedClips)
                {
                    var path = assetPath + "/" + m_cacheFileName;
                    var clip = AssetDatabase.LoadAssetAtPath <AudioClip>(path);
                    if (clip != null)
                    {
                        UseOutput(audio => { audio.Play(clip); });
                        return(true);
                    }
                }
#endif
            }

            m_isServerTalking = true;
            var tparam = rtTalkParams.defaultValue;
            tparam.cast = (short)m_castID;
            tparam.Assign(m_talkParams);
            m_asyncTalk = m_client.Talk(ref tparam, m_talkText);
            return(true);
        }
Beispiel #4
0
        void UpdateState()
        {
            bool talkSucceeded = false;

            if (m_asyncStats.isFinished)
            {
                m_asyncStats.Release();

                m_hostName = m_client.host;
                m_casts    = m_client.casts;
                foreach (var c in m_casts)
                {
                    c.hostName = m_hostName;
                }

                if (m_casts.Length > 0)
                {
                    castID = Mathf.Clamp(m_castID, 0, m_casts.Length - 1);
                }
                else
                {
                    castID = 0;
                }

                m_isServerReady = m_hostName != "Server Not Found";
                Misc.RefreshWindows();
            }

            var playing = isPlaying;

            if (m_asyncTalk)
            {
                if (!playing)
                {
                    var buf = m_client.SyncBuffers();
                    if (buf.sampleLength > m_sampleGranularity ||
                        (buf.sampleLength > 0 && m_asyncTalk.isFinished && m_asyncTalk.boolValue))
                    {
                        UseOutput(audio => { audio.Play(buf, SyncBuffers); });
                        FireOnTalkStart(m_currentTalk);
                    }
                }

                if (m_asyncTalk.isFinished)
                {
                    m_client.SyncBuffers();
                    talkSucceeded = m_asyncTalk.boolValue;
                    FireOnTalkFinish(m_currentTalk, talkSucceeded);

                    m_asyncTalk.Release();
                    m_isServerTalking = false;
#if UNITY_EDITOR
                    if (!talkSucceeded)
                    {
                        UpdateStats();
                    }

                    if (talkSucceeded && m_exportAudio)
                    {
                        MakeSureAssetDirectoryExists();
                        FinishExportClip(true);
                        m_exportingAssetPath = assetPath + "/" + m_cacheFileName;
                        if (m_exportFileFormat == AudioFileFormat.Ogg)
                        {
                            m_asyncExport = m_client.ExportOgg(m_exportingAssetPath, ref m_oggSettings);
                        }
                        else
                        {
                            m_asyncExport = m_client.ExportWave(m_exportingAssetPath);
                        }
                    }
#endif
                }
            }

#if UNITY_EDITOR
            if (!playing) // to avoid noise
            {
                FinishExportClip();
            }
#endif

            if (m_wasPlaying && !playing)
            {
                Misc.RefreshWindows();
            }
            m_wasPlaying = playing;

            if (m_asyncStop.isFinished)
            {
                m_isServerTalking = false;
                m_asyncStop.Release();
                Misc.RefreshWindows();
            }
        }
Beispiel #5
0
 public void UpdateStats()
 {
     m_client.Setup(m_serverAddress, m_serverPort);
     m_asyncStats = m_client.UpdateServerStatus();
 }