Upload from upload_mods.ps1

KFAttached/RigAdaptors/Adaptors/BlendConstraintAdaptor.cs

@@ -0,0 +1,56 @@
+using UnityEngine;
+using UnityEngine.Animations.Rigging;
+
+[AddComponentMenu("")]
+public class BlendConstraintAdaptor : RigAdaptorAbs
+{
+    [SerializeField]
+    private string m_ConstrainedObject;
+    [SerializeField]
+    private Transform m_SourceA;
+    [SerializeField]
+    private Transform m_SourceB;
+    [SerializeField]
+    private bool m_BlendPosition;
+    [SerializeField]
+    private bool m_BlendRotation;
+    [SerializeField]
+    private float m_PositionWeight;
+    [SerializeField]
+    private float m_RotationWeight;
+    [SerializeField]
+    private bool m_MaintainPositionOffsets;
+    [SerializeField]
+    private bool m_MaintainRotationOffsets;
+
+    public override void ReadRigData()
+    {
+        var constraint = GetComponent<BlendConstraint>();
+        weight = constraint.weight;
+        m_ConstrainedObject = constraint.data.constrainedObject?.name;
+        m_SourceA = constraint.data.sourceObjectA;
+        m_SourceB = constraint.data.sourceObjectB;
+        m_BlendPosition = constraint.data.blendPosition;
+        m_BlendRotation = constraint.data.blendRotation;
+        m_PositionWeight = constraint.data.positionWeight;
+        m_RotationWeight = constraint.data.rotationWeight;
+        m_MaintainPositionOffsets = constraint.data.maintainPositionOffsets;
+        m_MaintainRotationOffsets = constraint.data.maintainRotationOffsets;
+    }
+
+    public override void FindRigTargets()
+    {
+        var constraint = GetComponent<BlendConstraint>();
+        constraint.Reset();
+        constraint.weight = weight;
+        constraint.data.constrainedObject = targetRoot.FindInAllChildren(m_ConstrainedObject);
+        constraint.data.sourceObjectA = m_SourceA;
+        constraint.data.sourceObjectB = m_SourceB;
+        constraint.data.blendPosition = m_BlendPosition;
+        constraint.data.blendRotation = m_BlendRotation;
+        constraint.data.positionWeight = m_PositionWeight;
+        constraint.data.rotationWeight = m_RotationWeight;
+        constraint.data.maintainPositionOffsets = m_MaintainPositionOffsets;
+        constraint.data.maintainRotationOffsets = m_MaintainRotationOffsets;
+    }
+}

KFAttached/RigAdaptors/Adaptors/BlendConstraintAdaptor.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: b2ca56f5a0b464646817033fcff9f693
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

KFAttached/RigAdaptors/Adaptors/ChainIKConstraintAdaptor.cs

@@ -0,0 +1,56 @@
+using UnityEngine;
+using UnityEngine.Animations.Rigging;
+
+[AddComponentMenu("")]
+public class ChainIKConstraintAdaptor : RigAdaptorAbs
+{
+    [SerializeField]
+    private string m_Root;
+    [SerializeField]
+    private string m_Tip;
+    [SerializeField]
+    private Transform m_Target;
+    [SerializeField]
+    private float m_ChainRotationWeight;
+    [SerializeField]
+    private float m_TipRotationWeight;
+    [SerializeField]
+    private int m_MaxIterations;
+    [SerializeField]
+    private float m_Tolerance;
+    [SerializeField]
+    private bool m_MaintainTargetPositionOffset;
+    [SerializeField]
+    private bool m_MaintainTargetRotationOffset;
+
+    public override void ReadRigData()
+    {
+        var constraint = GetComponent<ChainIKConstraint>();
+        weight = constraint.weight;
+        m_Root = constraint.data.root?.name;
+        m_Tip = constraint.data.tip?.name;
+        m_Target = constraint.data.target;
+        m_ChainRotationWeight = constraint.data.chainRotationWeight;
+        m_TipRotationWeight = constraint.data.tipRotationWeight;
+        m_MaxIterations = constraint.data.maxIterations;
+        m_Tolerance = constraint.data.tolerance;
+        m_MaintainTargetPositionOffset = constraint.data.maintainTargetPositionOffset;
+        m_MaintainTargetRotationOffset = constraint.data.maintainTargetRotationOffset;
+    }
+
+    public override void FindRigTargets()
+    {
+        var constraint = GetComponent<ChainIKConstraint>();
+        constraint.Reset();
+        constraint.weight = weight;
+        constraint.data.root = targetRoot.FindInAllChildren(m_Root);
+        constraint.data.tip = targetRoot.FindInAllChildren(m_Tip);
+        constraint.data.target = m_Target;
+        constraint.data.chainRotationWeight = m_ChainRotationWeight;
+        constraint.data.tipRotationWeight = m_TipRotationWeight;
+        constraint.data.maxIterations = m_MaxIterations;
+        constraint.data.tolerance = m_Tolerance;
+        constraint.data.maintainTargetPositionOffset = m_MaintainTargetPositionOffset;
+        constraint.data.maintainTargetRotationOffset = m_MaintainTargetRotationOffset;
+    }
+}

