Heightmap terrain: .tch chunk packs, streaming with LOD, terrain painting, water and modifiers - terrain/<name>/terrain.yaml + <px>_<pz>.tch packs of 16x16 chunks (250 m, 0.5/1/2/5 m spacing), slices with crc-32 and optional zstd (vendored zstd 1.5.6 in ref/zstd) - heightmap_terrain [name] endheightmap_terrain directive replaces editorterrain - streamer: worker threads, camera + look-ahead loading, geomipmap LOD with skirts, pooled geometry - mat_terrain shader: up to 8 painted layer materials per chunk via texture arrays (opengl33); other renderers fall back to the dominant material - water bodies (outline + level), terrain modifiers (vertical profile shaping kept non-destructive) - F11 Terrain work mode rebuilt: chunks, sculpt, smooth, paint, point spacing, water tools

rendering/opengl33renderer.cpp

@@ -616,6 +616,8 @@ bool opengl33_renderer::Render()
 	}
 	// generate new frame
     opengl_texture::reset_unit_cache();
+	// textures of new heightmap terrain layers go to the arrays the terrain shader reads them from
+	m_terrainmaterials.update();
 	if( EditorModeFlag ) {
 		// the editor moves and resizes model instances in place, which leaves the copies of their bounds out of date
 		++m_instanceboundsversion;
@@ -2417,6 +2419,20 @@ IMaterial const *opengl33_renderer::Material(material_handle const Material) con
 	return &m_materials.material(Material);
 }
 
