Пример #1
0
        public override void GenerateOnly()
        {
            if (voxelObject == null || voxelObjectCore.voxelData == null)
            {
                return;
            }
            var voxelData = voxelObjectCore.voxelData;

            //BasicCube
            Vector3        cubeCenter;
            List <Vector3> cubeVertices;
            List <Vector3> cubeNormals;
            List <int>     cubeTriangles;

            CreateBasicCube(out cubeCenter, out cubeVertices, out cubeNormals, out cubeTriangles);

            #region Voxels
            List <Vector3> vertices  = new List <Vector3>();
            List <Vector3> normals   = new List <Vector3>();
            List <Color>   colors    = new List <Color>();
            List <Vector4> tangents  = new List <Vector4>();
            List <int>[]   triangles = new List <int> [voxelBase.materialData.Count];
            for (int i = 0; i < triangles.Length; i++)
            {
                triangles[i] = new List <int>();
            }

            #region Mesh
            Func <VoxelObjectExplosion.MeshData, VoxelObjectExplosion.MeshData> CreateMesh = (data) =>
            {
                if (data == null)
                {
                    data = new VoxelObjectExplosion.MeshData();
                }
                if (data.mesh == null)
                {
                    data.mesh = new Mesh();
                }
                else
                {
                    data.mesh.Clear(false);
                    data.mesh.ClearBlendShapes();
                }
                data.materialIndexes.Clear();
#if UNITY_2017_3_OR_NEWER
                data.mesh.indexFormat = vertices.Count > 65000 ? UnityEngine.Rendering.IndexFormat.UInt32 : UnityEngine.Rendering.IndexFormat.UInt16;
#endif
                data.mesh.vertices = vertices.ToArray();
                data.mesh.normals  = normals.ToArray();
                data.mesh.colors   = colors.ToArray();
                data.mesh.tangents = tangents.ToArray();
                {
                    int materialCount = 0;
                    for (int i = 0; i < triangles.Length; i++)
                    {
                        if (triangles[i].Count > 0)
                        {
                            materialCount++;
                        }
                    }
                    data.mesh.subMeshCount = materialCount;
                    int submesh = 0;
                    for (int i = 0; i < triangles.Length; i++)
                    {
                        if (triangles[i].Count > 0)
                        {
                            data.materialIndexes.Add(i);
                            data.mesh.SetTriangles(triangles[i].ToArray(), submesh++);
                        }
                    }
                }
                data.mesh.RecalculateBounds();
                {
                    var bounds = data.mesh.bounds;
                    bounds.min      -= Vector3.one * explosionBase.edit_velocityMax;
                    bounds.max      += Vector3.one * explosionBase.edit_velocityMax;
                    data.mesh.bounds = bounds;
                }
                vertices.Clear();
                normals.Clear();
                colors.Clear();
                tangents.Clear();
                for (int i = 0; i < voxelBase.materialData.Count; i++)
                {
                    triangles[i].Clear();
                }
                return(data);
            };
            #endregion

            {
                int meshIndex = 0;
                Action <int, int> AddVertex = (mat, index) =>
                {
                    if (explosionBase.edit_birthRate < 1f)
                    {
                        if (UnityEngine.Random.value >= explosionBase.edit_birthRate)
                        {
                            return;
                        }
                    }
                    if (explosionBase.edit_visibleOnly)
                    {
                        if (!voxelObjectCore.IsVoxelVisible(voxelData.voxels[index].position))
                        {
                            return;
                        }
                    }

#if !UNITY_2017_3_OR_NEWER
                    if (vertices.Count + cubeVertices.Count >= 65000)
                    {
                        for (int i = explosionObject.meshes.Count; i <= meshIndex; i++)
                        {
                            explosionObject.meshes.Add(null);
                        }
                        explosionObject.meshes[meshIndex] = CreateMesh(explosionObject.meshes[meshIndex]);
                        if (!AssetDatabase.Contains(explosionObject.meshes[meshIndex].mesh))
                        {
                            voxelBaseCore.AddObjectToPrefabAsset(explosionObject.meshes[meshIndex].mesh, "explosion_mesh", meshIndex);
                        }
                        meshIndex++;
                    }
#endif

                    var color   = voxelData.palettes[voxelData.voxels[index].palette];
                    var vOffset = vertices.Count;
                    for (int i = 0; i < cubeVertices.Count; i++)
                    {
                        var pos = cubeVertices[i];
                        pos.x += voxelData.voxels[index].position.x * voxelBase.importScale.x;
                        pos.y += voxelData.voxels[index].position.y * voxelBase.importScale.y;
                        pos.z += voxelData.voxels[index].position.z * voxelBase.importScale.z;
                        vertices.Add(pos);
                    }
                    normals.AddRange(cubeNormals);
                    for (int j = 0; j < cubeTriangles.Count; j++)
                    {
                        triangles[mat].Add(vOffset + cubeTriangles[j]);
                    }
                    for (int j = 0; j < cubeVertices.Count; j++)
                    {
                        colors.Add(color);
                    }
                    {
                        Vector3 center = new Vector3
                                         (
                            center.x = cubeCenter.x + voxelData.voxels[index].position.x * voxelBase.importScale.x,
                            center.y = cubeCenter.y + voxelData.voxels[index].position.y * voxelBase.importScale.y,
                            center.z = cubeCenter.z + voxelData.voxels[index].position.z * voxelBase.importScale.z
                                         );
                        var velocity = UnityEngine.Random.Range(explosionBase.edit_velocityMin, explosionBase.edit_velocityMax);
                        for (int j = 0; j < cubeVertices.Count; j++)
                        {
                            tangents.Add(new Vector4(center.x - vertices[vOffset + j].x, center.y - vertices[vOffset + j].y, center.z - vertices[vOffset + j].z, velocity));
                        }
                    }
                };

                if (explosionObject.meshes == null)
                {
                    explosionObject.meshes = new List <VoxelObjectExplosion.MeshData>();
                }
                FlagTable3 doneTable = new FlagTable3(voxelData.voxelSize.x, voxelData.voxelSize.y, voxelData.voxelSize.z);
                for (int i = 1; i < voxelBase.materialData.Count; i++)
                {
                    voxelBase.materialData[i].AllAction((pos) =>
                    {
                        doneTable.Set(pos, true);
                        var index = voxelData.VoxelTableContains(pos);
                        if (index < 0)
                        {
                            return;
                        }
                        AddVertex(i, index);
                    });
                }
                for (int index = 0; index < voxelData.voxels.Length; index++)
                {
                    if (doneTable.Get(voxelData.voxels[index].position))
                    {
                        continue;
                    }
                    AddVertex(0, index);
                }
                if (vertices.Count > 0)
                {
                    for (int i = explosionObject.meshes.Count; i <= meshIndex; i++)
                    {
                        explosionObject.meshes.Add(null);
                    }
                    explosionObject.meshes[meshIndex] = CreateMesh(explosionObject.meshes[meshIndex]);
                    if (!AssetDatabase.Contains(explosionObject.meshes[meshIndex].mesh))
                    {
                        voxelBaseCore.AddObjectToPrefabAsset(explosionObject.meshes[meshIndex].mesh, "explosion_mesh", meshIndex);
                    }
                    meshIndex++;
                }
                explosionObject.meshes.RemoveRange(meshIndex, explosionObject.meshes.Count - meshIndex);
            }
            #endregion

            #region Material
            if (explosionObject.materials == null)
            {
                explosionObject.materials = new List <Material>();
            }
            if (explosionObject.materials.Count < voxelBase.materialData.Count)
            {
                for (int i = explosionObject.materials.Count; i < voxelBase.materialData.Count; i++)
                {
                    explosionObject.materials.Add(null);
                }
            }
            else if (explosionObject.materials.Count > voxelBase.materialData.Count)
            {
                explosionObject.materials.RemoveRange(voxelBase.materialData.Count, explosionObject.materials.Count - voxelBase.materialData.Count);
            }
            for (int i = 0; i < voxelBase.materialData.Count; i++)
            {
                if (!voxelBase.materialIndexes.Contains(i))
                {
                    if (explosionObject.materials[i] != null)
                    {
                        explosionObject.materials[i] = null;
                        voxelBaseCore.DestroyUnusedObjectInPrefabObject();
                    }
                    continue;
                }
                if (explosionObject.materials[i] == null)
                {
                    explosionObject.materials[i] = new Material(GetStandardShader(voxelBase.materialData[i].transparent));
                }
                else
                {
                    explosionObject.materials[i].shader = GetStandardShader(voxelBase.materialData[i].transparent);
                }
                if (!AssetDatabase.Contains(explosionObject.materials[i]))
                {
                    explosionObject.materials[i].name = explosionObject.materials[i].shader.name;
                }
                if (!AssetDatabase.Contains(explosionObject.materials[i]))
                {
                    voxelBaseCore.AddObjectToPrefabAsset(explosionObject.materials[i], "explosion_mat", i);
                }
            }
            #endregion
        }