KFAttached/RigAdaptors/Adaptors/ChainIKConstraintAdaptor.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 3b4dd415747e268478ef7e27093e78a4
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

KFAttached/RigAdaptors/Adaptors/DampedTransformAdaptor.cs

@@ -0,0 +1,38 @@
+using UnityEngine;
+using UnityEngine.Animations.Rigging;
+
+[AddComponentMenu("")]
+public class DampedTransformAdaptor : RigAdaptorAbs
+{
+    [SerializeField]
+    private string m_ConstrainedObject;
+    [SerializeField]
+    private Transform m_Source;
+    [SerializeField]
+    private float m_DampPosition;
+    [SerializeField]
+    private float m_DampRotation;
+    [SerializeField]
+    private bool m_MaintainAim;
+    public override void FindRigTargets()
+    {
+        var constraint = GetComponent<DampedTransform>();
+        weight = constraint.weight;
+        m_ConstrainedObject = constraint.data.constrainedObject?.name;
+        m_Source = constraint.data.sourceObject;
+        m_DampPosition = constraint.data.dampPosition;
+        m_DampRotation = constraint.data.dampRotation;
+        m_MaintainAim = constraint.data.maintainAim;
+    }
+
+    public override void ReadRigData()
+    {
+        var constraint = GetComponent<DampedTransform>();
+        constraint.weight = weight;
+        constraint.data.constrainedObject = targetRoot.FindInAllChildren(m_ConstrainedObject);
+        constraint.data.sourceObject = m_Source;
+        constraint.data.dampPosition = m_DampPosition;
+        constraint.data.dampRotation = m_DampRotation;
+        constraint.data.maintainAim = m_MaintainAim;
+    }
+}

KFAttached/RigAdaptors/Adaptors/DampedTransformAdaptor.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 7eae293f02f20ea4e83de9504d5a5f93
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

KFAttached/RigAdaptors/Adaptors/Data.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 28f7c996c8fc946498369133083c03d9
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

KFAttached/RigAdaptors/Adaptors/Data/TwistNode.cs

@@ -0,0 +1,22 @@
+using System;
+using UnityEngine;
+
+namespace KFCommonUtilityLib.RigAdaptors.Adaptors.Data
+{
+    [Serializable]
+    public class TwistNode
+    {
+        [SerializeField]
+        public string name;
+        [SerializeField]
+        public float weight;
+
+        public TwistNode() { }
+
+        public TwistNode(string name, float weight)
+        {
+            this.name = name;
+            this.weight = weight;
+        }
+    }
+}

KFAttached/RigAdaptors/Adaptors/Data/TwistNode.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: ce4dc6aaaa5e6564d8f5975388620f86
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

KFAttached/RigAdaptors/Adaptors/MultiAimConstraintAdaptor.cs

