hheik
/
kuilu
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
kuilu/src/terrain2d/chunk2d.rs

621 lines
23 KiB
Rust
Raw Blame History

use std::collections::VecDeque;
use super::{
local_to_texel_index, texel_index_to_local, Terrain2D, TerrainEvent2D, Texel2D,
TexelBehaviour2D, TexelID, NEIGHBOUR_INDEX_MAP,
};
use crate::util::{CollisionLayers, Segment2I, Vector2I};
use bevy::{
prelude::*,
render::{render_resource::Extent3d, texture::ImageSampler},
};
use bevy_rapier2d::prelude::*;
use lazy_static::lazy_static;
type Island = VecDeque<Segment2I>;
lazy_static! {
/// Marching Square case dictionary.
///
/// Key is a bitmask of neighbouring tiles (up, right, down, left - least significant bit first).
/// Bit set to 1 means that the neighbour has collision. Only the 4 least significant bits are currently used.
///
/// Value is an array of segments that the tile should have. The segments are configured to go clockwise.
///
/// Note: This dictionary should only be used for empty tiles.
static ref MST_CASE_MAP: [Vec<Segment2I>; 16] = [
/* 0b0000 */ vec![],
/* 0b0001 */ vec![ Segment2I { from: Vector2I::ONE, to: Vector2I::UP } ],
/* 0b0010 */ vec![ Segment2I { from: Vector2I::RIGHT, to: Vector2I::ONE } ],
/* 0b0011 */ vec![ Segment2I { from: Vector2I::RIGHT, to: Vector2I::UP } ],
/* 0b0100 */ vec![ Segment2I { from: Vector2I::ZERO, to: Vector2I::RIGHT } ],
/* 0b0101 */ vec![ Segment2I { from: Vector2I::ONE, to: Vector2I::UP }, Segment2I { from: Vector2I::ZERO, to: Vector2I::RIGHT } ],
/* 0b0110 */ vec![ Segment2I { from: Vector2I::ZERO, to: Vector2I::ONE } ],
/* 0b0111 */ vec![ Segment2I { from: Vector2I::ZERO, to: Vector2I::UP } ],
/* 0b1000 */ vec![ Segment2I { from: Vector2I::UP, to: Vector2I::ZERO } ],
/* 0b1001 */ vec![ Segment2I { from: Vector2I::ONE, to: Vector2I::ZERO } ],
/* 0b1010 */ vec![ Segment2I { from: Vector2I::RIGHT, to: Vector2I::ONE }, Segment2I { from: Vector2I::UP, to: Vector2I::ZERO } ],
/* 0b1011 */ vec![ Segment2I { from: Vector2I::RIGHT, to: Vector2I::ZERO } ],
/* 0b1100 */ vec![ Segment2I { from: Vector2I::UP, to: Vector2I::RIGHT } ],
/* 0b1101 */ vec![ Segment2I { from: Vector2I::ONE, to: Vector2I::RIGHT } ],
/* 0b1110 */ vec![ Segment2I { from: Vector2I::UP, to: Vector2I::ONE } ],
/* 0b1111 */ vec![],
];
/// Version of the MS case dictionary that is used by the solid tiles at the edge of the chunk
static ref MST_EDGE_CASE_MAP: [Segment2I; 4] = [
/* up */ Segment2I { from: Vector2I::UP, to: Vector2I::ONE },
/* right */ Segment2I { from: Vector2I::ONE, to: Vector2I::RIGHT },
/* down */ Segment2I { from: Vector2I::RIGHT, to: Vector2I::ZERO },
/* left */ Segment2I { from: Vector2I::ZERO, to: Vector2I::UP },
];
}
#[derive(Reflect, Component, Default)]
#[reflect(Component)]
pub struct TerrainChunk2D {
pub index: Chunk2DIndex,
}
#[derive(Reflect, Component, Default)]
#[reflect(Component)]
pub struct TerrainChunkSpriteSync2D;
#[derive(Reflect, Component, Default)]
#[reflect(Component)]
pub struct TerrainChunkCollisionSync2D;
#[derive(Bundle, Default)]
pub struct ChunkSpriteBundle {
pub chunk: TerrainChunk2D,
pub sync_flag: TerrainChunkSpriteSync2D,
pub sprite: SpriteBundle,
}
#[derive(Bundle, Default)]
pub struct ChunkColliderBundle {
pub chunk: TerrainChunk2D,
pub sync_flag: TerrainChunkCollisionSync2D,
pub transform: TransformBundle,
}
pub type Chunk2DIndex = Vector2I;
#[derive(Clone, Copy)]
pub struct ChunkRect {
pub min: Vector2I,
pub max: Vector2I,
}
pub struct Chunk2D {
pub texels: [Texel2D; (Self::SIZE_X * Self::SIZE_Y) as usize],
// TODO: handle multiple dirty rects
pub dirty_rect: Option<ChunkRect>,
}
impl Chunk2D {
pub const SIZE_X: usize = 32;
pub const SIZE_Y: usize = 32;
pub const SIZE: Vector2I = Vector2I {
x: Self::SIZE_X as i32,
y: Self::SIZE_Y as i32,
};
pub fn new() -> Chunk2D {
Chunk2D {
texels: Self::new_texel_array(),
dirty_rect: None,
}
}
pub fn new_full() -> Chunk2D {
let mut chunk = Chunk2D {
texels: Self::new_texel_array(),
dirty_rect: None,
};
for y in 0..Self::SIZE_Y {
for x in 0..Self::SIZE_X {
chunk.set_texel(&Vector2I::new(x as i32, y as i32), 1);
}
}
chunk
}
pub fn new_half() -> Chunk2D {
let mut chunk = Chunk2D {
texels: Self::new_texel_array(),
dirty_rect: None,
};
for y in 0..Self::SIZE_Y {
for x in 0..Self::SIZE_X {
if x <= Self::SIZE_Y - y {
chunk.set_texel(&Vector2I::new(x as i32, y as i32), 1);
}
}
}
chunk
}
pub fn new_circle() -> Chunk2D {
let mut chunk = Chunk2D {
texels: Self::new_texel_array(),
dirty_rect: None,
};
let origin = Self::SIZE / 2;
let radius = Self::SIZE_X as i32 / 2;
for y in 0..Self::SIZE_Y {
for x in 0..Self::SIZE_X {
let dx = (x as i32 - origin.x).abs();
let dy = (y as i32 - origin.y).abs();
if dx * dx + dy * dy <= (radius - 1) * (radius - 1) {
chunk.set_texel(&Vector2I::new(x as i32, y as i32), 1);
}
}
}
chunk
}
pub fn new_texel_array() -> [Texel2D; Self::SIZE_X * Self::SIZE_Y] {
[Texel2D::default(); Self::SIZE_X * Self::SIZE_Y]
}
pub fn xy_vec() -> Vec<Vector2I> {
let mut result = Vec::with_capacity(Self::SIZE_X * Self::SIZE_Y);
for y in 0..Self::SIZE_Y {
for x in 0..Self::SIZE_X {
result.push(Vector2I {
x: x as i32,
y: y as i32,
});
}
}
result
}
pub fn mark_all_dirty(&mut self) {
self.dirty_rect = Some(ChunkRect {
min: Vector2I::ZERO,
max: Self::SIZE,
});
}
pub fn mark_dirty(&mut self, position: &Vector2I) {
match &self.dirty_rect {
Some(rect) => {
self.dirty_rect = Some(ChunkRect {
min: Vector2I::min(&rect.min, position),
max: Vector2I::max(&rect.max, position),
})
}
None => {
self.dirty_rect = Some(ChunkRect {
min: *position,
max: *position,
})
}
}
}
pub fn mark_clean(&mut self) {
self.dirty_rect = None;
}
pub fn get_texel(&self, position: &Vector2I) -> Option<Texel2D> {
local_to_texel_index(position).map(|i| self.texels[i])
}
pub fn get_texel_mut(&mut self, position: &Vector2I) -> Option<&mut Texel2D> {
local_to_texel_index(position).map(|i| &mut self.texels[i])
}
pub fn set_texel(&mut self, position: &Vector2I, id: TexelID) {
let i = local_to_texel_index(position).expect("Texel index out of range");
if self.texels[i].id != id {
self.mark_dirty(position);
}
let update_neighbours = self.texels[i].is_empty()
!= (Texel2D {
id,
..self.texels[i]
})
.is_empty();
self.texels[i].id = id;
// Update neighbour mask
if update_neighbours {
for offset in Texel2D::NEIGHBOUR_OFFSET_VECTORS {
// Flip neighbour's bit
match self.get_texel_mut(&(*position + offset)) {
Some(mut neighbour) => {
neighbour.neighbour_mask ^= 1 << NEIGHBOUR_INDEX_MAP[&-offset];
}
None => (),
}
}
}
}
pub fn create_texture_data(&self) -> Vec<u8> {
let mut image_data = Vec::with_capacity(Chunk2D::SIZE_X * Chunk2D::SIZE_Y * 4);
for y in (0..Chunk2D::SIZE_Y).rev() {
for x in 0..Chunk2D::SIZE_X {
let id = &self
.get_texel(&Vector2I::new(x as i32, y as i32))
.unwrap()
.id;
let behaviour = TexelBehaviour2D::from_id(id);
let color =
behaviour.map_or(Color::rgba_u8(0, 0, 0, 0), |behaviour| behaviour.color);
let color_data = color.as_rgba_u32();
let mut color_data: Vec<u8> = vec![
((color_data >> 0) & 0xff) as u8,
((color_data >> 8) & 0xff) as u8,
((color_data >> 16) & 0xff) as u8,
((color_data >> 24) & 0xff) as u8,
];
image_data.append(&mut color_data);
}
}
image_data
}
pub fn create_collision_data(&self) -> Vec<Vec<Vec2>> {
let mut islands: Vec<Island> = Vec::new();
for i in 0..self.texels.len() {
let local = texel_index_to_local(i);
let edge_mask: u8 = if local.y == Chunk2D::SIZE.y - 1 {
1 << 0
} else {
0
} | if local.x == Chunk2D::SIZE.x - 1 {
1 << 1
} else {
0
} | if local.y == 0 { 1 << 2 } else { 0 }
| if local.x == 0 { 1 << 3 } else { 0 };
let mut sides: Vec<Segment2I>;
if self.texels[i].is_empty() {
sides = MST_CASE_MAP[self.texels[i].neighbour_mask as usize]
.iter()
.clone()
.map(|side| Segment2I {
from: side.from + local,
to: side.to + local,
})
.collect();
} else if !self.texels[i].is_empty() && edge_mask != 0 {
sides = Vec::with_capacity(Chunk2D::SIZE_X * 2 + Chunk2D::SIZE_Y * 2);
for i in 0..MST_EDGE_CASE_MAP.len() {
if edge_mask & (1 << i) != 0 {
let edge = MST_EDGE_CASE_MAP[i];
sides.push(Segment2I {
from: edge.from + local,
to: edge.to + local,
})
}
}
} else {
continue;
}
for side in sides {
// Check if the side can be attached to any island
// The naming of front and back are kind of misleading, and come from the VecDeque type.
// You can think of the front as the beginning of the island loop, and back the end.
// Connect to an island if possible, otherwise create a new island
{
let mut connected_to: Option<&mut Island> = None;
for island in islands.iter_mut() {
if island.back().is_some() && island.back().unwrap().to == side.from {
connected_to = Some(island);
}
}
match connected_to {
Some(back) => {
back.push_back(side);
}
None => {
let mut island: Island = Island::new();
island.push_back(side);
islands.push(island);
}
}
}
// Find connected islands
loop {
let mut merge_index: Option<usize> = None;
'outer: for i in 0..islands.len() {
for j in 0..islands.len() {
if i == j {
continue;
}
if islands[i].back().is_some()
&& islands[j].front().is_some()
&& islands[i].back().unwrap().to == islands[j].front().unwrap().from
{
merge_index = Some(i);
break 'outer;
}
}
}
// Merge connected islands
match merge_index {
Some(index) => {
let mut merge_from = islands.swap_remove(index);
match islands.iter_mut().find(|island| match island.front() {
Some(front) => front.from == merge_from.back().unwrap().to,
None => false,
}) {
Some(merge_to) => loop {
match merge_from.pop_back() {
Some(segment) => merge_to.push_front(segment),
None => break,
}
},
None => (),
};
}
None => break,
}
}
}
}
let mut result: Vec<Vec<Vec2>> = Vec::with_capacity(islands.len());
for island in islands {
if island.len() < 4 {
continue;
}
let mut points: Vec<Vec2> = Vec::with_capacity(island.len() + 1);
points.push(Vec2::from(island.front().unwrap().from));
let mut current_angle: Option<f32> = None;
for side in island {
if current_angle.is_some() && (current_angle.unwrap() - side.angle()).abs() < 0.1 {
let len = points.len();
points[len - 1] = Vec2::from(side.to)
} else {
current_angle = Some(side.angle());
points.push(Vec2::from(side.to));
}
}
result.push(points);
}
result
}
}
pub fn chunk_spawner(
mut commands: Commands,
mut terrain_events: EventReader<TerrainEvent2D>,
mut images: ResMut<Assets<Image>>,
chunk_query: Query<(Entity, &TerrainChunk2D)>,
) {
for terrain_event in terrain_events.iter() {
match terrain_event {
TerrainEvent2D::ChunkAdded(chunk_index) => {
// Create unique handle for the image
let mut image = Image::new(
Extent3d {
width: Chunk2D::SIZE_X as u32,
height: Chunk2D::SIZE_Y as u32,
depth_or_array_layers: 1,
},
bevy::render::render_resource::TextureDimension::D2,
vec![0x00; Chunk2D::SIZE_X * Chunk2D::SIZE_Y * 4],
bevy::render::render_resource::TextureFormat::Rgba8Unorm,
);
image.sampler_descriptor = ImageSampler::nearest();
let texture = images.add(image);
let pos = Vec2::from(*chunk_index * Chunk2D::SIZE);
commands
.spawn(ChunkSpriteBundle {
chunk: TerrainChunk2D {
index: *chunk_index,
},
sprite: SpriteBundle {
sprite: Sprite {
custom_size: Some(Vec2::from(Chunk2D::SIZE)),
anchor: bevy::sprite::Anchor::BottomLeft,
..default()
},
texture,
transform: Transform::from_translation(Vec3::new(pos.x, pos.y, 0.0)),
..default()
},
..default()
})
.insert(Name::new(format!(
"Chunk Sprite {},{}",
chunk_index.x, chunk_index.y
)));
commands
.spawn(ChunkColliderBundle {
chunk: TerrainChunk2D {
index: *chunk_index,
},
transform: TransformBundle::from_transform(Transform::from_translation(
Vec3::new(pos.x, pos.y, 0.0),
)),
..default()
})
.insert(Name::new(format!(
"Chunk Collider {},{}",
chunk_index.x, chunk_index.y
)));
}
TerrainEvent2D::ChunkRemoved(chunk_index) => {
for (entity, chunk) in chunk_query.iter() {
if chunk.index == *chunk_index {
commands.entity(entity).despawn_recursive();
}
}
}
_ => (),
}
}
}
/**
Update the chunk sprite as needed
*/
pub fn chunk_sprite_sync(
mut terrain_events: EventReader<TerrainEvent2D>,
mut images: ResMut<Assets<Image>>,
terrain: Res<Terrain2D>,
added_chunk_query: Query<
(Entity, &TerrainChunk2D),
(With<TerrainChunkSpriteSync2D>, Changed<TerrainChunk2D>),
>,
chunk_query: Query<(Entity, &TerrainChunk2D), (With<TerrainChunkSpriteSync2D>, With<Sprite>)>,
texture_query: Query<&Handle<Image>>,
) {
let mut updated_chunks: Vec<(Entity, &TerrainChunk2D, Option<ChunkRect>)> = vec![];
// Check for added components
for (added_entity, added_chunk) in added_chunk_query.iter() {
updated_chunks.push((added_entity, added_chunk, None));
}
// Check for terrain events
for event in terrain_events.iter() {
for (entity, chunk) in chunk_query.iter() {
let (chunk_index, rect) = match event {
TerrainEvent2D::ChunkAdded(chunk_index) => {
// The entity should not have the time to react to the event since it was just made
// REM: This gets called when new chunk is instantiated with brush
// println!("[chunk_sprite_sync -> TerrainEvent2D::ChunkAdded] This probably shouldn't be firing, maybe the chunk was destroyed and immediately created? chunk: {chunk_index:?}");
(chunk_index, None)
}
TerrainEvent2D::TexelsUpdated(chunk_index, rect) => (chunk_index, Some(*rect)),
_ => continue,
};
if *chunk_index != chunk.index {
continue;
};
updated_chunks.push((entity, chunk, rect));
}
}
// Update sprite
for (entity, chunk, rect) in updated_chunks {
let chunk = terrain.index_to_chunk(&chunk.index).unwrap();
// TODO: Update only the rect
let _rect = rect.unwrap_or(ChunkRect {
min: Vector2I::ZERO,
max: Chunk2D::SIZE - Vector2I::ONE,
});
let handle = texture_query.get(entity).unwrap();
let mut image = images.get_mut(handle).unwrap();
let image_data = chunk.create_texture_data();
image.data = image_data;
}
}
/**
Create and update colliders for chunk as needed
*/
pub fn chunk_collision_sync(
mut terrain_events: EventReader<TerrainEvent2D>,
mut commands: Commands,
terrain: Res<Terrain2D>,
added_chunk_query: Query<
(Entity, &TerrainChunk2D),
(With<TerrainChunkCollisionSync2D>, Changed<TerrainChunk2D>),
>,
chunk_query: Query<(Entity, &TerrainChunk2D), With<TerrainChunkCollisionSync2D>>,
child_query: Query<&Children>,
collider_query: Query<&Collider>,
) {
let mut updated_chunks: Vec<(Entity, &TerrainChunk2D)> = vec![];
// Check for added components
for (added_entity, added_chunk) in added_chunk_query.iter() {
updated_chunks.push((added_entity, added_chunk));
}
// Check for terrain events
for event in terrain_events.iter() {
for (entity, chunk) in chunk_query.iter() {
let chunk_index = match event {
TerrainEvent2D::ChunkAdded(chunk_index) => {
// The entity should not have the time to react to the event since it was just made
// REM: This gets called when new chunk is instantiated with brush
// println!("[chunk_collision_sync -> TerrainEvent2D::ChunkAdded] This probably shouldn't be firing, maybe the chunk was destroyed and immediately created? chunk: {chunk_index:?}");
chunk_index
}
TerrainEvent2D::TexelsUpdated(chunk_index, _) => chunk_index,
_ => continue,
};
if *chunk_index != chunk.index {
continue;
};
updated_chunks.push((entity, chunk));
}
}
// let layer_membership = CollisionLayers::WORLD;
// REM: Kinda messy, partly due do how entity creation is timed
for (entity, chunk_component) in updated_chunks.iter() {
let chunk = terrain.index_to_chunk(&chunk_component.index).unwrap();
let new_islands = chunk.create_collision_data();
// Create new colliders
if let Ok(children) = child_query.get(*entity) {
// Chunk has children, new ones will be created and old ones components will be removed
for (index, island) in new_islands.iter().enumerate() {
if let Some(child) = children.get(index) {
// Replace collider
commands
.entity(*child)
.insert(Collider::polyline(island.clone(), None));
} else {
// Create new child
commands.entity(*entity).with_children(|builder| {
builder
.spawn(Collider::polyline(island.clone(), None))
.insert(TransformBundle::default())
.insert(CollisionGroups::new(CollisionLayers::WORLD, Group::ALL))
.insert(Name::new(format!("Island #{}", index)));
});
}
}
} else {
// Chunk doesn't have a Children component yet
for (index, island) in new_islands.iter().enumerate() {
commands.entity(*entity).with_children(|builder| {
builder
.spawn(Collider::polyline(island.clone(), None))
.insert(TransformBundle::default())
.insert(CollisionGroups::new(CollisionLayers::WORLD, Group::ALL))
.insert(Name::new(format!("Island #{}", index)));
});
}
};
// Remove extra children.
// Leaving them seems to cause weird problems with rapier when re-adding the collider. The collider is ignored until something else is updated.
for children in child_query.get(*entity) {
for (index, child) in children.iter().enumerate() {
if let Ok(_) = collider_query.get(*child) {
if index >= new_islands.len() {
commands.entity(*child).despawn_recursive();
}
}
}
}
}
}
Reference in New Issue View Git Blame Copy Permalink