コード例 #1
0
ファイル: MeshMerger.cs プロジェクト: Fuzzinator/The-Attic
        private void GenerateCubes()
        {
            _scannedSpaces.Clear();
            _pieceSize = scanningArea.ToFloat3() / sections.ToFloat3();
            var totalSpaces = new Float3(scanningArea.x / _pieceSize.x, scanningArea.y / _pieceSize.y,
                                         scanningArea.z / _pieceSize.z);

            var halfSpaces = new Float3(scanningArea.x * .5f, scanningArea.y * .5f, scanningArea.z * .5f);

            _halfPiece = _pieceSize * .5f;
            var min = new Float3(transform.position.x - halfSpaces.x + _halfPiece.x,
                                 transform.position.y - halfSpaces.y + _halfPiece.y,
                                 transform.position.z - halfSpaces.z + _halfPiece.z);


            var currentOffset = new Float3(0f, 0f, 0f);

            var pos = new Float3(0f, 0f, 0f);

            for (var y = 0f; y < totalSpaces.y; y++)
            {
                var currentY = min.y + currentOffset.y;
                currentOffset.x = 0;
                currentOffset.z = 0;
                for (var x = 0f; x < totalSpaces.x; x++)
                {
                    var currentX = min.x + currentOffset.x;
                    currentOffset.z = 0;
                    for (var i = 0f; i < totalSpaces.z; i++)
                    {
                        var currentZ = min.z + currentOffset.z;
                        pos = new Float3(currentX, currentY, currentZ);
                        if (_scannedSpaces.Contains(pos.ToVector3()))
                        {
                            continue;
                        }
                        currentOffset.z += _pieceSize.z;
                        _scannedSpaces.Add(pos.ToVector3());
                    }
                    currentOffset.x += _pieceSize.x;
                }
                currentOffset.y += _pieceSize.y;
            }
        }
コード例 #2
0
ファイル: MeshMerger.cs プロジェクト: Fuzzinator/The-Attic
        private void OnDrawGizmos()
        {
            var origColor = Gizmos.color;

            Gizmos.color = offWhite;
            foreach (var space in _scannedSpaces)
            {
                Gizmos.DrawWireCube(space, _pieceSize.ToVector3());
            }
            Gizmos.color = Color.cyan;
            Gizmos.DrawWireCube(transform.position, scanningArea);
            Gizmos.color = origColor;
        }
コード例 #3
0
ファイル: MeshMerger.cs プロジェクト: Fuzzinator/The-Attic
        private void ScanForMeshes()
        {
            _scannedObjects.Clear();
            _foundMeshes.Clear();
            _lodMeshes.Clear();
            foreach (var space in _scannedSpaces)
            {
                if (!_foundMeshes.ContainsKey(space))
                {
                    var list = new List <FilterAndMat>();
                    _foundMeshes.Add(space, list);
                }

                var colliders = Physics.OverlapBox(space, _halfPiece.ToVector3());
                foreach (var col in colliders)
                {
                    if (onlyStaticObjects)
                    {
                        if (!col.gameObject.isStatic)
                        {
                            continue;
                        }
                    }

                    if (policyList != null)
                    {
                        if (!policyList.CheckPolicy(col.gameObject))
                        {
                            continue;
                        }
                    }
                    if (skipLODObjects)
                    {
                        if (col.GetComponentInChildren <LODGroup>() || col.GetComponentInParent <LODGroup>())
                        {
                            continue;
                        }
                        if (_scannedObjects.Contains((col.gameObject)))
                        {
                            continue;
                        }
                        var filter = col.GetComponent <MeshFilter>();
                        var rend   = col.GetComponent <MeshRenderer>();
                        if (col.GetType() != typeof(MeshCollider) || filter == null || rend == null)
                        {
                            continue;
                        }
                        _scannedObjects.Add(col.gameObject);

                        var obj = new FilterAndMat(filter, rend.sharedMaterials); //, filter.GetComponents<Collider>());

                        _foundMeshes[space].Add(obj);
                    }
                    else
                    {
                        var lOD = col.GetComponentInParent <LODGroup>();
                        if (lOD == null)
                        {
                            if (_scannedObjects.Contains((col.gameObject)))
                            {
                                continue;
                            }
                            var filter = col.GetComponent <MeshFilter>();
                            var rend   = col.GetComponent <MeshRenderer>();
                            if (col.GetType() != typeof(MeshCollider) || filter == null || rend == null)
                            {
                                continue;
                            }
                            _scannedObjects.Add(col.gameObject);
                            var obj = new FilterAndMat(filter, rend.sharedMaterials); //, filter.GetComponents<Collider>());

                            _foundMeshes[space].Add(obj);
                        }
                        else
                        {
                            /*if (!_lodMeshes[space].ContainsKey(lOD))
                             * {
                             *  _lodMeshes[space].Add(lOD, new Dictionary<int, List<FilterAndMat>>());
                             * };*/
                            var lods = lOD.GetLODs();
                            switch (selectedLODOption)
                            {
                            case 0:
                                if (!_lodMeshes.ContainsKey(space))
                                {
                                    var d = new Dictionary <int, List <FilterAndMat> >();
                                    _lodMeshes.Add(space, d);
                                }
                                for (var i = 0; i < lods.Length; i++)
                                {
                                    if (!_lodMeshes[space].ContainsKey(i))
                                    {
                                        _lodMeshes[space].Add(i, new List <FilterAndMat>());
                                    }
                                    var iRends = lods[i].renderers;
                                    foreach (var rend in iRends)
                                    {
                                        if (rend == null)
                                        {
                                            continue;
                                        }
                                        var obj = rend.gameObject;
                                        if (obj != col.gameObject)
                                        {
                                            continue;
                                        }
                                        if (_scannedObjects.Contains(obj))
                                        {
                                            continue;
                                        }
                                        _scannedObjects.Add(obj);
                                        var filter = rend.GetComponent <MeshFilter>();
                                        var lodObj = new FilterAndMat(filter, rend.sharedMaterials);
                                        _lodMeshes[space][i].Add(lodObj);
                                    }
                                }
                                break;

                            case 1:
                                var rends = lods[0].renderers;
                                foreach (var rend in rends)
                                {
                                    var obj = rend.gameObject;
                                    if (obj != col.gameObject)
                                    {
                                        continue;
                                    }
                                    if (_scannedObjects.Contains(obj))
                                    {
                                        continue;
                                    }
                                    _scannedObjects.Add(obj);
                                    var filter = rend.GetComponent <MeshFilter>();
                                    var lodObj = new FilterAndMat(filter, rend.sharedMaterials);
                                    _foundMeshes[space].Add(lodObj);
                                }
                                break;
                            }
                        }
                    }
                }

                if (_foundMeshes[space].Count > 1)
                {
                    continue;
                }
                _foundMeshes.Remove(space);
            }
        }