@@ -0,0 +1,68 @@
+using UnityEngine;
+using UnityEngine.Animations.Rigging;
+
+[AddComponentMenu("")]
+public class MultiAimConstraintAdaptor : RigAdaptorAbs
+{
+    [SerializeField]
+    private string m_ConstrainedObject;
+    [SerializeField]
+    private WeightedTransformArray m_SourceObjects;
+    [SerializeField]
+    private Vector3 m_Offset;
+    [SerializeField]
+    private Vector2 m_limits;
+    [SerializeField]
+    private MultiAimConstraintData.Axis m_AimAxis;
+    [SerializeField]
+    private MultiAimConstraintData.Axis m_UpAxis;
+    [SerializeField]
+    private MultiAimConstraintData.WorldUpType m_WorldUpType;
+    [SerializeField]
+    private string m_WorldUpObject;
+    [SerializeField]
+    private MultiAimConstraintData.Axis m_WorldUpAxis;
+    [SerializeField]
+    private bool m_MaintainOffset;
+    [SerializeField]
+    private Vector3Bool m_ConstrainedAxes;
+
+    public override void FindRigTargets()
+    {
+        var constraint = GetComponent<MultiAimConstraint>();
+        constraint.Reset();
+        constraint.weight = weight;
+        constraint.data.constrainedObject = targetRoot.FindInAllChildren(m_ConstrainedObject);
+        constraint.data.sourceObjects = m_SourceObjects;
+        constraint.data.offset = m_Offset;
+        constraint.data.limits = m_limits;
+        constraint.data.aimAxis = m_AimAxis;
+        constraint.data.upAxis = m_UpAxis;
+        constraint.data.worldUpType = m_WorldUpType;
+        if (!string.IsNullOrEmpty(m_WorldUpObject))
+            constraint.data.worldUpObject = targetRoot.FindInAllChildren(m_WorldUpObject);
+        constraint.data.worldUpAxis = m_WorldUpAxis;
+        constraint.data.maintainOffset = m_MaintainOffset;
+        constraint.data.constrainedXAxis = m_ConstrainedAxes.x;
+        constraint.data.constrainedYAxis = m_ConstrainedAxes.y;
+        constraint.data.constrainedZAxis = m_ConstrainedAxes.z;
+    }
+
+    public override void ReadRigData()
+    {
+        var constraint = GetComponent<MultiAimConstraint>();
+        weight = constraint.weight;
+        m_ConstrainedObject = constraint.data.constrainedObject?.name;
+        m_SourceObjects = constraint.data.sourceObjects;
+        m_Offset = constraint.data.offset;
+        m_limits = constraint.data.limits;
+        m_AimAxis = constraint.data.aimAxis;
+        m_UpAxis = constraint.data.upAxis;
+        m_WorldUpType = constraint.data.worldUpType;
+        if ((m_WorldUpType == MultiAimConstraintData.WorldUpType.ObjectUp || m_WorldUpType == MultiAimConstraintData.WorldUpType.ObjectRotationUp) && constraint.data.worldUpObject)
+            m_WorldUpObject = constraint.data.worldUpObject.name;
+        m_WorldUpAxis = constraint.data.worldUpAxis;
+        m_MaintainOffset = constraint.data.maintainOffset;
+        m_ConstrainedAxes = new Vector3Bool(constraint.data.constrainedXAxis, constraint.data.constrainedYAxis, constraint.data.constrainedZAxis);
+    }
+}

KFAttached/RigAdaptors/Adaptors/MultiAimConstraintAdaptor.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 80b6e2441c0c1ab46a65e9ff120057de
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

KFAttached/RigAdaptors/Adaptors/MultiParentConstraintAdaptor.cs

