Пример #1
0
        protected virtual void ApplyScaleChange()
        {
            if (FoliageCore_MainManager.instance == null)
            {
                return;
            }

            FoliageCore_MainManager mInstance = FoliageCore_MainManager.instance;

            float scaleX = worldScale.x * transform.localScale.x;
            float scaleZ = worldScale.z * transform.localScale.z;

            mInstance.UpdateHeights(Mathf.FloorToInt(transform.position.x), Mathf.FloorToInt(transform.position.z), Mathf.CeilToInt(scaleX), Mathf.CeilToInt(scaleZ));

            scaleX = worldScale.x * lastReadScale.x;
            scaleZ = worldScale.z * lastReadScale.z;

            //revert old scale
            mInstance.UpdateHeights(Mathf.FloorToInt(transform.position.x), Mathf.FloorToInt(transform.position.z), Mathf.CeilToInt(scaleX), Mathf.CeilToInt(scaleZ));

            lastReadScale = transform.localScale;

            FoliageCore_MainManager.SaveDelayedMaps();
        }
Пример #2
0
        /// <summary>
        /// Set detail layer in world cords
        /// </summary>
        /// <param name="baseX">WORLD CORDS!!</param>
        /// <param name="baseZ">WORLD CORDS!!</param>
        /// <param name="sizeX">WORLD CORDS!!</param>
        /// <param name="sizeZ">WORLD CORDS!!</param>
        /// <param name="prototypeIndex">prototype.id</param>
        /// <param name="densities">the density in bytes from 0 -> 15</param>
        public void SetDetailLayer(int baseX, int baseZ, int sizeX, int sizeZ, int prototypeIndex, byte[,] densities)
        {
            if (sector == null)
            {
                return;
            }

            if (densities.GetLength(0) != sizeX || densities.GetLength(1) != sizeZ)
            {
                Debug.LogError("uNature: Densities out of range!!");

                return;
            }

            Vector3 pos = transform.position;

            int startX = baseX;
            int startZ = baseZ;

            int endX = startX + sizeX;
            int endZ = startZ + sizeZ;

            int interpolatedX;
            int interpolatedZ;

            int mChunkID;
            FoliageCore_Chunk      mChunk;
            FoliageManagerInstance mInstance;

            FoliagePrototype prototype;
            FoliageGrassMap  grassMap;

            for (int x = startX; x < endX; x++)
            {
                for (int z = startZ; z < endZ; z++)
                {
                    mChunkID = GetChunkID(x - pos.x, z - pos.z);

                    if (!CheckChunkInBounds(mChunkID))
                    {
                        continue;                                // if position is out of bounds continue to the next position [very rare]
                    }
                    mChunk = _sector.foliageChunks[mChunkID];

                    if (!mChunk.isFoliageInstanceAttached)
                    {
                        continue;                                    // if this chunk doesnt have an manager instance attached then there's no need to modify it.
                    }
                    mInstance = mChunk.GetOrCreateFoliageManagerInstance();

                    interpolatedX = mInstance.TransformCord(x, mInstance.transform.position.x);
                    interpolatedZ = mInstance.TransformCord(z, mInstance.transform.position.z);

                    prototype = FoliageDB.sortedPrototypes[prototypeIndex];

                    grassMap = mInstance.grassMaps[prototype];

                    grassMap.mapPixels[interpolatedX + interpolatedZ * grassMap.mapWidth].b = densities[x - startX, z - startZ];
                    grassMap.SetPixels32Delayed();
                    grassMap.dirty = true;
                }
            }

            FoliageCore_MainManager.SaveDelayedMaps();
        }
Пример #3
0
        void PaintBrush(bool isErase, Vector2 position, PaintBrush brush)
        {
            FoliageCore_MainManager mManager = FoliageCore_MainManager.instance;

            int chunkID;
            FoliageManagerInstance mInstance;

            brush.TryToResize(paintBrushSize);

            Texture2D texture = brush.instancedTexture;

            int textureWidth  = texture.width;
            int textureHeight = texture.height;

            Color32 pixel;

            Color32[] grassMapPixels;
            int       mapWidth;

            int posX;
            int posZ;

            int transformedCordX;
            int transformedCordZ;

            FoliagePrototype prototype;
            FoliageGrassMap  grassMap;

            int radius = textureWidth / 2;

            byte density;

            for (int prototypeIndex = 0; prototypeIndex < chosenPrototypes.Count; prototypeIndex++)
            {
                prototype = chosenPrototypes[prototypeIndex];

                for (int x = 0; x < textureWidth; x++)
                {
                    for (int y = 0; y < textureHeight; y++)
                    {
                        pixel = brush.pixels[x, y];

                        if (pixel.r == 255 && pixel.g == 255 && pixel.b == 255)
                        {
                            posX = x - radius + (int)position.x - (int)mManager.transform.position.x;
                            posZ = y - radius + (int)position.y - (int)mManager.transform.position.z;

                            chunkID = mManager.GetChunkID(posX, posZ);

                            mInstance = mManager.sector.foliageChunks[chunkID].GetOrCreateFoliageManagerInstance();

                            transformedCordX = mInstance.TransformCord(posX, mInstance.attachedTo.transform.localPosition.x);
                            transformedCordZ = mInstance.TransformCord(posZ, mInstance.attachedTo.transform.localPosition.z);

                            grassMap = mInstance.grassMaps[prototype];

                            grassMapPixels = grassMap.mapPixels;
                            mapWidth       = grassMap.mapWidth;

                            density = grassMapPixels[transformedCordX + transformedCordZ * mapWidth].b;

                            if (paintDensity > density || (isErase && (instaRemove || paintDensity < density)))
                            {
                                grassMap.mapPixels[transformedCordX + transformedCordZ * mapWidth].b = isErase && instaRemove ? (byte)0 : paintDensity;

                                grassMap.dirty = true;
                                grassMap.SetPixels32Delayed();
                            }
                        }
                    }
                }

                FoliageCore_MainManager.SaveDelayedMaps();
                FoliageCore_MainManager.CallInstancesChunksUpdate();
            }
        }