+material_handle opengl33_renderer::Terrain_Material(material_handle const Reuse, std::vector<gfx::terrain_layer> const &Layers, int const Samples, std::uint8_t const *Weights, glm::vec3 const &Placement)
+{
+	auto const material{m_terrainmaterials.make(Reuse, Layers, Samples, Weights, Placement)};
+	if (material != null_handle)
+		return material;
+	// the terrain shader can't be used, the chunk makes do with a plain material
+	return gfx_renderer::Terrain_Material(Reuse, Layers, Samples, Weights, Placement);
+}
+
+void opengl33_renderer::Terrain_Release(material_handle const Material)
+{
+	m_terrainmaterials.release(Material);
+}
+
 opengl_material &opengl33_renderer::Material(material_handle const Material)
 {
 	return m_materials.material(Material);

rendering/opengl33renderer.h

@@ -29,6 +29,7 @@ http://mozilla.org/MPL/2.0/.
 #include "gl/glsl_common.h"
 #include "gl/pbo.h"
 #include "gl/query.h"
+#include "rendering/opengl33terrain.h"
 
 // bare-bones render controller, in lack of anything better yet
 class opengl33_renderer : public gfx_renderer {
@@ -81,6 +82,10 @@ class opengl33_renderer : public gfx_renderer {
         Bind_Material( material_handle const Material, TSubModel const *sm = nullptr, lighting_data const *lighting = nullptr ) override;
     IMaterial const *
         Material( material_handle const Material ) const override;
+    material_handle
+        Terrain_Material( material_handle const Reuse, std::vector<gfx::terrain_layer> const &Layers, int const Samples, std::uint8_t const *Weights, glm::vec3 const &Placement ) override;
+    void
+        Terrain_Release( material_handle const Material ) override;
     // shader methods
     auto Fetch_Shader( std::string const &name ) -> std::shared_ptr<gl::program> override;
     // texture methods
@@ -350,6 +355,7 @@ class opengl33_renderer : public gfx_renderer {
 	gfx::geometrybank_manager m_geometry;
 	material_manager m_materials;
 	texture_manager m_textures;
+	opengl33_terrain_materials m_terrainmaterials{m_materials, m_textures};
 	opengl33_light m_sunlight;
 	opengllight_array m_lights;
 	/*

rendering/opengl33terrain.cpp

@@ -0,0 +1,423 @@
+/*
+This Source Code Form is subject to the
+terms of the Mozilla Public License, v.
+2.0. If a copy of the MPL was not
+distributed with this file, You can
+obtain one at
+http://mozilla.org/MPL/2.0/.
+*/
+
+#include "stdafx.h"
+#include "rendering/opengl33terrain.h"
+
+#include "rendering/opengl33geometrybank.h"
+#include "utilities/Globals.h"
+#include "utilities/Logs.h"
+
+namespace
+{
+
+std::size_t constexpr max_layers{8};
+int constexpr initial_capacity{8};
+int constexpr copy_attempts{600}; // frames to wait for the textures of a layer to load before it's left with what it has
+float constexpr default_repeat{8.f};
+
+// array textures: diffuse, normal maps, specular/gloss maps
+std::array<int, 3> constexpr array_sizes{1024, 512, 256};
+
+void bind_for_upload(opengl_texture const &Texture)
+{
+	::glActiveTexture(GL_TEXTURE0);
+	::glBindTexture(Texture.target, Texture.id);
+}
+
+void set_anisotropy(GLenum const Target)
+{
+	if (Global.AnisotropicFiltering >= 0 && (GLAD_GL_EXT_texture_filter_anisotropic || GLAD_GL_ARB_texture_filter_anisotropic))
+		::glTexParameterf(Target, GL_TEXTURE_MAX_ANISOTROPY_EXT, Global.AnisotropicFiltering);
+}
+
+} // namespace
+
+bool opengl33_terrain_materials::init()
+{
+	if (m_state != 0)
+		return m_state > 0;
+	m_state = -1;
+	try
+	{
+		m_copy = std::make_unique<gl::postfx>(gl::shader("copy.frag"));
+	}
+	catch (gl::shader_exception const &e)
+	{
+		ErrorLog("heightmap terrain: can't use the copy shader: " + std::string(e.what()));
+		return false;
+	}
+	m_framebuffer = std::make_unique<gl::framebuffer>();
+
+	m_white = make_texture("internal_src:terrain/white", GL_TEXTURE_2D);
+	{
+		auto const &white{m_textures.texture(m_white)};
+		std::uint8_t const texel[4]{255, 255, 255, 255};
+		bind_for_upload(white);
+		::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+		::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+		::glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, texel);
+	}
+	char const *names[]{"internal_src:terrain/layers_diffuse", "internal_src:terrain/layers_normal", "internal_src:terrain/layers_specgloss"};
+	for (std::size_t i = 0; i < m_arrays.size(); ++i)
+	{
+		auto &array{m_arrays[i]};
+		array.handle = make_texture(names[i], GL_TEXTURE_2D_ARRAY);
+		array.size = array_sizes[i];
+		array.srgb = (i == 0);
+		array.format = (array.srgb ? GL_SRGB8_ALPHA8 : GL_RGBA8);
+		make_storage(array, initial_capacity);
+	}
+	m_capacity = initial_capacity;
+	opengl_texture::reset_unit_cache();
+
+	// the shader is checked now, so a broken one makes the terrain fall back on plain materials instead of the failure indicator
+	try
+	{
+		GfxRenderer->Fetch_Shader("terrain");
+	}
+	catch (gl::shader_exception const &e)
+	{
+		ErrorLog("heightmap terrain: can't use the terrain shader: " + std::string(e.what()));
+		return false;
+	}
+	m_state = 1;
+	return true;
+}
+
+texture_handle opengl33_terrain_materials::make_texture(std::string const &Name, GLenum const Target)
+{
+	auto const handle{m_textures.create(Name, false, GL_RGBA)};
+	auto &texture{m_textures.texture(handle)};
+	if (texture.id == opengl_texture::invalid_id)
+		::glGenTextures(1, &texture.id);
+	texture.target = Target;
+	// the content is supplied here, the texture manager isn't to load, release or replace it
+	texture.is_ready = true;
+	texture.is_static = true;
+	texture.is_rendertarget = true;
+	texture.is_texstub = false;
+	texture.data_state = resource_state::good;
+	return handle;
+}
+
+void opengl33_terrain_materials::make_storage(texture_array &Array, int const Layers)
+{
+	auto &texture{m_textures.texture(Array.handle)};
+	bind_for_upload(texture);
+	::glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
+	::glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+	::glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_WRAP_S, GL_REPEAT);
+	::glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_WRAP_T, GL_REPEAT);
+	set_anisotropy(GL_TEXTURE_2D_ARRAY);
+	::glTexImage3D(GL_TEXTURE_2D_ARRAY, 0, Array.format, Array.size, Array.size, Layers, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
+	texture.data_width = Array.size;
+	texture.data_height = Array.size;
+	texture.layers = Layers;
+	texture.data_format = Array.format;
+	texture.data_components = GL_RGBA;
+}
+
+int opengl33_terrain_materials::layer_index(gfx::terrain_layer const &Layer)
+{
+	for (auto const &existing : m_layers)
+		if (existing.material == Layer.material && existing.size == Layer.size)
+			return existing.index;
+
+	layer entry;
+	entry.material = Layer.material;
+	entry.size = Layer.size;
+	entry.index = static_cast<int>(m_layers.size());
+	auto const &material{m_materials.material(Layer.material)};
+	entry.repeat = (Layer.size > 0.f ? Layer.size : (material.size.x > 0.f ? material.size.x : default_repeat));
+	if (material.shader)
+	{
+		entry.normalmap = material.shader->texture_conf.count("normalmap") > 0;
+		entry.specgloss = material.shader->texture_conf.count("specgloss") > 0;
+	}
+	entry.reflection = (std::isfinite(material.params[1].z) ? material.params[1].z : 0.f);
+	m_layers.push_back(entry);
+	m_pending = true;
+
+	if (static_cast<int>(m_layers.size()) > m_capacity)
+	{
+		// more room: the arrays are made anew, and every layer copied again
+		auto const capacity{m_capacity * 2};
+		for (auto &array : m_arrays)
+		{
+			auto &texture{m_textures.texture(array.handle)};
+			::glDeleteTextures(1, &texture.id);
+			::glGenTextures(1, &texture.id);
+			make_storage(array, capacity);
+		}
+		m_capacity = capacity;
+		for (auto &existing : m_layers)
+		{
+			existing.copied = false;
+			existing.attempts = 0;
+		}
+		opengl_texture::reset_unit_cache();
+	}
+	return entry.index;
+}
+
+std::size_t opengl33_terrain_materials::acquire_slot(material_handle const Reuse)
+{
+	if (Reuse != null_handle)
+	{
+		auto const lookup{m_slotof.find(Reuse)};
+		if (lookup != m_slotof.end())
+		{
+			m_slots[lookup->second].used = true;
+			return lookup->second;
+		}
+	}
+	if (false == m_free.empty())
+	{
+		auto const index{m_free.back()};
+		m_free.pop_back();
+		m_slots[index].used = true;
+		return index;
+	}
+	auto const index{m_slots.size()};
+	auto const suffix{std::to_string(index)};
+	slot entry;
+	entry.weights[0] = make_texture("internal_src:terrain/weights0_" + suffix, GL_TEXTURE_2D);
+	entry.weights[1] = make_texture("internal_src:terrain/weights1_" + suffix, GL_TEXTURE_2D);
+	entry.table = make_texture("internal_src:terrain/table_" + suffix, GL_TEXTURE_2D);
+	// the textures get their content before the material is made of them, which checks they're there
+	std::uint8_t const blank[4]{0, 0, 0, 0};
+	for (auto const handle : entry.weights)
+	{
+		bind_for_upload(m_textures.texture(handle));
+		::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+		::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+		::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+		::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
+		::glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, blank);
+		::glGenerateMipmap(GL_TEXTURE_2D);
+	}
+	{
+		bind_for_upload(m_textures.texture(entry.table));
+		::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+		::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+		std::array<float, max_layers * 2 * 4> const zeros{};
+		::glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA32F, static_cast<GLsizei>(max_layers), 2, 0, GL_RGBA, GL_FLOAT, zeros.data());
+	}
+	opengl_texture::reset_unit_cache();
+	auto const name = [&](texture_handle const Handle) { return "internal_src:" + m_textures.texture(Handle).name; };
+	std::string const definition{
+	    "shader: terrain\n"
+	    "texture1: " + name(m_white) + "\n"
+	    "texture2: " + name(entry.weights[0]) + "\n"
+	    "texture3: " + name(entry.weights[1]) + "\n"
+	    "texture4: " + name(m_arrays[0].handle) + "\n"
+	    "texture5: " + name(m_arrays[1].handle) + "\n"
+	    "texture6: " + name(m_arrays[2].handle) + "\n"
+	    "texture7: " + name(entry.table) + "\n"};
+	entry.material = m_materials.create_from_text("internal_src:terrain/chunk_" + suffix, definition);
+	if (entry.material == null_handle || false == m_materials.material(entry.material).is_good)
+	{
+		ErrorLog("heightmap terrain: can't make the material of a chunk");
+		m_state = -1;
+		return static_cast<std::size_t>(-1);
+	}
+	entry.used = true;
+	m_slots.push_back(entry);
+	m_slotof.emplace(entry.material, index);
+	return index;
+}
+
+material_handle opengl33_terrain_materials::make(material_handle const Reuse, std::vector<gfx::terrain_layer> const &Layers, int const Samples, std::uint8_t const *Weights, glm::vec3 const &Placement)
+{
+	if (Layers.empty() || false == init())
+		return null_handle;
+	auto const count{std::min(Layers.size(), max_layers)};
+	std::array<int, max_layers> indices{};
+	for (std::size_t i = 0; i < count; ++i)
+	{
+		if (Layers[i].material == null_handle)
+			return null_handle;
+		indices[i] = layer_index(Layers[i]);
+	}
+	auto const slotindex{acquire_slot(Reuse)};
+	if (slotindex == static_cast<std::size_t>(-1))
+		return null_handle;
+	auto &entry{m_slots[slotindex]};
+
+	// weights, four layers to a texture
+	auto const painted{Weights != nullptr && Samples > 0 && count > 1};
+	auto const side{painted ? Samples + 1 : 1};
+	auto const samples{static_cast<std::size_t>(side) * side};
+	std::vector<std::uint8_t> texels(samples * 4);
+	for (std::size_t texture = 0; texture < 2; ++texture)
+	{
+		std::fill(texels.begin(), texels.end(), 0);
+		for (std::size_t channel = 0; channel < 4; ++channel)
+		{
+			auto const layer{texture * 4 + channel};
+			if (layer >= count)
+				break;
+			if (false == painted)
+			{
+				if (layer == 0)
+					texels[channel] = 255;
+				continue;
+			}
+			auto const *source{Weights + layer * samples};
+			for (std::size_t i = 0; i < samples; ++i)
+				texels[i * 4 + channel] = source[i];
+		}
+		bind_for_upload(m_textures.texture(entry.weights[texture]));
+		::glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
+		::glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, side, side, 0, GL_RGBA, GL_UNSIGNED_BYTE, texels.data());
+		::glGenerateMipmap(GL_TEXTURE_2D);
+	}
+	// what the layers are: index in the arrays, repeat, which maps they have, reflection
+	std::array<float, max_layers * 2 * 4> table{};
+	for (std::size_t i = 0; i < count; ++i)
+	{
+		auto const &layer{m_layers[indices[i]]};
+		table[i * 4 + 0] = static_cast<float>(layer.index);
+		table[i * 4 + 1] = 1.f / std::max(0.01f, layer.repeat);
+		table[i * 4 + 2] = layer.normalmap ? 1.f : 0.f;
+		table[i * 4 + 3] = layer.specgloss ? 1.f : 0.f;
+		table[(max_layers + i) * 4 + 0] = layer.reflection;
+	}
+	bind_for_upload(m_textures.texture(entry.table));
+	::glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA32F, static_cast<GLsizei>(max_layers), 2, 0, GL_RGBA, GL_FLOAT, table.data());
+	opengl_texture::reset_unit_cache();
+
+	auto &material{m_materials.material(entry.material)};
+	material.params[2] = glm::vec4(Placement.x, Placement.y, 1.f / std::max(1.f, Placement.z), static_cast<float>(side - 1));
+	return entry.material;
+}
+
+void opengl33_terrain_materials::release(material_handle const Material)
+{
+	auto const lookup{m_slotof.find(Material)};
+	if (lookup == m_slotof.end() || false == m_slots[lookup->second].used)
+		return;
+	m_slots[lookup->second].used = false;
+	m_free.push_back(lookup->second);
+}
+
+bool opengl33_terrain_materials::copy_layer(layer &Layer)
+{
+	auto const &material{m_materials.material(Layer.material)};
+	auto const slot = [&](char const *Name, int const Fallback) {
+		if (material.shader)
+		{
+			auto const lookup{material.shader->texture_conf.find(Name)};
+			if (lookup != material.shader->texture_conf.end())
+				return static_cast<int>(lookup->second.id);
+			return -1;
+		}
+		return Fallback;
+	};
+	std::array<int, 3> const slots{slot("diffuse", 0), Layer.normalmap ? slot("normalmap", 1) : -1, Layer.specgloss ? slot("specgloss", 2) : -1};
+	// all maps of the layer have to be ready, so they go together
+	std::array<opengl_texture *, 3> sources{};
+	for (std::size_t i = 0; i < slots.size(); ++i)
+	{
+		if (slots[i] < 0 || material.textures[slots[i]] == null_handle)
+			continue;
+		auto &texture{m_textures.mark_as_used(material.textures[slots[i]])};
+		if (false == texture.create())
+		{
+			if (++Layer.attempts < copy_attempts)
+				return false;
+			continue; // waited long enough, the layer goes without it
+		}
+		sources[i] = &texture;
+	}
+	// defaults for maps the layer doesn't have: grey, flat, without specular reflections
+	std::array<std::array<float, 4>, 3> const defaults{{{0.5f, 0.5f, 0.5f, 1.f}, {0.5f, 0.5f, 1.f, 1.f}, {0.f, 1.f, 0.f, 1.f}}};
+	for (std::size_t i = 0; i < m_arrays.size(); ++i)
+	{
+		auto const &array{m_arrays[i]};
+		auto &target{m_textures.texture(array.handle)};
+		m_framebuffer->attach(target, GL_COLOR_ATTACHMENT0, Layer.index);
+		m_framebuffer->setup_drawing(1);
+		::glViewport(0, 0, array.size, array.size);
+		if (sources[i] == nullptr)
+		{
+			::glClearBufferfv(GL_COLOR, 0, defaults[i].data());
+			continue;
+		}
+		if (false == Global.gfx_usegles)
+		{
+			if (array.srgb)
+				::glEnable(GL_FRAMEBUFFER_SRGB);
+			else
+				::glDisable(GL_FRAMEBUFFER_SRGB);
+		}
+		m_copy->apply(*sources[i], m_framebuffer.get());
+	}
+	Layer.copied = true;
+	return true;
+}
+
+void opengl33_terrain_materials::update()
+{
+	if (false == m_pending || m_state <= 0)
+		return;
+
+	auto const blend{::glIsEnabled(GL_BLEND)};
+	auto const scissor{::glIsEnabled(GL_SCISSOR_TEST)};
+	auto const cull{::glIsEnabled(GL_CULL_FACE)};
+	auto const depth{::glIsEnabled(GL_DEPTH_TEST)};
+	auto const srgb{(false == Global.gfx_usegles) && ::glIsEnabled(GL_FRAMEBUFFER_SRGB)};
+	::glDisable(GL_BLEND);
+	::glDisable(GL_SCISSOR_TEST);
+	::glDisable(GL_CULL_FACE);
+
+	bool copied{false};
+	m_pending = false;
+	for (auto &layer : m_layers)
+	{
+		if (layer.copied)
+			continue;
+		if (copy_layer(layer))
+			copied = true;
+		else
+			m_pending = true;
+	}
+	if (copied)
+	{
+		for (auto const &array : m_arrays)
+		{
+			bind_for_upload(m_textures.texture(array.handle));
+			::glGenerateMipmap(GL_TEXTURE_2D_ARRAY);
+		}
+	}
+
+	// leave the state as the rest of the renderer knows it
+	gl::framebuffer::unbind();
+	if (blend)
+		::glEnable(GL_BLEND);
+	if (scissor)
+		::glEnable(GL_SCISSOR_TEST);
+	if (cull)
+		::glEnable(GL_CULL_FACE);
+	if (depth)
+		::glEnable(GL_DEPTH_TEST);
+	else
+		::glDisable(GL_DEPTH_TEST);
+	if (false == Global.gfx_usegles)
+	{
+		if (srgb)
+			::glEnable(GL_FRAMEBUFFER_SRGB);
+		else
+			::glDisable(GL_FRAMEBUFFER_SRGB);
+	}
+	::glDepthMask(GL_TRUE);
+	opengl_texture::reset_unit_cache();
+	gfx::opengl33_vaogeometrybank::reset();
+}