@@ -0,0 +1,47 @@
+using UnityEngine;
+using UnityEngine.Animations.Rigging;
+
+[AddComponentMenu("")]
+public class MultiParentConstraintAdaptor : RigAdaptorAbs
+{
+    [SerializeField]
+    private string m_ConstrainedObject;
+    [SerializeField]
+    private WeightedTransformArray m_SourceObjects;
+    [SerializeField]
+    private Vector3Bool m_ConstrainedPositionAxes;
+    [SerializeField]
+    private Vector3Bool m_ConstrainedRotationAxes;
+    [SerializeField]
+    private bool m_MaintainPositionOffset;
+    [SerializeField]
+    private bool m_MaintainRotationOffset;
+    public override void FindRigTargets()
+    {
+        var constraint = GetComponent<MultiParentConstraint>();
+        constraint.Reset();
+        constraint.weight = weight;
+        constraint.data.constrainedObject = targetRoot.FindInAllChildren(m_ConstrainedObject);
+        constraint.data.sourceObjects = m_SourceObjects;
+        constraint.data.constrainedPositionXAxis = m_ConstrainedPositionAxes.x;
+        constraint.data.constrainedPositionYAxis = m_ConstrainedPositionAxes.y;
+        constraint.data.constrainedPositionZAxis = m_ConstrainedPositionAxes.z;
+        constraint.data.constrainedRotationXAxis = m_ConstrainedRotationAxes.x;
+        constraint.data.constrainedRotationYAxis = m_ConstrainedRotationAxes.y;
+        constraint.data.constrainedRotationZAxis = m_ConstrainedRotationAxes.z;
+        constraint.data.maintainPositionOffset = m_MaintainPositionOffset;
+        constraint.data.maintainRotationOffset = m_MaintainRotationOffset;
+    }
+
+    public override void ReadRigData()
+    {
+        var constraint = GetComponent<MultiParentConstraint>();
+        weight = constraint.weight;
+        m_ConstrainedObject = constraint.data.constrainedObject?.name;
+        m_SourceObjects = constraint.data.sourceObjects;
+        m_ConstrainedPositionAxes = new Vector3Bool(constraint.data.constrainedPositionXAxis, constraint.data.constrainedPositionYAxis, constraint.data.constrainedPositionZAxis);
+        m_ConstrainedRotationAxes = new Vector3Bool(constraint.data.constrainedRotationXAxis, constraint.data.constrainedRotationYAxis, constraint.data.constrainedRotationZAxis);
+        m_MaintainPositionOffset = constraint.data.maintainPositionOffset;
+        m_MaintainRotationOffset = constraint.data.maintainRotationOffset;
+    }
+}

KFAttached/RigAdaptors/Adaptors/MultiParentConstraintAdaptor.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 1efc37cc0b8c5d748832a228eef2373c
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

KFAttached/RigAdaptors/Adaptors/MultiPositionConstraintAdaptor.cs

@@ -0,0 +1,42 @@
+using UnityEngine;
+using UnityEngine.Animations.Rigging;
+
+[AddComponentMenu("")]
+public class MultiPositionConstraintAdaptor : RigAdaptorAbs
+{
+    [SerializeField]
+    private string m_ConstrainedObject;
+    [SerializeField]
+    private WeightedTransformArray m_SourceObjects;
+    [SerializeField]
+    private Vector3 m_Offset;
+    [SerializeField]
+    private Vector3Bool m_ConstrainedAxes;
+    [SerializeField]
+    private bool m_MaintainOffset;
+
+    public override void FindRigTargets()
+    {
+        var constraint = GetComponent<MultiPositionConstraint>();
+        constraint.Reset();
+        constraint.weight = weight;
+        constraint.data.constrainedObject = targetRoot.FindInAllChildren(m_ConstrainedObject);
+        constraint.data.sourceObjects = m_SourceObjects;
+        constraint.data.offset = m_Offset;
+        constraint.data.constrainedXAxis = m_ConstrainedAxes.x;
+        constraint.data.constrainedYAxis = m_ConstrainedAxes.y;
+        constraint.data.constrainedZAxis = m_ConstrainedAxes.z;
+        constraint.data.maintainOffset = m_MaintainOffset;
+    }
+
+    public override void ReadRigData()
+    {
+        var constraint = GetComponent<MultiPositionConstraint>();
+        weight = constraint.weight;
+        m_ConstrainedObject = constraint.data.constrainedObject?.name;
+        m_SourceObjects = constraint.data.sourceObjects;
+        m_Offset = constraint.data.offset;
+        m_ConstrainedAxes = new Vector3Bool(constraint.data.constrainedXAxis, constraint.data.constrainedYAxis, constraint.data.constrainedZAxis);
+        m_MaintainOffset = constraint.data.maintainOffset;
+    }
+}

KFAttached/RigAdaptors/Adaptors/MultiPositionConstraintAdaptor.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: d705cece31c4abd4495c5fdf8203afe5
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

KFAttached/RigAdaptors/Adaptors/MultiReferentialConstraintAdaptor.cs

@@ -0,0 +1,29 @@
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.Animations.Rigging;
+
+[AddComponentMenu("")]
+public class MultiReferentialConstraintAdaptor : RigAdaptorAbs
+{
+    [SerializeField]
+    private int m_Driver;
+    [SerializeField]
+    private List<Transform> m_SourceObjects;
+
+    public override void FindRigTargets()
+    {
+        var constraint = GetComponent<MultiReferentialConstraint>();
+        constraint.Reset();
+        constraint.weight = weight;
+        constraint.data.driver = m_Driver;
+        constraint.data.sourceObjects = m_SourceObjects;
+    }
+
+    public override void ReadRigData()
+    {
+        var constraint = GetComponent<MultiReferentialConstraint>();
+        weight = constraint.weight;
+        m_Driver = constraint.data.driver;
+        m_SourceObjects = constraint.data.sourceObjects;
+    }
+}

