An another stab at getting y sort to work with walls.

meshers/isometric/terrain_2d_mesher_isometric.cpp

@@ -33,10 +33,7 @@ void Terrain2DMesherIsometric::_add_chunk(Ref<Terrain2DChunk> p_chunk) {
 	ERR_FAIL_COND(chunk->get_margin_end() < 1);
 	ERR_FAIL_COND(chunk->get_margin_start() < 1);
 
-	mesh_wall_back(chunk);
+	mesh_walls(chunk);
-	store_mesh();
-	mesh_wall_front2(chunk);
-	store_mesh();
 	mesh_base(chunk);
 }
 
@@ -349,6 +346,8 @@ void Terrain2DMesherIsometric::mesh_base(Ref<Terrain2DChunkDefault> chunk) {
 	//	if (!chunk->get_channel(Terrain2DChunkDefault::DEFAULT_CHANNEL_AO))
 	//		chunk->generate_ao();
 
+	_mesh_transform = Transform2D();
+
 	uint8_t *channel_type = chunk->channel_get(_channel_index_type);
 
 	if (!channel_type)
@@ -631,7 +630,7 @@ void Terrain2DMesherIsometric::mesh_base(Ref<Terrain2DChunkDefault> chunk) {
 	}
 }
 
-void Terrain2DMesherIsometric::mesh_wall_back(Ref<Terrain2DChunkDefault> chunk) {
+void Terrain2DMesherIsometric::mesh_walls(Ref<Terrain2DChunkDefault> chunk) {
 	//if ((get_build_flags() & Terrain2DChunkDefault::BUILD_FLAG_GENERATE_AO) != 0)
 	//	if (!chunk->get_channel(Terrain2DChunkDefault::DEFAULT_CHANNEL_AO))
 	//		chunk->generate_ao();
@@ -786,8 +785,10 @@ void Terrain2DMesherIsometric::mesh_wall_back(Ref<Terrain2DChunkDefault> chunk)
 				continue;
 			}
 
+			_mesh_transform = Transform2D(0, Vector2(x * cell_size_x, y * cell_size_y));
+
 			if ((flags & Terrain2DChunkDefault::FLAG_CHANNEL_WALL_NORTH) != 0) {
-				Vector2 vert_start_offset = mesh_transform_terrain.xform(Vector2(x * cell_size_x, y * cell_size_y));
+				Vector2 vert_start_offset = mesh_transform_terrain.xform(Vector2(cell_size_x, cell_size_y));
 
 				for (int i = 0; i < 4; ++i) {
 					if (use_lighting) {
@@ -811,7 +812,7 @@ void Terrain2DMesherIsometric::mesh_wall_back(Ref<Terrain2DChunkDefault> chunk)
 			}
 
 			if ((flags & Terrain2DChunkDefault::FLAG_CHANNEL_WALL_WEST) != 0) {
-				Vector2 vert_start_offset = mesh_transform_terrain.xform(Vector2(x * cell_size_x, (y + 1) * cell_size_y));
+				Vector2 vert_start_offset = mesh_transform_terrain.xform(Vector2(cell_size_x, cell_size_y + cell_size_y));
 
 				for (int i = 0; i < 4; ++i) {
 					if (use_lighting) {
@@ -834,9 +835,9 @@ void Terrain2DMesherIsometric::mesh_wall_back(Ref<Terrain2DChunkDefault> chunk)
 
 				vc += 4;
 			}
-/*
+
 			if ((flags & Terrain2DChunkDefault::FLAG_CHANNEL_WALL_SOUTH) != 0) {
-				Vector2 vert_start_offset = mesh_transform_terrain.xform(Vector2(x * cell_size_x, (y + 1) * cell_size_y));
+				Vector2 vert_start_offset = mesh_transform_terrain.xform(Vector2(cell_size_x, cell_size_y + cell_size_y));
 
 				for (int i = 0; i < 4; ++i) {
 					if (use_lighting) {
@@ -860,7 +861,7 @@ void Terrain2DMesherIsometric::mesh_wall_back(Ref<Terrain2DChunkDefault> chunk)
 			}
 
 			if ((flags & Terrain2DChunkDefault::FLAG_CHANNEL_WALL_EAST) != 0) {
-				Vector2 vert_start_offset = mesh_transform_terrain.xform(Vector2((x + 1) * cell_size_x, (y + 1) * cell_size_y));
+				Vector2 vert_start_offset = mesh_transform_terrain.xform(Vector2(cell_size_x + cell_size_x, cell_size_y + cell_size_y));
 
 				for (int i = 0; i < 4; ++i) {
 					if (use_lighting) {
@@ -882,272 +883,15 @@ void Terrain2DMesherIsometric::mesh_wall_back(Ref<Terrain2DChunkDefault> chunk)
 
 				vc += 4;
 			}
-			*/
+			
 		}
 	}
 
 	if ((chunk->get_build_flags() & Terrain2DChunkDefault::BUILD_FLAG_USE_LIGHTING) != 0) {
 		bake_colors(chunk);
 	}
-}
 
-void Terrain2DMesherIsometric::mesh_wall_front(Ref<Terrain2DChunkDefault> chunk) {
+	store_mesh();
-	//if ((get_build_flags() & Terrain2DChunkDefault::BUILD_FLAG_GENERATE_AO) != 0)
-	//	if (!chunk->get_channel(Terrain2DChunkDefault::DEFAULT_CHANNEL_AO))
-	//		chunk->generate_ao();
-
-	uint8_t *channel_type = chunk->channel_get(_channel_index_type);
-
-	if (!channel_type)
-		return;
-
-	uint8_t *channel_flags = chunk->channel_get(Terrain2DChunkDefault::DEFAULT_CHANNEL_FLAGS);
-
-	if (!channel_flags)
-		return;
-
-	int x_size = chunk->get_size_x();
-	int y_size = chunk->get_size_y();
-	int cell_size_x = get_cell_size_x();
-	int cell_size_y = get_cell_size_y();
-
-	Transform2D mesh_transform_terrain = chunk->mesh_transform_terrain_get();
-	Transform2D mesh_transform_wall_north = chunk->mesh_transform_wall_north_get();
-	Transform2D mesh_transform_wall_south = chunk->mesh_transform_wall_south_get();
-	Transform2D mesh_transform_wall_east = chunk->mesh_transform_wall_east_get();
-	Transform2D mesh_transform_wall_west = chunk->mesh_transform_wall_west_get();
-
-	uint8_t *channel_color_r = NULL;
-	uint8_t *channel_color_g = NULL;
-	uint8_t *channel_color_b = NULL;
-	uint8_t *channel_ao = NULL;
-	uint8_t *channel_rao = NULL;
-
-	Color base_light(_base_light_value, _base_light_value, _base_light_value);
-	Color light[4]{ Color(1, 1, 1), Color(1, 1, 1), Color(1, 1, 1), Color(1, 1, 1) };
-
-	bool use_lighting = (get_build_flags() & Terrain2DChunkDefault::BUILD_FLAG_USE_LIGHTING) != 0;
-	bool use_ao = (get_build_flags() & Terrain2DChunkDefault::BUILD_FLAG_USE_AO) != 0;
-	bool use_rao = (get_build_flags() & Terrain2DChunkDefault::BUILD_FLAG_USE_RAO) != 0;
-
-	if (use_lighting) {
-		channel_color_r = chunk->channel_get_valid(Terrain2DChunkDefault::DEFAULT_CHANNEL_LIGHT_COLOR_R);
-		channel_color_g = chunk->channel_get_valid(Terrain2DChunkDefault::DEFAULT_CHANNEL_LIGHT_COLOR_G);
-		channel_color_b = chunk->channel_get_valid(Terrain2DChunkDefault::DEFAULT_CHANNEL_LIGHT_COLOR_B);
-
-		if (use_ao)
-			channel_ao = chunk->channel_get_valid(Terrain2DChunkDefault::DEFAULT_CHANNEL_AO);
-
-		if (use_rao)
-			channel_rao = chunk->channel_get_valid(Terrain2DChunkDefault::DEFAULT_CHANNEL_RANDOM_AO);
-	}
-
-	Ref<Terrain2DMaterialCache> mcache;
-
-	if (chunk->material_cache_key_has()) {
-		mcache = _library->material_cache_get(chunk->material_cache_key_get());
-	}
-
-	int texture_scale = get_texture_scale();
-
-	int margin_start = chunk->get_margin_start();
-	//z_size + margin_start is fine, x, and z are in data space.
-	for (int y = margin_start; y < y_size + margin_start; ++y) {
-		for (int x = margin_start; x < x_size + margin_start; ++x) {
-			int indexes[4] = {
-				chunk->get_data_index(x, y),
-				chunk->get_data_index(x + 1, y),
-				chunk->get_data_index(x, y + 1),
-				chunk->get_data_index(x + 1, y + 1)
-			};
-
-			uint8_t type = channel_type[indexes[0]];
-
-			if (type == 0)
-				continue;
-
-			Ref<Terrain2DSurface> surface;
-
-			if (!mcache.is_valid()) {
-				surface = _library->terra_surface_get(type - 1);
-			} else {
-				surface = mcache->surface_id_get(type - 1);
-			}
-
-			if (!surface.is_valid())
-				continue;
-
-			int flags = channel_flags[indexes[0]];
-
-			if (use_lighting) {
-				for (int i = 0; i < 4; ++i) {
-					int indx = indexes[i];
-
-					light[i] = Color(channel_color_r[indx] / 255.0,
-							channel_color_g[indx] / 255.0,
-							channel_color_b[indx] / 255.0);
-
-					float ao = 0;
-
-					if (use_ao)
-						ao = channel_ao[indx] / 255.0;
-
-					if (use_rao) {
-						float rao = channel_rao[indx] / 255.0;
-						ao += rao;
-					}
-
-					light[i] += base_light;
-
-					if (ao > 0)
-						light[i] -= Color(ao, ao, ao) * _ao_strength;
-
-					light[i].r = CLAMP(light[i].r, 0, 1.0);
-					light[i].g = CLAMP(light[i].g, 0, 1.0);
-					light[i].b = CLAMP(light[i].b, 0, 1.0);
-				}
-			}
-
-			Vector2 uvs[] = {
-				Vector2(0, 0),
-				Vector2(1, 0),
-				Vector2(0, 1),
-				Vector2(1, 1)
-			};
-
-			if (texture_scale > 1) {
-				for (int i = 0; i < 4; ++i) {
-					uvs[i] = surface->transform_uv_scaled(uvs[i], x % texture_scale, y % texture_scale, texture_scale);
-				}
-			} else {
-				for (int i = 0; i < 4; ++i) {
-					uvs[i] = surface->transform_uv(uvs[i]);
-				}
-			}
-
-			Vector2 verts_normal[] = {
-				Vector2(0, 0),
-				Vector2(cell_size_x, 0),
-				Vector2(0, cell_size_y),
-				Vector2(cell_size_x, cell_size_y)
-			};
-
-			// Note that +y is down!
-			Vector2 verts_wall[] = {
-				Vector2(0, -cell_size_y),
-				Vector2(cell_size_x, -cell_size_y),
-				Vector2(0, 0),
-				Vector2(cell_size_x, 0)
-			};
-
-			int vc = get_vertex_count();
-
-			if ((flags & Terrain2DChunkDefault::FLAG_CHANNEL_WALL_HOLE) != 0) {
-				continue;
-			}
-/*
-			if ((flags & Terrain2DChunkDefault::FLAG_CHANNEL_WALL_NORTH) != 0) {
-				Vector2 vert_start_offset = mesh_transform_terrain.xform(Vector2(x * cell_size_x, y * cell_size_y));
-
-				for (int i = 0; i < 4; ++i) {
-					if (use_lighting) {
-						add_color(light[i]);
-					} else {
-						add_color(Color(1, 1, 1, 1));
-					}
-
-					add_uv(uvs[i]);
-					add_vertex(mesh_transform_wall_north.xform(verts_wall[i]) + vert_start_offset);
-				}
-
-				add_indices(vc + 0);
-				add_indices(vc + 1);
-				add_indices(vc + 2);
-				add_indices(vc + 1);
-				add_indices(vc + 2);
-				add_indices(vc + 3);
-
-				vc += 4;
-			}
-
-			if ((flags & Terrain2DChunkDefault::FLAG_CHANNEL_WALL_WEST) != 0) {
-				Vector2 vert_start_offset = mesh_transform_terrain.xform(Vector2(x * cell_size_x, (y + 1) * cell_size_y));
-
-				for (int i = 0; i < 4; ++i) {
-					if (use_lighting) {
-						add_color(light[i]);
-					} else {
-						add_color(Color(1, 1, 1, 1));
-					}
-
-					add_uv(uvs[i]);
-
-					add_vertex(mesh_transform_wall_west.xform(verts_wall[i]) + vert_start_offset);
-				}
-
-				add_indices(vc + 0);
-				add_indices(vc + 1);
-				add_indices(vc + 2);
-				add_indices(vc + 1);
-				add_indices(vc + 2);
-				add_indices(vc + 3);
-
-				vc += 4;
-			}
-*/
-			if ((flags & Terrain2DChunkDefault::FLAG_CHANNEL_WALL_SOUTH) != 0) {
-				Vector2 vert_start_offset = mesh_transform_terrain.xform(Vector2(x * cell_size_x, (y + 1) * cell_size_y));
-
-				for (int i = 0; i < 4; ++i) {
-					if (use_lighting) {
-						add_color(light[i]);
-					} else {
-						add_color(Color(1, 1, 1, 1));
-					}
-
-					add_uv(uvs[i]);
-					add_vertex(mesh_transform_wall_south.xform(verts_wall[i]) + vert_start_offset);
-				}
-
-				add_indices(vc + 0);
-				add_indices(vc + 1);
-				add_indices(vc + 2);
-				add_indices(vc + 1);
-				add_indices(vc + 2);
-				add_indices(vc + 3);
-
-				vc += 4;
-			}
-
-			if ((flags & Terrain2DChunkDefault::FLAG_CHANNEL_WALL_EAST) != 0) {
-				Vector2 vert_start_offset = mesh_transform_terrain.xform(Vector2((x + 1) * cell_size_x, (y + 1) * cell_size_y));
-
-				for (int i = 0; i < 4; ++i) {
-					if (use_lighting) {
-						add_color(light[i]);
-					} else {
-						add_color(Color(1, 1, 1, 1));
-					}
-
-					add_uv(uvs[i]);
-					add_vertex(mesh_transform_wall_east.xform(verts_wall[i]) + vert_start_offset);
-				}
-
-				add_indices(vc + 0);
-				add_indices(vc + 1);
-				add_indices(vc + 2);
-				add_indices(vc + 1);
-				add_indices(vc + 2);
-				add_indices(vc + 3);
-
-				vc += 4;
-			}
-		}
-	}
-
-	if ((chunk->get_build_flags() & Terrain2DChunkDefault::BUILD_FLAG_USE_LIGHTING) != 0) {
-		bake_colors(chunk);
-	}
 }
 
 Terrain2DMesherIsometric::Terrain2DMesherIsometric() {

meshers/isometric/terrain_2d_mesher_isometric.h

@@ -45,8 +45,7 @@ public:
 
 	void add_chunk_normal(Ref<Terrain2DChunkDefault> chunk);
 	void mesh_base(Ref<Terrain2DChunkDefault> chunk);
-	void mesh_wall_back(Ref<Terrain2DChunkDefault> chunk);
+	void mesh_walls(Ref<Terrain2DChunkDefault> chunk);
-	void mesh_wall_front(Ref<Terrain2DChunkDefault> chunk);
 
 	Terrain2DMesherIsometric();
 	~Terrain2DMesherIsometric();

meshers/terrain_2d_mesher.cpp

@@ -85,6 +85,13 @@ void Terrain2DMesher::set_texture_scale(const int value) {
 	_texture_scale = value;
 }
 
+Transform2D Terrain2DMesher::get_mesh_transform() {
+	return _mesh_transform;
+}
+void Terrain2DMesher::set_mesh_transform(const Transform2D &value) {
+	_mesh_transform = value;
+}
+
 Ref<Terrain2DLibrary> Terrain2DMesher::get_library() {
 	return _library;
 }
@@ -345,12 +352,12 @@ void Terrain2DMesher::remove_doubles_hashed() {
 	//print_error("after " + String::num(_vertices.size()) + " " + String::num(duration.count()));
 }
 
-
 void Terrain2DMesher::store_mesh() {
 	Terrain2DMesherStoredMesh m;
 
 	m.vertices = _vertices;
 	m.indices = _indices;
+	m.transform = _mesh_transform;
 
 	_vertices.resize(0);
 	_indices.resize(0);
@@ -463,6 +470,13 @@ Array Terrain2DMesher::build_stored_mesh(const int index) {
 
 	return a;
 }
+
+Transform2D Terrain2DMesher::get_stored_mesh_transform(const int index) {
+	ERR_FAIL_INDEX_V(index, _stored_meshes.size(), Transform2D());
+
+	return _stored_meshes[index].transform;
+}
+
 void Terrain2DMesher::build_stored_mesh_into(const int index, RID mesh) {
 	ERR_FAIL_COND(mesh == RID());
 
@@ -478,7 +492,6 @@ void Terrain2DMesher::build_stored_mesh_into(const int index, RID mesh) {
 	VS::get_singleton()->mesh_add_surface_from_arrays(mesh, VisualServer::PRIMITIVE_TRIANGLES, arr);
 }
 
-
 void Terrain2DMesher::reset() {
 	_vertices.resize(0);
 	_indices.resize(0);
@@ -908,6 +921,10 @@ void Terrain2DMesher::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("set_texture_scale", "value"), &Terrain2DMesher::set_texture_scale);
 	ADD_PROPERTY(PropertyInfo(Variant::INT, "texture_scale"), "set_texture_scale", "get_texture_scale");
 
+	ClassDB::bind_method(D_METHOD("get_mesh_transform"), &Terrain2DMesher::get_mesh_transform);
+	ClassDB::bind_method(D_METHOD("set_mesh_transform", "value"), &Terrain2DMesher::set_mesh_transform);
+	ADD_PROPERTY(PropertyInfo(Variant::TRANSFORM2D, "mesh_transform"), "set_mesh_transform", "get_mesh_transform");
+
 	ClassDB::bind_method(D_METHOD("get_library"), &Terrain2DMesher::get_library);
 	ClassDB::bind_method(D_METHOD("set_library", "value"), &Terrain2DMesher::set_library);
 	ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "library", PROPERTY_HINT_RESOURCE_TYPE, "Terrain2DLibrary"), "set_library", "get_library");
@@ -993,5 +1010,6 @@ void Terrain2DMesher::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("store_mesh"), &Terrain2DMesher::store_mesh);
 	ClassDB::bind_method(D_METHOD("get_stored_mesh_count"), &Terrain2DMesher::get_stored_mesh_count);
 	ClassDB::bind_method(D_METHOD("build_stored_mesh", "index"), &Terrain2DMesher::build_stored_mesh);
+	ClassDB::bind_method(D_METHOD("get_stored_mesh_transform", "index"), &Terrain2DMesher::get_stored_mesh_transform);
 	ClassDB::bind_method(D_METHOD("build_stored_mesh_into", "index", "mesh"), &Terrain2DMesher::build_stored_mesh_into);
 }

meshers/terrain_2d_mesher.h

@@ -102,6 +102,9 @@ public:
 	int get_texture_scale() const;
 	void set_texture_scale(const int value);
 
+	Transform2D get_mesh_transform();
+	void set_mesh_transform(const Transform2D &value);
+
 	Ref<Terrain2DLibrary> get_library();
 	void set_library(const Ref<Terrain2DLibrary> &library);
 
@@ -152,6 +155,7 @@ public:
 	void store_mesh();
 	int get_stored_mesh_count() const;
 	Array build_stored_mesh(const int index);
+	Transform2D get_stored_mesh_transform(const int index);
 	void build_stored_mesh_into(const int index, RID mesh);
 
 	PoolVector<Vector2> get_vertices() const;
@@ -197,6 +201,8 @@ protected:
 
 	int _texture_scale;
 
+	Transform2D _mesh_transform;
+
 	PoolVector<Vertex> _vertices;
 	PoolVector<int> _indices;
 
@@ -218,6 +224,7 @@ protected:
 	struct Terrain2DMesherStoredMesh {
 		PoolVector<Vertex> vertices;
 		PoolVector<int> indices;
+		Transform2D transform;
 	};
 
 	Vector<Terrain2DMesherStoredMesh> _stored_meshes;

world/default/terrain_2d_chunk_default.cpp

@@ -694,8 +694,12 @@ void Terrain2DChunkDefault::_draw() {
 		if (terrain_mesh_rid != RID()) {
 			RID terrain_texture_rid = mesh_rid_get(MESH_INDEX_TERRAIN, MESH_TYPE_INDEX_TEXTURE_RID);
 
+			//VisualServer::get_singleton()->canvas_item_add_set_transform(get_canvas_item(), _mesh_transforms[i]);
+
 			//Note: the transform parameter is not implemented in gles2
-			VisualServer::get_singleton()->canvas_item_add_mesh(get_canvas_item(), terrain_mesh_rid, Transform2D(), Color(1, 1, 1, 1), terrain_texture_rid, RID());
+			VisualServer::get_singleton()->canvas_item_add_mesh(get_canvas_item(), terrain_mesh_rid, _mesh_transforms[i], Color(1, 1, 1, 1), terrain_texture_rid, RID());
+
+			//VisualServer::get_singleton()->canvas_item_set_transform(get_canvas_item(), Transform2D());
 		}
 	}
 

world/default/terrain_2d_chunk_default.h

@@ -199,6 +199,9 @@ public:
 	Terrain2DChunkDefault();
 	~Terrain2DChunkDefault();
 
+	//Todo make this a generic thing
+	Vector<Transform2D> _mesh_transforms;
+
 protected:
 	virtual void _channel_setup();
 

world/jobs/terrain_2d_terrain_job.cpp

@@ -265,9 +265,12 @@ void Terrain2DTerrain2DJob::phase_terrain_mesh() {
 			//allocate
 			chunk->meshes_create(Terrain2DChunkDefault::MESH_INDEX_TERRAIN, 1 + _mesher->get_stored_mesh_count());
 
+			chunk->_mesh_transforms.resize(1 + _mesher->get_stored_mesh_count());
+
 		} else {
 			//we have the meshes, just clear
 			int count = chunk->mesh_rid_get_count(Terrain2DChunkDefault::MESH_INDEX_TERRAIN, Terrain2DChunkDefault::MESH_TYPE_INDEX_MESH);
+			chunk->_mesh_transforms.resize(count);
 
 			for (int i = 0; i < count; ++i) {
 				mesh_rid = chunk->mesh_rid_get_index(Terrain2DChunkDefault::MESH_INDEX_TERRAIN, Terrain2DChunkDefault::MESH_TYPE_INDEX_MESH, i);
@@ -278,6 +281,8 @@ void Terrain2DTerrain2DJob::phase_terrain_mesh() {
 #else
 					VS::get_singleton()->mesh_clear(mesh_rid);
 #endif
+
+				chunk->_mesh_transforms.write[i] = Transform2D();
 			}
 		}
 	}
@@ -404,6 +409,8 @@ void Terrain2DTerrain2DJob::step_type_normal() {
 		Array arr = _mesher->build_stored_mesh(i);
 		mesh_rid = chunk->mesh_rid_get_index(Terrain2DChunkDefault::MESH_INDEX_TERRAIN, Terrain2DChunkDefault::MESH_TYPE_INDEX_MESH, i + 1);
 		VS::get_singleton()->mesh_add_surface_from_arrays(mesh_rid, VisualServer::PRIMITIVE_TRIANGLES, arr);
+
+		chunk->_mesh_transforms.write[i + 1] = _mesher->get_stored_mesh_transform(i);
 	}
 }