コード例 #1
0
        private void FixedUpdate()
        {
            foreach (Tuple <PotentialBase, RigidTripletType> pot_rigids_pair in m_PotentialRigidbodiesPairs)
            {
                PotentialBase    potential     = pot_rigids_pair.Item1;
                RigidTripletType rigid_triplet = pot_rigids_pair.Item2;
                Rigidbody        rigid_i       = rigid_triplet.Item1;
                Rigidbody        rigid_j       = rigid_triplet.Item2;
                Rigidbody        rigid_k       = rigid_triplet.Item3;
                Vector3          r_ji          = rigid_i.position - rigid_j.position;
                Vector3          r_jk          = rigid_k.position - rigid_j.position;
                Vector3          e_ji          = r_ji.normalized;
                Vector3          e_jk          = r_jk.normalized;
                float            cos_theta     = Vector3.Dot(e_ji, e_jk);
                float            theta         = Mathf.Acos(cos_theta);
                float            sin_theta     = Mathf.Sin(theta);

                float inv_sin_r_ji_len = 1.0f / (sin_theta * r_ji.magnitude);
                float inv_sin_r_jk_len = 1.0f / (sin_theta * r_jk.magnitude);
                float coef             = potential.Derivative(theta);

                Vector3 Fi = -coef * inv_sin_r_ji_len * (cos_theta * e_ji - e_jk);
                Vector3 Fk = -coef * inv_sin_r_jk_len * (cos_theta * e_jk - e_ji);

                rigid_i.AddForce(Fi);
                rigid_k.AddForce(Fk);
                rigid_j.AddForce(-(Fi + Fk));
            }
        }
コード例 #2
0
        internal void Init(List <Tuple <PotentialBase, RigidTripletType> > pot_rigids_pairs)
        {
            enabled = true;

            m_PotentialRigidbodiesPairs = pot_rigids_pairs;

            // setting ignore collision
            foreach (Tuple <PotentialBase, RigidTripletType> pot_rigids_pair in m_PotentialRigidbodiesPairs)
            {
                RigidTripletType rigid_triplet = pot_rigids_pair.Item2;
                Collider         collider_i    = rigid_triplet.Item1.GetComponent <Collider>();
                Collider         collider_k    = rigid_triplet.Item3.GetComponent <Collider>();
                Physics.IgnoreCollision(collider_i, collider_k);
            }
        }
