ImBenji/Frontiers
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Add terrain shader and configuration files; update World class for shader integration

Browse Source
This commit is contained in:
ImBenji
2025-10-18 19:32:00 +01:00
parent f7de1c67af
commit 9e3cfb8d14
4 changed files with 2395 additions and 494 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2257
Shaders/FastNoiseLite.gdshader Normal file
View File

File diff suppressed because it is too large Load Diff

304
Source/Tile.cs
View File

@@ -1,304 +0,0 @@
using System;
using System.Diagnostics;
using System.Threading;
using System.Threading.Tasks;
using Godot;
public partial class Tile : Node2D
{
private Vector2I _size;
private Vector2I _chunkId;
private World _world;
public CancellationToken CancellationToken { get; set; }
public Tile(Vector2I size, Vector2I chunkId, World world)
{
_size = size;
_chunkId = chunkId;
_world = world;
}
public override void _Ready()
{
loadTile();
}
void loadTile()
{
Image image = Image.CreateEmpty(_size.X, _size.Y, false, Image.Format.Rgba8);
Vector2I heightMapResolution = new Vector2I(
_world.HeightMapImage.GetWidth(),
_world.HeightMapImage.GetHeight()
);
Vector2I mapResolution = _world.ChunksPerAxis * _world.TileSize;
Vector2I tileOffset = new Vector2I(
_chunkId.X * _world.TileSize,
_chunkId.Y * _world.TileSize
);
// Store parameters locally to avoid changes during generation
float rockThreshold = _world.RockThreshold;
float snowHeightThreshold = _world.SnowHeightThreshold;
float waterThreshold = _world.WaterThreshold;
float desertMoistureThreshold = _world.DesertMoistureThreshold;
float desertTemperatureThreshold = _world.DesertTemperatureThreshold;
DebugType debugType = _world.DebugType;
// Use limited parallelism instead of unlimited Task.Run
var parallelOptions = new ParallelOptions
{
MaxDegreeOfParallelism = Math.Max(1, (int)(System.Environment.ProcessorCount * 0.5)),
CancellationToken = CancellationToken
};
Task.Run(() =>
{
try
{
Parallel.For(0, _size.X, parallelOptions, x =>
{
if (CancellationToken.IsCancellationRequested) return;
for (int y = 0; y < _size.Y; y++)
{
if (CancellationToken.IsCancellationRequested) return;
Vector2I pixelOffset = new Vector2I(
x + tileOffset.X,
y + tileOffset.Y
);
float heightValue = GetValueAtMapPosition(pixelOffset);
float heatValue = GetHeatAtMapPosition(pixelOffset);
float moistureValue = GetMoistureAtMapPosition(pixelOffset);
// Get the max difference between the coord and its neighbors
float maxDiff = 0.0f;
float centerHeight = heightValue;
bool bordersSea = false;
for (int offsetX = -1; offsetX <= 1; offsetX++)
{
for (int offsetY = -1; offsetY <= 1; offsetY++)
{
if (offsetX == 0 && offsetY == 0)
continue;
Vector2I neighborCoords = new Vector2I(
pixelOffset.X + offsetX,
pixelOffset.Y + offsetY
);
float neighborHeight = GetValueAtMapPosition(neighborCoords);
if (IsSeaAtMapPosition(neighborCoords))
{
bordersSea = true;
}
float diff = Mathf.Abs(centerHeight - neighborHeight);
if (diff > maxDiff)
{
maxDiff = diff;
}
}
}
if (debugType == DebugType.None)
{
// Grass (default)
image.SetPixel(x, y, Color.FromString("#bed58a", Colors.Purple));
if (IsSeaAtMapPosition(pixelOffset))
{
// Water
image.SetPixel(x, y, Color.FromString("#4380b0", Colors.Purple));
continue;
}
if (isDesertAtMapPosition(pixelOffset))
{
// Desert
image.SetPixel(x, y, Color.FromString("#edc9af", Colors.Purple));
}
if (bordersSea)
{
// Beach
image.SetPixel(x, y, Color.FromString("#808080", Colors.Purple));
continue;
}
if (heightValue > snowHeightThreshold && !isDesertAtMapPosition(pixelOffset))
{
// Snow
image.SetPixel(x, y, Color.FromString("#f4f4f4", Colors.Purple));
}
// We want steep areas to be grey for rock.
if (maxDiff > rockThreshold)
{
// Steep area
image.SetPixel(x, y, Color.FromString("#e4d3a6", Colors.Purple));
continue;
}
}
else if (debugType == DebugType.Height)
{
float grayValue = heightValue;
image.SetPixel(x, y, new Color(grayValue, grayValue, grayValue));
}
else if (debugType == DebugType.Slope)
{
float grayValue = maxDiff * 5.0f;
image.SetPixel(x, y, new Color(grayValue, grayValue, grayValue));
} else if (debugType == DebugType.Temperature)
{
image.SetPixel(x, y, new Color(heatValue, heatValue, heatValue));
} else if (debugType == DebugType.Moisture)
{
image.SetPixel(x, y, new Color(moistureValue, moistureValue, moistureValue));
}
}
});
if (!CancellationToken.IsCancellationRequested)
{
// Create a texture from the image and assign it to a Sprite2D
Texture2D texture = ImageTexture.CreateFromImage(image);
Sprite2D sprite = new Sprite2D();
sprite.Texture = texture;
sprite.TextureFilter = TextureFilterEnum.Nearest;
CallDeferred("add_child", sprite);
}
}
catch (OperationCanceledException)
{
// Generation was cancelled, do nothing
}
}, CancellationToken);
}
// Terrain Query Methods
private Vector2I ToHeightMapCoordinates(Vector2I position)
{
Vector2I heightMapResolution = new Vector2I(
_world.HeightMapImage.GetWidth(),
_world.HeightMapImage.GetHeight()
);
Vector2I mapResolution = _world.ChunksPerAxis * _world.TileSize;
Vector2 mapDelta = (Vector2) position / (Vector2) mapResolution;
Vector2I heightMapCoords = new Vector2I(
(int)(mapDelta.X * heightMapResolution.X),
(int)(mapDelta.Y * heightMapResolution.Y)
);
// Clamp to valid range
heightMapCoords.X = Mathf.Clamp(heightMapCoords.X, 0, heightMapResolution.X - 1);
heightMapCoords.Y = Mathf.Clamp(heightMapCoords.Y, 0, heightMapResolution.Y - 1);
return heightMapCoords;
}
private float GetValueAtMapPosition(Vector2I position)
{
Vector2I heightMapCoords = ToHeightMapCoordinates(position);
Color hmColor = _world.HeightMapImage.GetPixel(heightMapCoords.X, heightMapCoords.Y);
return hmColor.R;
}
private bool isSeaAtMapPosition(Vector2I position)
{
float heightValue = GetValueAtMapPosition(position);
return heightValue <= _world.WaterThreshold;
}
private bool isDesertAtMapPosition(Vector2I position)
{
float heatValue = GetHeatAtMapPosition(position);
float moistureValue = GetMoistureAtMapPosition(position);
return moistureValue < _world.DesertMoistureThreshold && heatValue > _world.DesertTemperatureThreshold;
}
private bool IsSeaAtMapPosition(Vector2I position)
{
float heightValue = GetValueAtMapPosition(position);
return heightValue <= _world.WaterThreshold;
}
private FastNoiseLite _heatNoise = null;
private float GetHeatAtMapPosition(Vector2I position)
{
if (_heatNoise == null)
{
_heatNoise = new FastNoiseLite();
_heatNoise.SetNoiseType(FastNoiseLite.NoiseTypeEnum.Perlin);
_heatNoise.SetFrequency(1/_world.TemperatureNoiseFrequency);
_heatNoise.SetFractalType(FastNoiseLite.FractalTypeEnum.Fbm);
_heatNoise.SetFractalOctaves(12);
_heatNoise.SetSeed(1738);
}
Vector2I heightMapCoords = ToHeightMapCoordinates(position);
float heat = _heatNoise.GetNoise2D(heightMapCoords.X, heightMapCoords.Y);
heat *= _world.TemperatureNoiseAmplitude;
// Fall off towards the poles. Use sine function for a globe effect.
float mapResolutionY = _world.HeightMapImage.GetHeight();
float latitudeFactor = Mathf.Sin(Mathf.Pi * heightMapCoords.Y / mapResolutionY);
heat = latitudeFactor + heat;
return heat;
}
private FastNoiseLite _moistureNoise = null;
private float GetMoistureAtMapPosition(Vector2I position)
{
if (_moistureNoise == null)
{
_moistureNoise = new FastNoiseLite();
_moistureNoise.SetNoiseType(FastNoiseLite.NoiseTypeEnum.Perlin);
_moistureNoise.SetFrequency(1/_world.MoistureNoiseFrequency);
_moistureNoise.SetFractalType(FastNoiseLite.FractalTypeEnum.Fbm);
_moistureNoise.SetFractalOctaves(12);
_moistureNoise.SetSeed(1337);
}
Vector2I heightMapCoords = ToHeightMapCoordinates(position);
float moisture = _moistureNoise.GetNoise2D(heightMapCoords.X, heightMapCoords.Y);
moisture *= _world.MoistureNoiseAmplitude;
// Fall off towards the poles. Use sine function for a globe effect.
float mapResolutionY = _world.HeightMapImage.GetHeight();
float latitudeFactor = Mathf.Sin(Mathf.Pi * heightMapCoords.Y / mapResolutionY);
moisture = latitudeFactor + moisture;
return moisture;
}
}