rendering/opengl33terrain.h

@@ -0,0 +1,85 @@
+/*
+This Source Code Form is subject to the
+terms of the Mozilla Public License, v.
+2.0. If a copy of the MPL was not
+distributed with this file, You can
+obtain one at
+http://mozilla.org/MPL/2.0/.
+*/
+
+#pragma once
+
+#include <array>
+#include <memory>
+#include <unordered_map>
+#include <vector>
+
+#include "rendering/renderer.h"
+#include "model/material.h"
+#include "model/Texture.h"
+#include "gl/framebuffer.h"
+#include "gl/postfx.h"
+
+// materials of the heightmap terrain for the opengl 3.3 renderer (shader mat_terrain).
+// the textures of the layer materials are copied into texture arrays shared by all chunks; each chunk gets a material
+// of its own, with textures holding the weights of its layers and a table of what its layers are
+class opengl33_terrain_materials
+{
+  public:
+	opengl33_terrain_materials(material_manager &Materials, texture_manager &Textures) : m_materials(Materials), m_textures(Textures) {}
+
+	// see gfx_renderer::Terrain_Material. returns null_handle if the terrain shader can't be used
+	material_handle make(material_handle const Reuse, std::vector<gfx::terrain_layer> const &Layers, int const Samples, std::uint8_t const *Weights, glm::vec3 const &Placement);
+	void release(material_handle const Material);
+	// copies the textures of new layers into the arrays; to be called before the frame is drawn
+	void update();
+
+  private:
+	struct layer
+	{
+		material_handle material{null_handle};
+		float size{0.f}; // as given by the chunk
+		float repeat{8.f}; // metres the textures are repeated at
+		int index{0}; // in the arrays
+		bool normalmap{false};
+		bool specgloss{false};
+		float reflection{0.f};
+		bool copied{false};
+		int attempts{0};
+	};
+	struct texture_array
+	{
+		texture_handle handle{null_handle};
+		int size{0};
+		GLint format{0};
+		bool srgb{false};
+	};
+	struct slot
+	{
+		material_handle material{null_handle};
+		std::array<texture_handle, 2> weights{null_handle, null_handle};
+		texture_handle table{null_handle};
+		bool used{false};
+	};
+
+	bool init();
+	texture_handle make_texture(std::string const &Name, GLenum const Target);
+	void make_storage(texture_array &Array, int const Layers);
+	int layer_index(gfx::terrain_layer const &Layer);
+	bool copy_layer(layer &Layer);
+	std::size_t acquire_slot(material_handle const Reuse);
+
+	material_manager &m_materials;
+	texture_manager &m_textures;
+	int m_state{0}; // 0: not set up yet, 1: ready, -1: can't be used
+	texture_handle m_white{null_handle};
+	std::array<texture_array, 3> m_arrays; // diffuse, normal maps, specular/gloss
+	int m_capacity{0}; // layers the arrays have room for
+	std::vector<layer> m_layers;
+	bool m_pending{false};
+	std::vector<slot> m_slots;
+	std::vector<std::size_t> m_free;
+	std::unordered_map<material_handle, std::size_t> m_slotof;
+	std::unique_ptr<gl::postfx> m_copy;
+	std::unique_ptr<gl::framebuffer> m_framebuffer;
+};