KFAttached/RigAdaptors/Adaptors/MultiReferentialConstraintAdaptor.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: e103ecfa73363f14a90b16031c25e8b6
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

KFAttached/RigAdaptors/Adaptors/MultiRotationConstraintAdaptor.cs

@@ -0,0 +1,42 @@
+using UnityEngine;
+using UnityEngine.Animations.Rigging;
+
+[AddComponentMenu("")]
+public class MultiRotationConstraintAdaptor : RigAdaptorAbs
+{
+    [SerializeField]
+    private string m_ConstrainedObject;
+    [SerializeField]
+    private WeightedTransformArray m_SourceObjects;
+    [SerializeField]
+    private Vector3 m_Offset;
+    [SerializeField]
+    private Vector3Bool m_ConstrainedAxes;
+    [SerializeField]
+    private bool m_MaintainOffset;
+
+    public override void FindRigTargets()
+    {
+        var constraint = GetComponent<MultiRotationConstraint>();
+        constraint.Reset();
+        constraint.weight = weight;
+        constraint.data.constrainedObject = targetRoot.FindInAllChildren(m_ConstrainedObject);
+        constraint.data.sourceObjects = m_SourceObjects;
+        constraint.data.offset = m_Offset;
+        constraint.data.constrainedXAxis = m_ConstrainedAxes.x;
+        constraint.data.constrainedYAxis = m_ConstrainedAxes.y;
+        constraint.data.constrainedZAxis = m_ConstrainedAxes.z;
+        constraint.data.maintainOffset = m_MaintainOffset;
+    }
+
+    public override void ReadRigData()
+    {
+        var constraint = GetComponent<MultiRotationConstraint>();
+        weight = constraint.weight;
+        m_ConstrainedObject = constraint.data.constrainedObject?.name;
+        m_SourceObjects = constraint.data.sourceObjects;
+        m_Offset = constraint.data.offset;
+        m_ConstrainedAxes = new Vector3Bool(constraint.data.constrainedXAxis, constraint.data.constrainedYAxis, constraint.data.constrainedZAxis);
+        m_MaintainOffset = constraint.data.maintainOffset;
+    }
+}

KFAttached/RigAdaptors/Adaptors/MultiRotationConstraintAdaptor.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: de8f43467d976b544b7967ab5425d23b
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

KFAttached/RigAdaptors/Adaptors/OverrideTransformAdaptor.cs

@@ -0,0 +1,48 @@
+using UnityEngine;
+using UnityEngine.Animations.Rigging;
+
+[AddComponentMenu("")]
+public class OverrideTransformAdaptor : RigAdaptorAbs
+{
+    [SerializeField]
+    private string m_ConstrainedObject;
+    [SerializeField]
+    private Transform m_OverrideSource;
+    [SerializeField]
+    private Vector3 m_OverridePosition;
+    [SerializeField]
+    private Vector3 m_OverrideRotation;
+    [SerializeField]
+    private float m_PositionWeight;
+    [SerializeField]
+    private float m_RotationWeight;
+    [SerializeField]
+    private OverrideTransformData.Space m_Space;
+
+    public override void FindRigTargets()
+    {
+        var constraint = GetComponent<OverrideTransform>();
+        constraint.Reset();
+        constraint.weight = weight;
+        constraint.data.constrainedObject = targetRoot.FindInAllChildren(m_ConstrainedObject);
+        constraint.data.sourceObject = m_OverrideSource;
+        constraint.data.position = m_OverridePosition;
+        constraint.data.rotation = m_OverrideRotation;
+        constraint.data.positionWeight = m_PositionWeight;
+        constraint.data.rotationWeight = m_RotationWeight;
+        constraint.data.space = m_Space;
+    }
+
+    public override void ReadRigData()
+    {
+        var constraint = GetComponent<OverrideTransform>();
+        weight = constraint.weight;
+        m_ConstrainedObject = constraint.data.constrainedObject?.name;
+        m_OverrideSource = constraint.data.sourceObject;
+        m_OverridePosition = constraint.data.position;
+        m_OverrideRotation = constraint.data.rotation;
+        m_PositionWeight = constraint.data.positionWeight;
+        m_RotationWeight = constraint.data.rotationWeight;
+        m_Space = constraint.data.space;
+    }
+}

