Tweak rain gen; Fix seeding; Rename save->planet; Various other fixes
0c641573543d4d503e8c2d7e33b246709d7eface
This commit is contained in:
parent
39ecfb3cc2
commit
8df06365a7
GPG key ID:
2D05EFAB764D6A88
16 changed files with 1309 additions and 894 deletions
188
Cargo.lock
generated
188
Cargo.lock
generated
|
|
@ -14,9 +14,9 @@ dependencies = [
|
|||
|
||||
[[package]]
|
||||
name = "ab_glyph_rasterizer"
|
||||
version = "0.1.6"
|
||||
version = "0.1.7"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "363b9b88fad3af3be80bc8f762c9a3f9dfe906fd0327b8e92f1c12e5ae1b8bbb"
|
||||
checksum = "330223a1aecc308757b9926e9391c9b47f8ef2dbd8aea9df88312aea18c5e8d6"
|
||||
|
||||
[[package]]
|
||||
name = "ahash"
|
||||
|
|
@ -24,7 +24,7 @@ version = "0.7.6"
|
|||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "fcb51a0695d8f838b1ee009b3fbf66bda078cd64590202a864a8f3e8c4315c47"
|
||||
dependencies = [
|
||||
"getrandom 0.2.7",
|
||||
"getrandom",
|
||||
"once_cell",
|
||||
"version_check",
|
||||
]
|
||||
|
|
@ -76,9 +76,9 @@ dependencies = [
|
|||
|
||||
[[package]]
|
||||
name = "anyhow"
|
||||
version = "1.0.64"
|
||||
version = "1.0.65"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "b9a8f622bcf6ff3df478e9deba3e03e4e04b300f8e6a139e192c05fa3490afc7"
|
||||
checksum = "98161a4e3e2184da77bb14f02184cdd111e83bbbcc9979dfee3c44b9a85f5602"
|
||||
|
||||
[[package]]
|
||||
name = "approx"
|
||||
|
|
@ -697,7 +697,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
|
|||
checksum = "f6e9aa1866c1cf7ee000f281ce9e90d02d701f5c7380a107252017e58e2f5246"
|
||||
dependencies = [
|
||||
"ahash",
|
||||
"getrandom 0.2.7",
|
||||
"getrandom",
|
||||
"hashbrown",
|
||||
"instant",
|
||||
"tracing",
|
||||
|
|
@ -1210,17 +1210,6 @@ dependencies = [
|
|||
"byteorder",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "getrandom"
|
||||
version = "0.1.16"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "8fc3cb4d91f53b50155bdcfd23f6a4c39ae1969c2ae85982b135750cccaf5fce"
|
||||
dependencies = [
|
||||
"cfg-if 1.0.0",
|
||||
"libc",
|
||||
"wasi 0.9.0+wasi-snapshot-preview1",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "getrandom"
|
||||
version = "0.2.7"
|
||||
|
|
@ -1230,7 +1219,7 @@ dependencies = [
|
|||
"cfg-if 1.0.0",
|
||||
"js-sys",
|
||||
"libc",
|
||||
"wasi 0.11.0+wasi-snapshot-preview1",
|
||||
"wasi",
|
||||
"wasm-bindgen",
|
||||
]
|
||||
|
||||
|
|
@ -1449,9 +1438,9 @@ checksum = "a257582fdcde896fd96463bf2d40eefea0580021c0712a0e2b028b60b47a837a"
|
|||
|
||||
[[package]]
|
||||
name = "inplace_it"
|
||||
version = "0.3.4"
|
||||
version = "0.3.5"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "67f0347836f3f6362c1e7efdadde2b1c4b4556d211310b70631bae7eb692070b"
|
||||
checksum = "e567468c50f3d4bc7397702e09b380139f9b9288b4e909b070571007f8b5bf78"
|
||||
|
||||
[[package]]
|
||||
name = "instant"
|
||||
|
|
@ -1479,9 +1468,9 @@ checksum = "8eaf4bc02d17cbdd7ff4c7438cafcdf7fb9a4613313ad11b4f8fefe7d3fa0130"
|
|||
|
||||
[[package]]
|
||||
name = "js-sys"
|
||||
version = "0.3.59"
|
||||
version = "0.3.60"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "258451ab10b34f8af53416d1fdab72c22e805f0c92a1136d59470ec0b11138b2"
|
||||
checksum = "49409df3e3bf0856b916e2ceaca09ee28e6871cf7d9ce97a692cacfdb2a25a47"
|
||||
dependencies = [
|
||||
"wasm-bindgen",
|
||||
]
|
||||
|
|
@ -1652,16 +1641,6 @@ version = "0.2.2"
|
|||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "e1bcdd74c20ad5d95aacd60ef9ba40fdf77f767051040541df557b7a9b2a2121"
|
||||
|
||||
[[package]]
|
||||
name = "noise"
|
||||
version = "0.7.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "82051dd6745d5184c6efb7bc8be14892a7f6d4f3ad6dbf754d1c7d7d5fe24b43"
|
||||
dependencies = [
|
||||
"rand 0.7.3",
|
||||
"rand_xorshift",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "num-integer"
|
||||
version = "0.1.45"
|
||||
|
|
@ -1813,9 +1792,9 @@ dependencies = [
|
|||
|
||||
[[package]]
|
||||
name = "percent-encoding"
|
||||
version = "2.1.0"
|
||||
version = "2.2.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "d4fd5641d01c8f18a23da7b6fe29298ff4b55afcccdf78973b24cf3175fee32e"
|
||||
checksum = "478c572c3d73181ff3c2539045f6eb99e5491218eae919370993b890cdbdd98e"
|
||||
|
||||
[[package]]
|
||||
name = "petgraph"
|
||||
|
|
@ -1839,6 +1818,16 @@ version = "0.3.25"
|
|||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "1df8c4ec4b0627e53bdf214615ad287367e482558cf84b109250b37464dc03ae"
|
||||
|
||||
[[package]]
|
||||
name = "planet"
|
||||
version = "0.1.0"
|
||||
dependencies = [
|
||||
"bevy",
|
||||
"rand",
|
||||
"ron",
|
||||
"serde",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "pp-rs"
|
||||
version = "0.2.1"
|
||||
|
|
@ -1895,19 +1884,6 @@ version = "0.1.0"
|
|||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "17fd96390ed3feda12e1dfe2645ed587e0bea749e319333f104a33ff62f77a0b"
|
||||
|
||||
[[package]]
|
||||
name = "rand"
|
||||
version = "0.7.3"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "6a6b1679d49b24bbfe0c803429aa1874472f50d9b363131f0e89fc356b544d03"
|
||||
dependencies = [
|
||||
"getrandom 0.1.16",
|
||||
"libc",
|
||||
"rand_chacha 0.2.2",
|
||||
"rand_core 0.5.1",
|
||||
"rand_hc",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "rand"
|
||||
version = "0.8.5"
|
||||
|
|
@ -1915,18 +1891,8 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
|
|||
checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404"
|
||||
dependencies = [
|
||||
"libc",
|
||||
"rand_chacha 0.3.1",
|
||||
"rand_core 0.6.3",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "rand_chacha"
|
||||
version = "0.2.2"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "f4c8ed856279c9737206bf725bf36935d8666ead7aa69b52be55af369d193402"
|
||||
dependencies = [
|
||||
"ppv-lite86",
|
||||
"rand_core 0.5.1",
|
||||
"rand_chacha",
|
||||
"rand_core",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
|
|
@ -1936,43 +1902,16 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
|
|||
checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88"
|
||||
dependencies = [
|
||||
"ppv-lite86",
|
||||
"rand_core 0.6.3",
|
||||
"rand_core",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "rand_core"
|
||||
version = "0.5.1"
|
||||
version = "0.6.4"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "90bde5296fc891b0cef12a6d03ddccc162ce7b2aff54160af9338f8d40df6d19"
|
||||
checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"
|
||||
dependencies = [
|
||||
"getrandom 0.1.16",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "rand_core"
|
||||
version = "0.6.3"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "d34f1408f55294453790c48b2f1ebbb1c5b4b7563eb1f418bcfcfdbb06ebb4e7"
|
||||
dependencies = [
|
||||
"getrandom 0.2.7",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "rand_hc"
|
||||
version = "0.2.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "ca3129af7b92a17112d59ad498c6f81eaf463253766b90396d39ea7a39d6613c"
|
||||
dependencies = [
|
||||
"rand_core 0.5.1",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "rand_xorshift"
|
||||
version = "0.2.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "77d416b86801d23dde1aa643023b775c3a462efc0ed96443add11546cdf1dca8"
|
||||
dependencies = [
|
||||
"rand_core 0.5.1",
|
||||
"getrandom",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
|
|
@ -2060,17 +1999,6 @@ version = "1.0.11"
|
|||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "4501abdff3ae82a1c1b477a17252eb69cee9e66eb915c1abaa4f44d873df9f09"
|
||||
|
||||
[[package]]
|
||||
name = "save"
|
||||
version = "0.1.0"
|
||||
dependencies = [
|
||||
"bevy",
|
||||
"noise",
|
||||
"rand 0.8.5",
|
||||
"ron",
|
||||
"serde",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "scopeguard"
|
||||
version = "1.1.0"
|
||||
|
|
@ -2201,18 +2129,18 @@ dependencies = [
|
|||
|
||||
[[package]]
|
||||
name = "thiserror"
|
||||
version = "1.0.34"
|
||||
version = "1.0.35"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "8c1b05ca9d106ba7d2e31a9dab4a64e7be2cce415321966ea3132c49a656e252"
|
||||
checksum = "c53f98874615aea268107765aa1ed8f6116782501d18e53d08b471733bea6c85"
|
||||
dependencies = [
|
||||
"thiserror-impl",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "thiserror-impl"
|
||||
version = "1.0.34"
|
||||
version = "1.0.35"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "e8f2591983642de85c921015f3f070c665a197ed69e417af436115e3a1407487"
|
||||
checksum = "f8b463991b4eab2d801e724172285ec4195c650e8ec79b149e6c2a8e6dd3f783"
|
||||
dependencies = [
|
||||
"proc-macro2",
|
||||
"quote",
|
||||
|
|
@ -2324,21 +2252,21 @@ checksum = "dcf81ac59edc17cc8697ff311e8f5ef2d99fcbd9817b34cec66f90b6c3dfd987"
|
|||
|
||||
[[package]]
|
||||
name = "unicode-ident"
|
||||
version = "1.0.3"
|
||||
version = "1.0.4"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "c4f5b37a154999a8f3f98cc23a628d850e154479cd94decf3414696e12e31aaf"
|
||||
checksum = "dcc811dc4066ac62f84f11307873c4850cb653bfa9b1719cee2bd2204a4bc5dd"
|
||||
|
||||
[[package]]
|
||||
name = "unicode-width"
|
||||
version = "0.1.9"
|
||||
version = "0.1.10"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "3ed742d4ea2bd1176e236172c8429aaf54486e7ac098db29ffe6529e0ce50973"
|
||||
checksum = "c0edd1e5b14653f783770bce4a4dabb4a5108a5370a5f5d8cfe8710c361f6c8b"
|
||||
|
||||
[[package]]
|
||||
name = "unicode-xid"
|
||||
version = "0.2.3"
|
||||
version = "0.2.4"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "957e51f3646910546462e67d5f7599b9e4fb8acdd304b087a6494730f9eebf04"
|
||||
checksum = "f962df74c8c05a667b5ee8bcf162993134c104e96440b663c8daa176dc772d8c"
|
||||
|
||||
[[package]]
|
||||
name = "uuid"
|
||||
|
|
@ -2346,7 +2274,7 @@ version = "1.1.2"
|
|||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "dd6469f4314d5f1ffec476e05f17cc9a78bc7a27a6a857842170bdf8d6f98d2f"
|
||||
dependencies = [
|
||||
"getrandom 0.2.7",
|
||||
"getrandom",
|
||||
"serde",
|
||||
]
|
||||
|
||||
|
|
@ -2368,12 +2296,6 @@ version = "1.1.0"
|
|||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "9d5b2c62b4012a3e1eca5a7e077d13b3bf498c4073e33ccd58626607748ceeca"
|
||||
|
||||
[[package]]
|
||||
name = "wasi"
|
||||
version = "0.9.0+wasi-snapshot-preview1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "cccddf32554fecc6acb585f82a32a72e28b48f8c4c1883ddfeeeaa96f7d8e519"
|
||||
|
||||
[[package]]
|
||||
name = "wasi"
|
||||
version = "0.11.0+wasi-snapshot-preview1"
|
||||
|
|
@ -2382,9 +2304,9 @@ checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"
|
|||
|
||||
[[package]]
|
||||
name = "wasm-bindgen"
|
||||
version = "0.2.82"
|
||||
version = "0.2.83"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "fc7652e3f6c4706c8d9cd54832c4a4ccb9b5336e2c3bd154d5cccfbf1c1f5f7d"
|
||||
checksum = "eaf9f5aceeec8be17c128b2e93e031fb8a4d469bb9c4ae2d7dc1888b26887268"
|
||||
dependencies = [
|
||||
"cfg-if 1.0.0",
|
||||
"wasm-bindgen-macro",
|
||||
|
|
@ -2392,9 +2314,9 @@ dependencies = [
|
|||
|
||||
[[package]]
|
||||
name = "wasm-bindgen-backend"
|
||||
version = "0.2.82"
|
||||
version = "0.2.83"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "662cd44805586bd52971b9586b1df85cdbbd9112e4ef4d8f41559c334dc6ac3f"
|
||||
checksum = "4c8ffb332579b0557b52d268b91feab8df3615f265d5270fec2a8c95b17c1142"
|
||||
dependencies = [
|
||||
"bumpalo",
|
||||
"log",
|
||||
|
|
@ -2407,9 +2329,9 @@ dependencies = [
|
|||
|
||||
[[package]]
|
||||
name = "wasm-bindgen-futures"
|
||||
version = "0.4.32"
|
||||
version = "0.4.33"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "fa76fb221a1f8acddf5b54ace85912606980ad661ac7a503b4570ffd3a624dad"
|
||||
checksum = "23639446165ca5a5de86ae1d8896b737ae80319560fbaa4c2887b7da6e7ebd7d"
|
||||
dependencies = [
|
||||
"cfg-if 1.0.0",
|
||||
"js-sys",
|
||||
|
|
@ -2419,9 +2341,9 @@ dependencies = [
|
|||
|
||||
[[package]]
|
||||
name = "wasm-bindgen-macro"
|
||||
version = "0.2.82"
|
||||
version = "0.2.83"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "b260f13d3012071dfb1512849c033b1925038373aea48ced3012c09df952c602"
|
||||
checksum = "052be0f94026e6cbc75cdefc9bae13fd6052cdcaf532fa6c45e7ae33a1e6c810"
|
||||
dependencies = [
|
||||
"quote",
|
||||
"wasm-bindgen-macro-support",
|
||||
|
|
@ -2429,9 +2351,9 @@ dependencies = [
|
|||
|
||||
[[package]]
|
||||
name = "wasm-bindgen-macro-support"
|
||||
version = "0.2.82"
|
||||
version = "0.2.83"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "5be8e654bdd9b79216c2929ab90721aa82faf65c48cdf08bdc4e7f51357b80da"
|
||||
checksum = "07bc0c051dc5f23e307b13285f9d75df86bfdf816c5721e573dec1f9b8aa193c"
|
||||
dependencies = [
|
||||
"proc-macro2",
|
||||
"quote",
|
||||
|
|
@ -2442,15 +2364,15 @@ dependencies = [
|
|||
|
||||
[[package]]
|
||||
name = "wasm-bindgen-shared"
|
||||
version = "0.2.82"
|
||||
version = "0.2.83"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "6598dd0bd3c7d51095ff6531a5b23e02acdc81804e30d8f07afb77b7215a140a"
|
||||
checksum = "1c38c045535d93ec4f0b4defec448e4291638ee608530863b1e2ba115d4fff7f"
|
||||
|
||||
[[package]]
|
||||
name = "web-sys"
|
||||
version = "0.3.59"
|
||||
version = "0.3.60"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "ed055ab27f941423197eb86b2035720b1a3ce40504df082cac2ecc6ed73335a1"
|
||||
checksum = "bcda906d8be16e728fd5adc5b729afad4e444e106ab28cd1c7256e54fa61510f"
|
||||
dependencies = [
|
||||
"js-sys",
|
||||
"wasm-bindgen",
|
||||
|
|
@ -2657,7 +2579,7 @@ version = "0.1.0"
|
|||
dependencies = [
|
||||
"bevy",
|
||||
"bevy_pancam",
|
||||
"save",
|
||||
"planet",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
|
|
|
|||
|
|
@ -5,13 +5,13 @@ edition = "2021"
|
|||
resolver = "2"
|
||||
|
||||
[features]
|
||||
debug = ["save/debug"]
|
||||
debug = ["planet/debug"]
|
||||
planet_view = ["render"]
|
||||
render = ["bevy/bevy_asset", "bevy/bevy_winit", "bevy/render", "save/render", "dep:bevy_pancam"]
|
||||
render = ["bevy/bevy_asset", "bevy/bevy_winit", "bevy/render", "planet/render", "dep:bevy_pancam"]
|
||||
default = ["render", "debug"]
|
||||
|
||||
[dependencies.save]
|
||||
path = "save"
|
||||
[dependencies.planet]
|
||||
path = "planet"
|
||||
default-features = false
|
||||
|
||||
[dependencies.bevy]
|
||||
|
|
|
|||
File diff suppressed because one or more lines are too long
0
save/.gitignore → planet/.gitignore
vendored
0
save/.gitignore → planet/.gitignore
vendored
|
|
@ -1,5 +1,5 @@
|
|||
[package]
|
||||
name = "save"
|
||||
name = "planet"
|
||||
version = "0.1.0"
|
||||
edition = "2021"
|
||||
|
||||
|
|
@ -8,10 +8,6 @@ debug = []
|
|||
render = ["bevy/render"]
|
||||
default = ["render", "debug"]
|
||||
|
||||
[dependencies.noise]
|
||||
version = "0.7.0"
|
||||
default-features = false
|
||||
|
||||
[dependencies.rand]
|
||||
version = "0.8.5"
|
||||
|
||||
|
|
@ -38,3 +38,5 @@ pub mod world_manager;
|
|||
pub use world_manager::*;
|
||||
pub mod math_util;
|
||||
pub use math_util::*;
|
||||
pub mod perlin;
|
||||
pub mod saving;
|
||||
|
|
@ -5,7 +5,7 @@ use std::{
|
|||
};
|
||||
|
||||
use bevy::math::Vec3A;
|
||||
use rand::Rng;
|
||||
use rand::{rngs::StdRng, Rng};
|
||||
|
||||
#[derive(Debug, Copy, Clone)]
|
||||
pub enum CartesianError {
|
||||
|
|
@ -34,11 +34,14 @@ impl Display for CartesianError {
|
|||
}
|
||||
}
|
||||
|
||||
pub fn cartesian_coordinates(alpha: f32, beta: f32, radius: f32) -> Result<Vec3A, CartesianError> {
|
||||
pub fn cartesian_coordinates(
|
||||
alpha: f32,
|
||||
mut beta: f32,
|
||||
radius: f32,
|
||||
) -> Result<Vec3A, CartesianError> {
|
||||
if alpha < 0.0 || alpha > PI {
|
||||
return Err(CartesianError::InvalidAlpha(alpha));
|
||||
}
|
||||
let mut beta = beta.clone();
|
||||
|
||||
if beta < 0.0 {
|
||||
while beta < 0.0 {
|
||||
|
|
@ -57,17 +60,28 @@ pub fn cartesian_coordinates(alpha: f32, beta: f32, radius: f32) -> Result<Vec3A
|
|||
))
|
||||
}
|
||||
|
||||
pub fn random_point_in_sphere(radius: f32) -> Vec3A {
|
||||
let mut rng = rand::thread_rng();
|
||||
let x = rng.gen_range(-radius..radius);
|
||||
let y = rng.gen_range(-radius..radius);
|
||||
let z = rng.gen_range(-radius..radius);
|
||||
if x == 0.0 && y == 0.0 && z == 0.0 {
|
||||
return Vec3A::ZERO;
|
||||
}
|
||||
let mult = 1.0 / (x * x + y * y + z * z).sqrt();
|
||||
pub fn random_point_in_sphere(rng: &mut StdRng, radius: f32) -> Vec3A {
|
||||
// https://karthikkaranth.me/blog/generating-random-points-in-a-sphere/#better-choice-of-spherical-coordinates
|
||||
|
||||
Vec3A::new(mult * x, mult * y, mult * z)
|
||||
let u = rng.gen_range(0.0..1.0);
|
||||
let v = rng.gen_range(0.0..1.0);
|
||||
|
||||
let theta = u * TAU;
|
||||
let phi = f32::acos(2.0 * v - 1.0);
|
||||
|
||||
let r = f32::cbrt(rng.gen_range(0.0..radius));
|
||||
|
||||
let sin_theta = f32::sin(theta);
|
||||
let cos_theta = f32::cos(theta);
|
||||
|
||||
let sin_phi = f32::sin(phi);
|
||||
let cos_phi = f32::cos(phi);
|
||||
|
||||
Vec3A::new(
|
||||
r * sin_phi * cos_theta,
|
||||
r * sin_phi * sin_theta,
|
||||
r * cos_phi,
|
||||
)
|
||||
}
|
||||
|
||||
pub fn mix_values(a: f32, b: f32, weight_b: f32) -> f32 {
|
||||
95
planet/src/perlin.rs
Normal file
95
planet/src/perlin.rs
Normal file
|
|
@ -0,0 +1,95 @@
|
|||
const PERMUTATION: [u8; 256] = [
|
||||
151, 160, 137, 91, 90, 15, 131, 13, 201, 95, 96, 53, 194, 233, 7, 225, 140, 36, 103, 30, 69,
|
||||
142, 8, 99, 37, 240, 21, 10, 23, 190, 6, 148, 247, 120, 234, 75, 0, 26, 197, 62, 94, 252, 219,
|
||||
203, 117, 35, 11, 32, 57, 177, 33, 88, 237, 149, 56, 87, 174, 20, 125, 136, 171, 168, 68, 175,
|
||||
74, 165, 71, 134, 139, 48, 27, 166, 77, 146, 158, 231, 83, 111, 229, 122, 60, 211, 133, 230,
|
||||
220, 105, 92, 41, 55, 46, 245, 40, 244, 102, 143, 54, 65, 25, 63, 161, 1, 216, 80, 73, 209, 76,
|
||||
132, 187, 208, 89, 18, 169, 200, 196, 135, 130, 116, 188, 159, 86, 164, 100, 109, 198, 173,
|
||||
186, 3, 64, 52, 217, 226, 250, 124, 123, 5, 202, 38, 147, 118, 126, 255, 82, 85, 212, 207, 206,
|
||||
59, 227, 47, 16, 58, 17, 182, 189, 28, 42, 223, 183, 170, 213, 119, 248, 152, 2, 44, 154, 163,
|
||||
70, 221, 153, 101, 155, 167, 43, 172, 9, 129, 22, 39, 253, 19, 98, 108, 110, 79, 113, 224, 232,
|
||||
178, 185, 112, 104, 218, 246, 97, 228, 251, 34, 242, 193, 238, 210, 144, 12, 191, 179, 162,
|
||||
241, 81, 51, 145, 235, 249, 14, 239, 107, 49, 192, 214, 31, 181, 199, 106, 157, 184, 84, 204,
|
||||
176, 115, 121, 50, 45, 127, 4, 150, 254, 138, 236, 205, 93, 222, 114, 67, 29, 24, 72, 243, 141,
|
||||
128, 195, 78, 66, 215, 61, 156, 180,
|
||||
];
|
||||
|
||||
pub fn get_value(x: f32, y: f32, z: f32) -> f32 {
|
||||
let p = [PERMUTATION, PERMUTATION].concat();
|
||||
|
||||
let fx: i32 = f32::floor(x) as i32;
|
||||
let fy: i32 = f32::floor(y) as i32;
|
||||
let fz: i32 = f32::floor(z) as i32;
|
||||
|
||||
let xb: usize = (fx & 255) as usize;
|
||||
let yb: usize = (fy & 255) as usize;
|
||||
let zb: usize = (fz & 255) as usize;
|
||||
|
||||
let x = x - f32::floor(x);
|
||||
let y = y - f32::floor(y);
|
||||
let z = z - f32::floor(z);
|
||||
|
||||
let u = fade(x);
|
||||
let v = fade(y);
|
||||
let w = fade(z);
|
||||
|
||||
let a = p[xb] as usize + yb;
|
||||
let aa = p[a] as usize + zb;
|
||||
let ab = p[a + 1] as usize + zb;
|
||||
|
||||
let b = p[xb + 1] as usize + yb;
|
||||
let ba = p[b] as usize + zb;
|
||||
let bb = p[b + 1] as usize + zb;
|
||||
|
||||
scale(lerp(
|
||||
w,
|
||||
lerp(
|
||||
v,
|
||||
lerp(u, grad(p[aa], x, y, z), grad(p[ba], x - 1.0, y, z)),
|
||||
lerp(
|
||||
u,
|
||||
grad(p[ab], x, y - 1.0, z),
|
||||
grad(p[bb], x - 1.0, y - 1.0, z),
|
||||
),
|
||||
),
|
||||
lerp(
|
||||
v,
|
||||
lerp(
|
||||
u,
|
||||
grad(p[aa + 1], x, y, z - 1.0),
|
||||
grad(p[ba + 1], x - 1.0, y, z - 1.0),
|
||||
),
|
||||
lerp(
|
||||
u,
|
||||
grad(p[ab + 1], x, y - 1.0, z - 1.0),
|
||||
grad(p[bb + 1], x - 1.0, y - 1.0, z - 1.0),
|
||||
),
|
||||
),
|
||||
))
|
||||
}
|
||||
|
||||
fn fade(t: f32) -> f32 {
|
||||
t * t * t * (t * (t * 6.0 - 15.0) + 10.0)
|
||||
}
|
||||
|
||||
fn grad(hash: u8, x: f32, y: f32, z: f32) -> f32 {
|
||||
let h = hash & 15;
|
||||
let u = if h < 8 { x } else { y };
|
||||
let v = if h < 4 {
|
||||
y
|
||||
} else if (h == 12) || (h == 14) {
|
||||
x
|
||||
} else {
|
||||
z
|
||||
};
|
||||
|
||||
(if h & 1 == 0 { u } else { -u }) + (if h & 2 == 0 { v } else { -v })
|
||||
}
|
||||
|
||||
fn lerp(t: f32, a: f32, b: f32) -> f32 {
|
||||
a + t * (b - a)
|
||||
}
|
||||
|
||||
fn scale(n: f32) -> f32 {
|
||||
(1.0 + n) / 2.0
|
||||
}
|
||||
255
planet/src/saving.rs
Normal file
255
planet/src/saving.rs
Normal file
|
|
@ -0,0 +1,255 @@
|
|||
use std::fmt::{self, Formatter};
|
||||
|
||||
use rand::{rngs::StdRng, SeedableRng};
|
||||
use serde::{
|
||||
de::{Error, MapAccess, SeqAccess, Visitor},
|
||||
Deserialize,
|
||||
};
|
||||
|
||||
use crate::{TerrainCell, World};
|
||||
|
||||
struct WorldTerrainAttributes {
|
||||
max_altitude: f32,
|
||||
min_altitude: f32,
|
||||
max_rainfall: f32,
|
||||
min_rainfall: f32,
|
||||
max_temperature: f32,
|
||||
min_temperature: f32,
|
||||
}
|
||||
impl Default for WorldTerrainAttributes {
|
||||
fn default() -> Self {
|
||||
Self {
|
||||
max_altitude: World::MIN_ALTITUDE,
|
||||
min_altitude: World::MAX_ALTITUDE,
|
||||
max_rainfall: World::MIN_RAINFALL,
|
||||
min_rainfall: World::MAX_RAINFALL,
|
||||
max_temperature: World::MIN_TEMPERATURE,
|
||||
min_temperature: World::MAX_TEMPERATURE,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<'de> Deserialize<'de> for World {
|
||||
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
|
||||
where
|
||||
D: serde::Deserializer<'de>,
|
||||
{
|
||||
#[derive(Deserialize)]
|
||||
#[serde(field_identifier, rename_all = "snake_case")]
|
||||
enum Field {
|
||||
Width,
|
||||
Height,
|
||||
Seed,
|
||||
Terrain,
|
||||
ContinentOffsets,
|
||||
ContinentWidths,
|
||||
}
|
||||
|
||||
struct WorldVisitor;
|
||||
|
||||
impl<'de> Visitor<'de> for WorldVisitor {
|
||||
type Value = World;
|
||||
|
||||
fn expecting(&self, formatter: &mut Formatter<'_>) -> fmt::Result {
|
||||
formatter.write_str("struct World")
|
||||
}
|
||||
|
||||
fn visit_seq<V>(self, mut seq: V) -> Result<Self::Value, V::Error>
|
||||
where
|
||||
V: SeqAccess<'de>,
|
||||
{
|
||||
let width = seq
|
||||
.next_element()?
|
||||
.ok_or_else(|| Error::invalid_length(0, &self))?;
|
||||
|
||||
let height = seq
|
||||
.next_element()?
|
||||
.ok_or_else(|| Error::invalid_length(0, &self))?;
|
||||
|
||||
let seed = seq
|
||||
.next_element()?
|
||||
.ok_or_else(|| Error::invalid_length(0, &self))?;
|
||||
|
||||
let terrain: Vec<Vec<TerrainCell>> = seq
|
||||
.next_element()?
|
||||
.ok_or_else(|| Error::invalid_length(0, &self))?;
|
||||
|
||||
let continent_offsets = seq
|
||||
.next_element()?
|
||||
.ok_or_else(|| Error::invalid_length(0, &self))?;
|
||||
|
||||
let continent_widths = seq
|
||||
.next_element()?
|
||||
.ok_or_else(|| Error::invalid_length(0, &self))?;
|
||||
|
||||
let world_attributes = &mut WorldTerrainAttributes::default();
|
||||
let world_attributes =
|
||||
terrain
|
||||
.iter()
|
||||
.flatten()
|
||||
.fold(world_attributes, |attributes, cell| {
|
||||
if cell.altitude > attributes.max_altitude {
|
||||
attributes.max_altitude = cell.altitude;
|
||||
}
|
||||
if cell.altitude < attributes.min_altitude {
|
||||
attributes.min_altitude = cell.altitude;
|
||||
}
|
||||
|
||||
if cell.rainfall > attributes.max_rainfall {
|
||||
attributes.max_rainfall = cell.rainfall;
|
||||
}
|
||||
if cell.rainfall < attributes.min_rainfall {
|
||||
attributes.min_rainfall = cell.rainfall;
|
||||
}
|
||||
|
||||
if cell.temperature > attributes.max_temperature {
|
||||
attributes.max_temperature = cell.temperature;
|
||||
}
|
||||
if cell.temperature < attributes.min_temperature {
|
||||
attributes.min_temperature = cell.temperature;
|
||||
}
|
||||
attributes
|
||||
});
|
||||
|
||||
Ok(World {
|
||||
width,
|
||||
height,
|
||||
seed,
|
||||
terrain,
|
||||
continent_offsets,
|
||||
continent_widths,
|
||||
|
||||
max_altitude: world_attributes.max_altitude,
|
||||
min_altitude: world_attributes.min_altitude,
|
||||
max_rainfall: world_attributes.max_rainfall,
|
||||
min_rainfall: world_attributes.min_rainfall,
|
||||
max_temperature: world_attributes.max_temperature,
|
||||
min_temperature: world_attributes.min_temperature,
|
||||
|
||||
rng: StdRng::seed_from_u64(seed as u64),
|
||||
})
|
||||
}
|
||||
|
||||
fn visit_map<V>(self, mut map: V) -> Result<Self::Value, V::Error>
|
||||
where
|
||||
V: MapAccess<'de>,
|
||||
{
|
||||
let mut width = None;
|
||||
let mut height = None;
|
||||
let mut seed = None;
|
||||
let mut terrain = None;
|
||||
let mut continent_offsets = None;
|
||||
let mut continent_widths = None;
|
||||
|
||||
while let Some(key) = map.next_key()? {
|
||||
match key {
|
||||
Field::Width => {
|
||||
if width.is_some() {
|
||||
return Err(Error::duplicate_field("width"));
|
||||
}
|
||||
width = Some(map.next_value()?);
|
||||
}
|
||||
Field::Height => {
|
||||
if height.is_some() {
|
||||
return Err(Error::duplicate_field("height"));
|
||||
}
|
||||
height = Some(map.next_value()?);
|
||||
}
|
||||
Field::Seed => {
|
||||
if seed.is_some() {
|
||||
return Err(Error::duplicate_field("seed"));
|
||||
}
|
||||
seed = Some(map.next_value()?);
|
||||
}
|
||||
Field::Terrain => {
|
||||
if terrain.is_some() {
|
||||
return Err(Error::duplicate_field("terrain"));
|
||||
}
|
||||
terrain = Some(map.next_value()?);
|
||||
}
|
||||
Field::ContinentOffsets => {
|
||||
if continent_offsets.is_some() {
|
||||
return Err(Error::duplicate_field("continent_offsets"));
|
||||
}
|
||||
continent_offsets = Some(map.next_value()?);
|
||||
}
|
||||
Field::ContinentWidths => {
|
||||
if continent_widths.is_some() {
|
||||
return Err(Error::duplicate_field("continent_widths"));
|
||||
}
|
||||
continent_widths = Some(map.next_value()?);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
let width = width.ok_or_else(|| Error::missing_field("width"))?;
|
||||
let height = height.ok_or_else(|| Error::missing_field("height"))?;
|
||||
let seed = seed.ok_or_else(|| Error::missing_field("seed"))?;
|
||||
let terrain: Vec<Vec<TerrainCell>> =
|
||||
terrain.ok_or_else(|| Error::missing_field("terrain"))?;
|
||||
let continent_offsets =
|
||||
continent_offsets.ok_or_else(|| Error::missing_field("continent_offsets"))?;
|
||||
let continent_widths =
|
||||
continent_widths.ok_or_else(|| Error::missing_field("continent_widths"))?;
|
||||
|
||||
let world_attributes = &mut WorldTerrainAttributes::default();
|
||||
let world_attributes =
|
||||
terrain
|
||||
.iter()
|
||||
.flatten()
|
||||
.fold(world_attributes, |attributes, cell| {
|
||||
if cell.altitude > attributes.max_altitude {
|
||||
attributes.max_altitude = cell.altitude;
|
||||
}
|
||||
if cell.altitude < attributes.min_altitude {
|
||||
attributes.min_altitude = cell.altitude;
|
||||
}
|
||||
|
||||
if cell.rainfall > attributes.max_rainfall {
|
||||
attributes.max_rainfall = cell.rainfall;
|
||||
}
|
||||
if cell.rainfall < attributes.min_rainfall {
|
||||
attributes.min_rainfall = cell.rainfall;
|
||||
}
|
||||
|
||||
if cell.temperature > attributes.max_temperature {
|
||||
attributes.max_temperature = cell.temperature;
|
||||
}
|
||||
if cell.temperature < attributes.min_temperature {
|
||||
attributes.min_temperature = cell.temperature;
|
||||
}
|
||||
attributes
|
||||
});
|
||||
|
||||
Ok(World {
|
||||
width,
|
||||
height,
|
||||
seed,
|
||||
terrain,
|
||||
continent_offsets,
|
||||
continent_widths,
|
||||
|
||||
max_altitude: world_attributes.max_altitude,
|
||||
min_altitude: world_attributes.min_altitude,
|
||||
max_rainfall: world_attributes.max_rainfall,
|
||||
min_rainfall: world_attributes.min_rainfall,
|
||||
max_temperature: world_attributes.max_temperature,
|
||||
min_temperature: world_attributes.min_temperature,
|
||||
|
||||
rng: StdRng::seed_from_u64(seed as u64),
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
const FIELDS: &'static [&'static str] = &[
|
||||
"width",
|
||||
"height",
|
||||
"seed",
|
||||
"terrain",
|
||||
"continent_offsets",
|
||||
"continent_widths",
|
||||
];
|
||||
|
||||
deserializer.deserialize_struct("World", FIELDS, WorldVisitor)
|
||||
}
|
||||
}
|
||||
427
planet/src/world.rs
Normal file
427
planet/src/world.rs
Normal file
|
|
@ -0,0 +1,427 @@
|
|||
use serde::{Deserialize, Serialize};
|
||||
use std::{
|
||||
error::Error,
|
||||
f32::consts::{PI, TAU},
|
||||
fmt::{Debug, Display},
|
||||
};
|
||||
|
||||
// TODO: Logging doesn't seem to work here? Figure out why and fix
|
||||
|
||||
use crate::perlin;
|
||||
use bevy::{log::info, math::Vec3A, prelude::Vec2, utils::default};
|
||||
use rand::{rngs::StdRng, Rng, SeedableRng};
|
||||
|
||||
use crate::{cartesian_coordinates, mix_values, random_point_in_sphere, CartesianError, RepeatNum};
|
||||
|
||||
#[derive(Debug, Clone, Copy)]
|
||||
pub enum WorldGenError {
|
||||
CartesianError(CartesianError),
|
||||
}
|
||||
impl Error for WorldGenError {
|
||||
fn source(&self) -> Option<&(dyn Error + 'static)> {
|
||||
match *self {
|
||||
WorldGenError::CartesianError(ref e) => Some(e),
|
||||
}
|
||||
}
|
||||
|
||||
fn description(&self) -> &str {
|
||||
"description() is deprecated; use Display"
|
||||
}
|
||||
|
||||
fn cause(&self) -> Option<&dyn Error> {
|
||||
self.source()
|
||||
}
|
||||
}
|
||||
impl Display for WorldGenError {
|
||||
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
||||
match self {
|
||||
WorldGenError::CartesianError(err) => Display::fmt(err, f),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug, Serialize)]
|
||||
pub struct World {
|
||||
pub width: u32,
|
||||
pub height: u32,
|
||||
pub seed: u32,
|
||||
|
||||
pub terrain: Vec<Vec<TerrainCell>>,
|
||||
pub continent_offsets: [Vec2; World::NUM_CONTINENTS as usize],
|
||||
pub continent_widths: [f32; World::NUM_CONTINENTS as usize],
|
||||
#[serde(skip)]
|
||||
pub max_altitude: f32,
|
||||
#[serde(skip)]
|
||||
pub min_altitude: f32,
|
||||
#[serde(skip)]
|
||||
pub max_rainfall: f32,
|
||||
#[serde(skip)]
|
||||
pub min_rainfall: f32,
|
||||
#[serde(skip)]
|
||||
pub max_temperature: f32,
|
||||
#[serde(skip)]
|
||||
pub min_temperature: f32,
|
||||
#[serde(skip)]
|
||||
pub rng: StdRng,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
|
||||
pub struct Biome {
|
||||
pub altitude: f32,
|
||||
pub rainfall: f32,
|
||||
pub temperature: f32,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
|
||||
pub struct TerrainCell {
|
||||
pub altitude: f32,
|
||||
pub rainfall: f32,
|
||||
pub temperature: f32,
|
||||
|
||||
#[serde(skip)]
|
||||
pub rain_accumulated: f32,
|
||||
#[serde(skip)]
|
||||
pub previous_rain_accumulated: f32,
|
||||
}
|
||||
|
||||
impl World {
|
||||
pub fn new(width: u32, height: u32, seed: u32) -> World {
|
||||
World {
|
||||
width,
|
||||
height,
|
||||
seed,
|
||||
terrain: vec![
|
||||
vec![TerrainCell::default(); width.try_into().unwrap()];
|
||||
height.try_into().unwrap()
|
||||
],
|
||||
continent_offsets: [default(); World::NUM_CONTINENTS as usize],
|
||||
continent_widths: [default(); World::NUM_CONTINENTS as usize],
|
||||
max_altitude: World::MIN_ALTITUDE,
|
||||
min_altitude: World::MAX_ALTITUDE,
|
||||
max_rainfall: World::MIN_RAINFALL,
|
||||
min_rainfall: World::MAX_RAINFALL,
|
||||
max_temperature: World::MIN_TEMPERATURE,
|
||||
min_temperature: World::MAX_TEMPERATURE,
|
||||
rng: StdRng::seed_from_u64(seed as u64),
|
||||
}
|
||||
}
|
||||
|
||||
pub const NUM_CONTINENTS: u8 = 7;
|
||||
pub const CONTINENT_FACTOR: f32 = 0.75;
|
||||
pub const CONTINENT_MIN_WIDTH_FACTOR: f32 = 3.0;
|
||||
pub const CONTINENT_MAX_WIDTH_FACTOR: f32 = 7.0;
|
||||
|
||||
pub const MIN_ALTITUDE: f32 = -10000.0;
|
||||
pub const MAX_ALTITUDE: f32 = 10000.0;
|
||||
pub const ALTITUDE_SPAN: f32 = World::MAX_ALTITUDE - World::MIN_ALTITUDE;
|
||||
|
||||
pub const MOUNTAIN_RANGE_MIX_FACTOR: f32 = 0.075;
|
||||
pub const MOUNTAIN_RANGE_WIDTH_FACTOR: f32 = 25.0;
|
||||
|
||||
pub const TERRAIN_NOISE_FACTOR_1: f32 = 0.2;
|
||||
pub const TERRAIN_NOISE_FACTOR_2: f32 = 0.15;
|
||||
pub const TERRAIN_NOISE_FACTOR_3: f32 = 0.1;
|
||||
|
||||
pub const MIN_RAINFALL: f32 = 0.0;
|
||||
pub const MAX_RAINFALL: f32 = 5000.0;
|
||||
pub const RAINFALL_SPAN: f32 = World::MAX_RAINFALL - World::MIN_RAINFALL;
|
||||
pub const RAINFALL_ALTITUDE_FACTOR: f32 = 1.0;
|
||||
pub const RAINFALL_DRYNESS_FACTOR: f32 = 0.001;
|
||||
pub const RAINFALL_DRYNESS_OFFSET: f32 = World::RAINFALL_DRYNESS_FACTOR * World::MAX_RAINFALL;
|
||||
|
||||
pub const MIN_TEMPERATURE: f32 = -50.0;
|
||||
pub const MAX_TEMPERATURE: f32 = 30.0;
|
||||
pub const TEMPERATURE_SPAN: f32 = World::MAX_TEMPERATURE - World::MIN_RAINFALL;
|
||||
pub const TEMPERATURE_ALTITUDE_FACTOR: f32 = 1.0;
|
||||
|
||||
pub fn generate(&mut self) -> Result<(), WorldGenError> {
|
||||
if let Err(err) = self.generate_altitude() {
|
||||
return Err(WorldGenError::CartesianError(err));
|
||||
}
|
||||
if let Err(err) = self.generate_rainfall() {
|
||||
return Err(WorldGenError::CartesianError(err));
|
||||
}
|
||||
if let Err(err) = self.generate_temperature() {
|
||||
return Err(WorldGenError::CartesianError(err));
|
||||
}
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn generate_continents(&mut self) {
|
||||
info!("Generating continents");
|
||||
let width = self.width as f32;
|
||||
let height = self.height as f32;
|
||||
|
||||
for i in 0..World::NUM_CONTINENTS {
|
||||
info!("{}/{}", i, World::NUM_CONTINENTS);
|
||||
|
||||
self.continent_offsets[i as usize].x = self
|
||||
.rng
|
||||
.gen_range(width * i as f32 * 2.0 / 5.0..(width * (i as f32 + 2.0) * 2.0 / 5.0))
|
||||
.repeat(width);
|
||||
self.continent_offsets[i as usize].y =
|
||||
self.rng.gen_range(height * 1.0 / 6.0..height * 5.0 / 6.0);
|
||||
|
||||
self.continent_widths[i as usize] = self
|
||||
.rng
|
||||
.gen_range(World::CONTINENT_MIN_WIDTH_FACTOR..World::CONTINENT_MAX_WIDTH_FACTOR);
|
||||
}
|
||||
info!("Done generating continents");
|
||||
}
|
||||
|
||||
fn continent_modifier(&self, x: usize, y: usize) -> f32 {
|
||||
let x = x as f32;
|
||||
let y = y as f32;
|
||||
let width = self.width as f32;
|
||||
let height = self.height as f32;
|
||||
|
||||
let mut max_value = 0.0;
|
||||
let beta_factor = f32::sin(PI * y / height);
|
||||
|
||||
for i in 0..World::NUM_CONTINENTS {
|
||||
let idx = i as usize;
|
||||
let Vec2 {
|
||||
x: continent_x,
|
||||
y: continent_y,
|
||||
} = self.continent_offsets[idx];
|
||||
|
||||
let distance_x = f32::min(
|
||||
f32::min(f32::abs(continent_x - x), f32::abs(width + continent_x - x)),
|
||||
f32::abs(continent_x - x - width),
|
||||
) * beta_factor;
|
||||
|
||||
let distance_y = f32::abs(continent_y - y);
|
||||
|
||||
let distance = f32::sqrt((distance_x * distance_x) + (distance_y * distance_y));
|
||||
|
||||
let value = f32::max(0.0, 1.0 - self.continent_widths[idx] * distance / width);
|
||||
|
||||
if value > max_value {
|
||||
max_value = value;
|
||||
}
|
||||
}
|
||||
|
||||
max_value
|
||||
}
|
||||
|
||||
fn generate_altitude(&mut self) -> Result<(), CartesianError> {
|
||||
info!("Generating altitude");
|
||||
self.generate_continents();
|
||||
|
||||
const RADIUS_1: f32 = 0.5;
|
||||
const RADIUS_2: f32 = 4.0;
|
||||
const RADIUS_3: f32 = 4.0;
|
||||
const RADIUS_4: f32 = 8.0;
|
||||
const RADIUS_5: f32 = 16.0;
|
||||
|
||||
let offset_1 = World::random_offset_vector(&mut self.rng);
|
||||
let offset_2 = World::random_offset_vector(&mut self.rng);
|
||||
let offset_3 = World::random_offset_vector(&mut self.rng);
|
||||
let offset_4 = World::random_offset_vector(&mut self.rng);
|
||||
let offset_5 = World::random_offset_vector(&mut self.rng);
|
||||
|
||||
for y in 0..self.terrain.len() {
|
||||
let alpha = (y as f32 / self.height as f32) * PI;
|
||||
|
||||
for x in 0..self.terrain[y].len() {
|
||||
let beta = (x as f32 / self.width as f32) * TAU;
|
||||
|
||||
let value_1 =
|
||||
self.random_noise_from_polar_coordinates(alpha, beta, RADIUS_1, offset_1)?;
|
||||
let value_2 =
|
||||
self.random_noise_from_polar_coordinates(alpha, beta, RADIUS_2, offset_2)?;
|
||||
let value_3 =
|
||||
self.random_noise_from_polar_coordinates(alpha, beta, RADIUS_3, offset_3)?;
|
||||
let value_4 =
|
||||
self.random_noise_from_polar_coordinates(alpha, beta, RADIUS_4, offset_4)?;
|
||||
let value_5 =
|
||||
self.random_noise_from_polar_coordinates(alpha, beta, RADIUS_5, offset_5)?;
|
||||
|
||||
let value_a = mix_values(
|
||||
self.continent_modifier(x, y),
|
||||
value_3,
|
||||
World::TERRAIN_NOISE_FACTOR_1,
|
||||
) * mix_values(1.0, value_4, World::TERRAIN_NOISE_FACTOR_2)
|
||||
* mix_values(1.0, value_5, World::TERRAIN_NOISE_FACTOR_3);
|
||||
|
||||
let value_b = value_a * 0.04 + 0.48;
|
||||
|
||||
let value_c = mix_values(
|
||||
self.mountain_range_noise_from_random_noise(mix_values(
|
||||
value_1,
|
||||
value_2,
|
||||
World::MOUNTAIN_RANGE_MIX_FACTOR,
|
||||
)),
|
||||
value_3,
|
||||
World::TERRAIN_NOISE_FACTOR_1 * 1.5,
|
||||
) * mix_values(1.0, value_4, World::TERRAIN_NOISE_FACTOR_2 * 1.5)
|
||||
* mix_values(1.0, value_5, World::TERRAIN_NOISE_FACTOR_3 * 1.5);
|
||||
|
||||
let mut value_d = mix_values(value_a, value_c, 0.25);
|
||||
value_d = mix_values(value_d, value_c, 0.1);
|
||||
value_d = mix_values(value_d, value_b, 0.1);
|
||||
|
||||
let altitude = World::calculate_altitude(value_d);
|
||||
self.terrain[y][x].altitude = altitude;
|
||||
|
||||
if altitude > self.max_altitude {
|
||||
self.max_altitude = altitude;
|
||||
}
|
||||
if altitude < self.min_altitude {
|
||||
self.min_altitude = altitude;
|
||||
}
|
||||
}
|
||||
}
|
||||
info!("Done generating altitude");
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn random_offset_vector(rng: &mut StdRng) -> Vec3A {
|
||||
random_point_in_sphere(rng, 1000.0)
|
||||
}
|
||||
|
||||
fn random_noise_from_polar_coordinates(
|
||||
&self,
|
||||
alpha: f32,
|
||||
beta: f32,
|
||||
radius: f32,
|
||||
offset: Vec3A,
|
||||
) -> Result<f32, CartesianError> {
|
||||
let cartesian = cartesian_coordinates(alpha, beta, radius)?;
|
||||
Ok(perlin::get_value(
|
||||
cartesian.x + offset.x,
|
||||
cartesian.y + offset.y,
|
||||
cartesian.z + offset.z,
|
||||
))
|
||||
}
|
||||
|
||||
fn mountain_range_noise_from_random_noise(&self, noise: f32) -> f32 {
|
||||
let noise = noise * 2.0 - 1.0;
|
||||
|
||||
let value_1 = -f32::exp(-f32::powi(
|
||||
noise * World::MOUNTAIN_RANGE_WIDTH_FACTOR + 1.0,
|
||||
2,
|
||||
));
|
||||
let value_2 = f32::exp(-f32::powi(
|
||||
noise * World::MOUNTAIN_RANGE_WIDTH_FACTOR - 1.0,
|
||||
2,
|
||||
));
|
||||
let value_3 = -f32::exp(-f32::powi(
|
||||
noise * World::MOUNTAIN_RANGE_WIDTH_FACTOR + World::MOUNTAIN_RANGE_WIDTH_FACTOR / 2.0,
|
||||
2,
|
||||
));
|
||||
let value_4 = f32::exp(-f32::powi(
|
||||
noise * World::MOUNTAIN_RANGE_WIDTH_FACTOR - World::MOUNTAIN_RANGE_WIDTH_FACTOR / 2.0,
|
||||
2,
|
||||
));
|
||||
|
||||
(value_1 + value_2 + value_3 + value_4 + 1.0) / 2.0
|
||||
}
|
||||
|
||||
fn calculate_altitude(raw_altitude: f32) -> f32 {
|
||||
World::MIN_ALTITUDE + (raw_altitude * World::ALTITUDE_SPAN)
|
||||
}
|
||||
|
||||
fn generate_rainfall(&mut self) -> Result<(), CartesianError> {
|
||||
info!("Generating rainfall");
|
||||
// let offset = World::random_offset_vector(&mut self.rng);
|
||||
|
||||
let height = self.terrain.len();
|
||||
for y in 0..height {
|
||||
info!("Rainfall: {}/{}", y, height);
|
||||
let alpha = (y as f32 / self.height as f32) * PI;
|
||||
let latitude_modifier = f32::sin(2.0 * alpha);
|
||||
|
||||
let width = self.terrain[y].len();
|
||||
for x in 0..width {
|
||||
// let beta = (x as f32 / self.width as f32) * TAU;
|
||||
|
||||
let diff_cell_x =
|
||||
(width + x + f32::floor(latitude_modifier * width as f32 / 50.0) as usize)
|
||||
% width;
|
||||
let diff_cell = &self.terrain[y][diff_cell_x];
|
||||
let diff_altitude = f32::max(0.0, diff_cell.altitude);
|
||||
|
||||
let mut cell = &mut self.terrain[y][x];
|
||||
let altitude = f32::max(0.0, cell.altitude);
|
||||
|
||||
let altitude_factor =
|
||||
f32::max(0.0, 2.0 * (altitude - diff_altitude) / World::MAX_ALTITUDE);
|
||||
|
||||
let rainfall = f32::min(
|
||||
World::MAX_RAINFALL,
|
||||
World::calculate_rainfall(altitude_factor),
|
||||
);
|
||||
|
||||
cell.rainfall = rainfall;
|
||||
|
||||
if rainfall > self.max_rainfall {
|
||||
self.max_rainfall = rainfall;
|
||||
}
|
||||
if rainfall < self.min_rainfall {
|
||||
self.min_rainfall = rainfall;
|
||||
}
|
||||
}
|
||||
}
|
||||
info!("Done generating rainfall");
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn calculate_rainfall(raw_rainfall: f32) -> f32 {
|
||||
f32::clamp(
|
||||
(raw_rainfall * (World::RAINFALL_SPAN + World::RAINFALL_DRYNESS_OFFSET))
|
||||
+ World::MIN_RAINFALL
|
||||
- World::RAINFALL_DRYNESS_OFFSET,
|
||||
0.0,
|
||||
World::MAX_RAINFALL,
|
||||
)
|
||||
}
|
||||
|
||||
fn generate_temperature(&mut self) -> Result<(), CartesianError> {
|
||||
let offset = World::random_offset_vector(&mut self.rng);
|
||||
const RADIUS: f32 = 2.0;
|
||||
|
||||
for y in 0..self.terrain.len() {
|
||||
let alpha = (y as f32 / self.height as f32) * PI;
|
||||
for x in 0..self.terrain[y].len() {
|
||||
let beta = (x as f32 / self.width as f32) * TAU;
|
||||
|
||||
let random_noise =
|
||||
self.random_noise_from_polar_coordinates(alpha, beta, RADIUS, offset)?;
|
||||
|
||||
let cell = &mut self.terrain[y][x];
|
||||
|
||||
let altitude_factor = f32::max(
|
||||
0.0,
|
||||
(cell.altitude / World::MAX_ALTITUDE)
|
||||
* 2.5
|
||||
* World::TEMPERATURE_ALTITUDE_FACTOR,
|
||||
);
|
||||
|
||||
let latitude_modifer = (alpha * 0.8) + (random_noise * 0.2 * PI);
|
||||
let base_temperature = World::calculate_temperature(f32::sin(latitude_modifer));
|
||||
|
||||
let temperature = base_temperature * (1.0 - altitude_factor);
|
||||
cell.temperature = temperature;
|
||||
|
||||
if temperature > self.max_temperature {
|
||||
self.max_temperature = temperature;
|
||||
}
|
||||
if temperature < self.min_temperature {
|
||||
self.min_temperature = temperature;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn calculate_temperature(raw_temperature: f32) -> f32 {
|
||||
f32::clamp(
|
||||
(raw_temperature * World::TEMPERATURE_SPAN) + World::MIN_TEMPERATURE,
|
||||
World::MIN_TEMPERATURE,
|
||||
World::MAX_TEMPERATURE,
|
||||
)
|
||||
}
|
||||
}
|
||||
379
planet/src/world_manager.rs
Normal file
379
planet/src/world_manager.rs
Normal file
|
|
@ -0,0 +1,379 @@
|
|||
#[cfg(feature = "render")]
|
||||
use crate::TerrainCell;
|
||||
use crate::{World, WorldGenError};
|
||||
#[cfg(all(feature = "debug", feature = "render"))]
|
||||
use bevy::log::debug;
|
||||
use bevy::log::warn;
|
||||
#[cfg(feature = "debug")]
|
||||
use bevy::utils::default;
|
||||
#[cfg(feature = "render")]
|
||||
use bevy::{
|
||||
asset::{Assets, HandleId},
|
||||
render::render_resource::Extent3d,
|
||||
render::{color::Color, texture::Image},
|
||||
};
|
||||
use rand::random;
|
||||
use std::{
|
||||
error::Error,
|
||||
fmt::Display,
|
||||
fs::File,
|
||||
io::{self, Read, Write},
|
||||
path::Path,
|
||||
};
|
||||
|
||||
#[derive(Debug)]
|
||||
pub enum LoadError {
|
||||
MissingSave(io::Error),
|
||||
InvalidSave(ron::Error),
|
||||
}
|
||||
impl Error for LoadError {
|
||||
fn source(&self) -> Option<&(dyn Error + 'static)> {
|
||||
match self {
|
||||
LoadError::MissingSave(error) => Some(error),
|
||||
LoadError::InvalidSave(error) => Some(error),
|
||||
}
|
||||
}
|
||||
|
||||
fn description(&self) -> &str {
|
||||
"description() is deprecated; use Display"
|
||||
}
|
||||
|
||||
fn cause(&self) -> Option<&dyn Error> {
|
||||
self.source()
|
||||
}
|
||||
}
|
||||
impl Display for LoadError {
|
||||
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
||||
match self {
|
||||
LoadError::MissingSave(_) => f.write_str("No save found at given path"),
|
||||
LoadError::InvalidSave(_) => f.write_str("Loaded file is not a valid save"),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug)]
|
||||
pub enum SaveError {
|
||||
MissingWorld,
|
||||
SerializationError(ron::Error),
|
||||
FailedToWrite(io::Error),
|
||||
}
|
||||
impl Error for SaveError {
|
||||
fn source(&self) -> Option<&(dyn Error + 'static)> {
|
||||
match self {
|
||||
SaveError::MissingWorld => None,
|
||||
SaveError::SerializationError(error) => Some(error),
|
||||
SaveError::FailedToWrite(err) => Some(err),
|
||||
}
|
||||
}
|
||||
|
||||
fn description(&self) -> &str {
|
||||
"description() is deprecated; use Display"
|
||||
}
|
||||
|
||||
fn cause(&self) -> Option<&dyn Error> {
|
||||
self.source()
|
||||
}
|
||||
}
|
||||
impl Display for SaveError {
|
||||
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
||||
match self {
|
||||
SaveError::MissingWorld => f.write_str("No world to save found."),
|
||||
SaveError::SerializationError(_) => f.write_str("Failed to serialize world."),
|
||||
SaveError::FailedToWrite(_) => f.write_str("Failed to write save file."),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug)]
|
||||
pub struct WorldManager {
|
||||
#[cfg(feature = "render")]
|
||||
pub image_handle_id: Option<HandleId>,
|
||||
world: Option<World>,
|
||||
#[cfg(feature = "render")]
|
||||
rainfall_visible: bool,
|
||||
#[cfg(feature = "render")]
|
||||
temperature_visible: bool,
|
||||
#[cfg(feature = "render")]
|
||||
contours: bool,
|
||||
}
|
||||
|
||||
impl WorldManager {
|
||||
pub fn new() -> WorldManager {
|
||||
Self {
|
||||
#[cfg(feature = "render")]
|
||||
image_handle_id: None,
|
||||
world: None,
|
||||
#[cfg(feature = "render")]
|
||||
rainfall_visible: false,
|
||||
#[cfg(feature = "render")]
|
||||
temperature_visible: false,
|
||||
#[cfg(feature = "render")]
|
||||
contours: true,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn save_world<P: AsRef<Path>>(&self, path: P) -> Result<(), SaveError> {
|
||||
let world = match self.get_world() {
|
||||
Some(world) => world,
|
||||
None => {
|
||||
warn!("No world to save");
|
||||
return Err(SaveError::MissingWorld);
|
||||
}
|
||||
};
|
||||
#[cfg(feature = "debug")]
|
||||
let serialized = match ron::ser::to_string_pretty(world, default()) {
|
||||
Ok(serialized) => serialized,
|
||||
Err(err) => {
|
||||
return Err(SaveError::SerializationError(err));
|
||||
}
|
||||
};
|
||||
|
||||
#[cfg(not(feature = "debug"))]
|
||||
let serialized = match ron::to_string(world) {
|
||||
Ok(serialized) => serialized,
|
||||
Err(err) => {
|
||||
return Err(SaveError::SerializationError(err));
|
||||
}
|
||||
};
|
||||
|
||||
match File::create(path).unwrap().write_all(serialized.as_bytes()) {
|
||||
Ok(_) => Ok(()),
|
||||
Err(err) => Err(SaveError::FailedToWrite(err)),
|
||||
}
|
||||
}
|
||||
|
||||
pub fn load_world<P: AsRef<Path>>(
|
||||
&mut self,
|
||||
path: P,
|
||||
#[cfg(feature = "render")] images: &mut Assets<Image>,
|
||||
) -> Result<(), LoadError> {
|
||||
let mut file = match File::open(path) {
|
||||
Ok(file) => file,
|
||||
Err(err) => {
|
||||
return Err(LoadError::MissingSave(err));
|
||||
}
|
||||
};
|
||||
let mut buf = String::new();
|
||||
match file.read_to_string(&mut buf) {
|
||||
Ok(_) => {}
|
||||
Err(err) => {
|
||||
return Err(LoadError::MissingSave(err));
|
||||
}
|
||||
};
|
||||
match ron::from_str(buf.as_str()) {
|
||||
Ok(world) => {
|
||||
#[cfg(feature = "render")]
|
||||
let World { height, width, .. } = world;
|
||||
self.world = Some(world);
|
||||
#[cfg(feature = "render")]
|
||||
{
|
||||
let image_handle = &images.get_handle(
|
||||
self.image_handle_id
|
||||
.expect("Missing image handle, even though world is present"),
|
||||
);
|
||||
images
|
||||
.get_mut(image_handle)
|
||||
.expect("Handle for missing image")
|
||||
.resize(Extent3d {
|
||||
width,
|
||||
height,
|
||||
depth_or_array_layers: 0,
|
||||
});
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
Err(err) => Err(LoadError::InvalidSave(err)),
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(feature = "render")]
|
||||
pub fn toggle_rainfall(&mut self) {
|
||||
#[cfg(feature = "debug")]
|
||||
if self.rainfall_visible {
|
||||
debug!("Turning rainfall off");
|
||||
} else {
|
||||
debug!("Turning rainfall on");
|
||||
}
|
||||
self.rainfall_visible = !self.rainfall_visible;
|
||||
}
|
||||
|
||||
#[cfg(feature = "render")]
|
||||
pub fn toggle_temperature(&mut self) {
|
||||
#[cfg(feature = "debug")]
|
||||
if self.temperature_visible {
|
||||
debug!("Turning temperature off");
|
||||
} else {
|
||||
debug!("Turning temperature on");
|
||||
}
|
||||
self.temperature_visible = !self.temperature_visible;
|
||||
}
|
||||
|
||||
#[cfg(feature = "render")]
|
||||
pub fn toggle_contours(&mut self) {
|
||||
#[cfg(feature = "debug")]
|
||||
if self.contours {
|
||||
debug!("Turning terrain contours off");
|
||||
} else {
|
||||
debug!("Turning terrain contours on");
|
||||
}
|
||||
self.contours = !self.contours;
|
||||
}
|
||||
|
||||
pub fn get_world(&self) -> Option<&World> {
|
||||
self.world.as_ref()
|
||||
}
|
||||
pub fn world(&self) -> &World {
|
||||
assert!(self.world.is_some(), "No world.");
|
||||
self.get_world().unwrap()
|
||||
}
|
||||
|
||||
pub fn new_world(&mut self) -> Result<&World, WorldGenError> {
|
||||
let seed = random();
|
||||
let mut new_world = World::new(400, 200, seed);
|
||||
new_world.generate()?;
|
||||
self.world = Some(new_world);
|
||||
Ok(self.get_world().unwrap())
|
||||
}
|
||||
|
||||
#[cfg(feature = "render")]
|
||||
fn generate_color(&self, cell: &TerrainCell) -> Color {
|
||||
let altitude_color = if self.contours {
|
||||
WorldManager::altitude_contour_color(cell.altitude)
|
||||
} else {
|
||||
WorldManager::altitude_color(cell.altitude)
|
||||
};
|
||||
|
||||
let mut layer_count = 1.0;
|
||||
|
||||
let mut r = altitude_color.r();
|
||||
let mut g = altitude_color.g();
|
||||
let mut b = altitude_color.b();
|
||||
|
||||
if self.rainfall_visible {
|
||||
layer_count += 1.0;
|
||||
let rainfall_color = self.rainfall_contour_color(cell.rainfall);
|
||||
// if self.contours {
|
||||
// self.rainfall_contour_color(cell.rainfall)
|
||||
// } else {
|
||||
// WorldManager::rainfall_color(cell.rainfall)
|
||||
// };
|
||||
|
||||
r += rainfall_color.r();
|
||||
g += rainfall_color.g();
|
||||
b += rainfall_color.b();
|
||||
}
|
||||
|
||||
if self.temperature_visible {
|
||||
layer_count += 1.0;
|
||||
let temperature_color = self.temperature_contour_color(cell.temperature);
|
||||
// if self.contours {
|
||||
// self.temperature_contour_color(cell.temperature)
|
||||
// } else {
|
||||
// WorldManager::temperature_color(cell.temperature)
|
||||
// };
|
||||
|
||||
r += temperature_color.r();
|
||||
g += temperature_color.g();
|
||||
b += temperature_color.b();
|
||||
}
|
||||
|
||||
Color::rgb(r / layer_count, g / layer_count, b / layer_count)
|
||||
}
|
||||
|
||||
#[cfg(feature = "render")]
|
||||
fn altitude_color(altitude: f32) -> Color {
|
||||
if altitude < 0.0 {
|
||||
Color::rgb(0.0, 0.0, (2.0 - altitude / World::MIN_ALTITUDE) / 2.0)
|
||||
} else {
|
||||
let mult = (1.0 + altitude / World::MAX_ALTITUDE) / 2.0;
|
||||
|
||||
Color::rgb(0.58 * mult, 0.29 * mult, 0.0)
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(feature = "render")]
|
||||
fn altitude_contour_color(altitude: f32) -> Color {
|
||||
if altitude < 0.0 {
|
||||
Color::rgb(0.0, 0.0, (2.0 - altitude / World::MIN_ALTITUDE) / 2.0)
|
||||
} else {
|
||||
let mut shade_value = 1.0;
|
||||
|
||||
while shade_value > altitude / World::MAX_ALTITUDE {
|
||||
shade_value -= 0.05;
|
||||
}
|
||||
|
||||
Color::rgb(shade_value, shade_value, shade_value)
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(feature = "render")]
|
||||
fn rainfall_contour_color(&self, rainfall: f32) -> Color {
|
||||
Color::rgb(
|
||||
0.0,
|
||||
f32::floor((rainfall / self.world().max_rainfall) / 0.1),
|
||||
0.0,
|
||||
)
|
||||
}
|
||||
|
||||
#[cfg(feature = "render")]
|
||||
fn rainfall_color(rainfall: f32) -> Color {
|
||||
if rainfall <= 0.0 {
|
||||
Color::BLACK
|
||||
} else {
|
||||
Color::rgb(0.0, rainfall / World::MAX_RAINFALL, 0.0)
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(feature = "render")]
|
||||
fn temperature_contour_color(&self, temperature: f32) -> Color {
|
||||
let mut shade_value = 1.0;
|
||||
let value = (temperature - self.world().min_temperature)
|
||||
/ (self.world().max_temperature - self.world().min_temperature);
|
||||
|
||||
while shade_value > value {
|
||||
shade_value -= 0.1;
|
||||
}
|
||||
|
||||
Color::rgb(shade_value, 0.0, 1.0 - shade_value)
|
||||
}
|
||||
|
||||
#[cfg(feature = "render")]
|
||||
fn temperature_color(temperature: f32) -> Color {
|
||||
let normalized_temperature = WorldManager::normalize_temperature(temperature);
|
||||
Color::rgb(normalized_temperature, 1.0 - normalized_temperature, 0.0)
|
||||
}
|
||||
|
||||
#[cfg(feature = "render")]
|
||||
fn normalize_temperature(temperature: f32) -> f32 {
|
||||
(temperature - World::MIN_TEMPERATURE) / World::TEMPERATURE_SPAN
|
||||
}
|
||||
|
||||
#[cfg(feature = "render")]
|
||||
pub fn world_colors(&self) -> Vec<Color> {
|
||||
match self.get_world() {
|
||||
None => panic!("Called world_colors before generating world"),
|
||||
Some(world) => {
|
||||
let terrain_cells: Vec<_> = world.terrain.iter().rev().flatten().collect();
|
||||
|
||||
terrain_cells
|
||||
.iter()
|
||||
.map(|cell| self.generate_color(cell))
|
||||
.collect()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(feature = "render")]
|
||||
pub fn world_color_bytes(&self) -> Vec<u8> {
|
||||
self.world_colors()
|
||||
.iter()
|
||||
.flat_map(|color| {
|
||||
color
|
||||
.as_rgba_f32()
|
||||
.iter()
|
||||
.flat_map(|num| num.to_le_bytes())
|
||||
.collect::<Vec<u8>>()
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
}
|
||||
|
|
@ -1,445 +0,0 @@
|
|||
use serde::{Deserialize, Serialize};
|
||||
use std::{
|
||||
error::Error,
|
||||
f32::consts::{PI, TAU},
|
||||
fmt::{Debug, Display},
|
||||
};
|
||||
|
||||
// TODO: Logging doesn't seem to work here? Figure out why and fix
|
||||
|
||||
use bevy::{log::info, math::Vec3A, prelude::Vec2, utils::default};
|
||||
use noise::{NoiseFn, Perlin, Seedable};
|
||||
use rand::Rng;
|
||||
|
||||
use crate::{cartesian_coordinates, mix_values, random_point_in_sphere, CartesianError, RepeatNum};
|
||||
|
||||
#[derive(Debug, Clone, Copy)]
|
||||
pub enum WorldGenError {
|
||||
CartesianError(CartesianError),
|
||||
}
|
||||
impl Error for WorldGenError {
|
||||
fn source(&self) -> Option<&(dyn Error + 'static)> {
|
||||
match *self {
|
||||
WorldGenError::CartesianError(ref e) => Some(e),
|
||||
}
|
||||
}
|
||||
|
||||
fn description(&self) -> &str {
|
||||
"description() is deprecated; use Display"
|
||||
}
|
||||
|
||||
fn cause(&self) -> Option<&dyn Error> {
|
||||
self.source()
|
||||
}
|
||||
}
|
||||
impl Display for WorldGenError {
|
||||
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
||||
match self {
|
||||
WorldGenError::CartesianError(err) => Display::fmt(err, f),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, Deserialize, Serialize)]
|
||||
pub struct World {
|
||||
pub width: i32,
|
||||
pub height: i32,
|
||||
pub seed: u32,
|
||||
|
||||
pub terrain: Vec<Vec<TerrainCell>>,
|
||||
continent_offsets: [Vec2; World::NUM_CONTINENTS as usize],
|
||||
continent_widths: [f32; World::NUM_CONTINENTS as usize],
|
||||
#[serde(skip)]
|
||||
perlin: Perlin,
|
||||
}
|
||||
impl Debug for World {
|
||||
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
||||
f.debug_struct("World")
|
||||
.field("width", &self.width)
|
||||
.field("height", &self.height)
|
||||
.field("seed", &self.seed)
|
||||
.field(
|
||||
"Average Rainfall",
|
||||
&(self
|
||||
.terrain
|
||||
.iter()
|
||||
.flatten()
|
||||
.map(|cell| cell.rainfall)
|
||||
.sum::<f32>()
|
||||
/ (self.width * self.height) as f32),
|
||||
)
|
||||
.field("continent_offsets", &self.continent_offsets)
|
||||
.field("continent_widths", &self.continent_widths)
|
||||
.field("perlin", &self.perlin)
|
||||
.finish()
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
|
||||
pub(crate) struct Biome {
|
||||
pub altitude: f32,
|
||||
pub rainfall: f32,
|
||||
pub temperature: f32,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
|
||||
pub struct TerrainCell {
|
||||
pub altitude: f32,
|
||||
pub rainfall: f32,
|
||||
pub temperature: f32,
|
||||
|
||||
#[serde(skip)]
|
||||
pub rain_accumulated: f32,
|
||||
#[serde(skip)]
|
||||
pub previous_rain_accumulated: f32,
|
||||
}
|
||||
|
||||
impl World {
|
||||
pub fn new(width: i32, height: i32, seed: u32) -> World {
|
||||
World {
|
||||
width,
|
||||
height,
|
||||
seed,
|
||||
terrain: vec![
|
||||
vec![TerrainCell::default(); width.try_into().unwrap()];
|
||||
height.try_into().unwrap()
|
||||
],
|
||||
continent_offsets: [default(); Self::NUM_CONTINENTS as usize],
|
||||
continent_widths: [default(); Self::NUM_CONTINENTS as usize],
|
||||
perlin: Perlin::new().set_seed(seed),
|
||||
}
|
||||
}
|
||||
|
||||
pub const NUM_CONTINENTS: u8 = 7;
|
||||
pub const CONTINENT_FACTOR: f32 = 0.7;
|
||||
pub const CONTINENT_MIN_WIDTH_FACTOR: f32 = 3.0;
|
||||
pub const CONTINENT_MAX_WIDTH_FACTOR: f32 = 7.0;
|
||||
|
||||
pub const MIN_ALTITUDE: f32 = -10000.0;
|
||||
pub const MAX_ALTITUDE: f32 = 10000.0;
|
||||
pub const ALTITUDE_SPAN: f32 = Self::MAX_ALTITUDE - Self::MIN_ALTITUDE;
|
||||
|
||||
pub const MOUNTAIN_RANGE_MIX_FACTOR: f32 = 0.075;
|
||||
pub const MOUNTAIN_RANGE_WIDTH_FACTOR: f32 = 25.0;
|
||||
|
||||
pub const TERRAIN_NOISE_FACTOR_1: f32 = 0.2;
|
||||
pub const TERRAIN_NOISE_FACTOR_2: f32 = 0.15;
|
||||
pub const TERRAIN_NOISE_FACTOR_3: f32 = 0.1;
|
||||
|
||||
pub const MIN_RAINFALL: f32 = -20.0;
|
||||
pub const MAX_RAINFALL: f32 = 100.0;
|
||||
pub const RAINFALL_SPAN: f32 = Self::MAX_RAINFALL - Self::MIN_RAINFALL;
|
||||
pub const RAINFALL_ALTITUDE_FACTOR: f32 = 1.0;
|
||||
|
||||
pub const MIN_TEMPERATURE: f32 = -50.0;
|
||||
pub const MAX_TEMPERATURE: f32 = 30.0;
|
||||
pub const TEMPERATURE_SPAN: f32 = Self::MAX_TEMPERATURE - Self::MIN_RAINFALL;
|
||||
pub const TEMPERATURE_ALTITUDE_FACTOR: f32 = 1.0;
|
||||
|
||||
pub fn generate(&mut self) -> Result<(), WorldGenError> {
|
||||
if let Err(err) = self.generate_altitude() {
|
||||
return Err(WorldGenError::CartesianError(err));
|
||||
}
|
||||
if let Err(err) = self.generate_rainfall() {
|
||||
return Err(WorldGenError::CartesianError(err));
|
||||
}
|
||||
if let Err(err) = self.generate_temperature() {
|
||||
return Err(WorldGenError::CartesianError(err));
|
||||
}
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn generate_continents(&mut self) {
|
||||
info!("Generating continents");
|
||||
let mut rng = rand::thread_rng();
|
||||
let width = self.width as f32;
|
||||
let height = self.height as f32;
|
||||
|
||||
for i in 0..Self::NUM_CONTINENTS {
|
||||
info!("{}/{}", i, Self::NUM_CONTINENTS);
|
||||
|
||||
self.continent_offsets[i as usize].x = rng
|
||||
.gen_range(width * i as f32 * 2.0 / 5.0..width * (i as f32 + 2.0) * 2.0 / 5.0)
|
||||
.repeat(width);
|
||||
self.continent_offsets[i as usize].y =
|
||||
rng.gen_range(height * 1.0 / 6.0..height * 5.0 / 6.0);
|
||||
|
||||
self.continent_widths[i as usize] =
|
||||
rng.gen_range(Self::CONTINENT_MIN_WIDTH_FACTOR..Self::CONTINENT_MAX_WIDTH_FACTOR);
|
||||
}
|
||||
info!("Done generating continents");
|
||||
}
|
||||
|
||||
fn continent_modifier(&self, x: usize, y: usize) -> f32 {
|
||||
let x = x as f32;
|
||||
let y = y as f32;
|
||||
let width = self.width as f32;
|
||||
let height = self.height as f32;
|
||||
|
||||
let mut max_value = 0.0;
|
||||
let beta_factor = f32::sin(PI * y / height);
|
||||
|
||||
for i in 0..Self::NUM_CONTINENTS {
|
||||
let idx = i as usize;
|
||||
let Vec2 {
|
||||
x: continent_x,
|
||||
y: continent_y,
|
||||
} = self.continent_offsets[idx];
|
||||
|
||||
let distance_x = f32::min(
|
||||
f32::min((continent_x - x).abs(), (width + continent_x - x).abs()),
|
||||
(continent_x - x - width).abs(),
|
||||
) * beta_factor;
|
||||
|
||||
let distance_y = f32::abs(continent_y - y);
|
||||
|
||||
let distance = (distance_x * distance_x + distance_y * distance_y).sqrt();
|
||||
|
||||
let value = f32::max(0.0, 1.0 - self.continent_widths[idx] * distance / width);
|
||||
|
||||
max_value = f32::max(max_value, value);
|
||||
}
|
||||
|
||||
max_value
|
||||
}
|
||||
|
||||
fn generate_altitude(&mut self) -> Result<(), CartesianError> {
|
||||
info!("Generating altitude");
|
||||
self.generate_continents();
|
||||
|
||||
const RADIUS_1: f32 = 0.5;
|
||||
const RADIUS_2: f32 = 4.0;
|
||||
const RADIUS_3: f32 = 4.0;
|
||||
const RADIUS_4: f32 = 8.0;
|
||||
const RADIUS_5: f32 = 16.0;
|
||||
|
||||
let offset_1 = Self::random_offset_vector();
|
||||
let offset_2 = Self::random_offset_vector();
|
||||
let offset_3 = Self::random_offset_vector();
|
||||
let offset_4 = Self::random_offset_vector();
|
||||
let offset_5 = Self::random_offset_vector();
|
||||
|
||||
for y in 0..self.terrain.len() {
|
||||
let alpha = (y as f32 / self.height as f32) * PI;
|
||||
|
||||
info!("{}/{}", y, self.terrain.len());
|
||||
|
||||
for x in 0..self.terrain[y].len() {
|
||||
let beta = (x as f32 / self.width as f32) * TAU;
|
||||
|
||||
let value_1 =
|
||||
self.random_noise_from_polar_coordinates(alpha, beta, RADIUS_1, offset_1)?;
|
||||
let value_2 =
|
||||
self.random_noise_from_polar_coordinates(alpha, beta, RADIUS_2, offset_2)?;
|
||||
let value_3 =
|
||||
self.random_noise_from_polar_coordinates(alpha, beta, RADIUS_3, offset_3)?;
|
||||
let value_4 =
|
||||
self.random_noise_from_polar_coordinates(alpha, beta, RADIUS_4, offset_4)?;
|
||||
let value_5 =
|
||||
self.random_noise_from_polar_coordinates(alpha, beta, RADIUS_5, offset_5)?;
|
||||
|
||||
let continent_value = self.continent_modifier(x, y);
|
||||
|
||||
let mut value_continent = continent_value;
|
||||
value_continent =
|
||||
mix_values(value_continent, value_3, Self::TERRAIN_NOISE_FACTOR_1);
|
||||
value_continent *= mix_values(1.0, value_4, Self::TERRAIN_NOISE_FACTOR_2);
|
||||
|
||||
let value_b = mix_values(1.0, value_5, Self::TERRAIN_NOISE_FACTOR_3);
|
||||
|
||||
let mut value_mountain =
|
||||
mix_values(value_1, value_2, Self::MOUNTAIN_RANGE_MIX_FACTOR);
|
||||
value_mountain = self.mountain_range_noise_from_random_noise(value_mountain);
|
||||
value_mountain =
|
||||
mix_values(value_mountain, value_3, Self::TERRAIN_NOISE_FACTOR_1 * 1.5);
|
||||
value_mountain *= mix_values(1.0, value_4, Self::TERRAIN_NOISE_FACTOR_2 * 1.5);
|
||||
value_mountain *= mix_values(1.0, value_5, Self::TERRAIN_NOISE_FACTOR_3 * 1.5);
|
||||
|
||||
let mut raw_altitude = mix_values(value_continent, value_mountain, 0.25);
|
||||
raw_altitude = mix_values(raw_altitude, value_mountain, 0.1);
|
||||
raw_altitude = mix_values(raw_altitude, value_b, 0.1);
|
||||
|
||||
self.terrain[y][x].altitude = Self::calculate_altitude(raw_altitude);
|
||||
}
|
||||
}
|
||||
info!("Done generating altitude");
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn random_offset_vector() -> Vec3A {
|
||||
random_point_in_sphere(1000.0)
|
||||
}
|
||||
|
||||
fn random_noise_from_polar_coordinates(
|
||||
&self,
|
||||
alpha: f32,
|
||||
beta: f32,
|
||||
radius: f32,
|
||||
offset: Vec3A,
|
||||
) -> Result<f32, CartesianError> {
|
||||
let offset = cartesian_coordinates(alpha, beta, radius)? + offset;
|
||||
Ok(self
|
||||
.perlin
|
||||
.get([offset.x as f64, offset.y as f64, offset.z as f64]) as f32)
|
||||
}
|
||||
|
||||
fn mountain_range_noise_from_random_noise(&self, noise: f32) -> f32 {
|
||||
let noise = noise * 2.0 - 1.0;
|
||||
|
||||
let value_1 = -f32::exp(-f32::powi(
|
||||
noise * Self::MOUNTAIN_RANGE_WIDTH_FACTOR + 1.0,
|
||||
2,
|
||||
));
|
||||
let value_2 = f32::exp(-f32::powi(
|
||||
noise * Self::MOUNTAIN_RANGE_WIDTH_FACTOR - 1.0,
|
||||
2,
|
||||
));
|
||||
let value_3 = -f32::exp(-f32::powi(
|
||||
noise * Self::MOUNTAIN_RANGE_WIDTH_FACTOR + Self::MOUNTAIN_RANGE_WIDTH_FACTOR / 2.0,
|
||||
2,
|
||||
));
|
||||
let value_4 = f32::exp(-f32::powi(
|
||||
noise * Self::MOUNTAIN_RANGE_WIDTH_FACTOR - Self::MOUNTAIN_RANGE_WIDTH_FACTOR / 2.0,
|
||||
2,
|
||||
));
|
||||
|
||||
(value_1 + value_2 + value_3 + value_4 + 1.0) / 2.0
|
||||
}
|
||||
|
||||
fn calculate_altitude(raw_altitude: f32) -> f32 {
|
||||
Self::MIN_ALTITUDE + (raw_altitude * Self::ALTITUDE_SPAN)
|
||||
}
|
||||
|
||||
/*
|
||||
fn generate_rainfall_alt(&mut self) -> Result<(), CartesianError> {
|
||||
let max_cycles = self.width / 5;
|
||||
|
||||
const ACCUMULATED_RAIN_FACTOR: f32 = 0.06;
|
||||
const RAINFALL_FACTOR: f32 = 0.005;
|
||||
const RAINFALL_ALTITUDE_FACTOR: f32 = 0.05;
|
||||
|
||||
for _ in 0..max_cycles {
|
||||
for x in 0..self.width {
|
||||
for y in 0..self.height {
|
||||
let mut prev_x = (x - 1 + self.width) % self.width;
|
||||
let prev_y = if y < self.height / 4 {
|
||||
y + 1
|
||||
} else if y < self.height / 2 {
|
||||
prev_x = (x + 1) % self.width;
|
||||
y - 1
|
||||
} else if y < (self.height * 3) / 4 {
|
||||
prev_x = (x + 1) % self.width;
|
||||
y + 1
|
||||
} else {
|
||||
y - 1
|
||||
};
|
||||
|
||||
let mut cell = self.terrain[y as usize][x as usize];
|
||||
cell.previous_rain_accumulated = cell.rain_accumulated;
|
||||
cell.rain_accumulated = 0.0;
|
||||
|
||||
if cell.altitude <= 0.0 {
|
||||
cell.rain_accumulated += ACCUMULATED_RAIN_FACTOR * Self::MAX_RAINFALL;
|
||||
}
|
||||
|
||||
let prev_cell = self.terrain[prev_y as usize][prev_x as usize];
|
||||
|
||||
let altitude_difference =
|
||||
f32::max(0.0, cell.altitude) - f32::max(0.0, prev_cell.altitude);
|
||||
let altitude_factor = f32::max(
|
||||
0.0,
|
||||
RAINFALL_ALTITUDE_FACTOR * altitude_difference / Self::MAX_ALTITUDE,
|
||||
);
|
||||
let final_rain_factor = f32::min(1.0, RAINFALL_FACTOR + altitude_factor);
|
||||
|
||||
cell.rain_accumulated += prev_cell.previous_rain_accumulated;
|
||||
cell.rain_accumulated =
|
||||
f32::min(cell.rain_accumulated, Self::MAX_RAINFALL / RAINFALL_FACTOR);
|
||||
|
||||
let rain_accumulated = cell.rain_accumulated * final_rain_factor;
|
||||
cell.rainfall += rain_accumulated;
|
||||
cell.rain_accumulated -= rain_accumulated;
|
||||
|
||||
cell.rain_accumulated = f32::max(cell.rain_accumulated, 0.0);
|
||||
|
||||
self.terrain[y as usize][x as usize] = cell;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Ok(())
|
||||
}
|
||||
*/
|
||||
|
||||
fn generate_rainfall(&mut self) -> Result<(), CartesianError> {
|
||||
let offset = Self::random_offset_vector();
|
||||
const RADIUS: f32 = 2.0;
|
||||
|
||||
for y in 0..self.terrain.len() {
|
||||
let alpha = (y as f32 / self.height as f32) * PI;
|
||||
for x in 0..self.terrain[y].len() {
|
||||
let beta = (x as f32 / self.width as f32) * TAU;
|
||||
|
||||
let random_noise =
|
||||
self.random_noise_from_polar_coordinates(alpha, beta, RADIUS, offset)?;
|
||||
|
||||
let mut cell = &mut self.terrain[y][x];
|
||||
|
||||
let base_rainfall = Self::calculate_rainfall(random_noise);
|
||||
let altitude_factor = f32::clamp(
|
||||
(cell.altitude / Self::MAX_ALTITUDE) * Self::RAINFALL_ALTITUDE_FACTOR,
|
||||
0.0,
|
||||
1.0,
|
||||
);
|
||||
let rainfall = base_rainfall * (1.0 - altitude_factor);
|
||||
|
||||
cell.rainfall = rainfall;
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn calculate_rainfall(raw_rainfall: f32) -> f32 {
|
||||
f32::clamp(
|
||||
(raw_rainfall * Self::RAINFALL_SPAN) + Self::MIN_RAINFALL,
|
||||
0.0,
|
||||
Self::MAX_RAINFALL,
|
||||
)
|
||||
}
|
||||
|
||||
fn generate_temperature(&mut self) -> Result<(), CartesianError> {
|
||||
let offset = Self::random_offset_vector();
|
||||
const RADIUS: f32 = 2.0;
|
||||
|
||||
for y in 0..self.terrain.len() {
|
||||
let alpha = (y as f32 / self.height as f32) * PI;
|
||||
for x in 0..self.terrain[y].len() {
|
||||
let beta = (x as f32 / self.width as f32) * TAU;
|
||||
|
||||
let random_noise =
|
||||
self.random_noise_from_polar_coordinates(alpha, beta, RADIUS, offset)?;
|
||||
|
||||
let cell = &mut self.terrain[y][x];
|
||||
|
||||
let altitude_factor = (cell.altitude / Self::MAX_ALTITUDE)
|
||||
* (2.5 * Self::TEMPERATURE_ALTITUDE_FACTOR);
|
||||
|
||||
let latitude_modifer = (alpha * 0.8) + (random_noise * 0.2 * PI);
|
||||
let base_temperature = Self::calculate_temperature(f32::sin(latitude_modifer));
|
||||
|
||||
cell.temperature = base_temperature * (1.0 - altitude_factor);
|
||||
}
|
||||
}
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn calculate_temperature(raw_temperature: f32) -> f32 {
|
||||
f32::clamp(
|
||||
(raw_temperature * Self::TEMPERATURE_SPAN) + Self::MIN_TEMPERATURE,
|
||||
Self::MIN_TEMPERATURE,
|
||||
Self::MAX_TEMPERATURE,
|
||||
)
|
||||
}
|
||||
}
|
||||
|
|
@ -1,258 +0,0 @@
|
|||
#[cfg(feature = "render")]
|
||||
use crate::TerrainCell;
|
||||
use crate::{World, WorldGenError};
|
||||
use bevy::log::error;
|
||||
#[cfg(all(feature = "debug", feature = "render"))]
|
||||
use bevy::log::{debug, info};
|
||||
#[cfg(feature = "render")]
|
||||
use bevy::{
|
||||
asset::HandleId,
|
||||
render::{color::Color, texture::Image},
|
||||
};
|
||||
use rand::random;
|
||||
use std::{
|
||||
fs::File,
|
||||
io::{Read, Write},
|
||||
path::Path,
|
||||
};
|
||||
|
||||
#[derive(Debug)]
|
||||
pub struct WorldManager {
|
||||
#[cfg(feature = "render")]
|
||||
pub image_handle_id: HandleId,
|
||||
world: Option<World>,
|
||||
#[cfg(feature = "render")]
|
||||
rainfall_visible: bool,
|
||||
#[cfg(feature = "render")]
|
||||
temperature_visible: bool,
|
||||
#[cfg(feature = "render")]
|
||||
terrain_as_contours: bool,
|
||||
}
|
||||
|
||||
impl WorldManager {
|
||||
pub fn new() -> WorldManager {
|
||||
Self {
|
||||
#[cfg(feature = "render")]
|
||||
image_handle_id: HandleId::default::<Image>(),
|
||||
world: None,
|
||||
#[cfg(feature = "render")]
|
||||
rainfall_visible: false,
|
||||
#[cfg(feature = "render")]
|
||||
temperature_visible: false,
|
||||
#[cfg(feature = "render")]
|
||||
terrain_as_contours: false,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn save_world<P: AsRef<Path>>(&self, path: P) {
|
||||
let world = match self.get_world() {
|
||||
Some(world) => world,
|
||||
None => {
|
||||
info!("No world to save");
|
||||
return;
|
||||
}
|
||||
};
|
||||
let serialized = match ron::to_string(world) {
|
||||
Ok(serialized) => serialized,
|
||||
Err(err) => {
|
||||
error!("Could not serialize world: {}", err);
|
||||
return;
|
||||
}
|
||||
};
|
||||
File::create(path).unwrap().write_all(serialized.as_bytes());
|
||||
}
|
||||
|
||||
pub fn load_world<P: AsRef<Path>>(&mut self, path: P) {
|
||||
let mut file = match File::open(path) {
|
||||
Ok(file) => file,
|
||||
Err(err) => {
|
||||
error!("Could not open world file: {}", err);
|
||||
return;
|
||||
}
|
||||
};
|
||||
let mut buf = String::new();
|
||||
file.read_to_string(&mut buf);
|
||||
match ron::from_str(buf.as_str()) {
|
||||
Ok(world) => self.world = Some(world),
|
||||
Err(err) => {
|
||||
error!("Could not deserialize world: {}", err);
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(feature = "render")]
|
||||
pub fn toggle_rainfall(&mut self) {
|
||||
#[cfg(feature = "debug")]
|
||||
if self.rainfall_visible {
|
||||
debug!("Turning rainfall off");
|
||||
} else {
|
||||
debug!("Turning rainfall on");
|
||||
}
|
||||
self.rainfall_visible = !self.rainfall_visible;
|
||||
}
|
||||
|
||||
#[cfg(feature = "render")]
|
||||
pub fn toggle_temperature(&mut self) {
|
||||
#[cfg(feature = "debug")]
|
||||
if self.temperature_visible {
|
||||
debug!("Turning temperature off");
|
||||
} else {
|
||||
debug!("Turning temperature on");
|
||||
}
|
||||
self.temperature_visible = !self.temperature_visible;
|
||||
}
|
||||
|
||||
#[cfg(feature = "render")]
|
||||
pub fn toggle_contours(&mut self) {
|
||||
#[cfg(feature = "debug")]
|
||||
if self.terrain_as_contours {
|
||||
debug!("Turning terrain contours off");
|
||||
} else {
|
||||
debug!("Turning terrain contours on");
|
||||
}
|
||||
self.terrain_as_contours = !self.terrain_as_contours;
|
||||
}
|
||||
|
||||
pub fn get_world(&self) -> Option<&World> {
|
||||
self.world.as_ref()
|
||||
}
|
||||
pub fn world(&self) -> &World {
|
||||
self.get_world().unwrap()
|
||||
}
|
||||
|
||||
pub fn new_world(&mut self) -> Result<&World, WorldGenError> {
|
||||
let seed = random();
|
||||
let mut new_world = World::new(400, 200, seed);
|
||||
new_world.generate()?;
|
||||
self.world = Some(new_world);
|
||||
Ok(self.get_world().unwrap())
|
||||
}
|
||||
|
||||
#[cfg(feature = "render")]
|
||||
fn generate_color(&self, cell: &TerrainCell) -> Color {
|
||||
let mut final_color = if self.terrain_as_contours {
|
||||
Self::altitude_contour_color(cell.altitude)
|
||||
} else {
|
||||
Self::altitude_color(cell.altitude)
|
||||
};
|
||||
|
||||
if self.rainfall_visible {
|
||||
let rainfall_color = Self::rainfall_color(cell.rainfall);
|
||||
let normalized_rainfall = Self::normalize_rainfall(cell.rainfall);
|
||||
|
||||
_ = final_color.set_r(
|
||||
(final_color.r() * (1.0 - normalized_rainfall))
|
||||
+ (rainfall_color.r() * normalized_rainfall),
|
||||
);
|
||||
_ = final_color.set_g(
|
||||
(final_color.g() * (1.0 - normalized_rainfall))
|
||||
+ (rainfall_color.g() * normalized_rainfall),
|
||||
);
|
||||
_ = final_color.set_b(
|
||||
(final_color.b() * (1.0 - normalized_rainfall))
|
||||
+ (rainfall_color.b() * normalized_rainfall),
|
||||
);
|
||||
}
|
||||
|
||||
if self.temperature_visible {
|
||||
let temperature_color = Self::temperature_color(cell.temperature);
|
||||
let normalized_temperature = Self::normalize_temperature(cell.temperature);
|
||||
|
||||
_ = final_color.set_r(
|
||||
(final_color.r() * (1.0 - normalized_temperature))
|
||||
+ (temperature_color.r() * normalized_temperature),
|
||||
);
|
||||
_ = final_color.set_g(
|
||||
(final_color.g() * (1.0 - normalized_temperature))
|
||||
+ (temperature_color.g() * normalized_temperature),
|
||||
);
|
||||
_ = final_color.set_b(
|
||||
(final_color.b() * (1.0 - normalized_temperature))
|
||||
+ (temperature_color.b() * normalized_temperature),
|
||||
);
|
||||
}
|
||||
|
||||
final_color
|
||||
}
|
||||
|
||||
#[cfg(feature = "render")]
|
||||
fn altitude_color(altitude: f32) -> Color {
|
||||
if altitude < 0.0 {
|
||||
Color::rgb(0.0, 0.0, (2.0 - altitude / World::MIN_ALTITUDE) / 2.0)
|
||||
} else {
|
||||
let mult = (1.0 + altitude / World::MAX_ALTITUDE) / 2.0;
|
||||
|
||||
Color::rgb(0.58 * mult, 0.29 * mult, 0.0)
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(feature = "render")]
|
||||
fn altitude_contour_color(altitude: f32) -> Color {
|
||||
if altitude < 0.0 {
|
||||
Color::rgb(0.0, 0.0, (2.0 - altitude / World::MIN_ALTITUDE) / 2.0)
|
||||
} else {
|
||||
let mut shade_value = 1.0;
|
||||
|
||||
while shade_value > altitude / World::MAX_ALTITUDE {
|
||||
shade_value -= 0.05;
|
||||
}
|
||||
|
||||
Color::rgb(shade_value, shade_value, shade_value)
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(feature = "render")]
|
||||
fn rainfall_color(rainfall: f32) -> Color {
|
||||
Color::rgb(0.0, Self::normalize_rainfall(rainfall), 0.0)
|
||||
}
|
||||
|
||||
#[cfg(feature = "render")]
|
||||
fn normalize_rainfall(rainfall: f32) -> f32 {
|
||||
if rainfall <= 0.0 {
|
||||
0.0
|
||||
} else {
|
||||
rainfall / World::MAX_RAINFALL
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(feature = "render")]
|
||||
fn temperature_color(temperature: f32) -> Color {
|
||||
let normalized_temperature = Self::normalize_temperature(temperature);
|
||||
Color::rgb(normalized_temperature, 1.0 - normalized_temperature, 0.0)
|
||||
}
|
||||
|
||||
#[cfg(feature = "render")]
|
||||
fn normalize_temperature(temperature: f32) -> f32 {
|
||||
(temperature - World::MIN_TEMPERATURE) / World::TEMPERATURE_SPAN
|
||||
}
|
||||
|
||||
#[cfg(feature = "render")]
|
||||
pub fn world_colors(&self) -> Vec<Color> {
|
||||
match self.get_world() {
|
||||
None => panic!("Called world_colors before generating world"),
|
||||
Some(world) => {
|
||||
let terrain_cells: Vec<_> = world.terrain.iter().rev().flatten().collect();
|
||||
|
||||
terrain_cells
|
||||
.iter()
|
||||
.map(|cell| self.generate_color(cell))
|
||||
.collect()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(feature = "render")]
|
||||
pub fn world_color_bytes(&self) -> Vec<u8> {
|
||||
self.world_colors()
|
||||
.iter()
|
||||
.flat_map(|color| {
|
||||
color
|
||||
.as_rgba_f32()
|
||||
.iter()
|
||||
.flat_map(|num| num.to_le_bytes())
|
||||
.collect::<Vec<u8>>()
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
}
|
||||
|
|
@ -25,6 +25,7 @@ define_enum!(ToolbarButton {
|
|||
Contours,
|
||||
});
|
||||
|
||||
#[cfg(feature = "render")]
|
||||
impl From<ToolbarButton> for &'static str {
|
||||
fn from(button: ToolbarButton) -> Self {
|
||||
match button {
|
||||
|
|
@ -37,6 +38,7 @@ impl From<ToolbarButton> for &'static str {
|
|||
}
|
||||
}
|
||||
}
|
||||
#[cfg(feature = "render")]
|
||||
impl From<&ToolbarButton> for &'static str {
|
||||
fn from(button: &ToolbarButton) -> Self {
|
||||
match button {
|
||||
|
|
@ -50,12 +52,14 @@ impl From<&ToolbarButton> for &'static str {
|
|||
}
|
||||
}
|
||||
|
||||
#[cfg(feature = "render")]
|
||||
impl From<ToolbarButton> for String {
|
||||
fn from(button: ToolbarButton) -> Self {
|
||||
<&'static str>::from(button).into()
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(feature = "render")]
|
||||
impl From<&ToolbarButton> for String {
|
||||
fn from(button: &ToolbarButton) -> Self {
|
||||
<&'static str>::from(button).into()
|
||||
|
|
|
|||
77
src/main.rs
77
src/main.rs
|
|
@ -93,10 +93,10 @@ use components::{
|
|||
markers::{InfoPanel, ToolbarButton},
|
||||
third_party::PanCam,
|
||||
};
|
||||
use planet::WorldManager;
|
||||
use plugins::WorldPlugins;
|
||||
#[cfg(feature = "render")]
|
||||
use resources::CursorMapPosition;
|
||||
use save::*;
|
||||
#[cfg(feature = "render")]
|
||||
use ui_helpers::{toolbar_button, toolbar_button_text};
|
||||
|
||||
|
|
@ -104,8 +104,16 @@ use ui_helpers::{toolbar_button, toolbar_button_text};
|
|||
fn refresh_world_texture(images: &mut Assets<Image>, world_manager: &WorldManager) {
|
||||
#[cfg(feature = "debug")]
|
||||
debug!("refreshing world texture");
|
||||
let image_handle = images.get_handle(world_manager.image_handle_id);
|
||||
images.get_mut(&image_handle).unwrap().data = world_manager.world_color_bytes();
|
||||
let image_handle = images.get_handle(world_manager.image_handle_id.expect("No image handle"));
|
||||
let world_image = images
|
||||
.get_mut(&image_handle)
|
||||
.expect("Image handle pointing to non-existing texture");
|
||||
world_image.resize(Extent3d {
|
||||
width: world_manager.world().width,
|
||||
height: world_manager.world().height,
|
||||
depth_or_array_layers: 1,
|
||||
});
|
||||
world_image.data = world_manager.world_color_bytes();
|
||||
|
||||
// TODO: Update Icosphere material... try to find out why it doesn't automatically=
|
||||
}
|
||||
|
|
@ -138,16 +146,19 @@ fn handle_toolbar_button(
|
|||
#[cfg(feature = "debug")]
|
||||
debug!("Toggling rainfall");
|
||||
world_manager.toggle_rainfall();
|
||||
refresh_world_texture(&mut images, &world_manager);
|
||||
}
|
||||
ToolbarButton::Temperature => {
|
||||
#[cfg(feature = "debug")]
|
||||
debug!("Toggling temperature");
|
||||
world_manager.toggle_temperature();
|
||||
refresh_world_texture(&mut images, &world_manager);
|
||||
}
|
||||
ToolbarButton::Contours => {
|
||||
#[cfg(feature = "debug")]
|
||||
debug!("Toggling contours");
|
||||
world_manager.toggle_contours();
|
||||
refresh_world_texture(&mut images, &world_manager);
|
||||
}
|
||||
ToolbarButton::GenerateWorld => {
|
||||
#[cfg(feature = "debug")]
|
||||
|
|
@ -155,6 +166,7 @@ fn handle_toolbar_button(
|
|||
_ = world_manager
|
||||
.new_world()
|
||||
.expect("Failed to generate new world");
|
||||
refresh_world_texture(&mut images, &world_manager);
|
||||
}
|
||||
ToolbarButton::SaveWorld => {
|
||||
#[cfg(feature = "debug")]
|
||||
|
|
@ -164,10 +176,10 @@ fn handle_toolbar_button(
|
|||
ToolbarButton::LoadWorld => {
|
||||
#[cfg(feature = "debug")]
|
||||
debug!("Loading world");
|
||||
_ = world_manager.load_world("planet.ron");
|
||||
_ = world_manager.load_world("planet.ron", &mut images);
|
||||
refresh_world_texture(&mut images, &world_manager);
|
||||
}
|
||||
}
|
||||
refresh_world_texture(&mut images, &world_manager)
|
||||
}
|
||||
Interaction::Hovered => {
|
||||
windows.primary_mut().set_cursor_icon(CursorIcon::Hand);
|
||||
|
|
@ -208,8 +220,8 @@ fn update_cursor_map_position(
|
|||
ndc_to_world.project_point3(ndc.extend(-1.0)).truncate() / WORLD_SCALE as f32;
|
||||
|
||||
let world = world_manager.world();
|
||||
cursor_map_position.x = world_position.x as i32 + world.width / 2 - 1;
|
||||
cursor_map_position.y = world.height / 2 - world_position.y as i32 - 1;
|
||||
cursor_map_position.x = world.width as i32 / 2 + f32::ceil(world_position.x) as i32 - 1;
|
||||
cursor_map_position.y = world.height as i32 / 2 + f32::ceil(world_position.y) as i32 - 1;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -229,11 +241,12 @@ fn update_info_panel(
|
|||
) {
|
||||
let world = world_manager.world();
|
||||
text.single_mut().sections[0].value = if cursor_position.x >= 0
|
||||
&& cursor_position.x < world.width
|
||||
&& cursor_position.x < world.width as i32
|
||||
&& cursor_position.y >= 0
|
||||
&& cursor_position.y < world.height
|
||||
&& cursor_position.y < world.height as i32
|
||||
{
|
||||
let cell = &world.terrain[cursor_position.y as usize][cursor_position.x as usize];
|
||||
|
||||
#[cfg(feature = "debug")]
|
||||
{
|
||||
format!(
|
||||
|
|
@ -248,6 +261,7 @@ fn update_info_panel(
|
|||
cell.temperature
|
||||
)
|
||||
}
|
||||
|
||||
#[cfg(not(feature = "debug"))]
|
||||
{
|
||||
format!(
|
||||
|
|
@ -256,14 +270,22 @@ fn update_info_panel(
|
|||
)
|
||||
}
|
||||
} else {
|
||||
format!(
|
||||
"FPS: ~{}\nMouse position: {}\nOut of bounds",
|
||||
match diagnostics.get_measurement(FrameTimeDiagnosticsPlugin::FPS) {
|
||||
None => f64::NAN,
|
||||
Some(fps) => fps.value.round(),
|
||||
},
|
||||
*cursor_position
|
||||
)
|
||||
#[cfg(feature = "debug")]
|
||||
{
|
||||
format!(
|
||||
"FPS: ~{}\nMouse position: {}\nOut of bounds",
|
||||
match diagnostics.get_measurement(FrameTimeDiagnosticsPlugin::FPS) {
|
||||
None => f64::NAN,
|
||||
Some(fps) => fps.value.round(),
|
||||
},
|
||||
*cursor_position
|
||||
)
|
||||
}
|
||||
|
||||
#[cfg(not(feature = "debug"))]
|
||||
{
|
||||
format!("Mouse position: {}\nOut of bounds", *cursor_position)
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
|
|
@ -278,8 +300,8 @@ fn generate_graphics(
|
|||
) {
|
||||
let world = world_manager.world();
|
||||
let custom_sprite_size = Vec2 {
|
||||
x: (WORLD_SCALE * world.width) as f32,
|
||||
y: (WORLD_SCALE * world.height) as f32,
|
||||
x: (WORLD_SCALE * world.width as i32) as f32,
|
||||
y: (WORLD_SCALE * world.height as i32) as f32,
|
||||
};
|
||||
|
||||
let image_handle = images.add(Image {
|
||||
|
|
@ -287,8 +309,8 @@ fn generate_graphics(
|
|||
texture_descriptor: TextureDescriptor {
|
||||
label: None,
|
||||
size: Extent3d {
|
||||
width: world.width as u32,
|
||||
height: world.height as u32,
|
||||
width: world.width,
|
||||
height: world.height,
|
||||
..default()
|
||||
},
|
||||
dimension: TextureDimension::D2,
|
||||
|
|
@ -299,7 +321,7 @@ fn generate_graphics(
|
|||
},
|
||||
..default()
|
||||
});
|
||||
world_manager.image_handle_id = image_handle.id;
|
||||
world_manager.image_handle_id = Some(image_handle.id);
|
||||
|
||||
#[cfg(feature = "planet_view")]
|
||||
{
|
||||
|
|
@ -338,9 +360,12 @@ fn generate_graphics(
|
|||
|
||||
_ = commands
|
||||
.spawn_bundle(Camera2dBundle { ..default() })
|
||||
.insert(PanCam::default());
|
||||
.insert(PanCam {
|
||||
max_scale: Some(80.0),
|
||||
..default()
|
||||
});
|
||||
_ = commands.spawn_bundle(SpriteBundle {
|
||||
texture: images.get_handle(world_manager.image_handle_id),
|
||||
texture: images.get_handle(world_manager.image_handle_id.unwrap()),
|
||||
sprite: Sprite {
|
||||
custom_size: Some(custom_sprite_size),
|
||||
..default()
|
||||
|
|
@ -423,8 +448,8 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
|
|||
// Use nearest-neighbor rendering for cripsier pixels
|
||||
.insert_resource(ImageSettings::default_nearest())
|
||||
.insert_resource(WindowDescriptor {
|
||||
width: (WORLD_SCALE * world.width) as f32,
|
||||
height: (WORLD_SCALE * world.height) as f32,
|
||||
width: (WORLD_SCALE * world.width as i32) as f32,
|
||||
height: (WORLD_SCALE * world.height as i32) as f32,
|
||||
title: String::from("World-RS"),
|
||||
resizable: true,
|
||||
..default()
|
||||
|
|
|
|||
|
|
@ -3,7 +3,7 @@ pub(crate) struct WorldPlugins;
|
|||
use bevy::{
|
||||
app::{PluginGroup, PluginGroupBuilder},
|
||||
core::CorePlugin,
|
||||
diagnostic::{DiagnosticsPlugin, FrameTimeDiagnosticsPlugin, LogDiagnosticsPlugin},
|
||||
diagnostic::{DiagnosticsPlugin, LogDiagnosticsPlugin},
|
||||
log::LogPlugin,
|
||||
time::TimePlugin,
|
||||
};
|
||||
|
|
@ -43,10 +43,6 @@ impl PluginGroup for WorldPlugins {
|
|||
use bevy::pbr::PbrPlugin;
|
||||
_ = group.add(PbrPlugin::default())
|
||||
}
|
||||
#[cfg(feature = "debug")]
|
||||
{
|
||||
_ = group.add(FrameTimeDiagnosticsPlugin::default());
|
||||
}
|
||||
}
|
||||
#[cfg(not(feature = "render"))]
|
||||
{
|
||||
|
|
@ -54,9 +50,12 @@ impl PluginGroup for WorldPlugins {
|
|||
_ = group.add(ScheduleRunnerPlugin::default());
|
||||
}
|
||||
|
||||
_ = group
|
||||
.add(DiagnosticsPlugin::default())
|
||||
.add(FrameTimeDiagnosticsPlugin::default())
|
||||
.add(LogDiagnosticsPlugin::default());
|
||||
_ = group.add(DiagnosticsPlugin::default());
|
||||
#[cfg(all(feature = "debug"))]
|
||||
{
|
||||
use bevy::diagnostic::FrameTimeDiagnosticsPlugin;
|
||||
_ = group.add(FrameTimeDiagnosticsPlugin::default());
|
||||
}
|
||||
_ = group.add(LogDiagnosticsPlugin::default());
|
||||
}
|
||||
}
|
||||
|
|
|
|||
Loading…
Reference in a new issue