From adafd5a3702f4ef037e1527d9753077104df6b91 Mon Sep 17 00:00:00 2001 From: eater <=@eater.me> Date: Thu, 9 Apr 2020 14:50:00 +0200 Subject: [PATCH] Initial commit --- .gitignore | 1 + Cargo.lock | 741 +++++++++++++++++++++ Cargo.toml | 2 + eatgel-graph/Cargo.toml | 8 + eatgel-graph/src/lib.rs | 95 +++ eatgel-proc-macro/Cargo.toml | 16 + eatgel-proc-macro/src/lib.rs | 191 ++++++ eatgel/.gitignore | 2 + eatgel/Cargo.toml | 18 + eatgel/src/buffer.rs | 185 +++++ eatgel/src/err.rs | 31 + eatgel/src/lib.rs | 217 ++++++ eatgel/src/shader.rs | 144 ++++ eatgel/src/texture.rs | 180 +++++ eatgel/src/types.rs | 120 ++++ eatgel/src/update_uniform.rs | 342 ++++++++++ triangle-time/.gitignore | 1 + triangle-time/Cargo.lock | 388 +++++++++++ triangle-time/Cargo.toml | 14 + triangle-time/res/eater.png | Bin 0 -> 4410 bytes triangle-time/res/pizza.png | Bin 0 -> 210513 bytes triangle-time/shaders/simple_fragment.glsl | 11 + triangle-time/shaders/simple_vertex.glsl | 17 + triangle-time/src/main.rs | 394 +++++++++++ 24 files changed, 3118 insertions(+) create mode 100644 .gitignore create mode 100644 Cargo.lock create mode 100644 Cargo.toml create mode 100644 eatgel-graph/Cargo.toml create mode 100644 eatgel-graph/src/lib.rs create mode 100644 eatgel-proc-macro/Cargo.toml create mode 100644 eatgel-proc-macro/src/lib.rs create mode 100644 eatgel/.gitignore create mode 100644 eatgel/Cargo.toml create mode 100644 eatgel/src/buffer.rs create mode 100644 eatgel/src/err.rs create mode 100644 eatgel/src/lib.rs create mode 100644 eatgel/src/shader.rs create mode 100644 eatgel/src/texture.rs create mode 100644 eatgel/src/types.rs create mode 100644 eatgel/src/update_uniform.rs create mode 100644 triangle-time/.gitignore create mode 100644 triangle-time/Cargo.lock create mode 100644 triangle-time/Cargo.toml create mode 100644 triangle-time/res/eater.png create mode 100644 triangle-time/res/pizza.png create mode 100644 triangle-time/shaders/simple_fragment.glsl create mode 100644 triangle-time/shaders/simple_vertex.glsl create mode 100644 triangle-time/src/main.rs diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..eb5a316 --- /dev/null +++ b/.gitignore @@ -0,0 +1 @@ +target diff --git a/Cargo.lock b/Cargo.lock new file mode 100644 index 0000000..048ce40 --- /dev/null +++ b/Cargo.lock @@ -0,0 +1,741 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +[[package]] +name = "adler32" +version = "1.0.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5d2e7343e7fc9de883d1b0341e0b13970f764c14101234857d2ddafa1cb1cac2" + +[[package]] +name = "alga" +version = "0.9.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4f823d037a7ec6ea2197046bafd4ae150e6bc36f9ca347404f46a46823fa84f2" +dependencies = [ + "approx", + "num-complex", + "num-traits", +] + +[[package]] +name = "approx" +version = "0.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f0e60b75072ecd4168020818c0107f2857bb6c4e64252d8d3983f6263b40a5c3" +dependencies = [ + "num-traits", +] + +[[package]] +name = "autocfg" +version = "1.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f8aac770f1885fd7e387acedd76065302551364496e46b3dd00860b2f8359b9d" + +[[package]] +name = "bitflags" +version = "1.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cf1de2fe8c75bc145a2f577add951f8134889b4795d47466a54a5c846d691693" + +[[package]] +name = "bytemuck" +version = "1.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "37fa13df2292ecb479ec23aa06f4507928bef07839be9ef15281411076629431" + +[[package]] +name = "byteorder" +version = "1.3.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "08c48aae112d48ed9f069b33538ea9e3e90aa263cfa3d1c24309612b1f7472de" + +[[package]] +name = "c2-chacha" +version = "0.2.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "214238caa1bf3a496ec3392968969cab8549f96ff30652c9e56885329315f6bb" +dependencies = [ + "ppv-lite86", +] + +[[package]] +name = "cc" +version = "1.0.50" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "95e28fa049fda1c330bcf9d723be7663a899c4679724b34c81e9f5a326aab8cd" + +[[package]] +name = "cfg-if" +version = "0.1.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4785bdd1c96b2a846b2bd7cc02e86b6b3dbf14e7e53446c4f54c92a361040822" + +[[package]] +name = "cmake" +version = "0.1.42" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "81fb25b677f8bf1eb325017cb6bb8452f87969db0fedb4f757b297bee78a7c62" +dependencies = [ + "cc", +] + +[[package]] +name = "color_quant" +version = "1.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0dbbb57365263e881e805dc77d94697c9118fd94d8da011240555aa7b23445bd" + +[[package]] +name = "crc32fast" +version = "1.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ba125de2af0df55319f41944744ad91c71113bf74a4646efff39afe1f6842db1" +dependencies = [ + "cfg-if", +] + +[[package]] +name = "crossbeam-deque" +version = "0.7.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9f02af974daeee82218205558e51ec8768b48cf524bd01d550abe5573a608285" +dependencies = [ + "crossbeam-epoch", + "crossbeam-utils", + "maybe-uninit", +] + +[[package]] +name = "crossbeam-epoch" +version = "0.8.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "058ed274caafc1f60c4997b5fc07bf7dc7cca454af7c6e81edffe5f33f70dace" +dependencies = [ + "autocfg", + "cfg-if", + "crossbeam-utils", + "lazy_static", + "maybe-uninit", + "memoffset", + "scopeguard", +] + +[[package]] +name = "crossbeam-queue" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c695eeca1e7173472a32221542ae469b3e9aac3a4fc81f7696bcad82029493db" +dependencies = [ + "cfg-if", + "crossbeam-utils", +] + +[[package]] +name = "crossbeam-utils" +version = "0.7.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c3c7c73a2d1e9fc0886a08b93e98eb643461230d5f1925e4036204d5f2e261a8" +dependencies = [ + "autocfg", + "cfg-if", + "lazy_static", +] + +[[package]] +name = "deflate" +version = "0.7.20" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "707b6a7b384888a70c8d2e8650b3e60170dfc6a67bb4aa67b6dfca57af4bedb4" +dependencies = [ + "adler32", + "byteorder", +] + +[[package]] +name = "eatgel" +version = "0.1.0" +dependencies = [ + "eatgel-proc-macro", + "gl", + "image", + "nalgebra", + "nalgebra-glm", +] + +[[package]] +name = "eatgel-graph" +version = "0.1.0" +dependencies = [ + "nalgebra-glm", +] + +[[package]] +name = "eatgel-proc-macro" +version = "0.1.0" +dependencies = [ + "proc-macro2", + "proc_macro_roids", + "quote", + "syn", +] + +[[package]] +name = "either" +version = "1.5.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bb1f6b1ce1c140482ea30ddd3335fc0024ac7ee112895426e0a629a6c20adfe3" + +[[package]] +name = "generic-array" +version = "0.13.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0ed1e761351b56f54eb9dcd0cfaca9fd0daecf93918e1cfc01c8a3d26ee7adcd" +dependencies = [ + "typenum", +] + +[[package]] +name = "getrandom" +version = "0.1.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7abc8dd8451921606d809ba32e95b6111925cd2906060d2dcc29c070220503eb" +dependencies = [ + "cfg-if", + "libc", + "wasi", +] + +[[package]] +name = "gif" +version = "0.10.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "471d90201b3b223f3451cd4ad53e34295f16a1df17b1edf3736d47761c3981af" +dependencies = [ + "color_quant", + "lzw", +] + +[[package]] +name = "gl" +version = "0.14.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a94edab108827d67608095e269cf862e60d920f144a5026d3dbcfd8b877fb404" +dependencies = [ + "gl_generator", +] + +[[package]] +name = "gl_generator" +version = "0.14.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1a95dfc23a2b4a9a2f5ab41d194f8bfda3cabec42af4e39f08c339eb2a0c124d" +dependencies = [ + "khronos_api", + "log", + "xml-rs", +] + +[[package]] +name = "glfw" +version = "0.36.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3b4c1f2e99ce4181c37d9582986ed32a8f55235bdc9427258d96d09cc9666a29" +dependencies = [ + "bitflags", + "glfw-sys", + "libc", + "log", + "objc", + "raw-window-handle", + "semver", + "winapi", +] + +[[package]] +name = "glfw-sys" +version = "3.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0b567b13b593ec58ea912b2658ee6230ffe20a069fa5b771800acc69bb3a157e" +dependencies = [ + "cmake", +] + +[[package]] +name = "hermit-abi" +version = "0.1.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1010591b26bbfe835e9faeabeb11866061cc7dcebffd56ad7d0942d0e61aefd8" +dependencies = [ + "libc", +] + +[[package]] +name = "image" +version = "0.23.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ef4e336ec01a678e7ab692914c641181528e8656451e6252f8f9e33728882eaf" +dependencies = [ + "bytemuck", + "byteorder", + "gif", + "jpeg-decoder", + "num-iter", + "num-rational", + "num-traits", + "png", + "scoped_threadpool", + "tiff", +] + +[[package]] +name = "inflate" +version = "0.4.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1cdb29978cc5797bd8dcc8e5bf7de604891df2a8dc576973d71a281e916db2ff" +dependencies = [ + "adler32", +] + +[[package]] +name = "jpeg-decoder" +version = "0.1.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0256f0aec7352539102a9efbcb75543227b7ab1117e0f95450023af730128451" +dependencies = [ + "byteorder", + "rayon", +] + +[[package]] +name = "khronos_api" +version = "3.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e2db585e1d738fc771bf08a151420d3ed193d9d895a36df7f6f8a9456b911ddc" + +[[package]] +name = "lazy_static" +version = "1.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646" + +[[package]] +name = "libc" +version = "0.2.67" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "eb147597cdf94ed43ab7a9038716637d2d1bf2bc571da995d0028dec06bd3018" + +[[package]] +name = "libm" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c7d73b3f436185384286bd8098d17ec07c9a7d2388a6599f824d8502b529702a" + +[[package]] +name = "log" +version = "0.4.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "14b6052be84e6b71ab17edffc2eeabf5c2c3ae1fdb464aae35ac50c67a44e1f7" +dependencies = [ + "cfg-if", +] + +[[package]] +name = "lzw" +version = "0.10.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7d947cbb889ed21c2a84be6ffbaebf5b4e0f4340638cba0444907e38b56be084" + +[[package]] +name = "malloc_buf" +version = "0.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "62bb907fe88d54d8d9ce32a3cceab4218ed2f6b7d35617cafe9adf84e43919cb" +dependencies = [ + "libc", +] + +[[package]] +name = "matrixmultiply" +version = "0.2.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d4f7ec66360130972f34830bfad9ef05c6610a43938a467bcc9ab9369ab3478f" +dependencies = [ + "rawpointer", +] + +[[package]] +name = "maybe-uninit" +version = "2.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "60302e4db3a61da70c0cb7991976248362f30319e88850c487b9b95bbf059e00" + +[[package]] +name = "memoffset" +version = "0.5.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "75189eb85871ea5c2e2c15abbdd541185f63b408415e5051f5cac122d8c774b9" +dependencies = [ + "rustc_version", +] + +[[package]] +name = "miniz_oxide" +version = "0.3.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "aa679ff6578b1cddee93d7e82e263b94a575e0bfced07284eb0c037c1d2416a5" +dependencies = [ + "adler32", +] + +[[package]] +name = "nalgebra" +version = "0.20.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c6511777ed3da44b6a11e732a66a7d6274dfbbcd68ad968e64b778dcb829d94a" +dependencies = [ + "alga", + "approx", + "generic-array", + "matrixmultiply", + "num-complex", + "num-rational", + "num-traits", + "rand", + "rand_distr", + "typenum", +] + +[[package]] +name = "nalgebra-glm" +version = "0.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5ae78da13d67be0d2e4ab567490477e4c9f314fc151ddfff6713b15bdbb2aa72" +dependencies = [ + "alga", + "approx", + "nalgebra", + "num-traits", +] + +[[package]] +name = "num-complex" +version = "0.2.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b6b19411a9719e753aff12e5187b74d60d3dc449ec3f4dc21e3989c3f554bc95" +dependencies = [ + "autocfg", + "num-traits", +] + +[[package]] +name = "num-integer" +version = "0.1.42" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3f6ea62e9d81a77cd3ee9a2a5b9b609447857f3d358704331e4ef39eb247fcba" +dependencies = [ + "autocfg", + "num-traits", +] + +[[package]] +name = "num-iter" +version = "0.1.40" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dfb0800a0291891dd9f4fe7bd9c19384f98f7fbe0cd0f39a2c6b88b9868bbc00" +dependencies = [ + "autocfg", + "num-integer", + "num-traits", +] + +[[package]] +name = "num-rational" +version = "0.2.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "da4dc79f9e6c81bef96148c8f6b8e72ad4541caa4a24373e900a36da07de03a3" +dependencies = [ + "autocfg", + "num-integer", + "num-traits", +] + +[[package]] +name = "num-traits" +version = "0.2.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c62be47e61d1842b9170f0fdeec8eba98e60e90e5446449a0545e5152acd7096" +dependencies = [ + "autocfg", + "libm", +] + +[[package]] +name = "num_cpus" +version = "1.12.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "46203554f085ff89c235cd12f7075f3233af9b11ed7c9e16dfe2560d03313ce6" +dependencies = [ + "hermit-abi", + "libc", +] + +[[package]] +name = "objc" +version = "0.2.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "915b1b472bc21c53464d6c8461c9d3af805ba1ef837e1cac254428f4a77177b1" +dependencies = [ + "malloc_buf", +] + +[[package]] +name = "png" +version = "0.15.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ef859a23054bbfee7811284275ae522f0434a3c8e7f4b74bd4a35ae7e1c4a283" +dependencies = [ + "bitflags", + "crc32fast", + "deflate", + "inflate", +] + +[[package]] +name = "ppv-lite86" +version = "0.2.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "74490b50b9fbe561ac330df47c08f3f33073d2d00c150f719147d7c54522fa1b" + +[[package]] +name = "proc-macro2" +version = "1.0.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6c09721c6781493a2a492a96b5a5bf19b65917fe6728884e7c44dd0c60ca3435" +dependencies = [ + "unicode-xid", +] + +[[package]] +name = "proc_macro_roids" +version = "0.7.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "06675fa2c577f52bcf77fbb511123927547d154faa08097cc012c66ec3c9611a" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "quote" +version = "1.0.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2bdc6c187c65bca4260c9011c9e3132efe4909da44726bad24cf7572ae338d7f" +dependencies = [ + "proc-macro2", +] + +[[package]] +name = "rand" +version = "0.7.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6a6b1679d49b24bbfe0c803429aa1874472f50d9b363131f0e89fc356b544d03" +dependencies = [ + "getrandom", + "libc", + "rand_chacha", + "rand_core", + "rand_hc", +] + +[[package]] +name = "rand_chacha" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "03a2a90da8c7523f554344f921aa97283eadf6ac484a6d2a7d0212fa7f8d6853" +dependencies = [ + "c2-chacha", + "rand_core", +] + +[[package]] +name = "rand_core" +version = "0.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "90bde5296fc891b0cef12a6d03ddccc162ce7b2aff54160af9338f8d40df6d19" +dependencies = [ + "getrandom", +] + +[[package]] +name = "rand_distr" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "96977acbdd3a6576fb1d27391900035bf3863d4a16422973a409b488cf29ffb2" +dependencies = [ + "rand", +] + +[[package]] +name = "rand_hc" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ca3129af7b92a17112d59ad498c6f81eaf463253766b90396d39ea7a39d6613c" +dependencies = [ + "rand_core", +] + +[[package]] +name = "raw-window-handle" +version = "0.3.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0a441a7a6c80ad6473bd4b74ec1c9a4c951794285bf941c2126f607c72e48211" +dependencies = [ + "libc", +] + +[[package]] +name = "rawpointer" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "60a357793950651c4ed0f3f52338f53b2f809f32d83a07f72909fa13e4c6c1e3" + +[[package]] +name = "rayon" +version = "1.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "db6ce3297f9c85e16621bb8cca38a06779ffc31bb8184e1be4bed2be4678a098" +dependencies = [ + "crossbeam-deque", + "either", + "rayon-core", +] + +[[package]] +name = "rayon-core" +version = "1.7.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "08a89b46efaf957e52b18062fb2f4660f8b8a4dde1807ca002690868ef2c85a9" +dependencies = [ + "crossbeam-deque", + "crossbeam-queue", + "crossbeam-utils", + "lazy_static", + "num_cpus", +] + +[[package]] +name = "rustc_version" +version = "0.2.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "138e3e0acb6c9fb258b19b67cb8abd63c00679d2851805ea151465464fe9030a" +dependencies = [ + "semver", +] + +[[package]] +name = "scoped_threadpool" +version = "0.1.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1d51f5df5af43ab3f1360b429fa5e0152ac5ce8c0bd6485cae490332e96846a8" + +[[package]] +name = "scopeguard" +version = "1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d29ab0c6d3fc0ee92fe66e2d99f700eab17a8d57d1c1d3b748380fb20baa78cd" + +[[package]] +name = "semver" +version = "0.9.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1d7eb9ef2c18661902cc47e535f9bc51b78acd254da71d375c2f6720d9a40403" +dependencies = [ + "semver-parser", +] + +[[package]] +name = "semver-parser" +version = "0.7.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "388a1df253eca08550bef6c72392cfe7c30914bf41df5269b68cbd6ff8f570a3" + +[[package]] +name = "syn" +version = "1.0.16" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "123bd9499cfb380418d509322d7a6d52e5315f064fe4b3ad18a53d6b92c07859" +dependencies = [ + "proc-macro2", + "quote", + "unicode-xid", +] + +[[package]] +name = "tiff" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "002351e428db1eb1d8656d4ca61947c3519ac3191e1c804d4600cd32093b77ad" +dependencies = [ + "byteorder", + "lzw", + "miniz_oxide", +] + +[[package]] +name = "triangle-time" +version = "0.1.0" +dependencies = [ + "eatgel", + "gl", + "glfw", + "image", + "nalgebra-glm", +] + +[[package]] +name = "typenum" +version = "1.11.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6d2783fe2d6b8c1101136184eb41be8b1ad379e4657050b8aaff0c79ee7575f9" + +[[package]] +name = "unicode-xid" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "826e7639553986605ec5979c7dd957c7895e93eabed50ab2ffa7f6128a75097c" + +[[package]] +name = "wasi" +version = "0.9.0+wasi-snapshot-preview1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cccddf32554fecc6acb585f82a32a72e28b48f8c4c1883ddfeeeaa96f7d8e519" + +[[package]] +name = "winapi" +version = "0.3.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8093091eeb260906a183e6ae1abdba2ef5ef2257a21801128899c3fc699229c6" +dependencies = [ + "winapi-i686-pc-windows-gnu", + "winapi-x86_64-pc-windows-gnu", +] + +[[package]] +name = "winapi-i686-pc-windows-gnu" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6" + +[[package]] +name = "winapi-x86_64-pc-windows-gnu" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f" + +[[package]] +name = "xml-rs" +version = "0.8.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "541b12c998c5b56aa2b4e6f18f03664eef9a4fd0a246a55594efae6cc2d964b5" diff --git a/Cargo.toml b/Cargo.toml new file mode 100644 index 0000000..911daf5 --- /dev/null +++ b/Cargo.toml @@ -0,0 +1,2 @@ +[workspace] +members = ["triangle-time", "eatgel", "eatgel-proc-macro", "eatgel-graph"] diff --git a/eatgel-graph/Cargo.toml b/eatgel-graph/Cargo.toml new file mode 100644 index 0000000..c28fd1e --- /dev/null +++ b/eatgel-graph/Cargo.toml @@ -0,0 +1,8 @@ +[package] +name = "eatgel-graph" +version = "0.1.0" +authors = ["eater <=@eater.me>"] +edition = "2018" + +[dependencies] +nalgebra-glm = "0.6.0" \ No newline at end of file diff --git a/eatgel-graph/src/lib.rs b/eatgel-graph/src/lib.rs new file mode 100644 index 0000000..2a99042 --- /dev/null +++ b/eatgel-graph/src/lib.rs @@ -0,0 +1,95 @@ +use nalgebra_glm::{identity, vec3, Mat4, Vec3, U4}; +use std::cell::{Ref, RefCell}; +use std::rc::Rc; + +struct Graph { + root: NodeRef, +} + +impl Graph { + fn new() -> Graph { + let mut node = Node::new(); + node.is_root = true; + Graph { + root: node.into_ref(), + } + } +} + +type NodeRef = Rc>; + +trait NodeExt { + fn append_child(&self, child: &NodeRef); + fn remove_child(&self, child: &NodeRef); +} + +struct Node { + rotation: Vec3, + transform: Mat4, + origin: Vec3, + absolute_position: Option, + children: Vec, + parent: Option, + is_root: bool, +} + +impl Node { + fn new() -> Node { + Node { + rotation: vec3(0.0, 0.0, 0.0), + transform: identity::<_, U4>(), + origin: vec3(0.0, 0.0, 0.0), + absolute_position: None, + children: vec![], + parent: None, + is_root: false, + } + } + + fn into_ref(self) -> NodeRef { + Rc::new(RefCell::new(self)) + } +} + +impl NodeExt for NodeRef { + fn append_child(&self, child: &NodeRef) { + if Rc::ptr_eq(&self, child) { + return; + } + + if let Some(parent) = child.borrow().parent.clone() { + parent.remove_child(&self) + } + + self.borrow_mut().children.push(child.clone()) + } + + fn remove_child(&self, child: &NodeRef) { + let children = &mut self.borrow_mut().children; + let mut offset: usize = 0; + for i in 0..childs.len() { + if Rc::ptr_eq(&childs[i - offset], child) { + children.remove(i - offset); + offset += 1; + } + } + } +} + +#[cfg(test)] +pub mod test { + use crate::*; + + #[test] + pub fn it_works() { + let node = Node::new().into_ref(); + node.append_child(&node); + node.remove_child(&node); + let second_node = Node::new().into_ref(); + node.append_child(&second_node); + + let graph = Graph::new(); + graph.root.append_child(&node); + assert_eq!(1, graph.root.borrow().children.len()); + } +} diff --git a/eatgel-proc-macro/Cargo.toml b/eatgel-proc-macro/Cargo.toml new file mode 100644 index 0000000..d3a6661 --- /dev/null +++ b/eatgel-proc-macro/Cargo.toml @@ -0,0 +1,16 @@ +[package] +name = "eatgel-proc-macro" +version = "0.1.0" +authors = ["eater <=@eater.me>"] +edition = "2018" + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[lib] +proc-macro = true + +[dependencies] +proc_macro_roids = "0.7.0" +proc-macro2 = "1.0.9" +syn = "1.0.16" +quote = "1.0.3" \ No newline at end of file diff --git a/eatgel-proc-macro/src/lib.rs b/eatgel-proc-macro/src/lib.rs new file mode 100644 index 0000000..3b65d7d --- /dev/null +++ b/eatgel-proc-macro/src/lib.rs @@ -0,0 +1,191 @@ +extern crate proc_macro; + +use proc_macro::{Literal, TokenStream, TokenTree}; +use proc_macro_roids::{DeriveInputStructExt, FieldExt}; +use quote::quote; +use std::str::FromStr; + +use proc_macro2::TokenStream as TokenStream2; +use syn::{parse_macro_input, parse_quote, DeriveInput}; + +#[proc_macro_derive(ShaderData, attributes(skip))] +pub fn derive_shader_data(token_stream: TokenStream) -> TokenStream { + let mut iter = token_stream.into_iter(); + let empty = TokenStream::new(); + + if let Some(TokenTree::Ident(ident)) = iter.next() { + if ident.to_string() != "struct" { + return empty; + } + } else { + return empty; + } + + let struct_name = if let Some(TokenTree::Ident(ident)) = iter.next() { + ident.to_string() + } else { + return empty; + }; + + let mut group = if let Some(TokenTree::Group(group)) = iter.next() { + group + } else { + return empty; + } + .stream() + .into_iter(); + + let mut keys = vec![]; + + loop { + let item = group.next(); + if item.is_none() { + break; + } + + let item = item.unwrap(); + + if item.to_string() == "#" { + if let Some(TokenTree::Group(tag)) = group.next() { + if tag.to_string() == "[skip]" { + while let Some(x) = group.next() { + if x.to_string() == "," { + break; + } + } + } + continue; + } else { + break; + } + } + + let name = match item { + TokenTree::Ident(ident) => ident.to_string(), + _ => break, + }; + + // : + group.next(); + let mut stream = vec![]; + while let Some(x) = group.next() { + if x.to_string() == "," { + break; + } + + stream.push(x); + } + + keys.push(name); + } + + let init = keys + .iter() + .map(|name| Literal::string(&name).to_string()) + .collect::>() + .join(", "); + + let mut index = -1; + + let apply = keys + .iter() + .map(|name| { + index += 1; + + format!( + "(gl as &dyn UpdateUniform<_>).update_uniform_by_index(gl, program_id, {}, &self.{});", + index, + name + ) + }) + .collect::>() + .join("\n"); + + let gen_source = format!( + r#" +impl ::eatgel::ShaderData for {} {{ + fn init(&mut self, gl: &mut ::eatgel::GlContext, program_id: u32) {{ + gl.register_uniforms(program_id, &[{}]); + }} + fn apply(&self, gl: &::eatgel::GlContext, program_id: u32) {{ + {} + }} +}} +"#, + struct_name, init, apply, + ); + + TokenStream::from_str(&gen_source).unwrap() +} + +#[proc_macro_derive(VertexData, attributes(skip))] +pub fn derive_vertex_data(token_stream: TokenStream) -> TokenStream { + let ast = parse_macro_input!(token_stream as DeriveInput); + let name = &ast.ident; + + let mut index = -1; + let fields = ast + .fields() + .iter() + .map(move |field| { + index += 1; + let name = index; + (name, field) + }) + .filter(|(_, field)| !field.is_phantom_data()) + .filter(|(_, field)| !field.contains_tag(&parse_quote!(vertex_data), &parse_quote!(skip))); + + let sizes = fields + .clone() + .map(|(_, field)| { + let type_name = field.type_name(); + + quote!( + ::std::mem::size_of::<#type_name>() + ) + }) + .collect::>(); + + let types = fields + .clone() + .map(|(_, field)| { + let type_name = field.type_name(); + + quote!( + ::eatgel::type_descriptor_of::<#type_name>() + ) + }) + .collect::>(); + + let pointers = fields + .map(|(index, field)| { + if let Some(name) = field.ident.as_ref() { + quote!( + self.#name.as_ptr() as *const ::std::ffi::c_void + ) + } else { + quote!( + self.#index.as_ptr() as *const ::std::ffi::c_void + ) + } + }) + .collect::>(); + + let token_stream2: TokenStream2 = quote!( + impl ::eatgel::VertexData for #name { + fn get_sizes() -> Box<[usize]> { + return vec![#(#sizes,)*].into_boxed_slice() + } + + fn get_types() -> Box<[::eatgel::TypeDescriptor]> { + return vec![#(#types,)*].into_boxed_slice() + } + + fn get_pointers(&self) -> Box<[*const ::std::ffi::c_void]> { + return vec![#(#pointers,)*].into_boxed_slice() + } + } + ); + + token_stream2.into() +} diff --git a/eatgel/.gitignore b/eatgel/.gitignore new file mode 100644 index 0000000..96ef6c0 --- /dev/null +++ b/eatgel/.gitignore @@ -0,0 +1,2 @@ +/target +Cargo.lock diff --git a/eatgel/Cargo.toml b/eatgel/Cargo.toml new file mode 100644 index 0000000..0bd24f4 --- /dev/null +++ b/eatgel/Cargo.toml @@ -0,0 +1,18 @@ +[package] +name = "eatgel" +version = "0.1.0" +authors = ["eater <=@eater.me>"] +edition = "2018" + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[dependencies] +gl = "0.14.0" +nalgebra-glm = "0.6.0" +nalgebra = "0.20.0" +image = "0.23.0" +eatgel-proc-macro = { path = "../eatgel-proc-macro", optional = true } + +[features] +derive = ["eatgel-proc-macro"] +default = ["derive"] \ No newline at end of file diff --git a/eatgel/src/buffer.rs b/eatgel/src/buffer.rs new file mode 100644 index 0000000..978e002 --- /dev/null +++ b/eatgel/src/buffer.rs @@ -0,0 +1,185 @@ +use crate::types::TypeDescriptor; +use std::ffi::c_void; +use std::ops::Range; + +pub struct StaticBufferNonIndexed { + pub vao: u32, + pub attributes: Vec, + pub elements: usize, +} + +impl StaticBufferNonIndexed { + pub fn bind(&self) { + unsafe { + gl::BindVertexArray(self.vao); + } + } + + pub fn draw(&self) { + self.bind(); + + unsafe { gl::DrawArrays(gl::TRIANGLES, 0, self.elements as i32) } + } +} + +pub struct StaticBuffer { + pub vao: u32, + pub attributes: Vec, + pub ebo: u32, + pub indices: usize, +} + +impl StaticBuffer { + pub fn bind(&self) { + unsafe { + gl::BindVertexArray(self.vao); + gl::BindBuffer(gl::ELEMENT_ARRAY_BUFFER, self.ebo); + } + } + + pub fn draw(&self) { + self.bind(); + + unsafe { + gl::DrawElements( + gl::TRIANGLES, + self.indices as i32, + gl::UNSIGNED_INT, + 0 as *const c_void, + ) + } + } +} + +impl Drop for StaticBuffer { + fn drop(&mut self) { + unsafe { gl::DeleteVertexArrays(1, [self.vao].as_ptr()) } + } +} + +pub struct Attributes { + mem: Box<[u8]>, + pub attributes: Vec, + pub size: usize, + pub elements: usize, +} + +impl Attributes { + pub fn as_ptr(&self) -> *const c_void { + self.mem.as_ptr() as *const c_void + } +} + +pub struct Attribute { + pub amount: usize, + pub stride: usize, + pub offset: usize, + pub gl_type: u32, +} + +pub trait VertexData { + fn get_sizes() -> Box<[usize]>; + fn get_types() -> Box<[TypeDescriptor]>; + fn get_pointers(&self) -> Box<[*const c_void]>; +} + +pub trait VertexDataCollection +where + D: VertexData, +{ + fn get_amount(&self) -> usize; + fn get_list(&self) -> &[D]; + fn create_ptr(&self, interleaved: bool, range: Option>) -> Attributes { + let sizes = D::get_sizes(); + let struct_size = sizes.clone().iter().sum(); + let range = range.unwrap_or(0..self.get_amount()); + let amount = range.end - range.start; + let mut list = vec![0u8; struct_size * amount]; + let items = self.get_list(); + + for i in range.clone() { + let item = &items[i]; + let pointers = item.get_pointers(); + let sizes_and_pointers = sizes + .iter() + .zip(pointers.iter()) + .collect::>(); + + let mut offset = 0; + + for (size, ptr) in sizes_and_pointers { + let index = if interleaved { + offset + (struct_size * (i - range.start)) + } else { + (offset * amount) + size * i + }; + + unsafe { + std::ptr::copy(ptr.cast(), list.as_mut_ptr().add(index), *size); + } + + offset += size; + } + } + + let mut attributes = vec![]; + let mut offset = 0; + for (size, type_desc) in sizes.iter().zip(D::get_types().iter()) { + attributes.push(Attribute { + amount: type_desc.amount as usize, + gl_type: type_desc.gl_type, + stride: if interleaved { struct_size } else { *size }, + offset: if interleaved { offset } else { offset * amount }, + }); + + offset += *size; + } + + Attributes { + mem: list.into_boxed_slice(), + attributes, + size: struct_size * amount, + elements: items.len(), + } + } +} + +impl VertexDataCollection for Vec { + fn get_amount(&self) -> usize { + self.len() + } + + fn get_list(&self) -> &[D] { + &self + } +} + +impl VertexDataCollection for &[D] { + fn get_amount(&self) -> usize { + self.len() + } + + fn get_list(&self) -> &[D] { + self + } +} + +impl VertexDataCollection for Box<[D]> { + fn get_amount(&self) -> usize { + self.len() + } + + fn get_list(&self) -> &[D] { + &self + } +} + +impl VertexDataCollection for [D] { + fn get_amount(&self) -> usize { + self.len() + } + + fn get_list(&self) -> &[D] { + &self + } +} diff --git a/eatgel/src/err.rs b/eatgel/src/err.rs new file mode 100644 index 0000000..a106de5 --- /dev/null +++ b/eatgel/src/err.rs @@ -0,0 +1,31 @@ +use image::ImageError; +use std::ffi::NulError; +use std::str::Utf8Error; + +#[derive(Debug)] +pub enum Error { + ShaderContainsNul(NulError), + ShaderCompilationFailure(String), + ShaderProgramLinkFailure(String), + InfoLogEncodingError(Utf8Error), + TextureLoadError(ImageError), + TextureParseError, +} + +impl From for Error { + fn from(utf8err: Utf8Error) -> Self { + Error::InfoLogEncodingError(utf8err) + } +} + +impl From for Error { + fn from(nul_err: NulError) -> Self { + Error::ShaderContainsNul(nul_err) + } +} + +impl From for Error { + fn from(image_err: ImageError) -> Self { + Error::TextureLoadError(image_err) + } +} diff --git a/eatgel/src/lib.rs b/eatgel/src/lib.rs new file mode 100644 index 0000000..556dabc --- /dev/null +++ b/eatgel/src/lib.rs @@ -0,0 +1,217 @@ +use std::ffi::{c_void, CStr, CString}; + +pub mod buffer; +mod err; +pub mod shader; +pub mod texture; +mod types; +mod update_uniform; + +use crate::buffer::{Attributes, StaticBufferNonIndexed}; +use buffer::StaticBuffer; +pub use buffer::{VertexData, VertexDataCollection}; +#[cfg(feature = "derive")] +pub use eatgel_proc_macro::{ShaderData, VertexData}; +pub use shader::ShaderData; +use std::collections::HashMap; +use std::mem::size_of; +use std::ptr::null; +pub use types::{amount_of, type_descriptor_of, type_of, TypeDescriptor, TypeResolver}; +pub use update_uniform::*; + +pub struct GlContext { + cache: HashMap>, + clear_color: [f32; 4], +} + +#[repr(u32)] +#[derive(Debug, Copy, Clone)] +enum Severity { + Low = gl::DEBUG_SEVERITY_LOW, + Medium = gl::DEBUG_SEVERITY_MEDIUM, + High = gl::DEBUG_SEVERITY_HIGH, + Notification = gl::DEBUG_SEVERITY_NOTIFICATION, +} + +impl From for Severity { + fn from(x: u32) -> Self { + match x { + gl::DEBUG_SEVERITY_LOW => Severity::Low, + gl::DEBUG_SEVERITY_MEDIUM => Severity::Medium, + gl::DEBUG_SEVERITY_HIGH => Severity::High, + _ => Severity::Notification, + } + } +} + +extern "system" fn gl_message_callback( + _source: u32, + _error_type: u32, + _id: u32, + severity: u32, + _length: i32, + message: *const i8, + _user_data: *mut c_void, +) { + unsafe { + println!( + "Message ({:?}): {:?}", + Severity::from(severity), + CStr::from_ptr(message) + ); + } +} + +impl GlContext { + pub fn new(f: F) -> Self + where + F: FnMut(&'static str) -> *const c_void, + { + gl::load_with(f); + + unsafe { + gl::Enable(gl::DEBUG_OUTPUT); + gl::DebugMessageCallback(Some(gl_message_callback), null()) + } + + GlContext { + cache: HashMap::new(), + clear_color: [0., 0., 0., 0.], + } + } + + pub fn set_clear_color(&mut self, red: f32, green: f32, blue: f32, alpha: f32) { + self.clear_color = [red, green, blue, alpha]; + } + + pub fn clear(&self) { + unsafe { + gl::ClearColor( + self.clear_color[0], + self.clear_color[1], + self.clear_color[2], + self.clear_color[3], + ); + gl::Clear(gl::COLOR_BUFFER_BIT | gl::DEPTH_BUFFER_BIT); + } + } + + pub fn get_uniform_location(&self, program_id: u32, name: &str) -> i32 { + let name = CString::new(name).expect("Failed creating CString from &str"); + unsafe { gl::GetUniformLocation(program_id, name.as_ptr()) } + } + + pub fn register_uniforms(&mut self, program_id: u32, uniforms: &[&str]) { + let mut ids = vec![]; + + for name in uniforms { + unsafe { + ids.push(gl::GetUniformLocation( + program_id, + CString::new(name.to_string()) + .expect("Nul character in uniform name") + .as_ptr(), + )) + } + } + + self.cache.insert(program_id, ids.into_boxed_slice()); + } + + pub fn get_uniform_location_by_index(&self, program_id: u32, index: usize) -> i32 { + self.cache.get(&program_id).map(|x| x[index]).unwrap_or(-1) + } + + unsafe fn create_attribs(&self, attributes: &Attributes) { + let mut index = 0; + for attribute in &attributes.attributes { + gl::VertexAttribPointer( + index, + attribute.amount as i32, + attribute.gl_type, + gl::FALSE, + attribute.stride as i32, + attribute.offset as *const c_void, + ); + gl::EnableVertexAttribArray(index); + + index += 1; + } + } + + pub fn create_static_buffer_non_indexed, D: VertexData>( + &self, + buffer: C, + ) -> StaticBufferNonIndexed { + let attributes = buffer.create_ptr(false, None); + let mut vbo = 0; + let mut vao = 0; + + unsafe { + gl::GenVertexArrays(1, &mut vao); + gl::GenBuffers(1, &mut vbo); + + gl::BindVertexArray(vao); + + gl::BindBuffer(gl::ARRAY_BUFFER, vbo); + gl::BufferData( + gl::ARRAY_BUFFER, + attributes.size as isize, + attributes.as_ptr(), + gl::STATIC_DRAW, + ); + + self.create_attribs(&attributes) + } + + StaticBufferNonIndexed { + vao, + elements: attributes.elements, + attributes: attributes.attributes, + } + } + + pub fn create_static_buffer, D: VertexData>( + &self, + buffer: C, + indices: &[u32], + ) -> StaticBuffer { + let attributes = buffer.create_ptr(false, None); + let mut vbo = 0; + let mut vao = 0; + let mut ebo = 0; + + unsafe { + gl::GenVertexArrays(1, &mut vao); + gl::GenBuffers(1, &mut vbo); + gl::GenBuffers(1, &mut ebo); + + gl::BindVertexArray(vao); + + gl::BindBuffer(gl::ARRAY_BUFFER, vbo); + gl::BufferData( + gl::ARRAY_BUFFER, + attributes.size as isize, + attributes.as_ptr(), + gl::STATIC_DRAW, + ); + + self.create_attribs(&attributes); + + gl::BindBuffer(gl::ELEMENT_ARRAY_BUFFER, ebo); + gl::BufferData( + gl::ELEMENT_ARRAY_BUFFER, + (size_of::() * indices.len()) as isize, + indices.as_ptr() as *const c_void, + gl::STATIC_DRAW, + ); + } + + StaticBuffer { + vao, + ebo, + indices: indices.len(), + attributes: attributes.attributes, + } + } +} diff --git a/eatgel/src/shader.rs b/eatgel/src/shader.rs new file mode 100644 index 0000000..fa3d837 --- /dev/null +++ b/eatgel/src/shader.rs @@ -0,0 +1,144 @@ +use crate::err::Error; +use crate::GlContext; +use std::ffi::CString; +use std::ops::{Deref, DerefMut}; +use std::os::raw::c_char; +use std::ptr::null; +use std::str::from_utf8; + +pub trait ShaderData { + fn init(&mut self, gl: &mut GlContext, program_id: u32); + fn apply(&self, gl: &GlContext, program_id: u32); +} + +impl ShaderData for () { + fn init(&mut self, _gl: &mut GlContext, _program_id: u32) {} + fn apply(&self, _gl: &GlContext, _program_id: u32) {} +} + +pub struct ShaderProgram { + pub program_id: u32, + data: D, +} + +impl ShaderProgram { + pub fn init(&mut self, gl: &mut GlContext) { + self.data.init(gl, self.program_id); + } + + pub fn apply(&self, gl: &GlContext) { + self.data.apply(gl, self.program_id); + } +} + +impl Deref for ShaderProgram { + type Target = D; + + fn deref(&self) -> &Self::Target { + &self.data + } +} + +impl DerefMut for ShaderProgram { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.data + } +} + +pub struct Shader(pub u32); + +impl Drop for Shader { + fn drop(&mut self) { + unsafe { gl::DeleteShader(self.0) } + } +} + +#[repr(u32)] +pub enum ShaderType { + Vertex = gl::VERTEX_SHADER, + Fragment = gl::FRAGMENT_SHADER, +} + +impl Shader { + pub fn compile(shader_type: ShaderType, source: &str) -> Result { + let shader_id = unsafe { gl::CreateShader(shader_type as u32) }; + let source = CString::new(source.as_bytes())?; + unsafe { + gl::ShaderSource(shader_id, 1, &source.as_ptr(), null()); + gl::CompileShader(shader_id); + let mut success = 0; + gl::GetShaderiv(shader_id, gl::COMPILE_STATUS, &mut success); + + if success != 1 { + let mut log_length = 0; + gl::GetShaderiv(shader_id, gl::INFO_LOG_LENGTH, &mut log_length); + let mut log = Vec::with_capacity(log_length as usize); + let mut len = 0; + gl::GetShaderInfoLog( + shader_id, + log_length, + &mut len, + log.as_mut_ptr() as *mut c_char, + ); + log.set_len(len as usize); + + return Err(Error::ShaderCompilationFailure( + from_utf8(&log)?.to_string(), + )); + } + } + + Ok(Shader(shader_id)) + } +} + +impl ShaderProgram<()> { + pub fn create(shader0: Shader, shader1: Shader) -> Result, Error> { + ShaderProgram::create_with_data((), shader0, shader1) + } +} + +impl ShaderProgram { + pub fn enable(&self) { + unsafe { gl::UseProgram(self.program_id) } + } + + pub fn create_with_data( + data: D, + shader0: Shader, + shader1: Shader, + ) -> Result, Error> { + unsafe { + let program_id = gl::CreateProgram(); + gl::AttachShader(program_id, shader0.0); + gl::AttachShader(program_id, shader1.0); + gl::LinkProgram(program_id); + + let mut status = 0; + gl::GetProgramiv(program_id, gl::LINK_STATUS, &mut status); + if status != 1 { + let mut log_length = 0; + gl::GetProgramiv(program_id, gl::INFO_LOG_LENGTH, &mut log_length); + let mut log = Vec::with_capacity(log_length as usize); + let mut len = 0; + gl::GetProgramInfoLog( + program_id, + log_length, + &mut len, + log.as_mut_ptr() as *mut c_char, + ); + + log.set_len(len as usize); + + return Err(Error::ShaderProgramLinkFailure( + from_utf8(&log)?.to_string(), + )); + } + + gl::DeleteShader(shader0.0); + gl::DeleteShader(shader1.0); + + Ok(ShaderProgram { data, program_id }) + } + } +} diff --git a/eatgel/src/texture.rs b/eatgel/src/texture.rs new file mode 100644 index 0000000..429bb0f --- /dev/null +++ b/eatgel/src/texture.rs @@ -0,0 +1,180 @@ +use crate::err::Error; +pub use image::{ColorType, ImageFormat}; +use image::{DynamicImage, GenericImageView}; +use nalgebra_glm::Vec4; +use std::io::{BufRead, Seek}; +use std::os::raw::c_void; + +#[repr(u32)] +#[derive(Copy, Clone, Debug)] +pub enum WrapStyle { + Repeat = gl::REPEAT, + MirroredRepeat = gl::MIRRORED_REPEAT, + ClampToEdge = gl::CLAMP_TO_EDGE, + ClampToBorder = gl::CLAMP_TO_BORDER, +} + +#[repr(u32)] +#[derive(Copy, Clone, Debug)] +pub enum FilterStyle { + Nearest = gl::NEAREST, + Linear = gl::LINEAR, +} + +impl FilterStyle { + fn get_gl_enum(filter: FilterStyle, mipmap: Option) -> i32 { + let gl_enum = match (filter, mipmap) { + (FilterStyle::Nearest, None) => gl::NEAREST, + (FilterStyle::Linear, None) => gl::LINEAR, + (FilterStyle::Linear, Some(FilterStyle::Linear)) => gl::LINEAR_MIPMAP_LINEAR, + (FilterStyle::Linear, Some(FilterStyle::Nearest)) => gl::LINEAR_MIPMAP_NEAREST, + (FilterStyle::Nearest, Some(FilterStyle::Linear)) => gl::NEAREST_MIPMAP_LINEAR, + (FilterStyle::Nearest, Some(FilterStyle::Nearest)) => gl::NEAREST_MIPMAP_NEAREST, + }; + + gl_enum as i32 + } +} + +#[derive(Clone, Debug)] +pub struct Texture { + image_id: u32, + options: TextureOptions, +} + +pub struct Image { + pub image: DynamicImage, +} + +impl Image { + pub fn load(r: R, format: ImageFormat) -> Result { + Ok(Image { + image: image::load(r, format)?, + }) + } + + pub fn into_texture(mut self, options: TextureOptions) -> Result { + let mut image_id = 0; + unsafe { + gl::GenTextures(1, &mut image_id); + gl::BindTexture(gl::TEXTURE_2D, image_id); + gl::TexParameteri(gl::TEXTURE_2D, gl::TEXTURE_WRAP_S, options.wrap_s as i32); + gl::TexParameteri(gl::TEXTURE_2D, gl::TEXTURE_WRAP_T, options.wrap_t as i32); + gl::TexParameteri( + gl::TEXTURE_2D, + gl::TEXTURE_MAG_FILTER, + FilterStyle::get_gl_enum(options.mag_filter, options.mag_mipmap_filter), + ); + gl::TexParameteri( + gl::TEXTURE_2D, + gl::TEXTURE_MAG_FILTER, + FilterStyle::get_gl_enum(options.min_filter, options.min_mipmap_filter), + ); + + if let Some((_, ref border)) = options.border { + gl::TexParameterfv(gl::TEXTURE_2D, gl::TEXTURE_BORDER_COLOR, border.as_ptr()) + } + + if options.flip_vertically { + self.image = self.image.flipv() + } + let pixels = self + .image + .pixels() + .into_iter() + .flat_map(|x| vec![x.2[0], x.2[1], x.2[2], x.2[3]]) + .collect::>(); + + let width = self.image.width(); + let height = self.image.height(); + + gl::TexImage2D( + gl::TEXTURE_2D, + 0, + gl::RGBA as i32, + width as i32, + height as i32, + 0, + gl::RGBA, + gl::UNSIGNED_BYTE, + pixels.as_ptr() as *const c_void, + ); + gl::GenerateMipmap(gl::TEXTURE_2D); + } + + Ok(Texture { image_id, options }) + } +} + +#[derive(Clone, Debug)] +pub struct TextureOptions { + wrap_s: WrapStyle, + wrap_t: WrapStyle, + border: Option<(i32, Vec4)>, + mag_filter: FilterStyle, + min_filter: FilterStyle, + min_mipmap_filter: Option, + mag_mipmap_filter: Option, + flip_vertically: bool, +} + +impl Default for TextureOptions { + fn default() -> Self { + TextureOptions { + wrap_s: WrapStyle::Repeat, + wrap_t: WrapStyle::Repeat, + border: None, + mag_filter: FilterStyle::Linear, + min_filter: FilterStyle::Linear, + min_mipmap_filter: None, + mag_mipmap_filter: None, + flip_vertically: true, + } + } +} + +#[repr(u32)] +#[derive(Debug, Copy, Clone)] +pub enum TextureSlot { + Slot0 = gl::TEXTURE0, + Slot1 = gl::TEXTURE1, + Slot2 = gl::TEXTURE2, + Slot3 = gl::TEXTURE3, + Slot4 = gl::TEXTURE4, + Slot5 = gl::TEXTURE5, + Slot6 = gl::TEXTURE6, + Slot7 = gl::TEXTURE7, + Slot8 = gl::TEXTURE8, + Slot9 = gl::TEXTURE9, + Slot10 = gl::TEXTURE10, + Slot11 = gl::TEXTURE11, + Slot12 = gl::TEXTURE12, + Slot13 = gl::TEXTURE13, + Slot14 = gl::TEXTURE14, + Slot15 = gl::TEXTURE15, + Slot16 = gl::TEXTURE16, + Slot17 = gl::TEXTURE17, + Slot18 = gl::TEXTURE18, + Slot19 = gl::TEXTURE19, + Slot20 = gl::TEXTURE20, + Slot21 = gl::TEXTURE21, + Slot22 = gl::TEXTURE22, + Slot23 = gl::TEXTURE23, + Slot24 = gl::TEXTURE24, + Slot25 = gl::TEXTURE25, + Slot26 = gl::TEXTURE26, + Slot27 = gl::TEXTURE27, + Slot28 = gl::TEXTURE28, + Slot29 = gl::TEXTURE29, + Slot30 = gl::TEXTURE30, + Slot31 = gl::TEXTURE31, +} + +impl Texture { + pub fn enable(&self, slot: TextureSlot) { + unsafe { + gl::ActiveTexture(slot as u32); + gl::BindTexture(gl::TEXTURE_2D, self.image_id); + } + } +} diff --git a/eatgel/src/types.rs b/eatgel/src/types.rs new file mode 100644 index 0000000..97bbd18 --- /dev/null +++ b/eatgel/src/types.rs @@ -0,0 +1,120 @@ +use nalgebra_glm::{Vec2, Vec3, Vec4}; + +pub trait TypeResolver { + fn type_of() -> u32; + fn amount_of() -> u32; + fn get_type_descriptor() -> TypeDescriptor { + TypeDescriptor { + gl_type: Self::type_of(), + amount: Self::amount_of(), + } + } +} + +#[derive(Debug, Copy, Clone)] +pub struct TypeDescriptor { + pub gl_type: u32, + pub amount: u32, +} + +pub fn type_descriptor_of() -> TypeDescriptor { + T::get_type_descriptor() +} + +pub fn type_of() -> u32 { + T::type_of() +} + +pub fn amount_of() -> u32 { + T::amount_of() +} + +impl TypeResolver for bool { + fn type_of() -> u32 { + gl::UNSIGNED_BYTE + } + fn amount_of() -> u32 { + 1 + } +} + +impl TypeResolver for u8 { + fn type_of() -> u32 { + gl::UNSIGNED_BYTE + } + fn amount_of() -> u32 { + 1 + } +} + +impl TypeResolver for i8 { + fn type_of() -> u32 { + gl::BYTE + } + fn amount_of() -> u32 { + 1 + } +} + +impl TypeResolver for u16 { + fn type_of() -> u32 { + gl::UNSIGNED_SHORT + } + fn amount_of() -> u32 { + 1 + } +} + +impl TypeResolver for i16 { + fn type_of() -> u32 { + gl::SHORT + } + fn amount_of() -> u32 { + 1 + } +} + +impl TypeResolver for u32 { + fn type_of() -> u32 { + gl::UNSIGNED_INT + } + fn amount_of() -> u32 { + 1 + } +} + +impl TypeResolver for i32 { + fn type_of() -> u32 { + gl::INT + } + fn amount_of() -> u32 { + 1 + } +} + +impl TypeResolver for Vec2 { + fn type_of() -> u32 { + gl::FLOAT + } + fn amount_of() -> u32 { + 2 + } +} + +impl TypeResolver for Vec3 { + fn type_of() -> u32 { + gl::FLOAT + } + fn amount_of() -> u32 { + 3 + } +} + +impl TypeResolver for Vec4 { + fn type_of() -> u32 { + gl::FLOAT + } + fn amount_of() -> u32 { + 4 + } +} diff --git a/eatgel/src/update_uniform.rs b/eatgel/src/update_uniform.rs new file mode 100644 index 0000000..c3796c2 --- /dev/null +++ b/eatgel/src/update_uniform.rs @@ -0,0 +1,342 @@ +use crate::texture::TextureSlot; +use crate::GlContext; +use nalgebra_glm::{Mat3, Mat4}; +use std::convert::From; +use std::ptr::null; + +pub trait UpdateUniform { + fn update_uniform(&self, location: i32, value: T); + fn update_uniform_by_index(&self, gl: &GlContext, program_id: u32, index: usize, value: T) { + self.update_uniform(gl.get_uniform_location_by_index(program_id, index), value) + } +} + +impl UpdateUniform for GlContext { + fn update_uniform(&self, location: i32, value: i32) { + unsafe { gl::Uniform1i(location, value) } + } +} + +impl UpdateUniform<&i32> for GlContext { + fn update_uniform(&self, location: i32, value: &i32) { + unsafe { gl::Uniform1i(location, *value) } + } +} + +impl UpdateUniform<&Vec> for GlContext { + fn update_uniform(&self, location: i32, value: &Vec) { + unsafe { gl::Uniform1iv(location, value.len() as i32, value.as_ptr()) } + } +} + +impl UpdateUniform<&nalgebra_glm::TVec2> for GlContext { + fn update_uniform(&self, location: i32, value: &nalgebra_glm::TVec2) { + unsafe { gl::Uniform2i(location, value.x, value.y) } + } +} + +impl UpdateUniform<&Vec>> for GlContext { + fn update_uniform(&self, location: i32, value: &Vec>) { + unsafe { + gl::Uniform2iv( + location, + value.len() as i32, + value.first().map(|x| x.as_ptr()).unwrap_or(null()), + ) + } + } +} + +impl UpdateUniform<&nalgebra_glm::TVec3> for GlContext { + fn update_uniform(&self, location: i32, value: &nalgebra_glm::TVec3) { + unsafe { gl::Uniform3i(location, value.x, value.y, value.z) } + } +} + +impl UpdateUniform<&Vec>> for GlContext { + fn update_uniform(&self, location: i32, value: &Vec>) { + unsafe { + gl::Uniform3iv( + location, + value.len() as i32, + value.first().map(|x| x.as_ptr()).unwrap_or(null()), + ) + } + } +} + +impl UpdateUniform<&nalgebra_glm::TVec4> for GlContext { + fn update_uniform(&self, location: i32, value: &nalgebra_glm::TVec4) { + unsafe { gl::Uniform4i(location, value.x, value.y, value.z, value.w) } + } +} + +impl UpdateUniform<&Vec>> for GlContext { + fn update_uniform(&self, location: i32, value: &Vec>) { + unsafe { + gl::Uniform4iv( + location, + value.len() as i32, + value.first().map(|x| x.as_ptr()).unwrap_or(null()), + ) + } + } +} + +impl UpdateUniform for GlContext { + fn update_uniform(&self, location: i32, value: u32) { + unsafe { gl::Uniform1ui(location, value) } + } +} + +impl UpdateUniform<&u32> for GlContext { + fn update_uniform(&self, location: i32, value: &u32) { + unsafe { gl::Uniform1ui(location, *value) } + } +} + +impl UpdateUniform<&Vec> for GlContext { + fn update_uniform(&self, location: i32, value: &Vec) { + unsafe { gl::Uniform1uiv(location, value.len() as i32, value.as_ptr()) } + } +} + +impl UpdateUniform<&nalgebra_glm::TVec2> for GlContext { + fn update_uniform(&self, location: i32, value: &nalgebra_glm::TVec2) { + unsafe { gl::Uniform2ui(location, value.x, value.y) } + } +} + +impl UpdateUniform<&Vec>> for GlContext { + fn update_uniform(&self, location: i32, value: &Vec>) { + unsafe { + gl::Uniform2uiv( + location, + value.len() as i32, + value.first().map(|x| x.as_ptr()).unwrap_or(null()), + ) + } + } +} + +impl UpdateUniform<&nalgebra_glm::TVec3> for GlContext { + fn update_uniform(&self, location: i32, value: &nalgebra_glm::TVec3) { + unsafe { gl::Uniform3ui(location, value.x, value.y, value.z) } + } +} + +impl UpdateUniform<&Vec>> for GlContext { + fn update_uniform(&self, location: i32, value: &Vec>) { + unsafe { + gl::Uniform3uiv( + location, + value.len() as i32, + value.first().map(|x| x.as_ptr()).unwrap_or(null()), + ) + } + } +} + +impl UpdateUniform<&nalgebra_glm::TVec4> for GlContext { + fn update_uniform(&self, location: i32, value: &nalgebra_glm::TVec4) { + unsafe { gl::Uniform4ui(location, value.x, value.y, value.z, value.w) } + } +} + +impl UpdateUniform<&Vec>> for GlContext { + fn update_uniform(&self, location: i32, value: &Vec>) { + unsafe { + gl::Uniform4uiv( + location, + value.len() as i32, + value.first().map(|x| x.as_ptr()).unwrap_or(null()), + ) + } + } +} + +impl UpdateUniform for GlContext { + fn update_uniform(&self, location: i32, value: f32) { + unsafe { gl::Uniform1f(location, value) } + } +} + +impl UpdateUniform<&f32> for GlContext { + fn update_uniform(&self, location: i32, value: &f32) { + unsafe { gl::Uniform1f(location, *value) } + } +} + +impl UpdateUniform<&Vec> for GlContext { + fn update_uniform(&self, location: i32, value: &Vec) { + unsafe { gl::Uniform1fv(location, value.len() as i32, value.as_ptr()) } + } +} + +impl UpdateUniform<&nalgebra_glm::TVec1> for GlContext { + fn update_uniform(&self, location: i32, value: &nalgebra_glm::TVec1) { + unsafe { gl::Uniform1f(location, value.x) } + } +} + +impl UpdateUniform<&Vec>> for GlContext { + fn update_uniform(&self, location: i32, value: &Vec>) { + unsafe { + gl::Uniform1fv( + location, + value.len() as i32, + value.first().map(|x| x.as_ptr()).unwrap_or(null()), + ) + } + } +} + +impl UpdateUniform<&nalgebra_glm::TVec2> for GlContext { + fn update_uniform(&self, location: i32, value: &nalgebra_glm::TVec2) { + unsafe { gl::Uniform2f(location, value.x, value.y) } + } +} + +impl UpdateUniform<&Vec>> for GlContext { + fn update_uniform(&self, location: i32, value: &Vec>) { + unsafe { + gl::Uniform2fv( + location, + value.len() as i32, + value.first().map(|x| x.as_ptr()).unwrap_or(null()), + ) + } + } +} + +impl UpdateUniform<&nalgebra_glm::TVec3> for GlContext { + fn update_uniform(&self, location: i32, value: &nalgebra_glm::TVec3) { + unsafe { gl::Uniform3f(location, value.x, value.y, value.z) } + } +} + +impl UpdateUniform<&Vec>> for GlContext { + fn update_uniform(&self, location: i32, value: &Vec>) { + unsafe { + gl::Uniform3fv( + location, + value.len() as i32, + value.first().map(|x| x.as_ptr()).unwrap_or(null()), + ) + } + } +} + +impl UpdateUniform<&nalgebra_glm::TVec4> for GlContext { + fn update_uniform(&self, location: i32, value: &nalgebra_glm::TVec4) { + unsafe { gl::Uniform4f(location, value.x, value.y, value.z, value.w) } + } +} + +impl UpdateUniform<&Vec>> for GlContext { + fn update_uniform(&self, location: i32, value: &Vec>) { + unsafe { + gl::Uniform4fv( + location, + value.len() as i32, + value.first().map(|x| x.as_ptr()).unwrap_or(null()), + ) + } + } +} + +impl UpdateUniform for GlContext { + fn update_uniform(&self, location: i32, value: f64) { + unsafe { gl::Uniform1d(location, value) } + } +} + +impl UpdateUniform<&f64> for GlContext { + fn update_uniform(&self, location: i32, value: &f64) { + unsafe { gl::Uniform1d(location, *value) } + } +} + +impl UpdateUniform<&Vec> for GlContext { + fn update_uniform(&self, location: i32, value: &Vec) { + unsafe { gl::Uniform1dv(location, value.len() as i32, value.as_ptr()) } + } +} + +impl UpdateUniform<&nalgebra_glm::TVec1> for GlContext { + fn update_uniform(&self, location: i32, value: &nalgebra_glm::TVec1) { + unsafe { gl::Uniform1d(location, value.x) } + } +} + +impl UpdateUniform<&nalgebra_glm::TVec2> for GlContext { + fn update_uniform(&self, location: i32, value: &nalgebra_glm::TVec2) { + unsafe { gl::Uniform2d(location, value.x, value.y) } + } +} + +impl UpdateUniform<&Vec>> for GlContext { + fn update_uniform(&self, location: i32, value: &Vec>) { + unsafe { + gl::Uniform2dv( + location, + value.len() as i32, + value.first().map(|x| x.as_ptr()).unwrap_or(null()), + ) + } + } +} + +impl UpdateUniform<&nalgebra_glm::TVec3> for GlContext { + fn update_uniform(&self, location: i32, value: &nalgebra_glm::TVec3) { + unsafe { gl::Uniform3d(location, value.x, value.y, value.z) } + } +} + +impl UpdateUniform<&Vec>> for GlContext { + fn update_uniform(&self, location: i32, value: &Vec>) { + unsafe { + gl::Uniform3dv( + location, + value.len() as i32, + value.first().map(|x| x.as_ptr()).unwrap_or(null()), + ) + } + } +} + +impl UpdateUniform<&nalgebra_glm::TVec4> for GlContext { + fn update_uniform(&self, location: i32, value: &nalgebra_glm::TVec4) { + unsafe { gl::Uniform4d(location, value.x, value.y, value.z, value.w) } + } +} + +impl UpdateUniform<&Vec>> for GlContext { + fn update_uniform(&self, location: i32, value: &Vec>) { + unsafe { + gl::Uniform4dv( + location, + value.len() as i32, + value.first().map(|x| x.as_ptr()).unwrap_or(null()), + ) + } + } +} + +impl UpdateUniform<&Mat3> for GlContext { + fn update_uniform(&self, location: i32, value: &Mat3) { + unsafe { gl::UniformMatrix3fv(location, 1, u8::from(false), value.as_ptr()) } + } +} + +impl UpdateUniform<&Mat4> for GlContext { + fn update_uniform(&self, location: i32, value: &Mat4) { + unsafe { gl::UniformMatrix4fv(location, 1, u8::from(false), value.as_ptr()) } + } +} + +impl UpdateUniform<&TextureSlot> for GlContext { + fn update_uniform(&self, location: i32, value: &TextureSlot) { + unsafe { gl::Uniform1i(location, (*value as i32) - 0x84C0) } + } +} diff --git a/triangle-time/.gitignore b/triangle-time/.gitignore new file mode 100644 index 0000000..ea8c4bf --- /dev/null +++ b/triangle-time/.gitignore @@ -0,0 +1 @@ +/target diff --git a/triangle-time/Cargo.lock b/triangle-time/Cargo.lock new file mode 100644 index 0000000..0963761 --- /dev/null +++ b/triangle-time/Cargo.lock @@ -0,0 +1,388 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +[[package]] +name = "alga" +version = "0.9.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4f823d037a7ec6ea2197046bafd4ae150e6bc36f9ca347404f46a46823fa84f2" +dependencies = [ + "approx", + "num-complex", + "num-traits", +] + +[[package]] +name = "approx" +version = "0.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f0e60b75072ecd4168020818c0107f2857bb6c4e64252d8d3983f6263b40a5c3" +dependencies = [ + "num-traits", +] + +[[package]] +name = "autocfg" +version = "1.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f8aac770f1885fd7e387acedd76065302551364496e46b3dd00860b2f8359b9d" + +[[package]] +name = "bitflags" +version = "1.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cf1de2fe8c75bc145a2f577add951f8134889b4795d47466a54a5c846d691693" + +[[package]] +name = "c2-chacha" +version = "0.2.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "214238caa1bf3a496ec3392968969cab8549f96ff30652c9e56885329315f6bb" +dependencies = [ + "ppv-lite86", +] + +[[package]] +name = "cc" +version = "1.0.50" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "95e28fa049fda1c330bcf9d723be7663a899c4679724b34c81e9f5a326aab8cd" + +[[package]] +name = "cfg-if" +version = "0.1.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4785bdd1c96b2a846b2bd7cc02e86b6b3dbf14e7e53446c4f54c92a361040822" + +[[package]] +name = "cmake" +version = "0.1.42" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "81fb25b677f8bf1eb325017cb6bb8452f87969db0fedb4f757b297bee78a7c62" +dependencies = [ + "cc", +] + +[[package]] +name = "generic-array" +version = "0.13.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0ed1e761351b56f54eb9dcd0cfaca9fd0daecf93918e1cfc01c8a3d26ee7adcd" +dependencies = [ + "typenum", +] + +[[package]] +name = "getrandom" +version = "0.1.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7abc8dd8451921606d809ba32e95b6111925cd2906060d2dcc29c070220503eb" +dependencies = [ + "cfg-if", + "libc", + "wasi", +] + +[[package]] +name = "gl" +version = "0.14.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a94edab108827d67608095e269cf862e60d920f144a5026d3dbcfd8b877fb404" +dependencies = [ + "gl_generator", +] + +[[package]] +name = "gl_generator" +version = "0.14.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1a95dfc23a2b4a9a2f5ab41d194f8bfda3cabec42af4e39f08c339eb2a0c124d" +dependencies = [ + "khronos_api", + "log", + "xml-rs", +] + +[[package]] +name = "glfw" +version = "0.36.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3b4c1f2e99ce4181c37d9582986ed32a8f55235bdc9427258d96d09cc9666a29" +dependencies = [ + "bitflags", + "glfw-sys", + "libc", + "log", + "objc", + "raw-window-handle", + "semver", + "winapi", +] + +[[package]] +name = "glfw-sys" +version = "3.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0b567b13b593ec58ea912b2658ee6230ffe20a069fa5b771800acc69bb3a157e" +dependencies = [ + "cmake", +] + +[[package]] +name = "khronos_api" +version = "3.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e2db585e1d738fc771bf08a151420d3ed193d9d895a36df7f6f8a9456b911ddc" + +[[package]] +name = "libc" +version = "0.2.67" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "eb147597cdf94ed43ab7a9038716637d2d1bf2bc571da995d0028dec06bd3018" + +[[package]] +name = "libm" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c7d73b3f436185384286bd8098d17ec07c9a7d2388a6599f824d8502b529702a" + +[[package]] +name = "log" +version = "0.4.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "14b6052be84e6b71ab17edffc2eeabf5c2c3ae1fdb464aae35ac50c67a44e1f7" +dependencies = [ + "cfg-if", +] + +[[package]] +name = "malloc_buf" +version = "0.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "62bb907fe88d54d8d9ce32a3cceab4218ed2f6b7d35617cafe9adf84e43919cb" +dependencies = [ + "libc", +] + +[[package]] +name = "matrixmultiply" +version = "0.2.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d4f7ec66360130972f34830bfad9ef05c6610a43938a467bcc9ab9369ab3478f" +dependencies = [ + "rawpointer", +] + +[[package]] +name = "nalgebra" +version = "0.20.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c6511777ed3da44b6a11e732a66a7d6274dfbbcd68ad968e64b778dcb829d94a" +dependencies = [ + "alga", + "approx", + "generic-array", + "matrixmultiply", + "num-complex", + "num-rational", + "num-traits", + "rand", + "rand_distr", + "typenum", +] + +[[package]] +name = "nalgebra-glm" +version = "0.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5ae78da13d67be0d2e4ab567490477e4c9f314fc151ddfff6713b15bdbb2aa72" +dependencies = [ + "alga", + "approx", + "nalgebra", + "num-traits", +] + +[[package]] +name = "num-complex" +version = "0.2.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b6b19411a9719e753aff12e5187b74d60d3dc449ec3f4dc21e3989c3f554bc95" +dependencies = [ + "autocfg", + "num-traits", +] + +[[package]] +name = "num-integer" +version = "0.1.42" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3f6ea62e9d81a77cd3ee9a2a5b9b609447857f3d358704331e4ef39eb247fcba" +dependencies = [ + "autocfg", + "num-traits", +] + +[[package]] +name = "num-rational" +version = "0.2.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "da4dc79f9e6c81bef96148c8f6b8e72ad4541caa4a24373e900a36da07de03a3" +dependencies = [ + "autocfg", + "num-integer", + "num-traits", +] + +[[package]] +name = "num-traits" +version = "0.2.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c62be47e61d1842b9170f0fdeec8eba98e60e90e5446449a0545e5152acd7096" +dependencies = [ + "autocfg", + "libm", +] + +[[package]] +name = "objc" +version = "0.2.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "915b1b472bc21c53464d6c8461c9d3af805ba1ef837e1cac254428f4a77177b1" +dependencies = [ + "malloc_buf", +] + +[[package]] +name = "ppv-lite86" +version = "0.2.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "74490b50b9fbe561ac330df47c08f3f33073d2d00c150f719147d7c54522fa1b" + +[[package]] +name = "rand" +version = "0.7.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6a6b1679d49b24bbfe0c803429aa1874472f50d9b363131f0e89fc356b544d03" +dependencies = [ + "getrandom", + "libc", + "rand_chacha", + "rand_core", + "rand_hc", +] + +[[package]] +name = "rand_chacha" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "03a2a90da8c7523f554344f921aa97283eadf6ac484a6d2a7d0212fa7f8d6853" +dependencies = [ + "c2-chacha", + "rand_core", +] + +[[package]] +name = "rand_core" +version = "0.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "90bde5296fc891b0cef12a6d03ddccc162ce7b2aff54160af9338f8d40df6d19" +dependencies = [ + "getrandom", +] + +[[package]] +name = "rand_distr" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "96977acbdd3a6576fb1d27391900035bf3863d4a16422973a409b488cf29ffb2" +dependencies = [ + "rand", +] + +[[package]] +name = "rand_hc" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ca3129af7b92a17112d59ad498c6f81eaf463253766b90396d39ea7a39d6613c" +dependencies = [ + "rand_core", +] + +[[package]] +name = "raw-window-handle" +version = "0.3.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0a441a7a6c80ad6473bd4b74ec1c9a4c951794285bf941c2126f607c72e48211" +dependencies = [ + "libc", +] + +[[package]] +name = "rawpointer" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "60a357793950651c4ed0f3f52338f53b2f809f32d83a07f72909fa13e4c6c1e3" + +[[package]] +name = "semver" +version = "0.9.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1d7eb9ef2c18661902cc47e535f9bc51b78acd254da71d375c2f6720d9a40403" +dependencies = [ + "semver-parser", +] + +[[package]] +name = "semver-parser" +version = "0.7.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "388a1df253eca08550bef6c72392cfe7c30914bf41df5269b68cbd6ff8f570a3" + +[[package]] +name = "triangle-time" +version = "0.1.0" +dependencies = [ + "gl", + "glfw", + "nalgebra-glm", +] + +[[package]] +name = "typenum" +version = "1.11.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6d2783fe2d6b8c1101136184eb41be8b1ad379e4657050b8aaff0c79ee7575f9" + +[[package]] +name = "wasi" +version = "0.9.0+wasi-snapshot-preview1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cccddf32554fecc6acb585f82a32a72e28b48f8c4c1883ddfeeeaa96f7d8e519" + +[[package]] +name = "winapi" +version = "0.3.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8093091eeb260906a183e6ae1abdba2ef5ef2257a21801128899c3fc699229c6" +dependencies = [ + "winapi-i686-pc-windows-gnu", + "winapi-x86_64-pc-windows-gnu", +] + +[[package]] +name = "winapi-i686-pc-windows-gnu" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6" + +[[package]] +name = "winapi-x86_64-pc-windows-gnu" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f" + +[[package]] +name = "xml-rs" +version = "0.8.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "541b12c998c5b56aa2b4e6f18f03664eef9a4fd0a246a55594efae6cc2d964b5" diff --git a/triangle-time/Cargo.toml b/triangle-time/Cargo.toml new file mode 100644 index 0000000..b163b2a --- /dev/null +++ b/triangle-time/Cargo.toml @@ -0,0 +1,14 @@ +[package] +name = "triangle-time" +version = "0.1.0" +authors = ["eater <=@eater.me>"] +edition = "2018" + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[dependencies] +eatgel = { path = "../eatgel" } +glfw = "0.36.0" +gl = "0.14.0" +nalgebra-glm = "0.6.0" +image = "0.23.0" diff --git a/triangle-time/res/eater.png b/triangle-time/res/eater.png new file mode 100644 index 0000000000000000000000000000000000000000..fad3db7e6ab1469352392b609dd4ee0c92f6d264 GIT binary patch literal 4410 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 AaR2}S literal 0 HcmV?d00001 diff --git a/triangle-time/res/pizza.png b/triangle-time/res/pizza.png new file mode 100644 index 0000000000000000000000000000000000000000..dea7e0348dd1253fd5790335c03857a56534dc91 GIT binary patch literal 210513 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 N|NKGiLIE=O=5Hx9*5N~&1DJ9`1p zZ>wwod70Q08i$sM$UsqR`C}owm#?+Ox90~C8@j`vYGMc`3*DHI+m$V*0^@qr`W@~&a$T_b9|>*1lWA7CEZ%?a`6*{LVJ`*=RsU z|9)ggV+{?@>Og zY*b?6swLVtX{l_M$pTb~#h8sUiOR}K#s1CO>R_-cGqWl`qbP*X=jhLddCgvK&1e$0 z6V%qiibdWoqOgb z5T8Dj6KA6%Vm^@o?*u+Vz9vGY!9h)HxE%0u8I4z&cWXl;_nC~0J@2+p=Hw#K(IgRih&O(R9D6}?jqpxDVD{*w zY()){b7k?7tUHDompRc=j%V&R82G<-1YYI z4`1!*=~`5}eS1+;70RBPT0SA4-?TNz$Ic>8u!Tao_#OQqkVuU;z$Z3JoTkW&bB~fp zkPxH87&bos)6yP(4ah^hhR^?#Upsl`wBr zo;acZStru{O?svX@^ON^5`VE1c_*+kc-1h>10FhyyJD&eC0N$OV+vW4Y2Ap`GwtjkPsK<1Ow^ z(j%?q_6=MA{Vq|;xSmeu75S6xz8?y`7hY1*g|$1l`Rk>Tb8R`uOOWo+4B-LjgH1e> zw4mp0Kv};Gm@H*dREd{i?dT*$zHyv{;htGhkdKdw4Q2+s+8YHh5If}A2ZvO%D4Qa) z`R{!#n<9I*2K{Au-%9Fxb!9eRJpAH3zJ(fEJBkXR8{?#DOG*($_;r9mU~GoP%0D1A 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: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