KFAttached/RigAdaptors/Adaptors/OverrideTransformAdaptor.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 4b059f9f28d4d2e46a30530eeede98a4
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

KFAttached/RigAdaptors/Adaptors/RigAdaptorAbs.cs

@@ -0,0 +1,34 @@
+using System;
+using UnityEngine;
+using UnityEngine.Animations.Rigging;
+
+public abstract class RigAdaptorAbs : MonoBehaviour
+{
+    [NonSerialized]
+    public Transform targetRoot;
+    [SerializeField]
+    protected float weight = 1f;
+    public abstract void ReadRigData();
+    public abstract void FindRigTargets();
+
+    protected void WeightedTransformArrayToAdaptor(WeightedTransformArray array, out string[] transforms, out float[] weights)
+    {
+        transforms = new string[array.Count];
+        weights = new float[array.Count];
+        for (int i = 0; i < array.Count; i++)
+        {
+            transforms[i] = array[i].transform?.name;
+            weights[i] = array[i].weight;
+        }
+    }
+
+    protected WeightedTransformArray WeightedTransformArrayFromAdaptor(Transform targetRoot, string[] transforms, float[] weights)
+    {
+        WeightedTransformArray array = new WeightedTransformArray();
+        for (int i = 0; i < transforms.Length; i++)
+        {
+            array.Add(new WeightedTransform(targetRoot.FindInAllChildren(transforms[i]), weights[i]));
+        }
+        return array;
+    }
+}

KFAttached/RigAdaptors/Adaptors/RigAdaptorAbs.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: a19d5243587a11344927b47b3a9240fd
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

KFAttached/RigAdaptors/Adaptors/TwistChainConstraintAdaptor.cs

@@ -0,0 +1,40 @@
+using UnityEngine;
+using UnityEngine.Animations.Rigging;
+
+[AddComponentMenu("")]
+public class TwistChainConstraintAdaptor : RigAdaptorAbs
+{
+    [SerializeField]
+    private string m_Root;
+    [SerializeField]
+    private string m_Tip;
+    [SerializeField]
+    private Transform m_RootTarget;
+    [SerializeField]
+    private Transform m_TipTarget;
+    [SerializeField]
+    private AnimationCurve m_Curve;
+
+    public override void FindRigTargets()
+    {
+        var constraint = GetComponent<TwistChainConstraint>();
+        constraint.Reset();
+        constraint.weight = weight;
+        constraint.data.root = targetRoot.FindInAllChildren(m_Root);
+        constraint.data.tip = targetRoot.FindInAllChildren(m_Tip);
+        constraint.data.rootTarget = m_RootTarget;
+        constraint.data.tipTarget = m_TipTarget;
+        constraint.data.curve = m_Curve;
+    }
+
+    public override void ReadRigData()
+    {
+        var constraint = GetComponent<TwistChainConstraint>();
+        weight = constraint.weight;
+        m_Root = constraint.data.root?.name;
+        m_Tip = constraint.data.tip?.name;
+        m_RootTarget = constraint.data.rootTarget;
+        m_TipTarget = constraint.data.tipTarget;
+        m_Curve = constraint.data.curve;
+    }
+}

KFAttached/RigAdaptors/Adaptors/TwistChainConstraintAdaptor.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: e71b15efb8d89b9428eaee7b14e80f8d
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

KFAttached/RigAdaptors/Adaptors/TwistCorrectionAdaptor.cs

