예제 #1
0
파일: AverageOD.cs 프로젝트: dianatle/XTMF
        public void LoadData()
        {
            SparseTwinIndex <float> first  = GetMatrix(FirstMatrix, FirstDataSource);
            SparseTwinIndex <float> second = GetMatrix(SecondMatrix, SecondDataSource);
            SparseTwinIndex <float> ret    = GetResultMatrix(first);
            var data = ret.GetFlatData();
            var f    = first.GetFlatData();
            var s    = second.GetFlatData();

            if (VectorHelper.IsHardwareAccelerated)
            {
                for (int i = 0; i < data.Length; i++)
                {
                    VectorHelper.Average(data[i], 0, f[i], 0, s[i], 0, data[i].Length);
                }
            }
            else
            {
                for (int i = 0; i < data.Length; i++)
                {
                    for (int j = 0; j < data[i].Length; j++)
                    {
                        data[i][j] = (f[i][j] + s[i][j]) * 0.5f;
                    }
                }
            }
            Data   = ret;
            Loaded = true;
        }
예제 #2
0
    void OnCollisionStay(Collision col)
    {
        if (col.collider.attachedRigidbody != null)
        {
            Rigidbody body = col.collider.attachedRigidbody;

            // Add force to it
            Vector3[] points = new Vector3[col.contacts.Length];
            for (int i = 0; i < col.contacts.Length; i++)
            {
                points[i] = col.contacts[i].point;
            }

            body.AddForceAtPosition(transform.TransformVector(motion), VectorHelper.Average(points), ForceMode.Acceleration);

            // Change it's velocity directly
            //Vector3 vel = body.velocity;

            //if (motion.x != 0) vel.x = motion.x;
            //if (motion.y != 0) vel.y = motion.y;
            //if (motion.z != 0) vel.z = motion.z;

            //body.velocity = vel;
        }
    }
예제 #3
0
 private static void AverageResults(float[] results, float[] previousResults)
 {
     if (VectorHelper.IsHardwareAccelerated)
     {
         VectorHelper.Average(results, 0, results, 0, previousResults, 0, results.Length);
     }
     else
     {
         for (int i = 0; i < results.Length; i++)
         {
             results[i] = (results[i] + previousResults[i]) * 0.5f;
         }
     }
 }
예제 #4
0
        private SparseTriIndex <float> ConvertResults(float[] results, SparseArray <IZone> zoneSystem)
        {
            SparseTriIndex <float> ret = Data;

            // first create the datastructure
            if (ret == null)
            {
                ret = SparseTriIndex <float> .CreateSimilarArray(new SparseArray <int>(new SparseIndexing()
                {
                    Indexes = new SparseSet[]
                    { new SparseSet()
                      {
                          BaseLocation = 0,
                          Start = 0,
                          Stop = NumberOfWorkerCategories - 1
                      } }
                }), zoneSystem, zoneSystem);
            }
            // now fill it
            var r             = ret.GetFlatData();
            var numberOfZones = r[0].Length;
            var iterativeRoot = Root as IIterativeModel;

            if (iterativeRoot == null || iterativeRoot.CurrentIteration == 0)
            {
                Parallel.For(0, numberOfZones, (int i) =>
                {
                    for (int workerCategory = 0; workerCategory < r.Length; workerCategory++)
                    {
                        var workerCategoryMatrix = r[workerCategory];
                        var pos = sizeof(float) * ((workerCategoryMatrix.Length * workerCategoryMatrix.Length) * workerCategory + numberOfZones * i);
                        Buffer.BlockCopy(results, pos, workerCategoryMatrix[i], 0, numberOfZones * sizeof(float));
                    }
                });
            }
            else
            {
                Parallel.For(0, numberOfZones, (int i) =>
                {
                    for (int workerCategory = 0; workerCategory < r.Length; workerCategory++)
                    {
                        var workerCategoryMatrix = r[workerCategory];
                        var pos = ((workerCategoryMatrix.Length * workerCategoryMatrix.Length) * workerCategory + numberOfZones * i);
                        VectorHelper.Average(workerCategoryMatrix[i], 0, results, pos, workerCategoryMatrix[i], 0, numberOfZones);
                    }
                });
            }
            return(ret);
        }
