Method ExportTerrain

Source/Editor/Tools/Terrain/TerrainTools.cpp:363–456

}

bool TerrainTools::ExportTerrain(Terrain* terrain, String outputFolder)
{
    PROFILE_CPU_NAMED("Terrain.ExportTerrain");
    CHECK_RETURN(terrain && terrain->GetPatchesCount() != 0, true);

    // Find size of heightmap in patches
    const auto firstPatch = terrain->GetPatch(0);
    Int2 start(firstPatch->GetX(), firstPatch->GetZ());
    Int2 end(start);
    for (int32 patchIndex = 0; patchIndex < terrain->GetPatchesCount(); patchIndex++)
    {
        const auto patch = terrain->GetPatch(patchIndex);
        const Int2 pos(patch->GetX(), patch->GetZ());
        start = Int2::Min(start, pos);
        end = Int2::Max(end, pos);
    }
    const Int2 size = (end + 1) - start;

    // Allocate heightmap for a whole terrain (NumberOfPatches * 4x4 * ChunkSize + 1)
    const Int2 heightmapSize = size * Terrain::ChunksCountEdge * terrain->GetChunkSize() + 1;
    Array<float> heightmap;
    heightmap.Resize(heightmapSize.X * heightmapSize.Y);
    if (const float* heightmapData = firstPatch->GetHeightmapData())
        heightmap.SetAll(heightmapData[0]);

    // Fill heightmap with data from all patches
    const int32 rowSize = terrain->GetChunkSize() * Terrain::ChunksCountEdge + 1;
    for (int32 patchIndex = 0; patchIndex < terrain->GetPatchesCount(); patchIndex++)
    {
        const auto patch = terrain->GetPatch(patchIndex);
        const Int2 pos(patch->GetX() - start.X, patch->GetZ() - start.Y);
        const float* src = patch->GetHeightmapData();
        float* dst = heightmap.Get() + pos.X * (rowSize - 1) + pos.Y * heightmapSize.X * (rowSize - 1);
        if (src)
        {
            for (int32 row = 0; row < rowSize; row++)
                Platform::MemoryCopy(dst + row * heightmapSize.X, src + row * rowSize, rowSize * sizeof(float));
        }
        else
        {
            for (int32 row = 0; row < rowSize; row++)
                Platform::MemoryClear(dst + row * heightmapSize.X, rowSize * sizeof(float));
        }
    }

    // Interpolate to 16-bit int
    float maxHeight, minHeight;
    maxHeight = minHeight = heightmap[0];
    for (int32 i = 1; i < heightmap.Count(); i++)
    {
        float h = heightmap.Get()[i];
        if (maxHeight < h)
            maxHeight = h;
        else if (minHeight > h)
            minHeight = h;
    }
    const float alpha = MAX_uint16 / (maxHeight - minHeight);