Struct RiverData 

pub struct RiverData {
    pub(crate) velocity: Vec3<f32>,
    pub(crate) spline_derivative: Vec2<f32>,
    pub river_kind: Option<RiverKind>,
    pub(crate) neighbor_rivers: Vec<u32>,
}

From velocity and cross_section we can calculate the volumetric flow rate, as the cross-sectional area times the velocity.

TODO: we might choose to include a curve for the river, as long as it didn’t allow it to cross more than one neighboring chunk away. For now we defer this to rendering time.

NOTE: This structure is 57 (or more likely 64) bytes, which is kind of big.

Fields

velocity: Vec3<f32>

A velocity vector (in m / minute, i.e. voxels / second from a game perspective).

TODO: To represent this in a better-packed way, use u8s instead (as “f8s”).

spline_derivative: Vec2<f32>

The computed derivative for the segment of river starting at this chunk (and flowing downhill). Should be 0 at endpoints. For rivers with more than one incoming segment, we weight the derivatives by flux (cross-sectional area times velocity) which is correlated with mass / second; treating the derivative as “velocity” with respect to length along the river, we treat the weighted sum of incoming splines as the “momentum”, and can divide it by the total incoming mass as a way to find the velocity of the center of mass. We can then use this derivative to find a “tangent” for the incoming river segment at this point, and as the linear part of the interpolating spline at this point.

Note that we aren’t going to have completely smooth curves here anyway, so we will probably end up applying a dampening factor as well (maybe based on the length?) to prevent extremely wild oscillations.

river_kind: Option<RiverKind>

If this chunk is part of a river, this should be true. We can’t just compute this from the cross section because once a river becomes visible, we want it to stay visible until it reaches its sink.

neighbor_rivers: Vec<u32>

We also have a second record for recording any rivers in nearby chunks that manage to intersect this chunk, though this is unlikely to happen in current gameplay. This is because river areas are allowed to cross arbitrarily many chunk boundaries, if they are wide enough. In such cases we may choose to render the rivers as particularly deep in those places.

Implementations

impl RiverData

pub fn is_ocean(&self) -> bool

pub fn is_river(&self) -> bool

pub fn is_lake(&self) -> bool

pub fn near_river(&self) -> bool

pub fn near_water(&self) -> bool

Trait Implementations

impl Clone for RiverData

fn clone(&self) -> RiverData

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for RiverData

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for RiverData

fn default() -> RiverData

Returns the “default value” for a type.