285
Source/World.cs
View File

@@ -1,12 +1,5 @@
using Godot; using Godot;
using System; using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Diagnostics;
using System.Threading;
using System.Threading.Tasks;
using Godot.Collections;
using Environment = Godot.Environment;
public enum DebugType public enum DebugType
{ {
@@ -20,52 +13,21 @@ public enum DebugType
[Tool] [Tool]
public partial class World : Node2D public partial class World : Node2D
{ {
private int _chunksX = 32;
[Export]
public int ChunkXCount
{
get => _chunksX;
set
{
_chunksX = value;
LoadTiles();
}
}
public Vector2I ChunksPerAxis
{
get
{
if (HeightMapImage == null)
{
return new Vector2I(_chunksX, _chunksX);
}
Vector2I heightMapResolution = new Vector2I(HeightMapImage.GetWidth(), HeightMapImage.GetHeight());
int chunksY = (int)(heightMapResolution.Y / (heightMapResolution.X / _chunksX));
return new Vector2I(_chunksX, chunksY);
}
}
private int _tileSize = 96;
[Export]
public int TileSize
{
get => _tileSize;
set
{
_tileSize = value;
LoadTiles();
}
}
[Export] [Export]
public Texture2D HeightMapTexture; public Texture2D HeightMapTexture;
private float _rockThreshold = 0.05f; [Export]
public int MapWidth
{
get => _mapWidth;
set
{
_mapWidth = value;
SetupShader();
}
}
private int _mapWidth = 3072;
[Export] [Export]
public float RockThreshold public float RockThreshold
{ {
@@ -73,11 +35,11 @@ public partial class World : Node2D
set set
{ {
_rockThreshold = value; _rockThreshold = value;
LoadTiles(); UpdateShaderParameters();
} }
} }
private float _rockThreshold = 0.05f;
private float _snowHeightThreshold = 0.8f;
[Export] [Export]
public float SnowHeightThreshold public float SnowHeightThreshold
{ {
@@ -85,11 +47,11 @@ public partial class World : Node2D
set set
{ {
_snowHeightThreshold = value; _snowHeightThreshold = value;
LoadTiles(); UpdateShaderParameters();
} }
} }
private float _snowHeightThreshold = 0.8f;
private float _waterThreshold = 0.0f;
[Export] [Export]
public float WaterThreshold public float WaterThreshold
{ {
@@ -97,11 +59,11 @@ public partial class World : Node2D
set set
{ {
_waterThreshold = value; _waterThreshold = value;
LoadTiles(); UpdateShaderParameters();
} }
} }
private float _waterThreshold = 0.0f;
private float _desertTemperatureThreshold = 0.7f;
[Export] [Export]
public float DesertTemperatureThreshold public float DesertTemperatureThreshold
{ {
@@ -109,11 +71,11 @@ public partial class World : Node2D
set set
{ {
_desertTemperatureThreshold = value; _desertTemperatureThreshold = value;
LoadTiles(); UpdateShaderParameters();
} }
} }
private float _desertTemperatureThreshold = 0.7f;
private float _desertMoistureThreshold = 0.3f;
[Export] [Export]
public float DesertMoistureThreshold public float DesertMoistureThreshold
{ {
@@ -121,11 +83,11 @@ public partial class World : Node2D
set set
{ {
_desertMoistureThreshold = value; _desertMoistureThreshold = value;
LoadTiles(); UpdateShaderParameters();
} }
} }
private float _desertMoistureThreshold = 0.3f;
private float _temperatureNoiseFrequency = 0.01f;
[Export] [Export]
public float TemperatureNoiseFrequency public float TemperatureNoiseFrequency
{ {
@@ -133,11 +95,11 @@ public partial class World : Node2D
set set
{ {
_temperatureNoiseFrequency = value; _temperatureNoiseFrequency = value;
LoadTiles(); UpdateShaderParameters();
} }
} }
private float _temperatureNoiseFrequency = 0.01f;
private float _moistureNoiseFrequency = 0.01f;
[Export] [Export]
public float MoistureNoiseFrequency public float MoistureNoiseFrequency
{ {
@@ -145,35 +107,35 @@ public partial class World : Node2D
set set
{ {
_moistureNoiseFrequency = value; _moistureNoiseFrequency = value;
LoadTiles(); UpdateShaderParameters();
} }
} }
private float _moistureNoiseFrequency = 0.01f;
private float _TemperatureNoiseAmplitude = 0.1f;
[Export] [Export]
public float TemperatureNoiseAmplitude public float TemperatureNoiseAmplitude
{ {
get => _TemperatureNoiseAmplitude; get => _temperatureNoiseAmplitude;
set set
{ {
_TemperatureNoiseAmplitude = value; _temperatureNoiseAmplitude = value;
LoadTiles(); UpdateShaderParameters();
} }
} }
private float _temperatureNoiseAmplitude = 0.1f;
private float _MoistureNoiseAmplitude = 0.1f;
[Export] [Export]
public float MoistureNoiseAmplitude public float MoistureNoiseAmplitude
{ {
get => _MoistureNoiseAmplitude; get => _moistureNoiseAmplitude;
set set
{ {
_MoistureNoiseAmplitude = value; _moistureNoiseAmplitude = value;
LoadTiles(); UpdateShaderParameters();
} }
} }
private float _moistureNoiseAmplitude = 0.1f;
private DebugType _debugType = DebugType.None;
[Export] [Export]
public DebugType DebugType public DebugType DebugType
{ {
@@ -181,136 +143,121 @@ public partial class World : Node2D
set set
{ {
_debugType = value; _debugType = value;
LoadTiles(); UpdateShaderParameters();
} }
} }
private DebugType _debugType = DebugType.None;
private Sprite2D _terrainSprite;
private ShaderMaterial _shaderMaterial;
ConcurrentDictionary<Vector2I, Tile> _tiles = new ConcurrentDictionary<Vector2I, Tile>();
private CancellationTokenSource _cancellationTokenSource;
private static readonly int MaxDegreeOfParallelism = Math.Max(1, (int)(System.Environment.ProcessorCount * 0.5));
public World()
{
}
public override void _Ready() public override void _Ready()
{ {
// If the height map image is not assigned, log an error and return // If the height map image is not assigned, log an error and return
if (HeightMapTexture == null) if (HeightMapTexture == null)
{ {
GD.PrintErr("Height map image is not assigned."); GD.PrintErr("Height map texture is not assigned.");
return; return;
} }
LoadTiles(); SetupShader();
} }
private void LoadTiles() private void SetupShader()
{ {
// Check if HeightMapImage is available // Don't run during initialization if not ready
if (HeightMapImage == null) if (HeightMapTexture == null) return;
// Clear any existing terrain sprite
if (_terrainSprite != null)
{ {
GD.PrintErr("Cannot load tiles: HeightMapImage is null"); _terrainSprite.QueueFree();
_terrainSprite = null;
}
// Load the shader
Shader terrainShader = GD.Load<Shader>("res://Shaders/terrain.gdshader");
if (terrainShader == null)
{
GD.PrintErr("Failed to load terrain shader.");
return; return;
} }
// Cancel any existing generation // Create shader material
_cancellationTokenSource?.Cancel(); _shaderMaterial = new ShaderMaterial();
_cancellationTokenSource = new CancellationTokenSource(); _shaderMaterial.Shader = terrainShader;
var cancellationToken = _cancellationTokenSource.Token;
// Clear existing tiles // Get heightmap dimensions
foreach (var tile in _tiles.Values) Image heightImage = HeightMapTexture.GetImage();
if (heightImage == null)
{ {
tile.Visible = false; GD.PrintErr("Failed to get image from HeightMapTexture.");
return;
// Delete and delete its children
foreach (Node child in tile.GetChildren())
{
child.QueueFree();
}
tile.QueueFree();
} }
_tiles.Clear();
int scale = 1; Vector2I heightMapSize = new Vector2I(heightImage.GetWidth(), heightImage.GetHeight());
// Store local copies of parameters to avoid them changing mid-generation // Calculate output resolution
int tileSize = TileSize; // Height is always calculated based on heightmap aspect ratio
int chunksX = _chunksX; int outputWidth = MapWidth;
float aspectRatio = (float)heightMapSize.Y / heightMapSize.X;
int outputHeight = (int)(outputWidth * aspectRatio);
// Get the resolution of the height map image // Create a sprite to display the shader
Vector2I heightMapResolution = new Vector2I(HeightMapImage.GetWidth(), HeightMapImage.GetHeight()); _terrainSprite = new Sprite2D();
_terrainSprite.Material = _shaderMaterial;
_terrainSprite.TextureFilter = TextureFilterEnum.Nearest;
// Calculate the number of chunks in the Y direction based on the aspect ratio // Create a white texture with the desired output size
int chunksY = (int)(heightMapResolution.Y / (heightMapResolution.X / _chunksX)); // The shader will render over this
Image whiteImage = Image.CreateEmpty(outputWidth, outputHeight, false, Image.Format.Rgba8);
whiteImage.Fill(Colors.White);
_terrainSprite.Texture = ImageTexture.CreateFromImage(whiteImage);
// Loop through each chunk position and create a Tile // Center the sprite
Task.Run(() => _terrainSprite.Centered = false;
{
try
{
for (int x = 0; x < chunksX; x++)
{
if (cancellationToken.IsCancellationRequested) return;
for (int y = 0; y < chunksY; y++) AddChild(_terrainSprite);
{
if (cancellationToken.IsCancellationRequested) return;
Vector2I chunkId = new Vector2I(x, y);
Tile tile = new Tile(new Vector2I(tileSize, tileSize), chunkId, this);
tile.CancellationToken = cancellationToken;
tile.Position = new Vector2(chunkId.X * tileSize, chunkId.Y * tileSize) * scale;
tile.Scale = new Vector2(scale, scale);
if (!cancellationToken.IsCancellationRequested)
{
CallDeferred("add_child", tile);
_tiles[chunkId] = tile;
// GD.Print("Loaded tile at chunk " + chunkId);
}
}
}
}
catch (OperationCanceledException)
{
// GD.Print("Tile generation cancelled");
}
}, cancellationToken);
// Update all shader parameters
UpdateShaderParameters();
} }
private Image _heightMapCache; private void UpdateShaderParameters()
public Image HeightMapImage
{ {
get if (_shaderMaterial == null)
{ {
// If not cached, load and cache it GD.PrintErr("ShaderMaterial is null, cannot update parameters");
if (_heightMapCache == null && HeightMapTexture != null) return;
{
_heightMapCache = HeightMapTexture.GetImage();
// If GetImage() returns null, try loading directly from file
if (_heightMapCache == null && HeightMapTexture.ResourcePath != "")
{
_heightMapCache = Image.LoadFromFile(HeightMapTexture.ResourcePath);
if (_heightMapCache == null)
{
GD.PushError($"Could not load heightmap from {HeightMapTexture.ResourcePath}");
}
}
}
return _heightMapCache;
} }
if (HeightMapTexture == null)
{
GD.PrintErr("HeightMapTexture is null, cannot update parameters");
return;
}
GD.Print($"Setting height_map texture: {HeightMapTexture.ResourcePath}");
// Set the heightmap texture
_shaderMaterial.SetShaderParameter("height_map", HeightMapTexture);
// Set all threshold parameters
_shaderMaterial.SetShaderParameter("water_threshold", WaterThreshold);
_shaderMaterial.SetShaderParameter("rock_threshold", RockThreshold);
_shaderMaterial.SetShaderParameter("snow_height_threshold", SnowHeightThreshold);
_shaderMaterial.SetShaderParameter("desert_temperature_threshold", DesertTemperatureThreshold);
_shaderMaterial.SetShaderParameter("desert_moisture_threshold", DesertMoistureThreshold);
// Set noise parameters
_shaderMaterial.SetShaderParameter("temperature_noise_frequency", TemperatureNoiseFrequency);
_shaderMaterial.SetShaderParameter("temperature_noise_amplitude", TemperatureNoiseAmplitude);
_shaderMaterial.SetShaderParameter("moisture_noise_frequency", MoistureNoiseFrequency);
_shaderMaterial.SetShaderParameter("moisture_noise_amplitude", MoistureNoiseAmplitude);
// Set debug mode
_shaderMaterial.SetShaderParameter("debug_type", (int)DebugType);
GD.Print("Shader parameters updated successfully");
} }
} }

3
main.tscn
View File

@@ -18,6 +18,7 @@ RockThreshold = 0.04
SnowHeightThreshold = 0.32 SnowHeightThreshold = 0.32
WaterThreshold = 0.24 WaterThreshold = 0.24
DesertTemperatureThreshold = 0.84 DesertTemperatureThreshold = 0.84
DesertMoistureThreshold = 0.96 DesertMoistureThreshold = 0.98
TemperatureNoiseFrequency = 1500.0 TemperatureNoiseFrequency = 1500.0
MoistureNoiseFrequency = 1500.0 MoistureNoiseFrequency = 1500.0
MoistureNoiseAmplitude = 0.02