Membrane stretch by Patryk26g · Pull Request #7084 · Revolutionary-Games/Thrive

Patryk26g · 2026-06-28T18:02:32Z

Brief Description of What This PR Does

Extends membrane in multicellular colonies to other cell neighbours.

Membrane is generated in 2 passes - first normally like for single cell expect without applying membrane waviness. Then in the second pass, which is currently performed on a single thread, gets cells neighbours.,calculates the position of middle point between these cell, creates tangent lines to the cell coming from that point and casts vertices onto these lines checking if the are not accidentally inside other neighbours' membrane. After that a smoothing is applied.

Note: membrane stretching in a colony is sequential for each cell, not asynchronous. It's because it needs other cells' membranes (both original and stretched) to avoid overlaps. Also during calculations both current and neighbours membranes are modified to avoid cases where one cell's vertices are modified and second's not because of overlaps. The code makes sure that either both stretch or none do.

Unfortunately there are list allocations for rotated and shifted neighbours vertices. Maybe I should use array pool there?

Related Issues

Progress Checklist

Note: before starting this checklist the PR should be marked as non-draft.

PR author has checked that this PR works as intended and doesn't
break existing features:
https://wiki.revolutionarygamesstudio.com/wiki/Testing_Checklist
(this is important as to not waste the time of Thrive team
members reviewing this PR). This includes gameplay testing by the PR author.
Initial code review passed (this and further items should not be checked by the PR author)
Functionality is confirmed working by another person (see above checklist link)
Final code review is passed and code conforms to the
styleguide.

Before merging all CI jobs should finish on this PR without errors, if
there are automatically detected style issues they should be fixed by
the PR author. Merging must follow our
styleguide.

Smoothing

revolutionary-bot · 2026-06-28T18:02:35Z

The lead programmer for Thrive is currently on vacation until 2026-07-13. Until then other programmers will try to make pull request reviews, but please be patient if your PR is not getting reviewed.

PRs may be merged after multiple programmers have approved the changes (especially making sure to ensure style guide conformance and gameplay testing are good). If there are no active experienced programmers who can perform merges, PRs may need to wait until the lead programmer is back to be merged.

…with other neighbours

hhyyrylainen · 2026-07-15T11:58:51Z

Is this still experimental or, should this be marked as a draft or is this ready for review?

hhyyrylainen · 2026-07-15T12:09:17Z

 {
    public Vector2[] HexPositions { get; }
    public int HexPositionCount { get; }
+    public Vector2[]? MulticellularPositions { get; }


Adding all of this extra data makes this a ton heavier, enough so that I fear for the efficiency of the overall design being able to handle things...

What exactly do you mean by "being able to handle things"? I unfortunatelly need all of this data to make good membrane stretch generation. What would you propose here instead?

The way I made the hashing and finding stuff is that I bedgrudginly accepted that the game has to hash the full list of positions, and that works fine now. But this PR increases the amount of hashing effort 5x, and makes membranes unique based on colony position, meaning that the overall caching system for membranes might not even make sense. So by adding a lot of heavy weight to the membrane caching system might hinder it so much that the entire concept needs to be rethought.

I suggested a few things to try to make it lighter (by using a single list, and only verifying some properties), but there might be a fundamental limit that causes problems with doing so much new stuff in the membrane caching and generation.

Patryk26g · 2026-07-15T12:13:00Z

Is this still experimental or, should this be marked as a draft or is this ready for review?

its ready for review

hhyyrylainen · 2026-07-16T12:16:04Z

+                continue;
+
+            var cell = multicellular.Species.ModifiableGameplayCells[i];
+            var cellPosistion = Hex.AxialToCartesian(cell.Position);


Suggested change

var cellPosistion = Hex.AxialToCartesian(cell.Position);

var cellPosition = Hex.AxialToCartesian(cell.Position);

Typo

hhyyrylainen · 2026-07-16T12:17:10Z

+        var positionsArray = cellsPositions.ToArray();
+        var rotationsArray = cellsOrientations.ToArray();


For memory efficiency, these should absolutely be avoided.

If temporary memory is needed I think these should use array buffer renting.

Or having read the generation request data, I think we should have just a single array with structs in it and those structs then would hold all data related to the other cells rather than spreading it across like 5 or so arrays as they are currently.

I guess that also applies to the dictionaries with lists as values, right?

I dont quite understand what you mean by array with structs in it - why structs would be better in this case then classes? they would constantly be copied across all the method calls, wouldn't they?

Anyway, I will try to improve it, either using the arrayPool or somehow implementing the struct concept

I guess that also applies to the dictionaries with lists as values, right?

Yes.

I dont quite understand what you mean by array with structs in it - why structs would be better in this case then classes? they would constantly be copied across all the method calls, wouldn't they?

In C# structs are value types, which means that ArrayStruct[] and List<ArrayStruct> both allocate only one continuous segment of memory. Whereas a list of class objects first allocates the list memory and then each class separately this causes memory fragmentation and major slowdown as the CPU prefetch doesn't work. So a list of classes is a memory performance nightmare in comparison to an array. Even better would be being able to rent arrays from the global array buffer and only needing to not return the array when actually generating a new membrane, this would take most of the load off from using a cached copy of data.

Anyway, I will try to improve it, either using the arrayPool or somehow implementing the struct concept

Yes, I think this would be a very key optimization.

I thought about using stackalloc originally but I couldn't figure out a way to use it because when you fill it and hash it, and find out that the membrane is not cached, then you need to make a second array you can actually give to the membrane generation object. So if our cache hit rate is low the extra copy from the stackalloc array to the array that can be given to the membrane object to hold, will be a major performance drain (and stackalloc wouldn't help), but I haven't extensively tested so I'm not actually sure if this problem is real.

