protected void SyncfloatTarget(string floatTargetName)
{
floatTarget = null;
if (storableSelected.storable != null && floatTargetName != null && floatTargetName != "None")
{
floatTarget = storableSelected.storable.GetFloatJSONParam(floatTargetName);
if (floatTarget != null)
{
SuperController.LogMessage(">> " + floatTarget.val);
if (!insideRestore)
{
currentValue.val = floatTarget.val;
}
currentValue.min = floatTarget.min;
currentValue.max = floatTarget.max;
currentValueSlider.gameObject.SetActive(true);
}
}
else
{
floatTarget = null;
currentValueSlider.gameObject.SetActive(false);
}
}
protected void SyncReceiverTarget(string receiverTargetName)
{
_receiverTargetName = receiverTargetName;
receiverTarget = null;
if (receiver != null && receiverTargetName != null)
{
receiverTarget = receiver.GetFloatJSONParam(receiverTargetName);
if (receiverTarget != null)
{
lowerValueJSON.min = receiverTarget.min;
lowerValueJSON.max = receiverTarget.max;
upperValueJSON.min = receiverTarget.min;
upperValueJSON.max = receiverTarget.max;
currentValueJSON.min = receiverTarget.min;
currentValueJSON.max = receiverTarget.max;
targetValueJSON.min = receiverTarget.min;
targetValueJSON.max = receiverTarget.max;
if (!insideRestore)
{
lowerValueJSON.val = receiverTarget.val;
upperValueJSON.val = receiverTarget.max;
currentValueJSON.val = receiverTarget.val;
targetValueJSON.val = receiverTarget.val;
}
}
}
}
protected void RotationMultiFloatCallback(JSONStorableFloat jf)
{
if (jFoot != null)
{
jFoot.val = "\n" + jf.name + " set to " + jf.val.ToString("0.00");
}
}
public override void Init()
{
try
{
containingAtom.freeControllers.ToList().ForEach((controller) =>
{
initialRotationSpring[controller] = controller.RBHoldRotationSpring;
initialPositionSpring[controller] = controller.RBHoldPositionSpring;
});
rotationAmount = new JSONStorableFloat("rotationAmount", 300.0f, 0.0f, 500.0f);
RegisterFloat(rotationAmount);
CreateSlider(rotationAmount);
rotationSpeed = new JSONStorableFloat("rotationSpeed", 0.3f, 0.0f, 10.0f);
RegisterFloat(rotationSpeed);
CreateSlider(rotationSpeed);
positionAmount = new JSONStorableFloat("positionAmount", 400.0f, 0.0f, 500.0f);
RegisterFloat(positionAmount);
CreateSlider(positionAmount);
positionSpeed = new JSONStorableFloat("positionSpeed", 0.45f, 0.0f, 10.0f);
RegisterFloat(positionSpeed);
CreateSlider(positionSpeed);
}
catch (Exception e)
{
SuperController.LogError("Exception caught: " + e);
}
}
public void InitBreathing(Atom containingAtom, JSONStorableFloat theStomachMorph)
{
try
{
stomachMorph = theStomachMorph;
chestController = containingAtom.GetStorableByID("chestControl") as FreeControllerV3;
if (chestController != null)
{
chestController.jointRotationDriveSpring = 90.0f;
chestController.jointRotationDriveDamper = 1.0f;
}
breatheNeedInit = true;
float v = 0.2f * (breathEntries.Length - 1);
float min = Mathf.Max(0 - v - 1.0f, -0.5f);
float max = Mathf.Min(v + 1.0f, breathEntries.Length - 0.5f);
int index = Mathf.RoundToInt(UnityEngine.Random.Range(min, max));
breatheIndex = Mathf.Clamp(index, 0, breathEntries.Length - 1);
breatheCycle = 0.0f;
breathePower = UnityEngine.Random.Range(0.8f, 1.2f);
breatheDuration = UnityEngine.Random.Range(0.0f, 1.5f);
}
catch (Exception e) { SuperController.LogError("Exception caught: " + e + " (May be related to: Easy Sounds must be loaded on a female Person atom."); }
}
private JSONStorableFloat CreateAnalog(string ns, string jsfName)
{
var jsf = new JSONStorableFloat(jsfName, 0f, -1f, 1f);
_remoteCommandsManager.Add(new JSONStorableFloatCommandInvoker(_owner, ns, jsfName, jsf));
return(jsf);
}
public FloatParamAnimationTarget(JSONStorable storable, JSONStorableFloat floatParam)
: this(storable.containingAtom, storable.storeId, floatParam.name)
{
this.storable = storable;
this.floatParam = floatParam;
_available = true;
}
public override void Init()
{
try
{
headDistance = new JSONStorableFloat("Camera to head distance required", 0.2f, 0f, 0.5f, true);
headDistance.storeType = JSONStorableParam.StoreType.Full;
RegisterFloat(headDistance);
CreateSlider(headDistance, false);
xOffsetSlider = new JSONStorableFloat("X Offset", 0.045f, -0.1f, 0.1f, true);
xOffsetSlider.storeType = JSONStorableParam.StoreType.Full;
RegisterFloat(xOffsetSlider);
CreateSlider(xOffsetSlider, false);
provider = FindObjectOfType <LeapProvider>() as LeapProvider;
frame = provider.CurrentFrame;
hands = frame.Hands;
if (SuperController.singleton.isOVR)
{
mainCamera = SuperController.singleton.ViveCenterCamera;
}
else
{
mainCamera = SuperController.singleton.lookCamera;
}
}
catch (Exception e)
{
SuperController.LogError("Exception caught: " + e);
}
}
public UIDynamicSlider CreateUISliderInCanvas(JSONStorableFloat jsf, float x, float y)
{
var canvas = _atom.GetComponentInChildren <Canvas>();
if (canvas == null)
{
throw new NullReferenceException("Could not find a canvas to attach to");
}
var transform = UnityEngine.Object.Instantiate(_owner.manager.configurableSliderPrefab.transform);
if (transform == null)
{
throw new NullReferenceException("Could not instantiate configurableSliderPrefab");
}
_components.Add(transform);
transform.SetParent(canvas.transform, false);
transform.gameObject.SetActive(true);
var ui = transform.GetComponent <UIDynamicSlider>();
if (ui == null)
{
throw new NullReferenceException("Could not find a UIDynamicSlider component");
}
ui.Configure(jsf.name, jsf.min, jsf.max, jsf.defaultVal, jsf.constrained, "F3", true, !jsf.constrained);
jsf.slider = ui.slider;
ui.slider.interactable = true;
transform.Translate(Vector3.down * y, Space.Self);
transform.Translate(Vector3.right * x, Space.Self);
return(ui);
}
public Receiver(Breathe script, List <string> atoms, int index, bool rightSide)
{
this.index = index;
script.CreateSpacer(rightSide);
vartrigChooser = new JSONStorableStringChooser("receiver" + index, atoms, "", "Variable Trigger " + index);
vartrigChooser.setCallbackFunction += (string atomId) => {
Atom atom = script.GetAtomById(atomId);
JSONStorable storable = (atom != null) ? storable = atom.GetStorableByID("Trigger") : null;
vartrig = (storable != null) ? storable.GetFloatJSONParam("value") : null;
};
script.CreateScrollablePopup(vartrigChooser, rightSide);
script.RegisterStringChooser(vartrigChooser);
List <string> modes = new List <string>()
{
"Out+In", "OutHold", "InHold", "OutInSmooth", "OutSmooth", "InSmooth"
};
blendModeChooser = new JSONStorableStringChooser("mode" + index, modes, modes[blendMode], "Mode " + index);
blendModeChooser.setCallbackFunction += (string modeName) => {
blendMode = modes.FindIndex((string entry) => { return(entry == modeName); });
};
script.CreateScrollablePopup(blendModeChooser, rightSide);
script.RegisterStringChooser(blendModeChooser);
offsetStart = script.SetupSlider("Time Offset Start " + index, 0.0f, -0.5f, 0.5f, rightSide);
offsetEnd = script.SetupSlider("Time Offset End " + index, 0.0f, -0.5f, 2.0f, rightSide);
power = script.SetupSlider("Power " + index, 1.0f, 0.0f, 1.0f, rightSide);
}
public FloatSelector(
MVRScript plug, bool insideRestore,
CallbackAction call,
string startAtom = null,
AtomStorableSelector _storableSelected = null)
{
try
{
currentValue = new JSONStorableFloat("current value", 0f, setValue, -1f, 1f, false);
plug.RegisterFloat(currentValue);
currentValueSlider = plug.CreateSlider(currentValue, true);
currentValueSlider.gameObject.SetActive(false);
this.insideRestore = insideRestore;
if (_storableSelected == null)
{
storableSelected = new AtomStorableSelector(plug, SyncStorable, startAtom);
}
else
{
storableSelected = _storableSelected;
storableSelected.Add(SyncStorable);
}
floatChooser = new JSONStorableStringChooser("floatTarget", null, null, "Value", SyncfloatTarget);
UIDynamicPopup dp = plug.CreateScrollablePopup(floatChooser);
dp.popupPanelHeight = 820f;
plug.RegisterStringChooser(floatChooser);
}
catch (Exception e)
{
SuperController.LogError("Exception caught: " + e);
}
}
private void InitSequenceUI(bool rightSide)
{
_nextAnimationJSON = new JSONStorableStringChooser("Next Animation", GetEligibleNextAnimations(), "", "Next Animation", (string val) => ChangeNextAnimation(val));
RegisterStorable(_nextAnimationJSON);
var nextAnimationUI = plugin.CreateScrollablePopup(_nextAnimationJSON, rightSide);
nextAnimationUI.popupPanelHeight = 260f;
RegisterComponent(nextAnimationUI);
_nextAnimationTimeJSON = new JSONStorableFloat("Next Blend After Seconds", 0f, (float val) => SetNextAnimationTime(val), 0f, 60f, false)
{
valNoCallback = current.NextAnimationTime
};
RegisterStorable(_nextAnimationTimeJSON);
var nextAnimationTimeUI = plugin.CreateSlider(_nextAnimationTimeJSON, rightSide);
nextAnimationTimeUI.valueFormat = "F3";
RegisterComponent(nextAnimationTimeUI);
_blendDurationJSON = new JSONStorableFloat("BlendDuration", AtomAnimationClip.DefaultBlendDuration, v => UpdateBlendDuration(v), 0f, 5f, false);
RegisterStorable(_blendDurationJSON);
var blendDurationUI = plugin.CreateSlider(_blendDurationJSON, rightSide);
blendDurationUI.valueFormat = "F3";
RegisterComponent(blendDurationUI);
UpdateNextAnimationPreview();
}
public ExpressionController(DollmasterPlugin dm) : base(dm)
{
expressionsEnabled = new JSONStorableBool("expressionsEnabled", true);
dm.RegisterBool(expressionsEnabled);
UIDynamicToggle moduleEnableToggle = dm.CreateToggle(expressionsEnabled);
moduleEnableToggle.label = "Enable Expressions + Voice";
moduleEnableToggle.backgroundColor = Color.green;
JSONStorable geometry = atom.GetStorableByID("geometry");
DAZCharacterSelector character = geometry as DAZCharacterSelector;
morphControl = character.morphsControlUI;
mouthOpenMorph = morphControl.GetMorphByDisplayName("Mouth Open Wide");
tongueRaiseMorph = morphControl.GetMorphByDisplayName("Tongue Raise-Lower");
interpolationSpeed = new JSONStorableFloat("expression speed", 8f, 0.1f, 20.0f, true);
dm.RegisterFloat(interpolationSpeed);
dm.CreateSlider(interpolationSpeed);
upperJaw = atom.GetStorableByID("upperJaw") as DAZBone;
lowerJaw = atom.GetStorableByID("lowerJaw") as DAZBone;
// Hack to fix bad tongue morph values
morphControl.GetMorphByDisplayName("Tongue In-Out").startValue = 1.0f;
dm.CreateSpacer();
}
private void InitializeUI()
{
vibrationFrequencyStorable = new JSONStorableFloat("Frequency", 0.2f,
(float value) => {
if (vibrationAutoStrength.val)
{
// 1-Mathf.Pow(valueFrom0to1,3)
vibrationStrengthStorable.valNoCallback = StrengthFromFrequency(value);
}
},
0f, 1f);
RegisterFloat(vibrationFrequencyStorable);
CreateSlider(vibrationFrequencyStorable);
vibrationStrengthStorable = new JSONStorableFloat("Strength", 0.03f,
(float value) => {
vibrationAutoStrength.val = false;
},
0f, 1f);
RegisterFloat(vibrationStrengthStorable);
var strengthSlider = CreateSlider(vibrationStrengthStorable, rightSide: true);
vibrationAutoStrength = new JSONStorableBool("AutoStrength", true, (bool value) => {
if (value)
{
vibrationStrengthStorable.valNoCallback = StrengthFromFrequency(vibrationFrequencyStorable.val);
}
});
RegisterBool(vibrationAutoStrength);
CreateToggle(vibrationAutoStrength, rightSide: true);
}
public override void Awake()
{
try
{
base.Awake();
autoSetup = new SnugAutoSetup(context.containingAtom, this);
disableSelfGrabJSON = new JSONStorableBool("DisablePersonGrab", false);
falloffJSON = new JSONStorableFloat("Falloff", 0.3f, 0f, 5f, false);
_lHand = new SnugHand {
controller = containingAtom.freeControllers.FirstOrDefault(fc => fc.name == "lHandControl")
};
_rHand = new SnugHand {
controller = containingAtom.freeControllers.FirstOrDefault(fc => fc.name == "rHandControl")
};
InitAnchors();
InitVisualCues();
}
catch (Exception exc)
{
SuperController.LogError($"{nameof(SnugModule)}.{nameof(Awake)}: {exc}");
}
}
public void OnInitStorables(VAMLaunch plugin)
{
_minPosition = new JSONStorableFloat("oscSourceMinPosition", 10.0f, 0.0f, 99.0f);
plugin.RegisterFloat(_minPosition);
_maxPosition = new JSONStorableFloat("oscSourceMaxPosition", 80.0f, 0.0f, 99.0f);
plugin.RegisterFloat(_maxPosition);
_speed = new JSONStorableFloat("oscSourceSpeed", 30.0f, 20.0f, 80.0f);
plugin.RegisterFloat(_speed);
_animationOffset = new JSONStorableFloat("oscAnimationOffset", 0.0f, 0.0f, 0.5f);
plugin.RegisterFloat(_animationOffset);
_targetAnimationAtomChooser = new JSONStorableStringChooser("oscSourceTargetAnimationAtom",
GetTargetAnimationAtomChoices(), "", "Target Animation Pattern",
(name) =>
{
_animationAtomController = null;
_targetAnimationPattern = null;
if (string.IsNullOrEmpty(name))
{
return;
}
var atom = SuperController.singleton.GetAtomByUid(name);
if (atom && atom.animationPatterns.Length > 0)
{
_animationAtomController = atom.freeControllers[0];
_targetAnimationPattern = atom.animationPatterns[0];
}
});
plugin.RegisterStringChooser(_targetAnimationAtomChooser);
}
public virtual void CreateUI(IUIBuilder builder)
{
_group = new UIGroup(builder);
var visible = false;
var group = new UIGroup(_group);
MainTitle = _group.CreateButton("Main", () => group.SetVisible(visible = !visible), new Color(0.3f, 0.3f, 0.3f), Color.white, true);
SmoothingSlider = group.CreateSlider("Plugin:Smoothing", "Smoothing (%)", 0.1f, 0.0f, 0.99f, true, true, true, "P0");
ReferenceLengthScaleSlider = group.CreateSlider("Device:ReferenceLengthScale", "Reference Length (%)", 1.0f, 0, 3, true, true, true, "P0");
ReferenceRadiusScaleSlider = group.CreateSlider("Device:ReferenceRadiusScale", "Reference Radius (%)", 3.0f, 0, 5, true, true, true, "P0");
group.SetVisible(false);
CreateL0AxisUI(_group);
CreateL1AxisUI(_group);
CreateL2AxisUI(_group);
CreateR0AxisUI(_group);
CreateR1AxisUI(_group);
CreateR2AxisUI(_group);
CreateV0AxisUI(_group);
CreateA0AxisUI(_group);
CreateA1AxisUI(_group);
CreateA2AxisUI(_group);
}
public override void Init()
{
var renderer = containingAtom.gameObject.GetComponentInChildren <SkinnedMeshRenderer>();
if (renderer == null)
{
SuperController.LogError("The atom '" + containingAtom.name + "' does not have any SkinnedMeshRenderer");
return;
}
var mesh = renderer.sharedMesh;
if (mesh == null || mesh.blendShapeCount == 0)
{
SuperController.LogError("The atom '" + containingAtom.name + "' does not have any blend shapes");
return;
}
var blendShapeIndex = 0;
do
{
var localBlendShapeIndex = blendShapeIndex;
var storable = new JSONStorableFloat(
mesh.GetBlendShapeName(blendShapeIndex),
renderer.GetBlendShapeWeight(blendShapeIndex),
new JSONStorableFloat.SetFloatCallback(val => renderer.SetBlendShapeWeight(localBlendShapeIndex, val)),
0f,
100f,
false
);
RegisterFloat(storable);
CreateSlider(storable);
}while (++blendShapeIndex < renderer.sharedMesh.blendShapeCount);
}
public PoseController(DollmasterPlugin dm) : base(dm)
{
poseEnabled = new JSONStorableBool("poseEnabled", true);
dm.RegisterBool(poseEnabled);
UIDynamicToggle moduleEnableToggle = dm.CreateToggle(poseEnabled);
moduleEnableToggle.label = "Enable Pose Change";
moduleEnableToggle.backgroundColor = Color.green;
poseAnimationDuration = new JSONStorableFloat("poseAnimationDuration", 1.2f, 0.01f, 10.0f);
dm.RegisterFloat(poseAnimationDuration);
dm.CreateSlider(poseAnimationDuration);
durationBetweenPoseChange = new JSONStorableFloat("durationBetweenPoseChange", 8.0f, 1.0f, 20.0f, false);
dm.RegisterFloat(durationBetweenPoseChange);
dm.CreateSlider(durationBetweenPoseChange);
holdPose = new JSONStorableBool("holdPose", false);
dm.RegisterBool(holdPose);
UIDynamicToggle holdPoseToggle = ui.CreateToggle("Hold Pose", 180, 40);
holdPose.toggle = holdPoseToggle.toggle;
holdPoseToggle.transform.Translate(0.415f, 0.0630f, 0, Space.Self);
holdPoseToggle.backgroundColor = new Color(0.2f, 0.2f, 0.2f);
holdPoseToggle.labelText.color = new Color(1, 1, 1);
dm.CreateSpacer();
controllers = atom.freeControllers.ToList();
}
protected void SetGlossOffset(JSONStorableFloat jf)
{
foreach (Material vamMaterial in vamMaterials.SelectMany(x => x).Where(x => x != null))
{
vamMaterial.SetFloat("_GlossOffset", jf.val);
}
}
private void CreateAndRegisterGroupStorables(string groupKey)
{
RegisterAction(new JSONStorableAction($"Play {groupKey}{AtomAnimation.RandomizeGroupSuffix}", () =>
{
animation.PlayRandom(groupKey);
}));
var setSpeedJSON = new JSONStorableFloat($"Set Speed {groupKey}{AtomAnimation.RandomizeGroupSuffix}", 0f, -1f, 5f, false);
setSpeedJSON.setCallbackFunction = val =>
{
foreach (var clip in animation.clips.Where(c => c.animationNameGroup == groupKey))
{
clip.speed = val;
}
setSpeedJSON.valNoCallback = 0;
};
RegisterFloat(setSpeedJSON);
var setWeightJSON = new JSONStorableFloat($"Set Weight {groupKey}{AtomAnimation.RandomizeGroupSuffix}", 1f, 0f, 1f);
setWeightJSON.setCallbackFunction = val =>
{
foreach (var clip in animation.clips.Where(c => c.animationNameGroup == groupKey))
{
clip.weight = val;
}
setWeightJSON.valNoCallback = 0;
};
RegisterFloat(setWeightJSON);
}
protected void SetSpecFresnel(JSONStorableFloat jf)
{
foreach (Material vamMaterial in vamMaterials.SelectMany(x => x).Where(x => x != null))
{
vamMaterial.SetFloat("_Fresnel", jf.val);
}
}
protected void SetSpecSharpness(JSONStorableFloat jf)
{
foreach (Material vamMaterial in vamMaterials.SelectMany(x => x).Where(x => x != null))
{
vamMaterial.SetFloat("_Shininess", jf.val);
}
}
private void InitPlaybackUI()
{
_animationSpeedJSON = new JSONStorableFloat("Speed (Global)", 1f, (float val) => animation.speed = val, 0f, 10f, false)
{
valNoCallback = animation.speed
};
var animationSpeedUI = prefabFactory.CreateSlider(_animationSpeedJSON);
animationSpeedUI.valueFormat = "F3";
_clipSpeedJSON = new JSONStorableFloat("Speed (Local)", 1f, (float val) => current.speed = val, 0f, 10f, false)
{
valNoCallback = current.speed
};
var clipSpeedUI = prefabFactory.CreateSlider(_clipSpeedJSON);
clipSpeedUI.valueFormat = "F3";
_clipWeightJSON = new JSONStorableFloat("Weight", 1f, (float val) => current.weight = val, 0f, 1f, true)
{
valNoCallback = current.weight
};
var clipWeigthUI = prefabFactory.CreateSlider(_clipWeightJSON);
clipWeigthUI.valueFormat = "F4";
}
public void InitUserInterface()
{
_initCompleted = false;
BrightnessPollIntervalStorable = new JSONStorableFloat("Brightness Poll Delay", BRIGHTNESS_POLL_DEFAULT, (float value) => { _detector.PollFrequency = value; }, 0f, 5f);
CreateSlider(BrightnessPollIntervalStorable);
RegisterFloat(BrightnessPollIntervalStorable);
LightAdjustSpeedStorable = new JSONStorableFloat("Light Adjust Within", 3.50f, 0f, 10f);
CreateSlider(LightAdjustSpeedStorable);
RegisterFloat(LightAdjustSpeedStorable);
DarkAdjustSpeedStorable = new JSONStorableFloat("Dark Adjust Within", 5.00f, 0f, 10f);
CreateSlider(DarkAdjustSpeedStorable);
RegisterFloat(DarkAdjustSpeedStorable);
IdleAdjustSpeedStorable = new JSONStorableFloat("Idle: Adjust Over Seconds", 1.00f, 0f, 10f);
CreateSlider(IdleAdjustSpeedStorable, rightSide: true);
RegisterFloat(IdleAdjustSpeedStorable);
IdleStrengthStorable = new JSONStorableFloat("Idle: Strength", 0.05f, 0f, 1f);
CreateSlider(IdleStrengthStorable, rightSide: true);
RegisterFloat(IdleStrengthStorable);
IdleMaxDelayStorable = new JSONStorableFloat("Idle: Next Random Run", 2.50f, 0f, 10f);
CreateSlider(IdleMaxDelayStorable, rightSide: true);
RegisterFloat(IdleMaxDelayStorable);
_screenAtomUid = new JSONStorableString("DetectorAtomUid", String.Empty);
RegisterString(_screenAtomUid);
}
public HeadController(DollmasterPlugin dm) : base(dm)
{
headControlEnabled = new JSONStorableBool("headControlEnabled", true);
dm.RegisterBool(headControlEnabled);
UIDynamicToggle moduleEnableToggle = dm.CreateToggle(headControlEnabled);
moduleEnableToggle.label = "Enable Head Gaze";
moduleEnableToggle.backgroundColor = Color.green;
durationBetweenLookChange = new JSONStorableFloat("duration between look at toggle", 8, 1, 30, false);
dm.RegisterFloat(durationBetweenLookChange);
dm.CreateSlider(durationBetweenLookChange);
headTurnSpeed = new JSONStorableFloat("headTurnSpeed", 2.5f, 0.01f, 20.0f);
dm.RegisterFloat(headTurnSpeed);
dm.CreateSlider(headTurnSpeed);
headControl = atom.GetStorableByID("headControl") as FreeControllerV3;
chestControl = atom.GetStorableByID("chestControl") as FreeControllerV3;
neckBone = atom.GetStorableByID("neck") as DAZBone;
alwaysLookAtMe = new JSONStorableBool("alwaysLookAtMe", false);
dm.RegisterBool(alwaysLookAtMe);
UIDynamicToggle forceLookToggle = ui.CreateToggle("Hold Gaze", 180, 40);
alwaysLookAtMe.toggle = forceLookToggle.toggle;
forceLookToggle.transform.Translate(0.415f, 0.01f, 0, Space.Self);
forceLookToggle.backgroundColor = new Color(0.2f, 0.2f, 0.2f);
forceLookToggle.labelText.color = new Color(1, 1, 1);
eyesStorable = atom.GetStorableByID("Eyes");
dm.CreateSpacer(true);
}
protected readonly float valMaxS; //value at min mass and max softness
public PhysicsConfig(JSONStorableFloat setting, float valMinMS, float valMaxM, float valMaxS)
{
this.setting = setting;
this.valMinMS = valMinMS;
this.valMaxM = valMaxM;
this.valMaxS = valMaxS;
}
protected void SetIBLFilter(JSONStorableFloat jf)
{
foreach (Material vamMaterial in vamMaterials.SelectMany(x => x).Where(x => x != null))
{
vamMaterial.SetFloat("_IBLFilter", jf.val);
}
}
public override void Init()
{
if (containingAtom.type != "Person")
{
throw new Exception("This must be added to a Person");
}
_labiaTrigger = containingAtom.GetComponentsInChildren <CollisionTrigger>().FirstOrDefault(t => t.name == "LabiaTrigger");
_labiaHandler = _labiaTrigger.gameObject.GetComponentInChildren <CollisionTriggerEventHandler>();
_abdomen = containingAtom.freeControllers.FirstOrDefault(fc => fc.name == "abdomen2Control");
_animators = new List <LabiaAnimator>();
_animators.Add(LabiaAnimator.Create(containingAtom, "Labia minora-size", isInwardMorph: false, inwardMax: 0.7f, outwardMax: 2));
_animators.Add(LabiaAnimator.Create(containingAtom, "Labia minora-style1", isInwardMorph: false, inwardMax: 0.7f, outwardMax: 2f));
_animators.Add(LabiaAnimator.Create(containingAtom, "Labia minora-exstrophy", isInwardMorph: true, inwardMax: 0.1f, outwardMax: 1f));
_animators.Add(LabiaAnimator.Create(containingAtom, "Labia majora-relaxation", isInwardMorph: false, inwardMax: 1f, outwardMax: 0f));
_animators.Add(LabiaAnimator.Create(containingAtom, "Gen_Innie", isInwardMorph: true, inwardMax: 0.10f, outwardMax: 0.25f, easing: (p) => p * p * p));
_animators.Add(LabiaAnimator.Create(containingAtom, "Gens In - Out", isInwardMorph: true, inwardMax: 1.0f, outwardMax: 0f, enabled: false));
_animators = _animators.Where(a => a != null).ToList(); // remove any null entries
_animators.ForEach(a => a.Morph.SetDefaultValue());
FrictionStorable = new JSONStorableFloat("Friction", 1f, (f) => { _friction = f; }, 0, 1);
_friction = FrictionStorable.val;
CreateSlider(FrictionStorable);
RegisterFloat(FrictionStorable);
InwardExaggerationStorable = new JSONStorableFloat(
"Inward Exaggeration",
0f,
(val) => {
_animators.ForEach(a => a.InwardMax = a.InwardMaxDefault + val);
},
0, 1);
InwardExaggerationStorable.val = 0;
CreateSlider(InwardExaggerationStorable);
RegisterFloat(InwardExaggerationStorable);
OutwardExaggerationStorable = new JSONStorableFloat(
"Outward Exaggeration",
0f,
(val) => {
_animators.ForEach(a => a.OutwardMax = a.OutwardMaxDefault + val);
},
0, 1);
OutwardExaggerationStorable.val = 0;
CreateSlider(OutwardExaggerationStorable);
RegisterFloat(OutwardExaggerationStorable);
foreach (var a in _animators)
{
var storable = new JSONStorableBool(a.Morph.displayName, a.Enabled, (b) => {
a.Enabled = b;
a.Morph.SetDefaultValue();
});
storable.val = a.Enabled;
CreateToggle(storable, rightSide: true);
RegisterBool(storable);
}
}
public Transition(JSONStorableFloat camExposure, float camExposureFrom, float camExposureTo, float duration, bool destroyOnComplete)
{
_camExposure = camExposure;
_camExposureFrom = camExposureFrom;
_camExposureTo = camExposureTo;
_duration = duration;
_destroyOnComplete = destroyOnComplete;
}