@@ -0,0 +1,50 @@
+using System.Linq;
+using UnityEngine;
+using UnityEngine.Animations.Rigging;
+
+[AddComponentMenu("")]
+public class TwistCorrectionAdaptor : RigAdaptorAbs
+{
+    [SerializeField]
+    private string m_Source;
+    [SerializeField]
+    private TwistCorrectionData.Axis m_TwistAxis;
+    [SerializeField]
+    private string[] m_TwistNodes;
+    public override void FindRigTargets()
+    {
+        var constraint = GetComponent<TwistCorrection>();
+        if (m_TwistNodes == null)
+        {
+            Log.Error("twist nodes array not serialized!");
+            Component.Destroy(constraint);
+            Component.Destroy(this);
+            return;
+        }
+        constraint.Reset();
+        constraint.weight = weight;
+        constraint.data.sourceObject = targetRoot.FindInAllChildren(m_Source);
+        constraint.data.twistAxis = m_TwistAxis;
+        var twistNodes = new WeightedTransformArray(m_TwistNodes.Length);
+        for (int i = 0; i < m_TwistNodes.Length; i++)
+        {
+            string[] node = m_TwistNodes[i].Split(';');
+            if (node.Length == 2)
+            {
+                if (!string.IsNullOrEmpty(node[0]))
+                    twistNodes.SetTransform(i, targetRoot.FindInAllChildren(node[0]));
+                twistNodes.SetWeight(i, float.Parse(node[1]));
+            }
+        }
+        constraint.data.twistNodes = twistNodes;
+    }
+
+    public override void ReadRigData()
+    {
+        var constraint = GetComponent<TwistCorrection>();
+        weight = constraint.weight;
+        m_Source = constraint.data.sourceObject.name;
+        m_TwistAxis = constraint.data.twistAxis;
+        m_TwistNodes = constraint.data.twistNodes.Select(n => (n.transform.gameObject?.name ?? "") + ';' + n.weight.ToString()).ToArray();
+    }
+}

KFAttached/RigAdaptors/Adaptors/TwistCorrectionAdaptor.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 0de395249ff56c646ab5045a6b20568a
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

KFAttached/RigAdaptors/Adaptors/TwoBoneIKConstraintAdaptor.cs

@@ -0,0 +1,59 @@
+using UnityEngine;
+using UnityEngine.Animations.Rigging;
+
+[AddComponentMenu("")]
+public class TwoBoneIKConstraintAdaptor : RigAdaptorAbs
+{
+    [SerializeField]
+    private string m_Root;
+    [SerializeField]
+    private string m_Mid;
+    [SerializeField]
+    private string m_Tip;
+    [SerializeField]
+    private Transform m_Target;
+    [SerializeField]
+    private Transform m_Hint;
+    [SerializeField]
+    private float m_TargetPositionWeight;
+    [SerializeField]
+    private float m_TargetRotationWeight;
+    [SerializeField]
+    private float m_HintWeight;
+    [SerializeField]
+    private bool m_MaintainTargetPositionOffset;
+    [SerializeField]
+    private bool m_MaintainTargetRotationOffset;
+    public override void FindRigTargets()
+    {
+        var constraint = GetComponent<TwoBoneIKConstraint>();
+        constraint.Reset();
+        constraint.weight = weight;
+        constraint.data.root = targetRoot.FindInAllChildren(m_Root);
+        constraint.data.mid = targetRoot.FindInAllChildren(m_Mid);
+        constraint.data.tip = targetRoot.FindInAllChildren(m_Tip);
+        constraint.data.target = m_Target;
+        constraint.data.hint = m_Hint;
+        constraint.data.targetPositionWeight = m_TargetPositionWeight;
+        constraint.data.targetRotationWeight = m_TargetRotationWeight;
+        constraint.data.hintWeight = m_HintWeight;
+        constraint.data.maintainTargetPositionOffset = m_MaintainTargetPositionOffset;
+        constraint.data.maintainTargetRotationOffset = m_MaintainTargetRotationOffset;
+    }
+
+    public override void ReadRigData()
+    {
+        var constraint = GetComponent<TwoBoneIKConstraint>();
+        weight = constraint.weight;
+        m_Root = constraint.data.root?.name;
+        m_Mid = constraint.data.mid?.name;
+        m_Tip = constraint.data.tip?.name;
+        m_Target = constraint.data.target;
+        m_Hint = constraint.data.hint;
+        m_TargetPositionWeight = constraint.data.targetPositionWeight;
+        m_TargetRotationWeight = constraint.data.targetRotationWeight;
+        m_HintWeight = constraint.data.hintWeight;
+        m_MaintainTargetPositionOffset = constraint.data.maintainTargetPositionOffset;
+        m_MaintainTargetRotationOffset = constraint.data.maintainTargetRotationOffset;
+    }
+}

KFAttached/RigAdaptors/Adaptors/TwoBoneIKConstraintAdaptor.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 917124d705d34eb4bb6e982c423de951
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: