From 6f1eb16a30c0c8bf64145c6bda092af3d02987b6 Mon Sep 17 00:00:00 2001 From: catangent Date: Mon, 16 Dec 2024 23:19:26 +0000 Subject: [PATCH] start rewriting mesh code in zig --- .gitmodules | 3 + build.zig | 23 +- build.zig.zon | 5 +- resources/images/tiles.png | Bin 1492 -> 2843 bytes resources/images/tiles.png.kra | Bin 32831 -> 33818 bytes resources/images/tiles.png~ | Bin 1489 -> 2807 bytes rmodels.tmpzig | 40465 ++++++++++++++++++ src/{util => lib_helpers}/raylib_helper.zig | 0 src/main.zig | 26 +- src/rendering/chunk_mesh.zig | 177 + src/rendering/chunk_models.c | 6648 +++ src/world/chunk.zig | 36 +- todo.md | 13 + zig-gamedev | 1 + 14 files changed, 47357 insertions(+), 40 deletions(-) create mode 100644 rmodels.tmpzig rename src/{util => lib_helpers}/raylib_helper.zig (100%) create mode 100644 src/rendering/chunk_mesh.zig create mode 100644 src/rendering/chunk_models.c create mode 100644 todo.md create mode 160000 zig-gamedev diff --git a/.gitmodules b/.gitmodules index fccf93a..a6964fc 100644 --- a/.gitmodules +++ b/.gitmodules @@ -1,3 +1,6 @@ [submodule "raylib"] path = raylib url = git@github.com:raysan5/raylib.git +[submodule "zig-gamedev"] + path = zig-gamedev + url = https://github.com/zig-gamedev/zig-gamedev.git diff --git a/build.zig b/build.zig index 7d520d5..c608e70 100644 --- a/build.zig +++ b/build.zig @@ -4,6 +4,18 @@ pub fn build(b: *std.Build) void { const target = b.standardTargetOptions(.{}); const optimize = b.standardOptimizeOption(.{}); + const rl = raylib: { + const rl = b.dependency("raylib", .{ + .target = target, + .optimize = optimize, + }); + break :raylib rl; + }; + const znoise = b.dependency("znoise", .{ + .target = target, + .optimize = optimize, + }); + const exe = b.addExecutable(.{ .name = "voxel_test", .root_source_file = b.path("src/main.zig"), @@ -11,19 +23,14 @@ pub fn build(b: *std.Build) void { .optimize = optimize, }); - const rl = b.dependency("raylib", .{ - .target = target, - .optimize = optimize, - }); - exe.linkLibrary(rl.artifact("raylib")); + exe.root_module.addImport("znoise", znoise.module("root")); + exe.linkLibrary(znoise.artifact("FastNoiseLite")); b.installArtifact(exe); const run_cmd = b.addRunArtifact(exe); - run_cmd.step.dependOn(b.getInstallStep()); - if (b.args) |args| { run_cmd.addArgs(args); } @@ -38,6 +45,8 @@ pub fn build(b: *std.Build) void { }); exe_unit_tests.linkLibrary(rl.artifact("raylib")); + exe_unit_tests.root_module.addImport("znoise", znoise.module("root")); + exe_unit_tests.linkLibrary(znoise.artifact("FastNoiseLite")); const run_exe_unit_tests = b.addRunArtifact(exe_unit_tests); diff --git a/build.zig.zon b/build.zig.zon index 94e11dd..7b93093 100644 --- a/build.zig.zon +++ b/build.zig.zon @@ -4,9 +4,8 @@ .version = "0.0.0", .dependencies = .{ - .raylib = .{ - .path = "raylib", - }, + .znoise = .{ .path = "zig-gamedev/libs/znoise" }, + .raylib = .{ .path = "raylib" }, }, .paths = .{ diff --git a/resources/images/tiles.png b/resources/images/tiles.png index 1d9be0b89ce40328b71557779e06674072e46677..9f807c7614c915c455ca9cf154e324f80f61b7ef 100644 GIT binary patch delta 1744 zcmV;>1~2*43!4^@IDZPwNkl)=hx-=PNx&I*(@rRN(=^rD6Q4v zkAL|6w>;oCKfbdBo@Id)wX3!DNAs9Z=20n6Qec+i)^nS2^6zRCV-`D`YcY>jOq!FZ z#d=(%>+U@`jDM(1WBsd$^TsGfqtPPB^N|C4ZEfvq$zYijhQnc0tJTHz-EKG58qFB? zI;%ary9qqw0xKtgyRSFn_=|C@k2g{`o&x>mI9@%w9^J{K`1GhBg_H_fjauCM@;u^4 zr*Wsb6>+i^#T5L5)_&A#wW}U}JRYY(#N=y9VcGlV*MFQOauTR-wqn%pUETYP|AxLk zfu|N&IRU);X+3Vw*JA(VVQkc9(K#!{VLXg(>ZxDc*@$6n6qRlve*3HEV?2F6K04^c zqd1Gh>Txuyw-y1PTe)0bi~x$o;??K;CI@_;rQ~zDkf#7S=$DBh&-HT~OlE0naG4yY(^)zuF&SL^5Pk#SfxveruyO*p zxA!25|7gYQH+Q2u=tn8d{dc$P@!?53W}RLPyML3Y);e+b7maw33xkDjL<;_Tnl8-# zSzq+*%K~72p94Sl^8J4QDlsf|hEI$Z@^#DU!*{0VKPK=!7g#v~yfuC`-mf3W{&6?1 zH5yT_R^q7FkC*D57|q6UGCYsXYn9kPJdW195?>yrd3-sI63VHPzjGPv`N+L~9tGrL z-+#4h*J6EreerquTCdj^)Ol4R2mkWg@43InC-9vLT#l(%Xb(!=sP0Z;z1EIiV;%>y z{n#j0;=FejXM>h0(}oW**-5a;7j+-^7HBGn28ucSHs?E2MEKUep2Yc`vUrM}#j z%Yb=gkSqWB$Www@u@r?$HP$zpD?GVd34ahMf7?3$w`>!L!oPkK&1o9ej~fxEo#-4- zqqubut!5+D|BLbE$w_QXda+$j%Ymgd+`n@kFUL;Yjz)a6@i1DgpDuod9OSuI&%xgt zj-p;~Eav>>LNUgv$1hga7T5KLgP5G1EsBO30RpQDtQ%G-iuk`a`VqH75S!*d;VIb zoC6XPJpt+8Ha0dE3E;_%L#r{ko4~UvuyO)8ucj(}>ZRN5QoQ^^D+Zqz z<7TT6<;F&gQxM<(>QNjwhEYGOM1OyNJt;S$_mj`#mxUW~GBee2L}gN*DRL^|33u&3V~-=VC4jGeX|xPY3u*dSDmQ0(l*~nL-ck^2K{oh z(wcs&Uyc9vyK!`I6w&U+ovoYkLFYIcgO}p96!>}FKNt6M%RPQx{(Eu>Fc0%{kDo^Z zc_m;u?9W9&jR1kw1XfM}Z+{cRz|qHABP8%xOmWx(XJx;?g6aZkS>dL}RDz3sQxB{$Pp{L*q%#6KB zm+pmFC=!YyS8@EJ6n&AhG3{JwZ-09eAkbW3ogp+| zCM>yBXkKjxBtW3;3}EazmGJquxibarM1Vk;K->%&mRHNPfMT8k$hkNz$LYTHR1fe?YX8NiVI>!n<+}9g@`O+vYU~m zMG|GHkVKS9Q6Vw^XL`Ti_x-*7zTf`8=bHO^u50ekb?$TS&$-Vz&$($Stc4k@+nj9K zUD$;@lHZk1XZC~3~v8eiGuCy4QC9L}rE?7!ZV+W;Qtq0!JPTZLQkpy5U$nC5T3n(GlSQ!_;1H4)jC1Ok;I2u%@Y!1|{@oAU=lLhu*`l_7m=g&`tF67?Y!8Heb0TP*{!ulrsL(D_%5U5!ilNN5tqeFGgr_LS5*5s zLM|!3hJn}i*1l(zF6EC}5zN?irSUCiP+sHBo|4E~1+h4<5$}``I`4UY)ipu5g)Xit z}KN4w#;;|FFmh7=Bl`mybTJu|uRQB-8N zrfp9dd;7Ft^5yU=3wdr^qt5S4_xWcJ3F#((JjSc(1y<`_?%Y`#{MxvWHIG;Q`0Vj* z$HTR2*lbh^-Jj{*f3mhu!&Ri=#Ur7In~ zwkwWPk+1!o{mANXGpd^`)kBEhCvxliqs$lTheCH6cU>x_biETb2d2{GEiwCU6S!aVERozoWn`4>5#7GTiNOz^^PA#RIZk=IZuRr1#6cbHEXtG zW@`@|wmzk}<&nRSap=k$GrR0peS#tOx!`n!;`o`dPlv%Dt6NK)UmxYXaeHan;Iw$C z&dKkdkbpxxt=Zv&L4^F<;CJQ|0dlTBlELxk9a5E&f^z5kayW`yX>@X6ZrYsuL{BX0 zQE}v)r1l0KoUSYMnAoQ9aJ6c`oMhL>gApLN?Xb|q(fGsdETtMke2NA|a+YwacWrP= zg8jPO^Y})vS@F1Mza5RQ{EAmdtL~}UYRrZ2kEvu`C!vjv@#y;U%U4v%q19e5`=#Gc znKJ+#VXM7*8rM~-FEs7}+8w^1cMw<)l}!;;`RY1i?BY!ge4*7j^NeA=9d6s>TBAhW zM%cT0f-+@U(bz2#om#B7C#xozI7LLOrMQ=zoZ(b)Omd(KSg^_-=v1ssOTj~}Vkxe3Q zR`4uM-9^1KLJ|rk!Eed;- z#hJb4`za>}%WVh=W_;adZDr;Hy)~f0&k4m@Ja#z zJDatcv8&ao>U{g$7k%P)!PzLXoN}hOb=%@(buqFHD=@As1=IgFeBk2;YRTo2%2iT2 z>+WG&|I5dOU_Od3n(fE(-PQAZkj}FY>)_Q~8;51^^UEpck8-Rey~vTg!{YBEsdpr=vqkRQ)f3CZi_aF?l-ysk=mn)8Do!1{}9$=^L6 z&X}9lzD;`!E8mtoW;vVqXvOnXnynx^n%I(BQk}rh7ogvh6IwZ&hvIBa)3Hw*{l2?G zS2kNysf-iO73awhYl>p?!|=7d{O+w*y8zD*-+eyD+;=Ql<6{GN=#h_~+WaQVG~?Gv zd74KDTz6-Thmf9g5Ih8;99WVbSXytrlH+w-=QJT`719_g#%K_(|Uy$dp z-P8MH^nLzl%q!TFwhRk%bjjIk{{%9^MmbyaJ$@fAFYm(FM6tkDF>-*1Q*~Uy;*{{T z$!vwGy}Fh1)%;T(rAs!TPH$lx)s(FK>|B|LL3m-|M#w{*I@c1bI!hn7#a0f~>A;&* zpg6}y`Tj}~dhkXiVi6&AW8rIH`>OSV&+4X1-t0VJr3`sOb=mmHiGUOQYL{LQAIkw%h(M-Kx^Hcp0`1lb z4)xpGl6=bZPcL-C%T49fyUrduF}B=$EF*%fCx9N*8K0MZ{(ddYU@km1JFbT4d+1@@ z9NXI~Re6(=?uapbD9&54DTvp+_P%o}%j z+dlZlnW1E~b;|M)$kp&JGo1RKmvUV>;)ToDUSs~tXH9IZpJgrR~9rihp7 z^O4Jw3wCEz@)5KoUTqi=I-A_fgo8XggRYoxR#rlaiIFG$o}GDz2RaKk0UZw2lUe+A z;TI+5_Jvcg-{-N>OI}~sjIy)f!bry))t;_ewlwlFFFx_E)q?X@fnzf*ebmch*i<*^ zt?SrG)7(2e2%MLSP7b%0K4Pb)vu0JX-DU8o6nsLa{KqCO>=LOU-j)>Y@oBIM$FU!y zzke5@IzIjN`=G``zqoZbw^T*Q$5XWJL$U+fCTD=9FZWlUFErfM7~)wz`&>_cRVpv> zUc=i?6P`C;t_PkKOpzBe2)|gg@90V3$G6;E0~*pK7K}+;2`QH6>hR?or={P15itg5 zz(cP7@h}rV>kEZTz}nowtj5Iu_&+0Ypo{93K9pItp|Jx(xnZ#Z5kW`P!vhFGF*x;z z09=@sT2x3vP&h6qJSZ?WBofP_&CbdDGxxAIqu9Wuk(vl7`WmA& z5gMu*s&-x$s#@9_2o`{H1&%~60x%^8gHboFwKg4(fys@JkDr^?qEQ|p@+nT79F$~E zS;}LcZ9nVioF&#_W~hgh`Wg8D4_c`m2?`E~3y=M&D+>#-#rUO$;K~vIcoY(t#0miF z|IJd|F)$!1=r2>%10%7qP@SQM!yk=s@d>-5AxvELn3yczmanksUvZGVD*M*0Q#i>a zRh`>ih4~6z;8vb{mL0e3fZ_ZlT+;B+Y;*rBy2?(3_|-)XSXtnO9)c_(qn>`hS-15f z(X8rauhdi7^xm;AA9k|JpWRv$C~E*mc#LQzU4ajS*hHNSKufyaVvJRY&zQr9edgze zNAkRQeID&NEMYa~FI?e_zd%`lRm;foyP-$XsU3n^>0>qv37qb(;v?0DUe2hVPah7x zF)c+zj!Q@e&j}>@Un1+G-3(lw4k0uV$~U+Xt8UQI2%|30lC$ejMI z1OefsJ&{O4v! zndsQ>*Rim3FwwQJHFWSaB@jqS1RN>lI4LO!hq9Z7Ll#~(5@P5Z=o?shIM}{IT z>N+HY$;q<1#&mXUG!~yoq^m;$=@@CvJv!z#2fdv3>l?ZHnK&7QVxv=25>v=o!D4p&GxBV zqwV|>6BASLcsve|#qHo^A(NryK<0XUnnq{~Gb0RUzp;ypm9w7_ipCQgpOT%Oc{=kr ziG;`h)Sr$Ku{77yGc>Yr^mDSXuyEDWOG+VUXOmH>Ff1-KG;xLtgqFpKt19W~8`z=I zN@$FkxxRx#A~BH|9UU7RnxC9w2mbm|a^RxiTi~HCeVwnX>t;pS=pE`ED)r9z z_*mT%2Lp&>x)J0X@ah}Y)%3>3J179wNo~E+xO;tx6`KCQ2|}|1FMH|TlaC%ysr2&h z{+7mWB9S?puq4jlqjlb-Ha6DW>8Fi8X=`b{&y<=;Z(>RX`R;Tz)^~vQw7bKdK+YOyPtsQNR58GPHZd7+I zDKhxR`rGf{X|HeSynTyGtskSQ*F$nxK@j}uAzg6z*uAEf>&-Np>|IzRl!5yr8Ei4h zV2XMl5QDOVEP&htqM@U5)zi=7<}DzJ;T(V-j3SVrrWp2 z#viL=mgE_H55}K8c+gN;-8axht)f5cVQMno+t}UReWS6xy|l5Tp}8MLgEoRCJ)OS9 z^ehHfcUNOwT~%FOZN01^Yg2z0il)vmf@fxC6-DMP;w$K1nGR0FakQ z0!uIk5X)o^*ugI)EiI_IOT*1c1qp0}JAwyLZ!=v#H$63D_Z zG-HXzLagxttlCN{yI`#HyEL|K+lCZjZj1GH@m=Z?^3sARJ}EXXXmLdbkHQXF8Kix_}Ew`V*ntot!iOoF3l~%%?+p`|71)-RaH|L`tlah zR6z3V0=OYHxX`;qWMq(>NCgo&kQLxYL;J##nu>Y{DM4qTq_{;yczAgQ#jLH-@@QGm zk-X)QN-5fKqIFE2hRm3%T4q6`aB2Gw1>sCLw0 zR!&}CITm(>pQll-6&{-g1yv$}fD(rYloS65JdB@~0baosre&DncpWp%4s;=>WhfPh z89pe7{61eYlk#s98Sn3N_MaK|cZGq108_&6l9>|k@3Y~~e^xkBFU@4RpkxMl5FiJQ ze^tAbS#=aebQ`ZEvjg_JYlasFO(sA^y7=Fi1{DpI-2Va~{|DfRi?kdsQ$oy)4>t;; zT#}peN31AJl6&?Gr7~6zL<}%nCJDYDp1;5zx+?-a9;h;N5f1UWIgVAUo@}&|L~mR`?N-f83p@FvwBr?LG_v9;wyGt1Z$vS{~rn4qV^BZ zORYx{ir2OzeR^+jClUElVEPt$z70l;85TIBKU++Cn!%KYzE4B|=gRReUC5uOA z@;csFOf+{2@Lfg9JZif|po!6vRtI`pTy8Y#3pG4b-F41}ha*j? zdSoUST-$6yPwQej8(^1$QiZ8i)UTE+=N;cTD?7UQ=g*AdE=Dgeg$f6X?z zNU7*e^e$ceXsDMBR@en@R%NX8DOp?_lDoHZhAk-~;zQVd{|mz8?f}=Sk>0P9Slv;H z0kLleRfg?tTwYsm@vZ8P1>bmG&V%>bB=WEy|J$e7y+LsEM^s@-B9IuIu zW%P_?d31S;NOZkOukeqwQPR^;YLzqzEnRNhGaF_d@N8p#3@nn55v+*3efa5;&*Vln zgWPG9S}uA}pQU{x#1K0;c9=065dJiHNMEHl0G*9}cf)VuSw=vF@Hwn3X`^aB5KS~P zGFa%jrkB)NtC7JP>Z*3HjvpnGcx}}0iJxRY!=rtCx7P9t;tN!=()RKsGhFi znk?r{DdWhqeW2zgzQc`1xz>e@T3wsyQOUk3YH;>0%G&4W4nNBGoWg8&AbX29&(8wj zD|De>sYKUD>o18N>91oX{wN3Z7Ya_v4t~W++69M%MqQA){>0NjK~voO2S17JWhy;h zp)Q8CxoH)Z$vD=#s2hK6--4y`z-D~Y;^$Y^`+|#odD=iq#i&8_Dl#YG5AL*dtQle} zu~6;dmZ#sB_x-H?q!KpF>hdOuu}f1mj_jB%x*XU4wmbg%JVxP@A(FXEdr5nzYGv+j zMeEk=m2j?cpQ#wjEqGTfHqaNXh0YxaJ2#F&pB`-&^ph?lBCNzt=&M zW}iL$5~PNW9VQZqp9$+;wPVPq1UET2WBK_~3+=Arr(%Tn=^Gx$_-rOCJ~|xk7(MM9 zC=GAe99MFmX^$5@nik;t?!yAQs5g>brDR6(~K;sW`Vz!wILrf{K*J2aBeK#0U>uB1SD z@q(1&wdOd1>fjwCjI7Ud_pQV25^wo9^rx0-Ptb7E>USL`PFo~5e%A1+E>R<;OU<@; z40gSgJbl$SQuWP`ITOvk8+X;+M@7fJlGDx?74Oa@OR%t3aovO!9MmsO`S@yxqyq1>XWDo=;_YzKU5H)DT&} zo}0AgRaS&Z-V`&MlBxTVnPtfG_N9)Fjwsjk{T$OO&E|{r24#qMz1r)$i0{f?d~j+1 zVWPrOf_xoZ#Xr|)k$r&wCF7m5lrGsBQ)LE%BtvE0tE-g3*9Ga4(b@@O#ZM?z{@A7$ zSvzUy?f2L_y^;5JqNtt|| z=#z$lWA826aS512WQb(cyIb**!aMw)EZ)94ZkXZAQ1aCezq_GpblPI|yWHcZrl#6X z(4P1GME87tIjp?AJZlvWhkJ~v7H~2!uq{ODQ4jw)SQN2AR54_cG2~HP(KM{{(#rG; z-iBi{rg6BCROOe$_|_I38znsSv9GxL;%DP|J&Ck}8LIFaVG@H}jp;We`EDh}aB1+Z z;BreWSqVG+_1_Pg@6Q2JM_}#_KqM$bEUH{@kti8ulSYy8P!}jK)C66ZtV5{NI<4-L4YHR%7bJ%TgK(|ma z)&51-p}r2D)o9ak$$?e*rn^ORo6Jc#r8(j8>7hn`D)M?Xu2Dor`cmJ~`OUSkiQKP` z91x$pKh&BPCL|g>Sa|phWjy8e5Xn$rKr={bTRPnq}p&L zQJw`!hzc^4iw%hgiV46T4U$8}MjFa#YG^b}B*9qNpkzsToxJB~(){~Emm*J8k@-(| zQA`z}wh|zpnnl49Wqx9Qz29JBn2&s_2jwPF;%ATR*UsCY2qtC}y7%}$biABwSy-jn z{=OvpwQ2UZKqsDm3Pk>w&K`vy6#uE)ue~y+s6TBi{YBJYl5ofVTjT6kJ%4TJ{H^Cf zUI2jqyZY%ONhmY-``7B|Z#cKwUuIEQLB*fwU+bj5(XRgk?F35yq*)b|w9Iw-ONx2` z78@BGz-)5j)I$OTf7Sf&5()sI!uqdAKJ{JWYvhkw_UaZniPWo*a`(+Q`%-3KhDDWGCCu z&CMQC(sD*uvW$@I@;}qPJ(cVKJMCoo8c$(u`IB1JUYiJK{I;7|O@gahuf1`zndt@nOkZwNKqvvAv zrTDhN$H%wi<6FxdwzCz~F7}vPmTVUIP^T+>bb-_PH%Fd}Y@uWyM*m3*^^^u=M7Ds9 ziMNxkcgIkQ`qWqyJJzXvecS8(^1I?A*r5;egW9LCHx!9=0c;Udd%+AV^G!JwWb$ik zl4^0In*p2e6+-e9#`S&eM|^QouwKSxm36`esL|1fk)|%r(8jXUFNvmYugC1|+jc%v zYLZxAwRJFakg)(|Sm(Bk=KA#dBxx=A@DD+{I=TDO|jxHg}aVK&!TXVKytqEjNIkSe;vTh5Tl1igD`>Vml!(Lyl z*f%y?%N@AQaVe!Mr?M-!Q{9!K^CkC%Qy!k|Cfv1{zg|E4hw@Ug`?+THiN1H2EqgB< zq*xAAiQOpI>Mx$GkCdEp`8=C}MLsFEeThBRRWorgJzVdlVwn4)WkZ7&KC!sj{_fa> zy^mG0@|B4Gj4aP4o%MEU&yQjHK-RUhK`pj<&$C~33YD04(P$waCrlody>Qm@8fXW@ zpUZd1#(W({7&-2oIb2>oBgQkZ6zov}o`IcM^YM8Z2mqkL?iGh;Vb=!vQE7o*G*5q? zeJ>@n1oUF1&P+!N?UH*So-p(zi=Sz(9+JtlPCirl(W3yY6;M+YFo?>Y_##Wc7)I^hGG9+^cHnm(tcQ%AB`L<86qA~Kp1UYUv&9*2nu_&tP zmXN&eG#R{qiV!u1JNR2-e-Gx0iQwsB*G|gZ5pE>Hty6oo(#|nE=I+6cf!e*I^lf|H zE@b8CS2u%SR9iF`CarKO=ySdfezyeT`}dQ4%PD;9_v~Jbmi_0dAh}urQ5z%gA+Flp z?p@Z6k34+tE5EG{cczBSzUlm2_*;0dmj6gQd?d`LS2ih?-V`v_*|^`U@`}Hmjs&|Y zD#nRp;DiiM%k#R459Ns9n$*sA&bG*U-wHN4a%dB1{X6z6Ux!}Yz=a2c_>}TvCm(P0 zbJEq8dH6IarFpGr>d77Si!+KlJe-&b<+3Mw=5A_wIX~Jrih~A~#Iv}Tx}3bV$lZ2f zQ}^f3UgguzyJUz{Nc?So{L-^R-2>#&>5~zyB{=$mWZpB*vxe!$u~BfcAU7x5@Cv_c z?mq6#H(=<|1-bFRH~gB`DVhCda&TH@;Lbac=>gPWFKP&pPWydWWbF7re?s383I+Ny zNf$(R@ENPuviTHI-HSZ}>3YHj_zSW!Gnb=C@9q7JywV_ojdX)}Tx(&c$gHT^SlOsp zW!~|a{w!AR@SO1HtKjuiaUBcr&f4ses zQn($ZmrSYrQ>D%0&WGvN6%@zKs2GXP!T20y=2CUBXP9=?-Yn1>>|Uc!(|@u}H9$dg z?WZ`4HTS2hCqiTXK5uu!YR#(SvaU8oLzFm*OTC}?0oIp2HMH>o;c=DE7Y4Q^Pl7p} z=(+Rk&gX5^Tl;oO0>3^*op{mVR15$l!Cex5ih*9f)Z-eyZei4be+NwjItfFaW5$ba zMQI6<3Muk>2vAo`QwRYprNJxUE&*WxL>m&~1JaZsc*Y1?O@;sh1%UWO0RR#rW2N9} zL|YrgM}nsy2{IsIyc^OWGth9DM8?7tSOla=##TexAl3kjgk+a$0d@m6#2859gMm>- zKpQ;3%o=3u3|1Gw8evg=|F9td2)Pt>5?h5uL26_O2|%i37>$ANp3l1*90zJ3jM00U z8s-);Jjel>b!*2*_>2HnoFE*nRjCCa88U!@&;YcKT5WV)kyR?Z!*l&R6C7Oe0C1uJIK0ySU>Xszn|Rpw>^@O69soi&0)X_&SYjdD zb~Rp|hc-5AqZ`5~J-DyD^Ry6pK*JJm<0+AZe%-c9aQlxeCW(ku;YEJMt|+T8jEKd{ zE?2$gyXwLsTY0=FFRb;{Vxk8&M;C?(1*}DPVbtcBa{+oF=B&BN4*Sr<++IWLdXf}C zxi{2UXQi4~M<_$yce#BJ5^BC!Wqy71%z;f3=kbom7Vb!$yi%YY7Q0y97W}p1Q>6Ks zjNyuo4_B?@`negouBn4xxLHQkaS>!!e<}Ji4n}h31#*6K*XV3OuIiJ9`aD%@aRjmk z$=x1RAC@u*j%)jaCnT}$E|gn1ZC7RWa{Hr){rDA))3_p(k!{z;W=qSpFkF);<3!`v zB3PBV{11JW3;Cvj6l5{-*oInL{Jy1EC9BP_F4$@mX)Z?hj->b>YhLybEM(}^DBC(; zP?3-ON<+P*6N^?NNPHSx|%P#JqyU%d5t{vc`kTseiw-uU8XcsJCaLKGqCbnx&xy zUMCwTi&ETjPd+adx791$65fPjlEOXpLkMH2#XGw)t@pNj!ASwkcUha{?WCOgHMOhF z-knxJ0>C=B%YM%tb1Yh_&^l5aA?s_$~T2Ph%w(t>pyEUHyZAy_|rlN0j`}`v3nk1W5l1V5&sRe>>QI#`0|c zy(uzw*nP*+qSs@8Jp%wh>^l%16&ay{%TZ>!Q6#(FMj_#Ma+fI{0+dxxj3++qEV}D0~ zME^+XLw{4DeJOn@6hcBuC{65fY>zb~X>>oQd!Mle=OqCv5E6ge2+fS7@zE#N+H38- zr>N72uNg&AeBHwlfBpU4BnaekaN}igHv(S+@qO zs_y;!$@5spwtpNvkGL7GW4&HCL7s0puzS7USCYX#DXdnj=yto!^JlYJ^hQUqnokeA zc&{e#mJ1x50Dk@3alH7VigMGAb~`14Q57e>VN~@puIB3~(!X}A6Vq)KyZ*ZDcgtwc za#GmE;`nh&8iV^8ezV!6B4YcMq_Cg;^LEl71rYe22T|`mTvA8N?TFs(Lmo(~kquosv`nHU-PCK@pRxFmgxNXf-$M7PKx<76L zK96?0-BbW&S>Au2zsLcfyOjJ`9yv+mQJ$VeRUUl#Zw%*!1bzqt2S?Dm^)5E4FW*KT zyVMFaOMeEbcW&xh^MlnnQU#93UQ?T#K zPRzEQC{}5GV4d$U+2Kjv;6Jt?R{d{ z>#Sa@7V`7;#Q}3VV>XZo9F+6R> z?R825RT0}&>IfEP-0V_2aB&yx`Icw>Tm|ICzO%El==b~0_xtR;yV|R?8^*$1#0YMLW&@v8!X8 zo);-$tlm$#XZP^F)X%H?c^n-bHCugo?6(1PWsq0?^DVaoRoRN7(~bT(wGjpZ0>P z{-%BYZ#X6pAAIzOn9QE0t-vCxRod2D?0;gE%KM{1KTcAhKDoMz@pc~PgR_|C69>a8 zj?%8cFI(eyc|3`elV3C!pMyNl>N)u5>GuqWqo(I?7iC&t+@=K6Yo0exNo9L|-7Fd! z1PB}^aBvjOUObQGGzDm}jaCZq(?KuI@}ns8f?!?6hZpCu-JGR1VH?vF*mafm`hQd1 z@nkWH5hc$s?pRy;_3e%}9Y&AV}w0=(PpM73GPXVa^=>81p+YNz1uMX~Kh)nCUrt@hun zu3|d5x)0{l)6-_lFSi4EfiJHM39 zz4xO1{!N;g(*odpkV^H4$BP$ny~8b_o0y0&lOt!3p3|I{N$KWq%#l(|L4z z^K|65PW%695igbc{UV(X+_Ykoepc11RPOK6`G7Q|=k3ACFn-m0r#bqY7x(hWGk)Iw zdwmNqm-%_d&y_&l3D}qYc@fYcK;STegA>5to_(5Hfa9n)Rh)0SO#)b@89ufDQKvHj zMO{WGZU3Dfcca@$TX-o6ynmRacA-6ve=hzPzndK2w*Yze&jH?)|HHc~piX7~MP3s~ zh`WOFbEKMbAf{sKwLhG^LMHk|8y2tpQl4UsTJ65ia1I$`@^F_ymvf~ zk1uEO3yO+eZ%OzQ*hoe$$blh0$E4h4-*&Z3jn3-0>;ZgY|_Cx3#;^Dpn;RdX7! zoel}TI{BB^3O1=dSS*|beDjaqD+#2qIvC+MU&NP}X?FhaX{>ieocv@L@2=0|lc$q- zJYB@Uicg|HdyoP=ui&Si|G0=x7ngDIv-9RqPy6rbF9oY~0BAmoZJPb}?ZE3R{0|>K zYz_qFkrxDW;OB&qZvh6g!2$OJlMn(s8NROq{|AZ$sXdDpnvVbg002ovPDHLkV1l$K Bh!p?; delta 379 zcmV->0fhed710ZjIDZ9$Nkl%}v8F6ae6);>v|hDn?)hreFomtiTlP(oHHP z?gcDJB_is`KaZy9tCUNVm)M{4Y$tBV_s`Fe`HbV3+dT}soBaNTy^nXVP4Q3r!$JX@ zPA{0izZSS!L+$S04pqf?x!zR82_it?OQ2r|u-%uLKJUJdzke-@b2I@0-30z-2u+U( zjgJc5YV1S=2pk3a%>d@8za@P7u5_lLu?P?d6NsAuq(q;#RD6ja)`(6_pjIHR1DHx= z>R;P7;s}Hb#CHHj|L{h10RpuGo3zfK+tSYja$EMo^U>d9Ky5pTBM>4GHv^cGf1dQm z<-d^nI4J=F1yTYr9f0I7Xaa{4IG;fOWx!KQebdPQusvUGU6}xZ9|C=6084NDCBNH` zz^VlL&H!>R`6U0U8eU-tB!PY%fR}sjC;}HJ(60k%sJegkHQ)&)v+)M)1Cj?r8Q@|C ZJ^;MjL?kPA;I9Ax002ovPDHLkV1gVNuQdPw diff --git a/rmodels.tmpzig b/rmodels.tmpzig new file mode 100644 index 0000000..c24bfc5 --- /dev/null +++ b/rmodels.tmpzig @@ -0,0 +1,40465 @@ +pub const __builtin_bswap16 = @import("std").zig.c_builtins.__builtin_bswap16; +pub const __builtin_bswap32 = @import("std").zig.c_builtins.__builtin_bswap32; +pub const __builtin_bswap64 = @import("std").zig.c_builtins.__builtin_bswap64; +pub const __builtin_signbit = @import("std").zig.c_builtins.__builtin_signbit; +pub const __builtin_signbitf = @import("std").zig.c_builtins.__builtin_signbitf; +pub const __builtin_popcount = @import("std").zig.c_builtins.__builtin_popcount; +pub const __builtin_ctz = @import("std").zig.c_builtins.__builtin_ctz; +pub const __builtin_clz = @import("std").zig.c_builtins.__builtin_clz; +pub const __builtin_sqrt = @import("std").zig.c_builtins.__builtin_sqrt; +pub const __builtin_sqrtf = @import("std").zig.c_builtins.__builtin_sqrtf; +pub const __builtin_sin = @import("std").zig.c_builtins.__builtin_sin; +pub const __builtin_sinf = @import("std").zig.c_builtins.__builtin_sinf; +pub const __builtin_cos = @import("std").zig.c_builtins.__builtin_cos; +pub const __builtin_cosf = @import("std").zig.c_builtins.__builtin_cosf; +pub const __builtin_exp = @import("std").zig.c_builtins.__builtin_exp; +pub const __builtin_expf = @import("std").zig.c_builtins.__builtin_expf; +pub const __builtin_exp2 = @import("std").zig.c_builtins.__builtin_exp2; +pub const __builtin_exp2f = @import("std").zig.c_builtins.__builtin_exp2f; +pub const __builtin_log = @import("std").zig.c_builtins.__builtin_log; +pub const __builtin_logf = @import("std").zig.c_builtins.__builtin_logf; +pub const __builtin_log2 = @import("std").zig.c_builtins.__builtin_log2; +pub const __builtin_log2f = @import("std").zig.c_builtins.__builtin_log2f; +pub const __builtin_log10 = @import("std").zig.c_builtins.__builtin_log10; +pub const __builtin_log10f = @import("std").zig.c_builtins.__builtin_log10f; +pub const __builtin_abs = @import("std").zig.c_builtins.__builtin_abs; +pub const __builtin_labs = @import("std").zig.c_builtins.__builtin_labs; +pub const __builtin_llabs = @import("std").zig.c_builtins.__builtin_llabs; +pub const __builtin_fabs = @import("std").zig.c_builtins.__builtin_fabs; +pub const __builtin_fabsf = @import("std").zig.c_builtins.__builtin_fabsf; +pub const __builtin_floor = @import("std").zig.c_builtins.__builtin_floor; +pub const __builtin_floorf = @import("std").zig.c_builtins.__builtin_floorf; +pub const __builtin_ceil = @import("std").zig.c_builtins.__builtin_ceil; +pub const __builtin_ceilf = @import("std").zig.c_builtins.__builtin_ceilf; +pub const __builtin_trunc = @import("std").zig.c_builtins.__builtin_trunc; +pub const __builtin_truncf = @import("std").zig.c_builtins.__builtin_truncf; +pub const __builtin_round = @import("std").zig.c_builtins.__builtin_round; +pub const __builtin_roundf = @import("std").zig.c_builtins.__builtin_roundf; +pub const __builtin_strlen = @import("std").zig.c_builtins.__builtin_strlen; +pub const __builtin_strcmp = @import("std").zig.c_builtins.__builtin_strcmp; +pub const __builtin_object_size = @import("std").zig.c_builtins.__builtin_object_size; +pub const __builtin___memset_chk = @import("std").zig.c_builtins.__builtin___memset_chk; +pub const __builtin_memset = @import("std").zig.c_builtins.__builtin_memset; +pub const __builtin___memcpy_chk = @import("std").zig.c_builtins.__builtin___memcpy_chk; +pub const __builtin_memcpy = @import("std").zig.c_builtins.__builtin_memcpy; +pub const __builtin_expect = @import("std").zig.c_builtins.__builtin_expect; +pub const __builtin_nanf = @import("std").zig.c_builtins.__builtin_nanf; +pub const __builtin_huge_valf = @import("std").zig.c_builtins.__builtin_huge_valf; +pub const __builtin_inff = @import("std").zig.c_builtins.__builtin_inff; +pub const __builtin_isnan = @import("std").zig.c_builtins.__builtin_isnan; +pub const __builtin_isinf = @import("std").zig.c_builtins.__builtin_isinf; +pub const __builtin_isinf_sign = @import("std").zig.c_builtins.__builtin_isinf_sign; +pub const __has_builtin = @import("std").zig.c_builtins.__has_builtin; +pub const __builtin_assume = @import("std").zig.c_builtins.__builtin_assume; +pub const __builtin_unreachable = @import("std").zig.c_builtins.__builtin_unreachable; +pub const __builtin_constant_p = @import("std").zig.c_builtins.__builtin_constant_p; +pub const __builtin_mul_overflow = @import("std").zig.c_builtins.__builtin_mul_overflow; +pub const struct___va_list_tag_1 = extern struct { + gp_offset: c_uint = @import("std").mem.zeroes(c_uint), + fp_offset: c_uint = @import("std").mem.zeroes(c_uint), + overflow_arg_area: ?*anyopaque = @import("std").mem.zeroes(?*anyopaque), + reg_save_area: ?*anyopaque = @import("std").mem.zeroes(?*anyopaque), +}; +pub const __builtin_va_list = [1]struct___va_list_tag_1; +pub const __gnuc_va_list = __builtin_va_list; +pub const va_list = __builtin_va_list; +pub const struct_Vector2 = extern struct { + x: f32 = @import("std").mem.zeroes(f32), + y: f32 = @import("std").mem.zeroes(f32), +}; +pub const Vector2 = struct_Vector2; +pub const struct_Vector3 = extern struct { + x: f32 = @import("std").mem.zeroes(f32), + y: f32 = @import("std").mem.zeroes(f32), + z: f32 = @import("std").mem.zeroes(f32), +}; +pub const Vector3 = struct_Vector3; +pub const struct_Vector4 = extern struct { + x: f32 = @import("std").mem.zeroes(f32), + y: f32 = @import("std").mem.zeroes(f32), + z: f32 = @import("std").mem.zeroes(f32), + w: f32 = @import("std").mem.zeroes(f32), +}; +pub const Vector4 = struct_Vector4; +pub const Quaternion = Vector4; +pub const struct_Matrix = extern struct { + m0: f32 = @import("std").mem.zeroes(f32), + m4: f32 = @import("std").mem.zeroes(f32), + m8: f32 = @import("std").mem.zeroes(f32), + m12: f32 = @import("std").mem.zeroes(f32), + m1: f32 = @import("std").mem.zeroes(f32), + m5: f32 = @import("std").mem.zeroes(f32), + m9: f32 = @import("std").mem.zeroes(f32), + m13: f32 = @import("std").mem.zeroes(f32), + m2: f32 = @import("std").mem.zeroes(f32), + m6: f32 = @import("std").mem.zeroes(f32), + m10: f32 = @import("std").mem.zeroes(f32), + m14: f32 = @import("std").mem.zeroes(f32), + m3: f32 = @import("std").mem.zeroes(f32), + m7: f32 = @import("std").mem.zeroes(f32), + m11: f32 = @import("std").mem.zeroes(f32), + m15: f32 = @import("std").mem.zeroes(f32), +}; +pub const Matrix = struct_Matrix; +pub const struct_Color = extern struct { + r: u8 = @import("std").mem.zeroes(u8), + g: u8 = @import("std").mem.zeroes(u8), + b: u8 = @import("std").mem.zeroes(u8), + a: u8 = @import("std").mem.zeroes(u8), +}; +pub const Color = struct_Color; +pub const struct_Rectangle = extern struct { + x: f32 = @import("std").mem.zeroes(f32), + y: f32 = @import("std").mem.zeroes(f32), + width: f32 = @import("std").mem.zeroes(f32), + height: f32 = @import("std").mem.zeroes(f32), +}; +pub const Rectangle = struct_Rectangle; +pub const struct_Image = extern struct { + data: ?*anyopaque = @import("std").mem.zeroes(?*anyopaque), + width: c_int = @import("std").mem.zeroes(c_int), + height: c_int = @import("std").mem.zeroes(c_int), + mipmaps: c_int = @import("std").mem.zeroes(c_int), + format: c_int = @import("std").mem.zeroes(c_int), +}; +pub const Image = struct_Image; +pub const struct_Texture = extern struct { + id: c_uint = @import("std").mem.zeroes(c_uint), + width: c_int = @import("std").mem.zeroes(c_int), + height: c_int = @import("std").mem.zeroes(c_int), + mipmaps: c_int = @import("std").mem.zeroes(c_int), + format: c_int = @import("std").mem.zeroes(c_int), +}; +pub const Texture = struct_Texture; +pub const Texture2D = Texture; +pub const TextureCubemap = Texture; +pub const struct_RenderTexture = extern struct { + id: c_uint = @import("std").mem.zeroes(c_uint), + texture: Texture = @import("std").mem.zeroes(Texture), + depth: Texture = @import("std").mem.zeroes(Texture), +}; +pub const RenderTexture = struct_RenderTexture; +pub const RenderTexture2D = RenderTexture; +pub const struct_NPatchInfo = extern struct { + source: Rectangle = @import("std").mem.zeroes(Rectangle), + left: c_int = @import("std").mem.zeroes(c_int), + top: c_int = @import("std").mem.zeroes(c_int), + right: c_int = @import("std").mem.zeroes(c_int), + bottom: c_int = @import("std").mem.zeroes(c_int), + layout: c_int = @import("std").mem.zeroes(c_int), +}; +pub const NPatchInfo = struct_NPatchInfo; +pub const struct_GlyphInfo = extern struct { + value: c_int = @import("std").mem.zeroes(c_int), + offsetX: c_int = @import("std").mem.zeroes(c_int), + offsetY: c_int = @import("std").mem.zeroes(c_int), + advanceX: c_int = @import("std").mem.zeroes(c_int), + image: Image = @import("std").mem.zeroes(Image), +}; +pub const GlyphInfo = struct_GlyphInfo; +pub const struct_Font = extern struct { + baseSize: c_int = @import("std").mem.zeroes(c_int), + glyphCount: c_int = @import("std").mem.zeroes(c_int), + glyphPadding: c_int = @import("std").mem.zeroes(c_int), + texture: Texture2D = @import("std").mem.zeroes(Texture2D), + recs: [*c]Rectangle = @import("std").mem.zeroes([*c]Rectangle), + glyphs: [*c]GlyphInfo = @import("std").mem.zeroes([*c]GlyphInfo), +}; +pub const Font = struct_Font; +pub const struct_Camera3D = extern struct { + position: Vector3 = @import("std").mem.zeroes(Vector3), + target: Vector3 = @import("std").mem.zeroes(Vector3), + up: Vector3 = @import("std").mem.zeroes(Vector3), + fovy: f32 = @import("std").mem.zeroes(f32), + projection: c_int = @import("std").mem.zeroes(c_int), +}; +pub const Camera3D = struct_Camera3D; +pub const Camera = Camera3D; +pub const struct_Camera2D = extern struct { + offset: Vector2 = @import("std").mem.zeroes(Vector2), + target: Vector2 = @import("std").mem.zeroes(Vector2), + rotation: f32 = @import("std").mem.zeroes(f32), + zoom: f32 = @import("std").mem.zeroes(f32), +}; +pub const Camera2D = struct_Camera2D; +pub const struct_Mesh = extern struct { + vertexCount: c_int = @import("std").mem.zeroes(c_int), + triangleCount: c_int = @import("std").mem.zeroes(c_int), + vertices: [*c]f32 = @import("std").mem.zeroes([*c]f32), + texcoords: [*c]f32 = @import("std").mem.zeroes([*c]f32), + texcoords2: [*c]f32 = @import("std").mem.zeroes([*c]f32), + normals: [*c]f32 = @import("std").mem.zeroes([*c]f32), + tangents: [*c]f32 = @import("std").mem.zeroes([*c]f32), + colors: [*c]u8 = @import("std").mem.zeroes([*c]u8), + indices: [*c]c_ushort = @import("std").mem.zeroes([*c]c_ushort), + animVertices: [*c]f32 = @import("std").mem.zeroes([*c]f32), + animNormals: [*c]f32 = @import("std").mem.zeroes([*c]f32), + boneIds: [*c]u8 = @import("std").mem.zeroes([*c]u8), + boneWeights: [*c]f32 = @import("std").mem.zeroes([*c]f32), + vaoId: c_uint = @import("std").mem.zeroes(c_uint), + vboId: [*c]c_uint = @import("std").mem.zeroes([*c]c_uint), +}; +pub const Mesh = struct_Mesh; +pub const struct_Shader = extern struct { + id: c_uint = @import("std").mem.zeroes(c_uint), + locs: [*c]c_int = @import("std").mem.zeroes([*c]c_int), +}; +pub const Shader = struct_Shader; +pub const struct_MaterialMap = extern struct { + texture: Texture2D = @import("std").mem.zeroes(Texture2D), + color: Color = @import("std").mem.zeroes(Color), + value: f32 = @import("std").mem.zeroes(f32), +}; +pub const MaterialMap = struct_MaterialMap; +pub const struct_Material = extern struct { + shader: Shader = @import("std").mem.zeroes(Shader), + maps: [*c]MaterialMap = @import("std").mem.zeroes([*c]MaterialMap), + params: [4]f32 = @import("std").mem.zeroes([4]f32), +}; +pub const Material = struct_Material; +pub const struct_Transform = extern struct { + translation: Vector3 = @import("std").mem.zeroes(Vector3), + rotation: Quaternion = @import("std").mem.zeroes(Quaternion), + scale: Vector3 = @import("std").mem.zeroes(Vector3), +}; +pub const Transform = struct_Transform; +pub const struct_BoneInfo = extern struct { + name: [32]u8 = @import("std").mem.zeroes([32]u8), + parent: c_int = @import("std").mem.zeroes(c_int), +}; +pub const BoneInfo = struct_BoneInfo; +pub const struct_Model = extern struct { + transform: Matrix = @import("std").mem.zeroes(Matrix), + meshCount: c_int = @import("std").mem.zeroes(c_int), + materialCount: c_int = @import("std").mem.zeroes(c_int), + meshes: [*c]Mesh = @import("std").mem.zeroes([*c]Mesh), + materials: [*c]Material = @import("std").mem.zeroes([*c]Material), + meshMaterial: [*c]c_int = @import("std").mem.zeroes([*c]c_int), + boneCount: c_int = @import("std").mem.zeroes(c_int), + bones: [*c]BoneInfo = @import("std").mem.zeroes([*c]BoneInfo), + bindPose: [*c]Transform = @import("std").mem.zeroes([*c]Transform), +}; +pub const Model = struct_Model; +pub const struct_ModelAnimation = extern struct { + boneCount: c_int = @import("std").mem.zeroes(c_int), + frameCount: c_int = @import("std").mem.zeroes(c_int), + bones: [*c]BoneInfo = @import("std").mem.zeroes([*c]BoneInfo), + framePoses: [*c][*c]Transform = @import("std").mem.zeroes([*c][*c]Transform), + name: [32]u8 = @import("std").mem.zeroes([32]u8), +}; +pub const ModelAnimation = struct_ModelAnimation; +pub const struct_Ray = extern struct { + position: Vector3 = @import("std").mem.zeroes(Vector3), + direction: Vector3 = @import("std").mem.zeroes(Vector3), +}; +pub const Ray = struct_Ray; +pub const struct_RayCollision = extern struct { + hit: bool = @import("std").mem.zeroes(bool), + distance: f32 = @import("std").mem.zeroes(f32), + point: Vector3 = @import("std").mem.zeroes(Vector3), + normal: Vector3 = @import("std").mem.zeroes(Vector3), +}; +pub const RayCollision = struct_RayCollision; +pub const struct_BoundingBox = extern struct { + min: Vector3 = @import("std").mem.zeroes(Vector3), + max: Vector3 = @import("std").mem.zeroes(Vector3), +}; +pub const BoundingBox = struct_BoundingBox; +pub const struct_Wave = extern struct { + frameCount: c_uint = @import("std").mem.zeroes(c_uint), + sampleRate: c_uint = @import("std").mem.zeroes(c_uint), + sampleSize: c_uint = @import("std").mem.zeroes(c_uint), + channels: c_uint = @import("std").mem.zeroes(c_uint), + data: ?*anyopaque = @import("std").mem.zeroes(?*anyopaque), +}; +pub const Wave = struct_Wave; +pub const struct_rAudioBuffer = opaque {}; +pub const rAudioBuffer = struct_rAudioBuffer; +pub const struct_rAudioProcessor = opaque {}; +pub const rAudioProcessor = struct_rAudioProcessor; +pub const struct_AudioStream = extern struct { + buffer: ?*rAudioBuffer = @import("std").mem.zeroes(?*rAudioBuffer), + processor: ?*rAudioProcessor = @import("std").mem.zeroes(?*rAudioProcessor), + sampleRate: c_uint = @import("std").mem.zeroes(c_uint), + sampleSize: c_uint = @import("std").mem.zeroes(c_uint), + channels: c_uint = @import("std").mem.zeroes(c_uint), +}; +pub const AudioStream = struct_AudioStream; +pub const struct_Sound = extern struct { + stream: AudioStream = @import("std").mem.zeroes(AudioStream), + frameCount: c_uint = @import("std").mem.zeroes(c_uint), +}; +pub const Sound = struct_Sound; +pub const struct_Music = extern struct { + stream: AudioStream = @import("std").mem.zeroes(AudioStream), + frameCount: c_uint = @import("std").mem.zeroes(c_uint), + looping: bool = @import("std").mem.zeroes(bool), + ctxType: c_int = @import("std").mem.zeroes(c_int), + ctxData: ?*anyopaque = @import("std").mem.zeroes(?*anyopaque), +}; +pub const Music = struct_Music; +pub const struct_VrDeviceInfo = extern struct { + hResolution: c_int = @import("std").mem.zeroes(c_int), + vResolution: c_int = @import("std").mem.zeroes(c_int), + hScreenSize: f32 = @import("std").mem.zeroes(f32), + vScreenSize: f32 = @import("std").mem.zeroes(f32), + eyeToScreenDistance: f32 = @import("std").mem.zeroes(f32), + lensSeparationDistance: f32 = @import("std").mem.zeroes(f32), + interpupillaryDistance: f32 = @import("std").mem.zeroes(f32), + lensDistortionValues: [4]f32 = @import("std").mem.zeroes([4]f32), + chromaAbCorrection: [4]f32 = @import("std").mem.zeroes([4]f32), +}; +pub const VrDeviceInfo = struct_VrDeviceInfo; +pub const struct_VrStereoConfig = extern struct { + projection: [2]Matrix = @import("std").mem.zeroes([2]Matrix), + viewOffset: [2]Matrix = @import("std").mem.zeroes([2]Matrix), + leftLensCenter: [2]f32 = @import("std").mem.zeroes([2]f32), + rightLensCenter: [2]f32 = @import("std").mem.zeroes([2]f32), + leftScreenCenter: [2]f32 = @import("std").mem.zeroes([2]f32), + rightScreenCenter: [2]f32 = @import("std").mem.zeroes([2]f32), + scale: [2]f32 = @import("std").mem.zeroes([2]f32), + scaleIn: [2]f32 = @import("std").mem.zeroes([2]f32), +}; +pub const VrStereoConfig = struct_VrStereoConfig; +pub const struct_FilePathList = extern struct { + capacity: c_uint = @import("std").mem.zeroes(c_uint), + count: c_uint = @import("std").mem.zeroes(c_uint), + paths: [*c][*c]u8 = @import("std").mem.zeroes([*c][*c]u8), +}; +pub const FilePathList = struct_FilePathList; +pub const struct_AutomationEvent = extern struct { + frame: c_uint = @import("std").mem.zeroes(c_uint), + type: c_uint = @import("std").mem.zeroes(c_uint), + params: [4]c_int = @import("std").mem.zeroes([4]c_int), +}; +pub const AutomationEvent = struct_AutomationEvent; +pub const struct_AutomationEventList = extern struct { + capacity: c_uint = @import("std").mem.zeroes(c_uint), + count: c_uint = @import("std").mem.zeroes(c_uint), + events: [*c]AutomationEvent = @import("std").mem.zeroes([*c]AutomationEvent), +}; +pub const AutomationEventList = struct_AutomationEventList; +pub const FLAG_VSYNC_HINT: c_int = 64; +pub const FLAG_FULLSCREEN_MODE: c_int = 2; +pub const FLAG_WINDOW_RESIZABLE: c_int = 4; +pub const FLAG_WINDOW_UNDECORATED: c_int = 8; +pub const FLAG_WINDOW_HIDDEN: c_int = 128; +pub const FLAG_WINDOW_MINIMIZED: c_int = 512; +pub const FLAG_WINDOW_MAXIMIZED: c_int = 1024; +pub const FLAG_WINDOW_UNFOCUSED: c_int = 2048; +pub const FLAG_WINDOW_TOPMOST: c_int = 4096; +pub const FLAG_WINDOW_ALWAYS_RUN: c_int = 256; +pub const FLAG_WINDOW_TRANSPARENT: c_int = 16; +pub const FLAG_WINDOW_HIGHDPI: c_int = 8192; +pub const FLAG_WINDOW_MOUSE_PASSTHROUGH: c_int = 16384; +pub const FLAG_BORDERLESS_WINDOWED_MODE: c_int = 32768; +pub const FLAG_MSAA_4X_HINT: c_int = 32; +pub const FLAG_INTERLACED_HINT: c_int = 65536; +pub const ConfigFlags = c_uint; +pub const LOG_ALL: c_int = 0; +pub const LOG_TRACE: c_int = 1; +pub const LOG_DEBUG: c_int = 2; +pub const LOG_INFO: c_int = 3; +pub const LOG_WARNING: c_int = 4; +pub const LOG_ERROR: c_int = 5; +pub const LOG_FATAL: c_int = 6; +pub const LOG_NONE: c_int = 7; +pub const TraceLogLevel = c_uint; +pub const KEY_NULL: c_int = 0; +pub const KEY_APOSTROPHE: c_int = 39; +pub const KEY_COMMA: c_int = 44; +pub const KEY_MINUS: c_int = 45; +pub const KEY_PERIOD: c_int = 46; +pub const KEY_SLASH: c_int = 47; +pub const KEY_ZERO: c_int = 48; +pub const KEY_ONE: c_int = 49; +pub const KEY_TWO: c_int = 50; +pub const KEY_THREE: c_int = 51; +pub const KEY_FOUR: c_int = 52; +pub const KEY_FIVE: c_int = 53; +pub const KEY_SIX: c_int = 54; +pub const KEY_SEVEN: c_int = 55; +pub const KEY_EIGHT: c_int = 56; +pub const KEY_NINE: c_int = 57; +pub const KEY_SEMICOLON: c_int = 59; +pub const KEY_EQUAL: c_int = 61; +pub const KEY_A: c_int = 65; +pub const KEY_B: c_int = 66; +pub const KEY_C: c_int = 67; +pub const KEY_D: c_int = 68; +pub const KEY_E: c_int = 69; +pub const KEY_F: c_int = 70; +pub const KEY_G: c_int = 71; +pub const KEY_H: c_int = 72; +pub const KEY_I: c_int = 73; +pub const KEY_J: c_int = 74; +pub const KEY_K: c_int = 75; +pub const KEY_L: c_int = 76; +pub const KEY_M: c_int = 77; +pub const KEY_N: c_int = 78; +pub const KEY_O: c_int = 79; +pub const KEY_P: c_int = 80; +pub const KEY_Q: c_int = 81; +pub const KEY_R: c_int = 82; +pub const KEY_S: c_int = 83; +pub const KEY_T: c_int = 84; +pub const KEY_U: c_int = 85; +pub const KEY_V: c_int = 86; +pub const KEY_W: c_int = 87; +pub const KEY_X: c_int = 88; +pub const KEY_Y: c_int = 89; +pub const KEY_Z: c_int = 90; +pub const KEY_LEFT_BRACKET: c_int = 91; +pub const KEY_BACKSLASH: c_int = 92; +pub const KEY_RIGHT_BRACKET: c_int = 93; +pub const KEY_GRAVE: c_int = 96; +pub const KEY_SPACE: c_int = 32; +pub const KEY_ESCAPE: c_int = 256; +pub const KEY_ENTER: c_int = 257; +pub const KEY_TAB: c_int = 258; +pub const KEY_BACKSPACE: c_int = 259; +pub const KEY_INSERT: c_int = 260; +pub const KEY_DELETE: c_int = 261; +pub const KEY_RIGHT: c_int = 262; +pub const KEY_LEFT: c_int = 263; +pub const KEY_DOWN: c_int = 264; +pub const KEY_UP: c_int = 265; +pub const KEY_PAGE_UP: c_int = 266; +pub const KEY_PAGE_DOWN: c_int = 267; +pub const KEY_HOME: c_int = 268; +pub const KEY_END: c_int = 269; +pub const KEY_CAPS_LOCK: c_int = 280; +pub const KEY_SCROLL_LOCK: c_int = 281; +pub const KEY_NUM_LOCK: c_int = 282; +pub const KEY_PRINT_SCREEN: c_int = 283; +pub const KEY_PAUSE: c_int = 284; +pub const KEY_F1: c_int = 290; +pub const KEY_F2: c_int = 291; +pub const KEY_F3: c_int = 292; +pub const KEY_F4: c_int = 293; +pub const KEY_F5: c_int = 294; +pub const KEY_F6: c_int = 295; +pub const KEY_F7: c_int = 296; +pub const KEY_F8: c_int = 297; +pub const KEY_F9: c_int = 298; +pub const KEY_F10: c_int = 299; +pub const KEY_F11: c_int = 300; +pub const KEY_F12: c_int = 301; +pub const KEY_LEFT_SHIFT: c_int = 340; +pub const KEY_LEFT_CONTROL: c_int = 341; +pub const KEY_LEFT_ALT: c_int = 342; +pub const KEY_LEFT_SUPER: c_int = 343; +pub const KEY_RIGHT_SHIFT: c_int = 344; +pub const KEY_RIGHT_CONTROL: c_int = 345; +pub const KEY_RIGHT_ALT: c_int = 346; +pub const KEY_RIGHT_SUPER: c_int = 347; +pub const KEY_KB_MENU: c_int = 348; +pub const KEY_KP_0: c_int = 320; +pub const KEY_KP_1: c_int = 321; +pub const KEY_KP_2: c_int = 322; +pub const KEY_KP_3: c_int = 323; +pub const KEY_KP_4: c_int = 324; +pub const KEY_KP_5: c_int = 325; +pub const KEY_KP_6: c_int = 326; +pub const KEY_KP_7: c_int = 327; +pub const KEY_KP_8: c_int = 328; +pub const KEY_KP_9: c_int = 329; +pub const KEY_KP_DECIMAL: c_int = 330; +pub const KEY_KP_DIVIDE: c_int = 331; +pub const KEY_KP_MULTIPLY: c_int = 332; +pub const KEY_KP_SUBTRACT: c_int = 333; +pub const KEY_KP_ADD: c_int = 334; +pub const KEY_KP_ENTER: c_int = 335; +pub const KEY_KP_EQUAL: c_int = 336; +pub const KEY_BACK: c_int = 4; +pub const KEY_MENU: c_int = 5; +pub const KEY_VOLUME_UP: c_int = 24; +pub const KEY_VOLUME_DOWN: c_int = 25; +pub const KeyboardKey = c_uint; +pub const MOUSE_BUTTON_LEFT: c_int = 0; +pub const MOUSE_BUTTON_RIGHT: c_int = 1; +pub const MOUSE_BUTTON_MIDDLE: c_int = 2; +pub const MOUSE_BUTTON_SIDE: c_int = 3; +pub const MOUSE_BUTTON_EXTRA: c_int = 4; +pub const MOUSE_BUTTON_FORWARD: c_int = 5; +pub const MOUSE_BUTTON_BACK: c_int = 6; +pub const MouseButton = c_uint; +pub const MOUSE_CURSOR_DEFAULT: c_int = 0; +pub const MOUSE_CURSOR_ARROW: c_int = 1; +pub const MOUSE_CURSOR_IBEAM: c_int = 2; +pub const MOUSE_CURSOR_CROSSHAIR: c_int = 3; +pub const MOUSE_CURSOR_POINTING_HAND: c_int = 4; +pub const MOUSE_CURSOR_RESIZE_EW: c_int = 5; +pub const MOUSE_CURSOR_RESIZE_NS: c_int = 6; +pub const MOUSE_CURSOR_RESIZE_NWSE: c_int = 7; +pub const MOUSE_CURSOR_RESIZE_NESW: c_int = 8; +pub const MOUSE_CURSOR_RESIZE_ALL: c_int = 9; +pub const MOUSE_CURSOR_NOT_ALLOWED: c_int = 10; +pub const MouseCursor = c_uint; +pub const GAMEPAD_BUTTON_UNKNOWN: c_int = 0; +pub const GAMEPAD_BUTTON_LEFT_FACE_UP: c_int = 1; +pub const GAMEPAD_BUTTON_LEFT_FACE_RIGHT: c_int = 2; +pub const GAMEPAD_BUTTON_LEFT_FACE_DOWN: c_int = 3; +pub const GAMEPAD_BUTTON_LEFT_FACE_LEFT: c_int = 4; +pub const GAMEPAD_BUTTON_RIGHT_FACE_UP: c_int = 5; +pub const GAMEPAD_BUTTON_RIGHT_FACE_RIGHT: c_int = 6; +pub const GAMEPAD_BUTTON_RIGHT_FACE_DOWN: c_int = 7; +pub const GAMEPAD_BUTTON_RIGHT_FACE_LEFT: c_int = 8; +pub const GAMEPAD_BUTTON_LEFT_TRIGGER_1: c_int = 9; +pub const GAMEPAD_BUTTON_LEFT_TRIGGER_2: c_int = 10; +pub const GAMEPAD_BUTTON_RIGHT_TRIGGER_1: c_int = 11; +pub const GAMEPAD_BUTTON_RIGHT_TRIGGER_2: c_int = 12; +pub const GAMEPAD_BUTTON_MIDDLE_LEFT: c_int = 13; +pub const GAMEPAD_BUTTON_MIDDLE: c_int = 14; +pub const GAMEPAD_BUTTON_MIDDLE_RIGHT: c_int = 15; +pub const GAMEPAD_BUTTON_LEFT_THUMB: c_int = 16; +pub const GAMEPAD_BUTTON_RIGHT_THUMB: c_int = 17; +pub const GamepadButton = c_uint; +pub const GAMEPAD_AXIS_LEFT_X: c_int = 0; +pub const GAMEPAD_AXIS_LEFT_Y: c_int = 1; +pub const GAMEPAD_AXIS_RIGHT_X: c_int = 2; +pub const GAMEPAD_AXIS_RIGHT_Y: c_int = 3; +pub const GAMEPAD_AXIS_LEFT_TRIGGER: c_int = 4; +pub const GAMEPAD_AXIS_RIGHT_TRIGGER: c_int = 5; +pub const GamepadAxis = c_uint; +pub const MATERIAL_MAP_ALBEDO: c_int = 0; +pub const MATERIAL_MAP_METALNESS: c_int = 1; +pub const MATERIAL_MAP_NORMAL: c_int = 2; +pub const MATERIAL_MAP_ROUGHNESS: c_int = 3; +pub const MATERIAL_MAP_OCCLUSION: c_int = 4; +pub const MATERIAL_MAP_EMISSION: c_int = 5; +pub const MATERIAL_MAP_HEIGHT: c_int = 6; +pub const MATERIAL_MAP_CUBEMAP: c_int = 7; +pub const MATERIAL_MAP_IRRADIANCE: c_int = 8; +pub const MATERIAL_MAP_PREFILTER: c_int = 9; +pub const MATERIAL_MAP_BRDF: c_int = 10; +pub const MaterialMapIndex = c_uint; +pub const SHADER_LOC_VERTEX_POSITION: c_int = 0; +pub const SHADER_LOC_VERTEX_TEXCOORD01: c_int = 1; +pub const SHADER_LOC_VERTEX_TEXCOORD02: c_int = 2; +pub const SHADER_LOC_VERTEX_NORMAL: c_int = 3; +pub const SHADER_LOC_VERTEX_TANGENT: c_int = 4; +pub const SHADER_LOC_VERTEX_COLOR: c_int = 5; +pub const SHADER_LOC_MATRIX_MVP: c_int = 6; +pub const SHADER_LOC_MATRIX_VIEW: c_int = 7; +pub const SHADER_LOC_MATRIX_PROJECTION: c_int = 8; +pub const SHADER_LOC_MATRIX_MODEL: c_int = 9; +pub const SHADER_LOC_MATRIX_NORMAL: c_int = 10; +pub const SHADER_LOC_VECTOR_VIEW: c_int = 11; +pub const SHADER_LOC_COLOR_DIFFUSE: c_int = 12; +pub const SHADER_LOC_COLOR_SPECULAR: c_int = 13; +pub const SHADER_LOC_COLOR_AMBIENT: c_int = 14; +pub const SHADER_LOC_MAP_ALBEDO: c_int = 15; +pub const SHADER_LOC_MAP_METALNESS: c_int = 16; +pub const SHADER_LOC_MAP_NORMAL: c_int = 17; +pub const SHADER_LOC_MAP_ROUGHNESS: c_int = 18; +pub const SHADER_LOC_MAP_OCCLUSION: c_int = 19; +pub const SHADER_LOC_MAP_EMISSION: c_int = 20; +pub const SHADER_LOC_MAP_HEIGHT: c_int = 21; +pub const SHADER_LOC_MAP_CUBEMAP: c_int = 22; +pub const SHADER_LOC_MAP_IRRADIANCE: c_int = 23; +pub const SHADER_LOC_MAP_PREFILTER: c_int = 24; +pub const SHADER_LOC_MAP_BRDF: c_int = 25; +pub const ShaderLocationIndex = c_uint; +pub const SHADER_UNIFORM_FLOAT: c_int = 0; +pub const SHADER_UNIFORM_VEC2: c_int = 1; +pub const SHADER_UNIFORM_VEC3: c_int = 2; +pub const SHADER_UNIFORM_VEC4: c_int = 3; +pub const SHADER_UNIFORM_INT: c_int = 4; +pub const SHADER_UNIFORM_IVEC2: c_int = 5; +pub const SHADER_UNIFORM_IVEC3: c_int = 6; +pub const SHADER_UNIFORM_IVEC4: c_int = 7; +pub const SHADER_UNIFORM_SAMPLER2D: c_int = 8; +pub const ShaderUniformDataType = c_uint; +pub const SHADER_ATTRIB_FLOAT: c_int = 0; +pub const SHADER_ATTRIB_VEC2: c_int = 1; +pub const SHADER_ATTRIB_VEC3: c_int = 2; +pub const SHADER_ATTRIB_VEC4: c_int = 3; +pub const ShaderAttributeDataType = c_uint; +pub const PIXELFORMAT_UNCOMPRESSED_GRAYSCALE: c_int = 1; +pub const PIXELFORMAT_UNCOMPRESSED_GRAY_ALPHA: c_int = 2; +pub const PIXELFORMAT_UNCOMPRESSED_R5G6B5: c_int = 3; +pub const PIXELFORMAT_UNCOMPRESSED_R8G8B8: c_int = 4; +pub const PIXELFORMAT_UNCOMPRESSED_R5G5B5A1: c_int = 5; +pub const PIXELFORMAT_UNCOMPRESSED_R4G4B4A4: c_int = 6; +pub const PIXELFORMAT_UNCOMPRESSED_R8G8B8A8: c_int = 7; +pub const PIXELFORMAT_UNCOMPRESSED_R32: c_int = 8; +pub const PIXELFORMAT_UNCOMPRESSED_R32G32B32: c_int = 9; +pub const PIXELFORMAT_UNCOMPRESSED_R32G32B32A32: c_int = 10; +pub const PIXELFORMAT_UNCOMPRESSED_R16: c_int = 11; +pub const PIXELFORMAT_UNCOMPRESSED_R16G16B16: c_int = 12; +pub const PIXELFORMAT_UNCOMPRESSED_R16G16B16A16: c_int = 13; +pub const PIXELFORMAT_COMPRESSED_DXT1_RGB: c_int = 14; +pub const PIXELFORMAT_COMPRESSED_DXT1_RGBA: c_int = 15; +pub const PIXELFORMAT_COMPRESSED_DXT3_RGBA: c_int = 16; +pub const PIXELFORMAT_COMPRESSED_DXT5_RGBA: c_int = 17; +pub const PIXELFORMAT_COMPRESSED_ETC1_RGB: c_int = 18; +pub const PIXELFORMAT_COMPRESSED_ETC2_RGB: c_int = 19; +pub const PIXELFORMAT_COMPRESSED_ETC2_EAC_RGBA: c_int = 20; +pub const PIXELFORMAT_COMPRESSED_PVRT_RGB: c_int = 21; +pub const PIXELFORMAT_COMPRESSED_PVRT_RGBA: c_int = 22; +pub const PIXELFORMAT_COMPRESSED_ASTC_4x4_RGBA: c_int = 23; +pub const PIXELFORMAT_COMPRESSED_ASTC_8x8_RGBA: c_int = 24; +pub const PixelFormat = c_uint; +pub const TEXTURE_FILTER_POINT: c_int = 0; +pub const TEXTURE_FILTER_BILINEAR: c_int = 1; +pub const TEXTURE_FILTER_TRILINEAR: c_int = 2; +pub const TEXTURE_FILTER_ANISOTROPIC_4X: c_int = 3; +pub const TEXTURE_FILTER_ANISOTROPIC_8X: c_int = 4; +pub const TEXTURE_FILTER_ANISOTROPIC_16X: c_int = 5; +pub const TextureFilter = c_uint; +pub const TEXTURE_WRAP_REPEAT: c_int = 0; +pub const TEXTURE_WRAP_CLAMP: c_int = 1; +pub const TEXTURE_WRAP_MIRROR_REPEAT: c_int = 2; +pub const TEXTURE_WRAP_MIRROR_CLAMP: c_int = 3; +pub const TextureWrap = c_uint; +pub const CUBEMAP_LAYOUT_AUTO_DETECT: c_int = 0; +pub const CUBEMAP_LAYOUT_LINE_VERTICAL: c_int = 1; +pub const CUBEMAP_LAYOUT_LINE_HORIZONTAL: c_int = 2; +pub const CUBEMAP_LAYOUT_CROSS_THREE_BY_FOUR: c_int = 3; +pub const CUBEMAP_LAYOUT_CROSS_FOUR_BY_THREE: c_int = 4; +pub const CUBEMAP_LAYOUT_PANORAMA: c_int = 5; +pub const CubemapLayout = c_uint; +pub const FONT_DEFAULT: c_int = 0; +pub const FONT_BITMAP: c_int = 1; +pub const FONT_SDF: c_int = 2; +pub const FontType = c_uint; +pub const BLEND_ALPHA: c_int = 0; +pub const BLEND_ADDITIVE: c_int = 1; +pub const BLEND_MULTIPLIED: c_int = 2; +pub const BLEND_ADD_COLORS: c_int = 3; +pub const BLEND_SUBTRACT_COLORS: c_int = 4; +pub const BLEND_ALPHA_PREMULTIPLY: c_int = 5; +pub const BLEND_CUSTOM: c_int = 6; +pub const BLEND_CUSTOM_SEPARATE: c_int = 7; +pub const BlendMode = c_uint; +pub const GESTURE_NONE: c_int = 0; +pub const GESTURE_TAP: c_int = 1; +pub const GESTURE_DOUBLETAP: c_int = 2; +pub const GESTURE_HOLD: c_int = 4; +pub const GESTURE_DRAG: c_int = 8; +pub const GESTURE_SWIPE_RIGHT: c_int = 16; +pub const GESTURE_SWIPE_LEFT: c_int = 32; +pub const GESTURE_SWIPE_UP: c_int = 64; +pub const GESTURE_SWIPE_DOWN: c_int = 128; +pub const GESTURE_PINCH_IN: c_int = 256; +pub const GESTURE_PINCH_OUT: c_int = 512; +pub const Gesture = c_uint; +pub const CAMERA_CUSTOM: c_int = 0; +pub const CAMERA_FREE: c_int = 1; +pub const CAMERA_ORBITAL: c_int = 2; +pub const CAMERA_FIRST_PERSON: c_int = 3; +pub const CAMERA_THIRD_PERSON: c_int = 4; +pub const CameraMode = c_uint; +pub const CAMERA_PERSPECTIVE: c_int = 0; +pub const CAMERA_ORTHOGRAPHIC: c_int = 1; +pub const CameraProjection = c_uint; +pub const NPATCH_NINE_PATCH: c_int = 0; +pub const NPATCH_THREE_PATCH_VERTICAL: c_int = 1; +pub const NPATCH_THREE_PATCH_HORIZONTAL: c_int = 2; +pub const NPatchLayout = c_uint; +pub const TraceLogCallback = ?*const fn (c_int, [*c]const u8, [*c]struct___va_list_tag_1) callconv(.C) void; +pub const LoadFileDataCallback = ?*const fn ([*c]const u8, [*c]c_int) callconv(.C) [*c]u8; +pub const SaveFileDataCallback = ?*const fn ([*c]const u8, ?*anyopaque, c_int) callconv(.C) bool; +pub const LoadFileTextCallback = ?*const fn ([*c]const u8) callconv(.C) [*c]u8; +pub const SaveFileTextCallback = ?*const fn ([*c]const u8, [*c]u8) callconv(.C) bool; +pub extern fn InitWindow(width: c_int, height: c_int, title: [*c]const u8) void; +pub extern fn CloseWindow() void; +pub extern fn WindowShouldClose() bool; +pub extern fn IsWindowReady() bool; +pub extern fn IsWindowFullscreen() bool; +pub extern fn IsWindowHidden() bool; +pub extern fn IsWindowMinimized() bool; +pub extern fn IsWindowMaximized() bool; +pub extern fn IsWindowFocused() bool; +pub extern fn IsWindowResized() bool; +pub extern fn IsWindowState(flag: c_uint) bool; +pub extern fn SetWindowState(flags: c_uint) void; +pub extern fn ClearWindowState(flags: c_uint) void; +pub extern fn ToggleFullscreen() void; +pub extern fn ToggleBorderlessWindowed() void; +pub extern fn MaximizeWindow() void; +pub extern fn MinimizeWindow() void; +pub extern fn RestoreWindow() void; +pub extern fn SetWindowIcon(image: Image) void; +pub extern fn SetWindowIcons(images: [*c]Image, count: c_int) void; +pub extern fn SetWindowTitle(title: [*c]const u8) void; +pub extern fn SetWindowPosition(x: c_int, y: c_int) void; +pub extern fn SetWindowMonitor(monitor: c_int) void; +pub extern fn SetWindowMinSize(width: c_int, height: c_int) void; +pub extern fn SetWindowMaxSize(width: c_int, height: c_int) void; +pub extern fn SetWindowSize(width: c_int, height: c_int) void; +pub extern fn SetWindowOpacity(opacity: f32) void; +pub extern fn SetWindowFocused() void; +pub extern fn GetWindowHandle() ?*anyopaque; +pub extern fn GetScreenWidth() c_int; +pub extern fn GetScreenHeight() c_int; +pub extern fn GetRenderWidth() c_int; +pub extern fn GetRenderHeight() c_int; +pub extern fn GetMonitorCount() c_int; +pub extern fn GetCurrentMonitor() c_int; +pub extern fn GetMonitorPosition(monitor: c_int) Vector2; +pub extern fn GetMonitorWidth(monitor: c_int) c_int; +pub extern fn GetMonitorHeight(monitor: c_int) c_int; +pub extern fn GetMonitorPhysicalWidth(monitor: c_int) c_int; +pub extern fn GetMonitorPhysicalHeight(monitor: c_int) c_int; +pub extern fn GetMonitorRefreshRate(monitor: c_int) c_int; +pub extern fn GetWindowPosition() Vector2; +pub extern fn GetWindowScaleDPI() Vector2; +pub extern fn GetMonitorName(monitor: c_int) [*c]const u8; +pub extern fn SetClipboardText(text: [*c]const u8) void; +pub extern fn GetClipboardText() [*c]const u8; +pub extern fn EnableEventWaiting() void; +pub extern fn DisableEventWaiting() void; +pub extern fn ShowCursor() void; +pub extern fn HideCursor() void; +pub extern fn IsCursorHidden() bool; +pub extern fn EnableCursor() void; +pub extern fn DisableCursor() void; +pub extern fn IsCursorOnScreen() bool; +pub extern fn ClearBackground(color: Color) void; +pub extern fn BeginDrawing() void; +pub extern fn EndDrawing() void; +pub extern fn BeginMode2D(camera: Camera2D) void; +pub extern fn EndMode2D() void; +pub extern fn BeginMode3D(camera: Camera3D) void; +pub extern fn EndMode3D() void; +pub extern fn BeginTextureMode(target: RenderTexture2D) void; +pub extern fn EndTextureMode() void; +pub extern fn BeginShaderMode(shader: Shader) void; +pub extern fn EndShaderMode() void; +pub extern fn BeginBlendMode(mode: c_int) void; +pub extern fn EndBlendMode() void; +pub extern fn BeginScissorMode(x: c_int, y: c_int, width: c_int, height: c_int) void; +pub extern fn EndScissorMode() void; +pub extern fn BeginVrStereoMode(config: VrStereoConfig) void; +pub extern fn EndVrStereoMode() void; +pub extern fn LoadVrStereoConfig(device: VrDeviceInfo) VrStereoConfig; +pub extern fn UnloadVrStereoConfig(config: VrStereoConfig) void; +pub extern fn LoadShader(vsFileName: [*c]const u8, fsFileName: [*c]const u8) Shader; +pub extern fn LoadShaderFromMemory(vsCode: [*c]const u8, fsCode: [*c]const u8) Shader; +pub extern fn IsShaderReady(shader: Shader) bool; +pub extern fn GetShaderLocation(shader: Shader, uniformName: [*c]const u8) c_int; +pub extern fn GetShaderLocationAttrib(shader: Shader, attribName: [*c]const u8) c_int; +pub extern fn SetShaderValue(shader: Shader, locIndex: c_int, value: ?*const anyopaque, uniformType: c_int) void; +pub extern fn SetShaderValueV(shader: Shader, locIndex: c_int, value: ?*const anyopaque, uniformType: c_int, count: c_int) void; +pub extern fn SetShaderValueMatrix(shader: Shader, locIndex: c_int, mat: Matrix) void; +pub extern fn SetShaderValueTexture(shader: Shader, locIndex: c_int, texture: Texture2D) void; +pub extern fn UnloadShader(shader: Shader) void; +pub extern fn GetScreenToWorldRay(position: Vector2, camera: Camera) Ray; +pub extern fn GetScreenToWorldRayEx(position: Vector2, camera: Camera, width: c_int, height: c_int) Ray; +pub extern fn GetWorldToScreen(position: Vector3, camera: Camera) Vector2; +pub extern fn GetWorldToScreenEx(position: Vector3, camera: Camera, width: c_int, height: c_int) Vector2; +pub extern fn GetWorldToScreen2D(position: Vector2, camera: Camera2D) Vector2; +pub extern fn GetScreenToWorld2D(position: Vector2, camera: Camera2D) Vector2; +pub extern fn GetCameraMatrix(camera: Camera) Matrix; +pub extern fn GetCameraMatrix2D(camera: Camera2D) Matrix; +pub extern fn SetTargetFPS(fps: c_int) void; +pub extern fn GetFrameTime() f32; +pub extern fn GetTime() f64; +pub extern fn GetFPS() c_int; +pub extern fn SwapScreenBuffer() void; +pub extern fn PollInputEvents() void; +pub extern fn WaitTime(seconds: f64) void; +pub extern fn SetRandomSeed(seed: c_uint) void; +pub extern fn GetRandomValue(min: c_int, max: c_int) c_int; +pub extern fn LoadRandomSequence(count: c_uint, min: c_int, max: c_int) [*c]c_int; +pub extern fn UnloadRandomSequence(sequence: [*c]c_int) void; +pub extern fn TakeScreenshot(fileName: [*c]const u8) void; +pub extern fn SetConfigFlags(flags: c_uint) void; +pub extern fn OpenURL(url: [*c]const u8) void; +pub extern fn TraceLog(logLevel: c_int, text: [*c]const u8, ...) void; +pub extern fn SetTraceLogLevel(logLevel: c_int) void; +pub extern fn MemAlloc(size: c_uint) ?*anyopaque; +pub extern fn MemRealloc(ptr: ?*anyopaque, size: c_uint) ?*anyopaque; +pub extern fn MemFree(ptr: ?*anyopaque) void; +pub extern fn SetTraceLogCallback(callback: TraceLogCallback) void; +pub extern fn SetLoadFileDataCallback(callback: LoadFileDataCallback) void; +pub extern fn SetSaveFileDataCallback(callback: SaveFileDataCallback) void; +pub extern fn SetLoadFileTextCallback(callback: LoadFileTextCallback) void; +pub extern fn SetSaveFileTextCallback(callback: SaveFileTextCallback) void; +pub extern fn LoadFileData(fileName: [*c]const u8, dataSize: [*c]c_int) [*c]u8; +pub extern fn UnloadFileData(data: [*c]u8) void; +pub extern fn SaveFileData(fileName: [*c]const u8, data: ?*anyopaque, dataSize: c_int) bool; +pub extern fn ExportDataAsCode(data: [*c]const u8, dataSize: c_int, fileName: [*c]const u8) bool; +pub extern fn LoadFileText(fileName: [*c]const u8) [*c]u8; +pub extern fn UnloadFileText(text: [*c]u8) void; +pub extern fn SaveFileText(fileName: [*c]const u8, text: [*c]u8) bool; +pub extern fn FileExists(fileName: [*c]const u8) bool; +pub extern fn DirectoryExists(dirPath: [*c]const u8) bool; +pub extern fn IsFileExtension(fileName: [*c]const u8, ext: [*c]const u8) bool; +pub extern fn GetFileLength(fileName: [*c]const u8) c_int; +pub extern fn GetFileExtension(fileName: [*c]const u8) [*c]const u8; +pub extern fn GetFileName(filePath: [*c]const u8) [*c]const u8; +pub extern fn GetFileNameWithoutExt(filePath: [*c]const u8) [*c]const u8; +pub extern fn GetDirectoryPath(filePath: [*c]const u8) [*c]const u8; +pub extern fn GetPrevDirectoryPath(dirPath: [*c]const u8) [*c]const u8; +pub extern fn GetWorkingDirectory() [*c]const u8; +pub extern fn GetApplicationDirectory() [*c]const u8; +pub extern fn ChangeDirectory(dir: [*c]const u8) bool; +pub extern fn IsPathFile(path: [*c]const u8) bool; +pub extern fn IsFileNameValid(fileName: [*c]const u8) bool; +pub extern fn LoadDirectoryFiles(dirPath: [*c]const u8) FilePathList; +pub extern fn LoadDirectoryFilesEx(basePath: [*c]const u8, filter: [*c]const u8, scanSubdirs: bool) FilePathList; +pub extern fn UnloadDirectoryFiles(files: FilePathList) void; +pub extern fn IsFileDropped() bool; +pub extern fn LoadDroppedFiles() FilePathList; +pub extern fn UnloadDroppedFiles(files: FilePathList) void; +pub extern fn GetFileModTime(fileName: [*c]const u8) c_long; +pub extern fn CompressData(data: [*c]const u8, dataSize: c_int, compDataSize: [*c]c_int) [*c]u8; +pub extern fn DecompressData(compData: [*c]const u8, compDataSize: c_int, dataSize: [*c]c_int) [*c]u8; +pub extern fn EncodeDataBase64(data: [*c]const u8, dataSize: c_int, outputSize: [*c]c_int) [*c]u8; +pub extern fn DecodeDataBase64(data: [*c]const u8, outputSize: [*c]c_int) [*c]u8; +pub extern fn LoadAutomationEventList(fileName: [*c]const u8) AutomationEventList; +pub extern fn UnloadAutomationEventList(list: AutomationEventList) void; +pub extern fn ExportAutomationEventList(list: AutomationEventList, fileName: [*c]const u8) bool; +pub extern fn SetAutomationEventList(list: [*c]AutomationEventList) void; +pub extern fn SetAutomationEventBaseFrame(frame: c_int) void; +pub extern fn StartAutomationEventRecording() void; +pub extern fn StopAutomationEventRecording() void; +pub extern fn PlayAutomationEvent(event: AutomationEvent) void; +pub extern fn IsKeyPressed(key: c_int) bool; +pub extern fn IsKeyPressedRepeat(key: c_int) bool; +pub extern fn IsKeyDown(key: c_int) bool; +pub extern fn IsKeyReleased(key: c_int) bool; +pub extern fn IsKeyUp(key: c_int) bool; +pub extern fn GetKeyPressed() c_int; +pub extern fn GetCharPressed() c_int; +pub extern fn SetExitKey(key: c_int) void; +pub extern fn IsGamepadAvailable(gamepad: c_int) bool; +pub extern fn GetGamepadName(gamepad: c_int) [*c]const u8; +pub extern fn IsGamepadButtonPressed(gamepad: c_int, button: c_int) bool; +pub extern fn IsGamepadButtonDown(gamepad: c_int, button: c_int) bool; +pub extern fn IsGamepadButtonReleased(gamepad: c_int, button: c_int) bool; +pub extern fn IsGamepadButtonUp(gamepad: c_int, button: c_int) bool; +pub extern fn GetGamepadButtonPressed() c_int; +pub extern fn GetGamepadAxisCount(gamepad: c_int) c_int; +pub extern fn GetGamepadAxisMovement(gamepad: c_int, axis: c_int) f32; +pub extern fn SetGamepadMappings(mappings: [*c]const u8) c_int; +pub extern fn SetGamepadVibration(gamepad: c_int, leftMotor: f32, rightMotor: f32) void; +pub extern fn IsMouseButtonPressed(button: c_int) bool; +pub extern fn IsMouseButtonDown(button: c_int) bool; +pub extern fn IsMouseButtonReleased(button: c_int) bool; +pub extern fn IsMouseButtonUp(button: c_int) bool; +pub extern fn GetMouseX() c_int; +pub extern fn GetMouseY() c_int; +pub extern fn GetMousePosition() Vector2; +pub extern fn GetMouseDelta() Vector2; +pub extern fn SetMousePosition(x: c_int, y: c_int) void; +pub extern fn SetMouseOffset(offsetX: c_int, offsetY: c_int) void; +pub extern fn SetMouseScale(scaleX: f32, scaleY: f32) void; +pub extern fn GetMouseWheelMove() f32; +pub extern fn GetMouseWheelMoveV() Vector2; +pub extern fn SetMouseCursor(cursor: c_int) void; +pub extern fn GetTouchX() c_int; +pub extern fn GetTouchY() c_int; +pub extern fn GetTouchPosition(index: c_int) Vector2; +pub extern fn GetTouchPointId(index: c_int) c_int; +pub extern fn GetTouchPointCount() c_int; +pub extern fn SetGesturesEnabled(flags: c_uint) void; +pub extern fn IsGestureDetected(gesture: c_uint) bool; +pub extern fn GetGestureDetected() c_int; +pub extern fn GetGestureHoldDuration() f32; +pub extern fn GetGestureDragVector() Vector2; +pub extern fn GetGestureDragAngle() f32; +pub extern fn GetGesturePinchVector() Vector2; +pub extern fn GetGesturePinchAngle() f32; +pub extern fn UpdateCamera(camera: [*c]Camera, mode: c_int) void; +pub extern fn UpdateCameraPro(camera: [*c]Camera, movement: Vector3, rotation: Vector3, zoom: f32) void; +pub extern fn SetShapesTexture(texture: Texture2D, source: Rectangle) void; +pub extern fn GetShapesTexture() Texture2D; +pub extern fn GetShapesTextureRectangle() Rectangle; +pub extern fn DrawPixel(posX: c_int, posY: c_int, color: Color) void; +pub extern fn DrawPixelV(position: Vector2, color: Color) void; +pub extern fn DrawLine(startPosX: c_int, startPosY: c_int, endPosX: c_int, endPosY: c_int, color: Color) void; +pub extern fn DrawLineV(startPos: Vector2, endPos: Vector2, color: Color) void; +pub extern fn DrawLineEx(startPos: Vector2, endPos: Vector2, thick: f32, color: Color) void; +pub extern fn DrawLineStrip(points: [*c]const Vector2, pointCount: c_int, color: Color) void; +pub extern fn DrawLineBezier(startPos: Vector2, endPos: Vector2, thick: f32, color: Color) void; +pub extern fn DrawCircle(centerX: c_int, centerY: c_int, radius: f32, color: Color) void; +pub extern fn DrawCircleSector(center: Vector2, radius: f32, startAngle: f32, endAngle: f32, segments: c_int, color: Color) void; +pub extern fn DrawCircleSectorLines(center: Vector2, radius: f32, startAngle: f32, endAngle: f32, segments: c_int, color: Color) void; +pub extern fn DrawCircleGradient(centerX: c_int, centerY: c_int, radius: f32, inner: Color, outer: Color) void; +pub extern fn DrawCircleV(center: Vector2, radius: f32, color: Color) void; +pub extern fn DrawCircleLines(centerX: c_int, centerY: c_int, radius: f32, color: Color) void; +pub extern fn DrawCircleLinesV(center: Vector2, radius: f32, color: Color) void; +pub extern fn DrawEllipse(centerX: c_int, centerY: c_int, radiusH: f32, radiusV: f32, color: Color) void; +pub extern fn DrawEllipseLines(centerX: c_int, centerY: c_int, radiusH: f32, radiusV: f32, color: Color) void; +pub extern fn DrawRing(center: Vector2, innerRadius: f32, outerRadius: f32, startAngle: f32, endAngle: f32, segments: c_int, color: Color) void; +pub extern fn DrawRingLines(center: Vector2, innerRadius: f32, outerRadius: f32, startAngle: f32, endAngle: f32, segments: c_int, color: Color) void; +pub extern fn DrawRectangle(posX: c_int, posY: c_int, width: c_int, height: c_int, color: Color) void; +pub extern fn DrawRectangleV(position: Vector2, size: Vector2, color: Color) void; +pub extern fn DrawRectangleRec(rec: Rectangle, color: Color) void; +pub extern fn DrawRectanglePro(rec: Rectangle, origin: Vector2, rotation: f32, color: Color) void; +pub extern fn DrawRectangleGradientV(posX: c_int, posY: c_int, width: c_int, height: c_int, top: Color, bottom: Color) void; +pub extern fn DrawRectangleGradientH(posX: c_int, posY: c_int, width: c_int, height: c_int, left: Color, right: Color) void; +pub extern fn DrawRectangleGradientEx(rec: Rectangle, topLeft: Color, bottomLeft: Color, topRight: Color, bottomRight: Color) void; +pub extern fn DrawRectangleLines(posX: c_int, posY: c_int, width: c_int, height: c_int, color: Color) void; +pub extern fn DrawRectangleLinesEx(rec: Rectangle, lineThick: f32, color: Color) void; +pub extern fn DrawRectangleRounded(rec: Rectangle, roundness: f32, segments: c_int, color: Color) void; +pub extern fn DrawRectangleRoundedLines(rec: Rectangle, roundness: f32, segments: c_int, color: Color) void; +pub extern fn DrawRectangleRoundedLinesEx(rec: Rectangle, roundness: f32, segments: c_int, lineThick: f32, color: Color) void; +pub extern fn DrawTriangle(v1: Vector2, v2: Vector2, v3: Vector2, color: Color) void; +pub extern fn DrawTriangleLines(v1: Vector2, v2: Vector2, v3: Vector2, color: Color) void; +pub extern fn DrawTriangleFan(points: [*c]const Vector2, pointCount: c_int, color: Color) void; +pub extern fn DrawTriangleStrip(points: [*c]const Vector2, pointCount: c_int, color: Color) void; +pub extern fn DrawPoly(center: Vector2, sides: c_int, radius: f32, rotation: f32, color: Color) void; +pub extern fn DrawPolyLines(center: Vector2, sides: c_int, radius: f32, rotation: f32, color: Color) void; +pub extern fn DrawPolyLinesEx(center: Vector2, sides: c_int, radius: f32, rotation: f32, lineThick: f32, color: Color) void; +pub extern fn DrawSplineLinear(points: [*c]const Vector2, pointCount: c_int, thick: f32, color: Color) void; +pub extern fn DrawSplineBasis(points: [*c]const Vector2, pointCount: c_int, thick: f32, color: Color) void; +pub extern fn DrawSplineCatmullRom(points: [*c]const Vector2, pointCount: c_int, thick: f32, color: Color) void; +pub extern fn DrawSplineBezierQuadratic(points: [*c]const Vector2, pointCount: c_int, thick: f32, color: Color) void; +pub extern fn DrawSplineBezierCubic(points: [*c]const Vector2, pointCount: c_int, thick: f32, color: Color) void; +pub extern fn DrawSplineSegmentLinear(p1: Vector2, p2: Vector2, thick: f32, color: Color) void; +pub extern fn DrawSplineSegmentBasis(p1: Vector2, p2: Vector2, p3: Vector2, p4: Vector2, thick: f32, color: Color) void; +pub extern fn DrawSplineSegmentCatmullRom(p1: Vector2, p2: Vector2, p3: Vector2, p4: Vector2, thick: f32, color: Color) void; +pub extern fn DrawSplineSegmentBezierQuadratic(p1: Vector2, c2: Vector2, p3: Vector2, thick: f32, color: Color) void; +pub extern fn DrawSplineSegmentBezierCubic(p1: Vector2, c2: Vector2, c3: Vector2, p4: Vector2, thick: f32, color: Color) void; +pub extern fn GetSplinePointLinear(startPos: Vector2, endPos: Vector2, t: f32) Vector2; +pub extern fn GetSplinePointBasis(p1: Vector2, p2: Vector2, p3: Vector2, p4: Vector2, t: f32) Vector2; +pub extern fn GetSplinePointCatmullRom(p1: Vector2, p2: Vector2, p3: Vector2, p4: Vector2, t: f32) Vector2; +pub extern fn GetSplinePointBezierQuad(p1: Vector2, c2: Vector2, p3: Vector2, t: f32) Vector2; +pub extern fn GetSplinePointBezierCubic(p1: Vector2, c2: Vector2, c3: Vector2, p4: Vector2, t: f32) Vector2; +pub extern fn CheckCollisionRecs(rec1: Rectangle, rec2: Rectangle) bool; +pub extern fn CheckCollisionCircles(center1: Vector2, radius1: f32, center2: Vector2, radius2: f32) bool; +pub extern fn CheckCollisionCircleRec(center: Vector2, radius: f32, rec: Rectangle) bool; +pub extern fn CheckCollisionPointRec(point: Vector2, rec: Rectangle) bool; +pub extern fn CheckCollisionPointCircle(point: Vector2, center: Vector2, radius: f32) bool; +pub extern fn CheckCollisionPointTriangle(point: Vector2, p1: Vector2, p2: Vector2, p3: Vector2) bool; +pub extern fn CheckCollisionPointPoly(point: Vector2, points: [*c]const Vector2, pointCount: c_int) bool; +pub extern fn CheckCollisionLines(startPos1: Vector2, endPos1: Vector2, startPos2: Vector2, endPos2: Vector2, collisionPoint: [*c]Vector2) bool; +pub extern fn CheckCollisionPointLine(point: Vector2, p1: Vector2, p2: Vector2, threshold: c_int) bool; +pub extern fn CheckCollisionCircleLine(center: Vector2, radius: f32, p1: Vector2, p2: Vector2) bool; +pub extern fn GetCollisionRec(rec1: Rectangle, rec2: Rectangle) Rectangle; +pub extern fn LoadImage(fileName: [*c]const u8) Image; +pub extern fn LoadImageRaw(fileName: [*c]const u8, width: c_int, height: c_int, format: c_int, headerSize: c_int) Image; +pub extern fn LoadImageSvg(fileNameOrString: [*c]const u8, width: c_int, height: c_int) Image; +pub extern fn LoadImageAnim(fileName: [*c]const u8, frames: [*c]c_int) Image; +pub extern fn LoadImageAnimFromMemory(fileType: [*c]const u8, fileData: [*c]const u8, dataSize: c_int, frames: [*c]c_int) Image; +pub extern fn LoadImageFromMemory(fileType: [*c]const u8, fileData: [*c]const u8, dataSize: c_int) Image; +pub extern fn LoadImageFromTexture(texture: Texture2D) Image; +pub extern fn LoadImageFromScreen() Image; +pub extern fn IsImageReady(image: Image) bool; +pub extern fn UnloadImage(image: Image) void; +pub extern fn ExportImage(image: Image, fileName: [*c]const u8) bool; +pub extern fn ExportImageToMemory(image: Image, fileType: [*c]const u8, fileSize: [*c]c_int) [*c]u8; +pub extern fn ExportImageAsCode(image: Image, fileName: [*c]const u8) bool; +pub extern fn GenImageColor(width: c_int, height: c_int, color: Color) Image; +pub extern fn GenImageGradientLinear(width: c_int, height: c_int, direction: c_int, start: Color, end: Color) Image; +pub extern fn GenImageGradientRadial(width: c_int, height: c_int, density: f32, inner: Color, outer: Color) Image; +pub extern fn GenImageGradientSquare(width: c_int, height: c_int, density: f32, inner: Color, outer: Color) Image; +pub extern fn GenImageChecked(width: c_int, height: c_int, checksX: c_int, checksY: c_int, col1: Color, col2: Color) Image; +pub extern fn GenImageWhiteNoise(width: c_int, height: c_int, factor: f32) Image; +pub extern fn GenImagePerlinNoise(width: c_int, height: c_int, offsetX: c_int, offsetY: c_int, scale: f32) Image; +pub extern fn GenImageCellular(width: c_int, height: c_int, tileSize: c_int) Image; +pub extern fn GenImageText(width: c_int, height: c_int, text: [*c]const u8) Image; +pub extern fn ImageCopy(image: Image) Image; +pub extern fn ImageFromImage(image: Image, rec: Rectangle) Image; +pub extern fn ImageFromChannel(image: Image, selectedChannel: c_int) Image; +pub extern fn ImageText(text: [*c]const u8, fontSize: c_int, color: Color) Image; +pub extern fn ImageTextEx(font: Font, text: [*c]const u8, fontSize: f32, spacing: f32, tint: Color) Image; +pub extern fn ImageFormat(image: [*c]Image, newFormat: c_int) void; +pub extern fn ImageToPOT(image: [*c]Image, fill: Color) void; +pub extern fn ImageCrop(image: [*c]Image, crop: Rectangle) void; +pub extern fn ImageAlphaCrop(image: [*c]Image, threshold: f32) void; +pub extern fn ImageAlphaClear(image: [*c]Image, color: Color, threshold: f32) void; +pub extern fn ImageAlphaMask(image: [*c]Image, alphaMask: Image) void; +pub extern fn ImageAlphaPremultiply(image: [*c]Image) void; +pub extern fn ImageBlurGaussian(image: [*c]Image, blurSize: c_int) void; +pub extern fn ImageKernelConvolution(image: [*c]Image, kernel: [*c]const f32, kernelSize: c_int) void; +pub extern fn ImageResize(image: [*c]Image, newWidth: c_int, newHeight: c_int) void; +pub extern fn ImageResizeNN(image: [*c]Image, newWidth: c_int, newHeight: c_int) void; +pub extern fn ImageResizeCanvas(image: [*c]Image, newWidth: c_int, newHeight: c_int, offsetX: c_int, offsetY: c_int, fill: Color) void; +pub extern fn ImageMipmaps(image: [*c]Image) void; +pub extern fn ImageDither(image: [*c]Image, rBpp: c_int, gBpp: c_int, bBpp: c_int, aBpp: c_int) void; +pub extern fn ImageFlipVertical(image: [*c]Image) void; +pub extern fn ImageFlipHorizontal(image: [*c]Image) void; +pub extern fn ImageRotate(image: [*c]Image, degrees: c_int) void; +pub extern fn ImageRotateCW(image: [*c]Image) void; +pub extern fn ImageRotateCCW(image: [*c]Image) void; +pub extern fn ImageColorTint(image: [*c]Image, color: Color) void; +pub extern fn ImageColorInvert(image: [*c]Image) void; +pub extern fn ImageColorGrayscale(image: [*c]Image) void; +pub extern fn ImageColorContrast(image: [*c]Image, contrast: f32) void; +pub extern fn ImageColorBrightness(image: [*c]Image, brightness: c_int) void; +pub extern fn ImageColorReplace(image: [*c]Image, color: Color, replace: Color) void; +pub extern fn LoadImageColors(image: Image) [*c]Color; +pub extern fn LoadImagePalette(image: Image, maxPaletteSize: c_int, colorCount: [*c]c_int) [*c]Color; +pub extern fn UnloadImageColors(colors: [*c]Color) void; +pub extern fn UnloadImagePalette(colors: [*c]Color) void; +pub extern fn GetImageAlphaBorder(image: Image, threshold: f32) Rectangle; +pub extern fn GetImageColor(image: Image, x: c_int, y: c_int) Color; +pub extern fn ImageClearBackground(dst: [*c]Image, color: Color) void; +pub extern fn ImageDrawPixel(dst: [*c]Image, posX: c_int, posY: c_int, color: Color) void; +pub extern fn ImageDrawPixelV(dst: [*c]Image, position: Vector2, color: Color) void; +pub extern fn ImageDrawLine(dst: [*c]Image, startPosX: c_int, startPosY: c_int, endPosX: c_int, endPosY: c_int, color: Color) void; +pub extern fn ImageDrawLineV(dst: [*c]Image, start: Vector2, end: Vector2, color: Color) void; +pub extern fn ImageDrawLineEx(dst: [*c]Image, start: Vector2, end: Vector2, thick: c_int, color: Color) void; +pub extern fn ImageDrawCircle(dst: [*c]Image, centerX: c_int, centerY: c_int, radius: c_int, color: Color) void; +pub extern fn ImageDrawCircleV(dst: [*c]Image, center: Vector2, radius: c_int, color: Color) void; +pub extern fn ImageDrawCircleLines(dst: [*c]Image, centerX: c_int, centerY: c_int, radius: c_int, color: Color) void; +pub extern fn ImageDrawCircleLinesV(dst: [*c]Image, center: Vector2, radius: c_int, color: Color) void; +pub extern fn ImageDrawRectangle(dst: [*c]Image, posX: c_int, posY: c_int, width: c_int, height: c_int, color: Color) void; +pub extern fn ImageDrawRectangleV(dst: [*c]Image, position: Vector2, size: Vector2, color: Color) void; +pub extern fn ImageDrawRectangleRec(dst: [*c]Image, rec: Rectangle, color: Color) void; +pub extern fn ImageDrawRectangleLines(dst: [*c]Image, rec: Rectangle, thick: c_int, color: Color) void; +pub extern fn ImageDrawTriangle(dst: [*c]Image, v1: Vector2, v2: Vector2, v3: Vector2, color: Color) void; +pub extern fn ImageDrawTriangleEx(dst: [*c]Image, v1: Vector2, v2: Vector2, v3: Vector2, c1: Color, c2: Color, c3: Color) void; +pub extern fn ImageDrawTriangleLines(dst: [*c]Image, v1: Vector2, v2: Vector2, v3: Vector2, color: Color) void; +pub extern fn ImageDrawTriangleFan(dst: [*c]Image, points: [*c]Vector2, pointCount: c_int, color: Color) void; +pub extern fn ImageDrawTriangleStrip(dst: [*c]Image, points: [*c]Vector2, pointCount: c_int, color: Color) void; +pub extern fn ImageDraw(dst: [*c]Image, src: Image, srcRec: Rectangle, dstRec: Rectangle, tint: Color) void; +pub extern fn ImageDrawText(dst: [*c]Image, text: [*c]const u8, posX: c_int, posY: c_int, fontSize: c_int, color: Color) void; +pub extern fn ImageDrawTextEx(dst: [*c]Image, font: Font, text: [*c]const u8, position: Vector2, fontSize: f32, spacing: f32, tint: Color) void; +pub extern fn LoadTexture(fileName: [*c]const u8) Texture2D; +pub extern fn LoadTextureFromImage(image: Image) Texture2D; +pub extern fn LoadTextureCubemap(image: Image, layout: c_int) TextureCubemap; +pub extern fn LoadRenderTexture(width: c_int, height: c_int) RenderTexture2D; +pub extern fn IsTextureReady(texture: Texture2D) bool; +pub extern fn UnloadTexture(texture: Texture2D) void; +pub extern fn IsRenderTextureReady(target: RenderTexture2D) bool; +pub extern fn UnloadRenderTexture(target: RenderTexture2D) void; +pub extern fn UpdateTexture(texture: Texture2D, pixels: ?*const anyopaque) void; +pub extern fn UpdateTextureRec(texture: Texture2D, rec: Rectangle, pixels: ?*const anyopaque) void; +pub extern fn GenTextureMipmaps(texture: [*c]Texture2D) void; +pub extern fn SetTextureFilter(texture: Texture2D, filter: c_int) void; +pub extern fn SetTextureWrap(texture: Texture2D, wrap: c_int) void; +pub extern fn DrawTexture(texture: Texture2D, posX: c_int, posY: c_int, tint: Color) void; +pub extern fn DrawTextureV(texture: Texture2D, position: Vector2, tint: Color) void; +pub extern fn DrawTextureEx(texture: Texture2D, position: Vector2, rotation: f32, scale: f32, tint: Color) void; +pub extern fn DrawTextureRec(texture: Texture2D, source: Rectangle, position: Vector2, tint: Color) void; +pub extern fn DrawTexturePro(texture: Texture2D, source: Rectangle, dest: Rectangle, origin: Vector2, rotation: f32, tint: Color) void; +pub extern fn DrawTextureNPatch(texture: Texture2D, nPatchInfo: NPatchInfo, dest: Rectangle, origin: Vector2, rotation: f32, tint: Color) void; +pub extern fn ColorIsEqual(col1: Color, col2: Color) bool; +pub extern fn Fade(color: Color, alpha: f32) Color; +pub extern fn ColorToInt(color: Color) c_int; +pub extern fn ColorNormalize(color: Color) Vector4; +pub extern fn ColorFromNormalized(normalized: Vector4) Color; +pub extern fn ColorToHSV(color: Color) Vector3; +pub extern fn ColorFromHSV(hue: f32, saturation: f32, value: f32) Color; +pub extern fn ColorTint(color: Color, tint: Color) Color; +pub extern fn ColorBrightness(color: Color, factor: f32) Color; +pub extern fn ColorContrast(color: Color, contrast: f32) Color; +pub extern fn ColorAlpha(color: Color, alpha: f32) Color; +pub extern fn ColorAlphaBlend(dst: Color, src: Color, tint: Color) Color; +pub extern fn GetColor(hexValue: c_uint) Color; +pub extern fn GetPixelColor(srcPtr: ?*anyopaque, format: c_int) Color; +pub extern fn SetPixelColor(dstPtr: ?*anyopaque, color: Color, format: c_int) void; +pub extern fn GetPixelDataSize(width: c_int, height: c_int, format: c_int) c_int; +pub extern fn GetFontDefault() Font; +pub extern fn LoadFont(fileName: [*c]const u8) Font; +pub extern fn LoadFontEx(fileName: [*c]const u8, fontSize: c_int, codepoints: [*c]c_int, codepointCount: c_int) Font; +pub extern fn LoadFontFromImage(image: Image, key: Color, firstChar: c_int) Font; +pub extern fn LoadFontFromMemory(fileType: [*c]const u8, fileData: [*c]const u8, dataSize: c_int, fontSize: c_int, codepoints: [*c]c_int, codepointCount: c_int) Font; +pub extern fn IsFontReady(font: Font) bool; +pub extern fn LoadFontData(fileData: [*c]const u8, dataSize: c_int, fontSize: c_int, codepoints: [*c]c_int, codepointCount: c_int, @"type": c_int) [*c]GlyphInfo; +pub extern fn GenImageFontAtlas(glyphs: [*c]const GlyphInfo, glyphRecs: [*c][*c]Rectangle, glyphCount: c_int, fontSize: c_int, padding: c_int, packMethod: c_int) Image; +pub extern fn UnloadFontData(glyphs: [*c]GlyphInfo, glyphCount: c_int) void; +pub extern fn UnloadFont(font: Font) void; +pub extern fn ExportFontAsCode(font: Font, fileName: [*c]const u8) bool; +pub extern fn DrawFPS(posX: c_int, posY: c_int) void; +pub extern fn DrawText(text: [*c]const u8, posX: c_int, posY: c_int, fontSize: c_int, color: Color) void; +pub extern fn DrawTextEx(font: Font, text: [*c]const u8, position: Vector2, fontSize: f32, spacing: f32, tint: Color) void; +pub extern fn DrawTextPro(font: Font, text: [*c]const u8, position: Vector2, origin: Vector2, rotation: f32, fontSize: f32, spacing: f32, tint: Color) void; +pub extern fn DrawTextCodepoint(font: Font, codepoint: c_int, position: Vector2, fontSize: f32, tint: Color) void; +pub extern fn DrawTextCodepoints(font: Font, codepoints: [*c]const c_int, codepointCount: c_int, position: Vector2, fontSize: f32, spacing: f32, tint: Color) void; +pub extern fn SetTextLineSpacing(spacing: c_int) void; +pub extern fn MeasureText(text: [*c]const u8, fontSize: c_int) c_int; +pub extern fn MeasureTextEx(font: Font, text: [*c]const u8, fontSize: f32, spacing: f32) Vector2; +pub extern fn GetGlyphIndex(font: Font, codepoint: c_int) c_int; +pub extern fn GetGlyphInfo(font: Font, codepoint: c_int) GlyphInfo; +pub extern fn GetGlyphAtlasRec(font: Font, codepoint: c_int) Rectangle; +pub extern fn LoadUTF8(codepoints: [*c]const c_int, length: c_int) [*c]u8; +pub extern fn UnloadUTF8(text: [*c]u8) void; +pub extern fn LoadCodepoints(text: [*c]const u8, count: [*c]c_int) [*c]c_int; +pub extern fn UnloadCodepoints(codepoints: [*c]c_int) void; +pub extern fn GetCodepointCount(text: [*c]const u8) c_int; +pub extern fn GetCodepoint(text: [*c]const u8, codepointSize: [*c]c_int) c_int; +pub extern fn GetCodepointNext(text: [*c]const u8, codepointSize: [*c]c_int) c_int; +pub extern fn GetCodepointPrevious(text: [*c]const u8, codepointSize: [*c]c_int) c_int; +pub extern fn CodepointToUTF8(codepoint: c_int, utf8Size: [*c]c_int) [*c]const u8; +pub extern fn TextCopy(dst: [*c]u8, src: [*c]const u8) c_int; +pub extern fn TextIsEqual(text1: [*c]const u8, text2: [*c]const u8) bool; +pub extern fn TextLength(text: [*c]const u8) c_uint; +pub extern fn TextFormat(text: [*c]const u8, ...) [*c]const u8; +pub extern fn TextSubtext(text: [*c]const u8, position: c_int, length: c_int) [*c]const u8; +pub extern fn TextReplace(text: [*c]const u8, replace: [*c]const u8, by: [*c]const u8) [*c]u8; +pub extern fn TextInsert(text: [*c]const u8, insert: [*c]const u8, position: c_int) [*c]u8; +pub extern fn TextJoin(textList: [*c][*c]const u8, count: c_int, delimiter: [*c]const u8) [*c]const u8; +pub extern fn TextSplit(text: [*c]const u8, delimiter: u8, count: [*c]c_int) [*c][*c]const u8; +pub extern fn TextAppend(text: [*c]u8, append: [*c]const u8, position: [*c]c_int) void; +pub extern fn TextFindIndex(text: [*c]const u8, find: [*c]const u8) c_int; +pub extern fn TextToUpper(text: [*c]const u8) [*c]const u8; +pub extern fn TextToLower(text: [*c]const u8) [*c]const u8; +pub extern fn TextToPascal(text: [*c]const u8) [*c]const u8; +pub extern fn TextToSnake(text: [*c]const u8) [*c]const u8; +pub extern fn TextToCamel(text: [*c]const u8) [*c]const u8; +pub extern fn TextToInteger(text: [*c]const u8) c_int; +pub extern fn TextToFloat(text: [*c]const u8) f32; +pub export fn DrawLine3D(arg_startPos: Vector3, arg_endPos: Vector3, arg_color: Color) void { + var startPos = arg_startPos; + _ = &startPos; + var endPos = arg_endPos; + _ = &endPos; + var color = arg_color; + _ = &color; + rlBegin(@as(c_int, 1)); + rlColor4ub(color.r, color.g, color.b, color.a); + rlVertex3f(startPos.x, startPos.y, startPos.z); + rlVertex3f(endPos.x, endPos.y, endPos.z); + rlEnd(); +} +pub export fn DrawPoint3D(arg_position: Vector3, arg_color: Color) void { + var position = arg_position; + _ = &position; + var color = arg_color; + _ = &color; + rlPushMatrix(); + rlTranslatef(position.x, position.y, position.z); + rlBegin(@as(c_int, 1)); + rlColor4ub(color.r, color.g, color.b, color.a); + rlVertex3f(0.0, 0.0, 0.0); + rlVertex3f(0.0, 0.0, 0.10000000149011612); + rlEnd(); + rlPopMatrix(); +} +pub export fn DrawCircle3D(arg_center: Vector3, arg_radius: f32, arg_rotationAxis: Vector3, arg_rotationAngle: f32, arg_color: Color) void { + var center = arg_center; + _ = ¢er; + var radius = arg_radius; + _ = &radius; + var rotationAxis = arg_rotationAxis; + _ = &rotationAxis; + var rotationAngle = arg_rotationAngle; + _ = &rotationAngle; + var color = arg_color; + _ = &color; + rlPushMatrix(); + rlTranslatef(center.x, center.y, center.z); + rlRotatef(rotationAngle, rotationAxis.x, rotationAxis.y, rotationAxis.z); + rlBegin(@as(c_int, 1)); + { + var i: c_int = 0; + _ = &i; + while (i < @as(c_int, 360)) : (i += @as(c_int, 10)) { + rlColor4ub(color.r, color.g, color.b, color.a); + rlVertex3f(sinf((3.1415927410125732 / 180.0) * @as(f32, @floatFromInt(i))) * radius, cosf((3.1415927410125732 / 180.0) * @as(f32, @floatFromInt(i))) * radius, 0.0); + rlVertex3f(sinf((3.1415927410125732 / 180.0) * @as(f32, @floatFromInt(i + @as(c_int, 10)))) * radius, cosf((3.1415927410125732 / 180.0) * @as(f32, @floatFromInt(i + @as(c_int, 10)))) * radius, 0.0); + } + } + rlEnd(); + rlPopMatrix(); +} +pub export fn DrawTriangle3D(arg_v1: Vector3, arg_v2: Vector3, arg_v3: Vector3, arg_color: Color) void { + var v1 = arg_v1; + _ = &v1; + var v2 = arg_v2; + _ = &v2; + var v3 = arg_v3; + _ = &v3; + var color = arg_color; + _ = &color; + rlBegin(@as(c_int, 4)); + rlColor4ub(color.r, color.g, color.b, color.a); + rlVertex3f(v1.x, v1.y, v1.z); + rlVertex3f(v2.x, v2.y, v2.z); + rlVertex3f(v3.x, v3.y, v3.z); + rlEnd(); +} +pub export fn DrawTriangleStrip3D(arg_points: [*c]const Vector3, arg_pointCount: c_int, arg_color: Color) void { + var points = arg_points; + _ = &points; + var pointCount = arg_pointCount; + _ = &pointCount; + var color = arg_color; + _ = &color; + if (pointCount < @as(c_int, 3)) return; + rlBegin(@as(c_int, 4)); + rlColor4ub(color.r, color.g, color.b, color.a); + { + var i: c_int = 2; + _ = &i; + while (i < pointCount) : (i += 1) { + if (@import("std").zig.c_translation.signedRemainder(i, @as(c_int, 2)) == @as(c_int, 0)) { + rlVertex3f((blk: { + const tmp = i; + if (tmp >= 0) break :blk points + @as(usize, @intCast(tmp)) else break :blk points - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.x, (blk: { + const tmp = i; + if (tmp >= 0) break :blk points + @as(usize, @intCast(tmp)) else break :blk points - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.y, (blk: { + const tmp = i; + if (tmp >= 0) break :blk points + @as(usize, @intCast(tmp)) else break :blk points - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.z); + rlVertex3f((blk: { + const tmp = i - @as(c_int, 2); + if (tmp >= 0) break :blk points + @as(usize, @intCast(tmp)) else break :blk points - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.x, (blk: { + const tmp = i - @as(c_int, 2); + if (tmp >= 0) break :blk points + @as(usize, @intCast(tmp)) else break :blk points - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.y, (blk: { + const tmp = i - @as(c_int, 2); + if (tmp >= 0) break :blk points + @as(usize, @intCast(tmp)) else break :blk points - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.z); + rlVertex3f((blk: { + const tmp = i - @as(c_int, 1); + if (tmp >= 0) break :blk points + @as(usize, @intCast(tmp)) else break :blk points - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.x, (blk: { + const tmp = i - @as(c_int, 1); + if (tmp >= 0) break :blk points + @as(usize, @intCast(tmp)) else break :blk points - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.y, (blk: { + const tmp = i - @as(c_int, 1); + if (tmp >= 0) break :blk points + @as(usize, @intCast(tmp)) else break :blk points - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.z); + } else { + rlVertex3f((blk: { + const tmp = i; + if (tmp >= 0) break :blk points + @as(usize, @intCast(tmp)) else break :blk points - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.x, (blk: { + const tmp = i; + if (tmp >= 0) break :blk points + @as(usize, @intCast(tmp)) else break :blk points - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.y, (blk: { + const tmp = i; + if (tmp >= 0) break :blk points + @as(usize, @intCast(tmp)) else break :blk points - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.z); + rlVertex3f((blk: { + const tmp = i - @as(c_int, 1); + if (tmp >= 0) break :blk points + @as(usize, @intCast(tmp)) else break :blk points - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.x, (blk: { + const tmp = i - @as(c_int, 1); + if (tmp >= 0) break :blk points + @as(usize, @intCast(tmp)) else break :blk points - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.y, (blk: { + const tmp = i - @as(c_int, 1); + if (tmp >= 0) break :blk points + @as(usize, @intCast(tmp)) else break :blk points - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.z); + rlVertex3f((blk: { + const tmp = i - @as(c_int, 2); + if (tmp >= 0) break :blk points + @as(usize, @intCast(tmp)) else break :blk points - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.x, (blk: { + const tmp = i - @as(c_int, 2); + if (tmp >= 0) break :blk points + @as(usize, @intCast(tmp)) else break :blk points - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.y, (blk: { + const tmp = i - @as(c_int, 2); + if (tmp >= 0) break :blk points + @as(usize, @intCast(tmp)) else break :blk points - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.z); + } + } + } + rlEnd(); +} +pub export fn DrawCube(arg_position: Vector3, arg_width: f32, arg_height: f32, arg_length: f32, arg_color: Color) void { + var position = arg_position; + _ = &position; + var width = arg_width; + _ = &width; + var height = arg_height; + _ = &height; + var length = arg_length; + _ = &length; + var color = arg_color; + _ = &color; + var x: f32 = 0.0; + _ = &x; + var y: f32 = 0.0; + _ = &y; + var z: f32 = 0.0; + _ = &z; + rlPushMatrix(); + rlTranslatef(position.x, position.y, position.z); + rlBegin(@as(c_int, 4)); + rlColor4ub(color.r, color.g, color.b, color.a); + rlNormal3f(0.0, 0.0, 1.0); + rlVertex3f(x - (width / @as(f32, @floatFromInt(@as(c_int, 2)))), y - (height / @as(f32, @floatFromInt(@as(c_int, 2)))), z + (length / @as(f32, @floatFromInt(@as(c_int, 2))))); + rlVertex3f(x + (width / @as(f32, @floatFromInt(@as(c_int, 2)))), y - (height / @as(f32, @floatFromInt(@as(c_int, 2)))), z + (length / @as(f32, @floatFromInt(@as(c_int, 2))))); + rlVertex3f(x - (width / @as(f32, @floatFromInt(@as(c_int, 2)))), y + (height / @as(f32, @floatFromInt(@as(c_int, 2)))), z + (length / @as(f32, @floatFromInt(@as(c_int, 2))))); + rlVertex3f(x + (width / @as(f32, @floatFromInt(@as(c_int, 2)))), y + (height / @as(f32, @floatFromInt(@as(c_int, 2)))), z + (length / @as(f32, @floatFromInt(@as(c_int, 2))))); + rlVertex3f(x - (width / @as(f32, @floatFromInt(@as(c_int, 2)))), y + (height / @as(f32, @floatFromInt(@as(c_int, 2)))), z + (length / @as(f32, @floatFromInt(@as(c_int, 2))))); + rlVertex3f(x + (width / @as(f32, @floatFromInt(@as(c_int, 2)))), y - (height / @as(f32, @floatFromInt(@as(c_int, 2)))), z + (length / @as(f32, @floatFromInt(@as(c_int, 2))))); + rlNormal3f(0.0, 0.0, -1.0); + rlVertex3f(x - (width / @as(f32, @floatFromInt(@as(c_int, 2)))), y - (height / @as(f32, @floatFromInt(@as(c_int, 2)))), z - (length / @as(f32, @floatFromInt(@as(c_int, 2))))); + rlVertex3f(x - (width / @as(f32, @floatFromInt(@as(c_int, 2)))), y + (height / @as(f32, @floatFromInt(@as(c_int, 2)))), z - (length / @as(f32, @floatFromInt(@as(c_int, 2))))); + rlVertex3f(x + (width / @as(f32, @floatFromInt(@as(c_int, 2)))), y - (height / @as(f32, @floatFromInt(@as(c_int, 2)))), z - (length / @as(f32, @floatFromInt(@as(c_int, 2))))); + rlVertex3f(x + (width / @as(f32, @floatFromInt(@as(c_int, 2)))), y + (height / @as(f32, @floatFromInt(@as(c_int, 2)))), z - (length / @as(f32, @floatFromInt(@as(c_int, 2))))); + rlVertex3f(x + (width / @as(f32, @floatFromInt(@as(c_int, 2)))), y - (height / @as(f32, @floatFromInt(@as(c_int, 2)))), z - (length / @as(f32, @floatFromInt(@as(c_int, 2))))); + rlVertex3f(x - (width / @as(f32, @floatFromInt(@as(c_int, 2)))), y + (height / @as(f32, @floatFromInt(@as(c_int, 2)))), z - (length / @as(f32, @floatFromInt(@as(c_int, 2))))); + rlNormal3f(0.0, 1.0, 0.0); + rlVertex3f(x - (width / @as(f32, @floatFromInt(@as(c_int, 2)))), y + (height / @as(f32, @floatFromInt(@as(c_int, 2)))), z - (length / @as(f32, @floatFromInt(@as(c_int, 2))))); + rlVertex3f(x - (width / @as(f32, @floatFromInt(@as(c_int, 2)))), y + (height / @as(f32, @floatFromInt(@as(c_int, 2)))), z + (length / @as(f32, @floatFromInt(@as(c_int, 2))))); + rlVertex3f(x + (width / @as(f32, @floatFromInt(@as(c_int, 2)))), y + (height / @as(f32, @floatFromInt(@as(c_int, 2)))), z + (length / @as(f32, @floatFromInt(@as(c_int, 2))))); + rlVertex3f(x + (width / @as(f32, @floatFromInt(@as(c_int, 2)))), y + (height / @as(f32, @floatFromInt(@as(c_int, 2)))), z - (length / @as(f32, @floatFromInt(@as(c_int, 2))))); + rlVertex3f(x - (width / @as(f32, @floatFromInt(@as(c_int, 2)))), y + (height / @as(f32, @floatFromInt(@as(c_int, 2)))), z - (length / @as(f32, @floatFromInt(@as(c_int, 2))))); + rlVertex3f(x + (width / @as(f32, @floatFromInt(@as(c_int, 2)))), y + (height / @as(f32, @floatFromInt(@as(c_int, 2)))), z + (length / @as(f32, @floatFromInt(@as(c_int, 2))))); + rlNormal3f(0.0, -1.0, 0.0); + rlVertex3f(x - (width / @as(f32, @floatFromInt(@as(c_int, 2)))), y - (height / @as(f32, @floatFromInt(@as(c_int, 2)))), z - (length / @as(f32, @floatFromInt(@as(c_int, 2))))); + rlVertex3f(x + (width / @as(f32, @floatFromInt(@as(c_int, 2)))), y - (height / @as(f32, @floatFromInt(@as(c_int, 2)))), z + (length / @as(f32, @floatFromInt(@as(c_int, 2))))); + rlVertex3f(x - (width / @as(f32, @floatFromInt(@as(c_int, 2)))), y - (height / @as(f32, @floatFromInt(@as(c_int, 2)))), z + (length / @as(f32, @floatFromInt(@as(c_int, 2))))); + rlVertex3f(x + (width / @as(f32, @floatFromInt(@as(c_int, 2)))), y - (height / @as(f32, @floatFromInt(@as(c_int, 2)))), z - (length / @as(f32, @floatFromInt(@as(c_int, 2))))); + rlVertex3f(x + (width / @as(f32, @floatFromInt(@as(c_int, 2)))), y - (height / @as(f32, @floatFromInt(@as(c_int, 2)))), z + (length / @as(f32, @floatFromInt(@as(c_int, 2))))); + rlVertex3f(x - (width / @as(f32, @floatFromInt(@as(c_int, 2)))), y - (height / @as(f32, @floatFromInt(@as(c_int, 2)))), z - (length / @as(f32, @floatFromInt(@as(c_int, 2))))); + rlNormal3f(1.0, 0.0, 0.0); + rlVertex3f(x + (width / @as(f32, @floatFromInt(@as(c_int, 2)))), y - (height / @as(f32, @floatFromInt(@as(c_int, 2)))), z - (length / @as(f32, @floatFromInt(@as(c_int, 2))))); + rlVertex3f(x + (width / @as(f32, @floatFromInt(@as(c_int, 2)))), y + (height / @as(f32, @floatFromInt(@as(c_int, 2)))), z - (length / @as(f32, @floatFromInt(@as(c_int, 2))))); + rlVertex3f(x + (width / @as(f32, @floatFromInt(@as(c_int, 2)))), y + (height / @as(f32, @floatFromInt(@as(c_int, 2)))), z + (length / @as(f32, @floatFromInt(@as(c_int, 2))))); + rlVertex3f(x + (width / @as(f32, @floatFromInt(@as(c_int, 2)))), y - (height / @as(f32, @floatFromInt(@as(c_int, 2)))), z + (length / @as(f32, @floatFromInt(@as(c_int, 2))))); + rlVertex3f(x + (width / @as(f32, @floatFromInt(@as(c_int, 2)))), y - (height / @as(f32, @floatFromInt(@as(c_int, 2)))), z - (length / @as(f32, @floatFromInt(@as(c_int, 2))))); + rlVertex3f(x + (width / @as(f32, @floatFromInt(@as(c_int, 2)))), y + (height / @as(f32, @floatFromInt(@as(c_int, 2)))), z + (length / @as(f32, @floatFromInt(@as(c_int, 2))))); + rlNormal3f(-1.0, 0.0, 0.0); + rlVertex3f(x - (width / @as(f32, @floatFromInt(@as(c_int, 2)))), y - (height / @as(f32, @floatFromInt(@as(c_int, 2)))), z - (length / @as(f32, @floatFromInt(@as(c_int, 2))))); + rlVertex3f(x - (width / @as(f32, @floatFromInt(@as(c_int, 2)))), y + (height / @as(f32, @floatFromInt(@as(c_int, 2)))), z + (length / @as(f32, @floatFromInt(@as(c_int, 2))))); + rlVertex3f(x - (width / @as(f32, @floatFromInt(@as(c_int, 2)))), y + (height / @as(f32, @floatFromInt(@as(c_int, 2)))), z - (length / @as(f32, @floatFromInt(@as(c_int, 2))))); + rlVertex3f(x - (width / @as(f32, @floatFromInt(@as(c_int, 2)))), y - (height / @as(f32, @floatFromInt(@as(c_int, 2)))), z + (length / @as(f32, @floatFromInt(@as(c_int, 2))))); + rlVertex3f(x - (width / @as(f32, @floatFromInt(@as(c_int, 2)))), y + (height / @as(f32, @floatFromInt(@as(c_int, 2)))), z + (length / @as(f32, @floatFromInt(@as(c_int, 2))))); + rlVertex3f(x - (width / @as(f32, @floatFromInt(@as(c_int, 2)))), y - (height / @as(f32, @floatFromInt(@as(c_int, 2)))), z - (length / @as(f32, @floatFromInt(@as(c_int, 2))))); + rlEnd(); + rlPopMatrix(); +} +pub export fn DrawCubeV(arg_position: Vector3, arg_size: Vector3, arg_color: Color) void { + var position = arg_position; + _ = &position; + var size = arg_size; + _ = &size; + var color = arg_color; + _ = &color; + DrawCube(position, size.x, size.y, size.z, color); +} +pub export fn DrawCubeWires(arg_position: Vector3, arg_width: f32, arg_height: f32, arg_length: f32, arg_color: Color) void { + var position = arg_position; + _ = &position; + var width = arg_width; + _ = &width; + var height = arg_height; + _ = &height; + var length = arg_length; + _ = &length; + var color = arg_color; + _ = &color; + var x: f32 = 0.0; + _ = &x; + var y: f32 = 0.0; + _ = &y; + var z: f32 = 0.0; + _ = &z; + rlPushMatrix(); + rlTranslatef(position.x, position.y, position.z); + rlBegin(@as(c_int, 1)); + rlColor4ub(color.r, color.g, color.b, color.a); + rlVertex3f(x - (width / @as(f32, @floatFromInt(@as(c_int, 2)))), y - (height / @as(f32, @floatFromInt(@as(c_int, 2)))), z + (length / @as(f32, @floatFromInt(@as(c_int, 2))))); + rlVertex3f(x + (width / @as(f32, @floatFromInt(@as(c_int, 2)))), y - (height / @as(f32, @floatFromInt(@as(c_int, 2)))), z + (length / @as(f32, @floatFromInt(@as(c_int, 2))))); + rlVertex3f(x + (width / @as(f32, @floatFromInt(@as(c_int, 2)))), y - (height / @as(f32, @floatFromInt(@as(c_int, 2)))), z + (length / @as(f32, @floatFromInt(@as(c_int, 2))))); + rlVertex3f(x + (width / @as(f32, @floatFromInt(@as(c_int, 2)))), y + (height / @as(f32, @floatFromInt(@as(c_int, 2)))), z + (length / @as(f32, @floatFromInt(@as(c_int, 2))))); + rlVertex3f(x + (width / @as(f32, @floatFromInt(@as(c_int, 2)))), y + (height / @as(f32, @floatFromInt(@as(c_int, 2)))), z + (length / @as(f32, @floatFromInt(@as(c_int, 2))))); + rlVertex3f(x - (width / @as(f32, @floatFromInt(@as(c_int, 2)))), y + (height / @as(f32, @floatFromInt(@as(c_int, 2)))), z + (length / @as(f32, @floatFromInt(@as(c_int, 2))))); + rlVertex3f(x - (width / @as(f32, @floatFromInt(@as(c_int, 2)))), y + (height / @as(f32, @floatFromInt(@as(c_int, 2)))), z + (length / @as(f32, @floatFromInt(@as(c_int, 2))))); + rlVertex3f(x - (width / @as(f32, @floatFromInt(@as(c_int, 2)))), y - (height / @as(f32, @floatFromInt(@as(c_int, 2)))), z + (length / @as(f32, @floatFromInt(@as(c_int, 2))))); + rlVertex3f(x - (width / @as(f32, @floatFromInt(@as(c_int, 2)))), y - (height / @as(f32, @floatFromInt(@as(c_int, 2)))), z - (length / @as(f32, @floatFromInt(@as(c_int, 2))))); + rlVertex3f(x + (width / @as(f32, @floatFromInt(@as(c_int, 2)))), y - (height / @as(f32, @floatFromInt(@as(c_int, 2)))), z - (length / @as(f32, @floatFromInt(@as(c_int, 2))))); + rlVertex3f(x + (width / @as(f32, @floatFromInt(@as(c_int, 2)))), y - (height / @as(f32, @floatFromInt(@as(c_int, 2)))), z - (length / @as(f32, @floatFromInt(@as(c_int, 2))))); + rlVertex3f(x + (width / @as(f32, @floatFromInt(@as(c_int, 2)))), y + (height / @as(f32, @floatFromInt(@as(c_int, 2)))), z - (length / @as(f32, @floatFromInt(@as(c_int, 2))))); + rlVertex3f(x + (width / @as(f32, @floatFromInt(@as(c_int, 2)))), y + (height / @as(f32, @floatFromInt(@as(c_int, 2)))), z - (length / @as(f32, @floatFromInt(@as(c_int, 2))))); + rlVertex3f(x - (width / @as(f32, @floatFromInt(@as(c_int, 2)))), y + (height / @as(f32, @floatFromInt(@as(c_int, 2)))), z - (length / @as(f32, @floatFromInt(@as(c_int, 2))))); + rlVertex3f(x - (width / @as(f32, @floatFromInt(@as(c_int, 2)))), y + (height / @as(f32, @floatFromInt(@as(c_int, 2)))), z - (length / @as(f32, @floatFromInt(@as(c_int, 2))))); + rlVertex3f(x - (width / @as(f32, @floatFromInt(@as(c_int, 2)))), y - (height / @as(f32, @floatFromInt(@as(c_int, 2)))), z - (length / @as(f32, @floatFromInt(@as(c_int, 2))))); + rlVertex3f(x - (width / @as(f32, @floatFromInt(@as(c_int, 2)))), y + (height / @as(f32, @floatFromInt(@as(c_int, 2)))), z + (length / @as(f32, @floatFromInt(@as(c_int, 2))))); + rlVertex3f(x - (width / @as(f32, @floatFromInt(@as(c_int, 2)))), y + (height / @as(f32, @floatFromInt(@as(c_int, 2)))), z - (length / @as(f32, @floatFromInt(@as(c_int, 2))))); + rlVertex3f(x + (width / @as(f32, @floatFromInt(@as(c_int, 2)))), y + (height / @as(f32, @floatFromInt(@as(c_int, 2)))), z + (length / @as(f32, @floatFromInt(@as(c_int, 2))))); + rlVertex3f(x + (width / @as(f32, @floatFromInt(@as(c_int, 2)))), y + (height / @as(f32, @floatFromInt(@as(c_int, 2)))), z - (length / @as(f32, @floatFromInt(@as(c_int, 2))))); + rlVertex3f(x - (width / @as(f32, @floatFromInt(@as(c_int, 2)))), y - (height / @as(f32, @floatFromInt(@as(c_int, 2)))), z + (length / @as(f32, @floatFromInt(@as(c_int, 2))))); + rlVertex3f(x - (width / @as(f32, @floatFromInt(@as(c_int, 2)))), y - (height / @as(f32, @floatFromInt(@as(c_int, 2)))), z - (length / @as(f32, @floatFromInt(@as(c_int, 2))))); + rlVertex3f(x + (width / @as(f32, @floatFromInt(@as(c_int, 2)))), y - (height / @as(f32, @floatFromInt(@as(c_int, 2)))), z + (length / @as(f32, @floatFromInt(@as(c_int, 2))))); + rlVertex3f(x + (width / @as(f32, @floatFromInt(@as(c_int, 2)))), y - (height / @as(f32, @floatFromInt(@as(c_int, 2)))), z - (length / @as(f32, @floatFromInt(@as(c_int, 2))))); + rlEnd(); + rlPopMatrix(); +} +pub export fn DrawCubeWiresV(arg_position: Vector3, arg_size: Vector3, arg_color: Color) void { + var position = arg_position; + _ = &position; + var size = arg_size; + _ = &size; + var color = arg_color; + _ = &color; + DrawCubeWires(position, size.x, size.y, size.z, color); +} +pub export fn DrawSphere(arg_centerPos: Vector3, arg_radius: f32, arg_color: Color) void { + var centerPos = arg_centerPos; + _ = ¢erPos; + var radius = arg_radius; + _ = &radius; + var color = arg_color; + _ = &color; + DrawSphereEx(centerPos, radius, @as(c_int, 16), @as(c_int, 16), color); +} +pub export fn DrawSphereEx(arg_centerPos: Vector3, arg_radius: f32, arg_rings: c_int, arg_slices: c_int, arg_color: Color) void { + var centerPos = arg_centerPos; + _ = ¢erPos; + var radius = arg_radius; + _ = &radius; + var rings = arg_rings; + _ = &rings; + var slices = arg_slices; + _ = &slices; + var color = arg_color; + _ = &color; + rlPushMatrix(); + rlTranslatef(centerPos.x, centerPos.y, centerPos.z); + rlScalef(radius, radius, radius); + rlBegin(@as(c_int, 4)); + rlColor4ub(color.r, color.g, color.b, color.a); + var ringangle: f32 = (3.1415927410125732 / 180.0) * (180.0 / @as(f32, @floatFromInt(rings + @as(c_int, 1)))); + _ = &ringangle; + var sliceangle: f32 = (3.1415927410125732 / 180.0) * (360.0 / @as(f32, @floatFromInt(slices))); + _ = &sliceangle; + var cosring: f32 = cosf(ringangle); + _ = &cosring; + var sinring: f32 = sinf(ringangle); + _ = &sinring; + var cosslice: f32 = cosf(sliceangle); + _ = &cosslice; + var sinslice: f32 = sinf(sliceangle); + _ = &sinslice; + var vertices: [4]Vector3 = [1]Vector3{ + Vector3{ + .x = @as(f32, @floatFromInt(@as(c_int, 0))), + .y = 0, + .z = 0, + }, + } ++ [1]Vector3{@import("std").mem.zeroes(Vector3)} ** 3; + _ = &vertices; + vertices[@as(c_uint, @intCast(@as(c_int, 2)))] = Vector3{ + .x = @as(f32, @floatFromInt(@as(c_int, 0))), + .y = @as(f32, @floatFromInt(@as(c_int, 1))), + .z = @as(f32, @floatFromInt(@as(c_int, 0))), + }; + vertices[@as(c_uint, @intCast(@as(c_int, 3)))] = Vector3{ + .x = sinring, + .y = cosring, + .z = @as(f32, @floatFromInt(@as(c_int, 0))), + }; + { + var i: c_int = 0; + _ = &i; + while (i < (rings + @as(c_int, 1))) : (i += 1) { + { + var j: c_int = 0; + _ = &j; + while (j < slices) : (j += 1) { + vertices[@as(c_uint, @intCast(@as(c_int, 0)))] = vertices[@as(c_uint, @intCast(@as(c_int, 2)))]; + vertices[@as(c_uint, @intCast(@as(c_int, 1)))] = vertices[@as(c_uint, @intCast(@as(c_int, 3)))]; + vertices[@as(c_uint, @intCast(@as(c_int, 2)))] = Vector3{ + .x = (cosslice * vertices[@as(c_uint, @intCast(@as(c_int, 2)))].x) - (sinslice * vertices[@as(c_uint, @intCast(@as(c_int, 2)))].z), + .y = vertices[@as(c_uint, @intCast(@as(c_int, 2)))].y, + .z = (sinslice * vertices[@as(c_uint, @intCast(@as(c_int, 2)))].x) + (cosslice * vertices[@as(c_uint, @intCast(@as(c_int, 2)))].z), + }; + vertices[@as(c_uint, @intCast(@as(c_int, 3)))] = Vector3{ + .x = (cosslice * vertices[@as(c_uint, @intCast(@as(c_int, 3)))].x) - (sinslice * vertices[@as(c_uint, @intCast(@as(c_int, 3)))].z), + .y = vertices[@as(c_uint, @intCast(@as(c_int, 3)))].y, + .z = (sinslice * vertices[@as(c_uint, @intCast(@as(c_int, 3)))].x) + (cosslice * vertices[@as(c_uint, @intCast(@as(c_int, 3)))].z), + }; + rlVertex3f(vertices[@as(c_uint, @intCast(@as(c_int, 0)))].x, vertices[@as(c_uint, @intCast(@as(c_int, 0)))].y, vertices[@as(c_uint, @intCast(@as(c_int, 0)))].z); + rlVertex3f(vertices[@as(c_uint, @intCast(@as(c_int, 3)))].x, vertices[@as(c_uint, @intCast(@as(c_int, 3)))].y, vertices[@as(c_uint, @intCast(@as(c_int, 3)))].z); + rlVertex3f(vertices[@as(c_uint, @intCast(@as(c_int, 1)))].x, vertices[@as(c_uint, @intCast(@as(c_int, 1)))].y, vertices[@as(c_uint, @intCast(@as(c_int, 1)))].z); + rlVertex3f(vertices[@as(c_uint, @intCast(@as(c_int, 0)))].x, vertices[@as(c_uint, @intCast(@as(c_int, 0)))].y, vertices[@as(c_uint, @intCast(@as(c_int, 0)))].z); + rlVertex3f(vertices[@as(c_uint, @intCast(@as(c_int, 2)))].x, vertices[@as(c_uint, @intCast(@as(c_int, 2)))].y, vertices[@as(c_uint, @intCast(@as(c_int, 2)))].z); + rlVertex3f(vertices[@as(c_uint, @intCast(@as(c_int, 3)))].x, vertices[@as(c_uint, @intCast(@as(c_int, 3)))].y, vertices[@as(c_uint, @intCast(@as(c_int, 3)))].z); + } + } + vertices[@as(c_uint, @intCast(@as(c_int, 2)))] = vertices[@as(c_uint, @intCast(@as(c_int, 3)))]; + vertices[@as(c_uint, @intCast(@as(c_int, 3)))] = Vector3{ + .x = (cosring * vertices[@as(c_uint, @intCast(@as(c_int, 3)))].x) + (sinring * vertices[@as(c_uint, @intCast(@as(c_int, 3)))].y), + .y = (-sinring * vertices[@as(c_uint, @intCast(@as(c_int, 3)))].x) + (cosring * vertices[@as(c_uint, @intCast(@as(c_int, 3)))].y), + .z = vertices[@as(c_uint, @intCast(@as(c_int, 3)))].z, + }; + } + } + rlEnd(); + rlPopMatrix(); +} +pub export fn DrawSphereWires(arg_centerPos: Vector3, arg_radius: f32, arg_rings: c_int, arg_slices: c_int, arg_color: Color) void { + var centerPos = arg_centerPos; + _ = ¢erPos; + var radius = arg_radius; + _ = &radius; + var rings = arg_rings; + _ = &rings; + var slices = arg_slices; + _ = &slices; + var color = arg_color; + _ = &color; + rlPushMatrix(); + rlTranslatef(centerPos.x, centerPos.y, centerPos.z); + rlScalef(radius, radius, radius); + rlBegin(@as(c_int, 1)); + rlColor4ub(color.r, color.g, color.b, color.a); + { + var i: c_int = 0; + _ = &i; + while (i < (rings + @as(c_int, 2))) : (i += 1) { + { + var j: c_int = 0; + _ = &j; + while (j < slices) : (j += 1) { + rlVertex3f(cosf((3.1415927410125732 / 180.0) * (@as(f32, @floatFromInt(@as(c_int, 270))) + ((180.0 / @as(f32, @floatFromInt(rings + @as(c_int, 1)))) * @as(f32, @floatFromInt(i))))) * sinf((3.1415927410125732 / 180.0) * ((360.0 * @as(f32, @floatFromInt(j))) / @as(f32, @floatFromInt(slices)))), sinf((3.1415927410125732 / 180.0) * (@as(f32, @floatFromInt(@as(c_int, 270))) + ((180.0 / @as(f32, @floatFromInt(rings + @as(c_int, 1)))) * @as(f32, @floatFromInt(i))))), cosf((3.1415927410125732 / 180.0) * (@as(f32, @floatFromInt(@as(c_int, 270))) + ((180.0 / @as(f32, @floatFromInt(rings + @as(c_int, 1)))) * @as(f32, @floatFromInt(i))))) * cosf((3.1415927410125732 / 180.0) * ((360.0 * @as(f32, @floatFromInt(j))) / @as(f32, @floatFromInt(slices))))); + rlVertex3f(cosf((3.1415927410125732 / 180.0) * (@as(f32, @floatFromInt(@as(c_int, 270))) + ((180.0 / @as(f32, @floatFromInt(rings + @as(c_int, 1)))) * @as(f32, @floatFromInt(i + @as(c_int, 1)))))) * sinf((3.1415927410125732 / 180.0) * ((360.0 * @as(f32, @floatFromInt(j + @as(c_int, 1)))) / @as(f32, @floatFromInt(slices)))), sinf((3.1415927410125732 / 180.0) * (@as(f32, @floatFromInt(@as(c_int, 270))) + ((180.0 / @as(f32, @floatFromInt(rings + @as(c_int, 1)))) * @as(f32, @floatFromInt(i + @as(c_int, 1)))))), cosf((3.1415927410125732 / 180.0) * (@as(f32, @floatFromInt(@as(c_int, 270))) + ((180.0 / @as(f32, @floatFromInt(rings + @as(c_int, 1)))) * @as(f32, @floatFromInt(i + @as(c_int, 1)))))) * cosf((3.1415927410125732 / 180.0) * ((360.0 * @as(f32, @floatFromInt(j + @as(c_int, 1)))) / @as(f32, @floatFromInt(slices))))); + rlVertex3f(cosf((3.1415927410125732 / 180.0) * (@as(f32, @floatFromInt(@as(c_int, 270))) + ((180.0 / @as(f32, @floatFromInt(rings + @as(c_int, 1)))) * @as(f32, @floatFromInt(i + @as(c_int, 1)))))) * sinf((3.1415927410125732 / 180.0) * ((360.0 * @as(f32, @floatFromInt(j + @as(c_int, 1)))) / @as(f32, @floatFromInt(slices)))), sinf((3.1415927410125732 / 180.0) * (@as(f32, @floatFromInt(@as(c_int, 270))) + ((180.0 / @as(f32, @floatFromInt(rings + @as(c_int, 1)))) * @as(f32, @floatFromInt(i + @as(c_int, 1)))))), cosf((3.1415927410125732 / 180.0) * (@as(f32, @floatFromInt(@as(c_int, 270))) + ((180.0 / @as(f32, @floatFromInt(rings + @as(c_int, 1)))) * @as(f32, @floatFromInt(i + @as(c_int, 1)))))) * cosf((3.1415927410125732 / 180.0) * ((360.0 * @as(f32, @floatFromInt(j + @as(c_int, 1)))) / @as(f32, @floatFromInt(slices))))); + rlVertex3f(cosf((3.1415927410125732 / 180.0) * (@as(f32, @floatFromInt(@as(c_int, 270))) + ((180.0 / @as(f32, @floatFromInt(rings + @as(c_int, 1)))) * @as(f32, @floatFromInt(i + @as(c_int, 1)))))) * sinf((3.1415927410125732 / 180.0) * ((360.0 * @as(f32, @floatFromInt(j))) / @as(f32, @floatFromInt(slices)))), sinf((3.1415927410125732 / 180.0) * (@as(f32, @floatFromInt(@as(c_int, 270))) + ((180.0 / @as(f32, @floatFromInt(rings + @as(c_int, 1)))) * @as(f32, @floatFromInt(i + @as(c_int, 1)))))), cosf((3.1415927410125732 / 180.0) * (@as(f32, @floatFromInt(@as(c_int, 270))) + ((180.0 / @as(f32, @floatFromInt(rings + @as(c_int, 1)))) * @as(f32, @floatFromInt(i + @as(c_int, 1)))))) * cosf((3.1415927410125732 / 180.0) * ((360.0 * @as(f32, @floatFromInt(j))) / @as(f32, @floatFromInt(slices))))); + rlVertex3f(cosf((3.1415927410125732 / 180.0) * (@as(f32, @floatFromInt(@as(c_int, 270))) + ((180.0 / @as(f32, @floatFromInt(rings + @as(c_int, 1)))) * @as(f32, @floatFromInt(i + @as(c_int, 1)))))) * sinf((3.1415927410125732 / 180.0) * ((360.0 * @as(f32, @floatFromInt(j))) / @as(f32, @floatFromInt(slices)))), sinf((3.1415927410125732 / 180.0) * (@as(f32, @floatFromInt(@as(c_int, 270))) + ((180.0 / @as(f32, @floatFromInt(rings + @as(c_int, 1)))) * @as(f32, @floatFromInt(i + @as(c_int, 1)))))), cosf((3.1415927410125732 / 180.0) * (@as(f32, @floatFromInt(@as(c_int, 270))) + ((180.0 / @as(f32, @floatFromInt(rings + @as(c_int, 1)))) * @as(f32, @floatFromInt(i + @as(c_int, 1)))))) * cosf((3.1415927410125732 / 180.0) * ((360.0 * @as(f32, @floatFromInt(j))) / @as(f32, @floatFromInt(slices))))); + rlVertex3f(cosf((3.1415927410125732 / 180.0) * (@as(f32, @floatFromInt(@as(c_int, 270))) + ((180.0 / @as(f32, @floatFromInt(rings + @as(c_int, 1)))) * @as(f32, @floatFromInt(i))))) * sinf((3.1415927410125732 / 180.0) * ((360.0 * @as(f32, @floatFromInt(j))) / @as(f32, @floatFromInt(slices)))), sinf((3.1415927410125732 / 180.0) * (@as(f32, @floatFromInt(@as(c_int, 270))) + ((180.0 / @as(f32, @floatFromInt(rings + @as(c_int, 1)))) * @as(f32, @floatFromInt(i))))), cosf((3.1415927410125732 / 180.0) * (@as(f32, @floatFromInt(@as(c_int, 270))) + ((180.0 / @as(f32, @floatFromInt(rings + @as(c_int, 1)))) * @as(f32, @floatFromInt(i))))) * cosf((3.1415927410125732 / 180.0) * ((360.0 * @as(f32, @floatFromInt(j))) / @as(f32, @floatFromInt(slices))))); + } + } + } + } + rlEnd(); + rlPopMatrix(); +} +pub export fn DrawCylinder(arg_position: Vector3, arg_radiusTop: f32, arg_radiusBottom: f32, arg_height: f32, arg_sides: c_int, arg_color: Color) void { + var position = arg_position; + _ = &position; + var radiusTop = arg_radiusTop; + _ = &radiusTop; + var radiusBottom = arg_radiusBottom; + _ = &radiusBottom; + var height = arg_height; + _ = &height; + var sides = arg_sides; + _ = &sides; + var color = arg_color; + _ = &color; + if (sides < @as(c_int, 3)) { + sides = 3; + } + const angleStep: f32 = 360.0 / @as(f32, @floatFromInt(sides)); + _ = &angleStep; + rlPushMatrix(); + rlTranslatef(position.x, position.y, position.z); + rlBegin(@as(c_int, 4)); + rlColor4ub(color.r, color.g, color.b, color.a); + if (radiusTop > @as(f32, @floatFromInt(@as(c_int, 0)))) { + { + var i: c_int = 0; + _ = &i; + while (i < sides) : (i += 1) { + rlVertex3f(sinf(((3.1415927410125732 / 180.0) * @as(f32, @floatFromInt(i))) * angleStep) * radiusBottom, @as(f32, @floatFromInt(@as(c_int, 0))), cosf(((3.1415927410125732 / 180.0) * @as(f32, @floatFromInt(i))) * angleStep) * radiusBottom); + rlVertex3f(sinf(((3.1415927410125732 / 180.0) * @as(f32, @floatFromInt(i + @as(c_int, 1)))) * angleStep) * radiusBottom, @as(f32, @floatFromInt(@as(c_int, 0))), cosf(((3.1415927410125732 / 180.0) * @as(f32, @floatFromInt(i + @as(c_int, 1)))) * angleStep) * radiusBottom); + rlVertex3f(sinf(((3.1415927410125732 / 180.0) * @as(f32, @floatFromInt(i + @as(c_int, 1)))) * angleStep) * radiusTop, height, cosf(((3.1415927410125732 / 180.0) * @as(f32, @floatFromInt(i + @as(c_int, 1)))) * angleStep) * radiusTop); + rlVertex3f(sinf(((3.1415927410125732 / 180.0) * @as(f32, @floatFromInt(i))) * angleStep) * radiusTop, height, cosf(((3.1415927410125732 / 180.0) * @as(f32, @floatFromInt(i))) * angleStep) * radiusTop); + rlVertex3f(sinf(((3.1415927410125732 / 180.0) * @as(f32, @floatFromInt(i))) * angleStep) * radiusBottom, @as(f32, @floatFromInt(@as(c_int, 0))), cosf(((3.1415927410125732 / 180.0) * @as(f32, @floatFromInt(i))) * angleStep) * radiusBottom); + rlVertex3f(sinf(((3.1415927410125732 / 180.0) * @as(f32, @floatFromInt(i + @as(c_int, 1)))) * angleStep) * radiusTop, height, cosf(((3.1415927410125732 / 180.0) * @as(f32, @floatFromInt(i + @as(c_int, 1)))) * angleStep) * radiusTop); + } + } + { + var i: c_int = 0; + _ = &i; + while (i < sides) : (i += 1) { + rlVertex3f(@as(f32, @floatFromInt(@as(c_int, 0))), height, @as(f32, @floatFromInt(@as(c_int, 0)))); + rlVertex3f(sinf(((3.1415927410125732 / 180.0) * @as(f32, @floatFromInt(i))) * angleStep) * radiusTop, height, cosf(((3.1415927410125732 / 180.0) * @as(f32, @floatFromInt(i))) * angleStep) * radiusTop); + rlVertex3f(sinf(((3.1415927410125732 / 180.0) * @as(f32, @floatFromInt(i + @as(c_int, 1)))) * angleStep) * radiusTop, height, cosf(((3.1415927410125732 / 180.0) * @as(f32, @floatFromInt(i + @as(c_int, 1)))) * angleStep) * radiusTop); + } + } + } else { + { + var i: c_int = 0; + _ = &i; + while (i < sides) : (i += 1) { + rlVertex3f(@as(f32, @floatFromInt(@as(c_int, 0))), height, @as(f32, @floatFromInt(@as(c_int, 0)))); + rlVertex3f(sinf(((3.1415927410125732 / 180.0) * @as(f32, @floatFromInt(i))) * angleStep) * radiusBottom, @as(f32, @floatFromInt(@as(c_int, 0))), cosf(((3.1415927410125732 / 180.0) * @as(f32, @floatFromInt(i))) * angleStep) * radiusBottom); + rlVertex3f(sinf(((3.1415927410125732 / 180.0) * @as(f32, @floatFromInt(i + @as(c_int, 1)))) * angleStep) * radiusBottom, @as(f32, @floatFromInt(@as(c_int, 0))), cosf(((3.1415927410125732 / 180.0) * @as(f32, @floatFromInt(i + @as(c_int, 1)))) * angleStep) * radiusBottom); + } + } + } + { + var i: c_int = 0; + _ = &i; + while (i < sides) : (i += 1) { + rlVertex3f(@as(f32, @floatFromInt(@as(c_int, 0))), @as(f32, @floatFromInt(@as(c_int, 0))), @as(f32, @floatFromInt(@as(c_int, 0)))); + rlVertex3f(sinf(((3.1415927410125732 / 180.0) * @as(f32, @floatFromInt(i))) * angleStep) * radiusBottom, @as(f32, @floatFromInt(@as(c_int, 0))), cosf(((3.1415927410125732 / 180.0) * @as(f32, @floatFromInt(i + @as(c_int, 1)))) * angleStep) * radiusBottom); + rlVertex3f(sinf(((3.1415927410125732 / 180.0) * @as(f32, @floatFromInt(i))) * angleStep) * radiusBottom, @as(f32, @floatFromInt(@as(c_int, 0))), cosf(((3.1415927410125732 / 180.0) * @as(f32, @floatFromInt(i))) * angleStep) * radiusBottom); + } + } + rlEnd(); + rlPopMatrix(); +} +pub export fn DrawCylinderEx(arg_startPos: Vector3, arg_endPos: Vector3, arg_startRadius: f32, arg_endRadius: f32, arg_sides: c_int, arg_color: Color) void { + var startPos = arg_startPos; + _ = &startPos; + var endPos = arg_endPos; + _ = &endPos; + var startRadius = arg_startRadius; + _ = &startRadius; + var endRadius = arg_endRadius; + _ = &endRadius; + var sides = arg_sides; + _ = &sides; + var color = arg_color; + _ = &color; + if (sides < @as(c_int, 3)) { + sides = 3; + } + var direction: Vector3 = Vector3{ + .x = endPos.x - startPos.x, + .y = endPos.y - startPos.y, + .z = endPos.z - startPos.z, + }; + _ = &direction; + if (((direction.x == @as(f32, @floatFromInt(@as(c_int, 0)))) and (direction.y == @as(f32, @floatFromInt(@as(c_int, 0))))) and (direction.z == @as(f32, @floatFromInt(@as(c_int, 0))))) return; + var b1: Vector3 = Vector3Normalize(Vector3Perpendicular(direction)); + _ = &b1; + var b2: Vector3 = Vector3Normalize(Vector3CrossProduct(b1, direction)); + _ = &b2; + var baseAngle: f32 = (2.0 * 3.1415927410125732) / @as(f32, @floatFromInt(sides)); + _ = &baseAngle; + rlBegin(@as(c_int, 4)); + rlColor4ub(color.r, color.g, color.b, color.a); + { + var i: c_int = 0; + _ = &i; + while (i < sides) : (i += 1) { + var s1: f32 = sinf(baseAngle * @as(f32, @floatFromInt(i + @as(c_int, 0)))) * startRadius; + _ = &s1; + var c1: f32 = cosf(baseAngle * @as(f32, @floatFromInt(i + @as(c_int, 0)))) * startRadius; + _ = &c1; + var w1: Vector3 = Vector3{ + .x = (startPos.x + (s1 * b1.x)) + (c1 * b2.x), + .y = (startPos.y + (s1 * b1.y)) + (c1 * b2.y), + .z = (startPos.z + (s1 * b1.z)) + (c1 * b2.z), + }; + _ = &w1; + var s2: f32 = sinf(baseAngle * @as(f32, @floatFromInt(i + @as(c_int, 1)))) * startRadius; + _ = &s2; + var c2: f32 = cosf(baseAngle * @as(f32, @floatFromInt(i + @as(c_int, 1)))) * startRadius; + _ = &c2; + var w2: Vector3 = Vector3{ + .x = (startPos.x + (s2 * b1.x)) + (c2 * b2.x), + .y = (startPos.y + (s2 * b1.y)) + (c2 * b2.y), + .z = (startPos.z + (s2 * b1.z)) + (c2 * b2.z), + }; + _ = &w2; + var s3: f32 = sinf(baseAngle * @as(f32, @floatFromInt(i + @as(c_int, 0)))) * endRadius; + _ = &s3; + var c3: f32 = cosf(baseAngle * @as(f32, @floatFromInt(i + @as(c_int, 0)))) * endRadius; + _ = &c3; + var w3: Vector3 = Vector3{ + .x = (endPos.x + (s3 * b1.x)) + (c3 * b2.x), + .y = (endPos.y + (s3 * b1.y)) + (c3 * b2.y), + .z = (endPos.z + (s3 * b1.z)) + (c3 * b2.z), + }; + _ = &w3; + var s4: f32 = sinf(baseAngle * @as(f32, @floatFromInt(i + @as(c_int, 1)))) * endRadius; + _ = &s4; + var c4: f32 = cosf(baseAngle * @as(f32, @floatFromInt(i + @as(c_int, 1)))) * endRadius; + _ = &c4; + var w4: Vector3 = Vector3{ + .x = (endPos.x + (s4 * b1.x)) + (c4 * b2.x), + .y = (endPos.y + (s4 * b1.y)) + (c4 * b2.y), + .z = (endPos.z + (s4 * b1.z)) + (c4 * b2.z), + }; + _ = &w4; + if (startRadius > @as(f32, @floatFromInt(@as(c_int, 0)))) { + rlVertex3f(startPos.x, startPos.y, startPos.z); + rlVertex3f(w2.x, w2.y, w2.z); + rlVertex3f(w1.x, w1.y, w1.z); + } + rlVertex3f(w1.x, w1.y, w1.z); + rlVertex3f(w2.x, w2.y, w2.z); + rlVertex3f(w3.x, w3.y, w3.z); + rlVertex3f(w2.x, w2.y, w2.z); + rlVertex3f(w4.x, w4.y, w4.z); + rlVertex3f(w3.x, w3.y, w3.z); + if (endRadius > @as(f32, @floatFromInt(@as(c_int, 0)))) { + rlVertex3f(endPos.x, endPos.y, endPos.z); + rlVertex3f(w3.x, w3.y, w3.z); + rlVertex3f(w4.x, w4.y, w4.z); + } + } + } + rlEnd(); +} +pub export fn DrawCylinderWires(arg_position: Vector3, arg_radiusTop: f32, arg_radiusBottom: f32, arg_height: f32, arg_sides: c_int, arg_color: Color) void { + var position = arg_position; + _ = &position; + var radiusTop = arg_radiusTop; + _ = &radiusTop; + var radiusBottom = arg_radiusBottom; + _ = &radiusBottom; + var height = arg_height; + _ = &height; + var sides = arg_sides; + _ = &sides; + var color = arg_color; + _ = &color; + if (sides < @as(c_int, 3)) { + sides = 3; + } + const angleStep: f32 = 360.0 / @as(f32, @floatFromInt(sides)); + _ = &angleStep; + rlPushMatrix(); + rlTranslatef(position.x, position.y, position.z); + rlBegin(@as(c_int, 1)); + rlColor4ub(color.r, color.g, color.b, color.a); + { + var i: c_int = 0; + _ = &i; + while (i < sides) : (i += 1) { + rlVertex3f(sinf(((3.1415927410125732 / 180.0) * @as(f32, @floatFromInt(i))) * angleStep) * radiusBottom, @as(f32, @floatFromInt(@as(c_int, 0))), cosf(((3.1415927410125732 / 180.0) * @as(f32, @floatFromInt(i))) * angleStep) * radiusBottom); + rlVertex3f(sinf(((3.1415927410125732 / 180.0) * @as(f32, @floatFromInt(i + @as(c_int, 1)))) * angleStep) * radiusBottom, @as(f32, @floatFromInt(@as(c_int, 0))), cosf(((3.1415927410125732 / 180.0) * @as(f32, @floatFromInt(i + @as(c_int, 1)))) * angleStep) * radiusBottom); + rlVertex3f(sinf(((3.1415927410125732 / 180.0) * @as(f32, @floatFromInt(i + @as(c_int, 1)))) * angleStep) * radiusBottom, @as(f32, @floatFromInt(@as(c_int, 0))), cosf(((3.1415927410125732 / 180.0) * @as(f32, @floatFromInt(i + @as(c_int, 1)))) * angleStep) * radiusBottom); + rlVertex3f(sinf(((3.1415927410125732 / 180.0) * @as(f32, @floatFromInt(i + @as(c_int, 1)))) * angleStep) * radiusTop, height, cosf(((3.1415927410125732 / 180.0) * @as(f32, @floatFromInt(i + @as(c_int, 1)))) * angleStep) * radiusTop); + rlVertex3f(sinf(((3.1415927410125732 / 180.0) * @as(f32, @floatFromInt(i + @as(c_int, 1)))) * angleStep) * radiusTop, height, cosf(((3.1415927410125732 / 180.0) * @as(f32, @floatFromInt(i + @as(c_int, 1)))) * angleStep) * radiusTop); + rlVertex3f(sinf(((3.1415927410125732 / 180.0) * @as(f32, @floatFromInt(i))) * angleStep) * radiusTop, height, cosf(((3.1415927410125732 / 180.0) * @as(f32, @floatFromInt(i))) * angleStep) * radiusTop); + rlVertex3f(sinf(((3.1415927410125732 / 180.0) * @as(f32, @floatFromInt(i))) * angleStep) * radiusTop, height, cosf(((3.1415927410125732 / 180.0) * @as(f32, @floatFromInt(i))) * angleStep) * radiusTop); + rlVertex3f(sinf(((3.1415927410125732 / 180.0) * @as(f32, @floatFromInt(i))) * angleStep) * radiusBottom, @as(f32, @floatFromInt(@as(c_int, 0))), cosf(((3.1415927410125732 / 180.0) * @as(f32, @floatFromInt(i))) * angleStep) * radiusBottom); + } + } + rlEnd(); + rlPopMatrix(); +} +pub export fn DrawCylinderWiresEx(arg_startPos: Vector3, arg_endPos: Vector3, arg_startRadius: f32, arg_endRadius: f32, arg_sides: c_int, arg_color: Color) void { + var startPos = arg_startPos; + _ = &startPos; + var endPos = arg_endPos; + _ = &endPos; + var startRadius = arg_startRadius; + _ = &startRadius; + var endRadius = arg_endRadius; + _ = &endRadius; + var sides = arg_sides; + _ = &sides; + var color = arg_color; + _ = &color; + if (sides < @as(c_int, 3)) { + sides = 3; + } + var direction: Vector3 = Vector3{ + .x = endPos.x - startPos.x, + .y = endPos.y - startPos.y, + .z = endPos.z - startPos.z, + }; + _ = &direction; + if (((direction.x == @as(f32, @floatFromInt(@as(c_int, 0)))) and (direction.y == @as(f32, @floatFromInt(@as(c_int, 0))))) and (direction.z == @as(f32, @floatFromInt(@as(c_int, 0))))) return; + var b1: Vector3 = Vector3Normalize(Vector3Perpendicular(direction)); + _ = &b1; + var b2: Vector3 = Vector3Normalize(Vector3CrossProduct(b1, direction)); + _ = &b2; + var baseAngle: f32 = (2.0 * 3.1415927410125732) / @as(f32, @floatFromInt(sides)); + _ = &baseAngle; + rlBegin(@as(c_int, 1)); + rlColor4ub(color.r, color.g, color.b, color.a); + { + var i: c_int = 0; + _ = &i; + while (i < sides) : (i += 1) { + var s1: f32 = sinf(baseAngle * @as(f32, @floatFromInt(i + @as(c_int, 0)))) * startRadius; + _ = &s1; + var c1: f32 = cosf(baseAngle * @as(f32, @floatFromInt(i + @as(c_int, 0)))) * startRadius; + _ = &c1; + var w1: Vector3 = Vector3{ + .x = (startPos.x + (s1 * b1.x)) + (c1 * b2.x), + .y = (startPos.y + (s1 * b1.y)) + (c1 * b2.y), + .z = (startPos.z + (s1 * b1.z)) + (c1 * b2.z), + }; + _ = &w1; + var s2: f32 = sinf(baseAngle * @as(f32, @floatFromInt(i + @as(c_int, 1)))) * startRadius; + _ = &s2; + var c2: f32 = cosf(baseAngle * @as(f32, @floatFromInt(i + @as(c_int, 1)))) * startRadius; + _ = &c2; + var w2: Vector3 = Vector3{ + .x = (startPos.x + (s2 * b1.x)) + (c2 * b2.x), + .y = (startPos.y + (s2 * b1.y)) + (c2 * b2.y), + .z = (startPos.z + (s2 * b1.z)) + (c2 * b2.z), + }; + _ = &w2; + var s3: f32 = sinf(baseAngle * @as(f32, @floatFromInt(i + @as(c_int, 0)))) * endRadius; + _ = &s3; + var c3: f32 = cosf(baseAngle * @as(f32, @floatFromInt(i + @as(c_int, 0)))) * endRadius; + _ = &c3; + var w3: Vector3 = Vector3{ + .x = (endPos.x + (s3 * b1.x)) + (c3 * b2.x), + .y = (endPos.y + (s3 * b1.y)) + (c3 * b2.y), + .z = (endPos.z + (s3 * b1.z)) + (c3 * b2.z), + }; + _ = &w3; + var s4: f32 = sinf(baseAngle * @as(f32, @floatFromInt(i + @as(c_int, 1)))) * endRadius; + _ = &s4; + var c4: f32 = cosf(baseAngle * @as(f32, @floatFromInt(i + @as(c_int, 1)))) * endRadius; + _ = &c4; + var w4: Vector3 = Vector3{ + .x = (endPos.x + (s4 * b1.x)) + (c4 * b2.x), + .y = (endPos.y + (s4 * b1.y)) + (c4 * b2.y), + .z = (endPos.z + (s4 * b1.z)) + (c4 * b2.z), + }; + _ = &w4; + rlVertex3f(w1.x, w1.y, w1.z); + rlVertex3f(w2.x, w2.y, w2.z); + rlVertex3f(w1.x, w1.y, w1.z); + rlVertex3f(w3.x, w3.y, w3.z); + rlVertex3f(w3.x, w3.y, w3.z); + rlVertex3f(w4.x, w4.y, w4.z); + } + } + rlEnd(); +} +pub export fn DrawCapsule(arg_startPos: Vector3, arg_endPos: Vector3, arg_radius: f32, arg_slices: c_int, arg_rings: c_int, arg_color: Color) void { + var startPos = arg_startPos; + _ = &startPos; + var endPos = arg_endPos; + _ = &endPos; + var radius = arg_radius; + _ = &radius; + var slices = arg_slices; + _ = &slices; + var rings = arg_rings; + _ = &rings; + var color = arg_color; + _ = &color; + if (slices < @as(c_int, 3)) { + slices = 3; + } + var direction: Vector3 = Vector3{ + .x = endPos.x - startPos.x, + .y = endPos.y - startPos.y, + .z = endPos.z - startPos.z, + }; + _ = &direction; + var sphereCase: bool = ((direction.x == @as(f32, @floatFromInt(@as(c_int, 0)))) and (direction.y == @as(f32, @floatFromInt(@as(c_int, 0))))) and (direction.z == @as(f32, @floatFromInt(@as(c_int, 0)))); + _ = &sphereCase; + if (sphereCase) { + direction = Vector3{ + .x = 0.0, + .y = 1.0, + .z = 0.0, + }; + } + var b0: Vector3 = Vector3Normalize(direction); + _ = &b0; + var b1: Vector3 = Vector3Normalize(Vector3Perpendicular(direction)); + _ = &b1; + var b2: Vector3 = Vector3Normalize(Vector3CrossProduct(b1, direction)); + _ = &b2; + var capCenter: Vector3 = endPos; + _ = &capCenter; + var baseSliceAngle: f32 = (2.0 * 3.1415927410125732) / @as(f32, @floatFromInt(slices)); + _ = &baseSliceAngle; + var baseRingAngle: f32 = (3.1415927410125732 * 0.5) / @as(f32, @floatFromInt(rings)); + _ = &baseRingAngle; + rlBegin(@as(c_int, 4)); + rlColor4ub(color.r, color.g, color.b, color.a); + { + var c: c_int = 0; + _ = &c; + while (c < @as(c_int, 2)) : (c += 1) { + { + var i: c_int = 0; + _ = &i; + while (i < rings) : (i += 1) { + { + var j: c_int = 0; + _ = &j; + while (j < slices) : (j += 1) { + var ringSin1: f32 = sinf(baseSliceAngle * @as(f32, @floatFromInt(j + @as(c_int, 0)))) * cosf(baseRingAngle * @as(f32, @floatFromInt(i + @as(c_int, 0)))); + _ = &ringSin1; + var ringCos1: f32 = cosf(baseSliceAngle * @as(f32, @floatFromInt(j + @as(c_int, 0)))) * cosf(baseRingAngle * @as(f32, @floatFromInt(i + @as(c_int, 0)))); + _ = &ringCos1; + var w1: Vector3 = Vector3{ + .x = capCenter.x + ((((sinf(baseRingAngle * @as(f32, @floatFromInt(i + @as(c_int, 0)))) * b0.x) + (ringSin1 * b1.x)) + (ringCos1 * b2.x)) * radius), + .y = capCenter.y + ((((sinf(baseRingAngle * @as(f32, @floatFromInt(i + @as(c_int, 0)))) * b0.y) + (ringSin1 * b1.y)) + (ringCos1 * b2.y)) * radius), + .z = capCenter.z + ((((sinf(baseRingAngle * @as(f32, @floatFromInt(i + @as(c_int, 0)))) * b0.z) + (ringSin1 * b1.z)) + (ringCos1 * b2.z)) * radius), + }; + _ = &w1; + var ringSin2: f32 = sinf(baseSliceAngle * @as(f32, @floatFromInt(j + @as(c_int, 1)))) * cosf(baseRingAngle * @as(f32, @floatFromInt(i + @as(c_int, 0)))); + _ = &ringSin2; + var ringCos2: f32 = cosf(baseSliceAngle * @as(f32, @floatFromInt(j + @as(c_int, 1)))) * cosf(baseRingAngle * @as(f32, @floatFromInt(i + @as(c_int, 0)))); + _ = &ringCos2; + var w2: Vector3 = Vector3{ + .x = capCenter.x + ((((sinf(baseRingAngle * @as(f32, @floatFromInt(i + @as(c_int, 0)))) * b0.x) + (ringSin2 * b1.x)) + (ringCos2 * b2.x)) * radius), + .y = capCenter.y + ((((sinf(baseRingAngle * @as(f32, @floatFromInt(i + @as(c_int, 0)))) * b0.y) + (ringSin2 * b1.y)) + (ringCos2 * b2.y)) * radius), + .z = capCenter.z + ((((sinf(baseRingAngle * @as(f32, @floatFromInt(i + @as(c_int, 0)))) * b0.z) + (ringSin2 * b1.z)) + (ringCos2 * b2.z)) * radius), + }; + _ = &w2; + var ringSin3: f32 = sinf(baseSliceAngle * @as(f32, @floatFromInt(j + @as(c_int, 0)))) * cosf(baseRingAngle * @as(f32, @floatFromInt(i + @as(c_int, 1)))); + _ = &ringSin3; + var ringCos3: f32 = cosf(baseSliceAngle * @as(f32, @floatFromInt(j + @as(c_int, 0)))) * cosf(baseRingAngle * @as(f32, @floatFromInt(i + @as(c_int, 1)))); + _ = &ringCos3; + var w3: Vector3 = Vector3{ + .x = capCenter.x + ((((sinf(baseRingAngle * @as(f32, @floatFromInt(i + @as(c_int, 1)))) * b0.x) + (ringSin3 * b1.x)) + (ringCos3 * b2.x)) * radius), + .y = capCenter.y + ((((sinf(baseRingAngle * @as(f32, @floatFromInt(i + @as(c_int, 1)))) * b0.y) + (ringSin3 * b1.y)) + (ringCos3 * b2.y)) * radius), + .z = capCenter.z + ((((sinf(baseRingAngle * @as(f32, @floatFromInt(i + @as(c_int, 1)))) * b0.z) + (ringSin3 * b1.z)) + (ringCos3 * b2.z)) * radius), + }; + _ = &w3; + var ringSin4: f32 = sinf(baseSliceAngle * @as(f32, @floatFromInt(j + @as(c_int, 1)))) * cosf(baseRingAngle * @as(f32, @floatFromInt(i + @as(c_int, 1)))); + _ = &ringSin4; + var ringCos4: f32 = cosf(baseSliceAngle * @as(f32, @floatFromInt(j + @as(c_int, 1)))) * cosf(baseRingAngle * @as(f32, @floatFromInt(i + @as(c_int, 1)))); + _ = &ringCos4; + var w4: Vector3 = Vector3{ + .x = capCenter.x + ((((sinf(baseRingAngle * @as(f32, @floatFromInt(i + @as(c_int, 1)))) * b0.x) + (ringSin4 * b1.x)) + (ringCos4 * b2.x)) * radius), + .y = capCenter.y + ((((sinf(baseRingAngle * @as(f32, @floatFromInt(i + @as(c_int, 1)))) * b0.y) + (ringSin4 * b1.y)) + (ringCos4 * b2.y)) * radius), + .z = capCenter.z + ((((sinf(baseRingAngle * @as(f32, @floatFromInt(i + @as(c_int, 1)))) * b0.z) + (ringSin4 * b1.z)) + (ringCos4 * b2.z)) * radius), + }; + _ = &w4; + if (c == @as(c_int, 0)) { + rlVertex3f(w1.x, w1.y, w1.z); + rlVertex3f(w2.x, w2.y, w2.z); + rlVertex3f(w3.x, w3.y, w3.z); + rlVertex3f(w2.x, w2.y, w2.z); + rlVertex3f(w4.x, w4.y, w4.z); + rlVertex3f(w3.x, w3.y, w3.z); + } else { + rlVertex3f(w1.x, w1.y, w1.z); + rlVertex3f(w3.x, w3.y, w3.z); + rlVertex3f(w2.x, w2.y, w2.z); + rlVertex3f(w2.x, w2.y, w2.z); + rlVertex3f(w3.x, w3.y, w3.z); + rlVertex3f(w4.x, w4.y, w4.z); + } + } + } + } + } + capCenter = startPos; + b0 = Vector3Scale(b0, -1.0); + } + } + if (!sphereCase) { + { + var j: c_int = 0; + _ = &j; + while (j < slices) : (j += 1) { + var ringSin1: f32 = sinf(baseSliceAngle * @as(f32, @floatFromInt(j + @as(c_int, 0)))) * radius; + _ = &ringSin1; + var ringCos1: f32 = cosf(baseSliceAngle * @as(f32, @floatFromInt(j + @as(c_int, 0)))) * radius; + _ = &ringCos1; + var w1: Vector3 = Vector3{ + .x = (startPos.x + (ringSin1 * b1.x)) + (ringCos1 * b2.x), + .y = (startPos.y + (ringSin1 * b1.y)) + (ringCos1 * b2.y), + .z = (startPos.z + (ringSin1 * b1.z)) + (ringCos1 * b2.z), + }; + _ = &w1; + var ringSin2: f32 = sinf(baseSliceAngle * @as(f32, @floatFromInt(j + @as(c_int, 1)))) * radius; + _ = &ringSin2; + var ringCos2: f32 = cosf(baseSliceAngle * @as(f32, @floatFromInt(j + @as(c_int, 1)))) * radius; + _ = &ringCos2; + var w2: Vector3 = Vector3{ + .x = (startPos.x + (ringSin2 * b1.x)) + (ringCos2 * b2.x), + .y = (startPos.y + (ringSin2 * b1.y)) + (ringCos2 * b2.y), + .z = (startPos.z + (ringSin2 * b1.z)) + (ringCos2 * b2.z), + }; + _ = &w2; + var ringSin3: f32 = sinf(baseSliceAngle * @as(f32, @floatFromInt(j + @as(c_int, 0)))) * radius; + _ = &ringSin3; + var ringCos3: f32 = cosf(baseSliceAngle * @as(f32, @floatFromInt(j + @as(c_int, 0)))) * radius; + _ = &ringCos3; + var w3: Vector3 = Vector3{ + .x = (endPos.x + (ringSin3 * b1.x)) + (ringCos3 * b2.x), + .y = (endPos.y + (ringSin3 * b1.y)) + (ringCos3 * b2.y), + .z = (endPos.z + (ringSin3 * b1.z)) + (ringCos3 * b2.z), + }; + _ = &w3; + var ringSin4: f32 = sinf(baseSliceAngle * @as(f32, @floatFromInt(j + @as(c_int, 1)))) * radius; + _ = &ringSin4; + var ringCos4: f32 = cosf(baseSliceAngle * @as(f32, @floatFromInt(j + @as(c_int, 1)))) * radius; + _ = &ringCos4; + var w4: Vector3 = Vector3{ + .x = (endPos.x + (ringSin4 * b1.x)) + (ringCos4 * b2.x), + .y = (endPos.y + (ringSin4 * b1.y)) + (ringCos4 * b2.y), + .z = (endPos.z + (ringSin4 * b1.z)) + (ringCos4 * b2.z), + }; + _ = &w4; + rlVertex3f(w1.x, w1.y, w1.z); + rlVertex3f(w2.x, w2.y, w2.z); + rlVertex3f(w3.x, w3.y, w3.z); + rlVertex3f(w2.x, w2.y, w2.z); + rlVertex3f(w4.x, w4.y, w4.z); + rlVertex3f(w3.x, w3.y, w3.z); + } + } + } + rlEnd(); +} +pub export fn DrawCapsuleWires(arg_startPos: Vector3, arg_endPos: Vector3, arg_radius: f32, arg_slices: c_int, arg_rings: c_int, arg_color: Color) void { + var startPos = arg_startPos; + _ = &startPos; + var endPos = arg_endPos; + _ = &endPos; + var radius = arg_radius; + _ = &radius; + var slices = arg_slices; + _ = &slices; + var rings = arg_rings; + _ = &rings; + var color = arg_color; + _ = &color; + if (slices < @as(c_int, 3)) { + slices = 3; + } + var direction: Vector3 = Vector3{ + .x = endPos.x - startPos.x, + .y = endPos.y - startPos.y, + .z = endPos.z - startPos.z, + }; + _ = &direction; + var sphereCase: bool = ((direction.x == @as(f32, @floatFromInt(@as(c_int, 0)))) and (direction.y == @as(f32, @floatFromInt(@as(c_int, 0))))) and (direction.z == @as(f32, @floatFromInt(@as(c_int, 0)))); + _ = &sphereCase; + if (sphereCase) { + direction = Vector3{ + .x = 0.0, + .y = 1.0, + .z = 0.0, + }; + } + var b0: Vector3 = Vector3Normalize(direction); + _ = &b0; + var b1: Vector3 = Vector3Normalize(Vector3Perpendicular(direction)); + _ = &b1; + var b2: Vector3 = Vector3Normalize(Vector3CrossProduct(b1, direction)); + _ = &b2; + var capCenter: Vector3 = endPos; + _ = &capCenter; + var baseSliceAngle: f32 = (2.0 * 3.1415927410125732) / @as(f32, @floatFromInt(slices)); + _ = &baseSliceAngle; + var baseRingAngle: f32 = (3.1415927410125732 * 0.5) / @as(f32, @floatFromInt(rings)); + _ = &baseRingAngle; + rlBegin(@as(c_int, 1)); + rlColor4ub(color.r, color.g, color.b, color.a); + { + var c: c_int = 0; + _ = &c; + while (c < @as(c_int, 2)) : (c += 1) { + { + var i: c_int = 0; + _ = &i; + while (i < rings) : (i += 1) { + { + var j: c_int = 0; + _ = &j; + while (j < slices) : (j += 1) { + var ringSin1: f32 = sinf(baseSliceAngle * @as(f32, @floatFromInt(j + @as(c_int, 0)))) * cosf(baseRingAngle * @as(f32, @floatFromInt(i + @as(c_int, 0)))); + _ = &ringSin1; + var ringCos1: f32 = cosf(baseSliceAngle * @as(f32, @floatFromInt(j + @as(c_int, 0)))) * cosf(baseRingAngle * @as(f32, @floatFromInt(i + @as(c_int, 0)))); + _ = &ringCos1; + var w1: Vector3 = Vector3{ + .x = capCenter.x + ((((sinf(baseRingAngle * @as(f32, @floatFromInt(i + @as(c_int, 0)))) * b0.x) + (ringSin1 * b1.x)) + (ringCos1 * b2.x)) * radius), + .y = capCenter.y + ((((sinf(baseRingAngle * @as(f32, @floatFromInt(i + @as(c_int, 0)))) * b0.y) + (ringSin1 * b1.y)) + (ringCos1 * b2.y)) * radius), + .z = capCenter.z + ((((sinf(baseRingAngle * @as(f32, @floatFromInt(i + @as(c_int, 0)))) * b0.z) + (ringSin1 * b1.z)) + (ringCos1 * b2.z)) * radius), + }; + _ = &w1; + var ringSin2: f32 = sinf(baseSliceAngle * @as(f32, @floatFromInt(j + @as(c_int, 1)))) * cosf(baseRingAngle * @as(f32, @floatFromInt(i + @as(c_int, 0)))); + _ = &ringSin2; + var ringCos2: f32 = cosf(baseSliceAngle * @as(f32, @floatFromInt(j + @as(c_int, 1)))) * cosf(baseRingAngle * @as(f32, @floatFromInt(i + @as(c_int, 0)))); + _ = &ringCos2; + var w2: Vector3 = Vector3{ + .x = capCenter.x + ((((sinf(baseRingAngle * @as(f32, @floatFromInt(i + @as(c_int, 0)))) * b0.x) + (ringSin2 * b1.x)) + (ringCos2 * b2.x)) * radius), + .y = capCenter.y + ((((sinf(baseRingAngle * @as(f32, @floatFromInt(i + @as(c_int, 0)))) * b0.y) + (ringSin2 * b1.y)) + (ringCos2 * b2.y)) * radius), + .z = capCenter.z + ((((sinf(baseRingAngle * @as(f32, @floatFromInt(i + @as(c_int, 0)))) * b0.z) + (ringSin2 * b1.z)) + (ringCos2 * b2.z)) * radius), + }; + _ = &w2; + var ringSin3: f32 = sinf(baseSliceAngle * @as(f32, @floatFromInt(j + @as(c_int, 0)))) * cosf(baseRingAngle * @as(f32, @floatFromInt(i + @as(c_int, 1)))); + _ = &ringSin3; + var ringCos3: f32 = cosf(baseSliceAngle * @as(f32, @floatFromInt(j + @as(c_int, 0)))) * cosf(baseRingAngle * @as(f32, @floatFromInt(i + @as(c_int, 1)))); + _ = &ringCos3; + var w3: Vector3 = Vector3{ + .x = capCenter.x + ((((sinf(baseRingAngle * @as(f32, @floatFromInt(i + @as(c_int, 1)))) * b0.x) + (ringSin3 * b1.x)) + (ringCos3 * b2.x)) * radius), + .y = capCenter.y + ((((sinf(baseRingAngle * @as(f32, @floatFromInt(i + @as(c_int, 1)))) * b0.y) + (ringSin3 * b1.y)) + (ringCos3 * b2.y)) * radius), + .z = capCenter.z + ((((sinf(baseRingAngle * @as(f32, @floatFromInt(i + @as(c_int, 1)))) * b0.z) + (ringSin3 * b1.z)) + (ringCos3 * b2.z)) * radius), + }; + _ = &w3; + var ringSin4: f32 = sinf(baseSliceAngle * @as(f32, @floatFromInt(j + @as(c_int, 1)))) * cosf(baseRingAngle * @as(f32, @floatFromInt(i + @as(c_int, 1)))); + _ = &ringSin4; + var ringCos4: f32 = cosf(baseSliceAngle * @as(f32, @floatFromInt(j + @as(c_int, 1)))) * cosf(baseRingAngle * @as(f32, @floatFromInt(i + @as(c_int, 1)))); + _ = &ringCos4; + var w4: Vector3 = Vector3{ + .x = capCenter.x + ((((sinf(baseRingAngle * @as(f32, @floatFromInt(i + @as(c_int, 1)))) * b0.x) + (ringSin4 * b1.x)) + (ringCos4 * b2.x)) * radius), + .y = capCenter.y + ((((sinf(baseRingAngle * @as(f32, @floatFromInt(i + @as(c_int, 1)))) * b0.y) + (ringSin4 * b1.y)) + (ringCos4 * b2.y)) * radius), + .z = capCenter.z + ((((sinf(baseRingAngle * @as(f32, @floatFromInt(i + @as(c_int, 1)))) * b0.z) + (ringSin4 * b1.z)) + (ringCos4 * b2.z)) * radius), + }; + _ = &w4; + rlVertex3f(w1.x, w1.y, w1.z); + rlVertex3f(w2.x, w2.y, w2.z); + rlVertex3f(w2.x, w2.y, w2.z); + rlVertex3f(w3.x, w3.y, w3.z); + rlVertex3f(w1.x, w1.y, w1.z); + rlVertex3f(w3.x, w3.y, w3.z); + rlVertex3f(w2.x, w2.y, w2.z); + rlVertex3f(w4.x, w4.y, w4.z); + rlVertex3f(w3.x, w3.y, w3.z); + rlVertex3f(w4.x, w4.y, w4.z); + } + } + } + } + capCenter = startPos; + b0 = Vector3Scale(b0, -1.0); + } + } + if (!sphereCase) { + { + var j: c_int = 0; + _ = &j; + while (j < slices) : (j += 1) { + var ringSin1: f32 = sinf(baseSliceAngle * @as(f32, @floatFromInt(j + @as(c_int, 0)))) * radius; + _ = &ringSin1; + var ringCos1: f32 = cosf(baseSliceAngle * @as(f32, @floatFromInt(j + @as(c_int, 0)))) * radius; + _ = &ringCos1; + var w1: Vector3 = Vector3{ + .x = (startPos.x + (ringSin1 * b1.x)) + (ringCos1 * b2.x), + .y = (startPos.y + (ringSin1 * b1.y)) + (ringCos1 * b2.y), + .z = (startPos.z + (ringSin1 * b1.z)) + (ringCos1 * b2.z), + }; + _ = &w1; + var ringSin2: f32 = sinf(baseSliceAngle * @as(f32, @floatFromInt(j + @as(c_int, 1)))) * radius; + _ = &ringSin2; + var ringCos2: f32 = cosf(baseSliceAngle * @as(f32, @floatFromInt(j + @as(c_int, 1)))) * radius; + _ = &ringCos2; + var w2: Vector3 = Vector3{ + .x = (startPos.x + (ringSin2 * b1.x)) + (ringCos2 * b2.x), + .y = (startPos.y + (ringSin2 * b1.y)) + (ringCos2 * b2.y), + .z = (startPos.z + (ringSin2 * b1.z)) + (ringCos2 * b2.z), + }; + _ = &w2; + var ringSin3: f32 = sinf(baseSliceAngle * @as(f32, @floatFromInt(j + @as(c_int, 0)))) * radius; + _ = &ringSin3; + var ringCos3: f32 = cosf(baseSliceAngle * @as(f32, @floatFromInt(j + @as(c_int, 0)))) * radius; + _ = &ringCos3; + var w3: Vector3 = Vector3{ + .x = (endPos.x + (ringSin3 * b1.x)) + (ringCos3 * b2.x), + .y = (endPos.y + (ringSin3 * b1.y)) + (ringCos3 * b2.y), + .z = (endPos.z + (ringSin3 * b1.z)) + (ringCos3 * b2.z), + }; + _ = &w3; + var ringSin4: f32 = sinf(baseSliceAngle * @as(f32, @floatFromInt(j + @as(c_int, 1)))) * radius; + _ = &ringSin4; + var ringCos4: f32 = cosf(baseSliceAngle * @as(f32, @floatFromInt(j + @as(c_int, 1)))) * radius; + _ = &ringCos4; + var w4: Vector3 = Vector3{ + .x = (endPos.x + (ringSin4 * b1.x)) + (ringCos4 * b2.x), + .y = (endPos.y + (ringSin4 * b1.y)) + (ringCos4 * b2.y), + .z = (endPos.z + (ringSin4 * b1.z)) + (ringCos4 * b2.z), + }; + _ = &w4; + rlVertex3f(w1.x, w1.y, w1.z); + rlVertex3f(w3.x, w3.y, w3.z); + rlVertex3f(w2.x, w2.y, w2.z); + rlVertex3f(w4.x, w4.y, w4.z); + rlVertex3f(w2.x, w2.y, w2.z); + rlVertex3f(w3.x, w3.y, w3.z); + } + } + } + rlEnd(); +} +pub export fn DrawPlane(arg_centerPos: Vector3, arg_size: Vector2, arg_color: Color) void { + var centerPos = arg_centerPos; + _ = ¢erPos; + var size = arg_size; + _ = &size; + var color = arg_color; + _ = &color; + rlPushMatrix(); + rlTranslatef(centerPos.x, centerPos.y, centerPos.z); + rlScalef(size.x, 1.0, size.y); + rlBegin(@as(c_int, 7)); + rlColor4ub(color.r, color.g, color.b, color.a); + rlNormal3f(0.0, 1.0, 0.0); + rlVertex3f(-0.5, 0.0, -0.5); + rlVertex3f(-0.5, 0.0, 0.5); + rlVertex3f(0.5, 0.0, 0.5); + rlVertex3f(0.5, 0.0, -0.5); + rlEnd(); + rlPopMatrix(); +} +pub export fn DrawRay(arg_ray: Ray, arg_color: Color) void { + var ray = arg_ray; + _ = &ray; + var color = arg_color; + _ = &color; + var scale: f32 = 10000; + _ = &scale; + rlBegin(@as(c_int, 1)); + rlColor4ub(color.r, color.g, color.b, color.a); + rlColor4ub(color.r, color.g, color.b, color.a); + rlVertex3f(ray.position.x, ray.position.y, ray.position.z); + rlVertex3f(ray.position.x + (ray.direction.x * scale), ray.position.y + (ray.direction.y * scale), ray.position.z + (ray.direction.z * scale)); + rlEnd(); +} +pub export fn DrawGrid(arg_slices: c_int, arg_spacing: f32) void { + var slices = arg_slices; + _ = &slices; + var spacing = arg_spacing; + _ = &spacing; + var halfSlices: c_int = @divTrunc(slices, @as(c_int, 2)); + _ = &halfSlices; + rlBegin(@as(c_int, 1)); + { + var i: c_int = -halfSlices; + _ = &i; + while (i <= halfSlices) : (i += 1) { + if (i == @as(c_int, 0)) { + rlColor3f(0.5, 0.5, 0.5); + } else { + rlColor3f(0.75, 0.75, 0.75); + } + rlVertex3f(@as(f32, @floatFromInt(i)) * spacing, 0.0, @as(f32, @floatFromInt(-halfSlices)) * spacing); + rlVertex3f(@as(f32, @floatFromInt(i)) * spacing, 0.0, @as(f32, @floatFromInt(halfSlices)) * spacing); + rlVertex3f(@as(f32, @floatFromInt(-halfSlices)) * spacing, 0.0, @as(f32, @floatFromInt(i)) * spacing); + rlVertex3f(@as(f32, @floatFromInt(halfSlices)) * spacing, 0.0, @as(f32, @floatFromInt(i)) * spacing); + } + } + rlEnd(); +} +pub export fn LoadModel(arg_fileName: [*c]const u8) Model { + var fileName = arg_fileName; + _ = &fileName; + var model: Model = Model{ + .transform = Matrix{ + .m0 = @as(f32, @floatFromInt(@as(c_int, 0))), + .m4 = 0, + .m8 = 0, + .m12 = 0, + .m1 = 0, + .m5 = 0, + .m9 = 0, + .m13 = 0, + .m2 = 0, + .m6 = 0, + .m10 = 0, + .m14 = 0, + .m3 = 0, + .m7 = 0, + .m11 = 0, + .m15 = 0, + }, + .meshCount = 0, + .materialCount = 0, + .meshes = null, + .materials = null, + .meshMaterial = null, + .boneCount = 0, + .bones = null, + .bindPose = null, + }; + _ = &model; + if (IsFileExtension(fileName, ".obj")) { + model = LoadOBJ(fileName); + } + if (IsFileExtension(fileName, ".iqm")) { + model = LoadIQM(fileName); + } + if ((@as(c_int, @intFromBool(IsFileExtension(fileName, ".gltf"))) != 0) or (@as(c_int, @intFromBool(IsFileExtension(fileName, ".glb"))) != 0)) { + model = LoadGLTF(fileName); + } + if (IsFileExtension(fileName, ".vox")) { + model = LoadVOX(fileName); + } + if (IsFileExtension(fileName, ".m3d")) { + model = LoadM3D(fileName); + } + model.transform = MatrixIdentity(); + if ((model.meshCount != @as(c_int, 0)) and (model.meshes != @as([*c]Mesh, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0)))))))) { + { + var i: c_int = 0; + _ = &i; + while (i < model.meshCount) : (i += 1) { + UploadMesh(&(blk: { + const tmp = i; + if (tmp >= 0) break :blk model.meshes + @as(usize, @intCast(tmp)) else break :blk model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*, @as(c_int, 0) != 0); + } + } + } else { + TraceLog(LOG_WARNING, "MESH: [%s] Failed to load model mesh(es) data", fileName); + } + if (model.materialCount == @as(c_int, 0)) { + TraceLog(LOG_WARNING, "MATERIAL: [%s] Failed to load model material data, default to white material", fileName); + model.materialCount = 1; + model.materials = @as([*c]Material, @ptrCast(@alignCast(calloc(@as(c_ulong, @bitCast(@as(c_long, model.materialCount))), @sizeOf(Material))))); + model.materials[@as(c_uint, @intCast(@as(c_int, 0)))] = LoadMaterialDefault(); + if (model.meshMaterial == @as([*c]c_int, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0))))))) { + model.meshMaterial = @as([*c]c_int, @ptrCast(@alignCast(calloc(@as(c_ulong, @bitCast(@as(c_long, model.meshCount))), @sizeOf(c_int))))); + } + } + return model; +} +pub export fn LoadModelFromMesh(arg_mesh: Mesh) Model { + var mesh = arg_mesh; + _ = &mesh; + var model: Model = Model{ + .transform = Matrix{ + .m0 = @as(f32, @floatFromInt(@as(c_int, 0))), + .m4 = 0, + .m8 = 0, + .m12 = 0, + .m1 = 0, + .m5 = 0, + .m9 = 0, + .m13 = 0, + .m2 = 0, + .m6 = 0, + .m10 = 0, + .m14 = 0, + .m3 = 0, + .m7 = 0, + .m11 = 0, + .m15 = 0, + }, + .meshCount = 0, + .materialCount = 0, + .meshes = null, + .materials = null, + .meshMaterial = null, + .boneCount = 0, + .bones = null, + .bindPose = null, + }; + _ = &model; + model.transform = MatrixIdentity(); + model.meshCount = 1; + model.meshes = @as([*c]Mesh, @ptrCast(@alignCast(calloc(@as(c_ulong, @bitCast(@as(c_long, model.meshCount))), @sizeOf(Mesh))))); + model.meshes[@as(c_uint, @intCast(@as(c_int, 0)))] = mesh; + model.materialCount = 1; + model.materials = @as([*c]Material, @ptrCast(@alignCast(calloc(@as(c_ulong, @bitCast(@as(c_long, model.materialCount))), @sizeOf(Material))))); + model.materials[@as(c_uint, @intCast(@as(c_int, 0)))] = LoadMaterialDefault(); + model.meshMaterial = @as([*c]c_int, @ptrCast(@alignCast(calloc(@as(c_ulong, @bitCast(@as(c_long, model.meshCount))), @sizeOf(c_int))))); + model.meshMaterial[@as(c_uint, @intCast(@as(c_int, 0)))] = 0; + return model; +} +pub export fn IsModelReady(arg_model: Model) bool { + var model = arg_model; + _ = &model; + var result: bool = @as(c_int, 0) != 0; + _ = &result; + if (((((model.meshes != @as([*c]Mesh, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0))))))) and (model.materials != @as([*c]Material, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0)))))))) and (model.meshMaterial != @as([*c]c_int, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0)))))))) and (model.meshCount > @as(c_int, 0))) and (model.materialCount > @as(c_int, 0))) { + result = @as(c_int, 1) != 0; + } + return result; +} +pub export fn UnloadModel(arg_model: Model) void { + var model = arg_model; + _ = &model; + { + var i: c_int = 0; + _ = &i; + while (i < model.meshCount) : (i += 1) { + UnloadMesh((blk: { + const tmp = i; + if (tmp >= 0) break :blk model.meshes + @as(usize, @intCast(tmp)) else break :blk model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*); + } + } + { + var i: c_int = 0; + _ = &i; + while (i < model.materialCount) : (i += 1) { + free(@as(?*anyopaque, @ptrCast((blk: { + const tmp = i; + if (tmp >= 0) break :blk model.materials + @as(usize, @intCast(tmp)) else break :blk model.materials - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.maps))); + } + } + free(@as(?*anyopaque, @ptrCast(model.meshes))); + free(@as(?*anyopaque, @ptrCast(model.materials))); + free(@as(?*anyopaque, @ptrCast(model.meshMaterial))); + free(@as(?*anyopaque, @ptrCast(model.bones))); + free(@as(?*anyopaque, @ptrCast(model.bindPose))); + TraceLog(LOG_INFO, "MODEL: Unloaded model (and meshes) from RAM and VRAM"); +} +pub export fn GetModelBoundingBox(arg_model: Model) BoundingBox { + var model = arg_model; + _ = &model; + var bounds: BoundingBox = BoundingBox{ + .min = Vector3{ + .x = @as(f32, @floatFromInt(@as(c_int, 0))), + .y = 0, + .z = 0, + }, + .max = @import("std").mem.zeroes(Vector3), + }; + _ = &bounds; + if (model.meshCount > @as(c_int, 0)) { + var temp: Vector3 = Vector3{ + .x = @as(f32, @floatFromInt(@as(c_int, 0))), + .y = 0, + .z = 0, + }; + _ = &temp; + bounds = GetMeshBoundingBox(model.meshes[@as(c_uint, @intCast(@as(c_int, 0)))]); + { + var i: c_int = 1; + _ = &i; + while (i < model.meshCount) : (i += 1) { + var tempBounds: BoundingBox = GetMeshBoundingBox((blk: { + const tmp = i; + if (tmp >= 0) break :blk model.meshes + @as(usize, @intCast(tmp)) else break :blk model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*); + _ = &tempBounds; + temp.x = if (bounds.min.x < tempBounds.min.x) bounds.min.x else tempBounds.min.x; + temp.y = if (bounds.min.y < tempBounds.min.y) bounds.min.y else tempBounds.min.y; + temp.z = if (bounds.min.z < tempBounds.min.z) bounds.min.z else tempBounds.min.z; + bounds.min = temp; + temp.x = if (bounds.max.x > tempBounds.max.x) bounds.max.x else tempBounds.max.x; + temp.y = if (bounds.max.y > tempBounds.max.y) bounds.max.y else tempBounds.max.y; + temp.z = if (bounds.max.z > tempBounds.max.z) bounds.max.z else tempBounds.max.z; + bounds.max = temp; + } + } + } + bounds.min = Vector3Transform(bounds.min, model.transform); + bounds.max = Vector3Transform(bounds.max, model.transform); + return bounds; +} +pub export fn DrawModel(arg_model: Model, arg_position: Vector3, arg_scale: f32, arg_tint: Color) void { + var model = arg_model; + _ = &model; + var position = arg_position; + _ = &position; + var scale = arg_scale; + _ = &scale; + var tint = arg_tint; + _ = ∭ + var vScale: Vector3 = Vector3{ + .x = scale, + .y = scale, + .z = scale, + }; + _ = &vScale; + var rotationAxis: Vector3 = Vector3{ + .x = 0.0, + .y = 1.0, + .z = 0.0, + }; + _ = &rotationAxis; + DrawModelEx(model, position, rotationAxis, 0.0, vScale, tint); +} +pub export fn DrawModelEx(arg_model: Model, arg_position: Vector3, arg_rotationAxis: Vector3, arg_rotationAngle: f32, arg_scale: Vector3, arg_tint: Color) void { + var model = arg_model; + _ = &model; + var position = arg_position; + _ = &position; + var rotationAxis = arg_rotationAxis; + _ = &rotationAxis; + var rotationAngle = arg_rotationAngle; + _ = &rotationAngle; + var scale = arg_scale; + _ = &scale; + var tint = arg_tint; + _ = ∭ + var matScale: Matrix = MatrixScale(scale.x, scale.y, scale.z); + _ = &matScale; + var matRotation: Matrix = MatrixRotate(rotationAxis, rotationAngle * (3.1415927410125732 / 180.0)); + _ = &matRotation; + var matTranslation: Matrix = MatrixTranslate(position.x, position.y, position.z); + _ = &matTranslation; + var matTransform: Matrix = MatrixMultiply(MatrixMultiply(matScale, matRotation), matTranslation); + _ = &matTransform; + model.transform = MatrixMultiply(model.transform, matTransform); + { + var i: c_int = 0; + _ = &i; + while (i < model.meshCount) : (i += 1) { + var color: Color = (blk: { + const tmp = MATERIAL_MAP_ALBEDO; + if (tmp >= 0) break :blk (blk_1: { + const tmp_2 = (blk_2: { + const tmp_3 = i; + if (tmp_3 >= 0) break :blk_2 model.meshMaterial + @as(usize, @intCast(tmp_3)) else break :blk_2 model.meshMaterial - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_3)) +% -1)); + }).*; + if (tmp_2 >= 0) break :blk_1 model.materials + @as(usize, @intCast(tmp_2)) else break :blk_1 model.materials - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.maps + @as(usize, @intCast(tmp)) else break :blk (blk_1: { + const tmp_2 = (blk_2: { + const tmp_3 = i; + if (tmp_3 >= 0) break :blk_2 model.meshMaterial + @as(usize, @intCast(tmp_3)) else break :blk_2 model.meshMaterial - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_3)) +% -1)); + }).*; + if (tmp_2 >= 0) break :blk_1 model.materials + @as(usize, @intCast(tmp_2)) else break :blk_1 model.materials - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.maps - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.color; + _ = &color; + var colorTint: Color = Color{ + .r = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 255))))), + .g = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 255))))), + .b = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 255))))), + .a = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 255))))), + }; + _ = &colorTint; + colorTint.r = @as(u8, @bitCast(@as(i8, @truncate(@divTrunc(@as(c_int, @bitCast(@as(c_uint, color.r))) * @as(c_int, @bitCast(@as(c_uint, tint.r))), @as(c_int, 255)))))); + colorTint.g = @as(u8, @bitCast(@as(i8, @truncate(@divTrunc(@as(c_int, @bitCast(@as(c_uint, color.g))) * @as(c_int, @bitCast(@as(c_uint, tint.g))), @as(c_int, 255)))))); + colorTint.b = @as(u8, @bitCast(@as(i8, @truncate(@divTrunc(@as(c_int, @bitCast(@as(c_uint, color.b))) * @as(c_int, @bitCast(@as(c_uint, tint.b))), @as(c_int, 255)))))); + colorTint.a = @as(u8, @bitCast(@as(i8, @truncate(@divTrunc(@as(c_int, @bitCast(@as(c_uint, color.a))) * @as(c_int, @bitCast(@as(c_uint, tint.a))), @as(c_int, 255)))))); + (blk: { + const tmp = MATERIAL_MAP_ALBEDO; + if (tmp >= 0) break :blk (blk_1: { + const tmp_2 = (blk_2: { + const tmp_3 = i; + if (tmp_3 >= 0) break :blk_2 model.meshMaterial + @as(usize, @intCast(tmp_3)) else break :blk_2 model.meshMaterial - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_3)) +% -1)); + }).*; + if (tmp_2 >= 0) break :blk_1 model.materials + @as(usize, @intCast(tmp_2)) else break :blk_1 model.materials - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.maps + @as(usize, @intCast(tmp)) else break :blk (blk_1: { + const tmp_2 = (blk_2: { + const tmp_3 = i; + if (tmp_3 >= 0) break :blk_2 model.meshMaterial + @as(usize, @intCast(tmp_3)) else break :blk_2 model.meshMaterial - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_3)) +% -1)); + }).*; + if (tmp_2 >= 0) break :blk_1 model.materials + @as(usize, @intCast(tmp_2)) else break :blk_1 model.materials - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.maps - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.color = colorTint; + DrawMesh((blk: { + const tmp = i; + if (tmp >= 0) break :blk model.meshes + @as(usize, @intCast(tmp)) else break :blk model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*, (blk: { + const tmp = (blk_1: { + const tmp_2 = i; + if (tmp_2 >= 0) break :blk_1 model.meshMaterial + @as(usize, @intCast(tmp_2)) else break :blk_1 model.meshMaterial - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*; + if (tmp >= 0) break :blk model.materials + @as(usize, @intCast(tmp)) else break :blk model.materials - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*, model.transform); + (blk: { + const tmp = MATERIAL_MAP_ALBEDO; + if (tmp >= 0) break :blk (blk_1: { + const tmp_2 = (blk_2: { + const tmp_3 = i; + if (tmp_3 >= 0) break :blk_2 model.meshMaterial + @as(usize, @intCast(tmp_3)) else break :blk_2 model.meshMaterial - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_3)) +% -1)); + }).*; + if (tmp_2 >= 0) break :blk_1 model.materials + @as(usize, @intCast(tmp_2)) else break :blk_1 model.materials - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.maps + @as(usize, @intCast(tmp)) else break :blk (blk_1: { + const tmp_2 = (blk_2: { + const tmp_3 = i; + if (tmp_3 >= 0) break :blk_2 model.meshMaterial + @as(usize, @intCast(tmp_3)) else break :blk_2 model.meshMaterial - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_3)) +% -1)); + }).*; + if (tmp_2 >= 0) break :blk_1 model.materials + @as(usize, @intCast(tmp_2)) else break :blk_1 model.materials - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.maps - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.color = color; + } + } +} +pub export fn DrawModelWires(arg_model: Model, arg_position: Vector3, arg_scale: f32, arg_tint: Color) void { + var model = arg_model; + _ = &model; + var position = arg_position; + _ = &position; + var scale = arg_scale; + _ = &scale; + var tint = arg_tint; + _ = ∭ + rlEnableWireMode(); + DrawModel(model, position, scale, tint); + rlDisableWireMode(); +} +pub export fn DrawModelWiresEx(arg_model: Model, arg_position: Vector3, arg_rotationAxis: Vector3, arg_rotationAngle: f32, arg_scale: Vector3, arg_tint: Color) void { + var model = arg_model; + _ = &model; + var position = arg_position; + _ = &position; + var rotationAxis = arg_rotationAxis; + _ = &rotationAxis; + var rotationAngle = arg_rotationAngle; + _ = &rotationAngle; + var scale = arg_scale; + _ = &scale; + var tint = arg_tint; + _ = ∭ + rlEnableWireMode(); + DrawModelEx(model, position, rotationAxis, rotationAngle, scale, tint); + rlDisableWireMode(); +} +pub export fn DrawModelPoints(arg_model: Model, arg_position: Vector3, arg_scale: f32, arg_tint: Color) void { + var model = arg_model; + _ = &model; + var position = arg_position; + _ = &position; + var scale = arg_scale; + _ = &scale; + var tint = arg_tint; + _ = ∭ + rlEnablePointMode(); + rlDisableBackfaceCulling(); + DrawModel(model, position, scale, tint); + rlEnableBackfaceCulling(); + rlDisableWireMode(); +} +pub export fn DrawModelPointsEx(arg_model: Model, arg_position: Vector3, arg_rotationAxis: Vector3, arg_rotationAngle: f32, arg_scale: Vector3, arg_tint: Color) void { + var model = arg_model; + _ = &model; + var position = arg_position; + _ = &position; + var rotationAxis = arg_rotationAxis; + _ = &rotationAxis; + var rotationAngle = arg_rotationAngle; + _ = &rotationAngle; + var scale = arg_scale; + _ = &scale; + var tint = arg_tint; + _ = ∭ + rlEnablePointMode(); + rlDisableBackfaceCulling(); + DrawModelEx(model, position, rotationAxis, rotationAngle, scale, tint); + rlEnableBackfaceCulling(); + rlDisableWireMode(); +} +pub export fn DrawBoundingBox(arg_box: BoundingBox, arg_color: Color) void { + var box = arg_box; + _ = &box; + var color = arg_color; + _ = &color; + var size: Vector3 = Vector3{ + .x = @as(f32, @floatFromInt(@as(c_int, 0))), + .y = 0, + .z = 0, + }; + _ = &size; + size.x = fabsf(box.max.x - box.min.x); + size.y = fabsf(box.max.y - box.min.y); + size.z = fabsf(box.max.z - box.min.z); + var center: Vector3 = Vector3{ + .x = box.min.x + (size.x / 2.0), + .y = box.min.y + (size.y / 2.0), + .z = box.min.z + (size.z / 2.0), + }; + _ = ¢er; + DrawCubeWires(center, size.x, size.y, size.z, color); +} +pub export fn DrawBillboard(arg_camera: Camera, arg_texture: Texture2D, arg_position: Vector3, arg_scale: f32, arg_tint: Color) void { + var camera = arg_camera; + _ = &camera; + var texture = arg_texture; + _ = &texture; + var position = arg_position; + _ = &position; + var scale = arg_scale; + _ = &scale; + var tint = arg_tint; + _ = ∭ + var source: Rectangle = Rectangle{ + .x = 0.0, + .y = 0.0, + .width = @as(f32, @floatFromInt(texture.width)), + .height = @as(f32, @floatFromInt(texture.height)), + }; + _ = &source; + DrawBillboardRec(camera, texture, source, position, Vector2{ + .x = scale * fabsf(source.width / source.height), + .y = scale, + }, tint); +} +pub export fn DrawBillboardRec(arg_camera: Camera, arg_texture: Texture2D, arg_source: Rectangle, arg_position: Vector3, arg_size: Vector2, arg_tint: Color) void { + var camera = arg_camera; + _ = &camera; + var texture = arg_texture; + _ = &texture; + var source = arg_source; + _ = &source; + var position = arg_position; + _ = &position; + var size = arg_size; + _ = &size; + var tint = arg_tint; + _ = ∭ + var up: Vector3 = Vector3{ + .x = 0.0, + .y = 1.0, + .z = 0.0, + }; + _ = &up; + DrawBillboardPro(camera, texture, source, position, up, size, Vector2Scale(size, @as(f32, @floatCast(0.5))), 0.0, tint); +} +pub export fn DrawBillboardPro(arg_camera: Camera, arg_texture: Texture2D, arg_source: Rectangle, arg_position: Vector3, arg_up: Vector3, arg_size: Vector2, arg_origin: Vector2, arg_rotation: f32, arg_tint: Color) void { + var camera = arg_camera; + _ = &camera; + var texture = arg_texture; + _ = &texture; + var source = arg_source; + _ = &source; + var position = arg_position; + _ = &position; + var up = arg_up; + _ = &up; + var size = arg_size; + _ = &size; + var origin = arg_origin; + _ = &origin; + var rotation = arg_rotation; + _ = &rotation; + var tint = arg_tint; + _ = ∭ + var matView: Matrix = MatrixLookAt(camera.position, camera.target, camera.up); + _ = &matView; + var right: Vector3 = Vector3{ + .x = matView.m0, + .y = matView.m4, + .z = matView.m8, + }; + _ = &right; + right = Vector3Scale(right, size.x); + up = Vector3Scale(up, size.y); + if (size.x < 0.0) { + source.x += size.x; + source.width *= @as(f32, @floatCast(-1.0)); + right = Vector3Negate(right); + origin.x *= -1.0; + } + if (size.y < 0.0) { + source.y += size.y; + source.height *= @as(f32, @floatCast(-1.0)); + up = Vector3Negate(up); + origin.y *= -1.0; + } + var forward: Vector3 = undefined; + _ = &forward; + if (@as(f64, @floatCast(rotation)) != 0.0) { + forward = Vector3CrossProduct(right, up); + } + var origin3D: Vector3 = Vector3Add(Vector3Scale(Vector3Normalize(right), origin.x), Vector3Scale(Vector3Normalize(up), origin.y)); + _ = &origin3D; + var points: [4]Vector3 = undefined; + _ = &points; + points[@as(c_uint, @intCast(@as(c_int, 0)))] = Vector3Zero(); + points[@as(c_uint, @intCast(@as(c_int, 1)))] = right; + points[@as(c_uint, @intCast(@as(c_int, 2)))] = Vector3Add(up, right); + points[@as(c_uint, @intCast(@as(c_int, 3)))] = up; + { + var i: c_int = 0; + _ = &i; + while (i < @as(c_int, 4)) : (i += 1) { + points[@as(c_uint, @intCast(i))] = Vector3Subtract(points[@as(c_uint, @intCast(i))], origin3D); + if (@as(f64, @floatCast(rotation)) != 0.0) { + points[@as(c_uint, @intCast(i))] = Vector3RotateByAxisAngle(points[@as(c_uint, @intCast(i))], forward, rotation * (3.1415927410125732 / 180.0)); + } + points[@as(c_uint, @intCast(i))] = Vector3Add(points[@as(c_uint, @intCast(i))], position); + } + } + var texcoords: [4]Vector2 = undefined; + _ = &texcoords; + texcoords[@as(c_uint, @intCast(@as(c_int, 0)))] = Vector2{ + .x = source.x / @as(f32, @floatFromInt(texture.width)), + .y = (source.y + source.height) / @as(f32, @floatFromInt(texture.height)), + }; + texcoords[@as(c_uint, @intCast(@as(c_int, 1)))] = Vector2{ + .x = (source.x + source.width) / @as(f32, @floatFromInt(texture.width)), + .y = (source.y + source.height) / @as(f32, @floatFromInt(texture.height)), + }; + texcoords[@as(c_uint, @intCast(@as(c_int, 2)))] = Vector2{ + .x = (source.x + source.width) / @as(f32, @floatFromInt(texture.width)), + .y = source.y / @as(f32, @floatFromInt(texture.height)), + }; + texcoords[@as(c_uint, @intCast(@as(c_int, 3)))] = Vector2{ + .x = source.x / @as(f32, @floatFromInt(texture.width)), + .y = source.y / @as(f32, @floatFromInt(texture.height)), + }; + rlSetTexture(texture.id); + rlBegin(@as(c_int, 7)); + rlColor4ub(tint.r, tint.g, tint.b, tint.a); + { + var i: c_int = 0; + _ = &i; + while (i < @as(c_int, 4)) : (i += 1) { + rlTexCoord2f(texcoords[@as(c_uint, @intCast(i))].x, texcoords[@as(c_uint, @intCast(i))].y); + rlVertex3f(points[@as(c_uint, @intCast(i))].x, points[@as(c_uint, @intCast(i))].y, points[@as(c_uint, @intCast(i))].z); + } + } + rlEnd(); + rlSetTexture(@as(c_uint, @bitCast(@as(c_int, 0)))); +} +pub export fn UploadMesh(arg_mesh: [*c]Mesh, arg_dynamic: bool) void { + var mesh = arg_mesh; + _ = &mesh; + var dynamic = arg_dynamic; + _ = &dynamic; + if (mesh.*.vaoId > @as(c_uint, @bitCast(@as(c_int, 0)))) { + TraceLog(LOG_WARNING, "VAO: [ID %i] Trying to re-load an already loaded mesh", mesh.*.vaoId); + return; + } + mesh.*.vboId = @as([*c]c_uint, @ptrCast(@alignCast(calloc(@as(c_ulong, @bitCast(@as(c_long, @as(c_int, 7)))), @sizeOf(c_uint))))); + mesh.*.vaoId = 0; + mesh.*.vboId[@as(c_uint, @intCast(@as(c_int, 0)))] = 0; + mesh.*.vboId[@as(c_uint, @intCast(@as(c_int, 1)))] = 0; + mesh.*.vboId[@as(c_uint, @intCast(@as(c_int, 2)))] = 0; + mesh.*.vboId[@as(c_uint, @intCast(@as(c_int, 3)))] = 0; + mesh.*.vboId[@as(c_uint, @intCast(@as(c_int, 4)))] = 0; + mesh.*.vboId[@as(c_uint, @intCast(@as(c_int, 5)))] = 0; + mesh.*.vboId[@as(c_uint, @intCast(@as(c_int, 6)))] = 0; + mesh.*.vaoId = rlLoadVertexArray(); + _ = rlEnableVertexArray(mesh.*.vaoId); + var vertices: ?*anyopaque = @as(?*anyopaque, @ptrCast(if (mesh.*.animVertices != @as([*c]f32, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0))))))) mesh.*.animVertices else mesh.*.vertices)); + _ = &vertices; + mesh.*.vboId[@as(c_uint, @intCast(@as(c_int, 0)))] = rlLoadVertexBuffer(vertices, @as(c_int, @bitCast(@as(c_uint, @truncate(@as(c_ulong, @bitCast(@as(c_long, mesh.*.vertexCount * @as(c_int, 3)))) *% @sizeOf(f32))))), dynamic); + rlSetVertexAttribute(@as(c_uint, @bitCast(@as(c_int, 0))), @as(c_int, 3), @as(c_int, 5126), @as(c_int, 0) != 0, @as(c_int, 0), @as(c_int, 0)); + rlEnableVertexAttribute(@as(c_uint, @bitCast(@as(c_int, 0)))); + mesh.*.vboId[@as(c_uint, @intCast(@as(c_int, 1)))] = rlLoadVertexBuffer(@as(?*const anyopaque, @ptrCast(mesh.*.texcoords)), @as(c_int, @bitCast(@as(c_uint, @truncate(@as(c_ulong, @bitCast(@as(c_long, mesh.*.vertexCount * @as(c_int, 2)))) *% @sizeOf(f32))))), dynamic); + rlSetVertexAttribute(@as(c_uint, @bitCast(@as(c_int, 1))), @as(c_int, 2), @as(c_int, 5126), @as(c_int, 0) != 0, @as(c_int, 0), @as(c_int, 0)); + rlEnableVertexAttribute(@as(c_uint, @bitCast(@as(c_int, 1)))); + if (mesh.*.normals != @as([*c]f32, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0))))))) { + var normals: ?*anyopaque = @as(?*anyopaque, @ptrCast(if (mesh.*.animNormals != @as([*c]f32, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0))))))) mesh.*.animNormals else mesh.*.normals)); + _ = &normals; + mesh.*.vboId[@as(c_uint, @intCast(@as(c_int, 2)))] = rlLoadVertexBuffer(normals, @as(c_int, @bitCast(@as(c_uint, @truncate(@as(c_ulong, @bitCast(@as(c_long, mesh.*.vertexCount * @as(c_int, 3)))) *% @sizeOf(f32))))), dynamic); + rlSetVertexAttribute(@as(c_uint, @bitCast(@as(c_int, 2))), @as(c_int, 3), @as(c_int, 5126), @as(c_int, 0) != 0, @as(c_int, 0), @as(c_int, 0)); + rlEnableVertexAttribute(@as(c_uint, @bitCast(@as(c_int, 2)))); + } else { + var value: [3]f32 = [3]f32{ + 1.0, + 1.0, + 1.0, + }; + _ = &value; + rlSetVertexAttributeDefault(@as(c_int, 2), @as(?*const anyopaque, @ptrCast(@as([*c]f32, @ptrCast(@alignCast(&value))))), SHADER_ATTRIB_VEC3, @as(c_int, 3)); + rlDisableVertexAttribute(@as(c_uint, @bitCast(@as(c_int, 2)))); + } + if (mesh.*.colors != @as([*c]u8, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0))))))) { + mesh.*.vboId[@as(c_uint, @intCast(@as(c_int, 3)))] = rlLoadVertexBuffer(@as(?*const anyopaque, @ptrCast(mesh.*.colors)), @as(c_int, @bitCast(@as(c_uint, @truncate(@as(c_ulong, @bitCast(@as(c_long, mesh.*.vertexCount * @as(c_int, 4)))) *% @sizeOf(u8))))), dynamic); + rlSetVertexAttribute(@as(c_uint, @bitCast(@as(c_int, 3))), @as(c_int, 4), @as(c_int, 5121), @as(c_int, 1) != 0, @as(c_int, 0), @as(c_int, 0)); + rlEnableVertexAttribute(@as(c_uint, @bitCast(@as(c_int, 3)))); + } else { + var value: [4]f32 = [4]f32{ + 1.0, + 1.0, + 1.0, + 1.0, + }; + _ = &value; + rlSetVertexAttributeDefault(@as(c_int, 3), @as(?*const anyopaque, @ptrCast(@as([*c]f32, @ptrCast(@alignCast(&value))))), SHADER_ATTRIB_VEC4, @as(c_int, 4)); + rlDisableVertexAttribute(@as(c_uint, @bitCast(@as(c_int, 3)))); + } + if (mesh.*.tangents != @as([*c]f32, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0))))))) { + mesh.*.vboId[@as(c_uint, @intCast(@as(c_int, 4)))] = rlLoadVertexBuffer(@as(?*const anyopaque, @ptrCast(mesh.*.tangents)), @as(c_int, @bitCast(@as(c_uint, @truncate(@as(c_ulong, @bitCast(@as(c_long, mesh.*.vertexCount * @as(c_int, 4)))) *% @sizeOf(f32))))), dynamic); + rlSetVertexAttribute(@as(c_uint, @bitCast(@as(c_int, 4))), @as(c_int, 4), @as(c_int, 5126), @as(c_int, 0) != 0, @as(c_int, 0), @as(c_int, 0)); + rlEnableVertexAttribute(@as(c_uint, @bitCast(@as(c_int, 4)))); + } else { + var value: [4]f32 = [4]f32{ + 0.0, + 0.0, + 0.0, + 0.0, + }; + _ = &value; + rlSetVertexAttributeDefault(@as(c_int, 4), @as(?*const anyopaque, @ptrCast(@as([*c]f32, @ptrCast(@alignCast(&value))))), SHADER_ATTRIB_VEC4, @as(c_int, 4)); + rlDisableVertexAttribute(@as(c_uint, @bitCast(@as(c_int, 4)))); + } + if (mesh.*.texcoords2 != @as([*c]f32, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0))))))) { + mesh.*.vboId[@as(c_uint, @intCast(@as(c_int, 5)))] = rlLoadVertexBuffer(@as(?*const anyopaque, @ptrCast(mesh.*.texcoords2)), @as(c_int, @bitCast(@as(c_uint, @truncate(@as(c_ulong, @bitCast(@as(c_long, mesh.*.vertexCount * @as(c_int, 2)))) *% @sizeOf(f32))))), dynamic); + rlSetVertexAttribute(@as(c_uint, @bitCast(@as(c_int, 5))), @as(c_int, 2), @as(c_int, 5126), @as(c_int, 0) != 0, @as(c_int, 0), @as(c_int, 0)); + rlEnableVertexAttribute(@as(c_uint, @bitCast(@as(c_int, 5)))); + } else { + var value: [2]f32 = [2]f32{ + 0.0, + 0.0, + }; + _ = &value; + rlSetVertexAttributeDefault(@as(c_int, 5), @as(?*const anyopaque, @ptrCast(@as([*c]f32, @ptrCast(@alignCast(&value))))), SHADER_ATTRIB_VEC2, @as(c_int, 2)); + rlDisableVertexAttribute(@as(c_uint, @bitCast(@as(c_int, 5)))); + } + if (mesh.*.indices != @as([*c]c_ushort, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0))))))) { + mesh.*.vboId[@as(c_uint, @intCast(@as(c_int, 6)))] = rlLoadVertexBufferElement(@as(?*const anyopaque, @ptrCast(mesh.*.indices)), @as(c_int, @bitCast(@as(c_uint, @truncate(@as(c_ulong, @bitCast(@as(c_long, mesh.*.triangleCount * @as(c_int, 3)))) *% @sizeOf(c_ushort))))), dynamic); + } + if (mesh.*.vaoId > @as(c_uint, @bitCast(@as(c_int, 0)))) { + TraceLog(LOG_INFO, "VAO: [ID %i] Mesh uploaded successfully to VRAM (GPU)", mesh.*.vaoId); + } else { + TraceLog(LOG_INFO, "VBO: Mesh uploaded successfully to VRAM (GPU)"); + } + rlDisableVertexArray(); +} +pub export fn UpdateMeshBuffer(arg_mesh: Mesh, arg_index_1: c_int, arg_data: ?*const anyopaque, arg_dataSize: c_int, arg_offset: c_int) void { + var mesh = arg_mesh; + _ = &mesh; + var index_1 = arg_index_1; + _ = &index_1; + var data = arg_data; + _ = &data; + var dataSize = arg_dataSize; + _ = &dataSize; + var offset = arg_offset; + _ = &offset; + rlUpdateVertexBuffer((blk: { + const tmp = index_1; + if (tmp >= 0) break :blk mesh.vboId + @as(usize, @intCast(tmp)) else break :blk mesh.vboId - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*, data, dataSize, offset); +} +pub export fn UnloadMesh(arg_mesh: Mesh) void { + var mesh = arg_mesh; + _ = &mesh; + rlUnloadVertexArray(mesh.vaoId); + if (mesh.vboId != @as([*c]c_uint, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0))))))) { + var i: c_int = 0; + _ = &i; + while (i < @as(c_int, 7)) : (i += 1) { + rlUnloadVertexBuffer((blk: { + const tmp = i; + if (tmp >= 0) break :blk mesh.vboId + @as(usize, @intCast(tmp)) else break :blk mesh.vboId - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*); + } + } + free(@as(?*anyopaque, @ptrCast(mesh.vboId))); + free(@as(?*anyopaque, @ptrCast(mesh.vertices))); + free(@as(?*anyopaque, @ptrCast(mesh.texcoords))); + free(@as(?*anyopaque, @ptrCast(mesh.normals))); + free(@as(?*anyopaque, @ptrCast(mesh.colors))); + free(@as(?*anyopaque, @ptrCast(mesh.tangents))); + free(@as(?*anyopaque, @ptrCast(mesh.texcoords2))); + free(@as(?*anyopaque, @ptrCast(mesh.indices))); + free(@as(?*anyopaque, @ptrCast(mesh.animVertices))); + free(@as(?*anyopaque, @ptrCast(mesh.animNormals))); + free(@as(?*anyopaque, @ptrCast(mesh.boneWeights))); + free(@as(?*anyopaque, @ptrCast(mesh.boneIds))); +} +pub export fn DrawMesh(arg_mesh: Mesh, arg_material: Material, arg_transform: Matrix) void { + var mesh = arg_mesh; + _ = &mesh; + var material = arg_material; + _ = &material; + var transform = arg_transform; + _ = &transform; + rlEnableShader(material.shader.id); + if ((blk: { + const tmp = SHADER_LOC_COLOR_DIFFUSE; + if (tmp >= 0) break :blk material.shader.locs + @as(usize, @intCast(tmp)) else break :blk material.shader.locs - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* != -@as(c_int, 1)) { + var values: [4]f32 = [4]f32{ + @as(f32, @floatFromInt((blk: { + const tmp = MATERIAL_MAP_ALBEDO; + if (tmp >= 0) break :blk material.maps + @as(usize, @intCast(tmp)) else break :blk material.maps - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.color.r)) / 255.0, + @as(f32, @floatFromInt((blk: { + const tmp = MATERIAL_MAP_ALBEDO; + if (tmp >= 0) break :blk material.maps + @as(usize, @intCast(tmp)) else break :blk material.maps - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.color.g)) / 255.0, + @as(f32, @floatFromInt((blk: { + const tmp = MATERIAL_MAP_ALBEDO; + if (tmp >= 0) break :blk material.maps + @as(usize, @intCast(tmp)) else break :blk material.maps - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.color.b)) / 255.0, + @as(f32, @floatFromInt((blk: { + const tmp = MATERIAL_MAP_ALBEDO; + if (tmp >= 0) break :blk material.maps + @as(usize, @intCast(tmp)) else break :blk material.maps - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.color.a)) / 255.0, + }; + _ = &values; + rlSetUniform((blk: { + const tmp = SHADER_LOC_COLOR_DIFFUSE; + if (tmp >= 0) break :blk material.shader.locs + @as(usize, @intCast(tmp)) else break :blk material.shader.locs - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*, @as(?*const anyopaque, @ptrCast(@as([*c]f32, @ptrCast(@alignCast(&values))))), SHADER_UNIFORM_VEC4, @as(c_int, 1)); + } + if ((blk: { + const tmp = SHADER_LOC_COLOR_SPECULAR; + if (tmp >= 0) break :blk material.shader.locs + @as(usize, @intCast(tmp)) else break :blk material.shader.locs - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* != -@as(c_int, 1)) { + var values: [4]f32 = [4]f32{ + @as(f32, @floatFromInt((blk: { + const tmp = MATERIAL_MAP_METALNESS; + if (tmp >= 0) break :blk material.maps + @as(usize, @intCast(tmp)) else break :blk material.maps - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.color.r)) / 255.0, + @as(f32, @floatFromInt((blk: { + const tmp = MATERIAL_MAP_METALNESS; + if (tmp >= 0) break :blk material.maps + @as(usize, @intCast(tmp)) else break :blk material.maps - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.color.g)) / 255.0, + @as(f32, @floatFromInt((blk: { + const tmp = MATERIAL_MAP_METALNESS; + if (tmp >= 0) break :blk material.maps + @as(usize, @intCast(tmp)) else break :blk material.maps - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.color.b)) / 255.0, + @as(f32, @floatFromInt((blk: { + const tmp = MATERIAL_MAP_METALNESS; + if (tmp >= 0) break :blk material.maps + @as(usize, @intCast(tmp)) else break :blk material.maps - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.color.a)) / 255.0, + }; + _ = &values; + rlSetUniform((blk: { + const tmp = SHADER_LOC_COLOR_SPECULAR; + if (tmp >= 0) break :blk material.shader.locs + @as(usize, @intCast(tmp)) else break :blk material.shader.locs - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*, @as(?*const anyopaque, @ptrCast(@as([*c]f32, @ptrCast(@alignCast(&values))))), SHADER_UNIFORM_VEC4, @as(c_int, 1)); + } + var matModel: Matrix = MatrixIdentity(); + _ = &matModel; + var matView: Matrix = rlGetMatrixModelview(); + _ = &matView; + var matModelView: Matrix = MatrixIdentity(); + _ = &matModelView; + var matProjection: Matrix = rlGetMatrixProjection(); + _ = &matProjection; + if ((blk: { + const tmp = SHADER_LOC_MATRIX_VIEW; + if (tmp >= 0) break :blk material.shader.locs + @as(usize, @intCast(tmp)) else break :blk material.shader.locs - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* != -@as(c_int, 1)) { + rlSetUniformMatrix((blk: { + const tmp = SHADER_LOC_MATRIX_VIEW; + if (tmp >= 0) break :blk material.shader.locs + @as(usize, @intCast(tmp)) else break :blk material.shader.locs - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*, matView); + } + if ((blk: { + const tmp = SHADER_LOC_MATRIX_PROJECTION; + if (tmp >= 0) break :blk material.shader.locs + @as(usize, @intCast(tmp)) else break :blk material.shader.locs - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* != -@as(c_int, 1)) { + rlSetUniformMatrix((blk: { + const tmp = SHADER_LOC_MATRIX_PROJECTION; + if (tmp >= 0) break :blk material.shader.locs + @as(usize, @intCast(tmp)) else break :blk material.shader.locs - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*, matProjection); + } + matModel = MatrixMultiply(transform, rlGetMatrixTransform()); + if ((blk: { + const tmp = SHADER_LOC_MATRIX_MODEL; + if (tmp >= 0) break :blk material.shader.locs + @as(usize, @intCast(tmp)) else break :blk material.shader.locs - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* != -@as(c_int, 1)) { + rlSetUniformMatrix((blk: { + const tmp = SHADER_LOC_MATRIX_MODEL; + if (tmp >= 0) break :blk material.shader.locs + @as(usize, @intCast(tmp)) else break :blk material.shader.locs - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*, matModel); + } + matModelView = MatrixMultiply(matModel, matView); + if ((blk: { + const tmp = SHADER_LOC_MATRIX_NORMAL; + if (tmp >= 0) break :blk material.shader.locs + @as(usize, @intCast(tmp)) else break :blk material.shader.locs - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* != -@as(c_int, 1)) { + rlSetUniformMatrix((blk: { + const tmp = SHADER_LOC_MATRIX_NORMAL; + if (tmp >= 0) break :blk material.shader.locs + @as(usize, @intCast(tmp)) else break :blk material.shader.locs - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*, MatrixTranspose(MatrixInvert(matModel))); + } + { + var i: c_int = 0; + _ = &i; + while (i < @as(c_int, 12)) : (i += 1) { + if ((blk: { + const tmp = i; + if (tmp >= 0) break :blk material.maps + @as(usize, @intCast(tmp)) else break :blk material.maps - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.texture.id > @as(c_uint, @bitCast(@as(c_int, 0)))) { + rlActiveTextureSlot(i); + if (((i == MATERIAL_MAP_IRRADIANCE) or (i == MATERIAL_MAP_PREFILTER)) or (i == MATERIAL_MAP_CUBEMAP)) { + rlEnableTextureCubemap((blk: { + const tmp = i; + if (tmp >= 0) break :blk material.maps + @as(usize, @intCast(tmp)) else break :blk material.maps - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.texture.id); + } else { + rlEnableTexture((blk: { + const tmp = i; + if (tmp >= 0) break :blk material.maps + @as(usize, @intCast(tmp)) else break :blk material.maps - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.texture.id); + } + rlSetUniform((blk: { + const tmp = SHADER_LOC_MAP_ALBEDO + i; + if (tmp >= 0) break :blk material.shader.locs + @as(usize, @intCast(tmp)) else break :blk material.shader.locs - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*, @as(?*const anyopaque, @ptrCast(&i)), SHADER_UNIFORM_INT, @as(c_int, 1)); + } + } + } + if (!rlEnableVertexArray(mesh.vaoId)) { + rlEnableVertexBuffer(mesh.vboId[@as(c_uint, @intCast(@as(c_int, 0)))]); + rlSetVertexAttribute(@as(c_uint, @bitCast((blk: { + const tmp = SHADER_LOC_VERTEX_POSITION; + if (tmp >= 0) break :blk material.shader.locs + @as(usize, @intCast(tmp)) else break :blk material.shader.locs - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*)), @as(c_int, 3), @as(c_int, 5126), @as(c_int, 0) != 0, @as(c_int, 0), @as(c_int, 0)); + rlEnableVertexAttribute(@as(c_uint, @bitCast((blk: { + const tmp = SHADER_LOC_VERTEX_POSITION; + if (tmp >= 0) break :blk material.shader.locs + @as(usize, @intCast(tmp)) else break :blk material.shader.locs - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*))); + rlEnableVertexBuffer(mesh.vboId[@as(c_uint, @intCast(@as(c_int, 1)))]); + rlSetVertexAttribute(@as(c_uint, @bitCast((blk: { + const tmp = SHADER_LOC_VERTEX_TEXCOORD01; + if (tmp >= 0) break :blk material.shader.locs + @as(usize, @intCast(tmp)) else break :blk material.shader.locs - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*)), @as(c_int, 2), @as(c_int, 5126), @as(c_int, 0) != 0, @as(c_int, 0), @as(c_int, 0)); + rlEnableVertexAttribute(@as(c_uint, @bitCast((blk: { + const tmp = SHADER_LOC_VERTEX_TEXCOORD01; + if (tmp >= 0) break :blk material.shader.locs + @as(usize, @intCast(tmp)) else break :blk material.shader.locs - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*))); + if ((blk: { + const tmp = SHADER_LOC_VERTEX_NORMAL; + if (tmp >= 0) break :blk material.shader.locs + @as(usize, @intCast(tmp)) else break :blk material.shader.locs - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* != -@as(c_int, 1)) { + rlEnableVertexBuffer(mesh.vboId[@as(c_uint, @intCast(@as(c_int, 2)))]); + rlSetVertexAttribute(@as(c_uint, @bitCast((blk: { + const tmp = SHADER_LOC_VERTEX_NORMAL; + if (tmp >= 0) break :blk material.shader.locs + @as(usize, @intCast(tmp)) else break :blk material.shader.locs - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*)), @as(c_int, 3), @as(c_int, 5126), @as(c_int, 0) != 0, @as(c_int, 0), @as(c_int, 0)); + rlEnableVertexAttribute(@as(c_uint, @bitCast((blk: { + const tmp = SHADER_LOC_VERTEX_NORMAL; + if (tmp >= 0) break :blk material.shader.locs + @as(usize, @intCast(tmp)) else break :blk material.shader.locs - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*))); + } + if ((blk: { + const tmp = SHADER_LOC_VERTEX_COLOR; + if (tmp >= 0) break :blk material.shader.locs + @as(usize, @intCast(tmp)) else break :blk material.shader.locs - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* != -@as(c_int, 1)) { + if (mesh.vboId[@as(c_uint, @intCast(@as(c_int, 3)))] != @as(c_uint, @bitCast(@as(c_int, 0)))) { + rlEnableVertexBuffer(mesh.vboId[@as(c_uint, @intCast(@as(c_int, 3)))]); + rlSetVertexAttribute(@as(c_uint, @bitCast((blk: { + const tmp = SHADER_LOC_VERTEX_COLOR; + if (tmp >= 0) break :blk material.shader.locs + @as(usize, @intCast(tmp)) else break :blk material.shader.locs - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*)), @as(c_int, 4), @as(c_int, 5121), @as(c_int, 1) != 0, @as(c_int, 0), @as(c_int, 0)); + rlEnableVertexAttribute(@as(c_uint, @bitCast((blk: { + const tmp = SHADER_LOC_VERTEX_COLOR; + if (tmp >= 0) break :blk material.shader.locs + @as(usize, @intCast(tmp)) else break :blk material.shader.locs - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*))); + } else { + var value: [4]f32 = [4]f32{ + 1.0, + 1.0, + 1.0, + 1.0, + }; + _ = &value; + rlSetVertexAttributeDefault((blk: { + const tmp = SHADER_LOC_VERTEX_COLOR; + if (tmp >= 0) break :blk material.shader.locs + @as(usize, @intCast(tmp)) else break :blk material.shader.locs - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*, @as(?*const anyopaque, @ptrCast(@as([*c]f32, @ptrCast(@alignCast(&value))))), SHADER_ATTRIB_VEC4, @as(c_int, 4)); + rlDisableVertexAttribute(@as(c_uint, @bitCast((blk: { + const tmp = SHADER_LOC_VERTEX_COLOR; + if (tmp >= 0) break :blk material.shader.locs + @as(usize, @intCast(tmp)) else break :blk material.shader.locs - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*))); + } + } + if ((blk: { + const tmp = SHADER_LOC_VERTEX_TANGENT; + if (tmp >= 0) break :blk material.shader.locs + @as(usize, @intCast(tmp)) else break :blk material.shader.locs - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* != -@as(c_int, 1)) { + rlEnableVertexBuffer(mesh.vboId[@as(c_uint, @intCast(@as(c_int, 4)))]); + rlSetVertexAttribute(@as(c_uint, @bitCast((blk: { + const tmp = SHADER_LOC_VERTEX_TANGENT; + if (tmp >= 0) break :blk material.shader.locs + @as(usize, @intCast(tmp)) else break :blk material.shader.locs - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*)), @as(c_int, 4), @as(c_int, 5126), @as(c_int, 0) != 0, @as(c_int, 0), @as(c_int, 0)); + rlEnableVertexAttribute(@as(c_uint, @bitCast((blk: { + const tmp = SHADER_LOC_VERTEX_TANGENT; + if (tmp >= 0) break :blk material.shader.locs + @as(usize, @intCast(tmp)) else break :blk material.shader.locs - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*))); + } + if ((blk: { + const tmp = SHADER_LOC_VERTEX_TEXCOORD02; + if (tmp >= 0) break :blk material.shader.locs + @as(usize, @intCast(tmp)) else break :blk material.shader.locs - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* != -@as(c_int, 1)) { + rlEnableVertexBuffer(mesh.vboId[@as(c_uint, @intCast(@as(c_int, 5)))]); + rlSetVertexAttribute(@as(c_uint, @bitCast((blk: { + const tmp = SHADER_LOC_VERTEX_TEXCOORD02; + if (tmp >= 0) break :blk material.shader.locs + @as(usize, @intCast(tmp)) else break :blk material.shader.locs - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*)), @as(c_int, 2), @as(c_int, 5126), @as(c_int, 0) != 0, @as(c_int, 0), @as(c_int, 0)); + rlEnableVertexAttribute(@as(c_uint, @bitCast((blk: { + const tmp = SHADER_LOC_VERTEX_TEXCOORD02; + if (tmp >= 0) break :blk material.shader.locs + @as(usize, @intCast(tmp)) else break :blk material.shader.locs - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*))); + } + if (mesh.indices != @as([*c]c_ushort, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0))))))) { + rlEnableVertexBufferElement(mesh.vboId[@as(c_uint, @intCast(@as(c_int, 6)))]); + } + } + var eyeCount: c_int = 1; + _ = &eyeCount; + if (rlIsStereoRenderEnabled()) { + eyeCount = 2; + } + { + var eye: c_int = 0; + _ = &eye; + while (eye < eyeCount) : (eye += 1) { + var matModelViewProjection: Matrix = MatrixIdentity(); + _ = &matModelViewProjection; + if (eyeCount == @as(c_int, 1)) { + matModelViewProjection = MatrixMultiply(matModelView, matProjection); + } else { + rlViewport(@divTrunc(eye * rlGetFramebufferWidth(), @as(c_int, 2)), @as(c_int, 0), @divTrunc(rlGetFramebufferWidth(), @as(c_int, 2)), rlGetFramebufferHeight()); + matModelViewProjection = MatrixMultiply(MatrixMultiply(matModelView, rlGetMatrixViewOffsetStereo(eye)), rlGetMatrixProjectionStereo(eye)); + } + rlSetUniformMatrix((blk: { + const tmp = SHADER_LOC_MATRIX_MVP; + if (tmp >= 0) break :blk material.shader.locs + @as(usize, @intCast(tmp)) else break :blk material.shader.locs - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*, matModelViewProjection); + if (mesh.indices != @as([*c]c_ushort, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0))))))) { + rlDrawVertexArrayElements(@as(c_int, 0), mesh.triangleCount * @as(c_int, 3), null); + } else { + rlDrawVertexArray(@as(c_int, 0), mesh.vertexCount); + } + } + } + { + var i: c_int = 0; + _ = &i; + while (i < @as(c_int, 12)) : (i += 1) { + if ((blk: { + const tmp = i; + if (tmp >= 0) break :blk material.maps + @as(usize, @intCast(tmp)) else break :blk material.maps - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.texture.id > @as(c_uint, @bitCast(@as(c_int, 0)))) { + rlActiveTextureSlot(i); + if (((i == MATERIAL_MAP_IRRADIANCE) or (i == MATERIAL_MAP_PREFILTER)) or (i == MATERIAL_MAP_CUBEMAP)) { + rlDisableTextureCubemap(); + } else { + rlDisableTexture(); + } + } + } + } + rlDisableVertexArray(); + rlDisableVertexBuffer(); + rlDisableVertexBufferElement(); + rlDisableShader(); + rlSetMatrixModelview(matView); + rlSetMatrixProjection(matProjection); +} +pub const struct_float16 = extern struct { + v: [16]f32 = @import("std").mem.zeroes([16]f32), +}; +pub const float16 = struct_float16; +pub export fn DrawMeshInstanced(arg_mesh: Mesh, arg_material: Material, arg_transforms: [*c]const Matrix, arg_instances: c_int) void { + var mesh = arg_mesh; + _ = &mesh; + var material = arg_material; + _ = &material; + var transforms = arg_transforms; + _ = &transforms; + var instances = arg_instances; + _ = &instances; + var instanceTransforms: [*c]float16 = null; + _ = &instanceTransforms; + var instancesVboId: c_uint = 0; + _ = &instancesVboId; + rlEnableShader(material.shader.id); + if ((blk: { + const tmp = SHADER_LOC_COLOR_DIFFUSE; + if (tmp >= 0) break :blk material.shader.locs + @as(usize, @intCast(tmp)) else break :blk material.shader.locs - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* != -@as(c_int, 1)) { + var values: [4]f32 = [4]f32{ + @as(f32, @floatFromInt((blk: { + const tmp = MATERIAL_MAP_ALBEDO; + if (tmp >= 0) break :blk material.maps + @as(usize, @intCast(tmp)) else break :blk material.maps - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.color.r)) / 255.0, + @as(f32, @floatFromInt((blk: { + const tmp = MATERIAL_MAP_ALBEDO; + if (tmp >= 0) break :blk material.maps + @as(usize, @intCast(tmp)) else break :blk material.maps - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.color.g)) / 255.0, + @as(f32, @floatFromInt((blk: { + const tmp = MATERIAL_MAP_ALBEDO; + if (tmp >= 0) break :blk material.maps + @as(usize, @intCast(tmp)) else break :blk material.maps - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.color.b)) / 255.0, + @as(f32, @floatFromInt((blk: { + const tmp = MATERIAL_MAP_ALBEDO; + if (tmp >= 0) break :blk material.maps + @as(usize, @intCast(tmp)) else break :blk material.maps - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.color.a)) / 255.0, + }; + _ = &values; + rlSetUniform((blk: { + const tmp = SHADER_LOC_COLOR_DIFFUSE; + if (tmp >= 0) break :blk material.shader.locs + @as(usize, @intCast(tmp)) else break :blk material.shader.locs - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*, @as(?*const anyopaque, @ptrCast(@as([*c]f32, @ptrCast(@alignCast(&values))))), SHADER_UNIFORM_VEC4, @as(c_int, 1)); + } + if ((blk: { + const tmp = SHADER_LOC_COLOR_SPECULAR; + if (tmp >= 0) break :blk material.shader.locs + @as(usize, @intCast(tmp)) else break :blk material.shader.locs - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* != -@as(c_int, 1)) { + var values: [4]f32 = [4]f32{ + @as(f32, @floatFromInt((blk: { + const tmp = SHADER_LOC_COLOR_SPECULAR; + if (tmp >= 0) break :blk material.maps + @as(usize, @intCast(tmp)) else break :blk material.maps - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.color.r)) / 255.0, + @as(f32, @floatFromInt((blk: { + const tmp = SHADER_LOC_COLOR_SPECULAR; + if (tmp >= 0) break :blk material.maps + @as(usize, @intCast(tmp)) else break :blk material.maps - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.color.g)) / 255.0, + @as(f32, @floatFromInt((blk: { + const tmp = SHADER_LOC_COLOR_SPECULAR; + if (tmp >= 0) break :blk material.maps + @as(usize, @intCast(tmp)) else break :blk material.maps - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.color.b)) / 255.0, + @as(f32, @floatFromInt((blk: { + const tmp = SHADER_LOC_COLOR_SPECULAR; + if (tmp >= 0) break :blk material.maps + @as(usize, @intCast(tmp)) else break :blk material.maps - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.color.a)) / 255.0, + }; + _ = &values; + rlSetUniform((blk: { + const tmp = SHADER_LOC_COLOR_SPECULAR; + if (tmp >= 0) break :blk material.shader.locs + @as(usize, @intCast(tmp)) else break :blk material.shader.locs - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*, @as(?*const anyopaque, @ptrCast(@as([*c]f32, @ptrCast(@alignCast(&values))))), SHADER_UNIFORM_VEC4, @as(c_int, 1)); + } + var matModel: Matrix = MatrixIdentity(); + _ = &matModel; + var matView: Matrix = rlGetMatrixModelview(); + _ = &matView; + var matModelView: Matrix = MatrixIdentity(); + _ = &matModelView; + var matProjection: Matrix = rlGetMatrixProjection(); + _ = &matProjection; + if ((blk: { + const tmp = SHADER_LOC_MATRIX_VIEW; + if (tmp >= 0) break :blk material.shader.locs + @as(usize, @intCast(tmp)) else break :blk material.shader.locs - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* != -@as(c_int, 1)) { + rlSetUniformMatrix((blk: { + const tmp = SHADER_LOC_MATRIX_VIEW; + if (tmp >= 0) break :blk material.shader.locs + @as(usize, @intCast(tmp)) else break :blk material.shader.locs - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*, matView); + } + if ((blk: { + const tmp = SHADER_LOC_MATRIX_PROJECTION; + if (tmp >= 0) break :blk material.shader.locs + @as(usize, @intCast(tmp)) else break :blk material.shader.locs - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* != -@as(c_int, 1)) { + rlSetUniformMatrix((blk: { + const tmp = SHADER_LOC_MATRIX_PROJECTION; + if (tmp >= 0) break :blk material.shader.locs + @as(usize, @intCast(tmp)) else break :blk material.shader.locs - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*, matProjection); + } + instanceTransforms = @as([*c]float16, @ptrCast(@alignCast(malloc(@as(c_ulong, @bitCast(@as(c_long, instances))) *% @sizeOf(float16))))); + { + var i: c_int = 0; + _ = &i; + while (i < instances) : (i += 1) { + (blk: { + const tmp = i; + if (tmp >= 0) break :blk instanceTransforms + @as(usize, @intCast(tmp)) else break :blk instanceTransforms - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = MatrixToFloatV((blk: { + const tmp = i; + if (tmp >= 0) break :blk transforms + @as(usize, @intCast(tmp)) else break :blk transforms - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*); + } + } + _ = rlEnableVertexArray(mesh.vaoId); + instancesVboId = rlLoadVertexBuffer(@as(?*const anyopaque, @ptrCast(instanceTransforms)), @as(c_int, @bitCast(@as(c_uint, @truncate(@as(c_ulong, @bitCast(@as(c_long, instances))) *% @sizeOf(float16))))), @as(c_int, 0) != 0); + { + var i: c_uint = 0; + _ = &i; + while (i < @as(c_uint, @bitCast(@as(c_int, 4)))) : (i +%= 1) { + rlEnableVertexAttribute(@as(c_uint, @bitCast((blk: { + const tmp = SHADER_LOC_MATRIX_MODEL; + if (tmp >= 0) break :blk material.shader.locs + @as(usize, @intCast(tmp)) else break :blk material.shader.locs - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*)) +% i); + rlSetVertexAttribute(@as(c_uint, @bitCast((blk: { + const tmp = SHADER_LOC_MATRIX_MODEL; + if (tmp >= 0) break :blk material.shader.locs + @as(usize, @intCast(tmp)) else break :blk material.shader.locs - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*)) +% i, @as(c_int, 4), @as(c_int, 5126), @as(c_int, 0) != 0, @as(c_int, @bitCast(@as(c_uint, @truncate(@sizeOf(Matrix))))), @as(c_int, @bitCast(@as(c_uint, @truncate(@as(c_ulong, @bitCast(@as(c_ulong, i))) *% @sizeOf(Vector4)))))); + rlSetVertexAttributeDivisor(@as(c_uint, @bitCast((blk: { + const tmp = SHADER_LOC_MATRIX_MODEL; + if (tmp >= 0) break :blk material.shader.locs + @as(usize, @intCast(tmp)) else break :blk material.shader.locs - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*)) +% i, @as(c_int, 1)); + } + } + rlDisableVertexBuffer(); + rlDisableVertexArray(); + matModelView = MatrixMultiply(rlGetMatrixTransform(), matView); + if ((blk: { + const tmp = SHADER_LOC_MATRIX_NORMAL; + if (tmp >= 0) break :blk material.shader.locs + @as(usize, @intCast(tmp)) else break :blk material.shader.locs - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* != -@as(c_int, 1)) { + rlSetUniformMatrix((blk: { + const tmp = SHADER_LOC_MATRIX_NORMAL; + if (tmp >= 0) break :blk material.shader.locs + @as(usize, @intCast(tmp)) else break :blk material.shader.locs - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*, MatrixTranspose(MatrixInvert(matModel))); + } + { + var i: c_int = 0; + _ = &i; + while (i < @as(c_int, 12)) : (i += 1) { + if ((blk: { + const tmp = i; + if (tmp >= 0) break :blk material.maps + @as(usize, @intCast(tmp)) else break :blk material.maps - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.texture.id > @as(c_uint, @bitCast(@as(c_int, 0)))) { + rlActiveTextureSlot(i); + if (((i == MATERIAL_MAP_IRRADIANCE) or (i == MATERIAL_MAP_PREFILTER)) or (i == MATERIAL_MAP_CUBEMAP)) { + rlEnableTextureCubemap((blk: { + const tmp = i; + if (tmp >= 0) break :blk material.maps + @as(usize, @intCast(tmp)) else break :blk material.maps - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.texture.id); + } else { + rlEnableTexture((blk: { + const tmp = i; + if (tmp >= 0) break :blk material.maps + @as(usize, @intCast(tmp)) else break :blk material.maps - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.texture.id); + } + rlSetUniform((blk: { + const tmp = SHADER_LOC_MAP_ALBEDO + i; + if (tmp >= 0) break :blk material.shader.locs + @as(usize, @intCast(tmp)) else break :blk material.shader.locs - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*, @as(?*const anyopaque, @ptrCast(&i)), SHADER_UNIFORM_INT, @as(c_int, 1)); + } + } + } + if (!rlEnableVertexArray(mesh.vaoId)) { + rlEnableVertexBuffer(mesh.vboId[@as(c_uint, @intCast(@as(c_int, 0)))]); + rlSetVertexAttribute(@as(c_uint, @bitCast((blk: { + const tmp = SHADER_LOC_VERTEX_POSITION; + if (tmp >= 0) break :blk material.shader.locs + @as(usize, @intCast(tmp)) else break :blk material.shader.locs - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*)), @as(c_int, 3), @as(c_int, 5126), @as(c_int, 0) != 0, @as(c_int, 0), @as(c_int, 0)); + rlEnableVertexAttribute(@as(c_uint, @bitCast((blk: { + const tmp = SHADER_LOC_VERTEX_POSITION; + if (tmp >= 0) break :blk material.shader.locs + @as(usize, @intCast(tmp)) else break :blk material.shader.locs - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*))); + rlEnableVertexBuffer(mesh.vboId[@as(c_uint, @intCast(@as(c_int, 1)))]); + rlSetVertexAttribute(@as(c_uint, @bitCast((blk: { + const tmp = SHADER_LOC_VERTEX_TEXCOORD01; + if (tmp >= 0) break :blk material.shader.locs + @as(usize, @intCast(tmp)) else break :blk material.shader.locs - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*)), @as(c_int, 2), @as(c_int, 5126), @as(c_int, 0) != 0, @as(c_int, 0), @as(c_int, 0)); + rlEnableVertexAttribute(@as(c_uint, @bitCast((blk: { + const tmp = SHADER_LOC_VERTEX_TEXCOORD01; + if (tmp >= 0) break :blk material.shader.locs + @as(usize, @intCast(tmp)) else break :blk material.shader.locs - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*))); + if ((blk: { + const tmp = SHADER_LOC_VERTEX_NORMAL; + if (tmp >= 0) break :blk material.shader.locs + @as(usize, @intCast(tmp)) else break :blk material.shader.locs - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* != -@as(c_int, 1)) { + rlEnableVertexBuffer(mesh.vboId[@as(c_uint, @intCast(@as(c_int, 2)))]); + rlSetVertexAttribute(@as(c_uint, @bitCast((blk: { + const tmp = SHADER_LOC_VERTEX_NORMAL; + if (tmp >= 0) break :blk material.shader.locs + @as(usize, @intCast(tmp)) else break :blk material.shader.locs - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*)), @as(c_int, 3), @as(c_int, 5126), @as(c_int, 0) != 0, @as(c_int, 0), @as(c_int, 0)); + rlEnableVertexAttribute(@as(c_uint, @bitCast((blk: { + const tmp = SHADER_LOC_VERTEX_NORMAL; + if (tmp >= 0) break :blk material.shader.locs + @as(usize, @intCast(tmp)) else break :blk material.shader.locs - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*))); + } + if ((blk: { + const tmp = SHADER_LOC_VERTEX_COLOR; + if (tmp >= 0) break :blk material.shader.locs + @as(usize, @intCast(tmp)) else break :blk material.shader.locs - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* != -@as(c_int, 1)) { + if (mesh.vboId[@as(c_uint, @intCast(@as(c_int, 3)))] != @as(c_uint, @bitCast(@as(c_int, 0)))) { + rlEnableVertexBuffer(mesh.vboId[@as(c_uint, @intCast(@as(c_int, 3)))]); + rlSetVertexAttribute(@as(c_uint, @bitCast((blk: { + const tmp = SHADER_LOC_VERTEX_COLOR; + if (tmp >= 0) break :blk material.shader.locs + @as(usize, @intCast(tmp)) else break :blk material.shader.locs - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*)), @as(c_int, 4), @as(c_int, 5121), @as(c_int, 1) != 0, @as(c_int, 0), @as(c_int, 0)); + rlEnableVertexAttribute(@as(c_uint, @bitCast((blk: { + const tmp = SHADER_LOC_VERTEX_COLOR; + if (tmp >= 0) break :blk material.shader.locs + @as(usize, @intCast(tmp)) else break :blk material.shader.locs - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*))); + } else { + var value: [4]f32 = [4]f32{ + 1.0, + 1.0, + 1.0, + 1.0, + }; + _ = &value; + rlSetVertexAttributeDefault((blk: { + const tmp = SHADER_LOC_VERTEX_COLOR; + if (tmp >= 0) break :blk material.shader.locs + @as(usize, @intCast(tmp)) else break :blk material.shader.locs - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*, @as(?*const anyopaque, @ptrCast(@as([*c]f32, @ptrCast(@alignCast(&value))))), SHADER_ATTRIB_VEC4, @as(c_int, 4)); + rlDisableVertexAttribute(@as(c_uint, @bitCast((blk: { + const tmp = SHADER_LOC_VERTEX_COLOR; + if (tmp >= 0) break :blk material.shader.locs + @as(usize, @intCast(tmp)) else break :blk material.shader.locs - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*))); + } + } + if ((blk: { + const tmp = SHADER_LOC_VERTEX_TANGENT; + if (tmp >= 0) break :blk material.shader.locs + @as(usize, @intCast(tmp)) else break :blk material.shader.locs - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* != -@as(c_int, 1)) { + rlEnableVertexBuffer(mesh.vboId[@as(c_uint, @intCast(@as(c_int, 4)))]); + rlSetVertexAttribute(@as(c_uint, @bitCast((blk: { + const tmp = SHADER_LOC_VERTEX_TANGENT; + if (tmp >= 0) break :blk material.shader.locs + @as(usize, @intCast(tmp)) else break :blk material.shader.locs - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*)), @as(c_int, 4), @as(c_int, 5126), @as(c_int, 0) != 0, @as(c_int, 0), @as(c_int, 0)); + rlEnableVertexAttribute(@as(c_uint, @bitCast((blk: { + const tmp = SHADER_LOC_VERTEX_TANGENT; + if (tmp >= 0) break :blk material.shader.locs + @as(usize, @intCast(tmp)) else break :blk material.shader.locs - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*))); + } + if ((blk: { + const tmp = SHADER_LOC_VERTEX_TEXCOORD02; + if (tmp >= 0) break :blk material.shader.locs + @as(usize, @intCast(tmp)) else break :blk material.shader.locs - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* != -@as(c_int, 1)) { + rlEnableVertexBuffer(mesh.vboId[@as(c_uint, @intCast(@as(c_int, 5)))]); + rlSetVertexAttribute(@as(c_uint, @bitCast((blk: { + const tmp = SHADER_LOC_VERTEX_TEXCOORD02; + if (tmp >= 0) break :blk material.shader.locs + @as(usize, @intCast(tmp)) else break :blk material.shader.locs - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*)), @as(c_int, 2), @as(c_int, 5126), @as(c_int, 0) != 0, @as(c_int, 0), @as(c_int, 0)); + rlEnableVertexAttribute(@as(c_uint, @bitCast((blk: { + const tmp = SHADER_LOC_VERTEX_TEXCOORD02; + if (tmp >= 0) break :blk material.shader.locs + @as(usize, @intCast(tmp)) else break :blk material.shader.locs - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*))); + } + if (mesh.indices != @as([*c]c_ushort, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0))))))) { + rlEnableVertexBufferElement(mesh.vboId[@as(c_uint, @intCast(@as(c_int, 6)))]); + } + } + var eyeCount: c_int = 1; + _ = &eyeCount; + if (rlIsStereoRenderEnabled()) { + eyeCount = 2; + } + { + var eye: c_int = 0; + _ = &eye; + while (eye < eyeCount) : (eye += 1) { + var matModelViewProjection: Matrix = MatrixIdentity(); + _ = &matModelViewProjection; + if (eyeCount == @as(c_int, 1)) { + matModelViewProjection = MatrixMultiply(matModelView, matProjection); + } else { + rlViewport(@divTrunc(eye * rlGetFramebufferWidth(), @as(c_int, 2)), @as(c_int, 0), @divTrunc(rlGetFramebufferWidth(), @as(c_int, 2)), rlGetFramebufferHeight()); + matModelViewProjection = MatrixMultiply(MatrixMultiply(matModelView, rlGetMatrixViewOffsetStereo(eye)), rlGetMatrixProjectionStereo(eye)); + } + rlSetUniformMatrix((blk: { + const tmp = SHADER_LOC_MATRIX_MVP; + if (tmp >= 0) break :blk material.shader.locs + @as(usize, @intCast(tmp)) else break :blk material.shader.locs - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*, matModelViewProjection); + if (mesh.indices != @as([*c]c_ushort, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0))))))) { + rlDrawVertexArrayElementsInstanced(@as(c_int, 0), mesh.triangleCount * @as(c_int, 3), null, instances); + } else { + rlDrawVertexArrayInstanced(@as(c_int, 0), mesh.vertexCount, instances); + } + } + } + { + var i: c_int = 0; + _ = &i; + while (i < @as(c_int, 12)) : (i += 1) { + if ((blk: { + const tmp = i; + if (tmp >= 0) break :blk material.maps + @as(usize, @intCast(tmp)) else break :blk material.maps - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.texture.id > @as(c_uint, @bitCast(@as(c_int, 0)))) { + rlActiveTextureSlot(i); + if (((i == MATERIAL_MAP_IRRADIANCE) or (i == MATERIAL_MAP_PREFILTER)) or (i == MATERIAL_MAP_CUBEMAP)) { + rlDisableTextureCubemap(); + } else { + rlDisableTexture(); + } + } + } + } + rlDisableVertexArray(); + rlDisableVertexBuffer(); + rlDisableVertexBufferElement(); + rlDisableShader(); + rlUnloadVertexBuffer(instancesVboId); + free(@as(?*anyopaque, @ptrCast(instanceTransforms))); +} +pub export fn GetMeshBoundingBox(arg_mesh: Mesh) BoundingBox { + var mesh = arg_mesh; + _ = &mesh; + var minVertex: Vector3 = Vector3{ + .x = @as(f32, @floatFromInt(@as(c_int, 0))), + .y = 0, + .z = 0, + }; + _ = &minVertex; + var maxVertex: Vector3 = Vector3{ + .x = @as(f32, @floatFromInt(@as(c_int, 0))), + .y = 0, + .z = 0, + }; + _ = &maxVertex; + if (mesh.vertices != @as([*c]f32, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0))))))) { + minVertex = Vector3{ + .x = mesh.vertices[@as(c_uint, @intCast(@as(c_int, 0)))], + .y = mesh.vertices[@as(c_uint, @intCast(@as(c_int, 1)))], + .z = mesh.vertices[@as(c_uint, @intCast(@as(c_int, 2)))], + }; + maxVertex = Vector3{ + .x = mesh.vertices[@as(c_uint, @intCast(@as(c_int, 0)))], + .y = mesh.vertices[@as(c_uint, @intCast(@as(c_int, 1)))], + .z = mesh.vertices[@as(c_uint, @intCast(@as(c_int, 2)))], + }; + { + var i: c_int = 1; + _ = &i; + while (i < mesh.vertexCount) : (i += 1) { + minVertex = Vector3Min(minVertex, Vector3{ + .x = (blk: { + const tmp = i * @as(c_int, 3); + if (tmp >= 0) break :blk mesh.vertices + @as(usize, @intCast(tmp)) else break :blk mesh.vertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*, + .y = (blk: { + const tmp = (i * @as(c_int, 3)) + @as(c_int, 1); + if (tmp >= 0) break :blk mesh.vertices + @as(usize, @intCast(tmp)) else break :blk mesh.vertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*, + .z = (blk: { + const tmp = (i * @as(c_int, 3)) + @as(c_int, 2); + if (tmp >= 0) break :blk mesh.vertices + @as(usize, @intCast(tmp)) else break :blk mesh.vertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*, + }); + maxVertex = Vector3Max(maxVertex, Vector3{ + .x = (blk: { + const tmp = i * @as(c_int, 3); + if (tmp >= 0) break :blk mesh.vertices + @as(usize, @intCast(tmp)) else break :blk mesh.vertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*, + .y = (blk: { + const tmp = (i * @as(c_int, 3)) + @as(c_int, 1); + if (tmp >= 0) break :blk mesh.vertices + @as(usize, @intCast(tmp)) else break :blk mesh.vertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*, + .z = (blk: { + const tmp = (i * @as(c_int, 3)) + @as(c_int, 2); + if (tmp >= 0) break :blk mesh.vertices + @as(usize, @intCast(tmp)) else break :blk mesh.vertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*, + }); + } + } + } + var box: BoundingBox = BoundingBox{ + .min = Vector3{ + .x = @as(f32, @floatFromInt(@as(c_int, 0))), + .y = 0, + .z = 0, + }, + .max = @import("std").mem.zeroes(Vector3), + }; + _ = &box; + box.min = minVertex; + box.max = maxVertex; + return box; +} +pub export fn GenMeshTangents(arg_mesh: [*c]Mesh) void { + var mesh = arg_mesh; + _ = &mesh; + if ((mesh.*.vertices == @as([*c]f32, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0))))))) or (mesh.*.texcoords == @as([*c]f32, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0)))))))) { + TraceLog(LOG_WARNING, "MESH: Tangents generation requires texcoord vertex attribute data"); + return; + } + if (mesh.*.tangents == @as([*c]f32, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0))))))) { + mesh.*.tangents = @as([*c]f32, @ptrCast(@alignCast(malloc(@as(c_ulong, @bitCast(@as(c_long, mesh.*.vertexCount * @as(c_int, 4)))) *% @sizeOf(f32))))); + } else { + free(@as(?*anyopaque, @ptrCast(mesh.*.tangents))); + mesh.*.tangents = @as([*c]f32, @ptrCast(@alignCast(malloc(@as(c_ulong, @bitCast(@as(c_long, mesh.*.vertexCount * @as(c_int, 4)))) *% @sizeOf(f32))))); + } + var tan1: [*c]Vector3 = @as([*c]Vector3, @ptrCast(@alignCast(malloc(@as(c_ulong, @bitCast(@as(c_long, mesh.*.vertexCount))) *% @sizeOf(Vector3))))); + _ = &tan1; + var tan2: [*c]Vector3 = @as([*c]Vector3, @ptrCast(@alignCast(malloc(@as(c_ulong, @bitCast(@as(c_long, mesh.*.vertexCount))) *% @sizeOf(Vector3))))); + _ = &tan2; + if (@import("std").zig.c_translation.signedRemainder(mesh.*.vertexCount, @as(c_int, 3)) != @as(c_int, 0)) { + TraceLog(LOG_WARNING, "MESH: vertexCount expected to be a multiple of 3. Expect uninitialized values."); + } + { + var i: c_int = 0; + _ = &i; + while (i <= (mesh.*.vertexCount - @as(c_int, 3))) : (i += @as(c_int, 3)) { + var v1: Vector3 = Vector3{ + .x = (blk: { + const tmp = ((i + @as(c_int, 0)) * @as(c_int, 3)) + @as(c_int, 0); + if (tmp >= 0) break :blk mesh.*.vertices + @as(usize, @intCast(tmp)) else break :blk mesh.*.vertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*, + .y = (blk: { + const tmp = ((i + @as(c_int, 0)) * @as(c_int, 3)) + @as(c_int, 1); + if (tmp >= 0) break :blk mesh.*.vertices + @as(usize, @intCast(tmp)) else break :blk mesh.*.vertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*, + .z = (blk: { + const tmp = ((i + @as(c_int, 0)) * @as(c_int, 3)) + @as(c_int, 2); + if (tmp >= 0) break :blk mesh.*.vertices + @as(usize, @intCast(tmp)) else break :blk mesh.*.vertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*, + }; + _ = &v1; + var v2: Vector3 = Vector3{ + .x = (blk: { + const tmp = ((i + @as(c_int, 1)) * @as(c_int, 3)) + @as(c_int, 0); + if (tmp >= 0) break :blk mesh.*.vertices + @as(usize, @intCast(tmp)) else break :blk mesh.*.vertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*, + .y = (blk: { + const tmp = ((i + @as(c_int, 1)) * @as(c_int, 3)) + @as(c_int, 1); + if (tmp >= 0) break :blk mesh.*.vertices + @as(usize, @intCast(tmp)) else break :blk mesh.*.vertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*, + .z = (blk: { + const tmp = ((i + @as(c_int, 1)) * @as(c_int, 3)) + @as(c_int, 2); + if (tmp >= 0) break :blk mesh.*.vertices + @as(usize, @intCast(tmp)) else break :blk mesh.*.vertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*, + }; + _ = &v2; + var v3: Vector3 = Vector3{ + .x = (blk: { + const tmp = ((i + @as(c_int, 2)) * @as(c_int, 3)) + @as(c_int, 0); + if (tmp >= 0) break :blk mesh.*.vertices + @as(usize, @intCast(tmp)) else break :blk mesh.*.vertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*, + .y = (blk: { + const tmp = ((i + @as(c_int, 2)) * @as(c_int, 3)) + @as(c_int, 1); + if (tmp >= 0) break :blk mesh.*.vertices + @as(usize, @intCast(tmp)) else break :blk mesh.*.vertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*, + .z = (blk: { + const tmp = ((i + @as(c_int, 2)) * @as(c_int, 3)) + @as(c_int, 2); + if (tmp >= 0) break :blk mesh.*.vertices + @as(usize, @intCast(tmp)) else break :blk mesh.*.vertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*, + }; + _ = &v3; + var uv1: Vector2 = Vector2{ + .x = (blk: { + const tmp = ((i + @as(c_int, 0)) * @as(c_int, 2)) + @as(c_int, 0); + if (tmp >= 0) break :blk mesh.*.texcoords + @as(usize, @intCast(tmp)) else break :blk mesh.*.texcoords - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*, + .y = (blk: { + const tmp = ((i + @as(c_int, 0)) * @as(c_int, 2)) + @as(c_int, 1); + if (tmp >= 0) break :blk mesh.*.texcoords + @as(usize, @intCast(tmp)) else break :blk mesh.*.texcoords - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*, + }; + _ = &uv1; + var uv2: Vector2 = Vector2{ + .x = (blk: { + const tmp = ((i + @as(c_int, 1)) * @as(c_int, 2)) + @as(c_int, 0); + if (tmp >= 0) break :blk mesh.*.texcoords + @as(usize, @intCast(tmp)) else break :blk mesh.*.texcoords - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*, + .y = (blk: { + const tmp = ((i + @as(c_int, 1)) * @as(c_int, 2)) + @as(c_int, 1); + if (tmp >= 0) break :blk mesh.*.texcoords + @as(usize, @intCast(tmp)) else break :blk mesh.*.texcoords - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*, + }; + _ = &uv2; + var uv3: Vector2 = Vector2{ + .x = (blk: { + const tmp = ((i + @as(c_int, 2)) * @as(c_int, 2)) + @as(c_int, 0); + if (tmp >= 0) break :blk mesh.*.texcoords + @as(usize, @intCast(tmp)) else break :blk mesh.*.texcoords - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*, + .y = (blk: { + const tmp = ((i + @as(c_int, 2)) * @as(c_int, 2)) + @as(c_int, 1); + if (tmp >= 0) break :blk mesh.*.texcoords + @as(usize, @intCast(tmp)) else break :blk mesh.*.texcoords - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*, + }; + _ = &uv3; + var x1: f32 = v2.x - v1.x; + _ = &x1; + var y1_1: f32 = v2.y - v1.y; + _ = &y1_1; + var z1: f32 = v2.z - v1.z; + _ = &z1; + var x2: f32 = v3.x - v1.x; + _ = &x2; + var y2: f32 = v3.y - v1.y; + _ = &y2; + var z2: f32 = v3.z - v1.z; + _ = &z2; + var s1: f32 = uv2.x - uv1.x; + _ = &s1; + var t1: f32 = uv2.y - uv1.y; + _ = &t1; + var s2: f32 = uv3.x - uv1.x; + _ = &s2; + var t2: f32 = uv3.y - uv1.y; + _ = &t2; + var div_2: f32 = (s1 * t2) - (s2 * t1); + _ = &div_2; + var r: f32 = if (div_2 == 0.0) 0.0 else 1.0 / div_2; + _ = &r; + var sdir: Vector3 = Vector3{ + .x = ((t2 * x1) - (t1 * x2)) * r, + .y = ((t2 * y1_1) - (t1 * y2)) * r, + .z = ((t2 * z1) - (t1 * z2)) * r, + }; + _ = &sdir; + var tdir: Vector3 = Vector3{ + .x = ((s1 * x2) - (s2 * x1)) * r, + .y = ((s1 * y2) - (s2 * y1_1)) * r, + .z = ((s1 * z2) - (s2 * z1)) * r, + }; + _ = &tdir; + (blk: { + const tmp = i + @as(c_int, 0); + if (tmp >= 0) break :blk tan1 + @as(usize, @intCast(tmp)) else break :blk tan1 - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = sdir; + (blk: { + const tmp = i + @as(c_int, 1); + if (tmp >= 0) break :blk tan1 + @as(usize, @intCast(tmp)) else break :blk tan1 - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = sdir; + (blk: { + const tmp = i + @as(c_int, 2); + if (tmp >= 0) break :blk tan1 + @as(usize, @intCast(tmp)) else break :blk tan1 - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = sdir; + (blk: { + const tmp = i + @as(c_int, 0); + if (tmp >= 0) break :blk tan2 + @as(usize, @intCast(tmp)) else break :blk tan2 - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = tdir; + (blk: { + const tmp = i + @as(c_int, 1); + if (tmp >= 0) break :blk tan2 + @as(usize, @intCast(tmp)) else break :blk tan2 - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = tdir; + (blk: { + const tmp = i + @as(c_int, 2); + if (tmp >= 0) break :blk tan2 + @as(usize, @intCast(tmp)) else break :blk tan2 - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = tdir; + } + } + { + var i: c_int = 0; + _ = &i; + while (i < mesh.*.vertexCount) : (i += 1) { + var normal: Vector3 = Vector3{ + .x = (blk: { + const tmp = (i * @as(c_int, 3)) + @as(c_int, 0); + if (tmp >= 0) break :blk mesh.*.normals + @as(usize, @intCast(tmp)) else break :blk mesh.*.normals - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*, + .y = (blk: { + const tmp = (i * @as(c_int, 3)) + @as(c_int, 1); + if (tmp >= 0) break :blk mesh.*.normals + @as(usize, @intCast(tmp)) else break :blk mesh.*.normals - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*, + .z = (blk: { + const tmp = (i * @as(c_int, 3)) + @as(c_int, 2); + if (tmp >= 0) break :blk mesh.*.normals + @as(usize, @intCast(tmp)) else break :blk mesh.*.normals - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*, + }; + _ = &normal; + var tangent: Vector3 = (blk: { + const tmp = i; + if (tmp >= 0) break :blk tan1 + @as(usize, @intCast(tmp)) else break :blk tan1 - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*; + _ = &tangent; + Vector3OrthoNormalize(&normal, &tangent); + (blk: { + const tmp = (i * @as(c_int, 4)) + @as(c_int, 0); + if (tmp >= 0) break :blk mesh.*.tangents + @as(usize, @intCast(tmp)) else break :blk mesh.*.tangents - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = tangent.x; + (blk: { + const tmp = (i * @as(c_int, 4)) + @as(c_int, 1); + if (tmp >= 0) break :blk mesh.*.tangents + @as(usize, @intCast(tmp)) else break :blk mesh.*.tangents - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = tangent.y; + (blk: { + const tmp = (i * @as(c_int, 4)) + @as(c_int, 2); + if (tmp >= 0) break :blk mesh.*.tangents + @as(usize, @intCast(tmp)) else break :blk mesh.*.tangents - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = tangent.z; + (blk: { + const tmp = (i * @as(c_int, 4)) + @as(c_int, 3); + if (tmp >= 0) break :blk mesh.*.tangents + @as(usize, @intCast(tmp)) else break :blk mesh.*.tangents - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = if (Vector3DotProduct(Vector3CrossProduct(normal, tangent), (blk: { + const tmp = i; + if (tmp >= 0) break :blk tan2 + @as(usize, @intCast(tmp)) else break :blk tan2 - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*) < 0.0) -1.0 else 1.0; + } + } + free(@as(?*anyopaque, @ptrCast(tan1))); + free(@as(?*anyopaque, @ptrCast(tan2))); + if (mesh.*.vboId != @as([*c]c_uint, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0))))))) { + if ((blk: { + const tmp = SHADER_LOC_VERTEX_TANGENT; + if (tmp >= 0) break :blk mesh.*.vboId + @as(usize, @intCast(tmp)) else break :blk mesh.*.vboId - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* != @as(c_uint, @bitCast(@as(c_int, 0)))) { + rlUpdateVertexBuffer((blk: { + const tmp = SHADER_LOC_VERTEX_TANGENT; + if (tmp >= 0) break :blk mesh.*.vboId + @as(usize, @intCast(tmp)) else break :blk mesh.*.vboId - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*, @as(?*const anyopaque, @ptrCast(mesh.*.tangents)), @as(c_int, @bitCast(@as(c_uint, @truncate(@as(c_ulong, @bitCast(@as(c_long, mesh.*.vertexCount * @as(c_int, 4)))) *% @sizeOf(f32))))), @as(c_int, 0)); + } else { + (blk: { + const tmp = SHADER_LOC_VERTEX_TANGENT; + if (tmp >= 0) break :blk mesh.*.vboId + @as(usize, @intCast(tmp)) else break :blk mesh.*.vboId - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = rlLoadVertexBuffer(@as(?*const anyopaque, @ptrCast(mesh.*.tangents)), @as(c_int, @bitCast(@as(c_uint, @truncate(@as(c_ulong, @bitCast(@as(c_long, mesh.*.vertexCount * @as(c_int, 4)))) *% @sizeOf(f32))))), @as(c_int, 0) != 0); + } + _ = rlEnableVertexArray(mesh.*.vaoId); + rlSetVertexAttribute(@as(c_uint, @bitCast(@as(c_int, 4))), @as(c_int, 4), @as(c_int, 5126), @as(c_int, 0) != 0, @as(c_int, 0), @as(c_int, 0)); + rlEnableVertexAttribute(@as(c_uint, @bitCast(@as(c_int, 4)))); + rlDisableVertexArray(); + } + TraceLog(LOG_INFO, "MESH: Tangents data computed and uploaded for provided mesh"); +} +pub export fn ExportMesh(arg_mesh: Mesh, arg_fileName: [*c]const u8) bool { + var mesh = arg_mesh; + _ = &mesh; + var fileName = arg_fileName; + _ = &fileName; + var success: bool = @as(c_int, 0) != 0; + _ = &success; + if (IsFileExtension(fileName, ".obj")) { + var dataSize: c_int = (((mesh.vertexCount * @as(c_int, @bitCast(@as(c_uint, @truncate(strlen("v 0000.00f 0000.00f 0000.00f")))))) + (mesh.vertexCount * @as(c_int, @bitCast(@as(c_uint, @truncate(strlen("vt 0.000f 0.00f"))))))) + (mesh.vertexCount * @as(c_int, @bitCast(@as(c_uint, @truncate(strlen("vn 0.000f 0.00f 0.00f"))))))) + (mesh.triangleCount * @as(c_int, @bitCast(@as(c_uint, @truncate(strlen("f 00000/00000/00000 00000/00000/00000 00000/00000/00000")))))); + _ = &dataSize; + var txtData: [*c]u8 = @as([*c]u8, @ptrCast(@alignCast(calloc(@as(c_ulong, @bitCast(@as(c_long, (dataSize * @as(c_int, 2)) + @as(c_int, 2000)))), @sizeOf(u8))))); + _ = &txtData; + var byteCount: c_int = 0; + _ = &byteCount; + byteCount += sprintf(txtData + @as(usize, @bitCast(@as(isize, @intCast(byteCount)))), "# //////////////////////////////////////////////////////////////////////////////////\n"); + byteCount += sprintf(txtData + @as(usize, @bitCast(@as(isize, @intCast(byteCount)))), "# // //\n"); + byteCount += sprintf(txtData + @as(usize, @bitCast(@as(isize, @intCast(byteCount)))), "# // rMeshOBJ exporter v1.0 - Mesh exported as triangle faces and not optimized //\n"); + byteCount += sprintf(txtData + @as(usize, @bitCast(@as(isize, @intCast(byteCount)))), "# // //\n"); + byteCount += sprintf(txtData + @as(usize, @bitCast(@as(isize, @intCast(byteCount)))), "# // more info and bugs-report: github.com/raysan5/raylib //\n"); + byteCount += sprintf(txtData + @as(usize, @bitCast(@as(isize, @intCast(byteCount)))), "# // feedback and support: ray[at]raylib.com //\n"); + byteCount += sprintf(txtData + @as(usize, @bitCast(@as(isize, @intCast(byteCount)))), "# // //\n"); + byteCount += sprintf(txtData + @as(usize, @bitCast(@as(isize, @intCast(byteCount)))), "# // Copyright (c) 2018-2024 Ramon Santamaria (@raysan5) //\n"); + byteCount += sprintf(txtData + @as(usize, @bitCast(@as(isize, @intCast(byteCount)))), "# // //\n"); + byteCount += sprintf(txtData + @as(usize, @bitCast(@as(isize, @intCast(byteCount)))), "# //////////////////////////////////////////////////////////////////////////////////\n\n"); + byteCount += sprintf(txtData + @as(usize, @bitCast(@as(isize, @intCast(byteCount)))), "# Vertex Count: %i\n", mesh.vertexCount); + byteCount += sprintf(txtData + @as(usize, @bitCast(@as(isize, @intCast(byteCount)))), "# Triangle Count: %i\n\n", mesh.triangleCount); + byteCount += sprintf(txtData + @as(usize, @bitCast(@as(isize, @intCast(byteCount)))), "g mesh\n"); + { + var i: c_int = 0; + _ = &i; + var v: c_int = 0; + _ = &v; + while (i < mesh.vertexCount) : (_ = blk: { + i += 1; + break :blk blk_1: { + const ref = &v; + ref.* += @as(c_int, 3); + break :blk_1 ref.*; + }; + }) { + byteCount += sprintf(txtData + @as(usize, @bitCast(@as(isize, @intCast(byteCount)))), "v %.2f %.2f %.2f\n", @as(f64, @floatCast((blk: { + const tmp = v; + if (tmp >= 0) break :blk mesh.vertices + @as(usize, @intCast(tmp)) else break :blk mesh.vertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*)), @as(f64, @floatCast((blk: { + const tmp = v + @as(c_int, 1); + if (tmp >= 0) break :blk mesh.vertices + @as(usize, @intCast(tmp)) else break :blk mesh.vertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*)), @as(f64, @floatCast((blk: { + const tmp = v + @as(c_int, 2); + if (tmp >= 0) break :blk mesh.vertices + @as(usize, @intCast(tmp)) else break :blk mesh.vertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*))); + } + } + { + var i: c_int = 0; + _ = &i; + var v: c_int = 0; + _ = &v; + while (i < mesh.vertexCount) : (_ = blk: { + i += 1; + break :blk blk_1: { + const ref = &v; + ref.* += @as(c_int, 2); + break :blk_1 ref.*; + }; + }) { + byteCount += sprintf(txtData + @as(usize, @bitCast(@as(isize, @intCast(byteCount)))), "vt %.3f %.3f\n", @as(f64, @floatCast((blk: { + const tmp = v; + if (tmp >= 0) break :blk mesh.texcoords + @as(usize, @intCast(tmp)) else break :blk mesh.texcoords - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*)), @as(f64, @floatCast((blk: { + const tmp = v + @as(c_int, 1); + if (tmp >= 0) break :blk mesh.texcoords + @as(usize, @intCast(tmp)) else break :blk mesh.texcoords - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*))); + } + } + { + var i: c_int = 0; + _ = &i; + var v: c_int = 0; + _ = &v; + while (i < mesh.vertexCount) : (_ = blk: { + i += 1; + break :blk blk_1: { + const ref = &v; + ref.* += @as(c_int, 3); + break :blk_1 ref.*; + }; + }) { + byteCount += sprintf(txtData + @as(usize, @bitCast(@as(isize, @intCast(byteCount)))), "vn %.3f %.3f %.3f\n", @as(f64, @floatCast((blk: { + const tmp = v; + if (tmp >= 0) break :blk mesh.normals + @as(usize, @intCast(tmp)) else break :blk mesh.normals - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*)), @as(f64, @floatCast((blk: { + const tmp = v + @as(c_int, 1); + if (tmp >= 0) break :blk mesh.normals + @as(usize, @intCast(tmp)) else break :blk mesh.normals - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*)), @as(f64, @floatCast((blk: { + const tmp = v + @as(c_int, 2); + if (tmp >= 0) break :blk mesh.normals + @as(usize, @intCast(tmp)) else break :blk mesh.normals - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*))); + } + } + if (mesh.indices != @as([*c]c_ushort, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0))))))) { + { + var i: c_int = 0; + _ = &i; + var v: c_int = 0; + _ = &v; + while (i < mesh.triangleCount) : (_ = blk: { + i += 1; + break :blk blk_1: { + const ref = &v; + ref.* += @as(c_int, 3); + break :blk_1 ref.*; + }; + }) { + byteCount += sprintf(txtData + @as(usize, @bitCast(@as(isize, @intCast(byteCount)))), "f %i/%i/%i %i/%i/%i %i/%i/%i\n", @as(c_int, @bitCast(@as(c_uint, (blk: { + const tmp = v; + if (tmp >= 0) break :blk mesh.indices + @as(usize, @intCast(tmp)) else break :blk mesh.indices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*))) + @as(c_int, 1), @as(c_int, @bitCast(@as(c_uint, (blk: { + const tmp = v; + if (tmp >= 0) break :blk mesh.indices + @as(usize, @intCast(tmp)) else break :blk mesh.indices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*))) + @as(c_int, 1), @as(c_int, @bitCast(@as(c_uint, (blk: { + const tmp = v; + if (tmp >= 0) break :blk mesh.indices + @as(usize, @intCast(tmp)) else break :blk mesh.indices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*))) + @as(c_int, 1), @as(c_int, @bitCast(@as(c_uint, (blk: { + const tmp = v + @as(c_int, 1); + if (tmp >= 0) break :blk mesh.indices + @as(usize, @intCast(tmp)) else break :blk mesh.indices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*))) + @as(c_int, 1), @as(c_int, @bitCast(@as(c_uint, (blk: { + const tmp = v + @as(c_int, 1); + if (tmp >= 0) break :blk mesh.indices + @as(usize, @intCast(tmp)) else break :blk mesh.indices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*))) + @as(c_int, 1), @as(c_int, @bitCast(@as(c_uint, (blk: { + const tmp = v + @as(c_int, 1); + if (tmp >= 0) break :blk mesh.indices + @as(usize, @intCast(tmp)) else break :blk mesh.indices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*))) + @as(c_int, 1), @as(c_int, @bitCast(@as(c_uint, (blk: { + const tmp = v + @as(c_int, 2); + if (tmp >= 0) break :blk mesh.indices + @as(usize, @intCast(tmp)) else break :blk mesh.indices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*))) + @as(c_int, 1), @as(c_int, @bitCast(@as(c_uint, (blk: { + const tmp = v + @as(c_int, 2); + if (tmp >= 0) break :blk mesh.indices + @as(usize, @intCast(tmp)) else break :blk mesh.indices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*))) + @as(c_int, 1), @as(c_int, @bitCast(@as(c_uint, (blk: { + const tmp = v + @as(c_int, 2); + if (tmp >= 0) break :blk mesh.indices + @as(usize, @intCast(tmp)) else break :blk mesh.indices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*))) + @as(c_int, 1)); + } + } + } else { + { + var i: c_int = 0; + _ = &i; + var v: c_int = 1; + _ = &v; + while (i < mesh.triangleCount) : (_ = blk: { + i += 1; + break :blk blk_1: { + const ref = &v; + ref.* += @as(c_int, 3); + break :blk_1 ref.*; + }; + }) { + byteCount += sprintf(txtData + @as(usize, @bitCast(@as(isize, @intCast(byteCount)))), "f %i/%i/%i %i/%i/%i %i/%i/%i\n", v, v, v, v + @as(c_int, 1), v + @as(c_int, 1), v + @as(c_int, 1), v + @as(c_int, 2), v + @as(c_int, 2), v + @as(c_int, 2)); + } + } + } + byteCount += sprintf(txtData + @as(usize, @bitCast(@as(isize, @intCast(byteCount)))), "\n"); + success = SaveFileText(fileName, txtData); + free(@as(?*anyopaque, @ptrCast(txtData))); + } else if (IsFileExtension(fileName, ".raw")) {} + return success; +} +pub export fn ExportMeshAsCode(arg_mesh: Mesh, arg_fileName: [*c]const u8) bool { + var mesh = arg_mesh; + _ = &mesh; + var fileName = arg_fileName; + _ = &fileName; + var success: bool = @as(c_int, 0) != 0; + _ = &success; + var txtData: [*c]u8 = @as([*c]u8, @ptrCast(@alignCast(calloc(@as(c_ulong, @bitCast(@as(c_long, (@as(c_int, 64) * @as(c_int, 1024)) * @as(c_int, 1024)))), @sizeOf(u8))))); + _ = &txtData; + var byteCount: c_int = 0; + _ = &byteCount; + byteCount += sprintf(txtData + @as(usize, @bitCast(@as(isize, @intCast(byteCount)))), "////////////////////////////////////////////////////////////////////////////////////////\n"); + byteCount += sprintf(txtData + @as(usize, @bitCast(@as(isize, @intCast(byteCount)))), "// //\n"); + byteCount += sprintf(txtData + @as(usize, @bitCast(@as(isize, @intCast(byteCount)))), "// MeshAsCode exporter v1.0 - Mesh vertex data exported as arrays //\n"); + byteCount += sprintf(txtData + @as(usize, @bitCast(@as(isize, @intCast(byteCount)))), "// //\n"); + byteCount += sprintf(txtData + @as(usize, @bitCast(@as(isize, @intCast(byteCount)))), "// more info and bugs-report: github.com/raysan5/raylib //\n"); + byteCount += sprintf(txtData + @as(usize, @bitCast(@as(isize, @intCast(byteCount)))), "// feedback and support: ray[at]raylib.com //\n"); + byteCount += sprintf(txtData + @as(usize, @bitCast(@as(isize, @intCast(byteCount)))), "// //\n"); + byteCount += sprintf(txtData + @as(usize, @bitCast(@as(isize, @intCast(byteCount)))), "// Copyright (c) 2023 Ramon Santamaria (@raysan5) //\n"); + byteCount += sprintf(txtData + @as(usize, @bitCast(@as(isize, @intCast(byteCount)))), "// //\n"); + byteCount += sprintf(txtData + @as(usize, @bitCast(@as(isize, @intCast(byteCount)))), "////////////////////////////////////////////////////////////////////////////////////////\n\n"); + var varFileName: [256]u8 = [1]u8{ + 0, + } ++ [1]u8{0} ** 255; + _ = &varFileName; + _ = strcpy(@as([*c]u8, @ptrCast(@alignCast(&varFileName))), GetFileNameWithoutExt(fileName)); + { + var i: c_int = 0; + _ = &i; + while (@as(c_int, @bitCast(@as(c_uint, varFileName[@as(c_uint, @intCast(i))]))) != @as(c_int, '\x00')) : (i += 1) if ((@as(c_int, @bitCast(@as(c_uint, varFileName[@as(c_uint, @intCast(i))]))) >= @as(c_int, 'a')) and (@as(c_int, @bitCast(@as(c_uint, varFileName[@as(c_uint, @intCast(i))]))) <= @as(c_int, 'z'))) { + varFileName[@as(c_uint, @intCast(i))] = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, @bitCast(@as(c_uint, varFileName[@as(c_uint, @intCast(i))]))) - @as(c_int, 32))))); + }; + } + byteCount += sprintf(txtData + @as(usize, @bitCast(@as(isize, @intCast(byteCount)))), "// Mesh basic information\n"); + byteCount += sprintf(txtData + @as(usize, @bitCast(@as(isize, @intCast(byteCount)))), "#define %s_VERTEX_COUNT %i\n", @as([*c]u8, @ptrCast(@alignCast(&varFileName))), mesh.vertexCount); + byteCount += sprintf(txtData + @as(usize, @bitCast(@as(isize, @intCast(byteCount)))), "#define %s_TRIANGLE_COUNT %i\n\n", @as([*c]u8, @ptrCast(@alignCast(&varFileName))), mesh.triangleCount); + if (mesh.vertices != @as([*c]f32, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0))))))) { + byteCount += sprintf(txtData + @as(usize, @bitCast(@as(isize, @intCast(byteCount)))), "static float %s_VERTEX_DATA[%i] = { ", @as([*c]u8, @ptrCast(@alignCast(&varFileName))), mesh.vertexCount * @as(c_int, 3)); + { + var i: c_int = 0; + _ = &i; + while (i < ((mesh.vertexCount * @as(c_int, 3)) - @as(c_int, 1))) : (i += 1) { + byteCount += sprintf(txtData + @as(usize, @bitCast(@as(isize, @intCast(byteCount)))), if (@import("std").zig.c_translation.signedRemainder(i, @as(c_int, 20)) == @as(c_int, 0)) "%.3ff,\n" else "%.3ff, ", @as(f64, @floatCast((blk: { + const tmp = i; + if (tmp >= 0) break :blk mesh.vertices + @as(usize, @intCast(tmp)) else break :blk mesh.vertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*))); + } + } + byteCount += sprintf(txtData + @as(usize, @bitCast(@as(isize, @intCast(byteCount)))), "%.3ff };\n\n", @as(f64, @floatCast((blk: { + const tmp = (mesh.vertexCount * @as(c_int, 3)) - @as(c_int, 1); + if (tmp >= 0) break :blk mesh.vertices + @as(usize, @intCast(tmp)) else break :blk mesh.vertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*))); + } + if (mesh.texcoords != @as([*c]f32, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0))))))) { + byteCount += sprintf(txtData + @as(usize, @bitCast(@as(isize, @intCast(byteCount)))), "static float %s_TEXCOORD_DATA[%i] = { ", @as([*c]u8, @ptrCast(@alignCast(&varFileName))), mesh.vertexCount * @as(c_int, 2)); + { + var i: c_int = 0; + _ = &i; + while (i < ((mesh.vertexCount * @as(c_int, 2)) - @as(c_int, 1))) : (i += 1) { + byteCount += sprintf(txtData + @as(usize, @bitCast(@as(isize, @intCast(byteCount)))), if (@import("std").zig.c_translation.signedRemainder(i, @as(c_int, 20)) == @as(c_int, 0)) "%.3ff,\n" else "%.3ff, ", @as(f64, @floatCast((blk: { + const tmp = i; + if (tmp >= 0) break :blk mesh.texcoords + @as(usize, @intCast(tmp)) else break :blk mesh.texcoords - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*))); + } + } + byteCount += sprintf(txtData + @as(usize, @bitCast(@as(isize, @intCast(byteCount)))), "%.3ff };\n\n", @as(f64, @floatCast((blk: { + const tmp = (mesh.vertexCount * @as(c_int, 2)) - @as(c_int, 1); + if (tmp >= 0) break :blk mesh.texcoords + @as(usize, @intCast(tmp)) else break :blk mesh.texcoords - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*))); + } + if (mesh.texcoords2 != @as([*c]f32, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0))))))) { + byteCount += sprintf(txtData + @as(usize, @bitCast(@as(isize, @intCast(byteCount)))), "static float %s_TEXCOORD2_DATA[%i] = { ", @as([*c]u8, @ptrCast(@alignCast(&varFileName))), mesh.vertexCount * @as(c_int, 2)); + { + var i: c_int = 0; + _ = &i; + while (i < ((mesh.vertexCount * @as(c_int, 2)) - @as(c_int, 1))) : (i += 1) { + byteCount += sprintf(txtData + @as(usize, @bitCast(@as(isize, @intCast(byteCount)))), if (@import("std").zig.c_translation.signedRemainder(i, @as(c_int, 20)) == @as(c_int, 0)) "%.3ff,\n" else "%.3ff, ", @as(f64, @floatCast((blk: { + const tmp = i; + if (tmp >= 0) break :blk mesh.texcoords2 + @as(usize, @intCast(tmp)) else break :blk mesh.texcoords2 - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*))); + } + } + byteCount += sprintf(txtData + @as(usize, @bitCast(@as(isize, @intCast(byteCount)))), "%.3ff };\n\n", @as(f64, @floatCast((blk: { + const tmp = (mesh.vertexCount * @as(c_int, 2)) - @as(c_int, 1); + if (tmp >= 0) break :blk mesh.texcoords2 + @as(usize, @intCast(tmp)) else break :blk mesh.texcoords2 - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*))); + } + if (mesh.normals != @as([*c]f32, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0))))))) { + byteCount += sprintf(txtData + @as(usize, @bitCast(@as(isize, @intCast(byteCount)))), "static float %s_NORMAL_DATA[%i] = { ", @as([*c]u8, @ptrCast(@alignCast(&varFileName))), mesh.vertexCount * @as(c_int, 3)); + { + var i: c_int = 0; + _ = &i; + while (i < ((mesh.vertexCount * @as(c_int, 3)) - @as(c_int, 1))) : (i += 1) { + byteCount += sprintf(txtData + @as(usize, @bitCast(@as(isize, @intCast(byteCount)))), if (@import("std").zig.c_translation.signedRemainder(i, @as(c_int, 20)) == @as(c_int, 0)) "%.3ff,\n" else "%.3ff, ", @as(f64, @floatCast((blk: { + const tmp = i; + if (tmp >= 0) break :blk mesh.normals + @as(usize, @intCast(tmp)) else break :blk mesh.normals - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*))); + } + } + byteCount += sprintf(txtData + @as(usize, @bitCast(@as(isize, @intCast(byteCount)))), "%.3ff };\n\n", @as(f64, @floatCast((blk: { + const tmp = (mesh.vertexCount * @as(c_int, 3)) - @as(c_int, 1); + if (tmp >= 0) break :blk mesh.normals + @as(usize, @intCast(tmp)) else break :blk mesh.normals - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*))); + } + if (mesh.tangents != @as([*c]f32, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0))))))) { + byteCount += sprintf(txtData + @as(usize, @bitCast(@as(isize, @intCast(byteCount)))), "static float %s_TANGENT_DATA[%i] = { ", @as([*c]u8, @ptrCast(@alignCast(&varFileName))), mesh.vertexCount * @as(c_int, 4)); + { + var i: c_int = 0; + _ = &i; + while (i < ((mesh.vertexCount * @as(c_int, 4)) - @as(c_int, 1))) : (i += 1) { + byteCount += sprintf(txtData + @as(usize, @bitCast(@as(isize, @intCast(byteCount)))), if (@import("std").zig.c_translation.signedRemainder(i, @as(c_int, 20)) == @as(c_int, 0)) "%.3ff,\n" else "%.3ff, ", @as(f64, @floatCast((blk: { + const tmp = i; + if (tmp >= 0) break :blk mesh.tangents + @as(usize, @intCast(tmp)) else break :blk mesh.tangents - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*))); + } + } + byteCount += sprintf(txtData + @as(usize, @bitCast(@as(isize, @intCast(byteCount)))), "%.3ff };\n\n", @as(f64, @floatCast((blk: { + const tmp = (mesh.vertexCount * @as(c_int, 4)) - @as(c_int, 1); + if (tmp >= 0) break :blk mesh.tangents + @as(usize, @intCast(tmp)) else break :blk mesh.tangents - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*))); + } + if (mesh.colors != @as([*c]u8, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0))))))) { + byteCount += sprintf(txtData + @as(usize, @bitCast(@as(isize, @intCast(byteCount)))), "static unsigned char %s_COLOR_DATA[%i] = { ", @as([*c]u8, @ptrCast(@alignCast(&varFileName))), mesh.vertexCount * @as(c_int, 4)); + { + var i: c_int = 0; + _ = &i; + while (i < ((mesh.vertexCount * @as(c_int, 4)) - @as(c_int, 1))) : (i += 1) { + byteCount += sprintf(txtData + @as(usize, @bitCast(@as(isize, @intCast(byteCount)))), if (@import("std").zig.c_translation.signedRemainder(i, @as(c_int, 20)) == @as(c_int, 0)) "0x%x,\n" else "0x%x, ", @as(c_int, @bitCast(@as(c_uint, (blk: { + const tmp = i; + if (tmp >= 0) break :blk mesh.colors + @as(usize, @intCast(tmp)) else break :blk mesh.colors - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*)))); + } + } + byteCount += sprintf(txtData + @as(usize, @bitCast(@as(isize, @intCast(byteCount)))), "0x%x };\n\n", @as(c_int, @bitCast(@as(c_uint, (blk: { + const tmp = (mesh.vertexCount * @as(c_int, 4)) - @as(c_int, 1); + if (tmp >= 0) break :blk mesh.colors + @as(usize, @intCast(tmp)) else break :blk mesh.colors - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*)))); + } + if (mesh.indices != @as([*c]c_ushort, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0))))))) { + byteCount += sprintf(txtData + @as(usize, @bitCast(@as(isize, @intCast(byteCount)))), "static unsigned short %s_INDEX_DATA[%i] = { ", @as([*c]u8, @ptrCast(@alignCast(&varFileName))), mesh.triangleCount * @as(c_int, 3)); + { + var i: c_int = 0; + _ = &i; + while (i < ((mesh.triangleCount * @as(c_int, 3)) - @as(c_int, 1))) : (i += 1) { + byteCount += sprintf(txtData + @as(usize, @bitCast(@as(isize, @intCast(byteCount)))), if (@import("std").zig.c_translation.signedRemainder(i, @as(c_int, 20)) == @as(c_int, 0)) "%i,\n" else "%i, ", @as(c_int, @bitCast(@as(c_uint, (blk: { + const tmp = i; + if (tmp >= 0) break :blk mesh.indices + @as(usize, @intCast(tmp)) else break :blk mesh.indices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*)))); + } + } + byteCount += sprintf(txtData + @as(usize, @bitCast(@as(isize, @intCast(byteCount)))), "%i };\n", @as(c_int, @bitCast(@as(c_uint, (blk: { + const tmp = (mesh.triangleCount * @as(c_int, 3)) - @as(c_int, 1); + if (tmp >= 0) break :blk mesh.indices + @as(usize, @intCast(tmp)) else break :blk mesh.indices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*)))); + } + success = SaveFileText(fileName, txtData); + free(@as(?*anyopaque, @ptrCast(txtData))); + return success; +} +pub export fn GenMeshPoly(arg_sides: c_int, arg_radius: f32) Mesh { + var sides = arg_sides; + _ = &sides; + var radius = arg_radius; + _ = &radius; + var mesh: Mesh = Mesh{ + .vertexCount = @as(c_int, 0), + .triangleCount = 0, + .vertices = null, + .texcoords = null, + .texcoords2 = null, + .normals = null, + .tangents = null, + .colors = null, + .indices = null, + .animVertices = null, + .animNormals = null, + .boneIds = null, + .boneWeights = null, + .vaoId = 0, + .vboId = null, + }; + _ = &mesh; + if (sides < @as(c_int, 3)) return mesh; + var vertexCount: c_int = sides * @as(c_int, 3); + _ = &vertexCount; + var vertices: [*c]Vector3 = @as([*c]Vector3, @ptrCast(@alignCast(malloc(@as(c_ulong, @bitCast(@as(c_long, vertexCount))) *% @sizeOf(Vector3))))); + _ = &vertices; + var d: f32 = 0.0; + _ = &d; + var dStep: f32 = 360.0 / @as(f32, @floatFromInt(sides)); + _ = &dStep; + { + var v: c_int = 0; + _ = &v; + while (v < (vertexCount - @as(c_int, 2))) : (v += @as(c_int, 3)) { + (blk: { + const tmp = v; + if (tmp >= 0) break :blk vertices + @as(usize, @intCast(tmp)) else break :blk vertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = Vector3{ + .x = 0.0, + .y = 0.0, + .z = 0.0, + }; + (blk: { + const tmp = v + @as(c_int, 1); + if (tmp >= 0) break :blk vertices + @as(usize, @intCast(tmp)) else break :blk vertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = Vector3{ + .x = sinf((3.1415927410125732 / 180.0) * d) * radius, + .y = 0.0, + .z = cosf((3.1415927410125732 / 180.0) * d) * radius, + }; + (blk: { + const tmp = v + @as(c_int, 2); + if (tmp >= 0) break :blk vertices + @as(usize, @intCast(tmp)) else break :blk vertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = Vector3{ + .x = sinf((3.1415927410125732 / 180.0) * (d + dStep)) * radius, + .y = 0.0, + .z = cosf((3.1415927410125732 / 180.0) * (d + dStep)) * radius, + }; + d += dStep; + } + } + var normals: [*c]Vector3 = @as([*c]Vector3, @ptrCast(@alignCast(malloc(@as(c_ulong, @bitCast(@as(c_long, vertexCount))) *% @sizeOf(Vector3))))); + _ = &normals; + { + var n: c_int = 0; + _ = &n; + while (n < vertexCount) : (n += 1) { + (blk: { + const tmp = n; + if (tmp >= 0) break :blk normals + @as(usize, @intCast(tmp)) else break :blk normals - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = Vector3{ + .x = 0.0, + .y = 1.0, + .z = 0.0, + }; + } + } + var texcoords: [*c]Vector2 = @as([*c]Vector2, @ptrCast(@alignCast(malloc(@as(c_ulong, @bitCast(@as(c_long, vertexCount))) *% @sizeOf(Vector2))))); + _ = &texcoords; + { + var n: c_int = 0; + _ = &n; + while (n < vertexCount) : (n += 1) { + (blk: { + const tmp = n; + if (tmp >= 0) break :blk texcoords + @as(usize, @intCast(tmp)) else break :blk texcoords - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = Vector2{ + .x = 0.0, + .y = 0.0, + }; + } + } + mesh.vertexCount = vertexCount; + mesh.triangleCount = sides; + mesh.vertices = @as([*c]f32, @ptrCast(@alignCast(malloc(@as(c_ulong, @bitCast(@as(c_long, mesh.vertexCount * @as(c_int, 3)))) *% @sizeOf(f32))))); + mesh.texcoords = @as([*c]f32, @ptrCast(@alignCast(malloc(@as(c_ulong, @bitCast(@as(c_long, mesh.vertexCount * @as(c_int, 2)))) *% @sizeOf(f32))))); + mesh.normals = @as([*c]f32, @ptrCast(@alignCast(malloc(@as(c_ulong, @bitCast(@as(c_long, mesh.vertexCount * @as(c_int, 3)))) *% @sizeOf(f32))))); + { + var i: c_int = 0; + _ = &i; + while (i < mesh.vertexCount) : (i += 1) { + (blk: { + const tmp = @as(c_int, 3) * i; + if (tmp >= 0) break :blk mesh.vertices + @as(usize, @intCast(tmp)) else break :blk mesh.vertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = (blk: { + const tmp = i; + if (tmp >= 0) break :blk vertices + @as(usize, @intCast(tmp)) else break :blk vertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.x; + (blk: { + const tmp = (@as(c_int, 3) * i) + @as(c_int, 1); + if (tmp >= 0) break :blk mesh.vertices + @as(usize, @intCast(tmp)) else break :blk mesh.vertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = (blk: { + const tmp = i; + if (tmp >= 0) break :blk vertices + @as(usize, @intCast(tmp)) else break :blk vertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.y; + (blk: { + const tmp = (@as(c_int, 3) * i) + @as(c_int, 2); + if (tmp >= 0) break :blk mesh.vertices + @as(usize, @intCast(tmp)) else break :blk mesh.vertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = (blk: { + const tmp = i; + if (tmp >= 0) break :blk vertices + @as(usize, @intCast(tmp)) else break :blk vertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.z; + } + } + { + var i: c_int = 0; + _ = &i; + while (i < mesh.vertexCount) : (i += 1) { + (blk: { + const tmp = @as(c_int, 2) * i; + if (tmp >= 0) break :blk mesh.texcoords + @as(usize, @intCast(tmp)) else break :blk mesh.texcoords - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = (blk: { + const tmp = i; + if (tmp >= 0) break :blk texcoords + @as(usize, @intCast(tmp)) else break :blk texcoords - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.x; + (blk: { + const tmp = (@as(c_int, 2) * i) + @as(c_int, 1); + if (tmp >= 0) break :blk mesh.texcoords + @as(usize, @intCast(tmp)) else break :blk mesh.texcoords - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = (blk: { + const tmp = i; + if (tmp >= 0) break :blk texcoords + @as(usize, @intCast(tmp)) else break :blk texcoords - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.y; + } + } + { + var i: c_int = 0; + _ = &i; + while (i < mesh.vertexCount) : (i += 1) { + (blk: { + const tmp = @as(c_int, 3) * i; + if (tmp >= 0) break :blk mesh.normals + @as(usize, @intCast(tmp)) else break :blk mesh.normals - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = (blk: { + const tmp = i; + if (tmp >= 0) break :blk normals + @as(usize, @intCast(tmp)) else break :blk normals - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.x; + (blk: { + const tmp = (@as(c_int, 3) * i) + @as(c_int, 1); + if (tmp >= 0) break :blk mesh.normals + @as(usize, @intCast(tmp)) else break :blk mesh.normals - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = (blk: { + const tmp = i; + if (tmp >= 0) break :blk normals + @as(usize, @intCast(tmp)) else break :blk normals - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.y; + (blk: { + const tmp = (@as(c_int, 3) * i) + @as(c_int, 2); + if (tmp >= 0) break :blk mesh.normals + @as(usize, @intCast(tmp)) else break :blk mesh.normals - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = (blk: { + const tmp = i; + if (tmp >= 0) break :blk normals + @as(usize, @intCast(tmp)) else break :blk normals - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.z; + } + } + free(@as(?*anyopaque, @ptrCast(vertices))); + free(@as(?*anyopaque, @ptrCast(normals))); + free(@as(?*anyopaque, @ptrCast(texcoords))); + UploadMesh(&mesh, @as(c_int, 0) != 0); + return mesh; +} +pub export fn GenMeshPlane(arg_width: f32, arg_length: f32, arg_resX: c_int, arg_resZ: c_int) Mesh { + var width = arg_width; + _ = &width; + var length = arg_length; + _ = &length; + var resX = arg_resX; + _ = &resX; + var resZ = arg_resZ; + _ = &resZ; + var mesh: Mesh = Mesh{ + .vertexCount = @as(c_int, 0), + .triangleCount = 0, + .vertices = null, + .texcoords = null, + .texcoords2 = null, + .normals = null, + .tangents = null, + .colors = null, + .indices = null, + .animVertices = null, + .animNormals = null, + .boneIds = null, + .boneWeights = null, + .vaoId = 0, + .vboId = null, + }; + _ = &mesh; + resX += 1; + resZ += 1; + var vertexCount: c_int = resX * resZ; + _ = &vertexCount; + var vertices: [*c]Vector3 = @as([*c]Vector3, @ptrCast(@alignCast(malloc(@as(c_ulong, @bitCast(@as(c_long, vertexCount))) *% @sizeOf(Vector3))))); + _ = &vertices; + { + var z: c_int = 0; + _ = &z; + while (z < resZ) : (z += 1) { + var zPos: f32 = ((@as(f32, @floatFromInt(z)) / @as(f32, @floatFromInt(resZ - @as(c_int, 1)))) - 0.5) * length; + _ = &zPos; + { + var x: c_int = 0; + _ = &x; + while (x < resX) : (x += 1) { + var xPos: f32 = ((@as(f32, @floatFromInt(x)) / @as(f32, @floatFromInt(resX - @as(c_int, 1)))) - 0.5) * width; + _ = &xPos; + (blk: { + const tmp = x + (z * resX); + if (tmp >= 0) break :blk vertices + @as(usize, @intCast(tmp)) else break :blk vertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = Vector3{ + .x = xPos, + .y = 0.0, + .z = zPos, + }; + } + } + } + } + var normals: [*c]Vector3 = @as([*c]Vector3, @ptrCast(@alignCast(malloc(@as(c_ulong, @bitCast(@as(c_long, vertexCount))) *% @sizeOf(Vector3))))); + _ = &normals; + { + var n: c_int = 0; + _ = &n; + while (n < vertexCount) : (n += 1) { + (blk: { + const tmp = n; + if (tmp >= 0) break :blk normals + @as(usize, @intCast(tmp)) else break :blk normals - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = Vector3{ + .x = 0.0, + .y = 1.0, + .z = 0.0, + }; + } + } + var texcoords: [*c]Vector2 = @as([*c]Vector2, @ptrCast(@alignCast(malloc(@as(c_ulong, @bitCast(@as(c_long, vertexCount))) *% @sizeOf(Vector2))))); + _ = &texcoords; + { + var v: c_int = 0; + _ = &v; + while (v < resZ) : (v += 1) { + { + var u: c_int = 0; + _ = &u; + while (u < resX) : (u += 1) { + (blk: { + const tmp = u + (v * resX); + if (tmp >= 0) break :blk texcoords + @as(usize, @intCast(tmp)) else break :blk texcoords - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = Vector2{ + .x = @as(f32, @floatFromInt(u)) / @as(f32, @floatFromInt(resX - @as(c_int, 1))), + .y = @as(f32, @floatFromInt(v)) / @as(f32, @floatFromInt(resZ - @as(c_int, 1))), + }; + } + } + } + } + var numFaces: c_int = (resX - @as(c_int, 1)) * (resZ - @as(c_int, 1)); + _ = &numFaces; + var triangles: [*c]c_int = @as([*c]c_int, @ptrCast(@alignCast(malloc(@as(c_ulong, @bitCast(@as(c_long, numFaces * @as(c_int, 6)))) *% @sizeOf(c_int))))); + _ = &triangles; + var t: c_int = 0; + _ = &t; + { + var face: c_int = 0; + _ = &face; + while (face < numFaces) : (face += 1) { + var i: c_int = face + @divTrunc(face, resX - @as(c_int, 1)); + _ = &i; + (blk: { + const tmp = blk_1: { + const ref = &t; + const tmp_2 = ref.*; + ref.* += 1; + break :blk_1 tmp_2; + }; + if (tmp >= 0) break :blk triangles + @as(usize, @intCast(tmp)) else break :blk triangles - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = i + resX; + (blk: { + const tmp = blk_1: { + const ref = &t; + const tmp_2 = ref.*; + ref.* += 1; + break :blk_1 tmp_2; + }; + if (tmp >= 0) break :blk triangles + @as(usize, @intCast(tmp)) else break :blk triangles - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = i + @as(c_int, 1); + (blk: { + const tmp = blk_1: { + const ref = &t; + const tmp_2 = ref.*; + ref.* += 1; + break :blk_1 tmp_2; + }; + if (tmp >= 0) break :blk triangles + @as(usize, @intCast(tmp)) else break :blk triangles - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = i; + (blk: { + const tmp = blk_1: { + const ref = &t; + const tmp_2 = ref.*; + ref.* += 1; + break :blk_1 tmp_2; + }; + if (tmp >= 0) break :blk triangles + @as(usize, @intCast(tmp)) else break :blk triangles - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = i + resX; + (blk: { + const tmp = blk_1: { + const ref = &t; + const tmp_2 = ref.*; + ref.* += 1; + break :blk_1 tmp_2; + }; + if (tmp >= 0) break :blk triangles + @as(usize, @intCast(tmp)) else break :blk triangles - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = (i + resX) + @as(c_int, 1); + (blk: { + const tmp = blk_1: { + const ref = &t; + const tmp_2 = ref.*; + ref.* += 1; + break :blk_1 tmp_2; + }; + if (tmp >= 0) break :blk triangles + @as(usize, @intCast(tmp)) else break :blk triangles - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = i + @as(c_int, 1); + } + } + mesh.vertexCount = vertexCount; + mesh.triangleCount = numFaces * @as(c_int, 2); + mesh.vertices = @as([*c]f32, @ptrCast(@alignCast(malloc(@as(c_ulong, @bitCast(@as(c_long, mesh.vertexCount * @as(c_int, 3)))) *% @sizeOf(f32))))); + mesh.texcoords = @as([*c]f32, @ptrCast(@alignCast(malloc(@as(c_ulong, @bitCast(@as(c_long, mesh.vertexCount * @as(c_int, 2)))) *% @sizeOf(f32))))); + mesh.normals = @as([*c]f32, @ptrCast(@alignCast(malloc(@as(c_ulong, @bitCast(@as(c_long, mesh.vertexCount * @as(c_int, 3)))) *% @sizeOf(f32))))); + mesh.indices = @as([*c]c_ushort, @ptrCast(@alignCast(malloc(@as(c_ulong, @bitCast(@as(c_long, mesh.triangleCount * @as(c_int, 3)))) *% @sizeOf(c_ushort))))); + { + var i: c_int = 0; + _ = &i; + while (i < mesh.vertexCount) : (i += 1) { + (blk: { + const tmp = @as(c_int, 3) * i; + if (tmp >= 0) break :blk mesh.vertices + @as(usize, @intCast(tmp)) else break :blk mesh.vertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = (blk: { + const tmp = i; + if (tmp >= 0) break :blk vertices + @as(usize, @intCast(tmp)) else break :blk vertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.x; + (blk: { + const tmp = (@as(c_int, 3) * i) + @as(c_int, 1); + if (tmp >= 0) break :blk mesh.vertices + @as(usize, @intCast(tmp)) else break :blk mesh.vertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = (blk: { + const tmp = i; + if (tmp >= 0) break :blk vertices + @as(usize, @intCast(tmp)) else break :blk vertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.y; + (blk: { + const tmp = (@as(c_int, 3) * i) + @as(c_int, 2); + if (tmp >= 0) break :blk mesh.vertices + @as(usize, @intCast(tmp)) else break :blk mesh.vertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = (blk: { + const tmp = i; + if (tmp >= 0) break :blk vertices + @as(usize, @intCast(tmp)) else break :blk vertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.z; + } + } + { + var i: c_int = 0; + _ = &i; + while (i < mesh.vertexCount) : (i += 1) { + (blk: { + const tmp = @as(c_int, 2) * i; + if (tmp >= 0) break :blk mesh.texcoords + @as(usize, @intCast(tmp)) else break :blk mesh.texcoords - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = (blk: { + const tmp = i; + if (tmp >= 0) break :blk texcoords + @as(usize, @intCast(tmp)) else break :blk texcoords - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.x; + (blk: { + const tmp = (@as(c_int, 2) * i) + @as(c_int, 1); + if (tmp >= 0) break :blk mesh.texcoords + @as(usize, @intCast(tmp)) else break :blk mesh.texcoords - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = (blk: { + const tmp = i; + if (tmp >= 0) break :blk texcoords + @as(usize, @intCast(tmp)) else break :blk texcoords - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.y; + } + } + { + var i: c_int = 0; + _ = &i; + while (i < mesh.vertexCount) : (i += 1) { + (blk: { + const tmp = @as(c_int, 3) * i; + if (tmp >= 0) break :blk mesh.normals + @as(usize, @intCast(tmp)) else break :blk mesh.normals - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = (blk: { + const tmp = i; + if (tmp >= 0) break :blk normals + @as(usize, @intCast(tmp)) else break :blk normals - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.x; + (blk: { + const tmp = (@as(c_int, 3) * i) + @as(c_int, 1); + if (tmp >= 0) break :blk mesh.normals + @as(usize, @intCast(tmp)) else break :blk mesh.normals - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = (blk: { + const tmp = i; + if (tmp >= 0) break :blk normals + @as(usize, @intCast(tmp)) else break :blk normals - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.y; + (blk: { + const tmp = (@as(c_int, 3) * i) + @as(c_int, 2); + if (tmp >= 0) break :blk mesh.normals + @as(usize, @intCast(tmp)) else break :blk mesh.normals - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = (blk: { + const tmp = i; + if (tmp >= 0) break :blk normals + @as(usize, @intCast(tmp)) else break :blk normals - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.z; + } + } + { + var i: c_int = 0; + _ = &i; + while (i < (mesh.triangleCount * @as(c_int, 3))) : (i += 1) { + (blk: { + const tmp = i; + if (tmp >= 0) break :blk mesh.indices + @as(usize, @intCast(tmp)) else break :blk mesh.indices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = @as(c_ushort, @bitCast(@as(c_short, @truncate((blk: { + const tmp = i; + if (tmp >= 0) break :blk triangles + @as(usize, @intCast(tmp)) else break :blk triangles - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*)))); + } + } + free(@as(?*anyopaque, @ptrCast(vertices))); + free(@as(?*anyopaque, @ptrCast(normals))); + free(@as(?*anyopaque, @ptrCast(texcoords))); + free(@as(?*anyopaque, @ptrCast(triangles))); + UploadMesh(&mesh, @as(c_int, 0) != 0); + return mesh; +} +pub export fn GenMeshCube(arg_width: f32, arg_height: f32, arg_length: f32) Mesh { + var width = arg_width; + _ = &width; + var height = arg_height; + _ = &height; + var length = arg_length; + _ = &length; + var mesh: Mesh = Mesh{ + .vertexCount = @as(c_int, 0), + .triangleCount = 0, + .vertices = null, + .texcoords = null, + .texcoords2 = null, + .normals = null, + .tangents = null, + .colors = null, + .indices = null, + .animVertices = null, + .animNormals = null, + .boneIds = null, + .boneWeights = null, + .vaoId = 0, + .vboId = null, + }; + _ = &mesh; + var vertices: [72]f32 = [72]f32{ + -width / @as(f32, @floatFromInt(@as(c_int, 2))), + -height / @as(f32, @floatFromInt(@as(c_int, 2))), + length / @as(f32, @floatFromInt(@as(c_int, 2))), + width / @as(f32, @floatFromInt(@as(c_int, 2))), + -height / @as(f32, @floatFromInt(@as(c_int, 2))), + length / @as(f32, @floatFromInt(@as(c_int, 2))), + width / @as(f32, @floatFromInt(@as(c_int, 2))), + height / @as(f32, @floatFromInt(@as(c_int, 2))), + length / @as(f32, @floatFromInt(@as(c_int, 2))), + -width / @as(f32, @floatFromInt(@as(c_int, 2))), + height / @as(f32, @floatFromInt(@as(c_int, 2))), + length / @as(f32, @floatFromInt(@as(c_int, 2))), + -width / @as(f32, @floatFromInt(@as(c_int, 2))), + -height / @as(f32, @floatFromInt(@as(c_int, 2))), + -length / @as(f32, @floatFromInt(@as(c_int, 2))), + -width / @as(f32, @floatFromInt(@as(c_int, 2))), + height / @as(f32, @floatFromInt(@as(c_int, 2))), + -length / @as(f32, @floatFromInt(@as(c_int, 2))), + width / @as(f32, @floatFromInt(@as(c_int, 2))), + height / @as(f32, @floatFromInt(@as(c_int, 2))), + -length / @as(f32, @floatFromInt(@as(c_int, 2))), + width / @as(f32, @floatFromInt(@as(c_int, 2))), + -height / @as(f32, @floatFromInt(@as(c_int, 2))), + -length / @as(f32, @floatFromInt(@as(c_int, 2))), + -width / @as(f32, @floatFromInt(@as(c_int, 2))), + height / @as(f32, @floatFromInt(@as(c_int, 2))), + -length / @as(f32, @floatFromInt(@as(c_int, 2))), + -width / @as(f32, @floatFromInt(@as(c_int, 2))), + height / @as(f32, @floatFromInt(@as(c_int, 2))), + length / @as(f32, @floatFromInt(@as(c_int, 2))), + width / @as(f32, @floatFromInt(@as(c_int, 2))), + height / @as(f32, @floatFromInt(@as(c_int, 2))), + length / @as(f32, @floatFromInt(@as(c_int, 2))), + width / @as(f32, @floatFromInt(@as(c_int, 2))), + height / @as(f32, @floatFromInt(@as(c_int, 2))), + -length / @as(f32, @floatFromInt(@as(c_int, 2))), + -width / @as(f32, @floatFromInt(@as(c_int, 2))), + -height / @as(f32, @floatFromInt(@as(c_int, 2))), + -length / @as(f32, @floatFromInt(@as(c_int, 2))), + width / @as(f32, @floatFromInt(@as(c_int, 2))), + -height / @as(f32, @floatFromInt(@as(c_int, 2))), + -length / @as(f32, @floatFromInt(@as(c_int, 2))), + width / @as(f32, @floatFromInt(@as(c_int, 2))), + -height / @as(f32, @floatFromInt(@as(c_int, 2))), + length / @as(f32, @floatFromInt(@as(c_int, 2))), + -width / @as(f32, @floatFromInt(@as(c_int, 2))), + -height / @as(f32, @floatFromInt(@as(c_int, 2))), + length / @as(f32, @floatFromInt(@as(c_int, 2))), + width / @as(f32, @floatFromInt(@as(c_int, 2))), + -height / @as(f32, @floatFromInt(@as(c_int, 2))), + -length / @as(f32, @floatFromInt(@as(c_int, 2))), + width / @as(f32, @floatFromInt(@as(c_int, 2))), + height / @as(f32, @floatFromInt(@as(c_int, 2))), + -length / @as(f32, @floatFromInt(@as(c_int, 2))), + width / @as(f32, @floatFromInt(@as(c_int, 2))), + height / @as(f32, @floatFromInt(@as(c_int, 2))), + length / @as(f32, @floatFromInt(@as(c_int, 2))), + width / @as(f32, @floatFromInt(@as(c_int, 2))), + -height / @as(f32, @floatFromInt(@as(c_int, 2))), + length / @as(f32, @floatFromInt(@as(c_int, 2))), + -width / @as(f32, @floatFromInt(@as(c_int, 2))), + -height / @as(f32, @floatFromInt(@as(c_int, 2))), + -length / @as(f32, @floatFromInt(@as(c_int, 2))), + -width / @as(f32, @floatFromInt(@as(c_int, 2))), + -height / @as(f32, @floatFromInt(@as(c_int, 2))), + length / @as(f32, @floatFromInt(@as(c_int, 2))), + -width / @as(f32, @floatFromInt(@as(c_int, 2))), + height / @as(f32, @floatFromInt(@as(c_int, 2))), + length / @as(f32, @floatFromInt(@as(c_int, 2))), + -width / @as(f32, @floatFromInt(@as(c_int, 2))), + height / @as(f32, @floatFromInt(@as(c_int, 2))), + -length / @as(f32, @floatFromInt(@as(c_int, 2))), + }; + _ = &vertices; + var texcoords: [48]f32 = [48]f32{ + 0.0, + 0.0, + 1.0, + 0.0, + 1.0, + 1.0, + 0.0, + 1.0, + 1.0, + 0.0, + 1.0, + 1.0, + 0.0, + 1.0, + 0.0, + 0.0, + 0.0, + 1.0, + 0.0, + 0.0, + 1.0, + 0.0, + 1.0, + 1.0, + 1.0, + 1.0, + 0.0, + 1.0, + 0.0, + 0.0, + 1.0, + 0.0, + 1.0, + 0.0, + 1.0, + 1.0, + 0.0, + 1.0, + 0.0, + 0.0, + 0.0, + 0.0, + 1.0, + 0.0, + 1.0, + 1.0, + 0.0, + 1.0, + }; + _ = &texcoords; + var normals: [72]f32 = [72]f32{ + 0.0, + 0.0, + 1.0, + 0.0, + 0.0, + 1.0, + 0.0, + 0.0, + 1.0, + 0.0, + 0.0, + 1.0, + 0.0, + 0.0, + -1.0, + 0.0, + 0.0, + -1.0, + 0.0, + 0.0, + -1.0, + 0.0, + 0.0, + -1.0, + 0.0, + 1.0, + 0.0, + 0.0, + 1.0, + 0.0, + 0.0, + 1.0, + 0.0, + 0.0, + 1.0, + 0.0, + 0.0, + -1.0, + 0.0, + 0.0, + -1.0, + 0.0, + 0.0, + -1.0, + 0.0, + 0.0, + -1.0, + 0.0, + 1.0, + 0.0, + 0.0, + 1.0, + 0.0, + 0.0, + 1.0, + 0.0, + 0.0, + 1.0, + 0.0, + 0.0, + -1.0, + 0.0, + 0.0, + -1.0, + 0.0, + 0.0, + -1.0, + 0.0, + 0.0, + -1.0, + 0.0, + 0.0, + }; + _ = &normals; + mesh.vertices = @as([*c]f32, @ptrCast(@alignCast(malloc(@as(c_ulong, @bitCast(@as(c_long, @as(c_int, 24) * @as(c_int, 3)))) *% @sizeOf(f32))))); + _ = memcpy(@as(?*anyopaque, @ptrCast(mesh.vertices)), @as(?*const anyopaque, @ptrCast(@as([*c]f32, @ptrCast(@alignCast(&vertices))))), @as(c_ulong, @bitCast(@as(c_long, @as(c_int, 24) * @as(c_int, 3)))) *% @sizeOf(f32)); + mesh.texcoords = @as([*c]f32, @ptrCast(@alignCast(malloc(@as(c_ulong, @bitCast(@as(c_long, @as(c_int, 24) * @as(c_int, 2)))) *% @sizeOf(f32))))); + _ = memcpy(@as(?*anyopaque, @ptrCast(mesh.texcoords)), @as(?*const anyopaque, @ptrCast(@as([*c]f32, @ptrCast(@alignCast(&texcoords))))), @as(c_ulong, @bitCast(@as(c_long, @as(c_int, 24) * @as(c_int, 2)))) *% @sizeOf(f32)); + mesh.normals = @as([*c]f32, @ptrCast(@alignCast(malloc(@as(c_ulong, @bitCast(@as(c_long, @as(c_int, 24) * @as(c_int, 3)))) *% @sizeOf(f32))))); + _ = memcpy(@as(?*anyopaque, @ptrCast(mesh.normals)), @as(?*const anyopaque, @ptrCast(@as([*c]f32, @ptrCast(@alignCast(&normals))))), @as(c_ulong, @bitCast(@as(c_long, @as(c_int, 24) * @as(c_int, 3)))) *% @sizeOf(f32)); + mesh.indices = @as([*c]c_ushort, @ptrCast(@alignCast(malloc(@as(c_ulong, @bitCast(@as(c_long, @as(c_int, 36)))) *% @sizeOf(c_ushort))))); + var k: c_int = 0; + _ = &k; + { + var i: c_int = 0; + _ = &i; + while (i < @as(c_int, 36)) : (i += @as(c_int, 6)) { + (blk: { + const tmp = i; + if (tmp >= 0) break :blk mesh.indices + @as(usize, @intCast(tmp)) else break :blk mesh.indices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = @as(c_ushort, @bitCast(@as(c_short, @truncate(@as(c_int, 4) * k)))); + (blk: { + const tmp = i + @as(c_int, 1); + if (tmp >= 0) break :blk mesh.indices + @as(usize, @intCast(tmp)) else break :blk mesh.indices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = @as(c_ushort, @bitCast(@as(c_short, @truncate((@as(c_int, 4) * k) + @as(c_int, 1))))); + (blk: { + const tmp = i + @as(c_int, 2); + if (tmp >= 0) break :blk mesh.indices + @as(usize, @intCast(tmp)) else break :blk mesh.indices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = @as(c_ushort, @bitCast(@as(c_short, @truncate((@as(c_int, 4) * k) + @as(c_int, 2))))); + (blk: { + const tmp = i + @as(c_int, 3); + if (tmp >= 0) break :blk mesh.indices + @as(usize, @intCast(tmp)) else break :blk mesh.indices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = @as(c_ushort, @bitCast(@as(c_short, @truncate(@as(c_int, 4) * k)))); + (blk: { + const tmp = i + @as(c_int, 4); + if (tmp >= 0) break :blk mesh.indices + @as(usize, @intCast(tmp)) else break :blk mesh.indices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = @as(c_ushort, @bitCast(@as(c_short, @truncate((@as(c_int, 4) * k) + @as(c_int, 2))))); + (blk: { + const tmp = i + @as(c_int, 5); + if (tmp >= 0) break :blk mesh.indices + @as(usize, @intCast(tmp)) else break :blk mesh.indices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = @as(c_ushort, @bitCast(@as(c_short, @truncate((@as(c_int, 4) * k) + @as(c_int, 3))))); + k += 1; + } + } + mesh.vertexCount = 24; + mesh.triangleCount = 12; + UploadMesh(&mesh, @as(c_int, 0) != 0); + return mesh; +} +pub const struct_par_shapes_mesh_s = extern struct { + points: [*c]f32 = @import("std").mem.zeroes([*c]f32), + npoints: c_int = @import("std").mem.zeroes(c_int), + triangles: [*c]u16 = @import("std").mem.zeroes([*c]u16), + ntriangles: c_int = @import("std").mem.zeroes(c_int), + normals: [*c]f32 = @import("std").mem.zeroes([*c]f32), + tcoords: [*c]f32 = @import("std").mem.zeroes([*c]f32), +}; +pub const par_shapes_mesh = struct_par_shapes_mesh_s; +pub export fn GenMeshSphere(arg_radius: f32, arg_rings: c_int, arg_slices: c_int) Mesh { + var radius = arg_radius; + _ = &radius; + var rings = arg_rings; + _ = &rings; + var slices = arg_slices; + _ = &slices; + var mesh: Mesh = Mesh{ + .vertexCount = @as(c_int, 0), + .triangleCount = 0, + .vertices = null, + .texcoords = null, + .texcoords2 = null, + .normals = null, + .tangents = null, + .colors = null, + .indices = null, + .animVertices = null, + .animNormals = null, + .boneIds = null, + .boneWeights = null, + .vaoId = 0, + .vboId = null, + }; + _ = &mesh; + if ((rings >= @as(c_int, 3)) and (slices >= @as(c_int, 3))) { + var sphere: [*c]par_shapes_mesh = par_shapes_create_parametric_sphere(slices, rings); + _ = &sphere; + par_shapes_scale(sphere, radius, radius, radius); + mesh.vertices = @as([*c]f32, @ptrCast(@alignCast(malloc(@as(c_ulong, @bitCast(@as(c_long, (sphere.*.ntriangles * @as(c_int, 3)) * @as(c_int, 3)))) *% @sizeOf(f32))))); + mesh.texcoords = @as([*c]f32, @ptrCast(@alignCast(malloc(@as(c_ulong, @bitCast(@as(c_long, (sphere.*.ntriangles * @as(c_int, 3)) * @as(c_int, 2)))) *% @sizeOf(f32))))); + mesh.normals = @as([*c]f32, @ptrCast(@alignCast(malloc(@as(c_ulong, @bitCast(@as(c_long, (sphere.*.ntriangles * @as(c_int, 3)) * @as(c_int, 3)))) *% @sizeOf(f32))))); + mesh.vertexCount = sphere.*.ntriangles * @as(c_int, 3); + mesh.triangleCount = sphere.*.ntriangles; + { + var k: c_int = 0; + _ = &k; + while (k < mesh.vertexCount) : (k += 1) { + (blk: { + const tmp = k * @as(c_int, 3); + if (tmp >= 0) break :blk mesh.vertices + @as(usize, @intCast(tmp)) else break :blk mesh.vertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = (blk: { + const tmp = @as(c_int, @bitCast(@as(c_uint, (blk_1: { + const tmp_2 = k; + if (tmp_2 >= 0) break :blk_1 sphere.*.triangles + @as(usize, @intCast(tmp_2)) else break :blk_1 sphere.*.triangles - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*))) * @as(c_int, 3); + if (tmp >= 0) break :blk sphere.*.points + @as(usize, @intCast(tmp)) else break :blk sphere.*.points - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*; + (blk: { + const tmp = (k * @as(c_int, 3)) + @as(c_int, 1); + if (tmp >= 0) break :blk mesh.vertices + @as(usize, @intCast(tmp)) else break :blk mesh.vertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = (blk: { + const tmp = (@as(c_int, @bitCast(@as(c_uint, (blk_1: { + const tmp_2 = k; + if (tmp_2 >= 0) break :blk_1 sphere.*.triangles + @as(usize, @intCast(tmp_2)) else break :blk_1 sphere.*.triangles - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*))) * @as(c_int, 3)) + @as(c_int, 1); + if (tmp >= 0) break :blk sphere.*.points + @as(usize, @intCast(tmp)) else break :blk sphere.*.points - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*; + (blk: { + const tmp = (k * @as(c_int, 3)) + @as(c_int, 2); + if (tmp >= 0) break :blk mesh.vertices + @as(usize, @intCast(tmp)) else break :blk mesh.vertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = (blk: { + const tmp = (@as(c_int, @bitCast(@as(c_uint, (blk_1: { + const tmp_2 = k; + if (tmp_2 >= 0) break :blk_1 sphere.*.triangles + @as(usize, @intCast(tmp_2)) else break :blk_1 sphere.*.triangles - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*))) * @as(c_int, 3)) + @as(c_int, 2); + if (tmp >= 0) break :blk sphere.*.points + @as(usize, @intCast(tmp)) else break :blk sphere.*.points - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*; + (blk: { + const tmp = k * @as(c_int, 3); + if (tmp >= 0) break :blk mesh.normals + @as(usize, @intCast(tmp)) else break :blk mesh.normals - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = (blk: { + const tmp = @as(c_int, @bitCast(@as(c_uint, (blk_1: { + const tmp_2 = k; + if (tmp_2 >= 0) break :blk_1 sphere.*.triangles + @as(usize, @intCast(tmp_2)) else break :blk_1 sphere.*.triangles - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*))) * @as(c_int, 3); + if (tmp >= 0) break :blk sphere.*.normals + @as(usize, @intCast(tmp)) else break :blk sphere.*.normals - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*; + (blk: { + const tmp = (k * @as(c_int, 3)) + @as(c_int, 1); + if (tmp >= 0) break :blk mesh.normals + @as(usize, @intCast(tmp)) else break :blk mesh.normals - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = (blk: { + const tmp = (@as(c_int, @bitCast(@as(c_uint, (blk_1: { + const tmp_2 = k; + if (tmp_2 >= 0) break :blk_1 sphere.*.triangles + @as(usize, @intCast(tmp_2)) else break :blk_1 sphere.*.triangles - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*))) * @as(c_int, 3)) + @as(c_int, 1); + if (tmp >= 0) break :blk sphere.*.normals + @as(usize, @intCast(tmp)) else break :blk sphere.*.normals - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*; + (blk: { + const tmp = (k * @as(c_int, 3)) + @as(c_int, 2); + if (tmp >= 0) break :blk mesh.normals + @as(usize, @intCast(tmp)) else break :blk mesh.normals - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = (blk: { + const tmp = (@as(c_int, @bitCast(@as(c_uint, (blk_1: { + const tmp_2 = k; + if (tmp_2 >= 0) break :blk_1 sphere.*.triangles + @as(usize, @intCast(tmp_2)) else break :blk_1 sphere.*.triangles - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*))) * @as(c_int, 3)) + @as(c_int, 2); + if (tmp >= 0) break :blk sphere.*.normals + @as(usize, @intCast(tmp)) else break :blk sphere.*.normals - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*; + (blk: { + const tmp = k * @as(c_int, 2); + if (tmp >= 0) break :blk mesh.texcoords + @as(usize, @intCast(tmp)) else break :blk mesh.texcoords - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = (blk: { + const tmp = @as(c_int, @bitCast(@as(c_uint, (blk_1: { + const tmp_2 = k; + if (tmp_2 >= 0) break :blk_1 sphere.*.triangles + @as(usize, @intCast(tmp_2)) else break :blk_1 sphere.*.triangles - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*))) * @as(c_int, 2); + if (tmp >= 0) break :blk sphere.*.tcoords + @as(usize, @intCast(tmp)) else break :blk sphere.*.tcoords - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*; + (blk: { + const tmp = (k * @as(c_int, 2)) + @as(c_int, 1); + if (tmp >= 0) break :blk mesh.texcoords + @as(usize, @intCast(tmp)) else break :blk mesh.texcoords - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = (blk: { + const tmp = (@as(c_int, @bitCast(@as(c_uint, (blk_1: { + const tmp_2 = k; + if (tmp_2 >= 0) break :blk_1 sphere.*.triangles + @as(usize, @intCast(tmp_2)) else break :blk_1 sphere.*.triangles - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*))) * @as(c_int, 2)) + @as(c_int, 1); + if (tmp >= 0) break :blk sphere.*.tcoords + @as(usize, @intCast(tmp)) else break :blk sphere.*.tcoords - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*; + } + } + par_shapes_free_mesh(sphere); + UploadMesh(&mesh, @as(c_int, 0) != 0); + } else { + TraceLog(LOG_WARNING, "MESH: Failed to generate mesh: sphere"); + } + return mesh; +} +pub export fn GenMeshHemiSphere(arg_radius: f32, arg_rings: c_int, arg_slices: c_int) Mesh { + var radius = arg_radius; + _ = &radius; + var rings = arg_rings; + _ = &rings; + var slices = arg_slices; + _ = &slices; + var mesh: Mesh = Mesh{ + .vertexCount = @as(c_int, 0), + .triangleCount = 0, + .vertices = null, + .texcoords = null, + .texcoords2 = null, + .normals = null, + .tangents = null, + .colors = null, + .indices = null, + .animVertices = null, + .animNormals = null, + .boneIds = null, + .boneWeights = null, + .vaoId = 0, + .vboId = null, + }; + _ = &mesh; + if ((rings >= @as(c_int, 3)) and (slices >= @as(c_int, 3))) { + if (radius < 0.0) { + radius = 0.0; + } + var sphere: [*c]par_shapes_mesh = par_shapes_create_hemisphere(slices, rings); + _ = &sphere; + par_shapes_scale(sphere, radius, radius, radius); + mesh.vertices = @as([*c]f32, @ptrCast(@alignCast(malloc(@as(c_ulong, @bitCast(@as(c_long, (sphere.*.ntriangles * @as(c_int, 3)) * @as(c_int, 3)))) *% @sizeOf(f32))))); + mesh.texcoords = @as([*c]f32, @ptrCast(@alignCast(malloc(@as(c_ulong, @bitCast(@as(c_long, (sphere.*.ntriangles * @as(c_int, 3)) * @as(c_int, 2)))) *% @sizeOf(f32))))); + mesh.normals = @as([*c]f32, @ptrCast(@alignCast(malloc(@as(c_ulong, @bitCast(@as(c_long, (sphere.*.ntriangles * @as(c_int, 3)) * @as(c_int, 3)))) *% @sizeOf(f32))))); + mesh.vertexCount = sphere.*.ntriangles * @as(c_int, 3); + mesh.triangleCount = sphere.*.ntriangles; + { + var k: c_int = 0; + _ = &k; + while (k < mesh.vertexCount) : (k += 1) { + (blk: { + const tmp = k * @as(c_int, 3); + if (tmp >= 0) break :blk mesh.vertices + @as(usize, @intCast(tmp)) else break :blk mesh.vertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = (blk: { + const tmp = @as(c_int, @bitCast(@as(c_uint, (blk_1: { + const tmp_2 = k; + if (tmp_2 >= 0) break :blk_1 sphere.*.triangles + @as(usize, @intCast(tmp_2)) else break :blk_1 sphere.*.triangles - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*))) * @as(c_int, 3); + if (tmp >= 0) break :blk sphere.*.points + @as(usize, @intCast(tmp)) else break :blk sphere.*.points - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*; + (blk: { + const tmp = (k * @as(c_int, 3)) + @as(c_int, 1); + if (tmp >= 0) break :blk mesh.vertices + @as(usize, @intCast(tmp)) else break :blk mesh.vertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = (blk: { + const tmp = (@as(c_int, @bitCast(@as(c_uint, (blk_1: { + const tmp_2 = k; + if (tmp_2 >= 0) break :blk_1 sphere.*.triangles + @as(usize, @intCast(tmp_2)) else break :blk_1 sphere.*.triangles - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*))) * @as(c_int, 3)) + @as(c_int, 1); + if (tmp >= 0) break :blk sphere.*.points + @as(usize, @intCast(tmp)) else break :blk sphere.*.points - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*; + (blk: { + const tmp = (k * @as(c_int, 3)) + @as(c_int, 2); + if (tmp >= 0) break :blk mesh.vertices + @as(usize, @intCast(tmp)) else break :blk mesh.vertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = (blk: { + const tmp = (@as(c_int, @bitCast(@as(c_uint, (blk_1: { + const tmp_2 = k; + if (tmp_2 >= 0) break :blk_1 sphere.*.triangles + @as(usize, @intCast(tmp_2)) else break :blk_1 sphere.*.triangles - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*))) * @as(c_int, 3)) + @as(c_int, 2); + if (tmp >= 0) break :blk sphere.*.points + @as(usize, @intCast(tmp)) else break :blk sphere.*.points - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*; + (blk: { + const tmp = k * @as(c_int, 3); + if (tmp >= 0) break :blk mesh.normals + @as(usize, @intCast(tmp)) else break :blk mesh.normals - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = (blk: { + const tmp = @as(c_int, @bitCast(@as(c_uint, (blk_1: { + const tmp_2 = k; + if (tmp_2 >= 0) break :blk_1 sphere.*.triangles + @as(usize, @intCast(tmp_2)) else break :blk_1 sphere.*.triangles - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*))) * @as(c_int, 3); + if (tmp >= 0) break :blk sphere.*.normals + @as(usize, @intCast(tmp)) else break :blk sphere.*.normals - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*; + (blk: { + const tmp = (k * @as(c_int, 3)) + @as(c_int, 1); + if (tmp >= 0) break :blk mesh.normals + @as(usize, @intCast(tmp)) else break :blk mesh.normals - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = (blk: { + const tmp = (@as(c_int, @bitCast(@as(c_uint, (blk_1: { + const tmp_2 = k; + if (tmp_2 >= 0) break :blk_1 sphere.*.triangles + @as(usize, @intCast(tmp_2)) else break :blk_1 sphere.*.triangles - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*))) * @as(c_int, 3)) + @as(c_int, 1); + if (tmp >= 0) break :blk sphere.*.normals + @as(usize, @intCast(tmp)) else break :blk sphere.*.normals - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*; + (blk: { + const tmp = (k * @as(c_int, 3)) + @as(c_int, 2); + if (tmp >= 0) break :blk mesh.normals + @as(usize, @intCast(tmp)) else break :blk mesh.normals - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = (blk: { + const tmp = (@as(c_int, @bitCast(@as(c_uint, (blk_1: { + const tmp_2 = k; + if (tmp_2 >= 0) break :blk_1 sphere.*.triangles + @as(usize, @intCast(tmp_2)) else break :blk_1 sphere.*.triangles - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*))) * @as(c_int, 3)) + @as(c_int, 2); + if (tmp >= 0) break :blk sphere.*.normals + @as(usize, @intCast(tmp)) else break :blk sphere.*.normals - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*; + (blk: { + const tmp = k * @as(c_int, 2); + if (tmp >= 0) break :blk mesh.texcoords + @as(usize, @intCast(tmp)) else break :blk mesh.texcoords - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = (blk: { + const tmp = @as(c_int, @bitCast(@as(c_uint, (blk_1: { + const tmp_2 = k; + if (tmp_2 >= 0) break :blk_1 sphere.*.triangles + @as(usize, @intCast(tmp_2)) else break :blk_1 sphere.*.triangles - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*))) * @as(c_int, 2); + if (tmp >= 0) break :blk sphere.*.tcoords + @as(usize, @intCast(tmp)) else break :blk sphere.*.tcoords - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*; + (blk: { + const tmp = (k * @as(c_int, 2)) + @as(c_int, 1); + if (tmp >= 0) break :blk mesh.texcoords + @as(usize, @intCast(tmp)) else break :blk mesh.texcoords - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = (blk: { + const tmp = (@as(c_int, @bitCast(@as(c_uint, (blk_1: { + const tmp_2 = k; + if (tmp_2 >= 0) break :blk_1 sphere.*.triangles + @as(usize, @intCast(tmp_2)) else break :blk_1 sphere.*.triangles - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*))) * @as(c_int, 2)) + @as(c_int, 1); + if (tmp >= 0) break :blk sphere.*.tcoords + @as(usize, @intCast(tmp)) else break :blk sphere.*.tcoords - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*; + } + } + par_shapes_free_mesh(sphere); + UploadMesh(&mesh, @as(c_int, 0) != 0); + } else { + TraceLog(LOG_WARNING, "MESH: Failed to generate mesh: hemisphere"); + } + return mesh; +} +pub export fn GenMeshCylinder(arg_radius: f32, arg_height: f32, arg_slices: c_int) Mesh { + var radius = arg_radius; + _ = &radius; + var height = arg_height; + _ = &height; + var slices = arg_slices; + _ = &slices; + var mesh: Mesh = Mesh{ + .vertexCount = @as(c_int, 0), + .triangleCount = 0, + .vertices = null, + .texcoords = null, + .texcoords2 = null, + .normals = null, + .tangents = null, + .colors = null, + .indices = null, + .animVertices = null, + .animNormals = null, + .boneIds = null, + .boneWeights = null, + .vaoId = 0, + .vboId = null, + }; + _ = &mesh; + if (slices >= @as(c_int, 3)) { + var cylinder: [*c]par_shapes_mesh = par_shapes_create_cylinder(slices, @as(c_int, 8)); + _ = &cylinder; + par_shapes_scale(cylinder, radius, radius, height); + par_shapes_rotate(cylinder, -3.1415927410125732 / 2.0, @as([*c]f32, @ptrCast(@alignCast(&([3]f32{ + 1, + 0, + 0, + }))))); + var capTop: [*c]par_shapes_mesh = par_shapes_create_disk(radius, slices, @as([*c]f32, @ptrCast(@alignCast(&([3]f32{ + 0, + 0, + 0, + })))), @as([*c]f32, @ptrCast(@alignCast(&([3]f32{ + 0, + 0, + 1, + }))))); + _ = &capTop; + capTop.*.tcoords = @as([*c]f32, @ptrCast(@alignCast(malloc(@as(c_ulong, @bitCast(@as(c_long, @as(c_int, 2) * capTop.*.npoints))) *% @sizeOf(f32))))); + { + var i: c_int = 0; + _ = &i; + while (i < (@as(c_int, 2) * capTop.*.npoints)) : (i += 1) { + (blk: { + const tmp = i; + if (tmp >= 0) break :blk capTop.*.tcoords + @as(usize, @intCast(tmp)) else break :blk capTop.*.tcoords - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = 0.0; + } + } + par_shapes_rotate(capTop, -3.1415927410125732 / 2.0, @as([*c]f32, @ptrCast(@alignCast(&([3]f32{ + 1, + 0, + 0, + }))))); + par_shapes_rotate(capTop, @as(f32, @floatFromInt(@as(c_int, 90))) * (3.1415927410125732 / 180.0), @as([*c]f32, @ptrCast(@alignCast(&([3]f32{ + 0, + 1, + 0, + }))))); + par_shapes_translate(capTop, @as(f32, @floatFromInt(@as(c_int, 0))), height, @as(f32, @floatFromInt(@as(c_int, 0)))); + var capBottom: [*c]par_shapes_mesh = par_shapes_create_disk(radius, slices, @as([*c]f32, @ptrCast(@alignCast(&([3]f32{ + 0, + 0, + 0, + })))), @as([*c]f32, @ptrCast(@alignCast(&([3]f32{ + 0, + 0, + @as(f32, @floatFromInt(-@as(c_int, 1))), + }))))); + _ = &capBottom; + capBottom.*.tcoords = @as([*c]f32, @ptrCast(@alignCast(malloc(@as(c_ulong, @bitCast(@as(c_long, @as(c_int, 2) * capBottom.*.npoints))) *% @sizeOf(f32))))); + { + var i: c_int = 0; + _ = &i; + while (i < (@as(c_int, 2) * capBottom.*.npoints)) : (i += 1) { + (blk: { + const tmp = i; + if (tmp >= 0) break :blk capBottom.*.tcoords + @as(usize, @intCast(tmp)) else break :blk capBottom.*.tcoords - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = 0.949999988079071; + } + } + par_shapes_rotate(capBottom, 3.1415927410125732 / 2.0, @as([*c]f32, @ptrCast(@alignCast(&([3]f32{ + 1, + 0, + 0, + }))))); + par_shapes_rotate(capBottom, @as(f32, @floatFromInt(-@as(c_int, 90))) * (3.1415927410125732 / 180.0), @as([*c]f32, @ptrCast(@alignCast(&([3]f32{ + 0, + 1, + 0, + }))))); + par_shapes_merge_and_free(cylinder, capTop); + par_shapes_merge_and_free(cylinder, capBottom); + mesh.vertices = @as([*c]f32, @ptrCast(@alignCast(malloc(@as(c_ulong, @bitCast(@as(c_long, (cylinder.*.ntriangles * @as(c_int, 3)) * @as(c_int, 3)))) *% @sizeOf(f32))))); + mesh.texcoords = @as([*c]f32, @ptrCast(@alignCast(malloc(@as(c_ulong, @bitCast(@as(c_long, (cylinder.*.ntriangles * @as(c_int, 3)) * @as(c_int, 2)))) *% @sizeOf(f32))))); + mesh.normals = @as([*c]f32, @ptrCast(@alignCast(malloc(@as(c_ulong, @bitCast(@as(c_long, (cylinder.*.ntriangles * @as(c_int, 3)) * @as(c_int, 3)))) *% @sizeOf(f32))))); + mesh.vertexCount = cylinder.*.ntriangles * @as(c_int, 3); + mesh.triangleCount = cylinder.*.ntriangles; + { + var k: c_int = 0; + _ = &k; + while (k < mesh.vertexCount) : (k += 1) { + (blk: { + const tmp = k * @as(c_int, 3); + if (tmp >= 0) break :blk mesh.vertices + @as(usize, @intCast(tmp)) else break :blk mesh.vertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = (blk: { + const tmp = @as(c_int, @bitCast(@as(c_uint, (blk_1: { + const tmp_2 = k; + if (tmp_2 >= 0) break :blk_1 cylinder.*.triangles + @as(usize, @intCast(tmp_2)) else break :blk_1 cylinder.*.triangles - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*))) * @as(c_int, 3); + if (tmp >= 0) break :blk cylinder.*.points + @as(usize, @intCast(tmp)) else break :blk cylinder.*.points - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*; + (blk: { + const tmp = (k * @as(c_int, 3)) + @as(c_int, 1); + if (tmp >= 0) break :blk mesh.vertices + @as(usize, @intCast(tmp)) else break :blk mesh.vertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = (blk: { + const tmp = (@as(c_int, @bitCast(@as(c_uint, (blk_1: { + const tmp_2 = k; + if (tmp_2 >= 0) break :blk_1 cylinder.*.triangles + @as(usize, @intCast(tmp_2)) else break :blk_1 cylinder.*.triangles - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*))) * @as(c_int, 3)) + @as(c_int, 1); + if (tmp >= 0) break :blk cylinder.*.points + @as(usize, @intCast(tmp)) else break :blk cylinder.*.points - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*; + (blk: { + const tmp = (k * @as(c_int, 3)) + @as(c_int, 2); + if (tmp >= 0) break :blk mesh.vertices + @as(usize, @intCast(tmp)) else break :blk mesh.vertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = (blk: { + const tmp = (@as(c_int, @bitCast(@as(c_uint, (blk_1: { + const tmp_2 = k; + if (tmp_2 >= 0) break :blk_1 cylinder.*.triangles + @as(usize, @intCast(tmp_2)) else break :blk_1 cylinder.*.triangles - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*))) * @as(c_int, 3)) + @as(c_int, 2); + if (tmp >= 0) break :blk cylinder.*.points + @as(usize, @intCast(tmp)) else break :blk cylinder.*.points - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*; + (blk: { + const tmp = k * @as(c_int, 3); + if (tmp >= 0) break :blk mesh.normals + @as(usize, @intCast(tmp)) else break :blk mesh.normals - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = (blk: { + const tmp = @as(c_int, @bitCast(@as(c_uint, (blk_1: { + const tmp_2 = k; + if (tmp_2 >= 0) break :blk_1 cylinder.*.triangles + @as(usize, @intCast(tmp_2)) else break :blk_1 cylinder.*.triangles - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*))) * @as(c_int, 3); + if (tmp >= 0) break :blk cylinder.*.normals + @as(usize, @intCast(tmp)) else break :blk cylinder.*.normals - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*; + (blk: { + const tmp = (k * @as(c_int, 3)) + @as(c_int, 1); + if (tmp >= 0) break :blk mesh.normals + @as(usize, @intCast(tmp)) else break :blk mesh.normals - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = (blk: { + const tmp = (@as(c_int, @bitCast(@as(c_uint, (blk_1: { + const tmp_2 = k; + if (tmp_2 >= 0) break :blk_1 cylinder.*.triangles + @as(usize, @intCast(tmp_2)) else break :blk_1 cylinder.*.triangles - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*))) * @as(c_int, 3)) + @as(c_int, 1); + if (tmp >= 0) break :blk cylinder.*.normals + @as(usize, @intCast(tmp)) else break :blk cylinder.*.normals - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*; + (blk: { + const tmp = (k * @as(c_int, 3)) + @as(c_int, 2); + if (tmp >= 0) break :blk mesh.normals + @as(usize, @intCast(tmp)) else break :blk mesh.normals - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = (blk: { + const tmp = (@as(c_int, @bitCast(@as(c_uint, (blk_1: { + const tmp_2 = k; + if (tmp_2 >= 0) break :blk_1 cylinder.*.triangles + @as(usize, @intCast(tmp_2)) else break :blk_1 cylinder.*.triangles - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*))) * @as(c_int, 3)) + @as(c_int, 2); + if (tmp >= 0) break :blk cylinder.*.normals + @as(usize, @intCast(tmp)) else break :blk cylinder.*.normals - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*; + (blk: { + const tmp = k * @as(c_int, 2); + if (tmp >= 0) break :blk mesh.texcoords + @as(usize, @intCast(tmp)) else break :blk mesh.texcoords - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = (blk: { + const tmp = @as(c_int, @bitCast(@as(c_uint, (blk_1: { + const tmp_2 = k; + if (tmp_2 >= 0) break :blk_1 cylinder.*.triangles + @as(usize, @intCast(tmp_2)) else break :blk_1 cylinder.*.triangles - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*))) * @as(c_int, 2); + if (tmp >= 0) break :blk cylinder.*.tcoords + @as(usize, @intCast(tmp)) else break :blk cylinder.*.tcoords - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*; + (blk: { + const tmp = (k * @as(c_int, 2)) + @as(c_int, 1); + if (tmp >= 0) break :blk mesh.texcoords + @as(usize, @intCast(tmp)) else break :blk mesh.texcoords - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = (blk: { + const tmp = (@as(c_int, @bitCast(@as(c_uint, (blk_1: { + const tmp_2 = k; + if (tmp_2 >= 0) break :blk_1 cylinder.*.triangles + @as(usize, @intCast(tmp_2)) else break :blk_1 cylinder.*.triangles - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*))) * @as(c_int, 2)) + @as(c_int, 1); + if (tmp >= 0) break :blk cylinder.*.tcoords + @as(usize, @intCast(tmp)) else break :blk cylinder.*.tcoords - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*; + } + } + par_shapes_free_mesh(cylinder); + UploadMesh(&mesh, @as(c_int, 0) != 0); + } else { + TraceLog(LOG_WARNING, "MESH: Failed to generate mesh: cylinder"); + } + return mesh; +} +pub export fn GenMeshCone(arg_radius: f32, arg_height: f32, arg_slices: c_int) Mesh { + var radius = arg_radius; + _ = &radius; + var height = arg_height; + _ = &height; + var slices = arg_slices; + _ = &slices; + var mesh: Mesh = Mesh{ + .vertexCount = @as(c_int, 0), + .triangleCount = 0, + .vertices = null, + .texcoords = null, + .texcoords2 = null, + .normals = null, + .tangents = null, + .colors = null, + .indices = null, + .animVertices = null, + .animNormals = null, + .boneIds = null, + .boneWeights = null, + .vaoId = 0, + .vboId = null, + }; + _ = &mesh; + if (slices >= @as(c_int, 3)) { + var cone: [*c]par_shapes_mesh = par_shapes_create_cone(slices, @as(c_int, 8)); + _ = &cone; + par_shapes_scale(cone, radius, radius, height); + par_shapes_rotate(cone, -3.1415927410125732 / 2.0, @as([*c]f32, @ptrCast(@alignCast(&([3]f32{ + 1, + 0, + 0, + }))))); + par_shapes_rotate(cone, 3.1415927410125732 / 2.0, @as([*c]f32, @ptrCast(@alignCast(&([3]f32{ + 0, + 1, + 0, + }))))); + var capBottom: [*c]par_shapes_mesh = par_shapes_create_disk(radius, slices, @as([*c]f32, @ptrCast(@alignCast(&([3]f32{ + 0, + 0, + 0, + })))), @as([*c]f32, @ptrCast(@alignCast(&([3]f32{ + 0, + 0, + @as(f32, @floatFromInt(-@as(c_int, 1))), + }))))); + _ = &capBottom; + capBottom.*.tcoords = @as([*c]f32, @ptrCast(@alignCast(malloc(@as(c_ulong, @bitCast(@as(c_long, @as(c_int, 2) * capBottom.*.npoints))) *% @sizeOf(f32))))); + { + var i: c_int = 0; + _ = &i; + while (i < (@as(c_int, 2) * capBottom.*.npoints)) : (i += 1) { + (blk: { + const tmp = i; + if (tmp >= 0) break :blk capBottom.*.tcoords + @as(usize, @intCast(tmp)) else break :blk capBottom.*.tcoords - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = 0.949999988079071; + } + } + par_shapes_rotate(capBottom, 3.1415927410125732 / 2.0, @as([*c]f32, @ptrCast(@alignCast(&([3]f32{ + 1, + 0, + 0, + }))))); + par_shapes_merge_and_free(cone, capBottom); + mesh.vertices = @as([*c]f32, @ptrCast(@alignCast(malloc(@as(c_ulong, @bitCast(@as(c_long, (cone.*.ntriangles * @as(c_int, 3)) * @as(c_int, 3)))) *% @sizeOf(f32))))); + mesh.texcoords = @as([*c]f32, @ptrCast(@alignCast(malloc(@as(c_ulong, @bitCast(@as(c_long, (cone.*.ntriangles * @as(c_int, 3)) * @as(c_int, 2)))) *% @sizeOf(f32))))); + mesh.normals = @as([*c]f32, @ptrCast(@alignCast(malloc(@as(c_ulong, @bitCast(@as(c_long, (cone.*.ntriangles * @as(c_int, 3)) * @as(c_int, 3)))) *% @sizeOf(f32))))); + mesh.vertexCount = cone.*.ntriangles * @as(c_int, 3); + mesh.triangleCount = cone.*.ntriangles; + { + var k: c_int = 0; + _ = &k; + while (k < mesh.vertexCount) : (k += 1) { + (blk: { + const tmp = k * @as(c_int, 3); + if (tmp >= 0) break :blk mesh.vertices + @as(usize, @intCast(tmp)) else break :blk mesh.vertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = (blk: { + const tmp = @as(c_int, @bitCast(@as(c_uint, (blk_1: { + const tmp_2 = k; + if (tmp_2 >= 0) break :blk_1 cone.*.triangles + @as(usize, @intCast(tmp_2)) else break :blk_1 cone.*.triangles - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*))) * @as(c_int, 3); + if (tmp >= 0) break :blk cone.*.points + @as(usize, @intCast(tmp)) else break :blk cone.*.points - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*; + (blk: { + const tmp = (k * @as(c_int, 3)) + @as(c_int, 1); + if (tmp >= 0) break :blk mesh.vertices + @as(usize, @intCast(tmp)) else break :blk mesh.vertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = (blk: { + const tmp = (@as(c_int, @bitCast(@as(c_uint, (blk_1: { + const tmp_2 = k; + if (tmp_2 >= 0) break :blk_1 cone.*.triangles + @as(usize, @intCast(tmp_2)) else break :blk_1 cone.*.triangles - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*))) * @as(c_int, 3)) + @as(c_int, 1); + if (tmp >= 0) break :blk cone.*.points + @as(usize, @intCast(tmp)) else break :blk cone.*.points - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*; + (blk: { + const tmp = (k * @as(c_int, 3)) + @as(c_int, 2); + if (tmp >= 0) break :blk mesh.vertices + @as(usize, @intCast(tmp)) else break :blk mesh.vertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = (blk: { + const tmp = (@as(c_int, @bitCast(@as(c_uint, (blk_1: { + const tmp_2 = k; + if (tmp_2 >= 0) break :blk_1 cone.*.triangles + @as(usize, @intCast(tmp_2)) else break :blk_1 cone.*.triangles - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*))) * @as(c_int, 3)) + @as(c_int, 2); + if (tmp >= 0) break :blk cone.*.points + @as(usize, @intCast(tmp)) else break :blk cone.*.points - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*; + (blk: { + const tmp = k * @as(c_int, 3); + if (tmp >= 0) break :blk mesh.normals + @as(usize, @intCast(tmp)) else break :blk mesh.normals - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = (blk: { + const tmp = @as(c_int, @bitCast(@as(c_uint, (blk_1: { + const tmp_2 = k; + if (tmp_2 >= 0) break :blk_1 cone.*.triangles + @as(usize, @intCast(tmp_2)) else break :blk_1 cone.*.triangles - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*))) * @as(c_int, 3); + if (tmp >= 0) break :blk cone.*.normals + @as(usize, @intCast(tmp)) else break :blk cone.*.normals - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*; + (blk: { + const tmp = (k * @as(c_int, 3)) + @as(c_int, 1); + if (tmp >= 0) break :blk mesh.normals + @as(usize, @intCast(tmp)) else break :blk mesh.normals - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = (blk: { + const tmp = (@as(c_int, @bitCast(@as(c_uint, (blk_1: { + const tmp_2 = k; + if (tmp_2 >= 0) break :blk_1 cone.*.triangles + @as(usize, @intCast(tmp_2)) else break :blk_1 cone.*.triangles - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*))) * @as(c_int, 3)) + @as(c_int, 1); + if (tmp >= 0) break :blk cone.*.normals + @as(usize, @intCast(tmp)) else break :blk cone.*.normals - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*; + (blk: { + const tmp = (k * @as(c_int, 3)) + @as(c_int, 2); + if (tmp >= 0) break :blk mesh.normals + @as(usize, @intCast(tmp)) else break :blk mesh.normals - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = (blk: { + const tmp = (@as(c_int, @bitCast(@as(c_uint, (blk_1: { + const tmp_2 = k; + if (tmp_2 >= 0) break :blk_1 cone.*.triangles + @as(usize, @intCast(tmp_2)) else break :blk_1 cone.*.triangles - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*))) * @as(c_int, 3)) + @as(c_int, 2); + if (tmp >= 0) break :blk cone.*.normals + @as(usize, @intCast(tmp)) else break :blk cone.*.normals - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*; + (blk: { + const tmp = k * @as(c_int, 2); + if (tmp >= 0) break :blk mesh.texcoords + @as(usize, @intCast(tmp)) else break :blk mesh.texcoords - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = (blk: { + const tmp = @as(c_int, @bitCast(@as(c_uint, (blk_1: { + const tmp_2 = k; + if (tmp_2 >= 0) break :blk_1 cone.*.triangles + @as(usize, @intCast(tmp_2)) else break :blk_1 cone.*.triangles - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*))) * @as(c_int, 2); + if (tmp >= 0) break :blk cone.*.tcoords + @as(usize, @intCast(tmp)) else break :blk cone.*.tcoords - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*; + (blk: { + const tmp = (k * @as(c_int, 2)) + @as(c_int, 1); + if (tmp >= 0) break :blk mesh.texcoords + @as(usize, @intCast(tmp)) else break :blk mesh.texcoords - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = (blk: { + const tmp = (@as(c_int, @bitCast(@as(c_uint, (blk_1: { + const tmp_2 = k; + if (tmp_2 >= 0) break :blk_1 cone.*.triangles + @as(usize, @intCast(tmp_2)) else break :blk_1 cone.*.triangles - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*))) * @as(c_int, 2)) + @as(c_int, 1); + if (tmp >= 0) break :blk cone.*.tcoords + @as(usize, @intCast(tmp)) else break :blk cone.*.tcoords - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*; + } + } + par_shapes_free_mesh(cone); + UploadMesh(&mesh, @as(c_int, 0) != 0); + } else { + TraceLog(LOG_WARNING, "MESH: Failed to generate mesh: cone"); + } + return mesh; +} +pub export fn GenMeshTorus(arg_radius: f32, arg_size: f32, arg_radSeg: c_int, arg_sides: c_int) Mesh { + var radius = arg_radius; + _ = &radius; + var size = arg_size; + _ = &size; + var radSeg = arg_radSeg; + _ = &radSeg; + var sides = arg_sides; + _ = &sides; + var mesh: Mesh = Mesh{ + .vertexCount = @as(c_int, 0), + .triangleCount = 0, + .vertices = null, + .texcoords = null, + .texcoords2 = null, + .normals = null, + .tangents = null, + .colors = null, + .indices = null, + .animVertices = null, + .animNormals = null, + .boneIds = null, + .boneWeights = null, + .vaoId = 0, + .vboId = null, + }; + _ = &mesh; + if ((sides >= @as(c_int, 3)) and (radSeg >= @as(c_int, 3))) { + if (radius > 1.0) { + radius = 1.0; + } else if (radius < 0.10000000149011612) { + radius = 0.10000000149011612; + } + var torus: [*c]par_shapes_mesh = par_shapes_create_torus(radSeg, sides, radius); + _ = &torus; + par_shapes_scale(torus, size / @as(f32, @floatFromInt(@as(c_int, 2))), size / @as(f32, @floatFromInt(@as(c_int, 2))), size / @as(f32, @floatFromInt(@as(c_int, 2)))); + mesh.vertices = @as([*c]f32, @ptrCast(@alignCast(malloc(@as(c_ulong, @bitCast(@as(c_long, (torus.*.ntriangles * @as(c_int, 3)) * @as(c_int, 3)))) *% @sizeOf(f32))))); + mesh.texcoords = @as([*c]f32, @ptrCast(@alignCast(malloc(@as(c_ulong, @bitCast(@as(c_long, (torus.*.ntriangles * @as(c_int, 3)) * @as(c_int, 2)))) *% @sizeOf(f32))))); + mesh.normals = @as([*c]f32, @ptrCast(@alignCast(malloc(@as(c_ulong, @bitCast(@as(c_long, (torus.*.ntriangles * @as(c_int, 3)) * @as(c_int, 3)))) *% @sizeOf(f32))))); + mesh.vertexCount = torus.*.ntriangles * @as(c_int, 3); + mesh.triangleCount = torus.*.ntriangles; + { + var k: c_int = 0; + _ = &k; + while (k < mesh.vertexCount) : (k += 1) { + (blk: { + const tmp = k * @as(c_int, 3); + if (tmp >= 0) break :blk mesh.vertices + @as(usize, @intCast(tmp)) else break :blk mesh.vertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = (blk: { + const tmp = @as(c_int, @bitCast(@as(c_uint, (blk_1: { + const tmp_2 = k; + if (tmp_2 >= 0) break :blk_1 torus.*.triangles + @as(usize, @intCast(tmp_2)) else break :blk_1 torus.*.triangles - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*))) * @as(c_int, 3); + if (tmp >= 0) break :blk torus.*.points + @as(usize, @intCast(tmp)) else break :blk torus.*.points - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*; + (blk: { + const tmp = (k * @as(c_int, 3)) + @as(c_int, 1); + if (tmp >= 0) break :blk mesh.vertices + @as(usize, @intCast(tmp)) else break :blk mesh.vertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = (blk: { + const tmp = (@as(c_int, @bitCast(@as(c_uint, (blk_1: { + const tmp_2 = k; + if (tmp_2 >= 0) break :blk_1 torus.*.triangles + @as(usize, @intCast(tmp_2)) else break :blk_1 torus.*.triangles - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*))) * @as(c_int, 3)) + @as(c_int, 1); + if (tmp >= 0) break :blk torus.*.points + @as(usize, @intCast(tmp)) else break :blk torus.*.points - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*; + (blk: { + const tmp = (k * @as(c_int, 3)) + @as(c_int, 2); + if (tmp >= 0) break :blk mesh.vertices + @as(usize, @intCast(tmp)) else break :blk mesh.vertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = (blk: { + const tmp = (@as(c_int, @bitCast(@as(c_uint, (blk_1: { + const tmp_2 = k; + if (tmp_2 >= 0) break :blk_1 torus.*.triangles + @as(usize, @intCast(tmp_2)) else break :blk_1 torus.*.triangles - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*))) * @as(c_int, 3)) + @as(c_int, 2); + if (tmp >= 0) break :blk torus.*.points + @as(usize, @intCast(tmp)) else break :blk torus.*.points - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*; + (blk: { + const tmp = k * @as(c_int, 3); + if (tmp >= 0) break :blk mesh.normals + @as(usize, @intCast(tmp)) else break :blk mesh.normals - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = (blk: { + const tmp = @as(c_int, @bitCast(@as(c_uint, (blk_1: { + const tmp_2 = k; + if (tmp_2 >= 0) break :blk_1 torus.*.triangles + @as(usize, @intCast(tmp_2)) else break :blk_1 torus.*.triangles - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*))) * @as(c_int, 3); + if (tmp >= 0) break :blk torus.*.normals + @as(usize, @intCast(tmp)) else break :blk torus.*.normals - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*; + (blk: { + const tmp = (k * @as(c_int, 3)) + @as(c_int, 1); + if (tmp >= 0) break :blk mesh.normals + @as(usize, @intCast(tmp)) else break :blk mesh.normals - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = (blk: { + const tmp = (@as(c_int, @bitCast(@as(c_uint, (blk_1: { + const tmp_2 = k; + if (tmp_2 >= 0) break :blk_1 torus.*.triangles + @as(usize, @intCast(tmp_2)) else break :blk_1 torus.*.triangles - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*))) * @as(c_int, 3)) + @as(c_int, 1); + if (tmp >= 0) break :blk torus.*.normals + @as(usize, @intCast(tmp)) else break :blk torus.*.normals - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*; + (blk: { + const tmp = (k * @as(c_int, 3)) + @as(c_int, 2); + if (tmp >= 0) break :blk mesh.normals + @as(usize, @intCast(tmp)) else break :blk mesh.normals - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = (blk: { + const tmp = (@as(c_int, @bitCast(@as(c_uint, (blk_1: { + const tmp_2 = k; + if (tmp_2 >= 0) break :blk_1 torus.*.triangles + @as(usize, @intCast(tmp_2)) else break :blk_1 torus.*.triangles - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*))) * @as(c_int, 3)) + @as(c_int, 2); + if (tmp >= 0) break :blk torus.*.normals + @as(usize, @intCast(tmp)) else break :blk torus.*.normals - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*; + (blk: { + const tmp = k * @as(c_int, 2); + if (tmp >= 0) break :blk mesh.texcoords + @as(usize, @intCast(tmp)) else break :blk mesh.texcoords - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = (blk: { + const tmp = @as(c_int, @bitCast(@as(c_uint, (blk_1: { + const tmp_2 = k; + if (tmp_2 >= 0) break :blk_1 torus.*.triangles + @as(usize, @intCast(tmp_2)) else break :blk_1 torus.*.triangles - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*))) * @as(c_int, 2); + if (tmp >= 0) break :blk torus.*.tcoords + @as(usize, @intCast(tmp)) else break :blk torus.*.tcoords - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*; + (blk: { + const tmp = (k * @as(c_int, 2)) + @as(c_int, 1); + if (tmp >= 0) break :blk mesh.texcoords + @as(usize, @intCast(tmp)) else break :blk mesh.texcoords - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = (blk: { + const tmp = (@as(c_int, @bitCast(@as(c_uint, (blk_1: { + const tmp_2 = k; + if (tmp_2 >= 0) break :blk_1 torus.*.triangles + @as(usize, @intCast(tmp_2)) else break :blk_1 torus.*.triangles - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*))) * @as(c_int, 2)) + @as(c_int, 1); + if (tmp >= 0) break :blk torus.*.tcoords + @as(usize, @intCast(tmp)) else break :blk torus.*.tcoords - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*; + } + } + par_shapes_free_mesh(torus); + UploadMesh(&mesh, @as(c_int, 0) != 0); + } else { + TraceLog(LOG_WARNING, "MESH: Failed to generate mesh: torus"); + } + return mesh; +} +pub export fn GenMeshKnot(arg_radius: f32, arg_size: f32, arg_radSeg: c_int, arg_sides: c_int) Mesh { + var radius = arg_radius; + _ = &radius; + var size = arg_size; + _ = &size; + var radSeg = arg_radSeg; + _ = &radSeg; + var sides = arg_sides; + _ = &sides; + var mesh: Mesh = Mesh{ + .vertexCount = @as(c_int, 0), + .triangleCount = 0, + .vertices = null, + .texcoords = null, + .texcoords2 = null, + .normals = null, + .tangents = null, + .colors = null, + .indices = null, + .animVertices = null, + .animNormals = null, + .boneIds = null, + .boneWeights = null, + .vaoId = 0, + .vboId = null, + }; + _ = &mesh; + if ((sides >= @as(c_int, 3)) and (radSeg >= @as(c_int, 3))) { + if (radius > 3.0) { + radius = 3.0; + } else if (radius < 0.5) { + radius = 0.5; + } + var knot: [*c]par_shapes_mesh = par_shapes_create_trefoil_knot(radSeg, sides, radius); + _ = &knot; + par_shapes_scale(knot, size, size, size); + mesh.vertices = @as([*c]f32, @ptrCast(@alignCast(malloc(@as(c_ulong, @bitCast(@as(c_long, (knot.*.ntriangles * @as(c_int, 3)) * @as(c_int, 3)))) *% @sizeOf(f32))))); + mesh.texcoords = @as([*c]f32, @ptrCast(@alignCast(malloc(@as(c_ulong, @bitCast(@as(c_long, (knot.*.ntriangles * @as(c_int, 3)) * @as(c_int, 2)))) *% @sizeOf(f32))))); + mesh.normals = @as([*c]f32, @ptrCast(@alignCast(malloc(@as(c_ulong, @bitCast(@as(c_long, (knot.*.ntriangles * @as(c_int, 3)) * @as(c_int, 3)))) *% @sizeOf(f32))))); + mesh.vertexCount = knot.*.ntriangles * @as(c_int, 3); + mesh.triangleCount = knot.*.ntriangles; + { + var k: c_int = 0; + _ = &k; + while (k < mesh.vertexCount) : (k += 1) { + (blk: { + const tmp = k * @as(c_int, 3); + if (tmp >= 0) break :blk mesh.vertices + @as(usize, @intCast(tmp)) else break :blk mesh.vertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = (blk: { + const tmp = @as(c_int, @bitCast(@as(c_uint, (blk_1: { + const tmp_2 = k; + if (tmp_2 >= 0) break :blk_1 knot.*.triangles + @as(usize, @intCast(tmp_2)) else break :blk_1 knot.*.triangles - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*))) * @as(c_int, 3); + if (tmp >= 0) break :blk knot.*.points + @as(usize, @intCast(tmp)) else break :blk knot.*.points - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*; + (blk: { + const tmp = (k * @as(c_int, 3)) + @as(c_int, 1); + if (tmp >= 0) break :blk mesh.vertices + @as(usize, @intCast(tmp)) else break :blk mesh.vertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = (blk: { + const tmp = (@as(c_int, @bitCast(@as(c_uint, (blk_1: { + const tmp_2 = k; + if (tmp_2 >= 0) break :blk_1 knot.*.triangles + @as(usize, @intCast(tmp_2)) else break :blk_1 knot.*.triangles - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*))) * @as(c_int, 3)) + @as(c_int, 1); + if (tmp >= 0) break :blk knot.*.points + @as(usize, @intCast(tmp)) else break :blk knot.*.points - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*; + (blk: { + const tmp = (k * @as(c_int, 3)) + @as(c_int, 2); + if (tmp >= 0) break :blk mesh.vertices + @as(usize, @intCast(tmp)) else break :blk mesh.vertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = (blk: { + const tmp = (@as(c_int, @bitCast(@as(c_uint, (blk_1: { + const tmp_2 = k; + if (tmp_2 >= 0) break :blk_1 knot.*.triangles + @as(usize, @intCast(tmp_2)) else break :blk_1 knot.*.triangles - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*))) * @as(c_int, 3)) + @as(c_int, 2); + if (tmp >= 0) break :blk knot.*.points + @as(usize, @intCast(tmp)) else break :blk knot.*.points - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*; + (blk: { + const tmp = k * @as(c_int, 3); + if (tmp >= 0) break :blk mesh.normals + @as(usize, @intCast(tmp)) else break :blk mesh.normals - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = (blk: { + const tmp = @as(c_int, @bitCast(@as(c_uint, (blk_1: { + const tmp_2 = k; + if (tmp_2 >= 0) break :blk_1 knot.*.triangles + @as(usize, @intCast(tmp_2)) else break :blk_1 knot.*.triangles - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*))) * @as(c_int, 3); + if (tmp >= 0) break :blk knot.*.normals + @as(usize, @intCast(tmp)) else break :blk knot.*.normals - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*; + (blk: { + const tmp = (k * @as(c_int, 3)) + @as(c_int, 1); + if (tmp >= 0) break :blk mesh.normals + @as(usize, @intCast(tmp)) else break :blk mesh.normals - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = (blk: { + const tmp = (@as(c_int, @bitCast(@as(c_uint, (blk_1: { + const tmp_2 = k; + if (tmp_2 >= 0) break :blk_1 knot.*.triangles + @as(usize, @intCast(tmp_2)) else break :blk_1 knot.*.triangles - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*))) * @as(c_int, 3)) + @as(c_int, 1); + if (tmp >= 0) break :blk knot.*.normals + @as(usize, @intCast(tmp)) else break :blk knot.*.normals - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*; + (blk: { + const tmp = (k * @as(c_int, 3)) + @as(c_int, 2); + if (tmp >= 0) break :blk mesh.normals + @as(usize, @intCast(tmp)) else break :blk mesh.normals - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = (blk: { + const tmp = (@as(c_int, @bitCast(@as(c_uint, (blk_1: { + const tmp_2 = k; + if (tmp_2 >= 0) break :blk_1 knot.*.triangles + @as(usize, @intCast(tmp_2)) else break :blk_1 knot.*.triangles - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*))) * @as(c_int, 3)) + @as(c_int, 2); + if (tmp >= 0) break :blk knot.*.normals + @as(usize, @intCast(tmp)) else break :blk knot.*.normals - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*; + (blk: { + const tmp = k * @as(c_int, 2); + if (tmp >= 0) break :blk mesh.texcoords + @as(usize, @intCast(tmp)) else break :blk mesh.texcoords - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = (blk: { + const tmp = @as(c_int, @bitCast(@as(c_uint, (blk_1: { + const tmp_2 = k; + if (tmp_2 >= 0) break :blk_1 knot.*.triangles + @as(usize, @intCast(tmp_2)) else break :blk_1 knot.*.triangles - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*))) * @as(c_int, 2); + if (tmp >= 0) break :blk knot.*.tcoords + @as(usize, @intCast(tmp)) else break :blk knot.*.tcoords - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*; + (blk: { + const tmp = (k * @as(c_int, 2)) + @as(c_int, 1); + if (tmp >= 0) break :blk mesh.texcoords + @as(usize, @intCast(tmp)) else break :blk mesh.texcoords - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = (blk: { + const tmp = (@as(c_int, @bitCast(@as(c_uint, (blk_1: { + const tmp_2 = k; + if (tmp_2 >= 0) break :blk_1 knot.*.triangles + @as(usize, @intCast(tmp_2)) else break :blk_1 knot.*.triangles - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*))) * @as(c_int, 2)) + @as(c_int, 1); + if (tmp >= 0) break :blk knot.*.tcoords + @as(usize, @intCast(tmp)) else break :blk knot.*.tcoords - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*; + } + } + par_shapes_free_mesh(knot); + UploadMesh(&mesh, @as(c_int, 0) != 0); + } else { + TraceLog(LOG_WARNING, "MESH: Failed to generate mesh: knot"); + } + return mesh; +} +pub export fn GenMeshHeightmap(arg_heightmap: Image, arg_size: Vector3) Mesh { + var heightmap = arg_heightmap; + _ = &heightmap; + var size = arg_size; + _ = &size; + var mesh: Mesh = Mesh{ + .vertexCount = @as(c_int, 0), + .triangleCount = 0, + .vertices = null, + .texcoords = null, + .texcoords2 = null, + .normals = null, + .tangents = null, + .colors = null, + .indices = null, + .animVertices = null, + .animNormals = null, + .boneIds = null, + .boneWeights = null, + .vaoId = 0, + .vboId = null, + }; + _ = &mesh; + var mapX: c_int = heightmap.width; + _ = &mapX; + var mapZ: c_int = heightmap.height; + _ = &mapZ; + var pixels: [*c]Color = LoadImageColors(heightmap); + _ = &pixels; + mesh.triangleCount = ((mapX - @as(c_int, 1)) * (mapZ - @as(c_int, 1))) * @as(c_int, 2); + mesh.vertexCount = mesh.triangleCount * @as(c_int, 3); + mesh.vertices = @as([*c]f32, @ptrCast(@alignCast(malloc(@as(c_ulong, @bitCast(@as(c_long, mesh.vertexCount * @as(c_int, 3)))) *% @sizeOf(f32))))); + mesh.normals = @as([*c]f32, @ptrCast(@alignCast(malloc(@as(c_ulong, @bitCast(@as(c_long, mesh.vertexCount * @as(c_int, 3)))) *% @sizeOf(f32))))); + mesh.texcoords = @as([*c]f32, @ptrCast(@alignCast(malloc(@as(c_ulong, @bitCast(@as(c_long, mesh.vertexCount * @as(c_int, 2)))) *% @sizeOf(f32))))); + mesh.colors = null; + var vCounter: c_int = 0; + _ = &vCounter; + var tcCounter: c_int = 0; + _ = &tcCounter; + var nCounter: c_int = 0; + _ = &nCounter; + var scaleFactor: Vector3 = Vector3{ + .x = size.x / @as(f32, @floatFromInt(mapX - @as(c_int, 1))), + .y = size.y / 255.0, + .z = size.z / @as(f32, @floatFromInt(mapZ - @as(c_int, 1))), + }; + _ = &scaleFactor; + var vA: Vector3 = Vector3{ + .x = @as(f32, @floatFromInt(@as(c_int, 0))), + .y = 0, + .z = 0, + }; + _ = &vA; + var vB: Vector3 = Vector3{ + .x = @as(f32, @floatFromInt(@as(c_int, 0))), + .y = 0, + .z = 0, + }; + _ = &vB; + var vC: Vector3 = Vector3{ + .x = @as(f32, @floatFromInt(@as(c_int, 0))), + .y = 0, + .z = 0, + }; + _ = &vC; + var vN: Vector3 = Vector3{ + .x = @as(f32, @floatFromInt(@as(c_int, 0))), + .y = 0, + .z = 0, + }; + _ = &vN; + { + var z: c_int = 0; + _ = &z; + while (z < (mapZ - @as(c_int, 1))) : (z += 1) { + { + var x: c_int = 0; + _ = &x; + while (x < (mapX - @as(c_int, 1))) : (x += 1) { + (blk: { + const tmp = vCounter; + if (tmp >= 0) break :blk mesh.vertices + @as(usize, @intCast(tmp)) else break :blk mesh.vertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = @as(f32, @floatFromInt(x)) * scaleFactor.x; + (blk: { + const tmp = vCounter + @as(c_int, 1); + if (tmp >= 0) break :blk mesh.vertices + @as(usize, @intCast(tmp)) else break :blk mesh.vertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = (@as(f32, @floatFromInt((@as(c_int, @bitCast(@as(c_uint, (blk: { + const tmp = x + (z * mapX); + if (tmp >= 0) break :blk pixels + @as(usize, @intCast(tmp)) else break :blk pixels - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.r))) + @as(c_int, @bitCast(@as(c_uint, (blk: { + const tmp = x + (z * mapX); + if (tmp >= 0) break :blk pixels + @as(usize, @intCast(tmp)) else break :blk pixels - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.g)))) + @as(c_int, @bitCast(@as(c_uint, (blk: { + const tmp = x + (z * mapX); + if (tmp >= 0) break :blk pixels + @as(usize, @intCast(tmp)) else break :blk pixels - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.b))))) / 3.0) * scaleFactor.y; + (blk: { + const tmp = vCounter + @as(c_int, 2); + if (tmp >= 0) break :blk mesh.vertices + @as(usize, @intCast(tmp)) else break :blk mesh.vertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = @as(f32, @floatFromInt(z)) * scaleFactor.z; + (blk: { + const tmp = vCounter + @as(c_int, 3); + if (tmp >= 0) break :blk mesh.vertices + @as(usize, @intCast(tmp)) else break :blk mesh.vertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = @as(f32, @floatFromInt(x)) * scaleFactor.x; + (blk: { + const tmp = vCounter + @as(c_int, 4); + if (tmp >= 0) break :blk mesh.vertices + @as(usize, @intCast(tmp)) else break :blk mesh.vertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = (@as(f32, @floatFromInt((@as(c_int, @bitCast(@as(c_uint, (blk: { + const tmp = x + ((z + @as(c_int, 1)) * mapX); + if (tmp >= 0) break :blk pixels + @as(usize, @intCast(tmp)) else break :blk pixels - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.r))) + @as(c_int, @bitCast(@as(c_uint, (blk: { + const tmp = x + ((z + @as(c_int, 1)) * mapX); + if (tmp >= 0) break :blk pixels + @as(usize, @intCast(tmp)) else break :blk pixels - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.g)))) + @as(c_int, @bitCast(@as(c_uint, (blk: { + const tmp = x + ((z + @as(c_int, 1)) * mapX); + if (tmp >= 0) break :blk pixels + @as(usize, @intCast(tmp)) else break :blk pixels - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.b))))) / 3.0) * scaleFactor.y; + (blk: { + const tmp = vCounter + @as(c_int, 5); + if (tmp >= 0) break :blk mesh.vertices + @as(usize, @intCast(tmp)) else break :blk mesh.vertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = @as(f32, @floatFromInt(z + @as(c_int, 1))) * scaleFactor.z; + (blk: { + const tmp = vCounter + @as(c_int, 6); + if (tmp >= 0) break :blk mesh.vertices + @as(usize, @intCast(tmp)) else break :blk mesh.vertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = @as(f32, @floatFromInt(x + @as(c_int, 1))) * scaleFactor.x; + (blk: { + const tmp = vCounter + @as(c_int, 7); + if (tmp >= 0) break :blk mesh.vertices + @as(usize, @intCast(tmp)) else break :blk mesh.vertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = (@as(f32, @floatFromInt((@as(c_int, @bitCast(@as(c_uint, (blk: { + const tmp = (x + @as(c_int, 1)) + (z * mapX); + if (tmp >= 0) break :blk pixels + @as(usize, @intCast(tmp)) else break :blk pixels - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.r))) + @as(c_int, @bitCast(@as(c_uint, (blk: { + const tmp = (x + @as(c_int, 1)) + (z * mapX); + if (tmp >= 0) break :blk pixels + @as(usize, @intCast(tmp)) else break :blk pixels - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.g)))) + @as(c_int, @bitCast(@as(c_uint, (blk: { + const tmp = (x + @as(c_int, 1)) + (z * mapX); + if (tmp >= 0) break :blk pixels + @as(usize, @intCast(tmp)) else break :blk pixels - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.b))))) / 3.0) * scaleFactor.y; + (blk: { + const tmp = vCounter + @as(c_int, 8); + if (tmp >= 0) break :blk mesh.vertices + @as(usize, @intCast(tmp)) else break :blk mesh.vertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = @as(f32, @floatFromInt(z)) * scaleFactor.z; + (blk: { + const tmp = vCounter + @as(c_int, 9); + if (tmp >= 0) break :blk mesh.vertices + @as(usize, @intCast(tmp)) else break :blk mesh.vertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = (blk: { + const tmp = vCounter + @as(c_int, 6); + if (tmp >= 0) break :blk mesh.vertices + @as(usize, @intCast(tmp)) else break :blk mesh.vertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*; + (blk: { + const tmp = vCounter + @as(c_int, 10); + if (tmp >= 0) break :blk mesh.vertices + @as(usize, @intCast(tmp)) else break :blk mesh.vertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = (blk: { + const tmp = vCounter + @as(c_int, 7); + if (tmp >= 0) break :blk mesh.vertices + @as(usize, @intCast(tmp)) else break :blk mesh.vertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*; + (blk: { + const tmp = vCounter + @as(c_int, 11); + if (tmp >= 0) break :blk mesh.vertices + @as(usize, @intCast(tmp)) else break :blk mesh.vertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = (blk: { + const tmp = vCounter + @as(c_int, 8); + if (tmp >= 0) break :blk mesh.vertices + @as(usize, @intCast(tmp)) else break :blk mesh.vertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*; + (blk: { + const tmp = vCounter + @as(c_int, 12); + if (tmp >= 0) break :blk mesh.vertices + @as(usize, @intCast(tmp)) else break :blk mesh.vertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = (blk: { + const tmp = vCounter + @as(c_int, 3); + if (tmp >= 0) break :blk mesh.vertices + @as(usize, @intCast(tmp)) else break :blk mesh.vertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*; + (blk: { + const tmp = vCounter + @as(c_int, 13); + if (tmp >= 0) break :blk mesh.vertices + @as(usize, @intCast(tmp)) else break :blk mesh.vertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = (blk: { + const tmp = vCounter + @as(c_int, 4); + if (tmp >= 0) break :blk mesh.vertices + @as(usize, @intCast(tmp)) else break :blk mesh.vertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*; + (blk: { + const tmp = vCounter + @as(c_int, 14); + if (tmp >= 0) break :blk mesh.vertices + @as(usize, @intCast(tmp)) else break :blk mesh.vertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = (blk: { + const tmp = vCounter + @as(c_int, 5); + if (tmp >= 0) break :blk mesh.vertices + @as(usize, @intCast(tmp)) else break :blk mesh.vertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*; + (blk: { + const tmp = vCounter + @as(c_int, 15); + if (tmp >= 0) break :blk mesh.vertices + @as(usize, @intCast(tmp)) else break :blk mesh.vertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = @as(f32, @floatFromInt(x + @as(c_int, 1))) * scaleFactor.x; + (blk: { + const tmp = vCounter + @as(c_int, 16); + if (tmp >= 0) break :blk mesh.vertices + @as(usize, @intCast(tmp)) else break :blk mesh.vertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = (@as(f32, @floatFromInt((@as(c_int, @bitCast(@as(c_uint, (blk: { + const tmp = (x + @as(c_int, 1)) + ((z + @as(c_int, 1)) * mapX); + if (tmp >= 0) break :blk pixels + @as(usize, @intCast(tmp)) else break :blk pixels - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.r))) + @as(c_int, @bitCast(@as(c_uint, (blk: { + const tmp = (x + @as(c_int, 1)) + ((z + @as(c_int, 1)) * mapX); + if (tmp >= 0) break :blk pixels + @as(usize, @intCast(tmp)) else break :blk pixels - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.g)))) + @as(c_int, @bitCast(@as(c_uint, (blk: { + const tmp = (x + @as(c_int, 1)) + ((z + @as(c_int, 1)) * mapX); + if (tmp >= 0) break :blk pixels + @as(usize, @intCast(tmp)) else break :blk pixels - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.b))))) / 3.0) * scaleFactor.y; + (blk: { + const tmp = vCounter + @as(c_int, 17); + if (tmp >= 0) break :blk mesh.vertices + @as(usize, @intCast(tmp)) else break :blk mesh.vertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = @as(f32, @floatFromInt(z + @as(c_int, 1))) * scaleFactor.z; + vCounter += @as(c_int, 18); + (blk: { + const tmp = tcCounter; + if (tmp >= 0) break :blk mesh.texcoords + @as(usize, @intCast(tmp)) else break :blk mesh.texcoords - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = @as(f32, @floatFromInt(x)) / @as(f32, @floatFromInt(mapX - @as(c_int, 1))); + (blk: { + const tmp = tcCounter + @as(c_int, 1); + if (tmp >= 0) break :blk mesh.texcoords + @as(usize, @intCast(tmp)) else break :blk mesh.texcoords - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = @as(f32, @floatFromInt(z)) / @as(f32, @floatFromInt(mapZ - @as(c_int, 1))); + (blk: { + const tmp = tcCounter + @as(c_int, 2); + if (tmp >= 0) break :blk mesh.texcoords + @as(usize, @intCast(tmp)) else break :blk mesh.texcoords - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = @as(f32, @floatFromInt(x)) / @as(f32, @floatFromInt(mapX - @as(c_int, 1))); + (blk: { + const tmp = tcCounter + @as(c_int, 3); + if (tmp >= 0) break :blk mesh.texcoords + @as(usize, @intCast(tmp)) else break :blk mesh.texcoords - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = @as(f32, @floatFromInt(z + @as(c_int, 1))) / @as(f32, @floatFromInt(mapZ - @as(c_int, 1))); + (blk: { + const tmp = tcCounter + @as(c_int, 4); + if (tmp >= 0) break :blk mesh.texcoords + @as(usize, @intCast(tmp)) else break :blk mesh.texcoords - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = @as(f32, @floatFromInt(x + @as(c_int, 1))) / @as(f32, @floatFromInt(mapX - @as(c_int, 1))); + (blk: { + const tmp = tcCounter + @as(c_int, 5); + if (tmp >= 0) break :blk mesh.texcoords + @as(usize, @intCast(tmp)) else break :blk mesh.texcoords - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = @as(f32, @floatFromInt(z)) / @as(f32, @floatFromInt(mapZ - @as(c_int, 1))); + (blk: { + const tmp = tcCounter + @as(c_int, 6); + if (tmp >= 0) break :blk mesh.texcoords + @as(usize, @intCast(tmp)) else break :blk mesh.texcoords - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = (blk: { + const tmp = tcCounter + @as(c_int, 4); + if (tmp >= 0) break :blk mesh.texcoords + @as(usize, @intCast(tmp)) else break :blk mesh.texcoords - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*; + (blk: { + const tmp = tcCounter + @as(c_int, 7); + if (tmp >= 0) break :blk mesh.texcoords + @as(usize, @intCast(tmp)) else break :blk mesh.texcoords - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = (blk: { + const tmp = tcCounter + @as(c_int, 5); + if (tmp >= 0) break :blk mesh.texcoords + @as(usize, @intCast(tmp)) else break :blk mesh.texcoords - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*; + (blk: { + const tmp = tcCounter + @as(c_int, 8); + if (tmp >= 0) break :blk mesh.texcoords + @as(usize, @intCast(tmp)) else break :blk mesh.texcoords - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = (blk: { + const tmp = tcCounter + @as(c_int, 2); + if (tmp >= 0) break :blk mesh.texcoords + @as(usize, @intCast(tmp)) else break :blk mesh.texcoords - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*; + (blk: { + const tmp = tcCounter + @as(c_int, 9); + if (tmp >= 0) break :blk mesh.texcoords + @as(usize, @intCast(tmp)) else break :blk mesh.texcoords - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = (blk: { + const tmp = tcCounter + @as(c_int, 3); + if (tmp >= 0) break :blk mesh.texcoords + @as(usize, @intCast(tmp)) else break :blk mesh.texcoords - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*; + (blk: { + const tmp = tcCounter + @as(c_int, 10); + if (tmp >= 0) break :blk mesh.texcoords + @as(usize, @intCast(tmp)) else break :blk mesh.texcoords - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = @as(f32, @floatFromInt(x + @as(c_int, 1))) / @as(f32, @floatFromInt(mapX - @as(c_int, 1))); + (blk: { + const tmp = tcCounter + @as(c_int, 11); + if (tmp >= 0) break :blk mesh.texcoords + @as(usize, @intCast(tmp)) else break :blk mesh.texcoords - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = @as(f32, @floatFromInt(z + @as(c_int, 1))) / @as(f32, @floatFromInt(mapZ - @as(c_int, 1))); + tcCounter += @as(c_int, 12); + { + var i: c_int = 0; + _ = &i; + while (i < @as(c_int, 18)) : (i += @as(c_int, 9)) { + vA.x = (blk: { + const tmp = nCounter + i; + if (tmp >= 0) break :blk mesh.vertices + @as(usize, @intCast(tmp)) else break :blk mesh.vertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*; + vA.y = (blk: { + const tmp = (nCounter + i) + @as(c_int, 1); + if (tmp >= 0) break :blk mesh.vertices + @as(usize, @intCast(tmp)) else break :blk mesh.vertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*; + vA.z = (blk: { + const tmp = (nCounter + i) + @as(c_int, 2); + if (tmp >= 0) break :blk mesh.vertices + @as(usize, @intCast(tmp)) else break :blk mesh.vertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*; + vB.x = (blk: { + const tmp = (nCounter + i) + @as(c_int, 3); + if (tmp >= 0) break :blk mesh.vertices + @as(usize, @intCast(tmp)) else break :blk mesh.vertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*; + vB.y = (blk: { + const tmp = (nCounter + i) + @as(c_int, 4); + if (tmp >= 0) break :blk mesh.vertices + @as(usize, @intCast(tmp)) else break :blk mesh.vertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*; + vB.z = (blk: { + const tmp = (nCounter + i) + @as(c_int, 5); + if (tmp >= 0) break :blk mesh.vertices + @as(usize, @intCast(tmp)) else break :blk mesh.vertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*; + vC.x = (blk: { + const tmp = (nCounter + i) + @as(c_int, 6); + if (tmp >= 0) break :blk mesh.vertices + @as(usize, @intCast(tmp)) else break :blk mesh.vertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*; + vC.y = (blk: { + const tmp = (nCounter + i) + @as(c_int, 7); + if (tmp >= 0) break :blk mesh.vertices + @as(usize, @intCast(tmp)) else break :blk mesh.vertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*; + vC.z = (blk: { + const tmp = (nCounter + i) + @as(c_int, 8); + if (tmp >= 0) break :blk mesh.vertices + @as(usize, @intCast(tmp)) else break :blk mesh.vertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*; + vN = Vector3Normalize(Vector3CrossProduct(Vector3Subtract(vB, vA), Vector3Subtract(vC, vA))); + (blk: { + const tmp = nCounter + i; + if (tmp >= 0) break :blk mesh.normals + @as(usize, @intCast(tmp)) else break :blk mesh.normals - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = vN.x; + (blk: { + const tmp = (nCounter + i) + @as(c_int, 1); + if (tmp >= 0) break :blk mesh.normals + @as(usize, @intCast(tmp)) else break :blk mesh.normals - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = vN.y; + (blk: { + const tmp = (nCounter + i) + @as(c_int, 2); + if (tmp >= 0) break :blk mesh.normals + @as(usize, @intCast(tmp)) else break :blk mesh.normals - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = vN.z; + (blk: { + const tmp = (nCounter + i) + @as(c_int, 3); + if (tmp >= 0) break :blk mesh.normals + @as(usize, @intCast(tmp)) else break :blk mesh.normals - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = vN.x; + (blk: { + const tmp = (nCounter + i) + @as(c_int, 4); + if (tmp >= 0) break :blk mesh.normals + @as(usize, @intCast(tmp)) else break :blk mesh.normals - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = vN.y; + (blk: { + const tmp = (nCounter + i) + @as(c_int, 5); + if (tmp >= 0) break :blk mesh.normals + @as(usize, @intCast(tmp)) else break :blk mesh.normals - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = vN.z; + (blk: { + const tmp = (nCounter + i) + @as(c_int, 6); + if (tmp >= 0) break :blk mesh.normals + @as(usize, @intCast(tmp)) else break :blk mesh.normals - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = vN.x; + (blk: { + const tmp = (nCounter + i) + @as(c_int, 7); + if (tmp >= 0) break :blk mesh.normals + @as(usize, @intCast(tmp)) else break :blk mesh.normals - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = vN.y; + (blk: { + const tmp = (nCounter + i) + @as(c_int, 8); + if (tmp >= 0) break :blk mesh.normals + @as(usize, @intCast(tmp)) else break :blk mesh.normals - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = vN.z; + } + } + nCounter += @as(c_int, 18); + } + } + } + } + UnloadImageColors(pixels); + UploadMesh(&mesh, @as(c_int, 0) != 0); + return mesh; +} +pub export fn GenMeshCubicmap(arg_cubicmap: Image, arg_cubeSize: Vector3) Mesh { + var cubicmap = arg_cubicmap; + _ = &cubicmap; + var cubeSize = arg_cubeSize; + _ = &cubeSize; + var mesh: Mesh = Mesh{ + .vertexCount = @as(c_int, 0), + .triangleCount = 0, + .vertices = null, + .texcoords = null, + .texcoords2 = null, + .normals = null, + .tangents = null, + .colors = null, + .indices = null, + .animVertices = null, + .animNormals = null, + .boneIds = null, + .boneWeights = null, + .vaoId = 0, + .vboId = null, + }; + _ = &mesh; + var pixels: [*c]Color = LoadImageColors(cubicmap); + _ = &pixels; + var maxTriangles: c_int = (cubicmap.width * cubicmap.height) * @as(c_int, 12); + _ = &maxTriangles; + var vCounter: c_int = 0; + _ = &vCounter; + var tcCounter: c_int = 0; + _ = &tcCounter; + var nCounter: c_int = 0; + _ = &nCounter; + var w: f32 = cubeSize.x; + _ = &w; + var h: f32 = cubeSize.z; + _ = &h; + var h2: f32 = cubeSize.y; + _ = &h2; + var mapVertices: [*c]Vector3 = @as([*c]Vector3, @ptrCast(@alignCast(malloc(@as(c_ulong, @bitCast(@as(c_long, maxTriangles * @as(c_int, 3)))) *% @sizeOf(Vector3))))); + _ = &mapVertices; + var mapTexcoords: [*c]Vector2 = @as([*c]Vector2, @ptrCast(@alignCast(malloc(@as(c_ulong, @bitCast(@as(c_long, maxTriangles * @as(c_int, 3)))) *% @sizeOf(Vector2))))); + _ = &mapTexcoords; + var mapNormals: [*c]Vector3 = @as([*c]Vector3, @ptrCast(@alignCast(malloc(@as(c_ulong, @bitCast(@as(c_long, maxTriangles * @as(c_int, 3)))) *% @sizeOf(Vector3))))); + _ = &mapNormals; + var n1: Vector3 = Vector3{ + .x = 1.0, + .y = 0.0, + .z = 0.0, + }; + _ = &n1; + var n2: Vector3 = Vector3{ + .x = -1.0, + .y = 0.0, + .z = 0.0, + }; + _ = &n2; + var n3: Vector3 = Vector3{ + .x = 0.0, + .y = 1.0, + .z = 0.0, + }; + _ = &n3; + var n4: Vector3 = Vector3{ + .x = 0.0, + .y = -1.0, + .z = 0.0, + }; + _ = &n4; + var n5: Vector3 = Vector3{ + .x = 0.0, + .y = 0.0, + .z = -1.0, + }; + _ = &n5; + var n6: Vector3 = Vector3{ + .x = 0.0, + .y = 0.0, + .z = 1.0, + }; + _ = &n6; + const struct_RectangleF = extern struct { + x: f32 = @import("std").mem.zeroes(f32), + y: f32 = @import("std").mem.zeroes(f32), + width: f32 = @import("std").mem.zeroes(f32), + height: f32 = @import("std").mem.zeroes(f32), + }; + _ = &struct_RectangleF; + const RectangleF = struct_RectangleF; + _ = &RectangleF; + var rightTexUV: RectangleF = RectangleF{ + .x = 0.0, + .y = 0.0, + .width = 0.5, + .height = 0.5, + }; + _ = &rightTexUV; + var leftTexUV: RectangleF = RectangleF{ + .x = 0.5, + .y = 0.0, + .width = 0.5, + .height = 0.5, + }; + _ = &leftTexUV; + var frontTexUV: RectangleF = RectangleF{ + .x = 0.0, + .y = 0.0, + .width = 0.5, + .height = 0.5, + }; + _ = &frontTexUV; + var backTexUV: RectangleF = RectangleF{ + .x = 0.5, + .y = 0.0, + .width = 0.5, + .height = 0.5, + }; + _ = &backTexUV; + var topTexUV: RectangleF = RectangleF{ + .x = 0.0, + .y = 0.5, + .width = 0.5, + .height = 0.5, + }; + _ = &topTexUV; + var bottomTexUV: RectangleF = RectangleF{ + .x = 0.5, + .y = 0.5, + .width = 0.5, + .height = 0.5, + }; + _ = &bottomTexUV; + { + var z: c_int = 0; + _ = &z; + while (z < cubicmap.height) : (z += 1) { + { + var x: c_int = 0; + _ = &x; + while (x < cubicmap.width) : (x += 1) { + var v1: Vector3 = Vector3{ + .x = w * (@as(f32, @floatFromInt(x)) - 0.5), + .y = h2, + .z = h * (@as(f32, @floatFromInt(z)) - 0.5), + }; + _ = &v1; + var v2: Vector3 = Vector3{ + .x = w * (@as(f32, @floatFromInt(x)) - 0.5), + .y = h2, + .z = h * (@as(f32, @floatFromInt(z)) + 0.5), + }; + _ = &v2; + var v3: Vector3 = Vector3{ + .x = w * (@as(f32, @floatFromInt(x)) + 0.5), + .y = h2, + .z = h * (@as(f32, @floatFromInt(z)) + 0.5), + }; + _ = &v3; + var v4: Vector3 = Vector3{ + .x = w * (@as(f32, @floatFromInt(x)) + 0.5), + .y = h2, + .z = h * (@as(f32, @floatFromInt(z)) - 0.5), + }; + _ = &v4; + var v5: Vector3 = Vector3{ + .x = w * (@as(f32, @floatFromInt(x)) + 0.5), + .y = @as(f32, @floatFromInt(@as(c_int, 0))), + .z = h * (@as(f32, @floatFromInt(z)) - 0.5), + }; + _ = &v5; + var v6: Vector3 = Vector3{ + .x = w * (@as(f32, @floatFromInt(x)) - 0.5), + .y = @as(f32, @floatFromInt(@as(c_int, 0))), + .z = h * (@as(f32, @floatFromInt(z)) - 0.5), + }; + _ = &v6; + var v7: Vector3 = Vector3{ + .x = w * (@as(f32, @floatFromInt(x)) - 0.5), + .y = @as(f32, @floatFromInt(@as(c_int, 0))), + .z = h * (@as(f32, @floatFromInt(z)) + 0.5), + }; + _ = &v7; + var v8: Vector3 = Vector3{ + .x = w * (@as(f32, @floatFromInt(x)) + 0.5), + .y = @as(f32, @floatFromInt(@as(c_int, 0))), + .z = h * (@as(f32, @floatFromInt(z)) + 0.5), + }; + _ = &v8; + if ((((@as(c_int, @bitCast(@as(c_uint, (blk: { + const tmp = (z * cubicmap.width) + x; + if (tmp >= 0) break :blk pixels + @as(usize, @intCast(tmp)) else break :blk pixels - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.r))) == @as(c_int, @bitCast(@as(c_uint, (Color{ + .r = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 255))))), + .g = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 255))))), + .b = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 255))))), + .a = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 255))))), + }).r)))) and (@as(c_int, @bitCast(@as(c_uint, (blk: { + const tmp = (z * cubicmap.width) + x; + if (tmp >= 0) break :blk pixels + @as(usize, @intCast(tmp)) else break :blk pixels - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.g))) == @as(c_int, @bitCast(@as(c_uint, (Color{ + .r = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 255))))), + .g = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 255))))), + .b = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 255))))), + .a = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 255))))), + }).g))))) and (@as(c_int, @bitCast(@as(c_uint, (blk: { + const tmp = (z * cubicmap.width) + x; + if (tmp >= 0) break :blk pixels + @as(usize, @intCast(tmp)) else break :blk pixels - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.b))) == @as(c_int, @bitCast(@as(c_uint, (Color{ + .r = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 255))))), + .g = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 255))))), + .b = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 255))))), + .a = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 255))))), + }).b))))) and (@as(c_int, @bitCast(@as(c_uint, (blk: { + const tmp = (z * cubicmap.width) + x; + if (tmp >= 0) break :blk pixels + @as(usize, @intCast(tmp)) else break :blk pixels - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.a))) == @as(c_int, @bitCast(@as(c_uint, (Color{ + .r = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 255))))), + .g = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 255))))), + .b = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 255))))), + .a = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 255))))), + }).a))))) { + (blk: { + const tmp = vCounter; + if (tmp >= 0) break :blk mapVertices + @as(usize, @intCast(tmp)) else break :blk mapVertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = v1; + (blk: { + const tmp = vCounter + @as(c_int, 1); + if (tmp >= 0) break :blk mapVertices + @as(usize, @intCast(tmp)) else break :blk mapVertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = v2; + (blk: { + const tmp = vCounter + @as(c_int, 2); + if (tmp >= 0) break :blk mapVertices + @as(usize, @intCast(tmp)) else break :blk mapVertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = v3; + (blk: { + const tmp = vCounter + @as(c_int, 3); + if (tmp >= 0) break :blk mapVertices + @as(usize, @intCast(tmp)) else break :blk mapVertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = v1; + (blk: { + const tmp = vCounter + @as(c_int, 4); + if (tmp >= 0) break :blk mapVertices + @as(usize, @intCast(tmp)) else break :blk mapVertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = v3; + (blk: { + const tmp = vCounter + @as(c_int, 5); + if (tmp >= 0) break :blk mapVertices + @as(usize, @intCast(tmp)) else break :blk mapVertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = v4; + vCounter += @as(c_int, 6); + (blk: { + const tmp = nCounter; + if (tmp >= 0) break :blk mapNormals + @as(usize, @intCast(tmp)) else break :blk mapNormals - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = n3; + (blk: { + const tmp = nCounter + @as(c_int, 1); + if (tmp >= 0) break :blk mapNormals + @as(usize, @intCast(tmp)) else break :blk mapNormals - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = n3; + (blk: { + const tmp = nCounter + @as(c_int, 2); + if (tmp >= 0) break :blk mapNormals + @as(usize, @intCast(tmp)) else break :blk mapNormals - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = n3; + (blk: { + const tmp = nCounter + @as(c_int, 3); + if (tmp >= 0) break :blk mapNormals + @as(usize, @intCast(tmp)) else break :blk mapNormals - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = n3; + (blk: { + const tmp = nCounter + @as(c_int, 4); + if (tmp >= 0) break :blk mapNormals + @as(usize, @intCast(tmp)) else break :blk mapNormals - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = n3; + (blk: { + const tmp = nCounter + @as(c_int, 5); + if (tmp >= 0) break :blk mapNormals + @as(usize, @intCast(tmp)) else break :blk mapNormals - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = n3; + nCounter += @as(c_int, 6); + (blk: { + const tmp = tcCounter; + if (tmp >= 0) break :blk mapTexcoords + @as(usize, @intCast(tmp)) else break :blk mapTexcoords - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = Vector2{ + .x = topTexUV.x, + .y = topTexUV.y, + }; + (blk: { + const tmp = tcCounter + @as(c_int, 1); + if (tmp >= 0) break :blk mapTexcoords + @as(usize, @intCast(tmp)) else break :blk mapTexcoords - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = Vector2{ + .x = topTexUV.x, + .y = topTexUV.y + topTexUV.height, + }; + (blk: { + const tmp = tcCounter + @as(c_int, 2); + if (tmp >= 0) break :blk mapTexcoords + @as(usize, @intCast(tmp)) else break :blk mapTexcoords - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = Vector2{ + .x = topTexUV.x + topTexUV.width, + .y = topTexUV.y + topTexUV.height, + }; + (blk: { + const tmp = tcCounter + @as(c_int, 3); + if (tmp >= 0) break :blk mapTexcoords + @as(usize, @intCast(tmp)) else break :blk mapTexcoords - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = Vector2{ + .x = topTexUV.x, + .y = topTexUV.y, + }; + (blk: { + const tmp = tcCounter + @as(c_int, 4); + if (tmp >= 0) break :blk mapTexcoords + @as(usize, @intCast(tmp)) else break :blk mapTexcoords - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = Vector2{ + .x = topTexUV.x + topTexUV.width, + .y = topTexUV.y + topTexUV.height, + }; + (blk: { + const tmp = tcCounter + @as(c_int, 5); + if (tmp >= 0) break :blk mapTexcoords + @as(usize, @intCast(tmp)) else break :blk mapTexcoords - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = Vector2{ + .x = topTexUV.x + topTexUV.width, + .y = topTexUV.y, + }; + tcCounter += @as(c_int, 6); + (blk: { + const tmp = vCounter; + if (tmp >= 0) break :blk mapVertices + @as(usize, @intCast(tmp)) else break :blk mapVertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = v6; + (blk: { + const tmp = vCounter + @as(c_int, 1); + if (tmp >= 0) break :blk mapVertices + @as(usize, @intCast(tmp)) else break :blk mapVertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = v8; + (blk: { + const tmp = vCounter + @as(c_int, 2); + if (tmp >= 0) break :blk mapVertices + @as(usize, @intCast(tmp)) else break :blk mapVertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = v7; + (blk: { + const tmp = vCounter + @as(c_int, 3); + if (tmp >= 0) break :blk mapVertices + @as(usize, @intCast(tmp)) else break :blk mapVertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = v6; + (blk: { + const tmp = vCounter + @as(c_int, 4); + if (tmp >= 0) break :blk mapVertices + @as(usize, @intCast(tmp)) else break :blk mapVertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = v5; + (blk: { + const tmp = vCounter + @as(c_int, 5); + if (tmp >= 0) break :blk mapVertices + @as(usize, @intCast(tmp)) else break :blk mapVertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = v8; + vCounter += @as(c_int, 6); + (blk: { + const tmp = nCounter; + if (tmp >= 0) break :blk mapNormals + @as(usize, @intCast(tmp)) else break :blk mapNormals - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = n4; + (blk: { + const tmp = nCounter + @as(c_int, 1); + if (tmp >= 0) break :blk mapNormals + @as(usize, @intCast(tmp)) else break :blk mapNormals - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = n4; + (blk: { + const tmp = nCounter + @as(c_int, 2); + if (tmp >= 0) break :blk mapNormals + @as(usize, @intCast(tmp)) else break :blk mapNormals - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = n4; + (blk: { + const tmp = nCounter + @as(c_int, 3); + if (tmp >= 0) break :blk mapNormals + @as(usize, @intCast(tmp)) else break :blk mapNormals - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = n4; + (blk: { + const tmp = nCounter + @as(c_int, 4); + if (tmp >= 0) break :blk mapNormals + @as(usize, @intCast(tmp)) else break :blk mapNormals - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = n4; + (blk: { + const tmp = nCounter + @as(c_int, 5); + if (tmp >= 0) break :blk mapNormals + @as(usize, @intCast(tmp)) else break :blk mapNormals - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = n4; + nCounter += @as(c_int, 6); + (blk: { + const tmp = tcCounter; + if (tmp >= 0) break :blk mapTexcoords + @as(usize, @intCast(tmp)) else break :blk mapTexcoords - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = Vector2{ + .x = bottomTexUV.x + bottomTexUV.width, + .y = bottomTexUV.y, + }; + (blk: { + const tmp = tcCounter + @as(c_int, 1); + if (tmp >= 0) break :blk mapTexcoords + @as(usize, @intCast(tmp)) else break :blk mapTexcoords - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = Vector2{ + .x = bottomTexUV.x, + .y = bottomTexUV.y + bottomTexUV.height, + }; + (blk: { + const tmp = tcCounter + @as(c_int, 2); + if (tmp >= 0) break :blk mapTexcoords + @as(usize, @intCast(tmp)) else break :blk mapTexcoords - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = Vector2{ + .x = bottomTexUV.x + bottomTexUV.width, + .y = bottomTexUV.y + bottomTexUV.height, + }; + (blk: { + const tmp = tcCounter + @as(c_int, 3); + if (tmp >= 0) break :blk mapTexcoords + @as(usize, @intCast(tmp)) else break :blk mapTexcoords - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = Vector2{ + .x = bottomTexUV.x + bottomTexUV.width, + .y = bottomTexUV.y, + }; + (blk: { + const tmp = tcCounter + @as(c_int, 4); + if (tmp >= 0) break :blk mapTexcoords + @as(usize, @intCast(tmp)) else break :blk mapTexcoords - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = Vector2{ + .x = bottomTexUV.x, + .y = bottomTexUV.y, + }; + (blk: { + const tmp = tcCounter + @as(c_int, 5); + if (tmp >= 0) break :blk mapTexcoords + @as(usize, @intCast(tmp)) else break :blk mapTexcoords - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = Vector2{ + .x = bottomTexUV.x, + .y = bottomTexUV.y + bottomTexUV.height, + }; + tcCounter += @as(c_int, 6); + if (((z < (cubicmap.height - @as(c_int, 1))) and ((((@as(c_int, @bitCast(@as(c_uint, (blk: { + const tmp = ((z + @as(c_int, 1)) * cubicmap.width) + x; + if (tmp >= 0) break :blk pixels + @as(usize, @intCast(tmp)) else break :blk pixels - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.r))) == @as(c_int, @bitCast(@as(c_uint, (Color{ + .r = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + .g = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + .b = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + .a = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 255))))), + }).r)))) and (@as(c_int, @bitCast(@as(c_uint, (blk: { + const tmp = ((z + @as(c_int, 1)) * cubicmap.width) + x; + if (tmp >= 0) break :blk pixels + @as(usize, @intCast(tmp)) else break :blk pixels - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.g))) == @as(c_int, @bitCast(@as(c_uint, (Color{ + .r = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + .g = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + .b = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + .a = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 255))))), + }).g))))) and (@as(c_int, @bitCast(@as(c_uint, (blk: { + const tmp = ((z + @as(c_int, 1)) * cubicmap.width) + x; + if (tmp >= 0) break :blk pixels + @as(usize, @intCast(tmp)) else break :blk pixels - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.b))) == @as(c_int, @bitCast(@as(c_uint, (Color{ + .r = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + .g = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + .b = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + .a = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 255))))), + }).b))))) and (@as(c_int, @bitCast(@as(c_uint, (blk: { + const tmp = ((z + @as(c_int, 1)) * cubicmap.width) + x; + if (tmp >= 0) break :blk pixels + @as(usize, @intCast(tmp)) else break :blk pixels - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.a))) == @as(c_int, @bitCast(@as(c_uint, (Color{ + .r = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + .g = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + .b = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + .a = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 255))))), + }).a)))))) or (z == (cubicmap.height - @as(c_int, 1)))) { + (blk: { + const tmp = vCounter; + if (tmp >= 0) break :blk mapVertices + @as(usize, @intCast(tmp)) else break :blk mapVertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = v2; + (blk: { + const tmp = vCounter + @as(c_int, 1); + if (tmp >= 0) break :blk mapVertices + @as(usize, @intCast(tmp)) else break :blk mapVertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = v7; + (blk: { + const tmp = vCounter + @as(c_int, 2); + if (tmp >= 0) break :blk mapVertices + @as(usize, @intCast(tmp)) else break :blk mapVertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = v3; + (blk: { + const tmp = vCounter + @as(c_int, 3); + if (tmp >= 0) break :blk mapVertices + @as(usize, @intCast(tmp)) else break :blk mapVertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = v3; + (blk: { + const tmp = vCounter + @as(c_int, 4); + if (tmp >= 0) break :blk mapVertices + @as(usize, @intCast(tmp)) else break :blk mapVertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = v7; + (blk: { + const tmp = vCounter + @as(c_int, 5); + if (tmp >= 0) break :blk mapVertices + @as(usize, @intCast(tmp)) else break :blk mapVertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = v8; + vCounter += @as(c_int, 6); + (blk: { + const tmp = nCounter; + if (tmp >= 0) break :blk mapNormals + @as(usize, @intCast(tmp)) else break :blk mapNormals - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = n6; + (blk: { + const tmp = nCounter + @as(c_int, 1); + if (tmp >= 0) break :blk mapNormals + @as(usize, @intCast(tmp)) else break :blk mapNormals - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = n6; + (blk: { + const tmp = nCounter + @as(c_int, 2); + if (tmp >= 0) break :blk mapNormals + @as(usize, @intCast(tmp)) else break :blk mapNormals - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = n6; + (blk: { + const tmp = nCounter + @as(c_int, 3); + if (tmp >= 0) break :blk mapNormals + @as(usize, @intCast(tmp)) else break :blk mapNormals - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = n6; + (blk: { + const tmp = nCounter + @as(c_int, 4); + if (tmp >= 0) break :blk mapNormals + @as(usize, @intCast(tmp)) else break :blk mapNormals - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = n6; + (blk: { + const tmp = nCounter + @as(c_int, 5); + if (tmp >= 0) break :blk mapNormals + @as(usize, @intCast(tmp)) else break :blk mapNormals - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = n6; + nCounter += @as(c_int, 6); + (blk: { + const tmp = tcCounter; + if (tmp >= 0) break :blk mapTexcoords + @as(usize, @intCast(tmp)) else break :blk mapTexcoords - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = Vector2{ + .x = frontTexUV.x, + .y = frontTexUV.y, + }; + (blk: { + const tmp = tcCounter + @as(c_int, 1); + if (tmp >= 0) break :blk mapTexcoords + @as(usize, @intCast(tmp)) else break :blk mapTexcoords - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = Vector2{ + .x = frontTexUV.x, + .y = frontTexUV.y + frontTexUV.height, + }; + (blk: { + const tmp = tcCounter + @as(c_int, 2); + if (tmp >= 0) break :blk mapTexcoords + @as(usize, @intCast(tmp)) else break :blk mapTexcoords - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = Vector2{ + .x = frontTexUV.x + frontTexUV.width, + .y = frontTexUV.y, + }; + (blk: { + const tmp = tcCounter + @as(c_int, 3); + if (tmp >= 0) break :blk mapTexcoords + @as(usize, @intCast(tmp)) else break :blk mapTexcoords - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = Vector2{ + .x = frontTexUV.x + frontTexUV.width, + .y = frontTexUV.y, + }; + (blk: { + const tmp = tcCounter + @as(c_int, 4); + if (tmp >= 0) break :blk mapTexcoords + @as(usize, @intCast(tmp)) else break :blk mapTexcoords - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = Vector2{ + .x = frontTexUV.x, + .y = frontTexUV.y + frontTexUV.height, + }; + (blk: { + const tmp = tcCounter + @as(c_int, 5); + if (tmp >= 0) break :blk mapTexcoords + @as(usize, @intCast(tmp)) else break :blk mapTexcoords - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = Vector2{ + .x = frontTexUV.x + frontTexUV.width, + .y = frontTexUV.y + frontTexUV.height, + }; + tcCounter += @as(c_int, 6); + } + if (((z > @as(c_int, 0)) and ((((@as(c_int, @bitCast(@as(c_uint, (blk: { + const tmp = ((z - @as(c_int, 1)) * cubicmap.width) + x; + if (tmp >= 0) break :blk pixels + @as(usize, @intCast(tmp)) else break :blk pixels - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.r))) == @as(c_int, @bitCast(@as(c_uint, (Color{ + .r = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + .g = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + .b = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + .a = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 255))))), + }).r)))) and (@as(c_int, @bitCast(@as(c_uint, (blk: { + const tmp = ((z - @as(c_int, 1)) * cubicmap.width) + x; + if (tmp >= 0) break :blk pixels + @as(usize, @intCast(tmp)) else break :blk pixels - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.g))) == @as(c_int, @bitCast(@as(c_uint, (Color{ + .r = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + .g = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + .b = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + .a = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 255))))), + }).g))))) and (@as(c_int, @bitCast(@as(c_uint, (blk: { + const tmp = ((z - @as(c_int, 1)) * cubicmap.width) + x; + if (tmp >= 0) break :blk pixels + @as(usize, @intCast(tmp)) else break :blk pixels - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.b))) == @as(c_int, @bitCast(@as(c_uint, (Color{ + .r = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + .g = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + .b = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + .a = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 255))))), + }).b))))) and (@as(c_int, @bitCast(@as(c_uint, (blk: { + const tmp = ((z - @as(c_int, 1)) * cubicmap.width) + x; + if (tmp >= 0) break :blk pixels + @as(usize, @intCast(tmp)) else break :blk pixels - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.a))) == @as(c_int, @bitCast(@as(c_uint, (Color{ + .r = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + .g = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + .b = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + .a = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 255))))), + }).a)))))) or (z == @as(c_int, 0))) { + (blk: { + const tmp = vCounter; + if (tmp >= 0) break :blk mapVertices + @as(usize, @intCast(tmp)) else break :blk mapVertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = v1; + (blk: { + const tmp = vCounter + @as(c_int, 1); + if (tmp >= 0) break :blk mapVertices + @as(usize, @intCast(tmp)) else break :blk mapVertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = v5; + (blk: { + const tmp = vCounter + @as(c_int, 2); + if (tmp >= 0) break :blk mapVertices + @as(usize, @intCast(tmp)) else break :blk mapVertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = v6; + (blk: { + const tmp = vCounter + @as(c_int, 3); + if (tmp >= 0) break :blk mapVertices + @as(usize, @intCast(tmp)) else break :blk mapVertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = v1; + (blk: { + const tmp = vCounter + @as(c_int, 4); + if (tmp >= 0) break :blk mapVertices + @as(usize, @intCast(tmp)) else break :blk mapVertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = v4; + (blk: { + const tmp = vCounter + @as(c_int, 5); + if (tmp >= 0) break :blk mapVertices + @as(usize, @intCast(tmp)) else break :blk mapVertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = v5; + vCounter += @as(c_int, 6); + (blk: { + const tmp = nCounter; + if (tmp >= 0) break :blk mapNormals + @as(usize, @intCast(tmp)) else break :blk mapNormals - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = n5; + (blk: { + const tmp = nCounter + @as(c_int, 1); + if (tmp >= 0) break :blk mapNormals + @as(usize, @intCast(tmp)) else break :blk mapNormals - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = n5; + (blk: { + const tmp = nCounter + @as(c_int, 2); + if (tmp >= 0) break :blk mapNormals + @as(usize, @intCast(tmp)) else break :blk mapNormals - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = n5; + (blk: { + const tmp = nCounter + @as(c_int, 3); + if (tmp >= 0) break :blk mapNormals + @as(usize, @intCast(tmp)) else break :blk mapNormals - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = n5; + (blk: { + const tmp = nCounter + @as(c_int, 4); + if (tmp >= 0) break :blk mapNormals + @as(usize, @intCast(tmp)) else break :blk mapNormals - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = n5; + (blk: { + const tmp = nCounter + @as(c_int, 5); + if (tmp >= 0) break :blk mapNormals + @as(usize, @intCast(tmp)) else break :blk mapNormals - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = n5; + nCounter += @as(c_int, 6); + (blk: { + const tmp = tcCounter; + if (tmp >= 0) break :blk mapTexcoords + @as(usize, @intCast(tmp)) else break :blk mapTexcoords - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = Vector2{ + .x = backTexUV.x + backTexUV.width, + .y = backTexUV.y, + }; + (blk: { + const tmp = tcCounter + @as(c_int, 1); + if (tmp >= 0) break :blk mapTexcoords + @as(usize, @intCast(tmp)) else break :blk mapTexcoords - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = Vector2{ + .x = backTexUV.x, + .y = backTexUV.y + backTexUV.height, + }; + (blk: { + const tmp = tcCounter + @as(c_int, 2); + if (tmp >= 0) break :blk mapTexcoords + @as(usize, @intCast(tmp)) else break :blk mapTexcoords - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = Vector2{ + .x = backTexUV.x + backTexUV.width, + .y = backTexUV.y + backTexUV.height, + }; + (blk: { + const tmp = tcCounter + @as(c_int, 3); + if (tmp >= 0) break :blk mapTexcoords + @as(usize, @intCast(tmp)) else break :blk mapTexcoords - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = Vector2{ + .x = backTexUV.x + backTexUV.width, + .y = backTexUV.y, + }; + (blk: { + const tmp = tcCounter + @as(c_int, 4); + if (tmp >= 0) break :blk mapTexcoords + @as(usize, @intCast(tmp)) else break :blk mapTexcoords - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = Vector2{ + .x = backTexUV.x, + .y = backTexUV.y, + }; + (blk: { + const tmp = tcCounter + @as(c_int, 5); + if (tmp >= 0) break :blk mapTexcoords + @as(usize, @intCast(tmp)) else break :blk mapTexcoords - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = Vector2{ + .x = backTexUV.x, + .y = backTexUV.y + backTexUV.height, + }; + tcCounter += @as(c_int, 6); + } + if (((x < (cubicmap.width - @as(c_int, 1))) and ((((@as(c_int, @bitCast(@as(c_uint, (blk: { + const tmp = (z * cubicmap.width) + (x + @as(c_int, 1)); + if (tmp >= 0) break :blk pixels + @as(usize, @intCast(tmp)) else break :blk pixels - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.r))) == @as(c_int, @bitCast(@as(c_uint, (Color{ + .r = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + .g = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + .b = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + .a = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 255))))), + }).r)))) and (@as(c_int, @bitCast(@as(c_uint, (blk: { + const tmp = (z * cubicmap.width) + (x + @as(c_int, 1)); + if (tmp >= 0) break :blk pixels + @as(usize, @intCast(tmp)) else break :blk pixels - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.g))) == @as(c_int, @bitCast(@as(c_uint, (Color{ + .r = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + .g = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + .b = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + .a = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 255))))), + }).g))))) and (@as(c_int, @bitCast(@as(c_uint, (blk: { + const tmp = (z * cubicmap.width) + (x + @as(c_int, 1)); + if (tmp >= 0) break :blk pixels + @as(usize, @intCast(tmp)) else break :blk pixels - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.b))) == @as(c_int, @bitCast(@as(c_uint, (Color{ + .r = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + .g = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + .b = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + .a = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 255))))), + }).b))))) and (@as(c_int, @bitCast(@as(c_uint, (blk: { + const tmp = (z * cubicmap.width) + (x + @as(c_int, 1)); + if (tmp >= 0) break :blk pixels + @as(usize, @intCast(tmp)) else break :blk pixels - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.a))) == @as(c_int, @bitCast(@as(c_uint, (Color{ + .r = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + .g = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + .b = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + .a = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 255))))), + }).a)))))) or (x == (cubicmap.width - @as(c_int, 1)))) { + (blk: { + const tmp = vCounter; + if (tmp >= 0) break :blk mapVertices + @as(usize, @intCast(tmp)) else break :blk mapVertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = v3; + (blk: { + const tmp = vCounter + @as(c_int, 1); + if (tmp >= 0) break :blk mapVertices + @as(usize, @intCast(tmp)) else break :blk mapVertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = v8; + (blk: { + const tmp = vCounter + @as(c_int, 2); + if (tmp >= 0) break :blk mapVertices + @as(usize, @intCast(tmp)) else break :blk mapVertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = v4; + (blk: { + const tmp = vCounter + @as(c_int, 3); + if (tmp >= 0) break :blk mapVertices + @as(usize, @intCast(tmp)) else break :blk mapVertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = v4; + (blk: { + const tmp = vCounter + @as(c_int, 4); + if (tmp >= 0) break :blk mapVertices + @as(usize, @intCast(tmp)) else break :blk mapVertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = v8; + (blk: { + const tmp = vCounter + @as(c_int, 5); + if (tmp >= 0) break :blk mapVertices + @as(usize, @intCast(tmp)) else break :blk mapVertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = v5; + vCounter += @as(c_int, 6); + (blk: { + const tmp = nCounter; + if (tmp >= 0) break :blk mapNormals + @as(usize, @intCast(tmp)) else break :blk mapNormals - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = n1; + (blk: { + const tmp = nCounter + @as(c_int, 1); + if (tmp >= 0) break :blk mapNormals + @as(usize, @intCast(tmp)) else break :blk mapNormals - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = n1; + (blk: { + const tmp = nCounter + @as(c_int, 2); + if (tmp >= 0) break :blk mapNormals + @as(usize, @intCast(tmp)) else break :blk mapNormals - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = n1; + (blk: { + const tmp = nCounter + @as(c_int, 3); + if (tmp >= 0) break :blk mapNormals + @as(usize, @intCast(tmp)) else break :blk mapNormals - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = n1; + (blk: { + const tmp = nCounter + @as(c_int, 4); + if (tmp >= 0) break :blk mapNormals + @as(usize, @intCast(tmp)) else break :blk mapNormals - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = n1; + (blk: { + const tmp = nCounter + @as(c_int, 5); + if (tmp >= 0) break :blk mapNormals + @as(usize, @intCast(tmp)) else break :blk mapNormals - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = n1; + nCounter += @as(c_int, 6); + (blk: { + const tmp = tcCounter; + if (tmp >= 0) break :blk mapTexcoords + @as(usize, @intCast(tmp)) else break :blk mapTexcoords - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = Vector2{ + .x = rightTexUV.x, + .y = rightTexUV.y, + }; + (blk: { + const tmp = tcCounter + @as(c_int, 1); + if (tmp >= 0) break :blk mapTexcoords + @as(usize, @intCast(tmp)) else break :blk mapTexcoords - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = Vector2{ + .x = rightTexUV.x, + .y = rightTexUV.y + rightTexUV.height, + }; + (blk: { + const tmp = tcCounter + @as(c_int, 2); + if (tmp >= 0) break :blk mapTexcoords + @as(usize, @intCast(tmp)) else break :blk mapTexcoords - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = Vector2{ + .x = rightTexUV.x + rightTexUV.width, + .y = rightTexUV.y, + }; + (blk: { + const tmp = tcCounter + @as(c_int, 3); + if (tmp >= 0) break :blk mapTexcoords + @as(usize, @intCast(tmp)) else break :blk mapTexcoords - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = Vector2{ + .x = rightTexUV.x + rightTexUV.width, + .y = rightTexUV.y, + }; + (blk: { + const tmp = tcCounter + @as(c_int, 4); + if (tmp >= 0) break :blk mapTexcoords + @as(usize, @intCast(tmp)) else break :blk mapTexcoords - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = Vector2{ + .x = rightTexUV.x, + .y = rightTexUV.y + rightTexUV.height, + }; + (blk: { + const tmp = tcCounter + @as(c_int, 5); + if (tmp >= 0) break :blk mapTexcoords + @as(usize, @intCast(tmp)) else break :blk mapTexcoords - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = Vector2{ + .x = rightTexUV.x + rightTexUV.width, + .y = rightTexUV.y + rightTexUV.height, + }; + tcCounter += @as(c_int, 6); + } + if (((x > @as(c_int, 0)) and ((((@as(c_int, @bitCast(@as(c_uint, (blk: { + const tmp = (z * cubicmap.width) + (x - @as(c_int, 1)); + if (tmp >= 0) break :blk pixels + @as(usize, @intCast(tmp)) else break :blk pixels - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.r))) == @as(c_int, @bitCast(@as(c_uint, (Color{ + .r = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + .g = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + .b = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + .a = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 255))))), + }).r)))) and (@as(c_int, @bitCast(@as(c_uint, (blk: { + const tmp = (z * cubicmap.width) + (x - @as(c_int, 1)); + if (tmp >= 0) break :blk pixels + @as(usize, @intCast(tmp)) else break :blk pixels - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.g))) == @as(c_int, @bitCast(@as(c_uint, (Color{ + .r = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + .g = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + .b = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + .a = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 255))))), + }).g))))) and (@as(c_int, @bitCast(@as(c_uint, (blk: { + const tmp = (z * cubicmap.width) + (x - @as(c_int, 1)); + if (tmp >= 0) break :blk pixels + @as(usize, @intCast(tmp)) else break :blk pixels - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.b))) == @as(c_int, @bitCast(@as(c_uint, (Color{ + .r = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + .g = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + .b = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + .a = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 255))))), + }).b))))) and (@as(c_int, @bitCast(@as(c_uint, (blk: { + const tmp = (z * cubicmap.width) + (x - @as(c_int, 1)); + if (tmp >= 0) break :blk pixels + @as(usize, @intCast(tmp)) else break :blk pixels - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.a))) == @as(c_int, @bitCast(@as(c_uint, (Color{ + .r = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + .g = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + .b = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + .a = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 255))))), + }).a)))))) or (x == @as(c_int, 0))) { + (blk: { + const tmp = vCounter; + if (tmp >= 0) break :blk mapVertices + @as(usize, @intCast(tmp)) else break :blk mapVertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = v1; + (blk: { + const tmp = vCounter + @as(c_int, 1); + if (tmp >= 0) break :blk mapVertices + @as(usize, @intCast(tmp)) else break :blk mapVertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = v7; + (blk: { + const tmp = vCounter + @as(c_int, 2); + if (tmp >= 0) break :blk mapVertices + @as(usize, @intCast(tmp)) else break :blk mapVertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = v2; + (blk: { + const tmp = vCounter + @as(c_int, 3); + if (tmp >= 0) break :blk mapVertices + @as(usize, @intCast(tmp)) else break :blk mapVertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = v1; + (blk: { + const tmp = vCounter + @as(c_int, 4); + if (tmp >= 0) break :blk mapVertices + @as(usize, @intCast(tmp)) else break :blk mapVertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = v6; + (blk: { + const tmp = vCounter + @as(c_int, 5); + if (tmp >= 0) break :blk mapVertices + @as(usize, @intCast(tmp)) else break :blk mapVertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = v7; + vCounter += @as(c_int, 6); + (blk: { + const tmp = nCounter; + if (tmp >= 0) break :blk mapNormals + @as(usize, @intCast(tmp)) else break :blk mapNormals - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = n2; + (blk: { + const tmp = nCounter + @as(c_int, 1); + if (tmp >= 0) break :blk mapNormals + @as(usize, @intCast(tmp)) else break :blk mapNormals - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = n2; + (blk: { + const tmp = nCounter + @as(c_int, 2); + if (tmp >= 0) break :blk mapNormals + @as(usize, @intCast(tmp)) else break :blk mapNormals - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = n2; + (blk: { + const tmp = nCounter + @as(c_int, 3); + if (tmp >= 0) break :blk mapNormals + @as(usize, @intCast(tmp)) else break :blk mapNormals - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = n2; + (blk: { + const tmp = nCounter + @as(c_int, 4); + if (tmp >= 0) break :blk mapNormals + @as(usize, @intCast(tmp)) else break :blk mapNormals - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = n2; + (blk: { + const tmp = nCounter + @as(c_int, 5); + if (tmp >= 0) break :blk mapNormals + @as(usize, @intCast(tmp)) else break :blk mapNormals - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = n2; + nCounter += @as(c_int, 6); + (blk: { + const tmp = tcCounter; + if (tmp >= 0) break :blk mapTexcoords + @as(usize, @intCast(tmp)) else break :blk mapTexcoords - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = Vector2{ + .x = leftTexUV.x, + .y = leftTexUV.y, + }; + (blk: { + const tmp = tcCounter + @as(c_int, 1); + if (tmp >= 0) break :blk mapTexcoords + @as(usize, @intCast(tmp)) else break :blk mapTexcoords - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = Vector2{ + .x = leftTexUV.x + leftTexUV.width, + .y = leftTexUV.y + leftTexUV.height, + }; + (blk: { + const tmp = tcCounter + @as(c_int, 2); + if (tmp >= 0) break :blk mapTexcoords + @as(usize, @intCast(tmp)) else break :blk mapTexcoords - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = Vector2{ + .x = leftTexUV.x + leftTexUV.width, + .y = leftTexUV.y, + }; + (blk: { + const tmp = tcCounter + @as(c_int, 3); + if (tmp >= 0) break :blk mapTexcoords + @as(usize, @intCast(tmp)) else break :blk mapTexcoords - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = Vector2{ + .x = leftTexUV.x, + .y = leftTexUV.y, + }; + (blk: { + const tmp = tcCounter + @as(c_int, 4); + if (tmp >= 0) break :blk mapTexcoords + @as(usize, @intCast(tmp)) else break :blk mapTexcoords - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = Vector2{ + .x = leftTexUV.x, + .y = leftTexUV.y + leftTexUV.height, + }; + (blk: { + const tmp = tcCounter + @as(c_int, 5); + if (tmp >= 0) break :blk mapTexcoords + @as(usize, @intCast(tmp)) else break :blk mapTexcoords - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = Vector2{ + .x = leftTexUV.x + leftTexUV.width, + .y = leftTexUV.y + leftTexUV.height, + }; + tcCounter += @as(c_int, 6); + } + } else if ((((@as(c_int, @bitCast(@as(c_uint, (blk: { + const tmp = (z * cubicmap.width) + x; + if (tmp >= 0) break :blk pixels + @as(usize, @intCast(tmp)) else break :blk pixels - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.r))) == @as(c_int, @bitCast(@as(c_uint, (Color{ + .r = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + .g = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + .b = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + .a = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 255))))), + }).r)))) and (@as(c_int, @bitCast(@as(c_uint, (blk: { + const tmp = (z * cubicmap.width) + x; + if (tmp >= 0) break :blk pixels + @as(usize, @intCast(tmp)) else break :blk pixels - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.g))) == @as(c_int, @bitCast(@as(c_uint, (Color{ + .r = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + .g = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + .b = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + .a = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 255))))), + }).g))))) and (@as(c_int, @bitCast(@as(c_uint, (blk: { + const tmp = (z * cubicmap.width) + x; + if (tmp >= 0) break :blk pixels + @as(usize, @intCast(tmp)) else break :blk pixels - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.b))) == @as(c_int, @bitCast(@as(c_uint, (Color{ + .r = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + .g = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + .b = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + .a = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 255))))), + }).b))))) and (@as(c_int, @bitCast(@as(c_uint, (blk: { + const tmp = (z * cubicmap.width) + x; + if (tmp >= 0) break :blk pixels + @as(usize, @intCast(tmp)) else break :blk pixels - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.a))) == @as(c_int, @bitCast(@as(c_uint, (Color{ + .r = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + .g = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + .b = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + .a = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 255))))), + }).a))))) { + (blk: { + const tmp = vCounter; + if (tmp >= 0) break :blk mapVertices + @as(usize, @intCast(tmp)) else break :blk mapVertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = v1; + (blk: { + const tmp = vCounter + @as(c_int, 1); + if (tmp >= 0) break :blk mapVertices + @as(usize, @intCast(tmp)) else break :blk mapVertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = v3; + (blk: { + const tmp = vCounter + @as(c_int, 2); + if (tmp >= 0) break :blk mapVertices + @as(usize, @intCast(tmp)) else break :blk mapVertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = v2; + (blk: { + const tmp = vCounter + @as(c_int, 3); + if (tmp >= 0) break :blk mapVertices + @as(usize, @intCast(tmp)) else break :blk mapVertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = v1; + (blk: { + const tmp = vCounter + @as(c_int, 4); + if (tmp >= 0) break :blk mapVertices + @as(usize, @intCast(tmp)) else break :blk mapVertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = v4; + (blk: { + const tmp = vCounter + @as(c_int, 5); + if (tmp >= 0) break :blk mapVertices + @as(usize, @intCast(tmp)) else break :blk mapVertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = v3; + vCounter += @as(c_int, 6); + (blk: { + const tmp = nCounter; + if (tmp >= 0) break :blk mapNormals + @as(usize, @intCast(tmp)) else break :blk mapNormals - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = n4; + (blk: { + const tmp = nCounter + @as(c_int, 1); + if (tmp >= 0) break :blk mapNormals + @as(usize, @intCast(tmp)) else break :blk mapNormals - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = n4; + (blk: { + const tmp = nCounter + @as(c_int, 2); + if (tmp >= 0) break :blk mapNormals + @as(usize, @intCast(tmp)) else break :blk mapNormals - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = n4; + (blk: { + const tmp = nCounter + @as(c_int, 3); + if (tmp >= 0) break :blk mapNormals + @as(usize, @intCast(tmp)) else break :blk mapNormals - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = n4; + (blk: { + const tmp = nCounter + @as(c_int, 4); + if (tmp >= 0) break :blk mapNormals + @as(usize, @intCast(tmp)) else break :blk mapNormals - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = n4; + (blk: { + const tmp = nCounter + @as(c_int, 5); + if (tmp >= 0) break :blk mapNormals + @as(usize, @intCast(tmp)) else break :blk mapNormals - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = n4; + nCounter += @as(c_int, 6); + (blk: { + const tmp = tcCounter; + if (tmp >= 0) break :blk mapTexcoords + @as(usize, @intCast(tmp)) else break :blk mapTexcoords - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = Vector2{ + .x = topTexUV.x, + .y = topTexUV.y, + }; + (blk: { + const tmp = tcCounter + @as(c_int, 1); + if (tmp >= 0) break :blk mapTexcoords + @as(usize, @intCast(tmp)) else break :blk mapTexcoords - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = Vector2{ + .x = topTexUV.x + topTexUV.width, + .y = topTexUV.y + topTexUV.height, + }; + (blk: { + const tmp = tcCounter + @as(c_int, 2); + if (tmp >= 0) break :blk mapTexcoords + @as(usize, @intCast(tmp)) else break :blk mapTexcoords - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = Vector2{ + .x = topTexUV.x, + .y = topTexUV.y + topTexUV.height, + }; + (blk: { + const tmp = tcCounter + @as(c_int, 3); + if (tmp >= 0) break :blk mapTexcoords + @as(usize, @intCast(tmp)) else break :blk mapTexcoords - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = Vector2{ + .x = topTexUV.x, + .y = topTexUV.y, + }; + (blk: { + const tmp = tcCounter + @as(c_int, 4); + if (tmp >= 0) break :blk mapTexcoords + @as(usize, @intCast(tmp)) else break :blk mapTexcoords - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = Vector2{ + .x = topTexUV.x + topTexUV.width, + .y = topTexUV.y, + }; + (blk: { + const tmp = tcCounter + @as(c_int, 5); + if (tmp >= 0) break :blk mapTexcoords + @as(usize, @intCast(tmp)) else break :blk mapTexcoords - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = Vector2{ + .x = topTexUV.x + topTexUV.width, + .y = topTexUV.y + topTexUV.height, + }; + tcCounter += @as(c_int, 6); + (blk: { + const tmp = vCounter; + if (tmp >= 0) break :blk mapVertices + @as(usize, @intCast(tmp)) else break :blk mapVertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = v6; + (blk: { + const tmp = vCounter + @as(c_int, 1); + if (tmp >= 0) break :blk mapVertices + @as(usize, @intCast(tmp)) else break :blk mapVertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = v7; + (blk: { + const tmp = vCounter + @as(c_int, 2); + if (tmp >= 0) break :blk mapVertices + @as(usize, @intCast(tmp)) else break :blk mapVertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = v8; + (blk: { + const tmp = vCounter + @as(c_int, 3); + if (tmp >= 0) break :blk mapVertices + @as(usize, @intCast(tmp)) else break :blk mapVertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = v6; + (blk: { + const tmp = vCounter + @as(c_int, 4); + if (tmp >= 0) break :blk mapVertices + @as(usize, @intCast(tmp)) else break :blk mapVertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = v8; + (blk: { + const tmp = vCounter + @as(c_int, 5); + if (tmp >= 0) break :blk mapVertices + @as(usize, @intCast(tmp)) else break :blk mapVertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = v5; + vCounter += @as(c_int, 6); + (blk: { + const tmp = nCounter; + if (tmp >= 0) break :blk mapNormals + @as(usize, @intCast(tmp)) else break :blk mapNormals - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = n3; + (blk: { + const tmp = nCounter + @as(c_int, 1); + if (tmp >= 0) break :blk mapNormals + @as(usize, @intCast(tmp)) else break :blk mapNormals - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = n3; + (blk: { + const tmp = nCounter + @as(c_int, 2); + if (tmp >= 0) break :blk mapNormals + @as(usize, @intCast(tmp)) else break :blk mapNormals - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = n3; + (blk: { + const tmp = nCounter + @as(c_int, 3); + if (tmp >= 0) break :blk mapNormals + @as(usize, @intCast(tmp)) else break :blk mapNormals - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = n3; + (blk: { + const tmp = nCounter + @as(c_int, 4); + if (tmp >= 0) break :blk mapNormals + @as(usize, @intCast(tmp)) else break :blk mapNormals - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = n3; + (blk: { + const tmp = nCounter + @as(c_int, 5); + if (tmp >= 0) break :blk mapNormals + @as(usize, @intCast(tmp)) else break :blk mapNormals - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = n3; + nCounter += @as(c_int, 6); + (blk: { + const tmp = tcCounter; + if (tmp >= 0) break :blk mapTexcoords + @as(usize, @intCast(tmp)) else break :blk mapTexcoords - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = Vector2{ + .x = bottomTexUV.x + bottomTexUV.width, + .y = bottomTexUV.y, + }; + (blk: { + const tmp = tcCounter + @as(c_int, 1); + if (tmp >= 0) break :blk mapTexcoords + @as(usize, @intCast(tmp)) else break :blk mapTexcoords - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = Vector2{ + .x = bottomTexUV.x + bottomTexUV.width, + .y = bottomTexUV.y + bottomTexUV.height, + }; + (blk: { + const tmp = tcCounter + @as(c_int, 2); + if (tmp >= 0) break :blk mapTexcoords + @as(usize, @intCast(tmp)) else break :blk mapTexcoords - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = Vector2{ + .x = bottomTexUV.x, + .y = bottomTexUV.y + bottomTexUV.height, + }; + (blk: { + const tmp = tcCounter + @as(c_int, 3); + if (tmp >= 0) break :blk mapTexcoords + @as(usize, @intCast(tmp)) else break :blk mapTexcoords - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = Vector2{ + .x = bottomTexUV.x + bottomTexUV.width, + .y = bottomTexUV.y, + }; + (blk: { + const tmp = tcCounter + @as(c_int, 4); + if (tmp >= 0) break :blk mapTexcoords + @as(usize, @intCast(tmp)) else break :blk mapTexcoords - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = Vector2{ + .x = bottomTexUV.x, + .y = bottomTexUV.y + bottomTexUV.height, + }; + (blk: { + const tmp = tcCounter + @as(c_int, 5); + if (tmp >= 0) break :blk mapTexcoords + @as(usize, @intCast(tmp)) else break :blk mapTexcoords - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = Vector2{ + .x = bottomTexUV.x, + .y = bottomTexUV.y, + }; + tcCounter += @as(c_int, 6); + } + } + } + } + } + mesh.vertexCount = vCounter; + mesh.triangleCount = @divTrunc(vCounter, @as(c_int, 3)); + mesh.vertices = @as([*c]f32, @ptrCast(@alignCast(malloc(@as(c_ulong, @bitCast(@as(c_long, mesh.vertexCount * @as(c_int, 3)))) *% @sizeOf(f32))))); + mesh.normals = @as([*c]f32, @ptrCast(@alignCast(malloc(@as(c_ulong, @bitCast(@as(c_long, mesh.vertexCount * @as(c_int, 3)))) *% @sizeOf(f32))))); + mesh.texcoords = @as([*c]f32, @ptrCast(@alignCast(malloc(@as(c_ulong, @bitCast(@as(c_long, mesh.vertexCount * @as(c_int, 2)))) *% @sizeOf(f32))))); + mesh.colors = null; + var fCounter: c_int = 0; + _ = &fCounter; + { + var i: c_int = 0; + _ = &i; + while (i < vCounter) : (i += 1) { + (blk: { + const tmp = fCounter; + if (tmp >= 0) break :blk mesh.vertices + @as(usize, @intCast(tmp)) else break :blk mesh.vertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = (blk: { + const tmp = i; + if (tmp >= 0) break :blk mapVertices + @as(usize, @intCast(tmp)) else break :blk mapVertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.x; + (blk: { + const tmp = fCounter + @as(c_int, 1); + if (tmp >= 0) break :blk mesh.vertices + @as(usize, @intCast(tmp)) else break :blk mesh.vertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = (blk: { + const tmp = i; + if (tmp >= 0) break :blk mapVertices + @as(usize, @intCast(tmp)) else break :blk mapVertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.y; + (blk: { + const tmp = fCounter + @as(c_int, 2); + if (tmp >= 0) break :blk mesh.vertices + @as(usize, @intCast(tmp)) else break :blk mesh.vertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = (blk: { + const tmp = i; + if (tmp >= 0) break :blk mapVertices + @as(usize, @intCast(tmp)) else break :blk mapVertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.z; + fCounter += @as(c_int, 3); + } + } + fCounter = 0; + { + var i: c_int = 0; + _ = &i; + while (i < nCounter) : (i += 1) { + (blk: { + const tmp = fCounter; + if (tmp >= 0) break :blk mesh.normals + @as(usize, @intCast(tmp)) else break :blk mesh.normals - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = (blk: { + const tmp = i; + if (tmp >= 0) break :blk mapNormals + @as(usize, @intCast(tmp)) else break :blk mapNormals - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.x; + (blk: { + const tmp = fCounter + @as(c_int, 1); + if (tmp >= 0) break :blk mesh.normals + @as(usize, @intCast(tmp)) else break :blk mesh.normals - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = (blk: { + const tmp = i; + if (tmp >= 0) break :blk mapNormals + @as(usize, @intCast(tmp)) else break :blk mapNormals - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.y; + (blk: { + const tmp = fCounter + @as(c_int, 2); + if (tmp >= 0) break :blk mesh.normals + @as(usize, @intCast(tmp)) else break :blk mesh.normals - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = (blk: { + const tmp = i; + if (tmp >= 0) break :blk mapNormals + @as(usize, @intCast(tmp)) else break :blk mapNormals - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.z; + fCounter += @as(c_int, 3); + } + } + fCounter = 0; + { + var i: c_int = 0; + _ = &i; + while (i < tcCounter) : (i += 1) { + (blk: { + const tmp = fCounter; + if (tmp >= 0) break :blk mesh.texcoords + @as(usize, @intCast(tmp)) else break :blk mesh.texcoords - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = (blk: { + const tmp = i; + if (tmp >= 0) break :blk mapTexcoords + @as(usize, @intCast(tmp)) else break :blk mapTexcoords - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.x; + (blk: { + const tmp = fCounter + @as(c_int, 1); + if (tmp >= 0) break :blk mesh.texcoords + @as(usize, @intCast(tmp)) else break :blk mesh.texcoords - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = (blk: { + const tmp = i; + if (tmp >= 0) break :blk mapTexcoords + @as(usize, @intCast(tmp)) else break :blk mapTexcoords - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.y; + fCounter += @as(c_int, 2); + } + } + free(@as(?*anyopaque, @ptrCast(mapVertices))); + free(@as(?*anyopaque, @ptrCast(mapNormals))); + free(@as(?*anyopaque, @ptrCast(mapTexcoords))); + UnloadImageColors(pixels); + UploadMesh(&mesh, @as(c_int, 0) != 0); + return mesh; +} +pub export fn LoadMaterials(arg_fileName: [*c]const u8, arg_materialCount: [*c]c_int) [*c]Material { + var fileName = arg_fileName; + _ = &fileName; + var materialCount = arg_materialCount; + _ = &materialCount; + var materials: [*c]Material = null; + _ = &materials; + var count: c_uint = 0; + _ = &count; + if (IsFileExtension(fileName, ".mtl")) { + var mats: [*c]tinyobj_material_t = null; + _ = &mats; + var result: c_int = tinyobj_parse_mtl_file(&mats, &count, fileName); + _ = &result; + if (result != @as(c_int, 0)) { + TraceLog(LOG_WARNING, "MATERIAL: [%s] Failed to parse materials file", fileName); + } + materials = @as([*c]Material, @ptrCast(@alignCast(malloc(@as(c_ulong, @bitCast(@as(c_ulong, count))) *% @sizeOf(Material))))); + ProcessMaterialsOBJ(materials, mats, @as(c_int, @bitCast(count))); + tinyobj_materials_free(mats, count); + } + materialCount.* = @as(c_int, @bitCast(count)); + return materials; +} +pub export fn LoadMaterialDefault() Material { + var material: Material = Material{ + .shader = Shader{ + .id = @as(c_uint, @bitCast(@as(c_int, 0))), + .locs = null, + }, + .maps = null, + .params = @import("std").mem.zeroes([4]f32), + }; + _ = &material; + material.maps = @as([*c]MaterialMap, @ptrCast(@alignCast(calloc(@as(c_ulong, @bitCast(@as(c_long, @as(c_int, 12)))), @sizeOf(MaterialMap))))); + material.shader.id = rlGetShaderIdDefault(); + material.shader.locs = rlGetShaderLocsDefault(); + (blk: { + const tmp = MATERIAL_MAP_ALBEDO; + if (tmp >= 0) break :blk material.maps + @as(usize, @intCast(tmp)) else break :blk material.maps - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.texture = Texture2D{ + .id = rlGetTextureIdDefault(), + .width = @as(c_int, 1), + .height = @as(c_int, 1), + .mipmaps = @as(c_int, 1), + .format = PIXELFORMAT_UNCOMPRESSED_R8G8B8A8, + }; + (blk: { + const tmp = MATERIAL_MAP_ALBEDO; + if (tmp >= 0) break :blk material.maps + @as(usize, @intCast(tmp)) else break :blk material.maps - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.color = Color{ + .r = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 255))))), + .g = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 255))))), + .b = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 255))))), + .a = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 255))))), + }; + (blk: { + const tmp = MATERIAL_MAP_METALNESS; + if (tmp >= 0) break :blk material.maps + @as(usize, @intCast(tmp)) else break :blk material.maps - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.color = Color{ + .r = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 255))))), + .g = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 255))))), + .b = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 255))))), + .a = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 255))))), + }; + return material; +} +pub export fn IsMaterialReady(arg_material: Material) bool { + var material = arg_material; + _ = &material; + var result: bool = @as(c_int, 0) != 0; + _ = &result; + if ((material.maps != @as([*c]MaterialMap, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0))))))) and (material.shader.id > @as(c_uint, @bitCast(@as(c_int, 0))))) { + result = @as(c_int, 1) != 0; + } + return result; +} +pub export fn UnloadMaterial(arg_material: Material) void { + var material = arg_material; + _ = &material; + if (material.shader.id != rlGetShaderIdDefault()) { + UnloadShader(material.shader); + } + if (material.maps != @as([*c]MaterialMap, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0))))))) { + { + var i: c_int = 0; + _ = &i; + while (i < @as(c_int, 12)) : (i += 1) { + if ((blk: { + const tmp = i; + if (tmp >= 0) break :blk material.maps + @as(usize, @intCast(tmp)) else break :blk material.maps - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.texture.id != rlGetTextureIdDefault()) { + rlUnloadTexture((blk: { + const tmp = i; + if (tmp >= 0) break :blk material.maps + @as(usize, @intCast(tmp)) else break :blk material.maps - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.texture.id); + } + } + } + } + free(@as(?*anyopaque, @ptrCast(material.maps))); +} +pub export fn SetMaterialTexture(arg_material: [*c]Material, arg_mapType: c_int, arg_texture: Texture2D) void { + var material = arg_material; + _ = &material; + var mapType = arg_mapType; + _ = &mapType; + var texture = arg_texture; + _ = &texture; + (blk: { + const tmp = mapType; + if (tmp >= 0) break :blk material.*.maps + @as(usize, @intCast(tmp)) else break :blk material.*.maps - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.texture = texture; +} +pub export fn SetModelMeshMaterial(arg_model: [*c]Model, arg_meshId: c_int, arg_materialId: c_int) void { + var model = arg_model; + _ = &model; + var meshId = arg_meshId; + _ = &meshId; + var materialId = arg_materialId; + _ = &materialId; + if (meshId >= model.*.meshCount) { + TraceLog(LOG_WARNING, "MESH: Id greater than mesh count"); + } else if (materialId >= model.*.materialCount) { + TraceLog(LOG_WARNING, "MATERIAL: Id greater than material count"); + } else { + (blk: { + const tmp = meshId; + if (tmp >= 0) break :blk model.*.meshMaterial + @as(usize, @intCast(tmp)) else break :blk model.*.meshMaterial - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = materialId; + } +} +pub export fn LoadModelAnimations(arg_fileName: [*c]const u8, arg_animCount: [*c]c_int) [*c]ModelAnimation { + var fileName = arg_fileName; + _ = &fileName; + var animCount = arg_animCount; + _ = &animCount; + var animations: [*c]ModelAnimation = null; + _ = &animations; + if (IsFileExtension(fileName, ".iqm")) { + animations = LoadModelAnimationsIQM(fileName, animCount); + } + if (IsFileExtension(fileName, ".m3d")) { + animations = LoadModelAnimationsM3D(fileName, animCount); + } + if (IsFileExtension(fileName, ".gltf;.glb")) { + animations = LoadModelAnimationsGLTF(fileName, animCount); + } + return animations; +} +pub export fn UpdateModelAnimation(arg_model: Model, arg_anim: ModelAnimation, arg_frame: c_int) void { + var model = arg_model; + _ = &model; + var anim = arg_anim; + _ = &anim; + var frame = arg_frame; + _ = &frame; + if (((anim.frameCount > @as(c_int, 0)) and (anim.bones != @as([*c]BoneInfo, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0)))))))) and (anim.framePoses != @as([*c][*c]Transform, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0)))))))) { + if (frame >= anim.frameCount) { + frame = @import("std").zig.c_translation.signedRemainder(frame, anim.frameCount); + } + { + var m: c_int = 0; + _ = &m; + while (m < model.meshCount) : (m += 1) { + var mesh: Mesh = (blk: { + const tmp = m; + if (tmp >= 0) break :blk model.meshes + @as(usize, @intCast(tmp)) else break :blk model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*; + _ = &mesh; + if ((mesh.boneIds == @as([*c]u8, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0))))))) or (mesh.boneWeights == @as([*c]f32, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0)))))))) { + TraceLog(LOG_WARNING, "MODEL: UpdateModelAnimation(): Mesh %i has no connection to bones", m); + continue; + } + var updated: bool = @as(c_int, 0) != 0; + _ = &updated; + var animVertex: Vector3 = Vector3{ + .x = @as(f32, @floatFromInt(@as(c_int, 0))), + .y = 0, + .z = 0, + }; + _ = &animVertex; + var animNormal: Vector3 = Vector3{ + .x = @as(f32, @floatFromInt(@as(c_int, 0))), + .y = 0, + .z = 0, + }; + _ = &animNormal; + var inTranslation: Vector3 = Vector3{ + .x = @as(f32, @floatFromInt(@as(c_int, 0))), + .y = 0, + .z = 0, + }; + _ = &inTranslation; + var inRotation: Quaternion = Quaternion{ + .x = @as(f32, @floatFromInt(@as(c_int, 0))), + .y = 0, + .z = 0, + .w = 0, + }; + _ = &inRotation; + var outTranslation: Vector3 = Vector3{ + .x = @as(f32, @floatFromInt(@as(c_int, 0))), + .y = 0, + .z = 0, + }; + _ = &outTranslation; + var outRotation: Quaternion = Quaternion{ + .x = @as(f32, @floatFromInt(@as(c_int, 0))), + .y = 0, + .z = 0, + .w = 0, + }; + _ = &outRotation; + var outScale: Vector3 = Vector3{ + .x = @as(f32, @floatFromInt(@as(c_int, 0))), + .y = 0, + .z = 0, + }; + _ = &outScale; + var boneId: c_int = 0; + _ = &boneId; + var boneCounter: c_int = 0; + _ = &boneCounter; + var boneWeight: f32 = @as(f32, @floatCast(0.0)); + _ = &boneWeight; + const vValues: c_int = mesh.vertexCount * @as(c_int, 3); + _ = &vValues; + { + var vCounter: c_int = 0; + _ = &vCounter; + while (vCounter < vValues) : (vCounter += @as(c_int, 3)) { + (blk: { + const tmp = vCounter; + if (tmp >= 0) break :blk mesh.animVertices + @as(usize, @intCast(tmp)) else break :blk mesh.animVertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = 0; + (blk: { + const tmp = vCounter + @as(c_int, 1); + if (tmp >= 0) break :blk mesh.animVertices + @as(usize, @intCast(tmp)) else break :blk mesh.animVertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = 0; + (blk: { + const tmp = vCounter + @as(c_int, 2); + if (tmp >= 0) break :blk mesh.animVertices + @as(usize, @intCast(tmp)) else break :blk mesh.animVertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = 0; + if (mesh.animNormals != @as([*c]f32, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0))))))) { + (blk: { + const tmp = vCounter; + if (tmp >= 0) break :blk mesh.animNormals + @as(usize, @intCast(tmp)) else break :blk mesh.animNormals - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = 0; + (blk: { + const tmp = vCounter + @as(c_int, 1); + if (tmp >= 0) break :blk mesh.animNormals + @as(usize, @intCast(tmp)) else break :blk mesh.animNormals - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = 0; + (blk: { + const tmp = vCounter + @as(c_int, 2); + if (tmp >= 0) break :blk mesh.animNormals + @as(usize, @intCast(tmp)) else break :blk mesh.animNormals - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = 0; + } + { + var j: c_int = 0; + _ = &j; + while (j < @as(c_int, 4)) : (_ = blk: { + j += 1; + break :blk blk_1: { + const ref = &boneCounter; + const tmp = ref.*; + ref.* += 1; + break :blk_1 tmp; + }; + }) { + boneWeight = (blk: { + const tmp = boneCounter; + if (tmp >= 0) break :blk mesh.boneWeights + @as(usize, @intCast(tmp)) else break :blk mesh.boneWeights - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*; + if (boneWeight == 0.0) continue; + boneId = @as(c_int, @bitCast(@as(c_uint, (blk: { + const tmp = boneCounter; + if (tmp >= 0) break :blk mesh.boneIds + @as(usize, @intCast(tmp)) else break :blk mesh.boneIds - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*))); + inTranslation = (blk: { + const tmp = boneId; + if (tmp >= 0) break :blk model.bindPose + @as(usize, @intCast(tmp)) else break :blk model.bindPose - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.translation; + inRotation = (blk: { + const tmp = boneId; + if (tmp >= 0) break :blk model.bindPose + @as(usize, @intCast(tmp)) else break :blk model.bindPose - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.rotation; + outTranslation = (blk: { + const tmp = boneId; + if (tmp >= 0) break :blk (blk_1: { + const tmp_2 = frame; + if (tmp_2 >= 0) break :blk_1 anim.framePoses + @as(usize, @intCast(tmp_2)) else break :blk_1 anim.framePoses - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).* + @as(usize, @intCast(tmp)) else break :blk (blk_1: { + const tmp_2 = frame; + if (tmp_2 >= 0) break :blk_1 anim.framePoses + @as(usize, @intCast(tmp_2)) else break :blk_1 anim.framePoses - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).* - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.translation; + outRotation = (blk: { + const tmp = boneId; + if (tmp >= 0) break :blk (blk_1: { + const tmp_2 = frame; + if (tmp_2 >= 0) break :blk_1 anim.framePoses + @as(usize, @intCast(tmp_2)) else break :blk_1 anim.framePoses - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).* + @as(usize, @intCast(tmp)) else break :blk (blk_1: { + const tmp_2 = frame; + if (tmp_2 >= 0) break :blk_1 anim.framePoses + @as(usize, @intCast(tmp_2)) else break :blk_1 anim.framePoses - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).* - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.rotation; + outScale = (blk: { + const tmp = boneId; + if (tmp >= 0) break :blk (blk_1: { + const tmp_2 = frame; + if (tmp_2 >= 0) break :blk_1 anim.framePoses + @as(usize, @intCast(tmp_2)) else break :blk_1 anim.framePoses - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).* + @as(usize, @intCast(tmp)) else break :blk (blk_1: { + const tmp_2 = frame; + if (tmp_2 >= 0) break :blk_1 anim.framePoses + @as(usize, @intCast(tmp_2)) else break :blk_1 anim.framePoses - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).* - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.scale; + animVertex = Vector3{ + .x = (blk: { + const tmp = vCounter; + if (tmp >= 0) break :blk mesh.vertices + @as(usize, @intCast(tmp)) else break :blk mesh.vertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*, + .y = (blk: { + const tmp = vCounter + @as(c_int, 1); + if (tmp >= 0) break :blk mesh.vertices + @as(usize, @intCast(tmp)) else break :blk mesh.vertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*, + .z = (blk: { + const tmp = vCounter + @as(c_int, 2); + if (tmp >= 0) break :blk mesh.vertices + @as(usize, @intCast(tmp)) else break :blk mesh.vertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*, + }; + animVertex = Vector3Subtract(animVertex, inTranslation); + animVertex = Vector3Multiply(animVertex, outScale); + animVertex = Vector3RotateByQuaternion(animVertex, QuaternionMultiply(outRotation, QuaternionInvert(inRotation))); + animVertex = Vector3Add(animVertex, outTranslation); + (blk: { + const tmp = vCounter; + if (tmp >= 0) break :blk mesh.animVertices + @as(usize, @intCast(tmp)) else break :blk mesh.animVertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* += animVertex.x * boneWeight; + (blk: { + const tmp = vCounter + @as(c_int, 1); + if (tmp >= 0) break :blk mesh.animVertices + @as(usize, @intCast(tmp)) else break :blk mesh.animVertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* += animVertex.y * boneWeight; + (blk: { + const tmp = vCounter + @as(c_int, 2); + if (tmp >= 0) break :blk mesh.animVertices + @as(usize, @intCast(tmp)) else break :blk mesh.animVertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* += animVertex.z * boneWeight; + updated = @as(c_int, 1) != 0; + if (mesh.normals != @as([*c]f32, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0))))))) { + animNormal = Vector3{ + .x = (blk: { + const tmp = vCounter; + if (tmp >= 0) break :blk mesh.normals + @as(usize, @intCast(tmp)) else break :blk mesh.normals - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*, + .y = (blk: { + const tmp = vCounter + @as(c_int, 1); + if (tmp >= 0) break :blk mesh.normals + @as(usize, @intCast(tmp)) else break :blk mesh.normals - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*, + .z = (blk: { + const tmp = vCounter + @as(c_int, 2); + if (tmp >= 0) break :blk mesh.normals + @as(usize, @intCast(tmp)) else break :blk mesh.normals - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*, + }; + animNormal = Vector3RotateByQuaternion(animNormal, QuaternionMultiply(outRotation, QuaternionInvert(inRotation))); + (blk: { + const tmp = vCounter; + if (tmp >= 0) break :blk mesh.animNormals + @as(usize, @intCast(tmp)) else break :blk mesh.animNormals - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* += animNormal.x * boneWeight; + (blk: { + const tmp = vCounter + @as(c_int, 1); + if (tmp >= 0) break :blk mesh.animNormals + @as(usize, @intCast(tmp)) else break :blk mesh.animNormals - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* += animNormal.y * boneWeight; + (blk: { + const tmp = vCounter + @as(c_int, 2); + if (tmp >= 0) break :blk mesh.animNormals + @as(usize, @intCast(tmp)) else break :blk mesh.animNormals - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* += animNormal.z * boneWeight; + } + } + } + } + } + if (updated) { + rlUpdateVertexBuffer(mesh.vboId[@as(c_uint, @intCast(@as(c_int, 0)))], @as(?*const anyopaque, @ptrCast(mesh.animVertices)), @as(c_int, @bitCast(@as(c_uint, @truncate(@as(c_ulong, @bitCast(@as(c_long, mesh.vertexCount * @as(c_int, 3)))) *% @sizeOf(f32))))), @as(c_int, 0)); + rlUpdateVertexBuffer(mesh.vboId[@as(c_uint, @intCast(@as(c_int, 2)))], @as(?*const anyopaque, @ptrCast(mesh.animNormals)), @as(c_int, @bitCast(@as(c_uint, @truncate(@as(c_ulong, @bitCast(@as(c_long, mesh.vertexCount * @as(c_int, 3)))) *% @sizeOf(f32))))), @as(c_int, 0)); + } + } + } + } +} +pub export fn UnloadModelAnimation(arg_anim: ModelAnimation) void { + var anim = arg_anim; + _ = &anim; + { + var i: c_int = 0; + _ = &i; + while (i < anim.frameCount) : (i += 1) { + free(@as(?*anyopaque, @ptrCast((blk: { + const tmp = i; + if (tmp >= 0) break :blk anim.framePoses + @as(usize, @intCast(tmp)) else break :blk anim.framePoses - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*))); + } + } + free(@as(?*anyopaque, @ptrCast(anim.bones))); + free(@as(?*anyopaque, @ptrCast(anim.framePoses))); +} +pub export fn UnloadModelAnimations(arg_animations: [*c]ModelAnimation, arg_animCount: c_int) void { + var animations = arg_animations; + _ = &animations; + var animCount = arg_animCount; + _ = &animCount; + { + var i: c_int = 0; + _ = &i; + while (i < animCount) : (i += 1) { + UnloadModelAnimation((blk: { + const tmp = i; + if (tmp >= 0) break :blk animations + @as(usize, @intCast(tmp)) else break :blk animations - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*); + } + } + free(@as(?*anyopaque, @ptrCast(animations))); +} +pub export fn IsModelAnimationValid(arg_model: Model, arg_anim: ModelAnimation) bool { + var model = arg_model; + _ = &model; + var anim = arg_anim; + _ = &anim; + var result: c_int = 1; + _ = &result; + if (model.boneCount != anim.boneCount) { + result = 0; + } else { + { + var i: c_int = 0; + _ = &i; + while (i < model.boneCount) : (i += 1) { + if ((blk: { + const tmp = i; + if (tmp >= 0) break :blk model.bones + @as(usize, @intCast(tmp)) else break :blk model.bones - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.parent != (blk: { + const tmp = i; + if (tmp >= 0) break :blk anim.bones + @as(usize, @intCast(tmp)) else break :blk anim.bones - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.parent) { + result = 0; + break; + } + } + } + } + return result != 0; +} +pub export fn CheckCollisionSpheres(arg_center1: Vector3, arg_radius1: f32, arg_center2: Vector3, arg_radius2: f32) bool { + var center1 = arg_center1; + _ = ¢er1; + var radius1 = arg_radius1; + _ = &radius1; + var center2 = arg_center2; + _ = ¢er2; + var radius2 = arg_radius2; + _ = &radius2; + var collision: bool = @as(c_int, 0) != 0; + _ = &collision; + if (Vector3DotProduct(Vector3Subtract(center2, center1), Vector3Subtract(center2, center1)) <= ((radius1 + radius2) * (radius1 + radius2))) { + collision = @as(c_int, 1) != 0; + } + return collision; +} +pub export fn CheckCollisionBoxes(arg_box1: BoundingBox, arg_box2: BoundingBox) bool { + var box1 = arg_box1; + _ = &box1; + var box2 = arg_box2; + _ = &box2; + var collision: bool = @as(c_int, 1) != 0; + _ = &collision; + if ((box1.max.x >= box2.min.x) and (box1.min.x <= box2.max.x)) { + if ((box1.max.y < box2.min.y) or (box1.min.y > box2.max.y)) { + collision = @as(c_int, 0) != 0; + } + if ((box1.max.z < box2.min.z) or (box1.min.z > box2.max.z)) { + collision = @as(c_int, 0) != 0; + } + } else { + collision = @as(c_int, 0) != 0; + } + return collision; +} +pub export fn CheckCollisionBoxSphere(arg_box: BoundingBox, arg_center: Vector3, arg_radius: f32) bool { + var box = arg_box; + _ = &box; + var center = arg_center; + _ = ¢er; + var radius = arg_radius; + _ = &radius; + var collision: bool = @as(c_int, 0) != 0; + _ = &collision; + var dmin: f32 = 0; + _ = &dmin; + if (center.x < box.min.x) { + dmin += powf(center.x - box.min.x, @as(f32, @floatFromInt(@as(c_int, 2)))); + } else if (center.x > box.max.x) { + dmin += powf(center.x - box.max.x, @as(f32, @floatFromInt(@as(c_int, 2)))); + } + if (center.y < box.min.y) { + dmin += powf(center.y - box.min.y, @as(f32, @floatFromInt(@as(c_int, 2)))); + } else if (center.y > box.max.y) { + dmin += powf(center.y - box.max.y, @as(f32, @floatFromInt(@as(c_int, 2)))); + } + if (center.z < box.min.z) { + dmin += powf(center.z - box.min.z, @as(f32, @floatFromInt(@as(c_int, 2)))); + } else if (center.z > box.max.z) { + dmin += powf(center.z - box.max.z, @as(f32, @floatFromInt(@as(c_int, 2)))); + } + if (dmin <= (radius * radius)) { + collision = @as(c_int, 1) != 0; + } + return collision; +} +pub export fn GetRayCollisionSphere(arg_ray: Ray, arg_center: Vector3, arg_radius: f32) RayCollision { + var ray = arg_ray; + _ = &ray; + var center = arg_center; + _ = ¢er; + var radius = arg_radius; + _ = &radius; + var collision: RayCollision = RayCollision{ + .hit = @as(c_int, 0) != 0, + .distance = 0, + .point = @import("std").mem.zeroes(Vector3), + .normal = @import("std").mem.zeroes(Vector3), + }; + _ = &collision; + var raySpherePos: Vector3 = Vector3Subtract(center, ray.position); + _ = &raySpherePos; + var vector: f32 = Vector3DotProduct(raySpherePos, ray.direction); + _ = &vector; + var distance: f32 = Vector3Length(raySpherePos); + _ = &distance; + var d: f32 = (radius * radius) - ((distance * distance) - (vector * vector)); + _ = &d; + collision.hit = d >= 0.0; + if (distance < radius) { + collision.distance = vector + sqrtf(d); + collision.point = Vector3Add(ray.position, Vector3Scale(ray.direction, collision.distance)); + collision.normal = Vector3Negate(Vector3Normalize(Vector3Subtract(collision.point, center))); + } else { + collision.distance = vector - sqrtf(d); + collision.point = Vector3Add(ray.position, Vector3Scale(ray.direction, collision.distance)); + collision.normal = Vector3Normalize(Vector3Subtract(collision.point, center)); + } + return collision; +} +pub export fn GetRayCollisionBox(arg_ray: Ray, arg_box: BoundingBox) RayCollision { + var ray = arg_ray; + _ = &ray; + var box = arg_box; + _ = &box; + var collision: RayCollision = RayCollision{ + .hit = @as(c_int, 0) != 0, + .distance = 0, + .point = @import("std").mem.zeroes(Vector3), + .normal = @import("std").mem.zeroes(Vector3), + }; + _ = &collision; + var insideBox: bool = (((((ray.position.x > box.min.x) and (ray.position.x < box.max.x)) and (ray.position.y > box.min.y)) and (ray.position.y < box.max.y)) and (ray.position.z > box.min.z)) and (ray.position.z < box.max.z); + _ = &insideBox; + if (insideBox) { + ray.direction = Vector3Negate(ray.direction); + } + var t: [11]f32 = [1]f32{ + 0, + } ++ [1]f32{0} ** 10; + _ = &t; + t[@as(c_uint, @intCast(@as(c_int, 8)))] = 1.0 / ray.direction.x; + t[@as(c_uint, @intCast(@as(c_int, 9)))] = 1.0 / ray.direction.y; + t[@as(c_uint, @intCast(@as(c_int, 10)))] = 1.0 / ray.direction.z; + t[@as(c_uint, @intCast(@as(c_int, 0)))] = (box.min.x - ray.position.x) * t[@as(c_uint, @intCast(@as(c_int, 8)))]; + t[@as(c_uint, @intCast(@as(c_int, 1)))] = (box.max.x - ray.position.x) * t[@as(c_uint, @intCast(@as(c_int, 8)))]; + t[@as(c_uint, @intCast(@as(c_int, 2)))] = (box.min.y - ray.position.y) * t[@as(c_uint, @intCast(@as(c_int, 9)))]; + t[@as(c_uint, @intCast(@as(c_int, 3)))] = (box.max.y - ray.position.y) * t[@as(c_uint, @intCast(@as(c_int, 9)))]; + t[@as(c_uint, @intCast(@as(c_int, 4)))] = (box.min.z - ray.position.z) * t[@as(c_uint, @intCast(@as(c_int, 10)))]; + t[@as(c_uint, @intCast(@as(c_int, 5)))] = (box.max.z - ray.position.z) * t[@as(c_uint, @intCast(@as(c_int, 10)))]; + t[@as(c_uint, @intCast(@as(c_int, 6)))] = @as(f32, @floatCast(fmax(fmax(fmin(@as(f64, @floatCast(t[@as(c_uint, @intCast(@as(c_int, 0)))])), @as(f64, @floatCast(t[@as(c_uint, @intCast(@as(c_int, 1)))]))), fmin(@as(f64, @floatCast(t[@as(c_uint, @intCast(@as(c_int, 2)))])), @as(f64, @floatCast(t[@as(c_uint, @intCast(@as(c_int, 3)))])))), fmin(@as(f64, @floatCast(t[@as(c_uint, @intCast(@as(c_int, 4)))])), @as(f64, @floatCast(t[@as(c_uint, @intCast(@as(c_int, 5)))])))))); + t[@as(c_uint, @intCast(@as(c_int, 7)))] = @as(f32, @floatCast(fmin(fmin(fmax(@as(f64, @floatCast(t[@as(c_uint, @intCast(@as(c_int, 0)))])), @as(f64, @floatCast(t[@as(c_uint, @intCast(@as(c_int, 1)))]))), fmax(@as(f64, @floatCast(t[@as(c_uint, @intCast(@as(c_int, 2)))])), @as(f64, @floatCast(t[@as(c_uint, @intCast(@as(c_int, 3)))])))), fmax(@as(f64, @floatCast(t[@as(c_uint, @intCast(@as(c_int, 4)))])), @as(f64, @floatCast(t[@as(c_uint, @intCast(@as(c_int, 5)))])))))); + collision.hit = !((t[@as(c_uint, @intCast(@as(c_int, 7)))] < @as(f32, @floatFromInt(@as(c_int, 0)))) or (t[@as(c_uint, @intCast(@as(c_int, 6)))] > t[@as(c_uint, @intCast(@as(c_int, 7)))])); + collision.distance = t[@as(c_uint, @intCast(@as(c_int, 6)))]; + collision.point = Vector3Add(ray.position, Vector3Scale(ray.direction, collision.distance)); + collision.normal = Vector3Lerp(box.min, box.max, 0.5); + collision.normal = Vector3Subtract(collision.point, collision.normal); + collision.normal = Vector3Scale(collision.normal, 2.009999990463257); + collision.normal = Vector3Divide(collision.normal, Vector3Subtract(box.max, box.min)); + collision.normal.x = @as(f32, @floatFromInt(@as(c_int, @intFromFloat(collision.normal.x)))); + collision.normal.y = @as(f32, @floatFromInt(@as(c_int, @intFromFloat(collision.normal.y)))); + collision.normal.z = @as(f32, @floatFromInt(@as(c_int, @intFromFloat(collision.normal.z)))); + collision.normal = Vector3Normalize(collision.normal); + if (insideBox) { + ray.direction = Vector3Negate(ray.direction); + collision.distance *= -1.0; + collision.normal = Vector3Negate(collision.normal); + } + return collision; +} +pub export fn GetRayCollisionMesh(arg_ray: Ray, arg_mesh: Mesh, arg_transform: Matrix) RayCollision { + var ray = arg_ray; + _ = &ray; + var mesh = arg_mesh; + _ = &mesh; + var transform = arg_transform; + _ = &transform; + var collision: RayCollision = RayCollision{ + .hit = @as(c_int, 0) != 0, + .distance = 0, + .point = @import("std").mem.zeroes(Vector3), + .normal = @import("std").mem.zeroes(Vector3), + }; + _ = &collision; + if (mesh.vertices != @as([*c]f32, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0))))))) { + var triangleCount: c_int = mesh.triangleCount; + _ = &triangleCount; + { + var i: c_int = 0; + _ = &i; + while (i < triangleCount) : (i += 1) { + var a: Vector3 = undefined; + _ = &a; + var b: Vector3 = undefined; + _ = &b; + var c: Vector3 = undefined; + _ = &c; + var vertdata: [*c]Vector3 = @as([*c]Vector3, @ptrCast(@alignCast(mesh.vertices))); + _ = &vertdata; + if (mesh.indices != null) { + a = vertdata[(blk: { + const tmp = (i * @as(c_int, 3)) + @as(c_int, 0); + if (tmp >= 0) break :blk mesh.indices + @as(usize, @intCast(tmp)) else break :blk mesh.indices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*]; + b = vertdata[(blk: { + const tmp = (i * @as(c_int, 3)) + @as(c_int, 1); + if (tmp >= 0) break :blk mesh.indices + @as(usize, @intCast(tmp)) else break :blk mesh.indices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*]; + c = vertdata[(blk: { + const tmp = (i * @as(c_int, 3)) + @as(c_int, 2); + if (tmp >= 0) break :blk mesh.indices + @as(usize, @intCast(tmp)) else break :blk mesh.indices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*]; + } else { + a = (blk: { + const tmp = (i * @as(c_int, 3)) + @as(c_int, 0); + if (tmp >= 0) break :blk vertdata + @as(usize, @intCast(tmp)) else break :blk vertdata - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*; + b = (blk: { + const tmp = (i * @as(c_int, 3)) + @as(c_int, 1); + if (tmp >= 0) break :blk vertdata + @as(usize, @intCast(tmp)) else break :blk vertdata - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*; + c = (blk: { + const tmp = (i * @as(c_int, 3)) + @as(c_int, 2); + if (tmp >= 0) break :blk vertdata + @as(usize, @intCast(tmp)) else break :blk vertdata - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*; + } + a = Vector3Transform(a, transform); + b = Vector3Transform(b, transform); + c = Vector3Transform(c, transform); + var triHitInfo: RayCollision = GetRayCollisionTriangle(ray, a, b, c); + _ = &triHitInfo; + if (triHitInfo.hit) { + if (!collision.hit or (collision.distance > triHitInfo.distance)) { + collision = triHitInfo; + } + } + } + } + } + return collision; +} +pub export fn GetRayCollisionTriangle(arg_ray: Ray, arg_p1: Vector3, arg_p2: Vector3, arg_p3: Vector3) RayCollision { + var ray = arg_ray; + _ = &ray; + var p1 = arg_p1; + _ = &p1; + var p2 = arg_p2; + _ = &p2; + var p3 = arg_p3; + _ = &p3; + var collision: RayCollision = RayCollision{ + .hit = @as(c_int, 0) != 0, + .distance = 0, + .point = @import("std").mem.zeroes(Vector3), + .normal = @import("std").mem.zeroes(Vector3), + }; + _ = &collision; + var edge1: Vector3 = Vector3{ + .x = @as(f32, @floatFromInt(@as(c_int, 0))), + .y = 0, + .z = 0, + }; + _ = &edge1; + var edge2: Vector3 = Vector3{ + .x = @as(f32, @floatFromInt(@as(c_int, 0))), + .y = 0, + .z = 0, + }; + _ = &edge2; + var p: Vector3 = undefined; + _ = &p; + var q: Vector3 = undefined; + _ = &q; + var tv: Vector3 = undefined; + _ = &tv; + var det: f32 = undefined; + _ = &det; + var invDet: f32 = undefined; + _ = &invDet; + var u: f32 = undefined; + _ = &u; + var v: f32 = undefined; + _ = &v; + var t: f32 = undefined; + _ = &t; + edge1 = Vector3Subtract(p2, p1); + edge2 = Vector3Subtract(p3, p1); + p = Vector3CrossProduct(ray.direction, edge2); + det = Vector3DotProduct(edge1, p); + if ((det > -0.0000009999999974752427) and (det < 0.0000009999999974752427)) return collision; + invDet = 1.0 / det; + tv = Vector3Subtract(ray.position, p1); + u = Vector3DotProduct(tv, p) * invDet; + if ((u < 0.0) or (u > 1.0)) return collision; + q = Vector3CrossProduct(tv, edge1); + v = Vector3DotProduct(ray.direction, q) * invDet; + if ((v < 0.0) or ((u + v) > 1.0)) return collision; + t = Vector3DotProduct(edge2, q) * invDet; + if (t > 0.0000009999999974752427) { + collision.hit = @as(c_int, 1) != 0; + collision.distance = t; + collision.normal = Vector3Normalize(Vector3CrossProduct(edge1, edge2)); + collision.point = Vector3Add(ray.position, Vector3Scale(ray.direction, t)); + } + return collision; +} +pub export fn GetRayCollisionQuad(arg_ray: Ray, arg_p1: Vector3, arg_p2: Vector3, arg_p3: Vector3, arg_p4: Vector3) RayCollision { + var ray = arg_ray; + _ = &ray; + var p1 = arg_p1; + _ = &p1; + var p2 = arg_p2; + _ = &p2; + var p3 = arg_p3; + _ = &p3; + var p4 = arg_p4; + _ = &p4; + var collision: RayCollision = RayCollision{ + .hit = @as(c_int, 0) != 0, + .distance = 0, + .point = @import("std").mem.zeroes(Vector3), + .normal = @import("std").mem.zeroes(Vector3), + }; + _ = &collision; + collision = GetRayCollisionTriangle(ray, p1, p2, p4); + if (!collision.hit) { + collision = GetRayCollisionTriangle(ray, p2, p3, p4); + } + return collision; +} +pub const AudioCallback = ?*const fn (?*anyopaque, c_uint) callconv(.C) void; +pub extern fn InitAudioDevice() void; +pub extern fn CloseAudioDevice() void; +pub extern fn IsAudioDeviceReady() bool; +pub extern fn SetMasterVolume(volume: f32) void; +pub extern fn GetMasterVolume() f32; +pub extern fn LoadWave(fileName: [*c]const u8) Wave; +pub extern fn LoadWaveFromMemory(fileType: [*c]const u8, fileData: [*c]const u8, dataSize: c_int) Wave; +pub extern fn IsWaveReady(wave: Wave) bool; +pub extern fn LoadSound(fileName: [*c]const u8) Sound; +pub extern fn LoadSoundFromWave(wave: Wave) Sound; +pub extern fn LoadSoundAlias(source: Sound) Sound; +pub extern fn IsSoundReady(sound: Sound) bool; +pub extern fn UpdateSound(sound: Sound, data: ?*const anyopaque, sampleCount: c_int) void; +pub extern fn UnloadWave(wave: Wave) void; +pub extern fn UnloadSound(sound: Sound) void; +pub extern fn UnloadSoundAlias(alias: Sound) void; +pub extern fn ExportWave(wave: Wave, fileName: [*c]const u8) bool; +pub extern fn ExportWaveAsCode(wave: Wave, fileName: [*c]const u8) bool; +pub extern fn PlaySound(sound: Sound) void; +pub extern fn StopSound(sound: Sound) void; +pub extern fn PauseSound(sound: Sound) void; +pub extern fn ResumeSound(sound: Sound) void; +pub extern fn IsSoundPlaying(sound: Sound) bool; +pub extern fn SetSoundVolume(sound: Sound, volume: f32) void; +pub extern fn SetSoundPitch(sound: Sound, pitch: f32) void; +pub extern fn SetSoundPan(sound: Sound, pan: f32) void; +pub extern fn WaveCopy(wave: Wave) Wave; +pub extern fn WaveCrop(wave: [*c]Wave, initFrame: c_int, finalFrame: c_int) void; +pub extern fn WaveFormat(wave: [*c]Wave, sampleRate: c_int, sampleSize: c_int, channels: c_int) void; +pub extern fn LoadWaveSamples(wave: Wave) [*c]f32; +pub extern fn UnloadWaveSamples(samples: [*c]f32) void; +pub extern fn LoadMusicStream(fileName: [*c]const u8) Music; +pub extern fn LoadMusicStreamFromMemory(fileType: [*c]const u8, data: [*c]const u8, dataSize: c_int) Music; +pub extern fn IsMusicReady(music: Music) bool; +pub extern fn UnloadMusicStream(music: Music) void; +pub extern fn PlayMusicStream(music: Music) void; +pub extern fn IsMusicStreamPlaying(music: Music) bool; +pub extern fn UpdateMusicStream(music: Music) void; +pub extern fn StopMusicStream(music: Music) void; +pub extern fn PauseMusicStream(music: Music) void; +pub extern fn ResumeMusicStream(music: Music) void; +pub extern fn SeekMusicStream(music: Music, position: f32) void; +pub extern fn SetMusicVolume(music: Music, volume: f32) void; +pub extern fn SetMusicPitch(music: Music, pitch: f32) void; +pub extern fn SetMusicPan(music: Music, pan: f32) void; +pub extern fn GetMusicTimeLength(music: Music) f32; +pub extern fn GetMusicTimePlayed(music: Music) f32; +pub extern fn LoadAudioStream(sampleRate: c_uint, sampleSize: c_uint, channels: c_uint) AudioStream; +pub extern fn IsAudioStreamReady(stream: AudioStream) bool; +pub extern fn UnloadAudioStream(stream: AudioStream) void; +pub extern fn UpdateAudioStream(stream: AudioStream, data: ?*const anyopaque, frameCount: c_int) void; +pub extern fn IsAudioStreamProcessed(stream: AudioStream) bool; +pub extern fn PlayAudioStream(stream: AudioStream) void; +pub extern fn PauseAudioStream(stream: AudioStream) void; +pub extern fn ResumeAudioStream(stream: AudioStream) void; +pub extern fn IsAudioStreamPlaying(stream: AudioStream) bool; +pub extern fn StopAudioStream(stream: AudioStream) void; +pub extern fn SetAudioStreamVolume(stream: AudioStream, volume: f32) void; +pub extern fn SetAudioStreamPitch(stream: AudioStream, pitch: f32) void; +pub extern fn SetAudioStreamPan(stream: AudioStream, pan: f32) void; +pub extern fn SetAudioStreamBufferSizeDefault(size: c_int) void; +pub extern fn SetAudioStreamCallback(stream: AudioStream, callback: AudioCallback) void; +pub extern fn AttachAudioStreamProcessor(stream: AudioStream, processor: AudioCallback) void; +pub extern fn DetachAudioStreamProcessor(stream: AudioStream, processor: AudioCallback) void; +pub extern fn AttachAudioMixedProcessor(processor: AudioCallback) void; +pub extern fn DetachAudioMixedProcessor(processor: AudioCallback) void; +pub const struct_rlVertexBuffer = extern struct { + elementCount: c_int = @import("std").mem.zeroes(c_int), + vertices: [*c]f32 = @import("std").mem.zeroes([*c]f32), + texcoords: [*c]f32 = @import("std").mem.zeroes([*c]f32), + normals: [*c]f32 = @import("std").mem.zeroes([*c]f32), + colors: [*c]u8 = @import("std").mem.zeroes([*c]u8), + indices: [*c]c_uint = @import("std").mem.zeroes([*c]c_uint), + vaoId: c_uint = @import("std").mem.zeroes(c_uint), + vboId: [5]c_uint = @import("std").mem.zeroes([5]c_uint), +}; +pub const rlVertexBuffer = struct_rlVertexBuffer; +pub const struct_rlDrawCall = extern struct { + mode: c_int = @import("std").mem.zeroes(c_int), + vertexCount: c_int = @import("std").mem.zeroes(c_int), + vertexAlignment: c_int = @import("std").mem.zeroes(c_int), + textureId: c_uint = @import("std").mem.zeroes(c_uint), +}; +pub const rlDrawCall = struct_rlDrawCall; +pub const struct_rlRenderBatch = extern struct { + bufferCount: c_int = @import("std").mem.zeroes(c_int), + currentBuffer: c_int = @import("std").mem.zeroes(c_int), + vertexBuffer: [*c]rlVertexBuffer = @import("std").mem.zeroes([*c]rlVertexBuffer), + draws: [*c]rlDrawCall = @import("std").mem.zeroes([*c]rlDrawCall), + drawCounter: c_int = @import("std").mem.zeroes(c_int), + currentDepth: f32 = @import("std").mem.zeroes(f32), +}; +pub const rlRenderBatch = struct_rlRenderBatch; +pub const RL_OPENGL_11: c_int = 1; +pub const RL_OPENGL_21: c_int = 2; +pub const RL_OPENGL_33: c_int = 3; +pub const RL_OPENGL_43: c_int = 4; +pub const RL_OPENGL_ES_20: c_int = 5; +pub const RL_OPENGL_ES_30: c_int = 6; +pub const rlGlVersion = c_uint; +pub const RL_LOG_ALL: c_int = 0; +pub const RL_LOG_TRACE: c_int = 1; +pub const RL_LOG_DEBUG: c_int = 2; +pub const RL_LOG_INFO: c_int = 3; +pub const RL_LOG_WARNING: c_int = 4; +pub const RL_LOG_ERROR: c_int = 5; +pub const RL_LOG_FATAL: c_int = 6; +pub const RL_LOG_NONE: c_int = 7; +pub const rlTraceLogLevel = c_uint; +pub const RL_PIXELFORMAT_UNCOMPRESSED_GRAYSCALE: c_int = 1; +pub const RL_PIXELFORMAT_UNCOMPRESSED_GRAY_ALPHA: c_int = 2; +pub const RL_PIXELFORMAT_UNCOMPRESSED_R5G6B5: c_int = 3; +pub const RL_PIXELFORMAT_UNCOMPRESSED_R8G8B8: c_int = 4; +pub const RL_PIXELFORMAT_UNCOMPRESSED_R5G5B5A1: c_int = 5; +pub const RL_PIXELFORMAT_UNCOMPRESSED_R4G4B4A4: c_int = 6; +pub const RL_PIXELFORMAT_UNCOMPRESSED_R8G8B8A8: c_int = 7; +pub const RL_PIXELFORMAT_UNCOMPRESSED_R32: c_int = 8; +pub const RL_PIXELFORMAT_UNCOMPRESSED_R32G32B32: c_int = 9; +pub const RL_PIXELFORMAT_UNCOMPRESSED_R32G32B32A32: c_int = 10; +pub const RL_PIXELFORMAT_UNCOMPRESSED_R16: c_int = 11; +pub const RL_PIXELFORMAT_UNCOMPRESSED_R16G16B16: c_int = 12; +pub const RL_PIXELFORMAT_UNCOMPRESSED_R16G16B16A16: c_int = 13; +pub const RL_PIXELFORMAT_COMPRESSED_DXT1_RGB: c_int = 14; +pub const RL_PIXELFORMAT_COMPRESSED_DXT1_RGBA: c_int = 15; +pub const RL_PIXELFORMAT_COMPRESSED_DXT3_RGBA: c_int = 16; +pub const RL_PIXELFORMAT_COMPRESSED_DXT5_RGBA: c_int = 17; +pub const RL_PIXELFORMAT_COMPRESSED_ETC1_RGB: c_int = 18; +pub const RL_PIXELFORMAT_COMPRESSED_ETC2_RGB: c_int = 19; +pub const RL_PIXELFORMAT_COMPRESSED_ETC2_EAC_RGBA: c_int = 20; +pub const RL_PIXELFORMAT_COMPRESSED_PVRT_RGB: c_int = 21; +pub const RL_PIXELFORMAT_COMPRESSED_PVRT_RGBA: c_int = 22; +pub const RL_PIXELFORMAT_COMPRESSED_ASTC_4x4_RGBA: c_int = 23; +pub const RL_PIXELFORMAT_COMPRESSED_ASTC_8x8_RGBA: c_int = 24; +pub const rlPixelFormat = c_uint; +pub const RL_TEXTURE_FILTER_POINT: c_int = 0; +pub const RL_TEXTURE_FILTER_BILINEAR: c_int = 1; +pub const RL_TEXTURE_FILTER_TRILINEAR: c_int = 2; +pub const RL_TEXTURE_FILTER_ANISOTROPIC_4X: c_int = 3; +pub const RL_TEXTURE_FILTER_ANISOTROPIC_8X: c_int = 4; +pub const RL_TEXTURE_FILTER_ANISOTROPIC_16X: c_int = 5; +pub const rlTextureFilter = c_uint; +pub const RL_BLEND_ALPHA: c_int = 0; +pub const RL_BLEND_ADDITIVE: c_int = 1; +pub const RL_BLEND_MULTIPLIED: c_int = 2; +pub const RL_BLEND_ADD_COLORS: c_int = 3; +pub const RL_BLEND_SUBTRACT_COLORS: c_int = 4; +pub const RL_BLEND_ALPHA_PREMULTIPLY: c_int = 5; +pub const RL_BLEND_CUSTOM: c_int = 6; +pub const RL_BLEND_CUSTOM_SEPARATE: c_int = 7; +pub const rlBlendMode = c_uint; +pub const RL_SHADER_LOC_VERTEX_POSITION: c_int = 0; +pub const RL_SHADER_LOC_VERTEX_TEXCOORD01: c_int = 1; +pub const RL_SHADER_LOC_VERTEX_TEXCOORD02: c_int = 2; +pub const RL_SHADER_LOC_VERTEX_NORMAL: c_int = 3; +pub const RL_SHADER_LOC_VERTEX_TANGENT: c_int = 4; +pub const RL_SHADER_LOC_VERTEX_COLOR: c_int = 5; +pub const RL_SHADER_LOC_MATRIX_MVP: c_int = 6; +pub const RL_SHADER_LOC_MATRIX_VIEW: c_int = 7; +pub const RL_SHADER_LOC_MATRIX_PROJECTION: c_int = 8; +pub const RL_SHADER_LOC_MATRIX_MODEL: c_int = 9; +pub const RL_SHADER_LOC_MATRIX_NORMAL: c_int = 10; +pub const RL_SHADER_LOC_VECTOR_VIEW: c_int = 11; +pub const RL_SHADER_LOC_COLOR_DIFFUSE: c_int = 12; +pub const RL_SHADER_LOC_COLOR_SPECULAR: c_int = 13; +pub const RL_SHADER_LOC_COLOR_AMBIENT: c_int = 14; +pub const RL_SHADER_LOC_MAP_ALBEDO: c_int = 15; +pub const RL_SHADER_LOC_MAP_METALNESS: c_int = 16; +pub const RL_SHADER_LOC_MAP_NORMAL: c_int = 17; +pub const RL_SHADER_LOC_MAP_ROUGHNESS: c_int = 18; +pub const RL_SHADER_LOC_MAP_OCCLUSION: c_int = 19; +pub const RL_SHADER_LOC_MAP_EMISSION: c_int = 20; +pub const RL_SHADER_LOC_MAP_HEIGHT: c_int = 21; +pub const RL_SHADER_LOC_MAP_CUBEMAP: c_int = 22; +pub const RL_SHADER_LOC_MAP_IRRADIANCE: c_int = 23; +pub const RL_SHADER_LOC_MAP_PREFILTER: c_int = 24; +pub const RL_SHADER_LOC_MAP_BRDF: c_int = 25; +pub const rlShaderLocationIndex = c_uint; +pub const RL_SHADER_UNIFORM_FLOAT: c_int = 0; +pub const RL_SHADER_UNIFORM_VEC2: c_int = 1; +pub const RL_SHADER_UNIFORM_VEC3: c_int = 2; +pub const RL_SHADER_UNIFORM_VEC4: c_int = 3; +pub const RL_SHADER_UNIFORM_INT: c_int = 4; +pub const RL_SHADER_UNIFORM_IVEC2: c_int = 5; +pub const RL_SHADER_UNIFORM_IVEC3: c_int = 6; +pub const RL_SHADER_UNIFORM_IVEC4: c_int = 7; +pub const RL_SHADER_UNIFORM_UINT: c_int = 8; +pub const RL_SHADER_UNIFORM_UIVEC2: c_int = 9; +pub const RL_SHADER_UNIFORM_UIVEC3: c_int = 10; +pub const RL_SHADER_UNIFORM_UIVEC4: c_int = 11; +pub const RL_SHADER_UNIFORM_SAMPLER2D: c_int = 12; +pub const rlShaderUniformDataType = c_uint; +pub const RL_SHADER_ATTRIB_FLOAT: c_int = 0; +pub const RL_SHADER_ATTRIB_VEC2: c_int = 1; +pub const RL_SHADER_ATTRIB_VEC3: c_int = 2; +pub const RL_SHADER_ATTRIB_VEC4: c_int = 3; +pub const rlShaderAttributeDataType = c_uint; +pub const RL_ATTACHMENT_COLOR_CHANNEL0: c_int = 0; +pub const RL_ATTACHMENT_COLOR_CHANNEL1: c_int = 1; +pub const RL_ATTACHMENT_COLOR_CHANNEL2: c_int = 2; +pub const RL_ATTACHMENT_COLOR_CHANNEL3: c_int = 3; +pub const RL_ATTACHMENT_COLOR_CHANNEL4: c_int = 4; +pub const RL_ATTACHMENT_COLOR_CHANNEL5: c_int = 5; +pub const RL_ATTACHMENT_COLOR_CHANNEL6: c_int = 6; +pub const RL_ATTACHMENT_COLOR_CHANNEL7: c_int = 7; +pub const RL_ATTACHMENT_DEPTH: c_int = 100; +pub const RL_ATTACHMENT_STENCIL: c_int = 200; +pub const rlFramebufferAttachType = c_uint; +pub const RL_ATTACHMENT_CUBEMAP_POSITIVE_X: c_int = 0; +pub const RL_ATTACHMENT_CUBEMAP_NEGATIVE_X: c_int = 1; +pub const RL_ATTACHMENT_CUBEMAP_POSITIVE_Y: c_int = 2; +pub const RL_ATTACHMENT_CUBEMAP_NEGATIVE_Y: c_int = 3; +pub const RL_ATTACHMENT_CUBEMAP_POSITIVE_Z: c_int = 4; +pub const RL_ATTACHMENT_CUBEMAP_NEGATIVE_Z: c_int = 5; +pub const RL_ATTACHMENT_TEXTURE2D: c_int = 100; +pub const RL_ATTACHMENT_RENDERBUFFER: c_int = 200; +pub const rlFramebufferAttachTextureType = c_uint; +pub const RL_CULL_FACE_FRONT: c_int = 0; +pub const RL_CULL_FACE_BACK: c_int = 1; +pub const rlCullMode = c_uint; +pub extern fn rlMatrixMode(mode: c_int) void; +pub extern fn rlPushMatrix() void; +pub extern fn rlPopMatrix() void; +pub extern fn rlLoadIdentity() void; +pub extern fn rlTranslatef(x: f32, y: f32, z: f32) void; +pub extern fn rlRotatef(angle: f32, x: f32, y: f32, z: f32) void; +pub extern fn rlScalef(x: f32, y: f32, z: f32) void; +pub extern fn rlMultMatrixf(matf: [*c]const f32) void; +pub extern fn rlFrustum(left: f64, right: f64, bottom: f64, top: f64, znear: f64, zfar: f64) void; +pub extern fn rlOrtho(left: f64, right: f64, bottom: f64, top: f64, znear: f64, zfar: f64) void; +pub extern fn rlViewport(x: c_int, y: c_int, width: c_int, height: c_int) void; +pub extern fn rlSetClipPlanes(nearPlane: f64, farPlane: f64) void; +pub extern fn rlGetCullDistanceNear() f64; +pub extern fn rlGetCullDistanceFar() f64; +pub extern fn rlBegin(mode: c_int) void; +pub extern fn rlEnd() void; +pub extern fn rlVertex2i(x: c_int, y: c_int) void; +pub extern fn rlVertex2f(x: f32, y: f32) void; +pub extern fn rlVertex3f(x: f32, y: f32, z: f32) void; +pub extern fn rlTexCoord2f(x: f32, y: f32) void; +pub extern fn rlNormal3f(x: f32, y: f32, z: f32) void; +pub extern fn rlColor4ub(r: u8, g: u8, b: u8, a: u8) void; +pub extern fn rlColor3f(x: f32, y: f32, z: f32) void; +pub extern fn rlColor4f(x: f32, y: f32, z: f32, w: f32) void; +pub extern fn rlEnableVertexArray(vaoId: c_uint) bool; +pub extern fn rlDisableVertexArray() void; +pub extern fn rlEnableVertexBuffer(id: c_uint) void; +pub extern fn rlDisableVertexBuffer() void; +pub extern fn rlEnableVertexBufferElement(id: c_uint) void; +pub extern fn rlDisableVertexBufferElement() void; +pub extern fn rlEnableVertexAttribute(index: c_uint) void; +pub extern fn rlDisableVertexAttribute(index: c_uint) void; +pub extern fn rlActiveTextureSlot(slot: c_int) void; +pub extern fn rlEnableTexture(id: c_uint) void; +pub extern fn rlDisableTexture() void; +pub extern fn rlEnableTextureCubemap(id: c_uint) void; +pub extern fn rlDisableTextureCubemap() void; +pub extern fn rlTextureParameters(id: c_uint, param: c_int, value: c_int) void; +pub extern fn rlCubemapParameters(id: c_uint, param: c_int, value: c_int) void; +pub extern fn rlEnableShader(id: c_uint) void; +pub extern fn rlDisableShader() void; +pub extern fn rlEnableFramebuffer(id: c_uint) void; +pub extern fn rlDisableFramebuffer() void; +pub extern fn rlGetActiveFramebuffer() c_uint; +pub extern fn rlActiveDrawBuffers(count: c_int) void; +pub extern fn rlBlitFramebuffer(srcX: c_int, srcY: c_int, srcWidth: c_int, srcHeight: c_int, dstX: c_int, dstY: c_int, dstWidth: c_int, dstHeight: c_int, bufferMask: c_int) void; +pub extern fn rlBindFramebuffer(target: c_uint, framebuffer: c_uint) void; +pub extern fn rlEnableColorBlend() void; +pub extern fn rlDisableColorBlend() void; +pub extern fn rlEnableDepthTest() void; +pub extern fn rlDisableDepthTest() void; +pub extern fn rlEnableDepthMask() void; +pub extern fn rlDisableDepthMask() void; +pub extern fn rlEnableBackfaceCulling() void; +pub extern fn rlDisableBackfaceCulling() void; +pub extern fn rlColorMask(r: bool, g: bool, b: bool, a: bool) void; +pub extern fn rlSetCullFace(mode: c_int) void; +pub extern fn rlEnableScissorTest() void; +pub extern fn rlDisableScissorTest() void; +pub extern fn rlScissor(x: c_int, y: c_int, width: c_int, height: c_int) void; +pub extern fn rlEnableWireMode() void; +pub extern fn rlEnablePointMode() void; +pub extern fn rlDisableWireMode() void; +pub extern fn rlSetLineWidth(width: f32) void; +pub extern fn rlGetLineWidth() f32; +pub extern fn rlEnableSmoothLines() void; +pub extern fn rlDisableSmoothLines() void; +pub extern fn rlEnableStereoRender() void; +pub extern fn rlDisableStereoRender() void; +pub extern fn rlIsStereoRenderEnabled() bool; +pub extern fn rlClearColor(r: u8, g: u8, b: u8, a: u8) void; +pub extern fn rlClearScreenBuffers() void; +pub extern fn rlCheckErrors() void; +pub extern fn rlSetBlendMode(mode: c_int) void; +pub extern fn rlSetBlendFactors(glSrcFactor: c_int, glDstFactor: c_int, glEquation: c_int) void; +pub extern fn rlSetBlendFactorsSeparate(glSrcRGB: c_int, glDstRGB: c_int, glSrcAlpha: c_int, glDstAlpha: c_int, glEqRGB: c_int, glEqAlpha: c_int) void; +pub extern fn rlglInit(width: c_int, height: c_int) void; +pub extern fn rlglClose() void; +pub extern fn rlLoadExtensions(loader: ?*anyopaque) void; +pub extern fn rlGetVersion() c_int; +pub extern fn rlSetFramebufferWidth(width: c_int) void; +pub extern fn rlGetFramebufferWidth() c_int; +pub extern fn rlSetFramebufferHeight(height: c_int) void; +pub extern fn rlGetFramebufferHeight() c_int; +pub extern fn rlGetTextureIdDefault() c_uint; +pub extern fn rlGetShaderIdDefault() c_uint; +pub extern fn rlGetShaderLocsDefault() [*c]c_int; +pub extern fn rlLoadRenderBatch(numBuffers: c_int, bufferElements: c_int) rlRenderBatch; +pub extern fn rlUnloadRenderBatch(batch: rlRenderBatch) void; +pub extern fn rlDrawRenderBatch(batch: [*c]rlRenderBatch) void; +pub extern fn rlSetRenderBatchActive(batch: [*c]rlRenderBatch) void; +pub extern fn rlDrawRenderBatchActive() void; +pub extern fn rlCheckRenderBatchLimit(vCount: c_int) bool; +pub extern fn rlSetTexture(id: c_uint) void; +pub extern fn rlLoadVertexArray() c_uint; +pub extern fn rlLoadVertexBuffer(buffer: ?*const anyopaque, size: c_int, dynamic: bool) c_uint; +pub extern fn rlLoadVertexBufferElement(buffer: ?*const anyopaque, size: c_int, dynamic: bool) c_uint; +pub extern fn rlUpdateVertexBuffer(bufferId: c_uint, data: ?*const anyopaque, dataSize: c_int, offset: c_int) void; +pub extern fn rlUpdateVertexBufferElements(id: c_uint, data: ?*const anyopaque, dataSize: c_int, offset: c_int) void; +pub extern fn rlUnloadVertexArray(vaoId: c_uint) void; +pub extern fn rlUnloadVertexBuffer(vboId: c_uint) void; +pub extern fn rlSetVertexAttribute(index: c_uint, compSize: c_int, @"type": c_int, normalized: bool, stride: c_int, offset: c_int) void; +pub extern fn rlSetVertexAttributeDivisor(index: c_uint, divisor: c_int) void; +pub extern fn rlSetVertexAttributeDefault(locIndex: c_int, value: ?*const anyopaque, attribType: c_int, count: c_int) void; +pub extern fn rlDrawVertexArray(offset: c_int, count: c_int) void; +pub extern fn rlDrawVertexArrayElements(offset: c_int, count: c_int, buffer: ?*const anyopaque) void; +pub extern fn rlDrawVertexArrayInstanced(offset: c_int, count: c_int, instances: c_int) void; +pub extern fn rlDrawVertexArrayElementsInstanced(offset: c_int, count: c_int, buffer: ?*const anyopaque, instances: c_int) void; +pub extern fn rlLoadTexture(data: ?*const anyopaque, width: c_int, height: c_int, format: c_int, mipmapCount: c_int) c_uint; +pub extern fn rlLoadTextureDepth(width: c_int, height: c_int, useRenderBuffer: bool) c_uint; +pub extern fn rlLoadTextureCubemap(data: ?*const anyopaque, size: c_int, format: c_int) c_uint; +pub extern fn rlUpdateTexture(id: c_uint, offsetX: c_int, offsetY: c_int, width: c_int, height: c_int, format: c_int, data: ?*const anyopaque) void; +pub extern fn rlGetGlTextureFormats(format: c_int, glInternalFormat: [*c]c_uint, glFormat: [*c]c_uint, glType: [*c]c_uint) void; +pub extern fn rlGetPixelFormatName(format: c_uint) [*c]const u8; +pub extern fn rlUnloadTexture(id: c_uint) void; +pub extern fn rlGenTextureMipmaps(id: c_uint, width: c_int, height: c_int, format: c_int, mipmaps: [*c]c_int) void; +pub extern fn rlReadTexturePixels(id: c_uint, width: c_int, height: c_int, format: c_int) ?*anyopaque; +pub extern fn rlReadScreenPixels(width: c_int, height: c_int) [*c]u8; +pub extern fn rlLoadFramebuffer() c_uint; +pub extern fn rlFramebufferAttach(fboId: c_uint, texId: c_uint, attachType: c_int, texType: c_int, mipLevel: c_int) void; +pub extern fn rlFramebufferComplete(id: c_uint) bool; +pub extern fn rlUnloadFramebuffer(id: c_uint) void; +pub extern fn rlLoadShaderCode(vsCode: [*c]const u8, fsCode: [*c]const u8) c_uint; +pub extern fn rlCompileShader(shaderCode: [*c]const u8, @"type": c_int) c_uint; +pub extern fn rlLoadShaderProgram(vShaderId: c_uint, fShaderId: c_uint) c_uint; +pub extern fn rlUnloadShaderProgram(id: c_uint) void; +pub extern fn rlGetLocationUniform(shaderId: c_uint, uniformName: [*c]const u8) c_int; +pub extern fn rlGetLocationAttrib(shaderId: c_uint, attribName: [*c]const u8) c_int; +pub extern fn rlSetUniform(locIndex: c_int, value: ?*const anyopaque, uniformType: c_int, count: c_int) void; +pub extern fn rlSetUniformMatrix(locIndex: c_int, mat: Matrix) void; +pub extern fn rlSetUniformSampler(locIndex: c_int, textureId: c_uint) void; +pub extern fn rlSetShader(id: c_uint, locs: [*c]c_int) void; +pub extern fn rlLoadComputeShaderProgram(shaderId: c_uint) c_uint; +pub extern fn rlComputeShaderDispatch(groupX: c_uint, groupY: c_uint, groupZ: c_uint) void; +pub extern fn rlLoadShaderBuffer(size: c_uint, data: ?*const anyopaque, usageHint: c_int) c_uint; +pub extern fn rlUnloadShaderBuffer(ssboId: c_uint) void; +pub extern fn rlUpdateShaderBuffer(id: c_uint, data: ?*const anyopaque, dataSize: c_uint, offset: c_uint) void; +pub extern fn rlBindShaderBuffer(id: c_uint, index: c_uint) void; +pub extern fn rlReadShaderBuffer(id: c_uint, dest: ?*anyopaque, count: c_uint, offset: c_uint) void; +pub extern fn rlCopyShaderBuffer(destId: c_uint, srcId: c_uint, destOffset: c_uint, srcOffset: c_uint, count: c_uint) void; +pub extern fn rlGetShaderBufferSize(id: c_uint) c_uint; +pub extern fn rlBindImageTexture(id: c_uint, index: c_uint, format: c_int, readonly: bool) void; +pub extern fn rlGetMatrixModelview() Matrix; +pub extern fn rlGetMatrixProjection() Matrix; +pub extern fn rlGetMatrixTransform() Matrix; +pub extern fn rlGetMatrixProjectionStereo(eye: c_int) Matrix; +pub extern fn rlGetMatrixViewOffsetStereo(eye: c_int) Matrix; +pub extern fn rlSetMatrixProjection(proj: Matrix) void; +pub extern fn rlSetMatrixModelview(view: Matrix) void; +pub extern fn rlSetMatrixProjectionStereo(right: Matrix, left: Matrix) void; +pub extern fn rlSetMatrixViewOffsetStereo(right: Matrix, left: Matrix) void; +pub extern fn rlLoadDrawCube() void; +pub extern fn rlLoadDrawQuad() void; +pub const struct_float3 = extern struct { + v: [3]f32 = @import("std").mem.zeroes([3]f32), +}; +pub const float3 = struct_float3; +pub const __u_char = u8; +pub const __u_short = c_ushort; +pub const __u_int = c_uint; +pub const __u_long = c_ulong; +pub const __int8_t = i8; +pub const __uint8_t = u8; +pub const __int16_t = c_short; +pub const __uint16_t = c_ushort; +pub const __int32_t = c_int; +pub const __uint32_t = c_uint; +pub const __int64_t = c_long; +pub const __uint64_t = c_ulong; +pub const __int_least8_t = __int8_t; +pub const __uint_least8_t = __uint8_t; +pub const __int_least16_t = __int16_t; +pub const __uint_least16_t = __uint16_t; +pub const __int_least32_t = __int32_t; +pub const __uint_least32_t = __uint32_t; +pub const __int_least64_t = __int64_t; +pub const __uint_least64_t = __uint64_t; +pub const __quad_t = c_long; +pub const __u_quad_t = c_ulong; +pub const __intmax_t = c_long; +pub const __uintmax_t = c_ulong; +pub const __dev_t = c_ulong; +pub const __uid_t = c_uint; +pub const __gid_t = c_uint; +pub const __ino_t = c_ulong; +pub const __ino64_t = c_ulong; +pub const __mode_t = c_uint; +pub const __nlink_t = c_ulong; +pub const __off_t = c_long; +pub const __off64_t = c_long; +pub const __pid_t = c_int; +pub const __fsid_t = extern struct { + __val: [2]c_int = @import("std").mem.zeroes([2]c_int), +}; +pub const __clock_t = c_long; +pub const __rlim_t = c_ulong; +pub const __rlim64_t = c_ulong; +pub const __id_t = c_uint; +pub const __time_t = c_long; +pub const __useconds_t = c_uint; +pub const __suseconds_t = c_long; +pub const __suseconds64_t = c_long; +pub const __daddr_t = c_int; +pub const __key_t = c_int; +pub const __clockid_t = c_int; +pub const __timer_t = ?*anyopaque; +pub const __blksize_t = c_long; +pub const __blkcnt_t = c_long; +pub const __blkcnt64_t = c_long; +pub const __fsblkcnt_t = c_ulong; +pub const __fsblkcnt64_t = c_ulong; +pub const __fsfilcnt_t = c_ulong; +pub const __fsfilcnt64_t = c_ulong; +pub const __fsword_t = c_long; +pub const __ssize_t = c_long; +pub const __syscall_slong_t = c_long; +pub const __syscall_ulong_t = c_ulong; +pub const __loff_t = __off64_t; +pub const __caddr_t = [*c]u8; +pub const __intptr_t = c_long; +pub const __socklen_t = c_uint; +pub const __sig_atomic_t = c_int; +pub const _Float32 = f32; +pub const _Float64 = f64; +pub const _Float32x = f64; +pub const _Float64x = c_longdouble; +pub const float_t = f32; +pub const double_t = f64; +pub extern fn __fpclassify(__value: f64) c_int; +pub extern fn __signbit(__value: f64) c_int; +pub extern fn __isinf(__value: f64) c_int; +pub extern fn __finite(__value: f64) c_int; +pub extern fn __isnan(__value: f64) c_int; +pub extern fn __iseqsig(__x: f64, __y: f64) c_int; +pub extern fn __issignaling(__value: f64) c_int; +pub extern fn acos(__x: f64) f64; +pub extern fn __acos(__x: f64) f64; +pub extern fn asin(__x: f64) f64; +pub extern fn __asin(__x: f64) f64; +pub extern fn atan(__x: f64) f64; +pub extern fn __atan(__x: f64) f64; +pub extern fn atan2(__y: f64, __x: f64) f64; +pub extern fn __atan2(__y: f64, __x: f64) f64; +pub extern fn cos(__x: f64) f64; +pub extern fn __cos(__x: f64) f64; +pub extern fn sin(__x: f64) f64; +pub extern fn __sin(__x: f64) f64; +pub extern fn tan(__x: f64) f64; +pub extern fn __tan(__x: f64) f64; +pub extern fn cosh(__x: f64) f64; +pub extern fn __cosh(__x: f64) f64; +pub extern fn sinh(__x: f64) f64; +pub extern fn __sinh(__x: f64) f64; +pub extern fn tanh(__x: f64) f64; +pub extern fn __tanh(__x: f64) f64; +pub extern fn acosh(__x: f64) f64; +pub extern fn __acosh(__x: f64) f64; +pub extern fn asinh(__x: f64) f64; +pub extern fn __asinh(__x: f64) f64; +pub extern fn atanh(__x: f64) f64; +pub extern fn __atanh(__x: f64) f64; +pub extern fn exp(__x: f64) f64; +pub extern fn __exp(__x: f64) f64; +pub extern fn frexp(__x: f64, __exponent: [*c]c_int) f64; +pub extern fn __frexp(__x: f64, __exponent: [*c]c_int) f64; +pub extern fn ldexp(__x: f64, __exponent: c_int) f64; +pub extern fn __ldexp(__x: f64, __exponent: c_int) f64; +pub extern fn log(__x: f64) f64; +pub extern fn __log(__x: f64) f64; +pub extern fn log10(__x: f64) f64; +pub extern fn __log10(__x: f64) f64; +pub extern fn modf(__x: f64, __iptr: [*c]f64) f64; +pub extern fn __modf(__x: f64, __iptr: [*c]f64) f64; +pub extern fn expm1(__x: f64) f64; +pub extern fn __expm1(__x: f64) f64; +pub extern fn log1p(__x: f64) f64; +pub extern fn __log1p(__x: f64) f64; +pub extern fn logb(__x: f64) f64; +pub extern fn __logb(__x: f64) f64; +pub extern fn exp2(__x: f64) f64; +pub extern fn __exp2(__x: f64) f64; +pub extern fn log2(__x: f64) f64; +pub extern fn __log2(__x: f64) f64; +pub extern fn pow(__x: f64, __y: f64) f64; +pub extern fn __pow(__x: f64, __y: f64) f64; +pub extern fn sqrt(__x: f64) f64; +pub extern fn __sqrt(__x: f64) f64; +pub extern fn hypot(__x: f64, __y: f64) f64; +pub extern fn __hypot(__x: f64, __y: f64) f64; +pub extern fn cbrt(__x: f64) f64; +pub extern fn __cbrt(__x: f64) f64; +pub extern fn ceil(__x: f64) f64; +pub extern fn __ceil(__x: f64) f64; +pub extern fn fabs(__x: f64) f64; +pub extern fn __fabs(__x: f64) f64; +pub extern fn floor(__x: f64) f64; +pub extern fn __floor(__x: f64) f64; +pub extern fn fmod(__x: f64, __y: f64) f64; +pub extern fn __fmod(__x: f64, __y: f64) f64; +pub extern fn isinf(__value: f64) c_int; +pub extern fn finite(__value: f64) c_int; +pub extern fn drem(__x: f64, __y: f64) f64; +pub extern fn __drem(__x: f64, __y: f64) f64; +pub extern fn significand(__x: f64) f64; +pub extern fn __significand(__x: f64) f64; +pub extern fn copysign(__x: f64, __y: f64) f64; +pub extern fn __copysign(__x: f64, __y: f64) f64; +pub extern fn nan(__tagb: [*c]const u8) f64; +pub extern fn __nan(__tagb: [*c]const u8) f64; +pub extern fn isnan(__value: f64) c_int; +pub extern fn j0(f64) f64; +pub extern fn __j0(f64) f64; +pub extern fn j1(f64) f64; +pub extern fn __j1(f64) f64; +pub extern fn jn(c_int, f64) f64; +pub extern fn __jn(c_int, f64) f64; +pub extern fn y0(f64) f64; +pub extern fn __y0(f64) f64; +pub extern fn y1(f64) f64; +pub extern fn __y1(f64) f64; +pub extern fn yn(c_int, f64) f64; +pub extern fn __yn(c_int, f64) f64; +pub extern fn erf(f64) f64; +pub extern fn __erf(f64) f64; +pub extern fn erfc(f64) f64; +pub extern fn __erfc(f64) f64; +pub extern fn lgamma(f64) f64; +pub extern fn __lgamma(f64) f64; +pub extern fn tgamma(f64) f64; +pub extern fn __tgamma(f64) f64; +pub extern fn gamma(f64) f64; +pub extern fn __gamma(f64) f64; +pub extern fn lgamma_r(f64, __signgamp: [*c]c_int) f64; +pub extern fn __lgamma_r(f64, __signgamp: [*c]c_int) f64; +pub extern fn rint(__x: f64) f64; +pub extern fn __rint(__x: f64) f64; +pub extern fn nextafter(__x: f64, __y: f64) f64; +pub extern fn __nextafter(__x: f64, __y: f64) f64; +pub extern fn nexttoward(__x: f64, __y: c_longdouble) f64; +pub extern fn __nexttoward(__x: f64, __y: c_longdouble) f64; +pub extern fn remainder(__x: f64, __y: f64) f64; +pub extern fn __remainder(__x: f64, __y: f64) f64; +pub extern fn scalbn(__x: f64, __n: c_int) f64; +pub extern fn __scalbn(__x: f64, __n: c_int) f64; +pub extern fn ilogb(__x: f64) c_int; +pub extern fn __ilogb(__x: f64) c_int; +pub extern fn scalbln(__x: f64, __n: c_long) f64; +pub extern fn __scalbln(__x: f64, __n: c_long) f64; +pub extern fn nearbyint(__x: f64) f64; +pub extern fn __nearbyint(__x: f64) f64; +pub extern fn round(__x: f64) f64; +pub extern fn __round(__x: f64) f64; +pub extern fn trunc(__x: f64) f64; +pub extern fn __trunc(__x: f64) f64; +pub extern fn remquo(__x: f64, __y: f64, __quo: [*c]c_int) f64; +pub extern fn __remquo(__x: f64, __y: f64, __quo: [*c]c_int) f64; +pub extern fn lrint(__x: f64) c_long; +pub extern fn __lrint(__x: f64) c_long; +pub extern fn llrint(__x: f64) c_longlong; +pub extern fn __llrint(__x: f64) c_longlong; +pub extern fn lround(__x: f64) c_long; +pub extern fn __lround(__x: f64) c_long; +pub extern fn llround(__x: f64) c_longlong; +pub extern fn __llround(__x: f64) c_longlong; +pub extern fn fdim(__x: f64, __y: f64) f64; +pub extern fn __fdim(__x: f64, __y: f64) f64; +pub extern fn fmax(__x: f64, __y: f64) f64; +pub extern fn __fmax(__x: f64, __y: f64) f64; +pub extern fn fmin(__x: f64, __y: f64) f64; +pub extern fn __fmin(__x: f64, __y: f64) f64; +pub extern fn fma(__x: f64, __y: f64, __z: f64) f64; +pub extern fn __fma(__x: f64, __y: f64, __z: f64) f64; +pub extern fn scalb(__x: f64, __n: f64) f64; +pub extern fn __scalb(__x: f64, __n: f64) f64; +pub extern fn __fpclassifyf(__value: f32) c_int; +pub extern fn __signbitf(__value: f32) c_int; +pub extern fn __isinff(__value: f32) c_int; +pub extern fn __finitef(__value: f32) c_int; +pub extern fn __isnanf(__value: f32) c_int; +pub extern fn __iseqsigf(__x: f32, __y: f32) c_int; +pub extern fn __issignalingf(__value: f32) c_int; +pub extern fn acosf(__x: f32) f32; +pub extern fn __acosf(__x: f32) f32; +pub extern fn asinf(__x: f32) f32; +pub extern fn __asinf(__x: f32) f32; +pub extern fn atanf(__x: f32) f32; +pub extern fn __atanf(__x: f32) f32; +pub extern fn atan2f(__y: f32, __x: f32) f32; +pub extern fn __atan2f(__y: f32, __x: f32) f32; +pub extern fn cosf(__x: f32) f32; +pub extern fn __cosf(__x: f32) f32; +pub extern fn sinf(__x: f32) f32; +pub extern fn __sinf(__x: f32) f32; +pub extern fn tanf(__x: f32) f32; +pub extern fn __tanf(__x: f32) f32; +pub extern fn coshf(__x: f32) f32; +pub extern fn __coshf(__x: f32) f32; +pub extern fn sinhf(__x: f32) f32; +pub extern fn __sinhf(__x: f32) f32; +pub extern fn tanhf(__x: f32) f32; +pub extern fn __tanhf(__x: f32) f32; +pub extern fn acoshf(__x: f32) f32; +pub extern fn __acoshf(__x: f32) f32; +pub extern fn asinhf(__x: f32) f32; +pub extern fn __asinhf(__x: f32) f32; +pub extern fn atanhf(__x: f32) f32; +pub extern fn __atanhf(__x: f32) f32; +pub extern fn expf(__x: f32) f32; +pub extern fn __expf(__x: f32) f32; +pub extern fn frexpf(__x: f32, __exponent: [*c]c_int) f32; +pub extern fn __frexpf(__x: f32, __exponent: [*c]c_int) f32; +pub extern fn ldexpf(__x: f32, __exponent: c_int) f32; +pub extern fn __ldexpf(__x: f32, __exponent: c_int) f32; +pub extern fn logf(__x: f32) f32; +pub extern fn __logf(__x: f32) f32; +pub extern fn log10f(__x: f32) f32; +pub extern fn __log10f(__x: f32) f32; +pub extern fn modff(__x: f32, __iptr: [*c]f32) f32; +pub extern fn __modff(__x: f32, __iptr: [*c]f32) f32; +pub extern fn expm1f(__x: f32) f32; +pub extern fn __expm1f(__x: f32) f32; +pub extern fn log1pf(__x: f32) f32; +pub extern fn __log1pf(__x: f32) f32; +pub extern fn logbf(__x: f32) f32; +pub extern fn __logbf(__x: f32) f32; +pub extern fn exp2f(__x: f32) f32; +pub extern fn __exp2f(__x: f32) f32; +pub extern fn log2f(__x: f32) f32; +pub extern fn __log2f(__x: f32) f32; +pub extern fn powf(__x: f32, __y: f32) f32; +pub extern fn __powf(__x: f32, __y: f32) f32; +pub extern fn sqrtf(__x: f32) f32; +pub extern fn __sqrtf(__x: f32) f32; +pub extern fn hypotf(__x: f32, __y: f32) f32; +pub extern fn __hypotf(__x: f32, __y: f32) f32; +pub extern fn cbrtf(__x: f32) f32; +pub extern fn __cbrtf(__x: f32) f32; +pub extern fn ceilf(__x: f32) f32; +pub extern fn __ceilf(__x: f32) f32; +pub extern fn fabsf(__x: f32) f32; +pub extern fn __fabsf(__x: f32) f32; +pub extern fn floorf(__x: f32) f32; +pub extern fn __floorf(__x: f32) f32; +pub extern fn fmodf(__x: f32, __y: f32) f32; +pub extern fn __fmodf(__x: f32, __y: f32) f32; +pub extern fn isinff(__value: f32) c_int; +pub extern fn finitef(__value: f32) c_int; +pub extern fn dremf(__x: f32, __y: f32) f32; +pub extern fn __dremf(__x: f32, __y: f32) f32; +pub extern fn significandf(__x: f32) f32; +pub extern fn __significandf(__x: f32) f32; +pub extern fn copysignf(__x: f32, __y: f32) f32; +pub extern fn __copysignf(__x: f32, __y: f32) f32; +pub extern fn nanf(__tagb: [*c]const u8) f32; +pub extern fn __nanf(__tagb: [*c]const u8) f32; +pub extern fn isnanf(__value: f32) c_int; +pub extern fn j0f(f32) f32; +pub extern fn __j0f(f32) f32; +pub extern fn j1f(f32) f32; +pub extern fn __j1f(f32) f32; +pub extern fn jnf(c_int, f32) f32; +pub extern fn __jnf(c_int, f32) f32; +pub extern fn y0f(f32) f32; +pub extern fn __y0f(f32) f32; +pub extern fn y1f(f32) f32; +pub extern fn __y1f(f32) f32; +pub extern fn ynf(c_int, f32) f32; +pub extern fn __ynf(c_int, f32) f32; +pub extern fn erff(f32) f32; +pub extern fn __erff(f32) f32; +pub extern fn erfcf(f32) f32; +pub extern fn __erfcf(f32) f32; +pub extern fn lgammaf(f32) f32; +pub extern fn __lgammaf(f32) f32; +pub extern fn tgammaf(f32) f32; +pub extern fn __tgammaf(f32) f32; +pub extern fn gammaf(f32) f32; +pub extern fn __gammaf(f32) f32; +pub extern fn lgammaf_r(f32, __signgamp: [*c]c_int) f32; +pub extern fn __lgammaf_r(f32, __signgamp: [*c]c_int) f32; +pub extern fn rintf(__x: f32) f32; +pub extern fn __rintf(__x: f32) f32; +pub extern fn nextafterf(__x: f32, __y: f32) f32; +pub extern fn __nextafterf(__x: f32, __y: f32) f32; +pub extern fn nexttowardf(__x: f32, __y: c_longdouble) f32; +pub extern fn __nexttowardf(__x: f32, __y: c_longdouble) f32; +pub extern fn remainderf(__x: f32, __y: f32) f32; +pub extern fn __remainderf(__x: f32, __y: f32) f32; +pub extern fn scalbnf(__x: f32, __n: c_int) f32; +pub extern fn __scalbnf(__x: f32, __n: c_int) f32; +pub extern fn ilogbf(__x: f32) c_int; +pub extern fn __ilogbf(__x: f32) c_int; +pub extern fn scalblnf(__x: f32, __n: c_long) f32; +pub extern fn __scalblnf(__x: f32, __n: c_long) f32; +pub extern fn nearbyintf(__x: f32) f32; +pub extern fn __nearbyintf(__x: f32) f32; +pub extern fn roundf(__x: f32) f32; +pub extern fn __roundf(__x: f32) f32; +pub extern fn truncf(__x: f32) f32; +pub extern fn __truncf(__x: f32) f32; +pub extern fn remquof(__x: f32, __y: f32, __quo: [*c]c_int) f32; +pub extern fn __remquof(__x: f32, __y: f32, __quo: [*c]c_int) f32; +pub extern fn lrintf(__x: f32) c_long; +pub extern fn __lrintf(__x: f32) c_long; +pub extern fn llrintf(__x: f32) c_longlong; +pub extern fn __llrintf(__x: f32) c_longlong; +pub extern fn lroundf(__x: f32) c_long; +pub extern fn __lroundf(__x: f32) c_long; +pub extern fn llroundf(__x: f32) c_longlong; +pub extern fn __llroundf(__x: f32) c_longlong; +pub extern fn fdimf(__x: f32, __y: f32) f32; +pub extern fn __fdimf(__x: f32, __y: f32) f32; +pub extern fn fmaxf(__x: f32, __y: f32) f32; +pub extern fn __fmaxf(__x: f32, __y: f32) f32; +pub extern fn fminf(__x: f32, __y: f32) f32; +pub extern fn __fminf(__x: f32, __y: f32) f32; +pub extern fn fmaf(__x: f32, __y: f32, __z: f32) f32; +pub extern fn __fmaf(__x: f32, __y: f32, __z: f32) f32; +pub extern fn scalbf(__x: f32, __n: f32) f32; +pub extern fn __scalbf(__x: f32, __n: f32) f32; +pub extern fn __fpclassifyl(__value: c_longdouble) c_int; +pub extern fn __signbitl(__value: c_longdouble) c_int; +pub extern fn __isinfl(__value: c_longdouble) c_int; +pub extern fn __finitel(__value: c_longdouble) c_int; +pub extern fn __isnanl(__value: c_longdouble) c_int; +pub extern fn __iseqsigl(__x: c_longdouble, __y: c_longdouble) c_int; +pub extern fn __issignalingl(__value: c_longdouble) c_int; +pub extern fn acosl(__x: c_longdouble) c_longdouble; +pub extern fn __acosl(__x: c_longdouble) c_longdouble; +pub extern fn asinl(__x: c_longdouble) c_longdouble; +pub extern fn __asinl(__x: c_longdouble) c_longdouble; +pub extern fn atanl(__x: c_longdouble) c_longdouble; +pub extern fn __atanl(__x: c_longdouble) c_longdouble; +pub extern fn atan2l(__y: c_longdouble, __x: c_longdouble) c_longdouble; +pub extern fn __atan2l(__y: c_longdouble, __x: c_longdouble) c_longdouble; +pub extern fn cosl(__x: c_longdouble) c_longdouble; +pub extern fn __cosl(__x: c_longdouble) c_longdouble; +pub extern fn sinl(__x: c_longdouble) c_longdouble; +pub extern fn __sinl(__x: c_longdouble) c_longdouble; +pub extern fn tanl(__x: c_longdouble) c_longdouble; +pub extern fn __tanl(__x: c_longdouble) c_longdouble; +pub extern fn coshl(__x: c_longdouble) c_longdouble; +pub extern fn __coshl(__x: c_longdouble) c_longdouble; +pub extern fn sinhl(__x: c_longdouble) c_longdouble; +pub extern fn __sinhl(__x: c_longdouble) c_longdouble; +pub extern fn tanhl(__x: c_longdouble) c_longdouble; +pub extern fn __tanhl(__x: c_longdouble) c_longdouble; +pub extern fn acoshl(__x: c_longdouble) c_longdouble; +pub extern fn __acoshl(__x: c_longdouble) c_longdouble; +pub extern fn asinhl(__x: c_longdouble) c_longdouble; +pub extern fn __asinhl(__x: c_longdouble) c_longdouble; +pub extern fn atanhl(__x: c_longdouble) c_longdouble; +pub extern fn __atanhl(__x: c_longdouble) c_longdouble; +pub extern fn expl(__x: c_longdouble) c_longdouble; +pub extern fn __expl(__x: c_longdouble) c_longdouble; +pub extern fn frexpl(__x: c_longdouble, __exponent: [*c]c_int) c_longdouble; +pub extern fn __frexpl(__x: c_longdouble, __exponent: [*c]c_int) c_longdouble; +pub extern fn ldexpl(__x: c_longdouble, __exponent: c_int) c_longdouble; +pub extern fn __ldexpl(__x: c_longdouble, __exponent: c_int) c_longdouble; +pub extern fn logl(__x: c_longdouble) c_longdouble; +pub extern fn __logl(__x: c_longdouble) c_longdouble; +pub extern fn log10l(__x: c_longdouble) c_longdouble; +pub extern fn __log10l(__x: c_longdouble) c_longdouble; +pub extern fn modfl(__x: c_longdouble, __iptr: [*c]c_longdouble) c_longdouble; +pub extern fn __modfl(__x: c_longdouble, __iptr: [*c]c_longdouble) c_longdouble; +pub extern fn expm1l(__x: c_longdouble) c_longdouble; +pub extern fn __expm1l(__x: c_longdouble) c_longdouble; +pub extern fn log1pl(__x: c_longdouble) c_longdouble; +pub extern fn __log1pl(__x: c_longdouble) c_longdouble; +pub extern fn logbl(__x: c_longdouble) c_longdouble; +pub extern fn __logbl(__x: c_longdouble) c_longdouble; +pub extern fn exp2l(__x: c_longdouble) c_longdouble; +pub extern fn __exp2l(__x: c_longdouble) c_longdouble; +pub extern fn log2l(__x: c_longdouble) c_longdouble; +pub extern fn __log2l(__x: c_longdouble) c_longdouble; +pub extern fn powl(__x: c_longdouble, __y: c_longdouble) c_longdouble; +pub extern fn __powl(__x: c_longdouble, __y: c_longdouble) c_longdouble; +pub extern fn sqrtl(__x: c_longdouble) c_longdouble; +pub extern fn __sqrtl(__x: c_longdouble) c_longdouble; +pub extern fn hypotl(__x: c_longdouble, __y: c_longdouble) c_longdouble; +pub extern fn __hypotl(__x: c_longdouble, __y: c_longdouble) c_longdouble; +pub extern fn cbrtl(__x: c_longdouble) c_longdouble; +pub extern fn __cbrtl(__x: c_longdouble) c_longdouble; +pub extern fn ceill(__x: c_longdouble) c_longdouble; +pub extern fn __ceill(__x: c_longdouble) c_longdouble; +pub extern fn fabsl(__x: c_longdouble) c_longdouble; +pub extern fn __fabsl(__x: c_longdouble) c_longdouble; +pub extern fn floorl(__x: c_longdouble) c_longdouble; +pub extern fn __floorl(__x: c_longdouble) c_longdouble; +pub extern fn fmodl(__x: c_longdouble, __y: c_longdouble) c_longdouble; +pub extern fn __fmodl(__x: c_longdouble, __y: c_longdouble) c_longdouble; +pub extern fn isinfl(__value: c_longdouble) c_int; +pub extern fn finitel(__value: c_longdouble) c_int; +pub extern fn dreml(__x: c_longdouble, __y: c_longdouble) c_longdouble; +pub extern fn __dreml(__x: c_longdouble, __y: c_longdouble) c_longdouble; +pub extern fn significandl(__x: c_longdouble) c_longdouble; +pub extern fn __significandl(__x: c_longdouble) c_longdouble; +pub extern fn copysignl(__x: c_longdouble, __y: c_longdouble) c_longdouble; +pub extern fn __copysignl(__x: c_longdouble, __y: c_longdouble) c_longdouble; +pub extern fn nanl(__tagb: [*c]const u8) c_longdouble; +pub extern fn __nanl(__tagb: [*c]const u8) c_longdouble; +pub extern fn isnanl(__value: c_longdouble) c_int; +pub extern fn j0l(c_longdouble) c_longdouble; +pub extern fn __j0l(c_longdouble) c_longdouble; +pub extern fn j1l(c_longdouble) c_longdouble; +pub extern fn __j1l(c_longdouble) c_longdouble; +pub extern fn jnl(c_int, c_longdouble) c_longdouble; +pub extern fn __jnl(c_int, c_longdouble) c_longdouble; +pub extern fn y0l(c_longdouble) c_longdouble; +pub extern fn __y0l(c_longdouble) c_longdouble; +pub extern fn y1l(c_longdouble) c_longdouble; +pub extern fn __y1l(c_longdouble) c_longdouble; +pub extern fn ynl(c_int, c_longdouble) c_longdouble; +pub extern fn __ynl(c_int, c_longdouble) c_longdouble; +pub extern fn erfl(c_longdouble) c_longdouble; +pub extern fn __erfl(c_longdouble) c_longdouble; +pub extern fn erfcl(c_longdouble) c_longdouble; +pub extern fn __erfcl(c_longdouble) c_longdouble; +pub extern fn lgammal(c_longdouble) c_longdouble; +pub extern fn __lgammal(c_longdouble) c_longdouble; +pub extern fn tgammal(c_longdouble) c_longdouble; +pub extern fn __tgammal(c_longdouble) c_longdouble; +pub extern fn gammal(c_longdouble) c_longdouble; +pub extern fn __gammal(c_longdouble) c_longdouble; +pub extern fn lgammal_r(c_longdouble, __signgamp: [*c]c_int) c_longdouble; +pub extern fn __lgammal_r(c_longdouble, __signgamp: [*c]c_int) c_longdouble; +pub extern fn rintl(__x: c_longdouble) c_longdouble; +pub extern fn __rintl(__x: c_longdouble) c_longdouble; +pub extern fn nextafterl(__x: c_longdouble, __y: c_longdouble) c_longdouble; +pub extern fn __nextafterl(__x: c_longdouble, __y: c_longdouble) c_longdouble; +pub extern fn nexttowardl(__x: c_longdouble, __y: c_longdouble) c_longdouble; +pub extern fn __nexttowardl(__x: c_longdouble, __y: c_longdouble) c_longdouble; +pub extern fn remainderl(__x: c_longdouble, __y: c_longdouble) c_longdouble; +pub extern fn __remainderl(__x: c_longdouble, __y: c_longdouble) c_longdouble; +pub extern fn scalbnl(__x: c_longdouble, __n: c_int) c_longdouble; +pub extern fn __scalbnl(__x: c_longdouble, __n: c_int) c_longdouble; +pub extern fn ilogbl(__x: c_longdouble) c_int; +pub extern fn __ilogbl(__x: c_longdouble) c_int; +pub extern fn scalblnl(__x: c_longdouble, __n: c_long) c_longdouble; +pub extern fn __scalblnl(__x: c_longdouble, __n: c_long) c_longdouble; +pub extern fn nearbyintl(__x: c_longdouble) c_longdouble; +pub extern fn __nearbyintl(__x: c_longdouble) c_longdouble; +pub extern fn roundl(__x: c_longdouble) c_longdouble; +pub extern fn __roundl(__x: c_longdouble) c_longdouble; +pub extern fn truncl(__x: c_longdouble) c_longdouble; +pub extern fn __truncl(__x: c_longdouble) c_longdouble; +pub extern fn remquol(__x: c_longdouble, __y: c_longdouble, __quo: [*c]c_int) c_longdouble; +pub extern fn __remquol(__x: c_longdouble, __y: c_longdouble, __quo: [*c]c_int) c_longdouble; +pub extern fn lrintl(__x: c_longdouble) c_long; +pub extern fn __lrintl(__x: c_longdouble) c_long; +pub extern fn llrintl(__x: c_longdouble) c_longlong; +pub extern fn __llrintl(__x: c_longdouble) c_longlong; +pub extern fn lroundl(__x: c_longdouble) c_long; +pub extern fn __lroundl(__x: c_longdouble) c_long; +pub extern fn llroundl(__x: c_longdouble) c_longlong; +pub extern fn __llroundl(__x: c_longdouble) c_longlong; +pub extern fn fdiml(__x: c_longdouble, __y: c_longdouble) c_longdouble; +pub extern fn __fdiml(__x: c_longdouble, __y: c_longdouble) c_longdouble; +pub extern fn fmaxl(__x: c_longdouble, __y: c_longdouble) c_longdouble; +pub extern fn __fmaxl(__x: c_longdouble, __y: c_longdouble) c_longdouble; +pub extern fn fminl(__x: c_longdouble, __y: c_longdouble) c_longdouble; +pub extern fn __fminl(__x: c_longdouble, __y: c_longdouble) c_longdouble; +pub extern fn fmal(__x: c_longdouble, __y: c_longdouble, __z: c_longdouble) c_longdouble; +pub extern fn __fmal(__x: c_longdouble, __y: c_longdouble, __z: c_longdouble) c_longdouble; +pub extern fn scalbl(__x: c_longdouble, __n: c_longdouble) c_longdouble; +pub extern fn __scalbl(__x: c_longdouble, __n: c_longdouble) c_longdouble; +pub extern var signgam: c_int; +pub const FP_NAN: c_int = 0; +pub const FP_INFINITE: c_int = 1; +pub const FP_ZERO: c_int = 2; +pub const FP_SUBNORMAL: c_int = 3; +pub const FP_NORMAL: c_int = 4; +const enum_unnamed_2 = c_uint; +pub fn Clamp(arg_value: f32, arg_min: f32, arg_max: f32) callconv(.C) f32 { + var value = arg_value; + _ = &value; + var min = arg_min; + _ = &min; + var max = arg_max; + _ = &max; + var result: f32 = if (value < min) min else value; + _ = &result; + if (result > max) { + result = max; + } + return result; +} +pub fn Lerp(arg_start: f32, arg_end: f32, arg_amount: f32) callconv(.C) f32 { + var start = arg_start; + _ = &start; + var end = arg_end; + _ = &end; + var amount = arg_amount; + _ = &amount; + var result: f32 = start + (amount * (end - start)); + _ = &result; + return result; +} +pub fn Normalize(arg_value: f32, arg_start: f32, arg_end: f32) callconv(.C) f32 { + var value = arg_value; + _ = &value; + var start = arg_start; + _ = &start; + var end = arg_end; + _ = &end; + var result: f32 = (value - start) / (end - start); + _ = &result; + return result; +} +pub fn Remap(arg_value: f32, arg_inputStart: f32, arg_inputEnd: f32, arg_outputStart: f32, arg_outputEnd: f32) callconv(.C) f32 { + var value = arg_value; + _ = &value; + var inputStart = arg_inputStart; + _ = &inputStart; + var inputEnd = arg_inputEnd; + _ = &inputEnd; + var outputStart = arg_outputStart; + _ = &outputStart; + var outputEnd = arg_outputEnd; + _ = &outputEnd; + var result: f32 = (((value - inputStart) / (inputEnd - inputStart)) * (outputEnd - outputStart)) + outputStart; + _ = &result; + return result; +} +pub fn Wrap(arg_value: f32, arg_min: f32, arg_max: f32) callconv(.C) f32 { + var value = arg_value; + _ = &value; + var min = arg_min; + _ = &min; + var max = arg_max; + _ = &max; + var result: f32 = value - ((max - min) * floorf((value - min) / (max - min))); + _ = &result; + return result; +} +pub fn FloatEquals(arg_x: f32, arg_y: f32) callconv(.C) c_int { + var x = arg_x; + _ = &x; + var y = arg_y; + _ = &y; + var result: c_int = @intFromBool(fabsf(x - y) <= (0.0000009999999974752427 * fmaxf(1.0, fmaxf(fabsf(x), fabsf(y))))); + _ = &result; + return result; +} +pub fn Vector2Zero() callconv(.C) Vector2 { + var result: Vector2 = Vector2{ + .x = 0.0, + .y = 0.0, + }; + _ = &result; + return result; +} +pub fn Vector2One() callconv(.C) Vector2 { + var result: Vector2 = Vector2{ + .x = 1.0, + .y = 1.0, + }; + _ = &result; + return result; +} +pub fn Vector2Add(arg_v1: Vector2, arg_v2: Vector2) callconv(.C) Vector2 { + var v1 = arg_v1; + _ = &v1; + var v2 = arg_v2; + _ = &v2; + var result: Vector2 = Vector2{ + .x = v1.x + v2.x, + .y = v1.y + v2.y, + }; + _ = &result; + return result; +} +pub fn Vector2AddValue(arg_v: Vector2, arg_add: f32) callconv(.C) Vector2 { + var v = arg_v; + _ = &v; + var add = arg_add; + _ = &add; + var result: Vector2 = Vector2{ + .x = v.x + add, + .y = v.y + add, + }; + _ = &result; + return result; +} +pub fn Vector2Subtract(arg_v1: Vector2, arg_v2: Vector2) callconv(.C) Vector2 { + var v1 = arg_v1; + _ = &v1; + var v2 = arg_v2; + _ = &v2; + var result: Vector2 = Vector2{ + .x = v1.x - v2.x, + .y = v1.y - v2.y, + }; + _ = &result; + return result; +} +pub fn Vector2SubtractValue(arg_v: Vector2, arg_sub: f32) callconv(.C) Vector2 { + var v = arg_v; + _ = &v; + var sub = arg_sub; + _ = ⊂ + var result: Vector2 = Vector2{ + .x = v.x - sub, + .y = v.y - sub, + }; + _ = &result; + return result; +} +pub fn Vector2Length(arg_v: Vector2) callconv(.C) f32 { + var v = arg_v; + _ = &v; + var result: f32 = sqrtf((v.x * v.x) + (v.y * v.y)); + _ = &result; + return result; +} +pub fn Vector2LengthSqr(arg_v: Vector2) callconv(.C) f32 { + var v = arg_v; + _ = &v; + var result: f32 = (v.x * v.x) + (v.y * v.y); + _ = &result; + return result; +} +pub fn Vector2DotProduct(arg_v1: Vector2, arg_v2: Vector2) callconv(.C) f32 { + var v1 = arg_v1; + _ = &v1; + var v2 = arg_v2; + _ = &v2; + var result: f32 = (v1.x * v2.x) + (v1.y * v2.y); + _ = &result; + return result; +} +pub fn Vector2Distance(arg_v1: Vector2, arg_v2: Vector2) callconv(.C) f32 { + var v1 = arg_v1; + _ = &v1; + var v2 = arg_v2; + _ = &v2; + var result: f32 = sqrtf(((v1.x - v2.x) * (v1.x - v2.x)) + ((v1.y - v2.y) * (v1.y - v2.y))); + _ = &result; + return result; +} +pub fn Vector2DistanceSqr(arg_v1: Vector2, arg_v2: Vector2) callconv(.C) f32 { + var v1 = arg_v1; + _ = &v1; + var v2 = arg_v2; + _ = &v2; + var result: f32 = ((v1.x - v2.x) * (v1.x - v2.x)) + ((v1.y - v2.y) * (v1.y - v2.y)); + _ = &result; + return result; +} +pub fn Vector2Angle(arg_v1: Vector2, arg_v2: Vector2) callconv(.C) f32 { + var v1 = arg_v1; + _ = &v1; + var v2 = arg_v2; + _ = &v2; + var result: f32 = 0.0; + _ = &result; + var dot: f32 = (v1.x * v2.x) + (v1.y * v2.y); + _ = ˙ + var det: f32 = (v1.x * v2.y) - (v1.y * v2.x); + _ = &det; + result = atan2f(det, dot); + return result; +} +pub fn Vector2LineAngle(arg_start: Vector2, arg_end: Vector2) callconv(.C) f32 { + var start = arg_start; + _ = &start; + var end = arg_end; + _ = &end; + var result: f32 = 0.0; + _ = &result; + result = -atan2f(end.y - start.y, end.x - start.x); + return result; +} +pub fn Vector2Scale(arg_v: Vector2, arg_scale: f32) callconv(.C) Vector2 { + var v = arg_v; + _ = &v; + var scale = arg_scale; + _ = &scale; + var result: Vector2 = Vector2{ + .x = v.x * scale, + .y = v.y * scale, + }; + _ = &result; + return result; +} +pub fn Vector2Multiply(arg_v1: Vector2, arg_v2: Vector2) callconv(.C) Vector2 { + var v1 = arg_v1; + _ = &v1; + var v2 = arg_v2; + _ = &v2; + var result: Vector2 = Vector2{ + .x = v1.x * v2.x, + .y = v1.y * v2.y, + }; + _ = &result; + return result; +} +pub fn Vector2Negate(arg_v: Vector2) callconv(.C) Vector2 { + var v = arg_v; + _ = &v; + var result: Vector2 = Vector2{ + .x = -v.x, + .y = -v.y, + }; + _ = &result; + return result; +} +pub fn Vector2Divide(arg_v1: Vector2, arg_v2: Vector2) callconv(.C) Vector2 { + var v1 = arg_v1; + _ = &v1; + var v2 = arg_v2; + _ = &v2; + var result: Vector2 = Vector2{ + .x = v1.x / v2.x, + .y = v1.y / v2.y, + }; + _ = &result; + return result; +} +pub fn Vector2Normalize(arg_v: Vector2) callconv(.C) Vector2 { + var v = arg_v; + _ = &v; + var result: Vector2 = Vector2{ + .x = @as(f32, @floatFromInt(@as(c_int, 0))), + .y = 0, + }; + _ = &result; + var length: f32 = sqrtf((v.x * v.x) + (v.y * v.y)); + _ = &length; + if (length > @as(f32, @floatFromInt(@as(c_int, 0)))) { + var ilength: f32 = 1.0 / length; + _ = &ilength; + result.x = v.x * ilength; + result.y = v.y * ilength; + } + return result; +} +pub fn Vector2Transform(arg_v: Vector2, arg_mat: Matrix) callconv(.C) Vector2 { + var v = arg_v; + _ = &v; + var mat = arg_mat; + _ = &mat; + var result: Vector2 = Vector2{ + .x = @as(f32, @floatFromInt(@as(c_int, 0))), + .y = 0, + }; + _ = &result; + var x: f32 = v.x; + _ = &x; + var y: f32 = v.y; + _ = &y; + var z: f32 = 0; + _ = &z; + result.x = (((mat.m0 * x) + (mat.m4 * y)) + (mat.m8 * z)) + mat.m12; + result.y = (((mat.m1 * x) + (mat.m5 * y)) + (mat.m9 * z)) + mat.m13; + return result; +} +pub fn Vector2Lerp(arg_v1: Vector2, arg_v2: Vector2, arg_amount: f32) callconv(.C) Vector2 { + var v1 = arg_v1; + _ = &v1; + var v2 = arg_v2; + _ = &v2; + var amount = arg_amount; + _ = &amount; + var result: Vector2 = Vector2{ + .x = @as(f32, @floatFromInt(@as(c_int, 0))), + .y = 0, + }; + _ = &result; + result.x = v1.x + (amount * (v2.x - v1.x)); + result.y = v1.y + (amount * (v2.y - v1.y)); + return result; +} +pub fn Vector2Reflect(arg_v: Vector2, arg_normal: Vector2) callconv(.C) Vector2 { + var v = arg_v; + _ = &v; + var normal = arg_normal; + _ = &normal; + var result: Vector2 = Vector2{ + .x = @as(f32, @floatFromInt(@as(c_int, 0))), + .y = 0, + }; + _ = &result; + var dotProduct: f32 = (v.x * normal.x) + (v.y * normal.y); + _ = &dotProduct; + result.x = v.x - ((2.0 * normal.x) * dotProduct); + result.y = v.y - ((2.0 * normal.y) * dotProduct); + return result; +} +pub fn Vector2Min(arg_v1: Vector2, arg_v2: Vector2) callconv(.C) Vector2 { + var v1 = arg_v1; + _ = &v1; + var v2 = arg_v2; + _ = &v2; + var result: Vector2 = Vector2{ + .x = @as(f32, @floatFromInt(@as(c_int, 0))), + .y = 0, + }; + _ = &result; + result.x = fminf(v1.x, v2.x); + result.y = fminf(v1.y, v2.y); + return result; +} +pub fn Vector2Max(arg_v1: Vector2, arg_v2: Vector2) callconv(.C) Vector2 { + var v1 = arg_v1; + _ = &v1; + var v2 = arg_v2; + _ = &v2; + var result: Vector2 = Vector2{ + .x = @as(f32, @floatFromInt(@as(c_int, 0))), + .y = 0, + }; + _ = &result; + result.x = fmaxf(v1.x, v2.x); + result.y = fmaxf(v1.y, v2.y); + return result; +} +pub fn Vector2Rotate(arg_v: Vector2, arg_angle: f32) callconv(.C) Vector2 { + var v = arg_v; + _ = &v; + var angle = arg_angle; + _ = ∠ + var result: Vector2 = Vector2{ + .x = @as(f32, @floatFromInt(@as(c_int, 0))), + .y = 0, + }; + _ = &result; + var cosres: f32 = cosf(angle); + _ = &cosres; + var sinres: f32 = sinf(angle); + _ = &sinres; + result.x = (v.x * cosres) - (v.y * sinres); + result.y = (v.x * sinres) + (v.y * cosres); + return result; +} +pub fn Vector2MoveTowards(arg_v: Vector2, arg_target: Vector2, arg_maxDistance: f32) callconv(.C) Vector2 { + var v = arg_v; + _ = &v; + var target = arg_target; + _ = ⌖ + var maxDistance = arg_maxDistance; + _ = &maxDistance; + var result: Vector2 = Vector2{ + .x = @as(f32, @floatFromInt(@as(c_int, 0))), + .y = 0, + }; + _ = &result; + var dx: f32 = target.x - v.x; + _ = &dx; + var dy: f32 = target.y - v.y; + _ = &dy; + var value: f32 = (dx * dx) + (dy * dy); + _ = &value; + if ((value == @as(f32, @floatFromInt(@as(c_int, 0)))) or ((maxDistance >= @as(f32, @floatFromInt(@as(c_int, 0)))) and (value <= (maxDistance * maxDistance)))) return target; + var dist: f32 = sqrtf(value); + _ = &dist; + result.x = v.x + ((dx / dist) * maxDistance); + result.y = v.y + ((dy / dist) * maxDistance); + return result; +} +pub fn Vector2Invert(arg_v: Vector2) callconv(.C) Vector2 { + var v = arg_v; + _ = &v; + var result: Vector2 = Vector2{ + .x = 1.0 / v.x, + .y = 1.0 / v.y, + }; + _ = &result; + return result; +} +pub fn Vector2Clamp(arg_v: Vector2, arg_min: Vector2, arg_max: Vector2) callconv(.C) Vector2 { + var v = arg_v; + _ = &v; + var min = arg_min; + _ = &min; + var max = arg_max; + _ = &max; + var result: Vector2 = Vector2{ + .x = @as(f32, @floatFromInt(@as(c_int, 0))), + .y = 0, + }; + _ = &result; + result.x = fminf(max.x, fmaxf(min.x, v.x)); + result.y = fminf(max.y, fmaxf(min.y, v.y)); + return result; +} +pub fn Vector2ClampValue(arg_v: Vector2, arg_min: f32, arg_max: f32) callconv(.C) Vector2 { + var v = arg_v; + _ = &v; + var min = arg_min; + _ = &min; + var max = arg_max; + _ = &max; + var result: Vector2 = v; + _ = &result; + var length: f32 = (v.x * v.x) + (v.y * v.y); + _ = &length; + if (length > 0.0) { + length = sqrtf(length); + var scale: f32 = 1; + _ = &scale; + if (length < min) { + scale = min / length; + } else if (length > max) { + scale = max / length; + } + result.x = v.x * scale; + result.y = v.y * scale; + } + return result; +} +pub fn Vector2Equals(arg_p: Vector2, arg_q: Vector2) callconv(.C) c_int { + var p = arg_p; + _ = &p; + var q = arg_q; + _ = &q; + var result: c_int = @intFromBool((fabsf(p.x - q.x) <= (0.0000009999999974752427 * fmaxf(1.0, fmaxf(fabsf(p.x), fabsf(q.x))))) and (fabsf(p.y - q.y) <= (0.0000009999999974752427 * fmaxf(1.0, fmaxf(fabsf(p.y), fabsf(q.y)))))); + _ = &result; + return result; +} +pub fn Vector2Refract(arg_v: Vector2, arg_n: Vector2, arg_r: f32) callconv(.C) Vector2 { + var v = arg_v; + _ = &v; + var n = arg_n; + _ = &n; + var r = arg_r; + _ = &r; + var result: Vector2 = Vector2{ + .x = @as(f32, @floatFromInt(@as(c_int, 0))), + .y = 0, + }; + _ = &result; + var dot: f32 = (v.x * n.x) + (v.y * n.y); + _ = ˙ + var d: f32 = 1.0 - ((r * r) * (1.0 - (dot * dot))); + _ = &d; + if (d >= 0.0) { + d = sqrtf(d); + v.x = (r * v.x) - (((r * dot) + d) * n.x); + v.y = (r * v.y) - (((r * dot) + d) * n.y); + result = v; + } + return result; +} +pub fn Vector3Zero() callconv(.C) Vector3 { + var result: Vector3 = Vector3{ + .x = 0.0, + .y = 0.0, + .z = 0.0, + }; + _ = &result; + return result; +} +pub fn Vector3One() callconv(.C) Vector3 { + var result: Vector3 = Vector3{ + .x = 1.0, + .y = 1.0, + .z = 1.0, + }; + _ = &result; + return result; +} +pub fn Vector3Add(arg_v1: Vector3, arg_v2: Vector3) callconv(.C) Vector3 { + var v1 = arg_v1; + _ = &v1; + var v2 = arg_v2; + _ = &v2; + var result: Vector3 = Vector3{ + .x = v1.x + v2.x, + .y = v1.y + v2.y, + .z = v1.z + v2.z, + }; + _ = &result; + return result; +} +pub fn Vector3AddValue(arg_v: Vector3, arg_add: f32) callconv(.C) Vector3 { + var v = arg_v; + _ = &v; + var add = arg_add; + _ = &add; + var result: Vector3 = Vector3{ + .x = v.x + add, + .y = v.y + add, + .z = v.z + add, + }; + _ = &result; + return result; +} +pub fn Vector3Subtract(arg_v1: Vector3, arg_v2: Vector3) callconv(.C) Vector3 { + var v1 = arg_v1; + _ = &v1; + var v2 = arg_v2; + _ = &v2; + var result: Vector3 = Vector3{ + .x = v1.x - v2.x, + .y = v1.y - v2.y, + .z = v1.z - v2.z, + }; + _ = &result; + return result; +} +pub fn Vector3SubtractValue(arg_v: Vector3, arg_sub: f32) callconv(.C) Vector3 { + var v = arg_v; + _ = &v; + var sub = arg_sub; + _ = ⊂ + var result: Vector3 = Vector3{ + .x = v.x - sub, + .y = v.y - sub, + .z = v.z - sub, + }; + _ = &result; + return result; +} +pub fn Vector3Scale(arg_v: Vector3, arg_scalar: f32) callconv(.C) Vector3 { + var v = arg_v; + _ = &v; + var scalar = arg_scalar; + _ = &scalar; + var result: Vector3 = Vector3{ + .x = v.x * scalar, + .y = v.y * scalar, + .z = v.z * scalar, + }; + _ = &result; + return result; +} +pub fn Vector3Multiply(arg_v1: Vector3, arg_v2: Vector3) callconv(.C) Vector3 { + var v1 = arg_v1; + _ = &v1; + var v2 = arg_v2; + _ = &v2; + var result: Vector3 = Vector3{ + .x = v1.x * v2.x, + .y = v1.y * v2.y, + .z = v1.z * v2.z, + }; + _ = &result; + return result; +} +pub fn Vector3CrossProduct(arg_v1: Vector3, arg_v2: Vector3) callconv(.C) Vector3 { + var v1 = arg_v1; + _ = &v1; + var v2 = arg_v2; + _ = &v2; + var result: Vector3 = Vector3{ + .x = (v1.y * v2.z) - (v1.z * v2.y), + .y = (v1.z * v2.x) - (v1.x * v2.z), + .z = (v1.x * v2.y) - (v1.y * v2.x), + }; + _ = &result; + return result; +} +pub fn Vector3Perpendicular(arg_v: Vector3) callconv(.C) Vector3 { + var v = arg_v; + _ = &v; + var result: Vector3 = Vector3{ + .x = @as(f32, @floatFromInt(@as(c_int, 0))), + .y = 0, + .z = 0, + }; + _ = &result; + var min: f32 = fabsf(v.x); + _ = &min; + var cardinalAxis: Vector3 = Vector3{ + .x = 1.0, + .y = 0.0, + .z = 0.0, + }; + _ = &cardinalAxis; + if (fabsf(v.y) < min) { + min = fabsf(v.y); + var tmp: Vector3 = Vector3{ + .x = 0.0, + .y = 1.0, + .z = 0.0, + }; + _ = &tmp; + cardinalAxis = tmp; + } + if (fabsf(v.z) < min) { + var tmp: Vector3 = Vector3{ + .x = 0.0, + .y = 0.0, + .z = 1.0, + }; + _ = &tmp; + cardinalAxis = tmp; + } + result.x = (v.y * cardinalAxis.z) - (v.z * cardinalAxis.y); + result.y = (v.z * cardinalAxis.x) - (v.x * cardinalAxis.z); + result.z = (v.x * cardinalAxis.y) - (v.y * cardinalAxis.x); + return result; +} +pub fn Vector3Length(v: Vector3) callconv(.C) f32 { + _ = &v; + var result: f32 = sqrtf(((v.x * v.x) + (v.y * v.y)) + (v.z * v.z)); + _ = &result; + return result; +} +pub fn Vector3LengthSqr(v: Vector3) callconv(.C) f32 { + _ = &v; + var result: f32 = ((v.x * v.x) + (v.y * v.y)) + (v.z * v.z); + _ = &result; + return result; +} +pub fn Vector3DotProduct(arg_v1: Vector3, arg_v2: Vector3) callconv(.C) f32 { + var v1 = arg_v1; + _ = &v1; + var v2 = arg_v2; + _ = &v2; + var result: f32 = ((v1.x * v2.x) + (v1.y * v2.y)) + (v1.z * v2.z); + _ = &result; + return result; +} +pub fn Vector3Distance(arg_v1: Vector3, arg_v2: Vector3) callconv(.C) f32 { + var v1 = arg_v1; + _ = &v1; + var v2 = arg_v2; + _ = &v2; + var result: f32 = 0.0; + _ = &result; + var dx: f32 = v2.x - v1.x; + _ = &dx; + var dy: f32 = v2.y - v1.y; + _ = &dy; + var dz: f32 = v2.z - v1.z; + _ = &dz; + result = sqrtf(((dx * dx) + (dy * dy)) + (dz * dz)); + return result; +} +pub fn Vector3DistanceSqr(arg_v1: Vector3, arg_v2: Vector3) callconv(.C) f32 { + var v1 = arg_v1; + _ = &v1; + var v2 = arg_v2; + _ = &v2; + var result: f32 = 0.0; + _ = &result; + var dx: f32 = v2.x - v1.x; + _ = &dx; + var dy: f32 = v2.y - v1.y; + _ = &dy; + var dz: f32 = v2.z - v1.z; + _ = &dz; + result = ((dx * dx) + (dy * dy)) + (dz * dz); + return result; +} +pub fn Vector3Angle(arg_v1: Vector3, arg_v2: Vector3) callconv(.C) f32 { + var v1 = arg_v1; + _ = &v1; + var v2 = arg_v2; + _ = &v2; + var result: f32 = 0.0; + _ = &result; + var cross: Vector3 = Vector3{ + .x = (v1.y * v2.z) - (v1.z * v2.y), + .y = (v1.z * v2.x) - (v1.x * v2.z), + .z = (v1.x * v2.y) - (v1.y * v2.x), + }; + _ = ✗ + var len: f32 = sqrtf(((cross.x * cross.x) + (cross.y * cross.y)) + (cross.z * cross.z)); + _ = &len; + var dot: f32 = ((v1.x * v2.x) + (v1.y * v2.y)) + (v1.z * v2.z); + _ = ˙ + result = atan2f(len, dot); + return result; +} +pub fn Vector3Negate(arg_v: Vector3) callconv(.C) Vector3 { + var v = arg_v; + _ = &v; + var result: Vector3 = Vector3{ + .x = -v.x, + .y = -v.y, + .z = -v.z, + }; + _ = &result; + return result; +} +pub fn Vector3Divide(arg_v1: Vector3, arg_v2: Vector3) callconv(.C) Vector3 { + var v1 = arg_v1; + _ = &v1; + var v2 = arg_v2; + _ = &v2; + var result: Vector3 = Vector3{ + .x = v1.x / v2.x, + .y = v1.y / v2.y, + .z = v1.z / v2.z, + }; + _ = &result; + return result; +} +pub fn Vector3Normalize(arg_v: Vector3) callconv(.C) Vector3 { + var v = arg_v; + _ = &v; + var result: Vector3 = v; + _ = &result; + var length: f32 = sqrtf(((v.x * v.x) + (v.y * v.y)) + (v.z * v.z)); + _ = &length; + if (length != 0.0) { + var ilength: f32 = 1.0 / length; + _ = &ilength; + result.x *= ilength; + result.y *= ilength; + result.z *= ilength; + } + return result; +} +pub fn Vector3Project(arg_v1: Vector3, arg_v2: Vector3) callconv(.C) Vector3 { + var v1 = arg_v1; + _ = &v1; + var v2 = arg_v2; + _ = &v2; + var result: Vector3 = Vector3{ + .x = @as(f32, @floatFromInt(@as(c_int, 0))), + .y = 0, + .z = 0, + }; + _ = &result; + var v1dv2: f32 = ((v1.x * v2.x) + (v1.y * v2.y)) + (v1.z * v2.z); + _ = &v1dv2; + var v2dv2: f32 = ((v2.x * v2.x) + (v2.y * v2.y)) + (v2.z * v2.z); + _ = &v2dv2; + var mag: f32 = v1dv2 / v2dv2; + _ = &mag; + result.x = v2.x * mag; + result.y = v2.y * mag; + result.z = v2.z * mag; + return result; +} +pub fn Vector3Reject(arg_v1: Vector3, arg_v2: Vector3) callconv(.C) Vector3 { + var v1 = arg_v1; + _ = &v1; + var v2 = arg_v2; + _ = &v2; + var result: Vector3 = Vector3{ + .x = @as(f32, @floatFromInt(@as(c_int, 0))), + .y = 0, + .z = 0, + }; + _ = &result; + var v1dv2: f32 = ((v1.x * v2.x) + (v1.y * v2.y)) + (v1.z * v2.z); + _ = &v1dv2; + var v2dv2: f32 = ((v2.x * v2.x) + (v2.y * v2.y)) + (v2.z * v2.z); + _ = &v2dv2; + var mag: f32 = v1dv2 / v2dv2; + _ = &mag; + result.x = v1.x - (v2.x * mag); + result.y = v1.y - (v2.y * mag); + result.z = v1.z - (v2.z * mag); + return result; +} +pub fn Vector3OrthoNormalize(arg_v1: [*c]Vector3, arg_v2: [*c]Vector3) callconv(.C) void { + var v1 = arg_v1; + _ = &v1; + var v2 = arg_v2; + _ = &v2; + var length: f32 = 0.0; + _ = &length; + var ilength: f32 = 0.0; + _ = &ilength; + var v: Vector3 = v1.*; + _ = &v; + length = sqrtf(((v.x * v.x) + (v.y * v.y)) + (v.z * v.z)); + if (length == 0.0) { + length = 1.0; + } + ilength = 1.0 / length; + v1.*.x *= ilength; + v1.*.y *= ilength; + v1.*.z *= ilength; + var vn1: Vector3 = Vector3{ + .x = (v1.*.y * v2.*.z) - (v1.*.z * v2.*.y), + .y = (v1.*.z * v2.*.x) - (v1.*.x * v2.*.z), + .z = (v1.*.x * v2.*.y) - (v1.*.y * v2.*.x), + }; + _ = &vn1; + v = vn1; + length = sqrtf(((v.x * v.x) + (v.y * v.y)) + (v.z * v.z)); + if (length == 0.0) { + length = 1.0; + } + ilength = 1.0 / length; + vn1.x *= ilength; + vn1.y *= ilength; + vn1.z *= ilength; + var vn2: Vector3 = Vector3{ + .x = (vn1.y * v1.*.z) - (vn1.z * v1.*.y), + .y = (vn1.z * v1.*.x) - (vn1.x * v1.*.z), + .z = (vn1.x * v1.*.y) - (vn1.y * v1.*.x), + }; + _ = &vn2; + v2.* = vn2; +} +pub fn Vector3Transform(arg_v: Vector3, arg_mat: Matrix) callconv(.C) Vector3 { + var v = arg_v; + _ = &v; + var mat = arg_mat; + _ = &mat; + var result: Vector3 = Vector3{ + .x = @as(f32, @floatFromInt(@as(c_int, 0))), + .y = 0, + .z = 0, + }; + _ = &result; + var x: f32 = v.x; + _ = &x; + var y: f32 = v.y; + _ = &y; + var z: f32 = v.z; + _ = &z; + result.x = (((mat.m0 * x) + (mat.m4 * y)) + (mat.m8 * z)) + mat.m12; + result.y = (((mat.m1 * x) + (mat.m5 * y)) + (mat.m9 * z)) + mat.m13; + result.z = (((mat.m2 * x) + (mat.m6 * y)) + (mat.m10 * z)) + mat.m14; + return result; +} +pub fn Vector3RotateByQuaternion(arg_v: Vector3, arg_q: Quaternion) callconv(.C) Vector3 { + var v = arg_v; + _ = &v; + var q = arg_q; + _ = &q; + var result: Vector3 = Vector3{ + .x = @as(f32, @floatFromInt(@as(c_int, 0))), + .y = 0, + .z = 0, + }; + _ = &result; + result.x = ((v.x * ((((q.x * q.x) + (q.w * q.w)) - (q.y * q.y)) - (q.z * q.z))) + (v.y * (((@as(f32, @floatFromInt(@as(c_int, 2))) * q.x) * q.y) - ((@as(f32, @floatFromInt(@as(c_int, 2))) * q.w) * q.z)))) + (v.z * (((@as(f32, @floatFromInt(@as(c_int, 2))) * q.x) * q.z) + ((@as(f32, @floatFromInt(@as(c_int, 2))) * q.w) * q.y))); + result.y = ((v.x * (((@as(f32, @floatFromInt(@as(c_int, 2))) * q.w) * q.z) + ((@as(f32, @floatFromInt(@as(c_int, 2))) * q.x) * q.y))) + (v.y * ((((q.w * q.w) - (q.x * q.x)) + (q.y * q.y)) - (q.z * q.z)))) + (v.z * (((@as(f32, @floatFromInt(-@as(c_int, 2))) * q.w) * q.x) + ((@as(f32, @floatFromInt(@as(c_int, 2))) * q.y) * q.z))); + result.z = ((v.x * (((@as(f32, @floatFromInt(-@as(c_int, 2))) * q.w) * q.y) + ((@as(f32, @floatFromInt(@as(c_int, 2))) * q.x) * q.z))) + (v.y * (((@as(f32, @floatFromInt(@as(c_int, 2))) * q.w) * q.x) + ((@as(f32, @floatFromInt(@as(c_int, 2))) * q.y) * q.z)))) + (v.z * ((((q.w * q.w) - (q.x * q.x)) - (q.y * q.y)) + (q.z * q.z))); + return result; +} +pub fn Vector3RotateByAxisAngle(arg_v: Vector3, arg_axis: Vector3, arg_angle: f32) callconv(.C) Vector3 { + var v = arg_v; + _ = &v; + var axis = arg_axis; + _ = &axis; + var angle = arg_angle; + _ = ∠ + var result: Vector3 = v; + _ = &result; + var length: f32 = sqrtf(((axis.x * axis.x) + (axis.y * axis.y)) + (axis.z * axis.z)); + _ = &length; + if (length == 0.0) { + length = 1.0; + } + var ilength: f32 = 1.0 / length; + _ = &ilength; + axis.x *= ilength; + axis.y *= ilength; + axis.z *= ilength; + angle /= 2.0; + var a: f32 = sinf(angle); + _ = &a; + var b: f32 = axis.x * a; + _ = &b; + var c: f32 = axis.y * a; + _ = &c; + var d: f32 = axis.z * a; + _ = &d; + a = cosf(angle); + var w: Vector3 = Vector3{ + .x = b, + .y = c, + .z = d, + }; + _ = &w; + var wv: Vector3 = Vector3{ + .x = (w.y * v.z) - (w.z * v.y), + .y = (w.z * v.x) - (w.x * v.z), + .z = (w.x * v.y) - (w.y * v.x), + }; + _ = &wv; + var wwv: Vector3 = Vector3{ + .x = (w.y * wv.z) - (w.z * wv.y), + .y = (w.z * wv.x) - (w.x * wv.z), + .z = (w.x * wv.y) - (w.y * wv.x), + }; + _ = &wwv; + a *= @as(f32, @floatFromInt(@as(c_int, 2))); + wv.x *= a; + wv.y *= a; + wv.z *= a; + wwv.x *= @as(f32, @floatFromInt(@as(c_int, 2))); + wwv.y *= @as(f32, @floatFromInt(@as(c_int, 2))); + wwv.z *= @as(f32, @floatFromInt(@as(c_int, 2))); + result.x += wv.x; + result.y += wv.y; + result.z += wv.z; + result.x += wwv.x; + result.y += wwv.y; + result.z += wwv.z; + return result; +} +pub fn Vector3MoveTowards(arg_v: Vector3, arg_target: Vector3, arg_maxDistance: f32) callconv(.C) Vector3 { + var v = arg_v; + _ = &v; + var target = arg_target; + _ = ⌖ + var maxDistance = arg_maxDistance; + _ = &maxDistance; + var result: Vector3 = Vector3{ + .x = @as(f32, @floatFromInt(@as(c_int, 0))), + .y = 0, + .z = 0, + }; + _ = &result; + var dx: f32 = target.x - v.x; + _ = &dx; + var dy: f32 = target.y - v.y; + _ = &dy; + var dz: f32 = target.z - v.z; + _ = &dz; + var value: f32 = ((dx * dx) + (dy * dy)) + (dz * dz); + _ = &value; + if ((value == @as(f32, @floatFromInt(@as(c_int, 0)))) or ((maxDistance >= @as(f32, @floatFromInt(@as(c_int, 0)))) and (value <= (maxDistance * maxDistance)))) return target; + var dist: f32 = sqrtf(value); + _ = &dist; + result.x = v.x + ((dx / dist) * maxDistance); + result.y = v.y + ((dy / dist) * maxDistance); + result.z = v.z + ((dz / dist) * maxDistance); + return result; +} +pub fn Vector3Lerp(arg_v1: Vector3, arg_v2: Vector3, arg_amount: f32) callconv(.C) Vector3 { + var v1 = arg_v1; + _ = &v1; + var v2 = arg_v2; + _ = &v2; + var amount = arg_amount; + _ = &amount; + var result: Vector3 = Vector3{ + .x = @as(f32, @floatFromInt(@as(c_int, 0))), + .y = 0, + .z = 0, + }; + _ = &result; + result.x = v1.x + (amount * (v2.x - v1.x)); + result.y = v1.y + (amount * (v2.y - v1.y)); + result.z = v1.z + (amount * (v2.z - v1.z)); + return result; +} +pub fn Vector3CubicHermite(arg_v1: Vector3, arg_tangent1: Vector3, arg_v2: Vector3, arg_tangent2: Vector3, arg_amount: f32) callconv(.C) Vector3 { + var v1 = arg_v1; + _ = &v1; + var tangent1 = arg_tangent1; + _ = &tangent1; + var v2 = arg_v2; + _ = &v2; + var tangent2 = arg_tangent2; + _ = &tangent2; + var amount = arg_amount; + _ = &amount; + var result: Vector3 = Vector3{ + .x = @as(f32, @floatFromInt(@as(c_int, 0))), + .y = 0, + .z = 0, + }; + _ = &result; + var amountPow2: f32 = amount * amount; + _ = &amountPow2; + var amountPow3: f32 = (amount * amount) * amount; + _ = &amountPow3; + result.x = ((((((@as(f32, @floatFromInt(@as(c_int, 2))) * amountPow3) - (@as(f32, @floatFromInt(@as(c_int, 3))) * amountPow2)) + @as(f32, @floatFromInt(@as(c_int, 1)))) * v1.x) + (((amountPow3 - (@as(f32, @floatFromInt(@as(c_int, 2))) * amountPow2)) + amount) * tangent1.x)) + (((@as(f32, @floatFromInt(-@as(c_int, 2))) * amountPow3) + (@as(f32, @floatFromInt(@as(c_int, 3))) * amountPow2)) * v2.x)) + ((amountPow3 - amountPow2) * tangent2.x); + result.y = ((((((@as(f32, @floatFromInt(@as(c_int, 2))) * amountPow3) - (@as(f32, @floatFromInt(@as(c_int, 3))) * amountPow2)) + @as(f32, @floatFromInt(@as(c_int, 1)))) * v1.y) + (((amountPow3 - (@as(f32, @floatFromInt(@as(c_int, 2))) * amountPow2)) + amount) * tangent1.y)) + (((@as(f32, @floatFromInt(-@as(c_int, 2))) * amountPow3) + (@as(f32, @floatFromInt(@as(c_int, 3))) * amountPow2)) * v2.y)) + ((amountPow3 - amountPow2) * tangent2.y); + result.z = ((((((@as(f32, @floatFromInt(@as(c_int, 2))) * amountPow3) - (@as(f32, @floatFromInt(@as(c_int, 3))) * amountPow2)) + @as(f32, @floatFromInt(@as(c_int, 1)))) * v1.z) + (((amountPow3 - (@as(f32, @floatFromInt(@as(c_int, 2))) * amountPow2)) + amount) * tangent1.z)) + (((@as(f32, @floatFromInt(-@as(c_int, 2))) * amountPow3) + (@as(f32, @floatFromInt(@as(c_int, 3))) * amountPow2)) * v2.z)) + ((amountPow3 - amountPow2) * tangent2.z); + return result; +} +pub fn Vector3Reflect(arg_v: Vector3, arg_normal: Vector3) callconv(.C) Vector3 { + var v = arg_v; + _ = &v; + var normal = arg_normal; + _ = &normal; + var result: Vector3 = Vector3{ + .x = @as(f32, @floatFromInt(@as(c_int, 0))), + .y = 0, + .z = 0, + }; + _ = &result; + var dotProduct: f32 = ((v.x * normal.x) + (v.y * normal.y)) + (v.z * normal.z); + _ = &dotProduct; + result.x = v.x - ((2.0 * normal.x) * dotProduct); + result.y = v.y - ((2.0 * normal.y) * dotProduct); + result.z = v.z - ((2.0 * normal.z) * dotProduct); + return result; +} +pub fn Vector3Min(arg_v1: Vector3, arg_v2: Vector3) callconv(.C) Vector3 { + var v1 = arg_v1; + _ = &v1; + var v2 = arg_v2; + _ = &v2; + var result: Vector3 = Vector3{ + .x = @as(f32, @floatFromInt(@as(c_int, 0))), + .y = 0, + .z = 0, + }; + _ = &result; + result.x = fminf(v1.x, v2.x); + result.y = fminf(v1.y, v2.y); + result.z = fminf(v1.z, v2.z); + return result; +} +pub fn Vector3Max(arg_v1: Vector3, arg_v2: Vector3) callconv(.C) Vector3 { + var v1 = arg_v1; + _ = &v1; + var v2 = arg_v2; + _ = &v2; + var result: Vector3 = Vector3{ + .x = @as(f32, @floatFromInt(@as(c_int, 0))), + .y = 0, + .z = 0, + }; + _ = &result; + result.x = fmaxf(v1.x, v2.x); + result.y = fmaxf(v1.y, v2.y); + result.z = fmaxf(v1.z, v2.z); + return result; +} +pub fn Vector3Barycenter(arg_p: Vector3, arg_a: Vector3, arg_b: Vector3, arg_c: Vector3) callconv(.C) Vector3 { + var p = arg_p; + _ = &p; + var a = arg_a; + _ = &a; + var b = arg_b; + _ = &b; + var c = arg_c; + _ = &c; + var result: Vector3 = Vector3{ + .x = @as(f32, @floatFromInt(@as(c_int, 0))), + .y = 0, + .z = 0, + }; + _ = &result; + var v0: Vector3 = Vector3{ + .x = b.x - a.x, + .y = b.y - a.y, + .z = b.z - a.z, + }; + _ = &v0; + var v1: Vector3 = Vector3{ + .x = c.x - a.x, + .y = c.y - a.y, + .z = c.z - a.z, + }; + _ = &v1; + var v2: Vector3 = Vector3{ + .x = p.x - a.x, + .y = p.y - a.y, + .z = p.z - a.z, + }; + _ = &v2; + var d00: f32 = ((v0.x * v0.x) + (v0.y * v0.y)) + (v0.z * v0.z); + _ = &d00; + var d01: f32 = ((v0.x * v1.x) + (v0.y * v1.y)) + (v0.z * v1.z); + _ = &d01; + var d11: f32 = ((v1.x * v1.x) + (v1.y * v1.y)) + (v1.z * v1.z); + _ = &d11; + var d20: f32 = ((v2.x * v0.x) + (v2.y * v0.y)) + (v2.z * v0.z); + _ = &d20; + var d21: f32 = ((v2.x * v1.x) + (v2.y * v1.y)) + (v2.z * v1.z); + _ = &d21; + var denom: f32 = (d00 * d11) - (d01 * d01); + _ = &denom; + result.y = ((d11 * d20) - (d01 * d21)) / denom; + result.z = ((d00 * d21) - (d01 * d20)) / denom; + result.x = 1.0 - (result.z + result.y); + return result; +} +pub fn Vector3Unproject(arg_source: Vector3, arg_projection: Matrix, arg_view: Matrix) callconv(.C) Vector3 { + var source = arg_source; + _ = &source; + var projection = arg_projection; + _ = &projection; + var view = arg_view; + _ = &view; + var result: Vector3 = Vector3{ + .x = @as(f32, @floatFromInt(@as(c_int, 0))), + .y = 0, + .z = 0, + }; + _ = &result; + var matViewProj: Matrix = Matrix{ + .m0 = (((view.m0 * projection.m0) + (view.m1 * projection.m4)) + (view.m2 * projection.m8)) + (view.m3 * projection.m12), + .m4 = (((view.m0 * projection.m1) + (view.m1 * projection.m5)) + (view.m2 * projection.m9)) + (view.m3 * projection.m13), + .m8 = (((view.m0 * projection.m2) + (view.m1 * projection.m6)) + (view.m2 * projection.m10)) + (view.m3 * projection.m14), + .m12 = (((view.m0 * projection.m3) + (view.m1 * projection.m7)) + (view.m2 * projection.m11)) + (view.m3 * projection.m15), + .m1 = (((view.m4 * projection.m0) + (view.m5 * projection.m4)) + (view.m6 * projection.m8)) + (view.m7 * projection.m12), + .m5 = (((view.m4 * projection.m1) + (view.m5 * projection.m5)) + (view.m6 * projection.m9)) + (view.m7 * projection.m13), + .m9 = (((view.m4 * projection.m2) + (view.m5 * projection.m6)) + (view.m6 * projection.m10)) + (view.m7 * projection.m14), + .m13 = (((view.m4 * projection.m3) + (view.m5 * projection.m7)) + (view.m6 * projection.m11)) + (view.m7 * projection.m15), + .m2 = (((view.m8 * projection.m0) + (view.m9 * projection.m4)) + (view.m10 * projection.m8)) + (view.m11 * projection.m12), + .m6 = (((view.m8 * projection.m1) + (view.m9 * projection.m5)) + (view.m10 * projection.m9)) + (view.m11 * projection.m13), + .m10 = (((view.m8 * projection.m2) + (view.m9 * projection.m6)) + (view.m10 * projection.m10)) + (view.m11 * projection.m14), + .m14 = (((view.m8 * projection.m3) + (view.m9 * projection.m7)) + (view.m10 * projection.m11)) + (view.m11 * projection.m15), + .m3 = (((view.m12 * projection.m0) + (view.m13 * projection.m4)) + (view.m14 * projection.m8)) + (view.m15 * projection.m12), + .m7 = (((view.m12 * projection.m1) + (view.m13 * projection.m5)) + (view.m14 * projection.m9)) + (view.m15 * projection.m13), + .m11 = (((view.m12 * projection.m2) + (view.m13 * projection.m6)) + (view.m14 * projection.m10)) + (view.m15 * projection.m14), + .m15 = (((view.m12 * projection.m3) + (view.m13 * projection.m7)) + (view.m14 * projection.m11)) + (view.m15 * projection.m15), + }; + _ = &matViewProj; + var a00: f32 = matViewProj.m0; + _ = &a00; + var a01: f32 = matViewProj.m1; + _ = &a01; + var a02: f32 = matViewProj.m2; + _ = &a02; + var a03: f32 = matViewProj.m3; + _ = &a03; + var a10: f32 = matViewProj.m4; + _ = &a10; + var a11: f32 = matViewProj.m5; + _ = &a11; + var a12: f32 = matViewProj.m6; + _ = &a12; + var a13: f32 = matViewProj.m7; + _ = &a13; + var a20: f32 = matViewProj.m8; + _ = &a20; + var a21: f32 = matViewProj.m9; + _ = &a21; + var a22: f32 = matViewProj.m10; + _ = &a22; + var a23: f32 = matViewProj.m11; + _ = &a23; + var a30: f32 = matViewProj.m12; + _ = &a30; + var a31: f32 = matViewProj.m13; + _ = &a31; + var a32: f32 = matViewProj.m14; + _ = &a32; + var a33: f32 = matViewProj.m15; + _ = &a33; + var b00: f32 = (a00 * a11) - (a01 * a10); + _ = &b00; + var b01: f32 = (a00 * a12) - (a02 * a10); + _ = &b01; + var b02: f32 = (a00 * a13) - (a03 * a10); + _ = &b02; + var b03: f32 = (a01 * a12) - (a02 * a11); + _ = &b03; + var b04: f32 = (a01 * a13) - (a03 * a11); + _ = &b04; + var b05: f32 = (a02 * a13) - (a03 * a12); + _ = &b05; + var b06: f32 = (a20 * a31) - (a21 * a30); + _ = &b06; + var b07: f32 = (a20 * a32) - (a22 * a30); + _ = &b07; + var b08: f32 = (a20 * a33) - (a23 * a30); + _ = &b08; + var b09: f32 = (a21 * a32) - (a22 * a31); + _ = &b09; + var b10: f32 = (a21 * a33) - (a23 * a31); + _ = &b10; + var b11: f32 = (a22 * a33) - (a23 * a32); + _ = &b11; + var invDet: f32 = 1.0 / ((((((b00 * b11) - (b01 * b10)) + (b02 * b09)) + (b03 * b08)) - (b04 * b07)) + (b05 * b06)); + _ = &invDet; + var matViewProjInv: Matrix = Matrix{ + .m0 = (((a11 * b11) - (a12 * b10)) + (a13 * b09)) * invDet, + .m4 = (((-a01 * b11) + (a02 * b10)) - (a03 * b09)) * invDet, + .m8 = (((a31 * b05) - (a32 * b04)) + (a33 * b03)) * invDet, + .m12 = (((-a21 * b05) + (a22 * b04)) - (a23 * b03)) * invDet, + .m1 = (((-a10 * b11) + (a12 * b08)) - (a13 * b07)) * invDet, + .m5 = (((a00 * b11) - (a02 * b08)) + (a03 * b07)) * invDet, + .m9 = (((-a30 * b05) + (a32 * b02)) - (a33 * b01)) * invDet, + .m13 = (((a20 * b05) - (a22 * b02)) + (a23 * b01)) * invDet, + .m2 = (((a10 * b10) - (a11 * b08)) + (a13 * b06)) * invDet, + .m6 = (((-a00 * b10) + (a01 * b08)) - (a03 * b06)) * invDet, + .m10 = (((a30 * b04) - (a31 * b02)) + (a33 * b00)) * invDet, + .m14 = (((-a20 * b04) + (a21 * b02)) - (a23 * b00)) * invDet, + .m3 = (((-a10 * b09) + (a11 * b07)) - (a12 * b06)) * invDet, + .m7 = (((a00 * b09) - (a01 * b07)) + (a02 * b06)) * invDet, + .m11 = (((-a30 * b03) + (a31 * b01)) - (a32 * b00)) * invDet, + .m15 = (((a20 * b03) - (a21 * b01)) + (a22 * b00)) * invDet, + }; + _ = &matViewProjInv; + var quat: Quaternion = Quaternion{ + .x = source.x, + .y = source.y, + .z = source.z, + .w = 1.0, + }; + _ = &quat; + var qtransformed: Quaternion = Quaternion{ + .x = (((matViewProjInv.m0 * quat.x) + (matViewProjInv.m4 * quat.y)) + (matViewProjInv.m8 * quat.z)) + (matViewProjInv.m12 * quat.w), + .y = (((matViewProjInv.m1 * quat.x) + (matViewProjInv.m5 * quat.y)) + (matViewProjInv.m9 * quat.z)) + (matViewProjInv.m13 * quat.w), + .z = (((matViewProjInv.m2 * quat.x) + (matViewProjInv.m6 * quat.y)) + (matViewProjInv.m10 * quat.z)) + (matViewProjInv.m14 * quat.w), + .w = (((matViewProjInv.m3 * quat.x) + (matViewProjInv.m7 * quat.y)) + (matViewProjInv.m11 * quat.z)) + (matViewProjInv.m15 * quat.w), + }; + _ = &qtransformed; + result.x = qtransformed.x / qtransformed.w; + result.y = qtransformed.y / qtransformed.w; + result.z = qtransformed.z / qtransformed.w; + return result; +} +pub fn Vector3ToFloatV(arg_v: Vector3) callconv(.C) float3 { + var v = arg_v; + _ = &v; + var buffer: float3 = float3{ + .v = [1]f32{ + 0, + } ++ [1]f32{0} ** 2, + }; + _ = &buffer; + buffer.v[@as(c_uint, @intCast(@as(c_int, 0)))] = v.x; + buffer.v[@as(c_uint, @intCast(@as(c_int, 1)))] = v.y; + buffer.v[@as(c_uint, @intCast(@as(c_int, 2)))] = v.z; + return buffer; +} +pub fn Vector3Invert(arg_v: Vector3) callconv(.C) Vector3 { + var v = arg_v; + _ = &v; + var result: Vector3 = Vector3{ + .x = 1.0 / v.x, + .y = 1.0 / v.y, + .z = 1.0 / v.z, + }; + _ = &result; + return result; +} +pub fn Vector3Clamp(arg_v: Vector3, arg_min: Vector3, arg_max: Vector3) callconv(.C) Vector3 { + var v = arg_v; + _ = &v; + var min = arg_min; + _ = &min; + var max = arg_max; + _ = &max; + var result: Vector3 = Vector3{ + .x = @as(f32, @floatFromInt(@as(c_int, 0))), + .y = 0, + .z = 0, + }; + _ = &result; + result.x = fminf(max.x, fmaxf(min.x, v.x)); + result.y = fminf(max.y, fmaxf(min.y, v.y)); + result.z = fminf(max.z, fmaxf(min.z, v.z)); + return result; +} +pub fn Vector3ClampValue(arg_v: Vector3, arg_min: f32, arg_max: f32) callconv(.C) Vector3 { + var v = arg_v; + _ = &v; + var min = arg_min; + _ = &min; + var max = arg_max; + _ = &max; + var result: Vector3 = v; + _ = &result; + var length: f32 = ((v.x * v.x) + (v.y * v.y)) + (v.z * v.z); + _ = &length; + if (length > 0.0) { + length = sqrtf(length); + var scale: f32 = 1; + _ = &scale; + if (length < min) { + scale = min / length; + } else if (length > max) { + scale = max / length; + } + result.x = v.x * scale; + result.y = v.y * scale; + result.z = v.z * scale; + } + return result; +} +pub fn Vector3Equals(arg_p: Vector3, arg_q: Vector3) callconv(.C) c_int { + var p = arg_p; + _ = &p; + var q = arg_q; + _ = &q; + var result: c_int = @intFromBool(((fabsf(p.x - q.x) <= (0.0000009999999974752427 * fmaxf(1.0, fmaxf(fabsf(p.x), fabsf(q.x))))) and (fabsf(p.y - q.y) <= (0.0000009999999974752427 * fmaxf(1.0, fmaxf(fabsf(p.y), fabsf(q.y)))))) and (fabsf(p.z - q.z) <= (0.0000009999999974752427 * fmaxf(1.0, fmaxf(fabsf(p.z), fabsf(q.z)))))); + _ = &result; + return result; +} +pub fn Vector3Refract(arg_v: Vector3, arg_n: Vector3, arg_r: f32) callconv(.C) Vector3 { + var v = arg_v; + _ = &v; + var n = arg_n; + _ = &n; + var r = arg_r; + _ = &r; + var result: Vector3 = Vector3{ + .x = @as(f32, @floatFromInt(@as(c_int, 0))), + .y = 0, + .z = 0, + }; + _ = &result; + var dot: f32 = ((v.x * n.x) + (v.y * n.y)) + (v.z * n.z); + _ = ˙ + var d: f32 = 1.0 - ((r * r) * (1.0 - (dot * dot))); + _ = &d; + if (d >= 0.0) { + d = sqrtf(d); + v.x = (r * v.x) - (((r * dot) + d) * n.x); + v.y = (r * v.y) - (((r * dot) + d) * n.y); + v.z = (r * v.z) - (((r * dot) + d) * n.z); + result = v; + } + return result; +} +pub fn Vector4Zero() callconv(.C) Vector4 { + var result: Vector4 = Vector4{ + .x = 0.0, + .y = 0.0, + .z = 0.0, + .w = 0.0, + }; + _ = &result; + return result; +} +pub fn Vector4One() callconv(.C) Vector4 { + var result: Vector4 = Vector4{ + .x = 1.0, + .y = 1.0, + .z = 1.0, + .w = 1.0, + }; + _ = &result; + return result; +} +pub fn Vector4Add(arg_v1: Vector4, arg_v2: Vector4) callconv(.C) Vector4 { + var v1 = arg_v1; + _ = &v1; + var v2 = arg_v2; + _ = &v2; + var result: Vector4 = Vector4{ + .x = v1.x + v2.x, + .y = v1.y + v2.y, + .z = v1.z + v2.z, + .w = v1.w + v2.w, + }; + _ = &result; + return result; +} +pub fn Vector4AddValue(arg_v: Vector4, arg_add: f32) callconv(.C) Vector4 { + var v = arg_v; + _ = &v; + var add = arg_add; + _ = &add; + var result: Vector4 = Vector4{ + .x = v.x + add, + .y = v.y + add, + .z = v.z + add, + .w = v.w + add, + }; + _ = &result; + return result; +} +pub fn Vector4Subtract(arg_v1: Vector4, arg_v2: Vector4) callconv(.C) Vector4 { + var v1 = arg_v1; + _ = &v1; + var v2 = arg_v2; + _ = &v2; + var result: Vector4 = Vector4{ + .x = v1.x - v2.x, + .y = v1.y - v2.y, + .z = v1.z - v2.z, + .w = v1.w - v2.w, + }; + _ = &result; + return result; +} +pub fn Vector4SubtractValue(arg_v: Vector4, arg_add: f32) callconv(.C) Vector4 { + var v = arg_v; + _ = &v; + var add = arg_add; + _ = &add; + var result: Vector4 = Vector4{ + .x = v.x - add, + .y = v.y - add, + .z = v.z - add, + .w = v.w - add, + }; + _ = &result; + return result; +} +pub fn Vector4Length(arg_v: Vector4) callconv(.C) f32 { + var v = arg_v; + _ = &v; + var result: f32 = sqrtf((((v.x * v.x) + (v.y * v.y)) + (v.z * v.z)) + (v.w * v.w)); + _ = &result; + return result; +} +pub fn Vector4LengthSqr(arg_v: Vector4) callconv(.C) f32 { + var v = arg_v; + _ = &v; + var result: f32 = (((v.x * v.x) + (v.y * v.y)) + (v.z * v.z)) + (v.w * v.w); + _ = &result; + return result; +} +pub fn Vector4DotProduct(arg_v1: Vector4, arg_v2: Vector4) callconv(.C) f32 { + var v1 = arg_v1; + _ = &v1; + var v2 = arg_v2; + _ = &v2; + var result: f32 = (((v1.x * v2.x) + (v1.y * v2.y)) + (v1.z * v2.z)) + (v1.w * v2.w); + _ = &result; + return result; +} +pub fn Vector4Distance(arg_v1: Vector4, arg_v2: Vector4) callconv(.C) f32 { + var v1 = arg_v1; + _ = &v1; + var v2 = arg_v2; + _ = &v2; + var result: f32 = sqrtf(((((v1.x - v2.x) * (v1.x - v2.x)) + ((v1.y - v2.y) * (v1.y - v2.y))) + ((v1.z - v2.z) * (v1.z - v2.z))) + ((v1.w - v2.w) * (v1.w - v2.w))); + _ = &result; + return result; +} +pub fn Vector4DistanceSqr(arg_v1: Vector4, arg_v2: Vector4) callconv(.C) f32 { + var v1 = arg_v1; + _ = &v1; + var v2 = arg_v2; + _ = &v2; + var result: f32 = ((((v1.x - v2.x) * (v1.x - v2.x)) + ((v1.y - v2.y) * (v1.y - v2.y))) + ((v1.z - v2.z) * (v1.z - v2.z))) + ((v1.w - v2.w) * (v1.w - v2.w)); + _ = &result; + return result; +} +pub fn Vector4Scale(arg_v: Vector4, arg_scale: f32) callconv(.C) Vector4 { + var v = arg_v; + _ = &v; + var scale = arg_scale; + _ = &scale; + var result: Vector4 = Vector4{ + .x = v.x * scale, + .y = v.y * scale, + .z = v.z * scale, + .w = v.w * scale, + }; + _ = &result; + return result; +} +pub fn Vector4Multiply(arg_v1: Vector4, arg_v2: Vector4) callconv(.C) Vector4 { + var v1 = arg_v1; + _ = &v1; + var v2 = arg_v2; + _ = &v2; + var result: Vector4 = Vector4{ + .x = v1.x * v2.x, + .y = v1.y * v2.y, + .z = v1.z * v2.z, + .w = v1.w * v2.w, + }; + _ = &result; + return result; +} +pub fn Vector4Negate(arg_v: Vector4) callconv(.C) Vector4 { + var v = arg_v; + _ = &v; + var result: Vector4 = Vector4{ + .x = -v.x, + .y = -v.y, + .z = -v.z, + .w = -v.w, + }; + _ = &result; + return result; +} +pub fn Vector4Divide(arg_v1: Vector4, arg_v2: Vector4) callconv(.C) Vector4 { + var v1 = arg_v1; + _ = &v1; + var v2 = arg_v2; + _ = &v2; + var result: Vector4 = Vector4{ + .x = v1.x / v2.x, + .y = v1.y / v2.y, + .z = v1.z / v2.z, + .w = v1.w / v2.w, + }; + _ = &result; + return result; +} +pub fn Vector4Normalize(arg_v: Vector4) callconv(.C) Vector4 { + var v = arg_v; + _ = &v; + var result: Vector4 = Vector4{ + .x = @as(f32, @floatFromInt(@as(c_int, 0))), + .y = 0, + .z = 0, + .w = 0, + }; + _ = &result; + var length: f32 = sqrtf((((v.x * v.x) + (v.y * v.y)) + (v.z * v.z)) + (v.w * v.w)); + _ = &length; + if (length > @as(f32, @floatFromInt(@as(c_int, 0)))) { + var ilength: f32 = 1.0 / length; + _ = &ilength; + result.x = v.x * ilength; + result.y = v.y * ilength; + result.z = v.z * ilength; + result.w = v.w * ilength; + } + return result; +} +pub fn Vector4Min(arg_v1: Vector4, arg_v2: Vector4) callconv(.C) Vector4 { + var v1 = arg_v1; + _ = &v1; + var v2 = arg_v2; + _ = &v2; + var result: Vector4 = Vector4{ + .x = @as(f32, @floatFromInt(@as(c_int, 0))), + .y = 0, + .z = 0, + .w = 0, + }; + _ = &result; + result.x = fminf(v1.x, v2.x); + result.y = fminf(v1.y, v2.y); + result.z = fminf(v1.z, v2.z); + result.w = fminf(v1.w, v2.w); + return result; +} +pub fn Vector4Max(arg_v1: Vector4, arg_v2: Vector4) callconv(.C) Vector4 { + var v1 = arg_v1; + _ = &v1; + var v2 = arg_v2; + _ = &v2; + var result: Vector4 = Vector4{ + .x = @as(f32, @floatFromInt(@as(c_int, 0))), + .y = 0, + .z = 0, + .w = 0, + }; + _ = &result; + result.x = fmaxf(v1.x, v2.x); + result.y = fmaxf(v1.y, v2.y); + result.z = fmaxf(v1.z, v2.z); + result.w = fmaxf(v1.w, v2.w); + return result; +} +pub fn Vector4Lerp(arg_v1: Vector4, arg_v2: Vector4, arg_amount: f32) callconv(.C) Vector4 { + var v1 = arg_v1; + _ = &v1; + var v2 = arg_v2; + _ = &v2; + var amount = arg_amount; + _ = &amount; + var result: Vector4 = Vector4{ + .x = @as(f32, @floatFromInt(@as(c_int, 0))), + .y = 0, + .z = 0, + .w = 0, + }; + _ = &result; + result.x = v1.x + (amount * (v2.x - v1.x)); + result.y = v1.y + (amount * (v2.y - v1.y)); + result.z = v1.z + (amount * (v2.z - v1.z)); + result.w = v1.w + (amount * (v2.w - v1.w)); + return result; +} +pub fn Vector4MoveTowards(arg_v: Vector4, arg_target: Vector4, arg_maxDistance: f32) callconv(.C) Vector4 { + var v = arg_v; + _ = &v; + var target = arg_target; + _ = ⌖ + var maxDistance = arg_maxDistance; + _ = &maxDistance; + var result: Vector4 = Vector4{ + .x = @as(f32, @floatFromInt(@as(c_int, 0))), + .y = 0, + .z = 0, + .w = 0, + }; + _ = &result; + var dx: f32 = target.x - v.x; + _ = &dx; + var dy: f32 = target.y - v.y; + _ = &dy; + var dz: f32 = target.z - v.z; + _ = &dz; + var dw: f32 = target.w - v.w; + _ = &dw; + var value: f32 = (((dx * dx) + (dy * dy)) + (dz * dz)) + (dw * dw); + _ = &value; + if ((value == @as(f32, @floatFromInt(@as(c_int, 0)))) or ((maxDistance >= @as(f32, @floatFromInt(@as(c_int, 0)))) and (value <= (maxDistance * maxDistance)))) return target; + var dist: f32 = sqrtf(value); + _ = &dist; + result.x = v.x + ((dx / dist) * maxDistance); + result.y = v.y + ((dy / dist) * maxDistance); + result.z = v.z + ((dz / dist) * maxDistance); + result.w = v.w + ((dw / dist) * maxDistance); + return result; +} +pub fn Vector4Invert(arg_v: Vector4) callconv(.C) Vector4 { + var v = arg_v; + _ = &v; + var result: Vector4 = Vector4{ + .x = 1.0 / v.x, + .y = 1.0 / v.y, + .z = 1.0 / v.z, + .w = 1.0 / v.w, + }; + _ = &result; + return result; +} +pub fn Vector4Equals(arg_p: Vector4, arg_q: Vector4) callconv(.C) c_int { + var p = arg_p; + _ = &p; + var q = arg_q; + _ = &q; + var result: c_int = @intFromBool((((fabsf(p.x - q.x) <= (0.0000009999999974752427 * fmaxf(1.0, fmaxf(fabsf(p.x), fabsf(q.x))))) and (fabsf(p.y - q.y) <= (0.0000009999999974752427 * fmaxf(1.0, fmaxf(fabsf(p.y), fabsf(q.y)))))) and (fabsf(p.z - q.z) <= (0.0000009999999974752427 * fmaxf(1.0, fmaxf(fabsf(p.z), fabsf(q.z)))))) and (fabsf(p.w - q.w) <= (0.0000009999999974752427 * fmaxf(1.0, fmaxf(fabsf(p.w), fabsf(q.w)))))); + _ = &result; + return result; +} +pub fn MatrixDeterminant(arg_mat: Matrix) callconv(.C) f32 { + var mat = arg_mat; + _ = &mat; + var result: f32 = 0.0; + _ = &result; + var a00: f32 = mat.m0; + _ = &a00; + var a01: f32 = mat.m1; + _ = &a01; + var a02: f32 = mat.m2; + _ = &a02; + var a03: f32 = mat.m3; + _ = &a03; + var a10: f32 = mat.m4; + _ = &a10; + var a11: f32 = mat.m5; + _ = &a11; + var a12: f32 = mat.m6; + _ = &a12; + var a13: f32 = mat.m7; + _ = &a13; + var a20: f32 = mat.m8; + _ = &a20; + var a21: f32 = mat.m9; + _ = &a21; + var a22: f32 = mat.m10; + _ = &a22; + var a23: f32 = mat.m11; + _ = &a23; + var a30: f32 = mat.m12; + _ = &a30; + var a31: f32 = mat.m13; + _ = &a31; + var a32: f32 = mat.m14; + _ = &a32; + var a33: f32 = mat.m15; + _ = &a33; + result = (((((((((((((((((((((((((a30 * a21) * a12) * a03) - (((a20 * a31) * a12) * a03)) - (((a30 * a11) * a22) * a03)) + (((a10 * a31) * a22) * a03)) + (((a20 * a11) * a32) * a03)) - (((a10 * a21) * a32) * a03)) - (((a30 * a21) * a02) * a13)) + (((a20 * a31) * a02) * a13)) + (((a30 * a01) * a22) * a13)) - (((a00 * a31) * a22) * a13)) - (((a20 * a01) * a32) * a13)) + (((a00 * a21) * a32) * a13)) + (((a30 * a11) * a02) * a23)) - (((a10 * a31) * a02) * a23)) - (((a30 * a01) * a12) * a23)) + (((a00 * a31) * a12) * a23)) + (((a10 * a01) * a32) * a23)) - (((a00 * a11) * a32) * a23)) - (((a20 * a11) * a02) * a33)) + (((a10 * a21) * a02) * a33)) + (((a20 * a01) * a12) * a33)) - (((a00 * a21) * a12) * a33)) - (((a10 * a01) * a22) * a33)) + (((a00 * a11) * a22) * a33); + return result; +} +pub fn MatrixTrace(arg_mat: Matrix) callconv(.C) f32 { + var mat = arg_mat; + _ = &mat; + var result: f32 = ((mat.m0 + mat.m5) + mat.m10) + mat.m15; + _ = &result; + return result; +} +pub fn MatrixTranspose(arg_mat: Matrix) callconv(.C) Matrix { + var mat = arg_mat; + _ = &mat; + var result: Matrix = Matrix{ + .m0 = @as(f32, @floatFromInt(@as(c_int, 0))), + .m4 = 0, + .m8 = 0, + .m12 = 0, + .m1 = 0, + .m5 = 0, + .m9 = 0, + .m13 = 0, + .m2 = 0, + .m6 = 0, + .m10 = 0, + .m14 = 0, + .m3 = 0, + .m7 = 0, + .m11 = 0, + .m15 = 0, + }; + _ = &result; + result.m0 = mat.m0; + result.m1 = mat.m4; + result.m2 = mat.m8; + result.m3 = mat.m12; + result.m4 = mat.m1; + result.m5 = mat.m5; + result.m6 = mat.m9; + result.m7 = mat.m13; + result.m8 = mat.m2; + result.m9 = mat.m6; + result.m10 = mat.m10; + result.m11 = mat.m14; + result.m12 = mat.m3; + result.m13 = mat.m7; + result.m14 = mat.m11; + result.m15 = mat.m15; + return result; +} +pub fn MatrixInvert(arg_mat: Matrix) callconv(.C) Matrix { + var mat = arg_mat; + _ = &mat; + var result: Matrix = Matrix{ + .m0 = @as(f32, @floatFromInt(@as(c_int, 0))), + .m4 = 0, + .m8 = 0, + .m12 = 0, + .m1 = 0, + .m5 = 0, + .m9 = 0, + .m13 = 0, + .m2 = 0, + .m6 = 0, + .m10 = 0, + .m14 = 0, + .m3 = 0, + .m7 = 0, + .m11 = 0, + .m15 = 0, + }; + _ = &result; + var a00: f32 = mat.m0; + _ = &a00; + var a01: f32 = mat.m1; + _ = &a01; + var a02: f32 = mat.m2; + _ = &a02; + var a03: f32 = mat.m3; + _ = &a03; + var a10: f32 = mat.m4; + _ = &a10; + var a11: f32 = mat.m5; + _ = &a11; + var a12: f32 = mat.m6; + _ = &a12; + var a13: f32 = mat.m7; + _ = &a13; + var a20: f32 = mat.m8; + _ = &a20; + var a21: f32 = mat.m9; + _ = &a21; + var a22: f32 = mat.m10; + _ = &a22; + var a23: f32 = mat.m11; + _ = &a23; + var a30: f32 = mat.m12; + _ = &a30; + var a31: f32 = mat.m13; + _ = &a31; + var a32: f32 = mat.m14; + _ = &a32; + var a33: f32 = mat.m15; + _ = &a33; + var b00: f32 = (a00 * a11) - (a01 * a10); + _ = &b00; + var b01: f32 = (a00 * a12) - (a02 * a10); + _ = &b01; + var b02: f32 = (a00 * a13) - (a03 * a10); + _ = &b02; + var b03: f32 = (a01 * a12) - (a02 * a11); + _ = &b03; + var b04: f32 = (a01 * a13) - (a03 * a11); + _ = &b04; + var b05: f32 = (a02 * a13) - (a03 * a12); + _ = &b05; + var b06: f32 = (a20 * a31) - (a21 * a30); + _ = &b06; + var b07: f32 = (a20 * a32) - (a22 * a30); + _ = &b07; + var b08: f32 = (a20 * a33) - (a23 * a30); + _ = &b08; + var b09: f32 = (a21 * a32) - (a22 * a31); + _ = &b09; + var b10: f32 = (a21 * a33) - (a23 * a31); + _ = &b10; + var b11: f32 = (a22 * a33) - (a23 * a32); + _ = &b11; + var invDet: f32 = 1.0 / ((((((b00 * b11) - (b01 * b10)) + (b02 * b09)) + (b03 * b08)) - (b04 * b07)) + (b05 * b06)); + _ = &invDet; + result.m0 = (((a11 * b11) - (a12 * b10)) + (a13 * b09)) * invDet; + result.m1 = (((-a01 * b11) + (a02 * b10)) - (a03 * b09)) * invDet; + result.m2 = (((a31 * b05) - (a32 * b04)) + (a33 * b03)) * invDet; + result.m3 = (((-a21 * b05) + (a22 * b04)) - (a23 * b03)) * invDet; + result.m4 = (((-a10 * b11) + (a12 * b08)) - (a13 * b07)) * invDet; + result.m5 = (((a00 * b11) - (a02 * b08)) + (a03 * b07)) * invDet; + result.m6 = (((-a30 * b05) + (a32 * b02)) - (a33 * b01)) * invDet; + result.m7 = (((a20 * b05) - (a22 * b02)) + (a23 * b01)) * invDet; + result.m8 = (((a10 * b10) - (a11 * b08)) + (a13 * b06)) * invDet; + result.m9 = (((-a00 * b10) + (a01 * b08)) - (a03 * b06)) * invDet; + result.m10 = (((a30 * b04) - (a31 * b02)) + (a33 * b00)) * invDet; + result.m11 = (((-a20 * b04) + (a21 * b02)) - (a23 * b00)) * invDet; + result.m12 = (((-a10 * b09) + (a11 * b07)) - (a12 * b06)) * invDet; + result.m13 = (((a00 * b09) - (a01 * b07)) + (a02 * b06)) * invDet; + result.m14 = (((-a30 * b03) + (a31 * b01)) - (a32 * b00)) * invDet; + result.m15 = (((a20 * b03) - (a21 * b01)) + (a22 * b00)) * invDet; + return result; +} +pub fn MatrixIdentity() callconv(.C) Matrix { + var result: Matrix = Matrix{ + .m0 = 1.0, + .m4 = 0.0, + .m8 = 0.0, + .m12 = 0.0, + .m1 = 0.0, + .m5 = 1.0, + .m9 = 0.0, + .m13 = 0.0, + .m2 = 0.0, + .m6 = 0.0, + .m10 = 1.0, + .m14 = 0.0, + .m3 = 0.0, + .m7 = 0.0, + .m11 = 0.0, + .m15 = 1.0, + }; + _ = &result; + return result; +} +pub fn MatrixAdd(arg_left: Matrix, arg_right: Matrix) callconv(.C) Matrix { + var left = arg_left; + _ = &left; + var right = arg_right; + _ = &right; + var result: Matrix = Matrix{ + .m0 = @as(f32, @floatFromInt(@as(c_int, 0))), + .m4 = 0, + .m8 = 0, + .m12 = 0, + .m1 = 0, + .m5 = 0, + .m9 = 0, + .m13 = 0, + .m2 = 0, + .m6 = 0, + .m10 = 0, + .m14 = 0, + .m3 = 0, + .m7 = 0, + .m11 = 0, + .m15 = 0, + }; + _ = &result; + result.m0 = left.m0 + right.m0; + result.m1 = left.m1 + right.m1; + result.m2 = left.m2 + right.m2; + result.m3 = left.m3 + right.m3; + result.m4 = left.m4 + right.m4; + result.m5 = left.m5 + right.m5; + result.m6 = left.m6 + right.m6; + result.m7 = left.m7 + right.m7; + result.m8 = left.m8 + right.m8; + result.m9 = left.m9 + right.m9; + result.m10 = left.m10 + right.m10; + result.m11 = left.m11 + right.m11; + result.m12 = left.m12 + right.m12; + result.m13 = left.m13 + right.m13; + result.m14 = left.m14 + right.m14; + result.m15 = left.m15 + right.m15; + return result; +} +pub fn MatrixSubtract(arg_left: Matrix, arg_right: Matrix) callconv(.C) Matrix { + var left = arg_left; + _ = &left; + var right = arg_right; + _ = &right; + var result: Matrix = Matrix{ + .m0 = @as(f32, @floatFromInt(@as(c_int, 0))), + .m4 = 0, + .m8 = 0, + .m12 = 0, + .m1 = 0, + .m5 = 0, + .m9 = 0, + .m13 = 0, + .m2 = 0, + .m6 = 0, + .m10 = 0, + .m14 = 0, + .m3 = 0, + .m7 = 0, + .m11 = 0, + .m15 = 0, + }; + _ = &result; + result.m0 = left.m0 - right.m0; + result.m1 = left.m1 - right.m1; + result.m2 = left.m2 - right.m2; + result.m3 = left.m3 - right.m3; + result.m4 = left.m4 - right.m4; + result.m5 = left.m5 - right.m5; + result.m6 = left.m6 - right.m6; + result.m7 = left.m7 - right.m7; + result.m8 = left.m8 - right.m8; + result.m9 = left.m9 - right.m9; + result.m10 = left.m10 - right.m10; + result.m11 = left.m11 - right.m11; + result.m12 = left.m12 - right.m12; + result.m13 = left.m13 - right.m13; + result.m14 = left.m14 - right.m14; + result.m15 = left.m15 - right.m15; + return result; +} +pub fn MatrixMultiply(arg_left: Matrix, arg_right: Matrix) callconv(.C) Matrix { + var left = arg_left; + _ = &left; + var right = arg_right; + _ = &right; + var result: Matrix = Matrix{ + .m0 = @as(f32, @floatFromInt(@as(c_int, 0))), + .m4 = 0, + .m8 = 0, + .m12 = 0, + .m1 = 0, + .m5 = 0, + .m9 = 0, + .m13 = 0, + .m2 = 0, + .m6 = 0, + .m10 = 0, + .m14 = 0, + .m3 = 0, + .m7 = 0, + .m11 = 0, + .m15 = 0, + }; + _ = &result; + result.m0 = (((left.m0 * right.m0) + (left.m1 * right.m4)) + (left.m2 * right.m8)) + (left.m3 * right.m12); + result.m1 = (((left.m0 * right.m1) + (left.m1 * right.m5)) + (left.m2 * right.m9)) + (left.m3 * right.m13); + result.m2 = (((left.m0 * right.m2) + (left.m1 * right.m6)) + (left.m2 * right.m10)) + (left.m3 * right.m14); + result.m3 = (((left.m0 * right.m3) + (left.m1 * right.m7)) + (left.m2 * right.m11)) + (left.m3 * right.m15); + result.m4 = (((left.m4 * right.m0) + (left.m5 * right.m4)) + (left.m6 * right.m8)) + (left.m7 * right.m12); + result.m5 = (((left.m4 * right.m1) + (left.m5 * right.m5)) + (left.m6 * right.m9)) + (left.m7 * right.m13); + result.m6 = (((left.m4 * right.m2) + (left.m5 * right.m6)) + (left.m6 * right.m10)) + (left.m7 * right.m14); + result.m7 = (((left.m4 * right.m3) + (left.m5 * right.m7)) + (left.m6 * right.m11)) + (left.m7 * right.m15); + result.m8 = (((left.m8 * right.m0) + (left.m9 * right.m4)) + (left.m10 * right.m8)) + (left.m11 * right.m12); + result.m9 = (((left.m8 * right.m1) + (left.m9 * right.m5)) + (left.m10 * right.m9)) + (left.m11 * right.m13); + result.m10 = (((left.m8 * right.m2) + (left.m9 * right.m6)) + (left.m10 * right.m10)) + (left.m11 * right.m14); + result.m11 = (((left.m8 * right.m3) + (left.m9 * right.m7)) + (left.m10 * right.m11)) + (left.m11 * right.m15); + result.m12 = (((left.m12 * right.m0) + (left.m13 * right.m4)) + (left.m14 * right.m8)) + (left.m15 * right.m12); + result.m13 = (((left.m12 * right.m1) + (left.m13 * right.m5)) + (left.m14 * right.m9)) + (left.m15 * right.m13); + result.m14 = (((left.m12 * right.m2) + (left.m13 * right.m6)) + (left.m14 * right.m10)) + (left.m15 * right.m14); + result.m15 = (((left.m12 * right.m3) + (left.m13 * right.m7)) + (left.m14 * right.m11)) + (left.m15 * right.m15); + return result; +} +pub fn MatrixTranslate(arg_x: f32, arg_y: f32, arg_z: f32) callconv(.C) Matrix { + var x = arg_x; + _ = &x; + var y = arg_y; + _ = &y; + var z = arg_z; + _ = &z; + var result: Matrix = Matrix{ + .m0 = 1.0, + .m4 = 0.0, + .m8 = 0.0, + .m12 = x, + .m1 = 0.0, + .m5 = 1.0, + .m9 = 0.0, + .m13 = y, + .m2 = 0.0, + .m6 = 0.0, + .m10 = 1.0, + .m14 = z, + .m3 = 0.0, + .m7 = 0.0, + .m11 = 0.0, + .m15 = 1.0, + }; + _ = &result; + return result; +} +pub fn MatrixRotate(arg_axis: Vector3, arg_angle: f32) callconv(.C) Matrix { + var axis = arg_axis; + _ = &axis; + var angle = arg_angle; + _ = ∠ + var result: Matrix = Matrix{ + .m0 = @as(f32, @floatFromInt(@as(c_int, 0))), + .m4 = 0, + .m8 = 0, + .m12 = 0, + .m1 = 0, + .m5 = 0, + .m9 = 0, + .m13 = 0, + .m2 = 0, + .m6 = 0, + .m10 = 0, + .m14 = 0, + .m3 = 0, + .m7 = 0, + .m11 = 0, + .m15 = 0, + }; + _ = &result; + var x: f32 = axis.x; + _ = &x; + var y: f32 = axis.y; + _ = &y; + var z: f32 = axis.z; + _ = &z; + var lengthSquared: f32 = ((x * x) + (y * y)) + (z * z); + _ = &lengthSquared; + if ((lengthSquared != 1.0) and (lengthSquared != 0.0)) { + var ilength: f32 = 1.0 / sqrtf(lengthSquared); + _ = &ilength; + x *= ilength; + y *= ilength; + z *= ilength; + } + var sinres: f32 = sinf(angle); + _ = &sinres; + var cosres: f32 = cosf(angle); + _ = &cosres; + var t: f32 = 1.0 - cosres; + _ = &t; + result.m0 = ((x * x) * t) + cosres; + result.m1 = ((y * x) * t) + (z * sinres); + result.m2 = ((z * x) * t) - (y * sinres); + result.m3 = 0.0; + result.m4 = ((x * y) * t) - (z * sinres); + result.m5 = ((y * y) * t) + cosres; + result.m6 = ((z * y) * t) + (x * sinres); + result.m7 = 0.0; + result.m8 = ((x * z) * t) + (y * sinres); + result.m9 = ((y * z) * t) - (x * sinres); + result.m10 = ((z * z) * t) + cosres; + result.m11 = 0.0; + result.m12 = 0.0; + result.m13 = 0.0; + result.m14 = 0.0; + result.m15 = 1.0; + return result; +} +pub fn MatrixRotateX(arg_angle: f32) callconv(.C) Matrix { + var angle = arg_angle; + _ = ∠ + var result: Matrix = Matrix{ + .m0 = 1.0, + .m4 = 0.0, + .m8 = 0.0, + .m12 = 0.0, + .m1 = 0.0, + .m5 = 1.0, + .m9 = 0.0, + .m13 = 0.0, + .m2 = 0.0, + .m6 = 0.0, + .m10 = 1.0, + .m14 = 0.0, + .m3 = 0.0, + .m7 = 0.0, + .m11 = 0.0, + .m15 = 1.0, + }; + _ = &result; + var cosres: f32 = cosf(angle); + _ = &cosres; + var sinres: f32 = sinf(angle); + _ = &sinres; + result.m5 = cosres; + result.m6 = sinres; + result.m9 = -sinres; + result.m10 = cosres; + return result; +} +pub fn MatrixRotateY(arg_angle: f32) callconv(.C) Matrix { + var angle = arg_angle; + _ = ∠ + var result: Matrix = Matrix{ + .m0 = 1.0, + .m4 = 0.0, + .m8 = 0.0, + .m12 = 0.0, + .m1 = 0.0, + .m5 = 1.0, + .m9 = 0.0, + .m13 = 0.0, + .m2 = 0.0, + .m6 = 0.0, + .m10 = 1.0, + .m14 = 0.0, + .m3 = 0.0, + .m7 = 0.0, + .m11 = 0.0, + .m15 = 1.0, + }; + _ = &result; + var cosres: f32 = cosf(angle); + _ = &cosres; + var sinres: f32 = sinf(angle); + _ = &sinres; + result.m0 = cosres; + result.m2 = -sinres; + result.m8 = sinres; + result.m10 = cosres; + return result; +} +pub fn MatrixRotateZ(arg_angle: f32) callconv(.C) Matrix { + var angle = arg_angle; + _ = ∠ + var result: Matrix = Matrix{ + .m0 = 1.0, + .m4 = 0.0, + .m8 = 0.0, + .m12 = 0.0, + .m1 = 0.0, + .m5 = 1.0, + .m9 = 0.0, + .m13 = 0.0, + .m2 = 0.0, + .m6 = 0.0, + .m10 = 1.0, + .m14 = 0.0, + .m3 = 0.0, + .m7 = 0.0, + .m11 = 0.0, + .m15 = 1.0, + }; + _ = &result; + var cosres: f32 = cosf(angle); + _ = &cosres; + var sinres: f32 = sinf(angle); + _ = &sinres; + result.m0 = cosres; + result.m1 = sinres; + result.m4 = -sinres; + result.m5 = cosres; + return result; +} +pub fn MatrixRotateXYZ(arg_angle: Vector3) callconv(.C) Matrix { + var angle = arg_angle; + _ = ∠ + var result: Matrix = Matrix{ + .m0 = 1.0, + .m4 = 0.0, + .m8 = 0.0, + .m12 = 0.0, + .m1 = 0.0, + .m5 = 1.0, + .m9 = 0.0, + .m13 = 0.0, + .m2 = 0.0, + .m6 = 0.0, + .m10 = 1.0, + .m14 = 0.0, + .m3 = 0.0, + .m7 = 0.0, + .m11 = 0.0, + .m15 = 1.0, + }; + _ = &result; + var cosz: f32 = cosf(-angle.z); + _ = &cosz; + var sinz: f32 = sinf(-angle.z); + _ = &sinz; + var cosy: f32 = cosf(-angle.y); + _ = &cosy; + var siny: f32 = sinf(-angle.y); + _ = &siny; + var cosx: f32 = cosf(-angle.x); + _ = &cosx; + var sinx: f32 = sinf(-angle.x); + _ = &sinx; + result.m0 = cosz * cosy; + result.m1 = ((cosz * siny) * sinx) - (sinz * cosx); + result.m2 = ((cosz * siny) * cosx) + (sinz * sinx); + result.m4 = sinz * cosy; + result.m5 = ((sinz * siny) * sinx) + (cosz * cosx); + result.m6 = ((sinz * siny) * cosx) - (cosz * sinx); + result.m8 = -siny; + result.m9 = cosy * sinx; + result.m10 = cosy * cosx; + return result; +} +pub fn MatrixRotateZYX(arg_angle: Vector3) callconv(.C) Matrix { + var angle = arg_angle; + _ = ∠ + var result: Matrix = Matrix{ + .m0 = @as(f32, @floatFromInt(@as(c_int, 0))), + .m4 = 0, + .m8 = 0, + .m12 = 0, + .m1 = 0, + .m5 = 0, + .m9 = 0, + .m13 = 0, + .m2 = 0, + .m6 = 0, + .m10 = 0, + .m14 = 0, + .m3 = 0, + .m7 = 0, + .m11 = 0, + .m15 = 0, + }; + _ = &result; + var cz: f32 = cosf(angle.z); + _ = &cz; + var sz: f32 = sinf(angle.z); + _ = &sz; + var cy: f32 = cosf(angle.y); + _ = &cy; + var sy: f32 = sinf(angle.y); + _ = &sy; + var cx: f32 = cosf(angle.x); + _ = &cx; + var sx: f32 = sinf(angle.x); + _ = &sx; + result.m0 = cz * cy; + result.m4 = ((cz * sy) * sx) - (cx * sz); + result.m8 = (sz * sx) + ((cz * cx) * sy); + result.m12 = 0; + result.m1 = cy * sz; + result.m5 = (cz * cx) + ((sz * sy) * sx); + result.m9 = ((cx * sz) * sy) - (cz * sx); + result.m13 = 0; + result.m2 = -sy; + result.m6 = cy * sx; + result.m10 = cy * cx; + result.m14 = 0; + result.m3 = 0; + result.m7 = 0; + result.m11 = 0; + result.m15 = 1; + return result; +} +pub fn MatrixScale(arg_x: f32, arg_y: f32, arg_z: f32) callconv(.C) Matrix { + var x = arg_x; + _ = &x; + var y = arg_y; + _ = &y; + var z = arg_z; + _ = &z; + var result: Matrix = Matrix{ + .m0 = x, + .m4 = 0.0, + .m8 = 0.0, + .m12 = 0.0, + .m1 = 0.0, + .m5 = y, + .m9 = 0.0, + .m13 = 0.0, + .m2 = 0.0, + .m6 = 0.0, + .m10 = z, + .m14 = 0.0, + .m3 = 0.0, + .m7 = 0.0, + .m11 = 0.0, + .m15 = 1.0, + }; + _ = &result; + return result; +} +pub fn MatrixFrustum(arg_left: f64, arg_right: f64, arg_bottom: f64, arg_top: f64, arg_nearPlane: f64, arg_farPlane: f64) callconv(.C) Matrix { + var left = arg_left; + _ = &left; + var right = arg_right; + _ = &right; + var bottom = arg_bottom; + _ = ⊥ + var top = arg_top; + _ = ⊤ + var nearPlane = arg_nearPlane; + _ = &nearPlane; + var farPlane = arg_farPlane; + _ = &farPlane; + var result: Matrix = Matrix{ + .m0 = @as(f32, @floatFromInt(@as(c_int, 0))), + .m4 = 0, + .m8 = 0, + .m12 = 0, + .m1 = 0, + .m5 = 0, + .m9 = 0, + .m13 = 0, + .m2 = 0, + .m6 = 0, + .m10 = 0, + .m14 = 0, + .m3 = 0, + .m7 = 0, + .m11 = 0, + .m15 = 0, + }; + _ = &result; + var rl: f32 = @as(f32, @floatCast(right - left)); + _ = &rl; + var tb: f32 = @as(f32, @floatCast(top - bottom)); + _ = &tb; + var @"fn": f32 = @as(f32, @floatCast(farPlane - nearPlane)); + _ = &@"fn"; + result.m0 = (@as(f32, @floatCast(nearPlane)) * 2.0) / rl; + result.m1 = 0.0; + result.m2 = 0.0; + result.m3 = 0.0; + result.m4 = 0.0; + result.m5 = (@as(f32, @floatCast(nearPlane)) * 2.0) / tb; + result.m6 = 0.0; + result.m7 = 0.0; + result.m8 = (@as(f32, @floatCast(right)) + @as(f32, @floatCast(left))) / rl; + result.m9 = (@as(f32, @floatCast(top)) + @as(f32, @floatCast(bottom))) / tb; + result.m10 = -(@as(f32, @floatCast(farPlane)) + @as(f32, @floatCast(nearPlane))) / @"fn"; + result.m11 = -1.0; + result.m12 = 0.0; + result.m13 = 0.0; + result.m14 = -((@as(f32, @floatCast(farPlane)) * @as(f32, @floatCast(nearPlane))) * 2.0) / @"fn"; + result.m15 = 0.0; + return result; +} +pub fn MatrixPerspective(arg_fovY: f64, arg_aspect: f64, arg_nearPlane: f64, arg_farPlane: f64) callconv(.C) Matrix { + var fovY = arg_fovY; + _ = &fovY; + var aspect = arg_aspect; + _ = &aspect; + var nearPlane = arg_nearPlane; + _ = &nearPlane; + var farPlane = arg_farPlane; + _ = &farPlane; + var result: Matrix = Matrix{ + .m0 = @as(f32, @floatFromInt(@as(c_int, 0))), + .m4 = 0, + .m8 = 0, + .m12 = 0, + .m1 = 0, + .m5 = 0, + .m9 = 0, + .m13 = 0, + .m2 = 0, + .m6 = 0, + .m10 = 0, + .m14 = 0, + .m3 = 0, + .m7 = 0, + .m11 = 0, + .m15 = 0, + }; + _ = &result; + var top: f64 = nearPlane * tan(fovY * 0.5); + _ = ⊤ + var bottom: f64 = -top; + _ = ⊥ + var right: f64 = top * aspect; + _ = &right; + var left: f64 = -right; + _ = &left; + var rl: f32 = @as(f32, @floatCast(right - left)); + _ = &rl; + var tb: f32 = @as(f32, @floatCast(top - bottom)); + _ = &tb; + var @"fn": f32 = @as(f32, @floatCast(farPlane - nearPlane)); + _ = &@"fn"; + result.m0 = (@as(f32, @floatCast(nearPlane)) * 2.0) / rl; + result.m5 = (@as(f32, @floatCast(nearPlane)) * 2.0) / tb; + result.m8 = (@as(f32, @floatCast(right)) + @as(f32, @floatCast(left))) / rl; + result.m9 = (@as(f32, @floatCast(top)) + @as(f32, @floatCast(bottom))) / tb; + result.m10 = -(@as(f32, @floatCast(farPlane)) + @as(f32, @floatCast(nearPlane))) / @"fn"; + result.m11 = -1.0; + result.m14 = -((@as(f32, @floatCast(farPlane)) * @as(f32, @floatCast(nearPlane))) * 2.0) / @"fn"; + return result; +} +pub fn MatrixOrtho(arg_left: f64, arg_right: f64, arg_bottom: f64, arg_top: f64, arg_nearPlane: f64, arg_farPlane: f64) callconv(.C) Matrix { + var left = arg_left; + _ = &left; + var right = arg_right; + _ = &right; + var bottom = arg_bottom; + _ = ⊥ + var top = arg_top; + _ = ⊤ + var nearPlane = arg_nearPlane; + _ = &nearPlane; + var farPlane = arg_farPlane; + _ = &farPlane; + var result: Matrix = Matrix{ + .m0 = @as(f32, @floatFromInt(@as(c_int, 0))), + .m4 = 0, + .m8 = 0, + .m12 = 0, + .m1 = 0, + .m5 = 0, + .m9 = 0, + .m13 = 0, + .m2 = 0, + .m6 = 0, + .m10 = 0, + .m14 = 0, + .m3 = 0, + .m7 = 0, + .m11 = 0, + .m15 = 0, + }; + _ = &result; + var rl: f32 = @as(f32, @floatCast(right - left)); + _ = &rl; + var tb: f32 = @as(f32, @floatCast(top - bottom)); + _ = &tb; + var @"fn": f32 = @as(f32, @floatCast(farPlane - nearPlane)); + _ = &@"fn"; + result.m0 = 2.0 / rl; + result.m1 = 0.0; + result.m2 = 0.0; + result.m3 = 0.0; + result.m4 = 0.0; + result.m5 = 2.0 / tb; + result.m6 = 0.0; + result.m7 = 0.0; + result.m8 = 0.0; + result.m9 = 0.0; + result.m10 = -2.0 / @"fn"; + result.m11 = 0.0; + result.m12 = -(@as(f32, @floatCast(left)) + @as(f32, @floatCast(right))) / rl; + result.m13 = -(@as(f32, @floatCast(top)) + @as(f32, @floatCast(bottom))) / tb; + result.m14 = -(@as(f32, @floatCast(farPlane)) + @as(f32, @floatCast(nearPlane))) / @"fn"; + result.m15 = 1.0; + return result; +} +pub fn MatrixLookAt(arg_eye: Vector3, arg_target: Vector3, arg_up: Vector3) callconv(.C) Matrix { + var eye = arg_eye; + _ = &eye; + var target = arg_target; + _ = ⌖ + var up = arg_up; + _ = &up; + var result: Matrix = Matrix{ + .m0 = @as(f32, @floatFromInt(@as(c_int, 0))), + .m4 = 0, + .m8 = 0, + .m12 = 0, + .m1 = 0, + .m5 = 0, + .m9 = 0, + .m13 = 0, + .m2 = 0, + .m6 = 0, + .m10 = 0, + .m14 = 0, + .m3 = 0, + .m7 = 0, + .m11 = 0, + .m15 = 0, + }; + _ = &result; + var length: f32 = 0.0; + _ = &length; + var ilength: f32 = 0.0; + _ = &ilength; + var vz: Vector3 = Vector3{ + .x = eye.x - target.x, + .y = eye.y - target.y, + .z = eye.z - target.z, + }; + _ = &vz; + var v: Vector3 = vz; + _ = &v; + length = sqrtf(((v.x * v.x) + (v.y * v.y)) + (v.z * v.z)); + if (length == 0.0) { + length = 1.0; + } + ilength = 1.0 / length; + vz.x *= ilength; + vz.y *= ilength; + vz.z *= ilength; + var vx: Vector3 = Vector3{ + .x = (up.y * vz.z) - (up.z * vz.y), + .y = (up.z * vz.x) - (up.x * vz.z), + .z = (up.x * vz.y) - (up.y * vz.x), + }; + _ = &vx; + v = vx; + length = sqrtf(((v.x * v.x) + (v.y * v.y)) + (v.z * v.z)); + if (length == 0.0) { + length = 1.0; + } + ilength = 1.0 / length; + vx.x *= ilength; + vx.y *= ilength; + vx.z *= ilength; + var vy: Vector3 = Vector3{ + .x = (vz.y * vx.z) - (vz.z * vx.y), + .y = (vz.z * vx.x) - (vz.x * vx.z), + .z = (vz.x * vx.y) - (vz.y * vx.x), + }; + _ = &vy; + result.m0 = vx.x; + result.m1 = vy.x; + result.m2 = vz.x; + result.m3 = 0.0; + result.m4 = vx.y; + result.m5 = vy.y; + result.m6 = vz.y; + result.m7 = 0.0; + result.m8 = vx.z; + result.m9 = vy.z; + result.m10 = vz.z; + result.m11 = 0.0; + result.m12 = -(((vx.x * eye.x) + (vx.y * eye.y)) + (vx.z * eye.z)); + result.m13 = -(((vy.x * eye.x) + (vy.y * eye.y)) + (vy.z * eye.z)); + result.m14 = -(((vz.x * eye.x) + (vz.y * eye.y)) + (vz.z * eye.z)); + result.m15 = 1.0; + return result; +} +pub fn MatrixToFloatV(arg_mat: Matrix) callconv(.C) float16 { + var mat = arg_mat; + _ = &mat; + var result: float16 = float16{ + .v = [1]f32{ + 0, + } ++ [1]f32{0} ** 15, + }; + _ = &result; + result.v[@as(c_uint, @intCast(@as(c_int, 0)))] = mat.m0; + result.v[@as(c_uint, @intCast(@as(c_int, 1)))] = mat.m1; + result.v[@as(c_uint, @intCast(@as(c_int, 2)))] = mat.m2; + result.v[@as(c_uint, @intCast(@as(c_int, 3)))] = mat.m3; + result.v[@as(c_uint, @intCast(@as(c_int, 4)))] = mat.m4; + result.v[@as(c_uint, @intCast(@as(c_int, 5)))] = mat.m5; + result.v[@as(c_uint, @intCast(@as(c_int, 6)))] = mat.m6; + result.v[@as(c_uint, @intCast(@as(c_int, 7)))] = mat.m7; + result.v[@as(c_uint, @intCast(@as(c_int, 8)))] = mat.m8; + result.v[@as(c_uint, @intCast(@as(c_int, 9)))] = mat.m9; + result.v[@as(c_uint, @intCast(@as(c_int, 10)))] = mat.m10; + result.v[@as(c_uint, @intCast(@as(c_int, 11)))] = mat.m11; + result.v[@as(c_uint, @intCast(@as(c_int, 12)))] = mat.m12; + result.v[@as(c_uint, @intCast(@as(c_int, 13)))] = mat.m13; + result.v[@as(c_uint, @intCast(@as(c_int, 14)))] = mat.m14; + result.v[@as(c_uint, @intCast(@as(c_int, 15)))] = mat.m15; + return result; +} +pub fn QuaternionAdd(arg_q1: Quaternion, arg_q2: Quaternion) callconv(.C) Quaternion { + var q1 = arg_q1; + _ = &q1; + var q2 = arg_q2; + _ = &q2; + var result: Quaternion = Quaternion{ + .x = q1.x + q2.x, + .y = q1.y + q2.y, + .z = q1.z + q2.z, + .w = q1.w + q2.w, + }; + _ = &result; + return result; +} +pub fn QuaternionAddValue(arg_q: Quaternion, arg_add: f32) callconv(.C) Quaternion { + var q = arg_q; + _ = &q; + var add = arg_add; + _ = &add; + var result: Quaternion = Quaternion{ + .x = q.x + add, + .y = q.y + add, + .z = q.z + add, + .w = q.w + add, + }; + _ = &result; + return result; +} +pub fn QuaternionSubtract(arg_q1: Quaternion, arg_q2: Quaternion) callconv(.C) Quaternion { + var q1 = arg_q1; + _ = &q1; + var q2 = arg_q2; + _ = &q2; + var result: Quaternion = Quaternion{ + .x = q1.x - q2.x, + .y = q1.y - q2.y, + .z = q1.z - q2.z, + .w = q1.w - q2.w, + }; + _ = &result; + return result; +} +pub fn QuaternionSubtractValue(arg_q: Quaternion, arg_sub: f32) callconv(.C) Quaternion { + var q = arg_q; + _ = &q; + var sub = arg_sub; + _ = ⊂ + var result: Quaternion = Quaternion{ + .x = q.x - sub, + .y = q.y - sub, + .z = q.z - sub, + .w = q.w - sub, + }; + _ = &result; + return result; +} +pub fn QuaternionIdentity() callconv(.C) Quaternion { + var result: Quaternion = Quaternion{ + .x = 0.0, + .y = 0.0, + .z = 0.0, + .w = 1.0, + }; + _ = &result; + return result; +} +pub fn QuaternionLength(arg_q: Quaternion) callconv(.C) f32 { + var q = arg_q; + _ = &q; + var result: f32 = sqrtf((((q.x * q.x) + (q.y * q.y)) + (q.z * q.z)) + (q.w * q.w)); + _ = &result; + return result; +} +pub fn QuaternionNormalize(arg_q: Quaternion) callconv(.C) Quaternion { + var q = arg_q; + _ = &q; + var result: Quaternion = Quaternion{ + .x = @as(f32, @floatFromInt(@as(c_int, 0))), + .y = 0, + .z = 0, + .w = 0, + }; + _ = &result; + var length: f32 = sqrtf((((q.x * q.x) + (q.y * q.y)) + (q.z * q.z)) + (q.w * q.w)); + _ = &length; + if (length == 0.0) { + length = 1.0; + } + var ilength: f32 = 1.0 / length; + _ = &ilength; + result.x = q.x * ilength; + result.y = q.y * ilength; + result.z = q.z * ilength; + result.w = q.w * ilength; + return result; +} +pub fn QuaternionInvert(arg_q: Quaternion) callconv(.C) Quaternion { + var q = arg_q; + _ = &q; + var result: Quaternion = q; + _ = &result; + var lengthSq: f32 = (((q.x * q.x) + (q.y * q.y)) + (q.z * q.z)) + (q.w * q.w); + _ = &lengthSq; + if (lengthSq != 0.0) { + var invLength: f32 = 1.0 / lengthSq; + _ = &invLength; + result.x *= -invLength; + result.y *= -invLength; + result.z *= -invLength; + result.w *= invLength; + } + return result; +} +pub fn QuaternionMultiply(arg_q1: Quaternion, arg_q2: Quaternion) callconv(.C) Quaternion { + var q1 = arg_q1; + _ = &q1; + var q2 = arg_q2; + _ = &q2; + var result: Quaternion = Quaternion{ + .x = @as(f32, @floatFromInt(@as(c_int, 0))), + .y = 0, + .z = 0, + .w = 0, + }; + _ = &result; + var qax: f32 = q1.x; + _ = &qax; + var qay: f32 = q1.y; + _ = &qay; + var qaz: f32 = q1.z; + _ = &qaz; + var qaw: f32 = q1.w; + _ = &qaw; + var qbx: f32 = q2.x; + _ = &qbx; + var qby: f32 = q2.y; + _ = &qby; + var qbz: f32 = q2.z; + _ = &qbz; + var qbw: f32 = q2.w; + _ = &qbw; + result.x = (((qax * qbw) + (qaw * qbx)) + (qay * qbz)) - (qaz * qby); + result.y = (((qay * qbw) + (qaw * qby)) + (qaz * qbx)) - (qax * qbz); + result.z = (((qaz * qbw) + (qaw * qbz)) + (qax * qby)) - (qay * qbx); + result.w = (((qaw * qbw) - (qax * qbx)) - (qay * qby)) - (qaz * qbz); + return result; +} +pub fn QuaternionScale(arg_q: Quaternion, arg_mul: f32) callconv(.C) Quaternion { + var q = arg_q; + _ = &q; + var mul = arg_mul; + _ = &mul; + var result: Quaternion = Quaternion{ + .x = @as(f32, @floatFromInt(@as(c_int, 0))), + .y = 0, + .z = 0, + .w = 0, + }; + _ = &result; + result.x = q.x * mul; + result.y = q.y * mul; + result.z = q.z * mul; + result.w = q.w * mul; + return result; +} +pub fn QuaternionDivide(arg_q1: Quaternion, arg_q2: Quaternion) callconv(.C) Quaternion { + var q1 = arg_q1; + _ = &q1; + var q2 = arg_q2; + _ = &q2; + var result: Quaternion = Quaternion{ + .x = q1.x / q2.x, + .y = q1.y / q2.y, + .z = q1.z / q2.z, + .w = q1.w / q2.w, + }; + _ = &result; + return result; +} +pub fn QuaternionLerp(arg_q1: Quaternion, arg_q2: Quaternion, arg_amount: f32) callconv(.C) Quaternion { + var q1 = arg_q1; + _ = &q1; + var q2 = arg_q2; + _ = &q2; + var amount = arg_amount; + _ = &amount; + var result: Quaternion = Quaternion{ + .x = @as(f32, @floatFromInt(@as(c_int, 0))), + .y = 0, + .z = 0, + .w = 0, + }; + _ = &result; + result.x = q1.x + (amount * (q2.x - q1.x)); + result.y = q1.y + (amount * (q2.y - q1.y)); + result.z = q1.z + (amount * (q2.z - q1.z)); + result.w = q1.w + (amount * (q2.w - q1.w)); + return result; +} +pub fn QuaternionNlerp(arg_q1: Quaternion, arg_q2: Quaternion, arg_amount: f32) callconv(.C) Quaternion { + var q1 = arg_q1; + _ = &q1; + var q2 = arg_q2; + _ = &q2; + var amount = arg_amount; + _ = &amount; + var result: Quaternion = Quaternion{ + .x = @as(f32, @floatFromInt(@as(c_int, 0))), + .y = 0, + .z = 0, + .w = 0, + }; + _ = &result; + result.x = q1.x + (amount * (q2.x - q1.x)); + result.y = q1.y + (amount * (q2.y - q1.y)); + result.z = q1.z + (amount * (q2.z - q1.z)); + result.w = q1.w + (amount * (q2.w - q1.w)); + var q: Quaternion = result; + _ = &q; + var length: f32 = sqrtf((((q.x * q.x) + (q.y * q.y)) + (q.z * q.z)) + (q.w * q.w)); + _ = &length; + if (length == 0.0) { + length = 1.0; + } + var ilength: f32 = 1.0 / length; + _ = &ilength; + result.x = q.x * ilength; + result.y = q.y * ilength; + result.z = q.z * ilength; + result.w = q.w * ilength; + return result; +} +pub fn QuaternionSlerp(arg_q1: Quaternion, arg_q2: Quaternion, arg_amount: f32) callconv(.C) Quaternion { + var q1 = arg_q1; + _ = &q1; + var q2 = arg_q2; + _ = &q2; + var amount = arg_amount; + _ = &amount; + var result: Quaternion = Quaternion{ + .x = @as(f32, @floatFromInt(@as(c_int, 0))), + .y = 0, + .z = 0, + .w = 0, + }; + _ = &result; + var cosHalfTheta: f32 = (((q1.x * q2.x) + (q1.y * q2.y)) + (q1.z * q2.z)) + (q1.w * q2.w); + _ = &cosHalfTheta; + if (cosHalfTheta < @as(f32, @floatFromInt(@as(c_int, 0)))) { + q2.x = -q2.x; + q2.y = -q2.y; + q2.z = -q2.z; + q2.w = -q2.w; + cosHalfTheta = -cosHalfTheta; + } + if (fabsf(cosHalfTheta) >= 1.0) { + result = q1; + } else if (cosHalfTheta > 0.949999988079071) { + result = QuaternionNlerp(q1, q2, amount); + } else { + var halfTheta: f32 = acosf(cosHalfTheta); + _ = &halfTheta; + var sinHalfTheta: f32 = sqrtf(1.0 - (cosHalfTheta * cosHalfTheta)); + _ = &sinHalfTheta; + if (fabsf(sinHalfTheta) < 0.0000009999999974752427) { + result.x = (q1.x * 0.5) + (q2.x * 0.5); + result.y = (q1.y * 0.5) + (q2.y * 0.5); + result.z = (q1.z * 0.5) + (q2.z * 0.5); + result.w = (q1.w * 0.5) + (q2.w * 0.5); + } else { + var ratioA: f32 = sinf((@as(f32, @floatFromInt(@as(c_int, 1))) - amount) * halfTheta) / sinHalfTheta; + _ = &ratioA; + var ratioB: f32 = sinf(amount * halfTheta) / sinHalfTheta; + _ = &ratioB; + result.x = (q1.x * ratioA) + (q2.x * ratioB); + result.y = (q1.y * ratioA) + (q2.y * ratioB); + result.z = (q1.z * ratioA) + (q2.z * ratioB); + result.w = (q1.w * ratioA) + (q2.w * ratioB); + } + } + return result; +} +pub fn QuaternionCubicHermiteSpline(arg_q1: Quaternion, arg_outTangent1: Quaternion, arg_q2: Quaternion, arg_inTangent2: Quaternion, arg_t: f32) callconv(.C) Quaternion { + var q1 = arg_q1; + _ = &q1; + var outTangent1 = arg_outTangent1; + _ = &outTangent1; + var q2 = arg_q2; + _ = &q2; + var inTangent2 = arg_inTangent2; + _ = &inTangent2; + var t = arg_t; + _ = &t; + var t2: f32 = t * t; + _ = &t2; + var t3: f32 = t2 * t; + _ = &t3; + var h00: f32 = ((@as(f32, @floatFromInt(@as(c_int, 2))) * t3) - (@as(f32, @floatFromInt(@as(c_int, 3))) * t2)) + @as(f32, @floatFromInt(@as(c_int, 1))); + _ = &h00; + var h10: f32 = (t3 - (@as(f32, @floatFromInt(@as(c_int, 2))) * t2)) + t; + _ = &h10; + var h01: f32 = (@as(f32, @floatFromInt(-@as(c_int, 2))) * t3) + (@as(f32, @floatFromInt(@as(c_int, 3))) * t2); + _ = &h01; + var h11: f32 = t3 - t2; + _ = &h11; + var p0: Quaternion = QuaternionScale(q1, h00); + _ = &p0; + var m0: Quaternion = QuaternionScale(outTangent1, h10); + _ = &m0; + var p1: Quaternion = QuaternionScale(q2, h01); + _ = &p1; + var m1: Quaternion = QuaternionScale(inTangent2, h11); + _ = &m1; + var result: Quaternion = Quaternion{ + .x = @as(f32, @floatFromInt(@as(c_int, 0))), + .y = 0, + .z = 0, + .w = 0, + }; + _ = &result; + result = QuaternionAdd(p0, m0); + result = QuaternionAdd(result, p1); + result = QuaternionAdd(result, m1); + result = QuaternionNormalize(result); + return result; +} +pub fn QuaternionFromVector3ToVector3(arg_from: Vector3, arg_to: Vector3) callconv(.C) Quaternion { + var from = arg_from; + _ = &from; + var to = arg_to; + _ = &to; + var result: Quaternion = Quaternion{ + .x = @as(f32, @floatFromInt(@as(c_int, 0))), + .y = 0, + .z = 0, + .w = 0, + }; + _ = &result; + var cos2Theta: f32 = ((from.x * to.x) + (from.y * to.y)) + (from.z * to.z); + _ = &cos2Theta; + var cross: Vector3 = Vector3{ + .x = (from.y * to.z) - (from.z * to.y), + .y = (from.z * to.x) - (from.x * to.z), + .z = (from.x * to.y) - (from.y * to.x), + }; + _ = ✗ + result.x = cross.x; + result.y = cross.y; + result.z = cross.z; + result.w = 1.0 + cos2Theta; + var q: Quaternion = result; + _ = &q; + var length: f32 = sqrtf((((q.x * q.x) + (q.y * q.y)) + (q.z * q.z)) + (q.w * q.w)); + _ = &length; + if (length == 0.0) { + length = 1.0; + } + var ilength: f32 = 1.0 / length; + _ = &ilength; + result.x = q.x * ilength; + result.y = q.y * ilength; + result.z = q.z * ilength; + result.w = q.w * ilength; + return result; +} +pub fn QuaternionFromMatrix(arg_mat: Matrix) callconv(.C) Quaternion { + var mat = arg_mat; + _ = &mat; + var result: Quaternion = Quaternion{ + .x = @as(f32, @floatFromInt(@as(c_int, 0))), + .y = 0, + .z = 0, + .w = 0, + }; + _ = &result; + var fourWSquaredMinus1: f32 = (mat.m0 + mat.m5) + mat.m10; + _ = &fourWSquaredMinus1; + var fourXSquaredMinus1: f32 = (mat.m0 - mat.m5) - mat.m10; + _ = &fourXSquaredMinus1; + var fourYSquaredMinus1: f32 = (mat.m5 - mat.m0) - mat.m10; + _ = &fourYSquaredMinus1; + var fourZSquaredMinus1: f32 = (mat.m10 - mat.m0) - mat.m5; + _ = &fourZSquaredMinus1; + var biggestIndex: c_int = 0; + _ = &biggestIndex; + var fourBiggestSquaredMinus1: f32 = fourWSquaredMinus1; + _ = &fourBiggestSquaredMinus1; + if (fourXSquaredMinus1 > fourBiggestSquaredMinus1) { + fourBiggestSquaredMinus1 = fourXSquaredMinus1; + biggestIndex = 1; + } + if (fourYSquaredMinus1 > fourBiggestSquaredMinus1) { + fourBiggestSquaredMinus1 = fourYSquaredMinus1; + biggestIndex = 2; + } + if (fourZSquaredMinus1 > fourBiggestSquaredMinus1) { + fourBiggestSquaredMinus1 = fourZSquaredMinus1; + biggestIndex = 3; + } + var biggestVal: f32 = sqrtf(fourBiggestSquaredMinus1 + 1.0) * 0.5; + _ = &biggestVal; + var mult: f32 = 0.25 / biggestVal; + _ = &mult; + while (true) { + switch (biggestIndex) { + @as(c_int, 0) => { + result.w = biggestVal; + result.x = (mat.m6 - mat.m9) * mult; + result.y = (mat.m8 - mat.m2) * mult; + result.z = (mat.m1 - mat.m4) * mult; + break; + }, + @as(c_int, 1) => { + result.x = biggestVal; + result.w = (mat.m6 - mat.m9) * mult; + result.y = (mat.m1 + mat.m4) * mult; + result.z = (mat.m8 + mat.m2) * mult; + break; + }, + @as(c_int, 2) => { + result.y = biggestVal; + result.w = (mat.m8 - mat.m2) * mult; + result.x = (mat.m1 + mat.m4) * mult; + result.z = (mat.m6 + mat.m9) * mult; + break; + }, + @as(c_int, 3) => { + result.z = biggestVal; + result.w = (mat.m1 - mat.m4) * mult; + result.x = (mat.m8 + mat.m2) * mult; + result.y = (mat.m6 + mat.m9) * mult; + break; + }, + else => {}, + } + break; + } + return result; +} +pub fn QuaternionToMatrix(arg_q: Quaternion) callconv(.C) Matrix { + var q = arg_q; + _ = &q; + var result: Matrix = Matrix{ + .m0 = 1.0, + .m4 = 0.0, + .m8 = 0.0, + .m12 = 0.0, + .m1 = 0.0, + .m5 = 1.0, + .m9 = 0.0, + .m13 = 0.0, + .m2 = 0.0, + .m6 = 0.0, + .m10 = 1.0, + .m14 = 0.0, + .m3 = 0.0, + .m7 = 0.0, + .m11 = 0.0, + .m15 = 1.0, + }; + _ = &result; + var a2: f32 = q.x * q.x; + _ = &a2; + var b2: f32 = q.y * q.y; + _ = &b2; + var c2: f32 = q.z * q.z; + _ = &c2; + var ac: f32 = q.x * q.z; + _ = ∾ + var ab: f32 = q.x * q.y; + _ = &ab; + var bc: f32 = q.y * q.z; + _ = &bc; + var ad: f32 = q.w * q.x; + _ = &ad; + var bd: f32 = q.w * q.y; + _ = &bd; + var cd: f32 = q.w * q.z; + _ = &cd; + result.m0 = @as(f32, @floatFromInt(@as(c_int, 1))) - (@as(f32, @floatFromInt(@as(c_int, 2))) * (b2 + c2)); + result.m1 = @as(f32, @floatFromInt(@as(c_int, 2))) * (ab + cd); + result.m2 = @as(f32, @floatFromInt(@as(c_int, 2))) * (ac - bd); + result.m4 = @as(f32, @floatFromInt(@as(c_int, 2))) * (ab - cd); + result.m5 = @as(f32, @floatFromInt(@as(c_int, 1))) - (@as(f32, @floatFromInt(@as(c_int, 2))) * (a2 + c2)); + result.m6 = @as(f32, @floatFromInt(@as(c_int, 2))) * (bc + ad); + result.m8 = @as(f32, @floatFromInt(@as(c_int, 2))) * (ac + bd); + result.m9 = @as(f32, @floatFromInt(@as(c_int, 2))) * (bc - ad); + result.m10 = @as(f32, @floatFromInt(@as(c_int, 1))) - (@as(f32, @floatFromInt(@as(c_int, 2))) * (a2 + b2)); + return result; +} +pub fn QuaternionFromAxisAngle(arg_axis: Vector3, arg_angle: f32) callconv(.C) Quaternion { + var axis = arg_axis; + _ = &axis; + var angle = arg_angle; + _ = ∠ + var result: Quaternion = Quaternion{ + .x = 0.0, + .y = 0.0, + .z = 0.0, + .w = 1.0, + }; + _ = &result; + var axisLength: f32 = sqrtf(((axis.x * axis.x) + (axis.y * axis.y)) + (axis.z * axis.z)); + _ = &axisLength; + if (axisLength != 0.0) { + angle *= 0.5; + var length: f32 = 0.0; + _ = &length; + var ilength: f32 = 0.0; + _ = &ilength; + length = axisLength; + if (length == 0.0) { + length = 1.0; + } + ilength = 1.0 / length; + axis.x *= ilength; + axis.y *= ilength; + axis.z *= ilength; + var sinres: f32 = sinf(angle); + _ = &sinres; + var cosres: f32 = cosf(angle); + _ = &cosres; + result.x = axis.x * sinres; + result.y = axis.y * sinres; + result.z = axis.z * sinres; + result.w = cosres; + var q: Quaternion = result; + _ = &q; + length = sqrtf((((q.x * q.x) + (q.y * q.y)) + (q.z * q.z)) + (q.w * q.w)); + if (length == 0.0) { + length = 1.0; + } + ilength = 1.0 / length; + result.x = q.x * ilength; + result.y = q.y * ilength; + result.z = q.z * ilength; + result.w = q.w * ilength; + } + return result; +} +pub fn QuaternionToAxisAngle(arg_q: Quaternion, arg_outAxis: [*c]Vector3, arg_outAngle: [*c]f32) callconv(.C) void { + var q = arg_q; + _ = &q; + var outAxis = arg_outAxis; + _ = &outAxis; + var outAngle = arg_outAngle; + _ = &outAngle; + if (fabsf(q.w) > 1.0) { + var length: f32 = sqrtf((((q.x * q.x) + (q.y * q.y)) + (q.z * q.z)) + (q.w * q.w)); + _ = &length; + if (length == 0.0) { + length = 1.0; + } + var ilength: f32 = 1.0 / length; + _ = &ilength; + q.x = q.x * ilength; + q.y = q.y * ilength; + q.z = q.z * ilength; + q.w = q.w * ilength; + } + var resAxis: Vector3 = Vector3{ + .x = 0.0, + .y = 0.0, + .z = 0.0, + }; + _ = &resAxis; + var resAngle: f32 = 2.0 * acosf(q.w); + _ = &resAngle; + var den: f32 = sqrtf(1.0 - (q.w * q.w)); + _ = &den; + if (den > 0.0000009999999974752427) { + resAxis.x = q.x / den; + resAxis.y = q.y / den; + resAxis.z = q.z / den; + } else { + resAxis.x = 1.0; + } + outAxis.* = resAxis; + outAngle.* = resAngle; +} +pub fn QuaternionFromEuler(arg_pitch: f32, arg_yaw: f32, arg_roll: f32) callconv(.C) Quaternion { + var pitch = arg_pitch; + _ = &pitch; + var yaw = arg_yaw; + _ = &yaw; + var roll = arg_roll; + _ = &roll; + var result: Quaternion = Quaternion{ + .x = @as(f32, @floatFromInt(@as(c_int, 0))), + .y = 0, + .z = 0, + .w = 0, + }; + _ = &result; + var x0: f32 = cosf(pitch * 0.5); + _ = &x0; + var x1: f32 = sinf(pitch * 0.5); + _ = &x1; + var y0_1: f32 = cosf(yaw * 0.5); + _ = &y0_1; + var y1_2: f32 = sinf(yaw * 0.5); + _ = &y1_2; + var z0: f32 = cosf(roll * 0.5); + _ = &z0; + var z1: f32 = sinf(roll * 0.5); + _ = &z1; + result.x = ((x1 * y0_1) * z0) - ((x0 * y1_2) * z1); + result.y = ((x0 * y1_2) * z0) + ((x1 * y0_1) * z1); + result.z = ((x0 * y0_1) * z1) - ((x1 * y1_2) * z0); + result.w = ((x0 * y0_1) * z0) + ((x1 * y1_2) * z1); + return result; +} +pub fn QuaternionToEuler(arg_q: Quaternion) callconv(.C) Vector3 { + var q = arg_q; + _ = &q; + var result: Vector3 = Vector3{ + .x = @as(f32, @floatFromInt(@as(c_int, 0))), + .y = 0, + .z = 0, + }; + _ = &result; + var x0: f32 = 2.0 * ((q.w * q.x) + (q.y * q.z)); + _ = &x0; + var x1: f32 = 1.0 - (2.0 * ((q.x * q.x) + (q.y * q.y))); + _ = &x1; + result.x = atan2f(x0, x1); + var y0_1: f32 = 2.0 * ((q.w * q.y) - (q.z * q.x)); + _ = &y0_1; + y0_1 = if (y0_1 > 1.0) 1.0 else y0_1; + y0_1 = if (y0_1 < -1.0) -1.0 else y0_1; + result.y = asinf(y0_1); + var z0: f32 = 2.0 * ((q.w * q.z) + (q.x * q.y)); + _ = &z0; + var z1: f32 = 1.0 - (2.0 * ((q.y * q.y) + (q.z * q.z))); + _ = &z1; + result.z = atan2f(z0, z1); + return result; +} +pub fn QuaternionTransform(arg_q: Quaternion, arg_mat: Matrix) callconv(.C) Quaternion { + var q = arg_q; + _ = &q; + var mat = arg_mat; + _ = &mat; + var result: Quaternion = Quaternion{ + .x = @as(f32, @floatFromInt(@as(c_int, 0))), + .y = 0, + .z = 0, + .w = 0, + }; + _ = &result; + result.x = (((mat.m0 * q.x) + (mat.m4 * q.y)) + (mat.m8 * q.z)) + (mat.m12 * q.w); + result.y = (((mat.m1 * q.x) + (mat.m5 * q.y)) + (mat.m9 * q.z)) + (mat.m13 * q.w); + result.z = (((mat.m2 * q.x) + (mat.m6 * q.y)) + (mat.m10 * q.z)) + (mat.m14 * q.w); + result.w = (((mat.m3 * q.x) + (mat.m7 * q.y)) + (mat.m11 * q.z)) + (mat.m15 * q.w); + return result; +} +pub fn QuaternionEquals(arg_p: Quaternion, arg_q: Quaternion) callconv(.C) c_int { + var p = arg_p; + _ = &p; + var q = arg_q; + _ = &q; + var result: c_int = @intFromBool(((((fabsf(p.x - q.x) <= (0.0000009999999974752427 * fmaxf(1.0, fmaxf(fabsf(p.x), fabsf(q.x))))) and (fabsf(p.y - q.y) <= (0.0000009999999974752427 * fmaxf(1.0, fmaxf(fabsf(p.y), fabsf(q.y)))))) and (fabsf(p.z - q.z) <= (0.0000009999999974752427 * fmaxf(1.0, fmaxf(fabsf(p.z), fabsf(q.z)))))) and (fabsf(p.w - q.w) <= (0.0000009999999974752427 * fmaxf(1.0, fmaxf(fabsf(p.w), fabsf(q.w)))))) or ((((fabsf(p.x + q.x) <= (0.0000009999999974752427 * fmaxf(1.0, fmaxf(fabsf(p.x), fabsf(q.x))))) and (fabsf(p.y + q.y) <= (0.0000009999999974752427 * fmaxf(1.0, fmaxf(fabsf(p.y), fabsf(q.y)))))) and (fabsf(p.z + q.z) <= (0.0000009999999974752427 * fmaxf(1.0, fmaxf(fabsf(p.z), fabsf(q.z)))))) and (fabsf(p.w + q.w) <= (0.0000009999999974752427 * fmaxf(1.0, fmaxf(fabsf(p.w), fabsf(q.w))))))); + _ = &result; + return result; +} +pub fn MatrixDecompose(arg_mat: Matrix, arg_translation: [*c]Vector3, arg_rotation: [*c]Quaternion, arg_scale: [*c]Vector3) callconv(.C) void { + var mat = arg_mat; + _ = &mat; + var translation = arg_translation; + _ = &translation; + var rotation = arg_rotation; + _ = &rotation; + var scale = arg_scale; + _ = &scale; + translation.*.x = mat.m12; + translation.*.y = mat.m13; + translation.*.z = mat.m14; + const a: f32 = mat.m0; + _ = &a; + const b: f32 = mat.m4; + _ = &b; + const c: f32 = mat.m8; + _ = &c; + const d: f32 = mat.m1; + _ = &d; + const e: f32 = mat.m5; + _ = &e; + const f: f32 = mat.m9; + _ = &f; + const g: f32 = mat.m2; + _ = &g; + const h: f32 = mat.m6; + _ = &h; + const i: f32 = mat.m10; + _ = &i; + const A: f32 = (e * i) - (f * h); + _ = &A; + const B: f32 = (f * g) - (d * i); + _ = &B; + const C: f32 = (d * h) - (e * g); + _ = &C; + const det: f32 = ((a * A) + (b * B)) + (c * C); + _ = &det; + var abc: Vector3 = Vector3{ + .x = a, + .y = b, + .z = c, + }; + _ = &abc; + var def: Vector3 = Vector3{ + .x = d, + .y = e, + .z = f, + }; + _ = &def; + var ghi: Vector3 = Vector3{ + .x = g, + .y = h, + .z = i, + }; + _ = &ghi; + var scalex: f32 = Vector3Length(abc); + _ = &scalex; + var scaley: f32 = Vector3Length(def); + _ = &scaley; + var scalez: f32 = Vector3Length(ghi); + _ = &scalez; + var s: Vector3 = Vector3{ + .x = scalex, + .y = scaley, + .z = scalez, + }; + _ = &s; + if (det < @as(f32, @floatFromInt(@as(c_int, 0)))) { + s = Vector3Negate(s); + } + scale.* = s; + var clone: Matrix = mat; + _ = &clone; + if (!(FloatEquals(det, @as(f32, @floatFromInt(@as(c_int, 0)))) != 0)) { + clone.m0 /= s.x; + clone.m5 /= s.y; + clone.m10 /= s.z; + rotation.* = QuaternionFromMatrix(clone); + } else { + rotation.* = QuaternionIdentity(); + } +} +const union_unnamed_3 = extern union { + __wch: c_uint, + __wchb: [4]u8, +}; +pub const __mbstate_t = extern struct { + __count: c_int = @import("std").mem.zeroes(c_int), + __value: union_unnamed_3 = @import("std").mem.zeroes(union_unnamed_3), +}; +pub const struct__G_fpos_t = extern struct { + __pos: __off_t = @import("std").mem.zeroes(__off_t), + __state: __mbstate_t = @import("std").mem.zeroes(__mbstate_t), +}; +pub const __fpos_t = struct__G_fpos_t; +pub const struct__G_fpos64_t = extern struct { + __pos: __off64_t = @import("std").mem.zeroes(__off64_t), + __state: __mbstate_t = @import("std").mem.zeroes(__mbstate_t), +}; +pub const __fpos64_t = struct__G_fpos64_t; +pub const struct__IO_marker = opaque {}; +pub const _IO_lock_t = anyopaque; +pub const struct__IO_codecvt = opaque {}; +pub const struct__IO_wide_data = opaque {}; +pub const struct__IO_FILE = extern struct { + _flags: c_int = @import("std").mem.zeroes(c_int), + _IO_read_ptr: [*c]u8 = @import("std").mem.zeroes([*c]u8), + _IO_read_end: [*c]u8 = @import("std").mem.zeroes([*c]u8), + _IO_read_base: [*c]u8 = @import("std").mem.zeroes([*c]u8), + _IO_write_base: [*c]u8 = @import("std").mem.zeroes([*c]u8), + _IO_write_ptr: [*c]u8 = @import("std").mem.zeroes([*c]u8), + _IO_write_end: [*c]u8 = @import("std").mem.zeroes([*c]u8), + _IO_buf_base: [*c]u8 = @import("std").mem.zeroes([*c]u8), + _IO_buf_end: [*c]u8 = @import("std").mem.zeroes([*c]u8), + _IO_save_base: [*c]u8 = @import("std").mem.zeroes([*c]u8), + _IO_backup_base: [*c]u8 = @import("std").mem.zeroes([*c]u8), + _IO_save_end: [*c]u8 = @import("std").mem.zeroes([*c]u8), + _markers: ?*struct__IO_marker = @import("std").mem.zeroes(?*struct__IO_marker), + _chain: [*c]struct__IO_FILE = @import("std").mem.zeroes([*c]struct__IO_FILE), + _fileno: c_int = @import("std").mem.zeroes(c_int), + _flags2: c_int = @import("std").mem.zeroes(c_int), + _old_offset: __off_t = @import("std").mem.zeroes(__off_t), + _cur_column: c_ushort = @import("std").mem.zeroes(c_ushort), + _vtable_offset: i8 = @import("std").mem.zeroes(i8), + _shortbuf: [1]u8 = @import("std").mem.zeroes([1]u8), + _lock: ?*_IO_lock_t = @import("std").mem.zeroes(?*_IO_lock_t), + _offset: __off64_t = @import("std").mem.zeroes(__off64_t), + _codecvt: ?*struct__IO_codecvt = @import("std").mem.zeroes(?*struct__IO_codecvt), + _wide_data: ?*struct__IO_wide_data = @import("std").mem.zeroes(?*struct__IO_wide_data), + _freeres_list: [*c]struct__IO_FILE = @import("std").mem.zeroes([*c]struct__IO_FILE), + _freeres_buf: ?*anyopaque = @import("std").mem.zeroes(?*anyopaque), + _prevchain: [*c][*c]struct__IO_FILE = @import("std").mem.zeroes([*c][*c]struct__IO_FILE), + _mode: c_int = @import("std").mem.zeroes(c_int), + _unused2: [20]u8 = @import("std").mem.zeroes([20]u8), +}; +pub const __FILE = struct__IO_FILE; +pub const FILE = struct__IO_FILE; +pub const cookie_read_function_t = fn (?*anyopaque, [*c]u8, usize) callconv(.C) __ssize_t; +pub const cookie_write_function_t = fn (?*anyopaque, [*c]const u8, usize) callconv(.C) __ssize_t; +pub const cookie_seek_function_t = fn (?*anyopaque, [*c]__off64_t, c_int) callconv(.C) c_int; +pub const cookie_close_function_t = fn (?*anyopaque) callconv(.C) c_int; +pub const struct__IO_cookie_io_functions_t = extern struct { + read: ?*const cookie_read_function_t = @import("std").mem.zeroes(?*const cookie_read_function_t), + write: ?*const cookie_write_function_t = @import("std").mem.zeroes(?*const cookie_write_function_t), + seek: ?*const cookie_seek_function_t = @import("std").mem.zeroes(?*const cookie_seek_function_t), + close: ?*const cookie_close_function_t = @import("std").mem.zeroes(?*const cookie_close_function_t), +}; +pub const cookie_io_functions_t = struct__IO_cookie_io_functions_t; +pub const off_t = __off_t; +pub const fpos_t = __fpos_t; +pub extern var stdin: [*c]FILE; +pub extern var stdout: [*c]FILE; +pub extern var stderr: [*c]FILE; +pub extern fn remove(__filename: [*c]const u8) c_int; +pub extern fn rename(__old: [*c]const u8, __new: [*c]const u8) c_int; +pub extern fn renameat(__oldfd: c_int, __old: [*c]const u8, __newfd: c_int, __new: [*c]const u8) c_int; +pub extern fn fclose(__stream: [*c]FILE) c_int; +pub extern fn tmpfile() [*c]FILE; +pub extern fn tmpnam([*c]u8) [*c]u8; +pub extern fn tmpnam_r(__s: [*c]u8) [*c]u8; +pub extern fn tempnam(__dir: [*c]const u8, __pfx: [*c]const u8) [*c]u8; +pub extern fn fflush(__stream: [*c]FILE) c_int; +pub extern fn fflush_unlocked(__stream: [*c]FILE) c_int; +pub extern fn fopen(__filename: [*c]const u8, __modes: [*c]const u8) [*c]FILE; +pub extern fn freopen(noalias __filename: [*c]const u8, noalias __modes: [*c]const u8, noalias __stream: [*c]FILE) [*c]FILE; +pub extern fn fdopen(__fd: c_int, __modes: [*c]const u8) [*c]FILE; +pub extern fn fopencookie(noalias __magic_cookie: ?*anyopaque, noalias __modes: [*c]const u8, __io_funcs: cookie_io_functions_t) [*c]FILE; +pub extern fn fmemopen(__s: ?*anyopaque, __len: usize, __modes: [*c]const u8) [*c]FILE; +pub extern fn open_memstream(__bufloc: [*c][*c]u8, __sizeloc: [*c]usize) [*c]FILE; +pub extern fn setbuf(noalias __stream: [*c]FILE, noalias __buf: [*c]u8) void; +pub extern fn setvbuf(noalias __stream: [*c]FILE, noalias __buf: [*c]u8, __modes: c_int, __n: usize) c_int; +pub extern fn setbuffer(noalias __stream: [*c]FILE, noalias __buf: [*c]u8, __size: usize) void; +pub extern fn setlinebuf(__stream: [*c]FILE) void; +pub extern fn fprintf(__stream: [*c]FILE, __format: [*c]const u8, ...) c_int; +pub extern fn printf(__format: [*c]const u8, ...) c_int; +pub extern fn sprintf(__s: [*c]u8, __format: [*c]const u8, ...) c_int; +pub extern fn vfprintf(__s: [*c]FILE, __format: [*c]const u8, __arg: [*c]struct___va_list_tag_1) c_int; +pub extern fn vprintf(__format: [*c]const u8, __arg: [*c]struct___va_list_tag_1) c_int; +pub extern fn vsprintf(__s: [*c]u8, __format: [*c]const u8, __arg: [*c]struct___va_list_tag_1) c_int; +pub extern fn snprintf(__s: [*c]u8, __maxlen: c_ulong, __format: [*c]const u8, ...) c_int; +pub extern fn vsnprintf(__s: [*c]u8, __maxlen: c_ulong, __format: [*c]const u8, __arg: [*c]struct___va_list_tag_1) c_int; +pub extern fn vasprintf(noalias __ptr: [*c][*c]u8, noalias __f: [*c]const u8, __arg: [*c]struct___va_list_tag_1) c_int; +pub extern fn __asprintf(noalias __ptr: [*c][*c]u8, noalias __fmt: [*c]const u8, ...) c_int; +pub extern fn asprintf(noalias __ptr: [*c][*c]u8, noalias __fmt: [*c]const u8, ...) c_int; +pub extern fn vdprintf(__fd: c_int, noalias __fmt: [*c]const u8, __arg: [*c]struct___va_list_tag_1) c_int; +pub extern fn dprintf(__fd: c_int, noalias __fmt: [*c]const u8, ...) c_int; +pub extern fn fscanf(noalias __stream: [*c]FILE, noalias __format: [*c]const u8, ...) c_int; +pub extern fn scanf(noalias __format: [*c]const u8, ...) c_int; +pub extern fn sscanf(noalias __s: [*c]const u8, noalias __format: [*c]const u8, ...) c_int; +pub extern fn vfscanf(noalias __s: [*c]FILE, noalias __format: [*c]const u8, __arg: [*c]struct___va_list_tag_1) c_int; +pub extern fn vscanf(noalias __format: [*c]const u8, __arg: [*c]struct___va_list_tag_1) c_int; +pub extern fn vsscanf(noalias __s: [*c]const u8, noalias __format: [*c]const u8, __arg: [*c]struct___va_list_tag_1) c_int; +pub extern fn fgetc(__stream: [*c]FILE) c_int; +pub extern fn getc(__stream: [*c]FILE) c_int; +pub extern fn getchar() c_int; +pub extern fn getc_unlocked(__stream: [*c]FILE) c_int; +pub extern fn getchar_unlocked() c_int; +pub extern fn fgetc_unlocked(__stream: [*c]FILE) c_int; +pub extern fn fputc(__c: c_int, __stream: [*c]FILE) c_int; +pub extern fn putc(__c: c_int, __stream: [*c]FILE) c_int; +pub extern fn putchar(__c: c_int) c_int; +pub extern fn fputc_unlocked(__c: c_int, __stream: [*c]FILE) c_int; +pub extern fn putc_unlocked(__c: c_int, __stream: [*c]FILE) c_int; +pub extern fn putchar_unlocked(__c: c_int) c_int; +pub extern fn getw(__stream: [*c]FILE) c_int; +pub extern fn putw(__w: c_int, __stream: [*c]FILE) c_int; +pub extern fn fgets(noalias __s: [*c]u8, __n: c_int, noalias __stream: [*c]FILE) [*c]u8; +pub extern fn __getdelim(noalias __lineptr: [*c][*c]u8, noalias __n: [*c]usize, __delimiter: c_int, noalias __stream: [*c]FILE) __ssize_t; +pub extern fn getdelim(noalias __lineptr: [*c][*c]u8, noalias __n: [*c]usize, __delimiter: c_int, noalias __stream: [*c]FILE) __ssize_t; +pub extern fn getline(noalias __lineptr: [*c][*c]u8, noalias __n: [*c]usize, noalias __stream: [*c]FILE) __ssize_t; +pub extern fn fputs(noalias __s: [*c]const u8, noalias __stream: [*c]FILE) c_int; +pub extern fn puts(__s: [*c]const u8) c_int; +pub extern fn ungetc(__c: c_int, __stream: [*c]FILE) c_int; +pub extern fn fread(__ptr: ?*anyopaque, __size: c_ulong, __n: c_ulong, __stream: [*c]FILE) c_ulong; +pub extern fn fwrite(__ptr: ?*const anyopaque, __size: c_ulong, __n: c_ulong, __s: [*c]FILE) c_ulong; +pub extern fn fread_unlocked(noalias __ptr: ?*anyopaque, __size: usize, __n: usize, noalias __stream: [*c]FILE) usize; +pub extern fn fwrite_unlocked(noalias __ptr: ?*const anyopaque, __size: usize, __n: usize, noalias __stream: [*c]FILE) usize; +pub extern fn fseek(__stream: [*c]FILE, __off: c_long, __whence: c_int) c_int; +pub extern fn ftell(__stream: [*c]FILE) c_long; +pub extern fn rewind(__stream: [*c]FILE) void; +pub extern fn fseeko(__stream: [*c]FILE, __off: __off_t, __whence: c_int) c_int; +pub extern fn ftello(__stream: [*c]FILE) __off_t; +pub extern fn fgetpos(noalias __stream: [*c]FILE, noalias __pos: [*c]fpos_t) c_int; +pub extern fn fsetpos(__stream: [*c]FILE, __pos: [*c]const fpos_t) c_int; +pub extern fn clearerr(__stream: [*c]FILE) void; +pub extern fn feof(__stream: [*c]FILE) c_int; +pub extern fn ferror(__stream: [*c]FILE) c_int; +pub extern fn clearerr_unlocked(__stream: [*c]FILE) void; +pub extern fn feof_unlocked(__stream: [*c]FILE) c_int; +pub extern fn ferror_unlocked(__stream: [*c]FILE) c_int; +pub extern fn perror(__s: [*c]const u8) void; +pub extern fn fileno(__stream: [*c]FILE) c_int; +pub extern fn fileno_unlocked(__stream: [*c]FILE) c_int; +pub extern fn pclose(__stream: [*c]FILE) c_int; +pub extern fn popen(__command: [*c]const u8, __modes: [*c]const u8) [*c]FILE; +pub extern fn ctermid(__s: [*c]u8) [*c]u8; +pub extern fn flockfile(__stream: [*c]FILE) void; +pub extern fn ftrylockfile(__stream: [*c]FILE) c_int; +pub extern fn funlockfile(__stream: [*c]FILE) void; +pub extern fn __uflow([*c]FILE) c_int; +pub extern fn __overflow([*c]FILE, c_int) c_int; +pub const wchar_t = c_int; +pub const div_t = extern struct { + quot: c_int = @import("std").mem.zeroes(c_int), + rem: c_int = @import("std").mem.zeroes(c_int), +}; +pub const ldiv_t = extern struct { + quot: c_long = @import("std").mem.zeroes(c_long), + rem: c_long = @import("std").mem.zeroes(c_long), +}; +pub const lldiv_t = extern struct { + quot: c_longlong = @import("std").mem.zeroes(c_longlong), + rem: c_longlong = @import("std").mem.zeroes(c_longlong), +}; +pub extern fn __ctype_get_mb_cur_max() usize; +pub extern fn atof(__nptr: [*c]const u8) f64; +pub extern fn atoi(__nptr: [*c]const u8) c_int; +pub extern fn atol(__nptr: [*c]const u8) c_long; +pub extern fn atoll(__nptr: [*c]const u8) c_longlong; +pub extern fn strtod(__nptr: [*c]const u8, __endptr: [*c][*c]u8) f64; +pub extern fn strtof(__nptr: [*c]const u8, __endptr: [*c][*c]u8) f32; +pub extern fn strtold(__nptr: [*c]const u8, __endptr: [*c][*c]u8) c_longdouble; +pub extern fn strtol(__nptr: [*c]const u8, __endptr: [*c][*c]u8, __base: c_int) c_long; +pub extern fn strtoul(__nptr: [*c]const u8, __endptr: [*c][*c]u8, __base: c_int) c_ulong; +pub extern fn strtoq(noalias __nptr: [*c]const u8, noalias __endptr: [*c][*c]u8, __base: c_int) c_longlong; +pub extern fn strtouq(noalias __nptr: [*c]const u8, noalias __endptr: [*c][*c]u8, __base: c_int) c_ulonglong; +pub extern fn strtoll(__nptr: [*c]const u8, __endptr: [*c][*c]u8, __base: c_int) c_longlong; +pub extern fn strtoull(__nptr: [*c]const u8, __endptr: [*c][*c]u8, __base: c_int) c_ulonglong; +pub extern fn l64a(__n: c_long) [*c]u8; +pub extern fn a64l(__s: [*c]const u8) c_long; +pub const u_char = __u_char; +pub const u_short = __u_short; +pub const u_int = __u_int; +pub const u_long = __u_long; +pub const quad_t = __quad_t; +pub const u_quad_t = __u_quad_t; +pub const fsid_t = __fsid_t; +pub const loff_t = __loff_t; +pub const ino_t = __ino_t; +pub const dev_t = __dev_t; +pub const gid_t = __gid_t; +pub const mode_t = __mode_t; +pub const nlink_t = __nlink_t; +pub const uid_t = __uid_t; +pub const pid_t = __pid_t; +pub const id_t = __id_t; +pub const daddr_t = __daddr_t; +pub const caddr_t = __caddr_t; +pub const key_t = __key_t; +pub const clock_t = __clock_t; +pub const clockid_t = __clockid_t; +pub const time_t = __time_t; +pub const timer_t = __timer_t; +pub const ulong = c_ulong; +pub const ushort = c_ushort; +pub const uint = c_uint; +pub const u_int8_t = __uint8_t; +pub const u_int16_t = __uint16_t; +pub const u_int32_t = __uint32_t; +pub const u_int64_t = __uint64_t; +pub const register_t = c_long; +pub fn __bswap_16(arg___bsx: __uint16_t) callconv(.C) __uint16_t { + var __bsx = arg___bsx; + _ = &__bsx; + return @as(__uint16_t, @bitCast(@as(c_short, @truncate(((@as(c_int, @bitCast(@as(c_uint, __bsx))) >> @intCast(8)) & @as(c_int, 255)) | ((@as(c_int, @bitCast(@as(c_uint, __bsx))) & @as(c_int, 255)) << @intCast(8)))))); +} +pub fn __bswap_32(arg___bsx: __uint32_t) callconv(.C) __uint32_t { + var __bsx = arg___bsx; + _ = &__bsx; + return ((((__bsx & @as(c_uint, 4278190080)) >> @intCast(24)) | ((__bsx & @as(c_uint, 16711680)) >> @intCast(8))) | ((__bsx & @as(c_uint, 65280)) << @intCast(8))) | ((__bsx & @as(c_uint, 255)) << @intCast(24)); +} +pub fn __bswap_64(arg___bsx: __uint64_t) callconv(.C) __uint64_t { + var __bsx = arg___bsx; + _ = &__bsx; + return @as(__uint64_t, @bitCast(@as(c_ulong, @truncate(((((((((@as(c_ulonglong, @bitCast(@as(c_ulonglong, __bsx))) & @as(c_ulonglong, 18374686479671623680)) >> @intCast(56)) | ((@as(c_ulonglong, @bitCast(@as(c_ulonglong, __bsx))) & @as(c_ulonglong, 71776119061217280)) >> @intCast(40))) | ((@as(c_ulonglong, @bitCast(@as(c_ulonglong, __bsx))) & @as(c_ulonglong, 280375465082880)) >> @intCast(24))) | ((@as(c_ulonglong, @bitCast(@as(c_ulonglong, __bsx))) & @as(c_ulonglong, 1095216660480)) >> @intCast(8))) | ((@as(c_ulonglong, @bitCast(@as(c_ulonglong, __bsx))) & @as(c_ulonglong, 4278190080)) << @intCast(8))) | ((@as(c_ulonglong, @bitCast(@as(c_ulonglong, __bsx))) & @as(c_ulonglong, 16711680)) << @intCast(24))) | ((@as(c_ulonglong, @bitCast(@as(c_ulonglong, __bsx))) & @as(c_ulonglong, 65280)) << @intCast(40))) | ((@as(c_ulonglong, @bitCast(@as(c_ulonglong, __bsx))) & @as(c_ulonglong, 255)) << @intCast(56)))))); +} +pub fn __uint16_identity(arg___x: __uint16_t) callconv(.C) __uint16_t { + var __x = arg___x; + _ = &__x; + return __x; +} +pub fn __uint32_identity(arg___x: __uint32_t) callconv(.C) __uint32_t { + var __x = arg___x; + _ = &__x; + return __x; +} +pub fn __uint64_identity(arg___x: __uint64_t) callconv(.C) __uint64_t { + var __x = arg___x; + _ = &__x; + return __x; +} +pub const __sigset_t = extern struct { + __val: [16]c_ulong = @import("std").mem.zeroes([16]c_ulong), +}; +pub const sigset_t = __sigset_t; +pub const struct_timeval = extern struct { + tv_sec: __time_t = @import("std").mem.zeroes(__time_t), + tv_usec: __suseconds_t = @import("std").mem.zeroes(__suseconds_t), +}; +pub const struct_timespec = extern struct { + tv_sec: __time_t = @import("std").mem.zeroes(__time_t), + tv_nsec: __syscall_slong_t = @import("std").mem.zeroes(__syscall_slong_t), +}; +pub const suseconds_t = __suseconds_t; +pub const __fd_mask = c_long; +pub const fd_set = extern struct { + __fds_bits: [16]__fd_mask = @import("std").mem.zeroes([16]__fd_mask), +}; +pub const fd_mask = __fd_mask; +pub extern fn select(__nfds: c_int, noalias __readfds: [*c]fd_set, noalias __writefds: [*c]fd_set, noalias __exceptfds: [*c]fd_set, noalias __timeout: [*c]struct_timeval) c_int; +pub extern fn pselect(__nfds: c_int, noalias __readfds: [*c]fd_set, noalias __writefds: [*c]fd_set, noalias __exceptfds: [*c]fd_set, noalias __timeout: [*c]const struct_timespec, noalias __sigmask: [*c]const __sigset_t) c_int; +pub const blksize_t = __blksize_t; +pub const blkcnt_t = __blkcnt_t; +pub const fsblkcnt_t = __fsblkcnt_t; +pub const fsfilcnt_t = __fsfilcnt_t; +const struct_unnamed_4 = extern struct { + __low: c_uint = @import("std").mem.zeroes(c_uint), + __high: c_uint = @import("std").mem.zeroes(c_uint), +}; +pub const __atomic_wide_counter = extern union { + __value64: c_ulonglong, + __value32: struct_unnamed_4, +}; +pub const struct___pthread_internal_list = extern struct { + __prev: [*c]struct___pthread_internal_list = @import("std").mem.zeroes([*c]struct___pthread_internal_list), + __next: [*c]struct___pthread_internal_list = @import("std").mem.zeroes([*c]struct___pthread_internal_list), +}; +pub const __pthread_list_t = struct___pthread_internal_list; +pub const struct___pthread_internal_slist = extern struct { + __next: [*c]struct___pthread_internal_slist = @import("std").mem.zeroes([*c]struct___pthread_internal_slist), +}; +pub const __pthread_slist_t = struct___pthread_internal_slist; +pub const struct___pthread_mutex_s = extern struct { + __lock: c_int = @import("std").mem.zeroes(c_int), + __count: c_uint = @import("std").mem.zeroes(c_uint), + __owner: c_int = @import("std").mem.zeroes(c_int), + __nusers: c_uint = @import("std").mem.zeroes(c_uint), + __kind: c_int = @import("std").mem.zeroes(c_int), + __spins: c_short = @import("std").mem.zeroes(c_short), + __elision: c_short = @import("std").mem.zeroes(c_short), + __list: __pthread_list_t = @import("std").mem.zeroes(__pthread_list_t), +}; +pub const struct___pthread_rwlock_arch_t = extern struct { + __readers: c_uint = @import("std").mem.zeroes(c_uint), + __writers: c_uint = @import("std").mem.zeroes(c_uint), + __wrphase_futex: c_uint = @import("std").mem.zeroes(c_uint), + __writers_futex: c_uint = @import("std").mem.zeroes(c_uint), + __pad3: c_uint = @import("std").mem.zeroes(c_uint), + __pad4: c_uint = @import("std").mem.zeroes(c_uint), + __cur_writer: c_int = @import("std").mem.zeroes(c_int), + __shared: c_int = @import("std").mem.zeroes(c_int), + __rwelision: i8 = @import("std").mem.zeroes(i8), + __pad1: [7]u8 = @import("std").mem.zeroes([7]u8), + __pad2: c_ulong = @import("std").mem.zeroes(c_ulong), + __flags: c_uint = @import("std").mem.zeroes(c_uint), +}; +pub const struct___pthread_cond_s = extern struct { + __wseq: __atomic_wide_counter = @import("std").mem.zeroes(__atomic_wide_counter), + __g1_start: __atomic_wide_counter = @import("std").mem.zeroes(__atomic_wide_counter), + __g_refs: [2]c_uint = @import("std").mem.zeroes([2]c_uint), + __g_size: [2]c_uint = @import("std").mem.zeroes([2]c_uint), + __g1_orig_size: c_uint = @import("std").mem.zeroes(c_uint), + __wrefs: c_uint = @import("std").mem.zeroes(c_uint), + __g_signals: [2]c_uint = @import("std").mem.zeroes([2]c_uint), +}; +pub const __tss_t = c_uint; +pub const __thrd_t = c_ulong; +pub const __once_flag = extern struct { + __data: c_int = @import("std").mem.zeroes(c_int), +}; +pub const pthread_t = c_ulong; +pub const pthread_mutexattr_t = extern union { + __size: [4]u8, + __align: c_int, +}; +pub const pthread_condattr_t = extern union { + __size: [4]u8, + __align: c_int, +}; +pub const pthread_key_t = c_uint; +pub const pthread_once_t = c_int; +pub const union_pthread_attr_t = extern union { + __size: [56]u8, + __align: c_long, +}; +pub const pthread_attr_t = union_pthread_attr_t; +pub const pthread_mutex_t = extern union { + __data: struct___pthread_mutex_s, + __size: [40]u8, + __align: c_long, +}; +pub const pthread_cond_t = extern union { + __data: struct___pthread_cond_s, + __size: [48]u8, + __align: c_longlong, +}; +pub const pthread_rwlock_t = extern union { + __data: struct___pthread_rwlock_arch_t, + __size: [56]u8, + __align: c_long, +}; +pub const pthread_rwlockattr_t = extern union { + __size: [8]u8, + __align: c_long, +}; +pub const pthread_spinlock_t = c_int; +pub const pthread_barrier_t = extern union { + __size: [32]u8, + __align: c_long, +}; +pub const pthread_barrierattr_t = extern union { + __size: [4]u8, + __align: c_int, +}; +pub extern fn random() c_long; +pub extern fn srandom(__seed: c_uint) void; +pub extern fn initstate(__seed: c_uint, __statebuf: [*c]u8, __statelen: usize) [*c]u8; +pub extern fn setstate(__statebuf: [*c]u8) [*c]u8; +pub const struct_random_data = extern struct { + fptr: [*c]i32 = @import("std").mem.zeroes([*c]i32), + rptr: [*c]i32 = @import("std").mem.zeroes([*c]i32), + state: [*c]i32 = @import("std").mem.zeroes([*c]i32), + rand_type: c_int = @import("std").mem.zeroes(c_int), + rand_deg: c_int = @import("std").mem.zeroes(c_int), + rand_sep: c_int = @import("std").mem.zeroes(c_int), + end_ptr: [*c]i32 = @import("std").mem.zeroes([*c]i32), +}; +pub extern fn random_r(noalias __buf: [*c]struct_random_data, noalias __result: [*c]i32) c_int; +pub extern fn srandom_r(__seed: c_uint, __buf: [*c]struct_random_data) c_int; +pub extern fn initstate_r(__seed: c_uint, noalias __statebuf: [*c]u8, __statelen: usize, noalias __buf: [*c]struct_random_data) c_int; +pub extern fn setstate_r(noalias __statebuf: [*c]u8, noalias __buf: [*c]struct_random_data) c_int; +pub extern fn rand() c_int; +pub extern fn srand(__seed: c_uint) void; +pub extern fn rand_r(__seed: [*c]c_uint) c_int; +pub extern fn drand48() f64; +pub extern fn erand48(__xsubi: [*c]c_ushort) f64; +pub extern fn lrand48() c_long; +pub extern fn nrand48(__xsubi: [*c]c_ushort) c_long; +pub extern fn mrand48() c_long; +pub extern fn jrand48(__xsubi: [*c]c_ushort) c_long; +pub extern fn srand48(__seedval: c_long) void; +pub extern fn seed48(__seed16v: [*c]c_ushort) [*c]c_ushort; +pub extern fn lcong48(__param: [*c]c_ushort) void; +pub const struct_drand48_data = extern struct { + __x: [3]c_ushort = @import("std").mem.zeroes([3]c_ushort), + __old_x: [3]c_ushort = @import("std").mem.zeroes([3]c_ushort), + __c: c_ushort = @import("std").mem.zeroes(c_ushort), + __init: c_ushort = @import("std").mem.zeroes(c_ushort), + __a: c_ulonglong = @import("std").mem.zeroes(c_ulonglong), +}; +pub extern fn drand48_r(noalias __buffer: [*c]struct_drand48_data, noalias __result: [*c]f64) c_int; +pub extern fn erand48_r(__xsubi: [*c]c_ushort, noalias __buffer: [*c]struct_drand48_data, noalias __result: [*c]f64) c_int; +pub extern fn lrand48_r(noalias __buffer: [*c]struct_drand48_data, noalias __result: [*c]c_long) c_int; +pub extern fn nrand48_r(__xsubi: [*c]c_ushort, noalias __buffer: [*c]struct_drand48_data, noalias __result: [*c]c_long) c_int; +pub extern fn mrand48_r(noalias __buffer: [*c]struct_drand48_data, noalias __result: [*c]c_long) c_int; +pub extern fn jrand48_r(__xsubi: [*c]c_ushort, noalias __buffer: [*c]struct_drand48_data, noalias __result: [*c]c_long) c_int; +pub extern fn srand48_r(__seedval: c_long, __buffer: [*c]struct_drand48_data) c_int; +pub extern fn seed48_r(__seed16v: [*c]c_ushort, __buffer: [*c]struct_drand48_data) c_int; +pub extern fn lcong48_r(__param: [*c]c_ushort, __buffer: [*c]struct_drand48_data) c_int; +pub extern fn arc4random() __uint32_t; +pub extern fn arc4random_buf(__buf: ?*anyopaque, __size: usize) void; +pub extern fn arc4random_uniform(__upper_bound: __uint32_t) __uint32_t; +pub extern fn malloc(__size: c_ulong) ?*anyopaque; +pub extern fn calloc(__nmemb: c_ulong, __size: c_ulong) ?*anyopaque; +pub extern fn realloc(__ptr: ?*anyopaque, __size: c_ulong) ?*anyopaque; +pub extern fn free(__ptr: ?*anyopaque) void; +pub extern fn reallocarray(__ptr: ?*anyopaque, __nmemb: usize, __size: usize) ?*anyopaque; +pub extern fn alloca(__size: c_ulong) ?*anyopaque; +pub extern fn valloc(__size: usize) ?*anyopaque; +pub extern fn posix_memalign(__memptr: [*c]?*anyopaque, __alignment: usize, __size: usize) c_int; +pub extern fn aligned_alloc(__alignment: c_ulong, __size: c_ulong) ?*anyopaque; +pub extern fn abort() noreturn; +pub extern fn atexit(__func: ?*const fn () callconv(.C) void) c_int; +pub extern fn at_quick_exit(__func: ?*const fn () callconv(.C) void) c_int; +pub extern fn on_exit(__func: ?*const fn (c_int, ?*anyopaque) callconv(.C) void, __arg: ?*anyopaque) c_int; +pub extern fn exit(__status: c_int) noreturn; +pub extern fn quick_exit(__status: c_int) noreturn; +pub extern fn _Exit(__status: c_int) noreturn; +pub extern fn getenv(__name: [*c]const u8) [*c]u8; +pub extern fn putenv(__string: [*c]u8) c_int; +pub extern fn setenv(__name: [*c]const u8, __value: [*c]const u8, __replace: c_int) c_int; +pub extern fn unsetenv(__name: [*c]const u8) c_int; +pub extern fn clearenv() c_int; +pub extern fn mktemp(__template: [*c]u8) [*c]u8; +pub extern fn mkstemp(__template: [*c]u8) c_int; +pub extern fn mkstemps(__template: [*c]u8, __suffixlen: c_int) c_int; +pub extern fn mkdtemp(__template: [*c]u8) [*c]u8; +pub extern fn system(__command: [*c]const u8) c_int; +pub extern fn realpath(noalias __name: [*c]const u8, noalias __resolved: [*c]u8) [*c]u8; +pub const __compar_fn_t = ?*const fn (?*const anyopaque, ?*const anyopaque) callconv(.C) c_int; +pub extern fn bsearch(__key: ?*const anyopaque, __base: ?*const anyopaque, __nmemb: usize, __size: usize, __compar: __compar_fn_t) ?*anyopaque; +pub extern fn qsort(__base: ?*anyopaque, __nmemb: usize, __size: usize, __compar: __compar_fn_t) void; +pub extern fn abs(__x: c_int) c_int; +pub extern fn labs(__x: c_long) c_long; +pub extern fn llabs(__x: c_longlong) c_longlong; +pub extern fn div(__numer: c_int, __denom: c_int) div_t; +pub extern fn ldiv(__numer: c_long, __denom: c_long) ldiv_t; +pub extern fn lldiv(__numer: c_longlong, __denom: c_longlong) lldiv_t; +pub extern fn ecvt(__value: f64, __ndigit: c_int, noalias __decpt: [*c]c_int, noalias __sign: [*c]c_int) [*c]u8; +pub extern fn fcvt(__value: f64, __ndigit: c_int, noalias __decpt: [*c]c_int, noalias __sign: [*c]c_int) [*c]u8; +pub extern fn gcvt(__value: f64, __ndigit: c_int, __buf: [*c]u8) [*c]u8; +pub extern fn qecvt(__value: c_longdouble, __ndigit: c_int, noalias __decpt: [*c]c_int, noalias __sign: [*c]c_int) [*c]u8; +pub extern fn qfcvt(__value: c_longdouble, __ndigit: c_int, noalias __decpt: [*c]c_int, noalias __sign: [*c]c_int) [*c]u8; +pub extern fn qgcvt(__value: c_longdouble, __ndigit: c_int, __buf: [*c]u8) [*c]u8; +pub extern fn ecvt_r(__value: f64, __ndigit: c_int, noalias __decpt: [*c]c_int, noalias __sign: [*c]c_int, noalias __buf: [*c]u8, __len: usize) c_int; +pub extern fn fcvt_r(__value: f64, __ndigit: c_int, noalias __decpt: [*c]c_int, noalias __sign: [*c]c_int, noalias __buf: [*c]u8, __len: usize) c_int; +pub extern fn qecvt_r(__value: c_longdouble, __ndigit: c_int, noalias __decpt: [*c]c_int, noalias __sign: [*c]c_int, noalias __buf: [*c]u8, __len: usize) c_int; +pub extern fn qfcvt_r(__value: c_longdouble, __ndigit: c_int, noalias __decpt: [*c]c_int, noalias __sign: [*c]c_int, noalias __buf: [*c]u8, __len: usize) c_int; +pub extern fn mblen(__s: [*c]const u8, __n: usize) c_int; +pub extern fn mbtowc(noalias __pwc: [*c]wchar_t, noalias __s: [*c]const u8, __n: usize) c_int; +pub extern fn wctomb(__s: [*c]u8, __wchar: wchar_t) c_int; +pub extern fn mbstowcs(noalias __pwcs: [*c]wchar_t, noalias __s: [*c]const u8, __n: usize) usize; +pub extern fn wcstombs(noalias __s: [*c]u8, noalias __pwcs: [*c]const wchar_t, __n: usize) usize; +pub extern fn rpmatch(__response: [*c]const u8) c_int; +pub extern fn getsubopt(noalias __optionp: [*c][*c]u8, noalias __tokens: [*c]const [*c]u8, noalias __valuep: [*c][*c]u8) c_int; +pub extern fn getloadavg(__loadavg: [*c]f64, __nelem: c_int) c_int; +pub extern fn memcpy(__dest: ?*anyopaque, __src: ?*const anyopaque, __n: c_ulong) ?*anyopaque; +pub extern fn memmove(__dest: ?*anyopaque, __src: ?*const anyopaque, __n: c_ulong) ?*anyopaque; +pub extern fn memccpy(__dest: ?*anyopaque, __src: ?*const anyopaque, __c: c_int, __n: c_ulong) ?*anyopaque; +pub extern fn memset(__s: ?*anyopaque, __c: c_int, __n: c_ulong) ?*anyopaque; +pub extern fn memcmp(__s1: ?*const anyopaque, __s2: ?*const anyopaque, __n: c_ulong) c_int; +pub extern fn __memcmpeq(__s1: ?*const anyopaque, __s2: ?*const anyopaque, __n: usize) c_int; +pub extern fn memchr(__s: ?*const anyopaque, __c: c_int, __n: c_ulong) ?*anyopaque; +pub extern fn strcpy(__dest: [*c]u8, __src: [*c]const u8) [*c]u8; +pub extern fn strncpy(__dest: [*c]u8, __src: [*c]const u8, __n: c_ulong) [*c]u8; +pub extern fn strcat(__dest: [*c]u8, __src: [*c]const u8) [*c]u8; +pub extern fn strncat(__dest: [*c]u8, __src: [*c]const u8, __n: c_ulong) [*c]u8; +pub extern fn strcmp(__s1: [*c]const u8, __s2: [*c]const u8) c_int; +pub extern fn strncmp(__s1: [*c]const u8, __s2: [*c]const u8, __n: c_ulong) c_int; +pub extern fn strcoll(__s1: [*c]const u8, __s2: [*c]const u8) c_int; +pub extern fn strxfrm(__dest: [*c]u8, __src: [*c]const u8, __n: c_ulong) c_ulong; +pub const struct___locale_data_5 = opaque {}; +pub const struct___locale_struct = extern struct { + __locales: [13]?*struct___locale_data_5 = @import("std").mem.zeroes([13]?*struct___locale_data_5), + __ctype_b: [*c]const c_ushort = @import("std").mem.zeroes([*c]const c_ushort), + __ctype_tolower: [*c]const c_int = @import("std").mem.zeroes([*c]const c_int), + __ctype_toupper: [*c]const c_int = @import("std").mem.zeroes([*c]const c_int), + __names: [13][*c]const u8 = @import("std").mem.zeroes([13][*c]const u8), +}; +pub const __locale_t = [*c]struct___locale_struct; +pub const locale_t = __locale_t; +pub extern fn strcoll_l(__s1: [*c]const u8, __s2: [*c]const u8, __l: locale_t) c_int; +pub extern fn strxfrm_l(__dest: [*c]u8, __src: [*c]const u8, __n: usize, __l: locale_t) usize; +pub extern fn strdup(__s: [*c]const u8) [*c]u8; +pub extern fn strndup(__string: [*c]const u8, __n: c_ulong) [*c]u8; +pub extern fn strchr(__s: [*c]const u8, __c: c_int) [*c]u8; +pub extern fn strrchr(__s: [*c]const u8, __c: c_int) [*c]u8; +pub extern fn strchrnul(__s: [*c]const u8, __c: c_int) [*c]u8; +pub extern fn strcspn(__s: [*c]const u8, __reject: [*c]const u8) c_ulong; +pub extern fn strspn(__s: [*c]const u8, __accept: [*c]const u8) c_ulong; +pub extern fn strpbrk(__s: [*c]const u8, __accept: [*c]const u8) [*c]u8; +pub extern fn strstr(__haystack: [*c]const u8, __needle: [*c]const u8) [*c]u8; +pub extern fn strtok(__s: [*c]u8, __delim: [*c]const u8) [*c]u8; +pub extern fn __strtok_r(noalias __s: [*c]u8, noalias __delim: [*c]const u8, noalias __save_ptr: [*c][*c]u8) [*c]u8; +pub extern fn strtok_r(noalias __s: [*c]u8, noalias __delim: [*c]const u8, noalias __save_ptr: [*c][*c]u8) [*c]u8; +pub extern fn strcasestr(__haystack: [*c]const u8, __needle: [*c]const u8) [*c]u8; +pub extern fn memmem(__haystack: ?*const anyopaque, __haystacklen: usize, __needle: ?*const anyopaque, __needlelen: usize) ?*anyopaque; +pub extern fn __mempcpy(noalias __dest: ?*anyopaque, noalias __src: ?*const anyopaque, __n: usize) ?*anyopaque; +pub extern fn mempcpy(__dest: ?*anyopaque, __src: ?*const anyopaque, __n: c_ulong) ?*anyopaque; +pub extern fn strlen(__s: [*c]const u8) c_ulong; +pub extern fn strnlen(__string: [*c]const u8, __maxlen: usize) usize; +pub extern fn strerror(__errnum: c_int) [*c]u8; +pub extern fn strerror_r(__errnum: c_int, __buf: [*c]u8, __buflen: usize) c_int; +pub extern fn strerror_l(__errnum: c_int, __l: locale_t) [*c]u8; +pub extern fn bcmp(__s1: ?*const anyopaque, __s2: ?*const anyopaque, __n: c_ulong) c_int; +pub extern fn bcopy(__src: ?*const anyopaque, __dest: ?*anyopaque, __n: c_ulong) void; +pub extern fn bzero(__s: ?*anyopaque, __n: c_ulong) void; +pub extern fn index(__s: [*c]const u8, __c: c_int) [*c]u8; +pub extern fn rindex(__s: [*c]const u8, __c: c_int) [*c]u8; +pub extern fn ffs(__i: c_int) c_int; +pub extern fn ffsl(__l: c_long) c_int; +pub extern fn ffsll(__ll: c_longlong) c_int; +pub extern fn strcasecmp(__s1: [*c]const u8, __s2: [*c]const u8) c_int; +pub extern fn strncasecmp(__s1: [*c]const u8, __s2: [*c]const u8, __n: c_ulong) c_int; +pub extern fn strcasecmp_l(__s1: [*c]const u8, __s2: [*c]const u8, __loc: locale_t) c_int; +pub extern fn strncasecmp_l(__s1: [*c]const u8, __s2: [*c]const u8, __n: usize, __loc: locale_t) c_int; +pub extern fn explicit_bzero(__s: ?*anyopaque, __n: usize) void; +pub extern fn strsep(noalias __stringp: [*c][*c]u8, noalias __delim: [*c]const u8) [*c]u8; +pub extern fn strsignal(__sig: c_int) [*c]u8; +pub extern fn __stpcpy(noalias __dest: [*c]u8, noalias __src: [*c]const u8) [*c]u8; +pub extern fn stpcpy(__dest: [*c]u8, __src: [*c]const u8) [*c]u8; +pub extern fn __stpncpy(noalias __dest: [*c]u8, noalias __src: [*c]const u8, __n: usize) [*c]u8; +pub extern fn stpncpy(__dest: [*c]u8, __src: [*c]const u8, __n: c_ulong) [*c]u8; +pub extern fn strlcpy(__dest: [*c]u8, __src: [*c]const u8, __n: c_ulong) c_ulong; +pub extern fn strlcat(__dest: [*c]u8, __src: [*c]const u8, __n: c_ulong) c_ulong; +pub const tinyobj_material_t = extern struct { + name: [*c]u8 = @import("std").mem.zeroes([*c]u8), + ambient: [3]f32 = @import("std").mem.zeroes([3]f32), + diffuse: [3]f32 = @import("std").mem.zeroes([3]f32), + specular: [3]f32 = @import("std").mem.zeroes([3]f32), + transmittance: [3]f32 = @import("std").mem.zeroes([3]f32), + emission: [3]f32 = @import("std").mem.zeroes([3]f32), + shininess: f32 = @import("std").mem.zeroes(f32), + ior: f32 = @import("std").mem.zeroes(f32), + dissolve: f32 = @import("std").mem.zeroes(f32), + illum: c_int = @import("std").mem.zeroes(c_int), + pad0: c_int = @import("std").mem.zeroes(c_int), + ambient_texname: [*c]u8 = @import("std").mem.zeroes([*c]u8), + diffuse_texname: [*c]u8 = @import("std").mem.zeroes([*c]u8), + specular_texname: [*c]u8 = @import("std").mem.zeroes([*c]u8), + specular_highlight_texname: [*c]u8 = @import("std").mem.zeroes([*c]u8), + bump_texname: [*c]u8 = @import("std").mem.zeroes([*c]u8), + displacement_texname: [*c]u8 = @import("std").mem.zeroes([*c]u8), + alpha_texname: [*c]u8 = @import("std").mem.zeroes([*c]u8), +}; +pub const tinyobj_shape_t = extern struct { + name: [*c]u8 = @import("std").mem.zeroes([*c]u8), + face_offset: c_uint = @import("std").mem.zeroes(c_uint), + length: c_uint = @import("std").mem.zeroes(c_uint), +}; +pub const tinyobj_vertex_index_t = extern struct { + v_idx: c_int = @import("std").mem.zeroes(c_int), + vt_idx: c_int = @import("std").mem.zeroes(c_int), + vn_idx: c_int = @import("std").mem.zeroes(c_int), +}; +pub const tinyobj_attrib_t = extern struct { + num_vertices: c_uint = @import("std").mem.zeroes(c_uint), + num_normals: c_uint = @import("std").mem.zeroes(c_uint), + num_texcoords: c_uint = @import("std").mem.zeroes(c_uint), + num_faces: c_uint = @import("std").mem.zeroes(c_uint), + num_face_num_verts: c_uint = @import("std").mem.zeroes(c_uint), + pad0: c_int = @import("std").mem.zeroes(c_int), + vertices: [*c]f32 = @import("std").mem.zeroes([*c]f32), + normals: [*c]f32 = @import("std").mem.zeroes([*c]f32), + texcoords: [*c]f32 = @import("std").mem.zeroes([*c]f32), + faces: [*c]tinyobj_vertex_index_t = @import("std").mem.zeroes([*c]tinyobj_vertex_index_t), + face_num_verts: [*c]c_int = @import("std").mem.zeroes([*c]c_int), + material_ids: [*c]c_int = @import("std").mem.zeroes([*c]c_int), +}; +pub export fn tinyobj_parse_obj(arg_attrib: [*c]tinyobj_attrib_t, arg_shapes: [*c][*c]tinyobj_shape_t, arg_num_shapes: [*c]c_uint, arg_materials_out: [*c][*c]tinyobj_material_t, arg_num_materials_out: [*c]c_uint, arg_buf: [*c]const u8, arg_len: c_uint, arg_flags: c_uint) c_int { + var attrib = arg_attrib; + _ = &attrib; + var shapes = arg_shapes; + _ = &shapes; + var num_shapes = arg_num_shapes; + _ = &num_shapes; + var materials_out = arg_materials_out; + _ = &materials_out; + var num_materials_out = arg_num_materials_out; + _ = &num_materials_out; + var buf = arg_buf; + _ = &buf; + var len = arg_len; + _ = &len; + var flags = arg_flags; + _ = &flags; + var line_infos: [*c]LineInfo = null; + _ = &line_infos; + var commands: [*c]Command = null; + _ = &commands; + var num_lines: c_uint = 0; + _ = &num_lines; + var num_v: c_uint = 0; + _ = &num_v; + var num_vn: c_uint = 0; + _ = &num_vn; + var num_vt: c_uint = 0; + _ = &num_vt; + var num_f: c_uint = 0; + _ = &num_f; + var num_faces: c_uint = 0; + _ = &num_faces; + var mtllib_line_index: c_int = -@as(c_int, 1); + _ = &mtllib_line_index; + var materials: [*c]tinyobj_material_t = null; + _ = &materials; + var num_materials: c_uint = 0; + _ = &num_materials; + var material_table: hash_table_t = undefined; + _ = &material_table; + if (len < @as(c_uint, @bitCast(@as(c_int, 1)))) return -@as(c_int, 2); + if (attrib == @as([*c]tinyobj_attrib_t, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0))))))) return -@as(c_int, 2); + if (shapes == @as([*c][*c]tinyobj_shape_t, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0))))))) return -@as(c_int, 2); + if (num_shapes == @as([*c]c_uint, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0))))))) return -@as(c_int, 2); + if (buf == @as([*c]const u8, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0))))))) return -@as(c_int, 2); + if (materials_out == @as([*c][*c]tinyobj_material_t, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0))))))) return -@as(c_int, 2); + if (num_materials_out == @as([*c]c_uint, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0))))))) return -@as(c_int, 2); + tinyobj_attrib_init(attrib); + { + var i: c_uint = undefined; + _ = &i; + var end_idx: c_uint = len; + _ = &end_idx; + var prev_pos: c_uint = 0; + _ = &prev_pos; + var line_no: c_uint = 0; + _ = &line_no; + var last_line_ending: c_uint = 0; + _ = &last_line_ending; + { + i = 0; + while (i < end_idx) : (i +%= 1) { + if (is_line_ending(buf, i, end_idx) != 0) { + num_lines +%= 1; + last_line_ending = i; + } + } + } + if ((end_idx -% last_line_ending) > @as(c_uint, @bitCast(@as(c_int, 0)))) { + num_lines +%= 1; + } + if (num_lines == @as(c_uint, @bitCast(@as(c_int, 0)))) return -@as(c_int, 1); + line_infos = @as([*c]LineInfo, @ptrCast(@alignCast(malloc(@sizeOf(LineInfo) *% @as(c_ulong, @bitCast(@as(c_ulong, num_lines))))))); + { + i = 0; + while (i < end_idx) : (i +%= 1) { + if (is_line_ending(buf, i, end_idx) != 0) { + line_infos[line_no].pos = prev_pos; + line_infos[line_no].len = i -% prev_pos; + if ((i > @as(c_uint, @bitCast(@as(c_int, 0)))) and (@as(c_int, @bitCast(@as(c_uint, buf[i -% @as(c_uint, @bitCast(@as(c_int, 1)))]))) == @as(c_int, '\r'))) { + line_infos[line_no].len -%= 1; + } + prev_pos = i +% @as(c_uint, @bitCast(@as(c_int, 1))); + line_no +%= 1; + } + } + } + if ((end_idx -% last_line_ending) > @as(c_uint, @bitCast(@as(c_int, 0)))) { + line_infos[line_no].pos = prev_pos; + line_infos[line_no].len = (end_idx -% @as(c_uint, @bitCast(@as(c_int, 1)))) -% last_line_ending; + } + } + commands = @as([*c]Command, @ptrCast(@alignCast(malloc(@sizeOf(Command) *% @as(c_ulong, @bitCast(@as(c_ulong, num_lines))))))); + create_hash_table(@as(c_uint, @bitCast(@as(c_int, 10))), &material_table); + { + var i: c_uint = 0; + _ = &i; + { + i = 0; + while (i < num_lines) : (i +%= 1) { + var ret: c_int = parseLine(&commands[i], &buf[line_infos[i].pos], line_infos[i].len, @as(c_int, @bitCast(flags & @as(c_uint, @bitCast(@as(c_int, 1) << @intCast(0)))))); + _ = &ret; + if (ret != 0) { + if (commands[i].type == @as(c_uint, @bitCast(COMMAND_V))) { + num_v +%= 1; + } else if (commands[i].type == @as(c_uint, @bitCast(COMMAND_VN))) { + num_vn +%= 1; + } else if (commands[i].type == @as(c_uint, @bitCast(COMMAND_VT))) { + num_vt +%= 1; + } else if (commands[i].type == @as(c_uint, @bitCast(COMMAND_F))) { + num_f +%= commands[i].num_f; + num_faces +%= commands[i].num_f_num_verts; + } + if (commands[i].type == @as(c_uint, @bitCast(COMMAND_MTLLIB))) { + mtllib_line_index = @as(c_int, @bitCast(i)); + } + } + } + } + } + if (line_infos != null) { + free(@as(?*anyopaque, @ptrCast(line_infos))); + } + if (((mtllib_line_index >= @as(c_int, 0)) and ((blk: { + const tmp = mtllib_line_index; + if (tmp >= 0) break :blk commands + @as(usize, @intCast(tmp)) else break :blk commands - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.mtllib_name != null)) and ((blk: { + const tmp = mtllib_line_index; + if (tmp >= 0) break :blk commands + @as(usize, @intCast(tmp)) else break :blk commands - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.mtllib_name_len > @as(c_uint, @bitCast(@as(c_int, 0))))) { + var filename: [*c]u8 = my_strndup((blk: { + const tmp = mtllib_line_index; + if (tmp >= 0) break :blk commands + @as(usize, @intCast(tmp)) else break :blk commands - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.mtllib_name, (blk: { + const tmp = mtllib_line_index; + if (tmp >= 0) break :blk commands + @as(usize, @intCast(tmp)) else break :blk commands - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.mtllib_name_len); + _ = &filename; + var ret: c_int = tinyobj_parse_and_index_mtl_file(&materials, &num_materials, filename, &material_table); + _ = &ret; + if (ret != @as(c_int, 0)) { + _ = fprintf(stderr, "TINYOBJ: Failed to parse material file '%s': %d\n", filename, ret); + } + free(@as(?*anyopaque, @ptrCast(filename))); + } + { + var v_count: c_uint = 0; + _ = &v_count; + var n_count: c_uint = 0; + _ = &n_count; + var t_count: c_uint = 0; + _ = &t_count; + var f_count: c_uint = 0; + _ = &f_count; + var face_count: c_uint = 0; + _ = &face_count; + var material_id: c_int = -@as(c_int, 1); + _ = &material_id; + var i: c_uint = 0; + _ = &i; + attrib.*.vertices = @as([*c]f32, @ptrCast(@alignCast(malloc((@sizeOf(f32) *% @as(c_ulong, @bitCast(@as(c_ulong, num_v)))) *% @as(c_ulong, @bitCast(@as(c_long, @as(c_int, 3)))))))); + attrib.*.num_vertices = num_v; + attrib.*.normals = @as([*c]f32, @ptrCast(@alignCast(malloc((@sizeOf(f32) *% @as(c_ulong, @bitCast(@as(c_ulong, num_vn)))) *% @as(c_ulong, @bitCast(@as(c_long, @as(c_int, 3)))))))); + attrib.*.num_normals = num_vn; + attrib.*.texcoords = @as([*c]f32, @ptrCast(@alignCast(malloc((@sizeOf(f32) *% @as(c_ulong, @bitCast(@as(c_ulong, num_vt)))) *% @as(c_ulong, @bitCast(@as(c_long, @as(c_int, 2)))))))); + attrib.*.num_texcoords = num_vt; + attrib.*.faces = @as([*c]tinyobj_vertex_index_t, @ptrCast(@alignCast(malloc(@sizeOf(tinyobj_vertex_index_t) *% @as(c_ulong, @bitCast(@as(c_ulong, num_f))))))); + attrib.*.face_num_verts = @as([*c]c_int, @ptrCast(@alignCast(malloc(@sizeOf(c_int) *% @as(c_ulong, @bitCast(@as(c_ulong, num_faces))))))); + attrib.*.num_faces = num_faces; + attrib.*.num_face_num_verts = num_f; + attrib.*.material_ids = @as([*c]c_int, @ptrCast(@alignCast(malloc(@sizeOf(c_int) *% @as(c_ulong, @bitCast(@as(c_ulong, num_faces))))))); + { + i = 0; + while (i < num_lines) : (i +%= 1) { + if (commands[i].type == @as(c_uint, @bitCast(COMMAND_EMPTY))) { + continue; + } else if (commands[i].type == @as(c_uint, @bitCast(COMMAND_USEMTL))) { + if ((commands[i].material_name != null) and (commands[i].material_name_len > @as(c_uint, @bitCast(@as(c_int, 0))))) { + var material_name_null_term: [*c]u8 = @as([*c]u8, @ptrCast(@alignCast(malloc(@as(c_ulong, @bitCast(@as(c_ulong, commands[i].material_name_len +% @as(c_uint, @bitCast(@as(c_int, 1)))))))))); + _ = &material_name_null_term; + _ = memcpy(@as(?*anyopaque, @ptrCast(material_name_null_term)), @as(?*const anyopaque, @ptrCast(commands[i].material_name)), @as(c_ulong, @bitCast(@as(c_ulong, commands[i].material_name_len)))); + material_name_null_term[commands[i].material_name_len] = 0; + if (hash_table_exists(material_name_null_term, &material_table) != 0) { + material_id = @as(c_int, @bitCast(@as(c_int, @truncate(hash_table_get(material_name_null_term, &material_table))))); + } else { + material_id = -@as(c_int, 1); + } + free(@as(?*anyopaque, @ptrCast(material_name_null_term))); + } + } else if (commands[i].type == @as(c_uint, @bitCast(COMMAND_V))) { + attrib.*.vertices[(@as(c_uint, @bitCast(@as(c_int, 3))) *% v_count) +% @as(c_uint, @bitCast(@as(c_int, 0)))] = commands[i].vx; + attrib.*.vertices[(@as(c_uint, @bitCast(@as(c_int, 3))) *% v_count) +% @as(c_uint, @bitCast(@as(c_int, 1)))] = commands[i].vy; + attrib.*.vertices[(@as(c_uint, @bitCast(@as(c_int, 3))) *% v_count) +% @as(c_uint, @bitCast(@as(c_int, 2)))] = commands[i].vz; + v_count +%= 1; + } else if (commands[i].type == @as(c_uint, @bitCast(COMMAND_VN))) { + attrib.*.normals[(@as(c_uint, @bitCast(@as(c_int, 3))) *% n_count) +% @as(c_uint, @bitCast(@as(c_int, 0)))] = commands[i].nx; + attrib.*.normals[(@as(c_uint, @bitCast(@as(c_int, 3))) *% n_count) +% @as(c_uint, @bitCast(@as(c_int, 1)))] = commands[i].ny; + attrib.*.normals[(@as(c_uint, @bitCast(@as(c_int, 3))) *% n_count) +% @as(c_uint, @bitCast(@as(c_int, 2)))] = commands[i].nz; + n_count +%= 1; + } else if (commands[i].type == @as(c_uint, @bitCast(COMMAND_VT))) { + attrib.*.texcoords[(@as(c_uint, @bitCast(@as(c_int, 2))) *% t_count) +% @as(c_uint, @bitCast(@as(c_int, 0)))] = commands[i].tx; + attrib.*.texcoords[(@as(c_uint, @bitCast(@as(c_int, 2))) *% t_count) +% @as(c_uint, @bitCast(@as(c_int, 1)))] = commands[i].ty; + t_count +%= 1; + } else if (commands[i].type == @as(c_uint, @bitCast(COMMAND_F))) { + var k: c_uint = 0; + _ = &k; + { + k = 0; + while (k < commands[i].num_f) : (k +%= 1) { + var vi: tinyobj_vertex_index_t = commands[i].f[k]; + _ = &vi; + var v_idx: c_int = fixIndex(vi.v_idx, v_count); + _ = &v_idx; + var vn_idx: c_int = fixIndex(vi.vn_idx, n_count); + _ = &vn_idx; + var vt_idx: c_int = fixIndex(vi.vt_idx, t_count); + _ = &vt_idx; + attrib.*.faces[f_count +% k].v_idx = v_idx; + attrib.*.faces[f_count +% k].vn_idx = vn_idx; + attrib.*.faces[f_count +% k].vt_idx = vt_idx; + } + } + { + k = 0; + while (k < commands[i].num_f_num_verts) : (k +%= 1) { + attrib.*.material_ids[face_count +% k] = material_id; + attrib.*.face_num_verts[face_count +% k] = commands[i].f_num_verts[k]; + } + } + f_count +%= commands[i].num_f; + face_count +%= commands[i].num_f_num_verts; + } + } + } + } + { + var face_count: c_uint = 0; + _ = &face_count; + var i: c_uint = 0; + _ = &i; + var n: c_uint = 0; + _ = &n; + var shape_idx: c_uint = 0; + _ = &shape_idx; + var shape_name: [*c]const u8 = null; + _ = &shape_name; + var shape_name_len: c_uint = 0; + _ = &shape_name_len; + var prev_shape_name: [*c]const u8 = null; + _ = &prev_shape_name; + var prev_shape_name_len: c_uint = 0; + _ = &prev_shape_name_len; + var prev_shape_face_offset: c_uint = 0; + _ = &prev_shape_face_offset; + var prev_face_offset: c_uint = 0; + _ = &prev_face_offset; + var prev_shape: tinyobj_shape_t = tinyobj_shape_t{ + .name = null, + .face_offset = @as(c_uint, @bitCast(@as(c_int, 0))), + .length = @as(c_uint, @bitCast(@as(c_int, 0))), + }; + _ = &prev_shape; + { + i = 0; + while (i < num_lines) : (i +%= 1) { + if ((commands[i].type == @as(c_uint, @bitCast(COMMAND_O))) or (commands[i].type == @as(c_uint, @bitCast(COMMAND_G)))) { + n +%= 1; + } + } + } + shapes.* = @as([*c]tinyobj_shape_t, @ptrCast(@alignCast(malloc(@sizeOf(tinyobj_shape_t) *% @as(c_ulong, @bitCast(@as(c_ulong, n +% @as(c_uint, @bitCast(@as(c_int, 1)))))))))); + { + i = 0; + while (i < num_lines) : (i +%= 1) { + if ((commands[i].type == @as(c_uint, @bitCast(COMMAND_O))) or (commands[i].type == @as(c_uint, @bitCast(COMMAND_G)))) { + if (commands[i].type == @as(c_uint, @bitCast(COMMAND_O))) { + shape_name = commands[i].object_name; + shape_name_len = commands[i].object_name_len; + } else { + shape_name = commands[i].group_name; + shape_name_len = commands[i].group_name_len; + } + if (face_count == @as(c_uint, @bitCast(@as(c_int, 0)))) { + prev_shape_name = shape_name; + prev_shape_name_len = shape_name_len; + prev_shape_face_offset = face_count; + prev_face_offset = face_count; + } else { + if (shape_idx == @as(c_uint, @bitCast(@as(c_int, 0)))) { + shapes.*[shape_idx].name = my_strndup(prev_shape_name, prev_shape_name_len); + shapes.*[shape_idx].face_offset = prev_shape.face_offset; + shapes.*[shape_idx].length = face_count -% prev_face_offset; + shape_idx +%= 1; + prev_face_offset = face_count; + } else { + if ((face_count -% prev_face_offset) > @as(c_uint, @bitCast(@as(c_int, 0)))) { + shapes.*[shape_idx].name = my_strndup(prev_shape_name, prev_shape_name_len); + shapes.*[shape_idx].face_offset = prev_face_offset; + shapes.*[shape_idx].length = face_count -% prev_face_offset; + shape_idx +%= 1; + prev_face_offset = face_count; + } + } + prev_shape_name = shape_name; + prev_shape_name_len = shape_name_len; + prev_shape_face_offset = face_count; + } + } + if (commands[i].type == @as(c_uint, @bitCast(COMMAND_F))) { + face_count +%= 1; + } + } + } + if ((face_count -% prev_face_offset) > @as(c_uint, @bitCast(@as(c_int, 0)))) { + var length: c_uint = face_count -% prev_shape_face_offset; + _ = &length; + if (length > @as(c_uint, @bitCast(@as(c_int, 0)))) { + shapes.*[shape_idx].name = my_strndup(prev_shape_name, prev_shape_name_len); + shapes.*[shape_idx].face_offset = prev_face_offset; + shapes.*[shape_idx].length = face_count -% prev_face_offset; + shape_idx +%= 1; + } + } else {} + num_shapes.* = shape_idx; + } + if (commands != null) { + free(@as(?*anyopaque, @ptrCast(commands))); + } + destroy_hash_table(&material_table); + materials_out.* = materials; + num_materials_out.* = num_materials; + return @as(c_int, 0); +} +pub export fn tinyobj_parse_mtl_file(arg_materials_out: [*c][*c]tinyobj_material_t, arg_num_materials_out: [*c]c_uint, arg_filename: [*c]const u8) c_int { + var materials_out = arg_materials_out; + _ = &materials_out; + var num_materials_out = arg_num_materials_out; + _ = &num_materials_out; + var filename = arg_filename; + _ = &filename; + return tinyobj_parse_and_index_mtl_file(materials_out, num_materials_out, filename, null); +} +pub export fn tinyobj_attrib_init(arg_attrib: [*c]tinyobj_attrib_t) void { + var attrib = arg_attrib; + _ = &attrib; + attrib.*.vertices = null; + attrib.*.num_vertices = 0; + attrib.*.normals = null; + attrib.*.num_normals = 0; + attrib.*.texcoords = null; + attrib.*.num_texcoords = 0; + attrib.*.faces = null; + attrib.*.num_faces = 0; + attrib.*.face_num_verts = null; + attrib.*.num_face_num_verts = 0; + attrib.*.material_ids = null; +} +pub export fn tinyobj_attrib_free(arg_attrib: [*c]tinyobj_attrib_t) void { + var attrib = arg_attrib; + _ = &attrib; + if (attrib.*.vertices != null) { + free(@as(?*anyopaque, @ptrCast(attrib.*.vertices))); + } + if (attrib.*.normals != null) { + free(@as(?*anyopaque, @ptrCast(attrib.*.normals))); + } + if (attrib.*.texcoords != null) { + free(@as(?*anyopaque, @ptrCast(attrib.*.texcoords))); + } + if (attrib.*.faces != null) { + free(@as(?*anyopaque, @ptrCast(attrib.*.faces))); + } + if (attrib.*.face_num_verts != null) { + free(@as(?*anyopaque, @ptrCast(attrib.*.face_num_verts))); + } + if (attrib.*.material_ids != null) { + free(@as(?*anyopaque, @ptrCast(attrib.*.material_ids))); + } +} +pub export fn tinyobj_shapes_free(arg_shapes: [*c]tinyobj_shape_t, arg_num_shapes: c_uint) void { + var shapes = arg_shapes; + _ = &shapes; + var num_shapes = arg_num_shapes; + _ = &num_shapes; + var i: c_uint = undefined; + _ = &i; + if (shapes == @as([*c]tinyobj_shape_t, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0))))))) return; + { + i = 0; + while (i < num_shapes) : (i +%= 1) { + if (shapes[i].name != null) { + free(@as(?*anyopaque, @ptrCast(shapes[i].name))); + } + } + } + free(@as(?*anyopaque, @ptrCast(shapes))); +} +pub export fn tinyobj_materials_free(arg_materials: [*c]tinyobj_material_t, arg_num_materials: c_uint) void { + var materials = arg_materials; + _ = &materials; + var num_materials = arg_num_materials; + _ = &num_materials; + var i: c_uint = undefined; + _ = &i; + if (materials == @as([*c]tinyobj_material_t, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0))))))) return; + { + i = 0; + while (i < num_materials) : (i +%= 1) { + if (materials[i].name != null) { + free(@as(?*anyopaque, @ptrCast(materials[i].name))); + } + if (materials[i].ambient_texname != null) { + free(@as(?*anyopaque, @ptrCast(materials[i].ambient_texname))); + } + if (materials[i].diffuse_texname != null) { + free(@as(?*anyopaque, @ptrCast(materials[i].diffuse_texname))); + } + if (materials[i].specular_texname != null) { + free(@as(?*anyopaque, @ptrCast(materials[i].specular_texname))); + } + if (materials[i].specular_highlight_texname != null) { + free(@as(?*anyopaque, @ptrCast(materials[i].specular_highlight_texname))); + } + if (materials[i].bump_texname != null) { + free(@as(?*anyopaque, @ptrCast(materials[i].bump_texname))); + } + if (materials[i].displacement_texname != null) { + free(@as(?*anyopaque, @ptrCast(materials[i].displacement_texname))); + } + if (materials[i].alpha_texname != null) { + free(@as(?*anyopaque, @ptrCast(materials[i].alpha_texname))); + } + } + } + free(@as(?*anyopaque, @ptrCast(materials))); +} +pub extern fn __assert_fail(__assertion: [*c]const u8, __file: [*c]const u8, __line: c_uint, __function: [*c]const u8) noreturn; +pub extern fn __assert_perror_fail(__errnum: c_int, __file: [*c]const u8, __line: c_uint, __function: [*c]const u8) noreturn; +pub extern fn __assert(__assertion: [*c]const u8, __file: [*c]const u8, __line: c_int) noreturn; +pub extern fn __errno_location() [*c]c_int; +pub fn skip_space(arg_token: [*c][*c]const u8) callconv(.C) void { + var token = arg_token; + _ = &token; + while ((@as(c_int, @bitCast(@as(c_uint, token.*[@as(c_uint, @intCast(@as(c_int, 0)))]))) == @as(c_int, ' ')) or (@as(c_int, @bitCast(@as(c_uint, token.*[@as(c_uint, @intCast(@as(c_int, 0)))]))) == @as(c_int, '\t'))) { + token.* += 1; + } +} +pub fn skip_space_and_cr(arg_token: [*c][*c]const u8) callconv(.C) void { + var token = arg_token; + _ = &token; + while (((@as(c_int, @bitCast(@as(c_uint, token.*[@as(c_uint, @intCast(@as(c_int, 0)))]))) == @as(c_int, ' ')) or (@as(c_int, @bitCast(@as(c_uint, token.*[@as(c_uint, @intCast(@as(c_int, 0)))]))) == @as(c_int, '\t'))) or (@as(c_int, @bitCast(@as(c_uint, token.*[@as(c_uint, @intCast(@as(c_int, 0)))]))) == @as(c_int, '\r'))) { + token.* += 1; + } +} +pub fn until_space(arg_token: [*c]const u8) callconv(.C) c_int { + var token = arg_token; + _ = &token; + var p: [*c]const u8 = token; + _ = &p; + while ((((@as(c_int, @bitCast(@as(c_uint, p[@as(c_uint, @intCast(@as(c_int, 0)))]))) != @as(c_int, '\x00')) and (@as(c_int, @bitCast(@as(c_uint, p[@as(c_uint, @intCast(@as(c_int, 0)))]))) != @as(c_int, ' '))) and (@as(c_int, @bitCast(@as(c_uint, p[@as(c_uint, @intCast(@as(c_int, 0)))]))) != @as(c_int, '\t'))) and (@as(c_int, @bitCast(@as(c_uint, p[@as(c_uint, @intCast(@as(c_int, 0)))]))) != @as(c_int, '\r'))) { + p += 1; + } + return @as(c_int, @bitCast(@as(c_int, @truncate(@divExact(@as(c_long, @bitCast(@intFromPtr(p) -% @intFromPtr(token))), @sizeOf(u8)))))); +} +pub fn length_until_newline(arg_token: [*c]const u8, arg_n: c_uint) callconv(.C) c_uint { + var token = arg_token; + _ = &token; + var n = arg_n; + _ = &n; + var len: c_uint = 0; + _ = &len; + { + len = 0; + while (len < (n -% @as(c_uint, @bitCast(@as(c_int, 1))))) : (len +%= 1) { + if (@as(c_int, @bitCast(@as(c_uint, token[len]))) == @as(c_int, '\n')) { + break; + } + if ((@as(c_int, @bitCast(@as(c_uint, token[len]))) == @as(c_int, '\r')) and ((len < (n -% @as(c_uint, @bitCast(@as(c_int, 2))))) and (@as(c_int, @bitCast(@as(c_uint, token[len +% @as(c_uint, @bitCast(@as(c_int, 1)))]))) != @as(c_int, '\n')))) { + break; + } + } + } + return len; +} +pub fn length_until_line_feed(arg_token: [*c]const u8, arg_n: c_uint) callconv(.C) c_uint { + var token = arg_token; + _ = &token; + var n = arg_n; + _ = &n; + var len: c_uint = 0; + _ = &len; + { + len = 0; + while (len < n) : (len +%= 1) { + if ((@as(c_int, @bitCast(@as(c_uint, token[len]))) == @as(c_int, '\n')) or (@as(c_int, @bitCast(@as(c_uint, token[len]))) == @as(c_int, '\r'))) { + break; + } + } + } + return len; +} +pub fn my_atoi(arg_c: [*c]const u8) callconv(.C) c_int { + var c = arg_c; + _ = &c; + var value: c_int = 0; + _ = &value; + var sign: c_int = 1; + _ = &sign; + if ((@as(c_int, @bitCast(@as(c_uint, c.*))) == @as(c_int, '+')) or (@as(c_int, @bitCast(@as(c_uint, c.*))) == @as(c_int, '-'))) { + if (@as(c_int, @bitCast(@as(c_uint, c.*))) == @as(c_int, '-')) { + sign = -@as(c_int, 1); + } + c += 1; + } + while ((@as(c_int, @bitCast(@as(c_uint, c.*))) >= @as(c_int, '0')) and (@as(c_int, @bitCast(@as(c_uint, c.*))) <= @as(c_int, '9'))) { + value *= @as(c_int, 10); + value += @as(c_int, @bitCast(@as(c_uint, c.*))) - @as(c_int, '0'); + c += 1; + } + return value * sign; +} +pub fn fixIndex(arg_idx: c_int, arg_n: c_uint) callconv(.C) c_int { + var idx = arg_idx; + _ = &idx; + var n = arg_n; + _ = &n; + if (idx > @as(c_int, 0)) return idx - @as(c_int, 1); + if (idx == @as(c_int, 0)) return 0; + return @as(c_int, @bitCast(n)) + idx; +} +pub fn parseRawTriple(arg_token: [*c][*c]const u8) callconv(.C) tinyobj_vertex_index_t { + var token = arg_token; + _ = &token; + var vi: tinyobj_vertex_index_t = undefined; + _ = &vi; + vi.v_idx = @as(c_int, @bitCast(@as(c_uint, 2147483648))); + vi.vn_idx = @as(c_int, @bitCast(@as(c_uint, 2147483648))); + vi.vt_idx = @as(c_int, @bitCast(@as(c_uint, 2147483648))); + vi.v_idx = my_atoi(token.*); + while (((((@as(c_int, @bitCast(@as(c_uint, token.*[@as(c_uint, @intCast(@as(c_int, 0)))]))) != @as(c_int, '\x00')) and (@as(c_int, @bitCast(@as(c_uint, token.*[@as(c_uint, @intCast(@as(c_int, 0)))]))) != @as(c_int, '/'))) and (@as(c_int, @bitCast(@as(c_uint, token.*[@as(c_uint, @intCast(@as(c_int, 0)))]))) != @as(c_int, ' '))) and (@as(c_int, @bitCast(@as(c_uint, token.*[@as(c_uint, @intCast(@as(c_int, 0)))]))) != @as(c_int, '\t'))) and (@as(c_int, @bitCast(@as(c_uint, token.*[@as(c_uint, @intCast(@as(c_int, 0)))]))) != @as(c_int, '\r'))) { + token.* += 1; + } + if (@as(c_int, @bitCast(@as(c_uint, token.*[@as(c_uint, @intCast(@as(c_int, 0)))]))) != @as(c_int, '/')) { + return vi; + } + token.* += 1; + if (@as(c_int, @bitCast(@as(c_uint, token.*[@as(c_uint, @intCast(@as(c_int, 0)))]))) == @as(c_int, '/')) { + token.* += 1; + vi.vn_idx = my_atoi(token.*); + while (((((@as(c_int, @bitCast(@as(c_uint, token.*[@as(c_uint, @intCast(@as(c_int, 0)))]))) != @as(c_int, '\x00')) and (@as(c_int, @bitCast(@as(c_uint, token.*[@as(c_uint, @intCast(@as(c_int, 0)))]))) != @as(c_int, '/'))) and (@as(c_int, @bitCast(@as(c_uint, token.*[@as(c_uint, @intCast(@as(c_int, 0)))]))) != @as(c_int, ' '))) and (@as(c_int, @bitCast(@as(c_uint, token.*[@as(c_uint, @intCast(@as(c_int, 0)))]))) != @as(c_int, '\t'))) and (@as(c_int, @bitCast(@as(c_uint, token.*[@as(c_uint, @intCast(@as(c_int, 0)))]))) != @as(c_int, '\r'))) { + token.* += 1; + } + return vi; + } + vi.vt_idx = my_atoi(token.*); + while (((((@as(c_int, @bitCast(@as(c_uint, token.*[@as(c_uint, @intCast(@as(c_int, 0)))]))) != @as(c_int, '\x00')) and (@as(c_int, @bitCast(@as(c_uint, token.*[@as(c_uint, @intCast(@as(c_int, 0)))]))) != @as(c_int, '/'))) and (@as(c_int, @bitCast(@as(c_uint, token.*[@as(c_uint, @intCast(@as(c_int, 0)))]))) != @as(c_int, ' '))) and (@as(c_int, @bitCast(@as(c_uint, token.*[@as(c_uint, @intCast(@as(c_int, 0)))]))) != @as(c_int, '\t'))) and (@as(c_int, @bitCast(@as(c_uint, token.*[@as(c_uint, @intCast(@as(c_int, 0)))]))) != @as(c_int, '\r'))) { + token.* += 1; + } + if (@as(c_int, @bitCast(@as(c_uint, token.*[@as(c_uint, @intCast(@as(c_int, 0)))]))) != @as(c_int, '/')) { + return vi; + } + token.* += 1; + vi.vn_idx = my_atoi(token.*); + while (((((@as(c_int, @bitCast(@as(c_uint, token.*[@as(c_uint, @intCast(@as(c_int, 0)))]))) != @as(c_int, '\x00')) and (@as(c_int, @bitCast(@as(c_uint, token.*[@as(c_uint, @intCast(@as(c_int, 0)))]))) != @as(c_int, '/'))) and (@as(c_int, @bitCast(@as(c_uint, token.*[@as(c_uint, @intCast(@as(c_int, 0)))]))) != @as(c_int, ' '))) and (@as(c_int, @bitCast(@as(c_uint, token.*[@as(c_uint, @intCast(@as(c_int, 0)))]))) != @as(c_int, '\t'))) and (@as(c_int, @bitCast(@as(c_uint, token.*[@as(c_uint, @intCast(@as(c_int, 0)))]))) != @as(c_int, '\r'))) { + token.* += 1; + } + return vi; +} +pub fn parseInt(arg_token: [*c][*c]const u8) callconv(.C) c_int { + var token = arg_token; + _ = &token; + var i: c_int = 0; + _ = &i; + skip_space(token); + i = my_atoi(token.*); + token.* += @as(usize, @bitCast(@as(isize, @intCast(until_space(token.*))))); + return i; +} +// ./external/tinyobj_loader_c.h:334:5: warning: TODO implement translation of stmt class GotoStmtClass + +// ./external/tinyobj_loader_c.h:296:12: warning: unable to translate function, demoted to extern +pub extern fn tryParseDouble(arg_s: [*c]const u8, arg_s_end: [*c]const u8, arg_result: [*c]f64) callconv(.C) c_int; +pub fn parseFloat(arg_token: [*c][*c]const u8) callconv(.C) f32 { + var token = arg_token; + _ = &token; + var end: [*c]const u8 = undefined; + _ = &end; + var val: f64 = 0.0; + _ = &val; + var f: f32 = 0.0; + _ = &f; + skip_space(token); + end = token.* + @as(usize, @bitCast(@as(isize, @intCast(until_space(token.*))))); + val = 0.0; + _ = tryParseDouble(token.*, end, &val); + f = @as(f32, @floatCast(val)); + token.* = end; + return f; +} +pub fn parseFloat2(arg_x: [*c]f32, arg_y: [*c]f32, arg_token: [*c][*c]const u8) callconv(.C) void { + var x = arg_x; + _ = &x; + var y = arg_y; + _ = &y; + var token = arg_token; + _ = &token; + x.* = parseFloat(token); + y.* = parseFloat(token); +} +pub fn parseFloat3(arg_x: [*c]f32, arg_y: [*c]f32, arg_z: [*c]f32, arg_token: [*c][*c]const u8) callconv(.C) void { + var x = arg_x; + _ = &x; + var y = arg_y; + _ = &y; + var z = arg_z; + _ = &z; + var token = arg_token; + _ = &token; + x.* = parseFloat(token); + y.* = parseFloat(token); + z.* = parseFloat(token); +} +pub fn my_strnlen(arg_s: [*c]const u8, arg_n: c_uint) callconv(.C) c_uint { + var s = arg_s; + _ = &s; + var n = arg_n; + _ = &n; + var p: [*c]const u8 = @as([*c]const u8, @ptrCast(@alignCast(memchr(@as(?*const anyopaque, @ptrCast(s)), @as(c_int, 0), @as(c_ulong, @bitCast(@as(c_ulong, n))))))); + _ = &p; + return if (p != null) @as(c_uint, @bitCast(@as(c_int, @truncate(@divExact(@as(c_long, @bitCast(@intFromPtr(p) -% @intFromPtr(s))), @sizeOf(u8)))))) else n; +} +pub fn my_strdup(arg_s: [*c]const u8, arg_max_length: c_uint) callconv(.C) [*c]u8 { + var s = arg_s; + _ = &s; + var max_length = arg_max_length; + _ = &max_length; + var d: [*c]u8 = undefined; + _ = &d; + var len: c_uint = undefined; + _ = &len; + if (s == @as([*c]const u8, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0))))))) return null; + len = length_until_line_feed(s, max_length); + d = @as([*c]u8, @ptrCast(@alignCast(malloc(@as(c_ulong, @bitCast(@as(c_ulong, len +% @as(c_uint, @bitCast(@as(c_int, 1)))))))))); + _ = memcpy(@as(?*anyopaque, @ptrCast(d)), @as(?*const anyopaque, @ptrCast(s)), @as(c_ulong, @bitCast(@as(c_ulong, len)))); + d[len] = '\x00'; + return d; +} +pub fn my_strndup(arg_s: [*c]const u8, arg_len: c_uint) callconv(.C) [*c]u8 { + var s = arg_s; + _ = &s; + var len = arg_len; + _ = &len; + var d: [*c]u8 = undefined; + _ = &d; + var slen: c_uint = undefined; + _ = &slen; + if (s == @as([*c]const u8, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0))))))) return null; + if (len == @as(c_uint, @bitCast(@as(c_int, 0)))) return null; + slen = my_strnlen(s, len); + d = @as([*c]u8, @ptrCast(@alignCast(malloc(@as(c_ulong, @bitCast(@as(c_ulong, slen +% @as(c_uint, @bitCast(@as(c_int, 1)))))))))); + if (!(d != null)) { + return null; + } + _ = memcpy(@as(?*anyopaque, @ptrCast(d)), @as(?*const anyopaque, @ptrCast(s)), @as(c_ulong, @bitCast(@as(c_ulong, slen)))); + d[slen] = '\x00'; + return d; +} +pub export fn dynamic_fgets(arg_buf: [*c][*c]u8, arg_size: [*c]c_uint, arg_file: [*c]FILE) [*c]u8 { + var buf = arg_buf; + _ = &buf; + var size = arg_size; + _ = &size; + var file = arg_file; + _ = &file; + var offset: [*c]u8 = undefined; + _ = &offset; + var ret: [*c]u8 = undefined; + _ = &ret; + var old_size: c_uint = undefined; + _ = &old_size; + if (!((blk: { + const tmp = fgets(buf.*, @as(c_int, @bitCast(size.*)), file); + ret = tmp; + break :blk tmp; + }) != null)) { + return ret; + } + if (@as([*c]u8, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0)))))) != strchr(buf.*, @as(c_int, '\n'))) { + return ret; + } + while (true) { + old_size = size.*; + size.* *%= @as(c_uint, @bitCast(@as(c_int, 2))); + buf.* = @as([*c]u8, @ptrCast(@alignCast(realloc(@as(?*anyopaque, @ptrCast(buf.*)), @as(c_ulong, @bitCast(@as(c_ulong, size.*))))))); + offset = &buf.*[old_size -% @as(c_uint, @bitCast(@as(c_int, 1)))]; + ret = fgets(offset, @as(c_int, @bitCast(old_size +% @as(c_uint, @bitCast(@as(c_int, 1))))), file); + if (!((ret != null) and (@as([*c]u8, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0)))))) == strchr(buf.*, @as(c_int, '\n'))))) break; + } + return ret; +} +pub fn initMaterial(arg_material: [*c]tinyobj_material_t) callconv(.C) void { + var material = arg_material; + _ = &material; + var i: c_int = undefined; + _ = &i; + material.*.name = null; + material.*.ambient_texname = null; + material.*.diffuse_texname = null; + material.*.specular_texname = null; + material.*.specular_highlight_texname = null; + material.*.bump_texname = null; + material.*.displacement_texname = null; + material.*.alpha_texname = null; + { + i = 0; + while (i < @as(c_int, 3)) : (i += 1) { + material.*.ambient[@as(c_uint, @intCast(i))] = 0.0; + material.*.diffuse[@as(c_uint, @intCast(i))] = 0.0; + material.*.specular[@as(c_uint, @intCast(i))] = 0.0; + material.*.transmittance[@as(c_uint, @intCast(i))] = 0.0; + material.*.emission[@as(c_uint, @intCast(i))] = 0.0; + } + } + material.*.illum = 0; + material.*.dissolve = 1.0; + material.*.shininess = 1.0; + material.*.ior = 1.0; +} +pub const struct_hash_table_entry_t = extern struct { + hash: c_ulong = @import("std").mem.zeroes(c_ulong), + filled: c_int = @import("std").mem.zeroes(c_int), + pad0: c_int = @import("std").mem.zeroes(c_int), + value: c_long = @import("std").mem.zeroes(c_long), + next: [*c]struct_hash_table_entry_t = @import("std").mem.zeroes([*c]struct_hash_table_entry_t), +}; +pub const hash_table_entry_t = struct_hash_table_entry_t; +pub const hash_table_t = extern struct { + hashes: [*c]c_ulong = @import("std").mem.zeroes([*c]c_ulong), + entries: [*c]hash_table_entry_t = @import("std").mem.zeroes([*c]hash_table_entry_t), + capacity: c_uint = @import("std").mem.zeroes(c_uint), + n: c_uint = @import("std").mem.zeroes(c_uint), +}; +pub fn hash_djb2(arg_str: [*c]const u8) callconv(.C) c_ulong { + var str = arg_str; + _ = &str; + var hash: c_ulong = @as(c_ulong, @bitCast(@as(c_long, @as(c_int, 5381)))); + _ = &hash; + var c: c_int = undefined; + _ = &c; + while ((blk: { + const tmp = @as(c_int, @bitCast(@as(c_uint, (blk_1: { + const ref = &str; + const tmp_2 = ref.*; + ref.* += 1; + break :blk_1 tmp_2; + }).*))); + c = tmp; + break :blk tmp; + }) != 0) { + hash = ((hash << @intCast(5)) +% hash) +% @as(c_ulong, @bitCast(@as(c_long, c))); + } + return hash; +} +pub fn create_hash_table(arg_start_capacity: c_uint, arg_hash_table: [*c]hash_table_t) callconv(.C) void { + var start_capacity = arg_start_capacity; + _ = &start_capacity; + var hash_table = arg_hash_table; + _ = &hash_table; + if (start_capacity < @as(c_uint, @bitCast(@as(c_int, 1)))) { + start_capacity = 10; + } + hash_table.*.hashes = @as([*c]c_ulong, @ptrCast(@alignCast(malloc(@as(c_ulong, @bitCast(@as(c_ulong, start_capacity))) *% @sizeOf(c_ulong))))); + hash_table.*.entries = @as([*c]hash_table_entry_t, @ptrCast(@alignCast(calloc(@as(c_ulong, @bitCast(@as(c_ulong, start_capacity))), @sizeOf(hash_table_entry_t))))); + hash_table.*.capacity = start_capacity; + hash_table.*.n = 0; +} +pub fn destroy_hash_table(arg_hash_table: [*c]hash_table_t) callconv(.C) void { + var hash_table = arg_hash_table; + _ = &hash_table; + free(@as(?*anyopaque, @ptrCast(hash_table.*.entries))); + free(@as(?*anyopaque, @ptrCast(hash_table.*.hashes))); +} +pub fn hash_table_insert_value(arg_hash: c_ulong, arg_value: c_long, arg_hash_table: [*c]hash_table_t) callconv(.C) c_int { + var hash = arg_hash; + _ = &hash; + var value = arg_value; + _ = &value; + var hash_table = arg_hash_table; + _ = &hash_table; + var start_index: c_uint = @as(c_uint, @bitCast(@as(c_uint, @truncate(hash % @as(c_ulong, @bitCast(@as(c_ulong, hash_table.*.capacity))))))); + _ = &start_index; + var index_1: c_uint = start_index; + _ = &index_1; + var start_entry: [*c]hash_table_entry_t = hash_table.*.entries + start_index; + _ = &start_entry; + var i: c_uint = undefined; + _ = &i; + var entry: [*c]hash_table_entry_t = undefined; + _ = &entry; + { + i = 1; + while (hash_table.*.entries[index_1].filled != 0) : (i +%= 1) { + if (i >= hash_table.*.capacity) return 1; + index_1 = (start_index +% (i *% i)) % hash_table.*.capacity; + } + } + entry = hash_table.*.entries + index_1; + entry.*.hash = hash; + entry.*.filled = 1; + entry.*.value = value; + if (index_1 != start_index) { + entry.*.next = start_entry.*.next; + start_entry.*.next = entry; + } + return 0; +} +pub fn hash_table_insert(arg_hash: c_ulong, arg_value: c_long, arg_hash_table: [*c]hash_table_t) callconv(.C) c_int { + var hash = arg_hash; + _ = &hash; + var value = arg_value; + _ = &value; + var hash_table = arg_hash_table; + _ = &hash_table; + var ret: c_int = hash_table_insert_value(hash, value, hash_table); + _ = &ret; + if (ret == @as(c_int, 0)) { + hash_table.*.hashes[hash_table.*.n] = hash; + hash_table.*.n +%= 1; + } + return ret; +} +pub fn hash_table_find(arg_hash: c_ulong, arg_hash_table: [*c]hash_table_t) callconv(.C) [*c]hash_table_entry_t { + var hash = arg_hash; + _ = &hash; + var hash_table = arg_hash_table; + _ = &hash_table; + var entry: [*c]hash_table_entry_t = hash_table.*.entries + (hash % @as(c_ulong, @bitCast(@as(c_ulong, hash_table.*.capacity)))); + _ = &entry; + while (entry != null) { + if ((entry.*.hash == hash) and (entry.*.filled != 0)) { + return entry; + } + entry = entry.*.next; + } + return null; +} +pub fn hash_table_maybe_grow(arg_new_n: c_uint, arg_hash_table: [*c]hash_table_t) callconv(.C) void { + var new_n = arg_new_n; + _ = &new_n; + var hash_table = arg_hash_table; + _ = &hash_table; + var new_capacity: c_uint = undefined; + _ = &new_capacity; + var new_hash_table: hash_table_t = undefined; + _ = &new_hash_table; + var i: c_uint = undefined; + _ = &i; + if (new_n <= hash_table.*.capacity) { + return; + } + new_capacity = @as(c_uint, @bitCast(@as(c_int, 2))) *% (if ((@as(c_uint, @bitCast(@as(c_int, 2))) *% hash_table.*.capacity) > new_n) hash_table.*.capacity else new_n); + new_hash_table.hashes = blk: { + const tmp = @as([*c]c_ulong, @ptrCast(@alignCast(realloc(@as(?*anyopaque, @ptrCast(hash_table.*.hashes)), @sizeOf(c_ulong) *% @as(c_ulong, @bitCast(@as(c_ulong, new_capacity))))))); + hash_table.*.hashes = tmp; + break :blk tmp; + }; + new_hash_table.entries = @as([*c]hash_table_entry_t, @ptrCast(@alignCast(calloc(@as(c_ulong, @bitCast(@as(c_ulong, new_capacity))), @sizeOf(hash_table_entry_t))))); + new_hash_table.capacity = new_capacity; + new_hash_table.n = hash_table.*.n; + { + i = 0; + while (i < hash_table.*.capacity) : (i +%= 1) { + var entry: [*c]hash_table_entry_t = hash_table_find(hash_table.*.hashes[i], hash_table); + _ = &entry; + _ = hash_table_insert_value(hash_table.*.hashes[i], entry.*.value, &new_hash_table); + } + } + free(@as(?*anyopaque, @ptrCast(hash_table.*.entries))); + hash_table.* = new_hash_table; +} +pub fn hash_table_exists(arg_name: [*c]const u8, arg_hash_table: [*c]hash_table_t) callconv(.C) c_int { + var name = arg_name; + _ = &name; + var hash_table = arg_hash_table; + _ = &hash_table; + return @intFromBool(hash_table_find(hash_djb2(@as([*c]const u8, @ptrCast(@alignCast(name)))), hash_table) != @as([*c]hash_table_entry_t, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0))))))); +} +pub fn hash_table_set(arg_name: [*c]const u8, arg_val: c_uint, arg_hash_table: [*c]hash_table_t) callconv(.C) void { + var name = arg_name; + _ = &name; + var val = arg_val; + _ = &val; + var hash_table = arg_hash_table; + _ = &hash_table; + var hash: c_ulong = hash_djb2(@as([*c]const u8, @ptrCast(@alignCast(name)))); + _ = &hash; + var entry: [*c]hash_table_entry_t = hash_table_find(hash, hash_table); + _ = &entry; + if (entry != null) { + entry.*.value = @as(c_long, @bitCast(@as(c_ulong, val))); + return; + } + while (true) { + hash_table_maybe_grow(hash_table.*.n +% @as(c_uint, @bitCast(@as(c_int, 1))), hash_table); + if (!(hash_table_insert(hash, @as(c_long, @bitCast(@as(c_ulong, val))), hash_table) != @as(c_int, 0))) break; + } +} +pub fn hash_table_get(arg_name: [*c]const u8, arg_hash_table: [*c]hash_table_t) callconv(.C) c_long { + var name = arg_name; + _ = &name; + var hash_table = arg_hash_table; + _ = &hash_table; + var ret: [*c]hash_table_entry_t = hash_table_find(hash_djb2(@as([*c]const u8, @ptrCast(@alignCast(name)))), hash_table); + _ = &ret; + return ret.*.value; +} +pub fn tinyobj_material_add(arg_prev: [*c]tinyobj_material_t, arg_num_materials: c_uint, arg_new_mat: [*c]tinyobj_material_t) callconv(.C) [*c]tinyobj_material_t { + var prev = arg_prev; + _ = &prev; + var num_materials = arg_num_materials; + _ = &num_materials; + var new_mat = arg_new_mat; + _ = &new_mat; + var dst: [*c]tinyobj_material_t = undefined; + _ = &dst; + dst = @as([*c]tinyobj_material_t, @ptrCast(@alignCast(realloc(@as(?*anyopaque, @ptrCast(prev)), @sizeOf(tinyobj_material_t) *% @as(c_ulong, @bitCast(@as(c_ulong, num_materials +% @as(c_uint, @bitCast(@as(c_int, 1)))))))))); + dst[num_materials] = new_mat.*; + return dst; +} +pub fn tinyobj_parse_and_index_mtl_file(arg_materials_out: [*c][*c]tinyobj_material_t, arg_num_materials_out: [*c]c_uint, arg_filename: [*c]const u8, arg_material_table: [*c]hash_table_t) callconv(.C) c_int { + var materials_out = arg_materials_out; + _ = &materials_out; + var num_materials_out = arg_num_materials_out; + _ = &num_materials_out; + var filename = arg_filename; + _ = &filename; + var material_table = arg_material_table; + _ = &material_table; + var material: tinyobj_material_t = undefined; + _ = &material; + var buffer_size: c_uint = 128; + _ = &buffer_size; + var linebuf: [*c]u8 = undefined; + _ = &linebuf; + var fp: [*c]FILE = undefined; + _ = &fp; + var num_materials: c_uint = 0; + _ = &num_materials; + var materials: [*c]tinyobj_material_t = null; + _ = &materials; + var has_previous_material: c_int = 0; + _ = &has_previous_material; + var line_end: [*c]const u8 = null; + _ = &line_end; + if (materials_out == @as([*c][*c]tinyobj_material_t, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0))))))) { + return -@as(c_int, 2); + } + if (num_materials_out == @as([*c]c_uint, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0))))))) { + return -@as(c_int, 2); + } + materials_out.* = null; + num_materials_out.* = 0; + fp = fopen(filename, "rt"); + if (!(fp != null)) { + _ = fprintf(stderr, "TINYOBJ: Error reading file '%s': %s (%d)\n", filename, strerror(__errno_location().*), __errno_location().*); + return -@as(c_int, 3); + } + initMaterial(&material); + linebuf = @as([*c]u8, @ptrCast(@alignCast(malloc(@as(c_ulong, @bitCast(@as(c_ulong, buffer_size))))))); + while (@as([*c]u8, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0)))))) != dynamic_fgets(&linebuf, &buffer_size, fp)) { + var token: [*c]const u8 = linebuf; + _ = &token; + line_end = token + strlen(token); + token += @as([*c]const u8, @ptrFromInt(strspn(token, " \t"))); + _ = blk: { + _ = @sizeOf(c_int); + break :blk blk_1: { + break :blk_1 if (token != null) {} else { + __assert_fail("token", "./external/tinyobj_loader_c.h", @as(c_uint, @bitCast(@as(c_int, 767))), "int tinyobj_parse_and_index_mtl_file(tinyobj_material_t **, unsigned int *, const char *, hash_table_t *)"); + }; + }; + }; + if (@as(c_int, @bitCast(@as(c_uint, token[@as(c_uint, @intCast(@as(c_int, 0)))]))) == @as(c_int, '\x00')) continue; + if (@as(c_int, @bitCast(@as(c_uint, token[@as(c_uint, @intCast(@as(c_int, 0)))]))) == @as(c_int, '#')) continue; + if ((@as(c_int, 0) == strncmp(token, "newmtl", @as(c_ulong, @bitCast(@as(c_long, @as(c_int, 6)))))) and ((@as(c_int, @bitCast(@as(c_uint, token[@as(c_uint, @intCast(@as(c_int, 6)))]))) == @as(c_int, ' ')) or (@as(c_int, @bitCast(@as(c_uint, token[@as(c_uint, @intCast(@as(c_int, 6)))]))) == @as(c_int, '\t')))) { + var namebuf: [4096]u8 = undefined; + _ = &namebuf; + if (has_previous_material != 0) { + materials = tinyobj_material_add(materials, num_materials, &material); + num_materials +%= 1; + } else { + has_previous_material = 1; + } + initMaterial(&material); + token += @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 7))))); + _ = sscanf(token, "%s", @as([*c]u8, @ptrCast(@alignCast(&namebuf)))); + material.name = my_strdup(@as([*c]u8, @ptrCast(@alignCast(&namebuf))), @as(c_uint, @bitCast(@as(c_int, @truncate(@divExact(@as(c_long, @bitCast(@intFromPtr(line_end) -% @intFromPtr(token))), @sizeOf(u8))))))); + if (material_table != null) { + hash_table_set(material.name, num_materials, material_table); + } + continue; + } + if (((@as(c_int, @bitCast(@as(c_uint, token[@as(c_uint, @intCast(@as(c_int, 0)))]))) == @as(c_int, 'K')) and (@as(c_int, @bitCast(@as(c_uint, token[@as(c_uint, @intCast(@as(c_int, 1)))]))) == @as(c_int, 'a'))) and ((@as(c_int, @bitCast(@as(c_uint, token[@as(c_uint, @intCast(@as(c_int, 2)))]))) == @as(c_int, ' ')) or (@as(c_int, @bitCast(@as(c_uint, token[@as(c_uint, @intCast(@as(c_int, 2)))]))) == @as(c_int, '\t')))) { + var r: f32 = undefined; + _ = &r; + var g: f32 = undefined; + _ = &g; + var b: f32 = undefined; + _ = &b; + token += @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 2))))); + parseFloat3(&r, &g, &b, &token); + material.ambient[@as(c_uint, @intCast(@as(c_int, 0)))] = r; + material.ambient[@as(c_uint, @intCast(@as(c_int, 1)))] = g; + material.ambient[@as(c_uint, @intCast(@as(c_int, 2)))] = b; + continue; + } + if (((@as(c_int, @bitCast(@as(c_uint, token[@as(c_uint, @intCast(@as(c_int, 0)))]))) == @as(c_int, 'K')) and (@as(c_int, @bitCast(@as(c_uint, token[@as(c_uint, @intCast(@as(c_int, 1)))]))) == @as(c_int, 'd'))) and ((@as(c_int, @bitCast(@as(c_uint, token[@as(c_uint, @intCast(@as(c_int, 2)))]))) == @as(c_int, ' ')) or (@as(c_int, @bitCast(@as(c_uint, token[@as(c_uint, @intCast(@as(c_int, 2)))]))) == @as(c_int, '\t')))) { + var r: f32 = undefined; + _ = &r; + var g: f32 = undefined; + _ = &g; + var b: f32 = undefined; + _ = &b; + token += @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 2))))); + parseFloat3(&r, &g, &b, &token); + material.diffuse[@as(c_uint, @intCast(@as(c_int, 0)))] = r; + material.diffuse[@as(c_uint, @intCast(@as(c_int, 1)))] = g; + material.diffuse[@as(c_uint, @intCast(@as(c_int, 2)))] = b; + continue; + } + if (((@as(c_int, @bitCast(@as(c_uint, token[@as(c_uint, @intCast(@as(c_int, 0)))]))) == @as(c_int, 'K')) and (@as(c_int, @bitCast(@as(c_uint, token[@as(c_uint, @intCast(@as(c_int, 1)))]))) == @as(c_int, 's'))) and ((@as(c_int, @bitCast(@as(c_uint, token[@as(c_uint, @intCast(@as(c_int, 2)))]))) == @as(c_int, ' ')) or (@as(c_int, @bitCast(@as(c_uint, token[@as(c_uint, @intCast(@as(c_int, 2)))]))) == @as(c_int, '\t')))) { + var r: f32 = undefined; + _ = &r; + var g: f32 = undefined; + _ = &g; + var b: f32 = undefined; + _ = &b; + token += @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 2))))); + parseFloat3(&r, &g, &b, &token); + material.specular[@as(c_uint, @intCast(@as(c_int, 0)))] = r; + material.specular[@as(c_uint, @intCast(@as(c_int, 1)))] = g; + material.specular[@as(c_uint, @intCast(@as(c_int, 2)))] = b; + continue; + } + if (((@as(c_int, @bitCast(@as(c_uint, token[@as(c_uint, @intCast(@as(c_int, 0)))]))) == @as(c_int, 'K')) and (@as(c_int, @bitCast(@as(c_uint, token[@as(c_uint, @intCast(@as(c_int, 1)))]))) == @as(c_int, 't'))) and ((@as(c_int, @bitCast(@as(c_uint, token[@as(c_uint, @intCast(@as(c_int, 2)))]))) == @as(c_int, ' ')) or (@as(c_int, @bitCast(@as(c_uint, token[@as(c_uint, @intCast(@as(c_int, 2)))]))) == @as(c_int, '\t')))) { + var r: f32 = undefined; + _ = &r; + var g: f32 = undefined; + _ = &g; + var b: f32 = undefined; + _ = &b; + token += @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 2))))); + parseFloat3(&r, &g, &b, &token); + material.transmittance[@as(c_uint, @intCast(@as(c_int, 0)))] = r; + material.transmittance[@as(c_uint, @intCast(@as(c_int, 1)))] = g; + material.transmittance[@as(c_uint, @intCast(@as(c_int, 2)))] = b; + continue; + } + if (((@as(c_int, @bitCast(@as(c_uint, token[@as(c_uint, @intCast(@as(c_int, 0)))]))) == @as(c_int, 'N')) and (@as(c_int, @bitCast(@as(c_uint, token[@as(c_uint, @intCast(@as(c_int, 1)))]))) == @as(c_int, 'i'))) and ((@as(c_int, @bitCast(@as(c_uint, token[@as(c_uint, @intCast(@as(c_int, 2)))]))) == @as(c_int, ' ')) or (@as(c_int, @bitCast(@as(c_uint, token[@as(c_uint, @intCast(@as(c_int, 2)))]))) == @as(c_int, '\t')))) { + token += @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 2))))); + material.ior = parseFloat(&token); + continue; + } + if (((@as(c_int, @bitCast(@as(c_uint, token[@as(c_uint, @intCast(@as(c_int, 0)))]))) == @as(c_int, 'K')) and (@as(c_int, @bitCast(@as(c_uint, token[@as(c_uint, @intCast(@as(c_int, 1)))]))) == @as(c_int, 'e'))) and ((@as(c_int, @bitCast(@as(c_uint, token[@as(c_uint, @intCast(@as(c_int, 2)))]))) == @as(c_int, ' ')) or (@as(c_int, @bitCast(@as(c_uint, token[@as(c_uint, @intCast(@as(c_int, 2)))]))) == @as(c_int, '\t')))) { + var r: f32 = undefined; + _ = &r; + var g: f32 = undefined; + _ = &g; + var b: f32 = undefined; + _ = &b; + token += @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 2))))); + parseFloat3(&r, &g, &b, &token); + material.emission[@as(c_uint, @intCast(@as(c_int, 0)))] = r; + material.emission[@as(c_uint, @intCast(@as(c_int, 1)))] = g; + material.emission[@as(c_uint, @intCast(@as(c_int, 2)))] = b; + continue; + } + if (((@as(c_int, @bitCast(@as(c_uint, token[@as(c_uint, @intCast(@as(c_int, 0)))]))) == @as(c_int, 'N')) and (@as(c_int, @bitCast(@as(c_uint, token[@as(c_uint, @intCast(@as(c_int, 1)))]))) == @as(c_int, 's'))) and ((@as(c_int, @bitCast(@as(c_uint, token[@as(c_uint, @intCast(@as(c_int, 2)))]))) == @as(c_int, ' ')) or (@as(c_int, @bitCast(@as(c_uint, token[@as(c_uint, @intCast(@as(c_int, 2)))]))) == @as(c_int, '\t')))) { + token += @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 2))))); + material.shininess = parseFloat(&token); + continue; + } + if ((@as(c_int, 0) == strncmp(token, "illum", @as(c_ulong, @bitCast(@as(c_long, @as(c_int, 5)))))) and ((@as(c_int, @bitCast(@as(c_uint, token[@as(c_uint, @intCast(@as(c_int, 5)))]))) == @as(c_int, ' ')) or (@as(c_int, @bitCast(@as(c_uint, token[@as(c_uint, @intCast(@as(c_int, 5)))]))) == @as(c_int, '\t')))) { + token += @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 6))))); + material.illum = parseInt(&token); + continue; + } + if ((@as(c_int, @bitCast(@as(c_uint, token[@as(c_uint, @intCast(@as(c_int, 0)))]))) == @as(c_int, 'd')) and ((@as(c_int, @bitCast(@as(c_uint, token[@as(c_uint, @intCast(@as(c_int, 1)))]))) == @as(c_int, ' ')) or (@as(c_int, @bitCast(@as(c_uint, token[@as(c_uint, @intCast(@as(c_int, 1)))]))) == @as(c_int, '\t')))) { + token += @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 1))))); + material.dissolve = parseFloat(&token); + continue; + } + if (((@as(c_int, @bitCast(@as(c_uint, token[@as(c_uint, @intCast(@as(c_int, 0)))]))) == @as(c_int, 'T')) and (@as(c_int, @bitCast(@as(c_uint, token[@as(c_uint, @intCast(@as(c_int, 1)))]))) == @as(c_int, 'r'))) and ((@as(c_int, @bitCast(@as(c_uint, token[@as(c_uint, @intCast(@as(c_int, 2)))]))) == @as(c_int, ' ')) or (@as(c_int, @bitCast(@as(c_uint, token[@as(c_uint, @intCast(@as(c_int, 2)))]))) == @as(c_int, '\t')))) { + token += @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 2))))); + material.dissolve = 1.0 - parseFloat(&token); + continue; + } + if ((@as(c_int, 0) == strncmp(token, "map_Ka", @as(c_ulong, @bitCast(@as(c_long, @as(c_int, 6)))))) and ((@as(c_int, @bitCast(@as(c_uint, token[@as(c_uint, @intCast(@as(c_int, 6)))]))) == @as(c_int, ' ')) or (@as(c_int, @bitCast(@as(c_uint, token[@as(c_uint, @intCast(@as(c_int, 6)))]))) == @as(c_int, '\t')))) { + token += @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 7))))); + material.ambient_texname = my_strdup(token, @as(c_uint, @bitCast(@as(c_int, @truncate(@divExact(@as(c_long, @bitCast(@intFromPtr(line_end) -% @intFromPtr(token))), @sizeOf(u8))))))); + continue; + } + if ((@as(c_int, 0) == strncmp(token, "map_Kd", @as(c_ulong, @bitCast(@as(c_long, @as(c_int, 6)))))) and ((@as(c_int, @bitCast(@as(c_uint, token[@as(c_uint, @intCast(@as(c_int, 6)))]))) == @as(c_int, ' ')) or (@as(c_int, @bitCast(@as(c_uint, token[@as(c_uint, @intCast(@as(c_int, 6)))]))) == @as(c_int, '\t')))) { + token += @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 7))))); + material.diffuse_texname = my_strdup(token, @as(c_uint, @bitCast(@as(c_int, @truncate(@divExact(@as(c_long, @bitCast(@intFromPtr(line_end) -% @intFromPtr(token))), @sizeOf(u8))))))); + continue; + } + if ((@as(c_int, 0) == strncmp(token, "map_Ks", @as(c_ulong, @bitCast(@as(c_long, @as(c_int, 6)))))) and ((@as(c_int, @bitCast(@as(c_uint, token[@as(c_uint, @intCast(@as(c_int, 6)))]))) == @as(c_int, ' ')) or (@as(c_int, @bitCast(@as(c_uint, token[@as(c_uint, @intCast(@as(c_int, 6)))]))) == @as(c_int, '\t')))) { + token += @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 7))))); + material.specular_texname = my_strdup(token, @as(c_uint, @bitCast(@as(c_int, @truncate(@divExact(@as(c_long, @bitCast(@intFromPtr(line_end) -% @intFromPtr(token))), @sizeOf(u8))))))); + continue; + } + if ((@as(c_int, 0) == strncmp(token, "map_Ns", @as(c_ulong, @bitCast(@as(c_long, @as(c_int, 6)))))) and ((@as(c_int, @bitCast(@as(c_uint, token[@as(c_uint, @intCast(@as(c_int, 6)))]))) == @as(c_int, ' ')) or (@as(c_int, @bitCast(@as(c_uint, token[@as(c_uint, @intCast(@as(c_int, 6)))]))) == @as(c_int, '\t')))) { + token += @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 7))))); + material.specular_highlight_texname = my_strdup(token, @as(c_uint, @bitCast(@as(c_int, @truncate(@divExact(@as(c_long, @bitCast(@intFromPtr(line_end) -% @intFromPtr(token))), @sizeOf(u8))))))); + continue; + } + if ((@as(c_int, 0) == strncmp(token, "map_bump", @as(c_ulong, @bitCast(@as(c_long, @as(c_int, 8)))))) and ((@as(c_int, @bitCast(@as(c_uint, token[@as(c_uint, @intCast(@as(c_int, 8)))]))) == @as(c_int, ' ')) or (@as(c_int, @bitCast(@as(c_uint, token[@as(c_uint, @intCast(@as(c_int, 8)))]))) == @as(c_int, '\t')))) { + token += @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 9))))); + material.bump_texname = my_strdup(token, @as(c_uint, @bitCast(@as(c_int, @truncate(@divExact(@as(c_long, @bitCast(@intFromPtr(line_end) -% @intFromPtr(token))), @sizeOf(u8))))))); + continue; + } + if ((@as(c_int, 0) == strncmp(token, "map_d", @as(c_ulong, @bitCast(@as(c_long, @as(c_int, 5)))))) and ((@as(c_int, @bitCast(@as(c_uint, token[@as(c_uint, @intCast(@as(c_int, 5)))]))) == @as(c_int, ' ')) or (@as(c_int, @bitCast(@as(c_uint, token[@as(c_uint, @intCast(@as(c_int, 5)))]))) == @as(c_int, '\t')))) { + token += @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 6))))); + material.alpha_texname = my_strdup(token, @as(c_uint, @bitCast(@as(c_int, @truncate(@divExact(@as(c_long, @bitCast(@intFromPtr(line_end) -% @intFromPtr(token))), @sizeOf(u8))))))); + continue; + } + if ((@as(c_int, 0) == strncmp(token, "bump", @as(c_ulong, @bitCast(@as(c_long, @as(c_int, 4)))))) and ((@as(c_int, @bitCast(@as(c_uint, token[@as(c_uint, @intCast(@as(c_int, 4)))]))) == @as(c_int, ' ')) or (@as(c_int, @bitCast(@as(c_uint, token[@as(c_uint, @intCast(@as(c_int, 4)))]))) == @as(c_int, '\t')))) { + token += @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 5))))); + material.bump_texname = my_strdup(token, @as(c_uint, @bitCast(@as(c_int, @truncate(@divExact(@as(c_long, @bitCast(@intFromPtr(line_end) -% @intFromPtr(token))), @sizeOf(u8))))))); + continue; + } + if ((@as(c_int, 0) == strncmp(token, "disp", @as(c_ulong, @bitCast(@as(c_long, @as(c_int, 4)))))) and ((@as(c_int, @bitCast(@as(c_uint, token[@as(c_uint, @intCast(@as(c_int, 4)))]))) == @as(c_int, ' ')) or (@as(c_int, @bitCast(@as(c_uint, token[@as(c_uint, @intCast(@as(c_int, 4)))]))) == @as(c_int, '\t')))) { + token += @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 5))))); + material.displacement_texname = my_strdup(token, @as(c_uint, @bitCast(@as(c_int, @truncate(@divExact(@as(c_long, @bitCast(@intFromPtr(line_end) -% @intFromPtr(token))), @sizeOf(u8))))))); + continue; + } + } + _ = fclose(fp); + if (material.name != null) { + materials = tinyobj_material_add(materials, num_materials, &material); + num_materials +%= 1; + } + num_materials_out.* = num_materials; + materials_out.* = materials; + if (linebuf != null) { + free(@as(?*anyopaque, @ptrCast(linebuf))); + } + return @as(c_int, 0); +} +pub const COMMAND_EMPTY: c_int = 0; +pub const COMMAND_V: c_int = 1; +pub const COMMAND_VN: c_int = 2; +pub const COMMAND_VT: c_int = 3; +pub const COMMAND_F: c_int = 4; +pub const COMMAND_G: c_int = 5; +pub const COMMAND_O: c_int = 6; +pub const COMMAND_USEMTL: c_int = 7; +pub const COMMAND_MTLLIB: c_int = 8; +pub const CommandType = c_uint; +pub const Command = extern struct { + vx: f32 = @import("std").mem.zeroes(f32), + vy: f32 = @import("std").mem.zeroes(f32), + vz: f32 = @import("std").mem.zeroes(f32), + nx: f32 = @import("std").mem.zeroes(f32), + ny: f32 = @import("std").mem.zeroes(f32), + nz: f32 = @import("std").mem.zeroes(f32), + tx: f32 = @import("std").mem.zeroes(f32), + ty: f32 = @import("std").mem.zeroes(f32), + f: [16]tinyobj_vertex_index_t = @import("std").mem.zeroes([16]tinyobj_vertex_index_t), + num_f: c_uint = @import("std").mem.zeroes(c_uint), + f_num_verts: [16]c_int = @import("std").mem.zeroes([16]c_int), + num_f_num_verts: c_uint = @import("std").mem.zeroes(c_uint), + group_name: [*c]const u8 = @import("std").mem.zeroes([*c]const u8), + group_name_len: c_uint = @import("std").mem.zeroes(c_uint), + pad0: c_int = @import("std").mem.zeroes(c_int), + object_name: [*c]const u8 = @import("std").mem.zeroes([*c]const u8), + object_name_len: c_uint = @import("std").mem.zeroes(c_uint), + pad1: c_int = @import("std").mem.zeroes(c_int), + material_name: [*c]const u8 = @import("std").mem.zeroes([*c]const u8), + material_name_len: c_uint = @import("std").mem.zeroes(c_uint), + pad2: c_int = @import("std").mem.zeroes(c_int), + mtllib_name: [*c]const u8 = @import("std").mem.zeroes([*c]const u8), + mtllib_name_len: c_uint = @import("std").mem.zeroes(c_uint), + type: CommandType = @import("std").mem.zeroes(CommandType), +}; +pub fn parseLine(arg_command: [*c]Command, arg_p: [*c]const u8, arg_p_len: c_uint, arg_triangulate: c_int) callconv(.C) c_int { + var command = arg_command; + _ = &command; + var p = arg_p; + _ = &p; + var p_len = arg_p_len; + _ = &p_len; + var triangulate = arg_triangulate; + _ = &triangulate; + var linebuf: [4096]u8 = undefined; + _ = &linebuf; + var token: [*c]const u8 = undefined; + _ = &token; + _ = blk: { + _ = @sizeOf(c_int); + break :blk blk_1: { + break :blk_1 if (p_len < @as(c_uint, @bitCast(@as(c_int, 4095)))) {} else { + __assert_fail("p_len < 4095", "./external/tinyobj_loader_c.h", @as(c_uint, @bitCast(@as(c_int, 1023))), "int parseLine(Command *, const char *, unsigned int, int)"); + }; + }; + }; + _ = memcpy(@as(?*anyopaque, @ptrCast(@as([*c]u8, @ptrCast(@alignCast(&linebuf))))), @as(?*const anyopaque, @ptrCast(p)), @as(c_ulong, @bitCast(@as(c_ulong, p_len)))); + linebuf[p_len] = '\x00'; + token = @as([*c]u8, @ptrCast(@alignCast(&linebuf))); + command.*.type = @as(c_uint, @bitCast(COMMAND_EMPTY)); + skip_space(&token); + _ = blk: { + _ = @sizeOf(c_int); + break :blk blk_1: { + break :blk_1 if (token != null) {} else { + __assert_fail("token", "./external/tinyobj_loader_c.h", @as(c_uint, @bitCast(@as(c_int, 1035))), "int parseLine(Command *, const char *, unsigned int, int)"); + }; + }; + }; + if (@as(c_int, @bitCast(@as(c_uint, token[@as(c_uint, @intCast(@as(c_int, 0)))]))) == @as(c_int, '\x00')) { + return 0; + } + if (@as(c_int, @bitCast(@as(c_uint, token[@as(c_uint, @intCast(@as(c_int, 0)))]))) == @as(c_int, '#')) { + return 0; + } + if ((@as(c_int, @bitCast(@as(c_uint, token[@as(c_uint, @intCast(@as(c_int, 0)))]))) == @as(c_int, 'v')) and ((@as(c_int, @bitCast(@as(c_uint, token[@as(c_uint, @intCast(@as(c_int, 1)))]))) == @as(c_int, ' ')) or (@as(c_int, @bitCast(@as(c_uint, token[@as(c_uint, @intCast(@as(c_int, 1)))]))) == @as(c_int, '\t')))) { + var x: f32 = undefined; + _ = &x; + var y: f32 = undefined; + _ = &y; + var z: f32 = undefined; + _ = &z; + token += @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 2))))); + parseFloat3(&x, &y, &z, &token); + command.*.vx = x; + command.*.vy = y; + command.*.vz = z; + command.*.type = @as(c_uint, @bitCast(COMMAND_V)); + return 1; + } + if (((@as(c_int, @bitCast(@as(c_uint, token[@as(c_uint, @intCast(@as(c_int, 0)))]))) == @as(c_int, 'v')) and (@as(c_int, @bitCast(@as(c_uint, token[@as(c_uint, @intCast(@as(c_int, 1)))]))) == @as(c_int, 'n'))) and ((@as(c_int, @bitCast(@as(c_uint, token[@as(c_uint, @intCast(@as(c_int, 2)))]))) == @as(c_int, ' ')) or (@as(c_int, @bitCast(@as(c_uint, token[@as(c_uint, @intCast(@as(c_int, 2)))]))) == @as(c_int, '\t')))) { + var x: f32 = undefined; + _ = &x; + var y: f32 = undefined; + _ = &y; + var z: f32 = undefined; + _ = &z; + token += @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 3))))); + parseFloat3(&x, &y, &z, &token); + command.*.nx = x; + command.*.ny = y; + command.*.nz = z; + command.*.type = @as(c_uint, @bitCast(COMMAND_VN)); + return 1; + } + if (((@as(c_int, @bitCast(@as(c_uint, token[@as(c_uint, @intCast(@as(c_int, 0)))]))) == @as(c_int, 'v')) and (@as(c_int, @bitCast(@as(c_uint, token[@as(c_uint, @intCast(@as(c_int, 1)))]))) == @as(c_int, 't'))) and ((@as(c_int, @bitCast(@as(c_uint, token[@as(c_uint, @intCast(@as(c_int, 2)))]))) == @as(c_int, ' ')) or (@as(c_int, @bitCast(@as(c_uint, token[@as(c_uint, @intCast(@as(c_int, 2)))]))) == @as(c_int, '\t')))) { + var x: f32 = undefined; + _ = &x; + var y: f32 = undefined; + _ = &y; + token += @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 3))))); + parseFloat2(&x, &y, &token); + command.*.tx = x; + command.*.ty = y; + command.*.type = @as(c_uint, @bitCast(COMMAND_VT)); + return 1; + } + if ((@as(c_int, @bitCast(@as(c_uint, token[@as(c_uint, @intCast(@as(c_int, 0)))]))) == @as(c_int, 'f')) and ((@as(c_int, @bitCast(@as(c_uint, token[@as(c_uint, @intCast(@as(c_int, 1)))]))) == @as(c_int, ' ')) or (@as(c_int, @bitCast(@as(c_uint, token[@as(c_uint, @intCast(@as(c_int, 1)))]))) == @as(c_int, '\t')))) { + var num_f: c_uint = 0; + _ = &num_f; + var f: [16]tinyobj_vertex_index_t = undefined; + _ = &f; + token += @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 2))))); + skip_space(&token); + while (!(((@as(c_int, @bitCast(@as(c_uint, token[@as(c_uint, @intCast(@as(c_int, 0)))]))) == @as(c_int, '\r')) or (@as(c_int, @bitCast(@as(c_uint, token[@as(c_uint, @intCast(@as(c_int, 0)))]))) == @as(c_int, '\n'))) or (@as(c_int, @bitCast(@as(c_uint, token[@as(c_uint, @intCast(@as(c_int, 0)))]))) == @as(c_int, '\x00')))) { + var vi: tinyobj_vertex_index_t = parseRawTriple(&token); + _ = &vi; + skip_space_and_cr(&token); + f[num_f] = vi; + num_f +%= 1; + } + command.*.type = @as(c_uint, @bitCast(COMMAND_F)); + if (triangulate != 0) { + var k: c_uint = undefined; + _ = &k; + var n: c_uint = 0; + _ = &n; + var @"i0": tinyobj_vertex_index_t = f[@as(c_uint, @intCast(@as(c_int, 0)))]; + _ = &@"i0"; + var @"i1": tinyobj_vertex_index_t = undefined; + _ = &@"i1"; + var @"i2": tinyobj_vertex_index_t = f[@as(c_uint, @intCast(@as(c_int, 1)))]; + _ = &@"i2"; + _ = blk: { + _ = @sizeOf(c_int); + break :blk blk_1: { + break :blk_1 if ((@as(c_uint, @bitCast(@as(c_int, 3))) *% num_f) < @as(c_uint, @bitCast(@as(c_int, 16)))) {} else { + __assert_fail("3 * num_f < TINYOBJ_MAX_FACES_PER_F_LINE", "./external/tinyobj_loader_c.h", @as(c_uint, @bitCast(@as(c_int, 1105))), "int parseLine(Command *, const char *, unsigned int, int)"); + }; + }; + }; + { + k = 2; + while (k < num_f) : (k +%= 1) { + @"i1" = @"i2"; + @"i2" = f[k]; + command.*.f[(@as(c_uint, @bitCast(@as(c_int, 3))) *% n) +% @as(c_uint, @bitCast(@as(c_int, 0)))] = @"i0"; + command.*.f[(@as(c_uint, @bitCast(@as(c_int, 3))) *% n) +% @as(c_uint, @bitCast(@as(c_int, 1)))] = @"i1"; + command.*.f[(@as(c_uint, @bitCast(@as(c_int, 3))) *% n) +% @as(c_uint, @bitCast(@as(c_int, 2)))] = @"i2"; + command.*.f_num_verts[n] = 3; + n +%= 1; + } + } + command.*.num_f = @as(c_uint, @bitCast(@as(c_int, 3))) *% n; + command.*.num_f_num_verts = n; + } else { + var k: c_uint = 0; + _ = &k; + _ = blk: { + _ = @sizeOf(c_int); + break :blk blk_1: { + break :blk_1 if (num_f < @as(c_uint, @bitCast(@as(c_int, 16)))) {} else { + __assert_fail("num_f < TINYOBJ_MAX_FACES_PER_F_LINE", "./external/tinyobj_loader_c.h", @as(c_uint, @bitCast(@as(c_int, 1122))), "int parseLine(Command *, const char *, unsigned int, int)"); + }; + }; + }; + { + k = 0; + while (k < num_f) : (k +%= 1) { + command.*.f[k] = f[k]; + } + } + command.*.num_f = num_f; + command.*.f_num_verts[@as(c_uint, @intCast(@as(c_int, 0)))] = @as(c_int, @bitCast(num_f)); + command.*.num_f_num_verts = 1; + } + return 1; + } + if ((@as(c_int, 0) == strncmp(token, "usemtl", @as(c_ulong, @bitCast(@as(c_long, @as(c_int, 6)))))) and ((@as(c_int, @bitCast(@as(c_uint, token[@as(c_uint, @intCast(@as(c_int, 6)))]))) == @as(c_int, ' ')) or (@as(c_int, @bitCast(@as(c_uint, token[@as(c_uint, @intCast(@as(c_int, 6)))]))) == @as(c_int, '\t')))) { + token += @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 7))))); + skip_space(&token); + command.*.material_name = p + @as(usize, @bitCast(@as(isize, @intCast(@divExact(@as(c_long, @bitCast(@intFromPtr(token) -% @intFromPtr(@as([*c]u8, @ptrCast(@alignCast(&linebuf)))))), @sizeOf(u8)))))); + command.*.material_name_len = length_until_newline(token, (p_len -% @as(c_uint, @bitCast(@as(c_int, @truncate(@divExact(@as(c_long, @bitCast(@intFromPtr(token) -% @intFromPtr(@as([*c]u8, @ptrCast(@alignCast(&linebuf)))))), @sizeOf(u8))))))) +% @as(c_uint, @bitCast(@as(c_int, 1)))); + command.*.type = @as(c_uint, @bitCast(COMMAND_USEMTL)); + return 1; + } + if ((@as(c_int, 0) == strncmp(token, "mtllib", @as(c_ulong, @bitCast(@as(c_long, @as(c_int, 6)))))) and ((@as(c_int, @bitCast(@as(c_uint, token[@as(c_uint, @intCast(@as(c_int, 6)))]))) == @as(c_int, ' ')) or (@as(c_int, @bitCast(@as(c_uint, token[@as(c_uint, @intCast(@as(c_int, 6)))]))) == @as(c_int, '\t')))) { + token += @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 7))))); + skip_space(&token); + command.*.mtllib_name = p + @as(usize, @bitCast(@as(isize, @intCast(@divExact(@as(c_long, @bitCast(@intFromPtr(token) -% @intFromPtr(@as([*c]u8, @ptrCast(@alignCast(&linebuf)))))), @sizeOf(u8)))))); + command.*.mtllib_name_len = length_until_newline(token, p_len -% @as(c_uint, @bitCast(@as(c_int, @truncate(@divExact(@as(c_long, @bitCast(@intFromPtr(token) -% @intFromPtr(@as([*c]u8, @ptrCast(@alignCast(&linebuf)))))), @sizeOf(u8))))))) +% @as(c_uint, @bitCast(@as(c_int, 1))); + command.*.type = @as(c_uint, @bitCast(COMMAND_MTLLIB)); + return 1; + } + if ((@as(c_int, @bitCast(@as(c_uint, token[@as(c_uint, @intCast(@as(c_int, 0)))]))) == @as(c_int, 'g')) and ((@as(c_int, @bitCast(@as(c_uint, token[@as(c_uint, @intCast(@as(c_int, 1)))]))) == @as(c_int, ' ')) or (@as(c_int, @bitCast(@as(c_uint, token[@as(c_uint, @intCast(@as(c_int, 1)))]))) == @as(c_int, '\t')))) { + token += @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 2))))); + command.*.group_name = p + @as(usize, @bitCast(@as(isize, @intCast(@divExact(@as(c_long, @bitCast(@intFromPtr(token) -% @intFromPtr(@as([*c]u8, @ptrCast(@alignCast(&linebuf)))))), @sizeOf(u8)))))); + command.*.group_name_len = length_until_newline(token, p_len -% @as(c_uint, @bitCast(@as(c_int, @truncate(@divExact(@as(c_long, @bitCast(@intFromPtr(token) -% @intFromPtr(@as([*c]u8, @ptrCast(@alignCast(&linebuf)))))), @sizeOf(u8))))))) +% @as(c_uint, @bitCast(@as(c_int, 1))); + command.*.type = @as(c_uint, @bitCast(COMMAND_G)); + return 1; + } + if ((@as(c_int, @bitCast(@as(c_uint, token[@as(c_uint, @intCast(@as(c_int, 0)))]))) == @as(c_int, 'o')) and ((@as(c_int, @bitCast(@as(c_uint, token[@as(c_uint, @intCast(@as(c_int, 1)))]))) == @as(c_int, ' ')) or (@as(c_int, @bitCast(@as(c_uint, token[@as(c_uint, @intCast(@as(c_int, 1)))]))) == @as(c_int, '\t')))) { + token += @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 2))))); + command.*.object_name = p + @as(usize, @bitCast(@as(isize, @intCast(@divExact(@as(c_long, @bitCast(@intFromPtr(token) -% @intFromPtr(@as([*c]u8, @ptrCast(@alignCast(&linebuf)))))), @sizeOf(u8)))))); + command.*.object_name_len = length_until_newline(token, p_len -% @as(c_uint, @bitCast(@as(c_int, @truncate(@divExact(@as(c_long, @bitCast(@intFromPtr(token) -% @intFromPtr(@as([*c]u8, @ptrCast(@alignCast(&linebuf)))))), @sizeOf(u8))))))) +% @as(c_uint, @bitCast(@as(c_int, 1))); + command.*.type = @as(c_uint, @bitCast(COMMAND_O)); + return 1; + } + return 0; +} +pub const LineInfo = extern struct { + pos: c_uint = @import("std").mem.zeroes(c_uint), + len: c_uint = @import("std").mem.zeroes(c_uint), +}; +pub fn is_line_ending(arg_p: [*c]const u8, arg_i: c_uint, arg_end_i: c_uint) callconv(.C) c_int { + var p = arg_p; + _ = &p; + var i = arg_i; + _ = &i; + var end_i = arg_end_i; + _ = &end_i; + if (@as(c_int, @bitCast(@as(c_uint, p[i]))) == @as(c_int, '\x00')) return 1; + if (@as(c_int, @bitCast(@as(c_uint, p[i]))) == @as(c_int, '\n')) return 1; + if (@as(c_int, @bitCast(@as(c_uint, p[i]))) == @as(c_int, '\r')) { + if (((i +% @as(c_uint, @bitCast(@as(c_int, 1)))) < end_i) and (@as(c_int, @bitCast(@as(c_uint, p[i +% @as(c_uint, @bitCast(@as(c_int, 1)))]))) != @as(c_int, '\n'))) { + return 1; + } + } + return 0; +} +pub const ptrdiff_t = c_long; +pub const max_align_t = extern struct { + __clang_max_align_nonce1: c_longlong align(8) = @import("std").mem.zeroes(c_longlong), + __clang_max_align_nonce2: c_longdouble align(16) = @import("std").mem.zeroes(c_longdouble), +}; +pub const int_least8_t = __int_least8_t; +pub const int_least16_t = __int_least16_t; +pub const int_least32_t = __int_least32_t; +pub const int_least64_t = __int_least64_t; +pub const uint_least8_t = __uint_least8_t; +pub const uint_least16_t = __uint_least16_t; +pub const uint_least32_t = __uint_least32_t; +pub const uint_least64_t = __uint_least64_t; +pub const int_fast8_t = i8; +pub const int_fast16_t = c_long; +pub const int_fast32_t = c_long; +pub const int_fast64_t = c_long; +pub const uint_fast8_t = u8; +pub const uint_fast16_t = c_ulong; +pub const uint_fast32_t = c_ulong; +pub const uint_fast64_t = c_ulong; +pub const intmax_t = __intmax_t; +pub const uintmax_t = __uintmax_t; +pub const cgltf_size = usize; +pub const cgltf_ssize = c_longlong; +pub const cgltf_float = f32; +pub const cgltf_int = c_int; +pub const cgltf_uint = c_uint; +pub const cgltf_bool = c_int; +pub const cgltf_file_type_invalid: c_int = 0; +pub const cgltf_file_type_gltf: c_int = 1; +pub const cgltf_file_type_glb: c_int = 2; +pub const cgltf_file_type_max_enum: c_int = 3; +pub const enum_cgltf_file_type = c_uint; +pub const cgltf_file_type = enum_cgltf_file_type; +pub const cgltf_result_success: c_int = 0; +pub const cgltf_result_data_too_short: c_int = 1; +pub const cgltf_result_unknown_format: c_int = 2; +pub const cgltf_result_invalid_json: c_int = 3; +pub const cgltf_result_invalid_gltf: c_int = 4; +pub const cgltf_result_invalid_options: c_int = 5; +pub const cgltf_result_file_not_found: c_int = 6; +pub const cgltf_result_io_error: c_int = 7; +pub const cgltf_result_out_of_memory: c_int = 8; +pub const cgltf_result_legacy_gltf: c_int = 9; +pub const cgltf_result_max_enum: c_int = 10; +pub const enum_cgltf_result = c_uint; +pub const cgltf_result = enum_cgltf_result; +pub const struct_cgltf_memory_options = extern struct { + alloc_func: ?*const fn (?*anyopaque, cgltf_size) callconv(.C) ?*anyopaque = @import("std").mem.zeroes(?*const fn (?*anyopaque, cgltf_size) callconv(.C) ?*anyopaque), + free_func: ?*const fn (?*anyopaque, ?*anyopaque) callconv(.C) void = @import("std").mem.zeroes(?*const fn (?*anyopaque, ?*anyopaque) callconv(.C) void), + user_data: ?*anyopaque = @import("std").mem.zeroes(?*anyopaque), +}; +pub const cgltf_memory_options = struct_cgltf_memory_options; +pub const struct_cgltf_file_options = extern struct { + read: ?*const fn ([*c]const struct_cgltf_memory_options, [*c]const struct_cgltf_file_options, [*c]const u8, [*c]cgltf_size, [*c]?*anyopaque) callconv(.C) cgltf_result = @import("std").mem.zeroes(?*const fn ([*c]const struct_cgltf_memory_options, [*c]const struct_cgltf_file_options, [*c]const u8, [*c]cgltf_size, [*c]?*anyopaque) callconv(.C) cgltf_result), + release: ?*const fn ([*c]const struct_cgltf_memory_options, [*c]const struct_cgltf_file_options, ?*anyopaque) callconv(.C) void = @import("std").mem.zeroes(?*const fn ([*c]const struct_cgltf_memory_options, [*c]const struct_cgltf_file_options, ?*anyopaque) callconv(.C) void), + user_data: ?*anyopaque = @import("std").mem.zeroes(?*anyopaque), +}; +pub const cgltf_file_options = struct_cgltf_file_options; +pub const struct_cgltf_options = extern struct { + type: cgltf_file_type = @import("std").mem.zeroes(cgltf_file_type), + json_token_count: cgltf_size = @import("std").mem.zeroes(cgltf_size), + memory: cgltf_memory_options = @import("std").mem.zeroes(cgltf_memory_options), + file: cgltf_file_options = @import("std").mem.zeroes(cgltf_file_options), +}; +pub const cgltf_options = struct_cgltf_options; +pub const cgltf_buffer_view_type_invalid: c_int = 0; +pub const cgltf_buffer_view_type_indices: c_int = 1; +pub const cgltf_buffer_view_type_vertices: c_int = 2; +pub const cgltf_buffer_view_type_max_enum: c_int = 3; +pub const enum_cgltf_buffer_view_type = c_uint; +pub const cgltf_buffer_view_type = enum_cgltf_buffer_view_type; +pub const cgltf_attribute_type_invalid: c_int = 0; +pub const cgltf_attribute_type_position: c_int = 1; +pub const cgltf_attribute_type_normal: c_int = 2; +pub const cgltf_attribute_type_tangent: c_int = 3; +pub const cgltf_attribute_type_texcoord: c_int = 4; +pub const cgltf_attribute_type_color: c_int = 5; +pub const cgltf_attribute_type_joints: c_int = 6; +pub const cgltf_attribute_type_weights: c_int = 7; +pub const cgltf_attribute_type_custom: c_int = 8; +pub const cgltf_attribute_type_max_enum: c_int = 9; +pub const enum_cgltf_attribute_type = c_uint; +pub const cgltf_attribute_type = enum_cgltf_attribute_type; +pub const cgltf_component_type_invalid: c_int = 0; +pub const cgltf_component_type_r_8: c_int = 1; +pub const cgltf_component_type_r_8u: c_int = 2; +pub const cgltf_component_type_r_16: c_int = 3; +pub const cgltf_component_type_r_16u: c_int = 4; +pub const cgltf_component_type_r_32u: c_int = 5; +pub const cgltf_component_type_r_32f: c_int = 6; +pub const cgltf_component_type_max_enum: c_int = 7; +pub const enum_cgltf_component_type = c_uint; +pub const cgltf_component_type = enum_cgltf_component_type; +pub const cgltf_type_invalid: c_int = 0; +pub const cgltf_type_scalar: c_int = 1; +pub const cgltf_type_vec2: c_int = 2; +pub const cgltf_type_vec3: c_int = 3; +pub const cgltf_type_vec4: c_int = 4; +pub const cgltf_type_mat2: c_int = 5; +pub const cgltf_type_mat3: c_int = 6; +pub const cgltf_type_mat4: c_int = 7; +pub const cgltf_type_max_enum: c_int = 8; +pub const enum_cgltf_type = c_uint; +pub const cgltf_type = enum_cgltf_type; +pub const cgltf_primitive_type_invalid: c_int = 0; +pub const cgltf_primitive_type_points: c_int = 1; +pub const cgltf_primitive_type_lines: c_int = 2; +pub const cgltf_primitive_type_line_loop: c_int = 3; +pub const cgltf_primitive_type_line_strip: c_int = 4; +pub const cgltf_primitive_type_triangles: c_int = 5; +pub const cgltf_primitive_type_triangle_strip: c_int = 6; +pub const cgltf_primitive_type_triangle_fan: c_int = 7; +pub const cgltf_primitive_type_max_enum: c_int = 8; +pub const enum_cgltf_primitive_type = c_uint; +pub const cgltf_primitive_type = enum_cgltf_primitive_type; +pub const cgltf_alpha_mode_opaque: c_int = 0; +pub const cgltf_alpha_mode_mask: c_int = 1; +pub const cgltf_alpha_mode_blend: c_int = 2; +pub const cgltf_alpha_mode_max_enum: c_int = 3; +pub const enum_cgltf_alpha_mode = c_uint; +pub const cgltf_alpha_mode = enum_cgltf_alpha_mode; +pub const cgltf_animation_path_type_invalid: c_int = 0; +pub const cgltf_animation_path_type_translation: c_int = 1; +pub const cgltf_animation_path_type_rotation: c_int = 2; +pub const cgltf_animation_path_type_scale: c_int = 3; +pub const cgltf_animation_path_type_weights: c_int = 4; +pub const cgltf_animation_path_type_max_enum: c_int = 5; +pub const enum_cgltf_animation_path_type = c_uint; +pub const cgltf_animation_path_type = enum_cgltf_animation_path_type; +pub const cgltf_interpolation_type_linear: c_int = 0; +pub const cgltf_interpolation_type_step: c_int = 1; +pub const cgltf_interpolation_type_cubic_spline: c_int = 2; +pub const cgltf_interpolation_type_max_enum: c_int = 3; +pub const enum_cgltf_interpolation_type = c_uint; +pub const cgltf_interpolation_type = enum_cgltf_interpolation_type; +pub const cgltf_camera_type_invalid: c_int = 0; +pub const cgltf_camera_type_perspective: c_int = 1; +pub const cgltf_camera_type_orthographic: c_int = 2; +pub const cgltf_camera_type_max_enum: c_int = 3; +pub const enum_cgltf_camera_type = c_uint; +pub const cgltf_camera_type = enum_cgltf_camera_type; +pub const cgltf_light_type_invalid: c_int = 0; +pub const cgltf_light_type_directional: c_int = 1; +pub const cgltf_light_type_point: c_int = 2; +pub const cgltf_light_type_spot: c_int = 3; +pub const cgltf_light_type_max_enum: c_int = 4; +pub const enum_cgltf_light_type = c_uint; +pub const cgltf_light_type = enum_cgltf_light_type; +pub const cgltf_data_free_method_none: c_int = 0; +pub const cgltf_data_free_method_file_release: c_int = 1; +pub const cgltf_data_free_method_memory_free: c_int = 2; +pub const cgltf_data_free_method_max_enum: c_int = 3; +pub const enum_cgltf_data_free_method = c_uint; +pub const cgltf_data_free_method = enum_cgltf_data_free_method; +pub const struct_cgltf_extras = extern struct { + start_offset: cgltf_size = @import("std").mem.zeroes(cgltf_size), + end_offset: cgltf_size = @import("std").mem.zeroes(cgltf_size), + data: [*c]u8 = @import("std").mem.zeroes([*c]u8), +}; +pub const cgltf_extras = struct_cgltf_extras; +pub const struct_cgltf_extension = extern struct { + name: [*c]u8 = @import("std").mem.zeroes([*c]u8), + data: [*c]u8 = @import("std").mem.zeroes([*c]u8), +}; +pub const cgltf_extension = struct_cgltf_extension; +pub const struct_cgltf_buffer = extern struct { + name: [*c]u8 = @import("std").mem.zeroes([*c]u8), + size: cgltf_size = @import("std").mem.zeroes(cgltf_size), + uri: [*c]u8 = @import("std").mem.zeroes([*c]u8), + data: ?*anyopaque = @import("std").mem.zeroes(?*anyopaque), + data_free_method: cgltf_data_free_method = @import("std").mem.zeroes(cgltf_data_free_method), + extras: cgltf_extras = @import("std").mem.zeroes(cgltf_extras), + extensions_count: cgltf_size = @import("std").mem.zeroes(cgltf_size), + extensions: [*c]cgltf_extension = @import("std").mem.zeroes([*c]cgltf_extension), +}; +pub const cgltf_buffer = struct_cgltf_buffer; +pub const cgltf_meshopt_compression_mode_invalid: c_int = 0; +pub const cgltf_meshopt_compression_mode_attributes: c_int = 1; +pub const cgltf_meshopt_compression_mode_triangles: c_int = 2; +pub const cgltf_meshopt_compression_mode_indices: c_int = 3; +pub const cgltf_meshopt_compression_mode_max_enum: c_int = 4; +pub const enum_cgltf_meshopt_compression_mode = c_uint; +pub const cgltf_meshopt_compression_mode = enum_cgltf_meshopt_compression_mode; +pub const cgltf_meshopt_compression_filter_none: c_int = 0; +pub const cgltf_meshopt_compression_filter_octahedral: c_int = 1; +pub const cgltf_meshopt_compression_filter_quaternion: c_int = 2; +pub const cgltf_meshopt_compression_filter_exponential: c_int = 3; +pub const cgltf_meshopt_compression_filter_max_enum: c_int = 4; +pub const enum_cgltf_meshopt_compression_filter = c_uint; +pub const cgltf_meshopt_compression_filter = enum_cgltf_meshopt_compression_filter; +pub const struct_cgltf_meshopt_compression = extern struct { + buffer: [*c]cgltf_buffer = @import("std").mem.zeroes([*c]cgltf_buffer), + offset: cgltf_size = @import("std").mem.zeroes(cgltf_size), + size: cgltf_size = @import("std").mem.zeroes(cgltf_size), + stride: cgltf_size = @import("std").mem.zeroes(cgltf_size), + count: cgltf_size = @import("std").mem.zeroes(cgltf_size), + mode: cgltf_meshopt_compression_mode = @import("std").mem.zeroes(cgltf_meshopt_compression_mode), + filter: cgltf_meshopt_compression_filter = @import("std").mem.zeroes(cgltf_meshopt_compression_filter), +}; +pub const cgltf_meshopt_compression = struct_cgltf_meshopt_compression; +pub const struct_cgltf_buffer_view = extern struct { + name: [*c]u8 = @import("std").mem.zeroes([*c]u8), + buffer: [*c]cgltf_buffer = @import("std").mem.zeroes([*c]cgltf_buffer), + offset: cgltf_size = @import("std").mem.zeroes(cgltf_size), + size: cgltf_size = @import("std").mem.zeroes(cgltf_size), + stride: cgltf_size = @import("std").mem.zeroes(cgltf_size), + type: cgltf_buffer_view_type = @import("std").mem.zeroes(cgltf_buffer_view_type), + data: ?*anyopaque = @import("std").mem.zeroes(?*anyopaque), + has_meshopt_compression: cgltf_bool = @import("std").mem.zeroes(cgltf_bool), + meshopt_compression: cgltf_meshopt_compression = @import("std").mem.zeroes(cgltf_meshopt_compression), + extras: cgltf_extras = @import("std").mem.zeroes(cgltf_extras), + extensions_count: cgltf_size = @import("std").mem.zeroes(cgltf_size), + extensions: [*c]cgltf_extension = @import("std").mem.zeroes([*c]cgltf_extension), +}; +pub const cgltf_buffer_view = struct_cgltf_buffer_view; +pub const struct_cgltf_accessor_sparse = extern struct { + count: cgltf_size = @import("std").mem.zeroes(cgltf_size), + indices_buffer_view: [*c]cgltf_buffer_view = @import("std").mem.zeroes([*c]cgltf_buffer_view), + indices_byte_offset: cgltf_size = @import("std").mem.zeroes(cgltf_size), + indices_component_type: cgltf_component_type = @import("std").mem.zeroes(cgltf_component_type), + values_buffer_view: [*c]cgltf_buffer_view = @import("std").mem.zeroes([*c]cgltf_buffer_view), + values_byte_offset: cgltf_size = @import("std").mem.zeroes(cgltf_size), +}; +pub const cgltf_accessor_sparse = struct_cgltf_accessor_sparse; +pub const struct_cgltf_accessor = extern struct { + name: [*c]u8 = @import("std").mem.zeroes([*c]u8), + component_type: cgltf_component_type = @import("std").mem.zeroes(cgltf_component_type), + normalized: cgltf_bool = @import("std").mem.zeroes(cgltf_bool), + type: cgltf_type = @import("std").mem.zeroes(cgltf_type), + offset: cgltf_size = @import("std").mem.zeroes(cgltf_size), + count: cgltf_size = @import("std").mem.zeroes(cgltf_size), + stride: cgltf_size = @import("std").mem.zeroes(cgltf_size), + buffer_view: [*c]cgltf_buffer_view = @import("std").mem.zeroes([*c]cgltf_buffer_view), + has_min: cgltf_bool = @import("std").mem.zeroes(cgltf_bool), + min: [16]cgltf_float = @import("std").mem.zeroes([16]cgltf_float), + has_max: cgltf_bool = @import("std").mem.zeroes(cgltf_bool), + max: [16]cgltf_float = @import("std").mem.zeroes([16]cgltf_float), + is_sparse: cgltf_bool = @import("std").mem.zeroes(cgltf_bool), + sparse: cgltf_accessor_sparse = @import("std").mem.zeroes(cgltf_accessor_sparse), + extras: cgltf_extras = @import("std").mem.zeroes(cgltf_extras), + extensions_count: cgltf_size = @import("std").mem.zeroes(cgltf_size), + extensions: [*c]cgltf_extension = @import("std").mem.zeroes([*c]cgltf_extension), +}; +pub const cgltf_accessor = struct_cgltf_accessor; +pub const struct_cgltf_attribute = extern struct { + name: [*c]u8 = @import("std").mem.zeroes([*c]u8), + type: cgltf_attribute_type = @import("std").mem.zeroes(cgltf_attribute_type), + index: cgltf_int = @import("std").mem.zeroes(cgltf_int), + data: [*c]cgltf_accessor = @import("std").mem.zeroes([*c]cgltf_accessor), +}; +pub const cgltf_attribute = struct_cgltf_attribute; +pub const struct_cgltf_image = extern struct { + name: [*c]u8 = @import("std").mem.zeroes([*c]u8), + uri: [*c]u8 = @import("std").mem.zeroes([*c]u8), + buffer_view: [*c]cgltf_buffer_view = @import("std").mem.zeroes([*c]cgltf_buffer_view), + mime_type: [*c]u8 = @import("std").mem.zeroes([*c]u8), + extras: cgltf_extras = @import("std").mem.zeroes(cgltf_extras), + extensions_count: cgltf_size = @import("std").mem.zeroes(cgltf_size), + extensions: [*c]cgltf_extension = @import("std").mem.zeroes([*c]cgltf_extension), +}; +pub const cgltf_image = struct_cgltf_image; +pub const struct_cgltf_sampler = extern struct { + name: [*c]u8 = @import("std").mem.zeroes([*c]u8), + mag_filter: cgltf_int = @import("std").mem.zeroes(cgltf_int), + min_filter: cgltf_int = @import("std").mem.zeroes(cgltf_int), + wrap_s: cgltf_int = @import("std").mem.zeroes(cgltf_int), + wrap_t: cgltf_int = @import("std").mem.zeroes(cgltf_int), + extras: cgltf_extras = @import("std").mem.zeroes(cgltf_extras), + extensions_count: cgltf_size = @import("std").mem.zeroes(cgltf_size), + extensions: [*c]cgltf_extension = @import("std").mem.zeroes([*c]cgltf_extension), +}; +pub const cgltf_sampler = struct_cgltf_sampler; +pub const struct_cgltf_texture = extern struct { + name: [*c]u8 = @import("std").mem.zeroes([*c]u8), + image: [*c]cgltf_image = @import("std").mem.zeroes([*c]cgltf_image), + sampler: [*c]cgltf_sampler = @import("std").mem.zeroes([*c]cgltf_sampler), + has_basisu: cgltf_bool = @import("std").mem.zeroes(cgltf_bool), + basisu_image: [*c]cgltf_image = @import("std").mem.zeroes([*c]cgltf_image), + extras: cgltf_extras = @import("std").mem.zeroes(cgltf_extras), + extensions_count: cgltf_size = @import("std").mem.zeroes(cgltf_size), + extensions: [*c]cgltf_extension = @import("std").mem.zeroes([*c]cgltf_extension), +}; +pub const cgltf_texture = struct_cgltf_texture; +pub const struct_cgltf_texture_transform = extern struct { + offset: [2]cgltf_float = @import("std").mem.zeroes([2]cgltf_float), + rotation: cgltf_float = @import("std").mem.zeroes(cgltf_float), + scale: [2]cgltf_float = @import("std").mem.zeroes([2]cgltf_float), + has_texcoord: cgltf_bool = @import("std").mem.zeroes(cgltf_bool), + texcoord: cgltf_int = @import("std").mem.zeroes(cgltf_int), +}; +pub const cgltf_texture_transform = struct_cgltf_texture_transform; +pub const struct_cgltf_texture_view = extern struct { + texture: [*c]cgltf_texture = @import("std").mem.zeroes([*c]cgltf_texture), + texcoord: cgltf_int = @import("std").mem.zeroes(cgltf_int), + scale: cgltf_float = @import("std").mem.zeroes(cgltf_float), + has_transform: cgltf_bool = @import("std").mem.zeroes(cgltf_bool), + transform: cgltf_texture_transform = @import("std").mem.zeroes(cgltf_texture_transform), +}; +pub const cgltf_texture_view = struct_cgltf_texture_view; +pub const struct_cgltf_pbr_metallic_roughness = extern struct { + base_color_texture: cgltf_texture_view = @import("std").mem.zeroes(cgltf_texture_view), + metallic_roughness_texture: cgltf_texture_view = @import("std").mem.zeroes(cgltf_texture_view), + base_color_factor: [4]cgltf_float = @import("std").mem.zeroes([4]cgltf_float), + metallic_factor: cgltf_float = @import("std").mem.zeroes(cgltf_float), + roughness_factor: cgltf_float = @import("std").mem.zeroes(cgltf_float), +}; +pub const cgltf_pbr_metallic_roughness = struct_cgltf_pbr_metallic_roughness; +pub const struct_cgltf_pbr_specular_glossiness = extern struct { + diffuse_texture: cgltf_texture_view = @import("std").mem.zeroes(cgltf_texture_view), + specular_glossiness_texture: cgltf_texture_view = @import("std").mem.zeroes(cgltf_texture_view), + diffuse_factor: [4]cgltf_float = @import("std").mem.zeroes([4]cgltf_float), + specular_factor: [3]cgltf_float = @import("std").mem.zeroes([3]cgltf_float), + glossiness_factor: cgltf_float = @import("std").mem.zeroes(cgltf_float), +}; +pub const cgltf_pbr_specular_glossiness = struct_cgltf_pbr_specular_glossiness; +pub const struct_cgltf_clearcoat = extern struct { + clearcoat_texture: cgltf_texture_view = @import("std").mem.zeroes(cgltf_texture_view), + clearcoat_roughness_texture: cgltf_texture_view = @import("std").mem.zeroes(cgltf_texture_view), + clearcoat_normal_texture: cgltf_texture_view = @import("std").mem.zeroes(cgltf_texture_view), + clearcoat_factor: cgltf_float = @import("std").mem.zeroes(cgltf_float), + clearcoat_roughness_factor: cgltf_float = @import("std").mem.zeroes(cgltf_float), +}; +pub const cgltf_clearcoat = struct_cgltf_clearcoat; +pub const struct_cgltf_transmission = extern struct { + transmission_texture: cgltf_texture_view = @import("std").mem.zeroes(cgltf_texture_view), + transmission_factor: cgltf_float = @import("std").mem.zeroes(cgltf_float), +}; +pub const cgltf_transmission = struct_cgltf_transmission; +pub const struct_cgltf_ior = extern struct { + ior: cgltf_float = @import("std").mem.zeroes(cgltf_float), +}; +pub const cgltf_ior = struct_cgltf_ior; +pub const struct_cgltf_specular = extern struct { + specular_texture: cgltf_texture_view = @import("std").mem.zeroes(cgltf_texture_view), + specular_color_texture: cgltf_texture_view = @import("std").mem.zeroes(cgltf_texture_view), + specular_color_factor: [3]cgltf_float = @import("std").mem.zeroes([3]cgltf_float), + specular_factor: cgltf_float = @import("std").mem.zeroes(cgltf_float), +}; +pub const cgltf_specular = struct_cgltf_specular; +pub const struct_cgltf_volume = extern struct { + thickness_texture: cgltf_texture_view = @import("std").mem.zeroes(cgltf_texture_view), + thickness_factor: cgltf_float = @import("std").mem.zeroes(cgltf_float), + attenuation_color: [3]cgltf_float = @import("std").mem.zeroes([3]cgltf_float), + attenuation_distance: cgltf_float = @import("std").mem.zeroes(cgltf_float), +}; +pub const cgltf_volume = struct_cgltf_volume; +pub const struct_cgltf_sheen = extern struct { + sheen_color_texture: cgltf_texture_view = @import("std").mem.zeroes(cgltf_texture_view), + sheen_color_factor: [3]cgltf_float = @import("std").mem.zeroes([3]cgltf_float), + sheen_roughness_texture: cgltf_texture_view = @import("std").mem.zeroes(cgltf_texture_view), + sheen_roughness_factor: cgltf_float = @import("std").mem.zeroes(cgltf_float), +}; +pub const cgltf_sheen = struct_cgltf_sheen; +pub const struct_cgltf_emissive_strength = extern struct { + emissive_strength: cgltf_float = @import("std").mem.zeroes(cgltf_float), +}; +pub const cgltf_emissive_strength = struct_cgltf_emissive_strength; +pub const struct_cgltf_iridescence = extern struct { + iridescence_factor: cgltf_float = @import("std").mem.zeroes(cgltf_float), + iridescence_texture: cgltf_texture_view = @import("std").mem.zeroes(cgltf_texture_view), + iridescence_ior: cgltf_float = @import("std").mem.zeroes(cgltf_float), + iridescence_thickness_min: cgltf_float = @import("std").mem.zeroes(cgltf_float), + iridescence_thickness_max: cgltf_float = @import("std").mem.zeroes(cgltf_float), + iridescence_thickness_texture: cgltf_texture_view = @import("std").mem.zeroes(cgltf_texture_view), +}; +pub const cgltf_iridescence = struct_cgltf_iridescence; +pub const struct_cgltf_anisotropy = extern struct { + anisotropy_strength: cgltf_float = @import("std").mem.zeroes(cgltf_float), + anisotropy_rotation: cgltf_float = @import("std").mem.zeroes(cgltf_float), + anisotropy_texture: cgltf_texture_view = @import("std").mem.zeroes(cgltf_texture_view), +}; +pub const cgltf_anisotropy = struct_cgltf_anisotropy; +pub const struct_cgltf_dispersion = extern struct { + dispersion: cgltf_float = @import("std").mem.zeroes(cgltf_float), +}; +pub const cgltf_dispersion = struct_cgltf_dispersion; +pub const struct_cgltf_material = extern struct { + name: [*c]u8 = @import("std").mem.zeroes([*c]u8), + has_pbr_metallic_roughness: cgltf_bool = @import("std").mem.zeroes(cgltf_bool), + has_pbr_specular_glossiness: cgltf_bool = @import("std").mem.zeroes(cgltf_bool), + has_clearcoat: cgltf_bool = @import("std").mem.zeroes(cgltf_bool), + has_transmission: cgltf_bool = @import("std").mem.zeroes(cgltf_bool), + has_volume: cgltf_bool = @import("std").mem.zeroes(cgltf_bool), + has_ior: cgltf_bool = @import("std").mem.zeroes(cgltf_bool), + has_specular: cgltf_bool = @import("std").mem.zeroes(cgltf_bool), + has_sheen: cgltf_bool = @import("std").mem.zeroes(cgltf_bool), + has_emissive_strength: cgltf_bool = @import("std").mem.zeroes(cgltf_bool), + has_iridescence: cgltf_bool = @import("std").mem.zeroes(cgltf_bool), + has_anisotropy: cgltf_bool = @import("std").mem.zeroes(cgltf_bool), + has_dispersion: cgltf_bool = @import("std").mem.zeroes(cgltf_bool), + pbr_metallic_roughness: cgltf_pbr_metallic_roughness = @import("std").mem.zeroes(cgltf_pbr_metallic_roughness), + pbr_specular_glossiness: cgltf_pbr_specular_glossiness = @import("std").mem.zeroes(cgltf_pbr_specular_glossiness), + clearcoat: cgltf_clearcoat = @import("std").mem.zeroes(cgltf_clearcoat), + ior: cgltf_ior = @import("std").mem.zeroes(cgltf_ior), + specular: cgltf_specular = @import("std").mem.zeroes(cgltf_specular), + sheen: cgltf_sheen = @import("std").mem.zeroes(cgltf_sheen), + transmission: cgltf_transmission = @import("std").mem.zeroes(cgltf_transmission), + volume: cgltf_volume = @import("std").mem.zeroes(cgltf_volume), + emissive_strength: cgltf_emissive_strength = @import("std").mem.zeroes(cgltf_emissive_strength), + iridescence: cgltf_iridescence = @import("std").mem.zeroes(cgltf_iridescence), + anisotropy: cgltf_anisotropy = @import("std").mem.zeroes(cgltf_anisotropy), + dispersion: cgltf_dispersion = @import("std").mem.zeroes(cgltf_dispersion), + normal_texture: cgltf_texture_view = @import("std").mem.zeroes(cgltf_texture_view), + occlusion_texture: cgltf_texture_view = @import("std").mem.zeroes(cgltf_texture_view), + emissive_texture: cgltf_texture_view = @import("std").mem.zeroes(cgltf_texture_view), + emissive_factor: [3]cgltf_float = @import("std").mem.zeroes([3]cgltf_float), + alpha_mode: cgltf_alpha_mode = @import("std").mem.zeroes(cgltf_alpha_mode), + alpha_cutoff: cgltf_float = @import("std").mem.zeroes(cgltf_float), + double_sided: cgltf_bool = @import("std").mem.zeroes(cgltf_bool), + unlit: cgltf_bool = @import("std").mem.zeroes(cgltf_bool), + extras: cgltf_extras = @import("std").mem.zeroes(cgltf_extras), + extensions_count: cgltf_size = @import("std").mem.zeroes(cgltf_size), + extensions: [*c]cgltf_extension = @import("std").mem.zeroes([*c]cgltf_extension), +}; +pub const cgltf_material = struct_cgltf_material; +pub const struct_cgltf_material_mapping = extern struct { + variant: cgltf_size = @import("std").mem.zeroes(cgltf_size), + material: [*c]cgltf_material = @import("std").mem.zeroes([*c]cgltf_material), + extras: cgltf_extras = @import("std").mem.zeroes(cgltf_extras), +}; +pub const cgltf_material_mapping = struct_cgltf_material_mapping; +pub const struct_cgltf_morph_target = extern struct { + attributes: [*c]cgltf_attribute = @import("std").mem.zeroes([*c]cgltf_attribute), + attributes_count: cgltf_size = @import("std").mem.zeroes(cgltf_size), +}; +pub const cgltf_morph_target = struct_cgltf_morph_target; +pub const struct_cgltf_draco_mesh_compression = extern struct { + buffer_view: [*c]cgltf_buffer_view = @import("std").mem.zeroes([*c]cgltf_buffer_view), + attributes: [*c]cgltf_attribute = @import("std").mem.zeroes([*c]cgltf_attribute), + attributes_count: cgltf_size = @import("std").mem.zeroes(cgltf_size), +}; +pub const cgltf_draco_mesh_compression = struct_cgltf_draco_mesh_compression; +pub const struct_cgltf_mesh_gpu_instancing = extern struct { + attributes: [*c]cgltf_attribute = @import("std").mem.zeroes([*c]cgltf_attribute), + attributes_count: cgltf_size = @import("std").mem.zeroes(cgltf_size), +}; +pub const cgltf_mesh_gpu_instancing = struct_cgltf_mesh_gpu_instancing; +pub const struct_cgltf_primitive = extern struct { + type: cgltf_primitive_type = @import("std").mem.zeroes(cgltf_primitive_type), + indices: [*c]cgltf_accessor = @import("std").mem.zeroes([*c]cgltf_accessor), + material: [*c]cgltf_material = @import("std").mem.zeroes([*c]cgltf_material), + attributes: [*c]cgltf_attribute = @import("std").mem.zeroes([*c]cgltf_attribute), + attributes_count: cgltf_size = @import("std").mem.zeroes(cgltf_size), + targets: [*c]cgltf_morph_target = @import("std").mem.zeroes([*c]cgltf_morph_target), + targets_count: cgltf_size = @import("std").mem.zeroes(cgltf_size), + extras: cgltf_extras = @import("std").mem.zeroes(cgltf_extras), + has_draco_mesh_compression: cgltf_bool = @import("std").mem.zeroes(cgltf_bool), + draco_mesh_compression: cgltf_draco_mesh_compression = @import("std").mem.zeroes(cgltf_draco_mesh_compression), + mappings: [*c]cgltf_material_mapping = @import("std").mem.zeroes([*c]cgltf_material_mapping), + mappings_count: cgltf_size = @import("std").mem.zeroes(cgltf_size), + extensions_count: cgltf_size = @import("std").mem.zeroes(cgltf_size), + extensions: [*c]cgltf_extension = @import("std").mem.zeroes([*c]cgltf_extension), +}; +pub const cgltf_primitive = struct_cgltf_primitive; +pub const struct_cgltf_mesh = extern struct { + name: [*c]u8 = @import("std").mem.zeroes([*c]u8), + primitives: [*c]cgltf_primitive = @import("std").mem.zeroes([*c]cgltf_primitive), + primitives_count: cgltf_size = @import("std").mem.zeroes(cgltf_size), + weights: [*c]cgltf_float = @import("std").mem.zeroes([*c]cgltf_float), + weights_count: cgltf_size = @import("std").mem.zeroes(cgltf_size), + target_names: [*c][*c]u8 = @import("std").mem.zeroes([*c][*c]u8), + target_names_count: cgltf_size = @import("std").mem.zeroes(cgltf_size), + extras: cgltf_extras = @import("std").mem.zeroes(cgltf_extras), + extensions_count: cgltf_size = @import("std").mem.zeroes(cgltf_size), + extensions: [*c]cgltf_extension = @import("std").mem.zeroes([*c]cgltf_extension), +}; +pub const cgltf_mesh = struct_cgltf_mesh; +pub const cgltf_node = struct_cgltf_node; +pub const struct_cgltf_skin = extern struct { + name: [*c]u8 = @import("std").mem.zeroes([*c]u8), + joints: [*c][*c]cgltf_node = @import("std").mem.zeroes([*c][*c]cgltf_node), + joints_count: cgltf_size = @import("std").mem.zeroes(cgltf_size), + skeleton: [*c]cgltf_node = @import("std").mem.zeroes([*c]cgltf_node), + inverse_bind_matrices: [*c]cgltf_accessor = @import("std").mem.zeroes([*c]cgltf_accessor), + extras: cgltf_extras = @import("std").mem.zeroes(cgltf_extras), + extensions_count: cgltf_size = @import("std").mem.zeroes(cgltf_size), + extensions: [*c]cgltf_extension = @import("std").mem.zeroes([*c]cgltf_extension), +}; +pub const cgltf_skin = struct_cgltf_skin; +pub const struct_cgltf_camera_perspective = extern struct { + has_aspect_ratio: cgltf_bool = @import("std").mem.zeroes(cgltf_bool), + aspect_ratio: cgltf_float = @import("std").mem.zeroes(cgltf_float), + yfov: cgltf_float = @import("std").mem.zeroes(cgltf_float), + has_zfar: cgltf_bool = @import("std").mem.zeroes(cgltf_bool), + zfar: cgltf_float = @import("std").mem.zeroes(cgltf_float), + znear: cgltf_float = @import("std").mem.zeroes(cgltf_float), + extras: cgltf_extras = @import("std").mem.zeroes(cgltf_extras), +}; +pub const cgltf_camera_perspective = struct_cgltf_camera_perspective; +pub const struct_cgltf_camera_orthographic = extern struct { + xmag: cgltf_float = @import("std").mem.zeroes(cgltf_float), + ymag: cgltf_float = @import("std").mem.zeroes(cgltf_float), + zfar: cgltf_float = @import("std").mem.zeroes(cgltf_float), + znear: cgltf_float = @import("std").mem.zeroes(cgltf_float), + extras: cgltf_extras = @import("std").mem.zeroes(cgltf_extras), +}; +pub const cgltf_camera_orthographic = struct_cgltf_camera_orthographic; +const union_unnamed_6 = extern union { + perspective: cgltf_camera_perspective, + orthographic: cgltf_camera_orthographic, +}; +pub const struct_cgltf_camera = extern struct { + name: [*c]u8 = @import("std").mem.zeroes([*c]u8), + type: cgltf_camera_type = @import("std").mem.zeroes(cgltf_camera_type), + data: union_unnamed_6 = @import("std").mem.zeroes(union_unnamed_6), + extras: cgltf_extras = @import("std").mem.zeroes(cgltf_extras), + extensions_count: cgltf_size = @import("std").mem.zeroes(cgltf_size), + extensions: [*c]cgltf_extension = @import("std").mem.zeroes([*c]cgltf_extension), +}; +pub const cgltf_camera = struct_cgltf_camera; +pub const struct_cgltf_light = extern struct { + name: [*c]u8 = @import("std").mem.zeroes([*c]u8), + color: [3]cgltf_float = @import("std").mem.zeroes([3]cgltf_float), + intensity: cgltf_float = @import("std").mem.zeroes(cgltf_float), + type: cgltf_light_type = @import("std").mem.zeroes(cgltf_light_type), + range: cgltf_float = @import("std").mem.zeroes(cgltf_float), + spot_inner_cone_angle: cgltf_float = @import("std").mem.zeroes(cgltf_float), + spot_outer_cone_angle: cgltf_float = @import("std").mem.zeroes(cgltf_float), + extras: cgltf_extras = @import("std").mem.zeroes(cgltf_extras), +}; +pub const cgltf_light = struct_cgltf_light; +pub const struct_cgltf_node = extern struct { + name: [*c]u8 = @import("std").mem.zeroes([*c]u8), + parent: [*c]cgltf_node = @import("std").mem.zeroes([*c]cgltf_node), + children: [*c][*c]cgltf_node = @import("std").mem.zeroes([*c][*c]cgltf_node), + children_count: cgltf_size = @import("std").mem.zeroes(cgltf_size), + skin: [*c]cgltf_skin = @import("std").mem.zeroes([*c]cgltf_skin), + mesh: [*c]cgltf_mesh = @import("std").mem.zeroes([*c]cgltf_mesh), + camera: [*c]cgltf_camera = @import("std").mem.zeroes([*c]cgltf_camera), + light: [*c]cgltf_light = @import("std").mem.zeroes([*c]cgltf_light), + weights: [*c]cgltf_float = @import("std").mem.zeroes([*c]cgltf_float), + weights_count: cgltf_size = @import("std").mem.zeroes(cgltf_size), + has_translation: cgltf_bool = @import("std").mem.zeroes(cgltf_bool), + has_rotation: cgltf_bool = @import("std").mem.zeroes(cgltf_bool), + has_scale: cgltf_bool = @import("std").mem.zeroes(cgltf_bool), + has_matrix: cgltf_bool = @import("std").mem.zeroes(cgltf_bool), + translation: [3]cgltf_float = @import("std").mem.zeroes([3]cgltf_float), + rotation: [4]cgltf_float = @import("std").mem.zeroes([4]cgltf_float), + scale: [3]cgltf_float = @import("std").mem.zeroes([3]cgltf_float), + matrix: [16]cgltf_float = @import("std").mem.zeroes([16]cgltf_float), + extras: cgltf_extras = @import("std").mem.zeroes(cgltf_extras), + has_mesh_gpu_instancing: cgltf_bool = @import("std").mem.zeroes(cgltf_bool), + mesh_gpu_instancing: cgltf_mesh_gpu_instancing = @import("std").mem.zeroes(cgltf_mesh_gpu_instancing), + extensions_count: cgltf_size = @import("std").mem.zeroes(cgltf_size), + extensions: [*c]cgltf_extension = @import("std").mem.zeroes([*c]cgltf_extension), +}; +pub const struct_cgltf_scene = extern struct { + name: [*c]u8 = @import("std").mem.zeroes([*c]u8), + nodes: [*c][*c]cgltf_node = @import("std").mem.zeroes([*c][*c]cgltf_node), + nodes_count: cgltf_size = @import("std").mem.zeroes(cgltf_size), + extras: cgltf_extras = @import("std").mem.zeroes(cgltf_extras), + extensions_count: cgltf_size = @import("std").mem.zeroes(cgltf_size), + extensions: [*c]cgltf_extension = @import("std").mem.zeroes([*c]cgltf_extension), +}; +pub const cgltf_scene = struct_cgltf_scene; +pub const struct_cgltf_animation_sampler = extern struct { + input: [*c]cgltf_accessor = @import("std").mem.zeroes([*c]cgltf_accessor), + output: [*c]cgltf_accessor = @import("std").mem.zeroes([*c]cgltf_accessor), + interpolation: cgltf_interpolation_type = @import("std").mem.zeroes(cgltf_interpolation_type), + extras: cgltf_extras = @import("std").mem.zeroes(cgltf_extras), + extensions_count: cgltf_size = @import("std").mem.zeroes(cgltf_size), + extensions: [*c]cgltf_extension = @import("std").mem.zeroes([*c]cgltf_extension), +}; +pub const cgltf_animation_sampler = struct_cgltf_animation_sampler; +pub const struct_cgltf_animation_channel = extern struct { + sampler: [*c]cgltf_animation_sampler = @import("std").mem.zeroes([*c]cgltf_animation_sampler), + target_node: [*c]cgltf_node = @import("std").mem.zeroes([*c]cgltf_node), + target_path: cgltf_animation_path_type = @import("std").mem.zeroes(cgltf_animation_path_type), + extras: cgltf_extras = @import("std").mem.zeroes(cgltf_extras), + extensions_count: cgltf_size = @import("std").mem.zeroes(cgltf_size), + extensions: [*c]cgltf_extension = @import("std").mem.zeroes([*c]cgltf_extension), +}; +pub const cgltf_animation_channel = struct_cgltf_animation_channel; +pub const struct_cgltf_animation = extern struct { + name: [*c]u8 = @import("std").mem.zeroes([*c]u8), + samplers: [*c]cgltf_animation_sampler = @import("std").mem.zeroes([*c]cgltf_animation_sampler), + samplers_count: cgltf_size = @import("std").mem.zeroes(cgltf_size), + channels: [*c]cgltf_animation_channel = @import("std").mem.zeroes([*c]cgltf_animation_channel), + channels_count: cgltf_size = @import("std").mem.zeroes(cgltf_size), + extras: cgltf_extras = @import("std").mem.zeroes(cgltf_extras), + extensions_count: cgltf_size = @import("std").mem.zeroes(cgltf_size), + extensions: [*c]cgltf_extension = @import("std").mem.zeroes([*c]cgltf_extension), +}; +pub const cgltf_animation = struct_cgltf_animation; +pub const struct_cgltf_material_variant = extern struct { + name: [*c]u8 = @import("std").mem.zeroes([*c]u8), + extras: cgltf_extras = @import("std").mem.zeroes(cgltf_extras), +}; +pub const cgltf_material_variant = struct_cgltf_material_variant; +pub const struct_cgltf_asset = extern struct { + copyright: [*c]u8 = @import("std").mem.zeroes([*c]u8), + generator: [*c]u8 = @import("std").mem.zeroes([*c]u8), + version: [*c]u8 = @import("std").mem.zeroes([*c]u8), + min_version: [*c]u8 = @import("std").mem.zeroes([*c]u8), + extras: cgltf_extras = @import("std").mem.zeroes(cgltf_extras), + extensions_count: cgltf_size = @import("std").mem.zeroes(cgltf_size), + extensions: [*c]cgltf_extension = @import("std").mem.zeroes([*c]cgltf_extension), +}; +pub const cgltf_asset = struct_cgltf_asset; +pub const struct_cgltf_data = extern struct { + file_type: cgltf_file_type = @import("std").mem.zeroes(cgltf_file_type), + file_data: ?*anyopaque = @import("std").mem.zeroes(?*anyopaque), + asset: cgltf_asset = @import("std").mem.zeroes(cgltf_asset), + meshes: [*c]cgltf_mesh = @import("std").mem.zeroes([*c]cgltf_mesh), + meshes_count: cgltf_size = @import("std").mem.zeroes(cgltf_size), + materials: [*c]cgltf_material = @import("std").mem.zeroes([*c]cgltf_material), + materials_count: cgltf_size = @import("std").mem.zeroes(cgltf_size), + accessors: [*c]cgltf_accessor = @import("std").mem.zeroes([*c]cgltf_accessor), + accessors_count: cgltf_size = @import("std").mem.zeroes(cgltf_size), + buffer_views: [*c]cgltf_buffer_view = @import("std").mem.zeroes([*c]cgltf_buffer_view), + buffer_views_count: cgltf_size = @import("std").mem.zeroes(cgltf_size), + buffers: [*c]cgltf_buffer = @import("std").mem.zeroes([*c]cgltf_buffer), + buffers_count: cgltf_size = @import("std").mem.zeroes(cgltf_size), + images: [*c]cgltf_image = @import("std").mem.zeroes([*c]cgltf_image), + images_count: cgltf_size = @import("std").mem.zeroes(cgltf_size), + textures: [*c]cgltf_texture = @import("std").mem.zeroes([*c]cgltf_texture), + textures_count: cgltf_size = @import("std").mem.zeroes(cgltf_size), + samplers: [*c]cgltf_sampler = @import("std").mem.zeroes([*c]cgltf_sampler), + samplers_count: cgltf_size = @import("std").mem.zeroes(cgltf_size), + skins: [*c]cgltf_skin = @import("std").mem.zeroes([*c]cgltf_skin), + skins_count: cgltf_size = @import("std").mem.zeroes(cgltf_size), + cameras: [*c]cgltf_camera = @import("std").mem.zeroes([*c]cgltf_camera), + cameras_count: cgltf_size = @import("std").mem.zeroes(cgltf_size), + lights: [*c]cgltf_light = @import("std").mem.zeroes([*c]cgltf_light), + lights_count: cgltf_size = @import("std").mem.zeroes(cgltf_size), + nodes: [*c]cgltf_node = @import("std").mem.zeroes([*c]cgltf_node), + nodes_count: cgltf_size = @import("std").mem.zeroes(cgltf_size), + scenes: [*c]cgltf_scene = @import("std").mem.zeroes([*c]cgltf_scene), + scenes_count: cgltf_size = @import("std").mem.zeroes(cgltf_size), + scene: [*c]cgltf_scene = @import("std").mem.zeroes([*c]cgltf_scene), + animations: [*c]cgltf_animation = @import("std").mem.zeroes([*c]cgltf_animation), + animations_count: cgltf_size = @import("std").mem.zeroes(cgltf_size), + variants: [*c]cgltf_material_variant = @import("std").mem.zeroes([*c]cgltf_material_variant), + variants_count: cgltf_size = @import("std").mem.zeroes(cgltf_size), + extras: cgltf_extras = @import("std").mem.zeroes(cgltf_extras), + data_extensions_count: cgltf_size = @import("std").mem.zeroes(cgltf_size), + data_extensions: [*c]cgltf_extension = @import("std").mem.zeroes([*c]cgltf_extension), + extensions_used: [*c][*c]u8 = @import("std").mem.zeroes([*c][*c]u8), + extensions_used_count: cgltf_size = @import("std").mem.zeroes(cgltf_size), + extensions_required: [*c][*c]u8 = @import("std").mem.zeroes([*c][*c]u8), + extensions_required_count: cgltf_size = @import("std").mem.zeroes(cgltf_size), + json: [*c]const u8 = @import("std").mem.zeroes([*c]const u8), + json_size: cgltf_size = @import("std").mem.zeroes(cgltf_size), + bin: ?*const anyopaque = @import("std").mem.zeroes(?*const anyopaque), + bin_size: cgltf_size = @import("std").mem.zeroes(cgltf_size), + memory: cgltf_memory_options = @import("std").mem.zeroes(cgltf_memory_options), + file: cgltf_file_options = @import("std").mem.zeroes(cgltf_file_options), +}; +pub const cgltf_data = struct_cgltf_data; +pub export fn cgltf_parse(arg_options: [*c]const cgltf_options, arg_data: ?*const anyopaque, arg_size: cgltf_size, arg_out_data: [*c][*c]cgltf_data) cgltf_result { + var options = arg_options; + _ = &options; + var data = arg_data; + _ = &data; + var size = arg_size; + _ = &size; + var out_data = arg_out_data; + _ = &out_data; + if (size < @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 12))))) { + return @as(c_uint, @bitCast(cgltf_result_data_too_short)); + } + if (options == @as([*c]const cgltf_options, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0))))))) { + return @as(c_uint, @bitCast(cgltf_result_invalid_options)); + } + var fixed_options: cgltf_options = options.*; + _ = &fixed_options; + if (fixed_options.memory.alloc_func == @as(?*const fn (?*anyopaque, cgltf_size) callconv(.C) ?*anyopaque, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0))))))) { + fixed_options.memory.alloc_func = &cgltf_default_alloc; + } + if (fixed_options.memory.free_func == @as(?*const fn (?*anyopaque, ?*anyopaque) callconv(.C) void, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0))))))) { + fixed_options.memory.free_func = &cgltf_default_free; + } + var tmp: u32 = undefined; + _ = &tmp; + _ = memcpy(@as(?*anyopaque, @ptrCast(&tmp)), data, @as(c_ulong, @bitCast(@as(c_long, @as(c_int, 4))))); + if (tmp != GlbMagic) { + if (fixed_options.type == @as(c_uint, @bitCast(cgltf_file_type_invalid))) { + fixed_options.type = @as(c_uint, @bitCast(cgltf_file_type_gltf)); + } else if (fixed_options.type == @as(c_uint, @bitCast(cgltf_file_type_glb))) { + return @as(c_uint, @bitCast(cgltf_result_unknown_format)); + } + } + if (fixed_options.type == @as(c_uint, @bitCast(cgltf_file_type_gltf))) { + var json_result: cgltf_result = cgltf_parse_json(&fixed_options, @as([*c]const u8, @ptrCast(@alignCast(data))), size, out_data); + _ = &json_result; + if (json_result != @as(c_uint, @bitCast(cgltf_result_success))) { + return json_result; + } + out_data.*.*.file_type = @as(c_uint, @bitCast(cgltf_file_type_gltf)); + return @as(c_uint, @bitCast(cgltf_result_success)); + } + var ptr: [*c]const u8 = @as([*c]const u8, @ptrCast(@alignCast(data))); + _ = &ptr; + _ = memcpy(@as(?*anyopaque, @ptrCast(&tmp)), @as(?*const anyopaque, @ptrCast(ptr + @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 4))))))), @as(c_ulong, @bitCast(@as(c_long, @as(c_int, 4))))); + var version: u32 = tmp; + _ = &version; + if (version != GlbVersion) { + return @as(c_uint, @bitCast(if (version < GlbVersion) cgltf_result_legacy_gltf else cgltf_result_unknown_format)); + } + _ = memcpy(@as(?*anyopaque, @ptrCast(&tmp)), @as(?*const anyopaque, @ptrCast(ptr + @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 8))))))), @as(c_ulong, @bitCast(@as(c_long, @as(c_int, 4))))); + if (@as(cgltf_size, @bitCast(@as(c_ulong, tmp))) > size) { + return @as(c_uint, @bitCast(cgltf_result_data_too_short)); + } + var json_chunk: [*c]const u8 = ptr + @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 12))))); + _ = &json_chunk; + if (@as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 12) + @as(c_int, 8)))) > size) { + return @as(c_uint, @bitCast(cgltf_result_data_too_short)); + } + var json_length: u32 = undefined; + _ = &json_length; + _ = memcpy(@as(?*anyopaque, @ptrCast(&json_length)), @as(?*const anyopaque, @ptrCast(json_chunk)), @as(c_ulong, @bitCast(@as(c_long, @as(c_int, 4))))); + if (@as(cgltf_size, @bitCast(@as(c_ulong, json_length))) > ((size -% @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 12))))) -% @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 8)))))) { + return @as(c_uint, @bitCast(cgltf_result_data_too_short)); + } + _ = memcpy(@as(?*anyopaque, @ptrCast(&tmp)), @as(?*const anyopaque, @ptrCast(json_chunk + @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 4))))))), @as(c_ulong, @bitCast(@as(c_long, @as(c_int, 4))))); + if (tmp != GlbMagicJsonChunk) { + return @as(c_uint, @bitCast(cgltf_result_unknown_format)); + } + json_chunk += @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 8))))); + var bin: ?*const anyopaque = null; + _ = &bin; + var bin_size: cgltf_size = 0; + _ = &bin_size; + if (@as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 8)))) <= (((size -% @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 12))))) -% @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 8))))) -% @as(cgltf_size, @bitCast(@as(c_ulong, json_length))))) { + var bin_chunk: [*c]const u8 = json_chunk + json_length; + _ = &bin_chunk; + var bin_length: u32 = undefined; + _ = &bin_length; + _ = memcpy(@as(?*anyopaque, @ptrCast(&bin_length)), @as(?*const anyopaque, @ptrCast(bin_chunk)), @as(c_ulong, @bitCast(@as(c_long, @as(c_int, 4))))); + if (@as(cgltf_size, @bitCast(@as(c_ulong, bin_length))) > ((((size -% @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 12))))) -% @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 8))))) -% @as(cgltf_size, @bitCast(@as(c_ulong, json_length)))) -% @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 8)))))) { + return @as(c_uint, @bitCast(cgltf_result_data_too_short)); + } + _ = memcpy(@as(?*anyopaque, @ptrCast(&tmp)), @as(?*const anyopaque, @ptrCast(bin_chunk + @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 4))))))), @as(c_ulong, @bitCast(@as(c_long, @as(c_int, 4))))); + if (tmp != GlbMagicBinChunk) { + return @as(c_uint, @bitCast(cgltf_result_unknown_format)); + } + bin_chunk += @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 8))))); + bin = @as(?*const anyopaque, @ptrCast(bin_chunk)); + bin_size = @as(cgltf_size, @bitCast(@as(c_ulong, bin_length))); + } + var json_result: cgltf_result = cgltf_parse_json(&fixed_options, json_chunk, @as(cgltf_size, @bitCast(@as(c_ulong, json_length))), out_data); + _ = &json_result; + if (json_result != @as(c_uint, @bitCast(cgltf_result_success))) { + return json_result; + } + out_data.*.*.file_type = @as(c_uint, @bitCast(cgltf_file_type_glb)); + out_data.*.*.bin = bin; + out_data.*.*.bin_size = bin_size; + return @as(c_uint, @bitCast(cgltf_result_success)); +} +pub export fn cgltf_parse_file(arg_options: [*c]const cgltf_options, arg_path: [*c]const u8, arg_out_data: [*c][*c]cgltf_data) cgltf_result { + var options = arg_options; + _ = &options; + var path = arg_path; + _ = &path; + var out_data = arg_out_data; + _ = &out_data; + if (options == @as([*c]const cgltf_options, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0))))))) { + return @as(c_uint, @bitCast(cgltf_result_invalid_options)); + } + var file_read: ?*const fn ([*c]const struct_cgltf_memory_options, [*c]const struct_cgltf_file_options, [*c]const u8, [*c]cgltf_size, [*c]?*anyopaque) callconv(.C) cgltf_result = if (options.*.file.read != null) options.*.file.read else &cgltf_default_file_read; + _ = &file_read; + var file_release: ?*const fn ([*c]const struct_cgltf_memory_options, [*c]const struct_cgltf_file_options, ?*anyopaque) callconv(.C) void = if (options.*.file.release != null) options.*.file.release else &cgltf_default_file_release; + _ = &file_release; + var file_data: ?*anyopaque = @as(?*anyopaque, @ptrFromInt(@as(c_int, 0))); + _ = &file_data; + var file_size: cgltf_size = 0; + _ = &file_size; + var result: cgltf_result = file_read.?(&options.*.memory, &options.*.file, path, &file_size, &file_data); + _ = &result; + if (result != @as(c_uint, @bitCast(cgltf_result_success))) { + return result; + } + result = cgltf_parse(options, file_data, file_size, out_data); + if (result != @as(c_uint, @bitCast(cgltf_result_success))) { + file_release.?(&options.*.memory, &options.*.file, file_data); + return result; + } + out_data.*.*.file_data = file_data; + return @as(c_uint, @bitCast(cgltf_result_success)); +} +pub export fn cgltf_load_buffers(arg_options: [*c]const cgltf_options, arg_data: [*c]cgltf_data, arg_gltf_path: [*c]const u8) cgltf_result { + var options = arg_options; + _ = &options; + var data = arg_data; + _ = &data; + var gltf_path = arg_gltf_path; + _ = &gltf_path; + if (options == @as([*c]const cgltf_options, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0))))))) { + return @as(c_uint, @bitCast(cgltf_result_invalid_options)); + } + if ((((data.*.buffers_count != 0) and (data.*.buffers[@as(c_uint, @intCast(@as(c_int, 0)))].data == @as(?*anyopaque, @ptrFromInt(@as(c_int, 0))))) and (data.*.buffers[@as(c_uint, @intCast(@as(c_int, 0)))].uri == @as([*c]u8, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0)))))))) and (data.*.bin != null)) { + if (data.*.bin_size < data.*.buffers[@as(c_uint, @intCast(@as(c_int, 0)))].size) { + return @as(c_uint, @bitCast(cgltf_result_data_too_short)); + } + data.*.buffers[@as(c_uint, @intCast(@as(c_int, 0)))].data = @as(?*anyopaque, @ptrCast(@volatileCast(@constCast(data.*.bin)))); + data.*.buffers[@as(c_uint, @intCast(@as(c_int, 0)))].data_free_method = @as(c_uint, @bitCast(cgltf_data_free_method_none)); + } + { + var i: cgltf_size = 0; + _ = &i; + while (i < data.*.buffers_count) : (i +%= 1) { + if (data.*.buffers[i].data != null) { + continue; + } + var uri: [*c]const u8 = data.*.buffers[i].uri; + _ = &uri; + if (uri == @as([*c]const u8, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0))))))) { + continue; + } + if (strncmp(uri, "data:", @as(c_ulong, @bitCast(@as(c_long, @as(c_int, 5))))) == @as(c_int, 0)) { + var comma: [*c]const u8 = strchr(uri, @as(c_int, ',')); + _ = , + if (((comma != null) and (@divExact(@as(c_long, @bitCast(@intFromPtr(comma) -% @intFromPtr(uri))), @sizeOf(u8)) >= @as(c_long, @bitCast(@as(c_long, @as(c_int, 7)))))) and (strncmp(comma - @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 7))))), ";base64", @as(c_ulong, @bitCast(@as(c_long, @as(c_int, 7))))) == @as(c_int, 0))) { + var res: cgltf_result = cgltf_load_buffer_base64(options, data.*.buffers[i].size, comma + @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 1))))), &data.*.buffers[i].data); + _ = &res; + data.*.buffers[i].data_free_method = @as(c_uint, @bitCast(cgltf_data_free_method_memory_free)); + if (res != @as(c_uint, @bitCast(cgltf_result_success))) { + return res; + } + } else { + return @as(c_uint, @bitCast(cgltf_result_unknown_format)); + } + } else if ((strstr(uri, "://") == @as([*c]u8, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0))))))) and (gltf_path != null)) { + var res: cgltf_result = cgltf_load_buffer_file(options, data.*.buffers[i].size, uri, gltf_path, &data.*.buffers[i].data); + _ = &res; + data.*.buffers[i].data_free_method = @as(c_uint, @bitCast(cgltf_data_free_method_file_release)); + if (res != @as(c_uint, @bitCast(cgltf_result_success))) { + return res; + } + } else { + return @as(c_uint, @bitCast(cgltf_result_unknown_format)); + } + } + } + return @as(c_uint, @bitCast(cgltf_result_success)); +} +pub export fn cgltf_load_buffer_base64(arg_options: [*c]const cgltf_options, arg_size: cgltf_size, arg_base64: [*c]const u8, arg_out_data: [*c]?*anyopaque) cgltf_result { + var options = arg_options; + _ = &options; + var size = arg_size; + _ = &size; + var base64 = arg_base64; + _ = &base64; + var out_data = arg_out_data; + _ = &out_data; + var memory_alloc: ?*const fn (?*anyopaque, cgltf_size) callconv(.C) ?*anyopaque = if (options.*.memory.alloc_func != null) options.*.memory.alloc_func else &cgltf_default_alloc; + _ = &memory_alloc; + var memory_free: ?*const fn (?*anyopaque, ?*anyopaque) callconv(.C) void = if (options.*.memory.free_func != null) options.*.memory.free_func else &cgltf_default_free; + _ = &memory_free; + var data: [*c]u8 = @as([*c]u8, @ptrCast(@alignCast(memory_alloc.?(options.*.memory.user_data, size)))); + _ = &data; + if (!(data != null)) { + return @as(c_uint, @bitCast(cgltf_result_out_of_memory)); + } + var buffer: c_uint = 0; + _ = &buffer; + var buffer_bits: c_uint = 0; + _ = &buffer_bits; + { + var i: cgltf_size = 0; + _ = &i; + while (i < size) : (i +%= 1) { + while (buffer_bits < @as(c_uint, @bitCast(@as(c_int, 8)))) { + var ch: u8 = (blk: { + const ref = &base64; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).*; + _ = &ch; + var index_1: c_int = if (@as(c_uint, @bitCast(@as(c_int, @bitCast(@as(c_uint, ch))) - @as(c_int, 'A'))) < @as(c_uint, @bitCast(@as(c_int, 26)))) @as(c_int, @bitCast(@as(c_uint, ch))) - @as(c_int, 'A') else if (@as(c_uint, @bitCast(@as(c_int, @bitCast(@as(c_uint, ch))) - @as(c_int, 'a'))) < @as(c_uint, @bitCast(@as(c_int, 26)))) (@as(c_int, @bitCast(@as(c_uint, ch))) - @as(c_int, 'a')) + @as(c_int, 26) else if (@as(c_uint, @bitCast(@as(c_int, @bitCast(@as(c_uint, ch))) - @as(c_int, '0'))) < @as(c_uint, @bitCast(@as(c_int, 10)))) (@as(c_int, @bitCast(@as(c_uint, ch))) - @as(c_int, '0')) + @as(c_int, 52) else if (@as(c_int, @bitCast(@as(c_uint, ch))) == @as(c_int, '+')) @as(c_int, 62) else if (@as(c_int, @bitCast(@as(c_uint, ch))) == @as(c_int, '/')) @as(c_int, 63) else -@as(c_int, 1); + _ = &index_1; + if (index_1 < @as(c_int, 0)) { + memory_free.?(options.*.memory.user_data, @as(?*anyopaque, @ptrCast(data))); + return @as(c_uint, @bitCast(cgltf_result_io_error)); + } + buffer = (buffer << @intCast(6)) | @as(c_uint, @bitCast(index_1)); + buffer_bits +%= @as(c_uint, @bitCast(@as(c_int, 6))); + } + data[i] = @as(u8, @bitCast(@as(u8, @truncate(buffer >> @intCast(buffer_bits -% @as(c_uint, @bitCast(@as(c_int, 8)))))))); + buffer_bits -%= @as(c_uint, @bitCast(@as(c_int, 8))); + } + } + out_data.* = @as(?*anyopaque, @ptrCast(data)); + return @as(c_uint, @bitCast(cgltf_result_success)); +} +pub export fn cgltf_decode_string(arg_string: [*c]u8) cgltf_size { + var string = arg_string; + _ = &string; + var read_1: [*c]u8 = string + strcspn(string, "\\"); + _ = &read_1; + if (@as(c_int, @bitCast(@as(c_uint, read_1.*))) == @as(c_int, 0)) { + return @as(cgltf_size, @bitCast(@divExact(@as(c_long, @bitCast(@intFromPtr(read_1) -% @intFromPtr(string))), @sizeOf(u8)))); + } + var write_2: [*c]u8 = string; + _ = &write_2; + var last: [*c]u8 = string; + _ = &last; + while (true) { + var written: cgltf_size = @as(cgltf_size, @bitCast(@divExact(@as(c_long, @bitCast(@intFromPtr(read_1) -% @intFromPtr(last))), @sizeOf(u8)))); + _ = &written; + _ = memmove(@as(?*anyopaque, @ptrCast(write_2)), @as(?*const anyopaque, @ptrCast(last)), written); + write_2 += @as([*c]u8, @ptrFromInt(written)); + if (@as(c_int, @bitCast(@as(c_uint, (blk: { + const ref = &read_1; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).*))) == @as(c_int, 0)) { + break; + } + while (true) { + switch (@as(c_int, @bitCast(@as(c_uint, (blk: { + const ref = &read_1; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).*)))) { + @as(c_int, 34) => { + (blk: { + const ref = &write_2; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = '"'; + break; + }, + @as(c_int, 47) => { + (blk: { + const ref = &write_2; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = '/'; + break; + }, + @as(c_int, 92) => { + (blk: { + const ref = &write_2; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = '\\'; + break; + }, + @as(c_int, 98) => { + (blk: { + const ref = &write_2; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = '\x08'; + break; + }, + @as(c_int, 102) => { + (blk: { + const ref = &write_2; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = '\x0c'; + break; + }, + @as(c_int, 114) => { + (blk: { + const ref = &write_2; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = '\r'; + break; + }, + @as(c_int, 110) => { + (blk: { + const ref = &write_2; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = '\n'; + break; + }, + @as(c_int, 116) => { + (blk: { + const ref = &write_2; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = '\t'; + break; + }, + @as(c_int, 117) => { + { + var character: c_int = 0; + _ = &character; + { + var i: cgltf_size = 0; + _ = &i; + while (i < @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 4))))) : (i +%= 1) { + character = (character << @intCast(4)) + cgltf_unhex((blk: { + const ref = &read_1; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).*); + } + } + if (character <= @as(c_int, 127)) { + (blk: { + const ref = &write_2; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = @as(u8, @bitCast(@as(i8, @truncate(character & @as(c_int, 255))))); + } else if (character <= @as(c_int, 2047)) { + (blk: { + const ref = &write_2; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 192) | ((character >> @intCast(6)) & @as(c_int, 255)))))); + (blk: { + const ref = &write_2; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 128) | (character & @as(c_int, 63)))))); + } else { + (blk: { + const ref = &write_2; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 224) | ((character >> @intCast(12)) & @as(c_int, 255)))))); + (blk: { + const ref = &write_2; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 128) | ((character >> @intCast(6)) & @as(c_int, 63)))))); + (blk: { + const ref = &write_2; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 128) | (character & @as(c_int, 63)))))); + } + break; + } + }, + else => break, + } + break; + } + last = read_1; + read_1 += @as([*c]u8, @ptrFromInt(strcspn(read_1, "\\"))); + } + write_2.* = 0; + return @as(cgltf_size, @bitCast(@divExact(@as(c_long, @bitCast(@intFromPtr(write_2) -% @intFromPtr(string))), @sizeOf(u8)))); +} +pub export fn cgltf_decode_uri(arg_uri: [*c]u8) cgltf_size { + var uri = arg_uri; + _ = &uri; + var write_1: [*c]u8 = uri; + _ = &write_1; + var i: [*c]u8 = uri; + _ = &i; + while (i.* != 0) { + if (@as(c_int, @bitCast(@as(c_uint, i.*))) == @as(c_int, '%')) { + var ch1: c_int = cgltf_unhex(i[@as(c_uint, @intCast(@as(c_int, 1)))]); + _ = &ch1; + if (ch1 >= @as(c_int, 0)) { + var ch2: c_int = cgltf_unhex(i[@as(c_uint, @intCast(@as(c_int, 2)))]); + _ = &ch2; + if (ch2 >= @as(c_int, 0)) { + (blk: { + const ref = &write_1; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = @as(u8, @bitCast(@as(i8, @truncate((ch1 * @as(c_int, 16)) + ch2)))); + i += @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 3))))); + continue; + } + } + } + (blk: { + const ref = &write_1; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = (blk: { + const ref = &i; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).*; + } + write_1.* = 0; + return @as(cgltf_size, @bitCast(@divExact(@as(c_long, @bitCast(@intFromPtr(write_1) -% @intFromPtr(uri))), @sizeOf(u8)))); +} +pub export fn cgltf_validate(arg_data: [*c]cgltf_data) cgltf_result { + var data = arg_data; + _ = &data; + { + var i: cgltf_size = 0; + _ = &i; + while (i < data.*.accessors_count) : (i +%= 1) { + var accessor: [*c]cgltf_accessor = &data.*.accessors[i]; + _ = &accessor; + if (data.*.accessors[i].component_type == @as(c_uint, @bitCast(cgltf_component_type_invalid))) return @as(c_uint, @bitCast(cgltf_result_invalid_gltf)); + if (data.*.accessors[i].type == @as(c_uint, @bitCast(cgltf_type_invalid))) return @as(c_uint, @bitCast(cgltf_result_invalid_gltf)); + var element_size: cgltf_size = cgltf_calc_size(accessor.*.type, accessor.*.component_type); + _ = &element_size; + if (accessor.*.buffer_view != null) { + var req_size: cgltf_size = (accessor.*.offset +% (accessor.*.stride *% (accessor.*.count -% @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 1))))))) +% element_size; + _ = &req_size; + if (accessor.*.buffer_view.*.size < req_size) return @as(c_uint, @bitCast(cgltf_result_data_too_short)); + } + if (accessor.*.is_sparse != 0) { + var sparse: [*c]cgltf_accessor_sparse = &accessor.*.sparse; + _ = &sparse; + var indices_component_size: cgltf_size = cgltf_component_size(sparse.*.indices_component_type); + _ = &indices_component_size; + var indices_req_size: cgltf_size = sparse.*.indices_byte_offset +% (indices_component_size *% sparse.*.count); + _ = &indices_req_size; + var values_req_size: cgltf_size = sparse.*.values_byte_offset +% (element_size *% sparse.*.count); + _ = &values_req_size; + if ((sparse.*.indices_buffer_view.*.size < indices_req_size) or (sparse.*.values_buffer_view.*.size < values_req_size)) return @as(c_uint, @bitCast(cgltf_result_data_too_short)); + if (((sparse.*.indices_component_type != @as(c_uint, @bitCast(cgltf_component_type_r_8u))) and (sparse.*.indices_component_type != @as(c_uint, @bitCast(cgltf_component_type_r_16u)))) and (sparse.*.indices_component_type != @as(c_uint, @bitCast(cgltf_component_type_r_32u)))) return @as(c_uint, @bitCast(cgltf_result_invalid_gltf)); + if (sparse.*.indices_buffer_view.*.buffer.*.data != null) { + var index_bound: cgltf_size = cgltf_calc_index_bound(sparse.*.indices_buffer_view, sparse.*.indices_byte_offset, sparse.*.indices_component_type, sparse.*.count); + _ = &index_bound; + if (index_bound >= accessor.*.count) return @as(c_uint, @bitCast(cgltf_result_data_too_short)); + } + } + } + } + { + var i: cgltf_size = 0; + _ = &i; + while (i < data.*.buffer_views_count) : (i +%= 1) { + var req_size: cgltf_size = data.*.buffer_views[i].offset +% data.*.buffer_views[i].size; + _ = &req_size; + if ((data.*.buffer_views[i].buffer != null) and (data.*.buffer_views[i].buffer.*.size < req_size)) return @as(c_uint, @bitCast(cgltf_result_data_too_short)); + if (data.*.buffer_views[i].has_meshopt_compression != 0) { + var mc: [*c]cgltf_meshopt_compression = &data.*.buffer_views[i].meshopt_compression; + _ = &mc; + if ((mc.*.buffer == @as([*c]cgltf_buffer, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0))))))) or (mc.*.buffer.*.size < (mc.*.offset +% mc.*.size))) return @as(c_uint, @bitCast(cgltf_result_data_too_short)); + if ((data.*.buffer_views[i].stride != 0) and (mc.*.stride != data.*.buffer_views[i].stride)) return @as(c_uint, @bitCast(cgltf_result_invalid_gltf)); + if (data.*.buffer_views[i].size != (mc.*.stride *% mc.*.count)) return @as(c_uint, @bitCast(cgltf_result_invalid_gltf)); + if (mc.*.mode == @as(c_uint, @bitCast(cgltf_meshopt_compression_mode_invalid))) return @as(c_uint, @bitCast(cgltf_result_invalid_gltf)); + if ((mc.*.mode == @as(c_uint, @bitCast(cgltf_meshopt_compression_mode_attributes))) and !(((mc.*.stride % @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 4))))) == @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 0))))) and (mc.*.stride <= @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 256))))))) return @as(c_uint, @bitCast(cgltf_result_invalid_gltf)); + if ((mc.*.mode == @as(c_uint, @bitCast(cgltf_meshopt_compression_mode_triangles))) and ((mc.*.count % @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 3))))) != @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 0)))))) return @as(c_uint, @bitCast(cgltf_result_invalid_gltf)); + if ((((mc.*.mode == @as(c_uint, @bitCast(cgltf_meshopt_compression_mode_triangles))) or (mc.*.mode == @as(c_uint, @bitCast(cgltf_meshopt_compression_mode_indices)))) and (mc.*.stride != @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 2)))))) and (mc.*.stride != @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 4)))))) return @as(c_uint, @bitCast(cgltf_result_invalid_gltf)); + if (((mc.*.mode == @as(c_uint, @bitCast(cgltf_meshopt_compression_mode_triangles))) or (mc.*.mode == @as(c_uint, @bitCast(cgltf_meshopt_compression_mode_indices)))) and (mc.*.filter != @as(c_uint, @bitCast(cgltf_meshopt_compression_filter_none)))) return @as(c_uint, @bitCast(cgltf_result_invalid_gltf)); + if (((mc.*.filter == @as(c_uint, @bitCast(cgltf_meshopt_compression_filter_octahedral))) and (mc.*.stride != @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 4)))))) and (mc.*.stride != @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 8)))))) return @as(c_uint, @bitCast(cgltf_result_invalid_gltf)); + if ((mc.*.filter == @as(c_uint, @bitCast(cgltf_meshopt_compression_filter_quaternion))) and (mc.*.stride != @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 8)))))) return @as(c_uint, @bitCast(cgltf_result_invalid_gltf)); + } + } + } + { + var i: cgltf_size = 0; + _ = &i; + while (i < data.*.meshes_count) : (i +%= 1) { + if (data.*.meshes[i].weights != null) { + if ((data.*.meshes[i].primitives_count != 0) and (data.*.meshes[i].primitives[@as(c_uint, @intCast(@as(c_int, 0)))].targets_count != data.*.meshes[i].weights_count)) return @as(c_uint, @bitCast(cgltf_result_invalid_gltf)); + } + if (data.*.meshes[i].target_names != null) { + if ((data.*.meshes[i].primitives_count != 0) and (data.*.meshes[i].primitives[@as(c_uint, @intCast(@as(c_int, 0)))].targets_count != data.*.meshes[i].target_names_count)) return @as(c_uint, @bitCast(cgltf_result_invalid_gltf)); + } + { + var j: cgltf_size = 0; + _ = &j; + while (j < data.*.meshes[i].primitives_count) : (j +%= 1) { + if (data.*.meshes[i].primitives[j].type == @as(c_uint, @bitCast(cgltf_primitive_type_invalid))) return @as(c_uint, @bitCast(cgltf_result_invalid_gltf)); + if (data.*.meshes[i].primitives[j].targets_count != data.*.meshes[i].primitives[@as(c_uint, @intCast(@as(c_int, 0)))].targets_count) return @as(c_uint, @bitCast(cgltf_result_invalid_gltf)); + if (data.*.meshes[i].primitives[j].attributes_count == @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 0))))) return @as(c_uint, @bitCast(cgltf_result_invalid_gltf)); + var first: [*c]cgltf_accessor = data.*.meshes[i].primitives[j].attributes[@as(c_uint, @intCast(@as(c_int, 0)))].data; + _ = &first; + if (first.*.count == @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 0))))) return @as(c_uint, @bitCast(cgltf_result_invalid_gltf)); + { + var k: cgltf_size = 0; + _ = &k; + while (k < data.*.meshes[i].primitives[j].attributes_count) : (k +%= 1) { + if (data.*.meshes[i].primitives[j].attributes[k].data.*.count != first.*.count) return @as(c_uint, @bitCast(cgltf_result_invalid_gltf)); + } + } + { + var k: cgltf_size = 0; + _ = &k; + while (k < data.*.meshes[i].primitives[j].targets_count) : (k +%= 1) { + { + var m: cgltf_size = 0; + _ = &m; + while (m < data.*.meshes[i].primitives[j].targets[k].attributes_count) : (m +%= 1) { + if (data.*.meshes[i].primitives[j].targets[k].attributes[m].data.*.count != first.*.count) return @as(c_uint, @bitCast(cgltf_result_invalid_gltf)); + } + } + } + } + var indices: [*c]cgltf_accessor = data.*.meshes[i].primitives[j].indices; + _ = &indices; + if ((((indices != null) and (indices.*.component_type != @as(c_uint, @bitCast(cgltf_component_type_r_8u)))) and (indices.*.component_type != @as(c_uint, @bitCast(cgltf_component_type_r_16u)))) and (indices.*.component_type != @as(c_uint, @bitCast(cgltf_component_type_r_32u)))) return @as(c_uint, @bitCast(cgltf_result_invalid_gltf)); + if ((indices != null) and (indices.*.type != @as(c_uint, @bitCast(cgltf_type_scalar)))) return @as(c_uint, @bitCast(cgltf_result_invalid_gltf)); + if ((indices != null) and (indices.*.stride != cgltf_component_size(indices.*.component_type))) return @as(c_uint, @bitCast(cgltf_result_invalid_gltf)); + if (((indices != null) and (indices.*.buffer_view != null)) and (indices.*.buffer_view.*.buffer.*.data != null)) { + var index_bound: cgltf_size = cgltf_calc_index_bound(indices.*.buffer_view, indices.*.offset, indices.*.component_type, indices.*.count); + _ = &index_bound; + if (index_bound >= first.*.count) return @as(c_uint, @bitCast(cgltf_result_data_too_short)); + } + { + var k: cgltf_size = 0; + _ = &k; + while (k < data.*.meshes[i].primitives[j].mappings_count) : (k +%= 1) { + if (data.*.meshes[i].primitives[j].mappings[k].variant >= data.*.variants_count) return @as(c_uint, @bitCast(cgltf_result_invalid_gltf)); + } + } + } + } + } + } + { + var i: cgltf_size = 0; + _ = &i; + while (i < data.*.nodes_count) : (i +%= 1) { + if ((data.*.nodes[i].weights != null) and (data.*.nodes[i].mesh != null)) { + if ((data.*.nodes[i].mesh.*.primitives_count != 0) and (data.*.nodes[i].mesh.*.primitives[@as(c_uint, @intCast(@as(c_int, 0)))].targets_count != data.*.nodes[i].weights_count)) return @as(c_uint, @bitCast(cgltf_result_invalid_gltf)); + } + } + } + { + var i: cgltf_size = 0; + _ = &i; + while (i < data.*.nodes_count) : (i +%= 1) { + var p1: [*c]cgltf_node = data.*.nodes[i].parent; + _ = &p1; + var p2: [*c]cgltf_node = if (p1 != null) p1.*.parent else null; + _ = &p2; + while ((p1 != null) and (p2 != null)) { + if (p1 == p2) return @as(c_uint, @bitCast(cgltf_result_invalid_gltf)); + p1 = p1.*.parent; + p2 = if (p2.*.parent != null) p2.*.parent.*.parent else null; + } + } + } + { + var i: cgltf_size = 0; + _ = &i; + while (i < data.*.scenes_count) : (i +%= 1) { + { + var j: cgltf_size = 0; + _ = &j; + while (j < data.*.scenes[i].nodes_count) : (j +%= 1) { + if (data.*.scenes[i].nodes[j].*.parent != null) return @as(c_uint, @bitCast(cgltf_result_invalid_gltf)); + } + } + } + } + { + var i: cgltf_size = 0; + _ = &i; + while (i < data.*.animations_count) : (i +%= 1) { + { + var j: cgltf_size = 0; + _ = &j; + while (j < data.*.animations[i].channels_count) : (j +%= 1) { + var channel: [*c]cgltf_animation_channel = &data.*.animations[i].channels[j]; + _ = &channel; + if (!(channel.*.target_node != null)) { + continue; + } + var components: cgltf_size = 1; + _ = &components; + if (channel.*.target_path == @as(c_uint, @bitCast(cgltf_animation_path_type_weights))) { + if (!(channel.*.target_node.*.mesh != null) or !(channel.*.target_node.*.mesh.*.primitives_count != 0)) return @as(c_uint, @bitCast(cgltf_result_invalid_gltf)); + components = channel.*.target_node.*.mesh.*.primitives[@as(c_uint, @intCast(@as(c_int, 0)))].targets_count; + } + var values: cgltf_size = @as(cgltf_size, @bitCast(@as(c_long, if (channel.*.sampler.*.interpolation == @as(c_uint, @bitCast(cgltf_interpolation_type_cubic_spline))) @as(c_int, 3) else @as(c_int, 1)))); + _ = &values; + if (((channel.*.sampler.*.input.*.count *% components) *% values) != channel.*.sampler.*.output.*.count) return @as(c_uint, @bitCast(cgltf_result_invalid_gltf)); + } + } + } + } + { + var i: cgltf_size = 0; + _ = &i; + while (i < data.*.variants_count) : (i +%= 1) { + if (!(data.*.variants[i].name != null)) return @as(c_uint, @bitCast(cgltf_result_invalid_gltf)); + } + } + return @as(c_uint, @bitCast(cgltf_result_success)); +} +pub export fn cgltf_free(arg_data: [*c]cgltf_data) void { + var data = arg_data; + _ = &data; + if (!(data != null)) { + return; + } + var file_release: ?*const fn ([*c]const struct_cgltf_memory_options, [*c]const struct_cgltf_file_options, ?*anyopaque) callconv(.C) void = if (data.*.file.release != null) data.*.file.release else &cgltf_default_file_release; + _ = &file_release; + data.*.memory.free_func.?(data.*.memory.user_data, @as(?*anyopaque, @ptrCast(data.*.asset.copyright))); + data.*.memory.free_func.?(data.*.memory.user_data, @as(?*anyopaque, @ptrCast(data.*.asset.generator))); + data.*.memory.free_func.?(data.*.memory.user_data, @as(?*anyopaque, @ptrCast(data.*.asset.version))); + data.*.memory.free_func.?(data.*.memory.user_data, @as(?*anyopaque, @ptrCast(data.*.asset.min_version))); + cgltf_free_extensions(data, data.*.asset.extensions, data.*.asset.extensions_count); + cgltf_free_extras(data, &data.*.asset.extras); + { + var i: cgltf_size = 0; + _ = &i; + while (i < data.*.accessors_count) : (i +%= 1) { + data.*.memory.free_func.?(data.*.memory.user_data, @as(?*anyopaque, @ptrCast(data.*.accessors[i].name))); + cgltf_free_extensions(data, data.*.accessors[i].extensions, data.*.accessors[i].extensions_count); + cgltf_free_extras(data, &data.*.accessors[i].extras); + } + } + data.*.memory.free_func.?(data.*.memory.user_data, @as(?*anyopaque, @ptrCast(data.*.accessors))); + { + var i: cgltf_size = 0; + _ = &i; + while (i < data.*.buffer_views_count) : (i +%= 1) { + data.*.memory.free_func.?(data.*.memory.user_data, @as(?*anyopaque, @ptrCast(data.*.buffer_views[i].name))); + data.*.memory.free_func.?(data.*.memory.user_data, data.*.buffer_views[i].data); + cgltf_free_extensions(data, data.*.buffer_views[i].extensions, data.*.buffer_views[i].extensions_count); + cgltf_free_extras(data, &data.*.buffer_views[i].extras); + } + } + data.*.memory.free_func.?(data.*.memory.user_data, @as(?*anyopaque, @ptrCast(data.*.buffer_views))); + { + var i: cgltf_size = 0; + _ = &i; + while (i < data.*.buffers_count) : (i +%= 1) { + data.*.memory.free_func.?(data.*.memory.user_data, @as(?*anyopaque, @ptrCast(data.*.buffers[i].name))); + if (data.*.buffers[i].data_free_method == @as(c_uint, @bitCast(cgltf_data_free_method_file_release))) { + file_release.?(&data.*.memory, &data.*.file, data.*.buffers[i].data); + } else if (data.*.buffers[i].data_free_method == @as(c_uint, @bitCast(cgltf_data_free_method_memory_free))) { + data.*.memory.free_func.?(data.*.memory.user_data, data.*.buffers[i].data); + } + data.*.memory.free_func.?(data.*.memory.user_data, @as(?*anyopaque, @ptrCast(data.*.buffers[i].uri))); + cgltf_free_extensions(data, data.*.buffers[i].extensions, data.*.buffers[i].extensions_count); + cgltf_free_extras(data, &data.*.buffers[i].extras); + } + } + data.*.memory.free_func.?(data.*.memory.user_data, @as(?*anyopaque, @ptrCast(data.*.buffers))); + { + var i: cgltf_size = 0; + _ = &i; + while (i < data.*.meshes_count) : (i +%= 1) { + data.*.memory.free_func.?(data.*.memory.user_data, @as(?*anyopaque, @ptrCast(data.*.meshes[i].name))); + { + var j: cgltf_size = 0; + _ = &j; + while (j < data.*.meshes[i].primitives_count) : (j +%= 1) { + { + var k: cgltf_size = 0; + _ = &k; + while (k < data.*.meshes[i].primitives[j].attributes_count) : (k +%= 1) { + data.*.memory.free_func.?(data.*.memory.user_data, @as(?*anyopaque, @ptrCast(data.*.meshes[i].primitives[j].attributes[k].name))); + } + } + data.*.memory.free_func.?(data.*.memory.user_data, @as(?*anyopaque, @ptrCast(data.*.meshes[i].primitives[j].attributes))); + { + var k: cgltf_size = 0; + _ = &k; + while (k < data.*.meshes[i].primitives[j].targets_count) : (k +%= 1) { + { + var m: cgltf_size = 0; + _ = &m; + while (m < data.*.meshes[i].primitives[j].targets[k].attributes_count) : (m +%= 1) { + data.*.memory.free_func.?(data.*.memory.user_data, @as(?*anyopaque, @ptrCast(data.*.meshes[i].primitives[j].targets[k].attributes[m].name))); + } + } + data.*.memory.free_func.?(data.*.memory.user_data, @as(?*anyopaque, @ptrCast(data.*.meshes[i].primitives[j].targets[k].attributes))); + } + } + data.*.memory.free_func.?(data.*.memory.user_data, @as(?*anyopaque, @ptrCast(data.*.meshes[i].primitives[j].targets))); + if (data.*.meshes[i].primitives[j].has_draco_mesh_compression != 0) { + { + var k: cgltf_size = 0; + _ = &k; + while (k < data.*.meshes[i].primitives[j].draco_mesh_compression.attributes_count) : (k +%= 1) { + data.*.memory.free_func.?(data.*.memory.user_data, @as(?*anyopaque, @ptrCast(data.*.meshes[i].primitives[j].draco_mesh_compression.attributes[k].name))); + } + } + data.*.memory.free_func.?(data.*.memory.user_data, @as(?*anyopaque, @ptrCast(data.*.meshes[i].primitives[j].draco_mesh_compression.attributes))); + } + { + var k: cgltf_size = 0; + _ = &k; + while (k < data.*.meshes[i].primitives[j].mappings_count) : (k +%= 1) { + cgltf_free_extras(data, &data.*.meshes[i].primitives[j].mappings[k].extras); + } + } + data.*.memory.free_func.?(data.*.memory.user_data, @as(?*anyopaque, @ptrCast(data.*.meshes[i].primitives[j].mappings))); + cgltf_free_extensions(data, data.*.meshes[i].primitives[j].extensions, data.*.meshes[i].primitives[j].extensions_count); + cgltf_free_extras(data, &data.*.meshes[i].primitives[j].extras); + } + } + data.*.memory.free_func.?(data.*.memory.user_data, @as(?*anyopaque, @ptrCast(data.*.meshes[i].primitives))); + data.*.memory.free_func.?(data.*.memory.user_data, @as(?*anyopaque, @ptrCast(data.*.meshes[i].weights))); + { + var j: cgltf_size = 0; + _ = &j; + while (j < data.*.meshes[i].target_names_count) : (j +%= 1) { + data.*.memory.free_func.?(data.*.memory.user_data, @as(?*anyopaque, @ptrCast(data.*.meshes[i].target_names[j]))); + } + } + cgltf_free_extensions(data, data.*.meshes[i].extensions, data.*.meshes[i].extensions_count); + cgltf_free_extras(data, &data.*.meshes[i].extras); + data.*.memory.free_func.?(data.*.memory.user_data, @as(?*anyopaque, @ptrCast(data.*.meshes[i].target_names))); + } + } + data.*.memory.free_func.?(data.*.memory.user_data, @as(?*anyopaque, @ptrCast(data.*.meshes))); + { + var i: cgltf_size = 0; + _ = &i; + while (i < data.*.materials_count) : (i +%= 1) { + data.*.memory.free_func.?(data.*.memory.user_data, @as(?*anyopaque, @ptrCast(data.*.materials[i].name))); + cgltf_free_extensions(data, data.*.materials[i].extensions, data.*.materials[i].extensions_count); + cgltf_free_extras(data, &data.*.materials[i].extras); + } + } + data.*.memory.free_func.?(data.*.memory.user_data, @as(?*anyopaque, @ptrCast(data.*.materials))); + { + var i: cgltf_size = 0; + _ = &i; + while (i < data.*.images_count) : (i +%= 1) { + data.*.memory.free_func.?(data.*.memory.user_data, @as(?*anyopaque, @ptrCast(data.*.images[i].name))); + data.*.memory.free_func.?(data.*.memory.user_data, @as(?*anyopaque, @ptrCast(data.*.images[i].uri))); + data.*.memory.free_func.?(data.*.memory.user_data, @as(?*anyopaque, @ptrCast(data.*.images[i].mime_type))); + cgltf_free_extensions(data, data.*.images[i].extensions, data.*.images[i].extensions_count); + cgltf_free_extras(data, &data.*.images[i].extras); + } + } + data.*.memory.free_func.?(data.*.memory.user_data, @as(?*anyopaque, @ptrCast(data.*.images))); + { + var i: cgltf_size = 0; + _ = &i; + while (i < data.*.textures_count) : (i +%= 1) { + data.*.memory.free_func.?(data.*.memory.user_data, @as(?*anyopaque, @ptrCast(data.*.textures[i].name))); + cgltf_free_extensions(data, data.*.textures[i].extensions, data.*.textures[i].extensions_count); + cgltf_free_extras(data, &data.*.textures[i].extras); + } + } + data.*.memory.free_func.?(data.*.memory.user_data, @as(?*anyopaque, @ptrCast(data.*.textures))); + { + var i: cgltf_size = 0; + _ = &i; + while (i < data.*.samplers_count) : (i +%= 1) { + data.*.memory.free_func.?(data.*.memory.user_data, @as(?*anyopaque, @ptrCast(data.*.samplers[i].name))); + cgltf_free_extensions(data, data.*.samplers[i].extensions, data.*.samplers[i].extensions_count); + cgltf_free_extras(data, &data.*.samplers[i].extras); + } + } + data.*.memory.free_func.?(data.*.memory.user_data, @as(?*anyopaque, @ptrCast(data.*.samplers))); + { + var i: cgltf_size = 0; + _ = &i; + while (i < data.*.skins_count) : (i +%= 1) { + data.*.memory.free_func.?(data.*.memory.user_data, @as(?*anyopaque, @ptrCast(data.*.skins[i].name))); + data.*.memory.free_func.?(data.*.memory.user_data, @as(?*anyopaque, @ptrCast(data.*.skins[i].joints))); + cgltf_free_extensions(data, data.*.skins[i].extensions, data.*.skins[i].extensions_count); + cgltf_free_extras(data, &data.*.skins[i].extras); + } + } + data.*.memory.free_func.?(data.*.memory.user_data, @as(?*anyopaque, @ptrCast(data.*.skins))); + { + var i: cgltf_size = 0; + _ = &i; + while (i < data.*.cameras_count) : (i +%= 1) { + data.*.memory.free_func.?(data.*.memory.user_data, @as(?*anyopaque, @ptrCast(data.*.cameras[i].name))); + if (data.*.cameras[i].type == @as(c_uint, @bitCast(cgltf_camera_type_perspective))) { + cgltf_free_extras(data, &data.*.cameras[i].data.perspective.extras); + } else if (data.*.cameras[i].type == @as(c_uint, @bitCast(cgltf_camera_type_orthographic))) { + cgltf_free_extras(data, &data.*.cameras[i].data.orthographic.extras); + } + cgltf_free_extensions(data, data.*.cameras[i].extensions, data.*.cameras[i].extensions_count); + cgltf_free_extras(data, &data.*.cameras[i].extras); + } + } + data.*.memory.free_func.?(data.*.memory.user_data, @as(?*anyopaque, @ptrCast(data.*.cameras))); + { + var i: cgltf_size = 0; + _ = &i; + while (i < data.*.lights_count) : (i +%= 1) { + data.*.memory.free_func.?(data.*.memory.user_data, @as(?*anyopaque, @ptrCast(data.*.lights[i].name))); + cgltf_free_extras(data, &data.*.lights[i].extras); + } + } + data.*.memory.free_func.?(data.*.memory.user_data, @as(?*anyopaque, @ptrCast(data.*.lights))); + { + var i: cgltf_size = 0; + _ = &i; + while (i < data.*.nodes_count) : (i +%= 1) { + data.*.memory.free_func.?(data.*.memory.user_data, @as(?*anyopaque, @ptrCast(data.*.nodes[i].name))); + data.*.memory.free_func.?(data.*.memory.user_data, @as(?*anyopaque, @ptrCast(data.*.nodes[i].children))); + data.*.memory.free_func.?(data.*.memory.user_data, @as(?*anyopaque, @ptrCast(data.*.nodes[i].weights))); + if (data.*.nodes[i].has_mesh_gpu_instancing != 0) { + { + var j: cgltf_size = 0; + _ = &j; + while (j < data.*.nodes[i].mesh_gpu_instancing.attributes_count) : (j +%= 1) { + data.*.memory.free_func.?(data.*.memory.user_data, @as(?*anyopaque, @ptrCast(data.*.nodes[i].mesh_gpu_instancing.attributes[j].name))); + } + } + data.*.memory.free_func.?(data.*.memory.user_data, @as(?*anyopaque, @ptrCast(data.*.nodes[i].mesh_gpu_instancing.attributes))); + } + cgltf_free_extensions(data, data.*.nodes[i].extensions, data.*.nodes[i].extensions_count); + cgltf_free_extras(data, &data.*.nodes[i].extras); + } + } + data.*.memory.free_func.?(data.*.memory.user_data, @as(?*anyopaque, @ptrCast(data.*.nodes))); + { + var i: cgltf_size = 0; + _ = &i; + while (i < data.*.scenes_count) : (i +%= 1) { + data.*.memory.free_func.?(data.*.memory.user_data, @as(?*anyopaque, @ptrCast(data.*.scenes[i].name))); + data.*.memory.free_func.?(data.*.memory.user_data, @as(?*anyopaque, @ptrCast(data.*.scenes[i].nodes))); + cgltf_free_extensions(data, data.*.scenes[i].extensions, data.*.scenes[i].extensions_count); + cgltf_free_extras(data, &data.*.scenes[i].extras); + } + } + data.*.memory.free_func.?(data.*.memory.user_data, @as(?*anyopaque, @ptrCast(data.*.scenes))); + { + var i: cgltf_size = 0; + _ = &i; + while (i < data.*.animations_count) : (i +%= 1) { + data.*.memory.free_func.?(data.*.memory.user_data, @as(?*anyopaque, @ptrCast(data.*.animations[i].name))); + { + var j: cgltf_size = 0; + _ = &j; + while (j < data.*.animations[i].samplers_count) : (j +%= 1) { + cgltf_free_extensions(data, data.*.animations[i].samplers[j].extensions, data.*.animations[i].samplers[j].extensions_count); + cgltf_free_extras(data, &data.*.animations[i].samplers[j].extras); + } + } + data.*.memory.free_func.?(data.*.memory.user_data, @as(?*anyopaque, @ptrCast(data.*.animations[i].samplers))); + { + var j: cgltf_size = 0; + _ = &j; + while (j < data.*.animations[i].channels_count) : (j +%= 1) { + cgltf_free_extensions(data, data.*.animations[i].channels[j].extensions, data.*.animations[i].channels[j].extensions_count); + cgltf_free_extras(data, &data.*.animations[i].channels[j].extras); + } + } + data.*.memory.free_func.?(data.*.memory.user_data, @as(?*anyopaque, @ptrCast(data.*.animations[i].channels))); + cgltf_free_extensions(data, data.*.animations[i].extensions, data.*.animations[i].extensions_count); + cgltf_free_extras(data, &data.*.animations[i].extras); + } + } + data.*.memory.free_func.?(data.*.memory.user_data, @as(?*anyopaque, @ptrCast(data.*.animations))); + { + var i: cgltf_size = 0; + _ = &i; + while (i < data.*.variants_count) : (i +%= 1) { + data.*.memory.free_func.?(data.*.memory.user_data, @as(?*anyopaque, @ptrCast(data.*.variants[i].name))); + cgltf_free_extras(data, &data.*.variants[i].extras); + } + } + data.*.memory.free_func.?(data.*.memory.user_data, @as(?*anyopaque, @ptrCast(data.*.variants))); + cgltf_free_extensions(data, data.*.data_extensions, data.*.data_extensions_count); + cgltf_free_extras(data, &data.*.extras); + { + var i: cgltf_size = 0; + _ = &i; + while (i < data.*.extensions_used_count) : (i +%= 1) { + data.*.memory.free_func.?(data.*.memory.user_data, @as(?*anyopaque, @ptrCast(data.*.extensions_used[i]))); + } + } + data.*.memory.free_func.?(data.*.memory.user_data, @as(?*anyopaque, @ptrCast(data.*.extensions_used))); + { + var i: cgltf_size = 0; + _ = &i; + while (i < data.*.extensions_required_count) : (i +%= 1) { + data.*.memory.free_func.?(data.*.memory.user_data, @as(?*anyopaque, @ptrCast(data.*.extensions_required[i]))); + } + } + data.*.memory.free_func.?(data.*.memory.user_data, @as(?*anyopaque, @ptrCast(data.*.extensions_required))); + file_release.?(&data.*.memory, &data.*.file, data.*.file_data); + data.*.memory.free_func.?(data.*.memory.user_data, @as(?*anyopaque, @ptrCast(data))); +} +pub export fn cgltf_node_transform_local(arg_node: [*c]const cgltf_node, arg_out_matrix: [*c]cgltf_float) void { + var node = arg_node; + _ = &node; + var out_matrix = arg_out_matrix; + _ = &out_matrix; + var lm: [*c]cgltf_float = out_matrix; + _ = &lm; + if (node.*.has_matrix != 0) { + _ = memcpy(@as(?*anyopaque, @ptrCast(lm)), @as(?*const anyopaque, @ptrCast(@as([*c]const cgltf_float, @ptrCast(@alignCast(&node.*.matrix))))), @sizeOf(f32) *% @as(c_ulong, @bitCast(@as(c_long, @as(c_int, 16))))); + } else { + var tx: f32 = node.*.translation[@as(c_uint, @intCast(@as(c_int, 0)))]; + _ = &tx; + var ty: f32 = node.*.translation[@as(c_uint, @intCast(@as(c_int, 1)))]; + _ = &ty; + var tz: f32 = node.*.translation[@as(c_uint, @intCast(@as(c_int, 2)))]; + _ = &tz; + var qx: f32 = node.*.rotation[@as(c_uint, @intCast(@as(c_int, 0)))]; + _ = &qx; + var qy: f32 = node.*.rotation[@as(c_uint, @intCast(@as(c_int, 1)))]; + _ = &qy; + var qz: f32 = node.*.rotation[@as(c_uint, @intCast(@as(c_int, 2)))]; + _ = &qz; + var qw: f32 = node.*.rotation[@as(c_uint, @intCast(@as(c_int, 3)))]; + _ = &qw; + var sx: f32 = node.*.scale[@as(c_uint, @intCast(@as(c_int, 0)))]; + _ = &sx; + var sy: f32 = node.*.scale[@as(c_uint, @intCast(@as(c_int, 1)))]; + _ = &sy; + var sz: f32 = node.*.scale[@as(c_uint, @intCast(@as(c_int, 2)))]; + _ = &sz; + lm[@as(c_uint, @intCast(@as(c_int, 0)))] = ((@as(f32, @floatFromInt(@as(c_int, 1))) - ((@as(f32, @floatFromInt(@as(c_int, 2))) * qy) * qy)) - ((@as(f32, @floatFromInt(@as(c_int, 2))) * qz) * qz)) * sx; + lm[@as(c_uint, @intCast(@as(c_int, 1)))] = (((@as(f32, @floatFromInt(@as(c_int, 2))) * qx) * qy) + ((@as(f32, @floatFromInt(@as(c_int, 2))) * qz) * qw)) * sx; + lm[@as(c_uint, @intCast(@as(c_int, 2)))] = (((@as(f32, @floatFromInt(@as(c_int, 2))) * qx) * qz) - ((@as(f32, @floatFromInt(@as(c_int, 2))) * qy) * qw)) * sx; + lm[@as(c_uint, @intCast(@as(c_int, 3)))] = 0.0; + lm[@as(c_uint, @intCast(@as(c_int, 4)))] = (((@as(f32, @floatFromInt(@as(c_int, 2))) * qx) * qy) - ((@as(f32, @floatFromInt(@as(c_int, 2))) * qz) * qw)) * sy; + lm[@as(c_uint, @intCast(@as(c_int, 5)))] = ((@as(f32, @floatFromInt(@as(c_int, 1))) - ((@as(f32, @floatFromInt(@as(c_int, 2))) * qx) * qx)) - ((@as(f32, @floatFromInt(@as(c_int, 2))) * qz) * qz)) * sy; + lm[@as(c_uint, @intCast(@as(c_int, 6)))] = (((@as(f32, @floatFromInt(@as(c_int, 2))) * qy) * qz) + ((@as(f32, @floatFromInt(@as(c_int, 2))) * qx) * qw)) * sy; + lm[@as(c_uint, @intCast(@as(c_int, 7)))] = 0.0; + lm[@as(c_uint, @intCast(@as(c_int, 8)))] = (((@as(f32, @floatFromInt(@as(c_int, 2))) * qx) * qz) + ((@as(f32, @floatFromInt(@as(c_int, 2))) * qy) * qw)) * sz; + lm[@as(c_uint, @intCast(@as(c_int, 9)))] = (((@as(f32, @floatFromInt(@as(c_int, 2))) * qy) * qz) - ((@as(f32, @floatFromInt(@as(c_int, 2))) * qx) * qw)) * sz; + lm[@as(c_uint, @intCast(@as(c_int, 10)))] = ((@as(f32, @floatFromInt(@as(c_int, 1))) - ((@as(f32, @floatFromInt(@as(c_int, 2))) * qx) * qx)) - ((@as(f32, @floatFromInt(@as(c_int, 2))) * qy) * qy)) * sz; + lm[@as(c_uint, @intCast(@as(c_int, 11)))] = 0.0; + lm[@as(c_uint, @intCast(@as(c_int, 12)))] = tx; + lm[@as(c_uint, @intCast(@as(c_int, 13)))] = ty; + lm[@as(c_uint, @intCast(@as(c_int, 14)))] = tz; + lm[@as(c_uint, @intCast(@as(c_int, 15)))] = 1.0; + } +} +pub export fn cgltf_node_transform_world(arg_node: [*c]const cgltf_node, arg_out_matrix: [*c]cgltf_float) void { + var node = arg_node; + _ = &node; + var out_matrix = arg_out_matrix; + _ = &out_matrix; + var lm: [*c]cgltf_float = out_matrix; + _ = &lm; + cgltf_node_transform_local(node, lm); + var parent: [*c]const cgltf_node = node.*.parent; + _ = &parent; + while (parent != null) { + var pm: [16]f32 = undefined; + _ = ± + cgltf_node_transform_local(parent, @as([*c]f32, @ptrCast(@alignCast(&pm)))); + { + var i: c_int = 0; + _ = &i; + while (i < @as(c_int, 4)) : (i += 1) { + var l0: f32 = (blk: { + const tmp = (i * @as(c_int, 4)) + @as(c_int, 0); + if (tmp >= 0) break :blk lm + @as(usize, @intCast(tmp)) else break :blk lm - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*; + _ = &l0; + var l1: f32 = (blk: { + const tmp = (i * @as(c_int, 4)) + @as(c_int, 1); + if (tmp >= 0) break :blk lm + @as(usize, @intCast(tmp)) else break :blk lm - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*; + _ = &l1; + var l2: f32 = (blk: { + const tmp = (i * @as(c_int, 4)) + @as(c_int, 2); + if (tmp >= 0) break :blk lm + @as(usize, @intCast(tmp)) else break :blk lm - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*; + _ = &l2; + var r0: f32 = ((l0 * pm[@as(c_uint, @intCast(@as(c_int, 0)))]) + (l1 * pm[@as(c_uint, @intCast(@as(c_int, 4)))])) + (l2 * pm[@as(c_uint, @intCast(@as(c_int, 8)))]); + _ = &r0; + var r1: f32 = ((l0 * pm[@as(c_uint, @intCast(@as(c_int, 1)))]) + (l1 * pm[@as(c_uint, @intCast(@as(c_int, 5)))])) + (l2 * pm[@as(c_uint, @intCast(@as(c_int, 9)))]); + _ = &r1; + var r2: f32 = ((l0 * pm[@as(c_uint, @intCast(@as(c_int, 2)))]) + (l1 * pm[@as(c_uint, @intCast(@as(c_int, 6)))])) + (l2 * pm[@as(c_uint, @intCast(@as(c_int, 10)))]); + _ = &r2; + (blk: { + const tmp = (i * @as(c_int, 4)) + @as(c_int, 0); + if (tmp >= 0) break :blk lm + @as(usize, @intCast(tmp)) else break :blk lm - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = r0; + (blk: { + const tmp = (i * @as(c_int, 4)) + @as(c_int, 1); + if (tmp >= 0) break :blk lm + @as(usize, @intCast(tmp)) else break :blk lm - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = r1; + (blk: { + const tmp = (i * @as(c_int, 4)) + @as(c_int, 2); + if (tmp >= 0) break :blk lm + @as(usize, @intCast(tmp)) else break :blk lm - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = r2; + } + } + lm[@as(c_uint, @intCast(@as(c_int, 12)))] += @as(cgltf_float, @floatCast(pm[@as(c_uint, @intCast(@as(c_int, 12)))])); + lm[@as(c_uint, @intCast(@as(c_int, 13)))] += @as(cgltf_float, @floatCast(pm[@as(c_uint, @intCast(@as(c_int, 13)))])); + lm[@as(c_uint, @intCast(@as(c_int, 14)))] += @as(cgltf_float, @floatCast(pm[@as(c_uint, @intCast(@as(c_int, 14)))])); + parent = parent.*.parent; + } +} +pub export fn cgltf_buffer_view_data(arg_view: [*c]const cgltf_buffer_view) [*c]const u8 { + var view = arg_view; + _ = &view; + if (view.*.data != null) return @as([*c]const u8, @ptrCast(@alignCast(view.*.data))); + if (!(view.*.buffer.*.data != null)) return null; + var result: [*c]const u8 = @as([*c]const u8, @ptrCast(@alignCast(view.*.buffer.*.data))); + _ = &result; + result += @as([*c]const u8, @ptrFromInt(view.*.offset)); + return result; +} +pub export fn cgltf_accessor_read_float(arg_accessor: [*c]const cgltf_accessor, arg_index_1: cgltf_size, arg_out: [*c]cgltf_float, arg_element_size: cgltf_size) cgltf_bool { + var accessor = arg_accessor; + _ = &accessor; + var index_1 = arg_index_1; + _ = &index_1; + var out = arg_out; + _ = &out; + var element_size = arg_element_size; + _ = &element_size; + if (accessor.*.is_sparse != 0) { + return 0; + } + if (accessor.*.buffer_view == @as([*c]cgltf_buffer_view, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0))))))) { + _ = memset(@as(?*anyopaque, @ptrCast(out)), @as(c_int, 0), element_size *% @sizeOf(cgltf_float)); + return 1; + } + var element: [*c]const u8 = cgltf_buffer_view_data(accessor.*.buffer_view); + _ = &element; + if (element == @as([*c]const u8, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0))))))) { + return 0; + } + element += @as([*c]const u8, @ptrFromInt(accessor.*.offset +% (accessor.*.stride *% index_1))); + return cgltf_element_read_float(element, accessor.*.type, accessor.*.component_type, accessor.*.normalized, out, element_size); +} +pub export fn cgltf_accessor_read_uint(arg_accessor: [*c]const cgltf_accessor, arg_index_1: cgltf_size, arg_out: [*c]cgltf_uint, arg_element_size: cgltf_size) cgltf_bool { + var accessor = arg_accessor; + _ = &accessor; + var index_1 = arg_index_1; + _ = &index_1; + var out = arg_out; + _ = &out; + var element_size = arg_element_size; + _ = &element_size; + if (accessor.*.is_sparse != 0) { + return 0; + } + if (accessor.*.buffer_view == @as([*c]cgltf_buffer_view, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0))))))) { + _ = memset(@as(?*anyopaque, @ptrCast(out)), @as(c_int, 0), element_size *% @sizeOf(cgltf_uint)); + return 1; + } + var element: [*c]const u8 = cgltf_buffer_view_data(accessor.*.buffer_view); + _ = &element; + if (element == @as([*c]const u8, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0))))))) { + return 0; + } + element += @as([*c]const u8, @ptrFromInt(accessor.*.offset +% (accessor.*.stride *% index_1))); + return cgltf_element_read_uint(element, accessor.*.type, accessor.*.component_type, out, element_size); +} +pub export fn cgltf_accessor_read_index(arg_accessor: [*c]const cgltf_accessor, arg_index_1: cgltf_size) cgltf_size { + var accessor = arg_accessor; + _ = &accessor; + var index_1 = arg_index_1; + _ = &index_1; + if (accessor.*.is_sparse != 0) { + return 0; + } + if (accessor.*.buffer_view == @as([*c]cgltf_buffer_view, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0))))))) { + return 0; + } + var element: [*c]const u8 = cgltf_buffer_view_data(accessor.*.buffer_view); + _ = &element; + if (element == @as([*c]const u8, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0))))))) { + return 0; + } + element += @as([*c]const u8, @ptrFromInt(accessor.*.offset +% (accessor.*.stride *% index_1))); + return cgltf_component_read_index(@as(?*const anyopaque, @ptrCast(element)), accessor.*.component_type); +} +pub export fn cgltf_num_components(arg_type: cgltf_type) cgltf_size { + var @"type" = arg_type; + _ = &@"type"; + while (true) { + switch (@"type") { + @as(c_uint, @bitCast(@as(c_int, 2))) => return 2, + @as(c_uint, @bitCast(@as(c_int, 3))) => return 3, + @as(c_uint, @bitCast(@as(c_int, 4))) => return 4, + @as(c_uint, @bitCast(@as(c_int, 5))) => return 4, + @as(c_uint, @bitCast(@as(c_int, 6))) => return 9, + @as(c_uint, @bitCast(@as(c_int, 7))) => return 16, + else => return 1, + } + break; + } + return @import("std").mem.zeroes(cgltf_size); +} +pub export fn cgltf_component_size(arg_component_type: cgltf_component_type) cgltf_size { + var component_type = arg_component_type; + _ = &component_type; + while (true) { + switch (component_type) { + @as(c_uint, @bitCast(@as(c_int, 1))), @as(c_uint, @bitCast(@as(c_int, 2))) => return 1, + @as(c_uint, @bitCast(@as(c_int, 3))), @as(c_uint, @bitCast(@as(c_int, 4))) => return 2, + @as(c_uint, @bitCast(@as(c_int, 5))), @as(c_uint, @bitCast(@as(c_int, 6))) => return 4, + else => return 0, + } + break; + } + return @import("std").mem.zeroes(cgltf_size); +} +pub export fn cgltf_calc_size(arg_type: cgltf_type, arg_component_type: cgltf_component_type) cgltf_size { + var @"type" = arg_type; + _ = &@"type"; + var component_type = arg_component_type; + _ = &component_type; + var component_size: cgltf_size = cgltf_component_size(component_type); + _ = &component_size; + if ((@"type" == @as(c_uint, @bitCast(cgltf_type_mat2))) and (component_size == @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 1)))))) { + return @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 8)))) *% component_size; + } else if ((@"type" == @as(c_uint, @bitCast(cgltf_type_mat3))) and ((component_size == @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 1))))) or (component_size == @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 2))))))) { + return @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 12)))) *% component_size; + } + return component_size *% cgltf_num_components(@"type"); +} +pub export fn cgltf_accessor_unpack_floats(arg_accessor: [*c]const cgltf_accessor, arg_out: [*c]cgltf_float, arg_float_count: cgltf_size) cgltf_size { + var accessor = arg_accessor; + _ = &accessor; + var out = arg_out; + _ = &out; + var float_count = arg_float_count; + _ = &float_count; + var floats_per_element: cgltf_size = cgltf_num_components(accessor.*.type); + _ = &floats_per_element; + var available_floats: cgltf_size = accessor.*.count *% floats_per_element; + _ = &available_floats; + if (out == @as([*c]cgltf_float, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0))))))) { + return available_floats; + } + float_count = if (available_floats < float_count) available_floats else float_count; + var element_count: cgltf_size = float_count / floats_per_element; + _ = &element_count; + if (accessor.*.buffer_view == @as([*c]cgltf_buffer_view, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0))))))) { + _ = memset(@as(?*anyopaque, @ptrCast(out)), @as(c_int, 0), (element_count *% floats_per_element) *% @sizeOf(cgltf_float)); + } else { + var element: [*c]const u8 = cgltf_buffer_view_data(accessor.*.buffer_view); + _ = &element; + if (element == @as([*c]const u8, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0))))))) { + return 0; + } + element += @as([*c]const u8, @ptrFromInt(accessor.*.offset)); + if ((accessor.*.component_type == @as(c_uint, @bitCast(cgltf_component_type_r_32f))) and (accessor.*.stride == (floats_per_element *% @sizeOf(cgltf_float)))) { + _ = memcpy(@as(?*anyopaque, @ptrCast(out)), @as(?*const anyopaque, @ptrCast(element)), (element_count *% floats_per_element) *% @sizeOf(cgltf_float)); + } else { + var dest: [*c]cgltf_float = out; + _ = &dest; + { + var index_1: cgltf_size = 0; + _ = &index_1; + while (index_1 < element_count) : (_ = blk: { + _ = blk_1: { + index_1 +%= 1; + break :blk_1 blk_2: { + const ref = &dest; + ref.* += @as([*c]cgltf_float, @ptrFromInt(floats_per_element)); + break :blk_2 ref.*; + }; + }; + break :blk blk_1: { + const ref = &element; + ref.* += @as([*c]const u8, @ptrFromInt(accessor.*.stride)); + break :blk_1 ref.*; + }; + }) { + if (!(cgltf_element_read_float(element, accessor.*.type, accessor.*.component_type, accessor.*.normalized, dest, floats_per_element) != 0)) { + return 0; + } + } + } + } + } + if (accessor.*.is_sparse != 0) { + var sparse: [*c]const cgltf_accessor_sparse = &accessor.*.sparse; + _ = &sparse; + var index_data: [*c]const u8 = cgltf_buffer_view_data(sparse.*.indices_buffer_view); + _ = &index_data; + var reader_head: [*c]const u8 = cgltf_buffer_view_data(sparse.*.values_buffer_view); + _ = &reader_head; + if ((index_data == @as([*c]const u8, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0))))))) or (reader_head == @as([*c]const u8, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0)))))))) { + return 0; + } + index_data += @as([*c]const u8, @ptrFromInt(sparse.*.indices_byte_offset)); + reader_head += @as([*c]const u8, @ptrFromInt(sparse.*.values_byte_offset)); + var index_stride: cgltf_size = cgltf_component_size(sparse.*.indices_component_type); + _ = &index_stride; + { + var reader_index: cgltf_size = 0; + _ = &reader_index; + while (reader_index < sparse.*.count) : (_ = blk: { + _ = blk_1: { + reader_index +%= 1; + break :blk_1 blk_2: { + const ref = &index_data; + ref.* += @as([*c]const u8, @ptrFromInt(index_stride)); + break :blk_2 ref.*; + }; + }; + break :blk blk_1: { + const ref = &reader_head; + ref.* += @as([*c]const u8, @ptrFromInt(accessor.*.stride)); + break :blk_1 ref.*; + }; + }) { + var writer_index: usize = cgltf_component_read_index(@as(?*const anyopaque, @ptrCast(index_data)), sparse.*.indices_component_type); + _ = &writer_index; + var writer_head: [*c]f32 = out + (writer_index *% floats_per_element); + _ = &writer_head; + if (!(cgltf_element_read_float(reader_head, accessor.*.type, accessor.*.component_type, accessor.*.normalized, writer_head, floats_per_element) != 0)) { + return 0; + } + } + } + } + return element_count *% floats_per_element; +} +pub export fn cgltf_accessor_unpack_indices(arg_accessor: [*c]const cgltf_accessor, arg_out: ?*anyopaque, arg_out_component_size: cgltf_size, arg_index_count: cgltf_size) cgltf_size { + var accessor = arg_accessor; + _ = &accessor; + var out = arg_out; + _ = &out; + var out_component_size = arg_out_component_size; + _ = &out_component_size; + var index_count = arg_index_count; + _ = &index_count; + if (out == @as(?*anyopaque, @ptrFromInt(@as(c_int, 0)))) { + return accessor.*.count; + } + index_count = if (accessor.*.count < index_count) accessor.*.count else index_count; + var index_component_size: cgltf_size = cgltf_component_size(accessor.*.component_type); + _ = &index_component_size; + if (accessor.*.is_sparse != 0) { + return 0; + } + if (accessor.*.buffer_view == @as([*c]cgltf_buffer_view, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0))))))) { + return 0; + } + if (index_component_size > out_component_size) { + return 0; + } + var element: [*c]const u8 = cgltf_buffer_view_data(accessor.*.buffer_view); + _ = &element; + if (element == @as([*c]const u8, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0))))))) { + return 0; + } + element += @as([*c]const u8, @ptrFromInt(accessor.*.offset)); + if ((index_component_size == out_component_size) and (accessor.*.stride == out_component_size)) { + _ = memcpy(out, @as(?*const anyopaque, @ptrCast(element)), index_count *% index_component_size); + return index_count; + } + while (true) { + switch (out_component_size) { + @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 2)))) => { + { + var index_1: cgltf_size = 0; + _ = &index_1; + while (index_1 < index_count) : (_ = blk: { + index_1 +%= 1; + break :blk blk_1: { + const ref = &element; + ref.* += @as([*c]const u8, @ptrFromInt(accessor.*.stride)); + break :blk_1 ref.*; + }; + }) { + @as([*c]u16, @ptrCast(@alignCast(out)))[index_1] = @as(u16, @bitCast(@as(c_ushort, @truncate(cgltf_component_read_index(@as(?*const anyopaque, @ptrCast(element)), accessor.*.component_type))))); + } + } + break; + }, + @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 4)))) => { + { + var index_1: cgltf_size = 0; + _ = &index_1; + while (index_1 < index_count) : (_ = blk: { + index_1 +%= 1; + break :blk blk_1: { + const ref = &element; + ref.* += @as([*c]const u8, @ptrFromInt(accessor.*.stride)); + break :blk_1 ref.*; + }; + }) { + @as([*c]u32, @ptrCast(@alignCast(out)))[index_1] = @as(u32, @bitCast(@as(c_uint, @truncate(cgltf_component_read_index(@as(?*const anyopaque, @ptrCast(element)), accessor.*.component_type))))); + } + } + break; + }, + else => break, + } + break; + } + return index_count; +} +pub export fn cgltf_copy_extras_json(arg_data: [*c]const cgltf_data, arg_extras: [*c]const cgltf_extras, arg_dest: [*c]u8, arg_dest_size: [*c]cgltf_size) cgltf_result { + var data = arg_data; + _ = &data; + var extras = arg_extras; + _ = &extras; + var dest = arg_dest; + _ = &dest; + var dest_size = arg_dest_size; + _ = &dest_size; + var json_size: cgltf_size = extras.*.end_offset -% extras.*.start_offset; + _ = &json_size; + if (!(dest != null)) { + if (dest_size != null) { + dest_size.* = json_size +% @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 1)))); + return @as(c_uint, @bitCast(cgltf_result_success)); + } + return @as(c_uint, @bitCast(cgltf_result_invalid_options)); + } + if ((dest_size.* +% @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 1))))) < json_size) { + _ = strncpy(dest, data.*.json + extras.*.start_offset, dest_size.* -% @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 1))))); + dest[dest_size.* -% @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 1))))] = 0; + } else { + _ = strncpy(dest, data.*.json + extras.*.start_offset, json_size); + dest[json_size] = 0; + } + return @as(c_uint, @bitCast(cgltf_result_success)); +} +pub export fn cgltf_mesh_index(arg_data: [*c]const cgltf_data, arg_object: [*c]const cgltf_mesh) cgltf_size { + var data = arg_data; + _ = &data; + var object = arg_object; + _ = &object; + _ = blk: { + _ = @sizeOf(c_int); + break :blk blk_1: { + break :blk_1 if ((object != null) and (@as(cgltf_size, @bitCast(@divExact(@as(c_long, @bitCast(@intFromPtr(object) -% @intFromPtr(data.*.meshes))), @sizeOf(cgltf_mesh)))) < data.*.meshes_count)) {} else { + __assert_fail("object && (cgltf_size)(object - data->meshes) < data->meshes_count", "./external/cgltf.h", @as(c_uint, @bitCast(@as(c_int, 2485))), "cgltf_size cgltf_mesh_index(const cgltf_data *, const cgltf_mesh *)"); + }; + }; + }; + return @as(cgltf_size, @bitCast(@divExact(@as(c_long, @bitCast(@intFromPtr(object) -% @intFromPtr(data.*.meshes))), @sizeOf(cgltf_mesh)))); +} +pub export fn cgltf_material_index(arg_data: [*c]const cgltf_data, arg_object: [*c]const cgltf_material) cgltf_size { + var data = arg_data; + _ = &data; + var object = arg_object; + _ = &object; + _ = blk: { + _ = @sizeOf(c_int); + break :blk blk_1: { + break :blk_1 if ((object != null) and (@as(cgltf_size, @bitCast(@divExact(@as(c_long, @bitCast(@intFromPtr(object) -% @intFromPtr(data.*.materials))), @sizeOf(cgltf_material)))) < data.*.materials_count)) {} else { + __assert_fail("object && (cgltf_size)(object - data->materials) < data->materials_count", "./external/cgltf.h", @as(c_uint, @bitCast(@as(c_int, 2491))), "cgltf_size cgltf_material_index(const cgltf_data *, const cgltf_material *)"); + }; + }; + }; + return @as(cgltf_size, @bitCast(@divExact(@as(c_long, @bitCast(@intFromPtr(object) -% @intFromPtr(data.*.materials))), @sizeOf(cgltf_material)))); +} +pub export fn cgltf_accessor_index(arg_data: [*c]const cgltf_data, arg_object: [*c]const cgltf_accessor) cgltf_size { + var data = arg_data; + _ = &data; + var object = arg_object; + _ = &object; + _ = blk: { + _ = @sizeOf(c_int); + break :blk blk_1: { + break :blk_1 if ((object != null) and (@as(cgltf_size, @bitCast(@divExact(@as(c_long, @bitCast(@intFromPtr(object) -% @intFromPtr(data.*.accessors))), @sizeOf(cgltf_accessor)))) < data.*.accessors_count)) {} else { + __assert_fail("object && (cgltf_size)(object - data->accessors) < data->accessors_count", "./external/cgltf.h", @as(c_uint, @bitCast(@as(c_int, 2497))), "cgltf_size cgltf_accessor_index(const cgltf_data *, const cgltf_accessor *)"); + }; + }; + }; + return @as(cgltf_size, @bitCast(@divExact(@as(c_long, @bitCast(@intFromPtr(object) -% @intFromPtr(data.*.accessors))), @sizeOf(cgltf_accessor)))); +} +pub export fn cgltf_buffer_view_index(arg_data: [*c]const cgltf_data, arg_object: [*c]const cgltf_buffer_view) cgltf_size { + var data = arg_data; + _ = &data; + var object = arg_object; + _ = &object; + _ = blk: { + _ = @sizeOf(c_int); + break :blk blk_1: { + break :blk_1 if ((object != null) and (@as(cgltf_size, @bitCast(@divExact(@as(c_long, @bitCast(@intFromPtr(object) -% @intFromPtr(data.*.buffer_views))), @sizeOf(cgltf_buffer_view)))) < data.*.buffer_views_count)) {} else { + __assert_fail("object && (cgltf_size)(object - data->buffer_views) < data->buffer_views_count", "./external/cgltf.h", @as(c_uint, @bitCast(@as(c_int, 2503))), "cgltf_size cgltf_buffer_view_index(const cgltf_data *, const cgltf_buffer_view *)"); + }; + }; + }; + return @as(cgltf_size, @bitCast(@divExact(@as(c_long, @bitCast(@intFromPtr(object) -% @intFromPtr(data.*.buffer_views))), @sizeOf(cgltf_buffer_view)))); +} +pub export fn cgltf_buffer_index(arg_data: [*c]const cgltf_data, arg_object: [*c]const cgltf_buffer) cgltf_size { + var data = arg_data; + _ = &data; + var object = arg_object; + _ = &object; + _ = blk: { + _ = @sizeOf(c_int); + break :blk blk_1: { + break :blk_1 if ((object != null) and (@as(cgltf_size, @bitCast(@divExact(@as(c_long, @bitCast(@intFromPtr(object) -% @intFromPtr(data.*.buffers))), @sizeOf(cgltf_buffer)))) < data.*.buffers_count)) {} else { + __assert_fail("object && (cgltf_size)(object - data->buffers) < data->buffers_count", "./external/cgltf.h", @as(c_uint, @bitCast(@as(c_int, 2509))), "cgltf_size cgltf_buffer_index(const cgltf_data *, const cgltf_buffer *)"); + }; + }; + }; + return @as(cgltf_size, @bitCast(@divExact(@as(c_long, @bitCast(@intFromPtr(object) -% @intFromPtr(data.*.buffers))), @sizeOf(cgltf_buffer)))); +} +pub export fn cgltf_image_index(arg_data: [*c]const cgltf_data, arg_object: [*c]const cgltf_image) cgltf_size { + var data = arg_data; + _ = &data; + var object = arg_object; + _ = &object; + _ = blk: { + _ = @sizeOf(c_int); + break :blk blk_1: { + break :blk_1 if ((object != null) and (@as(cgltf_size, @bitCast(@divExact(@as(c_long, @bitCast(@intFromPtr(object) -% @intFromPtr(data.*.images))), @sizeOf(cgltf_image)))) < data.*.images_count)) {} else { + __assert_fail("object && (cgltf_size)(object - data->images) < data->images_count", "./external/cgltf.h", @as(c_uint, @bitCast(@as(c_int, 2515))), "cgltf_size cgltf_image_index(const cgltf_data *, const cgltf_image *)"); + }; + }; + }; + return @as(cgltf_size, @bitCast(@divExact(@as(c_long, @bitCast(@intFromPtr(object) -% @intFromPtr(data.*.images))), @sizeOf(cgltf_image)))); +} +pub export fn cgltf_texture_index(arg_data: [*c]const cgltf_data, arg_object: [*c]const cgltf_texture) cgltf_size { + var data = arg_data; + _ = &data; + var object = arg_object; + _ = &object; + _ = blk: { + _ = @sizeOf(c_int); + break :blk blk_1: { + break :blk_1 if ((object != null) and (@as(cgltf_size, @bitCast(@divExact(@as(c_long, @bitCast(@intFromPtr(object) -% @intFromPtr(data.*.textures))), @sizeOf(cgltf_texture)))) < data.*.textures_count)) {} else { + __assert_fail("object && (cgltf_size)(object - data->textures) < data->textures_count", "./external/cgltf.h", @as(c_uint, @bitCast(@as(c_int, 2521))), "cgltf_size cgltf_texture_index(const cgltf_data *, const cgltf_texture *)"); + }; + }; + }; + return @as(cgltf_size, @bitCast(@divExact(@as(c_long, @bitCast(@intFromPtr(object) -% @intFromPtr(data.*.textures))), @sizeOf(cgltf_texture)))); +} +pub export fn cgltf_sampler_index(arg_data: [*c]const cgltf_data, arg_object: [*c]const cgltf_sampler) cgltf_size { + var data = arg_data; + _ = &data; + var object = arg_object; + _ = &object; + _ = blk: { + _ = @sizeOf(c_int); + break :blk blk_1: { + break :blk_1 if ((object != null) and (@as(cgltf_size, @bitCast(@divExact(@as(c_long, @bitCast(@intFromPtr(object) -% @intFromPtr(data.*.samplers))), @sizeOf(cgltf_sampler)))) < data.*.samplers_count)) {} else { + __assert_fail("object && (cgltf_size)(object - data->samplers) < data->samplers_count", "./external/cgltf.h", @as(c_uint, @bitCast(@as(c_int, 2527))), "cgltf_size cgltf_sampler_index(const cgltf_data *, const cgltf_sampler *)"); + }; + }; + }; + return @as(cgltf_size, @bitCast(@divExact(@as(c_long, @bitCast(@intFromPtr(object) -% @intFromPtr(data.*.samplers))), @sizeOf(cgltf_sampler)))); +} +pub export fn cgltf_skin_index(arg_data: [*c]const cgltf_data, arg_object: [*c]const cgltf_skin) cgltf_size { + var data = arg_data; + _ = &data; + var object = arg_object; + _ = &object; + _ = blk: { + _ = @sizeOf(c_int); + break :blk blk_1: { + break :blk_1 if ((object != null) and (@as(cgltf_size, @bitCast(@divExact(@as(c_long, @bitCast(@intFromPtr(object) -% @intFromPtr(data.*.skins))), @sizeOf(cgltf_skin)))) < data.*.skins_count)) {} else { + __assert_fail("object && (cgltf_size)(object - data->skins) < data->skins_count", "./external/cgltf.h", @as(c_uint, @bitCast(@as(c_int, 2533))), "cgltf_size cgltf_skin_index(const cgltf_data *, const cgltf_skin *)"); + }; + }; + }; + return @as(cgltf_size, @bitCast(@divExact(@as(c_long, @bitCast(@intFromPtr(object) -% @intFromPtr(data.*.skins))), @sizeOf(cgltf_skin)))); +} +pub export fn cgltf_camera_index(arg_data: [*c]const cgltf_data, arg_object: [*c]const cgltf_camera) cgltf_size { + var data = arg_data; + _ = &data; + var object = arg_object; + _ = &object; + _ = blk: { + _ = @sizeOf(c_int); + break :blk blk_1: { + break :blk_1 if ((object != null) and (@as(cgltf_size, @bitCast(@divExact(@as(c_long, @bitCast(@intFromPtr(object) -% @intFromPtr(data.*.cameras))), @sizeOf(cgltf_camera)))) < data.*.cameras_count)) {} else { + __assert_fail("object && (cgltf_size)(object - data->cameras) < data->cameras_count", "./external/cgltf.h", @as(c_uint, @bitCast(@as(c_int, 2539))), "cgltf_size cgltf_camera_index(const cgltf_data *, const cgltf_camera *)"); + }; + }; + }; + return @as(cgltf_size, @bitCast(@divExact(@as(c_long, @bitCast(@intFromPtr(object) -% @intFromPtr(data.*.cameras))), @sizeOf(cgltf_camera)))); +} +pub export fn cgltf_light_index(arg_data: [*c]const cgltf_data, arg_object: [*c]const cgltf_light) cgltf_size { + var data = arg_data; + _ = &data; + var object = arg_object; + _ = &object; + _ = blk: { + _ = @sizeOf(c_int); + break :blk blk_1: { + break :blk_1 if ((object != null) and (@as(cgltf_size, @bitCast(@divExact(@as(c_long, @bitCast(@intFromPtr(object) -% @intFromPtr(data.*.lights))), @sizeOf(cgltf_light)))) < data.*.lights_count)) {} else { + __assert_fail("object && (cgltf_size)(object - data->lights) < data->lights_count", "./external/cgltf.h", @as(c_uint, @bitCast(@as(c_int, 2545))), "cgltf_size cgltf_light_index(const cgltf_data *, const cgltf_light *)"); + }; + }; + }; + return @as(cgltf_size, @bitCast(@divExact(@as(c_long, @bitCast(@intFromPtr(object) -% @intFromPtr(data.*.lights))), @sizeOf(cgltf_light)))); +} +pub export fn cgltf_node_index(arg_data: [*c]const cgltf_data, arg_object: [*c]const cgltf_node) cgltf_size { + var data = arg_data; + _ = &data; + var object = arg_object; + _ = &object; + _ = blk: { + _ = @sizeOf(c_int); + break :blk blk_1: { + break :blk_1 if ((object != null) and (@as(cgltf_size, @bitCast(@divExact(@as(c_long, @bitCast(@intFromPtr(object) -% @intFromPtr(data.*.nodes))), @sizeOf(cgltf_node)))) < data.*.nodes_count)) {} else { + __assert_fail("object && (cgltf_size)(object - data->nodes) < data->nodes_count", "./external/cgltf.h", @as(c_uint, @bitCast(@as(c_int, 2551))), "cgltf_size cgltf_node_index(const cgltf_data *, const cgltf_node *)"); + }; + }; + }; + return @as(cgltf_size, @bitCast(@divExact(@as(c_long, @bitCast(@intFromPtr(object) -% @intFromPtr(data.*.nodes))), @sizeOf(cgltf_node)))); +} +pub export fn cgltf_scene_index(arg_data: [*c]const cgltf_data, arg_object: [*c]const cgltf_scene) cgltf_size { + var data = arg_data; + _ = &data; + var object = arg_object; + _ = &object; + _ = blk: { + _ = @sizeOf(c_int); + break :blk blk_1: { + break :blk_1 if ((object != null) and (@as(cgltf_size, @bitCast(@divExact(@as(c_long, @bitCast(@intFromPtr(object) -% @intFromPtr(data.*.scenes))), @sizeOf(cgltf_scene)))) < data.*.scenes_count)) {} else { + __assert_fail("object && (cgltf_size)(object - data->scenes) < data->scenes_count", "./external/cgltf.h", @as(c_uint, @bitCast(@as(c_int, 2557))), "cgltf_size cgltf_scene_index(const cgltf_data *, const cgltf_scene *)"); + }; + }; + }; + return @as(cgltf_size, @bitCast(@divExact(@as(c_long, @bitCast(@intFromPtr(object) -% @intFromPtr(data.*.scenes))), @sizeOf(cgltf_scene)))); +} +pub export fn cgltf_animation_index(arg_data: [*c]const cgltf_data, arg_object: [*c]const cgltf_animation) cgltf_size { + var data = arg_data; + _ = &data; + var object = arg_object; + _ = &object; + _ = blk: { + _ = @sizeOf(c_int); + break :blk blk_1: { + break :blk_1 if ((object != null) and (@as(cgltf_size, @bitCast(@divExact(@as(c_long, @bitCast(@intFromPtr(object) -% @intFromPtr(data.*.animations))), @sizeOf(cgltf_animation)))) < data.*.animations_count)) {} else { + __assert_fail("object && (cgltf_size)(object - data->animations) < data->animations_count", "./external/cgltf.h", @as(c_uint, @bitCast(@as(c_int, 2563))), "cgltf_size cgltf_animation_index(const cgltf_data *, const cgltf_animation *)"); + }; + }; + }; + return @as(cgltf_size, @bitCast(@divExact(@as(c_long, @bitCast(@intFromPtr(object) -% @intFromPtr(data.*.animations))), @sizeOf(cgltf_animation)))); +} +pub export fn cgltf_animation_sampler_index(arg_animation: [*c]const cgltf_animation, arg_object: [*c]const cgltf_animation_sampler) cgltf_size { + var animation = arg_animation; + _ = &animation; + var object = arg_object; + _ = &object; + _ = blk: { + _ = @sizeOf(c_int); + break :blk blk_1: { + break :blk_1 if ((object != null) and (@as(cgltf_size, @bitCast(@divExact(@as(c_long, @bitCast(@intFromPtr(object) -% @intFromPtr(animation.*.samplers))), @sizeOf(cgltf_animation_sampler)))) < animation.*.samplers_count)) {} else { + __assert_fail("object && (cgltf_size)(object - animation->samplers) < animation->samplers_count", "./external/cgltf.h", @as(c_uint, @bitCast(@as(c_int, 2569))), "cgltf_size cgltf_animation_sampler_index(const cgltf_animation *, const cgltf_animation_sampler *)"); + }; + }; + }; + return @as(cgltf_size, @bitCast(@divExact(@as(c_long, @bitCast(@intFromPtr(object) -% @intFromPtr(animation.*.samplers))), @sizeOf(cgltf_animation_sampler)))); +} +pub export fn cgltf_animation_channel_index(arg_animation: [*c]const cgltf_animation, arg_object: [*c]const cgltf_animation_channel) cgltf_size { + var animation = arg_animation; + _ = &animation; + var object = arg_object; + _ = &object; + _ = blk: { + _ = @sizeOf(c_int); + break :blk blk_1: { + break :blk_1 if ((object != null) and (@as(cgltf_size, @bitCast(@divExact(@as(c_long, @bitCast(@intFromPtr(object) -% @intFromPtr(animation.*.channels))), @sizeOf(cgltf_animation_channel)))) < animation.*.channels_count)) {} else { + __assert_fail("object && (cgltf_size)(object - animation->channels) < animation->channels_count", "./external/cgltf.h", @as(c_uint, @bitCast(@as(c_int, 2575))), "cgltf_size cgltf_animation_channel_index(const cgltf_animation *, const cgltf_animation_channel *)"); + }; + }; + }; + return @as(cgltf_size, @bitCast(@divExact(@as(c_long, @bitCast(@intFromPtr(object) -% @intFromPtr(animation.*.channels))), @sizeOf(cgltf_animation_channel)))); +} +pub const JSMN_UNDEFINED: c_int = 0; +pub const JSMN_OBJECT: c_int = 1; +pub const JSMN_ARRAY: c_int = 2; +pub const JSMN_STRING: c_int = 3; +pub const JSMN_PRIMITIVE: c_int = 4; +pub const jsmntype_t = c_uint; +pub const JSMN_ERROR_NOMEM: c_int = -1; +pub const JSMN_ERROR_INVAL: c_int = -2; +pub const JSMN_ERROR_PART: c_int = -3; +pub const enum_jsmnerr = c_int; +pub const jsmntok_t = extern struct { + type: jsmntype_t = @import("std").mem.zeroes(jsmntype_t), + start: ptrdiff_t = @import("std").mem.zeroes(ptrdiff_t), + end: ptrdiff_t = @import("std").mem.zeroes(ptrdiff_t), + size: c_int = @import("std").mem.zeroes(c_int), + parent: c_int = @import("std").mem.zeroes(c_int), +}; +pub const jsmn_parser = extern struct { + pos: usize = @import("std").mem.zeroes(usize), + toknext: c_uint = @import("std").mem.zeroes(c_uint), + toksuper: c_int = @import("std").mem.zeroes(c_int), +}; +pub fn jsmn_init(arg_parser: [*c]jsmn_parser) callconv(.C) void { + var parser = arg_parser; + _ = &parser; + parser.*.pos = 0; + parser.*.toknext = 0; + parser.*.toksuper = -@as(c_int, 1); +} +pub fn jsmn_parse(arg_parser: [*c]jsmn_parser, arg_js: [*c]const u8, arg_len: usize, arg_tokens: [*c]jsmntok_t, arg_num_tokens: usize) callconv(.C) c_int { + var parser = arg_parser; + _ = &parser; + var js = arg_js; + _ = &js; + var len = arg_len; + _ = &len; + var tokens = arg_tokens; + _ = &tokens; + var num_tokens = arg_num_tokens; + _ = &num_tokens; + var r: c_int = undefined; + _ = &r; + var i: c_int = undefined; + _ = &i; + var token: [*c]jsmntok_t = undefined; + _ = &token; + var count: c_int = @as(c_int, @bitCast(parser.*.toknext)); + _ = &count; + while ((parser.*.pos < len) and (@as(c_int, @bitCast(@as(c_uint, js[parser.*.pos]))) != @as(c_int, '\x00'))) : (parser.*.pos +%= 1) { + var c: u8 = undefined; + _ = &c; + var @"type": jsmntype_t = undefined; + _ = &@"type"; + c = js[parser.*.pos]; + while (true) { + switch (@as(c_int, @bitCast(@as(c_uint, c)))) { + @as(c_int, 123), @as(c_int, 91) => { + count += 1; + if (tokens == @as([*c]jsmntok_t, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0))))))) { + break; + } + token = jsmn_alloc_token(parser, tokens, num_tokens); + if (token == @as([*c]jsmntok_t, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0))))))) return JSMN_ERROR_NOMEM; + if (parser.*.toksuper != -@as(c_int, 1)) { + (blk: { + const tmp = parser.*.toksuper; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.size += 1; + token.*.parent = parser.*.toksuper; + } + token.*.type = @as(c_uint, @bitCast(if (@as(c_int, @bitCast(@as(c_uint, c))) == @as(c_int, '{')) JSMN_OBJECT else JSMN_ARRAY)); + token.*.start = @as(ptrdiff_t, @bitCast(parser.*.pos)); + parser.*.toksuper = @as(c_int, @bitCast(parser.*.toknext -% @as(c_uint, @bitCast(@as(c_int, 1))))); + break; + }, + @as(c_int, 125), @as(c_int, 93) => { + if (tokens == @as([*c]jsmntok_t, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0))))))) break; + @"type" = @as(c_uint, @bitCast(if (@as(c_int, @bitCast(@as(c_uint, c))) == @as(c_int, '}')) JSMN_OBJECT else JSMN_ARRAY)); + if (parser.*.toknext < @as(c_uint, @bitCast(@as(c_int, 1)))) { + return JSMN_ERROR_INVAL; + } + token = &tokens[parser.*.toknext -% @as(c_uint, @bitCast(@as(c_int, 1)))]; + while (true) { + if ((token.*.start != @as(ptrdiff_t, @bitCast(@as(c_long, -@as(c_int, 1))))) and (token.*.end == @as(ptrdiff_t, @bitCast(@as(c_long, -@as(c_int, 1)))))) { + if (token.*.type != @"type") { + return JSMN_ERROR_INVAL; + } + token.*.end = @as(ptrdiff_t, @bitCast(parser.*.pos +% @as(usize, @bitCast(@as(c_long, @as(c_int, 1)))))); + parser.*.toksuper = token.*.parent; + break; + } + if (token.*.parent == -@as(c_int, 1)) { + if ((token.*.type != @"type") or (parser.*.toksuper == -@as(c_int, 1))) { + return JSMN_ERROR_INVAL; + } + break; + } + token = &(blk: { + const tmp = token.*.parent; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*; + } + break; + }, + @as(c_int, 34) => { + r = jsmn_parse_string(parser, js, len, tokens, num_tokens); + if (r < @as(c_int, 0)) return r; + count += 1; + if ((parser.*.toksuper != -@as(c_int, 1)) and (tokens != @as([*c]jsmntok_t, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0)))))))) { + (blk: { + const tmp = parser.*.toksuper; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.size += 1; + } + break; + }, + @as(c_int, 9), @as(c_int, 13), @as(c_int, 10), @as(c_int, 32) => break, + @as(c_int, 58) => { + parser.*.toksuper = @as(c_int, @bitCast(parser.*.toknext -% @as(c_uint, @bitCast(@as(c_int, 1))))); + break; + }, + @as(c_int, 44) => { + if ((((tokens != @as([*c]jsmntok_t, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0))))))) and (parser.*.toksuper != -@as(c_int, 1))) and ((blk: { + const tmp = parser.*.toksuper; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.type != @as(c_uint, @bitCast(JSMN_ARRAY)))) and ((blk: { + const tmp = parser.*.toksuper; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.type != @as(c_uint, @bitCast(JSMN_OBJECT)))) { + parser.*.toksuper = (blk: { + const tmp = parser.*.toksuper; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.parent; + } + break; + }, + @as(c_int, 45), @as(c_int, 48), @as(c_int, 49), @as(c_int, 50), @as(c_int, 51), @as(c_int, 52), @as(c_int, 53), @as(c_int, 54), @as(c_int, 55), @as(c_int, 56), @as(c_int, 57), @as(c_int, 116), @as(c_int, 102), @as(c_int, 110) => { + if ((tokens != @as([*c]jsmntok_t, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0))))))) and (parser.*.toksuper != -@as(c_int, 1))) { + var t: [*c]jsmntok_t = &(blk: { + const tmp = parser.*.toksuper; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*; + _ = &t; + if ((t.*.type == @as(c_uint, @bitCast(JSMN_OBJECT))) or ((t.*.type == @as(c_uint, @bitCast(JSMN_STRING))) and (t.*.size != @as(c_int, 0)))) { + return JSMN_ERROR_INVAL; + } + } + r = jsmn_parse_primitive(parser, js, len, tokens, num_tokens); + if (r < @as(c_int, 0)) return r; + count += 1; + if ((parser.*.toksuper != -@as(c_int, 1)) and (tokens != @as([*c]jsmntok_t, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0)))))))) { + (blk: { + const tmp = parser.*.toksuper; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.size += 1; + } + break; + }, + else => return JSMN_ERROR_INVAL, + } + break; + } + } + if (tokens != @as([*c]jsmntok_t, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0))))))) { + { + i = @as(c_int, @bitCast(parser.*.toknext -% @as(c_uint, @bitCast(@as(c_int, 1))))); + while (i >= @as(c_int, 0)) : (i -= 1) { + if (((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.start != @as(ptrdiff_t, @bitCast(@as(c_long, -@as(c_int, 1))))) and ((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.end == @as(ptrdiff_t, @bitCast(@as(c_long, -@as(c_int, 1)))))) { + return JSMN_ERROR_PART; + } + } + } + } + return count; +} +pub const GlbVersion: u32 = 2; +pub const GlbMagic: u32 = @as(u32, @bitCast(@as(c_int, 1179937895))); +pub const GlbMagicJsonChunk: u32 = @as(u32, @bitCast(@as(c_int, 1313821514))); +pub const GlbMagicBinChunk: u32 = @as(u32, @bitCast(@as(c_int, 5130562))); +pub fn cgltf_default_alloc(arg_user: ?*anyopaque, arg_size: cgltf_size) callconv(.C) ?*anyopaque { + var user = arg_user; + _ = &user; + var size = arg_size; + _ = &size; + _ = &user; + return malloc(size); +} +pub fn cgltf_default_free(arg_user: ?*anyopaque, arg_ptr: ?*anyopaque) callconv(.C) void { + var user = arg_user; + _ = &user; + var ptr = arg_ptr; + _ = &ptr; + _ = &user; + free(ptr); +} +pub fn cgltf_calloc(arg_options: [*c]cgltf_options, arg_element_size: usize, arg_count: cgltf_size) callconv(.C) ?*anyopaque { + var options = arg_options; + _ = &options; + var element_size = arg_element_size; + _ = &element_size; + var count = arg_count; + _ = &count; + if ((@as(c_ulong, 18446744073709551615) / element_size) < count) { + return @as(?*anyopaque, @ptrFromInt(@as(c_int, 0))); + } + var result: ?*anyopaque = options.*.memory.alloc_func.?(options.*.memory.user_data, element_size *% count); + _ = &result; + if (!(result != null)) { + return @as(?*anyopaque, @ptrFromInt(@as(c_int, 0))); + } + _ = memset(result, @as(c_int, 0), element_size *% count); + return result; +} +pub fn cgltf_default_file_read(arg_memory_options: [*c]const struct_cgltf_memory_options, arg_file_options: [*c]const struct_cgltf_file_options, arg_path: [*c]const u8, arg_size: [*c]cgltf_size, arg_data: [*c]?*anyopaque) callconv(.C) cgltf_result { + var memory_options = arg_memory_options; + _ = &memory_options; + var file_options = arg_file_options; + _ = &file_options; + var path = arg_path; + _ = &path; + var size = arg_size; + _ = &size; + var data = arg_data; + _ = &data; + _ = &file_options; + var memory_alloc: ?*const fn (?*anyopaque, cgltf_size) callconv(.C) ?*anyopaque = if (memory_options.*.alloc_func != null) memory_options.*.alloc_func else &cgltf_default_alloc; + _ = &memory_alloc; + var memory_free: ?*const fn (?*anyopaque, ?*anyopaque) callconv(.C) void = if (memory_options.*.free_func != null) memory_options.*.free_func else &cgltf_default_free; + _ = &memory_free; + var file: [*c]FILE = fopen(path, "rb"); + _ = &file; + if (!(file != null)) { + return @as(c_uint, @bitCast(cgltf_result_file_not_found)); + } + var file_size: cgltf_size = if (size != null) size.* else @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 0)))); + _ = &file_size; + if (file_size == @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 0))))) { + _ = fseek(file, @as(c_long, @bitCast(@as(c_long, @as(c_int, 0)))), @as(c_int, 2)); + var length: c_long = ftell(file); + _ = &length; + if (length < @as(c_long, @bitCast(@as(c_long, @as(c_int, 0))))) { + _ = fclose(file); + return @as(c_uint, @bitCast(cgltf_result_io_error)); + } + _ = fseek(file, @as(c_long, @bitCast(@as(c_long, @as(c_int, 0)))), @as(c_int, 0)); + file_size = @as(cgltf_size, @bitCast(length)); + } + var file_data: [*c]u8 = @as([*c]u8, @ptrCast(@alignCast(memory_alloc.?(memory_options.*.user_data, file_size)))); + _ = &file_data; + if (!(file_data != null)) { + _ = fclose(file); + return @as(c_uint, @bitCast(cgltf_result_out_of_memory)); + } + var read_size: cgltf_size = fread(@as(?*anyopaque, @ptrCast(file_data)), @as(c_ulong, @bitCast(@as(c_long, @as(c_int, 1)))), file_size, file); + _ = &read_size; + _ = fclose(file); + if (read_size != file_size) { + memory_free.?(memory_options.*.user_data, @as(?*anyopaque, @ptrCast(file_data))); + return @as(c_uint, @bitCast(cgltf_result_io_error)); + } + if (size != null) { + size.* = file_size; + } + if (data != null) { + data.* = @as(?*anyopaque, @ptrCast(file_data)); + } + return @as(c_uint, @bitCast(cgltf_result_success)); +} +pub fn cgltf_default_file_release(arg_memory_options: [*c]const struct_cgltf_memory_options, arg_file_options: [*c]const struct_cgltf_file_options, arg_data: ?*anyopaque) callconv(.C) void { + var memory_options = arg_memory_options; + _ = &memory_options; + var file_options = arg_file_options; + _ = &file_options; + var data = arg_data; + _ = &data; + _ = &file_options; + var memfree: ?*const fn (?*anyopaque, ?*anyopaque) callconv(.C) void = if (memory_options.*.free_func != null) memory_options.*.free_func else &cgltf_default_free; + _ = &memfree; + memfree.?(memory_options.*.user_data, data); +} +pub export fn cgltf_parse_json(arg_options: [*c]cgltf_options, arg_json_chunk: [*c]const u8, arg_size: cgltf_size, arg_out_data: [*c][*c]cgltf_data) cgltf_result { + var options = arg_options; + _ = &options; + var json_chunk = arg_json_chunk; + _ = &json_chunk; + var size = arg_size; + _ = &size; + var out_data = arg_out_data; + _ = &out_data; + var parser: jsmn_parser = jsmn_parser{ + .pos = @as(usize, @bitCast(@as(c_long, @as(c_int, 0)))), + .toknext = @as(c_uint, @bitCast(@as(c_int, 0))), + .toksuper = @as(c_int, 0), + }; + _ = &parser; + if (options.*.json_token_count == @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 0))))) { + var token_count: c_int = jsmn_parse(&parser, @as([*c]const u8, @ptrCast(@alignCast(json_chunk))), size, null, @as(usize, @bitCast(@as(c_long, @as(c_int, 0))))); + _ = &token_count; + if (token_count <= @as(c_int, 0)) { + return @as(c_uint, @bitCast(cgltf_result_invalid_json)); + } + options.*.json_token_count = @as(cgltf_size, @bitCast(@as(c_long, token_count))); + } + var tokens: [*c]jsmntok_t = @as([*c]jsmntok_t, @ptrCast(@alignCast(options.*.memory.alloc_func.?(options.*.memory.user_data, @sizeOf(jsmntok_t) *% (options.*.json_token_count +% @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 1))))))))); + _ = &tokens; + if (!(tokens != null)) { + return @as(c_uint, @bitCast(cgltf_result_out_of_memory)); + } + jsmn_init(&parser); + var token_count: c_int = jsmn_parse(&parser, @as([*c]const u8, @ptrCast(@alignCast(json_chunk))), size, tokens, options.*.json_token_count); + _ = &token_count; + if (token_count <= @as(c_int, 0)) { + options.*.memory.free_func.?(options.*.memory.user_data, @as(?*anyopaque, @ptrCast(tokens))); + return @as(c_uint, @bitCast(cgltf_result_invalid_json)); + } + (blk: { + const tmp = token_count; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.type = @as(c_uint, @bitCast(JSMN_UNDEFINED)); + var data: [*c]cgltf_data = @as([*c]cgltf_data, @ptrCast(@alignCast(options.*.memory.alloc_func.?(options.*.memory.user_data, @sizeOf(cgltf_data))))); + _ = &data; + if (!(data != null)) { + options.*.memory.free_func.?(options.*.memory.user_data, @as(?*anyopaque, @ptrCast(tokens))); + return @as(c_uint, @bitCast(cgltf_result_out_of_memory)); + } + _ = memset(@as(?*anyopaque, @ptrCast(data)), @as(c_int, 0), @sizeOf(cgltf_data)); + data.*.memory = options.*.memory; + data.*.file = options.*.file; + var i: c_int = cgltf_parse_json_root(options, tokens, @as(c_int, 0), json_chunk, data); + _ = &i; + options.*.memory.free_func.?(options.*.memory.user_data, @as(?*anyopaque, @ptrCast(tokens))); + if (i < @as(c_int, 0)) { + cgltf_free(data); + while (true) { + switch (i) { + @as(c_int, -2) => return @as(c_uint, @bitCast(cgltf_result_out_of_memory)), + @as(c_int, -3) => return @as(c_uint, @bitCast(cgltf_result_legacy_gltf)), + else => return @as(c_uint, @bitCast(cgltf_result_invalid_gltf)), + } + break; + } + } + if (cgltf_fixup_pointers(data) < @as(c_int, 0)) { + cgltf_free(data); + return @as(c_uint, @bitCast(cgltf_result_invalid_gltf)); + } + data.*.json = @as([*c]const u8, @ptrCast(@alignCast(json_chunk))); + data.*.json_size = size; + out_data.* = data; + return @as(c_uint, @bitCast(cgltf_result_success)); +} +pub fn cgltf_combine_paths(arg_path: [*c]u8, arg_base: [*c]const u8, arg_uri: [*c]const u8) callconv(.C) void { + var path = arg_path; + _ = &path; + var base = arg_base; + _ = &base; + var uri = arg_uri; + _ = &uri; + var s0: [*c]const u8 = strrchr(base, @as(c_int, '/')); + _ = &s0; + var s1: [*c]const u8 = strrchr(base, @as(c_int, '\\')); + _ = &s1; + var slash: [*c]const u8 = if (s0 != null) if ((s1 != null) and (s1 > s0)) s1 else s0 else s1; + _ = &slash; + if (slash != null) { + var prefix: usize = @as(usize, @bitCast(@divExact(@as(c_long, @bitCast(@intFromPtr(slash) -% @intFromPtr(base))), @sizeOf(u8)) + @as(c_long, @bitCast(@as(c_long, @as(c_int, 1)))))); + _ = &prefix; + _ = strncpy(path, base, prefix); + _ = strcpy(path + prefix, uri); + } else { + _ = strcpy(path, uri); + } +} +pub fn cgltf_load_buffer_file(arg_options: [*c]const cgltf_options, arg_size: cgltf_size, arg_uri: [*c]const u8, arg_gltf_path: [*c]const u8, arg_out_data: [*c]?*anyopaque) callconv(.C) cgltf_result { + var options = arg_options; + _ = &options; + var size = arg_size; + _ = &size; + var uri = arg_uri; + _ = &uri; + var gltf_path = arg_gltf_path; + _ = &gltf_path; + var out_data = arg_out_data; + _ = &out_data; + var memory_alloc: ?*const fn (?*anyopaque, cgltf_size) callconv(.C) ?*anyopaque = if (options.*.memory.alloc_func != null) options.*.memory.alloc_func else &cgltf_default_alloc; + _ = &memory_alloc; + var memory_free: ?*const fn (?*anyopaque, ?*anyopaque) callconv(.C) void = if (options.*.memory.free_func != null) options.*.memory.free_func else &cgltf_default_free; + _ = &memory_free; + var file_read: ?*const fn ([*c]const struct_cgltf_memory_options, [*c]const struct_cgltf_file_options, [*c]const u8, [*c]cgltf_size, [*c]?*anyopaque) callconv(.C) cgltf_result = if (options.*.file.read != null) options.*.file.read else &cgltf_default_file_read; + _ = &file_read; + var path: [*c]u8 = @as([*c]u8, @ptrCast(@alignCast(memory_alloc.?(options.*.memory.user_data, (strlen(uri) +% strlen(gltf_path)) +% @as(c_ulong, @bitCast(@as(c_long, @as(c_int, 1)))))))); + _ = &path; + if (!(path != null)) { + return @as(c_uint, @bitCast(cgltf_result_out_of_memory)); + } + cgltf_combine_paths(path, gltf_path, uri); + _ = cgltf_decode_uri((path + strlen(path)) - strlen(uri)); + var file_data: ?*anyopaque = @as(?*anyopaque, @ptrFromInt(@as(c_int, 0))); + _ = &file_data; + var result: cgltf_result = file_read.?(&options.*.memory, &options.*.file, path, &size, &file_data); + _ = &result; + memory_free.?(options.*.memory.user_data, @as(?*anyopaque, @ptrCast(path))); + out_data.* = if (result == @as(c_uint, @bitCast(cgltf_result_success))) file_data else @as(?*anyopaque, @ptrFromInt(@as(c_int, 0))); + return result; +} +pub fn cgltf_unhex(arg_ch: u8) callconv(.C) c_int { + var ch = arg_ch; + _ = &ch; + return if (@as(c_uint, @bitCast(@as(c_int, @bitCast(@as(c_uint, ch))) - @as(c_int, '0'))) < @as(c_uint, @bitCast(@as(c_int, 10)))) @as(c_int, @bitCast(@as(c_uint, ch))) - @as(c_int, '0') else if (@as(c_uint, @bitCast(@as(c_int, @bitCast(@as(c_uint, ch))) - @as(c_int, 'A'))) < @as(c_uint, @bitCast(@as(c_int, 6)))) (@as(c_int, @bitCast(@as(c_uint, ch))) - @as(c_int, 'A')) + @as(c_int, 10) else if (@as(c_uint, @bitCast(@as(c_int, @bitCast(@as(c_uint, ch))) - @as(c_int, 'a'))) < @as(c_uint, @bitCast(@as(c_int, 6)))) (@as(c_int, @bitCast(@as(c_uint, ch))) - @as(c_int, 'a')) + @as(c_int, 10) else -@as(c_int, 1); +} +pub fn cgltf_calc_index_bound(arg_buffer_view: [*c]cgltf_buffer_view, arg_offset: cgltf_size, arg_component_type: cgltf_component_type, arg_count: cgltf_size) callconv(.C) cgltf_size { + var buffer_view = arg_buffer_view; + _ = &buffer_view; + var offset = arg_offset; + _ = &offset; + var component_type = arg_component_type; + _ = &component_type; + var count = arg_count; + _ = &count; + var data: [*c]u8 = (@as([*c]u8, @ptrCast(@alignCast(buffer_view.*.buffer.*.data))) + offset) + buffer_view.*.offset; + _ = &data; + var bound: cgltf_size = 0; + _ = &bound; + while (true) { + switch (component_type) { + @as(c_uint, @bitCast(@as(c_int, 2))) => { + { + var i: usize = 0; + _ = &i; + while (i < count) : (i +%= 1) { + var v: cgltf_size = @as(cgltf_size, @bitCast(@as(c_ulong, @as([*c]u8, @ptrCast(@alignCast(data)))[i]))); + _ = &v; + bound = if (bound > v) bound else v; + } + } + break; + }, + @as(c_uint, @bitCast(@as(c_int, 4))) => { + { + var i: usize = 0; + _ = &i; + while (i < count) : (i +%= 1) { + var v: cgltf_size = @as(cgltf_size, @bitCast(@as(c_ulong, @as([*c]c_ushort, @ptrCast(@alignCast(data)))[i]))); + _ = &v; + bound = if (bound > v) bound else v; + } + } + break; + }, + @as(c_uint, @bitCast(@as(c_int, 5))) => { + { + var i: usize = 0; + _ = &i; + while (i < count) : (i +%= 1) { + var v: cgltf_size = @as(cgltf_size, @bitCast(@as(c_ulong, @as([*c]c_uint, @ptrCast(@alignCast(data)))[i]))); + _ = &v; + bound = if (bound > v) bound else v; + } + } + break; + }, + else => { + {} + }, + } + break; + } + return bound; +} +pub fn cgltf_free_extras(arg_data: [*c]cgltf_data, arg_extras: [*c]cgltf_extras) callconv(.C) void { + var data = arg_data; + _ = &data; + var extras = arg_extras; + _ = &extras; + data.*.memory.free_func.?(data.*.memory.user_data, @as(?*anyopaque, @ptrCast(extras.*.data))); +} +pub fn cgltf_free_extensions(arg_data: [*c]cgltf_data, arg_extensions: [*c]cgltf_extension, arg_extensions_count: cgltf_size) callconv(.C) void { + var data = arg_data; + _ = &data; + var extensions = arg_extensions; + _ = &extensions; + var extensions_count = arg_extensions_count; + _ = &extensions_count; + { + var i: cgltf_size = 0; + _ = &i; + while (i < extensions_count) : (i +%= 1) { + data.*.memory.free_func.?(data.*.memory.user_data, @as(?*anyopaque, @ptrCast(extensions[i].name))); + data.*.memory.free_func.?(data.*.memory.user_data, @as(?*anyopaque, @ptrCast(extensions[i].data))); + } + } + data.*.memory.free_func.?(data.*.memory.user_data, @as(?*anyopaque, @ptrCast(extensions))); +} +pub fn cgltf_component_read_integer(arg_in: ?*const anyopaque, arg_component_type: cgltf_component_type) callconv(.C) cgltf_ssize { + var in = arg_in; + _ = ∈ + var component_type = arg_component_type; + _ = &component_type; + while (true) { + switch (component_type) { + @as(c_uint, @bitCast(@as(c_int, 3))) => return @as(cgltf_ssize, @bitCast(@as(c_longlong, @as([*c]const i16, @ptrCast(@alignCast(in))).*))), + @as(c_uint, @bitCast(@as(c_int, 4))) => return @as(cgltf_ssize, @bitCast(@as(c_ulonglong, @as([*c]const u16, @ptrCast(@alignCast(in))).*))), + @as(c_uint, @bitCast(@as(c_int, 5))) => return @as(cgltf_ssize, @bitCast(@as(c_ulonglong, @as([*c]const u32, @ptrCast(@alignCast(in))).*))), + @as(c_uint, @bitCast(@as(c_int, 1))) => return @as(cgltf_ssize, @bitCast(@as(c_longlong, @as([*c]const i8, @ptrCast(@alignCast(in))).*))), + @as(c_uint, @bitCast(@as(c_int, 2))) => return @as(cgltf_ssize, @bitCast(@as(c_ulonglong, @as([*c]const u8, @ptrCast(@alignCast(in))).*))), + else => return 0, + } + break; + } + return @import("std").mem.zeroes(cgltf_ssize); +} +pub fn cgltf_component_read_index(arg_in: ?*const anyopaque, arg_component_type: cgltf_component_type) callconv(.C) cgltf_size { + var in = arg_in; + _ = ∈ + var component_type = arg_component_type; + _ = &component_type; + while (true) { + switch (component_type) { + @as(c_uint, @bitCast(@as(c_int, 4))) => return @as(cgltf_size, @bitCast(@as(c_ulong, @as([*c]const u16, @ptrCast(@alignCast(in))).*))), + @as(c_uint, @bitCast(@as(c_int, 5))) => return @as(cgltf_size, @bitCast(@as(c_ulong, @as([*c]const u32, @ptrCast(@alignCast(in))).*))), + @as(c_uint, @bitCast(@as(c_int, 2))) => return @as(cgltf_size, @bitCast(@as(c_ulong, @as([*c]const u8, @ptrCast(@alignCast(in))).*))), + else => return 0, + } + break; + } + return @import("std").mem.zeroes(cgltf_size); +} +pub fn cgltf_component_read_float(arg_in: ?*const anyopaque, arg_component_type: cgltf_component_type, arg_normalized: cgltf_bool) callconv(.C) cgltf_float { + var in = arg_in; + _ = ∈ + var component_type = arg_component_type; + _ = &component_type; + var normalized = arg_normalized; + _ = &normalized; + if (component_type == @as(c_uint, @bitCast(cgltf_component_type_r_32f))) { + return @as([*c]const f32, @ptrCast(@alignCast(in))).*; + } + if (normalized != 0) { + while (true) { + switch (component_type) { + @as(c_uint, @bitCast(@as(c_int, 3))) => return @as(cgltf_float, @floatFromInt(@as(c_int, @bitCast(@as(c_int, @as([*c]const i16, @ptrCast(@alignCast(in))).*))))) / @as(cgltf_float, @floatFromInt(@as(c_int, 32767))), + @as(c_uint, @bitCast(@as(c_int, 4))) => return @as(cgltf_float, @floatFromInt(@as(c_int, @bitCast(@as(c_uint, @as([*c]const u16, @ptrCast(@alignCast(in))).*))))) / @as(cgltf_float, @floatFromInt(@as(c_int, 65535))), + @as(c_uint, @bitCast(@as(c_int, 1))) => return @as(cgltf_float, @floatFromInt(@as(c_int, @bitCast(@as(c_int, @as([*c]const i8, @ptrCast(@alignCast(in))).*))))) / @as(cgltf_float, @floatFromInt(@as(c_int, 127))), + @as(c_uint, @bitCast(@as(c_int, 2))) => return @as(cgltf_float, @floatFromInt(@as(c_int, @bitCast(@as(c_uint, @as([*c]const u8, @ptrCast(@alignCast(in))).*))))) / @as(cgltf_float, @floatFromInt(@as(c_int, 255))), + else => return 0, + } + break; + } + } + return @as(cgltf_float, @floatFromInt(cgltf_component_read_integer(in, component_type))); +} +pub fn cgltf_element_read_float(arg_element: [*c]const u8, arg_type: cgltf_type, arg_component_type: cgltf_component_type, arg_normalized: cgltf_bool, arg_out: [*c]cgltf_float, arg_element_size: cgltf_size) callconv(.C) cgltf_bool { + var element = arg_element; + _ = &element; + var @"type" = arg_type; + _ = &@"type"; + var component_type = arg_component_type; + _ = &component_type; + var normalized = arg_normalized; + _ = &normalized; + var out = arg_out; + _ = &out; + var element_size = arg_element_size; + _ = &element_size; + var num_components: cgltf_size = cgltf_num_components(@"type"); + _ = &num_components; + if (element_size < num_components) { + return 0; + } + var component_size: cgltf_size = cgltf_component_size(component_type); + _ = &component_size; + if ((@"type" == @as(c_uint, @bitCast(cgltf_type_mat2))) and (component_size == @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 1)))))) { + out[@as(c_uint, @intCast(@as(c_int, 0)))] = cgltf_component_read_float(@as(?*const anyopaque, @ptrCast(element)), component_type, normalized); + out[@as(c_uint, @intCast(@as(c_int, 1)))] = cgltf_component_read_float(@as(?*const anyopaque, @ptrCast(element + @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 1))))))), component_type, normalized); + out[@as(c_uint, @intCast(@as(c_int, 2)))] = cgltf_component_read_float(@as(?*const anyopaque, @ptrCast(element + @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 4))))))), component_type, normalized); + out[@as(c_uint, @intCast(@as(c_int, 3)))] = cgltf_component_read_float(@as(?*const anyopaque, @ptrCast(element + @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 5))))))), component_type, normalized); + return 1; + } + if ((@"type" == @as(c_uint, @bitCast(cgltf_type_mat3))) and (component_size == @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 1)))))) { + out[@as(c_uint, @intCast(@as(c_int, 0)))] = cgltf_component_read_float(@as(?*const anyopaque, @ptrCast(element)), component_type, normalized); + out[@as(c_uint, @intCast(@as(c_int, 1)))] = cgltf_component_read_float(@as(?*const anyopaque, @ptrCast(element + @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 1))))))), component_type, normalized); + out[@as(c_uint, @intCast(@as(c_int, 2)))] = cgltf_component_read_float(@as(?*const anyopaque, @ptrCast(element + @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 2))))))), component_type, normalized); + out[@as(c_uint, @intCast(@as(c_int, 3)))] = cgltf_component_read_float(@as(?*const anyopaque, @ptrCast(element + @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 4))))))), component_type, normalized); + out[@as(c_uint, @intCast(@as(c_int, 4)))] = cgltf_component_read_float(@as(?*const anyopaque, @ptrCast(element + @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 5))))))), component_type, normalized); + out[@as(c_uint, @intCast(@as(c_int, 5)))] = cgltf_component_read_float(@as(?*const anyopaque, @ptrCast(element + @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 6))))))), component_type, normalized); + out[@as(c_uint, @intCast(@as(c_int, 6)))] = cgltf_component_read_float(@as(?*const anyopaque, @ptrCast(element + @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 8))))))), component_type, normalized); + out[@as(c_uint, @intCast(@as(c_int, 7)))] = cgltf_component_read_float(@as(?*const anyopaque, @ptrCast(element + @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 9))))))), component_type, normalized); + out[@as(c_uint, @intCast(@as(c_int, 8)))] = cgltf_component_read_float(@as(?*const anyopaque, @ptrCast(element + @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 10))))))), component_type, normalized); + return 1; + } + if ((@"type" == @as(c_uint, @bitCast(cgltf_type_mat3))) and (component_size == @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 2)))))) { + out[@as(c_uint, @intCast(@as(c_int, 0)))] = cgltf_component_read_float(@as(?*const anyopaque, @ptrCast(element)), component_type, normalized); + out[@as(c_uint, @intCast(@as(c_int, 1)))] = cgltf_component_read_float(@as(?*const anyopaque, @ptrCast(element + @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 2))))))), component_type, normalized); + out[@as(c_uint, @intCast(@as(c_int, 2)))] = cgltf_component_read_float(@as(?*const anyopaque, @ptrCast(element + @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 4))))))), component_type, normalized); + out[@as(c_uint, @intCast(@as(c_int, 3)))] = cgltf_component_read_float(@as(?*const anyopaque, @ptrCast(element + @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 8))))))), component_type, normalized); + out[@as(c_uint, @intCast(@as(c_int, 4)))] = cgltf_component_read_float(@as(?*const anyopaque, @ptrCast(element + @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 10))))))), component_type, normalized); + out[@as(c_uint, @intCast(@as(c_int, 5)))] = cgltf_component_read_float(@as(?*const anyopaque, @ptrCast(element + @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 12))))))), component_type, normalized); + out[@as(c_uint, @intCast(@as(c_int, 6)))] = cgltf_component_read_float(@as(?*const anyopaque, @ptrCast(element + @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 16))))))), component_type, normalized); + out[@as(c_uint, @intCast(@as(c_int, 7)))] = cgltf_component_read_float(@as(?*const anyopaque, @ptrCast(element + @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 18))))))), component_type, normalized); + out[@as(c_uint, @intCast(@as(c_int, 8)))] = cgltf_component_read_float(@as(?*const anyopaque, @ptrCast(element + @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 20))))))), component_type, normalized); + return 1; + } + { + var i: cgltf_size = 0; + _ = &i; + while (i < num_components) : (i +%= 1) { + out[i] = cgltf_component_read_float(@as(?*const anyopaque, @ptrCast(element + (component_size *% i))), component_type, normalized); + } + } + return 1; +} +pub fn cgltf_component_read_uint(arg_in: ?*const anyopaque, arg_component_type: cgltf_component_type) callconv(.C) cgltf_uint { + var in = arg_in; + _ = ∈ + var component_type = arg_component_type; + _ = &component_type; + while (true) { + switch (component_type) { + @as(c_uint, @bitCast(@as(c_int, 1))) => return @as(cgltf_uint, @bitCast(@as(c_int, @as([*c]const i8, @ptrCast(@alignCast(in))).*))), + @as(c_uint, @bitCast(@as(c_int, 2))) => return @as(cgltf_uint, @bitCast(@as(c_uint, @as([*c]const u8, @ptrCast(@alignCast(in))).*))), + @as(c_uint, @bitCast(@as(c_int, 3))) => return @as(cgltf_uint, @bitCast(@as(c_int, @as([*c]const i16, @ptrCast(@alignCast(in))).*))), + @as(c_uint, @bitCast(@as(c_int, 4))) => return @as(cgltf_uint, @bitCast(@as(c_uint, @as([*c]const u16, @ptrCast(@alignCast(in))).*))), + @as(c_uint, @bitCast(@as(c_int, 5))) => return @as([*c]const u32, @ptrCast(@alignCast(in))).*, + else => return 0, + } + break; + } + return @import("std").mem.zeroes(cgltf_uint); +} +pub fn cgltf_element_read_uint(arg_element: [*c]const u8, arg_type: cgltf_type, arg_component_type: cgltf_component_type, arg_out: [*c]cgltf_uint, arg_element_size: cgltf_size) callconv(.C) cgltf_bool { + var element = arg_element; + _ = &element; + var @"type" = arg_type; + _ = &@"type"; + var component_type = arg_component_type; + _ = &component_type; + var out = arg_out; + _ = &out; + var element_size = arg_element_size; + _ = &element_size; + var num_components: cgltf_size = cgltf_num_components(@"type"); + _ = &num_components; + if (element_size < num_components) { + return 0; + } + if (((@"type" == @as(c_uint, @bitCast(cgltf_type_mat2))) or (@"type" == @as(c_uint, @bitCast(cgltf_type_mat3)))) or (@"type" == @as(c_uint, @bitCast(cgltf_type_mat4)))) { + return 0; + } + var component_size: cgltf_size = cgltf_component_size(component_type); + _ = &component_size; + { + var i: cgltf_size = 0; + _ = &i; + while (i < num_components) : (i +%= 1) { + out[i] = cgltf_component_read_uint(@as(?*const anyopaque, @ptrCast(element + (component_size *% i))), component_type); + } + } + return 1; +} +pub fn cgltf_json_strcmp(arg_tok: [*c]const jsmntok_t, arg_json_chunk: [*c]const u8, arg_str: [*c]const u8) callconv(.C) c_int { + var tok = arg_tok; + _ = &tok; + var json_chunk = arg_json_chunk; + _ = &json_chunk; + var str = arg_str; + _ = &str; + if (tok.*.type != @as(c_uint, @bitCast(JSMN_STRING))) { + return -@as(c_int, 1); + } + const str_len: usize = strlen(str); + _ = &str_len; + const name_length: usize = @as(usize, @bitCast(tok.*.end - tok.*.start)); + _ = &name_length; + return if (str_len == name_length) strncmp(@as([*c]const u8, @ptrCast(@alignCast(json_chunk))) + @as(usize, @bitCast(@as(isize, @intCast(tok.*.start)))), str, str_len) else @as(c_int, 128); +} +pub fn cgltf_json_to_int(arg_tok: [*c]const jsmntok_t, arg_json_chunk: [*c]const u8) callconv(.C) c_int { + var tok = arg_tok; + _ = &tok; + var json_chunk = arg_json_chunk; + _ = &json_chunk; + if (tok.*.type != @as(c_uint, @bitCast(JSMN_PRIMITIVE))) { + return -@as(c_int, 1); + } + var tmp: [128]u8 = undefined; + _ = &tmp; + var size: c_int = if (@as(usize, @bitCast(tok.*.end - tok.*.start)) < @sizeOf([128]u8)) @as(c_int, @bitCast(@as(c_int, @truncate(tok.*.end - tok.*.start)))) else @as(c_int, @bitCast(@as(c_uint, @truncate(@sizeOf([128]u8) -% @as(c_ulong, @bitCast(@as(c_long, @as(c_int, 1)))))))); + _ = &size; + _ = strncpy(@as([*c]u8, @ptrCast(@alignCast(&tmp))), @as([*c]const u8, @ptrCast(@alignCast(json_chunk))) + @as(usize, @bitCast(@as(isize, @intCast(tok.*.start)))), @as(c_ulong, @bitCast(@as(c_long, size)))); + tmp[@as(c_uint, @intCast(size))] = 0; + return atoi(@as([*c]u8, @ptrCast(@alignCast(&tmp)))); +} +pub fn cgltf_json_to_size(arg_tok: [*c]const jsmntok_t, arg_json_chunk: [*c]const u8) callconv(.C) cgltf_size { + var tok = arg_tok; + _ = &tok; + var json_chunk = arg_json_chunk; + _ = &json_chunk; + if (tok.*.type != @as(c_uint, @bitCast(JSMN_PRIMITIVE))) { + return 0; + } + var tmp: [128]u8 = undefined; + _ = &tmp; + var size: c_int = if (@as(usize, @bitCast(tok.*.end - tok.*.start)) < @sizeOf([128]u8)) @as(c_int, @bitCast(@as(c_int, @truncate(tok.*.end - tok.*.start)))) else @as(c_int, @bitCast(@as(c_uint, @truncate(@sizeOf([128]u8) -% @as(c_ulong, @bitCast(@as(c_long, @as(c_int, 1)))))))); + _ = &size; + _ = strncpy(@as([*c]u8, @ptrCast(@alignCast(&tmp))), @as([*c]const u8, @ptrCast(@alignCast(json_chunk))) + @as(usize, @bitCast(@as(isize, @intCast(tok.*.start)))), @as(c_ulong, @bitCast(@as(c_long, size)))); + tmp[@as(c_uint, @intCast(size))] = 0; + var res: c_longlong = atoll(@as([*c]u8, @ptrCast(@alignCast(&tmp)))); + _ = &res; + return if (res < @as(c_longlong, @bitCast(@as(c_longlong, @as(c_int, 0))))) @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 0)))) else @as(cgltf_size, @bitCast(@as(c_long, @truncate(res)))); +} +pub fn cgltf_json_to_float(arg_tok: [*c]const jsmntok_t, arg_json_chunk: [*c]const u8) callconv(.C) cgltf_float { + var tok = arg_tok; + _ = &tok; + var json_chunk = arg_json_chunk; + _ = &json_chunk; + if (tok.*.type != @as(c_uint, @bitCast(JSMN_PRIMITIVE))) { + return @as(cgltf_float, @floatFromInt(-@as(c_int, 1))); + } + var tmp: [128]u8 = undefined; + _ = &tmp; + var size: c_int = if (@as(usize, @bitCast(tok.*.end - tok.*.start)) < @sizeOf([128]u8)) @as(c_int, @bitCast(@as(c_int, @truncate(tok.*.end - tok.*.start)))) else @as(c_int, @bitCast(@as(c_uint, @truncate(@sizeOf([128]u8) -% @as(c_ulong, @bitCast(@as(c_long, @as(c_int, 1)))))))); + _ = &size; + _ = strncpy(@as([*c]u8, @ptrCast(@alignCast(&tmp))), @as([*c]const u8, @ptrCast(@alignCast(json_chunk))) + @as(usize, @bitCast(@as(isize, @intCast(tok.*.start)))), @as(c_ulong, @bitCast(@as(c_long, size)))); + tmp[@as(c_uint, @intCast(size))] = 0; + return @as(cgltf_float, @floatCast(atof(@as([*c]u8, @ptrCast(@alignCast(&tmp)))))); +} +pub fn cgltf_json_to_bool(arg_tok: [*c]const jsmntok_t, arg_json_chunk: [*c]const u8) callconv(.C) cgltf_bool { + var tok = arg_tok; + _ = &tok; + var json_chunk = arg_json_chunk; + _ = &json_chunk; + var size: c_int = @as(c_int, @bitCast(@as(c_int, @truncate(tok.*.end - tok.*.start)))); + _ = &size; + return @intFromBool((size == @as(c_int, 4)) and (memcmp(@as(?*const anyopaque, @ptrCast(json_chunk + @as(usize, @bitCast(@as(isize, @intCast(tok.*.start)))))), @as(?*const anyopaque, @ptrCast("true")), @as(c_ulong, @bitCast(@as(c_long, @as(c_int, 4))))) == @as(c_int, 0))); +} +pub fn cgltf_skip_json(arg_tokens: [*c]const jsmntok_t, arg_i: c_int) callconv(.C) c_int { + var tokens = arg_tokens; + _ = &tokens; + var i = arg_i; + _ = &i; + var end: c_int = i + @as(c_int, 1); + _ = &end; + while (i < end) { + while (true) { + switch ((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.type) { + @as(c_uint, @bitCast(@as(c_int, 1))) => { + end += (blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.size * @as(c_int, 2); + break; + }, + @as(c_uint, @bitCast(@as(c_int, 2))) => { + end += (blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.size; + break; + }, + @as(c_uint, @bitCast(@as(c_int, 4))), @as(c_uint, @bitCast(@as(c_int, 3))) => break, + else => return -@as(c_int, 1), + } + break; + } + i += 1; + } + return i; +} +pub fn cgltf_fill_float_array(arg_out_array: [*c]f32, arg_size: c_int, arg_value: f32) callconv(.C) void { + var out_array = arg_out_array; + _ = &out_array; + var size = arg_size; + _ = &size; + var value = arg_value; + _ = &value; + { + var j: c_int = 0; + _ = &j; + while (j < size) : (j += 1) { + (blk: { + const tmp = j; + if (tmp >= 0) break :blk out_array + @as(usize, @intCast(tmp)) else break :blk out_array - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = value; + } + } +} +pub fn cgltf_parse_json_float_array(arg_tokens: [*c]const jsmntok_t, arg_i: c_int, arg_json_chunk: [*c]const u8, arg_out_array: [*c]f32, arg_size: c_int) callconv(.C) c_int { + var tokens = arg_tokens; + _ = &tokens; + var i = arg_i; + _ = &i; + var json_chunk = arg_json_chunk; + _ = &json_chunk; + var out_array = arg_out_array; + _ = &out_array; + var size = arg_size; + _ = &size; + if ((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.type != @as(c_uint, @bitCast(JSMN_ARRAY))) { + return -@as(c_int, 1); + } + if ((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.size != size) { + return -@as(c_int, 1); + } + i += 1; + { + var j: c_int = 0; + _ = &j; + while (j < size) : (j += 1) { + if ((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.type != @as(c_uint, @bitCast(JSMN_PRIMITIVE))) { + return -@as(c_int, 1); + } + (blk: { + const tmp = j; + if (tmp >= 0) break :blk out_array + @as(usize, @intCast(tmp)) else break :blk out_array - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = cgltf_json_to_float(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk); + i += 1; + } + } + return i; +} +pub fn cgltf_parse_json_string(arg_options: [*c]cgltf_options, arg_tokens: [*c]const jsmntok_t, arg_i: c_int, arg_json_chunk: [*c]const u8, arg_out_string: [*c][*c]u8) callconv(.C) c_int { + var options = arg_options; + _ = &options; + var tokens = arg_tokens; + _ = &tokens; + var i = arg_i; + _ = &i; + var json_chunk = arg_json_chunk; + _ = &json_chunk; + var out_string = arg_out_string; + _ = &out_string; + if ((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.type != @as(c_uint, @bitCast(JSMN_STRING))) { + return -@as(c_int, 1); + } + if (out_string.* != null) { + return -@as(c_int, 1); + } + var size: c_int = @as(c_int, @bitCast(@as(c_int, @truncate((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.end - (blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.start)))); + _ = &size; + var result: [*c]u8 = @as([*c]u8, @ptrCast(@alignCast(options.*.memory.alloc_func.?(options.*.memory.user_data, @as(cgltf_size, @bitCast(@as(c_long, size + @as(c_int, 1)))))))); + _ = &result; + if (!(result != null)) { + return -@as(c_int, 2); + } + _ = strncpy(result, @as([*c]const u8, @ptrCast(@alignCast(json_chunk))) + @as(usize, @bitCast(@as(isize, @intCast((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.start)))), @as(c_ulong, @bitCast(@as(c_long, size)))); + (blk: { + const tmp = size; + if (tmp >= 0) break :blk result + @as(usize, @intCast(tmp)) else break :blk result - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = 0; + out_string.* = result; + return i + @as(c_int, 1); +} +pub fn cgltf_parse_json_array(arg_options: [*c]cgltf_options, arg_tokens: [*c]const jsmntok_t, arg_i: c_int, arg_json_chunk: [*c]const u8, arg_element_size: usize, arg_out_array: [*c]?*anyopaque, arg_out_size: [*c]cgltf_size) callconv(.C) c_int { + var options = arg_options; + _ = &options; + var tokens = arg_tokens; + _ = &tokens; + var i = arg_i; + _ = &i; + var json_chunk = arg_json_chunk; + _ = &json_chunk; + var element_size = arg_element_size; + _ = &element_size; + var out_array = arg_out_array; + _ = &out_array; + var out_size = arg_out_size; + _ = &out_size; + _ = &json_chunk; + if ((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.type != @as(c_uint, @bitCast(JSMN_ARRAY))) { + return if ((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.type == @as(c_uint, @bitCast(JSMN_OBJECT))) -@as(c_int, 3) else -@as(c_int, 1); + } + if (out_array.* != null) { + return -@as(c_int, 1); + } + var size: c_int = (blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.size; + _ = &size; + var result: ?*anyopaque = cgltf_calloc(options, element_size, @as(cgltf_size, @bitCast(@as(c_long, size)))); + _ = &result; + if (!(result != null)) { + return -@as(c_int, 2); + } + out_array.* = result; + out_size.* = @as(cgltf_size, @bitCast(@as(c_long, size))); + return i + @as(c_int, 1); +} +pub fn cgltf_parse_json_string_array(arg_options: [*c]cgltf_options, arg_tokens: [*c]const jsmntok_t, arg_i: c_int, arg_json_chunk: [*c]const u8, arg_out_array: [*c][*c][*c]u8, arg_out_size: [*c]cgltf_size) callconv(.C) c_int { + var options = arg_options; + _ = &options; + var tokens = arg_tokens; + _ = &tokens; + var i = arg_i; + _ = &i; + var json_chunk = arg_json_chunk; + _ = &json_chunk; + var out_array = arg_out_array; + _ = &out_array; + var out_size = arg_out_size; + _ = &out_size; + if ((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.type != @as(c_uint, @bitCast(JSMN_ARRAY))) { + return -@as(c_int, 1); + } + i = cgltf_parse_json_array(options, tokens, i, json_chunk, @sizeOf([*c]u8), @as([*c]?*anyopaque, @ptrCast(@alignCast(out_array))), out_size); + if (i < @as(c_int, 0)) { + return i; + } + { + var j: cgltf_size = 0; + _ = &j; + while (j < out_size.*) : (j +%= 1) { + i = cgltf_parse_json_string(options, tokens, i, json_chunk, j + out_array.*); + if (i < @as(c_int, 0)) { + return i; + } + } + } + return i; +} +pub fn cgltf_parse_attribute_type(arg_name: [*c]const u8, arg_out_type: [*c]cgltf_attribute_type, arg_out_index: [*c]c_int) callconv(.C) void { + var name = arg_name; + _ = &name; + var out_type = arg_out_type; + _ = &out_type; + var out_index = arg_out_index; + _ = &out_index; + if (@as(c_int, @bitCast(@as(c_uint, name.*))) == @as(c_int, '_')) { + out_type.* = @as(c_uint, @bitCast(cgltf_attribute_type_custom)); + return; + } + var us: [*c]const u8 = strchr(name, @as(c_int, '_')); + _ = &us; + var len: usize = if (us != null) @as(usize, @bitCast(@divExact(@as(c_long, @bitCast(@intFromPtr(us) -% @intFromPtr(name))), @sizeOf(u8)))) else strlen(name); + _ = &len; + if ((len == @as(usize, @bitCast(@as(c_long, @as(c_int, 8))))) and (strncmp(name, "POSITION", @as(c_ulong, @bitCast(@as(c_long, @as(c_int, 8))))) == @as(c_int, 0))) { + out_type.* = @as(c_uint, @bitCast(cgltf_attribute_type_position)); + } else if ((len == @as(usize, @bitCast(@as(c_long, @as(c_int, 6))))) and (strncmp(name, "NORMAL", @as(c_ulong, @bitCast(@as(c_long, @as(c_int, 6))))) == @as(c_int, 0))) { + out_type.* = @as(c_uint, @bitCast(cgltf_attribute_type_normal)); + } else if ((len == @as(usize, @bitCast(@as(c_long, @as(c_int, 7))))) and (strncmp(name, "TANGENT", @as(c_ulong, @bitCast(@as(c_long, @as(c_int, 7))))) == @as(c_int, 0))) { + out_type.* = @as(c_uint, @bitCast(cgltf_attribute_type_tangent)); + } else if ((len == @as(usize, @bitCast(@as(c_long, @as(c_int, 8))))) and (strncmp(name, "TEXCOORD", @as(c_ulong, @bitCast(@as(c_long, @as(c_int, 8))))) == @as(c_int, 0))) { + out_type.* = @as(c_uint, @bitCast(cgltf_attribute_type_texcoord)); + } else if ((len == @as(usize, @bitCast(@as(c_long, @as(c_int, 5))))) and (strncmp(name, "COLOR", @as(c_ulong, @bitCast(@as(c_long, @as(c_int, 5))))) == @as(c_int, 0))) { + out_type.* = @as(c_uint, @bitCast(cgltf_attribute_type_color)); + } else if ((len == @as(usize, @bitCast(@as(c_long, @as(c_int, 6))))) and (strncmp(name, "JOINTS", @as(c_ulong, @bitCast(@as(c_long, @as(c_int, 6))))) == @as(c_int, 0))) { + out_type.* = @as(c_uint, @bitCast(cgltf_attribute_type_joints)); + } else if ((len == @as(usize, @bitCast(@as(c_long, @as(c_int, 7))))) and (strncmp(name, "WEIGHTS", @as(c_ulong, @bitCast(@as(c_long, @as(c_int, 7))))) == @as(c_int, 0))) { + out_type.* = @as(c_uint, @bitCast(cgltf_attribute_type_weights)); + } else { + out_type.* = @as(c_uint, @bitCast(cgltf_attribute_type_invalid)); + } + if ((us != null) and (out_type.* != @as(c_uint, @bitCast(cgltf_attribute_type_invalid)))) { + out_index.* = atoi(us + @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 1)))))); + if (out_index.* < @as(c_int, 0)) { + out_type.* = @as(c_uint, @bitCast(cgltf_attribute_type_invalid)); + out_index.* = 0; + } + } +} +pub fn cgltf_parse_json_attribute_list(arg_options: [*c]cgltf_options, arg_tokens: [*c]const jsmntok_t, arg_i: c_int, arg_json_chunk: [*c]const u8, arg_out_attributes: [*c][*c]cgltf_attribute, arg_out_attributes_count: [*c]cgltf_size) callconv(.C) c_int { + var options = arg_options; + _ = &options; + var tokens = arg_tokens; + _ = &tokens; + var i = arg_i; + _ = &i; + var json_chunk = arg_json_chunk; + _ = &json_chunk; + var out_attributes = arg_out_attributes; + _ = &out_attributes; + var out_attributes_count = arg_out_attributes_count; + _ = &out_attributes_count; + if ((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.type != @as(c_uint, @bitCast(JSMN_OBJECT))) { + return -@as(c_int, 1); + } + if (out_attributes.* != null) { + return -@as(c_int, 1); + } + out_attributes_count.* = @as(cgltf_size, @bitCast(@as(c_long, (blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.size))); + out_attributes.* = @as([*c]cgltf_attribute, @ptrCast(@alignCast(cgltf_calloc(options, @sizeOf(cgltf_attribute), out_attributes_count.*)))); + i += 1; + if (!(out_attributes.* != null)) { + return -@as(c_int, 2); + } + { + var j: cgltf_size = 0; + _ = &j; + while (j < out_attributes_count.*) : (j +%= 1) { + if (((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.type != @as(c_uint, @bitCast(JSMN_STRING))) or ((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.size == @as(c_int, 0))) { + return -@as(c_int, 1); + } + i = cgltf_parse_json_string(options, tokens, i, json_chunk, &out_attributes.*[j].name); + if (i < @as(c_int, 0)) { + return -@as(c_int, 1); + } + cgltf_parse_attribute_type(out_attributes.*[j].name, &out_attributes.*[j].type, &out_attributes.*[j].index); + out_attributes.*[j].data = @as([*c]cgltf_accessor, @ptrFromInt(@as(cgltf_size, @bitCast(@as(c_long, cgltf_json_to_int(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk)))) +% @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 1)))))); + i += 1; + } + } + return i; +} +pub fn cgltf_parse_json_extras(arg_options: [*c]cgltf_options, arg_tokens: [*c]const jsmntok_t, arg_i: c_int, arg_json_chunk: [*c]const u8, arg_out_extras: [*c]cgltf_extras) callconv(.C) c_int { + var options = arg_options; + _ = &options; + var tokens = arg_tokens; + _ = &tokens; + var i = arg_i; + _ = &i; + var json_chunk = arg_json_chunk; + _ = &json_chunk; + var out_extras = arg_out_extras; + _ = &out_extras; + if (out_extras.*.data != null) { + return -@as(c_int, 1); + } + out_extras.*.start_offset = @as(cgltf_size, @bitCast((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.start)); + out_extras.*.end_offset = @as(cgltf_size, @bitCast((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.end)); + var start: usize = @as(usize, @bitCast((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.start)); + _ = &start; + var size: usize = @as(usize, @bitCast((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.end)) -% start; + _ = &size; + out_extras.*.data = @as([*c]u8, @ptrCast(@alignCast(options.*.memory.alloc_func.?(options.*.memory.user_data, size +% @as(usize, @bitCast(@as(c_long, @as(c_int, 1)))))))); + if (!(out_extras.*.data != null)) { + return -@as(c_int, 2); + } + _ = strncpy(out_extras.*.data, @as([*c]const u8, @ptrCast(@alignCast(json_chunk))) + start, size); + out_extras.*.data[size] = '\x00'; + i = cgltf_skip_json(tokens, i); + return i; +} +pub fn cgltf_parse_json_unprocessed_extension(arg_options: [*c]cgltf_options, arg_tokens: [*c]const jsmntok_t, arg_i: c_int, arg_json_chunk: [*c]const u8, arg_out_extension: [*c]cgltf_extension) callconv(.C) c_int { + var options = arg_options; + _ = &options; + var tokens = arg_tokens; + _ = &tokens; + var i = arg_i; + _ = &i; + var json_chunk = arg_json_chunk; + _ = &json_chunk; + var out_extension = arg_out_extension; + _ = &out_extension; + if ((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.type != @as(c_uint, @bitCast(JSMN_STRING))) { + return -@as(c_int, 1); + } + if ((blk: { + const tmp = i + @as(c_int, 1); + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.type != @as(c_uint, @bitCast(JSMN_OBJECT))) { + return -@as(c_int, 1); + } + if (out_extension.*.name != null) { + return -@as(c_int, 1); + } + var name_length: cgltf_size = @as(cgltf_size, @bitCast((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.end - (blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.start)); + _ = &name_length; + out_extension.*.name = @as([*c]u8, @ptrCast(@alignCast(options.*.memory.alloc_func.?(options.*.memory.user_data, name_length +% @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 1)))))))); + if (!(out_extension.*.name != null)) { + return -@as(c_int, 2); + } + _ = strncpy(out_extension.*.name, @as([*c]const u8, @ptrCast(@alignCast(json_chunk))) + @as(usize, @bitCast(@as(isize, @intCast((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.start)))), name_length); + out_extension.*.name[name_length] = 0; + i += 1; + var start: usize = @as(usize, @bitCast((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.start)); + _ = &start; + var size: usize = @as(usize, @bitCast((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.end)) -% start; + _ = &size; + out_extension.*.data = @as([*c]u8, @ptrCast(@alignCast(options.*.memory.alloc_func.?(options.*.memory.user_data, size +% @as(usize, @bitCast(@as(c_long, @as(c_int, 1)))))))); + if (!(out_extension.*.data != null)) { + return -@as(c_int, 2); + } + _ = strncpy(out_extension.*.data, @as([*c]const u8, @ptrCast(@alignCast(json_chunk))) + start, size); + out_extension.*.data[size] = '\x00'; + i = cgltf_skip_json(tokens, i); + return i; +} +pub fn cgltf_parse_json_unprocessed_extensions(arg_options: [*c]cgltf_options, arg_tokens: [*c]const jsmntok_t, arg_i: c_int, arg_json_chunk: [*c]const u8, arg_out_extensions_count: [*c]cgltf_size, arg_out_extensions: [*c][*c]cgltf_extension) callconv(.C) c_int { + var options = arg_options; + _ = &options; + var tokens = arg_tokens; + _ = &tokens; + var i = arg_i; + _ = &i; + var json_chunk = arg_json_chunk; + _ = &json_chunk; + var out_extensions_count = arg_out_extensions_count; + _ = &out_extensions_count; + var out_extensions = arg_out_extensions; + _ = &out_extensions; + i += 1; + if ((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.type != @as(c_uint, @bitCast(JSMN_OBJECT))) { + return -@as(c_int, 1); + } + if (out_extensions.* != null) { + return -@as(c_int, 1); + } + var extensions_size: c_int = (blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.size; + _ = &extensions_size; + out_extensions_count.* = 0; + out_extensions.* = @as([*c]cgltf_extension, @ptrCast(@alignCast(cgltf_calloc(options, @sizeOf(cgltf_extension), @as(cgltf_size, @bitCast(@as(c_long, extensions_size))))))); + if (!(out_extensions.* != null)) { + return -@as(c_int, 2); + } + i += 1; + { + var j: c_int = 0; + _ = &j; + while (j < extensions_size) : (j += 1) { + if (((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.type != @as(c_uint, @bitCast(JSMN_STRING))) or ((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.size == @as(c_int, 0))) { + return -@as(c_int, 1); + } + var extension_index: cgltf_size = blk: { + const ref = &out_extensions_count.*; + const tmp = ref.*; + ref.* +%= 1; + break :blk tmp; + }; + _ = &extension_index; + var extension: [*c]cgltf_extension = &out_extensions.*[extension_index]; + _ = &extension; + i = cgltf_parse_json_unprocessed_extension(options, tokens, i, json_chunk, extension); + if (i < @as(c_int, 0)) { + return i; + } + } + } + return i; +} +pub fn cgltf_parse_json_draco_mesh_compression(arg_options: [*c]cgltf_options, arg_tokens: [*c]const jsmntok_t, arg_i: c_int, arg_json_chunk: [*c]const u8, arg_out_draco_mesh_compression: [*c]cgltf_draco_mesh_compression) callconv(.C) c_int { + var options = arg_options; + _ = &options; + var tokens = arg_tokens; + _ = &tokens; + var i = arg_i; + _ = &i; + var json_chunk = arg_json_chunk; + _ = &json_chunk; + var out_draco_mesh_compression = arg_out_draco_mesh_compression; + _ = &out_draco_mesh_compression; + if ((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.type != @as(c_uint, @bitCast(JSMN_OBJECT))) { + return -@as(c_int, 1); + } + var size: c_int = (blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.size; + _ = &size; + i += 1; + { + var j: c_int = 0; + _ = &j; + while (j < size) : (j += 1) { + if (((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.type != @as(c_uint, @bitCast(JSMN_STRING))) or ((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.size == @as(c_int, 0))) { + return -@as(c_int, 1); + } + if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "attributes") == @as(c_int, 0)) { + i = cgltf_parse_json_attribute_list(options, tokens, i + @as(c_int, 1), json_chunk, &out_draco_mesh_compression.*.attributes, &out_draco_mesh_compression.*.attributes_count); + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "bufferView") == @as(c_int, 0)) { + i += 1; + out_draco_mesh_compression.*.buffer_view = @as([*c]cgltf_buffer_view, @ptrFromInt(@as(cgltf_size, @bitCast(@as(c_long, cgltf_json_to_int(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk)))) +% @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 1)))))); + i += 1; + } else { + i = cgltf_skip_json(tokens, i + @as(c_int, 1)); + } + if (i < @as(c_int, 0)) { + return i; + } + } + } + return i; +} +pub fn cgltf_parse_json_mesh_gpu_instancing(arg_options: [*c]cgltf_options, arg_tokens: [*c]const jsmntok_t, arg_i: c_int, arg_json_chunk: [*c]const u8, arg_out_mesh_gpu_instancing: [*c]cgltf_mesh_gpu_instancing) callconv(.C) c_int { + var options = arg_options; + _ = &options; + var tokens = arg_tokens; + _ = &tokens; + var i = arg_i; + _ = &i; + var json_chunk = arg_json_chunk; + _ = &json_chunk; + var out_mesh_gpu_instancing = arg_out_mesh_gpu_instancing; + _ = &out_mesh_gpu_instancing; + if ((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.type != @as(c_uint, @bitCast(JSMN_OBJECT))) { + return -@as(c_int, 1); + } + var size: c_int = (blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.size; + _ = &size; + i += 1; + { + var j: c_int = 0; + _ = &j; + while (j < size) : (j += 1) { + if (((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.type != @as(c_uint, @bitCast(JSMN_STRING))) or ((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.size == @as(c_int, 0))) { + return -@as(c_int, 1); + } + if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "attributes") == @as(c_int, 0)) { + i = cgltf_parse_json_attribute_list(options, tokens, i + @as(c_int, 1), json_chunk, &out_mesh_gpu_instancing.*.attributes, &out_mesh_gpu_instancing.*.attributes_count); + } else { + i = cgltf_skip_json(tokens, i + @as(c_int, 1)); + } + if (i < @as(c_int, 0)) { + return i; + } + } + } + return i; +} +pub fn cgltf_parse_json_material_mapping_data(arg_options: [*c]cgltf_options, arg_tokens: [*c]const jsmntok_t, arg_i: c_int, arg_json_chunk: [*c]const u8, arg_out_mappings: [*c]cgltf_material_mapping, arg_offset: [*c]cgltf_size) callconv(.C) c_int { + var options = arg_options; + _ = &options; + var tokens = arg_tokens; + _ = &tokens; + var i = arg_i; + _ = &i; + var json_chunk = arg_json_chunk; + _ = &json_chunk; + var out_mappings = arg_out_mappings; + _ = &out_mappings; + var offset = arg_offset; + _ = &offset; + _ = &options; + if ((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.type != @as(c_uint, @bitCast(JSMN_ARRAY))) { + return -@as(c_int, 1); + } + var size: c_int = (blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.size; + _ = &size; + i += 1; + { + var j: c_int = 0; + _ = &j; + while (j < size) : (j += 1) { + if ((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.type != @as(c_uint, @bitCast(JSMN_OBJECT))) { + return -@as(c_int, 1); + } + var obj_size: c_int = (blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.size; + _ = &obj_size; + i += 1; + var material: c_int = -@as(c_int, 1); + _ = &material; + var variants_tok: c_int = -@as(c_int, 1); + _ = &variants_tok; + var extras_tok: c_int = -@as(c_int, 1); + _ = &extras_tok; + { + var k: c_int = 0; + _ = &k; + while (k < obj_size) : (k += 1) { + if (((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.type != @as(c_uint, @bitCast(JSMN_STRING))) or ((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.size == @as(c_int, 0))) { + return -@as(c_int, 1); + } + if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "material") == @as(c_int, 0)) { + i += 1; + material = cgltf_json_to_int(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk); + i += 1; + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "variants") == @as(c_int, 0)) { + variants_tok = i + @as(c_int, 1); + if ((blk: { + const tmp = variants_tok; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.type != @as(c_uint, @bitCast(JSMN_ARRAY))) { + return -@as(c_int, 1); + } + i = cgltf_skip_json(tokens, i + @as(c_int, 1)); + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "extras") == @as(c_int, 0)) { + extras_tok = i + @as(c_int, 1); + i = cgltf_skip_json(tokens, extras_tok); + } else { + i = cgltf_skip_json(tokens, i + @as(c_int, 1)); + } + if (i < @as(c_int, 0)) { + return i; + } + } + } + if ((material < @as(c_int, 0)) or (variants_tok < @as(c_int, 0))) { + return -@as(c_int, 1); + } + if (out_mappings != null) { + { + var k: c_int = 0; + _ = &k; + while (k < (blk: { + const tmp = variants_tok; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.size) : (k += 1) { + var variant: c_int = cgltf_json_to_int(&(blk: { + const tmp = (variants_tok + @as(c_int, 1)) + k; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*, json_chunk); + _ = &variant; + if (variant < @as(c_int, 0)) return variant; + out_mappings[offset.*].material = @as([*c]cgltf_material, @ptrFromInt(@as(cgltf_size, @bitCast(@as(c_long, material))) +% @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 1)))))); + out_mappings[offset.*].variant = @as(cgltf_size, @bitCast(@as(c_long, variant))); + if (extras_tok >= @as(c_int, 0)) { + var e: c_int = cgltf_parse_json_extras(options, tokens, extras_tok, json_chunk, &out_mappings[offset.*].extras); + _ = &e; + if (e < @as(c_int, 0)) return e; + } + offset.* +%= 1; + } + } + } else { + offset.* +%= @as(cgltf_size, @bitCast(@as(c_long, (blk: { + const tmp = variants_tok; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.size))); + } + } + } + return i; +} +pub fn cgltf_parse_json_material_mappings(arg_options: [*c]cgltf_options, arg_tokens: [*c]const jsmntok_t, arg_i: c_int, arg_json_chunk: [*c]const u8, arg_out_prim: [*c]cgltf_primitive) callconv(.C) c_int { + var options = arg_options; + _ = &options; + var tokens = arg_tokens; + _ = &tokens; + var i = arg_i; + _ = &i; + var json_chunk = arg_json_chunk; + _ = &json_chunk; + var out_prim = arg_out_prim; + _ = &out_prim; + if ((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.type != @as(c_uint, @bitCast(JSMN_OBJECT))) { + return -@as(c_int, 1); + } + var size: c_int = (blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.size; + _ = &size; + i += 1; + { + var j: c_int = 0; + _ = &j; + while (j < size) : (j += 1) { + if (((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.type != @as(c_uint, @bitCast(JSMN_STRING))) or ((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.size == @as(c_int, 0))) { + return -@as(c_int, 1); + } + if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "mappings") == @as(c_int, 0)) { + if (out_prim.*.mappings != null) { + return -@as(c_int, 1); + } + var mappings_offset: cgltf_size = 0; + _ = &mappings_offset; + var k: c_int = cgltf_parse_json_material_mapping_data(options, tokens, i + @as(c_int, 1), json_chunk, null, &mappings_offset); + _ = &k; + if (k < @as(c_int, 0)) { + return k; + } + out_prim.*.mappings_count = mappings_offset; + out_prim.*.mappings = @as([*c]cgltf_material_mapping, @ptrCast(@alignCast(cgltf_calloc(options, @sizeOf(cgltf_material_mapping), out_prim.*.mappings_count)))); + mappings_offset = 0; + i = cgltf_parse_json_material_mapping_data(options, tokens, i + @as(c_int, 1), json_chunk, out_prim.*.mappings, &mappings_offset); + } else { + i = cgltf_skip_json(tokens, i + @as(c_int, 1)); + } + if (i < @as(c_int, 0)) { + return i; + } + } + } + return i; +} +pub fn cgltf_json_to_primitive_type(arg_tok: [*c]const jsmntok_t, arg_json_chunk: [*c]const u8) callconv(.C) cgltf_primitive_type { + var tok = arg_tok; + _ = &tok; + var json_chunk = arg_json_chunk; + _ = &json_chunk; + var @"type": c_int = cgltf_json_to_int(tok, json_chunk); + _ = &@"type"; + while (true) { + switch (@"type") { + @as(c_int, 0) => return @as(c_uint, @bitCast(cgltf_primitive_type_points)), + @as(c_int, 1) => return @as(c_uint, @bitCast(cgltf_primitive_type_lines)), + @as(c_int, 2) => return @as(c_uint, @bitCast(cgltf_primitive_type_line_loop)), + @as(c_int, 3) => return @as(c_uint, @bitCast(cgltf_primitive_type_line_strip)), + @as(c_int, 4) => return @as(c_uint, @bitCast(cgltf_primitive_type_triangles)), + @as(c_int, 5) => return @as(c_uint, @bitCast(cgltf_primitive_type_triangle_strip)), + @as(c_int, 6) => return @as(c_uint, @bitCast(cgltf_primitive_type_triangle_fan)), + else => return @as(c_uint, @bitCast(cgltf_primitive_type_invalid)), + } + break; + } + return @import("std").mem.zeroes(cgltf_primitive_type); +} +pub fn cgltf_parse_json_primitive(arg_options: [*c]cgltf_options, arg_tokens: [*c]const jsmntok_t, arg_i: c_int, arg_json_chunk: [*c]const u8, arg_out_prim: [*c]cgltf_primitive) callconv(.C) c_int { + var options = arg_options; + _ = &options; + var tokens = arg_tokens; + _ = &tokens; + var i = arg_i; + _ = &i; + var json_chunk = arg_json_chunk; + _ = &json_chunk; + var out_prim = arg_out_prim; + _ = &out_prim; + if ((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.type != @as(c_uint, @bitCast(JSMN_OBJECT))) { + return -@as(c_int, 1); + } + out_prim.*.type = @as(c_uint, @bitCast(cgltf_primitive_type_triangles)); + var size: c_int = (blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.size; + _ = &size; + i += 1; + { + var j: c_int = 0; + _ = &j; + while (j < size) : (j += 1) { + if (((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.type != @as(c_uint, @bitCast(JSMN_STRING))) or ((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.size == @as(c_int, 0))) { + return -@as(c_int, 1); + } + if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "mode") == @as(c_int, 0)) { + i += 1; + out_prim.*.type = cgltf_json_to_primitive_type(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk); + i += 1; + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "indices") == @as(c_int, 0)) { + i += 1; + out_prim.*.indices = @as([*c]cgltf_accessor, @ptrFromInt(@as(cgltf_size, @bitCast(@as(c_long, cgltf_json_to_int(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk)))) +% @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 1)))))); + i += 1; + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "material") == @as(c_int, 0)) { + i += 1; + out_prim.*.material = @as([*c]cgltf_material, @ptrFromInt(@as(cgltf_size, @bitCast(@as(c_long, cgltf_json_to_int(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk)))) +% @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 1)))))); + i += 1; + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "attributes") == @as(c_int, 0)) { + i = cgltf_parse_json_attribute_list(options, tokens, i + @as(c_int, 1), json_chunk, &out_prim.*.attributes, &out_prim.*.attributes_count); + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "targets") == @as(c_int, 0)) { + i = cgltf_parse_json_array(options, tokens, i + @as(c_int, 1), json_chunk, @sizeOf(cgltf_morph_target), @as([*c]?*anyopaque, @ptrCast(@alignCast(&out_prim.*.targets))), &out_prim.*.targets_count); + if (i < @as(c_int, 0)) { + return i; + } + { + var k: cgltf_size = 0; + _ = &k; + while (k < out_prim.*.targets_count) : (k +%= 1) { + i = cgltf_parse_json_attribute_list(options, tokens, i, json_chunk, &out_prim.*.targets[k].attributes, &out_prim.*.targets[k].attributes_count); + if (i < @as(c_int, 0)) { + return i; + } + } + } + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "extras") == @as(c_int, 0)) { + i = cgltf_parse_json_extras(options, tokens, i + @as(c_int, 1), json_chunk, &out_prim.*.extras); + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "extensions") == @as(c_int, 0)) { + i += 1; + if ((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.type != @as(c_uint, @bitCast(JSMN_OBJECT))) { + return -@as(c_int, 1); + } + if (out_prim.*.extensions != null) { + return -@as(c_int, 1); + } + var extensions_size: c_int = (blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.size; + _ = &extensions_size; + out_prim.*.extensions_count = 0; + out_prim.*.extensions = @as([*c]cgltf_extension, @ptrCast(@alignCast(cgltf_calloc(options, @sizeOf(cgltf_extension), @as(cgltf_size, @bitCast(@as(c_long, extensions_size))))))); + if (!(out_prim.*.extensions != null)) { + return -@as(c_int, 2); + } + i += 1; + { + var k: c_int = 0; + _ = &k; + while (k < extensions_size) : (k += 1) { + if (((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.type != @as(c_uint, @bitCast(JSMN_STRING))) or ((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.size == @as(c_int, 0))) { + return -@as(c_int, 1); + } + if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "KHR_draco_mesh_compression") == @as(c_int, 0)) { + out_prim.*.has_draco_mesh_compression = 1; + i = cgltf_parse_json_draco_mesh_compression(options, tokens, i + @as(c_int, 1), json_chunk, &out_prim.*.draco_mesh_compression); + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "KHR_materials_variants") == @as(c_int, 0)) { + i = cgltf_parse_json_material_mappings(options, tokens, i + @as(c_int, 1), json_chunk, out_prim); + } else { + i = cgltf_parse_json_unprocessed_extension(options, tokens, i, json_chunk, &out_prim.*.extensions[blk: { + const ref = &out_prim.*.extensions_count; + const tmp = ref.*; + ref.* +%= 1; + break :blk tmp; + }]); + } + if (i < @as(c_int, 0)) { + return i; + } + } + } + } else { + i = cgltf_skip_json(tokens, i + @as(c_int, 1)); + } + if (i < @as(c_int, 0)) { + return i; + } + } + } + return i; +} +pub fn cgltf_parse_json_mesh(arg_options: [*c]cgltf_options, arg_tokens: [*c]const jsmntok_t, arg_i: c_int, arg_json_chunk: [*c]const u8, arg_out_mesh: [*c]cgltf_mesh) callconv(.C) c_int { + var options = arg_options; + _ = &options; + var tokens = arg_tokens; + _ = &tokens; + var i = arg_i; + _ = &i; + var json_chunk = arg_json_chunk; + _ = &json_chunk; + var out_mesh = arg_out_mesh; + _ = &out_mesh; + if ((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.type != @as(c_uint, @bitCast(JSMN_OBJECT))) { + return -@as(c_int, 1); + } + var size: c_int = (blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.size; + _ = &size; + i += 1; + { + var j: c_int = 0; + _ = &j; + while (j < size) : (j += 1) { + if (((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.type != @as(c_uint, @bitCast(JSMN_STRING))) or ((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.size == @as(c_int, 0))) { + return -@as(c_int, 1); + } + if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "name") == @as(c_int, 0)) { + i = cgltf_parse_json_string(options, tokens, i + @as(c_int, 1), json_chunk, &out_mesh.*.name); + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "primitives") == @as(c_int, 0)) { + i = cgltf_parse_json_array(options, tokens, i + @as(c_int, 1), json_chunk, @sizeOf(cgltf_primitive), @as([*c]?*anyopaque, @ptrCast(@alignCast(&out_mesh.*.primitives))), &out_mesh.*.primitives_count); + if (i < @as(c_int, 0)) { + return i; + } + { + var prim_index: cgltf_size = 0; + _ = &prim_index; + while (prim_index < out_mesh.*.primitives_count) : (prim_index +%= 1) { + i = cgltf_parse_json_primitive(options, tokens, i, json_chunk, &out_mesh.*.primitives[prim_index]); + if (i < @as(c_int, 0)) { + return i; + } + } + } + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "weights") == @as(c_int, 0)) { + i = cgltf_parse_json_array(options, tokens, i + @as(c_int, 1), json_chunk, @sizeOf(cgltf_float), @as([*c]?*anyopaque, @ptrCast(@alignCast(&out_mesh.*.weights))), &out_mesh.*.weights_count); + if (i < @as(c_int, 0)) { + return i; + } + i = cgltf_parse_json_float_array(tokens, i - @as(c_int, 1), json_chunk, out_mesh.*.weights, @as(c_int, @bitCast(@as(c_uint, @truncate(out_mesh.*.weights_count))))); + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "extras") == @as(c_int, 0)) { + i += 1; + out_mesh.*.extras.start_offset = @as(cgltf_size, @bitCast((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.start)); + out_mesh.*.extras.end_offset = @as(cgltf_size, @bitCast((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.end)); + if ((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.type == @as(c_uint, @bitCast(JSMN_OBJECT))) { + var extras_size: c_int = (blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.size; + _ = &extras_size; + i += 1; + { + var k: c_int = 0; + _ = &k; + while (k < extras_size) : (k += 1) { + if (((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.type != @as(c_uint, @bitCast(JSMN_STRING))) or ((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.size == @as(c_int, 0))) { + return -@as(c_int, 1); + } + if ((cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "targetNames") == @as(c_int, 0)) and ((blk: { + const tmp = i + @as(c_int, 1); + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.type == @as(c_uint, @bitCast(JSMN_ARRAY)))) { + i = cgltf_parse_json_string_array(options, tokens, i + @as(c_int, 1), json_chunk, &out_mesh.*.target_names, &out_mesh.*.target_names_count); + } else { + i = cgltf_skip_json(tokens, i + @as(c_int, 1)); + } + if (i < @as(c_int, 0)) { + return i; + } + } + } + } else { + i = cgltf_skip_json(tokens, i); + } + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "extensions") == @as(c_int, 0)) { + i = cgltf_parse_json_unprocessed_extensions(options, tokens, i, json_chunk, &out_mesh.*.extensions_count, &out_mesh.*.extensions); + } else { + i = cgltf_skip_json(tokens, i + @as(c_int, 1)); + } + if (i < @as(c_int, 0)) { + return i; + } + } + } + return i; +} +pub fn cgltf_parse_json_meshes(arg_options: [*c]cgltf_options, arg_tokens: [*c]const jsmntok_t, arg_i: c_int, arg_json_chunk: [*c]const u8, arg_out_data: [*c]cgltf_data) callconv(.C) c_int { + var options = arg_options; + _ = &options; + var tokens = arg_tokens; + _ = &tokens; + var i = arg_i; + _ = &i; + var json_chunk = arg_json_chunk; + _ = &json_chunk; + var out_data = arg_out_data; + _ = &out_data; + i = cgltf_parse_json_array(options, tokens, i, json_chunk, @sizeOf(cgltf_mesh), @as([*c]?*anyopaque, @ptrCast(@alignCast(&out_data.*.meshes))), &out_data.*.meshes_count); + if (i < @as(c_int, 0)) { + return i; + } + { + var j: cgltf_size = 0; + _ = &j; + while (j < out_data.*.meshes_count) : (j +%= 1) { + i = cgltf_parse_json_mesh(options, tokens, i, json_chunk, &out_data.*.meshes[j]); + if (i < @as(c_int, 0)) { + return i; + } + } + } + return i; +} +pub fn cgltf_json_to_component_type(arg_tok: [*c]const jsmntok_t, arg_json_chunk: [*c]const u8) callconv(.C) cgltf_component_type { + var tok = arg_tok; + _ = &tok; + var json_chunk = arg_json_chunk; + _ = &json_chunk; + var @"type": c_int = cgltf_json_to_int(tok, json_chunk); + _ = &@"type"; + while (true) { + switch (@"type") { + @as(c_int, 5120) => return @as(c_uint, @bitCast(cgltf_component_type_r_8)), + @as(c_int, 5121) => return @as(c_uint, @bitCast(cgltf_component_type_r_8u)), + @as(c_int, 5122) => return @as(c_uint, @bitCast(cgltf_component_type_r_16)), + @as(c_int, 5123) => return @as(c_uint, @bitCast(cgltf_component_type_r_16u)), + @as(c_int, 5125) => return @as(c_uint, @bitCast(cgltf_component_type_r_32u)), + @as(c_int, 5126) => return @as(c_uint, @bitCast(cgltf_component_type_r_32f)), + else => return @as(c_uint, @bitCast(cgltf_component_type_invalid)), + } + break; + } + return @import("std").mem.zeroes(cgltf_component_type); +} +pub fn cgltf_parse_json_accessor_sparse(arg_tokens: [*c]const jsmntok_t, arg_i: c_int, arg_json_chunk: [*c]const u8, arg_out_sparse: [*c]cgltf_accessor_sparse) callconv(.C) c_int { + var tokens = arg_tokens; + _ = &tokens; + var i = arg_i; + _ = &i; + var json_chunk = arg_json_chunk; + _ = &json_chunk; + var out_sparse = arg_out_sparse; + _ = &out_sparse; + if ((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.type != @as(c_uint, @bitCast(JSMN_OBJECT))) { + return -@as(c_int, 1); + } + var size: c_int = (blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.size; + _ = &size; + i += 1; + { + var j: c_int = 0; + _ = &j; + while (j < size) : (j += 1) { + if (((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.type != @as(c_uint, @bitCast(JSMN_STRING))) or ((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.size == @as(c_int, 0))) { + return -@as(c_int, 1); + } + if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "count") == @as(c_int, 0)) { + i += 1; + out_sparse.*.count = cgltf_json_to_size(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk); + i += 1; + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "indices") == @as(c_int, 0)) { + i += 1; + if ((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.type != @as(c_uint, @bitCast(JSMN_OBJECT))) { + return -@as(c_int, 1); + } + var indices_size: c_int = (blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.size; + _ = &indices_size; + i += 1; + { + var k: c_int = 0; + _ = &k; + while (k < indices_size) : (k += 1) { + if (((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.type != @as(c_uint, @bitCast(JSMN_STRING))) or ((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.size == @as(c_int, 0))) { + return -@as(c_int, 1); + } + if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "bufferView") == @as(c_int, 0)) { + i += 1; + out_sparse.*.indices_buffer_view = @as([*c]cgltf_buffer_view, @ptrFromInt(@as(cgltf_size, @bitCast(@as(c_long, cgltf_json_to_int(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk)))) +% @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 1)))))); + i += 1; + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "byteOffset") == @as(c_int, 0)) { + i += 1; + out_sparse.*.indices_byte_offset = cgltf_json_to_size(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk); + i += 1; + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "componentType") == @as(c_int, 0)) { + i += 1; + out_sparse.*.indices_component_type = cgltf_json_to_component_type(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk); + i += 1; + } else { + i = cgltf_skip_json(tokens, i + @as(c_int, 1)); + } + if (i < @as(c_int, 0)) { + return i; + } + } + } + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "values") == @as(c_int, 0)) { + i += 1; + if ((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.type != @as(c_uint, @bitCast(JSMN_OBJECT))) { + return -@as(c_int, 1); + } + var values_size: c_int = (blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.size; + _ = &values_size; + i += 1; + { + var k: c_int = 0; + _ = &k; + while (k < values_size) : (k += 1) { + if (((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.type != @as(c_uint, @bitCast(JSMN_STRING))) or ((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.size == @as(c_int, 0))) { + return -@as(c_int, 1); + } + if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "bufferView") == @as(c_int, 0)) { + i += 1; + out_sparse.*.values_buffer_view = @as([*c]cgltf_buffer_view, @ptrFromInt(@as(cgltf_size, @bitCast(@as(c_long, cgltf_json_to_int(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk)))) +% @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 1)))))); + i += 1; + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "byteOffset") == @as(c_int, 0)) { + i += 1; + out_sparse.*.values_byte_offset = cgltf_json_to_size(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk); + i += 1; + } else { + i = cgltf_skip_json(tokens, i + @as(c_int, 1)); + } + if (i < @as(c_int, 0)) { + return i; + } + } + } + } else { + i = cgltf_skip_json(tokens, i + @as(c_int, 1)); + } + if (i < @as(c_int, 0)) { + return i; + } + } + } + return i; +} +pub fn cgltf_parse_json_accessor(arg_options: [*c]cgltf_options, arg_tokens: [*c]const jsmntok_t, arg_i: c_int, arg_json_chunk: [*c]const u8, arg_out_accessor: [*c]cgltf_accessor) callconv(.C) c_int { + var options = arg_options; + _ = &options; + var tokens = arg_tokens; + _ = &tokens; + var i = arg_i; + _ = &i; + var json_chunk = arg_json_chunk; + _ = &json_chunk; + var out_accessor = arg_out_accessor; + _ = &out_accessor; + if ((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.type != @as(c_uint, @bitCast(JSMN_OBJECT))) { + return -@as(c_int, 1); + } + var size: c_int = (blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.size; + _ = &size; + i += 1; + { + var j: c_int = 0; + _ = &j; + while (j < size) : (j += 1) { + if (((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.type != @as(c_uint, @bitCast(JSMN_STRING))) or ((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.size == @as(c_int, 0))) { + return -@as(c_int, 1); + } + if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "name") == @as(c_int, 0)) { + i = cgltf_parse_json_string(options, tokens, i + @as(c_int, 1), json_chunk, &out_accessor.*.name); + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "bufferView") == @as(c_int, 0)) { + i += 1; + out_accessor.*.buffer_view = @as([*c]cgltf_buffer_view, @ptrFromInt(@as(cgltf_size, @bitCast(@as(c_long, cgltf_json_to_int(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk)))) +% @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 1)))))); + i += 1; + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "byteOffset") == @as(c_int, 0)) { + i += 1; + out_accessor.*.offset = cgltf_json_to_size(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk); + i += 1; + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "componentType") == @as(c_int, 0)) { + i += 1; + out_accessor.*.component_type = cgltf_json_to_component_type(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk); + i += 1; + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "normalized") == @as(c_int, 0)) { + i += 1; + out_accessor.*.normalized = cgltf_json_to_bool(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk); + i += 1; + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "count") == @as(c_int, 0)) { + i += 1; + out_accessor.*.count = cgltf_json_to_size(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk); + i += 1; + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "type") == @as(c_int, 0)) { + i += 1; + if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "SCALAR") == @as(c_int, 0)) { + out_accessor.*.type = @as(c_uint, @bitCast(cgltf_type_scalar)); + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "VEC2") == @as(c_int, 0)) { + out_accessor.*.type = @as(c_uint, @bitCast(cgltf_type_vec2)); + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "VEC3") == @as(c_int, 0)) { + out_accessor.*.type = @as(c_uint, @bitCast(cgltf_type_vec3)); + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "VEC4") == @as(c_int, 0)) { + out_accessor.*.type = @as(c_uint, @bitCast(cgltf_type_vec4)); + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "MAT2") == @as(c_int, 0)) { + out_accessor.*.type = @as(c_uint, @bitCast(cgltf_type_mat2)); + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "MAT3") == @as(c_int, 0)) { + out_accessor.*.type = @as(c_uint, @bitCast(cgltf_type_mat3)); + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "MAT4") == @as(c_int, 0)) { + out_accessor.*.type = @as(c_uint, @bitCast(cgltf_type_mat4)); + } + i += 1; + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "min") == @as(c_int, 0)) { + i += 1; + out_accessor.*.has_min = 1; + var min_size: c_int = if ((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.size > @as(c_int, 16)) @as(c_int, 16) else (blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.size; + _ = &min_size; + i = cgltf_parse_json_float_array(tokens, i, json_chunk, @as([*c]cgltf_float, @ptrCast(@alignCast(&out_accessor.*.min))), min_size); + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "max") == @as(c_int, 0)) { + i += 1; + out_accessor.*.has_max = 1; + var max_size: c_int = if ((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.size > @as(c_int, 16)) @as(c_int, 16) else (blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.size; + _ = &max_size; + i = cgltf_parse_json_float_array(tokens, i, json_chunk, @as([*c]cgltf_float, @ptrCast(@alignCast(&out_accessor.*.max))), max_size); + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "sparse") == @as(c_int, 0)) { + out_accessor.*.is_sparse = 1; + i = cgltf_parse_json_accessor_sparse(tokens, i + @as(c_int, 1), json_chunk, &out_accessor.*.sparse); + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "extras") == @as(c_int, 0)) { + i = cgltf_parse_json_extras(options, tokens, i + @as(c_int, 1), json_chunk, &out_accessor.*.extras); + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "extensions") == @as(c_int, 0)) { + i = cgltf_parse_json_unprocessed_extensions(options, tokens, i, json_chunk, &out_accessor.*.extensions_count, &out_accessor.*.extensions); + } else { + i = cgltf_skip_json(tokens, i + @as(c_int, 1)); + } + if (i < @as(c_int, 0)) { + return i; + } + } + } + return i; +} +pub fn cgltf_parse_json_texture_transform(arg_tokens: [*c]const jsmntok_t, arg_i: c_int, arg_json_chunk: [*c]const u8, arg_out_texture_transform: [*c]cgltf_texture_transform) callconv(.C) c_int { + var tokens = arg_tokens; + _ = &tokens; + var i = arg_i; + _ = &i; + var json_chunk = arg_json_chunk; + _ = &json_chunk; + var out_texture_transform = arg_out_texture_transform; + _ = &out_texture_transform; + if ((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.type != @as(c_uint, @bitCast(JSMN_OBJECT))) { + return -@as(c_int, 1); + } + var size: c_int = (blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.size; + _ = &size; + i += 1; + { + var j: c_int = 0; + _ = &j; + while (j < size) : (j += 1) { + if (((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.type != @as(c_uint, @bitCast(JSMN_STRING))) or ((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.size == @as(c_int, 0))) { + return -@as(c_int, 1); + } + if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "offset") == @as(c_int, 0)) { + i = cgltf_parse_json_float_array(tokens, i + @as(c_int, 1), json_chunk, @as([*c]cgltf_float, @ptrCast(@alignCast(&out_texture_transform.*.offset))), @as(c_int, 2)); + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "rotation") == @as(c_int, 0)) { + i += 1; + out_texture_transform.*.rotation = cgltf_json_to_float(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk); + i += 1; + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "scale") == @as(c_int, 0)) { + i = cgltf_parse_json_float_array(tokens, i + @as(c_int, 1), json_chunk, @as([*c]cgltf_float, @ptrCast(@alignCast(&out_texture_transform.*.scale))), @as(c_int, 2)); + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "texCoord") == @as(c_int, 0)) { + i += 1; + out_texture_transform.*.has_texcoord = 1; + out_texture_transform.*.texcoord = cgltf_json_to_int(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk); + i += 1; + } else { + i = cgltf_skip_json(tokens, i + @as(c_int, 1)); + } + if (i < @as(c_int, 0)) { + return i; + } + } + } + return i; +} +pub fn cgltf_parse_json_texture_view(arg_options: [*c]cgltf_options, arg_tokens: [*c]const jsmntok_t, arg_i: c_int, arg_json_chunk: [*c]const u8, arg_out_texture_view: [*c]cgltf_texture_view) callconv(.C) c_int { + var options = arg_options; + _ = &options; + var tokens = arg_tokens; + _ = &tokens; + var i = arg_i; + _ = &i; + var json_chunk = arg_json_chunk; + _ = &json_chunk; + var out_texture_view = arg_out_texture_view; + _ = &out_texture_view; + _ = &options; + if ((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.type != @as(c_uint, @bitCast(JSMN_OBJECT))) { + return -@as(c_int, 1); + } + out_texture_view.*.scale = 1.0; + cgltf_fill_float_array(@as([*c]cgltf_float, @ptrCast(@alignCast(&out_texture_view.*.transform.scale))), @as(c_int, 2), 1.0); + var size: c_int = (blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.size; + _ = &size; + i += 1; + { + var j: c_int = 0; + _ = &j; + while (j < size) : (j += 1) { + if (((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.type != @as(c_uint, @bitCast(JSMN_STRING))) or ((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.size == @as(c_int, 0))) { + return -@as(c_int, 1); + } + if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "index") == @as(c_int, 0)) { + i += 1; + out_texture_view.*.texture = @as([*c]cgltf_texture, @ptrFromInt(@as(cgltf_size, @bitCast(@as(c_long, cgltf_json_to_int(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk)))) +% @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 1)))))); + i += 1; + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "texCoord") == @as(c_int, 0)) { + i += 1; + out_texture_view.*.texcoord = cgltf_json_to_int(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk); + i += 1; + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "scale") == @as(c_int, 0)) { + i += 1; + out_texture_view.*.scale = cgltf_json_to_float(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk); + i += 1; + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "strength") == @as(c_int, 0)) { + i += 1; + out_texture_view.*.scale = cgltf_json_to_float(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk); + i += 1; + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "extensions") == @as(c_int, 0)) { + i += 1; + if ((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.type != @as(c_uint, @bitCast(JSMN_OBJECT))) { + return -@as(c_int, 1); + } + var extensions_size: c_int = (blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.size; + _ = &extensions_size; + i += 1; + { + var k: c_int = 0; + _ = &k; + while (k < extensions_size) : (k += 1) { + if (((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.type != @as(c_uint, @bitCast(JSMN_STRING))) or ((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.size == @as(c_int, 0))) { + return -@as(c_int, 1); + } + if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "KHR_texture_transform") == @as(c_int, 0)) { + out_texture_view.*.has_transform = 1; + i = cgltf_parse_json_texture_transform(tokens, i + @as(c_int, 1), json_chunk, &out_texture_view.*.transform); + } else { + i = cgltf_skip_json(tokens, i + @as(c_int, 1)); + } + if (i < @as(c_int, 0)) { + return i; + } + } + } + } else { + i = cgltf_skip_json(tokens, i + @as(c_int, 1)); + } + if (i < @as(c_int, 0)) { + return i; + } + } + } + return i; +} +pub fn cgltf_parse_json_pbr_metallic_roughness(arg_options: [*c]cgltf_options, arg_tokens: [*c]const jsmntok_t, arg_i: c_int, arg_json_chunk: [*c]const u8, arg_out_pbr: [*c]cgltf_pbr_metallic_roughness) callconv(.C) c_int { + var options = arg_options; + _ = &options; + var tokens = arg_tokens; + _ = &tokens; + var i = arg_i; + _ = &i; + var json_chunk = arg_json_chunk; + _ = &json_chunk; + var out_pbr = arg_out_pbr; + _ = &out_pbr; + if ((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.type != @as(c_uint, @bitCast(JSMN_OBJECT))) { + return -@as(c_int, 1); + } + var size: c_int = (blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.size; + _ = &size; + i += 1; + { + var j: c_int = 0; + _ = &j; + while (j < size) : (j += 1) { + if (((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.type != @as(c_uint, @bitCast(JSMN_STRING))) or ((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.size == @as(c_int, 0))) { + return -@as(c_int, 1); + } + if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "metallicFactor") == @as(c_int, 0)) { + i += 1; + out_pbr.*.metallic_factor = cgltf_json_to_float(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk); + i += 1; + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "roughnessFactor") == @as(c_int, 0)) { + i += 1; + out_pbr.*.roughness_factor = cgltf_json_to_float(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk); + i += 1; + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "baseColorFactor") == @as(c_int, 0)) { + i = cgltf_parse_json_float_array(tokens, i + @as(c_int, 1), json_chunk, @as([*c]cgltf_float, @ptrCast(@alignCast(&out_pbr.*.base_color_factor))), @as(c_int, 4)); + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "baseColorTexture") == @as(c_int, 0)) { + i = cgltf_parse_json_texture_view(options, tokens, i + @as(c_int, 1), json_chunk, &out_pbr.*.base_color_texture); + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "metallicRoughnessTexture") == @as(c_int, 0)) { + i = cgltf_parse_json_texture_view(options, tokens, i + @as(c_int, 1), json_chunk, &out_pbr.*.metallic_roughness_texture); + } else { + i = cgltf_skip_json(tokens, i + @as(c_int, 1)); + } + if (i < @as(c_int, 0)) { + return i; + } + } + } + return i; +} +pub fn cgltf_parse_json_pbr_specular_glossiness(arg_options: [*c]cgltf_options, arg_tokens: [*c]const jsmntok_t, arg_i: c_int, arg_json_chunk: [*c]const u8, arg_out_pbr: [*c]cgltf_pbr_specular_glossiness) callconv(.C) c_int { + var options = arg_options; + _ = &options; + var tokens = arg_tokens; + _ = &tokens; + var i = arg_i; + _ = &i; + var json_chunk = arg_json_chunk; + _ = &json_chunk; + var out_pbr = arg_out_pbr; + _ = &out_pbr; + if ((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.type != @as(c_uint, @bitCast(JSMN_OBJECT))) { + return -@as(c_int, 1); + } + var size: c_int = (blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.size; + _ = &size; + i += 1; + { + var j: c_int = 0; + _ = &j; + while (j < size) : (j += 1) { + if (((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.type != @as(c_uint, @bitCast(JSMN_STRING))) or ((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.size == @as(c_int, 0))) { + return -@as(c_int, 1); + } + if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "diffuseFactor") == @as(c_int, 0)) { + i = cgltf_parse_json_float_array(tokens, i + @as(c_int, 1), json_chunk, @as([*c]cgltf_float, @ptrCast(@alignCast(&out_pbr.*.diffuse_factor))), @as(c_int, 4)); + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "specularFactor") == @as(c_int, 0)) { + i = cgltf_parse_json_float_array(tokens, i + @as(c_int, 1), json_chunk, @as([*c]cgltf_float, @ptrCast(@alignCast(&out_pbr.*.specular_factor))), @as(c_int, 3)); + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "glossinessFactor") == @as(c_int, 0)) { + i += 1; + out_pbr.*.glossiness_factor = cgltf_json_to_float(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk); + i += 1; + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "diffuseTexture") == @as(c_int, 0)) { + i = cgltf_parse_json_texture_view(options, tokens, i + @as(c_int, 1), json_chunk, &out_pbr.*.diffuse_texture); + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "specularGlossinessTexture") == @as(c_int, 0)) { + i = cgltf_parse_json_texture_view(options, tokens, i + @as(c_int, 1), json_chunk, &out_pbr.*.specular_glossiness_texture); + } else { + i = cgltf_skip_json(tokens, i + @as(c_int, 1)); + } + if (i < @as(c_int, 0)) { + return i; + } + } + } + return i; +} +pub fn cgltf_parse_json_clearcoat(arg_options: [*c]cgltf_options, arg_tokens: [*c]const jsmntok_t, arg_i: c_int, arg_json_chunk: [*c]const u8, arg_out_clearcoat: [*c]cgltf_clearcoat) callconv(.C) c_int { + var options = arg_options; + _ = &options; + var tokens = arg_tokens; + _ = &tokens; + var i = arg_i; + _ = &i; + var json_chunk = arg_json_chunk; + _ = &json_chunk; + var out_clearcoat = arg_out_clearcoat; + _ = &out_clearcoat; + if ((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.type != @as(c_uint, @bitCast(JSMN_OBJECT))) { + return -@as(c_int, 1); + } + var size: c_int = (blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.size; + _ = &size; + i += 1; + { + var j: c_int = 0; + _ = &j; + while (j < size) : (j += 1) { + if (((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.type != @as(c_uint, @bitCast(JSMN_STRING))) or ((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.size == @as(c_int, 0))) { + return -@as(c_int, 1); + } + if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "clearcoatFactor") == @as(c_int, 0)) { + i += 1; + out_clearcoat.*.clearcoat_factor = cgltf_json_to_float(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk); + i += 1; + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "clearcoatRoughnessFactor") == @as(c_int, 0)) { + i += 1; + out_clearcoat.*.clearcoat_roughness_factor = cgltf_json_to_float(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk); + i += 1; + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "clearcoatTexture") == @as(c_int, 0)) { + i = cgltf_parse_json_texture_view(options, tokens, i + @as(c_int, 1), json_chunk, &out_clearcoat.*.clearcoat_texture); + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "clearcoatRoughnessTexture") == @as(c_int, 0)) { + i = cgltf_parse_json_texture_view(options, tokens, i + @as(c_int, 1), json_chunk, &out_clearcoat.*.clearcoat_roughness_texture); + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "clearcoatNormalTexture") == @as(c_int, 0)) { + i = cgltf_parse_json_texture_view(options, tokens, i + @as(c_int, 1), json_chunk, &out_clearcoat.*.clearcoat_normal_texture); + } else { + i = cgltf_skip_json(tokens, i + @as(c_int, 1)); + } + if (i < @as(c_int, 0)) { + return i; + } + } + } + return i; +} +pub fn cgltf_parse_json_ior(arg_tokens: [*c]const jsmntok_t, arg_i: c_int, arg_json_chunk: [*c]const u8, arg_out_ior: [*c]cgltf_ior) callconv(.C) c_int { + var tokens = arg_tokens; + _ = &tokens; + var i = arg_i; + _ = &i; + var json_chunk = arg_json_chunk; + _ = &json_chunk; + var out_ior = arg_out_ior; + _ = &out_ior; + if ((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.type != @as(c_uint, @bitCast(JSMN_OBJECT))) { + return -@as(c_int, 1); + } + var size: c_int = (blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.size; + _ = &size; + i += 1; + out_ior.*.ior = 1.5; + { + var j: c_int = 0; + _ = &j; + while (j < size) : (j += 1) { + if (((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.type != @as(c_uint, @bitCast(JSMN_STRING))) or ((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.size == @as(c_int, 0))) { + return -@as(c_int, 1); + } + if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "ior") == @as(c_int, 0)) { + i += 1; + out_ior.*.ior = cgltf_json_to_float(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk); + i += 1; + } else { + i = cgltf_skip_json(tokens, i + @as(c_int, 1)); + } + if (i < @as(c_int, 0)) { + return i; + } + } + } + return i; +} +pub fn cgltf_parse_json_specular(arg_options: [*c]cgltf_options, arg_tokens: [*c]const jsmntok_t, arg_i: c_int, arg_json_chunk: [*c]const u8, arg_out_specular: [*c]cgltf_specular) callconv(.C) c_int { + var options = arg_options; + _ = &options; + var tokens = arg_tokens; + _ = &tokens; + var i = arg_i; + _ = &i; + var json_chunk = arg_json_chunk; + _ = &json_chunk; + var out_specular = arg_out_specular; + _ = &out_specular; + if ((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.type != @as(c_uint, @bitCast(JSMN_OBJECT))) { + return -@as(c_int, 1); + } + var size: c_int = (blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.size; + _ = &size; + i += 1; + out_specular.*.specular_factor = 1.0; + cgltf_fill_float_array(@as([*c]cgltf_float, @ptrCast(@alignCast(&out_specular.*.specular_color_factor))), @as(c_int, 3), 1.0); + { + var j: c_int = 0; + _ = &j; + while (j < size) : (j += 1) { + if (((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.type != @as(c_uint, @bitCast(JSMN_STRING))) or ((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.size == @as(c_int, 0))) { + return -@as(c_int, 1); + } + if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "specularFactor") == @as(c_int, 0)) { + i += 1; + out_specular.*.specular_factor = cgltf_json_to_float(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk); + i += 1; + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "specularColorFactor") == @as(c_int, 0)) { + i = cgltf_parse_json_float_array(tokens, i + @as(c_int, 1), json_chunk, @as([*c]cgltf_float, @ptrCast(@alignCast(&out_specular.*.specular_color_factor))), @as(c_int, 3)); + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "specularTexture") == @as(c_int, 0)) { + i = cgltf_parse_json_texture_view(options, tokens, i + @as(c_int, 1), json_chunk, &out_specular.*.specular_texture); + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "specularColorTexture") == @as(c_int, 0)) { + i = cgltf_parse_json_texture_view(options, tokens, i + @as(c_int, 1), json_chunk, &out_specular.*.specular_color_texture); + } else { + i = cgltf_skip_json(tokens, i + @as(c_int, 1)); + } + if (i < @as(c_int, 0)) { + return i; + } + } + } + return i; +} +pub fn cgltf_parse_json_transmission(arg_options: [*c]cgltf_options, arg_tokens: [*c]const jsmntok_t, arg_i: c_int, arg_json_chunk: [*c]const u8, arg_out_transmission: [*c]cgltf_transmission) callconv(.C) c_int { + var options = arg_options; + _ = &options; + var tokens = arg_tokens; + _ = &tokens; + var i = arg_i; + _ = &i; + var json_chunk = arg_json_chunk; + _ = &json_chunk; + var out_transmission = arg_out_transmission; + _ = &out_transmission; + if ((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.type != @as(c_uint, @bitCast(JSMN_OBJECT))) { + return -@as(c_int, 1); + } + var size: c_int = (blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.size; + _ = &size; + i += 1; + { + var j: c_int = 0; + _ = &j; + while (j < size) : (j += 1) { + if (((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.type != @as(c_uint, @bitCast(JSMN_STRING))) or ((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.size == @as(c_int, 0))) { + return -@as(c_int, 1); + } + if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "transmissionFactor") == @as(c_int, 0)) { + i += 1; + out_transmission.*.transmission_factor = cgltf_json_to_float(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk); + i += 1; + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "transmissionTexture") == @as(c_int, 0)) { + i = cgltf_parse_json_texture_view(options, tokens, i + @as(c_int, 1), json_chunk, &out_transmission.*.transmission_texture); + } else { + i = cgltf_skip_json(tokens, i + @as(c_int, 1)); + } + if (i < @as(c_int, 0)) { + return i; + } + } + } + return i; +} +pub fn cgltf_parse_json_volume(arg_options: [*c]cgltf_options, arg_tokens: [*c]const jsmntok_t, arg_i: c_int, arg_json_chunk: [*c]const u8, arg_out_volume: [*c]cgltf_volume) callconv(.C) c_int { + var options = arg_options; + _ = &options; + var tokens = arg_tokens; + _ = &tokens; + var i = arg_i; + _ = &i; + var json_chunk = arg_json_chunk; + _ = &json_chunk; + var out_volume = arg_out_volume; + _ = &out_volume; + if ((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.type != @as(c_uint, @bitCast(JSMN_OBJECT))) { + return -@as(c_int, 1); + } + var size: c_int = (blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.size; + _ = &size; + i += 1; + { + var j: c_int = 0; + _ = &j; + while (j < size) : (j += 1) { + if (((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.type != @as(c_uint, @bitCast(JSMN_STRING))) or ((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.size == @as(c_int, 0))) { + return -@as(c_int, 1); + } + if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "thicknessFactor") == @as(c_int, 0)) { + i += 1; + out_volume.*.thickness_factor = cgltf_json_to_float(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk); + i += 1; + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "thicknessTexture") == @as(c_int, 0)) { + i = cgltf_parse_json_texture_view(options, tokens, i + @as(c_int, 1), json_chunk, &out_volume.*.thickness_texture); + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "attenuationColor") == @as(c_int, 0)) { + i = cgltf_parse_json_float_array(tokens, i + @as(c_int, 1), json_chunk, @as([*c]cgltf_float, @ptrCast(@alignCast(&out_volume.*.attenuation_color))), @as(c_int, 3)); + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "attenuationDistance") == @as(c_int, 0)) { + i += 1; + out_volume.*.attenuation_distance = cgltf_json_to_float(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk); + i += 1; + } else { + i = cgltf_skip_json(tokens, i + @as(c_int, 1)); + } + if (i < @as(c_int, 0)) { + return i; + } + } + } + return i; +} +pub fn cgltf_parse_json_sheen(arg_options: [*c]cgltf_options, arg_tokens: [*c]const jsmntok_t, arg_i: c_int, arg_json_chunk: [*c]const u8, arg_out_sheen: [*c]cgltf_sheen) callconv(.C) c_int { + var options = arg_options; + _ = &options; + var tokens = arg_tokens; + _ = &tokens; + var i = arg_i; + _ = &i; + var json_chunk = arg_json_chunk; + _ = &json_chunk; + var out_sheen = arg_out_sheen; + _ = &out_sheen; + if ((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.type != @as(c_uint, @bitCast(JSMN_OBJECT))) { + return -@as(c_int, 1); + } + var size: c_int = (blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.size; + _ = &size; + i += 1; + { + var j: c_int = 0; + _ = &j; + while (j < size) : (j += 1) { + if (((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.type != @as(c_uint, @bitCast(JSMN_STRING))) or ((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.size == @as(c_int, 0))) { + return -@as(c_int, 1); + } + if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "sheenColorFactor") == @as(c_int, 0)) { + i = cgltf_parse_json_float_array(tokens, i + @as(c_int, 1), json_chunk, @as([*c]cgltf_float, @ptrCast(@alignCast(&out_sheen.*.sheen_color_factor))), @as(c_int, 3)); + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "sheenColorTexture") == @as(c_int, 0)) { + i = cgltf_parse_json_texture_view(options, tokens, i + @as(c_int, 1), json_chunk, &out_sheen.*.sheen_color_texture); + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "sheenRoughnessFactor") == @as(c_int, 0)) { + i += 1; + out_sheen.*.sheen_roughness_factor = cgltf_json_to_float(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk); + i += 1; + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "sheenRoughnessTexture") == @as(c_int, 0)) { + i = cgltf_parse_json_texture_view(options, tokens, i + @as(c_int, 1), json_chunk, &out_sheen.*.sheen_roughness_texture); + } else { + i = cgltf_skip_json(tokens, i + @as(c_int, 1)); + } + if (i < @as(c_int, 0)) { + return i; + } + } + } + return i; +} +pub fn cgltf_parse_json_emissive_strength(arg_tokens: [*c]const jsmntok_t, arg_i: c_int, arg_json_chunk: [*c]const u8, arg_out_emissive_strength: [*c]cgltf_emissive_strength) callconv(.C) c_int { + var tokens = arg_tokens; + _ = &tokens; + var i = arg_i; + _ = &i; + var json_chunk = arg_json_chunk; + _ = &json_chunk; + var out_emissive_strength = arg_out_emissive_strength; + _ = &out_emissive_strength; + if ((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.type != @as(c_uint, @bitCast(JSMN_OBJECT))) { + return -@as(c_int, 1); + } + var size: c_int = (blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.size; + _ = &size; + i += 1; + out_emissive_strength.*.emissive_strength = 1.0; + { + var j: c_int = 0; + _ = &j; + while (j < size) : (j += 1) { + if (((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.type != @as(c_uint, @bitCast(JSMN_STRING))) or ((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.size == @as(c_int, 0))) { + return -@as(c_int, 1); + } + if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "emissiveStrength") == @as(c_int, 0)) { + i += 1; + out_emissive_strength.*.emissive_strength = cgltf_json_to_float(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk); + i += 1; + } else { + i = cgltf_skip_json(tokens, i + @as(c_int, 1)); + } + if (i < @as(c_int, 0)) { + return i; + } + } + } + return i; +} +pub fn cgltf_parse_json_iridescence(arg_options: [*c]cgltf_options, arg_tokens: [*c]const jsmntok_t, arg_i: c_int, arg_json_chunk: [*c]const u8, arg_out_iridescence: [*c]cgltf_iridescence) callconv(.C) c_int { + var options = arg_options; + _ = &options; + var tokens = arg_tokens; + _ = &tokens; + var i = arg_i; + _ = &i; + var json_chunk = arg_json_chunk; + _ = &json_chunk; + var out_iridescence = arg_out_iridescence; + _ = &out_iridescence; + if ((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.type != @as(c_uint, @bitCast(JSMN_OBJECT))) { + return -@as(c_int, 1); + } + var size: c_int = (blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.size; + _ = &size; + i += 1; + out_iridescence.*.iridescence_ior = 1.2999999523162842; + out_iridescence.*.iridescence_thickness_min = 100.0; + out_iridescence.*.iridescence_thickness_max = 400.0; + { + var j: c_int = 0; + _ = &j; + while (j < size) : (j += 1) { + if (((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.type != @as(c_uint, @bitCast(JSMN_STRING))) or ((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.size == @as(c_int, 0))) { + return -@as(c_int, 1); + } + if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "iridescenceFactor") == @as(c_int, 0)) { + i += 1; + out_iridescence.*.iridescence_factor = cgltf_json_to_float(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk); + i += 1; + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "iridescenceTexture") == @as(c_int, 0)) { + i = cgltf_parse_json_texture_view(options, tokens, i + @as(c_int, 1), json_chunk, &out_iridescence.*.iridescence_texture); + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "iridescenceIor") == @as(c_int, 0)) { + i += 1; + out_iridescence.*.iridescence_ior = cgltf_json_to_float(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk); + i += 1; + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "iridescenceThicknessMinimum") == @as(c_int, 0)) { + i += 1; + out_iridescence.*.iridescence_thickness_min = cgltf_json_to_float(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk); + i += 1; + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "iridescenceThicknessMaximum") == @as(c_int, 0)) { + i += 1; + out_iridescence.*.iridescence_thickness_max = cgltf_json_to_float(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk); + i += 1; + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "iridescenceThicknessTexture") == @as(c_int, 0)) { + i = cgltf_parse_json_texture_view(options, tokens, i + @as(c_int, 1), json_chunk, &out_iridescence.*.iridescence_thickness_texture); + } else { + i = cgltf_skip_json(tokens, i + @as(c_int, 1)); + } + if (i < @as(c_int, 0)) { + return i; + } + } + } + return i; +} +pub fn cgltf_parse_json_anisotropy(arg_options: [*c]cgltf_options, arg_tokens: [*c]const jsmntok_t, arg_i: c_int, arg_json_chunk: [*c]const u8, arg_out_anisotropy: [*c]cgltf_anisotropy) callconv(.C) c_int { + var options = arg_options; + _ = &options; + var tokens = arg_tokens; + _ = &tokens; + var i = arg_i; + _ = &i; + var json_chunk = arg_json_chunk; + _ = &json_chunk; + var out_anisotropy = arg_out_anisotropy; + _ = &out_anisotropy; + if ((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.type != @as(c_uint, @bitCast(JSMN_OBJECT))) { + return -@as(c_int, 1); + } + var size: c_int = (blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.size; + _ = &size; + i += 1; + { + var j: c_int = 0; + _ = &j; + while (j < size) : (j += 1) { + if (((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.type != @as(c_uint, @bitCast(JSMN_STRING))) or ((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.size == @as(c_int, 0))) { + return -@as(c_int, 1); + } + if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "anisotropyStrength") == @as(c_int, 0)) { + i += 1; + out_anisotropy.*.anisotropy_strength = cgltf_json_to_float(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk); + i += 1; + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "anisotropyRotation") == @as(c_int, 0)) { + i += 1; + out_anisotropy.*.anisotropy_rotation = cgltf_json_to_float(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk); + i += 1; + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "anisotropyTexture") == @as(c_int, 0)) { + i = cgltf_parse_json_texture_view(options, tokens, i + @as(c_int, 1), json_chunk, &out_anisotropy.*.anisotropy_texture); + } else { + i = cgltf_skip_json(tokens, i + @as(c_int, 1)); + } + if (i < @as(c_int, 0)) { + return i; + } + } + } + return i; +} +pub fn cgltf_parse_json_dispersion(arg_tokens: [*c]const jsmntok_t, arg_i: c_int, arg_json_chunk: [*c]const u8, arg_out_dispersion: [*c]cgltf_dispersion) callconv(.C) c_int { + var tokens = arg_tokens; + _ = &tokens; + var i = arg_i; + _ = &i; + var json_chunk = arg_json_chunk; + _ = &json_chunk; + var out_dispersion = arg_out_dispersion; + _ = &out_dispersion; + if ((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.type != @as(c_uint, @bitCast(JSMN_OBJECT))) { + return -@as(c_int, 1); + } + var size: c_int = (blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.size; + _ = &size; + i += 1; + { + var j: c_int = 0; + _ = &j; + while (j < size) : (j += 1) { + if (((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.type != @as(c_uint, @bitCast(JSMN_STRING))) or ((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.size == @as(c_int, 0))) { + return -@as(c_int, 1); + } + if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "dispersion") == @as(c_int, 0)) { + i += 1; + out_dispersion.*.dispersion = cgltf_json_to_float(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk); + i += 1; + } else { + i = cgltf_skip_json(tokens, i + @as(c_int, 1)); + } + if (i < @as(c_int, 0)) { + return i; + } + } + } + return i; +} +pub fn cgltf_parse_json_image(arg_options: [*c]cgltf_options, arg_tokens: [*c]const jsmntok_t, arg_i: c_int, arg_json_chunk: [*c]const u8, arg_out_image: [*c]cgltf_image) callconv(.C) c_int { + var options = arg_options; + _ = &options; + var tokens = arg_tokens; + _ = &tokens; + var i = arg_i; + _ = &i; + var json_chunk = arg_json_chunk; + _ = &json_chunk; + var out_image = arg_out_image; + _ = &out_image; + if ((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.type != @as(c_uint, @bitCast(JSMN_OBJECT))) { + return -@as(c_int, 1); + } + var size: c_int = (blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.size; + _ = &size; + i += 1; + { + var j: c_int = 0; + _ = &j; + while (j < size) : (j += 1) { + if (((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.type != @as(c_uint, @bitCast(JSMN_STRING))) or ((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.size == @as(c_int, 0))) { + return -@as(c_int, 1); + } + if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "uri") == @as(c_int, 0)) { + i = cgltf_parse_json_string(options, tokens, i + @as(c_int, 1), json_chunk, &out_image.*.uri); + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "bufferView") == @as(c_int, 0)) { + i += 1; + out_image.*.buffer_view = @as([*c]cgltf_buffer_view, @ptrFromInt(@as(cgltf_size, @bitCast(@as(c_long, cgltf_json_to_int(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk)))) +% @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 1)))))); + i += 1; + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "mimeType") == @as(c_int, 0)) { + i = cgltf_parse_json_string(options, tokens, i + @as(c_int, 1), json_chunk, &out_image.*.mime_type); + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "name") == @as(c_int, 0)) { + i = cgltf_parse_json_string(options, tokens, i + @as(c_int, 1), json_chunk, &out_image.*.name); + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "extras") == @as(c_int, 0)) { + i = cgltf_parse_json_extras(options, tokens, i + @as(c_int, 1), json_chunk, &out_image.*.extras); + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "extensions") == @as(c_int, 0)) { + i = cgltf_parse_json_unprocessed_extensions(options, tokens, i, json_chunk, &out_image.*.extensions_count, &out_image.*.extensions); + } else { + i = cgltf_skip_json(tokens, i + @as(c_int, 1)); + } + if (i < @as(c_int, 0)) { + return i; + } + } + } + return i; +} +pub fn cgltf_parse_json_sampler(arg_options: [*c]cgltf_options, arg_tokens: [*c]const jsmntok_t, arg_i: c_int, arg_json_chunk: [*c]const u8, arg_out_sampler: [*c]cgltf_sampler) callconv(.C) c_int { + var options = arg_options; + _ = &options; + var tokens = arg_tokens; + _ = &tokens; + var i = arg_i; + _ = &i; + var json_chunk = arg_json_chunk; + _ = &json_chunk; + var out_sampler = arg_out_sampler; + _ = &out_sampler; + _ = &options; + if ((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.type != @as(c_uint, @bitCast(JSMN_OBJECT))) { + return -@as(c_int, 1); + } + out_sampler.*.wrap_s = 10497; + out_sampler.*.wrap_t = 10497; + var size: c_int = (blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.size; + _ = &size; + i += 1; + { + var j: c_int = 0; + _ = &j; + while (j < size) : (j += 1) { + if (((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.type != @as(c_uint, @bitCast(JSMN_STRING))) or ((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.size == @as(c_int, 0))) { + return -@as(c_int, 1); + } + if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "name") == @as(c_int, 0)) { + i = cgltf_parse_json_string(options, tokens, i + @as(c_int, 1), json_chunk, &out_sampler.*.name); + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "magFilter") == @as(c_int, 0)) { + i += 1; + out_sampler.*.mag_filter = cgltf_json_to_int(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk); + i += 1; + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "minFilter") == @as(c_int, 0)) { + i += 1; + out_sampler.*.min_filter = cgltf_json_to_int(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk); + i += 1; + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "wrapS") == @as(c_int, 0)) { + i += 1; + out_sampler.*.wrap_s = cgltf_json_to_int(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk); + i += 1; + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "wrapT") == @as(c_int, 0)) { + i += 1; + out_sampler.*.wrap_t = cgltf_json_to_int(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk); + i += 1; + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "extras") == @as(c_int, 0)) { + i = cgltf_parse_json_extras(options, tokens, i + @as(c_int, 1), json_chunk, &out_sampler.*.extras); + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "extensions") == @as(c_int, 0)) { + i = cgltf_parse_json_unprocessed_extensions(options, tokens, i, json_chunk, &out_sampler.*.extensions_count, &out_sampler.*.extensions); + } else { + i = cgltf_skip_json(tokens, i + @as(c_int, 1)); + } + if (i < @as(c_int, 0)) { + return i; + } + } + } + return i; +} +pub fn cgltf_parse_json_texture(arg_options: [*c]cgltf_options, arg_tokens: [*c]const jsmntok_t, arg_i: c_int, arg_json_chunk: [*c]const u8, arg_out_texture: [*c]cgltf_texture) callconv(.C) c_int { + var options = arg_options; + _ = &options; + var tokens = arg_tokens; + _ = &tokens; + var i = arg_i; + _ = &i; + var json_chunk = arg_json_chunk; + _ = &json_chunk; + var out_texture = arg_out_texture; + _ = &out_texture; + if ((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.type != @as(c_uint, @bitCast(JSMN_OBJECT))) { + return -@as(c_int, 1); + } + var size: c_int = (blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.size; + _ = &size; + i += 1; + { + var j: c_int = 0; + _ = &j; + while (j < size) : (j += 1) { + if (((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.type != @as(c_uint, @bitCast(JSMN_STRING))) or ((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.size == @as(c_int, 0))) { + return -@as(c_int, 1); + } + if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "name") == @as(c_int, 0)) { + i = cgltf_parse_json_string(options, tokens, i + @as(c_int, 1), json_chunk, &out_texture.*.name); + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "sampler") == @as(c_int, 0)) { + i += 1; + out_texture.*.sampler = @as([*c]cgltf_sampler, @ptrFromInt(@as(cgltf_size, @bitCast(@as(c_long, cgltf_json_to_int(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk)))) +% @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 1)))))); + i += 1; + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "source") == @as(c_int, 0)) { + i += 1; + out_texture.*.image = @as([*c]cgltf_image, @ptrFromInt(@as(cgltf_size, @bitCast(@as(c_long, cgltf_json_to_int(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk)))) +% @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 1)))))); + i += 1; + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "extras") == @as(c_int, 0)) { + i = cgltf_parse_json_extras(options, tokens, i + @as(c_int, 1), json_chunk, &out_texture.*.extras); + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "extensions") == @as(c_int, 0)) { + i += 1; + if ((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.type != @as(c_uint, @bitCast(JSMN_OBJECT))) { + return -@as(c_int, 1); + } + if (out_texture.*.extensions != null) { + return -@as(c_int, 1); + } + var extensions_size: c_int = (blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.size; + _ = &extensions_size; + i += 1; + out_texture.*.extensions = @as([*c]cgltf_extension, @ptrCast(@alignCast(cgltf_calloc(options, @sizeOf(cgltf_extension), @as(cgltf_size, @bitCast(@as(c_long, extensions_size))))))); + out_texture.*.extensions_count = 0; + if (!(out_texture.*.extensions != null)) { + return -@as(c_int, 2); + } + { + var k: c_int = 0; + _ = &k; + while (k < extensions_size) : (k += 1) { + if (((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.type != @as(c_uint, @bitCast(JSMN_STRING))) or ((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.size == @as(c_int, 0))) { + return -@as(c_int, 1); + } + if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "KHR_texture_basisu") == @as(c_int, 0)) { + out_texture.*.has_basisu = 1; + i += 1; + if ((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.type != @as(c_uint, @bitCast(JSMN_OBJECT))) { + return -@as(c_int, 1); + } + var num_properties: c_int = (blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.size; + _ = &num_properties; + i += 1; + { + var t: c_int = 0; + _ = &t; + while (t < num_properties) : (t += 1) { + if (((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.type != @as(c_uint, @bitCast(JSMN_STRING))) or ((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.size == @as(c_int, 0))) { + return -@as(c_int, 1); + } + if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "source") == @as(c_int, 0)) { + i += 1; + out_texture.*.basisu_image = @as([*c]cgltf_image, @ptrFromInt(@as(cgltf_size, @bitCast(@as(c_long, cgltf_json_to_int(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk)))) +% @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 1)))))); + i += 1; + } else { + i = cgltf_skip_json(tokens, i + @as(c_int, 1)); + } + if (i < @as(c_int, 0)) { + return i; + } + } + } + } else { + i = cgltf_parse_json_unprocessed_extension(options, tokens, i, json_chunk, &out_texture.*.extensions[blk: { + const ref = &out_texture.*.extensions_count; + const tmp = ref.*; + ref.* +%= 1; + break :blk tmp; + }]); + } + if (i < @as(c_int, 0)) { + return i; + } + } + } + } else { + i = cgltf_skip_json(tokens, i + @as(c_int, 1)); + } + if (i < @as(c_int, 0)) { + return i; + } + } + } + return i; +} +pub fn cgltf_parse_json_material(arg_options: [*c]cgltf_options, arg_tokens: [*c]const jsmntok_t, arg_i: c_int, arg_json_chunk: [*c]const u8, arg_out_material: [*c]cgltf_material) callconv(.C) c_int { + var options = arg_options; + _ = &options; + var tokens = arg_tokens; + _ = &tokens; + var i = arg_i; + _ = &i; + var json_chunk = arg_json_chunk; + _ = &json_chunk; + var out_material = arg_out_material; + _ = &out_material; + if ((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.type != @as(c_uint, @bitCast(JSMN_OBJECT))) { + return -@as(c_int, 1); + } + cgltf_fill_float_array(@as([*c]cgltf_float, @ptrCast(@alignCast(&out_material.*.pbr_metallic_roughness.base_color_factor))), @as(c_int, 4), 1.0); + out_material.*.pbr_metallic_roughness.metallic_factor = 1.0; + out_material.*.pbr_metallic_roughness.roughness_factor = 1.0; + cgltf_fill_float_array(@as([*c]cgltf_float, @ptrCast(@alignCast(&out_material.*.pbr_specular_glossiness.diffuse_factor))), @as(c_int, 4), 1.0); + cgltf_fill_float_array(@as([*c]cgltf_float, @ptrCast(@alignCast(&out_material.*.pbr_specular_glossiness.specular_factor))), @as(c_int, 3), 1.0); + out_material.*.pbr_specular_glossiness.glossiness_factor = 1.0; + cgltf_fill_float_array(@as([*c]cgltf_float, @ptrCast(@alignCast(&out_material.*.volume.attenuation_color))), @as(c_int, 3), 1.0); + out_material.*.volume.attenuation_distance = 340282346638528860000000000000000000000.0; + out_material.*.alpha_cutoff = 0.5; + var size: c_int = (blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.size; + _ = &size; + i += 1; + { + var j: c_int = 0; + _ = &j; + while (j < size) : (j += 1) { + if (((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.type != @as(c_uint, @bitCast(JSMN_STRING))) or ((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.size == @as(c_int, 0))) { + return -@as(c_int, 1); + } + if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "name") == @as(c_int, 0)) { + i = cgltf_parse_json_string(options, tokens, i + @as(c_int, 1), json_chunk, &out_material.*.name); + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "pbrMetallicRoughness") == @as(c_int, 0)) { + out_material.*.has_pbr_metallic_roughness = 1; + i = cgltf_parse_json_pbr_metallic_roughness(options, tokens, i + @as(c_int, 1), json_chunk, &out_material.*.pbr_metallic_roughness); + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "emissiveFactor") == @as(c_int, 0)) { + i = cgltf_parse_json_float_array(tokens, i + @as(c_int, 1), json_chunk, @as([*c]cgltf_float, @ptrCast(@alignCast(&out_material.*.emissive_factor))), @as(c_int, 3)); + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "normalTexture") == @as(c_int, 0)) { + i = cgltf_parse_json_texture_view(options, tokens, i + @as(c_int, 1), json_chunk, &out_material.*.normal_texture); + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "occlusionTexture") == @as(c_int, 0)) { + i = cgltf_parse_json_texture_view(options, tokens, i + @as(c_int, 1), json_chunk, &out_material.*.occlusion_texture); + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "emissiveTexture") == @as(c_int, 0)) { + i = cgltf_parse_json_texture_view(options, tokens, i + @as(c_int, 1), json_chunk, &out_material.*.emissive_texture); + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "alphaMode") == @as(c_int, 0)) { + i += 1; + if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "OPAQUE") == @as(c_int, 0)) { + out_material.*.alpha_mode = @as(c_uint, @bitCast(cgltf_alpha_mode_opaque)); + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "MASK") == @as(c_int, 0)) { + out_material.*.alpha_mode = @as(c_uint, @bitCast(cgltf_alpha_mode_mask)); + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "BLEND") == @as(c_int, 0)) { + out_material.*.alpha_mode = @as(c_uint, @bitCast(cgltf_alpha_mode_blend)); + } + i += 1; + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "alphaCutoff") == @as(c_int, 0)) { + i += 1; + out_material.*.alpha_cutoff = cgltf_json_to_float(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk); + i += 1; + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "doubleSided") == @as(c_int, 0)) { + i += 1; + out_material.*.double_sided = cgltf_json_to_bool(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk); + i += 1; + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "extras") == @as(c_int, 0)) { + i = cgltf_parse_json_extras(options, tokens, i + @as(c_int, 1), json_chunk, &out_material.*.extras); + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "extensions") == @as(c_int, 0)) { + i += 1; + if ((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.type != @as(c_uint, @bitCast(JSMN_OBJECT))) { + return -@as(c_int, 1); + } + if (out_material.*.extensions != null) { + return -@as(c_int, 1); + } + var extensions_size: c_int = (blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.size; + _ = &extensions_size; + i += 1; + out_material.*.extensions = @as([*c]cgltf_extension, @ptrCast(@alignCast(cgltf_calloc(options, @sizeOf(cgltf_extension), @as(cgltf_size, @bitCast(@as(c_long, extensions_size))))))); + out_material.*.extensions_count = 0; + if (!(out_material.*.extensions != null)) { + return -@as(c_int, 2); + } + { + var k: c_int = 0; + _ = &k; + while (k < extensions_size) : (k += 1) { + if (((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.type != @as(c_uint, @bitCast(JSMN_STRING))) or ((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.size == @as(c_int, 0))) { + return -@as(c_int, 1); + } + if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "KHR_materials_pbrSpecularGlossiness") == @as(c_int, 0)) { + out_material.*.has_pbr_specular_glossiness = 1; + i = cgltf_parse_json_pbr_specular_glossiness(options, tokens, i + @as(c_int, 1), json_chunk, &out_material.*.pbr_specular_glossiness); + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "KHR_materials_unlit") == @as(c_int, 0)) { + out_material.*.unlit = 1; + i = cgltf_skip_json(tokens, i + @as(c_int, 1)); + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "KHR_materials_clearcoat") == @as(c_int, 0)) { + out_material.*.has_clearcoat = 1; + i = cgltf_parse_json_clearcoat(options, tokens, i + @as(c_int, 1), json_chunk, &out_material.*.clearcoat); + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "KHR_materials_ior") == @as(c_int, 0)) { + out_material.*.has_ior = 1; + i = cgltf_parse_json_ior(tokens, i + @as(c_int, 1), json_chunk, &out_material.*.ior); + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "KHR_materials_specular") == @as(c_int, 0)) { + out_material.*.has_specular = 1; + i = cgltf_parse_json_specular(options, tokens, i + @as(c_int, 1), json_chunk, &out_material.*.specular); + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "KHR_materials_transmission") == @as(c_int, 0)) { + out_material.*.has_transmission = 1; + i = cgltf_parse_json_transmission(options, tokens, i + @as(c_int, 1), json_chunk, &out_material.*.transmission); + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "KHR_materials_volume") == @as(c_int, 0)) { + out_material.*.has_volume = 1; + i = cgltf_parse_json_volume(options, tokens, i + @as(c_int, 1), json_chunk, &out_material.*.volume); + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "KHR_materials_sheen") == @as(c_int, 0)) { + out_material.*.has_sheen = 1; + i = cgltf_parse_json_sheen(options, tokens, i + @as(c_int, 1), json_chunk, &out_material.*.sheen); + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "KHR_materials_emissive_strength") == @as(c_int, 0)) { + out_material.*.has_emissive_strength = 1; + i = cgltf_parse_json_emissive_strength(tokens, i + @as(c_int, 1), json_chunk, &out_material.*.emissive_strength); + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "KHR_materials_iridescence") == @as(c_int, 0)) { + out_material.*.has_iridescence = 1; + i = cgltf_parse_json_iridescence(options, tokens, i + @as(c_int, 1), json_chunk, &out_material.*.iridescence); + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "KHR_materials_anisotropy") == @as(c_int, 0)) { + out_material.*.has_anisotropy = 1; + i = cgltf_parse_json_anisotropy(options, tokens, i + @as(c_int, 1), json_chunk, &out_material.*.anisotropy); + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "KHR_materials_dispersion") == @as(c_int, 0)) { + out_material.*.has_dispersion = 1; + i = cgltf_parse_json_dispersion(tokens, i + @as(c_int, 1), json_chunk, &out_material.*.dispersion); + } else { + i = cgltf_parse_json_unprocessed_extension(options, tokens, i, json_chunk, &out_material.*.extensions[blk: { + const ref = &out_material.*.extensions_count; + const tmp = ref.*; + ref.* +%= 1; + break :blk tmp; + }]); + } + if (i < @as(c_int, 0)) { + return i; + } + } + } + } else { + i = cgltf_skip_json(tokens, i + @as(c_int, 1)); + } + if (i < @as(c_int, 0)) { + return i; + } + } + } + return i; +} +pub fn cgltf_parse_json_accessors(arg_options: [*c]cgltf_options, arg_tokens: [*c]const jsmntok_t, arg_i: c_int, arg_json_chunk: [*c]const u8, arg_out_data: [*c]cgltf_data) callconv(.C) c_int { + var options = arg_options; + _ = &options; + var tokens = arg_tokens; + _ = &tokens; + var i = arg_i; + _ = &i; + var json_chunk = arg_json_chunk; + _ = &json_chunk; + var out_data = arg_out_data; + _ = &out_data; + i = cgltf_parse_json_array(options, tokens, i, json_chunk, @sizeOf(cgltf_accessor), @as([*c]?*anyopaque, @ptrCast(@alignCast(&out_data.*.accessors))), &out_data.*.accessors_count); + if (i < @as(c_int, 0)) { + return i; + } + { + var j: cgltf_size = 0; + _ = &j; + while (j < out_data.*.accessors_count) : (j +%= 1) { + i = cgltf_parse_json_accessor(options, tokens, i, json_chunk, &out_data.*.accessors[j]); + if (i < @as(c_int, 0)) { + return i; + } + } + } + return i; +} +pub fn cgltf_parse_json_materials(arg_options: [*c]cgltf_options, arg_tokens: [*c]const jsmntok_t, arg_i: c_int, arg_json_chunk: [*c]const u8, arg_out_data: [*c]cgltf_data) callconv(.C) c_int { + var options = arg_options; + _ = &options; + var tokens = arg_tokens; + _ = &tokens; + var i = arg_i; + _ = &i; + var json_chunk = arg_json_chunk; + _ = &json_chunk; + var out_data = arg_out_data; + _ = &out_data; + i = cgltf_parse_json_array(options, tokens, i, json_chunk, @sizeOf(cgltf_material), @as([*c]?*anyopaque, @ptrCast(@alignCast(&out_data.*.materials))), &out_data.*.materials_count); + if (i < @as(c_int, 0)) { + return i; + } + { + var j: cgltf_size = 0; + _ = &j; + while (j < out_data.*.materials_count) : (j +%= 1) { + i = cgltf_parse_json_material(options, tokens, i, json_chunk, &out_data.*.materials[j]); + if (i < @as(c_int, 0)) { + return i; + } + } + } + return i; +} +pub fn cgltf_parse_json_images(arg_options: [*c]cgltf_options, arg_tokens: [*c]const jsmntok_t, arg_i: c_int, arg_json_chunk: [*c]const u8, arg_out_data: [*c]cgltf_data) callconv(.C) c_int { + var options = arg_options; + _ = &options; + var tokens = arg_tokens; + _ = &tokens; + var i = arg_i; + _ = &i; + var json_chunk = arg_json_chunk; + _ = &json_chunk; + var out_data = arg_out_data; + _ = &out_data; + i = cgltf_parse_json_array(options, tokens, i, json_chunk, @sizeOf(cgltf_image), @as([*c]?*anyopaque, @ptrCast(@alignCast(&out_data.*.images))), &out_data.*.images_count); + if (i < @as(c_int, 0)) { + return i; + } + { + var j: cgltf_size = 0; + _ = &j; + while (j < out_data.*.images_count) : (j +%= 1) { + i = cgltf_parse_json_image(options, tokens, i, json_chunk, &out_data.*.images[j]); + if (i < @as(c_int, 0)) { + return i; + } + } + } + return i; +} +pub fn cgltf_parse_json_textures(arg_options: [*c]cgltf_options, arg_tokens: [*c]const jsmntok_t, arg_i: c_int, arg_json_chunk: [*c]const u8, arg_out_data: [*c]cgltf_data) callconv(.C) c_int { + var options = arg_options; + _ = &options; + var tokens = arg_tokens; + _ = &tokens; + var i = arg_i; + _ = &i; + var json_chunk = arg_json_chunk; + _ = &json_chunk; + var out_data = arg_out_data; + _ = &out_data; + i = cgltf_parse_json_array(options, tokens, i, json_chunk, @sizeOf(cgltf_texture), @as([*c]?*anyopaque, @ptrCast(@alignCast(&out_data.*.textures))), &out_data.*.textures_count); + if (i < @as(c_int, 0)) { + return i; + } + { + var j: cgltf_size = 0; + _ = &j; + while (j < out_data.*.textures_count) : (j +%= 1) { + i = cgltf_parse_json_texture(options, tokens, i, json_chunk, &out_data.*.textures[j]); + if (i < @as(c_int, 0)) { + return i; + } + } + } + return i; +} +pub fn cgltf_parse_json_samplers(arg_options: [*c]cgltf_options, arg_tokens: [*c]const jsmntok_t, arg_i: c_int, arg_json_chunk: [*c]const u8, arg_out_data: [*c]cgltf_data) callconv(.C) c_int { + var options = arg_options; + _ = &options; + var tokens = arg_tokens; + _ = &tokens; + var i = arg_i; + _ = &i; + var json_chunk = arg_json_chunk; + _ = &json_chunk; + var out_data = arg_out_data; + _ = &out_data; + i = cgltf_parse_json_array(options, tokens, i, json_chunk, @sizeOf(cgltf_sampler), @as([*c]?*anyopaque, @ptrCast(@alignCast(&out_data.*.samplers))), &out_data.*.samplers_count); + if (i < @as(c_int, 0)) { + return i; + } + { + var j: cgltf_size = 0; + _ = &j; + while (j < out_data.*.samplers_count) : (j +%= 1) { + i = cgltf_parse_json_sampler(options, tokens, i, json_chunk, &out_data.*.samplers[j]); + if (i < @as(c_int, 0)) { + return i; + } + } + } + return i; +} +pub fn cgltf_parse_json_meshopt_compression(arg_options: [*c]cgltf_options, arg_tokens: [*c]const jsmntok_t, arg_i: c_int, arg_json_chunk: [*c]const u8, arg_out_meshopt_compression: [*c]cgltf_meshopt_compression) callconv(.C) c_int { + var options = arg_options; + _ = &options; + var tokens = arg_tokens; + _ = &tokens; + var i = arg_i; + _ = &i; + var json_chunk = arg_json_chunk; + _ = &json_chunk; + var out_meshopt_compression = arg_out_meshopt_compression; + _ = &out_meshopt_compression; + _ = &options; + if ((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.type != @as(c_uint, @bitCast(JSMN_OBJECT))) { + return -@as(c_int, 1); + } + var size: c_int = (blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.size; + _ = &size; + i += 1; + { + var j: c_int = 0; + _ = &j; + while (j < size) : (j += 1) { + if (((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.type != @as(c_uint, @bitCast(JSMN_STRING))) or ((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.size == @as(c_int, 0))) { + return -@as(c_int, 1); + } + if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "buffer") == @as(c_int, 0)) { + i += 1; + out_meshopt_compression.*.buffer = @as([*c]cgltf_buffer, @ptrFromInt(@as(cgltf_size, @bitCast(@as(c_long, cgltf_json_to_int(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk)))) +% @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 1)))))); + i += 1; + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "byteOffset") == @as(c_int, 0)) { + i += 1; + out_meshopt_compression.*.offset = cgltf_json_to_size(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk); + i += 1; + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "byteLength") == @as(c_int, 0)) { + i += 1; + out_meshopt_compression.*.size = cgltf_json_to_size(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk); + i += 1; + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "byteStride") == @as(c_int, 0)) { + i += 1; + out_meshopt_compression.*.stride = cgltf_json_to_size(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk); + i += 1; + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "count") == @as(c_int, 0)) { + i += 1; + out_meshopt_compression.*.count = cgltf_json_to_size(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk); + i += 1; + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "mode") == @as(c_int, 0)) { + i += 1; + if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "ATTRIBUTES") == @as(c_int, 0)) { + out_meshopt_compression.*.mode = @as(c_uint, @bitCast(cgltf_meshopt_compression_mode_attributes)); + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "TRIANGLES") == @as(c_int, 0)) { + out_meshopt_compression.*.mode = @as(c_uint, @bitCast(cgltf_meshopt_compression_mode_triangles)); + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "INDICES") == @as(c_int, 0)) { + out_meshopt_compression.*.mode = @as(c_uint, @bitCast(cgltf_meshopt_compression_mode_indices)); + } + i += 1; + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "filter") == @as(c_int, 0)) { + i += 1; + if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "NONE") == @as(c_int, 0)) { + out_meshopt_compression.*.filter = @as(c_uint, @bitCast(cgltf_meshopt_compression_filter_none)); + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "OCTAHEDRAL") == @as(c_int, 0)) { + out_meshopt_compression.*.filter = @as(c_uint, @bitCast(cgltf_meshopt_compression_filter_octahedral)); + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "QUATERNION") == @as(c_int, 0)) { + out_meshopt_compression.*.filter = @as(c_uint, @bitCast(cgltf_meshopt_compression_filter_quaternion)); + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "EXPONENTIAL") == @as(c_int, 0)) { + out_meshopt_compression.*.filter = @as(c_uint, @bitCast(cgltf_meshopt_compression_filter_exponential)); + } + i += 1; + } else { + i = cgltf_skip_json(tokens, i + @as(c_int, 1)); + } + if (i < @as(c_int, 0)) { + return i; + } + } + } + return i; +} +pub fn cgltf_parse_json_buffer_view(arg_options: [*c]cgltf_options, arg_tokens: [*c]const jsmntok_t, arg_i: c_int, arg_json_chunk: [*c]const u8, arg_out_buffer_view: [*c]cgltf_buffer_view) callconv(.C) c_int { + var options = arg_options; + _ = &options; + var tokens = arg_tokens; + _ = &tokens; + var i = arg_i; + _ = &i; + var json_chunk = arg_json_chunk; + _ = &json_chunk; + var out_buffer_view = arg_out_buffer_view; + _ = &out_buffer_view; + if ((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.type != @as(c_uint, @bitCast(JSMN_OBJECT))) { + return -@as(c_int, 1); + } + var size: c_int = (blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.size; + _ = &size; + i += 1; + { + var j: c_int = 0; + _ = &j; + while (j < size) : (j += 1) { + if (((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.type != @as(c_uint, @bitCast(JSMN_STRING))) or ((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.size == @as(c_int, 0))) { + return -@as(c_int, 1); + } + if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "name") == @as(c_int, 0)) { + i = cgltf_parse_json_string(options, tokens, i + @as(c_int, 1), json_chunk, &out_buffer_view.*.name); + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "buffer") == @as(c_int, 0)) { + i += 1; + out_buffer_view.*.buffer = @as([*c]cgltf_buffer, @ptrFromInt(@as(cgltf_size, @bitCast(@as(c_long, cgltf_json_to_int(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk)))) +% @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 1)))))); + i += 1; + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "byteOffset") == @as(c_int, 0)) { + i += 1; + out_buffer_view.*.offset = cgltf_json_to_size(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk); + i += 1; + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "byteLength") == @as(c_int, 0)) { + i += 1; + out_buffer_view.*.size = cgltf_json_to_size(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk); + i += 1; + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "byteStride") == @as(c_int, 0)) { + i += 1; + out_buffer_view.*.stride = cgltf_json_to_size(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk); + i += 1; + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "target") == @as(c_int, 0)) { + i += 1; + var @"type": c_int = cgltf_json_to_int(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk); + _ = &@"type"; + while (true) { + switch (@"type") { + @as(c_int, 34962) => { + @"type" = cgltf_buffer_view_type_vertices; + break; + }, + @as(c_int, 34963) => { + @"type" = cgltf_buffer_view_type_indices; + break; + }, + else => { + @"type" = cgltf_buffer_view_type_invalid; + break; + }, + } + break; + } + out_buffer_view.*.type = @as(c_uint, @bitCast(@"type")); + i += 1; + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "extras") == @as(c_int, 0)) { + i = cgltf_parse_json_extras(options, tokens, i + @as(c_int, 1), json_chunk, &out_buffer_view.*.extras); + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "extensions") == @as(c_int, 0)) { + i += 1; + if ((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.type != @as(c_uint, @bitCast(JSMN_OBJECT))) { + return -@as(c_int, 1); + } + if (out_buffer_view.*.extensions != null) { + return -@as(c_int, 1); + } + var extensions_size: c_int = (blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.size; + _ = &extensions_size; + out_buffer_view.*.extensions_count = 0; + out_buffer_view.*.extensions = @as([*c]cgltf_extension, @ptrCast(@alignCast(cgltf_calloc(options, @sizeOf(cgltf_extension), @as(cgltf_size, @bitCast(@as(c_long, extensions_size))))))); + if (!(out_buffer_view.*.extensions != null)) { + return -@as(c_int, 2); + } + i += 1; + { + var k: c_int = 0; + _ = &k; + while (k < extensions_size) : (k += 1) { + if (((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.type != @as(c_uint, @bitCast(JSMN_STRING))) or ((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.size == @as(c_int, 0))) { + return -@as(c_int, 1); + } + if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "EXT_meshopt_compression") == @as(c_int, 0)) { + out_buffer_view.*.has_meshopt_compression = 1; + i = cgltf_parse_json_meshopt_compression(options, tokens, i + @as(c_int, 1), json_chunk, &out_buffer_view.*.meshopt_compression); + } else { + i = cgltf_parse_json_unprocessed_extension(options, tokens, i, json_chunk, &out_buffer_view.*.extensions[blk: { + const ref = &out_buffer_view.*.extensions_count; + const tmp = ref.*; + ref.* +%= 1; + break :blk tmp; + }]); + } + if (i < @as(c_int, 0)) { + return i; + } + } + } + } else { + i = cgltf_skip_json(tokens, i + @as(c_int, 1)); + } + if (i < @as(c_int, 0)) { + return i; + } + } + } + return i; +} +pub fn cgltf_parse_json_buffer_views(arg_options: [*c]cgltf_options, arg_tokens: [*c]const jsmntok_t, arg_i: c_int, arg_json_chunk: [*c]const u8, arg_out_data: [*c]cgltf_data) callconv(.C) c_int { + var options = arg_options; + _ = &options; + var tokens = arg_tokens; + _ = &tokens; + var i = arg_i; + _ = &i; + var json_chunk = arg_json_chunk; + _ = &json_chunk; + var out_data = arg_out_data; + _ = &out_data; + i = cgltf_parse_json_array(options, tokens, i, json_chunk, @sizeOf(cgltf_buffer_view), @as([*c]?*anyopaque, @ptrCast(@alignCast(&out_data.*.buffer_views))), &out_data.*.buffer_views_count); + if (i < @as(c_int, 0)) { + return i; + } + { + var j: cgltf_size = 0; + _ = &j; + while (j < out_data.*.buffer_views_count) : (j +%= 1) { + i = cgltf_parse_json_buffer_view(options, tokens, i, json_chunk, &out_data.*.buffer_views[j]); + if (i < @as(c_int, 0)) { + return i; + } + } + } + return i; +} +pub fn cgltf_parse_json_buffer(arg_options: [*c]cgltf_options, arg_tokens: [*c]const jsmntok_t, arg_i: c_int, arg_json_chunk: [*c]const u8, arg_out_buffer: [*c]cgltf_buffer) callconv(.C) c_int { + var options = arg_options; + _ = &options; + var tokens = arg_tokens; + _ = &tokens; + var i = arg_i; + _ = &i; + var json_chunk = arg_json_chunk; + _ = &json_chunk; + var out_buffer = arg_out_buffer; + _ = &out_buffer; + if ((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.type != @as(c_uint, @bitCast(JSMN_OBJECT))) { + return -@as(c_int, 1); + } + var size: c_int = (blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.size; + _ = &size; + i += 1; + { + var j: c_int = 0; + _ = &j; + while (j < size) : (j += 1) { + if (((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.type != @as(c_uint, @bitCast(JSMN_STRING))) or ((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.size == @as(c_int, 0))) { + return -@as(c_int, 1); + } + if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "name") == @as(c_int, 0)) { + i = cgltf_parse_json_string(options, tokens, i + @as(c_int, 1), json_chunk, &out_buffer.*.name); + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "byteLength") == @as(c_int, 0)) { + i += 1; + out_buffer.*.size = cgltf_json_to_size(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk); + i += 1; + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "uri") == @as(c_int, 0)) { + i = cgltf_parse_json_string(options, tokens, i + @as(c_int, 1), json_chunk, &out_buffer.*.uri); + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "extras") == @as(c_int, 0)) { + i = cgltf_parse_json_extras(options, tokens, i + @as(c_int, 1), json_chunk, &out_buffer.*.extras); + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "extensions") == @as(c_int, 0)) { + i = cgltf_parse_json_unprocessed_extensions(options, tokens, i, json_chunk, &out_buffer.*.extensions_count, &out_buffer.*.extensions); + } else { + i = cgltf_skip_json(tokens, i + @as(c_int, 1)); + } + if (i < @as(c_int, 0)) { + return i; + } + } + } + return i; +} +pub fn cgltf_parse_json_buffers(arg_options: [*c]cgltf_options, arg_tokens: [*c]const jsmntok_t, arg_i: c_int, arg_json_chunk: [*c]const u8, arg_out_data: [*c]cgltf_data) callconv(.C) c_int { + var options = arg_options; + _ = &options; + var tokens = arg_tokens; + _ = &tokens; + var i = arg_i; + _ = &i; + var json_chunk = arg_json_chunk; + _ = &json_chunk; + var out_data = arg_out_data; + _ = &out_data; + i = cgltf_parse_json_array(options, tokens, i, json_chunk, @sizeOf(cgltf_buffer), @as([*c]?*anyopaque, @ptrCast(@alignCast(&out_data.*.buffers))), &out_data.*.buffers_count); + if (i < @as(c_int, 0)) { + return i; + } + { + var j: cgltf_size = 0; + _ = &j; + while (j < out_data.*.buffers_count) : (j +%= 1) { + i = cgltf_parse_json_buffer(options, tokens, i, json_chunk, &out_data.*.buffers[j]); + if (i < @as(c_int, 0)) { + return i; + } + } + } + return i; +} +pub fn cgltf_parse_json_skin(arg_options: [*c]cgltf_options, arg_tokens: [*c]const jsmntok_t, arg_i: c_int, arg_json_chunk: [*c]const u8, arg_out_skin: [*c]cgltf_skin) callconv(.C) c_int { + var options = arg_options; + _ = &options; + var tokens = arg_tokens; + _ = &tokens; + var i = arg_i; + _ = &i; + var json_chunk = arg_json_chunk; + _ = &json_chunk; + var out_skin = arg_out_skin; + _ = &out_skin; + if ((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.type != @as(c_uint, @bitCast(JSMN_OBJECT))) { + return -@as(c_int, 1); + } + var size: c_int = (blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.size; + _ = &size; + i += 1; + { + var j: c_int = 0; + _ = &j; + while (j < size) : (j += 1) { + if (((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.type != @as(c_uint, @bitCast(JSMN_STRING))) or ((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.size == @as(c_int, 0))) { + return -@as(c_int, 1); + } + if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "name") == @as(c_int, 0)) { + i = cgltf_parse_json_string(options, tokens, i + @as(c_int, 1), json_chunk, &out_skin.*.name); + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "joints") == @as(c_int, 0)) { + i = cgltf_parse_json_array(options, tokens, i + @as(c_int, 1), json_chunk, @sizeOf([*c]cgltf_node), @as([*c]?*anyopaque, @ptrCast(@alignCast(&out_skin.*.joints))), &out_skin.*.joints_count); + if (i < @as(c_int, 0)) { + return i; + } + { + var k: cgltf_size = 0; + _ = &k; + while (k < out_skin.*.joints_count) : (k +%= 1) { + out_skin.*.joints[k] = @as([*c]cgltf_node, @ptrFromInt(@as(cgltf_size, @bitCast(@as(c_long, cgltf_json_to_int(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk)))) +% @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 1)))))); + i += 1; + } + } + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "skeleton") == @as(c_int, 0)) { + i += 1; + if ((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.type != @as(c_uint, @bitCast(JSMN_PRIMITIVE))) { + return -@as(c_int, 1); + } + out_skin.*.skeleton = @as([*c]cgltf_node, @ptrFromInt(@as(cgltf_size, @bitCast(@as(c_long, cgltf_json_to_int(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk)))) +% @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 1)))))); + i += 1; + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "inverseBindMatrices") == @as(c_int, 0)) { + i += 1; + if ((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.type != @as(c_uint, @bitCast(JSMN_PRIMITIVE))) { + return -@as(c_int, 1); + } + out_skin.*.inverse_bind_matrices = @as([*c]cgltf_accessor, @ptrFromInt(@as(cgltf_size, @bitCast(@as(c_long, cgltf_json_to_int(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk)))) +% @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 1)))))); + i += 1; + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "extras") == @as(c_int, 0)) { + i = cgltf_parse_json_extras(options, tokens, i + @as(c_int, 1), json_chunk, &out_skin.*.extras); + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "extensions") == @as(c_int, 0)) { + i = cgltf_parse_json_unprocessed_extensions(options, tokens, i, json_chunk, &out_skin.*.extensions_count, &out_skin.*.extensions); + } else { + i = cgltf_skip_json(tokens, i + @as(c_int, 1)); + } + if (i < @as(c_int, 0)) { + return i; + } + } + } + return i; +} +pub fn cgltf_parse_json_skins(arg_options: [*c]cgltf_options, arg_tokens: [*c]const jsmntok_t, arg_i: c_int, arg_json_chunk: [*c]const u8, arg_out_data: [*c]cgltf_data) callconv(.C) c_int { + var options = arg_options; + _ = &options; + var tokens = arg_tokens; + _ = &tokens; + var i = arg_i; + _ = &i; + var json_chunk = arg_json_chunk; + _ = &json_chunk; + var out_data = arg_out_data; + _ = &out_data; + i = cgltf_parse_json_array(options, tokens, i, json_chunk, @sizeOf(cgltf_skin), @as([*c]?*anyopaque, @ptrCast(@alignCast(&out_data.*.skins))), &out_data.*.skins_count); + if (i < @as(c_int, 0)) { + return i; + } + { + var j: cgltf_size = 0; + _ = &j; + while (j < out_data.*.skins_count) : (j +%= 1) { + i = cgltf_parse_json_skin(options, tokens, i, json_chunk, &out_data.*.skins[j]); + if (i < @as(c_int, 0)) { + return i; + } + } + } + return i; +} +pub fn cgltf_parse_json_camera(arg_options: [*c]cgltf_options, arg_tokens: [*c]const jsmntok_t, arg_i: c_int, arg_json_chunk: [*c]const u8, arg_out_camera: [*c]cgltf_camera) callconv(.C) c_int { + var options = arg_options; + _ = &options; + var tokens = arg_tokens; + _ = &tokens; + var i = arg_i; + _ = &i; + var json_chunk = arg_json_chunk; + _ = &json_chunk; + var out_camera = arg_out_camera; + _ = &out_camera; + if ((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.type != @as(c_uint, @bitCast(JSMN_OBJECT))) { + return -@as(c_int, 1); + } + var size: c_int = (blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.size; + _ = &size; + i += 1; + { + var j: c_int = 0; + _ = &j; + while (j < size) : (j += 1) { + if (((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.type != @as(c_uint, @bitCast(JSMN_STRING))) or ((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.size == @as(c_int, 0))) { + return -@as(c_int, 1); + } + if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "name") == @as(c_int, 0)) { + i = cgltf_parse_json_string(options, tokens, i + @as(c_int, 1), json_chunk, &out_camera.*.name); + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "perspective") == @as(c_int, 0)) { + i += 1; + if ((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.type != @as(c_uint, @bitCast(JSMN_OBJECT))) { + return -@as(c_int, 1); + } + var data_size: c_int = (blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.size; + _ = &data_size; + i += 1; + if (out_camera.*.type != @as(c_uint, @bitCast(cgltf_camera_type_invalid))) { + return -@as(c_int, 1); + } + out_camera.*.type = @as(c_uint, @bitCast(cgltf_camera_type_perspective)); + { + var k: c_int = 0; + _ = &k; + while (k < data_size) : (k += 1) { + if (((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.type != @as(c_uint, @bitCast(JSMN_STRING))) or ((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.size == @as(c_int, 0))) { + return -@as(c_int, 1); + } + if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "aspectRatio") == @as(c_int, 0)) { + i += 1; + out_camera.*.data.perspective.has_aspect_ratio = 1; + out_camera.*.data.perspective.aspect_ratio = cgltf_json_to_float(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk); + i += 1; + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "yfov") == @as(c_int, 0)) { + i += 1; + out_camera.*.data.perspective.yfov = cgltf_json_to_float(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk); + i += 1; + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "zfar") == @as(c_int, 0)) { + i += 1; + out_camera.*.data.perspective.has_zfar = 1; + out_camera.*.data.perspective.zfar = cgltf_json_to_float(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk); + i += 1; + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "znear") == @as(c_int, 0)) { + i += 1; + out_camera.*.data.perspective.znear = cgltf_json_to_float(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk); + i += 1; + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "extras") == @as(c_int, 0)) { + i = cgltf_parse_json_extras(options, tokens, i + @as(c_int, 1), json_chunk, &out_camera.*.data.perspective.extras); + } else { + i = cgltf_skip_json(tokens, i + @as(c_int, 1)); + } + if (i < @as(c_int, 0)) { + return i; + } + } + } + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "orthographic") == @as(c_int, 0)) { + i += 1; + if ((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.type != @as(c_uint, @bitCast(JSMN_OBJECT))) { + return -@as(c_int, 1); + } + var data_size: c_int = (blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.size; + _ = &data_size; + i += 1; + if (out_camera.*.type != @as(c_uint, @bitCast(cgltf_camera_type_invalid))) { + return -@as(c_int, 1); + } + out_camera.*.type = @as(c_uint, @bitCast(cgltf_camera_type_orthographic)); + { + var k: c_int = 0; + _ = &k; + while (k < data_size) : (k += 1) { + if (((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.type != @as(c_uint, @bitCast(JSMN_STRING))) or ((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.size == @as(c_int, 0))) { + return -@as(c_int, 1); + } + if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "xmag") == @as(c_int, 0)) { + i += 1; + out_camera.*.data.orthographic.xmag = cgltf_json_to_float(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk); + i += 1; + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "ymag") == @as(c_int, 0)) { + i += 1; + out_camera.*.data.orthographic.ymag = cgltf_json_to_float(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk); + i += 1; + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "zfar") == @as(c_int, 0)) { + i += 1; + out_camera.*.data.orthographic.zfar = cgltf_json_to_float(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk); + i += 1; + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "znear") == @as(c_int, 0)) { + i += 1; + out_camera.*.data.orthographic.znear = cgltf_json_to_float(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk); + i += 1; + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "extras") == @as(c_int, 0)) { + i = cgltf_parse_json_extras(options, tokens, i + @as(c_int, 1), json_chunk, &out_camera.*.data.orthographic.extras); + } else { + i = cgltf_skip_json(tokens, i + @as(c_int, 1)); + } + if (i < @as(c_int, 0)) { + return i; + } + } + } + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "extras") == @as(c_int, 0)) { + i = cgltf_parse_json_extras(options, tokens, i + @as(c_int, 1), json_chunk, &out_camera.*.extras); + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "extensions") == @as(c_int, 0)) { + i = cgltf_parse_json_unprocessed_extensions(options, tokens, i, json_chunk, &out_camera.*.extensions_count, &out_camera.*.extensions); + } else { + i = cgltf_skip_json(tokens, i + @as(c_int, 1)); + } + if (i < @as(c_int, 0)) { + return i; + } + } + } + return i; +} +pub fn cgltf_parse_json_cameras(arg_options: [*c]cgltf_options, arg_tokens: [*c]const jsmntok_t, arg_i: c_int, arg_json_chunk: [*c]const u8, arg_out_data: [*c]cgltf_data) callconv(.C) c_int { + var options = arg_options; + _ = &options; + var tokens = arg_tokens; + _ = &tokens; + var i = arg_i; + _ = &i; + var json_chunk = arg_json_chunk; + _ = &json_chunk; + var out_data = arg_out_data; + _ = &out_data; + i = cgltf_parse_json_array(options, tokens, i, json_chunk, @sizeOf(cgltf_camera), @as([*c]?*anyopaque, @ptrCast(@alignCast(&out_data.*.cameras))), &out_data.*.cameras_count); + if (i < @as(c_int, 0)) { + return i; + } + { + var j: cgltf_size = 0; + _ = &j; + while (j < out_data.*.cameras_count) : (j +%= 1) { + i = cgltf_parse_json_camera(options, tokens, i, json_chunk, &out_data.*.cameras[j]); + if (i < @as(c_int, 0)) { + return i; + } + } + } + return i; +} +pub fn cgltf_parse_json_light(arg_options: [*c]cgltf_options, arg_tokens: [*c]const jsmntok_t, arg_i: c_int, arg_json_chunk: [*c]const u8, arg_out_light: [*c]cgltf_light) callconv(.C) c_int { + var options = arg_options; + _ = &options; + var tokens = arg_tokens; + _ = &tokens; + var i = arg_i; + _ = &i; + var json_chunk = arg_json_chunk; + _ = &json_chunk; + var out_light = arg_out_light; + _ = &out_light; + if ((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.type != @as(c_uint, @bitCast(JSMN_OBJECT))) { + return -@as(c_int, 1); + } + out_light.*.color[@as(c_uint, @intCast(@as(c_int, 0)))] = 1.0; + out_light.*.color[@as(c_uint, @intCast(@as(c_int, 1)))] = 1.0; + out_light.*.color[@as(c_uint, @intCast(@as(c_int, 2)))] = 1.0; + out_light.*.intensity = 1.0; + out_light.*.spot_inner_cone_angle = 0.0; + out_light.*.spot_outer_cone_angle = 3.1415927410125732 / 4.0; + var size: c_int = (blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.size; + _ = &size; + i += 1; + { + var j: c_int = 0; + _ = &j; + while (j < size) : (j += 1) { + if (((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.type != @as(c_uint, @bitCast(JSMN_STRING))) or ((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.size == @as(c_int, 0))) { + return -@as(c_int, 1); + } + if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "name") == @as(c_int, 0)) { + i = cgltf_parse_json_string(options, tokens, i + @as(c_int, 1), json_chunk, &out_light.*.name); + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "color") == @as(c_int, 0)) { + i = cgltf_parse_json_float_array(tokens, i + @as(c_int, 1), json_chunk, @as([*c]cgltf_float, @ptrCast(@alignCast(&out_light.*.color))), @as(c_int, 3)); + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "intensity") == @as(c_int, 0)) { + i += 1; + out_light.*.intensity = cgltf_json_to_float(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk); + i += 1; + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "type") == @as(c_int, 0)) { + i += 1; + if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "directional") == @as(c_int, 0)) { + out_light.*.type = @as(c_uint, @bitCast(cgltf_light_type_directional)); + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "point") == @as(c_int, 0)) { + out_light.*.type = @as(c_uint, @bitCast(cgltf_light_type_point)); + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "spot") == @as(c_int, 0)) { + out_light.*.type = @as(c_uint, @bitCast(cgltf_light_type_spot)); + } + i += 1; + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "range") == @as(c_int, 0)) { + i += 1; + out_light.*.range = cgltf_json_to_float(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk); + i += 1; + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "spot") == @as(c_int, 0)) { + i += 1; + if ((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.type != @as(c_uint, @bitCast(JSMN_OBJECT))) { + return -@as(c_int, 1); + } + var data_size: c_int = (blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.size; + _ = &data_size; + i += 1; + { + var k: c_int = 0; + _ = &k; + while (k < data_size) : (k += 1) { + if (((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.type != @as(c_uint, @bitCast(JSMN_STRING))) or ((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.size == @as(c_int, 0))) { + return -@as(c_int, 1); + } + if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "innerConeAngle") == @as(c_int, 0)) { + i += 1; + out_light.*.spot_inner_cone_angle = cgltf_json_to_float(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk); + i += 1; + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "outerConeAngle") == @as(c_int, 0)) { + i += 1; + out_light.*.spot_outer_cone_angle = cgltf_json_to_float(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk); + i += 1; + } else { + i = cgltf_skip_json(tokens, i + @as(c_int, 1)); + } + if (i < @as(c_int, 0)) { + return i; + } + } + } + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "extras") == @as(c_int, 0)) { + i = cgltf_parse_json_extras(options, tokens, i + @as(c_int, 1), json_chunk, &out_light.*.extras); + } else { + i = cgltf_skip_json(tokens, i + @as(c_int, 1)); + } + if (i < @as(c_int, 0)) { + return i; + } + } + } + return i; +} +pub fn cgltf_parse_json_lights(arg_options: [*c]cgltf_options, arg_tokens: [*c]const jsmntok_t, arg_i: c_int, arg_json_chunk: [*c]const u8, arg_out_data: [*c]cgltf_data) callconv(.C) c_int { + var options = arg_options; + _ = &options; + var tokens = arg_tokens; + _ = &tokens; + var i = arg_i; + _ = &i; + var json_chunk = arg_json_chunk; + _ = &json_chunk; + var out_data = arg_out_data; + _ = &out_data; + i = cgltf_parse_json_array(options, tokens, i, json_chunk, @sizeOf(cgltf_light), @as([*c]?*anyopaque, @ptrCast(@alignCast(&out_data.*.lights))), &out_data.*.lights_count); + if (i < @as(c_int, 0)) { + return i; + } + { + var j: cgltf_size = 0; + _ = &j; + while (j < out_data.*.lights_count) : (j +%= 1) { + i = cgltf_parse_json_light(options, tokens, i, json_chunk, &out_data.*.lights[j]); + if (i < @as(c_int, 0)) { + return i; + } + } + } + return i; +} +pub fn cgltf_parse_json_node(arg_options: [*c]cgltf_options, arg_tokens: [*c]const jsmntok_t, arg_i: c_int, arg_json_chunk: [*c]const u8, arg_out_node: [*c]cgltf_node) callconv(.C) c_int { + var options = arg_options; + _ = &options; + var tokens = arg_tokens; + _ = &tokens; + var i = arg_i; + _ = &i; + var json_chunk = arg_json_chunk; + _ = &json_chunk; + var out_node = arg_out_node; + _ = &out_node; + if ((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.type != @as(c_uint, @bitCast(JSMN_OBJECT))) { + return -@as(c_int, 1); + } + out_node.*.rotation[@as(c_uint, @intCast(@as(c_int, 3)))] = 1.0; + out_node.*.scale[@as(c_uint, @intCast(@as(c_int, 0)))] = 1.0; + out_node.*.scale[@as(c_uint, @intCast(@as(c_int, 1)))] = 1.0; + out_node.*.scale[@as(c_uint, @intCast(@as(c_int, 2)))] = 1.0; + out_node.*.matrix[@as(c_uint, @intCast(@as(c_int, 0)))] = 1.0; + out_node.*.matrix[@as(c_uint, @intCast(@as(c_int, 5)))] = 1.0; + out_node.*.matrix[@as(c_uint, @intCast(@as(c_int, 10)))] = 1.0; + out_node.*.matrix[@as(c_uint, @intCast(@as(c_int, 15)))] = 1.0; + var size: c_int = (blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.size; + _ = &size; + i += 1; + { + var j: c_int = 0; + _ = &j; + while (j < size) : (j += 1) { + if (((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.type != @as(c_uint, @bitCast(JSMN_STRING))) or ((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.size == @as(c_int, 0))) { + return -@as(c_int, 1); + } + if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "name") == @as(c_int, 0)) { + i = cgltf_parse_json_string(options, tokens, i + @as(c_int, 1), json_chunk, &out_node.*.name); + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "children") == @as(c_int, 0)) { + i = cgltf_parse_json_array(options, tokens, i + @as(c_int, 1), json_chunk, @sizeOf([*c]cgltf_node), @as([*c]?*anyopaque, @ptrCast(@alignCast(&out_node.*.children))), &out_node.*.children_count); + if (i < @as(c_int, 0)) { + return i; + } + { + var k: cgltf_size = 0; + _ = &k; + while (k < out_node.*.children_count) : (k +%= 1) { + out_node.*.children[k] = @as([*c]cgltf_node, @ptrFromInt(@as(cgltf_size, @bitCast(@as(c_long, cgltf_json_to_int(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk)))) +% @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 1)))))); + i += 1; + } + } + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "mesh") == @as(c_int, 0)) { + i += 1; + if ((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.type != @as(c_uint, @bitCast(JSMN_PRIMITIVE))) { + return -@as(c_int, 1); + } + out_node.*.mesh = @as([*c]cgltf_mesh, @ptrFromInt(@as(cgltf_size, @bitCast(@as(c_long, cgltf_json_to_int(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk)))) +% @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 1)))))); + i += 1; + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "skin") == @as(c_int, 0)) { + i += 1; + if ((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.type != @as(c_uint, @bitCast(JSMN_PRIMITIVE))) { + return -@as(c_int, 1); + } + out_node.*.skin = @as([*c]cgltf_skin, @ptrFromInt(@as(cgltf_size, @bitCast(@as(c_long, cgltf_json_to_int(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk)))) +% @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 1)))))); + i += 1; + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "camera") == @as(c_int, 0)) { + i += 1; + if ((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.type != @as(c_uint, @bitCast(JSMN_PRIMITIVE))) { + return -@as(c_int, 1); + } + out_node.*.camera = @as([*c]cgltf_camera, @ptrFromInt(@as(cgltf_size, @bitCast(@as(c_long, cgltf_json_to_int(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk)))) +% @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 1)))))); + i += 1; + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "translation") == @as(c_int, 0)) { + out_node.*.has_translation = 1; + i = cgltf_parse_json_float_array(tokens, i + @as(c_int, 1), json_chunk, @as([*c]cgltf_float, @ptrCast(@alignCast(&out_node.*.translation))), @as(c_int, 3)); + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "rotation") == @as(c_int, 0)) { + out_node.*.has_rotation = 1; + i = cgltf_parse_json_float_array(tokens, i + @as(c_int, 1), json_chunk, @as([*c]cgltf_float, @ptrCast(@alignCast(&out_node.*.rotation))), @as(c_int, 4)); + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "scale") == @as(c_int, 0)) { + out_node.*.has_scale = 1; + i = cgltf_parse_json_float_array(tokens, i + @as(c_int, 1), json_chunk, @as([*c]cgltf_float, @ptrCast(@alignCast(&out_node.*.scale))), @as(c_int, 3)); + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "matrix") == @as(c_int, 0)) { + out_node.*.has_matrix = 1; + i = cgltf_parse_json_float_array(tokens, i + @as(c_int, 1), json_chunk, @as([*c]cgltf_float, @ptrCast(@alignCast(&out_node.*.matrix))), @as(c_int, 16)); + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "weights") == @as(c_int, 0)) { + i = cgltf_parse_json_array(options, tokens, i + @as(c_int, 1), json_chunk, @sizeOf(cgltf_float), @as([*c]?*anyopaque, @ptrCast(@alignCast(&out_node.*.weights))), &out_node.*.weights_count); + if (i < @as(c_int, 0)) { + return i; + } + i = cgltf_parse_json_float_array(tokens, i - @as(c_int, 1), json_chunk, out_node.*.weights, @as(c_int, @bitCast(@as(c_uint, @truncate(out_node.*.weights_count))))); + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "extras") == @as(c_int, 0)) { + i = cgltf_parse_json_extras(options, tokens, i + @as(c_int, 1), json_chunk, &out_node.*.extras); + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "extensions") == @as(c_int, 0)) { + i += 1; + if ((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.type != @as(c_uint, @bitCast(JSMN_OBJECT))) { + return -@as(c_int, 1); + } + if (out_node.*.extensions != null) { + return -@as(c_int, 1); + } + var extensions_size: c_int = (blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.size; + _ = &extensions_size; + out_node.*.extensions_count = 0; + out_node.*.extensions = @as([*c]cgltf_extension, @ptrCast(@alignCast(cgltf_calloc(options, @sizeOf(cgltf_extension), @as(cgltf_size, @bitCast(@as(c_long, extensions_size))))))); + if (!(out_node.*.extensions != null)) { + return -@as(c_int, 2); + } + i += 1; + { + var k: c_int = 0; + _ = &k; + while (k < extensions_size) : (k += 1) { + if (((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.type != @as(c_uint, @bitCast(JSMN_STRING))) or ((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.size == @as(c_int, 0))) { + return -@as(c_int, 1); + } + if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "KHR_lights_punctual") == @as(c_int, 0)) { + i += 1; + if ((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.type != @as(c_uint, @bitCast(JSMN_OBJECT))) { + return -@as(c_int, 1); + } + var data_size: c_int = (blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.size; + _ = &data_size; + i += 1; + { + var m: c_int = 0; + _ = &m; + while (m < data_size) : (m += 1) { + if (((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.type != @as(c_uint, @bitCast(JSMN_STRING))) or ((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.size == @as(c_int, 0))) { + return -@as(c_int, 1); + } + if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "light") == @as(c_int, 0)) { + i += 1; + if ((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.type != @as(c_uint, @bitCast(JSMN_PRIMITIVE))) { + return -@as(c_int, 1); + } + out_node.*.light = @as([*c]cgltf_light, @ptrFromInt(@as(cgltf_size, @bitCast(@as(c_long, cgltf_json_to_int(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk)))) +% @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 1)))))); + i += 1; + } else { + i = cgltf_skip_json(tokens, i + @as(c_int, 1)); + } + if (i < @as(c_int, 0)) { + return i; + } + } + } + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "EXT_mesh_gpu_instancing") == @as(c_int, 0)) { + out_node.*.has_mesh_gpu_instancing = 1; + i = cgltf_parse_json_mesh_gpu_instancing(options, tokens, i + @as(c_int, 1), json_chunk, &out_node.*.mesh_gpu_instancing); + } else { + i = cgltf_parse_json_unprocessed_extension(options, tokens, i, json_chunk, &out_node.*.extensions[blk: { + const ref = &out_node.*.extensions_count; + const tmp = ref.*; + ref.* +%= 1; + break :blk tmp; + }]); + } + if (i < @as(c_int, 0)) { + return i; + } + } + } + } else { + i = cgltf_skip_json(tokens, i + @as(c_int, 1)); + } + if (i < @as(c_int, 0)) { + return i; + } + } + } + return i; +} +pub fn cgltf_parse_json_nodes(arg_options: [*c]cgltf_options, arg_tokens: [*c]const jsmntok_t, arg_i: c_int, arg_json_chunk: [*c]const u8, arg_out_data: [*c]cgltf_data) callconv(.C) c_int { + var options = arg_options; + _ = &options; + var tokens = arg_tokens; + _ = &tokens; + var i = arg_i; + _ = &i; + var json_chunk = arg_json_chunk; + _ = &json_chunk; + var out_data = arg_out_data; + _ = &out_data; + i = cgltf_parse_json_array(options, tokens, i, json_chunk, @sizeOf(cgltf_node), @as([*c]?*anyopaque, @ptrCast(@alignCast(&out_data.*.nodes))), &out_data.*.nodes_count); + if (i < @as(c_int, 0)) { + return i; + } + { + var j: cgltf_size = 0; + _ = &j; + while (j < out_data.*.nodes_count) : (j +%= 1) { + i = cgltf_parse_json_node(options, tokens, i, json_chunk, &out_data.*.nodes[j]); + if (i < @as(c_int, 0)) { + return i; + } + } + } + return i; +} +pub fn cgltf_parse_json_scene(arg_options: [*c]cgltf_options, arg_tokens: [*c]const jsmntok_t, arg_i: c_int, arg_json_chunk: [*c]const u8, arg_out_scene: [*c]cgltf_scene) callconv(.C) c_int { + var options = arg_options; + _ = &options; + var tokens = arg_tokens; + _ = &tokens; + var i = arg_i; + _ = &i; + var json_chunk = arg_json_chunk; + _ = &json_chunk; + var out_scene = arg_out_scene; + _ = &out_scene; + if ((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.type != @as(c_uint, @bitCast(JSMN_OBJECT))) { + return -@as(c_int, 1); + } + var size: c_int = (blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.size; + _ = &size; + i += 1; + { + var j: c_int = 0; + _ = &j; + while (j < size) : (j += 1) { + if (((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.type != @as(c_uint, @bitCast(JSMN_STRING))) or ((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.size == @as(c_int, 0))) { + return -@as(c_int, 1); + } + if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "name") == @as(c_int, 0)) { + i = cgltf_parse_json_string(options, tokens, i + @as(c_int, 1), json_chunk, &out_scene.*.name); + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "nodes") == @as(c_int, 0)) { + i = cgltf_parse_json_array(options, tokens, i + @as(c_int, 1), json_chunk, @sizeOf([*c]cgltf_node), @as([*c]?*anyopaque, @ptrCast(@alignCast(&out_scene.*.nodes))), &out_scene.*.nodes_count); + if (i < @as(c_int, 0)) { + return i; + } + { + var k: cgltf_size = 0; + _ = &k; + while (k < out_scene.*.nodes_count) : (k +%= 1) { + out_scene.*.nodes[k] = @as([*c]cgltf_node, @ptrFromInt(@as(cgltf_size, @bitCast(@as(c_long, cgltf_json_to_int(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk)))) +% @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 1)))))); + i += 1; + } + } + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "extras") == @as(c_int, 0)) { + i = cgltf_parse_json_extras(options, tokens, i + @as(c_int, 1), json_chunk, &out_scene.*.extras); + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "extensions") == @as(c_int, 0)) { + i = cgltf_parse_json_unprocessed_extensions(options, tokens, i, json_chunk, &out_scene.*.extensions_count, &out_scene.*.extensions); + } else { + i = cgltf_skip_json(tokens, i + @as(c_int, 1)); + } + if (i < @as(c_int, 0)) { + return i; + } + } + } + return i; +} +pub fn cgltf_parse_json_scenes(arg_options: [*c]cgltf_options, arg_tokens: [*c]const jsmntok_t, arg_i: c_int, arg_json_chunk: [*c]const u8, arg_out_data: [*c]cgltf_data) callconv(.C) c_int { + var options = arg_options; + _ = &options; + var tokens = arg_tokens; + _ = &tokens; + var i = arg_i; + _ = &i; + var json_chunk = arg_json_chunk; + _ = &json_chunk; + var out_data = arg_out_data; + _ = &out_data; + i = cgltf_parse_json_array(options, tokens, i, json_chunk, @sizeOf(cgltf_scene), @as([*c]?*anyopaque, @ptrCast(@alignCast(&out_data.*.scenes))), &out_data.*.scenes_count); + if (i < @as(c_int, 0)) { + return i; + } + { + var j: cgltf_size = 0; + _ = &j; + while (j < out_data.*.scenes_count) : (j +%= 1) { + i = cgltf_parse_json_scene(options, tokens, i, json_chunk, &out_data.*.scenes[j]); + if (i < @as(c_int, 0)) { + return i; + } + } + } + return i; +} +pub fn cgltf_parse_json_animation_sampler(arg_options: [*c]cgltf_options, arg_tokens: [*c]const jsmntok_t, arg_i: c_int, arg_json_chunk: [*c]const u8, arg_out_sampler: [*c]cgltf_animation_sampler) callconv(.C) c_int { + var options = arg_options; + _ = &options; + var tokens = arg_tokens; + _ = &tokens; + var i = arg_i; + _ = &i; + var json_chunk = arg_json_chunk; + _ = &json_chunk; + var out_sampler = arg_out_sampler; + _ = &out_sampler; + _ = &options; + if ((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.type != @as(c_uint, @bitCast(JSMN_OBJECT))) { + return -@as(c_int, 1); + } + var size: c_int = (blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.size; + _ = &size; + i += 1; + { + var j: c_int = 0; + _ = &j; + while (j < size) : (j += 1) { + if (((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.type != @as(c_uint, @bitCast(JSMN_STRING))) or ((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.size == @as(c_int, 0))) { + return -@as(c_int, 1); + } + if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "input") == @as(c_int, 0)) { + i += 1; + out_sampler.*.input = @as([*c]cgltf_accessor, @ptrFromInt(@as(cgltf_size, @bitCast(@as(c_long, cgltf_json_to_int(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk)))) +% @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 1)))))); + i += 1; + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "output") == @as(c_int, 0)) { + i += 1; + out_sampler.*.output = @as([*c]cgltf_accessor, @ptrFromInt(@as(cgltf_size, @bitCast(@as(c_long, cgltf_json_to_int(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk)))) +% @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 1)))))); + i += 1; + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "interpolation") == @as(c_int, 0)) { + i += 1; + if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "LINEAR") == @as(c_int, 0)) { + out_sampler.*.interpolation = @as(c_uint, @bitCast(cgltf_interpolation_type_linear)); + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "STEP") == @as(c_int, 0)) { + out_sampler.*.interpolation = @as(c_uint, @bitCast(cgltf_interpolation_type_step)); + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "CUBICSPLINE") == @as(c_int, 0)) { + out_sampler.*.interpolation = @as(c_uint, @bitCast(cgltf_interpolation_type_cubic_spline)); + } + i += 1; + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "extras") == @as(c_int, 0)) { + i = cgltf_parse_json_extras(options, tokens, i + @as(c_int, 1), json_chunk, &out_sampler.*.extras); + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "extensions") == @as(c_int, 0)) { + i = cgltf_parse_json_unprocessed_extensions(options, tokens, i, json_chunk, &out_sampler.*.extensions_count, &out_sampler.*.extensions); + } else { + i = cgltf_skip_json(tokens, i + @as(c_int, 1)); + } + if (i < @as(c_int, 0)) { + return i; + } + } + } + return i; +} +pub fn cgltf_parse_json_animation_channel(arg_options: [*c]cgltf_options, arg_tokens: [*c]const jsmntok_t, arg_i: c_int, arg_json_chunk: [*c]const u8, arg_out_channel: [*c]cgltf_animation_channel) callconv(.C) c_int { + var options = arg_options; + _ = &options; + var tokens = arg_tokens; + _ = &tokens; + var i = arg_i; + _ = &i; + var json_chunk = arg_json_chunk; + _ = &json_chunk; + var out_channel = arg_out_channel; + _ = &out_channel; + _ = &options; + if ((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.type != @as(c_uint, @bitCast(JSMN_OBJECT))) { + return -@as(c_int, 1); + } + var size: c_int = (blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.size; + _ = &size; + i += 1; + { + var j: c_int = 0; + _ = &j; + while (j < size) : (j += 1) { + if (((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.type != @as(c_uint, @bitCast(JSMN_STRING))) or ((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.size == @as(c_int, 0))) { + return -@as(c_int, 1); + } + if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "sampler") == @as(c_int, 0)) { + i += 1; + out_channel.*.sampler = @as([*c]cgltf_animation_sampler, @ptrFromInt(@as(cgltf_size, @bitCast(@as(c_long, cgltf_json_to_int(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk)))) +% @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 1)))))); + i += 1; + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "target") == @as(c_int, 0)) { + i += 1; + if ((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.type != @as(c_uint, @bitCast(JSMN_OBJECT))) { + return -@as(c_int, 1); + } + var target_size: c_int = (blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.size; + _ = &target_size; + i += 1; + { + var k: c_int = 0; + _ = &k; + while (k < target_size) : (k += 1) { + if (((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.type != @as(c_uint, @bitCast(JSMN_STRING))) or ((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.size == @as(c_int, 0))) { + return -@as(c_int, 1); + } + if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "node") == @as(c_int, 0)) { + i += 1; + out_channel.*.target_node = @as([*c]cgltf_node, @ptrFromInt(@as(cgltf_size, @bitCast(@as(c_long, cgltf_json_to_int(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk)))) +% @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 1)))))); + i += 1; + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "path") == @as(c_int, 0)) { + i += 1; + if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "translation") == @as(c_int, 0)) { + out_channel.*.target_path = @as(c_uint, @bitCast(cgltf_animation_path_type_translation)); + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "rotation") == @as(c_int, 0)) { + out_channel.*.target_path = @as(c_uint, @bitCast(cgltf_animation_path_type_rotation)); + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "scale") == @as(c_int, 0)) { + out_channel.*.target_path = @as(c_uint, @bitCast(cgltf_animation_path_type_scale)); + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "weights") == @as(c_int, 0)) { + out_channel.*.target_path = @as(c_uint, @bitCast(cgltf_animation_path_type_weights)); + } + i += 1; + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "extras") == @as(c_int, 0)) { + i = cgltf_parse_json_extras(options, tokens, i + @as(c_int, 1), json_chunk, &out_channel.*.extras); + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "extensions") == @as(c_int, 0)) { + i = cgltf_parse_json_unprocessed_extensions(options, tokens, i, json_chunk, &out_channel.*.extensions_count, &out_channel.*.extensions); + } else { + i = cgltf_skip_json(tokens, i + @as(c_int, 1)); + } + if (i < @as(c_int, 0)) { + return i; + } + } + } + } else { + i = cgltf_skip_json(tokens, i + @as(c_int, 1)); + } + if (i < @as(c_int, 0)) { + return i; + } + } + } + return i; +} +pub fn cgltf_parse_json_animation(arg_options: [*c]cgltf_options, arg_tokens: [*c]const jsmntok_t, arg_i: c_int, arg_json_chunk: [*c]const u8, arg_out_animation: [*c]cgltf_animation) callconv(.C) c_int { + var options = arg_options; + _ = &options; + var tokens = arg_tokens; + _ = &tokens; + var i = arg_i; + _ = &i; + var json_chunk = arg_json_chunk; + _ = &json_chunk; + var out_animation = arg_out_animation; + _ = &out_animation; + if ((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.type != @as(c_uint, @bitCast(JSMN_OBJECT))) { + return -@as(c_int, 1); + } + var size: c_int = (blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.size; + _ = &size; + i += 1; + { + var j: c_int = 0; + _ = &j; + while (j < size) : (j += 1) { + if (((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.type != @as(c_uint, @bitCast(JSMN_STRING))) or ((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.size == @as(c_int, 0))) { + return -@as(c_int, 1); + } + if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "name") == @as(c_int, 0)) { + i = cgltf_parse_json_string(options, tokens, i + @as(c_int, 1), json_chunk, &out_animation.*.name); + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "samplers") == @as(c_int, 0)) { + i = cgltf_parse_json_array(options, tokens, i + @as(c_int, 1), json_chunk, @sizeOf(cgltf_animation_sampler), @as([*c]?*anyopaque, @ptrCast(@alignCast(&out_animation.*.samplers))), &out_animation.*.samplers_count); + if (i < @as(c_int, 0)) { + return i; + } + { + var k: cgltf_size = 0; + _ = &k; + while (k < out_animation.*.samplers_count) : (k +%= 1) { + i = cgltf_parse_json_animation_sampler(options, tokens, i, json_chunk, &out_animation.*.samplers[k]); + if (i < @as(c_int, 0)) { + return i; + } + } + } + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "channels") == @as(c_int, 0)) { + i = cgltf_parse_json_array(options, tokens, i + @as(c_int, 1), json_chunk, @sizeOf(cgltf_animation_channel), @as([*c]?*anyopaque, @ptrCast(@alignCast(&out_animation.*.channels))), &out_animation.*.channels_count); + if (i < @as(c_int, 0)) { + return i; + } + { + var k: cgltf_size = 0; + _ = &k; + while (k < out_animation.*.channels_count) : (k +%= 1) { + i = cgltf_parse_json_animation_channel(options, tokens, i, json_chunk, &out_animation.*.channels[k]); + if (i < @as(c_int, 0)) { + return i; + } + } + } + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "extras") == @as(c_int, 0)) { + i = cgltf_parse_json_extras(options, tokens, i + @as(c_int, 1), json_chunk, &out_animation.*.extras); + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "extensions") == @as(c_int, 0)) { + i = cgltf_parse_json_unprocessed_extensions(options, tokens, i, json_chunk, &out_animation.*.extensions_count, &out_animation.*.extensions); + } else { + i = cgltf_skip_json(tokens, i + @as(c_int, 1)); + } + if (i < @as(c_int, 0)) { + return i; + } + } + } + return i; +} +pub fn cgltf_parse_json_animations(arg_options: [*c]cgltf_options, arg_tokens: [*c]const jsmntok_t, arg_i: c_int, arg_json_chunk: [*c]const u8, arg_out_data: [*c]cgltf_data) callconv(.C) c_int { + var options = arg_options; + _ = &options; + var tokens = arg_tokens; + _ = &tokens; + var i = arg_i; + _ = &i; + var json_chunk = arg_json_chunk; + _ = &json_chunk; + var out_data = arg_out_data; + _ = &out_data; + i = cgltf_parse_json_array(options, tokens, i, json_chunk, @sizeOf(cgltf_animation), @as([*c]?*anyopaque, @ptrCast(@alignCast(&out_data.*.animations))), &out_data.*.animations_count); + if (i < @as(c_int, 0)) { + return i; + } + { + var j: cgltf_size = 0; + _ = &j; + while (j < out_data.*.animations_count) : (j +%= 1) { + i = cgltf_parse_json_animation(options, tokens, i, json_chunk, &out_data.*.animations[j]); + if (i < @as(c_int, 0)) { + return i; + } + } + } + return i; +} +pub fn cgltf_parse_json_variant(arg_options: [*c]cgltf_options, arg_tokens: [*c]const jsmntok_t, arg_i: c_int, arg_json_chunk: [*c]const u8, arg_out_variant: [*c]cgltf_material_variant) callconv(.C) c_int { + var options = arg_options; + _ = &options; + var tokens = arg_tokens; + _ = &tokens; + var i = arg_i; + _ = &i; + var json_chunk = arg_json_chunk; + _ = &json_chunk; + var out_variant = arg_out_variant; + _ = &out_variant; + if ((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.type != @as(c_uint, @bitCast(JSMN_OBJECT))) { + return -@as(c_int, 1); + } + var size: c_int = (blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.size; + _ = &size; + i += 1; + { + var j: c_int = 0; + _ = &j; + while (j < size) : (j += 1) { + if (((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.type != @as(c_uint, @bitCast(JSMN_STRING))) or ((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.size == @as(c_int, 0))) { + return -@as(c_int, 1); + } + if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "name") == @as(c_int, 0)) { + i = cgltf_parse_json_string(options, tokens, i + @as(c_int, 1), json_chunk, &out_variant.*.name); + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "extras") == @as(c_int, 0)) { + i = cgltf_parse_json_extras(options, tokens, i + @as(c_int, 1), json_chunk, &out_variant.*.extras); + } else { + i = cgltf_skip_json(tokens, i + @as(c_int, 1)); + } + if (i < @as(c_int, 0)) { + return i; + } + } + } + return i; +} +pub fn cgltf_parse_json_variants(arg_options: [*c]cgltf_options, arg_tokens: [*c]const jsmntok_t, arg_i: c_int, arg_json_chunk: [*c]const u8, arg_out_data: [*c]cgltf_data) callconv(.C) c_int { + var options = arg_options; + _ = &options; + var tokens = arg_tokens; + _ = &tokens; + var i = arg_i; + _ = &i; + var json_chunk = arg_json_chunk; + _ = &json_chunk; + var out_data = arg_out_data; + _ = &out_data; + i = cgltf_parse_json_array(options, tokens, i, json_chunk, @sizeOf(cgltf_material_variant), @as([*c]?*anyopaque, @ptrCast(@alignCast(&out_data.*.variants))), &out_data.*.variants_count); + if (i < @as(c_int, 0)) { + return i; + } + { + var j: cgltf_size = 0; + _ = &j; + while (j < out_data.*.variants_count) : (j +%= 1) { + i = cgltf_parse_json_variant(options, tokens, i, json_chunk, &out_data.*.variants[j]); + if (i < @as(c_int, 0)) { + return i; + } + } + } + return i; +} +pub fn cgltf_parse_json_asset(arg_options: [*c]cgltf_options, arg_tokens: [*c]const jsmntok_t, arg_i: c_int, arg_json_chunk: [*c]const u8, arg_out_asset: [*c]cgltf_asset) callconv(.C) c_int { + var options = arg_options; + _ = &options; + var tokens = arg_tokens; + _ = &tokens; + var i = arg_i; + _ = &i; + var json_chunk = arg_json_chunk; + _ = &json_chunk; + var out_asset = arg_out_asset; + _ = &out_asset; + if ((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.type != @as(c_uint, @bitCast(JSMN_OBJECT))) { + return -@as(c_int, 1); + } + var size: c_int = (blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.size; + _ = &size; + i += 1; + { + var j: c_int = 0; + _ = &j; + while (j < size) : (j += 1) { + if (((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.type != @as(c_uint, @bitCast(JSMN_STRING))) or ((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.size == @as(c_int, 0))) { + return -@as(c_int, 1); + } + if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "copyright") == @as(c_int, 0)) { + i = cgltf_parse_json_string(options, tokens, i + @as(c_int, 1), json_chunk, &out_asset.*.copyright); + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "generator") == @as(c_int, 0)) { + i = cgltf_parse_json_string(options, tokens, i + @as(c_int, 1), json_chunk, &out_asset.*.generator); + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "version") == @as(c_int, 0)) { + i = cgltf_parse_json_string(options, tokens, i + @as(c_int, 1), json_chunk, &out_asset.*.version); + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "minVersion") == @as(c_int, 0)) { + i = cgltf_parse_json_string(options, tokens, i + @as(c_int, 1), json_chunk, &out_asset.*.min_version); + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "extras") == @as(c_int, 0)) { + i = cgltf_parse_json_extras(options, tokens, i + @as(c_int, 1), json_chunk, &out_asset.*.extras); + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "extensions") == @as(c_int, 0)) { + i = cgltf_parse_json_unprocessed_extensions(options, tokens, i, json_chunk, &out_asset.*.extensions_count, &out_asset.*.extensions); + } else { + i = cgltf_skip_json(tokens, i + @as(c_int, 1)); + } + if (i < @as(c_int, 0)) { + return i; + } + } + } + if ((out_asset.*.version != null) and (atof(out_asset.*.version) < @as(f64, @floatFromInt(@as(c_int, 2))))) { + return -@as(c_int, 3); + } + return i; +} +pub fn cgltf_fixup_pointers(arg_data: [*c]cgltf_data) callconv(.C) c_int { + var data = arg_data; + _ = &data; + { + var i: cgltf_size = 0; + _ = &i; + while (i < data.*.meshes_count) : (i +%= 1) { + { + var j: cgltf_size = 0; + _ = &j; + while (j < data.*.meshes[i].primitives_count) : (j +%= 1) { + if (data.*.meshes[i].primitives[j].indices != null) { + if (@as(cgltf_size, @intCast(@intFromPtr(data.*.meshes[i].primitives[j].indices))) > data.*.accessors_count) { + return -@as(c_int, 1); + } + data.*.meshes[i].primitives[j].indices = &data.*.accessors[@as(cgltf_size, @intCast(@intFromPtr(data.*.meshes[i].primitives[j].indices))) -% @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 1))))]; + } + if (data.*.meshes[i].primitives[j].material != null) { + if (@as(cgltf_size, @intCast(@intFromPtr(data.*.meshes[i].primitives[j].material))) > data.*.materials_count) { + return -@as(c_int, 1); + } + data.*.meshes[i].primitives[j].material = &data.*.materials[@as(cgltf_size, @intCast(@intFromPtr(data.*.meshes[i].primitives[j].material))) -% @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 1))))]; + } + { + var k: cgltf_size = 0; + _ = &k; + while (k < data.*.meshes[i].primitives[j].attributes_count) : (k +%= 1) { + if (!(data.*.meshes[i].primitives[j].attributes[k].data != null) or (@as(cgltf_size, @intCast(@intFromPtr(data.*.meshes[i].primitives[j].attributes[k].data))) > data.*.accessors_count)) { + return -@as(c_int, 1); + } + data.*.meshes[i].primitives[j].attributes[k].data = &data.*.accessors[@as(cgltf_size, @intCast(@intFromPtr(data.*.meshes[i].primitives[j].attributes[k].data))) -% @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 1))))]; + } + } + { + var k: cgltf_size = 0; + _ = &k; + while (k < data.*.meshes[i].primitives[j].targets_count) : (k +%= 1) { + { + var m: cgltf_size = 0; + _ = &m; + while (m < data.*.meshes[i].primitives[j].targets[k].attributes_count) : (m +%= 1) { + if (!(data.*.meshes[i].primitives[j].targets[k].attributes[m].data != null) or (@as(cgltf_size, @intCast(@intFromPtr(data.*.meshes[i].primitives[j].targets[k].attributes[m].data))) > data.*.accessors_count)) { + return -@as(c_int, 1); + } + data.*.meshes[i].primitives[j].targets[k].attributes[m].data = &data.*.accessors[@as(cgltf_size, @intCast(@intFromPtr(data.*.meshes[i].primitives[j].targets[k].attributes[m].data))) -% @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 1))))]; + } + } + } + } + if (data.*.meshes[i].primitives[j].has_draco_mesh_compression != 0) { + if (!(data.*.meshes[i].primitives[j].draco_mesh_compression.buffer_view != null) or (@as(cgltf_size, @intCast(@intFromPtr(data.*.meshes[i].primitives[j].draco_mesh_compression.buffer_view))) > data.*.buffer_views_count)) { + return -@as(c_int, 1); + } + data.*.meshes[i].primitives[j].draco_mesh_compression.buffer_view = &data.*.buffer_views[@as(cgltf_size, @intCast(@intFromPtr(data.*.meshes[i].primitives[j].draco_mesh_compression.buffer_view))) -% @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 1))))]; + { + var m: cgltf_size = 0; + _ = &m; + while (m < data.*.meshes[i].primitives[j].draco_mesh_compression.attributes_count) : (m +%= 1) { + if (!(data.*.meshes[i].primitives[j].draco_mesh_compression.attributes[m].data != null) or (@as(cgltf_size, @intCast(@intFromPtr(data.*.meshes[i].primitives[j].draco_mesh_compression.attributes[m].data))) > data.*.accessors_count)) { + return -@as(c_int, 1); + } + data.*.meshes[i].primitives[j].draco_mesh_compression.attributes[m].data = &data.*.accessors[@as(cgltf_size, @intCast(@intFromPtr(data.*.meshes[i].primitives[j].draco_mesh_compression.attributes[m].data))) -% @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 1))))]; + } + } + } + { + var k: cgltf_size = 0; + _ = &k; + while (k < data.*.meshes[i].primitives[j].mappings_count) : (k +%= 1) { + if (!(data.*.meshes[i].primitives[j].mappings[k].material != null) or (@as(cgltf_size, @intCast(@intFromPtr(data.*.meshes[i].primitives[j].mappings[k].material))) > data.*.materials_count)) { + return -@as(c_int, 1); + } + data.*.meshes[i].primitives[j].mappings[k].material = &data.*.materials[@as(cgltf_size, @intCast(@intFromPtr(data.*.meshes[i].primitives[j].mappings[k].material))) -% @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 1))))]; + } + } + } + } + } + } + { + var i: cgltf_size = 0; + _ = &i; + while (i < data.*.accessors_count) : (i +%= 1) { + if (data.*.accessors[i].buffer_view != null) { + if (@as(cgltf_size, @intCast(@intFromPtr(data.*.accessors[i].buffer_view))) > data.*.buffer_views_count) { + return -@as(c_int, 1); + } + data.*.accessors[i].buffer_view = &data.*.buffer_views[@as(cgltf_size, @intCast(@intFromPtr(data.*.accessors[i].buffer_view))) -% @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 1))))]; + } + if (data.*.accessors[i].is_sparse != 0) { + if (!(data.*.accessors[i].sparse.indices_buffer_view != null) or (@as(cgltf_size, @intCast(@intFromPtr(data.*.accessors[i].sparse.indices_buffer_view))) > data.*.buffer_views_count)) { + return -@as(c_int, 1); + } + data.*.accessors[i].sparse.indices_buffer_view = &data.*.buffer_views[@as(cgltf_size, @intCast(@intFromPtr(data.*.accessors[i].sparse.indices_buffer_view))) -% @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 1))))]; + if (!(data.*.accessors[i].sparse.values_buffer_view != null) or (@as(cgltf_size, @intCast(@intFromPtr(data.*.accessors[i].sparse.values_buffer_view))) > data.*.buffer_views_count)) { + return -@as(c_int, 1); + } + data.*.accessors[i].sparse.values_buffer_view = &data.*.buffer_views[@as(cgltf_size, @intCast(@intFromPtr(data.*.accessors[i].sparse.values_buffer_view))) -% @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 1))))]; + } + if (data.*.accessors[i].buffer_view != null) { + data.*.accessors[i].stride = data.*.accessors[i].buffer_view.*.stride; + } + if (data.*.accessors[i].stride == @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 0))))) { + data.*.accessors[i].stride = cgltf_calc_size(data.*.accessors[i].type, data.*.accessors[i].component_type); + } + } + } + { + var i: cgltf_size = 0; + _ = &i; + while (i < data.*.textures_count) : (i +%= 1) { + if (data.*.textures[i].image != null) { + if (@as(cgltf_size, @intCast(@intFromPtr(data.*.textures[i].image))) > data.*.images_count) { + return -@as(c_int, 1); + } + data.*.textures[i].image = &data.*.images[@as(cgltf_size, @intCast(@intFromPtr(data.*.textures[i].image))) -% @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 1))))]; + } + if (data.*.textures[i].basisu_image != null) { + if (@as(cgltf_size, @intCast(@intFromPtr(data.*.textures[i].basisu_image))) > data.*.images_count) { + return -@as(c_int, 1); + } + data.*.textures[i].basisu_image = &data.*.images[@as(cgltf_size, @intCast(@intFromPtr(data.*.textures[i].basisu_image))) -% @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 1))))]; + } + if (data.*.textures[i].sampler != null) { + if (@as(cgltf_size, @intCast(@intFromPtr(data.*.textures[i].sampler))) > data.*.samplers_count) { + return -@as(c_int, 1); + } + data.*.textures[i].sampler = &data.*.samplers[@as(cgltf_size, @intCast(@intFromPtr(data.*.textures[i].sampler))) -% @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 1))))]; + } + } + } + { + var i: cgltf_size = 0; + _ = &i; + while (i < data.*.images_count) : (i +%= 1) { + if (data.*.images[i].buffer_view != null) { + if (@as(cgltf_size, @intCast(@intFromPtr(data.*.images[i].buffer_view))) > data.*.buffer_views_count) { + return -@as(c_int, 1); + } + data.*.images[i].buffer_view = &data.*.buffer_views[@as(cgltf_size, @intCast(@intFromPtr(data.*.images[i].buffer_view))) -% @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 1))))]; + } + } + } + { + var i: cgltf_size = 0; + _ = &i; + while (i < data.*.materials_count) : (i +%= 1) { + if (data.*.materials[i].normal_texture.texture != null) { + if (@as(cgltf_size, @intCast(@intFromPtr(data.*.materials[i].normal_texture.texture))) > data.*.textures_count) { + return -@as(c_int, 1); + } + data.*.materials[i].normal_texture.texture = &data.*.textures[@as(cgltf_size, @intCast(@intFromPtr(data.*.materials[i].normal_texture.texture))) -% @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 1))))]; + } + if (data.*.materials[i].emissive_texture.texture != null) { + if (@as(cgltf_size, @intCast(@intFromPtr(data.*.materials[i].emissive_texture.texture))) > data.*.textures_count) { + return -@as(c_int, 1); + } + data.*.materials[i].emissive_texture.texture = &data.*.textures[@as(cgltf_size, @intCast(@intFromPtr(data.*.materials[i].emissive_texture.texture))) -% @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 1))))]; + } + if (data.*.materials[i].occlusion_texture.texture != null) { + if (@as(cgltf_size, @intCast(@intFromPtr(data.*.materials[i].occlusion_texture.texture))) > data.*.textures_count) { + return -@as(c_int, 1); + } + data.*.materials[i].occlusion_texture.texture = &data.*.textures[@as(cgltf_size, @intCast(@intFromPtr(data.*.materials[i].occlusion_texture.texture))) -% @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 1))))]; + } + if (data.*.materials[i].pbr_metallic_roughness.base_color_texture.texture != null) { + if (@as(cgltf_size, @intCast(@intFromPtr(data.*.materials[i].pbr_metallic_roughness.base_color_texture.texture))) > data.*.textures_count) { + return -@as(c_int, 1); + } + data.*.materials[i].pbr_metallic_roughness.base_color_texture.texture = &data.*.textures[@as(cgltf_size, @intCast(@intFromPtr(data.*.materials[i].pbr_metallic_roughness.base_color_texture.texture))) -% @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 1))))]; + } + if (data.*.materials[i].pbr_metallic_roughness.metallic_roughness_texture.texture != null) { + if (@as(cgltf_size, @intCast(@intFromPtr(data.*.materials[i].pbr_metallic_roughness.metallic_roughness_texture.texture))) > data.*.textures_count) { + return -@as(c_int, 1); + } + data.*.materials[i].pbr_metallic_roughness.metallic_roughness_texture.texture = &data.*.textures[@as(cgltf_size, @intCast(@intFromPtr(data.*.materials[i].pbr_metallic_roughness.metallic_roughness_texture.texture))) -% @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 1))))]; + } + if (data.*.materials[i].pbr_specular_glossiness.diffuse_texture.texture != null) { + if (@as(cgltf_size, @intCast(@intFromPtr(data.*.materials[i].pbr_specular_glossiness.diffuse_texture.texture))) > data.*.textures_count) { + return -@as(c_int, 1); + } + data.*.materials[i].pbr_specular_glossiness.diffuse_texture.texture = &data.*.textures[@as(cgltf_size, @intCast(@intFromPtr(data.*.materials[i].pbr_specular_glossiness.diffuse_texture.texture))) -% @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 1))))]; + } + if (data.*.materials[i].pbr_specular_glossiness.specular_glossiness_texture.texture != null) { + if (@as(cgltf_size, @intCast(@intFromPtr(data.*.materials[i].pbr_specular_glossiness.specular_glossiness_texture.texture))) > data.*.textures_count) { + return -@as(c_int, 1); + } + data.*.materials[i].pbr_specular_glossiness.specular_glossiness_texture.texture = &data.*.textures[@as(cgltf_size, @intCast(@intFromPtr(data.*.materials[i].pbr_specular_glossiness.specular_glossiness_texture.texture))) -% @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 1))))]; + } + if (data.*.materials[i].clearcoat.clearcoat_texture.texture != null) { + if (@as(cgltf_size, @intCast(@intFromPtr(data.*.materials[i].clearcoat.clearcoat_texture.texture))) > data.*.textures_count) { + return -@as(c_int, 1); + } + data.*.materials[i].clearcoat.clearcoat_texture.texture = &data.*.textures[@as(cgltf_size, @intCast(@intFromPtr(data.*.materials[i].clearcoat.clearcoat_texture.texture))) -% @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 1))))]; + } + if (data.*.materials[i].clearcoat.clearcoat_roughness_texture.texture != null) { + if (@as(cgltf_size, @intCast(@intFromPtr(data.*.materials[i].clearcoat.clearcoat_roughness_texture.texture))) > data.*.textures_count) { + return -@as(c_int, 1); + } + data.*.materials[i].clearcoat.clearcoat_roughness_texture.texture = &data.*.textures[@as(cgltf_size, @intCast(@intFromPtr(data.*.materials[i].clearcoat.clearcoat_roughness_texture.texture))) -% @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 1))))]; + } + if (data.*.materials[i].clearcoat.clearcoat_normal_texture.texture != null) { + if (@as(cgltf_size, @intCast(@intFromPtr(data.*.materials[i].clearcoat.clearcoat_normal_texture.texture))) > data.*.textures_count) { + return -@as(c_int, 1); + } + data.*.materials[i].clearcoat.clearcoat_normal_texture.texture = &data.*.textures[@as(cgltf_size, @intCast(@intFromPtr(data.*.materials[i].clearcoat.clearcoat_normal_texture.texture))) -% @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 1))))]; + } + if (data.*.materials[i].specular.specular_texture.texture != null) { + if (@as(cgltf_size, @intCast(@intFromPtr(data.*.materials[i].specular.specular_texture.texture))) > data.*.textures_count) { + return -@as(c_int, 1); + } + data.*.materials[i].specular.specular_texture.texture = &data.*.textures[@as(cgltf_size, @intCast(@intFromPtr(data.*.materials[i].specular.specular_texture.texture))) -% @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 1))))]; + } + if (data.*.materials[i].specular.specular_color_texture.texture != null) { + if (@as(cgltf_size, @intCast(@intFromPtr(data.*.materials[i].specular.specular_color_texture.texture))) > data.*.textures_count) { + return -@as(c_int, 1); + } + data.*.materials[i].specular.specular_color_texture.texture = &data.*.textures[@as(cgltf_size, @intCast(@intFromPtr(data.*.materials[i].specular.specular_color_texture.texture))) -% @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 1))))]; + } + if (data.*.materials[i].transmission.transmission_texture.texture != null) { + if (@as(cgltf_size, @intCast(@intFromPtr(data.*.materials[i].transmission.transmission_texture.texture))) > data.*.textures_count) { + return -@as(c_int, 1); + } + data.*.materials[i].transmission.transmission_texture.texture = &data.*.textures[@as(cgltf_size, @intCast(@intFromPtr(data.*.materials[i].transmission.transmission_texture.texture))) -% @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 1))))]; + } + if (data.*.materials[i].volume.thickness_texture.texture != null) { + if (@as(cgltf_size, @intCast(@intFromPtr(data.*.materials[i].volume.thickness_texture.texture))) > data.*.textures_count) { + return -@as(c_int, 1); + } + data.*.materials[i].volume.thickness_texture.texture = &data.*.textures[@as(cgltf_size, @intCast(@intFromPtr(data.*.materials[i].volume.thickness_texture.texture))) -% @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 1))))]; + } + if (data.*.materials[i].sheen.sheen_color_texture.texture != null) { + if (@as(cgltf_size, @intCast(@intFromPtr(data.*.materials[i].sheen.sheen_color_texture.texture))) > data.*.textures_count) { + return -@as(c_int, 1); + } + data.*.materials[i].sheen.sheen_color_texture.texture = &data.*.textures[@as(cgltf_size, @intCast(@intFromPtr(data.*.materials[i].sheen.sheen_color_texture.texture))) -% @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 1))))]; + } + if (data.*.materials[i].sheen.sheen_roughness_texture.texture != null) { + if (@as(cgltf_size, @intCast(@intFromPtr(data.*.materials[i].sheen.sheen_roughness_texture.texture))) > data.*.textures_count) { + return -@as(c_int, 1); + } + data.*.materials[i].sheen.sheen_roughness_texture.texture = &data.*.textures[@as(cgltf_size, @intCast(@intFromPtr(data.*.materials[i].sheen.sheen_roughness_texture.texture))) -% @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 1))))]; + } + if (data.*.materials[i].iridescence.iridescence_texture.texture != null) { + if (@as(cgltf_size, @intCast(@intFromPtr(data.*.materials[i].iridescence.iridescence_texture.texture))) > data.*.textures_count) { + return -@as(c_int, 1); + } + data.*.materials[i].iridescence.iridescence_texture.texture = &data.*.textures[@as(cgltf_size, @intCast(@intFromPtr(data.*.materials[i].iridescence.iridescence_texture.texture))) -% @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 1))))]; + } + if (data.*.materials[i].iridescence.iridescence_thickness_texture.texture != null) { + if (@as(cgltf_size, @intCast(@intFromPtr(data.*.materials[i].iridescence.iridescence_thickness_texture.texture))) > data.*.textures_count) { + return -@as(c_int, 1); + } + data.*.materials[i].iridescence.iridescence_thickness_texture.texture = &data.*.textures[@as(cgltf_size, @intCast(@intFromPtr(data.*.materials[i].iridescence.iridescence_thickness_texture.texture))) -% @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 1))))]; + } + if (data.*.materials[i].anisotropy.anisotropy_texture.texture != null) { + if (@as(cgltf_size, @intCast(@intFromPtr(data.*.materials[i].anisotropy.anisotropy_texture.texture))) > data.*.textures_count) { + return -@as(c_int, 1); + } + data.*.materials[i].anisotropy.anisotropy_texture.texture = &data.*.textures[@as(cgltf_size, @intCast(@intFromPtr(data.*.materials[i].anisotropy.anisotropy_texture.texture))) -% @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 1))))]; + } + } + } + { + var i: cgltf_size = 0; + _ = &i; + while (i < data.*.buffer_views_count) : (i +%= 1) { + if (!(data.*.buffer_views[i].buffer != null) or (@as(cgltf_size, @intCast(@intFromPtr(data.*.buffer_views[i].buffer))) > data.*.buffers_count)) { + return -@as(c_int, 1); + } + data.*.buffer_views[i].buffer = &data.*.buffers[@as(cgltf_size, @intCast(@intFromPtr(data.*.buffer_views[i].buffer))) -% @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 1))))]; + if (data.*.buffer_views[i].has_meshopt_compression != 0) { + if (!(data.*.buffer_views[i].meshopt_compression.buffer != null) or (@as(cgltf_size, @intCast(@intFromPtr(data.*.buffer_views[i].meshopt_compression.buffer))) > data.*.buffers_count)) { + return -@as(c_int, 1); + } + data.*.buffer_views[i].meshopt_compression.buffer = &data.*.buffers[@as(cgltf_size, @intCast(@intFromPtr(data.*.buffer_views[i].meshopt_compression.buffer))) -% @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 1))))]; + } + } + } + { + var i: cgltf_size = 0; + _ = &i; + while (i < data.*.skins_count) : (i +%= 1) { + { + var j: cgltf_size = 0; + _ = &j; + while (j < data.*.skins[i].joints_count) : (j +%= 1) { + if (!(data.*.skins[i].joints[j] != null) or (@as(cgltf_size, @intCast(@intFromPtr(data.*.skins[i].joints[j]))) > data.*.nodes_count)) { + return -@as(c_int, 1); + } + data.*.skins[i].joints[j] = &data.*.nodes[@as(cgltf_size, @intCast(@intFromPtr(data.*.skins[i].joints[j]))) -% @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 1))))]; + } + } + if (data.*.skins[i].skeleton != null) { + if (@as(cgltf_size, @intCast(@intFromPtr(data.*.skins[i].skeleton))) > data.*.nodes_count) { + return -@as(c_int, 1); + } + data.*.skins[i].skeleton = &data.*.nodes[@as(cgltf_size, @intCast(@intFromPtr(data.*.skins[i].skeleton))) -% @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 1))))]; + } + if (data.*.skins[i].inverse_bind_matrices != null) { + if (@as(cgltf_size, @intCast(@intFromPtr(data.*.skins[i].inverse_bind_matrices))) > data.*.accessors_count) { + return -@as(c_int, 1); + } + data.*.skins[i].inverse_bind_matrices = &data.*.accessors[@as(cgltf_size, @intCast(@intFromPtr(data.*.skins[i].inverse_bind_matrices))) -% @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 1))))]; + } + } + } + { + var i: cgltf_size = 0; + _ = &i; + while (i < data.*.nodes_count) : (i +%= 1) { + { + var j: cgltf_size = 0; + _ = &j; + while (j < data.*.nodes[i].children_count) : (j +%= 1) { + if (!(data.*.nodes[i].children[j] != null) or (@as(cgltf_size, @intCast(@intFromPtr(data.*.nodes[i].children[j]))) > data.*.nodes_count)) { + return -@as(c_int, 1); + } + data.*.nodes[i].children[j] = &data.*.nodes[@as(cgltf_size, @intCast(@intFromPtr(data.*.nodes[i].children[j]))) -% @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 1))))]; + if (data.*.nodes[i].children[j].*.parent != null) { + return -@as(c_int, 1); + } + data.*.nodes[i].children[j].*.parent = &data.*.nodes[i]; + } + } + if (data.*.nodes[i].mesh != null) { + if (@as(cgltf_size, @intCast(@intFromPtr(data.*.nodes[i].mesh))) > data.*.meshes_count) { + return -@as(c_int, 1); + } + data.*.nodes[i].mesh = &data.*.meshes[@as(cgltf_size, @intCast(@intFromPtr(data.*.nodes[i].mesh))) -% @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 1))))]; + } + if (data.*.nodes[i].skin != null) { + if (@as(cgltf_size, @intCast(@intFromPtr(data.*.nodes[i].skin))) > data.*.skins_count) { + return -@as(c_int, 1); + } + data.*.nodes[i].skin = &data.*.skins[@as(cgltf_size, @intCast(@intFromPtr(data.*.nodes[i].skin))) -% @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 1))))]; + } + if (data.*.nodes[i].camera != null) { + if (@as(cgltf_size, @intCast(@intFromPtr(data.*.nodes[i].camera))) > data.*.cameras_count) { + return -@as(c_int, 1); + } + data.*.nodes[i].camera = &data.*.cameras[@as(cgltf_size, @intCast(@intFromPtr(data.*.nodes[i].camera))) -% @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 1))))]; + } + if (data.*.nodes[i].light != null) { + if (@as(cgltf_size, @intCast(@intFromPtr(data.*.nodes[i].light))) > data.*.lights_count) { + return -@as(c_int, 1); + } + data.*.nodes[i].light = &data.*.lights[@as(cgltf_size, @intCast(@intFromPtr(data.*.nodes[i].light))) -% @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 1))))]; + } + if (data.*.nodes[i].has_mesh_gpu_instancing != 0) { + { + var m: cgltf_size = 0; + _ = &m; + while (m < data.*.nodes[i].mesh_gpu_instancing.attributes_count) : (m +%= 1) { + if (!(data.*.nodes[i].mesh_gpu_instancing.attributes[m].data != null) or (@as(cgltf_size, @intCast(@intFromPtr(data.*.nodes[i].mesh_gpu_instancing.attributes[m].data))) > data.*.accessors_count)) { + return -@as(c_int, 1); + } + data.*.nodes[i].mesh_gpu_instancing.attributes[m].data = &data.*.accessors[@as(cgltf_size, @intCast(@intFromPtr(data.*.nodes[i].mesh_gpu_instancing.attributes[m].data))) -% @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 1))))]; + } + } + } + } + } + { + var i: cgltf_size = 0; + _ = &i; + while (i < data.*.scenes_count) : (i +%= 1) { + { + var j: cgltf_size = 0; + _ = &j; + while (j < data.*.scenes[i].nodes_count) : (j +%= 1) { + if (!(data.*.scenes[i].nodes[j] != null) or (@as(cgltf_size, @intCast(@intFromPtr(data.*.scenes[i].nodes[j]))) > data.*.nodes_count)) { + return -@as(c_int, 1); + } + data.*.scenes[i].nodes[j] = &data.*.nodes[@as(cgltf_size, @intCast(@intFromPtr(data.*.scenes[i].nodes[j]))) -% @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 1))))]; + if (data.*.scenes[i].nodes[j].*.parent != null) { + return -@as(c_int, 1); + } + } + } + } + } + if (data.*.scene != null) { + if (@as(cgltf_size, @intCast(@intFromPtr(data.*.scene))) > data.*.scenes_count) { + return -@as(c_int, 1); + } + data.*.scene = &data.*.scenes[@as(cgltf_size, @intCast(@intFromPtr(data.*.scene))) -% @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 1))))]; + } + { + var i: cgltf_size = 0; + _ = &i; + while (i < data.*.animations_count) : (i +%= 1) { + { + var j: cgltf_size = 0; + _ = &j; + while (j < data.*.animations[i].samplers_count) : (j +%= 1) { + if (!(data.*.animations[i].samplers[j].input != null) or (@as(cgltf_size, @intCast(@intFromPtr(data.*.animations[i].samplers[j].input))) > data.*.accessors_count)) { + return -@as(c_int, 1); + } + data.*.animations[i].samplers[j].input = &data.*.accessors[@as(cgltf_size, @intCast(@intFromPtr(data.*.animations[i].samplers[j].input))) -% @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 1))))]; + if (!(data.*.animations[i].samplers[j].output != null) or (@as(cgltf_size, @intCast(@intFromPtr(data.*.animations[i].samplers[j].output))) > data.*.accessors_count)) { + return -@as(c_int, 1); + } + data.*.animations[i].samplers[j].output = &data.*.accessors[@as(cgltf_size, @intCast(@intFromPtr(data.*.animations[i].samplers[j].output))) -% @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 1))))]; + } + } + { + var j: cgltf_size = 0; + _ = &j; + while (j < data.*.animations[i].channels_count) : (j +%= 1) { + if (!(data.*.animations[i].channels[j].sampler != null) or (@as(cgltf_size, @intCast(@intFromPtr(data.*.animations[i].channels[j].sampler))) > data.*.animations[i].samplers_count)) { + return -@as(c_int, 1); + } + data.*.animations[i].channels[j].sampler = &data.*.animations[i].samplers[@as(cgltf_size, @intCast(@intFromPtr(data.*.animations[i].channels[j].sampler))) -% @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 1))))]; + if (data.*.animations[i].channels[j].target_node != null) { + if (@as(cgltf_size, @intCast(@intFromPtr(data.*.animations[i].channels[j].target_node))) > data.*.nodes_count) { + return -@as(c_int, 1); + } + data.*.animations[i].channels[j].target_node = &data.*.nodes[@as(cgltf_size, @intCast(@intFromPtr(data.*.animations[i].channels[j].target_node))) -% @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 1))))]; + } + } + } + } + } + return 0; +} +pub fn cgltf_parse_json_root(arg_options: [*c]cgltf_options, arg_tokens: [*c]const jsmntok_t, arg_i: c_int, arg_json_chunk: [*c]const u8, arg_out_data: [*c]cgltf_data) callconv(.C) c_int { + var options = arg_options; + _ = &options; + var tokens = arg_tokens; + _ = &tokens; + var i = arg_i; + _ = &i; + var json_chunk = arg_json_chunk; + _ = &json_chunk; + var out_data = arg_out_data; + _ = &out_data; + if ((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.type != @as(c_uint, @bitCast(JSMN_OBJECT))) { + return -@as(c_int, 1); + } + var size: c_int = (blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.size; + _ = &size; + i += 1; + { + var j: c_int = 0; + _ = &j; + while (j < size) : (j += 1) { + if (((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.type != @as(c_uint, @bitCast(JSMN_STRING))) or ((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.size == @as(c_int, 0))) { + return -@as(c_int, 1); + } + if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "asset") == @as(c_int, 0)) { + i = cgltf_parse_json_asset(options, tokens, i + @as(c_int, 1), json_chunk, &out_data.*.asset); + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "meshes") == @as(c_int, 0)) { + i = cgltf_parse_json_meshes(options, tokens, i + @as(c_int, 1), json_chunk, out_data); + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "accessors") == @as(c_int, 0)) { + i = cgltf_parse_json_accessors(options, tokens, i + @as(c_int, 1), json_chunk, out_data); + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "bufferViews") == @as(c_int, 0)) { + i = cgltf_parse_json_buffer_views(options, tokens, i + @as(c_int, 1), json_chunk, out_data); + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "buffers") == @as(c_int, 0)) { + i = cgltf_parse_json_buffers(options, tokens, i + @as(c_int, 1), json_chunk, out_data); + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "materials") == @as(c_int, 0)) { + i = cgltf_parse_json_materials(options, tokens, i + @as(c_int, 1), json_chunk, out_data); + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "images") == @as(c_int, 0)) { + i = cgltf_parse_json_images(options, tokens, i + @as(c_int, 1), json_chunk, out_data); + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "textures") == @as(c_int, 0)) { + i = cgltf_parse_json_textures(options, tokens, i + @as(c_int, 1), json_chunk, out_data); + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "samplers") == @as(c_int, 0)) { + i = cgltf_parse_json_samplers(options, tokens, i + @as(c_int, 1), json_chunk, out_data); + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "skins") == @as(c_int, 0)) { + i = cgltf_parse_json_skins(options, tokens, i + @as(c_int, 1), json_chunk, out_data); + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "cameras") == @as(c_int, 0)) { + i = cgltf_parse_json_cameras(options, tokens, i + @as(c_int, 1), json_chunk, out_data); + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "nodes") == @as(c_int, 0)) { + i = cgltf_parse_json_nodes(options, tokens, i + @as(c_int, 1), json_chunk, out_data); + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "scenes") == @as(c_int, 0)) { + i = cgltf_parse_json_scenes(options, tokens, i + @as(c_int, 1), json_chunk, out_data); + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "scene") == @as(c_int, 0)) { + i += 1; + out_data.*.scene = @as([*c]cgltf_scene, @ptrFromInt(@as(cgltf_size, @bitCast(@as(c_long, cgltf_json_to_int(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk)))) +% @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 1)))))); + i += 1; + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "animations") == @as(c_int, 0)) { + i = cgltf_parse_json_animations(options, tokens, i + @as(c_int, 1), json_chunk, out_data); + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "extras") == @as(c_int, 0)) { + i = cgltf_parse_json_extras(options, tokens, i + @as(c_int, 1), json_chunk, &out_data.*.extras); + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "extensions") == @as(c_int, 0)) { + i += 1; + if ((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.type != @as(c_uint, @bitCast(JSMN_OBJECT))) { + return -@as(c_int, 1); + } + if (out_data.*.data_extensions != null) { + return -@as(c_int, 1); + } + var extensions_size: c_int = (blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.size; + _ = &extensions_size; + out_data.*.data_extensions_count = 0; + out_data.*.data_extensions = @as([*c]cgltf_extension, @ptrCast(@alignCast(cgltf_calloc(options, @sizeOf(cgltf_extension), @as(cgltf_size, @bitCast(@as(c_long, extensions_size))))))); + if (!(out_data.*.data_extensions != null)) { + return -@as(c_int, 2); + } + i += 1; + { + var k: c_int = 0; + _ = &k; + while (k < extensions_size) : (k += 1) { + if (((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.type != @as(c_uint, @bitCast(JSMN_STRING))) or ((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.size == @as(c_int, 0))) { + return -@as(c_int, 1); + } + if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "KHR_lights_punctual") == @as(c_int, 0)) { + i += 1; + if ((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.type != @as(c_uint, @bitCast(JSMN_OBJECT))) { + return -@as(c_int, 1); + } + var data_size: c_int = (blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.size; + _ = &data_size; + i += 1; + { + var m: c_int = 0; + _ = &m; + while (m < data_size) : (m += 1) { + if (((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.type != @as(c_uint, @bitCast(JSMN_STRING))) or ((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.size == @as(c_int, 0))) { + return -@as(c_int, 1); + } + if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "lights") == @as(c_int, 0)) { + i = cgltf_parse_json_lights(options, tokens, i + @as(c_int, 1), json_chunk, out_data); + } else { + i = cgltf_skip_json(tokens, i + @as(c_int, 1)); + } + if (i < @as(c_int, 0)) { + return i; + } + } + } + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "KHR_materials_variants") == @as(c_int, 0)) { + i += 1; + if ((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.type != @as(c_uint, @bitCast(JSMN_OBJECT))) { + return -@as(c_int, 1); + } + var data_size: c_int = (blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.size; + _ = &data_size; + i += 1; + { + var m: c_int = 0; + _ = &m; + while (m < data_size) : (m += 1) { + if (((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.type != @as(c_uint, @bitCast(JSMN_STRING))) or ((blk: { + const tmp = i; + if (tmp >= 0) break :blk tokens + @as(usize, @intCast(tmp)) else break :blk tokens - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.size == @as(c_int, 0))) { + return -@as(c_int, 1); + } + if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "variants") == @as(c_int, 0)) { + i = cgltf_parse_json_variants(options, tokens, i + @as(c_int, 1), json_chunk, out_data); + } else { + i = cgltf_skip_json(tokens, i + @as(c_int, 1)); + } + if (i < @as(c_int, 0)) { + return i; + } + } + } + } else { + i = cgltf_parse_json_unprocessed_extension(options, tokens, i, json_chunk, &out_data.*.data_extensions[blk: { + const ref = &out_data.*.data_extensions_count; + const tmp = ref.*; + ref.* +%= 1; + break :blk tmp; + }]); + } + if (i < @as(c_int, 0)) { + return i; + } + } + } + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "extensionsUsed") == @as(c_int, 0)) { + i = cgltf_parse_json_string_array(options, tokens, i + @as(c_int, 1), json_chunk, &out_data.*.extensions_used, &out_data.*.extensions_used_count); + } else if (cgltf_json_strcmp(tokens + @as(usize, @bitCast(@as(isize, @intCast(i)))), json_chunk, "extensionsRequired") == @as(c_int, 0)) { + i = cgltf_parse_json_string_array(options, tokens, i + @as(c_int, 1), json_chunk, &out_data.*.extensions_required, &out_data.*.extensions_required_count); + } else { + i = cgltf_skip_json(tokens, i + @as(c_int, 1)); + } + if (i < @as(c_int, 0)) { + return i; + } + } + } + return i; +} +pub fn jsmn_alloc_token(arg_parser: [*c]jsmn_parser, arg_tokens: [*c]jsmntok_t, arg_num_tokens: usize) callconv(.C) [*c]jsmntok_t { + var parser = arg_parser; + _ = &parser; + var tokens = arg_tokens; + _ = &tokens; + var num_tokens = arg_num_tokens; + _ = &num_tokens; + var tok: [*c]jsmntok_t = undefined; + _ = &tok; + if (@as(usize, @bitCast(@as(c_ulong, parser.*.toknext))) >= num_tokens) { + return null; + } + tok = &tokens[blk: { + const ref = &parser.*.toknext; + const tmp = ref.*; + ref.* +%= 1; + break :blk tmp; + }]; + tok.*.start = blk: { + const tmp = @as(ptrdiff_t, @bitCast(@as(c_long, -@as(c_int, 1)))); + tok.*.end = tmp; + break :blk tmp; + }; + tok.*.size = 0; + tok.*.parent = -@as(c_int, 1); + return tok; +} +pub fn jsmn_fill_token(arg_token: [*c]jsmntok_t, arg_type: jsmntype_t, arg_start: ptrdiff_t, arg_end: ptrdiff_t) callconv(.C) void { + var token = arg_token; + _ = &token; + var @"type" = arg_type; + _ = &@"type"; + var start = arg_start; + _ = &start; + var end = arg_end; + _ = &end; + token.*.type = @"type"; + token.*.start = start; + token.*.end = end; + token.*.size = 0; +} +// ./external/cgltf.h:6746:4: warning: TODO implement translation of stmt class GotoStmtClass + +// ./external/cgltf.h:6731:12: warning: unable to translate function, demoted to extern +pub extern fn jsmn_parse_primitive(arg_parser: [*c]jsmn_parser, arg_js: [*c]const u8, arg_len: usize, arg_tokens: [*c]jsmntok_t, arg_num_tokens: usize) callconv(.C) c_int; +pub fn jsmn_parse_string(arg_parser: [*c]jsmn_parser, arg_js: [*c]const u8, arg_len: usize, arg_tokens: [*c]jsmntok_t, arg_num_tokens: usize) callconv(.C) c_int { + var parser = arg_parser; + _ = &parser; + var js = arg_js; + _ = &js; + var len = arg_len; + _ = &len; + var tokens = arg_tokens; + _ = &tokens; + var num_tokens = arg_num_tokens; + _ = &num_tokens; + var token: [*c]jsmntok_t = undefined; + _ = &token; + var start: ptrdiff_t = @as(ptrdiff_t, @bitCast(parser.*.pos)); + _ = &start; + parser.*.pos +%= 1; + while ((parser.*.pos < len) and (@as(c_int, @bitCast(@as(c_uint, js[parser.*.pos]))) != @as(c_int, '\x00'))) : (parser.*.pos +%= 1) { + var c: u8 = js[parser.*.pos]; + _ = &c; + if (@as(c_int, @bitCast(@as(c_uint, c))) == @as(c_int, '"')) { + if (tokens == @as([*c]jsmntok_t, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0))))))) { + return 0; + } + token = jsmn_alloc_token(parser, tokens, num_tokens); + if (token == @as([*c]jsmntok_t, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0))))))) { + parser.*.pos = @as(usize, @bitCast(start)); + return JSMN_ERROR_NOMEM; + } + jsmn_fill_token(token, @as(c_uint, @bitCast(JSMN_STRING)), start + @as(ptrdiff_t, @bitCast(@as(c_long, @as(c_int, 1)))), @as(ptrdiff_t, @bitCast(parser.*.pos))); + token.*.parent = parser.*.toksuper; + return 0; + } + if ((@as(c_int, @bitCast(@as(c_uint, c))) == @as(c_int, '\\')) and ((parser.*.pos +% @as(usize, @bitCast(@as(c_long, @as(c_int, 1))))) < len)) { + var i: c_int = undefined; + _ = &i; + parser.*.pos +%= 1; + while (true) { + switch (@as(c_int, @bitCast(@as(c_uint, js[parser.*.pos])))) { + @as(c_int, 34), @as(c_int, 47), @as(c_int, 92), @as(c_int, 98), @as(c_int, 102), @as(c_int, 114), @as(c_int, 110), @as(c_int, 116) => break, + @as(c_int, 117) => { + parser.*.pos +%= 1; + { + i = 0; + while (((i < @as(c_int, 4)) and (parser.*.pos < len)) and (@as(c_int, @bitCast(@as(c_uint, js[parser.*.pos]))) != @as(c_int, '\x00'))) : (i += 1) { + if (!((((@as(c_int, @bitCast(@as(c_uint, js[parser.*.pos]))) >= @as(c_int, 48)) and (@as(c_int, @bitCast(@as(c_uint, js[parser.*.pos]))) <= @as(c_int, 57))) or ((@as(c_int, @bitCast(@as(c_uint, js[parser.*.pos]))) >= @as(c_int, 65)) and (@as(c_int, @bitCast(@as(c_uint, js[parser.*.pos]))) <= @as(c_int, 70)))) or ((@as(c_int, @bitCast(@as(c_uint, js[parser.*.pos]))) >= @as(c_int, 97)) and (@as(c_int, @bitCast(@as(c_uint, js[parser.*.pos]))) <= @as(c_int, 102))))) { + parser.*.pos = @as(usize, @bitCast(start)); + return JSMN_ERROR_INVAL; + } + parser.*.pos +%= 1; + } + } + parser.*.pos -%= 1; + break; + }, + else => { + parser.*.pos = @as(usize, @bitCast(start)); + return JSMN_ERROR_INVAL; + }, + } + break; + } + } + } + parser.*.pos = @as(usize, @bitCast(start)); + return JSMN_ERROR_PART; +} +pub const VoxColor = extern struct { + r: u8 = @import("std").mem.zeroes(u8), + g: u8 = @import("std").mem.zeroes(u8), + b: u8 = @import("std").mem.zeroes(u8), + a: u8 = @import("std").mem.zeroes(u8), +}; +pub const VoxVector3 = extern struct { + x: f32 = @import("std").mem.zeroes(f32), + y: f32 = @import("std").mem.zeroes(f32), + z: f32 = @import("std").mem.zeroes(f32), +}; +pub const ArrayVector3 = extern struct { + array: [*c]VoxVector3 = @import("std").mem.zeroes([*c]VoxVector3), + used: c_int = @import("std").mem.zeroes(c_int), + size: c_int = @import("std").mem.zeroes(c_int), +}; +pub const ArrayColor = extern struct { + array: [*c]VoxColor = @import("std").mem.zeroes([*c]VoxColor), + used: c_int = @import("std").mem.zeroes(c_int), + size: c_int = @import("std").mem.zeroes(c_int), +}; +pub const ArrayUShort = extern struct { + array: [*c]c_ushort = @import("std").mem.zeroes([*c]c_ushort), + used: c_int = @import("std").mem.zeroes(c_int), + size: c_int = @import("std").mem.zeroes(c_int), +}; +pub const CubeChunk3D = extern struct { + m_array: [*c]u8 = @import("std").mem.zeroes([*c]u8), + arraySize: c_int = @import("std").mem.zeroes(c_int), +}; +pub const VoxArray3D = extern struct { + sizeX: c_int = @import("std").mem.zeroes(c_int), + sizeY: c_int = @import("std").mem.zeroes(c_int), + sizeZ: c_int = @import("std").mem.zeroes(c_int), + chunksSizeX: c_int = @import("std").mem.zeroes(c_int), + chunksSizeY: c_int = @import("std").mem.zeroes(c_int), + chunksSizeZ: c_int = @import("std").mem.zeroes(c_int), + m_arrayChunks: [*c]CubeChunk3D = @import("std").mem.zeroes([*c]CubeChunk3D), + arrayChunksSize: c_int = @import("std").mem.zeroes(c_int), + ChunkFlattenOffset: c_int = @import("std").mem.zeroes(c_int), + chunksAllocated: c_int = @import("std").mem.zeroes(c_int), + chunksTotal: c_int = @import("std").mem.zeroes(c_int), + vertices: ArrayVector3 = @import("std").mem.zeroes(ArrayVector3), + normals: ArrayVector3 = @import("std").mem.zeroes(ArrayVector3), + indices: ArrayUShort = @import("std").mem.zeroes(ArrayUShort), + colors: ArrayColor = @import("std").mem.zeroes(ArrayColor), + palette: [256]VoxColor = @import("std").mem.zeroes([256]VoxColor), +}; +pub export fn Vox_LoadFromMemory(arg_pvoxData: [*c]u8, arg_voxDataSize: c_uint, arg_pvoxarray: [*c]VoxArray3D) c_int { + var pvoxData = arg_pvoxData; + _ = &pvoxData; + var voxDataSize = arg_voxDataSize; + _ = &voxDataSize; + var pvoxarray = arg_pvoxarray; + _ = &pvoxarray; + var fileData: [*c]u8 = pvoxData; + _ = &fileData; + var fileDataPtr: [*c]u8 = fileData; + _ = &fileDataPtr; + var endfileDataPtr: [*c]u8 = fileData + voxDataSize; + _ = &endfileDataPtr; + if (strncmp(@as([*c]u8, @ptrCast(@alignCast(fileDataPtr))), "VOX ", @as(c_ulong, @bitCast(@as(c_long, @as(c_int, 4))))) != @as(c_int, 0)) { + return -@as(c_int, 2); + } + fileDataPtr += @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 4))))); + var version: c_uint = 0; + _ = &version; + version = @as([*c]c_uint, @ptrCast(@alignCast(fileDataPtr)))[@as(c_uint, @intCast(@as(c_int, 0)))]; + fileDataPtr += @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 4))))); + if ((version != @as(c_uint, @bitCast(@as(c_int, 150)))) and (version != @as(c_uint, @bitCast(@as(c_int, 200))))) { + return -@as(c_int, 3); + } + var sizeX: c_uint = undefined; + _ = &sizeX; + var sizeY: c_uint = undefined; + _ = &sizeY; + var sizeZ: c_uint = undefined; + _ = &sizeZ; + sizeX = blk: { + const tmp = blk_1: { + const tmp_2 = @as(c_uint, @bitCast(@as(c_int, 0))); + sizeZ = tmp_2; + break :blk_1 tmp_2; + }; + sizeY = tmp; + break :blk tmp; + }; + var numVoxels: c_uint = 0; + _ = &numVoxels; + while (fileDataPtr < endfileDataPtr) { + var szChunkName: [5]u8 = undefined; + _ = &szChunkName; + _ = memcpy(@as(?*anyopaque, @ptrCast(@as([*c]u8, @ptrCast(@alignCast(&szChunkName))))), @as(?*const anyopaque, @ptrCast(fileDataPtr)), @as(c_ulong, @bitCast(@as(c_long, @as(c_int, 4))))); + szChunkName[@as(c_uint, @intCast(@as(c_int, 4)))] = 0; + fileDataPtr += @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 4))))); + var chunkSize: c_uint = @as([*c]c_uint, @ptrCast(@alignCast(fileDataPtr))).*; + _ = &chunkSize; + fileDataPtr += @as([*c]u8, @ptrFromInt(@sizeOf(c_uint))); + fileDataPtr += @as([*c]u8, @ptrFromInt(@sizeOf(c_uint))); + if (strcmp(@as([*c]u8, @ptrCast(@alignCast(&szChunkName))), "SIZE") == @as(c_int, 0)) { + sizeX = @as([*c]c_uint, @ptrCast(@alignCast(fileDataPtr))).*; + fileDataPtr += @as([*c]u8, @ptrFromInt(@sizeOf(c_uint))); + sizeY = @as([*c]c_uint, @ptrCast(@alignCast(fileDataPtr))).*; + fileDataPtr += @as([*c]u8, @ptrFromInt(@sizeOf(c_uint))); + sizeZ = @as([*c]c_uint, @ptrCast(@alignCast(fileDataPtr))).*; + fileDataPtr += @as([*c]u8, @ptrFromInt(@sizeOf(c_uint))); + Vox_AllocArray(pvoxarray, @as(c_int, @bitCast(sizeX)), @as(c_int, @bitCast(sizeZ)), @as(c_int, @bitCast(sizeY))); + } else if (strcmp(@as([*c]u8, @ptrCast(@alignCast(&szChunkName))), "XYZI") == @as(c_int, 0)) { + var vx: u8 = undefined; + _ = &vx; + var vy: u8 = undefined; + _ = &vy; + var vz: u8 = undefined; + _ = &vz; + var vi: u8 = undefined; + _ = &vi; + numVoxels = @as([*c]c_uint, @ptrCast(@alignCast(fileDataPtr))).*; + fileDataPtr += @as([*c]u8, @ptrFromInt(@sizeOf(c_uint))); + while (numVoxels > @as(c_uint, @bitCast(@as(c_int, 0)))) { + vx = (blk: { + const ref = &fileDataPtr; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).*; + vy = (blk: { + const ref = &fileDataPtr; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).*; + vz = (blk: { + const ref = &fileDataPtr; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).*; + vi = (blk: { + const ref = &fileDataPtr; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).*; + Vox_SetVoxel(pvoxarray, @as(c_int, @bitCast(@as(c_uint, vx))), @as(c_int, @bitCast(@as(c_uint, vz))), (pvoxarray.*.sizeZ - @as(c_int, @bitCast(@as(c_uint, vy)))) - @as(c_int, 1), vi); + numVoxels -%= 1; + } + } else if (strcmp(@as([*c]u8, @ptrCast(@alignCast(&szChunkName))), "RGBA") == @as(c_int, 0)) { + var col: VoxColor = undefined; + _ = &col; + { + var i: c_int = 0; + _ = &i; + while (i < (@as(c_int, 256) - @as(c_int, 1))) : (i += 1) { + col.r = (blk: { + const ref = &fileDataPtr; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).*; + col.g = (blk: { + const ref = &fileDataPtr; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).*; + col.b = (blk: { + const ref = &fileDataPtr; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).*; + col.a = (blk: { + const ref = &fileDataPtr; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).*; + pvoxarray.*.palette[@as(c_uint, @intCast(i + @as(c_int, 1)))] = col; + } + } + } else { + fileDataPtr += @as([*c]u8, @ptrFromInt(chunkSize)); + } + } + initArrayVector3(&pvoxarray.*.vertices, @as(c_int, 3) * @as(c_int, 1024)); + initArrayVector3(&pvoxarray.*.normals, @as(c_int, 3) * @as(c_int, 1024)); + initArrayUShort(&pvoxarray.*.indices, @as(c_int, 3) * @as(c_int, 1024)); + initArrayColor(&pvoxarray.*.colors, @as(c_int, 3) * @as(c_int, 1024)); + var x: c_int = undefined; + _ = &x; + var y: c_int = undefined; + _ = &y; + var z: c_int = undefined; + _ = &z; + { + x = 0; + while (x <= pvoxarray.*.sizeX) : (x += 1) { + { + z = 0; + while (z <= pvoxarray.*.sizeZ) : (z += 1) { + { + y = 0; + while (y <= pvoxarray.*.sizeY) : (y += 1) { + var matID: u8 = Vox_GetVoxel(pvoxarray, x, y, z); + _ = &matID; + if (@as(c_int, @bitCast(@as(c_uint, matID))) != @as(c_int, 0)) { + Vox_Build_Voxel(pvoxarray, x, y, z, @as(c_int, @bitCast(@as(c_uint, matID)))); + } + } + } + } + } + } + } + return @as(c_int, 0); +} +pub export fn Vox_FreeArrays(arg_voxarray: [*c]VoxArray3D) void { + var voxarray = arg_voxarray; + _ = &voxarray; + if (voxarray.*.m_arrayChunks != null) { + { + var i: c_int = 0; + _ = &i; + while (i < voxarray.*.chunksTotal) : (i += 1) { + var chunk: [*c]CubeChunk3D = &(blk: { + const tmp = i; + if (tmp >= 0) break :blk voxarray.*.m_arrayChunks + @as(usize, @intCast(tmp)) else break :blk voxarray.*.m_arrayChunks - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*; + _ = &chunk; + if (chunk.*.m_array != null) { + chunk.*.arraySize = 0; + free(@as(?*anyopaque, @ptrCast(chunk.*.m_array))); + } + } + } + free(@as(?*anyopaque, @ptrCast(voxarray.*.m_arrayChunks))); + voxarray.*.m_arrayChunks = null; + voxarray.*.arrayChunksSize = 0; + voxarray.*.chunksSizeX = blk: { + const tmp = blk_1: { + const tmp_2 = @as(c_int, 0); + voxarray.*.chunksSizeZ = tmp_2; + break :blk_1 tmp_2; + }; + voxarray.*.chunksSizeY = tmp; + break :blk tmp; + }; + voxarray.*.chunksTotal = 0; + voxarray.*.chunksAllocated = 0; + voxarray.*.ChunkFlattenOffset = 0; + voxarray.*.sizeX = blk: { + const tmp = blk_1: { + const tmp_2 = @as(c_int, 0); + voxarray.*.sizeZ = tmp_2; + break :blk_1 tmp_2; + }; + voxarray.*.sizeY = tmp; + break :blk tmp; + }; + } + freeArrayVector3(&voxarray.*.vertices); + freeArrayUShort(&voxarray.*.indices); + freeArrayColor(&voxarray.*.colors); +} +pub fn initArrayUShort(arg_a: [*c]ArrayUShort, arg_initialSize: c_int) callconv(.C) void { + var a = arg_a; + _ = &a; + var initialSize = arg_initialSize; + _ = &initialSize; + a.*.array = @as([*c]c_ushort, @ptrCast(@alignCast(malloc(@as(c_ulong, @bitCast(@as(c_long, initialSize))) *% @sizeOf(c_ushort))))); + a.*.used = 0; + a.*.size = initialSize; +} +pub fn insertArrayUShort(arg_a: [*c]ArrayUShort, arg_element: c_ushort) callconv(.C) void { + var a = arg_a; + _ = &a; + var element = arg_element; + _ = &element; + if (a.*.used == a.*.size) { + a.*.size *= @as(c_int, 2); + a.*.array = @as([*c]c_ushort, @ptrCast(@alignCast(realloc(@as(?*anyopaque, @ptrCast(a.*.array)), @as(c_ulong, @bitCast(@as(c_long, a.*.size))) *% @sizeOf(c_ushort))))); + } + (blk: { + const tmp = blk_1: { + const ref = &a.*.used; + const tmp_2 = ref.*; + ref.* += 1; + break :blk_1 tmp_2; + }; + if (tmp >= 0) break :blk a.*.array + @as(usize, @intCast(tmp)) else break :blk a.*.array - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = element; +} +pub fn freeArrayUShort(arg_a: [*c]ArrayUShort) callconv(.C) void { + var a = arg_a; + _ = &a; + free(@as(?*anyopaque, @ptrCast(a.*.array))); + a.*.array = null; + a.*.used = blk: { + const tmp = @as(c_int, 0); + a.*.size = tmp; + break :blk tmp; + }; +} +pub fn initArrayVector3(arg_a: [*c]ArrayVector3, arg_initialSize: c_int) callconv(.C) void { + var a = arg_a; + _ = &a; + var initialSize = arg_initialSize; + _ = &initialSize; + a.*.array = @as([*c]VoxVector3, @ptrCast(@alignCast(malloc(@as(c_ulong, @bitCast(@as(c_long, initialSize))) *% @sizeOf(VoxVector3))))); + a.*.used = 0; + a.*.size = initialSize; +} +pub fn insertArrayVector3(arg_a: [*c]ArrayVector3, arg_element: VoxVector3) callconv(.C) void { + var a = arg_a; + _ = &a; + var element = arg_element; + _ = &element; + if (a.*.used == a.*.size) { + a.*.size *= @as(c_int, 2); + a.*.array = @as([*c]VoxVector3, @ptrCast(@alignCast(realloc(@as(?*anyopaque, @ptrCast(a.*.array)), @as(c_ulong, @bitCast(@as(c_long, a.*.size))) *% @sizeOf(VoxVector3))))); + } + (blk: { + const tmp = blk_1: { + const ref = &a.*.used; + const tmp_2 = ref.*; + ref.* += 1; + break :blk_1 tmp_2; + }; + if (tmp >= 0) break :blk a.*.array + @as(usize, @intCast(tmp)) else break :blk a.*.array - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = element; +} +pub fn freeArrayVector3(arg_a: [*c]ArrayVector3) callconv(.C) void { + var a = arg_a; + _ = &a; + free(@as(?*anyopaque, @ptrCast(a.*.array))); + a.*.array = null; + a.*.used = blk: { + const tmp = @as(c_int, 0); + a.*.size = tmp; + break :blk tmp; + }; +} +pub fn initArrayColor(arg_a: [*c]ArrayColor, arg_initialSize: c_int) callconv(.C) void { + var a = arg_a; + _ = &a; + var initialSize = arg_initialSize; + _ = &initialSize; + a.*.array = @as([*c]VoxColor, @ptrCast(@alignCast(malloc(@as(c_ulong, @bitCast(@as(c_long, initialSize))) *% @sizeOf(VoxColor))))); + a.*.used = 0; + a.*.size = initialSize; +} +pub fn insertArrayColor(arg_a: [*c]ArrayColor, arg_element: VoxColor) callconv(.C) void { + var a = arg_a; + _ = &a; + var element = arg_element; + _ = &element; + if (a.*.used == a.*.size) { + a.*.size *= @as(c_int, 2); + a.*.array = @as([*c]VoxColor, @ptrCast(@alignCast(realloc(@as(?*anyopaque, @ptrCast(a.*.array)), @as(c_ulong, @bitCast(@as(c_long, a.*.size))) *% @sizeOf(VoxColor))))); + } + (blk: { + const tmp = blk_1: { + const ref = &a.*.used; + const tmp_2 = ref.*; + ref.* += 1; + break :blk_1 tmp_2; + }; + if (tmp >= 0) break :blk a.*.array + @as(usize, @intCast(tmp)) else break :blk a.*.array - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = element; +} +pub fn freeArrayColor(arg_a: [*c]ArrayColor) callconv(.C) void { + var a = arg_a; + _ = &a; + free(@as(?*anyopaque, @ptrCast(a.*.array))); + a.*.array = null; + a.*.used = blk: { + const tmp = @as(c_int, 0); + a.*.size = tmp; + break :blk tmp; + }; +} +pub export const fv: [6][4]c_int = [6][4]c_int{ + [4]c_int{ + 0, + 2, + 6, + 4, + }, + [4]c_int{ + 5, + 7, + 3, + 1, + }, + [4]c_int{ + 0, + 4, + 5, + 1, + }, + [4]c_int{ + 6, + 2, + 3, + 7, + }, + [4]c_int{ + 1, + 3, + 2, + 0, + }, + [4]c_int{ + 4, + 6, + 7, + 5, + }, +}; +pub export const SolidVertex: [8]VoxVector3 = [8]VoxVector3{ + VoxVector3{ + .x = @as(f32, @floatFromInt(@as(c_int, 0))), + .y = @as(f32, @floatFromInt(@as(c_int, 0))), + .z = @as(f32, @floatFromInt(@as(c_int, 0))), + }, + VoxVector3{ + .x = @as(f32, @floatFromInt(@as(c_int, 1))), + .y = @as(f32, @floatFromInt(@as(c_int, 0))), + .z = @as(f32, @floatFromInt(@as(c_int, 0))), + }, + VoxVector3{ + .x = @as(f32, @floatFromInt(@as(c_int, 0))), + .y = @as(f32, @floatFromInt(@as(c_int, 1))), + .z = @as(f32, @floatFromInt(@as(c_int, 0))), + }, + VoxVector3{ + .x = @as(f32, @floatFromInt(@as(c_int, 1))), + .y = @as(f32, @floatFromInt(@as(c_int, 1))), + .z = @as(f32, @floatFromInt(@as(c_int, 0))), + }, + VoxVector3{ + .x = @as(f32, @floatFromInt(@as(c_int, 0))), + .y = @as(f32, @floatFromInt(@as(c_int, 0))), + .z = @as(f32, @floatFromInt(@as(c_int, 1))), + }, + VoxVector3{ + .x = @as(f32, @floatFromInt(@as(c_int, 1))), + .y = @as(f32, @floatFromInt(@as(c_int, 0))), + .z = @as(f32, @floatFromInt(@as(c_int, 1))), + }, + VoxVector3{ + .x = @as(f32, @floatFromInt(@as(c_int, 0))), + .y = @as(f32, @floatFromInt(@as(c_int, 1))), + .z = @as(f32, @floatFromInt(@as(c_int, 1))), + }, + VoxVector3{ + .x = @as(f32, @floatFromInt(@as(c_int, 1))), + .y = @as(f32, @floatFromInt(@as(c_int, 1))), + .z = @as(f32, @floatFromInt(@as(c_int, 1))), + }, +}; +pub export const FacesPerSideNormal: [6]VoxVector3 = [6]VoxVector3{ + VoxVector3{ + .x = @as(f32, @floatFromInt(-@as(c_int, 1))), + .y = @as(f32, @floatFromInt(@as(c_int, 0))), + .z = @as(f32, @floatFromInt(@as(c_int, 0))), + }, + VoxVector3{ + .x = @as(f32, @floatFromInt(@as(c_int, 1))), + .y = @as(f32, @floatFromInt(@as(c_int, 0))), + .z = @as(f32, @floatFromInt(@as(c_int, 0))), + }, + VoxVector3{ + .x = @as(f32, @floatFromInt(@as(c_int, 0))), + .y = @as(f32, @floatFromInt(-@as(c_int, 1))), + .z = @as(f32, @floatFromInt(@as(c_int, 0))), + }, + VoxVector3{ + .x = @as(f32, @floatFromInt(@as(c_int, 0))), + .y = @as(f32, @floatFromInt(@as(c_int, 1))), + .z = @as(f32, @floatFromInt(@as(c_int, 0))), + }, + VoxVector3{ + .x = @as(f32, @floatFromInt(@as(c_int, 0))), + .y = @as(f32, @floatFromInt(@as(c_int, 0))), + .z = @as(f32, @floatFromInt(-@as(c_int, 1))), + }, + VoxVector3{ + .x = @as(f32, @floatFromInt(@as(c_int, 0))), + .y = @as(f32, @floatFromInt(@as(c_int, 0))), + .z = @as(f32, @floatFromInt(@as(c_int, 1))), + }, +}; +pub fn Vox_AllocArray(arg_pvoxarray: [*c]VoxArray3D, arg__sx: c_int, arg__sy: c_int, arg__sz: c_int) callconv(.C) void { + var pvoxarray = arg_pvoxarray; + _ = &pvoxarray; + var _sx = arg__sx; + _ = &_sx; + var _sy = arg__sy; + _ = &_sy; + var _sz = arg__sz; + _ = &_sz; + var sx: c_int = _sx + @import("std").zig.c_translation.signedRemainder(@as(c_int, 16) - @import("std").zig.c_translation.signedRemainder(_sx, @as(c_int, 16)), @as(c_int, 16)); + _ = &sx; + var sy: c_int = _sy + @import("std").zig.c_translation.signedRemainder(@as(c_int, 16) - @import("std").zig.c_translation.signedRemainder(_sy, @as(c_int, 16)), @as(c_int, 16)); + _ = &sy; + var sz: c_int = _sz + @import("std").zig.c_translation.signedRemainder(@as(c_int, 16) - @import("std").zig.c_translation.signedRemainder(_sz, @as(c_int, 16)), @as(c_int, 16)); + _ = &sz; + var chx: c_int = sx >> @intCast(4); + _ = &chx; + var chy: c_int = sy >> @intCast(4); + _ = &chy; + var chz: c_int = sz >> @intCast(4); + _ = &chz; + pvoxarray.*.sizeX = sx; + pvoxarray.*.sizeY = sy; + pvoxarray.*.sizeZ = sz; + pvoxarray.*.chunksSizeX = chx; + pvoxarray.*.chunksSizeY = chy; + pvoxarray.*.chunksSizeZ = chz; + pvoxarray.*.ChunkFlattenOffset = chy * chz; + var size: c_int = @as(c_int, @bitCast(@as(c_uint, @truncate(((@sizeOf(CubeChunk3D) *% @as(c_ulong, @bitCast(@as(c_long, chx)))) *% @as(c_ulong, @bitCast(@as(c_long, chy)))) *% @as(c_ulong, @bitCast(@as(c_long, chz))))))); + _ = &size; + pvoxarray.*.m_arrayChunks = @as([*c]CubeChunk3D, @ptrCast(@alignCast(malloc(@as(c_ulong, @bitCast(@as(c_long, size))))))); + pvoxarray.*.arrayChunksSize = size; + size = (chx * chy) * chz; + pvoxarray.*.chunksTotal = size; + pvoxarray.*.chunksAllocated = 0; + { + var i: c_int = 0; + _ = &i; + while (i < size) : (i += 1) { + (blk: { + const tmp = i; + if (tmp >= 0) break :blk pvoxarray.*.m_arrayChunks + @as(usize, @intCast(tmp)) else break :blk pvoxarray.*.m_arrayChunks - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.m_array = null; + (blk: { + const tmp = i; + if (tmp >= 0) break :blk pvoxarray.*.m_arrayChunks + @as(usize, @intCast(tmp)) else break :blk pvoxarray.*.m_arrayChunks - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.arraySize = 0; + } + } +} +pub fn Vox_SetVoxel(arg_pvoxarray: [*c]VoxArray3D, arg_x: c_int, arg_y: c_int, arg_z: c_int, arg_id: u8) callconv(.C) void { + var pvoxarray = arg_pvoxarray; + _ = &pvoxarray; + var x = arg_x; + _ = &x; + var y = arg_y; + _ = &y; + var z = arg_z; + _ = &z; + var id = arg_id; + _ = &id; + var chX: c_int = x >> @intCast(4); + _ = &chX; + var chY: c_int = y >> @intCast(4); + _ = &chY; + var chZ: c_int = z >> @intCast(4); + _ = &chZ; + var offset: c_int = ((chX * pvoxarray.*.ChunkFlattenOffset) + (chZ * pvoxarray.*.chunksSizeY)) + chY; + _ = &offset; + var chunk: [*c]CubeChunk3D = &(blk: { + const tmp = offset; + if (tmp >= 0) break :blk pvoxarray.*.m_arrayChunks + @as(usize, @intCast(tmp)) else break :blk pvoxarray.*.m_arrayChunks - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*; + _ = &chunk; + chX = x - (chX << @intCast(4)); + chY = y - (chY << @intCast(4)); + chZ = z - (chZ << @intCast(4)); + if (chunk.*.m_array == null) { + var size: c_int = (@as(c_int, 16) * @as(c_int, 16)) * @as(c_int, 16); + _ = &size; + chunk.*.m_array = @as([*c]u8, @ptrCast(@alignCast(malloc(@as(c_ulong, @bitCast(@as(c_long, size))))))); + chunk.*.arraySize = size; + _ = memset(@as(?*anyopaque, @ptrCast(chunk.*.m_array)), @as(c_int, 0), @as(c_ulong, @bitCast(@as(c_long, size)))); + pvoxarray.*.chunksAllocated += 1; + } + offset = ((chX << @intCast(8)) + (chZ << @intCast(4))) + chY; + (blk: { + const tmp = offset; + if (tmp >= 0) break :blk chunk.*.m_array + @as(usize, @intCast(tmp)) else break :blk chunk.*.m_array - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = id; +} +pub fn Vox_GetVoxel(arg_pvoxarray: [*c]VoxArray3D, arg_x: c_int, arg_y: c_int, arg_z: c_int) callconv(.C) u8 { + var pvoxarray = arg_pvoxarray; + _ = &pvoxarray; + var x = arg_x; + _ = &x; + var y = arg_y; + _ = &y; + var z = arg_z; + _ = &z; + if (((x < @as(c_int, 0)) or (y < @as(c_int, 0))) or (z < @as(c_int, 0))) return 0; + if (((x >= pvoxarray.*.sizeX) or (y >= pvoxarray.*.sizeY)) or (z >= pvoxarray.*.sizeZ)) return 0; + var chX: c_int = x >> @intCast(4); + _ = &chX; + var chY: c_int = y >> @intCast(4); + _ = &chY; + var chZ: c_int = z >> @intCast(4); + _ = &chZ; + var offset: c_int = ((chX * pvoxarray.*.ChunkFlattenOffset) + (chZ * pvoxarray.*.chunksSizeY)) + chY; + _ = &offset; + var chunk: [*c]CubeChunk3D = &(blk: { + const tmp = offset; + if (tmp >= 0) break :blk pvoxarray.*.m_arrayChunks + @as(usize, @intCast(tmp)) else break :blk pvoxarray.*.m_arrayChunks - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*; + _ = &chunk; + chX = x - (chX << @intCast(4)); + chY = y - (chY << @intCast(4)); + chZ = z - (chZ << @intCast(4)); + if (chunk.*.m_array == null) { + return 0; + } + offset = ((chX << @intCast(8)) + (chZ << @intCast(4))) + chY; + return (blk: { + const tmp = offset; + if (tmp >= 0) break :blk chunk.*.m_array + @as(usize, @intCast(tmp)) else break :blk chunk.*.m_array - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*; +} +pub fn Vox_CalcFacesVisible(arg_pvoxArray: [*c]VoxArray3D, arg_cx: c_int, arg_cy: c_int, arg_cz: c_int) callconv(.C) u8 { + var pvoxArray = arg_pvoxArray; + _ = &pvoxArray; + var cx = arg_cx; + _ = &cx; + var cy = arg_cy; + _ = &cy; + var cz = arg_cz; + _ = &cz; + var idXm1: u8 = Vox_GetVoxel(pvoxArray, cx - @as(c_int, 1), cy, cz); + _ = &idXm1; + var idXp1: u8 = Vox_GetVoxel(pvoxArray, cx + @as(c_int, 1), cy, cz); + _ = &idXp1; + var idYm1: u8 = Vox_GetVoxel(pvoxArray, cx, cy - @as(c_int, 1), cz); + _ = &idYm1; + var idYp1: u8 = Vox_GetVoxel(pvoxArray, cx, cy + @as(c_int, 1), cz); + _ = &idYp1; + var idZm1: u8 = Vox_GetVoxel(pvoxArray, cx, cy, cz - @as(c_int, 1)); + _ = &idZm1; + var idZp1: u8 = Vox_GetVoxel(pvoxArray, cx, cy, cz + @as(c_int, 1)); + _ = &idZp1; + var byVFMask: u8 = 0; + _ = &byVFMask; + if (@as(c_int, @bitCast(@as(c_uint, idXm1))) == @as(c_int, 0)) { + byVFMask |= @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 1) << @intCast(0))))); + } + if (@as(c_int, @bitCast(@as(c_uint, idXp1))) == @as(c_int, 0)) { + byVFMask |= @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 1) << @intCast(1))))); + } + if (@as(c_int, @bitCast(@as(c_uint, idYm1))) == @as(c_int, 0)) { + byVFMask |= @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 1) << @intCast(2))))); + } + if (@as(c_int, @bitCast(@as(c_uint, idYp1))) == @as(c_int, 0)) { + byVFMask |= @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 1) << @intCast(3))))); + } + if (@as(c_int, @bitCast(@as(c_uint, idZm1))) == @as(c_int, 0)) { + byVFMask |= @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 1) << @intCast(4))))); + } + if (@as(c_int, @bitCast(@as(c_uint, idZp1))) == @as(c_int, 0)) { + byVFMask |= @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 1) << @intCast(5))))); + } + return byVFMask; +} +pub fn Vox_GetVertexPosition(arg__wcx: c_int, arg__wcy: c_int, arg__wcz: c_int, arg__nNumVertex: c_int) callconv(.C) VoxVector3 { + var _wcx = arg__wcx; + _ = &_wcx; + var _wcy = arg__wcy; + _ = &_wcy; + var _wcz = arg__wcz; + _ = &_wcz; + var _nNumVertex = arg__nNumVertex; + _ = &_nNumVertex; + var scale: f32 = @as(f32, @floatCast(0.25)); + _ = &scale; + var vtx: VoxVector3 = SolidVertex[@as(c_uint, @intCast(_nNumVertex))]; + _ = &vtx; + vtx.x = (vtx.x + @as(f32, @floatFromInt(_wcx))) * scale; + vtx.y = (vtx.y + @as(f32, @floatFromInt(_wcy))) * scale; + vtx.z = (vtx.z + @as(f32, @floatFromInt(_wcz))) * scale; + return vtx; +} +pub fn Vox_Build_Voxel(arg_pvoxArray: [*c]VoxArray3D, arg_x: c_int, arg_y: c_int, arg_z: c_int, arg_matID: c_int) callconv(.C) void { + var pvoxArray = arg_pvoxArray; + _ = &pvoxArray; + var x = arg_x; + _ = &x; + var y = arg_y; + _ = &y; + var z = arg_z; + _ = &z; + var matID = arg_matID; + _ = &matID; + var byVFMask: u8 = Vox_CalcFacesVisible(pvoxArray, x, y, z); + _ = &byVFMask; + if (@as(c_int, @bitCast(@as(c_uint, byVFMask))) == @as(c_int, 0)) return; + var i: c_int = undefined; + _ = &i; + var j: c_int = undefined; + _ = &j; + var vertComputed: [8]VoxVector3 = undefined; + _ = &vertComputed; + var bVertexComputed: [8]c_int = undefined; + _ = &bVertexComputed; + _ = memset(@as(?*anyopaque, @ptrCast(@as([*c]VoxVector3, @ptrCast(@alignCast(&vertComputed))))), @as(c_int, 0), @sizeOf([8]VoxVector3)); + _ = memset(@as(?*anyopaque, @ptrCast(@as([*c]c_int, @ptrCast(@alignCast(&bVertexComputed))))), @as(c_int, 0), @sizeOf([8]c_int)); + { + i = 0; + while (i < @as(c_int, 6)) : (i += 1) { + if ((@as(c_int, @bitCast(@as(c_uint, byVFMask))) & (@as(c_int, 1) << @intCast(i))) != @as(c_int, 0)) { + { + j = 0; + while (j < @as(c_int, 4)) : (j += 1) { + var nNumVertex: c_int = fv[@as(c_uint, @intCast(i))][@as(c_uint, @intCast(j))]; + _ = &nNumVertex; + if (bVertexComputed[@as(c_uint, @intCast(nNumVertex))] == @as(c_int, 0)) { + bVertexComputed[@as(c_uint, @intCast(nNumVertex))] = 1; + vertComputed[@as(c_uint, @intCast(nNumVertex))] = Vox_GetVertexPosition(x, y, z, nNumVertex); + } + } + } + } + } + } + { + i = 0; + while (i < @as(c_int, 6)) : (i += 1) { + if ((@as(c_int, @bitCast(@as(c_uint, byVFMask))) & (@as(c_int, 1) << @intCast(i))) == @as(c_int, 0)) continue; + var v0: c_int = fv[@as(c_uint, @intCast(i))][@as(c_uint, @intCast(@as(c_int, 0)))]; + _ = &v0; + var v1: c_int = fv[@as(c_uint, @intCast(i))][@as(c_uint, @intCast(@as(c_int, 1)))]; + _ = &v1; + var v2: c_int = fv[@as(c_uint, @intCast(i))][@as(c_uint, @intCast(@as(c_int, 2)))]; + _ = &v2; + var v3: c_int = fv[@as(c_uint, @intCast(i))][@as(c_uint, @intCast(@as(c_int, 3)))]; + _ = &v3; + var idx: c_int = pvoxArray.*.vertices.used; + _ = &idx; + insertArrayVector3(&pvoxArray.*.vertices, vertComputed[@as(c_uint, @intCast(v0))]); + insertArrayVector3(&pvoxArray.*.vertices, vertComputed[@as(c_uint, @intCast(v1))]); + insertArrayVector3(&pvoxArray.*.vertices, vertComputed[@as(c_uint, @intCast(v2))]); + insertArrayVector3(&pvoxArray.*.vertices, vertComputed[@as(c_uint, @intCast(v3))]); + insertArrayVector3(&pvoxArray.*.normals, FacesPerSideNormal[@as(c_uint, @intCast(i))]); + insertArrayVector3(&pvoxArray.*.normals, FacesPerSideNormal[@as(c_uint, @intCast(i))]); + insertArrayVector3(&pvoxArray.*.normals, FacesPerSideNormal[@as(c_uint, @intCast(i))]); + insertArrayVector3(&pvoxArray.*.normals, FacesPerSideNormal[@as(c_uint, @intCast(i))]); + var col: VoxColor = pvoxArray.*.palette[@as(c_uint, @intCast(matID))]; + _ = &col; + insertArrayColor(&pvoxArray.*.colors, col); + insertArrayColor(&pvoxArray.*.colors, col); + insertArrayColor(&pvoxArray.*.colors, col); + insertArrayColor(&pvoxArray.*.colors, col); + insertArrayUShort(&pvoxArray.*.indices, @as(c_ushort, @bitCast(@as(c_short, @truncate(idx + @as(c_int, 0)))))); + insertArrayUShort(&pvoxArray.*.indices, @as(c_ushort, @bitCast(@as(c_short, @truncate(idx + @as(c_int, 2)))))); + insertArrayUShort(&pvoxArray.*.indices, @as(c_ushort, @bitCast(@as(c_short, @truncate(idx + @as(c_int, 1)))))); + insertArrayUShort(&pvoxArray.*.indices, @as(c_ushort, @bitCast(@as(c_short, @truncate(idx + @as(c_int, 0)))))); + insertArrayUShort(&pvoxArray.*.indices, @as(c_ushort, @bitCast(@as(c_short, @truncate(idx + @as(c_int, 3)))))); + insertArrayUShort(&pvoxArray.*.indices, @as(c_ushort, @bitCast(@as(c_short, @truncate(idx + @as(c_int, 2)))))); + } + } +} +pub const M3D_FLOAT = f32; +pub const M3D_INDEX = u32; +pub const M3D_VOXEL = u16; +pub const m3dhdr_t = extern struct { + magic: [4]u8 align(1) = @import("std").mem.zeroes([4]u8), + length: u32 align(1) = @import("std").mem.zeroes(u32), + scale: f32 align(1) = @import("std").mem.zeroes(f32), + types: u32 align(1) = @import("std").mem.zeroes(u32), +}; +pub const m3dchunk_t = extern struct { + magic: [4]u8 align(1) = @import("std").mem.zeroes([4]u8), + length: u32 align(1) = @import("std").mem.zeroes(u32), +}; +pub const m3dti_t = extern struct { + u: M3D_FLOAT = @import("std").mem.zeroes(M3D_FLOAT), + v: M3D_FLOAT = @import("std").mem.zeroes(M3D_FLOAT), +}; +pub const m3dtx_t = extern struct { + name: [*c]u8 = @import("std").mem.zeroes([*c]u8), + d: [*c]u8 = @import("std").mem.zeroes([*c]u8), + w: u16 = @import("std").mem.zeroes(u16), + h: u16 = @import("std").mem.zeroes(u16), + f: u8 = @import("std").mem.zeroes(u8), +}; +pub const m3dw_t = extern struct { + vertexid: M3D_INDEX = @import("std").mem.zeroes(M3D_INDEX), + weight: M3D_FLOAT = @import("std").mem.zeroes(M3D_FLOAT), +}; +pub const m3db_t = extern struct { + parent: M3D_INDEX = @import("std").mem.zeroes(M3D_INDEX), + name: [*c]u8 = @import("std").mem.zeroes([*c]u8), + pos: M3D_INDEX = @import("std").mem.zeroes(M3D_INDEX), + ori: M3D_INDEX = @import("std").mem.zeroes(M3D_INDEX), + numweight: M3D_INDEX = @import("std").mem.zeroes(M3D_INDEX), + weight: [*c]m3dw_t = @import("std").mem.zeroes([*c]m3dw_t), + mat4: [16]M3D_FLOAT = @import("std").mem.zeroes([16]M3D_FLOAT), +}; +pub const m3ds_t = extern struct { + boneid: [4]M3D_INDEX = @import("std").mem.zeroes([4]M3D_INDEX), + weight: [4]M3D_FLOAT = @import("std").mem.zeroes([4]M3D_FLOAT), +}; +pub const m3dv_t = extern struct { + x: M3D_FLOAT = @import("std").mem.zeroes(M3D_FLOAT), + y: M3D_FLOAT = @import("std").mem.zeroes(M3D_FLOAT), + z: M3D_FLOAT = @import("std").mem.zeroes(M3D_FLOAT), + w: M3D_FLOAT = @import("std").mem.zeroes(M3D_FLOAT), + color: u32 = @import("std").mem.zeroes(u32), + skinid: M3D_INDEX = @import("std").mem.zeroes(M3D_INDEX), +}; +pub const m3dpf_color: c_int = 0; +pub const m3dpf_uint8: c_int = 1; +pub const m3dpf_uint16: c_int = 2; +pub const m3dpf_uint32: c_int = 3; +pub const m3dpf_float: c_int = 4; +pub const m3dpf_map: c_int = 5; +const enum_unnamed_7 = c_uint; +pub const m3dpd_t = extern struct { + format: u8 = @import("std").mem.zeroes(u8), + id: u8 = @import("std").mem.zeroes(u8), +}; +pub const m3dp_Kd: c_int = 0; +pub const m3dp_Ka: c_int = 1; +pub const m3dp_Ks: c_int = 2; +pub const m3dp_Ns: c_int = 3; +pub const m3dp_Ke: c_int = 4; +pub const m3dp_Tf: c_int = 5; +pub const m3dp_Km: c_int = 6; +pub const m3dp_d: c_int = 7; +pub const m3dp_il: c_int = 8; +pub const m3dp_Pr: c_int = 64; +pub const m3dp_Pm: c_int = 65; +pub const m3dp_Ps: c_int = 66; +pub const m3dp_Ni: c_int = 67; +pub const m3dp_Nt: c_int = 68; +pub const m3dp_map_Kd: c_int = 128; +pub const m3dp_map_Ka: c_int = 129; +pub const m3dp_map_Ks: c_int = 130; +pub const m3dp_map_Ns: c_int = 131; +pub const m3dp_map_Ke: c_int = 132; +pub const m3dp_map_Tf: c_int = 133; +pub const m3dp_map_Km: c_int = 134; +pub const m3dp_map_D: c_int = 135; +pub const m3dp_map_N: c_int = 136; +pub const m3dp_map_Pr: c_int = 192; +pub const m3dp_map_Pm: c_int = 193; +pub const m3dp_map_Ps: c_int = 194; +pub const m3dp_map_Ni: c_int = 195; +pub const m3dp_map_Nt: c_int = 196; +const enum_unnamed_8 = c_uint; +pub const m3dp_bump: c_int = 134; +pub const m3dp_map_il: c_int = 136; +pub const m3dp_refl: c_int = 193; +const enum_unnamed_9 = c_uint; +const union_unnamed_10 = extern union { + color: u32, + num: u32, + fnum: f32, + textureid: M3D_INDEX, +}; +pub const m3dp_t = extern struct { + type: u8 = @import("std").mem.zeroes(u8), + value: union_unnamed_10 = @import("std").mem.zeroes(union_unnamed_10), +}; +pub const m3dm_t = extern struct { + name: [*c]u8 = @import("std").mem.zeroes([*c]u8), + numprop: u8 = @import("std").mem.zeroes(u8), + prop: [*c]m3dp_t = @import("std").mem.zeroes([*c]m3dp_t), +}; +pub const m3df_t = extern struct { + materialid: M3D_INDEX = @import("std").mem.zeroes(M3D_INDEX), + vertex: [3]M3D_INDEX = @import("std").mem.zeroes([3]M3D_INDEX), + normal: [3]M3D_INDEX = @import("std").mem.zeroes([3]M3D_INDEX), + texcoord: [3]M3D_INDEX = @import("std").mem.zeroes([3]M3D_INDEX), +}; +pub const m3dvi_t = extern struct { + count: u16 = @import("std").mem.zeroes(u16), + name: [*c]u8 = @import("std").mem.zeroes([*c]u8), +}; +pub const m3dvt_t = extern struct { + name: [*c]u8 = @import("std").mem.zeroes([*c]u8), + rotation: u8 = @import("std").mem.zeroes(u8), + voxshape: u16 = @import("std").mem.zeroes(u16), + materialid: M3D_INDEX = @import("std").mem.zeroes(M3D_INDEX), + color: u32 = @import("std").mem.zeroes(u32), + skinid: M3D_INDEX = @import("std").mem.zeroes(M3D_INDEX), + numitem: u8 = @import("std").mem.zeroes(u8), + item: [*c]m3dvi_t = @import("std").mem.zeroes([*c]m3dvi_t), +}; +pub const m3dvx_t = extern struct { + name: [*c]u8 = @import("std").mem.zeroes([*c]u8), + x: i32 = @import("std").mem.zeroes(i32), + y: i32 = @import("std").mem.zeroes(i32), + z: i32 = @import("std").mem.zeroes(i32), + w: u32 = @import("std").mem.zeroes(u32), + h: u32 = @import("std").mem.zeroes(u32), + d: u32 = @import("std").mem.zeroes(u32), + uncertain: u8 = @import("std").mem.zeroes(u8), + groupid: u8 = @import("std").mem.zeroes(u8), + data: [*c]M3D_VOXEL = @import("std").mem.zeroes([*c]M3D_VOXEL), +}; +pub const m3dc_use: c_int = 0; +pub const m3dc_inc: c_int = 1; +pub const m3dc_mesh: c_int = 2; +pub const m3dc_div: c_int = 3; +pub const m3dc_sub: c_int = 4; +pub const m3dc_len: c_int = 5; +pub const m3dc_dist: c_int = 6; +pub const m3dc_degu: c_int = 7; +pub const m3dc_deg: c_int = 8; +pub const m3dc_rangeu: c_int = 9; +pub const m3dc_range: c_int = 10; +pub const m3dc_paru: c_int = 11; +pub const m3dc_parv: c_int = 12; +pub const m3dc_trim: c_int = 13; +pub const m3dc_hole: c_int = 14; +pub const m3dc_scrv: c_int = 15; +pub const m3dc_sp: c_int = 16; +pub const m3dc_bez1: c_int = 17; +pub const m3dc_bsp1: c_int = 18; +pub const m3dc_bez2: c_int = 19; +pub const m3dc_bsp2: c_int = 20; +pub const m3dc_bezun: c_int = 21; +pub const m3dc_bezu: c_int = 22; +pub const m3dc_bezn: c_int = 23; +pub const m3dc_bez: c_int = 24; +pub const m3dc_nurbsun: c_int = 25; +pub const m3dc_nurbsu: c_int = 26; +pub const m3dc_nurbsn: c_int = 27; +pub const m3dc_nurbs: c_int = 28; +pub const m3dc_conn: c_int = 29; +pub const m3dc_line: c_int = 30; +pub const m3dc_polygon: c_int = 31; +pub const m3dc_circle: c_int = 32; +pub const m3dc_cylinder: c_int = 33; +pub const m3dc_shpere: c_int = 34; +pub const m3dc_torus: c_int = 35; +pub const m3dc_cone: c_int = 36; +pub const m3dc_cube: c_int = 37; +const enum_unnamed_11 = c_uint; +pub const m3dcp_mi_t: c_int = 1; +pub const m3dcp_hi_t: c_int = 2; +pub const m3dcp_fi_t: c_int = 3; +pub const m3dcp_ti_t: c_int = 4; +pub const m3dcp_vi_t: c_int = 5; +pub const m3dcp_qi_t: c_int = 6; +pub const m3dcp_vc_t: c_int = 7; +pub const m3dcp_i1_t: c_int = 8; +pub const m3dcp_i2_t: c_int = 9; +pub const m3dcp_i4_t: c_int = 10; +pub const m3dcp_va_t: c_int = 11; +const enum_unnamed_12 = c_uint; +pub const m3dcd_t = extern struct { + p: u8 = @import("std").mem.zeroes(u8), + a: [8]u8 = @import("std").mem.zeroes([8]u8), +}; +pub const m3dc_t = extern struct { + type: u16 = @import("std").mem.zeroes(u16), + arg: [*c]u32 = @import("std").mem.zeroes([*c]u32), +}; +pub const m3dh_t = extern struct { + name: [*c]u8 = @import("std").mem.zeroes([*c]u8), + group: M3D_INDEX = @import("std").mem.zeroes(M3D_INDEX), + numcmd: u32 = @import("std").mem.zeroes(u32), + cmd: [*c]m3dc_t = @import("std").mem.zeroes([*c]m3dc_t), +}; +pub const m3dl_t = extern struct { + name: [*c]u8 = @import("std").mem.zeroes([*c]u8), + lang: [*c]u8 = @import("std").mem.zeroes([*c]u8), + text: [*c]u8 = @import("std").mem.zeroes([*c]u8), + color: u32 = @import("std").mem.zeroes(u32), + vertexid: M3D_INDEX = @import("std").mem.zeroes(M3D_INDEX), +}; +pub const m3dtr_t = extern struct { + boneid: M3D_INDEX = @import("std").mem.zeroes(M3D_INDEX), + pos: M3D_INDEX = @import("std").mem.zeroes(M3D_INDEX), + ori: M3D_INDEX = @import("std").mem.zeroes(M3D_INDEX), +}; +pub const m3dfr_t = extern struct { + msec: u32 = @import("std").mem.zeroes(u32), + numtransform: M3D_INDEX = @import("std").mem.zeroes(M3D_INDEX), + transform: [*c]m3dtr_t = @import("std").mem.zeroes([*c]m3dtr_t), +}; +pub const m3da_t = extern struct { + name: [*c]u8 = @import("std").mem.zeroes([*c]u8), + durationmsec: u32 = @import("std").mem.zeroes(u32), + numframe: M3D_INDEX = @import("std").mem.zeroes(M3D_INDEX), + frame: [*c]m3dfr_t = @import("std").mem.zeroes([*c]m3dfr_t), +}; +pub const m3di_t = extern struct { + name: [*c]u8 = @import("std").mem.zeroes([*c]u8), + data: [*c]u8 = @import("std").mem.zeroes([*c]u8), + length: u32 = @import("std").mem.zeroes(u32), +}; +pub const m3d_t = extern struct { + raw: [*c]m3dhdr_t = @import("std").mem.zeroes([*c]m3dhdr_t), + flags: u8 = @import("std").mem.zeroes(u8), + errcode: i8 = @import("std").mem.zeroes(i8), + vc_s: u8 = @import("std").mem.zeroes(u8), + vi_s: u8 = @import("std").mem.zeroes(u8), + si_s: u8 = @import("std").mem.zeroes(u8), + ci_s: u8 = @import("std").mem.zeroes(u8), + ti_s: u8 = @import("std").mem.zeroes(u8), + bi_s: u8 = @import("std").mem.zeroes(u8), + nb_s: u8 = @import("std").mem.zeroes(u8), + sk_s: u8 = @import("std").mem.zeroes(u8), + fc_s: u8 = @import("std").mem.zeroes(u8), + hi_s: u8 = @import("std").mem.zeroes(u8), + fi_s: u8 = @import("std").mem.zeroes(u8), + vd_s: u8 = @import("std").mem.zeroes(u8), + vp_s: u8 = @import("std").mem.zeroes(u8), + name: [*c]u8 = @import("std").mem.zeroes([*c]u8), + license: [*c]u8 = @import("std").mem.zeroes([*c]u8), + author: [*c]u8 = @import("std").mem.zeroes([*c]u8), + desc: [*c]u8 = @import("std").mem.zeroes([*c]u8), + scale: M3D_FLOAT = @import("std").mem.zeroes(M3D_FLOAT), + numcmap: M3D_INDEX = @import("std").mem.zeroes(M3D_INDEX), + cmap: [*c]u32 = @import("std").mem.zeroes([*c]u32), + numtmap: M3D_INDEX = @import("std").mem.zeroes(M3D_INDEX), + tmap: [*c]m3dti_t = @import("std").mem.zeroes([*c]m3dti_t), + numtexture: M3D_INDEX = @import("std").mem.zeroes(M3D_INDEX), + texture: [*c]m3dtx_t = @import("std").mem.zeroes([*c]m3dtx_t), + numbone: M3D_INDEX = @import("std").mem.zeroes(M3D_INDEX), + bone: [*c]m3db_t = @import("std").mem.zeroes([*c]m3db_t), + numvertex: M3D_INDEX = @import("std").mem.zeroes(M3D_INDEX), + vertex: [*c]m3dv_t = @import("std").mem.zeroes([*c]m3dv_t), + numskin: M3D_INDEX = @import("std").mem.zeroes(M3D_INDEX), + skin: [*c]m3ds_t = @import("std").mem.zeroes([*c]m3ds_t), + nummaterial: M3D_INDEX = @import("std").mem.zeroes(M3D_INDEX), + material: [*c]m3dm_t = @import("std").mem.zeroes([*c]m3dm_t), + numface: M3D_INDEX = @import("std").mem.zeroes(M3D_INDEX), + face: [*c]m3df_t = @import("std").mem.zeroes([*c]m3df_t), + numvoxtype: M3D_INDEX = @import("std").mem.zeroes(M3D_INDEX), + voxtype: [*c]m3dvt_t = @import("std").mem.zeroes([*c]m3dvt_t), + numvoxel: M3D_INDEX = @import("std").mem.zeroes(M3D_INDEX), + voxel: [*c]m3dvx_t = @import("std").mem.zeroes([*c]m3dvx_t), + numshape: M3D_INDEX = @import("std").mem.zeroes(M3D_INDEX), + shape: [*c]m3dh_t = @import("std").mem.zeroes([*c]m3dh_t), + numlabel: M3D_INDEX = @import("std").mem.zeroes(M3D_INDEX), + label: [*c]m3dl_t = @import("std").mem.zeroes([*c]m3dl_t), + numaction: M3D_INDEX = @import("std").mem.zeroes(M3D_INDEX), + action: [*c]m3da_t = @import("std").mem.zeroes([*c]m3da_t), + numinlined: M3D_INDEX = @import("std").mem.zeroes(M3D_INDEX), + inlined: [*c]m3di_t = @import("std").mem.zeroes([*c]m3di_t), + numextra: M3D_INDEX = @import("std").mem.zeroes(M3D_INDEX), + extra: [*c][*c]m3dchunk_t = @import("std").mem.zeroes([*c][*c]m3dchunk_t), + preview: m3di_t = @import("std").mem.zeroes(m3di_t), +}; +pub const m3dread_t = ?*const fn ([*c]u8, [*c]c_uint) callconv(.C) [*c]u8; +pub const m3dfree_t = ?*const fn (?*anyopaque) callconv(.C) void; +pub const m3dtxsc_t = ?*const fn ([*c]const u8, ?*const anyopaque, u32, [*c]m3dtx_t) callconv(.C) c_int; +pub const m3dprsc_t = ?*const fn ([*c]const u8, ?*const anyopaque, u32, [*c]m3d_t) callconv(.C) c_int; +// ./external/m3d.h:3306:1: warning: TODO implement translation of stmt class LabelStmtClass + +// ./external/m3d.h:2382:8: warning: unable to translate function, demoted to extern +pub extern fn m3d_load(arg_data: [*c]u8, arg_readfilecb: m3dread_t, arg_freecb: m3dfree_t, arg_mtllib: [*c]m3d_t) [*c]m3d_t; +pub extern fn m3d_save(model: [*c]m3d_t, quality: c_int, flags: c_int, size: [*c]c_uint) [*c]u8; +pub export fn m3d_free(arg_model: [*c]m3d_t) void { + var model = arg_model; + _ = &model; + var i: c_uint = undefined; + _ = &i; + var j: c_uint = undefined; + _ = &j; + if (!(model != null)) return; + if ((@as(c_int, @bitCast(@as(c_uint, model.*.flags))) & (@as(c_int, 1) << @intCast(0))) != 0) { + free(@as(?*anyopaque, @ptrCast(model.*.raw))); + } + if (model.*.tmap != null) { + free(@as(?*anyopaque, @ptrCast(model.*.tmap))); + } + if (model.*.bone != null) { + { + i = 0; + while (i < model.*.numbone) : (i +%= 1) if (model.*.bone[i].weight != null) { + free(@as(?*anyopaque, @ptrCast(model.*.bone[i].weight))); + }; + } + free(@as(?*anyopaque, @ptrCast(model.*.bone))); + } + if (model.*.skin != null) { + free(@as(?*anyopaque, @ptrCast(model.*.skin))); + } + if (model.*.vertex != null) { + free(@as(?*anyopaque, @ptrCast(model.*.vertex))); + } + if (model.*.face != null) { + free(@as(?*anyopaque, @ptrCast(model.*.face))); + } + if (model.*.voxtype != null) { + { + i = 0; + while (i < model.*.numvoxtype) : (i +%= 1) if (model.*.voxtype[i].item != null) { + free(@as(?*anyopaque, @ptrCast(model.*.voxtype[i].item))); + }; + } + free(@as(?*anyopaque, @ptrCast(model.*.voxtype))); + } + if (model.*.voxel != null) { + { + i = 0; + while (i < model.*.numvoxel) : (i +%= 1) if (model.*.voxel[i].data != null) { + free(@as(?*anyopaque, @ptrCast(model.*.voxel[i].data))); + }; + } + free(@as(?*anyopaque, @ptrCast(model.*.voxel))); + } + if (model.*.shape != null) { + { + i = 0; + while (i < model.*.numshape) : (i +%= 1) { + if (model.*.shape[i].cmd != null) { + { + j = 0; + while (j < model.*.shape[i].numcmd) : (j +%= 1) if (model.*.shape[i].cmd[j].arg != null) { + free(@as(?*anyopaque, @ptrCast(model.*.shape[i].cmd[j].arg))); + }; + } + free(@as(?*anyopaque, @ptrCast(model.*.shape[i].cmd))); + } + } + } + free(@as(?*anyopaque, @ptrCast(model.*.shape))); + } + if ((model.*.material != null) and !((@as(c_int, @bitCast(@as(c_uint, model.*.flags))) & (@as(c_int, 1) << @intCast(2))) != 0)) { + { + i = 0; + while (i < model.*.nummaterial) : (i +%= 1) if (model.*.material[i].prop != null) { + free(@as(?*anyopaque, @ptrCast(model.*.material[i].prop))); + }; + } + free(@as(?*anyopaque, @ptrCast(model.*.material))); + } + if (model.*.texture != null) { + { + i = 0; + while (i < model.*.numtexture) : (i +%= 1) if (model.*.texture[i].d != null) { + free(@as(?*anyopaque, @ptrCast(model.*.texture[i].d))); + }; + } + free(@as(?*anyopaque, @ptrCast(model.*.texture))); + } + if (model.*.action != null) { + { + i = 0; + while (i < model.*.numaction) : (i +%= 1) { + if (model.*.action[i].frame != null) { + { + j = 0; + while (j < model.*.action[i].numframe) : (j +%= 1) if (model.*.action[i].frame[j].transform != null) { + free(@as(?*anyopaque, @ptrCast(model.*.action[i].frame[j].transform))); + }; + } + free(@as(?*anyopaque, @ptrCast(model.*.action[i].frame))); + } + } + } + free(@as(?*anyopaque, @ptrCast(model.*.action))); + } + if (model.*.label != null) { + free(@as(?*anyopaque, @ptrCast(model.*.label))); + } + if (model.*.inlined != null) { + free(@as(?*anyopaque, @ptrCast(model.*.inlined))); + } + if (model.*.extra != null) { + free(@as(?*anyopaque, @ptrCast(model.*.extra))); + } + free(@as(?*anyopaque, @ptrCast(model))); +} +// ./external/m3d.h:4218:9: warning: TODO implement translation of stmt class GotoStmtClass + +// ./external/m3d.h:4200:10: warning: unable to translate function, demoted to extern +pub extern fn m3d_frame(arg_model: [*c]m3d_t, arg_actionid: M3D_INDEX, arg_frameid: M3D_INDEX, arg_skeleton: [*c]m3dtr_t) [*c]m3dtr_t; +pub export fn m3d_pose(arg_model: [*c]m3d_t, arg_actionid: M3D_INDEX, arg_msec: u32) [*c]m3db_t { + var model = arg_model; + _ = &model; + var actionid = arg_actionid; + _ = &actionid; + var msec = arg_msec; + _ = &msec; + var i: c_uint = undefined; + _ = &i; + var j: c_uint = undefined; + _ = &j; + var l: c_uint = undefined; + _ = &l; + var r: [16]M3D_FLOAT = undefined; + _ = &r; + var t: M3D_FLOAT = undefined; + _ = &t; + var c: M3D_FLOAT = undefined; + _ = &c; + var d: M3D_FLOAT = undefined; + _ = &d; + var s: M3D_FLOAT = undefined; + _ = &s; + var ret: [*c]m3db_t = undefined; + _ = &ret; + var v: [*c]m3dv_t = undefined; + _ = &v; + var p: [*c]m3dv_t = undefined; + _ = &p; + var f: [*c]m3dv_t = undefined; + _ = &f; + var tmp: [*c]m3dtr_t = undefined; + _ = &tmp; + var fr: [*c]m3dfr_t = undefined; + _ = &fr; + if ((!(model != null) or !(model.*.numbone != 0)) or !(model.*.bone != null)) { + model.*.errcode = @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 69))))); + return null; + } + ret = @as([*c]m3db_t, @ptrCast(@alignCast(malloc(@as(c_ulong, @bitCast(@as(c_ulong, model.*.numbone))) *% @sizeOf(m3db_t))))); + if (!(ret != null)) { + model.*.errcode = @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 1))))); + return null; + } + _ = memcpy(@as(?*anyopaque, @ptrCast(ret)), @as(?*const anyopaque, @ptrCast(model.*.bone)), @as(c_ulong, @bitCast(@as(c_ulong, model.*.numbone))) *% @sizeOf(m3db_t)); + { + i = 0; + while (i < model.*.numbone) : (i +%= 1) { + _m3d_inv(@as([*c]M3D_FLOAT, @ptrCast(@alignCast(&ret[i].mat4)))); + } + } + if (!(model.*.action != null) or (actionid >= model.*.numaction)) { + model.*.errcode = @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 69))))); + return ret; + } + msec %= model.*.action[actionid].durationmsec; + model.*.errcode = 0; + fr = &model.*.action[actionid].frame[@as(c_uint, @intCast(@as(c_int, 0)))]; + { + j = blk: { + const tmp_1 = @as(c_uint, @bitCast(@as(c_int, 0))); + l = tmp_1; + break :blk tmp_1; + }; + while ((j < model.*.action[actionid].numframe) and (model.*.action[actionid].frame[j].msec <= msec)) : (j +%= 1) { + fr = &model.*.action[actionid].frame[j]; + l = fr.*.msec; + { + i = 0; + while (i < fr.*.numtransform) : (i +%= 1) { + ret[fr.*.transform[i].boneid].pos = fr.*.transform[i].pos; + ret[fr.*.transform[i].boneid].ori = fr.*.transform[i].ori; + } + } + } + } + if (l != msec) { + model.*.vertex = @as([*c]m3dv_t, @ptrCast(@alignCast(realloc(@as(?*anyopaque, @ptrCast(model.*.vertex)), @as(c_ulong, @bitCast(@as(c_ulong, model.*.numvertex +% (@as(M3D_INDEX, @bitCast(@as(c_int, 2))) *% model.*.numbone)))) *% @sizeOf(m3dv_t))))); + if (!(model.*.vertex != null)) { + free(@as(?*anyopaque, @ptrCast(ret))); + model.*.errcode = @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 1))))); + return null; + } + tmp = @as([*c]m3dtr_t, @ptrCast(@alignCast(malloc(@as(c_ulong, @bitCast(@as(c_ulong, model.*.numbone))) *% @sizeOf(m3dtr_t))))); + if (tmp != null) { + { + i = 0; + while (i < model.*.numbone) : (i +%= 1) { + tmp[i].pos = ret[i].pos; + tmp[i].ori = ret[i].ori; + } + } + fr = &model.*.action[actionid].frame[j % model.*.action[actionid].numframe]; + t = if (l >= fr.*.msec) @as(M3D_FLOAT, @floatCast(1.0)) else @as(M3D_FLOAT, @floatFromInt(msec -% l)) / @as(M3D_FLOAT, @floatFromInt(fr.*.msec -% l)); + { + i = 0; + while (i < fr.*.numtransform) : (i +%= 1) { + tmp[fr.*.transform[i].boneid].pos = fr.*.transform[i].pos; + tmp[fr.*.transform[i].boneid].ori = fr.*.transform[i].ori; + } + } + { + _ = blk: { + i = 0; + break :blk blk_1: { + const tmp_2 = model.*.numvertex; + j = tmp_2; + break :blk_1 tmp_2; + }; + }; + while (i < model.*.numbone) : (i +%= 1) { + if (ret[i].pos != tmp[i].pos) { + p = &model.*.vertex[ret[i].pos]; + f = &model.*.vertex[tmp[i].pos]; + v = &model.*.vertex[j]; + v.*.x = p.*.x + (t * (f.*.x - p.*.x)); + v.*.y = p.*.y + (t * (f.*.y - p.*.y)); + v.*.z = p.*.z + (t * (f.*.z - p.*.z)); + ret[i].pos = blk: { + const ref = &j; + const tmp_1 = ref.*; + ref.* +%= 1; + break :blk tmp_1; + }; + } + if (ret[i].ori != tmp[i].ori) { + p = &model.*.vertex[ret[i].ori]; + f = &model.*.vertex[tmp[i].ori]; + v = &model.*.vertex[j]; + d = (((p.*.w * f.*.w) + (p.*.x * f.*.x)) + (p.*.y * f.*.y)) + (p.*.z * f.*.z); + if (d < @as(M3D_FLOAT, @floatFromInt(@as(c_int, 0)))) { + d = -d; + s = @as(M3D_FLOAT, @floatCast(-1.0)); + } else { + s = @as(M3D_FLOAT, @floatCast(1.0)); + } + c = t - @as(M3D_FLOAT, @floatCast(0.5)); + t += ((t * c) * (t - @as(M3D_FLOAT, @floatCast(1.0)))) * ((((@as(M3D_FLOAT, @floatCast(1.0904)) + (d * (@as(M3D_FLOAT, @floatCast(-3.2452)) + (d * (@as(M3D_FLOAT, @floatCast(3.55645)) - (d * @as(M3D_FLOAT, @floatCast(1.43519)))))))) * c) * c) + (@as(M3D_FLOAT, @floatCast(0.848013)) + (d * (@as(M3D_FLOAT, @floatCast(-1.06021)) + (d * @as(M3D_FLOAT, @floatCast(0.215638))))))); + v.*.x = p.*.x + (t * ((s * f.*.x) - p.*.x)); + v.*.y = p.*.y + (t * ((s * f.*.y) - p.*.y)); + v.*.z = p.*.z + (t * ((s * f.*.z) - p.*.z)); + v.*.w = p.*.w + (t * ((s * f.*.w) - p.*.w)); + d = _m3d_rsq((((v.*.w * v.*.w) + (v.*.x * v.*.x)) + (v.*.y * v.*.y)) + (v.*.z * v.*.z)); + v.*.x *= d; + v.*.y *= d; + v.*.z *= d; + v.*.w *= d; + ret[i].ori = blk: { + const ref = &j; + const tmp_1 = ref.*; + ref.* +%= 1; + break :blk tmp_1; + }; + } + } + } + free(@as(?*anyopaque, @ptrCast(tmp))); + } + } + { + i = 0; + while (i < model.*.numbone) : (i +%= 1) { + if (ret[i].parent == @as(c_uint, 4294967295)) { + _m3d_mat(@as([*c]M3D_FLOAT, @ptrCast(@alignCast(&ret[i].mat4))), &model.*.vertex[ret[i].pos], &model.*.vertex[ret[i].ori]); + } else { + _m3d_mat(@as([*c]M3D_FLOAT, @ptrCast(@alignCast(&r))), &model.*.vertex[ret[i].pos], &model.*.vertex[ret[i].ori]); + _m3d_mul(@as([*c]M3D_FLOAT, @ptrCast(@alignCast(&ret[i].mat4))), @as([*c]M3D_FLOAT, @ptrCast(@alignCast(&ret[ret[i].parent].mat4))), @as([*c]M3D_FLOAT, @ptrCast(@alignCast(&r)))); + } + } + } + return ret; +} +pub export fn _m3d_safestr(arg_in: [*c]u8, arg_morelines: c_int) [*c]u8 { + var in = arg_in; + _ = ∈ + var morelines = arg_morelines; + _ = &morelines; + var out: [*c]u8 = undefined; + _ = &out; + var o: [*c]u8 = undefined; + _ = &o; + var i: [*c]u8 = in; + _ = &i; + var l: c_int = undefined; + _ = &l; + if (!(in != null) or !(in.* != 0)) { + out = @as([*c]u8, @ptrCast(@alignCast(malloc(@as(c_ulong, @bitCast(@as(c_long, @as(c_int, 1)))))))); + if (!(out != null)) return null; + out[@as(c_uint, @intCast(@as(c_int, 0)))] = 0; + } else { + { + _ = blk: { + o = in; + break :blk blk_1: { + const tmp = @as(c_int, 0); + l = tmp; + break :blk_1 tmp; + }; + }; + while (((@as(c_int, @bitCast(@as(c_uint, o.*))) != 0) and (((morelines & @as(c_int, 1)) != 0) or ((@as(c_int, @bitCast(@as(c_uint, o.*))) != @as(c_int, '\r')) and (@as(c_int, @bitCast(@as(c_uint, o.*))) != @as(c_int, '\n'))))) and (l < @as(c_int, 256))) : (_ = blk: { + o += 1; + break :blk blk_1: { + const ref = &l; + const tmp = ref.*; + ref.* += 1; + break :blk_1 tmp; + }; + }) {} + } + out = blk: { + const tmp = @as([*c]u8, @ptrCast(@alignCast(malloc(@as(c_ulong, @bitCast(@as(c_long, l + @as(c_int, 1)))))))); + o = tmp; + break :blk tmp; + }; + if (!(out != null)) return null; + while ((((@as(c_int, @bitCast(@as(c_uint, i.*))) == @as(c_int, ' ')) or (@as(c_int, @bitCast(@as(c_uint, i.*))) == @as(c_int, '\t'))) or (@as(c_int, @bitCast(@as(c_uint, i.*))) == @as(c_int, '\r'))) or ((morelines != 0) and (@as(c_int, @bitCast(@as(c_uint, i.*))) == @as(c_int, '\n')))) { + i += 1; + } + while ((@as(c_int, @bitCast(@as(c_uint, i.*))) != 0) and ((morelines != 0) or ((@as(c_int, @bitCast(@as(c_uint, i.*))) != @as(c_int, '\r')) and (@as(c_int, @bitCast(@as(c_uint, i.*))) != @as(c_int, '\n'))))) : (i += 1) { + if (@as(c_int, @bitCast(@as(c_uint, i.*))) == @as(c_int, '\r')) continue; + if (@as(c_int, @bitCast(@as(c_uint, i.*))) == @as(c_int, '\n')) { + if (((morelines >= @as(c_int, 3)) and (o > out)) and (@as(c_int, @bitCast(@as(c_uint, (o - @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 1)))))).*))) == @as(c_int, '\n'))) break; + if ((i > in) and (@as(c_int, @bitCast(@as(c_uint, (i - @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 1)))))).*))) == @as(c_int, '\n'))) continue; + if ((morelines & @as(c_int, 1)) != 0) { + if (morelines == @as(c_int, 1)) { + (blk: { + const ref = &o; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = '\r'; + } + (blk: { + const ref = &o; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = '\n'; + } else break; + } else if ((@as(c_int, @bitCast(@as(c_uint, i.*))) == @as(c_int, ' ')) or (@as(c_int, @bitCast(@as(c_uint, i.*))) == @as(c_int, '\t'))) { + (blk: { + const ref = &o; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = @as(u8, @bitCast(@as(i8, @truncate(if (morelines != 0) @as(c_int, ' ') else @as(c_int, '_'))))); + } else { + (blk: { + const ref = &o; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = @as(u8, @bitCast(@as(i8, @truncate(if (!(morelines != 0) and ((@as(c_int, @bitCast(@as(c_uint, i.*))) == @as(c_int, '/')) or (@as(c_int, @bitCast(@as(c_uint, i.*))) == @as(c_int, '\\')))) @as(c_int, '_') else @as(c_int, @bitCast(@as(c_uint, i.*))))))); + } + } + while ((o > out) and ((((@as(c_int, @bitCast(@as(c_uint, (o - @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 1)))))).*))) == @as(c_int, ' ')) or (@as(c_int, @bitCast(@as(c_uint, (o - @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 1)))))).*))) == @as(c_int, '\t'))) or (@as(c_int, @bitCast(@as(c_uint, (o - @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 1)))))).*))) == @as(c_int, '\r'))) or (@as(c_int, @bitCast(@as(c_uint, (o - @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 1)))))).*))) == @as(c_int, '\n')))) : (o -= 1) {} + o.* = 0; + out = @as([*c]u8, @ptrCast(@alignCast(realloc(@as(?*anyopaque, @ptrCast(out)), (@as(usize, @intCast(@intFromPtr(o))) -% @as(usize, @intCast(@intFromPtr(out)))) +% @as(usize, @bitCast(@as(c_long, @as(c_int, 1)))))))); + } + return out; +} +pub var m3d_propertytypes: [17]m3dpd_t = [17]m3dpd_t{ + m3dpd_t{ + .format = @as(u8, @bitCast(@as(i8, @truncate(m3dpf_color)))), + .id = @as(u8, @bitCast(@as(i8, @truncate(m3dp_Kd)))), + }, + m3dpd_t{ + .format = @as(u8, @bitCast(@as(i8, @truncate(m3dpf_color)))), + .id = @as(u8, @bitCast(@as(i8, @truncate(m3dp_Ka)))), + }, + m3dpd_t{ + .format = @as(u8, @bitCast(@as(i8, @truncate(m3dpf_color)))), + .id = @as(u8, @bitCast(@as(i8, @truncate(m3dp_Ks)))), + }, + m3dpd_t{ + .format = @as(u8, @bitCast(@as(i8, @truncate(m3dpf_float)))), + .id = @as(u8, @bitCast(@as(i8, @truncate(m3dp_Ns)))), + }, + m3dpd_t{ + .format = @as(u8, @bitCast(@as(i8, @truncate(m3dpf_color)))), + .id = @as(u8, @bitCast(@as(i8, @truncate(m3dp_Ke)))), + }, + m3dpd_t{ + .format = @as(u8, @bitCast(@as(i8, @truncate(m3dpf_color)))), + .id = @as(u8, @bitCast(@as(i8, @truncate(m3dp_Tf)))), + }, + m3dpd_t{ + .format = @as(u8, @bitCast(@as(i8, @truncate(m3dpf_float)))), + .id = @as(u8, @bitCast(@as(i8, @truncate(m3dp_Km)))), + }, + m3dpd_t{ + .format = @as(u8, @bitCast(@as(i8, @truncate(m3dpf_float)))), + .id = @as(u8, @bitCast(@as(i8, @truncate(m3dp_d)))), + }, + m3dpd_t{ + .format = @as(u8, @bitCast(@as(i8, @truncate(m3dpf_uint8)))), + .id = @as(u8, @bitCast(@as(i8, @truncate(m3dp_il)))), + }, + m3dpd_t{ + .format = @as(u8, @bitCast(@as(i8, @truncate(m3dpf_float)))), + .id = @as(u8, @bitCast(@as(i8, @truncate(m3dp_Pr)))), + }, + m3dpd_t{ + .format = @as(u8, @bitCast(@as(i8, @truncate(m3dpf_float)))), + .id = @as(u8, @bitCast(@as(i8, @truncate(m3dp_Pm)))), + }, + m3dpd_t{ + .format = @as(u8, @bitCast(@as(i8, @truncate(m3dpf_float)))), + .id = @as(u8, @bitCast(@as(i8, @truncate(m3dp_Ps)))), + }, + m3dpd_t{ + .format = @as(u8, @bitCast(@as(i8, @truncate(m3dpf_float)))), + .id = @as(u8, @bitCast(@as(i8, @truncate(m3dp_Ni)))), + }, + m3dpd_t{ + .format = @as(u8, @bitCast(@as(i8, @truncate(m3dpf_float)))), + .id = @as(u8, @bitCast(@as(i8, @truncate(m3dp_Nt)))), + }, + m3dpd_t{ + .format = @as(u8, @bitCast(@as(i8, @truncate(m3dpf_map)))), + .id = @as(u8, @bitCast(@as(i8, @truncate(m3dp_map_Km)))), + }, + m3dpd_t{ + .format = @as(u8, @bitCast(@as(i8, @truncate(m3dpf_map)))), + .id = @as(u8, @bitCast(@as(i8, @truncate(m3dp_map_N)))), + }, + m3dpd_t{ + .format = @as(u8, @bitCast(@as(i8, @truncate(m3dpf_map)))), + .id = @as(u8, @bitCast(@as(i8, @truncate(m3dp_map_Pm)))), + }, +}; +pub var m3d_commandtypes: [38]m3dcd_t = [38]m3dcd_t{ + m3dcd_t{ + .p = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 1))))), + .a = [8]u8{ + @as(u8, @bitCast(@as(i8, @truncate(m3dcp_mi_t)))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + }, + }, + m3dcd_t{ + .p = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 3))))), + .a = [8]u8{ + @as(u8, @bitCast(@as(i8, @truncate(m3dcp_hi_t)))), + @as(u8, @bitCast(@as(i8, @truncate(m3dcp_vi_t)))), + @as(u8, @bitCast(@as(i8, @truncate(m3dcp_qi_t)))), + @as(u8, @bitCast(@as(i8, @truncate(m3dcp_vi_t)))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + }, + }, + m3dcd_t{ + .p = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 1))))), + .a = [8]u8{ + @as(u8, @bitCast(@as(i8, @truncate(m3dcp_fi_t)))), + @as(u8, @bitCast(@as(i8, @truncate(m3dcp_fi_t)))), + @as(u8, @bitCast(@as(i8, @truncate(m3dcp_vi_t)))), + @as(u8, @bitCast(@as(i8, @truncate(m3dcp_qi_t)))), + @as(u8, @bitCast(@as(i8, @truncate(m3dcp_vi_t)))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + }, + }, + m3dcd_t{ + .p = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 1))))), + .a = [8]u8{ + @as(u8, @bitCast(@as(i8, @truncate(m3dcp_vc_t)))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + }, + }, + m3dcd_t{ + .p = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 2))))), + .a = [8]u8{ + @as(u8, @bitCast(@as(i8, @truncate(m3dcp_vc_t)))), + @as(u8, @bitCast(@as(i8, @truncate(m3dcp_vc_t)))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + }, + }, + m3dcd_t{ + .p = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 1))))), + .a = [8]u8{ + @as(u8, @bitCast(@as(i8, @truncate(m3dcp_vc_t)))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + }, + }, + m3dcd_t{ + .p = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 2))))), + .a = [8]u8{ + @as(u8, @bitCast(@as(i8, @truncate(m3dcp_vc_t)))), + @as(u8, @bitCast(@as(i8, @truncate(m3dcp_vc_t)))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + }, + }, + m3dcd_t{ + .p = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 1))))), + .a = [8]u8{ + @as(u8, @bitCast(@as(i8, @truncate(m3dcp_i1_t)))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + }, + }, + m3dcd_t{ + .p = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 2))))), + .a = [8]u8{ + @as(u8, @bitCast(@as(i8, @truncate(m3dcp_i1_t)))), + @as(u8, @bitCast(@as(i8, @truncate(m3dcp_i1_t)))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + }, + }, + m3dcd_t{ + .p = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 1))))), + .a = [8]u8{ + @as(u8, @bitCast(@as(i8, @truncate(m3dcp_ti_t)))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + }, + }, + m3dcd_t{ + .p = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 2))))), + .a = [8]u8{ + @as(u8, @bitCast(@as(i8, @truncate(m3dcp_ti_t)))), + @as(u8, @bitCast(@as(i8, @truncate(m3dcp_ti_t)))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + }, + }, + m3dcd_t{ + .p = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 2))))), + .a = [8]u8{ + @as(u8, @bitCast(@as(i8, @truncate(m3dcp_va_t)))), + @as(u8, @bitCast(@as(i8, @truncate(m3dcp_vc_t)))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + }, + }, + m3dcd_t{ + .p = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 2))))), + .a = [8]u8{ + @as(u8, @bitCast(@as(i8, @truncate(m3dcp_va_t)))), + @as(u8, @bitCast(@as(i8, @truncate(m3dcp_vc_t)))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + }, + }, + m3dcd_t{ + .p = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 3))))), + .a = [8]u8{ + @as(u8, @bitCast(@as(i8, @truncate(m3dcp_va_t)))), + @as(u8, @bitCast(@as(i8, @truncate(m3dcp_ti_t)))), + @as(u8, @bitCast(@as(i8, @truncate(m3dcp_i2_t)))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + }, + }, + m3dcd_t{ + .p = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 3))))), + .a = [8]u8{ + @as(u8, @bitCast(@as(i8, @truncate(m3dcp_va_t)))), + @as(u8, @bitCast(@as(i8, @truncate(m3dcp_ti_t)))), + @as(u8, @bitCast(@as(i8, @truncate(m3dcp_i2_t)))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + }, + }, + m3dcd_t{ + .p = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 3))))), + .a = [8]u8{ + @as(u8, @bitCast(@as(i8, @truncate(m3dcp_va_t)))), + @as(u8, @bitCast(@as(i8, @truncate(m3dcp_ti_t)))), + @as(u8, @bitCast(@as(i8, @truncate(m3dcp_i2_t)))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + }, + }, + m3dcd_t{ + .p = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 2))))), + .a = [8]u8{ + @as(u8, @bitCast(@as(i8, @truncate(m3dcp_va_t)))), + @as(u8, @bitCast(@as(i8, @truncate(m3dcp_vi_t)))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + }, + }, + m3dcd_t{ + .p = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 2))))), + .a = [8]u8{ + @as(u8, @bitCast(@as(i8, @truncate(m3dcp_va_t)))), + @as(u8, @bitCast(@as(i8, @truncate(m3dcp_vi_t)))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + }, + }, + m3dcd_t{ + .p = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 2))))), + .a = [8]u8{ + @as(u8, @bitCast(@as(i8, @truncate(m3dcp_va_t)))), + @as(u8, @bitCast(@as(i8, @truncate(m3dcp_vi_t)))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + }, + }, + m3dcd_t{ + .p = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 2))))), + .a = [8]u8{ + @as(u8, @bitCast(@as(i8, @truncate(m3dcp_va_t)))), + @as(u8, @bitCast(@as(i8, @truncate(m3dcp_vi_t)))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + }, + }, + m3dcd_t{ + .p = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 2))))), + .a = [8]u8{ + @as(u8, @bitCast(@as(i8, @truncate(m3dcp_va_t)))), + @as(u8, @bitCast(@as(i8, @truncate(m3dcp_vi_t)))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + }, + }, + m3dcd_t{ + .p = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 4))))), + .a = [8]u8{ + @as(u8, @bitCast(@as(i8, @truncate(m3dcp_va_t)))), + @as(u8, @bitCast(@as(i8, @truncate(m3dcp_vi_t)))), + @as(u8, @bitCast(@as(i8, @truncate(m3dcp_ti_t)))), + @as(u8, @bitCast(@as(i8, @truncate(m3dcp_vi_t)))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + }, + }, + m3dcd_t{ + .p = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 3))))), + .a = [8]u8{ + @as(u8, @bitCast(@as(i8, @truncate(m3dcp_va_t)))), + @as(u8, @bitCast(@as(i8, @truncate(m3dcp_vi_t)))), + @as(u8, @bitCast(@as(i8, @truncate(m3dcp_ti_t)))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + }, + }, + m3dcd_t{ + .p = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 3))))), + .a = [8]u8{ + @as(u8, @bitCast(@as(i8, @truncate(m3dcp_va_t)))), + @as(u8, @bitCast(@as(i8, @truncate(m3dcp_vi_t)))), + @as(u8, @bitCast(@as(i8, @truncate(m3dcp_vi_t)))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + }, + }, + m3dcd_t{ + .p = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 2))))), + .a = [8]u8{ + @as(u8, @bitCast(@as(i8, @truncate(m3dcp_va_t)))), + @as(u8, @bitCast(@as(i8, @truncate(m3dcp_vi_t)))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + }, + }, + m3dcd_t{ + .p = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 4))))), + .a = [8]u8{ + @as(u8, @bitCast(@as(i8, @truncate(m3dcp_va_t)))), + @as(u8, @bitCast(@as(i8, @truncate(m3dcp_vi_t)))), + @as(u8, @bitCast(@as(i8, @truncate(m3dcp_ti_t)))), + @as(u8, @bitCast(@as(i8, @truncate(m3dcp_vi_t)))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + }, + }, + m3dcd_t{ + .p = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 3))))), + .a = [8]u8{ + @as(u8, @bitCast(@as(i8, @truncate(m3dcp_va_t)))), + @as(u8, @bitCast(@as(i8, @truncate(m3dcp_vi_t)))), + @as(u8, @bitCast(@as(i8, @truncate(m3dcp_ti_t)))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + }, + }, + m3dcd_t{ + .p = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 3))))), + .a = [8]u8{ + @as(u8, @bitCast(@as(i8, @truncate(m3dcp_va_t)))), + @as(u8, @bitCast(@as(i8, @truncate(m3dcp_vi_t)))), + @as(u8, @bitCast(@as(i8, @truncate(m3dcp_vi_t)))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + }, + }, + m3dcd_t{ + .p = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 2))))), + .a = [8]u8{ + @as(u8, @bitCast(@as(i8, @truncate(m3dcp_va_t)))), + @as(u8, @bitCast(@as(i8, @truncate(m3dcp_vi_t)))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + }, + }, + m3dcd_t{ + .p = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 6))))), + .a = [8]u8{ + @as(u8, @bitCast(@as(i8, @truncate(m3dcp_i2_t)))), + @as(u8, @bitCast(@as(i8, @truncate(m3dcp_ti_t)))), + @as(u8, @bitCast(@as(i8, @truncate(m3dcp_i2_t)))), + @as(u8, @bitCast(@as(i8, @truncate(m3dcp_i2_t)))), + @as(u8, @bitCast(@as(i8, @truncate(m3dcp_ti_t)))), + @as(u8, @bitCast(@as(i8, @truncate(m3dcp_i2_t)))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + }, + }, + m3dcd_t{ + .p = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 2))))), + .a = [8]u8{ + @as(u8, @bitCast(@as(i8, @truncate(m3dcp_va_t)))), + @as(u8, @bitCast(@as(i8, @truncate(m3dcp_vi_t)))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + }, + }, + m3dcd_t{ + .p = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 2))))), + .a = [8]u8{ + @as(u8, @bitCast(@as(i8, @truncate(m3dcp_va_t)))), + @as(u8, @bitCast(@as(i8, @truncate(m3dcp_vi_t)))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + }, + }, + m3dcd_t{ + .p = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 3))))), + .a = [8]u8{ + @as(u8, @bitCast(@as(i8, @truncate(m3dcp_vi_t)))), + @as(u8, @bitCast(@as(i8, @truncate(m3dcp_qi_t)))), + @as(u8, @bitCast(@as(i8, @truncate(m3dcp_vc_t)))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + }, + }, + m3dcd_t{ + .p = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 6))))), + .a = [8]u8{ + @as(u8, @bitCast(@as(i8, @truncate(m3dcp_vi_t)))), + @as(u8, @bitCast(@as(i8, @truncate(m3dcp_qi_t)))), + @as(u8, @bitCast(@as(i8, @truncate(m3dcp_vc_t)))), + @as(u8, @bitCast(@as(i8, @truncate(m3dcp_vi_t)))), + @as(u8, @bitCast(@as(i8, @truncate(m3dcp_qi_t)))), + @as(u8, @bitCast(@as(i8, @truncate(m3dcp_vc_t)))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + }, + }, + m3dcd_t{ + .p = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 2))))), + .a = [8]u8{ + @as(u8, @bitCast(@as(i8, @truncate(m3dcp_vi_t)))), + @as(u8, @bitCast(@as(i8, @truncate(m3dcp_vc_t)))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + }, + }, + m3dcd_t{ + .p = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 4))))), + .a = [8]u8{ + @as(u8, @bitCast(@as(i8, @truncate(m3dcp_vi_t)))), + @as(u8, @bitCast(@as(i8, @truncate(m3dcp_qi_t)))), + @as(u8, @bitCast(@as(i8, @truncate(m3dcp_vc_t)))), + @as(u8, @bitCast(@as(i8, @truncate(m3dcp_vc_t)))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + }, + }, + m3dcd_t{ + .p = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 3))))), + .a = [8]u8{ + @as(u8, @bitCast(@as(i8, @truncate(m3dcp_vi_t)))), + @as(u8, @bitCast(@as(i8, @truncate(m3dcp_vi_t)))), + @as(u8, @bitCast(@as(i8, @truncate(m3dcp_vi_t)))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + }, + }, + m3dcd_t{ + .p = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 3))))), + .a = [8]u8{ + @as(u8, @bitCast(@as(i8, @truncate(m3dcp_vi_t)))), + @as(u8, @bitCast(@as(i8, @truncate(m3dcp_vi_t)))), + @as(u8, @bitCast(@as(i8, @truncate(m3dcp_vi_t)))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 0))))), + }, + }, +}; +pub var _m3dstbi__g_failure_reason: [*c]const u8 = @import("std").mem.zeroes([*c]const u8); +pub const STBI_default: c_int = 0; +pub const STBI_grey: c_int = 1; +pub const STBI_grey_alpha: c_int = 2; +pub const STBI_rgb: c_int = 3; +pub const STBI_rgb_alpha: c_int = 4; +const enum_unnamed_13 = c_uint; +pub const STBI__SCAN_load: c_int = 0; +pub const STBI__SCAN_type: c_int = 1; +pub const STBI__SCAN_header: c_int = 2; +const enum_unnamed_14 = c_uint; +pub const _m3dstbi_us = c_ushort; +pub const _m3dstbi__uint16 = u16; +pub const _m3dstbi__int16 = i16; +pub const _m3dstbi__uint32 = u32; +pub const _m3dstbi__int32 = i32; +pub const _m3dstbi__context = extern struct { + img_x: _m3dstbi__uint32 = @import("std").mem.zeroes(_m3dstbi__uint32), + img_y: _m3dstbi__uint32 = @import("std").mem.zeroes(_m3dstbi__uint32), + img_n: c_int = @import("std").mem.zeroes(c_int), + img_out_n: c_int = @import("std").mem.zeroes(c_int), + io_user_data: ?*anyopaque = @import("std").mem.zeroes(?*anyopaque), + read_from_callbacks: c_int = @import("std").mem.zeroes(c_int), + buflen: c_int = @import("std").mem.zeroes(c_int), + buffer_start: [128]u8 = @import("std").mem.zeroes([128]u8), + img_buffer: [*c]u8 = @import("std").mem.zeroes([*c]u8), + img_buffer_end: [*c]u8 = @import("std").mem.zeroes([*c]u8), + img_buffer_original: [*c]u8 = @import("std").mem.zeroes([*c]u8), + img_buffer_original_end: [*c]u8 = @import("std").mem.zeroes([*c]u8), +}; +pub const _m3dstbi__result_info = extern struct { + bits_per_channel: c_int = @import("std").mem.zeroes(c_int), + num_channels: c_int = @import("std").mem.zeroes(c_int), + channel_order: c_int = @import("std").mem.zeroes(c_int), +}; +pub fn _m3dstbi__get8(arg_s: [*c]_m3dstbi__context) callconv(.C) u8 { + var s = arg_s; + _ = &s; + if (s.*.img_buffer < s.*.img_buffer_end) return (blk: { + const ref = &s.*.img_buffer; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).*; + return 0; +} +pub fn _m3dstbi__at_eof(arg_s: [*c]_m3dstbi__context) callconv(.C) c_int { + var s = arg_s; + _ = &s; + return @intFromBool(s.*.img_buffer >= s.*.img_buffer_end); +} +pub fn _m3dstbi__skip(arg_s: [*c]_m3dstbi__context, arg_n: c_int) callconv(.C) void { + var s = arg_s; + _ = &s; + var n = arg_n; + _ = &n; + if (n < @as(c_int, 0)) { + s.*.img_buffer = s.*.img_buffer_end; + return; + } + s.*.img_buffer += @as(usize, @bitCast(@as(isize, @intCast(n)))); +} +pub fn _m3dstbi__getn(arg_s: [*c]_m3dstbi__context, arg_buffer: [*c]u8, arg_n: c_int) callconv(.C) c_int { + var s = arg_s; + _ = &s; + var buffer = arg_buffer; + _ = &buffer; + var n = arg_n; + _ = &n; + if ((s.*.img_buffer + @as(usize, @bitCast(@as(isize, @intCast(n))))) <= s.*.img_buffer_end) { + _ = memcpy(@as(?*anyopaque, @ptrCast(buffer)), @as(?*const anyopaque, @ptrCast(s.*.img_buffer)), @as(c_ulong, @bitCast(@as(c_long, n)))); + s.*.img_buffer += @as(usize, @bitCast(@as(isize, @intCast(n)))); + return 1; + } else return 0; + return 0; +} +pub fn _m3dstbi__get16be(arg_s: [*c]_m3dstbi__context) callconv(.C) c_int { + var s = arg_s; + _ = &s; + var z: c_int = @as(c_int, @bitCast(@as(c_uint, _m3dstbi__get8(s)))); + _ = &z; + return (z << @intCast(8)) + @as(c_int, @bitCast(@as(c_uint, _m3dstbi__get8(s)))); +} +pub fn _m3dstbi__get32be(arg_s: [*c]_m3dstbi__context) callconv(.C) _m3dstbi__uint32 { + var s = arg_s; + _ = &s; + var z: _m3dstbi__uint32 = @as(_m3dstbi__uint32, @bitCast(_m3dstbi__get16be(s))); + _ = &z; + return (z << @intCast(16)) +% @as(_m3dstbi__uint32, @bitCast(_m3dstbi__get16be(s))); +} +pub fn _m3dstbi__errstr(arg_str: [*c]const u8) callconv(.C) c_int { + var str = arg_str; + _ = &str; + _m3dstbi__g_failure_reason = str; + return 0; +} +pub fn _m3dstbi__malloc(arg_size: usize) callconv(.C) ?*anyopaque { + var size = arg_size; + _ = &size; + return malloc(size); +} +pub fn _m3dstbi__addsizes_valid(arg_a: c_int, arg_b: c_int) callconv(.C) c_int { + var a = arg_a; + _ = &a; + var b = arg_b; + _ = &b; + if (b < @as(c_int, 0)) return 0; + return @intFromBool(a <= (@as(c_int, 2147483647) - b)); +} +pub fn _m3dstbi__mul2sizes_valid(arg_a: c_int, arg_b: c_int) callconv(.C) c_int { + var a = arg_a; + _ = &a; + var b = arg_b; + _ = &b; + if ((a < @as(c_int, 0)) or (b < @as(c_int, 0))) return 0; + if (b == @as(c_int, 0)) return 1; + return @intFromBool(a <= @divTrunc(@as(c_int, 2147483647), b)); +} +pub fn _m3dstbi__mad2sizes_valid(arg_a: c_int, arg_b: c_int, arg_add: c_int) callconv(.C) c_int { + var a = arg_a; + _ = &a; + var b = arg_b; + _ = &b; + var add = arg_add; + _ = &add; + return @intFromBool((_m3dstbi__mul2sizes_valid(a, b) != 0) and (_m3dstbi__addsizes_valid(a * b, add) != 0)); +} +pub fn _m3dstbi__mad3sizes_valid(arg_a: c_int, arg_b: c_int, arg_c: c_int, arg_add: c_int) callconv(.C) c_int { + var a = arg_a; + _ = &a; + var b = arg_b; + _ = &b; + var c = arg_c; + _ = &c; + var add = arg_add; + _ = &add; + return @intFromBool(((_m3dstbi__mul2sizes_valid(a, b) != 0) and (_m3dstbi__mul2sizes_valid(a * b, c) != 0)) and (_m3dstbi__addsizes_valid((a * b) * c, add) != 0)); +} +pub fn _m3dstbi__malloc_mad2(arg_a: c_int, arg_b: c_int, arg_add: c_int) callconv(.C) ?*anyopaque { + var a = arg_a; + _ = &a; + var b = arg_b; + _ = &b; + var add = arg_add; + _ = &add; + if (!(_m3dstbi__mad2sizes_valid(a, b, add) != 0)) return @as(?*anyopaque, @ptrFromInt(@as(c_int, 0))); + return _m3dstbi__malloc(@as(usize, @bitCast(@as(c_long, (a * b) + add)))); +} +pub fn _m3dstbi__malloc_mad3(arg_a: c_int, arg_b: c_int, arg_c: c_int, arg_add: c_int) callconv(.C) ?*anyopaque { + var a = arg_a; + _ = &a; + var b = arg_b; + _ = &b; + var c = arg_c; + _ = &c; + var add = arg_add; + _ = &add; + if (!(_m3dstbi__mad3sizes_valid(a, b, c, add) != 0)) return @as(?*anyopaque, @ptrFromInt(@as(c_int, 0))); + return _m3dstbi__malloc(@as(usize, @bitCast(@as(c_long, ((a * b) * c) + add)))); +} +pub fn _m3dstbi__compute_y(arg_r: c_int, arg_g: c_int, arg_b: c_int) callconv(.C) u8 { + var r = arg_r; + _ = &r; + var g = arg_g; + _ = &g; + var b = arg_b; + _ = &b; + return @as(u8, @bitCast(@as(i8, @truncate((((r * @as(c_int, 77)) + (g * @as(c_int, 150))) + (@as(c_int, 29) * b)) >> @intCast(8))))); +} +pub fn _m3dstbi__convert_format(arg_data: [*c]u8, arg_img_n: c_int, arg_req_comp: c_int, arg_x: c_uint, arg_y: c_uint) callconv(.C) [*c]u8 { + var data = arg_data; + _ = &data; + var img_n = arg_img_n; + _ = &img_n; + var req_comp = arg_req_comp; + _ = &req_comp; + var x = arg_x; + _ = &x; + var y = arg_y; + _ = &y; + var i: c_int = undefined; + _ = &i; + var j: c_int = undefined; + _ = &j; + var good: [*c]u8 = undefined; + _ = &good; + if (req_comp == img_n) return data; + good = @as([*c]u8, @ptrCast(@alignCast(_m3dstbi__malloc_mad3(req_comp, @as(c_int, @bitCast(x)), @as(c_int, @bitCast(y)), @as(c_int, 0))))); + if (good == @as([*c]u8, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0))))))) { + free(@as(?*anyopaque, @ptrCast(data))); + _ = _m3dstbi__errstr("Out of memory"); + return null; + } + { + j = 0; + while (j < @as(c_int, @bitCast(y))) : (j += 1) { + var src: [*c]u8 = data + ((@as(c_uint, @bitCast(j)) *% x) *% @as(c_uint, @bitCast(img_n))); + _ = &src; + var dest: [*c]u8 = good + ((@as(c_uint, @bitCast(j)) *% x) *% @as(c_uint, @bitCast(req_comp))); + _ = &dest; + while (true) { + switch ((img_n * @as(c_int, 8)) + req_comp) { + @as(c_int, 10) => { + { + i = @as(c_int, @bitCast(x -% @as(c_uint, @bitCast(@as(c_int, 1))))); + while (i >= @as(c_int, 0)) : (_ = blk: { + _ = blk_1: { + i -= 1; + break :blk_1 blk_2: { + const ref = &src; + ref.* += @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 1))))); + break :blk_2 ref.*; + }; + }; + break :blk blk_1: { + const ref = &dest; + ref.* += @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 2))))); + break :blk_1 ref.*; + }; + }) { + _ = blk: { + dest[@as(c_uint, @intCast(@as(c_int, 0)))] = src[@as(c_uint, @intCast(@as(c_int, 0)))]; + break :blk blk_1: { + const tmp = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 255))))); + dest[@as(c_uint, @intCast(@as(c_int, 1)))] = tmp; + break :blk_1 tmp; + }; + }; + } + } + break; + }, + @as(c_int, 11) => { + { + i = @as(c_int, @bitCast(x -% @as(c_uint, @bitCast(@as(c_int, 1))))); + while (i >= @as(c_int, 0)) : (_ = blk: { + _ = blk_1: { + i -= 1; + break :blk_1 blk_2: { + const ref = &src; + ref.* += @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 1))))); + break :blk_2 ref.*; + }; + }; + break :blk blk_1: { + const ref = &dest; + ref.* += @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 3))))); + break :blk_1 ref.*; + }; + }) { + dest[@as(c_uint, @intCast(@as(c_int, 0)))] = blk: { + const tmp = blk_1: { + const tmp_2 = src[@as(c_uint, @intCast(@as(c_int, 0)))]; + dest[@as(c_uint, @intCast(@as(c_int, 2)))] = tmp_2; + break :blk_1 tmp_2; + }; + dest[@as(c_uint, @intCast(@as(c_int, 1)))] = tmp; + break :blk tmp; + }; + } + } + break; + }, + @as(c_int, 12) => { + { + i = @as(c_int, @bitCast(x -% @as(c_uint, @bitCast(@as(c_int, 1))))); + while (i >= @as(c_int, 0)) : (_ = blk: { + _ = blk_1: { + i -= 1; + break :blk_1 blk_2: { + const ref = &src; + ref.* += @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 1))))); + break :blk_2 ref.*; + }; + }; + break :blk blk_1: { + const ref = &dest; + ref.* += @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 4))))); + break :blk_1 ref.*; + }; + }) { + _ = blk: { + dest[@as(c_uint, @intCast(@as(c_int, 0)))] = blk_1: { + const tmp = blk_2: { + const tmp_3 = src[@as(c_uint, @intCast(@as(c_int, 0)))]; + dest[@as(c_uint, @intCast(@as(c_int, 2)))] = tmp_3; + break :blk_2 tmp_3; + }; + dest[@as(c_uint, @intCast(@as(c_int, 1)))] = tmp; + break :blk_1 tmp; + }; + break :blk blk_1: { + const tmp = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 255))))); + dest[@as(c_uint, @intCast(@as(c_int, 3)))] = tmp; + break :blk_1 tmp; + }; + }; + } + } + break; + }, + @as(c_int, 17) => { + { + i = @as(c_int, @bitCast(x -% @as(c_uint, @bitCast(@as(c_int, 1))))); + while (i >= @as(c_int, 0)) : (_ = blk: { + _ = blk_1: { + i -= 1; + break :blk_1 blk_2: { + const ref = &src; + ref.* += @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 2))))); + break :blk_2 ref.*; + }; + }; + break :blk blk_1: { + const ref = &dest; + ref.* += @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 1))))); + break :blk_1 ref.*; + }; + }) { + dest[@as(c_uint, @intCast(@as(c_int, 0)))] = src[@as(c_uint, @intCast(@as(c_int, 0)))]; + } + } + break; + }, + @as(c_int, 19) => { + { + i = @as(c_int, @bitCast(x -% @as(c_uint, @bitCast(@as(c_int, 1))))); + while (i >= @as(c_int, 0)) : (_ = blk: { + _ = blk_1: { + i -= 1; + break :blk_1 blk_2: { + const ref = &src; + ref.* += @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 2))))); + break :blk_2 ref.*; + }; + }; + break :blk blk_1: { + const ref = &dest; + ref.* += @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 3))))); + break :blk_1 ref.*; + }; + }) { + dest[@as(c_uint, @intCast(@as(c_int, 0)))] = blk: { + const tmp = blk_1: { + const tmp_2 = src[@as(c_uint, @intCast(@as(c_int, 0)))]; + dest[@as(c_uint, @intCast(@as(c_int, 2)))] = tmp_2; + break :blk_1 tmp_2; + }; + dest[@as(c_uint, @intCast(@as(c_int, 1)))] = tmp; + break :blk tmp; + }; + } + } + break; + }, + @as(c_int, 20) => { + { + i = @as(c_int, @bitCast(x -% @as(c_uint, @bitCast(@as(c_int, 1))))); + while (i >= @as(c_int, 0)) : (_ = blk: { + _ = blk_1: { + i -= 1; + break :blk_1 blk_2: { + const ref = &src; + ref.* += @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 2))))); + break :blk_2 ref.*; + }; + }; + break :blk blk_1: { + const ref = &dest; + ref.* += @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 4))))); + break :blk_1 ref.*; + }; + }) { + _ = blk: { + dest[@as(c_uint, @intCast(@as(c_int, 0)))] = blk_1: { + const tmp = blk_2: { + const tmp_3 = src[@as(c_uint, @intCast(@as(c_int, 0)))]; + dest[@as(c_uint, @intCast(@as(c_int, 2)))] = tmp_3; + break :blk_2 tmp_3; + }; + dest[@as(c_uint, @intCast(@as(c_int, 1)))] = tmp; + break :blk_1 tmp; + }; + break :blk blk_1: { + const tmp = src[@as(c_uint, @intCast(@as(c_int, 1)))]; + dest[@as(c_uint, @intCast(@as(c_int, 3)))] = tmp; + break :blk_1 tmp; + }; + }; + } + } + break; + }, + @as(c_int, 28) => { + { + i = @as(c_int, @bitCast(x -% @as(c_uint, @bitCast(@as(c_int, 1))))); + while (i >= @as(c_int, 0)) : (_ = blk: { + _ = blk_1: { + i -= 1; + break :blk_1 blk_2: { + const ref = &src; + ref.* += @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 3))))); + break :blk_2 ref.*; + }; + }; + break :blk blk_1: { + const ref = &dest; + ref.* += @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 4))))); + break :blk_1 ref.*; + }; + }) { + _ = blk: { + _ = blk_1: { + _ = blk_2: { + dest[@as(c_uint, @intCast(@as(c_int, 0)))] = src[@as(c_uint, @intCast(@as(c_int, 0)))]; + break :blk_2 blk_3: { + const tmp = src[@as(c_uint, @intCast(@as(c_int, 1)))]; + dest[@as(c_uint, @intCast(@as(c_int, 1)))] = tmp; + break :blk_3 tmp; + }; + }; + break :blk_1 blk_2: { + const tmp = src[@as(c_uint, @intCast(@as(c_int, 2)))]; + dest[@as(c_uint, @intCast(@as(c_int, 2)))] = tmp; + break :blk_2 tmp; + }; + }; + break :blk blk_1: { + const tmp = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 255))))); + dest[@as(c_uint, @intCast(@as(c_int, 3)))] = tmp; + break :blk_1 tmp; + }; + }; + } + } + break; + }, + @as(c_int, 25) => { + { + i = @as(c_int, @bitCast(x -% @as(c_uint, @bitCast(@as(c_int, 1))))); + while (i >= @as(c_int, 0)) : (_ = blk: { + _ = blk_1: { + i -= 1; + break :blk_1 blk_2: { + const ref = &src; + ref.* += @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 3))))); + break :blk_2 ref.*; + }; + }; + break :blk blk_1: { + const ref = &dest; + ref.* += @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 1))))); + break :blk_1 ref.*; + }; + }) { + dest[@as(c_uint, @intCast(@as(c_int, 0)))] = _m3dstbi__compute_y(@as(c_int, @bitCast(@as(c_uint, src[@as(c_uint, @intCast(@as(c_int, 0)))]))), @as(c_int, @bitCast(@as(c_uint, src[@as(c_uint, @intCast(@as(c_int, 1)))]))), @as(c_int, @bitCast(@as(c_uint, src[@as(c_uint, @intCast(@as(c_int, 2)))])))); + } + } + break; + }, + @as(c_int, 26) => { + { + i = @as(c_int, @bitCast(x -% @as(c_uint, @bitCast(@as(c_int, 1))))); + while (i >= @as(c_int, 0)) : (_ = blk: { + _ = blk_1: { + i -= 1; + break :blk_1 blk_2: { + const ref = &src; + ref.* += @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 3))))); + break :blk_2 ref.*; + }; + }; + break :blk blk_1: { + const ref = &dest; + ref.* += @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 2))))); + break :blk_1 ref.*; + }; + }) { + _ = blk: { + dest[@as(c_uint, @intCast(@as(c_int, 0)))] = _m3dstbi__compute_y(@as(c_int, @bitCast(@as(c_uint, src[@as(c_uint, @intCast(@as(c_int, 0)))]))), @as(c_int, @bitCast(@as(c_uint, src[@as(c_uint, @intCast(@as(c_int, 1)))]))), @as(c_int, @bitCast(@as(c_uint, src[@as(c_uint, @intCast(@as(c_int, 2)))])))); + break :blk blk_1: { + const tmp = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 255))))); + dest[@as(c_uint, @intCast(@as(c_int, 1)))] = tmp; + break :blk_1 tmp; + }; + }; + } + } + break; + }, + @as(c_int, 33) => { + { + i = @as(c_int, @bitCast(x -% @as(c_uint, @bitCast(@as(c_int, 1))))); + while (i >= @as(c_int, 0)) : (_ = blk: { + _ = blk_1: { + i -= 1; + break :blk_1 blk_2: { + const ref = &src; + ref.* += @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 4))))); + break :blk_2 ref.*; + }; + }; + break :blk blk_1: { + const ref = &dest; + ref.* += @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 1))))); + break :blk_1 ref.*; + }; + }) { + dest[@as(c_uint, @intCast(@as(c_int, 0)))] = _m3dstbi__compute_y(@as(c_int, @bitCast(@as(c_uint, src[@as(c_uint, @intCast(@as(c_int, 0)))]))), @as(c_int, @bitCast(@as(c_uint, src[@as(c_uint, @intCast(@as(c_int, 1)))]))), @as(c_int, @bitCast(@as(c_uint, src[@as(c_uint, @intCast(@as(c_int, 2)))])))); + } + } + break; + }, + @as(c_int, 34) => { + { + i = @as(c_int, @bitCast(x -% @as(c_uint, @bitCast(@as(c_int, 1))))); + while (i >= @as(c_int, 0)) : (_ = blk: { + _ = blk_1: { + i -= 1; + break :blk_1 blk_2: { + const ref = &src; + ref.* += @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 4))))); + break :blk_2 ref.*; + }; + }; + break :blk blk_1: { + const ref = &dest; + ref.* += @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 2))))); + break :blk_1 ref.*; + }; + }) { + _ = blk: { + dest[@as(c_uint, @intCast(@as(c_int, 0)))] = _m3dstbi__compute_y(@as(c_int, @bitCast(@as(c_uint, src[@as(c_uint, @intCast(@as(c_int, 0)))]))), @as(c_int, @bitCast(@as(c_uint, src[@as(c_uint, @intCast(@as(c_int, 1)))]))), @as(c_int, @bitCast(@as(c_uint, src[@as(c_uint, @intCast(@as(c_int, 2)))])))); + break :blk blk_1: { + const tmp = src[@as(c_uint, @intCast(@as(c_int, 3)))]; + dest[@as(c_uint, @intCast(@as(c_int, 1)))] = tmp; + break :blk_1 tmp; + }; + }; + } + } + break; + }, + @as(c_int, 35) => { + { + i = @as(c_int, @bitCast(x -% @as(c_uint, @bitCast(@as(c_int, 1))))); + while (i >= @as(c_int, 0)) : (_ = blk: { + _ = blk_1: { + i -= 1; + break :blk_1 blk_2: { + const ref = &src; + ref.* += @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 4))))); + break :blk_2 ref.*; + }; + }; + break :blk blk_1: { + const ref = &dest; + ref.* += @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 3))))); + break :blk_1 ref.*; + }; + }) { + _ = blk: { + _ = blk_1: { + dest[@as(c_uint, @intCast(@as(c_int, 0)))] = src[@as(c_uint, @intCast(@as(c_int, 0)))]; + break :blk_1 blk_2: { + const tmp = src[@as(c_uint, @intCast(@as(c_int, 1)))]; + dest[@as(c_uint, @intCast(@as(c_int, 1)))] = tmp; + break :blk_2 tmp; + }; + }; + break :blk blk_1: { + const tmp = src[@as(c_uint, @intCast(@as(c_int, 2)))]; + dest[@as(c_uint, @intCast(@as(c_int, 2)))] = tmp; + break :blk_1 tmp; + }; + }; + } + } + break; + }, + else => { + {} + }, + } + break; + } + } + } + free(@as(?*anyopaque, @ptrCast(data))); + return good; +} +pub fn _m3dstbi__compute_y_16(arg_r: c_int, arg_g: c_int, arg_b: c_int) callconv(.C) _m3dstbi__uint16 { + var r = arg_r; + _ = &r; + var g = arg_g; + _ = &g; + var b = arg_b; + _ = &b; + return @as(_m3dstbi__uint16, @bitCast(@as(c_short, @truncate((((r * @as(c_int, 77)) + (g * @as(c_int, 150))) + (@as(c_int, 29) * b)) >> @intCast(8))))); +} +pub fn _m3dstbi__convert_format16(arg_data: [*c]_m3dstbi__uint16, arg_img_n: c_int, arg_req_comp: c_int, arg_x: c_uint, arg_y: c_uint) callconv(.C) [*c]_m3dstbi__uint16 { + var data = arg_data; + _ = &data; + var img_n = arg_img_n; + _ = &img_n; + var req_comp = arg_req_comp; + _ = &req_comp; + var x = arg_x; + _ = &x; + var y = arg_y; + _ = &y; + var i: c_int = undefined; + _ = &i; + var j: c_int = undefined; + _ = &j; + var good: [*c]_m3dstbi__uint16 = undefined; + _ = &good; + if (req_comp == img_n) return data; + good = @as([*c]_m3dstbi__uint16, @ptrCast(@alignCast(_m3dstbi__malloc(@as(usize, @bitCast(@as(c_ulong, ((@as(c_uint, @bitCast(req_comp)) *% x) *% y) *% @as(c_uint, @bitCast(@as(c_int, 2)))))))))); + if (good == @as([*c]_m3dstbi__uint16, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0))))))) { + free(@as(?*anyopaque, @ptrCast(data))); + _ = _m3dstbi__errstr("Out of memory"); + return null; + } + { + j = 0; + while (j < @as(c_int, @bitCast(y))) : (j += 1) { + var src: [*c]_m3dstbi__uint16 = data + ((@as(c_uint, @bitCast(j)) *% x) *% @as(c_uint, @bitCast(img_n))); + _ = &src; + var dest: [*c]_m3dstbi__uint16 = good + ((@as(c_uint, @bitCast(j)) *% x) *% @as(c_uint, @bitCast(req_comp))); + _ = &dest; + while (true) { + switch ((img_n * @as(c_int, 8)) + req_comp) { + @as(c_int, 10) => { + { + i = @as(c_int, @bitCast(x -% @as(c_uint, @bitCast(@as(c_int, 1))))); + while (i >= @as(c_int, 0)) : (_ = blk: { + _ = blk_1: { + i -= 1; + break :blk_1 blk_2: { + const ref = &src; + ref.* += @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 1))))); + break :blk_2 ref.*; + }; + }; + break :blk blk_1: { + const ref = &dest; + ref.* += @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 2))))); + break :blk_1 ref.*; + }; + }) { + _ = blk: { + dest[@as(c_uint, @intCast(@as(c_int, 0)))] = src[@as(c_uint, @intCast(@as(c_int, 0)))]; + break :blk blk_1: { + const tmp = @as(_m3dstbi__uint16, @bitCast(@as(c_short, @truncate(@as(c_int, 65535))))); + dest[@as(c_uint, @intCast(@as(c_int, 1)))] = tmp; + break :blk_1 tmp; + }; + }; + } + } + break; + }, + @as(c_int, 11) => { + { + i = @as(c_int, @bitCast(x -% @as(c_uint, @bitCast(@as(c_int, 1))))); + while (i >= @as(c_int, 0)) : (_ = blk: { + _ = blk_1: { + i -= 1; + break :blk_1 blk_2: { + const ref = &src; + ref.* += @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 1))))); + break :blk_2 ref.*; + }; + }; + break :blk blk_1: { + const ref = &dest; + ref.* += @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 3))))); + break :blk_1 ref.*; + }; + }) { + dest[@as(c_uint, @intCast(@as(c_int, 0)))] = blk: { + const tmp = blk_1: { + const tmp_2 = src[@as(c_uint, @intCast(@as(c_int, 0)))]; + dest[@as(c_uint, @intCast(@as(c_int, 2)))] = tmp_2; + break :blk_1 tmp_2; + }; + dest[@as(c_uint, @intCast(@as(c_int, 1)))] = tmp; + break :blk tmp; + }; + } + } + break; + }, + @as(c_int, 12) => { + { + i = @as(c_int, @bitCast(x -% @as(c_uint, @bitCast(@as(c_int, 1))))); + while (i >= @as(c_int, 0)) : (_ = blk: { + _ = blk_1: { + i -= 1; + break :blk_1 blk_2: { + const ref = &src; + ref.* += @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 1))))); + break :blk_2 ref.*; + }; + }; + break :blk blk_1: { + const ref = &dest; + ref.* += @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 4))))); + break :blk_1 ref.*; + }; + }) { + _ = blk: { + dest[@as(c_uint, @intCast(@as(c_int, 0)))] = blk_1: { + const tmp = blk_2: { + const tmp_3 = src[@as(c_uint, @intCast(@as(c_int, 0)))]; + dest[@as(c_uint, @intCast(@as(c_int, 2)))] = tmp_3; + break :blk_2 tmp_3; + }; + dest[@as(c_uint, @intCast(@as(c_int, 1)))] = tmp; + break :blk_1 tmp; + }; + break :blk blk_1: { + const tmp = @as(_m3dstbi__uint16, @bitCast(@as(c_short, @truncate(@as(c_int, 65535))))); + dest[@as(c_uint, @intCast(@as(c_int, 3)))] = tmp; + break :blk_1 tmp; + }; + }; + } + } + break; + }, + @as(c_int, 17) => { + { + i = @as(c_int, @bitCast(x -% @as(c_uint, @bitCast(@as(c_int, 1))))); + while (i >= @as(c_int, 0)) : (_ = blk: { + _ = blk_1: { + i -= 1; + break :blk_1 blk_2: { + const ref = &src; + ref.* += @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 2))))); + break :blk_2 ref.*; + }; + }; + break :blk blk_1: { + const ref = &dest; + ref.* += @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 1))))); + break :blk_1 ref.*; + }; + }) { + dest[@as(c_uint, @intCast(@as(c_int, 0)))] = src[@as(c_uint, @intCast(@as(c_int, 0)))]; + } + } + break; + }, + @as(c_int, 19) => { + { + i = @as(c_int, @bitCast(x -% @as(c_uint, @bitCast(@as(c_int, 1))))); + while (i >= @as(c_int, 0)) : (_ = blk: { + _ = blk_1: { + i -= 1; + break :blk_1 blk_2: { + const ref = &src; + ref.* += @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 2))))); + break :blk_2 ref.*; + }; + }; + break :blk blk_1: { + const ref = &dest; + ref.* += @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 3))))); + break :blk_1 ref.*; + }; + }) { + dest[@as(c_uint, @intCast(@as(c_int, 0)))] = blk: { + const tmp = blk_1: { + const tmp_2 = src[@as(c_uint, @intCast(@as(c_int, 0)))]; + dest[@as(c_uint, @intCast(@as(c_int, 2)))] = tmp_2; + break :blk_1 tmp_2; + }; + dest[@as(c_uint, @intCast(@as(c_int, 1)))] = tmp; + break :blk tmp; + }; + } + } + break; + }, + @as(c_int, 20) => { + { + i = @as(c_int, @bitCast(x -% @as(c_uint, @bitCast(@as(c_int, 1))))); + while (i >= @as(c_int, 0)) : (_ = blk: { + _ = blk_1: { + i -= 1; + break :blk_1 blk_2: { + const ref = &src; + ref.* += @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 2))))); + break :blk_2 ref.*; + }; + }; + break :blk blk_1: { + const ref = &dest; + ref.* += @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 4))))); + break :blk_1 ref.*; + }; + }) { + _ = blk: { + dest[@as(c_uint, @intCast(@as(c_int, 0)))] = blk_1: { + const tmp = blk_2: { + const tmp_3 = src[@as(c_uint, @intCast(@as(c_int, 0)))]; + dest[@as(c_uint, @intCast(@as(c_int, 2)))] = tmp_3; + break :blk_2 tmp_3; + }; + dest[@as(c_uint, @intCast(@as(c_int, 1)))] = tmp; + break :blk_1 tmp; + }; + break :blk blk_1: { + const tmp = src[@as(c_uint, @intCast(@as(c_int, 1)))]; + dest[@as(c_uint, @intCast(@as(c_int, 3)))] = tmp; + break :blk_1 tmp; + }; + }; + } + } + break; + }, + @as(c_int, 28) => { + { + i = @as(c_int, @bitCast(x -% @as(c_uint, @bitCast(@as(c_int, 1))))); + while (i >= @as(c_int, 0)) : (_ = blk: { + _ = blk_1: { + i -= 1; + break :blk_1 blk_2: { + const ref = &src; + ref.* += @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 3))))); + break :blk_2 ref.*; + }; + }; + break :blk blk_1: { + const ref = &dest; + ref.* += @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 4))))); + break :blk_1 ref.*; + }; + }) { + _ = blk: { + _ = blk_1: { + _ = blk_2: { + dest[@as(c_uint, @intCast(@as(c_int, 0)))] = src[@as(c_uint, @intCast(@as(c_int, 0)))]; + break :blk_2 blk_3: { + const tmp = src[@as(c_uint, @intCast(@as(c_int, 1)))]; + dest[@as(c_uint, @intCast(@as(c_int, 1)))] = tmp; + break :blk_3 tmp; + }; + }; + break :blk_1 blk_2: { + const tmp = src[@as(c_uint, @intCast(@as(c_int, 2)))]; + dest[@as(c_uint, @intCast(@as(c_int, 2)))] = tmp; + break :blk_2 tmp; + }; + }; + break :blk blk_1: { + const tmp = @as(_m3dstbi__uint16, @bitCast(@as(c_short, @truncate(@as(c_int, 65535))))); + dest[@as(c_uint, @intCast(@as(c_int, 3)))] = tmp; + break :blk_1 tmp; + }; + }; + } + } + break; + }, + @as(c_int, 25) => { + { + i = @as(c_int, @bitCast(x -% @as(c_uint, @bitCast(@as(c_int, 1))))); + while (i >= @as(c_int, 0)) : (_ = blk: { + _ = blk_1: { + i -= 1; + break :blk_1 blk_2: { + const ref = &src; + ref.* += @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 3))))); + break :blk_2 ref.*; + }; + }; + break :blk blk_1: { + const ref = &dest; + ref.* += @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 1))))); + break :blk_1 ref.*; + }; + }) { + dest[@as(c_uint, @intCast(@as(c_int, 0)))] = _m3dstbi__compute_y_16(@as(c_int, @bitCast(@as(c_uint, src[@as(c_uint, @intCast(@as(c_int, 0)))]))), @as(c_int, @bitCast(@as(c_uint, src[@as(c_uint, @intCast(@as(c_int, 1)))]))), @as(c_int, @bitCast(@as(c_uint, src[@as(c_uint, @intCast(@as(c_int, 2)))])))); + } + } + break; + }, + @as(c_int, 26) => { + { + i = @as(c_int, @bitCast(x -% @as(c_uint, @bitCast(@as(c_int, 1))))); + while (i >= @as(c_int, 0)) : (_ = blk: { + _ = blk_1: { + i -= 1; + break :blk_1 blk_2: { + const ref = &src; + ref.* += @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 3))))); + break :blk_2 ref.*; + }; + }; + break :blk blk_1: { + const ref = &dest; + ref.* += @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 2))))); + break :blk_1 ref.*; + }; + }) { + _ = blk: { + dest[@as(c_uint, @intCast(@as(c_int, 0)))] = _m3dstbi__compute_y_16(@as(c_int, @bitCast(@as(c_uint, src[@as(c_uint, @intCast(@as(c_int, 0)))]))), @as(c_int, @bitCast(@as(c_uint, src[@as(c_uint, @intCast(@as(c_int, 1)))]))), @as(c_int, @bitCast(@as(c_uint, src[@as(c_uint, @intCast(@as(c_int, 2)))])))); + break :blk blk_1: { + const tmp = @as(_m3dstbi__uint16, @bitCast(@as(c_short, @truncate(@as(c_int, 65535))))); + dest[@as(c_uint, @intCast(@as(c_int, 1)))] = tmp; + break :blk_1 tmp; + }; + }; + } + } + break; + }, + @as(c_int, 33) => { + { + i = @as(c_int, @bitCast(x -% @as(c_uint, @bitCast(@as(c_int, 1))))); + while (i >= @as(c_int, 0)) : (_ = blk: { + _ = blk_1: { + i -= 1; + break :blk_1 blk_2: { + const ref = &src; + ref.* += @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 4))))); + break :blk_2 ref.*; + }; + }; + break :blk blk_1: { + const ref = &dest; + ref.* += @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 1))))); + break :blk_1 ref.*; + }; + }) { + dest[@as(c_uint, @intCast(@as(c_int, 0)))] = _m3dstbi__compute_y_16(@as(c_int, @bitCast(@as(c_uint, src[@as(c_uint, @intCast(@as(c_int, 0)))]))), @as(c_int, @bitCast(@as(c_uint, src[@as(c_uint, @intCast(@as(c_int, 1)))]))), @as(c_int, @bitCast(@as(c_uint, src[@as(c_uint, @intCast(@as(c_int, 2)))])))); + } + } + break; + }, + @as(c_int, 34) => { + { + i = @as(c_int, @bitCast(x -% @as(c_uint, @bitCast(@as(c_int, 1))))); + while (i >= @as(c_int, 0)) : (_ = blk: { + _ = blk_1: { + i -= 1; + break :blk_1 blk_2: { + const ref = &src; + ref.* += @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 4))))); + break :blk_2 ref.*; + }; + }; + break :blk blk_1: { + const ref = &dest; + ref.* += @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 2))))); + break :blk_1 ref.*; + }; + }) { + _ = blk: { + dest[@as(c_uint, @intCast(@as(c_int, 0)))] = _m3dstbi__compute_y_16(@as(c_int, @bitCast(@as(c_uint, src[@as(c_uint, @intCast(@as(c_int, 0)))]))), @as(c_int, @bitCast(@as(c_uint, src[@as(c_uint, @intCast(@as(c_int, 1)))]))), @as(c_int, @bitCast(@as(c_uint, src[@as(c_uint, @intCast(@as(c_int, 2)))])))); + break :blk blk_1: { + const tmp = src[@as(c_uint, @intCast(@as(c_int, 3)))]; + dest[@as(c_uint, @intCast(@as(c_int, 1)))] = tmp; + break :blk_1 tmp; + }; + }; + } + } + break; + }, + @as(c_int, 35) => { + { + i = @as(c_int, @bitCast(x -% @as(c_uint, @bitCast(@as(c_int, 1))))); + while (i >= @as(c_int, 0)) : (_ = blk: { + _ = blk_1: { + i -= 1; + break :blk_1 blk_2: { + const ref = &src; + ref.* += @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 4))))); + break :blk_2 ref.*; + }; + }; + break :blk blk_1: { + const ref = &dest; + ref.* += @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 3))))); + break :blk_1 ref.*; + }; + }) { + _ = blk: { + _ = blk_1: { + dest[@as(c_uint, @intCast(@as(c_int, 0)))] = src[@as(c_uint, @intCast(@as(c_int, 0)))]; + break :blk_1 blk_2: { + const tmp = src[@as(c_uint, @intCast(@as(c_int, 1)))]; + dest[@as(c_uint, @intCast(@as(c_int, 1)))] = tmp; + break :blk_2 tmp; + }; + }; + break :blk blk_1: { + const tmp = src[@as(c_uint, @intCast(@as(c_int, 2)))]; + dest[@as(c_uint, @intCast(@as(c_int, 2)))] = tmp; + break :blk_1 tmp; + }; + }; + } + } + break; + }, + else => { + {} + }, + } + break; + } + } + } + free(@as(?*anyopaque, @ptrCast(data))); + return good; +} +pub const _m3dstbi__zhuffman = extern struct { + fast: [512]_m3dstbi__uint16 = @import("std").mem.zeroes([512]_m3dstbi__uint16), + firstcode: [16]_m3dstbi__uint16 = @import("std").mem.zeroes([16]_m3dstbi__uint16), + maxcode: [17]c_int = @import("std").mem.zeroes([17]c_int), + firstsymbol: [16]_m3dstbi__uint16 = @import("std").mem.zeroes([16]_m3dstbi__uint16), + size: [288]u8 = @import("std").mem.zeroes([288]u8), + value: [288]_m3dstbi__uint16 = @import("std").mem.zeroes([288]_m3dstbi__uint16), +}; +pub fn _m3dstbi__bitreverse16(arg_n: c_int) callconv(.C) c_int { + var n = arg_n; + _ = &n; + n = ((n & @as(c_int, 43690)) >> @intCast(1)) | ((n & @as(c_int, 21845)) << @intCast(1)); + n = ((n & @as(c_int, 52428)) >> @intCast(2)) | ((n & @as(c_int, 13107)) << @intCast(2)); + n = ((n & @as(c_int, 61680)) >> @intCast(4)) | ((n & @as(c_int, 3855)) << @intCast(4)); + n = ((n & @as(c_int, 65280)) >> @intCast(8)) | ((n & @as(c_int, 255)) << @intCast(8)); + return n; +} +pub fn _m3dstbi__bit_reverse(arg_v: c_int, arg_bits: c_int) callconv(.C) c_int { + var v = arg_v; + _ = &v; + var bits = arg_bits; + _ = &bits; + return _m3dstbi__bitreverse16(v) >> @intCast(@as(c_int, 16) - bits); +} +pub fn _m3dstbi__zbuild_huffman(arg_z: [*c]_m3dstbi__zhuffman, arg_sizelist: [*c]u8, arg_num: c_int) callconv(.C) c_int { + var z = arg_z; + _ = &z; + var sizelist = arg_sizelist; + _ = &sizelist; + var num = arg_num; + _ = # + var i: c_int = undefined; + _ = &i; + var k: c_int = 0; + _ = &k; + var code: c_int = undefined; + _ = &code; + var next_code: [16]c_int = undefined; + _ = &next_code; + var sizes: [17]c_int = undefined; + _ = &sizes; + _ = memset(@as(?*anyopaque, @ptrCast(@as([*c]c_int, @ptrCast(@alignCast(&sizes))))), @as(c_int, 0), @sizeOf([17]c_int)); + _ = memset(@as(?*anyopaque, @ptrCast(@as([*c]_m3dstbi__uint16, @ptrCast(@alignCast(&z.*.fast))))), @as(c_int, 0), @sizeOf([512]_m3dstbi__uint16)); + { + i = 0; + while (i < num) : (i += 1) { + sizes[(blk: { + const tmp = i; + if (tmp >= 0) break :blk sizelist + @as(usize, @intCast(tmp)) else break :blk sizelist - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*] += 1; + } + } + sizes[@as(c_uint, @intCast(@as(c_int, 0)))] = 0; + { + i = 1; + while (i < @as(c_int, 16)) : (i += 1) if (sizes[@as(c_uint, @intCast(i))] > (@as(c_int, 1) << @intCast(i))) return _m3dstbi__errstr("Corrupt PNG"); + } + code = 0; + { + i = 1; + while (i < @as(c_int, 16)) : (i += 1) { + next_code[@as(c_uint, @intCast(i))] = code; + z.*.firstcode[@as(c_uint, @intCast(i))] = @as(_m3dstbi__uint16, @bitCast(@as(c_short, @truncate(code)))); + z.*.firstsymbol[@as(c_uint, @intCast(i))] = @as(_m3dstbi__uint16, @bitCast(@as(c_short, @truncate(k)))); + code = code + sizes[@as(c_uint, @intCast(i))]; + if (sizes[@as(c_uint, @intCast(i))] != 0) if ((code - @as(c_int, 1)) >= (@as(c_int, 1) << @intCast(i))) return _m3dstbi__errstr("Corrupt PNG"); + z.*.maxcode[@as(c_uint, @intCast(i))] = code << @intCast(@as(c_int, 16) - i); + code <<= @intCast(@as(c_int, 1)); + k += sizes[@as(c_uint, @intCast(i))]; + } + } + z.*.maxcode[@as(c_uint, @intCast(@as(c_int, 16)))] = 65536; + { + i = 0; + while (i < num) : (i += 1) { + var s: c_int = @as(c_int, @bitCast(@as(c_uint, (blk: { + const tmp = i; + if (tmp >= 0) break :blk sizelist + @as(usize, @intCast(tmp)) else break :blk sizelist - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*))); + _ = &s; + if (s != 0) { + var c: c_int = (next_code[@as(c_uint, @intCast(s))] - @as(c_int, @bitCast(@as(c_uint, z.*.firstcode[@as(c_uint, @intCast(s))])))) + @as(c_int, @bitCast(@as(c_uint, z.*.firstsymbol[@as(c_uint, @intCast(s))]))); + _ = &c; + var fastv: _m3dstbi__uint16 = @as(_m3dstbi__uint16, @bitCast(@as(c_short, @truncate((s << @intCast(9)) | i)))); + _ = &fastv; + z.*.size[@as(c_uint, @intCast(c))] = @as(u8, @bitCast(@as(i8, @truncate(s)))); + z.*.value[@as(c_uint, @intCast(c))] = @as(_m3dstbi__uint16, @bitCast(@as(c_short, @truncate(i)))); + if (s <= @as(c_int, 9)) { + var j: c_int = _m3dstbi__bit_reverse(next_code[@as(c_uint, @intCast(s))], s); + _ = &j; + while (j < (@as(c_int, 1) << @intCast(9))) { + z.*.fast[@as(c_uint, @intCast(j))] = fastv; + j += @as(c_int, 1) << @intCast(s); + } + } + next_code[@as(c_uint, @intCast(s))] += 1; + } + } + } + return 1; +} +pub const _m3dstbi__zbuf = extern struct { + zbuffer: [*c]u8 = @import("std").mem.zeroes([*c]u8), + zbuffer_end: [*c]u8 = @import("std").mem.zeroes([*c]u8), + num_bits: c_int = @import("std").mem.zeroes(c_int), + code_buffer: _m3dstbi__uint32 = @import("std").mem.zeroes(_m3dstbi__uint32), + zout: [*c]u8 = @import("std").mem.zeroes([*c]u8), + zout_start: [*c]u8 = @import("std").mem.zeroes([*c]u8), + zout_end: [*c]u8 = @import("std").mem.zeroes([*c]u8), + z_expandable: c_int = @import("std").mem.zeroes(c_int), + z_length: _m3dstbi__zhuffman = @import("std").mem.zeroes(_m3dstbi__zhuffman), + z_distance: _m3dstbi__zhuffman = @import("std").mem.zeroes(_m3dstbi__zhuffman), +}; +pub fn _m3dstbi__zget8(arg_z: [*c]_m3dstbi__zbuf) callconv(.C) u8 { + var z = arg_z; + _ = &z; + if (z.*.zbuffer >= z.*.zbuffer_end) return 0; + return (blk: { + const ref = &z.*.zbuffer; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).*; +} +pub fn _m3dstbi__fill_bits(arg_z: [*c]_m3dstbi__zbuf) callconv(.C) void { + var z = arg_z; + _ = &z; + while (true) { + z.*.code_buffer |= @as(_m3dstbi__uint32, @bitCast(@as(c_uint, @bitCast(@as(c_uint, _m3dstbi__zget8(z)))) << @intCast(z.*.num_bits))); + z.*.num_bits += @as(c_int, 8); + if (!(z.*.num_bits <= @as(c_int, 24))) break; + } +} +pub fn _m3dstbi__zreceive(arg_z: [*c]_m3dstbi__zbuf, arg_n: c_int) callconv(.C) c_uint { + var z = arg_z; + _ = &z; + var n = arg_n; + _ = &n; + var k: c_uint = undefined; + _ = &k; + if (z.*.num_bits < n) { + _m3dstbi__fill_bits(z); + } + k = z.*.code_buffer & @as(_m3dstbi__uint32, @bitCast((@as(c_int, 1) << @intCast(n)) - @as(c_int, 1))); + z.*.code_buffer >>= @intCast(n); + z.*.num_bits -= n; + return k; +} +pub fn _m3dstbi__zhuffman_decode_slowpath(arg_a: [*c]_m3dstbi__zbuf, arg_z: [*c]_m3dstbi__zhuffman) callconv(.C) c_int { + var a = arg_a; + _ = &a; + var z = arg_z; + _ = &z; + var b: c_int = undefined; + _ = &b; + var s: c_int = undefined; + _ = &s; + var k: c_int = undefined; + _ = &k; + k = _m3dstbi__bit_reverse(@as(c_int, @bitCast(a.*.code_buffer)), @as(c_int, 16)); + { + s = @as(c_int, 9) + @as(c_int, 1); + while (true) : (s += 1) if (k < z.*.maxcode[@as(c_uint, @intCast(s))]) break; + } + if (s == @as(c_int, 16)) return -@as(c_int, 1); + b = ((k >> @intCast(@as(c_int, 16) - s)) - @as(c_int, @bitCast(@as(c_uint, z.*.firstcode[@as(c_uint, @intCast(s))])))) + @as(c_int, @bitCast(@as(c_uint, z.*.firstsymbol[@as(c_uint, @intCast(s))]))); + a.*.code_buffer >>= @intCast(s); + a.*.num_bits -= s; + return @as(c_int, @bitCast(@as(c_uint, z.*.value[@as(c_uint, @intCast(b))]))); +} +pub fn _m3dstbi__zhuffman_decode(arg_a: [*c]_m3dstbi__zbuf, arg_z: [*c]_m3dstbi__zhuffman) callconv(.C) c_int { + var a = arg_a; + _ = &a; + var z = arg_z; + _ = &z; + var b: c_int = undefined; + _ = &b; + var s: c_int = undefined; + _ = &s; + if (a.*.num_bits < @as(c_int, 16)) { + _m3dstbi__fill_bits(a); + } + b = @as(c_int, @bitCast(@as(c_uint, z.*.fast[a.*.code_buffer & @as(_m3dstbi__uint32, @bitCast((@as(c_int, 1) << @intCast(9)) - @as(c_int, 1)))]))); + if (b != 0) { + s = b >> @intCast(9); + a.*.code_buffer >>= @intCast(s); + a.*.num_bits -= s; + return b & @as(c_int, 511); + } + return _m3dstbi__zhuffman_decode_slowpath(a, z); +} +pub fn _m3dstbi__zexpand(arg_z: [*c]_m3dstbi__zbuf, arg_zout: [*c]u8, arg_n: c_int) callconv(.C) c_int { + var z = arg_z; + _ = &z; + var zout = arg_zout; + _ = &zout; + var n = arg_n; + _ = &n; + var q: [*c]u8 = undefined; + _ = &q; + var cur: c_int = undefined; + _ = &cur; + var limit: c_int = undefined; + _ = &limit; + var old_limit: c_int = undefined; + _ = &old_limit; + z.*.zout = zout; + if (!(z.*.z_expandable != 0)) return _m3dstbi__errstr("Corrupt PNG"); + cur = @as(c_int, @bitCast(@as(c_int, @truncate(@divExact(@as(c_long, @bitCast(@intFromPtr(z.*.zout) -% @intFromPtr(z.*.zout_start))), @sizeOf(u8)))))); + limit = blk: { + const tmp = @as(c_int, @bitCast(@as(c_int, @truncate(@divExact(@as(c_long, @bitCast(@intFromPtr(z.*.zout_end) -% @intFromPtr(z.*.zout_start))), @sizeOf(u8)))))); + old_limit = tmp; + break :blk tmp; + }; + while ((cur + n) > limit) { + limit *= @as(c_int, 2); + } + q = @as([*c]u8, @ptrCast(@alignCast(realloc(@as(?*anyopaque, @ptrCast(z.*.zout_start)), @as(c_ulong, @bitCast(@as(c_long, limit))))))); + _ = @sizeOf(c_int); + if (q == @as([*c]u8, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0))))))) return _m3dstbi__errstr("Out of memory"); + z.*.zout_start = q; + z.*.zout = q + @as(usize, @bitCast(@as(isize, @intCast(cur)))); + z.*.zout_end = q + @as(usize, @bitCast(@as(isize, @intCast(limit)))); + return 1; +} +pub var _m3dstbi__zlength_base: [31]c_int = [31]c_int{ + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 13, + 15, + 17, + 19, + 23, + 27, + 31, + 35, + 43, + 51, + 59, + 67, + 83, + 99, + 115, + 131, + 163, + 195, + 227, + 258, + 0, + 0, +}; +pub var _m3dstbi__zlength_extra: [31]c_int = [31]c_int{ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 2, + 2, + 2, + 2, + 3, + 3, + 3, + 3, + 4, + 4, + 4, + 4, + 5, + 5, + 5, + 5, + 0, + 0, + 0, +}; +pub var _m3dstbi__zdist_base: [32]c_int = [32]c_int{ + 1, + 2, + 3, + 4, + 5, + 7, + 9, + 13, + 17, + 25, + 33, + 49, + 65, + 97, + 129, + 193, + 257, + 385, + 513, + 769, + 1025, + 1537, + 2049, + 3073, + 4097, + 6145, + 8193, + 12289, + 16385, + 24577, + 0, + 0, +}; +pub var _m3dstbi__zdist_extra: [32]c_int = [30]c_int{ + 0, + 0, + 0, + 0, + 1, + 1, + 2, + 2, + 3, + 3, + 4, + 4, + 5, + 5, + 6, + 6, + 7, + 7, + 8, + 8, + 9, + 9, + 10, + 10, + 11, + 11, + 12, + 12, + 13, + 13, +} ++ [1]c_int{0} ** 2; +pub fn _m3dstbi__parse_huffman_block(arg_a: [*c]_m3dstbi__zbuf) callconv(.C) c_int { + var a = arg_a; + _ = &a; + var zout: [*c]u8 = a.*.zout; + _ = &zout; + while (true) { + var z: c_int = _m3dstbi__zhuffman_decode(a, &a.*.z_length); + _ = &z; + if (z < @as(c_int, 256)) { + if (z < @as(c_int, 0)) return _m3dstbi__errstr("Corrupt PNG"); + if (zout >= a.*.zout_end) { + if (!(_m3dstbi__zexpand(a, zout, @as(c_int, 1)) != 0)) return 0; + zout = a.*.zout; + } + (blk: { + const ref = &zout; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = @as(u8, @bitCast(@as(i8, @truncate(z)))); + } else { + var p: [*c]u8 = undefined; + _ = &p; + var len: c_int = undefined; + _ = &len; + var dist: c_int = undefined; + _ = &dist; + if (z == @as(c_int, 256)) { + a.*.zout = zout; + return 1; + } + z -= @as(c_int, 257); + len = _m3dstbi__zlength_base[@as(c_uint, @intCast(z))]; + if (_m3dstbi__zlength_extra[@as(c_uint, @intCast(z))] != 0) { + len += @as(c_int, @bitCast(_m3dstbi__zreceive(a, _m3dstbi__zlength_extra[@as(c_uint, @intCast(z))]))); + } + z = _m3dstbi__zhuffman_decode(a, &a.*.z_distance); + if (z < @as(c_int, 0)) return _m3dstbi__errstr("Corrupt PNG"); + dist = _m3dstbi__zdist_base[@as(c_uint, @intCast(z))]; + if (_m3dstbi__zdist_extra[@as(c_uint, @intCast(z))] != 0) { + dist += @as(c_int, @bitCast(_m3dstbi__zreceive(a, _m3dstbi__zdist_extra[@as(c_uint, @intCast(z))]))); + } + if (@divExact(@as(c_long, @bitCast(@intFromPtr(zout) -% @intFromPtr(a.*.zout_start))), @sizeOf(u8)) < @as(c_long, @bitCast(@as(c_long, dist)))) return _m3dstbi__errstr("Corrupt PNG"); + if ((zout + @as(usize, @bitCast(@as(isize, @intCast(len))))) > a.*.zout_end) { + if (!(_m3dstbi__zexpand(a, zout, len) != 0)) return 0; + zout = a.*.zout; + } + p = @as([*c]u8, @ptrCast(@alignCast(zout - @as(usize, @bitCast(@as(isize, @intCast(dist))))))); + if (dist == @as(c_int, 1)) { + var v: u8 = p.*; + _ = &v; + if (len != 0) { + while (true) { + (blk: { + const ref = &zout; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = @as(u8, @bitCast(v)); + if (!((blk: { + const ref = &len; + ref.* -= 1; + break :blk ref.*; + }) != 0)) break; + } + } + } else { + if (len != 0) { + while (true) { + (blk: { + const ref = &zout; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = @as(u8, @bitCast((blk: { + const ref = &p; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).*)); + if (!((blk: { + const ref = &len; + ref.* -= 1; + break :blk ref.*; + }) != 0)) break; + } + } + } + } + } + return 0; +} +pub fn _m3dstbi__compute_huffman_codes(arg_a: [*c]_m3dstbi__zbuf) callconv(.C) c_int { + var a = arg_a; + _ = &a; + const length_dezigzag = struct { + var static: [19]u8 = [19]u8{ + 16, + 17, + 18, + 0, + 8, + 7, + 9, + 6, + 10, + 5, + 11, + 4, + 12, + 3, + 13, + 2, + 14, + 1, + 15, + }; + }; + _ = &length_dezigzag; + var z_codelength: _m3dstbi__zhuffman = undefined; + _ = &z_codelength; + var lencodes: [455]u8 = undefined; + _ = &lencodes; + var codelength_sizes: [19]u8 = undefined; + _ = &codelength_sizes; + var i: c_int = undefined; + _ = &i; + var n: c_int = undefined; + _ = &n; + var hlit: c_int = @as(c_int, @bitCast(_m3dstbi__zreceive(a, @as(c_int, 5)) +% @as(c_uint, @bitCast(@as(c_int, 257))))); + _ = &hlit; + var hdist: c_int = @as(c_int, @bitCast(_m3dstbi__zreceive(a, @as(c_int, 5)) +% @as(c_uint, @bitCast(@as(c_int, 1))))); + _ = &hdist; + var hclen: c_int = @as(c_int, @bitCast(_m3dstbi__zreceive(a, @as(c_int, 4)) +% @as(c_uint, @bitCast(@as(c_int, 4))))); + _ = &hclen; + var ntot: c_int = hlit + hdist; + _ = &ntot; + _ = memset(@as(?*anyopaque, @ptrCast(@as([*c]u8, @ptrCast(@alignCast(&codelength_sizes))))), @as(c_int, 0), @sizeOf([19]u8)); + { + i = 0; + while (i < hclen) : (i += 1) { + var s: c_int = @as(c_int, @bitCast(_m3dstbi__zreceive(a, @as(c_int, 3)))); + _ = &s; + codelength_sizes[length_dezigzag.static[@as(c_uint, @intCast(i))]] = @as(u8, @bitCast(@as(i8, @truncate(s)))); + } + } + if (!(_m3dstbi__zbuild_huffman(&z_codelength, @as([*c]u8, @ptrCast(@alignCast(&codelength_sizes))), @as(c_int, 19)) != 0)) return 0; + n = 0; + while (n < ntot) { + var c: c_int = _m3dstbi__zhuffman_decode(a, &z_codelength); + _ = &c; + if ((c < @as(c_int, 0)) or (c >= @as(c_int, 19))) return _m3dstbi__errstr("Corrupt PNG"); + if (c < @as(c_int, 16)) { + lencodes[@as(c_uint, @intCast(blk: { + const ref = &n; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }))] = @as(u8, @bitCast(@as(i8, @truncate(c)))); + } else { + var fill: u8 = 0; + _ = &fill; + if (c == @as(c_int, 16)) { + c = @as(c_int, @bitCast(_m3dstbi__zreceive(a, @as(c_int, 2)) +% @as(c_uint, @bitCast(@as(c_int, 3))))); + if (n == @as(c_int, 0)) return _m3dstbi__errstr("Corrupt PNG"); + fill = lencodes[@as(c_uint, @intCast(n - @as(c_int, 1)))]; + } else if (c == @as(c_int, 17)) { + c = @as(c_int, @bitCast(_m3dstbi__zreceive(a, @as(c_int, 3)) +% @as(c_uint, @bitCast(@as(c_int, 3))))); + } else { + c = @as(c_int, @bitCast(_m3dstbi__zreceive(a, @as(c_int, 7)) +% @as(c_uint, @bitCast(@as(c_int, 11))))); + } + if ((ntot - n) < c) return _m3dstbi__errstr("Corrupt PNG"); + _ = memset(@as(?*anyopaque, @ptrCast(@as([*c]u8, @ptrCast(@alignCast(&lencodes))) + @as(usize, @bitCast(@as(isize, @intCast(n)))))), @as(c_int, @bitCast(@as(c_uint, fill))), @as(c_ulong, @bitCast(@as(c_long, c)))); + n += c; + } + } + if (n != ntot) return _m3dstbi__errstr("Corrupt PNG"); + if (!(_m3dstbi__zbuild_huffman(&a.*.z_length, @as([*c]u8, @ptrCast(@alignCast(&lencodes))), hlit) != 0)) return 0; + if (!(_m3dstbi__zbuild_huffman(&a.*.z_distance, @as([*c]u8, @ptrCast(@alignCast(&lencodes))) + @as(usize, @bitCast(@as(isize, @intCast(hlit)))), hdist) != 0)) return 0; + return 1; +} +pub fn _m3dstbi__parse_uncompressed_block(arg_a: [*c]_m3dstbi__zbuf) callconv(.C) c_int { + var a = arg_a; + _ = &a; + var header: [4]u8 = undefined; + _ = &header; + var len: c_int = undefined; + _ = &len; + var nlen: c_int = undefined; + _ = &nlen; + var k: c_int = undefined; + _ = &k; + if ((a.*.num_bits & @as(c_int, 7)) != 0) { + _ = _m3dstbi__zreceive(a, a.*.num_bits & @as(c_int, 7)); + } + k = 0; + while (a.*.num_bits > @as(c_int, 0)) { + header[@as(c_uint, @intCast(blk: { + const ref = &k; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }))] = @as(u8, @bitCast(@as(u8, @truncate(a.*.code_buffer & @as(_m3dstbi__uint32, @bitCast(@as(c_int, 255))))))); + a.*.code_buffer >>= @intCast(@as(c_int, 8)); + a.*.num_bits -= @as(c_int, 8); + } + while (k < @as(c_int, 4)) { + header[@as(c_uint, @intCast(blk: { + const ref = &k; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }))] = _m3dstbi__zget8(a); + } + len = (@as(c_int, @bitCast(@as(c_uint, header[@as(c_uint, @intCast(@as(c_int, 1)))]))) * @as(c_int, 256)) + @as(c_int, @bitCast(@as(c_uint, header[@as(c_uint, @intCast(@as(c_int, 0)))]))); + nlen = (@as(c_int, @bitCast(@as(c_uint, header[@as(c_uint, @intCast(@as(c_int, 3)))]))) * @as(c_int, 256)) + @as(c_int, @bitCast(@as(c_uint, header[@as(c_uint, @intCast(@as(c_int, 2)))]))); + if (nlen != (len ^ @as(c_int, 65535))) return _m3dstbi__errstr("Corrupt PNG"); + if ((a.*.zbuffer + @as(usize, @bitCast(@as(isize, @intCast(len))))) > a.*.zbuffer_end) return _m3dstbi__errstr("Corrupt PNG"); + if ((a.*.zout + @as(usize, @bitCast(@as(isize, @intCast(len))))) > a.*.zout_end) if (!(_m3dstbi__zexpand(a, a.*.zout, len) != 0)) return 0; + _ = memcpy(@as(?*anyopaque, @ptrCast(a.*.zout)), @as(?*const anyopaque, @ptrCast(a.*.zbuffer)), @as(c_ulong, @bitCast(@as(c_long, len)))); + a.*.zbuffer += @as(usize, @bitCast(@as(isize, @intCast(len)))); + a.*.zout += @as(usize, @bitCast(@as(isize, @intCast(len)))); + return 1; +} +pub fn _m3dstbi__parse_zlib_header(arg_a: [*c]_m3dstbi__zbuf) callconv(.C) c_int { + var a = arg_a; + _ = &a; + var cmf: c_int = @as(c_int, @bitCast(@as(c_uint, _m3dstbi__zget8(a)))); + _ = &cmf; + var cm: c_int = cmf & @as(c_int, 15); + _ = &cm; + var flg: c_int = @as(c_int, @bitCast(@as(c_uint, _m3dstbi__zget8(a)))); + _ = &flg; + if (@import("std").zig.c_translation.signedRemainder((cmf * @as(c_int, 256)) + flg, @as(c_int, 31)) != @as(c_int, 0)) return _m3dstbi__errstr("Corrupt PNG"); + if ((flg & @as(c_int, 32)) != 0) return _m3dstbi__errstr("Corrupt PNG"); + if (cm != @as(c_int, 8)) return _m3dstbi__errstr("Corrupt PNG"); + return 1; +} +pub var _m3dstbi__zdefault_length: [288]u8 = @import("std").mem.zeroes([288]u8); +pub var _m3dstbi__zdefault_distance: [32]u8 = @import("std").mem.zeroes([32]u8); +pub fn _m3dstbi__init_zdefaults() callconv(.C) void { + var i: c_int = undefined; + _ = &i; + { + i = 0; + while (i <= @as(c_int, 143)) : (i += 1) { + _m3dstbi__zdefault_length[@as(c_uint, @intCast(i))] = 8; + } + } + while (i <= @as(c_int, 255)) : (i += 1) { + _m3dstbi__zdefault_length[@as(c_uint, @intCast(i))] = 9; + } + while (i <= @as(c_int, 279)) : (i += 1) { + _m3dstbi__zdefault_length[@as(c_uint, @intCast(i))] = 7; + } + while (i <= @as(c_int, 287)) : (i += 1) { + _m3dstbi__zdefault_length[@as(c_uint, @intCast(i))] = 8; + } + { + i = 0; + while (i <= @as(c_int, 31)) : (i += 1) { + _m3dstbi__zdefault_distance[@as(c_uint, @intCast(i))] = 5; + } + } +} +pub fn _m3dstbi__parse_zlib(arg_a: [*c]_m3dstbi__zbuf, arg_parse_header: c_int) callconv(.C) c_int { + var a = arg_a; + _ = &a; + var parse_header = arg_parse_header; + _ = &parse_header; + var final: c_int = undefined; + _ = &final; + var @"type": c_int = undefined; + _ = &@"type"; + if (parse_header != 0) if (!(_m3dstbi__parse_zlib_header(a) != 0)) return 0; + a.*.num_bits = 0; + a.*.code_buffer = 0; + while (true) { + final = @as(c_int, @bitCast(_m3dstbi__zreceive(a, @as(c_int, 1)))); + @"type" = @as(c_int, @bitCast(_m3dstbi__zreceive(a, @as(c_int, 2)))); + if (@"type" == @as(c_int, 0)) { + if (!(_m3dstbi__parse_uncompressed_block(a) != 0)) return 0; + } else if (@"type" == @as(c_int, 3)) { + return 0; + } else { + if (@"type" == @as(c_int, 1)) { + if (!(_m3dstbi__zbuild_huffman(&a.*.z_length, @as([*c]u8, @ptrCast(@alignCast(&_m3dstbi__zdefault_length))), @as(c_int, 288)) != 0)) return 0; + if (!(_m3dstbi__zbuild_huffman(&a.*.z_distance, @as([*c]u8, @ptrCast(@alignCast(&_m3dstbi__zdefault_distance))), @as(c_int, 32)) != 0)) return 0; + } else { + if (!(_m3dstbi__compute_huffman_codes(a) != 0)) return 0; + } + if (!(_m3dstbi__parse_huffman_block(a) != 0)) return 0; + } + if (!!(final != 0)) break; + } + return 1; +} +pub fn _m3dstbi__do_zlib(arg_a: [*c]_m3dstbi__zbuf, arg_obuf: [*c]u8, arg_olen: c_int, arg_exp_1: c_int, arg_parse_header: c_int) callconv(.C) c_int { + var a = arg_a; + _ = &a; + var obuf = arg_obuf; + _ = &obuf; + var olen = arg_olen; + _ = &olen; + var exp_1 = arg_exp_1; + _ = &exp_1; + var parse_header = arg_parse_header; + _ = &parse_header; + a.*.zout_start = obuf; + a.*.zout = obuf; + a.*.zout_end = obuf + @as(usize, @bitCast(@as(isize, @intCast(olen)))); + a.*.z_expandable = exp_1; + _m3dstbi__init_zdefaults(); + return _m3dstbi__parse_zlib(a, parse_header); +} +pub export fn _m3dstbi_zlib_decode_malloc_guesssize_headerflag(arg_buffer: [*c]const u8, arg_len: c_int, arg_initial_size: c_int, arg_outlen: [*c]c_int, arg_parse_header: c_int) [*c]u8 { + var buffer = arg_buffer; + _ = &buffer; + var len = arg_len; + _ = &len; + var initial_size = arg_initial_size; + _ = &initial_size; + var outlen = arg_outlen; + _ = &outlen; + var parse_header = arg_parse_header; + _ = &parse_header; + var a: _m3dstbi__zbuf = undefined; + _ = &a; + var p: [*c]u8 = @as([*c]u8, @ptrCast(@alignCast(_m3dstbi__malloc(@as(usize, @bitCast(@as(c_long, initial_size))))))); + _ = &p; + if (p == @as([*c]u8, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0))))))) return null; + a.zbuffer = @as([*c]u8, @ptrCast(@volatileCast(@constCast(buffer)))); + a.zbuffer_end = @as([*c]u8, @ptrCast(@volatileCast(@constCast(buffer)))) + @as(usize, @bitCast(@as(isize, @intCast(len)))); + if (_m3dstbi__do_zlib(&a, p, initial_size, @as(c_int, 1), parse_header) != 0) { + if (outlen != null) { + outlen.* = @as(c_int, @bitCast(@as(c_int, @truncate(@divExact(@as(c_long, @bitCast(@intFromPtr(a.zout) -% @intFromPtr(a.zout_start))), @sizeOf(u8)))))); + } + return a.zout_start; + } else { + free(@as(?*anyopaque, @ptrCast(a.zout_start))); + return null; + } + return null; +} +pub const _m3dstbi__pngchunk = extern struct { + length: _m3dstbi__uint32 = @import("std").mem.zeroes(_m3dstbi__uint32), + type: _m3dstbi__uint32 = @import("std").mem.zeroes(_m3dstbi__uint32), +}; +pub fn _m3dstbi__get_chunk_header(arg_s: [*c]_m3dstbi__context) callconv(.C) _m3dstbi__pngchunk { + var s = arg_s; + _ = &s; + var c: _m3dstbi__pngchunk = undefined; + _ = &c; + c.length = _m3dstbi__get32be(s); + c.type = _m3dstbi__get32be(s); + return c; +} +pub fn _m3dstbi__check_png_header(arg_s: [*c]_m3dstbi__context) callconv(.C) c_int { + var s = arg_s; + _ = &s; + const png_sig = struct { + var static: [8]u8 = [8]u8{ + 137, + 80, + 78, + 71, + 13, + 10, + 26, + 10, + }; + }; + _ = &png_sig; + var i: c_int = undefined; + _ = &i; + { + i = 0; + while (i < @as(c_int, 8)) : (i += 1) if (@as(c_int, @bitCast(@as(c_uint, _m3dstbi__get8(s)))) != @as(c_int, @bitCast(@as(c_uint, png_sig.static[@as(c_uint, @intCast(i))])))) return _m3dstbi__errstr("Not a PNG"); + } + return 1; +} +pub const _m3dstbi__png = extern struct { + s: [*c]_m3dstbi__context = @import("std").mem.zeroes([*c]_m3dstbi__context), + idata: [*c]u8 = @import("std").mem.zeroes([*c]u8), + expanded: [*c]u8 = @import("std").mem.zeroes([*c]u8), + out: [*c]u8 = @import("std").mem.zeroes([*c]u8), + depth: c_int = @import("std").mem.zeroes(c_int), +}; +pub const STBI__F_none: c_int = 0; +pub const STBI__F_sub: c_int = 1; +pub const STBI__F_up: c_int = 2; +pub const STBI__F_avg: c_int = 3; +pub const STBI__F_paeth: c_int = 4; +pub const STBI__F_avg_first: c_int = 5; +pub const STBI__F_paeth_first: c_int = 6; +const enum_unnamed_15 = c_uint; +pub var first_row_filter: [5]u8 = [5]u8{ + @as(u8, @bitCast(@as(i8, @truncate(STBI__F_none)))), + @as(u8, @bitCast(@as(i8, @truncate(STBI__F_sub)))), + @as(u8, @bitCast(@as(i8, @truncate(STBI__F_none)))), + @as(u8, @bitCast(@as(i8, @truncate(STBI__F_avg_first)))), + @as(u8, @bitCast(@as(i8, @truncate(STBI__F_paeth_first)))), +}; +pub fn _m3dstbi__paeth(arg_a: c_int, arg_b: c_int, arg_c: c_int) callconv(.C) c_int { + var a = arg_a; + _ = &a; + var b = arg_b; + _ = &b; + var c = arg_c; + _ = &c; + var p: c_int = (a + b) - c; + _ = &p; + var pa: c_int = abs(p - a); + _ = &pa; + var pb: c_int = abs(p - b); + _ = &pb; + var pc: c_int = abs(p - c); + _ = &pc; + if ((pa <= pb) and (pa <= pc)) return a; + if (pb <= pc) return b; + return c; +} +pub var _m3dstbi__depth_scale_table: [9]u8 = [9]u8{ + 0, + 255, + 85, + 0, + 17, + 0, + 0, + 0, + 1, +}; +pub fn _m3dstbi__create_png_image_raw(arg_a: [*c]_m3dstbi__png, arg_raw: [*c]u8, arg_raw_len: _m3dstbi__uint32, arg_out_n: c_int, arg_x: _m3dstbi__uint32, arg_y: _m3dstbi__uint32, arg_depth: c_int, arg_color: c_int) callconv(.C) c_int { + var a = arg_a; + _ = &a; + var raw = arg_raw; + _ = &raw; + var raw_len = arg_raw_len; + _ = &raw_len; + var out_n = arg_out_n; + _ = &out_n; + var x = arg_x; + _ = &x; + var y = arg_y; + _ = &y; + var depth = arg_depth; + _ = &depth; + var color = arg_color; + _ = &color; + var bytes: c_int = if (depth == @as(c_int, 16)) @as(c_int, 2) else @as(c_int, 1); + _ = &bytes; + var s: [*c]_m3dstbi__context = a.*.s; + _ = &s; + var i: _m3dstbi__uint32 = undefined; + _ = &i; + var j: _m3dstbi__uint32 = undefined; + _ = &j; + var stride: _m3dstbi__uint32 = (x *% @as(_m3dstbi__uint32, @bitCast(out_n))) *% @as(_m3dstbi__uint32, @bitCast(bytes)); + _ = &stride; + var img_len: _m3dstbi__uint32 = undefined; + _ = &img_len; + var img_width_bytes: _m3dstbi__uint32 = undefined; + _ = &img_width_bytes; + var k: c_int = undefined; + _ = &k; + var img_n: c_int = s.*.img_n; + _ = &img_n; + var output_bytes: c_int = out_n * bytes; + _ = &output_bytes; + var filter_bytes: c_int = img_n * bytes; + _ = &filter_bytes; + var width: c_int = @as(c_int, @bitCast(x)); + _ = &width; + a.*.out = @as([*c]u8, @ptrCast(@alignCast(_m3dstbi__malloc_mad3(@as(c_int, @bitCast(x)), @as(c_int, @bitCast(y)), output_bytes, @as(c_int, 0))))); + if (!(a.*.out != null)) return _m3dstbi__errstr("Out of memory"); + if (!(_m3dstbi__mad3sizes_valid(img_n, @as(c_int, @bitCast(x)), depth, @as(c_int, 7)) != 0)) return _m3dstbi__errstr("Corrupt PNG"); + img_width_bytes = (((@as(_m3dstbi__uint32, @bitCast(img_n)) *% x) *% @as(_m3dstbi__uint32, @bitCast(depth))) +% @as(_m3dstbi__uint32, @bitCast(@as(c_int, 7)))) >> @intCast(3); + img_len = (img_width_bytes +% @as(_m3dstbi__uint32, @bitCast(@as(c_int, 1)))) *% y; + if ((s.*.img_x == x) and (s.*.img_y == y)) { + if (raw_len != img_len) return _m3dstbi__errstr("Corrupt PNG"); + } else { + if (raw_len < img_len) return _m3dstbi__errstr("Corrupt PNG"); + } + { + j = 0; + while (j < y) : (j +%= 1) { + var cur: [*c]u8 = a.*.out + (stride *% j); + _ = &cur; + var prior: [*c]u8 = cur - stride; + _ = &prior; + var filter: c_int = @as(c_int, @bitCast(@as(c_uint, (blk: { + const ref = &raw; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).*))); + _ = &filter; + if (filter > @as(c_int, 4)) return _m3dstbi__errstr("Corrupt PNG"); + if (depth < @as(c_int, 8)) { + cur += @as([*c]u8, @ptrFromInt((x *% @as(_m3dstbi__uint32, @bitCast(out_n))) -% img_width_bytes)); + filter_bytes = 1; + width = @as(c_int, @bitCast(img_width_bytes)); + } + prior = cur - stride; + if (j == @as(_m3dstbi__uint32, @bitCast(@as(c_int, 0)))) { + filter = @as(c_int, @bitCast(@as(c_uint, first_row_filter[@as(c_uint, @intCast(filter))]))); + } + { + k = 0; + while (k < filter_bytes) : (k += 1) { + while (true) { + switch (filter) { + @as(c_int, 0) => { + (blk: { + const tmp = k; + if (tmp >= 0) break :blk cur + @as(usize, @intCast(tmp)) else break :blk cur - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = (blk: { + const tmp = k; + if (tmp >= 0) break :blk raw + @as(usize, @intCast(tmp)) else break :blk raw - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*; + break; + }, + @as(c_int, 1) => { + (blk: { + const tmp = k; + if (tmp >= 0) break :blk cur + @as(usize, @intCast(tmp)) else break :blk cur - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = (blk: { + const tmp = k; + if (tmp >= 0) break :blk raw + @as(usize, @intCast(tmp)) else break :blk raw - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*; + break; + }, + @as(c_int, 2) => { + (blk: { + const tmp = k; + if (tmp >= 0) break :blk cur + @as(usize, @intCast(tmp)) else break :blk cur - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = @as(u8, @bitCast(@as(i8, @truncate((@as(c_int, @bitCast(@as(c_uint, (blk: { + const tmp = k; + if (tmp >= 0) break :blk raw + @as(usize, @intCast(tmp)) else break :blk raw - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*))) + @as(c_int, @bitCast(@as(c_uint, (blk: { + const tmp = k; + if (tmp >= 0) break :blk prior + @as(usize, @intCast(tmp)) else break :blk prior - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*)))) & @as(c_int, 255))))); + break; + }, + @as(c_int, 3) => { + (blk: { + const tmp = k; + if (tmp >= 0) break :blk cur + @as(usize, @intCast(tmp)) else break :blk cur - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = @as(u8, @bitCast(@as(i8, @truncate((@as(c_int, @bitCast(@as(c_uint, (blk: { + const tmp = k; + if (tmp >= 0) break :blk raw + @as(usize, @intCast(tmp)) else break :blk raw - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*))) + (@as(c_int, @bitCast(@as(c_uint, (blk: { + const tmp = k; + if (tmp >= 0) break :blk prior + @as(usize, @intCast(tmp)) else break :blk prior - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*))) >> @intCast(1))) & @as(c_int, 255))))); + break; + }, + @as(c_int, 4) => { + (blk: { + const tmp = k; + if (tmp >= 0) break :blk cur + @as(usize, @intCast(tmp)) else break :blk cur - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = @as(u8, @bitCast(@as(i8, @truncate((@as(c_int, @bitCast(@as(c_uint, (blk: { + const tmp = k; + if (tmp >= 0) break :blk raw + @as(usize, @intCast(tmp)) else break :blk raw - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*))) + _m3dstbi__paeth(@as(c_int, 0), @as(c_int, @bitCast(@as(c_uint, (blk: { + const tmp = k; + if (tmp >= 0) break :blk prior + @as(usize, @intCast(tmp)) else break :blk prior - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*))), @as(c_int, 0))) & @as(c_int, 255))))); + break; + }, + @as(c_int, 5) => { + (blk: { + const tmp = k; + if (tmp >= 0) break :blk cur + @as(usize, @intCast(tmp)) else break :blk cur - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = (blk: { + const tmp = k; + if (tmp >= 0) break :blk raw + @as(usize, @intCast(tmp)) else break :blk raw - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*; + break; + }, + @as(c_int, 6) => { + (blk: { + const tmp = k; + if (tmp >= 0) break :blk cur + @as(usize, @intCast(tmp)) else break :blk cur - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = (blk: { + const tmp = k; + if (tmp >= 0) break :blk raw + @as(usize, @intCast(tmp)) else break :blk raw - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*; + break; + }, + else => {}, + } + break; + } + } + } + if (depth == @as(c_int, 8)) { + if (img_n != out_n) { + (blk: { + const tmp = img_n; + if (tmp >= 0) break :blk cur + @as(usize, @intCast(tmp)) else break :blk cur - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = 255; + } + raw += @as(usize, @bitCast(@as(isize, @intCast(img_n)))); + cur += @as(usize, @bitCast(@as(isize, @intCast(out_n)))); + prior += @as(usize, @bitCast(@as(isize, @intCast(out_n)))); + } else if (depth == @as(c_int, 16)) { + if (img_n != out_n) { + (blk: { + const tmp = filter_bytes; + if (tmp >= 0) break :blk cur + @as(usize, @intCast(tmp)) else break :blk cur - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = 255; + (blk: { + const tmp = filter_bytes + @as(c_int, 1); + if (tmp >= 0) break :blk cur + @as(usize, @intCast(tmp)) else break :blk cur - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = 255; + } + raw += @as(usize, @bitCast(@as(isize, @intCast(filter_bytes)))); + cur += @as(usize, @bitCast(@as(isize, @intCast(output_bytes)))); + prior += @as(usize, @bitCast(@as(isize, @intCast(output_bytes)))); + } else { + raw += @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 1))))); + cur += @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 1))))); + prior += @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 1))))); + } + if ((depth < @as(c_int, 8)) or (img_n == out_n)) { + var nk: c_int = (width - @as(c_int, 1)) * filter_bytes; + _ = &nk; + while (true) { + switch (filter) { + @as(c_int, 0) => { + _ = memcpy(@as(?*anyopaque, @ptrCast(cur)), @as(?*const anyopaque, @ptrCast(raw)), @as(c_ulong, @bitCast(@as(c_long, nk)))); + break; + }, + @as(c_int, 1) => { + { + k = 0; + while (k < nk) : (k += 1) { + (blk: { + const tmp = k; + if (tmp >= 0) break :blk cur + @as(usize, @intCast(tmp)) else break :blk cur - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = @as(u8, @bitCast(@as(i8, @truncate((@as(c_int, @bitCast(@as(c_uint, (blk: { + const tmp = k; + if (tmp >= 0) break :blk raw + @as(usize, @intCast(tmp)) else break :blk raw - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*))) + @as(c_int, @bitCast(@as(c_uint, (blk: { + const tmp = k - filter_bytes; + if (tmp >= 0) break :blk cur + @as(usize, @intCast(tmp)) else break :blk cur - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*)))) & @as(c_int, 255))))); + } + } + break; + }, + @as(c_int, 2) => { + { + k = 0; + while (k < nk) : (k += 1) { + (blk: { + const tmp = k; + if (tmp >= 0) break :blk cur + @as(usize, @intCast(tmp)) else break :blk cur - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = @as(u8, @bitCast(@as(i8, @truncate((@as(c_int, @bitCast(@as(c_uint, (blk: { + const tmp = k; + if (tmp >= 0) break :blk raw + @as(usize, @intCast(tmp)) else break :blk raw - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*))) + @as(c_int, @bitCast(@as(c_uint, (blk: { + const tmp = k; + if (tmp >= 0) break :blk prior + @as(usize, @intCast(tmp)) else break :blk prior - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*)))) & @as(c_int, 255))))); + } + } + break; + }, + @as(c_int, 3) => { + { + k = 0; + while (k < nk) : (k += 1) { + (blk: { + const tmp = k; + if (tmp >= 0) break :blk cur + @as(usize, @intCast(tmp)) else break :blk cur - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = @as(u8, @bitCast(@as(i8, @truncate((@as(c_int, @bitCast(@as(c_uint, (blk: { + const tmp = k; + if (tmp >= 0) break :blk raw + @as(usize, @intCast(tmp)) else break :blk raw - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*))) + ((@as(c_int, @bitCast(@as(c_uint, (blk: { + const tmp = k; + if (tmp >= 0) break :blk prior + @as(usize, @intCast(tmp)) else break :blk prior - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*))) + @as(c_int, @bitCast(@as(c_uint, (blk: { + const tmp = k - filter_bytes; + if (tmp >= 0) break :blk cur + @as(usize, @intCast(tmp)) else break :blk cur - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*)))) >> @intCast(1))) & @as(c_int, 255))))); + } + } + break; + }, + @as(c_int, 4) => { + { + k = 0; + while (k < nk) : (k += 1) { + (blk: { + const tmp = k; + if (tmp >= 0) break :blk cur + @as(usize, @intCast(tmp)) else break :blk cur - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = @as(u8, @bitCast(@as(i8, @truncate((@as(c_int, @bitCast(@as(c_uint, (blk: { + const tmp = k; + if (tmp >= 0) break :blk raw + @as(usize, @intCast(tmp)) else break :blk raw - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*))) + _m3dstbi__paeth(@as(c_int, @bitCast(@as(c_uint, (blk: { + const tmp = k - filter_bytes; + if (tmp >= 0) break :blk cur + @as(usize, @intCast(tmp)) else break :blk cur - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*))), @as(c_int, @bitCast(@as(c_uint, (blk: { + const tmp = k; + if (tmp >= 0) break :blk prior + @as(usize, @intCast(tmp)) else break :blk prior - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*))), @as(c_int, @bitCast(@as(c_uint, (blk: { + const tmp = k - filter_bytes; + if (tmp >= 0) break :blk prior + @as(usize, @intCast(tmp)) else break :blk prior - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*))))) & @as(c_int, 255))))); + } + } + break; + }, + @as(c_int, 5) => { + { + k = 0; + while (k < nk) : (k += 1) { + (blk: { + const tmp = k; + if (tmp >= 0) break :blk cur + @as(usize, @intCast(tmp)) else break :blk cur - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = @as(u8, @bitCast(@as(i8, @truncate((@as(c_int, @bitCast(@as(c_uint, (blk: { + const tmp = k; + if (tmp >= 0) break :blk raw + @as(usize, @intCast(tmp)) else break :blk raw - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*))) + (@as(c_int, @bitCast(@as(c_uint, (blk: { + const tmp = k - filter_bytes; + if (tmp >= 0) break :blk cur + @as(usize, @intCast(tmp)) else break :blk cur - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*))) >> @intCast(1))) & @as(c_int, 255))))); + } + } + break; + }, + @as(c_int, 6) => { + { + k = 0; + while (k < nk) : (k += 1) { + (blk: { + const tmp = k; + if (tmp >= 0) break :blk cur + @as(usize, @intCast(tmp)) else break :blk cur - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = @as(u8, @bitCast(@as(i8, @truncate((@as(c_int, @bitCast(@as(c_uint, (blk: { + const tmp = k; + if (tmp >= 0) break :blk raw + @as(usize, @intCast(tmp)) else break :blk raw - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*))) + _m3dstbi__paeth(@as(c_int, @bitCast(@as(c_uint, (blk: { + const tmp = k - filter_bytes; + if (tmp >= 0) break :blk cur + @as(usize, @intCast(tmp)) else break :blk cur - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*))), @as(c_int, 0), @as(c_int, 0))) & @as(c_int, 255))))); + } + } + break; + }, + else => {}, + } + break; + } + raw += @as(usize, @bitCast(@as(isize, @intCast(nk)))); + } else { + while (true) { + switch (filter) { + @as(c_int, 0) => { + { + i = x -% @as(_m3dstbi__uint32, @bitCast(@as(c_int, 1))); + while (i >= @as(_m3dstbi__uint32, @bitCast(@as(c_int, 1)))) : (_ = blk: { + _ = blk_1: { + _ = blk_2: { + _ = blk_3: { + i -%= 1; + break :blk_3 blk_4: { + const tmp = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 255))))); + (blk_5: { + const tmp_6 = filter_bytes; + if (tmp_6 >= 0) break :blk_5 cur + @as(usize, @intCast(tmp_6)) else break :blk_5 cur - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_6)) +% -1)); + }).* = tmp; + break :blk_4 tmp; + }; + }; + break :blk_2 blk_3: { + const ref = &raw; + ref.* += @as(usize, @bitCast(@as(isize, @intCast(filter_bytes)))); + break :blk_3 ref.*; + }; + }; + break :blk_1 blk_2: { + const ref = &cur; + ref.* += @as(usize, @bitCast(@as(isize, @intCast(output_bytes)))); + break :blk_2 ref.*; + }; + }; + break :blk blk_1: { + const ref = &prior; + ref.* += @as(usize, @bitCast(@as(isize, @intCast(output_bytes)))); + break :blk_1 ref.*; + }; + }) { + k = 0; + while (k < filter_bytes) : (k += 1) { + (blk: { + const tmp = k; + if (tmp >= 0) break :blk cur + @as(usize, @intCast(tmp)) else break :blk cur - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = (blk: { + const tmp = k; + if (tmp >= 0) break :blk raw + @as(usize, @intCast(tmp)) else break :blk raw - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*; + } + } + } + break; + }, + @as(c_int, 1) => { + { + i = x -% @as(_m3dstbi__uint32, @bitCast(@as(c_int, 1))); + while (i >= @as(_m3dstbi__uint32, @bitCast(@as(c_int, 1)))) : (_ = blk: { + _ = blk_1: { + _ = blk_2: { + _ = blk_3: { + i -%= 1; + break :blk_3 blk_4: { + const tmp = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 255))))); + (blk_5: { + const tmp_6 = filter_bytes; + if (tmp_6 >= 0) break :blk_5 cur + @as(usize, @intCast(tmp_6)) else break :blk_5 cur - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_6)) +% -1)); + }).* = tmp; + break :blk_4 tmp; + }; + }; + break :blk_2 blk_3: { + const ref = &raw; + ref.* += @as(usize, @bitCast(@as(isize, @intCast(filter_bytes)))); + break :blk_3 ref.*; + }; + }; + break :blk_1 blk_2: { + const ref = &cur; + ref.* += @as(usize, @bitCast(@as(isize, @intCast(output_bytes)))); + break :blk_2 ref.*; + }; + }; + break :blk blk_1: { + const ref = &prior; + ref.* += @as(usize, @bitCast(@as(isize, @intCast(output_bytes)))); + break :blk_1 ref.*; + }; + }) { + k = 0; + while (k < filter_bytes) : (k += 1) { + (blk: { + const tmp = k; + if (tmp >= 0) break :blk cur + @as(usize, @intCast(tmp)) else break :blk cur - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = @as(u8, @bitCast(@as(i8, @truncate((@as(c_int, @bitCast(@as(c_uint, (blk: { + const tmp = k; + if (tmp >= 0) break :blk raw + @as(usize, @intCast(tmp)) else break :blk raw - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*))) + @as(c_int, @bitCast(@as(c_uint, (blk: { + const tmp = k - output_bytes; + if (tmp >= 0) break :blk cur + @as(usize, @intCast(tmp)) else break :blk cur - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*)))) & @as(c_int, 255))))); + } + } + } + break; + }, + @as(c_int, 2) => { + { + i = x -% @as(_m3dstbi__uint32, @bitCast(@as(c_int, 1))); + while (i >= @as(_m3dstbi__uint32, @bitCast(@as(c_int, 1)))) : (_ = blk: { + _ = blk_1: { + _ = blk_2: { + _ = blk_3: { + i -%= 1; + break :blk_3 blk_4: { + const tmp = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 255))))); + (blk_5: { + const tmp_6 = filter_bytes; + if (tmp_6 >= 0) break :blk_5 cur + @as(usize, @intCast(tmp_6)) else break :blk_5 cur - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_6)) +% -1)); + }).* = tmp; + break :blk_4 tmp; + }; + }; + break :blk_2 blk_3: { + const ref = &raw; + ref.* += @as(usize, @bitCast(@as(isize, @intCast(filter_bytes)))); + break :blk_3 ref.*; + }; + }; + break :blk_1 blk_2: { + const ref = &cur; + ref.* += @as(usize, @bitCast(@as(isize, @intCast(output_bytes)))); + break :blk_2 ref.*; + }; + }; + break :blk blk_1: { + const ref = &prior; + ref.* += @as(usize, @bitCast(@as(isize, @intCast(output_bytes)))); + break :blk_1 ref.*; + }; + }) { + k = 0; + while (k < filter_bytes) : (k += 1) { + (blk: { + const tmp = k; + if (tmp >= 0) break :blk cur + @as(usize, @intCast(tmp)) else break :blk cur - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = @as(u8, @bitCast(@as(i8, @truncate((@as(c_int, @bitCast(@as(c_uint, (blk: { + const tmp = k; + if (tmp >= 0) break :blk raw + @as(usize, @intCast(tmp)) else break :blk raw - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*))) + @as(c_int, @bitCast(@as(c_uint, (blk: { + const tmp = k; + if (tmp >= 0) break :blk prior + @as(usize, @intCast(tmp)) else break :blk prior - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*)))) & @as(c_int, 255))))); + } + } + } + break; + }, + @as(c_int, 3) => { + { + i = x -% @as(_m3dstbi__uint32, @bitCast(@as(c_int, 1))); + while (i >= @as(_m3dstbi__uint32, @bitCast(@as(c_int, 1)))) : (_ = blk: { + _ = blk_1: { + _ = blk_2: { + _ = blk_3: { + i -%= 1; + break :blk_3 blk_4: { + const tmp = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 255))))); + (blk_5: { + const tmp_6 = filter_bytes; + if (tmp_6 >= 0) break :blk_5 cur + @as(usize, @intCast(tmp_6)) else break :blk_5 cur - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_6)) +% -1)); + }).* = tmp; + break :blk_4 tmp; + }; + }; + break :blk_2 blk_3: { + const ref = &raw; + ref.* += @as(usize, @bitCast(@as(isize, @intCast(filter_bytes)))); + break :blk_3 ref.*; + }; + }; + break :blk_1 blk_2: { + const ref = &cur; + ref.* += @as(usize, @bitCast(@as(isize, @intCast(output_bytes)))); + break :blk_2 ref.*; + }; + }; + break :blk blk_1: { + const ref = &prior; + ref.* += @as(usize, @bitCast(@as(isize, @intCast(output_bytes)))); + break :blk_1 ref.*; + }; + }) { + k = 0; + while (k < filter_bytes) : (k += 1) { + (blk: { + const tmp = k; + if (tmp >= 0) break :blk cur + @as(usize, @intCast(tmp)) else break :blk cur - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = @as(u8, @bitCast(@as(i8, @truncate((@as(c_int, @bitCast(@as(c_uint, (blk: { + const tmp = k; + if (tmp >= 0) break :blk raw + @as(usize, @intCast(tmp)) else break :blk raw - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*))) + ((@as(c_int, @bitCast(@as(c_uint, (blk: { + const tmp = k; + if (tmp >= 0) break :blk prior + @as(usize, @intCast(tmp)) else break :blk prior - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*))) + @as(c_int, @bitCast(@as(c_uint, (blk: { + const tmp = k - output_bytes; + if (tmp >= 0) break :blk cur + @as(usize, @intCast(tmp)) else break :blk cur - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*)))) >> @intCast(1))) & @as(c_int, 255))))); + } + } + } + break; + }, + @as(c_int, 4) => { + { + i = x -% @as(_m3dstbi__uint32, @bitCast(@as(c_int, 1))); + while (i >= @as(_m3dstbi__uint32, @bitCast(@as(c_int, 1)))) : (_ = blk: { + _ = blk_1: { + _ = blk_2: { + _ = blk_3: { + i -%= 1; + break :blk_3 blk_4: { + const tmp = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 255))))); + (blk_5: { + const tmp_6 = filter_bytes; + if (tmp_6 >= 0) break :blk_5 cur + @as(usize, @intCast(tmp_6)) else break :blk_5 cur - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_6)) +% -1)); + }).* = tmp; + break :blk_4 tmp; + }; + }; + break :blk_2 blk_3: { + const ref = &raw; + ref.* += @as(usize, @bitCast(@as(isize, @intCast(filter_bytes)))); + break :blk_3 ref.*; + }; + }; + break :blk_1 blk_2: { + const ref = &cur; + ref.* += @as(usize, @bitCast(@as(isize, @intCast(output_bytes)))); + break :blk_2 ref.*; + }; + }; + break :blk blk_1: { + const ref = &prior; + ref.* += @as(usize, @bitCast(@as(isize, @intCast(output_bytes)))); + break :blk_1 ref.*; + }; + }) { + k = 0; + while (k < filter_bytes) : (k += 1) { + (blk: { + const tmp = k; + if (tmp >= 0) break :blk cur + @as(usize, @intCast(tmp)) else break :blk cur - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = @as(u8, @bitCast(@as(i8, @truncate((@as(c_int, @bitCast(@as(c_uint, (blk: { + const tmp = k; + if (tmp >= 0) break :blk raw + @as(usize, @intCast(tmp)) else break :blk raw - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*))) + _m3dstbi__paeth(@as(c_int, @bitCast(@as(c_uint, (blk: { + const tmp = k - output_bytes; + if (tmp >= 0) break :blk cur + @as(usize, @intCast(tmp)) else break :blk cur - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*))), @as(c_int, @bitCast(@as(c_uint, (blk: { + const tmp = k; + if (tmp >= 0) break :blk prior + @as(usize, @intCast(tmp)) else break :blk prior - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*))), @as(c_int, @bitCast(@as(c_uint, (blk: { + const tmp = k - output_bytes; + if (tmp >= 0) break :blk prior + @as(usize, @intCast(tmp)) else break :blk prior - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*))))) & @as(c_int, 255))))); + } + } + } + break; + }, + @as(c_int, 5) => { + { + i = x -% @as(_m3dstbi__uint32, @bitCast(@as(c_int, 1))); + while (i >= @as(_m3dstbi__uint32, @bitCast(@as(c_int, 1)))) : (_ = blk: { + _ = blk_1: { + _ = blk_2: { + _ = blk_3: { + i -%= 1; + break :blk_3 blk_4: { + const tmp = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 255))))); + (blk_5: { + const tmp_6 = filter_bytes; + if (tmp_6 >= 0) break :blk_5 cur + @as(usize, @intCast(tmp_6)) else break :blk_5 cur - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_6)) +% -1)); + }).* = tmp; + break :blk_4 tmp; + }; + }; + break :blk_2 blk_3: { + const ref = &raw; + ref.* += @as(usize, @bitCast(@as(isize, @intCast(filter_bytes)))); + break :blk_3 ref.*; + }; + }; + break :blk_1 blk_2: { + const ref = &cur; + ref.* += @as(usize, @bitCast(@as(isize, @intCast(output_bytes)))); + break :blk_2 ref.*; + }; + }; + break :blk blk_1: { + const ref = &prior; + ref.* += @as(usize, @bitCast(@as(isize, @intCast(output_bytes)))); + break :blk_1 ref.*; + }; + }) { + k = 0; + while (k < filter_bytes) : (k += 1) { + (blk: { + const tmp = k; + if (tmp >= 0) break :blk cur + @as(usize, @intCast(tmp)) else break :blk cur - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = @as(u8, @bitCast(@as(i8, @truncate((@as(c_int, @bitCast(@as(c_uint, (blk: { + const tmp = k; + if (tmp >= 0) break :blk raw + @as(usize, @intCast(tmp)) else break :blk raw - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*))) + (@as(c_int, @bitCast(@as(c_uint, (blk: { + const tmp = k - output_bytes; + if (tmp >= 0) break :blk cur + @as(usize, @intCast(tmp)) else break :blk cur - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*))) >> @intCast(1))) & @as(c_int, 255))))); + } + } + } + break; + }, + @as(c_int, 6) => { + { + i = x -% @as(_m3dstbi__uint32, @bitCast(@as(c_int, 1))); + while (i >= @as(_m3dstbi__uint32, @bitCast(@as(c_int, 1)))) : (_ = blk: { + _ = blk_1: { + _ = blk_2: { + _ = blk_3: { + i -%= 1; + break :blk_3 blk_4: { + const tmp = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 255))))); + (blk_5: { + const tmp_6 = filter_bytes; + if (tmp_6 >= 0) break :blk_5 cur + @as(usize, @intCast(tmp_6)) else break :blk_5 cur - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_6)) +% -1)); + }).* = tmp; + break :blk_4 tmp; + }; + }; + break :blk_2 blk_3: { + const ref = &raw; + ref.* += @as(usize, @bitCast(@as(isize, @intCast(filter_bytes)))); + break :blk_3 ref.*; + }; + }; + break :blk_1 blk_2: { + const ref = &cur; + ref.* += @as(usize, @bitCast(@as(isize, @intCast(output_bytes)))); + break :blk_2 ref.*; + }; + }; + break :blk blk_1: { + const ref = &prior; + ref.* += @as(usize, @bitCast(@as(isize, @intCast(output_bytes)))); + break :blk_1 ref.*; + }; + }) { + k = 0; + while (k < filter_bytes) : (k += 1) { + (blk: { + const tmp = k; + if (tmp >= 0) break :blk cur + @as(usize, @intCast(tmp)) else break :blk cur - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = @as(u8, @bitCast(@as(i8, @truncate((@as(c_int, @bitCast(@as(c_uint, (blk: { + const tmp = k; + if (tmp >= 0) break :blk raw + @as(usize, @intCast(tmp)) else break :blk raw - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*))) + _m3dstbi__paeth(@as(c_int, @bitCast(@as(c_uint, (blk: { + const tmp = k - output_bytes; + if (tmp >= 0) break :blk cur + @as(usize, @intCast(tmp)) else break :blk cur - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*))), @as(c_int, 0), @as(c_int, 0))) & @as(c_int, 255))))); + } + } + } + break; + }, + else => {}, + } + break; + } + if (depth == @as(c_int, 16)) { + cur = a.*.out + (stride *% j); + { + i = 0; + while (i < x) : (_ = blk: { + i +%= 1; + break :blk blk_1: { + const ref = &cur; + ref.* += @as(usize, @bitCast(@as(isize, @intCast(output_bytes)))); + break :blk_1 ref.*; + }; + }) { + (blk: { + const tmp = filter_bytes + @as(c_int, 1); + if (tmp >= 0) break :blk cur + @as(usize, @intCast(tmp)) else break :blk cur - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = 255; + } + } + } + } + } + } + if (depth < @as(c_int, 8)) { + { + j = 0; + while (j < y) : (j +%= 1) { + var cur: [*c]u8 = a.*.out + (stride *% j); + _ = &cur; + var in: [*c]u8 = ((a.*.out + (stride *% j)) + (x *% @as(_m3dstbi__uint32, @bitCast(out_n)))) - img_width_bytes; + _ = ∈ + var scale: u8 = @as(u8, @bitCast(@as(i8, @truncate(if (color == @as(c_int, 0)) @as(c_int, @bitCast(@as(c_uint, _m3dstbi__depth_scale_table[@as(c_uint, @intCast(depth))]))) else @as(c_int, 1))))); + _ = &scale; + if (depth == @as(c_int, 4)) { + { + k = @as(c_int, @bitCast(x *% @as(_m3dstbi__uint32, @bitCast(img_n)))); + while (k >= @as(c_int, 2)) : (_ = blk: { + k -= @as(c_int, 2); + break :blk blk_1: { + const ref = ∈ + ref.* += 1; + break :blk_1 ref.*; + }; + }) { + (blk: { + const ref = &cur; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, @bitCast(@as(c_uint, scale))) * (@as(c_int, @bitCast(@as(c_uint, in.*))) >> @intCast(4)))))); + (blk: { + const ref = &cur; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, @bitCast(@as(c_uint, scale))) * (@as(c_int, @bitCast(@as(c_uint, in.*))) & @as(c_int, 15)))))); + } + } + if (k > @as(c_int, 0)) { + (blk: { + const ref = &cur; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, @bitCast(@as(c_uint, scale))) * (@as(c_int, @bitCast(@as(c_uint, in.*))) >> @intCast(4)))))); + } + } else if (depth == @as(c_int, 2)) { + { + k = @as(c_int, @bitCast(x *% @as(_m3dstbi__uint32, @bitCast(img_n)))); + while (k >= @as(c_int, 4)) : (_ = blk: { + k -= @as(c_int, 4); + break :blk blk_1: { + const ref = ∈ + ref.* += 1; + break :blk_1 ref.*; + }; + }) { + (blk: { + const ref = &cur; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, @bitCast(@as(c_uint, scale))) * (@as(c_int, @bitCast(@as(c_uint, in.*))) >> @intCast(6)))))); + (blk: { + const ref = &cur; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, @bitCast(@as(c_uint, scale))) * ((@as(c_int, @bitCast(@as(c_uint, in.*))) >> @intCast(4)) & @as(c_int, 3)))))); + (blk: { + const ref = &cur; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, @bitCast(@as(c_uint, scale))) * ((@as(c_int, @bitCast(@as(c_uint, in.*))) >> @intCast(2)) & @as(c_int, 3)))))); + (blk: { + const ref = &cur; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, @bitCast(@as(c_uint, scale))) * (@as(c_int, @bitCast(@as(c_uint, in.*))) & @as(c_int, 3)))))); + } + } + if (k > @as(c_int, 0)) { + (blk: { + const ref = &cur; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, @bitCast(@as(c_uint, scale))) * (@as(c_int, @bitCast(@as(c_uint, in.*))) >> @intCast(6)))))); + } + if (k > @as(c_int, 1)) { + (blk: { + const ref = &cur; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, @bitCast(@as(c_uint, scale))) * ((@as(c_int, @bitCast(@as(c_uint, in.*))) >> @intCast(4)) & @as(c_int, 3)))))); + } + if (k > @as(c_int, 2)) { + (blk: { + const ref = &cur; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, @bitCast(@as(c_uint, scale))) * ((@as(c_int, @bitCast(@as(c_uint, in.*))) >> @intCast(2)) & @as(c_int, 3)))))); + } + } else if (depth == @as(c_int, 1)) { + { + k = @as(c_int, @bitCast(x *% @as(_m3dstbi__uint32, @bitCast(img_n)))); + while (k >= @as(c_int, 8)) : (_ = blk: { + k -= @as(c_int, 8); + break :blk blk_1: { + const ref = ∈ + ref.* += 1; + break :blk_1 ref.*; + }; + }) { + (blk: { + const ref = &cur; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, @bitCast(@as(c_uint, scale))) * (@as(c_int, @bitCast(@as(c_uint, in.*))) >> @intCast(7)))))); + (blk: { + const ref = &cur; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, @bitCast(@as(c_uint, scale))) * ((@as(c_int, @bitCast(@as(c_uint, in.*))) >> @intCast(6)) & @as(c_int, 1)))))); + (blk: { + const ref = &cur; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, @bitCast(@as(c_uint, scale))) * ((@as(c_int, @bitCast(@as(c_uint, in.*))) >> @intCast(5)) & @as(c_int, 1)))))); + (blk: { + const ref = &cur; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, @bitCast(@as(c_uint, scale))) * ((@as(c_int, @bitCast(@as(c_uint, in.*))) >> @intCast(4)) & @as(c_int, 1)))))); + (blk: { + const ref = &cur; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, @bitCast(@as(c_uint, scale))) * ((@as(c_int, @bitCast(@as(c_uint, in.*))) >> @intCast(3)) & @as(c_int, 1)))))); + (blk: { + const ref = &cur; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, @bitCast(@as(c_uint, scale))) * ((@as(c_int, @bitCast(@as(c_uint, in.*))) >> @intCast(2)) & @as(c_int, 1)))))); + (blk: { + const ref = &cur; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, @bitCast(@as(c_uint, scale))) * ((@as(c_int, @bitCast(@as(c_uint, in.*))) >> @intCast(1)) & @as(c_int, 1)))))); + (blk: { + const ref = &cur; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, @bitCast(@as(c_uint, scale))) * (@as(c_int, @bitCast(@as(c_uint, in.*))) & @as(c_int, 1)))))); + } + } + if (k > @as(c_int, 0)) { + (blk: { + const ref = &cur; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, @bitCast(@as(c_uint, scale))) * (@as(c_int, @bitCast(@as(c_uint, in.*))) >> @intCast(7)))))); + } + if (k > @as(c_int, 1)) { + (blk: { + const ref = &cur; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, @bitCast(@as(c_uint, scale))) * ((@as(c_int, @bitCast(@as(c_uint, in.*))) >> @intCast(6)) & @as(c_int, 1)))))); + } + if (k > @as(c_int, 2)) { + (blk: { + const ref = &cur; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, @bitCast(@as(c_uint, scale))) * ((@as(c_int, @bitCast(@as(c_uint, in.*))) >> @intCast(5)) & @as(c_int, 1)))))); + } + if (k > @as(c_int, 3)) { + (blk: { + const ref = &cur; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, @bitCast(@as(c_uint, scale))) * ((@as(c_int, @bitCast(@as(c_uint, in.*))) >> @intCast(4)) & @as(c_int, 1)))))); + } + if (k > @as(c_int, 4)) { + (blk: { + const ref = &cur; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, @bitCast(@as(c_uint, scale))) * ((@as(c_int, @bitCast(@as(c_uint, in.*))) >> @intCast(3)) & @as(c_int, 1)))))); + } + if (k > @as(c_int, 5)) { + (blk: { + const ref = &cur; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, @bitCast(@as(c_uint, scale))) * ((@as(c_int, @bitCast(@as(c_uint, in.*))) >> @intCast(2)) & @as(c_int, 1)))))); + } + if (k > @as(c_int, 6)) { + (blk: { + const ref = &cur; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, @bitCast(@as(c_uint, scale))) * ((@as(c_int, @bitCast(@as(c_uint, in.*))) >> @intCast(1)) & @as(c_int, 1)))))); + } + } + if (img_n != out_n) { + var q: c_int = undefined; + _ = &q; + cur = a.*.out + (stride *% j); + if (img_n == @as(c_int, 1)) { + { + q = @as(c_int, @bitCast(x -% @as(_m3dstbi__uint32, @bitCast(@as(c_int, 1))))); + while (q >= @as(c_int, 0)) : (q -= 1) { + (blk: { + const tmp = (q * @as(c_int, 2)) + @as(c_int, 1); + if (tmp >= 0) break :blk cur + @as(usize, @intCast(tmp)) else break :blk cur - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = 255; + (blk: { + const tmp = (q * @as(c_int, 2)) + @as(c_int, 0); + if (tmp >= 0) break :blk cur + @as(usize, @intCast(tmp)) else break :blk cur - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = (blk: { + const tmp = q; + if (tmp >= 0) break :blk cur + @as(usize, @intCast(tmp)) else break :blk cur - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*; + } + } + } else { + { + q = @as(c_int, @bitCast(x -% @as(_m3dstbi__uint32, @bitCast(@as(c_int, 1))))); + while (q >= @as(c_int, 0)) : (q -= 1) { + (blk: { + const tmp = (q * @as(c_int, 4)) + @as(c_int, 3); + if (tmp >= 0) break :blk cur + @as(usize, @intCast(tmp)) else break :blk cur - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = 255; + (blk: { + const tmp = (q * @as(c_int, 4)) + @as(c_int, 2); + if (tmp >= 0) break :blk cur + @as(usize, @intCast(tmp)) else break :blk cur - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = (blk: { + const tmp = (q * @as(c_int, 3)) + @as(c_int, 2); + if (tmp >= 0) break :blk cur + @as(usize, @intCast(tmp)) else break :blk cur - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*; + (blk: { + const tmp = (q * @as(c_int, 4)) + @as(c_int, 1); + if (tmp >= 0) break :blk cur + @as(usize, @intCast(tmp)) else break :blk cur - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = (blk: { + const tmp = (q * @as(c_int, 3)) + @as(c_int, 1); + if (tmp >= 0) break :blk cur + @as(usize, @intCast(tmp)) else break :blk cur - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*; + (blk: { + const tmp = (q * @as(c_int, 4)) + @as(c_int, 0); + if (tmp >= 0) break :blk cur + @as(usize, @intCast(tmp)) else break :blk cur - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = (blk: { + const tmp = (q * @as(c_int, 3)) + @as(c_int, 0); + if (tmp >= 0) break :blk cur + @as(usize, @intCast(tmp)) else break :blk cur - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*; + } + } + } + } + } + } + } else if (depth == @as(c_int, 16)) { + var cur: [*c]u8 = a.*.out; + _ = &cur; + var cur16: [*c]_m3dstbi__uint16 = @as([*c]_m3dstbi__uint16, @ptrCast(@alignCast(cur))); + _ = &cur16; + { + i = 0; + while (i < ((x *% y) *% @as(_m3dstbi__uint32, @bitCast(out_n)))) : (_ = blk: { + _ = blk_1: { + i +%= 1; + break :blk_1 blk_2: { + const ref = &cur16; + const tmp = ref.*; + ref.* += 1; + break :blk_2 tmp; + }; + }; + break :blk blk_1: { + const ref = &cur; + ref.* += @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 2))))); + break :blk_1 ref.*; + }; + }) { + cur16.* = @as(_m3dstbi__uint16, @bitCast(@as(c_short, @truncate((@as(c_int, @bitCast(@as(c_uint, cur[@as(c_uint, @intCast(@as(c_int, 0)))]))) << @intCast(8)) | @as(c_int, @bitCast(@as(c_uint, cur[@as(c_uint, @intCast(@as(c_int, 1)))]))))))); + } + } + } + return 1; +} +pub fn _m3dstbi__create_png_image(arg_a: [*c]_m3dstbi__png, arg_image_data: [*c]u8, arg_image_data_len: _m3dstbi__uint32, arg_out_n: c_int, arg_depth: c_int, arg_color: c_int, arg_interlaced: c_int) callconv(.C) c_int { + var a = arg_a; + _ = &a; + var image_data = arg_image_data; + _ = &image_data; + var image_data_len = arg_image_data_len; + _ = &image_data_len; + var out_n = arg_out_n; + _ = &out_n; + var depth = arg_depth; + _ = &depth; + var color = arg_color; + _ = &color; + var interlaced = arg_interlaced; + _ = &interlaced; + var bytes: c_int = if (depth == @as(c_int, 16)) @as(c_int, 2) else @as(c_int, 1); + _ = &bytes; + var out_bytes: c_int = out_n * bytes; + _ = &out_bytes; + var final: [*c]u8 = undefined; + _ = &final; + var p: c_int = undefined; + _ = &p; + if (!(interlaced != 0)) return _m3dstbi__create_png_image_raw(a, image_data, image_data_len, out_n, a.*.s.*.img_x, a.*.s.*.img_y, depth, color); + final = @as([*c]u8, @ptrCast(@alignCast(_m3dstbi__malloc_mad3(@as(c_int, @bitCast(a.*.s.*.img_x)), @as(c_int, @bitCast(a.*.s.*.img_y)), out_bytes, @as(c_int, 0))))); + { + p = 0; + while (p < @as(c_int, 7)) : (p += 1) { + var xorig: [7]c_int = [7]c_int{ + 0, + 4, + 0, + 2, + 0, + 1, + 0, + }; + _ = &xorig; + var yorig: [7]c_int = [7]c_int{ + 0, + 0, + 4, + 0, + 2, + 0, + 1, + }; + _ = &yorig; + var xspc: [7]c_int = [7]c_int{ + 8, + 8, + 4, + 4, + 2, + 2, + 1, + }; + _ = &xspc; + var yspc: [7]c_int = [7]c_int{ + 8, + 8, + 8, + 4, + 4, + 2, + 2, + }; + _ = &yspc; + var i: c_int = undefined; + _ = &i; + var j: c_int = undefined; + _ = &j; + var x: c_int = undefined; + _ = &x; + var y: c_int = undefined; + _ = &y; + x = @as(c_int, @bitCast((((a.*.s.*.img_x -% @as(_m3dstbi__uint32, @bitCast(xorig[@as(c_uint, @intCast(p))]))) +% @as(_m3dstbi__uint32, @bitCast(xspc[@as(c_uint, @intCast(p))]))) -% @as(_m3dstbi__uint32, @bitCast(@as(c_int, 1)))) / @as(_m3dstbi__uint32, @bitCast(xspc[@as(c_uint, @intCast(p))])))); + y = @as(c_int, @bitCast((((a.*.s.*.img_y -% @as(_m3dstbi__uint32, @bitCast(yorig[@as(c_uint, @intCast(p))]))) +% @as(_m3dstbi__uint32, @bitCast(yspc[@as(c_uint, @intCast(p))]))) -% @as(_m3dstbi__uint32, @bitCast(@as(c_int, 1)))) / @as(_m3dstbi__uint32, @bitCast(yspc[@as(c_uint, @intCast(p))])))); + if ((x != 0) and (y != 0)) { + var img_len: _m3dstbi__uint32 = @as(_m3dstbi__uint32, @bitCast((((((a.*.s.*.img_n * x) * depth) + @as(c_int, 7)) >> @intCast(3)) + @as(c_int, 1)) * y)); + _ = &img_len; + if (!(_m3dstbi__create_png_image_raw(a, image_data, image_data_len, out_n, @as(_m3dstbi__uint32, @bitCast(x)), @as(_m3dstbi__uint32, @bitCast(y)), depth, color) != 0)) { + free(@as(?*anyopaque, @ptrCast(final))); + return 0; + } + { + j = 0; + while (j < y) : (j += 1) { + { + i = 0; + while (i < x) : (i += 1) { + var out_y: c_int = (j * yspc[@as(c_uint, @intCast(p))]) + yorig[@as(c_uint, @intCast(p))]; + _ = &out_y; + var out_x: c_int = (i * xspc[@as(c_uint, @intCast(p))]) + xorig[@as(c_uint, @intCast(p))]; + _ = &out_x; + _ = memcpy(@as(?*anyopaque, @ptrCast((final + ((@as(_m3dstbi__uint32, @bitCast(out_y)) *% a.*.s.*.img_x) *% @as(_m3dstbi__uint32, @bitCast(out_bytes)))) + @as(usize, @bitCast(@as(isize, @intCast(out_x * out_bytes)))))), @as(?*const anyopaque, @ptrCast(a.*.out + @as(usize, @bitCast(@as(isize, @intCast(((j * x) + i) * out_bytes)))))), @as(c_ulong, @bitCast(@as(c_long, out_bytes)))); + } + } + } + } + free(@as(?*anyopaque, @ptrCast(a.*.out))); + image_data += @as([*c]u8, @ptrFromInt(img_len)); + image_data_len -%= img_len; + } + } + } + a.*.out = final; + return 1; +} +pub fn _m3dstbi__compute_transparency(arg_z: [*c]_m3dstbi__png, arg_tc: [*c]u8, arg_out_n: c_int) callconv(.C) c_int { + var z = arg_z; + _ = &z; + var tc = arg_tc; + _ = &tc; + var out_n = arg_out_n; + _ = &out_n; + var s: [*c]_m3dstbi__context = z.*.s; + _ = &s; + var i: _m3dstbi__uint32 = undefined; + _ = &i; + var pixel_count: _m3dstbi__uint32 = s.*.img_x *% s.*.img_y; + _ = &pixel_count; + var p: [*c]u8 = z.*.out; + _ = &p; + if (out_n == @as(c_int, 2)) { + { + i = 0; + while (i < pixel_count) : (i +%= 1) { + p[@as(c_uint, @intCast(@as(c_int, 1)))] = @as(u8, @bitCast(@as(i8, @truncate(if (@as(c_int, @bitCast(@as(c_uint, p[@as(c_uint, @intCast(@as(c_int, 0)))]))) == @as(c_int, @bitCast(@as(c_uint, tc[@as(c_uint, @intCast(@as(c_int, 0)))])))) @as(c_int, 0) else @as(c_int, 255))))); + p += @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 2))))); + } + } + } else { + { + i = 0; + while (i < pixel_count) : (i +%= 1) { + if (((@as(c_int, @bitCast(@as(c_uint, p[@as(c_uint, @intCast(@as(c_int, 0)))]))) == @as(c_int, @bitCast(@as(c_uint, tc[@as(c_uint, @intCast(@as(c_int, 0)))])))) and (@as(c_int, @bitCast(@as(c_uint, p[@as(c_uint, @intCast(@as(c_int, 1)))]))) == @as(c_int, @bitCast(@as(c_uint, tc[@as(c_uint, @intCast(@as(c_int, 1)))]))))) and (@as(c_int, @bitCast(@as(c_uint, p[@as(c_uint, @intCast(@as(c_int, 2)))]))) == @as(c_int, @bitCast(@as(c_uint, tc[@as(c_uint, @intCast(@as(c_int, 2)))]))))) { + p[@as(c_uint, @intCast(@as(c_int, 3)))] = 0; + } + p += @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 4))))); + } + } + } + return 1; +} +pub fn _m3dstbi__compute_transparency16(arg_z: [*c]_m3dstbi__png, arg_tc: [*c]_m3dstbi__uint16, arg_out_n: c_int) callconv(.C) c_int { + var z = arg_z; + _ = &z; + var tc = arg_tc; + _ = &tc; + var out_n = arg_out_n; + _ = &out_n; + var s: [*c]_m3dstbi__context = z.*.s; + _ = &s; + var i: _m3dstbi__uint32 = undefined; + _ = &i; + var pixel_count: _m3dstbi__uint32 = s.*.img_x *% s.*.img_y; + _ = &pixel_count; + var p: [*c]_m3dstbi__uint16 = @as([*c]_m3dstbi__uint16, @ptrCast(@alignCast(z.*.out))); + _ = &p; + if (out_n == @as(c_int, 2)) { + { + i = 0; + while (i < pixel_count) : (i +%= 1) { + p[@as(c_uint, @intCast(@as(c_int, 1)))] = @as(_m3dstbi__uint16, @bitCast(@as(c_short, @truncate(if (@as(c_int, @bitCast(@as(c_uint, p[@as(c_uint, @intCast(@as(c_int, 0)))]))) == @as(c_int, @bitCast(@as(c_uint, tc[@as(c_uint, @intCast(@as(c_int, 0)))])))) @as(c_int, 0) else @as(c_int, 65535))))); + p += @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 2))))); + } + } + } else { + { + i = 0; + while (i < pixel_count) : (i +%= 1) { + if (((@as(c_int, @bitCast(@as(c_uint, p[@as(c_uint, @intCast(@as(c_int, 0)))]))) == @as(c_int, @bitCast(@as(c_uint, tc[@as(c_uint, @intCast(@as(c_int, 0)))])))) and (@as(c_int, @bitCast(@as(c_uint, p[@as(c_uint, @intCast(@as(c_int, 1)))]))) == @as(c_int, @bitCast(@as(c_uint, tc[@as(c_uint, @intCast(@as(c_int, 1)))]))))) and (@as(c_int, @bitCast(@as(c_uint, p[@as(c_uint, @intCast(@as(c_int, 2)))]))) == @as(c_int, @bitCast(@as(c_uint, tc[@as(c_uint, @intCast(@as(c_int, 2)))]))))) { + p[@as(c_uint, @intCast(@as(c_int, 3)))] = 0; + } + p += @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 4))))); + } + } + } + return 1; +} +pub fn _m3dstbi__expand_png_palette(arg_a: [*c]_m3dstbi__png, arg_palette: [*c]u8, arg_len: c_int, arg_pal_img_n: c_int) callconv(.C) c_int { + var a = arg_a; + _ = &a; + var palette = arg_palette; + _ = &palette; + var len = arg_len; + _ = &len; + var pal_img_n = arg_pal_img_n; + _ = &pal_img_n; + var i: _m3dstbi__uint32 = undefined; + _ = &i; + var pixel_count: _m3dstbi__uint32 = a.*.s.*.img_x *% a.*.s.*.img_y; + _ = &pixel_count; + var p: [*c]u8 = undefined; + _ = &p; + var temp_out: [*c]u8 = undefined; + _ = &temp_out; + var orig: [*c]u8 = a.*.out; + _ = &orig; + p = @as([*c]u8, @ptrCast(@alignCast(_m3dstbi__malloc_mad2(@as(c_int, @bitCast(pixel_count)), pal_img_n, @as(c_int, 0))))); + if (p == @as([*c]u8, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0))))))) return _m3dstbi__errstr("Out of memory"); + temp_out = p; + if (pal_img_n == @as(c_int, 3)) { + { + i = 0; + while (i < pixel_count) : (i +%= 1) { + var n: c_int = @as(c_int, @bitCast(@as(c_uint, orig[i]))) * @as(c_int, 4); + _ = &n; + p[@as(c_uint, @intCast(@as(c_int, 0)))] = (blk: { + const tmp = n; + if (tmp >= 0) break :blk palette + @as(usize, @intCast(tmp)) else break :blk palette - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*; + p[@as(c_uint, @intCast(@as(c_int, 1)))] = (blk: { + const tmp = n + @as(c_int, 1); + if (tmp >= 0) break :blk palette + @as(usize, @intCast(tmp)) else break :blk palette - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*; + p[@as(c_uint, @intCast(@as(c_int, 2)))] = (blk: { + const tmp = n + @as(c_int, 2); + if (tmp >= 0) break :blk palette + @as(usize, @intCast(tmp)) else break :blk palette - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*; + p += @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 3))))); + } + } + } else { + { + i = 0; + while (i < pixel_count) : (i +%= 1) { + var n: c_int = @as(c_int, @bitCast(@as(c_uint, orig[i]))) * @as(c_int, 4); + _ = &n; + p[@as(c_uint, @intCast(@as(c_int, 0)))] = (blk: { + const tmp = n; + if (tmp >= 0) break :blk palette + @as(usize, @intCast(tmp)) else break :blk palette - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*; + p[@as(c_uint, @intCast(@as(c_int, 1)))] = (blk: { + const tmp = n + @as(c_int, 1); + if (tmp >= 0) break :blk palette + @as(usize, @intCast(tmp)) else break :blk palette - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*; + p[@as(c_uint, @intCast(@as(c_int, 2)))] = (blk: { + const tmp = n + @as(c_int, 2); + if (tmp >= 0) break :blk palette + @as(usize, @intCast(tmp)) else break :blk palette - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*; + p[@as(c_uint, @intCast(@as(c_int, 3)))] = (blk: { + const tmp = n + @as(c_int, 3); + if (tmp >= 0) break :blk palette + @as(usize, @intCast(tmp)) else break :blk palette - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*; + p += @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 4))))); + } + } + } + free(@as(?*anyopaque, @ptrCast(a.*.out))); + a.*.out = temp_out; + _ = @sizeOf(c_int); + return 1; +} +pub fn _m3dstbi__parse_png_file(arg_z: [*c]_m3dstbi__png, arg_scan: c_int, arg_req_comp: c_int) callconv(.C) c_int { + var z = arg_z; + _ = &z; + var scan = arg_scan; + _ = &scan; + var req_comp = arg_req_comp; + _ = &req_comp; + var palette: [1024]u8 = undefined; + _ = &palette; + var pal_img_n: u8 = 0; + _ = &pal_img_n; + var has_trans: u8 = 0; + _ = &has_trans; + var tc: [3]u8 = undefined; + _ = &tc; + var tc16: [3]_m3dstbi__uint16 = undefined; + _ = &tc16; + var ioff: _m3dstbi__uint32 = 0; + _ = &ioff; + var idata_limit: _m3dstbi__uint32 = 0; + _ = &idata_limit; + var i: _m3dstbi__uint32 = undefined; + _ = &i; + var pal_len: _m3dstbi__uint32 = 0; + _ = &pal_len; + var first: c_int = 1; + _ = &first; + var k: c_int = undefined; + _ = &k; + var interlace: c_int = 0; + _ = &interlace; + var color: c_int = 0; + _ = &color; + var s: [*c]_m3dstbi__context = z.*.s; + _ = &s; + z.*.expanded = null; + z.*.idata = null; + z.*.out = null; + if (!(_m3dstbi__check_png_header(s) != 0)) return 0; + if (scan == STBI__SCAN_type) return 1; + while (true) { + var c: _m3dstbi__pngchunk = _m3dstbi__get_chunk_header(s); + _ = &c; + while (true) { + switch (c.type) { + @as(c_uint, 1130840649) => { + _m3dstbi__skip(s, @as(c_int, @bitCast(c.length))); + break; + }, + @as(c_uint, 1229472850) => { + { + var comp: c_int = undefined; + _ = ∁ + var filter: c_int = undefined; + _ = &filter; + if (!(first != 0)) return _m3dstbi__errstr("Corrupt PNG"); + first = 0; + if (c.length != @as(_m3dstbi__uint32, @bitCast(@as(c_int, 13)))) return _m3dstbi__errstr("Corrupt PNG"); + s.*.img_x = _m3dstbi__get32be(s); + if (s.*.img_x > @as(_m3dstbi__uint32, @bitCast(@as(c_int, 1) << @intCast(24)))) return _m3dstbi__errstr("Very large image (corrupt?)"); + s.*.img_y = _m3dstbi__get32be(s); + if (s.*.img_y > @as(_m3dstbi__uint32, @bitCast(@as(c_int, 1) << @intCast(24)))) return _m3dstbi__errstr("Very large image (corrupt?)"); + z.*.depth = @as(c_int, @bitCast(@as(c_uint, _m3dstbi__get8(s)))); + if (((((z.*.depth != @as(c_int, 1)) and (z.*.depth != @as(c_int, 2))) and (z.*.depth != @as(c_int, 4))) and (z.*.depth != @as(c_int, 8))) and (z.*.depth != @as(c_int, 16))) return _m3dstbi__errstr("PNG not supported: 1/2/4/8/16-bit only"); + color = @as(c_int, @bitCast(@as(c_uint, _m3dstbi__get8(s)))); + if (color > @as(c_int, 6)) return _m3dstbi__errstr("Corrupt PNG"); + if ((color == @as(c_int, 3)) and (z.*.depth == @as(c_int, 16))) return _m3dstbi__errstr("Corrupt PNG"); + if (color == @as(c_int, 3)) { + pal_img_n = 3; + } else if ((color & @as(c_int, 1)) != 0) return _m3dstbi__errstr("Corrupt PNG"); + comp = @as(c_int, @bitCast(@as(c_uint, _m3dstbi__get8(s)))); + if (comp != 0) return _m3dstbi__errstr("Corrupt PNG"); + filter = @as(c_int, @bitCast(@as(c_uint, _m3dstbi__get8(s)))); + if (filter != 0) return _m3dstbi__errstr("Corrupt PNG"); + interlace = @as(c_int, @bitCast(@as(c_uint, _m3dstbi__get8(s)))); + if (interlace > @as(c_int, 1)) return _m3dstbi__errstr("Corrupt PNG"); + if (!(s.*.img_x != 0) or !(s.*.img_y != 0)) return _m3dstbi__errstr("Corrupt PNG"); + if (!(pal_img_n != 0)) { + s.*.img_n = (if ((color & @as(c_int, 2)) != 0) @as(c_int, 3) else @as(c_int, 1)) + (if ((color & @as(c_int, 4)) != 0) @as(c_int, 1) else @as(c_int, 0)); + if (((@as(_m3dstbi__uint32, @bitCast(@as(c_int, 1) << @intCast(30))) / s.*.img_x) / @as(_m3dstbi__uint32, @bitCast(s.*.img_n))) < s.*.img_y) return _m3dstbi__errstr("Image too large to decode"); + if (scan == STBI__SCAN_header) return 1; + } else { + s.*.img_n = 1; + if (((@as(_m3dstbi__uint32, @bitCast(@as(c_int, 1) << @intCast(30))) / s.*.img_x) / @as(_m3dstbi__uint32, @bitCast(@as(c_int, 4)))) < s.*.img_y) return _m3dstbi__errstr("Corrupt PNG"); + } + break; + } + }, + @as(c_uint, 1347179589) => { + { + if (first != 0) return _m3dstbi__errstr("Corrupt PNG"); + if (c.length > @as(_m3dstbi__uint32, @bitCast(@as(c_int, 256) * @as(c_int, 3)))) return _m3dstbi__errstr("Corrupt PNG"); + pal_len = c.length / @as(_m3dstbi__uint32, @bitCast(@as(c_int, 3))); + if ((pal_len *% @as(_m3dstbi__uint32, @bitCast(@as(c_int, 3)))) != c.length) return _m3dstbi__errstr("Corrupt PNG"); + { + i = 0; + while (i < pal_len) : (i +%= 1) { + palette[(i *% @as(_m3dstbi__uint32, @bitCast(@as(c_int, 4)))) +% @as(_m3dstbi__uint32, @bitCast(@as(c_int, 0)))] = _m3dstbi__get8(s); + palette[(i *% @as(_m3dstbi__uint32, @bitCast(@as(c_int, 4)))) +% @as(_m3dstbi__uint32, @bitCast(@as(c_int, 1)))] = _m3dstbi__get8(s); + palette[(i *% @as(_m3dstbi__uint32, @bitCast(@as(c_int, 4)))) +% @as(_m3dstbi__uint32, @bitCast(@as(c_int, 2)))] = _m3dstbi__get8(s); + palette[(i *% @as(_m3dstbi__uint32, @bitCast(@as(c_int, 4)))) +% @as(_m3dstbi__uint32, @bitCast(@as(c_int, 3)))] = 255; + } + } + break; + } + }, + @as(c_uint, 1951551059) => { + { + if (first != 0) return _m3dstbi__errstr("Corrupt PNG"); + if (z.*.idata != null) return _m3dstbi__errstr("Corrupt PNG"); + if (pal_img_n != 0) { + if (scan == STBI__SCAN_header) { + s.*.img_n = 4; + return 1; + } + if (pal_len == @as(_m3dstbi__uint32, @bitCast(@as(c_int, 0)))) return _m3dstbi__errstr("Corrupt PNG"); + if (c.length > pal_len) return _m3dstbi__errstr("Corrupt PNG"); + pal_img_n = 4; + { + i = 0; + while (i < c.length) : (i +%= 1) { + palette[(i *% @as(_m3dstbi__uint32, @bitCast(@as(c_int, 4)))) +% @as(_m3dstbi__uint32, @bitCast(@as(c_int, 3)))] = _m3dstbi__get8(s); + } + } + } else { + if (!((s.*.img_n & @as(c_int, 1)) != 0)) return _m3dstbi__errstr("Corrupt PNG"); + if (c.length != (@as(_m3dstbi__uint32, @bitCast(s.*.img_n)) *% @as(_m3dstbi__uint32, @bitCast(@as(c_int, 2))))) return _m3dstbi__errstr("Corrupt PNG"); + has_trans = 1; + if (z.*.depth == @as(c_int, 16)) { + { + k = 0; + while (k < s.*.img_n) : (k += 1) { + tc16[@as(c_uint, @intCast(k))] = @as(_m3dstbi__uint16, @bitCast(@as(c_short, @truncate(_m3dstbi__get16be(s))))); + } + } + } else { + { + k = 0; + while (k < s.*.img_n) : (k += 1) { + tc[@as(c_uint, @intCast(k))] = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, @bitCast(@as(c_uint, @as(u8, @bitCast(@as(i8, @truncate(_m3dstbi__get16be(s) & @as(c_int, 255)))))))) * @as(c_int, @bitCast(@as(c_uint, _m3dstbi__depth_scale_table[@as(c_uint, @intCast(z.*.depth))]))))))); + } + } + } + } + break; + } + }, + @as(c_uint, 1229209940) => { + { + if (first != 0) return _m3dstbi__errstr("Corrupt PNG"); + if ((@as(c_int, @bitCast(@as(c_uint, pal_img_n))) != 0) and !(pal_len != 0)) return _m3dstbi__errstr("Corrupt PNG"); + if (scan == STBI__SCAN_header) { + s.*.img_n = @as(c_int, @bitCast(@as(c_uint, pal_img_n))); + return 1; + } + if (@as(c_int, @bitCast(ioff +% c.length)) < @as(c_int, @bitCast(ioff))) return 0; + if ((ioff +% c.length) > idata_limit) { + var idata_limit_old: _m3dstbi__uint32 = idata_limit; + _ = &idata_limit_old; + var p: [*c]u8 = undefined; + _ = &p; + if (idata_limit == @as(_m3dstbi__uint32, @bitCast(@as(c_int, 0)))) { + idata_limit = if (c.length > @as(_m3dstbi__uint32, @bitCast(@as(c_int, 4096)))) c.length else @as(_m3dstbi__uint32, @bitCast(@as(c_int, 4096))); + } + while ((ioff +% c.length) > idata_limit) { + idata_limit *%= @as(_m3dstbi__uint32, @bitCast(@as(c_int, 2))); + } + _ = @sizeOf(_m3dstbi__uint32); + p = @as([*c]u8, @ptrCast(@alignCast(realloc(@as(?*anyopaque, @ptrCast(z.*.idata)), @as(c_ulong, @bitCast(@as(c_ulong, idata_limit))))))); + if (p == @as([*c]u8, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0))))))) return _m3dstbi__errstr("Out of memory"); + z.*.idata = p; + } + if (!(_m3dstbi__getn(s, z.*.idata + ioff, @as(c_int, @bitCast(c.length))) != 0)) return _m3dstbi__errstr("Corrupt PNG"); + ioff +%= c.length; + break; + } + }, + @as(c_uint, 1229278788) => { + { + var raw_len: _m3dstbi__uint32 = undefined; + _ = &raw_len; + var bpl: _m3dstbi__uint32 = undefined; + _ = &bpl; + if (first != 0) return _m3dstbi__errstr("Corrupt PNG"); + if (scan != STBI__SCAN_load) return 1; + if (z.*.idata == @as([*c]u8, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0))))))) return _m3dstbi__errstr("Corrupt PNG"); + bpl = ((s.*.img_x *% @as(_m3dstbi__uint32, @bitCast(z.*.depth))) +% @as(_m3dstbi__uint32, @bitCast(@as(c_int, 7)))) / @as(_m3dstbi__uint32, @bitCast(@as(c_int, 8))); + raw_len = ((bpl *% s.*.img_y) *% @as(_m3dstbi__uint32, @bitCast(s.*.img_n))) +% s.*.img_y; + z.*.expanded = @as([*c]u8, @ptrCast(@alignCast(_m3dstbi_zlib_decode_malloc_guesssize_headerflag(@as([*c]u8, @ptrCast(@alignCast(z.*.idata))), @as(c_int, @bitCast(ioff)), @as(c_int, @bitCast(raw_len)), @as([*c]c_int, @ptrCast(@alignCast(&raw_len))), @as(c_int, 1))))); + if (z.*.expanded == @as([*c]u8, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0))))))) return 0; + free(@as(?*anyopaque, @ptrCast(z.*.idata))); + z.*.idata = null; + if ((((req_comp == (s.*.img_n + @as(c_int, 1))) and (req_comp != @as(c_int, 3))) and !(pal_img_n != 0)) or (@as(c_int, @bitCast(@as(c_uint, has_trans))) != 0)) { + s.*.img_out_n = s.*.img_n + @as(c_int, 1); + } else { + s.*.img_out_n = s.*.img_n; + } + if (!(_m3dstbi__create_png_image(z, z.*.expanded, raw_len, s.*.img_out_n, z.*.depth, color, interlace) != 0)) return 0; + if (has_trans != 0) { + if (z.*.depth == @as(c_int, 16)) { + if (!(_m3dstbi__compute_transparency16(z, @as([*c]_m3dstbi__uint16, @ptrCast(@alignCast(&tc16))), s.*.img_out_n) != 0)) return 0; + } else { + if (!(_m3dstbi__compute_transparency(z, @as([*c]u8, @ptrCast(@alignCast(&tc))), s.*.img_out_n) != 0)) return 0; + } + } + if (pal_img_n != 0) { + s.*.img_n = @as(c_int, @bitCast(@as(c_uint, pal_img_n))); + s.*.img_out_n = @as(c_int, @bitCast(@as(c_uint, pal_img_n))); + if (req_comp >= @as(c_int, 3)) { + s.*.img_out_n = req_comp; + } + if (!(_m3dstbi__expand_png_palette(z, @as([*c]u8, @ptrCast(@alignCast(&palette))), @as(c_int, @bitCast(pal_len)), s.*.img_out_n) != 0)) return 0; + } else if (has_trans != 0) { + s.*.img_n += 1; + } + free(@as(?*anyopaque, @ptrCast(z.*.expanded))); + z.*.expanded = null; + return 1; + } + }, + else => { + if (first != 0) return _m3dstbi__errstr("Corrupt PNG"); + if ((c.type & @as(_m3dstbi__uint32, @bitCast(@as(c_int, 1) << @intCast(29)))) == @as(_m3dstbi__uint32, @bitCast(@as(c_int, 0)))) { + return _m3dstbi__errstr("PNG not supported: unknown PNG chunk type"); + } + _m3dstbi__skip(s, @as(c_int, @bitCast(c.length))); + break; + }, + } + break; + } + _ = _m3dstbi__get32be(s); + } + return 0; +} +pub fn _m3dstbi__do_png(arg_p: [*c]_m3dstbi__png, arg_x: [*c]c_int, arg_y: [*c]c_int, arg_n: [*c]c_int, arg_req_comp: c_int, arg_ri: [*c]_m3dstbi__result_info) callconv(.C) ?*anyopaque { + var p = arg_p; + _ = &p; + var x = arg_x; + _ = &x; + var y = arg_y; + _ = &y; + var n = arg_n; + _ = &n; + var req_comp = arg_req_comp; + _ = &req_comp; + var ri = arg_ri; + _ = &ri; + var result: ?*anyopaque = @as(?*anyopaque, @ptrFromInt(@as(c_int, 0))); + _ = &result; + if ((req_comp < @as(c_int, 0)) or (req_comp > @as(c_int, 4))) { + _ = _m3dstbi__errstr("Internal error"); + return @as(?*anyopaque, @ptrFromInt(@as(c_int, 0))); + } + if (_m3dstbi__parse_png_file(p, STBI__SCAN_load, req_comp) != 0) { + if (p.*.depth < @as(c_int, 8)) { + ri.*.bits_per_channel = 8; + } else { + ri.*.bits_per_channel = p.*.depth; + } + result = @as(?*anyopaque, @ptrCast(p.*.out)); + p.*.out = null; + if ((req_comp != 0) and (req_comp != p.*.s.*.img_out_n)) { + if (ri.*.bits_per_channel == @as(c_int, 8)) { + result = @as(?*anyopaque, @ptrCast(_m3dstbi__convert_format(@as([*c]u8, @ptrCast(@alignCast(result))), p.*.s.*.img_out_n, req_comp, p.*.s.*.img_x, p.*.s.*.img_y))); + } else { + result = @as(?*anyopaque, @ptrCast(_m3dstbi__convert_format16(@as([*c]_m3dstbi__uint16, @ptrCast(@alignCast(result))), p.*.s.*.img_out_n, req_comp, p.*.s.*.img_x, p.*.s.*.img_y))); + } + p.*.s.*.img_out_n = req_comp; + if (result == @as(?*anyopaque, @ptrFromInt(@as(c_int, 0)))) return result; + } + x.* = @as(c_int, @bitCast(p.*.s.*.img_x)); + y.* = @as(c_int, @bitCast(p.*.s.*.img_y)); + if (n != null) { + n.* = p.*.s.*.img_n; + } + } + free(@as(?*anyopaque, @ptrCast(p.*.out))); + p.*.out = null; + free(@as(?*anyopaque, @ptrCast(p.*.expanded))); + p.*.expanded = null; + free(@as(?*anyopaque, @ptrCast(p.*.idata))); + p.*.idata = null; + return result; +} +pub fn _m3dstbi__png_load(arg_s: [*c]_m3dstbi__context, arg_x: [*c]c_int, arg_y: [*c]c_int, arg_comp: [*c]c_int, arg_req_comp: c_int, arg_ri: [*c]_m3dstbi__result_info) callconv(.C) ?*anyopaque { + var s = arg_s; + _ = &s; + var x = arg_x; + _ = &x; + var y = arg_y; + _ = &y; + var comp = arg_comp; + _ = ∁ + var req_comp = arg_req_comp; + _ = &req_comp; + var ri = arg_ri; + _ = &ri; + var p: _m3dstbi__png = undefined; + _ = &p; + p.s = s; + return _m3dstbi__do_png(&p, x, y, comp, req_comp, ri); +} +pub extern fn _m3dstbi_zlib_compress(data: [*c]u8, data_len: c_int, out_len: [*c]c_int, quality: c_int) [*c]u8; +pub export fn _m3d_gettx(arg_model: [*c]m3d_t, arg_readfilecb: m3dread_t, arg_freecb: m3dfree_t, arg_fn: [*c]u8) M3D_INDEX { + var model = arg_model; + _ = &model; + var readfilecb = arg_readfilecb; + _ = &readfilecb; + var freecb = arg_freecb; + _ = &freecb; + var @"fn" = arg_fn; + _ = &@"fn"; + var i: c_uint = undefined; + _ = &i; + var len: c_uint = 0; + _ = &len; + var buff: [*c]u8 = null; + _ = &buff; + var fn2: [*c]u8 = undefined; + _ = &fn2; + var w: c_uint = undefined; + _ = &w; + var h: c_uint = undefined; + _ = &h; + var s: _m3dstbi__context = undefined; + _ = &s; + var ri: _m3dstbi__result_info = undefined; + _ = &ri; + if (!(@"fn" != null) or !(@"fn".* != 0)) return 4294967295; + { + i = 0; + while (i < model.*.numtexture) : (i +%= 1) if (!(strcmp(@"fn", model.*.texture[i].name) != 0)) return i; + } + if (model.*.inlined != null) { + { + i = 0; + while (i < model.*.numinlined) : (i +%= 1) if (!(strcmp(@"fn", model.*.inlined[i].name) != 0)) { + buff = model.*.inlined[i].data; + len = model.*.inlined[i].length; + freecb = null; + break; + }; + } + } + if (!(buff != null) and (readfilecb != null)) { + i = @as(c_uint, @bitCast(@as(c_uint, @truncate(strlen(@"fn"))))); + if ((i < @as(c_uint, @bitCast(@as(c_int, 5)))) or (@as(c_int, @bitCast(@as(c_uint, @"fn"[i -% @as(c_uint, @bitCast(@as(c_int, 4)))]))) != @as(c_int, '.'))) { + fn2 = @as([*c]u8, @ptrCast(@alignCast(malloc(@as(c_ulong, @bitCast(@as(c_ulong, i +% @as(c_uint, @bitCast(@as(c_int, 5)))))))))); + if (!(fn2 != null)) { + model.*.errcode = @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 1))))); + return 4294967295; + } + _ = memcpy(@as(?*anyopaque, @ptrCast(fn2)), @as(?*const anyopaque, @ptrCast(@"fn")), @as(c_ulong, @bitCast(@as(c_ulong, i)))); + _ = memcpy(@as(?*anyopaque, @ptrCast(fn2 + i)), @as(?*const anyopaque, @ptrCast(".png")), @as(c_ulong, @bitCast(@as(c_long, @as(c_int, 5))))); + buff = readfilecb.?(fn2, &len); + free(@as(?*anyopaque, @ptrCast(fn2))); + } + if (!(buff != null)) { + buff = readfilecb.?(@"fn", &len); + if (!(buff != null)) return 4294967295; + } + } + i = blk: { + const ref = &model.*.numtexture; + const tmp = ref.*; + ref.* +%= 1; + break :blk tmp; + }; + model.*.texture = @as([*c]m3dtx_t, @ptrCast(@alignCast(realloc(@as(?*anyopaque, @ptrCast(model.*.texture)), @as(c_ulong, @bitCast(@as(c_ulong, model.*.numtexture))) *% @sizeOf(m3dtx_t))))); + if (!(model.*.texture != null)) { + if ((buff != null) and (freecb != null)) { + freecb.?(@as(?*anyopaque, @ptrCast(buff))); + } + model.*.errcode = @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 1))))); + return 4294967295; + } + model.*.texture[i].name = @"fn"; + model.*.texture[i].w = blk: { + const tmp = @as(u16, @bitCast(@as(c_short, @truncate(@as(c_int, 0))))); + model.*.texture[i].h = tmp; + break :blk tmp; + }; + model.*.texture[i].d = null; + if (buff != null) { + if ((((@as(c_int, @bitCast(@as(c_uint, buff[@as(c_uint, @intCast(@as(c_int, 0)))]))) == @as(c_int, 137)) and (@as(c_int, @bitCast(@as(c_uint, buff[@as(c_uint, @intCast(@as(c_int, 1)))]))) == @as(c_int, 'P'))) and (@as(c_int, @bitCast(@as(c_uint, buff[@as(c_uint, @intCast(@as(c_int, 2)))]))) == @as(c_int, 'N'))) and (@as(c_int, @bitCast(@as(c_uint, buff[@as(c_uint, @intCast(@as(c_int, 3)))]))) == @as(c_int, 'G'))) { + s.read_from_callbacks = 0; + s.img_buffer = blk: { + const tmp = buff; + s.img_buffer_original = tmp; + break :blk tmp; + }; + s.img_buffer_end = blk: { + const tmp = buff + len; + s.img_buffer_original_end = tmp; + break :blk tmp; + }; + w = blk: { + const tmp = blk_1: { + const tmp_2 = @as(c_uint, @bitCast(@as(c_int, 0))); + len = tmp_2; + break :blk_1 tmp_2; + }; + h = tmp; + break :blk tmp; + }; + ri.bits_per_channel = 8; + model.*.texture[i].d = @as([*c]u8, @ptrCast(@alignCast(_m3dstbi__png_load(&s, @as([*c]c_int, @ptrCast(@alignCast(&w))), @as([*c]c_int, @ptrCast(@alignCast(&h))), @as([*c]c_int, @ptrCast(@alignCast(&len))), @as(c_int, 0), &ri)))); + model.*.texture[i].w = @as(u16, @bitCast(@as(c_ushort, @truncate(w)))); + model.*.texture[i].h = @as(u16, @bitCast(@as(c_ushort, @truncate(h)))); + model.*.texture[i].f = @as(u8, @bitCast(@as(u8, @truncate(len)))); + } else {} + if (freecb != null) { + freecb.?(@as(?*anyopaque, @ptrCast(buff))); + } + } + if (!(model.*.texture[i].d != null)) { + model.*.errcode = @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 68))))); + } + return i; +} +pub export fn _m3d_getpr(arg_model: [*c]m3d_t, arg_readfilecb: m3dread_t, arg_freecb: m3dfree_t, arg_fn: [*c]u8) void { + var model = arg_model; + _ = &model; + var readfilecb = arg_readfilecb; + _ = &readfilecb; + var freecb = arg_freecb; + _ = &freecb; + var @"fn" = arg_fn; + _ = &@"fn"; + _ = &readfilecb; + _ = &freecb; + _ = &@"fn"; + model.*.errcode = @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 65))))); +} +pub fn _m3d_getidx(arg_data: [*c]u8, arg_type: u8, arg_idx: [*c]M3D_INDEX) callconv(.C) [*c]u8 { + var data = arg_data; + _ = &data; + var @"type" = arg_type; + _ = &@"type"; + var idx = arg_idx; + _ = &idx; + while (true) { + switch (@as(c_int, @bitCast(@as(c_uint, @"type")))) { + @as(c_int, 1) => { + idx.* = @as(M3D_INDEX, @bitCast(if (@as(c_int, @bitCast(@as(c_uint, data[@as(c_uint, @intCast(@as(c_int, 0)))]))) > @as(c_int, 253)) @as(c_int, @bitCast(@as(c_int, @as(i8, @bitCast(data[@as(c_uint, @intCast(@as(c_int, 0)))]))))) else @as(c_int, @bitCast(@as(c_uint, data[@as(c_uint, @intCast(@as(c_int, 0)))]))))); + data += 1; + break; + }, + @as(c_int, 2) => { + idx.* = @as(M3D_INDEX, @bitCast(if (@as(c_int, @bitCast(@as(c_uint, @as([*c]u16, @ptrCast(@alignCast(data))).*))) > @as(c_int, 65533)) @as(c_int, @bitCast(@as(c_int, @as([*c]i16, @ptrCast(@alignCast(data))).*))) else @as(c_int, @bitCast(@as(c_uint, @as([*c]u16, @ptrCast(@alignCast(data))).*))))); + data += @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 2))))); + break; + }, + @as(c_int, 4) => { + idx.* = @as(M3D_INDEX, @bitCast(@as([*c]i32, @ptrCast(@alignCast(data))).*)); + data += @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 4))))); + break; + }, + else => {}, + } + break; + } + return data; +} +pub export fn _m3d_mul(arg_r: [*c]M3D_FLOAT, arg_a: [*c]M3D_FLOAT, arg_b: [*c]M3D_FLOAT) void { + var r = arg_r; + _ = &r; + var a = arg_a; + _ = &a; + var b = arg_b; + _ = &b; + r[@as(c_uint, @intCast(@as(c_int, 0)))] = (((b[@as(c_uint, @intCast(@as(c_int, 0)))] * a[@as(c_uint, @intCast(@as(c_int, 0)))]) + (b[@as(c_uint, @intCast(@as(c_int, 4)))] * a[@as(c_uint, @intCast(@as(c_int, 1)))])) + (b[@as(c_uint, @intCast(@as(c_int, 8)))] * a[@as(c_uint, @intCast(@as(c_int, 2)))])) + (b[@as(c_uint, @intCast(@as(c_int, 12)))] * a[@as(c_uint, @intCast(@as(c_int, 3)))]); + r[@as(c_uint, @intCast(@as(c_int, 1)))] = (((b[@as(c_uint, @intCast(@as(c_int, 1)))] * a[@as(c_uint, @intCast(@as(c_int, 0)))]) + (b[@as(c_uint, @intCast(@as(c_int, 5)))] * a[@as(c_uint, @intCast(@as(c_int, 1)))])) + (b[@as(c_uint, @intCast(@as(c_int, 9)))] * a[@as(c_uint, @intCast(@as(c_int, 2)))])) + (b[@as(c_uint, @intCast(@as(c_int, 13)))] * a[@as(c_uint, @intCast(@as(c_int, 3)))]); + r[@as(c_uint, @intCast(@as(c_int, 2)))] = (((b[@as(c_uint, @intCast(@as(c_int, 2)))] * a[@as(c_uint, @intCast(@as(c_int, 0)))]) + (b[@as(c_uint, @intCast(@as(c_int, 6)))] * a[@as(c_uint, @intCast(@as(c_int, 1)))])) + (b[@as(c_uint, @intCast(@as(c_int, 10)))] * a[@as(c_uint, @intCast(@as(c_int, 2)))])) + (b[@as(c_uint, @intCast(@as(c_int, 14)))] * a[@as(c_uint, @intCast(@as(c_int, 3)))]); + r[@as(c_uint, @intCast(@as(c_int, 3)))] = (((b[@as(c_uint, @intCast(@as(c_int, 3)))] * a[@as(c_uint, @intCast(@as(c_int, 0)))]) + (b[@as(c_uint, @intCast(@as(c_int, 7)))] * a[@as(c_uint, @intCast(@as(c_int, 1)))])) + (b[@as(c_uint, @intCast(@as(c_int, 11)))] * a[@as(c_uint, @intCast(@as(c_int, 2)))])) + (b[@as(c_uint, @intCast(@as(c_int, 15)))] * a[@as(c_uint, @intCast(@as(c_int, 3)))]); + r[@as(c_uint, @intCast(@as(c_int, 4)))] = (((b[@as(c_uint, @intCast(@as(c_int, 0)))] * a[@as(c_uint, @intCast(@as(c_int, 4)))]) + (b[@as(c_uint, @intCast(@as(c_int, 4)))] * a[@as(c_uint, @intCast(@as(c_int, 5)))])) + (b[@as(c_uint, @intCast(@as(c_int, 8)))] * a[@as(c_uint, @intCast(@as(c_int, 6)))])) + (b[@as(c_uint, @intCast(@as(c_int, 12)))] * a[@as(c_uint, @intCast(@as(c_int, 7)))]); + r[@as(c_uint, @intCast(@as(c_int, 5)))] = (((b[@as(c_uint, @intCast(@as(c_int, 1)))] * a[@as(c_uint, @intCast(@as(c_int, 4)))]) + (b[@as(c_uint, @intCast(@as(c_int, 5)))] * a[@as(c_uint, @intCast(@as(c_int, 5)))])) + (b[@as(c_uint, @intCast(@as(c_int, 9)))] * a[@as(c_uint, @intCast(@as(c_int, 6)))])) + (b[@as(c_uint, @intCast(@as(c_int, 13)))] * a[@as(c_uint, @intCast(@as(c_int, 7)))]); + r[@as(c_uint, @intCast(@as(c_int, 6)))] = (((b[@as(c_uint, @intCast(@as(c_int, 2)))] * a[@as(c_uint, @intCast(@as(c_int, 4)))]) + (b[@as(c_uint, @intCast(@as(c_int, 6)))] * a[@as(c_uint, @intCast(@as(c_int, 5)))])) + (b[@as(c_uint, @intCast(@as(c_int, 10)))] * a[@as(c_uint, @intCast(@as(c_int, 6)))])) + (b[@as(c_uint, @intCast(@as(c_int, 14)))] * a[@as(c_uint, @intCast(@as(c_int, 7)))]); + r[@as(c_uint, @intCast(@as(c_int, 7)))] = (((b[@as(c_uint, @intCast(@as(c_int, 3)))] * a[@as(c_uint, @intCast(@as(c_int, 4)))]) + (b[@as(c_uint, @intCast(@as(c_int, 7)))] * a[@as(c_uint, @intCast(@as(c_int, 5)))])) + (b[@as(c_uint, @intCast(@as(c_int, 11)))] * a[@as(c_uint, @intCast(@as(c_int, 6)))])) + (b[@as(c_uint, @intCast(@as(c_int, 15)))] * a[@as(c_uint, @intCast(@as(c_int, 7)))]); + r[@as(c_uint, @intCast(@as(c_int, 8)))] = (((b[@as(c_uint, @intCast(@as(c_int, 0)))] * a[@as(c_uint, @intCast(@as(c_int, 8)))]) + (b[@as(c_uint, @intCast(@as(c_int, 4)))] * a[@as(c_uint, @intCast(@as(c_int, 9)))])) + (b[@as(c_uint, @intCast(@as(c_int, 8)))] * a[@as(c_uint, @intCast(@as(c_int, 10)))])) + (b[@as(c_uint, @intCast(@as(c_int, 12)))] * a[@as(c_uint, @intCast(@as(c_int, 11)))]); + r[@as(c_uint, @intCast(@as(c_int, 9)))] = (((b[@as(c_uint, @intCast(@as(c_int, 1)))] * a[@as(c_uint, @intCast(@as(c_int, 8)))]) + (b[@as(c_uint, @intCast(@as(c_int, 5)))] * a[@as(c_uint, @intCast(@as(c_int, 9)))])) + (b[@as(c_uint, @intCast(@as(c_int, 9)))] * a[@as(c_uint, @intCast(@as(c_int, 10)))])) + (b[@as(c_uint, @intCast(@as(c_int, 13)))] * a[@as(c_uint, @intCast(@as(c_int, 11)))]); + r[@as(c_uint, @intCast(@as(c_int, 10)))] = (((b[@as(c_uint, @intCast(@as(c_int, 2)))] * a[@as(c_uint, @intCast(@as(c_int, 8)))]) + (b[@as(c_uint, @intCast(@as(c_int, 6)))] * a[@as(c_uint, @intCast(@as(c_int, 9)))])) + (b[@as(c_uint, @intCast(@as(c_int, 10)))] * a[@as(c_uint, @intCast(@as(c_int, 10)))])) + (b[@as(c_uint, @intCast(@as(c_int, 14)))] * a[@as(c_uint, @intCast(@as(c_int, 11)))]); + r[@as(c_uint, @intCast(@as(c_int, 11)))] = (((b[@as(c_uint, @intCast(@as(c_int, 3)))] * a[@as(c_uint, @intCast(@as(c_int, 8)))]) + (b[@as(c_uint, @intCast(@as(c_int, 7)))] * a[@as(c_uint, @intCast(@as(c_int, 9)))])) + (b[@as(c_uint, @intCast(@as(c_int, 11)))] * a[@as(c_uint, @intCast(@as(c_int, 10)))])) + (b[@as(c_uint, @intCast(@as(c_int, 15)))] * a[@as(c_uint, @intCast(@as(c_int, 11)))]); + r[@as(c_uint, @intCast(@as(c_int, 12)))] = (((b[@as(c_uint, @intCast(@as(c_int, 0)))] * a[@as(c_uint, @intCast(@as(c_int, 12)))]) + (b[@as(c_uint, @intCast(@as(c_int, 4)))] * a[@as(c_uint, @intCast(@as(c_int, 13)))])) + (b[@as(c_uint, @intCast(@as(c_int, 8)))] * a[@as(c_uint, @intCast(@as(c_int, 14)))])) + (b[@as(c_uint, @intCast(@as(c_int, 12)))] * a[@as(c_uint, @intCast(@as(c_int, 15)))]); + r[@as(c_uint, @intCast(@as(c_int, 13)))] = (((b[@as(c_uint, @intCast(@as(c_int, 1)))] * a[@as(c_uint, @intCast(@as(c_int, 12)))]) + (b[@as(c_uint, @intCast(@as(c_int, 5)))] * a[@as(c_uint, @intCast(@as(c_int, 13)))])) + (b[@as(c_uint, @intCast(@as(c_int, 9)))] * a[@as(c_uint, @intCast(@as(c_int, 14)))])) + (b[@as(c_uint, @intCast(@as(c_int, 13)))] * a[@as(c_uint, @intCast(@as(c_int, 15)))]); + r[@as(c_uint, @intCast(@as(c_int, 14)))] = (((b[@as(c_uint, @intCast(@as(c_int, 2)))] * a[@as(c_uint, @intCast(@as(c_int, 12)))]) + (b[@as(c_uint, @intCast(@as(c_int, 6)))] * a[@as(c_uint, @intCast(@as(c_int, 13)))])) + (b[@as(c_uint, @intCast(@as(c_int, 10)))] * a[@as(c_uint, @intCast(@as(c_int, 14)))])) + (b[@as(c_uint, @intCast(@as(c_int, 14)))] * a[@as(c_uint, @intCast(@as(c_int, 15)))]); + r[@as(c_uint, @intCast(@as(c_int, 15)))] = (((b[@as(c_uint, @intCast(@as(c_int, 3)))] * a[@as(c_uint, @intCast(@as(c_int, 12)))]) + (b[@as(c_uint, @intCast(@as(c_int, 7)))] * a[@as(c_uint, @intCast(@as(c_int, 13)))])) + (b[@as(c_uint, @intCast(@as(c_int, 11)))] * a[@as(c_uint, @intCast(@as(c_int, 14)))])) + (b[@as(c_uint, @intCast(@as(c_int, 15)))] * a[@as(c_uint, @intCast(@as(c_int, 15)))]); +} +pub export fn _m3d_inv(arg_m: [*c]M3D_FLOAT) void { + var m = arg_m; + _ = &m; + var r: [16]M3D_FLOAT = undefined; + _ = &r; + var det: M3D_FLOAT = (((((((((((((((((((((((((m[@as(c_uint, @intCast(@as(c_int, 0)))] * m[@as(c_uint, @intCast(@as(c_int, 5)))]) * m[@as(c_uint, @intCast(@as(c_int, 10)))]) * m[@as(c_uint, @intCast(@as(c_int, 15)))]) - (((m[@as(c_uint, @intCast(@as(c_int, 0)))] * m[@as(c_uint, @intCast(@as(c_int, 5)))]) * m[@as(c_uint, @intCast(@as(c_int, 11)))]) * m[@as(c_uint, @intCast(@as(c_int, 14)))])) + (((m[@as(c_uint, @intCast(@as(c_int, 0)))] * m[@as(c_uint, @intCast(@as(c_int, 6)))]) * m[@as(c_uint, @intCast(@as(c_int, 11)))]) * m[@as(c_uint, @intCast(@as(c_int, 13)))])) - (((m[@as(c_uint, @intCast(@as(c_int, 0)))] * m[@as(c_uint, @intCast(@as(c_int, 6)))]) * m[@as(c_uint, @intCast(@as(c_int, 9)))]) * m[@as(c_uint, @intCast(@as(c_int, 15)))])) + (((m[@as(c_uint, @intCast(@as(c_int, 0)))] * m[@as(c_uint, @intCast(@as(c_int, 7)))]) * m[@as(c_uint, @intCast(@as(c_int, 9)))]) * m[@as(c_uint, @intCast(@as(c_int, 14)))])) - (((m[@as(c_uint, @intCast(@as(c_int, 0)))] * m[@as(c_uint, @intCast(@as(c_int, 7)))]) * m[@as(c_uint, @intCast(@as(c_int, 10)))]) * m[@as(c_uint, @intCast(@as(c_int, 13)))])) - (((m[@as(c_uint, @intCast(@as(c_int, 1)))] * m[@as(c_uint, @intCast(@as(c_int, 6)))]) * m[@as(c_uint, @intCast(@as(c_int, 11)))]) * m[@as(c_uint, @intCast(@as(c_int, 12)))])) + (((m[@as(c_uint, @intCast(@as(c_int, 1)))] * m[@as(c_uint, @intCast(@as(c_int, 6)))]) * m[@as(c_uint, @intCast(@as(c_int, 8)))]) * m[@as(c_uint, @intCast(@as(c_int, 15)))])) - (((m[@as(c_uint, @intCast(@as(c_int, 1)))] * m[@as(c_uint, @intCast(@as(c_int, 7)))]) * m[@as(c_uint, @intCast(@as(c_int, 8)))]) * m[@as(c_uint, @intCast(@as(c_int, 14)))])) + (((m[@as(c_uint, @intCast(@as(c_int, 1)))] * m[@as(c_uint, @intCast(@as(c_int, 7)))]) * m[@as(c_uint, @intCast(@as(c_int, 10)))]) * m[@as(c_uint, @intCast(@as(c_int, 12)))])) - (((m[@as(c_uint, @intCast(@as(c_int, 1)))] * m[@as(c_uint, @intCast(@as(c_int, 4)))]) * m[@as(c_uint, @intCast(@as(c_int, 10)))]) * m[@as(c_uint, @intCast(@as(c_int, 15)))])) + (((m[@as(c_uint, @intCast(@as(c_int, 1)))] * m[@as(c_uint, @intCast(@as(c_int, 4)))]) * m[@as(c_uint, @intCast(@as(c_int, 11)))]) * m[@as(c_uint, @intCast(@as(c_int, 14)))])) + (((m[@as(c_uint, @intCast(@as(c_int, 2)))] * m[@as(c_uint, @intCast(@as(c_int, 7)))]) * m[@as(c_uint, @intCast(@as(c_int, 8)))]) * m[@as(c_uint, @intCast(@as(c_int, 13)))])) - (((m[@as(c_uint, @intCast(@as(c_int, 2)))] * m[@as(c_uint, @intCast(@as(c_int, 7)))]) * m[@as(c_uint, @intCast(@as(c_int, 9)))]) * m[@as(c_uint, @intCast(@as(c_int, 12)))])) + (((m[@as(c_uint, @intCast(@as(c_int, 2)))] * m[@as(c_uint, @intCast(@as(c_int, 4)))]) * m[@as(c_uint, @intCast(@as(c_int, 9)))]) * m[@as(c_uint, @intCast(@as(c_int, 15)))])) - (((m[@as(c_uint, @intCast(@as(c_int, 2)))] * m[@as(c_uint, @intCast(@as(c_int, 4)))]) * m[@as(c_uint, @intCast(@as(c_int, 11)))]) * m[@as(c_uint, @intCast(@as(c_int, 13)))])) + (((m[@as(c_uint, @intCast(@as(c_int, 2)))] * m[@as(c_uint, @intCast(@as(c_int, 5)))]) * m[@as(c_uint, @intCast(@as(c_int, 11)))]) * m[@as(c_uint, @intCast(@as(c_int, 12)))])) - (((m[@as(c_uint, @intCast(@as(c_int, 2)))] * m[@as(c_uint, @intCast(@as(c_int, 5)))]) * m[@as(c_uint, @intCast(@as(c_int, 8)))]) * m[@as(c_uint, @intCast(@as(c_int, 15)))])) - (((m[@as(c_uint, @intCast(@as(c_int, 3)))] * m[@as(c_uint, @intCast(@as(c_int, 4)))]) * m[@as(c_uint, @intCast(@as(c_int, 9)))]) * m[@as(c_uint, @intCast(@as(c_int, 14)))])) + (((m[@as(c_uint, @intCast(@as(c_int, 3)))] * m[@as(c_uint, @intCast(@as(c_int, 4)))]) * m[@as(c_uint, @intCast(@as(c_int, 10)))]) * m[@as(c_uint, @intCast(@as(c_int, 13)))])) - (((m[@as(c_uint, @intCast(@as(c_int, 3)))] * m[@as(c_uint, @intCast(@as(c_int, 5)))]) * m[@as(c_uint, @intCast(@as(c_int, 10)))]) * m[@as(c_uint, @intCast(@as(c_int, 12)))])) + (((m[@as(c_uint, @intCast(@as(c_int, 3)))] * m[@as(c_uint, @intCast(@as(c_int, 5)))]) * m[@as(c_uint, @intCast(@as(c_int, 8)))]) * m[@as(c_uint, @intCast(@as(c_int, 14)))])) - (((m[@as(c_uint, @intCast(@as(c_int, 3)))] * m[@as(c_uint, @intCast(@as(c_int, 6)))]) * m[@as(c_uint, @intCast(@as(c_int, 8)))]) * m[@as(c_uint, @intCast(@as(c_int, 13)))])) + (((m[@as(c_uint, @intCast(@as(c_int, 3)))] * m[@as(c_uint, @intCast(@as(c_int, 6)))]) * m[@as(c_uint, @intCast(@as(c_int, 9)))]) * m[@as(c_uint, @intCast(@as(c_int, 12)))]); + _ = &det; + if ((det == @as(M3D_FLOAT, @floatCast(0.0))) or (det == @as(M3D_FLOAT, @floatCast(-0.0)))) { + det = @as(M3D_FLOAT, @floatCast(1.0)); + } else { + det = @as(M3D_FLOAT, @floatCast(1.0)) / det; + } + r[@as(c_uint, @intCast(@as(c_int, 0)))] = det * (((m[@as(c_uint, @intCast(@as(c_int, 5)))] * ((m[@as(c_uint, @intCast(@as(c_int, 10)))] * m[@as(c_uint, @intCast(@as(c_int, 15)))]) - (m[@as(c_uint, @intCast(@as(c_int, 11)))] * m[@as(c_uint, @intCast(@as(c_int, 14)))]))) + (m[@as(c_uint, @intCast(@as(c_int, 6)))] * ((m[@as(c_uint, @intCast(@as(c_int, 11)))] * m[@as(c_uint, @intCast(@as(c_int, 13)))]) - (m[@as(c_uint, @intCast(@as(c_int, 9)))] * m[@as(c_uint, @intCast(@as(c_int, 15)))])))) + (m[@as(c_uint, @intCast(@as(c_int, 7)))] * ((m[@as(c_uint, @intCast(@as(c_int, 9)))] * m[@as(c_uint, @intCast(@as(c_int, 14)))]) - (m[@as(c_uint, @intCast(@as(c_int, 10)))] * m[@as(c_uint, @intCast(@as(c_int, 13)))])))); + r[@as(c_uint, @intCast(@as(c_int, 1)))] = -det * (((m[@as(c_uint, @intCast(@as(c_int, 1)))] * ((m[@as(c_uint, @intCast(@as(c_int, 10)))] * m[@as(c_uint, @intCast(@as(c_int, 15)))]) - (m[@as(c_uint, @intCast(@as(c_int, 11)))] * m[@as(c_uint, @intCast(@as(c_int, 14)))]))) + (m[@as(c_uint, @intCast(@as(c_int, 2)))] * ((m[@as(c_uint, @intCast(@as(c_int, 11)))] * m[@as(c_uint, @intCast(@as(c_int, 13)))]) - (m[@as(c_uint, @intCast(@as(c_int, 9)))] * m[@as(c_uint, @intCast(@as(c_int, 15)))])))) + (m[@as(c_uint, @intCast(@as(c_int, 3)))] * ((m[@as(c_uint, @intCast(@as(c_int, 9)))] * m[@as(c_uint, @intCast(@as(c_int, 14)))]) - (m[@as(c_uint, @intCast(@as(c_int, 10)))] * m[@as(c_uint, @intCast(@as(c_int, 13)))])))); + r[@as(c_uint, @intCast(@as(c_int, 2)))] = det * (((m[@as(c_uint, @intCast(@as(c_int, 1)))] * ((m[@as(c_uint, @intCast(@as(c_int, 6)))] * m[@as(c_uint, @intCast(@as(c_int, 15)))]) - (m[@as(c_uint, @intCast(@as(c_int, 7)))] * m[@as(c_uint, @intCast(@as(c_int, 14)))]))) + (m[@as(c_uint, @intCast(@as(c_int, 2)))] * ((m[@as(c_uint, @intCast(@as(c_int, 7)))] * m[@as(c_uint, @intCast(@as(c_int, 13)))]) - (m[@as(c_uint, @intCast(@as(c_int, 5)))] * m[@as(c_uint, @intCast(@as(c_int, 15)))])))) + (m[@as(c_uint, @intCast(@as(c_int, 3)))] * ((m[@as(c_uint, @intCast(@as(c_int, 5)))] * m[@as(c_uint, @intCast(@as(c_int, 14)))]) - (m[@as(c_uint, @intCast(@as(c_int, 6)))] * m[@as(c_uint, @intCast(@as(c_int, 13)))])))); + r[@as(c_uint, @intCast(@as(c_int, 3)))] = -det * (((m[@as(c_uint, @intCast(@as(c_int, 1)))] * ((m[@as(c_uint, @intCast(@as(c_int, 6)))] * m[@as(c_uint, @intCast(@as(c_int, 11)))]) - (m[@as(c_uint, @intCast(@as(c_int, 7)))] * m[@as(c_uint, @intCast(@as(c_int, 10)))]))) + (m[@as(c_uint, @intCast(@as(c_int, 2)))] * ((m[@as(c_uint, @intCast(@as(c_int, 7)))] * m[@as(c_uint, @intCast(@as(c_int, 9)))]) - (m[@as(c_uint, @intCast(@as(c_int, 5)))] * m[@as(c_uint, @intCast(@as(c_int, 11)))])))) + (m[@as(c_uint, @intCast(@as(c_int, 3)))] * ((m[@as(c_uint, @intCast(@as(c_int, 5)))] * m[@as(c_uint, @intCast(@as(c_int, 10)))]) - (m[@as(c_uint, @intCast(@as(c_int, 6)))] * m[@as(c_uint, @intCast(@as(c_int, 9)))])))); + r[@as(c_uint, @intCast(@as(c_int, 4)))] = -det * (((m[@as(c_uint, @intCast(@as(c_int, 4)))] * ((m[@as(c_uint, @intCast(@as(c_int, 10)))] * m[@as(c_uint, @intCast(@as(c_int, 15)))]) - (m[@as(c_uint, @intCast(@as(c_int, 11)))] * m[@as(c_uint, @intCast(@as(c_int, 14)))]))) + (m[@as(c_uint, @intCast(@as(c_int, 6)))] * ((m[@as(c_uint, @intCast(@as(c_int, 11)))] * m[@as(c_uint, @intCast(@as(c_int, 12)))]) - (m[@as(c_uint, @intCast(@as(c_int, 8)))] * m[@as(c_uint, @intCast(@as(c_int, 15)))])))) + (m[@as(c_uint, @intCast(@as(c_int, 7)))] * ((m[@as(c_uint, @intCast(@as(c_int, 8)))] * m[@as(c_uint, @intCast(@as(c_int, 14)))]) - (m[@as(c_uint, @intCast(@as(c_int, 10)))] * m[@as(c_uint, @intCast(@as(c_int, 12)))])))); + r[@as(c_uint, @intCast(@as(c_int, 5)))] = det * (((m[@as(c_uint, @intCast(@as(c_int, 0)))] * ((m[@as(c_uint, @intCast(@as(c_int, 10)))] * m[@as(c_uint, @intCast(@as(c_int, 15)))]) - (m[@as(c_uint, @intCast(@as(c_int, 11)))] * m[@as(c_uint, @intCast(@as(c_int, 14)))]))) + (m[@as(c_uint, @intCast(@as(c_int, 2)))] * ((m[@as(c_uint, @intCast(@as(c_int, 11)))] * m[@as(c_uint, @intCast(@as(c_int, 12)))]) - (m[@as(c_uint, @intCast(@as(c_int, 8)))] * m[@as(c_uint, @intCast(@as(c_int, 15)))])))) + (m[@as(c_uint, @intCast(@as(c_int, 3)))] * ((m[@as(c_uint, @intCast(@as(c_int, 8)))] * m[@as(c_uint, @intCast(@as(c_int, 14)))]) - (m[@as(c_uint, @intCast(@as(c_int, 10)))] * m[@as(c_uint, @intCast(@as(c_int, 12)))])))); + r[@as(c_uint, @intCast(@as(c_int, 6)))] = -det * (((m[@as(c_uint, @intCast(@as(c_int, 0)))] * ((m[@as(c_uint, @intCast(@as(c_int, 6)))] * m[@as(c_uint, @intCast(@as(c_int, 15)))]) - (m[@as(c_uint, @intCast(@as(c_int, 7)))] * m[@as(c_uint, @intCast(@as(c_int, 14)))]))) + (m[@as(c_uint, @intCast(@as(c_int, 2)))] * ((m[@as(c_uint, @intCast(@as(c_int, 7)))] * m[@as(c_uint, @intCast(@as(c_int, 12)))]) - (m[@as(c_uint, @intCast(@as(c_int, 4)))] * m[@as(c_uint, @intCast(@as(c_int, 15)))])))) + (m[@as(c_uint, @intCast(@as(c_int, 3)))] * ((m[@as(c_uint, @intCast(@as(c_int, 4)))] * m[@as(c_uint, @intCast(@as(c_int, 14)))]) - (m[@as(c_uint, @intCast(@as(c_int, 6)))] * m[@as(c_uint, @intCast(@as(c_int, 12)))])))); + r[@as(c_uint, @intCast(@as(c_int, 7)))] = det * (((m[@as(c_uint, @intCast(@as(c_int, 0)))] * ((m[@as(c_uint, @intCast(@as(c_int, 6)))] * m[@as(c_uint, @intCast(@as(c_int, 11)))]) - (m[@as(c_uint, @intCast(@as(c_int, 7)))] * m[@as(c_uint, @intCast(@as(c_int, 10)))]))) + (m[@as(c_uint, @intCast(@as(c_int, 2)))] * ((m[@as(c_uint, @intCast(@as(c_int, 7)))] * m[@as(c_uint, @intCast(@as(c_int, 8)))]) - (m[@as(c_uint, @intCast(@as(c_int, 4)))] * m[@as(c_uint, @intCast(@as(c_int, 11)))])))) + (m[@as(c_uint, @intCast(@as(c_int, 3)))] * ((m[@as(c_uint, @intCast(@as(c_int, 4)))] * m[@as(c_uint, @intCast(@as(c_int, 10)))]) - (m[@as(c_uint, @intCast(@as(c_int, 6)))] * m[@as(c_uint, @intCast(@as(c_int, 8)))])))); + r[@as(c_uint, @intCast(@as(c_int, 8)))] = det * (((m[@as(c_uint, @intCast(@as(c_int, 4)))] * ((m[@as(c_uint, @intCast(@as(c_int, 9)))] * m[@as(c_uint, @intCast(@as(c_int, 15)))]) - (m[@as(c_uint, @intCast(@as(c_int, 11)))] * m[@as(c_uint, @intCast(@as(c_int, 13)))]))) + (m[@as(c_uint, @intCast(@as(c_int, 5)))] * ((m[@as(c_uint, @intCast(@as(c_int, 11)))] * m[@as(c_uint, @intCast(@as(c_int, 12)))]) - (m[@as(c_uint, @intCast(@as(c_int, 8)))] * m[@as(c_uint, @intCast(@as(c_int, 15)))])))) + (m[@as(c_uint, @intCast(@as(c_int, 7)))] * ((m[@as(c_uint, @intCast(@as(c_int, 8)))] * m[@as(c_uint, @intCast(@as(c_int, 13)))]) - (m[@as(c_uint, @intCast(@as(c_int, 9)))] * m[@as(c_uint, @intCast(@as(c_int, 12)))])))); + r[@as(c_uint, @intCast(@as(c_int, 9)))] = -det * (((m[@as(c_uint, @intCast(@as(c_int, 0)))] * ((m[@as(c_uint, @intCast(@as(c_int, 9)))] * m[@as(c_uint, @intCast(@as(c_int, 15)))]) - (m[@as(c_uint, @intCast(@as(c_int, 11)))] * m[@as(c_uint, @intCast(@as(c_int, 13)))]))) + (m[@as(c_uint, @intCast(@as(c_int, 1)))] * ((m[@as(c_uint, @intCast(@as(c_int, 11)))] * m[@as(c_uint, @intCast(@as(c_int, 12)))]) - (m[@as(c_uint, @intCast(@as(c_int, 8)))] * m[@as(c_uint, @intCast(@as(c_int, 15)))])))) + (m[@as(c_uint, @intCast(@as(c_int, 3)))] * ((m[@as(c_uint, @intCast(@as(c_int, 8)))] * m[@as(c_uint, @intCast(@as(c_int, 13)))]) - (m[@as(c_uint, @intCast(@as(c_int, 9)))] * m[@as(c_uint, @intCast(@as(c_int, 12)))])))); + r[@as(c_uint, @intCast(@as(c_int, 10)))] = det * (((m[@as(c_uint, @intCast(@as(c_int, 0)))] * ((m[@as(c_uint, @intCast(@as(c_int, 5)))] * m[@as(c_uint, @intCast(@as(c_int, 15)))]) - (m[@as(c_uint, @intCast(@as(c_int, 7)))] * m[@as(c_uint, @intCast(@as(c_int, 13)))]))) + (m[@as(c_uint, @intCast(@as(c_int, 1)))] * ((m[@as(c_uint, @intCast(@as(c_int, 7)))] * m[@as(c_uint, @intCast(@as(c_int, 12)))]) - (m[@as(c_uint, @intCast(@as(c_int, 4)))] * m[@as(c_uint, @intCast(@as(c_int, 15)))])))) + (m[@as(c_uint, @intCast(@as(c_int, 3)))] * ((m[@as(c_uint, @intCast(@as(c_int, 4)))] * m[@as(c_uint, @intCast(@as(c_int, 13)))]) - (m[@as(c_uint, @intCast(@as(c_int, 5)))] * m[@as(c_uint, @intCast(@as(c_int, 12)))])))); + r[@as(c_uint, @intCast(@as(c_int, 11)))] = -det * (((m[@as(c_uint, @intCast(@as(c_int, 0)))] * ((m[@as(c_uint, @intCast(@as(c_int, 5)))] * m[@as(c_uint, @intCast(@as(c_int, 11)))]) - (m[@as(c_uint, @intCast(@as(c_int, 7)))] * m[@as(c_uint, @intCast(@as(c_int, 9)))]))) + (m[@as(c_uint, @intCast(@as(c_int, 1)))] * ((m[@as(c_uint, @intCast(@as(c_int, 7)))] * m[@as(c_uint, @intCast(@as(c_int, 8)))]) - (m[@as(c_uint, @intCast(@as(c_int, 4)))] * m[@as(c_uint, @intCast(@as(c_int, 11)))])))) + (m[@as(c_uint, @intCast(@as(c_int, 3)))] * ((m[@as(c_uint, @intCast(@as(c_int, 4)))] * m[@as(c_uint, @intCast(@as(c_int, 9)))]) - (m[@as(c_uint, @intCast(@as(c_int, 5)))] * m[@as(c_uint, @intCast(@as(c_int, 8)))])))); + r[@as(c_uint, @intCast(@as(c_int, 12)))] = -det * (((m[@as(c_uint, @intCast(@as(c_int, 4)))] * ((m[@as(c_uint, @intCast(@as(c_int, 9)))] * m[@as(c_uint, @intCast(@as(c_int, 14)))]) - (m[@as(c_uint, @intCast(@as(c_int, 10)))] * m[@as(c_uint, @intCast(@as(c_int, 13)))]))) + (m[@as(c_uint, @intCast(@as(c_int, 5)))] * ((m[@as(c_uint, @intCast(@as(c_int, 10)))] * m[@as(c_uint, @intCast(@as(c_int, 12)))]) - (m[@as(c_uint, @intCast(@as(c_int, 8)))] * m[@as(c_uint, @intCast(@as(c_int, 14)))])))) + (m[@as(c_uint, @intCast(@as(c_int, 6)))] * ((m[@as(c_uint, @intCast(@as(c_int, 8)))] * m[@as(c_uint, @intCast(@as(c_int, 13)))]) - (m[@as(c_uint, @intCast(@as(c_int, 9)))] * m[@as(c_uint, @intCast(@as(c_int, 12)))])))); + r[@as(c_uint, @intCast(@as(c_int, 13)))] = det * (((m[@as(c_uint, @intCast(@as(c_int, 0)))] * ((m[@as(c_uint, @intCast(@as(c_int, 9)))] * m[@as(c_uint, @intCast(@as(c_int, 14)))]) - (m[@as(c_uint, @intCast(@as(c_int, 10)))] * m[@as(c_uint, @intCast(@as(c_int, 13)))]))) + (m[@as(c_uint, @intCast(@as(c_int, 1)))] * ((m[@as(c_uint, @intCast(@as(c_int, 10)))] * m[@as(c_uint, @intCast(@as(c_int, 12)))]) - (m[@as(c_uint, @intCast(@as(c_int, 8)))] * m[@as(c_uint, @intCast(@as(c_int, 14)))])))) + (m[@as(c_uint, @intCast(@as(c_int, 2)))] * ((m[@as(c_uint, @intCast(@as(c_int, 8)))] * m[@as(c_uint, @intCast(@as(c_int, 13)))]) - (m[@as(c_uint, @intCast(@as(c_int, 9)))] * m[@as(c_uint, @intCast(@as(c_int, 12)))])))); + r[@as(c_uint, @intCast(@as(c_int, 14)))] = -det * (((m[@as(c_uint, @intCast(@as(c_int, 0)))] * ((m[@as(c_uint, @intCast(@as(c_int, 5)))] * m[@as(c_uint, @intCast(@as(c_int, 14)))]) - (m[@as(c_uint, @intCast(@as(c_int, 6)))] * m[@as(c_uint, @intCast(@as(c_int, 13)))]))) + (m[@as(c_uint, @intCast(@as(c_int, 1)))] * ((m[@as(c_uint, @intCast(@as(c_int, 6)))] * m[@as(c_uint, @intCast(@as(c_int, 12)))]) - (m[@as(c_uint, @intCast(@as(c_int, 4)))] * m[@as(c_uint, @intCast(@as(c_int, 14)))])))) + (m[@as(c_uint, @intCast(@as(c_int, 2)))] * ((m[@as(c_uint, @intCast(@as(c_int, 4)))] * m[@as(c_uint, @intCast(@as(c_int, 13)))]) - (m[@as(c_uint, @intCast(@as(c_int, 5)))] * m[@as(c_uint, @intCast(@as(c_int, 12)))])))); + r[@as(c_uint, @intCast(@as(c_int, 15)))] = det * (((m[@as(c_uint, @intCast(@as(c_int, 0)))] * ((m[@as(c_uint, @intCast(@as(c_int, 5)))] * m[@as(c_uint, @intCast(@as(c_int, 10)))]) - (m[@as(c_uint, @intCast(@as(c_int, 6)))] * m[@as(c_uint, @intCast(@as(c_int, 9)))]))) + (m[@as(c_uint, @intCast(@as(c_int, 1)))] * ((m[@as(c_uint, @intCast(@as(c_int, 6)))] * m[@as(c_uint, @intCast(@as(c_int, 8)))]) - (m[@as(c_uint, @intCast(@as(c_int, 4)))] * m[@as(c_uint, @intCast(@as(c_int, 10)))])))) + (m[@as(c_uint, @intCast(@as(c_int, 2)))] * ((m[@as(c_uint, @intCast(@as(c_int, 4)))] * m[@as(c_uint, @intCast(@as(c_int, 9)))]) - (m[@as(c_uint, @intCast(@as(c_int, 5)))] * m[@as(c_uint, @intCast(@as(c_int, 8)))])))); + _ = memcpy(@as(?*anyopaque, @ptrCast(m)), @as(?*const anyopaque, @ptrCast(&r)), @sizeOf([16]M3D_FLOAT)); +} +pub export fn _m3d_mat(arg_r: [*c]M3D_FLOAT, arg_p: [*c]m3dv_t, arg_q: [*c]m3dv_t) void { + var r = arg_r; + _ = &r; + var p = arg_p; + _ = &p; + var q = arg_q; + _ = &q; + if (((((q.*.x == @as(M3D_FLOAT, @floatCast(0.0))) and (q.*.y == @as(M3D_FLOAT, @floatCast(0.0)))) and (q.*.z >= @as(M3D_FLOAT, @floatCast(0.7071065)))) and (q.*.z <= @as(M3D_FLOAT, @floatCast(0.7071075)))) and (q.*.w == @as(M3D_FLOAT, @floatCast(0.0)))) { + r[@as(c_uint, @intCast(@as(c_int, 1)))] = blk: { + const tmp = blk_1: { + const tmp_2 = blk_2: { + const tmp_3 = blk_3: { + const tmp_4 = blk_4: { + const tmp_5 = @as(M3D_FLOAT, @floatCast(0.0)); + r[@as(c_uint, @intCast(@as(c_int, 9)))] = tmp_5; + break :blk_4 tmp_5; + }; + r[@as(c_uint, @intCast(@as(c_int, 8)))] = tmp_4; + break :blk_3 tmp_4; + }; + r[@as(c_uint, @intCast(@as(c_int, 6)))] = tmp_3; + break :blk_2 tmp_3; + }; + r[@as(c_uint, @intCast(@as(c_int, 4)))] = tmp_2; + break :blk_1 tmp_2; + }; + r[@as(c_uint, @intCast(@as(c_int, 2)))] = tmp; + break :blk tmp; + }; + r[@as(c_uint, @intCast(@as(c_int, 0)))] = blk: { + const tmp = blk_1: { + const tmp_2 = @as(M3D_FLOAT, @floatCast(-1.0)); + r[@as(c_uint, @intCast(@as(c_int, 10)))] = tmp_2; + break :blk_1 tmp_2; + }; + r[@as(c_uint, @intCast(@as(c_int, 5)))] = tmp; + break :blk tmp; + }; + } else { + r[@as(c_uint, @intCast(@as(c_int, 0)))] = @as(M3D_FLOAT, @floatFromInt(@as(c_int, 1))) - (@as(M3D_FLOAT, @floatFromInt(@as(c_int, 2))) * ((q.*.y * q.*.y) + (q.*.z * q.*.z))); + if ((r[@as(c_uint, @intCast(@as(c_int, 0)))] > -@as(M3D_FLOAT, @floatCast(0.0000001))) and (r[@as(c_uint, @intCast(@as(c_int, 0)))] < @as(M3D_FLOAT, @floatCast(0.0000001)))) { + r[@as(c_uint, @intCast(@as(c_int, 0)))] = @as(M3D_FLOAT, @floatCast(0.0)); + } + r[@as(c_uint, @intCast(@as(c_int, 1)))] = @as(M3D_FLOAT, @floatFromInt(@as(c_int, 2))) * ((q.*.x * q.*.y) - (q.*.z * q.*.w)); + if ((r[@as(c_uint, @intCast(@as(c_int, 1)))] > -@as(M3D_FLOAT, @floatCast(0.0000001))) and (r[@as(c_uint, @intCast(@as(c_int, 1)))] < @as(M3D_FLOAT, @floatCast(0.0000001)))) { + r[@as(c_uint, @intCast(@as(c_int, 1)))] = @as(M3D_FLOAT, @floatCast(0.0)); + } + r[@as(c_uint, @intCast(@as(c_int, 2)))] = @as(M3D_FLOAT, @floatFromInt(@as(c_int, 2))) * ((q.*.x * q.*.z) + (q.*.y * q.*.w)); + if ((r[@as(c_uint, @intCast(@as(c_int, 2)))] > -@as(M3D_FLOAT, @floatCast(0.0000001))) and (r[@as(c_uint, @intCast(@as(c_int, 2)))] < @as(M3D_FLOAT, @floatCast(0.0000001)))) { + r[@as(c_uint, @intCast(@as(c_int, 2)))] = @as(M3D_FLOAT, @floatCast(0.0)); + } + r[@as(c_uint, @intCast(@as(c_int, 4)))] = @as(M3D_FLOAT, @floatFromInt(@as(c_int, 2))) * ((q.*.x * q.*.y) + (q.*.z * q.*.w)); + if ((r[@as(c_uint, @intCast(@as(c_int, 4)))] > -@as(M3D_FLOAT, @floatCast(0.0000001))) and (r[@as(c_uint, @intCast(@as(c_int, 4)))] < @as(M3D_FLOAT, @floatCast(0.0000001)))) { + r[@as(c_uint, @intCast(@as(c_int, 4)))] = @as(M3D_FLOAT, @floatCast(0.0)); + } + r[@as(c_uint, @intCast(@as(c_int, 5)))] = @as(M3D_FLOAT, @floatFromInt(@as(c_int, 1))) - (@as(M3D_FLOAT, @floatFromInt(@as(c_int, 2))) * ((q.*.x * q.*.x) + (q.*.z * q.*.z))); + if ((r[@as(c_uint, @intCast(@as(c_int, 5)))] > -@as(M3D_FLOAT, @floatCast(0.0000001))) and (r[@as(c_uint, @intCast(@as(c_int, 5)))] < @as(M3D_FLOAT, @floatCast(0.0000001)))) { + r[@as(c_uint, @intCast(@as(c_int, 5)))] = @as(M3D_FLOAT, @floatCast(0.0)); + } + r[@as(c_uint, @intCast(@as(c_int, 6)))] = @as(M3D_FLOAT, @floatFromInt(@as(c_int, 2))) * ((q.*.y * q.*.z) - (q.*.x * q.*.w)); + if ((r[@as(c_uint, @intCast(@as(c_int, 6)))] > -@as(M3D_FLOAT, @floatCast(0.0000001))) and (r[@as(c_uint, @intCast(@as(c_int, 6)))] < @as(M3D_FLOAT, @floatCast(0.0000001)))) { + r[@as(c_uint, @intCast(@as(c_int, 6)))] = @as(M3D_FLOAT, @floatCast(0.0)); + } + r[@as(c_uint, @intCast(@as(c_int, 8)))] = @as(M3D_FLOAT, @floatFromInt(@as(c_int, 2))) * ((q.*.x * q.*.z) - (q.*.y * q.*.w)); + if ((r[@as(c_uint, @intCast(@as(c_int, 8)))] > -@as(M3D_FLOAT, @floatCast(0.0000001))) and (r[@as(c_uint, @intCast(@as(c_int, 8)))] < @as(M3D_FLOAT, @floatCast(0.0000001)))) { + r[@as(c_uint, @intCast(@as(c_int, 8)))] = @as(M3D_FLOAT, @floatCast(0.0)); + } + r[@as(c_uint, @intCast(@as(c_int, 9)))] = @as(M3D_FLOAT, @floatFromInt(@as(c_int, 2))) * ((q.*.y * q.*.z) + (q.*.x * q.*.w)); + if ((r[@as(c_uint, @intCast(@as(c_int, 9)))] > -@as(M3D_FLOAT, @floatCast(0.0000001))) and (r[@as(c_uint, @intCast(@as(c_int, 9)))] < @as(M3D_FLOAT, @floatCast(0.0000001)))) { + r[@as(c_uint, @intCast(@as(c_int, 9)))] = @as(M3D_FLOAT, @floatCast(0.0)); + } + r[@as(c_uint, @intCast(@as(c_int, 10)))] = @as(M3D_FLOAT, @floatFromInt(@as(c_int, 1))) - (@as(M3D_FLOAT, @floatFromInt(@as(c_int, 2))) * ((q.*.x * q.*.x) + (q.*.y * q.*.y))); + if ((r[@as(c_uint, @intCast(@as(c_int, 10)))] > -@as(M3D_FLOAT, @floatCast(0.0000001))) and (r[@as(c_uint, @intCast(@as(c_int, 10)))] < @as(M3D_FLOAT, @floatCast(0.0000001)))) { + r[@as(c_uint, @intCast(@as(c_int, 10)))] = @as(M3D_FLOAT, @floatCast(0.0)); + } + } + r[@as(c_uint, @intCast(@as(c_int, 3)))] = p.*.x; + r[@as(c_uint, @intCast(@as(c_int, 7)))] = p.*.y; + r[@as(c_uint, @intCast(@as(c_int, 11)))] = p.*.z; + r[@as(c_uint, @intCast(@as(c_int, 12)))] = 0; + r[@as(c_uint, @intCast(@as(c_int, 13)))] = 0; + r[@as(c_uint, @intCast(@as(c_int, 14)))] = 0; + r[@as(c_uint, @intCast(@as(c_int, 15)))] = 1; +} +pub fn _m3d_rsq(arg_x: M3D_FLOAT) callconv(.C) M3D_FLOAT { + var x = arg_x; + _ = &x; + var x2: f32 = x * 0.5; + _ = &x2; + var i: [*c]u32 = @as([*c]u32, @ptrCast(@alignCast(&x))); + _ = &i; + i.* = @as(u32, @bitCast(@as(c_int, 1597463007))) -% (i.* >> @intCast(1)); + return x * (1.5 - ((x2 * x) * x)); +} +pub export fn par_shapes_free_mesh(arg_mesh: [*c]par_shapes_mesh) void { + var mesh = arg_mesh; + _ = &mesh; + free(@as(?*anyopaque, @ptrCast(mesh.*.points))); + free(@as(?*anyopaque, @ptrCast(mesh.*.triangles))); + free(@as(?*anyopaque, @ptrCast(mesh.*.normals))); + free(@as(?*anyopaque, @ptrCast(mesh.*.tcoords))); + free(@as(?*anyopaque, @ptrCast(mesh))); +} +pub export fn par_shapes_create_cylinder(arg_slices: c_int, arg_stacks: c_int) [*c]par_shapes_mesh { + var slices = arg_slices; + _ = &slices; + var stacks = arg_stacks; + _ = &stacks; + if ((slices < @as(c_int, 3)) or (stacks < @as(c_int, 1))) { + return null; + } + return par_shapes_create_parametric(&par_shapes__cylinder, slices, stacks, null); +} +pub export fn par_shapes_create_cone(arg_slices: c_int, arg_stacks: c_int) [*c]par_shapes_mesh { + var slices = arg_slices; + _ = &slices; + var stacks = arg_stacks; + _ = &stacks; + if ((slices < @as(c_int, 3)) or (stacks < @as(c_int, 1))) { + return null; + } + return par_shapes_create_parametric(&par_shapes__cone, slices, stacks, null); +} +pub export fn par_shapes_create_parametric_disk(arg_slices: c_int, arg_stacks: c_int) [*c]par_shapes_mesh { + var slices = arg_slices; + _ = &slices; + var stacks = arg_stacks; + _ = &stacks; + var m: [*c]par_shapes_mesh = par_shapes_create_cone(slices, stacks); + _ = &m; + if (m != null) { + par_shapes_scale(m, 1.0, 1.0, 0.0); + } + return m; +} +pub export fn par_shapes_create_torus(arg_slices: c_int, arg_stacks: c_int, arg_radius: f32) [*c]par_shapes_mesh { + var slices = arg_slices; + _ = &slices; + var stacks = arg_stacks; + _ = &stacks; + var radius = arg_radius; + _ = &radius; + if ((slices < @as(c_int, 3)) or (stacks < @as(c_int, 3))) { + return null; + } + _ = blk: { + _ = @sizeOf(c_int); + break :blk blk_1: { + break :blk_1 if ((@as(f64, @floatCast(radius)) <= 1.0) and (@intFromPtr("Use smaller radius to avoid self-intersection.") != 0)) {} else { + __assert_fail("radius <= 1.0 && \"Use smaller radius to avoid self-intersection.\"", "./external/par_shapes.h", @as(c_uint, @bitCast(@as(c_int, 395))), "par_shapes_mesh *par_shapes_create_torus(int, int, float)"); + }; + }; + }; + _ = blk: { + _ = @sizeOf(c_int); + break :blk blk_1: { + break :blk_1 if ((@as(f64, @floatCast(radius)) >= 0.1) and (@intFromPtr("Use larger radius to avoid self-intersection.") != 0)) {} else { + __assert_fail("radius >= 0.1 && \"Use larger radius to avoid self-intersection.\"", "./external/par_shapes.h", @as(c_uint, @bitCast(@as(c_int, 396))), "par_shapes_mesh *par_shapes_create_torus(int, int, float)"); + }; + }; + }; + var userdata: ?*anyopaque = @as(?*anyopaque, @ptrCast(&radius)); + _ = &userdata; + return par_shapes_create_parametric(&par_shapes__torus, slices, stacks, userdata); +} +pub export fn par_shapes_create_parametric_sphere(arg_slices: c_int, arg_stacks: c_int) [*c]par_shapes_mesh { + var slices = arg_slices; + _ = &slices; + var stacks = arg_stacks; + _ = &stacks; + if ((slices < @as(c_int, 3)) or (stacks < @as(c_int, 3))) { + return null; + } + var m: [*c]par_shapes_mesh = par_shapes_create_parametric(&par_shapes__sphere, slices, stacks, null); + _ = &m; + par_shapes_remove_degenerate(m, par_shapes__epsilon_degenerate_sphere); + return m; +} +pub export fn par_shapes_create_subdivided_sphere(arg_nsubd: c_int) [*c]par_shapes_mesh { + var nsubd = arg_nsubd; + _ = &nsubd; + var mesh: [*c]par_shapes_mesh = par_shapes_create_icosahedron(); + _ = &mesh; + par_shapes_unweld(mesh, @as(c_int, 0) != 0); + free(@as(?*anyopaque, @ptrCast(mesh.*.triangles))); + mesh.*.triangles = null; + while ((blk: { + const ref = &nsubd; + const tmp = ref.*; + ref.* -= 1; + break :blk tmp; + }) != 0) { + par_shapes__subdivide(mesh); + } + { + var i: c_int = 0; + _ = &i; + while (i < mesh.*.npoints) : (i += 1) { + par_shapes__normalize3(mesh.*.points + @as(usize, @bitCast(@as(isize, @intCast(i * @as(c_int, 3)))))); + } + } + mesh.*.triangles = @as([*c]u16, @ptrCast(@alignCast(malloc(@as(c_ulong, @bitCast(@as(c_long, @as(c_int, 3) * mesh.*.ntriangles))) *% @sizeOf(u16))))); + { + var i: c_int = 0; + _ = &i; + while (i < (mesh.*.ntriangles * @as(c_int, 3))) : (i += 1) { + (blk: { + const tmp = i; + if (tmp >= 0) break :blk mesh.*.triangles + @as(usize, @intCast(tmp)) else break :blk mesh.*.triangles - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = @as(u16, @bitCast(@as(c_short, @truncate(i)))); + } + } + var tmp: [*c]par_shapes_mesh = mesh; + _ = &tmp; + mesh = par_shapes_weld(mesh, @as(f32, @floatCast(0.01)), null); + par_shapes_free_mesh(tmp); + par_shapes_compute_normals(mesh); + return mesh; +} +pub export fn par_shapes_create_klein_bottle(arg_slices: c_int, arg_stacks: c_int) [*c]par_shapes_mesh { + var slices = arg_slices; + _ = &slices; + var stacks = arg_stacks; + _ = &stacks; + if ((slices < @as(c_int, 3)) or (stacks < @as(c_int, 3))) { + return null; + } + var mesh: [*c]par_shapes_mesh = par_shapes_create_parametric(&par_shapes__klein, slices, stacks, null); + _ = &mesh; + var face: c_int = 0; + _ = &face; + { + var stack: c_int = 0; + _ = &stack; + while (stack < stacks) : (stack += 1) { + { + var slice: c_int = 0; + _ = &slice; + while (slice < slices) : (_ = blk: { + slice += 1; + break :blk blk_1: { + const ref = &face; + ref.* += @as(c_int, 2); + break :blk_1 ref.*; + }; + }) { + if (stack < @divTrunc(@as(c_int, 27) * stacks, @as(c_int, 32))) { + par_shapes_invert(mesh, face, @as(c_int, 2)); + } + } + } + } + } + par_shapes__compute_welded_normals(mesh); + return mesh; +} +pub export fn par_shapes_create_trefoil_knot(arg_slices: c_int, arg_stacks: c_int, arg_radius: f32) [*c]par_shapes_mesh { + var slices = arg_slices; + _ = &slices; + var stacks = arg_stacks; + _ = &stacks; + var radius = arg_radius; + _ = &radius; + if ((slices < @as(c_int, 3)) or (stacks < @as(c_int, 3))) { + return null; + } + _ = blk: { + _ = @sizeOf(c_int); + break :blk blk_1: { + break :blk_1 if ((@as(f64, @floatCast(radius)) <= 3.0) and (@intFromPtr("Use smaller radius to avoid self-intersection.") != 0)) {} else { + __assert_fail("radius <= 3.0 && \"Use smaller radius to avoid self-intersection.\"", "./external/par_shapes.h", @as(c_uint, @bitCast(@as(c_int, 427))), "par_shapes_mesh *par_shapes_create_trefoil_knot(int, int, float)"); + }; + }; + }; + _ = blk: { + _ = @sizeOf(c_int); + break :blk blk_1: { + break :blk_1 if ((@as(f64, @floatCast(radius)) >= 0.5) and (@intFromPtr("Use larger radius to avoid self-intersection.") != 0)) {} else { + __assert_fail("radius >= 0.5 && \"Use larger radius to avoid self-intersection.\"", "./external/par_shapes.h", @as(c_uint, @bitCast(@as(c_int, 428))), "par_shapes_mesh *par_shapes_create_trefoil_knot(int, int, float)"); + }; + }; + }; + var userdata: ?*anyopaque = @as(?*anyopaque, @ptrCast(&radius)); + _ = &userdata; + return par_shapes_create_parametric(&par_shapes__trefoil, slices, stacks, userdata); +} +pub export fn par_shapes_create_hemisphere(arg_slices: c_int, arg_stacks: c_int) [*c]par_shapes_mesh { + var slices = arg_slices; + _ = &slices; + var stacks = arg_stacks; + _ = &stacks; + if ((slices < @as(c_int, 3)) or (stacks < @as(c_int, 3))) { + return null; + } + var m: [*c]par_shapes_mesh = par_shapes_create_parametric(&par_shapes__hemisphere, slices, stacks, null); + _ = &m; + par_shapes_remove_degenerate(m, par_shapes__epsilon_degenerate_sphere); + return m; +} +pub export fn par_shapes_create_plane(arg_slices: c_int, arg_stacks: c_int) [*c]par_shapes_mesh { + var slices = arg_slices; + _ = &slices; + var stacks = arg_stacks; + _ = &stacks; + if ((slices < @as(c_int, 1)) or (stacks < @as(c_int, 1))) { + return null; + } + return par_shapes_create_parametric(&par_shapes__plane, slices, stacks, null); +} +pub const par_shapes_fn = ?*const fn ([*c]const f32, [*c]f32, ?*anyopaque) callconv(.C) void; +pub export fn par_shapes_create_parametric(arg_fn: par_shapes_fn, arg_slices: c_int, arg_stacks: c_int, arg_userdata: ?*anyopaque) [*c]par_shapes_mesh { + var @"fn" = arg_fn; + _ = &@"fn"; + var slices = arg_slices; + _ = &slices; + var stacks = arg_stacks; + _ = &stacks; + var userdata = arg_userdata; + _ = &userdata; + var mesh: [*c]par_shapes_mesh = @as([*c]par_shapes_mesh, @ptrCast(@alignCast(calloc(@as(c_ulong, @bitCast(@as(c_long, @as(c_int, 1)))) *% @sizeOf(par_shapes_mesh), @as(c_ulong, @bitCast(@as(c_long, @as(c_int, 1)))))))); + _ = &mesh; + mesh.*.npoints = (slices + @as(c_int, 1)) * (stacks + @as(c_int, 1)); + mesh.*.points = @as([*c]f32, @ptrCast(@alignCast(calloc(@as(c_ulong, @bitCast(@as(c_long, @as(c_int, 3) * mesh.*.npoints))) *% @sizeOf(f32), @as(c_ulong, @bitCast(@as(c_long, @as(c_int, 1)))))))); + var uv: [2]f32 = undefined; + _ = &uv; + var xyz: [3]f32 = undefined; + _ = &xyz; + var points: [*c]f32 = mesh.*.points; + _ = &points; + { + var stack: c_int = 0; + _ = &stack; + while (stack < (stacks + @as(c_int, 1))) : (stack += 1) { + uv[@as(c_uint, @intCast(@as(c_int, 0)))] = @as(f32, @floatFromInt(stack)) / @as(f32, @floatFromInt(stacks)); + { + var slice: c_int = 0; + _ = &slice; + while (slice < (slices + @as(c_int, 1))) : (slice += 1) { + uv[@as(c_uint, @intCast(@as(c_int, 1)))] = @as(f32, @floatFromInt(slice)) / @as(f32, @floatFromInt(slices)); + @"fn".?(@as([*c]f32, @ptrCast(@alignCast(&uv))), @as([*c]f32, @ptrCast(@alignCast(&xyz))), userdata); + (blk: { + const ref = &points; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = xyz[@as(c_uint, @intCast(@as(c_int, 0)))]; + (blk: { + const ref = &points; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = xyz[@as(c_uint, @intCast(@as(c_int, 1)))]; + (blk: { + const ref = &points; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = xyz[@as(c_uint, @intCast(@as(c_int, 2)))]; + } + } + } + } + mesh.*.tcoords = @as([*c]f32, @ptrCast(@alignCast(calloc(@as(c_ulong, @bitCast(@as(c_long, @as(c_int, 2) * mesh.*.npoints))) *% @sizeOf(f32), @as(c_ulong, @bitCast(@as(c_long, @as(c_int, 1)))))))); + var uvs: [*c]f32 = mesh.*.tcoords; + _ = &uvs; + { + var stack: c_int = 0; + _ = &stack; + while (stack < (stacks + @as(c_int, 1))) : (stack += 1) { + uv[@as(c_uint, @intCast(@as(c_int, 0)))] = @as(f32, @floatFromInt(stack)) / @as(f32, @floatFromInt(stacks)); + { + var slice: c_int = 0; + _ = &slice; + while (slice < (slices + @as(c_int, 1))) : (slice += 1) { + uv[@as(c_uint, @intCast(@as(c_int, 1)))] = @as(f32, @floatFromInt(slice)) / @as(f32, @floatFromInt(slices)); + (blk: { + const ref = &uvs; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = uv[@as(c_uint, @intCast(@as(c_int, 0)))]; + (blk: { + const ref = &uvs; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = uv[@as(c_uint, @intCast(@as(c_int, 1)))]; + } + } + } + } + mesh.*.ntriangles = (@as(c_int, 2) * slices) * stacks; + mesh.*.triangles = @as([*c]u16, @ptrCast(@alignCast(calloc(@as(c_ulong, @bitCast(@as(c_long, @as(c_int, 3) * mesh.*.ntriangles))) *% @sizeOf(u16), @as(c_ulong, @bitCast(@as(c_long, @as(c_int, 1)))))))); + var v: c_int = 0; + _ = &v; + var face: [*c]u16 = mesh.*.triangles; + _ = &face; + { + var stack: c_int = 0; + _ = &stack; + while (stack < stacks) : (stack += 1) { + { + var slice: c_int = 0; + _ = &slice; + while (slice < slices) : (slice += 1) { + var next: c_int = slice + @as(c_int, 1); + _ = &next; + (blk: { + const ref = &face; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = @as(u16, @bitCast(@as(c_short, @truncate(((v + slice) + slices) + @as(c_int, 1))))); + (blk: { + const ref = &face; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = @as(u16, @bitCast(@as(c_short, @truncate(v + next)))); + (blk: { + const ref = &face; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = @as(u16, @bitCast(@as(c_short, @truncate(v + slice)))); + (blk: { + const ref = &face; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = @as(u16, @bitCast(@as(c_short, @truncate(((v + slice) + slices) + @as(c_int, 1))))); + (blk: { + const ref = &face; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = @as(u16, @bitCast(@as(c_short, @truncate(((v + next) + slices) + @as(c_int, 1))))); + (blk: { + const ref = &face; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = @as(u16, @bitCast(@as(c_short, @truncate(v + next)))); + } + } + v += slices + @as(c_int, 1); + } + } + par_shapes__compute_welded_normals(mesh); + return mesh; +} +pub export fn par_shapes_create_icosahedron() [*c]par_shapes_mesh { + const verts = struct { + var static: [36]f32 = [36]f32{ + @as(f32, @floatCast(0.0)), + @as(f32, @floatCast(0.0)), + @as(f32, @floatCast(1.0)), + @as(f32, @floatCast(0.894)), + @as(f32, @floatCast(0.0)), + @as(f32, @floatCast(0.447)), + @as(f32, @floatCast(0.276)), + @as(f32, @floatCast(0.851)), + @as(f32, @floatCast(0.447)), + @as(f32, @floatCast(-0.724)), + @as(f32, @floatCast(0.526)), + @as(f32, @floatCast(0.447)), + @as(f32, @floatCast(-0.724)), + @as(f32, @floatCast(-0.526)), + @as(f32, @floatCast(0.447)), + @as(f32, @floatCast(0.276)), + @as(f32, @floatCast(-0.851)), + @as(f32, @floatCast(0.447)), + @as(f32, @floatCast(0.724)), + @as(f32, @floatCast(0.526)), + @as(f32, @floatCast(-0.447)), + @as(f32, @floatCast(-0.276)), + @as(f32, @floatCast(0.851)), + @as(f32, @floatCast(-0.447)), + @as(f32, @floatCast(-0.894)), + @as(f32, @floatCast(0.0)), + @as(f32, @floatCast(-0.447)), + @as(f32, @floatCast(-0.276)), + @as(f32, @floatCast(-0.851)), + @as(f32, @floatCast(-0.447)), + @as(f32, @floatCast(0.724)), + @as(f32, @floatCast(-0.526)), + @as(f32, @floatCast(-0.447)), + @as(f32, @floatCast(0.0)), + @as(f32, @floatCast(0.0)), + @as(f32, @floatCast(-1.0)), + }; + }; + _ = &verts; + const faces = struct { + var static: [60]u16 = [60]u16{ + 0, + 1, + 2, + 0, + 2, + 3, + 0, + 3, + 4, + 0, + 4, + 5, + 0, + 5, + 1, + 7, + 6, + 11, + 8, + 7, + 11, + 9, + 8, + 11, + 10, + 9, + 11, + 6, + 10, + 11, + 6, + 2, + 1, + 7, + 3, + 2, + 8, + 4, + 3, + 9, + 5, + 4, + 10, + 1, + 5, + 6, + 7, + 2, + 7, + 8, + 3, + 8, + 9, + 4, + 9, + 10, + 5, + 10, + 6, + 1, + }; + }; + _ = &faces; + var mesh: [*c]par_shapes_mesh = @as([*c]par_shapes_mesh, @ptrCast(@alignCast(calloc(@as(c_ulong, @bitCast(@as(c_long, @as(c_int, 1)))) *% @sizeOf(par_shapes_mesh), @as(c_ulong, @bitCast(@as(c_long, @as(c_int, 1)))))))); + _ = &mesh; + mesh.*.npoints = @as(c_int, @bitCast(@as(c_uint, @truncate((@sizeOf([36]f32) / @sizeOf(f32)) / @as(c_ulong, @bitCast(@as(c_long, @as(c_int, 3)))))))); + mesh.*.points = @as([*c]f32, @ptrCast(@alignCast(malloc((@sizeOf([36]f32) / @as(c_ulong, @bitCast(@as(c_long, @as(c_int, 4))))) *% @sizeOf(f32))))); + _ = memcpy(@as(?*anyopaque, @ptrCast(mesh.*.points)), @as(?*const anyopaque, @ptrCast(@as([*c]f32, @ptrCast(@alignCast(&verts.static))))), @sizeOf([36]f32)); + mesh.*.ntriangles = @as(c_int, @bitCast(@as(c_uint, @truncate((@sizeOf([60]u16) / @sizeOf(u16)) / @as(c_ulong, @bitCast(@as(c_long, @as(c_int, 3)))))))); + mesh.*.triangles = @as([*c]u16, @ptrCast(@alignCast(malloc((@sizeOf([60]u16) / @as(c_ulong, @bitCast(@as(c_long, @as(c_int, 2))))) *% @sizeOf(u16))))); + _ = memcpy(@as(?*anyopaque, @ptrCast(mesh.*.triangles)), @as(?*const anyopaque, @ptrCast(@as([*c]u16, @ptrCast(@alignCast(&faces.static))))), @sizeOf([60]u16)); + return mesh; +} +pub export fn par_shapes_create_dodecahedron() [*c]par_shapes_mesh { + const verts = struct { + var static: [60]f32 = [60]f32{ + @as(f32, @floatCast(0.607)), + @as(f32, @floatCast(0.0)), + @as(f32, @floatCast(0.795)), + @as(f32, @floatCast(0.188)), + @as(f32, @floatCast(0.577)), + @as(f32, @floatCast(0.795)), + @as(f32, @floatCast(-0.491)), + @as(f32, @floatCast(0.357)), + @as(f32, @floatCast(0.795)), + @as(f32, @floatCast(-0.491)), + @as(f32, @floatCast(-0.357)), + @as(f32, @floatCast(0.795)), + @as(f32, @floatCast(0.188)), + @as(f32, @floatCast(-0.577)), + @as(f32, @floatCast(0.795)), + @as(f32, @floatCast(0.982)), + @as(f32, @floatCast(0.0)), + @as(f32, @floatCast(0.188)), + @as(f32, @floatCast(0.304)), + @as(f32, @floatCast(0.934)), + @as(f32, @floatCast(0.188)), + @as(f32, @floatCast(-0.795)), + @as(f32, @floatCast(0.577)), + @as(f32, @floatCast(0.188)), + @as(f32, @floatCast(-0.795)), + @as(f32, @floatCast(-0.577)), + @as(f32, @floatCast(0.188)), + @as(f32, @floatCast(0.304)), + @as(f32, @floatCast(-0.934)), + @as(f32, @floatCast(0.188)), + @as(f32, @floatCast(0.795)), + @as(f32, @floatCast(0.577)), + @as(f32, @floatCast(-0.188)), + @as(f32, @floatCast(-0.304)), + @as(f32, @floatCast(0.934)), + @as(f32, @floatCast(-0.188)), + @as(f32, @floatCast(-0.982)), + @as(f32, @floatCast(0.0)), + @as(f32, @floatCast(-0.188)), + @as(f32, @floatCast(-0.304)), + @as(f32, @floatCast(-0.934)), + @as(f32, @floatCast(-0.188)), + @as(f32, @floatCast(0.795)), + @as(f32, @floatCast(-0.577)), + @as(f32, @floatCast(-0.188)), + @as(f32, @floatCast(0.491)), + @as(f32, @floatCast(0.357)), + @as(f32, @floatCast(-0.795)), + @as(f32, @floatCast(-0.188)), + @as(f32, @floatCast(0.577)), + @as(f32, @floatCast(-0.795)), + @as(f32, @floatCast(-0.607)), + @as(f32, @floatCast(0.0)), + @as(f32, @floatCast(-0.795)), + @as(f32, @floatCast(-0.188)), + @as(f32, @floatCast(-0.577)), + @as(f32, @floatCast(-0.795)), + @as(f32, @floatCast(0.491)), + @as(f32, @floatCast(-0.357)), + @as(f32, @floatCast(-0.795)), + }; + }; + _ = &verts; + const pentagons = struct { + var static: [60]u16 = [60]u16{ + 0, + 1, + 2, + 3, + 4, + 5, + 10, + 6, + 1, + 0, + 6, + 11, + 7, + 2, + 1, + 7, + 12, + 8, + 3, + 2, + 8, + 13, + 9, + 4, + 3, + 9, + 14, + 5, + 0, + 4, + 15, + 16, + 11, + 6, + 10, + 16, + 17, + 12, + 7, + 11, + 17, + 18, + 13, + 8, + 12, + 18, + 19, + 14, + 9, + 13, + 19, + 15, + 10, + 5, + 14, + 19, + 18, + 17, + 16, + 15, + }; + }; + _ = &pentagons; + var npentagons: c_int = @as(c_int, @bitCast(@as(c_uint, @truncate((@sizeOf([60]u16) / @sizeOf(u16)) / @as(c_ulong, @bitCast(@as(c_long, @as(c_int, 5)))))))); + _ = &npentagons; + var mesh: [*c]par_shapes_mesh = @as([*c]par_shapes_mesh, @ptrCast(@alignCast(calloc(@as(c_ulong, @bitCast(@as(c_long, @as(c_int, 1)))) *% @sizeOf(par_shapes_mesh), @as(c_ulong, @bitCast(@as(c_long, @as(c_int, 1)))))))); + _ = &mesh; + var ncorners: c_int = @as(c_int, @bitCast(@as(c_uint, @truncate((@sizeOf([60]f32) / @sizeOf(f32)) / @as(c_ulong, @bitCast(@as(c_long, @as(c_int, 3)))))))); + _ = &ncorners; + mesh.*.npoints = ncorners; + mesh.*.points = @as([*c]f32, @ptrCast(@alignCast(malloc(@as(c_ulong, @bitCast(@as(c_long, mesh.*.npoints * @as(c_int, 3)))) *% @sizeOf(f32))))); + _ = memcpy(@as(?*anyopaque, @ptrCast(mesh.*.points)), @as(?*const anyopaque, @ptrCast(@as([*c]f32, @ptrCast(@alignCast(&verts.static))))), @sizeOf([60]f32)); + var pentagon: [*c]const u16 = @as([*c]u16, @ptrCast(@alignCast(&pentagons.static))); + _ = &pentagon; + mesh.*.ntriangles = npentagons * @as(c_int, 3); + mesh.*.triangles = @as([*c]u16, @ptrCast(@alignCast(malloc(@as(c_ulong, @bitCast(@as(c_long, mesh.*.ntriangles * @as(c_int, 3)))) *% @sizeOf(u16))))); + var tris: [*c]u16 = mesh.*.triangles; + _ = &tris; + { + var p: c_int = 0; + _ = &p; + while (p < npentagons) : (_ = blk: { + p += 1; + break :blk blk_1: { + const ref = &pentagon; + ref.* += @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 5))))); + break :blk_1 ref.*; + }; + }) { + (blk: { + const ref = &tris; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = pentagon[@as(c_uint, @intCast(@as(c_int, 0)))]; + (blk: { + const ref = &tris; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = pentagon[@as(c_uint, @intCast(@as(c_int, 1)))]; + (blk: { + const ref = &tris; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = pentagon[@as(c_uint, @intCast(@as(c_int, 2)))]; + (blk: { + const ref = &tris; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = pentagon[@as(c_uint, @intCast(@as(c_int, 0)))]; + (blk: { + const ref = &tris; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = pentagon[@as(c_uint, @intCast(@as(c_int, 2)))]; + (blk: { + const ref = &tris; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = pentagon[@as(c_uint, @intCast(@as(c_int, 3)))]; + (blk: { + const ref = &tris; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = pentagon[@as(c_uint, @intCast(@as(c_int, 0)))]; + (blk: { + const ref = &tris; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = pentagon[@as(c_uint, @intCast(@as(c_int, 3)))]; + (blk: { + const ref = &tris; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = pentagon[@as(c_uint, @intCast(@as(c_int, 4)))]; + } + } + return mesh; +} +pub export fn par_shapes_create_octahedron() [*c]par_shapes_mesh { + const verts = struct { + var static: [18]f32 = [18]f32{ + @as(f32, @floatCast(0.0)), + @as(f32, @floatCast(0.0)), + @as(f32, @floatCast(1.0)), + @as(f32, @floatCast(1.0)), + @as(f32, @floatCast(0.0)), + @as(f32, @floatCast(0.0)), + @as(f32, @floatCast(0.0)), + @as(f32, @floatCast(1.0)), + @as(f32, @floatCast(0.0)), + @as(f32, @floatCast(-1.0)), + @as(f32, @floatCast(0.0)), + @as(f32, @floatCast(0.0)), + @as(f32, @floatCast(0.0)), + @as(f32, @floatCast(-1.0)), + @as(f32, @floatCast(0.0)), + @as(f32, @floatCast(0.0)), + @as(f32, @floatCast(0.0)), + @as(f32, @floatCast(-1.0)), + }; + }; + _ = &verts; + const triangles = struct { + var static: [24]u16 = [24]u16{ + 0, + 1, + 2, + 0, + 2, + 3, + 0, + 3, + 4, + 0, + 4, + 1, + 2, + 1, + 5, + 3, + 2, + 5, + 4, + 3, + 5, + 1, + 4, + 5, + }; + }; + _ = &triangles; + var ntris: c_int = @as(c_int, @bitCast(@as(c_uint, @truncate((@sizeOf([24]u16) / @sizeOf(u16)) / @as(c_ulong, @bitCast(@as(c_long, @as(c_int, 3)))))))); + _ = &ntris; + var mesh: [*c]par_shapes_mesh = @as([*c]par_shapes_mesh, @ptrCast(@alignCast(calloc(@as(c_ulong, @bitCast(@as(c_long, @as(c_int, 1)))) *% @sizeOf(par_shapes_mesh), @as(c_ulong, @bitCast(@as(c_long, @as(c_int, 1)))))))); + _ = &mesh; + var ncorners: c_int = @as(c_int, @bitCast(@as(c_uint, @truncate((@sizeOf([18]f32) / @sizeOf(f32)) / @as(c_ulong, @bitCast(@as(c_long, @as(c_int, 3)))))))); + _ = &ncorners; + mesh.*.npoints = ncorners; + mesh.*.points = @as([*c]f32, @ptrCast(@alignCast(malloc(@as(c_ulong, @bitCast(@as(c_long, mesh.*.npoints * @as(c_int, 3)))) *% @sizeOf(f32))))); + _ = memcpy(@as(?*anyopaque, @ptrCast(mesh.*.points)), @as(?*const anyopaque, @ptrCast(@as([*c]f32, @ptrCast(@alignCast(&verts.static))))), @sizeOf([18]f32)); + var triangle: [*c]const u16 = @as([*c]u16, @ptrCast(@alignCast(&triangles.static))); + _ = ▵ + mesh.*.ntriangles = ntris; + mesh.*.triangles = @as([*c]u16, @ptrCast(@alignCast(malloc(@as(c_ulong, @bitCast(@as(c_long, mesh.*.ntriangles * @as(c_int, 3)))) *% @sizeOf(u16))))); + var tris: [*c]u16 = mesh.*.triangles; + _ = &tris; + { + var p: c_int = 0; + _ = &p; + while (p < ntris) : (p += 1) { + (blk: { + const ref = &tris; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = (blk: { + const ref = ▵ + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).*; + (blk: { + const ref = &tris; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = (blk: { + const ref = ▵ + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).*; + (blk: { + const ref = &tris; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = (blk: { + const ref = ▵ + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).*; + } + } + return mesh; +} +pub export fn par_shapes_create_tetrahedron() [*c]par_shapes_mesh { + const verts = struct { + var static: [12]f32 = [12]f32{ + @as(f32, @floatCast(0.0)), + @as(f32, @floatCast(1.333)), + 0, + @as(f32, @floatCast(0.943)), + 0, + 0, + @as(f32, @floatCast(-0.471)), + 0, + @as(f32, @floatCast(0.816)), + @as(f32, @floatCast(-0.471)), + 0, + @as(f32, @floatCast(-0.816)), + }; + }; + _ = &verts; + const triangles = struct { + var static: [12]u16 = [12]u16{ + 2, + 1, + 0, + 3, + 2, + 0, + 1, + 3, + 0, + 1, + 2, + 3, + }; + }; + _ = &triangles; + var ntris: c_int = @as(c_int, @bitCast(@as(c_uint, @truncate((@sizeOf([12]u16) / @sizeOf(u16)) / @as(c_ulong, @bitCast(@as(c_long, @as(c_int, 3)))))))); + _ = &ntris; + var mesh: [*c]par_shapes_mesh = @as([*c]par_shapes_mesh, @ptrCast(@alignCast(calloc(@as(c_ulong, @bitCast(@as(c_long, @as(c_int, 1)))) *% @sizeOf(par_shapes_mesh), @as(c_ulong, @bitCast(@as(c_long, @as(c_int, 1)))))))); + _ = &mesh; + var ncorners: c_int = @as(c_int, @bitCast(@as(c_uint, @truncate((@sizeOf([12]f32) / @sizeOf(f32)) / @as(c_ulong, @bitCast(@as(c_long, @as(c_int, 3)))))))); + _ = &ncorners; + mesh.*.npoints = ncorners; + mesh.*.points = @as([*c]f32, @ptrCast(@alignCast(malloc(@as(c_ulong, @bitCast(@as(c_long, mesh.*.npoints * @as(c_int, 3)))) *% @sizeOf(f32))))); + _ = memcpy(@as(?*anyopaque, @ptrCast(mesh.*.points)), @as(?*const anyopaque, @ptrCast(@as([*c]f32, @ptrCast(@alignCast(&verts.static))))), @sizeOf([12]f32)); + var triangle: [*c]const u16 = @as([*c]u16, @ptrCast(@alignCast(&triangles.static))); + _ = ▵ + mesh.*.ntriangles = ntris; + mesh.*.triangles = @as([*c]u16, @ptrCast(@alignCast(malloc(@as(c_ulong, @bitCast(@as(c_long, mesh.*.ntriangles * @as(c_int, 3)))) *% @sizeOf(u16))))); + var tris: [*c]u16 = mesh.*.triangles; + _ = &tris; + { + var p: c_int = 0; + _ = &p; + while (p < ntris) : (p += 1) { + (blk: { + const ref = &tris; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = (blk: { + const ref = ▵ + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).*; + (blk: { + const ref = &tris; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = (blk: { + const ref = ▵ + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).*; + (blk: { + const ref = &tris; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = (blk: { + const ref = ▵ + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).*; + } + } + return mesh; +} +pub export fn par_shapes_create_cube() [*c]par_shapes_mesh { + const verts = struct { + var static: [24]f32 = [24]f32{ + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 1, + }; + }; + _ = &verts; + const quads = struct { + var static: [24]u16 = [24]u16{ + 7, + 6, + 5, + 4, + 0, + 1, + 2, + 3, + 6, + 7, + 3, + 2, + 5, + 6, + 2, + 1, + 4, + 5, + 1, + 0, + 7, + 4, + 0, + 3, + }; + }; + _ = &quads; + var nquads: c_int = @as(c_int, @bitCast(@as(c_uint, @truncate((@sizeOf([24]u16) / @sizeOf(u16)) / @as(c_ulong, @bitCast(@as(c_long, @as(c_int, 4)))))))); + _ = &nquads; + var mesh: [*c]par_shapes_mesh = @as([*c]par_shapes_mesh, @ptrCast(@alignCast(calloc(@as(c_ulong, @bitCast(@as(c_long, @as(c_int, 1)))) *% @sizeOf(par_shapes_mesh), @as(c_ulong, @bitCast(@as(c_long, @as(c_int, 1)))))))); + _ = &mesh; + var ncorners: c_int = @as(c_int, @bitCast(@as(c_uint, @truncate((@sizeOf([24]f32) / @sizeOf(f32)) / @as(c_ulong, @bitCast(@as(c_long, @as(c_int, 3)))))))); + _ = &ncorners; + mesh.*.npoints = ncorners; + mesh.*.points = @as([*c]f32, @ptrCast(@alignCast(malloc(@as(c_ulong, @bitCast(@as(c_long, mesh.*.npoints * @as(c_int, 3)))) *% @sizeOf(f32))))); + _ = memcpy(@as(?*anyopaque, @ptrCast(mesh.*.points)), @as(?*const anyopaque, @ptrCast(@as([*c]f32, @ptrCast(@alignCast(&verts.static))))), @sizeOf([24]f32)); + var quad: [*c]const u16 = @as([*c]u16, @ptrCast(@alignCast(&quads.static))); + _ = &quad; + mesh.*.ntriangles = nquads * @as(c_int, 2); + mesh.*.triangles = @as([*c]u16, @ptrCast(@alignCast(malloc(@as(c_ulong, @bitCast(@as(c_long, mesh.*.ntriangles * @as(c_int, 3)))) *% @sizeOf(u16))))); + var tris: [*c]u16 = mesh.*.triangles; + _ = &tris; + { + var p: c_int = 0; + _ = &p; + while (p < nquads) : (_ = blk: { + p += 1; + break :blk blk_1: { + const ref = &quad; + ref.* += @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 4))))); + break :blk_1 ref.*; + }; + }) { + (blk: { + const ref = &tris; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = quad[@as(c_uint, @intCast(@as(c_int, 0)))]; + (blk: { + const ref = &tris; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = quad[@as(c_uint, @intCast(@as(c_int, 1)))]; + (blk: { + const ref = &tris; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = quad[@as(c_uint, @intCast(@as(c_int, 2)))]; + (blk: { + const ref = &tris; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = quad[@as(c_uint, @intCast(@as(c_int, 2)))]; + (blk: { + const ref = &tris; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = quad[@as(c_uint, @intCast(@as(c_int, 3)))]; + (blk: { + const ref = &tris; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = quad[@as(c_uint, @intCast(@as(c_int, 0)))]; + } + } + return mesh; +} +pub export fn par_shapes_create_disk(arg_radius: f32, arg_slices: c_int, arg_center: [*c]const f32, arg_normal: [*c]const f32) [*c]par_shapes_mesh { + var radius = arg_radius; + _ = &radius; + var slices = arg_slices; + _ = &slices; + var center = arg_center; + _ = ¢er; + var normal = arg_normal; + _ = &normal; + var mesh: [*c]par_shapes_mesh = @as([*c]par_shapes_mesh, @ptrCast(@alignCast(calloc(@as(c_ulong, @bitCast(@as(c_long, @as(c_int, 1)))) *% @sizeOf(par_shapes_mesh), @as(c_ulong, @bitCast(@as(c_long, @as(c_int, 1)))))))); + _ = &mesh; + mesh.*.npoints = slices + @as(c_int, 1); + mesh.*.points = @as([*c]f32, @ptrCast(@alignCast(malloc(@as(c_ulong, @bitCast(@as(c_long, @as(c_int, 3) * mesh.*.npoints))) *% @sizeOf(f32))))); + var points: [*c]f32 = mesh.*.points; + _ = &points; + (blk: { + const ref = &points; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = 0; + (blk: { + const ref = &points; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = 0; + (blk: { + const ref = &points; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = 0; + { + var i: c_int = 0; + _ = &i; + while (i < slices) : (i += 1) { + var theta: f32 = @as(f32, @floatCast(((@as(f64, @floatFromInt(i)) * 3.14159265359) * @as(f64, @floatFromInt(@as(c_int, 2)))) / @as(f64, @floatFromInt(slices)))); + _ = θ + (blk: { + const ref = &points; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = @as(f32, @floatCast(@as(f64, @floatCast(radius)) * cos(@as(f64, @floatCast(theta))))); + (blk: { + const ref = &points; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = @as(f32, @floatCast(@as(f64, @floatCast(radius)) * sin(@as(f64, @floatCast(theta))))); + (blk: { + const ref = &points; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = 0; + } + } + var nnormal: [3]f32 = [3]f32{ + normal[@as(c_uint, @intCast(@as(c_int, 0)))], + normal[@as(c_uint, @intCast(@as(c_int, 1)))], + normal[@as(c_uint, @intCast(@as(c_int, 2)))], + }; + _ = &nnormal; + par_shapes__normalize3(@as([*c]f32, @ptrCast(@alignCast(&nnormal)))); + mesh.*.normals = @as([*c]f32, @ptrCast(@alignCast(malloc(@as(c_ulong, @bitCast(@as(c_long, @as(c_int, 3) * mesh.*.npoints))) *% @sizeOf(f32))))); + var norms: [*c]f32 = mesh.*.normals; + _ = &norms; + { + var i: c_int = 0; + _ = &i; + while (i < mesh.*.npoints) : (i += 1) { + (blk: { + const ref = &norms; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = nnormal[@as(c_uint, @intCast(@as(c_int, 0)))]; + (blk: { + const ref = &norms; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = nnormal[@as(c_uint, @intCast(@as(c_int, 1)))]; + (blk: { + const ref = &norms; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = nnormal[@as(c_uint, @intCast(@as(c_int, 2)))]; + } + } + mesh.*.ntriangles = slices; + mesh.*.triangles = @as([*c]u16, @ptrCast(@alignCast(malloc(@as(c_ulong, @bitCast(@as(c_long, @as(c_int, 3) * mesh.*.ntriangles))) *% @sizeOf(u16))))); + var triangles: [*c]u16 = mesh.*.triangles; + _ = &triangles; + { + var i: c_int = 0; + _ = &i; + while (i < slices) : (i += 1) { + (blk: { + const ref = &triangles; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = 0; + (blk: { + const ref = &triangles; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = @as(u16, @bitCast(@as(c_short, @truncate(@as(c_int, 1) + i)))); + (blk: { + const ref = &triangles; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = @as(u16, @bitCast(@as(c_short, @truncate(@as(c_int, 1) + @import("std").zig.c_translation.signedRemainder(i + @as(c_int, 1), slices))))); + } + } + var k: [3]f32 = [3]f32{ + 0, + 0, + @as(f32, @floatFromInt(-@as(c_int, 1))), + }; + _ = &k; + var axis: [3]f32 = undefined; + _ = &axis; + par_shapes__cross3(@as([*c]f32, @ptrCast(@alignCast(&axis))), @as([*c]f32, @ptrCast(@alignCast(&nnormal))), @as([*c]f32, @ptrCast(@alignCast(&k)))); + par_shapes__normalize3(@as([*c]f32, @ptrCast(@alignCast(&axis)))); + par_shapes_rotate(mesh, @as(f32, @floatCast(acos(@as(f64, @floatCast(nnormal[@as(c_uint, @intCast(@as(c_int, 2)))]))))), @as([*c]f32, @ptrCast(@alignCast(&axis)))); + par_shapes_translate(mesh, center[@as(c_uint, @intCast(@as(c_int, 0)))], center[@as(c_uint, @intCast(@as(c_int, 1)))], center[@as(c_uint, @intCast(@as(c_int, 2)))]); + return mesh; +} +pub export fn par_shapes_create_empty() [*c]par_shapes_mesh { + return @as([*c]par_shapes_mesh, @ptrCast(@alignCast(calloc(@as(c_ulong, @bitCast(@as(c_long, @as(c_int, 1)))) *% @sizeOf(par_shapes_mesh), @as(c_ulong, @bitCast(@as(c_long, @as(c_int, 1)))))))); +} +pub const struct_osn_context = extern struct { + perm: [*c]i16 = @import("std").mem.zeroes([*c]i16), + permGradIndex3D: [*c]i16 = @import("std").mem.zeroes([*c]i16), +}; +pub export fn par_shapes_create_rock(arg_seed: c_int, arg_subd: c_int) [*c]par_shapes_mesh { + var seed = arg_seed; + _ = &seed; + var subd = arg_subd; + _ = &subd; + var mesh: [*c]par_shapes_mesh = par_shapes_create_subdivided_sphere(subd); + _ = &mesh; + var ctx: [*c]struct_osn_context = undefined; + _ = &ctx; + _ = par__simplex_noise(@as(i64, @bitCast(@as(c_long, seed))), &ctx); + { + var p: c_int = 0; + _ = &p; + while (p < mesh.*.npoints) : (p += 1) { + var pt: [*c]f32 = mesh.*.points + @as(usize, @bitCast(@as(isize, @intCast(p * @as(c_int, 3))))); + _ = &pt; + var a: f32 = @as(f32, @floatCast(0.25)); + _ = &a; + var f: f32 = @as(f32, @floatCast(1.0)); + _ = &f; + var n: f64 = @as(f64, @floatCast(a)) * par__simplex_noise2(ctx, @as(f64, @floatCast(f * pt[@as(c_uint, @intCast(@as(c_int, 0)))])), @as(f64, @floatCast(f * pt[@as(c_uint, @intCast(@as(c_int, 2)))]))); + _ = &n; + a *= @as(f32, @floatCast(0.5)); + f *= @as(f32, @floatFromInt(@as(c_int, 2))); + n += @as(f64, @floatCast(a)) * par__simplex_noise2(ctx, @as(f64, @floatCast(f * pt[@as(c_uint, @intCast(@as(c_int, 0)))])), @as(f64, @floatCast(f * pt[@as(c_uint, @intCast(@as(c_int, 2)))]))); + pt[@as(c_uint, @intCast(@as(c_int, 0)))] *= @as(f32, @floatCast(@as(f64, @floatFromInt(@as(c_int, 1))) + (@as(f64, @floatFromInt(@as(c_int, 2))) * n))); + pt[@as(c_uint, @intCast(@as(c_int, 1)))] *= @as(f32, @floatCast(@as(f64, @floatFromInt(@as(c_int, 1))) + n)); + pt[@as(c_uint, @intCast(@as(c_int, 2)))] *= @as(f32, @floatCast(@as(f64, @floatFromInt(@as(c_int, 1))) + (@as(f64, @floatFromInt(@as(c_int, 2))) * n))); + if (pt[@as(c_uint, @intCast(@as(c_int, 1)))] < @as(f32, @floatFromInt(@as(c_int, 0)))) { + pt[@as(c_uint, @intCast(@as(c_int, 1)))] = @as(f32, @floatCast(-pow(@as(f64, @floatCast(-pt[@as(c_uint, @intCast(@as(c_int, 1)))])), 0.5) / @as(f64, @floatFromInt(@as(c_int, 2))))); + } + } + } + par__simplex_noise_free(ctx); + par_shapes_compute_normals(mesh); + return mesh; +} +pub export fn par_shapes_create_lsystem(arg_text: [*c]const u8, arg_slices: c_int, arg_maxdepth: c_int) [*c]par_shapes_mesh { + var text = arg_text; + _ = &text; + var slices = arg_slices; + _ = &slices; + var maxdepth = arg_maxdepth; + _ = &maxdepth; + var program: [*c]u8 = undefined; + _ = &program; + program = @as([*c]u8, @ptrCast(@alignCast(malloc(strlen(text) +% (@as(c_ulong, @bitCast(@as(c_long, @as(c_int, 1)))) *% @sizeOf(u8)))))); + _ = strcpy(program, text); + var cmd: [*c]u8 = strtok(program, " "); + _ = &cmd; + var nrules: c_int = 1; + _ = &nrules; + var ncommands: c_int = 0; + _ = &ncommands; + while (cmd != null) { + var arg: [*c]u8 = strtok(null, " "); + _ = &arg; + if (!(arg != null)) { + _ = puts("lsystem error: unexpected end of program."); + break; + } + if (!(strcmp(cmd, "rule") != 0)) { + nrules += 1; + } else { + ncommands += 1; + } + cmd = strtok(null, " "); + } + var rules: [*c]par_shapes__rule = @as([*c]par_shapes__rule, @ptrCast(@alignCast(malloc(@as(c_ulong, @bitCast(@as(c_long, nrules))) *% @sizeOf(par_shapes__rule))))); + _ = &rules; + var commands: [*c]par_shapes__command = @as([*c]par_shapes__command, @ptrCast(@alignCast(malloc(@as(c_ulong, @bitCast(@as(c_long, ncommands))) *% @sizeOf(par_shapes__command))))); + _ = &commands; + var current_rule: [*c]par_shapes__rule = &rules[@as(c_uint, @intCast(@as(c_int, 0)))]; + _ = ¤t_rule; + var current_command: [*c]par_shapes__command = &commands[@as(c_uint, @intCast(@as(c_int, 0)))]; + _ = ¤t_command; + current_rule.*.name = "entry"; + current_rule.*.weight = 1; + current_rule.*.ncommands = 0; + current_rule.*.commands = current_command; + _ = strcpy(program, text); + cmd = strtok(program, " "); + while (cmd != null) { + var arg: [*c]u8 = strtok(null, " "); + _ = &arg; + if (!(strcmp(cmd, "rule") != 0)) { + current_rule += 1; + var dot: [*c]u8 = strchr(arg, @as(c_int, '.')); + _ = ˙ + if (dot != null) { + current_rule.*.weight = atoi(dot + @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 1)))))); + dot.* = 0; + } else { + current_rule.*.weight = 1; + } + current_rule.*.name = arg; + current_rule.*.ncommands = 0; + current_rule.*.commands = current_command; + } else { + current_rule.*.ncommands += 1; + current_command.*.cmd = cmd; + current_command.*.arg = arg; + current_command += 1; + } + cmd = strtok(null, " "); + } + var scene: [*c]par_shapes_mesh = @as([*c]par_shapes_mesh, @ptrCast(@alignCast(calloc(@as(c_ulong, @bitCast(@as(c_long, @as(c_int, 1)))) *% @sizeOf(par_shapes_mesh), @as(c_ulong, @bitCast(@as(c_long, @as(c_int, 1)))))))); + _ = &scene; + var tube: [*c]par_shapes_mesh = par_shapes_create_cylinder(slices, @as(c_int, 1)); + _ = &tube; + var turtle: [*c]par_shapes_mesh = par_shapes__create_turtle(); + _ = &turtle; + free(@as(?*anyopaque, @ptrCast(tube.*.normals))); + free(@as(?*anyopaque, @ptrCast(tube.*.tcoords))); + tube.*.normals = null; + tube.*.tcoords = null; + const xaxis: [3]f32 = [3]f32{ + 1, + 0, + 0, + }; + _ = &xaxis; + const yaxis: [3]f32 = [3]f32{ + 0, + 1, + 0, + }; + _ = &yaxis; + const zaxis: [3]f32 = [3]f32{ + 0, + 0, + 1, + }; + _ = &zaxis; + const units: [3]f32 = [3]f32{ + 1, + 1, + 1, + }; + _ = &units; + var stack: [*c]par_shapes__stackframe = @as([*c]par_shapes__stackframe, @ptrCast(@alignCast(calloc(@as(c_ulong, @bitCast(@as(c_long, maxdepth))) *% @sizeOf(par_shapes__stackframe), @as(c_ulong, @bitCast(@as(c_long, @as(c_int, 1)))))))); + _ = &stack; + var stackptr: c_int = 0; + _ = &stackptr; + stack[@as(c_uint, @intCast(@as(c_int, 0)))].orientation = turtle; + stack[@as(c_uint, @intCast(@as(c_int, 0)))].rule = &rules[@as(c_uint, @intCast(@as(c_int, 0)))]; + par_shapes__copy3(@as([*c]f32, @ptrCast(@alignCast(&stack[@as(c_uint, @intCast(@as(c_int, 0)))].scale))), @as([*c]const f32, @ptrCast(@alignCast(&units)))); + while (stackptr >= @as(c_int, 0)) { + var frame: [*c]par_shapes__stackframe = &(blk: { + const tmp = stackptr; + if (tmp >= 0) break :blk stack + @as(usize, @intCast(tmp)) else break :blk stack - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*; + _ = &frame; + var rule: [*c]par_shapes__rule = frame.*.rule; + _ = &rule; + var turtle_1: [*c]par_shapes_mesh = frame.*.orientation; + _ = &turtle_1; + var position: [*c]f32 = @as([*c]f32, @ptrCast(@alignCast(&frame.*.position))); + _ = &position; + var scale: [*c]f32 = @as([*c]f32, @ptrCast(@alignCast(&frame.*.scale))); + _ = &scale; + if (frame.*.pc >= rule.*.ncommands) { + par_shapes_free_mesh(turtle_1); + stackptr -= 1; + continue; + } + var cmd_2: [*c]par_shapes__command = rule.*.commands + @as(usize, @bitCast(@as(isize, @intCast(blk: { + const ref = &frame.*.pc; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + })))); + _ = &cmd_2; + var value: f32 = undefined; + _ = &value; + if (!(strcmp(cmd_2.*.cmd, "shape") != 0)) { + var m: [*c]par_shapes_mesh = par_shapes__apply_turtle(tube, turtle_1, position, scale); + _ = &m; + if (!(strcmp(cmd_2.*.arg, "connect") != 0)) { + par_shapes__connect(scene, m, slices); + } else { + par_shapes_merge(scene, m); + } + par_shapes_free_mesh(m); + } else if (!(strcmp(cmd_2.*.cmd, "call") != 0) and (stackptr < (maxdepth - @as(c_int, 1)))) { + rule = par_shapes__pick_rule(cmd_2.*.arg, rules, nrules); + frame = &(blk: { + const tmp = blk_1: { + const ref = &stackptr; + ref.* += 1; + break :blk_1 ref.*; + }; + if (tmp >= 0) break :blk stack + @as(usize, @intCast(tmp)) else break :blk stack - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*; + frame.*.rule = rule; + frame.*.orientation = par_shapes_clone(turtle_1, null); + frame.*.pc = 0; + par_shapes__copy3(@as([*c]f32, @ptrCast(@alignCast(&frame.*.scale))), scale); + par_shapes__copy3(@as([*c]f32, @ptrCast(@alignCast(&frame.*.position))), position); + continue; + } else { + value = @as(f32, @floatCast(atof(cmd_2.*.arg))); + if (!(strcmp(cmd_2.*.cmd, "rx") != 0)) { + par_shapes_rotate(turtle_1, @as(f32, @floatCast((@as(f64, @floatCast(value)) * 3.14159265359) / 180.0)), @as([*c]const f32, @ptrCast(@alignCast(&xaxis)))); + } else if (!(strcmp(cmd_2.*.cmd, "ry") != 0)) { + par_shapes_rotate(turtle_1, @as(f32, @floatCast((@as(f64, @floatCast(value)) * 3.14159265359) / 180.0)), @as([*c]const f32, @ptrCast(@alignCast(&yaxis)))); + } else if (!(strcmp(cmd_2.*.cmd, "rz") != 0)) { + par_shapes_rotate(turtle_1, @as(f32, @floatCast((@as(f64, @floatCast(value)) * 3.14159265359) / 180.0)), @as([*c]const f32, @ptrCast(@alignCast(&zaxis)))); + } else if (!(strcmp(cmd_2.*.cmd, "tx") != 0)) { + var vec: [3]f32 = [3]f32{ + value, + 0, + 0, + }; + _ = &vec; + var t: [3]f32 = [3]f32{ + par_shapes__dot3(turtle_1.*.points + @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 0))))), @as([*c]f32, @ptrCast(@alignCast(&vec)))), + par_shapes__dot3(turtle_1.*.points + @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 3))))), @as([*c]f32, @ptrCast(@alignCast(&vec)))), + par_shapes__dot3(turtle_1.*.points + @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 6))))), @as([*c]f32, @ptrCast(@alignCast(&vec)))), + }; + _ = &t; + par_shapes__add3(position, @as([*c]f32, @ptrCast(@alignCast(&t)))); + } else if (!(strcmp(cmd_2.*.cmd, "ty") != 0)) { + var vec: [3]f32 = [3]f32{ + 0, + value, + 0, + }; + _ = &vec; + var t: [3]f32 = [3]f32{ + par_shapes__dot3(turtle_1.*.points + @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 0))))), @as([*c]f32, @ptrCast(@alignCast(&vec)))), + par_shapes__dot3(turtle_1.*.points + @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 3))))), @as([*c]f32, @ptrCast(@alignCast(&vec)))), + par_shapes__dot3(turtle_1.*.points + @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 6))))), @as([*c]f32, @ptrCast(@alignCast(&vec)))), + }; + _ = &t; + par_shapes__add3(position, @as([*c]f32, @ptrCast(@alignCast(&t)))); + } else if (!(strcmp(cmd_2.*.cmd, "tz") != 0)) { + var vec: [3]f32 = [3]f32{ + 0, + 0, + value, + }; + _ = &vec; + var t: [3]f32 = [3]f32{ + par_shapes__dot3(turtle_1.*.points + @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 0))))), @as([*c]f32, @ptrCast(@alignCast(&vec)))), + par_shapes__dot3(turtle_1.*.points + @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 3))))), @as([*c]f32, @ptrCast(@alignCast(&vec)))), + par_shapes__dot3(turtle_1.*.points + @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 6))))), @as([*c]f32, @ptrCast(@alignCast(&vec)))), + }; + _ = &t; + par_shapes__add3(position, @as([*c]f32, @ptrCast(@alignCast(&t)))); + } else if (!(strcmp(cmd_2.*.cmd, "sx") != 0)) { + scale[@as(c_uint, @intCast(@as(c_int, 0)))] *= value; + } else if (!(strcmp(cmd_2.*.cmd, "sy") != 0)) { + scale[@as(c_uint, @intCast(@as(c_int, 1)))] *= value; + } else if (!(strcmp(cmd_2.*.cmd, "sz") != 0)) { + scale[@as(c_uint, @intCast(@as(c_int, 2)))] *= value; + } else if (!(strcmp(cmd_2.*.cmd, "sa") != 0)) { + scale[@as(c_uint, @intCast(@as(c_int, 0)))] *= value; + scale[@as(c_uint, @intCast(@as(c_int, 1)))] *= value; + scale[@as(c_uint, @intCast(@as(c_int, 2)))] *= value; + } + } + } + free(@as(?*anyopaque, @ptrCast(stack))); + free(@as(?*anyopaque, @ptrCast(program))); + free(@as(?*anyopaque, @ptrCast(rules))); + free(@as(?*anyopaque, @ptrCast(commands))); + return scene; +} +pub export fn par_shapes_export(arg_mesh: [*c]const par_shapes_mesh, arg_filename: [*c]const u8) void { + var mesh = arg_mesh; + _ = &mesh; + var filename = arg_filename; + _ = &filename; + var objfile: [*c]FILE = fopen(filename, "wt"); + _ = &objfile; + var points: [*c]const f32 = mesh.*.points; + _ = &points; + var tcoords: [*c]const f32 = mesh.*.tcoords; + _ = &tcoords; + var norms: [*c]const f32 = mesh.*.normals; + _ = &norms; + var indices: [*c]const u16 = mesh.*.triangles; + _ = &indices; + if ((tcoords != null) and (norms != null)) { + { + var nvert: c_int = 0; + _ = &nvert; + while (nvert < mesh.*.npoints) : (nvert += 1) { + _ = fprintf(objfile, "v %f %f %f\n", @as(f64, @floatCast(points[@as(c_uint, @intCast(@as(c_int, 0)))])), @as(f64, @floatCast(points[@as(c_uint, @intCast(@as(c_int, 1)))])), @as(f64, @floatCast(points[@as(c_uint, @intCast(@as(c_int, 2)))]))); + _ = fprintf(objfile, "vt %f %f\n", @as(f64, @floatCast(tcoords[@as(c_uint, @intCast(@as(c_int, 0)))])), @as(f64, @floatCast(tcoords[@as(c_uint, @intCast(@as(c_int, 1)))]))); + _ = fprintf(objfile, "vn %f %f %f\n", @as(f64, @floatCast(norms[@as(c_uint, @intCast(@as(c_int, 0)))])), @as(f64, @floatCast(norms[@as(c_uint, @intCast(@as(c_int, 1)))])), @as(f64, @floatCast(norms[@as(c_uint, @intCast(@as(c_int, 2)))]))); + points += @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 3))))); + norms += @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 3))))); + tcoords += @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 2))))); + } + } + { + var nface: c_int = 0; + _ = &nface; + while (nface < mesh.*.ntriangles) : (nface += 1) { + var a: c_int = @as(c_int, 1) + @as(c_int, @bitCast(@as(c_uint, (blk: { + const ref = &indices; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).*))); + _ = &a; + var b: c_int = @as(c_int, 1) + @as(c_int, @bitCast(@as(c_uint, (blk: { + const ref = &indices; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).*))); + _ = &b; + var c: c_int = @as(c_int, 1) + @as(c_int, @bitCast(@as(c_uint, (blk: { + const ref = &indices; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).*))); + _ = &c; + _ = fprintf(objfile, "f %d/%d/%d %d/%d/%d %d/%d/%d\n", a, a, a, b, b, b, c, c, c); + } + } + } else if (norms != null) { + { + var nvert: c_int = 0; + _ = &nvert; + while (nvert < mesh.*.npoints) : (nvert += 1) { + _ = fprintf(objfile, "v %f %f %f\n", @as(f64, @floatCast(points[@as(c_uint, @intCast(@as(c_int, 0)))])), @as(f64, @floatCast(points[@as(c_uint, @intCast(@as(c_int, 1)))])), @as(f64, @floatCast(points[@as(c_uint, @intCast(@as(c_int, 2)))]))); + _ = fprintf(objfile, "vn %f %f %f\n", @as(f64, @floatCast(norms[@as(c_uint, @intCast(@as(c_int, 0)))])), @as(f64, @floatCast(norms[@as(c_uint, @intCast(@as(c_int, 1)))])), @as(f64, @floatCast(norms[@as(c_uint, @intCast(@as(c_int, 2)))]))); + points += @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 3))))); + norms += @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 3))))); + } + } + { + var nface: c_int = 0; + _ = &nface; + while (nface < mesh.*.ntriangles) : (nface += 1) { + var a: c_int = @as(c_int, 1) + @as(c_int, @bitCast(@as(c_uint, (blk: { + const ref = &indices; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).*))); + _ = &a; + var b: c_int = @as(c_int, 1) + @as(c_int, @bitCast(@as(c_uint, (blk: { + const ref = &indices; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).*))); + _ = &b; + var c: c_int = @as(c_int, 1) + @as(c_int, @bitCast(@as(c_uint, (blk: { + const ref = &indices; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).*))); + _ = &c; + _ = fprintf(objfile, "f %d//%d %d//%d %d//%d\n", a, a, b, b, c, c); + } + } + } else if (tcoords != null) { + { + var nvert: c_int = 0; + _ = &nvert; + while (nvert < mesh.*.npoints) : (nvert += 1) { + _ = fprintf(objfile, "v %f %f %f\n", @as(f64, @floatCast(points[@as(c_uint, @intCast(@as(c_int, 0)))])), @as(f64, @floatCast(points[@as(c_uint, @intCast(@as(c_int, 1)))])), @as(f64, @floatCast(points[@as(c_uint, @intCast(@as(c_int, 2)))]))); + _ = fprintf(objfile, "vt %f %f\n", @as(f64, @floatCast(tcoords[@as(c_uint, @intCast(@as(c_int, 0)))])), @as(f64, @floatCast(tcoords[@as(c_uint, @intCast(@as(c_int, 1)))]))); + points += @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 3))))); + tcoords += @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 2))))); + } + } + { + var nface: c_int = 0; + _ = &nface; + while (nface < mesh.*.ntriangles) : (nface += 1) { + var a: c_int = @as(c_int, 1) + @as(c_int, @bitCast(@as(c_uint, (blk: { + const ref = &indices; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).*))); + _ = &a; + var b: c_int = @as(c_int, 1) + @as(c_int, @bitCast(@as(c_uint, (blk: { + const ref = &indices; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).*))); + _ = &b; + var c: c_int = @as(c_int, 1) + @as(c_int, @bitCast(@as(c_uint, (blk: { + const ref = &indices; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).*))); + _ = &c; + _ = fprintf(objfile, "f %d/%d %d/%d %d/%d\n", a, a, b, b, c, c); + } + } + } else { + { + var nvert: c_int = 0; + _ = &nvert; + while (nvert < mesh.*.npoints) : (nvert += 1) { + _ = fprintf(objfile, "v %f %f %f\n", @as(f64, @floatCast(points[@as(c_uint, @intCast(@as(c_int, 0)))])), @as(f64, @floatCast(points[@as(c_uint, @intCast(@as(c_int, 1)))])), @as(f64, @floatCast(points[@as(c_uint, @intCast(@as(c_int, 2)))]))); + points += @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 3))))); + } + } + { + var nface: c_int = 0; + _ = &nface; + while (nface < mesh.*.ntriangles) : (nface += 1) { + var a: c_int = @as(c_int, 1) + @as(c_int, @bitCast(@as(c_uint, (blk: { + const ref = &indices; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).*))); + _ = &a; + var b: c_int = @as(c_int, 1) + @as(c_int, @bitCast(@as(c_uint, (blk: { + const ref = &indices; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).*))); + _ = &b; + var c: c_int = @as(c_int, 1) + @as(c_int, @bitCast(@as(c_uint, (blk: { + const ref = &indices; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).*))); + _ = &c; + _ = fprintf(objfile, "f %d %d %d\n", a, b, c); + } + } + } + _ = fclose(objfile); +} +pub export fn par_shapes_compute_aabb(arg_m: [*c]const par_shapes_mesh, arg_aabb: [*c]f32) void { + var m = arg_m; + _ = &m; + var aabb = arg_aabb; + _ = &aabb; + var points: [*c]f32 = m.*.points; + _ = &points; + aabb[@as(c_uint, @intCast(@as(c_int, 0)))] = blk: { + const tmp = points[@as(c_uint, @intCast(@as(c_int, 0)))]; + aabb[@as(c_uint, @intCast(@as(c_int, 3)))] = tmp; + break :blk tmp; + }; + aabb[@as(c_uint, @intCast(@as(c_int, 1)))] = blk: { + const tmp = points[@as(c_uint, @intCast(@as(c_int, 1)))]; + aabb[@as(c_uint, @intCast(@as(c_int, 4)))] = tmp; + break :blk tmp; + }; + aabb[@as(c_uint, @intCast(@as(c_int, 2)))] = blk: { + const tmp = points[@as(c_uint, @intCast(@as(c_int, 2)))]; + aabb[@as(c_uint, @intCast(@as(c_int, 5)))] = tmp; + break :blk tmp; + }; + points += @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 3))))); + { + var i: c_int = 1; + _ = &i; + while (i < m.*.npoints) : (_ = blk: { + i += 1; + break :blk blk_1: { + const ref = &points; + ref.* += @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 3))))); + break :blk_1 ref.*; + }; + }) { + aabb[@as(c_uint, @intCast(@as(c_int, 0)))] = if (points[@as(c_uint, @intCast(@as(c_int, 0)))] > aabb[@as(c_uint, @intCast(@as(c_int, 0)))]) aabb[@as(c_uint, @intCast(@as(c_int, 0)))] else points[@as(c_uint, @intCast(@as(c_int, 0)))]; + aabb[@as(c_uint, @intCast(@as(c_int, 1)))] = if (points[@as(c_uint, @intCast(@as(c_int, 1)))] > aabb[@as(c_uint, @intCast(@as(c_int, 1)))]) aabb[@as(c_uint, @intCast(@as(c_int, 1)))] else points[@as(c_uint, @intCast(@as(c_int, 1)))]; + aabb[@as(c_uint, @intCast(@as(c_int, 2)))] = if (points[@as(c_uint, @intCast(@as(c_int, 2)))] > aabb[@as(c_uint, @intCast(@as(c_int, 2)))]) aabb[@as(c_uint, @intCast(@as(c_int, 2)))] else points[@as(c_uint, @intCast(@as(c_int, 2)))]; + aabb[@as(c_uint, @intCast(@as(c_int, 3)))] = if (points[@as(c_uint, @intCast(@as(c_int, 0)))] > aabb[@as(c_uint, @intCast(@as(c_int, 3)))]) points[@as(c_uint, @intCast(@as(c_int, 0)))] else aabb[@as(c_uint, @intCast(@as(c_int, 3)))]; + aabb[@as(c_uint, @intCast(@as(c_int, 4)))] = if (points[@as(c_uint, @intCast(@as(c_int, 1)))] > aabb[@as(c_uint, @intCast(@as(c_int, 4)))]) points[@as(c_uint, @intCast(@as(c_int, 1)))] else aabb[@as(c_uint, @intCast(@as(c_int, 4)))]; + aabb[@as(c_uint, @intCast(@as(c_int, 5)))] = if (points[@as(c_uint, @intCast(@as(c_int, 2)))] > aabb[@as(c_uint, @intCast(@as(c_int, 5)))]) points[@as(c_uint, @intCast(@as(c_int, 2)))] else aabb[@as(c_uint, @intCast(@as(c_int, 5)))]; + } + } +} +pub export fn par_shapes_clone(arg_mesh: [*c]const par_shapes_mesh, arg_clone: [*c]par_shapes_mesh) [*c]par_shapes_mesh { + var mesh = arg_mesh; + _ = &mesh; + var clone = arg_clone; + _ = &clone; + if (!(clone != null)) { + clone = @as([*c]par_shapes_mesh, @ptrCast(@alignCast(calloc(@as(c_ulong, @bitCast(@as(c_long, @as(c_int, 1)))) *% @sizeOf(par_shapes_mesh), @as(c_ulong, @bitCast(@as(c_long, @as(c_int, 1)))))))); + } + clone.*.npoints = mesh.*.npoints; + clone.*.points = @as([*c]f32, @ptrCast(@alignCast(realloc(@as(?*anyopaque, @ptrCast(clone.*.points)), @sizeOf(f32) *% @as(c_ulong, @bitCast(@as(c_long, @as(c_int, 3) * clone.*.npoints))))))); + _ = memcpy(@as(?*anyopaque, @ptrCast(clone.*.points)), @as(?*const anyopaque, @ptrCast(mesh.*.points)), (@sizeOf(f32) *% @as(c_ulong, @bitCast(@as(c_long, @as(c_int, 3))))) *% @as(c_ulong, @bitCast(@as(c_long, clone.*.npoints)))); + clone.*.ntriangles = mesh.*.ntriangles; + clone.*.triangles = @as([*c]u16, @ptrCast(@alignCast(realloc(@as(?*anyopaque, @ptrCast(clone.*.triangles)), @sizeOf(u16) *% @as(c_ulong, @bitCast(@as(c_long, @as(c_int, 3) * clone.*.ntriangles))))))); + _ = memcpy(@as(?*anyopaque, @ptrCast(clone.*.triangles)), @as(?*const anyopaque, @ptrCast(mesh.*.triangles)), (@sizeOf(u16) *% @as(c_ulong, @bitCast(@as(c_long, @as(c_int, 3))))) *% @as(c_ulong, @bitCast(@as(c_long, clone.*.ntriangles)))); + if (mesh.*.normals != null) { + clone.*.normals = @as([*c]f32, @ptrCast(@alignCast(realloc(@as(?*anyopaque, @ptrCast(clone.*.normals)), @sizeOf(f32) *% @as(c_ulong, @bitCast(@as(c_long, @as(c_int, 3) * clone.*.npoints))))))); + _ = memcpy(@as(?*anyopaque, @ptrCast(clone.*.normals)), @as(?*const anyopaque, @ptrCast(mesh.*.normals)), (@sizeOf(f32) *% @as(c_ulong, @bitCast(@as(c_long, @as(c_int, 3))))) *% @as(c_ulong, @bitCast(@as(c_long, clone.*.npoints)))); + } + if (mesh.*.tcoords != null) { + clone.*.tcoords = @as([*c]f32, @ptrCast(@alignCast(realloc(@as(?*anyopaque, @ptrCast(clone.*.tcoords)), @sizeOf(f32) *% @as(c_ulong, @bitCast(@as(c_long, @as(c_int, 2) * clone.*.npoints))))))); + _ = memcpy(@as(?*anyopaque, @ptrCast(clone.*.tcoords)), @as(?*const anyopaque, @ptrCast(mesh.*.tcoords)), (@sizeOf(f32) *% @as(c_ulong, @bitCast(@as(c_long, @as(c_int, 2))))) *% @as(c_ulong, @bitCast(@as(c_long, clone.*.npoints)))); + } + return clone; +} +pub export fn par_shapes_merge(arg_dst: [*c]par_shapes_mesh, arg_src: [*c]const par_shapes_mesh) void { + var dst = arg_dst; + _ = &dst; + var src = arg_src; + _ = &src; + var offset: u16 = @as(u16, @bitCast(@as(c_short, @truncate(dst.*.npoints)))); + _ = &offset; + var npoints: c_int = dst.*.npoints + src.*.npoints; + _ = &npoints; + var vecsize: c_int = @as(c_int, @bitCast(@as(c_uint, @truncate(@sizeOf(f32) *% @as(c_ulong, @bitCast(@as(c_long, @as(c_int, 3)))))))); + _ = &vecsize; + dst.*.points = @as([*c]f32, @ptrCast(@alignCast(realloc(@as(?*anyopaque, @ptrCast(dst.*.points)), @sizeOf(f32) *% @as(c_ulong, @bitCast(@as(c_long, @as(c_int, 3) * npoints))))))); + _ = memcpy(@as(?*anyopaque, @ptrCast(dst.*.points + @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 3) * dst.*.npoints)))))), @as(?*const anyopaque, @ptrCast(src.*.points)), @as(c_ulong, @bitCast(@as(c_long, vecsize * src.*.npoints)))); + dst.*.npoints = npoints; + if ((src.*.normals != null) or (dst.*.normals != null)) { + dst.*.normals = @as([*c]f32, @ptrCast(@alignCast(realloc(@as(?*anyopaque, @ptrCast(dst.*.normals)), @sizeOf(f32) *% @as(c_ulong, @bitCast(@as(c_long, @as(c_int, 3) * npoints))))))); + if (src.*.normals != null) { + _ = memcpy(@as(?*anyopaque, @ptrCast(dst.*.normals + @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 3) * @as(c_int, @bitCast(@as(c_uint, offset))))))))), @as(?*const anyopaque, @ptrCast(src.*.normals)), @as(c_ulong, @bitCast(@as(c_long, vecsize * src.*.npoints)))); + } + } + if ((src.*.tcoords != null) or (dst.*.tcoords != null)) { + var uvsize: c_int = @as(c_int, @bitCast(@as(c_uint, @truncate(@sizeOf(f32) *% @as(c_ulong, @bitCast(@as(c_long, @as(c_int, 2)))))))); + _ = &uvsize; + dst.*.tcoords = @as([*c]f32, @ptrCast(@alignCast(realloc(@as(?*anyopaque, @ptrCast(dst.*.tcoords)), @sizeOf(f32) *% @as(c_ulong, @bitCast(@as(c_long, @as(c_int, 2) * npoints))))))); + if (src.*.tcoords != null) { + _ = memcpy(@as(?*anyopaque, @ptrCast(dst.*.tcoords + @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 2) * @as(c_int, @bitCast(@as(c_uint, offset))))))))), @as(?*const anyopaque, @ptrCast(src.*.tcoords)), @as(c_ulong, @bitCast(@as(c_long, uvsize * src.*.npoints)))); + } + } + var ntriangles: c_int = dst.*.ntriangles + src.*.ntriangles; + _ = &ntriangles; + dst.*.triangles = @as([*c]u16, @ptrCast(@alignCast(realloc(@as(?*anyopaque, @ptrCast(dst.*.triangles)), @sizeOf(u16) *% @as(c_ulong, @bitCast(@as(c_long, @as(c_int, 3) * ntriangles))))))); + var ptriangles: [*c]u16 = dst.*.triangles + @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 3) * dst.*.ntriangles)))); + _ = &ptriangles; + var striangles: [*c]const u16 = src.*.triangles; + _ = &striangles; + { + var i: c_int = 0; + _ = &i; + while (i < src.*.ntriangles) : (i += 1) { + (blk: { + const ref = &ptriangles; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = @as(u16, @bitCast(@as(c_short, @truncate(@as(c_int, @bitCast(@as(c_uint, offset))) + @as(c_int, @bitCast(@as(c_uint, (blk: { + const ref = &striangles; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).*))))))); + (blk: { + const ref = &ptriangles; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = @as(u16, @bitCast(@as(c_short, @truncate(@as(c_int, @bitCast(@as(c_uint, offset))) + @as(c_int, @bitCast(@as(c_uint, (blk: { + const ref = &striangles; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).*))))))); + (blk: { + const ref = &ptriangles; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = @as(u16, @bitCast(@as(c_short, @truncate(@as(c_int, @bitCast(@as(c_uint, offset))) + @as(c_int, @bitCast(@as(c_uint, (blk: { + const ref = &striangles; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).*))))))); + } + } + dst.*.ntriangles = ntriangles; +} +pub export fn par_shapes_translate(arg_m: [*c]par_shapes_mesh, arg_x: f32, arg_y: f32, arg_z: f32) void { + var m = arg_m; + _ = &m; + var x = arg_x; + _ = &x; + var y = arg_y; + _ = &y; + var z = arg_z; + _ = &z; + var points: [*c]f32 = m.*.points; + _ = &points; + { + var i: c_int = 0; + _ = &i; + while (i < m.*.npoints) : (i += 1) { + (blk: { + const ref = &points; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* += x; + (blk: { + const ref = &points; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* += y; + (blk: { + const ref = &points; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* += z; + } + } +} +pub export fn par_shapes_rotate(arg_mesh: [*c]par_shapes_mesh, arg_radians: f32, arg_axis: [*c]const f32) void { + var mesh = arg_mesh; + _ = &mesh; + var radians = arg_radians; + _ = &radians; + var axis = arg_axis; + _ = &axis; + var s: f32 = sinf(radians); + _ = &s; + var c: f32 = cosf(radians); + _ = &c; + var x: f32 = axis[@as(c_uint, @intCast(@as(c_int, 0)))]; + _ = &x; + var y: f32 = axis[@as(c_uint, @intCast(@as(c_int, 1)))]; + _ = &y; + var z: f32 = axis[@as(c_uint, @intCast(@as(c_int, 2)))]; + _ = &z; + var xy: f32 = x * y; + _ = &xy; + var yz: f32 = y * z; + _ = &yz; + var zx: f32 = z * x; + _ = &zx; + var oneMinusC: f32 = 1.0 - c; + _ = &oneMinusC; + var col0: [3]f32 = [3]f32{ + ((x * x) * oneMinusC) + c, + (xy * oneMinusC) + (z * s), + (zx * oneMinusC) - (y * s), + }; + _ = &col0; + var col1: [3]f32 = [3]f32{ + (xy * oneMinusC) - (z * s), + ((y * y) * oneMinusC) + c, + (yz * oneMinusC) + (x * s), + }; + _ = &col1; + var col2: [3]f32 = [3]f32{ + (zx * oneMinusC) + (y * s), + (yz * oneMinusC) - (x * s), + ((z * z) * oneMinusC) + c, + }; + _ = &col2; + var p: [*c]f32 = mesh.*.points; + _ = &p; + { + var i: c_int = 0; + _ = &i; + while (i < mesh.*.npoints) : (_ = blk: { + i += 1; + break :blk blk_1: { + const ref = &p; + ref.* += @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 3))))); + break :blk_1 ref.*; + }; + }) { + var x_1: f32 = ((col0[@as(c_uint, @intCast(@as(c_int, 0)))] * p[@as(c_uint, @intCast(@as(c_int, 0)))]) + (col1[@as(c_uint, @intCast(@as(c_int, 0)))] * p[@as(c_uint, @intCast(@as(c_int, 1)))])) + (col2[@as(c_uint, @intCast(@as(c_int, 0)))] * p[@as(c_uint, @intCast(@as(c_int, 2)))]); + _ = &x_1; + var y_2: f32 = ((col0[@as(c_uint, @intCast(@as(c_int, 1)))] * p[@as(c_uint, @intCast(@as(c_int, 0)))]) + (col1[@as(c_uint, @intCast(@as(c_int, 1)))] * p[@as(c_uint, @intCast(@as(c_int, 1)))])) + (col2[@as(c_uint, @intCast(@as(c_int, 1)))] * p[@as(c_uint, @intCast(@as(c_int, 2)))]); + _ = &y_2; + var z_3: f32 = ((col0[@as(c_uint, @intCast(@as(c_int, 2)))] * p[@as(c_uint, @intCast(@as(c_int, 0)))]) + (col1[@as(c_uint, @intCast(@as(c_int, 2)))] * p[@as(c_uint, @intCast(@as(c_int, 1)))])) + (col2[@as(c_uint, @intCast(@as(c_int, 2)))] * p[@as(c_uint, @intCast(@as(c_int, 2)))]); + _ = &z_3; + p[@as(c_uint, @intCast(@as(c_int, 0)))] = x_1; + p[@as(c_uint, @intCast(@as(c_int, 1)))] = y_2; + p[@as(c_uint, @intCast(@as(c_int, 2)))] = z_3; + } + } + var n: [*c]f32 = mesh.*.normals; + _ = &n; + if (n != null) { + { + var i: c_int = 0; + _ = &i; + while (i < mesh.*.npoints) : (_ = blk: { + i += 1; + break :blk blk_1: { + const ref = &n; + ref.* += @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 3))))); + break :blk_1 ref.*; + }; + }) { + var x_1: f32 = ((col0[@as(c_uint, @intCast(@as(c_int, 0)))] * n[@as(c_uint, @intCast(@as(c_int, 0)))]) + (col1[@as(c_uint, @intCast(@as(c_int, 0)))] * n[@as(c_uint, @intCast(@as(c_int, 1)))])) + (col2[@as(c_uint, @intCast(@as(c_int, 0)))] * n[@as(c_uint, @intCast(@as(c_int, 2)))]); + _ = &x_1; + var y_2: f32 = ((col0[@as(c_uint, @intCast(@as(c_int, 1)))] * n[@as(c_uint, @intCast(@as(c_int, 0)))]) + (col1[@as(c_uint, @intCast(@as(c_int, 1)))] * n[@as(c_uint, @intCast(@as(c_int, 1)))])) + (col2[@as(c_uint, @intCast(@as(c_int, 1)))] * n[@as(c_uint, @intCast(@as(c_int, 2)))]); + _ = &y_2; + var z_3: f32 = ((col0[@as(c_uint, @intCast(@as(c_int, 2)))] * n[@as(c_uint, @intCast(@as(c_int, 0)))]) + (col1[@as(c_uint, @intCast(@as(c_int, 2)))] * n[@as(c_uint, @intCast(@as(c_int, 1)))])) + (col2[@as(c_uint, @intCast(@as(c_int, 2)))] * n[@as(c_uint, @intCast(@as(c_int, 2)))]); + _ = &z_3; + n[@as(c_uint, @intCast(@as(c_int, 0)))] = x_1; + n[@as(c_uint, @intCast(@as(c_int, 1)))] = y_2; + n[@as(c_uint, @intCast(@as(c_int, 2)))] = z_3; + } + } + } +} +pub export fn par_shapes_scale(arg_m: [*c]par_shapes_mesh, arg_x: f32, arg_y: f32, arg_z: f32) void { + var m = arg_m; + _ = &m; + var x = arg_x; + _ = &x; + var y = arg_y; + _ = &y; + var z = arg_z; + _ = &z; + var points: [*c]f32 = m.*.points; + _ = &points; + { + var i: c_int = 0; + _ = &i; + while (i < m.*.npoints) : (i += 1) { + (blk: { + const ref = &points; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* *= x; + (blk: { + const ref = &points; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* *= y; + (blk: { + const ref = &points; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* *= z; + } + } + var n: [*c]f32 = m.*.normals; + _ = &n; + if ((n != null) and !((x == y) and (y == z))) { + var x_zero: bool = x == @as(f32, @floatFromInt(@as(c_int, 0))); + _ = &x_zero; + var y_zero: bool = y == @as(f32, @floatFromInt(@as(c_int, 0))); + _ = &y_zero; + var z_zero: bool = z == @as(f32, @floatFromInt(@as(c_int, 0))); + _ = &z_zero; + if ((!x_zero and !y_zero) and !z_zero) { + x = 1.0 / x; + y = 1.0 / y; + z = 1.0 / z; + } else { + x = @as(f32, @floatFromInt(@intFromBool(((@as(c_int, @intFromBool(x_zero)) != 0) and !y_zero) and !z_zero))); + y = @as(f32, @floatFromInt(@intFromBool(((@as(c_int, @intFromBool(y_zero)) != 0) and !x_zero) and !z_zero))); + z = @as(f32, @floatFromInt(@intFromBool(((@as(c_int, @intFromBool(z_zero)) != 0) and !x_zero) and !y_zero))); + } + { + var i: c_int = 0; + _ = &i; + while (i < m.*.npoints) : (_ = blk: { + i += 1; + break :blk blk_1: { + const ref = &n; + ref.* += @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 3))))); + break :blk_1 ref.*; + }; + }) { + n[@as(c_uint, @intCast(@as(c_int, 0)))] *= x; + n[@as(c_uint, @intCast(@as(c_int, 1)))] *= y; + n[@as(c_uint, @intCast(@as(c_int, 2)))] *= z; + par_shapes__normalize3(n); + } + } + } +} +pub export fn par_shapes_merge_and_free(arg_dst: [*c]par_shapes_mesh, arg_src: [*c]par_shapes_mesh) void { + var dst = arg_dst; + _ = &dst; + var src = arg_src; + _ = &src; + par_shapes_merge(dst, src); + par_shapes_free_mesh(src); +} +pub export fn par_shapes_invert(arg_m: [*c]par_shapes_mesh, arg_face: c_int, arg_nfaces: c_int) void { + var m = arg_m; + _ = &m; + var face = arg_face; + _ = &face; + var nfaces = arg_nfaces; + _ = &nfaces; + nfaces = if (nfaces != 0) nfaces else m.*.ntriangles; + var tri: [*c]u16 = m.*.triangles + @as(usize, @bitCast(@as(isize, @intCast(face * @as(c_int, 3))))); + _ = &tri; + { + var i: c_int = 0; + _ = &i; + while (i < nfaces) : (i += 1) { + { + var tmp: u16 = tri[@as(c_uint, @intCast(@as(c_int, 2)))]; + _ = &tmp; + tri[@as(c_uint, @intCast(@as(c_int, 2)))] = tri[@as(c_uint, @intCast(@as(c_int, 0)))]; + tri[@as(c_uint, @intCast(@as(c_int, 0)))] = tmp; + } + tri += @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 3))))); + } + } +} +pub export fn par_shapes_remove_degenerate(arg_mesh: [*c]par_shapes_mesh, arg_mintriarea: f32) void { + var mesh = arg_mesh; + _ = &mesh; + var mintriarea = arg_mintriarea; + _ = &mintriarea; + var ntriangles: c_int = 0; + _ = &ntriangles; + var triangles: [*c]u16 = @as([*c]u16, @ptrCast(@alignCast(malloc(@as(c_ulong, @bitCast(@as(c_long, mesh.*.ntriangles * @as(c_int, 3)))) *% @sizeOf(u16))))); + _ = &triangles; + var dst: [*c]u16 = triangles; + _ = &dst; + var src: [*c]const u16 = mesh.*.triangles; + _ = &src; + var next: [3]f32 = undefined; + _ = &next; + var prev: [3]f32 = undefined; + _ = &prev; + var cp: [3]f32 = undefined; + _ = &cp; + var mincplen2: f32 = (mintriarea * @as(f32, @floatFromInt(@as(c_int, 2)))) * (mintriarea * @as(f32, @floatFromInt(@as(c_int, 2)))); + _ = &mincplen2; + { + var f: c_int = 0; + _ = &f; + while (f < mesh.*.ntriangles) : (_ = blk: { + f += 1; + break :blk blk_1: { + const ref = &src; + ref.* += @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 3))))); + break :blk_1 ref.*; + }; + }) { + var pa: [*c]const f32 = mesh.*.points + @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 3) * @as(c_int, @bitCast(@as(c_uint, src[@as(c_uint, @intCast(@as(c_int, 0)))]))))))); + _ = &pa; + var pb: [*c]const f32 = mesh.*.points + @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 3) * @as(c_int, @bitCast(@as(c_uint, src[@as(c_uint, @intCast(@as(c_int, 1)))]))))))); + _ = &pb; + var pc: [*c]const f32 = mesh.*.points + @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 3) * @as(c_int, @bitCast(@as(c_uint, src[@as(c_uint, @intCast(@as(c_int, 2)))]))))))); + _ = &pc; + par_shapes__copy3(@as([*c]f32, @ptrCast(@alignCast(&next))), pb); + par_shapes__subtract3(@as([*c]f32, @ptrCast(@alignCast(&next))), pa); + par_shapes__copy3(@as([*c]f32, @ptrCast(@alignCast(&prev))), pc); + par_shapes__subtract3(@as([*c]f32, @ptrCast(@alignCast(&prev))), pa); + par_shapes__cross3(@as([*c]f32, @ptrCast(@alignCast(&cp))), @as([*c]f32, @ptrCast(@alignCast(&next))), @as([*c]f32, @ptrCast(@alignCast(&prev)))); + var cplen2: f32 = par_shapes__dot3(@as([*c]f32, @ptrCast(@alignCast(&cp))), @as([*c]f32, @ptrCast(@alignCast(&cp)))); + _ = &cplen2; + if (cplen2 >= mincplen2) { + (blk: { + const ref = &dst; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = src[@as(c_uint, @intCast(@as(c_int, 0)))]; + (blk: { + const ref = &dst; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = src[@as(c_uint, @intCast(@as(c_int, 1)))]; + (blk: { + const ref = &dst; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = src[@as(c_uint, @intCast(@as(c_int, 2)))]; + ntriangles += 1; + } + } + } + mesh.*.ntriangles = ntriangles; + free(@as(?*anyopaque, @ptrCast(mesh.*.triangles))); + mesh.*.triangles = triangles; +} +pub export fn par_shapes_unweld(arg_mesh: [*c]par_shapes_mesh, arg_create_indices: bool) void { + var mesh = arg_mesh; + _ = &mesh; + var create_indices = arg_create_indices; + _ = &create_indices; + var npoints: c_int = mesh.*.ntriangles * @as(c_int, 3); + _ = &npoints; + var points: [*c]f32 = @as([*c]f32, @ptrCast(@alignCast(malloc(@as(c_ulong, @bitCast(@as(c_long, @as(c_int, 3) * npoints))) *% @sizeOf(f32))))); + _ = &points; + var dst: [*c]f32 = points; + _ = &dst; + var index_1: [*c]const u16 = mesh.*.triangles; + _ = &index_1; + { + var i: c_int = 0; + _ = &i; + while (i < npoints) : (i += 1) { + var src: [*c]const f32 = mesh.*.points + @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 3) * @as(c_int, @bitCast(@as(c_uint, (blk: { + const ref = &index_1; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).*))))))); + _ = &src; + (blk: { + const ref = &dst; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = src[@as(c_uint, @intCast(@as(c_int, 0)))]; + (blk: { + const ref = &dst; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = src[@as(c_uint, @intCast(@as(c_int, 1)))]; + (blk: { + const ref = &dst; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = src[@as(c_uint, @intCast(@as(c_int, 2)))]; + } + } + free(@as(?*anyopaque, @ptrCast(mesh.*.points))); + mesh.*.points = points; + mesh.*.npoints = npoints; + if (create_indices) { + var tris: [*c]u16 = @as([*c]u16, @ptrCast(@alignCast(malloc(@as(c_ulong, @bitCast(@as(c_long, @as(c_int, 3) * mesh.*.ntriangles))) *% @sizeOf(u16))))); + _ = &tris; + var index_2: [*c]u16 = tris; + _ = &index_2; + { + var i: c_int = 0; + _ = &i; + while (i < (mesh.*.ntriangles * @as(c_int, 3))) : (i += 1) { + (blk: { + const ref = &index_2; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = @as(u16, @bitCast(@as(c_short, @truncate(i)))); + } + } + free(@as(?*anyopaque, @ptrCast(mesh.*.triangles))); + mesh.*.triangles = tris; + } +} +pub export fn par_shapes_weld(arg_mesh: [*c]const par_shapes_mesh, arg_epsilon: f32, arg_weldmap: [*c]u16) [*c]par_shapes_mesh { + var mesh = arg_mesh; + _ = &mesh; + var epsilon = arg_epsilon; + _ = ε + var weldmap = arg_weldmap; + _ = &weldmap; + var clone: [*c]par_shapes_mesh = par_shapes_clone(mesh, null); + _ = &clone; + var aabb: [6]f32 = undefined; + _ = &aabb; + var gridsize: c_int = 20; + _ = &gridsize; + var maxcell: f32 = @as(f32, @floatFromInt(gridsize - @as(c_int, 1))); + _ = &maxcell; + par_shapes_compute_aabb(clone, @as([*c]f32, @ptrCast(@alignCast(&aabb)))); + var scale: [3]f32 = [3]f32{ + if (aabb[@as(c_uint, @intCast(@as(c_int, 3)))] == aabb[@as(c_uint, @intCast(@as(c_int, 0)))]) 1.0 else maxcell / (aabb[@as(c_uint, @intCast(@as(c_int, 3)))] - aabb[@as(c_uint, @intCast(@as(c_int, 0)))]), + if (aabb[@as(c_uint, @intCast(@as(c_int, 4)))] == aabb[@as(c_uint, @intCast(@as(c_int, 1)))]) 1.0 else maxcell / (aabb[@as(c_uint, @intCast(@as(c_int, 4)))] - aabb[@as(c_uint, @intCast(@as(c_int, 1)))]), + if (aabb[@as(c_uint, @intCast(@as(c_int, 5)))] == aabb[@as(c_uint, @intCast(@as(c_int, 2)))]) 1.0 else maxcell / (aabb[@as(c_uint, @intCast(@as(c_int, 5)))] - aabb[@as(c_uint, @intCast(@as(c_int, 2)))]), + }; + _ = &scale; + par_shapes_translate(clone, -aabb[@as(c_uint, @intCast(@as(c_int, 0)))], -aabb[@as(c_uint, @intCast(@as(c_int, 1)))], -aabb[@as(c_uint, @intCast(@as(c_int, 2)))]); + par_shapes_scale(clone, scale[@as(c_uint, @intCast(@as(c_int, 0)))], scale[@as(c_uint, @intCast(@as(c_int, 1)))], scale[@as(c_uint, @intCast(@as(c_int, 2)))]); + var sortmap: [*c]u16 = @as([*c]u16, @ptrCast(@alignCast(malloc(@as(c_ulong, @bitCast(@as(c_long, mesh.*.npoints))) *% @sizeOf(u16))))); + _ = &sortmap; + par_shapes__sort_points(clone, gridsize, sortmap); + var owner: bool = @as(c_int, 0) != 0; + _ = &owner; + if (!(weldmap != null)) { + owner = @as(c_int, 1) != 0; + weldmap = @as([*c]u16, @ptrCast(@alignCast(malloc(@as(c_ulong, @bitCast(@as(c_long, mesh.*.npoints))) *% @sizeOf(u16))))); + } + { + var i: c_int = 0; + _ = &i; + while (i < mesh.*.npoints) : (i += 1) { + (blk: { + const tmp = i; + if (tmp >= 0) break :blk weldmap + @as(usize, @intCast(tmp)) else break :blk weldmap - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = @as(u16, @bitCast(@as(c_short, @truncate(i)))); + } + } + par_shapes__weld_points(clone, gridsize, epsilon, weldmap); + if (owner) { + free(@as(?*anyopaque, @ptrCast(weldmap))); + } else { + var newmap: [*c]u16 = @as([*c]u16, @ptrCast(@alignCast(malloc(@as(c_ulong, @bitCast(@as(c_long, mesh.*.npoints))) *% @sizeOf(u16))))); + _ = &newmap; + { + var i: c_int = 0; + _ = &i; + while (i < mesh.*.npoints) : (i += 1) { + (blk: { + const tmp = i; + if (tmp >= 0) break :blk newmap + @as(usize, @intCast(tmp)) else break :blk newmap - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = weldmap[(blk: { + const tmp = i; + if (tmp >= 0) break :blk sortmap + @as(usize, @intCast(tmp)) else break :blk sortmap - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*]; + } + } + _ = memcpy(@as(?*anyopaque, @ptrCast(weldmap)), @as(?*const anyopaque, @ptrCast(newmap)), @sizeOf(u16) *% @as(c_ulong, @bitCast(@as(c_long, mesh.*.npoints)))); + free(@as(?*anyopaque, @ptrCast(newmap))); + } + free(@as(?*anyopaque, @ptrCast(sortmap))); + par_shapes_scale(clone, @as(f32, @floatCast(1.0 / @as(f64, @floatCast(scale[@as(c_uint, @intCast(@as(c_int, 0)))])))), @as(f32, @floatCast(1.0 / @as(f64, @floatCast(scale[@as(c_uint, @intCast(@as(c_int, 1)))])))), @as(f32, @floatCast(1.0 / @as(f64, @floatCast(scale[@as(c_uint, @intCast(@as(c_int, 2)))]))))); + par_shapes_translate(clone, aabb[@as(c_uint, @intCast(@as(c_int, 0)))], aabb[@as(c_uint, @intCast(@as(c_int, 1)))], aabb[@as(c_uint, @intCast(@as(c_int, 2)))]); + return clone; +} +pub export fn par_shapes_compute_normals(arg_m: [*c]par_shapes_mesh) void { + var m = arg_m; + _ = &m; + free(@as(?*anyopaque, @ptrCast(m.*.normals))); + m.*.normals = @as([*c]f32, @ptrCast(@alignCast(calloc(@as(c_ulong, @bitCast(@as(c_long, m.*.npoints * @as(c_int, 3)))) *% @sizeOf(f32), @as(c_ulong, @bitCast(@as(c_long, @as(c_int, 1)))))))); + var triangle: [*c]const u16 = m.*.triangles; + _ = ▵ + var next: [3]f32 = undefined; + _ = &next; + var prev: [3]f32 = undefined; + _ = &prev; + var cp: [3]f32 = undefined; + _ = &cp; + { + var f: c_int = 0; + _ = &f; + while (f < m.*.ntriangles) : (_ = blk: { + f += 1; + break :blk blk_1: { + const ref = ▵ + ref.* += @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 3))))); + break :blk_1 ref.*; + }; + }) { + var pa: [*c]const f32 = m.*.points + @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 3) * @as(c_int, @bitCast(@as(c_uint, triangle[@as(c_uint, @intCast(@as(c_int, 0)))]))))))); + _ = &pa; + var pb: [*c]const f32 = m.*.points + @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 3) * @as(c_int, @bitCast(@as(c_uint, triangle[@as(c_uint, @intCast(@as(c_int, 1)))]))))))); + _ = &pb; + var pc: [*c]const f32 = m.*.points + @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 3) * @as(c_int, @bitCast(@as(c_uint, triangle[@as(c_uint, @intCast(@as(c_int, 2)))]))))))); + _ = &pc; + par_shapes__copy3(@as([*c]f32, @ptrCast(@alignCast(&next))), pb); + par_shapes__subtract3(@as([*c]f32, @ptrCast(@alignCast(&next))), pa); + par_shapes__copy3(@as([*c]f32, @ptrCast(@alignCast(&prev))), pc); + par_shapes__subtract3(@as([*c]f32, @ptrCast(@alignCast(&prev))), pa); + par_shapes__cross3(@as([*c]f32, @ptrCast(@alignCast(&cp))), @as([*c]f32, @ptrCast(@alignCast(&next))), @as([*c]f32, @ptrCast(@alignCast(&prev)))); + par_shapes__add3(m.*.normals + @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 3) * @as(c_int, @bitCast(@as(c_uint, triangle[@as(c_uint, @intCast(@as(c_int, 0)))]))))))), @as([*c]f32, @ptrCast(@alignCast(&cp)))); + par_shapes__copy3(@as([*c]f32, @ptrCast(@alignCast(&next))), pc); + par_shapes__subtract3(@as([*c]f32, @ptrCast(@alignCast(&next))), pb); + par_shapes__copy3(@as([*c]f32, @ptrCast(@alignCast(&prev))), pa); + par_shapes__subtract3(@as([*c]f32, @ptrCast(@alignCast(&prev))), pb); + par_shapes__cross3(@as([*c]f32, @ptrCast(@alignCast(&cp))), @as([*c]f32, @ptrCast(@alignCast(&next))), @as([*c]f32, @ptrCast(@alignCast(&prev)))); + par_shapes__add3(m.*.normals + @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 3) * @as(c_int, @bitCast(@as(c_uint, triangle[@as(c_uint, @intCast(@as(c_int, 1)))]))))))), @as([*c]f32, @ptrCast(@alignCast(&cp)))); + par_shapes__copy3(@as([*c]f32, @ptrCast(@alignCast(&next))), pa); + par_shapes__subtract3(@as([*c]f32, @ptrCast(@alignCast(&next))), pc); + par_shapes__copy3(@as([*c]f32, @ptrCast(@alignCast(&prev))), pb); + par_shapes__subtract3(@as([*c]f32, @ptrCast(@alignCast(&prev))), pc); + par_shapes__cross3(@as([*c]f32, @ptrCast(@alignCast(&cp))), @as([*c]f32, @ptrCast(@alignCast(&next))), @as([*c]f32, @ptrCast(@alignCast(&prev)))); + par_shapes__add3(m.*.normals + @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 3) * @as(c_int, @bitCast(@as(c_uint, triangle[@as(c_uint, @intCast(@as(c_int, 2)))]))))))), @as([*c]f32, @ptrCast(@alignCast(&cp)))); + } + } + var normal: [*c]f32 = m.*.normals; + _ = &normal; + { + var p: c_int = 0; + _ = &p; + while (p < m.*.npoints) : (_ = blk: { + p += 1; + break :blk blk_1: { + const ref = &normal; + ref.* += @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 3))))); + break :blk_1 ref.*; + }; + }) { + par_shapes__normalize3(normal); + } + } +} +pub export fn par_shapes_set_epsilon_welded_normals(arg_epsilon: f32) void { + var epsilon = arg_epsilon; + _ = ε + par_shapes__epsilon_welded_normals = epsilon; +} +pub export fn par_shapes_set_epsilon_degenerate_sphere(arg_epsilon: f32) void { + var epsilon = arg_epsilon; + _ = ε + par_shapes__epsilon_degenerate_sphere = epsilon; +} +pub export fn par_shapes__compute_welded_normals(arg_m: [*c]par_shapes_mesh) void { + var m = arg_m; + _ = &m; + const epsilon: f32 = par_shapes__epsilon_welded_normals; + _ = ε + m.*.normals = @as([*c]f32, @ptrCast(@alignCast(malloc(@as(c_ulong, @bitCast(@as(c_long, m.*.npoints * @as(c_int, 3)))) *% @sizeOf(f32))))); + var weldmap: [*c]u16 = @as([*c]u16, @ptrCast(@alignCast(malloc(@as(c_ulong, @bitCast(@as(c_long, m.*.npoints))) *% @sizeOf(u16))))); + _ = &weldmap; + var welded: [*c]par_shapes_mesh = par_shapes_weld(m, epsilon, weldmap); + _ = &welded; + par_shapes_compute_normals(welded); + var pdst: [*c]f32 = m.*.normals; + _ = &pdst; + { + var i: c_int = 0; + _ = &i; + while (i < m.*.npoints) : (_ = blk: { + i += 1; + break :blk blk_1: { + const ref = &pdst; + ref.* += @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 3))))); + break :blk_1 ref.*; + }; + }) { + var d: c_int = @as(c_int, @bitCast(@as(c_uint, (blk: { + const tmp = i; + if (tmp >= 0) break :blk weldmap + @as(usize, @intCast(tmp)) else break :blk weldmap - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*))); + _ = &d; + var pnormal: [*c]const f32 = welded.*.normals + @as(usize, @bitCast(@as(isize, @intCast(d * @as(c_int, 3))))); + _ = &pnormal; + pdst[@as(c_uint, @intCast(@as(c_int, 0)))] = pnormal[@as(c_uint, @intCast(@as(c_int, 0)))]; + pdst[@as(c_uint, @intCast(@as(c_int, 1)))] = pnormal[@as(c_uint, @intCast(@as(c_int, 1)))]; + pdst[@as(c_uint, @intCast(@as(c_int, 2)))] = pnormal[@as(c_uint, @intCast(@as(c_int, 2)))]; + } + } + free(@as(?*anyopaque, @ptrCast(weldmap))); + par_shapes_free_mesh(welded); +} +pub export fn par_shapes__connect(arg_scene: [*c]par_shapes_mesh, arg_cylinder: [*c]par_shapes_mesh, arg_slices: c_int) void { + var scene = arg_scene; + _ = &scene; + var cylinder = arg_cylinder; + _ = &cylinder; + var slices = arg_slices; + _ = &slices; + var stacks: c_int = 1; + _ = &stacks; + var npoints: c_int = (slices + @as(c_int, 1)) * (stacks + @as(c_int, 1)); + _ = &npoints; + _ = blk: { + _ = @sizeOf(c_int); + break :blk blk_1: { + break :blk_1 if ((scene.*.npoints >= npoints) and (@intFromPtr("Cannot connect to empty scene.") != 0)) {} else { + __assert_fail("scene->npoints >= npoints && \"Cannot connect to empty scene.\"", "./external/par_shapes.h", @as(c_uint, @bitCast(@as(c_int, 1184))), "void par_shapes__connect(par_shapes_mesh *, par_shapes_mesh *, int)"); + }; + }; + }; + npoints = scene.*.npoints + (slices + @as(c_int, 1)); + var points: [*c]f32 = @as([*c]f32, @ptrCast(@alignCast(malloc(@as(c_ulong, @bitCast(@as(c_long, npoints * @as(c_int, 3)))) *% @sizeOf(f32))))); + _ = &points; + _ = memcpy(@as(?*anyopaque, @ptrCast(points)), @as(?*const anyopaque, @ptrCast(scene.*.points)), (@sizeOf(f32) *% @as(c_ulong, @bitCast(@as(c_long, scene.*.npoints)))) *% @as(c_ulong, @bitCast(@as(c_long, @as(c_int, 3))))); + var newpts: [*c]f32 = points + @as(usize, @bitCast(@as(isize, @intCast(scene.*.npoints * @as(c_int, 3))))); + _ = &newpts; + _ = memcpy(@as(?*anyopaque, @ptrCast(newpts)), @as(?*const anyopaque, @ptrCast(cylinder.*.points + @as(usize, @bitCast(@as(isize, @intCast((slices + @as(c_int, 1)) * @as(c_int, 3))))))), (@sizeOf(f32) *% @as(c_ulong, @bitCast(@as(c_long, slices + @as(c_int, 1))))) *% @as(c_ulong, @bitCast(@as(c_long, @as(c_int, 3))))); + free(@as(?*anyopaque, @ptrCast(scene.*.points))); + scene.*.points = points; + var ntriangles: c_int = scene.*.ntriangles + ((@as(c_int, 2) * slices) * stacks); + _ = &ntriangles; + var triangles: [*c]u16 = @as([*c]u16, @ptrCast(@alignCast(malloc(@as(c_ulong, @bitCast(@as(c_long, ntriangles * @as(c_int, 3)))) *% @sizeOf(u16))))); + _ = &triangles; + _ = memcpy(@as(?*anyopaque, @ptrCast(triangles)), @as(?*const anyopaque, @ptrCast(scene.*.triangles)), (@sizeOf(u16) *% @as(c_ulong, @bitCast(@as(c_long, scene.*.ntriangles)))) *% @as(c_ulong, @bitCast(@as(c_long, @as(c_int, 3))))); + var v: c_int = scene.*.npoints - (slices + @as(c_int, 1)); + _ = &v; + var face: [*c]u16 = triangles + @as(usize, @bitCast(@as(isize, @intCast(scene.*.ntriangles * @as(c_int, 3))))); + _ = &face; + { + var stack: c_int = 0; + _ = &stack; + while (stack < stacks) : (stack += 1) { + { + var slice: c_int = 0; + _ = &slice; + while (slice < slices) : (slice += 1) { + var next: c_int = slice + @as(c_int, 1); + _ = &next; + (blk: { + const ref = &face; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = @as(u16, @bitCast(@as(c_short, @truncate(((v + slice) + slices) + @as(c_int, 1))))); + (blk: { + const ref = &face; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = @as(u16, @bitCast(@as(c_short, @truncate(v + next)))); + (blk: { + const ref = &face; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = @as(u16, @bitCast(@as(c_short, @truncate(v + slice)))); + (blk: { + const ref = &face; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = @as(u16, @bitCast(@as(c_short, @truncate(((v + slice) + slices) + @as(c_int, 1))))); + (blk: { + const ref = &face; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = @as(u16, @bitCast(@as(c_short, @truncate(((v + next) + slices) + @as(c_int, 1))))); + (blk: { + const ref = &face; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = @as(u16, @bitCast(@as(c_short, @truncate(v + next)))); + } + } + v += slices + @as(c_int, 1); + } + } + free(@as(?*anyopaque, @ptrCast(scene.*.triangles))); + scene.*.triangles = triangles; + scene.*.npoints = npoints; + scene.*.ntriangles = ntriangles; +} +pub var par_shapes__epsilon_welded_normals: f32 = @as(f32, @floatCast(0.001)); +pub var par_shapes__epsilon_degenerate_sphere: f32 = @as(f32, @floatCast(0.0001)); +pub fn par_shapes__sphere(arg_uv: [*c]const f32, arg_xyz: [*c]f32, arg_userdata: ?*anyopaque) callconv(.C) void { + var uv = arg_uv; + _ = &uv; + var xyz = arg_xyz; + _ = &xyz; + var userdata = arg_userdata; + _ = &userdata; + var phi: f32 = @as(f32, @floatCast(@as(f64, @floatCast(uv[@as(c_uint, @intCast(@as(c_int, 0)))])) * 3.14159265359)); + _ = φ + var theta: f32 = @as(f32, @floatCast(@as(f64, @floatCast(uv[@as(c_uint, @intCast(@as(c_int, 1)))] * @as(f32, @floatFromInt(@as(c_int, 2))))) * 3.14159265359)); + _ = θ + xyz[@as(c_uint, @intCast(@as(c_int, 0)))] = cosf(theta) * sinf(phi); + xyz[@as(c_uint, @intCast(@as(c_int, 1)))] = sinf(theta) * sinf(phi); + xyz[@as(c_uint, @intCast(@as(c_int, 2)))] = cosf(phi); +} +pub fn par_shapes__hemisphere(arg_uv: [*c]const f32, arg_xyz: [*c]f32, arg_userdata: ?*anyopaque) callconv(.C) void { + var uv = arg_uv; + _ = &uv; + var xyz = arg_xyz; + _ = &xyz; + var userdata = arg_userdata; + _ = &userdata; + var phi: f32 = @as(f32, @floatCast(@as(f64, @floatCast(uv[@as(c_uint, @intCast(@as(c_int, 0)))])) * 3.14159265359)); + _ = φ + var theta: f32 = @as(f32, @floatCast(@as(f64, @floatCast(uv[@as(c_uint, @intCast(@as(c_int, 1)))])) * 3.14159265359)); + _ = θ + xyz[@as(c_uint, @intCast(@as(c_int, 0)))] = cosf(theta) * sinf(phi); + xyz[@as(c_uint, @intCast(@as(c_int, 1)))] = sinf(theta) * sinf(phi); + xyz[@as(c_uint, @intCast(@as(c_int, 2)))] = cosf(phi); +} +pub fn par_shapes__plane(arg_uv: [*c]const f32, arg_xyz: [*c]f32, arg_userdata: ?*anyopaque) callconv(.C) void { + var uv = arg_uv; + _ = &uv; + var xyz = arg_xyz; + _ = &xyz; + var userdata = arg_userdata; + _ = &userdata; + xyz[@as(c_uint, @intCast(@as(c_int, 0)))] = uv[@as(c_uint, @intCast(@as(c_int, 0)))]; + xyz[@as(c_uint, @intCast(@as(c_int, 1)))] = uv[@as(c_uint, @intCast(@as(c_int, 1)))]; + xyz[@as(c_uint, @intCast(@as(c_int, 2)))] = 0; +} +pub fn par_shapes__klein(arg_uv: [*c]const f32, arg_xyz: [*c]f32, arg_userdata: ?*anyopaque) callconv(.C) void { + var uv = arg_uv; + _ = &uv; + var xyz = arg_xyz; + _ = &xyz; + var userdata = arg_userdata; + _ = &userdata; + var u: f32 = @as(f32, @floatCast(@as(f64, @floatCast(uv[@as(c_uint, @intCast(@as(c_int, 0)))])) * 3.14159265359)); + _ = &u; + var v: f32 = @as(f32, @floatCast(@as(f64, @floatCast(uv[@as(c_uint, @intCast(@as(c_int, 1)))] * @as(f32, @floatFromInt(@as(c_int, 2))))) * 3.14159265359)); + _ = &v; + u = u * @as(f32, @floatFromInt(@as(c_int, 2))); + if (@as(f64, @floatCast(u)) < 3.14159265359) { + xyz[@as(c_uint, @intCast(@as(c_int, 0)))] = ((@as(f32, @floatFromInt(@as(c_int, 3))) * cosf(u)) * (@as(f32, @floatFromInt(@as(c_int, 1))) + sinf(u))) + (((@as(f32, @floatFromInt(@as(c_int, 2))) * (@as(f32, @floatFromInt(@as(c_int, 1))) - (cosf(u) / @as(f32, @floatFromInt(@as(c_int, 2)))))) * cosf(u)) * cosf(v)); + xyz[@as(c_uint, @intCast(@as(c_int, 2)))] = (@as(f32, @floatFromInt(-@as(c_int, 8))) * sinf(u)) - (((@as(f32, @floatFromInt(@as(c_int, 2))) * (@as(f32, @floatFromInt(@as(c_int, 1))) - (cosf(u) / @as(f32, @floatFromInt(@as(c_int, 2)))))) * sinf(u)) * cosf(v)); + } else { + xyz[@as(c_uint, @intCast(@as(c_int, 0)))] = ((@as(f32, @floatFromInt(@as(c_int, 3))) * cosf(u)) * (@as(f32, @floatFromInt(@as(c_int, 1))) + sinf(u))) + ((@as(f32, @floatFromInt(@as(c_int, 2))) * (@as(f32, @floatFromInt(@as(c_int, 1))) - (cosf(u) / @as(f32, @floatFromInt(@as(c_int, 2)))))) * cosf(@as(f32, @floatCast(@as(f64, @floatCast(v)) + 3.14159265359)))); + xyz[@as(c_uint, @intCast(@as(c_int, 2)))] = @as(f32, @floatFromInt(-@as(c_int, 8))) * sinf(u); + } + xyz[@as(c_uint, @intCast(@as(c_int, 1)))] = (@as(f32, @floatFromInt(-@as(c_int, 2))) * (@as(f32, @floatFromInt(@as(c_int, 1))) - (cosf(u) / @as(f32, @floatFromInt(@as(c_int, 2)))))) * sinf(v); +} +pub fn par_shapes__cylinder(arg_uv: [*c]const f32, arg_xyz: [*c]f32, arg_userdata: ?*anyopaque) callconv(.C) void { + var uv = arg_uv; + _ = &uv; + var xyz = arg_xyz; + _ = &xyz; + var userdata = arg_userdata; + _ = &userdata; + var theta: f32 = @as(f32, @floatCast(@as(f64, @floatCast(uv[@as(c_uint, @intCast(@as(c_int, 1)))] * @as(f32, @floatFromInt(@as(c_int, 2))))) * 3.14159265359)); + _ = θ + xyz[@as(c_uint, @intCast(@as(c_int, 0)))] = sinf(theta); + xyz[@as(c_uint, @intCast(@as(c_int, 1)))] = cosf(theta); + xyz[@as(c_uint, @intCast(@as(c_int, 2)))] = uv[@as(c_uint, @intCast(@as(c_int, 0)))]; +} +pub fn par_shapes__cone(arg_uv: [*c]const f32, arg_xyz: [*c]f32, arg_userdata: ?*anyopaque) callconv(.C) void { + var uv = arg_uv; + _ = &uv; + var xyz = arg_xyz; + _ = &xyz; + var userdata = arg_userdata; + _ = &userdata; + var r: f32 = 1.0 - uv[@as(c_uint, @intCast(@as(c_int, 0)))]; + _ = &r; + var theta: f32 = @as(f32, @floatCast(@as(f64, @floatCast(uv[@as(c_uint, @intCast(@as(c_int, 1)))] * @as(f32, @floatFromInt(@as(c_int, 2))))) * 3.14159265359)); + _ = θ + xyz[@as(c_uint, @intCast(@as(c_int, 0)))] = r * sinf(theta); + xyz[@as(c_uint, @intCast(@as(c_int, 1)))] = r * cosf(theta); + xyz[@as(c_uint, @intCast(@as(c_int, 2)))] = uv[@as(c_uint, @intCast(@as(c_int, 0)))]; +} +pub fn par_shapes__torus(arg_uv: [*c]const f32, arg_xyz: [*c]f32, arg_userdata: ?*anyopaque) callconv(.C) void { + var uv = arg_uv; + _ = &uv; + var xyz = arg_xyz; + _ = &xyz; + var userdata = arg_userdata; + _ = &userdata; + var major: f32 = 1; + _ = &major; + var minor: f32 = @as([*c]f32, @ptrCast(@alignCast(userdata))).*; + _ = &minor; + var theta: f32 = @as(f32, @floatCast(@as(f64, @floatCast(uv[@as(c_uint, @intCast(@as(c_int, 0)))] * @as(f32, @floatFromInt(@as(c_int, 2))))) * 3.14159265359)); + _ = θ + var phi: f32 = @as(f32, @floatCast(@as(f64, @floatCast(uv[@as(c_uint, @intCast(@as(c_int, 1)))] * @as(f32, @floatFromInt(@as(c_int, 2))))) * 3.14159265359)); + _ = φ + var beta: f32 = major + (minor * cosf(phi)); + _ = β + xyz[@as(c_uint, @intCast(@as(c_int, 0)))] = cosf(theta) * beta; + xyz[@as(c_uint, @intCast(@as(c_int, 1)))] = sinf(theta) * beta; + xyz[@as(c_uint, @intCast(@as(c_int, 2)))] = sinf(phi) * minor; +} +pub fn par_shapes__trefoil(arg_uv: [*c]const f32, arg_xyz: [*c]f32, arg_userdata: ?*anyopaque) callconv(.C) void { + var uv = arg_uv; + _ = &uv; + var xyz = arg_xyz; + _ = &xyz; + var userdata = arg_userdata; + _ = &userdata; + var minor: f32 = @as([*c]f32, @ptrCast(@alignCast(userdata))).*; + _ = &minor; + const a: f32 = 0.5; + _ = &a; + const b: f32 = 0.30000001192092896; + _ = &b; + const c: f32 = 0.5; + _ = &c; + const d: f32 = minor * 0.10000000149011612; + _ = &d; + const u: f32 = @as(f32, @floatCast(@as(f64, @floatCast((@as(f32, @floatFromInt(@as(c_int, 1))) - uv[@as(c_uint, @intCast(@as(c_int, 0)))]) * @as(f32, @floatFromInt(@as(c_int, 4))))) * 3.14159265359)); + _ = &u; + const v: f32 = @as(f32, @floatCast(@as(f64, @floatCast(uv[@as(c_uint, @intCast(@as(c_int, 1)))] * @as(f32, @floatFromInt(@as(c_int, 2))))) * 3.14159265359)); + _ = &v; + const r: f32 = @as(f32, @floatCast(@as(f64, @floatCast(a)) + (@as(f64, @floatCast(b)) * cos(@as(f64, @floatCast(1.5 * u)))))); + _ = &r; + const x: f32 = @as(f32, @floatCast(@as(f64, @floatCast(r)) * cos(@as(f64, @floatCast(u))))); + _ = &x; + const y: f32 = @as(f32, @floatCast(@as(f64, @floatCast(r)) * sin(@as(f64, @floatCast(u))))); + _ = &y; + const z: f32 = @as(f32, @floatCast(@as(f64, @floatCast(c)) * sin(@as(f64, @floatCast(1.5 * u))))); + _ = &z; + var q: [3]f32 = undefined; + _ = &q; + q[@as(c_uint, @intCast(@as(c_int, 0)))] = @as(f32, @floatCast(((@as(f64, @floatCast(-1.5 * b)) * sin(@as(f64, @floatCast(1.5 * u)))) * cos(@as(f64, @floatCast(u)))) - ((@as(f64, @floatCast(a)) + (@as(f64, @floatCast(b)) * cos(@as(f64, @floatCast(1.5 * u))))) * sin(@as(f64, @floatCast(u)))))); + q[@as(c_uint, @intCast(@as(c_int, 1)))] = @as(f32, @floatCast(((@as(f64, @floatCast(-1.5 * b)) * sin(@as(f64, @floatCast(1.5 * u)))) * sin(@as(f64, @floatCast(u)))) + ((@as(f64, @floatCast(a)) + (@as(f64, @floatCast(b)) * cos(@as(f64, @floatCast(1.5 * u))))) * cos(@as(f64, @floatCast(u)))))); + q[@as(c_uint, @intCast(@as(c_int, 2)))] = @as(f32, @floatCast(@as(f64, @floatCast(1.5 * c)) * cos(@as(f64, @floatCast(1.5 * u))))); + par_shapes__normalize3(@as([*c]f32, @ptrCast(@alignCast(&q)))); + var qvn: [3]f32 = [3]f32{ + q[@as(c_uint, @intCast(@as(c_int, 1)))], + -q[@as(c_uint, @intCast(@as(c_int, 0)))], + 0, + }; + _ = &qvn; + par_shapes__normalize3(@as([*c]f32, @ptrCast(@alignCast(&qvn)))); + var ww: [3]f32 = undefined; + _ = &ww; + par_shapes__cross3(@as([*c]f32, @ptrCast(@alignCast(&ww))), @as([*c]f32, @ptrCast(@alignCast(&q))), @as([*c]f32, @ptrCast(@alignCast(&qvn)))); + xyz[@as(c_uint, @intCast(@as(c_int, 0)))] = @as(f32, @floatCast(@as(f64, @floatCast(x)) + (@as(f64, @floatCast(d)) * ((@as(f64, @floatCast(qvn[@as(c_uint, @intCast(@as(c_int, 0)))])) * cos(@as(f64, @floatCast(v)))) + (@as(f64, @floatCast(ww[@as(c_uint, @intCast(@as(c_int, 0)))])) * sin(@as(f64, @floatCast(v)))))))); + xyz[@as(c_uint, @intCast(@as(c_int, 1)))] = @as(f32, @floatCast(@as(f64, @floatCast(y)) + (@as(f64, @floatCast(d)) * ((@as(f64, @floatCast(qvn[@as(c_uint, @intCast(@as(c_int, 1)))])) * cos(@as(f64, @floatCast(v)))) + (@as(f64, @floatCast(ww[@as(c_uint, @intCast(@as(c_int, 1)))])) * sin(@as(f64, @floatCast(v)))))))); + xyz[@as(c_uint, @intCast(@as(c_int, 2)))] = @as(f32, @floatCast(@as(f64, @floatCast(z)) + (@as(f64, @floatCast(d * ww[@as(c_uint, @intCast(@as(c_int, 2)))])) * sin(@as(f64, @floatCast(v)))))); +} +pub fn par__simplex_noise(arg_seed: i64, arg_ctx: [*c][*c]struct_osn_context) callconv(.C) c_int { + var seed = arg_seed; + _ = &seed; + var ctx = arg_ctx; + _ = &ctx; + var rc: c_int = undefined; + _ = &rc; + var source: [256]i16 = undefined; + _ = &source; + var i: c_int = undefined; + _ = &i; + var perm: [*c]i16 = undefined; + _ = &perm; + var permGradIndex3D: [*c]i16 = undefined; + _ = &permGradIndex3D; + ctx.* = @as([*c]struct_osn_context, @ptrCast(@alignCast(malloc(@as(c_ulong, @bitCast(@as(c_long, @as(c_int, 1)))) *% @sizeOf(struct_osn_context))))); + if (!(ctx.* != null)) { + return -@as(c_int, 12); + } + ctx.*.*.perm = null; + ctx.*.*.permGradIndex3D = null; + rc = allocate_perm(ctx.*, @as(c_int, 256), @as(c_int, 256)); + if (rc != 0) { + free(@as(?*anyopaque, @ptrCast(ctx.*))); + return rc; + } + perm = ctx.*.*.perm; + permGradIndex3D = ctx.*.*.permGradIndex3D; + { + i = 0; + while (i < @as(c_int, 256)) : (i += 1) { + source[@as(c_uint, @intCast(i))] = @as(i16, @bitCast(@as(c_short, @truncate(i)))); + } + } + seed = @as(i64, @bitCast(@as(c_long, @truncate((@as(c_longlong, @bitCast(@as(c_longlong, seed))) * @as(c_longlong, 6364136223846793005)) + @as(c_longlong, 1442695040888963407))))); + seed = @as(i64, @bitCast(@as(c_long, @truncate((@as(c_longlong, @bitCast(@as(c_longlong, seed))) * @as(c_longlong, 6364136223846793005)) + @as(c_longlong, 1442695040888963407))))); + seed = @as(i64, @bitCast(@as(c_long, @truncate((@as(c_longlong, @bitCast(@as(c_longlong, seed))) * @as(c_longlong, 6364136223846793005)) + @as(c_longlong, 1442695040888963407))))); + { + i = 255; + while (i >= @as(c_int, 0)) : (i -= 1) { + seed = @as(i64, @bitCast(@as(c_long, @truncate((@as(c_longlong, @bitCast(@as(c_longlong, seed))) * @as(c_longlong, 6364136223846793005)) + @as(c_longlong, 1442695040888963407))))); + var r: c_int = @as(c_int, @bitCast(@as(c_int, @truncate(@import("std").zig.c_translation.signedRemainder(seed + @as(i64, @bitCast(@as(c_long, @as(c_int, 31)))), @as(i64, @bitCast(@as(c_long, i + @as(c_int, 1))))))))); + _ = &r; + if (r < @as(c_int, 0)) { + r += i + @as(c_int, 1); + } + (blk: { + const tmp = i; + if (tmp >= 0) break :blk perm + @as(usize, @intCast(tmp)) else break :blk perm - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = source[@as(c_uint, @intCast(r))]; + (blk: { + const tmp = i; + if (tmp >= 0) break :blk permGradIndex3D + @as(usize, @intCast(tmp)) else break :blk permGradIndex3D - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = @as(c_short, @bitCast(@as(c_ushort, @truncate((@as(c_ulong, @bitCast(@as(c_long, (blk: { + const tmp = i; + if (tmp >= 0) break :blk perm + @as(usize, @intCast(tmp)) else break :blk perm - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*))) % ((@sizeOf([72]i8) / @sizeOf(i8)) / @as(c_ulong, @bitCast(@as(c_long, @as(c_int, 3)))))) *% @as(c_ulong, @bitCast(@as(c_long, @as(c_int, 3)))))))); + source[@as(c_uint, @intCast(r))] = source[@as(c_uint, @intCast(i))]; + } + } + return 0; +} +pub fn par__simplex_noise_free(arg_ctx: [*c]struct_osn_context) callconv(.C) void { + var ctx = arg_ctx; + _ = &ctx; + if (!(ctx != null)) return; + if (ctx.*.perm != null) { + free(@as(?*anyopaque, @ptrCast(ctx.*.perm))); + ctx.*.perm = null; + } + if (ctx.*.permGradIndex3D != null) { + free(@as(?*anyopaque, @ptrCast(ctx.*.permGradIndex3D))); + ctx.*.permGradIndex3D = null; + } + free(@as(?*anyopaque, @ptrCast(ctx))); +} +pub fn par__simplex_noise2(arg_ctx: [*c]struct_osn_context, arg_x: f64, arg_y: f64) callconv(.C) f64 { + var ctx = arg_ctx; + _ = &ctx; + var x = arg_x; + _ = &x; + var y = arg_y; + _ = &y; + var stretchOffset: f64 = (x + y) * -0.211324865405187; + _ = &stretchOffset; + var xs: f64 = x + stretchOffset; + _ = &xs; + var ys: f64 = y + stretchOffset; + _ = &ys; + var xsb: c_int = fastFloor(xs); + _ = &xsb; + var ysb: c_int = fastFloor(ys); + _ = &ysb; + var squishOffset: f64 = @as(f64, @floatFromInt(xsb + ysb)) * 0.366025403784439; + _ = &squishOffset; + var xb: f64 = @as(f64, @floatFromInt(xsb)) + squishOffset; + _ = &xb; + var yb: f64 = @as(f64, @floatFromInt(ysb)) + squishOffset; + _ = &yb; + var xins: f64 = xs - @as(f64, @floatFromInt(xsb)); + _ = &xins; + var yins: f64 = ys - @as(f64, @floatFromInt(ysb)); + _ = &yins; + var inSum: f64 = xins + yins; + _ = &inSum; + var dx0: f64 = x - xb; + _ = &dx0; + var dy0: f64 = y - yb; + _ = &dy0; + var dx_ext: f64 = undefined; + _ = &dx_ext; + var dy_ext: f64 = undefined; + _ = &dy_ext; + var xsv_ext: c_int = undefined; + _ = &xsv_ext; + var ysv_ext: c_int = undefined; + _ = &ysv_ext; + var value: f64 = 0; + _ = &value; + var dx1: f64 = (dx0 - @as(f64, @floatFromInt(@as(c_int, 1)))) - 0.366025403784439; + _ = &dx1; + var dy1: f64 = (dy0 - @as(f64, @floatFromInt(@as(c_int, 0)))) - 0.366025403784439; + _ = &dy1; + var attn1: f64 = (@as(f64, @floatFromInt(@as(c_int, 2))) - (dx1 * dx1)) - (dy1 * dy1); + _ = &attn1; + if (attn1 > @as(f64, @floatFromInt(@as(c_int, 0)))) { + attn1 *= attn1; + value += (attn1 * attn1) * extrapolate2(ctx, xsb + @as(c_int, 1), ysb + @as(c_int, 0), dx1, dy1); + } + var dx2: f64 = (dx0 - @as(f64, @floatFromInt(@as(c_int, 0)))) - 0.366025403784439; + _ = &dx2; + var dy2: f64 = (dy0 - @as(f64, @floatFromInt(@as(c_int, 1)))) - 0.366025403784439; + _ = &dy2; + var attn2: f64 = (@as(f64, @floatFromInt(@as(c_int, 2))) - (dx2 * dx2)) - (dy2 * dy2); + _ = &attn2; + if (attn2 > @as(f64, @floatFromInt(@as(c_int, 0)))) { + attn2 *= attn2; + value += (attn2 * attn2) * extrapolate2(ctx, xsb + @as(c_int, 0), ysb + @as(c_int, 1), dx2, dy2); + } + if (inSum <= @as(f64, @floatFromInt(@as(c_int, 1)))) { + var zins: f64 = @as(f64, @floatFromInt(@as(c_int, 1))) - inSum; + _ = &zins; + if ((zins > xins) or (zins > yins)) { + if (xins > yins) { + xsv_ext = xsb + @as(c_int, 1); + ysv_ext = ysb - @as(c_int, 1); + dx_ext = dx0 - @as(f64, @floatFromInt(@as(c_int, 1))); + dy_ext = dy0 + @as(f64, @floatFromInt(@as(c_int, 1))); + } else { + xsv_ext = xsb - @as(c_int, 1); + ysv_ext = ysb + @as(c_int, 1); + dx_ext = dx0 + @as(f64, @floatFromInt(@as(c_int, 1))); + dy_ext = dy0 - @as(f64, @floatFromInt(@as(c_int, 1))); + } + } else { + xsv_ext = xsb + @as(c_int, 1); + ysv_ext = ysb + @as(c_int, 1); + dx_ext = (dx0 - @as(f64, @floatFromInt(@as(c_int, 1)))) - (@as(f64, @floatFromInt(@as(c_int, 2))) * 0.366025403784439); + dy_ext = (dy0 - @as(f64, @floatFromInt(@as(c_int, 1)))) - (@as(f64, @floatFromInt(@as(c_int, 2))) * 0.366025403784439); + } + } else { + var zins: f64 = @as(f64, @floatFromInt(@as(c_int, 2))) - inSum; + _ = &zins; + if ((zins < xins) or (zins < yins)) { + if (xins > yins) { + xsv_ext = xsb + @as(c_int, 2); + ysv_ext = ysb + @as(c_int, 0); + dx_ext = (dx0 - @as(f64, @floatFromInt(@as(c_int, 2)))) - (@as(f64, @floatFromInt(@as(c_int, 2))) * 0.366025403784439); + dy_ext = (dy0 + @as(f64, @floatFromInt(@as(c_int, 0)))) - (@as(f64, @floatFromInt(@as(c_int, 2))) * 0.366025403784439); + } else { + xsv_ext = xsb + @as(c_int, 0); + ysv_ext = ysb + @as(c_int, 2); + dx_ext = (dx0 + @as(f64, @floatFromInt(@as(c_int, 0)))) - (@as(f64, @floatFromInt(@as(c_int, 2))) * 0.366025403784439); + dy_ext = (dy0 - @as(f64, @floatFromInt(@as(c_int, 2)))) - (@as(f64, @floatFromInt(@as(c_int, 2))) * 0.366025403784439); + } + } else { + dx_ext = dx0; + dy_ext = dy0; + xsv_ext = xsb; + ysv_ext = ysb; + } + xsb += @as(c_int, 1); + ysb += @as(c_int, 1); + dx0 = (dx0 - @as(f64, @floatFromInt(@as(c_int, 1)))) - (@as(f64, @floatFromInt(@as(c_int, 2))) * 0.366025403784439); + dy0 = (dy0 - @as(f64, @floatFromInt(@as(c_int, 1)))) - (@as(f64, @floatFromInt(@as(c_int, 2))) * 0.366025403784439); + } + var attn0: f64 = (@as(f64, @floatFromInt(@as(c_int, 2))) - (dx0 * dx0)) - (dy0 * dy0); + _ = &attn0; + if (attn0 > @as(f64, @floatFromInt(@as(c_int, 0)))) { + attn0 *= attn0; + value += (attn0 * attn0) * extrapolate2(ctx, xsb, ysb, dx0, dy0); + } + var attn_ext: f64 = (@as(f64, @floatFromInt(@as(c_int, 2))) - (dx_ext * dx_ext)) - (dy_ext * dy_ext); + _ = &attn_ext; + if (attn_ext > @as(f64, @floatFromInt(@as(c_int, 0)))) { + attn_ext *= attn_ext; + value += (attn_ext * attn_ext) * extrapolate2(ctx, xsv_ext, ysv_ext, dx_ext, dy_ext); + } + return value / 47.0; +} +pub fn par_shapes__copy3(arg_result: [*c]f32, arg_a: [*c]const f32) callconv(.C) void { + var result = arg_result; + _ = &result; + var a = arg_a; + _ = &a; + result[@as(c_uint, @intCast(@as(c_int, 0)))] = a[@as(c_uint, @intCast(@as(c_int, 0)))]; + result[@as(c_uint, @intCast(@as(c_int, 1)))] = a[@as(c_uint, @intCast(@as(c_int, 1)))]; + result[@as(c_uint, @intCast(@as(c_int, 2)))] = a[@as(c_uint, @intCast(@as(c_int, 2)))]; +} +pub fn par_shapes__dot3(arg_a: [*c]const f32, arg_b: [*c]const f32) callconv(.C) f32 { + var a = arg_a; + _ = &a; + var b = arg_b; + _ = &b; + return ((b[@as(c_uint, @intCast(@as(c_int, 0)))] * a[@as(c_uint, @intCast(@as(c_int, 0)))]) + (b[@as(c_uint, @intCast(@as(c_int, 1)))] * a[@as(c_uint, @intCast(@as(c_int, 1)))])) + (b[@as(c_uint, @intCast(@as(c_int, 2)))] * a[@as(c_uint, @intCast(@as(c_int, 2)))]); +} +pub fn par_shapes__transform3(arg_p: [*c]f32, arg_x: [*c]const f32, arg_y: [*c]const f32, arg_z: [*c]const f32) callconv(.C) void { + var p = arg_p; + _ = &p; + var x = arg_x; + _ = &x; + var y = arg_y; + _ = &y; + var z = arg_z; + _ = &z; + var px: f32 = par_shapes__dot3(p, x); + _ = &px; + var py: f32 = par_shapes__dot3(p, y); + _ = &py; + var pz: f32 = par_shapes__dot3(p, z); + _ = &pz; + p[@as(c_uint, @intCast(@as(c_int, 0)))] = px; + p[@as(c_uint, @intCast(@as(c_int, 1)))] = py; + p[@as(c_uint, @intCast(@as(c_int, 2)))] = pz; +} +pub fn par_shapes__cross3(arg_result: [*c]f32, arg_a: [*c]const f32, arg_b: [*c]const f32) callconv(.C) void { + var result = arg_result; + _ = &result; + var a = arg_a; + _ = &a; + var b = arg_b; + _ = &b; + var x: f32 = (a[@as(c_uint, @intCast(@as(c_int, 1)))] * b[@as(c_uint, @intCast(@as(c_int, 2)))]) - (a[@as(c_uint, @intCast(@as(c_int, 2)))] * b[@as(c_uint, @intCast(@as(c_int, 1)))]); + _ = &x; + var y: f32 = (a[@as(c_uint, @intCast(@as(c_int, 2)))] * b[@as(c_uint, @intCast(@as(c_int, 0)))]) - (a[@as(c_uint, @intCast(@as(c_int, 0)))] * b[@as(c_uint, @intCast(@as(c_int, 2)))]); + _ = &y; + var z: f32 = (a[@as(c_uint, @intCast(@as(c_int, 0)))] * b[@as(c_uint, @intCast(@as(c_int, 1)))]) - (a[@as(c_uint, @intCast(@as(c_int, 1)))] * b[@as(c_uint, @intCast(@as(c_int, 0)))]); + _ = &z; + result[@as(c_uint, @intCast(@as(c_int, 0)))] = x; + result[@as(c_uint, @intCast(@as(c_int, 1)))] = y; + result[@as(c_uint, @intCast(@as(c_int, 2)))] = z; +} +pub fn par_shapes__mix3(arg_d: [*c]f32, arg_a: [*c]const f32, arg_b: [*c]const f32, arg_t: f32) callconv(.C) void { + var d = arg_d; + _ = &d; + var a = arg_a; + _ = &a; + var b = arg_b; + _ = &b; + var t = arg_t; + _ = &t; + var x: f32 = (b[@as(c_uint, @intCast(@as(c_int, 0)))] * t) + (a[@as(c_uint, @intCast(@as(c_int, 0)))] * (@as(f32, @floatFromInt(@as(c_int, 1))) - t)); + _ = &x; + var y: f32 = (b[@as(c_uint, @intCast(@as(c_int, 1)))] * t) + (a[@as(c_uint, @intCast(@as(c_int, 1)))] * (@as(f32, @floatFromInt(@as(c_int, 1))) - t)); + _ = &y; + var z: f32 = (b[@as(c_uint, @intCast(@as(c_int, 2)))] * t) + (a[@as(c_uint, @intCast(@as(c_int, 2)))] * (@as(f32, @floatFromInt(@as(c_int, 1))) - t)); + _ = &z; + d[@as(c_uint, @intCast(@as(c_int, 0)))] = x; + d[@as(c_uint, @intCast(@as(c_int, 1)))] = y; + d[@as(c_uint, @intCast(@as(c_int, 2)))] = z; +} +pub fn par_shapes__scale3(arg_result: [*c]f32, arg_a: f32) callconv(.C) void { + var result = arg_result; + _ = &result; + var a = arg_a; + _ = &a; + result[@as(c_uint, @intCast(@as(c_int, 0)))] *= a; + result[@as(c_uint, @intCast(@as(c_int, 1)))] *= a; + result[@as(c_uint, @intCast(@as(c_int, 2)))] *= a; +} +pub fn par_shapes__normalize3(arg_v: [*c]f32) callconv(.C) void { + var v = arg_v; + _ = &v; + var lsqr: f32 = @as(f32, @floatCast(sqrt(@as(f64, @floatCast(((v[@as(c_uint, @intCast(@as(c_int, 0)))] * v[@as(c_uint, @intCast(@as(c_int, 0)))]) + (v[@as(c_uint, @intCast(@as(c_int, 1)))] * v[@as(c_uint, @intCast(@as(c_int, 1)))])) + (v[@as(c_uint, @intCast(@as(c_int, 2)))] * v[@as(c_uint, @intCast(@as(c_int, 2)))])))))); + _ = &lsqr; + if (lsqr > @as(f32, @floatFromInt(@as(c_int, 0)))) { + par_shapes__scale3(v, 1.0 / lsqr); + } +} +pub fn par_shapes__subtract3(arg_result: [*c]f32, arg_a: [*c]const f32) callconv(.C) void { + var result = arg_result; + _ = &result; + var a = arg_a; + _ = &a; + result[@as(c_uint, @intCast(@as(c_int, 0)))] -= a[@as(c_uint, @intCast(@as(c_int, 0)))]; + result[@as(c_uint, @intCast(@as(c_int, 1)))] -= a[@as(c_uint, @intCast(@as(c_int, 1)))]; + result[@as(c_uint, @intCast(@as(c_int, 2)))] -= a[@as(c_uint, @intCast(@as(c_int, 2)))]; +} +pub fn par_shapes__add3(arg_result: [*c]f32, arg_a: [*c]const f32) callconv(.C) void { + var result = arg_result; + _ = &result; + var a = arg_a; + _ = &a; + result[@as(c_uint, @intCast(@as(c_int, 0)))] += a[@as(c_uint, @intCast(@as(c_int, 0)))]; + result[@as(c_uint, @intCast(@as(c_int, 1)))] += a[@as(c_uint, @intCast(@as(c_int, 1)))]; + result[@as(c_uint, @intCast(@as(c_int, 2)))] += a[@as(c_uint, @intCast(@as(c_int, 2)))]; +} +pub fn par_shapes__sqrdist3(arg_a: [*c]const f32, arg_b: [*c]const f32) callconv(.C) f32 { + var a = arg_a; + _ = &a; + var b = arg_b; + _ = &b; + var dx: f32 = a[@as(c_uint, @intCast(@as(c_int, 0)))] - b[@as(c_uint, @intCast(@as(c_int, 0)))]; + _ = &dx; + var dy: f32 = a[@as(c_uint, @intCast(@as(c_int, 1)))] - b[@as(c_uint, @intCast(@as(c_int, 1)))]; + _ = &dy; + var dz: f32 = a[@as(c_uint, @intCast(@as(c_int, 2)))] - b[@as(c_uint, @intCast(@as(c_int, 2)))]; + _ = &dz; + return ((dx * dx) + (dy * dy)) + (dz * dz); +} +pub const par_shapes__command = extern struct { + cmd: [*c]u8 = @import("std").mem.zeroes([*c]u8), + arg: [*c]u8 = @import("std").mem.zeroes([*c]u8), +}; +pub const par_shapes__rule = extern struct { + name: [*c]const u8 = @import("std").mem.zeroes([*c]const u8), + weight: c_int = @import("std").mem.zeroes(c_int), + ncommands: c_int = @import("std").mem.zeroes(c_int), + commands: [*c]par_shapes__command = @import("std").mem.zeroes([*c]par_shapes__command), +}; +pub const par_shapes__stackframe = extern struct { + pc: c_int = @import("std").mem.zeroes(c_int), + position: [3]f32 = @import("std").mem.zeroes([3]f32), + scale: [3]f32 = @import("std").mem.zeroes([3]f32), + orientation: [*c]par_shapes_mesh = @import("std").mem.zeroes([*c]par_shapes_mesh), + rule: [*c]par_shapes__rule = @import("std").mem.zeroes([*c]par_shapes__rule), +}; +pub fn par_shapes__pick_rule(arg_name: [*c]const u8, arg_rules: [*c]par_shapes__rule, arg_nrules: c_int) callconv(.C) [*c]par_shapes__rule { + var name = arg_name; + _ = &name; + var rules = arg_rules; + _ = &rules; + var nrules = arg_nrules; + _ = &nrules; + var rule: [*c]par_shapes__rule = null; + _ = &rule; + var total: c_int = 0; + _ = &total; + { + var i: c_int = 0; + _ = &i; + while (i < nrules) : (i += 1) { + rule = rules + @as(usize, @bitCast(@as(isize, @intCast(i)))); + if (!(strcmp(rule.*.name, name) != 0)) { + total += rule.*.weight; + } + } + } + var r: f32 = @as(f32, @floatFromInt(rand())) / @as(f32, @floatFromInt(@as(c_int, 2147483647))); + _ = &r; + var t: f32 = 0; + _ = &t; + { + var i: c_int = 0; + _ = &i; + while (i < nrules) : (i += 1) { + rule = rules + @as(usize, @bitCast(@as(isize, @intCast(i)))); + if (!(strcmp(rule.*.name, name) != 0)) { + t += @as(f32, @floatFromInt(rule.*.weight)) / @as(f32, @floatFromInt(total)); + if (t >= r) { + return rule; + } + } + } + } + return rule; +} +pub fn par_shapes__create_turtle() callconv(.C) [*c]par_shapes_mesh { + const xaxis: [3]f32 = [3]f32{ + 1, + 0, + 0, + }; + _ = &xaxis; + const yaxis: [3]f32 = [3]f32{ + 0, + 1, + 0, + }; + _ = &yaxis; + const zaxis: [3]f32 = [3]f32{ + 0, + 0, + 1, + }; + _ = &zaxis; + var turtle: [*c]par_shapes_mesh = @as([*c]par_shapes_mesh, @ptrCast(@alignCast(calloc(@as(c_ulong, @bitCast(@as(c_long, @as(c_int, 1)))) *% @sizeOf(par_shapes_mesh), @as(c_ulong, @bitCast(@as(c_long, @as(c_int, 1)))))))); + _ = &turtle; + turtle.*.npoints = 3; + turtle.*.points = @as([*c]f32, @ptrCast(@alignCast(calloc(@as(c_ulong, @bitCast(@as(c_long, turtle.*.npoints * @as(c_int, 3)))) *% @sizeOf(f32), @as(c_ulong, @bitCast(@as(c_long, @as(c_int, 1)))))))); + par_shapes__copy3(turtle.*.points + @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 0))))), @as([*c]const f32, @ptrCast(@alignCast(&xaxis)))); + par_shapes__copy3(turtle.*.points + @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 3))))), @as([*c]const f32, @ptrCast(@alignCast(&yaxis)))); + par_shapes__copy3(turtle.*.points + @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 6))))), @as([*c]const f32, @ptrCast(@alignCast(&zaxis)))); + return turtle; +} +pub fn par_shapes__apply_turtle(arg_mesh: [*c]par_shapes_mesh, arg_turtle: [*c]par_shapes_mesh, arg_pos: [*c]const f32, arg_scale: [*c]const f32) callconv(.C) [*c]par_shapes_mesh { + var mesh = arg_mesh; + _ = &mesh; + var turtle = arg_turtle; + _ = &turtle; + var pos = arg_pos; + _ = &pos; + var scale = arg_scale; + _ = &scale; + var m: [*c]par_shapes_mesh = par_shapes_clone(mesh, null); + _ = &m; + { + var p: c_int = 0; + _ = &p; + while (p < m.*.npoints) : (p += 1) { + var pt: [*c]f32 = m.*.points + @as(usize, @bitCast(@as(isize, @intCast(p * @as(c_int, 3))))); + _ = &pt; + pt[@as(c_uint, @intCast(@as(c_int, 0)))] *= scale[@as(c_uint, @intCast(@as(c_int, 0)))]; + pt[@as(c_uint, @intCast(@as(c_int, 1)))] *= scale[@as(c_uint, @intCast(@as(c_int, 1)))]; + pt[@as(c_uint, @intCast(@as(c_int, 2)))] *= scale[@as(c_uint, @intCast(@as(c_int, 2)))]; + par_shapes__transform3(pt, turtle.*.points + @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 0))))), turtle.*.points + @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 3))))), turtle.*.points + @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 6)))))); + pt[@as(c_uint, @intCast(@as(c_int, 0)))] += pos[@as(c_uint, @intCast(@as(c_int, 0)))]; + pt[@as(c_uint, @intCast(@as(c_int, 1)))] += pos[@as(c_uint, @intCast(@as(c_int, 1)))]; + pt[@as(c_uint, @intCast(@as(c_int, 2)))] += pos[@as(c_uint, @intCast(@as(c_int, 2)))]; + } + } + return m; +} +pub fn par_shapes__subdivide(arg_mesh: [*c]par_shapes_mesh) callconv(.C) void { + var mesh = arg_mesh; + _ = &mesh; + _ = blk: { + _ = @sizeOf(c_int); + break :blk blk_1: { + break :blk_1 if ((mesh.*.npoints == (mesh.*.ntriangles * @as(c_int, 3))) and (@intFromPtr("Must be unwelded.") != 0)) {} else { + __assert_fail("mesh->npoints == mesh->ntriangles * 3 && \"Must be unwelded.\"", "./external/par_shapes.h", @as(c_uint, @bitCast(@as(c_int, 1476))), "void par_shapes__subdivide(par_shapes_mesh *)"); + }; + }; + }; + var ntriangles: c_int = mesh.*.ntriangles * @as(c_int, 4); + _ = &ntriangles; + var npoints: c_int = ntriangles * @as(c_int, 3); + _ = &npoints; + var points: [*c]f32 = @as([*c]f32, @ptrCast(@alignCast(calloc(@as(c_ulong, @bitCast(@as(c_long, npoints * @as(c_int, 3)))) *% @sizeOf(f32), @as(c_ulong, @bitCast(@as(c_long, @as(c_int, 1)))))))); + _ = &points; + var dpoint: [*c]f32 = points; + _ = &dpoint; + var spoint: [*c]const f32 = mesh.*.points; + _ = &spoint; + { + var t: c_int = 0; + _ = &t; + while (t < mesh.*.ntriangles) : (_ = blk: { + _ = blk_1: { + t += 1; + break :blk_1 blk_2: { + const ref = &spoint; + ref.* += @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 9))))); + break :blk_2 ref.*; + }; + }; + break :blk blk_1: { + const ref = &dpoint; + ref.* += @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 3))))); + break :blk_1 ref.*; + }; + }) { + var a: [*c]const f32 = spoint; + _ = &a; + var b: [*c]const f32 = spoint + @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 3))))); + _ = &b; + var c: [*c]const f32 = spoint + @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 6))))); + _ = &c; + var p0: [*c]const f32 = dpoint; + _ = &p0; + var p1: [*c]const f32 = dpoint + @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 3))))); + _ = &p1; + var p2: [*c]const f32 = dpoint + @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 6))))); + _ = &p2; + par_shapes__mix3(dpoint, a, b, @as(f32, @floatCast(0.5))); + par_shapes__mix3(blk: { + const ref = &dpoint; + ref.* += @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 3))))); + break :blk ref.*; + }, b, c, @as(f32, @floatCast(0.5))); + par_shapes__mix3(blk: { + const ref = &dpoint; + ref.* += @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 3))))); + break :blk ref.*; + }, a, c, @as(f32, @floatCast(0.5))); + par_shapes__add3(blk: { + const ref = &dpoint; + ref.* += @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 3))))); + break :blk ref.*; + }, a); + par_shapes__add3(blk: { + const ref = &dpoint; + ref.* += @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 3))))); + break :blk ref.*; + }, p0); + par_shapes__add3(blk: { + const ref = &dpoint; + ref.* += @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 3))))); + break :blk ref.*; + }, p2); + par_shapes__add3(blk: { + const ref = &dpoint; + ref.* += @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 3))))); + break :blk ref.*; + }, p0); + par_shapes__add3(blk: { + const ref = &dpoint; + ref.* += @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 3))))); + break :blk ref.*; + }, b); + par_shapes__add3(blk: { + const ref = &dpoint; + ref.* += @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 3))))); + break :blk ref.*; + }, p1); + par_shapes__add3(blk: { + const ref = &dpoint; + ref.* += @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 3))))); + break :blk ref.*; + }, p2); + par_shapes__add3(blk: { + const ref = &dpoint; + ref.* += @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 3))))); + break :blk ref.*; + }, p1); + par_shapes__add3(blk: { + const ref = &dpoint; + ref.* += @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 3))))); + break :blk ref.*; + }, c); + } + } + free(@as(?*anyopaque, @ptrCast(mesh.*.points))); + mesh.*.points = points; + mesh.*.npoints = npoints; + mesh.*.ntriangles = ntriangles; +} +const struct_unnamed_16 = extern struct { + points: [*c]const f32 = @import("std").mem.zeroes([*c]const f32), + gridsize: c_int = @import("std").mem.zeroes(c_int), +}; +pub var par_shapes__sort_context: struct_unnamed_16 = @import("std").mem.zeroes(struct_unnamed_16); +pub fn par_shapes__cmp1(arg_arg0: ?*const anyopaque, arg_arg1: ?*const anyopaque) callconv(.C) c_int { + var arg0 = arg_arg0; + _ = &arg0; + var arg1 = arg_arg1; + _ = &arg1; + const g: c_int = par_shapes__sort_context.gridsize; + _ = &g; + var d0: u16 = @as([*c]const u16, @ptrCast(@alignCast(arg0))).*; + _ = &d0; + var p0: [*c]const f32 = par_shapes__sort_context.points + @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, @bitCast(@as(c_uint, d0))) * @as(c_int, 3))))); + _ = &p0; + var @"i0": c_int = @as(c_int, @intFromFloat(p0[@as(c_uint, @intCast(@as(c_int, 0)))])); + _ = &@"i0"; + var j0_1: c_int = @as(c_int, @intFromFloat(p0[@as(c_uint, @intCast(@as(c_int, 1)))])); + _ = &j0_1; + var k0: c_int = @as(c_int, @intFromFloat(p0[@as(c_uint, @intCast(@as(c_int, 2)))])); + _ = &k0; + var index0: c_int = (@"i0" + (g * j0_1)) + ((g * g) * k0); + _ = &index0; + var d1: u16 = @as([*c]const u16, @ptrCast(@alignCast(arg1))).*; + _ = &d1; + var p1: [*c]const f32 = par_shapes__sort_context.points + @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, @bitCast(@as(c_uint, d1))) * @as(c_int, 3))))); + _ = &p1; + var @"i1": c_int = @as(c_int, @intFromFloat(p1[@as(c_uint, @intCast(@as(c_int, 0)))])); + _ = &@"i1"; + var j1_2: c_int = @as(c_int, @intFromFloat(p1[@as(c_uint, @intCast(@as(c_int, 1)))])); + _ = &j1_2; + var k1: c_int = @as(c_int, @intFromFloat(p1[@as(c_uint, @intCast(@as(c_int, 2)))])); + _ = &k1; + var index1: c_int = (@"i1" + (g * j1_2)) + ((g * g) * k1); + _ = &index1; + if (index0 < index1) return -@as(c_int, 1); + if (index0 > index1) return 1; + return 0; +} +pub fn par_shapes__sort_points(arg_mesh: [*c]par_shapes_mesh, arg_gridsize: c_int, arg_sortmap: [*c]u16) callconv(.C) void { + var mesh = arg_mesh; + _ = &mesh; + var gridsize = arg_gridsize; + _ = &gridsize; + var sortmap = arg_sortmap; + _ = &sortmap; + { + var i: c_int = 0; + _ = &i; + while (i < mesh.*.npoints) : (i += 1) { + (blk: { + const tmp = i; + if (tmp >= 0) break :blk sortmap + @as(usize, @intCast(tmp)) else break :blk sortmap - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = @as(u16, @bitCast(@as(c_short, @truncate(i)))); + } + } + par_shapes__sort_context.gridsize = gridsize; + par_shapes__sort_context.points = mesh.*.points; + qsort(@as(?*anyopaque, @ptrCast(sortmap)), @as(usize, @bitCast(@as(c_long, mesh.*.npoints))), @sizeOf(u16), &par_shapes__cmp1); + var newpts: [*c]f32 = @as([*c]f32, @ptrCast(@alignCast(malloc(@as(c_ulong, @bitCast(@as(c_long, mesh.*.npoints * @as(c_int, 3)))) *% @sizeOf(f32))))); + _ = &newpts; + var invmap: [*c]u16 = @as([*c]u16, @ptrCast(@alignCast(malloc(@as(c_ulong, @bitCast(@as(c_long, mesh.*.npoints))) *% @sizeOf(u16))))); + _ = &invmap; + var dstpt: [*c]f32 = newpts; + _ = &dstpt; + { + var i: c_int = 0; + _ = &i; + while (i < mesh.*.npoints) : (i += 1) { + invmap[(blk: { + const tmp = i; + if (tmp >= 0) break :blk sortmap + @as(usize, @intCast(tmp)) else break :blk sortmap - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*] = @as(u16, @bitCast(@as(c_short, @truncate(i)))); + var srcpt: [*c]const f32 = mesh.*.points + @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 3) * @as(c_int, @bitCast(@as(c_uint, (blk: { + const tmp = i; + if (tmp >= 0) break :blk sortmap + @as(usize, @intCast(tmp)) else break :blk sortmap - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*))))))); + _ = &srcpt; + (blk: { + const ref = &dstpt; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = (blk: { + const ref = &srcpt; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).*; + (blk: { + const ref = &dstpt; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = (blk: { + const ref = &srcpt; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).*; + (blk: { + const ref = &dstpt; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = (blk: { + const ref = &srcpt; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).*; + } + } + free(@as(?*anyopaque, @ptrCast(mesh.*.points))); + mesh.*.points = newpts; + var newinds: [*c]u16 = @as([*c]u16, @ptrCast(@alignCast(malloc(@as(c_ulong, @bitCast(@as(c_long, mesh.*.ntriangles * @as(c_int, 3)))) *% @sizeOf(u16))))); + _ = &newinds; + var dstind: [*c]u16 = newinds; + _ = &dstind; + var srcind: [*c]const u16 = mesh.*.triangles; + _ = &srcind; + { + var i: c_int = 0; + _ = &i; + while (i < (mesh.*.ntriangles * @as(c_int, 3))) : (i += 1) { + (blk: { + const ref = &dstind; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = invmap[(blk: { + const ref = &srcind; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).*]; + } + } + free(@as(?*anyopaque, @ptrCast(mesh.*.triangles))); + mesh.*.triangles = newinds; + _ = memcpy(@as(?*anyopaque, @ptrCast(sortmap)), @as(?*const anyopaque, @ptrCast(invmap)), @sizeOf(u16) *% @as(c_ulong, @bitCast(@as(c_long, mesh.*.npoints)))); + free(@as(?*anyopaque, @ptrCast(invmap))); +} +pub fn par_shapes__weld_points(arg_mesh: [*c]par_shapes_mesh, arg_gridsize: c_int, arg_epsilon: f32, arg_weldmap: [*c]u16) callconv(.C) void { + var mesh = arg_mesh; + _ = &mesh; + var gridsize = arg_gridsize; + _ = &gridsize; + var epsilon = arg_epsilon; + _ = ε + var weldmap = arg_weldmap; + _ = &weldmap; + var bins: [*c]u16 = @as([*c]u16, @ptrCast(@alignCast(calloc(@as(c_ulong, @bitCast(@as(c_long, (gridsize * gridsize) * gridsize))) *% @sizeOf(u16), @as(c_ulong, @bitCast(@as(c_long, @as(c_int, 1)))))))); + _ = &bins; + var prev_binindex: c_int = -@as(c_int, 1); + _ = &prev_binindex; + { + var p: c_int = 0; + _ = &p; + while (p < mesh.*.npoints) : (p += 1) { + var pt: [*c]const f32 = mesh.*.points + @as(usize, @bitCast(@as(isize, @intCast(p * @as(c_int, 3))))); + _ = &pt; + var i: c_int = @as(c_int, @intFromFloat(pt[@as(c_uint, @intCast(@as(c_int, 0)))])); + _ = &i; + var j: c_int = @as(c_int, @intFromFloat(pt[@as(c_uint, @intCast(@as(c_int, 1)))])); + _ = &j; + var k: c_int = @as(c_int, @intFromFloat(pt[@as(c_uint, @intCast(@as(c_int, 2)))])); + _ = &k; + var this_binindex: c_int = (i + (gridsize * j)) + ((gridsize * gridsize) * k); + _ = &this_binindex; + if (this_binindex != prev_binindex) { + (blk: { + const tmp = this_binindex; + if (tmp >= 0) break :blk bins + @as(usize, @intCast(tmp)) else break :blk bins - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = @as(u16, @bitCast(@as(c_short, @truncate(@as(c_int, 1) + p)))); + } + prev_binindex = this_binindex; + } + } + var pt: [*c]const f32 = mesh.*.points; + _ = &pt; + var nremoved: c_int = 0; + _ = &nremoved; + { + var p: c_int = 0; + _ = &p; + while (p < mesh.*.npoints) : (_ = blk: { + p += 1; + break :blk blk_1: { + const ref = &pt; + ref.* += @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 3))))); + break :blk_1 ref.*; + }; + }) { + if (@as(c_int, @bitCast(@as(c_uint, (blk: { + const tmp = p; + if (tmp >= 0) break :blk weldmap + @as(usize, @intCast(tmp)) else break :blk weldmap - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*))) != p) { + continue; + } + var nearby: [8]c_int = undefined; + _ = &nearby; + var nbins: c_int = 0; + _ = &nbins; + var minp: [3]c_int = undefined; + _ = &minp; + var maxp: [3]c_int = undefined; + _ = &maxp; + { + var c: c_int = 0; + _ = &c; + while (c < @as(c_int, 3)) : (c += 1) { + minp[@as(c_uint, @intCast(c))] = @as(c_int, @intFromFloat((blk: { + const tmp = c; + if (tmp >= 0) break :blk pt + @as(usize, @intCast(tmp)) else break :blk pt - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* - epsilon)); + maxp[@as(c_uint, @intCast(c))] = @as(c_int, @intFromFloat((blk: { + const tmp = c; + if (tmp >= 0) break :blk pt + @as(usize, @intCast(tmp)) else break :blk pt - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* + epsilon)); + } + } + { + var i: c_int = minp[@as(c_uint, @intCast(@as(c_int, 0)))]; + _ = &i; + while (i <= maxp[@as(c_uint, @intCast(@as(c_int, 0)))]) : (i += 1) { + { + var j: c_int = minp[@as(c_uint, @intCast(@as(c_int, 1)))]; + _ = &j; + while (j <= maxp[@as(c_uint, @intCast(@as(c_int, 1)))]) : (j += 1) { + { + var k: c_int = minp[@as(c_uint, @intCast(@as(c_int, 2)))]; + _ = &k; + while (k <= maxp[@as(c_uint, @intCast(@as(c_int, 2)))]) : (k += 1) { + var binindex: c_int = (i + (gridsize * j)) + ((gridsize * gridsize) * k); + _ = &binindex; + var binvalue: u16 = (bins + @as(usize, @bitCast(@as(isize, @intCast(binindex))))).*; + _ = &binvalue; + if (@as(c_int, @bitCast(@as(c_uint, binvalue))) > @as(c_int, 0)) { + if (nbins == @as(c_int, 8)) { + _ = printf("Epsilon value is too large.\n"); + break; + } + nearby[@as(c_uint, @intCast(blk: { + const ref = &nbins; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }))] = binindex; + } + } + } + } + } + } + } + { + var b: c_int = 0; + _ = &b; + while (b < nbins) : (b += 1) { + var binindex: c_int = nearby[@as(c_uint, @intCast(b))]; + _ = &binindex; + var binvalue: u16 = (blk: { + const tmp = binindex; + if (tmp >= 0) break :blk bins + @as(usize, @intCast(tmp)) else break :blk bins - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*; + _ = &binvalue; + var nindex: u16 = @as(u16, @bitCast(@as(c_short, @truncate(@as(c_int, @bitCast(@as(c_uint, binvalue))) - @as(c_int, 1))))); + _ = &nindex; + _ = blk: { + _ = @sizeOf(c_int); + break :blk blk_1: { + break :blk_1 if (@as(c_int, @bitCast(@as(c_uint, nindex))) < mesh.*.npoints) {} else { + __assert_fail("nindex < mesh->npoints", "./external/par_shapes.h", @as(c_uint, @bitCast(@as(c_int, 1715))), "void par_shapes__weld_points(par_shapes_mesh *, int, float, uint16_t *)"); + }; + }; + }; + while (true) { + if ((@as(c_int, @bitCast(@as(c_uint, nindex))) != p) and (@as(c_int, @bitCast(@as(c_uint, weldmap[nindex]))) == @as(c_int, @bitCast(@as(c_uint, nindex))))) { + var thatpt: [*c]const f32 = mesh.*.points + @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, @bitCast(@as(c_uint, nindex))) * @as(c_int, 3))))); + _ = &thatpt; + var dist2: f32 = par_shapes__sqrdist3(thatpt, pt); + _ = &dist2; + if (dist2 < epsilon) { + weldmap[nindex] = @as(u16, @bitCast(@as(c_short, @truncate(p)))); + nremoved += 1; + } + } + if (@as(c_int, @bitCast(@as(c_uint, blk: { + const ref = &nindex; + ref.* +%= 1; + break :blk ref.*; + }))) >= mesh.*.npoints) { + break; + } + var nextpt: [*c]const f32 = mesh.*.points + @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, @bitCast(@as(c_uint, nindex))) * @as(c_int, 3))))); + _ = &nextpt; + var i: c_int = @as(c_int, @intFromFloat(nextpt[@as(c_uint, @intCast(@as(c_int, 0)))])); + _ = &i; + var j: c_int = @as(c_int, @intFromFloat(nextpt[@as(c_uint, @intCast(@as(c_int, 1)))])); + _ = &j; + var k: c_int = @as(c_int, @intFromFloat(nextpt[@as(c_uint, @intCast(@as(c_int, 2)))])); + _ = &k; + var nextbinindex: c_int = (i + (gridsize * j)) + ((gridsize * gridsize) * k); + _ = &nextbinindex; + if (nextbinindex != binindex) { + break; + } + } + } + } + } + } + free(@as(?*anyopaque, @ptrCast(bins))); + var npoints: c_int = mesh.*.npoints - nremoved; + _ = &npoints; + var newpts: [*c]f32 = @as([*c]f32, @ptrCast(@alignCast(malloc(@as(c_ulong, @bitCast(@as(c_long, @as(c_int, 3) * npoints))) *% @sizeOf(f32))))); + _ = &newpts; + var dst: [*c]f32 = newpts; + _ = &dst; + var condensed_map: [*c]u16 = @as([*c]u16, @ptrCast(@alignCast(malloc(@as(c_ulong, @bitCast(@as(c_long, mesh.*.npoints))) *% @sizeOf(u16))))); + _ = &condensed_map; + var cmap: [*c]u16 = condensed_map; + _ = &cmap; + var src: [*c]const f32 = mesh.*.points; + _ = &src; + var ci: c_int = 0; + _ = &ci; + { + var p: c_int = 0; + _ = &p; + while (p < mesh.*.npoints) : (_ = blk: { + p += 1; + break :blk blk_1: { + const ref = &src; + ref.* += @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 3))))); + break :blk_1 ref.*; + }; + }) { + if (@as(c_int, @bitCast(@as(c_uint, (blk: { + const tmp = p; + if (tmp >= 0) break :blk weldmap + @as(usize, @intCast(tmp)) else break :blk weldmap - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*))) == p) { + (blk: { + const ref = &dst; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = src[@as(c_uint, @intCast(@as(c_int, 0)))]; + (blk: { + const ref = &dst; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = src[@as(c_uint, @intCast(@as(c_int, 1)))]; + (blk: { + const ref = &dst; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = src[@as(c_uint, @intCast(@as(c_int, 2)))]; + (blk: { + const ref = &cmap; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = @as(u16, @bitCast(@as(c_short, @truncate(blk: { + const ref = &ci; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + })))); + } else { + (blk: { + const ref = &cmap; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = condensed_map[(blk: { + const tmp = p; + if (tmp >= 0) break :blk weldmap + @as(usize, @intCast(tmp)) else break :blk weldmap - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*]; + } + } + } + _ = blk: { + _ = @sizeOf(c_int); + break :blk blk_1: { + break :blk_1 if (ci == npoints) {} else { + __assert_fail("ci == npoints", "./external/par_shapes.h", @as(c_uint, @bitCast(@as(c_int, 1765))), "void par_shapes__weld_points(par_shapes_mesh *, int, float, uint16_t *)"); + }; + }; + }; + free(@as(?*anyopaque, @ptrCast(mesh.*.points))); + _ = memcpy(@as(?*anyopaque, @ptrCast(weldmap)), @as(?*const anyopaque, @ptrCast(condensed_map)), @as(c_ulong, @bitCast(@as(c_long, mesh.*.npoints))) *% @sizeOf(u16)); + free(@as(?*anyopaque, @ptrCast(condensed_map))); + mesh.*.points = newpts; + mesh.*.npoints = npoints; + var tsrc: [*c]const u16 = mesh.*.triangles; + _ = &tsrc; + var tdst: [*c]u16 = mesh.*.triangles; + _ = &tdst; + var ntriangles: c_int = 0; + _ = &ntriangles; + { + var i: c_int = 0; + _ = &i; + while (i < mesh.*.ntriangles) : (_ = blk: { + i += 1; + break :blk blk_1: { + const ref = &tsrc; + ref.* += @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 3))))); + break :blk_1 ref.*; + }; + }) { + var a: u16 = weldmap[tsrc[@as(c_uint, @intCast(@as(c_int, 0)))]]; + _ = &a; + var b: u16 = weldmap[tsrc[@as(c_uint, @intCast(@as(c_int, 1)))]]; + _ = &b; + var c: u16 = weldmap[tsrc[@as(c_uint, @intCast(@as(c_int, 2)))]]; + _ = &c; + if (((@as(c_int, @bitCast(@as(c_uint, a))) != @as(c_int, @bitCast(@as(c_uint, b)))) and (@as(c_int, @bitCast(@as(c_uint, a))) != @as(c_int, @bitCast(@as(c_uint, c))))) and (@as(c_int, @bitCast(@as(c_uint, b))) != @as(c_int, @bitCast(@as(c_uint, c))))) { + _ = blk: { + _ = @sizeOf(c_int); + break :blk blk_1: { + break :blk_1 if (@as(c_int, @bitCast(@as(c_uint, a))) < mesh.*.npoints) {} else { + __assert_fail("a < mesh->npoints", "./external/par_shapes.h", @as(c_uint, @bitCast(@as(c_int, 1781))), "void par_shapes__weld_points(par_shapes_mesh *, int, float, uint16_t *)"); + }; + }; + }; + _ = blk: { + _ = @sizeOf(c_int); + break :blk blk_1: { + break :blk_1 if (@as(c_int, @bitCast(@as(c_uint, b))) < mesh.*.npoints) {} else { + __assert_fail("b < mesh->npoints", "./external/par_shapes.h", @as(c_uint, @bitCast(@as(c_int, 1782))), "void par_shapes__weld_points(par_shapes_mesh *, int, float, uint16_t *)"); + }; + }; + }; + _ = blk: { + _ = @sizeOf(c_int); + break :blk blk_1: { + break :blk_1 if (@as(c_int, @bitCast(@as(c_uint, c))) < mesh.*.npoints) {} else { + __assert_fail("c < mesh->npoints", "./external/par_shapes.h", @as(c_uint, @bitCast(@as(c_int, 1783))), "void par_shapes__weld_points(par_shapes_mesh *, int, float, uint16_t *)"); + }; + }; + }; + (blk: { + const ref = &tdst; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = a; + (blk: { + const ref = &tdst; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = b; + (blk: { + const ref = &tdst; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = c; + ntriangles += 1; + } + } + } + mesh.*.ntriangles = ntriangles; +} +pub const gradients2D: [16]i8 = [16]i8{ + 5, + 2, + 2, + 5, + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 5))))), + 2, + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 2))))), + 5, + 5, + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 2))))), + 2, + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 5))))), + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 5))))), + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 2))))), + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 2))))), + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 5))))), +}; +pub const gradients3D: [72]i8 = [72]i8{ + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 11))))), + 4, + 4, + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 4))))), + 11, + 4, + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 4))))), + 4, + 11, + 11, + 4, + 4, + 4, + 11, + 4, + 4, + 4, + 11, + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 11))))), + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 4))))), + 4, + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 4))))), + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 11))))), + 4, + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 4))))), + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 4))))), + 11, + 11, + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 4))))), + 4, + 4, + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 11))))), + 4, + 4, + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 4))))), + 11, + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 11))))), + 4, + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 4))))), + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 4))))), + 11, + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 4))))), + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 4))))), + 4, + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 11))))), + 11, + 4, + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 4))))), + 4, + 11, + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 4))))), + 4, + 4, + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 11))))), + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 11))))), + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 4))))), + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 4))))), + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 4))))), + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 11))))), + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 4))))), + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 4))))), + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 4))))), + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 11))))), + 11, + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 4))))), + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 4))))), + 4, + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 11))))), + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 4))))), + 4, + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 4))))), + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 11))))), +}; +pub const gradients4D: [256]i8 = [256]i8{ + 3, + 1, + 1, + 1, + 1, + 3, + 1, + 1, + 1, + 1, + 3, + 1, + 1, + 1, + 1, + 3, + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 3))))), + 1, + 1, + 1, + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 1))))), + 3, + 1, + 1, + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 1))))), + 1, + 3, + 1, + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 1))))), + 1, + 1, + 3, + 3, + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 1))))), + 1, + 1, + 1, + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 3))))), + 1, + 1, + 1, + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 1))))), + 3, + 1, + 1, + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 1))))), + 1, + 3, + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 3))))), + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 1))))), + 1, + 1, + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 1))))), + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 3))))), + 1, + 1, + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 1))))), + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 1))))), + 3, + 1, + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 1))))), + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 1))))), + 1, + 3, + 3, + 1, + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 1))))), + 1, + 1, + 3, + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 1))))), + 1, + 1, + 1, + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 3))))), + 1, + 1, + 1, + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 1))))), + 3, + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 3))))), + 1, + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 1))))), + 1, + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 1))))), + 3, + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 1))))), + 1, + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 1))))), + 1, + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 3))))), + 1, + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 1))))), + 1, + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 1))))), + 3, + 3, + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 1))))), + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 1))))), + 1, + 1, + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 3))))), + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 1))))), + 1, + 1, + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 1))))), + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 3))))), + 1, + 1, + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 1))))), + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 1))))), + 3, + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 3))))), + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 1))))), + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 1))))), + 1, + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 1))))), + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 3))))), + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 1))))), + 1, + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 1))))), + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 1))))), + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 3))))), + 1, + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 1))))), + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 1))))), + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 1))))), + 3, + 3, + 1, + 1, + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 1))))), + 1, + 3, + 1, + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 1))))), + 1, + 1, + 3, + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 1))))), + 1, + 1, + 1, + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 3))))), + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 3))))), + 1, + 1, + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 1))))), + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 1))))), + 3, + 1, + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 1))))), + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 1))))), + 1, + 3, + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 1))))), + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 1))))), + 1, + 1, + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 3))))), + 3, + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 1))))), + 1, + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 1))))), + 1, + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 3))))), + 1, + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 1))))), + 1, + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 1))))), + 3, + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 1))))), + 1, + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 1))))), + 1, + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 3))))), + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 3))))), + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 1))))), + 1, + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 1))))), + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 1))))), + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 3))))), + 1, + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 1))))), + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 1))))), + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 1))))), + 3, + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 1))))), + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 1))))), + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 1))))), + 1, + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 3))))), + 3, + 1, + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 1))))), + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 1))))), + 1, + 3, + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 1))))), + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 1))))), + 1, + 1, + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 3))))), + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 1))))), + 1, + 1, + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 1))))), + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 3))))), + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 3))))), + 1, + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 1))))), + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 1))))), + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 1))))), + 3, + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 1))))), + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 1))))), + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 1))))), + 1, + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 3))))), + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 1))))), + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 1))))), + 1, + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 1))))), + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 3))))), + 3, + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 1))))), + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 1))))), + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 1))))), + 1, + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 3))))), + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 1))))), + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 1))))), + 1, + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 1))))), + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 3))))), + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 1))))), + 1, + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 1))))), + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 1))))), + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 3))))), + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 3))))), + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 1))))), + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 1))))), + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 1))))), + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 1))))), + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 3))))), + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 1))))), + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 1))))), + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 1))))), + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 1))))), + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 3))))), + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 1))))), + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 1))))), + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 1))))), + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 1))))), + @as(i8, @bitCast(@as(i8, @truncate(-@as(c_int, 3))))), +}; +pub fn extrapolate2(arg_ctx: [*c]struct_osn_context, arg_xsb: c_int, arg_ysb: c_int, arg_dx: f64, arg_dy: f64) callconv(.C) f64 { + var ctx = arg_ctx; + _ = &ctx; + var xsb = arg_xsb; + _ = &xsb; + var ysb = arg_ysb; + _ = &ysb; + var dx = arg_dx; + _ = &dx; + var dy = arg_dy; + _ = &dy; + var perm: [*c]i16 = ctx.*.perm; + _ = &perm; + var index_1: c_int = @as(c_int, @bitCast(@as(c_int, (blk: { + const tmp = (@as(c_int, @bitCast(@as(c_int, (blk_1: { + const tmp_2 = xsb & @as(c_int, 255); + if (tmp_2 >= 0) break :blk_1 perm + @as(usize, @intCast(tmp_2)) else break :blk_1 perm - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*))) + ysb) & @as(c_int, 255); + if (tmp >= 0) break :blk perm + @as(usize, @intCast(tmp)) else break :blk perm - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*))) & @as(c_int, 14); + _ = &index_1; + return (@as(f64, @floatFromInt(@as(c_int, @bitCast(@as(c_int, gradients2D[@as(c_uint, @intCast(index_1))]))))) * dx) + (@as(f64, @floatFromInt(@as(c_int, @bitCast(@as(c_int, gradients2D[@as(c_uint, @intCast(index_1 + @as(c_int, 1)))]))))) * dy); +} +pub fn fastFloor(arg_x: f64) callconv(.C) c_int { + var x = arg_x; + _ = &x; + var xi: c_int = @as(c_int, @intFromFloat(x)); + _ = ξ + return if (x < @as(f64, @floatFromInt(xi))) xi - @as(c_int, 1) else xi; +} +pub fn allocate_perm(arg_ctx: [*c]struct_osn_context, arg_nperm: c_int, arg_ngrad: c_int) callconv(.C) c_int { + var ctx = arg_ctx; + _ = &ctx; + var nperm = arg_nperm; + _ = &nperm; + var ngrad = arg_ngrad; + _ = &ngrad; + free(@as(?*anyopaque, @ptrCast(ctx.*.perm))); + free(@as(?*anyopaque, @ptrCast(ctx.*.permGradIndex3D))); + ctx.*.perm = @as([*c]i16, @ptrCast(@alignCast(malloc(@as(c_ulong, @bitCast(@as(c_long, nperm))) *% @sizeOf(i16))))); + if (!(ctx.*.perm != null)) { + return -@as(c_int, 12); + } + ctx.*.permGradIndex3D = @as([*c]i16, @ptrCast(@alignCast(malloc(@as(c_ulong, @bitCast(@as(c_long, ngrad))) *% @sizeOf(i16))))); + if (!(ctx.*.permGradIndex3D != null)) { + free(@as(?*anyopaque, @ptrCast(ctx.*.perm))); + return -@as(c_int, 12); + } + return 0; +} +pub const useconds_t = __useconds_t; +pub const socklen_t = __socklen_t; +pub extern fn access(__name: [*c]const u8, __type: c_int) c_int; +pub extern fn faccessat(__fd: c_int, __file: [*c]const u8, __type: c_int, __flag: c_int) c_int; +pub extern fn lseek(__fd: c_int, __offset: __off_t, __whence: c_int) __off_t; +pub extern fn close(__fd: c_int) c_int; +pub extern fn closefrom(__lowfd: c_int) void; +pub extern fn read(__fd: c_int, __buf: ?*anyopaque, __nbytes: usize) isize; +pub extern fn write(__fd: c_int, __buf: ?*const anyopaque, __n: usize) isize; +pub extern fn pread(__fd: c_int, __buf: ?*anyopaque, __nbytes: usize, __offset: __off_t) isize; +pub extern fn pwrite(__fd: c_int, __buf: ?*const anyopaque, __n: usize, __offset: __off_t) isize; +pub extern fn pipe(__pipedes: [*c]c_int) c_int; +pub extern fn alarm(__seconds: c_uint) c_uint; +pub extern fn sleep(__seconds: c_uint) c_uint; +pub extern fn ualarm(__value: __useconds_t, __interval: __useconds_t) __useconds_t; +pub extern fn usleep(__useconds: __useconds_t) c_int; +pub extern fn pause() c_int; +pub extern fn chown(__file: [*c]const u8, __owner: __uid_t, __group: __gid_t) c_int; +pub extern fn fchown(__fd: c_int, __owner: __uid_t, __group: __gid_t) c_int; +pub extern fn lchown(__file: [*c]const u8, __owner: __uid_t, __group: __gid_t) c_int; +pub extern fn fchownat(__fd: c_int, __file: [*c]const u8, __owner: __uid_t, __group: __gid_t, __flag: c_int) c_int; +pub extern fn chdir(__path: [*c]const u8) c_int; +pub extern fn fchdir(__fd: c_int) c_int; +pub extern fn getcwd(__buf: [*c]u8, __size: usize) [*c]u8; +pub extern fn getwd(__buf: [*c]u8) [*c]u8; +pub extern fn dup(__fd: c_int) c_int; +pub extern fn dup2(__fd: c_int, __fd2: c_int) c_int; +pub extern var __environ: [*c][*c]u8; +pub extern fn execve(__path: [*c]const u8, __argv: [*c]const [*c]u8, __envp: [*c]const [*c]u8) c_int; +pub extern fn fexecve(__fd: c_int, __argv: [*c]const [*c]u8, __envp: [*c]const [*c]u8) c_int; +pub extern fn execv(__path: [*c]const u8, __argv: [*c]const [*c]u8) c_int; +pub extern fn execle(__path: [*c]const u8, __arg: [*c]const u8, ...) c_int; +pub extern fn execl(__path: [*c]const u8, __arg: [*c]const u8, ...) c_int; +pub extern fn execvp(__file: [*c]const u8, __argv: [*c]const [*c]u8) c_int; +pub extern fn execlp(__file: [*c]const u8, __arg: [*c]const u8, ...) c_int; +pub extern fn nice(__inc: c_int) c_int; +pub extern fn _exit(__status: c_int) noreturn; +pub const _PC_LINK_MAX: c_int = 0; +pub const _PC_MAX_CANON: c_int = 1; +pub const _PC_MAX_INPUT: c_int = 2; +pub const _PC_NAME_MAX: c_int = 3; +pub const _PC_PATH_MAX: c_int = 4; +pub const _PC_PIPE_BUF: c_int = 5; +pub const _PC_CHOWN_RESTRICTED: c_int = 6; +pub const _PC_NO_TRUNC: c_int = 7; +pub const _PC_VDISABLE: c_int = 8; +pub const _PC_SYNC_IO: c_int = 9; +pub const _PC_ASYNC_IO: c_int = 10; +pub const _PC_PRIO_IO: c_int = 11; +pub const _PC_SOCK_MAXBUF: c_int = 12; +pub const _PC_FILESIZEBITS: c_int = 13; +pub const _PC_REC_INCR_XFER_SIZE: c_int = 14; +pub const _PC_REC_MAX_XFER_SIZE: c_int = 15; +pub const _PC_REC_MIN_XFER_SIZE: c_int = 16; +pub const _PC_REC_XFER_ALIGN: c_int = 17; +pub const _PC_ALLOC_SIZE_MIN: c_int = 18; +pub const _PC_SYMLINK_MAX: c_int = 19; +pub const _PC_2_SYMLINKS: c_int = 20; +const enum_unnamed_17 = c_uint; +pub const _SC_ARG_MAX: c_int = 0; +pub const _SC_CHILD_MAX: c_int = 1; +pub const _SC_CLK_TCK: c_int = 2; +pub const _SC_NGROUPS_MAX: c_int = 3; +pub const _SC_OPEN_MAX: c_int = 4; +pub const _SC_STREAM_MAX: c_int = 5; +pub const _SC_TZNAME_MAX: c_int = 6; +pub const _SC_JOB_CONTROL: c_int = 7; +pub const _SC_SAVED_IDS: c_int = 8; +pub const _SC_REALTIME_SIGNALS: c_int = 9; +pub const _SC_PRIORITY_SCHEDULING: c_int = 10; +pub const _SC_TIMERS: c_int = 11; +pub const _SC_ASYNCHRONOUS_IO: c_int = 12; +pub const _SC_PRIORITIZED_IO: c_int = 13; +pub const _SC_SYNCHRONIZED_IO: c_int = 14; +pub const _SC_FSYNC: c_int = 15; +pub const _SC_MAPPED_FILES: c_int = 16; +pub const _SC_MEMLOCK: c_int = 17; +pub const _SC_MEMLOCK_RANGE: c_int = 18; +pub const _SC_MEMORY_PROTECTION: c_int = 19; +pub const _SC_MESSAGE_PASSING: c_int = 20; +pub const _SC_SEMAPHORES: c_int = 21; +pub const _SC_SHARED_MEMORY_OBJECTS: c_int = 22; +pub const _SC_AIO_LISTIO_MAX: c_int = 23; +pub const _SC_AIO_MAX: c_int = 24; +pub const _SC_AIO_PRIO_DELTA_MAX: c_int = 25; +pub const _SC_DELAYTIMER_MAX: c_int = 26; +pub const _SC_MQ_OPEN_MAX: c_int = 27; +pub const _SC_MQ_PRIO_MAX: c_int = 28; +pub const _SC_VERSION: c_int = 29; +pub const _SC_PAGESIZE: c_int = 30; +pub const _SC_RTSIG_MAX: c_int = 31; +pub const _SC_SEM_NSEMS_MAX: c_int = 32; +pub const _SC_SEM_VALUE_MAX: c_int = 33; +pub const _SC_SIGQUEUE_MAX: c_int = 34; +pub const _SC_TIMER_MAX: c_int = 35; +pub const _SC_BC_BASE_MAX: c_int = 36; +pub const _SC_BC_DIM_MAX: c_int = 37; +pub const _SC_BC_SCALE_MAX: c_int = 38; +pub const _SC_BC_STRING_MAX: c_int = 39; +pub const _SC_COLL_WEIGHTS_MAX: c_int = 40; +pub const _SC_EQUIV_CLASS_MAX: c_int = 41; +pub const _SC_EXPR_NEST_MAX: c_int = 42; +pub const _SC_LINE_MAX: c_int = 43; +pub const _SC_RE_DUP_MAX: c_int = 44; +pub const _SC_CHARCLASS_NAME_MAX: c_int = 45; +pub const _SC_2_VERSION: c_int = 46; +pub const _SC_2_C_BIND: c_int = 47; +pub const _SC_2_C_DEV: c_int = 48; +pub const _SC_2_FORT_DEV: c_int = 49; +pub const _SC_2_FORT_RUN: c_int = 50; +pub const _SC_2_SW_DEV: c_int = 51; +pub const _SC_2_LOCALEDEF: c_int = 52; +pub const _SC_PII: c_int = 53; +pub const _SC_PII_XTI: c_int = 54; +pub const _SC_PII_SOCKET: c_int = 55; +pub const _SC_PII_INTERNET: c_int = 56; +pub const _SC_PII_OSI: c_int = 57; +pub const _SC_POLL: c_int = 58; +pub const _SC_SELECT: c_int = 59; +pub const _SC_UIO_MAXIOV: c_int = 60; +pub const _SC_IOV_MAX: c_int = 60; +pub const _SC_PII_INTERNET_STREAM: c_int = 61; +pub const _SC_PII_INTERNET_DGRAM: c_int = 62; +pub const _SC_PII_OSI_COTS: c_int = 63; +pub const _SC_PII_OSI_CLTS: c_int = 64; +pub const _SC_PII_OSI_M: c_int = 65; +pub const _SC_T_IOV_MAX: c_int = 66; +pub const _SC_THREADS: c_int = 67; +pub const _SC_THREAD_SAFE_FUNCTIONS: c_int = 68; +pub const _SC_GETGR_R_SIZE_MAX: c_int = 69; +pub const _SC_GETPW_R_SIZE_MAX: c_int = 70; +pub const _SC_LOGIN_NAME_MAX: c_int = 71; +pub const _SC_TTY_NAME_MAX: c_int = 72; +pub const _SC_THREAD_DESTRUCTOR_ITERATIONS: c_int = 73; +pub const _SC_THREAD_KEYS_MAX: c_int = 74; +pub const _SC_THREAD_STACK_MIN: c_int = 75; +pub const _SC_THREAD_THREADS_MAX: c_int = 76; +pub const _SC_THREAD_ATTR_STACKADDR: c_int = 77; +pub const _SC_THREAD_ATTR_STACKSIZE: c_int = 78; +pub const _SC_THREAD_PRIORITY_SCHEDULING: c_int = 79; +pub const _SC_THREAD_PRIO_INHERIT: c_int = 80; +pub const _SC_THREAD_PRIO_PROTECT: c_int = 81; +pub const _SC_THREAD_PROCESS_SHARED: c_int = 82; +pub const _SC_NPROCESSORS_CONF: c_int = 83; +pub const _SC_NPROCESSORS_ONLN: c_int = 84; +pub const _SC_PHYS_PAGES: c_int = 85; +pub const _SC_AVPHYS_PAGES: c_int = 86; +pub const _SC_ATEXIT_MAX: c_int = 87; +pub const _SC_PASS_MAX: c_int = 88; +pub const _SC_XOPEN_VERSION: c_int = 89; +pub const _SC_XOPEN_XCU_VERSION: c_int = 90; +pub const _SC_XOPEN_UNIX: c_int = 91; +pub const _SC_XOPEN_CRYPT: c_int = 92; +pub const _SC_XOPEN_ENH_I18N: c_int = 93; +pub const _SC_XOPEN_SHM: c_int = 94; +pub const _SC_2_CHAR_TERM: c_int = 95; +pub const _SC_2_C_VERSION: c_int = 96; +pub const _SC_2_UPE: c_int = 97; +pub const _SC_XOPEN_XPG2: c_int = 98; +pub const _SC_XOPEN_XPG3: c_int = 99; +pub const _SC_XOPEN_XPG4: c_int = 100; +pub const _SC_CHAR_BIT: c_int = 101; +pub const _SC_CHAR_MAX: c_int = 102; +pub const _SC_CHAR_MIN: c_int = 103; +pub const _SC_INT_MAX: c_int = 104; +pub const _SC_INT_MIN: c_int = 105; +pub const _SC_LONG_BIT: c_int = 106; +pub const _SC_WORD_BIT: c_int = 107; +pub const _SC_MB_LEN_MAX: c_int = 108; +pub const _SC_NZERO: c_int = 109; +pub const _SC_SSIZE_MAX: c_int = 110; +pub const _SC_SCHAR_MAX: c_int = 111; +pub const _SC_SCHAR_MIN: c_int = 112; +pub const _SC_SHRT_MAX: c_int = 113; +pub const _SC_SHRT_MIN: c_int = 114; +pub const _SC_UCHAR_MAX: c_int = 115; +pub const _SC_UINT_MAX: c_int = 116; +pub const _SC_ULONG_MAX: c_int = 117; +pub const _SC_USHRT_MAX: c_int = 118; +pub const _SC_NL_ARGMAX: c_int = 119; +pub const _SC_NL_LANGMAX: c_int = 120; +pub const _SC_NL_MSGMAX: c_int = 121; +pub const _SC_NL_NMAX: c_int = 122; +pub const _SC_NL_SETMAX: c_int = 123; +pub const _SC_NL_TEXTMAX: c_int = 124; +pub const _SC_XBS5_ILP32_OFF32: c_int = 125; +pub const _SC_XBS5_ILP32_OFFBIG: c_int = 126; +pub const _SC_XBS5_LP64_OFF64: c_int = 127; +pub const _SC_XBS5_LPBIG_OFFBIG: c_int = 128; +pub const _SC_XOPEN_LEGACY: c_int = 129; +pub const _SC_XOPEN_REALTIME: c_int = 130; +pub const _SC_XOPEN_REALTIME_THREADS: c_int = 131; +pub const _SC_ADVISORY_INFO: c_int = 132; +pub const _SC_BARRIERS: c_int = 133; +pub const _SC_BASE: c_int = 134; +pub const _SC_C_LANG_SUPPORT: c_int = 135; +pub const _SC_C_LANG_SUPPORT_R: c_int = 136; +pub const _SC_CLOCK_SELECTION: c_int = 137; +pub const _SC_CPUTIME: c_int = 138; +pub const _SC_THREAD_CPUTIME: c_int = 139; +pub const _SC_DEVICE_IO: c_int = 140; +pub const _SC_DEVICE_SPECIFIC: c_int = 141; +pub const _SC_DEVICE_SPECIFIC_R: c_int = 142; +pub const _SC_FD_MGMT: c_int = 143; +pub const _SC_FIFO: c_int = 144; +pub const _SC_PIPE: c_int = 145; +pub const _SC_FILE_ATTRIBUTES: c_int = 146; +pub const _SC_FILE_LOCKING: c_int = 147; +pub const _SC_FILE_SYSTEM: c_int = 148; +pub const _SC_MONOTONIC_CLOCK: c_int = 149; +pub const _SC_MULTI_PROCESS: c_int = 150; +pub const _SC_SINGLE_PROCESS: c_int = 151; +pub const _SC_NETWORKING: c_int = 152; +pub const _SC_READER_WRITER_LOCKS: c_int = 153; +pub const _SC_SPIN_LOCKS: c_int = 154; +pub const _SC_REGEXP: c_int = 155; +pub const _SC_REGEX_VERSION: c_int = 156; +pub const _SC_SHELL: c_int = 157; +pub const _SC_SIGNALS: c_int = 158; +pub const _SC_SPAWN: c_int = 159; +pub const _SC_SPORADIC_SERVER: c_int = 160; +pub const _SC_THREAD_SPORADIC_SERVER: c_int = 161; +pub const _SC_SYSTEM_DATABASE: c_int = 162; +pub const _SC_SYSTEM_DATABASE_R: c_int = 163; +pub const _SC_TIMEOUTS: c_int = 164; +pub const _SC_TYPED_MEMORY_OBJECTS: c_int = 165; +pub const _SC_USER_GROUPS: c_int = 166; +pub const _SC_USER_GROUPS_R: c_int = 167; +pub const _SC_2_PBS: c_int = 168; +pub const _SC_2_PBS_ACCOUNTING: c_int = 169; +pub const _SC_2_PBS_LOCATE: c_int = 170; +pub const _SC_2_PBS_MESSAGE: c_int = 171; +pub const _SC_2_PBS_TRACK: c_int = 172; +pub const _SC_SYMLOOP_MAX: c_int = 173; +pub const _SC_STREAMS: c_int = 174; +pub const _SC_2_PBS_CHECKPOINT: c_int = 175; +pub const _SC_V6_ILP32_OFF32: c_int = 176; +pub const _SC_V6_ILP32_OFFBIG: c_int = 177; +pub const _SC_V6_LP64_OFF64: c_int = 178; +pub const _SC_V6_LPBIG_OFFBIG: c_int = 179; +pub const _SC_HOST_NAME_MAX: c_int = 180; +pub const _SC_TRACE: c_int = 181; +pub const _SC_TRACE_EVENT_FILTER: c_int = 182; +pub const _SC_TRACE_INHERIT: c_int = 183; +pub const _SC_TRACE_LOG: c_int = 184; +pub const _SC_LEVEL1_ICACHE_SIZE: c_int = 185; +pub const _SC_LEVEL1_ICACHE_ASSOC: c_int = 186; +pub const _SC_LEVEL1_ICACHE_LINESIZE: c_int = 187; +pub const _SC_LEVEL1_DCACHE_SIZE: c_int = 188; +pub const _SC_LEVEL1_DCACHE_ASSOC: c_int = 189; +pub const _SC_LEVEL1_DCACHE_LINESIZE: c_int = 190; +pub const _SC_LEVEL2_CACHE_SIZE: c_int = 191; +pub const _SC_LEVEL2_CACHE_ASSOC: c_int = 192; +pub const _SC_LEVEL2_CACHE_LINESIZE: c_int = 193; +pub const _SC_LEVEL3_CACHE_SIZE: c_int = 194; +pub const _SC_LEVEL3_CACHE_ASSOC: c_int = 195; +pub const _SC_LEVEL3_CACHE_LINESIZE: c_int = 196; +pub const _SC_LEVEL4_CACHE_SIZE: c_int = 197; +pub const _SC_LEVEL4_CACHE_ASSOC: c_int = 198; +pub const _SC_LEVEL4_CACHE_LINESIZE: c_int = 199; +pub const _SC_IPV6: c_int = 235; +pub const _SC_RAW_SOCKETS: c_int = 236; +pub const _SC_V7_ILP32_OFF32: c_int = 237; +pub const _SC_V7_ILP32_OFFBIG: c_int = 238; +pub const _SC_V7_LP64_OFF64: c_int = 239; +pub const _SC_V7_LPBIG_OFFBIG: c_int = 240; +pub const _SC_SS_REPL_MAX: c_int = 241; +pub const _SC_TRACE_EVENT_NAME_MAX: c_int = 242; +pub const _SC_TRACE_NAME_MAX: c_int = 243; +pub const _SC_TRACE_SYS_MAX: c_int = 244; +pub const _SC_TRACE_USER_EVENT_MAX: c_int = 245; +pub const _SC_XOPEN_STREAMS: c_int = 246; +pub const _SC_THREAD_ROBUST_PRIO_INHERIT: c_int = 247; +pub const _SC_THREAD_ROBUST_PRIO_PROTECT: c_int = 248; +pub const _SC_MINSIGSTKSZ: c_int = 249; +pub const _SC_SIGSTKSZ: c_int = 250; +const enum_unnamed_18 = c_uint; +pub const _CS_PATH: c_int = 0; +pub const _CS_V6_WIDTH_RESTRICTED_ENVS: c_int = 1; +pub const _CS_GNU_LIBC_VERSION: c_int = 2; +pub const _CS_GNU_LIBPTHREAD_VERSION: c_int = 3; +pub const _CS_V5_WIDTH_RESTRICTED_ENVS: c_int = 4; +pub const _CS_V7_WIDTH_RESTRICTED_ENVS: c_int = 5; +pub const _CS_LFS_CFLAGS: c_int = 1000; +pub const _CS_LFS_LDFLAGS: c_int = 1001; +pub const _CS_LFS_LIBS: c_int = 1002; +pub const _CS_LFS_LINTFLAGS: c_int = 1003; +pub const _CS_LFS64_CFLAGS: c_int = 1004; +pub const _CS_LFS64_LDFLAGS: c_int = 1005; +pub const _CS_LFS64_LIBS: c_int = 1006; +pub const _CS_LFS64_LINTFLAGS: c_int = 1007; +pub const _CS_XBS5_ILP32_OFF32_CFLAGS: c_int = 1100; +pub const _CS_XBS5_ILP32_OFF32_LDFLAGS: c_int = 1101; +pub const _CS_XBS5_ILP32_OFF32_LIBS: c_int = 1102; +pub const _CS_XBS5_ILP32_OFF32_LINTFLAGS: c_int = 1103; +pub const _CS_XBS5_ILP32_OFFBIG_CFLAGS: c_int = 1104; +pub const _CS_XBS5_ILP32_OFFBIG_LDFLAGS: c_int = 1105; +pub const _CS_XBS5_ILP32_OFFBIG_LIBS: c_int = 1106; +pub const _CS_XBS5_ILP32_OFFBIG_LINTFLAGS: c_int = 1107; +pub const _CS_XBS5_LP64_OFF64_CFLAGS: c_int = 1108; +pub const _CS_XBS5_LP64_OFF64_LDFLAGS: c_int = 1109; +pub const _CS_XBS5_LP64_OFF64_LIBS: c_int = 1110; +pub const _CS_XBS5_LP64_OFF64_LINTFLAGS: c_int = 1111; +pub const _CS_XBS5_LPBIG_OFFBIG_CFLAGS: c_int = 1112; +pub const _CS_XBS5_LPBIG_OFFBIG_LDFLAGS: c_int = 1113; +pub const _CS_XBS5_LPBIG_OFFBIG_LIBS: c_int = 1114; +pub const _CS_XBS5_LPBIG_OFFBIG_LINTFLAGS: c_int = 1115; +pub const _CS_POSIX_V6_ILP32_OFF32_CFLAGS: c_int = 1116; +pub const _CS_POSIX_V6_ILP32_OFF32_LDFLAGS: c_int = 1117; +pub const _CS_POSIX_V6_ILP32_OFF32_LIBS: c_int = 1118; +pub const _CS_POSIX_V6_ILP32_OFF32_LINTFLAGS: c_int = 1119; +pub const _CS_POSIX_V6_ILP32_OFFBIG_CFLAGS: c_int = 1120; +pub const _CS_POSIX_V6_ILP32_OFFBIG_LDFLAGS: c_int = 1121; +pub const _CS_POSIX_V6_ILP32_OFFBIG_LIBS: c_int = 1122; +pub const _CS_POSIX_V6_ILP32_OFFBIG_LINTFLAGS: c_int = 1123; +pub const _CS_POSIX_V6_LP64_OFF64_CFLAGS: c_int = 1124; +pub const _CS_POSIX_V6_LP64_OFF64_LDFLAGS: c_int = 1125; +pub const _CS_POSIX_V6_LP64_OFF64_LIBS: c_int = 1126; +pub const _CS_POSIX_V6_LP64_OFF64_LINTFLAGS: c_int = 1127; +pub const _CS_POSIX_V6_LPBIG_OFFBIG_CFLAGS: c_int = 1128; +pub const _CS_POSIX_V6_LPBIG_OFFBIG_LDFLAGS: c_int = 1129; +pub const _CS_POSIX_V6_LPBIG_OFFBIG_LIBS: c_int = 1130; +pub const _CS_POSIX_V6_LPBIG_OFFBIG_LINTFLAGS: c_int = 1131; +pub const _CS_POSIX_V7_ILP32_OFF32_CFLAGS: c_int = 1132; +pub const _CS_POSIX_V7_ILP32_OFF32_LDFLAGS: c_int = 1133; +pub const _CS_POSIX_V7_ILP32_OFF32_LIBS: c_int = 1134; +pub const _CS_POSIX_V7_ILP32_OFF32_LINTFLAGS: c_int = 1135; +pub const _CS_POSIX_V7_ILP32_OFFBIG_CFLAGS: c_int = 1136; +pub const _CS_POSIX_V7_ILP32_OFFBIG_LDFLAGS: c_int = 1137; +pub const _CS_POSIX_V7_ILP32_OFFBIG_LIBS: c_int = 1138; +pub const _CS_POSIX_V7_ILP32_OFFBIG_LINTFLAGS: c_int = 1139; +pub const _CS_POSIX_V7_LP64_OFF64_CFLAGS: c_int = 1140; +pub const _CS_POSIX_V7_LP64_OFF64_LDFLAGS: c_int = 1141; +pub const _CS_POSIX_V7_LP64_OFF64_LIBS: c_int = 1142; +pub const _CS_POSIX_V7_LP64_OFF64_LINTFLAGS: c_int = 1143; +pub const _CS_POSIX_V7_LPBIG_OFFBIG_CFLAGS: c_int = 1144; +pub const _CS_POSIX_V7_LPBIG_OFFBIG_LDFLAGS: c_int = 1145; +pub const _CS_POSIX_V7_LPBIG_OFFBIG_LIBS: c_int = 1146; +pub const _CS_POSIX_V7_LPBIG_OFFBIG_LINTFLAGS: c_int = 1147; +pub const _CS_V6_ENV: c_int = 1148; +pub const _CS_V7_ENV: c_int = 1149; +const enum_unnamed_19 = c_uint; +pub extern fn pathconf(__path: [*c]const u8, __name: c_int) c_long; +pub extern fn fpathconf(__fd: c_int, __name: c_int) c_long; +pub extern fn sysconf(__name: c_int) c_long; +pub extern fn confstr(__name: c_int, __buf: [*c]u8, __len: usize) usize; +pub extern fn getpid() __pid_t; +pub extern fn getppid() __pid_t; +pub extern fn getpgrp() __pid_t; +pub extern fn __getpgid(__pid: __pid_t) __pid_t; +pub extern fn getpgid(__pid: __pid_t) __pid_t; +pub extern fn setpgid(__pid: __pid_t, __pgid: __pid_t) c_int; +pub extern fn setpgrp() c_int; +pub extern fn setsid() __pid_t; +pub extern fn getsid(__pid: __pid_t) __pid_t; +pub extern fn getuid() __uid_t; +pub extern fn geteuid() __uid_t; +pub extern fn getgid() __gid_t; +pub extern fn getegid() __gid_t; +pub extern fn getgroups(__size: c_int, __list: [*c]__gid_t) c_int; +pub extern fn setuid(__uid: __uid_t) c_int; +pub extern fn setreuid(__ruid: __uid_t, __euid: __uid_t) c_int; +pub extern fn seteuid(__uid: __uid_t) c_int; +pub extern fn setgid(__gid: __gid_t) c_int; +pub extern fn setregid(__rgid: __gid_t, __egid: __gid_t) c_int; +pub extern fn setegid(__gid: __gid_t) c_int; +pub extern fn fork() __pid_t; +pub extern fn vfork() c_int; +pub extern fn ttyname(__fd: c_int) [*c]u8; +pub extern fn ttyname_r(__fd: c_int, __buf: [*c]u8, __buflen: usize) c_int; +pub extern fn isatty(__fd: c_int) c_int; +pub extern fn ttyslot() c_int; +pub extern fn link(__from: [*c]const u8, __to: [*c]const u8) c_int; +pub extern fn linkat(__fromfd: c_int, __from: [*c]const u8, __tofd: c_int, __to: [*c]const u8, __flags: c_int) c_int; +pub extern fn symlink(__from: [*c]const u8, __to: [*c]const u8) c_int; +pub extern fn readlink(noalias __path: [*c]const u8, noalias __buf: [*c]u8, __len: usize) isize; +pub extern fn symlinkat(__from: [*c]const u8, __tofd: c_int, __to: [*c]const u8) c_int; +pub extern fn readlinkat(__fd: c_int, noalias __path: [*c]const u8, noalias __buf: [*c]u8, __len: usize) isize; +pub extern fn unlink(__name: [*c]const u8) c_int; +pub extern fn unlinkat(__fd: c_int, __name: [*c]const u8, __flag: c_int) c_int; +pub extern fn rmdir(__path: [*c]const u8) c_int; +pub extern fn tcgetpgrp(__fd: c_int) __pid_t; +pub extern fn tcsetpgrp(__fd: c_int, __pgrp_id: __pid_t) c_int; +pub extern fn getlogin() [*c]u8; +pub extern fn getlogin_r(__name: [*c]u8, __name_len: usize) c_int; +pub extern fn setlogin(__name: [*c]const u8) c_int; +pub extern var optarg: [*c]u8; +pub extern var optind: c_int; +pub extern var opterr: c_int; +pub extern var optopt: c_int; +pub extern fn getopt(___argc: c_int, ___argv: [*c]const [*c]u8, __shortopts: [*c]const u8) c_int; +pub extern fn gethostname(__name: [*c]u8, __len: usize) c_int; +pub extern fn sethostname(__name: [*c]const u8, __len: usize) c_int; +pub extern fn sethostid(__id: c_long) c_int; +pub extern fn getdomainname(__name: [*c]u8, __len: usize) c_int; +pub extern fn setdomainname(__name: [*c]const u8, __len: usize) c_int; +pub extern fn vhangup() c_int; +pub extern fn revoke(__file: [*c]const u8) c_int; +pub extern fn profil(__sample_buffer: [*c]c_ushort, __size: usize, __offset: usize, __scale: c_uint) c_int; +pub extern fn acct(__name: [*c]const u8) c_int; +pub extern fn getusershell() [*c]u8; +pub extern fn endusershell() void; +pub extern fn setusershell() void; +pub extern fn daemon(__nochdir: c_int, __noclose: c_int) c_int; +pub extern fn chroot(__path: [*c]const u8) c_int; +pub extern fn getpass(__prompt: [*c]const u8) [*c]u8; +pub extern fn fsync(__fd: c_int) c_int; +pub extern fn gethostid() c_long; +pub extern fn sync() void; +pub extern fn getpagesize() c_int; +pub extern fn getdtablesize() c_int; +pub extern fn truncate(__file: [*c]const u8, __length: __off_t) c_int; +pub extern fn ftruncate(__fd: c_int, __length: __off_t) c_int; +pub extern fn brk(__addr: ?*anyopaque) c_int; +pub extern fn sbrk(__delta: isize) ?*anyopaque; +pub extern fn syscall(__sysno: c_long, ...) c_long; +pub extern fn lockf(__fd: c_int, __cmd: c_int, __len: __off_t) c_int; +pub extern fn fdatasync(__fildes: c_int) c_int; +pub extern fn crypt(__key: [*c]const u8, __salt: [*c]const u8) [*c]u8; +pub extern fn getentropy(__buffer: ?*anyopaque, __length: usize) c_int; +pub fn LoadOBJ(arg_fileName: [*c]const u8) callconv(.C) Model { + var fileName = arg_fileName; + _ = &fileName; + var objAttributes: tinyobj_attrib_t = tinyobj_attrib_t{ + .num_vertices = @as(c_uint, @bitCast(@as(c_int, 0))), + .num_normals = 0, + .num_texcoords = 0, + .num_faces = 0, + .num_face_num_verts = 0, + .pad0 = 0, + .vertices = null, + .normals = null, + .texcoords = null, + .faces = null, + .face_num_verts = null, + .material_ids = null, + }; + _ = &objAttributes; + var objShapes: [*c]tinyobj_shape_t = null; + _ = &objShapes; + var objShapeCount: c_uint = 0; + _ = &objShapeCount; + var objMaterials: [*c]tinyobj_material_t = null; + _ = &objMaterials; + var objMaterialCount: c_uint = 0; + _ = &objMaterialCount; + var model: Model = Model{ + .transform = Matrix{ + .m0 = @as(f32, @floatFromInt(@as(c_int, 0))), + .m4 = 0, + .m8 = 0, + .m12 = 0, + .m1 = 0, + .m5 = 0, + .m9 = 0, + .m13 = 0, + .m2 = 0, + .m6 = 0, + .m10 = 0, + .m14 = 0, + .m3 = 0, + .m7 = 0, + .m11 = 0, + .m15 = 0, + }, + .meshCount = 0, + .materialCount = 0, + .meshes = null, + .materials = null, + .meshMaterial = null, + .boneCount = 0, + .bones = null, + .bindPose = null, + }; + _ = &model; + model.transform = MatrixIdentity(); + var fileText: [*c]u8 = LoadFileText(fileName); + _ = &fileText; + if (fileText == @as([*c]u8, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0))))))) { + TraceLog(LOG_ERROR, "MODEL Unable to read obj file %s", fileName); + return model; + } + var currentDir: [1024]u8 = [1]u8{ + 0, + } ++ [1]u8{0} ** 1023; + _ = ¤tDir; + _ = strcpy(@as([*c]u8, @ptrCast(@alignCast(¤tDir))), GetWorkingDirectory()); + var workingDir: [*c]const u8 = GetDirectoryPath(fileName); + _ = &workingDir; + if (chdir(workingDir) != @as(c_int, 0)) { + TraceLog(LOG_WARNING, "MODEL: [%s] Failed to change working directory", workingDir); + } + var dataSize: c_uint = @as(c_uint, @bitCast(@as(c_uint, @truncate(strlen(fileText))))); + _ = &dataSize; + var flags: c_uint = @as(c_uint, @bitCast(@as(c_int, 1) << @intCast(0))); + _ = &flags; + var ret: c_int = tinyobj_parse_obj(&objAttributes, &objShapes, &objShapeCount, &objMaterials, &objMaterialCount, fileText, dataSize, flags); + _ = &ret; + if (ret != @as(c_int, 0)) { + TraceLog(LOG_ERROR, "MODEL Unable to read obj data %s", fileName); + return model; + } + UnloadFileText(fileText); + var faceVertIndex: c_uint = 0; + _ = &faceVertIndex; + var nextShape: c_uint = 1; + _ = &nextShape; + var lastMaterial: c_int = -@as(c_int, 1); + _ = &lastMaterial; + var meshIndex: c_uint = 0; + _ = &meshIndex; + var nextShapeEnd: c_uint = objAttributes.num_face_num_verts; + _ = &nextShapeEnd; + if (objShapeCount > @as(c_uint, @bitCast(@as(c_int, 1)))) { + nextShapeEnd = objShapes[nextShape].face_offset; + } + { + var faceId: c_uint = 0; + _ = &faceId; + while (faceId < objAttributes.num_faces) : (faceId +%= 1) { + if (faceVertIndex >= nextShapeEnd) { + nextShape +%= 1; + if (nextShape < objShapeCount) { + nextShapeEnd = objShapes[nextShape].face_offset; + } else { + nextShapeEnd = objAttributes.num_face_num_verts; + } + meshIndex +%= 1; + } else if ((lastMaterial != -@as(c_int, 1)) and (objAttributes.material_ids[faceId] != lastMaterial)) { + meshIndex +%= 1; + } + lastMaterial = objAttributes.material_ids[faceId]; + faceVertIndex +%= @as(c_uint, @bitCast(objAttributes.face_num_verts[faceId])); + } + } + model.meshCount = @as(c_int, @bitCast(meshIndex +% @as(c_uint, @bitCast(@as(c_int, 1))))); + model.meshes = @as([*c]Mesh, @ptrCast(@alignCast(MemAlloc(@as(c_uint, @bitCast(@as(c_uint, @truncate(@sizeOf(Mesh) *% @as(c_ulong, @bitCast(@as(c_long, model.meshCount))))))))))); + if (objMaterialCount > @as(c_uint, @bitCast(@as(c_int, 0)))) { + model.materialCount = @as(c_int, @bitCast(objMaterialCount)); + model.materials = @as([*c]Material, @ptrCast(@alignCast(MemAlloc(@as(c_uint, @bitCast(@as(c_uint, @truncate(@sizeOf(Material) *% @as(c_ulong, @bitCast(@as(c_ulong, objMaterialCount))))))))))); + } else { + model.materialCount = 1; + model.materials = @as([*c]Material, @ptrCast(@alignCast(MemAlloc(@as(c_uint, @bitCast(@as(c_uint, @truncate(@sizeOf(Material) *% @as(c_ulong, @bitCast(@as(c_long, @as(c_int, 1)))))))))))); + } + model.meshMaterial = @as([*c]c_int, @ptrCast(@alignCast(MemAlloc(@as(c_uint, @bitCast(@as(c_uint, @truncate(@sizeOf(c_int) *% @as(c_ulong, @bitCast(@as(c_long, model.meshCount))))))))))); + var localMeshVertexCounts: [*c]c_uint = @as([*c]c_uint, @ptrCast(@alignCast(MemAlloc(@as(c_uint, @bitCast(@as(c_uint, @truncate(@sizeOf(c_uint) *% @as(c_ulong, @bitCast(@as(c_long, model.meshCount))))))))))); + _ = &localMeshVertexCounts; + faceVertIndex = 0; + nextShapeEnd = objAttributes.num_face_num_verts; + lastMaterial = -@as(c_int, 1); + meshIndex = 0; + var localMeshVertexCount: c_uint = 0; + _ = &localMeshVertexCount; + nextShape = 1; + if (objShapeCount > @as(c_uint, @bitCast(@as(c_int, 1)))) { + nextShapeEnd = objShapes[nextShape].face_offset; + } + { + var faceId: c_uint = 0; + _ = &faceId; + while (faceId < objAttributes.num_faces) : (faceId +%= 1) { + var newMesh: bool = @as(c_int, 0) != 0; + _ = &newMesh; + if (faceVertIndex >= nextShapeEnd) { + nextShape +%= 1; + if (nextShape < objShapeCount) { + nextShapeEnd = objShapes[nextShape].face_offset; + } else { + nextShapeEnd = objAttributes.num_face_num_verts; + } + newMesh = @as(c_int, 1) != 0; + } else if ((lastMaterial != -@as(c_int, 1)) and (objAttributes.material_ids[faceId] != lastMaterial)) { + newMesh = @as(c_int, 1) != 0; + } + lastMaterial = objAttributes.material_ids[faceId]; + if (newMesh) { + localMeshVertexCounts[meshIndex] = localMeshVertexCount; + localMeshVertexCount = 0; + meshIndex +%= 1; + } + faceVertIndex +%= @as(c_uint, @bitCast(objAttributes.face_num_verts[faceId])); + localMeshVertexCount +%= @as(c_uint, @bitCast(objAttributes.face_num_verts[faceId])); + } + } + localMeshVertexCounts[meshIndex] = localMeshVertexCount; + { + var i: c_int = 0; + _ = &i; + while (i < model.meshCount) : (i += 1) { + var vertexCount: c_uint = (blk: { + const tmp = i; + if (tmp >= 0) break :blk localMeshVertexCounts + @as(usize, @intCast(tmp)) else break :blk localMeshVertexCounts - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*; + _ = &vertexCount; + (blk: { + const tmp = i; + if (tmp >= 0) break :blk model.meshes + @as(usize, @intCast(tmp)) else break :blk model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.vertexCount = @as(c_int, @bitCast(vertexCount)); + (blk: { + const tmp = i; + if (tmp >= 0) break :blk model.meshes + @as(usize, @intCast(tmp)) else break :blk model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.triangleCount = @as(c_int, @bitCast(vertexCount / @as(c_uint, @bitCast(@as(c_int, 3))))); + (blk: { + const tmp = i; + if (tmp >= 0) break :blk model.meshes + @as(usize, @intCast(tmp)) else break :blk model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.vertices = @as([*c]f32, @ptrCast(@alignCast(MemAlloc(@as(c_uint, @bitCast(@as(c_uint, @truncate((@sizeOf(f32) *% @as(c_ulong, @bitCast(@as(c_ulong, vertexCount)))) *% @as(c_ulong, @bitCast(@as(c_long, @as(c_int, 3)))))))))))); + (blk: { + const tmp = i; + if (tmp >= 0) break :blk model.meshes + @as(usize, @intCast(tmp)) else break :blk model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.normals = @as([*c]f32, @ptrCast(@alignCast(MemAlloc(@as(c_uint, @bitCast(@as(c_uint, @truncate((@sizeOf(f32) *% @as(c_ulong, @bitCast(@as(c_ulong, vertexCount)))) *% @as(c_ulong, @bitCast(@as(c_long, @as(c_int, 3)))))))))))); + (blk: { + const tmp = i; + if (tmp >= 0) break :blk model.meshes + @as(usize, @intCast(tmp)) else break :blk model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.texcoords = @as([*c]f32, @ptrCast(@alignCast(MemAlloc(@as(c_uint, @bitCast(@as(c_uint, @truncate((@sizeOf(f32) *% @as(c_ulong, @bitCast(@as(c_ulong, vertexCount)))) *% @as(c_ulong, @bitCast(@as(c_long, @as(c_int, 2)))))))))))); + (blk: { + const tmp = i; + if (tmp >= 0) break :blk model.meshes + @as(usize, @intCast(tmp)) else break :blk model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.colors = @as([*c]u8, @ptrCast(@alignCast(MemAlloc(@as(c_uint, @bitCast(@as(c_uint, @truncate((@sizeOf(u8) *% @as(c_ulong, @bitCast(@as(c_ulong, vertexCount)))) *% @as(c_ulong, @bitCast(@as(c_long, @as(c_int, 4)))))))))))); + } + } + MemFree(@as(?*anyopaque, @ptrCast(localMeshVertexCounts))); + localMeshVertexCounts = null; + faceVertIndex = 0; + nextShapeEnd = objAttributes.num_face_num_verts; + nextShape = 1; + if (objShapeCount > @as(c_uint, @bitCast(@as(c_int, 1)))) { + nextShapeEnd = objShapes[nextShape].face_offset; + } + lastMaterial = -@as(c_int, 1); + meshIndex = 0; + localMeshVertexCount = 0; + { + var faceId: c_uint = 0; + _ = &faceId; + while (faceId < objAttributes.num_faces) : (faceId +%= 1) { + var newMesh: bool = @as(c_int, 0) != 0; + _ = &newMesh; + if (faceVertIndex >= nextShapeEnd) { + nextShape +%= 1; + if (nextShape < objShapeCount) { + nextShapeEnd = objShapes[nextShape].face_offset; + } else { + nextShapeEnd = objAttributes.num_face_num_verts; + } + newMesh = @as(c_int, 1) != 0; + } + if ((lastMaterial != -@as(c_int, 1)) and (objAttributes.material_ids[faceId] != lastMaterial)) { + newMesh = @as(c_int, 1) != 0; + } + lastMaterial = objAttributes.material_ids[faceId]; + if (newMesh) { + localMeshVertexCount = 0; + meshIndex +%= 1; + } + var matId: c_int = 0; + _ = &matId; + if ((lastMaterial >= @as(c_int, 0)) and (lastMaterial < @as(c_int, @bitCast(objMaterialCount)))) { + matId = lastMaterial; + } + model.meshMaterial[meshIndex] = matId; + { + var f: c_int = 0; + _ = &f; + while (f < objAttributes.face_num_verts[faceId]) : (f += 1) { + var vertIndex: c_int = objAttributes.faces[faceVertIndex].v_idx; + _ = &vertIndex; + var normalIndex: c_int = objAttributes.faces[faceVertIndex].vn_idx; + _ = &normalIndex; + var texcordIndex: c_int = objAttributes.faces[faceVertIndex].vt_idx; + _ = &texcordIndex; + { + var i: c_int = 0; + _ = &i; + while (i < @as(c_int, 3)) : (i += 1) { + model.meshes[meshIndex].vertices[(localMeshVertexCount *% @as(c_uint, @bitCast(@as(c_int, 3)))) +% @as(c_uint, @bitCast(i))] = (blk: { + const tmp = (vertIndex * @as(c_int, 3)) + i; + if (tmp >= 0) break :blk objAttributes.vertices + @as(usize, @intCast(tmp)) else break :blk objAttributes.vertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*; + } + } + { + var i: c_int = 0; + _ = &i; + while (i < @as(c_int, 3)) : (i += 1) { + model.meshes[meshIndex].normals[(localMeshVertexCount *% @as(c_uint, @bitCast(@as(c_int, 3)))) +% @as(c_uint, @bitCast(i))] = (blk: { + const tmp = (normalIndex * @as(c_int, 3)) + i; + if (tmp >= 0) break :blk objAttributes.normals + @as(usize, @intCast(tmp)) else break :blk objAttributes.normals - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*; + } + } + { + var i: c_int = 0; + _ = &i; + while (i < @as(c_int, 2)) : (i += 1) { + model.meshes[meshIndex].texcoords[(localMeshVertexCount *% @as(c_uint, @bitCast(@as(c_int, 2)))) +% @as(c_uint, @bitCast(i))] = (blk: { + const tmp = (texcordIndex * @as(c_int, 2)) + i; + if (tmp >= 0) break :blk objAttributes.texcoords + @as(usize, @intCast(tmp)) else break :blk objAttributes.texcoords - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*; + } + } + model.meshes[meshIndex].texcoords[(localMeshVertexCount *% @as(c_uint, @bitCast(@as(c_int, 2)))) +% @as(c_uint, @bitCast(@as(c_int, 1)))] = 1.0 - model.meshes[meshIndex].texcoords[(localMeshVertexCount *% @as(c_uint, @bitCast(@as(c_int, 2)))) +% @as(c_uint, @bitCast(@as(c_int, 1)))]; + { + var i: c_int = 0; + _ = &i; + while (i < @as(c_int, 4)) : (i += 1) { + model.meshes[meshIndex].colors[(localMeshVertexCount *% @as(c_uint, @bitCast(@as(c_int, 4)))) +% @as(c_uint, @bitCast(i))] = 255; + } + } + faceVertIndex +%= 1; + localMeshVertexCount +%= 1; + } + } + } + } + if (objMaterialCount > @as(c_uint, @bitCast(@as(c_int, 0)))) { + ProcessMaterialsOBJ(model.materials, objMaterials, @as(c_int, @bitCast(objMaterialCount))); + } else { + model.materials[@as(c_uint, @intCast(@as(c_int, 0)))] = LoadMaterialDefault(); + } + tinyobj_attrib_free(&objAttributes); + tinyobj_shapes_free(objShapes, objShapeCount); + tinyobj_materials_free(objMaterials, objMaterialCount); + { + var i: c_int = 0; + _ = &i; + while (i < model.meshCount) : (i += 1) { + UploadMesh(model.meshes + @as(usize, @bitCast(@as(isize, @intCast(i)))), @as(c_int, 1) != 0); + } + } + if (chdir(@as([*c]u8, @ptrCast(@alignCast(¤tDir)))) != @as(c_int, 0)) { + TraceLog(LOG_WARNING, "MODEL: [%s] Failed to change working directory", @as([*c]u8, @ptrCast(@alignCast(¤tDir)))); + } + return model; +} +pub fn LoadIQM(arg_fileName: [*c]const u8) callconv(.C) Model { + var fileName = arg_fileName; + _ = &fileName; + var dataSize: c_int = 0; + _ = &dataSize; + var fileData: [*c]u8 = LoadFileData(fileName, &dataSize); + _ = &fileData; + var fileDataPtr: [*c]u8 = fileData; + _ = &fileDataPtr; + const struct_IQMHeader = extern struct { + magic: [16]u8 = @import("std").mem.zeroes([16]u8), + version: c_uint = @import("std").mem.zeroes(c_uint), + dataSize: c_uint = @import("std").mem.zeroes(c_uint), + flags: c_uint = @import("std").mem.zeroes(c_uint), + num_text: c_uint = @import("std").mem.zeroes(c_uint), + ofs_text: c_uint = @import("std").mem.zeroes(c_uint), + num_meshes: c_uint = @import("std").mem.zeroes(c_uint), + ofs_meshes: c_uint = @import("std").mem.zeroes(c_uint), + num_vertexarrays: c_uint = @import("std").mem.zeroes(c_uint), + num_vertexes: c_uint = @import("std").mem.zeroes(c_uint), + ofs_vertexarrays: c_uint = @import("std").mem.zeroes(c_uint), + num_triangles: c_uint = @import("std").mem.zeroes(c_uint), + ofs_triangles: c_uint = @import("std").mem.zeroes(c_uint), + ofs_adjacency: c_uint = @import("std").mem.zeroes(c_uint), + num_joints: c_uint = @import("std").mem.zeroes(c_uint), + ofs_joints: c_uint = @import("std").mem.zeroes(c_uint), + num_poses: c_uint = @import("std").mem.zeroes(c_uint), + ofs_poses: c_uint = @import("std").mem.zeroes(c_uint), + num_anims: c_uint = @import("std").mem.zeroes(c_uint), + ofs_anims: c_uint = @import("std").mem.zeroes(c_uint), + num_frames: c_uint = @import("std").mem.zeroes(c_uint), + num_framechannels: c_uint = @import("std").mem.zeroes(c_uint), + ofs_frames: c_uint = @import("std").mem.zeroes(c_uint), + ofs_bounds: c_uint = @import("std").mem.zeroes(c_uint), + num_comment: c_uint = @import("std").mem.zeroes(c_uint), + ofs_comment: c_uint = @import("std").mem.zeroes(c_uint), + num_extensions: c_uint = @import("std").mem.zeroes(c_uint), + ofs_extensions: c_uint = @import("std").mem.zeroes(c_uint), + }; + _ = &struct_IQMHeader; + const IQMHeader = struct_IQMHeader; + _ = &IQMHeader; + const struct_IQMMesh = extern struct { + name: c_uint = @import("std").mem.zeroes(c_uint), + material: c_uint = @import("std").mem.zeroes(c_uint), + first_vertex: c_uint = @import("std").mem.zeroes(c_uint), + num_vertexes: c_uint = @import("std").mem.zeroes(c_uint), + first_triangle: c_uint = @import("std").mem.zeroes(c_uint), + num_triangles: c_uint = @import("std").mem.zeroes(c_uint), + }; + _ = &struct_IQMMesh; + const IQMMesh = struct_IQMMesh; + _ = &IQMMesh; + const struct_IQMTriangle = extern struct { + vertex: [3]c_uint = @import("std").mem.zeroes([3]c_uint), + }; + _ = &struct_IQMTriangle; + const IQMTriangle = struct_IQMTriangle; + _ = &IQMTriangle; + const struct_IQMJoint = extern struct { + name: c_uint = @import("std").mem.zeroes(c_uint), + parent: c_int = @import("std").mem.zeroes(c_int), + translate: [3]f32 = @import("std").mem.zeroes([3]f32), + rotate: [4]f32 = @import("std").mem.zeroes([4]f32), + scale: [3]f32 = @import("std").mem.zeroes([3]f32), + }; + _ = &struct_IQMJoint; + const IQMJoint = struct_IQMJoint; + _ = &IQMJoint; + const struct_IQMVertexArray = extern struct { + type: c_uint = @import("std").mem.zeroes(c_uint), + flags: c_uint = @import("std").mem.zeroes(c_uint), + format: c_uint = @import("std").mem.zeroes(c_uint), + size: c_uint = @import("std").mem.zeroes(c_uint), + offset: c_uint = @import("std").mem.zeroes(c_uint), + }; + _ = &struct_IQMVertexArray; + const IQMVertexArray = struct_IQMVertexArray; + _ = &IQMVertexArray; + const IQM_POSITION: c_int = 0; + _ = &IQM_POSITION; + const IQM_TEXCOORD: c_int = 1; + _ = &IQM_TEXCOORD; + const IQM_NORMAL: c_int = 2; + _ = &IQM_NORMAL; + const IQM_TANGENT: c_int = 3; + _ = &IQM_TANGENT; + const IQM_BLENDINDEXES: c_int = 4; + _ = &IQM_BLENDINDEXES; + const IQM_BLENDWEIGHTS: c_int = 5; + _ = &IQM_BLENDWEIGHTS; + const IQM_COLOR: c_int = 6; + _ = &IQM_COLOR; + const IQM_CUSTOM: c_int = 16; + _ = &IQM_CUSTOM; + const enum_unnamed_20 = c_uint; + _ = &enum_unnamed_20; + var model: Model = Model{ + .transform = Matrix{ + .m0 = @as(f32, @floatFromInt(@as(c_int, 0))), + .m4 = 0, + .m8 = 0, + .m12 = 0, + .m1 = 0, + .m5 = 0, + .m9 = 0, + .m13 = 0, + .m2 = 0, + .m6 = 0, + .m10 = 0, + .m14 = 0, + .m3 = 0, + .m7 = 0, + .m11 = 0, + .m15 = 0, + }, + .meshCount = 0, + .materialCount = 0, + .meshes = null, + .materials = null, + .meshMaterial = null, + .boneCount = 0, + .bones = null, + .bindPose = null, + }; + _ = &model; + var imesh: [*c]IQMMesh = null; + _ = &imesh; + var tri: [*c]IQMTriangle = null; + _ = &tri; + var va: [*c]IQMVertexArray = null; + _ = &va; + var ijoint: [*c]IQMJoint = null; + _ = &ijoint; + var vertex: [*c]f32 = null; + _ = &vertex; + var normal: [*c]f32 = null; + _ = &normal; + var text: [*c]f32 = null; + _ = &text; + var blendi: [*c]u8 = null; + _ = &blendi; + var blendw: [*c]u8 = null; + _ = &blendw; + var color: [*c]u8 = null; + _ = &color; + if (fileDataPtr == @as([*c]u8, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0))))))) return model; + var basePath: [*c]const u8 = GetDirectoryPath(fileName); + _ = &basePath; + var iqmHeader: [*c]IQMHeader = @as([*c]IQMHeader, @ptrCast(@alignCast(fileDataPtr))); + _ = &iqmHeader; + if (memcmp(@as(?*const anyopaque, @ptrCast(@as([*c]u8, @ptrCast(@alignCast(&iqmHeader.*.magic))))), @as(?*const anyopaque, @ptrCast("INTERQUAKEMODEL")), @sizeOf([16]u8)) != @as(c_int, 0)) { + TraceLog(LOG_WARNING, "MODEL: [%s] IQM file is not a valid model", fileName); + return model; + } + if (iqmHeader.*.version != @as(c_uint, @bitCast(@as(c_int, 2)))) { + TraceLog(LOG_WARNING, "MODEL: [%s] IQM file version not supported (%i)", fileName, iqmHeader.*.version); + return model; + } + imesh = @as([*c]IQMMesh, @ptrCast(@alignCast(malloc(@as(c_ulong, @bitCast(@as(c_ulong, iqmHeader.*.num_meshes))) *% @sizeOf(IQMMesh))))); + _ = memcpy(@as(?*anyopaque, @ptrCast(imesh)), @as(?*const anyopaque, @ptrCast(fileDataPtr + iqmHeader.*.ofs_meshes)), @as(c_ulong, @bitCast(@as(c_ulong, iqmHeader.*.num_meshes))) *% @sizeOf(IQMMesh)); + model.meshCount = @as(c_int, @bitCast(iqmHeader.*.num_meshes)); + model.meshes = @as([*c]Mesh, @ptrCast(@alignCast(calloc(@as(c_ulong, @bitCast(@as(c_long, model.meshCount))), @sizeOf(Mesh))))); + model.materialCount = model.meshCount; + model.materials = @as([*c]Material, @ptrCast(@alignCast(calloc(@as(c_ulong, @bitCast(@as(c_long, model.materialCount))), @sizeOf(Material))))); + model.meshMaterial = @as([*c]c_int, @ptrCast(@alignCast(calloc(@as(c_ulong, @bitCast(@as(c_long, model.meshCount))), @sizeOf(c_int))))); + var name: [32]u8 = [1]u8{ + 0, + } ++ [1]u8{0} ** 31; + _ = &name; + var material: [32]u8 = [1]u8{ + 0, + } ++ [1]u8{0} ** 31; + _ = &material; + { + var i: c_int = 0; + _ = &i; + while (i < model.meshCount) : (i += 1) { + _ = memcpy(@as(?*anyopaque, @ptrCast(@as([*c]u8, @ptrCast(@alignCast(&name))))), @as(?*const anyopaque, @ptrCast((fileDataPtr + iqmHeader.*.ofs_text) + (blk: { + const tmp = i; + if (tmp >= 0) break :blk imesh + @as(usize, @intCast(tmp)) else break :blk imesh - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.name)), @as(c_ulong, @bitCast(@as(c_long, @as(c_int, 32)))) *% @sizeOf(u8)); + _ = memcpy(@as(?*anyopaque, @ptrCast(@as([*c]u8, @ptrCast(@alignCast(&material))))), @as(?*const anyopaque, @ptrCast((fileDataPtr + iqmHeader.*.ofs_text) + (blk: { + const tmp = i; + if (tmp >= 0) break :blk imesh + @as(usize, @intCast(tmp)) else break :blk imesh - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.material)), @as(c_ulong, @bitCast(@as(c_long, @as(c_int, 32)))) *% @sizeOf(u8)); + (blk: { + const tmp = i; + if (tmp >= 0) break :blk model.materials + @as(usize, @intCast(tmp)) else break :blk model.materials - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = LoadMaterialDefault(); + (blk: { + const tmp = MATERIAL_MAP_ALBEDO; + if (tmp >= 0) break :blk (blk_1: { + const tmp_2 = i; + if (tmp_2 >= 0) break :blk_1 model.materials + @as(usize, @intCast(tmp_2)) else break :blk_1 model.materials - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.maps + @as(usize, @intCast(tmp)) else break :blk (blk_1: { + const tmp_2 = i; + if (tmp_2 >= 0) break :blk_1 model.materials + @as(usize, @intCast(tmp_2)) else break :blk_1 model.materials - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.maps - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.texture = LoadTexture(TextFormat("%s/%s", basePath, @as([*c]u8, @ptrCast(@alignCast(&material))))); + (blk: { + const tmp = i; + if (tmp >= 0) break :blk model.meshMaterial + @as(usize, @intCast(tmp)) else break :blk model.meshMaterial - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = i; + TraceLog(LOG_DEBUG, "MODEL: [%s] mesh name (%s), material (%s)", fileName, @as([*c]u8, @ptrCast(@alignCast(&name))), @as([*c]u8, @ptrCast(@alignCast(&material)))); + (blk: { + const tmp = i; + if (tmp >= 0) break :blk model.meshes + @as(usize, @intCast(tmp)) else break :blk model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.vertexCount = @as(c_int, @bitCast((blk: { + const tmp = i; + if (tmp >= 0) break :blk imesh + @as(usize, @intCast(tmp)) else break :blk imesh - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.num_vertexes)); + (blk: { + const tmp = i; + if (tmp >= 0) break :blk model.meshes + @as(usize, @intCast(tmp)) else break :blk model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.vertices = @as([*c]f32, @ptrCast(@alignCast(calloc(@as(c_ulong, @bitCast(@as(c_long, (blk: { + const tmp = i; + if (tmp >= 0) break :blk model.meshes + @as(usize, @intCast(tmp)) else break :blk model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.vertexCount * @as(c_int, 3)))), @sizeOf(f32))))); + (blk: { + const tmp = i; + if (tmp >= 0) break :blk model.meshes + @as(usize, @intCast(tmp)) else break :blk model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.normals = @as([*c]f32, @ptrCast(@alignCast(calloc(@as(c_ulong, @bitCast(@as(c_long, (blk: { + const tmp = i; + if (tmp >= 0) break :blk model.meshes + @as(usize, @intCast(tmp)) else break :blk model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.vertexCount * @as(c_int, 3)))), @sizeOf(f32))))); + (blk: { + const tmp = i; + if (tmp >= 0) break :blk model.meshes + @as(usize, @intCast(tmp)) else break :blk model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.texcoords = @as([*c]f32, @ptrCast(@alignCast(calloc(@as(c_ulong, @bitCast(@as(c_long, (blk: { + const tmp = i; + if (tmp >= 0) break :blk model.meshes + @as(usize, @intCast(tmp)) else break :blk model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.vertexCount * @as(c_int, 2)))), @sizeOf(f32))))); + (blk: { + const tmp = i; + if (tmp >= 0) break :blk model.meshes + @as(usize, @intCast(tmp)) else break :blk model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.boneIds = @as([*c]u8, @ptrCast(@alignCast(calloc(@as(c_ulong, @bitCast(@as(c_long, (blk: { + const tmp = i; + if (tmp >= 0) break :blk model.meshes + @as(usize, @intCast(tmp)) else break :blk model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.vertexCount * @as(c_int, 4)))), @sizeOf(u8))))); + (blk: { + const tmp = i; + if (tmp >= 0) break :blk model.meshes + @as(usize, @intCast(tmp)) else break :blk model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.boneWeights = @as([*c]f32, @ptrCast(@alignCast(calloc(@as(c_ulong, @bitCast(@as(c_long, (blk: { + const tmp = i; + if (tmp >= 0) break :blk model.meshes + @as(usize, @intCast(tmp)) else break :blk model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.vertexCount * @as(c_int, 4)))), @sizeOf(f32))))); + (blk: { + const tmp = i; + if (tmp >= 0) break :blk model.meshes + @as(usize, @intCast(tmp)) else break :blk model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.triangleCount = @as(c_int, @bitCast((blk: { + const tmp = i; + if (tmp >= 0) break :blk imesh + @as(usize, @intCast(tmp)) else break :blk imesh - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.num_triangles)); + (blk: { + const tmp = i; + if (tmp >= 0) break :blk model.meshes + @as(usize, @intCast(tmp)) else break :blk model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.indices = @as([*c]c_ushort, @ptrCast(@alignCast(calloc(@as(c_ulong, @bitCast(@as(c_long, (blk: { + const tmp = i; + if (tmp >= 0) break :blk model.meshes + @as(usize, @intCast(tmp)) else break :blk model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.triangleCount * @as(c_int, 3)))), @sizeOf(c_ushort))))); + (blk: { + const tmp = i; + if (tmp >= 0) break :blk model.meshes + @as(usize, @intCast(tmp)) else break :blk model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.animVertices = @as([*c]f32, @ptrCast(@alignCast(calloc(@as(c_ulong, @bitCast(@as(c_long, (blk: { + const tmp = i; + if (tmp >= 0) break :blk model.meshes + @as(usize, @intCast(tmp)) else break :blk model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.vertexCount * @as(c_int, 3)))), @sizeOf(f32))))); + (blk: { + const tmp = i; + if (tmp >= 0) break :blk model.meshes + @as(usize, @intCast(tmp)) else break :blk model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.animNormals = @as([*c]f32, @ptrCast(@alignCast(calloc(@as(c_ulong, @bitCast(@as(c_long, (blk: { + const tmp = i; + if (tmp >= 0) break :blk model.meshes + @as(usize, @intCast(tmp)) else break :blk model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.vertexCount * @as(c_int, 3)))), @sizeOf(f32))))); + } + } + tri = @as([*c]IQMTriangle, @ptrCast(@alignCast(malloc(@as(c_ulong, @bitCast(@as(c_ulong, iqmHeader.*.num_triangles))) *% @sizeOf(IQMTriangle))))); + _ = memcpy(@as(?*anyopaque, @ptrCast(tri)), @as(?*const anyopaque, @ptrCast(fileDataPtr + iqmHeader.*.ofs_triangles)), @as(c_ulong, @bitCast(@as(c_ulong, iqmHeader.*.num_triangles))) *% @sizeOf(IQMTriangle)); + { + var m: c_int = 0; + _ = &m; + while (m < model.meshCount) : (m += 1) { + var tcounter: c_int = 0; + _ = &tcounter; + { + var i: c_uint = (blk: { + const tmp = m; + if (tmp >= 0) break :blk imesh + @as(usize, @intCast(tmp)) else break :blk imesh - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.first_triangle; + _ = &i; + while (i < ((blk: { + const tmp = m; + if (tmp >= 0) break :blk imesh + @as(usize, @intCast(tmp)) else break :blk imesh - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.first_triangle +% (blk: { + const tmp = m; + if (tmp >= 0) break :blk imesh + @as(usize, @intCast(tmp)) else break :blk imesh - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.num_triangles)) : (i +%= 1) { + (blk: { + const tmp = tcounter + @as(c_int, 2); + if (tmp >= 0) break :blk (blk_1: { + const tmp_2 = m; + if (tmp_2 >= 0) break :blk_1 model.meshes + @as(usize, @intCast(tmp_2)) else break :blk_1 model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.indices + @as(usize, @intCast(tmp)) else break :blk (blk_1: { + const tmp_2 = m; + if (tmp_2 >= 0) break :blk_1 model.meshes + @as(usize, @intCast(tmp_2)) else break :blk_1 model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.indices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = @as(c_ushort, @bitCast(@as(c_ushort, @truncate(tri[i].vertex[@as(c_uint, @intCast(@as(c_int, 0)))] -% (blk: { + const tmp = m; + if (tmp >= 0) break :blk imesh + @as(usize, @intCast(tmp)) else break :blk imesh - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.first_vertex)))); + (blk: { + const tmp = tcounter + @as(c_int, 1); + if (tmp >= 0) break :blk (blk_1: { + const tmp_2 = m; + if (tmp_2 >= 0) break :blk_1 model.meshes + @as(usize, @intCast(tmp_2)) else break :blk_1 model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.indices + @as(usize, @intCast(tmp)) else break :blk (blk_1: { + const tmp_2 = m; + if (tmp_2 >= 0) break :blk_1 model.meshes + @as(usize, @intCast(tmp_2)) else break :blk_1 model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.indices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = @as(c_ushort, @bitCast(@as(c_ushort, @truncate(tri[i].vertex[@as(c_uint, @intCast(@as(c_int, 1)))] -% (blk: { + const tmp = m; + if (tmp >= 0) break :blk imesh + @as(usize, @intCast(tmp)) else break :blk imesh - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.first_vertex)))); + (blk: { + const tmp = tcounter; + if (tmp >= 0) break :blk (blk_1: { + const tmp_2 = m; + if (tmp_2 >= 0) break :blk_1 model.meshes + @as(usize, @intCast(tmp_2)) else break :blk_1 model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.indices + @as(usize, @intCast(tmp)) else break :blk (blk_1: { + const tmp_2 = m; + if (tmp_2 >= 0) break :blk_1 model.meshes + @as(usize, @intCast(tmp_2)) else break :blk_1 model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.indices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = @as(c_ushort, @bitCast(@as(c_ushort, @truncate(tri[i].vertex[@as(c_uint, @intCast(@as(c_int, 2)))] -% (blk: { + const tmp = m; + if (tmp >= 0) break :blk imesh + @as(usize, @intCast(tmp)) else break :blk imesh - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.first_vertex)))); + tcounter += @as(c_int, 3); + } + } + } + } + va = @as([*c]IQMVertexArray, @ptrCast(@alignCast(malloc(@as(c_ulong, @bitCast(@as(c_ulong, iqmHeader.*.num_vertexarrays))) *% @sizeOf(IQMVertexArray))))); + _ = memcpy(@as(?*anyopaque, @ptrCast(va)), @as(?*const anyopaque, @ptrCast(fileDataPtr + iqmHeader.*.ofs_vertexarrays)), @as(c_ulong, @bitCast(@as(c_ulong, iqmHeader.*.num_vertexarrays))) *% @sizeOf(IQMVertexArray)); + { + var i: c_uint = 0; + _ = &i; + while (i < iqmHeader.*.num_vertexarrays) : (i +%= 1) { + while (true) { + switch (va[i].type) { + @as(c_uint, @bitCast(@as(c_int, 0))) => { + { + vertex = @as([*c]f32, @ptrCast(@alignCast(malloc(@as(c_ulong, @bitCast(@as(c_ulong, iqmHeader.*.num_vertexes *% @as(c_uint, @bitCast(@as(c_int, 3)))))) *% @sizeOf(f32))))); + _ = memcpy(@as(?*anyopaque, @ptrCast(vertex)), @as(?*const anyopaque, @ptrCast(fileDataPtr + va[i].offset)), @as(c_ulong, @bitCast(@as(c_ulong, iqmHeader.*.num_vertexes *% @as(c_uint, @bitCast(@as(c_int, 3)))))) *% @sizeOf(f32)); + { + var m: c_uint = 0; + _ = &m; + while (m < iqmHeader.*.num_meshes) : (m +%= 1) { + var vCounter: c_int = 0; + _ = &vCounter; + { + var i_1: c_uint = imesh[m].first_vertex *% @as(c_uint, @bitCast(@as(c_int, 3))); + _ = &i_1; + while (i_1 < ((imesh[m].first_vertex +% imesh[m].num_vertexes) *% @as(c_uint, @bitCast(@as(c_int, 3))))) : (i_1 +%= 1) { + (blk: { + const tmp = vCounter; + if (tmp >= 0) break :blk model.meshes[m].vertices + @as(usize, @intCast(tmp)) else break :blk model.meshes[m].vertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = vertex[i_1]; + (blk: { + const tmp = vCounter; + if (tmp >= 0) break :blk model.meshes[m].animVertices + @as(usize, @intCast(tmp)) else break :blk model.meshes[m].animVertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = vertex[i_1]; + vCounter += 1; + } + } + } + } + } + break; + }, + @as(c_uint, @bitCast(@as(c_int, 2))) => { + { + normal = @as([*c]f32, @ptrCast(@alignCast(malloc(@as(c_ulong, @bitCast(@as(c_ulong, iqmHeader.*.num_vertexes *% @as(c_uint, @bitCast(@as(c_int, 3)))))) *% @sizeOf(f32))))); + _ = memcpy(@as(?*anyopaque, @ptrCast(normal)), @as(?*const anyopaque, @ptrCast(fileDataPtr + va[i].offset)), @as(c_ulong, @bitCast(@as(c_ulong, iqmHeader.*.num_vertexes *% @as(c_uint, @bitCast(@as(c_int, 3)))))) *% @sizeOf(f32)); + { + var m: c_uint = 0; + _ = &m; + while (m < iqmHeader.*.num_meshes) : (m +%= 1) { + var vCounter: c_int = 0; + _ = &vCounter; + { + var i_1: c_uint = imesh[m].first_vertex *% @as(c_uint, @bitCast(@as(c_int, 3))); + _ = &i_1; + while (i_1 < ((imesh[m].first_vertex +% imesh[m].num_vertexes) *% @as(c_uint, @bitCast(@as(c_int, 3))))) : (i_1 +%= 1) { + (blk: { + const tmp = vCounter; + if (tmp >= 0) break :blk model.meshes[m].normals + @as(usize, @intCast(tmp)) else break :blk model.meshes[m].normals - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = normal[i_1]; + (blk: { + const tmp = vCounter; + if (tmp >= 0) break :blk model.meshes[m].animNormals + @as(usize, @intCast(tmp)) else break :blk model.meshes[m].animNormals - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = normal[i_1]; + vCounter += 1; + } + } + } + } + } + break; + }, + @as(c_uint, @bitCast(@as(c_int, 1))) => { + { + text = @as([*c]f32, @ptrCast(@alignCast(malloc(@as(c_ulong, @bitCast(@as(c_ulong, iqmHeader.*.num_vertexes *% @as(c_uint, @bitCast(@as(c_int, 2)))))) *% @sizeOf(f32))))); + _ = memcpy(@as(?*anyopaque, @ptrCast(text)), @as(?*const anyopaque, @ptrCast(fileDataPtr + va[i].offset)), @as(c_ulong, @bitCast(@as(c_ulong, iqmHeader.*.num_vertexes *% @as(c_uint, @bitCast(@as(c_int, 2)))))) *% @sizeOf(f32)); + { + var m: c_uint = 0; + _ = &m; + while (m < iqmHeader.*.num_meshes) : (m +%= 1) { + var vCounter: c_int = 0; + _ = &vCounter; + { + var i_1: c_uint = imesh[m].first_vertex *% @as(c_uint, @bitCast(@as(c_int, 2))); + _ = &i_1; + while (i_1 < ((imesh[m].first_vertex +% imesh[m].num_vertexes) *% @as(c_uint, @bitCast(@as(c_int, 2))))) : (i_1 +%= 1) { + (blk: { + const tmp = vCounter; + if (tmp >= 0) break :blk model.meshes[m].texcoords + @as(usize, @intCast(tmp)) else break :blk model.meshes[m].texcoords - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = text[i_1]; + vCounter += 1; + } + } + } + } + } + break; + }, + @as(c_uint, @bitCast(@as(c_int, 4))) => { + { + blendi = @as([*c]u8, @ptrCast(@alignCast(malloc(@as(c_ulong, @bitCast(@as(c_ulong, iqmHeader.*.num_vertexes *% @as(c_uint, @bitCast(@as(c_int, 4)))))) *% @sizeOf(u8))))); + _ = memcpy(@as(?*anyopaque, @ptrCast(blendi)), @as(?*const anyopaque, @ptrCast(fileDataPtr + va[i].offset)), @as(c_ulong, @bitCast(@as(c_ulong, iqmHeader.*.num_vertexes *% @as(c_uint, @bitCast(@as(c_int, 4)))))) *% @sizeOf(u8)); + { + var m: c_uint = 0; + _ = &m; + while (m < iqmHeader.*.num_meshes) : (m +%= 1) { + var boneCounter: c_int = 0; + _ = &boneCounter; + { + var i_1: c_uint = imesh[m].first_vertex *% @as(c_uint, @bitCast(@as(c_int, 4))); + _ = &i_1; + while (i_1 < ((imesh[m].first_vertex +% imesh[m].num_vertexes) *% @as(c_uint, @bitCast(@as(c_int, 4))))) : (i_1 +%= 1) { + (blk: { + const tmp = boneCounter; + if (tmp >= 0) break :blk model.meshes[m].boneIds + @as(usize, @intCast(tmp)) else break :blk model.meshes[m].boneIds - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = @as(u8, @bitCast(blendi[i_1])); + boneCounter += 1; + } + } + } + } + } + break; + }, + @as(c_uint, @bitCast(@as(c_int, 5))) => { + { + blendw = @as([*c]u8, @ptrCast(@alignCast(malloc(@as(c_ulong, @bitCast(@as(c_ulong, iqmHeader.*.num_vertexes *% @as(c_uint, @bitCast(@as(c_int, 4)))))) *% @sizeOf(u8))))); + _ = memcpy(@as(?*anyopaque, @ptrCast(blendw)), @as(?*const anyopaque, @ptrCast(fileDataPtr + va[i].offset)), @as(c_ulong, @bitCast(@as(c_ulong, iqmHeader.*.num_vertexes *% @as(c_uint, @bitCast(@as(c_int, 4)))))) *% @sizeOf(u8)); + { + var m: c_uint = 0; + _ = &m; + while (m < iqmHeader.*.num_meshes) : (m +%= 1) { + var boneCounter: c_int = 0; + _ = &boneCounter; + { + var i_1: c_uint = imesh[m].first_vertex *% @as(c_uint, @bitCast(@as(c_int, 4))); + _ = &i_1; + while (i_1 < ((imesh[m].first_vertex +% imesh[m].num_vertexes) *% @as(c_uint, @bitCast(@as(c_int, 4))))) : (i_1 +%= 1) { + (blk: { + const tmp = boneCounter; + if (tmp >= 0) break :blk model.meshes[m].boneWeights + @as(usize, @intCast(tmp)) else break :blk model.meshes[m].boneWeights - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = @as(f32, @floatFromInt(@as(c_int, @bitCast(@as(c_uint, blendw[i_1]))))) / 255.0; + boneCounter += 1; + } + } + } + } + } + break; + }, + @as(c_uint, @bitCast(@as(c_int, 6))) => { + { + color = @as([*c]u8, @ptrCast(@alignCast(malloc(@as(c_ulong, @bitCast(@as(c_ulong, iqmHeader.*.num_vertexes *% @as(c_uint, @bitCast(@as(c_int, 4)))))) *% @sizeOf(u8))))); + _ = memcpy(@as(?*anyopaque, @ptrCast(color)), @as(?*const anyopaque, @ptrCast(fileDataPtr + va[i].offset)), @as(c_ulong, @bitCast(@as(c_ulong, iqmHeader.*.num_vertexes *% @as(c_uint, @bitCast(@as(c_int, 4)))))) *% @sizeOf(u8)); + { + var m: c_uint = 0; + _ = &m; + while (m < iqmHeader.*.num_meshes) : (m +%= 1) { + model.meshes[m].colors = @as([*c]u8, @ptrCast(@alignCast(calloc(@as(c_ulong, @bitCast(@as(c_long, model.meshes[m].vertexCount * @as(c_int, 4)))), @sizeOf(u8))))); + var vCounter: c_int = 0; + _ = &vCounter; + { + var i_1: c_uint = imesh[m].first_vertex *% @as(c_uint, @bitCast(@as(c_int, 4))); + _ = &i_1; + while (i_1 < ((imesh[m].first_vertex +% imesh[m].num_vertexes) *% @as(c_uint, @bitCast(@as(c_int, 4))))) : (i_1 +%= 1) { + (blk: { + const tmp = vCounter; + if (tmp >= 0) break :blk model.meshes[m].colors + @as(usize, @intCast(tmp)) else break :blk model.meshes[m].colors - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = color[i_1]; + vCounter += 1; + } + } + } + } + } + break; + }, + else => {}, + } + break; + } + } + } + ijoint = @as([*c]IQMJoint, @ptrCast(@alignCast(malloc(@as(c_ulong, @bitCast(@as(c_ulong, iqmHeader.*.num_joints))) *% @sizeOf(IQMJoint))))); + _ = memcpy(@as(?*anyopaque, @ptrCast(ijoint)), @as(?*const anyopaque, @ptrCast(fileDataPtr + iqmHeader.*.ofs_joints)), @as(c_ulong, @bitCast(@as(c_ulong, iqmHeader.*.num_joints))) *% @sizeOf(IQMJoint)); + model.boneCount = @as(c_int, @bitCast(iqmHeader.*.num_joints)); + model.bones = @as([*c]BoneInfo, @ptrCast(@alignCast(malloc(@as(c_ulong, @bitCast(@as(c_ulong, iqmHeader.*.num_joints))) *% @sizeOf(BoneInfo))))); + model.bindPose = @as([*c]Transform, @ptrCast(@alignCast(malloc(@as(c_ulong, @bitCast(@as(c_ulong, iqmHeader.*.num_joints))) *% @sizeOf(Transform))))); + { + var i: c_uint = 0; + _ = &i; + while (i < iqmHeader.*.num_joints) : (i +%= 1) { + model.bones[i].parent = ijoint[i].parent; + _ = memcpy(@as(?*anyopaque, @ptrCast(@as([*c]u8, @ptrCast(@alignCast(&model.bones[i].name))))), @as(?*const anyopaque, @ptrCast((fileDataPtr + iqmHeader.*.ofs_text) + ijoint[i].name)), @as(c_ulong, @bitCast(@as(c_long, @as(c_int, 32)))) *% @sizeOf(u8)); + model.bindPose[i].translation.x = ijoint[i].translate[@as(c_uint, @intCast(@as(c_int, 0)))]; + model.bindPose[i].translation.y = ijoint[i].translate[@as(c_uint, @intCast(@as(c_int, 1)))]; + model.bindPose[i].translation.z = ijoint[i].translate[@as(c_uint, @intCast(@as(c_int, 2)))]; + model.bindPose[i].rotation.x = ijoint[i].rotate[@as(c_uint, @intCast(@as(c_int, 0)))]; + model.bindPose[i].rotation.y = ijoint[i].rotate[@as(c_uint, @intCast(@as(c_int, 1)))]; + model.bindPose[i].rotation.z = ijoint[i].rotate[@as(c_uint, @intCast(@as(c_int, 2)))]; + model.bindPose[i].rotation.w = ijoint[i].rotate[@as(c_uint, @intCast(@as(c_int, 3)))]; + model.bindPose[i].scale.x = ijoint[i].scale[@as(c_uint, @intCast(@as(c_int, 0)))]; + model.bindPose[i].scale.y = ijoint[i].scale[@as(c_uint, @intCast(@as(c_int, 1)))]; + model.bindPose[i].scale.z = ijoint[i].scale[@as(c_uint, @intCast(@as(c_int, 2)))]; + } + } + BuildPoseFromParentJoints(model.bones, model.boneCount, model.bindPose); + UnloadFileData(fileData); + free(@as(?*anyopaque, @ptrCast(imesh))); + free(@as(?*anyopaque, @ptrCast(tri))); + free(@as(?*anyopaque, @ptrCast(va))); + free(@as(?*anyopaque, @ptrCast(vertex))); + free(@as(?*anyopaque, @ptrCast(normal))); + free(@as(?*anyopaque, @ptrCast(text))); + free(@as(?*anyopaque, @ptrCast(blendi))); + free(@as(?*anyopaque, @ptrCast(blendw))); + free(@as(?*anyopaque, @ptrCast(ijoint))); + free(@as(?*anyopaque, @ptrCast(color))); + return model; +} +pub fn LoadModelAnimationsIQM(arg_fileName: [*c]const u8, arg_animCount: [*c]c_int) callconv(.C) [*c]ModelAnimation { + var fileName = arg_fileName; + _ = &fileName; + var animCount = arg_animCount; + _ = &animCount; + var dataSize: c_int = 0; + _ = &dataSize; + var fileData: [*c]u8 = LoadFileData(fileName, &dataSize); + _ = &fileData; + var fileDataPtr: [*c]u8 = fileData; + _ = &fileDataPtr; + const struct_IQMHeader = extern struct { + magic: [16]u8 = @import("std").mem.zeroes([16]u8), + version: c_uint = @import("std").mem.zeroes(c_uint), + dataSize: c_uint = @import("std").mem.zeroes(c_uint), + flags: c_uint = @import("std").mem.zeroes(c_uint), + num_text: c_uint = @import("std").mem.zeroes(c_uint), + ofs_text: c_uint = @import("std").mem.zeroes(c_uint), + num_meshes: c_uint = @import("std").mem.zeroes(c_uint), + ofs_meshes: c_uint = @import("std").mem.zeroes(c_uint), + num_vertexarrays: c_uint = @import("std").mem.zeroes(c_uint), + num_vertexes: c_uint = @import("std").mem.zeroes(c_uint), + ofs_vertexarrays: c_uint = @import("std").mem.zeroes(c_uint), + num_triangles: c_uint = @import("std").mem.zeroes(c_uint), + ofs_triangles: c_uint = @import("std").mem.zeroes(c_uint), + ofs_adjacency: c_uint = @import("std").mem.zeroes(c_uint), + num_joints: c_uint = @import("std").mem.zeroes(c_uint), + ofs_joints: c_uint = @import("std").mem.zeroes(c_uint), + num_poses: c_uint = @import("std").mem.zeroes(c_uint), + ofs_poses: c_uint = @import("std").mem.zeroes(c_uint), + num_anims: c_uint = @import("std").mem.zeroes(c_uint), + ofs_anims: c_uint = @import("std").mem.zeroes(c_uint), + num_frames: c_uint = @import("std").mem.zeroes(c_uint), + num_framechannels: c_uint = @import("std").mem.zeroes(c_uint), + ofs_frames: c_uint = @import("std").mem.zeroes(c_uint), + ofs_bounds: c_uint = @import("std").mem.zeroes(c_uint), + num_comment: c_uint = @import("std").mem.zeroes(c_uint), + ofs_comment: c_uint = @import("std").mem.zeroes(c_uint), + num_extensions: c_uint = @import("std").mem.zeroes(c_uint), + ofs_extensions: c_uint = @import("std").mem.zeroes(c_uint), + }; + _ = &struct_IQMHeader; + const IQMHeader = struct_IQMHeader; + _ = &IQMHeader; + const struct_IQMJoint = extern struct { + name: c_uint = @import("std").mem.zeroes(c_uint), + parent: c_int = @import("std").mem.zeroes(c_int), + translate: [3]f32 = @import("std").mem.zeroes([3]f32), + rotate: [4]f32 = @import("std").mem.zeroes([4]f32), + scale: [3]f32 = @import("std").mem.zeroes([3]f32), + }; + _ = &struct_IQMJoint; + const IQMJoint = struct_IQMJoint; + _ = &IQMJoint; + const struct_IQMPose = extern struct { + parent: c_int = @import("std").mem.zeroes(c_int), + mask: c_uint = @import("std").mem.zeroes(c_uint), + channeloffset: [10]f32 = @import("std").mem.zeroes([10]f32), + channelscale: [10]f32 = @import("std").mem.zeroes([10]f32), + }; + _ = &struct_IQMPose; + const IQMPose = struct_IQMPose; + _ = &IQMPose; + const struct_IQMAnim = extern struct { + name: c_uint = @import("std").mem.zeroes(c_uint), + first_frame: c_uint = @import("std").mem.zeroes(c_uint), + num_frames: c_uint = @import("std").mem.zeroes(c_uint), + framerate: f32 = @import("std").mem.zeroes(f32), + flags: c_uint = @import("std").mem.zeroes(c_uint), + }; + _ = &struct_IQMAnim; + const IQMAnim = struct_IQMAnim; + _ = &IQMAnim; + if (fileDataPtr == @as([*c]u8, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0))))))) return null; + var iqmHeader: [*c]IQMHeader = @as([*c]IQMHeader, @ptrCast(@alignCast(fileDataPtr))); + _ = &iqmHeader; + if (memcmp(@as(?*const anyopaque, @ptrCast(@as([*c]u8, @ptrCast(@alignCast(&iqmHeader.*.magic))))), @as(?*const anyopaque, @ptrCast("INTERQUAKEMODEL")), @sizeOf([16]u8)) != @as(c_int, 0)) { + TraceLog(LOG_WARNING, "MODEL: [%s] IQM file is not a valid model", fileName); + return null; + } + if (iqmHeader.*.version != @as(c_uint, @bitCast(@as(c_int, 2)))) { + TraceLog(LOG_WARNING, "MODEL: [%s] IQM file version not supported (%i)", fileName, iqmHeader.*.version); + return null; + } + var poses: [*c]IQMPose = @as([*c]IQMPose, @ptrCast(@alignCast(malloc(@as(c_ulong, @bitCast(@as(c_ulong, iqmHeader.*.num_poses))) *% @sizeOf(IQMPose))))); + _ = &poses; + _ = memcpy(@as(?*anyopaque, @ptrCast(poses)), @as(?*const anyopaque, @ptrCast(fileDataPtr + iqmHeader.*.ofs_poses)), @as(c_ulong, @bitCast(@as(c_ulong, iqmHeader.*.num_poses))) *% @sizeOf(IQMPose)); + animCount.* = @as(c_int, @bitCast(iqmHeader.*.num_anims)); + var anim: [*c]IQMAnim = @as([*c]IQMAnim, @ptrCast(@alignCast(malloc(@as(c_ulong, @bitCast(@as(c_ulong, iqmHeader.*.num_anims))) *% @sizeOf(IQMAnim))))); + _ = &anim; + _ = memcpy(@as(?*anyopaque, @ptrCast(anim)), @as(?*const anyopaque, @ptrCast(fileDataPtr + iqmHeader.*.ofs_anims)), @as(c_ulong, @bitCast(@as(c_ulong, iqmHeader.*.num_anims))) *% @sizeOf(IQMAnim)); + var animations: [*c]ModelAnimation = @as([*c]ModelAnimation, @ptrCast(@alignCast(malloc(@as(c_ulong, @bitCast(@as(c_ulong, iqmHeader.*.num_anims))) *% @sizeOf(ModelAnimation))))); + _ = &animations; + var framedata: [*c]c_ushort = @as([*c]c_ushort, @ptrCast(@alignCast(malloc(@as(c_ulong, @bitCast(@as(c_ulong, iqmHeader.*.num_frames *% iqmHeader.*.num_framechannels))) *% @sizeOf(c_ushort))))); + _ = &framedata; + _ = memcpy(@as(?*anyopaque, @ptrCast(framedata)), @as(?*const anyopaque, @ptrCast(fileDataPtr + iqmHeader.*.ofs_frames)), @as(c_ulong, @bitCast(@as(c_ulong, iqmHeader.*.num_frames *% iqmHeader.*.num_framechannels))) *% @sizeOf(c_ushort)); + var joints: [*c]IQMJoint = @as([*c]IQMJoint, @ptrCast(@alignCast(malloc(@as(c_ulong, @bitCast(@as(c_ulong, iqmHeader.*.num_joints))) *% @sizeOf(IQMJoint))))); + _ = &joints; + _ = memcpy(@as(?*anyopaque, @ptrCast(joints)), @as(?*const anyopaque, @ptrCast(fileDataPtr + iqmHeader.*.ofs_joints)), @as(c_ulong, @bitCast(@as(c_ulong, iqmHeader.*.num_joints))) *% @sizeOf(IQMJoint)); + { + var a: c_uint = 0; + _ = &a; + while (a < iqmHeader.*.num_anims) : (a +%= 1) { + animations[a].frameCount = @as(c_int, @bitCast(anim[a].num_frames)); + animations[a].boneCount = @as(c_int, @bitCast(iqmHeader.*.num_poses)); + animations[a].bones = @as([*c]BoneInfo, @ptrCast(@alignCast(malloc(@as(c_ulong, @bitCast(@as(c_ulong, iqmHeader.*.num_poses))) *% @sizeOf(BoneInfo))))); + animations[a].framePoses = @as([*c][*c]Transform, @ptrCast(@alignCast(malloc(@as(c_ulong, @bitCast(@as(c_ulong, anim[a].num_frames))) *% @sizeOf([*c]Transform))))); + _ = memcpy(@as(?*anyopaque, @ptrCast(@as([*c]u8, @ptrCast(@alignCast(&animations[a].name))))), @as(?*const anyopaque, @ptrCast((fileDataPtr + iqmHeader.*.ofs_text) + anim[a].name)), @as(c_ulong, @bitCast(@as(c_long, @as(c_int, 32))))); + TraceLog(LOG_INFO, "IQM Anim %s", @as([*c]u8, @ptrCast(@alignCast(&animations[a].name)))); + { + var j: c_uint = 0; + _ = &j; + while (j < iqmHeader.*.num_poses) : (j +%= 1) { + if (iqmHeader.*.num_joints > @as(c_uint, @bitCast(@as(c_int, 0)))) { + _ = memcpy(@as(?*anyopaque, @ptrCast(@as([*c]u8, @ptrCast(@alignCast(&animations[a].bones[j].name))))), @as(?*const anyopaque, @ptrCast((fileDataPtr + iqmHeader.*.ofs_text) + joints[j].name)), @as(c_ulong, @bitCast(@as(c_long, @as(c_int, 32)))) *% @sizeOf(u8)); + } else { + _ = strcpy(@as([*c]u8, @ptrCast(@alignCast(&animations[a].bones[j].name))), "ANIMJOINTNAME"); + } + animations[a].bones[j].parent = poses[j].parent; + } + } + { + var j: c_uint = 0; + _ = &j; + while (j < anim[a].num_frames) : (j +%= 1) { + animations[a].framePoses[j] = @as([*c]Transform, @ptrCast(@alignCast(malloc(@as(c_ulong, @bitCast(@as(c_ulong, iqmHeader.*.num_poses))) *% @sizeOf(Transform))))); + } + } + var dcounter: c_int = @as(c_int, @bitCast(anim[a].first_frame *% iqmHeader.*.num_framechannels)); + _ = &dcounter; + { + var frame: c_uint = 0; + _ = &frame; + while (frame < anim[a].num_frames) : (frame +%= 1) { + { + var i: c_uint = 0; + _ = &i; + while (i < iqmHeader.*.num_poses) : (i +%= 1) { + animations[a].framePoses[frame][i].translation.x = poses[i].channeloffset[@as(c_uint, @intCast(@as(c_int, 0)))]; + if ((poses[i].mask & @as(c_uint, @bitCast(@as(c_int, 1)))) != 0) { + animations[a].framePoses[frame][i].translation.x += @as(f32, @floatFromInt(@as(c_int, @bitCast(@as(c_uint, (blk: { + const tmp = dcounter; + if (tmp >= 0) break :blk framedata + @as(usize, @intCast(tmp)) else break :blk framedata - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*))))) * poses[i].channelscale[@as(c_uint, @intCast(@as(c_int, 0)))]; + dcounter += 1; + } + animations[a].framePoses[frame][i].translation.y = poses[i].channeloffset[@as(c_uint, @intCast(@as(c_int, 1)))]; + if ((poses[i].mask & @as(c_uint, @bitCast(@as(c_int, 2)))) != 0) { + animations[a].framePoses[frame][i].translation.y += @as(f32, @floatFromInt(@as(c_int, @bitCast(@as(c_uint, (blk: { + const tmp = dcounter; + if (tmp >= 0) break :blk framedata + @as(usize, @intCast(tmp)) else break :blk framedata - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*))))) * poses[i].channelscale[@as(c_uint, @intCast(@as(c_int, 1)))]; + dcounter += 1; + } + animations[a].framePoses[frame][i].translation.z = poses[i].channeloffset[@as(c_uint, @intCast(@as(c_int, 2)))]; + if ((poses[i].mask & @as(c_uint, @bitCast(@as(c_int, 4)))) != 0) { + animations[a].framePoses[frame][i].translation.z += @as(f32, @floatFromInt(@as(c_int, @bitCast(@as(c_uint, (blk: { + const tmp = dcounter; + if (tmp >= 0) break :blk framedata + @as(usize, @intCast(tmp)) else break :blk framedata - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*))))) * poses[i].channelscale[@as(c_uint, @intCast(@as(c_int, 2)))]; + dcounter += 1; + } + animations[a].framePoses[frame][i].rotation.x = poses[i].channeloffset[@as(c_uint, @intCast(@as(c_int, 3)))]; + if ((poses[i].mask & @as(c_uint, @bitCast(@as(c_int, 8)))) != 0) { + animations[a].framePoses[frame][i].rotation.x += @as(f32, @floatFromInt(@as(c_int, @bitCast(@as(c_uint, (blk: { + const tmp = dcounter; + if (tmp >= 0) break :blk framedata + @as(usize, @intCast(tmp)) else break :blk framedata - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*))))) * poses[i].channelscale[@as(c_uint, @intCast(@as(c_int, 3)))]; + dcounter += 1; + } + animations[a].framePoses[frame][i].rotation.y = poses[i].channeloffset[@as(c_uint, @intCast(@as(c_int, 4)))]; + if ((poses[i].mask & @as(c_uint, @bitCast(@as(c_int, 16)))) != 0) { + animations[a].framePoses[frame][i].rotation.y += @as(f32, @floatFromInt(@as(c_int, @bitCast(@as(c_uint, (blk: { + const tmp = dcounter; + if (tmp >= 0) break :blk framedata + @as(usize, @intCast(tmp)) else break :blk framedata - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*))))) * poses[i].channelscale[@as(c_uint, @intCast(@as(c_int, 4)))]; + dcounter += 1; + } + animations[a].framePoses[frame][i].rotation.z = poses[i].channeloffset[@as(c_uint, @intCast(@as(c_int, 5)))]; + if ((poses[i].mask & @as(c_uint, @bitCast(@as(c_int, 32)))) != 0) { + animations[a].framePoses[frame][i].rotation.z += @as(f32, @floatFromInt(@as(c_int, @bitCast(@as(c_uint, (blk: { + const tmp = dcounter; + if (tmp >= 0) break :blk framedata + @as(usize, @intCast(tmp)) else break :blk framedata - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*))))) * poses[i].channelscale[@as(c_uint, @intCast(@as(c_int, 5)))]; + dcounter += 1; + } + animations[a].framePoses[frame][i].rotation.w = poses[i].channeloffset[@as(c_uint, @intCast(@as(c_int, 6)))]; + if ((poses[i].mask & @as(c_uint, @bitCast(@as(c_int, 64)))) != 0) { + animations[a].framePoses[frame][i].rotation.w += @as(f32, @floatFromInt(@as(c_int, @bitCast(@as(c_uint, (blk: { + const tmp = dcounter; + if (tmp >= 0) break :blk framedata + @as(usize, @intCast(tmp)) else break :blk framedata - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*))))) * poses[i].channelscale[@as(c_uint, @intCast(@as(c_int, 6)))]; + dcounter += 1; + } + animations[a].framePoses[frame][i].scale.x = poses[i].channeloffset[@as(c_uint, @intCast(@as(c_int, 7)))]; + if ((poses[i].mask & @as(c_uint, @bitCast(@as(c_int, 128)))) != 0) { + animations[a].framePoses[frame][i].scale.x += @as(f32, @floatFromInt(@as(c_int, @bitCast(@as(c_uint, (blk: { + const tmp = dcounter; + if (tmp >= 0) break :blk framedata + @as(usize, @intCast(tmp)) else break :blk framedata - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*))))) * poses[i].channelscale[@as(c_uint, @intCast(@as(c_int, 7)))]; + dcounter += 1; + } + animations[a].framePoses[frame][i].scale.y = poses[i].channeloffset[@as(c_uint, @intCast(@as(c_int, 8)))]; + if ((poses[i].mask & @as(c_uint, @bitCast(@as(c_int, 256)))) != 0) { + animations[a].framePoses[frame][i].scale.y += @as(f32, @floatFromInt(@as(c_int, @bitCast(@as(c_uint, (blk: { + const tmp = dcounter; + if (tmp >= 0) break :blk framedata + @as(usize, @intCast(tmp)) else break :blk framedata - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*))))) * poses[i].channelscale[@as(c_uint, @intCast(@as(c_int, 8)))]; + dcounter += 1; + } + animations[a].framePoses[frame][i].scale.z = poses[i].channeloffset[@as(c_uint, @intCast(@as(c_int, 9)))]; + if ((poses[i].mask & @as(c_uint, @bitCast(@as(c_int, 512)))) != 0) { + animations[a].framePoses[frame][i].scale.z += @as(f32, @floatFromInt(@as(c_int, @bitCast(@as(c_uint, (blk: { + const tmp = dcounter; + if (tmp >= 0) break :blk framedata + @as(usize, @intCast(tmp)) else break :blk framedata - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*))))) * poses[i].channelscale[@as(c_uint, @intCast(@as(c_int, 9)))]; + dcounter += 1; + } + animations[a].framePoses[frame][i].rotation = QuaternionNormalize(animations[a].framePoses[frame][i].rotation); + } + } + } + } + { + var frame: c_uint = 0; + _ = &frame; + while (frame < anim[a].num_frames) : (frame +%= 1) { + { + var i: c_int = 0; + _ = &i; + while (i < animations[a].boneCount) : (i += 1) { + if ((blk: { + const tmp = i; + if (tmp >= 0) break :blk animations[a].bones + @as(usize, @intCast(tmp)) else break :blk animations[a].bones - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.parent >= @as(c_int, 0)) { + (blk: { + const tmp = i; + if (tmp >= 0) break :blk animations[a].framePoses[frame] + @as(usize, @intCast(tmp)) else break :blk animations[a].framePoses[frame] - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.rotation = QuaternionMultiply((blk: { + const tmp = (blk_1: { + const tmp_2 = i; + if (tmp_2 >= 0) break :blk_1 animations[a].bones + @as(usize, @intCast(tmp_2)) else break :blk_1 animations[a].bones - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.parent; + if (tmp >= 0) break :blk animations[a].framePoses[frame] + @as(usize, @intCast(tmp)) else break :blk animations[a].framePoses[frame] - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.rotation, (blk: { + const tmp = i; + if (tmp >= 0) break :blk animations[a].framePoses[frame] + @as(usize, @intCast(tmp)) else break :blk animations[a].framePoses[frame] - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.rotation); + (blk: { + const tmp = i; + if (tmp >= 0) break :blk animations[a].framePoses[frame] + @as(usize, @intCast(tmp)) else break :blk animations[a].framePoses[frame] - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.translation = Vector3RotateByQuaternion((blk: { + const tmp = i; + if (tmp >= 0) break :blk animations[a].framePoses[frame] + @as(usize, @intCast(tmp)) else break :blk animations[a].framePoses[frame] - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.translation, (blk: { + const tmp = (blk_1: { + const tmp_2 = i; + if (tmp_2 >= 0) break :blk_1 animations[a].bones + @as(usize, @intCast(tmp_2)) else break :blk_1 animations[a].bones - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.parent; + if (tmp >= 0) break :blk animations[a].framePoses[frame] + @as(usize, @intCast(tmp)) else break :blk animations[a].framePoses[frame] - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.rotation); + (blk: { + const tmp = i; + if (tmp >= 0) break :blk animations[a].framePoses[frame] + @as(usize, @intCast(tmp)) else break :blk animations[a].framePoses[frame] - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.translation = Vector3Add((blk: { + const tmp = i; + if (tmp >= 0) break :blk animations[a].framePoses[frame] + @as(usize, @intCast(tmp)) else break :blk animations[a].framePoses[frame] - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.translation, (blk: { + const tmp = (blk_1: { + const tmp_2 = i; + if (tmp_2 >= 0) break :blk_1 animations[a].bones + @as(usize, @intCast(tmp_2)) else break :blk_1 animations[a].bones - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.parent; + if (tmp >= 0) break :blk animations[a].framePoses[frame] + @as(usize, @intCast(tmp)) else break :blk animations[a].framePoses[frame] - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.translation); + (blk: { + const tmp = i; + if (tmp >= 0) break :blk animations[a].framePoses[frame] + @as(usize, @intCast(tmp)) else break :blk animations[a].framePoses[frame] - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.scale = Vector3Multiply((blk: { + const tmp = i; + if (tmp >= 0) break :blk animations[a].framePoses[frame] + @as(usize, @intCast(tmp)) else break :blk animations[a].framePoses[frame] - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.scale, (blk: { + const tmp = (blk_1: { + const tmp_2 = i; + if (tmp_2 >= 0) break :blk_1 animations[a].bones + @as(usize, @intCast(tmp_2)) else break :blk_1 animations[a].bones - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.parent; + if (tmp >= 0) break :blk animations[a].framePoses[frame] + @as(usize, @intCast(tmp)) else break :blk animations[a].framePoses[frame] - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.scale); + } + } + } + } + } + } + } + UnloadFileData(fileData); + free(@as(?*anyopaque, @ptrCast(joints))); + free(@as(?*anyopaque, @ptrCast(framedata))); + free(@as(?*anyopaque, @ptrCast(poses))); + free(@as(?*anyopaque, @ptrCast(anim))); + return animations; +} +pub fn LoadGLTF(arg_fileName: [*c]const u8) callconv(.C) Model { + var fileName = arg_fileName; + _ = &fileName; + var model: Model = Model{ + .transform = Matrix{ + .m0 = @as(f32, @floatFromInt(@as(c_int, 0))), + .m4 = 0, + .m8 = 0, + .m12 = 0, + .m1 = 0, + .m5 = 0, + .m9 = 0, + .m13 = 0, + .m2 = 0, + .m6 = 0, + .m10 = 0, + .m14 = 0, + .m3 = 0, + .m7 = 0, + .m11 = 0, + .m15 = 0, + }, + .meshCount = 0, + .materialCount = 0, + .meshes = null, + .materials = null, + .meshMaterial = null, + .boneCount = 0, + .bones = null, + .bindPose = null, + }; + _ = &model; + var dataSize: c_int = 0; + _ = &dataSize; + var fileData: [*c]u8 = LoadFileData(fileName, &dataSize); + _ = &fileData; + if (fileData == @as([*c]u8, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0))))))) return model; + var options: cgltf_options = cgltf_options{ + .type = @as(c_uint, @bitCast(@as(c_int, 0))), + .json_token_count = @import("std").mem.zeroes(cgltf_size), + .memory = @import("std").mem.zeroes(cgltf_memory_options), + .file = @import("std").mem.zeroes(cgltf_file_options), + }; + _ = &options; + options.file.read = &LoadFileGLTFCallback; + options.file.release = &ReleaseFileGLTFCallback; + var data: [*c]cgltf_data = null; + _ = &data; + var result: cgltf_result = cgltf_parse(&options, @as(?*const anyopaque, @ptrCast(fileData)), @as(cgltf_size, @bitCast(@as(c_long, dataSize))), &data); + _ = &result; + if (result == @as(c_uint, @bitCast(cgltf_result_success))) { + if (data.*.file_type == @as(c_uint, @bitCast(cgltf_file_type_glb))) { + TraceLog(LOG_INFO, "MODEL: [%s] Model basic data (glb) loaded successfully", fileName); + } else if (data.*.file_type == @as(c_uint, @bitCast(cgltf_file_type_gltf))) { + TraceLog(LOG_INFO, "MODEL: [%s] Model basic data (glTF) loaded successfully", fileName); + } else { + TraceLog(LOG_WARNING, "MODEL: [%s] Model format not recognized", fileName); + } + TraceLog(LOG_INFO, " > Meshes count: %i", data.*.meshes_count); + TraceLog(LOG_INFO, " > Materials count: %i (+1 default)", data.*.materials_count); + TraceLog(LOG_DEBUG, " > Buffers count: %i", data.*.buffers_count); + TraceLog(LOG_DEBUG, " > Images count: %i", data.*.images_count); + TraceLog(LOG_DEBUG, " > Textures count: %i", data.*.textures_count); + result = cgltf_load_buffers(&options, data, fileName); + if (result != @as(c_uint, @bitCast(cgltf_result_success))) { + TraceLog(LOG_INFO, "MODEL: [%s] Failed to load mesh/material buffers", fileName); + } + var primitivesCount: c_int = 0; + _ = &primitivesCount; + { + var i: c_uint = 0; + _ = &i; + while (@as(cgltf_size, @bitCast(@as(c_ulong, i))) < data.*.nodes_count) : (i +%= 1) { + var node: [*c]cgltf_node = &data.*.nodes[i]; + _ = &node; + var mesh: [*c]cgltf_mesh = node.*.mesh; + _ = &mesh; + if (!(mesh != null)) continue; + { + var p: c_uint = 0; + _ = &p; + while (@as(cgltf_size, @bitCast(@as(c_ulong, p))) < mesh.*.primitives_count) : (p +%= 1) { + if (mesh.*.primitives[p].type == @as(c_uint, @bitCast(cgltf_primitive_type_triangles))) { + primitivesCount += 1; + } + } + } + } + } + TraceLog(LOG_DEBUG, " > Primitives (triangles only) count based on hierarchy : %i", primitivesCount); + model.meshCount = primitivesCount; + model.meshes = @as([*c]Mesh, @ptrCast(@alignCast(calloc(@as(c_ulong, @bitCast(@as(c_long, model.meshCount))), @sizeOf(Mesh))))); + model.materialCount = @as(c_int, @bitCast(@as(c_uint, @truncate(data.*.materials_count)))) + @as(c_int, 1); + model.materials = @as([*c]Material, @ptrCast(@alignCast(calloc(@as(c_ulong, @bitCast(@as(c_long, model.materialCount))), @sizeOf(Material))))); + model.materials[@as(c_uint, @intCast(@as(c_int, 0)))] = LoadMaterialDefault(); + model.meshMaterial = @as([*c]c_int, @ptrCast(@alignCast(calloc(@as(c_ulong, @bitCast(@as(c_long, model.meshCount))), @sizeOf(c_int))))); + { + var i: c_uint = 0; + _ = &i; + var j: c_uint = 1; + _ = &j; + while (@as(cgltf_size, @bitCast(@as(c_ulong, i))) < data.*.materials_count) : (_ = blk: { + i +%= 1; + break :blk blk_1: { + const ref = &j; + const tmp = ref.*; + ref.* +%= 1; + break :blk_1 tmp; + }; + }) { + model.materials[j] = LoadMaterialDefault(); + var texPath: [*c]const u8 = GetDirectoryPath(fileName); + _ = &texPath; + if (data.*.materials[i].has_pbr_metallic_roughness != 0) { + if (data.*.materials[i].pbr_metallic_roughness.base_color_texture.texture != null) { + var imAlbedo: Image = LoadImageFromCgltfImage(data.*.materials[i].pbr_metallic_roughness.base_color_texture.texture.*.image, texPath); + _ = &imAlbedo; + if (imAlbedo.data != @as(?*anyopaque, @ptrFromInt(@as(c_int, 0)))) { + (blk: { + const tmp = MATERIAL_MAP_ALBEDO; + if (tmp >= 0) break :blk model.materials[j].maps + @as(usize, @intCast(tmp)) else break :blk model.materials[j].maps - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.texture = LoadTextureFromImage(imAlbedo); + UnloadImage(imAlbedo); + } + } + (blk: { + const tmp = MATERIAL_MAP_ALBEDO; + if (tmp >= 0) break :blk model.materials[j].maps + @as(usize, @intCast(tmp)) else break :blk model.materials[j].maps - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.color.r = @as(u8, @intFromFloat(data.*.materials[i].pbr_metallic_roughness.base_color_factor[@as(c_uint, @intCast(@as(c_int, 0)))] * @as(cgltf_float, @floatFromInt(@as(c_int, 255))))); + (blk: { + const tmp = MATERIAL_MAP_ALBEDO; + if (tmp >= 0) break :blk model.materials[j].maps + @as(usize, @intCast(tmp)) else break :blk model.materials[j].maps - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.color.g = @as(u8, @intFromFloat(data.*.materials[i].pbr_metallic_roughness.base_color_factor[@as(c_uint, @intCast(@as(c_int, 1)))] * @as(cgltf_float, @floatFromInt(@as(c_int, 255))))); + (blk: { + const tmp = MATERIAL_MAP_ALBEDO; + if (tmp >= 0) break :blk model.materials[j].maps + @as(usize, @intCast(tmp)) else break :blk model.materials[j].maps - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.color.b = @as(u8, @intFromFloat(data.*.materials[i].pbr_metallic_roughness.base_color_factor[@as(c_uint, @intCast(@as(c_int, 2)))] * @as(cgltf_float, @floatFromInt(@as(c_int, 255))))); + (blk: { + const tmp = MATERIAL_MAP_ALBEDO; + if (tmp >= 0) break :blk model.materials[j].maps + @as(usize, @intCast(tmp)) else break :blk model.materials[j].maps - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.color.a = @as(u8, @intFromFloat(data.*.materials[i].pbr_metallic_roughness.base_color_factor[@as(c_uint, @intCast(@as(c_int, 3)))] * @as(cgltf_float, @floatFromInt(@as(c_int, 255))))); + if (data.*.materials[i].pbr_metallic_roughness.metallic_roughness_texture.texture != null) { + var imMetallicRoughness: Image = LoadImageFromCgltfImage(data.*.materials[i].pbr_metallic_roughness.metallic_roughness_texture.texture.*.image, texPath); + _ = &imMetallicRoughness; + if (imMetallicRoughness.data != @as(?*anyopaque, @ptrFromInt(@as(c_int, 0)))) { + (blk: { + const tmp = MATERIAL_MAP_ROUGHNESS; + if (tmp >= 0) break :blk model.materials[j].maps + @as(usize, @intCast(tmp)) else break :blk model.materials[j].maps - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.texture = LoadTextureFromImage(imMetallicRoughness); + UnloadImage(imMetallicRoughness); + } + var roughness: f32 = data.*.materials[i].pbr_metallic_roughness.roughness_factor; + _ = &roughness; + (blk: { + const tmp = MATERIAL_MAP_ROUGHNESS; + if (tmp >= 0) break :blk model.materials[j].maps + @as(usize, @intCast(tmp)) else break :blk model.materials[j].maps - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.value = roughness; + var metallic: f32 = data.*.materials[i].pbr_metallic_roughness.metallic_factor; + _ = &metallic; + (blk: { + const tmp = MATERIAL_MAP_METALNESS; + if (tmp >= 0) break :blk model.materials[j].maps + @as(usize, @intCast(tmp)) else break :blk model.materials[j].maps - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.value = metallic; + } + if (data.*.materials[i].normal_texture.texture != null) { + var imNormal: Image = LoadImageFromCgltfImage(data.*.materials[i].normal_texture.texture.*.image, texPath); + _ = &imNormal; + if (imNormal.data != @as(?*anyopaque, @ptrFromInt(@as(c_int, 0)))) { + (blk: { + const tmp = MATERIAL_MAP_NORMAL; + if (tmp >= 0) break :blk model.materials[j].maps + @as(usize, @intCast(tmp)) else break :blk model.materials[j].maps - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.texture = LoadTextureFromImage(imNormal); + UnloadImage(imNormal); + } + } + if (data.*.materials[i].occlusion_texture.texture != null) { + var imOcclusion: Image = LoadImageFromCgltfImage(data.*.materials[i].occlusion_texture.texture.*.image, texPath); + _ = &imOcclusion; + if (imOcclusion.data != @as(?*anyopaque, @ptrFromInt(@as(c_int, 0)))) { + (blk: { + const tmp = MATERIAL_MAP_OCCLUSION; + if (tmp >= 0) break :blk model.materials[j].maps + @as(usize, @intCast(tmp)) else break :blk model.materials[j].maps - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.texture = LoadTextureFromImage(imOcclusion); + UnloadImage(imOcclusion); + } + } + if (data.*.materials[i].emissive_texture.texture != null) { + var imEmissive: Image = LoadImageFromCgltfImage(data.*.materials[i].emissive_texture.texture.*.image, texPath); + _ = &imEmissive; + if (imEmissive.data != @as(?*anyopaque, @ptrFromInt(@as(c_int, 0)))) { + (blk: { + const tmp = MATERIAL_MAP_EMISSION; + if (tmp >= 0) break :blk model.materials[j].maps + @as(usize, @intCast(tmp)) else break :blk model.materials[j].maps - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.texture = LoadTextureFromImage(imEmissive); + UnloadImage(imEmissive); + } + (blk: { + const tmp = MATERIAL_MAP_EMISSION; + if (tmp >= 0) break :blk model.materials[j].maps + @as(usize, @intCast(tmp)) else break :blk model.materials[j].maps - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.color.r = @as(u8, @intFromFloat(data.*.materials[i].emissive_factor[@as(c_uint, @intCast(@as(c_int, 0)))] * @as(cgltf_float, @floatFromInt(@as(c_int, 255))))); + (blk: { + const tmp = MATERIAL_MAP_EMISSION; + if (tmp >= 0) break :blk model.materials[j].maps + @as(usize, @intCast(tmp)) else break :blk model.materials[j].maps - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.color.g = @as(u8, @intFromFloat(data.*.materials[i].emissive_factor[@as(c_uint, @intCast(@as(c_int, 1)))] * @as(cgltf_float, @floatFromInt(@as(c_int, 255))))); + (blk: { + const tmp = MATERIAL_MAP_EMISSION; + if (tmp >= 0) break :blk model.materials[j].maps + @as(usize, @intCast(tmp)) else break :blk model.materials[j].maps - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.color.b = @as(u8, @intFromFloat(data.*.materials[i].emissive_factor[@as(c_uint, @intCast(@as(c_int, 2)))] * @as(cgltf_float, @floatFromInt(@as(c_int, 255))))); + (blk: { + const tmp = MATERIAL_MAP_EMISSION; + if (tmp >= 0) break :blk model.materials[j].maps + @as(usize, @intCast(tmp)) else break :blk model.materials[j].maps - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.color.a = 255; + } + } + } + } + var meshIndex: c_int = 0; + _ = &meshIndex; + { + var i: c_uint = 0; + _ = &i; + while (@as(cgltf_size, @bitCast(@as(c_ulong, i))) < data.*.nodes_count) : (i +%= 1) { + var node: [*c]cgltf_node = &data.*.nodes[i]; + _ = &node; + var mesh: [*c]cgltf_mesh = node.*.mesh; + _ = &mesh; + if (!(mesh != null)) continue; + var worldTransform: [16]cgltf_float = undefined; + _ = &worldTransform; + cgltf_node_transform_world(node, @as([*c]cgltf_float, @ptrCast(@alignCast(&worldTransform)))); + var worldMatrix: Matrix = Matrix{ + .m0 = worldTransform[@as(c_uint, @intCast(@as(c_int, 0)))], + .m4 = worldTransform[@as(c_uint, @intCast(@as(c_int, 4)))], + .m8 = worldTransform[@as(c_uint, @intCast(@as(c_int, 8)))], + .m12 = worldTransform[@as(c_uint, @intCast(@as(c_int, 12)))], + .m1 = worldTransform[@as(c_uint, @intCast(@as(c_int, 1)))], + .m5 = worldTransform[@as(c_uint, @intCast(@as(c_int, 5)))], + .m9 = worldTransform[@as(c_uint, @intCast(@as(c_int, 9)))], + .m13 = worldTransform[@as(c_uint, @intCast(@as(c_int, 13)))], + .m2 = worldTransform[@as(c_uint, @intCast(@as(c_int, 2)))], + .m6 = worldTransform[@as(c_uint, @intCast(@as(c_int, 6)))], + .m10 = worldTransform[@as(c_uint, @intCast(@as(c_int, 10)))], + .m14 = worldTransform[@as(c_uint, @intCast(@as(c_int, 14)))], + .m3 = worldTransform[@as(c_uint, @intCast(@as(c_int, 3)))], + .m7 = worldTransform[@as(c_uint, @intCast(@as(c_int, 7)))], + .m11 = worldTransform[@as(c_uint, @intCast(@as(c_int, 11)))], + .m15 = worldTransform[@as(c_uint, @intCast(@as(c_int, 15)))], + }; + _ = &worldMatrix; + var worldMatrixNormals: Matrix = MatrixTranspose(MatrixInvert(worldMatrix)); + _ = &worldMatrixNormals; + { + var p: c_uint = 0; + _ = &p; + while (@as(cgltf_size, @bitCast(@as(c_ulong, p))) < mesh.*.primitives_count) : (p +%= 1) { + if (mesh.*.primitives[p].type != @as(c_uint, @bitCast(cgltf_primitive_type_triangles))) continue; + { + var j: c_uint = 0; + _ = &j; + while (@as(cgltf_size, @bitCast(@as(c_ulong, j))) < mesh.*.primitives[p].attributes_count) : (j +%= 1) { + if (mesh.*.primitives[p].attributes[j].type == @as(c_uint, @bitCast(cgltf_attribute_type_position))) { + var attribute: [*c]cgltf_accessor = mesh.*.primitives[p].attributes[j].data; + _ = &attribute; + if ((attribute.*.type == @as(c_uint, @bitCast(cgltf_type_vec3))) and (attribute.*.component_type == @as(c_uint, @bitCast(cgltf_component_type_r_32f)))) { + (blk: { + const tmp = meshIndex; + if (tmp >= 0) break :blk model.meshes + @as(usize, @intCast(tmp)) else break :blk model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.vertexCount = @as(c_int, @bitCast(@as(c_uint, @truncate(attribute.*.count)))); + (blk: { + const tmp = meshIndex; + if (tmp >= 0) break :blk model.meshes + @as(usize, @intCast(tmp)) else break :blk model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.vertices = @as([*c]f32, @ptrCast(@alignCast(malloc((attribute.*.count *% @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 3))))) *% @sizeOf(f32))))); + { + var n: c_int = 0; + _ = &n; + var buffer: [*c]f32 = (@as([*c]f32, @ptrCast(@alignCast(attribute.*.buffer_view.*.buffer.*.data))) + (attribute.*.buffer_view.*.offset / @sizeOf(f32))) + (attribute.*.offset / @sizeOf(f32)); + _ = &buffer; + { + var k: c_uint = 0; + _ = &k; + while (@as(cgltf_size, @bitCast(@as(c_ulong, k))) < attribute.*.count) : (k +%= 1) { + { + var l: c_int = 0; + _ = &l; + while (l < @as(c_int, 3)) : (l += 1) { + (blk: { + const tmp = meshIndex; + if (tmp >= 0) break :blk model.meshes + @as(usize, @intCast(tmp)) else break :blk model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.vertices[(@as(c_uint, @bitCast(@as(c_int, 3))) *% k) +% @as(c_uint, @bitCast(l))] = (blk: { + const tmp = n + l; + if (tmp >= 0) break :blk buffer + @as(usize, @intCast(tmp)) else break :blk buffer - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*; + } + } + n += @as(c_int, @bitCast(@as(c_uint, @truncate(attribute.*.stride / @sizeOf(f32))))); + } + } + } + var vertices: [*c]f32 = (blk: { + const tmp = meshIndex; + if (tmp >= 0) break :blk model.meshes + @as(usize, @intCast(tmp)) else break :blk model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.vertices; + _ = &vertices; + { + var k: c_uint = 0; + _ = &k; + while (@as(cgltf_size, @bitCast(@as(c_ulong, k))) < attribute.*.count) : (k +%= 1) { + var vt: Vector3 = Vector3Transform(Vector3{ + .x = vertices[@as(c_uint, @bitCast(@as(c_int, 3))) *% k], + .y = vertices[(@as(c_uint, @bitCast(@as(c_int, 3))) *% k) +% @as(c_uint, @bitCast(@as(c_int, 1)))], + .z = vertices[(@as(c_uint, @bitCast(@as(c_int, 3))) *% k) +% @as(c_uint, @bitCast(@as(c_int, 2)))], + }, worldMatrix); + _ = &vt; + vertices[@as(c_uint, @bitCast(@as(c_int, 3))) *% k] = vt.x; + vertices[(@as(c_uint, @bitCast(@as(c_int, 3))) *% k) +% @as(c_uint, @bitCast(@as(c_int, 1)))] = vt.y; + vertices[(@as(c_uint, @bitCast(@as(c_int, 3))) *% k) +% @as(c_uint, @bitCast(@as(c_int, 2)))] = vt.z; + } + } + } else { + TraceLog(LOG_WARNING, "MODEL: [%s] Vertices attribute data format not supported, use vec3 float", fileName); + } + } else if (mesh.*.primitives[p].attributes[j].type == @as(c_uint, @bitCast(cgltf_attribute_type_normal))) { + var attribute: [*c]cgltf_accessor = mesh.*.primitives[p].attributes[j].data; + _ = &attribute; + if ((attribute.*.type == @as(c_uint, @bitCast(cgltf_type_vec3))) and (attribute.*.component_type == @as(c_uint, @bitCast(cgltf_component_type_r_32f)))) { + (blk: { + const tmp = meshIndex; + if (tmp >= 0) break :blk model.meshes + @as(usize, @intCast(tmp)) else break :blk model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.normals = @as([*c]f32, @ptrCast(@alignCast(malloc((attribute.*.count *% @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 3))))) *% @sizeOf(f32))))); + { + var n: c_int = 0; + _ = &n; + var buffer: [*c]f32 = (@as([*c]f32, @ptrCast(@alignCast(attribute.*.buffer_view.*.buffer.*.data))) + (attribute.*.buffer_view.*.offset / @sizeOf(f32))) + (attribute.*.offset / @sizeOf(f32)); + _ = &buffer; + { + var k: c_uint = 0; + _ = &k; + while (@as(cgltf_size, @bitCast(@as(c_ulong, k))) < attribute.*.count) : (k +%= 1) { + { + var l: c_int = 0; + _ = &l; + while (l < @as(c_int, 3)) : (l += 1) { + (blk: { + const tmp = meshIndex; + if (tmp >= 0) break :blk model.meshes + @as(usize, @intCast(tmp)) else break :blk model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.normals[(@as(c_uint, @bitCast(@as(c_int, 3))) *% k) +% @as(c_uint, @bitCast(l))] = (blk: { + const tmp = n + l; + if (tmp >= 0) break :blk buffer + @as(usize, @intCast(tmp)) else break :blk buffer - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*; + } + } + n += @as(c_int, @bitCast(@as(c_uint, @truncate(attribute.*.stride / @sizeOf(f32))))); + } + } + } + var normals: [*c]f32 = (blk: { + const tmp = meshIndex; + if (tmp >= 0) break :blk model.meshes + @as(usize, @intCast(tmp)) else break :blk model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.normals; + _ = &normals; + { + var k: c_uint = 0; + _ = &k; + while (@as(cgltf_size, @bitCast(@as(c_ulong, k))) < attribute.*.count) : (k +%= 1) { + var nt: Vector3 = Vector3Transform(Vector3{ + .x = normals[@as(c_uint, @bitCast(@as(c_int, 3))) *% k], + .y = normals[(@as(c_uint, @bitCast(@as(c_int, 3))) *% k) +% @as(c_uint, @bitCast(@as(c_int, 1)))], + .z = normals[(@as(c_uint, @bitCast(@as(c_int, 3))) *% k) +% @as(c_uint, @bitCast(@as(c_int, 2)))], + }, worldMatrixNormals); + _ = &nt; + normals[@as(c_uint, @bitCast(@as(c_int, 3))) *% k] = nt.x; + normals[(@as(c_uint, @bitCast(@as(c_int, 3))) *% k) +% @as(c_uint, @bitCast(@as(c_int, 1)))] = nt.y; + normals[(@as(c_uint, @bitCast(@as(c_int, 3))) *% k) +% @as(c_uint, @bitCast(@as(c_int, 2)))] = nt.z; + } + } + } else { + TraceLog(LOG_WARNING, "MODEL: [%s] Normal attribute data format not supported, use vec3 float", fileName); + } + } else if (mesh.*.primitives[p].attributes[j].type == @as(c_uint, @bitCast(cgltf_attribute_type_tangent))) { + var attribute: [*c]cgltf_accessor = mesh.*.primitives[p].attributes[j].data; + _ = &attribute; + if ((attribute.*.type == @as(c_uint, @bitCast(cgltf_type_vec4))) and (attribute.*.component_type == @as(c_uint, @bitCast(cgltf_component_type_r_32f)))) { + (blk: { + const tmp = meshIndex; + if (tmp >= 0) break :blk model.meshes + @as(usize, @intCast(tmp)) else break :blk model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.tangents = @as([*c]f32, @ptrCast(@alignCast(malloc((attribute.*.count *% @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 4))))) *% @sizeOf(f32))))); + { + var n: c_int = 0; + _ = &n; + var buffer: [*c]f32 = (@as([*c]f32, @ptrCast(@alignCast(attribute.*.buffer_view.*.buffer.*.data))) + (attribute.*.buffer_view.*.offset / @sizeOf(f32))) + (attribute.*.offset / @sizeOf(f32)); + _ = &buffer; + { + var k: c_uint = 0; + _ = &k; + while (@as(cgltf_size, @bitCast(@as(c_ulong, k))) < attribute.*.count) : (k +%= 1) { + { + var l: c_int = 0; + _ = &l; + while (l < @as(c_int, 4)) : (l += 1) { + (blk: { + const tmp = meshIndex; + if (tmp >= 0) break :blk model.meshes + @as(usize, @intCast(tmp)) else break :blk model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.tangents[(@as(c_uint, @bitCast(@as(c_int, 4))) *% k) +% @as(c_uint, @bitCast(l))] = (blk: { + const tmp = n + l; + if (tmp >= 0) break :blk buffer + @as(usize, @intCast(tmp)) else break :blk buffer - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*; + } + } + n += @as(c_int, @bitCast(@as(c_uint, @truncate(attribute.*.stride / @sizeOf(f32))))); + } + } + } + var tangents: [*c]f32 = (blk: { + const tmp = meshIndex; + if (tmp >= 0) break :blk model.meshes + @as(usize, @intCast(tmp)) else break :blk model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.tangents; + _ = &tangents; + { + var k: c_uint = 0; + _ = &k; + while (@as(cgltf_size, @bitCast(@as(c_ulong, k))) < attribute.*.count) : (k +%= 1) { + var tt: Vector3 = Vector3Transform(Vector3{ + .x = tangents[@as(c_uint, @bitCast(@as(c_int, 3))) *% k], + .y = tangents[(@as(c_uint, @bitCast(@as(c_int, 3))) *% k) +% @as(c_uint, @bitCast(@as(c_int, 1)))], + .z = tangents[(@as(c_uint, @bitCast(@as(c_int, 3))) *% k) +% @as(c_uint, @bitCast(@as(c_int, 2)))], + }, worldMatrix); + _ = &tt; + tangents[@as(c_uint, @bitCast(@as(c_int, 3))) *% k] = tt.x; + tangents[(@as(c_uint, @bitCast(@as(c_int, 3))) *% k) +% @as(c_uint, @bitCast(@as(c_int, 1)))] = tt.y; + tangents[(@as(c_uint, @bitCast(@as(c_int, 3))) *% k) +% @as(c_uint, @bitCast(@as(c_int, 2)))] = tt.z; + } + } + } else { + TraceLog(LOG_WARNING, "MODEL: [%s] Tangent attribute data format not supported, use vec4 float", fileName); + } + } else if (mesh.*.primitives[p].attributes[j].type == @as(c_uint, @bitCast(cgltf_attribute_type_texcoord))) { + var texcoordPtr: [*c]f32 = null; + _ = &texcoordPtr; + var attribute: [*c]cgltf_accessor = mesh.*.primitives[p].attributes[j].data; + _ = &attribute; + if (attribute.*.type == @as(c_uint, @bitCast(cgltf_type_vec2))) { + if (attribute.*.component_type == @as(c_uint, @bitCast(cgltf_component_type_r_32f))) { + texcoordPtr = @as([*c]f32, @ptrCast(@alignCast(malloc((attribute.*.count *% @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 2))))) *% @sizeOf(f32))))); + { + var n: c_int = 0; + _ = &n; + var buffer: [*c]f32 = (@as([*c]f32, @ptrCast(@alignCast(attribute.*.buffer_view.*.buffer.*.data))) + (attribute.*.buffer_view.*.offset / @sizeOf(f32))) + (attribute.*.offset / @sizeOf(f32)); + _ = &buffer; + { + var k: c_uint = 0; + _ = &k; + while (@as(cgltf_size, @bitCast(@as(c_ulong, k))) < attribute.*.count) : (k +%= 1) { + { + var l: c_int = 0; + _ = &l; + while (l < @as(c_int, 2)) : (l += 1) { + texcoordPtr[(@as(c_uint, @bitCast(@as(c_int, 2))) *% k) +% @as(c_uint, @bitCast(l))] = (blk: { + const tmp = n + l; + if (tmp >= 0) break :blk buffer + @as(usize, @intCast(tmp)) else break :blk buffer - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*; + } + } + n += @as(c_int, @bitCast(@as(c_uint, @truncate(attribute.*.stride / @sizeOf(f32))))); + } + } + } + } else if (attribute.*.component_type == @as(c_uint, @bitCast(cgltf_component_type_r_8u))) { + texcoordPtr = @as([*c]f32, @ptrCast(@alignCast(malloc((attribute.*.count *% @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 2))))) *% @sizeOf(f32))))); + var temp: [*c]u8 = @as([*c]u8, @ptrCast(@alignCast(malloc((attribute.*.count *% @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 2))))) *% @sizeOf(u8))))); + _ = &temp; + { + var n: c_int = 0; + _ = &n; + var buffer: [*c]u8 = (@as([*c]u8, @ptrCast(@alignCast(attribute.*.buffer_view.*.buffer.*.data))) + (attribute.*.buffer_view.*.offset / @sizeOf(u8))) + (attribute.*.offset / @sizeOf(u8)); + _ = &buffer; + { + var k: c_uint = 0; + _ = &k; + while (@as(cgltf_size, @bitCast(@as(c_ulong, k))) < attribute.*.count) : (k +%= 1) { + { + var l: c_int = 0; + _ = &l; + while (l < @as(c_int, 2)) : (l += 1) { + temp[(@as(c_uint, @bitCast(@as(c_int, 2))) *% k) +% @as(c_uint, @bitCast(l))] = (blk: { + const tmp = n + l; + if (tmp >= 0) break :blk buffer + @as(usize, @intCast(tmp)) else break :blk buffer - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*; + } + } + n += @as(c_int, @bitCast(@as(c_uint, @truncate(attribute.*.stride / @sizeOf(u8))))); + } + } + } + { + var t: c_uint = 0; + _ = &t; + while (@as(cgltf_size, @bitCast(@as(c_ulong, t))) < (attribute.*.count *% @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 2)))))) : (t +%= 1) { + texcoordPtr[t] = @as(f32, @floatFromInt(temp[t])) / 255.0; + } + } + free(@as(?*anyopaque, @ptrCast(temp))); + } else if (attribute.*.component_type == @as(c_uint, @bitCast(cgltf_component_type_r_16u))) { + texcoordPtr = @as([*c]f32, @ptrCast(@alignCast(malloc((attribute.*.count *% @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 2))))) *% @sizeOf(f32))))); + var temp: [*c]c_ushort = @as([*c]c_ushort, @ptrCast(@alignCast(malloc((attribute.*.count *% @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 2))))) *% @sizeOf(c_ushort))))); + _ = &temp; + { + var n: c_int = 0; + _ = &n; + var buffer: [*c]c_ushort = (@as([*c]c_ushort, @ptrCast(@alignCast(attribute.*.buffer_view.*.buffer.*.data))) + (attribute.*.buffer_view.*.offset / @sizeOf(c_ushort))) + (attribute.*.offset / @sizeOf(c_ushort)); + _ = &buffer; + { + var k: c_uint = 0; + _ = &k; + while (@as(cgltf_size, @bitCast(@as(c_ulong, k))) < attribute.*.count) : (k +%= 1) { + { + var l: c_int = 0; + _ = &l; + while (l < @as(c_int, 2)) : (l += 1) { + temp[(@as(c_uint, @bitCast(@as(c_int, 2))) *% k) +% @as(c_uint, @bitCast(l))] = (blk: { + const tmp = n + l; + if (tmp >= 0) break :blk buffer + @as(usize, @intCast(tmp)) else break :blk buffer - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*; + } + } + n += @as(c_int, @bitCast(@as(c_uint, @truncate(attribute.*.stride / @sizeOf(c_ushort))))); + } + } + } + { + var t: c_uint = 0; + _ = &t; + while (@as(cgltf_size, @bitCast(@as(c_ulong, t))) < (attribute.*.count *% @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 2)))))) : (t +%= 1) { + texcoordPtr[t] = @as(f32, @floatFromInt(temp[t])) / 65535.0; + } + } + free(@as(?*anyopaque, @ptrCast(temp))); + } else { + TraceLog(LOG_WARNING, "MODEL: [%s] Texcoords attribute data format not supported", fileName); + } + } else { + TraceLog(LOG_WARNING, "MODEL: [%s] Texcoords attribute data format not supported, use vec2 float", fileName); + } + var index_1: c_int = mesh.*.primitives[p].attributes[j].index; + _ = &index_1; + if (index_1 == @as(c_int, 0)) { + (blk: { + const tmp = meshIndex; + if (tmp >= 0) break :blk model.meshes + @as(usize, @intCast(tmp)) else break :blk model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.texcoords = texcoordPtr; + } else if (index_1 == @as(c_int, 1)) { + (blk: { + const tmp = meshIndex; + if (tmp >= 0) break :blk model.meshes + @as(usize, @intCast(tmp)) else break :blk model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.texcoords2 = texcoordPtr; + } else { + TraceLog(LOG_WARNING, "MODEL: [%s] No more than 2 texture coordinates attributes supported", fileName); + if (texcoordPtr != @as([*c]f32, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0))))))) { + free(@as(?*anyopaque, @ptrCast(texcoordPtr))); + } + } + } else if (mesh.*.primitives[p].attributes[j].type == @as(c_uint, @bitCast(cgltf_attribute_type_color))) { + var attribute: [*c]cgltf_accessor = mesh.*.primitives[p].attributes[j].data; + _ = &attribute; + if (attribute.*.type == @as(c_uint, @bitCast(cgltf_type_vec3))) { + if (attribute.*.component_type == @as(c_uint, @bitCast(cgltf_component_type_r_8u))) { + (blk: { + const tmp = meshIndex; + if (tmp >= 0) break :blk model.meshes + @as(usize, @intCast(tmp)) else break :blk model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.colors = @as([*c]u8, @ptrCast(@alignCast(malloc((attribute.*.count *% @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 4))))) *% @sizeOf(u8))))); + var temp: [*c]u8 = @as([*c]u8, @ptrCast(@alignCast(malloc((attribute.*.count *% @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 3))))) *% @sizeOf(u8))))); + _ = &temp; + { + var n: c_int = 0; + _ = &n; + var buffer: [*c]u8 = (@as([*c]u8, @ptrCast(@alignCast(attribute.*.buffer_view.*.buffer.*.data))) + (attribute.*.buffer_view.*.offset / @sizeOf(u8))) + (attribute.*.offset / @sizeOf(u8)); + _ = &buffer; + { + var k: c_uint = 0; + _ = &k; + while (@as(cgltf_size, @bitCast(@as(c_ulong, k))) < attribute.*.count) : (k +%= 1) { + { + var l: c_int = 0; + _ = &l; + while (l < @as(c_int, 3)) : (l += 1) { + temp[(@as(c_uint, @bitCast(@as(c_int, 3))) *% k) +% @as(c_uint, @bitCast(l))] = (blk: { + const tmp = n + l; + if (tmp >= 0) break :blk buffer + @as(usize, @intCast(tmp)) else break :blk buffer - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*; + } + } + n += @as(c_int, @bitCast(@as(c_uint, @truncate(attribute.*.stride / @sizeOf(u8))))); + } + } + } + { + var c: c_uint = 0; + _ = &c; + var k: c_uint = 0; + _ = &k; + while (@as(cgltf_size, @bitCast(@as(c_ulong, c))) < ((attribute.*.count *% @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 4))))) -% @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 3)))))) : (_ = blk: { + c +%= @as(c_uint, @bitCast(@as(c_int, 4))); + break :blk blk_1: { + const ref = &k; + ref.* +%= @as(c_uint, @bitCast(@as(c_int, 3))); + break :blk_1 ref.*; + }; + }) { + (blk: { + const tmp = meshIndex; + if (tmp >= 0) break :blk model.meshes + @as(usize, @intCast(tmp)) else break :blk model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.colors[c] = temp[k]; + (blk: { + const tmp = meshIndex; + if (tmp >= 0) break :blk model.meshes + @as(usize, @intCast(tmp)) else break :blk model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.colors[c +% @as(c_uint, @bitCast(@as(c_int, 1)))] = temp[k +% @as(c_uint, @bitCast(@as(c_int, 1)))]; + (blk: { + const tmp = meshIndex; + if (tmp >= 0) break :blk model.meshes + @as(usize, @intCast(tmp)) else break :blk model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.colors[c +% @as(c_uint, @bitCast(@as(c_int, 2)))] = temp[k +% @as(c_uint, @bitCast(@as(c_int, 2)))]; + (blk: { + const tmp = meshIndex; + if (tmp >= 0) break :blk model.meshes + @as(usize, @intCast(tmp)) else break :blk model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.colors[c +% @as(c_uint, @bitCast(@as(c_int, 3)))] = 255; + } + } + free(@as(?*anyopaque, @ptrCast(temp))); + } else if (attribute.*.component_type == @as(c_uint, @bitCast(cgltf_component_type_r_16u))) { + (blk: { + const tmp = meshIndex; + if (tmp >= 0) break :blk model.meshes + @as(usize, @intCast(tmp)) else break :blk model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.colors = @as([*c]u8, @ptrCast(@alignCast(malloc((attribute.*.count *% @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 4))))) *% @sizeOf(u8))))); + var temp: [*c]c_ushort = @as([*c]c_ushort, @ptrCast(@alignCast(malloc((attribute.*.count *% @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 3))))) *% @sizeOf(c_ushort))))); + _ = &temp; + { + var n: c_int = 0; + _ = &n; + var buffer: [*c]c_ushort = (@as([*c]c_ushort, @ptrCast(@alignCast(attribute.*.buffer_view.*.buffer.*.data))) + (attribute.*.buffer_view.*.offset / @sizeOf(c_ushort))) + (attribute.*.offset / @sizeOf(c_ushort)); + _ = &buffer; + { + var k: c_uint = 0; + _ = &k; + while (@as(cgltf_size, @bitCast(@as(c_ulong, k))) < attribute.*.count) : (k +%= 1) { + { + var l: c_int = 0; + _ = &l; + while (l < @as(c_int, 3)) : (l += 1) { + temp[(@as(c_uint, @bitCast(@as(c_int, 3))) *% k) +% @as(c_uint, @bitCast(l))] = (blk: { + const tmp = n + l; + if (tmp >= 0) break :blk buffer + @as(usize, @intCast(tmp)) else break :blk buffer - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*; + } + } + n += @as(c_int, @bitCast(@as(c_uint, @truncate(attribute.*.stride / @sizeOf(c_ushort))))); + } + } + } + { + var c: c_uint = 0; + _ = &c; + var k: c_uint = 0; + _ = &k; + while (@as(cgltf_size, @bitCast(@as(c_ulong, c))) < ((attribute.*.count *% @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 4))))) -% @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 3)))))) : (_ = blk: { + c +%= @as(c_uint, @bitCast(@as(c_int, 4))); + break :blk blk_1: { + const ref = &k; + ref.* +%= @as(c_uint, @bitCast(@as(c_int, 3))); + break :blk_1 ref.*; + }; + }) { + (blk: { + const tmp = meshIndex; + if (tmp >= 0) break :blk model.meshes + @as(usize, @intCast(tmp)) else break :blk model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.colors[c] = @as(u8, @intFromFloat((@as(f32, @floatFromInt(temp[k])) / 65535.0) * 255.0)); + (blk: { + const tmp = meshIndex; + if (tmp >= 0) break :blk model.meshes + @as(usize, @intCast(tmp)) else break :blk model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.colors[c +% @as(c_uint, @bitCast(@as(c_int, 1)))] = @as(u8, @intFromFloat((@as(f32, @floatFromInt(temp[k +% @as(c_uint, @bitCast(@as(c_int, 1)))])) / 65535.0) * 255.0)); + (blk: { + const tmp = meshIndex; + if (tmp >= 0) break :blk model.meshes + @as(usize, @intCast(tmp)) else break :blk model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.colors[c +% @as(c_uint, @bitCast(@as(c_int, 2)))] = @as(u8, @intFromFloat((@as(f32, @floatFromInt(temp[k +% @as(c_uint, @bitCast(@as(c_int, 2)))])) / 65535.0) * 255.0)); + (blk: { + const tmp = meshIndex; + if (tmp >= 0) break :blk model.meshes + @as(usize, @intCast(tmp)) else break :blk model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.colors[c +% @as(c_uint, @bitCast(@as(c_int, 3)))] = 255; + } + } + free(@as(?*anyopaque, @ptrCast(temp))); + } else if (attribute.*.component_type == @as(c_uint, @bitCast(cgltf_component_type_r_32f))) { + (blk: { + const tmp = meshIndex; + if (tmp >= 0) break :blk model.meshes + @as(usize, @intCast(tmp)) else break :blk model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.colors = @as([*c]u8, @ptrCast(@alignCast(malloc((attribute.*.count *% @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 4))))) *% @sizeOf(u8))))); + var temp: [*c]f32 = @as([*c]f32, @ptrCast(@alignCast(malloc((attribute.*.count *% @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 3))))) *% @sizeOf(f32))))); + _ = &temp; + { + var n: c_int = 0; + _ = &n; + var buffer: [*c]f32 = (@as([*c]f32, @ptrCast(@alignCast(attribute.*.buffer_view.*.buffer.*.data))) + (attribute.*.buffer_view.*.offset / @sizeOf(f32))) + (attribute.*.offset / @sizeOf(f32)); + _ = &buffer; + { + var k: c_uint = 0; + _ = &k; + while (@as(cgltf_size, @bitCast(@as(c_ulong, k))) < attribute.*.count) : (k +%= 1) { + { + var l: c_int = 0; + _ = &l; + while (l < @as(c_int, 3)) : (l += 1) { + temp[(@as(c_uint, @bitCast(@as(c_int, 3))) *% k) +% @as(c_uint, @bitCast(l))] = (blk: { + const tmp = n + l; + if (tmp >= 0) break :blk buffer + @as(usize, @intCast(tmp)) else break :blk buffer - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*; + } + } + n += @as(c_int, @bitCast(@as(c_uint, @truncate(attribute.*.stride / @sizeOf(f32))))); + } + } + } + { + var c: c_uint = 0; + _ = &c; + var k: c_uint = 0; + _ = &k; + while (@as(cgltf_size, @bitCast(@as(c_ulong, c))) < ((attribute.*.count *% @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 4))))) -% @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 3)))))) : (_ = blk: { + c +%= @as(c_uint, @bitCast(@as(c_int, 4))); + break :blk blk_1: { + const ref = &k; + ref.* +%= @as(c_uint, @bitCast(@as(c_int, 3))); + break :blk_1 ref.*; + }; + }) { + (blk: { + const tmp = meshIndex; + if (tmp >= 0) break :blk model.meshes + @as(usize, @intCast(tmp)) else break :blk model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.colors[c] = @as(u8, @intFromFloat(temp[k] * 255.0)); + (blk: { + const tmp = meshIndex; + if (tmp >= 0) break :blk model.meshes + @as(usize, @intCast(tmp)) else break :blk model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.colors[c +% @as(c_uint, @bitCast(@as(c_int, 1)))] = @as(u8, @intFromFloat(temp[k +% @as(c_uint, @bitCast(@as(c_int, 1)))] * 255.0)); + (blk: { + const tmp = meshIndex; + if (tmp >= 0) break :blk model.meshes + @as(usize, @intCast(tmp)) else break :blk model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.colors[c +% @as(c_uint, @bitCast(@as(c_int, 2)))] = @as(u8, @intFromFloat(temp[k +% @as(c_uint, @bitCast(@as(c_int, 2)))] * 255.0)); + (blk: { + const tmp = meshIndex; + if (tmp >= 0) break :blk model.meshes + @as(usize, @intCast(tmp)) else break :blk model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.colors[c +% @as(c_uint, @bitCast(@as(c_int, 3)))] = 255; + } + } + free(@as(?*anyopaque, @ptrCast(temp))); + } else { + TraceLog(LOG_WARNING, "MODEL: [%s] Color attribute data format not supported", fileName); + } + } else if (attribute.*.type == @as(c_uint, @bitCast(cgltf_type_vec4))) { + if (attribute.*.component_type == @as(c_uint, @bitCast(cgltf_component_type_r_8u))) { + (blk: { + const tmp = meshIndex; + if (tmp >= 0) break :blk model.meshes + @as(usize, @intCast(tmp)) else break :blk model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.colors = @as([*c]u8, @ptrCast(@alignCast(malloc((attribute.*.count *% @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 4))))) *% @sizeOf(u8))))); + { + var n: c_int = 0; + _ = &n; + var buffer: [*c]u8 = (@as([*c]u8, @ptrCast(@alignCast(attribute.*.buffer_view.*.buffer.*.data))) + (attribute.*.buffer_view.*.offset / @sizeOf(u8))) + (attribute.*.offset / @sizeOf(u8)); + _ = &buffer; + { + var k: c_uint = 0; + _ = &k; + while (@as(cgltf_size, @bitCast(@as(c_ulong, k))) < attribute.*.count) : (k +%= 1) { + { + var l: c_int = 0; + _ = &l; + while (l < @as(c_int, 4)) : (l += 1) { + (blk: { + const tmp = meshIndex; + if (tmp >= 0) break :blk model.meshes + @as(usize, @intCast(tmp)) else break :blk model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.colors[(@as(c_uint, @bitCast(@as(c_int, 4))) *% k) +% @as(c_uint, @bitCast(l))] = (blk: { + const tmp = n + l; + if (tmp >= 0) break :blk buffer + @as(usize, @intCast(tmp)) else break :blk buffer - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*; + } + } + n += @as(c_int, @bitCast(@as(c_uint, @truncate(attribute.*.stride / @sizeOf(u8))))); + } + } + } + } else if (attribute.*.component_type == @as(c_uint, @bitCast(cgltf_component_type_r_16u))) { + (blk: { + const tmp = meshIndex; + if (tmp >= 0) break :blk model.meshes + @as(usize, @intCast(tmp)) else break :blk model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.colors = @as([*c]u8, @ptrCast(@alignCast(malloc((attribute.*.count *% @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 4))))) *% @sizeOf(u8))))); + var temp: [*c]c_ushort = @as([*c]c_ushort, @ptrCast(@alignCast(malloc((attribute.*.count *% @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 4))))) *% @sizeOf(c_ushort))))); + _ = &temp; + { + var n: c_int = 0; + _ = &n; + var buffer: [*c]c_ushort = (@as([*c]c_ushort, @ptrCast(@alignCast(attribute.*.buffer_view.*.buffer.*.data))) + (attribute.*.buffer_view.*.offset / @sizeOf(c_ushort))) + (attribute.*.offset / @sizeOf(c_ushort)); + _ = &buffer; + { + var k: c_uint = 0; + _ = &k; + while (@as(cgltf_size, @bitCast(@as(c_ulong, k))) < attribute.*.count) : (k +%= 1) { + { + var l: c_int = 0; + _ = &l; + while (l < @as(c_int, 4)) : (l += 1) { + temp[(@as(c_uint, @bitCast(@as(c_int, 4))) *% k) +% @as(c_uint, @bitCast(l))] = (blk: { + const tmp = n + l; + if (tmp >= 0) break :blk buffer + @as(usize, @intCast(tmp)) else break :blk buffer - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*; + } + } + n += @as(c_int, @bitCast(@as(c_uint, @truncate(attribute.*.stride / @sizeOf(c_ushort))))); + } + } + } + { + var c: c_uint = 0; + _ = &c; + while (@as(cgltf_size, @bitCast(@as(c_ulong, c))) < (attribute.*.count *% @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 4)))))) : (c +%= 1) { + (blk: { + const tmp = meshIndex; + if (tmp >= 0) break :blk model.meshes + @as(usize, @intCast(tmp)) else break :blk model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.colors[c] = @as(u8, @intFromFloat((@as(f32, @floatFromInt(temp[c])) / 65535.0) * 255.0)); + } + } + free(@as(?*anyopaque, @ptrCast(temp))); + } else if (attribute.*.component_type == @as(c_uint, @bitCast(cgltf_component_type_r_32f))) { + (blk: { + const tmp = meshIndex; + if (tmp >= 0) break :blk model.meshes + @as(usize, @intCast(tmp)) else break :blk model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.colors = @as([*c]u8, @ptrCast(@alignCast(malloc((attribute.*.count *% @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 4))))) *% @sizeOf(u8))))); + var temp: [*c]f32 = @as([*c]f32, @ptrCast(@alignCast(malloc((attribute.*.count *% @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 4))))) *% @sizeOf(f32))))); + _ = &temp; + { + var n: c_int = 0; + _ = &n; + var buffer: [*c]f32 = (@as([*c]f32, @ptrCast(@alignCast(attribute.*.buffer_view.*.buffer.*.data))) + (attribute.*.buffer_view.*.offset / @sizeOf(f32))) + (attribute.*.offset / @sizeOf(f32)); + _ = &buffer; + { + var k: c_uint = 0; + _ = &k; + while (@as(cgltf_size, @bitCast(@as(c_ulong, k))) < attribute.*.count) : (k +%= 1) { + { + var l: c_int = 0; + _ = &l; + while (l < @as(c_int, 4)) : (l += 1) { + temp[(@as(c_uint, @bitCast(@as(c_int, 4))) *% k) +% @as(c_uint, @bitCast(l))] = (blk: { + const tmp = n + l; + if (tmp >= 0) break :blk buffer + @as(usize, @intCast(tmp)) else break :blk buffer - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*; + } + } + n += @as(c_int, @bitCast(@as(c_uint, @truncate(attribute.*.stride / @sizeOf(f32))))); + } + } + } + { + var c: c_uint = 0; + _ = &c; + while (@as(cgltf_size, @bitCast(@as(c_ulong, c))) < (attribute.*.count *% @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 4)))))) : (c +%= 1) { + (blk: { + const tmp = meshIndex; + if (tmp >= 0) break :blk model.meshes + @as(usize, @intCast(tmp)) else break :blk model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.colors[c] = @as(u8, @intFromFloat(temp[c] * 255.0)); + } + } + free(@as(?*anyopaque, @ptrCast(temp))); + } else { + TraceLog(LOG_WARNING, "MODEL: [%s] Color attribute data format not supported", fileName); + } + } else { + TraceLog(LOG_WARNING, "MODEL: [%s] Color attribute data format not supported", fileName); + } + } + } + } + if (mesh.*.primitives[p].indices != @as([*c]cgltf_accessor, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0))))))) { + var attribute: [*c]cgltf_accessor = mesh.*.primitives[p].indices; + _ = &attribute; + (blk: { + const tmp = meshIndex; + if (tmp >= 0) break :blk model.meshes + @as(usize, @intCast(tmp)) else break :blk model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.triangleCount = @divTrunc(@as(c_int, @bitCast(@as(c_uint, @truncate(attribute.*.count)))), @as(c_int, 3)); + if (attribute.*.component_type == @as(c_uint, @bitCast(cgltf_component_type_r_16u))) { + (blk: { + const tmp = meshIndex; + if (tmp >= 0) break :blk model.meshes + @as(usize, @intCast(tmp)) else break :blk model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.indices = @as([*c]c_ushort, @ptrCast(@alignCast(malloc(attribute.*.count *% @sizeOf(c_ushort))))); + { + var n: c_int = 0; + _ = &n; + var buffer: [*c]c_ushort = (@as([*c]c_ushort, @ptrCast(@alignCast(attribute.*.buffer_view.*.buffer.*.data))) + (attribute.*.buffer_view.*.offset / @sizeOf(c_ushort))) + (attribute.*.offset / @sizeOf(c_ushort)); + _ = &buffer; + { + var k: c_uint = 0; + _ = &k; + while (@as(cgltf_size, @bitCast(@as(c_ulong, k))) < attribute.*.count) : (k +%= 1) { + { + var l: c_int = 0; + _ = &l; + while (l < @as(c_int, 1)) : (l += 1) { + (blk: { + const tmp = meshIndex; + if (tmp >= 0) break :blk model.meshes + @as(usize, @intCast(tmp)) else break :blk model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.indices[(@as(c_uint, @bitCast(@as(c_int, 1))) *% k) +% @as(c_uint, @bitCast(l))] = (blk: { + const tmp = n + l; + if (tmp >= 0) break :blk buffer + @as(usize, @intCast(tmp)) else break :blk buffer - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*; + } + } + n += @as(c_int, @bitCast(@as(c_uint, @truncate(attribute.*.stride / @sizeOf(c_ushort))))); + } + } + } + } else if (attribute.*.component_type == @as(c_uint, @bitCast(cgltf_component_type_r_32u))) { + (blk: { + const tmp = meshIndex; + if (tmp >= 0) break :blk model.meshes + @as(usize, @intCast(tmp)) else break :blk model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.indices = @as([*c]c_ushort, @ptrCast(@alignCast(malloc(attribute.*.count *% @sizeOf(c_ushort))))); + var temp: [*c]c_uint = @as([*c]c_uint, @ptrCast(@alignCast(malloc(attribute.*.count *% @sizeOf(c_uint))))); + _ = &temp; + { + var n: c_int = 0; + _ = &n; + var buffer: [*c]c_uint = (@as([*c]c_uint, @ptrCast(@alignCast(attribute.*.buffer_view.*.buffer.*.data))) + (attribute.*.buffer_view.*.offset / @sizeOf(c_uint))) + (attribute.*.offset / @sizeOf(c_uint)); + _ = &buffer; + { + var k: c_uint = 0; + _ = &k; + while (@as(cgltf_size, @bitCast(@as(c_ulong, k))) < attribute.*.count) : (k +%= 1) { + { + var l: c_int = 0; + _ = &l; + while (l < @as(c_int, 1)) : (l += 1) { + temp[(@as(c_uint, @bitCast(@as(c_int, 1))) *% k) +% @as(c_uint, @bitCast(l))] = (blk: { + const tmp = n + l; + if (tmp >= 0) break :blk buffer + @as(usize, @intCast(tmp)) else break :blk buffer - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*; + } + } + n += @as(c_int, @bitCast(@as(c_uint, @truncate(attribute.*.stride / @sizeOf(c_uint))))); + } + } + } + { + var d: c_uint = 0; + _ = &d; + while (@as(cgltf_size, @bitCast(@as(c_ulong, d))) < attribute.*.count) : (d +%= 1) { + (blk: { + const tmp = meshIndex; + if (tmp >= 0) break :blk model.meshes + @as(usize, @intCast(tmp)) else break :blk model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.indices[d] = @as(c_ushort, @bitCast(@as(c_ushort, @truncate(temp[d])))); + } + } + TraceLog(LOG_WARNING, "MODEL: [%s] Indices data converted from u32 to u16, possible loss of data", fileName); + free(@as(?*anyopaque, @ptrCast(temp))); + } else { + TraceLog(LOG_WARNING, "MODEL: [%s] Indices data format not supported, use u16", fileName); + } + } else { + (blk: { + const tmp = meshIndex; + if (tmp >= 0) break :blk model.meshes + @as(usize, @intCast(tmp)) else break :blk model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.triangleCount = @divTrunc((blk: { + const tmp = meshIndex; + if (tmp >= 0) break :blk model.meshes + @as(usize, @intCast(tmp)) else break :blk model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.vertexCount, @as(c_int, 3)); + } + { + var m: c_uint = 0; + _ = &m; + while (@as(cgltf_size, @bitCast(@as(c_ulong, m))) < data.*.materials_count) : (m +%= 1) { + if ((&data.*.materials[m]) == mesh.*.primitives[p].material) { + (blk: { + const tmp = meshIndex; + if (tmp >= 0) break :blk model.meshMaterial + @as(usize, @intCast(tmp)) else break :blk model.meshMaterial - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = @as(c_int, @bitCast(m +% @as(c_uint, @bitCast(@as(c_int, 1))))); + break; + } + } + } + meshIndex += 1; + } + } + } + } + if (data.*.skins_count == @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 1))))) { + var skin: cgltf_skin = data.*.skins[@as(c_uint, @intCast(@as(c_int, 0)))]; + _ = &skin; + model.bones = LoadBoneInfoGLTF(skin, &model.boneCount); + model.bindPose = @as([*c]Transform, @ptrCast(@alignCast(malloc(@as(c_ulong, @bitCast(@as(c_long, model.boneCount))) *% @sizeOf(Transform))))); + { + var i: c_int = 0; + _ = &i; + while (i < model.boneCount) : (i += 1) { + var node: [*c]cgltf_node = (blk: { + const tmp = i; + if (tmp >= 0) break :blk skin.joints + @as(usize, @intCast(tmp)) else break :blk skin.joints - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*; + _ = &node; + var worldTransform: [16]cgltf_float = undefined; + _ = &worldTransform; + cgltf_node_transform_world(node, @as([*c]cgltf_float, @ptrCast(@alignCast(&worldTransform)))); + var worldMatrix: Matrix = Matrix{ + .m0 = worldTransform[@as(c_uint, @intCast(@as(c_int, 0)))], + .m4 = worldTransform[@as(c_uint, @intCast(@as(c_int, 4)))], + .m8 = worldTransform[@as(c_uint, @intCast(@as(c_int, 8)))], + .m12 = worldTransform[@as(c_uint, @intCast(@as(c_int, 12)))], + .m1 = worldTransform[@as(c_uint, @intCast(@as(c_int, 1)))], + .m5 = worldTransform[@as(c_uint, @intCast(@as(c_int, 5)))], + .m9 = worldTransform[@as(c_uint, @intCast(@as(c_int, 9)))], + .m13 = worldTransform[@as(c_uint, @intCast(@as(c_int, 13)))], + .m2 = worldTransform[@as(c_uint, @intCast(@as(c_int, 2)))], + .m6 = worldTransform[@as(c_uint, @intCast(@as(c_int, 6)))], + .m10 = worldTransform[@as(c_uint, @intCast(@as(c_int, 10)))], + .m14 = worldTransform[@as(c_uint, @intCast(@as(c_int, 14)))], + .m3 = worldTransform[@as(c_uint, @intCast(@as(c_int, 3)))], + .m7 = worldTransform[@as(c_uint, @intCast(@as(c_int, 7)))], + .m11 = worldTransform[@as(c_uint, @intCast(@as(c_int, 11)))], + .m15 = worldTransform[@as(c_uint, @intCast(@as(c_int, 15)))], + }; + _ = &worldMatrix; + MatrixDecompose(worldMatrix, &(blk: { + const tmp = i; + if (tmp >= 0) break :blk model.bindPose + @as(usize, @intCast(tmp)) else break :blk model.bindPose - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.translation, &(blk: { + const tmp = i; + if (tmp >= 0) break :blk model.bindPose + @as(usize, @intCast(tmp)) else break :blk model.bindPose - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.rotation, &(blk: { + const tmp = i; + if (tmp >= 0) break :blk model.bindPose + @as(usize, @intCast(tmp)) else break :blk model.bindPose - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.scale); + } + } + } else if (data.*.skins_count > @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 1))))) { + TraceLog(LOG_ERROR, "MODEL: [%s] can only load one skin (armature) per model, but gltf skins_count == %i", fileName, data.*.skins_count); + } + meshIndex = 0; + { + var i: c_uint = 0; + _ = &i; + while (@as(cgltf_size, @bitCast(@as(c_ulong, i))) < data.*.nodes_count) : (i +%= 1) { + var node: [*c]cgltf_node = &data.*.nodes[i]; + _ = &node; + var mesh: [*c]cgltf_mesh = node.*.mesh; + _ = &mesh; + if (!(mesh != null)) continue; + { + var p: c_uint = 0; + _ = &p; + while (@as(cgltf_size, @bitCast(@as(c_ulong, p))) < mesh.*.primitives_count) : (p +%= 1) { + if (mesh.*.primitives[p].type != @as(c_uint, @bitCast(cgltf_primitive_type_triangles))) continue; + { + var j: c_uint = 0; + _ = &j; + while (@as(cgltf_size, @bitCast(@as(c_ulong, j))) < mesh.*.primitives[p].attributes_count) : (j +%= 1) { + if (mesh.*.primitives[p].attributes[j].type == @as(c_uint, @bitCast(cgltf_attribute_type_joints))) { + var attribute: [*c]cgltf_accessor = mesh.*.primitives[p].attributes[j].data; + _ = &attribute; + if (attribute.*.type == @as(c_uint, @bitCast(cgltf_type_vec4))) { + if (attribute.*.component_type == @as(c_uint, @bitCast(cgltf_component_type_r_8u))) { + (blk: { + const tmp = meshIndex; + if (tmp >= 0) break :blk model.meshes + @as(usize, @intCast(tmp)) else break :blk model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.boneIds = @as([*c]u8, @ptrCast(@alignCast(calloc(@as(c_ulong, @bitCast(@as(c_long, (blk: { + const tmp = meshIndex; + if (tmp >= 0) break :blk model.meshes + @as(usize, @intCast(tmp)) else break :blk model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.vertexCount * @as(c_int, 4)))), @sizeOf(u8))))); + { + var n: c_int = 0; + _ = &n; + var buffer: [*c]u8 = (@as([*c]u8, @ptrCast(@alignCast(attribute.*.buffer_view.*.buffer.*.data))) + (attribute.*.buffer_view.*.offset / @sizeOf(u8))) + (attribute.*.offset / @sizeOf(u8)); + _ = &buffer; + { + var k: c_uint = 0; + _ = &k; + while (@as(cgltf_size, @bitCast(@as(c_ulong, k))) < attribute.*.count) : (k +%= 1) { + { + var l: c_int = 0; + _ = &l; + while (l < @as(c_int, 4)) : (l += 1) { + (blk: { + const tmp = meshIndex; + if (tmp >= 0) break :blk model.meshes + @as(usize, @intCast(tmp)) else break :blk model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.boneIds[(@as(c_uint, @bitCast(@as(c_int, 4))) *% k) +% @as(c_uint, @bitCast(l))] = (blk: { + const tmp = n + l; + if (tmp >= 0) break :blk buffer + @as(usize, @intCast(tmp)) else break :blk buffer - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*; + } + } + n += @as(c_int, @bitCast(@as(c_uint, @truncate(attribute.*.stride / @sizeOf(u8))))); + } + } + } + } else if (attribute.*.component_type == @as(c_uint, @bitCast(cgltf_component_type_r_16u))) { + (blk: { + const tmp = meshIndex; + if (tmp >= 0) break :blk model.meshes + @as(usize, @intCast(tmp)) else break :blk model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.boneIds = @as([*c]u8, @ptrCast(@alignCast(calloc(@as(c_ulong, @bitCast(@as(c_long, (blk: { + const tmp = meshIndex; + if (tmp >= 0) break :blk model.meshes + @as(usize, @intCast(tmp)) else break :blk model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.vertexCount * @as(c_int, 4)))), @sizeOf(u8))))); + var temp: [*c]c_ushort = @as([*c]c_ushort, @ptrCast(@alignCast(calloc(@as(c_ulong, @bitCast(@as(c_long, (blk: { + const tmp = meshIndex; + if (tmp >= 0) break :blk model.meshes + @as(usize, @intCast(tmp)) else break :blk model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.vertexCount * @as(c_int, 4)))), @sizeOf(c_ushort))))); + _ = &temp; + { + var n: c_int = 0; + _ = &n; + var buffer: [*c]c_ushort = (@as([*c]c_ushort, @ptrCast(@alignCast(attribute.*.buffer_view.*.buffer.*.data))) + (attribute.*.buffer_view.*.offset / @sizeOf(c_ushort))) + (attribute.*.offset / @sizeOf(c_ushort)); + _ = &buffer; + { + var k: c_uint = 0; + _ = &k; + while (@as(cgltf_size, @bitCast(@as(c_ulong, k))) < attribute.*.count) : (k +%= 1) { + { + var l: c_int = 0; + _ = &l; + while (l < @as(c_int, 4)) : (l += 1) { + temp[(@as(c_uint, @bitCast(@as(c_int, 4))) *% k) +% @as(c_uint, @bitCast(l))] = (blk: { + const tmp = n + l; + if (tmp >= 0) break :blk buffer + @as(usize, @intCast(tmp)) else break :blk buffer - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*; + } + } + n += @as(c_int, @bitCast(@as(c_uint, @truncate(attribute.*.stride / @sizeOf(c_ushort))))); + } + } + } + var boneIdOverflowWarning: bool = @as(c_int, 0) != 0; + _ = &boneIdOverflowWarning; + { + var b: c_int = 0; + _ = &b; + while (b < ((blk: { + const tmp = meshIndex; + if (tmp >= 0) break :blk model.meshes + @as(usize, @intCast(tmp)) else break :blk model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.vertexCount * @as(c_int, 4))) : (b += 1) { + if ((@as(c_int, @bitCast(@as(c_uint, (blk: { + const tmp = b; + if (tmp >= 0) break :blk temp + @as(usize, @intCast(tmp)) else break :blk temp - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*))) > @as(c_int, 255)) and !boneIdOverflowWarning) { + TraceLog(LOG_WARNING, "MODEL: [%s] Joint attribute data format (u16) overflow", fileName); + boneIdOverflowWarning = @as(c_int, 1) != 0; + } + (blk: { + const tmp = b; + if (tmp >= 0) break :blk (blk_1: { + const tmp_2 = meshIndex; + if (tmp_2 >= 0) break :blk_1 model.meshes + @as(usize, @intCast(tmp_2)) else break :blk_1 model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.boneIds + @as(usize, @intCast(tmp)) else break :blk (blk_1: { + const tmp_2 = meshIndex; + if (tmp_2 >= 0) break :blk_1 model.meshes + @as(usize, @intCast(tmp_2)) else break :blk_1 model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.boneIds - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = @as(u8, @bitCast(@as(u8, @truncate((blk: { + const tmp = b; + if (tmp >= 0) break :blk temp + @as(usize, @intCast(tmp)) else break :blk temp - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*)))); + } + } + free(@as(?*anyopaque, @ptrCast(temp))); + } else { + TraceLog(LOG_WARNING, "MODEL: [%s] Joint attribute data format not supported", fileName); + } + } else { + TraceLog(LOG_WARNING, "MODEL: [%s] Joint attribute data format not supported", fileName); + } + } else if (mesh.*.primitives[p].attributes[j].type == @as(c_uint, @bitCast(cgltf_attribute_type_weights))) { + var attribute: [*c]cgltf_accessor = mesh.*.primitives[p].attributes[j].data; + _ = &attribute; + if (attribute.*.type == @as(c_uint, @bitCast(cgltf_type_vec4))) { + if (attribute.*.component_type == @as(c_uint, @bitCast(cgltf_component_type_r_8u))) { + (blk: { + const tmp = meshIndex; + if (tmp >= 0) break :blk model.meshes + @as(usize, @intCast(tmp)) else break :blk model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.boneWeights = @as([*c]f32, @ptrCast(@alignCast(calloc(@as(c_ulong, @bitCast(@as(c_long, (blk: { + const tmp = meshIndex; + if (tmp >= 0) break :blk model.meshes + @as(usize, @intCast(tmp)) else break :blk model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.vertexCount * @as(c_int, 4)))), @sizeOf(f32))))); + var temp: [*c]u8 = @as([*c]u8, @ptrCast(@alignCast(malloc((attribute.*.count *% @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 4))))) *% @sizeOf(u8))))); + _ = &temp; + { + var n: c_int = 0; + _ = &n; + var buffer: [*c]u8 = (@as([*c]u8, @ptrCast(@alignCast(attribute.*.buffer_view.*.buffer.*.data))) + (attribute.*.buffer_view.*.offset / @sizeOf(u8))) + (attribute.*.offset / @sizeOf(u8)); + _ = &buffer; + { + var k: c_uint = 0; + _ = &k; + while (@as(cgltf_size, @bitCast(@as(c_ulong, k))) < attribute.*.count) : (k +%= 1) { + { + var l: c_int = 0; + _ = &l; + while (l < @as(c_int, 4)) : (l += 1) { + temp[(@as(c_uint, @bitCast(@as(c_int, 4))) *% k) +% @as(c_uint, @bitCast(l))] = (blk: { + const tmp = n + l; + if (tmp >= 0) break :blk buffer + @as(usize, @intCast(tmp)) else break :blk buffer - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*; + } + } + n += @as(c_int, @bitCast(@as(c_uint, @truncate(attribute.*.stride / @sizeOf(u8))))); + } + } + } + { + var b: c_uint = 0; + _ = &b; + while (@as(cgltf_size, @bitCast(@as(c_ulong, b))) < (attribute.*.count *% @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 4)))))) : (b +%= 1) { + (blk: { + const tmp = meshIndex; + if (tmp >= 0) break :blk model.meshes + @as(usize, @intCast(tmp)) else break :blk model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.boneWeights[b] = @as(f32, @floatFromInt(temp[b])) / 255.0; + } + } + free(@as(?*anyopaque, @ptrCast(temp))); + } else if (attribute.*.component_type == @as(c_uint, @bitCast(cgltf_component_type_r_16u))) { + (blk: { + const tmp = meshIndex; + if (tmp >= 0) break :blk model.meshes + @as(usize, @intCast(tmp)) else break :blk model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.boneWeights = @as([*c]f32, @ptrCast(@alignCast(calloc(@as(c_ulong, @bitCast(@as(c_long, (blk: { + const tmp = meshIndex; + if (tmp >= 0) break :blk model.meshes + @as(usize, @intCast(tmp)) else break :blk model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.vertexCount * @as(c_int, 4)))), @sizeOf(f32))))); + var temp: [*c]c_ushort = @as([*c]c_ushort, @ptrCast(@alignCast(malloc((attribute.*.count *% @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 4))))) *% @sizeOf(c_ushort))))); + _ = &temp; + { + var n: c_int = 0; + _ = &n; + var buffer: [*c]c_ushort = (@as([*c]c_ushort, @ptrCast(@alignCast(attribute.*.buffer_view.*.buffer.*.data))) + (attribute.*.buffer_view.*.offset / @sizeOf(c_ushort))) + (attribute.*.offset / @sizeOf(c_ushort)); + _ = &buffer; + { + var k: c_uint = 0; + _ = &k; + while (@as(cgltf_size, @bitCast(@as(c_ulong, k))) < attribute.*.count) : (k +%= 1) { + { + var l: c_int = 0; + _ = &l; + while (l < @as(c_int, 4)) : (l += 1) { + temp[(@as(c_uint, @bitCast(@as(c_int, 4))) *% k) +% @as(c_uint, @bitCast(l))] = (blk: { + const tmp = n + l; + if (tmp >= 0) break :blk buffer + @as(usize, @intCast(tmp)) else break :blk buffer - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*; + } + } + n += @as(c_int, @bitCast(@as(c_uint, @truncate(attribute.*.stride / @sizeOf(c_ushort))))); + } + } + } + { + var b: c_uint = 0; + _ = &b; + while (@as(cgltf_size, @bitCast(@as(c_ulong, b))) < (attribute.*.count *% @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 4)))))) : (b +%= 1) { + (blk: { + const tmp = meshIndex; + if (tmp >= 0) break :blk model.meshes + @as(usize, @intCast(tmp)) else break :blk model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.boneWeights[b] = @as(f32, @floatFromInt(temp[b])) / 65535.0; + } + } + free(@as(?*anyopaque, @ptrCast(temp))); + } else if (attribute.*.component_type == @as(c_uint, @bitCast(cgltf_component_type_r_32f))) { + (blk: { + const tmp = meshIndex; + if (tmp >= 0) break :blk model.meshes + @as(usize, @intCast(tmp)) else break :blk model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.boneWeights = @as([*c]f32, @ptrCast(@alignCast(calloc(@as(c_ulong, @bitCast(@as(c_long, (blk: { + const tmp = meshIndex; + if (tmp >= 0) break :blk model.meshes + @as(usize, @intCast(tmp)) else break :blk model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.vertexCount * @as(c_int, 4)))), @sizeOf(f32))))); + { + var n: c_int = 0; + _ = &n; + var buffer: [*c]f32 = (@as([*c]f32, @ptrCast(@alignCast(attribute.*.buffer_view.*.buffer.*.data))) + (attribute.*.buffer_view.*.offset / @sizeOf(f32))) + (attribute.*.offset / @sizeOf(f32)); + _ = &buffer; + { + var k: c_uint = 0; + _ = &k; + while (@as(cgltf_size, @bitCast(@as(c_ulong, k))) < attribute.*.count) : (k +%= 1) { + { + var l: c_int = 0; + _ = &l; + while (l < @as(c_int, 4)) : (l += 1) { + (blk: { + const tmp = meshIndex; + if (tmp >= 0) break :blk model.meshes + @as(usize, @intCast(tmp)) else break :blk model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.boneWeights[(@as(c_uint, @bitCast(@as(c_int, 4))) *% k) +% @as(c_uint, @bitCast(l))] = (blk: { + const tmp = n + l; + if (tmp >= 0) break :blk buffer + @as(usize, @intCast(tmp)) else break :blk buffer - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*; + } + } + n += @as(c_int, @bitCast(@as(c_uint, @truncate(attribute.*.stride / @sizeOf(f32))))); + } + } + } + } else { + TraceLog(LOG_WARNING, "MODEL: [%s] Joint weight attribute data format not supported, use vec4 float", fileName); + } + } else { + TraceLog(LOG_WARNING, "MODEL: [%s] Joint weight attribute data format not supported, use vec4 float", fileName); + } + } + } + } + (blk: { + const tmp = meshIndex; + if (tmp >= 0) break :blk model.meshes + @as(usize, @intCast(tmp)) else break :blk model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.animVertices = @as([*c]f32, @ptrCast(@alignCast(calloc(@as(c_ulong, @bitCast(@as(c_long, (blk: { + const tmp = meshIndex; + if (tmp >= 0) break :blk model.meshes + @as(usize, @intCast(tmp)) else break :blk model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.vertexCount * @as(c_int, 3)))), @sizeOf(f32))))); + _ = memcpy(@as(?*anyopaque, @ptrCast((blk: { + const tmp = meshIndex; + if (tmp >= 0) break :blk model.meshes + @as(usize, @intCast(tmp)) else break :blk model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.animVertices)), @as(?*const anyopaque, @ptrCast((blk: { + const tmp = meshIndex; + if (tmp >= 0) break :blk model.meshes + @as(usize, @intCast(tmp)) else break :blk model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.vertices)), @as(c_ulong, @bitCast(@as(c_long, (blk: { + const tmp = meshIndex; + if (tmp >= 0) break :blk model.meshes + @as(usize, @intCast(tmp)) else break :blk model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.vertexCount * @as(c_int, 3)))) *% @sizeOf(f32)); + (blk: { + const tmp = meshIndex; + if (tmp >= 0) break :blk model.meshes + @as(usize, @intCast(tmp)) else break :blk model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.animNormals = @as([*c]f32, @ptrCast(@alignCast(calloc(@as(c_ulong, @bitCast(@as(c_long, (blk: { + const tmp = meshIndex; + if (tmp >= 0) break :blk model.meshes + @as(usize, @intCast(tmp)) else break :blk model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.vertexCount * @as(c_int, 3)))), @sizeOf(f32))))); + if ((blk: { + const tmp = meshIndex; + if (tmp >= 0) break :blk model.meshes + @as(usize, @intCast(tmp)) else break :blk model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.normals != @as([*c]f32, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0))))))) { + _ = memcpy(@as(?*anyopaque, @ptrCast((blk: { + const tmp = meshIndex; + if (tmp >= 0) break :blk model.meshes + @as(usize, @intCast(tmp)) else break :blk model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.animNormals)), @as(?*const anyopaque, @ptrCast((blk: { + const tmp = meshIndex; + if (tmp >= 0) break :blk model.meshes + @as(usize, @intCast(tmp)) else break :blk model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.normals)), @as(c_ulong, @bitCast(@as(c_long, (blk: { + const tmp = meshIndex; + if (tmp >= 0) break :blk model.meshes + @as(usize, @intCast(tmp)) else break :blk model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.vertexCount * @as(c_int, 3)))) *% @sizeOf(f32)); + } + meshIndex += 1; + } + } + } + } + cgltf_free(data); + } else { + TraceLog(LOG_WARNING, "MODEL: [%s] Failed to load glTF data", fileName); + } + UnloadFileData(fileData); + return model; +} +pub fn LoadModelAnimationsGLTF(arg_fileName: [*c]const u8, arg_animCount: [*c]c_int) callconv(.C) [*c]ModelAnimation { + var fileName = arg_fileName; + _ = &fileName; + var animCount = arg_animCount; + _ = &animCount; + var dataSize: c_int = 0; + _ = &dataSize; + var fileData: [*c]u8 = LoadFileData(fileName, &dataSize); + _ = &fileData; + var animations: [*c]ModelAnimation = null; + _ = &animations; + var options: cgltf_options = cgltf_options{ + .type = @as(c_uint, @bitCast(@as(c_int, 0))), + .json_token_count = @import("std").mem.zeroes(cgltf_size), + .memory = @import("std").mem.zeroes(cgltf_memory_options), + .file = @import("std").mem.zeroes(cgltf_file_options), + }; + _ = &options; + options.file.read = &LoadFileGLTFCallback; + options.file.release = &ReleaseFileGLTFCallback; + var data: [*c]cgltf_data = null; + _ = &data; + var result: cgltf_result = cgltf_parse(&options, @as(?*const anyopaque, @ptrCast(fileData)), @as(cgltf_size, @bitCast(@as(c_long, dataSize))), &data); + _ = &result; + if (result != @as(c_uint, @bitCast(cgltf_result_success))) { + TraceLog(LOG_WARNING, "MODEL: [%s] Failed to load glTF data", fileName); + animCount.* = 0; + return null; + } + result = cgltf_load_buffers(&options, data, fileName); + if (result != @as(c_uint, @bitCast(cgltf_result_success))) { + TraceLog(LOG_INFO, "MODEL: [%s] Failed to load animation buffers", fileName); + } + if (result == @as(c_uint, @bitCast(cgltf_result_success))) { + if (data.*.skins_count == @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 1))))) { + var skin: cgltf_skin = data.*.skins[@as(c_uint, @intCast(@as(c_int, 0)))]; + _ = &skin; + animCount.* = @as(c_int, @bitCast(@as(c_uint, @truncate(data.*.animations_count)))); + animations = @as([*c]ModelAnimation, @ptrCast(@alignCast(malloc(data.*.animations_count *% @sizeOf(ModelAnimation))))); + { + var i: c_uint = 0; + _ = &i; + while (@as(cgltf_size, @bitCast(@as(c_ulong, i))) < data.*.animations_count) : (i +%= 1) { + animations[i].bones = LoadBoneInfoGLTF(skin, &animations[i].boneCount); + var animData: cgltf_animation = data.*.animations[i]; + _ = &animData; + const struct_Channels = extern struct { + translate: [*c]cgltf_animation_channel = @import("std").mem.zeroes([*c]cgltf_animation_channel), + rotate: [*c]cgltf_animation_channel = @import("std").mem.zeroes([*c]cgltf_animation_channel), + scale: [*c]cgltf_animation_channel = @import("std").mem.zeroes([*c]cgltf_animation_channel), + interpolationType: cgltf_interpolation_type = @import("std").mem.zeroes(cgltf_interpolation_type), + }; + _ = &struct_Channels; + var boneChannels: [*c]struct_Channels = @as([*c]struct_Channels, @ptrCast(@alignCast(calloc(@as(c_ulong, @bitCast(@as(c_long, animations[i].boneCount))), @sizeOf(struct_Channels))))); + _ = &boneChannels; + var animDuration: f32 = 0.0; + _ = &animDuration; + { + var j: c_uint = 0; + _ = &j; + while (@as(cgltf_size, @bitCast(@as(c_ulong, j))) < animData.channels_count) : (j +%= 1) { + var channel: cgltf_animation_channel = animData.channels[j]; + _ = &channel; + var boneIndex: c_int = -@as(c_int, 1); + _ = &boneIndex; + { + var k: c_uint = 0; + _ = &k; + while (@as(cgltf_size, @bitCast(@as(c_ulong, k))) < skin.joints_count) : (k +%= 1) { + if (animData.channels[j].target_node == skin.joints[k]) { + boneIndex = @as(c_int, @bitCast(k)); + break; + } + } + } + if (boneIndex == -@as(c_int, 1)) { + continue; + } + (blk: { + const tmp = boneIndex; + if (tmp >= 0) break :blk boneChannels + @as(usize, @intCast(tmp)) else break :blk boneChannels - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.interpolationType = animData.channels[j].sampler.*.interpolation; + if (animData.channels[j].sampler.*.interpolation != @as(c_uint, @bitCast(cgltf_interpolation_type_max_enum))) { + if (channel.target_path == @as(c_uint, @bitCast(cgltf_animation_path_type_translation))) { + (blk: { + const tmp = boneIndex; + if (tmp >= 0) break :blk boneChannels + @as(usize, @intCast(tmp)) else break :blk boneChannels - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.translate = &animData.channels[j]; + } else if (channel.target_path == @as(c_uint, @bitCast(cgltf_animation_path_type_rotation))) { + (blk: { + const tmp = boneIndex; + if (tmp >= 0) break :blk boneChannels + @as(usize, @intCast(tmp)) else break :blk boneChannels - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.rotate = &animData.channels[j]; + } else if (channel.target_path == @as(c_uint, @bitCast(cgltf_animation_path_type_scale))) { + (blk: { + const tmp = boneIndex; + if (tmp >= 0) break :blk boneChannels + @as(usize, @intCast(tmp)) else break :blk boneChannels - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.scale = &animData.channels[j]; + } else { + TraceLog(LOG_WARNING, "MODEL: [%s] Unsupported target_path on channel %d's sampler for animation %d. Skipping.", fileName, j, i); + } + } else { + TraceLog(LOG_WARNING, "MODEL: [%s] Invalid interpolation curve encountered for GLTF animation.", fileName); + } + var t: f32 = 0.0; + _ = &t; + var r: cgltf_bool = cgltf_accessor_read_float(channel.sampler.*.input, channel.sampler.*.input.*.count -% @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 1)))), &t, @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 1))))); + _ = &r; + if (!(r != 0)) { + TraceLog(LOG_WARNING, "MODEL: [%s] Failed to load input time", fileName); + continue; + } + animDuration = if (t > animDuration) t else animDuration; + } + } + if (animData.name != @as([*c]u8, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0))))))) { + _ = strncpy(@as([*c]u8, @ptrCast(@alignCast(&animations[i].name))), animData.name, @sizeOf([32]u8)); + animations[i].name[@sizeOf([32]u8) -% @as(c_ulong, @bitCast(@as(c_long, @as(c_int, 1))))] = '\x00'; + } + animations[i].frameCount = @as(c_int, @intFromFloat((animDuration * 1000.0) / @as(f32, @floatFromInt(@as(c_int, 17))))) + @as(c_int, 1); + animations[i].framePoses = @as([*c][*c]Transform, @ptrCast(@alignCast(malloc(@as(c_ulong, @bitCast(@as(c_long, animations[i].frameCount))) *% @sizeOf([*c]Transform))))); + { + var j: c_int = 0; + _ = &j; + while (j < animations[i].frameCount) : (j += 1) { + (blk: { + const tmp = j; + if (tmp >= 0) break :blk animations[i].framePoses + @as(usize, @intCast(tmp)) else break :blk animations[i].framePoses - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = @as([*c]Transform, @ptrCast(@alignCast(malloc(@as(c_ulong, @bitCast(@as(c_long, animations[i].boneCount))) *% @sizeOf(Transform))))); + var time: f32 = (@as(f32, @floatFromInt(j)) * @as(f32, @floatFromInt(@as(c_int, 17)))) / 1000.0; + _ = &time; + { + var k: c_int = 0; + _ = &k; + while (k < animations[i].boneCount) : (k += 1) { + var translation: Vector3 = Vector3{ + .x = (blk: { + const tmp = k; + if (tmp >= 0) break :blk skin.joints + @as(usize, @intCast(tmp)) else break :blk skin.joints - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.*.translation[@as(c_uint, @intCast(@as(c_int, 0)))], + .y = (blk: { + const tmp = k; + if (tmp >= 0) break :blk skin.joints + @as(usize, @intCast(tmp)) else break :blk skin.joints - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.*.translation[@as(c_uint, @intCast(@as(c_int, 1)))], + .z = (blk: { + const tmp = k; + if (tmp >= 0) break :blk skin.joints + @as(usize, @intCast(tmp)) else break :blk skin.joints - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.*.translation[@as(c_uint, @intCast(@as(c_int, 2)))], + }; + _ = &translation; + var rotation: Quaternion = Quaternion{ + .x = (blk: { + const tmp = k; + if (tmp >= 0) break :blk skin.joints + @as(usize, @intCast(tmp)) else break :blk skin.joints - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.*.rotation[@as(c_uint, @intCast(@as(c_int, 0)))], + .y = (blk: { + const tmp = k; + if (tmp >= 0) break :blk skin.joints + @as(usize, @intCast(tmp)) else break :blk skin.joints - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.*.rotation[@as(c_uint, @intCast(@as(c_int, 1)))], + .z = (blk: { + const tmp = k; + if (tmp >= 0) break :blk skin.joints + @as(usize, @intCast(tmp)) else break :blk skin.joints - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.*.rotation[@as(c_uint, @intCast(@as(c_int, 2)))], + .w = (blk: { + const tmp = k; + if (tmp >= 0) break :blk skin.joints + @as(usize, @intCast(tmp)) else break :blk skin.joints - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.*.rotation[@as(c_uint, @intCast(@as(c_int, 3)))], + }; + _ = &rotation; + var scale: Vector3 = Vector3{ + .x = (blk: { + const tmp = k; + if (tmp >= 0) break :blk skin.joints + @as(usize, @intCast(tmp)) else break :blk skin.joints - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.*.scale[@as(c_uint, @intCast(@as(c_int, 0)))], + .y = (blk: { + const tmp = k; + if (tmp >= 0) break :blk skin.joints + @as(usize, @intCast(tmp)) else break :blk skin.joints - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.*.scale[@as(c_uint, @intCast(@as(c_int, 1)))], + .z = (blk: { + const tmp = k; + if (tmp >= 0) break :blk skin.joints + @as(usize, @intCast(tmp)) else break :blk skin.joints - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.*.scale[@as(c_uint, @intCast(@as(c_int, 2)))], + }; + _ = &scale; + if ((blk: { + const tmp = k; + if (tmp >= 0) break :blk boneChannels + @as(usize, @intCast(tmp)) else break :blk boneChannels - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.translate != null) { + if (!GetPoseAtTimeGLTF((blk: { + const tmp = k; + if (tmp >= 0) break :blk boneChannels + @as(usize, @intCast(tmp)) else break :blk boneChannels - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.interpolationType, (blk: { + const tmp = k; + if (tmp >= 0) break :blk boneChannels + @as(usize, @intCast(tmp)) else break :blk boneChannels - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.translate.*.sampler.*.input, (blk: { + const tmp = k; + if (tmp >= 0) break :blk boneChannels + @as(usize, @intCast(tmp)) else break :blk boneChannels - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.translate.*.sampler.*.output, time, @as(?*anyopaque, @ptrCast(&translation)))) { + TraceLog(LOG_INFO, "MODEL: [%s] Failed to load translate pose data for bone %s", fileName, @as([*c]u8, @ptrCast(@alignCast(&(blk: { + const tmp = k; + if (tmp >= 0) break :blk animations[i].bones + @as(usize, @intCast(tmp)) else break :blk animations[i].bones - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.name)))); + } + } + if ((blk: { + const tmp = k; + if (tmp >= 0) break :blk boneChannels + @as(usize, @intCast(tmp)) else break :blk boneChannels - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.rotate != null) { + if (!GetPoseAtTimeGLTF((blk: { + const tmp = k; + if (tmp >= 0) break :blk boneChannels + @as(usize, @intCast(tmp)) else break :blk boneChannels - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.interpolationType, (blk: { + const tmp = k; + if (tmp >= 0) break :blk boneChannels + @as(usize, @intCast(tmp)) else break :blk boneChannels - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.rotate.*.sampler.*.input, (blk: { + const tmp = k; + if (tmp >= 0) break :blk boneChannels + @as(usize, @intCast(tmp)) else break :blk boneChannels - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.rotate.*.sampler.*.output, time, @as(?*anyopaque, @ptrCast(&rotation)))) { + TraceLog(LOG_INFO, "MODEL: [%s] Failed to load rotate pose data for bone %s", fileName, @as([*c]u8, @ptrCast(@alignCast(&(blk: { + const tmp = k; + if (tmp >= 0) break :blk animations[i].bones + @as(usize, @intCast(tmp)) else break :blk animations[i].bones - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.name)))); + } + } + if ((blk: { + const tmp = k; + if (tmp >= 0) break :blk boneChannels + @as(usize, @intCast(tmp)) else break :blk boneChannels - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.scale != null) { + if (!GetPoseAtTimeGLTF((blk: { + const tmp = k; + if (tmp >= 0) break :blk boneChannels + @as(usize, @intCast(tmp)) else break :blk boneChannels - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.interpolationType, (blk: { + const tmp = k; + if (tmp >= 0) break :blk boneChannels + @as(usize, @intCast(tmp)) else break :blk boneChannels - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.scale.*.sampler.*.input, (blk: { + const tmp = k; + if (tmp >= 0) break :blk boneChannels + @as(usize, @intCast(tmp)) else break :blk boneChannels - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.scale.*.sampler.*.output, time, @as(?*anyopaque, @ptrCast(&scale)))) { + TraceLog(LOG_INFO, "MODEL: [%s] Failed to load scale pose data for bone %s", fileName, @as([*c]u8, @ptrCast(@alignCast(&(blk: { + const tmp = k; + if (tmp >= 0) break :blk animations[i].bones + @as(usize, @intCast(tmp)) else break :blk animations[i].bones - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.name)))); + } + } + (blk: { + const tmp = k; + if (tmp >= 0) break :blk (blk_1: { + const tmp_2 = j; + if (tmp_2 >= 0) break :blk_1 animations[i].framePoses + @as(usize, @intCast(tmp_2)) else break :blk_1 animations[i].framePoses - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).* + @as(usize, @intCast(tmp)) else break :blk (blk_1: { + const tmp_2 = j; + if (tmp_2 >= 0) break :blk_1 animations[i].framePoses + @as(usize, @intCast(tmp_2)) else break :blk_1 animations[i].framePoses - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).* - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = Transform{ + .translation = translation, + .rotation = rotation, + .scale = scale, + }; + } + } + BuildPoseFromParentJoints(animations[i].bones, animations[i].boneCount, (blk: { + const tmp = j; + if (tmp >= 0) break :blk animations[i].framePoses + @as(usize, @intCast(tmp)) else break :blk animations[i].framePoses - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*); + } + } + TraceLog(LOG_INFO, "MODEL: [%s] Loaded animation: %s (%d frames, %fs)", fileName, if (animData.name != @as([*c]u8, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0))))))) animData.name else "NULL", animations[i].frameCount, @as(f64, @floatCast(animDuration))); + free(@as(?*anyopaque, @ptrCast(boneChannels))); + } + } + } else { + TraceLog(LOG_ERROR, "MODEL: [%s] expected exactly one skin to load animation data from, but found %i", fileName, data.*.skins_count); + } + cgltf_free(data); + } + UnloadFileData(fileData); + return animations; +} +pub fn LoadVOX(arg_fileName: [*c]const u8) callconv(.C) Model { + var fileName = arg_fileName; + _ = &fileName; + var model: Model = Model{ + .transform = Matrix{ + .m0 = @as(f32, @floatFromInt(@as(c_int, 0))), + .m4 = 0, + .m8 = 0, + .m12 = 0, + .m1 = 0, + .m5 = 0, + .m9 = 0, + .m13 = 0, + .m2 = 0, + .m6 = 0, + .m10 = 0, + .m14 = 0, + .m3 = 0, + .m7 = 0, + .m11 = 0, + .m15 = 0, + }, + .meshCount = 0, + .materialCount = 0, + .meshes = null, + .materials = null, + .meshMaterial = null, + .boneCount = 0, + .bones = null, + .bindPose = null, + }; + _ = &model; + var nbvertices: c_int = 0; + _ = &nbvertices; + var meshescount: c_int = 0; + _ = &meshescount; + var dataSize: c_int = 0; + _ = &dataSize; + var fileData: [*c]u8 = LoadFileData(fileName, &dataSize); + _ = &fileData; + if (fileData == null) { + TraceLog(LOG_WARNING, "MODEL: [%s] Failed to load VOX file", fileName); + return model; + } + var voxarray: VoxArray3D = VoxArray3D{ + .sizeX = @as(c_int, 0), + .sizeY = 0, + .sizeZ = 0, + .chunksSizeX = 0, + .chunksSizeY = 0, + .chunksSizeZ = 0, + .m_arrayChunks = null, + .arrayChunksSize = 0, + .ChunkFlattenOffset = 0, + .chunksAllocated = 0, + .chunksTotal = 0, + .vertices = @import("std").mem.zeroes(ArrayVector3), + .normals = @import("std").mem.zeroes(ArrayVector3), + .indices = @import("std").mem.zeroes(ArrayUShort), + .colors = @import("std").mem.zeroes(ArrayColor), + .palette = @import("std").mem.zeroes([256]VoxColor), + }; + _ = &voxarray; + var ret: c_int = Vox_LoadFromMemory(fileData, @as(c_uint, @bitCast(dataSize)), &voxarray); + _ = &ret; + if (ret != @as(c_int, 0)) { + UnloadFileData(fileData); + TraceLog(LOG_WARNING, "MODEL: [%s] Failed to load VOX data", fileName); + return model; + } else { + nbvertices = voxarray.vertices.used; + meshescount = @as(c_int, 1) + @divTrunc(nbvertices, @as(c_int, 65536)); + TraceLog(LOG_INFO, "MODEL: [%s] VOX data loaded successfully : %i vertices/%i meshes", fileName, nbvertices, meshescount); + } + model.transform = MatrixIdentity(); + model.meshCount = meshescount; + model.meshes = @as([*c]Mesh, @ptrCast(@alignCast(calloc(@as(c_ulong, @bitCast(@as(c_long, model.meshCount))), @sizeOf(Mesh))))); + model.meshMaterial = @as([*c]c_int, @ptrCast(@alignCast(calloc(@as(c_ulong, @bitCast(@as(c_long, model.meshCount))), @sizeOf(c_int))))); + model.materialCount = 1; + model.materials = @as([*c]Material, @ptrCast(@alignCast(calloc(@as(c_ulong, @bitCast(@as(c_long, model.materialCount))), @sizeOf(Material))))); + model.materials[@as(c_uint, @intCast(@as(c_int, 0)))] = LoadMaterialDefault(); + var verticesRemain: c_int = voxarray.vertices.used; + _ = &verticesRemain; + var verticesMax: c_int = 65532; + _ = &verticesMax; + var pvertices: [*c]Vector3 = @as([*c]Vector3, @ptrCast(@alignCast(voxarray.vertices.array))); + _ = &pvertices; + var pnormals: [*c]Vector3 = @as([*c]Vector3, @ptrCast(@alignCast(voxarray.normals.array))); + _ = &pnormals; + var pcolors: [*c]Color = @as([*c]Color, @ptrCast(@alignCast(voxarray.colors.array))); + _ = &pcolors; + var pindices: [*c]c_ushort = voxarray.indices.array; + _ = &pindices; + var size: c_int = 0; + _ = &size; + { + var i: c_int = 0; + _ = &i; + while (i < meshescount) : (i += 1) { + var pmesh: [*c]Mesh = &(blk: { + const tmp = i; + if (tmp >= 0) break :blk model.meshes + @as(usize, @intCast(tmp)) else break :blk model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*; + _ = &pmesh; + _ = memset(@as(?*anyopaque, @ptrCast(pmesh)), @as(c_int, 0), @sizeOf(Mesh)); + pmesh.*.vertexCount = @as(c_int, @intFromFloat(fmin(@as(f64, @floatFromInt(verticesMax)), @as(f64, @floatFromInt(verticesRemain))))); + size = @as(c_int, @bitCast(@as(c_uint, @truncate((@as(c_ulong, @bitCast(@as(c_long, pmesh.*.vertexCount))) *% @sizeOf(f32)) *% @as(c_ulong, @bitCast(@as(c_long, @as(c_int, 3)))))))); + pmesh.*.vertices = @as([*c]f32, @ptrCast(@alignCast(malloc(@as(c_ulong, @bitCast(@as(c_long, size))))))); + _ = memcpy(@as(?*anyopaque, @ptrCast(pmesh.*.vertices)), @as(?*const anyopaque, @ptrCast(pvertices)), @as(c_ulong, @bitCast(@as(c_long, size)))); + pmesh.*.normals = @as([*c]f32, @ptrCast(@alignCast(malloc(@as(c_ulong, @bitCast(@as(c_long, size))))))); + _ = memcpy(@as(?*anyopaque, @ptrCast(pmesh.*.normals)), @as(?*const anyopaque, @ptrCast(pnormals)), @as(c_ulong, @bitCast(@as(c_long, size)))); + size = @as(c_int, @bitCast(@as(c_uint, @truncate(@as(c_ulong, @bitCast(@as(c_long, voxarray.indices.used))) *% @sizeOf(c_ushort))))); + pmesh.*.indices = @as([*c]c_ushort, @ptrCast(@alignCast(malloc(@as(c_ulong, @bitCast(@as(c_long, size))))))); + _ = memcpy(@as(?*anyopaque, @ptrCast(pmesh.*.indices)), @as(?*const anyopaque, @ptrCast(pindices)), @as(c_ulong, @bitCast(@as(c_long, size)))); + pmesh.*.triangleCount = @divTrunc(pmesh.*.vertexCount, @as(c_int, 4)) * @as(c_int, 2); + size = @as(c_int, @bitCast(@as(c_uint, @truncate(@as(c_ulong, @bitCast(@as(c_long, pmesh.*.vertexCount))) *% @sizeOf(Color))))); + pmesh.*.colors = @as([*c]u8, @ptrCast(@alignCast(malloc(@as(c_ulong, @bitCast(@as(c_long, size))))))); + _ = memcpy(@as(?*anyopaque, @ptrCast(pmesh.*.colors)), @as(?*const anyopaque, @ptrCast(pcolors)), @as(c_ulong, @bitCast(@as(c_long, size)))); + (blk: { + const tmp = i; + if (tmp >= 0) break :blk model.meshMaterial + @as(usize, @intCast(tmp)) else break :blk model.meshMaterial - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = 0; + verticesRemain -= verticesMax; + pvertices += @as(usize, @bitCast(@as(isize, @intCast(verticesMax)))); + pnormals += @as(usize, @bitCast(@as(isize, @intCast(verticesMax)))); + pcolors += @as(usize, @bitCast(@as(isize, @intCast(verticesMax)))); + } + } + Vox_FreeArrays(&voxarray); + UnloadFileData(fileData); + return model; +} +pub fn LoadM3D(arg_fileName: [*c]const u8) callconv(.C) Model { + var fileName = arg_fileName; + _ = &fileName; + var model: Model = Model{ + .transform = Matrix{ + .m0 = @as(f32, @floatFromInt(@as(c_int, 0))), + .m4 = 0, + .m8 = 0, + .m12 = 0, + .m1 = 0, + .m5 = 0, + .m9 = 0, + .m13 = 0, + .m2 = 0, + .m6 = 0, + .m10 = 0, + .m14 = 0, + .m3 = 0, + .m7 = 0, + .m11 = 0, + .m15 = 0, + }, + .meshCount = 0, + .materialCount = 0, + .meshes = null, + .materials = null, + .meshMaterial = null, + .boneCount = 0, + .bones = null, + .bindPose = null, + }; + _ = &model; + var m3d: [*c]m3d_t = null; + _ = &m3d; + var prop: [*c]m3dp_t = null; + _ = ∝ + var i: c_int = undefined; + _ = &i; + var j: c_int = undefined; + _ = &j; + var k: c_int = undefined; + _ = &k; + var l: c_int = undefined; + _ = &l; + var n: c_int = undefined; + _ = &n; + var mi: c_int = -@as(c_int, 2); + _ = &mi; + var vcolor: c_int = 0; + _ = &vcolor; + var dataSize: c_int = 0; + _ = &dataSize; + var fileData: [*c]u8 = LoadFileData(fileName, &dataSize); + _ = &fileData; + if (fileData != @as([*c]u8, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0))))))) { + m3d = m3d_load(fileData, &m3d_loaderhook, &m3d_freehook, null); + if (!(m3d != null) or ((@as(c_int, @bitCast(@as(c_int, m3d.*.errcode))) < @as(c_int, 0)) and (@as(c_int, @bitCast(@as(c_int, m3d.*.errcode))) > -@as(c_int, 65)))) { + TraceLog(LOG_WARNING, "MODEL: [%s] Failed to load M3D data, error code %d", fileName, if (m3d != null) @as(c_int, @bitCast(@as(c_int, m3d.*.errcode))) else -@as(c_int, 2)); + if (m3d != null) { + m3d_free(m3d); + } + UnloadFileData(fileData); + return model; + } else { + TraceLog(LOG_INFO, "MODEL: [%s] M3D data loaded successfully: %i faces/%i materials", fileName, m3d.*.numface, m3d.*.nummaterial); + } + if (!(m3d.*.numface != 0)) { + m3d_free(m3d); + UnloadFileData(fileData); + return model; + } + if (m3d.*.nummaterial > @as(M3D_INDEX, @bitCast(@as(c_int, 0)))) { + model.meshCount = blk: { + const tmp = @as(c_int, @bitCast(m3d.*.nummaterial)); + model.materialCount = tmp; + break :blk tmp; + }; + TraceLog(LOG_INFO, "MODEL: model has %i material meshes", model.materialCount); + } else { + model.meshCount = 1; + model.materialCount = 0; + TraceLog(LOG_INFO, "MODEL: No materials, putting all meshes in a default material"); + } + model.materialCount += 1; + model.meshes = @as([*c]Mesh, @ptrCast(@alignCast(calloc(@as(c_ulong, @bitCast(@as(c_long, model.meshCount))), @sizeOf(Mesh))))); + model.meshMaterial = @as([*c]c_int, @ptrCast(@alignCast(calloc(@as(c_ulong, @bitCast(@as(c_long, model.meshCount))), @sizeOf(c_int))))); + model.materials = @as([*c]Material, @ptrCast(@alignCast(calloc(@as(c_ulong, @bitCast(@as(c_long, model.materialCount + @as(c_int, 1)))), @sizeOf(Material))))); + model.materials[@as(c_uint, @intCast(@as(c_int, 0)))] = LoadMaterialDefault(); + { + _ = blk: { + i = blk_1: { + const tmp = @as(c_int, 0); + l = tmp; + break :blk_1 tmp; + }; + break :blk blk_1: { + const tmp = -@as(c_int, 1); + k = tmp; + break :blk_1 tmp; + }; + }; + while (i < @as(c_int, @bitCast(m3d.*.numface))) : (_ = blk: { + i += 1; + break :blk blk_1: { + const ref = &l; + const tmp = ref.*; + ref.* += 1; + break :blk_1 tmp; + }; + }) { + if (@as(M3D_INDEX, @bitCast(mi)) != (blk: { + const tmp = i; + if (tmp >= 0) break :blk m3d.*.face + @as(usize, @intCast(tmp)) else break :blk m3d.*.face - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.materialid) { + if ((k + @as(c_int, 1)) >= model.meshCount) { + model.meshCount += 1; + model.meshes = @as([*c]Mesh, @ptrCast(@alignCast(realloc(@as(?*anyopaque, @ptrCast(model.meshes)), @as(c_ulong, @bitCast(@as(c_long, model.meshCount))) *% @sizeOf(Mesh))))); + _ = memset(@as(?*anyopaque, @ptrCast(&(blk: { + const tmp = model.meshCount - @as(c_int, 1); + if (tmp >= 0) break :blk model.meshes + @as(usize, @intCast(tmp)) else break :blk model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*)), @as(c_int, 0), @sizeOf(Mesh)); + model.meshMaterial = @as([*c]c_int, @ptrCast(@alignCast(realloc(@as(?*anyopaque, @ptrCast(model.meshMaterial)), @as(c_ulong, @bitCast(@as(c_long, model.meshCount))) *% @sizeOf(c_int))))); + } + k += 1; + mi = @as(c_int, @bitCast((blk: { + const tmp = i; + if (tmp >= 0) break :blk m3d.*.face + @as(usize, @intCast(tmp)) else break :blk m3d.*.face - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.materialid)); + { + _ = blk: { + j = i; + break :blk blk_1: { + const tmp = blk_2: { + const tmp_3 = @as(c_int, 0); + vcolor = tmp_3; + break :blk_2 tmp_3; + }; + l = tmp; + break :blk_1 tmp; + }; + }; + while ((j < @as(c_int, @bitCast(m3d.*.numface))) and (@as(M3D_INDEX, @bitCast(mi)) == (blk: { + const tmp = j; + if (tmp >= 0) break :blk m3d.*.face + @as(usize, @intCast(tmp)) else break :blk m3d.*.face - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.materialid)) : (_ = blk: { + j += 1; + break :blk blk_1: { + const ref = &l; + const tmp = ref.*; + ref.* += 1; + break :blk_1 tmp; + }; + }) { + if ((!(m3d.*.vertex[(blk: { + const tmp = j; + if (tmp >= 0) break :blk m3d.*.face + @as(usize, @intCast(tmp)) else break :blk m3d.*.face - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.vertex[@as(c_uint, @intCast(@as(c_int, 0)))]].color != 0) or !(m3d.*.vertex[(blk: { + const tmp = j; + if (tmp >= 0) break :blk m3d.*.face + @as(usize, @intCast(tmp)) else break :blk m3d.*.face - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.vertex[@as(c_uint, @intCast(@as(c_int, 1)))]].color != 0)) or !(m3d.*.vertex[(blk: { + const tmp = j; + if (tmp >= 0) break :blk m3d.*.face + @as(usize, @intCast(tmp)) else break :blk m3d.*.face - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.vertex[@as(c_uint, @intCast(@as(c_int, 2)))]].color != 0)) + { + vcolor = 1; + } + } + } + (blk: { + const tmp = k; + if (tmp >= 0) break :blk model.meshes + @as(usize, @intCast(tmp)) else break :blk model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.vertexCount = l * @as(c_int, 3); + (blk: { + const tmp = k; + if (tmp >= 0) break :blk model.meshes + @as(usize, @intCast(tmp)) else break :blk model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.triangleCount = l; + (blk: { + const tmp = k; + if (tmp >= 0) break :blk model.meshes + @as(usize, @intCast(tmp)) else break :blk model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.vertices = @as([*c]f32, @ptrCast(@alignCast(calloc(@as(c_ulong, @bitCast(@as(c_long, (blk: { + const tmp = k; + if (tmp >= 0) break :blk model.meshes + @as(usize, @intCast(tmp)) else break :blk model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.vertexCount * @as(c_int, 3)))), @sizeOf(f32))))); + (blk: { + const tmp = k; + if (tmp >= 0) break :blk model.meshes + @as(usize, @intCast(tmp)) else break :blk model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.texcoords = @as([*c]f32, @ptrCast(@alignCast(calloc(@as(c_ulong, @bitCast(@as(c_long, (blk: { + const tmp = k; + if (tmp >= 0) break :blk model.meshes + @as(usize, @intCast(tmp)) else break :blk model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.vertexCount * @as(c_int, 2)))), @sizeOf(f32))))); + (blk: { + const tmp = k; + if (tmp >= 0) break :blk model.meshes + @as(usize, @intCast(tmp)) else break :blk model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.normals = @as([*c]f32, @ptrCast(@alignCast(calloc(@as(c_ulong, @bitCast(@as(c_long, (blk: { + const tmp = k; + if (tmp >= 0) break :blk model.meshes + @as(usize, @intCast(tmp)) else break :blk model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.vertexCount * @as(c_int, 3)))), @sizeOf(f32))))); + if ((@as(c_uint, @bitCast(mi)) == @as(c_uint, 4294967295)) or (vcolor != 0)) { + (blk: { + const tmp = k; + if (tmp >= 0) break :blk model.meshes + @as(usize, @intCast(tmp)) else break :blk model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.colors = @as([*c]u8, @ptrCast(@alignCast(calloc(@as(c_ulong, @bitCast(@as(c_long, (blk: { + const tmp = k; + if (tmp >= 0) break :blk model.meshes + @as(usize, @intCast(tmp)) else break :blk model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.vertexCount * @as(c_int, 4)))), @sizeOf(u8))))); + } + if ((@as(c_uint, @bitCast(mi)) == @as(c_uint, 4294967295)) and ((blk: { + const tmp = k; + if (tmp >= 0) break :blk model.meshes + @as(usize, @intCast(tmp)) else break :blk model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.colors != @as([*c]u8, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0)))))))) { + { + var c: c_int = 0; + _ = &c; + while (c < ((blk: { + const tmp = k; + if (tmp >= 0) break :blk model.meshes + @as(usize, @intCast(tmp)) else break :blk model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.vertexCount * @as(c_int, 4))) : (c += 1) { + (blk: { + const tmp = c; + if (tmp >= 0) break :blk (blk_1: { + const tmp_2 = k; + if (tmp_2 >= 0) break :blk_1 model.meshes + @as(usize, @intCast(tmp_2)) else break :blk_1 model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.colors + @as(usize, @intCast(tmp)) else break :blk (blk_1: { + const tmp_2 = k; + if (tmp_2 >= 0) break :blk_1 model.meshes + @as(usize, @intCast(tmp_2)) else break :blk_1 model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.colors - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = 255; + } + } + } + if ((m3d.*.numbone != 0) and (m3d.*.numskin != 0)) { + (blk: { + const tmp = k; + if (tmp >= 0) break :blk model.meshes + @as(usize, @intCast(tmp)) else break :blk model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.boneIds = @as([*c]u8, @ptrCast(@alignCast(calloc(@as(c_ulong, @bitCast(@as(c_long, (blk: { + const tmp = k; + if (tmp >= 0) break :blk model.meshes + @as(usize, @intCast(tmp)) else break :blk model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.vertexCount * @as(c_int, 4)))), @sizeOf(u8))))); + (blk: { + const tmp = k; + if (tmp >= 0) break :blk model.meshes + @as(usize, @intCast(tmp)) else break :blk model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.boneWeights = @as([*c]f32, @ptrCast(@alignCast(calloc(@as(c_ulong, @bitCast(@as(c_long, (blk: { + const tmp = k; + if (tmp >= 0) break :blk model.meshes + @as(usize, @intCast(tmp)) else break :blk model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.vertexCount * @as(c_int, 4)))), @sizeOf(f32))))); + (blk: { + const tmp = k; + if (tmp >= 0) break :blk model.meshes + @as(usize, @intCast(tmp)) else break :blk model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.animVertices = @as([*c]f32, @ptrCast(@alignCast(calloc(@as(c_ulong, @bitCast(@as(c_long, (blk: { + const tmp = k; + if (tmp >= 0) break :blk model.meshes + @as(usize, @intCast(tmp)) else break :blk model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.vertexCount * @as(c_int, 3)))), @sizeOf(f32))))); + (blk: { + const tmp = k; + if (tmp >= 0) break :blk model.meshes + @as(usize, @intCast(tmp)) else break :blk model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.animNormals = @as([*c]f32, @ptrCast(@alignCast(calloc(@as(c_ulong, @bitCast(@as(c_long, (blk: { + const tmp = k; + if (tmp >= 0) break :blk model.meshes + @as(usize, @intCast(tmp)) else break :blk model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.vertexCount * @as(c_int, 3)))), @sizeOf(f32))))); + } + (blk: { + const tmp = k; + if (tmp >= 0) break :blk model.meshMaterial + @as(usize, @intCast(tmp)) else break :blk model.meshMaterial - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = mi + @as(c_int, 1); + l = 0; + } + (blk: { + const tmp = (l * @as(c_int, 9)) + @as(c_int, 0); + if (tmp >= 0) break :blk (blk_1: { + const tmp_2 = k; + if (tmp_2 >= 0) break :blk_1 model.meshes + @as(usize, @intCast(tmp_2)) else break :blk_1 model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.vertices + @as(usize, @intCast(tmp)) else break :blk (blk_1: { + const tmp_2 = k; + if (tmp_2 >= 0) break :blk_1 model.meshes + @as(usize, @intCast(tmp_2)) else break :blk_1 model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.vertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = m3d.*.vertex[(blk: { + const tmp = i; + if (tmp >= 0) break :blk m3d.*.face + @as(usize, @intCast(tmp)) else break :blk m3d.*.face - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.vertex[@as(c_uint, @intCast(@as(c_int, 0)))]].x * m3d.*.scale; + (blk: { + const tmp = (l * @as(c_int, 9)) + @as(c_int, 1); + if (tmp >= 0) break :blk (blk_1: { + const tmp_2 = k; + if (tmp_2 >= 0) break :blk_1 model.meshes + @as(usize, @intCast(tmp_2)) else break :blk_1 model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.vertices + @as(usize, @intCast(tmp)) else break :blk (blk_1: { + const tmp_2 = k; + if (tmp_2 >= 0) break :blk_1 model.meshes + @as(usize, @intCast(tmp_2)) else break :blk_1 model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.vertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = m3d.*.vertex[(blk: { + const tmp = i; + if (tmp >= 0) break :blk m3d.*.face + @as(usize, @intCast(tmp)) else break :blk m3d.*.face - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.vertex[@as(c_uint, @intCast(@as(c_int, 0)))]].y * m3d.*.scale; + (blk: { + const tmp = (l * @as(c_int, 9)) + @as(c_int, 2); + if (tmp >= 0) break :blk (blk_1: { + const tmp_2 = k; + if (tmp_2 >= 0) break :blk_1 model.meshes + @as(usize, @intCast(tmp_2)) else break :blk_1 model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.vertices + @as(usize, @intCast(tmp)) else break :blk (blk_1: { + const tmp_2 = k; + if (tmp_2 >= 0) break :blk_1 model.meshes + @as(usize, @intCast(tmp_2)) else break :blk_1 model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.vertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = m3d.*.vertex[(blk: { + const tmp = i; + if (tmp >= 0) break :blk m3d.*.face + @as(usize, @intCast(tmp)) else break :blk m3d.*.face - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.vertex[@as(c_uint, @intCast(@as(c_int, 0)))]].z * m3d.*.scale; + (blk: { + const tmp = (l * @as(c_int, 9)) + @as(c_int, 3); + if (tmp >= 0) break :blk (blk_1: { + const tmp_2 = k; + if (tmp_2 >= 0) break :blk_1 model.meshes + @as(usize, @intCast(tmp_2)) else break :blk_1 model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.vertices + @as(usize, @intCast(tmp)) else break :blk (blk_1: { + const tmp_2 = k; + if (tmp_2 >= 0) break :blk_1 model.meshes + @as(usize, @intCast(tmp_2)) else break :blk_1 model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.vertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = m3d.*.vertex[(blk: { + const tmp = i; + if (tmp >= 0) break :blk m3d.*.face + @as(usize, @intCast(tmp)) else break :blk m3d.*.face - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.vertex[@as(c_uint, @intCast(@as(c_int, 1)))]].x * m3d.*.scale; + (blk: { + const tmp = (l * @as(c_int, 9)) + @as(c_int, 4); + if (tmp >= 0) break :blk (blk_1: { + const tmp_2 = k; + if (tmp_2 >= 0) break :blk_1 model.meshes + @as(usize, @intCast(tmp_2)) else break :blk_1 model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.vertices + @as(usize, @intCast(tmp)) else break :blk (blk_1: { + const tmp_2 = k; + if (tmp_2 >= 0) break :blk_1 model.meshes + @as(usize, @intCast(tmp_2)) else break :blk_1 model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.vertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = m3d.*.vertex[(blk: { + const tmp = i; + if (tmp >= 0) break :blk m3d.*.face + @as(usize, @intCast(tmp)) else break :blk m3d.*.face - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.vertex[@as(c_uint, @intCast(@as(c_int, 1)))]].y * m3d.*.scale; + (blk: { + const tmp = (l * @as(c_int, 9)) + @as(c_int, 5); + if (tmp >= 0) break :blk (blk_1: { + const tmp_2 = k; + if (tmp_2 >= 0) break :blk_1 model.meshes + @as(usize, @intCast(tmp_2)) else break :blk_1 model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.vertices + @as(usize, @intCast(tmp)) else break :blk (blk_1: { + const tmp_2 = k; + if (tmp_2 >= 0) break :blk_1 model.meshes + @as(usize, @intCast(tmp_2)) else break :blk_1 model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.vertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = m3d.*.vertex[(blk: { + const tmp = i; + if (tmp >= 0) break :blk m3d.*.face + @as(usize, @intCast(tmp)) else break :blk m3d.*.face - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.vertex[@as(c_uint, @intCast(@as(c_int, 1)))]].z * m3d.*.scale; + (blk: { + const tmp = (l * @as(c_int, 9)) + @as(c_int, 6); + if (tmp >= 0) break :blk (blk_1: { + const tmp_2 = k; + if (tmp_2 >= 0) break :blk_1 model.meshes + @as(usize, @intCast(tmp_2)) else break :blk_1 model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.vertices + @as(usize, @intCast(tmp)) else break :blk (blk_1: { + const tmp_2 = k; + if (tmp_2 >= 0) break :blk_1 model.meshes + @as(usize, @intCast(tmp_2)) else break :blk_1 model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.vertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = m3d.*.vertex[(blk: { + const tmp = i; + if (tmp >= 0) break :blk m3d.*.face + @as(usize, @intCast(tmp)) else break :blk m3d.*.face - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.vertex[@as(c_uint, @intCast(@as(c_int, 2)))]].x * m3d.*.scale; + (blk: { + const tmp = (l * @as(c_int, 9)) + @as(c_int, 7); + if (tmp >= 0) break :blk (blk_1: { + const tmp_2 = k; + if (tmp_2 >= 0) break :blk_1 model.meshes + @as(usize, @intCast(tmp_2)) else break :blk_1 model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.vertices + @as(usize, @intCast(tmp)) else break :blk (blk_1: { + const tmp_2 = k; + if (tmp_2 >= 0) break :blk_1 model.meshes + @as(usize, @intCast(tmp_2)) else break :blk_1 model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.vertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = m3d.*.vertex[(blk: { + const tmp = i; + if (tmp >= 0) break :blk m3d.*.face + @as(usize, @intCast(tmp)) else break :blk m3d.*.face - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.vertex[@as(c_uint, @intCast(@as(c_int, 2)))]].y * m3d.*.scale; + (blk: { + const tmp = (l * @as(c_int, 9)) + @as(c_int, 8); + if (tmp >= 0) break :blk (blk_1: { + const tmp_2 = k; + if (tmp_2 >= 0) break :blk_1 model.meshes + @as(usize, @intCast(tmp_2)) else break :blk_1 model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.vertices + @as(usize, @intCast(tmp)) else break :blk (blk_1: { + const tmp_2 = k; + if (tmp_2 >= 0) break :blk_1 model.meshes + @as(usize, @intCast(tmp_2)) else break :blk_1 model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.vertices - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = m3d.*.vertex[(blk: { + const tmp = i; + if (tmp >= 0) break :blk m3d.*.face + @as(usize, @intCast(tmp)) else break :blk m3d.*.face - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.vertex[@as(c_uint, @intCast(@as(c_int, 2)))]].z * m3d.*.scale; + if ((blk: { + const tmp = k; + if (tmp >= 0) break :blk model.meshes + @as(usize, @intCast(tmp)) else break :blk model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.colors != @as([*c]u8, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0))))))) { + if ((m3d.*.vertex[(blk: { + const tmp = i; + if (tmp >= 0) break :blk m3d.*.face + @as(usize, @intCast(tmp)) else break :blk m3d.*.face - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.vertex[@as(c_uint, @intCast(@as(c_int, 0)))]].color & @as(c_uint, 4278190080)) != 0) + { + _ = memcpy(@as(?*anyopaque, @ptrCast(&(blk: { + const tmp = (l * @as(c_int, 12)) + @as(c_int, 0); + if (tmp >= 0) break :blk (blk_1: { + const tmp_2 = k; + if (tmp_2 >= 0) break :blk_1 model.meshes + @as(usize, @intCast(tmp_2)) else break :blk_1 model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.colors + @as(usize, @intCast(tmp)) else break :blk (blk_1: { + const tmp_2 = k; + if (tmp_2 >= 0) break :blk_1 model.meshes + @as(usize, @intCast(tmp_2)) else break :blk_1 model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.colors - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*)), @as(?*const anyopaque, @ptrCast(&m3d.*.vertex[(blk: { + const tmp = i; + if (tmp >= 0) break :blk m3d.*.face + @as(usize, @intCast(tmp)) else break :blk m3d.*.face - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.vertex[@as(c_uint, @intCast(@as(c_int, 0)))]].color)), @as(c_ulong, @bitCast(@as(c_long, @as(c_int, 4))))); + } + if ((m3d.*.vertex[(blk: { + const tmp = i; + if (tmp >= 0) break :blk m3d.*.face + @as(usize, @intCast(tmp)) else break :blk m3d.*.face - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.vertex[@as(c_uint, @intCast(@as(c_int, 1)))]].color & @as(c_uint, 4278190080)) != 0) + { + _ = memcpy(@as(?*anyopaque, @ptrCast(&(blk: { + const tmp = (l * @as(c_int, 12)) + @as(c_int, 4); + if (tmp >= 0) break :blk (blk_1: { + const tmp_2 = k; + if (tmp_2 >= 0) break :blk_1 model.meshes + @as(usize, @intCast(tmp_2)) else break :blk_1 model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.colors + @as(usize, @intCast(tmp)) else break :blk (blk_1: { + const tmp_2 = k; + if (tmp_2 >= 0) break :blk_1 model.meshes + @as(usize, @intCast(tmp_2)) else break :blk_1 model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.colors - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*)), @as(?*const anyopaque, @ptrCast(&m3d.*.vertex[(blk: { + const tmp = i; + if (tmp >= 0) break :blk m3d.*.face + @as(usize, @intCast(tmp)) else break :blk m3d.*.face - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.vertex[@as(c_uint, @intCast(@as(c_int, 1)))]].color)), @as(c_ulong, @bitCast(@as(c_long, @as(c_int, 4))))); + } + if ((m3d.*.vertex[(blk: { + const tmp = i; + if (tmp >= 0) break :blk m3d.*.face + @as(usize, @intCast(tmp)) else break :blk m3d.*.face - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.vertex[@as(c_uint, @intCast(@as(c_int, 2)))]].color & @as(c_uint, 4278190080)) != 0) + { + _ = memcpy(@as(?*anyopaque, @ptrCast(&(blk: { + const tmp = (l * @as(c_int, 12)) + @as(c_int, 8); + if (tmp >= 0) break :blk (blk_1: { + const tmp_2 = k; + if (tmp_2 >= 0) break :blk_1 model.meshes + @as(usize, @intCast(tmp_2)) else break :blk_1 model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.colors + @as(usize, @intCast(tmp)) else break :blk (blk_1: { + const tmp_2 = k; + if (tmp_2 >= 0) break :blk_1 model.meshes + @as(usize, @intCast(tmp_2)) else break :blk_1 model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.colors - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*)), @as(?*const anyopaque, @ptrCast(&m3d.*.vertex[(blk: { + const tmp = i; + if (tmp >= 0) break :blk m3d.*.face + @as(usize, @intCast(tmp)) else break :blk m3d.*.face - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.vertex[@as(c_uint, @intCast(@as(c_int, 2)))]].color)), @as(c_ulong, @bitCast(@as(c_long, @as(c_int, 4))))); + } + } + if ((blk: { + const tmp = i; + if (tmp >= 0) break :blk m3d.*.face + @as(usize, @intCast(tmp)) else break :blk m3d.*.face - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.texcoord[@as(c_uint, @intCast(@as(c_int, 0)))] != @as(c_uint, 4294967295)) { + (blk: { + const tmp = (l * @as(c_int, 6)) + @as(c_int, 0); + if (tmp >= 0) break :blk (blk_1: { + const tmp_2 = k; + if (tmp_2 >= 0) break :blk_1 model.meshes + @as(usize, @intCast(tmp_2)) else break :blk_1 model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.texcoords + @as(usize, @intCast(tmp)) else break :blk (blk_1: { + const tmp_2 = k; + if (tmp_2 >= 0) break :blk_1 model.meshes + @as(usize, @intCast(tmp_2)) else break :blk_1 model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.texcoords - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = m3d.*.tmap[(blk: { + const tmp = i; + if (tmp >= 0) break :blk m3d.*.face + @as(usize, @intCast(tmp)) else break :blk m3d.*.face - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.texcoord[@as(c_uint, @intCast(@as(c_int, 0)))]].u; + (blk: { + const tmp = (l * @as(c_int, 6)) + @as(c_int, 1); + if (tmp >= 0) break :blk (blk_1: { + const tmp_2 = k; + if (tmp_2 >= 0) break :blk_1 model.meshes + @as(usize, @intCast(tmp_2)) else break :blk_1 model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.texcoords + @as(usize, @intCast(tmp)) else break :blk (blk_1: { + const tmp_2 = k; + if (tmp_2 >= 0) break :blk_1 model.meshes + @as(usize, @intCast(tmp_2)) else break :blk_1 model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.texcoords - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = 1.0 - m3d.*.tmap[(blk: { + const tmp = i; + if (tmp >= 0) break :blk m3d.*.face + @as(usize, @intCast(tmp)) else break :blk m3d.*.face - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.texcoord[@as(c_uint, @intCast(@as(c_int, 0)))]].v; + (blk: { + const tmp = (l * @as(c_int, 6)) + @as(c_int, 2); + if (tmp >= 0) break :blk (blk_1: { + const tmp_2 = k; + if (tmp_2 >= 0) break :blk_1 model.meshes + @as(usize, @intCast(tmp_2)) else break :blk_1 model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.texcoords + @as(usize, @intCast(tmp)) else break :blk (blk_1: { + const tmp_2 = k; + if (tmp_2 >= 0) break :blk_1 model.meshes + @as(usize, @intCast(tmp_2)) else break :blk_1 model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.texcoords - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = m3d.*.tmap[(blk: { + const tmp = i; + if (tmp >= 0) break :blk m3d.*.face + @as(usize, @intCast(tmp)) else break :blk m3d.*.face - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.texcoord[@as(c_uint, @intCast(@as(c_int, 1)))]].u; + (blk: { + const tmp = (l * @as(c_int, 6)) + @as(c_int, 3); + if (tmp >= 0) break :blk (blk_1: { + const tmp_2 = k; + if (tmp_2 >= 0) break :blk_1 model.meshes + @as(usize, @intCast(tmp_2)) else break :blk_1 model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.texcoords + @as(usize, @intCast(tmp)) else break :blk (blk_1: { + const tmp_2 = k; + if (tmp_2 >= 0) break :blk_1 model.meshes + @as(usize, @intCast(tmp_2)) else break :blk_1 model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.texcoords - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = 1.0 - m3d.*.tmap[(blk: { + const tmp = i; + if (tmp >= 0) break :blk m3d.*.face + @as(usize, @intCast(tmp)) else break :blk m3d.*.face - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.texcoord[@as(c_uint, @intCast(@as(c_int, 1)))]].v; + (blk: { + const tmp = (l * @as(c_int, 6)) + @as(c_int, 4); + if (tmp >= 0) break :blk (blk_1: { + const tmp_2 = k; + if (tmp_2 >= 0) break :blk_1 model.meshes + @as(usize, @intCast(tmp_2)) else break :blk_1 model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.texcoords + @as(usize, @intCast(tmp)) else break :blk (blk_1: { + const tmp_2 = k; + if (tmp_2 >= 0) break :blk_1 model.meshes + @as(usize, @intCast(tmp_2)) else break :blk_1 model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.texcoords - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = m3d.*.tmap[(blk: { + const tmp = i; + if (tmp >= 0) break :blk m3d.*.face + @as(usize, @intCast(tmp)) else break :blk m3d.*.face - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.texcoord[@as(c_uint, @intCast(@as(c_int, 2)))]].u; + (blk: { + const tmp = (l * @as(c_int, 6)) + @as(c_int, 5); + if (tmp >= 0) break :blk (blk_1: { + const tmp_2 = k; + if (tmp_2 >= 0) break :blk_1 model.meshes + @as(usize, @intCast(tmp_2)) else break :blk_1 model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.texcoords + @as(usize, @intCast(tmp)) else break :blk (blk_1: { + const tmp_2 = k; + if (tmp_2 >= 0) break :blk_1 model.meshes + @as(usize, @intCast(tmp_2)) else break :blk_1 model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.texcoords - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = 1.0 - m3d.*.tmap[(blk: { + const tmp = i; + if (tmp >= 0) break :blk m3d.*.face + @as(usize, @intCast(tmp)) else break :blk m3d.*.face - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.texcoord[@as(c_uint, @intCast(@as(c_int, 2)))]].v; + } + if ((blk: { + const tmp = i; + if (tmp >= 0) break :blk m3d.*.face + @as(usize, @intCast(tmp)) else break :blk m3d.*.face - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.normal[@as(c_uint, @intCast(@as(c_int, 0)))] != @as(c_uint, 4294967295)) { + (blk: { + const tmp = (l * @as(c_int, 9)) + @as(c_int, 0); + if (tmp >= 0) break :blk (blk_1: { + const tmp_2 = k; + if (tmp_2 >= 0) break :blk_1 model.meshes + @as(usize, @intCast(tmp_2)) else break :blk_1 model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.normals + @as(usize, @intCast(tmp)) else break :blk (blk_1: { + const tmp_2 = k; + if (tmp_2 >= 0) break :blk_1 model.meshes + @as(usize, @intCast(tmp_2)) else break :blk_1 model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.normals - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = m3d.*.vertex[(blk: { + const tmp = i; + if (tmp >= 0) break :blk m3d.*.face + @as(usize, @intCast(tmp)) else break :blk m3d.*.face - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.normal[@as(c_uint, @intCast(@as(c_int, 0)))]].x; + (blk: { + const tmp = (l * @as(c_int, 9)) + @as(c_int, 1); + if (tmp >= 0) break :blk (blk_1: { + const tmp_2 = k; + if (tmp_2 >= 0) break :blk_1 model.meshes + @as(usize, @intCast(tmp_2)) else break :blk_1 model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.normals + @as(usize, @intCast(tmp)) else break :blk (blk_1: { + const tmp_2 = k; + if (tmp_2 >= 0) break :blk_1 model.meshes + @as(usize, @intCast(tmp_2)) else break :blk_1 model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.normals - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = m3d.*.vertex[(blk: { + const tmp = i; + if (tmp >= 0) break :blk m3d.*.face + @as(usize, @intCast(tmp)) else break :blk m3d.*.face - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.normal[@as(c_uint, @intCast(@as(c_int, 0)))]].y; + (blk: { + const tmp = (l * @as(c_int, 9)) + @as(c_int, 2); + if (tmp >= 0) break :blk (blk_1: { + const tmp_2 = k; + if (tmp_2 >= 0) break :blk_1 model.meshes + @as(usize, @intCast(tmp_2)) else break :blk_1 model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.normals + @as(usize, @intCast(tmp)) else break :blk (blk_1: { + const tmp_2 = k; + if (tmp_2 >= 0) break :blk_1 model.meshes + @as(usize, @intCast(tmp_2)) else break :blk_1 model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.normals - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = m3d.*.vertex[(blk: { + const tmp = i; + if (tmp >= 0) break :blk m3d.*.face + @as(usize, @intCast(tmp)) else break :blk m3d.*.face - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.normal[@as(c_uint, @intCast(@as(c_int, 0)))]].z; + (blk: { + const tmp = (l * @as(c_int, 9)) + @as(c_int, 3); + if (tmp >= 0) break :blk (blk_1: { + const tmp_2 = k; + if (tmp_2 >= 0) break :blk_1 model.meshes + @as(usize, @intCast(tmp_2)) else break :blk_1 model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.normals + @as(usize, @intCast(tmp)) else break :blk (blk_1: { + const tmp_2 = k; + if (tmp_2 >= 0) break :blk_1 model.meshes + @as(usize, @intCast(tmp_2)) else break :blk_1 model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.normals - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = m3d.*.vertex[(blk: { + const tmp = i; + if (tmp >= 0) break :blk m3d.*.face + @as(usize, @intCast(tmp)) else break :blk m3d.*.face - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.normal[@as(c_uint, @intCast(@as(c_int, 1)))]].x; + (blk: { + const tmp = (l * @as(c_int, 9)) + @as(c_int, 4); + if (tmp >= 0) break :blk (blk_1: { + const tmp_2 = k; + if (tmp_2 >= 0) break :blk_1 model.meshes + @as(usize, @intCast(tmp_2)) else break :blk_1 model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.normals + @as(usize, @intCast(tmp)) else break :blk (blk_1: { + const tmp_2 = k; + if (tmp_2 >= 0) break :blk_1 model.meshes + @as(usize, @intCast(tmp_2)) else break :blk_1 model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.normals - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = m3d.*.vertex[(blk: { + const tmp = i; + if (tmp >= 0) break :blk m3d.*.face + @as(usize, @intCast(tmp)) else break :blk m3d.*.face - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.normal[@as(c_uint, @intCast(@as(c_int, 1)))]].y; + (blk: { + const tmp = (l * @as(c_int, 9)) + @as(c_int, 5); + if (tmp >= 0) break :blk (blk_1: { + const tmp_2 = k; + if (tmp_2 >= 0) break :blk_1 model.meshes + @as(usize, @intCast(tmp_2)) else break :blk_1 model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.normals + @as(usize, @intCast(tmp)) else break :blk (blk_1: { + const tmp_2 = k; + if (tmp_2 >= 0) break :blk_1 model.meshes + @as(usize, @intCast(tmp_2)) else break :blk_1 model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.normals - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = m3d.*.vertex[(blk: { + const tmp = i; + if (tmp >= 0) break :blk m3d.*.face + @as(usize, @intCast(tmp)) else break :blk m3d.*.face - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.normal[@as(c_uint, @intCast(@as(c_int, 1)))]].z; + (blk: { + const tmp = (l * @as(c_int, 9)) + @as(c_int, 6); + if (tmp >= 0) break :blk (blk_1: { + const tmp_2 = k; + if (tmp_2 >= 0) break :blk_1 model.meshes + @as(usize, @intCast(tmp_2)) else break :blk_1 model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.normals + @as(usize, @intCast(tmp)) else break :blk (blk_1: { + const tmp_2 = k; + if (tmp_2 >= 0) break :blk_1 model.meshes + @as(usize, @intCast(tmp_2)) else break :blk_1 model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.normals - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = m3d.*.vertex[(blk: { + const tmp = i; + if (tmp >= 0) break :blk m3d.*.face + @as(usize, @intCast(tmp)) else break :blk m3d.*.face - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.normal[@as(c_uint, @intCast(@as(c_int, 2)))]].x; + (blk: { + const tmp = (l * @as(c_int, 9)) + @as(c_int, 7); + if (tmp >= 0) break :blk (blk_1: { + const tmp_2 = k; + if (tmp_2 >= 0) break :blk_1 model.meshes + @as(usize, @intCast(tmp_2)) else break :blk_1 model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.normals + @as(usize, @intCast(tmp)) else break :blk (blk_1: { + const tmp_2 = k; + if (tmp_2 >= 0) break :blk_1 model.meshes + @as(usize, @intCast(tmp_2)) else break :blk_1 model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.normals - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = m3d.*.vertex[(blk: { + const tmp = i; + if (tmp >= 0) break :blk m3d.*.face + @as(usize, @intCast(tmp)) else break :blk m3d.*.face - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.normal[@as(c_uint, @intCast(@as(c_int, 2)))]].y; + (blk: { + const tmp = (l * @as(c_int, 9)) + @as(c_int, 8); + if (tmp >= 0) break :blk (blk_1: { + const tmp_2 = k; + if (tmp_2 >= 0) break :blk_1 model.meshes + @as(usize, @intCast(tmp_2)) else break :blk_1 model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.normals + @as(usize, @intCast(tmp)) else break :blk (blk_1: { + const tmp_2 = k; + if (tmp_2 >= 0) break :blk_1 model.meshes + @as(usize, @intCast(tmp_2)) else break :blk_1 model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.normals - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = m3d.*.vertex[(blk: { + const tmp = i; + if (tmp >= 0) break :blk m3d.*.face + @as(usize, @intCast(tmp)) else break :blk m3d.*.face - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.normal[@as(c_uint, @intCast(@as(c_int, 2)))]].z; + } + if ((m3d.*.numbone != 0) and (m3d.*.numskin != 0)) { + { + n = 0; + while (n < @as(c_int, 3)) : (n += 1) { + var skinid: c_int = @as(c_int, @bitCast(m3d.*.vertex[(blk: { + const tmp = i; + if (tmp >= 0) break :blk m3d.*.face + @as(usize, @intCast(tmp)) else break :blk m3d.*.face - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.vertex[@as(c_uint, @intCast(n))]].skinid)); + _ = &skinid; + if ((@as(c_uint, @bitCast(skinid)) != @as(c_uint, 4294967295)) and (skinid < @as(c_int, @bitCast(m3d.*.numskin)))) { + { + j = 0; + while (j < @as(c_int, 4)) : (j += 1) { + (blk: { + const tmp = ((l * @as(c_int, 12)) + (n * @as(c_int, 4))) + j; + if (tmp >= 0) break :blk (blk_1: { + const tmp_2 = k; + if (tmp_2 >= 0) break :blk_1 model.meshes + @as(usize, @intCast(tmp_2)) else break :blk_1 model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.boneIds + @as(usize, @intCast(tmp)) else break :blk (blk_1: { + const tmp_2 = k; + if (tmp_2 >= 0) break :blk_1 model.meshes + @as(usize, @intCast(tmp_2)) else break :blk_1 model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.boneIds - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = @as(u8, @bitCast(@as(u8, @truncate((blk: { + const tmp = skinid; + if (tmp >= 0) break :blk m3d.*.skin + @as(usize, @intCast(tmp)) else break :blk m3d.*.skin - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.boneid[@as(c_uint, @intCast(j))])))); + (blk: { + const tmp = ((l * @as(c_int, 12)) + (n * @as(c_int, 4))) + j; + if (tmp >= 0) break :blk (blk_1: { + const tmp_2 = k; + if (tmp_2 >= 0) break :blk_1 model.meshes + @as(usize, @intCast(tmp_2)) else break :blk_1 model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.boneWeights + @as(usize, @intCast(tmp)) else break :blk (blk_1: { + const tmp_2 = k; + if (tmp_2 >= 0) break :blk_1 model.meshes + @as(usize, @intCast(tmp_2)) else break :blk_1 model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.boneWeights - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = (blk: { + const tmp = skinid; + if (tmp >= 0) break :blk m3d.*.skin + @as(usize, @intCast(tmp)) else break :blk m3d.*.skin - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.weight[@as(c_uint, @intCast(j))]; + } + } + } else { + (blk: { + const tmp = (l * @as(c_int, 12)) + (n * @as(c_int, 4)); + if (tmp >= 0) break :blk (blk_1: { + const tmp_2 = k; + if (tmp_2 >= 0) break :blk_1 model.meshes + @as(usize, @intCast(tmp_2)) else break :blk_1 model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.boneIds + @as(usize, @intCast(tmp)) else break :blk (blk_1: { + const tmp_2 = k; + if (tmp_2 >= 0) break :blk_1 model.meshes + @as(usize, @intCast(tmp_2)) else break :blk_1 model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.boneIds - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = @as(u8, @bitCast(@as(u8, @truncate(m3d.*.numbone)))); + (blk: { + const tmp = (l * @as(c_int, 12)) + (n * @as(c_int, 4)); + if (tmp >= 0) break :blk (blk_1: { + const tmp_2 = k; + if (tmp_2 >= 0) break :blk_1 model.meshes + @as(usize, @intCast(tmp_2)) else break :blk_1 model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.boneWeights + @as(usize, @intCast(tmp)) else break :blk (blk_1: { + const tmp_2 = k; + if (tmp_2 >= 0) break :blk_1 model.meshes + @as(usize, @intCast(tmp_2)) else break :blk_1 model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.boneWeights - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = 1.0; + } + } + } + } + } + } + { + i = 0; + while (i < @as(c_int, @bitCast(m3d.*.nummaterial))) : (i += 1) { + (blk: { + const tmp = i + @as(c_int, 1); + if (tmp >= 0) break :blk model.materials + @as(usize, @intCast(tmp)) else break :blk model.materials - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = LoadMaterialDefault(); + { + j = 0; + while (j < @as(c_int, @bitCast(@as(c_uint, (blk: { + const tmp = i; + if (tmp >= 0) break :blk m3d.*.material + @as(usize, @intCast(tmp)) else break :blk m3d.*.material - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.numprop)))) : (j += 1) { + prop = &(blk: { + const tmp = j; + if (tmp >= 0) break :blk (blk_1: { + const tmp_2 = i; + if (tmp_2 >= 0) break :blk_1 m3d.*.material + @as(usize, @intCast(tmp_2)) else break :blk_1 m3d.*.material - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.prop + @as(usize, @intCast(tmp)) else break :blk (blk_1: { + const tmp_2 = i; + if (tmp_2 >= 0) break :blk_1 m3d.*.material + @as(usize, @intCast(tmp_2)) else break :blk_1 m3d.*.material - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.prop - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*; + while (true) { + switch (@as(c_int, @bitCast(@as(c_uint, prop.*.type)))) { + @as(c_int, 0) => { + { + _ = memcpy(@as(?*anyopaque, @ptrCast(&(blk: { + const tmp = MATERIAL_MAP_ALBEDO; + if (tmp >= 0) break :blk (blk_1: { + const tmp_2 = i + @as(c_int, 1); + if (tmp_2 >= 0) break :blk_1 model.materials + @as(usize, @intCast(tmp_2)) else break :blk_1 model.materials - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.maps + @as(usize, @intCast(tmp)) else break :blk (blk_1: { + const tmp_2 = i + @as(c_int, 1); + if (tmp_2 >= 0) break :blk_1 model.materials + @as(usize, @intCast(tmp_2)) else break :blk_1 model.materials - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.maps - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.color)), @as(?*const anyopaque, @ptrCast(&prop.*.value.color)), @as(c_ulong, @bitCast(@as(c_long, @as(c_int, 4))))); + (blk: { + const tmp = MATERIAL_MAP_ALBEDO; + if (tmp >= 0) break :blk (blk_1: { + const tmp_2 = i + @as(c_int, 1); + if (tmp_2 >= 0) break :blk_1 model.materials + @as(usize, @intCast(tmp_2)) else break :blk_1 model.materials - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.maps + @as(usize, @intCast(tmp)) else break :blk (blk_1: { + const tmp_2 = i + @as(c_int, 1); + if (tmp_2 >= 0) break :blk_1 model.materials + @as(usize, @intCast(tmp_2)) else break :blk_1 model.materials - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.maps - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.value = 0.0; + } + break; + }, + @as(c_int, 2) => { + { + _ = memcpy(@as(?*anyopaque, @ptrCast(&(blk: { + const tmp = MATERIAL_MAP_METALNESS; + if (tmp >= 0) break :blk (blk_1: { + const tmp_2 = i + @as(c_int, 1); + if (tmp_2 >= 0) break :blk_1 model.materials + @as(usize, @intCast(tmp_2)) else break :blk_1 model.materials - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.maps + @as(usize, @intCast(tmp)) else break :blk (blk_1: { + const tmp_2 = i + @as(c_int, 1); + if (tmp_2 >= 0) break :blk_1 model.materials + @as(usize, @intCast(tmp_2)) else break :blk_1 model.materials - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.maps - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.color)), @as(?*const anyopaque, @ptrCast(&prop.*.value.color)), @as(c_ulong, @bitCast(@as(c_long, @as(c_int, 4))))); + } + break; + }, + @as(c_int, 3) => { + { + (blk: { + const tmp = MATERIAL_MAP_METALNESS; + if (tmp >= 0) break :blk (blk_1: { + const tmp_2 = i + @as(c_int, 1); + if (tmp_2 >= 0) break :blk_1 model.materials + @as(usize, @intCast(tmp_2)) else break :blk_1 model.materials - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.maps + @as(usize, @intCast(tmp)) else break :blk (blk_1: { + const tmp_2 = i + @as(c_int, 1); + if (tmp_2 >= 0) break :blk_1 model.materials + @as(usize, @intCast(tmp_2)) else break :blk_1 model.materials - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.maps - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.value = prop.*.value.fnum; + } + break; + }, + @as(c_int, 4) => { + { + _ = memcpy(@as(?*anyopaque, @ptrCast(&(blk: { + const tmp = MATERIAL_MAP_EMISSION; + if (tmp >= 0) break :blk (blk_1: { + const tmp_2 = i + @as(c_int, 1); + if (tmp_2 >= 0) break :blk_1 model.materials + @as(usize, @intCast(tmp_2)) else break :blk_1 model.materials - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.maps + @as(usize, @intCast(tmp)) else break :blk (blk_1: { + const tmp_2 = i + @as(c_int, 1); + if (tmp_2 >= 0) break :blk_1 model.materials + @as(usize, @intCast(tmp_2)) else break :blk_1 model.materials - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.maps - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.color)), @as(?*const anyopaque, @ptrCast(&prop.*.value.color)), @as(c_ulong, @bitCast(@as(c_long, @as(c_int, 4))))); + (blk: { + const tmp = MATERIAL_MAP_EMISSION; + if (tmp >= 0) break :blk (blk_1: { + const tmp_2 = i + @as(c_int, 1); + if (tmp_2 >= 0) break :blk_1 model.materials + @as(usize, @intCast(tmp_2)) else break :blk_1 model.materials - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.maps + @as(usize, @intCast(tmp)) else break :blk (blk_1: { + const tmp_2 = i + @as(c_int, 1); + if (tmp_2 >= 0) break :blk_1 model.materials + @as(usize, @intCast(tmp_2)) else break :blk_1 model.materials - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.maps - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.value = 0.0; + } + break; + }, + @as(c_int, 65) => { + { + (blk: { + const tmp = MATERIAL_MAP_METALNESS; + if (tmp >= 0) break :blk (blk_1: { + const tmp_2 = i + @as(c_int, 1); + if (tmp_2 >= 0) break :blk_1 model.materials + @as(usize, @intCast(tmp_2)) else break :blk_1 model.materials - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.maps + @as(usize, @intCast(tmp)) else break :blk (blk_1: { + const tmp_2 = i + @as(c_int, 1); + if (tmp_2 >= 0) break :blk_1 model.materials + @as(usize, @intCast(tmp_2)) else break :blk_1 model.materials - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.maps - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.value = prop.*.value.fnum; + } + break; + }, + @as(c_int, 64) => { + { + (blk: { + const tmp = MATERIAL_MAP_ROUGHNESS; + if (tmp >= 0) break :blk (blk_1: { + const tmp_2 = i + @as(c_int, 1); + if (tmp_2 >= 0) break :blk_1 model.materials + @as(usize, @intCast(tmp_2)) else break :blk_1 model.materials - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.maps + @as(usize, @intCast(tmp)) else break :blk (blk_1: { + const tmp_2 = i + @as(c_int, 1); + if (tmp_2 >= 0) break :blk_1 model.materials + @as(usize, @intCast(tmp_2)) else break :blk_1 model.materials - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.maps - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.value = prop.*.value.fnum; + } + break; + }, + @as(c_int, 66) => { + { + (blk: { + const tmp = MATERIAL_MAP_NORMAL; + if (tmp >= 0) break :blk (blk_1: { + const tmp_2 = i + @as(c_int, 1); + if (tmp_2 >= 0) break :blk_1 model.materials + @as(usize, @intCast(tmp_2)) else break :blk_1 model.materials - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.maps + @as(usize, @intCast(tmp)) else break :blk (blk_1: { + const tmp_2 = i + @as(c_int, 1); + if (tmp_2 >= 0) break :blk_1 model.materials + @as(usize, @intCast(tmp_2)) else break :blk_1 model.materials - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.maps - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.color = Color{ + .r = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 255))))), + .g = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 255))))), + .b = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 255))))), + .a = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 255))))), + }; + (blk: { + const tmp = MATERIAL_MAP_NORMAL; + if (tmp >= 0) break :blk (blk_1: { + const tmp_2 = i + @as(c_int, 1); + if (tmp_2 >= 0) break :blk_1 model.materials + @as(usize, @intCast(tmp_2)) else break :blk_1 model.materials - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.maps + @as(usize, @intCast(tmp)) else break :blk (blk_1: { + const tmp_2 = i + @as(c_int, 1); + if (tmp_2 >= 0) break :blk_1 model.materials + @as(usize, @intCast(tmp_2)) else break :blk_1 model.materials - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.maps - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.value = prop.*.value.fnum; + } + break; + }, + else => { + { + if (@as(c_int, @bitCast(@as(c_uint, prop.*.type))) >= @as(c_int, 128)) { + var image: Image = Image{ + .data = null, + .width = 0, + .height = 0, + .mipmaps = 0, + .format = 0, + }; + _ = ℑ + image.data = @as(?*anyopaque, @ptrCast(m3d.*.texture[prop.*.value.textureid].d)); + image.width = @as(c_int, @bitCast(@as(c_uint, m3d.*.texture[prop.*.value.textureid].w))); + image.height = @as(c_int, @bitCast(@as(c_uint, m3d.*.texture[prop.*.value.textureid].h))); + image.mipmaps = 1; + image.format = if (@as(c_int, @bitCast(@as(c_uint, m3d.*.texture[prop.*.value.textureid].f))) == @as(c_int, 4)) PIXELFORMAT_UNCOMPRESSED_R8G8B8A8 else if (@as(c_int, @bitCast(@as(c_uint, m3d.*.texture[prop.*.value.textureid].f))) == @as(c_int, 3)) PIXELFORMAT_UNCOMPRESSED_R8G8B8 else if (@as(c_int, @bitCast(@as(c_uint, m3d.*.texture[prop.*.value.textureid].f))) == @as(c_int, 2)) PIXELFORMAT_UNCOMPRESSED_GRAY_ALPHA else PIXELFORMAT_UNCOMPRESSED_GRAYSCALE; + while (true) { + switch (@as(c_int, @bitCast(@as(c_uint, prop.*.type)))) { + @as(c_int, 128) => { + (blk: { + const tmp = MATERIAL_MAP_ALBEDO; + if (tmp >= 0) break :blk (blk_1: { + const tmp_2 = i + @as(c_int, 1); + if (tmp_2 >= 0) break :blk_1 model.materials + @as(usize, @intCast(tmp_2)) else break :blk_1 model.materials - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.maps + @as(usize, @intCast(tmp)) else break :blk (blk_1: { + const tmp_2 = i + @as(c_int, 1); + if (tmp_2 >= 0) break :blk_1 model.materials + @as(usize, @intCast(tmp_2)) else break :blk_1 model.materials - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.maps - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.texture = LoadTextureFromImage(image); + break; + }, + @as(c_int, 130) => { + (blk: { + const tmp = MATERIAL_MAP_METALNESS; + if (tmp >= 0) break :blk (blk_1: { + const tmp_2 = i + @as(c_int, 1); + if (tmp_2 >= 0) break :blk_1 model.materials + @as(usize, @intCast(tmp_2)) else break :blk_1 model.materials - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.maps + @as(usize, @intCast(tmp)) else break :blk (blk_1: { + const tmp_2 = i + @as(c_int, 1); + if (tmp_2 >= 0) break :blk_1 model.materials + @as(usize, @intCast(tmp_2)) else break :blk_1 model.materials - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.maps - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.texture = LoadTextureFromImage(image); + break; + }, + @as(c_int, 132) => { + (blk: { + const tmp = MATERIAL_MAP_EMISSION; + if (tmp >= 0) break :blk (blk_1: { + const tmp_2 = i + @as(c_int, 1); + if (tmp_2 >= 0) break :blk_1 model.materials + @as(usize, @intCast(tmp_2)) else break :blk_1 model.materials - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.maps + @as(usize, @intCast(tmp)) else break :blk (blk_1: { + const tmp_2 = i + @as(c_int, 1); + if (tmp_2 >= 0) break :blk_1 model.materials + @as(usize, @intCast(tmp_2)) else break :blk_1 model.materials - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.maps - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.texture = LoadTextureFromImage(image); + break; + }, + @as(c_int, 134) => { + (blk: { + const tmp = MATERIAL_MAP_NORMAL; + if (tmp >= 0) break :blk (blk_1: { + const tmp_2 = i + @as(c_int, 1); + if (tmp_2 >= 0) break :blk_1 model.materials + @as(usize, @intCast(tmp_2)) else break :blk_1 model.materials - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.maps + @as(usize, @intCast(tmp)) else break :blk (blk_1: { + const tmp_2 = i + @as(c_int, 1); + if (tmp_2 >= 0) break :blk_1 model.materials + @as(usize, @intCast(tmp_2)) else break :blk_1 model.materials - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.maps - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.texture = LoadTextureFromImage(image); + break; + }, + @as(c_int, 129) => { + (blk: { + const tmp = MATERIAL_MAP_OCCLUSION; + if (tmp >= 0) break :blk (blk_1: { + const tmp_2 = i + @as(c_int, 1); + if (tmp_2 >= 0) break :blk_1 model.materials + @as(usize, @intCast(tmp_2)) else break :blk_1 model.materials - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.maps + @as(usize, @intCast(tmp)) else break :blk (blk_1: { + const tmp_2 = i + @as(c_int, 1); + if (tmp_2 >= 0) break :blk_1 model.materials + @as(usize, @intCast(tmp_2)) else break :blk_1 model.materials - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.maps - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.texture = LoadTextureFromImage(image); + break; + }, + @as(c_int, 193) => { + (blk: { + const tmp = MATERIAL_MAP_ROUGHNESS; + if (tmp >= 0) break :blk (blk_1: { + const tmp_2 = i + @as(c_int, 1); + if (tmp_2 >= 0) break :blk_1 model.materials + @as(usize, @intCast(tmp_2)) else break :blk_1 model.materials - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.maps + @as(usize, @intCast(tmp)) else break :blk (blk_1: { + const tmp_2 = i + @as(c_int, 1); + if (tmp_2 >= 0) break :blk_1 model.materials + @as(usize, @intCast(tmp_2)) else break :blk_1 model.materials - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.maps - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.texture = LoadTextureFromImage(image); + break; + }, + else => break, + } + break; + } + } + } + break; + }, + } + break; + } + } + } + } + } + if (m3d.*.numbone != 0) { + model.boneCount = @as(c_int, @bitCast(m3d.*.numbone +% @as(M3D_INDEX, @bitCast(@as(c_int, 1))))); + model.bones = @as([*c]BoneInfo, @ptrCast(@alignCast(calloc(@as(c_ulong, @bitCast(@as(c_long, model.boneCount))), @sizeOf(BoneInfo))))); + model.bindPose = @as([*c]Transform, @ptrCast(@alignCast(calloc(@as(c_ulong, @bitCast(@as(c_long, model.boneCount))), @sizeOf(Transform))))); + { + i = 0; + while (i < @as(c_int, @bitCast(m3d.*.numbone))) : (i += 1) { + (blk: { + const tmp = i; + if (tmp >= 0) break :blk model.bones + @as(usize, @intCast(tmp)) else break :blk model.bones - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.parent = @as(c_int, @bitCast((blk: { + const tmp = i; + if (tmp >= 0) break :blk m3d.*.bone + @as(usize, @intCast(tmp)) else break :blk m3d.*.bone - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.parent)); + _ = strncpy(@as([*c]u8, @ptrCast(@alignCast(&(blk: { + const tmp = i; + if (tmp >= 0) break :blk model.bones + @as(usize, @intCast(tmp)) else break :blk model.bones - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.name))), (blk: { + const tmp = i; + if (tmp >= 0) break :blk m3d.*.bone + @as(usize, @intCast(tmp)) else break :blk m3d.*.bone - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.name, @sizeOf([32]u8)); + (blk: { + const tmp = i; + if (tmp >= 0) break :blk model.bindPose + @as(usize, @intCast(tmp)) else break :blk model.bindPose - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.translation.x = m3d.*.vertex[(blk: { + const tmp = i; + if (tmp >= 0) break :blk m3d.*.bone + @as(usize, @intCast(tmp)) else break :blk m3d.*.bone - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.pos].x * m3d.*.scale; + (blk: { + const tmp = i; + if (tmp >= 0) break :blk model.bindPose + @as(usize, @intCast(tmp)) else break :blk model.bindPose - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.translation.y = m3d.*.vertex[(blk: { + const tmp = i; + if (tmp >= 0) break :blk m3d.*.bone + @as(usize, @intCast(tmp)) else break :blk m3d.*.bone - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.pos].y * m3d.*.scale; + (blk: { + const tmp = i; + if (tmp >= 0) break :blk model.bindPose + @as(usize, @intCast(tmp)) else break :blk model.bindPose - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.translation.z = m3d.*.vertex[(blk: { + const tmp = i; + if (tmp >= 0) break :blk m3d.*.bone + @as(usize, @intCast(tmp)) else break :blk m3d.*.bone - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.pos].z * m3d.*.scale; + (blk: { + const tmp = i; + if (tmp >= 0) break :blk model.bindPose + @as(usize, @intCast(tmp)) else break :blk model.bindPose - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.rotation.x = m3d.*.vertex[(blk: { + const tmp = i; + if (tmp >= 0) break :blk m3d.*.bone + @as(usize, @intCast(tmp)) else break :blk m3d.*.bone - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.ori].x; + (blk: { + const tmp = i; + if (tmp >= 0) break :blk model.bindPose + @as(usize, @intCast(tmp)) else break :blk model.bindPose - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.rotation.y = m3d.*.vertex[(blk: { + const tmp = i; + if (tmp >= 0) break :blk m3d.*.bone + @as(usize, @intCast(tmp)) else break :blk m3d.*.bone - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.ori].y; + (blk: { + const tmp = i; + if (tmp >= 0) break :blk model.bindPose + @as(usize, @intCast(tmp)) else break :blk model.bindPose - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.rotation.z = m3d.*.vertex[(blk: { + const tmp = i; + if (tmp >= 0) break :blk m3d.*.bone + @as(usize, @intCast(tmp)) else break :blk m3d.*.bone - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.ori].z; + (blk: { + const tmp = i; + if (tmp >= 0) break :blk model.bindPose + @as(usize, @intCast(tmp)) else break :blk model.bindPose - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.rotation.w = m3d.*.vertex[(blk: { + const tmp = i; + if (tmp >= 0) break :blk m3d.*.bone + @as(usize, @intCast(tmp)) else break :blk m3d.*.bone - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.ori].w; + (blk: { + const tmp = i; + if (tmp >= 0) break :blk model.bindPose + @as(usize, @intCast(tmp)) else break :blk model.bindPose - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.rotation = QuaternionNormalize((blk: { + const tmp = i; + if (tmp >= 0) break :blk model.bindPose + @as(usize, @intCast(tmp)) else break :blk model.bindPose - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.rotation); + (blk: { + const tmp = i; + if (tmp >= 0) break :blk model.bindPose + @as(usize, @intCast(tmp)) else break :blk model.bindPose - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.scale.x = blk: { + const tmp = blk_1: { + const tmp_2 = 1.0; + (blk_2: { + const tmp_3 = i; + if (tmp_3 >= 0) break :blk_2 model.bindPose + @as(usize, @intCast(tmp_3)) else break :blk_2 model.bindPose - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_3)) +% -1)); + }).*.scale.z = tmp_2; + break :blk_1 tmp_2; + }; + (blk_1: { + const tmp_2 = i; + if (tmp_2 >= 0) break :blk_1 model.bindPose + @as(usize, @intCast(tmp_2)) else break :blk_1 model.bindPose - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.scale.y = tmp; + break :blk tmp; + }; + if ((blk: { + const tmp = i; + if (tmp >= 0) break :blk model.bones + @as(usize, @intCast(tmp)) else break :blk model.bones - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.parent >= @as(c_int, 0)) { + (blk: { + const tmp = i; + if (tmp >= 0) break :blk model.bindPose + @as(usize, @intCast(tmp)) else break :blk model.bindPose - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.rotation = QuaternionMultiply((blk: { + const tmp = (blk_1: { + const tmp_2 = i; + if (tmp_2 >= 0) break :blk_1 model.bones + @as(usize, @intCast(tmp_2)) else break :blk_1 model.bones - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.parent; + if (tmp >= 0) break :blk model.bindPose + @as(usize, @intCast(tmp)) else break :blk model.bindPose - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.rotation, (blk: { + const tmp = i; + if (tmp >= 0) break :blk model.bindPose + @as(usize, @intCast(tmp)) else break :blk model.bindPose - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.rotation); + (blk: { + const tmp = i; + if (tmp >= 0) break :blk model.bindPose + @as(usize, @intCast(tmp)) else break :blk model.bindPose - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.translation = Vector3RotateByQuaternion((blk: { + const tmp = i; + if (tmp >= 0) break :blk model.bindPose + @as(usize, @intCast(tmp)) else break :blk model.bindPose - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.translation, (blk: { + const tmp = (blk_1: { + const tmp_2 = i; + if (tmp_2 >= 0) break :blk_1 model.bones + @as(usize, @intCast(tmp_2)) else break :blk_1 model.bones - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.parent; + if (tmp >= 0) break :blk model.bindPose + @as(usize, @intCast(tmp)) else break :blk model.bindPose - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.rotation); + (blk: { + const tmp = i; + if (tmp >= 0) break :blk model.bindPose + @as(usize, @intCast(tmp)) else break :blk model.bindPose - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.translation = Vector3Add((blk: { + const tmp = i; + if (tmp >= 0) break :blk model.bindPose + @as(usize, @intCast(tmp)) else break :blk model.bindPose - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.translation, (blk: { + const tmp = (blk_1: { + const tmp_2 = i; + if (tmp_2 >= 0) break :blk_1 model.bones + @as(usize, @intCast(tmp_2)) else break :blk_1 model.bones - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.parent; + if (tmp >= 0) break :blk model.bindPose + @as(usize, @intCast(tmp)) else break :blk model.bindPose - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.translation); + (blk: { + const tmp = i; + if (tmp >= 0) break :blk model.bindPose + @as(usize, @intCast(tmp)) else break :blk model.bindPose - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.scale = Vector3Multiply((blk: { + const tmp = i; + if (tmp >= 0) break :blk model.bindPose + @as(usize, @intCast(tmp)) else break :blk model.bindPose - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.scale, (blk: { + const tmp = (blk_1: { + const tmp_2 = i; + if (tmp_2 >= 0) break :blk_1 model.bones + @as(usize, @intCast(tmp_2)) else break :blk_1 model.bones - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.parent; + if (tmp >= 0) break :blk model.bindPose + @as(usize, @intCast(tmp)) else break :blk model.bindPose - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.scale); + } + } + } + (blk: { + const tmp = i; + if (tmp >= 0) break :blk model.bones + @as(usize, @intCast(tmp)) else break :blk model.bones - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.parent = -@as(c_int, 1); + _ = strcpy(@as([*c]u8, @ptrCast(@alignCast(&(blk: { + const tmp = i; + if (tmp >= 0) break :blk model.bones + @as(usize, @intCast(tmp)) else break :blk model.bones - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.name))), "NO BONE"); + (blk: { + const tmp = i; + if (tmp >= 0) break :blk model.bindPose + @as(usize, @intCast(tmp)) else break :blk model.bindPose - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.translation.x = 0.0; + (blk: { + const tmp = i; + if (tmp >= 0) break :blk model.bindPose + @as(usize, @intCast(tmp)) else break :blk model.bindPose - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.translation.y = 0.0; + (blk: { + const tmp = i; + if (tmp >= 0) break :blk model.bindPose + @as(usize, @intCast(tmp)) else break :blk model.bindPose - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.translation.z = 0.0; + (blk: { + const tmp = i; + if (tmp >= 0) break :blk model.bindPose + @as(usize, @intCast(tmp)) else break :blk model.bindPose - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.rotation.x = 0.0; + (blk: { + const tmp = i; + if (tmp >= 0) break :blk model.bindPose + @as(usize, @intCast(tmp)) else break :blk model.bindPose - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.rotation.y = 0.0; + (blk: { + const tmp = i; + if (tmp >= 0) break :blk model.bindPose + @as(usize, @intCast(tmp)) else break :blk model.bindPose - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.rotation.z = 0.0; + (blk: { + const tmp = i; + if (tmp >= 0) break :blk model.bindPose + @as(usize, @intCast(tmp)) else break :blk model.bindPose - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.rotation.w = 1.0; + (blk: { + const tmp = i; + if (tmp >= 0) break :blk model.bindPose + @as(usize, @intCast(tmp)) else break :blk model.bindPose - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.scale.x = blk: { + const tmp = blk_1: { + const tmp_2 = 1.0; + (blk_2: { + const tmp_3 = i; + if (tmp_3 >= 0) break :blk_2 model.bindPose + @as(usize, @intCast(tmp_3)) else break :blk_2 model.bindPose - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_3)) +% -1)); + }).*.scale.z = tmp_2; + break :blk_1 tmp_2; + }; + (blk_1: { + const tmp_2 = i; + if (tmp_2 >= 0) break :blk_1 model.bindPose + @as(usize, @intCast(tmp_2)) else break :blk_1 model.bindPose - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.scale.y = tmp; + break :blk tmp; + }; + } + if ((m3d.*.numbone != 0) and (m3d.*.numskin != 0)) { + { + i = 0; + while (i < model.meshCount) : (i += 1) { + _ = memcpy(@as(?*anyopaque, @ptrCast((blk: { + const tmp = i; + if (tmp >= 0) break :blk model.meshes + @as(usize, @intCast(tmp)) else break :blk model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.animVertices)), @as(?*const anyopaque, @ptrCast((blk: { + const tmp = i; + if (tmp >= 0) break :blk model.meshes + @as(usize, @intCast(tmp)) else break :blk model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.vertices)), @as(c_ulong, @bitCast(@as(c_long, (blk: { + const tmp = i; + if (tmp >= 0) break :blk model.meshes + @as(usize, @intCast(tmp)) else break :blk model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.vertexCount * @as(c_int, 3)))) *% @sizeOf(f32)); + _ = memcpy(@as(?*anyopaque, @ptrCast((blk: { + const tmp = i; + if (tmp >= 0) break :blk model.meshes + @as(usize, @intCast(tmp)) else break :blk model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.animNormals)), @as(?*const anyopaque, @ptrCast((blk: { + const tmp = i; + if (tmp >= 0) break :blk model.meshes + @as(usize, @intCast(tmp)) else break :blk model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.normals)), @as(c_ulong, @bitCast(@as(c_long, (blk: { + const tmp = i; + if (tmp >= 0) break :blk model.meshes + @as(usize, @intCast(tmp)) else break :blk model.meshes - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.vertexCount * @as(c_int, 3)))) *% @sizeOf(f32)); + } + } + } + m3d_free(m3d); + UnloadFileData(fileData); + } + return model; +} +pub fn LoadModelAnimationsM3D(arg_fileName: [*c]const u8, arg_animCount: [*c]c_int) callconv(.C) [*c]ModelAnimation { + var fileName = arg_fileName; + _ = &fileName; + var animCount = arg_animCount; + _ = &animCount; + var animations: [*c]ModelAnimation = null; + _ = &animations; + var m3d: [*c]m3d_t = null; + _ = &m3d; + var i: c_int = 0; + _ = &i; + var j: c_int = 0; + _ = &j; + animCount.* = 0; + var dataSize: c_int = 0; + _ = &dataSize; + var fileData: [*c]u8 = LoadFileData(fileName, &dataSize); + _ = &fileData; + if (fileData != @as([*c]u8, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0))))))) { + m3d = m3d_load(fileData, &m3d_loaderhook, &m3d_freehook, null); + if (!(m3d != null) or ((@as(c_int, @bitCast(@as(c_int, m3d.*.errcode))) < @as(c_int, 0)) and (@as(c_int, @bitCast(@as(c_int, m3d.*.errcode))) > -@as(c_int, 65)))) { + TraceLog(LOG_WARNING, "MODEL: [%s] Failed to load M3D data, error code %d", fileName, if (m3d != null) @as(c_int, @bitCast(@as(c_int, m3d.*.errcode))) else -@as(c_int, 2)); + UnloadFileData(fileData); + return null; + } else { + TraceLog(LOG_INFO, "MODEL: [%s] M3D data loaded successfully: %i animations, %i bones, %i skins", fileName, m3d.*.numaction, m3d.*.numbone, m3d.*.numskin); + } + if ((!(m3d.*.numaction != 0) or !(m3d.*.numbone != 0)) or !(m3d.*.numskin != 0)) { + m3d_free(m3d); + UnloadFileData(fileData); + return null; + } + animations = @as([*c]ModelAnimation, @ptrCast(@alignCast(malloc(@as(c_ulong, @bitCast(@as(c_ulong, m3d.*.numaction))) *% @sizeOf(ModelAnimation))))); + animCount.* = @as(c_int, @bitCast(m3d.*.numaction)); + { + var a: c_uint = 0; + _ = &a; + while (a < m3d.*.numaction) : (a +%= 1) { + animations[a].frameCount = @as(c_int, @bitCast(m3d.*.action[a].durationmsec / @as(u32, @bitCast(@as(c_int, 17))))); + animations[a].boneCount = @as(c_int, @bitCast(m3d.*.numbone +% @as(M3D_INDEX, @bitCast(@as(c_int, 1))))); + animations[a].bones = @as([*c]BoneInfo, @ptrCast(@alignCast(malloc(@as(c_ulong, @bitCast(@as(c_ulong, m3d.*.numbone +% @as(M3D_INDEX, @bitCast(@as(c_int, 1)))))) *% @sizeOf(BoneInfo))))); + animations[a].framePoses = @as([*c][*c]Transform, @ptrCast(@alignCast(malloc(@as(c_ulong, @bitCast(@as(c_long, animations[a].frameCount))) *% @sizeOf([*c]Transform))))); + _ = strncpy(@as([*c]u8, @ptrCast(@alignCast(&animations[a].name))), m3d.*.action[a].name, @sizeOf([32]u8)); + animations[a].name[@sizeOf([32]u8) -% @as(c_ulong, @bitCast(@as(c_long, @as(c_int, 1))))] = '\x00'; + TraceLog(LOG_INFO, "MODEL: [%s] animation #%i: %i msec, %i frames", fileName, a, m3d.*.action[a].durationmsec, animations[a].frameCount); + { + i = 0; + while (i < @as(c_int, @bitCast(m3d.*.numbone))) : (i += 1) { + (blk: { + const tmp = i; + if (tmp >= 0) break :blk animations[a].bones + @as(usize, @intCast(tmp)) else break :blk animations[a].bones - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.parent = @as(c_int, @bitCast((blk: { + const tmp = i; + if (tmp >= 0) break :blk m3d.*.bone + @as(usize, @intCast(tmp)) else break :blk m3d.*.bone - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.parent)); + _ = strncpy(@as([*c]u8, @ptrCast(@alignCast(&(blk: { + const tmp = i; + if (tmp >= 0) break :blk animations[a].bones + @as(usize, @intCast(tmp)) else break :blk animations[a].bones - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.name))), (blk: { + const tmp = i; + if (tmp >= 0) break :blk m3d.*.bone + @as(usize, @intCast(tmp)) else break :blk m3d.*.bone - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.name, @sizeOf([32]u8)); + } + } + (blk: { + const tmp = i; + if (tmp >= 0) break :blk animations[a].bones + @as(usize, @intCast(tmp)) else break :blk animations[a].bones - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.parent = -@as(c_int, 1); + _ = strcpy(@as([*c]u8, @ptrCast(@alignCast(&(blk: { + const tmp = i; + if (tmp >= 0) break :blk animations[a].bones + @as(usize, @intCast(tmp)) else break :blk animations[a].bones - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.name))), "NO BONE"); + { + i = 0; + while (i < animations[a].frameCount) : (i += 1) { + (blk: { + const tmp = i; + if (tmp >= 0) break :blk animations[a].framePoses + @as(usize, @intCast(tmp)) else break :blk animations[a].framePoses - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = @as([*c]Transform, @ptrCast(@alignCast(malloc(@as(c_ulong, @bitCast(@as(c_ulong, m3d.*.numbone +% @as(M3D_INDEX, @bitCast(@as(c_int, 1)))))) *% @sizeOf(Transform))))); + var pose: [*c]m3db_t = m3d_pose(m3d, a, @as(u32, @bitCast(i * @as(c_int, 17)))); + _ = &pose; + if (pose != @as([*c]m3db_t, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0))))))) { + { + j = 0; + while (j < @as(c_int, @bitCast(m3d.*.numbone))) : (j += 1) { + (blk: { + const tmp = j; + if (tmp >= 0) break :blk (blk_1: { + const tmp_2 = i; + if (tmp_2 >= 0) break :blk_1 animations[a].framePoses + @as(usize, @intCast(tmp_2)) else break :blk_1 animations[a].framePoses - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).* + @as(usize, @intCast(tmp)) else break :blk (blk_1: { + const tmp_2 = i; + if (tmp_2 >= 0) break :blk_1 animations[a].framePoses + @as(usize, @intCast(tmp_2)) else break :blk_1 animations[a].framePoses - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).* - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.translation.x = m3d.*.vertex[(blk: { + const tmp = j; + if (tmp >= 0) break :blk pose + @as(usize, @intCast(tmp)) else break :blk pose - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.pos].x * m3d.*.scale; + (blk: { + const tmp = j; + if (tmp >= 0) break :blk (blk_1: { + const tmp_2 = i; + if (tmp_2 >= 0) break :blk_1 animations[a].framePoses + @as(usize, @intCast(tmp_2)) else break :blk_1 animations[a].framePoses - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).* + @as(usize, @intCast(tmp)) else break :blk (blk_1: { + const tmp_2 = i; + if (tmp_2 >= 0) break :blk_1 animations[a].framePoses + @as(usize, @intCast(tmp_2)) else break :blk_1 animations[a].framePoses - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).* - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.translation.y = m3d.*.vertex[(blk: { + const tmp = j; + if (tmp >= 0) break :blk pose + @as(usize, @intCast(tmp)) else break :blk pose - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.pos].y * m3d.*.scale; + (blk: { + const tmp = j; + if (tmp >= 0) break :blk (blk_1: { + const tmp_2 = i; + if (tmp_2 >= 0) break :blk_1 animations[a].framePoses + @as(usize, @intCast(tmp_2)) else break :blk_1 animations[a].framePoses - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).* + @as(usize, @intCast(tmp)) else break :blk (blk_1: { + const tmp_2 = i; + if (tmp_2 >= 0) break :blk_1 animations[a].framePoses + @as(usize, @intCast(tmp_2)) else break :blk_1 animations[a].framePoses - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).* - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.translation.z = m3d.*.vertex[(blk: { + const tmp = j; + if (tmp >= 0) break :blk pose + @as(usize, @intCast(tmp)) else break :blk pose - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.pos].z * m3d.*.scale; + (blk: { + const tmp = j; + if (tmp >= 0) break :blk (blk_1: { + const tmp_2 = i; + if (tmp_2 >= 0) break :blk_1 animations[a].framePoses + @as(usize, @intCast(tmp_2)) else break :blk_1 animations[a].framePoses - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).* + @as(usize, @intCast(tmp)) else break :blk (blk_1: { + const tmp_2 = i; + if (tmp_2 >= 0) break :blk_1 animations[a].framePoses + @as(usize, @intCast(tmp_2)) else break :blk_1 animations[a].framePoses - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).* - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.rotation.x = m3d.*.vertex[(blk: { + const tmp = j; + if (tmp >= 0) break :blk pose + @as(usize, @intCast(tmp)) else break :blk pose - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.ori].x; + (blk: { + const tmp = j; + if (tmp >= 0) break :blk (blk_1: { + const tmp_2 = i; + if (tmp_2 >= 0) break :blk_1 animations[a].framePoses + @as(usize, @intCast(tmp_2)) else break :blk_1 animations[a].framePoses - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).* + @as(usize, @intCast(tmp)) else break :blk (blk_1: { + const tmp_2 = i; + if (tmp_2 >= 0) break :blk_1 animations[a].framePoses + @as(usize, @intCast(tmp_2)) else break :blk_1 animations[a].framePoses - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).* - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.rotation.y = m3d.*.vertex[(blk: { + const tmp = j; + if (tmp >= 0) break :blk pose + @as(usize, @intCast(tmp)) else break :blk pose - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.ori].y; + (blk: { + const tmp = j; + if (tmp >= 0) break :blk (blk_1: { + const tmp_2 = i; + if (tmp_2 >= 0) break :blk_1 animations[a].framePoses + @as(usize, @intCast(tmp_2)) else break :blk_1 animations[a].framePoses - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).* + @as(usize, @intCast(tmp)) else break :blk (blk_1: { + const tmp_2 = i; + if (tmp_2 >= 0) break :blk_1 animations[a].framePoses + @as(usize, @intCast(tmp_2)) else break :blk_1 animations[a].framePoses - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).* - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.rotation.z = m3d.*.vertex[(blk: { + const tmp = j; + if (tmp >= 0) break :blk pose + @as(usize, @intCast(tmp)) else break :blk pose - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.ori].z; + (blk: { + const tmp = j; + if (tmp >= 0) break :blk (blk_1: { + const tmp_2 = i; + if (tmp_2 >= 0) break :blk_1 animations[a].framePoses + @as(usize, @intCast(tmp_2)) else break :blk_1 animations[a].framePoses - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).* + @as(usize, @intCast(tmp)) else break :blk (blk_1: { + const tmp_2 = i; + if (tmp_2 >= 0) break :blk_1 animations[a].framePoses + @as(usize, @intCast(tmp_2)) else break :blk_1 animations[a].framePoses - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).* - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.rotation.w = m3d.*.vertex[(blk: { + const tmp = j; + if (tmp >= 0) break :blk pose + @as(usize, @intCast(tmp)) else break :blk pose - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.ori].w; + (blk: { + const tmp = j; + if (tmp >= 0) break :blk (blk_1: { + const tmp_2 = i; + if (tmp_2 >= 0) break :blk_1 animations[a].framePoses + @as(usize, @intCast(tmp_2)) else break :blk_1 animations[a].framePoses - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).* + @as(usize, @intCast(tmp)) else break :blk (blk_1: { + const tmp_2 = i; + if (tmp_2 >= 0) break :blk_1 animations[a].framePoses + @as(usize, @intCast(tmp_2)) else break :blk_1 animations[a].framePoses - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).* - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.rotation = QuaternionNormalize((blk: { + const tmp = j; + if (tmp >= 0) break :blk (blk_1: { + const tmp_2 = i; + if (tmp_2 >= 0) break :blk_1 animations[a].framePoses + @as(usize, @intCast(tmp_2)) else break :blk_1 animations[a].framePoses - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).* + @as(usize, @intCast(tmp)) else break :blk (blk_1: { + const tmp_2 = i; + if (tmp_2 >= 0) break :blk_1 animations[a].framePoses + @as(usize, @intCast(tmp_2)) else break :blk_1 animations[a].framePoses - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).* - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.rotation); + (blk: { + const tmp = j; + if (tmp >= 0) break :blk (blk_1: { + const tmp_2 = i; + if (tmp_2 >= 0) break :blk_1 animations[a].framePoses + @as(usize, @intCast(tmp_2)) else break :blk_1 animations[a].framePoses - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).* + @as(usize, @intCast(tmp)) else break :blk (blk_1: { + const tmp_2 = i; + if (tmp_2 >= 0) break :blk_1 animations[a].framePoses + @as(usize, @intCast(tmp_2)) else break :blk_1 animations[a].framePoses - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).* - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.scale.x = blk: { + const tmp = blk_1: { + const tmp_2 = 1.0; + (blk_2: { + const tmp_3 = j; + if (tmp_3 >= 0) break :blk_2 (blk_3: { + const tmp_4 = i; + if (tmp_4 >= 0) break :blk_3 animations[a].framePoses + @as(usize, @intCast(tmp_4)) else break :blk_3 animations[a].framePoses - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_4)) +% -1)); + }).* + @as(usize, @intCast(tmp_3)) else break :blk_2 (blk_3: { + const tmp_4 = i; + if (tmp_4 >= 0) break :blk_3 animations[a].framePoses + @as(usize, @intCast(tmp_4)) else break :blk_3 animations[a].framePoses - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_4)) +% -1)); + }).* - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_3)) +% -1)); + }).*.scale.z = tmp_2; + break :blk_1 tmp_2; + }; + (blk_1: { + const tmp_2 = j; + if (tmp_2 >= 0) break :blk_1 (blk_2: { + const tmp_3 = i; + if (tmp_3 >= 0) break :blk_2 animations[a].framePoses + @as(usize, @intCast(tmp_3)) else break :blk_2 animations[a].framePoses - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_3)) +% -1)); + }).* + @as(usize, @intCast(tmp_2)) else break :blk_1 (blk_2: { + const tmp_3 = i; + if (tmp_3 >= 0) break :blk_2 animations[a].framePoses + @as(usize, @intCast(tmp_3)) else break :blk_2 animations[a].framePoses - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_3)) +% -1)); + }).* - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.scale.y = tmp; + break :blk tmp; + }; + if ((blk: { + const tmp = j; + if (tmp >= 0) break :blk animations[a].bones + @as(usize, @intCast(tmp)) else break :blk animations[a].bones - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.parent >= @as(c_int, 0)) { + (blk: { + const tmp = j; + if (tmp >= 0) break :blk (blk_1: { + const tmp_2 = i; + if (tmp_2 >= 0) break :blk_1 animations[a].framePoses + @as(usize, @intCast(tmp_2)) else break :blk_1 animations[a].framePoses - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).* + @as(usize, @intCast(tmp)) else break :blk (blk_1: { + const tmp_2 = i; + if (tmp_2 >= 0) break :blk_1 animations[a].framePoses + @as(usize, @intCast(tmp_2)) else break :blk_1 animations[a].framePoses - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).* - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.rotation = QuaternionMultiply((blk: { + const tmp = (blk_1: { + const tmp_2 = j; + if (tmp_2 >= 0) break :blk_1 animations[a].bones + @as(usize, @intCast(tmp_2)) else break :blk_1 animations[a].bones - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.parent; + if (tmp >= 0) break :blk (blk_1: { + const tmp_2 = i; + if (tmp_2 >= 0) break :blk_1 animations[a].framePoses + @as(usize, @intCast(tmp_2)) else break :blk_1 animations[a].framePoses - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).* + @as(usize, @intCast(tmp)) else break :blk (blk_1: { + const tmp_2 = i; + if (tmp_2 >= 0) break :blk_1 animations[a].framePoses + @as(usize, @intCast(tmp_2)) else break :blk_1 animations[a].framePoses - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).* - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.rotation, (blk: { + const tmp = j; + if (tmp >= 0) break :blk (blk_1: { + const tmp_2 = i; + if (tmp_2 >= 0) break :blk_1 animations[a].framePoses + @as(usize, @intCast(tmp_2)) else break :blk_1 animations[a].framePoses - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).* + @as(usize, @intCast(tmp)) else break :blk (blk_1: { + const tmp_2 = i; + if (tmp_2 >= 0) break :blk_1 animations[a].framePoses + @as(usize, @intCast(tmp_2)) else break :blk_1 animations[a].framePoses - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).* - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.rotation); + (blk: { + const tmp = j; + if (tmp >= 0) break :blk (blk_1: { + const tmp_2 = i; + if (tmp_2 >= 0) break :blk_1 animations[a].framePoses + @as(usize, @intCast(tmp_2)) else break :blk_1 animations[a].framePoses - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).* + @as(usize, @intCast(tmp)) else break :blk (blk_1: { + const tmp_2 = i; + if (tmp_2 >= 0) break :blk_1 animations[a].framePoses + @as(usize, @intCast(tmp_2)) else break :blk_1 animations[a].framePoses - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).* - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.translation = Vector3RotateByQuaternion((blk: { + const tmp = j; + if (tmp >= 0) break :blk (blk_1: { + const tmp_2 = i; + if (tmp_2 >= 0) break :blk_1 animations[a].framePoses + @as(usize, @intCast(tmp_2)) else break :blk_1 animations[a].framePoses - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).* + @as(usize, @intCast(tmp)) else break :blk (blk_1: { + const tmp_2 = i; + if (tmp_2 >= 0) break :blk_1 animations[a].framePoses + @as(usize, @intCast(tmp_2)) else break :blk_1 animations[a].framePoses - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).* - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.translation, (blk: { + const tmp = (blk_1: { + const tmp_2 = j; + if (tmp_2 >= 0) break :blk_1 animations[a].bones + @as(usize, @intCast(tmp_2)) else break :blk_1 animations[a].bones - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.parent; + if (tmp >= 0) break :blk (blk_1: { + const tmp_2 = i; + if (tmp_2 >= 0) break :blk_1 animations[a].framePoses + @as(usize, @intCast(tmp_2)) else break :blk_1 animations[a].framePoses - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).* + @as(usize, @intCast(tmp)) else break :blk (blk_1: { + const tmp_2 = i; + if (tmp_2 >= 0) break :blk_1 animations[a].framePoses + @as(usize, @intCast(tmp_2)) else break :blk_1 animations[a].framePoses - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).* - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.rotation); + (blk: { + const tmp = j; + if (tmp >= 0) break :blk (blk_1: { + const tmp_2 = i; + if (tmp_2 >= 0) break :blk_1 animations[a].framePoses + @as(usize, @intCast(tmp_2)) else break :blk_1 animations[a].framePoses - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).* + @as(usize, @intCast(tmp)) else break :blk (blk_1: { + const tmp_2 = i; + if (tmp_2 >= 0) break :blk_1 animations[a].framePoses + @as(usize, @intCast(tmp_2)) else break :blk_1 animations[a].framePoses - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).* - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.translation = Vector3Add((blk: { + const tmp = j; + if (tmp >= 0) break :blk (blk_1: { + const tmp_2 = i; + if (tmp_2 >= 0) break :blk_1 animations[a].framePoses + @as(usize, @intCast(tmp_2)) else break :blk_1 animations[a].framePoses - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).* + @as(usize, @intCast(tmp)) else break :blk (blk_1: { + const tmp_2 = i; + if (tmp_2 >= 0) break :blk_1 animations[a].framePoses + @as(usize, @intCast(tmp_2)) else break :blk_1 animations[a].framePoses - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).* - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.translation, (blk: { + const tmp = (blk_1: { + const tmp_2 = j; + if (tmp_2 >= 0) break :blk_1 animations[a].bones + @as(usize, @intCast(tmp_2)) else break :blk_1 animations[a].bones - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.parent; + if (tmp >= 0) break :blk (blk_1: { + const tmp_2 = i; + if (tmp_2 >= 0) break :blk_1 animations[a].framePoses + @as(usize, @intCast(tmp_2)) else break :blk_1 animations[a].framePoses - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).* + @as(usize, @intCast(tmp)) else break :blk (blk_1: { + const tmp_2 = i; + if (tmp_2 >= 0) break :blk_1 animations[a].framePoses + @as(usize, @intCast(tmp_2)) else break :blk_1 animations[a].framePoses - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).* - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.translation); + (blk: { + const tmp = j; + if (tmp >= 0) break :blk (blk_1: { + const tmp_2 = i; + if (tmp_2 >= 0) break :blk_1 animations[a].framePoses + @as(usize, @intCast(tmp_2)) else break :blk_1 animations[a].framePoses - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).* + @as(usize, @intCast(tmp)) else break :blk (blk_1: { + const tmp_2 = i; + if (tmp_2 >= 0) break :blk_1 animations[a].framePoses + @as(usize, @intCast(tmp_2)) else break :blk_1 animations[a].framePoses - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).* - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.scale = Vector3Multiply((blk: { + const tmp = j; + if (tmp >= 0) break :blk (blk_1: { + const tmp_2 = i; + if (tmp_2 >= 0) break :blk_1 animations[a].framePoses + @as(usize, @intCast(tmp_2)) else break :blk_1 animations[a].framePoses - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).* + @as(usize, @intCast(tmp)) else break :blk (blk_1: { + const tmp_2 = i; + if (tmp_2 >= 0) break :blk_1 animations[a].framePoses + @as(usize, @intCast(tmp_2)) else break :blk_1 animations[a].framePoses - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).* - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.scale, (blk: { + const tmp = (blk_1: { + const tmp_2 = j; + if (tmp_2 >= 0) break :blk_1 animations[a].bones + @as(usize, @intCast(tmp_2)) else break :blk_1 animations[a].bones - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.parent; + if (tmp >= 0) break :blk (blk_1: { + const tmp_2 = i; + if (tmp_2 >= 0) break :blk_1 animations[a].framePoses + @as(usize, @intCast(tmp_2)) else break :blk_1 animations[a].framePoses - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).* + @as(usize, @intCast(tmp)) else break :blk (blk_1: { + const tmp_2 = i; + if (tmp_2 >= 0) break :blk_1 animations[a].framePoses + @as(usize, @intCast(tmp_2)) else break :blk_1 animations[a].framePoses - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).* - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.scale); + } + } + } + (blk: { + const tmp = j; + if (tmp >= 0) break :blk (blk_1: { + const tmp_2 = i; + if (tmp_2 >= 0) break :blk_1 animations[a].framePoses + @as(usize, @intCast(tmp_2)) else break :blk_1 animations[a].framePoses - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).* + @as(usize, @intCast(tmp)) else break :blk (blk_1: { + const tmp_2 = i; + if (tmp_2 >= 0) break :blk_1 animations[a].framePoses + @as(usize, @intCast(tmp_2)) else break :blk_1 animations[a].framePoses - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).* - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.translation.x = 0.0; + (blk: { + const tmp = j; + if (tmp >= 0) break :blk (blk_1: { + const tmp_2 = i; + if (tmp_2 >= 0) break :blk_1 animations[a].framePoses + @as(usize, @intCast(tmp_2)) else break :blk_1 animations[a].framePoses - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).* + @as(usize, @intCast(tmp)) else break :blk (blk_1: { + const tmp_2 = i; + if (tmp_2 >= 0) break :blk_1 animations[a].framePoses + @as(usize, @intCast(tmp_2)) else break :blk_1 animations[a].framePoses - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).* - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.translation.y = 0.0; + (blk: { + const tmp = j; + if (tmp >= 0) break :blk (blk_1: { + const tmp_2 = i; + if (tmp_2 >= 0) break :blk_1 animations[a].framePoses + @as(usize, @intCast(tmp_2)) else break :blk_1 animations[a].framePoses - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).* + @as(usize, @intCast(tmp)) else break :blk (blk_1: { + const tmp_2 = i; + if (tmp_2 >= 0) break :blk_1 animations[a].framePoses + @as(usize, @intCast(tmp_2)) else break :blk_1 animations[a].framePoses - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).* - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.translation.z = 0.0; + (blk: { + const tmp = j; + if (tmp >= 0) break :blk (blk_1: { + const tmp_2 = i; + if (tmp_2 >= 0) break :blk_1 animations[a].framePoses + @as(usize, @intCast(tmp_2)) else break :blk_1 animations[a].framePoses - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).* + @as(usize, @intCast(tmp)) else break :blk (blk_1: { + const tmp_2 = i; + if (tmp_2 >= 0) break :blk_1 animations[a].framePoses + @as(usize, @intCast(tmp_2)) else break :blk_1 animations[a].framePoses - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).* - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.rotation.x = 0.0; + (blk: { + const tmp = j; + if (tmp >= 0) break :blk (blk_1: { + const tmp_2 = i; + if (tmp_2 >= 0) break :blk_1 animations[a].framePoses + @as(usize, @intCast(tmp_2)) else break :blk_1 animations[a].framePoses - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).* + @as(usize, @intCast(tmp)) else break :blk (blk_1: { + const tmp_2 = i; + if (tmp_2 >= 0) break :blk_1 animations[a].framePoses + @as(usize, @intCast(tmp_2)) else break :blk_1 animations[a].framePoses - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).* - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.rotation.y = 0.0; + (blk: { + const tmp = j; + if (tmp >= 0) break :blk (blk_1: { + const tmp_2 = i; + if (tmp_2 >= 0) break :blk_1 animations[a].framePoses + @as(usize, @intCast(tmp_2)) else break :blk_1 animations[a].framePoses - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).* + @as(usize, @intCast(tmp)) else break :blk (blk_1: { + const tmp_2 = i; + if (tmp_2 >= 0) break :blk_1 animations[a].framePoses + @as(usize, @intCast(tmp_2)) else break :blk_1 animations[a].framePoses - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).* - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.rotation.z = 0.0; + (blk: { + const tmp = j; + if (tmp >= 0) break :blk (blk_1: { + const tmp_2 = i; + if (tmp_2 >= 0) break :blk_1 animations[a].framePoses + @as(usize, @intCast(tmp_2)) else break :blk_1 animations[a].framePoses - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).* + @as(usize, @intCast(tmp)) else break :blk (blk_1: { + const tmp_2 = i; + if (tmp_2 >= 0) break :blk_1 animations[a].framePoses + @as(usize, @intCast(tmp_2)) else break :blk_1 animations[a].framePoses - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).* - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.rotation.w = 1.0; + (blk: { + const tmp = j; + if (tmp >= 0) break :blk (blk_1: { + const tmp_2 = i; + if (tmp_2 >= 0) break :blk_1 animations[a].framePoses + @as(usize, @intCast(tmp_2)) else break :blk_1 animations[a].framePoses - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).* + @as(usize, @intCast(tmp)) else break :blk (blk_1: { + const tmp_2 = i; + if (tmp_2 >= 0) break :blk_1 animations[a].framePoses + @as(usize, @intCast(tmp_2)) else break :blk_1 animations[a].framePoses - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).* - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.scale.x = blk: { + const tmp = blk_1: { + const tmp_2 = 1.0; + (blk_2: { + const tmp_3 = j; + if (tmp_3 >= 0) break :blk_2 (blk_3: { + const tmp_4 = i; + if (tmp_4 >= 0) break :blk_3 animations[a].framePoses + @as(usize, @intCast(tmp_4)) else break :blk_3 animations[a].framePoses - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_4)) +% -1)); + }).* + @as(usize, @intCast(tmp_3)) else break :blk_2 (blk_3: { + const tmp_4 = i; + if (tmp_4 >= 0) break :blk_3 animations[a].framePoses + @as(usize, @intCast(tmp_4)) else break :blk_3 animations[a].framePoses - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_4)) +% -1)); + }).* - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_3)) +% -1)); + }).*.scale.z = tmp_2; + break :blk_1 tmp_2; + }; + (blk_1: { + const tmp_2 = j; + if (tmp_2 >= 0) break :blk_1 (blk_2: { + const tmp_3 = i; + if (tmp_3 >= 0) break :blk_2 animations[a].framePoses + @as(usize, @intCast(tmp_3)) else break :blk_2 animations[a].framePoses - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_3)) +% -1)); + }).* + @as(usize, @intCast(tmp_2)) else break :blk_1 (blk_2: { + const tmp_3 = i; + if (tmp_3 >= 0) break :blk_2 animations[a].framePoses + @as(usize, @intCast(tmp_3)) else break :blk_2 animations[a].framePoses - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_3)) +% -1)); + }).* - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.scale.y = tmp; + break :blk tmp; + }; + free(@as(?*anyopaque, @ptrCast(pose))); + } + } + } + } + } + m3d_free(m3d); + UnloadFileData(fileData); + } + return animations; +} +pub fn ProcessMaterialsOBJ(arg_materials: [*c]Material, arg_mats: [*c]tinyobj_material_t, arg_materialCount: c_int) callconv(.C) void { + var materials = arg_materials; + _ = &materials; + var mats = arg_mats; + _ = &mats; + var materialCount = arg_materialCount; + _ = &materialCount; + { + var m: c_int = 0; + _ = &m; + while (m < materialCount) : (m += 1) { + (blk: { + const tmp = m; + if (tmp >= 0) break :blk materials + @as(usize, @intCast(tmp)) else break :blk materials - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = LoadMaterialDefault(); + if (mats == @as([*c]tinyobj_material_t, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0))))))) continue; + (blk: { + const tmp = MATERIAL_MAP_ALBEDO; + if (tmp >= 0) break :blk (blk_1: { + const tmp_2 = m; + if (tmp_2 >= 0) break :blk_1 materials + @as(usize, @intCast(tmp_2)) else break :blk_1 materials - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.maps + @as(usize, @intCast(tmp)) else break :blk (blk_1: { + const tmp_2 = m; + if (tmp_2 >= 0) break :blk_1 materials + @as(usize, @intCast(tmp_2)) else break :blk_1 materials - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.maps - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.texture = Texture2D{ + .id = rlGetTextureIdDefault(), + .width = @as(c_int, 1), + .height = @as(c_int, 1), + .mipmaps = @as(c_int, 1), + .format = PIXELFORMAT_UNCOMPRESSED_R8G8B8A8, + }; + if ((blk: { + const tmp = m; + if (tmp >= 0) break :blk mats + @as(usize, @intCast(tmp)) else break :blk mats - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.diffuse_texname != @as([*c]u8, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0))))))) { + (blk: { + const tmp = MATERIAL_MAP_ALBEDO; + if (tmp >= 0) break :blk (blk_1: { + const tmp_2 = m; + if (tmp_2 >= 0) break :blk_1 materials + @as(usize, @intCast(tmp_2)) else break :blk_1 materials - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.maps + @as(usize, @intCast(tmp)) else break :blk (blk_1: { + const tmp_2 = m; + if (tmp_2 >= 0) break :blk_1 materials + @as(usize, @intCast(tmp_2)) else break :blk_1 materials - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.maps - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.texture = LoadTexture((blk: { + const tmp = m; + if (tmp >= 0) break :blk mats + @as(usize, @intCast(tmp)) else break :blk mats - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.diffuse_texname); + } else { + (blk: { + const tmp = MATERIAL_MAP_ALBEDO; + if (tmp >= 0) break :blk (blk_1: { + const tmp_2 = m; + if (tmp_2 >= 0) break :blk_1 materials + @as(usize, @intCast(tmp_2)) else break :blk_1 materials - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.maps + @as(usize, @intCast(tmp)) else break :blk (blk_1: { + const tmp_2 = m; + if (tmp_2 >= 0) break :blk_1 materials + @as(usize, @intCast(tmp_2)) else break :blk_1 materials - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.maps - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.color = Color{ + .r = @as(u8, @intFromFloat((blk: { + const tmp = m; + if (tmp >= 0) break :blk mats + @as(usize, @intCast(tmp)) else break :blk mats - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.diffuse[@as(c_uint, @intCast(@as(c_int, 0)))] * 255.0)), + .g = @as(u8, @intFromFloat((blk: { + const tmp = m; + if (tmp >= 0) break :blk mats + @as(usize, @intCast(tmp)) else break :blk mats - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.diffuse[@as(c_uint, @intCast(@as(c_int, 1)))] * 255.0)), + .b = @as(u8, @intFromFloat((blk: { + const tmp = m; + if (tmp >= 0) break :blk mats + @as(usize, @intCast(tmp)) else break :blk mats - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.diffuse[@as(c_uint, @intCast(@as(c_int, 2)))] * 255.0)), + .a = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 255))))), + }; + } + (blk: { + const tmp = MATERIAL_MAP_ALBEDO; + if (tmp >= 0) break :blk (blk_1: { + const tmp_2 = m; + if (tmp_2 >= 0) break :blk_1 materials + @as(usize, @intCast(tmp_2)) else break :blk_1 materials - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.maps + @as(usize, @intCast(tmp)) else break :blk (blk_1: { + const tmp_2 = m; + if (tmp_2 >= 0) break :blk_1 materials + @as(usize, @intCast(tmp_2)) else break :blk_1 materials - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.maps - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.value = 0.0; + if ((blk: { + const tmp = m; + if (tmp >= 0) break :blk mats + @as(usize, @intCast(tmp)) else break :blk mats - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.specular_texname != @as([*c]u8, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0))))))) { + (blk: { + const tmp = MATERIAL_MAP_METALNESS; + if (tmp >= 0) break :blk (blk_1: { + const tmp_2 = m; + if (tmp_2 >= 0) break :blk_1 materials + @as(usize, @intCast(tmp_2)) else break :blk_1 materials - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.maps + @as(usize, @intCast(tmp)) else break :blk (blk_1: { + const tmp_2 = m; + if (tmp_2 >= 0) break :blk_1 materials + @as(usize, @intCast(tmp_2)) else break :blk_1 materials - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.maps - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.texture = LoadTexture((blk: { + const tmp = m; + if (tmp >= 0) break :blk mats + @as(usize, @intCast(tmp)) else break :blk mats - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.specular_texname); + } + (blk: { + const tmp = MATERIAL_MAP_METALNESS; + if (tmp >= 0) break :blk (blk_1: { + const tmp_2 = m; + if (tmp_2 >= 0) break :blk_1 materials + @as(usize, @intCast(tmp_2)) else break :blk_1 materials - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.maps + @as(usize, @intCast(tmp)) else break :blk (blk_1: { + const tmp_2 = m; + if (tmp_2 >= 0) break :blk_1 materials + @as(usize, @intCast(tmp_2)) else break :blk_1 materials - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.maps - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.color = Color{ + .r = @as(u8, @intFromFloat((blk: { + const tmp = m; + if (tmp >= 0) break :blk mats + @as(usize, @intCast(tmp)) else break :blk mats - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.specular[@as(c_uint, @intCast(@as(c_int, 0)))] * 255.0)), + .g = @as(u8, @intFromFloat((blk: { + const tmp = m; + if (tmp >= 0) break :blk mats + @as(usize, @intCast(tmp)) else break :blk mats - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.specular[@as(c_uint, @intCast(@as(c_int, 1)))] * 255.0)), + .b = @as(u8, @intFromFloat((blk: { + const tmp = m; + if (tmp >= 0) break :blk mats + @as(usize, @intCast(tmp)) else break :blk mats - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.specular[@as(c_uint, @intCast(@as(c_int, 2)))] * 255.0)), + .a = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 255))))), + }; + (blk: { + const tmp = MATERIAL_MAP_METALNESS; + if (tmp >= 0) break :blk (blk_1: { + const tmp_2 = m; + if (tmp_2 >= 0) break :blk_1 materials + @as(usize, @intCast(tmp_2)) else break :blk_1 materials - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.maps + @as(usize, @intCast(tmp)) else break :blk (blk_1: { + const tmp_2 = m; + if (tmp_2 >= 0) break :blk_1 materials + @as(usize, @intCast(tmp_2)) else break :blk_1 materials - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.maps - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.value = 0.0; + if ((blk: { + const tmp = m; + if (tmp >= 0) break :blk mats + @as(usize, @intCast(tmp)) else break :blk mats - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.bump_texname != @as([*c]u8, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0))))))) { + (blk: { + const tmp = MATERIAL_MAP_NORMAL; + if (tmp >= 0) break :blk (blk_1: { + const tmp_2 = m; + if (tmp_2 >= 0) break :blk_1 materials + @as(usize, @intCast(tmp_2)) else break :blk_1 materials - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.maps + @as(usize, @intCast(tmp)) else break :blk (blk_1: { + const tmp_2 = m; + if (tmp_2 >= 0) break :blk_1 materials + @as(usize, @intCast(tmp_2)) else break :blk_1 materials - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.maps - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.texture = LoadTexture((blk: { + const tmp = m; + if (tmp >= 0) break :blk mats + @as(usize, @intCast(tmp)) else break :blk mats - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.bump_texname); + } + (blk: { + const tmp = MATERIAL_MAP_NORMAL; + if (tmp >= 0) break :blk (blk_1: { + const tmp_2 = m; + if (tmp_2 >= 0) break :blk_1 materials + @as(usize, @intCast(tmp_2)) else break :blk_1 materials - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.maps + @as(usize, @intCast(tmp)) else break :blk (blk_1: { + const tmp_2 = m; + if (tmp_2 >= 0) break :blk_1 materials + @as(usize, @intCast(tmp_2)) else break :blk_1 materials - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.maps - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.color = Color{ + .r = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 255))))), + .g = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 255))))), + .b = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 255))))), + .a = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 255))))), + }; + (blk: { + const tmp = MATERIAL_MAP_NORMAL; + if (tmp >= 0) break :blk (blk_1: { + const tmp_2 = m; + if (tmp_2 >= 0) break :blk_1 materials + @as(usize, @intCast(tmp_2)) else break :blk_1 materials - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.maps + @as(usize, @intCast(tmp)) else break :blk (blk_1: { + const tmp_2 = m; + if (tmp_2 >= 0) break :blk_1 materials + @as(usize, @intCast(tmp_2)) else break :blk_1 materials - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.maps - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.value = (blk: { + const tmp = m; + if (tmp >= 0) break :blk mats + @as(usize, @intCast(tmp)) else break :blk mats - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.shininess; + (blk: { + const tmp = MATERIAL_MAP_EMISSION; + if (tmp >= 0) break :blk (blk_1: { + const tmp_2 = m; + if (tmp_2 >= 0) break :blk_1 materials + @as(usize, @intCast(tmp_2)) else break :blk_1 materials - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.maps + @as(usize, @intCast(tmp)) else break :blk (blk_1: { + const tmp_2 = m; + if (tmp_2 >= 0) break :blk_1 materials + @as(usize, @intCast(tmp_2)) else break :blk_1 materials - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.maps - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.color = Color{ + .r = @as(u8, @intFromFloat((blk: { + const tmp = m; + if (tmp >= 0) break :blk mats + @as(usize, @intCast(tmp)) else break :blk mats - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.emission[@as(c_uint, @intCast(@as(c_int, 0)))] * 255.0)), + .g = @as(u8, @intFromFloat((blk: { + const tmp = m; + if (tmp >= 0) break :blk mats + @as(usize, @intCast(tmp)) else break :blk mats - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.emission[@as(c_uint, @intCast(@as(c_int, 1)))] * 255.0)), + .b = @as(u8, @intFromFloat((blk: { + const tmp = m; + if (tmp >= 0) break :blk mats + @as(usize, @intCast(tmp)) else break :blk mats - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.emission[@as(c_uint, @intCast(@as(c_int, 2)))] * 255.0)), + .a = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, 255))))), + }; + if ((blk: { + const tmp = m; + if (tmp >= 0) break :blk mats + @as(usize, @intCast(tmp)) else break :blk mats - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.displacement_texname != @as([*c]u8, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0))))))) { + (blk: { + const tmp = MATERIAL_MAP_HEIGHT; + if (tmp >= 0) break :blk (blk_1: { + const tmp_2 = m; + if (tmp_2 >= 0) break :blk_1 materials + @as(usize, @intCast(tmp_2)) else break :blk_1 materials - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.maps + @as(usize, @intCast(tmp)) else break :blk (blk_1: { + const tmp_2 = m; + if (tmp_2 >= 0) break :blk_1 materials + @as(usize, @intCast(tmp_2)) else break :blk_1 materials - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.maps - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.texture = LoadTexture((blk: { + const tmp = m; + if (tmp >= 0) break :blk mats + @as(usize, @intCast(tmp)) else break :blk mats - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.displacement_texname); + } + } + } +} +pub fn BuildPoseFromParentJoints(arg_bones: [*c]BoneInfo, arg_boneCount: c_int, arg_transforms: [*c]Transform) callconv(.C) void { + var bones = arg_bones; + _ = &bones; + var boneCount = arg_boneCount; + _ = &boneCount; + var transforms = arg_transforms; + _ = &transforms; + { + var i: c_int = 0; + _ = &i; + while (i < boneCount) : (i += 1) { + if ((blk: { + const tmp = i; + if (tmp >= 0) break :blk bones + @as(usize, @intCast(tmp)) else break :blk bones - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.parent >= @as(c_int, 0)) { + if ((blk: { + const tmp = i; + if (tmp >= 0) break :blk bones + @as(usize, @intCast(tmp)) else break :blk bones - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.parent > i) { + TraceLog(LOG_WARNING, "Assumes bones are toplogically sorted, but bone %d has parent %d. Skipping.", i, (blk: { + const tmp = i; + if (tmp >= 0) break :blk bones + @as(usize, @intCast(tmp)) else break :blk bones - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.parent); + continue; + } + (blk: { + const tmp = i; + if (tmp >= 0) break :blk transforms + @as(usize, @intCast(tmp)) else break :blk transforms - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.rotation = QuaternionMultiply((blk: { + const tmp = (blk_1: { + const tmp_2 = i; + if (tmp_2 >= 0) break :blk_1 bones + @as(usize, @intCast(tmp_2)) else break :blk_1 bones - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.parent; + if (tmp >= 0) break :blk transforms + @as(usize, @intCast(tmp)) else break :blk transforms - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.rotation, (blk: { + const tmp = i; + if (tmp >= 0) break :blk transforms + @as(usize, @intCast(tmp)) else break :blk transforms - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.rotation); + (blk: { + const tmp = i; + if (tmp >= 0) break :blk transforms + @as(usize, @intCast(tmp)) else break :blk transforms - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.translation = Vector3RotateByQuaternion((blk: { + const tmp = i; + if (tmp >= 0) break :blk transforms + @as(usize, @intCast(tmp)) else break :blk transforms - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.translation, (blk: { + const tmp = (blk_1: { + const tmp_2 = i; + if (tmp_2 >= 0) break :blk_1 bones + @as(usize, @intCast(tmp_2)) else break :blk_1 bones - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.parent; + if (tmp >= 0) break :blk transforms + @as(usize, @intCast(tmp)) else break :blk transforms - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.rotation); + (blk: { + const tmp = i; + if (tmp >= 0) break :blk transforms + @as(usize, @intCast(tmp)) else break :blk transforms - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.translation = Vector3Add((blk: { + const tmp = i; + if (tmp >= 0) break :blk transforms + @as(usize, @intCast(tmp)) else break :blk transforms - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.translation, (blk: { + const tmp = (blk_1: { + const tmp_2 = i; + if (tmp_2 >= 0) break :blk_1 bones + @as(usize, @intCast(tmp_2)) else break :blk_1 bones - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.parent; + if (tmp >= 0) break :blk transforms + @as(usize, @intCast(tmp)) else break :blk transforms - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.translation); + (blk: { + const tmp = i; + if (tmp >= 0) break :blk transforms + @as(usize, @intCast(tmp)) else break :blk transforms - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.scale = Vector3Multiply((blk: { + const tmp = i; + if (tmp >= 0) break :blk transforms + @as(usize, @intCast(tmp)) else break :blk transforms - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.scale, (blk: { + const tmp = (blk_1: { + const tmp_2 = i; + if (tmp_2 >= 0) break :blk_1 bones + @as(usize, @intCast(tmp_2)) else break :blk_1 bones - ~@as(usize, @bitCast(@as(isize, @intCast(tmp_2)) +% -1)); + }).*.parent; + if (tmp >= 0) break :blk transforms + @as(usize, @intCast(tmp)) else break :blk transforms - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.scale); + } + } + } +} +pub fn LoadFileGLTFCallback(arg_memoryOptions: [*c]const struct_cgltf_memory_options, arg_fileOptions: [*c]const struct_cgltf_file_options, arg_path: [*c]const u8, arg_size: [*c]cgltf_size, arg_data: [*c]?*anyopaque) callconv(.C) cgltf_result { + var memoryOptions = arg_memoryOptions; + _ = &memoryOptions; + var fileOptions = arg_fileOptions; + _ = &fileOptions; + var path = arg_path; + _ = &path; + var size = arg_size; + _ = &size; + var data = arg_data; + _ = &data; + var filesize: c_int = undefined; + _ = &filesize; + var filedata: [*c]u8 = LoadFileData(path, &filesize); + _ = &filedata; + if (filedata == @as([*c]u8, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0))))))) return @as(c_uint, @bitCast(cgltf_result_io_error)); + size.* = @as(cgltf_size, @bitCast(@as(c_long, filesize))); + data.* = @as(?*anyopaque, @ptrCast(filedata)); + return @as(c_uint, @bitCast(cgltf_result_success)); +} +pub fn ReleaseFileGLTFCallback(arg_memoryOptions: [*c]const struct_cgltf_memory_options, arg_fileOptions: [*c]const struct_cgltf_file_options, arg_data: ?*anyopaque) callconv(.C) void { + var memoryOptions = arg_memoryOptions; + _ = &memoryOptions; + var fileOptions = arg_fileOptions; + _ = &fileOptions; + var data = arg_data; + _ = &data; + UnloadFileData(@as([*c]u8, @ptrCast(@alignCast(data)))); +} +pub fn LoadImageFromCgltfImage(arg_cgltfImage: [*c]cgltf_image, arg_texPath: [*c]const u8) callconv(.C) Image { + var cgltfImage = arg_cgltfImage; + _ = &cgltfImage; + var texPath = arg_texPath; + _ = &texPath; + var image: Image = Image{ + .data = null, + .width = 0, + .height = 0, + .mipmaps = 0, + .format = 0, + }; + _ = ℑ + if (cgltfImage.*.uri != @as([*c]u8, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0))))))) { + if ((((((strlen(cgltfImage.*.uri) > @as(c_ulong, @bitCast(@as(c_long, @as(c_int, 5))))) and (@as(c_int, @bitCast(@as(c_uint, cgltfImage.*.uri[@as(c_uint, @intCast(@as(c_int, 0)))]))) == @as(c_int, 'd'))) and (@as(c_int, @bitCast(@as(c_uint, cgltfImage.*.uri[@as(c_uint, @intCast(@as(c_int, 1)))]))) == @as(c_int, 'a'))) and (@as(c_int, @bitCast(@as(c_uint, cgltfImage.*.uri[@as(c_uint, @intCast(@as(c_int, 2)))]))) == @as(c_int, 't'))) and (@as(c_int, @bitCast(@as(c_uint, cgltfImage.*.uri[@as(c_uint, @intCast(@as(c_int, 3)))]))) == @as(c_int, 'a'))) and (@as(c_int, @bitCast(@as(c_uint, cgltfImage.*.uri[@as(c_uint, @intCast(@as(c_int, 4)))]))) == @as(c_int, ':'))) { + var i: c_int = 0; + _ = &i; + while ((@as(c_int, @bitCast(@as(c_uint, (blk: { + const tmp = i; + if (tmp >= 0) break :blk cgltfImage.*.uri + @as(usize, @intCast(tmp)) else break :blk cgltfImage.*.uri - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*))) != @as(c_int, ',')) and (@as(c_int, @bitCast(@as(c_uint, (blk: { + const tmp = i; + if (tmp >= 0) break :blk cgltfImage.*.uri + @as(usize, @intCast(tmp)) else break :blk cgltfImage.*.uri - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*))) != @as(c_int, 0))) { + i += 1; + } + if (@as(c_int, @bitCast(@as(c_uint, (blk: { + const tmp = i; + if (tmp >= 0) break :blk cgltfImage.*.uri + @as(usize, @intCast(tmp)) else break :blk cgltfImage.*.uri - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*))) == @as(c_int, 0)) { + TraceLog(LOG_WARNING, "IMAGE: glTF data URI is not a valid image"); + } else { + var base64Size: c_int = @as(c_int, @bitCast(@as(c_uint, @truncate(strlen((cgltfImage.*.uri + @as(usize, @bitCast(@as(isize, @intCast(i))))) + @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 1)))))))))); + _ = &base64Size; + while (@as(c_int, @bitCast(@as(c_uint, (blk: { + const tmp = i + base64Size; + if (tmp >= 0) break :blk cgltfImage.*.uri + @as(usize, @intCast(tmp)) else break :blk cgltfImage.*.uri - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*))) == @as(c_int, '=')) { + base64Size -= 1; + } + var numberOfEncodedBits: c_int = (base64Size * @as(c_int, 6)) - @import("std").zig.c_translation.signedRemainder(base64Size * @as(c_int, 6), @as(c_int, 8)); + _ = &numberOfEncodedBits; + var outSize: c_int = @divTrunc(numberOfEncodedBits, @as(c_int, 8)); + _ = &outSize; + var data: ?*anyopaque = @as(?*anyopaque, @ptrFromInt(@as(c_int, 0))); + _ = &data; + var options: cgltf_options = cgltf_options{ + .type = @as(c_uint, @bitCast(@as(c_int, 0))), + .json_token_count = @import("std").mem.zeroes(cgltf_size), + .memory = @import("std").mem.zeroes(cgltf_memory_options), + .file = @import("std").mem.zeroes(cgltf_file_options), + }; + _ = &options; + options.file.read = &LoadFileGLTFCallback; + options.file.release = &ReleaseFileGLTFCallback; + var result: cgltf_result = cgltf_load_buffer_base64(&options, @as(cgltf_size, @bitCast(@as(c_long, outSize))), (cgltfImage.*.uri + @as(usize, @bitCast(@as(isize, @intCast(i))))) + @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 1))))), &data); + _ = &result; + if (result == @as(c_uint, @bitCast(cgltf_result_success))) { + image = LoadImageFromMemory(".png", @as([*c]u8, @ptrCast(@alignCast(data))), outSize); + free(data); + } + } + } else { + image = LoadImage(TextFormat("%s/%s", texPath, cgltfImage.*.uri)); + } + } else if (cgltfImage.*.buffer_view.*.buffer.*.data != @as(?*anyopaque, @ptrFromInt(@as(c_int, 0)))) { + var data: [*c]u8 = @as([*c]u8, @ptrCast(@alignCast(malloc(cgltfImage.*.buffer_view.*.size)))); + _ = &data; + var offset: c_int = @as(c_int, @bitCast(@as(c_uint, @truncate(cgltfImage.*.buffer_view.*.offset)))); + _ = &offset; + var stride: c_int = if (@as(c_int, @bitCast(@as(c_uint, @truncate(cgltfImage.*.buffer_view.*.stride)))) != 0) @as(c_int, @bitCast(@as(c_uint, @truncate(cgltfImage.*.buffer_view.*.stride)))) else @as(c_int, 1); + _ = &stride; + { + var i: c_uint = 0; + _ = &i; + while (@as(cgltf_size, @bitCast(@as(c_ulong, i))) < cgltfImage.*.buffer_view.*.size) : (i +%= 1) { + data[i] = (blk: { + const tmp = offset; + if (tmp >= 0) break :blk @as([*c]u8, @ptrCast(@alignCast(cgltfImage.*.buffer_view.*.buffer.*.data))) + @as(usize, @intCast(tmp)) else break :blk @as([*c]u8, @ptrCast(@alignCast(cgltfImage.*.buffer_view.*.buffer.*.data))) - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*; + offset += stride; + } + } + if ((strcmp(cgltfImage.*.mime_type, "image\\/png") == @as(c_int, 0)) or (strcmp(cgltfImage.*.mime_type, "image/png") == @as(c_int, 0))) { + image = LoadImageFromMemory(".png", data, @as(c_int, @bitCast(@as(c_uint, @truncate(cgltfImage.*.buffer_view.*.size))))); + } else if ((strcmp(cgltfImage.*.mime_type, "image\\/jpeg") == @as(c_int, 0)) or (strcmp(cgltfImage.*.mime_type, "image/jpeg") == @as(c_int, 0))) { + image = LoadImageFromMemory(".jpg", data, @as(c_int, @bitCast(@as(c_uint, @truncate(cgltfImage.*.buffer_view.*.size))))); + } else { + TraceLog(LOG_WARNING, "MODEL: glTF image data MIME type not recognized", TextFormat("%s/%s", texPath, cgltfImage.*.uri)); + } + free(@as(?*anyopaque, @ptrCast(data))); + } + return image; +} +pub fn LoadBoneInfoGLTF(arg_skin: cgltf_skin, arg_boneCount: [*c]c_int) callconv(.C) [*c]BoneInfo { + var skin = arg_skin; + _ = &skin; + var boneCount = arg_boneCount; + _ = &boneCount; + boneCount.* = @as(c_int, @bitCast(@as(c_uint, @truncate(skin.joints_count)))); + var bones: [*c]BoneInfo = @as([*c]BoneInfo, @ptrCast(@alignCast(malloc(skin.joints_count *% @sizeOf(BoneInfo))))); + _ = &bones; + { + var i: c_uint = 0; + _ = &i; + while (@as(cgltf_size, @bitCast(@as(c_ulong, i))) < skin.joints_count) : (i +%= 1) { + var node: cgltf_node = skin.joints[i].*; + _ = &node; + if (node.name != @as([*c]u8, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0))))))) { + _ = strncpy(@as([*c]u8, @ptrCast(@alignCast(&bones[i].name))), node.name, @sizeOf([32]u8)); + bones[i].name[@sizeOf([32]u8) -% @as(c_ulong, @bitCast(@as(c_long, @as(c_int, 1))))] = '\x00'; + } + var parentIndex: c_int = -@as(c_int, 1); + _ = &parentIndex; + { + var j: c_uint = 0; + _ = &j; + while (@as(cgltf_size, @bitCast(@as(c_ulong, j))) < skin.joints_count) : (j +%= 1) { + if (skin.joints[j] == node.parent) { + parentIndex = @as(c_int, @bitCast(j)); + break; + } + } + } + bones[i].parent = parentIndex; + } + } + return bones; +} +pub fn GetPoseAtTimeGLTF(arg_interpolationType: cgltf_interpolation_type, arg_input: [*c]cgltf_accessor, arg_output: [*c]cgltf_accessor, arg_time: f32, arg_data: ?*anyopaque) callconv(.C) bool { + var interpolationType = arg_interpolationType; + _ = &interpolationType; + var input = arg_input; + _ = &input; + var output = arg_output; + _ = &output; + var time = arg_time; + _ = &time; + var data = arg_data; + _ = &data; + if (interpolationType >= @as(c_uint, @bitCast(cgltf_interpolation_type_max_enum))) return @as(c_int, 0) != 0; + var tstart: f32 = 0.0; + _ = &tstart; + var tend: f32 = 0.0; + _ = &tend; + var keyframe: c_int = 0; + _ = &keyframe; + { + var i: c_int = 0; + _ = &i; + while (i < (@as(c_int, @bitCast(@as(c_uint, @truncate(input.*.count)))) - @as(c_int, 1))) : (i += 1) { + var r1: cgltf_bool = cgltf_accessor_read_float(input, @as(cgltf_size, @bitCast(@as(c_long, i))), &tstart, @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 1))))); + _ = &r1; + if (!(r1 != 0)) return @as(c_int, 0) != 0; + var r2: cgltf_bool = cgltf_accessor_read_float(input, @as(cgltf_size, @bitCast(@as(c_long, i + @as(c_int, 1)))), &tend, @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 1))))); + _ = &r2; + if (!(r2 != 0)) return @as(c_int, 0) != 0; + if ((tstart <= time) and (time < tend)) { + keyframe = i; + break; + } + } + } + if (FloatEquals(tend, tstart) != 0) return @as(c_int, 1) != 0; + var duration: f32 = fmaxf(tend - tstart, 0.0000009999999974752427); + _ = &duration; + var t: f32 = (time - tstart) / duration; + _ = &t; + t = if (t < 0.0) 0.0 else t; + t = if (t > 1.0) 1.0 else t; + if (output.*.component_type != @as(c_uint, @bitCast(cgltf_component_type_r_32f))) return @as(c_int, 0) != 0; + if (output.*.type == @as(c_uint, @bitCast(cgltf_type_vec3))) { + while (true) { + switch (interpolationType) { + @as(c_uint, @bitCast(@as(c_int, 1))) => { + { + var tmp: [3]f32 = [1]f32{ + 0.0, + } ++ [1]f32{0} ** 2; + _ = &tmp; + _ = cgltf_accessor_read_float(output, @as(cgltf_size, @bitCast(@as(c_long, keyframe))), @as([*c]f32, @ptrCast(@alignCast(&tmp))), @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 3))))); + var v1: Vector3 = Vector3{ + .x = tmp[@as(c_uint, @intCast(@as(c_int, 0)))], + .y = tmp[@as(c_uint, @intCast(@as(c_int, 1)))], + .z = tmp[@as(c_uint, @intCast(@as(c_int, 2)))], + }; + _ = &v1; + var r: [*c]Vector3 = @as([*c]Vector3, @ptrCast(@alignCast(data))); + _ = &r; + r.* = v1; + } + break; + }, + @as(c_uint, @bitCast(@as(c_int, 0))) => { + { + var tmp: [3]f32 = [1]f32{ + 0.0, + } ++ [1]f32{0} ** 2; + _ = &tmp; + _ = cgltf_accessor_read_float(output, @as(cgltf_size, @bitCast(@as(c_long, keyframe))), @as([*c]f32, @ptrCast(@alignCast(&tmp))), @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 3))))); + var v1: Vector3 = Vector3{ + .x = tmp[@as(c_uint, @intCast(@as(c_int, 0)))], + .y = tmp[@as(c_uint, @intCast(@as(c_int, 1)))], + .z = tmp[@as(c_uint, @intCast(@as(c_int, 2)))], + }; + _ = &v1; + _ = cgltf_accessor_read_float(output, @as(cgltf_size, @bitCast(@as(c_long, keyframe + @as(c_int, 1)))), @as([*c]f32, @ptrCast(@alignCast(&tmp))), @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 3))))); + var v2: Vector3 = Vector3{ + .x = tmp[@as(c_uint, @intCast(@as(c_int, 0)))], + .y = tmp[@as(c_uint, @intCast(@as(c_int, 1)))], + .z = tmp[@as(c_uint, @intCast(@as(c_int, 2)))], + }; + _ = &v2; + var r: [*c]Vector3 = @as([*c]Vector3, @ptrCast(@alignCast(data))); + _ = &r; + r.* = Vector3Lerp(v1, v2, t); + } + break; + }, + @as(c_uint, @bitCast(@as(c_int, 2))) => { + { + var tmp: [3]f32 = [1]f32{ + 0.0, + } ++ [1]f32{0} ** 2; + _ = &tmp; + _ = cgltf_accessor_read_float(output, @as(cgltf_size, @bitCast(@as(c_long, (@as(c_int, 3) * keyframe) + @as(c_int, 1)))), @as([*c]f32, @ptrCast(@alignCast(&tmp))), @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 3))))); + var v1: Vector3 = Vector3{ + .x = tmp[@as(c_uint, @intCast(@as(c_int, 0)))], + .y = tmp[@as(c_uint, @intCast(@as(c_int, 1)))], + .z = tmp[@as(c_uint, @intCast(@as(c_int, 2)))], + }; + _ = &v1; + _ = cgltf_accessor_read_float(output, @as(cgltf_size, @bitCast(@as(c_long, (@as(c_int, 3) * keyframe) + @as(c_int, 2)))), @as([*c]f32, @ptrCast(@alignCast(&tmp))), @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 3))))); + var tangent1: Vector3 = Vector3{ + .x = tmp[@as(c_uint, @intCast(@as(c_int, 0)))], + .y = tmp[@as(c_uint, @intCast(@as(c_int, 1)))], + .z = tmp[@as(c_uint, @intCast(@as(c_int, 2)))], + }; + _ = &tangent1; + _ = cgltf_accessor_read_float(output, @as(cgltf_size, @bitCast(@as(c_long, (@as(c_int, 3) * (keyframe + @as(c_int, 1))) + @as(c_int, 1)))), @as([*c]f32, @ptrCast(@alignCast(&tmp))), @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 3))))); + var v2: Vector3 = Vector3{ + .x = tmp[@as(c_uint, @intCast(@as(c_int, 0)))], + .y = tmp[@as(c_uint, @intCast(@as(c_int, 1)))], + .z = tmp[@as(c_uint, @intCast(@as(c_int, 2)))], + }; + _ = &v2; + _ = cgltf_accessor_read_float(output, @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 3) * (keyframe + @as(c_int, 1))))), @as([*c]f32, @ptrCast(@alignCast(&tmp))), @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 3))))); + var tangent2: Vector3 = Vector3{ + .x = tmp[@as(c_uint, @intCast(@as(c_int, 0)))], + .y = tmp[@as(c_uint, @intCast(@as(c_int, 1)))], + .z = tmp[@as(c_uint, @intCast(@as(c_int, 2)))], + }; + _ = &tangent2; + var r: [*c]Vector3 = @as([*c]Vector3, @ptrCast(@alignCast(data))); + _ = &r; + r.* = Vector3CubicHermite(v1, tangent1, v2, tangent2, t); + } + break; + }, + else => break, + } + break; + } + } else if (output.*.type == @as(c_uint, @bitCast(cgltf_type_vec4))) { + while (true) { + switch (interpolationType) { + @as(c_uint, @bitCast(@as(c_int, 1))) => { + { + var tmp: [4]f32 = [1]f32{ + 0.0, + } ++ [1]f32{0} ** 3; + _ = &tmp; + _ = cgltf_accessor_read_float(output, @as(cgltf_size, @bitCast(@as(c_long, keyframe))), @as([*c]f32, @ptrCast(@alignCast(&tmp))), @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 4))))); + var v1: Vector4 = Vector4{ + .x = tmp[@as(c_uint, @intCast(@as(c_int, 0)))], + .y = tmp[@as(c_uint, @intCast(@as(c_int, 1)))], + .z = tmp[@as(c_uint, @intCast(@as(c_int, 2)))], + .w = tmp[@as(c_uint, @intCast(@as(c_int, 3)))], + }; + _ = &v1; + var r: [*c]Vector4 = @as([*c]Vector4, @ptrCast(@alignCast(data))); + _ = &r; + r.* = v1; + } + break; + }, + @as(c_uint, @bitCast(@as(c_int, 0))) => { + { + var tmp: [4]f32 = [1]f32{ + 0.0, + } ++ [1]f32{0} ** 3; + _ = &tmp; + _ = cgltf_accessor_read_float(output, @as(cgltf_size, @bitCast(@as(c_long, keyframe))), @as([*c]f32, @ptrCast(@alignCast(&tmp))), @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 4))))); + var v1: Vector4 = Vector4{ + .x = tmp[@as(c_uint, @intCast(@as(c_int, 0)))], + .y = tmp[@as(c_uint, @intCast(@as(c_int, 1)))], + .z = tmp[@as(c_uint, @intCast(@as(c_int, 2)))], + .w = tmp[@as(c_uint, @intCast(@as(c_int, 3)))], + }; + _ = &v1; + _ = cgltf_accessor_read_float(output, @as(cgltf_size, @bitCast(@as(c_long, keyframe + @as(c_int, 1)))), @as([*c]f32, @ptrCast(@alignCast(&tmp))), @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 4))))); + var v2: Vector4 = Vector4{ + .x = tmp[@as(c_uint, @intCast(@as(c_int, 0)))], + .y = tmp[@as(c_uint, @intCast(@as(c_int, 1)))], + .z = tmp[@as(c_uint, @intCast(@as(c_int, 2)))], + .w = tmp[@as(c_uint, @intCast(@as(c_int, 3)))], + }; + _ = &v2; + var r: [*c]Vector4 = @as([*c]Vector4, @ptrCast(@alignCast(data))); + _ = &r; + r.* = QuaternionSlerp(v1, v2, t); + } + break; + }, + @as(c_uint, @bitCast(@as(c_int, 2))) => { + { + var tmp: [4]f32 = [1]f32{ + 0.0, + } ++ [1]f32{0} ** 3; + _ = &tmp; + _ = cgltf_accessor_read_float(output, @as(cgltf_size, @bitCast(@as(c_long, (@as(c_int, 3) * keyframe) + @as(c_int, 1)))), @as([*c]f32, @ptrCast(@alignCast(&tmp))), @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 4))))); + var v1: Vector4 = Vector4{ + .x = tmp[@as(c_uint, @intCast(@as(c_int, 0)))], + .y = tmp[@as(c_uint, @intCast(@as(c_int, 1)))], + .z = tmp[@as(c_uint, @intCast(@as(c_int, 2)))], + .w = tmp[@as(c_uint, @intCast(@as(c_int, 3)))], + }; + _ = &v1; + _ = cgltf_accessor_read_float(output, @as(cgltf_size, @bitCast(@as(c_long, (@as(c_int, 3) * keyframe) + @as(c_int, 2)))), @as([*c]f32, @ptrCast(@alignCast(&tmp))), @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 4))))); + var outTangent1: Vector4 = Vector4{ + .x = tmp[@as(c_uint, @intCast(@as(c_int, 0)))], + .y = tmp[@as(c_uint, @intCast(@as(c_int, 1)))], + .z = tmp[@as(c_uint, @intCast(@as(c_int, 2)))], + .w = 0.0, + }; + _ = &outTangent1; + _ = cgltf_accessor_read_float(output, @as(cgltf_size, @bitCast(@as(c_long, (@as(c_int, 3) * (keyframe + @as(c_int, 1))) + @as(c_int, 1)))), @as([*c]f32, @ptrCast(@alignCast(&tmp))), @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 4))))); + var v2: Vector4 = Vector4{ + .x = tmp[@as(c_uint, @intCast(@as(c_int, 0)))], + .y = tmp[@as(c_uint, @intCast(@as(c_int, 1)))], + .z = tmp[@as(c_uint, @intCast(@as(c_int, 2)))], + .w = tmp[@as(c_uint, @intCast(@as(c_int, 3)))], + }; + _ = &v2; + _ = cgltf_accessor_read_float(output, @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 3) * (keyframe + @as(c_int, 1))))), @as([*c]f32, @ptrCast(@alignCast(&tmp))), @as(cgltf_size, @bitCast(@as(c_long, @as(c_int, 4))))); + var inTangent2: Vector4 = Vector4{ + .x = tmp[@as(c_uint, @intCast(@as(c_int, 0)))], + .y = tmp[@as(c_uint, @intCast(@as(c_int, 1)))], + .z = tmp[@as(c_uint, @intCast(@as(c_int, 2)))], + .w = 0.0, + }; + _ = &inTangent2; + var r: [*c]Vector4 = @as([*c]Vector4, @ptrCast(@alignCast(data))); + _ = &r; + v1 = QuaternionNormalize(v1); + v2 = QuaternionNormalize(v2); + if (Vector4DotProduct(v1, v2) < 0.0) { + v2 = Vector4Negate(v2); + } + outTangent1 = Vector4Scale(outTangent1, duration); + inTangent2 = Vector4Scale(inTangent2, duration); + r.* = QuaternionCubicHermiteSpline(v1, outTangent1, v2, inTangent2, t); + } + break; + }, + else => break, + } + break; + } + } + return @as(c_int, 1) != 0; +} +pub export fn m3d_loaderhook(arg_fn: [*c]u8, arg_len: [*c]c_uint) [*c]u8 { + var @"fn" = arg_fn; + _ = &@"fn"; + var len = arg_len; + _ = &len; + return LoadFileData(@as([*c]const u8, @ptrCast(@alignCast(@"fn"))), @as([*c]c_int, @ptrCast(@alignCast(len)))); +} +pub export fn m3d_freehook(arg_data: ?*anyopaque) void { + var data = arg_data; + _ = &data; + UnloadFileData(@as([*c]u8, @ptrCast(@alignCast(data)))); +} +pub const __llvm__ = @as(c_int, 1); +pub const __clang__ = @as(c_int, 1); +pub const __clang_major__ = @as(c_int, 18); +pub const __clang_minor__ = @as(c_int, 1); +pub const __clang_patchlevel__ = @as(c_int, 6); +pub const __clang_version__ = "18.1.6 (https://github.com/ziglang/zig-bootstrap 98bc6bf4fc4009888d33941daf6b600d20a42a56)"; +pub const __GNUC__ = @as(c_int, 4); +pub const __GNUC_MINOR__ = @as(c_int, 2); +pub const __GNUC_PATCHLEVEL__ = @as(c_int, 1); +pub const __GXX_ABI_VERSION = @as(c_int, 1002); +pub const __ATOMIC_RELAXED = @as(c_int, 0); +pub const __ATOMIC_CONSUME = @as(c_int, 1); +pub const __ATOMIC_ACQUIRE = @as(c_int, 2); +pub const __ATOMIC_RELEASE = @as(c_int, 3); +pub const __ATOMIC_ACQ_REL = @as(c_int, 4); +pub const __ATOMIC_SEQ_CST = @as(c_int, 5); +pub const __MEMORY_SCOPE_SYSTEM = @as(c_int, 0); +pub const __MEMORY_SCOPE_DEVICE = @as(c_int, 1); +pub const __MEMORY_SCOPE_WRKGRP = @as(c_int, 2); +pub const __MEMORY_SCOPE_WVFRNT = @as(c_int, 3); +pub const __MEMORY_SCOPE_SINGLE = @as(c_int, 4); +pub const __OPENCL_MEMORY_SCOPE_WORK_ITEM = @as(c_int, 0); +pub const __OPENCL_MEMORY_SCOPE_WORK_GROUP = @as(c_int, 1); +pub const __OPENCL_MEMORY_SCOPE_DEVICE = @as(c_int, 2); +pub const __OPENCL_MEMORY_SCOPE_ALL_SVM_DEVICES = @as(c_int, 3); +pub const __OPENCL_MEMORY_SCOPE_SUB_GROUP = @as(c_int, 4); +pub const __FPCLASS_SNAN = @as(c_int, 0x0001); +pub const __FPCLASS_QNAN = @as(c_int, 0x0002); +pub const __FPCLASS_NEGINF = @as(c_int, 0x0004); +pub const __FPCLASS_NEGNORMAL = @as(c_int, 0x0008); +pub const __FPCLASS_NEGSUBNORMAL = @as(c_int, 0x0010); +pub const __FPCLASS_NEGZERO = @as(c_int, 0x0020); +pub const __FPCLASS_POSZERO = @as(c_int, 0x0040); +pub const __FPCLASS_POSSUBNORMAL = @as(c_int, 0x0080); +pub const __FPCLASS_POSNORMAL = @as(c_int, 0x0100); +pub const __FPCLASS_POSINF = @as(c_int, 0x0200); +pub const __PRAGMA_REDEFINE_EXTNAME = @as(c_int, 1); +pub const __VERSION__ = "Clang 18.1.6 (https://github.com/ziglang/zig-bootstrap 98bc6bf4fc4009888d33941daf6b600d20a42a56)"; +pub const __OBJC_BOOL_IS_BOOL = @as(c_int, 0); +pub const __CONSTANT_CFSTRINGS__ = @as(c_int, 1); +pub const __clang_literal_encoding__ = "UTF-8"; +pub const __clang_wide_literal_encoding__ = "UTF-32"; +pub const __ORDER_LITTLE_ENDIAN__ = @as(c_int, 1234); +pub const __ORDER_BIG_ENDIAN__ = @as(c_int, 4321); +pub const __ORDER_PDP_ENDIAN__ = @as(c_int, 3412); +pub const __BYTE_ORDER__ = __ORDER_LITTLE_ENDIAN__; +pub const __LITTLE_ENDIAN__ = @as(c_int, 1); +pub const _LP64 = @as(c_int, 1); +pub const __LP64__ = @as(c_int, 1); +pub const __CHAR_BIT__ = @as(c_int, 8); +pub const __BOOL_WIDTH__ = @as(c_int, 8); +pub const __SHRT_WIDTH__ = @as(c_int, 16); +pub const __INT_WIDTH__ = @as(c_int, 32); +pub const __LONG_WIDTH__ = @as(c_int, 64); +pub const __LLONG_WIDTH__ = @as(c_int, 64); +pub const __BITINT_MAXWIDTH__ = @import("std").zig.c_translation.promoteIntLiteral(c_int, 8388608, .decimal); +pub const __SCHAR_MAX__ = @as(c_int, 127); +pub const __SHRT_MAX__ = @as(c_int, 32767); +pub const __INT_MAX__ = @import("std").zig.c_translation.promoteIntLiteral(c_int, 2147483647, .decimal); +pub const __LONG_MAX__ = @import("std").zig.c_translation.promoteIntLiteral(c_long, 9223372036854775807, .decimal); +pub const __LONG_LONG_MAX__ = @as(c_longlong, 9223372036854775807); +pub const __WCHAR_MAX__ = @import("std").zig.c_translation.promoteIntLiteral(c_int, 2147483647, .decimal); +pub const __WCHAR_WIDTH__ = @as(c_int, 32); +pub const __WINT_MAX__ = @import("std").zig.c_translation.promoteIntLiteral(c_uint, 4294967295, .decimal); +pub const __WINT_WIDTH__ = @as(c_int, 32); +pub const __INTMAX_MAX__ = @import("std").zig.c_translation.promoteIntLiteral(c_long, 9223372036854775807, .decimal); +pub const __INTMAX_WIDTH__ = @as(c_int, 64); +pub const __SIZE_MAX__ = @import("std").zig.c_translation.promoteIntLiteral(c_ulong, 18446744073709551615, .decimal); +pub const __SIZE_WIDTH__ = @as(c_int, 64); +pub const __UINTMAX_MAX__ = @import("std").zig.c_translation.promoteIntLiteral(c_ulong, 18446744073709551615, .decimal); +pub const __UINTMAX_WIDTH__ = @as(c_int, 64); +pub const __PTRDIFF_MAX__ = @import("std").zig.c_translation.promoteIntLiteral(c_long, 9223372036854775807, .decimal); +pub const __PTRDIFF_WIDTH__ = @as(c_int, 64); +pub const __INTPTR_MAX__ = @import("std").zig.c_translation.promoteIntLiteral(c_long, 9223372036854775807, .decimal); +pub const __INTPTR_WIDTH__ = @as(c_int, 64); +pub const __UINTPTR_MAX__ = @import("std").zig.c_translation.promoteIntLiteral(c_ulong, 18446744073709551615, .decimal); +pub const __UINTPTR_WIDTH__ = @as(c_int, 64); +pub const __SIZEOF_DOUBLE__ = @as(c_int, 8); +pub const __SIZEOF_FLOAT__ = @as(c_int, 4); +pub const __SIZEOF_INT__ = @as(c_int, 4); +pub const __SIZEOF_LONG__ = @as(c_int, 8); +pub const __SIZEOF_LONG_DOUBLE__ = @as(c_int, 16); +pub const __SIZEOF_LONG_LONG__ = @as(c_int, 8); +pub const __SIZEOF_POINTER__ = @as(c_int, 8); +pub const __SIZEOF_SHORT__ = @as(c_int, 2); +pub const __SIZEOF_PTRDIFF_T__ = @as(c_int, 8); +pub const __SIZEOF_SIZE_T__ = @as(c_int, 8); +pub const __SIZEOF_WCHAR_T__ = @as(c_int, 4); +pub const __SIZEOF_WINT_T__ = @as(c_int, 4); +pub const __SIZEOF_INT128__ = @as(c_int, 16); +pub const __INTMAX_TYPE__ = c_long; +pub const __INTMAX_FMTd__ = "ld"; +pub const __INTMAX_FMTi__ = "li"; +pub const __INTMAX_C_SUFFIX__ = @compileError("unable to translate macro: undefined identifier `L`"); +// (no file):95:9 +pub const __UINTMAX_TYPE__ = c_ulong; +pub const __UINTMAX_FMTo__ = "lo"; +pub const __UINTMAX_FMTu__ = "lu"; +pub const __UINTMAX_FMTx__ = "lx"; +pub const __UINTMAX_FMTX__ = "lX"; +pub const __UINTMAX_C_SUFFIX__ = @compileError("unable to translate macro: undefined identifier `UL`"); +// (no file):101:9 +pub const __PTRDIFF_TYPE__ = c_long; +pub const __PTRDIFF_FMTd__ = "ld"; +pub const __PTRDIFF_FMTi__ = "li"; +pub const __INTPTR_TYPE__ = c_long; +pub const __INTPTR_FMTd__ = "ld"; +pub const __INTPTR_FMTi__ = "li"; +pub const __SIZE_TYPE__ = c_ulong; +pub const __SIZE_FMTo__ = "lo"; +pub const __SIZE_FMTu__ = "lu"; +pub const __SIZE_FMTx__ = "lx"; +pub const __SIZE_FMTX__ = "lX"; +pub const __WCHAR_TYPE__ = c_int; +pub const __WINT_TYPE__ = c_uint; +pub const __SIG_ATOMIC_MAX__ = @import("std").zig.c_translation.promoteIntLiteral(c_int, 2147483647, .decimal); +pub const __SIG_ATOMIC_WIDTH__ = @as(c_int, 32); +pub const __CHAR16_TYPE__ = c_ushort; +pub const __CHAR32_TYPE__ = c_uint; +pub const __UINTPTR_TYPE__ = c_ulong; +pub const __UINTPTR_FMTo__ = "lo"; +pub const __UINTPTR_FMTu__ = "lu"; +pub const __UINTPTR_FMTx__ = "lx"; +pub const __UINTPTR_FMTX__ = "lX"; +pub const __FLT16_DENORM_MIN__ = @as(f16, 5.9604644775390625e-8); +pub const __FLT16_HAS_DENORM__ = @as(c_int, 1); +pub const __FLT16_DIG__ = @as(c_int, 3); +pub const __FLT16_DECIMAL_DIG__ = @as(c_int, 5); +pub const __FLT16_EPSILON__ = @as(f16, 9.765625e-4); +pub const __FLT16_HAS_INFINITY__ = @as(c_int, 1); +pub const __FLT16_HAS_QUIET_NAN__ = @as(c_int, 1); +pub const __FLT16_MANT_DIG__ = @as(c_int, 11); +pub const __FLT16_MAX_10_EXP__ = @as(c_int, 4); +pub const __FLT16_MAX_EXP__ = @as(c_int, 16); +pub const __FLT16_MAX__ = @as(f16, 6.5504e+4); +pub const __FLT16_MIN_10_EXP__ = -@as(c_int, 4); +pub const __FLT16_MIN_EXP__ = -@as(c_int, 13); +pub const __FLT16_MIN__ = @as(f16, 6.103515625e-5); +pub const __FLT_DENORM_MIN__ = @as(f32, 1.40129846e-45); +pub const __FLT_HAS_DENORM__ = @as(c_int, 1); +pub const __FLT_DIG__ = @as(c_int, 6); +pub const __FLT_DECIMAL_DIG__ = @as(c_int, 9); +pub const __FLT_EPSILON__ = @as(f32, 1.19209290e-7); +pub const __FLT_HAS_INFINITY__ = @as(c_int, 1); +pub const __FLT_HAS_QUIET_NAN__ = @as(c_int, 1); +pub const __FLT_MANT_DIG__ = @as(c_int, 24); +pub const __FLT_MAX_10_EXP__ = @as(c_int, 38); +pub const __FLT_MAX_EXP__ = @as(c_int, 128); +pub const __FLT_MAX__ = @as(f32, 3.40282347e+38); +pub const __FLT_MIN_10_EXP__ = -@as(c_int, 37); +pub const __FLT_MIN_EXP__ = -@as(c_int, 125); +pub const __FLT_MIN__ = @as(f32, 1.17549435e-38); +pub const __DBL_DENORM_MIN__ = @as(f64, 4.9406564584124654e-324); +pub const __DBL_HAS_DENORM__ = @as(c_int, 1); +pub const __DBL_DIG__ = @as(c_int, 15); +pub const __DBL_DECIMAL_DIG__ = @as(c_int, 17); +pub const __DBL_EPSILON__ = @as(f64, 2.2204460492503131e-16); +pub const __DBL_HAS_INFINITY__ = @as(c_int, 1); +pub const __DBL_HAS_QUIET_NAN__ = @as(c_int, 1); +pub const __DBL_MANT_DIG__ = @as(c_int, 53); +pub const __DBL_MAX_10_EXP__ = @as(c_int, 308); +pub const __DBL_MAX_EXP__ = @as(c_int, 1024); +pub const __DBL_MAX__ = @as(f64, 1.7976931348623157e+308); +pub const __DBL_MIN_10_EXP__ = -@as(c_int, 307); +pub const __DBL_MIN_EXP__ = -@as(c_int, 1021); +pub const __DBL_MIN__ = @as(f64, 2.2250738585072014e-308); +pub const __LDBL_DENORM_MIN__ = @as(c_longdouble, 3.64519953188247460253e-4951); +pub const __LDBL_HAS_DENORM__ = @as(c_int, 1); +pub const __LDBL_DIG__ = @as(c_int, 18); +pub const __LDBL_DECIMAL_DIG__ = @as(c_int, 21); +pub const __LDBL_EPSILON__ = @as(c_longdouble, 1.08420217248550443401e-19); +pub const __LDBL_HAS_INFINITY__ = @as(c_int, 1); +pub const __LDBL_HAS_QUIET_NAN__ = @as(c_int, 1); +pub const __LDBL_MANT_DIG__ = @as(c_int, 64); +pub const __LDBL_MAX_10_EXP__ = @as(c_int, 4932); +pub const __LDBL_MAX_EXP__ = @as(c_int, 16384); +pub const __LDBL_MAX__ = @as(c_longdouble, 1.18973149535723176502e+4932); +pub const __LDBL_MIN_10_EXP__ = -@as(c_int, 4931); +pub const __LDBL_MIN_EXP__ = -@as(c_int, 16381); +pub const __LDBL_MIN__ = @as(c_longdouble, 3.36210314311209350626e-4932); +pub const __POINTER_WIDTH__ = @as(c_int, 64); +pub const __BIGGEST_ALIGNMENT__ = @as(c_int, 16); +pub const __WINT_UNSIGNED__ = @as(c_int, 1); +pub const __INT8_TYPE__ = i8; +pub const __INT8_FMTd__ = "hhd"; +pub const __INT8_FMTi__ = "hhi"; +pub const __INT8_C_SUFFIX__ = ""; +pub const __INT16_TYPE__ = c_short; +pub const __INT16_FMTd__ = "hd"; +pub const __INT16_FMTi__ = "hi"; +pub const __INT16_C_SUFFIX__ = ""; +pub const __INT32_TYPE__ = c_int; +pub const __INT32_FMTd__ = "d"; +pub const __INT32_FMTi__ = "i"; +pub const __INT32_C_SUFFIX__ = ""; +pub const __INT64_TYPE__ = c_long; +pub const __INT64_FMTd__ = "ld"; +pub const __INT64_FMTi__ = "li"; +pub const __INT64_C_SUFFIX__ = @compileError("unable to translate macro: undefined identifier `L`"); +// (no file):198:9 +pub const __UINT8_TYPE__ = u8; +pub const __UINT8_FMTo__ = "hho"; +pub const __UINT8_FMTu__ = "hhu"; +pub const __UINT8_FMTx__ = "hhx"; +pub const __UINT8_FMTX__ = "hhX"; +pub const __UINT8_C_SUFFIX__ = ""; +pub const __UINT8_MAX__ = @as(c_int, 255); +pub const __INT8_MAX__ = @as(c_int, 127); +pub const __UINT16_TYPE__ = c_ushort; +pub const __UINT16_FMTo__ = "ho"; +pub const __UINT16_FMTu__ = "hu"; +pub const __UINT16_FMTx__ = "hx"; +pub const __UINT16_FMTX__ = "hX"; +pub const __UINT16_C_SUFFIX__ = ""; +pub const __UINT16_MAX__ = @import("std").zig.c_translation.promoteIntLiteral(c_int, 65535, .decimal); +pub const __INT16_MAX__ = @as(c_int, 32767); +pub const __UINT32_TYPE__ = c_uint; +pub const __UINT32_FMTo__ = "o"; +pub const __UINT32_FMTu__ = "u"; +pub const __UINT32_FMTx__ = "x"; +pub const __UINT32_FMTX__ = "X"; +pub const __UINT32_C_SUFFIX__ = @compileError("unable to translate macro: undefined identifier `U`"); +// (no file):220:9 +pub const __UINT32_MAX__ = @import("std").zig.c_translation.promoteIntLiteral(c_uint, 4294967295, .decimal); +pub const __INT32_MAX__ = @import("std").zig.c_translation.promoteIntLiteral(c_int, 2147483647, .decimal); +pub const __UINT64_TYPE__ = c_ulong; +pub const __UINT64_FMTo__ = "lo"; +pub const __UINT64_FMTu__ = "lu"; +pub const __UINT64_FMTx__ = "lx"; +pub const __UINT64_FMTX__ = "lX"; +pub const __UINT64_C_SUFFIX__ = @compileError("unable to translate macro: undefined identifier `UL`"); +// (no file):228:9 +pub const __UINT64_MAX__ = @import("std").zig.c_translation.promoteIntLiteral(c_ulong, 18446744073709551615, .decimal); +pub const __INT64_MAX__ = @import("std").zig.c_translation.promoteIntLiteral(c_long, 9223372036854775807, .decimal); +pub const __INT_LEAST8_TYPE__ = i8; +pub const __INT_LEAST8_MAX__ = @as(c_int, 127); +pub const __INT_LEAST8_WIDTH__ = @as(c_int, 8); +pub const __INT_LEAST8_FMTd__ = "hhd"; +pub const __INT_LEAST8_FMTi__ = "hhi"; +pub const __UINT_LEAST8_TYPE__ = u8; +pub const __UINT_LEAST8_MAX__ = @as(c_int, 255); +pub const __UINT_LEAST8_FMTo__ = "hho"; +pub const __UINT_LEAST8_FMTu__ = "hhu"; +pub const __UINT_LEAST8_FMTx__ = "hhx"; +pub const __UINT_LEAST8_FMTX__ = "hhX"; +pub const __INT_LEAST16_TYPE__ = c_short; +pub const __INT_LEAST16_MAX__ = @as(c_int, 32767); +pub const __INT_LEAST16_WIDTH__ = @as(c_int, 16); +pub const __INT_LEAST16_FMTd__ = "hd"; +pub const __INT_LEAST16_FMTi__ = "hi"; +pub const __UINT_LEAST16_TYPE__ = c_ushort; +pub const __UINT_LEAST16_MAX__ = @import("std").zig.c_translation.promoteIntLiteral(c_int, 65535, .decimal); +pub const __UINT_LEAST16_FMTo__ = "ho"; +pub const __UINT_LEAST16_FMTu__ = "hu"; +pub const __UINT_LEAST16_FMTx__ = "hx"; +pub const __UINT_LEAST16_FMTX__ = "hX"; +pub const __INT_LEAST32_TYPE__ = c_int; +pub const __INT_LEAST32_MAX__ = @import("std").zig.c_translation.promoteIntLiteral(c_int, 2147483647, .decimal); +pub const __INT_LEAST32_WIDTH__ = @as(c_int, 32); +pub const __INT_LEAST32_FMTd__ = "d"; +pub const __INT_LEAST32_FMTi__ = "i"; +pub const __UINT_LEAST32_TYPE__ = c_uint; +pub const __UINT_LEAST32_MAX__ = @import("std").zig.c_translation.promoteIntLiteral(c_uint, 4294967295, .decimal); +pub const __UINT_LEAST32_FMTo__ = "o"; +pub const __UINT_LEAST32_FMTu__ = "u"; +pub const __UINT_LEAST32_FMTx__ = "x"; +pub const __UINT_LEAST32_FMTX__ = "X"; +pub const __INT_LEAST64_TYPE__ = c_long; +pub const __INT_LEAST64_MAX__ = @import("std").zig.c_translation.promoteIntLiteral(c_long, 9223372036854775807, .decimal); +pub const __INT_LEAST64_WIDTH__ = @as(c_int, 64); +pub const __INT_LEAST64_FMTd__ = "ld"; +pub const __INT_LEAST64_FMTi__ = "li"; +pub const __UINT_LEAST64_TYPE__ = c_ulong; +pub const __UINT_LEAST64_MAX__ = @import("std").zig.c_translation.promoteIntLiteral(c_ulong, 18446744073709551615, .decimal); +pub const __UINT_LEAST64_FMTo__ = "lo"; +pub const __UINT_LEAST64_FMTu__ = "lu"; +pub const __UINT_LEAST64_FMTx__ = "lx"; +pub const __UINT_LEAST64_FMTX__ = "lX"; +pub const __INT_FAST8_TYPE__ = i8; +pub const __INT_FAST8_MAX__ = @as(c_int, 127); +pub const __INT_FAST8_WIDTH__ = @as(c_int, 8); +pub const __INT_FAST8_FMTd__ = "hhd"; +pub const __INT_FAST8_FMTi__ = "hhi"; +pub const __UINT_FAST8_TYPE__ = u8; +pub const __UINT_FAST8_MAX__ = @as(c_int, 255); +pub const __UINT_FAST8_FMTo__ = "hho"; +pub const __UINT_FAST8_FMTu__ = "hhu"; +pub const __UINT_FAST8_FMTx__ = "hhx"; +pub const __UINT_FAST8_FMTX__ = "hhX"; +pub const __INT_FAST16_TYPE__ = c_short; +pub const __INT_FAST16_MAX__ = @as(c_int, 32767); +pub const __INT_FAST16_WIDTH__ = @as(c_int, 16); +pub const __INT_FAST16_FMTd__ = "hd"; +pub const __INT_FAST16_FMTi__ = "hi"; +pub const __UINT_FAST16_TYPE__ = c_ushort; +pub const __UINT_FAST16_MAX__ = @import("std").zig.c_translation.promoteIntLiteral(c_int, 65535, .decimal); +pub const __UINT_FAST16_FMTo__ = "ho"; +pub const __UINT_FAST16_FMTu__ = "hu"; +pub const __UINT_FAST16_FMTx__ = "hx"; +pub const __UINT_FAST16_FMTX__ = "hX"; +pub const __INT_FAST32_TYPE__ = c_int; +pub const __INT_FAST32_MAX__ = @import("std").zig.c_translation.promoteIntLiteral(c_int, 2147483647, .decimal); +pub const __INT_FAST32_WIDTH__ = @as(c_int, 32); +pub const __INT_FAST32_FMTd__ = "d"; +pub const __INT_FAST32_FMTi__ = "i"; +pub const __UINT_FAST32_TYPE__ = c_uint; +pub const __UINT_FAST32_MAX__ = @import("std").zig.c_translation.promoteIntLiteral(c_uint, 4294967295, .decimal); +pub const __UINT_FAST32_FMTo__ = "o"; +pub const __UINT_FAST32_FMTu__ = "u"; +pub const __UINT_FAST32_FMTx__ = "x"; +pub const __UINT_FAST32_FMTX__ = "X"; +pub const __INT_FAST64_TYPE__ = c_long; +pub const __INT_FAST64_MAX__ = @import("std").zig.c_translation.promoteIntLiteral(c_long, 9223372036854775807, .decimal); +pub const __INT_FAST64_WIDTH__ = @as(c_int, 64); +pub const __INT_FAST64_FMTd__ = "ld"; +pub const __INT_FAST64_FMTi__ = "li"; +pub const __UINT_FAST64_TYPE__ = c_ulong; +pub const __UINT_FAST64_MAX__ = @import("std").zig.c_translation.promoteIntLiteral(c_ulong, 18446744073709551615, .decimal); +pub const __UINT_FAST64_FMTo__ = "lo"; +pub const __UINT_FAST64_FMTu__ = "lu"; +pub const __UINT_FAST64_FMTx__ = "lx"; +pub const __UINT_FAST64_FMTX__ = "lX"; +pub const __USER_LABEL_PREFIX__ = ""; +pub const __FINITE_MATH_ONLY__ = @as(c_int, 0); +pub const __GNUC_STDC_INLINE__ = @as(c_int, 1); +pub const __GCC_ATOMIC_TEST_AND_SET_TRUEVAL = @as(c_int, 1); +pub const __CLANG_ATOMIC_BOOL_LOCK_FREE = @as(c_int, 2); +pub const __CLANG_ATOMIC_CHAR_LOCK_FREE = @as(c_int, 2); +pub const __CLANG_ATOMIC_CHAR16_T_LOCK_FREE = @as(c_int, 2); +pub const __CLANG_ATOMIC_CHAR32_T_LOCK_FREE = @as(c_int, 2); +pub const __CLANG_ATOMIC_WCHAR_T_LOCK_FREE = @as(c_int, 2); +pub const __CLANG_ATOMIC_SHORT_LOCK_FREE = @as(c_int, 2); +pub const __CLANG_ATOMIC_INT_LOCK_FREE = @as(c_int, 2); +pub const __CLANG_ATOMIC_LONG_LOCK_FREE = @as(c_int, 2); +pub const __CLANG_ATOMIC_LLONG_LOCK_FREE = @as(c_int, 2); +pub const __CLANG_ATOMIC_POINTER_LOCK_FREE = @as(c_int, 2); +pub const __GCC_ATOMIC_BOOL_LOCK_FREE = @as(c_int, 2); +pub const __GCC_ATOMIC_CHAR_LOCK_FREE = @as(c_int, 2); +pub const __GCC_ATOMIC_CHAR16_T_LOCK_FREE = @as(c_int, 2); +pub const __GCC_ATOMIC_CHAR32_T_LOCK_FREE = @as(c_int, 2); +pub const __GCC_ATOMIC_WCHAR_T_LOCK_FREE = @as(c_int, 2); +pub const __GCC_ATOMIC_SHORT_LOCK_FREE = @as(c_int, 2); +pub const __GCC_ATOMIC_INT_LOCK_FREE = @as(c_int, 2); +pub const __GCC_ATOMIC_LONG_LOCK_FREE = @as(c_int, 2); +pub const __GCC_ATOMIC_LLONG_LOCK_FREE = @as(c_int, 2); +pub const __GCC_ATOMIC_POINTER_LOCK_FREE = @as(c_int, 2); +pub const __NO_INLINE__ = @as(c_int, 1); +pub const __PIC__ = @as(c_int, 2); +pub const __pic__ = @as(c_int, 2); +pub const __FLT_RADIX__ = @as(c_int, 2); +pub const __DECIMAL_DIG__ = __LDBL_DECIMAL_DIG__; +pub const __SSP_STRONG__ = @as(c_int, 2); +pub const __ELF__ = @as(c_int, 1); +pub const __GCC_ASM_FLAG_OUTPUTS__ = @as(c_int, 1); +pub const __code_model_small__ = @as(c_int, 1); +pub const __amd64__ = @as(c_int, 1); +pub const __amd64 = @as(c_int, 1); +pub const __x86_64 = @as(c_int, 1); +pub const __x86_64__ = @as(c_int, 1); +pub const __SEG_GS = @as(c_int, 1); +pub const __SEG_FS = @as(c_int, 1); +pub const __seg_gs = @compileError("unable to translate macro: undefined identifier `address_space`"); +// (no file):358:9 +pub const __seg_fs = @compileError("unable to translate macro: undefined identifier `address_space`"); +// (no file):359:9 +pub const __znver3 = @as(c_int, 1); +pub const __znver3__ = @as(c_int, 1); +pub const __tune_znver3__ = @as(c_int, 1); +pub const __REGISTER_PREFIX__ = ""; +pub const __NO_MATH_INLINES = @as(c_int, 1); +pub const __AES__ = @as(c_int, 1); +pub const __VAES__ = @as(c_int, 1); +pub const __PCLMUL__ = @as(c_int, 1); +pub const __VPCLMULQDQ__ = @as(c_int, 1); +pub const __LAHF_SAHF__ = @as(c_int, 1); +pub const __LZCNT__ = @as(c_int, 1); +pub const __RDRND__ = @as(c_int, 1); +pub const __FSGSBASE__ = @as(c_int, 1); +pub const __BMI__ = @as(c_int, 1); +pub const __BMI2__ = @as(c_int, 1); +pub const __POPCNT__ = @as(c_int, 1); +pub const __PRFCHW__ = @as(c_int, 1); +pub const __RDSEED__ = @as(c_int, 1); +pub const __ADX__ = @as(c_int, 1); +pub const __MWAITX__ = @as(c_int, 1); +pub const __MOVBE__ = @as(c_int, 1); +pub const __SSE4A__ = @as(c_int, 1); +pub const __FMA__ = @as(c_int, 1); +pub const __F16C__ = @as(c_int, 1); +pub const __SHA__ = @as(c_int, 1); +pub const __FXSR__ = @as(c_int, 1); +pub const __XSAVE__ = @as(c_int, 1); +pub const __XSAVEOPT__ = @as(c_int, 1); +pub const __XSAVEC__ = @as(c_int, 1); +pub const __XSAVES__ = @as(c_int, 1); +pub const __PKU__ = @as(c_int, 1); +pub const __CLFLUSHOPT__ = @as(c_int, 1); +pub const __CLWB__ = @as(c_int, 1); +pub const __WBNOINVD__ = @as(c_int, 1); +pub const __SHSTK__ = @as(c_int, 1); +pub const __CLZERO__ = @as(c_int, 1); +pub const __RDPID__ = @as(c_int, 1); +pub const __RDPRU__ = @as(c_int, 1); +pub const __INVPCID__ = @as(c_int, 1); +pub const __CRC32__ = @as(c_int, 1); +pub const __AVX2__ = @as(c_int, 1); +pub const __AVX__ = @as(c_int, 1); +pub const __SSE4_2__ = @as(c_int, 1); +pub const __SSE4_1__ = @as(c_int, 1); +pub const __SSSE3__ = @as(c_int, 1); +pub const __SSE3__ = @as(c_int, 1); +pub const __SSE2__ = @as(c_int, 1); +pub const __SSE2_MATH__ = @as(c_int, 1); +pub const __SSE__ = @as(c_int, 1); +pub const __SSE_MATH__ = @as(c_int, 1); +pub const __MMX__ = @as(c_int, 1); +pub const __GCC_HAVE_SYNC_COMPARE_AND_SWAP_1 = @as(c_int, 1); +pub const __GCC_HAVE_SYNC_COMPARE_AND_SWAP_2 = @as(c_int, 1); +pub const __GCC_HAVE_SYNC_COMPARE_AND_SWAP_4 = @as(c_int, 1); +pub const __GCC_HAVE_SYNC_COMPARE_AND_SWAP_8 = @as(c_int, 1); +pub const __GCC_HAVE_SYNC_COMPARE_AND_SWAP_16 = @as(c_int, 1); +pub const __SIZEOF_FLOAT128__ = @as(c_int, 16); +pub const unix = @as(c_int, 1); +pub const __unix = @as(c_int, 1); +pub const __unix__ = @as(c_int, 1); +pub const linux = @as(c_int, 1); +pub const __linux = @as(c_int, 1); +pub const __linux__ = @as(c_int, 1); +pub const __gnu_linux__ = @as(c_int, 1); +pub const __FLOAT128__ = @as(c_int, 1); +pub const __STDC__ = @as(c_int, 1); +pub const __STDC_HOSTED__ = @as(c_int, 1); +pub const __STDC_VERSION__ = @as(c_long, 201710); +pub const __STDC_UTF_16__ = @as(c_int, 1); +pub const __STDC_UTF_32__ = @as(c_int, 1); +pub const __GLIBC_MINOR__ = @as(c_int, 39); +pub const _DEBUG = @as(c_int, 1); +pub const __GCC_HAVE_DWARF2_CFI_ASM = @as(c_int, 1); +pub const RAYLIB_H = ""; +pub const __STDARG_H = ""; +pub const __need___va_list = ""; +pub const __need_va_list = ""; +pub const __need_va_arg = ""; +pub const __need___va_copy = ""; +pub const __need_va_copy = ""; +pub const __GNUC_VA_LIST = ""; +pub const _VA_LIST = ""; +pub const va_start = @compileError("unable to translate macro: undefined identifier `__builtin_va_start`"); +// /opt/zig-bin-0.13.0/lib/include/__stdarg_va_arg.h:17:9 +pub const va_end = @compileError("unable to translate macro: undefined identifier `__builtin_va_end`"); +// /opt/zig-bin-0.13.0/lib/include/__stdarg_va_arg.h:19:9 +pub const va_arg = @compileError("unable to translate C expr: unexpected token 'an identifier'"); +// /opt/zig-bin-0.13.0/lib/include/__stdarg_va_arg.h:20:9 +pub const __va_copy = @compileError("unable to translate macro: undefined identifier `__builtin_va_copy`"); +// /opt/zig-bin-0.13.0/lib/include/__stdarg___va_copy.h:11:9 +pub const va_copy = @compileError("unable to translate macro: undefined identifier `__builtin_va_copy`"); +// /opt/zig-bin-0.13.0/lib/include/__stdarg_va_copy.h:11:9 +pub const RAYLIB_VERSION_MAJOR = @as(c_int, 5); +pub const RAYLIB_VERSION_MINOR = @as(c_int, 5); +pub const RAYLIB_VERSION_PATCH = @as(c_int, 0); +pub const RAYLIB_VERSION = "5.5-dev"; +pub const RLAPI = ""; +pub const PI = @as(f32, 3.14159265358979323846); +pub const DEG2RAD = @import("std").zig.c_translation.MacroArithmetic.div(PI, @as(f32, 180.0)); +pub const RAD2DEG = @import("std").zig.c_translation.MacroArithmetic.div(@as(f32, 180.0), PI); +pub inline fn RL_MALLOC(sz: anytype) @TypeOf(malloc(sz)) { + _ = &sz; + return malloc(sz); +} +pub inline fn RL_CALLOC(n: anytype, sz: anytype) @TypeOf(calloc(n, sz)) { + _ = &n; + _ = &sz; + return calloc(n, sz); +} +pub inline fn RL_REALLOC(ptr: anytype, sz: anytype) @TypeOf(realloc(ptr, sz)) { + _ = &ptr; + _ = &sz; + return realloc(ptr, sz); +} +pub inline fn RL_FREE(ptr: anytype) @TypeOf(free(ptr)) { + _ = &ptr; + return free(ptr); +} +pub inline fn CLITERAL(@"type": anytype) @TypeOf(@"type") { + _ = &@"type"; + return @"type"; +} +pub const RL_COLOR_TYPE = ""; +pub const RL_RECTANGLE_TYPE = ""; +pub const RL_VECTOR2_TYPE = ""; +pub const RL_VECTOR3_TYPE = ""; +pub const RL_VECTOR4_TYPE = ""; +pub const RL_QUATERNION_TYPE = ""; +pub const RL_MATRIX_TYPE = ""; +pub const LIGHTGRAY = @import("std").mem.zeroInit(CLITERAL(Color), .{ @as(c_int, 200), @as(c_int, 200), @as(c_int, 200), @as(c_int, 255) }); +pub const GRAY = @import("std").mem.zeroInit(CLITERAL(Color), .{ @as(c_int, 130), @as(c_int, 130), @as(c_int, 130), @as(c_int, 255) }); +pub const DARKGRAY = @import("std").mem.zeroInit(CLITERAL(Color), .{ @as(c_int, 80), @as(c_int, 80), @as(c_int, 80), @as(c_int, 255) }); +pub const YELLOW = @import("std").mem.zeroInit(CLITERAL(Color), .{ @as(c_int, 253), @as(c_int, 249), @as(c_int, 0), @as(c_int, 255) }); +pub const GOLD = @import("std").mem.zeroInit(CLITERAL(Color), .{ @as(c_int, 255), @as(c_int, 203), @as(c_int, 0), @as(c_int, 255) }); +pub const ORANGE = @import("std").mem.zeroInit(CLITERAL(Color), .{ @as(c_int, 255), @as(c_int, 161), @as(c_int, 0), @as(c_int, 255) }); +pub const PINK = @import("std").mem.zeroInit(CLITERAL(Color), .{ @as(c_int, 255), @as(c_int, 109), @as(c_int, 194), @as(c_int, 255) }); +pub const RED = @import("std").mem.zeroInit(CLITERAL(Color), .{ @as(c_int, 230), @as(c_int, 41), @as(c_int, 55), @as(c_int, 255) }); +pub const MAROON = @import("std").mem.zeroInit(CLITERAL(Color), .{ @as(c_int, 190), @as(c_int, 33), @as(c_int, 55), @as(c_int, 255) }); +pub const GREEN = @import("std").mem.zeroInit(CLITERAL(Color), .{ @as(c_int, 0), @as(c_int, 228), @as(c_int, 48), @as(c_int, 255) }); +pub const LIME = @import("std").mem.zeroInit(CLITERAL(Color), .{ @as(c_int, 0), @as(c_int, 158), @as(c_int, 47), @as(c_int, 255) }); +pub const DARKGREEN = @import("std").mem.zeroInit(CLITERAL(Color), .{ @as(c_int, 0), @as(c_int, 117), @as(c_int, 44), @as(c_int, 255) }); +pub const SKYBLUE = @import("std").mem.zeroInit(CLITERAL(Color), .{ @as(c_int, 102), @as(c_int, 191), @as(c_int, 255), @as(c_int, 255) }); +pub const BLUE = @import("std").mem.zeroInit(CLITERAL(Color), .{ @as(c_int, 0), @as(c_int, 121), @as(c_int, 241), @as(c_int, 255) }); +pub const DARKBLUE = @import("std").mem.zeroInit(CLITERAL(Color), .{ @as(c_int, 0), @as(c_int, 82), @as(c_int, 172), @as(c_int, 255) }); +pub const PURPLE = @import("std").mem.zeroInit(CLITERAL(Color), .{ @as(c_int, 200), @as(c_int, 122), @as(c_int, 255), @as(c_int, 255) }); +pub const VIOLET = @import("std").mem.zeroInit(CLITERAL(Color), .{ @as(c_int, 135), @as(c_int, 60), @as(c_int, 190), @as(c_int, 255) }); +pub const DARKPURPLE = @import("std").mem.zeroInit(CLITERAL(Color), .{ @as(c_int, 112), @as(c_int, 31), @as(c_int, 126), @as(c_int, 255) }); +pub const BEIGE = @import("std").mem.zeroInit(CLITERAL(Color), .{ @as(c_int, 211), @as(c_int, 176), @as(c_int, 131), @as(c_int, 255) }); +pub const BROWN = @import("std").mem.zeroInit(CLITERAL(Color), .{ @as(c_int, 127), @as(c_int, 106), @as(c_int, 79), @as(c_int, 255) }); +pub const DARKBROWN = @import("std").mem.zeroInit(CLITERAL(Color), .{ @as(c_int, 76), @as(c_int, 63), @as(c_int, 47), @as(c_int, 255) }); +pub const WHITE = @import("std").mem.zeroInit(CLITERAL(Color), .{ @as(c_int, 255), @as(c_int, 255), @as(c_int, 255), @as(c_int, 255) }); +pub const BLACK = @import("std").mem.zeroInit(CLITERAL(Color), .{ @as(c_int, 0), @as(c_int, 0), @as(c_int, 0), @as(c_int, 255) }); +pub const BLANK = @import("std").mem.zeroInit(CLITERAL(Color), .{ @as(c_int, 0), @as(c_int, 0), @as(c_int, 0), @as(c_int, 0) }); +pub const MAGENTA = @import("std").mem.zeroInit(CLITERAL(Color), .{ @as(c_int, 255), @as(c_int, 0), @as(c_int, 255), @as(c_int, 255) }); +pub const RAYWHITE = @import("std").mem.zeroInit(CLITERAL(Color), .{ @as(c_int, 245), @as(c_int, 245), @as(c_int, 245), @as(c_int, 255) }); +pub const __STDBOOL_H = ""; +pub const __bool_true_false_are_defined = @as(c_int, 1); +pub const @"bool" = bool; +pub const @"true" = @as(c_int, 1); +pub const @"false" = @as(c_int, 0); +pub const MOUSE_LEFT_BUTTON = MOUSE_BUTTON_LEFT; +pub const MOUSE_RIGHT_BUTTON = MOUSE_BUTTON_RIGHT; +pub const MOUSE_MIDDLE_BUTTON = MOUSE_BUTTON_MIDDLE; +pub const MATERIAL_MAP_DIFFUSE = MATERIAL_MAP_ALBEDO; +pub const MATERIAL_MAP_SPECULAR = MATERIAL_MAP_METALNESS; +pub const SHADER_LOC_MAP_DIFFUSE = SHADER_LOC_MAP_ALBEDO; +pub const SHADER_LOC_MAP_SPECULAR = SHADER_LOC_MAP_METALNESS; +pub const GetMouseRay = GetScreenToWorldRay; +pub const CONFIG_H = ""; +pub const SUPPORT_MODULE_RSHAPES = @as(c_int, 1); +pub const SUPPORT_MODULE_RTEXTURES = @as(c_int, 1); +pub const SUPPORT_MODULE_RTEXT = @as(c_int, 1); +pub const SUPPORT_MODULE_RMODELS = @as(c_int, 1); +pub const SUPPORT_MODULE_RAUDIO = @as(c_int, 1); +pub const SUPPORT_CAMERA_SYSTEM = @as(c_int, 1); +pub const SUPPORT_GESTURES_SYSTEM = @as(c_int, 1); +pub const SUPPORT_RPRAND_GENERATOR = @as(c_int, 1); +pub const SUPPORT_MOUSE_GESTURES = @as(c_int, 1); +pub const SUPPORT_SSH_KEYBOARD_RPI = @as(c_int, 1); +pub const SUPPORT_WINMM_HIGHRES_TIMER = @as(c_int, 1); +pub const SUPPORT_PARTIALBUSY_WAIT_LOOP = @as(c_int, 1); +pub const SUPPORT_SCREEN_CAPTURE = @as(c_int, 1); +pub const SUPPORT_GIF_RECORDING = @as(c_int, 1); +pub const SUPPORT_COMPRESSION_API = @as(c_int, 1); +pub const SUPPORT_AUTOMATION_EVENTS = @as(c_int, 1); +pub const MAX_FILEPATH_CAPACITY = @as(c_int, 8192); +pub const MAX_FILEPATH_LENGTH = @as(c_int, 4096); +pub const MAX_KEYBOARD_KEYS = @as(c_int, 512); +pub const MAX_MOUSE_BUTTONS = @as(c_int, 8); +pub const MAX_GAMEPADS = @as(c_int, 4); +pub const MAX_GAMEPAD_AXIS = @as(c_int, 8); +pub const MAX_GAMEPAD_BUTTONS = @as(c_int, 32); +pub const MAX_GAMEPAD_VIBRATION_TIME = @as(f32, 2.0); +pub const MAX_TOUCH_POINTS = @as(c_int, 8); +pub const MAX_KEY_PRESSED_QUEUE = @as(c_int, 16); +pub const MAX_CHAR_PRESSED_QUEUE = @as(c_int, 16); +pub const MAX_DECOMPRESSION_SIZE = @as(c_int, 64); +pub const MAX_AUTOMATION_EVENTS = @as(c_int, 16384); +pub const RL_DEFAULT_BATCH_BUFFERS = @as(c_int, 1); +pub const RL_DEFAULT_BATCH_DRAWCALLS = @as(c_int, 256); +pub const RL_DEFAULT_BATCH_MAX_TEXTURE_UNITS = @as(c_int, 4); +pub const RL_MAX_MATRIX_STACK_SIZE = @as(c_int, 32); +pub const RL_MAX_SHADER_LOCATIONS = @as(c_int, 32); +pub const RL_CULL_DISTANCE_NEAR = @as(f64, 0.01); +pub const RL_CULL_DISTANCE_FAR = @as(f64, 1000.0); +pub const RL_DEFAULT_SHADER_ATTRIB_LOCATION_POSITION = @as(c_int, 0); +pub const RL_DEFAULT_SHADER_ATTRIB_LOCATION_TEXCOORD = @as(c_int, 1); +pub const RL_DEFAULT_SHADER_ATTRIB_LOCATION_NORMAL = @as(c_int, 2); +pub const RL_DEFAULT_SHADER_ATTRIB_LOCATION_COLOR = @as(c_int, 3); +pub const RL_DEFAULT_SHADER_ATTRIB_LOCATION_TANGENT = @as(c_int, 4); +pub const RL_DEFAULT_SHADER_ATTRIB_LOCATION_TEXCOORD2 = @as(c_int, 5); +pub const RL_DEFAULT_SHADER_ATTRIB_NAME_POSITION = "vertexPosition"; +pub const RL_DEFAULT_SHADER_ATTRIB_NAME_TEXCOORD = "vertexTexCoord"; +pub const RL_DEFAULT_SHADER_ATTRIB_NAME_NORMAL = "vertexNormal"; +pub const RL_DEFAULT_SHADER_ATTRIB_NAME_COLOR = "vertexColor"; +pub const RL_DEFAULT_SHADER_ATTRIB_NAME_TANGENT = "vertexTangent"; +pub const RL_DEFAULT_SHADER_ATTRIB_NAME_TEXCOORD2 = "vertexTexCoord2"; +pub const RL_DEFAULT_SHADER_UNIFORM_NAME_MVP = "mvp"; +pub const RL_DEFAULT_SHADER_UNIFORM_NAME_VIEW = "matView"; +pub const RL_DEFAULT_SHADER_UNIFORM_NAME_PROJECTION = "matProjection"; +pub const RL_DEFAULT_SHADER_UNIFORM_NAME_MODEL = "matModel"; +pub const RL_DEFAULT_SHADER_UNIFORM_NAME_NORMAL = "matNormal"; +pub const RL_DEFAULT_SHADER_UNIFORM_NAME_COLOR = "colDiffuse"; +pub const RL_DEFAULT_SHADER_SAMPLER2D_NAME_TEXTURE0 = "texture0"; +pub const RL_DEFAULT_SHADER_SAMPLER2D_NAME_TEXTURE1 = "texture1"; +pub const RL_DEFAULT_SHADER_SAMPLER2D_NAME_TEXTURE2 = "texture2"; +pub const SUPPORT_QUADS_DRAW_MODE = @as(c_int, 1); +pub const SPLINE_SEGMENT_DIVISIONS = @as(c_int, 24); +pub const SUPPORT_FILEFORMAT_PNG = @as(c_int, 1); +pub const SUPPORT_FILEFORMAT_GIF = @as(c_int, 1); +pub const SUPPORT_FILEFORMAT_QOI = @as(c_int, 1); +pub const SUPPORT_FILEFORMAT_DDS = @as(c_int, 1); +pub const SUPPORT_IMAGE_EXPORT = @as(c_int, 1); +pub const SUPPORT_IMAGE_GENERATION = @as(c_int, 1); +pub const SUPPORT_IMAGE_MANIPULATION = @as(c_int, 1); +pub const SUPPORT_DEFAULT_FONT = @as(c_int, 1); +pub const SUPPORT_FILEFORMAT_TTF = @as(c_int, 1); +pub const SUPPORT_FILEFORMAT_FNT = @as(c_int, 1); +pub const SUPPORT_TEXT_MANIPULATION = @as(c_int, 1); +pub const SUPPORT_FONT_ATLAS_WHITE_REC = @as(c_int, 1); +pub const MAX_TEXT_BUFFER_LENGTH = @as(c_int, 1024); +pub const MAX_TEXTSPLIT_COUNT = @as(c_int, 128); +pub const SUPPORT_FILEFORMAT_OBJ = @as(c_int, 1); +pub const SUPPORT_FILEFORMAT_MTL = @as(c_int, 1); +pub const SUPPORT_FILEFORMAT_IQM = @as(c_int, 1); +pub const SUPPORT_FILEFORMAT_GLTF = @as(c_int, 1); +pub const SUPPORT_FILEFORMAT_VOX = @as(c_int, 1); +pub const SUPPORT_FILEFORMAT_M3D = @as(c_int, 1); +pub const SUPPORT_MESH_GENERATION = @as(c_int, 1); +pub const MAX_MATERIAL_MAPS = @as(c_int, 12); +pub const MAX_MESH_VERTEX_BUFFERS = @as(c_int, 7); +pub const SUPPORT_FILEFORMAT_WAV = @as(c_int, 1); +pub const SUPPORT_FILEFORMAT_OGG = @as(c_int, 1); +pub const SUPPORT_FILEFORMAT_MP3 = @as(c_int, 1); +pub const SUPPORT_FILEFORMAT_QOA = @as(c_int, 1); +pub const SUPPORT_FILEFORMAT_XM = @as(c_int, 1); +pub const SUPPORT_FILEFORMAT_MOD = @as(c_int, 1); +pub const AUDIO_DEVICE_FORMAT = @compileError("unable to translate macro: undefined identifier `ma_format_f32`"); +// ./config.h:244:9 +pub const AUDIO_DEVICE_CHANNELS = @as(c_int, 2); +pub const AUDIO_DEVICE_SAMPLE_RATE = @as(c_int, 0); +pub const MAX_AUDIO_BUFFER_POOL_CHANNELS = @as(c_int, 16); +pub const SUPPORT_STANDARD_FILEIO = @as(c_int, 1); +pub const SUPPORT_TRACELOG = @as(c_int, 1); +pub const MAX_TRACELOG_MSG_LENGTH = @as(c_int, 256); +pub const UTILS_H = ""; +pub const TRACELOG = @compileError("unable to translate C expr: expected ')' instead got '...'"); +// ./utils.h:36:13 +pub const TRACELOGD = @compileError("unable to translate C expr: expected ')' instead got '...'"); +// ./utils.h:41:17 +pub const RLGL_H = ""; +pub const RLGL_VERSION = "5.0"; +pub const GRAPHICS_API_OPENGL_33 = ""; +pub const RLGL_RENDER_TEXTURES_HINT = ""; +pub const RL_DEFAULT_BATCH_BUFFER_ELEMENTS = @as(c_int, 8192); +pub const RL_TEXTURE_WRAP_S = @as(c_int, 0x2802); +pub const RL_TEXTURE_WRAP_T = @as(c_int, 0x2803); +pub const RL_TEXTURE_MAG_FILTER = @as(c_int, 0x2800); +pub const RL_TEXTURE_MIN_FILTER = @as(c_int, 0x2801); +pub const RL_TEXTURE_FILTER_NEAREST = @as(c_int, 0x2600); +pub const RL_TEXTURE_FILTER_LINEAR = @as(c_int, 0x2601); +pub const RL_TEXTURE_FILTER_MIP_NEAREST = @as(c_int, 0x2700); +pub const RL_TEXTURE_FILTER_NEAREST_MIP_LINEAR = @as(c_int, 0x2702); +pub const RL_TEXTURE_FILTER_LINEAR_MIP_NEAREST = @as(c_int, 0x2701); +pub const RL_TEXTURE_FILTER_MIP_LINEAR = @as(c_int, 0x2703); +pub const RL_TEXTURE_FILTER_ANISOTROPIC = @as(c_int, 0x3000); +pub const RL_TEXTURE_MIPMAP_BIAS_RATIO = @as(c_int, 0x4000); +pub const RL_TEXTURE_WRAP_REPEAT = @as(c_int, 0x2901); +pub const RL_TEXTURE_WRAP_CLAMP = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x812F, .hex); +pub const RL_TEXTURE_WRAP_MIRROR_REPEAT = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x8370, .hex); +pub const RL_TEXTURE_WRAP_MIRROR_CLAMP = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x8742, .hex); +pub const RL_MODELVIEW = @as(c_int, 0x1700); +pub const RL_PROJECTION = @as(c_int, 0x1701); +pub const RL_TEXTURE = @as(c_int, 0x1702); +pub const RL_LINES = @as(c_int, 0x0001); +pub const RL_TRIANGLES = @as(c_int, 0x0004); +pub const RL_QUADS = @as(c_int, 0x0007); +pub const RL_UNSIGNED_BYTE = @as(c_int, 0x1401); +pub const RL_FLOAT = @as(c_int, 0x1406); +pub const RL_STREAM_DRAW = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x88E0, .hex); +pub const RL_STREAM_READ = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x88E1, .hex); +pub const RL_STREAM_COPY = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x88E2, .hex); +pub const RL_STATIC_DRAW = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x88E4, .hex); +pub const RL_STATIC_READ = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x88E5, .hex); +pub const RL_STATIC_COPY = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x88E6, .hex); +pub const RL_DYNAMIC_DRAW = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x88E8, .hex); +pub const RL_DYNAMIC_READ = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x88E9, .hex); +pub const RL_DYNAMIC_COPY = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x88EA, .hex); +pub const RL_FRAGMENT_SHADER = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x8B30, .hex); +pub const RL_VERTEX_SHADER = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x8B31, .hex); +pub const RL_COMPUTE_SHADER = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x91B9, .hex); +pub const RL_ZERO = @as(c_int, 0); +pub const RL_ONE = @as(c_int, 1); +pub const RL_SRC_COLOR = @as(c_int, 0x0300); +pub const RL_ONE_MINUS_SRC_COLOR = @as(c_int, 0x0301); +pub const RL_SRC_ALPHA = @as(c_int, 0x0302); +pub const RL_ONE_MINUS_SRC_ALPHA = @as(c_int, 0x0303); +pub const RL_DST_ALPHA = @as(c_int, 0x0304); +pub const RL_ONE_MINUS_DST_ALPHA = @as(c_int, 0x0305); +pub const RL_DST_COLOR = @as(c_int, 0x0306); +pub const RL_ONE_MINUS_DST_COLOR = @as(c_int, 0x0307); +pub const RL_SRC_ALPHA_SATURATE = @as(c_int, 0x0308); +pub const RL_CONSTANT_COLOR = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x8001, .hex); +pub const RL_ONE_MINUS_CONSTANT_COLOR = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x8002, .hex); +pub const RL_CONSTANT_ALPHA = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x8003, .hex); +pub const RL_ONE_MINUS_CONSTANT_ALPHA = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x8004, .hex); +pub const RL_FUNC_ADD = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x8006, .hex); +pub const RL_MIN = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x8007, .hex); +pub const RL_MAX = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x8008, .hex); +pub const RL_FUNC_SUBTRACT = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x800A, .hex); +pub const RL_FUNC_REVERSE_SUBTRACT = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x800B, .hex); +pub const RL_BLEND_EQUATION = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x8009, .hex); +pub const RL_BLEND_EQUATION_RGB = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x8009, .hex); +pub const RL_BLEND_EQUATION_ALPHA = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x883D, .hex); +pub const RL_BLEND_DST_RGB = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x80C8, .hex); +pub const RL_BLEND_SRC_RGB = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x80C9, .hex); +pub const RL_BLEND_DST_ALPHA = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x80CA, .hex); +pub const RL_BLEND_SRC_ALPHA = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x80CB, .hex); +pub const RL_BLEND_COLOR = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x8005, .hex); +pub const RL_READ_FRAMEBUFFER = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x8CA8, .hex); +pub const RL_DRAW_FRAMEBUFFER = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x8CA9, .hex); +pub const RL_SHADER_LOC_MAP_DIFFUSE = RL_SHADER_LOC_MAP_ALBEDO; +pub const RL_SHADER_LOC_MAP_SPECULAR = RL_SHADER_LOC_MAP_METALNESS; +pub const RAYMATH_H = ""; +pub const RMAPI = @compileError("unable to translate C expr: unexpected token 'inline'"); +// ./raymath.h:76:17 +pub const EPSILON = @as(f32, 0.000001); +pub inline fn MatrixToFloat(mat: anytype) @TypeOf(MatrixToFloatV(mat).v) { + _ = &mat; + return MatrixToFloatV(mat).v; +} +pub inline fn Vector3ToFloat(vec: anytype) @TypeOf(Vector3ToFloatV(vec).v) { + _ = &vec; + return Vector3ToFloatV(vec).v; +} +pub const _MATH_H = @as(c_int, 1); +pub const __GLIBC_INTERNAL_STARTING_HEADER_IMPLEMENTATION = ""; +pub const _FEATURES_H = @as(c_int, 1); +pub const __KERNEL_STRICT_NAMES = ""; +pub inline fn __GNUC_PREREQ(maj: anytype, min: anytype) @TypeOf(((__GNUC__ << @as(c_int, 16)) + __GNUC_MINOR__) >= ((maj << @as(c_int, 16)) + min)) { + _ = &maj; + _ = &min; + return ((__GNUC__ << @as(c_int, 16)) + __GNUC_MINOR__) >= ((maj << @as(c_int, 16)) + min); +} +pub inline fn __glibc_clang_prereq(maj: anytype, min: anytype) @TypeOf(((__clang_major__ << @as(c_int, 16)) + __clang_minor__) >= ((maj << @as(c_int, 16)) + min)) { + _ = &maj; + _ = &min; + return ((__clang_major__ << @as(c_int, 16)) + __clang_minor__) >= ((maj << @as(c_int, 16)) + min); +} +pub const __GLIBC_USE = @compileError("unable to translate macro: undefined identifier `__GLIBC_USE_`"); +// /usr/include/features.h:189:9 +pub const _DEFAULT_SOURCE = @as(c_int, 1); +pub const __GLIBC_USE_ISOC23 = @as(c_int, 0); +pub const __USE_ISOC11 = @as(c_int, 1); +pub const __USE_ISOC99 = @as(c_int, 1); +pub const __USE_ISOC95 = @as(c_int, 1); +pub const __USE_POSIX_IMPLICITLY = @as(c_int, 1); +pub const _POSIX_SOURCE = @as(c_int, 1); +pub const _POSIX_C_SOURCE = @as(c_long, 200809); +pub const __USE_POSIX = @as(c_int, 1); +pub const __USE_POSIX2 = @as(c_int, 1); +pub const __USE_POSIX199309 = @as(c_int, 1); +pub const __USE_POSIX199506 = @as(c_int, 1); +pub const __USE_XOPEN2K = @as(c_int, 1); +pub const __USE_XOPEN2K8 = @as(c_int, 1); +pub const _ATFILE_SOURCE = @as(c_int, 1); +pub const __WORDSIZE = @as(c_int, 64); +pub const __WORDSIZE_TIME64_COMPAT32 = @as(c_int, 1); +pub const __SYSCALL_WORDSIZE = @as(c_int, 64); +pub const __TIMESIZE = __WORDSIZE; +pub const __USE_TIME_BITS64 = @as(c_int, 1); +pub const __USE_MISC = @as(c_int, 1); +pub const __USE_ATFILE = @as(c_int, 1); +pub const __USE_FORTIFY_LEVEL = @as(c_int, 0); +pub const __GLIBC_USE_DEPRECATED_GETS = @as(c_int, 0); +pub const __GLIBC_USE_DEPRECATED_SCANF = @as(c_int, 0); +pub const __GLIBC_USE_C23_STRTOL = @as(c_int, 0); +pub const _STDC_PREDEF_H = @as(c_int, 1); +pub const __STDC_IEC_559__ = @as(c_int, 1); +pub const __STDC_IEC_60559_BFP__ = @as(c_long, 201404); +pub const __STDC_IEC_559_COMPLEX__ = @as(c_int, 1); +pub const __STDC_IEC_60559_COMPLEX__ = @as(c_long, 201404); +pub const __STDC_ISO_10646__ = @as(c_long, 201706); +pub const __GNU_LIBRARY__ = @as(c_int, 6); +pub const __GLIBC__ = @as(c_int, 2); +pub inline fn __GLIBC_PREREQ(maj: anytype, min: anytype) @TypeOf(((__GLIBC__ << @as(c_int, 16)) + __GLIBC_MINOR__) >= ((maj << @as(c_int, 16)) + min)) { + _ = &maj; + _ = &min; + return ((__GLIBC__ << @as(c_int, 16)) + __GLIBC_MINOR__) >= ((maj << @as(c_int, 16)) + min); +} +pub const _SYS_CDEFS_H = @as(c_int, 1); +pub const __glibc_has_attribute = @compileError("unable to translate macro: undefined identifier `__has_attribute`"); +// /usr/include/sys/cdefs.h:45:10 +pub inline fn __glibc_has_builtin(name: anytype) @TypeOf(__has_builtin(name)) { + _ = &name; + return __has_builtin(name); +} +pub const __glibc_has_extension = @compileError("unable to translate macro: undefined identifier `__has_extension`"); +// /usr/include/sys/cdefs.h:55:10 +pub const __LEAF = ""; +pub const __LEAF_ATTR = ""; +pub const __THROW = @compileError("unable to translate macro: undefined identifier `__nothrow__`"); +// /usr/include/sys/cdefs.h:79:11 +pub const __THROWNL = @compileError("unable to translate macro: undefined identifier `__nothrow__`"); +// /usr/include/sys/cdefs.h:80:11 +pub const __NTH = @compileError("unable to translate macro: undefined identifier `__nothrow__`"); +// /usr/include/sys/cdefs.h:81:11 +pub const __NTHNL = @compileError("unable to translate macro: undefined identifier `__nothrow__`"); +// /usr/include/sys/cdefs.h:82:11 +pub const __COLD = @compileError("unable to translate macro: undefined identifier `__cold__`"); +// /usr/include/sys/cdefs.h:102:11 +pub inline fn __P(args: anytype) @TypeOf(args) { + _ = &args; + return args; +} +pub inline fn __PMT(args: anytype) @TypeOf(args) { + _ = &args; + return args; +} +pub const __CONCAT = @compileError("unable to translate C expr: unexpected token '##'"); +// /usr/include/sys/cdefs.h:131:9 +pub const __STRING = @compileError("unable to translate C expr: unexpected token '#'"); +// /usr/include/sys/cdefs.h:132:9 +pub const __ptr_t = ?*anyopaque; +pub const __BEGIN_DECLS = ""; +pub const __END_DECLS = ""; +pub const __attribute_overloadable__ = @compileError("unable to translate macro: undefined identifier `__overloadable__`"); +// /usr/include/sys/cdefs.h:151:10 +pub inline fn __bos(ptr: anytype) @TypeOf(__builtin_object_size(ptr, __USE_FORTIFY_LEVEL > @as(c_int, 1))) { + _ = &ptr; + return __builtin_object_size(ptr, __USE_FORTIFY_LEVEL > @as(c_int, 1)); +} +pub inline fn __bos0(ptr: anytype) @TypeOf(__builtin_object_size(ptr, @as(c_int, 0))) { + _ = &ptr; + return __builtin_object_size(ptr, @as(c_int, 0)); +} +pub inline fn __glibc_objsize0(__o: anytype) @TypeOf(__bos0(__o)) { + _ = &__o; + return __bos0(__o); +} +pub inline fn __glibc_objsize(__o: anytype) @TypeOf(__bos(__o)) { + _ = &__o; + return __bos(__o); +} +pub const __warnattr = @compileError("unable to translate C expr: unexpected token ''"); +// /usr/include/sys/cdefs.h:370:10 +pub const __errordecl = @compileError("unable to translate C expr: unexpected token 'extern'"); +// /usr/include/sys/cdefs.h:371:10 +pub const __flexarr = @compileError("unable to translate C expr: unexpected token '['"); +// /usr/include/sys/cdefs.h:379:10 +pub const __glibc_c99_flexarr_available = @as(c_int, 1); +pub const __REDIRECT = @compileError("unable to translate C expr: unexpected token '__asm__'"); +// /usr/include/sys/cdefs.h:410:10 +pub const __REDIRECT_NTH = @compileError("unable to translate C expr: unexpected token '__asm__'"); +// /usr/include/sys/cdefs.h:417:11 +pub const __REDIRECT_NTHNL = @compileError("unable to translate C expr: unexpected token '__asm__'"); +// /usr/include/sys/cdefs.h:419:11 +pub const __ASMNAME = @compileError("unable to translate C expr: unexpected token ','"); +// /usr/include/sys/cdefs.h:422:10 +pub inline fn __ASMNAME2(prefix: anytype, cname: anytype) @TypeOf(__STRING(prefix) ++ cname) { + _ = &prefix; + _ = &cname; + return __STRING(prefix) ++ cname; +} +pub const __REDIRECT_FORTIFY = __REDIRECT; +pub const __REDIRECT_FORTIFY_NTH = __REDIRECT_NTH; +pub const __attribute_malloc__ = @compileError("unable to translate macro: undefined identifier `__malloc__`"); +// /usr/include/sys/cdefs.h:452:10 +pub const __attribute_alloc_size__ = @compileError("unable to translate C expr: unexpected token ''"); +// /usr/include/sys/cdefs.h:463:10 +pub const __attribute_alloc_align__ = @compileError("unable to translate macro: undefined identifier `__alloc_align__`"); +// /usr/include/sys/cdefs.h:469:10 +pub const __attribute_pure__ = @compileError("unable to translate macro: undefined identifier `__pure__`"); +// /usr/include/sys/cdefs.h:479:10 +pub const __attribute_const__ = @compileError("unable to translate C expr: unexpected token '__attribute__'"); +// /usr/include/sys/cdefs.h:486:10 +pub const __attribute_maybe_unused__ = @compileError("unable to translate macro: undefined identifier `__unused__`"); +// /usr/include/sys/cdefs.h:492:10 +pub const __attribute_used__ = @compileError("unable to translate macro: undefined identifier `__used__`"); +// /usr/include/sys/cdefs.h:501:10 +pub const __attribute_noinline__ = @compileError("unable to translate macro: undefined identifier `__noinline__`"); +// /usr/include/sys/cdefs.h:502:10 +pub const __attribute_deprecated__ = @compileError("unable to translate macro: undefined identifier `__deprecated__`"); +// /usr/include/sys/cdefs.h:510:10 +pub const __attribute_deprecated_msg__ = @compileError("unable to translate macro: undefined identifier `__deprecated__`"); +// /usr/include/sys/cdefs.h:520:10 +pub const __attribute_format_arg__ = @compileError("unable to translate macro: undefined identifier `__format_arg__`"); +// /usr/include/sys/cdefs.h:533:10 +pub const __attribute_format_strfmon__ = @compileError("unable to translate macro: undefined identifier `__format__`"); +// /usr/include/sys/cdefs.h:543:10 +pub const __attribute_nonnull__ = @compileError("unable to translate macro: undefined identifier `__nonnull__`"); +// /usr/include/sys/cdefs.h:555:11 +pub inline fn __nonnull(params: anytype) @TypeOf(__attribute_nonnull__(params)) { + _ = ¶ms; + return __attribute_nonnull__(params); +} +pub const __returns_nonnull = @compileError("unable to translate macro: undefined identifier `__returns_nonnull__`"); +// /usr/include/sys/cdefs.h:568:10 +pub const __attribute_warn_unused_result__ = @compileError("unable to translate macro: undefined identifier `__warn_unused_result__`"); +// /usr/include/sys/cdefs.h:577:10 +pub const __wur = ""; +pub const __always_inline = @compileError("unable to translate macro: undefined identifier `__always_inline__`"); +// /usr/include/sys/cdefs.h:595:10 +pub const __attribute_artificial__ = @compileError("unable to translate macro: undefined identifier `__artificial__`"); +// /usr/include/sys/cdefs.h:604:10 +pub const __extern_inline = @compileError("unable to translate macro: undefined identifier `__gnu_inline__`"); +// /usr/include/sys/cdefs.h:622:11 +pub const __extern_always_inline = @compileError("unable to translate macro: undefined identifier `__gnu_inline__`"); +// /usr/include/sys/cdefs.h:623:11 +pub const __fortify_function = __extern_always_inline ++ __attribute_artificial__; +pub const __restrict_arr = @compileError("unable to translate C expr: unexpected token '__restrict'"); +// /usr/include/sys/cdefs.h:666:10 +pub inline fn __glibc_unlikely(cond: anytype) @TypeOf(__builtin_expect(cond, @as(c_int, 0))) { + _ = &cond; + return __builtin_expect(cond, @as(c_int, 0)); +} +pub inline fn __glibc_likely(cond: anytype) @TypeOf(__builtin_expect(cond, @as(c_int, 1))) { + _ = &cond; + return __builtin_expect(cond, @as(c_int, 1)); +} +pub const __attribute_nonstring__ = ""; +pub const __attribute_copy__ = @compileError("unable to translate C expr: unexpected token ''"); +// /usr/include/sys/cdefs.h:715:10 +pub const __LDOUBLE_REDIRECTS_TO_FLOAT128_ABI = @as(c_int, 0); +pub inline fn __LDBL_REDIR1(name: anytype, proto: anytype, alias: anytype) @TypeOf(name ++ proto) { + _ = &name; + _ = &proto; + _ = &alias; + return name ++ proto; +} +pub inline fn __LDBL_REDIR(name: anytype, proto: anytype) @TypeOf(name ++ proto) { + _ = &name; + _ = &proto; + return name ++ proto; +} +pub inline fn __LDBL_REDIR1_NTH(name: anytype, proto: anytype, alias: anytype) @TypeOf(name ++ proto ++ __THROW) { + _ = &name; + _ = &proto; + _ = &alias; + return name ++ proto ++ __THROW; +} +pub inline fn __LDBL_REDIR_NTH(name: anytype, proto: anytype) @TypeOf(name ++ proto ++ __THROW) { + _ = &name; + _ = &proto; + return name ++ proto ++ __THROW; +} +pub const __LDBL_REDIR2_DECL = @compileError("unable to translate C expr: unexpected token ''"); +// /usr/include/sys/cdefs.h:792:10 +pub const __LDBL_REDIR_DECL = @compileError("unable to translate C expr: unexpected token ''"); +// /usr/include/sys/cdefs.h:793:10 +pub inline fn __REDIRECT_LDBL(name: anytype, proto: anytype, alias: anytype) @TypeOf(__REDIRECT(name, proto, alias)) { + _ = &name; + _ = &proto; + _ = &alias; + return __REDIRECT(name, proto, alias); +} +pub inline fn __REDIRECT_NTH_LDBL(name: anytype, proto: anytype, alias: anytype) @TypeOf(__REDIRECT_NTH(name, proto, alias)) { + _ = &name; + _ = &proto; + _ = &alias; + return __REDIRECT_NTH(name, proto, alias); +} +pub const __glibc_macro_warning1 = @compileError("unable to translate macro: undefined identifier `_Pragma`"); +// /usr/include/sys/cdefs.h:807:10 +pub const __glibc_macro_warning = @compileError("unable to translate macro: undefined identifier `GCC`"); +// /usr/include/sys/cdefs.h:808:10 +pub const __HAVE_GENERIC_SELECTION = @as(c_int, 1); +pub const __fortified_attr_access = @compileError("unable to translate C expr: unexpected token ''"); +// /usr/include/sys/cdefs.h:853:11 +pub const __attr_access = @compileError("unable to translate C expr: unexpected token ''"); +// /usr/include/sys/cdefs.h:854:11 +pub const __attr_access_none = @compileError("unable to translate C expr: unexpected token ''"); +// /usr/include/sys/cdefs.h:855:11 +pub const __attr_dealloc = @compileError("unable to translate C expr: unexpected token ''"); +// /usr/include/sys/cdefs.h:865:10 +pub const __attr_dealloc_free = ""; +pub const __attribute_returns_twice__ = @compileError("unable to translate macro: undefined identifier `__returns_twice__`"); +// /usr/include/sys/cdefs.h:872:10 +pub const __attribute_struct_may_alias__ = @compileError("unable to translate macro: undefined identifier `__may_alias__`"); +// /usr/include/sys/cdefs.h:881:10 +pub const __stub___compat_bdflush = ""; +pub const __stub_chflags = ""; +pub const __stub_fchflags = ""; +pub const __stub_gtty = ""; +pub const __stub_revoke = ""; +pub const __stub_setlogin = ""; +pub const __stub_sigreturn = ""; +pub const __stub_stty = ""; +pub const __GLIBC_USE_LIB_EXT2 = @as(c_int, 0); +pub const __GLIBC_USE_IEC_60559_BFP_EXT = @as(c_int, 0); +pub const __GLIBC_USE_IEC_60559_BFP_EXT_C23 = @as(c_int, 0); +pub const __GLIBC_USE_IEC_60559_EXT = @as(c_int, 0); +pub const __GLIBC_USE_IEC_60559_FUNCS_EXT = @as(c_int, 0); +pub const __GLIBC_USE_IEC_60559_FUNCS_EXT_C23 = @as(c_int, 0); +pub const __GLIBC_USE_IEC_60559_TYPES_EXT = @as(c_int, 0); +pub const _BITS_TYPES_H = @as(c_int, 1); +pub const __S16_TYPE = c_short; +pub const __U16_TYPE = c_ushort; +pub const __S32_TYPE = c_int; +pub const __U32_TYPE = c_uint; +pub const __SLONGWORD_TYPE = c_long; +pub const __ULONGWORD_TYPE = c_ulong; +pub const __SQUAD_TYPE = c_long; +pub const __UQUAD_TYPE = c_ulong; +pub const __SWORD_TYPE = c_long; +pub const __UWORD_TYPE = c_ulong; +pub const __SLONG32_TYPE = c_int; +pub const __ULONG32_TYPE = c_uint; +pub const __S64_TYPE = c_long; +pub const __U64_TYPE = c_ulong; +pub const __STD_TYPE = @compileError("unable to translate C expr: unexpected token 'typedef'"); +// /usr/include/bits/types.h:137:10 +pub const _BITS_TYPESIZES_H = @as(c_int, 1); +pub const __SYSCALL_SLONG_TYPE = __SLONGWORD_TYPE; +pub const __SYSCALL_ULONG_TYPE = __ULONGWORD_TYPE; +pub const __DEV_T_TYPE = __UQUAD_TYPE; +pub const __UID_T_TYPE = __U32_TYPE; +pub const __GID_T_TYPE = __U32_TYPE; +pub const __INO_T_TYPE = __SYSCALL_ULONG_TYPE; +pub const __INO64_T_TYPE = __UQUAD_TYPE; +pub const __MODE_T_TYPE = __U32_TYPE; +pub const __NLINK_T_TYPE = __SYSCALL_ULONG_TYPE; +pub const __FSWORD_T_TYPE = __SYSCALL_SLONG_TYPE; +pub const __OFF_T_TYPE = __SYSCALL_SLONG_TYPE; +pub const __OFF64_T_TYPE = __SQUAD_TYPE; +pub const __PID_T_TYPE = __S32_TYPE; +pub const __RLIM_T_TYPE = __SYSCALL_ULONG_TYPE; +pub const __RLIM64_T_TYPE = __UQUAD_TYPE; +pub const __BLKCNT_T_TYPE = __SYSCALL_SLONG_TYPE; +pub const __BLKCNT64_T_TYPE = __SQUAD_TYPE; +pub const __FSBLKCNT_T_TYPE = __SYSCALL_ULONG_TYPE; +pub const __FSBLKCNT64_T_TYPE = __UQUAD_TYPE; +pub const __FSFILCNT_T_TYPE = __SYSCALL_ULONG_TYPE; +pub const __FSFILCNT64_T_TYPE = __UQUAD_TYPE; +pub const __ID_T_TYPE = __U32_TYPE; +pub const __CLOCK_T_TYPE = __SYSCALL_SLONG_TYPE; +pub const __TIME_T_TYPE = __SYSCALL_SLONG_TYPE; +pub const __USECONDS_T_TYPE = __U32_TYPE; +pub const __SUSECONDS_T_TYPE = __SYSCALL_SLONG_TYPE; +pub const __SUSECONDS64_T_TYPE = __SQUAD_TYPE; +pub const __DADDR_T_TYPE = __S32_TYPE; +pub const __KEY_T_TYPE = __S32_TYPE; +pub const __CLOCKID_T_TYPE = __S32_TYPE; +pub const __TIMER_T_TYPE = ?*anyopaque; +pub const __BLKSIZE_T_TYPE = __SYSCALL_SLONG_TYPE; +pub const __FSID_T_TYPE = @compileError("unable to translate macro: undefined identifier `__val`"); +// /usr/include/bits/typesizes.h:73:9 +pub const __SSIZE_T_TYPE = __SWORD_TYPE; +pub const __CPU_MASK_TYPE = __SYSCALL_ULONG_TYPE; +pub const __OFF_T_MATCHES_OFF64_T = @as(c_int, 1); +pub const __INO_T_MATCHES_INO64_T = @as(c_int, 1); +pub const __RLIM_T_MATCHES_RLIM64_T = @as(c_int, 1); +pub const __STATFS_MATCHES_STATFS64 = @as(c_int, 1); +pub const __KERNEL_OLD_TIMEVAL_MATCHES_TIMEVAL64 = @as(c_int, 1); +pub const __FD_SETSIZE = @as(c_int, 1024); +pub const _BITS_TIME64_H = @as(c_int, 1); +pub const __TIME64_T_TYPE = __TIME_T_TYPE; +pub const _BITS_LIBM_SIMD_DECL_STUBS_H = @as(c_int, 1); +pub const __DECL_SIMD_cos = ""; +pub const __DECL_SIMD_cosf = ""; +pub const __DECL_SIMD_cosl = ""; +pub const __DECL_SIMD_cosf16 = ""; +pub const __DECL_SIMD_cosf32 = ""; +pub const __DECL_SIMD_cosf64 = ""; +pub const __DECL_SIMD_cosf128 = ""; +pub const __DECL_SIMD_cosf32x = ""; +pub const __DECL_SIMD_cosf64x = ""; +pub const __DECL_SIMD_cosf128x = ""; +pub const __DECL_SIMD_sin = ""; +pub const __DECL_SIMD_sinf = ""; +pub const __DECL_SIMD_sinl = ""; +pub const __DECL_SIMD_sinf16 = ""; +pub const __DECL_SIMD_sinf32 = ""; +pub const __DECL_SIMD_sinf64 = ""; +pub const __DECL_SIMD_sinf128 = ""; +pub const __DECL_SIMD_sinf32x = ""; +pub const __DECL_SIMD_sinf64x = ""; +pub const __DECL_SIMD_sinf128x = ""; +pub const __DECL_SIMD_sincos = ""; +pub const __DECL_SIMD_sincosf = ""; +pub const __DECL_SIMD_sincosl = ""; +pub const __DECL_SIMD_sincosf16 = ""; +pub const __DECL_SIMD_sincosf32 = ""; +pub const __DECL_SIMD_sincosf64 = ""; +pub const __DECL_SIMD_sincosf128 = ""; +pub const __DECL_SIMD_sincosf32x = ""; +pub const __DECL_SIMD_sincosf64x = ""; +pub const __DECL_SIMD_sincosf128x = ""; +pub const __DECL_SIMD_log = ""; +pub const __DECL_SIMD_logf = ""; +pub const __DECL_SIMD_logl = ""; +pub const __DECL_SIMD_logf16 = ""; +pub const __DECL_SIMD_logf32 = ""; +pub const __DECL_SIMD_logf64 = ""; +pub const __DECL_SIMD_logf128 = ""; +pub const __DECL_SIMD_logf32x = ""; +pub const __DECL_SIMD_logf64x = ""; +pub const __DECL_SIMD_logf128x = ""; +pub const __DECL_SIMD_exp = ""; +pub const __DECL_SIMD_expf = ""; +pub const __DECL_SIMD_expl = ""; +pub const __DECL_SIMD_expf16 = ""; +pub const __DECL_SIMD_expf32 = ""; +pub const __DECL_SIMD_expf64 = ""; +pub const __DECL_SIMD_expf128 = ""; +pub const __DECL_SIMD_expf32x = ""; +pub const __DECL_SIMD_expf64x = ""; +pub const __DECL_SIMD_expf128x = ""; +pub const __DECL_SIMD_pow = ""; +pub const __DECL_SIMD_powf = ""; +pub const __DECL_SIMD_powl = ""; +pub const __DECL_SIMD_powf16 = ""; +pub const __DECL_SIMD_powf32 = ""; +pub const __DECL_SIMD_powf64 = ""; +pub const __DECL_SIMD_powf128 = ""; +pub const __DECL_SIMD_powf32x = ""; +pub const __DECL_SIMD_powf64x = ""; +pub const __DECL_SIMD_powf128x = ""; +pub const __DECL_SIMD_acos = ""; +pub const __DECL_SIMD_acosf = ""; +pub const __DECL_SIMD_acosl = ""; +pub const __DECL_SIMD_acosf16 = ""; +pub const __DECL_SIMD_acosf32 = ""; +pub const __DECL_SIMD_acosf64 = ""; +pub const __DECL_SIMD_acosf128 = ""; +pub const __DECL_SIMD_acosf32x = ""; +pub const __DECL_SIMD_acosf64x = ""; +pub const __DECL_SIMD_acosf128x = ""; +pub const __DECL_SIMD_atan = ""; +pub const __DECL_SIMD_atanf = ""; +pub const __DECL_SIMD_atanl = ""; +pub const __DECL_SIMD_atanf16 = ""; +pub const __DECL_SIMD_atanf32 = ""; +pub const __DECL_SIMD_atanf64 = ""; +pub const __DECL_SIMD_atanf128 = ""; +pub const __DECL_SIMD_atanf32x = ""; +pub const __DECL_SIMD_atanf64x = ""; +pub const __DECL_SIMD_atanf128x = ""; +pub const __DECL_SIMD_asin = ""; +pub const __DECL_SIMD_asinf = ""; +pub const __DECL_SIMD_asinl = ""; +pub const __DECL_SIMD_asinf16 = ""; +pub const __DECL_SIMD_asinf32 = ""; +pub const __DECL_SIMD_asinf64 = ""; +pub const __DECL_SIMD_asinf128 = ""; +pub const __DECL_SIMD_asinf32x = ""; +pub const __DECL_SIMD_asinf64x = ""; +pub const __DECL_SIMD_asinf128x = ""; +pub const __DECL_SIMD_hypot = ""; +pub const __DECL_SIMD_hypotf = ""; +pub const __DECL_SIMD_hypotl = ""; +pub const __DECL_SIMD_hypotf16 = ""; +pub const __DECL_SIMD_hypotf32 = ""; +pub const __DECL_SIMD_hypotf64 = ""; +pub const __DECL_SIMD_hypotf128 = ""; +pub const __DECL_SIMD_hypotf32x = ""; +pub const __DECL_SIMD_hypotf64x = ""; +pub const __DECL_SIMD_hypotf128x = ""; +pub const __DECL_SIMD_exp2 = ""; +pub const __DECL_SIMD_exp2f = ""; +pub const __DECL_SIMD_exp2l = ""; +pub const __DECL_SIMD_exp2f16 = ""; +pub const __DECL_SIMD_exp2f32 = ""; +pub const __DECL_SIMD_exp2f64 = ""; +pub const __DECL_SIMD_exp2f128 = ""; +pub const __DECL_SIMD_exp2f32x = ""; +pub const __DECL_SIMD_exp2f64x = ""; +pub const __DECL_SIMD_exp2f128x = ""; +pub const __DECL_SIMD_exp10 = ""; +pub const __DECL_SIMD_exp10f = ""; +pub const __DECL_SIMD_exp10l = ""; +pub const __DECL_SIMD_exp10f16 = ""; +pub const __DECL_SIMD_exp10f32 = ""; +pub const __DECL_SIMD_exp10f64 = ""; +pub const __DECL_SIMD_exp10f128 = ""; +pub const __DECL_SIMD_exp10f32x = ""; +pub const __DECL_SIMD_exp10f64x = ""; +pub const __DECL_SIMD_exp10f128x = ""; +pub const __DECL_SIMD_cosh = ""; +pub const __DECL_SIMD_coshf = ""; +pub const __DECL_SIMD_coshl = ""; +pub const __DECL_SIMD_coshf16 = ""; +pub const __DECL_SIMD_coshf32 = ""; +pub const __DECL_SIMD_coshf64 = ""; +pub const __DECL_SIMD_coshf128 = ""; +pub const __DECL_SIMD_coshf32x = ""; +pub const __DECL_SIMD_coshf64x = ""; +pub const __DECL_SIMD_coshf128x = ""; +pub const __DECL_SIMD_expm1 = ""; +pub const __DECL_SIMD_expm1f = ""; +pub const __DECL_SIMD_expm1l = ""; +pub const __DECL_SIMD_expm1f16 = ""; +pub const __DECL_SIMD_expm1f32 = ""; +pub const __DECL_SIMD_expm1f64 = ""; +pub const __DECL_SIMD_expm1f128 = ""; +pub const __DECL_SIMD_expm1f32x = ""; +pub const __DECL_SIMD_expm1f64x = ""; +pub const __DECL_SIMD_expm1f128x = ""; +pub const __DECL_SIMD_sinh = ""; +pub const __DECL_SIMD_sinhf = ""; +pub const __DECL_SIMD_sinhl = ""; +pub const __DECL_SIMD_sinhf16 = ""; +pub const __DECL_SIMD_sinhf32 = ""; +pub const __DECL_SIMD_sinhf64 = ""; +pub const __DECL_SIMD_sinhf128 = ""; +pub const __DECL_SIMD_sinhf32x = ""; +pub const __DECL_SIMD_sinhf64x = ""; +pub const __DECL_SIMD_sinhf128x = ""; +pub const __DECL_SIMD_cbrt = ""; +pub const __DECL_SIMD_cbrtf = ""; +pub const __DECL_SIMD_cbrtl = ""; +pub const __DECL_SIMD_cbrtf16 = ""; +pub const __DECL_SIMD_cbrtf32 = ""; +pub const __DECL_SIMD_cbrtf64 = ""; +pub const __DECL_SIMD_cbrtf128 = ""; +pub const __DECL_SIMD_cbrtf32x = ""; +pub const __DECL_SIMD_cbrtf64x = ""; +pub const __DECL_SIMD_cbrtf128x = ""; +pub const __DECL_SIMD_atan2 = ""; +pub const __DECL_SIMD_atan2f = ""; +pub const __DECL_SIMD_atan2l = ""; +pub const __DECL_SIMD_atan2f16 = ""; +pub const __DECL_SIMD_atan2f32 = ""; +pub const __DECL_SIMD_atan2f64 = ""; +pub const __DECL_SIMD_atan2f128 = ""; +pub const __DECL_SIMD_atan2f32x = ""; +pub const __DECL_SIMD_atan2f64x = ""; +pub const __DECL_SIMD_atan2f128x = ""; +pub const __DECL_SIMD_log10 = ""; +pub const __DECL_SIMD_log10f = ""; +pub const __DECL_SIMD_log10l = ""; +pub const __DECL_SIMD_log10f16 = ""; +pub const __DECL_SIMD_log10f32 = ""; +pub const __DECL_SIMD_log10f64 = ""; +pub const __DECL_SIMD_log10f128 = ""; +pub const __DECL_SIMD_log10f32x = ""; +pub const __DECL_SIMD_log10f64x = ""; +pub const __DECL_SIMD_log10f128x = ""; +pub const __DECL_SIMD_log2 = ""; +pub const __DECL_SIMD_log2f = ""; +pub const __DECL_SIMD_log2l = ""; +pub const __DECL_SIMD_log2f16 = ""; +pub const __DECL_SIMD_log2f32 = ""; +pub const __DECL_SIMD_log2f64 = ""; +pub const __DECL_SIMD_log2f128 = ""; +pub const __DECL_SIMD_log2f32x = ""; +pub const __DECL_SIMD_log2f64x = ""; +pub const __DECL_SIMD_log2f128x = ""; +pub const __DECL_SIMD_log1p = ""; +pub const __DECL_SIMD_log1pf = ""; +pub const __DECL_SIMD_log1pl = ""; +pub const __DECL_SIMD_log1pf16 = ""; +pub const __DECL_SIMD_log1pf32 = ""; +pub const __DECL_SIMD_log1pf64 = ""; +pub const __DECL_SIMD_log1pf128 = ""; +pub const __DECL_SIMD_log1pf32x = ""; +pub const __DECL_SIMD_log1pf64x = ""; +pub const __DECL_SIMD_log1pf128x = ""; +pub const __DECL_SIMD_atanh = ""; +pub const __DECL_SIMD_atanhf = ""; +pub const __DECL_SIMD_atanhl = ""; +pub const __DECL_SIMD_atanhf16 = ""; +pub const __DECL_SIMD_atanhf32 = ""; +pub const __DECL_SIMD_atanhf64 = ""; +pub const __DECL_SIMD_atanhf128 = ""; +pub const __DECL_SIMD_atanhf32x = ""; +pub const __DECL_SIMD_atanhf64x = ""; +pub const __DECL_SIMD_atanhf128x = ""; +pub const __DECL_SIMD_acosh = ""; +pub const __DECL_SIMD_acoshf = ""; +pub const __DECL_SIMD_acoshl = ""; +pub const __DECL_SIMD_acoshf16 = ""; +pub const __DECL_SIMD_acoshf32 = ""; +pub const __DECL_SIMD_acoshf64 = ""; +pub const __DECL_SIMD_acoshf128 = ""; +pub const __DECL_SIMD_acoshf32x = ""; +pub const __DECL_SIMD_acoshf64x = ""; +pub const __DECL_SIMD_acoshf128x = ""; +pub const __DECL_SIMD_erf = ""; +pub const __DECL_SIMD_erff = ""; +pub const __DECL_SIMD_erfl = ""; +pub const __DECL_SIMD_erff16 = ""; +pub const __DECL_SIMD_erff32 = ""; +pub const __DECL_SIMD_erff64 = ""; +pub const __DECL_SIMD_erff128 = ""; +pub const __DECL_SIMD_erff32x = ""; +pub const __DECL_SIMD_erff64x = ""; +pub const __DECL_SIMD_erff128x = ""; +pub const __DECL_SIMD_tanh = ""; +pub const __DECL_SIMD_tanhf = ""; +pub const __DECL_SIMD_tanhl = ""; +pub const __DECL_SIMD_tanhf16 = ""; +pub const __DECL_SIMD_tanhf32 = ""; +pub const __DECL_SIMD_tanhf64 = ""; +pub const __DECL_SIMD_tanhf128 = ""; +pub const __DECL_SIMD_tanhf32x = ""; +pub const __DECL_SIMD_tanhf64x = ""; +pub const __DECL_SIMD_tanhf128x = ""; +pub const __DECL_SIMD_asinh = ""; +pub const __DECL_SIMD_asinhf = ""; +pub const __DECL_SIMD_asinhl = ""; +pub const __DECL_SIMD_asinhf16 = ""; +pub const __DECL_SIMD_asinhf32 = ""; +pub const __DECL_SIMD_asinhf64 = ""; +pub const __DECL_SIMD_asinhf128 = ""; +pub const __DECL_SIMD_asinhf32x = ""; +pub const __DECL_SIMD_asinhf64x = ""; +pub const __DECL_SIMD_asinhf128x = ""; +pub const __DECL_SIMD_erfc = ""; +pub const __DECL_SIMD_erfcf = ""; +pub const __DECL_SIMD_erfcl = ""; +pub const __DECL_SIMD_erfcf16 = ""; +pub const __DECL_SIMD_erfcf32 = ""; +pub const __DECL_SIMD_erfcf64 = ""; +pub const __DECL_SIMD_erfcf128 = ""; +pub const __DECL_SIMD_erfcf32x = ""; +pub const __DECL_SIMD_erfcf64x = ""; +pub const __DECL_SIMD_erfcf128x = ""; +pub const __DECL_SIMD_tan = ""; +pub const __DECL_SIMD_tanf = ""; +pub const __DECL_SIMD_tanl = ""; +pub const __DECL_SIMD_tanf16 = ""; +pub const __DECL_SIMD_tanf32 = ""; +pub const __DECL_SIMD_tanf64 = ""; +pub const __DECL_SIMD_tanf128 = ""; +pub const __DECL_SIMD_tanf32x = ""; +pub const __DECL_SIMD_tanf64x = ""; +pub const __DECL_SIMD_tanf128x = ""; +pub const _BITS_FLOATN_H = ""; +pub const __HAVE_FLOAT128 = @as(c_int, 0); +pub const __HAVE_DISTINCT_FLOAT128 = @as(c_int, 0); +pub const __HAVE_FLOAT64X = @as(c_int, 1); +pub const __HAVE_FLOAT64X_LONG_DOUBLE = @as(c_int, 1); +pub const _BITS_FLOATN_COMMON_H = ""; +pub const __HAVE_FLOAT16 = @as(c_int, 0); +pub const __HAVE_FLOAT32 = @as(c_int, 1); +pub const __HAVE_FLOAT64 = @as(c_int, 1); +pub const __HAVE_FLOAT32X = @as(c_int, 1); +pub const __HAVE_FLOAT128X = @as(c_int, 0); +pub const __HAVE_DISTINCT_FLOAT16 = __HAVE_FLOAT16; +pub const __HAVE_DISTINCT_FLOAT32 = @as(c_int, 0); +pub const __HAVE_DISTINCT_FLOAT64 = @as(c_int, 0); +pub const __HAVE_DISTINCT_FLOAT32X = @as(c_int, 0); +pub const __HAVE_DISTINCT_FLOAT64X = @as(c_int, 0); +pub const __HAVE_DISTINCT_FLOAT128X = __HAVE_FLOAT128X; +pub const __HAVE_FLOAT128_UNLIKE_LDBL = (__HAVE_DISTINCT_FLOAT128 != 0) and (__LDBL_MANT_DIG__ != @as(c_int, 113)); +pub const __HAVE_FLOATN_NOT_TYPEDEF = @as(c_int, 0); +pub const __f32 = @import("std").zig.c_translation.Macros.F_SUFFIX; +pub inline fn __f64(x: anytype) @TypeOf(x) { + _ = &x; + return x; +} +pub inline fn __f32x(x: anytype) @TypeOf(x) { + _ = &x; + return x; +} +pub const __f64x = @import("std").zig.c_translation.Macros.L_SUFFIX; +pub const __CFLOAT32 = @compileError("unable to translate: TODO _Complex"); +// /usr/include/bits/floatn-common.h:149:12 +pub const __CFLOAT64 = @compileError("unable to translate: TODO _Complex"); +// /usr/include/bits/floatn-common.h:160:13 +pub const __CFLOAT32X = @compileError("unable to translate: TODO _Complex"); +// /usr/include/bits/floatn-common.h:169:12 +pub const __CFLOAT64X = @compileError("unable to translate: TODO _Complex"); +// /usr/include/bits/floatn-common.h:178:13 +pub inline fn __builtin_huge_valf32() @TypeOf(__builtin_huge_valf()) { + return __builtin_huge_valf(); +} +pub inline fn __builtin_inff32() @TypeOf(__builtin_inff()) { + return __builtin_inff(); +} +pub inline fn __builtin_nanf32(x: anytype) @TypeOf(__builtin_nanf(x)) { + _ = &x; + return __builtin_nanf(x); +} +pub const __builtin_nansf32 = @compileError("unable to translate macro: undefined identifier `__builtin_nansf`"); +// /usr/include/bits/floatn-common.h:221:12 +pub const __builtin_huge_valf64 = @compileError("unable to translate macro: undefined identifier `__builtin_huge_val`"); +// /usr/include/bits/floatn-common.h:255:13 +pub const __builtin_inff64 = @compileError("unable to translate macro: undefined identifier `__builtin_inf`"); +// /usr/include/bits/floatn-common.h:256:13 +pub const __builtin_nanf64 = @compileError("unable to translate macro: undefined identifier `__builtin_nan`"); +// /usr/include/bits/floatn-common.h:257:13 +pub const __builtin_nansf64 = @compileError("unable to translate macro: undefined identifier `__builtin_nans`"); +// /usr/include/bits/floatn-common.h:258:13 +pub const __builtin_huge_valf32x = @compileError("unable to translate macro: undefined identifier `__builtin_huge_val`"); +// /usr/include/bits/floatn-common.h:272:12 +pub const __builtin_inff32x = @compileError("unable to translate macro: undefined identifier `__builtin_inf`"); +// /usr/include/bits/floatn-common.h:273:12 +pub const __builtin_nanf32x = @compileError("unable to translate macro: undefined identifier `__builtin_nan`"); +// /usr/include/bits/floatn-common.h:274:12 +pub const __builtin_nansf32x = @compileError("unable to translate macro: undefined identifier `__builtin_nans`"); +// /usr/include/bits/floatn-common.h:275:12 +pub const __builtin_huge_valf64x = @compileError("unable to translate macro: undefined identifier `__builtin_huge_vall`"); +// /usr/include/bits/floatn-common.h:289:13 +pub const __builtin_inff64x = @compileError("unable to translate macro: undefined identifier `__builtin_infl`"); +// /usr/include/bits/floatn-common.h:290:13 +pub const __builtin_nanf64x = @compileError("unable to translate macro: undefined identifier `__builtin_nanl`"); +// /usr/include/bits/floatn-common.h:291:13 +pub const __builtin_nansf64x = @compileError("unable to translate macro: undefined identifier `__builtin_nansl`"); +// /usr/include/bits/floatn-common.h:292:13 +pub const HUGE_VAL = @compileError("unable to translate macro: undefined identifier `__builtin_huge_val`"); +// /usr/include/math.h:48:10 +pub const HUGE_VALF = __builtin_huge_valf(); +pub const HUGE_VALL = @compileError("unable to translate macro: undefined identifier `__builtin_huge_vall`"); +// /usr/include/math.h:60:11 +pub const INFINITY = __builtin_inff(); +pub const NAN = __builtin_nanf(""); +pub const __GLIBC_FLT_EVAL_METHOD = @compileError("unable to translate macro: undefined identifier `__FLT_EVAL_METHOD__`"); +// /usr/include/bits/flt-eval-method.h:27:11 +pub const __FP_LOGB0_IS_MIN = @as(c_int, 1); +pub const __FP_LOGBNAN_IS_MIN = @as(c_int, 1); +pub const FP_ILOGB0 = -@import("std").zig.c_translation.promoteIntLiteral(c_int, 2147483647, .decimal) - @as(c_int, 1); +pub const FP_ILOGBNAN = -@import("std").zig.c_translation.promoteIntLiteral(c_int, 2147483647, .decimal) - @as(c_int, 1); +pub const __SIMD_DECL = @compileError("unable to translate macro: undefined identifier `__DECL_SIMD_`"); +// /usr/include/math.h:276:9 +pub inline fn __MATHCALL_VEC(function: anytype, suffix: anytype, args: anytype) @TypeOf(__SIMD_DECL(__MATH_PRECNAME(function, suffix)) ++ __MATHCALL(function, suffix, args)) { + _ = &function; + _ = &suffix; + _ = &args; + return __SIMD_DECL(__MATH_PRECNAME(function, suffix)) ++ __MATHCALL(function, suffix, args); +} +pub inline fn __MATHDECL_VEC(@"type": anytype, function: anytype, suffix: anytype, args: anytype) @TypeOf(__SIMD_DECL(__MATH_PRECNAME(function, suffix)) ++ __MATHDECL(@"type", function, suffix, args)) { + _ = &@"type"; + _ = &function; + _ = &suffix; + _ = &args; + return __SIMD_DECL(__MATH_PRECNAME(function, suffix)) ++ __MATHDECL(@"type", function, suffix, args); +} +pub inline fn __MATHCALL(function: anytype, suffix: anytype, args: anytype) @TypeOf(__MATHDECL(_Mdouble_, function, suffix, args)) { + _ = &function; + _ = &suffix; + _ = &args; + return __MATHDECL(_Mdouble_, function, suffix, args); +} +pub const __MATHDECL = @compileError("unable to translate macro: undefined identifier `__`"); +// /usr/include/math.h:288:9 +pub inline fn __MATHCALLX(function: anytype, suffix: anytype, args: anytype, attrib: anytype) @TypeOf(__MATHDECLX(_Mdouble_, function, suffix, args, attrib)) { + _ = &function; + _ = &suffix; + _ = &args; + _ = &attrib; + return __MATHDECLX(_Mdouble_, function, suffix, args, attrib); +} +pub const __MATHDECLX = @compileError("unable to translate macro: undefined identifier `__`"); +// /usr/include/math.h:293:9 +pub const __MATHDECL_1_IMPL = @compileError("unable to translate C expr: unexpected token 'extern'"); +// /usr/include/math.h:296:9 +pub inline fn __MATHDECL_1(@"type": anytype, function: anytype, suffix: anytype, args: anytype) @TypeOf(__MATHDECL_1_IMPL(@"type", function, suffix, args)) { + _ = &@"type"; + _ = &function; + _ = &suffix; + _ = &args; + return __MATHDECL_1_IMPL(@"type", function, suffix, args); +} +pub inline fn __MATHDECL_ALIAS(@"type": anytype, function: anytype, suffix: anytype, args: anytype, alias: anytype) @TypeOf(__MATHDECL_1(@"type", function, suffix, args)) { + _ = &@"type"; + _ = &function; + _ = &suffix; + _ = &args; + _ = &alias; + return __MATHDECL_1(@"type", function, suffix, args); +} +pub const __MATHREDIR = @compileError("unable to translate C expr: unexpected token 'extern'"); +// /usr/include/math.h:305:9 +pub const _Mdouble_ = f64; +pub inline fn __MATH_PRECNAME(name: anytype, r: anytype) @TypeOf(__CONCAT(name, r)) { + _ = &name; + _ = &r; + return __CONCAT(name, r); +} +pub const __MATH_DECLARING_DOUBLE = @as(c_int, 1); +pub const __MATH_DECLARING_FLOATN = @as(c_int, 0); +pub const __MATH_DECLARE_LDOUBLE = @as(c_int, 1); +pub const __MATHCALL_NARROW_ARGS_1 = @compileError("unable to translate macro: undefined identifier `_Marg_`"); +// /usr/include/math.h:550:9 +pub const __MATHCALL_NARROW_ARGS_2 = @compileError("unable to translate macro: undefined identifier `_Marg_`"); +// /usr/include/math.h:551:9 +pub const __MATHCALL_NARROW_ARGS_3 = @compileError("unable to translate macro: undefined identifier `_Marg_`"); +// /usr/include/math.h:552:9 +pub const __MATHCALL_NARROW_NORMAL = @compileError("unable to translate macro: undefined identifier `_Mret_`"); +// /usr/include/math.h:553:9 +pub const __MATHCALL_NARROW_REDIR = @compileError("unable to translate macro: undefined identifier `_Mret_`"); +// /usr/include/math.h:555:9 +pub inline fn __MATHCALL_NARROW(func: anytype, redir: anytype, nargs: anytype) @TypeOf(__MATHCALL_NARROW_NORMAL(func, nargs)) { + _ = &func; + _ = &redir; + _ = &nargs; + return __MATHCALL_NARROW_NORMAL(func, nargs); +} +pub const __MATH_TG = @compileError("unable to translate macro: undefined identifier `f`"); +// /usr/include/math.h:922:10 +pub const fpclassify = @compileError("unable to translate macro: undefined identifier `__builtin_fpclassify`"); +// /usr/include/math.h:967:11 +pub inline fn signbit(x: anytype) @TypeOf(__builtin_signbit(x)) { + _ = &x; + return __builtin_signbit(x); +} +pub const isfinite = @compileError("unable to translate macro: undefined identifier `__builtin_isfinite`"); +// /usr/include/math.h:994:11 +pub const isnormal = @compileError("unable to translate macro: undefined identifier `__builtin_isnormal`"); +// /usr/include/math.h:1002:11 +pub const MATH_ERRNO = @as(c_int, 1); +pub const MATH_ERREXCEPT = @as(c_int, 2); +pub const math_errhandling = MATH_ERRNO | MATH_ERREXCEPT; +pub const M_E = @as(f64, 2.7182818284590452354); +pub const M_LOG2E = @as(f64, 1.4426950408889634074); +pub const M_LOG10E = @as(f64, 0.43429448190325182765); +pub const M_LN2 = @as(f64, 0.69314718055994530942); +pub const M_LN10 = @as(f64, 2.30258509299404568402); +pub const M_PI = @as(f64, 3.14159265358979323846); +pub const M_PI_2 = @as(f64, 1.57079632679489661923); +pub const M_PI_4 = @as(f64, 0.78539816339744830962); +pub const M_1_PI = @as(f64, 0.31830988618379067154); +pub const M_2_PI = @as(f64, 0.63661977236758134308); +pub const M_2_SQRTPI = @as(f64, 1.12837916709551257390); +pub const M_SQRT2 = @as(f64, 1.41421356237309504880); +pub const M_SQRT1_2 = @as(f64, 0.70710678118654752440); +pub const isgreater = @compileError("unable to translate macro: undefined identifier `__builtin_isgreater`"); +// /usr/include/math.h:1306:11 +pub const isgreaterequal = @compileError("unable to translate macro: undefined identifier `__builtin_isgreaterequal`"); +// /usr/include/math.h:1307:11 +pub const isless = @compileError("unable to translate macro: undefined identifier `__builtin_isless`"); +// /usr/include/math.h:1308:11 +pub const islessequal = @compileError("unable to translate macro: undefined identifier `__builtin_islessequal`"); +// /usr/include/math.h:1309:11 +pub const islessgreater = @compileError("unable to translate macro: undefined identifier `__builtin_islessgreater`"); +// /usr/include/math.h:1310:11 +pub const isunordered = @compileError("unable to translate macro: undefined identifier `__builtin_isunordered`"); +// /usr/include/math.h:1311:11 +pub const _STDIO_H = @as(c_int, 1); +pub const __need_size_t = ""; +pub const __need_NULL = ""; +pub const _SIZE_T = ""; +pub const NULL = @import("std").zig.c_translation.cast(?*anyopaque, @as(c_int, 0)); +pub const _____fpos_t_defined = @as(c_int, 1); +pub const ____mbstate_t_defined = @as(c_int, 1); +pub const _____fpos64_t_defined = @as(c_int, 1); +pub const ____FILE_defined = @as(c_int, 1); +pub const __FILE_defined = @as(c_int, 1); +pub const __struct_FILE_defined = @as(c_int, 1); +pub const __getc_unlocked_body = @compileError("TODO postfix inc/dec expr"); +// /usr/include/bits/types/struct_FILE.h:102:9 +pub const __putc_unlocked_body = @compileError("TODO postfix inc/dec expr"); +// /usr/include/bits/types/struct_FILE.h:106:9 +pub const _IO_EOF_SEEN = @as(c_int, 0x0010); +pub inline fn __feof_unlocked_body(_fp: anytype) @TypeOf((_fp.*._flags & _IO_EOF_SEEN) != @as(c_int, 0)) { + _ = &_fp; + return (_fp.*._flags & _IO_EOF_SEEN) != @as(c_int, 0); +} +pub const _IO_ERR_SEEN = @as(c_int, 0x0020); +pub inline fn __ferror_unlocked_body(_fp: anytype) @TypeOf((_fp.*._flags & _IO_ERR_SEEN) != @as(c_int, 0)) { + _ = &_fp; + return (_fp.*._flags & _IO_ERR_SEEN) != @as(c_int, 0); +} +pub const _IO_USER_LOCK = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x8000, .hex); +pub const __cookie_io_functions_t_defined = @as(c_int, 1); +pub const _VA_LIST_DEFINED = ""; +pub const __off_t_defined = ""; +pub const __ssize_t_defined = ""; +pub const _IOFBF = @as(c_int, 0); +pub const _IOLBF = @as(c_int, 1); +pub const _IONBF = @as(c_int, 2); +pub const BUFSIZ = @as(c_int, 8192); +pub const EOF = -@as(c_int, 1); +pub const SEEK_SET = @as(c_int, 0); +pub const SEEK_CUR = @as(c_int, 1); +pub const SEEK_END = @as(c_int, 2); +pub const P_tmpdir = "/tmp"; +pub const L_tmpnam = @as(c_int, 20); +pub const TMP_MAX = @import("std").zig.c_translation.promoteIntLiteral(c_int, 238328, .decimal); +pub const _BITS_STDIO_LIM_H = @as(c_int, 1); +pub const FILENAME_MAX = @as(c_int, 4096); +pub const L_ctermid = @as(c_int, 9); +pub const FOPEN_MAX = @as(c_int, 16); +pub const __attr_dealloc_fclose = __attr_dealloc(fclose, @as(c_int, 1)); +pub const __need_wchar_t = ""; +pub const _WCHAR_T = ""; +pub const _STDLIB_H = @as(c_int, 1); +pub const WNOHANG = @as(c_int, 1); +pub const WUNTRACED = @as(c_int, 2); +pub const WSTOPPED = @as(c_int, 2); +pub const WEXITED = @as(c_int, 4); +pub const WCONTINUED = @as(c_int, 8); +pub const WNOWAIT = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x01000000, .hex); +pub const __WNOTHREAD = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x20000000, .hex); +pub const __WALL = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x40000000, .hex); +pub const __WCLONE = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x80000000, .hex); +pub inline fn __WEXITSTATUS(status: anytype) @TypeOf((status & @import("std").zig.c_translation.promoteIntLiteral(c_int, 0xff00, .hex)) >> @as(c_int, 8)) { + _ = &status; + return (status & @import("std").zig.c_translation.promoteIntLiteral(c_int, 0xff00, .hex)) >> @as(c_int, 8); +} +pub inline fn __WTERMSIG(status: anytype) @TypeOf(status & @as(c_int, 0x7f)) { + _ = &status; + return status & @as(c_int, 0x7f); +} +pub inline fn __WSTOPSIG(status: anytype) @TypeOf(__WEXITSTATUS(status)) { + _ = &status; + return __WEXITSTATUS(status); +} +pub inline fn __WIFEXITED(status: anytype) @TypeOf(__WTERMSIG(status) == @as(c_int, 0)) { + _ = &status; + return __WTERMSIG(status) == @as(c_int, 0); +} +pub inline fn __WIFSIGNALED(status: anytype) @TypeOf((@import("std").zig.c_translation.cast(i8, (status & @as(c_int, 0x7f)) + @as(c_int, 1)) >> @as(c_int, 1)) > @as(c_int, 0)) { + _ = &status; + return (@import("std").zig.c_translation.cast(i8, (status & @as(c_int, 0x7f)) + @as(c_int, 1)) >> @as(c_int, 1)) > @as(c_int, 0); +} +pub inline fn __WIFSTOPPED(status: anytype) @TypeOf((status & @as(c_int, 0xff)) == @as(c_int, 0x7f)) { + _ = &status; + return (status & @as(c_int, 0xff)) == @as(c_int, 0x7f); +} +pub inline fn __WIFCONTINUED(status: anytype) @TypeOf(status == __W_CONTINUED) { + _ = &status; + return status == __W_CONTINUED; +} +pub inline fn __WCOREDUMP(status: anytype) @TypeOf(status & __WCOREFLAG) { + _ = &status; + return status & __WCOREFLAG; +} +pub inline fn __W_EXITCODE(ret: anytype, sig: anytype) @TypeOf((ret << @as(c_int, 8)) | sig) { + _ = &ret; + _ = &sig; + return (ret << @as(c_int, 8)) | sig; +} +pub inline fn __W_STOPCODE(sig: anytype) @TypeOf((sig << @as(c_int, 8)) | @as(c_int, 0x7f)) { + _ = &sig; + return (sig << @as(c_int, 8)) | @as(c_int, 0x7f); +} +pub const __W_CONTINUED = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0xffff, .hex); +pub const __WCOREFLAG = @as(c_int, 0x80); +pub inline fn WEXITSTATUS(status: anytype) @TypeOf(__WEXITSTATUS(status)) { + _ = &status; + return __WEXITSTATUS(status); +} +pub inline fn WTERMSIG(status: anytype) @TypeOf(__WTERMSIG(status)) { + _ = &status; + return __WTERMSIG(status); +} +pub inline fn WSTOPSIG(status: anytype) @TypeOf(__WSTOPSIG(status)) { + _ = &status; + return __WSTOPSIG(status); +} +pub inline fn WIFEXITED(status: anytype) @TypeOf(__WIFEXITED(status)) { + _ = &status; + return __WIFEXITED(status); +} +pub inline fn WIFSIGNALED(status: anytype) @TypeOf(__WIFSIGNALED(status)) { + _ = &status; + return __WIFSIGNALED(status); +} +pub inline fn WIFSTOPPED(status: anytype) @TypeOf(__WIFSTOPPED(status)) { + _ = &status; + return __WIFSTOPPED(status); +} +pub inline fn WIFCONTINUED(status: anytype) @TypeOf(__WIFCONTINUED(status)) { + _ = &status; + return __WIFCONTINUED(status); +} +pub const __ldiv_t_defined = @as(c_int, 1); +pub const __lldiv_t_defined = @as(c_int, 1); +pub const RAND_MAX = @import("std").zig.c_translation.promoteIntLiteral(c_int, 2147483647, .decimal); +pub const EXIT_FAILURE = @as(c_int, 1); +pub const EXIT_SUCCESS = @as(c_int, 0); +pub const MB_CUR_MAX = __ctype_get_mb_cur_max(); +pub const _SYS_TYPES_H = @as(c_int, 1); +pub const __u_char_defined = ""; +pub const __ino_t_defined = ""; +pub const __dev_t_defined = ""; +pub const __gid_t_defined = ""; +pub const __mode_t_defined = ""; +pub const __nlink_t_defined = ""; +pub const __uid_t_defined = ""; +pub const __pid_t_defined = ""; +pub const __id_t_defined = ""; +pub const __daddr_t_defined = ""; +pub const __key_t_defined = ""; +pub const __clock_t_defined = @as(c_int, 1); +pub const __clockid_t_defined = @as(c_int, 1); +pub const __time_t_defined = @as(c_int, 1); +pub const __timer_t_defined = @as(c_int, 1); +pub const _BITS_STDINT_INTN_H = @as(c_int, 1); +pub const __BIT_TYPES_DEFINED__ = @as(c_int, 1); +pub const _ENDIAN_H = @as(c_int, 1); +pub const _BITS_ENDIAN_H = @as(c_int, 1); +pub const __LITTLE_ENDIAN = @as(c_int, 1234); +pub const __BIG_ENDIAN = @as(c_int, 4321); +pub const __PDP_ENDIAN = @as(c_int, 3412); +pub const _BITS_ENDIANNESS_H = @as(c_int, 1); +pub const __BYTE_ORDER = __LITTLE_ENDIAN; +pub const __FLOAT_WORD_ORDER = __BYTE_ORDER; +pub inline fn __LONG_LONG_PAIR(HI: anytype, LO: anytype) @TypeOf(HI) { + _ = &HI; + _ = &LO; + return blk: { + _ = &LO; + break :blk HI; + }; +} +pub const LITTLE_ENDIAN = __LITTLE_ENDIAN; +pub const BIG_ENDIAN = __BIG_ENDIAN; +pub const PDP_ENDIAN = __PDP_ENDIAN; +pub const BYTE_ORDER = __BYTE_ORDER; +pub const _BITS_BYTESWAP_H = @as(c_int, 1); +pub inline fn __bswap_constant_16(x: anytype) __uint16_t { + _ = &x; + return @import("std").zig.c_translation.cast(__uint16_t, ((x >> @as(c_int, 8)) & @as(c_int, 0xff)) | ((x & @as(c_int, 0xff)) << @as(c_int, 8))); +} +pub inline fn __bswap_constant_32(x: anytype) @TypeOf(((((x & @import("std").zig.c_translation.promoteIntLiteral(c_uint, 0xff000000, .hex)) >> @as(c_int, 24)) | ((x & @import("std").zig.c_translation.promoteIntLiteral(c_uint, 0x00ff0000, .hex)) >> @as(c_int, 8))) | ((x & @as(c_uint, 0x0000ff00)) << @as(c_int, 8))) | ((x & @as(c_uint, 0x000000ff)) << @as(c_int, 24))) { + _ = &x; + return ((((x & @import("std").zig.c_translation.promoteIntLiteral(c_uint, 0xff000000, .hex)) >> @as(c_int, 24)) | ((x & @import("std").zig.c_translation.promoteIntLiteral(c_uint, 0x00ff0000, .hex)) >> @as(c_int, 8))) | ((x & @as(c_uint, 0x0000ff00)) << @as(c_int, 8))) | ((x & @as(c_uint, 0x000000ff)) << @as(c_int, 24)); +} +pub inline fn __bswap_constant_64(x: anytype) @TypeOf(((((((((x & @as(c_ulonglong, 0xff00000000000000)) >> @as(c_int, 56)) | ((x & @as(c_ulonglong, 0x00ff000000000000)) >> @as(c_int, 40))) | ((x & @as(c_ulonglong, 0x0000ff0000000000)) >> @as(c_int, 24))) | ((x & @as(c_ulonglong, 0x000000ff00000000)) >> @as(c_int, 8))) | ((x & @as(c_ulonglong, 0x00000000ff000000)) << @as(c_int, 8))) | ((x & @as(c_ulonglong, 0x0000000000ff0000)) << @as(c_int, 24))) | ((x & @as(c_ulonglong, 0x000000000000ff00)) << @as(c_int, 40))) | ((x & @as(c_ulonglong, 0x00000000000000ff)) << @as(c_int, 56))) { + _ = &x; + return ((((((((x & @as(c_ulonglong, 0xff00000000000000)) >> @as(c_int, 56)) | ((x & @as(c_ulonglong, 0x00ff000000000000)) >> @as(c_int, 40))) | ((x & @as(c_ulonglong, 0x0000ff0000000000)) >> @as(c_int, 24))) | ((x & @as(c_ulonglong, 0x000000ff00000000)) >> @as(c_int, 8))) | ((x & @as(c_ulonglong, 0x00000000ff000000)) << @as(c_int, 8))) | ((x & @as(c_ulonglong, 0x0000000000ff0000)) << @as(c_int, 24))) | ((x & @as(c_ulonglong, 0x000000000000ff00)) << @as(c_int, 40))) | ((x & @as(c_ulonglong, 0x00000000000000ff)) << @as(c_int, 56)); +} +pub const _BITS_UINTN_IDENTITY_H = @as(c_int, 1); +pub inline fn htobe16(x: anytype) @TypeOf(__bswap_16(x)) { + _ = &x; + return __bswap_16(x); +} +pub inline fn htole16(x: anytype) @TypeOf(__uint16_identity(x)) { + _ = &x; + return __uint16_identity(x); +} +pub inline fn be16toh(x: anytype) @TypeOf(__bswap_16(x)) { + _ = &x; + return __bswap_16(x); +} +pub inline fn le16toh(x: anytype) @TypeOf(__uint16_identity(x)) { + _ = &x; + return __uint16_identity(x); +} +pub inline fn htobe32(x: anytype) @TypeOf(__bswap_32(x)) { + _ = &x; + return __bswap_32(x); +} +pub inline fn htole32(x: anytype) @TypeOf(__uint32_identity(x)) { + _ = &x; + return __uint32_identity(x); +} +pub inline fn be32toh(x: anytype) @TypeOf(__bswap_32(x)) { + _ = &x; + return __bswap_32(x); +} +pub inline fn le32toh(x: anytype) @TypeOf(__uint32_identity(x)) { + _ = &x; + return __uint32_identity(x); +} +pub inline fn htobe64(x: anytype) @TypeOf(__bswap_64(x)) { + _ = &x; + return __bswap_64(x); +} +pub inline fn htole64(x: anytype) @TypeOf(__uint64_identity(x)) { + _ = &x; + return __uint64_identity(x); +} +pub inline fn be64toh(x: anytype) @TypeOf(__bswap_64(x)) { + _ = &x; + return __bswap_64(x); +} +pub inline fn le64toh(x: anytype) @TypeOf(__uint64_identity(x)) { + _ = &x; + return __uint64_identity(x); +} +pub const _SYS_SELECT_H = @as(c_int, 1); +pub const __FD_ZERO = @compileError("unable to translate macro: undefined identifier `__i`"); +// /usr/include/bits/select.h:25:9 +pub const __FD_SET = @compileError("unable to translate C expr: expected ')' instead got '|='"); +// /usr/include/bits/select.h:32:9 +pub const __FD_CLR = @compileError("unable to translate C expr: expected ')' instead got '&='"); +// /usr/include/bits/select.h:34:9 +pub inline fn __FD_ISSET(d: anytype, s: anytype) @TypeOf((__FDS_BITS(s)[@as(usize, @intCast(__FD_ELT(d)))] & __FD_MASK(d)) != @as(c_int, 0)) { + _ = &d; + _ = &s; + return (__FDS_BITS(s)[@as(usize, @intCast(__FD_ELT(d)))] & __FD_MASK(d)) != @as(c_int, 0); +} +pub const __sigset_t_defined = @as(c_int, 1); +pub const ____sigset_t_defined = ""; +pub const _SIGSET_NWORDS = @import("std").zig.c_translation.MacroArithmetic.div(@as(c_int, 1024), @as(c_int, 8) * @import("std").zig.c_translation.sizeof(c_ulong)); +pub const __timeval_defined = @as(c_int, 1); +pub const _STRUCT_TIMESPEC = @as(c_int, 1); +pub const __suseconds_t_defined = ""; +pub const __NFDBITS = @as(c_int, 8) * @import("std").zig.c_translation.cast(c_int, @import("std").zig.c_translation.sizeof(__fd_mask)); +pub inline fn __FD_ELT(d: anytype) @TypeOf(@import("std").zig.c_translation.MacroArithmetic.div(d, __NFDBITS)) { + _ = &d; + return @import("std").zig.c_translation.MacroArithmetic.div(d, __NFDBITS); +} +pub inline fn __FD_MASK(d: anytype) __fd_mask { + _ = &d; + return @import("std").zig.c_translation.cast(__fd_mask, @as(c_ulong, 1) << @import("std").zig.c_translation.MacroArithmetic.rem(d, __NFDBITS)); +} +pub inline fn __FDS_BITS(set: anytype) @TypeOf(set.*.__fds_bits) { + _ = &set; + return set.*.__fds_bits; +} +pub const FD_SETSIZE = __FD_SETSIZE; +pub const NFDBITS = __NFDBITS; +pub inline fn FD_SET(fd: anytype, fdsetp: anytype) @TypeOf(__FD_SET(fd, fdsetp)) { + _ = &fd; + _ = &fdsetp; + return __FD_SET(fd, fdsetp); +} +pub inline fn FD_CLR(fd: anytype, fdsetp: anytype) @TypeOf(__FD_CLR(fd, fdsetp)) { + _ = &fd; + _ = &fdsetp; + return __FD_CLR(fd, fdsetp); +} +pub inline fn FD_ISSET(fd: anytype, fdsetp: anytype) @TypeOf(__FD_ISSET(fd, fdsetp)) { + _ = &fd; + _ = &fdsetp; + return __FD_ISSET(fd, fdsetp); +} +pub inline fn FD_ZERO(fdsetp: anytype) @TypeOf(__FD_ZERO(fdsetp)) { + _ = &fdsetp; + return __FD_ZERO(fdsetp); +} +pub const __blksize_t_defined = ""; +pub const __blkcnt_t_defined = ""; +pub const __fsblkcnt_t_defined = ""; +pub const __fsfilcnt_t_defined = ""; +pub const _BITS_PTHREADTYPES_COMMON_H = @as(c_int, 1); +pub const _THREAD_SHARED_TYPES_H = @as(c_int, 1); +pub const _BITS_PTHREADTYPES_ARCH_H = @as(c_int, 1); +pub const __SIZEOF_PTHREAD_MUTEX_T = @as(c_int, 40); +pub const __SIZEOF_PTHREAD_ATTR_T = @as(c_int, 56); +pub const __SIZEOF_PTHREAD_RWLOCK_T = @as(c_int, 56); +pub const __SIZEOF_PTHREAD_BARRIER_T = @as(c_int, 32); +pub const __SIZEOF_PTHREAD_MUTEXATTR_T = @as(c_int, 4); +pub const __SIZEOF_PTHREAD_COND_T = @as(c_int, 48); +pub const __SIZEOF_PTHREAD_CONDATTR_T = @as(c_int, 4); +pub const __SIZEOF_PTHREAD_RWLOCKATTR_T = @as(c_int, 8); +pub const __SIZEOF_PTHREAD_BARRIERATTR_T = @as(c_int, 4); +pub const __LOCK_ALIGNMENT = ""; +pub const __ONCE_ALIGNMENT = ""; +pub const _BITS_ATOMIC_WIDE_COUNTER_H = ""; +pub const _THREAD_MUTEX_INTERNAL_H = @as(c_int, 1); +pub const __PTHREAD_MUTEX_HAVE_PREV = @as(c_int, 1); +pub const __PTHREAD_MUTEX_INITIALIZER = @compileError("unable to translate C expr: unexpected token '{'"); +// /usr/include/bits/struct_mutex.h:56:10 +pub const _RWLOCK_INTERNAL_H = ""; +pub const __PTHREAD_RWLOCK_ELISION_EXTRA = @compileError("unable to translate C expr: unexpected token '{'"); +// /usr/include/bits/struct_rwlock.h:40:11 +pub inline fn __PTHREAD_RWLOCK_INITIALIZER(__flags: anytype) @TypeOf(__flags) { + _ = &__flags; + return blk: { + _ = @as(c_int, 0); + _ = @as(c_int, 0); + _ = @as(c_int, 0); + _ = @as(c_int, 0); + _ = @as(c_int, 0); + _ = @as(c_int, 0); + _ = @as(c_int, 0); + _ = @as(c_int, 0); + _ = &__PTHREAD_RWLOCK_ELISION_EXTRA; + _ = @as(c_int, 0); + break :blk __flags; + }; +} +pub const __ONCE_FLAG_INIT = @compileError("unable to translate C expr: unexpected token '{'"); +// /usr/include/bits/thread-shared-types.h:113:9 +pub const __have_pthread_attr_t = @as(c_int, 1); +pub const _ALLOCA_H = @as(c_int, 1); +pub const __COMPAR_FN_T = ""; +pub const _STRING_H = @as(c_int, 1); +pub const _BITS_TYPES_LOCALE_T_H = @as(c_int, 1); +pub const _BITS_TYPES___LOCALE_T_H = @as(c_int, 1); +pub const _STRINGS_H = @as(c_int, 1); +pub const TINYOBJ_MALLOC = RL_MALLOC; +pub const TINYOBJ_CALLOC = RL_CALLOC; +pub const TINYOBJ_REALLOC = RL_REALLOC; +pub const TINYOBJ_FREE = RL_FREE; +pub const TINYOBJ_LOADER_C_IMPLEMENTATION = ""; +pub const TINOBJ_LOADER_C_H_ = ""; +pub const TINYOBJ_FLAG_TRIANGULATE = @as(c_int, 1) << @as(c_int, 0); +pub const TINYOBJ_INVALID_INDEX = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x80000000, .hex); +pub const TINYOBJ_SUCCESS = @as(c_int, 0); +pub const TINYOBJ_ERROR_EMPTY = -@as(c_int, 1); +pub const TINYOBJ_ERROR_INVALID_PARAMETER = -@as(c_int, 2); +pub const TINYOBJ_ERROR_FILE_OPERATION = -@as(c_int, 3); +pub const _ASSERT_H = @as(c_int, 1); +pub const __ASSERT_VOID_CAST = @compileError("unable to translate C expr: unexpected token ''"); +// /usr/include/assert.h:40:10 +pub const assert = @compileError("unable to translate macro: undefined identifier `__FILE__`"); +// /usr/include/assert.h:115:11 +pub const __ASSERT_FUNCTION = @compileError("unable to translate C expr: unexpected token '__extension__'"); +// /usr/include/assert.h:137:12 +pub const static_assert = @compileError("unable to translate C expr: unexpected token '_Static_assert'"); +// /usr/include/assert.h:155:10 +pub const _ERRNO_H = @as(c_int, 1); +pub const _BITS_ERRNO_H = @as(c_int, 1); +pub const _ASM_GENERIC_ERRNO_H = ""; +pub const _ASM_GENERIC_ERRNO_BASE_H = ""; +pub const EPERM = @as(c_int, 1); +pub const ENOENT = @as(c_int, 2); +pub const ESRCH = @as(c_int, 3); +pub const EINTR = @as(c_int, 4); +pub const EIO = @as(c_int, 5); +pub const ENXIO = @as(c_int, 6); +pub const E2BIG = @as(c_int, 7); +pub const ENOEXEC = @as(c_int, 8); +pub const EBADF = @as(c_int, 9); +pub const ECHILD = @as(c_int, 10); +pub const EAGAIN = @as(c_int, 11); +pub const ENOMEM = @as(c_int, 12); +pub const EACCES = @as(c_int, 13); +pub const EFAULT = @as(c_int, 14); +pub const ENOTBLK = @as(c_int, 15); +pub const EBUSY = @as(c_int, 16); +pub const EEXIST = @as(c_int, 17); +pub const EXDEV = @as(c_int, 18); +pub const ENODEV = @as(c_int, 19); +pub const ENOTDIR = @as(c_int, 20); +pub const EISDIR = @as(c_int, 21); +pub const EINVAL = @as(c_int, 22); +pub const ENFILE = @as(c_int, 23); +pub const EMFILE = @as(c_int, 24); +pub const ENOTTY = @as(c_int, 25); +pub const ETXTBSY = @as(c_int, 26); +pub const EFBIG = @as(c_int, 27); +pub const ENOSPC = @as(c_int, 28); +pub const ESPIPE = @as(c_int, 29); +pub const EROFS = @as(c_int, 30); +pub const EMLINK = @as(c_int, 31); +pub const EPIPE = @as(c_int, 32); +pub const EDOM = @as(c_int, 33); +pub const ERANGE = @as(c_int, 34); +pub const EDEADLK = @as(c_int, 35); +pub const ENAMETOOLONG = @as(c_int, 36); +pub const ENOLCK = @as(c_int, 37); +pub const ENOSYS = @as(c_int, 38); +pub const ENOTEMPTY = @as(c_int, 39); +pub const ELOOP = @as(c_int, 40); +pub const EWOULDBLOCK = EAGAIN; +pub const ENOMSG = @as(c_int, 42); +pub const EIDRM = @as(c_int, 43); +pub const ECHRNG = @as(c_int, 44); +pub const EL2NSYNC = @as(c_int, 45); +pub const EL3HLT = @as(c_int, 46); +pub const EL3RST = @as(c_int, 47); +pub const ELNRNG = @as(c_int, 48); +pub const EUNATCH = @as(c_int, 49); +pub const ENOCSI = @as(c_int, 50); +pub const EL2HLT = @as(c_int, 51); +pub const EBADE = @as(c_int, 52); +pub const EBADR = @as(c_int, 53); +pub const EXFULL = @as(c_int, 54); +pub const ENOANO = @as(c_int, 55); +pub const EBADRQC = @as(c_int, 56); +pub const EBADSLT = @as(c_int, 57); +pub const EDEADLOCK = EDEADLK; +pub const EBFONT = @as(c_int, 59); +pub const ENOSTR = @as(c_int, 60); +pub const ENODATA = @as(c_int, 61); +pub const ETIME = @as(c_int, 62); +pub const ENOSR = @as(c_int, 63); +pub const ENONET = @as(c_int, 64); +pub const ENOPKG = @as(c_int, 65); +pub const EREMOTE = @as(c_int, 66); +pub const ENOLINK = @as(c_int, 67); +pub const EADV = @as(c_int, 68); +pub const ESRMNT = @as(c_int, 69); +pub const ECOMM = @as(c_int, 70); +pub const EPROTO = @as(c_int, 71); +pub const EMULTIHOP = @as(c_int, 72); +pub const EDOTDOT = @as(c_int, 73); +pub const EBADMSG = @as(c_int, 74); +pub const EOVERFLOW = @as(c_int, 75); +pub const ENOTUNIQ = @as(c_int, 76); +pub const EBADFD = @as(c_int, 77); +pub const EREMCHG = @as(c_int, 78); +pub const ELIBACC = @as(c_int, 79); +pub const ELIBBAD = @as(c_int, 80); +pub const ELIBSCN = @as(c_int, 81); +pub const ELIBMAX = @as(c_int, 82); +pub const ELIBEXEC = @as(c_int, 83); +pub const EILSEQ = @as(c_int, 84); +pub const ERESTART = @as(c_int, 85); +pub const ESTRPIPE = @as(c_int, 86); +pub const EUSERS = @as(c_int, 87); +pub const ENOTSOCK = @as(c_int, 88); +pub const EDESTADDRREQ = @as(c_int, 89); +pub const EMSGSIZE = @as(c_int, 90); +pub const EPROTOTYPE = @as(c_int, 91); +pub const ENOPROTOOPT = @as(c_int, 92); +pub const EPROTONOSUPPORT = @as(c_int, 93); +pub const ESOCKTNOSUPPORT = @as(c_int, 94); +pub const EOPNOTSUPP = @as(c_int, 95); +pub const EPFNOSUPPORT = @as(c_int, 96); +pub const EAFNOSUPPORT = @as(c_int, 97); +pub const EADDRINUSE = @as(c_int, 98); +pub const EADDRNOTAVAIL = @as(c_int, 99); +pub const ENETDOWN = @as(c_int, 100); +pub const ENETUNREACH = @as(c_int, 101); +pub const ENETRESET = @as(c_int, 102); +pub const ECONNABORTED = @as(c_int, 103); +pub const ECONNRESET = @as(c_int, 104); +pub const ENOBUFS = @as(c_int, 105); +pub const EISCONN = @as(c_int, 106); +pub const ENOTCONN = @as(c_int, 107); +pub const ESHUTDOWN = @as(c_int, 108); +pub const ETOOMANYREFS = @as(c_int, 109); +pub const ETIMEDOUT = @as(c_int, 110); +pub const ECONNREFUSED = @as(c_int, 111); +pub const EHOSTDOWN = @as(c_int, 112); +pub const EHOSTUNREACH = @as(c_int, 113); +pub const EALREADY = @as(c_int, 114); +pub const EINPROGRESS = @as(c_int, 115); +pub const ESTALE = @as(c_int, 116); +pub const EUCLEAN = @as(c_int, 117); +pub const ENOTNAM = @as(c_int, 118); +pub const ENAVAIL = @as(c_int, 119); +pub const EISNAM = @as(c_int, 120); +pub const EREMOTEIO = @as(c_int, 121); +pub const EDQUOT = @as(c_int, 122); +pub const ENOMEDIUM = @as(c_int, 123); +pub const EMEDIUMTYPE = @as(c_int, 124); +pub const ECANCELED = @as(c_int, 125); +pub const ENOKEY = @as(c_int, 126); +pub const EKEYEXPIRED = @as(c_int, 127); +pub const EKEYREVOKED = @as(c_int, 128); +pub const EKEYREJECTED = @as(c_int, 129); +pub const EOWNERDEAD = @as(c_int, 130); +pub const ENOTRECOVERABLE = @as(c_int, 131); +pub const ERFKILL = @as(c_int, 132); +pub const EHWPOISON = @as(c_int, 133); +pub const ENOTSUP = EOPNOTSUPP; +pub const errno = __errno_location().*; +pub const TINYOBJ_MAX_FACES_PER_F_LINE = @as(c_int, 16); +pub inline fn IS_SPACE(x: anytype) @TypeOf((x == ' ') or (x == '\t')) { + _ = &x; + return (x == ' ') or (x == '\t'); +} +pub inline fn IS_DIGIT(x: anytype) @TypeOf(@import("std").zig.c_translation.cast(c_uint, x - '0') < @import("std").zig.c_translation.cast(c_uint, @as(c_int, 10))) { + _ = &x; + return @import("std").zig.c_translation.cast(c_uint, x - '0') < @import("std").zig.c_translation.cast(c_uint, @as(c_int, 10)); +} +pub inline fn IS_NEW_LINE(x: anytype) @TypeOf(((x == '\r') or (x == '\n')) or (x == '\x00')) { + _ = &x; + return ((x == '\r') or (x == '\n')) or (x == '\x00'); +} +pub const HASH_TABLE_ERROR = @as(c_int, 1); +pub const HASH_TABLE_SUCCESS = @as(c_int, 0); +pub const HASH_TABLE_DEFAULT_SIZE = @as(c_int, 10); +pub const CGLTF_MALLOC = RL_MALLOC; +pub const CGLTF_FREE = RL_FREE; +pub const CGLTF_IMPLEMENTATION = ""; +pub const CGLTF_H_INCLUDED__ = ""; +pub const __STDDEF_H = ""; +pub const __need_ptrdiff_t = ""; +pub const __need_max_align_t = ""; +pub const __need_offsetof = ""; +pub const _PTRDIFF_T = ""; +pub const __CLANG_MAX_ALIGN_T_DEFINED = ""; +pub const offsetof = @compileError("unable to translate C expr: unexpected token 'an identifier'"); +// /opt/zig-bin-0.13.0/lib/include/__stddef_offsetof.h:16:9 +pub const __CLANG_STDINT_H = ""; +pub const _STDINT_H = @as(c_int, 1); +pub const _BITS_WCHAR_H = @as(c_int, 1); +pub const __WCHAR_MAX = __WCHAR_MAX__; +pub const __WCHAR_MIN = -__WCHAR_MAX - @as(c_int, 1); +pub const _BITS_STDINT_UINTN_H = @as(c_int, 1); +pub const _BITS_STDINT_LEAST_H = @as(c_int, 1); +pub const __intptr_t_defined = ""; +pub const __INT64_C = @import("std").zig.c_translation.Macros.L_SUFFIX; +pub const __UINT64_C = @import("std").zig.c_translation.Macros.UL_SUFFIX; +pub const INT8_MIN = -@as(c_int, 128); +pub const INT16_MIN = -@as(c_int, 32767) - @as(c_int, 1); +pub const INT32_MIN = -@import("std").zig.c_translation.promoteIntLiteral(c_int, 2147483647, .decimal) - @as(c_int, 1); +pub const INT64_MIN = -__INT64_C(@import("std").zig.c_translation.promoteIntLiteral(c_int, 9223372036854775807, .decimal)) - @as(c_int, 1); +pub const INT8_MAX = @as(c_int, 127); +pub const INT16_MAX = @as(c_int, 32767); +pub const INT32_MAX = @import("std").zig.c_translation.promoteIntLiteral(c_int, 2147483647, .decimal); +pub const INT64_MAX = __INT64_C(@import("std").zig.c_translation.promoteIntLiteral(c_int, 9223372036854775807, .decimal)); +pub const UINT8_MAX = @as(c_int, 255); +pub const UINT16_MAX = @import("std").zig.c_translation.promoteIntLiteral(c_int, 65535, .decimal); +pub const UINT32_MAX = @import("std").zig.c_translation.promoteIntLiteral(c_uint, 4294967295, .decimal); +pub const UINT64_MAX = __UINT64_C(@import("std").zig.c_translation.promoteIntLiteral(c_int, 18446744073709551615, .decimal)); +pub const INT_LEAST8_MIN = -@as(c_int, 128); +pub const INT_LEAST16_MIN = -@as(c_int, 32767) - @as(c_int, 1); +pub const INT_LEAST32_MIN = -@import("std").zig.c_translation.promoteIntLiteral(c_int, 2147483647, .decimal) - @as(c_int, 1); +pub const INT_LEAST64_MIN = -__INT64_C(@import("std").zig.c_translation.promoteIntLiteral(c_int, 9223372036854775807, .decimal)) - @as(c_int, 1); +pub const INT_LEAST8_MAX = @as(c_int, 127); +pub const INT_LEAST16_MAX = @as(c_int, 32767); +pub const INT_LEAST32_MAX = @import("std").zig.c_translation.promoteIntLiteral(c_int, 2147483647, .decimal); +pub const INT_LEAST64_MAX = __INT64_C(@import("std").zig.c_translation.promoteIntLiteral(c_int, 9223372036854775807, .decimal)); +pub const UINT_LEAST8_MAX = @as(c_int, 255); +pub const UINT_LEAST16_MAX = @import("std").zig.c_translation.promoteIntLiteral(c_int, 65535, .decimal); +pub const UINT_LEAST32_MAX = @import("std").zig.c_translation.promoteIntLiteral(c_uint, 4294967295, .decimal); +pub const UINT_LEAST64_MAX = __UINT64_C(@import("std").zig.c_translation.promoteIntLiteral(c_int, 18446744073709551615, .decimal)); +pub const INT_FAST8_MIN = -@as(c_int, 128); +pub const INT_FAST16_MIN = -@import("std").zig.c_translation.promoteIntLiteral(c_long, 9223372036854775807, .decimal) - @as(c_int, 1); +pub const INT_FAST32_MIN = -@import("std").zig.c_translation.promoteIntLiteral(c_long, 9223372036854775807, .decimal) - @as(c_int, 1); +pub const INT_FAST64_MIN = -__INT64_C(@import("std").zig.c_translation.promoteIntLiteral(c_int, 9223372036854775807, .decimal)) - @as(c_int, 1); +pub const INT_FAST8_MAX = @as(c_int, 127); +pub const INT_FAST16_MAX = @import("std").zig.c_translation.promoteIntLiteral(c_long, 9223372036854775807, .decimal); +pub const INT_FAST32_MAX = @import("std").zig.c_translation.promoteIntLiteral(c_long, 9223372036854775807, .decimal); +pub const INT_FAST64_MAX = __INT64_C(@import("std").zig.c_translation.promoteIntLiteral(c_int, 9223372036854775807, .decimal)); +pub const UINT_FAST8_MAX = @as(c_int, 255); +pub const UINT_FAST16_MAX = @import("std").zig.c_translation.promoteIntLiteral(c_ulong, 18446744073709551615, .decimal); +pub const UINT_FAST32_MAX = @import("std").zig.c_translation.promoteIntLiteral(c_ulong, 18446744073709551615, .decimal); +pub const UINT_FAST64_MAX = __UINT64_C(@import("std").zig.c_translation.promoteIntLiteral(c_int, 18446744073709551615, .decimal)); +pub const INTPTR_MIN = -@import("std").zig.c_translation.promoteIntLiteral(c_long, 9223372036854775807, .decimal) - @as(c_int, 1); +pub const INTPTR_MAX = @import("std").zig.c_translation.promoteIntLiteral(c_long, 9223372036854775807, .decimal); +pub const UINTPTR_MAX = @import("std").zig.c_translation.promoteIntLiteral(c_ulong, 18446744073709551615, .decimal); +pub const INTMAX_MIN = -__INT64_C(@import("std").zig.c_translation.promoteIntLiteral(c_int, 9223372036854775807, .decimal)) - @as(c_int, 1); +pub const INTMAX_MAX = __INT64_C(@import("std").zig.c_translation.promoteIntLiteral(c_int, 9223372036854775807, .decimal)); +pub const UINTMAX_MAX = __UINT64_C(@import("std").zig.c_translation.promoteIntLiteral(c_int, 18446744073709551615, .decimal)); +pub const PTRDIFF_MIN = -@import("std").zig.c_translation.promoteIntLiteral(c_long, 9223372036854775807, .decimal) - @as(c_int, 1); +pub const PTRDIFF_MAX = @import("std").zig.c_translation.promoteIntLiteral(c_long, 9223372036854775807, .decimal); +pub const SIG_ATOMIC_MIN = -@import("std").zig.c_translation.promoteIntLiteral(c_int, 2147483647, .decimal) - @as(c_int, 1); +pub const SIG_ATOMIC_MAX = @import("std").zig.c_translation.promoteIntLiteral(c_int, 2147483647, .decimal); +pub const SIZE_MAX = @import("std").zig.c_translation.promoteIntLiteral(c_ulong, 18446744073709551615, .decimal); +pub const WCHAR_MIN = __WCHAR_MIN; +pub const WCHAR_MAX = __WCHAR_MAX; +pub const WINT_MIN = @as(c_uint, 0); +pub const WINT_MAX = @import("std").zig.c_translation.promoteIntLiteral(c_uint, 4294967295, .decimal); +pub inline fn INT8_C(c: anytype) @TypeOf(c) { + _ = &c; + return c; +} +pub inline fn INT16_C(c: anytype) @TypeOf(c) { + _ = &c; + return c; +} +pub inline fn INT32_C(c: anytype) @TypeOf(c) { + _ = &c; + return c; +} +pub const INT64_C = @import("std").zig.c_translation.Macros.L_SUFFIX; +pub inline fn UINT8_C(c: anytype) @TypeOf(c) { + _ = &c; + return c; +} +pub inline fn UINT16_C(c: anytype) @TypeOf(c) { + _ = &c; + return c; +} +pub const UINT32_C = @import("std").zig.c_translation.Macros.U_SUFFIX; +pub const UINT64_C = @import("std").zig.c_translation.Macros.UL_SUFFIX; +pub const INTMAX_C = @import("std").zig.c_translation.Macros.L_SUFFIX; +pub const UINTMAX_C = @import("std").zig.c_translation.Macros.UL_SUFFIX; +pub const __CLANG_LIMITS_H = ""; +pub const _GCC_LIMITS_H_ = ""; +pub const _LIBC_LIMITS_H_ = @as(c_int, 1); +pub const MB_LEN_MAX = @as(c_int, 16); +pub const LLONG_MIN = -LLONG_MAX - @as(c_int, 1); +pub const LLONG_MAX = __LONG_LONG_MAX__; +pub const ULLONG_MAX = (LLONG_MAX * @as(c_ulonglong, 2)) + @as(c_int, 1); +pub const _BITS_POSIX1_LIM_H = @as(c_int, 1); +pub const _POSIX_AIO_LISTIO_MAX = @as(c_int, 2); +pub const _POSIX_AIO_MAX = @as(c_int, 1); +pub const _POSIX_ARG_MAX = @as(c_int, 4096); +pub const _POSIX_CHILD_MAX = @as(c_int, 25); +pub const _POSIX_DELAYTIMER_MAX = @as(c_int, 32); +pub const _POSIX_HOST_NAME_MAX = @as(c_int, 255); +pub const _POSIX_LINK_MAX = @as(c_int, 8); +pub const _POSIX_LOGIN_NAME_MAX = @as(c_int, 9); +pub const _POSIX_MAX_CANON = @as(c_int, 255); +pub const _POSIX_MAX_INPUT = @as(c_int, 255); +pub const _POSIX_MQ_OPEN_MAX = @as(c_int, 8); +pub const _POSIX_MQ_PRIO_MAX = @as(c_int, 32); +pub const _POSIX_NAME_MAX = @as(c_int, 14); +pub const _POSIX_NGROUPS_MAX = @as(c_int, 8); +pub const _POSIX_OPEN_MAX = @as(c_int, 20); +pub const _POSIX_PATH_MAX = @as(c_int, 256); +pub const _POSIX_PIPE_BUF = @as(c_int, 512); +pub const _POSIX_RE_DUP_MAX = @as(c_int, 255); +pub const _POSIX_RTSIG_MAX = @as(c_int, 8); +pub const _POSIX_SEM_NSEMS_MAX = @as(c_int, 256); +pub const _POSIX_SEM_VALUE_MAX = @as(c_int, 32767); +pub const _POSIX_SIGQUEUE_MAX = @as(c_int, 32); +pub const _POSIX_SSIZE_MAX = @as(c_int, 32767); +pub const _POSIX_STREAM_MAX = @as(c_int, 8); +pub const _POSIX_SYMLINK_MAX = @as(c_int, 255); +pub const _POSIX_SYMLOOP_MAX = @as(c_int, 8); +pub const _POSIX_TIMER_MAX = @as(c_int, 32); +pub const _POSIX_TTY_NAME_MAX = @as(c_int, 9); +pub const _POSIX_TZNAME_MAX = @as(c_int, 6); +pub const _POSIX_CLOCKRES_MIN = @import("std").zig.c_translation.promoteIntLiteral(c_int, 20000000, .decimal); +pub const __undef_NR_OPEN = ""; +pub const __undef_LINK_MAX = ""; +pub const __undef_OPEN_MAX = ""; +pub const __undef_ARG_MAX = ""; +pub const _LINUX_LIMITS_H = ""; +pub const NR_OPEN = @as(c_int, 1024); +pub const NGROUPS_MAX = @import("std").zig.c_translation.promoteIntLiteral(c_int, 65536, .decimal); +pub const ARG_MAX = @import("std").zig.c_translation.promoteIntLiteral(c_int, 131072, .decimal); +pub const LINK_MAX = @as(c_int, 127); +pub const MAX_CANON = @as(c_int, 255); +pub const MAX_INPUT = @as(c_int, 255); +pub const NAME_MAX = @as(c_int, 255); +pub const PATH_MAX = @as(c_int, 4096); +pub const PIPE_BUF = @as(c_int, 4096); +pub const XATTR_NAME_MAX = @as(c_int, 255); +pub const XATTR_SIZE_MAX = @import("std").zig.c_translation.promoteIntLiteral(c_int, 65536, .decimal); +pub const XATTR_LIST_MAX = @import("std").zig.c_translation.promoteIntLiteral(c_int, 65536, .decimal); +pub const RTSIG_MAX = @as(c_int, 32); +pub const _POSIX_THREAD_KEYS_MAX = @as(c_int, 128); +pub const PTHREAD_KEYS_MAX = @as(c_int, 1024); +pub const _POSIX_THREAD_DESTRUCTOR_ITERATIONS = @as(c_int, 4); +pub const PTHREAD_DESTRUCTOR_ITERATIONS = _POSIX_THREAD_DESTRUCTOR_ITERATIONS; +pub const _POSIX_THREAD_THREADS_MAX = @as(c_int, 64); +pub const AIO_PRIO_DELTA_MAX = @as(c_int, 20); +pub const PTHREAD_STACK_MIN = @as(c_int, 16384); +pub const DELAYTIMER_MAX = @import("std").zig.c_translation.promoteIntLiteral(c_int, 2147483647, .decimal); +pub const TTY_NAME_MAX = @as(c_int, 32); +pub const LOGIN_NAME_MAX = @as(c_int, 256); +pub const HOST_NAME_MAX = @as(c_int, 64); +pub const MQ_PRIO_MAX = @import("std").zig.c_translation.promoteIntLiteral(c_int, 32768, .decimal); +pub const SEM_VALUE_MAX = @import("std").zig.c_translation.promoteIntLiteral(c_int, 2147483647, .decimal); +pub const SSIZE_MAX = LONG_MAX; +pub const _BITS_POSIX2_LIM_H = @as(c_int, 1); +pub const _POSIX2_BC_BASE_MAX = @as(c_int, 99); +pub const _POSIX2_BC_DIM_MAX = @as(c_int, 2048); +pub const _POSIX2_BC_SCALE_MAX = @as(c_int, 99); +pub const _POSIX2_BC_STRING_MAX = @as(c_int, 1000); +pub const _POSIX2_COLL_WEIGHTS_MAX = @as(c_int, 2); +pub const _POSIX2_EXPR_NEST_MAX = @as(c_int, 32); +pub const _POSIX2_LINE_MAX = @as(c_int, 2048); +pub const _POSIX2_RE_DUP_MAX = @as(c_int, 255); +pub const _POSIX2_CHARCLASS_NAME_MAX = @as(c_int, 14); +pub const BC_BASE_MAX = _POSIX2_BC_BASE_MAX; +pub const BC_DIM_MAX = _POSIX2_BC_DIM_MAX; +pub const BC_SCALE_MAX = _POSIX2_BC_SCALE_MAX; +pub const BC_STRING_MAX = _POSIX2_BC_STRING_MAX; +pub const COLL_WEIGHTS_MAX = @as(c_int, 255); +pub const EXPR_NEST_MAX = _POSIX2_EXPR_NEST_MAX; +pub const LINE_MAX = _POSIX2_LINE_MAX; +pub const CHARCLASS_NAME_MAX = @as(c_int, 2048); +pub const RE_DUP_MAX = @as(c_int, 0x7fff); +pub const SCHAR_MAX = __SCHAR_MAX__; +pub const SHRT_MAX = __SHRT_MAX__; +pub const INT_MAX = __INT_MAX__; +pub const LONG_MAX = __LONG_MAX__; +pub const SCHAR_MIN = -__SCHAR_MAX__ - @as(c_int, 1); +pub const SHRT_MIN = -__SHRT_MAX__ - @as(c_int, 1); +pub const INT_MIN = -__INT_MAX__ - @as(c_int, 1); +pub const LONG_MIN = -__LONG_MAX__ - @as(c_long, 1); +pub const UCHAR_MAX = (__SCHAR_MAX__ * @as(c_int, 2)) + @as(c_int, 1); +pub const USHRT_MAX = (__SHRT_MAX__ * @as(c_int, 2)) + @as(c_int, 1); +pub const UINT_MAX = (__INT_MAX__ * @as(c_uint, 2)) + @as(c_uint, 1); +pub const ULONG_MAX = (__LONG_MAX__ * @as(c_ulong, 2)) + @as(c_ulong, 1); +pub const CHAR_BIT = __CHAR_BIT__; +pub const CHAR_MIN = SCHAR_MIN; +pub const CHAR_MAX = __SCHAR_MAX__; +pub const __CLANG_FLOAT_H = ""; +pub const FLT_EVAL_METHOD = @compileError("unable to translate macro: undefined identifier `__FLT_EVAL_METHOD__`"); +// /opt/zig-bin-0.13.0/lib/include/float.h:91:9 +pub const FLT_ROUNDS = @compileError("unable to translate macro: undefined identifier `__builtin_flt_rounds`"); +// /opt/zig-bin-0.13.0/lib/include/float.h:93:9 +pub const FLT_RADIX = __FLT_RADIX__; +pub const FLT_MANT_DIG = __FLT_MANT_DIG__; +pub const DBL_MANT_DIG = __DBL_MANT_DIG__; +pub const LDBL_MANT_DIG = __LDBL_MANT_DIG__; +pub const DECIMAL_DIG = __DECIMAL_DIG__; +pub const FLT_DIG = __FLT_DIG__; +pub const DBL_DIG = __DBL_DIG__; +pub const LDBL_DIG = __LDBL_DIG__; +pub const FLT_MIN_EXP = __FLT_MIN_EXP__; +pub const DBL_MIN_EXP = __DBL_MIN_EXP__; +pub const LDBL_MIN_EXP = __LDBL_MIN_EXP__; +pub const FLT_MIN_10_EXP = __FLT_MIN_10_EXP__; +pub const DBL_MIN_10_EXP = __DBL_MIN_10_EXP__; +pub const LDBL_MIN_10_EXP = __LDBL_MIN_10_EXP__; +pub const FLT_MAX_EXP = __FLT_MAX_EXP__; +pub const DBL_MAX_EXP = __DBL_MAX_EXP__; +pub const LDBL_MAX_EXP = __LDBL_MAX_EXP__; +pub const FLT_MAX_10_EXP = __FLT_MAX_10_EXP__; +pub const DBL_MAX_10_EXP = __DBL_MAX_10_EXP__; +pub const LDBL_MAX_10_EXP = __LDBL_MAX_10_EXP__; +pub const FLT_MAX = __FLT_MAX__; +pub const DBL_MAX = __DBL_MAX__; +pub const LDBL_MAX = __LDBL_MAX__; +pub const FLT_EPSILON = __FLT_EPSILON__; +pub const DBL_EPSILON = __DBL_EPSILON__; +pub const LDBL_EPSILON = __LDBL_EPSILON__; +pub const FLT_MIN = __FLT_MIN__; +pub const DBL_MIN = __DBL_MIN__; +pub const LDBL_MIN = __LDBL_MIN__; +pub const FLT_TRUE_MIN = __FLT_DENORM_MIN__; +pub const DBL_TRUE_MIN = __DBL_DENORM_MIN__; +pub const LDBL_TRUE_MIN = __LDBL_DENORM_MIN__; +pub const FLT_DECIMAL_DIG = __FLT_DECIMAL_DIG__; +pub const DBL_DECIMAL_DIG = __DBL_DECIMAL_DIG__; +pub const LDBL_DECIMAL_DIG = __LDBL_DECIMAL_DIG__; +pub const FLT_HAS_SUBNORM = __FLT_HAS_DENORM__; +pub const DBL_HAS_SUBNORM = __DBL_HAS_DENORM__; +pub const LDBL_HAS_SUBNORM = __LDBL_HAS_DENORM__; +pub const JSMN_PARENT_LINKS = ""; +pub const JSMN_STRICT = ""; +pub const GlbHeaderSize = @as(c_int, 12); +pub const GlbChunkHeaderSize = @as(c_int, 8); +pub const CGLTF_CONSTS = ""; +pub inline fn CGLTF_ATOI(str: anytype) @TypeOf(atoi(str)) { + _ = &str; + return atoi(str); +} +pub inline fn CGLTF_ATOF(str: anytype) @TypeOf(atof(str)) { + _ = &str; + return atof(str); +} +pub inline fn CGLTF_ATOLL(str: anytype) @TypeOf(atoll(str)) { + _ = &str; + return atoll(str); +} +pub const CGLTF_VALIDATE_ENABLE_ASSERTS = @as(c_int, 0); +pub const CGLTF_ASSERT_IF = @compileError("unable to translate C expr: unexpected token 'if'"); +// ./external/cgltf.h:1559:9 +pub const CGLTF_ERROR_JSON = -@as(c_int, 1); +pub const CGLTF_ERROR_NOMEM = -@as(c_int, 2); +pub const CGLTF_ERROR_LEGACY = -@as(c_int, 3); +pub const CGLTF_CHECK_TOKTYPE = @compileError("unable to translate C expr: unexpected token 'if'"); +// ./external/cgltf.h:2640:9 +pub const CGLTF_CHECK_TOKTYPE_RET = @compileError("unable to translate C expr: unexpected token 'if'"); +// ./external/cgltf.h:2641:9 +pub const CGLTF_CHECK_KEY = @compileError("unable to translate C expr: unexpected token 'if'"); +// ./external/cgltf.h:2642:9 +pub const CGLTF_PTRINDEX = @compileError("unable to translate C expr: unexpected token ')'"); +// ./external/cgltf.h:2644:9 +pub const CGLTF_PTRFIXUP = @compileError("unable to translate C expr: unexpected token 'if'"); +// ./external/cgltf.h:2645:9 +pub const CGLTF_PTRFIXUP_REQ = @compileError("unable to translate C expr: unexpected token 'if'"); +// ./external/cgltf.h:2646:9 +pub const VOX_MALLOC = RL_MALLOC; +pub const VOX_CALLOC = RL_CALLOC; +pub const VOX_REALLOC = RL_REALLOC; +pub const VOX_FREE = RL_FREE; +pub const VOX_LOADER_IMPLEMENTATION = ""; +pub const VOX_LOADER_H = ""; +pub const VOX_SUCCESS = @as(c_int, 0); +pub const VOX_ERROR_FILE_NOT_FOUND = -@as(c_int, 1); +pub const VOX_ERROR_INVALID_FORMAT = -@as(c_int, 2); +pub const VOX_ERROR_FILE_VERSION_NOT_MATCH = -@as(c_int, 3); +pub const CHUNKSIZE = @as(c_int, 16); +pub const CHUNKSIZE_OPSHIFT = @as(c_int, 4); +pub const CHUNK_FLATTENOFFSET_OPSHIFT = @as(c_int, 8); +pub const M3D_MALLOC = RL_MALLOC; +pub const M3D_REALLOC = RL_REALLOC; +pub const M3D_FREE = RL_FREE; +pub const M3D_IMPLEMENTATION = ""; +pub const _M3D_H_ = ""; +pub const M3D_LOG = @compileError("unable to translate C expr: unexpected token ''"); +// ./external/m3d.h:56:10 +pub const M3D_APIVERSION = @as(c_int, 0x0100); +pub const M3D_EPSILON = @import("std").zig.c_translation.cast(M3D_FLOAT, @as(f64, 1e-7)); +pub const M3D_UNDEF = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0xffffffff, .hex); +pub const M3D_INDEXMAX = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0xfffffffe, .hex); +pub const M3D_VOXUNDEF = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0xffff, .hex); +pub const M3D_VOXCLEAR = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0xfffe, .hex); +pub const M3D_NOTDEFINED = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0xffffffff, .hex); +pub const M3D_NUMBONE = @as(c_int, 4); +pub const M3D_BONEMAXLEVEL = @as(c_int, 64); +pub const _inline = @compileError("unable to translate C expr: unexpected token '__inline__'"); +// ./external/m3d.h:96:9 +pub const _pack = @compileError("unable to translate macro: undefined identifier `packed`"); +// ./external/m3d.h:98:9 +pub const _unused = @compileError("unable to translate macro: undefined identifier `unused`"); +// ./external/m3d.h:99:9 +pub const _register = @compileError("unable to translate C expr: unexpected token 'register'"); +// ./external/m3d.h:106:9 +pub const m3d_textureindex_t = m3dti_t; +pub const m3d_texturedata_t = m3dtx_t; +pub const m3d_weight_t = m3dw_t; +pub const m3d_bone_t = m3db_t; +pub const m3d_skin_t = m3ds_t; +pub const m3d_vertex_t = m3dv_t; +pub const M3D_PROPERTYDEF = @compileError("unable to translate C expr: unexpected token '{'"); +// ./external/m3d.h:240:9 +pub const m3d_property_t = m3dp_t; +pub const m3d_material_t = m3dm_t; +pub const m3d_face_t = m3df_t; +pub const m3d_voxelitem_t = m3dvi_t; +pub const m3d_parameter_t = m3dvi_t; +pub const m3d_voxeltype_t = m3dvt_t; +pub const m3d_voxel_t = m3dvx_t; +pub const M3D_CMDMAXARG = @as(c_int, 8); +pub const M3D_CMDDEF = @compileError("unable to translate C expr: unexpected token '{'"); +// ./external/m3d.h:418:9 +pub const m3d_shapecommand_t = m3dc_t; +pub const m3d_shape_t = m3dh_t; +pub const m3d_label_t = m3dl_t; +pub const m3d_transform_t = m3dtr_t; +pub const m3d_frame_t = m3dfr_t; +pub const m3d_action_t = m3da_t; +pub const m3d_inlinedasset_t = m3di_t; +pub const M3D_FLG_FREERAW = @as(c_int, 1) << @as(c_int, 0); +pub const M3D_FLG_FREESTR = @as(c_int, 1) << @as(c_int, 1); +pub const M3D_FLG_MTLLIB = @as(c_int, 1) << @as(c_int, 2); +pub const M3D_FLG_GENNORM = @as(c_int, 1) << @as(c_int, 3); +pub const M3D_EXP_INT8 = @as(c_int, 0); +pub const M3D_EXP_INT16 = @as(c_int, 1); +pub const M3D_EXP_FLOAT = @as(c_int, 2); +pub const M3D_EXP_DOUBLE = @as(c_int, 3); +pub const M3D_EXP_NOCMAP = @as(c_int, 1) << @as(c_int, 0); +pub const M3D_EXP_NOMATERIAL = @as(c_int, 1) << @as(c_int, 1); +pub const M3D_EXP_NOFACE = @as(c_int, 1) << @as(c_int, 2); +pub const M3D_EXP_NONORMAL = @as(c_int, 1) << @as(c_int, 3); +pub const M3D_EXP_NOTXTCRD = @as(c_int, 1) << @as(c_int, 4); +pub const M3D_EXP_FLIPTXTCRD = @as(c_int, 1) << @as(c_int, 5); +pub const M3D_EXP_NORECALC = @as(c_int, 1) << @as(c_int, 6); +pub const M3D_EXP_IDOSUCK = @as(c_int, 1) << @as(c_int, 7); +pub const M3D_EXP_NOBONE = @as(c_int, 1) << @as(c_int, 8); +pub const M3D_EXP_NOACTION = @as(c_int, 1) << @as(c_int, 9); +pub const M3D_EXP_INLINE = @as(c_int, 1) << @as(c_int, 10); +pub const M3D_EXP_EXTRA = @as(c_int, 1) << @as(c_int, 11); +pub const M3D_EXP_NOZLIB = @as(c_int, 1) << @as(c_int, 14); +pub const M3D_EXP_ASCII = @as(c_int, 1) << @as(c_int, 15); +pub const M3D_EXP_NOVRTMAX = @as(c_int, 1) << @as(c_int, 16); +pub const M3D_SUCCESS = @as(c_int, 0); +pub const M3D_ERR_ALLOC = -@as(c_int, 1); +pub const M3D_ERR_BADFILE = -@as(c_int, 2); +pub const M3D_ERR_UNIMPL = -@as(c_int, 65); +pub const M3D_ERR_UNKPROP = -@as(c_int, 66); +pub const M3D_ERR_UNKMESH = -@as(c_int, 67); +pub const M3D_ERR_UNKIMG = -@as(c_int, 68); +pub const M3D_ERR_UNKFRAME = -@as(c_int, 69); +pub const M3D_ERR_UNKCMD = -@as(c_int, 70); +pub const M3D_ERR_UNKVOX = -@as(c_int, 71); +pub const M3D_ERR_TRUNC = -@as(c_int, 72); +pub const M3D_ERR_CMAP = -@as(c_int, 73); +pub const M3D_ERR_TMAP = -@as(c_int, 74); +pub const M3D_ERR_VRTS = -@as(c_int, 75); +pub const M3D_ERR_BONE = -@as(c_int, 76); +pub const M3D_ERR_MTRL = -@as(c_int, 77); +pub const M3D_ERR_SHPE = -@as(c_int, 78); +pub const M3D_ERR_VOXT = -@as(c_int, 79); +pub inline fn M3D_ERR_ISFATAL(x: anytype) @TypeOf((x < @as(c_int, 0)) and (x > -@as(c_int, 65))) { + _ = &x; + return (x < @as(c_int, 0)) and (x > -@as(c_int, 65)); +} +pub const STBI_ASSERT = @compileError("unable to translate C expr: unexpected token ''"); +// ./external/m3d.h:730:9 +pub inline fn STBI_NOTUSED(v: anytype) anyopaque { + _ = &v; + return @import("std").zig.c_translation.cast(anyopaque, @import("std").zig.c_translation.sizeof(v)); +} +pub inline fn STBI__BYTECAST(x: anytype) u8 { + _ = &x; + return @import("std").zig.c_translation.cast(u8, x & @as(c_int, 255)); +} +pub inline fn STBI_MALLOC(sz: anytype) @TypeOf(M3D_MALLOC(sz)) { + _ = &sz; + return M3D_MALLOC(sz); +} +pub inline fn STBI_REALLOC(p: anytype, newsz: anytype) @TypeOf(M3D_REALLOC(p, newsz)) { + _ = &p; + _ = &newsz; + return M3D_REALLOC(p, newsz); +} +pub inline fn STBI_FREE(p: anytype) @TypeOf(M3D_FREE(p)) { + _ = &p; + return M3D_FREE(p); +} +pub inline fn STBI_REALLOC_SIZED(p: anytype, oldsz: anytype, newsz: anytype) @TypeOf(STBI_REALLOC(p, newsz)) { + _ = &p; + _ = &oldsz; + _ = &newsz; + return STBI_REALLOC(p, newsz); +} +pub inline fn _m3dstbi__err(x: anytype, y: anytype) @TypeOf(_m3dstbi__errstr(y)) { + _ = &x; + _ = &y; + return _m3dstbi__errstr(y); +} +pub inline fn STBI__COMBO(a: anytype, b: anytype) @TypeOf((a * @as(c_int, 8)) + b) { + _ = &a; + _ = &b; + return (a * @as(c_int, 8)) + b; +} +pub const STBI__CASE = @compileError("unable to translate macro: undefined identifier `i`"); +// ./external/m3d.h:854:15 +pub const STBI__ZFAST_BITS = @as(c_int, 9); +pub const STBI__ZFAST_MASK = (@as(c_int, 1) << STBI__ZFAST_BITS) - @as(c_int, 1); +pub inline fn STBI__PNG_TYPE(a: anytype, b: anytype, c: anytype, d: anytype) @TypeOf((((@import("std").zig.c_translation.cast(c_uint, a) << @as(c_int, 24)) + (@import("std").zig.c_translation.cast(c_uint, b) << @as(c_int, 16))) + (@import("std").zig.c_translation.cast(c_uint, c) << @as(c_int, 8))) + @import("std").zig.c_translation.cast(c_uint, d)) { + _ = &a; + _ = &b; + _ = &c; + _ = &d; + return (((@import("std").zig.c_translation.cast(c_uint, a) << @as(c_int, 24)) + (@import("std").zig.c_translation.cast(c_uint, b) << @as(c_int, 16))) + (@import("std").zig.c_translation.cast(c_uint, c) << @as(c_int, 8))) + @import("std").zig.c_translation.cast(c_uint, d); +} +pub const stbi__context = _m3dstbi__context; +pub const stbi__result_info = _m3dstbi__result_info; +pub const stbi__png_load = _m3dstbi__png_load; +pub const stbi_zlib_decode_malloc_guesssize_headerflag = _m3dstbi_zlib_decode_malloc_guesssize_headerflag; +pub inline fn M3D_CHUNKMAGIC(m: anytype, a: anytype, b: anytype, c: anytype, d: anytype) @TypeOf((((m[@as(usize, @intCast(@as(c_int, 0)))] == a) and (m[@as(usize, @intCast(@as(c_int, 1)))] == b)) and (m[@as(usize, @intCast(@as(c_int, 2)))] == c)) and (m[@as(usize, @intCast(@as(c_int, 3)))] == d)) { + _ = &m; + _ = &a; + _ = &b; + _ = &c; + _ = &d; + return (((m[@as(usize, @intCast(@as(c_int, 0)))] == a) and (m[@as(usize, @intCast(@as(c_int, 1)))] == b)) and (m[@as(usize, @intCast(@as(c_int, 2)))] == c)) and (m[@as(usize, @intCast(@as(c_int, 3)))] == d); +} +pub const M3D_GETSTR = @compileError("unable to translate macro: undefined identifier `offs`"); +// ./external/m3d.h:2278:9 +pub const PAR_MALLOC = @compileError("unable to translate C expr: unexpected token ')'"); +// rmodels.c:99:13 +pub const PAR_CALLOC = @compileError("unable to translate C expr: unexpected token ')'"); +// rmodels.c:100:13 +pub const PAR_REALLOC = @compileError("unable to translate C expr: unexpected token ')'"); +// rmodels.c:101:13 +pub const PAR_FREE = RL_FREE; +pub const PAR_SHAPES_IMPLEMENTATION = ""; +pub const PAR_SHAPES_H = ""; +pub const PAR_SHAPES_T = u16; +pub const PAR_PI = @as(f64, 3.14159265359); +pub inline fn PAR_MIN(a: anytype, b: anytype) @TypeOf(if (a > b) b else a) { + _ = &a; + _ = &b; + return if (a > b) b else a; +} +pub inline fn PAR_MAX(a: anytype, b: anytype) @TypeOf(if (a > b) a else b) { + _ = &a; + _ = &b; + return if (a > b) a else b; +} +pub inline fn PAR_CLAMP(v: anytype, lo: anytype, hi: anytype) @TypeOf(PAR_MAX(lo, PAR_MIN(hi, v))) { + _ = &v; + _ = &lo; + _ = &hi; + return PAR_MAX(lo, PAR_MIN(hi, v)); +} +pub const PAR_SWAP = @compileError("unable to translate macro: undefined identifier `tmp`"); +// ./external/par_shapes.h:197:9 +pub inline fn PAR_SQR(a: anytype) @TypeOf(a * a) { + _ = &a; + return a * a; +} +pub const STRETCH_CONSTANT_2D = -@as(f64, 0.211324865405187); +pub const SQUISH_CONSTANT_2D = @as(f64, 0.366025403784439); +pub const STRETCH_CONSTANT_3D = @import("std").zig.c_translation.MacroArithmetic.div(-@as(f64, 1.0), @as(f64, 6.0)); +pub const SQUISH_CONSTANT_3D = @import("std").zig.c_translation.MacroArithmetic.div(@as(f64, 1.0), @as(f64, 3.0)); +pub const STRETCH_CONSTANT_4D = -@as(f64, 0.138196601125011); +pub const SQUISH_CONSTANT_4D = @as(f64, 0.309016994374947); +pub const NORM_CONSTANT_2D = @as(f64, 47.0); +pub const NORM_CONSTANT_3D = @as(f64, 103.0); +pub const NORM_CONSTANT_4D = @as(f64, 30.0); +pub const DEFAULT_SEED = @as(c_longlong, 0); +pub const ARRAYSIZE = @compileError("unable to translate C expr: unexpected token '('"); +// ./external/par_shapes.h:1857:9 +pub const _UNISTD_H = @as(c_int, 1); +pub const _POSIX_VERSION = @as(c_long, 200809); +pub const __POSIX2_THIS_VERSION = @as(c_long, 200809); +pub const _POSIX2_VERSION = __POSIX2_THIS_VERSION; +pub const _POSIX2_C_VERSION = __POSIX2_THIS_VERSION; +pub const _POSIX2_C_BIND = __POSIX2_THIS_VERSION; +pub const _POSIX2_C_DEV = __POSIX2_THIS_VERSION; +pub const _POSIX2_SW_DEV = __POSIX2_THIS_VERSION; +pub const _POSIX2_LOCALEDEF = __POSIX2_THIS_VERSION; +pub const _XOPEN_VERSION = @as(c_int, 700); +pub const _XOPEN_XCU_VERSION = @as(c_int, 4); +pub const _XOPEN_XPG2 = @as(c_int, 1); +pub const _XOPEN_XPG3 = @as(c_int, 1); +pub const _XOPEN_XPG4 = @as(c_int, 1); +pub const _XOPEN_UNIX = @as(c_int, 1); +pub const _XOPEN_ENH_I18N = @as(c_int, 1); +pub const _XOPEN_LEGACY = @as(c_int, 1); +pub const _BITS_POSIX_OPT_H = @as(c_int, 1); +pub const _POSIX_JOB_CONTROL = @as(c_int, 1); +pub const _POSIX_SAVED_IDS = @as(c_int, 1); +pub const _POSIX_PRIORITY_SCHEDULING = @as(c_long, 200809); +pub const _POSIX_SYNCHRONIZED_IO = @as(c_long, 200809); +pub const _POSIX_FSYNC = @as(c_long, 200809); +pub const _POSIX_MAPPED_FILES = @as(c_long, 200809); +pub const _POSIX_MEMLOCK = @as(c_long, 200809); +pub const _POSIX_MEMLOCK_RANGE = @as(c_long, 200809); +pub const _POSIX_MEMORY_PROTECTION = @as(c_long, 200809); +pub const _POSIX_CHOWN_RESTRICTED = @as(c_int, 0); +pub const _POSIX_VDISABLE = '\x00'; +pub const _POSIX_NO_TRUNC = @as(c_int, 1); +pub const _XOPEN_REALTIME = @as(c_int, 1); +pub const _XOPEN_REALTIME_THREADS = @as(c_int, 1); +pub const _XOPEN_SHM = @as(c_int, 1); +pub const _POSIX_THREADS = @as(c_long, 200809); +pub const _POSIX_REENTRANT_FUNCTIONS = @as(c_int, 1); +pub const _POSIX_THREAD_SAFE_FUNCTIONS = @as(c_long, 200809); +pub const _POSIX_THREAD_PRIORITY_SCHEDULING = @as(c_long, 200809); +pub const _POSIX_THREAD_ATTR_STACKSIZE = @as(c_long, 200809); +pub const _POSIX_THREAD_ATTR_STACKADDR = @as(c_long, 200809); +pub const _POSIX_THREAD_PRIO_INHERIT = @as(c_long, 200809); +pub const _POSIX_THREAD_PRIO_PROTECT = @as(c_long, 200809); +pub const _POSIX_THREAD_ROBUST_PRIO_INHERIT = @as(c_long, 200809); +pub const _POSIX_THREAD_ROBUST_PRIO_PROTECT = -@as(c_int, 1); +pub const _POSIX_SEMAPHORES = @as(c_long, 200809); +pub const _POSIX_REALTIME_SIGNALS = @as(c_long, 200809); +pub const _POSIX_ASYNCHRONOUS_IO = @as(c_long, 200809); +pub const _POSIX_ASYNC_IO = @as(c_int, 1); +pub const _LFS_ASYNCHRONOUS_IO = @as(c_int, 1); +pub const _POSIX_PRIORITIZED_IO = @as(c_long, 200809); +pub const _LFS64_ASYNCHRONOUS_IO = @as(c_int, 1); +pub const _LFS_LARGEFILE = @as(c_int, 1); +pub const _LFS64_LARGEFILE = @as(c_int, 1); +pub const _LFS64_STDIO = @as(c_int, 1); +pub const _POSIX_SHARED_MEMORY_OBJECTS = @as(c_long, 200809); +pub const _POSIX_CPUTIME = @as(c_int, 0); +pub const _POSIX_THREAD_CPUTIME = @as(c_int, 0); +pub const _POSIX_REGEXP = @as(c_int, 1); +pub const _POSIX_READER_WRITER_LOCKS = @as(c_long, 200809); +pub const _POSIX_SHELL = @as(c_int, 1); +pub const _POSIX_TIMEOUTS = @as(c_long, 200809); +pub const _POSIX_SPIN_LOCKS = @as(c_long, 200809); +pub const _POSIX_SPAWN = @as(c_long, 200809); +pub const _POSIX_TIMERS = @as(c_long, 200809); +pub const _POSIX_BARRIERS = @as(c_long, 200809); +pub const _POSIX_MESSAGE_PASSING = @as(c_long, 200809); +pub const _POSIX_THREAD_PROCESS_SHARED = @as(c_long, 200809); +pub const _POSIX_MONOTONIC_CLOCK = @as(c_int, 0); +pub const _POSIX_CLOCK_SELECTION = @as(c_long, 200809); +pub const _POSIX_ADVISORY_INFO = @as(c_long, 200809); +pub const _POSIX_IPV6 = @as(c_long, 200809); +pub const _POSIX_RAW_SOCKETS = @as(c_long, 200809); +pub const _POSIX2_CHAR_TERM = @as(c_long, 200809); +pub const _POSIX_SPORADIC_SERVER = -@as(c_int, 1); +pub const _POSIX_THREAD_SPORADIC_SERVER = -@as(c_int, 1); +pub const _POSIX_TRACE = -@as(c_int, 1); +pub const _POSIX_TRACE_EVENT_FILTER = -@as(c_int, 1); +pub const _POSIX_TRACE_INHERIT = -@as(c_int, 1); +pub const _POSIX_TRACE_LOG = -@as(c_int, 1); +pub const _POSIX_TYPED_MEMORY_OBJECTS = -@as(c_int, 1); +pub const _POSIX_V7_LPBIG_OFFBIG = -@as(c_int, 1); +pub const _POSIX_V6_LPBIG_OFFBIG = -@as(c_int, 1); +pub const _XBS5_LPBIG_OFFBIG = -@as(c_int, 1); +pub const _POSIX_V7_LP64_OFF64 = @as(c_int, 1); +pub const _POSIX_V6_LP64_OFF64 = @as(c_int, 1); +pub const _XBS5_LP64_OFF64 = @as(c_int, 1); +pub const __ILP32_OFF32_CFLAGS = "-m32"; +pub const __ILP32_OFF32_LDFLAGS = "-m32"; +pub const __ILP32_OFFBIG_CFLAGS = "-m32 -D_LARGEFILE_SOURCE -D_FILE_OFFSET_BITS=64"; +pub const __ILP32_OFFBIG_LDFLAGS = "-m32"; +pub const __LP64_OFF64_CFLAGS = "-m64"; +pub const __LP64_OFF64_LDFLAGS = "-m64"; +pub const STDIN_FILENO = @as(c_int, 0); +pub const STDOUT_FILENO = @as(c_int, 1); +pub const STDERR_FILENO = @as(c_int, 2); +pub const __useconds_t_defined = ""; +pub const __socklen_t_defined = ""; +pub const R_OK = @as(c_int, 4); +pub const W_OK = @as(c_int, 2); +pub const X_OK = @as(c_int, 1); +pub const F_OK = @as(c_int, 0); +pub const L_SET = SEEK_SET; +pub const L_INCR = SEEK_CUR; +pub const L_XTND = SEEK_END; +pub const _SC_PAGE_SIZE = _SC_PAGESIZE; +pub const _CS_POSIX_V6_WIDTH_RESTRICTED_ENVS = _CS_V6_WIDTH_RESTRICTED_ENVS; +pub const _CS_POSIX_V5_WIDTH_RESTRICTED_ENVS = _CS_V5_WIDTH_RESTRICTED_ENVS; +pub const _CS_POSIX_V7_WIDTH_RESTRICTED_ENVS = _CS_V7_WIDTH_RESTRICTED_ENVS; +pub const _GETOPT_POSIX_H = @as(c_int, 1); +pub const _GETOPT_CORE_H = @as(c_int, 1); +pub const F_ULOCK = @as(c_int, 0); +pub const F_LOCK = @as(c_int, 1); +pub const F_TLOCK = @as(c_int, 2); +pub const F_TEST = @as(c_int, 3); +pub const CHDIR = chdir; +pub const TEXT_BYTES_PER_LINE = @as(c_int, 20); +pub const CUSTOM_MESH_GEN_PLANE = ""; +pub const CUSTOM_MESH_GEN_CUBE = ""; +pub inline fn GRAY_VALUE(c: anytype) @TypeOf(@import("std").zig.c_translation.MacroArithmetic.div(@import("std").zig.c_translation.cast(f32, (c.r + c.g) + c.b), @as(f32, 3.0))) { + _ = &c; + return @import("std").zig.c_translation.MacroArithmetic.div(@import("std").zig.c_translation.cast(f32, (c.r + c.g) + c.b), @as(f32, 3.0)); +} +pub inline fn COLOR_EQUAL(col1: anytype, col2: anytype) @TypeOf((((col1.r == col2.r) and (col1.g == col2.g)) and (col1.b == col2.b)) and (col1.a == col2.a)) { + _ = &col1; + _ = &col2; + return (((col1.r == col2.r) and (col1.g == col2.g)) and (col1.b == col2.b)) and (col1.a == col2.a); +} +pub const IQM_MAGIC = "INTERQUAKEMODEL"; +pub const IQM_VERSION = @as(c_int, 2); +pub const BONE_NAME_LENGTH = @as(c_int, 32); +pub const MESH_NAME_LENGTH = @as(c_int, 32); +pub const MATERIAL_NAME_LENGTH = @as(c_int, 32); +pub const LOAD_ATTRIBUTE = @compileError("unable to translate macro: undefined identifier `n`"); +// rmodels.c:5083:13 +pub const GLTF_ANIMDELAY = @as(c_int, 17); +pub const M3D_ANIMDELAY = @as(c_int, 17); +pub const par_shapes_mesh_s = struct_par_shapes_mesh_s; +pub const _G_fpos_t = struct__G_fpos_t; +pub const _G_fpos64_t = struct__G_fpos64_t; +pub const _IO_marker = struct__IO_marker; +pub const _IO_codecvt = struct__IO_codecvt; +pub const _IO_wide_data = struct__IO_wide_data; +pub const _IO_FILE = struct__IO_FILE; +pub const _IO_cookie_io_functions_t = struct__IO_cookie_io_functions_t; +pub const timeval = struct_timeval; +pub const timespec = struct_timespec; +pub const __pthread_internal_list = struct___pthread_internal_list; +pub const __pthread_internal_slist = struct___pthread_internal_slist; +pub const __pthread_mutex_s = struct___pthread_mutex_s; +pub const __pthread_rwlock_arch_t = struct___pthread_rwlock_arch_t; +pub const __pthread_cond_s = struct___pthread_cond_s; +pub const random_data = struct_random_data; +pub const drand48_data = struct_drand48_data; +pub const __locale_struct = struct___locale_struct; +pub const jsmnerr = enum_jsmnerr; +pub const osn_context = struct_osn_context; diff --git a/src/util/raylib_helper.zig b/src/lib_helpers/raylib_helper.zig similarity index 100% rename from src/util/raylib_helper.zig rename to src/lib_helpers/raylib_helper.zig diff --git a/src/main.zig b/src/main.zig index 7cfc3e1..e34600e 100644 --- a/src/main.zig +++ b/src/main.zig @@ -1,7 +1,10 @@ const std = @import("std"); -const rh = @import("util/raylib_helper.zig"); -const raylib = rh.raylib; -const v3 = rh.v3; + +const raylib_helper = @import("lib_helpers/raylib_helper.zig"); +const raylib = raylib_helper.raylib; +const v3 = raylib_helper.v3; +const znoise = @import("znoise"); + const chunks = @import("world/chunk.zig"); const TILE_TEXTURE_RESOLUTION = 16; @@ -14,7 +17,7 @@ pub fn drawCameraPosition(camera: raylib.Camera3D, x: i32, y: i32) !void { const slice = try std.fmt.bufPrintZ( &buf, - "position: {d} {d} {d}", + "position: {d:.2} {d:.2} {d:.2}", .{ camera.position.x, camera.position.y, camera.position.z }, ); @@ -43,7 +46,8 @@ pub fn main() !void { defer raylib.CloseWindow(); raylib.DisableCursor(); - raylib.SetTargetFPS(60); + raylib.SetWindowState(raylib.FLAG_VSYNC_HINT); + raylib.SetWindowState(raylib.FLAG_FULLSCREEN_MODE); var camera = raylib.Camera3D{ .position = raylib.Vector3{ .x = 0, .y = 0, .z = 0 }, @@ -67,14 +71,18 @@ pub fn main() !void { var chunk = try chunks.Chunk.init(a7r); defer chunk.deinit(); + const height_generator = znoise.FnlGenerator{ .seed = 413445 }; + const tile_type_generator = znoise.FnlGenerator{ .seed = 4435, .frequency = 0.1 }; for (0..32) |raw_x| for (0..32) |raw_y| for (0..32) |raw_z| { const x: u5 = @intCast(raw_x); const y: u5 = @intCast(raw_y); const z: u5 = @intCast(raw_z); - const xt: i32 = @as(i32, @intCast(x)) - 16; - const yt: i32 = @as(i32, @intCast(y)) - 16; - const zt: i32 = @as(i32, @intCast(z)) - 16; - if (xt * xt + yt * yt + zt * zt < 15 * 15) chunk.setTile(x, y, z, if (2 * xt > yt - 30) 1 else 2); + const xf: f32 = @floatFromInt(raw_x); + const yf: f32 = @floatFromInt(raw_y); + const zf: f32 = @floatFromInt(raw_z); + const height: f32 = (height_generator.noise2(xf, zf) + 1) * 16; + const tile_type: u32 = if (tile_type_generator.noise3(xf, yf, zf) > 0) 1 else 2; + if (height >= yf) chunk.setTile(x, y, z, tile_type); }; if (benchmark_chunk_meshing) { diff --git a/src/rendering/chunk_mesh.zig b/src/rendering/chunk_mesh.zig new file mode 100644 index 0000000..d0ae2f7 --- /dev/null +++ b/src/rendering/chunk_mesh.zig @@ -0,0 +1,177 @@ +const std = @import("std"); +const raylib_helper = @import("../lib_helpers/raylib_helper.zig"); +const raylib = raylib_helper.raylib; + +const MAX_VBOS = 4; + +const VERTICES_VBO_ID = 0; +const TEXCOORDS_VBO_ID = 1; +const TEXCOORDS2_VBO_ID = 2; +const NORMALS_VBO_ID = 3; + +const ChunkMesh = packed struct { + vertexCount: i32, + triangleCount: i32, + + vertices: [*]f32, // vertex position, XYZ, 3 vars per vertex + texcoords: [*]f32, // vertex texture coorinates, UV, 2 vars per vertex + texcoords2: [*]f32, // vertex second texture coorinates, UV, 2 vars per vertex + normals: [*]f32, // vertex normals, XYZ, 3 vars per vertex + + vaoId: u32, + vboId: [*]u32, +}; + +pub fn UploadChunkMesh(mesh: ChunkMesh, dynamic: bool) void { + if (mesh.vaoId > 0) { + raylib.TraceLog(raylib.LOG_WARNING, "VAO: [ID %i] Trying to re-load an already loaded chunk mesh", mesh.vaoId); + return; + } + + mesh.vboId = @ptrCast(@alignCast(raylib.MemAlloc(@sizeOf(u32) * MAX_VBOS))); + mesh.vaoId = 0; + + mesh.vboId[VERTICES_VBO_ID] = 0; + mesh.vboId[TEXCOORDS_VBO_ID] = 0; + mesh.vboId[TEXCOORDS2_VBO_ID] = 0; + mesh.vboId[NORMALS_VBO_ID] = 0; + + mesh.vaoId = raylib.rlLoadVertexArray(); + raylib.rlEnableVertexArray(mesh.vaoId); + + mesh.vboId[VERTICES_VBO_ID] = raylib.rlLoadVertexBuffer(mesh.vertices, mesh.vertexCount * 3 * @sizeOf(f32), dynamic); + raylib.rlSetVertexAttribute(VERTICES_VBO_ID, 3, raylib.RL_FLOAT, false, 0, 0); + raylib.rlEnableVertexAttribute(VERTICES_VBO_ID); + + mesh.vboId[TEXCOORDS_VBO_ID] = raylib.rlLoadVertexBuffer(mesh.texcoords, mesh.vertexCount * 2 * @sizeOf(f32), dynamic); + raylib.rlSetVertexAttribute(TEXCOORDS_VBO_ID, 2, raylib.RL_FLOAT, false, 0, 0); + raylib.rlEnableVertexAttribute(TEXCOORDS_VBO_ID); + + mesh.vboId[TEXCOORDS2_VBO_ID] = raylib.rlLoadVertexBuffer(mesh.texcoords, mesh.vertexCount * 2 * @sizeOf(f32), dynamic); + raylib.rlSetVertexAttribute(TEXCOORDS2_VBO_ID, 2, raylib.RL_FLOAT, false, 0, 0); + raylib.rlEnableVertexAttribute(TEXCOORDS2_VBO_ID); + + mesh.vboId[NORMALS_VBO_ID] = raylib.rlLoadVertexBuffer(mesh.vertices, mesh.vertexCount * 3 * @sizeOf(f32), dynamic); + raylib.rlSetVertexAttribute(NORMALS_VBO_ID, 3, raylib.RL_FLOAT, false, 0, 0); + raylib.rlEnableVertexAttribute(NORMALS_VBO_ID); + + if (mesh.vaoId > 0) { + raylib.TraceLog(raylib.LOG_INFO, "VAO: [ID %i] Chunk mesh uploaded successfully to VRAM (GPU)", mesh.vaoId); + } else { + raylib.TraceLog(raylib.LOG_INFO, "VBO: Chunk mesh uploaded successfully to VRAM (GPU)"); + } + raylib.rlDisableVertexArray(); +} +pub fn UpdateMeshBuffer(mesh: ChunkMesh, index: i32, data: ?*const anyopaque, dataSize: i32, offset: i32) void { + raylib.rlUpdateVertexBuffer(mesh.vboId[index], data, dataSize, offset); +} +pub export fn UnloadMesh(mesh: ChunkMesh) void { + raylib.rlUnloadVertexArray(mesh.vaoId); + if (mesh.vboId != null) { + for (0..MAX_VBOS) |i| { + raylib.rlUnloadVertexBuffer(mesh.vboId[i]); + } + } + raylib.MemFree(mesh.vboId); + + raylib.MemFree(mesh.vertices); + raylib.MemFree(mesh.texcoords); + raylib.MemFree(mesh.texcoords2); + raylib.MemFree(mesh.normals); +} +pub fn DrawMesh(mesh: ChunkMesh, material: raylib.Material, transform: raylib.Matrix) void { + raylib.rlEnableShader(material.shader.id); + if (material.shader.locs[raylib.SHADER_LOC_COLOR_DIFFUSE] != -1) { + const values: [4]f32 = [4]f32{ + @as(u32, @floatFromInt(material.maps[raylib.MATERIAL_MAP_DIFFUSE].color.r)) / 255.0, + @as(u32, @floatFromInt(material.maps[raylib.MATERIAL_MAP_DIFFUSE].color.g)) / 255.0, + @as(u32, @floatFromInt(material.maps[raylib.MATERIAL_MAP_DIFFUSE].color.b)) / 255.0, + @as(u32, @floatFromInt(material.maps[raylib.MATERIAL_MAP_DIFFUSE].color.a)) / 255.0, + }; + raylib.rlSetUniform(material.shader.locs[raylib.SHADER_LOC_COLOR_DIFFUSE], values, raylib.SHADER_UNIFORM_VEC4, 1); + } + if (material.shader.locs[raylib.SHADER_LOC_COLOR_SPECULAR] != -1) { + const values: [4]f32 = [4]f32{ + @as(u32, @floatFromInt(material.maps[raylib.MATERIAL_MAP_SPECULAR].color.r)) / 255.0, + @as(u32, @floatFromInt(material.maps[raylib.MATERIAL_MAP_SPECULAR].color.g)) / 255.0, + @as(u32, @floatFromInt(material.maps[raylib.MATERIAL_MAP_SPECULAR].color.b)) / 255.0, + @as(u32, @floatFromInt(material.maps[raylib.MATERIAL_MAP_SPECULAR].color.a)) / 255.0, + }; + raylib.rlSetUniform(material.shader.locs[raylib.SHADER_LOC_COLOR_SPECULAR], values, raylib.SHADER_UNIFORM_VEC4, 1); + } + + var matModel: raylib.Matrix = raylib.MatrixIdentity(); + const matView: raylib.Matrix = raylib.rlGetMatrixModelview(); + var matModelView: raylib.Matrix = raylib.MatrixIdentity(); + const matProjection: raylib.Matrix = raylib.rlGetMatrixProjection(); + + if (material.shader.locs[raylib.SHADER_LOC_MATRIX_VIEW] != -1) raylib.rlSetUniformMatrix(material.shader.locs[raylib.SHADER_LOC_MATRIX_VIEW], matView); + if (material.shader.locs[raylib.SHADER_LOC_MATRIX_PROJECTION] != -1) raylib.rlSetUniformMatrix(material.shader.locs[raylib.SHADER_LOC_MATRIX_PROJECTION], matProjection); + + matModel = raylib.MatrixMultiply(transform, raylib.rlGetMatrixTransform()); + if (material.shader.locs[raylib.SHADER_LOC_MATRIX_MODEL] != -1) raylib.rlSetUniformMatrix(material.shader.locs[raylib.SHADER_LOC_MATRIX_MODEL], matModel); + + matModelView = raylib.MatrixMultiply(matModel, matView); + if (material.shader.locs[raylib.SHADER_LOC_MATRIX_NORMAL] != -1) raylib.rlSetUniformMatrix(material.shader.locs[raylib.SHADER_LOC_MATRIX_NORMAL], raylib.MatrixTranspose(raylib.MatrixInvert(matModel))); + + for (0..raylib.MAX_MATERIAL_MAPS) |i| { + if (material.maps[i].texture.id > 0) { + raylib.rlActiveTextureSlot(i); + if (i == raylib.MATERIAL_MAP_IRRADIANCE or i == raylib.MATERIAL_MAP_PREFILTER or i == raylib.MATERIAL_MAP_CUBEMAP) { + raylib.rlEnableTextureCubemap(material.maps[i].texture.id); + } else { + raylib.rlEnableTexture(material.maps[i].texture.id); + } + raylib.rlSetUniform(material.shader.locs[raylib.SHADER_LOC_MAP_DIFFUSE + i], &i, raylib.SHADER_UNIFORM_INT, 1); + } + } + + if (!raylib.rlEnableVertexArray(mesh.vaoId)) { + raylib.rlEnableVertexBuffer(mesh.vboId[0]); + raylib.rlSetVertexAttribute(material.shader.locs[VERTICES_VBO_ID], 3, raylib.RL_FLOAT, 0, 0, 0); + raylib.rlEnableVertexAttribute(material.shader.locs[VERTICES_VBO_ID]); + + raylib.rlEnableVertexBuffer(mesh.vboId[1]); + raylib.rlSetVertexAttribute(material.shader.locs[TEXCOORDS_VBO_ID], 2, raylib.RL_FLOAT, 0, 0, 0); + raylib.rlEnableVertexAttribute(material.shader.locs[TEXCOORDS_VBO_ID]); + + raylib.rlEnableVertexBuffer(mesh.vboId[2]); + raylib.rlSetVertexAttribute(material.shader.locs[TEXCOORDS2_VBO_ID], 2, raylib.RL_FLOAT, 0, 0, 0); + raylib.rlEnableVertexAttribute(material.shader.locs[TEXCOORDS2_VBO_ID]); + + raylib.rlEnableVertexBuffer(mesh.vboId[3]); + raylib.rlSetVertexAttribute(material.shader.locs[NORMALS_VBO_ID], 3, raylib.RL_FLOAT, 0, 0, 0); + raylib.rlEnableVertexAttribute(material.shader.locs[NORMALS_VBO_ID]); + } + var eyeCount = 1; + if (raylib.rlIsStereoRenderEnabled()) { + eyeCount = 2; + } + for (0..eyeCount) |eye| { + var matModelViewProjection: raylib.Matrix = raylib.MatrixIdentity(); + if (eyeCount == 1) { + matModelViewProjection = raylib.MatrixMultiply(matModelView, matProjection); + } else { + raylib.rlViewport(@divTrunc(eye * raylib.rlGetFramebufferWidth(), 2), 0, @divTrunc(raylib.rlGetFramebufferWidth(), 2), raylib.rlGetFramebufferHeight()); + matModelViewProjection = raylib.MatrixMultiply(raylib.MatrixMultiply(matModelView, raylib.rlGetMatrixViewOffsetStereo(eye)), raylib.rlGetMatrixProjectionStereo(eye)); + } + raylib.rlSetUniformMatrix(material.shader.locs[raylib.SHADER_LOC_MATRIX_MVP], matModelViewProjection); + raylib.rlDrawVertexArray(0, mesh.vertexCount); + } + for (0..raylib.MAX_MATERIAL_MAPS) |i| { + if (material.maps[i].texture.id > 0) { + raylib.rlActiveTextureSlot(i); + if (((i == raylib.MATERIAL_MAP_IRRADIANCE) or (i == raylib.MATERIAL_MAP_PREFILTER)) or (i == raylib.MATERIAL_MAP_CUBEMAP)) { + raylib.rlDisableTextureCubemap(); + } else { + raylib.rlDisableTexture(); + } + } + } + raylib.rlDisableVertexArray(); + raylib.rlDisableVertexBuffer(); + raylib.rlDisableVertexBufferElement(); + raylib.rlDisableShader(); + raylib.rlSetMatrixModelview(matView); + raylib.rlSetMatrixProjection(matProjection); +} diff --git a/src/rendering/chunk_models.c b/src/rendering/chunk_models.c new file mode 100644 index 0000000..5fb5124 --- /dev/null +++ b/src/rendering/chunk_models.c @@ -0,0 +1,6648 @@ +/********************************************************************************************** +* +* rmodels - Basic functions to draw 3d shapes and load and draw 3d models +* +* CONFIGURATION: +* #define SUPPORT_MODULE_RMODELS +* rmodels module is included in the build +* +* #define SUPPORT_FILEFORMAT_OBJ +* #define SUPPORT_FILEFORMAT_MTL +* #define SUPPORT_FILEFORMAT_IQM +* #define SUPPORT_FILEFORMAT_GLTF +* #define SUPPORT_FILEFORMAT_VOX +* #define SUPPORT_FILEFORMAT_M3D +* Selected desired fileformats to be supported for model data loading. +* +* #define SUPPORT_MESH_GENERATION +* Support procedural mesh generation functions, uses external par_shapes.h library +* NOTE: Some generated meshes DO NOT include generated texture coordinates +* +* +* LICENSE: zlib/libpng +* +* Copyright (c) 2013-2024 Ramon Santamaria (@raysan5) +* +* This software is provided "as-is", without any express or implied warranty. In no event +* will the authors be held liable for any damages arising from the use of this software. +* +* Permission is granted to anyone to use this software for any purpose, including commercial +* applications, and to alter it and redistribute it freely, subject to the following restrictions: +* +* 1. The origin of this software must not be misrepresented; you must not claim that you +* wrote the original software. If you use this software in a product, an acknowledgment +* in the product documentation would be appreciated but is not required. +* +* 2. Altered source versions must be plainly marked as such, and must not be misrepresented +* as being the original software. +* +* 3. This notice may not be removed or altered from any source distribution. +* +**********************************************************************************************/ + +#include "raylib.h" // Declares module functions + +// Check if config flags have been externally provided on compilation line +#if !defined(EXTERNAL_CONFIG_FLAGS) + #include "config.h" // Defines module configuration flags +#endif + +#if defined(SUPPORT_MODULE_RMODELS) + +#include "utils.h" // Required for: TRACELOG(), LoadFileData(), LoadFileText(), SaveFileText() +#include "rlgl.h" // OpenGL abstraction layer to OpenGL 1.1, 2.1, 3.3+ or ES2 +#include "raymath.h" // Required for: Vector3, Quaternion and Matrix functionality + +#include // Required for: sprintf() +#include // Required for: malloc(), calloc(), free() +#include // Required for: memcmp(), strlen(), strncpy() +#include // Required for: sinf(), cosf(), sqrtf(), fabsf() + +#if defined(SUPPORT_FILEFORMAT_OBJ) || defined(SUPPORT_FILEFORMAT_MTL) + #define TINYOBJ_MALLOC RL_MALLOC + #define TINYOBJ_CALLOC RL_CALLOC + #define TINYOBJ_REALLOC RL_REALLOC + #define TINYOBJ_FREE RL_FREE + + #define TINYOBJ_LOADER_C_IMPLEMENTATION + #include "external/tinyobj_loader_c.h" // OBJ/MTL file formats loading +#endif + +#if defined(SUPPORT_FILEFORMAT_GLTF) + #define CGLTF_MALLOC RL_MALLOC + #define CGLTF_FREE RL_FREE + + #define CGLTF_IMPLEMENTATION + #include "external/cgltf.h" // glTF file format loading +#endif + +#if defined(SUPPORT_FILEFORMAT_VOX) + #define VOX_MALLOC RL_MALLOC + #define VOX_CALLOC RL_CALLOC + #define VOX_REALLOC RL_REALLOC + #define VOX_FREE RL_FREE + + #define VOX_LOADER_IMPLEMENTATION + #include "external/vox_loader.h" // VOX file format loading (MagikaVoxel) +#endif + +#if defined(SUPPORT_FILEFORMAT_M3D) + #define M3D_MALLOC RL_MALLOC + #define M3D_REALLOC RL_REALLOC + #define M3D_FREE RL_FREE + + #define M3D_IMPLEMENTATION + #include "external/m3d.h" // Model3D file format loading +#endif + +#if defined(SUPPORT_MESH_GENERATION) + #define PAR_MALLOC(T, N) ((T*)RL_MALLOC(N*sizeof(T))) + #define PAR_CALLOC(T, N) ((T*)RL_CALLOC(N*sizeof(T), 1)) + #define PAR_REALLOC(T, BUF, N) ((T*)RL_REALLOC(BUF, sizeof(T)*(N))) + #define PAR_FREE RL_FREE + + #if defined(_MSC_VER) // Disable some MSVC warning + #pragma warning(push) + #pragma warning(disable : 4244) + #pragma warning(disable : 4305) + #endif + + #define PAR_SHAPES_IMPLEMENTATION + #include "external/par_shapes.h" // Shapes 3d parametric generation + + #if defined(_MSC_VER) + #pragma warning(pop) // Disable MSVC warning suppression + #endif +#endif + +#if defined(_WIN32) + #include // Required for: _chdir() [Used in LoadOBJ()] + #define CHDIR _chdir +#else + #include // Required for: chdir() (POSIX) [Used in LoadOBJ()] + #define CHDIR chdir +#endif + +//---------------------------------------------------------------------------------- +// Defines and Macros +//---------------------------------------------------------------------------------- +#ifndef MAX_MATERIAL_MAPS + #define MAX_MATERIAL_MAPS 12 // Maximum number of maps supported +#endif +#ifndef MAX_MESH_VERTEX_BUFFERS + #define MAX_MESH_VERTEX_BUFFERS 7 // Maximum vertex buffers (VBO) per mesh +#endif + +//---------------------------------------------------------------------------------- +// Types and Structures Definition +//---------------------------------------------------------------------------------- +// ... + +//---------------------------------------------------------------------------------- +// Global Variables Definition +//---------------------------------------------------------------------------------- +// ... + +//---------------------------------------------------------------------------------- +// Module specific Functions Declaration +//---------------------------------------------------------------------------------- +#if defined(SUPPORT_FILEFORMAT_OBJ) +static Model LoadOBJ(const char *fileName); // Load OBJ mesh data +#endif +#if defined(SUPPORT_FILEFORMAT_IQM) +static Model LoadIQM(const char *fileName); // Load IQM mesh data +static ModelAnimation *LoadModelAnimationsIQM(const char *fileName, int *animCount); // Load IQM animation data +#endif +#if defined(SUPPORT_FILEFORMAT_GLTF) +static Model LoadGLTF(const char *fileName); // Load GLTF mesh data +static ModelAnimation *LoadModelAnimationsGLTF(const char *fileName, int *animCount); // Load GLTF animation data +#endif +#if defined(SUPPORT_FILEFORMAT_VOX) +static Model LoadVOX(const char *filename); // Load VOX mesh data +#endif +#if defined(SUPPORT_FILEFORMAT_M3D) +static Model LoadM3D(const char *filename); // Load M3D mesh data +static ModelAnimation *LoadModelAnimationsM3D(const char *fileName, int *animCount); // Load M3D animation data +#endif +#if defined(SUPPORT_FILEFORMAT_OBJ) || defined(SUPPORT_FILEFORMAT_MTL) +static void ProcessMaterialsOBJ(Material *rayMaterials, tinyobj_material_t *materials, int materialCount); // Process obj materials +#endif + +//---------------------------------------------------------------------------------- +// Module Functions Definition +//---------------------------------------------------------------------------------- + +// Draw a line in 3D world space +void DrawLine3D(Vector3 startPos, Vector3 endPos, Color color) +{ + rlBegin(RL_LINES); + rlColor4ub(color.r, color.g, color.b, color.a); + rlVertex3f(startPos.x, startPos.y, startPos.z); + rlVertex3f(endPos.x, endPos.y, endPos.z); + rlEnd(); +} + +// Draw a point in 3D space, actually a small line +void DrawPoint3D(Vector3 position, Color color) +{ + rlPushMatrix(); + rlTranslatef(position.x, position.y, position.z); + rlBegin(RL_LINES); + rlColor4ub(color.r, color.g, color.b, color.a); + rlVertex3f(0.0f, 0.0f, 0.0f); + rlVertex3f(0.0f, 0.0f, 0.1f); + rlEnd(); + rlPopMatrix(); +} + +// Draw a circle in 3D world space +void DrawCircle3D(Vector3 center, float radius, Vector3 rotationAxis, float rotationAngle, Color color) +{ + rlPushMatrix(); + rlTranslatef(center.x, center.y, center.z); + rlRotatef(rotationAngle, rotationAxis.x, rotationAxis.y, rotationAxis.z); + + rlBegin(RL_LINES); + for (int i = 0; i < 360; i += 10) + { + rlColor4ub(color.r, color.g, color.b, color.a); + + rlVertex3f(sinf(DEG2RAD*i)*radius, cosf(DEG2RAD*i)*radius, 0.0f); + rlVertex3f(sinf(DEG2RAD*(i + 10))*radius, cosf(DEG2RAD*(i + 10))*radius, 0.0f); + } + rlEnd(); + rlPopMatrix(); +} + +// Draw a color-filled triangle (vertex in counter-clockwise order!) +void DrawTriangle3D(Vector3 v1, Vector3 v2, Vector3 v3, Color color) +{ + rlBegin(RL_TRIANGLES); + rlColor4ub(color.r, color.g, color.b, color.a); + rlVertex3f(v1.x, v1.y, v1.z); + rlVertex3f(v2.x, v2.y, v2.z); + rlVertex3f(v3.x, v3.y, v3.z); + rlEnd(); +} + +// Draw a triangle strip defined by points +void DrawTriangleStrip3D(const Vector3 *points, int pointCount, Color color) +{ + if (pointCount < 3) return; // Security check + + rlBegin(RL_TRIANGLES); + rlColor4ub(color.r, color.g, color.b, color.a); + + for (int i = 2; i < pointCount; i++) + { + if ((i%2) == 0) + { + rlVertex3f(points[i].x, points[i].y, points[i].z); + rlVertex3f(points[i - 2].x, points[i - 2].y, points[i - 2].z); + rlVertex3f(points[i - 1].x, points[i - 1].y, points[i - 1].z); + } + else + { + rlVertex3f(points[i].x, points[i].y, points[i].z); + rlVertex3f(points[i - 1].x, points[i - 1].y, points[i - 1].z); + rlVertex3f(points[i - 2].x, points[i - 2].y, points[i - 2].z); + } + } + rlEnd(); +} + +// Draw cube +// NOTE: Cube position is the center position +void DrawCube(Vector3 position, float width, float height, float length, Color color) +{ + float x = 0.0f; + float y = 0.0f; + float z = 0.0f; + + rlPushMatrix(); + // NOTE: Transformation is applied in inverse order (scale -> rotate -> translate) + rlTranslatef(position.x, position.y, position.z); + //rlRotatef(45, 0, 1, 0); + //rlScalef(1.0f, 1.0f, 1.0f); // NOTE: Vertices are directly scaled on definition + + rlBegin(RL_TRIANGLES); + rlColor4ub(color.r, color.g, color.b, color.a); + + // Front face + rlNormal3f(0.0f, 0.0f, 1.0f); + rlVertex3f(x - width/2, y - height/2, z + length/2); // Bottom Left + rlVertex3f(x + width/2, y - height/2, z + length/2); // Bottom Right + rlVertex3f(x - width/2, y + height/2, z + length/2); // Top Left + + rlVertex3f(x + width/2, y + height/2, z + length/2); // Top Right + rlVertex3f(x - width/2, y + height/2, z + length/2); // Top Left + rlVertex3f(x + width/2, y - height/2, z + length/2); // Bottom Right + + // Back face + rlNormal3f(0.0f, 0.0f, -1.0f); + rlVertex3f(x - width/2, y - height/2, z - length/2); // Bottom Left + rlVertex3f(x - width/2, y + height/2, z - length/2); // Top Left + rlVertex3f(x + width/2, y - height/2, z - length/2); // Bottom Right + + rlVertex3f(x + width/2, y + height/2, z - length/2); // Top Right + rlVertex3f(x + width/2, y - height/2, z - length/2); // Bottom Right + rlVertex3f(x - width/2, y + height/2, z - length/2); // Top Left + + // Top face + rlNormal3f(0.0f, 1.0f, 0.0f); + rlVertex3f(x - width/2, y + height/2, z - length/2); // Top Left + rlVertex3f(x - width/2, y + height/2, z + length/2); // Bottom Left + rlVertex3f(x + width/2, y + height/2, z + length/2); // Bottom Right + + rlVertex3f(x + width/2, y + height/2, z - length/2); // Top Right + rlVertex3f(x - width/2, y + height/2, z - length/2); // Top Left + rlVertex3f(x + width/2, y + height/2, z + length/2); // Bottom Right + + // Bottom face + rlNormal3f(0.0f, -1.0f, 0.0f); + rlVertex3f(x - width/2, y - height/2, z - length/2); // Top Left + rlVertex3f(x + width/2, y - height/2, z + length/2); // Bottom Right + rlVertex3f(x - width/2, y - height/2, z + length/2); // Bottom Left + + rlVertex3f(x + width/2, y - height/2, z - length/2); // Top Right + rlVertex3f(x + width/2, y - height/2, z + length/2); // Bottom Right + rlVertex3f(x - width/2, y - height/2, z - length/2); // Top Left + + // Right face + rlNormal3f(1.0f, 0.0f, 0.0f); + rlVertex3f(x + width/2, y - height/2, z - length/2); // Bottom Right + rlVertex3f(x + width/2, y + height/2, z - length/2); // Top Right + rlVertex3f(x + width/2, y + height/2, z + length/2); // Top Left + + rlVertex3f(x + width/2, y - height/2, z + length/2); // Bottom Left + rlVertex3f(x + width/2, y - height/2, z - length/2); // Bottom Right + rlVertex3f(x + width/2, y + height/2, z + length/2); // Top Left + + // Left face + rlNormal3f(-1.0f, 0.0f, 0.0f); + rlVertex3f(x - width/2, y - height/2, z - length/2); // Bottom Right + rlVertex3f(x - width/2, y + height/2, z + length/2); // Top Left + rlVertex3f(x - width/2, y + height/2, z - length/2); // Top Right + + rlVertex3f(x - width/2, y - height/2, z + length/2); // Bottom Left + rlVertex3f(x - width/2, y + height/2, z + length/2); // Top Left + rlVertex3f(x - width/2, y - height/2, z - length/2); // Bottom Right + rlEnd(); + rlPopMatrix(); +} + +// Draw cube (Vector version) +void DrawCubeV(Vector3 position, Vector3 size, Color color) +{ + DrawCube(position, size.x, size.y, size.z, color); +} + +// Draw cube wires +void DrawCubeWires(Vector3 position, float width, float height, float length, Color color) +{ + float x = 0.0f; + float y = 0.0f; + float z = 0.0f; + + rlPushMatrix(); + rlTranslatef(position.x, position.y, position.z); + + rlBegin(RL_LINES); + rlColor4ub(color.r, color.g, color.b, color.a); + + // Front face + //------------------------------------------------------------------ + // Bottom line + rlVertex3f(x - width/2, y - height/2, z + length/2); // Bottom left + rlVertex3f(x + width/2, y - height/2, z + length/2); // Bottom right + + // Left line + rlVertex3f(x + width/2, y - height/2, z + length/2); // Bottom right + rlVertex3f(x + width/2, y + height/2, z + length/2); // Top right + + // Top line + rlVertex3f(x + width/2, y + height/2, z + length/2); // Top right + rlVertex3f(x - width/2, y + height/2, z + length/2); // Top left + + // Right line + rlVertex3f(x - width/2, y + height/2, z + length/2); // Top left + rlVertex3f(x - width/2, y - height/2, z + length/2); // Bottom left + + // Back face + //------------------------------------------------------------------ + // Bottom line + rlVertex3f(x - width/2, y - height/2, z - length/2); // Bottom left + rlVertex3f(x + width/2, y - height/2, z - length/2); // Bottom right + + // Left line + rlVertex3f(x + width/2, y - height/2, z - length/2); // Bottom right + rlVertex3f(x + width/2, y + height/2, z - length/2); // Top right + + // Top line + rlVertex3f(x + width/2, y + height/2, z - length/2); // Top right + rlVertex3f(x - width/2, y + height/2, z - length/2); // Top left + + // Right line + rlVertex3f(x - width/2, y + height/2, z - length/2); // Top left + rlVertex3f(x - width/2, y - height/2, z - length/2); // Bottom left + + // Top face + //------------------------------------------------------------------ + // Left line + rlVertex3f(x - width/2, y + height/2, z + length/2); // Top left front + rlVertex3f(x - width/2, y + height/2, z - length/2); // Top left back + + // Right line + rlVertex3f(x + width/2, y + height/2, z + length/2); // Top right front + rlVertex3f(x + width/2, y + height/2, z - length/2); // Top right back + + // Bottom face + //------------------------------------------------------------------ + // Left line + rlVertex3f(x - width/2, y - height/2, z + length/2); // Top left front + rlVertex3f(x - width/2, y - height/2, z - length/2); // Top left back + + // Right line + rlVertex3f(x + width/2, y - height/2, z + length/2); // Top right front + rlVertex3f(x + width/2, y - height/2, z - length/2); // Top right back + rlEnd(); + rlPopMatrix(); +} + +// Draw cube wires (vector version) +void DrawCubeWiresV(Vector3 position, Vector3 size, Color color) +{ + DrawCubeWires(position, size.x, size.y, size.z, color); +} + +// Draw sphere +void DrawSphere(Vector3 centerPos, float radius, Color color) +{ + DrawSphereEx(centerPos, radius, 16, 16, color); +} + +// Draw sphere with extended parameters +void DrawSphereEx(Vector3 centerPos, float radius, int rings, int slices, Color color) +{ +#if 0 + // Basic implementation, do not use it! + // For a sphere with 16 rings and 16 slices it requires 8640 cos()/sin() function calls! + // New optimized version below only requires 4 cos()/sin() calls + + rlPushMatrix(); + // NOTE: Transformation is applied in inverse order (scale -> translate) + rlTranslatef(centerPos.x, centerPos.y, centerPos.z); + rlScalef(radius, radius, radius); + + rlBegin(RL_TRIANGLES); + rlColor4ub(color.r, color.g, color.b, color.a); + + for (int i = 0; i < (rings + 2); i++) + { + for (int j = 0; j < slices; j++) + { + rlVertex3f(cosf(DEG2RAD*(270 + (180.0f/(rings + 1))*i))*sinf(DEG2RAD*(360.0f*j/slices)), + sinf(DEG2RAD*(270 + (180.0f/(rings + 1))*i)), + cosf(DEG2RAD*(270 + (180.0f/(rings + 1))*i))*cosf(DEG2RAD*(360.0f*j/slices))); + rlVertex3f(cosf(DEG2RAD*(270 + (180.0f/(rings + 1))*(i + 1)))*sinf(DEG2RAD*(360.0f*(j + 1)/slices)), + sinf(DEG2RAD*(270 + (180.0f/(rings + 1))*(i + 1))), + cosf(DEG2RAD*(270 + (180.0f/(rings + 1))*(i + 1)))*cosf(DEG2RAD*(360.0f*(j + 1)/slices))); + rlVertex3f(cosf(DEG2RAD*(270 + (180.0f/(rings + 1))*(i + 1)))*sinf(DEG2RAD*(360.0f*j/slices)), + sinf(DEG2RAD*(270 + (180.0f/(rings + 1))*(i + 1))), + cosf(DEG2RAD*(270 + (180.0f/(rings + 1))*(i + 1)))*cosf(DEG2RAD*(360.0f*j/slices))); + + rlVertex3f(cosf(DEG2RAD*(270 + (180.0f/(rings + 1))*i))*sinf(DEG2RAD*(360.0f*j/slices)), + sinf(DEG2RAD*(270 + (180.0f/(rings + 1))*i)), + cosf(DEG2RAD*(270 + (180.0f/(rings + 1))*i))*cosf(DEG2RAD*(360.0f*j/slices))); + rlVertex3f(cosf(DEG2RAD*(270 + (180.0f/(rings + 1))*(i)))*sinf(DEG2RAD*(360.0f*(j + 1)/slices)), + sinf(DEG2RAD*(270 + (180.0f/(rings + 1))*(i))), + cosf(DEG2RAD*(270 + (180.0f/(rings + 1))*(i)))*cosf(DEG2RAD*(360.0f*(j + 1)/slices))); + rlVertex3f(cosf(DEG2RAD*(270 + (180.0f/(rings + 1))*(i + 1)))*sinf(DEG2RAD*(360.0f*(j + 1)/slices)), + sinf(DEG2RAD*(270 + (180.0f/(rings + 1))*(i + 1))), + cosf(DEG2RAD*(270 + (180.0f/(rings + 1))*(i + 1)))*cosf(DEG2RAD*(360.0f*(j + 1)/slices))); + } + } + rlEnd(); + rlPopMatrix(); +#endif + + rlPushMatrix(); + // NOTE: Transformation is applied in inverse order (scale -> translate) + rlTranslatef(centerPos.x, centerPos.y, centerPos.z); + rlScalef(radius, radius, radius); + + rlBegin(RL_TRIANGLES); + rlColor4ub(color.r, color.g, color.b, color.a); + + float ringangle = DEG2RAD*(180.0f/(rings + 1)); // Angle between latitudinal parallels + float sliceangle = DEG2RAD*(360.0f/slices); // Angle between longitudinal meridians + + float cosring = cosf(ringangle); + float sinring = sinf(ringangle); + float cosslice = cosf(sliceangle); + float sinslice = sinf(sliceangle); + + Vector3 vertices[4] = { 0 }; // Required to store face vertices + vertices[2] = (Vector3){ 0, 1, 0 }; + vertices[3] = (Vector3){ sinring, cosring, 0 }; + + for (int i = 0; i < rings + 1; i++) + { + for (int j = 0; j < slices; j++) + { + vertices[0] = vertices[2]; // Rotate around y axis to set up vertices for next face + vertices[1] = vertices[3]; + vertices[2] = (Vector3){ cosslice*vertices[2].x - sinslice*vertices[2].z, vertices[2].y, sinslice*vertices[2].x + cosslice*vertices[2].z }; // Rotation matrix around y axis + vertices[3] = (Vector3){ cosslice*vertices[3].x - sinslice*vertices[3].z, vertices[3].y, sinslice*vertices[3].x + cosslice*vertices[3].z }; + + rlVertex3f(vertices[0].x, vertices[0].y, vertices[0].z); + rlVertex3f(vertices[3].x, vertices[3].y, vertices[3].z); + rlVertex3f(vertices[1].x, vertices[1].y, vertices[1].z); + + rlVertex3f(vertices[0].x, vertices[0].y, vertices[0].z); + rlVertex3f(vertices[2].x, vertices[2].y, vertices[2].z); + rlVertex3f(vertices[3].x, vertices[3].y, vertices[3].z); + } + + vertices[2] = vertices[3]; // Rotate around z axis to set up starting vertices for next ring + vertices[3] = (Vector3){ cosring*vertices[3].x + sinring*vertices[3].y, -sinring*vertices[3].x + cosring*vertices[3].y, vertices[3].z }; // Rotation matrix around z axis + } + rlEnd(); + rlPopMatrix(); +} + +// Draw sphere wires +void DrawSphereWires(Vector3 centerPos, float radius, int rings, int slices, Color color) +{ + rlPushMatrix(); + // NOTE: Transformation is applied in inverse order (scale -> translate) + rlTranslatef(centerPos.x, centerPos.y, centerPos.z); + rlScalef(radius, radius, radius); + + rlBegin(RL_LINES); + rlColor4ub(color.r, color.g, color.b, color.a); + + for (int i = 0; i < (rings + 2); i++) + { + for (int j = 0; j < slices; j++) + { + rlVertex3f(cosf(DEG2RAD*(270 + (180.0f/(rings + 1))*i))*sinf(DEG2RAD*(360.0f*j/slices)), + sinf(DEG2RAD*(270 + (180.0f/(rings + 1))*i)), + cosf(DEG2RAD*(270 + (180.0f/(rings + 1))*i))*cosf(DEG2RAD*(360.0f*j/slices))); + rlVertex3f(cosf(DEG2RAD*(270 + (180.0f/(rings + 1))*(i + 1)))*sinf(DEG2RAD*(360.0f*(j + 1)/slices)), + sinf(DEG2RAD*(270 + (180.0f/(rings + 1))*(i + 1))), + cosf(DEG2RAD*(270 + (180.0f/(rings + 1))*(i + 1)))*cosf(DEG2RAD*(360.0f*(j + 1)/slices))); + + rlVertex3f(cosf(DEG2RAD*(270 + (180.0f/(rings + 1))*(i + 1)))*sinf(DEG2RAD*(360.0f*(j + 1)/slices)), + sinf(DEG2RAD*(270 + (180.0f/(rings + 1))*(i + 1))), + cosf(DEG2RAD*(270 + (180.0f/(rings + 1))*(i + 1)))*cosf(DEG2RAD*(360.0f*(j + 1)/slices))); + rlVertex3f(cosf(DEG2RAD*(270 + (180.0f/(rings + 1))*(i + 1)))*sinf(DEG2RAD*(360.0f*j/slices)), + sinf(DEG2RAD*(270 + (180.0f/(rings + 1))*(i + 1))), + cosf(DEG2RAD*(270 + (180.0f/(rings + 1))*(i + 1)))*cosf(DEG2RAD*(360.0f*j/slices))); + + rlVertex3f(cosf(DEG2RAD*(270 + (180.0f/(rings + 1))*(i + 1)))*sinf(DEG2RAD*(360.0f*j/slices)), + sinf(DEG2RAD*(270 + (180.0f/(rings + 1))*(i + 1))), + cosf(DEG2RAD*(270 + (180.0f/(rings + 1))*(i + 1)))*cosf(DEG2RAD*(360.0f*j/slices))); + rlVertex3f(cosf(DEG2RAD*(270 + (180.0f/(rings + 1))*i))*sinf(DEG2RAD*(360.0f*j/slices)), + sinf(DEG2RAD*(270 + (180.0f/(rings + 1))*i)), + cosf(DEG2RAD*(270 + (180.0f/(rings + 1))*i))*cosf(DEG2RAD*(360.0f*j/slices))); + } + } + rlEnd(); + rlPopMatrix(); +} + +// Draw a cylinder +// NOTE: It could be also used for pyramid and cone +void DrawCylinder(Vector3 position, float radiusTop, float radiusBottom, float height, int sides, Color color) +{ + if (sides < 3) sides = 3; + + const float angleStep = 360.0f/sides; + + rlPushMatrix(); + rlTranslatef(position.x, position.y, position.z); + + rlBegin(RL_TRIANGLES); + rlColor4ub(color.r, color.g, color.b, color.a); + + if (radiusTop > 0) + { + // Draw Body ------------------------------------------------------------------------------------- + for (int i = 0; i < sides; i++) + { + rlVertex3f(sinf(DEG2RAD*i*angleStep)*radiusBottom, 0, cosf(DEG2RAD*i*angleStep)*radiusBottom); //Bottom Left + rlVertex3f(sinf(DEG2RAD*(i+1)*angleStep)*radiusBottom, 0, cosf(DEG2RAD*(i+1)*angleStep)*radiusBottom); //Bottom Right + rlVertex3f(sinf(DEG2RAD*(i+1)*angleStep)*radiusTop, height, cosf(DEG2RAD*(i+1)*angleStep)*radiusTop); //Top Right + + rlVertex3f(sinf(DEG2RAD*i*angleStep)*radiusTop, height, cosf(DEG2RAD*i*angleStep)*radiusTop); //Top Left + rlVertex3f(sinf(DEG2RAD*i*angleStep)*radiusBottom, 0, cosf(DEG2RAD*i*angleStep)*radiusBottom); //Bottom Left + rlVertex3f(sinf(DEG2RAD*(i+1)*angleStep)*radiusTop, height, cosf(DEG2RAD*(i+1)*angleStep)*radiusTop); //Top Right + } + + // Draw Cap -------------------------------------------------------------------------------------- + for (int i = 0; i < sides; i++) + { + rlVertex3f(0, height, 0); + rlVertex3f(sinf(DEG2RAD*i*angleStep)*radiusTop, height, cosf(DEG2RAD*i*angleStep)*radiusTop); + rlVertex3f(sinf(DEG2RAD*(i+1)*angleStep)*radiusTop, height, cosf(DEG2RAD*(i+1)*angleStep)*radiusTop); + } + } + else + { + // Draw Cone ------------------------------------------------------------------------------------- + for (int i = 0; i < sides; i++) + { + rlVertex3f(0, height, 0); + rlVertex3f(sinf(DEG2RAD*i*angleStep)*radiusBottom, 0, cosf(DEG2RAD*i*angleStep)*radiusBottom); + rlVertex3f(sinf(DEG2RAD*(i+1)*angleStep)*radiusBottom, 0, cosf(DEG2RAD*(i+1)*angleStep)*radiusBottom); + } + } + + // Draw Base ----------------------------------------------------------------------------------------- + for (int i = 0; i < sides; i++) + { + rlVertex3f(0, 0, 0); + rlVertex3f(sinf(DEG2RAD*i*angleStep)*radiusBottom, 0, cosf(DEG2RAD*(i+1)*angleStep)*radiusBottom); + rlVertex3f(sinf(DEG2RAD*i*angleStep)*radiusBottom, 0, cosf(DEG2RAD*i*angleStep)*radiusBottom); + } + + rlEnd(); + rlPopMatrix(); +} + +// Draw a cylinder with base at startPos and top at endPos +// NOTE: It could be also used for pyramid and cone +void DrawCylinderEx(Vector3 startPos, Vector3 endPos, float startRadius, float endRadius, int sides, Color color) +{ + if (sides < 3) sides = 3; + + Vector3 direction = { endPos.x - startPos.x, endPos.y - startPos.y, endPos.z - startPos.z }; + if ((direction.x == 0) && (direction.y == 0) && (direction.z == 0)) return; // Security check + + // Construct a basis of the base and the top face: + Vector3 b1 = Vector3Normalize(Vector3Perpendicular(direction)); + Vector3 b2 = Vector3Normalize(Vector3CrossProduct(b1, direction)); + + float baseAngle = (2.0f*PI)/sides; + + rlBegin(RL_TRIANGLES); + rlColor4ub(color.r, color.g, color.b, color.a); + + for (int i = 0; i < sides; i++) + { + // Compute the four vertices + float s1 = sinf(baseAngle*(i + 0))*startRadius; + float c1 = cosf(baseAngle*(i + 0))*startRadius; + Vector3 w1 = { startPos.x + s1*b1.x + c1*b2.x, startPos.y + s1*b1.y + c1*b2.y, startPos.z + s1*b1.z + c1*b2.z }; + float s2 = sinf(baseAngle*(i + 1))*startRadius; + float c2 = cosf(baseAngle*(i + 1))*startRadius; + Vector3 w2 = { startPos.x + s2*b1.x + c2*b2.x, startPos.y + s2*b1.y + c2*b2.y, startPos.z + s2*b1.z + c2*b2.z }; + float s3 = sinf(baseAngle*(i + 0))*endRadius; + float c3 = cosf(baseAngle*(i + 0))*endRadius; + Vector3 w3 = { endPos.x + s3*b1.x + c3*b2.x, endPos.y + s3*b1.y + c3*b2.y, endPos.z + s3*b1.z + c3*b2.z }; + float s4 = sinf(baseAngle*(i + 1))*endRadius; + float c4 = cosf(baseAngle*(i + 1))*endRadius; + Vector3 w4 = { endPos.x + s4*b1.x + c4*b2.x, endPos.y + s4*b1.y + c4*b2.y, endPos.z + s4*b1.z + c4*b2.z }; + + if (startRadius > 0) + { + rlVertex3f(startPos.x, startPos.y, startPos.z); // | + rlVertex3f(w2.x, w2.y, w2.z); // T0 + rlVertex3f(w1.x, w1.y, w1.z); // | + } + // w2 x.-----------x startPos + rlVertex3f(w1.x, w1.y, w1.z); // | |\'. T0 / + rlVertex3f(w2.x, w2.y, w2.z); // T1 | \ '. / + rlVertex3f(w3.x, w3.y, w3.z); // | |T \ '. / + // | 2 \ T 'x w1 + rlVertex3f(w2.x, w2.y, w2.z); // | w4 x.---\-1-|---x endPos + rlVertex3f(w4.x, w4.y, w4.z); // T2 '. \ |T3/ + rlVertex3f(w3.x, w3.y, w3.z); // | '. \ | / + // '.\|/ + if (endRadius > 0) // 'x w3 + { + rlVertex3f(endPos.x, endPos.y, endPos.z); // | + rlVertex3f(w3.x, w3.y, w3.z); // T3 + rlVertex3f(w4.x, w4.y, w4.z); // | + } // + } + rlEnd(); +} + +// Draw a wired cylinder +// NOTE: It could be also used for pyramid and cone +void DrawCylinderWires(Vector3 position, float radiusTop, float radiusBottom, float height, int sides, Color color) +{ + if (sides < 3) sides = 3; + + const float angleStep = 360.0f/sides; + + rlPushMatrix(); + rlTranslatef(position.x, position.y, position.z); + + rlBegin(RL_LINES); + rlColor4ub(color.r, color.g, color.b, color.a); + + for (int i = 0; i < sides; i++) + { + rlVertex3f(sinf(DEG2RAD*i*angleStep)*radiusBottom, 0, cosf(DEG2RAD*i*angleStep)*radiusBottom); + rlVertex3f(sinf(DEG2RAD*(i+1)*angleStep)*radiusBottom, 0, cosf(DEG2RAD*(i+1)*angleStep)*radiusBottom); + + rlVertex3f(sinf(DEG2RAD*(i+1)*angleStep)*radiusBottom, 0, cosf(DEG2RAD*(i+1)*angleStep)*radiusBottom); + rlVertex3f(sinf(DEG2RAD*(i+1)*angleStep)*radiusTop, height, cosf(DEG2RAD*(i+1)*angleStep)*radiusTop); + + rlVertex3f(sinf(DEG2RAD*(i+1)*angleStep)*radiusTop, height, cosf(DEG2RAD*(i+1)*angleStep)*radiusTop); + rlVertex3f(sinf(DEG2RAD*i*angleStep)*radiusTop, height, cosf(DEG2RAD*i*angleStep)*radiusTop); + + rlVertex3f(sinf(DEG2RAD*i*angleStep)*radiusTop, height, cosf(DEG2RAD*i*angleStep)*radiusTop); + rlVertex3f(sinf(DEG2RAD*i*angleStep)*radiusBottom, 0, cosf(DEG2RAD*i*angleStep)*radiusBottom); + } + rlEnd(); + rlPopMatrix(); +} + + +// Draw a wired cylinder with base at startPos and top at endPos +// NOTE: It could be also used for pyramid and cone +void DrawCylinderWiresEx(Vector3 startPos, Vector3 endPos, float startRadius, float endRadius, int sides, Color color) +{ + if (sides < 3) sides = 3; + + Vector3 direction = { endPos.x - startPos.x, endPos.y - startPos.y, endPos.z - startPos.z }; + if ((direction.x == 0) && (direction.y == 0) && (direction.z == 0)) return; // Security check + + // Construct a basis of the base and the top face: + Vector3 b1 = Vector3Normalize(Vector3Perpendicular(direction)); + Vector3 b2 = Vector3Normalize(Vector3CrossProduct(b1, direction)); + + float baseAngle = (2.0f*PI)/sides; + + rlBegin(RL_LINES); + rlColor4ub(color.r, color.g, color.b, color.a); + + for (int i = 0; i < sides; i++) + { + // Compute the four vertices + float s1 = sinf(baseAngle*(i + 0))*startRadius; + float c1 = cosf(baseAngle*(i + 0))*startRadius; + Vector3 w1 = { startPos.x + s1*b1.x + c1*b2.x, startPos.y + s1*b1.y + c1*b2.y, startPos.z + s1*b1.z + c1*b2.z }; + float s2 = sinf(baseAngle*(i + 1))*startRadius; + float c2 = cosf(baseAngle*(i + 1))*startRadius; + Vector3 w2 = { startPos.x + s2*b1.x + c2*b2.x, startPos.y + s2*b1.y + c2*b2.y, startPos.z + s2*b1.z + c2*b2.z }; + float s3 = sinf(baseAngle*(i + 0))*endRadius; + float c3 = cosf(baseAngle*(i + 0))*endRadius; + Vector3 w3 = { endPos.x + s3*b1.x + c3*b2.x, endPos.y + s3*b1.y + c3*b2.y, endPos.z + s3*b1.z + c3*b2.z }; + float s4 = sinf(baseAngle*(i + 1))*endRadius; + float c4 = cosf(baseAngle*(i + 1))*endRadius; + Vector3 w4 = { endPos.x + s4*b1.x + c4*b2.x, endPos.y + s4*b1.y + c4*b2.y, endPos.z + s4*b1.z + c4*b2.z }; + + rlVertex3f(w1.x, w1.y, w1.z); + rlVertex3f(w2.x, w2.y, w2.z); + + rlVertex3f(w1.x, w1.y, w1.z); + rlVertex3f(w3.x, w3.y, w3.z); + + rlVertex3f(w3.x, w3.y, w3.z); + rlVertex3f(w4.x, w4.y, w4.z); + } + rlEnd(); +} + +// Draw a capsule with the center of its sphere caps at startPos and endPos +void DrawCapsule(Vector3 startPos, Vector3 endPos, float radius, int slices, int rings, Color color) +{ + if (slices < 3) slices = 3; + + Vector3 direction = { endPos.x - startPos.x, endPos.y - startPos.y, endPos.z - startPos.z }; + + // draw a sphere if start and end points are the same + bool sphereCase = (direction.x == 0) && (direction.y == 0) && (direction.z == 0); + if (sphereCase) direction = (Vector3){0.0f, 1.0f, 0.0f}; + + // Construct a basis of the base and the caps: + Vector3 b0 = Vector3Normalize(direction); + Vector3 b1 = Vector3Normalize(Vector3Perpendicular(direction)); + Vector3 b2 = Vector3Normalize(Vector3CrossProduct(b1, direction)); + Vector3 capCenter = endPos; + + float baseSliceAngle = (2.0f*PI)/slices; + float baseRingAngle = PI*0.5f/rings; + + rlBegin(RL_TRIANGLES); + rlColor4ub(color.r, color.g, color.b, color.a); + + // render both caps + for (int c = 0; c < 2; c++) + { + for (int i = 0; i < rings; i++) + { + for (int j = 0; j < slices; j++) + { + + // we build up the rings from capCenter in the direction of the 'direction' vector we computed earlier + + // as we iterate through the rings they must be placed higher above the center, the height we need is sin(angle(i)) + // as we iterate through the rings they must get smaller by the cos(angle(i)) + + // compute the four vertices + float ringSin1 = sinf(baseSliceAngle*(j + 0))*cosf(baseRingAngle*( i + 0 )); + float ringCos1 = cosf(baseSliceAngle*(j + 0))*cosf(baseRingAngle*( i + 0 )); + Vector3 w1 = (Vector3){ + capCenter.x + (sinf(baseRingAngle*( i + 0 ))*b0.x + ringSin1*b1.x + ringCos1*b2.x)*radius, + capCenter.y + (sinf(baseRingAngle*( i + 0 ))*b0.y + ringSin1*b1.y + ringCos1*b2.y)*radius, + capCenter.z + (sinf(baseRingAngle*( i + 0 ))*b0.z + ringSin1*b1.z + ringCos1*b2.z)*radius + }; + float ringSin2 = sinf(baseSliceAngle*(j + 1))*cosf(baseRingAngle*( i + 0 )); + float ringCos2 = cosf(baseSliceAngle*(j + 1))*cosf(baseRingAngle*( i + 0 )); + Vector3 w2 = (Vector3){ + capCenter.x + (sinf(baseRingAngle*( i + 0 ))*b0.x + ringSin2*b1.x + ringCos2*b2.x)*radius, + capCenter.y + (sinf(baseRingAngle*( i + 0 ))*b0.y + ringSin2*b1.y + ringCos2*b2.y)*radius, + capCenter.z + (sinf(baseRingAngle*( i + 0 ))*b0.z + ringSin2*b1.z + ringCos2*b2.z)*radius + }; + + float ringSin3 = sinf(baseSliceAngle*(j + 0))*cosf(baseRingAngle*( i + 1 )); + float ringCos3 = cosf(baseSliceAngle*(j + 0))*cosf(baseRingAngle*( i + 1 )); + Vector3 w3 = (Vector3){ + capCenter.x + (sinf(baseRingAngle*( i + 1 ))*b0.x + ringSin3*b1.x + ringCos3*b2.x)*radius, + capCenter.y + (sinf(baseRingAngle*( i + 1 ))*b0.y + ringSin3*b1.y + ringCos3*b2.y)*radius, + capCenter.z + (sinf(baseRingAngle*( i + 1 ))*b0.z + ringSin3*b1.z + ringCos3*b2.z)*radius + }; + float ringSin4 = sinf(baseSliceAngle*(j + 1))*cosf(baseRingAngle*( i + 1 )); + float ringCos4 = cosf(baseSliceAngle*(j + 1))*cosf(baseRingAngle*( i + 1 )); + Vector3 w4 = (Vector3){ + capCenter.x + (sinf(baseRingAngle*( i + 1 ))*b0.x + ringSin4*b1.x + ringCos4*b2.x)*radius, + capCenter.y + (sinf(baseRingAngle*( i + 1 ))*b0.y + ringSin4*b1.y + ringCos4*b2.y)*radius, + capCenter.z + (sinf(baseRingAngle*( i + 1 ))*b0.z + ringSin4*b1.z + ringCos4*b2.z)*radius + }; + + // Make sure cap triangle normals are facing outwards + if (c == 0) + { + rlVertex3f(w1.x, w1.y, w1.z); + rlVertex3f(w2.x, w2.y, w2.z); + rlVertex3f(w3.x, w3.y, w3.z); + + rlVertex3f(w2.x, w2.y, w2.z); + rlVertex3f(w4.x, w4.y, w4.z); + rlVertex3f(w3.x, w3.y, w3.z); + } + else + { + rlVertex3f(w1.x, w1.y, w1.z); + rlVertex3f(w3.x, w3.y, w3.z); + rlVertex3f(w2.x, w2.y, w2.z); + + rlVertex3f(w2.x, w2.y, w2.z); + rlVertex3f(w3.x, w3.y, w3.z); + rlVertex3f(w4.x, w4.y, w4.z); + } + } + } + capCenter = startPos; + b0 = Vector3Scale(b0, -1.0f); + } + // render middle + if (!sphereCase) + { + for (int j = 0; j < slices; j++) + { + // compute the four vertices + float ringSin1 = sinf(baseSliceAngle*(j + 0))*radius; + float ringCos1 = cosf(baseSliceAngle*(j + 0))*radius; + Vector3 w1 = { + startPos.x + ringSin1*b1.x + ringCos1*b2.x, + startPos.y + ringSin1*b1.y + ringCos1*b2.y, + startPos.z + ringSin1*b1.z + ringCos1*b2.z + }; + float ringSin2 = sinf(baseSliceAngle*(j + 1))*radius; + float ringCos2 = cosf(baseSliceAngle*(j + 1))*radius; + Vector3 w2 = { + startPos.x + ringSin2*b1.x + ringCos2*b2.x, + startPos.y + ringSin2*b1.y + ringCos2*b2.y, + startPos.z + ringSin2*b1.z + ringCos2*b2.z + }; + + float ringSin3 = sinf(baseSliceAngle*(j + 0))*radius; + float ringCos3 = cosf(baseSliceAngle*(j + 0))*radius; + Vector3 w3 = { + endPos.x + ringSin3*b1.x + ringCos3*b2.x, + endPos.y + ringSin3*b1.y + ringCos3*b2.y, + endPos.z + ringSin3*b1.z + ringCos3*b2.z + }; + float ringSin4 = sinf(baseSliceAngle*(j + 1))*radius; + float ringCos4 = cosf(baseSliceAngle*(j + 1))*radius; + Vector3 w4 = { + endPos.x + ringSin4*b1.x + ringCos4*b2.x, + endPos.y + ringSin4*b1.y + ringCos4*b2.y, + endPos.z + ringSin4*b1.z + ringCos4*b2.z + }; + // w2 x.-----------x startPos + rlVertex3f(w1.x, w1.y, w1.z); // | |\'. T0 / + rlVertex3f(w2.x, w2.y, w2.z); // T1 | \ '. / + rlVertex3f(w3.x, w3.y, w3.z); // | |T \ '. / + // | 2 \ T 'x w1 + rlVertex3f(w2.x, w2.y, w2.z); // | w4 x.---\-1-|---x endPos + rlVertex3f(w4.x, w4.y, w4.z); // T2 '. \ |T3/ + rlVertex3f(w3.x, w3.y, w3.z); // | '. \ | / + // '.\|/ + // 'x w3 + } + } + rlEnd(); +} + +// Draw capsule wires with the center of its sphere caps at startPos and endPos +void DrawCapsuleWires(Vector3 startPos, Vector3 endPos, float radius, int slices, int rings, Color color) +{ + if (slices < 3) slices = 3; + + Vector3 direction = { endPos.x - startPos.x, endPos.y - startPos.y, endPos.z - startPos.z }; + + // draw a sphere if start and end points are the same + bool sphereCase = (direction.x == 0) && (direction.y == 0) && (direction.z == 0); + if (sphereCase) direction = (Vector3){0.0f, 1.0f, 0.0f}; + + // Construct a basis of the base and the caps: + Vector3 b0 = Vector3Normalize(direction); + Vector3 b1 = Vector3Normalize(Vector3Perpendicular(direction)); + Vector3 b2 = Vector3Normalize(Vector3CrossProduct(b1, direction)); + Vector3 capCenter = endPos; + + float baseSliceAngle = (2.0f*PI)/slices; + float baseRingAngle = PI*0.5f/rings; + + rlBegin(RL_LINES); + rlColor4ub(color.r, color.g, color.b, color.a); + + // render both caps + for (int c = 0; c < 2; c++) + { + for (int i = 0; i < rings; i++) + { + for (int j = 0; j < slices; j++) + { + + // we build up the rings from capCenter in the direction of the 'direction' vector we computed earlier + + // as we iterate through the rings they must be placed higher above the center, the height we need is sin(angle(i)) + // as we iterate through the rings they must get smaller by the cos(angle(i)) + + // compute the four vertices + float ringSin1 = sinf(baseSliceAngle*(j + 0))*cosf(baseRingAngle*( i + 0 )); + float ringCos1 = cosf(baseSliceAngle*(j + 0))*cosf(baseRingAngle*( i + 0 )); + Vector3 w1 = (Vector3){ + capCenter.x + (sinf(baseRingAngle*( i + 0 ))*b0.x + ringSin1*b1.x + ringCos1*b2.x)*radius, + capCenter.y + (sinf(baseRingAngle*( i + 0 ))*b0.y + ringSin1*b1.y + ringCos1*b2.y)*radius, + capCenter.z + (sinf(baseRingAngle*( i + 0 ))*b0.z + ringSin1*b1.z + ringCos1*b2.z)*radius + }; + float ringSin2 = sinf(baseSliceAngle*(j + 1))*cosf(baseRingAngle*( i + 0 )); + float ringCos2 = cosf(baseSliceAngle*(j + 1))*cosf(baseRingAngle*( i + 0 )); + Vector3 w2 = (Vector3){ + capCenter.x + (sinf(baseRingAngle*( i + 0 ))*b0.x + ringSin2*b1.x + ringCos2*b2.x)*radius, + capCenter.y + (sinf(baseRingAngle*( i + 0 ))*b0.y + ringSin2*b1.y + ringCos2*b2.y)*radius, + capCenter.z + (sinf(baseRingAngle*( i + 0 ))*b0.z + ringSin2*b1.z + ringCos2*b2.z)*radius + }; + + float ringSin3 = sinf(baseSliceAngle*(j + 0))*cosf(baseRingAngle*( i + 1 )); + float ringCos3 = cosf(baseSliceAngle*(j + 0))*cosf(baseRingAngle*( i + 1 )); + Vector3 w3 = (Vector3){ + capCenter.x + (sinf(baseRingAngle*( i + 1 ))*b0.x + ringSin3*b1.x + ringCos3*b2.x)*radius, + capCenter.y + (sinf(baseRingAngle*( i + 1 ))*b0.y + ringSin3*b1.y + ringCos3*b2.y)*radius, + capCenter.z + (sinf(baseRingAngle*( i + 1 ))*b0.z + ringSin3*b1.z + ringCos3*b2.z)*radius + }; + float ringSin4 = sinf(baseSliceAngle*(j + 1))*cosf(baseRingAngle*( i + 1 )); + float ringCos4 = cosf(baseSliceAngle*(j + 1))*cosf(baseRingAngle*( i + 1 )); + Vector3 w4 = (Vector3){ + capCenter.x + (sinf(baseRingAngle*( i + 1 ))*b0.x + ringSin4*b1.x + ringCos4*b2.x)*radius, + capCenter.y + (sinf(baseRingAngle*( i + 1 ))*b0.y + ringSin4*b1.y + ringCos4*b2.y)*radius, + capCenter.z + (sinf(baseRingAngle*( i + 1 ))*b0.z + ringSin4*b1.z + ringCos4*b2.z)*radius + }; + + rlVertex3f(w1.x, w1.y, w1.z); + rlVertex3f(w2.x, w2.y, w2.z); + + rlVertex3f(w2.x, w2.y, w2.z); + rlVertex3f(w3.x, w3.y, w3.z); + + rlVertex3f(w1.x, w1.y, w1.z); + rlVertex3f(w3.x, w3.y, w3.z); + + rlVertex3f(w2.x, w2.y, w2.z); + rlVertex3f(w4.x, w4.y, w4.z); + + rlVertex3f(w3.x, w3.y, w3.z); + rlVertex3f(w4.x, w4.y, w4.z); + } + } + capCenter = startPos; + b0 = Vector3Scale(b0, -1.0f); + } + // render middle + if (!sphereCase) + { + for (int j = 0; j < slices; j++) + { + // compute the four vertices + float ringSin1 = sinf(baseSliceAngle*(j + 0))*radius; + float ringCos1 = cosf(baseSliceAngle*(j + 0))*radius; + Vector3 w1 = { + startPos.x + ringSin1*b1.x + ringCos1*b2.x, + startPos.y + ringSin1*b1.y + ringCos1*b2.y, + startPos.z + ringSin1*b1.z + ringCos1*b2.z + }; + float ringSin2 = sinf(baseSliceAngle*(j + 1))*radius; + float ringCos2 = cosf(baseSliceAngle*(j + 1))*radius; + Vector3 w2 = { + startPos.x + ringSin2*b1.x + ringCos2*b2.x, + startPos.y + ringSin2*b1.y + ringCos2*b2.y, + startPos.z + ringSin2*b1.z + ringCos2*b2.z + }; + + float ringSin3 = sinf(baseSliceAngle*(j + 0))*radius; + float ringCos3 = cosf(baseSliceAngle*(j + 0))*radius; + Vector3 w3 = { + endPos.x + ringSin3*b1.x + ringCos3*b2.x, + endPos.y + ringSin3*b1.y + ringCos3*b2.y, + endPos.z + ringSin3*b1.z + ringCos3*b2.z + }; + float ringSin4 = sinf(baseSliceAngle*(j + 1))*radius; + float ringCos4 = cosf(baseSliceAngle*(j + 1))*radius; + Vector3 w4 = { + endPos.x + ringSin4*b1.x + ringCos4*b2.x, + endPos.y + ringSin4*b1.y + ringCos4*b2.y, + endPos.z + ringSin4*b1.z + ringCos4*b2.z + }; + + rlVertex3f(w1.x, w1.y, w1.z); + rlVertex3f(w3.x, w3.y, w3.z); + + rlVertex3f(w2.x, w2.y, w2.z); + rlVertex3f(w4.x, w4.y, w4.z); + + rlVertex3f(w2.x, w2.y, w2.z); + rlVertex3f(w3.x, w3.y, w3.z); + } + } + rlEnd(); +} + +// Draw a plane +void DrawPlane(Vector3 centerPos, Vector2 size, Color color) +{ + // NOTE: Plane is always created on XZ ground + rlPushMatrix(); + rlTranslatef(centerPos.x, centerPos.y, centerPos.z); + rlScalef(size.x, 1.0f, size.y); + + rlBegin(RL_QUADS); + rlColor4ub(color.r, color.g, color.b, color.a); + rlNormal3f(0.0f, 1.0f, 0.0f); + + rlVertex3f(-0.5f, 0.0f, -0.5f); + rlVertex3f(-0.5f, 0.0f, 0.5f); + rlVertex3f(0.5f, 0.0f, 0.5f); + rlVertex3f(0.5f, 0.0f, -0.5f); + rlEnd(); + rlPopMatrix(); +} + +// Draw a ray line +void DrawRay(Ray ray, Color color) +{ + float scale = 10000; + + rlBegin(RL_LINES); + rlColor4ub(color.r, color.g, color.b, color.a); + rlColor4ub(color.r, color.g, color.b, color.a); + + rlVertex3f(ray.position.x, ray.position.y, ray.position.z); + rlVertex3f(ray.position.x + ray.direction.x*scale, ray.position.y + ray.direction.y*scale, ray.position.z + ray.direction.z*scale); + rlEnd(); +} + +// Draw a grid centered at (0, 0, 0) +void DrawGrid(int slices, float spacing) +{ + int halfSlices = slices/2; + + rlBegin(RL_LINES); + for (int i = -halfSlices; i <= halfSlices; i++) + { + if (i == 0) + { + rlColor3f(0.5f, 0.5f, 0.5f); + } + else + { + rlColor3f(0.75f, 0.75f, 0.75f); + } + + rlVertex3f((float)i*spacing, 0.0f, (float)-halfSlices*spacing); + rlVertex3f((float)i*spacing, 0.0f, (float)halfSlices*spacing); + + rlVertex3f((float)-halfSlices*spacing, 0.0f, (float)i*spacing); + rlVertex3f((float)halfSlices*spacing, 0.0f, (float)i*spacing); + } + rlEnd(); +} + +// Load model from files (mesh and material) +Model LoadModel(const char *fileName) +{ + Model model = { 0 }; + +#if defined(SUPPORT_FILEFORMAT_OBJ) + if (IsFileExtension(fileName, ".obj")) model = LoadOBJ(fileName); +#endif +#if defined(SUPPORT_FILEFORMAT_IQM) + if (IsFileExtension(fileName, ".iqm")) model = LoadIQM(fileName); +#endif +#if defined(SUPPORT_FILEFORMAT_GLTF) + if (IsFileExtension(fileName, ".gltf") || IsFileExtension(fileName, ".glb")) model = LoadGLTF(fileName); +#endif +#if defined(SUPPORT_FILEFORMAT_VOX) + if (IsFileExtension(fileName, ".vox")) model = LoadVOX(fileName); +#endif +#if defined(SUPPORT_FILEFORMAT_M3D) + if (IsFileExtension(fileName, ".m3d")) model = LoadM3D(fileName); +#endif + + // Make sure model transform is set to identity matrix! + model.transform = MatrixIdentity(); + + if ((model.meshCount != 0) && (model.meshes != NULL)) + { + // Upload vertex data to GPU (static meshes) + for (int i = 0; i < model.meshCount; i++) UploadMesh(&model.meshes[i], false); + } + else TRACELOG(LOG_WARNING, "MESH: [%s] Failed to load model mesh(es) data", fileName); + + if (model.materialCount == 0) + { + TRACELOG(LOG_WARNING, "MATERIAL: [%s] Failed to load model material data, default to white material", fileName); + + model.materialCount = 1; + model.materials = (Material *)RL_CALLOC(model.materialCount, sizeof(Material)); + model.materials[0] = LoadMaterialDefault(); + + if (model.meshMaterial == NULL) model.meshMaterial = (int *)RL_CALLOC(model.meshCount, sizeof(int)); + } + + return model; +} + +// Load model from generated mesh +// WARNING: A shallow copy of mesh is generated, passed by value, +// as long as struct contains pointers to data and some values, we get a copy +// of mesh pointing to same data as original version... be careful! +Model LoadModelFromMesh(Mesh mesh) +{ + Model model = { 0 }; + + model.transform = MatrixIdentity(); + + model.meshCount = 1; + model.meshes = (Mesh *)RL_CALLOC(model.meshCount, sizeof(Mesh)); + model.meshes[0] = mesh; + + model.materialCount = 1; + model.materials = (Material *)RL_CALLOC(model.materialCount, sizeof(Material)); + model.materials[0] = LoadMaterialDefault(); + + model.meshMaterial = (int *)RL_CALLOC(model.meshCount, sizeof(int)); + model.meshMaterial[0] = 0; // First material index + + return model; +} + +// Check if a model is ready +bool IsModelReady(Model model) +{ + bool result = false; + + if ((model.meshes != NULL) && // Validate model contains some mesh + (model.materials != NULL) && // Validate model contains some material (at least default one) + (model.meshMaterial != NULL) && // Validate mesh-material linkage + (model.meshCount > 0) && // Validate mesh count + (model.materialCount > 0)) result = true; // Validate material count + + // NOTE: This is a very general model validation, many elements could be validated from a model... + + return result; +} + +// Unload model (meshes/materials) from memory (RAM and/or VRAM) +// NOTE: This function takes care of all model elements, for a detailed control +// over them, use UnloadMesh() and UnloadMaterial() +void UnloadModel(Model model) +{ + // Unload meshes + for (int i = 0; i < model.meshCount; i++) UnloadMesh(model.meshes[i]); + + // Unload materials maps + // NOTE: As the user could be sharing shaders and textures between models, + // we don't unload the material but just free its maps, + // the user is responsible for freeing models shaders and textures + for (int i = 0; i < model.materialCount; i++) RL_FREE(model.materials[i].maps); + + // Unload arrays + RL_FREE(model.meshes); + RL_FREE(model.materials); + RL_FREE(model.meshMaterial); + + // Unload animation data + RL_FREE(model.bones); + RL_FREE(model.bindPose); + + TRACELOG(LOG_INFO, "MODEL: Unloaded model (and meshes) from RAM and VRAM"); +} + +// Compute model bounding box limits (considers all meshes) +BoundingBox GetModelBoundingBox(Model model) +{ + BoundingBox bounds = { 0 }; + + if (model.meshCount > 0) + { + Vector3 temp = { 0 }; + bounds = GetMeshBoundingBox(model.meshes[0]); + + for (int i = 1; i < model.meshCount; i++) + { + BoundingBox tempBounds = GetMeshBoundingBox(model.meshes[i]); + + temp.x = (bounds.min.x < tempBounds.min.x)? bounds.min.x : tempBounds.min.x; + temp.y = (bounds.min.y < tempBounds.min.y)? bounds.min.y : tempBounds.min.y; + temp.z = (bounds.min.z < tempBounds.min.z)? bounds.min.z : tempBounds.min.z; + bounds.min = temp; + + temp.x = (bounds.max.x > tempBounds.max.x)? bounds.max.x : tempBounds.max.x; + temp.y = (bounds.max.y > tempBounds.max.y)? bounds.max.y : tempBounds.max.y; + temp.z = (bounds.max.z > tempBounds.max.z)? bounds.max.z : tempBounds.max.z; + bounds.max = temp; + } + } + + // Apply model.transform to bounding box + // WARNING: Current BoundingBox structure design does not support rotation transformations, + // in those cases is up to the user to calculate the proper box bounds (8 vertices transformed) + bounds.min = Vector3Transform(bounds.min, model.transform); + bounds.max = Vector3Transform(bounds.max, model.transform); + + return bounds; +} + +// Upload vertex data into a VAO (if supported) and VBO +void UploadMesh(Mesh *mesh, bool dynamic) +{ + if (mesh->vaoId > 0) + { + // Check if mesh has already been loaded in GPU + TRACELOG(LOG_WARNING, "VAO: [ID %i] Trying to re-load an already loaded mesh", mesh->vaoId); + return; + } + + mesh->vboId = (unsigned int *)RL_CALLOC(MAX_MESH_VERTEX_BUFFERS, sizeof(unsigned int)); + + mesh->vaoId = 0; // Vertex Array Object + mesh->vboId[0] = 0; // Vertex buffer: positions + mesh->vboId[1] = 0; // Vertex buffer: texcoords + mesh->vboId[2] = 0; // Vertex buffer: normals + mesh->vboId[3] = 0; // Vertex buffer: colors + mesh->vboId[4] = 0; // Vertex buffer: tangents + mesh->vboId[5] = 0; // Vertex buffer: texcoords2 + mesh->vboId[6] = 0; // Vertex buffer: indices + +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + mesh->vaoId = rlLoadVertexArray(); + rlEnableVertexArray(mesh->vaoId); + + // NOTE: Vertex attributes must be uploaded considering default locations points and available vertex data + + // Enable vertex attributes: position (shader-location = 0) + void *vertices = (mesh->animVertices != NULL)? mesh->animVertices : mesh->vertices; + mesh->vboId[0] = rlLoadVertexBuffer(vertices, mesh->vertexCount*3*sizeof(float), dynamic); + rlSetVertexAttribute(RL_DEFAULT_SHADER_ATTRIB_LOCATION_POSITION, 3, RL_FLOAT, 0, 0, 0); + rlEnableVertexAttribute(RL_DEFAULT_SHADER_ATTRIB_LOCATION_POSITION); + + // Enable vertex attributes: texcoords (shader-location = 1) + mesh->vboId[1] = rlLoadVertexBuffer(mesh->texcoords, mesh->vertexCount*2*sizeof(float), dynamic); + rlSetVertexAttribute(RL_DEFAULT_SHADER_ATTRIB_LOCATION_TEXCOORD, 2, RL_FLOAT, 0, 0, 0); + rlEnableVertexAttribute(RL_DEFAULT_SHADER_ATTRIB_LOCATION_TEXCOORD); + + // WARNING: When setting default vertex attribute values, the values for each generic vertex attribute + // is part of current state, and it is maintained even if a different program object is used + + if (mesh->normals != NULL) + { + // Enable vertex attributes: normals (shader-location = 2) + void *normals = (mesh->animNormals != NULL)? mesh->animNormals : mesh->normals; + mesh->vboId[2] = rlLoadVertexBuffer(normals, mesh->vertexCount*3*sizeof(float), dynamic); + rlSetVertexAttribute(RL_DEFAULT_SHADER_ATTRIB_LOCATION_NORMAL, 3, RL_FLOAT, 0, 0, 0); + rlEnableVertexAttribute(RL_DEFAULT_SHADER_ATTRIB_LOCATION_NORMAL); + } + else + { + // Default vertex attribute: normal + // WARNING: Default value provided to shader if location available + float value[3] = { 1.0f, 1.0f, 1.0f }; + rlSetVertexAttributeDefault(RL_DEFAULT_SHADER_ATTRIB_LOCATION_NORMAL, value, SHADER_ATTRIB_VEC3, 3); + rlDisableVertexAttribute(RL_DEFAULT_SHADER_ATTRIB_LOCATION_NORMAL); + } + + if (mesh->colors != NULL) + { + // Enable vertex attribute: color (shader-location = 3) + mesh->vboId[3] = rlLoadVertexBuffer(mesh->colors, mesh->vertexCount*4*sizeof(unsigned char), dynamic); + rlSetVertexAttribute(RL_DEFAULT_SHADER_ATTRIB_LOCATION_COLOR, 4, RL_UNSIGNED_BYTE, 1, 0, 0); + rlEnableVertexAttribute(RL_DEFAULT_SHADER_ATTRIB_LOCATION_COLOR); + } + else + { + // Default vertex attribute: color + // WARNING: Default value provided to shader if location available + float value[4] = { 1.0f, 1.0f, 1.0f, 1.0f }; // WHITE + rlSetVertexAttributeDefault(RL_DEFAULT_SHADER_ATTRIB_LOCATION_COLOR, value, SHADER_ATTRIB_VEC4, 4); + rlDisableVertexAttribute(RL_DEFAULT_SHADER_ATTRIB_LOCATION_COLOR); + } + + if (mesh->tangents != NULL) + { + // Enable vertex attribute: tangent (shader-location = 4) + mesh->vboId[4] = rlLoadVertexBuffer(mesh->tangents, mesh->vertexCount*4*sizeof(float), dynamic); + rlSetVertexAttribute(RL_DEFAULT_SHADER_ATTRIB_LOCATION_TANGENT, 4, RL_FLOAT, 0, 0, 0); + rlEnableVertexAttribute(RL_DEFAULT_SHADER_ATTRIB_LOCATION_TANGENT); + } + else + { + // Default vertex attribute: tangent + // WARNING: Default value provided to shader if location available + float value[4] = { 0.0f, 0.0f, 0.0f, 0.0f }; + rlSetVertexAttributeDefault(RL_DEFAULT_SHADER_ATTRIB_LOCATION_TANGENT, value, SHADER_ATTRIB_VEC4, 4); + rlDisableVertexAttribute(RL_DEFAULT_SHADER_ATTRIB_LOCATION_TANGENT); + } + + if (mesh->texcoords2 != NULL) + { + // Enable vertex attribute: texcoord2 (shader-location = 5) + mesh->vboId[5] = rlLoadVertexBuffer(mesh->texcoords2, mesh->vertexCount*2*sizeof(float), dynamic); + rlSetVertexAttribute(RL_DEFAULT_SHADER_ATTRIB_LOCATION_TEXCOORD2, 2, RL_FLOAT, 0, 0, 0); + rlEnableVertexAttribute(RL_DEFAULT_SHADER_ATTRIB_LOCATION_TEXCOORD2); + } + else + { + // Default vertex attribute: texcoord2 + // WARNING: Default value provided to shader if location available + float value[2] = { 0.0f, 0.0f }; + rlSetVertexAttributeDefault(RL_DEFAULT_SHADER_ATTRIB_LOCATION_TEXCOORD2, value, SHADER_ATTRIB_VEC2, 2); + rlDisableVertexAttribute(RL_DEFAULT_SHADER_ATTRIB_LOCATION_TEXCOORD2); + } + + if (mesh->indices != NULL) + { + mesh->vboId[6] = rlLoadVertexBufferElement(mesh->indices, mesh->triangleCount*3*sizeof(unsigned short), dynamic); + } + + if (mesh->vaoId > 0) TRACELOG(LOG_INFO, "VAO: [ID %i] Mesh uploaded successfully to VRAM (GPU)", mesh->vaoId); + else TRACELOG(LOG_INFO, "VBO: Mesh uploaded successfully to VRAM (GPU)"); + + rlDisableVertexArray(); +#endif +} + +// Update mesh vertex data in GPU for a specific buffer index +void UpdateMeshBuffer(Mesh mesh, int index, const void *data, int dataSize, int offset) +{ + rlUpdateVertexBuffer(mesh.vboId[index], data, dataSize, offset); +} + +// Draw a 3d mesh with material and transform +void DrawMesh(Mesh mesh, Material material, Matrix transform) +{ +#if defined(GRAPHICS_API_OPENGL_11) + #define GL_VERTEX_ARRAY 0x8074 + #define GL_NORMAL_ARRAY 0x8075 + #define GL_COLOR_ARRAY 0x8076 + #define GL_TEXTURE_COORD_ARRAY 0x8078 + + rlEnableTexture(material.maps[MATERIAL_MAP_DIFFUSE].texture.id); + + rlEnableStatePointer(GL_VERTEX_ARRAY, mesh.vertices); + rlEnableStatePointer(GL_TEXTURE_COORD_ARRAY, mesh.texcoords); + rlEnableStatePointer(GL_NORMAL_ARRAY, mesh.normals); + rlEnableStatePointer(GL_COLOR_ARRAY, mesh.colors); + + rlPushMatrix(); + rlMultMatrixf(MatrixToFloat(transform)); + rlColor4ub(material.maps[MATERIAL_MAP_DIFFUSE].color.r, + material.maps[MATERIAL_MAP_DIFFUSE].color.g, + material.maps[MATERIAL_MAP_DIFFUSE].color.b, + material.maps[MATERIAL_MAP_DIFFUSE].color.a); + + if (mesh.indices != NULL) rlDrawVertexArrayElements(0, mesh.triangleCount*3, mesh.indices); + else rlDrawVertexArray(0, mesh.vertexCount); + rlPopMatrix(); + + rlDisableStatePointer(GL_VERTEX_ARRAY); + rlDisableStatePointer(GL_TEXTURE_COORD_ARRAY); + rlDisableStatePointer(GL_NORMAL_ARRAY); + rlDisableStatePointer(GL_COLOR_ARRAY); + + rlDisableTexture(); +#endif + +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + // Bind shader program + rlEnableShader(material.shader.id); + + // Send required data to shader (matrices, values) + //----------------------------------------------------- + // Upload to shader material.colDiffuse + if (material.shader.locs[SHADER_LOC_COLOR_DIFFUSE] != -1) + { + float values[4] = { + (float)material.maps[MATERIAL_MAP_DIFFUSE].color.r/255.0f, + (float)material.maps[MATERIAL_MAP_DIFFUSE].color.g/255.0f, + (float)material.maps[MATERIAL_MAP_DIFFUSE].color.b/255.0f, + (float)material.maps[MATERIAL_MAP_DIFFUSE].color.a/255.0f + }; + + rlSetUniform(material.shader.locs[SHADER_LOC_COLOR_DIFFUSE], values, SHADER_UNIFORM_VEC4, 1); + } + + // Upload to shader material.colSpecular (if location available) + if (material.shader.locs[SHADER_LOC_COLOR_SPECULAR] != -1) + { + float values[4] = { + (float)material.maps[MATERIAL_MAP_SPECULAR].color.r/255.0f, + (float)material.maps[MATERIAL_MAP_SPECULAR].color.g/255.0f, + (float)material.maps[MATERIAL_MAP_SPECULAR].color.b/255.0f, + (float)material.maps[MATERIAL_MAP_SPECULAR].color.a/255.0f + }; + + rlSetUniform(material.shader.locs[SHADER_LOC_COLOR_SPECULAR], values, SHADER_UNIFORM_VEC4, 1); + } + + // Get a copy of current matrices to work with, + // just in case stereo render is required, and we need to modify them + // NOTE: At this point the modelview matrix just contains the view matrix (camera) + // That's because BeginMode3D() sets it and there is no model-drawing function + // that modifies it, all use rlPushMatrix() and rlPopMatrix() + Matrix matModel = MatrixIdentity(); + Matrix matView = rlGetMatrixModelview(); + Matrix matModelView = MatrixIdentity(); + Matrix matProjection = rlGetMatrixProjection(); + + // Upload view and projection matrices (if locations available) + if (material.shader.locs[SHADER_LOC_MATRIX_VIEW] != -1) rlSetUniformMatrix(material.shader.locs[SHADER_LOC_MATRIX_VIEW], matView); + if (material.shader.locs[SHADER_LOC_MATRIX_PROJECTION] != -1) rlSetUniformMatrix(material.shader.locs[SHADER_LOC_MATRIX_PROJECTION], matProjection); + + // Accumulate several model transformations: + // transform: model transformation provided (includes DrawModel() params combined with model.transform) + // rlGetMatrixTransform(): rlgl internal transform matrix due to push/pop matrix stack + matModel = MatrixMultiply(transform, rlGetMatrixTransform()); + + // Model transformation matrix is sent to shader uniform location: SHADER_LOC_MATRIX_MODEL + if (material.shader.locs[SHADER_LOC_MATRIX_MODEL] != -1) rlSetUniformMatrix(material.shader.locs[SHADER_LOC_MATRIX_MODEL], matModel); + + // Get model-view matrix + matModelView = MatrixMultiply(matModel, matView); + + // Upload model normal matrix (if locations available) + if (material.shader.locs[SHADER_LOC_MATRIX_NORMAL] != -1) rlSetUniformMatrix(material.shader.locs[SHADER_LOC_MATRIX_NORMAL], MatrixTranspose(MatrixInvert(matModel))); + //----------------------------------------------------- + + // Bind active texture maps (if available) + for (int i = 0; i < MAX_MATERIAL_MAPS; i++) + { + if (material.maps[i].texture.id > 0) + { + // Select current shader texture slot + rlActiveTextureSlot(i); + + // Enable texture for active slot + if ((i == MATERIAL_MAP_IRRADIANCE) || + (i == MATERIAL_MAP_PREFILTER) || + (i == MATERIAL_MAP_CUBEMAP)) rlEnableTextureCubemap(material.maps[i].texture.id); + else rlEnableTexture(material.maps[i].texture.id); + + rlSetUniform(material.shader.locs[SHADER_LOC_MAP_DIFFUSE + i], &i, SHADER_UNIFORM_INT, 1); + } + } + + // Try binding vertex array objects (VAO) or use VBOs if not possible + // WARNING: UploadMesh() enables all vertex attributes available in mesh and sets default attribute values + // for shader expected vertex attributes that are not provided by the mesh (i.e. colors) + // This could be a dangerous approach because different meshes with different shaders can enable/disable some attributes + if (!rlEnableVertexArray(mesh.vaoId)) + { + // Bind mesh VBO data: vertex position (shader-location = 0) + rlEnableVertexBuffer(mesh.vboId[0]); + rlSetVertexAttribute(material.shader.locs[SHADER_LOC_VERTEX_POSITION], 3, RL_FLOAT, 0, 0, 0); + rlEnableVertexAttribute(material.shader.locs[SHADER_LOC_VERTEX_POSITION]); + + // Bind mesh VBO data: vertex texcoords (shader-location = 1) + rlEnableVertexBuffer(mesh.vboId[1]); + rlSetVertexAttribute(material.shader.locs[SHADER_LOC_VERTEX_TEXCOORD01], 2, RL_FLOAT, 0, 0, 0); + rlEnableVertexAttribute(material.shader.locs[SHADER_LOC_VERTEX_TEXCOORD01]); + + if (material.shader.locs[SHADER_LOC_VERTEX_NORMAL] != -1) + { + // Bind mesh VBO data: vertex normals (shader-location = 2) + rlEnableVertexBuffer(mesh.vboId[2]); + rlSetVertexAttribute(material.shader.locs[SHADER_LOC_VERTEX_NORMAL], 3, RL_FLOAT, 0, 0, 0); + rlEnableVertexAttribute(material.shader.locs[SHADER_LOC_VERTEX_NORMAL]); + } + + // Bind mesh VBO data: vertex colors (shader-location = 3, if available) + if (material.shader.locs[SHADER_LOC_VERTEX_COLOR] != -1) + { + if (mesh.vboId[3] != 0) + { + rlEnableVertexBuffer(mesh.vboId[3]); + rlSetVertexAttribute(material.shader.locs[SHADER_LOC_VERTEX_COLOR], 4, RL_UNSIGNED_BYTE, 1, 0, 0); + rlEnableVertexAttribute(material.shader.locs[SHADER_LOC_VERTEX_COLOR]); + } + else + { + // Set default value for defined vertex attribute in shader but not provided by mesh + // WARNING: It could result in GPU undefined behaviour + float value[4] = { 1.0f, 1.0f, 1.0f, 1.0f }; + rlSetVertexAttributeDefault(material.shader.locs[SHADER_LOC_VERTEX_COLOR], value, SHADER_ATTRIB_VEC4, 4); + rlDisableVertexAttribute(material.shader.locs[SHADER_LOC_VERTEX_COLOR]); + } + } + + // Bind mesh VBO data: vertex tangents (shader-location = 4, if available) + if (material.shader.locs[SHADER_LOC_VERTEX_TANGENT] != -1) + { + rlEnableVertexBuffer(mesh.vboId[4]); + rlSetVertexAttribute(material.shader.locs[SHADER_LOC_VERTEX_TANGENT], 4, RL_FLOAT, 0, 0, 0); + rlEnableVertexAttribute(material.shader.locs[SHADER_LOC_VERTEX_TANGENT]); + } + + // Bind mesh VBO data: vertex texcoords2 (shader-location = 5, if available) + if (material.shader.locs[SHADER_LOC_VERTEX_TEXCOORD02] != -1) + { + rlEnableVertexBuffer(mesh.vboId[5]); + rlSetVertexAttribute(material.shader.locs[SHADER_LOC_VERTEX_TEXCOORD02], 2, RL_FLOAT, 0, 0, 0); + rlEnableVertexAttribute(material.shader.locs[SHADER_LOC_VERTEX_TEXCOORD02]); + } + + if (mesh.indices != NULL) rlEnableVertexBufferElement(mesh.vboId[6]); + } + + int eyeCount = 1; + if (rlIsStereoRenderEnabled()) eyeCount = 2; + + for (int eye = 0; eye < eyeCount; eye++) + { + // Calculate model-view-projection matrix (MVP) + Matrix matModelViewProjection = MatrixIdentity(); + if (eyeCount == 1) matModelViewProjection = MatrixMultiply(matModelView, matProjection); + else + { + // Setup current eye viewport (half screen width) + rlViewport(eye*rlGetFramebufferWidth()/2, 0, rlGetFramebufferWidth()/2, rlGetFramebufferHeight()); + matModelViewProjection = MatrixMultiply(MatrixMultiply(matModelView, rlGetMatrixViewOffsetStereo(eye)), rlGetMatrixProjectionStereo(eye)); + } + + // Send combined model-view-projection matrix to shader + rlSetUniformMatrix(material.shader.locs[SHADER_LOC_MATRIX_MVP], matModelViewProjection); + + // Draw mesh + if (mesh.indices != NULL) rlDrawVertexArrayElements(0, mesh.triangleCount*3, 0); + else rlDrawVertexArray(0, mesh.vertexCount); + } + + // Unbind all bound texture maps + for (int i = 0; i < MAX_MATERIAL_MAPS; i++) + { + if (material.maps[i].texture.id > 0) + { + // Select current shader texture slot + rlActiveTextureSlot(i); + + // Disable texture for active slot + if ((i == MATERIAL_MAP_IRRADIANCE) || + (i == MATERIAL_MAP_PREFILTER) || + (i == MATERIAL_MAP_CUBEMAP)) rlDisableTextureCubemap(); + else rlDisableTexture(); + } + } + + // Disable all possible vertex array objects (or VBOs) + rlDisableVertexArray(); + rlDisableVertexBuffer(); + rlDisableVertexBufferElement(); + + // Disable shader program + rlDisableShader(); + + // Restore rlgl internal modelview and projection matrices + rlSetMatrixModelview(matView); + rlSetMatrixProjection(matProjection); +#endif +} + +// Draw multiple mesh instances with material and different transforms +void DrawMeshInstanced(Mesh mesh, Material material, const Matrix *transforms, int instances) +{ +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + // Instancing required variables + float16 *instanceTransforms = NULL; + unsigned int instancesVboId = 0; + + // Bind shader program + rlEnableShader(material.shader.id); + + // Send required data to shader (matrices, values) + //----------------------------------------------------- + // Upload to shader material.colDiffuse + if (material.shader.locs[SHADER_LOC_COLOR_DIFFUSE] != -1) + { + float values[4] = { + (float)material.maps[MATERIAL_MAP_DIFFUSE].color.r/255.0f, + (float)material.maps[MATERIAL_MAP_DIFFUSE].color.g/255.0f, + (float)material.maps[MATERIAL_MAP_DIFFUSE].color.b/255.0f, + (float)material.maps[MATERIAL_MAP_DIFFUSE].color.a/255.0f + }; + + rlSetUniform(material.shader.locs[SHADER_LOC_COLOR_DIFFUSE], values, SHADER_UNIFORM_VEC4, 1); + } + + // Upload to shader material.colSpecular (if location available) + if (material.shader.locs[SHADER_LOC_COLOR_SPECULAR] != -1) + { + float values[4] = { + (float)material.maps[SHADER_LOC_COLOR_SPECULAR].color.r/255.0f, + (float)material.maps[SHADER_LOC_COLOR_SPECULAR].color.g/255.0f, + (float)material.maps[SHADER_LOC_COLOR_SPECULAR].color.b/255.0f, + (float)material.maps[SHADER_LOC_COLOR_SPECULAR].color.a/255.0f + }; + + rlSetUniform(material.shader.locs[SHADER_LOC_COLOR_SPECULAR], values, SHADER_UNIFORM_VEC4, 1); + } + + // Get a copy of current matrices to work with, + // just in case stereo render is required, and we need to modify them + // NOTE: At this point the modelview matrix just contains the view matrix (camera) + // That's because BeginMode3D() sets it and there is no model-drawing function + // that modifies it, all use rlPushMatrix() and rlPopMatrix() + Matrix matModel = MatrixIdentity(); + Matrix matView = rlGetMatrixModelview(); + Matrix matModelView = MatrixIdentity(); + Matrix matProjection = rlGetMatrixProjection(); + + // Upload view and projection matrices (if locations available) + if (material.shader.locs[SHADER_LOC_MATRIX_VIEW] != -1) rlSetUniformMatrix(material.shader.locs[SHADER_LOC_MATRIX_VIEW], matView); + if (material.shader.locs[SHADER_LOC_MATRIX_PROJECTION] != -1) rlSetUniformMatrix(material.shader.locs[SHADER_LOC_MATRIX_PROJECTION], matProjection); + + // Create instances buffer + instanceTransforms = (float16 *)RL_MALLOC(instances*sizeof(float16)); + + // Fill buffer with instances transformations as float16 arrays + for (int i = 0; i < instances; i++) instanceTransforms[i] = MatrixToFloatV(transforms[i]); + + // Enable mesh VAO to attach new buffer + rlEnableVertexArray(mesh.vaoId); + + // This could alternatively use a static VBO and either glMapBuffer() or glBufferSubData() + // It isn't clear which would be reliably faster in all cases and on all platforms, + // anecdotally glMapBuffer() seems very slow (syncs) while glBufferSubData() seems + // no faster, since we're transferring all the transform matrices anyway + instancesVboId = rlLoadVertexBuffer(instanceTransforms, instances*sizeof(float16), false); + + // Instances transformation matrices are send to shader attribute location: SHADER_LOC_MATRIX_MODEL + for (unsigned int i = 0; i < 4; i++) + { + rlEnableVertexAttribute(material.shader.locs[SHADER_LOC_MATRIX_MODEL] + i); + rlSetVertexAttribute(material.shader.locs[SHADER_LOC_MATRIX_MODEL] + i, 4, RL_FLOAT, 0, sizeof(Matrix), i*sizeof(Vector4)); + rlSetVertexAttributeDivisor(material.shader.locs[SHADER_LOC_MATRIX_MODEL] + i, 1); + } + + rlDisableVertexBuffer(); + rlDisableVertexArray(); + + // Accumulate internal matrix transform (push/pop) and view matrix + // NOTE: In this case, model instance transformation must be computed in the shader + matModelView = MatrixMultiply(rlGetMatrixTransform(), matView); + + // Upload model normal matrix (if locations available) + if (material.shader.locs[SHADER_LOC_MATRIX_NORMAL] != -1) rlSetUniformMatrix(material.shader.locs[SHADER_LOC_MATRIX_NORMAL], MatrixTranspose(MatrixInvert(matModel))); + //----------------------------------------------------- + + // Bind active texture maps (if available) + for (int i = 0; i < MAX_MATERIAL_MAPS; i++) + { + if (material.maps[i].texture.id > 0) + { + // Select current shader texture slot + rlActiveTextureSlot(i); + + // Enable texture for active slot + if ((i == MATERIAL_MAP_IRRADIANCE) || + (i == MATERIAL_MAP_PREFILTER) || + (i == MATERIAL_MAP_CUBEMAP)) rlEnableTextureCubemap(material.maps[i].texture.id); + else rlEnableTexture(material.maps[i].texture.id); + + rlSetUniform(material.shader.locs[SHADER_LOC_MAP_DIFFUSE + i], &i, SHADER_UNIFORM_INT, 1); + } + } + + // Try binding vertex array objects (VAO) + // or use VBOs if not possible + if (!rlEnableVertexArray(mesh.vaoId)) + { + // Bind mesh VBO data: vertex position (shader-location = 0) + rlEnableVertexBuffer(mesh.vboId[0]); + rlSetVertexAttribute(material.shader.locs[SHADER_LOC_VERTEX_POSITION], 3, RL_FLOAT, 0, 0, 0); + rlEnableVertexAttribute(material.shader.locs[SHADER_LOC_VERTEX_POSITION]); + + // Bind mesh VBO data: vertex texcoords (shader-location = 1) + rlEnableVertexBuffer(mesh.vboId[1]); + rlSetVertexAttribute(material.shader.locs[SHADER_LOC_VERTEX_TEXCOORD01], 2, RL_FLOAT, 0, 0, 0); + rlEnableVertexAttribute(material.shader.locs[SHADER_LOC_VERTEX_TEXCOORD01]); + + if (material.shader.locs[SHADER_LOC_VERTEX_NORMAL] != -1) + { + // Bind mesh VBO data: vertex normals (shader-location = 2) + rlEnableVertexBuffer(mesh.vboId[2]); + rlSetVertexAttribute(material.shader.locs[SHADER_LOC_VERTEX_NORMAL], 3, RL_FLOAT, 0, 0, 0); + rlEnableVertexAttribute(material.shader.locs[SHADER_LOC_VERTEX_NORMAL]); + } + + // Bind mesh VBO data: vertex colors (shader-location = 3, if available) + if (material.shader.locs[SHADER_LOC_VERTEX_COLOR] != -1) + { + if (mesh.vboId[3] != 0) + { + rlEnableVertexBuffer(mesh.vboId[3]); + rlSetVertexAttribute(material.shader.locs[SHADER_LOC_VERTEX_COLOR], 4, RL_UNSIGNED_BYTE, 1, 0, 0); + rlEnableVertexAttribute(material.shader.locs[SHADER_LOC_VERTEX_COLOR]); + } + else + { + // Set default value for unused attribute + // NOTE: Required when using default shader and no VAO support + float value[4] = { 1.0f, 1.0f, 1.0f, 1.0f }; + rlSetVertexAttributeDefault(material.shader.locs[SHADER_LOC_VERTEX_COLOR], value, SHADER_ATTRIB_VEC4, 4); + rlDisableVertexAttribute(material.shader.locs[SHADER_LOC_VERTEX_COLOR]); + } + } + + // Bind mesh VBO data: vertex tangents (shader-location = 4, if available) + if (material.shader.locs[SHADER_LOC_VERTEX_TANGENT] != -1) + { + rlEnableVertexBuffer(mesh.vboId[4]); + rlSetVertexAttribute(material.shader.locs[SHADER_LOC_VERTEX_TANGENT], 4, RL_FLOAT, 0, 0, 0); + rlEnableVertexAttribute(material.shader.locs[SHADER_LOC_VERTEX_TANGENT]); + } + + // Bind mesh VBO data: vertex texcoords2 (shader-location = 5, if available) + if (material.shader.locs[SHADER_LOC_VERTEX_TEXCOORD02] != -1) + { + rlEnableVertexBuffer(mesh.vboId[5]); + rlSetVertexAttribute(material.shader.locs[SHADER_LOC_VERTEX_TEXCOORD02], 2, RL_FLOAT, 0, 0, 0); + rlEnableVertexAttribute(material.shader.locs[SHADER_LOC_VERTEX_TEXCOORD02]); + } + + if (mesh.indices != NULL) rlEnableVertexBufferElement(mesh.vboId[6]); + } + + int eyeCount = 1; + if (rlIsStereoRenderEnabled()) eyeCount = 2; + + for (int eye = 0; eye < eyeCount; eye++) + { + // Calculate model-view-projection matrix (MVP) + Matrix matModelViewProjection = MatrixIdentity(); + if (eyeCount == 1) matModelViewProjection = MatrixMultiply(matModelView, matProjection); + else + { + // Setup current eye viewport (half screen width) + rlViewport(eye*rlGetFramebufferWidth()/2, 0, rlGetFramebufferWidth()/2, rlGetFramebufferHeight()); + matModelViewProjection = MatrixMultiply(MatrixMultiply(matModelView, rlGetMatrixViewOffsetStereo(eye)), rlGetMatrixProjectionStereo(eye)); + } + + // Send combined model-view-projection matrix to shader + rlSetUniformMatrix(material.shader.locs[SHADER_LOC_MATRIX_MVP], matModelViewProjection); + + // Draw mesh instanced + if (mesh.indices != NULL) rlDrawVertexArrayElementsInstanced(0, mesh.triangleCount*3, 0, instances); + else rlDrawVertexArrayInstanced(0, mesh.vertexCount, instances); + } + + // Unbind all bound texture maps + for (int i = 0; i < MAX_MATERIAL_MAPS; i++) + { + if (material.maps[i].texture.id > 0) + { + // Select current shader texture slot + rlActiveTextureSlot(i); + + // Disable texture for active slot + if ((i == MATERIAL_MAP_IRRADIANCE) || + (i == MATERIAL_MAP_PREFILTER) || + (i == MATERIAL_MAP_CUBEMAP)) rlDisableTextureCubemap(); + else rlDisableTexture(); + } + } + + // Disable all possible vertex array objects (or VBOs) + rlDisableVertexArray(); + rlDisableVertexBuffer(); + rlDisableVertexBufferElement(); + + // Disable shader program + rlDisableShader(); + + // Remove instance transforms buffer + rlUnloadVertexBuffer(instancesVboId); + RL_FREE(instanceTransforms); +#endif +} + +// Unload mesh from memory (RAM and VRAM) +void UnloadMesh(Mesh mesh) +{ + // Unload rlgl mesh vboId data + rlUnloadVertexArray(mesh.vaoId); + + if (mesh.vboId != NULL) for (int i = 0; i < MAX_MESH_VERTEX_BUFFERS; i++) rlUnloadVertexBuffer(mesh.vboId[i]); + RL_FREE(mesh.vboId); + + RL_FREE(mesh.vertices); + RL_FREE(mesh.texcoords); + RL_FREE(mesh.normals); + RL_FREE(mesh.colors); + RL_FREE(mesh.tangents); + RL_FREE(mesh.texcoords2); + RL_FREE(mesh.indices); + + RL_FREE(mesh.animVertices); + RL_FREE(mesh.animNormals); + RL_FREE(mesh.boneWeights); + RL_FREE(mesh.boneIds); +} + +// Export mesh data to file +bool ExportMesh(Mesh mesh, const char *fileName) +{ + bool success = false; + + if (IsFileExtension(fileName, ".obj")) + { + // Estimated data size, it should be enough... + int dataSize = mesh.vertexCount*(int)strlen("v 0000.00f 0000.00f 0000.00f") + + mesh.vertexCount*(int)strlen("vt 0.000f 0.00f") + + mesh.vertexCount*(int)strlen("vn 0.000f 0.00f 0.00f") + + mesh.triangleCount*(int)strlen("f 00000/00000/00000 00000/00000/00000 00000/00000/00000"); + + // NOTE: Text data buffer size is estimated considering mesh data size + char *txtData = (char *)RL_CALLOC(dataSize*2 + 2000, sizeof(char)); + + int byteCount = 0; + byteCount += sprintf(txtData + byteCount, "# //////////////////////////////////////////////////////////////////////////////////\n"); + byteCount += sprintf(txtData + byteCount, "# // //\n"); + byteCount += sprintf(txtData + byteCount, "# // rMeshOBJ exporter v1.0 - Mesh exported as triangle faces and not optimized //\n"); + byteCount += sprintf(txtData + byteCount, "# // //\n"); + byteCount += sprintf(txtData + byteCount, "# // more info and bugs-report: github.com/raysan5/raylib //\n"); + byteCount += sprintf(txtData + byteCount, "# // feedback and support: ray[at]raylib.com //\n"); + byteCount += sprintf(txtData + byteCount, "# // //\n"); + byteCount += sprintf(txtData + byteCount, "# // Copyright (c) 2018-2024 Ramon Santamaria (@raysan5) //\n"); + byteCount += sprintf(txtData + byteCount, "# // //\n"); + byteCount += sprintf(txtData + byteCount, "# //////////////////////////////////////////////////////////////////////////////////\n\n"); + byteCount += sprintf(txtData + byteCount, "# Vertex Count: %i\n", mesh.vertexCount); + byteCount += sprintf(txtData + byteCount, "# Triangle Count: %i\n\n", mesh.triangleCount); + + byteCount += sprintf(txtData + byteCount, "g mesh\n"); + + for (int i = 0, v = 0; i < mesh.vertexCount; i++, v += 3) + { + byteCount += sprintf(txtData + byteCount, "v %.2f %.2f %.2f\n", mesh.vertices[v], mesh.vertices[v + 1], mesh.vertices[v + 2]); + } + + for (int i = 0, v = 0; i < mesh.vertexCount; i++, v += 2) + { + byteCount += sprintf(txtData + byteCount, "vt %.3f %.3f\n", mesh.texcoords[v], mesh.texcoords[v + 1]); + } + + for (int i = 0, v = 0; i < mesh.vertexCount; i++, v += 3) + { + byteCount += sprintf(txtData + byteCount, "vn %.3f %.3f %.3f\n", mesh.normals[v], mesh.normals[v + 1], mesh.normals[v + 2]); + } + + if (mesh.indices != NULL) + { + for (int i = 0, v = 0; i < mesh.triangleCount; i++, v += 3) + { + byteCount += sprintf(txtData + byteCount, "f %i/%i/%i %i/%i/%i %i/%i/%i\n", + mesh.indices[v] + 1, mesh.indices[v] + 1, mesh.indices[v] + 1, + mesh.indices[v + 1] + 1, mesh.indices[v + 1] + 1, mesh.indices[v + 1] + 1, + mesh.indices[v + 2] + 1, mesh.indices[v + 2] + 1, mesh.indices[v + 2] + 1); + } + } + else + { + for (int i = 0, v = 1; i < mesh.triangleCount; i++, v += 3) + { + byteCount += sprintf(txtData + byteCount, "f %i/%i/%i %i/%i/%i %i/%i/%i\n", v, v, v, v + 1, v + 1, v + 1, v + 2, v + 2, v + 2); + } + } + + byteCount += sprintf(txtData + byteCount, "\n"); + + // NOTE: Text data length exported is determined by '\0' (NULL) character + success = SaveFileText(fileName, txtData); + + RL_FREE(txtData); + } + else if (IsFileExtension(fileName, ".raw")) + { + // TODO: Support additional file formats to export mesh vertex data + } + + return success; +} + +// Export mesh as code file (.h) defining multiple arrays of vertex attributes +bool ExportMeshAsCode(Mesh mesh, const char *fileName) +{ + bool success = false; + +#ifndef TEXT_BYTES_PER_LINE + #define TEXT_BYTES_PER_LINE 20 +#endif + + // NOTE: Text data buffer size is fixed to 64MB + char *txtData = (char *)RL_CALLOC(64*1024*1024, sizeof(char)); // 64 MB + + int byteCount = 0; + byteCount += sprintf(txtData + byteCount, "////////////////////////////////////////////////////////////////////////////////////////\n"); + byteCount += sprintf(txtData + byteCount, "// //\n"); + byteCount += sprintf(txtData + byteCount, "// MeshAsCode exporter v1.0 - Mesh vertex data exported as arrays //\n"); + byteCount += sprintf(txtData + byteCount, "// //\n"); + byteCount += sprintf(txtData + byteCount, "// more info and bugs-report: github.com/raysan5/raylib //\n"); + byteCount += sprintf(txtData + byteCount, "// feedback and support: ray[at]raylib.com //\n"); + byteCount += sprintf(txtData + byteCount, "// //\n"); + byteCount += sprintf(txtData + byteCount, "// Copyright (c) 2023 Ramon Santamaria (@raysan5) //\n"); + byteCount += sprintf(txtData + byteCount, "// //\n"); + byteCount += sprintf(txtData + byteCount, "////////////////////////////////////////////////////////////////////////////////////////\n\n"); + + // Get file name from path and convert variable name to uppercase + char varFileName[256] = { 0 }; + strcpy(varFileName, GetFileNameWithoutExt(fileName)); + for (int i = 0; varFileName[i] != '\0'; i++) if ((varFileName[i] >= 'a') && (varFileName[i] <= 'z')) { varFileName[i] = varFileName[i] - 32; } + + // Add image information + byteCount += sprintf(txtData + byteCount, "// Mesh basic information\n"); + byteCount += sprintf(txtData + byteCount, "#define %s_VERTEX_COUNT %i\n", varFileName, mesh.vertexCount); + byteCount += sprintf(txtData + byteCount, "#define %s_TRIANGLE_COUNT %i\n\n", varFileName, mesh.triangleCount); + + // Define vertex attributes data as separate arrays + //----------------------------------------------------------------------------------------- + if (mesh.vertices != NULL) // Vertex position (XYZ - 3 components per vertex - float) + { + byteCount += sprintf(txtData + byteCount, "static float %s_VERTEX_DATA[%i] = { ", varFileName, mesh.vertexCount*3); + for (int i = 0; i < mesh.vertexCount*3 - 1; i++) byteCount += sprintf(txtData + byteCount, ((i%TEXT_BYTES_PER_LINE == 0)? "%.3ff,\n" : "%.3ff, "), mesh.vertices[i]); + byteCount += sprintf(txtData + byteCount, "%.3ff };\n\n", mesh.vertices[mesh.vertexCount*3 - 1]); + } + + if (mesh.texcoords != NULL) // Vertex texture coordinates (UV - 2 components per vertex - float) + { + byteCount += sprintf(txtData + byteCount, "static float %s_TEXCOORD_DATA[%i] = { ", varFileName, mesh.vertexCount*2); + for (int i = 0; i < mesh.vertexCount*2 - 1; i++) byteCount += sprintf(txtData + byteCount, ((i%TEXT_BYTES_PER_LINE == 0)? "%.3ff,\n" : "%.3ff, "), mesh.texcoords[i]); + byteCount += sprintf(txtData + byteCount, "%.3ff };\n\n", mesh.texcoords[mesh.vertexCount*2 - 1]); + } + + if (mesh.texcoords2 != NULL) // Vertex texture coordinates (UV - 2 components per vertex - float) + { + byteCount += sprintf(txtData + byteCount, "static float %s_TEXCOORD2_DATA[%i] = { ", varFileName, mesh.vertexCount*2); + for (int i = 0; i < mesh.vertexCount*2 - 1; i++) byteCount += sprintf(txtData + byteCount, ((i%TEXT_BYTES_PER_LINE == 0)? "%.3ff,\n" : "%.3ff, "), mesh.texcoords2[i]); + byteCount += sprintf(txtData + byteCount, "%.3ff };\n\n", mesh.texcoords2[mesh.vertexCount*2 - 1]); + } + + if (mesh.normals != NULL) // Vertex normals (XYZ - 3 components per vertex - float) + { + byteCount += sprintf(txtData + byteCount, "static float %s_NORMAL_DATA[%i] = { ", varFileName, mesh.vertexCount*3); + for (int i = 0; i < mesh.vertexCount*3 - 1; i++) byteCount += sprintf(txtData + byteCount, ((i%TEXT_BYTES_PER_LINE == 0)? "%.3ff,\n" : "%.3ff, "), mesh.normals[i]); + byteCount += sprintf(txtData + byteCount, "%.3ff };\n\n", mesh.normals[mesh.vertexCount*3 - 1]); + } + + if (mesh.tangents != NULL) // Vertex tangents (XYZW - 4 components per vertex - float) + { + byteCount += sprintf(txtData + byteCount, "static float %s_TANGENT_DATA[%i] = { ", varFileName, mesh.vertexCount*4); + for (int i = 0; i < mesh.vertexCount*4 - 1; i++) byteCount += sprintf(txtData + byteCount, ((i%TEXT_BYTES_PER_LINE == 0)? "%.3ff,\n" : "%.3ff, "), mesh.tangents[i]); + byteCount += sprintf(txtData + byteCount, "%.3ff };\n\n", mesh.tangents[mesh.vertexCount*4 - 1]); + } + + if (mesh.colors != NULL) // Vertex colors (RGBA - 4 components per vertex - unsigned char) + { + byteCount += sprintf(txtData + byteCount, "static unsigned char %s_COLOR_DATA[%i] = { ", varFileName, mesh.vertexCount*4); + for (int i = 0; i < mesh.vertexCount*4 - 1; i++) byteCount += sprintf(txtData + byteCount, ((i%TEXT_BYTES_PER_LINE == 0)? "0x%x,\n" : "0x%x, "), mesh.colors[i]); + byteCount += sprintf(txtData + byteCount, "0x%x };\n\n", mesh.colors[mesh.vertexCount*4 - 1]); + } + + if (mesh.indices != NULL) // Vertex indices (3 index per triangle - unsigned short) + { + byteCount += sprintf(txtData + byteCount, "static unsigned short %s_INDEX_DATA[%i] = { ", varFileName, mesh.triangleCount*3); + for (int i = 0; i < mesh.triangleCount*3 - 1; i++) byteCount += sprintf(txtData + byteCount, ((i%TEXT_BYTES_PER_LINE == 0)? "%i,\n" : "%i, "), mesh.indices[i]); + byteCount += sprintf(txtData + byteCount, "%i };\n", mesh.indices[mesh.triangleCount*3 - 1]); + } + //----------------------------------------------------------------------------------------- + + // NOTE: Text data size exported is determined by '\0' (NULL) character + success = SaveFileText(fileName, txtData); + + RL_FREE(txtData); + + //if (success != 0) TRACELOG(LOG_INFO, "FILEIO: [%s] Image as code exported successfully", fileName); + //else TRACELOG(LOG_WARNING, "FILEIO: [%s] Failed to export image as code", fileName); + + return success; +} + + +#if defined(SUPPORT_FILEFORMAT_OBJ) || defined(SUPPORT_FILEFORMAT_MTL) +// Process obj materials +static void ProcessMaterialsOBJ(Material *materials, tinyobj_material_t *mats, int materialCount) +{ + // Init model mats + for (int m = 0; m < materialCount; m++) + { + // Init material to default + // NOTE: Uses default shader, which only supports MATERIAL_MAP_DIFFUSE + materials[m] = LoadMaterialDefault(); + + if (mats == NULL) continue; + + // Get default texture, in case no texture is defined + // NOTE: rlgl default texture is a 1x1 pixel UNCOMPRESSED_R8G8B8A8 + materials[m].maps[MATERIAL_MAP_DIFFUSE].texture = (Texture2D){ rlGetTextureIdDefault(), 1, 1, 1, PIXELFORMAT_UNCOMPRESSED_R8G8B8A8 }; + + if (mats[m].diffuse_texname != NULL) materials[m].maps[MATERIAL_MAP_DIFFUSE].texture = LoadTexture(mats[m].diffuse_texname); //char *diffuse_texname; // map_Kd + else materials[m].maps[MATERIAL_MAP_DIFFUSE].color = (Color){ (unsigned char)(mats[m].diffuse[0]*255.0f), (unsigned char)(mats[m].diffuse[1]*255.0f), (unsigned char)(mats[m].diffuse[2]*255.0f), 255 }; //float diffuse[3]; + materials[m].maps[MATERIAL_MAP_DIFFUSE].value = 0.0f; + + if (mats[m].specular_texname != NULL) materials[m].maps[MATERIAL_MAP_SPECULAR].texture = LoadTexture(mats[m].specular_texname); //char *specular_texname; // map_Ks + materials[m].maps[MATERIAL_MAP_SPECULAR].color = (Color){ (unsigned char)(mats[m].specular[0]*255.0f), (unsigned char)(mats[m].specular[1]*255.0f), (unsigned char)(mats[m].specular[2]*255.0f), 255 }; //float specular[3]; + materials[m].maps[MATERIAL_MAP_SPECULAR].value = 0.0f; + + if (mats[m].bump_texname != NULL) materials[m].maps[MATERIAL_MAP_NORMAL].texture = LoadTexture(mats[m].bump_texname); //char *bump_texname; // map_bump, bump + materials[m].maps[MATERIAL_MAP_NORMAL].color = WHITE; + materials[m].maps[MATERIAL_MAP_NORMAL].value = mats[m].shininess; + + materials[m].maps[MATERIAL_MAP_EMISSION].color = (Color){ (unsigned char)(mats[m].emission[0]*255.0f), (unsigned char)(mats[m].emission[1]*255.0f), (unsigned char)(mats[m].emission[2]*255.0f), 255 }; //float emission[3]; + + if (mats[m].displacement_texname != NULL) materials[m].maps[MATERIAL_MAP_HEIGHT].texture = LoadTexture(mats[m].displacement_texname); //char *displacement_texname; // disp + } +} +#endif + +// Load materials from model file +Material *LoadMaterials(const char *fileName, int *materialCount) +{ + Material *materials = NULL; + unsigned int count = 0; + + // TODO: Support IQM and GLTF for materials parsing + +#if defined(SUPPORT_FILEFORMAT_MTL) + if (IsFileExtension(fileName, ".mtl")) + { + tinyobj_material_t *mats = NULL; + + int result = tinyobj_parse_mtl_file(&mats, &count, fileName); + if (result != TINYOBJ_SUCCESS) TRACELOG(LOG_WARNING, "MATERIAL: [%s] Failed to parse materials file", fileName); + + materials = RL_MALLOC(count*sizeof(Material)); + ProcessMaterialsOBJ(materials, mats, count); + + tinyobj_materials_free(mats, count); + } +#else + TRACELOG(LOG_WARNING, "FILEIO: [%s] Failed to load material file", fileName); +#endif + + *materialCount = count; + return materials; +} + +// Load default material (Supports: DIFFUSE, SPECULAR, NORMAL maps) +Material LoadMaterialDefault(void) +{ + Material material = { 0 }; + material.maps = (MaterialMap *)RL_CALLOC(MAX_MATERIAL_MAPS, sizeof(MaterialMap)); + + // Using rlgl default shader + material.shader.id = rlGetShaderIdDefault(); + material.shader.locs = rlGetShaderLocsDefault(); + + // Using rlgl default texture (1x1 pixel, UNCOMPRESSED_R8G8B8A8, 1 mipmap) + material.maps[MATERIAL_MAP_DIFFUSE].texture = (Texture2D){ rlGetTextureIdDefault(), 1, 1, 1, PIXELFORMAT_UNCOMPRESSED_R8G8B8A8 }; + //material.maps[MATERIAL_MAP_NORMAL].texture; // NOTE: By default, not set + //material.maps[MATERIAL_MAP_SPECULAR].texture; // NOTE: By default, not set + + material.maps[MATERIAL_MAP_DIFFUSE].color = WHITE; // Diffuse color + material.maps[MATERIAL_MAP_SPECULAR].color = WHITE; // Specular color + + return material; +} + +// Check if a material is ready +bool IsMaterialReady(Material material) +{ + bool result = false; + + if ((material.maps != NULL) && // Validate material contain some map + (material.shader.id > 0)) result = true; // Validate material shader is valid + + return result; +} + +// Unload material from memory +void UnloadMaterial(Material material) +{ + // Unload material shader (avoid unloading default shader, managed by raylib) + if (material.shader.id != rlGetShaderIdDefault()) UnloadShader(material.shader); + + // Unload loaded texture maps (avoid unloading default texture, managed by raylib) + if (material.maps != NULL) + { + for (int i = 0; i < MAX_MATERIAL_MAPS; i++) + { + if (material.maps[i].texture.id != rlGetTextureIdDefault()) rlUnloadTexture(material.maps[i].texture.id); + } + } + + RL_FREE(material.maps); +} + +// Set texture for a material map type (MATERIAL_MAP_DIFFUSE, MATERIAL_MAP_SPECULAR...) +// NOTE: Previous texture should be manually unloaded +void SetMaterialTexture(Material *material, int mapType, Texture2D texture) +{ + material->maps[mapType].texture = texture; +} + +// Set the material for a mesh +void SetModelMeshMaterial(Model *model, int meshId, int materialId) +{ + if (meshId >= model->meshCount) TRACELOG(LOG_WARNING, "MESH: Id greater than mesh count"); + else if (materialId >= model->materialCount) TRACELOG(LOG_WARNING, "MATERIAL: Id greater than material count"); + else model->meshMaterial[meshId] = materialId; +} + +// Load model animations from file +ModelAnimation *LoadModelAnimations(const char *fileName, int *animCount) +{ + ModelAnimation *animations = NULL; + +#if defined(SUPPORT_FILEFORMAT_IQM) + if (IsFileExtension(fileName, ".iqm")) animations = LoadModelAnimationsIQM(fileName, animCount); +#endif +#if defined(SUPPORT_FILEFORMAT_M3D) + if (IsFileExtension(fileName, ".m3d")) animations = LoadModelAnimationsM3D(fileName, animCount); +#endif +#if defined(SUPPORT_FILEFORMAT_GLTF) + if (IsFileExtension(fileName, ".gltf;.glb")) animations = LoadModelAnimationsGLTF(fileName, animCount); +#endif + + return animations; +} + +// Update model animated vertex data (positions and normals) for a given frame +// NOTE: Updated data is uploaded to GPU +void UpdateModelAnimation(Model model, ModelAnimation anim, int frame) +{ + if ((anim.frameCount > 0) && (anim.bones != NULL) && (anim.framePoses != NULL)) + { + if (frame >= anim.frameCount) frame = frame%anim.frameCount; + + for (int m = 0; m < model.meshCount; m++) + { + Mesh mesh = model.meshes[m]; + + if (mesh.boneIds == NULL || mesh.boneWeights == NULL) + { + TRACELOG(LOG_WARNING, "MODEL: UpdateModelAnimation(): Mesh %i has no connection to bones", m); + continue; + } + + bool updated = false; // Flag to check when anim vertex information is updated + Vector3 animVertex = { 0 }; + Vector3 animNormal = { 0 }; + + Vector3 inTranslation = { 0 }; + Quaternion inRotation = { 0 }; + // Vector3 inScale = { 0 }; + + Vector3 outTranslation = { 0 }; + Quaternion outRotation = { 0 }; + Vector3 outScale = { 0 }; + + int boneId = 0; + int boneCounter = 0; + float boneWeight = 0.0; + + const int vValues = mesh.vertexCount*3; + for (int vCounter = 0; vCounter < vValues; vCounter += 3) + { + mesh.animVertices[vCounter] = 0; + mesh.animVertices[vCounter + 1] = 0; + mesh.animVertices[vCounter + 2] = 0; + + if (mesh.animNormals != NULL) + { + mesh.animNormals[vCounter] = 0; + mesh.animNormals[vCounter + 1] = 0; + mesh.animNormals[vCounter + 2] = 0; + } + + // Iterates over 4 bones per vertex + for (int j = 0; j < 4; j++, boneCounter++) + { + boneWeight = mesh.boneWeights[boneCounter]; + + // Early stop when no transformation will be applied + if (boneWeight == 0.0f) continue; + + boneId = mesh.boneIds[boneCounter]; + //int boneIdParent = model.bones[boneId].parent; + inTranslation = model.bindPose[boneId].translation; + inRotation = model.bindPose[boneId].rotation; + //inScale = model.bindPose[boneId].scale; + outTranslation = anim.framePoses[frame][boneId].translation; + outRotation = anim.framePoses[frame][boneId].rotation; + outScale = anim.framePoses[frame][boneId].scale; + + // Vertices processing + // NOTE: We use meshes.vertices (default vertex position) to calculate meshes.animVertices (animated vertex position) + animVertex = (Vector3){ mesh.vertices[vCounter], mesh.vertices[vCounter + 1], mesh.vertices[vCounter + 2] }; + animVertex = Vector3Subtract(animVertex, inTranslation); + animVertex = Vector3Multiply(animVertex, outScale); + animVertex = Vector3RotateByQuaternion(animVertex, QuaternionMultiply(outRotation, QuaternionInvert(inRotation))); + animVertex = Vector3Add(animVertex, outTranslation); + //animVertex = Vector3Transform(animVertex, model.transform); + mesh.animVertices[vCounter] += animVertex.x*boneWeight; + mesh.animVertices[vCounter + 1] += animVertex.y*boneWeight; + mesh.animVertices[vCounter + 2] += animVertex.z*boneWeight; + updated = true; + + // Normals processing + // NOTE: We use meshes.baseNormals (default normal) to calculate meshes.normals (animated normals) + if (mesh.normals != NULL) + { + animNormal = (Vector3){ mesh.normals[vCounter], mesh.normals[vCounter + 1], mesh.normals[vCounter + 2] }; + animNormal = Vector3RotateByQuaternion(animNormal, QuaternionMultiply(outRotation, QuaternionInvert(inRotation))); + mesh.animNormals[vCounter] += animNormal.x*boneWeight; + mesh.animNormals[vCounter + 1] += animNormal.y*boneWeight; + mesh.animNormals[vCounter + 2] += animNormal.z*boneWeight; + } + } + } + + // Upload new vertex data to GPU for model drawing + // NOTE: Only update data when values changed + if (updated) + { + rlUpdateVertexBuffer(mesh.vboId[0], mesh.animVertices, mesh.vertexCount*3*sizeof(float), 0); // Update vertex position + rlUpdateVertexBuffer(mesh.vboId[2], mesh.animNormals, mesh.vertexCount*3*sizeof(float), 0); // Update vertex normals + } + } + } +} + +// Unload animation array data +void UnloadModelAnimations(ModelAnimation *animations, int animCount) +{ + for (int i = 0; i < animCount; i++) UnloadModelAnimation(animations[i]); + RL_FREE(animations); +} + +// Unload animation data +void UnloadModelAnimation(ModelAnimation anim) +{ + for (int i = 0; i < anim.frameCount; i++) RL_FREE(anim.framePoses[i]); + + RL_FREE(anim.bones); + RL_FREE(anim.framePoses); +} + +// Check model animation skeleton match +// NOTE: Only number of bones and parent connections are checked +bool IsModelAnimationValid(Model model, ModelAnimation anim) +{ + int result = true; + + if (model.boneCount != anim.boneCount) result = false; + else + { + for (int i = 0; i < model.boneCount; i++) + { + if (model.bones[i].parent != anim.bones[i].parent) { result = false; break; } + } + } + + return result; +} + +#if defined(SUPPORT_MESH_GENERATION) +// Generate polygonal mesh +Mesh GenMeshPoly(int sides, float radius) +{ + Mesh mesh = { 0 }; + + if (sides < 3) return mesh; // Security check + + int vertexCount = sides*3; + + // Vertices definition + Vector3 *vertices = (Vector3 *)RL_MALLOC(vertexCount*sizeof(Vector3)); + + float d = 0.0f, dStep = 360.0f/sides; + for (int v = 0; v < vertexCount - 2; v += 3) + { + vertices[v] = (Vector3){ 0.0f, 0.0f, 0.0f }; + vertices[v + 1] = (Vector3){ sinf(DEG2RAD*d)*radius, 0.0f, cosf(DEG2RAD*d)*radius }; + vertices[v + 2] = (Vector3){ sinf(DEG2RAD*(d+dStep))*radius, 0.0f, cosf(DEG2RAD*(d+dStep))*radius }; + d += dStep; + } + + // Normals definition + Vector3 *normals = (Vector3 *)RL_MALLOC(vertexCount*sizeof(Vector3)); + for (int n = 0; n < vertexCount; n++) normals[n] = (Vector3){ 0.0f, 1.0f, 0.0f }; // Vector3.up; + + // TexCoords definition + Vector2 *texcoords = (Vector2 *)RL_MALLOC(vertexCount*sizeof(Vector2)); + for (int n = 0; n < vertexCount; n++) texcoords[n] = (Vector2){ 0.0f, 0.0f }; + + mesh.vertexCount = vertexCount; + mesh.triangleCount = sides; + mesh.vertices = (float *)RL_MALLOC(mesh.vertexCount*3*sizeof(float)); + mesh.texcoords = (float *)RL_MALLOC(mesh.vertexCount*2*sizeof(float)); + mesh.normals = (float *)RL_MALLOC(mesh.vertexCount*3*sizeof(float)); + + // Mesh vertices position array + for (int i = 0; i < mesh.vertexCount; i++) + { + mesh.vertices[3*i] = vertices[i].x; + mesh.vertices[3*i + 1] = vertices[i].y; + mesh.vertices[3*i + 2] = vertices[i].z; + } + + // Mesh texcoords array + for (int i = 0; i < mesh.vertexCount; i++) + { + mesh.texcoords[2*i] = texcoords[i].x; + mesh.texcoords[2*i + 1] = texcoords[i].y; + } + + // Mesh normals array + for (int i = 0; i < mesh.vertexCount; i++) + { + mesh.normals[3*i] = normals[i].x; + mesh.normals[3*i + 1] = normals[i].y; + mesh.normals[3*i + 2] = normals[i].z; + } + + RL_FREE(vertices); + RL_FREE(normals); + RL_FREE(texcoords); + + // Upload vertex data to GPU (static mesh) + // NOTE: mesh.vboId array is allocated inside UploadMesh() + UploadMesh(&mesh, false); + + return mesh; +} + +// Generate plane mesh (with subdivisions) +Mesh GenMeshPlane(float width, float length, int resX, int resZ) +{ + Mesh mesh = { 0 }; + +#define CUSTOM_MESH_GEN_PLANE +#if defined(CUSTOM_MESH_GEN_PLANE) + resX++; + resZ++; + + // Vertices definition + int vertexCount = resX*resZ; // vertices get reused for the faces + + Vector3 *vertices = (Vector3 *)RL_MALLOC(vertexCount*sizeof(Vector3)); + for (int z = 0; z < resZ; z++) + { + // [-length/2, length/2] + float zPos = ((float)z/(resZ - 1) - 0.5f)*length; + for (int x = 0; x < resX; x++) + { + // [-width/2, width/2] + float xPos = ((float)x/(resX - 1) - 0.5f)*width; + vertices[x + z*resX] = (Vector3){ xPos, 0.0f, zPos }; + } + } + + // Normals definition + Vector3 *normals = (Vector3 *)RL_MALLOC(vertexCount*sizeof(Vector3)); + for (int n = 0; n < vertexCount; n++) normals[n] = (Vector3){ 0.0f, 1.0f, 0.0f }; // Vector3.up; + + // TexCoords definition + Vector2 *texcoords = (Vector2 *)RL_MALLOC(vertexCount*sizeof(Vector2)); + for (int v = 0; v < resZ; v++) + { + for (int u = 0; u < resX; u++) + { + texcoords[u + v*resX] = (Vector2){ (float)u/(resX - 1), (float)v/(resZ - 1) }; + } + } + + // Triangles definition (indices) + int numFaces = (resX - 1)*(resZ - 1); + int *triangles = (int *)RL_MALLOC(numFaces*6*sizeof(int)); + int t = 0; + for (int face = 0; face < numFaces; face++) + { + // Retrieve lower left corner from face ind + int i = face + face/(resX - 1); + + triangles[t++] = i + resX; + triangles[t++] = i + 1; + triangles[t++] = i; + + triangles[t++] = i + resX; + triangles[t++] = i + resX + 1; + triangles[t++] = i + 1; + } + + mesh.vertexCount = vertexCount; + mesh.triangleCount = numFaces*2; + mesh.vertices = (float *)RL_MALLOC(mesh.vertexCount*3*sizeof(float)); + mesh.texcoords = (float *)RL_MALLOC(mesh.vertexCount*2*sizeof(float)); + mesh.normals = (float *)RL_MALLOC(mesh.vertexCount*3*sizeof(float)); + mesh.indices = (unsigned short *)RL_MALLOC(mesh.triangleCount*3*sizeof(unsigned short)); + + // Mesh vertices position array + for (int i = 0; i < mesh.vertexCount; i++) + { + mesh.vertices[3*i] = vertices[i].x; + mesh.vertices[3*i + 1] = vertices[i].y; + mesh.vertices[3*i + 2] = vertices[i].z; + } + + // Mesh texcoords array + for (int i = 0; i < mesh.vertexCount; i++) + { + mesh.texcoords[2*i] = texcoords[i].x; + mesh.texcoords[2*i + 1] = texcoords[i].y; + } + + // Mesh normals array + for (int i = 0; i < mesh.vertexCount; i++) + { + mesh.normals[3*i] = normals[i].x; + mesh.normals[3*i + 1] = normals[i].y; + mesh.normals[3*i + 2] = normals[i].z; + } + + // Mesh indices array initialization + for (int i = 0; i < mesh.triangleCount*3; i++) mesh.indices[i] = triangles[i]; + + RL_FREE(vertices); + RL_FREE(normals); + RL_FREE(texcoords); + RL_FREE(triangles); + +#else // Use par_shapes library to generate plane mesh + + par_shapes_mesh *plane = par_shapes_create_plane(resX, resZ); // No normals/texcoords generated!!! + par_shapes_scale(plane, width, length, 1.0f); + par_shapes_rotate(plane, -PI/2.0f, (float[]){ 1, 0, 0 }); + par_shapes_translate(plane, -width/2, 0.0f, length/2); + + mesh.vertices = (float *)RL_MALLOC(plane->ntriangles*3*3*sizeof(float)); + mesh.texcoords = (float *)RL_MALLOC(plane->ntriangles*3*2*sizeof(float)); + mesh.normals = (float *)RL_MALLOC(plane->ntriangles*3*3*sizeof(float)); + + mesh.vertexCount = plane->ntriangles*3; + mesh.triangleCount = plane->ntriangles; + + for (int k = 0; k < mesh.vertexCount; k++) + { + mesh.vertices[k*3] = plane->points[plane->triangles[k]*3]; + mesh.vertices[k*3 + 1] = plane->points[plane->triangles[k]*3 + 1]; + mesh.vertices[k*3 + 2] = plane->points[plane->triangles[k]*3 + 2]; + + mesh.normals[k*3] = plane->normals[plane->triangles[k]*3]; + mesh.normals[k*3 + 1] = plane->normals[plane->triangles[k]*3 + 1]; + mesh.normals[k*3 + 2] = plane->normals[plane->triangles[k]*3 + 2]; + + mesh.texcoords[k*2] = plane->tcoords[plane->triangles[k]*2]; + mesh.texcoords[k*2 + 1] = plane->tcoords[plane->triangles[k]*2 + 1]; + } + + par_shapes_free_mesh(plane); +#endif + + // Upload vertex data to GPU (static mesh) + UploadMesh(&mesh, false); + + return mesh; +} + +// Generated cuboid mesh +Mesh GenMeshCube(float width, float height, float length) +{ + Mesh mesh = { 0 }; + +#define CUSTOM_MESH_GEN_CUBE +#if defined(CUSTOM_MESH_GEN_CUBE) + float vertices[] = { + -width/2, -height/2, length/2, + width/2, -height/2, length/2, + width/2, height/2, length/2, + -width/2, height/2, length/2, + -width/2, -height/2, -length/2, + -width/2, height/2, -length/2, + width/2, height/2, -length/2, + width/2, -height/2, -length/2, + -width/2, height/2, -length/2, + -width/2, height/2, length/2, + width/2, height/2, length/2, + width/2, height/2, -length/2, + -width/2, -height/2, -length/2, + width/2, -height/2, -length/2, + width/2, -height/2, length/2, + -width/2, -height/2, length/2, + width/2, -height/2, -length/2, + width/2, height/2, -length/2, + width/2, height/2, length/2, + width/2, -height/2, length/2, + -width/2, -height/2, -length/2, + -width/2, -height/2, length/2, + -width/2, height/2, length/2, + -width/2, height/2, -length/2 + }; + + float texcoords[] = { + 0.0f, 0.0f, + 1.0f, 0.0f, + 1.0f, 1.0f, + 0.0f, 1.0f, + 1.0f, 0.0f, + 1.0f, 1.0f, + 0.0f, 1.0f, + 0.0f, 0.0f, + 0.0f, 1.0f, + 0.0f, 0.0f, + 1.0f, 0.0f, + 1.0f, 1.0f, + 1.0f, 1.0f, + 0.0f, 1.0f, + 0.0f, 0.0f, + 1.0f, 0.0f, + 1.0f, 0.0f, + 1.0f, 1.0f, + 0.0f, 1.0f, + 0.0f, 0.0f, + 0.0f, 0.0f, + 1.0f, 0.0f, + 1.0f, 1.0f, + 0.0f, 1.0f + }; + + float normals[] = { + 0.0f, 0.0f, 1.0f, + 0.0f, 0.0f, 1.0f, + 0.0f, 0.0f, 1.0f, + 0.0f, 0.0f, 1.0f, + 0.0f, 0.0f,-1.0f, + 0.0f, 0.0f,-1.0f, + 0.0f, 0.0f,-1.0f, + 0.0f, 0.0f,-1.0f, + 0.0f, 1.0f, 0.0f, + 0.0f, 1.0f, 0.0f, + 0.0f, 1.0f, 0.0f, + 0.0f, 1.0f, 0.0f, + 0.0f,-1.0f, 0.0f, + 0.0f,-1.0f, 0.0f, + 0.0f,-1.0f, 0.0f, + 0.0f,-1.0f, 0.0f, + 1.0f, 0.0f, 0.0f, + 1.0f, 0.0f, 0.0f, + 1.0f, 0.0f, 0.0f, + 1.0f, 0.0f, 0.0f, + -1.0f, 0.0f, 0.0f, + -1.0f, 0.0f, 0.0f, + -1.0f, 0.0f, 0.0f, + -1.0f, 0.0f, 0.0f + }; + + mesh.vertices = (float *)RL_MALLOC(24*3*sizeof(float)); + memcpy(mesh.vertices, vertices, 24*3*sizeof(float)); + + mesh.texcoords = (float *)RL_MALLOC(24*2*sizeof(float)); + memcpy(mesh.texcoords, texcoords, 24*2*sizeof(float)); + + mesh.normals = (float *)RL_MALLOC(24*3*sizeof(float)); + memcpy(mesh.normals, normals, 24*3*sizeof(float)); + + mesh.indices = (unsigned short *)RL_MALLOC(36*sizeof(unsigned short)); + + int k = 0; + + // Indices can be initialized right now + for (int i = 0; i < 36; i += 6) + { + mesh.indices[i] = 4*k; + mesh.indices[i + 1] = 4*k + 1; + mesh.indices[i + 2] = 4*k + 2; + mesh.indices[i + 3] = 4*k; + mesh.indices[i + 4] = 4*k + 2; + mesh.indices[i + 5] = 4*k + 3; + + k++; + } + + mesh.vertexCount = 24; + mesh.triangleCount = 12; + +#else // Use par_shapes library to generate cube mesh +/* +// Platonic solids: +par_shapes_mesh* par_shapes_create_tetrahedron(); // 4 sides polyhedron (pyramid) +par_shapes_mesh* par_shapes_create_cube(); // 6 sides polyhedron (cube) +par_shapes_mesh* par_shapes_create_octahedron(); // 8 sides polyhedron (diamond) +par_shapes_mesh* par_shapes_create_dodecahedron(); // 12 sides polyhedron +par_shapes_mesh* par_shapes_create_icosahedron(); // 20 sides polyhedron +*/ + // Platonic solid generation: cube (6 sides) + // NOTE: No normals/texcoords generated by default + par_shapes_mesh *cube = par_shapes_create_cube(); + cube->tcoords = PAR_MALLOC(float, 2*cube->npoints); + for (int i = 0; i < 2*cube->npoints; i++) cube->tcoords[i] = 0.0f; + par_shapes_scale(cube, width, height, length); + par_shapes_translate(cube, -width/2, 0.0f, -length/2); + par_shapes_compute_normals(cube); + + mesh.vertices = (float *)RL_MALLOC(cube->ntriangles*3*3*sizeof(float)); + mesh.texcoords = (float *)RL_MALLOC(cube->ntriangles*3*2*sizeof(float)); + mesh.normals = (float *)RL_MALLOC(cube->ntriangles*3*3*sizeof(float)); + + mesh.vertexCount = cube->ntriangles*3; + mesh.triangleCount = cube->ntriangles; + + for (int k = 0; k < mesh.vertexCount; k++) + { + mesh.vertices[k*3] = cube->points[cube->triangles[k]*3]; + mesh.vertices[k*3 + 1] = cube->points[cube->triangles[k]*3 + 1]; + mesh.vertices[k*3 + 2] = cube->points[cube->triangles[k]*3 + 2]; + + mesh.normals[k*3] = cube->normals[cube->triangles[k]*3]; + mesh.normals[k*3 + 1] = cube->normals[cube->triangles[k]*3 + 1]; + mesh.normals[k*3 + 2] = cube->normals[cube->triangles[k]*3 + 2]; + + mesh.texcoords[k*2] = cube->tcoords[cube->triangles[k]*2]; + mesh.texcoords[k*2 + 1] = cube->tcoords[cube->triangles[k]*2 + 1]; + } + + par_shapes_free_mesh(cube); +#endif + + // Upload vertex data to GPU (static mesh) + UploadMesh(&mesh, false); + + return mesh; +} + +// Generate sphere mesh (standard sphere) +Mesh GenMeshSphere(float radius, int rings, int slices) +{ + Mesh mesh = { 0 }; + + if ((rings >= 3) && (slices >= 3)) + { + par_shapes_mesh *sphere = par_shapes_create_parametric_sphere(slices, rings); + par_shapes_scale(sphere, radius, radius, radius); + // NOTE: Soft normals are computed internally + + mesh.vertices = (float *)RL_MALLOC(sphere->ntriangles*3*3*sizeof(float)); + mesh.texcoords = (float *)RL_MALLOC(sphere->ntriangles*3*2*sizeof(float)); + mesh.normals = (float *)RL_MALLOC(sphere->ntriangles*3*3*sizeof(float)); + + mesh.vertexCount = sphere->ntriangles*3; + mesh.triangleCount = sphere->ntriangles; + + for (int k = 0; k < mesh.vertexCount; k++) + { + mesh.vertices[k*3] = sphere->points[sphere->triangles[k]*3]; + mesh.vertices[k*3 + 1] = sphere->points[sphere->triangles[k]*3 + 1]; + mesh.vertices[k*3 + 2] = sphere->points[sphere->triangles[k]*3 + 2]; + + mesh.normals[k*3] = sphere->normals[sphere->triangles[k]*3]; + mesh.normals[k*3 + 1] = sphere->normals[sphere->triangles[k]*3 + 1]; + mesh.normals[k*3 + 2] = sphere->normals[sphere->triangles[k]*3 + 2]; + + mesh.texcoords[k*2] = sphere->tcoords[sphere->triangles[k]*2]; + mesh.texcoords[k*2 + 1] = sphere->tcoords[sphere->triangles[k]*2 + 1]; + } + + par_shapes_free_mesh(sphere); + + // Upload vertex data to GPU (static mesh) + UploadMesh(&mesh, false); + } + else TRACELOG(LOG_WARNING, "MESH: Failed to generate mesh: sphere"); + + return mesh; +} + +// Generate hemisphere mesh (half sphere, no bottom cap) +Mesh GenMeshHemiSphere(float radius, int rings, int slices) +{ + Mesh mesh = { 0 }; + + if ((rings >= 3) && (slices >= 3)) + { + if (radius < 0.0f) radius = 0.0f; + + par_shapes_mesh *sphere = par_shapes_create_hemisphere(slices, rings); + par_shapes_scale(sphere, radius, radius, radius); + // NOTE: Soft normals are computed internally + + mesh.vertices = (float *)RL_MALLOC(sphere->ntriangles*3*3*sizeof(float)); + mesh.texcoords = (float *)RL_MALLOC(sphere->ntriangles*3*2*sizeof(float)); + mesh.normals = (float *)RL_MALLOC(sphere->ntriangles*3*3*sizeof(float)); + + mesh.vertexCount = sphere->ntriangles*3; + mesh.triangleCount = sphere->ntriangles; + + for (int k = 0; k < mesh.vertexCount; k++) + { + mesh.vertices[k*3] = sphere->points[sphere->triangles[k]*3]; + mesh.vertices[k*3 + 1] = sphere->points[sphere->triangles[k]*3 + 1]; + mesh.vertices[k*3 + 2] = sphere->points[sphere->triangles[k]*3 + 2]; + + mesh.normals[k*3] = sphere->normals[sphere->triangles[k]*3]; + mesh.normals[k*3 + 1] = sphere->normals[sphere->triangles[k]*3 + 1]; + mesh.normals[k*3 + 2] = sphere->normals[sphere->triangles[k]*3 + 2]; + + mesh.texcoords[k*2] = sphere->tcoords[sphere->triangles[k]*2]; + mesh.texcoords[k*2 + 1] = sphere->tcoords[sphere->triangles[k]*2 + 1]; + } + + par_shapes_free_mesh(sphere); + + // Upload vertex data to GPU (static mesh) + UploadMesh(&mesh, false); + } + else TRACELOG(LOG_WARNING, "MESH: Failed to generate mesh: hemisphere"); + + return mesh; +} + +// Generate cylinder mesh +Mesh GenMeshCylinder(float radius, float height, int slices) +{ + Mesh mesh = { 0 }; + + if (slices >= 3) + { + // Instance a cylinder that sits on the Z=0 plane using the given tessellation + // levels across the UV domain. Think of "slices" like a number of pizza + // slices, and "stacks" like a number of stacked rings + // Height and radius are both 1.0, but they can easily be changed with par_shapes_scale + par_shapes_mesh *cylinder = par_shapes_create_cylinder(slices, 8); + par_shapes_scale(cylinder, radius, radius, height); + par_shapes_rotate(cylinder, -PI/2.0f, (float[]){ 1, 0, 0 }); + + // Generate an orientable disk shape (top cap) + par_shapes_mesh *capTop = par_shapes_create_disk(radius, slices, (float[]){ 0, 0, 0 }, (float[]){ 0, 0, 1 }); + capTop->tcoords = PAR_MALLOC(float, 2*capTop->npoints); + for (int i = 0; i < 2*capTop->npoints; i++) capTop->tcoords[i] = 0.0f; + par_shapes_rotate(capTop, -PI/2.0f, (float[]){ 1, 0, 0 }); + par_shapes_rotate(capTop, 90*DEG2RAD, (float[]){ 0, 1, 0 }); + par_shapes_translate(capTop, 0, height, 0); + + // Generate an orientable disk shape (bottom cap) + par_shapes_mesh *capBottom = par_shapes_create_disk(radius, slices, (float[]){ 0, 0, 0 }, (float[]){ 0, 0, -1 }); + capBottom->tcoords = PAR_MALLOC(float, 2*capBottom->npoints); + for (int i = 0; i < 2*capBottom->npoints; i++) capBottom->tcoords[i] = 0.95f; + par_shapes_rotate(capBottom, PI/2.0f, (float[]){ 1, 0, 0 }); + par_shapes_rotate(capBottom, -90*DEG2RAD, (float[]){ 0, 1, 0 }); + + par_shapes_merge_and_free(cylinder, capTop); + par_shapes_merge_and_free(cylinder, capBottom); + + mesh.vertices = (float *)RL_MALLOC(cylinder->ntriangles*3*3*sizeof(float)); + mesh.texcoords = (float *)RL_MALLOC(cylinder->ntriangles*3*2*sizeof(float)); + mesh.normals = (float *)RL_MALLOC(cylinder->ntriangles*3*3*sizeof(float)); + + mesh.vertexCount = cylinder->ntriangles*3; + mesh.triangleCount = cylinder->ntriangles; + + for (int k = 0; k < mesh.vertexCount; k++) + { + mesh.vertices[k*3] = cylinder->points[cylinder->triangles[k]*3]; + mesh.vertices[k*3 + 1] = cylinder->points[cylinder->triangles[k]*3 + 1]; + mesh.vertices[k*3 + 2] = cylinder->points[cylinder->triangles[k]*3 + 2]; + + mesh.normals[k*3] = cylinder->normals[cylinder->triangles[k]*3]; + mesh.normals[k*3 + 1] = cylinder->normals[cylinder->triangles[k]*3 + 1]; + mesh.normals[k*3 + 2] = cylinder->normals[cylinder->triangles[k]*3 + 2]; + + mesh.texcoords[k*2] = cylinder->tcoords[cylinder->triangles[k]*2]; + mesh.texcoords[k*2 + 1] = cylinder->tcoords[cylinder->triangles[k]*2 + 1]; + } + + par_shapes_free_mesh(cylinder); + + // Upload vertex data to GPU (static mesh) + UploadMesh(&mesh, false); + } + else TRACELOG(LOG_WARNING, "MESH: Failed to generate mesh: cylinder"); + + return mesh; +} + +// Generate cone/pyramid mesh +Mesh GenMeshCone(float radius, float height, int slices) +{ + Mesh mesh = { 0 }; + + if (slices >= 3) + { + // Instance a cone that sits on the Z=0 plane using the given tessellation + // levels across the UV domain. Think of "slices" like a number of pizza + // slices, and "stacks" like a number of stacked rings + // Height and radius are both 1.0, but they can easily be changed with par_shapes_scale + par_shapes_mesh *cone = par_shapes_create_cone(slices, 8); + par_shapes_scale(cone, radius, radius, height); + par_shapes_rotate(cone, -PI/2.0f, (float[]){ 1, 0, 0 }); + par_shapes_rotate(cone, PI/2.0f, (float[]){ 0, 1, 0 }); + + // Generate an orientable disk shape (bottom cap) + par_shapes_mesh *capBottom = par_shapes_create_disk(radius, slices, (float[]){ 0, 0, 0 }, (float[]){ 0, 0, -1 }); + capBottom->tcoords = PAR_MALLOC(float, 2*capBottom->npoints); + for (int i = 0; i < 2*capBottom->npoints; i++) capBottom->tcoords[i] = 0.95f; + par_shapes_rotate(capBottom, PI/2.0f, (float[]){ 1, 0, 0 }); + + par_shapes_merge_and_free(cone, capBottom); + + mesh.vertices = (float *)RL_MALLOC(cone->ntriangles*3*3*sizeof(float)); + mesh.texcoords = (float *)RL_MALLOC(cone->ntriangles*3*2*sizeof(float)); + mesh.normals = (float *)RL_MALLOC(cone->ntriangles*3*3*sizeof(float)); + + mesh.vertexCount = cone->ntriangles*3; + mesh.triangleCount = cone->ntriangles; + + for (int k = 0; k < mesh.vertexCount; k++) + { + mesh.vertices[k*3] = cone->points[cone->triangles[k]*3]; + mesh.vertices[k*3 + 1] = cone->points[cone->triangles[k]*3 + 1]; + mesh.vertices[k*3 + 2] = cone->points[cone->triangles[k]*3 + 2]; + + mesh.normals[k*3] = cone->normals[cone->triangles[k]*3]; + mesh.normals[k*3 + 1] = cone->normals[cone->triangles[k]*3 + 1]; + mesh.normals[k*3 + 2] = cone->normals[cone->triangles[k]*3 + 2]; + + mesh.texcoords[k*2] = cone->tcoords[cone->triangles[k]*2]; + mesh.texcoords[k*2 + 1] = cone->tcoords[cone->triangles[k]*2 + 1]; + } + + par_shapes_free_mesh(cone); + + // Upload vertex data to GPU (static mesh) + UploadMesh(&mesh, false); + } + else TRACELOG(LOG_WARNING, "MESH: Failed to generate mesh: cone"); + + return mesh; +} + +// Generate torus mesh +Mesh GenMeshTorus(float radius, float size, int radSeg, int sides) +{ + Mesh mesh = { 0 }; + + if ((sides >= 3) && (radSeg >= 3)) + { + if (radius > 1.0f) radius = 1.0f; + else if (radius < 0.1f) radius = 0.1f; + + // Create a donut that sits on the Z=0 plane with the specified inner radius + // The outer radius can be controlled with par_shapes_scale + par_shapes_mesh *torus = par_shapes_create_torus(radSeg, sides, radius); + par_shapes_scale(torus, size/2, size/2, size/2); + + mesh.vertices = (float *)RL_MALLOC(torus->ntriangles*3*3*sizeof(float)); + mesh.texcoords = (float *)RL_MALLOC(torus->ntriangles*3*2*sizeof(float)); + mesh.normals = (float *)RL_MALLOC(torus->ntriangles*3*3*sizeof(float)); + + mesh.vertexCount = torus->ntriangles*3; + mesh.triangleCount = torus->ntriangles; + + for (int k = 0; k < mesh.vertexCount; k++) + { + mesh.vertices[k*3] = torus->points[torus->triangles[k]*3]; + mesh.vertices[k*3 + 1] = torus->points[torus->triangles[k]*3 + 1]; + mesh.vertices[k*3 + 2] = torus->points[torus->triangles[k]*3 + 2]; + + mesh.normals[k*3] = torus->normals[torus->triangles[k]*3]; + mesh.normals[k*3 + 1] = torus->normals[torus->triangles[k]*3 + 1]; + mesh.normals[k*3 + 2] = torus->normals[torus->triangles[k]*3 + 2]; + + mesh.texcoords[k*2] = torus->tcoords[torus->triangles[k]*2]; + mesh.texcoords[k*2 + 1] = torus->tcoords[torus->triangles[k]*2 + 1]; + } + + par_shapes_free_mesh(torus); + + // Upload vertex data to GPU (static mesh) + UploadMesh(&mesh, false); + } + else TRACELOG(LOG_WARNING, "MESH: Failed to generate mesh: torus"); + + return mesh; +} + +// Generate trefoil knot mesh +Mesh GenMeshKnot(float radius, float size, int radSeg, int sides) +{ + Mesh mesh = { 0 }; + + if ((sides >= 3) && (radSeg >= 3)) + { + if (radius > 3.0f) radius = 3.0f; + else if (radius < 0.5f) radius = 0.5f; + + par_shapes_mesh *knot = par_shapes_create_trefoil_knot(radSeg, sides, radius); + par_shapes_scale(knot, size, size, size); + + mesh.vertices = (float *)RL_MALLOC(knot->ntriangles*3*3*sizeof(float)); + mesh.texcoords = (float *)RL_MALLOC(knot->ntriangles*3*2*sizeof(float)); + mesh.normals = (float *)RL_MALLOC(knot->ntriangles*3*3*sizeof(float)); + + mesh.vertexCount = knot->ntriangles*3; + mesh.triangleCount = knot->ntriangles; + + for (int k = 0; k < mesh.vertexCount; k++) + { + mesh.vertices[k*3] = knot->points[knot->triangles[k]*3]; + mesh.vertices[k*3 + 1] = knot->points[knot->triangles[k]*3 + 1]; + mesh.vertices[k*3 + 2] = knot->points[knot->triangles[k]*3 + 2]; + + mesh.normals[k*3] = knot->normals[knot->triangles[k]*3]; + mesh.normals[k*3 + 1] = knot->normals[knot->triangles[k]*3 + 1]; + mesh.normals[k*3 + 2] = knot->normals[knot->triangles[k]*3 + 2]; + + mesh.texcoords[k*2] = knot->tcoords[knot->triangles[k]*2]; + mesh.texcoords[k*2 + 1] = knot->tcoords[knot->triangles[k]*2 + 1]; + } + + par_shapes_free_mesh(knot); + + // Upload vertex data to GPU (static mesh) + UploadMesh(&mesh, false); + } + else TRACELOG(LOG_WARNING, "MESH: Failed to generate mesh: knot"); + + return mesh; +} + +// Generate a mesh from heightmap +// NOTE: Vertex data is uploaded to GPU +Mesh GenMeshHeightmap(Image heightmap, Vector3 size) +{ + #define GRAY_VALUE(c) ((float)(c.r + c.g + c.b)/3.0f) + + Mesh mesh = { 0 }; + + int mapX = heightmap.width; + int mapZ = heightmap.height; + + Color *pixels = LoadImageColors(heightmap); + + // NOTE: One vertex per pixel + mesh.triangleCount = (mapX - 1)*(mapZ - 1)*2; // One quad every four pixels + + mesh.vertexCount = mesh.triangleCount*3; + + mesh.vertices = (float *)RL_MALLOC(mesh.vertexCount*3*sizeof(float)); + mesh.normals = (float *)RL_MALLOC(mesh.vertexCount*3*sizeof(float)); + mesh.texcoords = (float *)RL_MALLOC(mesh.vertexCount*2*sizeof(float)); + mesh.colors = NULL; + + int vCounter = 0; // Used to count vertices float by float + int tcCounter = 0; // Used to count texcoords float by float + int nCounter = 0; // Used to count normals float by float + + Vector3 scaleFactor = { size.x/(mapX - 1), size.y/255.0f, size.z/(mapZ - 1) }; + + Vector3 vA = { 0 }; + Vector3 vB = { 0 }; + Vector3 vC = { 0 }; + Vector3 vN = { 0 }; + + for (int z = 0; z < mapZ-1; z++) + { + for (int x = 0; x < mapX-1; x++) + { + // Fill vertices array with data + //---------------------------------------------------------- + + // one triangle - 3 vertex + mesh.vertices[vCounter] = (float)x*scaleFactor.x; + mesh.vertices[vCounter + 1] = GRAY_VALUE(pixels[x + z*mapX])*scaleFactor.y; + mesh.vertices[vCounter + 2] = (float)z*scaleFactor.z; + + mesh.vertices[vCounter + 3] = (float)x*scaleFactor.x; + mesh.vertices[vCounter + 4] = GRAY_VALUE(pixels[x + (z + 1)*mapX])*scaleFactor.y; + mesh.vertices[vCounter + 5] = (float)(z + 1)*scaleFactor.z; + + mesh.vertices[vCounter + 6] = (float)(x + 1)*scaleFactor.x; + mesh.vertices[vCounter + 7] = GRAY_VALUE(pixels[(x + 1) + z*mapX])*scaleFactor.y; + mesh.vertices[vCounter + 8] = (float)z*scaleFactor.z; + + // Another triangle - 3 vertex + mesh.vertices[vCounter + 9] = mesh.vertices[vCounter + 6]; + mesh.vertices[vCounter + 10] = mesh.vertices[vCounter + 7]; + mesh.vertices[vCounter + 11] = mesh.vertices[vCounter + 8]; + + mesh.vertices[vCounter + 12] = mesh.vertices[vCounter + 3]; + mesh.vertices[vCounter + 13] = mesh.vertices[vCounter + 4]; + mesh.vertices[vCounter + 14] = mesh.vertices[vCounter + 5]; + + mesh.vertices[vCounter + 15] = (float)(x + 1)*scaleFactor.x; + mesh.vertices[vCounter + 16] = GRAY_VALUE(pixels[(x + 1) + (z + 1)*mapX])*scaleFactor.y; + mesh.vertices[vCounter + 17] = (float)(z + 1)*scaleFactor.z; + vCounter += 18; // 6 vertex, 18 floats + + // Fill texcoords array with data + //-------------------------------------------------------------- + mesh.texcoords[tcCounter] = (float)x/(mapX - 1); + mesh.texcoords[tcCounter + 1] = (float)z/(mapZ - 1); + + mesh.texcoords[tcCounter + 2] = (float)x/(mapX - 1); + mesh.texcoords[tcCounter + 3] = (float)(z + 1)/(mapZ - 1); + + mesh.texcoords[tcCounter + 4] = (float)(x + 1)/(mapX - 1); + mesh.texcoords[tcCounter + 5] = (float)z/(mapZ - 1); + + mesh.texcoords[tcCounter + 6] = mesh.texcoords[tcCounter + 4]; + mesh.texcoords[tcCounter + 7] = mesh.texcoords[tcCounter + 5]; + + mesh.texcoords[tcCounter + 8] = mesh.texcoords[tcCounter + 2]; + mesh.texcoords[tcCounter + 9] = mesh.texcoords[tcCounter + 3]; + + mesh.texcoords[tcCounter + 10] = (float)(x + 1)/(mapX - 1); + mesh.texcoords[tcCounter + 11] = (float)(z + 1)/(mapZ - 1); + tcCounter += 12; // 6 texcoords, 12 floats + + // Fill normals array with data + //-------------------------------------------------------------- + for (int i = 0; i < 18; i += 9) + { + vA.x = mesh.vertices[nCounter + i]; + vA.y = mesh.vertices[nCounter + i + 1]; + vA.z = mesh.vertices[nCounter + i + 2]; + + vB.x = mesh.vertices[nCounter + i + 3]; + vB.y = mesh.vertices[nCounter + i + 4]; + vB.z = mesh.vertices[nCounter + i + 5]; + + vC.x = mesh.vertices[nCounter + i + 6]; + vC.y = mesh.vertices[nCounter + i + 7]; + vC.z = mesh.vertices[nCounter + i + 8]; + + vN = Vector3Normalize(Vector3CrossProduct(Vector3Subtract(vB, vA), Vector3Subtract(vC, vA))); + + mesh.normals[nCounter + i] = vN.x; + mesh.normals[nCounter + i + 1] = vN.y; + mesh.normals[nCounter + i + 2] = vN.z; + + mesh.normals[nCounter + i + 3] = vN.x; + mesh.normals[nCounter + i + 4] = vN.y; + mesh.normals[nCounter + i + 5] = vN.z; + + mesh.normals[nCounter + i + 6] = vN.x; + mesh.normals[nCounter + i + 7] = vN.y; + mesh.normals[nCounter + i + 8] = vN.z; + } + + nCounter += 18; // 6 vertex, 18 floats + } + } + + UnloadImageColors(pixels); // Unload pixels color data + + // Upload vertex data to GPU (static mesh) + UploadMesh(&mesh, false); + + return mesh; +} + +// Generate a cubes mesh from pixel data +// NOTE: Vertex data is uploaded to GPU +Mesh GenMeshCubicmap(Image cubicmap, Vector3 cubeSize) +{ + #define COLOR_EQUAL(col1, col2) ((col1.r == col2.r)&&(col1.g == col2.g)&&(col1.b == col2.b)&&(col1.a == col2.a)) + + Mesh mesh = { 0 }; + + Color *pixels = LoadImageColors(cubicmap); + + // NOTE: Max possible number of triangles numCubes*(12 triangles by cube) + int maxTriangles = cubicmap.width*cubicmap.height*12; + + int vCounter = 0; // Used to count vertices + int tcCounter = 0; // Used to count texcoords + int nCounter = 0; // Used to count normals + + float w = cubeSize.x; + float h = cubeSize.z; + float h2 = cubeSize.y; + + Vector3 *mapVertices = (Vector3 *)RL_MALLOC(maxTriangles*3*sizeof(Vector3)); + Vector2 *mapTexcoords = (Vector2 *)RL_MALLOC(maxTriangles*3*sizeof(Vector2)); + Vector3 *mapNormals = (Vector3 *)RL_MALLOC(maxTriangles*3*sizeof(Vector3)); + + // Define the 6 normals of the cube, we will combine them accordingly later... + Vector3 n1 = { 1.0f, 0.0f, 0.0f }; + Vector3 n2 = { -1.0f, 0.0f, 0.0f }; + Vector3 n3 = { 0.0f, 1.0f, 0.0f }; + Vector3 n4 = { 0.0f, -1.0f, 0.0f }; + Vector3 n5 = { 0.0f, 0.0f, -1.0f }; + Vector3 n6 = { 0.0f, 0.0f, 1.0f }; + + // NOTE: We use texture rectangles to define different textures for top-bottom-front-back-right-left (6) + typedef struct RectangleF { + float x; + float y; + float width; + float height; + } RectangleF; + + RectangleF rightTexUV = { 0.0f, 0.0f, 0.5f, 0.5f }; + RectangleF leftTexUV = { 0.5f, 0.0f, 0.5f, 0.5f }; + RectangleF frontTexUV = { 0.0f, 0.0f, 0.5f, 0.5f }; + RectangleF backTexUV = { 0.5f, 0.0f, 0.5f, 0.5f }; + RectangleF topTexUV = { 0.0f, 0.5f, 0.5f, 0.5f }; + RectangleF bottomTexUV = { 0.5f, 0.5f, 0.5f, 0.5f }; + + for (int z = 0; z < cubicmap.height; ++z) + { + for (int x = 0; x < cubicmap.width; ++x) + { + // Define the 8 vertex of the cube, we will combine them accordingly later... + Vector3 v1 = { w*(x - 0.5f), h2, h*(z - 0.5f) }; + Vector3 v2 = { w*(x - 0.5f), h2, h*(z + 0.5f) }; + Vector3 v3 = { w*(x + 0.5f), h2, h*(z + 0.5f) }; + Vector3 v4 = { w*(x + 0.5f), h2, h*(z - 0.5f) }; + Vector3 v5 = { w*(x + 0.5f), 0, h*(z - 0.5f) }; + Vector3 v6 = { w*(x - 0.5f), 0, h*(z - 0.5f) }; + Vector3 v7 = { w*(x - 0.5f), 0, h*(z + 0.5f) }; + Vector3 v8 = { w*(x + 0.5f), 0, h*(z + 0.5f) }; + + // We check pixel color to be WHITE -> draw full cube + if (COLOR_EQUAL(pixels[z*cubicmap.width + x], WHITE)) + { + // Define triangles and checking collateral cubes + //------------------------------------------------ + + // Define top triangles (2 tris, 6 vertex --> v1-v2-v3, v1-v3-v4) + // WARNING: Not required for a WHITE cubes, created to allow seeing the map from outside + mapVertices[vCounter] = v1; + mapVertices[vCounter + 1] = v2; + mapVertices[vCounter + 2] = v3; + mapVertices[vCounter + 3] = v1; + mapVertices[vCounter + 4] = v3; + mapVertices[vCounter + 5] = v4; + vCounter += 6; + + mapNormals[nCounter] = n3; + mapNormals[nCounter + 1] = n3; + mapNormals[nCounter + 2] = n3; + mapNormals[nCounter + 3] = n3; + mapNormals[nCounter + 4] = n3; + mapNormals[nCounter + 5] = n3; + nCounter += 6; + + mapTexcoords[tcCounter] = (Vector2){ topTexUV.x, topTexUV.y }; + mapTexcoords[tcCounter + 1] = (Vector2){ topTexUV.x, topTexUV.y + topTexUV.height }; + mapTexcoords[tcCounter + 2] = (Vector2){ topTexUV.x + topTexUV.width, topTexUV.y + topTexUV.height }; + mapTexcoords[tcCounter + 3] = (Vector2){ topTexUV.x, topTexUV.y }; + mapTexcoords[tcCounter + 4] = (Vector2){ topTexUV.x + topTexUV.width, topTexUV.y + topTexUV.height }; + mapTexcoords[tcCounter + 5] = (Vector2){ topTexUV.x + topTexUV.width, topTexUV.y }; + tcCounter += 6; + + // Define bottom triangles (2 tris, 6 vertex --> v6-v8-v7, v6-v5-v8) + mapVertices[vCounter] = v6; + mapVertices[vCounter + 1] = v8; + mapVertices[vCounter + 2] = v7; + mapVertices[vCounter + 3] = v6; + mapVertices[vCounter + 4] = v5; + mapVertices[vCounter + 5] = v8; + vCounter += 6; + + mapNormals[nCounter] = n4; + mapNormals[nCounter + 1] = n4; + mapNormals[nCounter + 2] = n4; + mapNormals[nCounter + 3] = n4; + mapNormals[nCounter + 4] = n4; + mapNormals[nCounter + 5] = n4; + nCounter += 6; + + mapTexcoords[tcCounter] = (Vector2){ bottomTexUV.x + bottomTexUV.width, bottomTexUV.y }; + mapTexcoords[tcCounter + 1] = (Vector2){ bottomTexUV.x, bottomTexUV.y + bottomTexUV.height }; + mapTexcoords[tcCounter + 2] = (Vector2){ bottomTexUV.x + bottomTexUV.width, bottomTexUV.y + bottomTexUV.height }; + mapTexcoords[tcCounter + 3] = (Vector2){ bottomTexUV.x + bottomTexUV.width, bottomTexUV.y }; + mapTexcoords[tcCounter + 4] = (Vector2){ bottomTexUV.x, bottomTexUV.y }; + mapTexcoords[tcCounter + 5] = (Vector2){ bottomTexUV.x, bottomTexUV.y + bottomTexUV.height }; + tcCounter += 6; + + // Checking cube on bottom of current cube + if (((z < cubicmap.height - 1) && COLOR_EQUAL(pixels[(z + 1)*cubicmap.width + x], BLACK)) || (z == cubicmap.height - 1)) + { + // Define front triangles (2 tris, 6 vertex) --> v2 v7 v3, v3 v7 v8 + // NOTE: Collateral occluded faces are not generated + mapVertices[vCounter] = v2; + mapVertices[vCounter + 1] = v7; + mapVertices[vCounter + 2] = v3; + mapVertices[vCounter + 3] = v3; + mapVertices[vCounter + 4] = v7; + mapVertices[vCounter + 5] = v8; + vCounter += 6; + + mapNormals[nCounter] = n6; + mapNormals[nCounter + 1] = n6; + mapNormals[nCounter + 2] = n6; + mapNormals[nCounter + 3] = n6; + mapNormals[nCounter + 4] = n6; + mapNormals[nCounter + 5] = n6; + nCounter += 6; + + mapTexcoords[tcCounter] = (Vector2){ frontTexUV.x, frontTexUV.y }; + mapTexcoords[tcCounter + 1] = (Vector2){ frontTexUV.x, frontTexUV.y + frontTexUV.height }; + mapTexcoords[tcCounter + 2] = (Vector2){ frontTexUV.x + frontTexUV.width, frontTexUV.y }; + mapTexcoords[tcCounter + 3] = (Vector2){ frontTexUV.x + frontTexUV.width, frontTexUV.y }; + mapTexcoords[tcCounter + 4] = (Vector2){ frontTexUV.x, frontTexUV.y + frontTexUV.height }; + mapTexcoords[tcCounter + 5] = (Vector2){ frontTexUV.x + frontTexUV.width, frontTexUV.y + frontTexUV.height }; + tcCounter += 6; + } + + // Checking cube on top of current cube + if (((z > 0) && COLOR_EQUAL(pixels[(z - 1)*cubicmap.width + x], BLACK)) || (z == 0)) + { + // Define back triangles (2 tris, 6 vertex) --> v1 v5 v6, v1 v4 v5 + // NOTE: Collateral occluded faces are not generated + mapVertices[vCounter] = v1; + mapVertices[vCounter + 1] = v5; + mapVertices[vCounter + 2] = v6; + mapVertices[vCounter + 3] = v1; + mapVertices[vCounter + 4] = v4; + mapVertices[vCounter + 5] = v5; + vCounter += 6; + + mapNormals[nCounter] = n5; + mapNormals[nCounter + 1] = n5; + mapNormals[nCounter + 2] = n5; + mapNormals[nCounter + 3] = n5; + mapNormals[nCounter + 4] = n5; + mapNormals[nCounter + 5] = n5; + nCounter += 6; + + mapTexcoords[tcCounter] = (Vector2){ backTexUV.x + backTexUV.width, backTexUV.y }; + mapTexcoords[tcCounter + 1] = (Vector2){ backTexUV.x, backTexUV.y + backTexUV.height }; + mapTexcoords[tcCounter + 2] = (Vector2){ backTexUV.x + backTexUV.width, backTexUV.y + backTexUV.height }; + mapTexcoords[tcCounter + 3] = (Vector2){ backTexUV.x + backTexUV.width, backTexUV.y }; + mapTexcoords[tcCounter + 4] = (Vector2){ backTexUV.x, backTexUV.y }; + mapTexcoords[tcCounter + 5] = (Vector2){ backTexUV.x, backTexUV.y + backTexUV.height }; + tcCounter += 6; + } + + // Checking cube on right of current cube + if (((x < cubicmap.width - 1) && COLOR_EQUAL(pixels[z*cubicmap.width + (x + 1)], BLACK)) || (x == cubicmap.width - 1)) + { + // Define right triangles (2 tris, 6 vertex) --> v3 v8 v4, v4 v8 v5 + // NOTE: Collateral occluded faces are not generated + mapVertices[vCounter] = v3; + mapVertices[vCounter + 1] = v8; + mapVertices[vCounter + 2] = v4; + mapVertices[vCounter + 3] = v4; + mapVertices[vCounter + 4] = v8; + mapVertices[vCounter + 5] = v5; + vCounter += 6; + + mapNormals[nCounter] = n1; + mapNormals[nCounter + 1] = n1; + mapNormals[nCounter + 2] = n1; + mapNormals[nCounter + 3] = n1; + mapNormals[nCounter + 4] = n1; + mapNormals[nCounter + 5] = n1; + nCounter += 6; + + mapTexcoords[tcCounter] = (Vector2){ rightTexUV.x, rightTexUV.y }; + mapTexcoords[tcCounter + 1] = (Vector2){ rightTexUV.x, rightTexUV.y + rightTexUV.height }; + mapTexcoords[tcCounter + 2] = (Vector2){ rightTexUV.x + rightTexUV.width, rightTexUV.y }; + mapTexcoords[tcCounter + 3] = (Vector2){ rightTexUV.x + rightTexUV.width, rightTexUV.y }; + mapTexcoords[tcCounter + 4] = (Vector2){ rightTexUV.x, rightTexUV.y + rightTexUV.height }; + mapTexcoords[tcCounter + 5] = (Vector2){ rightTexUV.x + rightTexUV.width, rightTexUV.y + rightTexUV.height }; + tcCounter += 6; + } + + // Checking cube on left of current cube + if (((x > 0) && COLOR_EQUAL(pixels[z*cubicmap.width + (x - 1)], BLACK)) || (x == 0)) + { + // Define left triangles (2 tris, 6 vertex) --> v1 v7 v2, v1 v6 v7 + // NOTE: Collateral occluded faces are not generated + mapVertices[vCounter] = v1; + mapVertices[vCounter + 1] = v7; + mapVertices[vCounter + 2] = v2; + mapVertices[vCounter + 3] = v1; + mapVertices[vCounter + 4] = v6; + mapVertices[vCounter + 5] = v7; + vCounter += 6; + + mapNormals[nCounter] = n2; + mapNormals[nCounter + 1] = n2; + mapNormals[nCounter + 2] = n2; + mapNormals[nCounter + 3] = n2; + mapNormals[nCounter + 4] = n2; + mapNormals[nCounter + 5] = n2; + nCounter += 6; + + mapTexcoords[tcCounter] = (Vector2){ leftTexUV.x, leftTexUV.y }; + mapTexcoords[tcCounter + 1] = (Vector2){ leftTexUV.x + leftTexUV.width, leftTexUV.y + leftTexUV.height }; + mapTexcoords[tcCounter + 2] = (Vector2){ leftTexUV.x + leftTexUV.width, leftTexUV.y }; + mapTexcoords[tcCounter + 3] = (Vector2){ leftTexUV.x, leftTexUV.y }; + mapTexcoords[tcCounter + 4] = (Vector2){ leftTexUV.x, leftTexUV.y + leftTexUV.height }; + mapTexcoords[tcCounter + 5] = (Vector2){ leftTexUV.x + leftTexUV.width, leftTexUV.y + leftTexUV.height }; + tcCounter += 6; + } + } + // We check pixel color to be BLACK, we will only draw floor and roof + else if (COLOR_EQUAL(pixels[z*cubicmap.width + x], BLACK)) + { + // Define top triangles (2 tris, 6 vertex --> v1-v2-v3, v1-v3-v4) + mapVertices[vCounter] = v1; + mapVertices[vCounter + 1] = v3; + mapVertices[vCounter + 2] = v2; + mapVertices[vCounter + 3] = v1; + mapVertices[vCounter + 4] = v4; + mapVertices[vCounter + 5] = v3; + vCounter += 6; + + mapNormals[nCounter] = n4; + mapNormals[nCounter + 1] = n4; + mapNormals[nCounter + 2] = n4; + mapNormals[nCounter + 3] = n4; + mapNormals[nCounter + 4] = n4; + mapNormals[nCounter + 5] = n4; + nCounter += 6; + + mapTexcoords[tcCounter] = (Vector2){ topTexUV.x, topTexUV.y }; + mapTexcoords[tcCounter + 1] = (Vector2){ topTexUV.x + topTexUV.width, topTexUV.y + topTexUV.height }; + mapTexcoords[tcCounter + 2] = (Vector2){ topTexUV.x, topTexUV.y + topTexUV.height }; + mapTexcoords[tcCounter + 3] = (Vector2){ topTexUV.x, topTexUV.y }; + mapTexcoords[tcCounter + 4] = (Vector2){ topTexUV.x + topTexUV.width, topTexUV.y }; + mapTexcoords[tcCounter + 5] = (Vector2){ topTexUV.x + topTexUV.width, topTexUV.y + topTexUV.height }; + tcCounter += 6; + + // Define bottom triangles (2 tris, 6 vertex --> v6-v8-v7, v6-v5-v8) + mapVertices[vCounter] = v6; + mapVertices[vCounter + 1] = v7; + mapVertices[vCounter + 2] = v8; + mapVertices[vCounter + 3] = v6; + mapVertices[vCounter + 4] = v8; + mapVertices[vCounter + 5] = v5; + vCounter += 6; + + mapNormals[nCounter] = n3; + mapNormals[nCounter + 1] = n3; + mapNormals[nCounter + 2] = n3; + mapNormals[nCounter + 3] = n3; + mapNormals[nCounter + 4] = n3; + mapNormals[nCounter + 5] = n3; + nCounter += 6; + + mapTexcoords[tcCounter] = (Vector2){ bottomTexUV.x + bottomTexUV.width, bottomTexUV.y }; + mapTexcoords[tcCounter + 1] = (Vector2){ bottomTexUV.x + bottomTexUV.width, bottomTexUV.y + bottomTexUV.height }; + mapTexcoords[tcCounter + 2] = (Vector2){ bottomTexUV.x, bottomTexUV.y + bottomTexUV.height }; + mapTexcoords[tcCounter + 3] = (Vector2){ bottomTexUV.x + bottomTexUV.width, bottomTexUV.y }; + mapTexcoords[tcCounter + 4] = (Vector2){ bottomTexUV.x, bottomTexUV.y + bottomTexUV.height }; + mapTexcoords[tcCounter + 5] = (Vector2){ bottomTexUV.x, bottomTexUV.y }; + tcCounter += 6; + } + } + } + + // Move data from mapVertices temp arrays to vertices float array + mesh.vertexCount = vCounter; + mesh.triangleCount = vCounter/3; + + mesh.vertices = (float *)RL_MALLOC(mesh.vertexCount*3*sizeof(float)); + mesh.normals = (float *)RL_MALLOC(mesh.vertexCount*3*sizeof(float)); + mesh.texcoords = (float *)RL_MALLOC(mesh.vertexCount*2*sizeof(float)); + mesh.colors = NULL; + + int fCounter = 0; + + // Move vertices data + for (int i = 0; i < vCounter; i++) + { + mesh.vertices[fCounter] = mapVertices[i].x; + mesh.vertices[fCounter + 1] = mapVertices[i].y; + mesh.vertices[fCounter + 2] = mapVertices[i].z; + fCounter += 3; + } + + fCounter = 0; + + // Move normals data + for (int i = 0; i < nCounter; i++) + { + mesh.normals[fCounter] = mapNormals[i].x; + mesh.normals[fCounter + 1] = mapNormals[i].y; + mesh.normals[fCounter + 2] = mapNormals[i].z; + fCounter += 3; + } + + fCounter = 0; + + // Move texcoords data + for (int i = 0; i < tcCounter; i++) + { + mesh.texcoords[fCounter] = mapTexcoords[i].x; + mesh.texcoords[fCounter + 1] = mapTexcoords[i].y; + fCounter += 2; + } + + RL_FREE(mapVertices); + RL_FREE(mapNormals); + RL_FREE(mapTexcoords); + + UnloadImageColors(pixels); // Unload pixels color data + + // Upload vertex data to GPU (static mesh) + UploadMesh(&mesh, false); + + return mesh; +} +#endif // SUPPORT_MESH_GENERATION + +// Compute mesh bounding box limits +// NOTE: minVertex and maxVertex should be transformed by model transform matrix +BoundingBox GetMeshBoundingBox(Mesh mesh) +{ + // Get min and max vertex to construct bounds (AABB) + Vector3 minVertex = { 0 }; + Vector3 maxVertex = { 0 }; + + if (mesh.vertices != NULL) + { + minVertex = (Vector3){ mesh.vertices[0], mesh.vertices[1], mesh.vertices[2] }; + maxVertex = (Vector3){ mesh.vertices[0], mesh.vertices[1], mesh.vertices[2] }; + + for (int i = 1; i < mesh.vertexCount; i++) + { + minVertex = Vector3Min(minVertex, (Vector3){ mesh.vertices[i*3], mesh.vertices[i*3 + 1], mesh.vertices[i*3 + 2] }); + maxVertex = Vector3Max(maxVertex, (Vector3){ mesh.vertices[i*3], mesh.vertices[i*3 + 1], mesh.vertices[i*3 + 2] }); + } + } + + // Create the bounding box + BoundingBox box = { 0 }; + box.min = minVertex; + box.max = maxVertex; + + return box; +} + +// Compute mesh tangents +// NOTE: To calculate mesh tangents and binormals we need mesh vertex positions and texture coordinates +// Implementation based on: https://answers.unity.com/questions/7789/calculating-tangents-vector4.html +void GenMeshTangents(Mesh *mesh) +{ + if ((mesh->vertices == NULL) || (mesh->texcoords == NULL)) + { + TRACELOG(LOG_WARNING, "MESH: Tangents generation requires texcoord vertex attribute data"); + return; + } + + if (mesh->tangents == NULL) mesh->tangents = (float *)RL_MALLOC(mesh->vertexCount*4*sizeof(float)); + else + { + RL_FREE(mesh->tangents); + mesh->tangents = (float *)RL_MALLOC(mesh->vertexCount*4*sizeof(float)); + } + + Vector3 *tan1 = (Vector3 *)RL_MALLOC(mesh->vertexCount*sizeof(Vector3)); + Vector3 *tan2 = (Vector3 *)RL_MALLOC(mesh->vertexCount*sizeof(Vector3)); + + if (mesh->vertexCount % 3 != 0) + { + TRACELOG(LOG_WARNING, "MESH: vertexCount expected to be a multiple of 3. Expect uninitialized values."); + } + + for (int i = 0; i <= mesh->vertexCount - 3; i += 3) + { + // Get triangle vertices + Vector3 v1 = { mesh->vertices[(i + 0)*3 + 0], mesh->vertices[(i + 0)*3 + 1], mesh->vertices[(i + 0)*3 + 2] }; + Vector3 v2 = { mesh->vertices[(i + 1)*3 + 0], mesh->vertices[(i + 1)*3 + 1], mesh->vertices[(i + 1)*3 + 2] }; + Vector3 v3 = { mesh->vertices[(i + 2)*3 + 0], mesh->vertices[(i + 2)*3 + 1], mesh->vertices[(i + 2)*3 + 2] }; + + // Get triangle texcoords + Vector2 uv1 = { mesh->texcoords[(i + 0)*2 + 0], mesh->texcoords[(i + 0)*2 + 1] }; + Vector2 uv2 = { mesh->texcoords[(i + 1)*2 + 0], mesh->texcoords[(i + 1)*2 + 1] }; + Vector2 uv3 = { mesh->texcoords[(i + 2)*2 + 0], mesh->texcoords[(i + 2)*2 + 1] }; + + float x1 = v2.x - v1.x; + float y1 = v2.y - v1.y; + float z1 = v2.z - v1.z; + float x2 = v3.x - v1.x; + float y2 = v3.y - v1.y; + float z2 = v3.z - v1.z; + + float s1 = uv2.x - uv1.x; + float t1 = uv2.y - uv1.y; + float s2 = uv3.x - uv1.x; + float t2 = uv3.y - uv1.y; + + float div = s1*t2 - s2*t1; + float r = (div == 0.0f)? 0.0f : 1.0f/div; + + Vector3 sdir = { (t2*x1 - t1*x2)*r, (t2*y1 - t1*y2)*r, (t2*z1 - t1*z2)*r }; + Vector3 tdir = { (s1*x2 - s2*x1)*r, (s1*y2 - s2*y1)*r, (s1*z2 - s2*z1)*r }; + + tan1[i + 0] = sdir; + tan1[i + 1] = sdir; + tan1[i + 2] = sdir; + + tan2[i + 0] = tdir; + tan2[i + 1] = tdir; + tan2[i + 2] = tdir; + } + + // Compute tangents considering normals + for (int i = 0; i < mesh->vertexCount; i++) + { + Vector3 normal = { mesh->normals[i*3 + 0], mesh->normals[i*3 + 1], mesh->normals[i*3 + 2] }; + Vector3 tangent = tan1[i]; + + // TODO: Review, not sure if tangent computation is right, just used reference proposed maths... +#if defined(COMPUTE_TANGENTS_METHOD_01) + Vector3 tmp = Vector3Subtract(tangent, Vector3Scale(normal, Vector3DotProduct(normal, tangent))); + tmp = Vector3Normalize(tmp); + mesh->tangents[i*4 + 0] = tmp.x; + mesh->tangents[i*4 + 1] = tmp.y; + mesh->tangents[i*4 + 2] = tmp.z; + mesh->tangents[i*4 + 3] = 1.0f; +#else + Vector3OrthoNormalize(&normal, &tangent); + mesh->tangents[i*4 + 0] = tangent.x; + mesh->tangents[i*4 + 1] = tangent.y; + mesh->tangents[i*4 + 2] = tangent.z; + mesh->tangents[i*4 + 3] = (Vector3DotProduct(Vector3CrossProduct(normal, tangent), tan2[i]) < 0.0f)? -1.0f : 1.0f; +#endif + } + + RL_FREE(tan1); + RL_FREE(tan2); + + if (mesh->vboId != NULL) + { + if (mesh->vboId[SHADER_LOC_VERTEX_TANGENT] != 0) + { + // Update existing vertex buffer + rlUpdateVertexBuffer(mesh->vboId[SHADER_LOC_VERTEX_TANGENT], mesh->tangents, mesh->vertexCount*4*sizeof(float), 0); + } + else + { + // Load a new tangent attributes buffer + mesh->vboId[SHADER_LOC_VERTEX_TANGENT] = rlLoadVertexBuffer(mesh->tangents, mesh->vertexCount*4*sizeof(float), false); + } + + rlEnableVertexArray(mesh->vaoId); + rlSetVertexAttribute(RL_DEFAULT_SHADER_ATTRIB_LOCATION_TANGENT, 4, RL_FLOAT, 0, 0, 0); + rlEnableVertexAttribute(RL_DEFAULT_SHADER_ATTRIB_LOCATION_TANGENT); + rlDisableVertexArray(); + } + + TRACELOG(LOG_INFO, "MESH: Tangents data computed and uploaded for provided mesh"); +} + +// Draw a model (with texture if set) +void DrawModel(Model model, Vector3 position, float scale, Color tint) +{ + Vector3 vScale = { scale, scale, scale }; + Vector3 rotationAxis = { 0.0f, 1.0f, 0.0f }; + + DrawModelEx(model, position, rotationAxis, 0.0f, vScale, tint); +} + +// Draw a model with extended parameters +void DrawModelEx(Model model, Vector3 position, Vector3 rotationAxis, float rotationAngle, Vector3 scale, Color tint) +{ + // Calculate transformation matrix from function parameters + // Get transform matrix (rotation -> scale -> translation) + Matrix matScale = MatrixScale(scale.x, scale.y, scale.z); + Matrix matRotation = MatrixRotate(rotationAxis, rotationAngle*DEG2RAD); + Matrix matTranslation = MatrixTranslate(position.x, position.y, position.z); + + Matrix matTransform = MatrixMultiply(MatrixMultiply(matScale, matRotation), matTranslation); + + // Combine model transformation matrix (model.transform) with matrix generated by function parameters (matTransform) + model.transform = MatrixMultiply(model.transform, matTransform); + + for (int i = 0; i < model.meshCount; i++) + { + Color color = model.materials[model.meshMaterial[i]].maps[MATERIAL_MAP_DIFFUSE].color; + + Color colorTint = WHITE; + colorTint.r = (unsigned char)(((int)color.r*(int)tint.r)/255); + colorTint.g = (unsigned char)(((int)color.g*(int)tint.g)/255); + colorTint.b = (unsigned char)(((int)color.b*(int)tint.b)/255); + colorTint.a = (unsigned char)(((int)color.a*(int)tint.a)/255); + + model.materials[model.meshMaterial[i]].maps[MATERIAL_MAP_DIFFUSE].color = colorTint; + DrawMesh(model.meshes[i], model.materials[model.meshMaterial[i]], model.transform); + model.materials[model.meshMaterial[i]].maps[MATERIAL_MAP_DIFFUSE].color = color; + } +} + +// Draw a model wires (with texture if set) +void DrawModelWires(Model model, Vector3 position, float scale, Color tint) +{ + rlEnableWireMode(); + + DrawModel(model, position, scale, tint); + + rlDisableWireMode(); +} + +// Draw a model wires (with texture if set) with extended parameters +void DrawModelWiresEx(Model model, Vector3 position, Vector3 rotationAxis, float rotationAngle, Vector3 scale, Color tint) +{ + rlEnableWireMode(); + + DrawModelEx(model, position, rotationAxis, rotationAngle, scale, tint); + + rlDisableWireMode(); +} + +// Draw a model points +void DrawModelPoints(Model model, Vector3 position, float scale, Color tint) +{ + rlEnablePointMode(); + rlDisableBackfaceCulling(); + + DrawModel(model, position, scale, tint); + + rlEnableBackfaceCulling(); + rlDisableWireMode(); +} + +// Draw a model points +void DrawModelPointsEx(Model model, Vector3 position, Vector3 rotationAxis, float rotationAngle, Vector3 scale, Color tint) +{ + rlEnablePointMode(); + rlDisableBackfaceCulling(); + + DrawModelEx(model, position, rotationAxis, rotationAngle, scale, tint); + + rlEnableBackfaceCulling(); + rlDisableWireMode(); +} + +// Draw a billboard +void DrawBillboard(Camera camera, Texture2D texture, Vector3 position, float scale, Color tint) +{ + Rectangle source = { 0.0f, 0.0f, (float)texture.width, (float)texture.height }; + + DrawBillboardRec(camera, texture, source, position, (Vector2) { scale*fabsf((float)source.width/source.height), scale }, tint); +} + +// Draw a billboard (part of a texture defined by a rectangle) +void DrawBillboardRec(Camera camera, Texture2D texture, Rectangle source, Vector3 position, Vector2 size, Color tint) +{ + // NOTE: Billboard locked on axis-Y + Vector3 up = { 0.0f, 1.0f, 0.0f }; + + DrawBillboardPro(camera, texture, source, position, up, size, Vector2Scale(size, 0.5), 0.0f, tint); +} + +// Draw a billboard with additional parameters +void DrawBillboardPro(Camera camera, Texture2D texture, Rectangle source, Vector3 position, Vector3 up, Vector2 size, Vector2 origin, float rotation, Color tint) +{ + // Compute the up vector and the right vector + Matrix matView = MatrixLookAt(camera.position, camera.target, camera.up); + Vector3 right = { matView.m0, matView.m4, matView.m8 }; + right = Vector3Scale(right, size.x); + up = Vector3Scale(up, size.y); + + // Flip the content of the billboard while maintaining the counterclockwise edge rendering order + if (size.x < 0.0f) + { + source.x += size.x; + source.width *= -1.0; + right = Vector3Negate(right); + origin.x *= -1.0f; + } + if (size.y < 0.0f) + { + source.y += size.y; + source.height *= -1.0; + up = Vector3Negate(up); + origin.y *= -1.0f; + } + + // Draw the texture region described by source on the following rectangle in 3D space: + // + // size.x <--. + // 3 ^---------------------------+ 2 \ rotation + // | | / + // | | + // | origin.x position | + // up |.............. | size.y + // | . | + // | . origin.y | + // | . | + // 0 +---------------------------> 1 + // right + Vector3 forward; + if (rotation != 0.0) forward = Vector3CrossProduct(right, up); + + Vector3 origin3D = Vector3Add(Vector3Scale(Vector3Normalize(right), origin.x), Vector3Scale(Vector3Normalize(up), origin.y)); + + Vector3 points[4]; + points[0] = Vector3Zero(); + points[1] = right; + points[2] = Vector3Add(up, right); + points[3] = up; + + for (int i = 0; i < 4; i++) + { + points[i] = Vector3Subtract(points[i], origin3D); + if (rotation != 0.0) points[i] = Vector3RotateByAxisAngle(points[i], forward, rotation * DEG2RAD); + points[i] = Vector3Add(points[i], position); + } + + Vector2 texcoords[4]; + texcoords[0] = (Vector2) { (float)source.x/texture.width, (float)(source.y + source.height)/texture.height }; + texcoords[1] = (Vector2) { (float)(source.x + source.width)/texture.width, (float)(source.y + source.height)/texture.height }; + texcoords[2] = (Vector2) { (float)(source.x + source.width)/texture.width, (float)source.y/texture.height }; + texcoords[3] = (Vector2) { (float)source.x/texture.width, (float)source.y/texture.height }; + + rlSetTexture(texture.id); + rlBegin(RL_QUADS); + + rlColor4ub(tint.r, tint.g, tint.b, tint.a); + for (int i = 0; i < 4; i++) + { + rlTexCoord2f(texcoords[i].x, texcoords[i].y); + rlVertex3f(points[i].x, points[i].y, points[i].z); + } + + rlEnd(); + rlSetTexture(0); +} + +// Draw a bounding box with wires +void DrawBoundingBox(BoundingBox box, Color color) +{ + Vector3 size = { 0 }; + + size.x = fabsf(box.max.x - box.min.x); + size.y = fabsf(box.max.y - box.min.y); + size.z = fabsf(box.max.z - box.min.z); + + Vector3 center = { box.min.x + size.x/2.0f, box.min.y + size.y/2.0f, box.min.z + size.z/2.0f }; + + DrawCubeWires(center, size.x, size.y, size.z, color); +} + +// Check collision between two spheres +bool CheckCollisionSpheres(Vector3 center1, float radius1, Vector3 center2, float radius2) +{ + bool collision = false; + + // Simple way to check for collision, just checking distance between two points + // Unfortunately, sqrtf() is a costly operation, so we avoid it with following solution + /* + float dx = center1.x - center2.x; // X distance between centers + float dy = center1.y - center2.y; // Y distance between centers + float dz = center1.z - center2.z; // Z distance between centers + + float distance = sqrtf(dx*dx + dy*dy + dz*dz); // Distance between centers + + if (distance <= (radius1 + radius2)) collision = true; + */ + + // Check for distances squared to avoid sqrtf() + if (Vector3DotProduct(Vector3Subtract(center2, center1), Vector3Subtract(center2, center1)) <= (radius1 + radius2)*(radius1 + radius2)) collision = true; + + return collision; +} + +// Check collision between two boxes +// NOTE: Boxes are defined by two points minimum and maximum +bool CheckCollisionBoxes(BoundingBox box1, BoundingBox box2) +{ + bool collision = true; + + if ((box1.max.x >= box2.min.x) && (box1.min.x <= box2.max.x)) + { + if ((box1.max.y < box2.min.y) || (box1.min.y > box2.max.y)) collision = false; + if ((box1.max.z < box2.min.z) || (box1.min.z > box2.max.z)) collision = false; + } + else collision = false; + + return collision; +} + +// Check collision between box and sphere +bool CheckCollisionBoxSphere(BoundingBox box, Vector3 center, float radius) +{ + bool collision = false; + + float dmin = 0; + + if (center.x < box.min.x) dmin += powf(center.x - box.min.x, 2); + else if (center.x > box.max.x) dmin += powf(center.x - box.max.x, 2); + + if (center.y < box.min.y) dmin += powf(center.y - box.min.y, 2); + else if (center.y > box.max.y) dmin += powf(center.y - box.max.y, 2); + + if (center.z < box.min.z) dmin += powf(center.z - box.min.z, 2); + else if (center.z > box.max.z) dmin += powf(center.z - box.max.z, 2); + + if (dmin <= (radius*radius)) collision = true; + + return collision; +} + +// Get collision info between ray and sphere +RayCollision GetRayCollisionSphere(Ray ray, Vector3 center, float radius) +{ + RayCollision collision = { 0 }; + + Vector3 raySpherePos = Vector3Subtract(center, ray.position); + float vector = Vector3DotProduct(raySpherePos, ray.direction); + float distance = Vector3Length(raySpherePos); + float d = radius*radius - (distance*distance - vector*vector); + + collision.hit = d >= 0.0f; + + // Check if ray origin is inside the sphere to calculate the correct collision point + if (distance < radius) + { + collision.distance = vector + sqrtf(d); + + // Calculate collision point + collision.point = Vector3Add(ray.position, Vector3Scale(ray.direction, collision.distance)); + + // Calculate collision normal (pointing outwards) + collision.normal = Vector3Negate(Vector3Normalize(Vector3Subtract(collision.point, center))); + } + else + { + collision.distance = vector - sqrtf(d); + + // Calculate collision point + collision.point = Vector3Add(ray.position, Vector3Scale(ray.direction, collision.distance)); + + // Calculate collision normal (pointing inwards) + collision.normal = Vector3Normalize(Vector3Subtract(collision.point, center)); + } + + return collision; +} + +// Get collision info between ray and box +RayCollision GetRayCollisionBox(Ray ray, BoundingBox box) +{ + RayCollision collision = { 0 }; + + // Note: If ray.position is inside the box, the distance is negative (as if the ray was reversed) + // Reversing ray.direction will give use the correct result + bool insideBox = (ray.position.x > box.min.x) && (ray.position.x < box.max.x) && + (ray.position.y > box.min.y) && (ray.position.y < box.max.y) && + (ray.position.z > box.min.z) && (ray.position.z < box.max.z); + + if (insideBox) ray.direction = Vector3Negate(ray.direction); + + float t[11] = { 0 }; + + t[8] = 1.0f/ray.direction.x; + t[9] = 1.0f/ray.direction.y; + t[10] = 1.0f/ray.direction.z; + + t[0] = (box.min.x - ray.position.x)*t[8]; + t[1] = (box.max.x - ray.position.x)*t[8]; + t[2] = (box.min.y - ray.position.y)*t[9]; + t[3] = (box.max.y - ray.position.y)*t[9]; + t[4] = (box.min.z - ray.position.z)*t[10]; + t[5] = (box.max.z - ray.position.z)*t[10]; + t[6] = (float)fmax(fmax(fmin(t[0], t[1]), fmin(t[2], t[3])), fmin(t[4], t[5])); + t[7] = (float)fmin(fmin(fmax(t[0], t[1]), fmax(t[2], t[3])), fmax(t[4], t[5])); + + collision.hit = !((t[7] < 0) || (t[6] > t[7])); + collision.distance = t[6]; + collision.point = Vector3Add(ray.position, Vector3Scale(ray.direction, collision.distance)); + + // Get box center point + collision.normal = Vector3Lerp(box.min, box.max, 0.5f); + // Get vector center point->hit point + collision.normal = Vector3Subtract(collision.point, collision.normal); + // Scale vector to unit cube + // NOTE: We use an additional .01 to fix numerical errors + collision.normal = Vector3Scale(collision.normal, 2.01f); + collision.normal = Vector3Divide(collision.normal, Vector3Subtract(box.max, box.min)); + // The relevant elements of the vector are now slightly larger than 1.0f (or smaller than -1.0f) + // and the others are somewhere between -1.0 and 1.0 casting to int is exactly our wanted normal! + collision.normal.x = (float)((int)collision.normal.x); + collision.normal.y = (float)((int)collision.normal.y); + collision.normal.z = (float)((int)collision.normal.z); + + collision.normal = Vector3Normalize(collision.normal); + + if (insideBox) + { + // Reset ray.direction + ray.direction = Vector3Negate(ray.direction); + // Fix result + collision.distance *= -1.0f; + collision.normal = Vector3Negate(collision.normal); + } + + return collision; +} + +// Get collision info between ray and mesh +RayCollision GetRayCollisionMesh(Ray ray, Mesh mesh, Matrix transform) +{ + RayCollision collision = { 0 }; + + // Check if mesh vertex data on CPU for testing + if (mesh.vertices != NULL) + { + int triangleCount = mesh.triangleCount; + + // Test against all triangles in mesh + for (int i = 0; i < triangleCount; i++) + { + Vector3 a, b, c; + Vector3* vertdata = (Vector3*)mesh.vertices; + + if (mesh.indices) + { + a = vertdata[mesh.indices[i*3 + 0]]; + b = vertdata[mesh.indices[i*3 + 1]]; + c = vertdata[mesh.indices[i*3 + 2]]; + } + else + { + a = vertdata[i*3 + 0]; + b = vertdata[i*3 + 1]; + c = vertdata[i*3 + 2]; + } + + a = Vector3Transform(a, transform); + b = Vector3Transform(b, transform); + c = Vector3Transform(c, transform); + + RayCollision triHitInfo = GetRayCollisionTriangle(ray, a, b, c); + + if (triHitInfo.hit) + { + // Save the closest hit triangle + if ((!collision.hit) || (collision.distance > triHitInfo.distance)) collision = triHitInfo; + } + } + } + + return collision; +} + +// Get collision info between ray and triangle +// NOTE: The points are expected to be in counter-clockwise winding +// NOTE: Based on https://en.wikipedia.org/wiki/M%C3%B6ller%E2%80%93Trumbore_intersection_algorithm +RayCollision GetRayCollisionTriangle(Ray ray, Vector3 p1, Vector3 p2, Vector3 p3) +{ + #define EPSILON 0.000001f // A small number + + RayCollision collision = { 0 }; + Vector3 edge1 = { 0 }; + Vector3 edge2 = { 0 }; + Vector3 p, q, tv; + float det, invDet, u, v, t; + + // Find vectors for two edges sharing V1 + edge1 = Vector3Subtract(p2, p1); + edge2 = Vector3Subtract(p3, p1); + + // Begin calculating determinant - also used to calculate u parameter + p = Vector3CrossProduct(ray.direction, edge2); + + // If determinant is near zero, ray lies in plane of triangle or ray is parallel to plane of triangle + det = Vector3DotProduct(edge1, p); + + // Avoid culling! + if ((det > -EPSILON) && (det < EPSILON)) return collision; + + invDet = 1.0f/det; + + // Calculate distance from V1 to ray origin + tv = Vector3Subtract(ray.position, p1); + + // Calculate u parameter and test bound + u = Vector3DotProduct(tv, p)*invDet; + + // The intersection lies outside the triangle + if ((u < 0.0f) || (u > 1.0f)) return collision; + + // Prepare to test v parameter + q = Vector3CrossProduct(tv, edge1); + + // Calculate V parameter and test bound + v = Vector3DotProduct(ray.direction, q)*invDet; + + // The intersection lies outside the triangle + if ((v < 0.0f) || ((u + v) > 1.0f)) return collision; + + t = Vector3DotProduct(edge2, q)*invDet; + + if (t > EPSILON) + { + // Ray hit, get hit point and normal + collision.hit = true; + collision.distance = t; + collision.normal = Vector3Normalize(Vector3CrossProduct(edge1, edge2)); + collision.point = Vector3Add(ray.position, Vector3Scale(ray.direction, t)); + } + + return collision; +} + +// Get collision info between ray and quad +// NOTE: The points are expected to be in counter-clockwise winding +RayCollision GetRayCollisionQuad(Ray ray, Vector3 p1, Vector3 p2, Vector3 p3, Vector3 p4) +{ + RayCollision collision = { 0 }; + + collision = GetRayCollisionTriangle(ray, p1, p2, p4); + + if (!collision.hit) collision = GetRayCollisionTriangle(ray, p2, p3, p4); + + return collision; +} + +//---------------------------------------------------------------------------------- +// Module specific Functions Definition +//---------------------------------------------------------------------------------- +#if defined(SUPPORT_FILEFORMAT_IQM) || defined(SUPPORT_FILEFORMAT_GLTF) +// Build pose from parent joints +// NOTE: Required for animations loading (required by IQM and GLTF) +static void BuildPoseFromParentJoints(BoneInfo *bones, int boneCount, Transform *transforms) +{ + for (int i = 0; i < boneCount; i++) + { + if (bones[i].parent >= 0) + { + if (bones[i].parent > i) + { + TRACELOG(LOG_WARNING, "Assumes bones are toplogically sorted, but bone %d has parent %d. Skipping.", i, bones[i].parent); + continue; + } + transforms[i].rotation = QuaternionMultiply(transforms[bones[i].parent].rotation, transforms[i].rotation); + transforms[i].translation = Vector3RotateByQuaternion(transforms[i].translation, transforms[bones[i].parent].rotation); + transforms[i].translation = Vector3Add(transforms[i].translation, transforms[bones[i].parent].translation); + transforms[i].scale = Vector3Multiply(transforms[i].scale, transforms[bones[i].parent].scale); + } + } +} +#endif + +#if defined(SUPPORT_FILEFORMAT_OBJ) +// Load OBJ mesh data +// +// Keep the following information in mind when reading this +// - A mesh is created for every material present in the obj file +// - the model.meshCount is therefore the materialCount returned from tinyobj +// - the mesh is automatically triangulated by tinyobj +static Model LoadOBJ(const char *fileName) +{ + tinyobj_attrib_t objAttributes = { 0 }; + tinyobj_shape_t* objShapes = NULL; + unsigned int objShapeCount = 0; + + tinyobj_material_t* objMaterials = NULL; + unsigned int objMaterialCount = 0; + + Model model = { 0 }; + model.transform = MatrixIdentity(); + + char* fileText = LoadFileText(fileName); + + if (fileText == NULL) + { + TRACELOG(LOG_ERROR, "MODEL Unable to read obj file %s", fileName); + return model; + } + + char currentDir[1024] = { 0 }; + strcpy(currentDir, GetWorkingDirectory()); // Save current working directory + const char* workingDir = GetDirectoryPath(fileName); // Switch to OBJ directory for material path correctness + if (CHDIR(workingDir) != 0) + { + TRACELOG(LOG_WARNING, "MODEL: [%s] Failed to change working directory", workingDir); + } + + unsigned int dataSize = (unsigned int)strlen(fileText); + + unsigned int flags = TINYOBJ_FLAG_TRIANGULATE; + int ret = tinyobj_parse_obj(&objAttributes, &objShapes, &objShapeCount, &objMaterials, &objMaterialCount, fileText, dataSize, flags); + + if (ret != TINYOBJ_SUCCESS) + { + TRACELOG(LOG_ERROR, "MODEL Unable to read obj data %s", fileName); + return model; + } + + UnloadFileText(fileText); + + unsigned int faceVertIndex = 0; + unsigned int nextShape = 1; + int lastMaterial = -1; + unsigned int meshIndex = 0; + + // count meshes + unsigned int nextShapeEnd = objAttributes.num_face_num_verts; + + // see how many verts till the next shape + + if (objShapeCount > 1) nextShapeEnd = objShapes[nextShape].face_offset; + + // walk all the faces + for (unsigned int faceId = 0; faceId < objAttributes.num_faces; faceId++) + { + if (faceVertIndex >= nextShapeEnd) + { + // try to find the last vert in the next shape + nextShape++; + if (nextShape < objShapeCount) nextShapeEnd = objShapes[nextShape].face_offset; + else nextShapeEnd = objAttributes.num_face_num_verts; // this is actually the total number of face verts in the file, not faces + meshIndex++; + } + else if (lastMaterial != -1 && objAttributes.material_ids[faceId] != lastMaterial) + { + meshIndex++;// if this is a new material, we need to allocate a new mesh + } + + lastMaterial = objAttributes.material_ids[faceId]; + faceVertIndex += objAttributes.face_num_verts[faceId]; + } + + // allocate the base meshes and materials + model.meshCount = meshIndex + 1; + model.meshes = (Mesh*)MemAlloc(sizeof(Mesh) * model.meshCount); + + if (objMaterialCount > 0) + { + model.materialCount = objMaterialCount; + model.materials = (Material*)MemAlloc(sizeof(Material) * objMaterialCount); + } + else // we must allocate at least one material + { + model.materialCount = 1; + model.materials = (Material*)MemAlloc(sizeof(Material) * 1); + } + + model.meshMaterial = (int*)MemAlloc(sizeof(int) * model.meshCount); + + // see how many verts are in each mesh + unsigned int* localMeshVertexCounts = (unsigned int*)MemAlloc(sizeof(unsigned int) * model.meshCount); + + faceVertIndex = 0; + nextShapeEnd = objAttributes.num_face_num_verts; + lastMaterial = -1; + meshIndex = 0; + unsigned int localMeshVertexCount = 0; + + nextShape = 1; + if (objShapeCount > 1) + nextShapeEnd = objShapes[nextShape].face_offset; + + // walk all the faces + for (unsigned int faceId = 0; faceId < objAttributes.num_faces; faceId++) + { + bool newMesh = false; // do we need a new mesh? + if (faceVertIndex >= nextShapeEnd) + { + // try to find the last vert in the next shape + nextShape++; + if (nextShape < objShapeCount) nextShapeEnd = objShapes[nextShape].face_offset; + else nextShapeEnd = objAttributes.num_face_num_verts; // this is actually the total number of face verts in the file, not faces + + newMesh = true; + } + else if (lastMaterial != -1 && objAttributes.material_ids[faceId] != lastMaterial) + { + newMesh = true; + } + + lastMaterial = objAttributes.material_ids[faceId]; + + if (newMesh) + { + localMeshVertexCounts[meshIndex] = localMeshVertexCount; + + localMeshVertexCount = 0; + meshIndex++; + } + + faceVertIndex += objAttributes.face_num_verts[faceId]; + localMeshVertexCount += objAttributes.face_num_verts[faceId]; + } + localMeshVertexCounts[meshIndex] = localMeshVertexCount; + + for (int i = 0; i < model.meshCount; i++) + { + // allocate the buffers for each mesh + unsigned int vertexCount = localMeshVertexCounts[i]; + + model.meshes[i].vertexCount = vertexCount; + model.meshes[i].triangleCount = vertexCount / 3; + + model.meshes[i].vertices = (float*)MemAlloc(sizeof(float) * vertexCount * 3); + model.meshes[i].normals = (float*)MemAlloc(sizeof(float) * vertexCount * 3); + model.meshes[i].texcoords = (float*)MemAlloc(sizeof(float) * vertexCount * 2); + model.meshes[i].colors = (unsigned char*)MemAlloc(sizeof(unsigned char) * vertexCount * 4); + } + + MemFree(localMeshVertexCounts); + localMeshVertexCounts = NULL; + + // fill meshes + faceVertIndex = 0; + + nextShapeEnd = objAttributes.num_face_num_verts; + + // see how many verts till the next shape + nextShape = 1; + if (objShapeCount > 1) nextShapeEnd = objShapes[nextShape].face_offset; + lastMaterial = -1; + meshIndex = 0; + localMeshVertexCount = 0; + + // walk all the faces + for (unsigned int faceId = 0; faceId < objAttributes.num_faces; faceId++) + { + bool newMesh = false; // do we need a new mesh? + if (faceVertIndex >= nextShapeEnd) + { + // try to find the last vert in the next shape + nextShape++; + if (nextShape < objShapeCount) nextShapeEnd = objShapes[nextShape].face_offset; + else nextShapeEnd = objAttributes.num_face_num_verts; // this is actually the total number of face verts in the file, not faces + newMesh = true; + } + // if this is a new material, we need to allocate a new mesh + if (lastMaterial != -1 && objAttributes.material_ids[faceId] != lastMaterial) newMesh = true; + lastMaterial = objAttributes.material_ids[faceId];; + + if (newMesh) + { + localMeshVertexCount = 0; + meshIndex++; + } + + int matId = 0; + if (lastMaterial >= 0 && lastMaterial < (int)objMaterialCount) + matId = lastMaterial; + + model.meshMaterial[meshIndex] = matId; + + for (int f = 0; f < objAttributes.face_num_verts[faceId]; f++) + { + int vertIndex = objAttributes.faces[faceVertIndex].v_idx; + int normalIndex = objAttributes.faces[faceVertIndex].vn_idx; + int texcordIndex = objAttributes.faces[faceVertIndex].vt_idx; + + for (int i = 0; i < 3; i++) + model.meshes[meshIndex].vertices[localMeshVertexCount * 3 + i] = objAttributes.vertices[vertIndex * 3 + i]; + + for (int i = 0; i < 3; i++) + model.meshes[meshIndex].normals[localMeshVertexCount * 3 + i] = objAttributes.normals[normalIndex * 3 + i]; + + for (int i = 0; i < 2; i++) + model.meshes[meshIndex].texcoords[localMeshVertexCount * 2 + i] = objAttributes.texcoords[texcordIndex * 2 + i]; + + model.meshes[meshIndex].texcoords[localMeshVertexCount * 2 + 1] = 1.0f - model.meshes[meshIndex].texcoords[localMeshVertexCount * 2 + 1]; + + for (int i = 0; i < 4; i++) + model.meshes[meshIndex].colors[localMeshVertexCount * 4 + i] = 255; + + faceVertIndex++; + localMeshVertexCount++; + } + } + + if (objMaterialCount > 0) ProcessMaterialsOBJ(model.materials, objMaterials, objMaterialCount); + else model.materials[0] = LoadMaterialDefault(); // Set default material for the mesh + + tinyobj_attrib_free(&objAttributes); + tinyobj_shapes_free(objShapes, objShapeCount); + tinyobj_materials_free(objMaterials, objMaterialCount); + + for (int i = 0; i < model.meshCount; i++) + UploadMesh(model.meshes + i, true); + + // Restore current working directory + if (CHDIR(currentDir) != 0) + { + TRACELOG(LOG_WARNING, "MODEL: [%s] Failed to change working directory", currentDir); + } + + return model; +} +#endif + +#if defined(SUPPORT_FILEFORMAT_IQM) +// Load IQM mesh data +static Model LoadIQM(const char *fileName) +{ + #define IQM_MAGIC "INTERQUAKEMODEL" // IQM file magic number + #define IQM_VERSION 2 // only IQM version 2 supported + + #define BONE_NAME_LENGTH 32 // BoneInfo name string length + #define MESH_NAME_LENGTH 32 // Mesh name string length + #define MATERIAL_NAME_LENGTH 32 // Material name string length + + int dataSize = 0; + unsigned char *fileData = LoadFileData(fileName, &dataSize); + unsigned char *fileDataPtr = fileData; + + // IQM file structs + //----------------------------------------------------------------------------------- + typedef struct IQMHeader { + char magic[16]; + unsigned int version; + unsigned int dataSize; + unsigned int flags; + unsigned int num_text, ofs_text; + unsigned int num_meshes, ofs_meshes; + unsigned int num_vertexarrays, num_vertexes, ofs_vertexarrays; + unsigned int num_triangles, ofs_triangles, ofs_adjacency; + unsigned int num_joints, ofs_joints; + unsigned int num_poses, ofs_poses; + unsigned int num_anims, ofs_anims; + unsigned int num_frames, num_framechannels, ofs_frames, ofs_bounds; + unsigned int num_comment, ofs_comment; + unsigned int num_extensions, ofs_extensions; + } IQMHeader; + + typedef struct IQMMesh { + unsigned int name; + unsigned int material; + unsigned int first_vertex, num_vertexes; + unsigned int first_triangle, num_triangles; + } IQMMesh; + + typedef struct IQMTriangle { + unsigned int vertex[3]; + } IQMTriangle; + + typedef struct IQMJoint { + unsigned int name; + int parent; + float translate[3], rotate[4], scale[3]; + } IQMJoint; + + typedef struct IQMVertexArray { + unsigned int type; + unsigned int flags; + unsigned int format; + unsigned int size; + unsigned int offset; + } IQMVertexArray; + + // NOTE: Below IQM structures are not used but listed for reference + /* + typedef struct IQMAdjacency { + unsigned int triangle[3]; + } IQMAdjacency; + + typedef struct IQMPose { + int parent; + unsigned int mask; + float channeloffset[10]; + float channelscale[10]; + } IQMPose; + + typedef struct IQMAnim { + unsigned int name; + unsigned int first_frame, num_frames; + float framerate; + unsigned int flags; + } IQMAnim; + + typedef struct IQMBounds { + float bbmin[3], bbmax[3]; + float xyradius, radius; + } IQMBounds; + */ + //----------------------------------------------------------------------------------- + + // IQM vertex data types + enum { + IQM_POSITION = 0, + IQM_TEXCOORD = 1, + IQM_NORMAL = 2, + IQM_TANGENT = 3, // NOTE: Tangents unused by default + IQM_BLENDINDEXES = 4, + IQM_BLENDWEIGHTS = 5, + IQM_COLOR = 6, + IQM_CUSTOM = 0x10 // NOTE: Custom vertex values unused by default + }; + + Model model = { 0 }; + + IQMMesh *imesh = NULL; + IQMTriangle *tri = NULL; + IQMVertexArray *va = NULL; + IQMJoint *ijoint = NULL; + + float *vertex = NULL; + float *normal = NULL; + float *text = NULL; + char *blendi = NULL; + unsigned char *blendw = NULL; + unsigned char *color = NULL; + + // In case file can not be read, return an empty model + if (fileDataPtr == NULL) return model; + + const char *basePath = GetDirectoryPath(fileName); + + // Read IQM header + IQMHeader *iqmHeader = (IQMHeader *)fileDataPtr; + + if (memcmp(iqmHeader->magic, IQM_MAGIC, sizeof(IQM_MAGIC)) != 0) + { + TRACELOG(LOG_WARNING, "MODEL: [%s] IQM file is not a valid model", fileName); + return model; + } + + if (iqmHeader->version != IQM_VERSION) + { + TRACELOG(LOG_WARNING, "MODEL: [%s] IQM file version not supported (%i)", fileName, iqmHeader->version); + return model; + } + + //fileDataPtr += sizeof(IQMHeader); // Move file data pointer + + // Meshes data processing + imesh = RL_MALLOC(iqmHeader->num_meshes*sizeof(IQMMesh)); + //fseek(iqmFile, iqmHeader->ofs_meshes, SEEK_SET); + //fread(imesh, sizeof(IQMMesh)*iqmHeader->num_meshes, 1, iqmFile); + memcpy(imesh, fileDataPtr + iqmHeader->ofs_meshes, iqmHeader->num_meshes*sizeof(IQMMesh)); + + model.meshCount = iqmHeader->num_meshes; + model.meshes = RL_CALLOC(model.meshCount, sizeof(Mesh)); + + model.materialCount = model.meshCount; + model.materials = (Material *)RL_CALLOC(model.materialCount, sizeof(Material)); + model.meshMaterial = (int *)RL_CALLOC(model.meshCount, sizeof(int)); + + char name[MESH_NAME_LENGTH] = { 0 }; + char material[MATERIAL_NAME_LENGTH] = { 0 }; + + for (int i = 0; i < model.meshCount; i++) + { + //fseek(iqmFile, iqmHeader->ofs_text + imesh[i].name, SEEK_SET); + //fread(name, sizeof(char), MESH_NAME_LENGTH, iqmFile); + memcpy(name, fileDataPtr + iqmHeader->ofs_text + imesh[i].name, MESH_NAME_LENGTH*sizeof(char)); + + //fseek(iqmFile, iqmHeader->ofs_text + imesh[i].material, SEEK_SET); + //fread(material, sizeof(char), MATERIAL_NAME_LENGTH, iqmFile); + memcpy(material, fileDataPtr + iqmHeader->ofs_text + imesh[i].material, MATERIAL_NAME_LENGTH*sizeof(char)); + + model.materials[i] = LoadMaterialDefault(); + model.materials[i].maps[MATERIAL_MAP_ALBEDO].texture = LoadTexture(TextFormat("%s/%s", basePath, material)); + + model.meshMaterial[i] = i; + + TRACELOG(LOG_DEBUG, "MODEL: [%s] mesh name (%s), material (%s)", fileName, name, material); + + model.meshes[i].vertexCount = imesh[i].num_vertexes; + + model.meshes[i].vertices = RL_CALLOC(model.meshes[i].vertexCount*3, sizeof(float)); // Default vertex positions + model.meshes[i].normals = RL_CALLOC(model.meshes[i].vertexCount*3, sizeof(float)); // Default vertex normals + model.meshes[i].texcoords = RL_CALLOC(model.meshes[i].vertexCount*2, sizeof(float)); // Default vertex texcoords + + model.meshes[i].boneIds = RL_CALLOC(model.meshes[i].vertexCount*4, sizeof(unsigned char)); // Up-to 4 bones supported! + model.meshes[i].boneWeights = RL_CALLOC(model.meshes[i].vertexCount*4, sizeof(float)); // Up-to 4 bones supported! + + model.meshes[i].triangleCount = imesh[i].num_triangles; + model.meshes[i].indices = RL_CALLOC(model.meshes[i].triangleCount*3, sizeof(unsigned short)); + + // Animated vertex data, what we actually process for rendering + // NOTE: Animated vertex should be re-uploaded to GPU (if not using GPU skinning) + model.meshes[i].animVertices = RL_CALLOC(model.meshes[i].vertexCount*3, sizeof(float)); + model.meshes[i].animNormals = RL_CALLOC(model.meshes[i].vertexCount*3, sizeof(float)); + } + + // Triangles data processing + tri = RL_MALLOC(iqmHeader->num_triangles*sizeof(IQMTriangle)); + //fseek(iqmFile, iqmHeader->ofs_triangles, SEEK_SET); + //fread(tri, sizeof(IQMTriangle), iqmHeader->num_triangles, iqmFile); + memcpy(tri, fileDataPtr + iqmHeader->ofs_triangles, iqmHeader->num_triangles*sizeof(IQMTriangle)); + + for (int m = 0; m < model.meshCount; m++) + { + int tcounter = 0; + + for (unsigned int i = imesh[m].first_triangle; i < (imesh[m].first_triangle + imesh[m].num_triangles); i++) + { + // IQM triangles indexes are stored in counter-clockwise, but raylib processes the index in linear order, + // expecting they point to the counter-clockwise vertex triangle, so we need to reverse triangle indexes + // NOTE: raylib renders vertex data in counter-clockwise order (standard convention) by default + model.meshes[m].indices[tcounter + 2] = tri[i].vertex[0] - imesh[m].first_vertex; + model.meshes[m].indices[tcounter + 1] = tri[i].vertex[1] - imesh[m].first_vertex; + model.meshes[m].indices[tcounter] = tri[i].vertex[2] - imesh[m].first_vertex; + tcounter += 3; + } + } + + // Vertex arrays data processing + va = RL_MALLOC(iqmHeader->num_vertexarrays*sizeof(IQMVertexArray)); + //fseek(iqmFile, iqmHeader->ofs_vertexarrays, SEEK_SET); + //fread(va, sizeof(IQMVertexArray), iqmHeader->num_vertexarrays, iqmFile); + memcpy(va, fileDataPtr + iqmHeader->ofs_vertexarrays, iqmHeader->num_vertexarrays*sizeof(IQMVertexArray)); + + for (unsigned int i = 0; i < iqmHeader->num_vertexarrays; i++) + { + switch (va[i].type) + { + case IQM_POSITION: + { + vertex = RL_MALLOC(iqmHeader->num_vertexes*3*sizeof(float)); + //fseek(iqmFile, va[i].offset, SEEK_SET); + //fread(vertex, iqmHeader->num_vertexes*3*sizeof(float), 1, iqmFile); + memcpy(vertex, fileDataPtr + va[i].offset, iqmHeader->num_vertexes*3*sizeof(float)); + + for (unsigned int m = 0; m < iqmHeader->num_meshes; m++) + { + int vCounter = 0; + for (unsigned int i = imesh[m].first_vertex*3; i < (imesh[m].first_vertex + imesh[m].num_vertexes)*3; i++) + { + model.meshes[m].vertices[vCounter] = vertex[i]; + model.meshes[m].animVertices[vCounter] = vertex[i]; + vCounter++; + } + } + } break; + case IQM_NORMAL: + { + normal = RL_MALLOC(iqmHeader->num_vertexes*3*sizeof(float)); + //fseek(iqmFile, va[i].offset, SEEK_SET); + //fread(normal, iqmHeader->num_vertexes*3*sizeof(float), 1, iqmFile); + memcpy(normal, fileDataPtr + va[i].offset, iqmHeader->num_vertexes*3*sizeof(float)); + + for (unsigned int m = 0; m < iqmHeader->num_meshes; m++) + { + int vCounter = 0; + for (unsigned int i = imesh[m].first_vertex*3; i < (imesh[m].first_vertex + imesh[m].num_vertexes)*3; i++) + { + model.meshes[m].normals[vCounter] = normal[i]; + model.meshes[m].animNormals[vCounter] = normal[i]; + vCounter++; + } + } + } break; + case IQM_TEXCOORD: + { + text = RL_MALLOC(iqmHeader->num_vertexes*2*sizeof(float)); + //fseek(iqmFile, va[i].offset, SEEK_SET); + //fread(text, iqmHeader->num_vertexes*2*sizeof(float), 1, iqmFile); + memcpy(text, fileDataPtr + va[i].offset, iqmHeader->num_vertexes*2*sizeof(float)); + + for (unsigned int m = 0; m < iqmHeader->num_meshes; m++) + { + int vCounter = 0; + for (unsigned int i = imesh[m].first_vertex*2; i < (imesh[m].first_vertex + imesh[m].num_vertexes)*2; i++) + { + model.meshes[m].texcoords[vCounter] = text[i]; + vCounter++; + } + } + } break; + case IQM_BLENDINDEXES: + { + blendi = RL_MALLOC(iqmHeader->num_vertexes*4*sizeof(char)); + //fseek(iqmFile, va[i].offset, SEEK_SET); + //fread(blendi, iqmHeader->num_vertexes*4*sizeof(char), 1, iqmFile); + memcpy(blendi, fileDataPtr + va[i].offset, iqmHeader->num_vertexes*4*sizeof(char)); + + for (unsigned int m = 0; m < iqmHeader->num_meshes; m++) + { + int boneCounter = 0; + for (unsigned int i = imesh[m].first_vertex*4; i < (imesh[m].first_vertex + imesh[m].num_vertexes)*4; i++) + { + model.meshes[m].boneIds[boneCounter] = blendi[i]; + boneCounter++; + } + } + } break; + case IQM_BLENDWEIGHTS: + { + blendw = RL_MALLOC(iqmHeader->num_vertexes*4*sizeof(unsigned char)); + //fseek(iqmFile, va[i].offset, SEEK_SET); + //fread(blendw, iqmHeader->num_vertexes*4*sizeof(unsigned char), 1, iqmFile); + memcpy(blendw, fileDataPtr + va[i].offset, iqmHeader->num_vertexes*4*sizeof(unsigned char)); + + for (unsigned int m = 0; m < iqmHeader->num_meshes; m++) + { + int boneCounter = 0; + for (unsigned int i = imesh[m].first_vertex*4; i < (imesh[m].first_vertex + imesh[m].num_vertexes)*4; i++) + { + model.meshes[m].boneWeights[boneCounter] = blendw[i]/255.0f; + boneCounter++; + } + } + } break; + case IQM_COLOR: + { + color = RL_MALLOC(iqmHeader->num_vertexes*4*sizeof(unsigned char)); + //fseek(iqmFile, va[i].offset, SEEK_SET); + //fread(blendw, iqmHeader->num_vertexes*4*sizeof(unsigned char), 1, iqmFile); + memcpy(color, fileDataPtr + va[i].offset, iqmHeader->num_vertexes*4*sizeof(unsigned char)); + + for (unsigned int m = 0; m < iqmHeader->num_meshes; m++) + { + model.meshes[m].colors = RL_CALLOC(model.meshes[m].vertexCount*4, sizeof(unsigned char)); + + int vCounter = 0; + for (unsigned int i = imesh[m].first_vertex*4; i < (imesh[m].first_vertex + imesh[m].num_vertexes)*4; i++) + { + model.meshes[m].colors[vCounter] = color[i]; + vCounter++; + } + } + } break; + } + } + + // Bones (joints) data processing + ijoint = RL_MALLOC(iqmHeader->num_joints*sizeof(IQMJoint)); + //fseek(iqmFile, iqmHeader->ofs_joints, SEEK_SET); + //fread(ijoint, sizeof(IQMJoint), iqmHeader->num_joints, iqmFile); + memcpy(ijoint, fileDataPtr + iqmHeader->ofs_joints, iqmHeader->num_joints*sizeof(IQMJoint)); + + model.boneCount = iqmHeader->num_joints; + model.bones = RL_MALLOC(iqmHeader->num_joints*sizeof(BoneInfo)); + model.bindPose = RL_MALLOC(iqmHeader->num_joints*sizeof(Transform)); + + for (unsigned int i = 0; i < iqmHeader->num_joints; i++) + { + // Bones + model.bones[i].parent = ijoint[i].parent; + //fseek(iqmFile, iqmHeader->ofs_text + ijoint[i].name, SEEK_SET); + //fread(model.bones[i].name, sizeof(char), BONE_NAME_LENGTH, iqmFile); + memcpy(model.bones[i].name, fileDataPtr + iqmHeader->ofs_text + ijoint[i].name, BONE_NAME_LENGTH*sizeof(char)); + + // Bind pose (base pose) + model.bindPose[i].translation.x = ijoint[i].translate[0]; + model.bindPose[i].translation.y = ijoint[i].translate[1]; + model.bindPose[i].translation.z = ijoint[i].translate[2]; + + model.bindPose[i].rotation.x = ijoint[i].rotate[0]; + model.bindPose[i].rotation.y = ijoint[i].rotate[1]; + model.bindPose[i].rotation.z = ijoint[i].rotate[2]; + model.bindPose[i].rotation.w = ijoint[i].rotate[3]; + + model.bindPose[i].scale.x = ijoint[i].scale[0]; + model.bindPose[i].scale.y = ijoint[i].scale[1]; + model.bindPose[i].scale.z = ijoint[i].scale[2]; + } + + BuildPoseFromParentJoints(model.bones, model.boneCount, model.bindPose); + + UnloadFileData(fileData); + + RL_FREE(imesh); + RL_FREE(tri); + RL_FREE(va); + RL_FREE(vertex); + RL_FREE(normal); + RL_FREE(text); + RL_FREE(blendi); + RL_FREE(blendw); + RL_FREE(ijoint); + RL_FREE(color); + + return model; +} + +// Load IQM animation data +static ModelAnimation *LoadModelAnimationsIQM(const char *fileName, int *animCount) +{ + #define IQM_MAGIC "INTERQUAKEMODEL" // IQM file magic number + #define IQM_VERSION 2 // only IQM version 2 supported + + int dataSize = 0; + unsigned char *fileData = LoadFileData(fileName, &dataSize); + unsigned char *fileDataPtr = fileData; + + typedef struct IQMHeader { + char magic[16]; + unsigned int version; + unsigned int dataSize; + unsigned int flags; + unsigned int num_text, ofs_text; + unsigned int num_meshes, ofs_meshes; + unsigned int num_vertexarrays, num_vertexes, ofs_vertexarrays; + unsigned int num_triangles, ofs_triangles, ofs_adjacency; + unsigned int num_joints, ofs_joints; + unsigned int num_poses, ofs_poses; + unsigned int num_anims, ofs_anims; + unsigned int num_frames, num_framechannels, ofs_frames, ofs_bounds; + unsigned int num_comment, ofs_comment; + unsigned int num_extensions, ofs_extensions; + } IQMHeader; + + typedef struct IQMJoint { + unsigned int name; + int parent; + float translate[3], rotate[4], scale[3]; + } IQMJoint; + + typedef struct IQMPose { + int parent; + unsigned int mask; + float channeloffset[10]; + float channelscale[10]; + } IQMPose; + + typedef struct IQMAnim { + unsigned int name; + unsigned int first_frame, num_frames; + float framerate; + unsigned int flags; + } IQMAnim; + + // In case file can not be read, return an empty model + if (fileDataPtr == NULL) return NULL; + + // Read IQM header + IQMHeader *iqmHeader = (IQMHeader *)fileDataPtr; + + if (memcmp(iqmHeader->magic, IQM_MAGIC, sizeof(IQM_MAGIC)) != 0) + { + TRACELOG(LOG_WARNING, "MODEL: [%s] IQM file is not a valid model", fileName); + return NULL; + } + + if (iqmHeader->version != IQM_VERSION) + { + TRACELOG(LOG_WARNING, "MODEL: [%s] IQM file version not supported (%i)", fileName, iqmHeader->version); + return NULL; + } + + // Get bones data + IQMPose *poses = RL_MALLOC(iqmHeader->num_poses*sizeof(IQMPose)); + //fseek(iqmFile, iqmHeader->ofs_poses, SEEK_SET); + //fread(poses, sizeof(IQMPose), iqmHeader->num_poses, iqmFile); + memcpy(poses, fileDataPtr + iqmHeader->ofs_poses, iqmHeader->num_poses*sizeof(IQMPose)); + + // Get animations data + *animCount = iqmHeader->num_anims; + IQMAnim *anim = RL_MALLOC(iqmHeader->num_anims*sizeof(IQMAnim)); + //fseek(iqmFile, iqmHeader->ofs_anims, SEEK_SET); + //fread(anim, sizeof(IQMAnim), iqmHeader->num_anims, iqmFile); + memcpy(anim, fileDataPtr + iqmHeader->ofs_anims, iqmHeader->num_anims*sizeof(IQMAnim)); + + ModelAnimation *animations = RL_MALLOC(iqmHeader->num_anims*sizeof(ModelAnimation)); + + // frameposes + unsigned short *framedata = RL_MALLOC(iqmHeader->num_frames*iqmHeader->num_framechannels*sizeof(unsigned short)); + //fseek(iqmFile, iqmHeader->ofs_frames, SEEK_SET); + //fread(framedata, sizeof(unsigned short), iqmHeader->num_frames*iqmHeader->num_framechannels, iqmFile); + memcpy(framedata, fileDataPtr + iqmHeader->ofs_frames, iqmHeader->num_frames*iqmHeader->num_framechannels*sizeof(unsigned short)); + + // joints + IQMJoint *joints = RL_MALLOC(iqmHeader->num_joints*sizeof(IQMJoint)); + memcpy(joints, fileDataPtr + iqmHeader->ofs_joints, iqmHeader->num_joints*sizeof(IQMJoint)); + + for (unsigned int a = 0; a < iqmHeader->num_anims; a++) + { + animations[a].frameCount = anim[a].num_frames; + animations[a].boneCount = iqmHeader->num_poses; + animations[a].bones = RL_MALLOC(iqmHeader->num_poses*sizeof(BoneInfo)); + animations[a].framePoses = RL_MALLOC(anim[a].num_frames*sizeof(Transform *)); + memcpy(animations[a].name, fileDataPtr + iqmHeader->ofs_text + anim[a].name, 32); // I don't like this 32 here + TraceLog(LOG_INFO, "IQM Anim %s", animations[a].name); + // animations[a].framerate = anim.framerate; // TODO: Use animation framerate data? + + for (unsigned int j = 0; j < iqmHeader->num_poses; j++) + { + // If animations and skeleton are in the same file, copy bone names to anim + if (iqmHeader->num_joints > 0) + memcpy(animations[a].bones[j].name, fileDataPtr + iqmHeader->ofs_text + joints[j].name, BONE_NAME_LENGTH*sizeof(char)); + else + strcpy(animations[a].bones[j].name, "ANIMJOINTNAME"); // default bone name otherwise + animations[a].bones[j].parent = poses[j].parent; + } + + for (unsigned int j = 0; j < anim[a].num_frames; j++) animations[a].framePoses[j] = RL_MALLOC(iqmHeader->num_poses*sizeof(Transform)); + + int dcounter = anim[a].first_frame*iqmHeader->num_framechannels; + + for (unsigned int frame = 0; frame < anim[a].num_frames; frame++) + { + for (unsigned int i = 0; i < iqmHeader->num_poses; i++) + { + animations[a].framePoses[frame][i].translation.x = poses[i].channeloffset[0]; + + if (poses[i].mask & 0x01) + { + animations[a].framePoses[frame][i].translation.x += framedata[dcounter]*poses[i].channelscale[0]; + dcounter++; + } + + animations[a].framePoses[frame][i].translation.y = poses[i].channeloffset[1]; + + if (poses[i].mask & 0x02) + { + animations[a].framePoses[frame][i].translation.y += framedata[dcounter]*poses[i].channelscale[1]; + dcounter++; + } + + animations[a].framePoses[frame][i].translation.z = poses[i].channeloffset[2]; + + if (poses[i].mask & 0x04) + { + animations[a].framePoses[frame][i].translation.z += framedata[dcounter]*poses[i].channelscale[2]; + dcounter++; + } + + animations[a].framePoses[frame][i].rotation.x = poses[i].channeloffset[3]; + + if (poses[i].mask & 0x08) + { + animations[a].framePoses[frame][i].rotation.x += framedata[dcounter]*poses[i].channelscale[3]; + dcounter++; + } + + animations[a].framePoses[frame][i].rotation.y = poses[i].channeloffset[4]; + + if (poses[i].mask & 0x10) + { + animations[a].framePoses[frame][i].rotation.y += framedata[dcounter]*poses[i].channelscale[4]; + dcounter++; + } + + animations[a].framePoses[frame][i].rotation.z = poses[i].channeloffset[5]; + + if (poses[i].mask & 0x20) + { + animations[a].framePoses[frame][i].rotation.z += framedata[dcounter]*poses[i].channelscale[5]; + dcounter++; + } + + animations[a].framePoses[frame][i].rotation.w = poses[i].channeloffset[6]; + + if (poses[i].mask & 0x40) + { + animations[a].framePoses[frame][i].rotation.w += framedata[dcounter]*poses[i].channelscale[6]; + dcounter++; + } + + animations[a].framePoses[frame][i].scale.x = poses[i].channeloffset[7]; + + if (poses[i].mask & 0x80) + { + animations[a].framePoses[frame][i].scale.x += framedata[dcounter]*poses[i].channelscale[7]; + dcounter++; + } + + animations[a].framePoses[frame][i].scale.y = poses[i].channeloffset[8]; + + if (poses[i].mask & 0x100) + { + animations[a].framePoses[frame][i].scale.y += framedata[dcounter]*poses[i].channelscale[8]; + dcounter++; + } + + animations[a].framePoses[frame][i].scale.z = poses[i].channeloffset[9]; + + if (poses[i].mask & 0x200) + { + animations[a].framePoses[frame][i].scale.z += framedata[dcounter]*poses[i].channelscale[9]; + dcounter++; + } + + animations[a].framePoses[frame][i].rotation = QuaternionNormalize(animations[a].framePoses[frame][i].rotation); + } + } + + // Build frameposes + for (unsigned int frame = 0; frame < anim[a].num_frames; frame++) + { + for (int i = 0; i < animations[a].boneCount; i++) + { + if (animations[a].bones[i].parent >= 0) + { + animations[a].framePoses[frame][i].rotation = QuaternionMultiply(animations[a].framePoses[frame][animations[a].bones[i].parent].rotation, animations[a].framePoses[frame][i].rotation); + animations[a].framePoses[frame][i].translation = Vector3RotateByQuaternion(animations[a].framePoses[frame][i].translation, animations[a].framePoses[frame][animations[a].bones[i].parent].rotation); + animations[a].framePoses[frame][i].translation = Vector3Add(animations[a].framePoses[frame][i].translation, animations[a].framePoses[frame][animations[a].bones[i].parent].translation); + animations[a].framePoses[frame][i].scale = Vector3Multiply(animations[a].framePoses[frame][i].scale, animations[a].framePoses[frame][animations[a].bones[i].parent].scale); + } + } + } + } + + UnloadFileData(fileData); + + RL_FREE(joints); + RL_FREE(framedata); + RL_FREE(poses); + RL_FREE(anim); + + return animations; +} + +#endif + +#if defined(SUPPORT_FILEFORMAT_GLTF) +// Load file data callback for cgltf +static cgltf_result LoadFileGLTFCallback(const struct cgltf_memory_options *memoryOptions, const struct cgltf_file_options *fileOptions, const char *path, cgltf_size *size, void **data) +{ + int filesize; + unsigned char *filedata = LoadFileData(path, &filesize); + + if (filedata == NULL) return cgltf_result_io_error; + + *size = filesize; + *data = filedata; + + return cgltf_result_success; +} + +// Release file data callback for cgltf +static void ReleaseFileGLTFCallback(const struct cgltf_memory_options *memoryOptions, const struct cgltf_file_options *fileOptions, void *data) +{ + UnloadFileData(data); +} + +// Load image from different glTF provided methods (uri, path, buffer_view) +static Image LoadImageFromCgltfImage(cgltf_image *cgltfImage, const char *texPath) +{ + Image image = { 0 }; + + if (cgltfImage->uri != NULL) // Check if image data is provided as an uri (base64 or path) + { + if ((strlen(cgltfImage->uri) > 5) && + (cgltfImage->uri[0] == 'd') && + (cgltfImage->uri[1] == 'a') && + (cgltfImage->uri[2] == 't') && + (cgltfImage->uri[3] == 'a') && + (cgltfImage->uri[4] == ':')) // Check if image is provided as base64 text data + { + // Data URI Format: data:;base64, + + // Find the comma + int i = 0; + while ((cgltfImage->uri[i] != ',') && (cgltfImage->uri[i] != 0)) i++; + + if (cgltfImage->uri[i] == 0) TRACELOG(LOG_WARNING, "IMAGE: glTF data URI is not a valid image"); + else + { + int base64Size = (int)strlen(cgltfImage->uri + i + 1); + while (cgltfImage->uri[i + base64Size] == '=') base64Size--; // Ignore optional paddings + int numberOfEncodedBits = base64Size*6 - (base64Size*6) % 8 ; // Encoded bits minus extra bits, so it becomes a multiple of 8 bits + int outSize = numberOfEncodedBits/8 ; // Actual encoded bytes + void *data = NULL; + + cgltf_options options = { 0 }; + options.file.read = LoadFileGLTFCallback; + options.file.release = ReleaseFileGLTFCallback; + cgltf_result result = cgltf_load_buffer_base64(&options, outSize, cgltfImage->uri + i + 1, &data); + + if (result == cgltf_result_success) + { + image = LoadImageFromMemory(".png", (unsigned char *)data, outSize); + RL_FREE(data); + } + } + } + else // Check if image is provided as image path + { + image = LoadImage(TextFormat("%s/%s", texPath, cgltfImage->uri)); + } + } + else if (cgltfImage->buffer_view->buffer->data != NULL) // Check if image is provided as data buffer + { + unsigned char *data = RL_MALLOC(cgltfImage->buffer_view->size); + int offset = (int)cgltfImage->buffer_view->offset; + int stride = (int)cgltfImage->buffer_view->stride? (int)cgltfImage->buffer_view->stride : 1; + + // Copy buffer data to memory for loading + for (unsigned int i = 0; i < cgltfImage->buffer_view->size; i++) + { + data[i] = ((unsigned char *)cgltfImage->buffer_view->buffer->data)[offset]; + offset += stride; + } + + // Check mime_type for image: (cgltfImage->mime_type == "image/png") + // NOTE: Detected that some models define mime_type as "image\\/png" + if ((strcmp(cgltfImage->mime_type, "image\\/png") == 0) || + (strcmp(cgltfImage->mime_type, "image/png") == 0)) image = LoadImageFromMemory(".png", data, (int)cgltfImage->buffer_view->size); + else if ((strcmp(cgltfImage->mime_type, "image\\/jpeg") == 0) || + (strcmp(cgltfImage->mime_type, "image/jpeg") == 0)) image = LoadImageFromMemory(".jpg", data, (int)cgltfImage->buffer_view->size); + else TRACELOG(LOG_WARNING, "MODEL: glTF image data MIME type not recognized", TextFormat("%s/%s", texPath, cgltfImage->uri)); + + RL_FREE(data); + } + + return image; +} + +// Load bone info from GLTF skin data +static BoneInfo *LoadBoneInfoGLTF(cgltf_skin skin, int *boneCount) +{ + *boneCount = (int)skin.joints_count; + BoneInfo *bones = RL_MALLOC(skin.joints_count*sizeof(BoneInfo)); + + for (unsigned int i = 0; i < skin.joints_count; i++) + { + cgltf_node node = *skin.joints[i]; + if (node.name != NULL) + { + strncpy(bones[i].name, node.name, sizeof(bones[i].name)); + bones[i].name[sizeof(bones[i].name) - 1] = '\0'; + } + + // Find parent bone index + int parentIndex = -1; + + for (unsigned int j = 0; j < skin.joints_count; j++) + { + if (skin.joints[j] == node.parent) + { + parentIndex = (int)j; + break; + } + } + + bones[i].parent = parentIndex; + } + + return bones; +} + +// Load glTF file into model struct, .gltf and .glb supported +static Model LoadGLTF(const char *fileName) +{ + /********************************************************************************************* + + Function implemented by Wilhem Barbier(@wbrbr), with modifications by Tyler Bezera(@gamerfiend) + Transform handling implemented by Paul Melis (@paulmelis). + Reviewed by Ramon Santamaria (@raysan5) + + FEATURES: + - Supports .gltf and .glb files + - Supports embedded (base64) or external textures + - Supports PBR metallic/roughness flow, loads material textures, values and colors + PBR specular/glossiness flow and extended texture flows not supported + - Supports multiple meshes per model (every primitives is loaded as a separate mesh) + - Supports basic animations + - Transforms, including parent-child relations, are applied on the mesh data, but the + hierarchy is not kept (as it can't be represented). + - Mesh instances in the glTF file (i.e. same mesh linked from multiple nodes) + are turned into separate raylib Meshes. + + RESTRICTIONS: + - Only triangle meshes supported + - Vertex attribute types and formats supported: + > Vertices (position): vec3: float + > Normals: vec3: float + > Texcoords: vec2: float + > Colors: vec4: u8, u16, f32 (normalized) + > Indices: u16, u32 (truncated to u16) + - Scenes defined in the glTF file are ignored. All nodes in the file + are used. + + ***********************************************************************************************/ + + // Macro to simplify attributes loading code + #define LOAD_ATTRIBUTE(accesor, numComp, dataType, dstPtr) \ + { \ + int n = 0; \ + dataType *buffer = (dataType *)accesor->buffer_view->buffer->data + accesor->buffer_view->offset/sizeof(dataType) + accesor->offset/sizeof(dataType); \ + for (unsigned int k = 0; k < accesor->count; k++) \ + {\ + for (int l = 0; l < numComp; l++) \ + {\ + dstPtr[numComp*k + l] = buffer[n + l];\ + }\ + n += (int)(accesor->stride/sizeof(dataType));\ + }\ + } + + Model model = { 0 }; + + // glTF file loading + int dataSize = 0; + unsigned char *fileData = LoadFileData(fileName, &dataSize); + + if (fileData == NULL) return model; + + // glTF data loading + cgltf_options options = { 0 }; + options.file.read = LoadFileGLTFCallback; + options.file.release = ReleaseFileGLTFCallback; + cgltf_data *data = NULL; + cgltf_result result = cgltf_parse(&options, fileData, dataSize, &data); + + if (result == cgltf_result_success) + { + if (data->file_type == cgltf_file_type_glb) TRACELOG(LOG_INFO, "MODEL: [%s] Model basic data (glb) loaded successfully", fileName); + else if (data->file_type == cgltf_file_type_gltf) TRACELOG(LOG_INFO, "MODEL: [%s] Model basic data (glTF) loaded successfully", fileName); + else TRACELOG(LOG_WARNING, "MODEL: [%s] Model format not recognized", fileName); + + TRACELOG(LOG_INFO, " > Meshes count: %i", data->meshes_count); + TRACELOG(LOG_INFO, " > Materials count: %i (+1 default)", data->materials_count); + TRACELOG(LOG_DEBUG, " > Buffers count: %i", data->buffers_count); + TRACELOG(LOG_DEBUG, " > Images count: %i", data->images_count); + TRACELOG(LOG_DEBUG, " > Textures count: %i", data->textures_count); + + // Force reading data buffers (fills buffer_view->buffer->data) + // NOTE: If an uri is defined to base64 data or external path, it's automatically loaded + result = cgltf_load_buffers(&options, data, fileName); + if (result != cgltf_result_success) TRACELOG(LOG_INFO, "MODEL: [%s] Failed to load mesh/material buffers", fileName); + + int primitivesCount = 0; + // NOTE: We will load every primitive in the glTF as a separate raylib Mesh. + // Determine total number of meshes needed from the node hierarchy. + for (unsigned int i = 0; i < data->nodes_count; i++) + { + cgltf_node *node = &(data->nodes[i]); + cgltf_mesh *mesh = node->mesh; + if (!mesh) + continue; + + for (unsigned int p = 0; p < mesh->primitives_count; p++) + { + if (mesh->primitives[p].type == cgltf_primitive_type_triangles) + primitivesCount++; + } + } + TRACELOG(LOG_DEBUG, " > Primitives (triangles only) count based on hierarchy : %i", primitivesCount); + + // Load our model data: meshes and materials + model.meshCount = primitivesCount; + model.meshes = RL_CALLOC(model.meshCount, sizeof(Mesh)); + + // NOTE: We keep an extra slot for default material, in case some mesh requires it + model.materialCount = (int)data->materials_count + 1; + model.materials = RL_CALLOC(model.materialCount, sizeof(Material)); + model.materials[0] = LoadMaterialDefault(); // Load default material (index: 0) + + // Load mesh-material indices, by default all meshes are mapped to material index: 0 + model.meshMaterial = RL_CALLOC(model.meshCount, sizeof(int)); + + // Load materials data + //---------------------------------------------------------------------------------------------------- + for (unsigned int i = 0, j = 1; i < data->materials_count; i++, j++) + { + model.materials[j] = LoadMaterialDefault(); + const char *texPath = GetDirectoryPath(fileName); + + // Check glTF material flow: PBR metallic/roughness flow + // NOTE: Alternatively, materials can follow PBR specular/glossiness flow + if (data->materials[i].has_pbr_metallic_roughness) + { + // Load base color texture (albedo) + if (data->materials[i].pbr_metallic_roughness.base_color_texture.texture) + { + Image imAlbedo = LoadImageFromCgltfImage(data->materials[i].pbr_metallic_roughness.base_color_texture.texture->image, texPath); + if (imAlbedo.data != NULL) + { + model.materials[j].maps[MATERIAL_MAP_ALBEDO].texture = LoadTextureFromImage(imAlbedo); + UnloadImage(imAlbedo); + } + } + // Load base color factor (tint) + model.materials[j].maps[MATERIAL_MAP_ALBEDO].color.r = (unsigned char)(data->materials[i].pbr_metallic_roughness.base_color_factor[0]*255); + model.materials[j].maps[MATERIAL_MAP_ALBEDO].color.g = (unsigned char)(data->materials[i].pbr_metallic_roughness.base_color_factor[1]*255); + model.materials[j].maps[MATERIAL_MAP_ALBEDO].color.b = (unsigned char)(data->materials[i].pbr_metallic_roughness.base_color_factor[2]*255); + model.materials[j].maps[MATERIAL_MAP_ALBEDO].color.a = (unsigned char)(data->materials[i].pbr_metallic_roughness.base_color_factor[3]*255); + + // Load metallic/roughness texture + if (data->materials[i].pbr_metallic_roughness.metallic_roughness_texture.texture) + { + Image imMetallicRoughness = LoadImageFromCgltfImage(data->materials[i].pbr_metallic_roughness.metallic_roughness_texture.texture->image, texPath); + if (imMetallicRoughness.data != NULL) + { + model.materials[j].maps[MATERIAL_MAP_ROUGHNESS].texture = LoadTextureFromImage(imMetallicRoughness); + UnloadImage(imMetallicRoughness); + } + + // Load metallic/roughness material properties + float roughness = data->materials[i].pbr_metallic_roughness.roughness_factor; + model.materials[j].maps[MATERIAL_MAP_ROUGHNESS].value = roughness; + + float metallic = data->materials[i].pbr_metallic_roughness.metallic_factor; + model.materials[j].maps[MATERIAL_MAP_METALNESS].value = metallic; + } + + // Load normal texture + if (data->materials[i].normal_texture.texture) + { + Image imNormal = LoadImageFromCgltfImage(data->materials[i].normal_texture.texture->image, texPath); + if (imNormal.data != NULL) + { + model.materials[j].maps[MATERIAL_MAP_NORMAL].texture = LoadTextureFromImage(imNormal); + UnloadImage(imNormal); + } + } + + // Load ambient occlusion texture + if (data->materials[i].occlusion_texture.texture) + { + Image imOcclusion = LoadImageFromCgltfImage(data->materials[i].occlusion_texture.texture->image, texPath); + if (imOcclusion.data != NULL) + { + model.materials[j].maps[MATERIAL_MAP_OCCLUSION].texture = LoadTextureFromImage(imOcclusion); + UnloadImage(imOcclusion); + } + } + + // Load emissive texture + if (data->materials[i].emissive_texture.texture) + { + Image imEmissive = LoadImageFromCgltfImage(data->materials[i].emissive_texture.texture->image, texPath); + if (imEmissive.data != NULL) + { + model.materials[j].maps[MATERIAL_MAP_EMISSION].texture = LoadTextureFromImage(imEmissive); + UnloadImage(imEmissive); + } + + // Load emissive color factor + model.materials[j].maps[MATERIAL_MAP_EMISSION].color.r = (unsigned char)(data->materials[i].emissive_factor[0]*255); + model.materials[j].maps[MATERIAL_MAP_EMISSION].color.g = (unsigned char)(data->materials[i].emissive_factor[1]*255); + model.materials[j].maps[MATERIAL_MAP_EMISSION].color.b = (unsigned char)(data->materials[i].emissive_factor[2]*255); + model.materials[j].maps[MATERIAL_MAP_EMISSION].color.a = 255; + } + } + + // Other possible materials not supported by raylib pipeline: + // has_clearcoat, has_transmission, has_volume, has_ior, has specular, has_sheen + } + + // Visit each node in the hierarchy and process any mesh linked from it. + // Each primitive within a glTF node becomes a Raylib Mesh. + // The local-to-world transform of each node is used to transform the + // points/normals/tangents of the created Mesh(es). + // Any glTF mesh linked from more than one Node (i.e. instancing) + // is turned into multiple Mesh's, as each Node will have its own + // transform applied. + // Note: the code below disregards the scenes defined in the file, all nodes are used. + //---------------------------------------------------------------------------------------------------- + int meshIndex = 0; + for (unsigned int i = 0; i < data->nodes_count; i++) + { + cgltf_node *node = &(data->nodes[i]); + + cgltf_mesh *mesh = node->mesh; + if (!mesh) + continue; + + cgltf_float worldTransform[16]; + cgltf_node_transform_world(node, worldTransform); + + Matrix worldMatrix = { + worldTransform[0], worldTransform[4], worldTransform[8], worldTransform[12], + worldTransform[1], worldTransform[5], worldTransform[9], worldTransform[13], + worldTransform[2], worldTransform[6], worldTransform[10], worldTransform[14], + worldTransform[3], worldTransform[7], worldTransform[11], worldTransform[15] + }; + + Matrix worldMatrixNormals = MatrixTranspose(MatrixInvert(worldMatrix)); + + for (unsigned int p = 0; p < mesh->primitives_count; p++) + { + // NOTE: We only support primitives defined by triangles + // Other alternatives: points, lines, line_strip, triangle_strip + if (mesh->primitives[p].type != cgltf_primitive_type_triangles) continue; + + // NOTE: Attributes data could be provided in several data formats (8, 8u, 16u, 32...), + // Only some formats for each attribute type are supported, read info at the top of this function! + + for (unsigned int j = 0; j < mesh->primitives[p].attributes_count; j++) + { + // Check the different attributes for every primitive + if (mesh->primitives[p].attributes[j].type == cgltf_attribute_type_position) // POSITION, vec3, float + { + cgltf_accessor *attribute = mesh->primitives[p].attributes[j].data; + + // WARNING: SPECS: POSITION accessor MUST have its min and max properties defined + + if ((attribute->type == cgltf_type_vec3) && (attribute->component_type == cgltf_component_type_r_32f)) + { + // Init raylib mesh vertices to copy glTF attribute data + model.meshes[meshIndex].vertexCount = (int)attribute->count; + model.meshes[meshIndex].vertices = RL_MALLOC(attribute->count*3*sizeof(float)); + + // Load 3 components of float data type into mesh.vertices + LOAD_ATTRIBUTE(attribute, 3, float, model.meshes[meshIndex].vertices) + + // Transform the vertices + float *vertices = model.meshes[meshIndex].vertices; + for (unsigned int k = 0; k < attribute->count; k++) + { + Vector3 vt = Vector3Transform((Vector3){ vertices[3*k], vertices[3*k+1], vertices[3*k+2] }, worldMatrix); + vertices[3*k] = vt.x; + vertices[3*k+1] = vt.y; + vertices[3*k+2] = vt.z; + } + } + else TRACELOG(LOG_WARNING, "MODEL: [%s] Vertices attribute data format not supported, use vec3 float", fileName); + } + else if (mesh->primitives[p].attributes[j].type == cgltf_attribute_type_normal) // NORMAL, vec3, float + { + cgltf_accessor *attribute = mesh->primitives[p].attributes[j].data; + + if ((attribute->type == cgltf_type_vec3) && (attribute->component_type == cgltf_component_type_r_32f)) + { + // Init raylib mesh normals to copy glTF attribute data + model.meshes[meshIndex].normals = RL_MALLOC(attribute->count*3*sizeof(float)); + + // Load 3 components of float data type into mesh.normals + LOAD_ATTRIBUTE(attribute, 3, float, model.meshes[meshIndex].normals) + + // Transform the normals + float *normals = model.meshes[meshIndex].normals; + for (unsigned int k = 0; k < attribute->count; k++) + { + Vector3 nt = Vector3Transform((Vector3){ normals[3*k], normals[3*k+1], normals[3*k+2] }, worldMatrixNormals); + normals[3*k] = nt.x; + normals[3*k+1] = nt.y; + normals[3*k+2] = nt.z; + } + } + else TRACELOG(LOG_WARNING, "MODEL: [%s] Normal attribute data format not supported, use vec3 float", fileName); + } + else if (mesh->primitives[p].attributes[j].type == cgltf_attribute_type_tangent) // TANGENT, vec3, float + { + cgltf_accessor *attribute = mesh->primitives[p].attributes[j].data; + + if ((attribute->type == cgltf_type_vec4) && (attribute->component_type == cgltf_component_type_r_32f)) + { + // Init raylib mesh tangent to copy glTF attribute data + model.meshes[meshIndex].tangents = RL_MALLOC(attribute->count*4*sizeof(float)); + + // Load 4 components of float data type into mesh.tangents + LOAD_ATTRIBUTE(attribute, 4, float, model.meshes[meshIndex].tangents) + + // Transform the tangents + float *tangents = model.meshes[meshIndex].tangents; + for (unsigned int k = 0; k < attribute->count; k++) + { + Vector3 tt = Vector3Transform((Vector3){ tangents[3*k], tangents[3*k+1], tangents[3*k+2] }, worldMatrix); + tangents[3*k] = tt.x; + tangents[3*k+1] = tt.y; + tangents[3*k+2] = tt.z; + } + } + else TRACELOG(LOG_WARNING, "MODEL: [%s] Tangent attribute data format not supported, use vec4 float", fileName); + } + else if (mesh->primitives[p].attributes[j].type == cgltf_attribute_type_texcoord) // TEXCOORD_n, vec2, float/u8n/u16n + { + // Support up to 2 texture coordinates attributes + float *texcoordPtr = NULL; + + cgltf_accessor *attribute = mesh->primitives[p].attributes[j].data; + + if (attribute->type == cgltf_type_vec2) + { + if (attribute->component_type == cgltf_component_type_r_32f) // vec2, float + { + // Init raylib mesh texcoords to copy glTF attribute data + texcoordPtr = (float *)RL_MALLOC(attribute->count*2*sizeof(float)); + + // Load 3 components of float data type into mesh.texcoords + LOAD_ATTRIBUTE(attribute, 2, float, texcoordPtr) + } + else if (attribute->component_type == cgltf_component_type_r_8u) // vec2, u8n + { + // Init raylib mesh texcoords to copy glTF attribute data + texcoordPtr = (float *)RL_MALLOC(attribute->count*2*sizeof(float)); + + // Load data into a temp buffer to be converted to raylib data type + unsigned char *temp = (unsigned char *)RL_MALLOC(attribute->count*2*sizeof(unsigned char)); + LOAD_ATTRIBUTE(attribute, 2, unsigned char, temp); + + // Convert data to raylib texcoord data type (float) + for (unsigned int t = 0; t < attribute->count*2; t++) texcoordPtr[t] = (float)temp[t]/255.0f; + + RL_FREE(temp); + } + else if (attribute->component_type == cgltf_component_type_r_16u) // vec2, u16n + { + // Init raylib mesh texcoords to copy glTF attribute data + texcoordPtr = (float *)RL_MALLOC(attribute->count*2*sizeof(float)); + + // Load data into a temp buffer to be converted to raylib data type + unsigned short *temp = (unsigned short *)RL_MALLOC(attribute->count*2*sizeof(unsigned short)); + LOAD_ATTRIBUTE(attribute, 2, unsigned short, temp); + + // Convert data to raylib texcoord data type (float) + for (unsigned int t = 0; t < attribute->count*2; t++) texcoordPtr[t] = (float)temp[t]/65535.0f; + + RL_FREE(temp); + } + else TRACELOG(LOG_WARNING, "MODEL: [%s] Texcoords attribute data format not supported", fileName); + } + else TRACELOG(LOG_WARNING, "MODEL: [%s] Texcoords attribute data format not supported, use vec2 float", fileName); + + int index = mesh->primitives[p].attributes[j].index; + if (index == 0) model.meshes[meshIndex].texcoords = texcoordPtr; + else if (index == 1) model.meshes[meshIndex].texcoords2 = texcoordPtr; + else + { + TRACELOG(LOG_WARNING, "MODEL: [%s] No more than 2 texture coordinates attributes supported", fileName); + if (texcoordPtr != NULL) RL_FREE(texcoordPtr); + } + } + else if (mesh->primitives[p].attributes[j].type == cgltf_attribute_type_color) // COLOR_n, vec3/vec4, float/u8n/u16n + { + cgltf_accessor *attribute = mesh->primitives[p].attributes[j].data; + + // WARNING: SPECS: All components of each COLOR_n accessor element MUST be clamped to [0.0, 1.0] range + + if (attribute->type == cgltf_type_vec3) // RGB + { + if (attribute->component_type == cgltf_component_type_r_8u) + { + // Init raylib mesh color to copy glTF attribute data + model.meshes[meshIndex].colors = RL_MALLOC(attribute->count*4*sizeof(unsigned char)); + + // Load data into a temp buffer to be converted to raylib data type + unsigned char *temp = RL_MALLOC(attribute->count*3*sizeof(unsigned char)); + LOAD_ATTRIBUTE(attribute, 3, unsigned char, temp); + + // Convert data to raylib color data type (4 bytes) + for (unsigned int c = 0, k = 0; c < (attribute->count*4 - 3); c += 4, k += 3) + { + model.meshes[meshIndex].colors[c] = temp[k]; + model.meshes[meshIndex].colors[c + 1] = temp[k + 1]; + model.meshes[meshIndex].colors[c + 2] = temp[k + 2]; + model.meshes[meshIndex].colors[c + 3] = 255; + } + + RL_FREE(temp); + } + else if (attribute->component_type == cgltf_component_type_r_16u) + { + // Init raylib mesh color to copy glTF attribute data + model.meshes[meshIndex].colors = RL_MALLOC(attribute->count*4*sizeof(unsigned char)); + + // Load data into a temp buffer to be converted to raylib data type + unsigned short *temp = RL_MALLOC(attribute->count*3*sizeof(unsigned short)); + LOAD_ATTRIBUTE(attribute, 3, unsigned short, temp); + + // Convert data to raylib color data type (4 bytes) + for (unsigned int c = 0, k = 0; c < (attribute->count*4 - 3); c += 4, k += 3) + { + model.meshes[meshIndex].colors[c] = (unsigned char)(((float)temp[k]/65535.0f)*255.0f); + model.meshes[meshIndex].colors[c + 1] = (unsigned char)(((float)temp[k + 1]/65535.0f)*255.0f); + model.meshes[meshIndex].colors[c + 2] = (unsigned char)(((float)temp[k + 2]/65535.0f)*255.0f); + model.meshes[meshIndex].colors[c + 3] = 255; + } + + RL_FREE(temp); + } + else if (attribute->component_type == cgltf_component_type_r_32f) + { + // Init raylib mesh color to copy glTF attribute data + model.meshes[meshIndex].colors = RL_MALLOC(attribute->count*4*sizeof(unsigned char)); + + // Load data into a temp buffer to be converted to raylib data type + float *temp = RL_MALLOC(attribute->count*3*sizeof(float)); + LOAD_ATTRIBUTE(attribute, 3, float, temp); + + // Convert data to raylib color data type (4 bytes) + for (unsigned int c = 0, k = 0; c < (attribute->count*4 - 3); c += 4, k += 3) + { + model.meshes[meshIndex].colors[c] = (unsigned char)(temp[k]*255.0f); + model.meshes[meshIndex].colors[c + 1] = (unsigned char)(temp[k + 1]*255.0f); + model.meshes[meshIndex].colors[c + 2] = (unsigned char)(temp[k + 2]*255.0f); + model.meshes[meshIndex].colors[c + 3] = 255; + } + + RL_FREE(temp); + } + else TRACELOG(LOG_WARNING, "MODEL: [%s] Color attribute data format not supported", fileName); + } + else if (attribute->type == cgltf_type_vec4) // RGBA + { + if (attribute->component_type == cgltf_component_type_r_8u) + { + // Init raylib mesh color to copy glTF attribute data + model.meshes[meshIndex].colors = RL_MALLOC(attribute->count*4*sizeof(unsigned char)); + + // Load 4 components of unsigned char data type into mesh.colors + LOAD_ATTRIBUTE(attribute, 4, unsigned char, model.meshes[meshIndex].colors) + } + else if (attribute->component_type == cgltf_component_type_r_16u) + { + // Init raylib mesh color to copy glTF attribute data + model.meshes[meshIndex].colors = RL_MALLOC(attribute->count*4*sizeof(unsigned char)); + + // Load data into a temp buffer to be converted to raylib data type + unsigned short *temp = RL_MALLOC(attribute->count*4*sizeof(unsigned short)); + LOAD_ATTRIBUTE(attribute, 4, unsigned short, temp); + + // Convert data to raylib color data type (4 bytes) + for (unsigned int c = 0; c < attribute->count*4; c++) model.meshes[meshIndex].colors[c] = (unsigned char)(((float)temp[c]/65535.0f)*255.0f); + + RL_FREE(temp); + } + else if (attribute->component_type == cgltf_component_type_r_32f) + { + // Init raylib mesh color to copy glTF attribute data + model.meshes[meshIndex].colors = RL_MALLOC(attribute->count*4*sizeof(unsigned char)); + + // Load data into a temp buffer to be converted to raylib data type + float *temp = RL_MALLOC(attribute->count*4*sizeof(float)); + LOAD_ATTRIBUTE(attribute, 4, float, temp); + + // Convert data to raylib color data type (4 bytes), we expect the color data normalized + for (unsigned int c = 0; c < attribute->count*4; c++) model.meshes[meshIndex].colors[c] = (unsigned char)(temp[c]*255.0f); + + RL_FREE(temp); + } + else TRACELOG(LOG_WARNING, "MODEL: [%s] Color attribute data format not supported", fileName); + } + else TRACELOG(LOG_WARNING, "MODEL: [%s] Color attribute data format not supported", fileName); + + + } + + // NOTE: Attributes related to animations are processed separately + } + + // Load primitive indices data (if provided) + if (mesh->primitives[p].indices != NULL) + { + cgltf_accessor *attribute = mesh->primitives[p].indices; + + model.meshes[meshIndex].triangleCount = (int)attribute->count/3; + + if (attribute->component_type == cgltf_component_type_r_16u) + { + // Init raylib mesh indices to copy glTF attribute data + model.meshes[meshIndex].indices = RL_MALLOC(attribute->count*sizeof(unsigned short)); + + // Load unsigned short data type into mesh.indices + LOAD_ATTRIBUTE(attribute, 1, unsigned short, model.meshes[meshIndex].indices) + } + else if (attribute->component_type == cgltf_component_type_r_32u) + { + // Init raylib mesh indices to copy glTF attribute data + model.meshes[meshIndex].indices = RL_MALLOC(attribute->count*sizeof(unsigned short)); + + // Load data into a temp buffer to be converted to raylib data type + unsigned int *temp = RL_MALLOC(attribute->count*sizeof(unsigned int)); + LOAD_ATTRIBUTE(attribute, 1, unsigned int, temp); + + // Convert data to raylib indices data type (unsigned short) + for (unsigned int d = 0; d < attribute->count; d++) model.meshes[meshIndex].indices[d] = (unsigned short)temp[d]; + + TRACELOG(LOG_WARNING, "MODEL: [%s] Indices data converted from u32 to u16, possible loss of data", fileName); + + RL_FREE(temp); + } + else TRACELOG(LOG_WARNING, "MODEL: [%s] Indices data format not supported, use u16", fileName); + } + else model.meshes[meshIndex].triangleCount = model.meshes[meshIndex].vertexCount/3; // Unindexed mesh + + // Assign to the primitive mesh the corresponding material index + // NOTE: If no material defined, mesh uses the already assigned default material (index: 0) + for (unsigned int m = 0; m < data->materials_count; m++) + { + // The primitive actually keeps the pointer to the corresponding material, + // raylib instead assigns to the mesh the by its index, as loaded in model.materials array + // To get the index, we check if material pointers match, and we assign the corresponding index, + // skipping index 0, the default material + if (&data->materials[m] == mesh->primitives[p].material) + { + model.meshMaterial[meshIndex] = m + 1; + break; + } + } + + meshIndex++; // Move to next mesh + } + } + + // Load glTF meshes animation data + // REF: https://www.khronos.org/registry/glTF/specs/2.0/glTF-2.0.html#skins + // REF: https://www.khronos.org/registry/glTF/specs/2.0/glTF-2.0.html#skinned-mesh-attributes + // + // LIMITATIONS: + // - Only supports 1 armature per file, and skips loading it if there are multiple armatures + // - Only supports linear interpolation (default method in Blender when checked "Always Sample Animations" when exporting a GLTF file) + // - Only supports translation/rotation/scale animation channel.path, weights not considered (i.e. morph targets) + //---------------------------------------------------------------------------------------------------- + if (data->skins_count == 1) + { + cgltf_skin skin = data->skins[0]; + model.bones = LoadBoneInfoGLTF(skin, &model.boneCount); + model.bindPose = RL_MALLOC(model.boneCount*sizeof(Transform)); + + for (int i = 0; i < model.boneCount; i++) + { + cgltf_node* node = skin.joints[i]; + cgltf_float worldTransform[16]; + cgltf_node_transform_world(node, worldTransform); + Matrix worldMatrix = { + worldTransform[0], worldTransform[4], worldTransform[8], worldTransform[12], + worldTransform[1], worldTransform[5], worldTransform[9], worldTransform[13], + worldTransform[2], worldTransform[6], worldTransform[10], worldTransform[14], + worldTransform[3], worldTransform[7], worldTransform[11], worldTransform[15] + }; + MatrixDecompose(worldMatrix, &(model.bindPose[i].translation), &(model.bindPose[i].rotation), &(model.bindPose[i].scale)); + } + } + else if (data->skins_count > 1) + { + TRACELOG(LOG_ERROR, "MODEL: [%s] can only load one skin (armature) per model, but gltf skins_count == %i", fileName, data->skins_count); + } + + meshIndex = 0; + for (unsigned int i = 0; i < data->nodes_count; i++) + { + cgltf_node *node = &(data->nodes[i]); + + cgltf_mesh *mesh = node->mesh; + if (!mesh) + continue; + + for (unsigned int p = 0; p < mesh->primitives_count; p++) + { + // NOTE: We only support primitives defined by triangles + if (mesh->primitives[p].type != cgltf_primitive_type_triangles) continue; + + for (unsigned int j = 0; j < mesh->primitives[p].attributes_count; j++) + { + // NOTE: JOINTS_1 + WEIGHT_1 will be used for +4 joints influencing a vertex -> Not supported by raylib + + if (mesh->primitives[p].attributes[j].type == cgltf_attribute_type_joints) // JOINTS_n (vec4: 4 bones max per vertex / u8, u16) + { + cgltf_accessor *attribute = mesh->primitives[p].attributes[j].data; + + // NOTE: JOINTS_n can only be vec4 and u8/u16 + // SPECS: https://registry.khronos.org/glTF/specs/2.0/glTF-2.0.html#meshes-overview + + // WARNING: raylib only supports model.meshes[].boneIds as u8 (unsigned char), + // if data is provided in any other format, it is converted to supported format but + // it could imply data loss (a warning message is issued in that case) + + if (attribute->type == cgltf_type_vec4) + { + if (attribute->component_type == cgltf_component_type_r_8u) + { + // Init raylib mesh boneIds to copy glTF attribute data + model.meshes[meshIndex].boneIds = RL_CALLOC(model.meshes[meshIndex].vertexCount*4, sizeof(unsigned char)); + + // Load attribute: vec4, u8 (unsigned char) + LOAD_ATTRIBUTE(attribute, 4, unsigned char, model.meshes[meshIndex].boneIds) + } + else if (attribute->component_type == cgltf_component_type_r_16u) + { + // Init raylib mesh boneIds to copy glTF attribute data + model.meshes[meshIndex].boneIds = RL_CALLOC(model.meshes[meshIndex].vertexCount*4, sizeof(unsigned char)); + + // Load data into a temp buffer to be converted to raylib data type + unsigned short *temp = RL_CALLOC(model.meshes[meshIndex].vertexCount*4, sizeof(unsigned short)); + LOAD_ATTRIBUTE(attribute, 4, unsigned short, temp); + + // Convert data to raylib color data type (4 bytes) + bool boneIdOverflowWarning = false; + for (int b = 0; b < model.meshes[meshIndex].vertexCount*4; b++) + { + if ((temp[b] > 255) && !boneIdOverflowWarning) + { + TRACELOG(LOG_WARNING, "MODEL: [%s] Joint attribute data format (u16) overflow", fileName); + boneIdOverflowWarning = true; + } + + // Despite the possible overflow, we convert data to unsigned char + model.meshes[meshIndex].boneIds[b] = (unsigned char)temp[b]; + } + + RL_FREE(temp); + } + else TRACELOG(LOG_WARNING, "MODEL: [%s] Joint attribute data format not supported", fileName); + } + else TRACELOG(LOG_WARNING, "MODEL: [%s] Joint attribute data format not supported", fileName); + } + else if (mesh->primitives[p].attributes[j].type == cgltf_attribute_type_weights) // WEIGHTS_n (vec4, u8n/u16n/f32) + { + cgltf_accessor *attribute = mesh->primitives[p].attributes[j].data; + + if (attribute->type == cgltf_type_vec4) + { + // TODO: Support component types: u8, u16? + if (attribute->component_type == cgltf_component_type_r_8u) + { + // Init raylib mesh bone weight to copy glTF attribute data + model.meshes[meshIndex].boneWeights = RL_CALLOC(model.meshes[meshIndex].vertexCount*4, sizeof(float)); + + // Load data into a temp buffer to be converted to raylib data type + unsigned char *temp = RL_MALLOC(attribute->count*4*sizeof(unsigned char)); + LOAD_ATTRIBUTE(attribute, 4, unsigned char, temp); + + // Convert data to raylib bone weight data type (4 bytes) + for (unsigned int b = 0; b < attribute->count*4; b++) model.meshes[meshIndex].boneWeights[b] = (float)temp[b]/255.0f; + + RL_FREE(temp); + } + else if (attribute->component_type == cgltf_component_type_r_16u) + { + // Init raylib mesh bone weight to copy glTF attribute data + model.meshes[meshIndex].boneWeights = RL_CALLOC(model.meshes[meshIndex].vertexCount*4, sizeof(float)); + + // Load data into a temp buffer to be converted to raylib data type + unsigned short *temp = RL_MALLOC(attribute->count*4*sizeof(unsigned short)); + LOAD_ATTRIBUTE(attribute, 4, unsigned short, temp); + + // Convert data to raylib bone weight data type + for (unsigned int b = 0; b < attribute->count*4; b++) model.meshes[meshIndex].boneWeights[b] = (float)temp[b]/65535.0f; + + RL_FREE(temp); + } + else if (attribute->component_type == cgltf_component_type_r_32f) + { + // Init raylib mesh bone weight to copy glTF attribute data + model.meshes[meshIndex].boneWeights = RL_CALLOC(model.meshes[meshIndex].vertexCount*4, sizeof(float)); + + // Load 4 components of float data type into mesh.boneWeights + // for cgltf_attribute_type_weights we have: + // - data.meshes[0] (256 vertices) + // - 256 values, provided as cgltf_type_vec4 of float (4 byte per joint, stride 16) + LOAD_ATTRIBUTE(attribute, 4, float, model.meshes[meshIndex].boneWeights) + } + else TRACELOG(LOG_WARNING, "MODEL: [%s] Joint weight attribute data format not supported, use vec4 float", fileName); + } + else TRACELOG(LOG_WARNING, "MODEL: [%s] Joint weight attribute data format not supported, use vec4 float", fileName); + } + } + + // Animated vertex data + model.meshes[meshIndex].animVertices = RL_CALLOC(model.meshes[meshIndex].vertexCount*3, sizeof(float)); + memcpy(model.meshes[meshIndex].animVertices, model.meshes[meshIndex].vertices, model.meshes[meshIndex].vertexCount*3*sizeof(float)); + model.meshes[meshIndex].animNormals = RL_CALLOC(model.meshes[meshIndex].vertexCount*3, sizeof(float)); + if (model.meshes[meshIndex].normals != NULL) + { + memcpy(model.meshes[meshIndex].animNormals, model.meshes[meshIndex].normals, model.meshes[meshIndex].vertexCount*3*sizeof(float)); + } + + meshIndex++; // Move to next mesh + } + + } + + // Free all cgltf loaded data + cgltf_free(data); + } + else TRACELOG(LOG_WARNING, "MODEL: [%s] Failed to load glTF data", fileName); + + // WARNING: cgltf requires the file pointer available while reading data + UnloadFileData(fileData); + + return model; +} + +// Get interpolated pose for bone sampler at a specific time. Returns true on success +static bool GetPoseAtTimeGLTF(cgltf_interpolation_type interpolationType, cgltf_accessor *input, cgltf_accessor *output, float time, void *data) +{ + if (interpolationType >= cgltf_interpolation_type_max_enum) return false; + + // Input and output should have the same count + float tstart = 0.0f; + float tend = 0.0f; + int keyframe = 0; // Defaults to first pose + + for (int i = 0; i < (int)input->count - 1; i++) + { + cgltf_bool r1 = cgltf_accessor_read_float(input, i, &tstart, 1); + if (!r1) return false; + + cgltf_bool r2 = cgltf_accessor_read_float(input, i + 1, &tend, 1); + if (!r2) return false; + + if ((tstart <= time) && (time < tend)) + { + keyframe = i; + break; + } + } + + // Constant animation, no need to interpolate + if (FloatEquals(tend, tstart)) return true; + + float duration = fmaxf((tend - tstart), EPSILON); + float t = (time - tstart)/duration; + t = (t < 0.0f)? 0.0f : t; + t = (t > 1.0f)? 1.0f : t; + + if (output->component_type != cgltf_component_type_r_32f) return false; + + if (output->type == cgltf_type_vec3) + { + switch (interpolationType) + { + case cgltf_interpolation_type_step: + { + float tmp[3] = { 0.0f }; + cgltf_accessor_read_float(output, keyframe, tmp, 3); + Vector3 v1 = {tmp[0], tmp[1], tmp[2]}; + Vector3 *r = data; + + *r = v1; + } break; + case cgltf_interpolation_type_linear: + { + float tmp[3] = { 0.0f }; + cgltf_accessor_read_float(output, keyframe, tmp, 3); + Vector3 v1 = {tmp[0], tmp[1], tmp[2]}; + cgltf_accessor_read_float(output, keyframe+1, tmp, 3); + Vector3 v2 = {tmp[0], tmp[1], tmp[2]}; + Vector3 *r = data; + + *r = Vector3Lerp(v1, v2, t); + } break; + case cgltf_interpolation_type_cubic_spline: + { + float tmp[3] = { 0.0f }; + cgltf_accessor_read_float(output, 3*keyframe+1, tmp, 3); + Vector3 v1 = {tmp[0], tmp[1], tmp[2]}; + cgltf_accessor_read_float(output, 3*keyframe+2, tmp, 3); + Vector3 tangent1 = {tmp[0], tmp[1], tmp[2]}; + cgltf_accessor_read_float(output, 3*(keyframe+1)+1, tmp, 3); + Vector3 v2 = {tmp[0], tmp[1], tmp[2]}; + cgltf_accessor_read_float(output, 3*(keyframe+1), tmp, 3); + Vector3 tangent2 = {tmp[0], tmp[1], tmp[2]}; + Vector3 *r = data; + + *r = Vector3CubicHermite(v1, tangent1, v2, tangent2, t); + } break; + default: break; + } + } + else if (output->type == cgltf_type_vec4) + { + // Only v4 is for rotations, so we know it's a quaternion + switch (interpolationType) + { + case cgltf_interpolation_type_step: + { + float tmp[4] = { 0.0f }; + cgltf_accessor_read_float(output, keyframe, tmp, 4); + Vector4 v1 = {tmp[0], tmp[1], tmp[2], tmp[3]}; + Vector4 *r = data; + + *r = v1; + } break; + case cgltf_interpolation_type_linear: + { + float tmp[4] = { 0.0f }; + cgltf_accessor_read_float(output, keyframe, tmp, 4); + Vector4 v1 = {tmp[0], tmp[1], tmp[2], tmp[3]}; + cgltf_accessor_read_float(output, keyframe+1, tmp, 4); + Vector4 v2 = {tmp[0], tmp[1], tmp[2], tmp[3]}; + Vector4 *r = data; + + *r = QuaternionSlerp(v1, v2, t); + } break; + case cgltf_interpolation_type_cubic_spline: + { + float tmp[4] = { 0.0f }; + cgltf_accessor_read_float(output, 3*keyframe+1, tmp, 4); + Vector4 v1 = {tmp[0], tmp[1], tmp[2], tmp[3]}; + cgltf_accessor_read_float(output, 3*keyframe+2, tmp, 4); + Vector4 outTangent1 = {tmp[0], tmp[1], tmp[2], 0.0f}; + cgltf_accessor_read_float(output, 3*(keyframe+1)+1, tmp, 4); + Vector4 v2 = {tmp[0], tmp[1], tmp[2], tmp[3]}; + cgltf_accessor_read_float(output, 3*(keyframe+1), tmp, 4); + Vector4 inTangent2 = {tmp[0], tmp[1], tmp[2], 0.0f}; + Vector4 *r = data; + + v1 = QuaternionNormalize(v1); + v2 = QuaternionNormalize(v2); + + if (Vector4DotProduct(v1, v2) < 0.0f) + { + v2 = Vector4Negate(v2); + } + + outTangent1 = Vector4Scale(outTangent1, duration); + inTangent2 = Vector4Scale(inTangent2, duration); + + *r = QuaternionCubicHermiteSpline(v1, outTangent1, v2, inTangent2, t); + } break; + default: break; + } + } + + return true; +} + +#define GLTF_ANIMDELAY 17 // Animation frames delay, (~1000 ms/60 FPS = 16.666666* ms) + +static ModelAnimation *LoadModelAnimationsGLTF(const char *fileName, int *animCount) +{ + // glTF file loading + int dataSize = 0; + unsigned char *fileData = LoadFileData(fileName, &dataSize); + + ModelAnimation *animations = NULL; + + // glTF data loading + cgltf_options options = { 0 }; + options.file.read = LoadFileGLTFCallback; + options.file.release = ReleaseFileGLTFCallback; + cgltf_data *data = NULL; + cgltf_result result = cgltf_parse(&options, fileData, dataSize, &data); + + if (result != cgltf_result_success) + { + TRACELOG(LOG_WARNING, "MODEL: [%s] Failed to load glTF data", fileName); + *animCount = 0; + return NULL; + } + + result = cgltf_load_buffers(&options, data, fileName); + if (result != cgltf_result_success) TRACELOG(LOG_INFO, "MODEL: [%s] Failed to load animation buffers", fileName); + + if (result == cgltf_result_success) + { + if (data->skins_count == 1) + { + cgltf_skin skin = data->skins[0]; + *animCount = (int)data->animations_count; + animations = RL_MALLOC(data->animations_count*sizeof(ModelAnimation)); + + for (unsigned int i = 0; i < data->animations_count; i++) + { + animations[i].bones = LoadBoneInfoGLTF(skin, &animations[i].boneCount); + + cgltf_animation animData = data->animations[i]; + + struct Channels { + cgltf_animation_channel *translate; + cgltf_animation_channel *rotate; + cgltf_animation_channel *scale; + cgltf_interpolation_type interpolationType; + }; + + struct Channels *boneChannels = RL_CALLOC(animations[i].boneCount, sizeof(struct Channels)); + float animDuration = 0.0f; + + for (unsigned int j = 0; j < animData.channels_count; j++) + { + cgltf_animation_channel channel = animData.channels[j]; + int boneIndex = -1; + + for (unsigned int k = 0; k < skin.joints_count; k++) + { + if (animData.channels[j].target_node == skin.joints[k]) + { + boneIndex = k; + break; + } + } + + if (boneIndex == -1) + { + // Animation channel for a node not in the armature + continue; + } + + boneChannels[boneIndex].interpolationType = animData.channels[j].sampler->interpolation; + + if (animData.channels[j].sampler->interpolation != cgltf_interpolation_type_max_enum) + { + if (channel.target_path == cgltf_animation_path_type_translation) + { + boneChannels[boneIndex].translate = &animData.channels[j]; + } + else if (channel.target_path == cgltf_animation_path_type_rotation) + { + boneChannels[boneIndex].rotate = &animData.channels[j]; + } + else if (channel.target_path == cgltf_animation_path_type_scale) + { + boneChannels[boneIndex].scale = &animData.channels[j]; + } + else + { + TRACELOG(LOG_WARNING, "MODEL: [%s] Unsupported target_path on channel %d's sampler for animation %d. Skipping.", fileName, j, i); + } + } + else TRACELOG(LOG_WARNING, "MODEL: [%s] Invalid interpolation curve encountered for GLTF animation.", fileName); + + float t = 0.0f; + cgltf_bool r = cgltf_accessor_read_float(channel.sampler->input, channel.sampler->input->count - 1, &t, 1); + + if (!r) + { + TRACELOG(LOG_WARNING, "MODEL: [%s] Failed to load input time", fileName); + continue; + } + + animDuration = (t > animDuration)? t : animDuration; + } + + if (animData.name != NULL) + { + strncpy(animations[i].name, animData.name, sizeof(animations[i].name)); + animations[i].name[sizeof(animations[i].name) - 1] = '\0'; + } + + animations[i].frameCount = (int)(animDuration*1000.0f/GLTF_ANIMDELAY) + 1; + animations[i].framePoses = RL_MALLOC(animations[i].frameCount*sizeof(Transform *)); + + for (int j = 0; j < animations[i].frameCount; j++) + { + animations[i].framePoses[j] = RL_MALLOC(animations[i].boneCount*sizeof(Transform)); + float time = ((float) j*GLTF_ANIMDELAY)/1000.0f; + + for (int k = 0; k < animations[i].boneCount; k++) + { + Vector3 translation = {skin.joints[k]->translation[0], skin.joints[k]->translation[1], skin.joints[k]->translation[2]}; + Quaternion rotation = {skin.joints[k]->rotation[0], skin.joints[k]->rotation[1], skin.joints[k]->rotation[2], skin.joints[k]->rotation[3]}; + Vector3 scale = {skin.joints[k]->scale[0], skin.joints[k]->scale[1], skin.joints[k]->scale[2]}; + + if (boneChannels[k].translate) + { + if (!GetPoseAtTimeGLTF(boneChannels[k].interpolationType, boneChannels[k].translate->sampler->input, boneChannels[k].translate->sampler->output, time, &translation)) + { + TRACELOG(LOG_INFO, "MODEL: [%s] Failed to load translate pose data for bone %s", fileName, animations[i].bones[k].name); + } + } + + if (boneChannels[k].rotate) + { + if (!GetPoseAtTimeGLTF(boneChannels[k].interpolationType, boneChannels[k].rotate->sampler->input, boneChannels[k].rotate->sampler->output, time, &rotation)) + { + TRACELOG(LOG_INFO, "MODEL: [%s] Failed to load rotate pose data for bone %s", fileName, animations[i].bones[k].name); + } + } + + if (boneChannels[k].scale) + { + if (!GetPoseAtTimeGLTF(boneChannels[k].interpolationType, boneChannels[k].scale->sampler->input, boneChannels[k].scale->sampler->output, time, &scale)) + { + TRACELOG(LOG_INFO, "MODEL: [%s] Failed to load scale pose data for bone %s", fileName, animations[i].bones[k].name); + } + } + + animations[i].framePoses[j][k] = (Transform){ + .translation = translation, + .rotation = rotation, + .scale = scale + }; + } + + BuildPoseFromParentJoints(animations[i].bones, animations[i].boneCount, animations[i].framePoses[j]); + } + + TRACELOG(LOG_INFO, "MODEL: [%s] Loaded animation: %s (%d frames, %fs)", fileName, (animData.name != NULL)? animData.name : "NULL", animations[i].frameCount, animDuration); + RL_FREE(boneChannels); + } + } + else TRACELOG(LOG_ERROR, "MODEL: [%s] expected exactly one skin to load animation data from, but found %i", fileName, data->skins_count); + + cgltf_free(data); + } + UnloadFileData(fileData); + return animations; +} +#endif + +#if defined(SUPPORT_FILEFORMAT_VOX) +// Load VOX (MagicaVoxel) mesh data +static Model LoadVOX(const char *fileName) +{ + Model model = { 0 }; + + int nbvertices = 0; + int meshescount = 0; + + // Read vox file into buffer + int dataSize = 0; + unsigned char *fileData = LoadFileData(fileName, &dataSize); + + if (fileData == 0) + { + TRACELOG(LOG_WARNING, "MODEL: [%s] Failed to load VOX file", fileName); + return model; + } + + // Read and build voxarray description + VoxArray3D voxarray = { 0 }; + int ret = Vox_LoadFromMemory(fileData, dataSize, &voxarray); + + if (ret != VOX_SUCCESS) + { + // Error + UnloadFileData(fileData); + + TRACELOG(LOG_WARNING, "MODEL: [%s] Failed to load VOX data", fileName); + return model; + } + else + { + // Success: Compute meshes count + nbvertices = voxarray.vertices.used; + meshescount = 1 + (nbvertices/65536); + + TRACELOG(LOG_INFO, "MODEL: [%s] VOX data loaded successfully : %i vertices/%i meshes", fileName, nbvertices, meshescount); + } + + // Build models from meshes + model.transform = MatrixIdentity(); + + model.meshCount = meshescount; + model.meshes = (Mesh *)RL_CALLOC(model.meshCount, sizeof(Mesh)); + + model.meshMaterial = (int *)RL_CALLOC(model.meshCount, sizeof(int)); + + model.materialCount = 1; + model.materials = (Material *)RL_CALLOC(model.materialCount, sizeof(Material)); + model.materials[0] = LoadMaterialDefault(); + + // Init model meshes + int verticesRemain = voxarray.vertices.used; + int verticesMax = 65532; // 5461 voxels x 12 vertices per voxel -> 65532 (must be inf 65536) + + // 6*4 = 12 vertices per voxel + Vector3 *pvertices = (Vector3 *)voxarray.vertices.array; + Vector3 *pnormals = (Vector3 *)voxarray.normals.array; + Color *pcolors = (Color *)voxarray.colors.array; + + unsigned short *pindices = voxarray.indices.array; // 5461*6*6 = 196596 indices max per mesh + + int size = 0; + + for (int i = 0; i < meshescount; i++) + { + Mesh *pmesh = &model.meshes[i]; + memset(pmesh, 0, sizeof(Mesh)); + + // Copy vertices + pmesh->vertexCount = (int)fmin(verticesMax, verticesRemain); + + size = pmesh->vertexCount*sizeof(float)*3; + pmesh->vertices = (float *)RL_MALLOC(size); + memcpy(pmesh->vertices, pvertices, size); + + // Copy normals + pmesh->normals = (float *)RL_MALLOC(size); + memcpy(pmesh->normals, pnormals, size); + + // Copy indices + size = voxarray.indices.used*sizeof(unsigned short); + pmesh->indices = (unsigned short *)RL_MALLOC(size); + memcpy(pmesh->indices, pindices, size); + + pmesh->triangleCount = (pmesh->vertexCount/4)*2; + + // Copy colors + size = pmesh->vertexCount*sizeof(Color); + pmesh->colors = RL_MALLOC(size); + memcpy(pmesh->colors, pcolors, size); + + // First material index + model.meshMaterial[i] = 0; + + verticesRemain -= verticesMax; + pvertices += verticesMax; + pnormals += verticesMax; + pcolors += verticesMax; + } + + // Free buffers + Vox_FreeArrays(&voxarray); + UnloadFileData(fileData); + + return model; +} +#endif + +#if defined(SUPPORT_FILEFORMAT_M3D) +// Hook LoadFileData()/UnloadFileData() calls to M3D loaders +unsigned char *m3d_loaderhook(char *fn, unsigned int *len) { return LoadFileData((const char *)fn, (int *)len); } +void m3d_freehook(void *data) { UnloadFileData((unsigned char *)data); } + +// Load M3D mesh data +static Model LoadM3D(const char *fileName) +{ + Model model = { 0 }; + + m3d_t *m3d = NULL; + m3dp_t *prop = NULL; + int i, j, k, l, n, mi = -2, vcolor = 0; + + int dataSize = 0; + unsigned char *fileData = LoadFileData(fileName, &dataSize); + + if (fileData != NULL) + { + m3d = m3d_load(fileData, m3d_loaderhook, m3d_freehook, NULL); + + if (!m3d || M3D_ERR_ISFATAL(m3d->errcode)) + { + TRACELOG(LOG_WARNING, "MODEL: [%s] Failed to load M3D data, error code %d", fileName, m3d? m3d->errcode : -2); + if (m3d) m3d_free(m3d); + UnloadFileData(fileData); + return model; + } + else TRACELOG(LOG_INFO, "MODEL: [%s] M3D data loaded successfully: %i faces/%i materials", fileName, m3d->numface, m3d->nummaterial); + + // no face? this is probably just a material library + if (!m3d->numface) + { + m3d_free(m3d); + UnloadFileData(fileData); + return model; + } + + if (m3d->nummaterial > 0) + { + model.meshCount = model.materialCount = m3d->nummaterial; + TRACELOG(LOG_INFO, "MODEL: model has %i material meshes", model.materialCount); + } + else + { + model.meshCount = 1; model.materialCount = 0; + TRACELOG(LOG_INFO, "MODEL: No materials, putting all meshes in a default material"); + } + + // We always need a default material, so we add +1 + model.materialCount++; + + // Faces must be in non-decreasing materialid order. Verify that quickly, sorting them otherwise + // WARNING: Sorting is not needed, valid M3D model files should already be sorted + // Just keeping the sorting function for reference (Check PR #3363 #3385) + /* + for (i = 1; i < m3d->numface; i++) + { + if (m3d->face[i-1].materialid <= m3d->face[i].materialid) continue; + + // face[i-1] > face[i]. slide face[i] lower + m3df_t slider = m3d->face[i]; + j = i-1; + + do + { // face[j] > slider, face[j+1] is svailable vacant gap + m3d->face[j+1] = m3d->face[j]; + j = j-1; + } + while (j >= 0 && m3d->face[j].materialid > slider.materialid); + + m3d->face[j+1] = slider; + } + */ + + model.meshes = (Mesh *)RL_CALLOC(model.meshCount, sizeof(Mesh)); + model.meshMaterial = (int *)RL_CALLOC(model.meshCount, sizeof(int)); + model.materials = (Material *)RL_CALLOC(model.materialCount + 1, sizeof(Material)); + + // Map no material to index 0 with default shader, everything else materialid + 1 + model.materials[0] = LoadMaterialDefault(); + + for (i = l = 0, k = -1; i < (int)m3d->numface; i++, l++) + { + // Materials are grouped together + if (mi != m3d->face[i].materialid) + { + // there should be only one material switch per material kind, but be bulletproof for non-optimal model files + if (k + 1 >= model.meshCount) + { + model.meshCount++; + model.meshes = (Mesh *)RL_REALLOC(model.meshes, model.meshCount*sizeof(Mesh)); + memset(&model.meshes[model.meshCount - 1], 0, sizeof(Mesh)); + model.meshMaterial = (int *)RL_REALLOC(model.meshMaterial, model.meshCount*sizeof(int)); + } + + k++; + mi = m3d->face[i].materialid; + + // Only allocate colors VertexBuffer if there's a color vertex in the model for this material batch + // if all colors are fully transparent black for all verteces of this materal, then we assume no vertex colors + for (j = i, l = vcolor = 0; (j < (int)m3d->numface) && (mi == m3d->face[j].materialid); j++, l++) + { + if (!m3d->vertex[m3d->face[j].vertex[0]].color || + !m3d->vertex[m3d->face[j].vertex[1]].color || + !m3d->vertex[m3d->face[j].vertex[2]].color) vcolor = 1; + } + + model.meshes[k].vertexCount = l*3; + model.meshes[k].triangleCount = l; + model.meshes[k].vertices = (float *)RL_CALLOC(model.meshes[k].vertexCount*3, sizeof(float)); + model.meshes[k].texcoords = (float *)RL_CALLOC(model.meshes[k].vertexCount*2, sizeof(float)); + model.meshes[k].normals = (float *)RL_CALLOC(model.meshes[k].vertexCount*3, sizeof(float)); + + // If no map is provided, or we have colors defined, we allocate storage for vertex colors + // M3D specs only consider vertex colors if no material is provided, however raylib uses both and mixes the colors + if ((mi == M3D_UNDEF) || vcolor) model.meshes[k].colors = RL_CALLOC(model.meshes[k].vertexCount*4, sizeof(unsigned char)); + + // If no map is provided and we allocated vertex colors, set them to white + if ((mi == M3D_UNDEF) && (model.meshes[k].colors != NULL)) + { + for (int c = 0; c < model.meshes[k].vertexCount*4; c++) model.meshes[k].colors[c] = 255; + } + + if (m3d->numbone && m3d->numskin) + { + model.meshes[k].boneIds = (unsigned char *)RL_CALLOC(model.meshes[k].vertexCount*4, sizeof(unsigned char)); + model.meshes[k].boneWeights = (float *)RL_CALLOC(model.meshes[k].vertexCount*4, sizeof(float)); + model.meshes[k].animVertices = (float *)RL_CALLOC(model.meshes[k].vertexCount*3, sizeof(float)); + model.meshes[k].animNormals = (float *)RL_CALLOC(model.meshes[k].vertexCount*3, sizeof(float)); + } + + model.meshMaterial[k] = mi + 1; + l = 0; + } + + // Process meshes per material, add triangles + model.meshes[k].vertices[l*9 + 0] = m3d->vertex[m3d->face[i].vertex[0]].x*m3d->scale; + model.meshes[k].vertices[l*9 + 1] = m3d->vertex[m3d->face[i].vertex[0]].y*m3d->scale; + model.meshes[k].vertices[l*9 + 2] = m3d->vertex[m3d->face[i].vertex[0]].z*m3d->scale; + model.meshes[k].vertices[l*9 + 3] = m3d->vertex[m3d->face[i].vertex[1]].x*m3d->scale; + model.meshes[k].vertices[l*9 + 4] = m3d->vertex[m3d->face[i].vertex[1]].y*m3d->scale; + model.meshes[k].vertices[l*9 + 5] = m3d->vertex[m3d->face[i].vertex[1]].z*m3d->scale; + model.meshes[k].vertices[l*9 + 6] = m3d->vertex[m3d->face[i].vertex[2]].x*m3d->scale; + model.meshes[k].vertices[l*9 + 7] = m3d->vertex[m3d->face[i].vertex[2]].y*m3d->scale; + model.meshes[k].vertices[l*9 + 8] = m3d->vertex[m3d->face[i].vertex[2]].z*m3d->scale; + + // Without vertex color (full transparency), we use the default color + if (model.meshes[k].colors != NULL) + { + if (m3d->vertex[m3d->face[i].vertex[0]].color & 0xFF000000) + memcpy(&model.meshes[k].colors[l*12 + 0], &m3d->vertex[m3d->face[i].vertex[0]].color, 4); + if (m3d->vertex[m3d->face[i].vertex[1]].color & 0xFF000000) + memcpy(&model.meshes[k].colors[l*12 + 4], &m3d->vertex[m3d->face[i].vertex[1]].color, 4); + if (m3d->vertex[m3d->face[i].vertex[2]].color & 0xFF000000) + memcpy(&model.meshes[k].colors[l*12 + 8], &m3d->vertex[m3d->face[i].vertex[2]].color, 4); + } + + if (m3d->face[i].texcoord[0] != M3D_UNDEF) + { + model.meshes[k].texcoords[l*6 + 0] = m3d->tmap[m3d->face[i].texcoord[0]].u; + model.meshes[k].texcoords[l*6 + 1] = 1.0f - m3d->tmap[m3d->face[i].texcoord[0]].v; + model.meshes[k].texcoords[l*6 + 2] = m3d->tmap[m3d->face[i].texcoord[1]].u; + model.meshes[k].texcoords[l*6 + 3] = 1.0f - m3d->tmap[m3d->face[i].texcoord[1]].v; + model.meshes[k].texcoords[l*6 + 4] = m3d->tmap[m3d->face[i].texcoord[2]].u; + model.meshes[k].texcoords[l*6 + 5] = 1.0f - m3d->tmap[m3d->face[i].texcoord[2]].v; + } + + if (m3d->face[i].normal[0] != M3D_UNDEF) + { + model.meshes[k].normals[l*9 + 0] = m3d->vertex[m3d->face[i].normal[0]].x; + model.meshes[k].normals[l*9 + 1] = m3d->vertex[m3d->face[i].normal[0]].y; + model.meshes[k].normals[l*9 + 2] = m3d->vertex[m3d->face[i].normal[0]].z; + model.meshes[k].normals[l*9 + 3] = m3d->vertex[m3d->face[i].normal[1]].x; + model.meshes[k].normals[l*9 + 4] = m3d->vertex[m3d->face[i].normal[1]].y; + model.meshes[k].normals[l*9 + 5] = m3d->vertex[m3d->face[i].normal[1]].z; + model.meshes[k].normals[l*9 + 6] = m3d->vertex[m3d->face[i].normal[2]].x; + model.meshes[k].normals[l*9 + 7] = m3d->vertex[m3d->face[i].normal[2]].y; + model.meshes[k].normals[l*9 + 8] = m3d->vertex[m3d->face[i].normal[2]].z; + } + + // Add skin (vertex / bone weight pairs) + if (m3d->numbone && m3d->numskin) + { + for (n = 0; n < 3; n++) + { + int skinid = m3d->vertex[m3d->face[i].vertex[n]].skinid; + + // Check if there is a skin for this mesh, should be, just failsafe + if ((skinid != M3D_UNDEF) && (skinid < (int)m3d->numskin)) + { + for (j = 0; j < 4; j++) + { + model.meshes[k].boneIds[l*12 + n*4 + j] = m3d->skin[skinid].boneid[j]; + model.meshes[k].boneWeights[l*12 + n*4 + j] = m3d->skin[skinid].weight[j]; + } + } + else + { + // raylib does not handle boneless meshes with skeletal animations, so + // we put all vertices without a bone into a special "no bone" bone + model.meshes[k].boneIds[l*12 + n*4] = m3d->numbone; + model.meshes[k].boneWeights[l*12 + n*4] = 1.0f; + } + } + } + } + + // Load materials + for (i = 0; i < (int)m3d->nummaterial; i++) + { + model.materials[i + 1] = LoadMaterialDefault(); + + for (j = 0; j < m3d->material[i].numprop; j++) + { + prop = &m3d->material[i].prop[j]; + + switch (prop->type) + { + case m3dp_Kd: + { + memcpy(&model.materials[i + 1].maps[MATERIAL_MAP_DIFFUSE].color, &prop->value.color, 4); + model.materials[i + 1].maps[MATERIAL_MAP_DIFFUSE].value = 0.0f; + } break; + case m3dp_Ks: + { + memcpy(&model.materials[i + 1].maps[MATERIAL_MAP_SPECULAR].color, &prop->value.color, 4); + } break; + case m3dp_Ns: + { + model.materials[i + 1].maps[MATERIAL_MAP_SPECULAR].value = prop->value.fnum; + } break; + case m3dp_Ke: + { + memcpy(&model.materials[i + 1].maps[MATERIAL_MAP_EMISSION].color, &prop->value.color, 4); + model.materials[i + 1].maps[MATERIAL_MAP_EMISSION].value = 0.0f; + } break; + case m3dp_Pm: + { + model.materials[i + 1].maps[MATERIAL_MAP_METALNESS].value = prop->value.fnum; + } break; + case m3dp_Pr: + { + model.materials[i + 1].maps[MATERIAL_MAP_ROUGHNESS].value = prop->value.fnum; + } break; + case m3dp_Ps: + { + model.materials[i + 1].maps[MATERIAL_MAP_NORMAL].color = WHITE; + model.materials[i + 1].maps[MATERIAL_MAP_NORMAL].value = prop->value.fnum; + } break; + default: + { + if (prop->type >= 128) + { + Image image = { 0 }; + image.data = m3d->texture[prop->value.textureid].d; + image.width = m3d->texture[prop->value.textureid].w; + image.height = m3d->texture[prop->value.textureid].h; + image.mipmaps = 1; + image.format = (m3d->texture[prop->value.textureid].f == 4)? PIXELFORMAT_UNCOMPRESSED_R8G8B8A8 : + ((m3d->texture[prop->value.textureid].f == 3)? PIXELFORMAT_UNCOMPRESSED_R8G8B8 : + ((m3d->texture[prop->value.textureid].f == 2)? PIXELFORMAT_UNCOMPRESSED_GRAY_ALPHA : PIXELFORMAT_UNCOMPRESSED_GRAYSCALE)); + + switch (prop->type) + { + case m3dp_map_Kd: model.materials[i + 1].maps[MATERIAL_MAP_DIFFUSE].texture = LoadTextureFromImage(image); break; + case m3dp_map_Ks: model.materials[i + 1].maps[MATERIAL_MAP_SPECULAR].texture = LoadTextureFromImage(image); break; + case m3dp_map_Ke: model.materials[i + 1].maps[MATERIAL_MAP_EMISSION].texture = LoadTextureFromImage(image); break; + case m3dp_map_Km: model.materials[i + 1].maps[MATERIAL_MAP_NORMAL].texture = LoadTextureFromImage(image); break; + case m3dp_map_Ka: model.materials[i + 1].maps[MATERIAL_MAP_OCCLUSION].texture = LoadTextureFromImage(image); break; + case m3dp_map_Pm: model.materials[i + 1].maps[MATERIAL_MAP_ROUGHNESS].texture = LoadTextureFromImage(image); break; + default: break; + } + } + } break; + } + } + } + + // Load bones + if (m3d->numbone) + { + model.boneCount = m3d->numbone + 1; + model.bones = RL_CALLOC(model.boneCount, sizeof(BoneInfo)); + model.bindPose = RL_CALLOC(model.boneCount, sizeof(Transform)); + + for (i = 0; i < (int)m3d->numbone; i++) + { + model.bones[i].parent = m3d->bone[i].parent; + strncpy(model.bones[i].name, m3d->bone[i].name, sizeof(model.bones[i].name)); + model.bindPose[i].translation.x = m3d->vertex[m3d->bone[i].pos].x*m3d->scale; + model.bindPose[i].translation.y = m3d->vertex[m3d->bone[i].pos].y*m3d->scale; + model.bindPose[i].translation.z = m3d->vertex[m3d->bone[i].pos].z*m3d->scale; + model.bindPose[i].rotation.x = m3d->vertex[m3d->bone[i].ori].x; + model.bindPose[i].rotation.y = m3d->vertex[m3d->bone[i].ori].y; + model.bindPose[i].rotation.z = m3d->vertex[m3d->bone[i].ori].z; + model.bindPose[i].rotation.w = m3d->vertex[m3d->bone[i].ori].w; + + // TODO: If the orientation quaternion is not normalized, then that's encoding scaling + model.bindPose[i].rotation = QuaternionNormalize(model.bindPose[i].rotation); + model.bindPose[i].scale.x = model.bindPose[i].scale.y = model.bindPose[i].scale.z = 1.0f; + + // Child bones are stored in parent bone relative space, convert that into model space + if (model.bones[i].parent >= 0) + { + model.bindPose[i].rotation = QuaternionMultiply(model.bindPose[model.bones[i].parent].rotation, model.bindPose[i].rotation); + model.bindPose[i].translation = Vector3RotateByQuaternion(model.bindPose[i].translation, model.bindPose[model.bones[i].parent].rotation); + model.bindPose[i].translation = Vector3Add(model.bindPose[i].translation, model.bindPose[model.bones[i].parent].translation); + model.bindPose[i].scale = Vector3Multiply(model.bindPose[i].scale, model.bindPose[model.bones[i].parent].scale); + } + } + + // Add a special "no bone" bone + model.bones[i].parent = -1; + strcpy(model.bones[i].name, "NO BONE"); + model.bindPose[i].translation.x = 0.0f; + model.bindPose[i].translation.y = 0.0f; + model.bindPose[i].translation.z = 0.0f; + model.bindPose[i].rotation.x = 0.0f; + model.bindPose[i].rotation.y = 0.0f; + model.bindPose[i].rotation.z = 0.0f; + model.bindPose[i].rotation.w = 1.0f; + model.bindPose[i].scale.x = model.bindPose[i].scale.y = model.bindPose[i].scale.z = 1.0f; + } + + // Load bone-pose default mesh into animation vertices. These will be updated when UpdateModelAnimation gets + // called, but not before, however DrawMesh uses these if they exist (so not good if they are left empty) + if (m3d->numbone && m3d->numskin) + { + for (i = 0; i < model.meshCount; i++) + { + memcpy(model.meshes[i].animVertices, model.meshes[i].vertices, model.meshes[i].vertexCount*3*sizeof(float)); + memcpy(model.meshes[i].animNormals, model.meshes[i].normals, model.meshes[i].vertexCount*3*sizeof(float)); + } + } + + m3d_free(m3d); + UnloadFileData(fileData); + } + + return model; +} + +#define M3D_ANIMDELAY 17 // Animation frames delay, (~1000 ms/60 FPS = 16.666666* ms) + +// Load M3D animation data +static ModelAnimation *LoadModelAnimationsM3D(const char *fileName, int *animCount) +{ + ModelAnimation *animations = NULL; + + m3d_t *m3d = NULL; + int i = 0, j = 0; + *animCount = 0; + + int dataSize = 0; + unsigned char *fileData = LoadFileData(fileName, &dataSize); + + if (fileData != NULL) + { + m3d = m3d_load(fileData, m3d_loaderhook, m3d_freehook, NULL); + + if (!m3d || M3D_ERR_ISFATAL(m3d->errcode)) + { + TRACELOG(LOG_WARNING, "MODEL: [%s] Failed to load M3D data, error code %d", fileName, m3d? m3d->errcode : -2); + UnloadFileData(fileData); + return NULL; + } + else TRACELOG(LOG_INFO, "MODEL: [%s] M3D data loaded successfully: %i animations, %i bones, %i skins", fileName, + m3d->numaction, m3d->numbone, m3d->numskin); + + // No animation or bone+skin? + if (!m3d->numaction || !m3d->numbone || !m3d->numskin) + { + m3d_free(m3d); + UnloadFileData(fileData); + return NULL; + } + + animations = RL_MALLOC(m3d->numaction*sizeof(ModelAnimation)); + *animCount = m3d->numaction; + + for (unsigned int a = 0; a < m3d->numaction; a++) + { + animations[a].frameCount = m3d->action[a].durationmsec/M3D_ANIMDELAY; + animations[a].boneCount = m3d->numbone + 1; + animations[a].bones = RL_MALLOC((m3d->numbone + 1)*sizeof(BoneInfo)); + animations[a].framePoses = RL_MALLOC(animations[a].frameCount*sizeof(Transform *)); + strncpy(animations[a].name, m3d->action[a].name, sizeof(animations[a].name)); + animations[a].name[sizeof(animations[a].name) - 1] = '\0'; + + TRACELOG(LOG_INFO, "MODEL: [%s] animation #%i: %i msec, %i frames", fileName, a, m3d->action[a].durationmsec, animations[a].frameCount); + + for (i = 0; i < (int)m3d->numbone; i++) + { + animations[a].bones[i].parent = m3d->bone[i].parent; + strncpy(animations[a].bones[i].name, m3d->bone[i].name, sizeof(animations[a].bones[i].name)); + } + + // A special, never transformed "no bone" bone, used for boneless vertices + animations[a].bones[i].parent = -1; + strcpy(animations[a].bones[i].name, "NO BONE"); + + // M3D stores frames at arbitrary intervals with sparse skeletons. We need full skeletons at + // regular intervals, so let the M3D SDK do the heavy lifting and calculate interpolated bones + for (i = 0; i < animations[a].frameCount; i++) + { + animations[a].framePoses[i] = RL_MALLOC((m3d->numbone + 1)*sizeof(Transform)); + + m3db_t *pose = m3d_pose(m3d, a, i*M3D_ANIMDELAY); + + if (pose != NULL) + { + for (j = 0; j < (int)m3d->numbone; j++) + { + animations[a].framePoses[i][j].translation.x = m3d->vertex[pose[j].pos].x*m3d->scale; + animations[a].framePoses[i][j].translation.y = m3d->vertex[pose[j].pos].y*m3d->scale; + animations[a].framePoses[i][j].translation.z = m3d->vertex[pose[j].pos].z*m3d->scale; + animations[a].framePoses[i][j].rotation.x = m3d->vertex[pose[j].ori].x; + animations[a].framePoses[i][j].rotation.y = m3d->vertex[pose[j].ori].y; + animations[a].framePoses[i][j].rotation.z = m3d->vertex[pose[j].ori].z; + animations[a].framePoses[i][j].rotation.w = m3d->vertex[pose[j].ori].w; + animations[a].framePoses[i][j].rotation = QuaternionNormalize(animations[a].framePoses[i][j].rotation); + animations[a].framePoses[i][j].scale.x = animations[a].framePoses[i][j].scale.y = animations[a].framePoses[i][j].scale.z = 1.0f; + + // Child bones are stored in parent bone relative space, convert that into model space + if (animations[a].bones[j].parent >= 0) + { + animations[a].framePoses[i][j].rotation = QuaternionMultiply(animations[a].framePoses[i][animations[a].bones[j].parent].rotation, animations[a].framePoses[i][j].rotation); + animations[a].framePoses[i][j].translation = Vector3RotateByQuaternion(animations[a].framePoses[i][j].translation, animations[a].framePoses[i][animations[a].bones[j].parent].rotation); + animations[a].framePoses[i][j].translation = Vector3Add(animations[a].framePoses[i][j].translation, animations[a].framePoses[i][animations[a].bones[j].parent].translation); + animations[a].framePoses[i][j].scale = Vector3Multiply(animations[a].framePoses[i][j].scale, animations[a].framePoses[i][animations[a].bones[j].parent].scale); + } + } + + // Default transform for the "no bone" bone + animations[a].framePoses[i][j].translation.x = 0.0f; + animations[a].framePoses[i][j].translation.y = 0.0f; + animations[a].framePoses[i][j].translation.z = 0.0f; + animations[a].framePoses[i][j].rotation.x = 0.0f; + animations[a].framePoses[i][j].rotation.y = 0.0f; + animations[a].framePoses[i][j].rotation.z = 0.0f; + animations[a].framePoses[i][j].rotation.w = 1.0f; + animations[a].framePoses[i][j].scale.x = animations[a].framePoses[i][j].scale.y = animations[a].framePoses[i][j].scale.z = 1.0f; + RL_FREE(pose); + } + } + } + + m3d_free(m3d); + UnloadFileData(fileData); + } + + return animations; +} +#endif + +#endif // SUPPORT_MODULE_RMODELS diff --git a/src/world/chunk.zig b/src/world/chunk.zig index 1b6d3d8..e826bb1 100644 --- a/src/world/chunk.zig +++ b/src/world/chunk.zig @@ -1,11 +1,11 @@ const std = @import("std"); -const rh = @import("../util/raylib_helper.zig"); -const raylib = rh.raylib; -const v3 = rh.v3; +const raylib_helper = @import("../lib_helpers/raylib_helper.zig"); +const raylib = raylib_helper.raylib; +const v3 = raylib_helper.v3; const A7r = std.mem.Allocator; const RawQuad = struct { - tile: i32, + tile: u32, top_left: raylib.Vector3, top_right: raylib.Vector3, bottom_right: raylib.Vector3, @@ -16,13 +16,13 @@ const RawQuad = struct { }; pub const Chunk = struct { - tiles: []i32, + tiles: []u32, a7r: A7r, pub fn init(a7r: A7r) !Chunk { const self = Chunk{ .a7r = a7r, - .tiles = try a7r.alloc(i32, 32 * 32 * 32), + .tiles = try a7r.alloc(u32, 32 * 32 * 32), }; @memset(self.tiles, 0); return self; @@ -32,19 +32,19 @@ pub const Chunk = struct { self.a7r.free(self.tiles); } - pub fn getTile(self: Chunk, x: u5, y: u5, z: u5) i32 { + pub fn getTile(self: Chunk, x: u5, y: u5, z: u5) u32 { return self.tiles[@as(u15, x) << 10 | @as(u15, y) << 5 | @as(u15, z)]; } - pub fn setTile(self: Chunk, x: u5, y: u5, z: u5, tile: i32) void { + pub fn setTile(self: Chunk, x: u5, y: u5, z: u5, tile: u32) void { self.tiles[@as(u15, x) << 10 | @as(u15, y) << 5 | @as(u15, z)] = tile; } - fn getTileRaw(self: Chunk, x: u5, y: u5, z: u5) i32 { + fn getTileRaw(self: Chunk, x: u5, y: u5, z: u5) u32 { return self.tiles[@as(u15, x) << 10 | @as(u15, y) << 5 | @as(u15, z)]; } - inline fn getTileRawShifted(self: Chunk, x: u5, y: u5, z: u5, comptime d: comptime_int) i32 { + inline fn getTileRawShifted(self: Chunk, x: u5, y: u5, z: u5, comptime d: comptime_int) u32 { if (d % 3 == 0) { return self.getTileRaw(x, y, z); } else if (d % 3 == 1) { @@ -61,12 +61,12 @@ pub const Chunk = struct { inline for (0..3) |d| { for (0..32) |raw_x| { const x: u5 = @intCast(raw_x); - var positive_tile_surfaces: [32][32]i32 = .{.{0} ** 32} ** 32; - var negative_tile_surfaces: [32][32]i32 = .{.{0} ** 32} ** 32; + var positive_tile_surfaces: [32][32]u32 = .{.{0} ** 32} ** 32; + var negative_tile_surfaces: [32][32]u32 = .{.{0} ** 32} ** 32; for (0..32) |raw_y| for (0..32) |raw_z| { const y: u5 = @intCast(raw_y); const z: u5 = @intCast(raw_z); - const tile: i32 = chunk.getTileRawShifted(x, y, z, d); + const tile: u32 = chunk.getTileRawShifted(x, y, z, d); if (tile == 0) continue; if (x == 31 or chunk.getTileRawShifted(x + 1, y, z, d) == 0) positive_tile_surfaces[y][z] = tile; if (x == 0 or chunk.getTileRawShifted(x - 1, y, z, d) == 0) negative_tile_surfaces[y][z] = tile; @@ -154,7 +154,7 @@ pub const Chunk = struct { for (raw_quads.items, 0..) |raw_quad, i| { if (raw_quad.tile <= 0) continue; - const tile = @as(u32, @intCast(raw_quad.tile)); + const tile = raw_quad.tile; for (0..6) |j| { normals[18 * i + 3 * j + 0] = raw_quad.normal.x; @@ -224,13 +224,7 @@ pub const Chunk = struct { .texcoords = texcoords, .texcoords2 = texcoords2, .normals = normals, - .tangents = null, - .colors = null, - .indices = null, - .animVertices = null, - .animNormals = null, - .boneIds = null, - .boneWeights = null, + .vaoId = 0, .vboId = null, }; diff --git a/todo.md b/todo.md new file mode 100644 index 0000000..f57a97c --- /dev/null +++ b/todo.md @@ -0,0 +1,13 @@ +# current tasks +yoink implementation of mesh into meshes.zig so i could modify it to add ambient occlusion vars +implement ambient occlusion either + - via passing extra info to shader (can use 132 bits to indicate what tiles around the quad are obsuring light. need to pass as an extra variable) +implement animated textures by either + - making literally everything animated + - somehow passing extra info to shader +limit vertical camera rotations +update libraries like raylib + +# future tasks +implement chunk meshing cache to reduce delay on block placement +investigate binary/SIMD meshing for performance diff --git a/zig-gamedev b/zig-gamedev new file mode 160000 index 0000000..d96ecc9 --- /dev/null +++ b/zig-gamedev @@ -0,0 +1 @@ +Subproject commit d96ecc993bcfc4461f44d9432589dc9273952a78