void Update() { try { foreach (var tracked in TrackedMorphs) { if (!tracked.Enabled) { continue; } tracked.Sync(); } } catch (Exception e) { SuperController.LogError("Exception caught: " + e); } }
public override void Init() { Log("### Init ###"); try { base.Init(); _triggers = new TriggerManager(this); InitStorables(); InitFileManager(); StartCoroutine(DeferredInit()); } catch (Exception e) { SuperController.LogError($"AudioMate.{nameof(AudioMateController)}.{nameof(Init)}: {e}"); } }
private void OnAnimationParametersChanged() { try { scrubberJSON.max = animationEditContext.current.animationLength; scrubberJSON.valNoCallback = animationEditContext.clipTime; timeJSON.valNoCallback = animationEditContext.playTime; speedJSON.valNoCallback = animation.speed; BroadcastToControllers(nameof(IRemoteControllerPlugin.OnTimelineAnimationParametersChanged)); } catch (Exception exc) { SuperController.LogError($"Timeline.{nameof(AtomPlugin)}.{nameof(OnAnimationParametersChanged)}: {exc}"); } }
public override void Init() { try { defautHeight = new JSONStorableFloat("Default height", heightByDef, 0.0f, 2.0f, true); defautHeight.storeType = JSONStorableParam.StoreType.Full; RegisterFloat(defautHeight); CreateSlider(defautHeight, true); StartCoroutine(Setup()); } catch (Exception e) { SuperController.LogError("Exception caught: " + e); } }
public AtomStorableSelector( MVRScript plug, CallbackAction call, string startAtom = "None") : base(call) { try { atomSelected = new AtomSelector(plug, this.SyncAtom, startAtom); storableChooser = new JSONStorableStringChooser("element", null, null, "Element", SyncStorable); plug.RegisterStringChooser(storableChooser); UIDynamicPopup dp = plug.CreateScrollablePopup(storableChooser); dp.popupPanelHeight = 960f; } catch (Exception e) { SuperController.LogError("Exception caught: " + e); } }
public override JSONClass GetJSON(bool includePhysical = true, bool includeAppearance = true, bool forceStore = false) { var json = base.GetJSON(includePhysical, includeAppearance, forceStore); try { json["actions"] = _customCommands.GetJSON(); needsStore = true; } catch (Exception exc) { SuperController.LogError($"Keybindings: {nameof(CustomActions)}.{nameof(GetJSON)}: {exc}"); } return(json); }
public override void Init() { try { // TODO: Implement this! SuperController.LogMessage("Plugin installed"); #if (VAM_DIAGNOSTICS) SuperController.LogMessage("This will only appear in debug mode"); #endif } catch (Exception e) { SuperController.LogError("Failed to initialize plugin: " + e); } }
public AtomClipboardEntry Start(float clipTime, IEnumerable <FreeControllerAnimationTarget> targets) { // ReSharper disable once RedundantEnumerableCastCall var snapshot = AtomAnimationClip.Copy(clipTime, targets.Cast <IAtomAnimationTarget>().ToList()); if (snapshot.controllers.Count == 0) { SuperController.LogError($"Timeline: Cannot offset, no keyframes were found at time {clipTime}."); return(null); } if (snapshot.controllers.Select(c => _clip.targetControllers.First(t => t.controller == c.controller)).Any(t => !t.EnsureParentAvailable(false))) { return(null); } return(snapshot); }
public void OnDisable() { try { if (animation?.IsPlaying() ?? false) { animation.Stop(); } _ui?.Disable(); DestroyControllerPanel(); } catch (Exception exc) { SuperController.LogError($"VamTimeline.{nameof(AtomPlugin)}.{nameof(OnDisable)}: " + exc); } }
private IEnumerator StopWhenPlaybackIsComplete() { var waitFor = plugin.animation.Clips.Sum(c => c.NextAnimationTime.IsSameFrame(0) ? c.animationLength : c.NextAnimationTime); yield return(new WaitForSeconds(waitFor)); try { SuperController.singleton.motionAnimationMaster.StopRecord(); plugin.animation.Stop(); } catch (Exception exc) { SuperController.LogError($"VamTimeline.{nameof(AdvancedScreen)}.{nameof(StopWhenPlaybackIsComplete)}: {exc}"); } }
public AudioMateClipCollection(JSONNode jn, AudioMateController controller) { if (jn == null || jn.AsObject == null) { return; } try { _controller = controller; Parse(jn); } catch (Exception e) { SuperController.LogError($"AudioMate.{nameof(AudioMateClipCollection)}.{nameof(AudioMateClipCollection)} (JSON): {e}"); } }
private void InitFloatParamsUI() { _addStorableListJSON = new JSONStorableStringChooser("Animate storable", new List <string>(), "", "Animate Storable", (string name) => { RefreshStorableFloatsList(); _addParamListJSON.valNoCallback = _addParamListJSON.choices.FirstOrDefault() ?? ""; }); _addStorableListUI = prefabFactory.CreateScrollablePopup(_addStorableListJSON); _addStorableListUI.popupPanelHeight = 700f; _addStorableListUI.popup.onOpenPopupHandlers += RefreshStorablesList; _addParamListJSON = new JSONStorableStringChooser("Animate param", new List <string>(), "", "Animate param"); _addParamListUI = prefabFactory.CreateScrollablePopup(_addParamListJSON); _addParamListUI.popup.onOpenPopupHandlers += RefreshStorableFloatsList; _addParamListUI.popupPanelHeight = 600f; _toggleFloatParamUI = prefabFactory.CreateButton("Add param"); _toggleFloatParamUI.button.onClick.AddListener(() => AddAnimatedFloatParam()); RefreshStorablesList(); RefreshStorableFloatsList(); var character = plugin.containingAtom.GetComponentInChildren <DAZCharacterSelector>(); if (character != null) { prefabFactory.CreateSpacer(); var makeMorphsAnimatableUI = prefabFactory.CreateButton("<i>Go to <b>morphs</b> (animatable)</i>"); makeMorphsAnimatableUI.button.onClick.AddListener(() => { SuperController.singleton.SelectController(plugin.containingAtom.freeControllers.First(f => f.name == "control")); var selector = plugin.containingAtom.gameObject.GetComponentInChildren <UITabSelector>(); if (selector == null) { SuperController.LogError("Could not find the tabs selector"); } else if (character.selectedCharacter.isMale) { selector.SetActiveTab("Male Morphs"); } else { selector.SetActiveTab("Female Morphs"); } }); } }
public void Update() { try { if (!_active) { if (_toggleKey != KeyCode.None && Input.GetKeyDown(_toggleKey)) { _activeJSON.val = true; return; } return; } if (!HealthCheck()) { return; } if (Input.GetKeyDown(KeyCode.Escape) || _toggleKey != KeyCode.None && Input.GetKeyDown(_toggleKey)) { _activeJSON.val = false; return; } var navigationRig = SuperController.singleton.navigationRig; if (_follower != null) { PossessRotation(); } else if (_rotationLockJSON.val) { UpdateRotation(navigationRig, _rotationSmoothingJSON.val); } if (_positionLockJSON.val) { UpdatePosition(navigationRig, _positionSmoothingJSON.val); } } catch (Exception e) { SuperController.LogError("Failed to update: " + e); } }
private void UpdateAnimationLength(float newLength) { if (animation.isPlaying) { _lengthJSON.valNoCallback = current.animationLength; return; } newLength = newLength.Snap(animation.snap); if (newLength < 0.1f) { newLength = 0.1f; } var time = animation.clipTime.Snap(); switch (_lengthModeJSON.val) { case ChangeLengthModeStretch: operations.Resize().Stretch(newLength); break; case ChangeLengthModeCropExtendEnd: operations.Resize().CropOrExtendEnd(newLength); break; case ChangeLengthModeCropExtendBegin: operations.Resize().CropOrExtendAt(newLength, 0f); break; case ChangeLengthModeCropExtendAtTime: operations.Resize().CropOrExtendAt(newLength, time); break; case ChangeLengthModeLoop: operations.Resize().Loop(newLength); break; default: SuperController.LogError($"VamTimeline: Unknown animation length type: {_lengthModeJSON.val}"); break; } _lengthJSON.valNoCallback = current.animationLength; current.DirtyAll(); animation.clipTime = Math.Min(time, newLength); }
public override bool Validate() { if (context.containingAtom.GetStorableIDs().Any(id => id.EndsWith("Glance"))) { return(false); } Rescan(); if (controlAutoFocusPoint.val) { _autoFocusPoint = SuperController.singleton.GetAtoms().FirstOrDefault(a => a.type == "Empty" && a.uid == "AutoFocusPoint")?.mainController.control; if (_autoFocusPoint == null) { SuperController.LogError("Embody: There is no AutoFocusPoint atom of type Empty in your scene."); } } return(_mirrors.Count > 0 || _objects.Count > 0 || _autoFocusPoint != null); }
public void ChangeAnimation(string animationName) { if (string.IsNullOrEmpty(animationName)) { return; } try { animation.SelectAnimation(animationName); animationJSON.valNoCallback = animation.current.animationName; } catch (Exception exc) { SuperController.LogError($"VamTimeline.{nameof(AtomPlugin)}.{nameof(ChangeAnimation)}: {exc}"); } }
void Update() { try { if (Input.GetKey(KeyCode.LeftControl) || Input.GetKey(KeyCode.RightControl)) { if (Input.GetKeyDown(KeyCode.D)) { CloneSelected(); } } } catch (Exception e) { SuperController.LogError("Exception caught: " + e); } }
public static void DebugLog(string condition, string stackTrace, LogType type) { if (condition == null || condition.StartsWith("Log ") || string.IsNullOrEmpty(stackTrace)) { return; } var msg = $"{type} {condition} {stackTrace}"; if (type == LogType.Error || type == LogType.Exception) { SuperController.LogError(msg); } else { SuperController.LogMessage(msg); } }
public override JSONClass GetJSON(bool includePhysical = true, bool includeAppearance = true, bool forceStore = false) { var json = base.GetJSON(includePhysical, includeAppearance, forceStore); try { json["Animation"] = serializer.SerializeAnimation(animation); json["Options"] = AtomAnimationSerializer.SerializeEditContext(animationEditContext); needsStore = true; } catch (Exception exc) { SuperController.LogError($"Timeline.{nameof(AtomPlugin)}.{nameof(GetJSON)} (Serialize): {exc}"); } return(json); }
private void EnableAllTargets() { try { var allControllers = plugin.animation.Clips.SelectMany(c => c.TargetControllers).Select(t => t.controller).Distinct().ToList(); var h = new HashSet <JSONStorableFloat>(); var allFloatParams = plugin.animation.Clips.SelectMany(c => c.TargetFloatParams).Where(t => h.Add(t.floatParam)).Select(t => new FloatParamRef { Storable = t.storable, FloatParam = t.floatParam }).ToList(); foreach (var clip in plugin.animation.Clips) { foreach (var controller in allControllers) { if (!clip.TargetControllers.Any(t => t.controller == controller)) { var target = clip.Add(controller); if (target != null) { target.SetKeyframeToCurrentTransform(0f); target.SetKeyframeToCurrentTransform(clip.animationLength); } } } clip.TargetControllers.Sort(new FreeControllerAnimationTarget.Comparer()); foreach (var floatParamRef in allFloatParams) { if (!clip.TargetFloatParams.Any(t => t.floatParam == floatParamRef.FloatParam)) { var target = clip.Add(floatParamRef.Storable, floatParamRef.FloatParam); if (target != null) { target.SetKeyframe(0f, floatParamRef.FloatParam.val); target.SetKeyframe(clip.animationLength, floatParamRef.FloatParam.val); } } } clip.TargetFloatParams.Sort(new FloatParamAnimationTarget.Comparer()); } } catch (Exception exc) { SuperController.LogError($"VamTimeline.{nameof(TargetsScreen)}.{nameof(EnableAllTargets)}: {exc}"); } }
// FixedUpdate is called with each physics simulation frame by Unity void FixedUpdate() { try { if (containingAtom.type != "Person") { return; } DAZCharacterSelector dcs = containingAtom.GetComponentInChildren <DAZCharacterSelector>(); BreastsFixedUpdate(dcs); GlutesFixedUpdate(dcs); } catch (Exception e) { SuperController.LogError("Exception caught FixedUpdate(): " + e); } }
public override void Init() { try { _atom = GetAtom(); InitStorables(); InitCustomUI(); if (!_hideJSON.val) { OnEnable(); } } catch (Exception exc) { SuperController.LogError($"VamTimeline.{nameof(ControllerPlugin)}.{nameof(Init)}: " + exc); } }
public override void Init() { try { _step = containingAtom.parentAtom.GetComponentInChildren <AnimationStep>(); if (_step == null) { throw new Exception("Can only apply DirectorStep on AnimationStep"); } InitControls(); } catch (Exception e) { SuperController.LogError("Failed to initialize plugin: " + e); } }
private void Import() { try { #if (VAM_GT_1_20) FileManagerSecure.CreateDirectory(_saveFolder); var shortcuts = FileManagerSecure.GetShortCutsForDirectory(_saveFolder); SuperController.singleton.GetMediaPathDialog(ImportFileSelected, _saveExt, _saveFolder, false, true, false, null, false, shortcuts); #else SuperController.singleton.GetMediaPathDialog(ImportFileSelected, _saveExt, _saveFolder); #endif } catch (Exception exc) { SuperController.LogError($"Timeline: Failed to open file dialog: {exc}"); } }
/** * Set the audio source controller which plays the clips */ public void SyncAudioReceiver() { if (ReceiverAtom == null || ReceiverNode == null) { return; } try { Receiver = SuperController.singleton.GetAtomByUid(ReceiverAtom)?.GetStorableByID(ReceiverNode) as AudioSourceControl; } catch (Exception e) { SuperController.LogError($"AudioMate.{nameof(AudioMateController)}.{nameof(SyncAudioReceiver)}: {e}"); } }
public void OnTimelineEvent(object[] e) { if (_receiving) { throw new InvalidOperationException("Already syncing, infinite loop avoided!"); } _receiving = true; try { switch ((string)e[0]) { case nameof(SendPlaybackState): ReceivePlaybackState(e); break; case nameof(SendTime): ReceiveTime(e); break; case nameof(SendCurrentAnimation): ReceiveCurrentAnimation(e); break; case nameof(SendScreen): ReceiveScreen(e); break; case nameof(SendSyncAnimation): ReceiveSyncAnimation(e); break; default: SuperController.LogError($"Received message name {e[0]} but no handler exists for that event"); break; } } catch (Exception exc) { SuperController.LogError($"VamTimeline.{nameof(PeerManager)}.{nameof(OnTimelineEvent)}: {exc}"); } finally { _receiving = false; } }
private JSONClass GetCollectionsJSON() { var json = new JSONClass(); try { foreach (var collection in _collections.Where(collection => collection != null && collection.Count != 0)) { json[collection.Name] = collection.ToJSON(); } } catch (Exception e) { SuperController.LogError($"AudioMate.{nameof(AudioMateCollectionManager)}.{nameof(GetCollectionsJSON)}: {e}"); } return(json); }
private void StartRecordOffset() { if (current.clipTime < _startJSON.val || current.clipTime > _endJSON.val) { SuperController.LogError($"VamTimeline: Cannot offset, current time is outside of the bounds of the selection"); return; } _offsetSnapshot = current.Copy(current.clipTime, current.GetAllOrSelectedTargets().OfType <FreeControllerAnimationTarget>().Cast <IAtomAnimationTarget>()); if (_offsetSnapshot.controllers.Count == 0) { SuperController.LogError($"VamTimeline: Cannot offset, no keyframes were found at time {current.clipTime}."); return; } _offsetControllerUI.label = _offsetControllerUIOfsettingLabel; _offsetting = true; }
public override void Init() { try { _atom = GetAtom(); _labelJSON = new JSONStorableString("Label", "My Slider", label => { if (_ui == null) { return; } _ui.label = label; }); RegisterString(_labelJSON); CreateTextInput(_labelJSON); _valueJSON = new JSONStorableFloat(_labelJSON.val, 0f, v => UpdateValue(v), 0f, 10f, false); RegisterFloat(_valueJSON); OnEnable(); _atomJSON = new JSONStorableStringChooser("Target atom", SuperController.singleton.GetAtomUIDs(), "", "Target atom", uid => OnTargetAtomChanged(uid)); RegisterStringChooser(_atomJSON); var atomPopup = CreateScrollablePopup(_atomJSON, true); atomPopup.popupPanelHeight = 800f; SuperController.singleton.onAtomUIDsChangedHandlers += (uids) => OnAtomsChanged(uids); OnAtomsChanged(SuperController.singleton.GetAtomUIDs()); var storables = new List <string>(new[] { "" }); _storableJSON = new JSONStorableStringChooser("Target storable", storables, "", "Target storable", storable => OnTargetStorableChanged(storable)); RegisterStringChooser(_storableJSON); var storablePopup = CreateScrollablePopup(_storableJSON, true); storablePopup.popupPanelHeight = 800f; var storableParams = new List <string>(new[] { "" }); _storableParamJSON = new JSONStorableStringChooser("Target param", storables, "", "Target param", floatParam => OnTargetParamChanged(floatParam)); RegisterStringChooser(_storableParamJSON); var storableParamUI = CreateScrollablePopup(_storableParamJSON, true); storableParamUI.popupPanelHeight = 800f; } catch (Exception exc) { SuperController.LogError($"{nameof(UISlider)}.{nameof(Init)}: " + exc); } }
// FixedUpdate is called with each physics simulation frame by Unity void FixedUpdate() { try { // apply forces here float timeFactor = Time.fixedDeltaTime; currentForce = Vector3.Lerp(currentForce, targetForce, timeFactor * forceQuicknessJSON.val); currentTorque = Vector3.Lerp(currentTorque, targetTorque, timeFactor * torqueQuicknessJSON.val); if (RB && (!SuperController.singleton || !SuperController.singleton.freezeAnimation)) { RB.AddForce(currentForce, ForceMode.Force); RB.AddTorque(currentTorque, ForceMode.Force); } } catch (Exception e) { SuperController.LogError("Exception caught: " + e); } }