コード例 #3
0
ファイル: InputToml.cs プロジェクト: yutakasi634/Coral-iMD-VR
        // This method generate InteractionManager for local of SceneBuilder by side effect.
        internal void GenerateLocalInteractionManagers(
            GameObject scene_builder, List <GameObject> base_particles, float timescale)
        {
            List <TomlTable> local_ffs = ForceFieldTable.Get <List <TomlTable> >("local");

            foreach (TomlTable local_ff in local_ffs)
            {
                string interaction   = local_ff.Get <string>("interaction");
                string potential_str = local_ff.Get <string>("potential");
                if (interaction == "BondLength")
                {
                    var parameters       = local_ff.Get <List <TomlTable> >("parameters");
                    var pot_rigids_pairs = new List <Tuple <PotentialBase, RigidPairType> >();
                    if (potential_str == "Harmonic")
                    {
                        foreach (TomlTable parameter in parameters)
                        {
                            var v0        = parameter.Get <float>("v0");
                            var k         = parameter.Get <float>("k");
                            var potential = new HarmonicPotential(v0, k, timescale);

                            List <int> indices = parameter.Get <List <int> >("indices");

                            Assert.AreEqual(indices.Count, 2,
                                            "The length of indices must be 2.");

                            var rigid1     = base_particles[indices[0]].GetComponent <Rigidbody>();
                            var rigid2     = base_particles[indices[1]].GetComponent <Rigidbody>();
                            var rigid_pair = new RigidPairType(rigid1, rigid2);

                            pot_rigids_pairs.Add(new Tuple <PotentialBase, RigidPairType>(potential, rigid_pair));
                        }
                    }
                    else if (potential_str == "GoContact")
                    {
                        foreach (TomlTable parameter in parameters)
                        {
                            var v0        = parameter.Get <float>("v0");
                            var k         = parameter.Get <float>("k");
                            var potential = new GoContactPotential(v0, k, timescale);

                            List <int> indices = parameter.Get <List <int> >("indices");

                            Assert.AreEqual(indices.Count, 2,
                                            "The length of indices must be 2.");

                            var rigid1     = base_particles[indices[0]].GetComponent <Rigidbody>();
                            var rigid2     = base_particles[indices[1]].GetComponent <Rigidbody>();
                            var rigid_pair = new RigidPairType(rigid1, rigid2);

                            pot_rigids_pairs.Add(new Tuple <PotentialBase, RigidPairType>(potential, rigid_pair));
                        }
                    }
                    BondLengthInteractionManager bli_manager
                        = scene_builder.AddComponent <BondLengthInteractionManager>() as BondLengthInteractionManager;
                    bli_manager.Init(pot_rigids_pairs);
                    string potential_name = bli_manager.PotentialName();
                    Debug.Log($"BondLengthInteraction with {potential_name} initialization finished.");
                }
                else if (interaction == "BondAngle")
                {
                    var parameters       = local_ff.Get <List <TomlTable> >("parameters");
                    var pot_rigids_pairs = new List <Tuple <PotentialBase, RigidTripletType> >();
                    if (potential_str == "Harmonic")
                    {
                        foreach (TomlTable parameter in parameters)
                        {
                            var v0        = parameter.Get <float>("v0");
                            var k         = parameter.Get <float>("k");
                            var potential = new HarmonicPotential(v0, k, timescale);

                            List <int> indices = parameter.Get <List <int> >("indices");

                            Assert.AreEqual(indices.Count, 3,
                                            "The length of indices must be 3.");

                            var rigid_i        = base_particles[indices[0]].GetComponent <Rigidbody>();
                            var rigid_j        = base_particles[indices[1]].GetComponent <Rigidbody>();
                            var rigid_k        = base_particles[indices[2]].GetComponent <Rigidbody>();
                            var rigid_triplets = new RigidTripletType(rigid_i, rigid_j, rigid_k);

                            pot_rigids_pairs.Add(new Tuple <PotentialBase, RigidTripletType>(potential, rigid_triplets));
                        }
                    }
                    BondAngleInteractionManager bai_manager =
                        scene_builder.AddComponent <BondAngleInteractionManager>() as BondAngleInteractionManager;
                    bai_manager.Init(pot_rigids_pairs);
                    string potential_name = bai_manager.PotentialName();
                    Debug.Log($"BondAngleInteraciton with {potential_name} initialization finished.");
                }
                else if (interaction == "DihedralAngle")
                {
                    var parameters       = local_ff.Get <List <TomlTable> >("parameters");
                    var pot_rigids_pairs = new List <Tuple <PotentialBase, RigidQuadrupletType> >();
                    if (potential_str == "ClementiDihedral")
                    {
                        foreach (TomlTable parameter in parameters)
                        {
                            var v0        = parameter.Get <float>("v0");
                            var k1        = parameter.Get <float>("k1");
                            var k3        = parameter.Get <float>("k3");
                            var potential = new ClementiDihedralPotential(v0, k1, k3, timescale);

                            List <int> indices = parameter.Get <List <int> >("indices");
                            Assert.AreEqual(indices.Count, 4,
                                            "The length of indices must be 4.");

                            var rigid_i          = base_particles[indices[0]].GetComponent <Rigidbody>();
                            var rigid_j          = base_particles[indices[1]].GetComponent <Rigidbody>();
                            var rigid_k          = base_particles[indices[2]].GetComponent <Rigidbody>();
                            var rigid_l          = base_particles[indices[3]].GetComponent <Rigidbody>();
                            var rigid_quadruplet = new RigidQuadrupletType(rigid_i, rigid_j, rigid_k, rigid_l);

                            pot_rigids_pairs.Add(
                                new Tuple <PotentialBase, RigidQuadrupletType>(potential, rigid_quadruplet));
                        }
                    }
                    DihedralAngleInteractionManager dai_manager =
                        scene_builder.AddComponent <DihedralAngleInteractionManager>() as DihedralAngleInteractionManager;
                    dai_manager.Init(pot_rigids_pairs);
                    string potential_name = dai_manager.PotentialName();
                    Debug.Log($"DihedralAngleInteraction with {potential_name} initialization finished");
                }
                else
                {
                    Debug.LogWarning($@"
Unknown combination of local interaction {interaction} and forcefields {potential_str} is specified.
This table will be ignored.
Available combination is
    - Interaction: BondLength,    Potential: Harmonic
    - Interaction: BondLength,    Potential: GoContact
    - Interaction: BondAngle,     Potential: Harmonic
    - Interaction: DihedralAngle, Potential: ClementiDihedral");
                }
            }
        }