From 04d1969084f925fc55881fcd9892630b184c892d Mon Sep 17 00:00:00 2001 From: milkwx3 Date: Tue, 7 Jul 2026 22:02:10 +0300 Subject: [PATCH] Added day&night cycle. Also fixed world loading --- compile_linux.sh | 4 +- compile_windows.sh | 4 +- compile_windows_64.sh | 4 +- data/resources/archimedes-64.hex | 64 - data/resources/bomb.png | Bin 308 -> 0 bytes data/resources/locale.yaml | 14 +- data/resources/moon.png | Bin 0 -> 4564 bytes data/resources/shaders/terrain.fs | 37 + data/resources/shaders/terrain.vs | 32 + data/resources/shaders/water.fs | 46 + data/resources/shaders/water.vs | 34 + data/resources/stars.png | Bin 0 -> 901 bytes data/resources/sun.png | Bin 0 -> 2045 bytes src/CMakeLists.txt | 2 +- src/FastNoiseLite.h | 2441 +++++++++++++++++++++++++++++ src/PerlinNoise.hpp | 659 -------- src/helpers/chunks.cpp | 231 ++- src/helpers/common.hpp | 16 +- src/helpers/entities.cpp | 2 +- src/helpers/input.cpp | 8 +- src/helpers/inventory.cpp | 8 +- src/helpers/mesher.cpp | 12 +- src/helpers/utils.cpp | 59 +- src/helpers/vars.hpp | 7 +- src/rcraft.cpp | 222 ++- 25 files changed, 3018 insertions(+), 888 deletions(-) delete mode 100644 data/resources/archimedes-64.hex delete mode 100644 data/resources/bomb.png create mode 100644 data/resources/moon.png create mode 100644 data/resources/shaders/terrain.fs create mode 100644 data/resources/shaders/terrain.vs create mode 100644 data/resources/shaders/water.fs create mode 100644 data/resources/shaders/water.vs create mode 100644 data/resources/stars.png create mode 100644 data/resources/sun.png create mode 100644 src/FastNoiseLite.h delete mode 100644 src/PerlinNoise.hpp diff --git a/compile_linux.sh b/compile_linux.sh index ed6bb9d..21231e4 100644 --- a/compile_linux.sh +++ b/compile_linux.sh @@ -12,6 +12,4 @@ make -j12 cd .. mkdir OUTPUT-Linux cp build/src/RCRAFT OUTPUT-Linux/CubeGame -cp -r data/resources OUTPUT-Linux -mkdir OUTPUT-Linux/user -mkdir OUTPUT-Linux/user/worlds \ No newline at end of file +cp -r data/resources OUTPUT-Linux \ No newline at end of file diff --git a/compile_windows.sh b/compile_windows.sh index f1a4155..3d058ac 100644 --- a/compile_windows.sh +++ b/compile_windows.sh @@ -12,6 +12,4 @@ make -j12 cd .. mkdir OUTPUT-w32 cp build/src/RCRAFT.exe OUTPUT-w32/CubeGame.exe -cp -r data/resources OUTPUT-w32 -mkdir OUTPUT-w32/user -mkdir OUTPUT-w32/user/worlds \ No newline at end of file +cp -r data/resources OUTPUT-w32 \ No newline at end of file diff --git a/compile_windows_64.sh b/compile_windows_64.sh index 6a6179a..a38b01f 100644 --- a/compile_windows_64.sh +++ b/compile_windows_64.sh @@ -12,6 +12,4 @@ make -j12 cd .. mkdir OUTPUT-w64 cp build/src/RCRAFT.exe OUTPUT-w64/CubeGame.exe -cp -r data/resources OUTPUT-w64 -mkdir OUTPUT-w64/user -mkdir OUTPUT-w64/user/worlds \ No newline at end of file +cp -r data/resources OUTPUT-w64 \ No newline at end of file diff --git a/data/resources/archimedes-64.hex b/data/resources/archimedes-64.hex deleted file mode 100644 index 8b5017c..0000000 --- a/data/resources/archimedes-64.hex +++ /dev/null @@ -1,64 +0,0 @@ -211d25 -413d42 -5c5b63 -7c808b -a5b0b6 -d6dede -ffffff -dcded1 -aab1a1 -7b8375 -585f57 -3c3c3c -635d5a -8d837d -b4aea4 -dedcd1 -eadedf -bcacb1 -8f8189 -685d66 -643747 -b2434d -e55858 -fa8971 -ffb999 -ffe0b7 -ffbdc1 -ef93b5 -c971a2 -944e89 -4c3d57 -5d558f -777dc4 -96b1e7 -bedef6 -aae3db -5ac5ce -4694a8 -346376 -2a3b4a -29684a -379648 -79b547 -b8cf61 -f3db6f -f4ba7a -e79055 -ce6442 -944940 -91555d -b76f6b -cd9383 -e1ba9e -facafb -d49ce5 -9f76b8 -725689 -edb762 -fcfbc9 -de9463 -b66a4d -333f29 -4e5c2c -708939 diff --git a/data/resources/bomb.png b/data/resources/bomb.png deleted file mode 100644 index 0ac13d6d2bb4b10b7bce93630d79bbdb023ad3b4..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 308 zcmeAS@N?(olHy`uVBq!ia0vp^0wB!63?wyl`GbKJV{wqX6T`Z5GB1IggaDrqS7!#T zP6qXxDmMQU!~btjI-ciNY^i4=D9_9;pl+?}+GIIrr}h6EM*o|vFFMHANJ<&)MO1^?E>33B^73m3|3A3%zhmVA>nRE1i5uf*OaR)Y zP!i-9%z@;j|==^1poj5AY({UO#lFTCIA3{ga82g0001h=l}q9FaQARU;qF* zm;eA5aGbhPJOBUy32;bRa{vGf5&!@T5&_cPe*6Fc02y>eSad^gZEa<4bO1wgWnpw> zWFU8GbZ8()Nlj2!fese{01+5TL_t(|+SQw9b0pVwhM)J`p48m~U`dM0U|N z|3g-?tYVo_T&}sm)-g#aX{3N923yKpKnn&|Kz_Y z0{r=3gc*d8z?(ppt|+w_l_cMR_w=|$uhFgQ`q%!8Ai%%>v#=I;N5H@Y@@0LX_AL># zS^zjcy49>by86d=Mufe4@PAU0bSrTw9}H|j{o{PJpQHN^qW$dn8mlk#cc}sX>`zJU zWnk87fjSLnNzlj#s8@aOO(8i#AAAx}Hk`zZmjB>?7XUi#f(i4a+SzgP8P6!4e{h>kaz2(nXX|7%Eu zcRt}QNYLAZZ%@-ocm&+AV1&X@e%^b*tObmvPpbtn;xQ7Nn2AV-GWetg-i66GBtdTl z-Y;CVGH{s@LLf{6Ap|TKQb1Wx39%tIXP`kH z0kLzGZ$N_H9K5$0kiaN|oXm<0zQC-&LO?3g`${CF?^sU&48X?(nh1WzY104ph-bV> zuk~gThtcA7%t3DkKDHWQS@{AM3W`}lC~bqXMKM@ydjs4_^l z?F}dqAV1+c1E-`to=iv*-lQ6$|BG3u?yE1PVpO4BN|$M&(`eIZ>vPD1gc zz<0Sw6u6QU+(6mcg$$kvVg^icpCV1c7AVx1o}kIc$ZtS5i6EP$t2D=~-nY1J@!d0G ze1U6?Yd_YW){&BU@O*nQCb#P93k|)RghvVR?|!e2&~&9C0fAy#V4*;*s%x60&lFhD zuw*j(7z_W5^AU=3SQ*3sL2#9T#M^m_|GI&tqhlc0H+c99(Y_+a^*{rZv_@?@;7~Yr zPDzxqDWvyPUHJ$Juh0N*ElOQ+uB?V(60)Ofo!kVGh>#ZGAF@0BmKh%ro09cfEIDF} zJ*-*V=L+vnoC2-Me}Z^o1A+Yy*SEV`mp zK<#_1+yiq~>yoDVS4h z)>WeFz`G^&w@JW?fI^W8D3Y_YIcI;L?e-I71%(yVEVyeTSIrC91j_KdvA|8__xRf=8L9}_b2Ke*et1sK> zeSmw)=QRl^qzHg=h_e|df1myCGu{ip)q!Fk@p^-A_BcDd7DPkqGJEkz^gY{cMFn`d zWfLOh>`1tqAz&L8ENU=r(EdNM05N=?5+oW>&J1Z%NC+WC6(Vwh9Cx)Tv#-CB>QDV~ z4KVAQ8NHd>+_ss`R`9P5uRI*2L4PPmpv53dA|*2q`>xo2Cz{76;#aB~^)p z;(inJzjd#1(}I^7DpJaeLMQ!Gv*39CkoQc4_XI&K%QLsDDRNe6{5CLS|TPT%NEft||A|aI=ROa|ksd1_EMfDcvCo!&oj;7&DtE zr`jBo3h&NIW7adaI7<$MP*Imc0etDK*P`@-&Gs`Ev%g_lgC7&{oMOA@`@1N)+p4h@ z^!971{KSj#i~rkqcDOJB$xxAjt50ba=2-Coan+z8RFrU4VRuKC<&okr2M=gHBYI%# zqAr9ggKe2|ta1Z7P*~*J9Ip>p0hC*8TcxzQ+EXo$7#o&#K=vtq{F>P8`V5hftIbq$ zd(^#(#~;%GD+X#m>fjpcn)}v+*Az{k;N0*-(Qp$WEcdXU;2v1-=3L(dtSF!`%#C_2 zR0{S-sFE+=Y@wPfx6;5ZXJ28Bm*6T{?@H?O2g<1hysA`&8|%wh#}< zPgL$G9PmnPHzie!s6M8UW|N#V2(8y(Gq&-Ds%g;e0<=WaBIPH8o9{^I++G_AgpVEJ zKm)>HY^8CZuW$1AwuTJNr>J^@vxj&@L2z}3$pWrx3T~-&NQF|ZoT2R#5eR&NZRSK) zD2TdVqRkqY<(Ahmea8*=4V0n|3rtTSp1><;0*aS?#vc5I)LVnNPk?L;zPEqTj&%BV zR`RwefK784dXdh&ox)Nn>#M;m=Gy)TV4G@JI{^!z#Oo>B-3`^;&^|(aKq`S;7Vjp+ zIjrQcK5?ZpT+QG%0(H`WFuv)e{Tfe|vh@2t>ZJw@MphbVK>NaFQq+gSS(cQ6MOYp| zTd4mp=hM67FTBJx10BE%XeO{bqk2YFPSI|W)ZLcA0h)D6vFjNoxLP)Ne1WeUJkF5K zVA

Sc6)Hu2(Rc#6H{vD**hw>R){b{P@d#Ryg*w1~@SaTSvIwLaed}-r+k#WdN&y zCG3)vQ-l#LP7o|rfL_7w4*UnGmr1GjE8=X++9I{~=z5x}z`@v{y+8M%K=m38k;^aW z0pOS6g%geuV+rRy>$^F%8`c18fflLqD}mJxMTR@enKq=z&G1<6H zQq-tYPqD6J>MY41HmSO7ix$6#^X+RFiGaUBPw){{YH+`1wKD4SbCyx4XlG5N~1kJ}e^GyeBjo>;o(;6$|ow{wXd;af5bew7e!p$L@|$2oKy#b$q;EFy1%t z%jxigL)ZtpBlrFq@D-AAbzKu~mZ+%Vx`v{J>V$8O;PZ3_J0yu(gvAkdGuUKPst)OP zBCr#9jeA8rAGuo{S+5pEub~V?KeD=WnsN=3W*}A{kJZ~&`%CV=(|{3h`2|h64J^ik zN<3F%s~mVHU`xDcld^~hV?#l;xk2?B>OB!d#N3_TDa#|a zU8E?oXjr-zr|a4)F}@DkUaYRr3D60za`> z&d~A%n&F7uF16HQp02-7g%bPh#m$j9(t)x9E7Ne*cA)Zvmlf;n0+uJx^VCco+*1m5 zalC7Dp}~H!AfZtCC=5PKM10^lC!qE{EF)N%^Jz;0S&8jN#O4TFL(y0)nmiOarwcAp zQpL>1&Q>!-!1g!PWr0}YTddcXjBtgmW{4o}dYycz%ZJ?>v4 zdkTC2zQ`v(f<#po*nR@@0uED{H|%!rQI8h7OonPVxcNiAen7<>mVhd#j~EC1 z_$}^-QA^B8^My1}9gNdEE%#w-OpA}bc!iZHf2p0n4M|9o8#sbL1OGO+!)J&Ekq_7y z)FD810xGC##Dr3HYN{-<12l*EVL*1a<-J4cIkB1IO@Y>1ynKe+_YjZW+%P%hRw()C zM(Ovq&KL|f>CK?imZ4W|ZzzwfI^cuDH+cLUc#%`s9a=k8nQ{bT1-l9{K~|wEjHWx3 zK)6)hn7~__6UMk^wYsG_eM58jD=}_xPT7>s-MzWzvASaN2)TQFX#|Up{E;OoXS~MM zvU(5vDII=*_&px~jB}UYbL2C&s|CJYjBQ*w+UUZ$4zGuU8k!hcZ_YH$ElvD}X7L9I z&$Edfb0U_8sA+=S;7z=USm}DMd#{cNP^f*dtauqqvj%t`P3K8%x``w1JG}WC;vYeG zP&a5Bsp1wbwyD(}Gq_9OyFBIGM%eUZyPw%@kId({Y&Snpg#SX}8_*8tfOEwCm?p*@ z_$KWY5PRusv~H#H>0@1CzbGHon}B^v@u+scsKi9LUvJ7)immp5qLEOWA4Svk^>wTMxN{O^H(&S*lquV%0FhaE2!&+u2;!96R=AfVFTcJ z%JJ{cZ2U;6FJbXNgyMP9GT-IMb4aG=X|U>k?xf#Njg$%Qz<>DTMq?_jFG-*qIwn8x zKw;EbOafzk!+g3$;VD(|YZN|8V>60;o<%0`GR&TVJ>qXHW}hQ{hqD?;ecwG!>VL%J zDXq>7wnos%^*sds(L5lLa5pBQ+ro&$9>GAxMv)^DiZf`7_zvO|+@2zCK-amCFv*`i z=Hm|h1>SrI^A`kL<77!^n7!iZoWY+un~&%7 z7<`}i{}}ME)euop_at~rLhBu3@5N~PNM}WMuQ6mq0h(T?sh|LxF*+} ziB0;Sh>qi`Rrf;OJ0aj637sYkmj693{mWwN>ob@j6S}>kaReFk9Jr`AyvZ3}lYCCz z7$vp@d2ffQ@KOErwH75`yCtTgc0a8yy6XcK^zN4r0jxnDk`&vKn)j=+50~6o3)IrJHY)NQmEiHyN{u*l9Wyd^3aT@@)tVEZ?s@QFd zwiTVnh&M53cs{E42ie}6fPbr|Xd>Zm44@x84Z~&Z#?3D4eg%@2H!kyxes?~t&JS$7 zbF!Xxe}>>ce&codx9AFkCRd3B4e~{G9fxKRG17XCVxBS$6t^>`i{cAjc8r=@Zv+0V z3Ft|<9g=X_Q@L!ijh=~eyeo&I?8o&Ro7)A#)4O;&$oMstsxdvB@w;Fs~s(e9p)&($@LhWiyS&4c{n yS7hC<$fd2=gyL}G2anMprB-lYeY$Kep*R+Vo@qXKw@TIiJqTph=Qq} zp`M|UFr#}3P|=Rm2+uT6Pb~%xAcvJfijkFp5y>NgBus9P?+>nupK@dns z0dZzK3s^h{$OeG~AO`7&(df1^FfcPPOkihV0je=DGB#jb05KP&hjjtOtZ6_t2rvOn zVgjoSva|rQpt=kV3_!9sm(QAdayxfCP@SQti(`m|f9@6k4&OkT10Sm^|JkU?Z4x*v zteKRaebh;_&FB=9@1h)$vrdR9O~Xv z`R?=IdzRtbkFU48TU_`3UirD7bBp6+)`qd4dRnwFLg$-n;1?Fdz69xIk1gKin$3Q@ z<$SX0KK5|K&g6)8wNHlZ!Y>}1U#kA&w_g00_}k~oJ%wVQ3umUQoj6*!H*UQMSF4|p z|4zde$(-YgcbbG>9tvF3ZrE3M=NRXkV@@UsDg_H1#WR$A9!TjpnExy+D$bn!{pQsj zg15{KnLX}Ma#vHE2xx7k8d8>Za}u40E*-MqHvf`4=4nn@cOU+T5QNWV*z zT(clC)Yhx&A&YOybFJ?9f`IqeKbCKpHlyizHfP=J6Rz9twz;d^%{s(-<6Y8h+0TA2 zen&_89KIu|zJc9(qqwL|!_+$*@2`Fk`{`-5lD}f=w>0tObLo3lb<}+Q*IAHnd~K1g z=Op=<`Xt6R2`7yWJRUQ=OOo)*VD~$Cvh1+_R^hyf`umR+|6r6oZnq<1bw=x*M%NF2 zLoGW0xBi#uyL~^yWZJc?t?QQtW%m3Fi@3|DUeVdc9Pbz=c>X%8&nDjGmB;o^ERJB@ zU$p(PmEFOU>l;H)w+sK}DL-Do*!J_yjUPv=_+nfB{(bnWe4|a*qKWq50Xp~RuJ5=H ON=TlrelF{r5}E)3gh>_v literal 0 HcmV?d00001 diff --git a/data/resources/sun.png b/data/resources/sun.png new file mode 100644 index 0000000000000000000000000000000000000000..1a5985438ec9dd68b7ddc774fa1157700576345b GIT binary patch literal 2045 zcmVz@;j|==^1poj5AY({UO#lFTCIA3{ga82g0001h=l}q9FaQARU;qF* zm;eA5aGbhPJOBUy32;bRa{vG?BLDy{BLR4&KXw2B02y>eSad^gZEa<4bO1wgWnpw> zWFU8GbZ8()Nlj2!fese{00%)yL_t(|+T~kKZ`?KzeM8AMkepp7bzR#d zSI1u0*(Qe1ZBg%v(*wy}YQ!O_k4*|xfFNmC8tT0n4rhiGVZn|0F9HaM-55kKcqwVL zEcl{$sz#Z+1QsKK4g-AAHnKqH5MG~l@U9Lapq&18sftCTkJCKm89c#6pIkMU%#*jcW zz*F302Jl!CQlJ$gShJF95@=!Y@|+4}cw8;>W(|*`(=C|m6PIaFm3A6xs4X}1hk&ps!3rEEwcoYe=Ab2Cdik&nPkOt2I ztlU|gi+!9W(8NBkX*}#r1U$Z$B%}z4L3RMg;5&tk$s|xZwr5TIn${)wCIa3FQeqM$ z0RsH)7>MW+Bq-LPIY#Q`4s9W^83VqFz(?n36%t7J09L?ny(M)3hiAIPyV~KaGiym) zAfeTLBg=k|ME{ps4}jYUczoUnpFmO=pt#=$@ZtV#zkMP>LU=ZI(i|z0J$WoGq0O6qt;6eS{%E+<(cTK0 z3-=r=1auG1+_43C17MSOoD?TSEV@E`A0zQlXKXJ$A3g9Ea zTma@Apw|G-fO`V$nQO*80+$Tn5uh&suL1i2G`|4dN-=qFHLQ`K_<=qdZN~IVjxQeL zh4$$Lz=;D-mw@>Rz&Wsb=VaJZ;lO_YJ^?UK0Nw*vAA#mafIkBbc@m__`z}M)TZl=J zP%Npn84IC;1&E<9kU+?GUDB4$bZ!Ux3QfByh%-#SrmDw6Lv0B%l!Pp3}g&t7{C1Kn*jL`DG- z*@zg*_<|}QkSk+JA0S8|@9_A@nLT;%HNYha0C4lxzXAhx?PPbi0B<7_WI!fKV1)>R z?>jlID?=e=NI>fx9?qTF&)x1`Ia%f+5oAU0K$JVKxvRJ1Ok z<^N~Hp>ED*Po2y`J5x1ZMF8rpA@o1?nz}#06!E>6&7#dJ&8tw%gg2pbybvP1B{zFk zp=BD2!Qg+sO(B5GNr`zpz^guHO5-R6JlcI`BKTDKDI_Ofd}6ckcIjo4Xj3HvncsIm zn@UY{Md>=;AAMr8l=h#TOtnJH71mMJ1-M@81MraE}H z1AsMf{dK+tTz_@4>_fkeUfVX|6RMnetK2}!xh!2b5%|W{@Va|f$>GoL+16)uwdwHA z>;bgD0sO0zMP4><5+r2i2UKS`D2uZaNJ!x18Mpi5bkWFizvg(Yw|)fu)K7r>dZKCa4`ehr^}YTB(FC*heZpCR6oo+p?m!0^7$ z_rN~`{2UR`WoC-F!l47;K^Nde5uw%!qVP04-rc!Mj$ONa{_2l%QIw;iC~YF}|F~n% z3gq13Xe%J*zo}3b&rOAeN|2ln$dtv6FN>2>7Po6r7T_3vAxvm?xBDs%Jv##IDm^h`ANE~}H+{fT`-7oS(|Ue^#Dv+Q)P(5FsWGIc z#^PN#Ki2$!hza7Ua^j>DBznO^61c}vVjfOto#T7M-t{LsdCKJIc6i<$zyjxJ52jwxAdQCu#wx( zKte6(8UhqDmH|JS0EL8jgun#g7*7OelbnNmF;XUhYCo8oN&ry!UT7@%$pj2Zpc>#) z2&f@qGWb~pWYXxVz^4!~i0!{A0R<9j +#include +#include +#include + +// Enums +typedef enum +{ + FNL_NOISE_OPENSIMPLEX2, + FNL_NOISE_OPENSIMPLEX2S, + FNL_NOISE_CELLULAR, + FNL_NOISE_PERLIN, + FNL_NOISE_VALUE_CUBIC, + FNL_NOISE_VALUE +} fnl_noise_type; + +typedef enum +{ + FNL_ROTATION_NONE, + FNL_ROTATION_IMPROVE_XY_PLANES, + FNL_ROTATION_IMPROVE_XZ_PLANES +} fnl_rotation_type_3d; + +typedef enum +{ + FNL_FRACTAL_NONE, + FNL_FRACTAL_FBM, + FNL_FRACTAL_RIDGED, + FNL_FRACTAL_PINGPONG, + FNL_FRACTAL_DOMAIN_WARP_PROGRESSIVE, + FNL_FRACTAL_DOMAIN_WARP_INDEPENDENT +} fnl_fractal_type; + +typedef enum +{ + FNL_CELLULAR_DISTANCE_EUCLIDEAN, + FNL_CELLULAR_DISTANCE_EUCLIDEANSQ, + FNL_CELLULAR_DISTANCE_MANHATTAN, + FNL_CELLULAR_DISTANCE_HYBRID +} fnl_cellular_distance_func; + +typedef enum +{ + FNL_CELLULAR_RETURN_TYPE_CELLVALUE, + FNL_CELLULAR_RETURN_TYPE_DISTANCE, + FNL_CELLULAR_RETURN_TYPE_DISTANCE2, + FNL_CELLULAR_RETURN_TYPE_DISTANCE2ADD, + FNL_CELLULAR_RETURN_TYPE_DISTANCE2SUB, + FNL_CELLULAR_RETURN_TYPE_DISTANCE2MUL, + FNL_CELLULAR_RETURN_TYPE_DISTANCE2DIV, +} fnl_cellular_return_type; + +typedef enum +{ + FNL_DOMAIN_WARP_OPENSIMPLEX2, + FNL_DOMAIN_WARP_OPENSIMPLEX2_REDUCED, + FNL_DOMAIN_WARP_BASICGRID +} fnl_domain_warp_type; + +/** + * Structure containing entire noise system state. + * @note Must only be created using fnlCreateState(optional: seed). To ensure defaults are set. + */ +typedef struct fnl_state +{ + /** + * Seed used for all noise types. + * @remark Default: 1337 + */ + int seed; + + /** + * The frequency for all noise types. + * @remark Default: 0.01 + */ + float frequency; + + /** + * The noise algorithm to be used by GetNoise(...). + * @remark Default: FNL_NOISE_OPENSIMPLEX2 + */ + fnl_noise_type noise_type; + + /** + * Sets noise rotation type for 3D. + * @remark Default: FNL_ROTATION_NONE + */ + fnl_rotation_type_3d rotation_type_3d; + + /** + * The method used for combining octaves for all fractal noise types. + * @remark Default: None + * @remark FNL_FRACTAL_DOMAIN_WARP_... only effects fnlDomainWarp... + */ + fnl_fractal_type fractal_type; + + /** + * The octave count for all fractal noise types. + * @remark Default: 3 + */ + int octaves; + + /** + * The octave lacunarity for all fractal noise types. + * @remark Default: 2.0 + */ + float lacunarity; + + /** + * The octave gain for all fractal noise types. + * @remark Default: 0.5 + */ + float gain; + + /** + * The octave weighting for all none Domaain Warp fractal types. + * @remark Default: 0.0 + * @remark + */ + float weighted_strength; + + /** + * The strength of the fractal ping pong effect. + * @remark Default: 2.0 + */ + float ping_pong_strength; + + /** + * The distance function used in cellular noise calculations. + * @remark Default: FNL_CELLULAR_DISTANCE_EUCLIDEANSQ + */ + fnl_cellular_distance_func cellular_distance_func; + + /** + * The cellular return type from cellular noise calculations. + * @remark Default: FNL_CELLULAR_RETURN_TYPE_DISTANCE + */ + fnl_cellular_return_type cellular_return_type; + + /** + * The maximum distance a cellular point can move from it's grid position. + * @remark Default: 1.0 + * @note Setting this higher than 1 will cause artifacts. + */ + float cellular_jitter_mod; + + /** + * The warp algorithm when using fnlDomainWarp... + * @remark Default: OpenSimplex2 + */ + fnl_domain_warp_type domain_warp_type; + + /** + * The maximum warp distance from original position when using fnlDomainWarp... + * @remark Default: 1.0 + */ + float domain_warp_amp; +} fnl_state; + +#if defined(__cplusplus) +extern "C" { +#endif + +/** + * Creates a noise state with default values. + * @param seed Optionally set the state seed. + */ +fnl_state fnlCreateState(); + +/** + * 2D noise at given position using the state settings + * @returns Noise output bounded between -1 and 1. + */ +float fnlGetNoise2D(const fnl_state *state, FNLfloat x, FNLfloat y); + +/** + * 3D noise at given position using the state settings + * @returns Noise output bounded between -1 and 1. + */ +float fnlGetNoise3D(const fnl_state *state, FNLfloat x, FNLfloat y, FNLfloat z); + +/** + * 2D warps the input position using current domain warp settings. + * + * Example usage with fnlGetNoise2D: + * ``` + * fnlDomainWarp2D(&state, &x, &y); + * noise = fnlGetNoise2D(&state, x, y); + * ``` + */ +void fnlDomainWarp2D(const fnl_state *state, FNLfloat *x, FNLfloat *y); + +/** + * 3D warps the input position using current domain warp settings. + * + * Example usage with fnlGetNoise3D: + * ``` + * fnlDomainWarp3D(&state, &x, &y, &z); + * noise = fnlGetNoise3D(&state, x, y, z); + * ``` + */ +void fnlDomainWarp3D(const fnl_state *state, FNLfloat *x, FNLfloat *y, FNLfloat *z); + +#if defined(__cplusplus) +} +#endif + +#endif // FASTNOISELITE_H + +// ==================== +// Below this line is the implementation +// ==================== + +#if defined(FNL_IMPL) + +#if defined(__cplusplus) +extern "C" { +#endif + +// Constants + +static const float GRADIENTS_2D[] = +{ + 0.130526192220052f, 0.99144486137381f, 0.38268343236509f, 0.923879532511287f, 0.608761429008721f, 0.793353340291235f, 0.793353340291235f, 0.608761429008721f, + 0.923879532511287f, 0.38268343236509f, 0.99144486137381f, 0.130526192220051f, 0.99144486137381f, -0.130526192220051f, 0.923879532511287f, -0.38268343236509f, + 0.793353340291235f, -0.60876142900872f, 0.608761429008721f, -0.793353340291235f, 0.38268343236509f, -0.923879532511287f, 0.130526192220052f, -0.99144486137381f, + -0.130526192220052f, -0.99144486137381f, -0.38268343236509f, -0.923879532511287f, -0.608761429008721f, -0.793353340291235f, -0.793353340291235f, -0.608761429008721f, + -0.923879532511287f, -0.38268343236509f, -0.99144486137381f, -0.130526192220052f, -0.99144486137381f, 0.130526192220051f, -0.923879532511287f, 0.38268343236509f, + -0.793353340291235f, 0.608761429008721f, -0.608761429008721f, 0.793353340291235f, -0.38268343236509f, 0.923879532511287f, -0.130526192220052f, 0.99144486137381f, + 0.130526192220052f, 0.99144486137381f, 0.38268343236509f, 0.923879532511287f, 0.608761429008721f, 0.793353340291235f, 0.793353340291235f, 0.608761429008721f, + 0.923879532511287f, 0.38268343236509f, 0.99144486137381f, 0.130526192220051f, 0.99144486137381f, -0.130526192220051f, 0.923879532511287f, -0.38268343236509f, + 0.793353340291235f, -0.60876142900872f, 0.608761429008721f, -0.793353340291235f, 0.38268343236509f, -0.923879532511287f, 0.130526192220052f, -0.99144486137381f, + -0.130526192220052f, -0.99144486137381f, -0.38268343236509f, -0.923879532511287f, -0.608761429008721f, -0.793353340291235f, -0.793353340291235f, -0.608761429008721f, + -0.923879532511287f, -0.38268343236509f, -0.99144486137381f, -0.130526192220052f, -0.99144486137381f, 0.130526192220051f, -0.923879532511287f, 0.38268343236509f, + -0.793353340291235f, 0.608761429008721f, -0.608761429008721f, 0.793353340291235f, -0.38268343236509f, 0.923879532511287f, -0.130526192220052f, 0.99144486137381f, + 0.130526192220052f, 0.99144486137381f, 0.38268343236509f, 0.923879532511287f, 0.608761429008721f, 0.793353340291235f, 0.793353340291235f, 0.608761429008721f, + 0.923879532511287f, 0.38268343236509f, 0.99144486137381f, 0.130526192220051f, 0.99144486137381f, -0.130526192220051f, 0.923879532511287f, -0.38268343236509f, + 0.793353340291235f, -0.60876142900872f, 0.608761429008721f, -0.793353340291235f, 0.38268343236509f, -0.923879532511287f, 0.130526192220052f, -0.99144486137381f, + -0.130526192220052f, -0.99144486137381f, -0.38268343236509f, -0.923879532511287f, -0.608761429008721f, -0.793353340291235f, -0.793353340291235f, -0.608761429008721f, + -0.923879532511287f, -0.38268343236509f, -0.99144486137381f, -0.130526192220052f, -0.99144486137381f, 0.130526192220051f, -0.923879532511287f, 0.38268343236509f, + -0.793353340291235f, 0.608761429008721f, -0.608761429008721f, 0.793353340291235f, -0.38268343236509f, 0.923879532511287f, -0.130526192220052f, 0.99144486137381f, + 0.130526192220052f, 0.99144486137381f, 0.38268343236509f, 0.923879532511287f, 0.608761429008721f, 0.793353340291235f, 0.793353340291235f, 0.608761429008721f, + 0.923879532511287f, 0.38268343236509f, 0.99144486137381f, 0.130526192220051f, 0.99144486137381f, -0.130526192220051f, 0.923879532511287f, -0.38268343236509f, + 0.793353340291235f, -0.60876142900872f, 0.608761429008721f, -0.793353340291235f, 0.38268343236509f, -0.923879532511287f, 0.130526192220052f, -0.99144486137381f, + -0.130526192220052f, -0.99144486137381f, -0.38268343236509f, -0.923879532511287f, -0.608761429008721f, -0.793353340291235f, -0.793353340291235f, -0.608761429008721f, + -0.923879532511287f, -0.38268343236509f, -0.99144486137381f, -0.130526192220052f, -0.99144486137381f, 0.130526192220051f, -0.923879532511287f, 0.38268343236509f, + -0.793353340291235f, 0.608761429008721f, -0.608761429008721f, 0.793353340291235f, -0.38268343236509f, 0.923879532511287f, -0.130526192220052f, 0.99144486137381f, + 0.130526192220052f, 0.99144486137381f, 0.38268343236509f, 0.923879532511287f, 0.608761429008721f, 0.793353340291235f, 0.793353340291235f, 0.608761429008721f, + 0.923879532511287f, 0.38268343236509f, 0.99144486137381f, 0.130526192220051f, 0.99144486137381f, -0.130526192220051f, 0.923879532511287f, -0.38268343236509f, + 0.793353340291235f, -0.60876142900872f, 0.608761429008721f, -0.793353340291235f, 0.38268343236509f, -0.923879532511287f, 0.130526192220052f, -0.99144486137381f, + -0.130526192220052f, -0.99144486137381f, -0.38268343236509f, -0.923879532511287f, -0.608761429008721f, -0.793353340291235f, -0.793353340291235f, -0.608761429008721f, + -0.923879532511287f, -0.38268343236509f, -0.99144486137381f, -0.130526192220052f, -0.99144486137381f, 0.130526192220051f, -0.923879532511287f, 0.38268343236509f, + -0.793353340291235f, 0.608761429008721f, -0.608761429008721f, 0.793353340291235f, -0.38268343236509f, 0.923879532511287f, -0.130526192220052f, 0.99144486137381f, + 0.38268343236509f, 0.923879532511287f, 0.923879532511287f, 0.38268343236509f, 0.923879532511287f, -0.38268343236509f, 0.38268343236509f, -0.923879532511287f, + -0.38268343236509f, -0.923879532511287f, -0.923879532511287f, -0.38268343236509f, -0.923879532511287f, 0.38268343236509f, -0.38268343236509f, 0.923879532511287f, +}; + +static const float RAND_VECS_2D[] = +{ + -0.2700222198f, -0.9628540911f, 0.3863092627f, -0.9223693152f, 0.04444859006f, -0.999011673f, -0.5992523158f, -0.8005602176f, -0.7819280288f, 0.6233687174f, 0.9464672271f, 0.3227999196f, -0.6514146797f, -0.7587218957f, 0.9378472289f, 0.347048376f, + -0.8497875957f, -0.5271252623f, -0.879042592f, 0.4767432447f, -0.892300288f, -0.4514423508f, -0.379844434f, -0.9250503802f, -0.9951650832f, 0.0982163789f, 0.7724397808f, -0.6350880136f, 0.7573283322f, -0.6530343002f, -0.9928004525f, -0.119780055f, + -0.0532665713f, 0.9985803285f, 0.9754253726f, -0.2203300762f, -0.7665018163f, 0.6422421394f, 0.991636706f, 0.1290606184f, -0.994696838f, 0.1028503788f, -0.5379205513f, -0.84299554f, 0.5022815471f, -0.8647041387f, 0.4559821461f, -0.8899889226f, + -0.8659131224f, -0.5001944266f, 0.0879458407f, -0.9961252577f, -0.5051684983f, 0.8630207346f, 0.7753185226f, -0.6315704146f, -0.6921944612f, 0.7217110418f, -0.5191659449f, -0.8546734591f, 0.8978622882f, -0.4402764035f, -0.1706774107f, 0.9853269617f, + -0.9353430106f, -0.3537420705f, -0.9992404798f, 0.03896746794f, -0.2882064021f, -0.9575683108f, -0.9663811329f, 0.2571137995f, -0.8759714238f, -0.4823630009f, -0.8303123018f, -0.5572983775f, 0.05110133755f, -0.9986934731f, -0.8558373281f, -0.5172450752f, + 0.09887025282f, 0.9951003332f, 0.9189016087f, 0.3944867976f, -0.2439375892f, -0.9697909324f, -0.8121409387f, -0.5834613061f, -0.9910431363f, 0.1335421355f, 0.8492423985f, -0.5280031709f, -0.9717838994f, -0.2358729591f, 0.9949457207f, 0.1004142068f, + 0.6241065508f, -0.7813392434f, 0.662910307f, 0.7486988212f, -0.7197418176f, 0.6942418282f, -0.8143370775f, -0.5803922158f, 0.104521054f, -0.9945226741f, -0.1065926113f, -0.9943027784f, 0.445799684f, -0.8951327509f, 0.105547406f, 0.9944142724f, + -0.992790267f, 0.1198644477f, -0.8334366408f, 0.552615025f, 0.9115561563f, -0.4111755999f, 0.8285544909f, -0.5599084351f, 0.7217097654f, -0.6921957921f, 0.4940492677f, -0.8694339084f, -0.3652321272f, -0.9309164803f, -0.9696606758f, 0.2444548501f, + 0.08925509731f, -0.996008799f, 0.5354071276f, -0.8445941083f, -0.1053576186f, 0.9944343981f, -0.9890284586f, 0.1477251101f, 0.004856104961f, 0.9999882091f, 0.9885598478f, 0.1508291331f, 0.9286129562f, -0.3710498316f, -0.5832393863f, -0.8123003252f, + 0.3015207509f, 0.9534596146f, -0.9575110528f, 0.2883965738f, 0.9715802154f, -0.2367105511f, 0.229981792f, 0.9731949318f, 0.955763816f, -0.2941352207f, 0.740956116f, 0.6715534485f, -0.9971513787f, -0.07542630764f, 0.6905710663f, -0.7232645452f, + -0.290713703f, -0.9568100872f, 0.5912777791f, -0.8064679708f, -0.9454592212f, -0.325740481f, 0.6664455681f, 0.74555369f, 0.6236134912f, 0.7817328275f, 0.9126993851f, -0.4086316587f, -0.8191762011f, 0.5735419353f, -0.8812745759f, -0.4726046147f, + 0.9953313627f, 0.09651672651f, 0.9855650846f, -0.1692969699f, -0.8495980887f, 0.5274306472f, 0.6174853946f, -0.7865823463f, 0.8508156371f, 0.52546432f, 0.9985032451f, -0.05469249926f, 0.1971371563f, -0.9803759185f, 0.6607855748f, -0.7505747292f, + -0.03097494063f, 0.9995201614f, -0.6731660801f, 0.739491331f, -0.7195018362f, -0.6944905383f, 0.9727511689f, 0.2318515979f, 0.9997059088f, -0.0242506907f, 0.4421787429f, -0.8969269532f, 0.9981350961f, -0.061043673f, -0.9173660799f, -0.3980445648f, + -0.8150056635f, -0.5794529907f, -0.8789331304f, 0.4769450202f, 0.0158605829f, 0.999874213f, -0.8095464474f, 0.5870558317f, -0.9165898907f, -0.3998286786f, -0.8023542565f, 0.5968480938f, -0.5176737917f, 0.8555780767f, -0.8154407307f, -0.5788405779f, + 0.4022010347f, -0.9155513791f, -0.9052556868f, -0.4248672045f, 0.7317445619f, 0.6815789728f, -0.5647632201f, -0.8252529947f, -0.8403276335f, -0.5420788397f, -0.9314281527f, 0.363925262f, 0.5238198472f, 0.8518290719f, 0.7432803869f, -0.6689800195f, + -0.985371561f, -0.1704197369f, 0.4601468731f, 0.88784281f, 0.825855404f, 0.5638819483f, 0.6182366099f, 0.7859920446f, 0.8331502863f, -0.553046653f, 0.1500307506f, 0.9886813308f, -0.662330369f, -0.7492119075f, -0.668598664f, 0.743623444f, + 0.7025606278f, 0.7116238924f, -0.5419389763f, -0.8404178401f, -0.3388616456f, 0.9408362159f, 0.8331530315f, 0.5530425174f, -0.2989720662f, -0.9542618632f, 0.2638522993f, 0.9645630949f, 0.124108739f, -0.9922686234f, -0.7282649308f, -0.6852956957f, + 0.6962500149f, 0.7177993569f, -0.9183535368f, 0.3957610156f, -0.6326102274f, -0.7744703352f, -0.9331891859f, -0.359385508f, -0.1153779357f, -0.9933216659f, 0.9514974788f, -0.3076565421f, -0.08987977445f, -0.9959526224f, 0.6678496916f, 0.7442961705f, + 0.7952400393f, -0.6062947138f, -0.6462007402f, -0.7631674805f, -0.2733598753f, 0.9619118351f, 0.9669590226f, -0.254931851f, -0.9792894595f, 0.2024651934f, -0.5369502995f, -0.8436138784f, -0.270036471f, -0.9628500944f, -0.6400277131f, 0.7683518247f, + -0.7854537493f, -0.6189203566f, 0.06005905383f, -0.9981948257f, -0.02455770378f, 0.9996984141f, -0.65983623f, 0.751409442f, -0.6253894466f, -0.7803127835f, -0.6210408851f, -0.7837781695f, 0.8348888491f, 0.5504185768f, -0.1592275245f, 0.9872419133f, + 0.8367622488f, 0.5475663786f, -0.8675753916f, -0.4973056806f, -0.2022662628f, -0.9793305667f, 0.9399189937f, 0.3413975472f, 0.9877404807f, -0.1561049093f, -0.9034455656f, 0.4287028224f, 0.1269804218f, -0.9919052235f, -0.3819600854f, 0.924178821f, + 0.9754625894f, 0.2201652486f, -0.3204015856f, -0.9472818081f, -0.9874760884f, 0.1577687387f, 0.02535348474f, -0.9996785487f, 0.4835130794f, -0.8753371362f, -0.2850799925f, -0.9585037287f, -0.06805516006f, -0.99768156f, -0.7885244045f, -0.6150034663f, + 0.3185392127f, -0.9479096845f, 0.8880043089f, 0.4598351306f, 0.6476921488f, -0.7619021462f, 0.9820241299f, 0.1887554194f, 0.9357275128f, -0.3527237187f, -0.8894895414f, 0.4569555293f, 0.7922791302f, 0.6101588153f, 0.7483818261f, 0.6632681526f, + -0.7288929755f, -0.6846276581f, 0.8729032783f, -0.4878932944f, 0.8288345784f, 0.5594937369f, 0.08074567077f, 0.9967347374f, 0.9799148216f, -0.1994165048f, -0.580730673f, -0.8140957471f, -0.4700049791f, -0.8826637636f, 0.2409492979f, 0.9705377045f, + 0.9437816757f, -0.3305694308f, -0.8927998638f, -0.4504535528f, -0.8069622304f, 0.5906030467f, 0.06258973166f, 0.9980393407f, -0.9312597469f, 0.3643559849f, 0.5777449785f, 0.8162173362f, -0.3360095855f, -0.941858566f, 0.697932075f, -0.7161639607f, + -0.002008157227f, -0.9999979837f, -0.1827294312f, -0.9831632392f, -0.6523911722f, 0.7578824173f, -0.4302626911f, -0.9027037258f, -0.9985126289f, -0.05452091251f, -0.01028102172f, -0.9999471489f, -0.4946071129f, 0.8691166802f, -0.2999350194f, 0.9539596344f, + 0.8165471961f, 0.5772786819f, 0.2697460475f, 0.962931498f, -0.7306287391f, -0.6827749597f, -0.7590952064f, -0.6509796216f, -0.907053853f, 0.4210146171f, -0.5104861064f, -0.8598860013f, 0.8613350597f, 0.5080373165f, 0.5007881595f, -0.8655698812f, + -0.654158152f, 0.7563577938f, -0.8382755311f, -0.545246856f, 0.6940070834f, 0.7199681717f, 0.06950936031f, 0.9975812994f, 0.1702942185f, -0.9853932612f, 0.2695973274f, 0.9629731466f, 0.5519612192f, -0.8338697815f, 0.225657487f, -0.9742067022f, + 0.4215262855f, -0.9068161835f, 0.4881873305f, -0.8727388672f, -0.3683854996f, -0.9296731273f, -0.9825390578f, 0.1860564427f, 0.81256471f, 0.5828709909f, 0.3196460933f, -0.9475370046f, 0.9570913859f, 0.2897862643f, -0.6876655497f, -0.7260276109f, + -0.9988770922f, -0.047376731f, -0.1250179027f, 0.992154486f, -0.8280133617f, 0.560708367f, 0.9324863769f, -0.3612051451f, 0.6394653183f, 0.7688199442f, -0.01623847064f, -0.9998681473f, -0.9955014666f, -0.09474613458f, -0.81453315f, 0.580117012f, + 0.4037327978f, -0.9148769469f, 0.9944263371f, 0.1054336766f, -0.1624711654f, 0.9867132919f, -0.9949487814f, -0.100383875f, -0.6995302564f, 0.7146029809f, 0.5263414922f, -0.85027327f, -0.5395221479f, 0.841971408f, 0.6579370318f, 0.7530729462f, + 0.01426758847f, -0.9998982128f, -0.6734383991f, 0.7392433447f, 0.639412098f, -0.7688642071f, 0.9211571421f, 0.3891908523f, -0.146637214f, -0.9891903394f, -0.782318098f, 0.6228791163f, -0.5039610839f, -0.8637263605f, -0.7743120191f, -0.6328039957f, +}; + +static const float GRADIENTS_3D[] = +{ + 0, 1, 1, 0, 0,-1, 1, 0, 0, 1,-1, 0, 0,-1,-1, 0, + 1, 0, 1, 0, -1, 0, 1, 0, 1, 0,-1, 0, -1, 0,-1, 0, + 1, 1, 0, 0, -1, 1, 0, 0, 1,-1, 0, 0, -1,-1, 0, 0, + 0, 1, 1, 0, 0,-1, 1, 0, 0, 1,-1, 0, 0,-1,-1, 0, + 1, 0, 1, 0, -1, 0, 1, 0, 1, 0,-1, 0, -1, 0,-1, 0, + 1, 1, 0, 0, -1, 1, 0, 0, 1,-1, 0, 0, -1,-1, 0, 0, + 0, 1, 1, 0, 0,-1, 1, 0, 0, 1,-1, 0, 0,-1,-1, 0, + 1, 0, 1, 0, -1, 0, 1, 0, 1, 0,-1, 0, -1, 0,-1, 0, + 1, 1, 0, 0, -1, 1, 0, 0, 1,-1, 0, 0, -1,-1, 0, 0, + 0, 1, 1, 0, 0,-1, 1, 0, 0, 1,-1, 0, 0,-1,-1, 0, + 1, 0, 1, 0, -1, 0, 1, 0, 1, 0,-1, 0, -1, 0,-1, 0, + 1, 1, 0, 0, -1, 1, 0, 0, 1,-1, 0, 0, -1,-1, 0, 0, + 0, 1, 1, 0, 0,-1, 1, 0, 0, 1,-1, 0, 0,-1,-1, 0, + 1, 0, 1, 0, -1, 0, 1, 0, 1, 0,-1, 0, -1, 0,-1, 0, + 1, 1, 0, 0, -1, 1, 0, 0, 1,-1, 0, 0, -1,-1, 0, 0, + 1, 1, 0, 0, 0,-1, 1, 0, -1, 1, 0, 0, 0,-1,-1, 0 +}; + +static const float RAND_VECS_3D[] = +{ + -0.7292736885f, -0.6618439697f, 0.1735581948f, 0, 0.790292081f, -0.5480887466f, -0.2739291014f, 0, 0.7217578935f, 0.6226212466f, -0.3023380997f, 0, 0.565683137f, -0.8208298145f, -0.0790000257f, 0, 0.760049034f, -0.5555979497f, -0.3370999617f, 0, 0.3713945616f, 0.5011264475f, 0.7816254623f, 0, -0.1277062463f, -0.4254438999f, -0.8959289049f, 0, -0.2881560924f, -0.5815838982f, 0.7607405838f, 0, + 0.5849561111f, -0.662820239f, -0.4674352136f, 0, 0.3307171178f, 0.0391653737f, 0.94291689f, 0, 0.8712121778f, -0.4113374369f, -0.2679381538f, 0, 0.580981015f, 0.7021915846f, 0.4115677815f, 0, 0.503756873f, 0.6330056931f, -0.5878203852f, 0, 0.4493712205f, 0.601390195f, 0.6606022552f, 0, -0.6878403724f, 0.09018890807f, -0.7202371714f, 0, -0.5958956522f, -0.6469350577f, 0.475797649f, 0, + -0.5127052122f, 0.1946921978f, -0.8361987284f, 0, -0.9911507142f, -0.05410276466f, -0.1212153153f, 0, -0.2149721042f, 0.9720882117f, -0.09397607749f, 0, -0.7518650936f, -0.5428057603f, 0.3742469607f, 0, 0.5237068895f, 0.8516377189f, -0.02107817834f, 0, 0.6333504779f, 0.1926167129f, -0.7495104896f, 0, -0.06788241606f, 0.3998305789f, 0.9140719259f, 0, -0.5538628599f, -0.4729896695f, -0.6852128902f, 0, + -0.7261455366f, -0.5911990757f, 0.3509933228f, 0, -0.9229274737f, -0.1782808786f, 0.3412049336f, 0, -0.6968815002f, 0.6511274338f, 0.3006480328f, 0, 0.9608044783f, -0.2098363234f, -0.1811724921f, 0, 0.06817146062f, -0.9743405129f, 0.2145069156f, 0, -0.3577285196f, -0.6697087264f, -0.6507845481f, 0, -0.1868621131f, 0.7648617052f, -0.6164974636f, 0, -0.6541697588f, 0.3967914832f, 0.6439087246f, 0, + 0.6993340405f, -0.6164538506f, 0.3618239211f, 0, -0.1546665739f, 0.6291283928f, 0.7617583057f, 0, -0.6841612949f, -0.2580482182f, -0.6821542638f, 0, 0.5383980957f, 0.4258654885f, 0.7271630328f, 0, -0.5026987823f, -0.7939832935f, -0.3418836993f, 0, 0.3202971715f, 0.2834415347f, 0.9039195862f, 0, 0.8683227101f, -0.0003762656404f, -0.4959995258f, 0, 0.791120031f, -0.08511045745f, 0.6057105799f, 0, + -0.04011016052f, -0.4397248749f, 0.8972364289f, 0, 0.9145119872f, 0.3579346169f, -0.1885487608f, 0, -0.9612039066f, -0.2756484276f, 0.01024666929f, 0, 0.6510361721f, -0.2877799159f, -0.7023778346f, 0, -0.2041786351f, 0.7365237271f, 0.644859585f, 0, -0.7718263711f, 0.3790626912f, 0.5104855816f, 0, -0.3060082741f, -0.7692987727f, 0.5608371729f, 0, 0.454007341f, -0.5024843065f, 0.7357899537f, 0, + 0.4816795475f, 0.6021208291f, -0.6367380315f, 0, 0.6961980369f, -0.3222197429f, 0.641469197f, 0, -0.6532160499f, -0.6781148932f, 0.3368515753f, 0, 0.5089301236f, -0.6154662304f, -0.6018234363f, 0, -0.1635919754f, -0.9133604627f, -0.372840892f, 0, 0.52408019f, -0.8437664109f, 0.1157505864f, 0, 0.5902587356f, 0.4983817807f, -0.6349883666f, 0, 0.5863227872f, 0.494764745f, 0.6414307729f, 0, + 0.6779335087f, 0.2341345225f, 0.6968408593f, 0, 0.7177054546f, -0.6858979348f, 0.120178631f, 0, -0.5328819713f, -0.5205125012f, 0.6671608058f, 0, -0.8654874251f, -0.0700727088f, -0.4960053754f, 0, -0.2861810166f, 0.7952089234f, 0.5345495242f, 0, -0.04849529634f, 0.9810836427f, -0.1874115585f, 0, -0.6358521667f, 0.6058348682f, 0.4781800233f, 0, 0.6254794696f, -0.2861619734f, 0.7258696564f, 0, + -0.2585259868f, 0.5061949264f, -0.8227581726f, 0, 0.02136306781f, 0.5064016808f, -0.8620330371f, 0, 0.200111773f, 0.8599263484f, 0.4695550591f, 0, 0.4743561372f, 0.6014985084f, -0.6427953014f, 0, 0.6622993731f, -0.5202474575f, -0.5391679918f, 0, 0.08084972818f, -0.6532720452f, 0.7527940996f, 0, -0.6893687501f, 0.0592860349f, 0.7219805347f, 0, -0.1121887082f, -0.9673185067f, 0.2273952515f, 0, + 0.7344116094f, 0.5979668656f, -0.3210532909f, 0, 0.5789393465f, -0.2488849713f, 0.7764570201f, 0, 0.6988182827f, 0.3557169806f, -0.6205791146f, 0, -0.8636845529f, -0.2748771249f, -0.4224826141f, 0, -0.4247027957f, -0.4640880967f, 0.777335046f, 0, 0.5257722489f, -0.8427017621f, 0.1158329937f, 0, 0.9343830603f, 0.316302472f, -0.1639543925f, 0, -0.1016836419f, -0.8057303073f, -0.5834887393f, 0, + -0.6529238969f, 0.50602126f, -0.5635892736f, 0, -0.2465286165f, -0.9668205684f, -0.06694497494f, 0, -0.9776897119f, -0.2099250524f, -0.007368825344f, 0, 0.7736893337f, 0.5734244712f, 0.2694238123f, 0, -0.6095087895f, 0.4995678998f, 0.6155736747f, 0, 0.5794535482f, 0.7434546771f, 0.3339292269f, 0, -0.8226211154f, 0.08142581855f, 0.5627293636f, 0, -0.510385483f, 0.4703667658f, 0.7199039967f, 0, + -0.5764971849f, -0.07231656274f, -0.8138926898f, 0, 0.7250628871f, 0.3949971505f, -0.5641463116f, 0, -0.1525424005f, 0.4860840828f, -0.8604958341f, 0, -0.5550976208f, -0.4957820792f, 0.667882296f, 0, -0.1883614327f, 0.9145869398f, 0.357841725f, 0, 0.7625556724f, -0.5414408243f, -0.3540489801f, 0, -0.5870231946f, -0.3226498013f, -0.7424963803f, 0, 0.3051124198f, 0.2262544068f, -0.9250488391f, 0, + 0.6379576059f, 0.577242424f, -0.5097070502f, 0, -0.5966775796f, 0.1454852398f, -0.7891830656f, 0, -0.658330573f, 0.6555487542f, -0.3699414651f, 0, 0.7434892426f, 0.2351084581f, 0.6260573129f, 0, 0.5562114096f, 0.8264360377f, -0.0873632843f, 0, -0.3028940016f, -0.8251527185f, 0.4768419182f, 0, 0.1129343818f, -0.985888439f, -0.1235710781f, 0, 0.5937652891f, -0.5896813806f, 0.5474656618f, 0, + 0.6757964092f, -0.5835758614f, -0.4502648413f, 0, 0.7242302609f, -0.1152719764f, 0.6798550586f, 0, -0.9511914166f, 0.0753623979f, -0.2992580792f, 0, 0.2539470961f, -0.1886339355f, 0.9486454084f, 0, 0.571433621f, -0.1679450851f, -0.8032795685f, 0, -0.06778234979f, 0.3978269256f, 0.9149531629f, 0, 0.6074972649f, 0.733060024f, -0.3058922593f, 0, -0.5435478392f, 0.1675822484f, 0.8224791405f, 0, + -0.5876678086f, -0.3380045064f, -0.7351186982f, 0, -0.7967562402f, 0.04097822706f, -0.6029098428f, 0, -0.1996350917f, 0.8706294745f, 0.4496111079f, 0, -0.02787660336f, -0.9106232682f, -0.4122962022f, 0, -0.7797625996f, -0.6257634692f, 0.01975775581f, 0, -0.5211232846f, 0.7401644346f, -0.4249554471f, 0, 0.8575424857f, 0.4053272873f, -0.3167501783f, 0, 0.1045223322f, 0.8390195772f, -0.5339674439f, 0, + 0.3501822831f, 0.9242524096f, -0.1520850155f, 0, 0.1987849858f, 0.07647613266f, 0.9770547224f, 0, 0.7845996363f, 0.6066256811f, -0.1280964233f, 0, 0.09006737436f, -0.9750989929f, -0.2026569073f, 0, -0.8274343547f, -0.542299559f, 0.1458203587f, 0, -0.3485797732f, -0.415802277f, 0.840000362f, 0, -0.2471778936f, -0.7304819962f, -0.6366310879f, 0, -0.3700154943f, 0.8577948156f, 0.3567584454f, 0, + 0.5913394901f, -0.548311967f, -0.5913303597f, 0, 0.1204873514f, -0.7626472379f, -0.6354935001f, 0, 0.616959265f, 0.03079647928f, 0.7863922953f, 0, 0.1258156836f, -0.6640829889f, -0.7369967419f, 0, -0.6477565124f, -0.1740147258f, -0.7417077429f, 0, 0.6217889313f, -0.7804430448f, -0.06547655076f, 0, 0.6589943422f, -0.6096987708f, 0.4404473475f, 0, -0.2689837504f, -0.6732403169f, -0.6887635427f, 0, + -0.3849775103f, 0.5676542638f, 0.7277093879f, 0, 0.5754444408f, 0.8110471154f, -0.1051963504f, 0, 0.9141593684f, 0.3832947817f, 0.131900567f, 0, -0.107925319f, 0.9245493968f, 0.3654593525f, 0, 0.377977089f, 0.3043148782f, 0.8743716458f, 0, -0.2142885215f, -0.8259286236f, 0.5214617324f, 0, 0.5802544474f, 0.4148098596f, -0.7008834116f, 0, -0.1982660881f, 0.8567161266f, -0.4761596756f, 0, + -0.03381553704f, 0.3773180787f, -0.9254661404f, 0, -0.6867922841f, -0.6656597827f, 0.2919133642f, 0, 0.7731742607f, -0.2875793547f, -0.5652430251f, 0, -0.09655941928f, 0.9193708367f, -0.3813575004f, 0, 0.2715702457f, -0.9577909544f, -0.09426605581f, 0, 0.2451015704f, -0.6917998565f, -0.6792188003f, 0, 0.977700782f, -0.1753855374f, 0.1155036542f, 0, -0.5224739938f, 0.8521606816f, 0.02903615945f, 0, + -0.7734880599f, -0.5261292347f, 0.3534179531f, 0, -0.7134492443f, -0.269547243f, 0.6467878011f, 0, 0.1644037271f, 0.5105846203f, -0.8439637196f, 0, 0.6494635788f, 0.05585611296f, 0.7583384168f, 0, -0.4711970882f, 0.5017280509f, -0.7254255765f, 0, -0.6335764307f, -0.2381686273f, -0.7361091029f, 0, -0.9021533097f, -0.270947803f, -0.3357181763f, 0, -0.3793711033f, 0.872258117f, 0.3086152025f, 0, + -0.6855598966f, -0.3250143309f, 0.6514394162f, 0, 0.2900942212f, -0.7799057743f, -0.5546100667f, 0, -0.2098319339f, 0.85037073f, 0.4825351604f, 0, -0.4592603758f, 0.6598504336f, -0.5947077538f, 0, 0.8715945488f, 0.09616365406f, -0.4807031248f, 0, -0.6776666319f, 0.7118504878f, -0.1844907016f, 0, 0.7044377633f, 0.312427597f, 0.637304036f, 0, -0.7052318886f, -0.2401093292f, -0.6670798253f, 0, + 0.081921007f, -0.7207336136f, -0.6883545647f, 0, -0.6993680906f, -0.5875763221f, -0.4069869034f, 0, -0.1281454481f, 0.6419895885f, 0.7559286424f, 0, -0.6337388239f, -0.6785471501f, -0.3714146849f, 0, 0.5565051903f, -0.2168887573f, -0.8020356851f, 0, -0.5791554484f, 0.7244372011f, -0.3738578718f, 0, 0.1175779076f, -0.7096451073f, 0.6946792478f, 0, -0.6134619607f, 0.1323631078f, 0.7785527795f, 0, + 0.6984635305f, -0.02980516237f, -0.715024719f, 0, 0.8318082963f, -0.3930171956f, 0.3919597455f, 0, 0.1469576422f, 0.05541651717f, -0.9875892167f, 0, 0.708868575f, -0.2690503865f, 0.6520101478f, 0, 0.2726053183f, 0.67369766f, -0.68688995f, 0, -0.6591295371f, 0.3035458599f, -0.6880466294f, 0, 0.4815131379f, -0.7528270071f, 0.4487723203f, 0, 0.9430009463f, 0.1675647412f, -0.2875261255f, 0, + 0.434802957f, 0.7695304522f, -0.4677277752f, 0, 0.3931996188f, 0.594473625f, 0.7014236729f, 0, 0.7254336655f, -0.603925654f, 0.3301814672f, 0, 0.7590235227f, -0.6506083235f, 0.02433313207f, 0, -0.8552768592f, -0.3430042733f, 0.3883935666f, 0, -0.6139746835f, 0.6981725247f, 0.3682257648f, 0, -0.7465905486f, -0.5752009504f, 0.3342849376f, 0, 0.5730065677f, 0.810555537f, -0.1210916791f, 0, + -0.9225877367f, -0.3475211012f, -0.167514036f, 0, -0.7105816789f, -0.4719692027f, -0.5218416899f, 0, -0.08564609717f, 0.3583001386f, 0.929669703f, 0, -0.8279697606f, -0.2043157126f, 0.5222271202f, 0, 0.427944023f, 0.278165994f, 0.8599346446f, 0, 0.5399079671f, -0.7857120652f, -0.3019204161f, 0, 0.5678404253f, -0.5495413974f, -0.6128307303f, 0, -0.9896071041f, 0.1365639107f, -0.04503418428f, 0, + -0.6154342638f, -0.6440875597f, 0.4543037336f, 0, 0.1074204368f, -0.7946340692f, 0.5975094525f, 0, -0.3595449969f, -0.8885529948f, 0.28495784f, 0, -0.2180405296f, 0.1529888965f, 0.9638738118f, 0, -0.7277432317f, -0.6164050508f, -0.3007234646f, 0, 0.7249729114f, -0.00669719484f, 0.6887448187f, 0, -0.5553659455f, -0.5336586252f, 0.6377908264f, 0, 0.5137558015f, 0.7976208196f, -0.3160000073f, 0, + -0.3794024848f, 0.9245608561f, -0.03522751494f, 0, 0.8229248658f, 0.2745365933f, -0.4974176556f, 0, -0.5404114394f, 0.6091141441f, 0.5804613989f, 0, 0.8036581901f, -0.2703029469f, 0.5301601931f, 0, 0.6044318879f, 0.6832968393f, 0.4095943388f, 0, 0.06389988817f, 0.9658208605f, -0.2512108074f, 0, 0.1087113286f, 0.7402471173f, -0.6634877936f, 0, -0.713427712f, -0.6926784018f, 0.1059128479f, 0, + 0.6458897819f, -0.5724548511f, -0.5050958653f, 0, -0.6553931414f, 0.7381471625f, 0.159995615f, 0, 0.3910961323f, 0.9188871375f, -0.05186755998f, 0, -0.4879022471f, -0.5904376907f, 0.6429111375f, 0, 0.6014790094f, 0.7707441366f, -0.2101820095f, 0, -0.5677173047f, 0.7511360995f, 0.3368851762f, 0, 0.7858573506f, 0.226674665f, 0.5753666838f, 0, -0.4520345543f, -0.604222686f, -0.6561857263f, 0, + 0.002272116345f, 0.4132844051f, -0.9105991643f, 0, -0.5815751419f, -0.5162925989f, 0.6286591339f, 0, -0.03703704785f, 0.8273785755f, 0.5604221175f, 0, -0.5119692504f, 0.7953543429f, -0.3244980058f, 0, -0.2682417366f, -0.9572290247f, -0.1084387619f, 0, -0.2322482736f, -0.9679131102f, -0.09594243324f, 0, 0.3554328906f, -0.8881505545f, 0.2913006227f, 0, 0.7346520519f, -0.4371373164f, 0.5188422971f, 0, + 0.9985120116f, 0.04659011161f, -0.02833944577f, 0, -0.3727687496f, -0.9082481361f, 0.1900757285f, 0, 0.91737377f, -0.3483642108f, 0.1925298489f, 0, 0.2714911074f, 0.4147529736f, -0.8684886582f, 0, 0.5131763485f, -0.7116334161f, 0.4798207128f, 0, -0.8737353606f, 0.18886992f, -0.4482350644f, 0, 0.8460043821f, -0.3725217914f, 0.3814499973f, 0, 0.8978727456f, -0.1780209141f, -0.4026575304f, 0, + 0.2178065647f, -0.9698322841f, -0.1094789531f, 0, -0.1518031304f, -0.7788918132f, -0.6085091231f, 0, -0.2600384876f, -0.4755398075f, -0.8403819825f, 0, 0.572313509f, -0.7474340931f, -0.3373418503f, 0, -0.7174141009f, 0.1699017182f, -0.6756111411f, 0, -0.684180784f, 0.02145707593f, -0.7289967412f, 0, -0.2007447902f, 0.06555605789f, -0.9774476623f, 0, -0.1148803697f, -0.8044887315f, 0.5827524187f, 0, + -0.7870349638f, 0.03447489231f, 0.6159443543f, 0, -0.2015596421f, 0.6859872284f, 0.6991389226f, 0, -0.08581082512f, -0.10920836f, -0.9903080513f, 0, 0.5532693395f, 0.7325250401f, -0.396610771f, 0, -0.1842489331f, -0.9777375055f, -0.1004076743f, 0, 0.0775473789f, -0.9111505856f, 0.4047110257f, 0, 0.1399838409f, 0.7601631212f, -0.6344734459f, 0, 0.4484419361f, -0.845289248f, 0.2904925424f, 0 +}; + +// Utilities + +static inline float _fnlFastMin(float x, float y) { return x < y ? x : y; } + +static inline float _fnlFastMax(float x, float y) { return x > y ? x : y; } + +static inline float _fnlFastAbs(float f) { return f < 0 ? -f : f; } + +static inline float _fnlCasti32Tof32(int i) +{ + union + { + float f; + int32_t i; + } u; + u.i = i; + return u.f; +} + +static inline int _fnlCastf32Toi32(float f) +{ + union + { + float f; + int32_t i; + } u; + u.f = f; + return u.i; +} + +static inline float _fnlInvSqrt(float a) +{ + float xhalf = 0.5f * a; + a = _fnlCasti32Tof32(0x5f3759df - (_fnlCastf32Toi32(a) >> 1)); + a = a * (1.5f - xhalf * a * a); + return a; +} + +// NOTE: If your language does not support this method (seen above), then simply use the native sqrt function. +static inline float _fnlFastSqrt(float a) { return a * _fnlInvSqrt(a); } + +static inline int _fnlFastFloor(FNLfloat f) { return (f >= 0 ? (int)f : (int)f - 1); } + +static inline int _fnlFastRound(FNLfloat f) { return (f >= 0) ? (int)(f + 0.5f) : (int)(f - 0.5f); } + +static inline float _fnlLerp(float a, float b, float t) { return a + t * (b - a); } + +static inline float _fnlInterpHermite(float t) { return t * t * (3 - 2 * t); } + +static inline float _fnlInterpQuintic(float t) { return t * t * t * (t * (t * 6 - 15) + 10); } + +static inline float _fnlCubicLerp(float a, float b, float c, float d, float t) +{ + float p = (d - c) - (a - b); + return t * t * t * p + t * t * ((a - b) - p) + t * (c - a) + b; +} + +static inline float _fnlPingPong(float t) +{ + t -= (int)(t * 0.5f) * 2; + return t < 1 ? t : 2 - t; +} + +static float _fnlCalculateFractalBounding(const fnl_state *state) +{ + float gain = _fnlFastAbs(state->gain); + float amp = gain; + float ampFractal = 1.0f; + for (int i = 1; i < state->octaves; i++) + { + ampFractal += amp; + amp *= gain; + } + return 1.0f / ampFractal; +} + +// Hashing + +static const int PRIME_X = 501125321; +static const int PRIME_Y = 1136930381; +static const int PRIME_Z = 1720413743; + +static inline int _fnlHash2D(int seed, int xPrimed, int yPrimed) +{ + int hash = seed ^ xPrimed ^ yPrimed; + + hash *= 0x27d4eb2d; + return hash; +} + +static inline int _fnlHash3D(int seed, int xPrimed, int yPrimed, int zPrimed) +{ + int hash = seed ^ xPrimed ^ yPrimed ^ zPrimed; + + hash *= 0x27d4eb2d; + return hash; +} + +static inline float _fnlValCoord2D(int seed, int xPrimed, int yPrimed) +{ + int hash = _fnlHash2D(seed, xPrimed, yPrimed); + hash *= hash; + hash ^= hash << 19; + return hash * (1 / 2147483648.0f); +} + +static inline float _fnlValCoord3D(int seed, int xPrimed, int yPrimed, int zPrimed) +{ + int hash = _fnlHash3D(seed, xPrimed, yPrimed, zPrimed); + hash *= hash; + hash ^= hash << 19; + return hash * (1 / 2147483648.0f); +} + +static inline float _fnlGradCoord2D(int seed, int xPrimed, int yPrimed, float xd, float yd) +{ + int hash = _fnlHash2D(seed, xPrimed, yPrimed); + hash ^= hash >> 15; + hash &= 127 << 1; + return xd * GRADIENTS_2D[hash] + yd * GRADIENTS_2D[hash | 1]; +} + +static inline float _fnlGradCoord3D(int seed, int xPrimed, int yPrimed, int zPrimed, float xd, float yd, float zd) +{ + int hash = _fnlHash3D(seed, xPrimed, yPrimed, zPrimed); + hash ^= hash >> 15; + hash &= 63 << 2; + return xd * GRADIENTS_3D[hash] + yd * GRADIENTS_3D[hash | 1] + zd * GRADIENTS_3D[hash | 2]; +} + +static inline void _fnlGradCoordOut2D(int seed, int xPrimed, int yPrimed, float *xo, float *yo) +{ + int hash = _fnlHash2D(seed, xPrimed, yPrimed) & (255 << 1); + + *xo = RAND_VECS_2D[hash]; + *yo = RAND_VECS_2D[hash | 1]; +} + +static inline void _fnlGradCoordOut3D(int seed, int xPrimed, int yPrimed, int zPrimed, float *xo, float *yo, float *zo) +{ + int hash = _fnlHash3D(seed, xPrimed, yPrimed, zPrimed) & (255 << 2); + + *xo = RAND_VECS_3D[hash]; + *yo = RAND_VECS_3D[hash | 1]; + *zo = RAND_VECS_3D[hash | 2]; +} + +static inline void _fnlGradCoordDual2D(int seed, int xPrimed, int yPrimed, float xd, float yd, float *xo, float *yo) +{ + int hash = _fnlHash2D(seed, xPrimed, yPrimed); + int index1 = hash & (127 << 1); + int index2 = (hash >> 7) & (255 << 1); + + float xg = GRADIENTS_2D[index1]; + float yg = GRADIENTS_2D[index1 | 1]; + float value = xd * xg + yd * yg; + + float xgo = RAND_VECS_2D[index2]; + float ygo = RAND_VECS_2D[index2 | 1]; + + *xo = value * xgo; + *yo = value * ygo; +} + +static inline void _fnlGradCoordDual3D(int seed, int xPrimed, int yPrimed, int zPrimed, float xd, float yd, float zd, float *xo, float *yo, float *zo) +{ + int hash = _fnlHash3D(seed, xPrimed, yPrimed, zPrimed); + int index1 = hash & (63 << 2); + int index2 = (hash >> 6) & (255 << 2); + + float xg = GRADIENTS_3D[index1]; + float yg = GRADIENTS_3D[index1 | 1]; + float zg = GRADIENTS_3D[index1 | 2]; + float value = xd * xg + yd * yg + zd * zg; + + float xgo = RAND_VECS_3D[index2]; + float ygo = RAND_VECS_3D[index2 | 1]; + float zgo = RAND_VECS_3D[index2 | 2]; + + *xo = value * xgo; + *yo = value * ygo; + *zo = value * zgo; +} + +// Generic Noise Gen + +static float _fnlSingleSimplex2D(int seed, FNLfloat x, FNLfloat y); +static float _fnlSingleOpenSimplex23D(int seed, FNLfloat x, FNLfloat y, FNLfloat z); +static float _fnlSingleOpenSimplex2S2D(int seed, FNLfloat x, FNLfloat y); +static float _fnlSingleOpenSimplex2S3D(int seed, FNLfloat x, FNLfloat y, FNLfloat z); +static float _fnlSingleCellular2D(const fnl_state *state, int seed, FNLfloat x, FNLfloat y); +static float _fnlSingleCellular3D(const fnl_state *state, int seed, FNLfloat x, FNLfloat y, FNLfloat z); +static float _fnlSinglePerlin2D(int seed, FNLfloat x, FNLfloat y); +static float _fnlSinglePerlin3D(int seed, FNLfloat x, FNLfloat y, FNLfloat z); +static float _fnlSingleValueCubic2D(int seed, FNLfloat x, FNLfloat y); +static float _fnlSingleValueCubic3D(int seed, FNLfloat x, FNLfloat y, FNLfloat z); +static float _fnlSingleValue2D(int seed, FNLfloat x, FNLfloat y); +static float _fnlSingleValue3D(int seed, FNLfloat x, FNLfloat y, FNLfloat z); + +static float _fnlGenNoiseSingle2D(const fnl_state *state, int seed, FNLfloat x, FNLfloat y) +{ + switch (state->noise_type) + { + case FNL_NOISE_OPENSIMPLEX2: + return _fnlSingleSimplex2D(seed, x, y); + case FNL_NOISE_OPENSIMPLEX2S: + return _fnlSingleOpenSimplex2S2D(seed, x, y); + case FNL_NOISE_CELLULAR: + return _fnlSingleCellular2D(state, seed, x, y); + case FNL_NOISE_PERLIN: + return _fnlSinglePerlin2D(seed, x, y); + case FNL_NOISE_VALUE_CUBIC: + return _fnlSingleValueCubic2D(seed, x, y); + case FNL_NOISE_VALUE: + return _fnlSingleValue2D(seed, x, y); + default: + return 0; + } +} + +static float _fnlGenNoiseSingle3D(const fnl_state *state, int seed, FNLfloat x, FNLfloat y, FNLfloat z) +{ + switch (state->noise_type) + { + case FNL_NOISE_OPENSIMPLEX2: + return _fnlSingleOpenSimplex23D(seed, x, y, z); + case FNL_NOISE_OPENSIMPLEX2S: + return _fnlSingleOpenSimplex2S3D(seed, x, y, z); + case FNL_NOISE_CELLULAR: + return _fnlSingleCellular3D(state, seed, x, y, z); + case FNL_NOISE_PERLIN: + return _fnlSinglePerlin3D(seed, x, y, z); + case FNL_NOISE_VALUE_CUBIC: + return _fnlSingleValueCubic3D(seed, x, y, z); + case FNL_NOISE_VALUE: + return _fnlSingleValue3D(seed, x, y, z); + default: + return 0; + } +} + +// Noise Coordinate Transforms (frequency, and possible skew or rotation) + +static void _fnlTransformNoiseCoordinate2D(const fnl_state *state, FNLfloat *x, FNLfloat *y) +{ + *x *= state->frequency; + *y *= state->frequency; + + switch (state->noise_type) + { + case FNL_NOISE_OPENSIMPLEX2: + case FNL_NOISE_OPENSIMPLEX2S: + { + const FNLfloat SQRT3 = (FNLfloat)1.7320508075688772935274463415059; + const FNLfloat F2 = 0.5f * (SQRT3 - 1); + FNLfloat t = (*x + *y) * F2; + *x += t; + *y += t; + } + break; + default: + break; + } +} + +static void _fnlTransformNoiseCoordinate3D(const fnl_state *state, FNLfloat *x, FNLfloat *y, FNLfloat *z) +{ + *x *= state->frequency; + *y *= state->frequency; + *z *= state->frequency; + + switch (state->rotation_type_3d) + { + case FNL_ROTATION_IMPROVE_XY_PLANES: + { + FNLfloat xy = *x + *y; + FNLfloat s2 = xy * -(FNLfloat)0.211324865405187; + *z *= (FNLfloat)0.577350269189626; + *x += s2 - *z; + *y = *y + s2 - *z; + *z += xy * (FNLfloat)0.577350269189626; + } + break; + case FNL_ROTATION_IMPROVE_XZ_PLANES: + { + FNLfloat xz = *x + *z; + FNLfloat s2 = xz * -(FNLfloat)0.211324865405187; + *y *= (FNLfloat)0.577350269189626; + *x += s2 - *y; + *z += s2 - *y; + *y += xz * (FNLfloat)0.577350269189626; + } + break; + default: + switch (state->noise_type) + { + case FNL_NOISE_OPENSIMPLEX2: + case FNL_NOISE_OPENSIMPLEX2S: + { + const FNLfloat R3 = (FNLfloat)(2.0 / 3.0); + FNLfloat r = (*x + *y + *z) * R3; // Rotation, not skew + *x = r - *x; + *y = r - *y; + *z = r - *z; + } + break; + default: + break; + } + } +} + +// Domain Warp Coordinate Transforms + +static void _fnlTransformDomainWarpCoordinate2D(const fnl_state *state, FNLfloat *x, FNLfloat *y) +{ + switch (state->domain_warp_type) + { + case FNL_DOMAIN_WARP_OPENSIMPLEX2: + case FNL_DOMAIN_WARP_OPENSIMPLEX2_REDUCED: + { + const FNLfloat SQRT3 = (FNLfloat)1.7320508075688772935274463415059; + const FNLfloat F2 = 0.5f * (SQRT3 - 1); + FNLfloat t = (*x + *y) * F2; + *x += t; + *y += t; + } + break; + default: + break; + } +} + +static void _fnlTransformDomainWarpCoordinate3D(const fnl_state *state, FNLfloat *x, FNLfloat *y, FNLfloat *z) +{ + switch (state->rotation_type_3d) + { + case FNL_ROTATION_IMPROVE_XY_PLANES: + { + FNLfloat xy = *x + *y; + FNLfloat s2 = xy * -(FNLfloat)0.211324865405187; + *z *= (FNLfloat)0.577350269189626; + *x += s2 - *z; + *y = *y + s2 - *z; + *z += xy * (FNLfloat)0.577350269189626; + } + break; + case FNL_ROTATION_IMPROVE_XZ_PLANES: + { + FNLfloat xz = *x + *z; + FNLfloat s2 = xz * -(FNLfloat)0.211324865405187; + *y *= (FNLfloat)0.577350269189626; + *x += s2 - *y; + *z += s2 - *y; + *y += xz * (FNLfloat)0.577350269189626; + } + break; + default: + switch (state->domain_warp_type) + { + case FNL_DOMAIN_WARP_OPENSIMPLEX2: + case FNL_DOMAIN_WARP_OPENSIMPLEX2_REDUCED: + { + const FNLfloat R3 = (FNLfloat)(2.0 / 3.0); + FNLfloat r = (*x + *y + *z) * R3; // Rotation, not skew + *x = r - *x; + *y = r - *y; + *z = r - *z; + } + break; + default: + break; + } + } +} + +// Fractal FBm +static float _fnlGenFractalFBM2D(const fnl_state *state, FNLfloat x, FNLfloat y) +{ + int seed = state->seed; + float sum = 0; + float amp = _fnlCalculateFractalBounding(state); + + for (int i = 0; i < state->octaves; i++) + { + float noise = _fnlGenNoiseSingle2D(state, seed++, x, y); + sum += noise * amp; + amp *= _fnlLerp(1.0f, _fnlFastMin(noise + 1, 2) * 0.5f, state->weighted_strength); + + x *= state->lacunarity; + y *= state->lacunarity; + amp *= state->gain; + } + + return sum; +} + +static float _fnlGenFractalFBM3D(const fnl_state *state, FNLfloat x, FNLfloat y, FNLfloat z) +{ + int seed = state->seed; + float sum = 0; + float amp = _fnlCalculateFractalBounding(state); + + for (int i = 0; i < state->octaves; i++) + { + float noise = _fnlGenNoiseSingle3D(state, seed++, x, y, z); + sum += noise * amp; + amp *= _fnlLerp(1.0f, (noise + 1) * 0.5f, state->weighted_strength); + + x *= state->lacunarity; + y *= state->lacunarity; + z *= state->lacunarity; + amp *= state->gain; + } + + return sum; +} + +// Fractal Ridged + +static float _fnlGenFractalRidged2D(const fnl_state *state, FNLfloat x, FNLfloat y) +{ + int seed = state->seed; + float sum = 0; + float amp = _fnlCalculateFractalBounding(state); + + for (int i = 0; i < state->octaves; i++) + { + float noise = _fnlFastAbs(_fnlGenNoiseSingle2D(state, seed++, x, y)); + sum += (noise * -2 + 1) * amp; + amp *= _fnlLerp(1.0f, 1 - noise, state->weighted_strength); + + x *= state->lacunarity; + y *= state->lacunarity; + amp *= state->gain; + } + + return sum; +} + +static float _fnlGenFractalRidged3D(const fnl_state *state, FNLfloat x, FNLfloat y, FNLfloat z) +{ + int seed = state->seed; + float sum = 0; + float amp = _fnlCalculateFractalBounding(state); + + for (int i = 0; i < state->octaves; i++) + { + float noise = _fnlFastAbs(_fnlGenNoiseSingle3D(state, seed++, x, y, z)); + sum += (noise * -2 + 1) * amp; + amp *= _fnlLerp(1.0f, 1 - noise, state->weighted_strength); + + x *= state->lacunarity; + y *= state->lacunarity; + z *= state->lacunarity; + amp *= state->gain; + } + + return sum; +} + +// Fractal PingPong + +static float _fnlGenFractalPingPong2D(const fnl_state *state, FNLfloat x, FNLfloat y) +{ + int seed = state->seed; + float sum = 0; + float amp = _fnlCalculateFractalBounding(state); + + for (int i = 0; i < state->octaves; i++) + { + float noise = _fnlPingPong((_fnlGenNoiseSingle2D(state, seed++, x, y) + 1) * state->ping_pong_strength); + sum += (noise - 0.5f) * 2 * amp; + amp *= _fnlLerp(1.0f, noise, state->weighted_strength); + + x *= state->lacunarity; + y *= state->lacunarity; + amp *= state->gain; + } + + return sum; +} + +static float _fnlGenFractalPingPong3D(const fnl_state *state, FNLfloat x, FNLfloat y, FNLfloat z) +{ + int seed = state->seed; + float sum = 0; + float amp = _fnlCalculateFractalBounding(state); + + for (int i = 0; i < state->octaves; i++) + { + float noise = _fnlPingPong((_fnlGenNoiseSingle3D(state, seed++, x, y, z) + 1) * state->ping_pong_strength); + sum += (noise - 0.5f) * 2 * amp; + amp *= _fnlLerp(1.0f, noise, state->weighted_strength); + + x *= state->lacunarity; + y *= state->lacunarity; + z *= state->lacunarity; + amp *= state->gain; + } + + return sum; +} + +// Simplex/OpenSimplex2 Noise + +static float _fnlSingleSimplex2D(int seed, FNLfloat x, FNLfloat y) +{ + // 2D OpenSimplex2 case uses the same algorithm as ordinary Simplex. + + const float SQRT3 = 1.7320508075688772935274463415059f; + const float G2 = (3 - SQRT3) / 6; + + /* + * --- Skew moved to TransformNoiseCoordinate method --- + * const FNLfloat F2 = 0.5f * (SQRT3 - 1); + * FNLfloat s = (x + y) * F2; + * x += s; y += s; + */ + + int i = _fnlFastFloor(x); + int j = _fnlFastFloor(y); + float xi = (float)(x - i); + float yi = (float)(y - j); + + float t = (xi + yi) * G2; + float x0 = (float)(xi - t); + float y0 = (float)(yi - t); + + i *= PRIME_X; + j *= PRIME_Y; + + float n0, n1, n2; + + float a = 0.5f - x0 * x0 - y0 * y0; + if (a <= 0) + n0 = 0; + else + { + n0 = (a * a) * (a * a) * _fnlGradCoord2D(seed, i, j, x0, y0); + } + + float c = (float)(2 * (1 - 2 * G2) * (1 / G2 - 2)) * t + ((float)(-2 * (1 - 2 * G2) * (1 - 2 * G2)) + a); + if (c <= 0) + n2 = 0; + else + { + float x2 = x0 + (2 * (float)G2 - 1); + float y2 = y0 + (2 * (float)G2 - 1); + n2 = (c * c) * (c * c) * _fnlGradCoord2D(seed, i + PRIME_X, j + PRIME_Y, x2, y2); + } + + if (y0 > x0) + { + float x1 = x0 + (float)G2; + float y1 = y0 + ((float)G2 - 1); + float b = 0.5f - x1 * x1 - y1 * y1; + if (b <= 0) + n1 = 0; + else + { + n1 = (b * b) * (b * b) * _fnlGradCoord2D(seed, i, j + PRIME_Y, x1, y1); + } + } + else + { + float x1 = x0 + ((float)G2 - 1); + float y1 = y0 + (float)G2; + float b = 0.5f - x1 * x1 - y1 * y1; + if (b <= 0) + n1 = 0; + else + { + n1 = (b * b) * (b * b) * _fnlGradCoord2D(seed, i + PRIME_X, j, x1, y1); + } + } + + return (n0 + n1 + n2) * 99.83685446303647f; +} + +static float _fnlSingleOpenSimplex23D(int seed, FNLfloat x, FNLfloat y, FNLfloat z) +{ + // 3D OpenSimplex2 case uses two offset rotated cube grids. + + /* + * --- Rotation moved to TransformNoiseCoordinate method --- + * const FNLfloat R3 = (FNLfloat)(2.0 / 3.0); + * FNLfloat r = (x + y + z) * R3; // Rotation, not skew + * x = r - x; y = r - y; z = r - z; + */ + + int i = _fnlFastRound(x); + int j = _fnlFastRound(y); + int k = _fnlFastRound(z); + float x0 = (float)(x - i); + float y0 = (float)(y - j); + float z0 = (float)(z - k); + + int xNSign = (int)(-1.0f - x0) | 1; + int yNSign = (int)(-1.0f - y0) | 1; + int zNSign = (int)(-1.0f - z0) | 1; + + float ax0 = xNSign * -x0; + float ay0 = yNSign * -y0; + float az0 = zNSign * -z0; + + i *= PRIME_X; + j *= PRIME_Y; + k *= PRIME_Z; + + float value = 0; + float a = (0.6f - x0 * x0) - (y0 * y0 + z0 * z0); + + for (int l = 0; ; l++) + { + if (a > 0) + { + value += (a * a) * (a * a) * _fnlGradCoord3D(seed, i, j, k, x0, y0, z0); + } + + float b = a + 1; + int i1 = i; + int j1 = j; + int k1 = k; + float x1 = x0; + float y1 = y0; + float z1 = z0; + if (ax0 >= ay0 && ax0 >= az0) + { + x1 += xNSign; + b -= xNSign * 2 * x1; + i1 -= xNSign * PRIME_X; + } + else if (ay0 > ax0 && ay0 >= az0) + { + y1 += yNSign; + b -= yNSign * 2 * y1; + j1 -= yNSign * PRIME_Y; + } + else + { + z1 += zNSign; + b -= zNSign * 2 * z1; + k1 -= zNSign * PRIME_Z; + } + + if (b > 0) + { + value += (b * b) * (b * b) * _fnlGradCoord3D(seed, i1, j1, k1, x1, y1, z1); + } + + if (l == 1) + break; + + ax0 = 0.5f - ax0; + ay0 = 0.5f - ay0; + az0 = 0.5f - az0; + + x0 = xNSign * ax0; + y0 = yNSign * ay0; + z0 = zNSign * az0; + + a += (0.75f - ax0) - (ay0 + az0); + + i += (xNSign >> 1) & PRIME_X; + j += (yNSign >> 1) & PRIME_Y; + k += (zNSign >> 1) & PRIME_Z; + + xNSign = -xNSign; + yNSign = -yNSign; + zNSign = -zNSign; + + seed = ~seed; + } + + return value * 32.69428253173828125f; +} + +// OpenSimplex2S Noise + +static float _fnlSingleOpenSimplex2S2D(int seed, FNLfloat x, FNLfloat y) +{ + // 2D OpenSimplex2S case is a modified 2D simplex noise. + + const FNLfloat SQRT3 = (FNLfloat)1.7320508075688772935274463415059; + const FNLfloat G2 = (3 - SQRT3) / 6; + + /* + * --- Skew moved to TransformNoiseCoordinate method --- + * const FNLfloat F2 = 0.5f * (SQRT3 - 1); + * FNLfloat s = (x + y) * F2; + * x += s; y += s; + */ + + int i = _fnlFastFloor(x); + int j = _fnlFastFloor(y); + float xi = (float)(x - i); + float yi = (float)(y - j); + + i *= PRIME_X; + j *= PRIME_Y; + int i1 = i + PRIME_X; + int j1 = j + PRIME_Y; + + float t = (xi + yi) * (float)G2; + float x0 = xi - t; + float y0 = yi - t; + + float a0 = (2.0f / 3.0f) - x0 * x0 - y0 * y0; + float value = (a0 * a0) * (a0 * a0) * _fnlGradCoord2D(seed, i, j, x0, y0); + + float a1 = (float)(2 * (1 - 2 * G2) * (1 / G2 - 2)) * t + ((float)(-2 * (1 - 2 * G2) * (1 - 2 * G2)) + a0); + float x1 = x0 - (float)(1 - 2 * G2); + float y1 = y0 - (float)(1 - 2 * G2); + value += (a1 * a1) * (a1 * a1) * _fnlGradCoord2D(seed, i1, j1, x1, y1); + + // Nested conditionals were faster than compact bit logic/arithmetic. + float xmyi = xi - yi; + if (t > G2) + { + if (xi + xmyi > 1) + { + float x2 = x0 + (float)(3 * G2 - 2); + float y2 = y0 + (float)(3 * G2 - 1); + float a2 = (2.0f / 3.0f) - x2 * x2 - y2 * y2; + if (a2 > 0) + { + value += (a2 * a2) * (a2 * a2) * _fnlGradCoord2D(seed, i + (PRIME_X << 1), j + PRIME_Y, x2, y2); + } + } + else + { + float x2 = x0 + (float)G2; + float y2 = y0 + (float)(G2 - 1); + float a2 = (2.0f / 3.0f) - x2 * x2 - y2 * y2; + if (a2 > 0) + { + value += (a2 * a2) * (a2 * a2) * _fnlGradCoord2D(seed, i, j + PRIME_Y, x2, y2); + } + } + + if (yi - xmyi > 1) + { + float x3 = x0 + (float)(3 * G2 - 1); + float y3 = y0 + (float)(3 * G2 - 2); + float a3 = (2.0f / 3.0f) - x3 * x3 - y3 * y3; + if (a3 > 0) + { + value += (a3 * a3) * (a3 * a3) * _fnlGradCoord2D(seed, i + PRIME_X, j + (PRIME_Y << 1), x3, y3); + } + } + else + { + float x3 = x0 + (float)(G2 - 1); + float y3 = y0 + (float)G2; + float a3 = (2.0f / 3.0f) - x3 * x3 - y3 * y3; + if (a3 > 0) + { + value += (a3 * a3) * (a3 * a3) * _fnlGradCoord2D(seed, i + PRIME_X, j, x3, y3); + } + } + } + else + { + if (xi + xmyi < 0) + { + float x2 = x0 + (float)(1 - G2); + float y2 = y0 - (float)G2; + float a2 = (2.0f / 3.0f) - x2 * x2 - y2 * y2; + if (a2 > 0) + { + value += (a2 * a2) * (a2 * a2) * _fnlGradCoord2D(seed, i - PRIME_X, j, x2, y2); + } + } + else + { + float x2 = x0 + (float)(G2 - 1); + float y2 = y0 + (float)G2; + float a2 = (2.0f / 3.0f) - x2 * x2 - y2 * y2; + if (a2 > 0) + { + value += (a2 * a2) * (a2 * a2) * _fnlGradCoord2D(seed, i + PRIME_X, j, x2, y2); + } + } + + if (yi < xmyi) + { + float x2 = x0 - (float)G2; + float y2 = y0 - (float)(G2 - 1); + float a2 = (2.0f / 3.0f) - x2 * x2 - y2 * y2; + if (a2 > 0) + { + value += (a2 * a2) * (a2 * a2) * _fnlGradCoord2D(seed, i, j - PRIME_Y, x2, y2); + } + } + else + { + float x2 = x0 + (float)G2; + float y2 = y0 + (float)(G2 - 1); + float a2 = (2.0f / 3.0f) - x2 * x2 - y2 * y2; + if (a2 > 0) + { + value += (a2 * a2) * (a2 * a2) * _fnlGradCoord2D(seed, i, j + PRIME_Y, x2, y2); + } + } + } + + return value * 18.24196194486065f; +} + +static float _fnlSingleOpenSimplex2S3D(int seed, FNLfloat x, FNLfloat y, FNLfloat z) +{ + // 3D OpenSimplex2S case uses two offset rotated cube grids. + + /* + * --- Rotation moved to TransformNoiseCoordinate method --- + * const FNLfloat R3 = (FNLfloat)(2.0 / 3.0); + * FNLfloat r = (x + y + z) * R3; // Rotation, not skew + * x = r - x; y = r - y; z = r - z; + */ + + int i = _fnlFastFloor(x); + int j = _fnlFastFloor(y); + int k = _fnlFastFloor(z); + float xi = (float)(x - i); + float yi = (float)(y - j); + float zi = (float)(z - k); + + i *= PRIME_X; + j *= PRIME_Y; + k *= PRIME_Z; + int seed2 = seed + 1293373; + + int xNMask = (int)(-0.5f - xi); + int yNMask = (int)(-0.5f - yi); + int zNMask = (int)(-0.5f - zi); + + float x0 = xi + xNMask; + float y0 = yi + yNMask; + float z0 = zi + zNMask; + float a0 = 0.75f - x0 * x0 - y0 * y0 - z0 * z0; + float value = (a0 * a0) * (a0 * a0) * _fnlGradCoord3D(seed, + i + (xNMask & PRIME_X), j + (yNMask & PRIME_Y), k + (zNMask & PRIME_Z), x0, y0, z0); + + float x1 = xi - 0.5f; + float y1 = yi - 0.5f; + float z1 = zi - 0.5f; + float a1 = 0.75f - x1 * x1 - y1 * y1 - z1 * z1; + value += (a1 * a1) * (a1 * a1) * _fnlGradCoord3D(seed2, + i + PRIME_X, j + PRIME_Y, k + PRIME_Z, x1, y1, z1); + + float xAFlipMask0 = ((xNMask | 1) << 1) * x1; + float yAFlipMask0 = ((yNMask | 1) << 1) * y1; + float zAFlipMask0 = ((zNMask | 1) << 1) * z1; + float xAFlipMask1 = (-2 - (xNMask << 2)) * x1 - 1.0f; + float yAFlipMask1 = (-2 - (yNMask << 2)) * y1 - 1.0f; + float zAFlipMask1 = (-2 - (zNMask << 2)) * z1 - 1.0f; + + bool skip5 = false; + float a2 = xAFlipMask0 + a0; + if (a2 > 0) + { + float x2 = x0 - (xNMask | 1); + float y2 = y0; + float z2 = z0; + value += (a2 * a2) * (a2 * a2) * _fnlGradCoord3D(seed, + i + (~xNMask & PRIME_X), j + (yNMask & PRIME_Y), k + (zNMask & PRIME_Z), x2, y2, z2); + } + else + { + float a3 = yAFlipMask0 + zAFlipMask0 + a0; + if (a3 > 0) + { + float x3 = x0; + float y3 = y0 - (yNMask | 1); + float z3 = z0 - (zNMask | 1); + value += (a3 * a3) * (a3 * a3) * _fnlGradCoord3D(seed, + i + (xNMask & PRIME_X), j + (~yNMask & PRIME_Y), k + (~zNMask & PRIME_Z), x3, y3, z3); + } + + float a4 = xAFlipMask1 + a1; + if (a4 > 0) + { + float x4 = (xNMask | 1) + x1; + float y4 = y1; + float z4 = z1; + value += (a4 * a4) * (a4 * a4) * _fnlGradCoord3D(seed2, + i + (xNMask & (PRIME_X * 2)), j + PRIME_Y, k + PRIME_Z, x4, y4, z4); + skip5 = true; + } + } + + bool skip9 = false; + float a6 = yAFlipMask0 + a0; + if (a6 > 0) + { + float x6 = x0; + float y6 = y0 - (yNMask | 1); + float z6 = z0; + value += (a6 * a6) * (a6 * a6) * _fnlGradCoord3D(seed, + i + (xNMask & PRIME_X), j + (~yNMask & PRIME_Y), k + (zNMask & PRIME_Z), x6, y6, z6); + } + else + { + float a7 = xAFlipMask0 + zAFlipMask0 + a0; + if (a7 > 0) + { + float x7 = x0 - (xNMask | 1); + float y7 = y0; + float z7 = z0 - (zNMask | 1); + value += (a7 * a7) * (a7 * a7) * _fnlGradCoord3D(seed, + i + (~xNMask & PRIME_X), j + (yNMask & PRIME_Y), k + (~zNMask & PRIME_Z), x7, y7, z7); + } + + float a8 = yAFlipMask1 + a1; + if (a8 > 0) + { + float x8 = x1; + float y8 = (yNMask | 1) + y1; + float z8 = z1; + value += (a8 * a8) * (a8 * a8) * _fnlGradCoord3D(seed2, + i + PRIME_X, j + (yNMask & (PRIME_Y << 1)), k + PRIME_Z, x8, y8, z8); + skip9 = true; + } + } + + bool skipD = false; + float aA = zAFlipMask0 + a0; + if (aA > 0) + { + float xA = x0; + float yA = y0; + float zA = z0 - (zNMask | 1); + value += (aA * aA) * (aA * aA) * _fnlGradCoord3D(seed, + i + (xNMask & PRIME_X), j + (yNMask & PRIME_Y), k + (~zNMask & PRIME_Z), xA, yA, zA); + } + else + { + float aB = xAFlipMask0 + yAFlipMask0 + a0; + if (aB > 0) + { + float xB = x0 - (xNMask | 1); + float yB = y0 - (yNMask | 1); + float zB = z0; + value += (aB * aB) * (aB * aB) * _fnlGradCoord3D(seed, + i + (~xNMask & PRIME_X), j + (~yNMask & PRIME_Y), k + (zNMask & PRIME_Z), xB, yB, zB); + } + + float aC = zAFlipMask1 + a1; + if (aC > 0) + { + float xC = x1; + float yC = y1; + float zC = (zNMask | 1) + z1; + value += (aC * aC) * (aC * aC) * _fnlGradCoord3D(seed2, + i + PRIME_X, j + PRIME_Y, k + (zNMask & (PRIME_Z << 1)), xC, yC, zC); + skipD = true; + } + } + + if (!skip5) + { + float a5 = yAFlipMask1 + zAFlipMask1 + a1; + if (a5 > 0) + { + float x5 = x1; + float y5 = (yNMask | 1) + y1; + float z5 = (zNMask | 1) + z1; + value += (a5 * a5) * (a5 * a5) * _fnlGradCoord3D(seed2, + i + PRIME_X, j + (yNMask & (PRIME_Y << 1)), k + (zNMask & (PRIME_Z << 1)), x5, y5, z5); + } + } + + if (!skip9) + { + float a9 = xAFlipMask1 + zAFlipMask1 + a1; + if (a9 > 0) + { + float x9 = (xNMask | 1) + x1; + float y9 = y1; + float z9 = (zNMask | 1) + z1; + value += (a9 * a9) * (a9 * a9) * _fnlGradCoord3D(seed2, + i + (xNMask & (PRIME_X * 2)), j + PRIME_Y, k + (zNMask & (PRIME_Z << 1)), x9, y9, z9); + } + } + + if (!skipD) + { + float aD = xAFlipMask1 + yAFlipMask1 + a1; + if (aD > 0) + { + float xD = (xNMask | 1) + x1; + float yD = (yNMask | 1) + y1; + float zD = z1; + value += (aD * aD) * (aD * aD) * _fnlGradCoord3D(seed2, + i + (xNMask & (PRIME_X << 1)), j + (yNMask & (PRIME_Y << 1)), k + PRIME_Z, xD, yD, zD); + } + } + + return value * 9.046026385208288f; +} + +// Cellular Noise + +static float _fnlSingleCellular2D(const fnl_state *state, int seed, FNLfloat x, FNLfloat y) +{ + int xr = _fnlFastRound(x); + int yr = _fnlFastRound(y); + + float distance0 = FLT_MAX; + float distance1 = FLT_MAX; + int closestHash = 0; + + float cellularJitter = 0.43701595f * state->cellular_jitter_mod; + + int xPrimed = (xr - 1) * PRIME_X; + int yPrimedBase = (yr - 1) * PRIME_Y; + + switch (state->cellular_distance_func) + { + default: + case FNL_CELLULAR_DISTANCE_EUCLIDEAN: + case FNL_CELLULAR_DISTANCE_EUCLIDEANSQ: + for (int xi = xr - 1; xi <= xr + 1; xi++) + { + int yPrimed = yPrimedBase; + + for (int yi = yr - 1; yi <= yr + 1; yi++) + { + int hash = _fnlHash2D(seed, xPrimed, yPrimed); + int idx = hash & (255 << 1); + + float vecX = (float)(xi - x) + RAND_VECS_2D[idx] * cellularJitter; + float vecY = (float)(yi - y) + RAND_VECS_2D[idx | 1] * cellularJitter; + + float newDistance = vecX * vecX + vecY * vecY; + + distance1 = _fnlFastMax(_fnlFastMin(distance1, newDistance), distance0); + if (newDistance < distance0) + { + distance0 = newDistance; + closestHash = hash; + } + yPrimed += PRIME_Y; + } + xPrimed += PRIME_X; + } + break; + case FNL_CELLULAR_DISTANCE_MANHATTAN: + for (int xi = xr - 1; xi <= xr + 1; xi++) + { + int yPrimed = yPrimedBase; + + for (int yi = yr - 1; yi <= yr + 1; yi++) + { + int hash = _fnlHash2D(seed, xPrimed, yPrimed); + int idx = hash & (255 << 1); + + float vecX = (float)(xi - x) + RAND_VECS_2D[idx] * cellularJitter; + float vecY = (float)(yi - y) + RAND_VECS_2D[idx | 1] * cellularJitter; + + float newDistance = _fnlFastAbs(vecX) + _fnlFastAbs(vecY); + + distance1 = _fnlFastMax(_fnlFastMin(distance1, newDistance), distance0); + if (newDistance < distance0) + { + distance0 = newDistance; + closestHash = hash; + } + yPrimed += PRIME_Y; + } + xPrimed += PRIME_X; + } + break; + case FNL_CELLULAR_DISTANCE_HYBRID: + for (int xi = xr - 1; xi <= xr + 1; xi++) + { + int yPrimed = yPrimedBase; + for (int yi = yr - 1; yi <= yr + 1; yi++) + { + int hash = _fnlHash2D(seed, xPrimed, yPrimed); + int idx = hash & (255 << 1); + + float vecX = (float)(xi - x) + RAND_VECS_2D[idx] * cellularJitter; + float vecY = (float)(yi - y) + RAND_VECS_2D[idx | 1] * cellularJitter; + + float newDistance = (_fnlFastAbs(vecX) + _fnlFastAbs(vecY)) + (vecX * vecX + vecY * vecY); + + distance1 = _fnlFastMax(_fnlFastMin(distance1, newDistance), distance0); + if (newDistance < distance0) + { + distance0 = newDistance; + closestHash = hash; + } + yPrimed += PRIME_Y; + } + xPrimed += PRIME_X; + } + break; + } + + if (state->cellular_distance_func == FNL_CELLULAR_DISTANCE_EUCLIDEAN && state->cellular_return_type >= FNL_CELLULAR_RETURN_TYPE_DISTANCE) + { + distance0 = _fnlFastSqrt(distance0); + if (state->cellular_return_type >= FNL_CELLULAR_RETURN_TYPE_DISTANCE2) + distance1 = _fnlFastSqrt(distance1); + } + + switch (state->cellular_return_type) + { + case FNL_CELLULAR_RETURN_TYPE_CELLVALUE: + return closestHash * (1 / 2147483648.0f); + case FNL_CELLULAR_RETURN_TYPE_DISTANCE: + return distance0 - 1; + case FNL_CELLULAR_RETURN_TYPE_DISTANCE2: + return distance1 - 1; + case FNL_CELLULAR_RETURN_TYPE_DISTANCE2ADD: + return (distance1 + distance0) * 0.5f - 1; + case FNL_CELLULAR_RETURN_TYPE_DISTANCE2SUB: + return distance1 - distance0 - 1; + case FNL_CELLULAR_RETURN_TYPE_DISTANCE2MUL: + return distance1 * distance0 * 0.5f - 1; + case FNL_CELLULAR_RETURN_TYPE_DISTANCE2DIV: + return distance0 / distance1 - 1; + default: + return 0; + } +} + +static float _fnlSingleCellular3D(const fnl_state *state, int seed, FNLfloat x, FNLfloat y, FNLfloat z) +{ + int xr = _fnlFastRound(x); + int yr = _fnlFastRound(y); + int zr = _fnlFastRound(z); + + float distance0 = FLT_MAX; + float distance1 = FLT_MAX; + int closestHash = 0; + + float cellularJitter = 0.39614353f * state->cellular_jitter_mod; + + int xPrimed = (xr - 1) * PRIME_X; + int yPrimedBase = (yr - 1) * PRIME_Y; + int zPrimedBase = (zr - 1) * PRIME_Z; + + switch (state->cellular_distance_func) + { + default: + case FNL_CELLULAR_DISTANCE_EUCLIDEAN: + case FNL_CELLULAR_DISTANCE_EUCLIDEANSQ: + for (int xi = xr - 1; xi <= xr + 1; xi++) + { + int yPrimed = yPrimedBase; + + for (int yi = yr - 1; yi <= yr + 1; yi++) + { + int zPrimed = zPrimedBase; + + for (int zi = zr - 1; zi <= zr + 1; zi++) + { + int hash = _fnlHash3D(seed, xPrimed, yPrimed, zPrimed); + int idx = hash & (255 << 2); + + float vecX = (float)(xi - x) + RAND_VECS_3D[idx] * cellularJitter; + float vecY = (float)(yi - y) + RAND_VECS_3D[idx | 1] * cellularJitter; + float vecZ = (float)(zi - z) + RAND_VECS_3D[idx | 2] * cellularJitter; + + float newDistance = vecX * vecX + vecY * vecY + vecZ * vecZ; + + distance1 = _fnlFastMax(_fnlFastMin(distance1, newDistance), distance0); + if (newDistance < distance0) + { + distance0 = newDistance; + closestHash = hash; + } + zPrimed += PRIME_Z; + } + yPrimed += PRIME_Y; + } + xPrimed += PRIME_X; + } + break; + case FNL_CELLULAR_DISTANCE_MANHATTAN: + for (int xi = xr - 1; xi <= xr + 1; xi++) + { + int yPrimed = yPrimedBase; + + for (int yi = yr - 1; yi <= yr + 1; yi++) + { + int zPrimed = zPrimedBase; + + for (int zi = zr - 1; zi <= zr + 1; zi++) + { + int hash = _fnlHash3D(seed, xPrimed, yPrimed, zPrimed); + int idx = hash & (255 << 2); + + float vecX = (float)(xi - x) + RAND_VECS_3D[idx] * cellularJitter; + float vecY = (float)(yi - y) + RAND_VECS_3D[idx | 1] * cellularJitter; + float vecZ = (float)(zi - z) + RAND_VECS_3D[idx | 2] * cellularJitter; + + float newDistance = _fnlFastAbs(vecX) + _fnlFastAbs(vecY) + _fnlFastAbs(vecZ); + + distance1 = _fnlFastMax(_fnlFastMin(distance1, newDistance), distance0); + if (newDistance < distance0) + { + distance0 = newDistance; + closestHash = hash; + } + zPrimed += PRIME_Z; + } + yPrimed += PRIME_Y; + } + xPrimed += PRIME_X; + } + break; + case FNL_CELLULAR_DISTANCE_HYBRID: + for (int xi = xr - 1; xi <= xr + 1; xi++) + { + int yPrimed = yPrimedBase; + + for (int yi = yr - 1; yi <= yr + 1; yi++) + { + int zPrimed = zPrimedBase; + + for (int zi = zr - 1; zi <= zr + 1; zi++) + { + int hash = _fnlHash3D(seed, xPrimed, yPrimed, zPrimed); + int idx = hash & (255 << 2); + + float vecX = (float)(xi - x) + RAND_VECS_3D[idx] * cellularJitter; + float vecY = (float)(yi - y) + RAND_VECS_3D[idx | 1] * cellularJitter; + float vecZ = (float)(zi - z) + RAND_VECS_3D[idx | 2] * cellularJitter; + + float newDistance = (_fnlFastAbs(vecX) + _fnlFastAbs(vecY) + _fnlFastAbs(vecZ)) + (vecX * vecX + vecY * vecY + vecZ * vecZ); + + distance1 = _fnlFastMax(_fnlFastMin(distance1, newDistance), distance0); + if (newDistance < distance0) + { + distance0 = newDistance; + closestHash = hash; + } + zPrimed += PRIME_Z; + } + yPrimed += PRIME_Y; + } + xPrimed += PRIME_X; + } + break; + } + + if (state->cellular_distance_func == FNL_CELLULAR_DISTANCE_EUCLIDEAN && state->cellular_return_type >= FNL_CELLULAR_RETURN_TYPE_DISTANCE) + { + distance0 = _fnlFastSqrt(distance0); + if (state->cellular_return_type >= FNL_CELLULAR_RETURN_TYPE_DISTANCE2) + distance1 = _fnlFastSqrt(distance1); + } + + switch (state->cellular_return_type) + { + case FNL_CELLULAR_RETURN_TYPE_CELLVALUE: + return closestHash * (1 / 2147483648.0f); + case FNL_CELLULAR_RETURN_TYPE_DISTANCE: + return distance0 - 1; + case FNL_CELLULAR_RETURN_TYPE_DISTANCE2: + return distance1 - 1; + case FNL_CELLULAR_RETURN_TYPE_DISTANCE2ADD: + return (distance1 + distance0) * 0.5f - 1; + case FNL_CELLULAR_RETURN_TYPE_DISTANCE2SUB: + return distance1 - distance0 - 1; + case FNL_CELLULAR_RETURN_TYPE_DISTANCE2MUL: + return distance1 * distance0 * 0.5f - 1; + case FNL_CELLULAR_RETURN_TYPE_DISTANCE2DIV: + return distance0 / distance1 - 1; + default: + return 0; + } +} + +// Perlin Noise + +static float _fnlSinglePerlin2D(int seed, FNLfloat x, FNLfloat y) +{ + int x0 = _fnlFastFloor(x); + int y0 = _fnlFastFloor(y); + + float xd0 = (float)(x - x0); + float yd0 = (float)(y - y0); + float xd1 = xd0 - 1; + float yd1 = yd0 - 1; + + float xs = _fnlInterpQuintic(xd0); + float ys = _fnlInterpQuintic(yd0); + + x0 *= PRIME_X; + y0 *= PRIME_Y; + int x1 = x0 + PRIME_X; + int y1 = y0 + PRIME_Y; + + float xf0 = _fnlLerp(_fnlGradCoord2D(seed, x0, y0, xd0, yd0), _fnlGradCoord2D(seed, x1, y0, xd1, yd0), xs); + float xf1 = _fnlLerp(_fnlGradCoord2D(seed, x0, y1, xd0, yd1), _fnlGradCoord2D(seed, x1, y1, xd1, yd1), xs); + + return _fnlLerp(xf0, xf1, ys) * 1.4247691104677813f; +} + +static float _fnlSinglePerlin3D(int seed, FNLfloat x, FNLfloat y, FNLfloat z) +{ + int x0 = _fnlFastFloor(x); + int y0 = _fnlFastFloor(y); + int z0 = _fnlFastFloor(z); + + float xd0 = (float)(x - x0); + float yd0 = (float)(y - y0); + float zd0 = (float)(z - z0); + float xd1 = xd0 - 1; + float yd1 = yd0 - 1; + float zd1 = zd0 - 1; + + float xs = _fnlInterpQuintic(xd0); + float ys = _fnlInterpQuintic(yd0); + float zs = _fnlInterpQuintic(zd0); + + x0 *= PRIME_X; + y0 *= PRIME_Y; + z0 *= PRIME_Z; + int x1 = x0 + PRIME_X; + int y1 = y0 + PRIME_Y; + int z1 = z0 + PRIME_Z; + + float xf00 = _fnlLerp(_fnlGradCoord3D(seed, x0, y0, z0, xd0, yd0, zd0), _fnlGradCoord3D(seed, x1, y0, z0, xd1, yd0, zd0), xs); + float xf10 = _fnlLerp(_fnlGradCoord3D(seed, x0, y1, z0, xd0, yd1, zd0), _fnlGradCoord3D(seed, x1, y1, z0, xd1, yd1, zd0), xs); + float xf01 = _fnlLerp(_fnlGradCoord3D(seed, x0, y0, z1, xd0, yd0, zd1), _fnlGradCoord3D(seed, x1, y0, z1, xd1, yd0, zd1), xs); + float xf11 = _fnlLerp(_fnlGradCoord3D(seed, x0, y1, z1, xd0, yd1, zd1), _fnlGradCoord3D(seed, x1, y1, z1, xd1, yd1, zd1), xs); + + float yf0 = _fnlLerp(xf00, xf10, ys); + float yf1 = _fnlLerp(xf01, xf11, ys); + + return _fnlLerp(yf0, yf1, zs) * 0.964921414852142333984375f; +} + +// Value Cubic + +static float _fnlSingleValueCubic2D(int seed, FNLfloat x, FNLfloat y) +{ + int x1 = _fnlFastFloor(x); + int y1 = _fnlFastFloor(y); + + float xs = x - (float)x1; + float ys = y - (float)y1; + + x1 *= PRIME_X; + y1 *= PRIME_Y; + + int x0 = x1 - PRIME_X; + int y0 = y1 - PRIME_Y; + int x2 = x1 + PRIME_X; + int y2 = y1 + PRIME_Y; + int x3 = x1 + (int)((long)PRIME_X << 1); + int y3 = y1 + (int)((long)PRIME_Y << 1); + + return _fnlCubicLerp( + _fnlCubicLerp(_fnlValCoord2D(seed, x0, y0), _fnlValCoord2D(seed, x1, y0), _fnlValCoord2D(seed, x2, y0), _fnlValCoord2D(seed, x3, y0), + xs), + _fnlCubicLerp(_fnlValCoord2D(seed, x0, y1), _fnlValCoord2D(seed, x1, y1), _fnlValCoord2D(seed, x2, y1), _fnlValCoord2D(seed, x3, y1), + xs), + _fnlCubicLerp(_fnlValCoord2D(seed, x0, y2), _fnlValCoord2D(seed, x1, y2), _fnlValCoord2D(seed, x2, y2), _fnlValCoord2D(seed, x3, y2), + xs), + _fnlCubicLerp(_fnlValCoord2D(seed, x0, y3), _fnlValCoord2D(seed, x1, y3), _fnlValCoord2D(seed, x2, y3), _fnlValCoord2D(seed, x3, y3), + xs), + ys) * (1 / (1.5f * 1.5f)); +} + +static float _fnlSingleValueCubic3D(int seed, FNLfloat x, FNLfloat y, FNLfloat z) +{ + int x1 = _fnlFastFloor(x); + int y1 = _fnlFastFloor(y); + int z1 = _fnlFastFloor(z); + + float xs = x - (float)x1; + float ys = y - (float)y1; + float zs = z - (float)z1; + + x1 *= PRIME_X; + y1 *= PRIME_Y; + z1 *= PRIME_Z; + + int x0 = x1 - PRIME_X; + int y0 = y1 - PRIME_Y; + int z0 = z1 - PRIME_Z; + int x2 = x1 + PRIME_X; + int y2 = y1 + PRIME_Y; + int z2 = z1 + PRIME_Z; + int x3 = x1 + (int)((long)PRIME_X << 1); + int y3 = y1 + (int)((long)PRIME_Y << 1); + int z3 = z1 + (int)((long)PRIME_Z << 1); + + return _fnlCubicLerp( + _fnlCubicLerp( + _fnlCubicLerp(_fnlValCoord3D(seed, x0, y0, z0), _fnlValCoord3D(seed, x1, y0, z0), _fnlValCoord3D(seed, x2, y0, z0), _fnlValCoord3D(seed, x3, y0, z0), xs), + _fnlCubicLerp(_fnlValCoord3D(seed, x0, y1, z0), _fnlValCoord3D(seed, x1, y1, z0), _fnlValCoord3D(seed, x2, y1, z0), _fnlValCoord3D(seed, x3, y1, z0), xs), + _fnlCubicLerp(_fnlValCoord3D(seed, x0, y2, z0), _fnlValCoord3D(seed, x1, y2, z0), _fnlValCoord3D(seed, x2, y2, z0), _fnlValCoord3D(seed, x3, y2, z0), xs), + _fnlCubicLerp(_fnlValCoord3D(seed, x0, y3, z0), _fnlValCoord3D(seed, x1, y3, z0), _fnlValCoord3D(seed, x2, y3, z0), _fnlValCoord3D(seed, x3, y3, z0), xs), + ys), + _fnlCubicLerp( + _fnlCubicLerp(_fnlValCoord3D(seed, x0, y0, z1), _fnlValCoord3D(seed, x1, y0, z1), _fnlValCoord3D(seed, x2, y0, z1), _fnlValCoord3D(seed, x3, y0, z1), xs), + _fnlCubicLerp(_fnlValCoord3D(seed, x0, y1, z1), _fnlValCoord3D(seed, x1, y1, z1), _fnlValCoord3D(seed, x2, y1, z1), _fnlValCoord3D(seed, x3, y1, z1), xs), + _fnlCubicLerp(_fnlValCoord3D(seed, x0, y2, z1), _fnlValCoord3D(seed, x1, y2, z1), _fnlValCoord3D(seed, x2, y2, z1), _fnlValCoord3D(seed, x3, y2, z1), xs), + _fnlCubicLerp(_fnlValCoord3D(seed, x0, y3, z1), _fnlValCoord3D(seed, x1, y3, z1), _fnlValCoord3D(seed, x2, y3, z1), _fnlValCoord3D(seed, x3, y3, z1), xs), + ys), + _fnlCubicLerp( + _fnlCubicLerp(_fnlValCoord3D(seed, x0, y0, z2), _fnlValCoord3D(seed, x1, y0, z2), _fnlValCoord3D(seed, x2, y0, z2), _fnlValCoord3D(seed, x3, y0, z2), xs), + _fnlCubicLerp(_fnlValCoord3D(seed, x0, y1, z2), _fnlValCoord3D(seed, x1, y1, z2), _fnlValCoord3D(seed, x2, y1, z2), _fnlValCoord3D(seed, x3, y1, z2), xs), + _fnlCubicLerp(_fnlValCoord3D(seed, x0, y2, z2), _fnlValCoord3D(seed, x1, y2, z2), _fnlValCoord3D(seed, x2, y2, z2), _fnlValCoord3D(seed, x3, y2, z2), xs), + _fnlCubicLerp(_fnlValCoord3D(seed, x0, y3, z2), _fnlValCoord3D(seed, x1, y3, z2), _fnlValCoord3D(seed, x2, y3, z2), _fnlValCoord3D(seed, x3, y3, z2), xs), + ys), + _fnlCubicLerp( + _fnlCubicLerp(_fnlValCoord3D(seed, x0, y0, z3), _fnlValCoord3D(seed, x1, y0, z3), _fnlValCoord3D(seed, x2, y0, z3), _fnlValCoord3D(seed, x3, y0, z3), xs), + _fnlCubicLerp(_fnlValCoord3D(seed, x0, y1, z3), _fnlValCoord3D(seed, x1, y1, z3), _fnlValCoord3D(seed, x2, y1, z3), _fnlValCoord3D(seed, x3, y1, z3), xs), + _fnlCubicLerp(_fnlValCoord3D(seed, x0, y2, z3), _fnlValCoord3D(seed, x1, y2, z3), _fnlValCoord3D(seed, x2, y2, z3), _fnlValCoord3D(seed, x3, y2, z3), xs), + _fnlCubicLerp(_fnlValCoord3D(seed, x0, y3, z3), _fnlValCoord3D(seed, x1, y3, z3), _fnlValCoord3D(seed, x2, y3, z3), _fnlValCoord3D(seed, x3, y3, z3), xs), + ys), + zs) * (1 / (1.5f * 1.5f * 1.5f)); +} + +// Value noise + +static float _fnlSingleValue2D(int seed, FNLfloat x, FNLfloat y) +{ + int x0 = _fnlFastFloor(x); + int y0 = _fnlFastFloor(y); + + float xs = _fnlInterpHermite((float)(x - x0)); + float ys = _fnlInterpHermite((float)(y - y0)); + + x0 *= PRIME_X; + y0 *= PRIME_Y; + int x1 = x0 + PRIME_X; + int y1 = y0 + PRIME_Y; + + float xf0 = _fnlLerp(_fnlValCoord2D(seed, x0, y0), _fnlValCoord2D(seed, x1, y0), xs); + float xf1 = _fnlLerp(_fnlValCoord2D(seed, x0, y1), _fnlValCoord2D(seed, x1, y1), xs); + + return _fnlLerp(xf0, xf1, ys); +} + +static float _fnlSingleValue3D(int seed, FNLfloat x, FNLfloat y, FNLfloat z) +{ + int x0 = _fnlFastFloor(x); + int y0 = _fnlFastFloor(y); + int z0 = _fnlFastFloor(z); + + float xs = _fnlInterpHermite((float)(x - x0)); + float ys = _fnlInterpHermite((float)(y - y0)); + float zs = _fnlInterpHermite((float)(z - z0)); + + x0 *= PRIME_X; + y0 *= PRIME_Y; + z0 *= PRIME_Z; + int x1 = x0 + PRIME_X; + int y1 = y0 + PRIME_Y; + int z1 = z0 + PRIME_Z; + + float xf00 = _fnlLerp(_fnlValCoord3D(seed, x0, y0, z0), _fnlValCoord3D(seed, x1, y0, z0), xs); + float xf10 = _fnlLerp(_fnlValCoord3D(seed, x0, y1, z0), _fnlValCoord3D(seed, x1, y1, z0), xs); + float xf01 = _fnlLerp(_fnlValCoord3D(seed, x0, y0, z1), _fnlValCoord3D(seed, x1, y0, z1), xs); + float xf11 = _fnlLerp(_fnlValCoord3D(seed, x0, y1, z1), _fnlValCoord3D(seed, x1, y1, z1), xs); + + float yf0 = _fnlLerp(xf00, xf10, ys); + float yf1 = _fnlLerp(xf01, xf11, ys); + + return _fnlLerp(yf0, yf1, zs); +} + +// Domain Warp + +// Forward declare +static void _fnlSingleDomainWarpBasicGrid2D(int seed, float warpAmp, float frequency, FNLfloat x, FNLfloat y, FNLfloat *xp, FNLfloat *yp); +static void _fnlSingleDomainWarpBasicGrid3D(int seed, float warpAmp, float frequency, FNLfloat x, FNLfloat y, FNLfloat z, FNLfloat *xp, FNLfloat *yp, FNLfloat *zp); +static void _fnlSingleDomainWarpSimplexGradient(int seed, float warpAmp, float frequency, FNLfloat x, FNLfloat y, FNLfloat *xr, FNLfloat *yr, bool outGradOnly); +static void _fnlSingleDomainWarpOpenSimplex2Gradient(int seed, float warpAmp, float frequency, FNLfloat x, FNLfloat y, FNLfloat z, FNLfloat *xr, FNLfloat *yr, FNLfloat *zr, bool outGradOnly); + +static inline void _fnlDoSingleDomainWarp2D(const fnl_state *state, int seed, float amp, float freq, FNLfloat x, FNLfloat y, FNLfloat *xp, FNLfloat *yp) +{ + switch (state->domain_warp_type) + { + case FNL_DOMAIN_WARP_OPENSIMPLEX2: + _fnlSingleDomainWarpSimplexGradient(seed, amp * 38.283687591552734375f, freq, x, y, xp, yp, false); + break; + case FNL_DOMAIN_WARP_OPENSIMPLEX2_REDUCED: + _fnlSingleDomainWarpSimplexGradient(seed, amp * 16.0f, freq, x, y, xp, yp, true); + break; + case FNL_DOMAIN_WARP_BASICGRID: + _fnlSingleDomainWarpBasicGrid2D(seed, amp, freq, x, y, xp, yp); + break; + } +} + +static inline void _fnlDoSingleDomainWarp3D(const fnl_state *state, int seed, float amp, float freq, FNLfloat x, FNLfloat y, FNLfloat z, FNLfloat *xp, FNLfloat *yp, FNLfloat *zp) +{ + switch (state->domain_warp_type) + { + case FNL_DOMAIN_WARP_OPENSIMPLEX2: + _fnlSingleDomainWarpOpenSimplex2Gradient(seed, amp * 32.69428253173828125f, freq, x, y, z, xp, yp, zp, false); + break; + case FNL_DOMAIN_WARP_OPENSIMPLEX2_REDUCED: + _fnlSingleDomainWarpOpenSimplex2Gradient(seed, amp * 7.71604938271605f, freq, x, y, z, xp, yp, zp, true); + break; + case FNL_DOMAIN_WARP_BASICGRID: + _fnlSingleDomainWarpBasicGrid3D(seed, amp, freq, x, y, z, xp, yp, zp); + break; + } +} + +// Domain Warp Single Wrapper + +static void _fnlDomainWarpSingle2D(const fnl_state *state, FNLfloat *x, FNLfloat *y) +{ + int seed = state->seed; + float amp = state->domain_warp_amp * _fnlCalculateFractalBounding(state); + float freq = state->frequency; + + FNLfloat xs = *x; + FNLfloat ys = *y; + _fnlTransformDomainWarpCoordinate2D(state, &xs, &ys); + + _fnlDoSingleDomainWarp2D(state, seed, amp, freq, xs, ys, x, y); +} + +static void _fnlDomainWarpSingle3D(const fnl_state *state, FNLfloat *x, FNLfloat *y, FNLfloat *z) +{ + int seed = state->seed; + float amp = state->domain_warp_amp * _fnlCalculateFractalBounding(state); + float freq = state->frequency; + + FNLfloat xs = *x; + FNLfloat ys = *y; + FNLfloat zs = *z; + _fnlTransformDomainWarpCoordinate3D(state, &xs, &ys, &zs); + + _fnlDoSingleDomainWarp3D(state, seed, amp, freq, xs, ys, zs, x, y, z); +} + +// Domain Warp Fractal Progressive + +static void _fnlDomainWarpFractalProgressive2D(const fnl_state *state, FNLfloat *x, FNLfloat *y) +{ + int seed = state->seed; + float amp = state->domain_warp_amp * _fnlCalculateFractalBounding(state); + float freq = state->frequency; + + for (int i = 0; i < state->octaves; i++) + { + FNLfloat xs = *x; + FNLfloat ys = *y; + _fnlTransformDomainWarpCoordinate2D(state, &xs, &ys); + + _fnlDoSingleDomainWarp2D(state, seed, amp, freq, xs, ys, x, y); + + seed++; + amp *= state->gain; + freq *= state->lacunarity; + } +} + +static void _fnlDomainWarpFractalProgressive3D(const fnl_state *state, FNLfloat *x, FNLfloat *y, FNLfloat *z) +{ + int seed = state->seed; + float amp = state->domain_warp_amp * _fnlCalculateFractalBounding(state); + float freq = state->frequency; + + for (int i = 0; i < state->octaves; i++) + { + FNLfloat xs = *x; + FNLfloat ys = *y; + FNLfloat zs = *z; + _fnlTransformDomainWarpCoordinate3D(state, &xs, &ys, &zs); + + _fnlDoSingleDomainWarp3D(state, seed, amp, freq, xs, ys, zs, x, y, z); + + seed++; + amp *= state->gain; + freq *= state->lacunarity; + } +} + +// Domain Warp Fractal Independent + +static void _fnlDomainWarpFractalIndependent2D(const fnl_state *state, FNLfloat *x, FNLfloat *y) +{ + FNLfloat xs = *x; + FNLfloat ys = *y; + _fnlTransformDomainWarpCoordinate2D(state, &xs, &ys); + + int seed = state->seed; + float amp = state->domain_warp_amp * _fnlCalculateFractalBounding(state); + float freq = state->frequency; + + for (int i = 0; i < state->octaves; i++) + { + _fnlDoSingleDomainWarp2D(state, seed, amp, freq, xs, ys, x, y); + + seed++; + amp *= state->gain; + freq *= state->lacunarity; + } +} + +static void _fnlDomainWarpFractalIndependent3D(const fnl_state *state, FNLfloat *x, FNLfloat *y, FNLfloat *z) +{ + FNLfloat xs = *x; + FNLfloat ys = *y; + FNLfloat zs = *z; + _fnlTransformDomainWarpCoordinate3D(state, &xs, &ys, &zs); + + int seed = state->seed; + float amp = state->domain_warp_amp * _fnlCalculateFractalBounding(state); + float freq = state->frequency; + + for (int i = 0; i < state->octaves; i++) + { + _fnlDoSingleDomainWarp3D(state, seed, amp, freq, xs, ys, zs, x, y, z); + + seed++; + amp *= state->gain; + freq *= state->lacunarity; + } +} + +// Domain Warp Basic Grid + +static void _fnlSingleDomainWarpBasicGrid2D(int seed, float warpAmp, float frequency, FNLfloat x, FNLfloat y, FNLfloat *xp, FNLfloat *yp) +{ + FNLfloat xf = x * frequency; + FNLfloat yf = y * frequency; + + int x0 = _fnlFastFloor(xf); + int y0 = _fnlFastFloor(yf); + + float xs = _fnlInterpHermite((float)(xf - x0)); + float ys = _fnlInterpHermite((float)(yf - y0)); + + x0 *= PRIME_X; + y0 *= PRIME_Y; + int x1 = x0 + PRIME_X; + int y1 = y0 + PRIME_Y; + + int idx0 = _fnlHash2D(seed, x0, y0) & (255 << 1); + int idx1 = _fnlHash2D(seed, x1, y0) & (255 << 1); + + float lx0x = _fnlLerp(RAND_VECS_2D[idx0], RAND_VECS_2D[idx1], xs); + float ly0x = _fnlLerp(RAND_VECS_2D[idx0 | 1], RAND_VECS_2D[idx1 | 1], xs); + + idx0 = _fnlHash2D(seed, x0, y1) & (255 << 1); + idx1 = _fnlHash2D(seed, x1, y1) & (255 << 1); + + float lx1x = _fnlLerp(RAND_VECS_2D[idx0], RAND_VECS_2D[idx1], xs); + float ly1x = _fnlLerp(RAND_VECS_2D[idx0 | 1], RAND_VECS_2D[idx1 | 1], xs); + + *xp += _fnlLerp(lx0x, lx1x, ys) * warpAmp; + *yp += _fnlLerp(ly0x, ly1x, ys) * warpAmp; +} + +static void _fnlSingleDomainWarpBasicGrid3D(int seed, float warpAmp, float frequency, FNLfloat x, FNLfloat y, FNLfloat z, FNLfloat *xp, FNLfloat *yp, FNLfloat *zp) +{ + FNLfloat xf = x * frequency; + FNLfloat yf = y * frequency; + FNLfloat zf = z * frequency; + + int x0 = _fnlFastFloor(xf); + int y0 = _fnlFastFloor(yf); + int z0 = _fnlFastFloor(zf); + + float xs = _fnlInterpHermite((float)(xf - x0)); + float ys = _fnlInterpHermite((float)(yf - y0)); + float zs = _fnlInterpHermite((float)(zf - z0)); + + x0 *= PRIME_X; + y0 *= PRIME_Y; + z0 *= PRIME_Z; + int x1 = x0 + PRIME_X; + int y1 = y0 + PRIME_Y; + int z1 = z0 + PRIME_Z; + + int idx0 = _fnlHash3D(seed, x0, y0, z0) & (255 << 2); + int idx1 = _fnlHash3D(seed, x1, y0, z0) & (255 << 2); + + float lx0x = _fnlLerp(RAND_VECS_3D[idx0], RAND_VECS_3D[idx1], xs); + float ly0x = _fnlLerp(RAND_VECS_3D[idx0 | 1], RAND_VECS_3D[idx1 | 1], xs); + float lz0x = _fnlLerp(RAND_VECS_3D[idx0 | 2], RAND_VECS_3D[idx1 | 2], xs); + + idx0 = _fnlHash3D(seed, x0, y1, z0) & (255 << 2); + idx1 = _fnlHash3D(seed, x1, y1, z0) & (255 << 2); + + float lx1x = _fnlLerp(RAND_VECS_3D[idx0], RAND_VECS_3D[idx1], xs); + float ly1x = _fnlLerp(RAND_VECS_3D[idx0 | 1], RAND_VECS_3D[idx1 | 1], xs); + float lz1x = _fnlLerp(RAND_VECS_3D[idx0 | 2], RAND_VECS_3D[idx1 | 2], xs); + + float lx0y = _fnlLerp(lx0x, lx1x, ys); + float ly0y = _fnlLerp(ly0x, ly1x, ys); + float lz0y = _fnlLerp(lz0x, lz1x, ys); + + idx0 = _fnlHash3D(seed, x0, y0, z1) & (255 << 2); + idx1 = _fnlHash3D(seed, x1, y0, z1) & (255 << 2); + + lx0x = _fnlLerp(RAND_VECS_3D[idx0], RAND_VECS_3D[idx1], xs); + ly0x = _fnlLerp(RAND_VECS_3D[idx0 | 1], RAND_VECS_3D[idx1 | 1], xs); + lz0x = _fnlLerp(RAND_VECS_3D[idx0 | 2], RAND_VECS_3D[idx1 | 2], xs); + + idx0 = _fnlHash3D(seed, x0, y1, z1) & (255 << 2); + idx1 = _fnlHash3D(seed, x1, y1, z1) & (255 << 2); + + lx1x = _fnlLerp(RAND_VECS_3D[idx0], RAND_VECS_3D[idx1], xs); + ly1x = _fnlLerp(RAND_VECS_3D[idx0 | 1], RAND_VECS_3D[idx1 | 1], xs); + lz1x = _fnlLerp(RAND_VECS_3D[idx0 | 2], RAND_VECS_3D[idx1 | 2], xs); + + *xp += _fnlLerp(lx0y, _fnlLerp(lx0x, lx1x, ys), zs) * warpAmp; + *yp += _fnlLerp(ly0y, _fnlLerp(ly0x, ly1x, ys), zs) * warpAmp; + *zp += _fnlLerp(lz0y, _fnlLerp(lz0x, lz1x, ys), zs) * warpAmp; +} + +// Domain Warp Simplex/OpenSimplex2 + +static void _fnlSingleDomainWarpSimplexGradient(int seed, float warpAmp, float frequency, FNLfloat x, FNLfloat y, FNLfloat *xr, FNLfloat *yr, bool outGradOnly) +{ + const float SQRT3 = 1.7320508075688772935274463415059f; + const float G2 = (3 - SQRT3) / 6; + + x *= frequency; + y *= frequency; + + /* + * --- Skew moved to TransformNoiseCoordinate method --- + * const FNLfloat F2 = 0.5f * (SQRT3 - 1); + * FNLfloat s = (x + y) * F2; + * x += s; y += s; + */ + + int i = _fnlFastFloor(x); + int j = _fnlFastFloor(y); + float xi = (float)(x - i); + float yi = (float)(y - j); + + float t = (xi + yi) * G2; + float x0 = (float)(xi - t); + float y0 = (float)(yi - t); + + i *= PRIME_X; + j *= PRIME_Y; + + float vx, vy; + vx = vy = 0; + + float a = 0.5f - x0 * x0 - y0 * y0; + if (a > 0) + { + float aaaa = (a * a) * (a * a); + float xo, yo; + if (outGradOnly) + _fnlGradCoordOut2D(seed, i, j, &xo, &yo); + else + _fnlGradCoordDual2D(seed, i, j, x0, y0, &xo, &yo); + vx += aaaa * xo; + vy += aaaa * yo; + } + + float c = (float)(2 * (1 - 2 * G2) * (1 / G2 - 2)) * t + ((float)(-2 * (1 - 2 * G2) * (1 - 2 * G2)) + a); + if (c > 0) + { + float x2 = x0 + (2 * (float)G2 - 1); + float y2 = y0 + (2 * (float)G2 - 1); + float cccc = (c * c) * (c * c); + float xo, yo; + if (outGradOnly) + _fnlGradCoordOut2D(seed, i + PRIME_X, j + PRIME_Y, &xo, &yo); + else + _fnlGradCoordDual2D(seed, i + PRIME_X, j + PRIME_Y, x2, y2, &xo, &yo); + vx += cccc * xo; + vy += cccc * yo; + } + + if (y0 > x0) + { + float x1 = x0 + (float)G2; + float y1 = y0 + ((float)G2 - 1); + float b = 0.5f - x1 * x1 - y1 * y1; + if (b > 0) + { + float bbbb = (b * b) * (b * b); + float xo, yo; + if (outGradOnly) + _fnlGradCoordOut2D(seed, i, j + PRIME_Y, &xo, &yo); + else + _fnlGradCoordDual2D(seed, i, j + PRIME_Y, x1, y1, &xo, &yo); + vx += bbbb * xo; + vy += bbbb * yo; + } + } + else + { + float x1 = x0 + ((float)G2 - 1); + float y1 = y0 + (float)G2; + float b = 0.5f - x1 * x1 - y1 * y1; + if (b > 0) + { + float bbbb = (b * b) * (b * b); + float xo, yo; + if (outGradOnly) + _fnlGradCoordOut2D(seed, i + PRIME_X, j, &xo, &yo); + else + _fnlGradCoordDual2D(seed, i + PRIME_X, j, x1, y1, &xo, &yo); + vx += bbbb * xo; + vy += bbbb * yo; + } + } + + *xr += vx * warpAmp; + *yr += vy * warpAmp; +} + +static void _fnlSingleDomainWarpOpenSimplex2Gradient(int seed, float warpAmp, float frequency, FNLfloat x, FNLfloat y, FNLfloat z, FNLfloat *xr, FNLfloat *yr, FNLfloat *zr, bool outGradOnly) +{ + x *= frequency; + y *= frequency; + z *= frequency; + + /* + * --- Rotation moved to TransformDomainWarpCoordinate method --- + * const FNLfloat R3 = (FNLfloat)(2.0 / 3.0); + * FNLfloat r = (x + y + z) * R3; // Rotation, not skew + * x = r - x; y = r - y; z = r - z; + */ + + int i = _fnlFastRound(x); + int j = _fnlFastRound(y); + int k = _fnlFastRound(z); + float x0 = (float)x - i; + float y0 = (float)y - j; + float z0 = (float)z - k; + + int xNSign = (int)(-x0 - 1.0f) | 1; + int yNSign = (int)(-y0 - 1.0f) | 1; + int zNSign = (int)(-z0 - 1.0f) | 1; + + float ax0 = xNSign * -x0; + float ay0 = yNSign * -y0; + float az0 = zNSign * -z0; + + i *= PRIME_X; + j *= PRIME_Y; + k *= PRIME_Z; + + float vx, vy, vz; + vx = vy = vz = 0; + + float a = (0.6f - x0 * x0) - (y0 * y0 + z0 * z0); + for (int l = 0; l < 2; l++) + { + if (a > 0) + { + float aaaa = (a * a) * (a * a); + float xo, yo, zo; + if (outGradOnly) + _fnlGradCoordOut3D(seed, i, j, k, &xo, &yo, &zo); + else + _fnlGradCoordDual3D(seed, i, j, k, x0, y0, z0, &xo, &yo, &zo); + vx += aaaa * xo; + vy += aaaa * yo; + vz += aaaa * zo; + } + + float b = a + 1; + int i1 = i; + int j1 = j; + int k1 = k; + float x1 = x0; + float y1 = y0; + float z1 = z0; + if (ax0 >= ay0 && ax0 >= az0) + { + x1 += xNSign; + b -= xNSign * 2 * x1; + i1 -= xNSign * PRIME_X; + } + else if (ay0 > ax0 && ay0 >= az0) + { + y1 += yNSign; + b -= yNSign * 2 * y1; + j1 -= yNSign * PRIME_Y; + } + else + { + z1 += zNSign; + b -= zNSign * 2 * z1; + k1 -= zNSign * PRIME_Z; + } + + if (b > 0) + { + float bbbb = (b * b) * (b * b); + float xo, yo, zo; + if (outGradOnly) + _fnlGradCoordOut3D(seed, i1, j1, k1, &xo, &yo, &zo); + else + _fnlGradCoordDual3D(seed, i1, j1, k1, x1, y1, z1, &xo, &yo, &zo); + vx += bbbb * xo; + vy += bbbb * yo; + vz += bbbb * zo; + } + + if (l == 1) + break; + + ax0 = 0.5f - ax0; + ay0 = 0.5f - ay0; + az0 = 0.5f - az0; + + x0 = xNSign * ax0; + y0 = yNSign * ay0; + z0 = zNSign * az0; + + a += (0.75f - ax0) - (ay0 + az0); + + i += (xNSign >> 1) & PRIME_X; + j += (yNSign >> 1) & PRIME_Y; + k += (zNSign >> 1) & PRIME_Z; + + xNSign = -xNSign; + yNSign = -yNSign; + zNSign = -zNSign; + + seed += 1293373; + } + + *xr += vx * warpAmp; + *yr += vy * warpAmp; + *zr += vz * warpAmp; +} + +// ==================== +// Public API +// ==================== + +fnl_state fnlCreateState() +{ + fnl_state newState; + newState.seed = 1337; + newState.frequency = 0.01f; + newState.noise_type = FNL_NOISE_OPENSIMPLEX2; + newState.rotation_type_3d = FNL_ROTATION_NONE; + newState.fractal_type = FNL_FRACTAL_NONE; + newState.octaves = 3; + newState.lacunarity = 2.0f; + newState.gain = 0.5f; + newState.weighted_strength = 0.0f; + newState.ping_pong_strength = 2.0f; + newState.cellular_distance_func = FNL_CELLULAR_DISTANCE_EUCLIDEANSQ; + newState.cellular_return_type = FNL_CELLULAR_RETURN_TYPE_DISTANCE; + newState.cellular_jitter_mod = 1.0f; + newState.domain_warp_amp = 30.0f; + newState.domain_warp_type = FNL_DOMAIN_WARP_OPENSIMPLEX2; + return newState; +} + +float fnlGetNoise2D(const fnl_state *state, FNLfloat x, FNLfloat y) +{ + _fnlTransformNoiseCoordinate2D(state, &x, &y); + + switch (state->fractal_type) + { + default: + return _fnlGenNoiseSingle2D(state, state->seed, x, y); + case FNL_FRACTAL_FBM: + return _fnlGenFractalFBM2D(state, x, y); + case FNL_FRACTAL_RIDGED: + return _fnlGenFractalRidged2D(state, x, y); + case FNL_FRACTAL_PINGPONG: + return _fnlGenFractalPingPong2D(state, x, y); + } +} + +float fnlGetNoise3D(const fnl_state *state, FNLfloat x, FNLfloat y, FNLfloat z) +{ + _fnlTransformNoiseCoordinate3D(state, &x, &y, &z); + + // Select a noise type + switch (state->fractal_type) + { + default: + return _fnlGenNoiseSingle3D(state, state->seed, x, y, z); + case FNL_FRACTAL_FBM: + return _fnlGenFractalFBM3D(state, x, y, z); + case FNL_FRACTAL_RIDGED: + return _fnlGenFractalRidged3D(state, x, y, z); + case FNL_FRACTAL_PINGPONG: + return _fnlGenFractalPingPong3D(state, x, y, z); + } +} + +void fnlDomainWarp2D(const fnl_state *state, FNLfloat *x, FNLfloat *y) +{ + switch (state->fractal_type) + { + default: + _fnlDomainWarpSingle2D(state, x, y); + break; + case FNL_FRACTAL_DOMAIN_WARP_PROGRESSIVE: + _fnlDomainWarpFractalProgressive2D(state, x, y); + break; + case FNL_FRACTAL_DOMAIN_WARP_INDEPENDENT: + _fnlDomainWarpFractalIndependent2D(state, x, y); + break; + } +} + +void fnlDomainWarp3D(const fnl_state *state, FNLfloat *x, FNLfloat *y, FNLfloat *z) +{ + switch (state->fractal_type) + { + default: + _fnlDomainWarpSingle3D(state, x, y, z); + break; + case FNL_FRACTAL_DOMAIN_WARP_PROGRESSIVE: + _fnlDomainWarpFractalProgressive3D(state, x, y, z); + break; + case FNL_FRACTAL_DOMAIN_WARP_INDEPENDENT: + _fnlDomainWarpFractalIndependent3D(state, x, y, z); + break; + } +} + +#if defined(__cplusplus) +} +#endif + +#endif // FNL_IMPL diff --git a/src/PerlinNoise.hpp b/src/PerlinNoise.hpp deleted file mode 100644 index 9dc3106..0000000 --- a/src/PerlinNoise.hpp +++ /dev/null @@ -1,659 +0,0 @@ -//---------------------------------------------------------------------------------------- -// -// siv::PerlinNoise -// Perlin noise library for modern C++ -// -// Copyright (C) 2013-2021 Ryo Suzuki -// -// Permission is hereby granted, free of charge, to any person obtaining a copy -// of this software and associated documentation files(the "Software"), to deal -// in the Software without restriction, including without limitation the rights -// to use, copy, modify, merge, publish, distribute, sublicense, and / or sell -// copies of the Software, and to permit persons to whom the Software is -// furnished to do so, subject to the following conditions : -// -// The above copyright notice and this permission notice shall be included in -// all copies or substantial portions of the Software. -// -// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE -// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN -// THE SOFTWARE. -// -//---------------------------------------------------------------------------------------- - -# pragma once -# include -# include -# include -# include -# include -# include -# include - -# if __has_include() && defined(__cpp_concepts) -# include -# endif - - -// Library major version -# define SIVPERLIN_VERSION_MAJOR 3 - -// Library minor version -# define SIVPERLIN_VERSION_MINOR 0 - -// Library revision version -# define SIVPERLIN_VERSION_REVISION 0 - -// Library version -# define SIVPERLIN_VERSION ((SIVPERLIN_VERSION_MAJOR * 100 * 100) + (SIVPERLIN_VERSION_MINOR * 100) + (SIVPERLIN_VERSION_REVISION)) - - -// [[nodiscard]] for constructors -# if (201907L <= __has_cpp_attribute(nodiscard)) -# define SIVPERLIN_NODISCARD_CXX20 [[nodiscard]] -# else -# define SIVPERLIN_NODISCARD_CXX20 -# endif - - -// std::uniform_random_bit_generator concept -# if __cpp_lib_concepts -# define SIVPERLIN_CONCEPT_URBG template -# define SIVPERLIN_CONCEPT_URBG_ template -# else -# define SIVPERLIN_CONCEPT_URBG template , std::is_unsigned>>>* = nullptr> -# define SIVPERLIN_CONCEPT_URBG_ template , std::is_unsigned>>>*> -# endif - - -// arbitrary value for increasing entropy -# ifndef SIVPERLIN_DEFAULT_Y -# define SIVPERLIN_DEFAULT_Y (0.12345) -# endif - -// arbitrary value for increasing entropy -# ifndef SIVPERLIN_DEFAULT_Z -# define SIVPERLIN_DEFAULT_Z (0.34567) -# endif - - -namespace siv -{ - template - class BasicPerlinNoise - { - public: - - static_assert(std::is_floating_point_v); - - /////////////////////////////////////// - // - // Typedefs - // - - using state_type = std::array; - - using value_type = Float; - - using default_random_engine = std::mt19937; - - using seed_type = typename default_random_engine::result_type; - - /////////////////////////////////////// - // - // Constructors - // - - SIVPERLIN_NODISCARD_CXX20 - constexpr BasicPerlinNoise() noexcept; - - SIVPERLIN_NODISCARD_CXX20 - explicit BasicPerlinNoise(seed_type seed); - - SIVPERLIN_CONCEPT_URBG - SIVPERLIN_NODISCARD_CXX20 - explicit BasicPerlinNoise(URBG&& urbg); - - /////////////////////////////////////// - // - // Reseed - // - - void reseed(seed_type seed); - - SIVPERLIN_CONCEPT_URBG - void reseed(URBG&& urbg); - - /////////////////////////////////////// - // - // Serialization - // - - [[nodiscard]] - constexpr const state_type& serialize() const noexcept; - - constexpr void deserialize(const state_type& state) noexcept; - - /////////////////////////////////////// - // - // Noise (The result is in the range [-1, 1]) - // - - [[nodiscard]] - value_type noise1D(value_type x) const noexcept; - - [[nodiscard]] - value_type noise2D(value_type x, value_type y) const noexcept; - - [[nodiscard]] - value_type noise3D(value_type x, value_type y, value_type z) const noexcept; - - /////////////////////////////////////// - // - // Noise (The result is remapped to the range [0, 1]) - // - - [[nodiscard]] - value_type noise1D_01(value_type x) const noexcept; - - [[nodiscard]] - value_type noise2D_01(value_type x, value_type y) const noexcept; - - [[nodiscard]] - value_type noise3D_01(value_type x, value_type y, value_type z) const noexcept; - - /////////////////////////////////////// - // - // Octave noise (The result can be out of the range [-1, 1]) - // - - [[nodiscard]] - value_type octave1D(value_type x, std::int32_t octaves, value_type persistence = value_type(0.5)) const noexcept; - - [[nodiscard]] - value_type octave2D(value_type x, value_type y, std::int32_t octaves, value_type persistence = value_type(0.5)) const noexcept; - - [[nodiscard]] - value_type octave3D(value_type x, value_type y, value_type z, std::int32_t octaves, value_type persistence = value_type(0.5)) const noexcept; - - /////////////////////////////////////// - // - // Octave noise (The result is clamped to the range [-1, 1]) - // - - [[nodiscard]] - value_type octave1D_11(value_type x, std::int32_t octaves, value_type persistence = value_type(0.5)) const noexcept; - - [[nodiscard]] - value_type octave2D_11(value_type x, value_type y, std::int32_t octaves, value_type persistence = value_type(0.5)) const noexcept; - - [[nodiscard]] - value_type octave3D_11(value_type x, value_type y, value_type z, std::int32_t octaves, value_type persistence = value_type(0.5)) const noexcept; - - /////////////////////////////////////// - // - // Octave noise (The result is clamped and remapped to the range [0, 1]) - // - - [[nodiscard]] - value_type octave1D_01(value_type x, std::int32_t octaves, value_type persistence = value_type(0.5)) const noexcept; - - [[nodiscard]] - value_type octave2D_01(value_type x, value_type y, std::int32_t octaves, value_type persistence = value_type(0.5)) const noexcept; - - [[nodiscard]] - value_type octave3D_01(value_type x, value_type y, value_type z, std::int32_t octaves, value_type persistence = value_type(0.5)) const noexcept; - - /////////////////////////////////////// - // - // Octave noise (The result is normalized to the range [-1, 1]) - // - - [[nodiscard]] - value_type normalizedOctave1D(value_type x, std::int32_t octaves, value_type persistence = value_type(0.5)) const noexcept; - - [[nodiscard]] - value_type normalizedOctave2D(value_type x, value_type y, std::int32_t octaves, value_type persistence = value_type(0.5)) const noexcept; - - [[nodiscard]] - value_type normalizedOctave3D(value_type x, value_type y, value_type z, std::int32_t octaves, value_type persistence = value_type(0.5)) const noexcept; - - /////////////////////////////////////// - // - // Octave noise (The result is normalized and remapped to the range [0, 1]) - // - - [[nodiscard]] - value_type normalizedOctave1D_01(value_type x, std::int32_t octaves, value_type persistence = value_type(0.5)) const noexcept; - - [[nodiscard]] - value_type normalizedOctave2D_01(value_type x, value_type y, std::int32_t octaves, value_type persistence = value_type(0.5)) const noexcept; - - [[nodiscard]] - value_type normalizedOctave3D_01(value_type x, value_type y, value_type z, std::int32_t octaves, value_type persistence = value_type(0.5)) const noexcept; - - private: - - state_type m_permutation; - }; - - using PerlinNoise = BasicPerlinNoise; - - namespace perlin_detail - { - //////////////////////////////////////////////// - // - // These functions are provided for consistency. - // You may get different results from std::shuffle() with different standard library implementations. - // - SIVPERLIN_CONCEPT_URBG - [[nodiscard]] - inline std::uint64_t Random(const std::uint64_t max, URBG&& urbg) - { - return (urbg() % (max + 1)); - } - - template - inline void Shuffle(RandomIt first, RandomIt last, URBG&& urbg) - { - if (first == last) - { - return; - } - - using difference_type = typename std::iterator_traits::difference_type; - - for (RandomIt it = first + 1; it < last; ++it) - { - const std::uint64_t n = static_cast(it - first); - std::iter_swap(it, first + static_cast(Random(n, std::forward(urbg)))); - } - } - // - //////////////////////////////////////////////// - - template - [[nodiscard]] - inline constexpr Float Fade(const Float t) noexcept - { - return t * t * t * (t * (t * 6 - 15) + 10); - } - - template - [[nodiscard]] - inline constexpr Float Lerp(const Float a, const Float b, const Float t) noexcept - { - return (a + (b - a) * t); - } - - template - [[nodiscard]] - inline constexpr Float Grad(const std::uint8_t hash, const Float x, const Float y, const Float z) noexcept - { - const std::uint8_t h = hash & 15; - const Float u = h < 8 ? x : y; - const Float v = h < 4 ? y : h == 12 || h == 14 ? x : z; - return ((h & 1) == 0 ? u : -u) + ((h & 2) == 0 ? v : -v); - } - - template - [[nodiscard]] - inline constexpr Float Remap_01(const Float x) noexcept - { - return (x * Float(0.5) + Float(0.5)); - } - - template - [[nodiscard]] - inline constexpr Float Clamp_11(const Float x) noexcept - { - return std::clamp(x, Float(-1.0), Float(1.0)); - } - - template - [[nodiscard]] - inline constexpr Float RemapClamp_01(const Float x) noexcept - { - if (x <= Float(-1.0)) - { - return Float(0.0); - } - else if (Float(1.0) <= x) - { - return Float(1.0); - } - - return (x * Float(0.5) + Float(0.5)); - } - - template - [[nodiscard]] - inline auto Octave1D(const Noise& noise, Float x, const std::int32_t octaves, const Float persistence) noexcept - { - using value_type = Float; - value_type result = 0; - value_type amplitude = 1; - - for (std::int32_t i = 0; i < octaves; ++i) - { - result += (noise.noise1D(x) * amplitude); - x *= 2; - amplitude *= persistence; - } - - return result; - } - - template - [[nodiscard]] - inline auto Octave2D(const Noise& noise, Float x, Float y, const std::int32_t octaves, const Float persistence) noexcept - { - using value_type = Float; - value_type result = 0; - value_type amplitude = 1; - - for (std::int32_t i = 0; i < octaves; ++i) - { - result += (noise.noise2D(x, y) * amplitude); - x *= 2; - y *= 2; - amplitude *= persistence; - } - - return result; - } - - template - [[nodiscard]] - inline auto Octave3D(const Noise& noise, Float x, Float y, Float z, const std::int32_t octaves, const Float persistence) noexcept - { - using value_type = Float; - value_type result = 0; - value_type amplitude = 1; - - for (std::int32_t i = 0; i < octaves; ++i) - { - result += (noise.noise3D(x, y, z) * amplitude); - x *= 2; - y *= 2; - z *= 2; - amplitude *= persistence; - } - - return result; - } - - template - [[nodiscard]] - inline constexpr Float MaxAmplitude(const std::int32_t octaves, const Float persistence) noexcept - { - using value_type = Float; - value_type result = 0; - value_type amplitude = 1; - - for (std::int32_t i = 0; i < octaves; ++i) - { - result += amplitude; - amplitude *= persistence; - } - - return result; - } - } - - /////////////////////////////////////// - - template - inline constexpr BasicPerlinNoise::BasicPerlinNoise() noexcept - : m_permutation{ 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 } {} - - template - inline BasicPerlinNoise::BasicPerlinNoise(const seed_type seed) - { - reseed(seed); - } - - template - SIVPERLIN_CONCEPT_URBG_ - inline BasicPerlinNoise::BasicPerlinNoise(URBG&& urbg) - { - reseed(std::forward(urbg)); - } - - /////////////////////////////////////// - - template - inline void BasicPerlinNoise::reseed(const seed_type seed) - { - reseed(default_random_engine{ seed }); - } - - template - SIVPERLIN_CONCEPT_URBG_ - inline void BasicPerlinNoise::reseed(URBG&& urbg) - { - std::iota(m_permutation.begin(), m_permutation.end(), uint8_t{ 0 }); - - perlin_detail::Shuffle(m_permutation.begin(), m_permutation.end(), std::forward(urbg)); - } - - /////////////////////////////////////// - - template - inline constexpr const typename BasicPerlinNoise::state_type& BasicPerlinNoise::serialize() const noexcept - { - return m_permutation; - } - - template - inline constexpr void BasicPerlinNoise::deserialize(const state_type& state) noexcept - { - m_permutation = state; - } - - /////////////////////////////////////// - - template - inline typename BasicPerlinNoise::value_type BasicPerlinNoise::noise1D(const value_type x) const noexcept - { - return noise3D(x, - static_cast(SIVPERLIN_DEFAULT_Y), - static_cast(SIVPERLIN_DEFAULT_Z)); - } - - template - inline typename BasicPerlinNoise::value_type BasicPerlinNoise::noise2D(const value_type x, const value_type y) const noexcept - { - return noise3D(x, - y, - static_cast(SIVPERLIN_DEFAULT_Z)); - } - - template - inline typename BasicPerlinNoise::value_type BasicPerlinNoise::noise3D(const value_type x, const value_type y, const value_type z) const noexcept - { - const value_type _x = std::floor(x); - const value_type _y = std::floor(y); - const value_type _z = std::floor(z); - - const std::int32_t ix = static_cast(_x) & 255; - const std::int32_t iy = static_cast(_y) & 255; - const std::int32_t iz = static_cast(_z) & 255; - - const value_type fx = (x - _x); - const value_type fy = (y - _y); - const value_type fz = (z - _z); - - const value_type u = perlin_detail::Fade(fx); - const value_type v = perlin_detail::Fade(fy); - const value_type w = perlin_detail::Fade(fz); - - const std::uint8_t A = (m_permutation[ix & 255] + iy) & 255; - const std::uint8_t B = (m_permutation[(ix + 1) & 255] + iy) & 255; - - const std::uint8_t AA = (m_permutation[A] + iz) & 255; - const std::uint8_t AB = (m_permutation[(A + 1) & 255] + iz) & 255; - - const std::uint8_t BA = (m_permutation[B] + iz) & 255; - const std::uint8_t BB = (m_permutation[(B + 1) & 255] + iz) & 255; - - const value_type p0 = perlin_detail::Grad(m_permutation[AA], fx, fy, fz); - const value_type p1 = perlin_detail::Grad(m_permutation[BA], fx - 1, fy, fz); - const value_type p2 = perlin_detail::Grad(m_permutation[AB], fx, fy - 1, fz); - const value_type p3 = perlin_detail::Grad(m_permutation[BB], fx - 1, fy - 1, fz); - const value_type p4 = perlin_detail::Grad(m_permutation[(AA + 1) & 255], fx, fy, fz - 1); - const value_type p5 = perlin_detail::Grad(m_permutation[(BA + 1) & 255], fx - 1, fy, fz - 1); - const value_type p6 = perlin_detail::Grad(m_permutation[(AB + 1) & 255], fx, fy - 1, fz - 1); - const value_type p7 = perlin_detail::Grad(m_permutation[(BB + 1) & 255], fx - 1, fy - 1, fz - 1); - - const value_type q0 = perlin_detail::Lerp(p0, p1, u); - const value_type q1 = perlin_detail::Lerp(p2, p3, u); - const value_type q2 = perlin_detail::Lerp(p4, p5, u); - const value_type q3 = perlin_detail::Lerp(p6, p7, u); - - const value_type r0 = perlin_detail::Lerp(q0, q1, v); - const value_type r1 = perlin_detail::Lerp(q2, q3, v); - - return perlin_detail::Lerp(r0, r1, w); - } - - /////////////////////////////////////// - - template - inline typename BasicPerlinNoise::value_type BasicPerlinNoise::noise1D_01(const value_type x) const noexcept - { - return perlin_detail::Remap_01(noise1D(x)); - } - - template - inline typename BasicPerlinNoise::value_type BasicPerlinNoise::noise2D_01(const value_type x, const value_type y) const noexcept - { - return perlin_detail::Remap_01(noise2D(x, y)); - } - - template - inline typename BasicPerlinNoise::value_type BasicPerlinNoise::noise3D_01(const value_type x, const value_type y, const value_type z) const noexcept - { - return perlin_detail::Remap_01(noise3D(x, y, z)); - } - - /////////////////////////////////////// - - template - inline typename BasicPerlinNoise::value_type BasicPerlinNoise::octave1D(const value_type x, const std::int32_t octaves, const value_type persistence) const noexcept - { - return perlin_detail::Octave1D(*this, x, octaves, persistence); - } - - template - inline typename BasicPerlinNoise::value_type BasicPerlinNoise::octave2D(const value_type x, const value_type y, const std::int32_t octaves, const value_type persistence) const noexcept - { - return perlin_detail::Octave2D(*this, x, y, octaves, persistence); - } - - template - inline typename BasicPerlinNoise::value_type BasicPerlinNoise::octave3D(const value_type x, const value_type y, const value_type z, const std::int32_t octaves, const value_type persistence) const noexcept - { - return perlin_detail::Octave3D(*this, x, y, z, octaves, persistence); - } - - /////////////////////////////////////// - - template - inline typename BasicPerlinNoise::value_type BasicPerlinNoise::octave1D_11(const value_type x, const std::int32_t octaves, const value_type persistence) const noexcept - { - return perlin_detail::Clamp_11(octave1D(x, octaves, persistence)); - } - - template - inline typename BasicPerlinNoise::value_type BasicPerlinNoise::octave2D_11(const value_type x, const value_type y, const std::int32_t octaves, const value_type persistence) const noexcept - { - return perlin_detail::Clamp_11(octave2D(x, y, octaves, persistence)); - } - - template - inline typename BasicPerlinNoise::value_type BasicPerlinNoise::octave3D_11(const value_type x, const value_type y, const value_type z, const std::int32_t octaves, const value_type persistence) const noexcept - { - return perlin_detail::Clamp_11(octave3D(x, y, z, octaves, persistence)); - } - - /////////////////////////////////////// - - template - inline typename BasicPerlinNoise::value_type BasicPerlinNoise::octave1D_01(const value_type x, const std::int32_t octaves, const value_type persistence) const noexcept - { - return perlin_detail::RemapClamp_01(octave1D(x, octaves, persistence)); - } - - template - inline typename BasicPerlinNoise::value_type BasicPerlinNoise::octave2D_01(const value_type x, const value_type y, const std::int32_t octaves, const value_type persistence) const noexcept - { - return perlin_detail::RemapClamp_01(octave2D(x, y, octaves, persistence)); - } - - template - inline typename BasicPerlinNoise::value_type BasicPerlinNoise::octave3D_01(const value_type x, const value_type y, const value_type z, const std::int32_t octaves, const value_type persistence) const noexcept - { - return perlin_detail::RemapClamp_01(octave3D(x, y, z, octaves, persistence)); - } - - /////////////////////////////////////// - - template - inline typename BasicPerlinNoise::value_type BasicPerlinNoise::normalizedOctave1D(const value_type x, const std::int32_t octaves, const value_type persistence) const noexcept - { - return (octave1D(x, octaves, persistence) / perlin_detail::MaxAmplitude(octaves, persistence)); - } - - template - inline typename BasicPerlinNoise::value_type BasicPerlinNoise::normalizedOctave2D(const value_type x, const value_type y, const std::int32_t octaves, const value_type persistence) const noexcept - { - return (octave2D(x, y, octaves, persistence) / perlin_detail::MaxAmplitude(octaves, persistence)); - } - - template - inline typename BasicPerlinNoise::value_type BasicPerlinNoise::normalizedOctave3D(const value_type x, const value_type y, const value_type z, const std::int32_t octaves, const value_type persistence) const noexcept - { - return (octave3D(x, y, z, octaves, persistence) / perlin_detail::MaxAmplitude(octaves, persistence)); - } - - /////////////////////////////////////// - - template - inline typename BasicPerlinNoise::value_type BasicPerlinNoise::normalizedOctave1D_01(const value_type x, const std::int32_t octaves, const value_type persistence) const noexcept - { - return perlin_detail::Remap_01(normalizedOctave1D(x, octaves, persistence)); - } - - template - inline typename BasicPerlinNoise::value_type BasicPerlinNoise::normalizedOctave2D_01(const value_type x, const value_type y, const std::int32_t octaves, const value_type persistence) const noexcept - { - return perlin_detail::Remap_01(normalizedOctave2D(x, y, octaves, persistence)); - } - - template - inline typename BasicPerlinNoise::value_type BasicPerlinNoise::normalizedOctave3D_01(const value_type x, const value_type y, const value_type z, const std::int32_t octaves, const value_type persistence) const noexcept - { - return perlin_detail::Remap_01(normalizedOctave3D(x, y, z, octaves, persistence)); - } -} - -# undef SIVPERLIN_NODISCARD_CXX20 -# undef SIVPERLIN_CONCEPT_URBG -# undef SIVPERLIN_CONCEPT_URBG_ diff --git a/src/helpers/chunks.cpp b/src/helpers/chunks.cpp index 65083a3..92fdcd7 100644 --- a/src/helpers/chunks.cpp +++ b/src/helpers/chunks.cpp @@ -9,9 +9,12 @@ #include #include +#define FNL_IMPL +#include "../FastNoiseLite.h" + #define HUMIDITY_OFFSET 12.3f #define CAVE_OFFSET 45.6f -#define SCALE 0.01f +#define SCALE 0.1f #define CAVE_COEFF 0.06 #define EDGES_FADE 64 #define CLOUD_SCALE 0.25f @@ -19,7 +22,9 @@ #define BIOME_FOREST 0 #define BIOME_TAIGA 1 -static const siv::PerlinNoise perlin; +static fnl_state perlin; +static fnl_state perlin2; +static fnl_state perlinLofi; static int world_type = 0; @@ -31,10 +36,10 @@ std::vector BLOCKS = { BlockDef{ "sand", R_Normal, B_Dirt, 2, 0, 4}, BlockDef{ "water", R_Translucent, B_Stone, 0, 0, 14}, BlockDef{ "planks", R_Normal, B_Wood, 3, 0, 11}, - BlockDef{ "gray_bricks", R_Normal, B_Stone, 5, 1, 16}, - BlockDef{ "red_bricks", R_Normal, B_Stone, 5, 1, 17}, - BlockDef{ "blue_bricks", R_Normal, B_Stone, 5, 1, 18}, - BlockDef{ "green_bricks", R_Normal, B_Stone, 5, 1, 19}, + BlockDef{ "stone_bricks", R_Normal, B_Stone, 5, 1, 16}, + BlockDef{ "copper_block", R_Normal, B_Stone, 5, 1, 17}, + BlockDef{ "silver_block", R_Normal, B_Stone, 5, 1, 18}, + BlockDef{ "gold_block", R_Normal, B_Stone, 5, 1, 19}, BlockDef{ "glass", R_Translucent, B_Stone, 3, 1, 12}, BlockDef{ "log", R_TriSide, B_Wood, 5, 0, 10, 9, 10}, BlockDef{ "spruce_planks", R_Normal, B_Wood, 3, 0, 13}, @@ -67,24 +72,38 @@ int GetNumericIDFromString(std::string s) { } static std::bitset<256> marked; -static int GetBlockRegularWorld(int x, int y, int z) { - float fade_x = (fmax(EDGES_FADE - x, 0) + fmax(EDGES_FADE - WORLD_SIZE_BLOCKS + x, 0)) / (float)EDGES_FADE; - float fade_z = (fmax(EDGES_FADE - z, 0) + fmax(EDGES_FADE - WORLD_SIZE_BLOCKS + z, 0)) / (float)EDGES_FADE; - float fade = 1 - (fade_x + fade_z); +static int GetBlockRegularWorld(int _x, int y, int _z) { + int x = _x + 0; + int z = _z + 0; + const int SEA_HEIGHT = 64; + const int BEACH_DEPTH = 3; + const float heightBias = 24; + float p0 = fnlGetNoise3D(&perlin, (float)x, y / 2.0f, z); + float p1 = fnlGetNoise3D(&perlin2, x, y / 2.0f, z); + float pr = fnlGetNoise3D(&perlinLofi, x, y / 2.0f, z)*12.75f; + float P = 0; + if(pr >= 1) P = p1; + if(pr <= 0) P = p0; + if(pr>0&&pr<1) P = Lerp(p0, p1, pr); + float density = P + (WORLD_HEIGHT-(y+60)) / heightBias; + if(density > 0.5f) { + return BLOCK_STONE; + } + if(density > 0) { + return BLOCK_DIRT; + } + if(y < SEA_HEIGHT) { + return BLOCK_WATERS; + } + //float height0 = (fnlGetNoise3D(&perlin, x, y, z) + 1.0f ) / 2.0f * 8.0f; + //float height1 = (fnlGetNoise3D(&perlin2, x, y, z) + 1.0f ) / 2.0f * 16.0f; - const int SEA_HEIGHT = 32; // sea surface y - const int BEACH_DEPTH = 3; // how many blocks below surface become sand + //int height = Lerp(height0, height1, fnlGetNoise2D(&perlinLofi, x, z)) + 26 + 48; + //float dist = Vector2Distance({(float)x, (float)z}, {MAX_WORLD_SIZE*CHUNK_SIZE/2, MAX_WORLD_SIZE*CHUNK_SIZE/2}); - float height0 = (perlin.noise2D((double)x * 1.5f * SCALE, (double)z * 1.5f * SCALE) + 1.0f ) / 2.0f * 16.0f; - float mountains = pow((perlin.noise2D((double)x * 0.5f, (double)z * 0.5f * SCALE) + 1.0f ) / 2.0f, 16); - float height1 = (perlin.noise2D((double)x * 4.5f * SCALE, (double)z * 4.5f * SCALE) + 1.0f ) / 2.0f * 24.0f * mountains; - - int height = floor((height0 + height1) * fade) + 26; - - float caveNoise = fabs(perlin.noise3D((double)x * 1.0f * SCALE + CAVE_OFFSET, (double)y * 4.0f * SCALE + CAVE_OFFSET, (double)z * 1.0f * SCALE + CAVE_OFFSET)); - - if (y <= height) { - if(caveNoise < 0.02f) return BLOCK_AIR; + //height = Lerp(32, height, fmin(1.0f, -fmin(0.0f, dist - (MAX_WORLD_SIZE*CHUNK_SIZE/2)-48)/96.0f)); + /*if (y <= height) { + //if(caveNoise < 0.02f) return BLOCK_AIR; if (y == height) { if (height <= SEA_HEIGHT) { return BLOCK_SAND; @@ -96,13 +115,13 @@ static int GetBlockRegularWorld(int x, int y, int z) { if (y > height - BEACH_DEPTH && height <= SEA_HEIGHT + 2) { return BLOCK_SAND; } - if(caveNoise < 0.2f || y < 4) return BLOCK_STONE; + //if(caveNoise < 0.2f || y < 4) return BLOCK_STONE; return BLOCK_DIRT; } if (y <= SEA_HEIGHT && height < SEA_HEIGHT) { return BLOCK_WATERS; - } + }*/ return BLOCK_AIR; } @@ -162,6 +181,7 @@ int GetBLight(World &world, int x, int y, int z) { int skyLight = light & 0xF; return skyLight; } +Color GetSunlightColor(); Color GetLight(World &world, int x, int y, int z) { if(CheckOOBWorld(x, y, z)) return {0, 0, 0, 0}; int locX = x % CHUNK_SIZE; @@ -173,24 +193,41 @@ Color GetLight(World &world, int x, int y, int z) { Color r = {((light >> 8) & 0xF) * 16, 0, 0, 255}; Color g = {0, ((light >> 4) & 0xF) * 16, 0, 255}; Color b = {0, 0, ((light >> 0) & 0xF) * 16, 255}; + Color sun = GetSunlightColor(); return { - fmin((int)skyLight + (int)r.r, 255), - fmin((int)skyLight + (int)g.g, 255), - fmin((int)skyLight + (int)b.b, 255), + fmax((int)skyLight * (sun.r/255.0f), (int)r.r), + fmax((int)skyLight * (sun.g/255.0f), (int)g.g), + fmax((int)skyLight * (sun.b/255.0f), (int)b.b), 255 }; } +Color GetLightMesher(World &world, int x, int y, int z) { + if(CheckOOBWorld(x, y, z)) return {0, 0, 0, 0}; + int locX = x % CHUNK_SIZE; + int locZ = z % CHUNK_SIZE; + int cx = x / CHUNK_SIZE; + int cz = z / CHUNK_SIZE; + uint16_t light = world.chunks[GetIndexWorld(cx, cz)].light[GetIndexChunk(locX, y, locZ)]; + int skyLight = powf(((light >> 12) & 0xF) / 15.0f, 1) * 255; + return { + ((light >> 8) & 0xF) * 16, + ((light >> 4) & 0xF) * 16, + ((light >> 0) & 0xF) * 16, + skyLight + }; +} bool CanTick(int blockType) { // TODO: make smarter in case other blocks can tick too! return blockType == BLOCK_SAND; } bool GetCloud(int x, int z) { - return (perlin.noise2D((x / 8) * 1.5f * CLOUD_SCALE, (z / 8) * 1.5f * CLOUD_SCALE) + 1.0f) / 2.0f > 0.5f; + //return (perlin.noise2D((x / 8) * 1.5f * CLOUD_SCALE, (z / 8) * 1.5f * CLOUD_SCALE) + 1.0f) / 2.0f > 0.5f; + return false; } static int GetBlockCaveWorld(int x, int y, int z) { - float caveNoise = (perlin.noise3D((float)x * 3.0f * SCALE + CAVE_OFFSET, (float)y * 3.0f * SCALE + CAVE_OFFSET, (float)z * 3.0f * SCALE + CAVE_OFFSET) + 1.0f) / 2.0f; + /*float caveNoise = (perlin.noise3D((float)x * 3.0f * SCALE + CAVE_OFFSET, (float)y * 3.0f * SCALE + CAVE_OFFSET, (float)z * 3.0f * SCALE + CAVE_OFFSET) + 1.0f) / 2.0f; if(caveNoise > 0.5f) { return BLOCK_STONE; - } + }*/ return BLOCK_AIR; } static int has_block(int x, int y, int z) @@ -311,8 +348,24 @@ void SetLight(World &world, int x, int y, int z, uint8_t sky, uint8_t r, uint8_t } void InitWorldgen(int worldType) { - const siv::PerlinNoise::seed_type seed = 0u; - const siv::PerlinNoise perlin{ seed }; + perlin = fnlCreateState(); + perlin.noise_type = FNL_NOISE_OPENSIMPLEX2; + perlin.fractal_type = FNL_FRACTAL_FBM; + perlin.frequency = 0.00522f; + perlin.octaves = 8; + + perlinLofi = fnlCreateState(); + perlinLofi.noise_type = FNL_NOISE_OPENSIMPLEX2; + perlinLofi.fractal_type = FNL_FRACTAL_FBM; + perlinLofi.frequency = 0.01671f; + perlinLofi.octaves = 4; + + perlin2 = fnlCreateState(); + perlin2.noise_type = FNL_NOISE_OPENSIMPLEX2; + perlin2.fractal_type = FNL_FRACTAL_FBM; + perlin2.frequency = 0.00522f; + perlin2.octaves = 8; + constexpr size_t MAX = 128; // allowed range: 0..MAX-1 for (int i = 0; i < BLOCKS.size(); i++) { @@ -332,16 +385,11 @@ Chunk GenerateChunk(int _x, int _y) { new_chunk.x = _x; new_chunk.z = _y; memset(&new_chunk.light, 0, sizeof(new_chunk.light)); + for (int y = 0; y < WORLD_HEIGHT; y++) for (int x = 0; x < CHUNK_SIZE; x++) - { - for (int y = 0; y < WORLD_HEIGHT; y++) - { - for (int z = 0; z < CHUNK_SIZE; z++) - { - int id = has_block(_x * CHUNK_SIZE + x,y,_y * CHUNK_SIZE + z); - SetBlockChunk(&new_chunk, x, y, z, id); - } - } + for (int z = 0; z < CHUNK_SIZE; z++) { + int id = has_block(_x * CHUNK_SIZE + x,y,_y * CHUNK_SIZE + z); + SetBlockChunk(&new_chunk, x, y, z, id); } return new_chunk; } @@ -357,33 +405,8 @@ void GenerateWorldAdditional(World &world) { Chunk c = world.chunks[GetIndexWorld(x / CHUNK_SIZE, z / CHUNK_SIZE)]; int highestY = c.highestBlock[GetIndexChunk2D(x % CHUNK_SIZE, z % CHUNK_SIZE)]; int b = fetch_block(c, x % CHUNK_SIZE, highestY, z % CHUNK_SIZE); - for (int _ = 0; _ < GetRandomValue(0, 6); _++) - { - if(GetRandomValue(0, 800) == 0) { - int max = GetRandomValue(10, 120); - Vector3 pos = {x, GetRandomValue(12, WORLD_HEIGHT-32), z}; - Vector3 direction = {GetRandomValue(-100, 100) / 100.0f, GetRandomValue(-100, -5) / 100.0f, GetRandomValue(-100, 100) / 100.0f}; - int radius = 2; - for (int _ = 0; _ < max; _++) - { - for (int x = -radius; x < radius; x++) - { - for (int y = -radius; y < radius; y++) - { - for (int z = -radius; z < radius; z++) - { - if(Vector3Distance({pos.x + x, pos.y + y, pos.z + z}, pos) <= radius) { - if(!CheckOOBWorld(pos.x + x, pos.y + y, pos.z + z)) { - SetBlock(world, pos.x + x, pos.y + y, pos.z + z, 0); - } - } - } - } - } - direction += {GetRandomValue(-100, 100) / 100.0f, GetRandomValue(-100, -5) / 100.0f, GetRandomValue(-100, 100) / 100.0f}; - pos += direction; - } - } + if(b == BLOCK_DIRT) { + SetBlock(world, x, highestY, z, BLOCK_GRASS); } for (int _ = 0; _ < GetRandomValue(8, 24); _++) { @@ -424,7 +447,7 @@ void GenerateWorldAdditional(World &world) { Chunk c = world.chunks[GetIndexWorld(x / CHUNK_SIZE, z / CHUNK_SIZE)]; int highestY = c.highestBlock[GetIndexChunk2D(x % CHUNK_SIZE, z % CHUNK_SIZE)]; int b = fetch_block(c, x % CHUNK_SIZE, highestY, z % CHUNK_SIZE); - if(b == BLOCK_GRASS && GetRandomValue(0, 100) < 4 && biome == BIOME_FOREST) { // Regular trees + if(b == BLOCK_GRASS && GetRandomValue(0, 100) == 0 && biome == BIOME_FOREST) { // Regular trees SetBlock(world, x, highestY, z, BLOCK_DIRT); int maxY = GetRandomValue(5, 7); for (int y = 1; y < maxY; y++) @@ -441,7 +464,7 @@ void GenerateWorldAdditional(World &world) { SetBlock(world, x, wy, z, 12); // log } } - if(b == BLOCK_GRASS && GetRandomValue(0, 100) < 2 && biome == BIOME_TAIGA) { // Spruce + if(b == BLOCK_GRASS && GetRandomValue(0, 100) == 0 && biome == BIOME_TAIGA) { // Spruce SetBlock(world, x, highestY, z, BLOCK_DIRT); int maxY = 8; for (int y = 1; y < maxY; y++) @@ -658,7 +681,6 @@ void RebuildLighting(World &world, int startX, int startZ) { } } } - std::cout << nodes.size() << std::endl; while (!nodes.empty()) { LightNode node = nodes.front(); nodes.pop(); @@ -696,7 +718,6 @@ void RebuildLighting(World &world, int startX, int startZ) { if (CheckOOBWorld(x, y, z)) continue; if(chunk.blocks[i] != 18 && chunk.blocks[i] != 21) continue; Vector3I pos = { x + chunk.x * CHUNK_SIZE, y, z + chunk.z * CHUNK_SIZE }; - std::cout << pos.y << std::endl; LightNode node{pos, 15}; nodesR.push(node); } @@ -704,7 +725,6 @@ void RebuildLighting(World &world, int startX, int startZ) { } while (!nodesR.empty()) { - std::cout << nodesR.size() << std::endl; LightNode node = nodesR.front(); nodesR.pop(); @@ -741,7 +761,6 @@ void RebuildLighting(World &world, int startX, int startZ) { if (CheckOOBWorld(x, y, z)) continue; if(chunk.blocks[i] != 19 && chunk.blocks[i] != 21) continue; Vector3I pos = { x + chunk.x * CHUNK_SIZE, y, z + chunk.z * CHUNK_SIZE }; - std::cout << pos.y << std::endl; LightNode node{pos, 15}; nodesG.push(node); } @@ -749,7 +768,6 @@ void RebuildLighting(World &world, int startX, int startZ) { } while (!nodesG.empty()) { - std::cout << nodesG.size() << std::endl; LightNode node = nodesG.front(); nodesG.pop(); @@ -786,7 +804,6 @@ void RebuildLighting(World &world, int startX, int startZ) { if (CheckOOBWorld(x, y, z)) continue; if(chunk.blocks[i] != 20 && chunk.blocks[i] != 21) continue; Vector3I pos = { x + chunk.x * CHUNK_SIZE, y, z + chunk.z * CHUNK_SIZE }; - std::cout << pos.y << std::endl; LightNode node{pos, 15}; nodesB.push(node); } @@ -794,7 +811,6 @@ void RebuildLighting(World &world, int startX, int startZ) { } while (!nodesB.empty()) { - std::cout << nodesB.size() << std::endl; LightNode node = nodesB.front(); nodesB.pop(); @@ -887,6 +903,55 @@ ChunkRenderData GenerateCRDTranslucent(Chunk chunk, World &world) { new_chunk.sides[i2] = 0xFF; continue; } + if(BLOCKS[fetch_block(chunk, _x, y, _z)].name == "water") { + continue; + } + int x = _x + chunk.x * CHUNK_SIZE; + int z = _z + chunk.z * CHUNK_SIZE; + bool l = (_x > 0) ? !TestMask(mask, i2-1) : !TestAirMaskWorld(world, x - 1, y, z); + bool r = (_x < CHUNK_SIZE-1) ? !TestMask(mask, i2+1) : !TestAirMaskWorld(world, x + 1, y, z); + bool u = (y==WORLD_HEIGHT-1) ? false : !TestMask(mask, i2+CHUNK_SIZE_SQR); + bool d = (y==0) ? true : !TestMask(mask, i2-CHUNK_SIZE_SQR); + bool b = (_z==0) ? !TestAirMaskWorld(world, x, y, z - 1) : !TestMask(mask, i2-CHUNK_SIZE); + bool f = (_z==CHUNK_SIZE-1) ? !TestAirMaskWorld(world, x, y, z + 1) : !TestMask(mask, i2+CHUNK_SIZE); + new_chunk.sides[i2] = pack6( + !l, + !r, + !u, + !d, + !b, + !f + ); + } + } + return new_chunk; +} + +//Generates a CRD for water (ChunkRenderData). Outputs the CRD. +ChunkRenderData GenerateCRDWater(Chunk chunk, World &world) { + struct ChunkRenderData new_chunk = { 0 }; + uint16_t *mask0= chunk.opaqueMask; + uint16_t *mask = chunk.airMask; + for (int step = 0; step < CHUNK_DATA_SIZE/16; ++step) + { + uint16_t m = ~(mask[step]); + if(m == 0) continue; + + while (m) { + int bit = __builtin_ctz(m); + m &= m - 1; + int i2 = (step<<4) + bit; + int _x = bit; + int y = step >> 4; + int _z = step & 0xF; + + if (TestMask(mask0, i2)) { + new_chunk.sides[i2] = 0; + continue; + }; + if(BLOCKS[fetch_block(chunk, _x, y, _z)].name != "water") { + continue; + } int x = _x + chunk.x * CHUNK_SIZE; int z = _z + chunk.z * CHUNK_SIZE; bool l = (_x > 0) ? !TestMask(mask, i2-1) : !TestAirMaskWorld(world, x - 1, y, z); @@ -957,6 +1022,7 @@ void SaveWorld(World &world, const char* path) { } void Debug_Write(const std::string &stuff); + bool LoadWorld(World &world, const char* path) { std::ifstream data(path, std::ios::binary); if (!data) return false; @@ -986,19 +1052,22 @@ bool LoadWorld(World &world, const char* path) { return false; } } - Chunk *c = &world.chunks[i]; + Chunk c = {0}; + c.x = i % 16; + c.z = i >> 4; int outIndex = 0; for (size_t p = 0; p + 1 < size; p += 2) { uint8_t count = temp[p]; uint8_t value = temp[p + 1]; for (uint8_t k = 0; k < count; ++k) { - SetBlockChunkFast(c, outIndex++, value); + SetBlockChunkFast(&c, outIndex++, value); } } while (outIndex < CHUNK_DATA_SIZE) { - SetBlockChunkFast(c, outIndex++, 0); + SetBlockChunkFast(&c, outIndex++, 0); } - RebuildHeightmap(*c); + RebuildHeightmap(c); + memcpy(&world.chunks[i], &c, sizeof(c)); } free(temp); return true; diff --git a/src/helpers/common.hpp b/src/helpers/common.hpp index 1e7f66a..49d4fd2 100644 --- a/src/helpers/common.hpp +++ b/src/helpers/common.hpp @@ -11,7 +11,6 @@ #endif #include #include "glfw_keycodes_to_string.h" -#include "../PerlinNoise.hpp" #include "raylib.h" #include "raymath.h" #include @@ -76,9 +75,9 @@ #define GAME_NAME "CubeGame" #define GAME_VERSION_INT 0 #define DEFAULT_FONT_SIZE 16 -#define TPS 30.0 +#define TPS 30 #define TPS_DIV 1.0 / TPS -#define RENDER_DISTANCE 5 +#define RENDER_DISTANCE 16 #define RENDER_DISTANCE_SQUARED RENDER_DISTANCE*RENDER_DISTANCE #define MAX_HP 100 #define PATH_APPEND "resources/" @@ -87,6 +86,8 @@ #define INVENTORY_WIDTH 8 #define INVENTORY_HEIGHT 6 #define INVENTORY_SIZE INVENTORY_WIDTH*INVENTORY_HEIGHT +#define WORLD_TIME_SECONDS (24*60) +#define WORLD_TIME_TICKS WORLD_TIME_SECONDS*TPS enum BlockType { B_Wood, B_Stone, @@ -311,7 +312,9 @@ int GetSkyLight(World&world,int x,int y,int z); int GetRLight(World&world,int x,int y,int z); int GetGLight(World&world,int x,int y,int z); int GetBLight(World&world,int x,int y,int z); +Color GetSunlightColor(); Color GetLight(World&world,int x,int y,int z); +Color GetLightMesher(World&world,int x,int y,int z); bool CanTick(int blockType); bool GetCloud(int x,int z); bool IsTranslucent(int blockType); @@ -333,6 +336,7 @@ void RebuildLighting(World&world,int startX,int startZ); #if !defined(SERVER) ChunkRenderData GenerateCRDOpaque(Chunk&chunk,World&world); ChunkRenderData GenerateCRDTranslucent(Chunk chunk,World&world); +ChunkRenderData GenerateCRDWater(Chunk chunk,World&world); #endif void SaveWorld(World&world,const char *path); bool LoadWorld(World&world,const char *path); @@ -444,10 +448,12 @@ const char *Pathify(const char *src); const char *PathifyUser(const char *src); #if !defined(SERVER) void DrawCubeTexture(Texture2D texture,Vector3 position,float width,float height,float length,Color color,int offsetX,int offsetY,int sizeX,int sizeY); -void DrawCubeBlock(Texture2D texture,Vector3 position,float width,float height,float length,BlockDef def); +void DrawCubeBlock(Texture2D texture,Vector3 position,float width,float height,float length,BlockDef def,Color tint); void DrawTextCodepoint3D(Font font,int codepoint,Vector3 position,float fontSize,bool backface,Color tint); void DrawText3D(Font font,const char *text,Vector3 position,float fontSize,float fontSpacing,float lineSpacing,bool backface,Color tint); #endif +RenderTexture2D LoadRenderTextureDepthTex(int width,int height); +void UnloadRenderTextureDepthTex(RenderTexture2D target); inline uint8_t pack6(bool b0,bool b1,bool b2,bool b3,bool b4,bool b5){ return (uint8_t)( ((uint8_t)(b0 ? 1 : 0) << 0) | @@ -619,7 +625,7 @@ void HotbarAddItemLots(Item *registry,int damage,int amount); void InitHotbar(); void DrawHotbar(); InventoryItem HotbarGetSelected(); -void DrawSelectedItem(); +void DrawSelectedItem(Color tint); void CloseInventory(); void UpdateHotbar(); void LocaleUpdate(); diff --git a/src/helpers/entities.cpp b/src/helpers/entities.cpp index 74fe434..5c53570 100644 --- a/src/helpers/entities.cpp +++ b/src/helpers/entities.cpp @@ -363,7 +363,7 @@ void DrawEntities(float dt) { DrawCube(pos_lerped, 1, 1, 1, RED); } if(ent.type == 4) { - DrawCubeBlock(terrain, pos_lerped, 1,1,1, GetBlockDefinition(ent.data[1])); + DrawCubeBlock(terrain, pos_lerped, 1,1,1, GetBlockDefinition(ent.data[1]), WHITE); } } } diff --git a/src/helpers/input.cpp b/src/helpers/input.cpp index edfc81f..63268e9 100644 --- a/src/helpers/input.cpp +++ b/src/helpers/input.cpp @@ -63,7 +63,7 @@ Vector2 InputGetWalkAxis() { float y = 0; if(isJoystick) { x = GetGamepadAxisMovement(0, GAMEPAD_AXIS_LEFT_X); - y = GetGamepadAxisMovement(0, GAMEPAD_AXIS_LEFT_Y); + y = -GetGamepadAxisMovement(0, GAMEPAD_AXIS_LEFT_Y); if(abs(x) < 0.5f) { x = 0; } @@ -84,8 +84,8 @@ Vector2 InputGetLookAxis() { float x = 0; float y = 0; if(isJoystick) { - x = GetGamepadAxisMovement(0, GAMEPAD_AXIS_RIGHT_X); - y = GetGamepadAxisMovement(0, GAMEPAD_AXIS_RIGHT_Y); + x = GetGamepadAxisMovement(0, GAMEPAD_AXIS_RIGHT_X)*3.0f; + y = GetGamepadAxisMovement(0, GAMEPAD_AXIS_RIGHT_Y)*3.0f; if(abs(x) < 0.1f) { x = 0; } @@ -108,6 +108,7 @@ Vector2 InputGetDPAD() { if (IsGamepadButtonPressed(0, GAMEPAD_BUTTON_LEFT_FACE_RIGHT)) { x = 1; } if (IsGamepadButtonPressed(0, GAMEPAD_BUTTON_LEFT_FACE_LEFT)) { x = -1; } } + return {x, y}; } void InputWriteControls() { @@ -135,7 +136,6 @@ void InputInit() { { controls[key] = val; } - swap_mouse = config["Swap mouse buttons"].as(); } diff --git a/src/helpers/inventory.cpp b/src/helpers/inventory.cpp index 30a5525..fcc0030 100644 --- a/src/helpers/inventory.cpp +++ b/src/helpers/inventory.cpp @@ -441,7 +441,7 @@ void DrawHotbar() { InventoryItem HotbarGetSelected() { return hotbar[selected]; } -void DrawSelectedItem() { +void DrawSelectedItem(Color tint) { InventoryItem item = hotbar[selected]; Vector3 center = {-0.75f, -0.45f, 0.5f}; rlPushMatrix(); @@ -458,16 +458,16 @@ void DrawSelectedItem() { rlRotatef(-45, 1, 0, 0); rlRotatef(25, 0, 0, 1); - DrawCubeTexture(playerTex, {0, -12*PIXUNIT/2, 0}, 4*PIXUNIT, 12*PIXUNIT, 4*PIXUNIT, WHITE, 44,20,4,4); + DrawCubeTexture(playerTex, {0, -12*PIXUNIT/2, 0}, 4*PIXUNIT, 12*PIXUNIT, 4*PIXUNIT, tint, 44,20,4,4); if(item.item != nullptr) { if(item.item->type == IType_Block) { - DrawCubeBlock(terrain, {0, -12*PIXUNIT - 0.25f, 0}, 0.5f, 0.5f, 0.5f, GetBlockDefinition(item.damage)); + DrawCubeBlock(terrain, {0, -12*PIXUNIT - 0.25f, 0}, 0.5f, 0.5f, 0.5f, GetBlockDefinition(item.damage), tint); } else { UVCorners left = GetUVTex(item.item->texture); rlSetTexture(item_atlas.id); rlBegin(RL_QUADS); - rlColor4ub(255, 255, 255, 255); + rlColor4ub(tint.r, tint.g, tint.b, 255); rlNormal3f(1.0f, 0.0f, 0.0f); const float size = 0.5f; rlTexCoord2f(left.corner0.x, left.corner0.y); rlVertex3f(0, -12*PIXUNIT - size, 0.25f - size); diff --git a/src/helpers/mesher.cpp b/src/helpers/mesher.cpp index b4a163c..4925c8f 100644 --- a/src/helpers/mesher.cpp +++ b/src/helpers/mesher.cpp @@ -72,7 +72,7 @@ MeshData GenerateChunkMesh(World &world, ChunkRenderData chunkRenderData, Chunk positions.push_back(verts[3]); normals.push_back(normal); - Color clr = GetLight(world, wx-1, wy, wz); + Color clr = GetLightMesher(world, wx-1, wy, wz); colors.push_back(clr); uvs.push_back(corners[0]); @@ -112,7 +112,7 @@ MeshData GenerateChunkMesh(World &world, ChunkRenderData chunkRenderData, Chunk positions.push_back(verts[3]); normals.push_back(normal); - Color clr = GetLight(world, wx+1, wy, wz); + Color clr = GetLightMesher(world, wx+1, wy, wz); colors.push_back(clr); uvs.push_back(corners[0]); @@ -152,7 +152,7 @@ MeshData GenerateChunkMesh(World &world, ChunkRenderData chunkRenderData, Chunk positions.push_back(verts[3]); normals.push_back(normal); - Color clr = GetLight(world, wx, wy-1, wz); + Color clr = GetLightMesher(world, wx, wy-1, wz); colors.push_back(clr); uvs.push_back(corners[0]); @@ -192,7 +192,7 @@ MeshData GenerateChunkMesh(World &world, ChunkRenderData chunkRenderData, Chunk positions.push_back(verts[3]); normals.push_back(normal); - Color clr = GetLight(world, wx, wy+1, wz); + Color clr = GetLightMesher(world, wx, wy+1, wz); colors.push_back(clr); uvs.push_back(corners[0]); @@ -232,7 +232,7 @@ MeshData GenerateChunkMesh(World &world, ChunkRenderData chunkRenderData, Chunk positions.push_back(verts[3]); normals.push_back(normal); - Color clr = GetLight(world, wx, wy, wz+1); + Color clr = GetLightMesher(world, wx, wy, wz+1); colors.push_back(clr); uvs.push_back(corners[0]); @@ -272,7 +272,7 @@ MeshData GenerateChunkMesh(World &world, ChunkRenderData chunkRenderData, Chunk positions.push_back(verts[3]); normals.push_back(normal); - Color clr = GetLight(world, wx, wy, wz-1); + Color clr = GetLightMesher(world, wx, wy, wz-1); colors.push_back(clr); uvs.push_back(corners[0]); diff --git a/src/helpers/utils.cpp b/src/helpers/utils.cpp index b1a999e..5b1dd8a 100644 --- a/src/helpers/utils.cpp +++ b/src/helpers/utils.cpp @@ -87,7 +87,7 @@ void DrawCubeTexture(Texture2D texture, Vector3 position, float width, float hei rlSetTexture(0); } -void DrawCubeBlock(Texture2D texture, Vector3 position, float width, float height, float length, BlockDef def) +void DrawCubeBlock(Texture2D texture, Vector3 position, float width, float height, float length, BlockDef def, Color tint) { float x = position.x; float y = position.y; @@ -104,7 +104,7 @@ void DrawCubeBlock(Texture2D texture, Vector3 position, float width, float heigh UVCorners right = GetUVTex(def.textureSide); rlSetTexture(texture.id); rlBegin(RL_QUADS); - rlColor4ub(255, 255, 255, 255); + rlColor4ub(tint.r, tint.g, tint.b, 255); // Front Face rlNormal3f(0.0f, 0.0f, 1.0f); // Normal Pointing Towards Viewer rlTexCoord2f(front.corner0.x, front.corner0.y); rlVertex3f(x - width/2, y - height/2, z + length/2); // Bottom Left Of The Texture and Quad @@ -253,4 +253,57 @@ void DrawText3D(Font font, const char *text, Vector3 position, float fontSize, f i += codepointByteCount; // Move text bytes counter to next codepoint } } -#endif \ No newline at end of file +#endif + +RenderTexture2D LoadRenderTextureDepthTex(int width, int height) +{ + RenderTexture2D target = { 0 }; + + target.id = rlLoadFramebuffer(); // Load an empty framebuffer + + if (target.id > 0) + { + rlEnableFramebuffer(target.id); + + // Create color texture (default to RGBA) + target.texture.id = rlLoadTexture(0, width, height, PIXELFORMAT_UNCOMPRESSED_R8G8B8A8, 1); + target.texture.width = width; + target.texture.height = height; + target.texture.format = PIXELFORMAT_UNCOMPRESSED_R8G8B8A8; + target.texture.mipmaps = 1; + + // Create depth texture buffer (instead of raylib default renderbuffer) + target.depth.id = rlLoadTextureDepth(width, height, false); + target.depth.width = width; + target.depth.height = height; + target.depth.format = 19; // DEPTH_COMPONENT_24BIT: Not defined in raylib + target.depth.mipmaps = 1; + + // Attach color texture and depth texture to FBO + rlFramebufferAttach(target.id, target.texture.id, RL_ATTACHMENT_COLOR_CHANNEL0, RL_ATTACHMENT_TEXTURE2D, 0); + rlFramebufferAttach(target.id, target.depth.id, RL_ATTACHMENT_DEPTH, RL_ATTACHMENT_TEXTURE2D, 0); + + // Check if fbo is complete with attachments (valid) + if (rlFramebufferComplete(target.id)) TRACELOG(LOG_INFO, "FBO: [ID %i] Framebuffer object created successfully", target.id); + + rlDisableFramebuffer(); + } + else TRACELOG(LOG_WARNING, "FBO: Framebuffer object can not be created"); + + return target; +} + +// Unload render texture from GPU memory (VRAM) +void UnloadRenderTextureDepthTex(RenderTexture2D target) +{ + if (target.id > 0) + { + // Color texture attached to FBO is deleted + rlUnloadTexture(target.texture.id); + rlUnloadTexture(target.depth.id); + + // NOTE: Depth texture is automatically + // queried and deleted before deleting framebuffer + rlUnloadFramebuffer(target.id); + } +} \ No newline at end of file diff --git a/src/helpers/vars.hpp b/src/helpers/vars.hpp index 77f91c4..bed6c95 100644 --- a/src/helpers/vars.hpp +++ b/src/helpers/vars.hpp @@ -5,7 +5,6 @@ #undef Escape #endif #include "glfw_keycodes_to_string.h" -#include "../PerlinNoise.hpp" #ifdef WIN32 #include "external/fix_win32_compatibility.h" @@ -99,10 +98,10 @@ #define GAME_VERSION_INT 0 #define DEFAULT_FONT_SIZE 16 -#define TPS 30.0 +#define TPS 30 #define TPS_DIV 1.0 / TPS //Rendering -#define RENDER_DISTANCE 5 +#define RENDER_DISTANCE 16 #define RENDER_DISTANCE_SQUARED RENDER_DISTANCE*RENDER_DISTANCE //Game stuff @@ -115,6 +114,8 @@ #define INVENTORY_HEIGHT 6 #define INVENTORY_SIZE INVENTORY_WIDTH*INVENTORY_HEIGHT +#define WORLD_TIME_SECONDS (24*60) +#define WORLD_TIME_TICKS WORLD_TIME_SECONDS*TPS enum BlockType { B_Wood, B_Stone, diff --git a/src/rcraft.cpp b/src/rcraft.cpp index b6d736d..19b01fb 100644 --- a/src/rcraft.cpp +++ b/src/rcraft.cpp @@ -15,6 +15,7 @@ #include #include #include +#include #define MAX_RAY_DISTANCE 8.0f struct MessageData { std::string message; @@ -57,15 +58,21 @@ static Sound wood_place; static Sound stone_place; static Sound dirt_place; static Sound grass_place; -bool tick_entities; +static Texture2D sun; +static Texture2D moon; +static Texture2D stars; +bool tick_entities = true; const std::string LocaleGet(std::string loc); bool InputGetKeyDown(const std::string name); bool InputGetKeyPressed(const std::string name); + extern std::list entities; std::bitset clouds; std::queue tickedBlocks; struct MeshUnit { Model model; + Model modelTransparent; + Model modelWater; int vertices; }; struct ProfilerPart { @@ -91,8 +98,17 @@ static Vector3 CameraForwardFromYawPitch(float yaw, float pitch) } World world; static MeshUnit rendering[MAX_WORLD_AREA]; -static MeshUnit renderingT[MAX_WORLD_AREA]; +std::map loadedShaders; +static void LoadNewShader(std::string name) { + Shader temp = LoadShader( + TextFormat("%s/shaders/%s.vs", PATH_APPEND, name.c_str()), + TextFormat("%s/shaders/%s.fs", PATH_APPEND, name.c_str()) + ); + temp.locs[SHADER_LOC_MATRIX_MODEL] = GetShaderLocation(temp, "matModel"); + temp.locs[SHADER_LOC_VECTOR_VIEW] = GetShaderLocation(temp, "viewPos"); + loadedShaders[name] = temp; +} GameState state = GAME_STATE_MAINMENU; bool loaderParam_remeshOnly = false; int worldCreationProgress = 0; @@ -274,37 +290,37 @@ void Debug_EndMeasureLoops(const std::string &stuff, int loops); static void RemeshChunk(int x, int y) { int idx = GetIndexWorld(x, y); if(loadedChunks[idx]) { - UnloadModel(renderingT[idx].model); UnloadModel(rendering[idx].model); + UnloadModel(rendering[idx].modelTransparent); + UnloadModel(rendering[idx].modelWater); } Chunk &chunk = world.chunks[idx]; RebuildOpaqueMask(chunk); - /*for (int i = 0; i < 4; i++) - { - Vector3I dir = dirs2d[i]; - if(!CheckOOBWorldChunk(x+dir.x, y+dir.z)) { - RebuildLighting(world, world.chunks[GetIndexWorld(x+dir.x, y+dir.z)]); - } - }*/ - RebuildLighting(world, chunk.x, chunk.z); + + MeshData renderDataOpq = GenerateChunkMesh(world, GenerateCRDOpaque(chunk, world), chunk, x, y, 0xFF); - MeshData renderDataTsl = GenerateChunkMesh(world, GenerateCRDTranslucent(chunk, world), chunk, x, y, 0xFF); - - Model model = LoadModelFromMesh(GenChunkMesh(renderDataOpq)); - model.materials[0].maps[MATERIAL_MAP_DIFFUSE].texture = terrain; + Model model0 = LoadModelFromMesh(GenChunkMesh(renderDataOpq)); + model0.materials[0].maps[MATERIAL_MAP_DIFFUSE].texture = terrain; + model0.materials[0].shader = loadedShaders["terrain"]; MeshUnit munit0; - munit0.model = model; + munit0.model = model0; munit0.vertices += renderDataOpq.vertexCount; - rendering[idx] = munit0; - model = LoadModelFromMesh(GenChunkMesh(renderDataTsl)); - model.materials[0].maps[MATERIAL_MAP_DIFFUSE].texture = terrain; - MeshUnit munit1; - munit1.model = model; - munit1.vertices += renderDataTsl.vertexCount; - renderingT[idx] = munit1; - loadedChunks[idx] = true; + MeshData renderDataTsl = GenerateChunkMesh(world, GenerateCRDTranslucent(chunk, world), chunk, x, y, 0xFF); + Model model1 = LoadModelFromMesh(GenChunkMesh(renderDataTsl)); + model1.materials[0].maps[MATERIAL_MAP_DIFFUSE].texture = terrain; + model1.materials[0].shader = loadedShaders["terrain"]; + munit0.modelTransparent = model1; + + MeshData renderDataWtr = GenerateChunkMesh(world, GenerateCRDWater(chunk, world), chunk, x, y, 0xFF); + Model model2 = LoadModelFromMesh(GenChunkMesh(renderDataWtr)); + model2.materials[0].maps[MATERIAL_MAP_DIFFUSE].texture = terrain; + model2.materials[0].shader = loadedShaders["water"]; + munit0.modelWater = model2; + + loadedChunks[idx] = true; + rendering[idx] = munit0; } static bool RaycastBlock(Vector3 origin, Vector3 dir, float maxDist, Vector3 *outBlock, Vector3 *outPrev) @@ -549,6 +565,54 @@ void TakeDamage(float amount) { int currentlyTickedChunk = 0; Vector3 highlightBlock = {-1, -1, -1}; +float GetDayProgression() { + return (float)(worldTime % (unsigned long long)(WORLD_TIME_TICKS)) / (float)(WORLD_TIME_TICKS); +} +Color GetSkyColor() { + float progression = GetDayProgression(); + Color night = ColorBrightness(BLUE, -0.9f); + Color sunrise = ColorBrightness(ORANGE, -0.25f); + Color noon = BLUE; + if(progression > 0.5f) { + progression = 1 - progression; + } + + if(progression < 0.20f) { + return night; + } + if(progression>=0.20f&&progression<0.30f) { + return ColorLerp(night, sunrise, (progression - 0.2f) / 0.1f); + } + if(progression>=0.30f&&progression<0.35f) { + return ColorLerp(sunrise, noon, (progression - 0.3f) / 0.05f); + } + return noon; +} +Color GetSunlightColor() { + float progression = GetDayProgression(); + Color night = ColorBrightness(BLUE, -0.9f); + Color sunrise = ColorBrightness(ORANGE, -0.25f); + Color noon = WHITE; + if(progression > 0.5f) { + progression = 1 - progression; + } + if(progression < 0.20f) { + return night; + } + if(progression>=0.20f&&progression<0.30f) { + return ColorLerp(night, sunrise, (progression - 0.2f) / 0.1f); + } + if(progression>=0.30f&&progression<0.35f) { + return ColorLerp(sunrise, noon, (progression - 0.3f) / 0.05f); + } + return noon; +} + +static Vector3 GetSunDirection() { + float time = GetDayProgression() - 0.25f; + return Vector3Normalize({-sinf(time*PI*2), -sinf(time*PI*2)/2.0f, -cosf(time*PI*2)}); +} + static void GameUpdate(Camera camera, float &time) { if (player_position.y < 0 || player_position.x < 0 || @@ -691,6 +755,9 @@ static void GameUpdate(Camera camera, float &time) { if(IsKeyPressed(KEY_F10)) { tick_entities = !tick_entities; } + if(IsKeyDown(KEY_F11)) { + worldTime+=8; + } if(IsKeyPressed(KEY_B) && !online) { Entity temp = NewEntity(); temp.type = 3; @@ -888,12 +955,13 @@ static void GameUpdate(Camera camera, float &time) { PROFCOUNT = GetTime(); if(tick_entities) { - entUpdateCounter += dt; + entUpdateCounter += dt / 2.0f; if(entUpdateCounter > TPS_DIV) { while (entUpdateCounter > 0) { UpdateEntities(world, TPS_DIV / 2.0f); entUpdateCounter-= TPS_DIV; + worldTime++; } TickAvailableBlocks(); entUpdateCounter = 0.0f; @@ -917,12 +985,56 @@ static void GameUpdate(Camera camera, float &time) { UpdateCamera(&camera, CAMERA_CUSTOM); unsigned int debug_verts_opaque = 0; - unsigned int debug_verts_transparent = 0; UpdateHotbar(); Frustum frustum = ExtractFrustumPlanes(camera, (float)GetScreenWidth() / (float)GetScreenHeight()); BeginDrawing(); - ClearBackground(RAYWHITE); - DrawRectangle(0, 0, GetScreenWidth(), GetScreenHeight(), BLUE); + UpdateCamera(&camera, CAMERA_CUSTOM); + + ClearBackground(GetSkyColor()); + + BeginMode3D(camera); + float time = GetDayProgression() - 0.25f; + Vector3 sunOffset = Vector3Negate(GetSunDirection()); + Vector3 _forward = Vector3Subtract(camera.target, camera.position); + Vector3 up = { 0.0f, 1.0f, 0.0f }; + Vector3 _right = Vector3CrossProduct(up, _forward); + up = Vector3CrossProduct(_forward, _right); + up = Vector3Normalize(up); + SetRandomSeed(1337); + time += 0.25f; + if(time > 0.5f) { + time = 1-time; + } + float starAlpha = 0.0f; + if(time > 0.2f && time <= 0.3f) { + starAlpha = 1-(time - 0.2f) / 0.1f; + } + if(time <= 0.2f) { + starAlpha = 1; + } + rlSetBlendMode(BLEND_ADDITIVE); + DrawBillboardPro(camera, sun, {0, 0, 64, 64}, player_position+sunOffset*1000, up, {150, 150}, {0.5f, 0.5f}, 0, WHITE); + DrawBillboardPro(camera, moon, {0, 0, 64, 64}, player_position-sunOffset*1000, up, {150, 150}, {0.5f, 0.5f}, 0, WHITE); + for (int i = 0; i < 120; i++) + { + float u = GetRandomValue(0, 100) / 100.0f; + float v = GetRandomValue(0, 100) / 100.0f; + double theta = 2.0 * M_PI * u; + double z = v; + double r = std::sqrt(1.0 - z*z); + + Vector3 starOffset = { + r * std::cos(theta), + z, + r * std::sin(theta) + }; + Vector3 tgt = starOffset*1000; + float alphaModMoon = fmax(0, fmin(1, Vector3Distance(starOffset, (Vector3Negate(sunOffset)))/0.25f-1)); + float alphaModSun = fmax(0, fmin(1, Vector3Distance(starOffset, sunOffset)/0.25f-0.25f)); + DrawBillboardPro(camera, stars, {(float)GetRandomValue(0, stars.width/8)*8, 0, 8, 8}, player_position+tgt, up, {10, 10}, {0.5f, 0.5f}, GetRandomValue(0, 360), ColorAlpha(WHITE, starAlpha*alphaModMoon*alphaModSun)); + } + rlSetBlendMode(BLEND_ALPHA); + EndMode3D(); BeginMode3D(camera); @@ -1017,8 +1129,8 @@ static void GameUpdate(Camera camera, float &time) { for (auto &p : distances) { int idx = p.second; - DrawModel(renderingT[idx].model, {0, 0, 0}, 1.0f, WHITE); - debug_verts_transparent += renderingT[idx].vertices; + DrawModel(rendering[idx].modelTransparent, {0, 0, 0}, 1.0f, WHITE); + DrawModel(rendering[idx].modelWater, {0, 0, 0}, 1.0f, WHITE); } AddProfilerPart("chunk render tsl", GetTime()-PROFCOUNT, RED); if (highlightValid) @@ -1037,7 +1149,7 @@ static void GameUpdate(Camera camera, float &time) { BeginMode3D(camera); rlDisableDepthMask(); rlDisableDepthTest(); - DrawSelectedItem(); + DrawSelectedItem(GetLight(world, (int)player_position.x, (int)player_position.y, (int)player_position.z)); rlEnableDepthTest(); rlEnableDepthMask(); EndMode3D(); @@ -1076,6 +1188,13 @@ static void GameUpdate(Camera camera, float &time) { GetBLight(world, ppos.x, ppos.y, ppos.z) ); DrawTextB(text, 20, 100, DEFAULT_FONT_SIZE, WHITE); + sprintf(text, "world time %dt (%.1fs)", worldTime, worldTime * TPS_DIV); + DrawTextB(text, 20, 120, DEFAULT_FONT_SIZE, WHITE); + float progress = GetDayProgression(); + int hours = progress*24; + int minutes = (int)(progress*24*60)%60; + sprintf(text, "%02d:%02d", hours, minutes); + DrawTextB(text, 20, 140, DEFAULT_FONT_SIZE, WHITE); DrawRectangle(GetScreenWidth()/2-3, GetScreenHeight()/2-3, 6, 6, BLACK); DrawRectangle(GetScreenWidth()/2-2, GetScreenHeight()/2-2, 4, 4, WHITE); @@ -1176,6 +1295,7 @@ static void GameUpdate(Camera camera, float &time) { } } static void GameStart() { + const int cloudMapSize = MAX_WORLD_SIZE*CHUNK_SIZE/8; for (int x = 0; x < cloudMapSize; x++) { @@ -1190,7 +1310,9 @@ static void GameStart() { data[0] = NET_ARG_REQPLAYERS; SendPacketR(peer, data, 1); // Tell the server to fetch all players } - + + worldTime = (int)(WORLD_TIME_TICKS * 0.3f); + camera = { 0 }; camera.position = (Vector3){ MAX_WORLD_SIZE / 2 * CHUNK_SIZE, 12.0f, MAX_WORLD_SIZE / 2 * CHUNK_SIZE}; camera.target = (Vector3){camera.position.x, camera.position.y, camera.position.z + 1}; @@ -1408,14 +1530,6 @@ void GameModeCleanupFull() { enet_host_destroy(client); online = false; } - - for (int idx = 0; idx < MAX_WORLD_AREA; idx++) - { - if(loadedChunks[idx]) { - //UnloadModel(renderingT[idx]); - //UnloadModel(rendering[idx]); - } - } memset(loadedChunks, 0, sizeof(loadedChunks)); memset(dirtyChunks, 0, sizeof(dirtyChunks)); entities.clear(); @@ -1439,6 +1553,13 @@ int main(void) SetTraceLogLevel(LOG_WARNING); SetConfigFlags(FLAG_WINDOW_RESIZABLE); InitWindow(WIDTH, HEIGHT, GAME_NAME); + + if(!DirectoryExists(PathifyUser(""))) { + MakeDirectory(PathifyUser("")); + } + if(!DirectoryExists(PathifyUser("worlds"))) { + MakeDirectory(PathifyUser("worlds")); + } InitWorldgen(0); InitAudioDevice(); InitMenu(); @@ -1456,6 +1577,9 @@ int main(void) fnt = LoadFontEx(Pathify("font.ttf"), 32, NULL, 1024*8); terrain = LoadTexture(Pathify("terrain.png")); + sun = LoadTexture(Pathify("sun.png")); + moon = LoadTexture(Pathify("moon.png")); + stars = LoadTexture(Pathify("stars.png")); GenTextureMipmaps(&terrain); Image temp = GenImageColor(1, 1, WHITE); white_pixel = LoadTextureFromImage(temp); @@ -1471,14 +1595,32 @@ int main(void) ImageCrop(&copied, src0); water = LoadTextureFromImage(copied); + SetTextureWrap(terrain, TEXTURE_WRAP_REPEAT); SetTextureWrap(water, TEXTURE_WRAP_REPEAT); SetTargetFPS(-1); float time; + LoadNewShader("terrain"); + LoadNewShader("water"); + SetExitKey(KEY_NULL); while (!WindowShouldClose()) { + for (const auto& [key, shader] : loadedShaders) { + Vector4 sunlight = ColorNormalize(GetSunlightColor()); + SetShaderValue(shader, GetShaderLocation(shader, "sunlightColor"), &sunlight, SHADER_UNIFORM_VEC4); + + Vector4 skyColor = ColorNormalize(GetSkyColor()); + SetShaderValue(shader, GetShaderLocation(shader, "skyColor"), &skyColor, SHADER_UNIFORM_VEC4); + + Vector3 sunlightDir = Vector3Negate(GetSunDirection()); + SetShaderValue(shader, GetShaderLocation(shader, "lightDir"), &sunlightDir, SHADER_UNIFORM_VEC3); + + float time = (float)GetTime(); + SetShaderValue(shader, GetShaderLocation(shader, "time"), &time, SHADER_UNIFORM_FLOAT); + } + NetworkUpdate(); InputUpdate();