Пример #2
0
        public void CreateVoxelTable()
        {
            #region voxelTable
            {
                voxelTable = new DataTable3 <int>(voxelSize.x, voxelSize.y, voxelSize.z);
                if (voxels != null)
                {
                    for (int i = 0; i < voxels.Length; i++)
                    {
                        voxelTable.Set(voxels[i].position, i);
                    }
                }
            }
            #endregion

            #region vertexList
            {
                vertexList         = new List <IntVector3>(2 * voxels.Length);
                bool[,,] doneTable = new bool[voxelSize.x + 1, voxelSize.y + 1, voxelSize.z + 1];
                Action <IntVector3> AddPoint = (pos) =>
                {
                    if (pos.x < 0 || pos.y < 0 || pos.z < 0)
                    {
                        return;
                    }
                    if (!doneTable[pos.x, pos.y, pos.z])
                    {
                        doneTable[pos.x, pos.y, pos.z] = true;
                        vertexList.Add(pos);
                    }
                };
                if (voxels != null)
                {
                    for (int i = 0; i < voxels.Length; i++)
                    {
                        AddPoint(new IntVector3(voxels[i].x, voxels[i].y, voxels[i].z));
                        AddPoint(new IntVector3(voxels[i].x + 1, voxels[i].y, voxels[i].z));
                        AddPoint(new IntVector3(voxels[i].x, voxels[i].y + 1, voxels[i].z));
                        AddPoint(new IntVector3(voxels[i].x, voxels[i].y, voxels[i].z + 1));
                        AddPoint(new IntVector3(voxels[i].x + 1, voxels[i].y + 1, voxels[i].z));
                        AddPoint(new IntVector3(voxels[i].x + 1, voxels[i].y, voxels[i].z + 1));
                        AddPoint(new IntVector3(voxels[i].x, voxels[i].y + 1, voxels[i].z + 1));
                        AddPoint(new IntVector3(voxels[i].x + 1, voxels[i].y + 1, voxels[i].z + 1));
                    }
                }
            }
            #endregion

            #region outsideTable
            {
                bool[,,] doneTable = new bool[voxelSize.x, voxelSize.y, voxelSize.z];
                outsideTable       = new FlagTable3(voxelSize.x, voxelSize.y, voxelSize.z);
                List <IntVector3>      findList    = new List <IntVector3>(voxelSize.x * voxelSize.y * voxelSize.z);
                Action <int, int, int> AddFindList = (x, y, z) =>
                {
                    if (x < 0 || x >= voxelSize.x || y < 0 || y >= voxelSize.y || z < 0 || z >= voxelSize.z)
                    {
                        return;
                    }
                    if (doneTable[x, y, z])
                    {
                        return;
                    }
                    doneTable[x, y, z] = true;
                    if (VoxelTableContains(x, y, z) >= 0)
                    {
                        return;
                    }
                    if (outsideTable.Get(x, y, z))
                    {
                        return;
                    }
                    findList.Add(new IntVector3(x, y, z));
                    outsideTable.Set(x, y, z, true);
                };
                for (int x = 0; x < voxelSize.x; x++)
                {
                    for (int y = 0; y < voxelSize.y; y++)
                    {
                        AddFindList(x, y, 0);
                        AddFindList(x, y, voxelSize.z - 1);
                    }
                    for (int z = 0; z < voxelSize.z; z++)
                    {
                        AddFindList(x, 0, z);
                        AddFindList(x, voxelSize.y - 1, z);
                    }
                }
                for (int z = 0; z < voxelSize.z; z++)
                {
                    for (int y = 0; y < voxelSize.y; y++)
                    {
                        AddFindList(0, y, z);
                        AddFindList(voxelSize.x - 1, y, z);
                    }
                }
                for (int i = 0; i < findList.Count; i++)
                {
                    var pos = findList[i];
                    AddFindList(pos.x + 1, pos.y, pos.z);
                    AddFindList(pos.x - 1, pos.y, pos.z);
                    AddFindList(pos.x, pos.y + 1, pos.z);
                    AddFindList(pos.x, pos.y - 1, pos.z);
                    AddFindList(pos.x, pos.y, pos.z + 1);
                    AddFindList(pos.x, pos.y, pos.z - 1);
                }
            }
            #endregion

            updateVoxelTableLastTimeTicks = DateTime.Now.Ticks;
        }
        public override void GenerateOnly()
        {
            if (voxelObject == null || voxelObjectCore.voxelData == null)
            {
                return;
            }
            var voxelData = voxelObjectCore.voxelData;

            //BasicCube
            Vector3        cubeCenter;
            List <Vector3> cubeVertices;
            List <Vector3> cubeNormals;
            List <int>     cubeTriangles;

            CreateBasicCube(out cubeCenter, out cubeVertices, out cubeNormals, out cubeTriangles);

            #region Voxels
            List <Vector3> vertices  = new List <Vector3>();
            List <Vector3> normals   = new List <Vector3>();
            List <Color>   colors    = new List <Color>();
            List <Vector4> tangents  = new List <Vector4>();
            List <int>[]   triangles = new List <int> [voxelBase.materialData.Count];
            for (int i = 0; i < triangles.Length; i++)
            {
                triangles[i] = new List <int>();
            }

            #region Mesh
            Func <VoxelBaseExplosion.MeshData, VoxelBaseExplosion.MeshData> CreateMesh = (data) =>
            {
                if (data == null)
                {
                    data = new VoxelObjectExplosion.MeshData();
                }
                if (data.mesh == null)
                {
                    data.mesh = new Mesh();
                }
                else
                {
                    data.mesh.Clear(false);
                    data.mesh.ClearBlendShapes();
                }
                data.materialIndexes.Clear();
#if UNITY_2017_3_OR_NEWER
                data.mesh.indexFormat = vertices.Count > 65000 ? UnityEngine.Rendering.IndexFormat.UInt32 : UnityEngine.Rendering.IndexFormat.UInt16;
#endif
                data.mesh.vertices = vertices.ToArray();
                data.mesh.normals  = normals.ToArray();
                data.mesh.colors   = colors.ToArray();
                data.mesh.tangents = tangents.ToArray();
                {
                    int materialCount = 0;
                    for (int i = 0; i < triangles.Length; i++)
                    {
                        if (triangles[i].Count > 0)
                        {
                            materialCount++;
                        }
                    }
                    data.mesh.subMeshCount = materialCount;
                    int submesh = 0;
                    for (int i = 0; i < triangles.Length; i++)
                    {
                        if (triangles[i].Count > 0)
                        {
                            data.materialIndexes.Add(i);
                            data.mesh.SetTriangles(triangles[i].ToArray(), submesh++);
                        }
                    }
                }
                data.mesh.RecalculateBounds();
                {
                    var bounds = data.mesh.bounds;
                    bounds.min      -= Vector3.one * explosionBase.edit_velocityMax;
                    bounds.max      += Vector3.one * explosionBase.edit_velocityMax;
                    data.mesh.bounds = bounds;
                }
                vertices.Clear();
                normals.Clear();
                colors.Clear();
                tangents.Clear();
                for (int i = 0; i < voxelBase.materialData.Count; i++)
                {
                    triangles[i].Clear();
                }
                return(data);
            };
            #endregion

            {
                var        chunkObjects = voxelObject.chunks;
                FlagTable3 doneTable    = new FlagTable3(voxelData.voxelSize.x, voxelData.voxelSize.y, voxelData.voxelSize.z);
                for (int chunkIndex = 0; chunkIndex < chunkObjects.Length; chunkIndex++)
                {
                    var chunkObject = chunkObjects[chunkIndex];
                    if (chunkObject == null)
                    {
                        explosionObject.chunksExplosion[chunkIndex] = null;
                        continue;
                    }
                    var explosionChunk = explosionObject.chunksExplosion[chunkIndex] = chunkObject.gameObject.GetComponent <VoxelChunksObjectChunkExplosion>();
                    if (explosionChunk == null)
                    {
                        explosionChunk = explosionObject.chunksExplosion[chunkIndex] = Undo.AddComponent <VoxelChunksObjectChunkExplosion>(chunkObject.gameObject);
                    }

                    int meshIndex = 0;
                    Action <int, int> AddVertex = (mat, index) =>
                    {
                        if (explosionBase.edit_birthRate < 1f)
                        {
                            if (UnityEngine.Random.value >= explosionBase.edit_birthRate)
                            {
                                return;
                            }
                        }
                        if (explosionBase.edit_visibleOnly)
                        {
                            if (!voxelObjectCore.IsVoxelVisible(voxelData.voxels[index].position))
                            {
                                return;
                            }
                        }

#if !UNITY_2017_3_OR_NEWER
                        if (vertices.Count + cubeVertices.Count >= 65000)
                        {
                            for (int i = explosionChunk.meshes.Count; i <= meshIndex; i++)
                            {
                                explosionChunk.meshes.Add(null);
                            }
                            explosionChunk.meshes[meshIndex] = CreateMesh(explosionChunk.meshes[meshIndex]);
                            {
                                if (voxelBase.legacySubAssetNaming)
                                {
                                    explosionChunk.meshes[meshIndex].mesh.name = string.Format("{0}_explosion_mesh{1}", explosionChunk.name, meshIndex);
                                }
                                else
                                {
                                    explosionChunk.meshes[meshIndex].mesh.name = Path.GetFileNameWithoutExtension(voxelBase.voxelFilePath) + string.Format("_{0}_explosion_{1}", explosionChunk.name, meshIndex);
                                }
                            }
                            if (!AssetDatabase.Contains(explosionChunk.meshes[meshIndex].mesh))
                            {
                                voxelBaseCore.AddObjectToPrefabAsset(explosionChunk.meshes[meshIndex].mesh);
                            }
                            meshIndex++;
                        }
#endif

                        var velocity = UnityEngine.Random.Range(explosionBase.edit_velocityMin, explosionBase.edit_velocityMax);
                        var color    = voxelData.palettes[voxelData.voxels[index].palette];
#if UNITY_2018_1_OR_NEWER
                        if (EditorCommon.IsUniversalRenderPipeline() || EditorCommon.IsHighDefinitionRenderPipeline())
                        {
                            color.a = velocity;
                        }
#endif
                        var vOffset = vertices.Count;
                        for (int i = 0; i < cubeVertices.Count; i++)
                        {
                            var pos = cubeVertices[i];
                            pos.x += voxelData.voxels[index].position.x * voxelBase.importScale.x;
                            pos.y += voxelData.voxels[index].position.y * voxelBase.importScale.y;
                            pos.z += voxelData.voxels[index].position.z * voxelBase.importScale.z;
                            vertices.Add(pos);
                        }
                        normals.AddRange(cubeNormals);
                        for (int j = 0; j < cubeTriangles.Count; j++)
                        {
                            triangles[mat].Add(vOffset + cubeTriangles[j]);
                        }
                        for (int j = 0; j < cubeVertices.Count; j++)
                        {
                            colors.Add(color);
                        }
                        {
                            Vector3 center = new Vector3
                                             (
                                center.x = cubeCenter.x + voxelData.voxels[index].position.x * voxelBase.importScale.x,
                                center.y = cubeCenter.y + voxelData.voxels[index].position.y * voxelBase.importScale.y,
                                center.z = cubeCenter.z + voxelData.voxels[index].position.z * voxelBase.importScale.z
                                             );
                            for (int j = 0; j < cubeVertices.Count; j++)
                            {
                                tangents.Add(new Vector4(center.x - vertices[vOffset + j].x, center.y - vertices[vOffset + j].y, center.z - vertices[vOffset + j].z, velocity));
                            }
                        }
                    };

                    if (explosionChunk.meshes == null)
                    {
                        explosionChunk.meshes = new List <VoxelBaseExplosion.MeshData>();
                    }
                    for (int i = 1; i < voxelBase.materialData.Count; i++)
                    {
                        voxelBase.materialData[i].AllAction((pos) =>
                        {
                            if (doneTable.Get(pos))
                            {
                                return;
                            }
                            if (voxelData.chunkTable.Get(pos) != chunkObject.position)
                            {
                                return;
                            }
                            doneTable.Set(pos, true);
                            var index = voxelData.VoxelTableContains(pos);
                            if (index < 0)
                            {
                                return;
                            }
                            AddVertex(i, index);
                        });
                    }
                    for (int index = 0; index < voxelData.voxels.Length; index++)
                    {
                        var pos = voxelData.voxels[index].position;
                        if (doneTable.Get(pos))
                        {
                            continue;
                        }
                        if (voxelData.chunkTable.Get(pos) != chunkObject.position)
                        {
                            continue;
                        }
                        doneTable.Set(pos, true);
                        AddVertex(0, index);
                    }
                    if (vertices.Count > 0)
                    {
                        for (int i = explosionChunk.meshes.Count; i <= meshIndex; i++)
                        {
                            explosionChunk.meshes.Add(null);
                        }
                        explosionChunk.meshes[meshIndex] = CreateMesh(explosionChunk.meshes[meshIndex]);
                        if (!AssetDatabase.IsMainAsset(explosionChunk.meshes[meshIndex].mesh))
                        {
                            if (voxelBase.legacyAssetNaming)
                            {
                                explosionChunk.meshes[meshIndex].mesh.name = string.Format("{0}_explosion_mesh{1}", explosionChunk.name, meshIndex);
                            }
                            else
                            {
                                explosionChunk.meshes[meshIndex].mesh.name = Path.GetFileNameWithoutExtension(voxelBase.voxelFilePath) + string.Format("_{0}_explosion_{1}", explosionChunk.name, meshIndex);
                            }
                        }
                        if (!AssetDatabase.Contains(explosionChunk.meshes[meshIndex].mesh))
                        {
                            voxelBaseCore.AddObjectToPrefabAsset(explosionChunk.meshes[meshIndex].mesh);
                        }
                        meshIndex++;
                    }
                    explosionChunk.meshes.RemoveRange(meshIndex, explosionChunk.meshes.Count - meshIndex);

                    explosionChunk.chunkBasicOffset = chunkObject.basicOffset;
                }
            }
            #endregion

            #region Material
            explosionObject.materialMode = voxelObject.materialMode;
            if (voxelObject.materialMode == VoxelChunksObject.MaterialMode.Combine)
            {
                if (explosionObject.materials == null)
                {
                    explosionObject.materials = new List <Material>();
                }
                if (explosionObject.materials.Count < voxelBase.materialData.Count)
                {
                    for (int i = explosionObject.materials.Count; i < voxelBase.materialData.Count; i++)
                    {
                        explosionObject.materials.Add(null);
                    }
                }
                else if (explosionObject.materials.Count > voxelBase.materialData.Count)
                {
                    explosionObject.materials.RemoveRange(voxelBase.materialData.Count, explosionObject.materials.Count - voxelBase.materialData.Count);
                }
                for (int i = 0; i < explosionObject.chunksExplosion.Length; i++)
                {
                    explosionObject.chunksExplosion[i].materials = null;
                }
                for (int i = 0; i < voxelBase.materialData.Count; i++)
                {
                    if (!voxelBase.materialIndexes.Contains(i))
                    {
                        if (explosionObject.materials[i] != null)
                        {
                            explosionObject.materials[i] = null;
                            voxelBaseCore.DestroyUnusedObjectInPrefabObject();
                        }
                        continue;
                    }
                    if (explosionObject.materials[i] == null)
                    {
                        explosionObject.materials[i] = new Material(GetStandardShader(voxelBase.materialData[i].transparent));
                    }
                    else
                    {
                        explosionObject.materials[i].shader = GetStandardShader(voxelBase.materialData[i].transparent);
                    }
                    if (!AssetDatabase.Contains(explosionObject.materials[i]))
                    {
                        explosionObject.materials[i].name = explosionObject.materials[i].shader.name;
                    }
                    if (!AssetDatabase.IsMainAsset(explosionObject.materials[i]))
                    {
                        if (voxelBase.legacyAssetNaming)
                        {
                            explosionObject.materials[i].name = string.Format("explosion_mat{0}", i);
                        }
                        else
                        {
                            explosionObject.materials[i].name = Path.GetFileNameWithoutExtension(voxelBase.voxelFilePath) + string.Format("_explosion_{0}", i);
                        }
                    }
                    if (!AssetDatabase.Contains(explosionObject.materials[i]))
                    {
                        voxelBaseCore.AddObjectToPrefabAsset(explosionObject.materials[i]);
                    }
                }
            }
            else if (voxelObject.materialMode == VoxelChunksObject.MaterialMode.Individual)
            {
                explosionObject.materials = null;
                for (int chunkIndex = 0; chunkIndex < explosionObject.chunksExplosion.Length; chunkIndex++)
                {
                    var explosionChunk = explosionObject.chunksExplosion[chunkIndex];
                    if (explosionChunk.materials == null)
                    {
                        explosionChunk.materials = new List <Material>();
                    }
                    if (explosionChunk.materials.Count < voxelBase.materialData.Count)
                    {
                        for (int i = explosionChunk.materials.Count; i < voxelBase.materialData.Count; i++)
                        {
                            explosionChunk.materials.Add(null);
                        }
                    }
                    else if (explosionChunk.materials.Count > voxelBase.materialData.Count)
                    {
                        explosionChunk.materials.RemoveRange(voxelBase.materialData.Count, explosionChunk.materials.Count - voxelBase.materialData.Count);
                    }
                    for (int i = 0; i < voxelBase.materialData.Count; i++)
                    {
                        if (!voxelObject.chunks[chunkIndex].materialIndexes.Contains(i))
                        {
                            if (explosionChunk.materials[i] != null)
                            {
                                explosionChunk.materials[i] = null;
                                voxelBaseCore.DestroyUnusedObjectInPrefabObject();
                            }
                            continue;
                        }
                        if (explosionChunk.materials[i] == null)
                        {
                            explosionChunk.materials[i] = new Material(GetStandardShader(voxelBase.materialData[i].transparent));
                        }
                        else
                        {
                            explosionChunk.materials[i].shader = GetStandardShader(voxelBase.materialData[i].transparent);
                        }
                        if (!AssetDatabase.Contains(explosionChunk.materials[i]))
                        {
                            explosionChunk.materials[i].name = explosionChunk.materials[i].shader.name;
                        }
                        if (!AssetDatabase.IsMainAsset(explosionChunk.materials[i]))
                        {
                            if (voxelBase.legacyAssetNaming)
                            {
                                explosionChunk.materials[i].name = string.Format("{0}_explosion_mat{1}", explosionChunk.name, i);
                            }
                            else
                            {
                                explosionChunk.materials[i].name = Path.GetFileNameWithoutExtension(voxelBase.voxelFilePath) + string.Format("_{0}_explosion_{1}", explosionChunk.name, i);
                            }
                        }
                        if (!AssetDatabase.Contains(explosionChunk.materials[i]))
                        {
                            voxelBaseCore.AddObjectToPrefabAsset(explosionChunk.materials[i]);
                        }
                    }
                }
            }
            else
            {
                Assert.IsTrue(false);
            }
            #endregion
        }