rendering/renderer.cpp

@@ -39,5 +39,29 @@ gfx_renderer_factory *gfx_renderer_factory::get_instance()
 
 gfx_renderer_factory *gfx_renderer_factory::instance;
 
+material_handle gfx_renderer::Terrain_Material( material_handle const Reuse, std::vector<gfx::terrain_layer> const &Layers, int const Samples, std::uint8_t const *Weights, glm::vec3 const &Placement )
+{
+    // without blending the chunk gets the material which covers the most of it
+    if( Layers.empty() ) {
+        return null_handle;
+    }
+    std::size_t best { 0 };
+    if( ( Weights != nullptr ) && ( Samples > 0 ) ) {
+        auto const samples { static_cast<std::size_t>( Samples + 1 ) * ( Samples + 1 ) };
+        std::uint64_t bestsum { 0 };
+        for( std::size_t layer = 0; layer < Layers.size(); ++layer ) {
+            std::uint64_t sum { 0 };
+            for( std::size_t i = 0; i < samples; ++i ) {
+                sum += Weights[ layer * samples + i ];
+            }
+            if( sum > bestsum ) {
+                bestsum = sum;
+                best = layer;
+            }
+        }
+    }
+    return Layers[ best ].material;
+}
+
 
 //---------------------------------------------------------------------------

