Exemple #1
0
        public void UnregisterPendingStructures()
        {
            // TODO: This is not exactly optimal. A lot of iterations for one mutex. On the other hand, I expect only
            // a small amount of structures stored here. Definitelly not hundreds or more. But there's a room for
            // improvement...
            lock (pendingStructureMutex)
            {
                // Let's see whether we can unload any positions
                for (int i = 0; i < pendingStructureInfo.Count;)
                {
                    StructureInfo info = pendingStructureInfo[i];
                    Vector3Int    pos  = info.chunkPos;

                    // See whether we can remove the structure
                    if (!Bounds.IsInside(ref pos))
                    {
                        pendingStructureInfo.RemoveAt(i);
                    }
                    else
                    {
                        ++i;
                        continue;
                    }

                    // Structure removed. We need to remove any associated world positions now
                    for (int y = info.bounds.minY; y < info.bounds.maxY; y += Env.CHUNK_SIZE)
                    {
                        for (int z = info.bounds.minZ; z < info.bounds.maxZ; z += Env.CHUNK_SIZE)
                        {
                            for (int x = info.bounds.minX; x < info.bounds.maxX; x += Env.CHUNK_SIZE)
                            {
                                if (!pendingStructures.TryGetValue(new Vector3Int(x, y, z), out List <StructureContext> list) || list.Count <= 0)
                                {
                                    continue;
                                }

                                // Remove any occurence of this structure from pending positions
                                for (int j = 0; j < list.Count;)
                                {
                                    if (list[j].id == info.id)
                                    {
                                        list.RemoveAt(j);
                                    }
                                    else
                                    {
                                        ++j;
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
Exemple #2
0
        public void RegisterPendingStructure(StructureInfo info, StructureContext context)
        {
            if (info == null || context == null)
            {
                return;
            }

            lock (pendingStructureMutex)
            {
                {
                    bool alreadyThere = false;

                    // Do not register the same thing twice
                    for (int i = 0; i < pendingStructureInfo.Count; i++)
                    {
                        if (pendingStructureInfo[i].Equals(info))
                        {
                            alreadyThere = true;
                            break;
                        }
                    }

                    if (!alreadyThere)
                    {
                        pendingStructureInfo.Add(info);
                    }
                }

                if (pendingStructures.TryGetValue(context.chunkPos, out List <StructureContext> list))
                {
                    list.Add(context);
                }
                else
                {
                    pendingStructures.Add(context.chunkPos, new List <StructureContext> {
                        context
                    });
                }
            }

            {
                Chunk chunk;
                lock (chunks)
                {
                    // Let the chunk know it needs an update if it exists
                    chunk = GetChunk(ref context.chunkPos);
                }
                if (chunk != null)
                {
                    chunk.needApplyStructure = true;
                }
            }
        }
Exemple #3
0
        public override void Build(Chunk chunk, int id, ref Vector3Int worldPos, TerrainLayer layer)
        {
            World world = chunk.World;

            int noise =
                Helpers.FastFloor(NoiseUtils.GetNoise(layer.Noise.Noise, worldPos.x, worldPos.y, worldPos.z, 1f, 3, 1f));
            int leavesRange  = MIN_CROWN_SIZE + noise;
            int leavesRange1 = leavesRange - 1;
            int trunkHeight  = MIN_TRUNK_SIZE + noise;

            // Make the crown an ellipsoid flattened on the y axis
            float a2inv = 1.0f / (leavesRange * leavesRange);
            float b2inv = 1.0f / (leavesRange1 * leavesRange1);

            int x1 = worldPos.x - leavesRange;
            int x2 = worldPos.x + leavesRange;
            int y1 = worldPos.y + 1 + trunkHeight;
            int y2 = y1 + 1 + 2 * leavesRange1;
            int z1 = worldPos.z - leavesRange;
            int z2 = worldPos.z + leavesRange;

            int cx, cy, cz;
            int minX, minY, minZ;
            int maxX, maxY, maxZ;

            AABBInt       bounds   = new AABBInt(x1, worldPos.y, z1, x2, y2, z2);
            Vector3Int    chunkPos = chunk.Pos;
            StructureInfo info     = null;

            // Generate the crown
            Vector3Int posFrom      = new Vector3Int(x1, y1, z1);
            Vector3Int posTo        = new Vector3Int(x2, y2, z2);
            Vector3Int chunkPosFrom = Helpers.ContainingChunkPos(ref posFrom);
            Vector3Int chunkPosTo   = Helpers.ContainingChunkPos(ref posTo);

            minY = Helpers.Mod(posFrom.y, Env.CHUNK_SIZE);
            for (cy = chunkPosFrom.y; cy <= chunkPosTo.y; cy += Env.CHUNK_SIZE, minY = 0)
            {
                maxY = System.Math.Min(posTo.y - cy, Env.CHUNK_SIZE_1);
                minZ = Helpers.Mod(posFrom.z, Env.CHUNK_SIZE);
                for (cz = chunkPosFrom.z; cz <= chunkPosTo.z; cz += Env.CHUNK_SIZE, minZ = 0)
                {
                    maxZ = System.Math.Min(posTo.z - cz, Env.CHUNK_SIZE_1);
                    minX = Helpers.Mod(posFrom.x, Env.CHUNK_SIZE);
                    for (cx = chunkPosFrom.x; cx <= chunkPosTo.x; cx += Env.CHUNK_SIZE, minX = 0)
                    {
                        maxX = System.Math.Min(posTo.x - cx, Env.CHUNK_SIZE_1);

                        int xOff = cx - worldPos.x;
                        int yOff = cy - y1 - leavesRange1;
                        int zOff = cz - worldPos.z;

                        if (cx != chunk.Pos.x || cy != chunk.Pos.y || cz != chunk.Pos.z)
                        {
                            Vector3Int pos = new Vector3Int(cx, cy, cz);
                            Vector3Int min = new Vector3Int(minX, minY, minZ);
                            Vector3Int max = new Vector3Int(maxX, maxY, maxZ);

                            if (info == null)
                            {
                                info = new StructureInfo(id, ref chunkPos, ref bounds);
                            }

                            world.RegisterPendingStructure(info, new StructureContextTreeCrown(id, ref pos, ref worldPos, ref min, ref max, noise));

                            continue;
                        }

                        // Actual crown construction
                        ChunkBlocks blocks  = chunk.Blocks;
                        int         index   = Helpers.GetChunkIndex1DFrom3D(minX, minY, minZ);
                        int         yOffset = Env.CHUNK_SIZE_WITH_PADDING_POW_2 - (maxZ - minZ + 1) * Env.CHUNK_SIZE_WITH_PADDING;
                        int         zOffset = Env.CHUNK_SIZE_WITH_PADDING - (maxX - minX + 1);
                        for (int y = minY; y <= maxY; ++y, index += yOffset)
                        {
                            for (int z = minZ; z <= maxZ; ++z, index += zOffset)
                            {
                                for (int x = minX; x <= maxX; ++x, ++index)
                                {
                                    int xx = x + xOff;
                                    int yy = y + yOff;
                                    int zz = z + zOff;

                                    float _x = xx * xx * a2inv;
                                    float _y = yy * yy * b2inv;
                                    float _z = zz * zz * a2inv;
                                    if (_x + _y + _z <= 1.0f)
                                    {
                                        blocks.SetRaw(index, leaves);
                                    }
                                }
                            }
                        }
                    }
                }
            }

            // Generate the trunk
            posFrom      = new Vector3Int(worldPos.x, worldPos.y, worldPos.z);
            posTo        = new Vector3Int(worldPos.x, worldPos.y + trunkHeight, worldPos.z);
            chunkPosFrom = Helpers.ContainingChunkPos(ref posFrom);
            chunkPosTo   = Helpers.ContainingChunkPos(ref posTo);

            cx = Helpers.MakeChunkCoordinate(worldPos.x);
            cz = Helpers.MakeChunkCoordinate(worldPos.z);

            int tx = Helpers.Mod(worldPos.x, Env.CHUNK_SIZE);
            int tz = Helpers.Mod(worldPos.z, Env.CHUNK_SIZE);

            minY = Helpers.Mod(posFrom.y, Env.CHUNK_SIZE);
            for (cy = chunkPosFrom.y; cy <= chunkPosTo.y; cy += Env.CHUNK_SIZE, minY = 0)
            {
                maxY = System.Math.Min(posTo.y - cy, Env.CHUNK_SIZE_1);

                if (cx != chunk.Pos.x || cy != chunk.Pos.y || cz != chunk.Pos.z)
                {
                    Vector3Int pos = new Vector3Int(cx, cy, cz);
                    Vector3Int min = new Vector3Int(tx, minY, tz);
                    Vector3Int max = new Vector3Int(tx, maxY, tz);

                    if (info == null)
                    {
                        info = new StructureInfo(id, ref chunkPos, ref bounds);
                    }

                    world.RegisterPendingStructure(info, new StructureContextTreeTrunk(id, ref pos, ref min, ref max));

                    continue;
                }

                // Actual trunk construction
                ChunkBlocks blocks = chunk.Blocks;
                int         index  = Helpers.GetChunkIndex1DFrom3D(tx, minY, tz);
                for (int y = minY; y <= maxY; ++y, index += Env.CHUNK_SIZE_WITH_PADDING_POW_2)
                {
                    blocks.SetRaw(index, log);
                }
            }
        }