/// <summary>
        /// Generate new mesh instances
        /// </summary>
        /// <param name="areaSize"></param>
        public static void GenerateFoliageMeshInstances(FoliageResolutions resolution)
        {
            if (!prototypeMeshInstances.ContainsKey(resolution))
            {
                prototypeMeshInstances.Add(resolution, new Dictionary <int, GPUMesh>());
            }

            var meshInstances = prototypeMeshInstances[resolution];

            if (meshInstances.Count > 0)
            {
                for (int i = 0; i < FoliageDB.unSortedPrototypes.Count; i++)
                {
                    if (meshInstances.ContainsKey(FoliageDB.unSortedPrototypes[i].id))
                    {
                        meshInstances[FoliageDB.unSortedPrototypes[i].id].Destroy();
                    }
                }

                meshInstances.Clear();
            }

            if (FoliageCore_MainManager.instance.enabled)
            {
                for (int prototypeIndex = 0; prototypeIndex < FoliageDB.unSortedPrototypes.Count; prototypeIndex++)
                {
                    if (FoliageDB.unSortedPrototypes[prototypeIndex].enabled)
                    {
                        GenerateFoliageMeshInstanceForIndex(FoliageDB.unSortedPrototypes[prototypeIndex].id, resolution);
                    }
                }
            }
        }
        /// <summary>
        /// Create Foliage mesh instances for a certain index and foliage size.
        /// </summary>
        /// <param name="meshInstances"></param>
        /// <param name="prototypeIndex"></param>
        public static void GenerateFoliageMeshInstanceForIndex(int prototypeIndex, FoliageResolutions resolution)
        {
            Dictionary <int, GPUMesh> meshInstances = prototypeMeshInstances[resolution];

            FoliagePrototype prototype = FoliageDB.sortedPrototypes[prototypeIndex];

            if (!FoliageCore_MainManager.instance.enabled)
            {
                return;
            }

            bool prototypeMeshExists = prototypeMeshInstances != null && meshInstances.ContainsKey(prototypeIndex);

            if (prototypeMeshExists)
            {
                meshInstances[prototypeIndex].Destroy();
                meshInstances.Remove(prototypeIndex);
            }

            Mesh[] meshes    = new Mesh[prototype.meshLodsCount];
            int[]  densities = new int[prototype.meshLodsCount];
            List <UNPhysicsTemplate>[] physicsObjects = new List <UNPhysicsTemplate> [prototype.meshLodsCount];

            for (int i = 0; i < prototype.meshLodsCount; i++)
            {
                meshes[i]    = CreateNewMesh();
                densities[i] = Mathf.FloorToInt((float)prototype.maxGeneratedDensity / (i + 1));

                FoliageMeshInstance.CreateGPUMesh(prototype, meshes[i], densities[i]);
            }
            meshInstances.Add(prototypeIndex, new GPUMesh(meshes, densities, prototypeIndex, physicsObjects, resolution));
        }
Exemple #3
0
        internal static Dictionary <int, GPUMesh> GetPrototypeMeshInstances(FoliageResolutions resolution)
        {
            if (!prototypeMeshInstances.ContainsKey(resolution))
            {
                GenerateFoliageMeshInstances(resolution);
            }

            return(prototypeMeshInstances[resolution]);
        }
        public GPUMesh(Mesh[] LODMeshes, int[] LODLevels, int prototypeIndex, List <UNPhysicsTemplate>[] physicsInformation, FoliageResolutions resolution)
        {
            if (LODMeshes.Length != LODLevels.Length)
            {
                Debug.LogError("uNature Foliage : Generating LODs Failed!, Array sizes are different!");
                return;
            }

            LODMeshInstances = new FoliageMeshInstancesGroup[LODMeshes.Length];

            for (int i = 0; i < LODMeshes.Length; i++)
            {
                meshes.Add(new GPUMeshLOD(LODMeshes[i], LODLevels[i], prototypeIndex, physicsInformation[i]));

                LODMeshInstances[i] = FoliageMeshInstance.CreateFoliageInstances(prototypeIndex, LODLevels[i], resolution);
            }
        }
Exemple #5
0
        public static FoliageMeshInstancesGroup CreateFoliageInstances(int prototypeIndex, int density, FoliageResolutions resolution)
        {
            float resMultiplier = (float)resolution / FoliageCore_MainManager.FOLIAGE_INSTANCE_AREA_SIZE;

            FoliagePrototype prototype = FoliageDB.sortedPrototypes[prototypeIndex];

            int maxGenerationInstancesPerMesh = (int)(CalculatePerMeshInstances(prototype, density) / resMultiplier);

            int generationAmountPerRadius = GENERATION_AMOUNT_PER_RADIUS(maxGenerationInstancesPerMesh);

            FoliageMeshInstancesGroup meshGroup = new FoliageMeshInstancesGroup();

            Vector3 position;

            int gAmountX = generationAmountPerRadius - (int)prototype.meshInstancesGenerationOffset.x;

            if (gAmountX == 0)
            {
                gAmountX = 1;                // dont clamp, it can be minus
            }
            int gAmountZ = generationAmountPerRadius - (int)prototype.meshInstancesGenerationOffset.y;

            if (gAmountZ == 0)
            {
                gAmountZ = 1;                // dont clamp, it can be minus
            }
            for (int x = 0; x < gAmountX; x++)
            {
                for (int z = 0; z < gAmountZ; z++)
                {
                    position = new Vector3(z * maxGenerationInstancesPerMesh, 0, x * maxGenerationInstancesPerMesh);

                    meshGroup.AddMeshInstance(FoliageMeshInstance.CreateFoliageMesh(prototype, position, maxGenerationInstancesPerMesh));
                }
            }

            return(meshGroup);
        }