Пример #4
0
        public List <IntVector3> GetFillVoxel(IntVector3 pos)
        {
            if (objectTarget.voxelData == null)
            {
                return(null);
            }
            if (objectTarget.voxelData.VoxelTableContains(pos) < 0)
            {
                return(null);
            }

            if (fillVoxelTable == null)
            {
                fillVoxelTable = new DataTable3 <List <IntVector3> >(objectTarget.voxelData.voxelSize.x, objectTarget.voxelData.voxelSize.y, objectTarget.voxelData.voxelSize.z);
            }
            if (!fillVoxelTable.Contains(pos))
            {
                List <IntVector3> searchList = new List <IntVector3>();
                for (int i = 0; i < objectTarget.voxelData.voxels.Length; i++)
                {
                    int posPalette = 0;
                    var doneTable  = new FlagTable3(objectTarget.voxelData.voxelSize.x, objectTarget.voxelData.voxelSize.y, objectTarget.voxelData.voxelSize.z);
                    {
                        var p = objectTarget.voxelData.voxels[i].position;
                        if (fillVoxelTable.Get(p) != null)
                        {
                            continue;
                        }
                        var index = objectTarget.voxelData.VoxelTableContains(p);
                        posPalette = objectTarget.voxelData.voxels[index].palette;
                        searchList.Clear();
                        searchList.Add(p);
                        doneTable.Set(p, true);
                    }
                    var result = new List <IntVector3>();
                    for (int j = 0; j < searchList.Count; j++)
                    {
                        var p     = searchList[j];
                        var index = objectTarget.voxelData.VoxelTableContains(p);
                        if (index < 0)
                        {
                            continue;
                        }
                        if (objectTarget.voxelData.voxels[index].palette == posPalette)
                        {
                            result.Add(p);
                            for (int x = p.x - 1; x <= p.x + 1; x++)
                            {
                                for (int y = p.y - 1; y <= p.y + 1; y++)
                                {
                                    for (int z = p.z - 1; z <= p.z + 1; z++)
                                    {
                                        if (x >= 0 && y >= 0 && z >= 0 &&
                                            x < objectTarget.voxelData.voxelSize.x && y < objectTarget.voxelData.voxelSize.y && z < objectTarget.voxelData.voxelSize.z &&
                                            !doneTable.Get(x, y, z))
                                        {
                                            doneTable.Set(x, y, z, true);
                                            var indexTmp = objectTarget.voxelData.VoxelTableContains(x, y, z);
                                            if (indexTmp >= 0 && objectTarget.voxelData.voxels[indexTmp].palette == posPalette)
                                            {
                                                searchList.Add(new IntVector3(x, y, z));
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }

                    for (int j = 0; j < result.Count; j++)
                    {
                        fillVoxelTable.Set(result[j], result);
                    }
                }
            }
            var fillVoxel = fillVoxelTable.Get(pos);

            return(fillVoxel);
        }
Пример #5
0
        public Dictionary <IntVector3, VoxelBase.Face> GetSelectionRectVoxelFace()
        {
            Dictionary <IntVector3, VoxelBase.Face> result = new Dictionary <IntVector3, VoxelBase.Face>();

            if (selectionRect.Enable &&
                objectTarget.voxelData != null && objectTarget.voxelData.vertexList != null)
            {
                var        localToWorldMatrix = objectTarget.transform.localToWorldMatrix;
                FlagTable3 containsTable      = new FlagTable3(objectTarget.voxelData.voxelSize.x + 1, objectTarget.voxelData.voxelSize.y + 1, objectTarget.voxelData.voxelSize.z + 1);
                for (int i = 0; i < objectTarget.voxelData.vertexList.Count; i++)
                {
                    var local  = objectCore.GetVoxelRatePosition(objectTarget.voxelData.vertexList[i], Vector3.zero);
                    var world  = localToWorldMatrix.MultiplyPoint3x4(local);
                    var screen = HandleUtility.WorldToGUIPoint(world);
                    if (selectionRect.rect.Contains(screen))
                    {
                        containsTable.Set(objectTarget.voxelData.vertexList[i], true);
                    }
                }
                containsTable.AllAction((x, y, z) =>
                {
                    Action <int, int, int, VoxelBase.Face> AddFace = (xx, yy, zz, face) =>
                    {
                        var pos   = new IntVector3(xx, yy, zz);
                        var index = objectTarget.voxelData.VoxelTableContains(pos);
                        if (index < 0)
                        {
                            return;
                        }
                        if ((objectTarget.voxelData.voxels[index].visible & face) == 0)
                        {
                            return;
                        }

                        VoxelBase.Face combineFace;
                        if (!result.TryGetValue(pos, out combineFace))
                        {
                            result.Add(pos, face);
                        }
                        else
                        {
                            combineFace |= face;
                            result[pos]  = combineFace;
                        }
                    };
                    #region Left
                    if (containsTable.Get(x, y + 1, z) &&
                        containsTable.Get(x, y, z + 1) &&
                        containsTable.Get(x, y + 1, z + 1))
                    {
                        AddFace(x, y, z, VoxelBase.Face.left);
                        AddFace(x - 1, y, z, VoxelBase.Face.right);
                    }
                    #endregion
                    #region Down
                    if (containsTable.Get(x + 1, y, z) &&
                        containsTable.Get(x, y, z + 1) &&
                        containsTable.Get(x + 1, y, z + 1))
                    {
                        AddFace(x, y, z, VoxelBase.Face.down);
                        AddFace(x, y - 1, z, VoxelBase.Face.up);
                    }
                    #endregion
                    #region Back
                    if (containsTable.Get(x + 1, y, z) &&
                        containsTable.Get(x, y + 1, z) &&
                        containsTable.Get(x + 1, y + 1, z))
                    {
                        AddFace(x, y, z, VoxelBase.Face.back);
                        AddFace(x, y, z - 1, VoxelBase.Face.forward);
                    }
                    #endregion
                });
            }
            return(result);
        }
Пример #6
0
        public List <IntVector3> GetFillVoxelFace(IntVector3 pos, VoxelBase.Face face)
        {
            if (objectTarget.voxelData == null)
            {
                return(null);
            }
            if (objectTarget.voxelData.VoxelTableContains(pos) < 0)
            {
                return(null);
            }

            CheckFillVoxelTableCheck();
            if (fillVoxelFaceTable == null)
            {
                fillVoxelFaceTable = new DataTable3 <Dictionary <int, List <IntVector3> > >(objectTarget.voxelData.voxelSize.x, objectTarget.voxelData.voxelSize.y, objectTarget.voxelData.voxelSize.z);
            }
            if (!fillVoxelFaceTable.Contains(pos) ||
                !fillVoxelFaceTable.Get(pos).ContainsKey((int)face))
            {
                List <IntVector3> searchList = new List <IntVector3>();
                var doneTable = new FlagTable3(objectTarget.voxelData.voxelSize.x, objectTarget.voxelData.voxelSize.y, objectTarget.voxelData.voxelSize.z);
                {
                    searchList.Clear();
                    searchList.Add(pos);
                    doneTable.Set(pos, true);
                }
                var result = new List <IntVector3>();
                for (int j = 0; j < searchList.Count; j++)
                {
                    var p     = searchList[j];
                    var index = objectTarget.voxelData.VoxelTableContains(p);
                    if (index < 0)
                    {
                        continue;
                    }
                    if ((objectTarget.voxelData.voxels[index].visible & face) != 0)
                    {
                        result.Add(p);
                        int xOffset = (face & (VoxelBase.Face.up | VoxelBase.Face.down | VoxelBase.Face.forward | VoxelBase.Face.back)) != 0 ? 1 : 0;
                        int yOffset = (face & (VoxelBase.Face.right | VoxelBase.Face.left | VoxelBase.Face.forward | VoxelBase.Face.back)) != 0 ? 1 : 0;
                        int zOffset = (face & (VoxelBase.Face.right | VoxelBase.Face.left | VoxelBase.Face.up | VoxelBase.Face.down)) != 0 ? 1 : 0;
                        for (int x = p.x - xOffset; x <= p.x + xOffset; x++)
                        {
                            for (int y = p.y - yOffset; y <= p.y + yOffset; y++)
                            {
                                for (int z = p.z - zOffset; z <= p.z + zOffset; z++)
                                {
                                    if (x >= 0 && y >= 0 && z >= 0 &&
                                        x < objectTarget.voxelData.voxelSize.x && y < objectTarget.voxelData.voxelSize.y && z < objectTarget.voxelData.voxelSize.z &&
                                        !doneTable.Get(x, y, z))
                                    {
                                        doneTable.Set(x, y, z, true);
                                        var indexTmp = objectTarget.voxelData.VoxelTableContains(x, y, z);
                                        if (indexTmp >= 0)
                                        {
                                            searchList.Add(new IntVector3(x, y, z));
                                        }
                                    }
                                }
                            }
                        }
                    }
                }

                Dictionary <int, List <IntVector3> > data;
                if (fillVoxelFaceTable.Contains(pos))
                {
                    data = fillVoxelFaceTable.Get(pos);
                }
                else
                {
                    data = new Dictionary <int, List <IntVector3> >();
                }
                data[(int)face] = result;
                fillVoxelFaceTable.Set(pos, data);
                for (int j = 0; j < result.Count; j++)
                {
                    if (fillVoxelFaceTable.Contains(result[j]))
                    {
                        data = fillVoxelFaceTable.Get(result[j]);
                    }
                    else
                    {
                        data = new Dictionary <int, List <IntVector3> >();
                    }
                    data[(int)face] = result;
                    fillVoxelFaceTable.Set(result[j], data);
                }
            }
            var fillVoxel = fillVoxelFaceTable.Get(pos)[(int)face];

            return(fillVoxel);
        }
Пример #7
0
 public DataTable3(int reserveX = 0, int reserveY = 0, int reserveZ = 0)
 {
     reserve = new IntVector3(reserveX, reserveY, reserveZ);
     enable  = new FlagTable3(reserveX, reserveY, reserveZ);
 }