private void AddClip(NamedAudioClip c)
{
bool isChecked = clips_.Contains(c);
var time = "?";
if (c.sourceClip != null)
{
time = Utilities.SecondsToString(c.sourceClip.length);
}
var name = "?";
if (c.displayName != null)
{
name = c.displayName;
}
var text = "[" + time + "] " + name;
var cb = new Checkbox(
text, isChecked,
b => ClipToggled(c, b), flags_ | Widget.Tall);
collapsible_.Add(cb);
}
public static NamedAudioClip LoadAudio(string path)
{
string localPath = SuperController.singleton.NormalizeLoadPath(path);
NamedAudioClip existing = URLAudioClipManager.singleton.GetClip(localPath);
if (existing != null)
{
return(existing);
}
URLAudioClip clip = URLAudioClipManager.singleton.QueueClip(SuperController.singleton.NormalizeMediaPath(path));
if (clip == null)
{
return(null);
}
NamedAudioClip nac = URLAudioClipManager.singleton.GetClip(clip.uid);
if (nac == null)
{
return(null);
}
return(nac);
}
public Expression(JSONNode expressionData, Dictionary <string, Facial> facialDict)
{
audioClip = Utils.LoadAudioClipAbs(Utils.AbsPath(expressionData["audio"]));
if (expressionData["minIntensity"] != null)
{
minIntensity = float.Parse(expressionData["minIntensity"]);
}
if (expressionData["maxIntensity"] != null)
{
maxIntensity = float.Parse(expressionData["maxIntensity"]);
}
if (expressionData["mouthClosed"] != null)
{
keepMouthClosed = expressionData["mouthClosed"].AsBool;
}
var facialListNode = expressionData["facial"];
for (int i = 0; i < facialListNode.Count; i++)
{
facialList.Add(facialListNode[i]);
}
facialLookup = facialDict;
}
public ExpressionAnimation(GenerateDAZMorphsControlUI morphControl, string jsonString)
{
this.morphControl = morphControl;
JSONClass obj = JSON.Parse(jsonString).AsObject;
audio = obj["audio"].Value;
duration = obj["duration"].AsFloat;
JSONArray keyframesData = obj["keyframes"].AsArray;
for (int i = 0; i < keyframesData.Count; i++)
{
ExpressionKeyframe keyframe = new ExpressionKeyframe();
JSONClass keyframeData = keyframesData[i].AsObject;
keyframeData.Keys.ToList().ForEach((keyName) =>
{
float value = keyframeData[keyName].AsFloat;
if (keyName == "time")
{
keyframe.time = value;
}
else
{
keyframe.morphValues[keyName] = value;
}
});
keyframes.Add(keyframe);
}
nac = URLAudioClipManager.singleton.GetClip(audio);
}
public static GameObject Play(NamedAudioClip namedAudio, bool loop)
{
var sound = new GameObject(string.Format("Sound - {0}", namedAudio.name));
sound.transform.SetParent(instance.transform);
sound.transform.localPosition = Vector3.zero;
var source = sound.AddComponent <AudioSource>();
source.clip = namedAudio.clip;
source.volume = namedAudio.volume;
if (namedAudio.name.Contains("Music"))
{
source.outputAudioMixerGroup = instance.musicMixerGroup;
}
else
{
source.outputAudioMixerGroup = instance.soundMixerGroup;
}
source.Play();
source.loop = loop;
if (!loop)
{
Destroy(sound, namedAudio.clip.length + 1);
}
return(sound);
}
public void PlayAudio(NamedAudioClip clip)
{
if (clip != null)
{
headAudioSource.PlayNow(clip);
}
}
public void TriggerClimax()
{
if (dm.personality == null)
{
return;
}
if (dm.expressions == null)
{
return;
}
NamedAudioClip clip = dm.personality.GetRandomClimaxClip();
if (clip == null || clip.sourceClip == null)
{
return;
}
dm.PlayAudio(clip);
lastPlayedClip = clip;
dm.climaxController.SetClimaxDuration(clip.sourceClip.length);
currentIdle = dm.expressions.climaxGroup.SelectRandomExpression();
currentMouthOpened = dm.expressions.mouthOpenGroup.SelectRandomExpression();
}
JSONClass KeyToJSON(string key, JSONNode expressionNode)
{
if (key.ToLower().Contains(".json"))
{
string expressionPath = Expressions.EXPRESSIONS_PATH + "/" + key;
//Debug.Log(expressionPath);
JSONClass expression = JSON.Parse(SuperController.singleton.ReadFileIntoString(expressionPath)).AsObject;
if (expression["audio"] != null)
{
NamedAudioClip clip = DollmasterPlugin.LoadAudio(DollmasterPlugin.PLUGIN_PATH + "/" + expression["audio"]);
audioClips[expression["audio"]] = clip;
}
return(expression);
}
else
{
JSONClass node = new JSONClass();
node["morphs"] = new JSONArray();
JSONClass morphNode = new JSONClass();
morphNode["name"] = key;
morphNode["value"] = expressionNode;
node["morphs"].Add(morphNode);
return(node);
}
}
JSONStorableStringChooser BuildClipUI(int index)
{
NamedAudioClip clip = null;
JSONStorableStringChooser chooser = new JSONStorableStringChooser("clip_" + index, GetClipIds(), null, "Choose Audio Clip", (string choice) =>
{
clip = URLAudioClipManager.singleton.GetClip(choice);
clips.Add(clip);
clipCount.val = clips.Count;
Debug.Log("updating choice " + choice);
});
RegisterStringChooser(chooser);
UIDynamicPopup popup = CreateScrollablePopup(chooser, true);
UIDynamicButton remove = CreateButton("Remove Clip Above", true);
remove.button.onClick.AddListener(() =>
{
RemoveButton(remove);
Destroy(popup.gameObject);
clips.Remove(clip);
clipCount.val = clips.Count;
});
return(chooser);
}
public void AddClip(NamedAudioClip c)
{
if (c != null)
{
clips_.Add(c);
Reshuffle();
}
}
void SampleAudioClipAtT(NamedAudioClip clip, float t)
{
AudioSource testAudioSource = URLAudioClipManager.singleton.testAudioSource;
testAudioSource.Stop();
testAudioSource.time = clip.clipToPlay.length * t;
URLAudioClipManager.singleton.TestClip(clip);
testAudioSource.SetScheduledEndTime(AudioSettings.dspTime + 0.2f);
}
public void playNext(AudioSource audioSource, float volume = 1.0f)
{
NamedAudioClip nac = audioClips[next];
audioSource.clip = nac.clipToPlay;
audioSource.volume = volume;
audioSource.pitch = UnityEngine.Random.Range(pitchlow, pitchhigh);
next = (next + 1) % audioClips.Count;
audioSource.Play();
}
public static void PlaySound(NamedAudioClip clip, Vector3 position, float minVolume, float maxVolume,
float minPitch, float maxPitch)
{
var instance = Instantiate(Resources.Load("Prefabs/AudioPlayer", typeof(GameObject))) as GameObject;
instance.transform.position = position;
var audioPlayer = instance.GetComponent <InstantiatedAudioPlayer>();
audioPlayer.PlayClip(clip, position, minVolume, maxVolume, minPitch, maxPitch);
}
private AudioClip GetAudioClip(string name)
{
NamedAudioClip clip = _clips.Find((NamedAudioClip c) => { return(c._name == name); });
if (clip == null)
{
Debug.LogWarning("No AudioClip attached with name: " + name, this);
return(null);
}
return(clip._clip);
}
void PlayAudioClipAtT(NamedAudioClip clip, float t)
{
if (clip == null)
{
Debug.Log("clip is null");
return;
}
AudioSource testAudioSource = URLAudioClipManager.singleton.testAudioSource;
testAudioSource.Stop();
testAudioSource.time = clip.clipToPlay.length * t;
URLAudioClipManager.singleton.TestClip(clip);
}
public static NamedAudioClip LoadAudioClip(string localFilePath)
{
NamedAudioClip existing = URLAudioClipManager.singleton.GetClip(localFilePath);
if (existing != null)
{
return(existing);
}
URLAudioClip clip = URLAudioClipManager.singleton.QueueClip(localFilePath, localFilePath);
return(URLAudioClipManager.singleton.GetClip(clip.uid));
}
private void PlayClip(NamedAudioClip clip, Vector3 position, float minVolume, float maxVolume,
float minPitch, float maxPitch)
{
transform.position = position;
_source.clip = clip.Clip;
_source.volume = Random.Range(minVolume, maxVolume);
_source.pitch = Random.Range(minPitch, maxPitch);
_started = true;
_source.Play();
ShowText(AudioTextLoader.GetSelectedDescription(clip.Name), position, clip.Clip.length);
}
private void ClipToggled(NamedAudioClip c, bool b)
{
if (b)
{
clips_.Add(c);
}
else
{
clips_.Remove(c);
}
callback_?.Invoke(clips_.ToList());
}
public void StartExpression()
{
if (dm == null)
{
return;
}
if (dm.personality == null)
{
return;
}
if (dm.expressions == null)
{
return;
}
NamedAudioClip clip = dm.personality.GetTriggeredAudioClip(dm.arousal);
if (clip == null || clip.sourceClip == null || clip == lastPlayedClip)
{
return;
}
//Debug.Log("playing " + clip.displayName);
currentIdle = null;
if (voiceEnabled.val)
{
dm.PlayAudio(clip);
lastPlayedClip = clip;
}
nextTriggerAvailableTime = Time.time + clip.sourceClip.length + UnityEngine.Random.Range(0.5f, 3.0f);
if (UnityEngine.Random.Range(0, 100) > 10)
{
currentMouthOpened = dm.expressions.mouthOpenGroup.SelectRandomExpression();
}
if (UnityEngine.Random.Range(0, 100) > 40)
{
currentMouthClosed = dm.expressions.mouthClosedGroup.SelectRandomExpression();
}
if (UnityEngine.Random.Range(0, 100) > 60)
{
currentEyes = dm.expressions.eyesGroup.SelectRandomExpression();
}
}
public static NamedAudioClip LoadAudioClipAbs(string absFilePath)
{
string localPath = SuperController.singleton.NormalizePath(absFilePath);
NamedAudioClip existing = URLAudioClipManager.singleton.GetClip(localPath);
if (existing != null)
{
return(existing);
}
URLAudioClip clip = URLAudioClipManager.singleton.QueueClip(absFilePath, localPath);
return(URLAudioClipManager.singleton.GetClip(clip.uid));
}
/**
* Removes a clip from this collection
*/
public bool Remove(NamedAudioClip sourceClip)
{
if (_clips == null)
{
return(false);
}
var clip = FindByNamedAudioClip(sourceClip);
if (clip == null)
{
return(false);
}
ResetUnplayedClips();
return(true);
}
public void RemoveClip(NamedAudioClip c)
{
if (c != null && clips_.Contains(c))
{
if (currentClip_ == c)
{
StopAudio();
needsDelay_ = false;
currentClip_ = null;
}
clips_.Remove(c);
Reshuffle();
}
}
// Converts a NamedAudioClip into a AudioMateClip and creates the necessary UI to display the clip
// in the clip library
private AudioMateClip CreateClip(NamedAudioClip sourceClip)
{
var clip = new AudioMateClip(sourceClip);
var clipUID = GetClipObjectName(clip);
var go = new GameObject(clipUID);
go.transform.SetParent(_content, false);
var gridLayout = go.AddComponent <HorizontalLayoutGroup>();
gridLayout.spacing = 10f;
gridLayout.childForceExpandWidth = false;
gridLayout.childControlWidth = true;
gridLayout.childForceExpandHeight = true;
gridLayout.childControlHeight = false;
gridLayout.padding = new RectOffset(5, 5, -20, -20);
var buttonGroup = gridLayout.gameObject.AddComponent <HorizontalButtonGroup>();
var previewButton = buttonGroup.CreateButton("\u25B6", Styles.Success, () =>
{
clip.SourceClip.Test();
Cursor.Clip = clip;
Cursor.Index = Clips.IndexOf(clip);
RefreshUI();
}, false, 10f);
var toggleButton = buttonGroup.CreateButton(clip.DisplayName, Styles.Disabled, () =>
{
clip.ToggleState();
if (clip.IsInActiveCollection)
{
_collections.AddClipToActiveCollection(clip);
}
else
{
_collections.RemoveClipFromActiveCollection(clip);
}
RefreshUI();
}, true, 100f);
clip.UI.PreviewButton = previewButton;
clip.UI.ToggleButton = toggleButton;
clip.RefreshUI();
return(clip);
}
public BreathEntry(string name, float breatheOut, float holdOut, float breatheIn, float holdIn, bool noseIn)
{
this.name = name;
this.breatheOut = breatheOut;
this.holdOut = holdOut;
this.breatheIn = breatheIn;
this.holdInReference = holdIn - breatheIn;
this.noseIn = noseIn;
string filename = "./" + AUDIO_DIR + name;
audioClip = URLAudioClipManager.singleton.GetClip(filename);
if (audioClip == null)
{
URLAudioClipManager.singleton.QueueClip(SCENE_DIR + AUDIO_DIR + name);
audioClip = URLAudioClipManager.singleton.GetClip(filename);
}
}
public void playRandom(AudioSource audioSource, float volume = 1.0f, float delay = 0)
{
NamedAudioClip nac = audioClips[next];
if (audioSource != null && nac.clipToPlay != null)
{
audioSource.clip = audioClips[next].clipToPlay;
audioSource.volume = volume;
audioSource.pitch = UnityEngine.Random.Range(pitchlow, pitchhigh);
audioSource.PlayDelayed(delay);
previous = next;
next = (int)UnityEngine.Random.Range(0f, (float)audioClips.Count - 1);
// take next if its the same again
if (next == previous)
{
next = (next + 1) % audioClips.Count;
}
}
}
public BreathController(DollmasterPlugin dm) : base(dm)
{
chestControl = atom.GetStorableByID("chestControl") as FreeControllerV3;
string SFX_PATH = DollmasterPlugin.ASSETS_PATH + "/SFX";
breathingMouth = DollmasterPlugin.LoadAudio(SFX_PATH + "/breathing_mouth.wav");
breathingNose = DollmasterPlugin.LoadAudio(SFX_PATH + "/breathing_nose.wav");
breathingPanting = DollmasterPlugin.LoadAudio(SFX_PATH + "/breathing_panting.mp3");
breathEnabled = new JSONStorableBool("breathEnabled", true);
dm.RegisterBool(breathEnabled);
UIDynamicToggle moduleEnableToggle = dm.CreateToggle(breathEnabled);
moduleEnableToggle.label = "Enable Breathing";
moduleEnableToggle.backgroundColor = Color.green;
dm.CreateSpacer();
}
private AudioMateClip FindByNamedAudioClip(NamedAudioClip sourceClip)
{
return(_clips?.Find(x => x.SourceClip == sourceClip));
}
/**
* Checks if a NamedAudioClip already exists in this collection.
*/
public bool ContainsNamedAudioClip(NamedAudioClip namedAudioClip)
{
return(ContainsNamedAudioClip(namedAudioClip.uid));
}
public AudioMateClip(NamedAudioClip sourceClip)
{
SourceClip = sourceClip;
Init();
}
public override void Update()
{
base.Update();
if (breathEnabled.val == false)
{
return;
}
if (dm.arousal.value > 1)
{
breathesPerMinute += 2.0f * Time.deltaTime;
}
else
{
breathesPerMinute -= 10.0f * Time.deltaTime;
}
breathesPerMinute = Mathf.Clamp(breathesPerMinute, minBPM, maxBPM);
float amount = 6.0f;
float oneBreathePerMinute = Time.deltaTime * Mathf.PI * 2.0f / 60.0f;
cycle += oneBreathePerMinute * breathesPerMinute;
chestControl.jointRotationDriveXTarget = Mathf.Sin(cycle * 0.5f) * amount;
if (dm.kissController.isKissing)
{
return;
}
if (dm.headAudioSource.playingClip == null)
{
if (breathesPerMinute > 100 && dm.thrustController.slider.slider.value > 2 && dm.arousal.value > 20)
{
NamedAudioClip pantingClip = dm.personality.GetRandomPantingClip();
if (pantingClip == null)
{
pantingClip = breathingPanting;
}
if (pantingClip == null)
{
return;
}
dm.headAudioSource.PlayIfClear(pantingClip);
breatheWithMouth = true;
}
else
if (breathesPerMinute > 60)
{
if (dm.thrustController.sliderValue <= 0 && breathingMouth != null)
{
dm.headAudioSource.PlayIfClear(breathingMouth);
}
breatheWithMouth = true;
}
else
{
if (dm.thrustController.sliderValue <= 0 && breathingNose != null)
{
dm.headAudioSource.PlayIfClear(breathingNose);
}
breatheWithMouth = false;
}
}
}