예제 #5
0
        public void LoadData()
        {
            SparseTwinIndex <float> first  = ModuleHelper.GetDataFromDatasourceOrResource(FirstDataSource, FirstMatrix);
            SparseTwinIndex <float> second = ModuleHelper.GetDataFromDatasourceOrResource(SecondDataSource, SecondMatrix);
            SparseTwinIndex <float> ret    = GetResultMatrix(first);
            var data = ret.GetFlatData();
            var f    = first.GetFlatData();
            var s    = second.GetFlatData();

            for (int i = 0; i < data.Length; i++)
            {
                VectorHelper.Average(data[i], 0, f[i], 0, s[i], 0, data[i].Length);
            }
            Data   = ret;
            Loaded = true;
        }
예제 #6
0
    void LateUpdate()
    {
        if (list.Length > 0)
        {
            Vector3[] collection = new Vector3[list.Length];
            for (int i = 0; i < list.Length; i++)
            {
                if (!list[i])
                {
                    continue;
                }
                collection[i] = list[i].position;
            }

            transform.position = VectorHelper.Average(vectors: collection);
        }
    }
 private static void AverageResults(float[] results, float[] previousResults)
 {
     VectorHelper.Average(results, 0, results, 0, previousResults, 0, results.Length);
 }
예제 #8
0
    void OnSceneGUI()
    {
        if (!move)
        {
            return;
        }

        Event e = Event.current;

        int controlID = GUIUtility.GetControlID(FocusType.Passive);

        switch (e.GetTypeForControl(controlID))
        {
        case EventType.MouseDown:
            if (e.button == 1)
            {
                move = false;
                GUIUtility.hotControl = 0;
                e.Use();
            }
            else if (e.button == 0)
            {
                GUIUtility.hotControl = controlID;
                e.Use();
            }
            break;

        case EventType.MouseUp:
            if (e.button != 0)
            {
                break;
            }

            // Calculate center
            Vector3[] all = new Vector3[Selection.transforms.Length];
            for (int i = 0; i < Selection.transforms.Length; i++)
            {
                all[i] = Selection.transforms[i].position;
            }
            Vector3 center = VectorHelper.Average(all);

            // Move em
            foreach (var t in Selection.transforms)
            {
                Undo.RecordObject(t, "Move position");
                t.position = lastHit.point + t.position - center;
            }

            move = false;
            GUIUtility.hotControl = 0;
            e.Use();
            break;

        case EventType.MouseMove:
            mouse = Event.current.mousePosition;
            HandleUtility.Repaint();
            break;

        case EventType.KeyDown:
            if (e.keyCode == KeyCode.Escape && move)
            {
                // Abort
                move = false;
                GUIUtility.hotControl = 0;
                e.Use();
            }
            break;
        }

        if (Camera.current && e.type == EventType.Repaint)
        {
            Ray        ray = HandleUtility.GUIPointToWorldRay(mouse);
            RaycastHit hit;
            if (Physics.Raycast(ray, out hit, Camera.current.farClipPlane, LayerMask.GetMask("Default", "Terrain")))
            {
                Handles.color = new Color(0, 1, 1);
                Handles.ArrowCap(controlID, hit.point, Quaternion.FromToRotation(Vector3.forward, hit.normal), 1);
                Handles.CircleCap(controlID, hit.point, Quaternion.FromToRotation(Vector3.forward, hit.normal), 1);

                #region Draw meshes
                foreach (var filter in hit.collider.GetComponentsInChildren <MeshFilter>())
                {
                    mat2.SetPass(0);
                    Handles.color = Color.magenta;
                    Graphics.DrawMeshNow(filter.sharedMesh, Matrix4x4.TRS(filter.transform.position, filter.transform.rotation, filter.transform.lossyScale));
                }
                #endregion

                #region Draw box colliders
                foreach (var box in hit.collider.GetComponentsInChildren <BoxCollider>())
                {
                    Handles.color = Color.red;

                    Vector3 pos  = box.transform.position;
                    Vector3 half = box.size / 2;

                    Handles.DrawLine(pos + box.transform.TransformVector(box.center + new Vector3(half.x, half.y, half.z)),
                                     pos + box.transform.TransformVector(box.center + new Vector3(half.x, half.y, -half.z)));

                    Handles.DrawLine(pos + box.transform.TransformVector(box.center + new Vector3(half.x, half.y, -half.z)),
                                     pos + box.transform.TransformVector(box.center + new Vector3(-half.x, half.y, -half.z)));

                    Handles.DrawLine(pos + box.transform.TransformVector(box.center + new Vector3(-half.x, half.y, -half.z)),
                                     pos + box.transform.TransformVector(box.center + new Vector3(-half.x, half.y, half.z)));

                    Handles.DrawLine(pos + box.transform.TransformVector(box.center + new Vector3(-half.x, half.y, half.z)),
                                     pos + box.transform.TransformVector(box.center + new Vector3(half.x, half.y, half.z)));


                    Handles.DrawLine(pos + box.transform.TransformVector(box.center + new Vector3(half.x, half.y, half.z)),
                                     pos + box.transform.TransformVector(box.center + new Vector3(half.x, -half.y, half.z)));

                    Handles.DrawLine(pos + box.transform.TransformVector(box.center + new Vector3(half.x, half.y, -half.z)),
                                     pos + box.transform.TransformVector(box.center + new Vector3(half.x, -half.y, -half.z)));

                    Handles.DrawLine(pos + box.transform.TransformVector(box.center + new Vector3(-half.x, half.y, half.z)),
                                     pos + box.transform.TransformVector(box.center + new Vector3(-half.x, -half.y, half.z)));

                    Handles.DrawLine(pos + box.transform.TransformVector(box.center + new Vector3(-half.x, half.y, -half.z)),
                                     pos + box.transform.TransformVector(box.center + new Vector3(-half.x, -half.y, -half.z)));


                    Handles.DrawLine(pos + box.transform.TransformVector(box.center + new Vector3(half.x, -half.y, half.z)),
                                     pos + box.transform.TransformVector(box.center + new Vector3(half.x, -half.y, -half.z)));

                    Handles.DrawLine(pos + box.transform.TransformVector(box.center + new Vector3(half.x, -half.y, -half.z)),
                                     pos + box.transform.TransformVector(box.center + new Vector3(-half.x, -half.y, -half.z)));

                    Handles.DrawLine(pos + box.transform.TransformVector(box.center + new Vector3(-half.x, -half.y, -half.z)),
                                     pos + box.transform.TransformVector(box.center + new Vector3(-half.x, -half.y, half.z)));

                    Handles.DrawLine(pos + box.transform.TransformVector(box.center + new Vector3(-half.x, -half.y, half.z)),
                                     pos + box.transform.TransformVector(box.center + new Vector3(half.x, -half.y, half.z)));
                }
                #endregion

                #region Draw what's held

                // Calculate center
                Vector3[] all = new Vector3[Selection.transforms.Length];
                for (int i = 0; i < Selection.transforms.Length; i++)
                {
                    all[i] = Selection.transforms[i].position;
                }
                Vector3 center = VectorHelper.Average(all);

                Transform t      = target as Transform;
                Vector3   newpos = lastHit.point + t.position - center;

                Handles.color = new Color(1, 1, 0, .5f);
                Handles.CircleCap(controlID, newpos, Quaternion.FromToRotation(Vector3.forward, Vector3.up), 1);
                foreach (var filter in t.GetComponentsInChildren <MeshFilter>())
                {
                    Vector3 offset = filter.transform.position - t.position;
                    mat.SetPass(0);
                    Graphics.DrawMeshNow(filter.sharedMesh, Matrix4x4.TRS(newpos + offset, filter.transform.rotation, filter.transform.lossyScale));
                }

                #endregion

                Handles.Label(hit.point + Vector3.up * HandleUtility.GetHandleSize(hit.point) / 2, label + "\nLMB to move\nRMB to abort");
                lastHit = hit;
            }
        }
    }