hhyyrylainen · 2026-07-16T12:18:37Z


        var sourcePoints = dataSource.HexPositions;

+        if (dataSource.MulticellularPositions != null || multicellularPositions != null)


This looks quite bad in terms of new performance drain, so I would only keep the most important comparison and put all else behind a #if DEBUG condition check to still help catch bugs but not eat up runtime performance for players.

makes sense

Patryk26g added 7 commits June 20, 2026 22:20

Experimental multicellular membrane stretch (unstable)

8cdeb63

Working cell rotation

a0c5c5c

Improved middle point calculation and inside point check

2936878

Fix array pool bugs causing hash collisions

6e9edc5

cell growth changes membrane

40a3837

Shape smoothing and Cleaning-up

4d00df7

Smoothing

Second clean-up

583071b

github-project-automation Bot added this to Thrive Planning Jun 28, 2026

github-project-automation Bot moved this to In progress in Thrive Planning Jun 28, 2026

Patryk26g added 8 commits July 1, 2026 21:05

Code clean-up

fa6767b

Clean-up check

25057c1

Import fix

2974e2f

Improvements

a01ba9f

Fixes

04e62bd

Fix CalculateIterationIndices

1f40548

Process current cell and neighbour at the same time. Remove overlaps …

53d9466

…with other neighbours

Documentation

6aa589e

Patryk26g marked this pull request as ready for review July 6, 2026 17:43

Improvements

0cfb7ae

hhyyrylainen reviewed Jul 15, 2026

View reviewed changes

Patryk26g changed the title ~~Experimental membrane stretch~~ Membrane stretch Jul 15, 2026

hhyyrylainen added the review label Jul 15, 2026

hhyyrylainen added this to the Release 1.2.0 milestone Jul 15, 2026

hhyyrylainen reviewed Jul 16, 2026

View reviewed changes

	var cellPosistion = Hex.AxialToCartesian(cell.Position);
	var cellPosition = Hex.AxialToCartesian(cell.Position);

		var positionsArray = cellsPositions.ToArray();
		var rotationsArray = cellsOrientations.ToArray();


		var sourcePoints = dataSource.HexPositions;

		if (dataSource.MulticellularPositions != null \|\| multicellularPositions != null)

Uh oh!

Uh oh!

Conversation

Patryk26g commented Jun 28, 2026 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

revolutionary-bot commented Jun 28, 2026

Uh oh!

hhyyrylainen commented Jul 15, 2026

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Patryk26g commented Jul 15, 2026

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

3 participants

Patryk26g commented Jun 28, 2026 •

edited

Loading