k?#B46C 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

4Q_pjsg`gpqB-Dkk{ACTa0^J#XP?KLWzd# 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 Self { + Simple { + model: zero(), + view: zero(), + projection: zero(), + our_texture: TextureSlot::Slot0, + } + } +} + +impl Simple { + pub fn new() -> Self { + Self::default() + } +} + +struct State { + shader_program: ShaderProgram, + texture: Texture, + context: GlContext, + object: StaticBufferNonIndexed, + size: (i32, i32), +} + +fn init(mut context: GlContext, window: &Window) -> State { + let vertex_shader = Shader::compile( + ShaderType::Vertex, + include_str!("../shaders/simple_vertex.glsl"), + ) + .expect("Failed to compile vertex shader"); + let fragment_shader = Shader::compile( + ShaderType::Fragment, + include_str!("../shaders/simple_fragment.glsl"), + ) + .expect("Failed to compile fragment shader"); + + let mut shader_program = + ShaderProgram::create_with_data(Simple::new(), vertex_shader, fragment_shader) + .expect("Failed create shader program"); + + let vertices = vec![ + Vertex { + position: vec3(-0.5, -0.5, -0.5), + uv: vec2(0.0, 0.0), + }, + Vertex { + position: vec3(0.5, -0.5, -0.5), + uv: vec2(1.0, 0.0), + }, + Vertex { + position: vec3(0.5, 0.5, -0.5), + uv: vec2(1.0, 1.0), + }, + Vertex { + position: vec3(0.5, 0.5, -0.5), + uv: vec2(1.0, 1.0), + }, + Vertex { + position: vec3(-0.5, 0.5, -0.5), + uv: vec2(0.0, 1.0), + }, + Vertex { + position: vec3(-0.5, -0.5, -0.5), + uv: vec2(0.0, 0.0), + }, + Vertex { + position: vec3(-0.5, -0.5, 0.5), + uv: vec2(0.0, 0.0), + }, + Vertex { + position: vec3(0.5, -0.5, 0.5), + uv: vec2(1.0, 0.0), + }, + Vertex { + position: vec3(0.5, 0.5, 0.5), + uv: vec2(1.0, 1.0), + }, + Vertex { + position: vec3(0.5, 0.5, 0.5), + uv: vec2(1.0, 1.0), + }, + Vertex { + position: vec3(-0.5, 0.5, 0.5), + uv: vec2(0.0, 1.0), + }, + Vertex { + position: vec3(-0.5, -0.5, 0.5), + uv: vec2(0.0, 0.0), + }, + Vertex { + position: vec3(-0.5, 0.5, 0.5), + uv: vec2(1.0, 0.0), + }, + Vertex { + position: vec3(-0.5, 0.5, -0.5), + uv: vec2(1.0, 1.0), + }, + Vertex { + position: vec3(-0.5, -0.5, -0.5), + uv: vec2(0.0, 1.0), + }, + Vertex { + position: vec3(-0.5, -0.5, -0.5), + uv: vec2(0.0, 1.0), + }, + Vertex { + position: vec3(-0.5, -0.5, 0.5), + uv: vec2(0.0, 0.0), + }, + Vertex { + position: vec3(-0.5, 0.5, 0.5), + uv: vec2(1.0, 0.0), + }, + Vertex { + position: vec3(0.5, 0.5, 0.5), + uv: vec2(1.0, 0.0), + }, + Vertex { + position: vec3(0.5, 0.5, -0.5), + uv: vec2(1.0, 1.0), + }, + Vertex { + position: vec3(0.5, -0.5, -0.5), + uv: vec2(0.0, 1.0), + }, + Vertex { + position: vec3(0.5, -0.5, -0.5), + uv: vec2(0.0, 1.0), + }, + Vertex { + position: vec3(0.5, -0.5, 0.5), + uv: vec2(0.0, 0.0), + }, + Vertex { + position: vec3(0.5, 0.5, 0.5), + uv: vec2(1.0, 0.0), + }, + Vertex { + position: vec3(-0.5, -0.5, -0.5), + uv: vec2(0.0, 1.0), + }, + Vertex { + position: vec3(0.5, -0.5, -0.5), + uv: vec2(1.0, 1.0), + }, + Vertex { + position: vec3(0.5, -0.5, 0.5), + uv: vec2(1.0, 0.0), + }, + Vertex { + position: vec3(0.5, -0.5, 0.5), + uv: vec2(1.0, 0.0), + }, + Vertex { + position: vec3(-0.5, -0.5, 0.5), + uv: vec2(0.0, 0.0), + }, + Vertex { + position: vec3(-0.5, -0.5, -0.5), + uv: vec2(0.0, 1.0), + }, + Vertex { + position: vec3(-0.5, 0.5, -0.5), + uv: vec2(0.0, 1.0), + }, + Vertex { + position: vec3(0.5, 0.5, -0.5), + uv: vec2(1.0, 1.0), + }, + Vertex { + position: vec3(0.5, 0.5, 0.5), + uv: vec2(1.0, 0.0), + }, + Vertex { + position: vec3(0.5, 0.5, 0.5), + uv: vec2(1.0, 0.0), + }, + Vertex { + position: vec3(-0.5, 0.5, 0.5), + uv: vec2(0.0, 0.0), + }, + Vertex { + position: vec3(-0.5, 0.5, -0.5), + uv: vec2(0.0, 1.0), + }, + ]; + + /*let data: &[f32] = &[ + -0.5, -0.5, -0.5, 0.0, 0.0, 0.5, -0.5, -0.5, 1.0, 0.0, 0.5, 0.5, -0.5, 1.0, 1.0, 0.5, 0.5, + -0.5, 1.0, 1.0, -0.5, 0.5, -0.5, 0.0, 1.0, -0.5, -0.5, -0.5, 0.0, 0.0, -0.5, -0.5, 0.5, + 0.0, 0.0, 0.5, -0.5, 0.5, 1.0, 0.0, 0.5, 0.5, 0.5, 1.0, 1.0, 0.5, 0.5, 0.5, 1.0, 1.0, -0.5, + 0.5, 0.5, 0.0, 1.0, -0.5, -0.5, 0.5, 0.0, 0.0, -0.5, 0.5, 0.5, 1.0, 0.0, -0.5, 0.5, -0.5, + 1.0, 1.0, -0.5, -0.5, -0.5, 0.0, 1.0, -0.5, -0.5, -0.5, 0.0, 1.0, -0.5, -0.5, 0.5, 0.0, + 0.0, -0.5, 0.5, 0.5, 1.0, 0.0, 0.5, 0.5, 0.5, 1.0, 0.0, 0.5, 0.5, -0.5, 1.0, 1.0, 0.5, + -0.5, -0.5, 0.0, 1.0, 0.5, -0.5, -0.5, 0.0, 1.0, 0.5, -0.5, 0.5, 0.0, 0.0, 0.5, 0.5, 0.5, + 1.0, 0.0, -0.5, -0.5, -0.5, 0.0, 1.0, 0.5, -0.5, -0.5, 1.0, 1.0, 0.5, -0.5, 0.5, 1.0, 0.0, + 0.5, -0.5, 0.5, 1.0, 0.0, -0.5, -0.5, 0.5, 0.0, 0.0, -0.5, -0.5, -0.5, 0.0, 1.0, -0.5, 0.5, + -0.5, 0.0, 1.0, 0.5, 0.5, -0.5, 1.0, 1.0, 0.5, 0.5, 0.5, 1.0, 0.0, 0.5, 0.5, 0.5, 1.0, 0.0, + -0.5, 0.5, 0.5, 0.0, 0.0, -0.5, 0.5, -0.5, 0.0, 1.0, + ];*/ + let _indices: &[u32] = &[0, 1, 3, 1, 2, 3]; + + let object = context.create_static_buffer_non_indexed(vertices); + let bytes = Cursor::new(include_bytes!("../res/eater.png").to_vec()); + + shader_program.init(&mut context); + + State { + shader_program, + context, + object, + texture: Image::load(bytes, ImageFormat::Png) + .expect("Failed to load image") + .into_texture(Default::default()) + .expect("Failed to load as texture"), + size: window.get_size(), + } +} + +fn render(state: &mut State, _glfw: &mut Glfw) { + let gl = &state.context; + let shader = &mut state.shader_program; + let texture = &state.texture; + + gl.clear(); + + shader.enable(); + texture.enable(TextureSlot::Slot0); + shader.our_texture = TextureSlot::Slot0; + + let model = one::(); + let _model = glm::rotate(&model, -55.0f32.to_radians(), &vec3(1.0f32, 0.0f32, 0.0f32)); + + let view = one::(); + let view = glm::translate(&view, &vec3(0.0f32, 0.0f32, -3.0f32)); + + let projection: Mat4 = glm::perspective(45.0f32.to_radians(), 1.0, 0.1, 100.0); + + /*let camera_pos: Vec3 = vec3(0.0, 0.0, 3.0); + let camera_target: Vec3 = vec3(0.0, 0.0, 0.0); + let camera_sub: Vec3 = camera_pos - camera_target; + let camera_direction: Vec3 = glm::normalize::(&camera_sub); + + let up = vec3(0.0, 1.0, 0.0); + let camera_right = glm::normalize(&glm::cross(&up, &camera_direction)); + let camera_up = glm::cross(&camera_direction, &camera_right); + + let view = glm::look_at( + &vec3(0.0, 0.0, 0.3), + &vec3(0.0, 0.0, 0.0), + &vec3(0.0, 0.1, 0.0), + );*/ + + // let trans = one::(); + // let trans = glm::translate(&trans, &vec3(0.5, -0.5, 0.0f32)); + + unsafe { + gl::Enable(gl::MULTISAMPLE); + } + + let translates = &[ + glm::vec3(0.0, 0.0, 0.0), + glm::vec3(2.0, 5.0, -15.0), + glm::vec3(-1.5, -2.2, -2.5), + glm::vec3(-3.8, -2.0, -12.3), + glm::vec3(2.4, -0.4, -3.5), + glm::vec3(-1.7, 3.0, -7.5), + glm::vec3(1.3, -2.0, -2.5), + glm::vec3(1.5, 2.0, -2.5), + glm::vec3(1.5, 0.2, -1.5), + glm::vec3(-1.3, 1.0, -1.5), + ]; + + shader.view = view; + shader.projection = projection; + + let time = unsafe { glfwGetTime() } as f32; + let radius = 10.0; + let cam_x = time.sin() * radius; + let cam_z = time.cos() * radius; + + shader.view = glm::look_at( + &vec3(cam_x, 0.0, cam_z), + &zero::(), + &vec3(0.0, 1.0, 0.0), + ); + + for i in 0..translates.len() { + let model = one::(); + let model = glm::translate(&model, &translates[i]); + let angle = i as f32 * 20f32; + let model = glm::rotate( + &model, + unsafe { glfwGetTime() } as f32 * 50.0f32.to_radians(), + &vec3(0.5, 1.0, 0.0), + ); + shader.model = glm::rotate(&model, angle, &vec3(1.0f32, 0.3f32, 0.5f32)); + shader.apply(&gl); + state.object.draw(); + } +} + +fn main() { + let mut glfw = glfw::init::<()>(Some(Callback { + f: |err, err_str, _| { + println!("{:?}: {:?}", err, err_str); + }, + data: (), + })) + .expect("Failed to init GLFW"); + + glfw.window_hint(WindowHint::ContextVersion(3, 3)); + glfw.window_hint(WindowHint::OpenGlProfile(OpenGlProfileHint::Core)); + glfw.window_hint(WindowHint::Samples(Some(4))); + + let (mut window, events) = glfw + .create_window(500, 500, "T̶ R҉ I͜ A ͢N ͠G L̷ E̷", WindowMode::Windowed) + .expect("Failed to create window"); + + window.make_current(); + window.set_key_polling(true); + + glfw.set_swap_interval(SwapInterval::Adaptive); + + let context = GlContext::new(|x| window.get_proc_address(x)); + + let mut state = init(context, &window); + + unsafe { + gl::Viewport(0, 0, state.size.0, state.size.1); + gl::Enable(gl::DEPTH_TEST); + } + // let mut time = Instant::now(); + // println!("0"); + while !window.should_close() { + let (width, height) = window.get_size(); + + if state.size != (width, height) { + unsafe { gl::Viewport(0, 0, width, height) } + } + + state.size = (width, height); + + render(&mut state, &mut glfw); + + window.swap_buffers(); + glfw.poll_events(); + for (_, event) in flush_messages(&events) { + if let WindowEvent::Key(key, _, Action::Release, _) = event { + if key == Key::Escape || key == Key::Q { + window.set_should_close(true); + } + } + } + // + // let new_time = Instant::now(); + // println!( + // "\x1B[1A\x1B[Kfps: {}", + // (1.0 / (new_time - time).as_secs_f64()).floor() + // ); + // + // time = new_time; + } + + window.close(); +}