rendering/renderer.h

@@ -21,6 +21,16 @@ namespace gl
 class program;
 }
 
+namespace gfx
+{
+// material painted over the heightmap terrain, and the size (metres) its textures are repeated at; 0: the size given by the material, or 8 m
+struct terrain_layer
+{
+	material_handle material{null_handle};
+	float size{0.f};
+};
+} // namespace gfx
+
 class gfx_renderer {
 
 public:
@@ -58,6 +68,14 @@ public:
     virtual auto Fetch_Material( std::string const &Filename, bool const Loadnow = true ) -> material_handle = 0;
     virtual void Bind_Material( material_handle const Material, TSubModel const *sm = nullptr, lighting_data const *lighting = nullptr ) = 0;
     virtual auto Material( material_handle const Material ) const -> IMaterial const * = 0;
+    // heightmap terrain: material of a chunk blending the materials of up to 8 layers by their weights.
+    // Weights: (Samples + 1)^2 values per layer, planar, rows of growing z, the weights of a sample adding up to 255; null with a single layer.
+    // Placement: corner of the chunk (x, z) in the texture coordinates of its mesh, and the size of the chunk.
+    // Reuse: a material made by this call before, to be filled anew, or null_handle.
+    // returns: the material. backends which can't blend give back the material of the layer covering the most
+    virtual auto Terrain_Material( material_handle const Reuse, std::vector<gfx::terrain_layer> const &Layers, int const Samples, std::uint8_t const *Weights, glm::vec3 const &Placement ) -> material_handle;
+    // gives back a material made by Terrain_Material, once its chunk is gone
+    virtual void Terrain_Release( material_handle const Material ) {}
     // shader methods
     virtual auto Fetch_Shader( std::string const &name ) -> std::shared_ptr<gl::program> = 0;
     // texture methods