widelands-dev team mailing list archive

[Klaus Halfmann <klaus.halfmann@xxxxxxxx>]

Some comments inline, now going to compile / run this ...

Diff comments:

> === modified file 'cmake/codecheck/rules/correct_include_order'
> --- cmake/codecheck/rules/correct_include_order	2015-04-04 15:03:14 +0000
> +++ cmake/codecheck/rules/correct_include_order	2017-01-07 12:36:16 +0000
> @@ -45,9 +45,10 @@
>              delims = set(entry[1] for entry in block)
>              if len(delims) != 1:
>                  errors.append((fn, block[0][0], """Use either '"' or '<' for all includes in a block."""))
> -            if sorted(includes) != includes:
> -                errors.append((fn, block[0][0], "Include block is not sorted alphabetically."))
> -                return errors
> +            for include_sorted, include_actual in zip(sorted(includes), includes):
> +                if include_sorted != include_actual:
> +                    errors.append((fn, block[0][0], "Include block is not sorted alphabetically: '%s' must be included before '%s'" % (include_sorted, include_actual)))
> +                    return errors

How can I provoke that message :-)

>  
>          if ".cc" in fn:
>              base_file = os.path.basename(fn)[:-3]
> 
> === added file 'data/shaders/blit_gl4.vp'
> --- data/shaders/blit_gl4.vp	1970-01-01 00:00:00 +0000
> +++ data/shaders/blit_gl4.vp	2017-01-07 12:36:16 +0000
> @@ -0,0 +1,70 @@
> +#version 130
> +#extension GL_ARB_separate_shader_objects : enable
> +#extension GL_ARB_shader_storage_buffer_object : enable
> +#extension GL_ARB_uniform_buffer_object : enable
> +
> +// Varyings.
> +out vec4 out_texture_coordinates;
> +out vec4 out_blend;
> +out float out_program_flavor;
> +
> +struct Rect {
> +	float dst_x, dst_y, dst_width, dst_height;
> +	uint src_x, src_y, src_width, src_height;
> +	uint src_parent_width, src_parent_height;
> +	uint mask_x, mask_y, mask_width, mask_height;
> +	uint mask_parent_width, mask_parent_height;
> +	uint blend_r, blend_g, blend_b, blend_a;
> +	float program_flavor, z;
> +};
> +
> +layout(std140, binding=0) buffer ssbo_rects {
> +	Rect rects[];
> +};
> +
> +void main() {
> +	// Determine rect and vertex relative to rect
> +	uint rect_idx = uint(gl_VertexID) >> 2;
> +	uint vertex_idx = uint(gl_VertexID) & 3u;
> +	Rect r = rects[rect_idx];
> +
> +	out_program_flavor = r.program_flavor;
> +
> +	// Position
> +	gl_Position = vec4(r.dst_x, r.dst_y, r.z, 1.);
> +	if ((vertex_idx & 1u) != 0u)
> +		gl_Position.x += r.dst_width;
> +	if ((vertex_idx & 2u) != 0u)
> +		gl_Position.y += r.dst_height;
> +
> +	// Texture coordinate
> +	uint tx = r.src_x;
> +	uint ty = r.src_y;
> +	if ((vertex_idx & 1u) != 0u)
> +		tx += r.src_width;
> +	if ((vertex_idx & 2u) == 0u)
> +		ty += r.src_height;
> +	out_texture_coordinates.x = tx * (1. / r.src_parent_width);
> +	out_texture_coordinates.y = 1.0 - ty * (1. / r.src_parent_height);
> +
> +	// Blending
> +	out_blend.a = r.blend_a * (1. / 255.);
> +
> +//	if (out_program_flavor >= 1.) {

Please comment why theses ifs are not used ....

> +		out_blend.r = r.blend_r * (1. / 255.);
> +		out_blend.g = r.blend_g * (1. / 255.);
> +		out_blend.b = r.blend_b * (1. / 255.);
> +
> +//		if (out_program_flavor >= 2.) {
> +			// Mask texture coordinate
> +			tx = r.mask_x;
> +			ty = r.mask_y;
> +			if ((vertex_idx & 1u) != 0u)
> +				tx += r.mask_width;
> +			if ((vertex_idx & 2u) == 0u)
> +				ty += r.mask_height;
> +			out_texture_coordinates.z = tx * (1. / r.mask_parent_width);
> +			out_texture_coordinates.w = 1.0 - ty * (1. / r.mask_parent_height);
> +//		}
> +//	}
> +}
> 
> === added file 'src/graphic/gl/terrain_program_gl4.cc'
> --- src/graphic/gl/terrain_program_gl4.cc	1970-01-01 00:00:00 +0000
> +++ src/graphic/gl/terrain_program_gl4.cc	2017-01-07 12:36:16 +0000
> @@ -0,0 +1,1065 @@
> +/*
> + * Copyright (C) 2006-2016 by the Widelands Development Team
> + *
> + * This program is free software; you can redistribute it and/or
> + * modify it under the terms of the GNU General Public License
> + * as published by the Free Software Foundation; either version 2
> + * of the License, or (at your option) any later version.
> + *
> + * This program is distributed in the hope that it will be useful,
> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
> + * GNU General Public License for more details.
> + *
> + * You should have received a copy of the GNU General Public License
> + * along with this program; if not, write to the Free Software
> + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
> + *
> + */
> +
> +#include "graphic/gl/terrain_program_gl4.h"
> +
> +#include "graphic/game_renderer_gl4.h"
> +#include "graphic/gl/coordinate_conversion.h"
> +#include "graphic/gl/utils.h"
> +#include "graphic/image_io.h"
> +#include "io/filesystem/layered_filesystem.h"
> +#include "logic/editor_game_base.h"
> +#include "logic/map.h"
> +#include "logic/map_objects/tribes/tribe_descr.h"
> +#include "logic/map_objects/world/terrain_description.h"
> +#include "logic/map_objects/world/world.h"
> +#include "profile/profile.h"
> +#include "wui/mapviewpixelfunctions.h"
> +
> +using namespace Widelands;
> +
> +/**
> + * This is the back-end of the GL4 rendering path.
> + *
> + * Per-field data is uploaded directly into integer-valued textures that span
> + * the entire map, and vertex shaders do most of the heavy lifting. The
> + * following textures are used:
> + *
> + * Fields texture: data that is usually constant throughout a game, GL_RGBA8UI:
> + *  R = r-triangle texture index
> + *  G = d-triangle texture index
> + *  B = height
> + *  A = brightness
> + * This information can be modified in the editor and in scenarios. Note that
> + * the triangle textures depend on the player perspective.
> + *
> + * Player brightness texture:
> + *  R = player-perspective-dependent brightness modulation
> + * This information is re-uploaded every frame.
> + *
> + * Semi-permanent information (GL_R8UI):
> + *  R = bits 0..5: field ownership (player number)
> + *      bits 6..7: road/flag/building data:
> + *                 0: nothing, 1: road, 2: flag, 3: building
> + * This information is only needed for the minimap, and re-uploaded every frame
> + * when it is shown.
> + *
> + * Terrain is rendered in patches of a fixed structure, and many patches are
> + * rendered in one call via instancing. Per-instance data is processed in a
> + * vertex shader.
> + *
> + * Each patch consists of the triangles associated to a WxH "rectangle" of
> + * fields, where the top-left field must be at an even y-coordinate, and H is
> + * even, e.g. a 2x4-patch:
> + *
> + *       (0,0)
> + *           O-------O-------*
> + *          / \     / \     /
> + *         /   \   /   \   /
> + *        /     \ /     \ /
> + *       *-------O-------O-------*
> + *              / \     / \     /
> + *             /   \   /   \   /
> + *            /     \ /     \ /
> + *           O-------O-------*
> + *          / \     / \     /
> + *         /   \   /   \   /
> + *        /     \ /     \ /
> + *       *-------O-------O-------*
> + *              / \     / \     /
> + *             /   \   /   \   /
> + *            /     \ /     \ /
> + *           *-------*-------*
> + *
> + * OpenGL vertices of triangles are not shared; this allows separate textures
> + * and dithering in a single pass.
> + *
> + * Road rendering is also handled here. Roads are rendered as two triangles per
> + * segment. Only per-road data is uploaded; the vertex shader sources data
> + * from the per-road buffer based on the vertex ID, and an index buffer
> + * (element array buffer in OpenGL terms) is used to share two vertices between
> + * the triangles that make up each segment.
> + */
> +
> +TerrainInformationGl4::GlobalMap TerrainInformationGl4::global_map_;
> +
> +std::shared_ptr<TerrainInformationGl4>
> +TerrainInformationGl4::get(const Widelands::EditorGameBase& egbase,
> +                           const Widelands::Player* player) {
> +	GlobalKey key(&egbase, player);
> +	auto it = global_map_.find(key);
> +	if (it != global_map_.end())
> +		return it->second.lock();
> +
> +	std::shared_ptr<TerrainInformationGl4> instance(
> +		new TerrainInformationGl4(egbase, player));
> +	global_map_[key] = instance;
> +	return instance;
> +}
> +
> +TerrainInformationGl4::TerrainInformationGl4(const Widelands::EditorGameBase& egbase,
> +                                             const Widelands::Player* player)
> +  : egbase_(egbase), player_(player), uploads_(GL_PIXEL_UNPACK_BUFFER) {
> +	glGenTextures(1, &brightness_texture_);
> +	glGenTextures(1, &fields_texture_);
> +	glGenTextures(1, &minimap_texture_);
> +
> +	const Map& map = egbase.map();
> +	auto& gl = Gl::State::instance();
> +	gl.bind(GL_TEXTURE0, fields_texture_);
> +	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
> +	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
> +	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
> +	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
> +
> +	gl.bind(GL_TEXTURE0, brightness_texture_);
> +	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
> +	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
> +	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_R8, map.get_width(), map.get_height(), 0,
> +	             GL_RED, GL_UNSIGNED_BYTE, NULL);
> +	brightness_see_all_ = false;
> +
> +	gl.bind(GL_TEXTURE0, minimap_texture_);
> +	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
> +	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
> +	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_R8UI, map.get_width(), map.get_height(), 0,
> +	             GL_RED_INTEGER, GL_UNSIGNED_BYTE, NULL);
> +
> +	fields_update();
> +	upload_road_textures();
> +	upload_constant_textures();
> +
> +	updated_minimap_ = false;
> +	need_update_minimap_ = false;
> +	minimap_update_next_ = 0;
> +}
> +
> +TerrainInformationGl4::~TerrainInformationGl4() {
> +	if (brightness_texture_)
> +		glDeleteTextures(1, &brightness_texture_);
> +
> +	if (fields_texture_)
> +		glDeleteTextures(1, &fields_texture_);
> +
> +	if (minimap_texture_)
> +		glDeleteTextures(1, &minimap_texture_);
> +
> +	if (terrain_color_texture_)
> +		glDeleteTextures(1, &terrain_color_texture_);
> +
> +	global_map_.erase(GlobalKey(&egbase_, player_));
> +}
> +
> +/// Add @p rect to @p rects, merging it with any overlapping or touching
> +/// pre-existing rects (where merging means that the rectangles are replaced by
> +/// a single rectangle that contains their union). The order of rectangles in
> +/// @p rects is not preserved.
> +///
> +/// Rectangles are interpreted as half-open.
> +static void add_rect(std::vector<Recti>& rects, const Recti& rect) {
> +	Recti new_rect = rect;
> +
> +	for (size_t i = 0; i < rects.size(); ++i) {
> +		// Merge rectangles even if they only touch instead of fully overlapping.
> +		// The rationale is that reducing the number of uploads is often a
> +		// benefit even when the total size of uploads becomes larger.
> +		if (new_rect.x + new_rect.w < rects[i].x ||
> +		    rects[i].x + rects[i].w < new_rect.x ||
> +		    new_rect.y + new_rect.h < rects[i].y ||
> +		    rects[i].y + rects[i].h < new_rect.y)
> +			continue;
> +
> +		rects[i] = rects.back();
> +		rects.pop_back();
> +		i--;
> +	}
> +
> +	rects.push_back(new_rect);
> +}
> +
> +void TerrainInformationGl4::update(int minfx, int maxfx, int minfy, int maxfy) {
> +	const Map& map = egbase().map();
> +	int width = map.get_width();
> +	int height = map.get_height();
> +
> +	auto normalize = [](int& min, int& max, int size) {
> +		while (min < 0) {
> +			min += size;
> +			max += size;
> +		}
> +		while (min >= size) {
> +			min -= size;
> +			max -= size;
> +		}
> +	};
> +
> +	normalize(minfx, maxfx, width);
> +	normalize(minfy, maxfy, height);
> +
> +	// Ensure proper row alignment during texture uploads.
> +	minfx = (minfx / 4) * 4;
> +	maxfx = ((maxfx + 4) / 4) * 4 - 1;
> +
> +	auto add = [&](int startx, int endx) {
> +		add_rect(update_, Recti(startx, minfy, endx - startx, std::min(maxfy + 1, height) - minfy));
> +		if (maxfy >= height)
> +			add_rect(update_, Recti(startx, 0, endx - startx, std::min(maxfy + 1 - height, height)));
> +	};
> +
> +	add(minfx, std::min(maxfx + 1, width));
> +	if (maxfx >= width)
> +		add(0, std::min(maxfx + 1 - width, width));
> +}
> +
> +void TerrainInformationGl4::update_minimap() {
> +	need_update_minimap_ = true;
> +}
> +
> +void TerrainInformationGl4::do_prepare_frame() {

This function is quite long can you break it into smaller pieces?
thos commetns should be actually function names (I got lost after the first 3d od that code)

> +	const Map& map = egbase().map();
> +
> +	upload_terrain_data();
> +
> +	if (need_update_minimap_) {
> +		if (!updated_minimap_) {
> +			// Need a full update when the minimap is drawn for the first
> +			// time.
> +			update_.clear();
> +			update_.emplace_back(0, 0, map.get_width(), map.get_height());
> +		} else {
> +			// For the minimap, we want to do rolling texture updates of
> +			// stripes that cover the whole width or height of the map,
> +			// depending on which is smaller. For consistency and simplicity,
> +			// expand all other dirty rectangles to full strips as well.
> +			//
> +			// Furthermore, use stripes of a size that is a multiple of a small
> +			// power of two, since that likely has bandwidth benefits due to
> +			// how textures are laid out in memory. This also avoids confusion
> +			// due to pixel (un)packing row alignments.
> +			unsigned width = map.get_width();
> +			unsigned height = map.get_height();
> +			bool horiz = width <= height;
> +			std::vector<std::pair<unsigned, unsigned>> stripes;
> +
> +			// Massage existing stripes, effectively a form of insertion sort.
> +			stripes.reserve(update_.size() + 1);
> +			for (size_t i = 0; i < update_.size(); ++i) {
> +				unsigned min = horiz ? update_[i].y : update_[i].x;
> +				unsigned max = min + (horiz ? update_[i].h : update_[i].w);
> +
> +				min = (min / 8) * 8;
> +				max = ((max + 7) / 8) * 8;
> +
> +				size_t j;
> +				for (j = 0; j < stripes.size(); ++j) {
> +					if (max < stripes[j].first) {
> +						stripes.insert(stripes.begin() + j, std::make_pair(min, max));
> +						break;
> +					}
> +
> +					if (min <= stripes[j].second) {
> +						stripes[j].first = std::min(stripes[j].first, min);
> +						stripes[j].second = std::max(stripes[j].second, max);
> +
> +						size_t k;
> +						for (k = j + 1; k < stripes.size(); ++k) {
> +							if (stripes[j].second < stripes[k].first)
> +								break;
> +
> +							stripes[j].second = std::max(stripes[j].second, stripes[k].second);
> +						}
> +
> +						stripes.erase(stripes.begin() + j + 1, stripes.begin() + k);
> +						break;
> +					}
> +				}
> +				if (j >= stripes.size())
> +					stripes.emplace_back(min, max);
> +			}
> +
> +			if (stripes.empty() || stripes[0].first != 0 ||
> +			    stripes[0].second < (horiz ? height : width)) {
> +				// Add a stripe (or expand an existing one) for the rolling minimap
> +				// update.
> +				if (minimap_update_next_ >= (horiz ? height : width))
> +					minimap_update_next_ = 0;
> +
> +				unsigned min = minimap_update_next_;
> +				size_t j;
> +				for (j = 0; j < stripes.size(); ++j) {
> +					unsigned max = min + 8;
> +					if (max < stripes[j].first) {
> +						stripes.insert(stripes.begin() + j, std::make_pair(min, max));
> +						break;
> +					}
> +
> +					if (min <= stripes[j].second) {
> +						if (min < stripes[j].first) {
> +							assert(max == stripes[j].first); // due to multiples of 8
> +							stripes[j].first = min;
> +							break;
> +						}
> +
> +						min = minimap_update_next_ = stripes[j].second;
> +						if (min >= (horiz ? height : width)) {
> +							min = 0;
> +							j = 0;
> +							continue;
> +						}
> +						max = std::min(min + 8, horiz ? height : width);
> +						stripes[j].second = max;
> +
> +						size_t k;
> +						for (k = j + 1; k < stripes.size(); ++k) {
> +							if (stripes[j].second < stripes[k].first)
> +								break;
> +
> +							stripes[j].second = std::max(stripes[j].second, stripes[k].second);
> +						}
> +						stripes.erase(stripes.begin() + j + 1, stripes.begin() + k);
> +						break;
> +					}
> +				}
> +				if (j >= stripes.size())
> +					stripes.emplace_back(min, min + 8);
> +
> +				minimap_update_next_ += 8;
> +			}
> +
> +			// Convert stripes back to update rectangles.
> +			update_.resize(stripes.size());
> +			for (size_t i = 0; i < stripes.size(); ++i) {
> +				if (horiz) {
> +					update_[i].x = 0;
> +					update_[i].w = width;
> +					update_[i].y = stripes[i].first;
> +					update_[i].h = stripes[i].second - stripes[i].first;
> +				} else {
> +					update_[i].y = 0;
> +					update_[i].h = height;
> +					update_[i].x = stripes[i].first;
> +					update_[i].w = stripes[i].second - stripes[i].first;
> +				}
> +			}
> +		}
> +	}
> +
> +	// Fields data updates are guarded by version numbers instead of
> +	// rectangles.
> +	if (fields_base_version_ != map.get_fields_base_version() ||
> +	    (player() && terrain_vision_version_ != player()->get_terrain_vision_version()))
> +		fields_update();
> +
> +	brightness_update();
> +
> +	if (need_update_minimap_)
> +		do_update_minimap();
> +
> +	update_.clear();
> +	updated_minimap_ = need_update_minimap_;
> +	need_update_minimap_ = false;
> +}
> +
> +void TerrainInformationGl4::prepare_frame() {
> +	for (auto& entries : global_map_) {
> +		std::shared_ptr<TerrainInformationGl4> ti = entries.second.lock();
> +
> +		ti->do_prepare_frame();
> +	}
> +}
> +
> +void TerrainInformationGl4::do_update_minimap() {
> +	// Re-upload minimap data.
> +	auto& gl = Gl::State::instance();
> +	const Map& map = egbase().map();
> +	unsigned width = map.get_width();
> +	std::vector<uint8_t> data;
> +	const bool see_all = !player() || player()->see_all();
> +
> +	auto detail_bits = [&](const Widelands::BaseImmovable* imm) -> uint8_t {
> +		if (imm) {
> +			Widelands::MapObjectType type = imm->descr().type();
> +			if (type == Widelands::MapObjectType::ROAD)
> +				return 1u << 6;
> +			if (type == Widelands::MapObjectType::FLAG)
> +				return 2u << 6;
> +			if (type >= Widelands::MapObjectType::BUILDING)
> +				return 3u << 6;
> +		}
> +		return 0;
> +	};
> +
> +	gl.bind(GL_TEXTURE0, minimap_texture_);
> +
> +	for (const Recti& rect : update_) {
> +		data.resize(rect.w * rect.h);
> +		if (see_all) {
> +			unsigned i = 0;
> +			for (unsigned y = 0; y < unsigned(rect.h); ++y) {
> +				unsigned idx = (rect.y + y) * width + rect.x;
> +				for (unsigned x = 0; x < unsigned(rect.w); ++x, ++i, ++idx) {
> +					const Field& f = map[idx];
> +					data[i] = f.get_owned_by();
> +					data[i] |= detail_bits(f.get_immovable());
> +				}
> +			}
> +		} else {
> +			unsigned i = 0;
> +			for (unsigned y = 0; y < unsigned(rect.h); ++y) {
> +				unsigned idx = (rect.y + y) * width + rect.x;
> +				for (unsigned x = 0; x < unsigned(rect.w); ++x, ++i, ++idx) {
> +					const Player::Field& pf = player()->fields()[idx];
> +					data[i] = pf.owner;
> +
> +					if (pf.vision >= 2) {
> +						const Field& f = map[idx];
> +						data[i] |= detail_bits(f.get_immovable());
> +					}
> +				}
> +			}
> +		}
> +
> +		glTexSubImage2D(GL_TEXTURE_2D, 0, rect.x, rect.y, rect.w, rect.h,
> +		                GL_RED_INTEGER, GL_UNSIGNED_BYTE, data.data());
> +	}
> +}
> +
> +void TerrainInformationGl4::fields_update() {
> +	auto& gl = Gl::State::instance();
> +	const Map& map = egbase().map();
> +	auto stream = uploads_.stream(sizeof(PerFieldData) * uint(map.get_width()) * map.get_height());
> +	PerFieldData* fd =
> +		reinterpret_cast<PerFieldData*>
> +			(stream.add(sizeof(PerFieldData) * uint(map.get_width()) * map.get_height()));
> +	MapIndex max_index = map.max_index();
> +	const bool see_all = !player() || player()->see_all();
> +
> +	if (see_all) {
> +		for (MapIndex i = 0; i < max_index; ++i) {
> +			const Field& f = map[i];
> +			fd[i].terrain_r = f.terrain_r();
> +			fd[i].terrain_d = f.terrain_d();
> +			fd[i].height = f.get_height();
> +			fd[i].brightness = f.get_brightness();
> +		}
> +	} else {
> +		const Player::Field* player_fields = player()->fields();
> +
> +		for (MapIndex i = 0; i < max_index; ++i) {
> +			const Field& f = map[i];
> +			const Player::Field& pf = player_fields[i];
> +			fd[i].terrain_r = pf.terrains.r;
> +			fd[i].terrain_d = pf.terrains.d;
> +			fd[i].height = f.get_height();
> +			fd[i].brightness = f.get_brightness();
> +		}
> +	}
> +
> +	GLintptr offset = stream.unmap();
> +	uploads_.bind();
> +
> +	gl.bind(GL_TEXTURE0, fields_texture_);
> +	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8UI, map.get_width(), map.get_height(), 0,
> +				 GL_RGBA_INTEGER, GL_UNSIGNED_BYTE, reinterpret_cast<void*>(offset));
> +
> +	glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0);
> +
> +	fields_base_version_ = map.get_fields_base_version();
> +	if (player())
> +		terrain_vision_version_ = player()->get_terrain_vision_version();
> +}
> +
> +TerrainInformationGl4::PerRoadTextureData::PerRoadTextureData(const Rectf& rect)
> +  : x(rect.x), y(rect.y), w(rect.w), h(rect.h) {
> +}
> +
> +void TerrainInformationGl4::upload_road_textures() {
> +	std::vector<PerRoadTextureData> roads;
> +	std::map<const TribeDescr*, unsigned> tribe_map;
> +	PlayerNumber const nr_players = egbase().map().get_nrplayers();
> +
> +	player_roads_.resize(nr_players + 1);
> +
> +	iterate_players_existing_const(p, nr_players, egbase(), player) {
> +		const TribeDescr& tribe = player->tribe();
> +		auto it = tribe_map.find(&tribe);
> +		if (it != tribe_map.end()) {
> +			player_roads_[p] = player_roads_[it->second];
> +		} else {
> +			const auto& normal_textures = tribe.road_textures().get_normal_textures();
> +			player_roads_[p].normal_roads = roads.size();
> +			player_roads_[p].num_normal_roads = normal_textures.size();
> +			for (const Image* image : normal_textures) {
> +				const BlitData& blit_data = image->blit_data();
> +				roads.emplace_back(to_gl_texture(blit_data));
> +				road_texture_object_ = blit_data.texture_id;
> +			}
> +
> +			const auto& busy_textures = tribe.road_textures().get_busy_textures();
> +			player_roads_[p].busy_roads = roads.size();
> +			player_roads_[p].num_busy_roads = busy_textures.size();
> +			for (const Image* image : busy_textures)
> +				roads.emplace_back(to_gl_texture(image->blit_data()));
> +
> +			tribe_map[&tribe] = p;
> +		}
> +	}
> +
> +	road_textures_.bind();
> +	road_textures_.update(roads);
> +}
> +
> +unsigned TerrainInformationGl4::road_texture_idx(PlayerNumber owner,
> +                                                 RoadType road_type,
> +                                                 const Coords& coords,
> +                                                 WalkingDir direction) const {
> +	const PlayerRoads& roads = player_roads_[owner];
> +	unsigned base, count;
> +
> +	if (road_type == RoadType::kNormal) {
> +		base = roads.normal_roads;
> +		count = roads.num_normal_roads;
> +	} else {
> +		base = roads.busy_roads;
> +		count = roads.num_busy_roads;
> +	}
> +
> +	return base + unsigned(coords.x + coords.y + direction) % count;
> +}
> +
> +// Upload the per-terrain texture data. This is done on every draw call because
> +// it depends on the gametime.
> +void TerrainInformationGl4::upload_terrain_data() {
> +	uint32_t gametime = egbase().get_gametime();
> +	const auto& terrains = egbase().world().terrains();
> +	std::vector<PerTerrainData> data;
> +
> +	data.resize(terrains.size());
> +
> +	for (unsigned i = 0; i < terrains.size(); ++i) {
> +		PerTerrainData& terrain = data[i];
> +		const TerrainDescription& descr = terrains.get(i);
> +		terrain.offset =
> +			to_gl_texture(descr.get_texture(gametime).blit_data()).origin();
> +		terrain.dither_layer = descr.dither_layer();
> +	}
> +
> +	terrain_data_.bind();
> +	terrain_data_.update(data);
> +}
> +
> +void TerrainInformationGl4::brightness_update() {
> +	auto& gl = Gl::State::instance();
> +	bool see_all = !player_ || player_->see_all();
> +
> +	gl.bind(GL_TEXTURE0, brightness_texture_);
> +
> +	if (see_all) {
> +		if (!brightness_see_all_) {
> +			// Pixel unpacking has a per-row alignment of 4 bytes. Usually this
> +			// is not a problem for us, because maps' widths are always multiples
> +			// of 4, but in this particular case, OpenGL implementations disagree
> +			// about whether the alignment should be considered for the bounds
> +			// check in glTexImage2D. If we only allocate 1 byte, some
> +			// implementations flag a GL_INVALID_OPERATION.
> +			static const uint8_t data[4] = {255, 255, 255, 255};
> +
> +			glTexImage2D(GL_TEXTURE_2D, 0, GL_R8, 1, 1, 0, GL_RED, GL_UNSIGNED_BYTE,
> +			             data);
> +			brightness_see_all_ = true;
> +		}
> +	} else {
> +		const Map& map = egbase().map();
> +		int width = map.get_width();
> +		int height = map.get_height();
> +		uint32_t gametime = egbase().get_gametime();
> +		std::vector<uint8_t> data;
> +
> +		if (brightness_see_all_) {
> +			// Resize the texture when switching between see-all and not-see-all.
> +			glTexImage2D(GL_TEXTURE_2D, 0, GL_R8, width, height, 0, GL_RED,
> +			             GL_UNSIGNED_BYTE, NULL);
> +			brightness_see_all_ = false;
> +		}
> +
> +		for (const Recti& rect : update_) {
> +			data.resize(rect.w * rect.h);
> +
> +			unsigned dst = 0;
> +			for (unsigned y = 0; y < unsigned(rect.h); ++y) {
> +				unsigned src = (rect.y + y) * width + rect.x;
> +				for (unsigned x = 0; x < unsigned(rect.w); ++x, ++src, ++dst) {
> +					const Player::Field& pf = player_->fields()[src];
> +					if (pf.vision == 0) {
> +						data[dst] = 0;
> +					} else if (pf.vision == 1) {
> +						static const uint32_t kDecayTimeInMs = 20000;
> +						const Duration time_ago = gametime - pf.time_node_last_unseen;
> +						if (time_ago < kDecayTimeInMs) {
> +							data[dst] = 255 * (2 * kDecayTimeInMs - time_ago) / (2 * kDecayTimeInMs);
> +						} else {
> +							data[dst] = 128;
> +						}
> +					} else {
> +						data[dst] = 255;
> +					}
> +				}
> +			}
> +
> +			glTexSubImage2D(GL_TEXTURE_2D, 0, rect.x, rect.y, rect.w, rect.h,
> +			                GL_RED, GL_UNSIGNED_BYTE, &data[0]);
> +		}
> +	}
> +}
> +
> +void TerrainInformationGl4::upload_constant_textures() {
> +	auto& gl = Gl::State::instance();
> +	const auto& terrains = egbase().world().terrains();
> +	std::vector<RGBColor> colors;
> +
> +	for (Widelands::DescriptionIndex i = 0; i < terrains.size(); ++i)
> +		colors.push_back(terrains.get(i).get_minimap_color(0));
> +
> +	glGenTextures(1, &terrain_color_texture_);
> +
> +	gl.bind(GL_TEXTURE0, terrain_color_texture_);
> +	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, colors.size(), 1, 0, GL_RGB, GL_UNSIGNED_BYTE,
> +	             colors.data());
> +	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_MIN_FILTER, GL_NEAREST);
> +	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
> +
> +	colors.resize(kMaxPlayers);
> +	for (int i = 1; i <= kMaxPlayers; ++i) {
> +		const Widelands::Player* player = egbase().get_player(i);
> +		if (player)
> +			colors[i - 1] = player->get_playercolor();
> +	}
> +
> +	glGenTextures(1, &player_color_texture_);
> +
> +	gl.bind(GL_TEXTURE0, player_color_texture_);
> +	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, colors.size(), 1, 0, GL_RGB, GL_UNSIGNED_BYTE,
> +	             colors.data());
> +	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_MIN_FILTER, GL_NEAREST);
> +	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
> +}
> +
> +TerrainProgramGl4::Terrain::Terrain()
> +  : instance_data(GL_ARRAY_BUFFER) {
> +	// Initialize program.
> +	gl_program.build_vp_fp({"terrain_gl4", "terrain_common_gl4"}, {"terrain_gl4"});
> +
> +	in_vertex_coordinate = glGetAttribLocation(gl_program.object(), "in_vertex_coordinate");
> +	in_patch_coordinate = glGetAttribLocation(gl_program.object(), "in_patch_coordinate");
> +
> +	u_position_scale = glGetUniformLocation(gl_program.object(), "u_position_scale");
> +	u_position_offset = glGetUniformLocation(gl_program.object(), "u_position_offset");
> +	u_z_value = glGetUniformLocation(gl_program.object(), "u_z_value");
> +	u_texture_dimensions = glGetUniformLocation(gl_program.object(), "u_texture_dimensions");
> +
> +	u_terrain_base = glGetUniformLocation(gl_program.object(), "u_terrain_base");
> +	u_player_brightness = glGetUniformLocation(gl_program.object(), "u_player_brightness");
> +	u_terrain_texture = glGetUniformLocation(gl_program.object(), "u_terrain_texture");
> +	u_dither_texture = glGetUniformLocation(gl_program.object(), "u_dither_texture");
> +
> +	block_terrains_idx = glGetUniformBlockIndex(gl_program.object(), "block_terrains");
> +}
> +
> +TerrainProgramGl4::Terrain::~Terrain() {
> +}
> +
> +TerrainProgramGl4::Roads::Roads()
> +  : road_data(GL_SHADER_STORAGE_BUFFER) {
> +	num_index_roads = 0;
> +
> +	// Initialize program.
> +	gl_program.build_vp_fp({"road_gl4", "terrain_common_gl4"}, {"road"});
> +
> +	u_position_scale = glGetUniformLocation(gl_program.object(), "u_position_scale");
> +	u_position_offset = glGetUniformLocation(gl_program.object(), "u_position_offset");
> +	u_z_value = glGetUniformLocation(gl_program.object(), "u_z_value");
> +
> +	u_terrain_base = glGetUniformLocation(gl_program.object(), "u_terrain_base");
> +	u_player_brightness = glGetUniformLocation(gl_program.object(), "u_player_brightness");
> +	u_texture = glGetUniformLocation(gl_program.object(), "u_texture");
> +
> +	block_textures_idx = glGetUniformBlockIndex(gl_program.object(), "block_textures");
> +}
> +
> +TerrainProgramGl4::Roads::~Roads() {
> +}
> +
> +TerrainProgramGl4::MiniMap::MiniMap()
> +  : vertex_data(GL_ARRAY_BUFFER) {
> +	gl_program.build_vp_fp({"minimap_gl4"}, {"minimap_gl4"});
> +
> +	in_position = glGetAttribLocation(gl_program.object(), "in_position");
> +	in_field = glGetAttribLocation(gl_program.object(), "in_field");
> +
> +	u_layer_terrain = glGetUniformLocation(gl_program.object(), "u_layer_terrain");
> +	u_layer_owner = glGetUniformLocation(gl_program.object(), "u_layer_owner");
> +	u_layer_details = glGetUniformLocation(gl_program.object(), "u_layer_details");
> +
> +	u_frame_topleft = glGetUniformLocation(gl_program.object(), "u_frame_topleft");
> +	u_frame_bottomright = glGetUniformLocation(gl_program.object(), "u_frame_bottomright");
> +
> +	u_terrain_base = glGetUniformLocation(gl_program.object(), "u_terrain_base");
> +	u_player_brightness = glGetUniformLocation(gl_program.object(), "u_player_brightness");
> +	u_minimap_extra = glGetUniformLocation(gl_program.object(), "u_minimap_extra");
> +	u_terrain_color = glGetUniformLocation(gl_program.object(), "u_terrain_color");
> +	u_player_color = glGetUniformLocation(gl_program.object(), "u_player_color");
> +}
> +
> +TerrainProgramGl4::MiniMap::~MiniMap() {
> +}
> +
> +TerrainProgramGl4::TerrainProgramGl4() {
> +	log("Using GL4 terrain rendering path\n");
> +
> +	// Initialize vertex buffer (every instance/path has the same structure).
> +	init_vertex_data();
> +
> +	// Load mask texture for dithering.
> +	terrain_.dither_mask.reset(new Texture(load_image_as_sdl_surface("world/pics/edge.png", g_fs), true));
> +
> +	Gl::State::instance().bind(GL_TEXTURE0, terrain_.dither_mask->blit_data().texture_id);
> +	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, static_cast<GLint>(GL_CLAMP_TO_EDGE));
> +	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, static_cast<GLint>(GL_CLAMP_TO_EDGE));
> +	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, static_cast<GLint>(GL_LINEAR));
> +	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, static_cast<GLint>(GL_LINEAR));
> +}
> +
> +TerrainProgramGl4::~TerrainProgramGl4() {
> +}
> +
> +bool TerrainProgramGl4::supported() {
> +	const auto& caps = Gl::State::instance().capabilities();
> +
> +	if (caps.glsl_version < 130)
> +		return false;
> +
> +	if (!caps.ARB_separate_shader_objects ||
> +	    !caps.ARB_shader_storage_buffer_object ||
> +	    !caps.ARB_uniform_buffer_object)
> +		return false;
> +
> +	return !g_options.pull_section("global").get_bool("disable_gl4", false);
> +}
> +
> +void TerrainProgramGl4::draw(const TerrainGl4Arguments* args,
> +                             float z_value) {
> +	auto& gl = Gl::State::instance();
> +
> +	// First, draw the terrain.
> +	glUseProgram(terrain_.gl_program.object());
> +
> +	// Coordinate transform from map coordinates to GL coordinates.
> +	float scale_x = 2.0 / args->surface_width * args->scale;
> +	float scale_y = -2.0 / args->surface_height * args->scale;
> +	float offset_x = args->surface_offset.x * scale_x - 1.0;
> +	float offset_y = args->surface_offset.y * scale_y + 1.0;
> +
> +	// Texture size
> +	const BlitData& blit_data = args->terrain->egbase().world().terrains().get(0).get_texture(0).blit_data();
> +	const Rectf texture_coordinates = to_gl_texture(blit_data);
> +
> +	// Prepare uniforms.
> +	glBindBufferBase(GL_UNIFORM_BUFFER, terrain_.block_terrains_idx,
> +	                 args->terrain->terrain_data_buffer_object());
> +
> +	glUniform2f(terrain_.u_position_scale, scale_x, scale_y);
> +	glUniform2f(terrain_.u_position_offset, offset_x, offset_y);
> +	glUniform1f(terrain_.u_z_value, z_value);
> +	glUniform2f(terrain_.u_texture_dimensions, texture_coordinates.w, texture_coordinates.h);
> +
> +	// Prepare textures & sampler uniforms.
> +	glUniform1i(terrain_.u_terrain_base, 0);
> +	gl.bind(GL_TEXTURE0, args->terrain->fields_texture());
> +
> +	glUniform1i(terrain_.u_player_brightness, 1);
> +	gl.bind(GL_TEXTURE1, args->terrain->player_brightness_texture());
> +
> +	glUniform1i(terrain_.u_terrain_texture, 2);
> +	gl.bind(GL_TEXTURE2, blit_data.texture_id);
> +
> +	glUniform1i(terrain_.u_dither_texture, 3);
> +	gl.bind(GL_TEXTURE3, terrain_.dither_mask->blit_data().texture_id);
> +
> +	// Setup vertex and instance attribute data.
> +	gl.enable_vertex_attrib_array(
> +	   {terrain_.in_vertex_coordinate, terrain_.in_patch_coordinate});
> +
> +	unsigned num_instances = upload_instance_data(args);
> +
> +	terrain_.vertex_data.bind();
> +	glVertexAttribIPointer(terrain_.in_vertex_coordinate, 4, GL_INT, sizeof(PerVertexData), nullptr);
> +
> +	glDrawArraysInstanced(GL_TRIANGLES, 0, 6 * kPatchWidth * kPatchHeight, num_instances);
> +
> +	glVertexBindingDivisor(terrain_.in_patch_coordinate, 0);
> +}
> +
> +void TerrainProgramGl4::draw_minimap(const TerrainGl4Arguments* args,
> +                                     float z_value) {
> +	auto& gl = Gl::State::instance();
> +	const Widelands::Map& map = args->terrain->egbase().map();
> +	float width = map.get_width();
> +	float height = map.get_height();
> +
> +	glUseProgram(minimap_.gl_program.object());
> +
> +	// Prepare minimap setting uniforms
> +	glUniform1i(minimap_.u_layer_terrain, (args->minimap_layers & MiniMapLayer::Terrain) ? 1 : 0);
> +	glUniform1i(minimap_.u_layer_owner, (args->minimap_layers & MiniMapLayer::Owner) ? 1 : 0);
> +
> +	uint details = 0;
> +	if (args->minimap_layers & MiniMapLayer::Road)
> +		details |= 1;
> +	if (args->minimap_layers & MiniMapLayer::Flag)
> +		details |= 2;
> +	if (args->minimap_layers & MiniMapLayer::Building)
> +		details |= 4;
> +
> +	glUniform1ui(minimap_.u_layer_details, details);
> +
> +	// Prepare textures & sampler uniforms.
> +	glUniform1i(minimap_.u_terrain_base, 0);
> +	gl.bind(GL_TEXTURE0, args->terrain->fields_texture());
> +
> +	glUniform1i(minimap_.u_player_brightness, 1);
> +	gl.bind(GL_TEXTURE1, args->terrain->player_brightness_texture());
> +
> +	glUniform1i(minimap_.u_minimap_extra, 2);
> +	gl.bind(GL_TEXTURE2, args->terrain->minimap_texture());
> +
> +	glUniform1i(minimap_.u_terrain_color, 3);
> +	gl.bind(GL_TEXTURE3, args->terrain->terrain_color_texture());
> +
> +	glUniform1i(minimap_.u_player_color, 4);
> +	gl.bind(GL_TEXTURE4, args->terrain->player_color_texture());
> +
> +	glUniform2f(minimap_.u_frame_topleft, (args->minfx + 0.001) / width, (args->minfy + 0.001) / height);
> +	glUniform2f(minimap_.u_frame_bottomright, (args->maxfx - 0.001) / width, (args->maxfy - 0.001) / height);
> +
> +	// Compute coordinates and upload vertex data.
> +	if (args->minimap_layers & MiniMapLayer::Zoom2) {
> +		width *= 2;
> +		height *= 2;
> +	}
> +
> +	float left = args->surface_offset.x;
> +	float right = left + width;
> +	float top = args->surface_offset.y;
> +	float bottom = top + height;
> +
> +	pixel_to_gl_renderbuffer(args->surface_width, args->surface_height, &left, &top);
> +	pixel_to_gl_renderbuffer(args->surface_width, args->surface_height, &right, &bottom);
> +
> +	float tx = args->minimap_tl_fx * (1.0 / map.get_width());
> +	float ty = args->minimap_tl_fy * (1.0 / map.get_height());
> +
> +	auto stream = minimap_.vertex_data.stream(4);
> +	MiniMap::VertexData* v = stream.add(4);
> +
> +	v[0].x = left;

Could this be done via some object/struct assigend like v[0] = {left, top, ,,, } ?

> +	v[0].y = top;
> +	v[0].z = z_value;
> +	v[0].tx = tx;
> +	v[0].ty = ty;
> +
> +	v[1].x = left;
> +	v[1].y = bottom;
> +	v[1].z = z_value;
> +	v[1].tx = tx;
> +	v[1].ty = ty + 1.0;
> +
> +	v[2].x = right;
> +	v[2].y = top;
> +	v[2].z = z_value;
> +	v[2].tx = tx + 1.0;
> +	v[2].ty = ty;
> +
> +	v[3].x = right;
> +	v[3].y = bottom;
> +	v[3].z = z_value;
> +	v[3].tx = tx + 1.0;
> +	v[3].ty = ty + 1.0;
> +
> +	GLintptr offset = stream.unmap();
> +
> +	gl.enable_vertex_attrib_array({minimap_.in_position, minimap_.in_field});
> +
> +	minimap_.vertex_data.bind();
> +	Gl::vertex_attrib_pointer(minimap_.in_position, 3, sizeof(MiniMap::VertexData), offset);
> +	Gl::vertex_attrib_pointer(minimap_.in_field, 2, sizeof(MiniMap::VertexData),
> +	                          offset + offsetof(MiniMap::VertexData, tx));
> +
> +	glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
> +}
> +
> +void TerrainProgramGl4::draw_roads(const TerrainGl4Arguments* args,
> +                                   float z_value) {
> +	auto& gl = Gl::State::instance();
> +
> +	// Coordinate transform from map coordinates to GL coordinates.
> +	float scale_x = 2.0 / args->surface_width * args->scale;
> +	float scale_y = -2.0 / args->surface_height * args->scale;
> +	float offset_x = args->surface_offset.x * scale_x - 1.0;
> +	float offset_y = args->surface_offset.y * scale_y + 1.0;
> +
> +	glUseProgram(roads_.gl_program.object());
> +
> +	setup_road_index_buffer(args->roads.size());
> +
> +	// Prepare uniforms.
> +	glUniform2f(roads_.u_position_scale, scale_x, scale_y);
> +	glUniform2f(roads_.u_position_offset, offset_x, offset_y);
> +	glUniform1f(roads_.u_z_value, z_value);
> +
> +	// Prepare textures & sampler uniforms.
> +	glUniform1i(roads_.u_terrain_base, 0);
> +	gl.bind(GL_TEXTURE0, args->terrain->fields_texture());
> +
> +	glUniform1i(roads_.u_player_brightness, 1);
> +	gl.bind(GL_TEXTURE1, args->terrain->player_brightness_texture());
> +
> +	glUniform1i(roads_.u_texture, 2);
> +	gl.bind(GL_TEXTURE2, args->terrain->road_texture_object());
> +
> +	glBindBufferBase(GL_UNIFORM_BUFFER, roads_.block_textures_idx,
> +	                 args->terrain->road_textures_buffer_object());
> +
> +	upload_road_data(args);
> +
> +	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, roads_.gl_index_buffer.object());
> +	glDrawElements(GL_TRIANGLES, 6 * args->roads.size(), GL_UNSIGNED_SHORT, nullptr);
> +	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
> +}
> +
> +void TerrainProgramGl4::init_vertex_data() {
> +	std::vector<PerVertexData> vertices;
> +
> +	for (int y = 0; y < int(kPatchHeight); ++y) {
> +		for (int x = 0; x < int(kPatchWidth); ++x) {
> +			int blx = (y & 1) ? x : (x - 1);
> +
> +			// Down triangle.
> +			vertices.emplace_back(x,       y,     x, y, false, 2);
> +			vertices.emplace_back(blx,     y + 1, x, y, false, 0);
> +			vertices.emplace_back(blx + 1, y + 1, x, y, false, 1);
> +
> +			// Right triangle.
> +			vertices.emplace_back(x,       y,     x, y, true, 1);
> +			vertices.emplace_back(blx + 1, y + 1, x, y, true, 2);
> +			vertices.emplace_back(x + 1,   y,     x, y, true, 0);
> +		}
> +	}
> +
> +	assert(vertices.size() == 6 * kPatchWidth * kPatchHeight);
> +
> +	terrain_.vertex_data.bind();
> +	terrain_.vertex_data.update(vertices);
> +}
> +
> +// Determine which instances/patches to draw, upload the data and set up the
> +// vertex attributes.
> +unsigned TerrainProgramGl4::upload_instance_data(const TerrainGl4Arguments* args) {
> +	int minfx = args->minfx;
> +	int minfy = args->minfy;
> +	int maxfx = args->maxfx;
> +	int maxfy = args->maxfy;
> +	if (minfy & 1)
> +		minfy--;
> +
> +	int ph = (maxfy - minfy + kPatchHeight) / kPatchHeight;
> +	int pw = (maxfx - minfx + kPatchWidth) / kPatchWidth;
> +	int num_patches = pw * ph;
> +
> +	auto stream = terrain_.instance_data.stream(num_patches);
> +	for (int py = 0; py < ph; ++py) {
> +		for (int px = 0; px < pw; ++px) {
> +			const int fx = minfx + px * kPatchWidth;
> +			const int fy = minfy + py * kPatchHeight;
> +
> +			stream.emplace_back();
> +			PerInstanceData& i = stream.back();
> +			i.coordinate.x = fx;
> +			i.coordinate.y = fy;
> +		}
> +	}
> +
> +	GLintptr offset = stream.unmap();
> +
> +	glVertexAttribIPointer(terrain_.in_patch_coordinate, 2, GL_INT, sizeof(PerInstanceData),
> +	                       reinterpret_cast<void*>(offset + offsetof(PerInstanceData, coordinate)));
> +
> +	glVertexBindingDivisor(terrain_.in_patch_coordinate, 1);
> +
> +	return num_patches;
> +}
> +
> +void TerrainProgramGl4::setup_road_index_buffer(unsigned num_roads) {
> +	if (num_roads <= roads_.num_index_roads)
> +		return;
> +
> +	if (num_roads > 65536 / 4)
> +		throw wexception("Too many roads for 16-bit indices");
> +
> +	std::vector<uint16_t> indices;
> +	indices.reserve(num_roads * 6);
> +
> +	for (unsigned i = 0; i < num_roads; ++i) {
> +		indices.push_back(4 * i);
> +		indices.push_back(4 * i + 1);
> +		indices.push_back(4 * i + 2);
> +
> +		indices.push_back(4 * i + 2);
> +		indices.push_back(4 * i + 1);
> +		indices.push_back(4 * i + 3);
> +	}
> +
> +	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, roads_.gl_index_buffer.object());
> +	glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(uint16_t) * indices.size(),
> +	             indices.data(), GL_STATIC_DRAW);
> +	roads_.num_index_roads = num_roads;
> +}
> +
> +void TerrainProgramGl4::upload_road_data(const TerrainGl4Arguments* args) {
> +	assert(!args->roads.empty());
> +
> +	auto stream = roads_.road_data.stream(args->roads.size());
> +
> +	for (const TerrainGl4Arguments::Road& road : args->roads) {
> +		stream.emplace_back(
> +			Vector2i(road.coord.x, road.coord.y), road.direction,
> +			args->terrain->road_texture_idx(
> +				road.owner, RoadType(road.type), road.coord, WalkingDir(road.direction)));
> +	}
> +
> +	glBindBufferRange(GL_SHADER_STORAGE_BUFFER, 0, roads_.road_data.object(),
> +	                  stream.unmap(), args->roads.size() * sizeof(PerRoadData));
> +}
> 
> === modified file 'src/graphic/gl/utils.cc'
> --- src/graphic/gl/utils.cc	2016-09-06 07:59:30 +0000
> +++ src/graphic/gl/utils.cc	2017-01-07 12:36:16 +0000
> @@ -169,8 +183,49 @@
>  	}
>  }
>  
> +void Program::build(const std::string& program_name) {
> +	build_vp_fp({program_name}, {program_name});
> +}
> +
> +void Capabilities::check() {
> +	// Reset all variables
> +	*this = {};
> +
> +	const char* glsl_version_string = reinterpret_cast<const char*>(glGetString(GL_SHADING_LANGUAGE_VERSION));
> +	int major = 0, minor = 0;
> +
> +	if (sscanf(glsl_version_string, "%d.%d", &major, &minor) != 2)
> +		log("Warning: Malformed GLSL version string: %s\n", glsl_version_string);
> +
> +	glsl_version = major * 100 + minor;
> +
> +	GLint num_extensions;
> +	glGetIntegerv(GL_NUM_EXTENSIONS, &num_extensions);
> +
> +	for (GLint i = 0; i < num_extensions; ++i) {
> +		const char* extension = reinterpret_cast<const char*>(glGetStringi(GL_EXTENSIONS, i));
> +
> +#define EXTENSION(basename) \

can this not be done without such an ugly macro?

> +		do { \
> +			if (!strcmp(extension, "GL_" #basename)) \
> +				basename = true; \
> +		} while (false)
> +
> +		EXTENSION(ARB_separate_shader_objects);
> +		EXTENSION(ARB_shader_storage_buffer_object);
> +		EXTENSION(ARB_uniform_buffer_object);
> +
> +#undef EXTENSION
> +	}
> +}
> +
>  State::State()
> -   : last_active_texture_(NONE), current_framebuffer_(0), current_framebuffer_texture_(0) {
> +   : target_to_texture_(kMaxTextureTargets), last_active_texture_(NONE),
> +     current_framebuffer_(0), current_framebuffer_texture_(0) {
> +}
> +
> +void State::check_capabilities() {
> +	caps_.check();
>  }
>  
>  void State::bind(const GLenum target, const GLuint texture) {


-- 
https://code.launchpad.net/~nha/widelands/graphics/+merge/314279
Your team Widelands Developers is requested to review the proposed merge of lp:~nha/widelands/graphics into lp:widelands.