From 73901c52a567bfddaf5fac8151e6df7007030c5f Mon Sep 17 00:00:00 2001 From: Butcher3Years Date: Tue, 17 Feb 2026 00:07:56 +0530 Subject: [PATCH] I have spend shit while setting up --- Dynamic libraries/glfw3.dll | Bin 0 -> 305664 bytes Dynamic libraries/include/GLFW/glfw3.h | 6547 ++++++++++++++++++ Dynamic libraries/include/GLFW/glfw3native.h | 663 ++ Dynamic libraries/include/KHR/khrplatform.h | 311 + Dynamic libraries/include/glad/glad.h | 2129 ++++++ Dynamic libraries/src/glad.c | 1140 +++ Dynamic libraries/src/lib/.vscode/tasks.json | 32 + Dynamic libraries/src/lib/libglfw3dll.a | Bin 0 -> 89452 bytes Dynamic libraries/src/main.cpp | 11 + 9 files changed, 10833 insertions(+) create mode 100644 Dynamic libraries/glfw3.dll create mode 100644 Dynamic libraries/include/GLFW/glfw3.h create mode 100644 Dynamic libraries/include/GLFW/glfw3native.h create mode 100644 Dynamic libraries/include/KHR/khrplatform.h create mode 100644 Dynamic libraries/include/glad/glad.h create mode 100644 Dynamic libraries/src/glad.c create mode 100644 Dynamic libraries/src/lib/.vscode/tasks.json create mode 100644 Dynamic libraries/src/lib/libglfw3dll.a create mode 100644 Dynamic libraries/src/main.cpp diff --git a/Dynamic libraries/glfw3.dll b/Dynamic libraries/glfw3.dll new file mode 100644 index 0000000000000000000000000000000000000000..86ab39a84bfb72be9c76c0962f107916f50bab59 GIT binary patch literal 305664 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%0A}|42ij86TRC@@;p_oYzWPt> znc=d08uKal-gE|ckWcWk_|)u$dqN!=Gew&-tMZW}DI7K~NWCLYtxfQk;byO+eYD2c z>|)LF6$b6)(=cqaKs-E;xSn-UgH6{{b{fenYvwBm$z|o){4hZ4Jh|MmxynJ^Kp`1e zrSBJ+zTKROeF!({EzkbCf`kSYEcZ@+73s7mcmGb}Fst+}oW!F3wOWZf5cn1?WdFrXiKbd366o^8wNW;%)bXUNMvx(p(8x0U~8`nVKf^AV_~iRlmtKUl za?fb|tv-*ua!b5?U4Ch-WBMv=4lzGO8ar|cIpu1#V{{{yACazuH>KWHm zHV!Zcv)~y@4+L@r@xzy5XQ>oQHl-TTbkuc?@Q`(D`HysfZ1#Fz8VwiZPZ zicTP!yMVm@d&P6iazGwe4TTOQ6(xp)-D=I?I;OmSgQ`DprnNSi*6b*uv|o`1B^d2- z0`)%9_*PmBHlkt7SzMR?;U*(5PSIBisMWo;KjDs-5$>M}i)bI>`a@)YBN@y^4Hs>} zHUzTn(QJ2VGN)@Y4R*!OSB$efI*lg(jNwxA%wa@Tdb+rGa(nsctxlI?s+=LwpJ%pBPMewhu-r@UgNu}avYP!f+`*PF;}xlEEoLWREU|MV|Ww|?vdka6rKoq$UF|C{}k2Qbc z-}tWaD&m8dsu&F8{lq7t{=yXeiGBV0p8BoaqcwWhum03(wvcDXv-aRE|Dq-z06F(P zNdyu}yp(R6n;PzJr($AHETl#0v!?+>gEf{ICex4|*|a4+EX`-z&}hTmx2pW1QGL^d zY%wd#%l=5^g4Ap^k!JrC^TK|3*a_cHd>;&6j^N)iX;Bx@d#QGS2+sX#YN4Qk;>}x@ zf8c1KZ)teY!Fw3u5*>ICBe3m=F56z6{mB`&RuTl0XnsR+=WeO)PmWbDAf>5-FVwQQi?!k69I;L;kz#ko2c@ZONSnnd-HWgB_$ zw|Q8s^Vg%wYDFQO9IQn4h8Ij`LWvG0-8n)JruZm$_O5-Ii2nhp?wrM3JCQEx9q|-} z*^7_(OZJkH6p~-7&N(|+pf;U+_bNECKEw`>Z&Xd&wpCIhMVFq*UoZ7FLFYaE7k6sP zY>r{%y=}b_X71qZb^Fk0_AP2H`2xjr=f1;o5H`Kk22!>E(PTm2Rk>rNxEcr)(`u(n z{gaf&E;4sIT`4>}AGz}d1VS3r`3qhlfkv@xxdt&2W=S#pe`+JSr37&rjM-%=EuKAfZ}nR^Z-QA0xYK3> zS-Gw^HCfUp#FzC|^Eef*0>4{T|9o=QU|!gHH>}A0p1#7316qaKpAI;=(adwyzqR%z zj>YNcz0}W{-gwej5mWOIVwiOumHpfX$Gvdbkv)E*!e4G3u<0=Nf4k!ZmxEf0+HFcU zpnT-Jf7R6BAtTUpapsEh)475N*inee5IkH&qtO~{G^QAcyjZQkaSG`J&A0T6SzYvJtm*a zertq)A7(mprxG*@P6}NOMr#-~GrE#oqZ2s9f%G;zxq0Vgtp`~~Evap%&^~-LgGr4p z#el2K93U4@B-z)i!Ph+4Lp1q&qX;%(dA;Ci!dH%V1dxqG3Aq_2(m5em{E^#^b(@%j zZ2|j!GG|MA7<8$5NM)(h*XJS&$;A1vxW#PxXxizxbNs<>?d`mYR`im=bv2kby7n_<)75X zYo8@I)$?qI?o`k3gYet~v>Huf%g+)h&yCP365mI()6kgVe{G~x4U?d;Y}Z)+1o!%g zZskHSP?-LgP#-)^y^qnYEGLVZKCxCr<8&)ur%j!j+iG+3pxBM(r(R%&fih*fh}>nYZ$lXS7bxv#9YOkVR`c1+nnUx3j+YG0%Z27#%%zVk z|M;r!h)viG^{@II>5G7i8Tsea=qrk7kNOMTTtv1SUYLOUL2W_hzEK#E%KcIi&gURH z4o`hULk0SE|Js$$bwes_>1`C{ejIg&P=MGLsylMS88pv_e3Bv6!)ZU(;M|yc>Cwb; zm(W5{-%xmu(nAFd+fR}Kvs`ndHqXBGHz!csNGCD>a1?BbFYvvY$?i)t-zRml`_jx1 z_KeAc*@L{)RNIK8AIRSG`mVfA4blb1{Bw?hsJ--eAyzYb@lvgpK7WB~U>?^RU4m4M z;t8SVAIjo6ySp98M;eUG$bq1|rCfZu$ z;!i83bLvsq3oswDES|u$e@0Wr-#)v*w^y==xq>~)gv4uUuA9E^=kpqh) zr|E1pzd9$fPqgGCIqK)e8VrqP*%QxqYi0%j6u&X_^ejtFOUTc~4K{Z^2zrv>(4sdS z<`?k9eB|t>X!Ih(al63G&S-b-?%A*1$v<}O{zUC=0fu6ihaBYy0+@<+sK(EO^8hs?rU<2>6Cw(WjX6HTvil%{V+2h%FhYII6$sl8_!@@0h z?o6AOVE*89-J7ZY1xv&{%sBrWPxRyb{tdPVM|M3a=uT|SU1_D6j{txAjO_aCFMkOG zO7~#wnmC+qA~~6Uc|NjG)$GG(j3xK&w{{iJmjmG~dGF0<9`(qJk8rl|{xbC%kg*~s zF&JBI+C0$dLG^@C3S1+8-ZJA&?{2I^bIr^CQBlvG18`o|T#j#-;5_T^?cM#Aim}V1 znRT45502F@j}d8Df8`K#&e6r`_BYrS(XCQEu#JQT` zwR$#6DyFS{M;f2>gk7+kmMl3gGu4(*Ix0=T}GOj2Q4#c#^!ZQH z!vWBpM~yxv1|!g}q%8(w&>Jx^4Q|^zptbO&*_h%>v+??fz3%%T zeB=i}`ERGi^o7n|ocoyq=R7dpaI;f;^?(>KGK;Of@P48&b2e=vh(<~U^M|QTJbT11 z-9{mwmrUUMqyF0oyjd0cO&~%{OSpB9!}2?rP)+B4NEA%888?$l$FR3INwH@}=GTG&H$6?axas-1o1Xoo8g*3F@{v~`{dTF9R0uXGnno3& z$G$@$&$?|J_0*U5!BrwyVtZ(G%9F;iws@@HP!_jUZcb(whTqieda=fB|x`|o}|>y7Pz^&H5bZW4Hx$t&yN z67AeI=x+3VDx@!&QA+e&`tX1T%A8l1pnCqW2s2pH!_2P5L%~tFLi30Hi$?q9m%O)| zr;^$SgBL-IKoDe$+fZW{ixKJd3RT5IJ2~X~+i6kqLQsfp$##tan+40T(a_0{YmQ@N|Sh?*u9!F&?Kl9wlNHZxb91RbK6V&j^u@&#LGdm@B+ zL0LI+Zw86w@3f78f?EA5Xs5;GAheaP2|)SxZ-(xnwqAagjy!zlHkj=ao*K`79-CBu zYJ#vST1k&(4<-#_Z^@mai8py81Y74|tmq~C;hiP>uNzF_`#(J3d8Ar9)p>;%SAl_d zeGeweT|u5yXtFoI6hKiaRB_&y6qk8N zPakA}_q&xW>I#sRkNk2KS}l$&*x-S*9mM*5+e`A6d#@|`2u6-QZHKf+X^u>fw$%n> zLwQ~Bg$0597+8ujTcBzH=jM$|;M7X*03WXjA4#uU#`%}$`Q?d9Zz0A{#glK}t(rBX zPg)*B%g&Oxkn~Lk(~rL0_XA6)dc}$YtI9`y!w>_gSz$G2>6}VZNeh8~F8O*vM9e%B z%k=7*X~TLi)g;9ZC*R_6`+cy2BNgf2Zkq(YCBJy7zfdmbpEdkp>D;skVify#;uX3& zO4*v>*F-BXeXxm?6YkhcZ2FpldaYYcmC7)wFPSKbh&O@*WGLc&>R^RK5zjZ}Sw4~k zA6gG_?UbSTz#F7Gq6HbQ@Q|)3s{IU1hoTxss&GAUavKVG(W16~InZ%ty!{{tN%oe- zoYtR1V6ycP$ZL~(`pauao=Wqfy!Lc|d5tZrR9+hiRrj@q`)#80rQo7D{5-E#ZDjT+vpj__TX@q z^4*$id4n_UF0#99y6P7e=eCKXQE_hn3;HTvef6WUeB@#lUw|N*36!NFdF1{X>an;E zV+_)K_wxVW43QjSam-|!MfvuJtHCN+Ybd#flI2+I=_}yo`s>r|GiZ5 zfM%fd=!F!?QJHnD?IIYH7KI&}izk=jyV9!}N&n@LqD@*IaDFL0N7q42_|SIr_J8FZ zjV15y&LxgU+Xdh52~!`iba2Tmg?oJO!kpo{Fzx5Aij^Y@6{a^Cc7Gu3XGPV5t@>=3U=H%Ny#x&r-NBpO+8RZ*Xin zVE6N)4Z2wI;(--02%fV0iaI~K`EvW6f3p-u`N%npF5a-hThPNN32cWeRYo~IUAUVr zr!4x{!dAL?K>W`ZclwgXI6Erq1?|@-Nk*>n%+ExlQFy@;0R>$MIb_woVw&Wv!D9(;n-*~%kIb1{Ko|`;DqDNsNzc<8~4=j1bIh^;% zbW~`+?KZ@@@q-eFBwu}@*hh0|JK_G_@#+itZTVuM+Wv*?d*F4JEfRDC&PU$laAL!1 z^RQ#7y!LILLJ7bX(6fy&aL*;+#_^7q;_Nt2IjH_357pzOF$m88m1j`DZ>jNR^9Lv8 zM@`tNH|Fg^zn9REIy^`nx}LnxuD-P5j+(^roIeT}MVdYfgkat_;r%UxFxO(Em!$2g z$P?;nDHdv)+%m0`Ai56~W_GbDZp&L&=dNc%Ihm2=!SW^(@DsWZov;f z!Uy|ThuA^sn=#RqJs6YRExRS=HELLCTgIjL>emJZPllJIk*@w&l;5>#Y6i4ql=_hu zeD5q0lD+hW5I9XvDKznyps z3d&~tcCnAGz=!7F+m-;hW?6vGb_~@KkulXP7uvaRB1`s|%sQOVW0d{Kveyn?zrFmC z^*bBv4QN|c!~9=E4v7XfY)t-eJX2`FT|+!$aEC8OfAxU1c@%A;Q9O@<4Ll16zQNiV z1IzApNNKf|LT8a1FG-?EKJbm#<;g}KQr_{-tUU0|LB`|q2k=^>1ryGE}8_e zr$XC{%57J+T8ORo<;MJB7gLOREWH23fPtMN@TdsZxR(KNc7zdXO9~5)D2>pKy*$Fi z0DomPAsy3RTKm|+vkKk`d?Y?vNE%O4(FvcyKhqoeh%r1K*y=%V<~Go2Z&q;CWGpxz zx!``o+IX-AK0XtUX+_~Y*%V~#P5#cw!=Qd81`li+WK_R za&#H&uiw-Vg8lXRe*5diYM?N&ES~4?`*-{6ctcj=#sLpxgYQz<^R1M$#mvXpGPP_* z(?zggSW%kby`_8gb(EEz{9&Fo(eO)m*Q~|dvCFmfYw~rs+X7Va-nqJe*1w=E2v|Xe zd;W`k>fDJUc`2AFtH!LX8y&Bm=k|N;%$f^n_tkq#Y4;9LlKU+L3EjB2xmwoWG5#c% zb|p`fVIvc*5BO8@T{8540Buk!ts5$s!S^snbiNhlx5L#AA~l#F81E;8*VDnwfue(` z?eYsoM>B+g%(C2{99%NQsnh%exu_U1b8`2tLDr{ERMIPqdJ|RCe0$e|sgB+Ig%b@` z|4=mxaoFXHe=faA6&5END`bg0PL_O6@d9L@W!~O~+FY759zX`?7n9k-=8)SyS=u~i zibwvKHi`~>Om4#$C?ebU$%tousj1D?+UQI!G-0q5*K)xD#|hsrPvpLxK7?d8KOuP{ zPiq~LKXVmG_8gJ}_(ISa`E69Q_sdYgzD6>T;`*I6U5&YS%aDc`gHm%Xyj@f9I?0+?h4#%J9#YdSVwA!hM@r52IZh zG!Yk9?=PPf^iLV?8+bO#S6kO+KXEVPO83MwQ>u6iP!P?g&hb)wN|x1@=D&p#R0mEXJIG|(;}1AcYCVBGC_ zUB!eG37Lq77t@98rQU9b=6b+d^X&ndApayyHFyu>%S6TqNN4iEYE&Y2wQcKs`&5O;POMX!x z2=;F_&I#*x3@WoRF!|}b4gSv<#Mc_`BBbWaPq{gHr3 zgUJ;I1H{H*p%KJ-2~_>}`)CS7ASU{uLVRrg&zKl93B2i$0L4jr*1a{M^1E zLD1z4bvaZl;D2<_7nx5nI{qtJWd&&FSk`QpwXB4Koc#x*t$ca=AWi@=f8J61YyKWJ zL&-Ea<1?`nN%Fgn;ja{9wf?*dSm7Nz2F-$Y&9`gEj=_Z6hArI-E1$k`tYgUe)UaFy zd5KFpc2x4aw2BgKmlgQA`RPH7X87yZ?aD76M0PwgxVLODfy}Im-o~nlb%c!ZVG82U zYXl4!z#ARif?^N#`{L48jNAI|rQf9^1i_t!_LuIV_|1j5->&-g8yLr39XqV{?cAXi z{5^t+P1|gpYLcO{Czxd_BHjrn{@k9nB$*s zQwXg9Ge38&_@^t-pCK0cLn{j|zg2y3%PQx|bn^x+VArb`K0#kzD#=vH#yV9yTixrO zuVfHct;STM%_5Gm7(%dE=Hz+BfZB@9mAel3!@Oe1`a7} z+b@_IVWH&wMmt|oJLcc?8#LkYRG7ceziG^}`d%*VkA7wi#Jp?f$l#w%n5s?vfl> zn8w08pZ2UOK?bj2CYf2@*IUwIQQzWEID`(R1-s_gqghM~(B;RIvs=qDH?0F)?6l{U z9cgrVAWUQZdQkN0`*!wm;eF$LXZTT4LfC;pFR>fJ4eG zau%n_xhQGIqm62M!9Jki_UF3LhajuO_j`nB*DnihpWl@7* z_OIOkAt#*A2`k>UwUfW$o?tq3j)Myq&Og`OqzrDyEjf4S_f4)Z)K99uKWB~A#&6-H zvW>aUXw1(D1Df6E7~H;)>;o?ZYa{zuf_;Q{EHg6P0IFt z8?u~4k-mU*%HBrV?59h!BfiVg>d6l8my>ikLTUCLteXo>MlN$X-OAb6FDK!0dX%%Y zU(UB(j!>NawaYOko=L7F2|u{MWe1gms#s_>xf-41*irHBF|eV-L^Ui&i7s{kFfyX7 zJ9rUjR7yUw_w6!-*iP9Dwzy{z<7|*h!UuKCm@fnv<`9}@@{BA$UxSc&>3qQ~0Oa^! zWq!T@Rn>Kd*b!3zKR@5dt8+xF8%vfVg|yRM+LqF^ue-GErDv3-GrcvFtb%{w37~Sf6&JXQ`>0~ofQrMd zBIZ}S>+wWa@twa@@d<7>OMB!ACq3e#e0LSkbrmu^mP_f1;Ub6d&b6v%Gs@Qjb|1s8D#SeF1ahFcmog*$)#Xk?I zIL0c*c3<&+SMeNGylg;4?F0Cc*?q-ZUBxe|V&i~{6;^Sd-B+{^Zg-9tsfv3Hs5sIp zB2MoPtBX37D-Bogn6md*t+KS46p(YDC_CE@YCwWwG-- zwvJrVzyExgeyvL%MS5>iRH%QwNs*NciB4Qd6YoNrNf*-8xR7w|LPDMk2^%h?;pv~w zaey&N8%j|=Oll3o5WEzw7L3a;&vkJl7mUL#Fsf}pC7}B*TdKrc2gLUn5dZdo_%yXy zQh)J)`1c3IuasJ)r2K>d@z)2GznwV3kGO#T;rOjEusZ?8gp=G@3Wf92T$rCd(7Bs4 z^4x$4Wtf*E+#&arHmAoxuDKS$;MyzcE>_5Yw@42q`NtLVuiS0@QHA`&cALLnA^)D; z=F7XAgKzC_^Y!gzm#^nNABBHoA^-i|=3iaNmvg9()~_q%ckC?WcSioSF{Jw&FR=Ac z!^=Zt*P(rqJm%eGWQb`{ZZ=PnLi+44zBZN(xbN5~cHn<)4DzcfvlrBkVHLOVqOy)( zv@rh9oCsrD?0n>Ze;FKW5gX=8s_{|>4^tDB``&6=^C){Q&#q{e?Z^%ZoV35iT})<` zKSv7*@e(6gFLljO>98-V{4NY7=HFnO&saW>Mnxr`M>4JcoF9+m+k)h;6W4=5lI{tT zzNV4@yqUPtdxG?@236N7J$(h+THL?dhPRl{OX^J1vLCHfO<<^rs z$IBC4Sx#R}w)Lcsz%;tah$9@^VGRdKf&w$I%<^p;k}uWbdxA=th7 z)iFf0&Wdmrn>)v^MD4+Mby)Vo6>k!5H9BObbs60v)Yl00V~X>68JBsSeB!!^Z~H_p z&8F%27@s_7Zs7UV#iVo`Gq}12b;xUeszRirUS_~M(BF&<&wpY0DXx6^!1AB}nDYC& z^7~r(jwROqI3iwJjw9(|pZ@Sv0Wk0kE-inU%BR*d?vIwg(v{!a$_Ma=)X)%x5N>hR zI3@)nz8m7Ahe&A+Osr|z%Ct0Oz0~cl%qRMnspwbcMptHZ|1wqm%7~EZ>y!P<3=hlL z3|!^P9MZo`by&vWx!9FCw11hA{mOjHl{u(?nNj`9oaM?K+`r5L{mRrkjMnroQ`4`^ zR9EIx{maz$D^u>u)b=lfO-Koz|HZ)s{OnU&hVyZ_RAT-w#Bl9__Ao$~GjlQij){){ z-9;BA{4e!C>|?Z#Yqp+pzOxkfuG!B9ocwtm!~yH|FHHh@KIFP1OILwkU(%E22Is!)L;{f2);@xXa+WPRyP{ON3=eu(G-6^ zN^w^aDJ1N!WV$Xyi>+2|wY9CS^raTjsw4rD06qe~Km-vLXIy!z5D>`!d+y9^Hh|Xu z=l|#PAv1gDKF&S&+;h%7_uO-Ddef7WKf96KX+{tiX-k+xBLOGXV((DMBWP}eMSrmt z{R#C{Ch0@43?nhA68~oFQrWmm8)ch%VJ9ttC$uWt14Gg zf)l!Y?in)p0cRn}#i|G4yOHdPdqi86!oOoA68DJ4D!-cf6-c}+YAX!My$Dcld%2Sj z-oOPC6N}`yevTgP72fAK2U zMRewPQZf+~|D^LE6;akDK*brDglnYSbwXXc{k%txH|jb&V)x4M|AwLHh|QDN2YF4_ zWJg=FyxIbZi;KlGby#AKDBIM0A|;KwRc_&DI5z4Q7Ru>c7;93VKYU4_0{78`S2=q| z=Dn(6FC|%%rRr9R_dC##K=6AvW3na}z9r^v=|L|X^T^AUYpR?B1PZ_bc}~7h@;D8; zfIdhKo>mZ3lYvg)%IByIZpS1E8xWVJI4cHJC{eEP^pKHE=C*t$>zlLwN^n{+BwHjU z2@)djSaZ+XF7MhcOVu|vPivi0r(|RqE=4o4Od^Xau53Z_g>qA+T;mc^{T!pMd)u05 zL;|9H1L0!&Ofs3}MBz~f4eT$70>UcnkE@tv$~tX7t#*vFUN1$a`Q?0ci=I1s};u3)THXCikfpTP%O0?8aE zI-9#=vP#%X)aJET`Ip(x!WxOA*PQJe^FT>|3S#H+jrp~D&7oIgE>*9(VrzY6#SlqL z4#^gJ=r5qI`IiFaAyzT<&51dRk8#F!k3!}@9MIrH&j2b6ExwAdTrE}pmN9=>ya0hdb#%ane8M$b~ahyRTJH-s+^UO{ah0q~GPFFHWZ~ zbJF8Z`cvuje>>^-IqAPjr$6MRKT0|yUM({69wj61ab)BdU&x1)=IMV*V$Yb=I65lA zGO{_4n5Q_D3cPX&Sg_kD;mXgxQofbBK)JC}&Q3Ut&8!+>zv95ORbWzM{_#K5nE%Nc zu}@y{aIyIss;{GZM&Ja&oXY*2lUqU)lm566vr1n?Zn|`xq#sJG0F5gd>?dSY6S+f} zII{Q?p@Wwm`UG_Av(I$C_E0k}6UiZ$rvbX!Y2pVxQaqE80|}#mDCT+L5#+xx4Qhb{ z>MLNG^xM+uU;JHl_*o}?QyLNPIq8o$>Fw$KOPutWlU^_B%CBR-lYR^7?sz%-U)Z?R z{?|p`{?~Dh&lk}*any*M!d{qKmPchT%;UQsOQmWb>>?SN`|7(Cu%798rrM&&H zGo9aSdxlO+vSZ%dGxRF=dA|Gnq5C|=eID&T2e{8Y_d4Z1b)WCL&*kp(1^4+k_j$kj zoaH{JxXgm}(dWJp?Q%!qaSGmtN_xZH@{Db?v-+j(xz8OgJ#2KJtK4Us`+VAc{=t3T?>=X_&nfQndiQyW`yA^&Pj{auy3fJxGs}H` zGadE}J<)W=XR!Osa-TamLLhXx(S5FRpKb2*Y4`aD_j$kjoaH{JxXyWYi4V>0v)-;?2OueBYA9_QQnDbXj`|~%X@G_O5sWTdE`qr0cHr>r815de?HIM z4|n)iAX(`*ThEV&2PB9&t{jD`*QFXi0;V_ zAH~|@2&LtEz{beKM&XZH%J!!B`olcKDls}Li@VT$A~K?TvcgAjLLz)&InXjtPeE@ythKC_`h4l#i+A=D7B^@9Q}|W4 zMPuw+;kas{de@5XJuyU(_eshSWd+_5M?5?@Tw7~$(8gt1n7LZ5AFh|74VRXw!qzcl zbk20+&tZMcN2_}scQv~5-r29OG3w4b`4aGqnQ?_SN34jDLoq2RiY)qz84L%Xp#-sa z7f->JttKyVNnX(3#ZPV4F9Ad+Bs_V`^os3~)#5kGc?6*!nsg_+VVm_!u@omx75%#-_Zl+GKb!%wNHEHm7)dP4hM9W- zUqS?#F2`G^yZ?+|^LJq42yJeZx)a&5M)^7OATcgSUhCy`LLT!$i$B6UG+q#@NNLfl z={t@_n^=_v7x6xm|2?T|dTCnM7M$JqK?@*M#&&9Et`u&3%||YyyglT9jjQL5GPp>G z4BFfah0db;8?<`^yb%=Cx|KzP-gI`ly(Ia#?>Ujpsm&a1!OD<-Lv&9`D3Nzj^2`z~ zb~44Z**31PWZ&o<(fcZPwpWrB(fU!bM1Y z=Uo>BrI#`$J)!*dX^d#0iv2TQUMR^%Mf=QWWjxkVp6=T>dvHpk+(;25@p8d{JF4Nf z)ax=oyx&^v5x%-!=E#@c^!*I6U6`&Y}VOjY|@_1F4(6EjbVp8KAtpB;(@V`{gZjHE4*#4i|^dFwDt$$doOiY@azwS{ZVL z0x|bRQuu9{-+fxWje{pm;!|pVw38c)UHQd56nv$*6_LX-Jjw*m$+I4Es^}Tg(jZ+N zbd&r>K!0!Ks?mmr7ay&KH!;s2P}YPoSRE zx<2g8@gFZicsg;C?i@i)L;~J_fk5Z%hJzz7@ys@JC zDxwS5T|C5y3d}#f4Cr8&%aIA zquqITa{hTpfEDk^we^iZ1hy-Uy0J9c)i_FEi=1EII2DK@W3}gMia0=4Sj!lQqCrbU)bXD(j^W z2S2SLvkm;9xmK*4GCvbPXb~0C{<8YUQO+>c^r9l1Z+5!tXBQ`1wdag}PGU@k56POl zd%1!ikfnlPUCro_zpe3yeaE@Jahl+C8v{F*fgS4&Y*ul2mrNZ#+7DWV4ivJP?@0x@G|Vm^p8yp zsc_)`miPzdMnCY+IMhfdmIafS78Zx!(UZEO4e;OA2mfQCPw?LY{>Os<)+q%>w5=>y zu~N}zVr=OyIT+~CM=0^#zoJp0Rx;w}2t`!ajT>FNv{d~uC2##hKh!9TTl z%6E)LTm6dW`;1f7oBDd^Cq{XzL1OKdeTzHy*<_??!&`43%w1ERFR(8^Qw}K2tZ2I{ zACMjT)XG{jayK_?!#n?9<#+s{)ciJ1e9mvvacq3FTZ)+ zNDRQA-CDeoEQucO^UNX`kuH@L(vdajR6oJ3FA(!f*yMH38LOf z3^VQ-A!zn1;cEp1z"!Th5h<#9JkI@#8rPU9PhO6u*BE=~|KUf%9`(H<+=42Xx z%Q`7tWkW*MrgX&ALymm-tc*+M{gK1KPb8muzpoOy1Yq2Cqo7|X!e#*>KsqwXL&N@(Fz~p6(zj|-eImyeywzQ0m zH+A4bypj#cV-WhKQZAeqKqa+ArSekiz0{}|@{OXcrcJ8ZvlZ5uCWGC~tC+}viVwBeZh?SkPhNj##^E|cWwUVX})C-=TeS*53OV7{c! z7=?=rVgi=PoT-;wE(gF9X#x*1eWLtk{iD$N&i>)GRh2LAzuX@7g9Ng>4^tz`kqu1P>LnFvq-Mspcy=H&~ zT z722%G3N_Mmb}_gf;lLQs?)v%hNSCg*v54}s zHL}NTYWDE}mo7gpS+po>jZnE>W;1hijke%24tzM7@7Pck?|A`SadA*!kIceB6pmV< z(Zlb&jQyL_*&dSPuXQ=I)YWwL&9rD=sF3T(Q(!rhwYQ`!sLFQW$+Cy>+u>7ADr?lG zS@w~t9h%3*!;@E4F}&YVV%JfKeMR;^TVL|g(Dob1zfa}8mjoLT*YNu``FkLlk4Je5%c>x%E&TnVlJKh zsweWUwRstDqjI#^MT335{{ml6>K%t}un3My6*e=`%iU5(LHp?QQth9eYT*fy^?}4K zrCdkA4y}P@$>^QMT;M>7^!#z?c?k`wd2FA-$NFaIB+E!%n5Dhk9o;&DnBLC7+(yT3ooD>-&8t<5fhZ9xR~g1$tc@S~gS_2{M? zE&dS0q(^&t)S3_~>fX7yL5oiza{A7Wep>AD<3KqfA!n8gZp0fifqZO1gOPXmafwWV z5+CRMzsJJTmqTq89lCa52c|p6&$Gr_#GL2Ah?FlO9;soLX|c#@QsIj(%j_Y7Na84i zQz*&vnO1v_zvI~F3xUjvQB)mD<;J^GB z>4ngb&Uq^9da4daxB97Gi~Uf2+XM4^O_ZHbvY4ub9K-xDm6bh{J2(03|wU|mGf9g-!(TN% z8sjbF6BPiyaeS5!J!pKA1#}1pQ0q7WM&VSHETpnw_Sa&ILD;t#q7T~tKMm2*_}6$t zv@$MH&vNm2vn1Fu5ASq;?Opk-&2Ei9q>&df(9u7pIIzVgp5=m|L_s3 zYGmXJB1f9x2w&E=`w&R1KOerzr;BZtcqNu4g;vL8knEcHJqP= zS`~E1PKOhlU(x1n>j=7nbz?vNt(x#oZg#V+EqE3<>@dG6rh1iHYS~MqWk>nwkf>S0 zpg7&;-|GJLx}u%4Cgu5M$GB#Y>zlPa6SrISMDCf$4w zoKF=FKH0j9_PC5&*wdwaCEw(LIpR=S#3W|MXijgYbtgvs7e4XNK z|C14Y#dv%RMug5m(C8~HzDfDRktU;=camVma^&b1IiCmaXOCl#$qh(%Q6>EKPoG}K$= zkM~qIMSPJz!kbeI4vA**rxNz^s#5O13C%a30DeTbvsSjrko2P2VJ3H!N$USZ^E?Xw z|AFQu+k4S09@-u^ak+<)beT*BuTU(;V}mf77sAyK|_L=*Alx{@RM-$!<$F7M0xtwAg$UmxkTB z2(-TXP9MGfy%x7UN4yJ9mBE#N=wE;!LaKz@tF5P7$k_p{qPG7?U~}c>ywVLM8OeK9 zLF<_0{)HTHjX}sV+q4g(S5YVXzqwRBe$F%R#g! zPnYu{x;abPFC^zhOS!2=Nc$zIGTMEc7VD3G7wx`@I)pKd6n}C3`5S2jTtxSd&|;Sn zIZS|CO&apyNgg6_o8;%}p<;sK%<&{2Nl&OG#jm0pD%%~QEFa{K0q#AV&m+(zH$J+m zm;E>?^hv&Bn<*5)5RW2_JdOQHs}qmcJnO!QJAn2FMx1wL)gKJqoZSlU1p z5N3Uz4_idQ{E`?$a3GF(A%VujyBf}emc}T4xig?$^rb@E4N{rd%xvoc9Em-oRg)|O zv{UhTrq}CcNimcNF|cCAJeL>tGG`D>8eK{p*GN&J;Y1k4A(L<`wGcp=q z4QA#2q!-+jM_CXpfQp(`RVq0A(%`n}2=TwX5s*3YBw%fz`In$crJx+F zl7yIRTycuA%T-B2kfJl~4pd3JPV~YJnG3X&qz7vCRA^oMDVGt-?yUnLr>^J+G}Y>L zMYxp(INTO|m^)bwR_Ipsf9b|KFRE{n7Yh<4;T zb~1#hWH-!FQOrVqEEjeU&du>n)Y?F18tdESw7Zs!Gp}%(yPn$a-2)PCW{MlAE z5Iiqz%PLo0TIvlIk@M*Yo!lz%^0k+bY}j*+wt&^y1IV_9J*P&B>;!M_d~Ofqa{r`b zQWCm9nopyz(PBd(z|p5hHfReDYuJ5Fcy(-9_)TmC`$w&u^2(^?TJ%+hlv<;0ey@g6 zZBw?S77CdOA;OH(BEZK@mfqB#$Z$lvF?9}7yq?Qw9H;S+`Kj4T^aiVr%(mRk>CWmx zDznQF_3m$e$}G2s^d`x~w{v@cOOfb@+oLOn*;}DRw;(LlXTQ&H#c#Z6VSk^LgYAZ5 zE&UiuPiy>NXDyX$P_Vj?eHDuhPybO1mv@;|Y5SMAehDp z;&{V>ApYQ>dgiC=IY!{iSh8FVg5eP!uC&-uXyh^n-%&b>n%zhB&Tccy9!U*yISh>> z+@F^7Cz+jifssB4Kf}`PKg{QmJDE3UGH^couT*AWg20g=VD79k_g9&pu$(i@ue7)( z`~@arWYLmZnMQ`X>tpuDWPYP%p>eS|PN+q!1kgMRN@U<>C{Yu}W}^h?rJK^U8gD_v z@eKabh4__Z8})K{BTkHJAPAXvz|Ax6%s`$$D*m9wV;(wTm7{wuME(i^b{hRjc- z3%dCQ8oav0EuGzC0o1QKM6)$uXxP<@+U+CW2MqhT!+--1Z2lGW@NeZYG` zkqO;J$%nx^P%5Ba`%sX_Qbs{!KgdPEo?XxU605B!!4m@&8^dSX|DYZ8b+IGWJSKQ4WrNVMOF#+=iJY{*3B)hLgu%9P_wq+NB&q# z*hFxN+9r~9g`zW{a5Sg#cHCj&J0&RAocD@lu(-}%#;+_z>_Jgny77Bu9r}xWZNZsY zm7{(Twt}om}f3f7E0aUig zGJBk=pwee$KZ{3;kNq2;{U25jqFiU8h-XDt`0YC(l8l4`yFN3aaYYWC!M=pFka+{w z@b(VBfsLnDk>~prDM19ox zX@3e~wFicX?D(-~zYSzq9=nm>WJZx;9Su|q2>i6f^6Ns|cv zTDyR{(j-a5LKK?SbkM5%K!!P7I#tyFv>NLX+1REtm3nLc3SI#7dXgfj2(kq5rXJe8 z7At4HwsUc1ct9}PgNgNMeu^ZN7NmKsOOA#|zp=zYf|D9QZs4Q!(FVm;gBVC$4SH;Q z&M1`p%UIM#KV(N>8-hz#pZ`*IwS}nGl9J0$5^7vKUwzQx7oZ{uZ6@S2b6y6w4XgwvveTA6_cj!z`Y-5xMK45Ce~jze%mGSaUUySM<3) zm|;QHM0#qHv))dQS8J5ndq_);Us>TOq|>hxD`9JMs^JzZOH8#-RQzcL25m@irz zBd!*;UjnYfFCwqXG@YzGSw5v+(S3djsP=kUFgq{~(BgHd0Whnn>UwP6#imw9KNj)M z{j3-D&{$Dv#SZxJRpz$T2#>!CQOY)}gB$A?@2hshBgkG*ifpOq)Z+Q-`-j2k62IOs zy3`k04izS^ktGXj%N~0!DjMQu!8l>Do2t!CE{X(MeX$g(z;9iP66;pkTYGy|ot)8Q zHPg5p=O)L@B9P&dN42>ZkC8JDR-A7EsCr0bdS&ht(5zS?QYSj5)LWEg%%#1%oJPf%da0z>wO5WJ zyowep0RmLgS2ApWihA7*2g6SCWG4Xyc7k_C|C7Hym~Ppv7@DDvBS*QHJ(vEa~#)wZDUM(pwo zT{9)M_;~QKb8(gy{~bDQ!-p85HONdjq;-UJ<^bikDa#Hjwphs)@Dpmh?Ay@c9qGq% zUv#b7Gz&pE*M!SmsjP(Xv4XAI3^ANUqVy5N(&@Aiw$?k=z&r8;m_w{~Yo+B{I&uk` zo&5;*h>Marr2v6i`o7#i%%O%;oF=f56RAK=B8CVwqlMBxGM0t>A6H{=`8jn&dsH+6 zal;8~>{iLTSo!26bGV6Fk#mXtf1>>S?~I0B13>NujoL{U**wY02OwEPV~B9}Q&4>% zRr@(n!M{zlkFg~978y(I5_$we?N3<3cq)uqNBw{);ps3>|4oKKR%R!V>RM{gdDby| z#IJ=b+v8|3Z3pw#xsE30u_C33rAJ0X` zS*6u{?rAmlP*wNAy3`ESMp~E3KCmexv#G2#8)Tqf!a|bS%GwI0IoYiYq+?e@c^ibO zRWhGjkj~t@MmDpACt%Tp;GT-*Jq5ND%j+pru*L?dRqnm6102`YrusQMy3tRGzFLJYpe3)!;0Og=D0Db1 z@oZX1ujj3S?=U*9yV}jrH2cJlxSADVT>8i`)WoU65yTqoZV)2pShVLOHohbK)<})m zXW3#AlnufhC16~s_Q$tXJJ1ij%Bbr?rVT-+wa_HngRe;-DCFn_e^WL-(UHfgE%m$* z+@Y0uEp{rpURtK7z2{^HcqNER&*QJ#0k${0TS6x(B0L1IPHzcGTo8L3>mRWT2$76c z()tiZ((L_ZDe@9Unh(}eg5sZ{+(jmt>y^r4&3;p+tjj3O#V~`^WREjg|M!+RK;el@ zv)lj77_||)Au1WR25Ev-gD737B1kB@FjY=z{ZW;W?ObHew^$kPc|u@QKGe?2Sm`0s zOj<72P^Gt0w11A+%2<+Di^0ed*at$j7o$f&G&yQip`7wO(5mFJ0I@Hrb$eEQz$^@x zxeIp%x0snkZ9o~S=wkVP+1CJR^aA-56GS*XerLat-0n_+J%C2PmGr#({cn}A*1mI> zBf`!Q{q#Vc347oWxTvt4*k75dLhwIP1b={XRZq@c(5BE{P0;)-gmzFv0dt>jera}a z0Rryh>_1yq{!tAO#HYpDlx8GGKCZs)4wzfats!jdQZ8hEY?$8>zV!!Jpf=M{XJgaJVwbtZgpn0znQC-|L(a4}9~WfF z`Kp6vnii{-`OJVpVw&|g$?3SU+UM~h`XScJ^;+zUTxZZGDpVgZXiZ9#Rgyh{7or%+ z7PFSkgk-j-XPxgsq7H&HEN67yqIJjX%u%&vqg*ycIa-R>W=LZ1yZp=CnYt~_BgX@U5@PM)Yv7R= z(Z1r5^OA~37Q-W}TplSVMk|!O+ppN<8n|RWjb)5>Kv#6S?oFT+gAQaGRkg>AqoqenDE$lfWgUm1NYo%soe{Hq<%V4u&HMot! z@fs9~R3c7-avbQRM};O?sV9^YrZ_Ga&mY=P(0=6GE#*q=3pf5R#0*9(ya{&`xv_#F zKS;oc+<1lz--5hq?Wa)EztupT{Dm+S5TKiFJbLF<=9KCRm@BPcu5hQ+QOx^q0Yr&y zu$KE484Y_m)bP#F4z~Y^-l@f3W9e#-hsvynAC`TFQy^gbURD@z{WGx-H1aB2YOxMEAmKIg5zIc~pDQmginnym5TitI9~Q2CCa{~av4 zY{Gv}i=84niuhmPWrcl37~BT1g*T4lgAt!is(l5Sbo2A*vK}4hYUnOvv(&0t~6w7EGY0({1fuTKncP8f@RoR0yD)H_`dtZffx}Xv*zs zi-1xiJf}p-Yt`TOz=$57JxJwZm4Nh9g09e;{N_hl`NAnWP>qnh#~5znXb2K`6z@ zg&uOiqSx++H3ZHR8>&X>>#}{#+881}S`1ArixmAniRLZd^+Ki3i-sY_u5ZvXPh>&v z0sSU>7ipULDeNx8pd!|jrgg{xG;^gRCl;l7Pz!s)&6vC_O%5y?%OZ1JN%xNZIwFW;sDr824cMrHczL%{BY<-{w>MTtF*95TdXVWi(c2@<4U z7H_qgwfFaGAGuad5UJ4N3S-*?B}|h|3}K)1;a4oIM7g+pf)!m%bLCi!i9qp&y8el- zj$EZLEatm)Pqy#H9`-aN#~C^)E`cgsdt|!4GrqCDAqUmR`n8Oz{MJ={ z>+L-%t=`=DMsim3weaai@+$NPH73ie&DN32baS;;aWa(fE<<)<7g1H)bB<)6KyFl3 z=SutJW`bD*$?blZ2IPD!YoirGbEV=l1iK*D^S(-uuwf`!>$=)=j*t>^TXS(Cv`^4I$jVEpXIHYUYesl7bwkXc%`7;%qd+ntaQ!ZHMf*<@@q+6E&HJCaTbQ; z@8KMSZZldxEiqR%ZuI%K&1_^gX}(5w9=EZx_CRZXtBP=$*BZ&mUl}=4;<0l3>(#VG zUBzDf0j`8~e)jq@i#^9Xf4rnYE`^?~fUMWby5xn$Mu*Y5wS=2{cQ>N=(C7!!Xnvdd z+Cu4Z{@dZB{4)QKc5_9bM^IcuYJO9>0z?R`qW%cYZgewP-r$iz;6 zo>MY>L%lY9$Su(<-!#rah2hI%#BB_Zdj5`)=7`6mQd!`^_DN+LG!e+q_kxHU>Gxvm z#nWgw2?McaF#%u<<}qZb*S7Ao8)>c?3rnn-7ir7qww0%9Rc)a)`an5{lBK%Ot$p{) z??U(YS|vF;d?%0#2hV>IS69tR>+E^#Wt9p(32F45mZ2hm@mE8q*##7mP9Dqo59=&#c7Yh^o9 zjl>%Zmrhcs64S)B=pI1S34U6@NT>G80zpH(AAf;}l`4M+6)Lz+>zu;H!l&g9;FlIH z$I2>4nV+fhxvScyKlb(T;Bc-^*G}tG%U6KO<1%xyj}aH z^iPYQ-?x|lr8>#Rc}?kK(^qstvJ1?GOcUwvQPSTjGWN~x#M(lS$B4hR7VA{9F}2czL9USz82&gD7`E`k@u%SP zkS3C*4PXSeX|Xremn()$mux?m>8-kaE^k_V6o2h;09D^C!+4xqr9s{u+O<3E-;m(q zPc=K2=)gdknqA-AJ4$Qzz-3*6vqkJ`%5Q4t)MteTgra=X_64eP;Rx2YIqAs+H8{*b zy7I3Xghun2!o&Qa5eyzy35>=bNO>Wilw5j0nX21%Xv5y>o&EMzjGq!+>JJ}`P%?Mu z<3e4`5@lr|CQ9jO>+vf^gNbhJAKjCC=dIYaAEPOwuIN6)zr1Io+h4@`=;VD!PdTtL zs&(U0A}wb6@|Pn$mXX@TM7H#E|yh z^p4ca0&k^=wh=mAQ}cL6tN8}w(8bW@{)fzna3x+jYQJ(QWZ=_XG1nPiOZ;kKj9uEp z2-<dVZ(b8ptQw^b+b~qeh4|oUgkQ?0gjK$VhXILqM0FHIv$jU4g-~N$v-ae#IK@ za|&{UeQZ@Y4_}%1N2HUzU8rLO-K%utYKZCLF=>Mu-;b{nGV@d0U7{A8wRO77ZfdNn z@0Idf*ODwYf0%69fDK>%O%JAk_R!c8cx7!!>`7Y;X9Bj*GPC1d!tIOL^0(e9CKxKJ5+O5K@0+84C3#?tIgFa(2)RN7;BL> zeF8!JWxnC{?xuZ#v6eg3NsF(Y`dtUo4U!i7HEB|6IlpXEGBC?!fPdkBXq69>`O(Xb zl>R!2Fsy{))W!JBx?eX}G3jcV`@~M#*fTQ{cJ)(H=^!x)UT8kRQ%~OCw#Yr`t}R+c z*#Hx(0mg<2Lv%3Clf&W+QMpIJ9)6C^B|xq+VRr#(YgCBuxYn>rv3^xf!RV4no<6H{ zch$_u!*1K6VD_MxhEKz46hQmJ%sg^g>H*@X!MkF;|}=!#mq6BYBB&r4{4KW(;oF#6l@MQexCiC~YbzBpEA@IS$`x32f6_Kk!(2 zCfxUc3?6^#6JJL0`ddoNB+L+ZF>|Ak7{_0&CX6P2r$3)1)f85=vuwTa?RZOKT!9wc zfy3k6jlkS7t^kmG0?B$2^K;nUBzCBdi<~1*wdXF4;7q0}Dx)H%)f^cdf_4PW{h{Ra z{{9rP?T{ZC{i&|lPnWpsbwZvvR%IgK0}!BVFJH)#GdsLodU+y-7^jy`u?T@&+wpnd zP`-`E=H3l(KulCM!U#?%m{H=u#R~EH65y~TzCyD zHBT9zbomK=%SSf3n3%hh52-(S`1VpakQ%+Yz;6p&;Eta?se8TqZ%gz zjNw$2S;;yoF%n0FmpdqJc57*O`=@AAExjv!<=tkRZdMl1Gpfjm{D5#~@;i;sY$kq2 zTaispH{;&{QTCnuamLS0?MH$_=dJRkm;Al>$I0AZ-64|oZKLiIf?G=XFGCC9!?h;9 zYU(l8$+szUfoKkEfKuW$-_D3YkJbb_kwVk<{O_ZmjjAFRaC{l)7yY#-a<#szP1aTm zzt0FnCg?lcD#H_nXPmmQgp?+(>J25YE*+*vH=Kh#k9l{VHurJ9N+~Vg#v9Wtk8K;?+WVn{wEOM(ygTE4 z=(g{mZ3VTy5T`MMuP#yT(>85}e^q5}N2ry^d=22@NR20S5leYQwB-kZ{LU)#4bDhb z=-T+j#v7kfrfGan^tb6b_!9V)lV*-s zD)wdne(TdHJ+0Uh$(MrhdElFZl;S|d^ed&4E~j*EI+DJI2L>braC=t!_?{8^i!{{} ztoZWwqQu>KRjlZGY|i#@wxof-DB%YLOm@?C2kjIIm~{o=GR89xD@chR{fxssA8B(# z0Fu#6>QM)u0%X(g>4<8HQjEQ`-e!XfdP>hnIbT3!{@XVLoBp!!t0~9ZGToFu<>kYKSF~F<&GHzxQ*H`+(nmADXCF@8z5GX2 zjER(r_2hVlWCtK{nwd5ZsQ(?OeyP0GVMP6%7E&+OHy?ubizyH7hi`aZWUnoZr*}#L zk~ZrHKqBGa0xp%tt|E^jkpEDEfz^^9@B%0dgW#VU!9JU%z-a%0KWYAPX!>3759n7~ z*B8n}@#xn+M_^Iyn%&CvYmAR!)Z(H8R@Z&xQC_vVA>`j=O>XqydyaBo0T>)|(qd1M zV(;ZonvO2_%j`m-McS8J_BHAoM$%oqmVTKGZ`C;pOG zYl`zC*p$g0Yvo6JJOpc6>}~pOB=7XM_dgYam~v98)`Ra5^E`YGM6D*eR9TrZ)8Eq@ zKk}8(hBMU{TQg?#o$8ULi1^e|!e@H*43f}QP&F_vSbi?GA6GDA1VPbvF6~uU);D~t zG>uMYf}bq)D%~W-WtlQhzm`t|BK;*kfa>1&?PC=O!;qmb6fqan{>c*W(-Zt%DkfJm z_^33@{kZWkwr4Uj&DVlo9rHN ztQ%Kk$e~PE{D1yeAnmB?mPR?3$KgOi@r#=cr-goShokVn&Nqe>V{AWv>S$-2GWGpn z#TTOQpN+mRs6J5N_tbsXeQnkm(|butN<~-%>^02KP}%jXufZnc;-CIw?(|vDaOR}> z5Z_&pjbx^mzya0XOW& zrC58E;E9RpS(bOXJk|Jd()0NdRDyT2gedT9FL$CcSXJB6$G7;yBLwL1yACsaDabzz0}h##?6oMARZJE_#nzY85(4`E}PUhLg|13Ct%b z12v#*?yC$&d~;f>I#t9=+I}MXi>T1nGuse=nA6hZw#F)CUZzfP#_?`S!)H z)Bl6ud6PoT^?LNK5`@fLe(1@{tQUj=o~KvDFZ?Ilh}H?5>Lx%ApQ*aMGj*ifj_o(w z{L7`|u|a$!AoXYV`MkJzVC9ND+9={*4-yEzr)`p9$Q^&>+a)qS&ZM*;(Y5qu^cOI94 zE~_%fTk2%)=rZ|b3Drw|MCHtRlSh!najqmZ+n?*rdmgVJ?KO%9+kzJ~(zC7d7* z1oReZlLmp+Qnw4Dk{p|sAK$E(ocGOo$(#tRw2xkr(Z7E)W2Ao%aa7JjiW~2{CUXF^ zCJASv#Xd;)PRQd>y?Y<0EBw1;6dHTfWiPS!$jaOwDrFJ{8-* zxAHw)1LTgB&H|QA%^)ki-ut>eesepR>%(sZ^z{Vi5zuR3iEzY#NXp2W^5s~1&TNpH zAwy8>R{jbzO1?kQx1{iWvZr2WEFo6tLH;T)sRQUl#@PN6dUDb;@c9#FtW+J$tXdM9 z!}POT7_d1Q#*>&ph2z#Xc1 zXUf3D?S-O^bM=UiMMN+;#jiJI1zYVLP7E>Lpdi2m-k{07M6vtjC!@#eVn!Z;oiJ@q z0I@sR0eG75RCm0jtQo6Q3)MI%_-0>D&EgJn7_g}ep@J*zK>5nn53-00_q>=&oL?b- zr`B{h4afnBH!K`gxmin#4q?Ul<3Jz{L+8>JBnnWcWLkl>=lv2 zys>fOa)pwzz83RwgY~a7#IJ6kd~@LP#_>uP<85c+)x`7J)hHMiDy*-S?1+eJgY#NaX9-r%JV*Qt5NqhCh|g*WR6}*&DsJk zxMH1Z#k1$sHTrNECN+GM{Ef3IruD;$nFE|#p>KrwY+z@Dq_Jdr4P z!MdV(A^*l6aWw#scnw$^ZiPSNaU;Kpxjs5yn_a||#b%qW%^sj8FB;$kEObuD{c4Wn z9j~j)om{8Xw}kU6ES ziv_qcnU=sbdXg5?X;GkZbm^BBY>WAhj7OHHtd?7ZR%uJzIo1666sisX4Y!y1=oMV4~U=?JRjRhk*h&Su~iq zG7sn5fVSujINXnt#|}on9-X;f&b0sc1 z_v6v&ctTj;m9cFQ@^|?~25qRJhHQE%BZDeL!J26O<9&)>hKHRu2-3}2R3{!(C2Fi) z_}%eNV)s#(BW4yj=^F~{l>+aBxXc3o;rG|I@Dz4A`yY}aJ!OTLJh7hSr&#HzVZI!Y zWhFZ?Bz~c4z)^p-^4Rk?v$ZBXf>oiQ$!(2W zsz$E0pY~w>1235rMq&E_?_>Ocj|c^ODrt&0sM9F~+oA*v!Z%u*EB>``p|;x%P7IyOelT z_Qw>IPJ;(|(cML8g>FT2;8+s;=*YtZUz+&;J2lBoEiL+~bUD zwkyD+?b&Yc9;HGeNpz5t#18gbt!wq~;6GKGmWO%k6r4AuN z`>%YGvw>4c5RpDcW?aK7xXRtu!t3;1c^%m)NW#p1t;Sv#DwZuOcieLr|UXVfmP_cK~Rkbz{z zZ!j&GalxF|;`nCr)>@U<87Xi)FIiwxzqr|^UD>Dgm!B=+FiviGFP?%94ks6Gs9b={ zcq;==AjAz=arYA0oJBI2t&U8{Ux|C+P+{mambX08e~i3`2jfIX394mgM(0G<;MQ9=vYNn%#Y|1HSMi&qU<34gfy@xq?IGzczAhboVhcij@VzU6=b? z(BzXfM^!AJ{sl|4p~o^2i`h()^CsfJ=E)z=z8dX51_vlMP-fhys^P9rr6+jx=oMWv zKc}Mij)A^edz-~X;0+}!b7ISyj2v!a3m@s~X9H*jpPM#6U-CHDPi#9lTz|5trd|Ie z?t1#Stk0DOL{}5Ry>GBoxUJPl8hd#zcL~2T$G!>J)A06Lk3l;lTN2ZXD())cingHn zws!9pux})}W2%7J5uQE=nTrQekU+am%!Dw4fFxr}f(SI-7m+u&U+?cw|Ra|N*$inng>s7ee}YT=&&$PISae1h2TriQrpcO-WKHt@wq+}G%02BkFzQ}o_Y zIsQFetSn4@ulOkA8){UnyZv3Gt|OSti6!zlJ~Ny%kHezvuHPRUmeAe-tDFG!;WcTKd?vYEkk^$6$eJ01T2sG* z-umFb@w0_=!9XsFJkk>tfy9fYB_iusdX^~>C6j~iqxcatU%_&Z%;#W;EPMG=W_Cw6 zysn#mdG==qUyHo~!!Y+tgza!?fJl)11b`U+#lA%O$YsjqE4r^_Mn06;>aSQjbC+d& zhZd7nNDPkJQ8POOxzK2FbzRH($$|z&mjP~~QPkg-!=0i5^ZdQHePhSJ!PeFE47{ zm^)T`De#Zt=(gj_alu2c*lwMD6q)hQXA3H(f^?$v)M)YJrH=7M(!Y6vt>io>f+r>B zoxmrYVPQMV#5J1R2UiJ2;OkW;&aWEUQZv!{XVKpsT5WCv$;ySgwspo3X?TZDwNmFDsz7b) zj(|3-OM#@F)+y>+NSiI|AhT-=4E!E!WkE-nOpyVgLQ(~0ZVtn_rJ|4I>Hg@mo4~~D` z!p9s)`ax>YV#f}0bI0ZogN#oEE_|gQk`g^r+Ca-u1W9<%*I1U_t87>}PSPGu;m-XH z0g_|nb?1q7ESgCGqmHBr$EekTx*(Kra*Nd()hJvBR;DUfZ&u>L*61gBsxMdpMnj!S z?PU*;oD{}U=rA4711EZL7n6r=ok;`5rV<|@zwRw$H)9p7&fhC-_{EqqB08l^yr9Dt!TIn` zIb-LSCCV+OA-}x~CeTbtnGEuepm3aT?_m*^J;0k75g33>3~x$kF^T=CF9PqdtN@h9 z3=H_Up`p-6fkAE5#g|E^w2NBJR(ll%di4|4v^)8wQF}k|P)Uu`8wENv)O0g*^ANpj zmiF{>0;NUT+~esvl=wH;l2J!8(-o>IYUNb0W?l&3Ckw zZ_rzktR~Irzz>X51)1=Fu{qSprh~Z(jwxH)lf^eV_JxRUU<;IQ*2$7X3Vrg^)fQ_Oa0;9vkxDG`)Qy>4AXiv5lm&3M#c&hT*K_(=WJ`zLI zdR0tFociHJ92d5a5Wb<6Z4?!!P0_R~R)o>Ov_52#4LKE8G@)d6Q{>{IO8J1fvW;LA zE^~&Xtz?ii7!W7!PI;G)(DMr6(hg^4S4wzYpkiI5P2Czh9Iiv%x%p1rFzQ;xsI}Ss z)t9Sr<&-(_fBX_s7Ekprc&`EvMcx!p%ED&4>#bK9(2){MZ92p&bZOrs{Y$Tx1b1?= z$7JAQ+g8x0#W+_hBP-ecpE8z1nD5FGXx)lpqwIN*uS_-c#l14y;xo`MLL}76N%BdG z2?pRL+}^hbm~jK)%aH;4&i-tzWb@ld-i*I% z(A+X(AaRGLqMrPmW`t}4O}F+Col!}_Sdv621^Q57<*i!k<#(v!6ZKn`8Rl*+_8kV$ z8qGJ>b3$044w~w)%1J^QboDiip`b!^zEM=@&UouA%&gAo@IZ3X2;A(g+rfkgb~!a~ zF14QJXCPq|LZPyZj30{#QUnYBtsl90Co0+v3ddk2Lq9_K#5%c`sh}tNvk)B!ALCXI z7?&R1SHb$$K{eycZqT{(5=70pnP7)i$=lM5Ihg!EEJ;08O{Z`tNVCj3s{qiTj@UG6 zmP^A11uJ0Ma#zBud{Q*8;tShnDuyg_%sL6Ezy^r0887C0{MU@J)FD*o=H-=ZK`Ut| zTw1HhC}ge^0yR=xAzUd;z#BVjvh-86GM`pt)Z`jlZ_MO`ob?N~zGcL!nr`a}R6L;w zX8M1FW(uW*!BgSz$AP8j?kpB|+@~h*IN;44BvW8~v4ATZQ#>DNVQ;Z@LkHmL)YoT zPq(g3{mA88lvyIHdphbeRIix>n-CrM%H>YQ!xu}XbyVsKCh11Sp2)v>PL&x^k;C{R z%VQVN{$vb*RSA;F# z1p9#!zUWQ;>=V|dIc{uxhUdZ<*i^9s5!I)b}X#$ zcko1)Yt>kfqgtqdUFAp*S<^MqIh@^r$~O7q_7A1c{zAf8!F~l>!Yf8t0bwVCNmX;Z z6%fAb2yAWcznCWQ`RK=xv|Q{Rol&H)Cqh`8`&Z#C!737NT)Qq5$P3cWq6f^7Eb&>76lTR_@x(PdW}1@H?J>15b9s&T4C2GqdePixa= z|AxVajkPJHF_kAx8yLxN_yCe#ileSzMH)vRXqeUm0af;dKUa>%un}skv0Gp&Bjt#{ zVungp@10TFZ`;^tbD3uA#vBk6u;)<1&C+Vu(TK1_dl`_?{6tLLjxw(MSN2(j*bzFU z#Pn`w4vd08kiTk(nDtuxFzD_Oa@g*sY6W78te$&8bfELV`VOTtO$mYvdkKO!abdBj zLf3*{q|DsIdxt>K{;^DRI3T=mIyXaba^c=JkV$zf4A7KS)O^sVI`(Sc?)(`vh=>Bk zYSq_Qz5PoDk`yFA6i6;Fc4$IW)sJA3imN~uBFya{1Bs}e;*Tjl|59-YjoT8Yp)YTm z3nL%d5}i@(LmzOJ0ec#W-u{^DEn9bGk@;58T;94bw<0z3XuV^sG86JFrefD}DgI5e z|DCf?Wf@iMFcj4m#dyMBr;@ zr=un3jSc2X4(^)c_f{p0y-xNi>x}Xgs%S77cw}$D%nP4_EX|Q1SW*oCM z#Xo~vt7Y~uJ^n9!TSb+uh5rS)`u(^ z+r#^KG;XuV_g4C6?RXTuSw?1rALo_NIR6?dPWY&&|AU*3qF;uHhcKcX9qOO;MRtBh z@Xxr&+S`XIYT+x$L#9f8e%2bCh44w0C-T8geDw5R`wlWmkQ6!kTh!m=(El&E3D-vJ zP#d~y)*_rkywKD5ID!gcOlpU?t7r5oAFkYt8|AVm&j{}8pLHSo2=!tmuoLUV|M2^4 z931|Iz&nfoF$d@8XC3+_n_}=hc2Ax!j_GC4h$0s}iC;&D@ZmLlK!+W6l4tagt~?ER z<^A-+k2&^42T78?Gy8To0>(vjP2*#p{>;5(Vl#Yr`z<}!-i9A$c*B`{L${E|Lw@l9 zJ!sxcdMcJh&hTQQhw#CNNth4)3ETT%+I?3N76xN8!+Sh~FU*X-SBbB9Cm-&)_ENed zB7ks0wxN{^3xAho1;6e=KLA`ruYou3>!xq$o%C;rhpV@bES`;0RXhN=f{r!IR?nXU zzUj?HKP_k z`&#{4{{~e1QCSOG6gu{3XY{-Kvsooi#!=`HVfscb4bW%L`NZunQesH>+2B0qr_bMb z6@r9d@c14M_GE`Yjr&FMSYAy9BchkkMYRg>Ek-Gc82E-b4<2B0ovIBZwR2R#9weO) z%^Hx(6QgrY_a6R+j{fY7T)qIV2ZUd|9ka!oT!`Afo@>4MHUk)bZ*Ybs*y!n>_xlpO ztom$ExMmIphn|VzKDhFZm3U<2g1zwL<89Gy0`#_ew$Bo;Yi-2?Iha9oe+ACN6CT0s z`f$6RYyX71<0&;+q5mg|@Q*k&I&b4Ek_da{b0Rf47|%RBYxohoPeVMj=an39V_>eQ z@m9o>e^rHQLg$gsTo^`X`V&=+N2xkP*_n75QR<+^kcnp4 zuVRGW2qxIL1I)Ll%K1jumDHagd=T6#cLd?XOA$22&Wb$Z7`+UWff-jF@y^d)9-04N z)sc1C)y@~HBDNn{dwOs)yhYSNWB18R)oY#ac_TI!uwG#S@- zEv@Xoh=SH|rUZxabi{KZvYR*e&j3b6ymkCn`K$gZ#^0lVf>J5&`k|g{zxxQt2V1a2E_fQB zM(24BgTa0QLttwF8vL>7Q?%x3y}50gKige>uduU${K2``x|c1IZgv1iw;RX9d}c=#K*gNjerN?iqx0xAzb z-Cvaze#!;CdhXy~XR+{F#v5*U%3RJzH@=TW+41T2H={4mps8{N`2HqtjdJX4RKw5p z4E_o4@|XjTHC8=cRR%I_L`b0u^~u@r`+6hi--$$DT;lq4k2t^C*?totMc-KMtf9L-V@27gf^11H*s=4rrhe~Kw zVtnA%gW1RlKwd!IjO^jrjE_49yRbu26azhsRE_t$opXZ2m6z^u_3S||$!@SQ&R>oA zrMolEj?9{&TxiBOKW%LHUwdY1UOMO zn#}XmL=#t-HOa|zQ9~+hY9y0RqMc89B3+ka5ph)K9>Cu2FINrzd4|XN7vScnnS>`G zzB-bbS(Wi9>hw{>g{lv0&ja{Hr8mlN83fXhw+oeDOaBjN zKnq94GSVtoCI=`Qvj%^1JlQjPUg##=PrXWi&gKVT{95oUxKr-2p{RNi4d`5?9F4e! zqLJnE+~MC1z3863U4JdRKQ6_{98V4%QZLn?BlT;>q0s4soC=_VUD2Pw)MLzQJMWyu zbcq8Z!*4J)*F`yZXzd3~-2r(p2MN-nxBqtLIn-V}?BkP>F19+XIP5S|cnCR4$cgLpN{4Gotw*SnDsm|2%i_ z&@6ZOoSxS%M@GQ8lmbY)8qmqtpUe8t9(Fr-#HHX7xEt<-e4*^%&nhClGky(^SNNQ5 zMTFJdf$+KLd7}{r=+Fb=j9iyt-TMCCCpXOrUS!>R5&0ZRX`=(7SEXSh3_PZ9L+hyG zR!;b_>hNwPEp3wWmh7BeW$)r~C}rE-r9i2Ado&n>D>FQYEAde9bp7buAFDY3v)E;m zoY#1B6?4lGSIK6}fyrp8ZwWo{0%|W0y^s5Lb`q~pRlrX!qBR5+@Qvu7aGJMq*<1{6 z_?x;3HyiW8sJ~tRx8@JfV5!I5E-!jAMC#^WL#d~w(R~o2u+B@}{l!?Aunn#W?{(+C zp0N)&h93sz!!_2spTWh*RW7pj{u@4FAH8h=uz-d!2k{MZ@`w0_u|+?a50w_z;xjV% zqK~tZ=7Z7iV9hg8gXg%zNBft~?Ky;OELbj;+tI=SI=1x}bzjWxdHr(Q!R-J@oFP0~2csKtKN_cNn?i$u?-*Z(Z^C`Z74-K5^8rvK8Zs4ji@<+zC?S=xx*vp@q4<-0JHXPfU-eNxEUD_zCCN`5WU65 zC;Nk6%yx(OUa>R!UAQp%-XvFOj%!!ud<@%S?R$|%(Kq^V4ZZ=T*SL@;K77%x3g&1) zt3jMdKZXAWC4TNOJiM{!)pm^Y7r4&inq4?QM)?x`E3+_zyS|KLXu}cSKKukn= zgFEDhbaNF0WJx}TSJhvUy+4Y06>{xjU&R@09UY98;r8@$NwY#DId~6tQO7eE{3L9u z(dSW-%w|FFDE0{Mv>79V;eeNLF>!fLWwEc}7s21LaA+o^zhF;WOf&kv5(FzOAEtrf ztC(+$6gOtK?xtkIE&cAE>>)8ky8E}U9%E>33=Qv#jn3M8Gwv2^1o>~Ki(AIJ_*`5} zQ({-gUdDB*JSD^*q}kgjXr2?j4ELhbY!nd60fu6)(CMnYquX%mjeSi#|KU}bE9)0c z6DASKip046p!c^7zaRP$=RX+#DDj{3D6cel7}7XA2dt#bBJzhLpSm38YxwEG(OJ$7 zS=PHA#Us3trP<-5Kwr0TbXhRT$JV0$j+lq(j-JRhiSG!lWdtf{^y|1OYL2Tijxpha z`{%yq8VW$)-~xfkzvwX53Jich;*}7pJ_1DO7@(2=-SG->T5Il4<_}=x*4&5Kc7JYb zF5kuiAMToe6u;oZm*!h=Dr^3^%L7Mi3%*g{W<6l^0dWI9J;5g`OQ{ZYD`Ml=WDZ#w7;ZftObkCf*z>~kJ;y3}-(vhw$9|wf zx37YgR?hyNwQm-EpnRHJ@qul5^*4w*SnpZEzE)X#v+%WNWSO-OiAS&q{*%og#^h7j z@_=|m??+jXxR*tD`TM8kfj5MT#-A`U@d7DC102+I0!WyUoNti9JG>)@I^Ywy1R zDVTK)PD9$Y2Lae+WE6j%#o88|B#bw|pckf?L@ zjAU6qkD^P&#ytDr?FB*btE>;ZKul$L#0VboG6sOV&OlVEPL6*`*#rxFTfTUTayB8xM6UVOg$?Rw;)BWHoxgX9U&EjY}J)=}`~%H9FjgTN#t>JQ-v zkS|Fi=8NU4qW8#&`W*1?o1sT!_1wkYP*ycm1MKH?7kh)?(%$GV;rgNj^unVzQm+v4 zGGD_(dPdr;z0{LXeOj2mM!`8~$;3WIoQv`ki3VtZcxXN5jmh6U|7MmR+Y0hJA1)g7 zJkLEy&T{Ykrr@Qn$Wpwsnd}R?R-q;bi3?ylO?}U7n}hoxR-mhi$YZN+g?g@y(x1L0m(sj8p5vLBI`W|F&&wwG}G`P=Dk zFCkEU6r2HP&<`jt5J_*5-ud@o$kF>KAoV5onKD(t-1$Ox&lCxCPq}knqUZ3h8~={d zR0gB_Um6`1XSl;Jy2IaMcW{M|i1YBiy?6ohEV-yw*+HBHi^YvV&|Ozs!L9ml%&c?{ zStIY^i#vS8o%pg$KQs{Ya)Oy#45R2yyDIzOS82wHk zJz>{e!B4?gHsOd{#1!d$ejN`&wlhWQYv^qBiA5_W>s?QPHR27Iu}mRX_!wF>QcLhv zRBzBiFDm-mD{)3}ejO@&5Z9x;7KmmNjUBiS&5Lj{Di!9;dgQ~1d*j0e597ldZtKQ* z&*DSwQC!>VMstR{@KmsE&pswf(FBvJgmt*ldQYSR_7zwtPQgvR#AK0Zv6)g;I^g+@ z4xzt<2XBc^AnOTRAsQm%1$j6QI-y&mw?y=t;(Yqf&xf^DJ{R6t&FMaB!@2*-(8mmF zH?Z~toFDxP8m2JOAAa5yX)Utkz6AtsT9w7dh6UUNa(tBdggavxuek*y{!H#r_;25ZAFpT{szUvI%dn_aCvCun_OL0WeJ48-#Z{{)`Fs9>%r6 zRo`V8n&5rl8KmmBIKRXQAn2s`D>-M+$mQ0%e+&W1%$nhgX*;lY52t_>L@?!l+v6%R<$X zbKhsL(Ba40M;*j^_^OAmvk4iUq&uv}W>rO6N!j4NRNn zufq6(4sgM1J(p8*R?be!$F}j$PXJptBBvf@3wQ3p*t@xC$Rq-;ue%sMkMkN zco^l))Y8L=P@`3B7zd*+z}U?Yha{h|m11>#Va=dpUHt6{?Oa{A+Y{ z2Ax&uG#BU}t_)m_^Vjab z_3l5jB{l2gA3`*4KZ>c4B~+$xy#~>);qVcvY^)j_F6@cTp?(M5)xyDu9th;8TN3Hb z$N;LzOX->YXwNY#dMl7LdkQa@Z6@~A?LX;x(aP+S7{47vaUr{xaP>ugkVUt^NVvBX z_krtn`5ko7*#jv+;~9?s4oH$lCvQ=x{IkZ~PROfT{*# zKfnj*nAX0F=$(XjGkjt7lONJ(ZE`@ur^WIR+&(NDB~p8KKx6Y1zjc z(YPYz#Qp2hEh>`v2oXf&GpOLEO$C7Wn~BI`g>d>vAxZggs7)iORTKSZuu5WzH5q&f z$+bx7&Z}a7q=`mU_5ar&;Oc+hhq(H`0B?^%O#HA1tB^*P5%sg*(KD@wzv>LZ+hD{c zw-I9N%mmmoa@ZRAEm))Lt!FtM2D72HeD^Y`wH!g2k&S6BN0`>qdmY>=CR#f8e8SnR z&*36HE%EgR0+`-qy0>%XdJqX5_p}Jb2ok{8F#kceLF&1 zU?epdRPTA28qTs8H2Ndl36cP0$wZnYZG68A&(Dbd=sEg5 z7X1!EX}#qBo-LaioMFKhvLC_FH2(G$8j%e~&v^#8pAYW08CaZ^btwX@?`2e83Tm8l z!3=x@CP5cRL6UQj961L+x~yNIa)!sPcfJUIiJab@Ff)++_|Xx}e-)6`glr!OoVTpK z{{@V}xCtUYaP`ry4?5nAHL$sM(|{nPLPyA=p&!@&0hz9=GPc?A1KkeV#wvGi6mCk~ z_^-Gy7Z-B>CXM=DpbpYGb{o4Lr+?gLm-WsPOoe8$Fq;xFZ{CHYJFRzKfuru(KVbGo zb@*K`Gy~FQ*?WRUKm{4S0n7$6mC&o&{YXhaCtCX~$-x(*O98nYbcs(L(GvOuqyK6^ zak0y}B+D8h=c=&rSX$G+La4H;>(8;ns`ohQ6e%(zT>Y1m1L7z1 z$=~3PR9sF4*eJfP8ay<^o3Yb_-edGj*Zb+l^ocq4qE~zv5C6mE!Sf$bFs$5zLv8Oi zBR?0MQYvFaoW0xOgLgys*@TnOM1VBHzQ^$yscCcJG3VwQ)G_RD-}B-~#=z`-Juia! z58*jj2j9Y(vDn{h|nBzY7749(iHgCo%2j@frWHbXgHTPw^`Y*CRw0G#R6E^Qf)_blK`O<_A z-Na#rQcWq17pwxk>foxvcS1(=189{gC#vlmDCa5PteD0(afNu5(H}!btFvU|6gGGG zoY*`dm92AmpI8N_E4<6^K$B4C3!GT{S`l=_4-eu84DV)7glnlfPXukUO$3HlrbMZM zTF=Ni0#9g+hn~c$|4Ay42B)edvse#KRfn_=%LYa{eaB+5#8%_G4r#G^49gSYYYbyy zs+;tZkX1(&NlkQX@|EB&3f%?AbD}#TH%NHx#(Rq$gdK-pnR<tmk#tCn$t6Ikw8T3K1iCr zBRGLnFI1^<2Y||U`}%P|-Lj{;j(dW*hTI~(x8Z{@^;Y2{*ee%--)B6M8K)59JEGqQ z&&Aa4rsm}0W@K<8hUKR9Br#27mMd0B1jGQgcQd$MA5~n$K8*)pG2Ki{^grmptvHZk z7}fD86sNfP5OM!V#nAgXXtP`W%@u;pcu%2rM zqu5;#$FcK`3&m8fo_Dj>!Ws70Ik*22VS$V%ho5Cw*&aQ22y^}}?j_%qBtiMEBo?tp zl;ES>g(k*E94Pj4NMQ`Hj*%s9T#x*d{&~MbK0o;#|0#33Bwf-jA0_g{Rj_LX-4dO~ zvOsn2@RQvAl*_dGnrPrju0E|IGOCGv7)u7Evh507ZSDPU{2#p;$<83rvr)JQdcTf0 zsE+#0vTRr)h&*3{F_L%UEu6~Ah!(&}3*HkA!IsrgPwWV3UJw16_r9c80a`A;#0;fg{!)Bg=puaue2}t7rG93yCe~ zLBb6{C56(Z-HaamW;t%qdnGQx1})LIpdJd6?e9Q7A(twVl{`@I-kcrY`xf>|yqug9 z+YxOa%z&Lv%vm?Q*j_MD>|B)LMhR3ss4DCB^H5hATZ%bDkHxfmM&{rEd_-Vlk<2ed z=DK3n;iJs7=g^!F+Fw2wt`gQ7Y3MWOAjXNr26WJcf)L#gI`B5uB4MH;`{&sh4a@ta zqz43OYmh~{cy4v%{2t`k;`#lV7gHjXyT9-fO2Bkme-<5#&Osl_zq$thJf||_Jrw;{ zW}s*AD>!z!KGs!)e2so=^|ym%`CEUse=vr}ycphR{n?WkO$KBnJrF5)c%BP+ zTDYk5*W|ak#Qm`w&kuf-8Ny2_r{rHLsD{;&F!d992-HH#GydUz5)ra?XotZ=dJ%92 zCB+kdK62_U&@0da)hrr${=U$K?0jbA zI|qX2HJA5Xs!9G8;lq5Q~s4-EY^3&{A(6*eL&upLp&FIvye8 zV2{V@M#b;KYfsxf(HgrH(>bO z*neYwOg|#bF()0lc<5;9`R4==$7tgX_B)lSQf1iy(v--5W!<_I$yPfuy05WXLa)0^ z2d%vaaZ5rV@UZpb;QMk9xFdyqIA&onJ!rUx=mbL9KLTY)=EYnNpf6(XQ7Dl;Bj=*k zB@K6i?5y${X8O0-bf94NIhrmxdTVN8Bck` zhcP~o>F|{_KD=QUBrkR;L`Ss8;P@LlgpF<41tS=Sb!!Fs^er7-MA7F1IDq(+658ty zf5633BItMAj#vn`JADB88T57^CTwlJIBsTre+Tx??FC%Og1CRgsT9O51VJFz5V%8# zbMCpcjF8q7Suu*O`m(K`|8KBs58RnOhv!(gR%Hx-MEc**&(dPy&NsKUV$izP!)j_F zzg>~K6-PnTbFIkYMY2!#vFx?`!}}?uN=+VJ8BfPZq6m8jllSHh(Y!yGg+U^JatF9O z=1Eg?^kwNJT^ztuQyyuAG>jPci2Ac5aWzKh|^f> zagIk9ODzR9X8?OMVgr&6(dpy>5=U6Ig_;Eqy76QjwQkKKYQ(nF)?Vsu+kMPVT%m6V zR^etAUxqS7+~E!D*1dSSbTaxK?y&Y=NHb%Osn`b@>dN@C1y^E|>H8v$7E0b`Ko% zRW2B_Ky765el)fcH>M%w(2%aAA$?ODQZ;*XSOXnsQ?n;V>OHN`@DPpio$&9X+u;g^ z4ZJhB0PB&Bja4v(_YNIGQXTT?TvxikYzbaKC5fvrFj|Dz&KZ}xGM84t$ZD!yXT`8+~YyIYbA_<%-90l z&0V@3jE>WUweRmR*Vs&u6xlMI24F(4O%dP1$?O>m#NNvsfWqlKVj32lfoE4WuA3WO z`xJE8cV^&ips*Ai%}p=cxo+<5**z~`9=sZnq5I!uoICezrh{#~j2S;PSL%vz<1W%7 z*#&+$h zv=Dw`%kYaJZ}ihT{( zBJKB|@Txr-2e2$jrplE$i06TB^zs8MHuP%jSGY~tn>%M%dmqOQT<3)>J%558Ox1C* zhuAHjiBW@VF)AX5|HIeV)x_5N=gxod!?-gN=D@)E?x8z`M;P*eJGjY)US!yUx2*ii zx!qVvJwujQ3r-6kCKO!@Qyxm}UQ9fU-O-OlZ8$)0?`|A<7_`r~_6GUKK7eTv{5yALn6@ZQkhupfx2Aj#)Oc0sqe&-ED;*dzMeg-3ycNC2Z*G?g?BJ76CktPa1f z-akBqpyFkhSN38ht_BhJyscP2kCs{%=MxAltU<_=y3}E@9sa3 zx(wu0<|45OHYl=ev9}Fs5h`<`*nsucAnElW)Z5JPKGf$9x@V)#yA7QzUmH4%4||a> z%!(yl)~Czft#Tgi{56t(Ar+C4g}YWce{cO9`Cp)|LZ8N_R`g_Iu9#Qf5|C;iTs^Qz z|0qUC4gJrx-u)83(zQL*2LuJasHxy`@Y^Vn=z7~5sYa|m${S|pLI7eL6jZlWIS*0^ zCL||#a}@cOd%YPic#wUgt9&Ev0;!-#@7(TqGCJ>k;Gw_rUF1E@p`8mY`0VL9f)caP z`BlzWLPrHh*aoEv!#3?4PWZu8Q2hwJX5Id`{THK_9Ge1JU9*SW;lCAgj$MFhVlrK? z?y6ukf{MJJ;Y=4}lf!6@#OiNQ%prb8<_T9TfwJzmm30?!{jvrXbfnEIYu_Nk`3C9# zJUcA(6?~pazeKzd51lrXW#iIy-pH+)$Q=+WP#G1XU&AI0AOE=+*8>VB_H%p~MVZFo zE08`}`EHCl_eedYfOyI={Ev^b=k46;@Y8r@q4{XYqky7OwDLxE_(JRF%84^AVV9O+ zI}%FRWi<%6By_YYd=8r@(y+HNzt!v+cmH*n zR45J;HoTh^Y@y-3D8)bwzimG%IzWf$K=^d|yB_E3osTop8w9(GaYb+I^@Jkpo!`J* zu&`#*&|}}h7sj;I-Juj$q%14^TV%*0!3+EEAe-D1c+z?IA4*XL0?qIWG*_jpz`MVP z0kc;~F+B_K3cDR$Ve@y8w3+Q~L^CQxXHawsXA!8_vhg;w-|nb#&kyp z>tuladjbw^mUP& zubTY`R0+%QPl*noYEX$hkk0w3sEHt^Gj5!$JL1gX7>tLL2$xUg>B z&fTHQfe@5CZ%6lFYWTG$^fY@H-f#w{?xGvfaig~?CgA-%G5;BpC{tI1Fd`acYP2k;~A_vSj!rBJo!(z#P&lp zZl*#Wjard^O1%S6T?6*$8ay@&E%81(zbcZsY4{>e_x-%S3|TQnRq%lxbv%jQ0eF5@ z;~-A!-gp>pr{GKO{yE|OOlnu+K0`6r&KgLD5+HQdN;|@O-{T2*rFyP4C zDxfvflflc3P%ql^Nk|QvJEoM|p`z zt#!|DVL8cO5Eh~;VDsz)1cx#@Zv=KS7-<%?buSkGkD?#JV0KwPic_``hha|;e1+%l z+tJ>isWL(zxB}YH#b*@ZSzs$q}ESV?aG`_sHLV{!~M;h z8SK&NSI7fy+m9gc0jZ;?`^M&Z z7)c%5AB%P&S&uYvn6^*jJP#7}6xRdLj#0*!Ae;jbG5j02h&> zLWP=;_r3GGaRmBIHH_Eh@VRoW^Ak|V*&M!z&6f^n^tY*Q{wQSIWLuMBsi zo}W)c43Ea78=e@~rth;RC6Op{?eu(L_+Ky-*QShZApg-}bVzVR36r}smXYrB7|6C6 z$oV+-I3w2ZaS$+;He(RP`QR^(eh(0DloA7Ts?e+;a>2ekkO>4%#Ig|&daad@M=S9N z#x=_Lf(1@`F;?6`UyojfH12zFF}8g4((8R14;m5Nq=G%}(I`PY4o`+YjvILTFJbMJ zX;l$#X#)=;_VU5u>j>}kGq}}`8Q?K!+z-a$318B6H3ljMOnj|67a7K_h@5^EY6^JF zUgAIJ;a#E52CS2)y7(2B%P{&VUy_fJvh9ytr=J_8V##X}Oxp<~G<8}EU_Dnp5 zm{}2j(81wvi*<=x4F8+PFFb^OtZiU>2fKB2DTV>2dJUf@Mhj$*z*PH(Zh>s88>us| zLrl*9IPJ7L1dWPeoYf$zHrMD?hyM$0W;Vye*TwO(kmDykJV<&Ty{hv*etm<0uYZ@m z%il@5Hn z4Y)Q2MvS}Cd(3Cgk@t5z`M@l&@#wd9y@ys?l%>13>#xuzFKGM(_W1dD5TE;JSv`1q zIP)sp!(u&8<*oD~_Tc}%r*j`{24`S@n{Qe8S#V_aPaanfOz;C%bIL#ZJ)?u3%od`0 zE;~-Y(LdVYHOXJ;CO+_0hN_5V2B^i>XXzQ*A`0oUKl zzh{4492aop8~nTSEe;O|xaHgY`@nZNjDA;~_g@@(zQE|47dyvEELmXy5%wf$V z9JUN_*geSMz1uk~+ri=bUy9?8a=2|Lhlh4?XxYP|vX{fM$2eT|D-OGV&Eb~EIlTV~ z4iD|)aL$t)+J`u-`3;BbpW<-y(;VLaTMiE$;86J;hxN~JxcT=SZhDr(`=8_R!1Ln! zAr7~_z~P}6IUM-|hdD2C==l?eEiZGpDazrN7>D;B=J4n+howh2tobvC-LGI+@m;{(R{lLY zheONzIn2J8L;G9~m3bVNUBY3@-*C7oo5S^&a@g?!4!8U*hubdW@X!Z2%(|RIyTW1p z6&&V#n8T=mbLR8!rB`t{BH*FFsk(TKF*=%@5T2r0bLx{ zlylf!!QuUG4x^PEDoZ%5_i(tmio=2HI6SbF!=qjf=PcvUzMMl(4Tmk)bGT^*hg)hn ztgqv+<_7WmN)GS6k;C2f93H)i!{{eCwA{>L**}Wk1ypX~-#x21?C^28rGdkNMh=fQ zahToAVcBX94@lU;zuy<&aNDgMuD^}L`&&6Yu!h5|b`C8a9NIt0VM`~6o4YvN7UXbW zNPJ(*;eG2k+`XQ|`!{g7`BNNj`!t8q&v2N%kweez9JX|GxcLqa@BbW!`+7J$+RNdb zJ2}kxJcl)#IP3^>xcQ$s+}6+Gp}RQDx|>7$Jsj3-=CJHvIBfX>hnv61;kGYv82vJb z_kD%Kd;gWg&09F^{x=Rw|D8koe{k6GpB&!*|2W+CRSu(H<1qW{9F~5A!}@P>xcOTg z-urCXxawydZr;Y>zyll}`ZF^0S@m!$l-zCak%>#4iEjFL(6j<<~+|~{UHuFzrf+{7dagH z1BW>;aajK+4!d9G@V+RAH8Bob4s*C^n8SNt;c)j64x@kOFzYCXIj?b8_Bw~F-r#Wk z|8aQlUpO3ilf(Po630gbJSKjBo5Sck9A>}AVd-BvTs6w!CW~FjTMiG+;4mwb!_rwC z)}O=S`g1wFH;cpFvpI~ukHf6a<@26c8vabhd54dD*f?Q z;yB_&hT}EjIC+}%=a-4&lpd--ZWqV1lN`UybX*bVD>y!f#xMTl@%c%P=Oj69GaVPV zv)J(gaq@2YT|!5asa{S{-j{kj<<7G*XyOJC)Pjb8>$#Hj*+dCTBc51Un`Al?zn$$3p{`(?zpG1G)83@bOWsF4&)@3zb@_q37T?+crX=1) zg|Cfc_BOxL80ze#7qTu8Y*BmwZB6a#lwgZ5sI>UH@CGCvG>l+;;t7HP#QnO~`8t$_ zP;)chh0@-f{@vt#{6U4?D*$rp1ZlCswTFVZqa3b4RpLR3`+PFw@7$n(ApLEOHfV}z z+y!Yv>ZNVIH9!?dTZ13(PVuklz`O1Wb_Uv3%XOfg&yOpee*EsI8GtAnI@@paw^`Je zoL5n;=)ZY&-xSO0)+PR66%eo*DB#~}<-;o5f|yuGJMfe05pqqW7z`h|IwY0uQeU#H zT|Ke6J%lw8Xp>Z8e5OE5it}}}&Yww_tnlO2bp^2w#mMAc+3L0_tHBlwhs1N@uG8H; z>7@+O9JK+<67Map73H@y`5Qv3Zvm}zgo5&zVUf#&+DfD&mGyPE7>_LVthhz2m0Oxy zLtQQGTW5PK-e?6DXD1uEkzRE#H*JdLh&cL<_eRUU`QB(Z{_VrRIp2D3v=slk@$Ufs z5`Wvzj> z05}9upkON1fvzsB1*JLE*2tJYh{DHj*p6u)?e6XtugTKU>I;IyuCe$m4VLwm4VDI9 z<879%pszD%Sse;A`7N#f=3o~VYipCg)6yAO-J*SCKLrE0fFEZcn>s=rmZlDN1Q0B& z4S-H%x5C0%jdjGYkYDK6_3Y;j{D<`%Y_QmLvjhbgnC!2xdGGJ>?-l%e7yll@Kb7x> zI=jG;3_O|Uyu!B*2Seb*YuY(#h_Qmng*rOgJBiLAxq>a=5nUTV_G{>xrib4f{Q>^H zi+^+R&xU{UIk)*YK+vg!i`AX*eD2T>f6c!9 zCicO>zsvvI3fwDhaJws4*x0*SF68y5K-Huh@QFY*=fPdJuulXSG`Mkcko$WEg_ z`JBd5{+xV!L8*KOL0f4J*}Dhljp2%;v$2+Z_kFD^=mr)s|5z$U?7(q)mvLsib^D>U#zaPuUbUcCam zlyP2_`IQ(6p@0}&VPZySo*%eev3`P*4lqAu2{il;UsEE!l9ExV;~GC(S1)lIr;?Os zo9AJ7B<9yN5Af=xoL7t2WfpAN;Fz zpfB@)$195sgeFAr7*bY~M-Z9GDakyKe0#o0pWysN%;PlIDbnY;X8e@e&y4qMFHF47 z@SexkiN>?eH2NEtK4f z(bE}$r-@LMHy5y!XlON&bq>F2b{G#`Y~3>lA@HLfkLsOyyQDbjZ1`K#R_9A08l z(%z^&GaMKb5kU$4b9SRyrt%NM(-bK-MiMw-{y7ar1>>~!68SHIAA>^8=m`9E3h|TD z#ytUYXhMjRa!B&o{3QOu+Qo46B+~g3QAIi?V^WKqk-5s>9MWD)A}87Smw-~*V!;Cy7r^Yz#k^uDMbYop4F~pBE8rAnL@#x4mzHpWQCmEkGK^7p~ zk=jG!U~aQG2aR^Xoyu|N+Y|fUli_t5m`(}hR$-!bl7jxGE1rt;6Wf_%(9=m@ z2lj%*{vR5*P9aU=?@M1Z6|U}yF5@`f zV*UFQ{$$SWMAMx*gU~#_0(*gUFf$8AzQ^R_OOq)~U^>hhhAB@(u*&)Q>~@w&P>`Qs zey}6i{B&ky5*nR)1u7-=X#P82fxVGlNWQ@viM%lva#Y)u3d-`XMgkdU11@pp z*;xe6@Y*TGj?y;AoqA`aZJt*mITO#UQ(e5{&oYrW5c!7c9YjJN)`iBI@})&CNtd@(=VA^dryIwdA@y;w%Z)-|-`&6M>r4 z%U`wciskw$GzJ)Ku4YL6)yUYMmgJ-2r=ZXQ5d`mGvE9HSHT)OIE99m(84s+}YGlE28rm&$#prS-L~o}Ol)iXZ83aTF98^(f#ch>jJ_ ze&sq*yGocUCRbjGAR%)uC8vEOyD%jVI;2CWK&`+mO85>X9ZS6!z6_%rrtyIy1OC<~ zrSPnH5#mLCuafTbeI*75zpdQu0=5d3#Z)n_ujV?Tc6~z8VxpDFNR%1_xm;JJ_EH|lFhn!X;-wg^WVr2YUQdD54QQ?x9~3j_K4(q{ zI<-4SwKG(FIV5Fq?Agkv8NQf0l*~(`*&C4ZJa5Lq^FLHSO?hW~`)x|Kud{1fdL$(E z6c;yhPHm9(#Fsil@JD#j>#wb;4xR5NkEN5OPbbTcNfnjQ=%=aF!TW+4x;_zpZdkn7 z?^`oz1mqK_dBCn0=_@mw?lSm^H9^`}`g3&R})Ylq+f9Y-Ru&Ejte%*K++hjO3oYk>a4&hKfl>f zXk@F{(9qtwT3NZUKv@x5(|{J}`oirA2Srlwa+9-m!Q^8hd6I`4!s{wGPe=Ztofr2A z2={=b5u4lJ49%O72ols+_!{xCzC=eAXNFgM46|3&6H1yy-bSe*eZvksQ31pTV5ct7 z$^vW)xTr?HLB5TB-oO+1^VH*|HujkvcMwWNqODkH=@eL!6wuOsa`IZlPt7@W6%S7HC>IrkW!H73w8I?J=wbwcIYX zZ%m)h)X*gS@%gMwLoNfnU%~^GA*>8QVP;LE^#St9p~c8GI5I?riPIS289!!Z6@uLq z;n5JKDS&Fd2G6lb5#o{bBI{V}PD6N}c_SM`d~97CF#vb+u>?lVy8x>Px3S-RoZ~sWqsxK zXPg$7+!-(BmaKmQcQ)EVgb!uKVqR&;8(u5$B^Do793@I0O_>cfc6!Dbimb$glv7Y+ z4UE^e7#e$6x?Ge0CAON&IlkU8&j@!~uLI3`bHr=lK^Y%>y_ zf7;$;XZ60N=J*)P=cLVrD%#hq!Co{lK!Lhq(lRHHtcgg!le-`#9jW*-n(2010(=#n zQHV-QO;Ghr6<_9j85Li(6u48?ptplkc)Ss&TJ>>lzXU5+Pf)x0jp6KyqYH!dhkZ7_ zc{NLhb&(hQ$9rHZn`gAO=TH>jzTDC-~t*fe7s;oTjTw(%q9OGS*zow+L z*jel^v6mE;6smKU%0JoL?0qsHh*DQsO9VT)Af0@XX3rHj1mq-TZy3$9Wg=KO!o|)8 zsU6sIPBM=T?beNY8oBDt3Rz7B&2uVUE~(6%6T;|IxT1&*RQ{#rj~K87I$(HOSygT* zXEC@E($8B@p+gu0w&|nD6t6|i4YLOf;aZcoE@efOq$3&s$uG_~Xb=oPjZ+o!5sSp= z&4n>b2*VWk+R^r`Q&)}VlT46xo_e7$D$wXau9w1Mhk?Vhd7467`d(m0&pYiaC)&(5 zIEwI*y#)B@3-B2m0X2w{1v!DqIjqI(*}i>(IgH5x<$G1_`zDipPu+6REJrC&>TXz3 zzWjJgY|YzD?^?yni6}@&Zk*}(1G=noO;DzJ3R%JE0+ByvnZdoE08fcl`vfMaUNT;l zg;BPA&%Q>{H>^n>;S*rvuMJGwes&Tsg)%Ouf3MRRFU|N9s4xIdFI3{DOMy3NMyI=H zJ+%W&t{%01A`w5RCH$~r$xxe4$4bB((oBhvO62L|O_um_Ht;^x#;%2=UsYVathi7K zwlmM^+5&72D|PJ>2uqf5N*k}L;*`=*J~jYAyszAaziC zwbGPz$8w&AWD%^O_<3rc;nQ)RNb}%&pp&%&Q+b4KiN7rniqDWbv$=w%KT5n5IE;zb z0xw9^U*C-EJEgqUhh4y#@jQ*Vr-mmrU&v^dVx2JhQSr0{y%w4RzAgnCv*ZhBN+oP6 zNhA4YQKRU$S70o-(&1?_(UT5OE2kP!hI|rJ78(r9B*vNM!jM@-Niz2}<1Il#2{U9; zAWGs1*x~w0gOQ+YOO{kR?M?-W!|j1qnWJ}Fx;T*X6a#)#&Zj!!#V*8Kzv9Vsj8 z^Gz!6^u|-+Sv<9O8hZuQebJCc-WI$;Z*Ny3G)W2^T zCoD8{7h-q{c7;%?QXRN0q#yy*#6(PQ`vlm{Cl_s!t{{xKAKKwJ$|Vn$M^N#s%v(~N zqFMJuQov~?smoyefkj3JNyUhq59(0)LN67KAH`y^c>+Po60d9uu-xd1U`wdAC8TXj z0x2@F_BYA&65fYTov2h&)zo)$f_SkEyro6&#RXjNLj1%SH}PEO&a02p)YFe8C7Yg6 zX+Ig;95Y%dOz17q_`l=_a`zRSHnb;DrO$ZfN@ssaK8yID;g7Ey!jo%SV#rKKPJ>mW z(oy?ux1qUFU3;jr4c1v(P;u9@NH`ETd9;mT(y?fb=4CV`O2IKX-du=8_KALb&yrGm zfz7jgMHRe=DB^Q7J3(n;svR!Zfzwb0Bj0nK ztKvkcU6LUhIcgdrRo=kFQ70u~i8|u-Ril?s;HhIOs9sV)Ix*gpEOZj!r#MbO!}_6o zq7$U2N=h)2(kX~1Q=pjf85K{*UvEu}r<1?r%<{+BRZm-Qpr^$(EIs%5sIsXNSWiBd z;`x$4*}9{|`{SN>pO~7C)2dT5p~p0;b^Hn57~y$z7%CNPo)xZ|d<8pb)YM*GTg!4% zP@fNuE>ly`yNOg9Lo|aI*XwlvrpM?%*id9=d?1siYQ2l1@&LPOot#xwMmHY-oyKiX;CG2{?;;w zRebl{<0V-9j_%4|$IZ<%kL-)JOITUAZv66R_!q=Tg&4=@sfvFWBM3NQ{AuBqv! zAaE5yi3mYWnbh@yNfrgr^cT6W6|iD(VcM!X{HuLR&5}H)JwHBOZnF3>a(@$k#!+1_ z5Foj~89xGjhU%M1;-?@veo9Nw+poMegdIrQgDq-;_5w!48x~PkY@Ya>2b0*GPInsN zQh0X8L1A*;!5-!DH=ogwWxK8-&wWEZdU95JD=U^)E7jG@Rm@3sPqJBunyEW6UBkE< zIg?h`k|+sE$(LpJlcYDZ&kOZMQr*xvvr2IJcD431Y3GOZQvJ<{)3ha&>R6R^Z zj$Ni}PYgK*nRWci;1Z}|oQ#r+EK*lheOsj?QzARz<%WV{M?tlc!y7} z9y)g@Io@2}&2K$*^BZ?(KciN_1(l|+8P*Q?c%0fI7$!3+Q)JU>bRIVkVR)Rj^N6EE z`94-m!TU(Yin(=)9+g|jW~52e)5yzr@ga@F{PSLe`BC4(B3wAG$mVQr>b4v zrlTi`FKp|u8lA`pTL!Ink`{u9)o?jw%1|4J^jEcNegk16sQQB@{q=@7+jOR*)fa3w z*FePKr8pU0SmS6{BV|QTo`6m|BQmzsPR_04@Kc%$KZ}bTcD=`DdZ>(X_;Du1Psv&Q zz{v0=!;i|I$0nkQM1)KlqDkS2cS4LaY0dop?MdfH?6lg~CU&V1iFs4WSUL05aYCAM zN;jr?)`FRu+~m?WNEkej^Dijn@v`D#qodMR4P&yx7yOh`v9NC8iiO^Vn&kvtZfZ+O zPMG-B%a-vGiWyHucBA7`!xL+G2l7yARxCd;wFJ_VJ_%-2Qo$3CFR>w<)K^rxGUID{ z=4zSoRa$6FL^07~m742>jdW(h+w`Qhgm`ll7~{o>@s_`U zZ2HOT&&doh?kGEM3{Aw9As|!6CX)CT6XVUe0a225%J6m^(+0U6mKblz`#x%(beVCJ z#QUgOWg6a$&iAB(fRKhiGk-(-OG7|Q!&`Nr5fuT`Tib}o7fL6Rtk1g2eCB7<8topx z<;fK^RYe_#xo=ic6H(H5ZP`S0gniUg;st5Vfz>TRwlYo>Ued^CmZ+R`WrcZtl@`V8 zr;Vh>i>ez9D`?BCu+5N86nfG~W0vUAwcphkP&#B2$A1dU`!7P?rNGZ|7JH}Ox^g7I z4>JR67gwz`r4$n3OwJHarVg0gi{l8RnKQ>k>R}3rpE7J5M>pU%B4W%98C$i>UE!+x zgi^bBrD1JxO_PUV(Zcd{TU_In?vn51`}qEz*oN55kFkicgV^ySl9TQ=NJT*sKTeUC z?`vu>G&F?XvtESkR|YzRw7H?SFHIcLq`mDyB0sgtRHs^ek5Ou2&;!-_5eM&Qs>bK5 zeH)rveO)bbF|lzYu7Motc+?A_W~rBGhL2Fl(rR+9)8Ey37o;(7eLjI9tdMr9qYxDQ zb?eO+M(EsnG15XB*b?TGX`@b^YBmAfNqUia7bS*j1jNZzda3rU4m2vuv>LoKI*CBy zMbcAKelmK}<7IN$1Ie_E6DB~C>8|6*BWMzNkPf@gSZ|k{eokNad@?+xa56}GQtSBS z0nOhm}v9L1hGRG!pREyx~xWLyjGNZp+KV67eo&RrLnyYyGXaT`a5-c%LI6~ z#-dEo9l=Vp-^H9I$2PTHU=)%lfFq|V<*6Tz0x3%gYW(HKKtQR0WbFc%NuXjtfj0(o z_$C{~SJ^fjTC;H4l7sEN;jqaSm6#u^bD3&ILrcC%QU#{@Pb7aqalzEVRcNn7>u zB`&4DrYO&))U+mOL_hJ=M&YYgb$8Akgz|;T8)7*s>)?uhN=;tqy7C5Q4?v>KSv8Gs z%*v-YJT;s!JeiZ>Pb)k*lF}0z8%-@eo!)p#N>69;MEZ-rxq)@!@HaIZI&#>m+uQu8 z<4)`}Iq`M^0*b`9QZg#3^Cb?lp{kV0Kinc&ddfKL1gQrW7nhp!otnJT(&A#JHq-&d zmnB1@Pb|qk1F|ORVKVY4qa~ik=4_Ien`=Wf6eTbb#^Zic^_pUAEl2c)su@G4F55C! z#qwp!l8QY1oM6Aov~@nIBAdC?N!R{Tc`Y^l*_rQPaoWO$LPLio8}&oU&+BOK3`#{= z)uW^-k-mzc)gvcN_D$r6Dl+Ny%PQ-uyf@S4nzm(uwxGYQsU1BO$wLunyNzx5#o0RV$&%2>H{mZ4LdFnY z<9e-f{A%5+so|wI{@QhcAj)5;{iD$xaeP9FC+wXkkW6Ejr>b%Z{UiB$E)eUR2`Tt- zmbG``eXnU(mKCyn(x(JV=Du4-Byo|YE^KbMr6dyB=q0g+ql@Be3qv*XAuYf!QcERG zE}@SdvsWF3vXGY}%C>A}mAlHNBPnIA-LcTl1F+0}g9mXtpY0+$4hF9A`((o0khW$F zT8}6D%7`|T0V}11K`&I9EZa}dIre^fh1e>WVaQ?Z&}&-@9A0PyZI6JjpG%2}AKBW513rv3VWwkdd>#*Zjlit^xR58d` zJATL}6s4;3Q>9=-WfXA01*N(c3@Cvz94ALLI-8_kp=Uw#R5PyC?ZBhSX>%nfi8%aB#t{awVuGP{Q0o?%$yIOO=1gCCE@WqJvs##+6D zW=?4QNOcVr(<=vyKp+?`W#TBqq`ycyD{d+>#%Gq-)Fdc_otz&z85=UPZuWN(dvZN$c9)UBY|F7h;cC7AT^D$nq+8a+jf5R4X35c_k_2}@rWA4p{v>6ZdV{ee z?MZnSk(9(!L9xh-FfK!^!y9gLF-Nve#HpyFZPEEouVly5(gE>Oke%@wd?u5HVmBK1 z5;UW7Ujq%9kdwBL!<2?V%ZZJ|Aj??y0=6Y=@@1yt1yYRJ>&?Y>qd%yoknyIbq}69w z#N%SC8W$GJ%$#dtl<$%N^wtHNqofFvL6qDj&p3*F|FW+iv>XEk*lOH0%1VD{SEx(d z)kPGe9Z#mBn@ybDGEUc+NHfNC)%PmnwsQVL?X}x#0$>biWwIU>@@rVE$z;i-`BIHi z_=NeZGy$Vi7t*kg3&p~%k@)P(<-|{yygLnnTyx5H?geiQN zdcG&;Sy19I#1oKk^*NJ^`<6-(H#-%rjQ&YO6YfVou z^*g9(U+3>ctc`Xqoex(bv!#ugIL?fj3DaC(KR|?t{4W{4vyLl~2p~Kgzd^@&7UKbB41Y6+gxJBaTyC5+}#TM?c(*5Uv%y zbwR!tmKJNaE)29|^kGgQCBjslka}Ybod`=3gO%$_^~)8=BPw4uxgPjh0kb(3m+|lKV(|qol}4Nn_#Z z%;86=CBDRyD(B60A7iXHJ)Xw3-jdOifisz;8>h9D3(pu#!OAr|liBygZZ|I7Qm;G} zPt81D;3zcvN6yv)=}J~O$^2)*>%Oe z38d9nMkyAKqzj3s#=xk5ui9vv^8?Cx5Xy-d9_6YOcFAfv!deqHH44 z8OMl{=+={5fpYydi~bso4d!@xZH<~90S?7Nh3eLX<7LN2V`CilgsSke4GU8kPjdWl zXNeg&q=;b)!*;!|t=uP@VW3k;E#*Qf z9Aew4G&A$O9mV6CH+DIUpEsVCW)grsLAt!LI>Zk!C~4b&@}Gr3s<-n(+gq= zkj3U)gz+*M`GU-;Y9>$5I5>}Bzw(`$`UoUVvy$&irO$kk2g-?+y{`tJvb>=y&=f!y zY|%zedw(#as@t1bT8~K)A?ulp_*>!o6zUc|8=5*<>W{&>IwkU45XLwP&W$F8s4tfbP6oFU zyDY|12UIzs;=#O+E5}2PuPxZ(@AOUY=Fd8PS;d!`U&rHX`Zj$|gfFpAw&Ybdj;|HI zz^x%Lq=o=bRWK~K^z|*Hd^WnEk7H7YmUO8qF1m+f9aYvmi8(oWO)wme!p z8y4lk`ZBj!op46G5dNB;Z%_?%5-?7W<_Bas4*NDSK_}N4qN&X8HBu4$sVgd7UTFwn zCyj;2vFW^F_9n#$nq^8PfS<76rT91L+evLg^ZbhqyTj4^{b)%hv~1+OE@)Jm^6mH1KIL&Sqn{f%IwJIC-}mcBlp&tW>de{D&*)Ma{Q$fRpO}FwV8@tsz#< z8Q&V`#Cz6Hw(%T?ul(`iOUci1T%Dh*zS|R8E^)Hars}zp&QMJ|PC8SLy8@F~i#xd} zQ|V0R3HnWW1S{GRcCYZYHElRsMya!-WS;_bt1xg}+gW_AS%fWvMH!{G9tC~nH=o5< zsss_a9t)dA{N1cqb%xqL()N)i*?@dXB%^5KCG$Z9M@r1D#!Q=8-s%&tNaM>K?- z)3q;rq8``bYnE|SrcKyteW;NK$J)@)-nn}6LeQ))v+ts{mC@ZkrG{662u^ClOVW+R zOMU@5#pwQwcu`g^bns?6XIfsf8t_VuE|o9I{4?~|G4gRiN33D63)^J0uU3SD&x|jv z9oi&Qc2W@3RMt0X1ZC{Q!t4u2LRT1>7b>14T_Gx%5KlF55YcKA$eFN3$9+3GgUu9$ z5EiR?LXnzqmv|E9bzyIm8Iyc*$aPVJ0xr9rKNCqbHRw0YAKJy-^4m^gewN=~NTbamLbE8N_BhA)Pj% zUV}CfVCZp->GY!{Ej}?`RVJaF&bKGl|4^=tkk(l|sd}FyG5=l>T7zyiCLJJ6(J#1C zS~Bir^KQA`uwNq&eWLO}XGYk;m)h3(khbpIK%H^h{K=B#I4d>^YY|&WBwpon@hoP~ z<(E1Q5jH%RHmJKr>|l3G{z5$w8?7{x4#|apaU>?KGIa~Tq{%Eg{n*(c`j#53QLMC6 zeB99MS%i+%U;Uqr?FzWW-{$WMbSc%;MXjJ*-!fY2`l>=ap6C-pyQ=W&Z2n|zhV}Lb zAE#lLWx_A*$5yRw%EpIUJVis*XNn~qd&+K>lCIUdihNUl`&w^aaZyoGUTrz6cQGWK zPJMp2#Jvm!rd$<9W!hwINGA{OkU*Cnf4;Y@H*qGy3oj`);3RE{ZsZLoOe56fxG^N0 zvIg4 zQj<`I$AErJga4Riw6w+y49KW6r&w!}FC*`Q(T~F^_QeuH5P0(YTalI=@OKdn2@IvF z0qW+DdM5fN8E^`3vG6XNJzZk{iKh!>NHLT+SwPOWpp-8cM}G48DvLY)`rS?W!b#u9 z!)7mo3MnS6o}x`L0rwnpiUvDKzSjarig|*ALaXe8eci5m$6~r^7uP15t_*>gUcN5X zoUTfo2EujJB-Aju-90rqqtZj^IPg^OjYpFzj}7}KlNW-GABFMMEKW3tlbj-P0kTAv zF|Kk#;^RprsetDI5TYU`HfmDuwOnG`ng(KESRNY%@mn|bD1fvGW^t#)PQ zGNnGR#^qK;u#A}yaZI{5uF6Qqzn0WXw8f+G8C7zmjwncakbRUL4%7ZRe0wjNv%y8D zE|c-99dfChG?%7^8lwW6${N=AN?{Q?nBgx!-(IQ)Knzhv|_rT zOI=55yuZYdu4K2>af|jwY}wT6?_#>hbR;af?o>Sau)&M&&sMk4L5|_-cnLMp{ZF89 z7)3g_9d%rUeom>uiiA}45;eDzN8^%89c>*o`y70Ka&zC-I=^p?!gj=)E~cMBziSZn zyNKHxGIMQp{>GLyRKFVtZcyrr^9o8=#tERbxl1BCNUW`(AI5m8Lf*if9;0c&2^=e0 zT0^2Ju0}UB>{gK!$QbpBVF8ju8A@pNVPo8=Uvt7=YH z{@QiE4h7|_CO^aE5H=B&=!94gDO4iKog|&1onVUfxENBtE7;z-hKGFF-Z-j2lgl#g zXs^Iq>Npe^cB-UGe|-wNQtzO#F^%F>O_IyM6bm#CZ-wdNjpuVu7ltPBCHuVF3r&6S z>jL0iOMGi+|Dda>X*c_(&L@YFnsC22548G@$5Ag$iw$(eY%U$t;be)GqN-?B{guC@><%c0-{9A&=?m22<%9 z;U$*0;3(lxx-4v=6+UeHOF~$r;7^WUo^)eE6}+jrq@){}e-)Qcj*?oXFweCfStpMC zyz)>mh=xk1JDSp7UMl^_yb*L&H1?$@JgwHK#}Ii)+rM$jO53C!GD$~8MY5k%gE7u+ z!Vj1yZPYILGR34=2m)SuDN)EzC?ty9)5xxFb}#Zq)KH}`rV_=rMU{O@$DoKn2w5ex z4k?Ksh}bxAhXke*-!_^d1`IY{VlnZm(vPfz#jYzxyVHc9=}JE`u4gy*p)%p;H0RE0 zbSpJ?*7UMwJI@G2xHBc)oOqAU3DNSCdUWI}l5x*MbKLVd(#;9e1}Cr?pTvvYzXKy>e1et!w)Qn=^=1`64TGgi0BERsr_)PmR)i<=S=f3K|TE8j0WKd#{U-CS) zr%mEaien6do=nN}c~Y?lt`neX%BdVI5dMnr5DVGbF z)IF@ylcR*{P3`tV^Zt{Br)rL;RQw6@Ce36~fh@G6FjAJ$dNPT=@h6c=1;Lb_?@JUp zQWGp7SyQLytN1D@Ep}35t=MnuJZr13YU>CEQ=uwtfhWnzj44Bn)G5ZwrT!%CgTiK$ zeeel)UY+7#IZM2YZ_JH% zziJu;7QB!pMm{7Mhek@W`DU@)WK6W<;u?0TLEq;3djbvJR_dEzyI|(XXhko>)e@p zozI7S`0@L#wb%Q#*Is*_z2wzAl z;b;C_cYjgb!E3LUKP-`+V$eVHa@Hwh{ZX4Prt#biI^nt`EwQ`C2_S4 z0nX+NB;(P_+Ui;?8f)vLYH>p#x>a^jlH_FV7QUoNYWIEEY)CN63$?eM=N6aoHlf6-104Dp+kAJlvXQT!G}TqoR< zx9XHrFAehBkH}V zHrALVxFni-s;W&gkZjkHNj*e-d8mq!J}DkjV*JXMaod= zH`i~uk_+{b%2?8GxpZTBMSZj}Qs=jn(3^h+y zPh^BlXWR4=Q{BFNPvlSfi2S%m_bJ;=s2n|V$tY1-S1Y46tv-;X#d1j&7%En+uCN_J z633sLFW4YzYVqXe3p?vioqim2f&<_w@EkY>UIcj!r%q1?*MRw;1T~VzpSefS=HgL5p|_h^f!!Q zAPnN51+)SM3P1`3KoAVSn{f@y0*gQy*aYgpy-j~hnK8-G?WRjQ zL#8~*Rf(M$y@vd|Nfc?82@dxLonVuHJIQ&q0&p2}`KEqkSn`*yT5PL=+{x6Nc`*YR z4}%Tn`DZm>;KU10KU9yaHC^k@gUR9Iz$)fYTcaUe5alv!PCHLmGM$%N;NIgZxUap!kCVEaR`HaZVEcyb}sisXXHULxu`Su&da zs49&y^PGxlVIVVUsgLl5JR6i70`$Bi%Uxw%lvN@(MpzGSPE&V3VNi_-7QDn`OqN*bSYB2kGe@_UQn5KAjVjx= zdCr`%mUhOdFDzcQyliPE6duszQB}ej?@9%uH!dc=UNuiIR7~jKJa|m(Ur&Txsntaq z8A$4FGa$Ee!BkPmUK>?a;==q9zrX)%VJ?bQz>apVM~o?N*F9PC(jo9LAUToAxSl#k zD{P;#(M)i)q9Imcp6Z7i4ne+zyAhQas2GvFV=A@Ety4?YIofP31{+O2acidX6`u1#}YZ(pb% z1@tsx)RKcPUA|42h{}_ly9JB8%vzv!vnnPvVMdB1PGwPz35vd!86T_Z_Rgoi_pGLw z%7D5yFlTnNDQ|y!cm?-!={Us2z(NBful-d%-Ys2GhQ_7tKV#&0 z_YLF742t$fwv_wbIM(Jyo3xkg-O%0pjC=om&e-VNGy|8p-C4g_mPF%?HQAQ_+nmX{ z3B;f8SGc9&#ko)S1^2X)Ua^#APUA{qaPF7I65Aq)s_T8rhIXVj3mlnIWpui1JPg0p ztg$C~7)eK@9j3!iuS1RQVkR_SI@0da>s5N(w{!SRddIq}k`i_9-ax?lmnt<6o)3g? z0Pb&+nyh8&(5(A%MSapjp`<~K;5j~s@|sVQk&E}R9LmCb{051FUQOE^1MmjWN(U>@15mM_0IODdFOaD zyi2{yyvw~Syv1sXDpnyLQuyV|?Po9SKaUFQ{gZ}i^ez1f@PUGL5I-r@zlIo@1vo;TmS!MoAB$y?yv>@D<) zyv5!Uuh=W`mU_#)366%sW(&JYEUs1SMO2@l~j$Y zNo`fzRI}Qy-kn}=OR|Vl8LQH3Si3uT<^%cNJnwb!T-V978Q28Mz#=dUTmhzmQ@A|= zo(D(3A<@|Hhlk+3@KdmaDOw=l)9R$~a5pWC~1xLUj zH~@OVUeF45f@V+$!k`@dXQlU*!g;ObTSuOxK1xZ~z3?KNzWtQzs0N&6;4x_4T>ov> zzCw-$%FEWW+)@>lS#aiWrg?3l#`xo|$y-mR;bsxLI>E8v>&lm1zrgr?HTNvK7}w3U zvd?!;#e6-J85>Xf_88mNz_L$O6SHLA4p#B-$t%0WJUihW6Q7qzH&(6QXKQQ^pJ{Gq;U|EHX{h;O424fzw z9NuWmEtZ4UzQuC<4(tC;!$l(|z5&aj-xzc1q_wv^m}BFyT$F3fp*+JQmg7^5IgoF7 z(D58&RyP_hy2)^>OfJ!-I^%y$|4 z!A*vTEst0ZzQfqJS`O2SB49J91hQx*>q7FjYzwFXvgb-x<741%P!FzPCNmYzo*kXT zjO=V?XYESnP9aZuW9M{1=6i2bxy<8kr*AD~E>_MAY#p;SnVa3kT+d_Pw3r!MiJiZh z+1p#0D~46Mw~5)>M&@_xndPlwPB%->9yc=YTJHta3~#)d+!f3X%?xd&ov*FZv$qg= z2v|&lv;S5suh3QuJ)`eywqLqEE@Q6CTW7l&iQN_vSqx(0Hg?=Fuk)?TO8?k7e!RYL zc}JR*Tb9(Dy>%MalXVC7Itr%nZ(D zSKZuZ+5PC(W;bLoJ&$$2=5lUc3*+1VI!Et*cLx7fZ)fM<*6i%kTX>y?*|X|QZigmC zWFVkFhf}BT10M&QzHsXFO85>C1#<0OU`&16_Q;ZaRPVEr7QwtDscs0)zj^-r8*Y^U zef2kcep1pm)3Qsm%~qNMD0xSm1EjCa0`fO}&uo2v`E5>p$M3%Wt@EGwTFKJ2EP5Zy zGXEsY{QE5Pi&^FuvdlluG7o2&=d^5pVqt0f%KnePqw1G8eoUveKoZ!(n{3`=QkGdKtqOZ_G`8WaWZKB{dDmd-1aXjsvPlweTW6Ct!TGh;`=g^b+^3T-p;}Ln6 zE9<|bU7Oe3D$}C2B{-tpY)z6m2uq(buVPa}f^}+rMqv8YjdE?-?e!Ydj_i13U)(a< zG%_hojvZfQ9NJo2#j?4KKzhlx@oTKxALf||J_eoxPk{rV6G(YY5MRBSj|G@Ji>tJ| zaUX!$eK7Zi8%McwZ((#%W?r7Kk9XcbEmmrfIvf9QOnPiTTC;q~;=txwKI|RW9w&0g zhrjP}?j~}R-aJD{6S?74X;L=dxq0F|p1?Dv3R+n)cgIyaE%M)(a1v2F|J0n?K_!6N3wQjQa#Tf!XYqh_DS&|6Q{0!ke`_s%dx&B`b7yp+@O+paI9JEhDfjQE8!Gw4w9coEWS$}=Tqkb(azot#QwD_+kV|JDmzlESnrqRINg88 zv~SzrvK@|bmtH5?QWx9IrgpOiq2D3$UMs#iMlAG+G5*+~e@|ePAKfv>xQp>3Qg%h! zkj7kh^S`tcxuKZF7q^SlZm)61ZKF1o>R6T8sT;Dp@y$$0M-?)!i1p?amOEv0E-$mw z`7zsL8DXTHDx-n=+GJApLXEe7HM3`w*oyV$3LS;rCZU5JTTZqfY(zFInHQ6`JSM!4 z*zAoZ<`^Ex1&@H8;9;->JOthYc7e>_X@0<>|B2P<5dU2b+#E|Rm3n89rp$jW8JTr2 zll5G^rYrmR1P>Hv+$xpAP|l>M4c-Xf1#f^i!FR#>ujsKNtHuz&eetj6jr+1tJY~5X zcmI!)Hn^qEEvf0avi#{)wNcKtxs4WX1q_Q4j_zrU`Yc%2@xSuJi7XJAeKIA*YLwaM z&Ht7WH*0HHwJT!=#VkB4T{7D-d*IA-obH!ZP4)HL-8*hua#{Xts~hVw%bhOQQLfwq zzfC-^QteJ#v!6$Hn3!y3Us=3niCi%q!)DgLakZCZ*O1#LlnIBOY|%Pa33*C2&TF@d zdlFg!SJd+hq1q%r#A0F8+3C%OW>a8Ak{Oe}AR9u)y&$2O^6+h5aY2o~Alp#nJ*ch+ zy}KyudNesVoy;tEiP&bAM`ZyuQ$ORmOYf7B^hge5?`nFVi?j6YoN?*ajiSOm z+}pCM9Cx?OcuQ(Z#ZJwJvqul4Ed?pIW9myE6JOs08r-Wb5!IL%D< z5M;gB*Wr(T`Tv@Na;-l*NPl>2I?C*Jo;Xz%zRr{#oGIs$1Up?5na#_iTT*~)`qybQ zYiHYE6WI3nD*i~{7_U106Zspxe|vPP`P;MfgQN`RZg6&+H+OJ#_ zZHASsIv0mJy%V`3gD%W0cTxTNM<-IIIXW?!A9~uHjq>{{Gn4f@lv)FXBf$L?1el+I z3qdZp2wV&<0W-j*;4*MIxB|QZTn%0at^}_K0dN(#23!En2kvk1ezTtJ%wsq>N3Rp* zTR!n@P@97RV?V}ymIc4F-Lg&p&NjiXqU1*pvi!lXCKt-;GyC?i=~I5TFw5ncZ> z<@%)ELmuEGsfk7wVf0>D_Y(oSb6{o_ztwAGiH0Bj*$t0`;-XLcV_wlnSk9-eDg7dw zpVc%=*`x=g3WLp9*1 zGHTn3mrq|&`k#vvYbFlw{I%xVE*tMG%*(BvONT#A&YipFSlk@k`10xC?f>u4O}-?) zXWnjD%npA^Iu@=To91)ZW$a#BpV9tsUHoDv?p@r%f7tNy>DlG49f5J&PNqD^3*%Po z-#E^-OMP|{zwJ*gu3y1^t>SvNxmmVEV}4M(Y`AAI?A91Ma1kg{gy{<0mU85Dp8AY{#~CqFqWou0x5Hu}6#sY2ecHSvDAPGL~1BCA+1mUnRBu9r_Yw;9asHT?D- z!x77J{h!en+3WAd&&RC4&-(nkaQ;#rvSGAzn|Qwf9|xD(__uc$dkJ^Ir?cbvs7;^W ze#GX@ZL%l|AqM_N|{i9DcO$eNW%|r|thUbYaPNZq0k?zE50y z{o{+~-no38n2mea4z4LO=6uUnSe|a#T;>0kw9-P_v-z6@vHeorXU*eNc6@gfX?O0q ze%Dux`RK~ zeCp8m;Q817{+?;Ys%7}5?O$D7tWrlG-Y|b_u{ykJOZ`{&6|1*>Fnny|kBf_Tf3Ep; ze}7R)=+`fN@7QIxm3-*CD<^+zq@{##_1~dKj(+Sj-`=}uUQh3Lul~b|o8Q*+V#&+r zbwz6VlZ{vN^IEUJmiTR0=UBJT z9ZQd~E=yxL7aM6uYz@@!?B#vex!`o=(cy=)(xbBG!TDL{f-G|&+ngF5{_^7Dg@MB61vggQIRAQ96XwljDqM4YBD!_X ztiX~cwx7utDwtLC^%^l&@k`c3Og_i*#=x9;v**rEk9j7?XTm#EerMXtnf~F%zcb^( znepH+84p~$`ESbw><Sd^X>c!k5T5-yrCP)d z{PdN)cSH}tpJXDp2R#5^eht5iLW>nvsF_SFkyTiE&KpDj&6Z}1V+R?Jd^pxDYWbu90t=L#2(&0 zm$@jq1^x&qM5o~Ld6X?W4F3`Y(IfClFdr=w)2qP(bPzrO7NG~>Z-El@5d7JNybl$7 z_#1CiDlYcIwC_1L7X8<0cKRO6M1`5!va4!3;W}pk;hd@B=;k>s~=3);|zKt>$4WGrw z4(E%8kANcd5Pa`S_6MR{;Qe3|dH_BS!srpWknKw~=%6r&qvLQdXcqVIanK^};lkCl zVQ~-FfL3u2_kum*9*%}6XR(KiZYOTEa9|DX87({loO8KBe@J4ViIt+gbw1|87qt#07MyKGx8rmmX_^evW z3ta$j00+=vcuGBeTk~iE>1T z;C}^S^axzLmHvZ{!+oGp+`}iqy=eK7MLyVxE`aBNUFahCBn#BA$kCQOAGA^9fTKyljsl}0jJP$_(7l^rftA& zAP+qNe+A^Dhu|NBY3LEydyuk17r=ACbaWBC6wE+};I%s#Kha_MruWd7#0~rsn1xpF zRq9y~L=VGt?_-=q$KgJ(5j_Au2g2e8E_jsR2cU%;K^?jU_I6XYVh@*r7IX;S4R)ei z;Ui!ddI+BOey)jo_(jl)Rv(~hz~kr^_z>8G9)z!WjQ)uZz?(n{9fm&wI?*XOua$B~ z7r^tu0J;dS0te7>crQ38?%|vd5{I~l=YzxI9l+ikHCc=Bmd|i zTm!BV_i!(mCGO$lV7|DA3-?fu;vOysCFn4`6O^J`;S-=t+{4p9&bWpSz&C+%bP@a@ z*eLGdYyXxufDXbBfjY5=e-4__Bk&!cAP#gG?(d>b(F5?Gz+SZKR;u{3)E7Dgw}3-v z;iKRw^f0{O0OgM^f>(j(#65gFIEoI#5%4@Z4ky7dx&?j)977MmU;iBW6b(Q81^OMj z75*~FdoT3@ulpipjt;|1zeG8sL+}lUC`WV=ya&ujr(pGE$`&nrEhs?;;kBR)9fltR z<>*#;FW7`m!3RMYJqRBKRp?=O`V-VEIso4R>d;~MUeJhcfsYST&gc<%%U4JfIu4%z zonjCF2JAfak?M{HcE=ZgCGk z^E7Q3Jp`WsY8QUt*w-jebR6CV^3kpEw8H>h0B-}+(JgQ%xB@)@e*py0gYY?Dr)`US z_!3Zv4#3xeS?C~q69}S<;N@UGIt1Si7NEm$Em(w(!`nd-x&?j^l%QMTkAhNk3f>3G z&;#(NK?pqvU-%8`5gmYk4K|@i;Af9eU+7`@_n;ZAzRCR*+>0)NF99v+0DKkLi4MYZ zz%FzVycq08hv3^mD>@AKgU8VW@N-}fdKmsO*oz*4{{T{G^$c?}(1|X9&j-Ee0DKkL zj}F2WU;rJ4W8e@v4ky7Nx&?j+JcVwBKMW3|Q*h0*^ha?IKLnl=H}D6+QE>xzfalQz z@aMrWdJujZ977Mm&w}IVVfZKD1bPHM2}aQB+q7HoBDw&+1e`<%;OoFCbP&D?s7EM6 zcpbk9}aRc9R zim?kFhOau!HFOXz^*ps79fI4yAbJ4)QjVt%qX*%yfTQRk_?BExJ&!JeZ_D%433Lel zB{+p1fj3X_)U-z_6ZrCcPhEo!z=I%&7Jm0xo+?7Oz{4Pf7A~6Vsf}pir$HD!1W!K4 zQ+4P9c;>mD+KCRr|9GCKTEz|ga90$QXyFUNFggIQ1IN%|cxoB-g)V^SfK%uqcooQdKlKQ|6Xc`Aa08fz zj>9j40<>D`smH(-=vMe6;2Lxa?gEAA0r+=dmbhO<+W_;?Bk*0TDK~T&{xc{QH~b{^ z5GY3v!cT)u=pp!#HM9YAE8Gd1(F5=>Xh93V40fT_T2IBmZgdhYf{%bf^bov`joF9MVfbBONZiAl@1Xsl@h!*}i*n}Q|D<7e( z(Q&vNREZn-=J!!<=puOXqx4yH0em5dqr-4DXhg^1$3ZhX1wRGuMGwJhH|2~LegN!3 zx4^#ykE2K6miIGWi9I~+1EdvQ04Kpgv4>jIZS&(7r}eMNpuSS zCdg|g4RGY^go}>De|UznMXPUl>Tf|IIt7P@C|k7f&hL0?0lF2w_c_WI-2#6fl%a>= zhVRi&(Q){|_bDIrAUx$L<$x}L+rdus0KDOc^hb0U{>d=?1U&-Z@&auMT?AkHGuj+F z0G|NE;s$=~=a|v0aO^mFM91OdzaWnv#0~sEenq=Mr{MSfkv4-?FL~;pz#??fpFFh< zl%QMSQ=m-TobuFlU?VyRfAVG826_OVaZ!$HLTxg~oq~S?u0fB$YuD$fLUb5D41(w(_}5^*xPiBC$We>X zE$|bd1U(3Uej|Al4gU~Sp@-ow-jSnf#2&uxPV$Hj!jIlX9?`AvNzjT`n{w1S@1Rc6 z1#k^GfF5~gj+$MOqn<(s;YHvGIs`uiN*^Q~_#+h0%U{(P!nUv%E*tsJQ*T2`0^=!{b|x+VfRYxcQ55MH>;dny5oc+ zdb2GbSMGlQ&d%k5*#*%Ej+LyPf#2i67_xKgupIVZ!o< zxc>ZR$LZqs+dJ)8^1Q>g8yDZ~3)Jl1d^K~=6!rRDlhviolhpK@JawLTq4KA8R6R*J zo23VmE*G}2f9!DS5uT_|I=}w9@Rvz;y=1q`?D54P=S12czH{TZyYy^zX-!C-@3pJZ zJ<#S=@+kgX+OyN>!hAJ${EaO_WuYtxbzr``3blhjo2GG$_?to&*5YZtHa7f;u(vv=&`ckJR3 zbKqPR*fU98#=771=3I3iW5v|Z`0lsAzcbEOGw6R8(ErY%|K-1sbw6?ONf>VI z_qSWWc5a1TJdXX>{u1r-?~g~?{*DRK`Im(4FPCh8F5YbW*J2jGuD`ncJ9hq^*`-0o zG@9>qO*q=RFo$Wp1xm@dezkiOCT_(Dn&l}s$^K(_cSE%$D>euH?QRjG9s7$LN zPJbC>hwt*J<5@8_9vL%#n+Z*aC1v8T$HH@YcQH-9zWHo*NzGKo{>w*?{jQ88|Dr#{ zd_niC3o`xcs&mv;&C?k>FJ$a|)7Y_7r|*Yj)2H)$?dbeU95Ppvy!y*l;@9y8GVx}+ z5p%n%9o*}9-#j*6J&(LvaW{;cFrUhVspIgOUHLoqm)#{(DYJ7av)7LhoLko>rG0(Av=*k9%n#)o`ixcFV%ez*Rz@oT>uzs?R@;?`yM)>kgGC0S_{ ze=c4A@LgW~?b7wNi>5BUC^tQW9-J~XX*hSp3ypd9m3+*#ZNeY6%fG}S@Vj$%uf{G6 zzhA$W@|o)^d*|NeRhQLOW6P>wk}B}>b7Wqw?;F`>$%iWw2~*m+g!u;YA$_Z6%Gi5> zw0&{=A>8Wro@<^5#ov?m+FY(p)Q|o7@|UCd-;Do@rp}~3me?nnOnppbf8LZE&dW`= z?m@k7klnts<81ehRZfc=*Cxh$_R?j1(bzI}>2`JEk4x%(qGuT$-X&who6Kng=@l3J zXSXRAPj=l&nP=x)+)ABF8eEC`*JZNZk2lUs{Nvf@=4S4H*?IQY>qPA!J72dloy$3M#AbSvQ!x3iLk1hMjWFM&P-h`kA9#z@9EBkt7Kd(eRQ%9Pxf)kK5f~zEqkmG}mHq6p zA5ZpW%04yOhbH@#WiOuW*^|A(vPW3<(8_*d*$XWDkY#_c?EjU$+_LXY_Jqp*Puce@ zdv#?Wuk1N)iDL)ixDVo9_SvcrP(L5W?xTc%lzmcJNM+0Pg{9U_ba0 zcn16eoC22|&r@#%#o$hGH@FXc6zl^}fnS1`!G*ubQ`dr0P!8?}_ku@33Va%T6?_-` z0=x_g{xwfs18xE9z}?^h&}t8Jzn|@&Xova&QlL7^J}G!IR(z;MZX4uSg46 z4(MQT90!wrou{q@LGX6488m?pfKPx=f-i$3;Ah|^aMlQQ24;g|z(}TY zRIVa4HCavJ`?F{9+uXDH7VSCwHupSLz^`*JP#5z3+Kbf1>JomRdnv!qy`10YzD`}q zFLVRyD)k0+wYo;lRM)EO_>Jxx^~oKtbe76OPE%RLm$z@>M+`;kKXOKjIf><+szQZT zME&Kbf&7iSmtV5quO3h>>Or+bJ*0N3ht-z4>TTx00a3-~xJ2_k#f-&T`=v#`>Lwpr z%v|8hee%hyYzud2qS%*2t0R2A%(yJorxqG(zHb=Y?hDbLMdb@J{dG0_(ZXnzj%it} zvMK3vCZC&g-&QmqXw%Nb+I)qs*dG5V@furl5sD?9GjlMTJ|WUN!NwgsnX&QbieSu1 zl=kv6`CPF18rxdVuyrBx3EgNsQnd=ovZ6>ilfnANS$$*;-*XLsDCx7&|~FK&*ebL8xnG&MGI#%i|H>)gJ}uYI-T#8F}@pZ%FH=2XMgE4F6=>P)~~x@P8JCThRT{&NHash}=EYqLgYN$-t zp0-^tUnz3#?13Cv#?ifOy?lw<-&oTY>8SYvS5_ya|IVAcxGEC&wIgkpl~Zjuy0aUT z`A(usn6VqLQJE{cfBIXGu^t;4!`W(cYWe7(eZz(EIySKK+Qv*g|3TJ_2PfAr_mHwC#wy0vj1W)0fTXRLf!!&aT#$u8Xcn+Hq%;t!;GLPJevU zjEZ)QwAP&b&hX_+kZX^lhu{z&>tDK+V@FL5Q#g%F>*I~vwVe)XO=O$yO)Fz^z|3gh z(p33Ip^1fhBpf+%TDr;_>^Voqmw>el<9tr8m~ZrMj#S>GU0FNYTyl*4IClbZp1E_S zO-p4A8{=O)bhVv!i$%7}l0+x;Uq?MD5tLl8>YEVLUT{n4xU+D6t_@+vpo(GDc}xd~;7n zU=oua7BfcQEy`H>i;gFNGk<^mCD6?Cnfu#&@g#L}(j;}{^Ee}~fX88}6^UpEyU2ORp%X2L+vHVWU3Cr)Z{I`|| zEPuoD&n&BRP5Akir(3?#@+`{>Er%>`ww$o+^1aKN|IYFO%THSVp5ggO;DPe8lqiEWcp+ zgylb2R=od^zp0j|TfWkAq2;-j7g=6rd5z^wma8qha*kW`4$G~U+q2vqu;y=A{*mRE zEKfV%r1LV%vn(&MTyDAAa--#)miJihw>)V1dzMEm=U-srx!7`{Q7R#F~*H}(i-f8)7 zE%#eKWceGGU$Fcu%ZjmE{-#?lv|MU=y=B*4&y2sOyv~fjrX0?Uzqa4n@$t;~Ys%xy z_-o4HKYRSWjMI~2Jbs5Vr;_k~!@L_1Zo;f(Cq?q62TfKU-eA|!TVq-Q(Q}|=NFNdXNvtC*pi6_5^4`;C_NpDcev)71d1*m7EEPZT;qo%BDm`eWck~((WrN zYGa$NsS;B%+StT96OQ(&;owKUI-n{d^~o(2(Pox<)wfgywhb}9HsDpr*RLtAdNt@( z=n9;aTfu9x##rr*^VRuQH;F+N=TPgo zT3;F8uGA+)$(e-e??jO`rT#weUA#_fRG-bG3UvaGX;AD4m9YDoI4PEUv7K#v3^-p4Vwt zX`5x#3x}ffwpXs}rXrW=z1L=J^gA)Wi80Qp@babSC8S`BS&1r-mB%QXLVHHNebGp3 z)u(;xk)llTMw4an@)(P&Q7NC5ViUK^*qlXa)<@l9x10-Y#$Z{^TtTCk)8+Zmm$fw! zOVC}47qZ4EqYioa6gHG;Y`b0>{j@U~H|mQ@(ids0tjUahKT~?KKmF2`AL6Q|9C>VW zVn*ZS2K6VutzB_Wsz3W}N9FqTcvnc_1>Q0a)U2^7y2PW?FRpClSR8BfX0a)jGdIg( z4O>Eu3H$_&ofM+ng48@~Hb?N4L>ePX-JF>`|o3(KoZJqp!|sVuTRnuu1J z2+gY}&Uj7oZAH0ii$*Vbs~y_LtPGp+yHji^?KtV`5zWgHy{@m5(L2gUpKmPQ7-jp% zUXc^h)IqUds}H(e8RZ1eO44yu>`d~c5QyoA85>^WR7UG53i?mRR+r1`a#keu3OGGw zKH3DazBXCAxh|@1#OBUete!XTswhY90j33RP$k;5qMqT9xGHj3&b5Op1&7VMa%_b! zOT_AJJteS9SDH%ZtW0i^Rb6hadaUJiGczMds(W)*S64H-=p?H9a^z5+OmllQClrm| zlWC8S<*=IWDuK8^o)hA|iShfzoHh1vR^32!?;1?onWnmmcU09(1LV%LK^;k7O;?ky zl%zV!mAYs|-b=(AIR=L>+&CLr&A*^!Xfzf5lN{4?%VVY|EA`u)wb6#EOsfBYxiKBm zpS8*LXVX4&WENw)d|pP&y99NvnDu)OrOq>&Q)m<1Z*3!07m4kJ?e;Bl)wao?XkA>Z zM2%`it1~vfRuuBtN@~_+%;nMMM(QAv%YwUmSD@aNYnp4w9jlx)J)=3dJhrZ(R&K1! zRmu~*;L|Uf%zMNK#ik)y$4diSY|N~3*EP7~c6E&s*KVKP*cw&pGr7{tTo4CyO$Mc5 z+Cf{dDa%~?wPSh7iu75E)A9HJ1Gg<*vubHsIvLziCjGZUeR6AMqH%Ur9ry4>q}`9T zrAy0P)5%=eujIZfA^D(SfYuQV?UM*E?P%G4Go~kO~ zRcaYp{{C0qum3E2h4a`eEPsw~)h03Lv5$E4Un7a(i)u^yt>YC>qWoGcb4iTpYbL4=&86} ztz+4ua~C0JE`JT_ly1ScnjbQV-zqe>cbm5meq-1*k=Diu^A^-;8tpbaW&U)P5WYuE zMhM-dCR5sqecChxR%Q~qOp~N1GOCQu${P>|Xa4@$N`UW6O(RXcf6ss69CeD$7EaZq z;;H6TOKMlDHMJ*|O7*4&QU_Cmsl%zE)X~&%>Ue4-buy*e^4kj9X0!#`3fqEh3)+g> zO4~wh8{5KdHEr>>=C+o$U2Uyxd)iWMy=?<+2ipeQ4z~@p9c>$KJKi?ZcCt;i=eHNM z&u9;{7q$o67ql0(m$rx6H@1h{Yue-O&FwAiyV_gZ_q3u}dl*U_%wuH#)JT_?L#cYb$4_l)j9 zcVTz1dqHa&z_!CPjAma&%vI- zp2IyuJx65&^v~!I^cVIA z`xo>V^_TXC`ZxB6`)m5+{muO?{k!^G`}g#x`g{8a`VaOG_8;ya>Oa~)+<&}(r2k~U z+LyntVBd^=fqjMhg8LTiE817OFSKvtzVN=9eer$G`&#zx+Sj^o&%V^Y-hBi64(=P= zH@xrUzJmRQ`-}E(+#lb+YkzA0!Tm$~kMF1L$N83;^i5iP%C>eD;CD?}{dJWt2@0BY z_5M}$${9VXh;NyYyg<4oU + * + * 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. + * + *************************************************************************/ + +#ifndef _glfw3_h_ +#define _glfw3_h_ + +#ifdef __cplusplus +extern "C" { +#endif + + +/************************************************************************* + * Doxygen documentation + *************************************************************************/ + +/*! @file glfw3.h + * @brief The header of the GLFW 3 API. + * + * This is the header file of the GLFW 3 API. It defines all its types and + * declares all its functions. + * + * For more information about how to use this file, see @ref build_include. + */ +/*! @defgroup context Context reference + * @brief Functions and types related to OpenGL and OpenGL ES contexts. + * + * This is the reference documentation for OpenGL and OpenGL ES context related + * functions. For more task-oriented information, see the @ref context_guide. + */ +/*! @defgroup vulkan Vulkan support reference + * @brief Functions and types related to Vulkan. + * + * This is the reference documentation for Vulkan related functions and types. + * For more task-oriented information, see the @ref vulkan_guide. + */ +/*! @defgroup init Initialization, version and error reference + * @brief Functions and types related to initialization and error handling. + * + * This is the reference documentation for initialization and termination of + * the library, version management and error handling. For more task-oriented + * information, see the @ref intro_guide. + */ +/*! @defgroup input Input reference + * @brief Functions and types related to input handling. + * + * This is the reference documentation for input related functions and types. + * For more task-oriented information, see the @ref input_guide. + */ +/*! @defgroup monitor Monitor reference + * @brief Functions and types related to monitors. + * + * This is the reference documentation for monitor related functions and types. + * For more task-oriented information, see the @ref monitor_guide. + */ +/*! @defgroup window Window reference + * @brief Functions and types related to windows. + * + * This is the reference documentation for window related functions and types, + * including creation, deletion and event polling. For more task-oriented + * information, see the @ref window_guide. + */ + + +/************************************************************************* + * Compiler- and platform-specific preprocessor work + *************************************************************************/ + +/* If we are we on Windows, we want a single define for it. + */ +#if !defined(_WIN32) && (defined(__WIN32__) || defined(WIN32) || defined(__MINGW32__)) + #define _WIN32 +#endif /* _WIN32 */ + +/* Include because most Windows GLU headers need wchar_t and + * the macOS OpenGL header blocks the definition of ptrdiff_t by glext.h. + * Include it unconditionally to avoid surprising side-effects. + */ +#include + +/* Include because it is needed by Vulkan and related functions. + * Include it unconditionally to avoid surprising side-effects. + */ +#include + +#if defined(GLFW_INCLUDE_VULKAN) + #include +#endif /* Vulkan header */ + +/* The Vulkan header may have indirectly included windows.h (because of + * VK_USE_PLATFORM_WIN32_KHR) so we offer our replacement symbols after it. + */ + +/* It is customary to use APIENTRY for OpenGL function pointer declarations on + * all platforms. Additionally, the Windows OpenGL header needs APIENTRY. + */ +#if !defined(APIENTRY) + #if defined(_WIN32) + #define APIENTRY __stdcall + #else + #define APIENTRY + #endif + #define GLFW_APIENTRY_DEFINED +#endif /* APIENTRY */ + +/* Some Windows OpenGL headers need this. + */ +#if !defined(WINGDIAPI) && defined(_WIN32) + #define WINGDIAPI __declspec(dllimport) + #define GLFW_WINGDIAPI_DEFINED +#endif /* WINGDIAPI */ + +/* Some Windows GLU headers need this. + */ +#if !defined(CALLBACK) && defined(_WIN32) + #define CALLBACK __stdcall + #define GLFW_CALLBACK_DEFINED +#endif /* CALLBACK */ + +/* Include the chosen OpenGL or OpenGL ES headers. + */ +#if defined(GLFW_INCLUDE_ES1) + + #include + #if defined(GLFW_INCLUDE_GLEXT) + #include + #endif + +#elif defined(GLFW_INCLUDE_ES2) + + #include + #if defined(GLFW_INCLUDE_GLEXT) + #include + #endif + +#elif defined(GLFW_INCLUDE_ES3) + + #include + #if defined(GLFW_INCLUDE_GLEXT) + #include + #endif + +#elif defined(GLFW_INCLUDE_ES31) + + #include + #if defined(GLFW_INCLUDE_GLEXT) + #include + #endif + +#elif defined(GLFW_INCLUDE_ES32) + + #include + #if defined(GLFW_INCLUDE_GLEXT) + #include + #endif + +#elif defined(GLFW_INCLUDE_GLCOREARB) + + #if defined(__APPLE__) + + #include + #if defined(GLFW_INCLUDE_GLEXT) + #include + #endif /*GLFW_INCLUDE_GLEXT*/ + + #else /*__APPLE__*/ + + #include + #if defined(GLFW_INCLUDE_GLEXT) + #include + #endif + + #endif /*__APPLE__*/ + +#elif defined(GLFW_INCLUDE_GLU) + + #if defined(__APPLE__) + + #if defined(GLFW_INCLUDE_GLU) + #include + #endif + + #else /*__APPLE__*/ + + #if defined(GLFW_INCLUDE_GLU) + #include + #endif + + #endif /*__APPLE__*/ + +#elif !defined(GLFW_INCLUDE_NONE) && \ + !defined(__gl_h_) && \ + !defined(__gles1_gl_h_) && \ + !defined(__gles2_gl2_h_) && \ + !defined(__gles2_gl3_h_) && \ + !defined(__gles2_gl31_h_) && \ + !defined(__gles2_gl32_h_) && \ + !defined(__gl_glcorearb_h_) && \ + !defined(__gl2_h_) /*legacy*/ && \ + !defined(__gl3_h_) /*legacy*/ && \ + !defined(__gl31_h_) /*legacy*/ && \ + !defined(__gl32_h_) /*legacy*/ && \ + !defined(__glcorearb_h_) /*legacy*/ && \ + !defined(__GL_H__) /*non-standard*/ && \ + !defined(__gltypes_h_) /*non-standard*/ && \ + !defined(__glee_h_) /*non-standard*/ + + #if defined(__APPLE__) + + #if !defined(GLFW_INCLUDE_GLEXT) + #define GL_GLEXT_LEGACY + #endif + #include + + #else /*__APPLE__*/ + + #include + #if defined(GLFW_INCLUDE_GLEXT) + #include + #endif + + #endif /*__APPLE__*/ + +#endif /* OpenGL and OpenGL ES headers */ + +#if defined(GLFW_DLL) && defined(_GLFW_BUILD_DLL) + /* GLFW_DLL must be defined by applications that are linking against the DLL + * version of the GLFW library. _GLFW_BUILD_DLL is defined by the GLFW + * configuration header when compiling the DLL version of the library. + */ + #error "You must not have both GLFW_DLL and _GLFW_BUILD_DLL defined" +#endif + +/* GLFWAPI is used to declare public API functions for export + * from the DLL / shared library / dynamic library. + */ +#if defined(_WIN32) && defined(_GLFW_BUILD_DLL) + /* We are building GLFW as a Win32 DLL */ + #define GLFWAPI __declspec(dllexport) +#elif defined(_WIN32) && defined(GLFW_DLL) + /* We are calling a GLFW Win32 DLL */ + #define GLFWAPI __declspec(dllimport) +#elif defined(__GNUC__) && defined(_GLFW_BUILD_DLL) + /* We are building GLFW as a Unix shared library */ + #define GLFWAPI __attribute__((visibility("default"))) +#else + #define GLFWAPI +#endif + + +/************************************************************************* + * GLFW API tokens + *************************************************************************/ + +/*! @name GLFW version macros + * @{ */ +/*! @brief The major version number of the GLFW header. + * + * The major version number of the GLFW header. This is incremented when the + * API is changed in non-compatible ways. + * @ingroup init + */ +#define GLFW_VERSION_MAJOR 3 +/*! @brief The minor version number of the GLFW header. + * + * The minor version number of the GLFW header. This is incremented when + * features are added to the API but it remains backward-compatible. + * @ingroup init + */ +#define GLFW_VERSION_MINOR 4 +/*! @brief The revision number of the GLFW header. + * + * The revision number of the GLFW header. This is incremented when a bug fix + * release is made that does not contain any API changes. + * @ingroup init + */ +#define GLFW_VERSION_REVISION 0 +/*! @} */ + +/*! @brief One. + * + * This is only semantic sugar for the number 1. You can instead use `1` or + * `true` or `_True` or `GL_TRUE` or `VK_TRUE` or anything else that is equal + * to one. + * + * @ingroup init + */ +#define GLFW_TRUE 1 +/*! @brief Zero. + * + * This is only semantic sugar for the number 0. You can instead use `0` or + * `false` or `_False` or `GL_FALSE` or `VK_FALSE` or anything else that is + * equal to zero. + * + * @ingroup init + */ +#define GLFW_FALSE 0 + +/*! @name Key and button actions + * @{ */ +/*! @brief The key or mouse button was released. + * + * The key or mouse button was released. + * + * @ingroup input + */ +#define GLFW_RELEASE 0 +/*! @brief The key or mouse button was pressed. + * + * The key or mouse button was pressed. + * + * @ingroup input + */ +#define GLFW_PRESS 1 +/*! @brief The key was held down until it repeated. + * + * The key was held down until it repeated. + * + * @ingroup input + */ +#define GLFW_REPEAT 2 +/*! @} */ + +/*! @defgroup hat_state Joystick hat states + * @brief Joystick hat states. + * + * See [joystick hat input](@ref joystick_hat) for how these are used. + * + * @ingroup input + * @{ */ +#define GLFW_HAT_CENTERED 0 +#define GLFW_HAT_UP 1 +#define GLFW_HAT_RIGHT 2 +#define GLFW_HAT_DOWN 4 +#define GLFW_HAT_LEFT 8 +#define GLFW_HAT_RIGHT_UP (GLFW_HAT_RIGHT | GLFW_HAT_UP) +#define GLFW_HAT_RIGHT_DOWN (GLFW_HAT_RIGHT | GLFW_HAT_DOWN) +#define GLFW_HAT_LEFT_UP (GLFW_HAT_LEFT | GLFW_HAT_UP) +#define GLFW_HAT_LEFT_DOWN (GLFW_HAT_LEFT | GLFW_HAT_DOWN) + +/*! @ingroup input + */ +#define GLFW_KEY_UNKNOWN -1 + +/*! @} */ + +/*! @defgroup keys Keyboard key tokens + * @brief Keyboard key tokens. + * + * See [key input](@ref input_key) for how these are used. + * + * These key codes are inspired by the _USB HID Usage Tables v1.12_ (p. 53-60), + * but re-arranged to map to 7-bit ASCII for printable keys (function keys are + * put in the 256+ range). + * + * The naming of the key codes follow these rules: + * - The US keyboard layout is used + * - Names of printable alphanumeric characters are used (e.g. "A", "R", + * "3", etc.) + * - For non-alphanumeric characters, Unicode:ish names are used (e.g. + * "COMMA", "LEFT_SQUARE_BRACKET", etc.). Note that some names do not + * correspond to the Unicode standard (usually for brevity) + * - Keys that lack a clear US mapping are named "WORLD_x" + * - For non-printable keys, custom names are used (e.g. "F4", + * "BACKSPACE", etc.) + * + * @ingroup input + * @{ + */ + +/* Printable keys */ +#define GLFW_KEY_SPACE 32 +#define GLFW_KEY_APOSTROPHE 39 /* ' */ +#define GLFW_KEY_COMMA 44 /* , */ +#define GLFW_KEY_MINUS 45 /* - */ +#define GLFW_KEY_PERIOD 46 /* . */ +#define GLFW_KEY_SLASH 47 /* / */ +#define GLFW_KEY_0 48 +#define GLFW_KEY_1 49 +#define GLFW_KEY_2 50 +#define GLFW_KEY_3 51 +#define GLFW_KEY_4 52 +#define GLFW_KEY_5 53 +#define GLFW_KEY_6 54 +#define GLFW_KEY_7 55 +#define GLFW_KEY_8 56 +#define GLFW_KEY_9 57 +#define GLFW_KEY_SEMICOLON 59 /* ; */ +#define GLFW_KEY_EQUAL 61 /* = */ +#define GLFW_KEY_A 65 +#define GLFW_KEY_B 66 +#define GLFW_KEY_C 67 +#define GLFW_KEY_D 68 +#define GLFW_KEY_E 69 +#define GLFW_KEY_F 70 +#define GLFW_KEY_G 71 +#define GLFW_KEY_H 72 +#define GLFW_KEY_I 73 +#define GLFW_KEY_J 74 +#define GLFW_KEY_K 75 +#define GLFW_KEY_L 76 +#define GLFW_KEY_M 77 +#define GLFW_KEY_N 78 +#define GLFW_KEY_O 79 +#define GLFW_KEY_P 80 +#define GLFW_KEY_Q 81 +#define GLFW_KEY_R 82 +#define GLFW_KEY_S 83 +#define GLFW_KEY_T 84 +#define GLFW_KEY_U 85 +#define GLFW_KEY_V 86 +#define GLFW_KEY_W 87 +#define GLFW_KEY_X 88 +#define GLFW_KEY_Y 89 +#define GLFW_KEY_Z 90 +#define GLFW_KEY_LEFT_BRACKET 91 /* [ */ +#define GLFW_KEY_BACKSLASH 92 /* \ */ +#define GLFW_KEY_RIGHT_BRACKET 93 /* ] */ +#define GLFW_KEY_GRAVE_ACCENT 96 /* ` */ +#define GLFW_KEY_WORLD_1 161 /* non-US #1 */ +#define GLFW_KEY_WORLD_2 162 /* non-US #2 */ + +/* Function keys */ +#define GLFW_KEY_ESCAPE 256 +#define GLFW_KEY_ENTER 257 +#define GLFW_KEY_TAB 258 +#define GLFW_KEY_BACKSPACE 259 +#define GLFW_KEY_INSERT 260 +#define GLFW_KEY_DELETE 261 +#define GLFW_KEY_RIGHT 262 +#define GLFW_KEY_LEFT 263 +#define GLFW_KEY_DOWN 264 +#define GLFW_KEY_UP 265 +#define GLFW_KEY_PAGE_UP 266 +#define GLFW_KEY_PAGE_DOWN 267 +#define GLFW_KEY_HOME 268 +#define GLFW_KEY_END 269 +#define GLFW_KEY_CAPS_LOCK 280 +#define GLFW_KEY_SCROLL_LOCK 281 +#define GLFW_KEY_NUM_LOCK 282 +#define GLFW_KEY_PRINT_SCREEN 283 +#define GLFW_KEY_PAUSE 284 +#define GLFW_KEY_F1 290 +#define GLFW_KEY_F2 291 +#define GLFW_KEY_F3 292 +#define GLFW_KEY_F4 293 +#define GLFW_KEY_F5 294 +#define GLFW_KEY_F6 295 +#define GLFW_KEY_F7 296 +#define GLFW_KEY_F8 297 +#define GLFW_KEY_F9 298 +#define GLFW_KEY_F10 299 +#define GLFW_KEY_F11 300 +#define GLFW_KEY_F12 301 +#define GLFW_KEY_F13 302 +#define GLFW_KEY_F14 303 +#define GLFW_KEY_F15 304 +#define GLFW_KEY_F16 305 +#define GLFW_KEY_F17 306 +#define GLFW_KEY_F18 307 +#define GLFW_KEY_F19 308 +#define GLFW_KEY_F20 309 +#define GLFW_KEY_F21 310 +#define GLFW_KEY_F22 311 +#define GLFW_KEY_F23 312 +#define GLFW_KEY_F24 313 +#define GLFW_KEY_F25 314 +#define GLFW_KEY_KP_0 320 +#define GLFW_KEY_KP_1 321 +#define GLFW_KEY_KP_2 322 +#define GLFW_KEY_KP_3 323 +#define GLFW_KEY_KP_4 324 +#define GLFW_KEY_KP_5 325 +#define GLFW_KEY_KP_6 326 +#define GLFW_KEY_KP_7 327 +#define GLFW_KEY_KP_8 328 +#define GLFW_KEY_KP_9 329 +#define GLFW_KEY_KP_DECIMAL 330 +#define GLFW_KEY_KP_DIVIDE 331 +#define GLFW_KEY_KP_MULTIPLY 332 +#define GLFW_KEY_KP_SUBTRACT 333 +#define GLFW_KEY_KP_ADD 334 +#define GLFW_KEY_KP_ENTER 335 +#define GLFW_KEY_KP_EQUAL 336 +#define GLFW_KEY_LEFT_SHIFT 340 +#define GLFW_KEY_LEFT_CONTROL 341 +#define GLFW_KEY_LEFT_ALT 342 +#define GLFW_KEY_LEFT_SUPER 343 +#define GLFW_KEY_RIGHT_SHIFT 344 +#define GLFW_KEY_RIGHT_CONTROL 345 +#define GLFW_KEY_RIGHT_ALT 346 +#define GLFW_KEY_RIGHT_SUPER 347 +#define GLFW_KEY_MENU 348 + +#define GLFW_KEY_LAST GLFW_KEY_MENU + +/*! @} */ + +/*! @defgroup mods Modifier key flags + * @brief Modifier key flags. + * + * See [key input](@ref input_key) for how these are used. + * + * @ingroup input + * @{ */ + +/*! @brief If this bit is set one or more Shift keys were held down. + * + * If this bit is set one or more Shift keys were held down. + */ +#define GLFW_MOD_SHIFT 0x0001 +/*! @brief If this bit is set one or more Control keys were held down. + * + * If this bit is set one or more Control keys were held down. + */ +#define GLFW_MOD_CONTROL 0x0002 +/*! @brief If this bit is set one or more Alt keys were held down. + * + * If this bit is set one or more Alt keys were held down. + */ +#define GLFW_MOD_ALT 0x0004 +/*! @brief If this bit is set one or more Super keys were held down. + * + * If this bit is set one or more Super keys were held down. + */ +#define GLFW_MOD_SUPER 0x0008 +/*! @brief If this bit is set the Caps Lock key is enabled. + * + * If this bit is set the Caps Lock key is enabled and the @ref + * GLFW_LOCK_KEY_MODS input mode is set. + */ +#define GLFW_MOD_CAPS_LOCK 0x0010 +/*! @brief If this bit is set the Num Lock key is enabled. + * + * If this bit is set the Num Lock key is enabled and the @ref + * GLFW_LOCK_KEY_MODS input mode is set. + */ +#define GLFW_MOD_NUM_LOCK 0x0020 + +/*! @} */ + +/*! @defgroup buttons Mouse buttons + * @brief Mouse button IDs. + * + * See [mouse button input](@ref input_mouse_button) for how these are used. + * + * @ingroup input + * @{ */ +#define GLFW_MOUSE_BUTTON_1 0 +#define GLFW_MOUSE_BUTTON_2 1 +#define GLFW_MOUSE_BUTTON_3 2 +#define GLFW_MOUSE_BUTTON_4 3 +#define GLFW_MOUSE_BUTTON_5 4 +#define GLFW_MOUSE_BUTTON_6 5 +#define GLFW_MOUSE_BUTTON_7 6 +#define GLFW_MOUSE_BUTTON_8 7 +#define GLFW_MOUSE_BUTTON_LAST GLFW_MOUSE_BUTTON_8 +#define GLFW_MOUSE_BUTTON_LEFT GLFW_MOUSE_BUTTON_1 +#define GLFW_MOUSE_BUTTON_RIGHT GLFW_MOUSE_BUTTON_2 +#define GLFW_MOUSE_BUTTON_MIDDLE GLFW_MOUSE_BUTTON_3 +/*! @} */ + +/*! @defgroup joysticks Joysticks + * @brief Joystick IDs. + * + * See [joystick input](@ref joystick) for how these are used. + * + * @ingroup input + * @{ */ +#define GLFW_JOYSTICK_1 0 +#define GLFW_JOYSTICK_2 1 +#define GLFW_JOYSTICK_3 2 +#define GLFW_JOYSTICK_4 3 +#define GLFW_JOYSTICK_5 4 +#define GLFW_JOYSTICK_6 5 +#define GLFW_JOYSTICK_7 6 +#define GLFW_JOYSTICK_8 7 +#define GLFW_JOYSTICK_9 8 +#define GLFW_JOYSTICK_10 9 +#define GLFW_JOYSTICK_11 10 +#define GLFW_JOYSTICK_12 11 +#define GLFW_JOYSTICK_13 12 +#define GLFW_JOYSTICK_14 13 +#define GLFW_JOYSTICK_15 14 +#define GLFW_JOYSTICK_16 15 +#define GLFW_JOYSTICK_LAST GLFW_JOYSTICK_16 +/*! @} */ + +/*! @defgroup gamepad_buttons Gamepad buttons + * @brief Gamepad buttons. + * + * See @ref gamepad for how these are used. + * + * @ingroup input + * @{ */ +#define GLFW_GAMEPAD_BUTTON_A 0 +#define GLFW_GAMEPAD_BUTTON_B 1 +#define GLFW_GAMEPAD_BUTTON_X 2 +#define GLFW_GAMEPAD_BUTTON_Y 3 +#define GLFW_GAMEPAD_BUTTON_LEFT_BUMPER 4 +#define GLFW_GAMEPAD_BUTTON_RIGHT_BUMPER 5 +#define GLFW_GAMEPAD_BUTTON_BACK 6 +#define GLFW_GAMEPAD_BUTTON_START 7 +#define GLFW_GAMEPAD_BUTTON_GUIDE 8 +#define GLFW_GAMEPAD_BUTTON_LEFT_THUMB 9 +#define GLFW_GAMEPAD_BUTTON_RIGHT_THUMB 10 +#define GLFW_GAMEPAD_BUTTON_DPAD_UP 11 +#define GLFW_GAMEPAD_BUTTON_DPAD_RIGHT 12 +#define GLFW_GAMEPAD_BUTTON_DPAD_DOWN 13 +#define GLFW_GAMEPAD_BUTTON_DPAD_LEFT 14 +#define GLFW_GAMEPAD_BUTTON_LAST GLFW_GAMEPAD_BUTTON_DPAD_LEFT + +#define GLFW_GAMEPAD_BUTTON_CROSS GLFW_GAMEPAD_BUTTON_A +#define GLFW_GAMEPAD_BUTTON_CIRCLE GLFW_GAMEPAD_BUTTON_B +#define GLFW_GAMEPAD_BUTTON_SQUARE GLFW_GAMEPAD_BUTTON_X +#define GLFW_GAMEPAD_BUTTON_TRIANGLE GLFW_GAMEPAD_BUTTON_Y +/*! @} */ + +/*! @defgroup gamepad_axes Gamepad axes + * @brief Gamepad axes. + * + * See @ref gamepad for how these are used. + * + * @ingroup input + * @{ */ +#define GLFW_GAMEPAD_AXIS_LEFT_X 0 +#define GLFW_GAMEPAD_AXIS_LEFT_Y 1 +#define GLFW_GAMEPAD_AXIS_RIGHT_X 2 +#define GLFW_GAMEPAD_AXIS_RIGHT_Y 3 +#define GLFW_GAMEPAD_AXIS_LEFT_TRIGGER 4 +#define GLFW_GAMEPAD_AXIS_RIGHT_TRIGGER 5 +#define GLFW_GAMEPAD_AXIS_LAST GLFW_GAMEPAD_AXIS_RIGHT_TRIGGER +/*! @} */ + +/*! @defgroup errors Error codes + * @brief Error codes. + * + * See [error handling](@ref error_handling) for how these are used. + * + * @ingroup init + * @{ */ +/*! @brief No error has occurred. + * + * No error has occurred. + * + * @analysis Yay. + */ +#define GLFW_NO_ERROR 0 +/*! @brief GLFW has not been initialized. + * + * This occurs if a GLFW function was called that must not be called unless the + * library is [initialized](@ref intro_init). + * + * @analysis Application programmer error. Initialize GLFW before calling any + * function that requires initialization. + */ +#define GLFW_NOT_INITIALIZED 0x00010001 +/*! @brief No context is current for this thread. + * + * This occurs if a GLFW function was called that needs and operates on the + * current OpenGL or OpenGL ES context but no context is current on the calling + * thread. One such function is @ref glfwSwapInterval. + * + * @analysis Application programmer error. Ensure a context is current before + * calling functions that require a current context. + */ +#define GLFW_NO_CURRENT_CONTEXT 0x00010002 +/*! @brief One of the arguments to the function was an invalid enum value. + * + * One of the arguments to the function was an invalid enum value, for example + * requesting @ref GLFW_RED_BITS with @ref glfwGetWindowAttrib. + * + * @analysis Application programmer error. Fix the offending call. + */ +#define GLFW_INVALID_ENUM 0x00010003 +/*! @brief One of the arguments to the function was an invalid value. + * + * One of the arguments to the function was an invalid value, for example + * requesting a non-existent OpenGL or OpenGL ES version like 2.7. + * + * Requesting a valid but unavailable OpenGL or OpenGL ES version will instead + * result in a @ref GLFW_VERSION_UNAVAILABLE error. + * + * @analysis Application programmer error. Fix the offending call. + */ +#define GLFW_INVALID_VALUE 0x00010004 +/*! @brief A memory allocation failed. + * + * A memory allocation failed. + * + * @analysis A bug in GLFW or the underlying operating system. Report the bug + * to our [issue tracker](https://github.com/glfw/glfw/issues). + */ +#define GLFW_OUT_OF_MEMORY 0x00010005 +/*! @brief GLFW could not find support for the requested API on the system. + * + * GLFW could not find support for the requested API on the system. + * + * @analysis The installed graphics driver does not support the requested + * API, or does not support it via the chosen context creation API. + * Below are a few examples. + * + * @par + * Some pre-installed Windows graphics drivers do not support OpenGL. AMD only + * supports OpenGL ES via EGL, while Nvidia and Intel only support it via + * a WGL or GLX extension. macOS does not provide OpenGL ES at all. The Mesa + * EGL, OpenGL and OpenGL ES libraries do not interface with the Nvidia binary + * driver. Older graphics drivers do not support Vulkan. + */ +#define GLFW_API_UNAVAILABLE 0x00010006 +/*! @brief The requested OpenGL or OpenGL ES version is not available. + * + * The requested OpenGL or OpenGL ES version (including any requested context + * or framebuffer hints) is not available on this machine. + * + * @analysis The machine does not support your requirements. If your + * application is sufficiently flexible, downgrade your requirements and try + * again. Otherwise, inform the user that their machine does not match your + * requirements. + * + * @par + * Future invalid OpenGL and OpenGL ES versions, for example OpenGL 4.8 if 5.0 + * comes out before the 4.x series gets that far, also fail with this error and + * not @ref GLFW_INVALID_VALUE, because GLFW cannot know what future versions + * will exist. + */ +#define GLFW_VERSION_UNAVAILABLE 0x00010007 +/*! @brief A platform-specific error occurred that does not match any of the + * more specific categories. + * + * A platform-specific error occurred that does not match any of the more + * specific categories. + * + * @analysis A bug or configuration error in GLFW, the underlying operating + * system or its drivers, or a lack of required resources. Report the issue to + * our [issue tracker](https://github.com/glfw/glfw/issues). + */ +#define GLFW_PLATFORM_ERROR 0x00010008 +/*! @brief The requested format is not supported or available. + * + * If emitted during window creation, the requested pixel format is not + * supported. + * + * If emitted when querying the clipboard, the contents of the clipboard could + * not be converted to the requested format. + * + * @analysis If emitted during window creation, one or more + * [hard constraints](@ref window_hints_hard) did not match any of the + * available pixel formats. If your application is sufficiently flexible, + * downgrade your requirements and try again. Otherwise, inform the user that + * their machine does not match your requirements. + * + * @par + * If emitted when querying the clipboard, ignore the error or report it to + * the user, as appropriate. + */ +#define GLFW_FORMAT_UNAVAILABLE 0x00010009 +/*! @brief The specified window does not have an OpenGL or OpenGL ES context. + * + * A window that does not have an OpenGL or OpenGL ES context was passed to + * a function that requires it to have one. + * + * @analysis Application programmer error. Fix the offending call. + */ +#define GLFW_NO_WINDOW_CONTEXT 0x0001000A +/*! @brief The specified cursor shape is not available. + * + * The specified standard cursor shape is not available, either because the + * current platform cursor theme does not provide it or because it is not + * available on the platform. + * + * @analysis Platform or system settings limitation. Pick another + * [standard cursor shape](@ref shapes) or create a + * [custom cursor](@ref cursor_custom). + */ +#define GLFW_CURSOR_UNAVAILABLE 0x0001000B +/*! @brief The requested feature is not provided by the platform. + * + * The requested feature is not provided by the platform, so GLFW is unable to + * implement it. The documentation for each function notes if it could emit + * this error. + * + * @analysis Platform or platform version limitation. The error can be ignored + * unless the feature is critical to the application. + * + * @par + * A function call that emits this error has no effect other than the error and + * updating any existing out parameters. + */ +#define GLFW_FEATURE_UNAVAILABLE 0x0001000C +/*! @brief The requested feature is not implemented for the platform. + * + * The requested feature has not yet been implemented in GLFW for this platform. + * + * @analysis An incomplete implementation of GLFW for this platform, hopefully + * fixed in a future release. The error can be ignored unless the feature is + * critical to the application. + * + * @par + * A function call that emits this error has no effect other than the error and + * updating any existing out parameters. + */ +#define GLFW_FEATURE_UNIMPLEMENTED 0x0001000D +/*! @brief Platform unavailable or no matching platform was found. + * + * If emitted during initialization, no matching platform was found. If the @ref + * GLFW_PLATFORM init hint was set to `GLFW_ANY_PLATFORM`, GLFW could not detect any of + * the platforms supported by this library binary, except for the Null platform. If the + * init hint was set to a specific platform, it is either not supported by this library + * binary or GLFW was not able to detect it. + * + * If emitted by a native access function, GLFW was initialized for a different platform + * than the function is for. + * + * @analysis Failure to detect any platform usually only happens on non-macOS Unix + * systems, either when no window system is running or the program was run from + * a terminal that does not have the necessary environment variables. Fall back to + * a different platform if possible or notify the user that no usable platform was + * detected. + * + * Failure to detect a specific platform may have the same cause as above or be because + * support for that platform was not compiled in. Call @ref glfwPlatformSupported to + * check whether a specific platform is supported by a library binary. + */ +#define GLFW_PLATFORM_UNAVAILABLE 0x0001000E +/*! @} */ + +/*! @addtogroup window + * @{ */ +/*! @brief Input focus window hint and attribute + * + * Input focus [window hint](@ref GLFW_FOCUSED_hint) or + * [window attribute](@ref GLFW_FOCUSED_attrib). + */ +#define GLFW_FOCUSED 0x00020001 +/*! @brief Window iconification window attribute + * + * Window iconification [window attribute](@ref GLFW_ICONIFIED_attrib). + */ +#define GLFW_ICONIFIED 0x00020002 +/*! @brief Window resize-ability window hint and attribute + * + * Window resize-ability [window hint](@ref GLFW_RESIZABLE_hint) and + * [window attribute](@ref GLFW_RESIZABLE_attrib). + */ +#define GLFW_RESIZABLE 0x00020003 +/*! @brief Window visibility window hint and attribute + * + * Window visibility [window hint](@ref GLFW_VISIBLE_hint) and + * [window attribute](@ref GLFW_VISIBLE_attrib). + */ +#define GLFW_VISIBLE 0x00020004 +/*! @brief Window decoration window hint and attribute + * + * Window decoration [window hint](@ref GLFW_DECORATED_hint) and + * [window attribute](@ref GLFW_DECORATED_attrib). + */ +#define GLFW_DECORATED 0x00020005 +/*! @brief Window auto-iconification window hint and attribute + * + * Window auto-iconification [window hint](@ref GLFW_AUTO_ICONIFY_hint) and + * [window attribute](@ref GLFW_AUTO_ICONIFY_attrib). + */ +#define GLFW_AUTO_ICONIFY 0x00020006 +/*! @brief Window decoration window hint and attribute + * + * Window decoration [window hint](@ref GLFW_FLOATING_hint) and + * [window attribute](@ref GLFW_FLOATING_attrib). + */ +#define GLFW_FLOATING 0x00020007 +/*! @brief Window maximization window hint and attribute + * + * Window maximization [window hint](@ref GLFW_MAXIMIZED_hint) and + * [window attribute](@ref GLFW_MAXIMIZED_attrib). + */ +#define GLFW_MAXIMIZED 0x00020008 +/*! @brief Cursor centering window hint + * + * Cursor centering [window hint](@ref GLFW_CENTER_CURSOR_hint). + */ +#define GLFW_CENTER_CURSOR 0x00020009 +/*! @brief Window framebuffer transparency hint and attribute + * + * Window framebuffer transparency + * [window hint](@ref GLFW_TRANSPARENT_FRAMEBUFFER_hint) and + * [window attribute](@ref GLFW_TRANSPARENT_FRAMEBUFFER_attrib). + */ +#define GLFW_TRANSPARENT_FRAMEBUFFER 0x0002000A +/*! @brief Mouse cursor hover window attribute. + * + * Mouse cursor hover [window attribute](@ref GLFW_HOVERED_attrib). + */ +#define GLFW_HOVERED 0x0002000B +/*! @brief Input focus on calling show window hint and attribute + * + * Input focus [window hint](@ref GLFW_FOCUS_ON_SHOW_hint) or + * [window attribute](@ref GLFW_FOCUS_ON_SHOW_attrib). + */ +#define GLFW_FOCUS_ON_SHOW 0x0002000C + +/*! @brief Mouse input transparency window hint and attribute + * + * Mouse input transparency [window hint](@ref GLFW_MOUSE_PASSTHROUGH_hint) or + * [window attribute](@ref GLFW_MOUSE_PASSTHROUGH_attrib). + */ +#define GLFW_MOUSE_PASSTHROUGH 0x0002000D + +/*! @brief Initial position x-coordinate window hint. + * + * Initial position x-coordinate [window hint](@ref GLFW_POSITION_X). + */ +#define GLFW_POSITION_X 0x0002000E + +/*! @brief Initial position y-coordinate window hint. + * + * Initial position y-coordinate [window hint](@ref GLFW_POSITION_Y). + */ +#define GLFW_POSITION_Y 0x0002000F + +/*! @brief Framebuffer bit depth hint. + * + * Framebuffer bit depth [hint](@ref GLFW_RED_BITS). + */ +#define GLFW_RED_BITS 0x00021001 +/*! @brief Framebuffer bit depth hint. + * + * Framebuffer bit depth [hint](@ref GLFW_GREEN_BITS). + */ +#define GLFW_GREEN_BITS 0x00021002 +/*! @brief Framebuffer bit depth hint. + * + * Framebuffer bit depth [hint](@ref GLFW_BLUE_BITS). + */ +#define GLFW_BLUE_BITS 0x00021003 +/*! @brief Framebuffer bit depth hint. + * + * Framebuffer bit depth [hint](@ref GLFW_ALPHA_BITS). + */ +#define GLFW_ALPHA_BITS 0x00021004 +/*! @brief Framebuffer bit depth hint. + * + * Framebuffer bit depth [hint](@ref GLFW_DEPTH_BITS). + */ +#define GLFW_DEPTH_BITS 0x00021005 +/*! @brief Framebuffer bit depth hint. + * + * Framebuffer bit depth [hint](@ref GLFW_STENCIL_BITS). + */ +#define GLFW_STENCIL_BITS 0x00021006 +/*! @brief Framebuffer bit depth hint. + * + * Framebuffer bit depth [hint](@ref GLFW_ACCUM_RED_BITS). + */ +#define GLFW_ACCUM_RED_BITS 0x00021007 +/*! @brief Framebuffer bit depth hint. + * + * Framebuffer bit depth [hint](@ref GLFW_ACCUM_GREEN_BITS). + */ +#define GLFW_ACCUM_GREEN_BITS 0x00021008 +/*! @brief Framebuffer bit depth hint. + * + * Framebuffer bit depth [hint](@ref GLFW_ACCUM_BLUE_BITS). + */ +#define GLFW_ACCUM_BLUE_BITS 0x00021009 +/*! @brief Framebuffer bit depth hint. + * + * Framebuffer bit depth [hint](@ref GLFW_ACCUM_ALPHA_BITS). + */ +#define GLFW_ACCUM_ALPHA_BITS 0x0002100A +/*! @brief Framebuffer auxiliary buffer hint. + * + * Framebuffer auxiliary buffer [hint](@ref GLFW_AUX_BUFFERS). + */ +#define GLFW_AUX_BUFFERS 0x0002100B +/*! @brief OpenGL stereoscopic rendering hint. + * + * OpenGL stereoscopic rendering [hint](@ref GLFW_STEREO). + */ +#define GLFW_STEREO 0x0002100C +/*! @brief Framebuffer MSAA samples hint. + * + * Framebuffer MSAA samples [hint](@ref GLFW_SAMPLES). + */ +#define GLFW_SAMPLES 0x0002100D +/*! @brief Framebuffer sRGB hint. + * + * Framebuffer sRGB [hint](@ref GLFW_SRGB_CAPABLE). + */ +#define GLFW_SRGB_CAPABLE 0x0002100E +/*! @brief Monitor refresh rate hint. + * + * Monitor refresh rate [hint](@ref GLFW_REFRESH_RATE). + */ +#define GLFW_REFRESH_RATE 0x0002100F +/*! @brief Framebuffer double buffering hint and attribute. + * + * Framebuffer double buffering [hint](@ref GLFW_DOUBLEBUFFER_hint) and + * [attribute](@ref GLFW_DOUBLEBUFFER_attrib). + */ +#define GLFW_DOUBLEBUFFER 0x00021010 + +/*! @brief Context client API hint and attribute. + * + * Context client API [hint](@ref GLFW_CLIENT_API_hint) and + * [attribute](@ref GLFW_CLIENT_API_attrib). + */ +#define GLFW_CLIENT_API 0x00022001 +/*! @brief Context client API major version hint and attribute. + * + * Context client API major version [hint](@ref GLFW_CONTEXT_VERSION_MAJOR_hint) + * and [attribute](@ref GLFW_CONTEXT_VERSION_MAJOR_attrib). + */ +#define GLFW_CONTEXT_VERSION_MAJOR 0x00022002 +/*! @brief Context client API minor version hint and attribute. + * + * Context client API minor version [hint](@ref GLFW_CONTEXT_VERSION_MINOR_hint) + * and [attribute](@ref GLFW_CONTEXT_VERSION_MINOR_attrib). + */ +#define GLFW_CONTEXT_VERSION_MINOR 0x00022003 +/*! @brief Context client API revision number attribute. + * + * Context client API revision number + * [attribute](@ref GLFW_CONTEXT_REVISION_attrib). + */ +#define GLFW_CONTEXT_REVISION 0x00022004 +/*! @brief Context robustness hint and attribute. + * + * Context client API revision number [hint](@ref GLFW_CONTEXT_ROBUSTNESS_hint) + * and [attribute](@ref GLFW_CONTEXT_ROBUSTNESS_attrib). + */ +#define GLFW_CONTEXT_ROBUSTNESS 0x00022005 +/*! @brief OpenGL forward-compatibility hint and attribute. + * + * OpenGL forward-compatibility [hint](@ref GLFW_OPENGL_FORWARD_COMPAT_hint) + * and [attribute](@ref GLFW_OPENGL_FORWARD_COMPAT_attrib). + */ +#define GLFW_OPENGL_FORWARD_COMPAT 0x00022006 +/*! @brief Debug mode context hint and attribute. + * + * Debug mode context [hint](@ref GLFW_CONTEXT_DEBUG_hint) and + * [attribute](@ref GLFW_CONTEXT_DEBUG_attrib). + */ +#define GLFW_CONTEXT_DEBUG 0x00022007 +/*! @brief Legacy name for compatibility. + * + * This is an alias for compatibility with earlier versions. + */ +#define GLFW_OPENGL_DEBUG_CONTEXT GLFW_CONTEXT_DEBUG +/*! @brief OpenGL profile hint and attribute. + * + * OpenGL profile [hint](@ref GLFW_OPENGL_PROFILE_hint) and + * [attribute](@ref GLFW_OPENGL_PROFILE_attrib). + */ +#define GLFW_OPENGL_PROFILE 0x00022008 +/*! @brief Context flush-on-release hint and attribute. + * + * Context flush-on-release [hint](@ref GLFW_CONTEXT_RELEASE_BEHAVIOR_hint) and + * [attribute](@ref GLFW_CONTEXT_RELEASE_BEHAVIOR_attrib). + */ +#define GLFW_CONTEXT_RELEASE_BEHAVIOR 0x00022009 +/*! @brief Context error suppression hint and attribute. + * + * Context error suppression [hint](@ref GLFW_CONTEXT_NO_ERROR_hint) and + * [attribute](@ref GLFW_CONTEXT_NO_ERROR_attrib). + */ +#define GLFW_CONTEXT_NO_ERROR 0x0002200A +/*! @brief Context creation API hint and attribute. + * + * Context creation API [hint](@ref GLFW_CONTEXT_CREATION_API_hint) and + * [attribute](@ref GLFW_CONTEXT_CREATION_API_attrib). + */ +#define GLFW_CONTEXT_CREATION_API 0x0002200B +/*! @brief Window content area scaling window + * [window hint](@ref GLFW_SCALE_TO_MONITOR). + */ +#define GLFW_SCALE_TO_MONITOR 0x0002200C +/*! @brief Window framebuffer scaling + * [window hint](@ref GLFW_SCALE_FRAMEBUFFER_hint). + */ +#define GLFW_SCALE_FRAMEBUFFER 0x0002200D +/*! @brief Legacy name for compatibility. + * + * This is an alias for the + * [GLFW_SCALE_FRAMEBUFFER](@ref GLFW_SCALE_FRAMEBUFFER_hint) window hint for + * compatibility with earlier versions. + */ +#define GLFW_COCOA_RETINA_FRAMEBUFFER 0x00023001 +/*! @brief macOS specific + * [window hint](@ref GLFW_COCOA_FRAME_NAME_hint). + */ +#define GLFW_COCOA_FRAME_NAME 0x00023002 +/*! @brief macOS specific + * [window hint](@ref GLFW_COCOA_GRAPHICS_SWITCHING_hint). + */ +#define GLFW_COCOA_GRAPHICS_SWITCHING 0x00023003 +/*! @brief X11 specific + * [window hint](@ref GLFW_X11_CLASS_NAME_hint). + */ +#define GLFW_X11_CLASS_NAME 0x00024001 +/*! @brief X11 specific + * [window hint](@ref GLFW_X11_CLASS_NAME_hint). + */ +#define GLFW_X11_INSTANCE_NAME 0x00024002 +#define GLFW_WIN32_KEYBOARD_MENU 0x00025001 +/*! @brief Win32 specific [window hint](@ref GLFW_WIN32_SHOWDEFAULT_hint). + */ +#define GLFW_WIN32_SHOWDEFAULT 0x00025002 +/*! @brief Wayland specific + * [window hint](@ref GLFW_WAYLAND_APP_ID_hint). + * + * Allows specification of the Wayland app_id. + */ +#define GLFW_WAYLAND_APP_ID 0x00026001 +/*! @} */ + +#define GLFW_NO_API 0 +#define GLFW_OPENGL_API 0x00030001 +#define GLFW_OPENGL_ES_API 0x00030002 + +#define GLFW_NO_ROBUSTNESS 0 +#define GLFW_NO_RESET_NOTIFICATION 0x00031001 +#define GLFW_LOSE_CONTEXT_ON_RESET 0x00031002 + +#define GLFW_OPENGL_ANY_PROFILE 0 +#define GLFW_OPENGL_CORE_PROFILE 0x00032001 +#define GLFW_OPENGL_COMPAT_PROFILE 0x00032002 + +#define GLFW_CURSOR 0x00033001 +#define GLFW_STICKY_KEYS 0x00033002 +#define GLFW_STICKY_MOUSE_BUTTONS 0x00033003 +#define GLFW_LOCK_KEY_MODS 0x00033004 +#define GLFW_RAW_MOUSE_MOTION 0x00033005 + +#define GLFW_CURSOR_NORMAL 0x00034001 +#define GLFW_CURSOR_HIDDEN 0x00034002 +#define GLFW_CURSOR_DISABLED 0x00034003 +#define GLFW_CURSOR_CAPTURED 0x00034004 + +#define GLFW_ANY_RELEASE_BEHAVIOR 0 +#define GLFW_RELEASE_BEHAVIOR_FLUSH 0x00035001 +#define GLFW_RELEASE_BEHAVIOR_NONE 0x00035002 + +#define GLFW_NATIVE_CONTEXT_API 0x00036001 +#define GLFW_EGL_CONTEXT_API 0x00036002 +#define GLFW_OSMESA_CONTEXT_API 0x00036003 + +#define GLFW_ANGLE_PLATFORM_TYPE_NONE 0x00037001 +#define GLFW_ANGLE_PLATFORM_TYPE_OPENGL 0x00037002 +#define GLFW_ANGLE_PLATFORM_TYPE_OPENGLES 0x00037003 +#define GLFW_ANGLE_PLATFORM_TYPE_D3D9 0x00037004 +#define GLFW_ANGLE_PLATFORM_TYPE_D3D11 0x00037005 +#define GLFW_ANGLE_PLATFORM_TYPE_VULKAN 0x00037007 +#define GLFW_ANGLE_PLATFORM_TYPE_METAL 0x00037008 + +#define GLFW_WAYLAND_PREFER_LIBDECOR 0x00038001 +#define GLFW_WAYLAND_DISABLE_LIBDECOR 0x00038002 + +#define GLFW_ANY_POSITION 0x80000000 + +/*! @defgroup shapes Standard cursor shapes + * @brief Standard system cursor shapes. + * + * These are the [standard cursor shapes](@ref cursor_standard) that can be + * requested from the platform (window system). + * + * @ingroup input + * @{ */ + +/*! @brief The regular arrow cursor shape. + * + * The regular arrow cursor shape. + */ +#define GLFW_ARROW_CURSOR 0x00036001 +/*! @brief The text input I-beam cursor shape. + * + * The text input I-beam cursor shape. + */ +#define GLFW_IBEAM_CURSOR 0x00036002 +/*! @brief The crosshair cursor shape. + * + * The crosshair cursor shape. + */ +#define GLFW_CROSSHAIR_CURSOR 0x00036003 +/*! @brief The pointing hand cursor shape. + * + * The pointing hand cursor shape. + */ +#define GLFW_POINTING_HAND_CURSOR 0x00036004 +/*! @brief The horizontal resize/move arrow shape. + * + * The horizontal resize/move arrow shape. This is usually a horizontal + * double-headed arrow. + */ +#define GLFW_RESIZE_EW_CURSOR 0x00036005 +/*! @brief The vertical resize/move arrow shape. + * + * The vertical resize/move shape. This is usually a vertical double-headed + * arrow. + */ +#define GLFW_RESIZE_NS_CURSOR 0x00036006 +/*! @brief The top-left to bottom-right diagonal resize/move arrow shape. + * + * The top-left to bottom-right diagonal resize/move shape. This is usually + * a diagonal double-headed arrow. + * + * @note @macos This shape is provided by a private system API and may fail + * with @ref GLFW_CURSOR_UNAVAILABLE in the future. + * + * @note @wayland This shape is provided by a newer standard not supported by + * all cursor themes. + * + * @note @x11 This shape is provided by a newer standard not supported by all + * cursor themes. + */ +#define GLFW_RESIZE_NWSE_CURSOR 0x00036007 +/*! @brief The top-right to bottom-left diagonal resize/move arrow shape. + * + * The top-right to bottom-left diagonal resize/move shape. This is usually + * a diagonal double-headed arrow. + * + * @note @macos This shape is provided by a private system API and may fail + * with @ref GLFW_CURSOR_UNAVAILABLE in the future. + * + * @note @wayland This shape is provided by a newer standard not supported by + * all cursor themes. + * + * @note @x11 This shape is provided by a newer standard not supported by all + * cursor themes. + */ +#define GLFW_RESIZE_NESW_CURSOR 0x00036008 +/*! @brief The omni-directional resize/move cursor shape. + * + * The omni-directional resize cursor/move shape. This is usually either + * a combined horizontal and vertical double-headed arrow or a grabbing hand. + */ +#define GLFW_RESIZE_ALL_CURSOR 0x00036009 +/*! @brief The operation-not-allowed shape. + * + * The operation-not-allowed shape. This is usually a circle with a diagonal + * line through it. + * + * @note @wayland This shape is provided by a newer standard not supported by + * all cursor themes. + * + * @note @x11 This shape is provided by a newer standard not supported by all + * cursor themes. + */ +#define GLFW_NOT_ALLOWED_CURSOR 0x0003600A +/*! @brief Legacy name for compatibility. + * + * This is an alias for compatibility with earlier versions. + */ +#define GLFW_HRESIZE_CURSOR GLFW_RESIZE_EW_CURSOR +/*! @brief Legacy name for compatibility. + * + * This is an alias for compatibility with earlier versions. + */ +#define GLFW_VRESIZE_CURSOR GLFW_RESIZE_NS_CURSOR +/*! @brief Legacy name for compatibility. + * + * This is an alias for compatibility with earlier versions. + */ +#define GLFW_HAND_CURSOR GLFW_POINTING_HAND_CURSOR +/*! @} */ + +#define GLFW_CONNECTED 0x00040001 +#define GLFW_DISCONNECTED 0x00040002 + +/*! @addtogroup init + * @{ */ +/*! @brief Joystick hat buttons init hint. + * + * Joystick hat buttons [init hint](@ref GLFW_JOYSTICK_HAT_BUTTONS). + */ +#define GLFW_JOYSTICK_HAT_BUTTONS 0x00050001 +/*! @brief ANGLE rendering backend init hint. + * + * ANGLE rendering backend [init hint](@ref GLFW_ANGLE_PLATFORM_TYPE_hint). + */ +#define GLFW_ANGLE_PLATFORM_TYPE 0x00050002 +/*! @brief Platform selection init hint. + * + * Platform selection [init hint](@ref GLFW_PLATFORM). + */ +#define GLFW_PLATFORM 0x00050003 +/*! @brief macOS specific init hint. + * + * macOS specific [init hint](@ref GLFW_COCOA_CHDIR_RESOURCES_hint). + */ +#define GLFW_COCOA_CHDIR_RESOURCES 0x00051001 +/*! @brief macOS specific init hint. + * + * macOS specific [init hint](@ref GLFW_COCOA_MENUBAR_hint). + */ +#define GLFW_COCOA_MENUBAR 0x00051002 +/*! @brief X11 specific init hint. + * + * X11 specific [init hint](@ref GLFW_X11_XCB_VULKAN_SURFACE_hint). + */ +#define GLFW_X11_XCB_VULKAN_SURFACE 0x00052001 +/*! @brief Wayland specific init hint. + * + * Wayland specific [init hint](@ref GLFW_WAYLAND_LIBDECOR_hint). + */ +#define GLFW_WAYLAND_LIBDECOR 0x00053001 +/*! @} */ + +/*! @addtogroup init + * @{ */ +/*! @brief Hint value that enables automatic platform selection. + * + * Hint value for @ref GLFW_PLATFORM that enables automatic platform selection. + */ +#define GLFW_ANY_PLATFORM 0x00060000 +#define GLFW_PLATFORM_WIN32 0x00060001 +#define GLFW_PLATFORM_COCOA 0x00060002 +#define GLFW_PLATFORM_WAYLAND 0x00060003 +#define GLFW_PLATFORM_X11 0x00060004 +#define GLFW_PLATFORM_NULL 0x00060005 +/*! @} */ + +#define GLFW_DONT_CARE -1 + + +/************************************************************************* + * GLFW API types + *************************************************************************/ + +/*! @brief Client API function pointer type. + * + * Generic function pointer used for returning client API function pointers + * without forcing a cast from a regular pointer. + * + * @sa @ref context_glext + * @sa @ref glfwGetProcAddress + * + * @since Added in version 3.0. + * + * @ingroup context + */ +typedef void (*GLFWglproc)(void); + +/*! @brief Vulkan API function pointer type. + * + * Generic function pointer used for returning Vulkan API function pointers + * without forcing a cast from a regular pointer. + * + * @sa @ref vulkan_proc + * @sa @ref glfwGetInstanceProcAddress + * + * @since Added in version 3.2. + * + * @ingroup vulkan + */ +typedef void (*GLFWvkproc)(void); + +/*! @brief Opaque monitor object. + * + * Opaque monitor object. + * + * @see @ref monitor_object + * + * @since Added in version 3.0. + * + * @ingroup monitor + */ +typedef struct GLFWmonitor GLFWmonitor; + +/*! @brief Opaque window object. + * + * Opaque window object. + * + * @see @ref window_object + * + * @since Added in version 3.0. + * + * @ingroup window + */ +typedef struct GLFWwindow GLFWwindow; + +/*! @brief Opaque cursor object. + * + * Opaque cursor object. + * + * @see @ref cursor_object + * + * @since Added in version 3.1. + * + * @ingroup input + */ +typedef struct GLFWcursor GLFWcursor; + +/*! @brief The function pointer type for memory allocation callbacks. + * + * This is the function pointer type for memory allocation callbacks. A memory + * allocation callback function has the following signature: + * @code + * void* function_name(size_t size, void* user) + * @endcode + * + * This function must return either a memory block at least `size` bytes long, + * or `NULL` if allocation failed. Note that not all parts of GLFW handle allocation + * failures gracefully yet. + * + * This function must support being called during @ref glfwInit but before the library is + * flagged as initialized, as well as during @ref glfwTerminate after the library is no + * longer flagged as initialized. + * + * Any memory allocated via this function will be deallocated via the same allocator + * during library termination or earlier. + * + * Any memory allocated via this function must be suitably aligned for any object type. + * If you are using C99 or earlier, this alignment is platform-dependent but will be the + * same as what `malloc` provides. If you are using C11 or later, this is the value of + * `alignof(max_align_t)`. + * + * The size will always be greater than zero. Allocations of size zero are filtered out + * before reaching the custom allocator. + * + * If this function returns `NULL`, GLFW will emit @ref GLFW_OUT_OF_MEMORY. + * + * This function must not call any GLFW function. + * + * @param[in] size The minimum size, in bytes, of the memory block. + * @param[in] user The user-defined pointer from the allocator. + * @return The address of the newly allocated memory block, or `NULL` if an + * error occurred. + * + * @pointer_lifetime The returned memory block must be valid at least until it + * is deallocated. + * + * @reentrancy This function should not call any GLFW function. + * + * @thread_safety This function must support being called from any thread that calls GLFW + * functions. + * + * @sa @ref init_allocator + * @sa @ref GLFWallocator + * + * @since Added in version 3.4. + * + * @ingroup init + */ +typedef void* (* GLFWallocatefun)(size_t size, void* user); + +/*! @brief The function pointer type for memory reallocation callbacks. + * + * This is the function pointer type for memory reallocation callbacks. + * A memory reallocation callback function has the following signature: + * @code + * void* function_name(void* block, size_t size, void* user) + * @endcode + * + * This function must return a memory block at least `size` bytes long, or + * `NULL` if allocation failed. Note that not all parts of GLFW handle allocation + * failures gracefully yet. + * + * This function must support being called during @ref glfwInit but before the library is + * flagged as initialized, as well as during @ref glfwTerminate after the library is no + * longer flagged as initialized. + * + * Any memory allocated via this function will be deallocated via the same allocator + * during library termination or earlier. + * + * Any memory allocated via this function must be suitably aligned for any object type. + * If you are using C99 or earlier, this alignment is platform-dependent but will be the + * same as what `realloc` provides. If you are using C11 or later, this is the value of + * `alignof(max_align_t)`. + * + * The block address will never be `NULL` and the size will always be greater than zero. + * Reallocations of a block to size zero are converted into deallocations before reaching + * the custom allocator. Reallocations of `NULL` to a non-zero size are converted into + * regular allocations before reaching the custom allocator. + * + * If this function returns `NULL`, GLFW will emit @ref GLFW_OUT_OF_MEMORY. + * + * This function must not call any GLFW function. + * + * @param[in] block The address of the memory block to reallocate. + * @param[in] size The new minimum size, in bytes, of the memory block. + * @param[in] user The user-defined pointer from the allocator. + * @return The address of the newly allocated or resized memory block, or + * `NULL` if an error occurred. + * + * @pointer_lifetime The returned memory block must be valid at least until it + * is deallocated. + * + * @reentrancy This function should not call any GLFW function. + * + * @thread_safety This function must support being called from any thread that calls GLFW + * functions. + * + * @sa @ref init_allocator + * @sa @ref GLFWallocator + * + * @since Added in version 3.4. + * + * @ingroup init + */ +typedef void* (* GLFWreallocatefun)(void* block, size_t size, void* user); + +/*! @brief The function pointer type for memory deallocation callbacks. + * + * This is the function pointer type for memory deallocation callbacks. + * A memory deallocation callback function has the following signature: + * @code + * void function_name(void* block, void* user) + * @endcode + * + * This function may deallocate the specified memory block. This memory block + * will have been allocated with the same allocator. + * + * This function must support being called during @ref glfwInit but before the library is + * flagged as initialized, as well as during @ref glfwTerminate after the library is no + * longer flagged as initialized. + * + * The block address will never be `NULL`. Deallocations of `NULL` are filtered out + * before reaching the custom allocator. + * + * If this function returns `NULL`, GLFW will emit @ref GLFW_OUT_OF_MEMORY. + * + * This function must not call any GLFW function. + * + * @param[in] block The address of the memory block to deallocate. + * @param[in] user The user-defined pointer from the allocator. + * + * @pointer_lifetime The specified memory block will not be accessed by GLFW + * after this function is called. + * + * @reentrancy This function should not call any GLFW function. + * + * @thread_safety This function must support being called from any thread that calls GLFW + * functions. + * + * @sa @ref init_allocator + * @sa @ref GLFWallocator + * + * @since Added in version 3.4. + * + * @ingroup init + */ +typedef void (* GLFWdeallocatefun)(void* block, void* user); + +/*! @brief The function pointer type for error callbacks. + * + * This is the function pointer type for error callbacks. An error callback + * function has the following signature: + * @code + * void callback_name(int error_code, const char* description) + * @endcode + * + * @param[in] error_code An [error code](@ref errors). Future releases may add + * more error codes. + * @param[in] description A UTF-8 encoded string describing the error. + * + * @pointer_lifetime The error description string is valid until the callback + * function returns. + * + * @sa @ref error_handling + * @sa @ref glfwSetErrorCallback + * + * @since Added in version 3.0. + * + * @ingroup init + */ +typedef void (* GLFWerrorfun)(int error_code, const char* description); + +/*! @brief The function pointer type for window position callbacks. + * + * This is the function pointer type for window position callbacks. A window + * position callback function has the following signature: + * @code + * void callback_name(GLFWwindow* window, int xpos, int ypos) + * @endcode + * + * @param[in] window The window that was moved. + * @param[in] xpos The new x-coordinate, in screen coordinates, of the + * upper-left corner of the content area of the window. + * @param[in] ypos The new y-coordinate, in screen coordinates, of the + * upper-left corner of the content area of the window. + * + * @sa @ref window_pos + * @sa @ref glfwSetWindowPosCallback + * + * @since Added in version 3.0. + * + * @ingroup window + */ +typedef void (* GLFWwindowposfun)(GLFWwindow* window, int xpos, int ypos); + +/*! @brief The function pointer type for window size callbacks. + * + * This is the function pointer type for window size callbacks. A window size + * callback function has the following signature: + * @code + * void callback_name(GLFWwindow* window, int width, int height) + * @endcode + * + * @param[in] window The window that was resized. + * @param[in] width The new width, in screen coordinates, of the window. + * @param[in] height The new height, in screen coordinates, of the window. + * + * @sa @ref window_size + * @sa @ref glfwSetWindowSizeCallback + * + * @since Added in version 1.0. + * @glfw3 Added window handle parameter. + * + * @ingroup window + */ +typedef void (* GLFWwindowsizefun)(GLFWwindow* window, int width, int height); + +/*! @brief The function pointer type for window close callbacks. + * + * This is the function pointer type for window close callbacks. A window + * close callback function has the following signature: + * @code + * void function_name(GLFWwindow* window) + * @endcode + * + * @param[in] window The window that the user attempted to close. + * + * @sa @ref window_close + * @sa @ref glfwSetWindowCloseCallback + * + * @since Added in version 2.5. + * @glfw3 Added window handle parameter. + * + * @ingroup window + */ +typedef void (* GLFWwindowclosefun)(GLFWwindow* window); + +/*! @brief The function pointer type for window content refresh callbacks. + * + * This is the function pointer type for window content refresh callbacks. + * A window content refresh callback function has the following signature: + * @code + * void function_name(GLFWwindow* window); + * @endcode + * + * @param[in] window The window whose content needs to be refreshed. + * + * @sa @ref window_refresh + * @sa @ref glfwSetWindowRefreshCallback + * + * @since Added in version 2.5. + * @glfw3 Added window handle parameter. + * + * @ingroup window + */ +typedef void (* GLFWwindowrefreshfun)(GLFWwindow* window); + +/*! @brief The function pointer type for window focus callbacks. + * + * This is the function pointer type for window focus callbacks. A window + * focus callback function has the following signature: + * @code + * void function_name(GLFWwindow* window, int focused) + * @endcode + * + * @param[in] window The window that gained or lost input focus. + * @param[in] focused `GLFW_TRUE` if the window was given input focus, or + * `GLFW_FALSE` if it lost it. + * + * @sa @ref window_focus + * @sa @ref glfwSetWindowFocusCallback + * + * @since Added in version 3.0. + * + * @ingroup window + */ +typedef void (* GLFWwindowfocusfun)(GLFWwindow* window, int focused); + +/*! @brief The function pointer type for window iconify callbacks. + * + * This is the function pointer type for window iconify callbacks. A window + * iconify callback function has the following signature: + * @code + * void function_name(GLFWwindow* window, int iconified) + * @endcode + * + * @param[in] window The window that was iconified or restored. + * @param[in] iconified `GLFW_TRUE` if the window was iconified, or + * `GLFW_FALSE` if it was restored. + * + * @sa @ref window_iconify + * @sa @ref glfwSetWindowIconifyCallback + * + * @since Added in version 3.0. + * + * @ingroup window + */ +typedef void (* GLFWwindowiconifyfun)(GLFWwindow* window, int iconified); + +/*! @brief The function pointer type for window maximize callbacks. + * + * This is the function pointer type for window maximize callbacks. A window + * maximize callback function has the following signature: + * @code + * void function_name(GLFWwindow* window, int maximized) + * @endcode + * + * @param[in] window The window that was maximized or restored. + * @param[in] maximized `GLFW_TRUE` if the window was maximized, or + * `GLFW_FALSE` if it was restored. + * + * @sa @ref window_maximize + * @sa glfwSetWindowMaximizeCallback + * + * @since Added in version 3.3. + * + * @ingroup window + */ +typedef void (* GLFWwindowmaximizefun)(GLFWwindow* window, int maximized); + +/*! @brief The function pointer type for framebuffer size callbacks. + * + * This is the function pointer type for framebuffer size callbacks. + * A framebuffer size callback function has the following signature: + * @code + * void function_name(GLFWwindow* window, int width, int height) + * @endcode + * + * @param[in] window The window whose framebuffer was resized. + * @param[in] width The new width, in pixels, of the framebuffer. + * @param[in] height The new height, in pixels, of the framebuffer. + * + * @sa @ref window_fbsize + * @sa @ref glfwSetFramebufferSizeCallback + * + * @since Added in version 3.0. + * + * @ingroup window + */ +typedef void (* GLFWframebuffersizefun)(GLFWwindow* window, int width, int height); + +/*! @brief The function pointer type for window content scale callbacks. + * + * This is the function pointer type for window content scale callbacks. + * A window content scale callback function has the following signature: + * @code + * void function_name(GLFWwindow* window, float xscale, float yscale) + * @endcode + * + * @param[in] window The window whose content scale changed. + * @param[in] xscale The new x-axis content scale of the window. + * @param[in] yscale The new y-axis content scale of the window. + * + * @sa @ref window_scale + * @sa @ref glfwSetWindowContentScaleCallback + * + * @since Added in version 3.3. + * + * @ingroup window + */ +typedef void (* GLFWwindowcontentscalefun)(GLFWwindow* window, float xscale, float yscale); + +/*! @brief The function pointer type for mouse button callbacks. + * + * This is the function pointer type for mouse button callback functions. + * A mouse button callback function has the following signature: + * @code + * void function_name(GLFWwindow* window, int button, int action, int mods) + * @endcode + * + * @param[in] window The window that received the event. + * @param[in] button The [mouse button](@ref buttons) that was pressed or + * released. + * @param[in] action One of `GLFW_PRESS` or `GLFW_RELEASE`. Future releases + * may add more actions. + * @param[in] mods Bit field describing which [modifier keys](@ref mods) were + * held down. + * + * @sa @ref input_mouse_button + * @sa @ref glfwSetMouseButtonCallback + * + * @since Added in version 1.0. + * @glfw3 Added window handle and modifier mask parameters. + * + * @ingroup input + */ +typedef void (* GLFWmousebuttonfun)(GLFWwindow* window, int button, int action, int mods); + +/*! @brief The function pointer type for cursor position callbacks. + * + * This is the function pointer type for cursor position callbacks. A cursor + * position callback function has the following signature: + * @code + * void function_name(GLFWwindow* window, double xpos, double ypos); + * @endcode + * + * @param[in] window The window that received the event. + * @param[in] xpos The new cursor x-coordinate, relative to the left edge of + * the content area. + * @param[in] ypos The new cursor y-coordinate, relative to the top edge of the + * content area. + * + * @sa @ref cursor_pos + * @sa @ref glfwSetCursorPosCallback + * + * @since Added in version 3.0. Replaces `GLFWmouseposfun`. + * + * @ingroup input + */ +typedef void (* GLFWcursorposfun)(GLFWwindow* window, double xpos, double ypos); + +/*! @brief The function pointer type for cursor enter/leave callbacks. + * + * This is the function pointer type for cursor enter/leave callbacks. + * A cursor enter/leave callback function has the following signature: + * @code + * void function_name(GLFWwindow* window, int entered) + * @endcode + * + * @param[in] window The window that received the event. + * @param[in] entered `GLFW_TRUE` if the cursor entered the window's content + * area, or `GLFW_FALSE` if it left it. + * + * @sa @ref cursor_enter + * @sa @ref glfwSetCursorEnterCallback + * + * @since Added in version 3.0. + * + * @ingroup input + */ +typedef void (* GLFWcursorenterfun)(GLFWwindow* window, int entered); + +/*! @brief The function pointer type for scroll callbacks. + * + * This is the function pointer type for scroll callbacks. A scroll callback + * function has the following signature: + * @code + * void function_name(GLFWwindow* window, double xoffset, double yoffset) + * @endcode + * + * @param[in] window The window that received the event. + * @param[in] xoffset The scroll offset along the x-axis. + * @param[in] yoffset The scroll offset along the y-axis. + * + * @sa @ref scrolling + * @sa @ref glfwSetScrollCallback + * + * @since Added in version 3.0. Replaces `GLFWmousewheelfun`. + * + * @ingroup input + */ +typedef void (* GLFWscrollfun)(GLFWwindow* window, double xoffset, double yoffset); + +/*! @brief The function pointer type for keyboard key callbacks. + * + * This is the function pointer type for keyboard key callbacks. A keyboard + * key callback function has the following signature: + * @code + * void function_name(GLFWwindow* window, int key, int scancode, int action, int mods) + * @endcode + * + * @param[in] window The window that received the event. + * @param[in] key The [keyboard key](@ref keys) that was pressed or released. + * @param[in] scancode The platform-specific scancode of the key. + * @param[in] action `GLFW_PRESS`, `GLFW_RELEASE` or `GLFW_REPEAT`. Future + * releases may add more actions. + * @param[in] mods Bit field describing which [modifier keys](@ref mods) were + * held down. + * + * @sa @ref input_key + * @sa @ref glfwSetKeyCallback + * + * @since Added in version 1.0. + * @glfw3 Added window handle, scancode and modifier mask parameters. + * + * @ingroup input + */ +typedef void (* GLFWkeyfun)(GLFWwindow* window, int key, int scancode, int action, int mods); + +/*! @brief The function pointer type for Unicode character callbacks. + * + * This is the function pointer type for Unicode character callbacks. + * A Unicode character callback function has the following signature: + * @code + * void function_name(GLFWwindow* window, unsigned int codepoint) + * @endcode + * + * @param[in] window The window that received the event. + * @param[in] codepoint The Unicode code point of the character. + * + * @sa @ref input_char + * @sa @ref glfwSetCharCallback + * + * @since Added in version 2.4. + * @glfw3 Added window handle parameter. + * + * @ingroup input + */ +typedef void (* GLFWcharfun)(GLFWwindow* window, unsigned int codepoint); + +/*! @brief The function pointer type for Unicode character with modifiers + * callbacks. + * + * This is the function pointer type for Unicode character with modifiers + * callbacks. It is called for each input character, regardless of what + * modifier keys are held down. A Unicode character with modifiers callback + * function has the following signature: + * @code + * void function_name(GLFWwindow* window, unsigned int codepoint, int mods) + * @endcode + * + * @param[in] window The window that received the event. + * @param[in] codepoint The Unicode code point of the character. + * @param[in] mods Bit field describing which [modifier keys](@ref mods) were + * held down. + * + * @sa @ref input_char + * @sa @ref glfwSetCharModsCallback + * + * @deprecated Scheduled for removal in version 4.0. + * + * @since Added in version 3.1. + * + * @ingroup input + */ +typedef void (* GLFWcharmodsfun)(GLFWwindow* window, unsigned int codepoint, int mods); + +/*! @brief The function pointer type for path drop callbacks. + * + * This is the function pointer type for path drop callbacks. A path drop + * callback function has the following signature: + * @code + * void function_name(GLFWwindow* window, int path_count, const char* paths[]) + * @endcode + * + * @param[in] window The window that received the event. + * @param[in] path_count The number of dropped paths. + * @param[in] paths The UTF-8 encoded file and/or directory path names. + * + * @pointer_lifetime The path array and its strings are valid until the + * callback function returns. + * + * @sa @ref path_drop + * @sa @ref glfwSetDropCallback + * + * @since Added in version 3.1. + * + * @ingroup input + */ +typedef void (* GLFWdropfun)(GLFWwindow* window, int path_count, const char* paths[]); + +/*! @brief The function pointer type for monitor configuration callbacks. + * + * This is the function pointer type for monitor configuration callbacks. + * A monitor callback function has the following signature: + * @code + * void function_name(GLFWmonitor* monitor, int event) + * @endcode + * + * @param[in] monitor The monitor that was connected or disconnected. + * @param[in] event One of `GLFW_CONNECTED` or `GLFW_DISCONNECTED`. Future + * releases may add more events. + * + * @sa @ref monitor_event + * @sa @ref glfwSetMonitorCallback + * + * @since Added in version 3.0. + * + * @ingroup monitor + */ +typedef void (* GLFWmonitorfun)(GLFWmonitor* monitor, int event); + +/*! @brief The function pointer type for joystick configuration callbacks. + * + * This is the function pointer type for joystick configuration callbacks. + * A joystick configuration callback function has the following signature: + * @code + * void function_name(int jid, int event) + * @endcode + * + * @param[in] jid The joystick that was connected or disconnected. + * @param[in] event One of `GLFW_CONNECTED` or `GLFW_DISCONNECTED`. Future + * releases may add more events. + * + * @sa @ref joystick_event + * @sa @ref glfwSetJoystickCallback + * + * @since Added in version 3.2. + * + * @ingroup input + */ +typedef void (* GLFWjoystickfun)(int jid, int event); + +/*! @brief Video mode type. + * + * This describes a single video mode. + * + * @sa @ref monitor_modes + * @sa @ref glfwGetVideoMode + * @sa @ref glfwGetVideoModes + * + * @since Added in version 1.0. + * @glfw3 Added refresh rate member. + * + * @ingroup monitor + */ +typedef struct GLFWvidmode +{ + /*! The width, in screen coordinates, of the video mode. + */ + int width; + /*! The height, in screen coordinates, of the video mode. + */ + int height; + /*! The bit depth of the red channel of the video mode. + */ + int redBits; + /*! The bit depth of the green channel of the video mode. + */ + int greenBits; + /*! The bit depth of the blue channel of the video mode. + */ + int blueBits; + /*! The refresh rate, in Hz, of the video mode. + */ + int refreshRate; +} GLFWvidmode; + +/*! @brief Gamma ramp. + * + * This describes the gamma ramp for a monitor. + * + * @sa @ref monitor_gamma + * @sa @ref glfwGetGammaRamp + * @sa @ref glfwSetGammaRamp + * + * @since Added in version 3.0. + * + * @ingroup monitor + */ +typedef struct GLFWgammaramp +{ + /*! An array of value describing the response of the red channel. + */ + unsigned short* red; + /*! An array of value describing the response of the green channel. + */ + unsigned short* green; + /*! An array of value describing the response of the blue channel. + */ + unsigned short* blue; + /*! The number of elements in each array. + */ + unsigned int size; +} GLFWgammaramp; + +/*! @brief Image data. + * + * This describes a single 2D image. See the documentation for each related + * function what the expected pixel format is. + * + * @sa @ref cursor_custom + * @sa @ref window_icon + * + * @since Added in version 2.1. + * @glfw3 Removed format and bytes-per-pixel members. + * + * @ingroup window + */ +typedef struct GLFWimage +{ + /*! The width, in pixels, of this image. + */ + int width; + /*! The height, in pixels, of this image. + */ + int height; + /*! The pixel data of this image, arranged left-to-right, top-to-bottom. + */ + unsigned char* pixels; +} GLFWimage; + +/*! @brief Gamepad input state + * + * This describes the input state of a gamepad. + * + * @sa @ref gamepad + * @sa @ref glfwGetGamepadState + * + * @since Added in version 3.3. + * + * @ingroup input + */ +typedef struct GLFWgamepadstate +{ + /*! The states of each [gamepad button](@ref gamepad_buttons), `GLFW_PRESS` + * or `GLFW_RELEASE`. + */ + unsigned char buttons[15]; + /*! The states of each [gamepad axis](@ref gamepad_axes), in the range -1.0 + * to 1.0 inclusive. + */ + float axes[6]; +} GLFWgamepadstate; + +/*! @brief Custom heap memory allocator. + * + * This describes a custom heap memory allocator for GLFW. To set an allocator, pass it + * to @ref glfwInitAllocator before initializing the library. + * + * @sa @ref init_allocator + * @sa @ref glfwInitAllocator + * + * @since Added in version 3.4. + * + * @ingroup init + */ +typedef struct GLFWallocator +{ + /*! The memory allocation function. See @ref GLFWallocatefun for details about + * allocation function. + */ + GLFWallocatefun allocate; + /*! The memory reallocation function. See @ref GLFWreallocatefun for details about + * reallocation function. + */ + GLFWreallocatefun reallocate; + /*! The memory deallocation function. See @ref GLFWdeallocatefun for details about + * deallocation function. + */ + GLFWdeallocatefun deallocate; + /*! The user pointer for this custom allocator. This value will be passed to the + * allocator functions. + */ + void* user; +} GLFWallocator; + + +/************************************************************************* + * GLFW API functions + *************************************************************************/ + +/*! @brief Initializes the GLFW library. + * + * This function initializes the GLFW library. Before most GLFW functions can + * be used, GLFW must be initialized, and before an application terminates GLFW + * should be terminated in order to free any resources allocated during or + * after initialization. + * + * If this function fails, it calls @ref glfwTerminate before returning. If it + * succeeds, you should call @ref glfwTerminate before the application exits. + * + * Additional calls to this function after successful initialization but before + * termination will return `GLFW_TRUE` immediately. + * + * The @ref GLFW_PLATFORM init hint controls which platforms are considered during + * initialization. This also depends on which platforms the library was compiled to + * support. + * + * @return `GLFW_TRUE` if successful, or `GLFW_FALSE` if an + * [error](@ref error_handling) occurred. + * + * @errors Possible errors include @ref GLFW_PLATFORM_UNAVAILABLE and @ref + * GLFW_PLATFORM_ERROR. + * + * @remark @macos This function will change the current directory of the + * application to the `Contents/Resources` subdirectory of the application's + * bundle, if present. This can be disabled with the @ref + * GLFW_COCOA_CHDIR_RESOURCES init hint. + * + * @remark @macos This function will create the main menu and dock icon for the + * application. If GLFW finds a `MainMenu.nib` it is loaded and assumed to + * contain a menu bar. Otherwise a minimal menu bar is created manually with + * common commands like Hide, Quit and About. The About entry opens a minimal + * about dialog with information from the application's bundle. The menu bar + * and dock icon can be disabled entirely with the @ref GLFW_COCOA_MENUBAR init + * hint. + * + * @remark __Wayland, X11:__ If the library was compiled with support for both + * Wayland and X11, and the @ref GLFW_PLATFORM init hint is set to + * `GLFW_ANY_PLATFORM`, the `XDG_SESSION_TYPE` environment variable affects + * which platform is picked. If the environment variable is not set, or is set + * to something other than `wayland` or `x11`, the regular detection mechanism + * will be used instead. + * + * @remark @x11 This function will set the `LC_CTYPE` category of the + * application locale according to the current environment if that category is + * still "C". This is because the "C" locale breaks Unicode text input. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref intro_init + * @sa @ref glfwInitHint + * @sa @ref glfwInitAllocator + * @sa @ref glfwTerminate + * + * @since Added in version 1.0. + * + * @ingroup init + */ +GLFWAPI int glfwInit(void); + +/*! @brief Terminates the GLFW library. + * + * This function destroys all remaining windows and cursors, restores any + * modified gamma ramps and frees any other allocated resources. Once this + * function is called, you must again call @ref glfwInit successfully before + * you will be able to use most GLFW functions. + * + * If GLFW has been successfully initialized, this function should be called + * before the application exits. If initialization fails, there is no need to + * call this function, as it is called by @ref glfwInit before it returns + * failure. + * + * This function has no effect if GLFW is not initialized. + * + * @errors Possible errors include @ref GLFW_PLATFORM_ERROR. + * + * @remark This function may be called before @ref glfwInit. + * + * @warning The contexts of any remaining windows must not be current on any + * other thread when this function is called. + * + * @reentrancy This function must not be called from a callback. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref intro_init + * @sa @ref glfwInit + * + * @since Added in version 1.0. + * + * @ingroup init + */ +GLFWAPI void glfwTerminate(void); + +/*! @brief Sets the specified init hint to the desired value. + * + * This function sets hints for the next initialization of GLFW. + * + * The values you set hints to are never reset by GLFW, but they only take + * effect during initialization. Once GLFW has been initialized, any values + * you set will be ignored until the library is terminated and initialized + * again. + * + * Some hints are platform specific. These may be set on any platform but they + * will only affect their specific platform. Other platforms will ignore them. + * Setting these hints requires no platform specific headers or functions. + * + * @param[in] hint The [init hint](@ref init_hints) to set. + * @param[in] value The new value of the init hint. + * + * @errors Possible errors include @ref GLFW_INVALID_ENUM and @ref + * GLFW_INVALID_VALUE. + * + * @remarks This function may be called before @ref glfwInit. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa init_hints + * @sa glfwInit + * + * @since Added in version 3.3. + * + * @ingroup init + */ +GLFWAPI void glfwInitHint(int hint, int value); + +/*! @brief Sets the init allocator to the desired value. + * + * To use the default allocator, call this function with a `NULL` argument. + * + * If you specify an allocator struct, every member must be a valid function + * pointer. If any member is `NULL`, this function will emit @ref + * GLFW_INVALID_VALUE and the init allocator will be unchanged. + * + * The functions in the allocator must fulfil a number of requirements. See the + * documentation for @ref GLFWallocatefun, @ref GLFWreallocatefun and @ref + * GLFWdeallocatefun for details. + * + * @param[in] allocator The allocator to use at the next initialization, or + * `NULL` to use the default one. + * + * @errors Possible errors include @ref GLFW_INVALID_VALUE. + * + * @pointer_lifetime The specified allocator is copied before this function + * returns. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref init_allocator + * @sa @ref glfwInit + * + * @since Added in version 3.4. + * + * @ingroup init + */ +GLFWAPI void glfwInitAllocator(const GLFWallocator* allocator); + +#if defined(VK_VERSION_1_0) + +/*! @brief Sets the desired Vulkan `vkGetInstanceProcAddr` function. + * + * This function sets the `vkGetInstanceProcAddr` function that GLFW will use for all + * Vulkan related entry point queries. + * + * This feature is mostly useful on macOS, if your copy of the Vulkan loader is in + * a location where GLFW cannot find it through dynamic loading, or if you are still + * using the static library version of the loader. + * + * If set to `NULL`, GLFW will try to load the Vulkan loader dynamically by its standard + * name and get this function from there. This is the default behavior. + * + * The standard name of the loader is `vulkan-1.dll` on Windows, `libvulkan.so.1` on + * Linux and other Unix-like systems and `libvulkan.1.dylib` on macOS. If your code is + * also loading it via these names then you probably don't need to use this function. + * + * The function address you set is never reset by GLFW, but it only takes effect during + * initialization. Once GLFW has been initialized, any updates will be ignored until the + * library is terminated and initialized again. + * + * @param[in] loader The address of the function to use, or `NULL`. + * + * @par Loader function signature + * @code + * PFN_vkVoidFunction vkGetInstanceProcAddr(VkInstance instance, const char* name) + * @endcode + * For more information about this function, see the + * [Vulkan Registry](https://www.khronos.org/registry/vulkan/). + * + * @errors None. + * + * @remark This function may be called before @ref glfwInit. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref vulkan_loader + * @sa @ref glfwInit + * + * @since Added in version 3.4. + * + * @ingroup init + */ +GLFWAPI void glfwInitVulkanLoader(PFN_vkGetInstanceProcAddr loader); + +#endif /*VK_VERSION_1_0*/ + +/*! @brief Retrieves the version of the GLFW library. + * + * This function retrieves the major, minor and revision numbers of the GLFW + * library. It is intended for when you are using GLFW as a shared library and + * want to ensure that you are using the minimum required version. + * + * Any or all of the version arguments may be `NULL`. + * + * @param[out] major Where to store the major version number, or `NULL`. + * @param[out] minor Where to store the minor version number, or `NULL`. + * @param[out] rev Where to store the revision number, or `NULL`. + * + * @errors None. + * + * @remark This function may be called before @ref glfwInit. + * + * @thread_safety This function may be called from any thread. + * + * @sa @ref intro_version + * @sa @ref glfwGetVersionString + * + * @since Added in version 1.0. + * + * @ingroup init + */ +GLFWAPI void glfwGetVersion(int* major, int* minor, int* rev); + +/*! @brief Returns a string describing the compile-time configuration. + * + * This function returns the compile-time generated + * [version string](@ref intro_version_string) of the GLFW library binary. It describes + * the version, platforms, compiler and any platform or operating system specific + * compile-time options. It should not be confused with the OpenGL or OpenGL ES version + * string, queried with `glGetString`. + * + * __Do not use the version string__ to parse the GLFW library version. The + * @ref glfwGetVersion function provides the version of the running library + * binary in numerical format. + * + * __Do not use the version string__ to parse what platforms are supported. The @ref + * glfwPlatformSupported function lets you query platform support. + * + * @return The ASCII encoded GLFW version string. + * + * @errors None. + * + * @remark This function may be called before @ref glfwInit. + * + * @pointer_lifetime The returned string is static and compile-time generated. + * + * @thread_safety This function may be called from any thread. + * + * @sa @ref intro_version + * @sa @ref glfwGetVersion + * + * @since Added in version 3.0. + * + * @ingroup init + */ +GLFWAPI const char* glfwGetVersionString(void); + +/*! @brief Returns and clears the last error for the calling thread. + * + * This function returns and clears the [error code](@ref errors) of the last + * error that occurred on the calling thread, and optionally a UTF-8 encoded + * human-readable description of it. If no error has occurred since the last + * call, it returns @ref GLFW_NO_ERROR (zero) and the description pointer is + * set to `NULL`. + * + * @param[in] description Where to store the error description pointer, or `NULL`. + * @return The last error code for the calling thread, or @ref GLFW_NO_ERROR + * (zero). + * + * @errors None. + * + * @pointer_lifetime The returned string is allocated and freed by GLFW. You + * should not free it yourself. It is guaranteed to be valid only until the + * next error occurs or the library is terminated. + * + * @remark This function may be called before @ref glfwInit. + * + * @thread_safety This function may be called from any thread. + * + * @sa @ref error_handling + * @sa @ref glfwSetErrorCallback + * + * @since Added in version 3.3. + * + * @ingroup init + */ +GLFWAPI int glfwGetError(const char** description); + +/*! @brief Sets the error callback. + * + * This function sets the error callback, which is called with an error code + * and a human-readable description each time a GLFW error occurs. + * + * The error code is set before the callback is called. Calling @ref + * glfwGetError from the error callback will return the same value as the error + * code argument. + * + * The error callback is called on the thread where the error occurred. If you + * are using GLFW from multiple threads, your error callback needs to be + * written accordingly. + * + * Because the description string may have been generated specifically for that + * error, it is not guaranteed to be valid after the callback has returned. If + * you wish to use it after the callback returns, you need to make a copy. + * + * Once set, the error callback remains set even after the library has been + * terminated. + * + * @param[in] callback The new callback, or `NULL` to remove the currently set + * callback. + * @return The previously set callback, or `NULL` if no callback was set. + * + * @callback_signature + * @code + * void callback_name(int error_code, const char* description) + * @endcode + * For more information about the callback parameters, see the + * [callback pointer type](@ref GLFWerrorfun). + * + * @errors None. + * + * @remark This function may be called before @ref glfwInit. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref error_handling + * @sa @ref glfwGetError + * + * @since Added in version 3.0. + * + * @ingroup init + */ +GLFWAPI GLFWerrorfun glfwSetErrorCallback(GLFWerrorfun callback); + +/*! @brief Returns the currently selected platform. + * + * This function returns the platform that was selected during initialization. The + * returned value will be one of `GLFW_PLATFORM_WIN32`, `GLFW_PLATFORM_COCOA`, + * `GLFW_PLATFORM_WAYLAND`, `GLFW_PLATFORM_X11` or `GLFW_PLATFORM_NULL`. + * + * @return The currently selected platform, or zero if an error occurred. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED. + * + * @thread_safety This function may be called from any thread. + * + * @sa @ref platform + * @sa @ref glfwPlatformSupported + * + * @since Added in version 3.4. + * + * @ingroup init + */ +GLFWAPI int glfwGetPlatform(void); + +/*! @brief Returns whether the library includes support for the specified platform. + * + * This function returns whether the library was compiled with support for the specified + * platform. The platform must be one of `GLFW_PLATFORM_WIN32`, `GLFW_PLATFORM_COCOA`, + * `GLFW_PLATFORM_WAYLAND`, `GLFW_PLATFORM_X11` or `GLFW_PLATFORM_NULL`. + * + * @param[in] platform The platform to query. + * @return `GLFW_TRUE` if the platform is supported, or `GLFW_FALSE` otherwise. + * + * @errors Possible errors include @ref GLFW_INVALID_ENUM. + * + * @remark This function may be called before @ref glfwInit. + * + * @thread_safety This function may be called from any thread. + * + * @sa @ref platform + * @sa @ref glfwGetPlatform + * + * @since Added in version 3.4. + * + * @ingroup init + */ +GLFWAPI int glfwPlatformSupported(int platform); + +/*! @brief Returns the currently connected monitors. + * + * This function returns an array of handles for all currently connected + * monitors. The primary monitor is always first in the returned array. If no + * monitors were found, this function returns `NULL`. + * + * @param[out] count Where to store the number of monitors in the returned + * array. This is set to zero if an error occurred. + * @return An array of monitor handles, or `NULL` if no monitors were found or + * if an [error](@ref error_handling) occurred. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED. + * + * @pointer_lifetime The returned array is allocated and freed by GLFW. You + * should not free it yourself. It is guaranteed to be valid only until the + * monitor configuration changes or the library is terminated. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref monitor_monitors + * @sa @ref monitor_event + * @sa @ref glfwGetPrimaryMonitor + * + * @since Added in version 3.0. + * + * @ingroup monitor + */ +GLFWAPI GLFWmonitor** glfwGetMonitors(int* count); + +/*! @brief Returns the primary monitor. + * + * This function returns the primary monitor. This is usually the monitor + * where elements like the task bar or global menu bar are located. + * + * @return The primary monitor, or `NULL` if no monitors were found or if an + * [error](@ref error_handling) occurred. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED. + * + * @thread_safety This function must only be called from the main thread. + * + * @remark The primary monitor is always first in the array returned by @ref + * glfwGetMonitors. + * + * @sa @ref monitor_monitors + * @sa @ref glfwGetMonitors + * + * @since Added in version 3.0. + * + * @ingroup monitor + */ +GLFWAPI GLFWmonitor* glfwGetPrimaryMonitor(void); + +/*! @brief Returns the position of the monitor's viewport on the virtual screen. + * + * This function returns the position, in screen coordinates, of the upper-left + * corner of the specified monitor. + * + * Any or all of the position arguments may be `NULL`. If an error occurs, all + * non-`NULL` position arguments will be set to zero. + * + * @param[in] monitor The monitor to query. + * @param[out] xpos Where to store the monitor x-coordinate, or `NULL`. + * @param[out] ypos Where to store the monitor y-coordinate, or `NULL`. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref + * GLFW_PLATFORM_ERROR. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref monitor_properties + * + * @since Added in version 3.0. + * + * @ingroup monitor + */ +GLFWAPI void glfwGetMonitorPos(GLFWmonitor* monitor, int* xpos, int* ypos); + +/*! @brief Retrieves the work area of the monitor. + * + * This function returns the position, in screen coordinates, of the upper-left + * corner of the work area of the specified monitor along with the work area + * size in screen coordinates. The work area is defined as the area of the + * monitor not occluded by the window system task bar where present. If no + * task bar exists then the work area is the monitor resolution in screen + * coordinates. + * + * Any or all of the position and size arguments may be `NULL`. If an error + * occurs, all non-`NULL` position and size arguments will be set to zero. + * + * @param[in] monitor The monitor to query. + * @param[out] xpos Where to store the monitor x-coordinate, or `NULL`. + * @param[out] ypos Where to store the monitor y-coordinate, or `NULL`. + * @param[out] width Where to store the monitor width, or `NULL`. + * @param[out] height Where to store the monitor height, or `NULL`. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref + * GLFW_PLATFORM_ERROR. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref monitor_workarea + * + * @since Added in version 3.3. + * + * @ingroup monitor + */ +GLFWAPI void glfwGetMonitorWorkarea(GLFWmonitor* monitor, int* xpos, int* ypos, int* width, int* height); + +/*! @brief Returns the physical size of the monitor. + * + * This function returns the size, in millimetres, of the display area of the + * specified monitor. + * + * Some platforms do not provide accurate monitor size information, either + * because the monitor [EDID][] data is incorrect or because the driver does + * not report it accurately. + * + * [EDID]: https://en.wikipedia.org/wiki/Extended_display_identification_data + * + * Any or all of the size arguments may be `NULL`. If an error occurs, all + * non-`NULL` size arguments will be set to zero. + * + * @param[in] monitor The monitor to query. + * @param[out] widthMM Where to store the width, in millimetres, of the + * monitor's display area, or `NULL`. + * @param[out] heightMM Where to store the height, in millimetres, of the + * monitor's display area, or `NULL`. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED. + * + * @remark @win32 On Windows 8 and earlier the physical size is calculated from + * the current resolution and system DPI instead of querying the monitor EDID data. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref monitor_properties + * + * @since Added in version 3.0. + * + * @ingroup monitor + */ +GLFWAPI void glfwGetMonitorPhysicalSize(GLFWmonitor* monitor, int* widthMM, int* heightMM); + +/*! @brief Retrieves the content scale for the specified monitor. + * + * This function retrieves the content scale for the specified monitor. The + * content scale is the ratio between the current DPI and the platform's + * default DPI. This is especially important for text and any UI elements. If + * the pixel dimensions of your UI scaled by this look appropriate on your + * machine then it should appear at a reasonable size on other machines + * regardless of their DPI and scaling settings. This relies on the system DPI + * and scaling settings being somewhat correct. + * + * The content scale may depend on both the monitor resolution and pixel + * density and on user settings. It may be very different from the raw DPI + * calculated from the physical size and current resolution. + * + * @param[in] monitor The monitor to query. + * @param[out] xscale Where to store the x-axis content scale, or `NULL`. + * @param[out] yscale Where to store the y-axis content scale, or `NULL`. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref + * GLFW_PLATFORM_ERROR. + * + * @remark @wayland Fractional scaling information is not yet available for + * monitors, so this function only returns integer content scales. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref monitor_scale + * @sa @ref glfwGetWindowContentScale + * + * @since Added in version 3.3. + * + * @ingroup monitor + */ +GLFWAPI void glfwGetMonitorContentScale(GLFWmonitor* monitor, float* xscale, float* yscale); + +/*! @brief Returns the name of the specified monitor. + * + * This function returns a human-readable name, encoded as UTF-8, of the + * specified monitor. The name typically reflects the make and model of the + * monitor and is not guaranteed to be unique among the connected monitors. + * + * @param[in] monitor The monitor to query. + * @return The UTF-8 encoded name of the monitor, or `NULL` if an + * [error](@ref error_handling) occurred. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED. + * + * @pointer_lifetime The returned string is allocated and freed by GLFW. You + * should not free it yourself. It is valid until the specified monitor is + * disconnected or the library is terminated. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref monitor_properties + * + * @since Added in version 3.0. + * + * @ingroup monitor + */ +GLFWAPI const char* glfwGetMonitorName(GLFWmonitor* monitor); + +/*! @brief Sets the user pointer of the specified monitor. + * + * This function sets the user-defined pointer of the specified monitor. The + * current value is retained until the monitor is disconnected. The initial + * value is `NULL`. + * + * This function may be called from the monitor callback, even for a monitor + * that is being disconnected. + * + * @param[in] monitor The monitor whose pointer to set. + * @param[in] pointer The new value. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED. + * + * @thread_safety This function may be called from any thread. Access is not + * synchronized. + * + * @sa @ref monitor_userptr + * @sa @ref glfwGetMonitorUserPointer + * + * @since Added in version 3.3. + * + * @ingroup monitor + */ +GLFWAPI void glfwSetMonitorUserPointer(GLFWmonitor* monitor, void* pointer); + +/*! @brief Returns the user pointer of the specified monitor. + * + * This function returns the current value of the user-defined pointer of the + * specified monitor. The initial value is `NULL`. + * + * This function may be called from the monitor callback, even for a monitor + * that is being disconnected. + * + * @param[in] monitor The monitor whose pointer to return. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED. + * + * @thread_safety This function may be called from any thread. Access is not + * synchronized. + * + * @sa @ref monitor_userptr + * @sa @ref glfwSetMonitorUserPointer + * + * @since Added in version 3.3. + * + * @ingroup monitor + */ +GLFWAPI void* glfwGetMonitorUserPointer(GLFWmonitor* monitor); + +/*! @brief Sets the monitor configuration callback. + * + * This function sets the monitor configuration callback, or removes the + * currently set callback. This is called when a monitor is connected to or + * disconnected from the system. + * + * @param[in] callback The new callback, or `NULL` to remove the currently set + * callback. + * @return The previously set callback, or `NULL` if no callback was set or the + * library had not been [initialized](@ref intro_init). + * + * @callback_signature + * @code + * void function_name(GLFWmonitor* monitor, int event) + * @endcode + * For more information about the callback parameters, see the + * [function pointer type](@ref GLFWmonitorfun). + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref monitor_event + * + * @since Added in version 3.0. + * + * @ingroup monitor + */ +GLFWAPI GLFWmonitorfun glfwSetMonitorCallback(GLFWmonitorfun callback); + +/*! @brief Returns the available video modes for the specified monitor. + * + * This function returns an array of all video modes supported by the specified + * monitor. The returned array is sorted in ascending order, first by color + * bit depth (the sum of all channel depths), then by resolution area (the + * product of width and height), then resolution width and finally by refresh + * rate. + * + * @param[in] monitor The monitor to query. + * @param[out] count Where to store the number of video modes in the returned + * array. This is set to zero if an error occurred. + * @return An array of video modes, or `NULL` if an + * [error](@ref error_handling) occurred. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref + * GLFW_PLATFORM_ERROR. + * + * @pointer_lifetime The returned array is allocated and freed by GLFW. You + * should not free it yourself. It is valid until the specified monitor is + * disconnected, this function is called again for that monitor or the library + * is terminated. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref monitor_modes + * @sa @ref glfwGetVideoMode + * + * @since Added in version 1.0. + * @glfw3 Changed to return an array of modes for a specific monitor. + * + * @ingroup monitor + */ +GLFWAPI const GLFWvidmode* glfwGetVideoModes(GLFWmonitor* monitor, int* count); + +/*! @brief Returns the current mode of the specified monitor. + * + * This function returns the current video mode of the specified monitor. If + * you have created a full screen window for that monitor, the return value + * will depend on whether that window is iconified. + * + * @param[in] monitor The monitor to query. + * @return The current mode of the monitor, or `NULL` if an + * [error](@ref error_handling) occurred. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref + * GLFW_PLATFORM_ERROR. + * + * @pointer_lifetime The returned array is allocated and freed by GLFW. You + * should not free it yourself. It is valid until the specified monitor is + * disconnected or the library is terminated. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref monitor_modes + * @sa @ref glfwGetVideoModes + * + * @since Added in version 3.0. Replaces `glfwGetDesktopMode`. + * + * @ingroup monitor + */ +GLFWAPI const GLFWvidmode* glfwGetVideoMode(GLFWmonitor* monitor); + +/*! @brief Generates a gamma ramp and sets it for the specified monitor. + * + * This function generates an appropriately sized gamma ramp from the specified + * exponent and then calls @ref glfwSetGammaRamp with it. The value must be + * a finite number greater than zero. + * + * The software controlled gamma ramp is applied _in addition_ to the hardware + * gamma correction, which today is usually an approximation of sRGB gamma. + * This means that setting a perfectly linear ramp, or gamma 1.0, will produce + * the default (usually sRGB-like) behavior. + * + * For gamma correct rendering with OpenGL or OpenGL ES, see the @ref + * GLFW_SRGB_CAPABLE hint. + * + * @param[in] monitor The monitor whose gamma ramp to set. + * @param[in] gamma The desired exponent. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED, @ref GLFW_INVALID_VALUE, + * @ref GLFW_PLATFORM_ERROR and @ref GLFW_FEATURE_UNAVAILABLE (see remarks). + * + * @remark @wayland Gamma handling is a privileged protocol, this function + * will thus never be implemented and emits @ref GLFW_FEATURE_UNAVAILABLE. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref monitor_gamma + * + * @since Added in version 3.0. + * + * @ingroup monitor + */ +GLFWAPI void glfwSetGamma(GLFWmonitor* monitor, float gamma); + +/*! @brief Returns the current gamma ramp for the specified monitor. + * + * This function returns the current gamma ramp of the specified monitor. + * + * @param[in] monitor The monitor to query. + * @return The current gamma ramp, or `NULL` if an + * [error](@ref error_handling) occurred. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED, @ref GLFW_PLATFORM_ERROR + * and @ref GLFW_FEATURE_UNAVAILABLE (see remarks). + * + * @remark @wayland Gamma handling is a privileged protocol, this function + * will thus never be implemented and emits @ref GLFW_FEATURE_UNAVAILABLE while + * returning `NULL`. + * + * @pointer_lifetime The returned structure and its arrays are allocated and + * freed by GLFW. You should not free them yourself. They are valid until the + * specified monitor is disconnected, this function is called again for that + * monitor or the library is terminated. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref monitor_gamma + * + * @since Added in version 3.0. + * + * @ingroup monitor + */ +GLFWAPI const GLFWgammaramp* glfwGetGammaRamp(GLFWmonitor* monitor); + +/*! @brief Sets the current gamma ramp for the specified monitor. + * + * This function sets the current gamma ramp for the specified monitor. The + * original gamma ramp for that monitor is saved by GLFW the first time this + * function is called and is restored by @ref glfwTerminate. + * + * The software controlled gamma ramp is applied _in addition_ to the hardware + * gamma correction, which today is usually an approximation of sRGB gamma. + * This means that setting a perfectly linear ramp, or gamma 1.0, will produce + * the default (usually sRGB-like) behavior. + * + * For gamma correct rendering with OpenGL or OpenGL ES, see the @ref + * GLFW_SRGB_CAPABLE hint. + * + * @param[in] monitor The monitor whose gamma ramp to set. + * @param[in] ramp The gamma ramp to use. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED, @ref GLFW_PLATFORM_ERROR + * and @ref GLFW_FEATURE_UNAVAILABLE (see remarks). + * + * @remark The size of the specified gamma ramp should match the size of the + * current ramp for that monitor. + * + * @remark @win32 The gamma ramp size must be 256. + * + * @remark @wayland Gamma handling is a privileged protocol, this function + * will thus never be implemented and emits @ref GLFW_FEATURE_UNAVAILABLE. + * + * @pointer_lifetime The specified gamma ramp is copied before this function + * returns. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref monitor_gamma + * + * @since Added in version 3.0. + * + * @ingroup monitor + */ +GLFWAPI void glfwSetGammaRamp(GLFWmonitor* monitor, const GLFWgammaramp* ramp); + +/*! @brief Resets all window hints to their default values. + * + * This function resets all window hints to their + * [default values](@ref window_hints_values). + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref window_hints + * @sa @ref glfwWindowHint + * @sa @ref glfwWindowHintString + * + * @since Added in version 3.0. + * + * @ingroup window + */ +GLFWAPI void glfwDefaultWindowHints(void); + +/*! @brief Sets the specified window hint to the desired value. + * + * This function sets hints for the next call to @ref glfwCreateWindow. The + * hints, once set, retain their values until changed by a call to this + * function or @ref glfwDefaultWindowHints, or until the library is terminated. + * + * Only integer value hints can be set with this function. String value hints + * are set with @ref glfwWindowHintString. + * + * This function does not check whether the specified hint values are valid. + * If you set hints to invalid values this will instead be reported by the next + * call to @ref glfwCreateWindow. + * + * Some hints are platform specific. These may be set on any platform but they + * will only affect their specific platform. Other platforms will ignore them. + * Setting these hints requires no platform specific headers or functions. + * + * @param[in] hint The [window hint](@ref window_hints) to set. + * @param[in] value The new value of the window hint. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref + * GLFW_INVALID_ENUM. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref window_hints + * @sa @ref glfwWindowHintString + * @sa @ref glfwDefaultWindowHints + * + * @since Added in version 3.0. Replaces `glfwOpenWindowHint`. + * + * @ingroup window + */ +GLFWAPI void glfwWindowHint(int hint, int value); + +/*! @brief Sets the specified window hint to the desired value. + * + * This function sets hints for the next call to @ref glfwCreateWindow. The + * hints, once set, retain their values until changed by a call to this + * function or @ref glfwDefaultWindowHints, or until the library is terminated. + * + * Only string type hints can be set with this function. Integer value hints + * are set with @ref glfwWindowHint. + * + * This function does not check whether the specified hint values are valid. + * If you set hints to invalid values this will instead be reported by the next + * call to @ref glfwCreateWindow. + * + * Some hints are platform specific. These may be set on any platform but they + * will only affect their specific platform. Other platforms will ignore them. + * Setting these hints requires no platform specific headers or functions. + * + * @param[in] hint The [window hint](@ref window_hints) to set. + * @param[in] value The new value of the window hint. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref + * GLFW_INVALID_ENUM. + * + * @pointer_lifetime The specified string is copied before this function + * returns. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref window_hints + * @sa @ref glfwWindowHint + * @sa @ref glfwDefaultWindowHints + * + * @since Added in version 3.3. + * + * @ingroup window + */ +GLFWAPI void glfwWindowHintString(int hint, const char* value); + +/*! @brief Creates a window and its associated context. + * + * This function creates a window and its associated OpenGL or OpenGL ES + * context. Most of the options controlling how the window and its context + * should be created are specified with [window hints](@ref window_hints). + * + * Successful creation does not change which context is current. Before you + * can use the newly created context, you need to + * [make it current](@ref context_current). For information about the `share` + * parameter, see @ref context_sharing. + * + * The created window, framebuffer and context may differ from what you + * requested, as not all parameters and hints are + * [hard constraints](@ref window_hints_hard). This includes the size of the + * window, especially for full screen windows. To query the actual attributes + * of the created window, framebuffer and context, see @ref + * glfwGetWindowAttrib, @ref glfwGetWindowSize and @ref glfwGetFramebufferSize. + * + * To create a full screen window, you need to specify the monitor the window + * will cover. If no monitor is specified, the window will be windowed mode. + * Unless you have a way for the user to choose a specific monitor, it is + * recommended that you pick the primary monitor. For more information on how + * to query connected monitors, see @ref monitor_monitors. + * + * For full screen windows, the specified size becomes the resolution of the + * window's _desired video mode_. As long as a full screen window is not + * iconified, the supported video mode most closely matching the desired video + * mode is set for the specified monitor. For more information about full + * screen windows, including the creation of so called _windowed full screen_ + * or _borderless full screen_ windows, see @ref window_windowed_full_screen. + * + * Once you have created the window, you can switch it between windowed and + * full screen mode with @ref glfwSetWindowMonitor. This will not affect its + * OpenGL or OpenGL ES context. + * + * By default, newly created windows use the placement recommended by the + * window system. To create the window at a specific position, set the @ref + * GLFW_POSITION_X and @ref GLFW_POSITION_Y window hints before creation. To + * restore the default behavior, set either or both hints back to + * `GLFW_ANY_POSITION`. + * + * As long as at least one full screen window is not iconified, the screensaver + * is prohibited from starting. + * + * Window systems put limits on window sizes. Very large or very small window + * dimensions may be overridden by the window system on creation. Check the + * actual [size](@ref window_size) after creation. + * + * The [swap interval](@ref buffer_swap) is not set during window creation and + * the initial value may vary depending on driver settings and defaults. + * + * @param[in] width The desired width, in screen coordinates, of the window. + * This must be greater than zero. + * @param[in] height The desired height, in screen coordinates, of the window. + * This must be greater than zero. + * @param[in] title The initial, UTF-8 encoded window title. + * @param[in] monitor The monitor to use for full screen mode, or `NULL` for + * windowed mode. + * @param[in] share The window whose context to share resources with, or `NULL` + * to not share resources. + * @return The handle of the created window, or `NULL` if an + * [error](@ref error_handling) occurred. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED, @ref + * GLFW_INVALID_ENUM, @ref GLFW_INVALID_VALUE, @ref GLFW_API_UNAVAILABLE, @ref + * GLFW_VERSION_UNAVAILABLE, @ref GLFW_FORMAT_UNAVAILABLE, @ref + * GLFW_NO_WINDOW_CONTEXT and @ref GLFW_PLATFORM_ERROR. + * + * @remark @win32 Window creation will fail if the Microsoft GDI software + * OpenGL implementation is the only one available. + * + * @remark @win32 If the executable has an icon resource named `GLFW_ICON,` it + * will be set as the initial icon for the window. If no such icon is present, + * the `IDI_APPLICATION` icon will be used instead. To set a different icon, + * see @ref glfwSetWindowIcon. + * + * @remark @win32 The context to share resources with must not be current on + * any other thread. + * + * @remark @macos The OS only supports core profile contexts for OpenGL + * versions 3.2 and later. Before creating an OpenGL context of version 3.2 or + * later you must set the [GLFW_OPENGL_PROFILE](@ref GLFW_OPENGL_PROFILE_hint) + * hint accordingly. OpenGL 3.0 and 3.1 contexts are not supported at all + * on macOS. + * + * @remark @macos The GLFW window has no icon, as it is not a document + * window, but the dock icon will be the same as the application bundle's icon. + * For more information on bundles, see the + * [Bundle Programming Guide][bundle-guide] in the Mac Developer Library. + * + * [bundle-guide]: https://developer.apple.com/library/mac/documentation/CoreFoundation/Conceptual/CFBundles/ + * + * @remark @macos On OS X 10.10 and later the window frame will not be rendered + * at full resolution on Retina displays unless the + * [GLFW_SCALE_FRAMEBUFFER](@ref GLFW_SCALE_FRAMEBUFFER_hint) + * hint is `GLFW_TRUE` and the `NSHighResolutionCapable` key is enabled in the + * application bundle's `Info.plist`. For more information, see + * [High Resolution Guidelines for OS X][hidpi-guide] in the Mac Developer + * Library. The GLFW test and example programs use a custom `Info.plist` + * template for this, which can be found as `CMake/Info.plist.in` in the source + * tree. + * + * [hidpi-guide]: https://developer.apple.com/library/mac/documentation/GraphicsAnimation/Conceptual/HighResolutionOSX/Explained/Explained.html + * + * @remark @macos When activating frame autosaving with + * [GLFW_COCOA_FRAME_NAME](@ref GLFW_COCOA_FRAME_NAME_hint), the specified + * window size and position may be overridden by previously saved values. + * + * @remark @wayland GLFW uses [libdecor][] where available to create its window + * decorations. This in turn uses server-side XDG decorations where available + * and provides high quality client-side decorations on compositors like GNOME. + * If both XDG decorations and libdecor are unavailable, GLFW falls back to + * a very simple set of window decorations that only support moving, resizing + * and the window manager's right-click menu. + * + * [libdecor]: https://gitlab.freedesktop.org/libdecor/libdecor + * + * @remark @x11 Some window managers will not respect the placement of + * initially hidden windows. + * + * @remark @x11 Due to the asynchronous nature of X11, it may take a moment for + * a window to reach its requested state. This means you may not be able to + * query the final size, position or other attributes directly after window + * creation. + * + * @remark @x11 The class part of the `WM_CLASS` window property will by + * default be set to the window title passed to this function. The instance + * part will use the contents of the `RESOURCE_NAME` environment variable, if + * present and not empty, or fall back to the window title. Set the + * [GLFW_X11_CLASS_NAME](@ref GLFW_X11_CLASS_NAME_hint) and + * [GLFW_X11_INSTANCE_NAME](@ref GLFW_X11_INSTANCE_NAME_hint) window hints to + * override this. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref window_creation + * @sa @ref glfwDestroyWindow + * + * @since Added in version 3.0. Replaces `glfwOpenWindow`. + * + * @ingroup window + */ +GLFWAPI GLFWwindow* glfwCreateWindow(int width, int height, const char* title, GLFWmonitor* monitor, GLFWwindow* share); + +/*! @brief Destroys the specified window and its context. + * + * This function destroys the specified window and its context. On calling + * this function, no further callbacks will be called for that window. + * + * If the context of the specified window is current on the main thread, it is + * detached before being destroyed. + * + * @param[in] window The window to destroy. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref + * GLFW_PLATFORM_ERROR. + * + * @note The context of the specified window must not be current on any other + * thread when this function is called. + * + * @reentrancy This function must not be called from a callback. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref window_creation + * @sa @ref glfwCreateWindow + * + * @since Added in version 3.0. Replaces `glfwCloseWindow`. + * + * @ingroup window + */ +GLFWAPI void glfwDestroyWindow(GLFWwindow* window); + +/*! @brief Checks the close flag of the specified window. + * + * This function returns the value of the close flag of the specified window. + * + * @param[in] window The window to query. + * @return The value of the close flag. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED. + * + * @thread_safety This function may be called from any thread. Access is not + * synchronized. + * + * @sa @ref window_close + * + * @since Added in version 3.0. + * + * @ingroup window + */ +GLFWAPI int glfwWindowShouldClose(GLFWwindow* window); + +/*! @brief Sets the close flag of the specified window. + * + * This function sets the value of the close flag of the specified window. + * This can be used to override the user's attempt to close the window, or + * to signal that it should be closed. + * + * @param[in] window The window whose flag to change. + * @param[in] value The new value. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED. + * + * @thread_safety This function may be called from any thread. Access is not + * synchronized. + * + * @sa @ref window_close + * + * @since Added in version 3.0. + * + * @ingroup window + */ +GLFWAPI void glfwSetWindowShouldClose(GLFWwindow* window, int value); + +/*! @brief Returns the title of the specified window. + * + * This function returns the window title, encoded as UTF-8, of the specified + * window. This is the title set previously by @ref glfwCreateWindow + * or @ref glfwSetWindowTitle. + * + * @param[in] window The window to query. + * @return The UTF-8 encoded window title, or `NULL` if an + * [error](@ref error_handling) occurred. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED. + * + * @remark The returned title is currently a copy of the title last set by @ref + * glfwCreateWindow or @ref glfwSetWindowTitle. It does not include any + * additional text which may be appended by the platform or another program. + * + * @pointer_lifetime The returned string is allocated and freed by GLFW. You + * should not free it yourself. It is valid until the next call to @ref + * glfwGetWindowTitle or @ref glfwSetWindowTitle, or until the library is + * terminated. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref window_title + * @sa @ref glfwSetWindowTitle + * + * @since Added in version 3.4. + * + * @ingroup window + */ +GLFWAPI const char* glfwGetWindowTitle(GLFWwindow* window); + +/*! @brief Sets the title of the specified window. + * + * This function sets the window title, encoded as UTF-8, of the specified + * window. + * + * @param[in] window The window whose title to change. + * @param[in] title The UTF-8 encoded window title. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref + * GLFW_PLATFORM_ERROR. + * + * @remark @macos The window title will not be updated until the next time you + * process events. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref window_title + * @sa @ref glfwGetWindowTitle + * + * @since Added in version 1.0. + * @glfw3 Added window handle parameter. + * + * @ingroup window + */ +GLFWAPI void glfwSetWindowTitle(GLFWwindow* window, const char* title); + +/*! @brief Sets the icon for the specified window. + * + * This function sets the icon of the specified window. If passed an array of + * candidate images, those of or closest to the sizes desired by the system are + * selected. If no images are specified, the window reverts to its default + * icon. + * + * The pixels are 32-bit, little-endian, non-premultiplied RGBA, i.e. eight + * bits per channel with the red channel first. They are arranged canonically + * as packed sequential rows, starting from the top-left corner. + * + * The desired image sizes varies depending on platform and system settings. + * The selected images will be rescaled as needed. Good sizes include 16x16, + * 32x32 and 48x48. + * + * @param[in] window The window whose icon to set. + * @param[in] count The number of images in the specified array, or zero to + * revert to the default window icon. + * @param[in] images The images to create the icon from. This is ignored if + * count is zero. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED, @ref + * GLFW_INVALID_VALUE, @ref GLFW_PLATFORM_ERROR and @ref + * GLFW_FEATURE_UNAVAILABLE (see remarks). + * + * @pointer_lifetime The specified image data is copied before this function + * returns. + * + * @remark @macos Regular windows do not have icons on macOS. This function + * will emit @ref GLFW_FEATURE_UNAVAILABLE. The dock icon will be the same as + * the application bundle's icon. For more information on bundles, see the + * [Bundle Programming Guide][bundle-guide] in the Mac Developer Library. + * + * [bundle-guide]: https://developer.apple.com/library/mac/documentation/CoreFoundation/Conceptual/CFBundles/ + * + * @remark @wayland There is no existing protocol to change an icon, the + * window will thus inherit the one defined in the application's desktop file. + * This function will emit @ref GLFW_FEATURE_UNAVAILABLE. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref window_icon + * + * @since Added in version 3.2. + * + * @ingroup window + */ +GLFWAPI void glfwSetWindowIcon(GLFWwindow* window, int count, const GLFWimage* images); + +/*! @brief Retrieves the position of the content area of the specified window. + * + * This function retrieves the position, in screen coordinates, of the + * upper-left corner of the content area of the specified window. + * + * Any or all of the position arguments may be `NULL`. If an error occurs, all + * non-`NULL` position arguments will be set to zero. + * + * @param[in] window The window to query. + * @param[out] xpos Where to store the x-coordinate of the upper-left corner of + * the content area, or `NULL`. + * @param[out] ypos Where to store the y-coordinate of the upper-left corner of + * the content area, or `NULL`. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED, @ref + * GLFW_PLATFORM_ERROR and @ref GLFW_FEATURE_UNAVAILABLE (see remarks). + * + * @remark @wayland There is no way for an application to retrieve the global + * position of its windows. This function will emit @ref + * GLFW_FEATURE_UNAVAILABLE. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref window_pos + * @sa @ref glfwSetWindowPos + * + * @since Added in version 3.0. + * + * @ingroup window + */ +GLFWAPI void glfwGetWindowPos(GLFWwindow* window, int* xpos, int* ypos); + +/*! @brief Sets the position of the content area of the specified window. + * + * This function sets the position, in screen coordinates, of the upper-left + * corner of the content area of the specified windowed mode window. If the + * window is a full screen window, this function does nothing. + * + * __Do not use this function__ to move an already visible window unless you + * have very good reasons for doing so, as it will confuse and annoy the user. + * + * The window manager may put limits on what positions are allowed. GLFW + * cannot and should not override these limits. + * + * @param[in] window The window to query. + * @param[in] xpos The x-coordinate of the upper-left corner of the content area. + * @param[in] ypos The y-coordinate of the upper-left corner of the content area. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED, @ref + * GLFW_PLATFORM_ERROR and @ref GLFW_FEATURE_UNAVAILABLE (see remarks). + * + * @remark @wayland There is no way for an application to set the global + * position of its windows. This function will emit @ref + * GLFW_FEATURE_UNAVAILABLE. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref window_pos + * @sa @ref glfwGetWindowPos + * + * @since Added in version 1.0. + * @glfw3 Added window handle parameter. + * + * @ingroup window + */ +GLFWAPI void glfwSetWindowPos(GLFWwindow* window, int xpos, int ypos); + +/*! @brief Retrieves the size of the content area of the specified window. + * + * This function retrieves the size, in screen coordinates, of the content area + * of the specified window. If you wish to retrieve the size of the + * framebuffer of the window in pixels, see @ref glfwGetFramebufferSize. + * + * Any or all of the size arguments may be `NULL`. If an error occurs, all + * non-`NULL` size arguments will be set to zero. + * + * @param[in] window The window whose size to retrieve. + * @param[out] width Where to store the width, in screen coordinates, of the + * content area, or `NULL`. + * @param[out] height Where to store the height, in screen coordinates, of the + * content area, or `NULL`. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref + * GLFW_PLATFORM_ERROR. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref window_size + * @sa @ref glfwSetWindowSize + * + * @since Added in version 1.0. + * @glfw3 Added window handle parameter. + * + * @ingroup window + */ +GLFWAPI void glfwGetWindowSize(GLFWwindow* window, int* width, int* height); + +/*! @brief Sets the size limits of the specified window. + * + * This function sets the size limits of the content area of the specified + * window. If the window is full screen, the size limits only take effect + * once it is made windowed. If the window is not resizable, this function + * does nothing. + * + * The size limits are applied immediately to a windowed mode window and may + * cause it to be resized. + * + * The maximum dimensions must be greater than or equal to the minimum + * dimensions and all must be greater than or equal to zero. + * + * @param[in] window The window to set limits for. + * @param[in] minwidth The minimum width, in screen coordinates, of the content + * area, or `GLFW_DONT_CARE`. + * @param[in] minheight The minimum height, in screen coordinates, of the + * content area, or `GLFW_DONT_CARE`. + * @param[in] maxwidth The maximum width, in screen coordinates, of the content + * area, or `GLFW_DONT_CARE`. + * @param[in] maxheight The maximum height, in screen coordinates, of the + * content area, or `GLFW_DONT_CARE`. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED, @ref + * GLFW_INVALID_VALUE and @ref GLFW_PLATFORM_ERROR. + * + * @remark If you set size limits and an aspect ratio that conflict, the + * results are undefined. + * + * @remark @wayland The size limits will not be applied until the window is + * actually resized, either by the user or by the compositor. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref window_sizelimits + * @sa @ref glfwSetWindowAspectRatio + * + * @since Added in version 3.2. + * + * @ingroup window + */ +GLFWAPI void glfwSetWindowSizeLimits(GLFWwindow* window, int minwidth, int minheight, int maxwidth, int maxheight); + +/*! @brief Sets the aspect ratio of the specified window. + * + * This function sets the required aspect ratio of the content area of the + * specified window. If the window is full screen, the aspect ratio only takes + * effect once it is made windowed. If the window is not resizable, this + * function does nothing. + * + * The aspect ratio is specified as a numerator and a denominator and both + * values must be greater than zero. For example, the common 16:9 aspect ratio + * is specified as 16 and 9, respectively. + * + * If the numerator and denominator is set to `GLFW_DONT_CARE` then the aspect + * ratio limit is disabled. + * + * The aspect ratio is applied immediately to a windowed mode window and may + * cause it to be resized. + * + * @param[in] window The window to set limits for. + * @param[in] numer The numerator of the desired aspect ratio, or + * `GLFW_DONT_CARE`. + * @param[in] denom The denominator of the desired aspect ratio, or + * `GLFW_DONT_CARE`. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED, @ref + * GLFW_INVALID_VALUE and @ref GLFW_PLATFORM_ERROR. + * + * @remark If you set size limits and an aspect ratio that conflict, the + * results are undefined. + * + * @remark @wayland The aspect ratio will not be applied until the window is + * actually resized, either by the user or by the compositor. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref window_sizelimits + * @sa @ref glfwSetWindowSizeLimits + * + * @since Added in version 3.2. + * + * @ingroup window + */ +GLFWAPI void glfwSetWindowAspectRatio(GLFWwindow* window, int numer, int denom); + +/*! @brief Sets the size of the content area of the specified window. + * + * This function sets the size, in screen coordinates, of the content area of + * the specified window. + * + * For full screen windows, this function updates the resolution of its desired + * video mode and switches to the video mode closest to it, without affecting + * the window's context. As the context is unaffected, the bit depths of the + * framebuffer remain unchanged. + * + * If you wish to update the refresh rate of the desired video mode in addition + * to its resolution, see @ref glfwSetWindowMonitor. + * + * The window manager may put limits on what sizes are allowed. GLFW cannot + * and should not override these limits. + * + * @param[in] window The window to resize. + * @param[in] width The desired width, in screen coordinates, of the window + * content area. + * @param[in] height The desired height, in screen coordinates, of the window + * content area. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref + * GLFW_PLATFORM_ERROR. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref window_size + * @sa @ref glfwGetWindowSize + * @sa @ref glfwSetWindowMonitor + * + * @since Added in version 1.0. + * @glfw3 Added window handle parameter. + * + * @ingroup window + */ +GLFWAPI void glfwSetWindowSize(GLFWwindow* window, int width, int height); + +/*! @brief Retrieves the size of the framebuffer of the specified window. + * + * This function retrieves the size, in pixels, of the framebuffer of the + * specified window. If you wish to retrieve the size of the window in screen + * coordinates, see @ref glfwGetWindowSize. + * + * Any or all of the size arguments may be `NULL`. If an error occurs, all + * non-`NULL` size arguments will be set to zero. + * + * @param[in] window The window whose framebuffer to query. + * @param[out] width Where to store the width, in pixels, of the framebuffer, + * or `NULL`. + * @param[out] height Where to store the height, in pixels, of the framebuffer, + * or `NULL`. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref + * GLFW_PLATFORM_ERROR. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref window_fbsize + * @sa @ref glfwSetFramebufferSizeCallback + * + * @since Added in version 3.0. + * + * @ingroup window + */ +GLFWAPI void glfwGetFramebufferSize(GLFWwindow* window, int* width, int* height); + +/*! @brief Retrieves the size of the frame of the window. + * + * This function retrieves the size, in screen coordinates, of each edge of the + * frame of the specified window. This size includes the title bar, if the + * window has one. The size of the frame may vary depending on the + * [window-related hints](@ref window_hints_wnd) used to create it. + * + * Because this function retrieves the size of each window frame edge and not + * the offset along a particular coordinate axis, the retrieved values will + * always be zero or positive. + * + * Any or all of the size arguments may be `NULL`. If an error occurs, all + * non-`NULL` size arguments will be set to zero. + * + * @param[in] window The window whose frame size to query. + * @param[out] left Where to store the size, in screen coordinates, of the left + * edge of the window frame, or `NULL`. + * @param[out] top Where to store the size, in screen coordinates, of the top + * edge of the window frame, or `NULL`. + * @param[out] right Where to store the size, in screen coordinates, of the + * right edge of the window frame, or `NULL`. + * @param[out] bottom Where to store the size, in screen coordinates, of the + * bottom edge of the window frame, or `NULL`. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref + * GLFW_PLATFORM_ERROR. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref window_size + * + * @since Added in version 3.1. + * + * @ingroup window + */ +GLFWAPI void glfwGetWindowFrameSize(GLFWwindow* window, int* left, int* top, int* right, int* bottom); + +/*! @brief Retrieves the content scale for the specified window. + * + * This function retrieves the content scale for the specified window. The + * content scale is the ratio between the current DPI and the platform's + * default DPI. This is especially important for text and any UI elements. If + * the pixel dimensions of your UI scaled by this look appropriate on your + * machine then it should appear at a reasonable size on other machines + * regardless of their DPI and scaling settings. This relies on the system DPI + * and scaling settings being somewhat correct. + * + * On platforms where each monitors can have its own content scale, the window + * content scale will depend on which monitor the system considers the window + * to be on. + * + * @param[in] window The window to query. + * @param[out] xscale Where to store the x-axis content scale, or `NULL`. + * @param[out] yscale Where to store the y-axis content scale, or `NULL`. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref + * GLFW_PLATFORM_ERROR. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref window_scale + * @sa @ref glfwSetWindowContentScaleCallback + * @sa @ref glfwGetMonitorContentScale + * + * @since Added in version 3.3. + * + * @ingroup window + */ +GLFWAPI void glfwGetWindowContentScale(GLFWwindow* window, float* xscale, float* yscale); + +/*! @brief Returns the opacity of the whole window. + * + * This function returns the opacity of the window, including any decorations. + * + * The opacity (or alpha) value is a positive finite number between zero and + * one, where zero is fully transparent and one is fully opaque. If the system + * does not support whole window transparency, this function always returns one. + * + * The initial opacity value for newly created windows is one. + * + * @param[in] window The window to query. + * @return The opacity value of the specified window. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref + * GLFW_PLATFORM_ERROR. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref window_transparency + * @sa @ref glfwSetWindowOpacity + * + * @since Added in version 3.3. + * + * @ingroup window + */ +GLFWAPI float glfwGetWindowOpacity(GLFWwindow* window); + +/*! @brief Sets the opacity of the whole window. + * + * This function sets the opacity of the window, including any decorations. + * + * The opacity (or alpha) value is a positive finite number between zero and + * one, where zero is fully transparent and one is fully opaque. + * + * The initial opacity value for newly created windows is one. + * + * A window created with framebuffer transparency may not use whole window + * transparency. The results of doing this are undefined. + * + * @param[in] window The window to set the opacity for. + * @param[in] opacity The desired opacity of the specified window. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED, @ref + * GLFW_PLATFORM_ERROR and @ref GLFW_FEATURE_UNAVAILABLE (see remarks). + * + * @remark @wayland There is no way to set an opacity factor for a window. + * This function will emit @ref GLFW_FEATURE_UNAVAILABLE. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref window_transparency + * @sa @ref glfwGetWindowOpacity + * + * @since Added in version 3.3. + * + * @ingroup window + */ +GLFWAPI void glfwSetWindowOpacity(GLFWwindow* window, float opacity); + +/*! @brief Iconifies the specified window. + * + * This function iconifies (minimizes) the specified window if it was + * previously restored. If the window is already iconified, this function does + * nothing. + * + * If the specified window is a full screen window, GLFW restores the original + * video mode of the monitor. The window's desired video mode is set again + * when the window is restored. + * + * @param[in] window The window to iconify. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref + * GLFW_PLATFORM_ERROR. + * + * @remark @wayland Once a window is iconified, @ref glfwRestoreWindow won’t + * be able to restore it. This is a design decision of the xdg-shell + * protocol. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref window_iconify + * @sa @ref glfwRestoreWindow + * @sa @ref glfwMaximizeWindow + * + * @since Added in version 2.1. + * @glfw3 Added window handle parameter. + * + * @ingroup window + */ +GLFWAPI void glfwIconifyWindow(GLFWwindow* window); + +/*! @brief Restores the specified window. + * + * This function restores the specified window if it was previously iconified + * (minimized) or maximized. If the window is already restored, this function + * does nothing. + * + * If the specified window is an iconified full screen window, its desired + * video mode is set again for its monitor when the window is restored. + * + * @param[in] window The window to restore. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref + * GLFW_PLATFORM_ERROR. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref window_iconify + * @sa @ref glfwIconifyWindow + * @sa @ref glfwMaximizeWindow + * + * @since Added in version 2.1. + * @glfw3 Added window handle parameter. + * + * @ingroup window + */ +GLFWAPI void glfwRestoreWindow(GLFWwindow* window); + +/*! @brief Maximizes the specified window. + * + * This function maximizes the specified window if it was previously not + * maximized. If the window is already maximized, this function does nothing. + * + * If the specified window is a full screen window, this function does nothing. + * + * @param[in] window The window to maximize. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref + * GLFW_PLATFORM_ERROR. + * + * @par Thread Safety + * This function may only be called from the main thread. + * + * @sa @ref window_iconify + * @sa @ref glfwIconifyWindow + * @sa @ref glfwRestoreWindow + * + * @since Added in GLFW 3.2. + * + * @ingroup window + */ +GLFWAPI void glfwMaximizeWindow(GLFWwindow* window); + +/*! @brief Makes the specified window visible. + * + * This function makes the specified window visible if it was previously + * hidden. If the window is already visible or is in full screen mode, this + * function does nothing. + * + * By default, windowed mode windows are focused when shown + * Set the [GLFW_FOCUS_ON_SHOW](@ref GLFW_FOCUS_ON_SHOW_hint) window hint + * to change this behavior for all newly created windows, or change the + * behavior for an existing window with @ref glfwSetWindowAttrib. + * + * @param[in] window The window to make visible. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref + * GLFW_PLATFORM_ERROR. + * + * @remark @wayland Because Wayland wants every frame of the desktop to be + * complete, this function does not immediately make the window visible. + * Instead it will become visible the next time the window framebuffer is + * updated after this call. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref window_hide + * @sa @ref glfwHideWindow + * + * @since Added in version 3.0. + * + * @ingroup window + */ +GLFWAPI void glfwShowWindow(GLFWwindow* window); + +/*! @brief Hides the specified window. + * + * This function hides the specified window if it was previously visible. If + * the window is already hidden or is in full screen mode, this function does + * nothing. + * + * @param[in] window The window to hide. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref + * GLFW_PLATFORM_ERROR. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref window_hide + * @sa @ref glfwShowWindow + * + * @since Added in version 3.0. + * + * @ingroup window + */ +GLFWAPI void glfwHideWindow(GLFWwindow* window); + +/*! @brief Brings the specified window to front and sets input focus. + * + * This function brings the specified window to front and sets input focus. + * The window should already be visible and not iconified. + * + * By default, both windowed and full screen mode windows are focused when + * initially created. Set the [GLFW_FOCUSED](@ref GLFW_FOCUSED_hint) to + * disable this behavior. + * + * Also by default, windowed mode windows are focused when shown + * with @ref glfwShowWindow. Set the + * [GLFW_FOCUS_ON_SHOW](@ref GLFW_FOCUS_ON_SHOW_hint) to disable this behavior. + * + * __Do not use this function__ to steal focus from other applications unless + * you are certain that is what the user wants. Focus stealing can be + * extremely disruptive. + * + * For a less disruptive way of getting the user's attention, see + * [attention requests](@ref window_attention). + * + * @param[in] window The window to give input focus. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref + * GLFW_PLATFORM_ERROR. + * + * @remark @wayland The compositor will likely ignore focus requests unless + * another window created by the same application already has input focus. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref window_focus + * @sa @ref window_attention + * + * @since Added in version 3.2. + * + * @ingroup window + */ +GLFWAPI void glfwFocusWindow(GLFWwindow* window); + +/*! @brief Requests user attention to the specified window. + * + * This function requests user attention to the specified window. On + * platforms where this is not supported, attention is requested to the + * application as a whole. + * + * Once the user has given attention, usually by focusing the window or + * application, the system will end the request automatically. + * + * @param[in] window The window to request attention to. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref + * GLFW_PLATFORM_ERROR. + * + * @remark @macos Attention is requested to the application as a whole, not the + * specific window. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref window_attention + * + * @since Added in version 3.3. + * + * @ingroup window + */ +GLFWAPI void glfwRequestWindowAttention(GLFWwindow* window); + +/*! @brief Returns the monitor that the window uses for full screen mode. + * + * This function returns the handle of the monitor that the specified window is + * in full screen on. + * + * @param[in] window The window to query. + * @return The monitor, or `NULL` if the window is in windowed mode or an + * [error](@ref error_handling) occurred. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref window_monitor + * @sa @ref glfwSetWindowMonitor + * + * @since Added in version 3.0. + * + * @ingroup window + */ +GLFWAPI GLFWmonitor* glfwGetWindowMonitor(GLFWwindow* window); + +/*! @brief Sets the mode, monitor, video mode and placement of a window. + * + * This function sets the monitor that the window uses for full screen mode or, + * if the monitor is `NULL`, makes it windowed mode. + * + * When setting a monitor, this function updates the width, height and refresh + * rate of the desired video mode and switches to the video mode closest to it. + * The window position is ignored when setting a monitor. + * + * When the monitor is `NULL`, the position, width and height are used to + * place the window content area. The refresh rate is ignored when no monitor + * is specified. + * + * If you only wish to update the resolution of a full screen window or the + * size of a windowed mode window, see @ref glfwSetWindowSize. + * + * When a window transitions from full screen to windowed mode, this function + * restores any previous window settings such as whether it is decorated, + * floating, resizable, has size or aspect ratio limits, etc. + * + * @param[in] window The window whose monitor, size or video mode to set. + * @param[in] monitor The desired monitor, or `NULL` to set windowed mode. + * @param[in] xpos The desired x-coordinate of the upper-left corner of the + * content area. + * @param[in] ypos The desired y-coordinate of the upper-left corner of the + * content area. + * @param[in] width The desired with, in screen coordinates, of the content + * area or video mode. + * @param[in] height The desired height, in screen coordinates, of the content + * area or video mode. + * @param[in] refreshRate The desired refresh rate, in Hz, of the video mode, + * or `GLFW_DONT_CARE`. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref + * GLFW_PLATFORM_ERROR. + * + * @remark The OpenGL or OpenGL ES context will not be destroyed or otherwise + * affected by any resizing or mode switching, although you may need to update + * your viewport if the framebuffer size has changed. + * + * @remark @wayland The desired window position is ignored, as there is no way + * for an application to set this property. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref window_monitor + * @sa @ref window_full_screen + * @sa @ref glfwGetWindowMonitor + * @sa @ref glfwSetWindowSize + * + * @since Added in version 3.2. + * + * @ingroup window + */ +GLFWAPI void glfwSetWindowMonitor(GLFWwindow* window, GLFWmonitor* monitor, int xpos, int ypos, int width, int height, int refreshRate); + +/*! @brief Returns an attribute of the specified window. + * + * This function returns the value of an attribute of the specified window or + * its OpenGL or OpenGL ES context. + * + * @param[in] window The window to query. + * @param[in] attrib The [window attribute](@ref window_attribs) whose value to + * return. + * @return The value of the attribute, or zero if an + * [error](@ref error_handling) occurred. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED, @ref + * GLFW_INVALID_ENUM and @ref GLFW_PLATFORM_ERROR. + * + * @remark Framebuffer related hints are not window attributes. See @ref + * window_attribs_fb for more information. + * + * @remark Zero is a valid value for many window and context related + * attributes so you cannot use a return value of zero as an indication of + * errors. However, this function should not fail as long as it is passed + * valid arguments and the library has been [initialized](@ref intro_init). + * + * @remark @wayland The Wayland protocol provides no way to check whether a + * window is iconfied, so @ref GLFW_ICONIFIED always returns `GLFW_FALSE`. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref window_attribs + * @sa @ref glfwSetWindowAttrib + * + * @since Added in version 3.0. Replaces `glfwGetWindowParam` and + * `glfwGetGLVersion`. + * + * @ingroup window + */ +GLFWAPI int glfwGetWindowAttrib(GLFWwindow* window, int attrib); + +/*! @brief Sets an attribute of the specified window. + * + * This function sets the value of an attribute of the specified window. + * + * The supported attributes are [GLFW_DECORATED](@ref GLFW_DECORATED_attrib), + * [GLFW_RESIZABLE](@ref GLFW_RESIZABLE_attrib), + * [GLFW_FLOATING](@ref GLFW_FLOATING_attrib), + * [GLFW_AUTO_ICONIFY](@ref GLFW_AUTO_ICONIFY_attrib) and + * [GLFW_FOCUS_ON_SHOW](@ref GLFW_FOCUS_ON_SHOW_attrib). + * [GLFW_MOUSE_PASSTHROUGH](@ref GLFW_MOUSE_PASSTHROUGH_attrib) + * + * Some of these attributes are ignored for full screen windows. The new + * value will take effect if the window is later made windowed. + * + * Some of these attributes are ignored for windowed mode windows. The new + * value will take effect if the window is later made full screen. + * + * @param[in] window The window to set the attribute for. + * @param[in] attrib A supported window attribute. + * @param[in] value `GLFW_TRUE` or `GLFW_FALSE`. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED, @ref + * GLFW_INVALID_ENUM, @ref GLFW_INVALID_VALUE, @ref GLFW_PLATFORM_ERROR and @ref + * GLFW_FEATURE_UNAVAILABLE (see remarks). + * + * @remark Calling @ref glfwGetWindowAttrib will always return the latest + * value, even if that value is ignored by the current mode of the window. + * + * @remark @wayland The [GLFW_FLOATING](@ref GLFW_FLOATING_attrib) window attribute is + * not supported. Setting this will emit @ref GLFW_FEATURE_UNAVAILABLE. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref window_attribs + * @sa @ref glfwGetWindowAttrib + * + * @since Added in version 3.3. + * + * @ingroup window + */ +GLFWAPI void glfwSetWindowAttrib(GLFWwindow* window, int attrib, int value); + +/*! @brief Sets the user pointer of the specified window. + * + * This function sets the user-defined pointer of the specified window. The + * current value is retained until the window is destroyed. The initial value + * is `NULL`. + * + * @param[in] window The window whose pointer to set. + * @param[in] pointer The new value. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED. + * + * @thread_safety This function may be called from any thread. Access is not + * synchronized. + * + * @sa @ref window_userptr + * @sa @ref glfwGetWindowUserPointer + * + * @since Added in version 3.0. + * + * @ingroup window + */ +GLFWAPI void glfwSetWindowUserPointer(GLFWwindow* window, void* pointer); + +/*! @brief Returns the user pointer of the specified window. + * + * This function returns the current value of the user-defined pointer of the + * specified window. The initial value is `NULL`. + * + * @param[in] window The window whose pointer to return. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED. + * + * @thread_safety This function may be called from any thread. Access is not + * synchronized. + * + * @sa @ref window_userptr + * @sa @ref glfwSetWindowUserPointer + * + * @since Added in version 3.0. + * + * @ingroup window + */ +GLFWAPI void* glfwGetWindowUserPointer(GLFWwindow* window); + +/*! @brief Sets the position callback for the specified window. + * + * This function sets the position callback of the specified window, which is + * called when the window is moved. The callback is provided with the + * position, in screen coordinates, of the upper-left corner of the content + * area of the window. + * + * @param[in] window The window whose callback to set. + * @param[in] callback The new callback, or `NULL` to remove the currently set + * callback. + * @return The previously set callback, or `NULL` if no callback was set or the + * library had not been [initialized](@ref intro_init). + * + * @callback_signature + * @code + * void function_name(GLFWwindow* window, int xpos, int ypos) + * @endcode + * For more information about the callback parameters, see the + * [function pointer type](@ref GLFWwindowposfun). + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED. + * + * @remark @wayland This callback will never be called, as there is no way for + * an application to know its global position. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref window_pos + * + * @since Added in version 3.0. + * + * @ingroup window + */ +GLFWAPI GLFWwindowposfun glfwSetWindowPosCallback(GLFWwindow* window, GLFWwindowposfun callback); + +/*! @brief Sets the size callback for the specified window. + * + * This function sets the size callback of the specified window, which is + * called when the window is resized. The callback is provided with the size, + * in screen coordinates, of the content area of the window. + * + * @param[in] window The window whose callback to set. + * @param[in] callback The new callback, or `NULL` to remove the currently set + * callback. + * @return The previously set callback, or `NULL` if no callback was set or the + * library had not been [initialized](@ref intro_init). + * + * @callback_signature + * @code + * void function_name(GLFWwindow* window, int width, int height) + * @endcode + * For more information about the callback parameters, see the + * [function pointer type](@ref GLFWwindowsizefun). + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref window_size + * + * @since Added in version 1.0. + * @glfw3 Added window handle parameter and return value. + * + * @ingroup window + */ +GLFWAPI GLFWwindowsizefun glfwSetWindowSizeCallback(GLFWwindow* window, GLFWwindowsizefun callback); + +/*! @brief Sets the close callback for the specified window. + * + * This function sets the close callback of the specified window, which is + * called when the user attempts to close the window, for example by clicking + * the close widget in the title bar. + * + * The close flag is set before this callback is called, but you can modify it + * at any time with @ref glfwSetWindowShouldClose. + * + * The close callback is not triggered by @ref glfwDestroyWindow. + * + * @param[in] window The window whose callback to set. + * @param[in] callback The new callback, or `NULL` to remove the currently set + * callback. + * @return The previously set callback, or `NULL` if no callback was set or the + * library had not been [initialized](@ref intro_init). + * + * @callback_signature + * @code + * void function_name(GLFWwindow* window) + * @endcode + * For more information about the callback parameters, see the + * [function pointer type](@ref GLFWwindowclosefun). + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED. + * + * @remark @macos Selecting Quit from the application menu will trigger the + * close callback for all windows. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref window_close + * + * @since Added in version 2.5. + * @glfw3 Added window handle parameter and return value. + * + * @ingroup window + */ +GLFWAPI GLFWwindowclosefun glfwSetWindowCloseCallback(GLFWwindow* window, GLFWwindowclosefun callback); + +/*! @brief Sets the refresh callback for the specified window. + * + * This function sets the refresh callback of the specified window, which is + * called when the content area of the window needs to be redrawn, for example + * if the window has been exposed after having been covered by another window. + * + * On compositing window systems such as Aero, Compiz, Aqua or Wayland, where + * the window contents are saved off-screen, this callback may be called only + * very infrequently or never at all. + * + * @param[in] window The window whose callback to set. + * @param[in] callback The new callback, or `NULL` to remove the currently set + * callback. + * @return The previously set callback, or `NULL` if no callback was set or the + * library had not been [initialized](@ref intro_init). + * + * @callback_signature + * @code + * void function_name(GLFWwindow* window); + * @endcode + * For more information about the callback parameters, see the + * [function pointer type](@ref GLFWwindowrefreshfun). + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref window_refresh + * + * @since Added in version 2.5. + * @glfw3 Added window handle parameter and return value. + * + * @ingroup window + */ +GLFWAPI GLFWwindowrefreshfun glfwSetWindowRefreshCallback(GLFWwindow* window, GLFWwindowrefreshfun callback); + +/*! @brief Sets the focus callback for the specified window. + * + * This function sets the focus callback of the specified window, which is + * called when the window gains or loses input focus. + * + * After the focus callback is called for a window that lost input focus, + * synthetic key and mouse button release events will be generated for all such + * that had been pressed. For more information, see @ref glfwSetKeyCallback + * and @ref glfwSetMouseButtonCallback. + * + * @param[in] window The window whose callback to set. + * @param[in] callback The new callback, or `NULL` to remove the currently set + * callback. + * @return The previously set callback, or `NULL` if no callback was set or the + * library had not been [initialized](@ref intro_init). + * + * @callback_signature + * @code + * void function_name(GLFWwindow* window, int focused) + * @endcode + * For more information about the callback parameters, see the + * [function pointer type](@ref GLFWwindowfocusfun). + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref window_focus + * + * @since Added in version 3.0. + * + * @ingroup window + */ +GLFWAPI GLFWwindowfocusfun glfwSetWindowFocusCallback(GLFWwindow* window, GLFWwindowfocusfun callback); + +/*! @brief Sets the iconify callback for the specified window. + * + * This function sets the iconification callback of the specified window, which + * is called when the window is iconified or restored. + * + * @param[in] window The window whose callback to set. + * @param[in] callback The new callback, or `NULL` to remove the currently set + * callback. + * @return The previously set callback, or `NULL` if no callback was set or the + * library had not been [initialized](@ref intro_init). + * + * @callback_signature + * @code + * void function_name(GLFWwindow* window, int iconified) + * @endcode + * For more information about the callback parameters, see the + * [function pointer type](@ref GLFWwindowiconifyfun). + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref window_iconify + * + * @since Added in version 3.0. + * + * @ingroup window + */ +GLFWAPI GLFWwindowiconifyfun glfwSetWindowIconifyCallback(GLFWwindow* window, GLFWwindowiconifyfun callback); + +/*! @brief Sets the maximize callback for the specified window. + * + * This function sets the maximization callback of the specified window, which + * is called when the window is maximized or restored. + * + * @param[in] window The window whose callback to set. + * @param[in] callback The new callback, or `NULL` to remove the currently set + * callback. + * @return The previously set callback, or `NULL` if no callback was set or the + * library had not been [initialized](@ref intro_init). + * + * @callback_signature + * @code + * void function_name(GLFWwindow* window, int maximized) + * @endcode + * For more information about the callback parameters, see the + * [function pointer type](@ref GLFWwindowmaximizefun). + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref window_maximize + * + * @since Added in version 3.3. + * + * @ingroup window + */ +GLFWAPI GLFWwindowmaximizefun glfwSetWindowMaximizeCallback(GLFWwindow* window, GLFWwindowmaximizefun callback); + +/*! @brief Sets the framebuffer resize callback for the specified window. + * + * This function sets the framebuffer resize callback of the specified window, + * which is called when the framebuffer of the specified window is resized. + * + * @param[in] window The window whose callback to set. + * @param[in] callback The new callback, or `NULL` to remove the currently set + * callback. + * @return The previously set callback, or `NULL` if no callback was set or the + * library had not been [initialized](@ref intro_init). + * + * @callback_signature + * @code + * void function_name(GLFWwindow* window, int width, int height) + * @endcode + * For more information about the callback parameters, see the + * [function pointer type](@ref GLFWframebuffersizefun). + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref window_fbsize + * + * @since Added in version 3.0. + * + * @ingroup window + */ +GLFWAPI GLFWframebuffersizefun glfwSetFramebufferSizeCallback(GLFWwindow* window, GLFWframebuffersizefun callback); + +/*! @brief Sets the window content scale callback for the specified window. + * + * This function sets the window content scale callback of the specified window, + * which is called when the content scale of the specified window changes. + * + * @param[in] window The window whose callback to set. + * @param[in] callback The new callback, or `NULL` to remove the currently set + * callback. + * @return The previously set callback, or `NULL` if no callback was set or the + * library had not been [initialized](@ref intro_init). + * + * @callback_signature + * @code + * void function_name(GLFWwindow* window, float xscale, float yscale) + * @endcode + * For more information about the callback parameters, see the + * [function pointer type](@ref GLFWwindowcontentscalefun). + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref window_scale + * @sa @ref glfwGetWindowContentScale + * + * @since Added in version 3.3. + * + * @ingroup window + */ +GLFWAPI GLFWwindowcontentscalefun glfwSetWindowContentScaleCallback(GLFWwindow* window, GLFWwindowcontentscalefun callback); + +/*! @brief Processes all pending events. + * + * This function processes only those events that are already in the event + * queue and then returns immediately. Processing events will cause the window + * and input callbacks associated with those events to be called. + * + * On some platforms, a window move, resize or menu operation will cause event + * processing to block. This is due to how event processing is designed on + * those platforms. You can use the + * [window refresh callback](@ref window_refresh) to redraw the contents of + * your window when necessary during such operations. + * + * Do not assume that callbacks you set will _only_ be called in response to + * event processing functions like this one. While it is necessary to poll for + * events, window systems that require GLFW to register callbacks of its own + * can pass events to GLFW in response to many window system function calls. + * GLFW will pass those events on to the application callbacks before + * returning. + * + * Event processing is not required for joystick input to work. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref + * GLFW_PLATFORM_ERROR. + * + * @reentrancy This function must not be called from a callback. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref events + * @sa @ref glfwWaitEvents + * @sa @ref glfwWaitEventsTimeout + * + * @since Added in version 1.0. + * + * @ingroup window + */ +GLFWAPI void glfwPollEvents(void); + +/*! @brief Waits until events are queued and processes them. + * + * This function puts the calling thread to sleep until at least one event is + * available in the event queue. Once one or more events are available, + * it behaves exactly like @ref glfwPollEvents, i.e. the events in the queue + * are processed and the function then returns immediately. Processing events + * will cause the window and input callbacks associated with those events to be + * called. + * + * Since not all events are associated with callbacks, this function may return + * without a callback having been called even if you are monitoring all + * callbacks. + * + * On some platforms, a window move, resize or menu operation will cause event + * processing to block. This is due to how event processing is designed on + * those platforms. You can use the + * [window refresh callback](@ref window_refresh) to redraw the contents of + * your window when necessary during such operations. + * + * Do not assume that callbacks you set will _only_ be called in response to + * event processing functions like this one. While it is necessary to poll for + * events, window systems that require GLFW to register callbacks of its own + * can pass events to GLFW in response to many window system function calls. + * GLFW will pass those events on to the application callbacks before + * returning. + * + * Event processing is not required for joystick input to work. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref + * GLFW_PLATFORM_ERROR. + * + * @reentrancy This function must not be called from a callback. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref events + * @sa @ref glfwPollEvents + * @sa @ref glfwWaitEventsTimeout + * + * @since Added in version 2.5. + * + * @ingroup window + */ +GLFWAPI void glfwWaitEvents(void); + +/*! @brief Waits with timeout until events are queued and processes them. + * + * This function puts the calling thread to sleep until at least one event is + * available in the event queue, or until the specified timeout is reached. If + * one or more events are available, it behaves exactly like @ref + * glfwPollEvents, i.e. the events in the queue are processed and the function + * then returns immediately. Processing events will cause the window and input + * callbacks associated with those events to be called. + * + * The timeout value must be a positive finite number. + * + * Since not all events are associated with callbacks, this function may return + * without a callback having been called even if you are monitoring all + * callbacks. + * + * On some platforms, a window move, resize or menu operation will cause event + * processing to block. This is due to how event processing is designed on + * those platforms. You can use the + * [window refresh callback](@ref window_refresh) to redraw the contents of + * your window when necessary during such operations. + * + * Do not assume that callbacks you set will _only_ be called in response to + * event processing functions like this one. While it is necessary to poll for + * events, window systems that require GLFW to register callbacks of its own + * can pass events to GLFW in response to many window system function calls. + * GLFW will pass those events on to the application callbacks before + * returning. + * + * Event processing is not required for joystick input to work. + * + * @param[in] timeout The maximum amount of time, in seconds, to wait. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED, @ref + * GLFW_INVALID_VALUE and @ref GLFW_PLATFORM_ERROR. + * + * @reentrancy This function must not be called from a callback. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref events + * @sa @ref glfwPollEvents + * @sa @ref glfwWaitEvents + * + * @since Added in version 3.2. + * + * @ingroup window + */ +GLFWAPI void glfwWaitEventsTimeout(double timeout); + +/*! @brief Posts an empty event to the event queue. + * + * This function posts an empty event from the current thread to the event + * queue, causing @ref glfwWaitEvents or @ref glfwWaitEventsTimeout to return. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref + * GLFW_PLATFORM_ERROR. + * + * @thread_safety This function may be called from any thread. + * + * @sa @ref events + * @sa @ref glfwWaitEvents + * @sa @ref glfwWaitEventsTimeout + * + * @since Added in version 3.1. + * + * @ingroup window + */ +GLFWAPI void glfwPostEmptyEvent(void); + +/*! @brief Returns the value of an input option for the specified window. + * + * This function returns the value of an input option for the specified window. + * The mode must be one of @ref GLFW_CURSOR, @ref GLFW_STICKY_KEYS, + * @ref GLFW_STICKY_MOUSE_BUTTONS, @ref GLFW_LOCK_KEY_MODS or + * @ref GLFW_RAW_MOUSE_MOTION. + * + * @param[in] window The window to query. + * @param[in] mode One of `GLFW_CURSOR`, `GLFW_STICKY_KEYS`, + * `GLFW_STICKY_MOUSE_BUTTONS`, `GLFW_LOCK_KEY_MODS` or + * `GLFW_RAW_MOUSE_MOTION`. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref + * GLFW_INVALID_ENUM. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref glfwSetInputMode + * + * @since Added in version 3.0. + * + * @ingroup input + */ +GLFWAPI int glfwGetInputMode(GLFWwindow* window, int mode); + +/*! @brief Sets an input option for the specified window. + * + * This function sets an input mode option for the specified window. The mode + * must be one of @ref GLFW_CURSOR, @ref GLFW_STICKY_KEYS, + * @ref GLFW_STICKY_MOUSE_BUTTONS, @ref GLFW_LOCK_KEY_MODS or + * @ref GLFW_RAW_MOUSE_MOTION. + * + * If the mode is `GLFW_CURSOR`, the value must be one of the following cursor + * modes: + * - `GLFW_CURSOR_NORMAL` makes the cursor visible and behaving normally. + * - `GLFW_CURSOR_HIDDEN` makes the cursor invisible when it is over the + * content area of the window but does not restrict the cursor from leaving. + * - `GLFW_CURSOR_DISABLED` hides and grabs the cursor, providing virtual + * and unlimited cursor movement. This is useful for implementing for + * example 3D camera controls. + * - `GLFW_CURSOR_CAPTURED` makes the cursor visible and confines it to the + * content area of the window. + * + * If the mode is `GLFW_STICKY_KEYS`, the value must be either `GLFW_TRUE` to + * enable sticky keys, or `GLFW_FALSE` to disable it. If sticky keys are + * enabled, a key press will ensure that @ref glfwGetKey returns `GLFW_PRESS` + * the next time it is called even if the key had been released before the + * call. This is useful when you are only interested in whether keys have been + * pressed but not when or in which order. + * + * If the mode is `GLFW_STICKY_MOUSE_BUTTONS`, the value must be either + * `GLFW_TRUE` to enable sticky mouse buttons, or `GLFW_FALSE` to disable it. + * If sticky mouse buttons are enabled, a mouse button press will ensure that + * @ref glfwGetMouseButton returns `GLFW_PRESS` the next time it is called even + * if the mouse button had been released before the call. This is useful when + * you are only interested in whether mouse buttons have been pressed but not + * when or in which order. + * + * If the mode is `GLFW_LOCK_KEY_MODS`, the value must be either `GLFW_TRUE` to + * enable lock key modifier bits, or `GLFW_FALSE` to disable them. If enabled, + * callbacks that receive modifier bits will also have the @ref + * GLFW_MOD_CAPS_LOCK bit set when the event was generated with Caps Lock on, + * and the @ref GLFW_MOD_NUM_LOCK bit when Num Lock was on. + * + * If the mode is `GLFW_RAW_MOUSE_MOTION`, the value must be either `GLFW_TRUE` + * to enable raw (unscaled and unaccelerated) mouse motion when the cursor is + * disabled, or `GLFW_FALSE` to disable it. If raw motion is not supported, + * attempting to set this will emit @ref GLFW_FEATURE_UNAVAILABLE. Call @ref + * glfwRawMouseMotionSupported to check for support. + * + * @param[in] window The window whose input mode to set. + * @param[in] mode One of `GLFW_CURSOR`, `GLFW_STICKY_KEYS`, + * `GLFW_STICKY_MOUSE_BUTTONS`, `GLFW_LOCK_KEY_MODS` or + * `GLFW_RAW_MOUSE_MOTION`. + * @param[in] value The new value of the specified input mode. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED, @ref + * GLFW_INVALID_ENUM, @ref GLFW_PLATFORM_ERROR and @ref + * GLFW_FEATURE_UNAVAILABLE (see above). + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref glfwGetInputMode + * + * @since Added in version 3.0. Replaces `glfwEnable` and `glfwDisable`. + * + * @ingroup input + */ +GLFWAPI void glfwSetInputMode(GLFWwindow* window, int mode, int value); + +/*! @brief Returns whether raw mouse motion is supported. + * + * This function returns whether raw mouse motion is supported on the current + * system. This status does not change after GLFW has been initialized so you + * only need to check this once. If you attempt to enable raw motion on + * a system that does not support it, @ref GLFW_PLATFORM_ERROR will be emitted. + * + * Raw mouse motion is closer to the actual motion of the mouse across + * a surface. It is not affected by the scaling and acceleration applied to + * the motion of the desktop cursor. That processing is suitable for a cursor + * while raw motion is better for controlling for example a 3D camera. Because + * of this, raw mouse motion is only provided when the cursor is disabled. + * + * @return `GLFW_TRUE` if raw mouse motion is supported on the current machine, + * or `GLFW_FALSE` otherwise. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref raw_mouse_motion + * @sa @ref glfwSetInputMode + * + * @since Added in version 3.3. + * + * @ingroup input + */ +GLFWAPI int glfwRawMouseMotionSupported(void); + +/*! @brief Returns the layout-specific name of the specified printable key. + * + * This function returns the name of the specified printable key, encoded as + * UTF-8. This is typically the character that key would produce without any + * modifier keys, intended for displaying key bindings to the user. For dead + * keys, it is typically the diacritic it would add to a character. + * + * __Do not use this function__ for [text input](@ref input_char). You will + * break text input for many languages even if it happens to work for yours. + * + * If the key is `GLFW_KEY_UNKNOWN`, the scancode is used to identify the key, + * otherwise the scancode is ignored. If you specify a non-printable key, or + * `GLFW_KEY_UNKNOWN` and a scancode that maps to a non-printable key, this + * function returns `NULL` but does not emit an error. + * + * This behavior allows you to always pass in the arguments in the + * [key callback](@ref input_key) without modification. + * + * The printable keys are: + * - `GLFW_KEY_APOSTROPHE` + * - `GLFW_KEY_COMMA` + * - `GLFW_KEY_MINUS` + * - `GLFW_KEY_PERIOD` + * - `GLFW_KEY_SLASH` + * - `GLFW_KEY_SEMICOLON` + * - `GLFW_KEY_EQUAL` + * - `GLFW_KEY_LEFT_BRACKET` + * - `GLFW_KEY_RIGHT_BRACKET` + * - `GLFW_KEY_BACKSLASH` + * - `GLFW_KEY_WORLD_1` + * - `GLFW_KEY_WORLD_2` + * - `GLFW_KEY_0` to `GLFW_KEY_9` + * - `GLFW_KEY_A` to `GLFW_KEY_Z` + * - `GLFW_KEY_KP_0` to `GLFW_KEY_KP_9` + * - `GLFW_KEY_KP_DECIMAL` + * - `GLFW_KEY_KP_DIVIDE` + * - `GLFW_KEY_KP_MULTIPLY` + * - `GLFW_KEY_KP_SUBTRACT` + * - `GLFW_KEY_KP_ADD` + * - `GLFW_KEY_KP_EQUAL` + * + * Names for printable keys depend on keyboard layout, while names for + * non-printable keys are the same across layouts but depend on the application + * language and should be localized along with other user interface text. + * + * @param[in] key The key to query, or `GLFW_KEY_UNKNOWN`. + * @param[in] scancode The scancode of the key to query. + * @return The UTF-8 encoded, layout-specific name of the key, or `NULL`. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED, @ref + * GLFW_INVALID_VALUE, @ref GLFW_INVALID_ENUM and @ref GLFW_PLATFORM_ERROR. + * + * @remark The contents of the returned string may change when a keyboard + * layout change event is received. + * + * @pointer_lifetime The returned string is allocated and freed by GLFW. You + * should not free it yourself. It is valid until the library is terminated. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref input_key_name + * + * @since Added in version 3.2. + * + * @ingroup input + */ +GLFWAPI const char* glfwGetKeyName(int key, int scancode); + +/*! @brief Returns the platform-specific scancode of the specified key. + * + * This function returns the platform-specific scancode of the specified key. + * + * If the specified [key token](@ref keys) corresponds to a physical key not + * supported on the current platform then this method will return `-1`. + * Calling this function with anything other than a key token will return `-1` + * and generate a @ref GLFW_INVALID_ENUM error. + * + * @param[in] key Any [key token](@ref keys). + * @return The platform-specific scancode for the key, or `-1` if the key is + * not supported on the current platform or an [error](@ref error_handling) + * occurred. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref + * GLFW_INVALID_ENUM. + * + * @thread_safety This function may be called from any thread. + * + * @sa @ref input_key + * + * @since Added in version 3.3. + * + * @ingroup input + */ +GLFWAPI int glfwGetKeyScancode(int key); + +/*! @brief Returns the last reported state of a keyboard key for the specified + * window. + * + * This function returns the last state reported for the specified key to the + * specified window. The returned state is one of `GLFW_PRESS` or + * `GLFW_RELEASE`. The action `GLFW_REPEAT` is only reported to the key callback. + * + * If the @ref GLFW_STICKY_KEYS input mode is enabled, this function returns + * `GLFW_PRESS` the first time you call it for a key that was pressed, even if + * that key has already been released. + * + * The key functions deal with physical keys, with [key tokens](@ref keys) + * named after their use on the standard US keyboard layout. If you want to + * input text, use the Unicode character callback instead. + * + * The [modifier key bit masks](@ref mods) are not key tokens and cannot be + * used with this function. + * + * __Do not use this function__ to implement [text input](@ref input_char). + * + * @param[in] window The desired window. + * @param[in] key The desired [keyboard key](@ref keys). `GLFW_KEY_UNKNOWN` is + * not a valid key for this function. + * @return One of `GLFW_PRESS` or `GLFW_RELEASE`. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref + * GLFW_INVALID_ENUM. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref input_key + * + * @since Added in version 1.0. + * @glfw3 Added window handle parameter. + * + * @ingroup input + */ +GLFWAPI int glfwGetKey(GLFWwindow* window, int key); + +/*! @brief Returns the last reported state of a mouse button for the specified + * window. + * + * This function returns the last state reported for the specified mouse button + * to the specified window. The returned state is one of `GLFW_PRESS` or + * `GLFW_RELEASE`. + * + * If the @ref GLFW_STICKY_MOUSE_BUTTONS input mode is enabled, this function + * returns `GLFW_PRESS` the first time you call it for a mouse button that was + * pressed, even if that mouse button has already been released. + * + * @param[in] window The desired window. + * @param[in] button The desired [mouse button](@ref buttons). + * @return One of `GLFW_PRESS` or `GLFW_RELEASE`. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref + * GLFW_INVALID_ENUM. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref input_mouse_button + * + * @since Added in version 1.0. + * @glfw3 Added window handle parameter. + * + * @ingroup input + */ +GLFWAPI int glfwGetMouseButton(GLFWwindow* window, int button); + +/*! @brief Retrieves the position of the cursor relative to the content area of + * the window. + * + * This function returns the position of the cursor, in screen coordinates, + * relative to the upper-left corner of the content area of the specified + * window. + * + * If the cursor is disabled (with `GLFW_CURSOR_DISABLED`) then the cursor + * position is unbounded and limited only by the minimum and maximum values of + * a `double`. + * + * The coordinate can be converted to their integer equivalents with the + * `floor` function. Casting directly to an integer type works for positive + * coordinates, but fails for negative ones. + * + * Any or all of the position arguments may be `NULL`. If an error occurs, all + * non-`NULL` position arguments will be set to zero. + * + * @param[in] window The desired window. + * @param[out] xpos Where to store the cursor x-coordinate, relative to the + * left edge of the content area, or `NULL`. + * @param[out] ypos Where to store the cursor y-coordinate, relative to the to + * top edge of the content area, or `NULL`. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref + * GLFW_PLATFORM_ERROR. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref cursor_pos + * @sa @ref glfwSetCursorPos + * + * @since Added in version 3.0. Replaces `glfwGetMousePos`. + * + * @ingroup input + */ +GLFWAPI void glfwGetCursorPos(GLFWwindow* window, double* xpos, double* ypos); + +/*! @brief Sets the position of the cursor, relative to the content area of the + * window. + * + * This function sets the position, in screen coordinates, of the cursor + * relative to the upper-left corner of the content area of the specified + * window. The window must have input focus. If the window does not have + * input focus when this function is called, it fails silently. + * + * __Do not use this function__ to implement things like camera controls. GLFW + * already provides the `GLFW_CURSOR_DISABLED` cursor mode that hides the + * cursor, transparently re-centers it and provides unconstrained cursor + * motion. See @ref glfwSetInputMode for more information. + * + * If the cursor mode is `GLFW_CURSOR_DISABLED` then the cursor position is + * unconstrained and limited only by the minimum and maximum values of + * a `double`. + * + * @param[in] window The desired window. + * @param[in] xpos The desired x-coordinate, relative to the left edge of the + * content area. + * @param[in] ypos The desired y-coordinate, relative to the top edge of the + * content area. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED, @ref + * GLFW_PLATFORM_ERROR and @ref GLFW_FEATURE_UNAVAILABLE (see remarks). + * + * @remark @wayland This function will only work when the cursor mode is + * `GLFW_CURSOR_DISABLED`, otherwise it will emit @ref GLFW_FEATURE_UNAVAILABLE. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref cursor_pos + * @sa @ref glfwGetCursorPos + * + * @since Added in version 3.0. Replaces `glfwSetMousePos`. + * + * @ingroup input + */ +GLFWAPI void glfwSetCursorPos(GLFWwindow* window, double xpos, double ypos); + +/*! @brief Creates a custom cursor. + * + * Creates a new custom cursor image that can be set for a window with @ref + * glfwSetCursor. The cursor can be destroyed with @ref glfwDestroyCursor. + * Any remaining cursors are destroyed by @ref glfwTerminate. + * + * The pixels are 32-bit, little-endian, non-premultiplied RGBA, i.e. eight + * bits per channel with the red channel first. They are arranged canonically + * as packed sequential rows, starting from the top-left corner. + * + * The cursor hotspot is specified in pixels, relative to the upper-left corner + * of the cursor image. Like all other coordinate systems in GLFW, the X-axis + * points to the right and the Y-axis points down. + * + * @param[in] image The desired cursor image. + * @param[in] xhot The desired x-coordinate, in pixels, of the cursor hotspot. + * @param[in] yhot The desired y-coordinate, in pixels, of the cursor hotspot. + * @return The handle of the created cursor, or `NULL` if an + * [error](@ref error_handling) occurred. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED, @ref + * GLFW_INVALID_VALUE and @ref GLFW_PLATFORM_ERROR. + * + * @pointer_lifetime The specified image data is copied before this function + * returns. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref cursor_object + * @sa @ref glfwDestroyCursor + * @sa @ref glfwCreateStandardCursor + * + * @since Added in version 3.1. + * + * @ingroup input + */ +GLFWAPI GLFWcursor* glfwCreateCursor(const GLFWimage* image, int xhot, int yhot); + +/*! @brief Creates a cursor with a standard shape. + * + * Returns a cursor with a standard shape, that can be set for a window with + * @ref glfwSetCursor. The images for these cursors come from the system + * cursor theme and their exact appearance will vary between platforms. + * + * Most of these shapes are guaranteed to exist on every supported platform but + * a few may not be present. See the table below for details. + * + * Cursor shape | Windows | macOS | X11 | Wayland + * ------------------------------ | ------- | ----- | ------ | ------- + * @ref GLFW_ARROW_CURSOR | Yes | Yes | Yes | Yes + * @ref GLFW_IBEAM_CURSOR | Yes | Yes | Yes | Yes + * @ref GLFW_CROSSHAIR_CURSOR | Yes | Yes | Yes | Yes + * @ref GLFW_POINTING_HAND_CURSOR | Yes | Yes | Yes | Yes + * @ref GLFW_RESIZE_EW_CURSOR | Yes | Yes | Yes | Yes + * @ref GLFW_RESIZE_NS_CURSOR | Yes | Yes | Yes | Yes + * @ref GLFW_RESIZE_NWSE_CURSOR | Yes | Yes1 | Maybe2 | Maybe2 + * @ref GLFW_RESIZE_NESW_CURSOR | Yes | Yes1 | Maybe2 | Maybe2 + * @ref GLFW_RESIZE_ALL_CURSOR | Yes | Yes | Yes | Yes + * @ref GLFW_NOT_ALLOWED_CURSOR | Yes | Yes | Maybe2 | Maybe2 + * + * 1) This uses a private system API and may fail in the future. + * + * 2) This uses a newer standard that not all cursor themes support. + * + * If the requested shape is not available, this function emits a @ref + * GLFW_CURSOR_UNAVAILABLE error and returns `NULL`. + * + * @param[in] shape One of the [standard shapes](@ref shapes). + * @return A new cursor ready to use or `NULL` if an + * [error](@ref error_handling) occurred. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED, @ref + * GLFW_INVALID_ENUM, @ref GLFW_CURSOR_UNAVAILABLE and @ref + * GLFW_PLATFORM_ERROR. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref cursor_standard + * @sa @ref glfwCreateCursor + * + * @since Added in version 3.1. + * + * @ingroup input + */ +GLFWAPI GLFWcursor* glfwCreateStandardCursor(int shape); + +/*! @brief Destroys a cursor. + * + * This function destroys a cursor previously created with @ref + * glfwCreateCursor. Any remaining cursors will be destroyed by @ref + * glfwTerminate. + * + * If the specified cursor is current for any window, that window will be + * reverted to the default cursor. This does not affect the cursor mode. + * + * @param[in] cursor The cursor object to destroy. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref + * GLFW_PLATFORM_ERROR. + * + * @reentrancy This function must not be called from a callback. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref cursor_object + * @sa @ref glfwCreateCursor + * + * @since Added in version 3.1. + * + * @ingroup input + */ +GLFWAPI void glfwDestroyCursor(GLFWcursor* cursor); + +/*! @brief Sets the cursor for the window. + * + * This function sets the cursor image to be used when the cursor is over the + * content area of the specified window. The set cursor will only be visible + * when the [cursor mode](@ref cursor_mode) of the window is + * `GLFW_CURSOR_NORMAL`. + * + * On some platforms, the set cursor may not be visible unless the window also + * has input focus. + * + * @param[in] window The window to set the cursor for. + * @param[in] cursor The cursor to set, or `NULL` to switch back to the default + * arrow cursor. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref + * GLFW_PLATFORM_ERROR. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref cursor_object + * + * @since Added in version 3.1. + * + * @ingroup input + */ +GLFWAPI void glfwSetCursor(GLFWwindow* window, GLFWcursor* cursor); + +/*! @brief Sets the key callback. + * + * This function sets the key callback of the specified window, which is called + * when a key is pressed, repeated or released. + * + * The key functions deal with physical keys, with layout independent + * [key tokens](@ref keys) named after their values in the standard US keyboard + * layout. If you want to input text, use the + * [character callback](@ref glfwSetCharCallback) instead. + * + * When a window loses input focus, it will generate synthetic key release + * events for all pressed keys with associated key tokens. You can tell these + * events from user-generated events by the fact that the synthetic ones are + * generated after the focus loss event has been processed, i.e. after the + * [window focus callback](@ref glfwSetWindowFocusCallback) has been called. + * + * The scancode of a key is specific to that platform or sometimes even to that + * machine. Scancodes are intended to allow users to bind keys that don't have + * a GLFW key token. Such keys have `key` set to `GLFW_KEY_UNKNOWN`, their + * state is not saved and so it cannot be queried with @ref glfwGetKey. + * + * Sometimes GLFW needs to generate synthetic key events, in which case the + * scancode may be zero. + * + * @param[in] window The window whose callback to set. + * @param[in] callback The new key callback, or `NULL` to remove the currently + * set callback. + * @return The previously set callback, or `NULL` if no callback was set or the + * library had not been [initialized](@ref intro_init). + * + * @callback_signature + * @code + * void function_name(GLFWwindow* window, int key, int scancode, int action, int mods) + * @endcode + * For more information about the callback parameters, see the + * [function pointer type](@ref GLFWkeyfun). + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref input_key + * + * @since Added in version 1.0. + * @glfw3 Added window handle parameter and return value. + * + * @ingroup input + */ +GLFWAPI GLFWkeyfun glfwSetKeyCallback(GLFWwindow* window, GLFWkeyfun callback); + +/*! @brief Sets the Unicode character callback. + * + * This function sets the character callback of the specified window, which is + * called when a Unicode character is input. + * + * The character callback is intended for Unicode text input. As it deals with + * characters, it is keyboard layout dependent, whereas the + * [key callback](@ref glfwSetKeyCallback) is not. Characters do not map 1:1 + * to physical keys, as a key may produce zero, one or more characters. If you + * want to know whether a specific physical key was pressed or released, see + * the key callback instead. + * + * The character callback behaves as system text input normally does and will + * not be called if modifier keys are held down that would prevent normal text + * input on that platform, for example a Super (Command) key on macOS or Alt key + * on Windows. + * + * @param[in] window The window whose callback to set. + * @param[in] callback The new callback, or `NULL` to remove the currently set + * callback. + * @return The previously set callback, or `NULL` if no callback was set or the + * library had not been [initialized](@ref intro_init). + * + * @callback_signature + * @code + * void function_name(GLFWwindow* window, unsigned int codepoint) + * @endcode + * For more information about the callback parameters, see the + * [function pointer type](@ref GLFWcharfun). + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref input_char + * + * @since Added in version 2.4. + * @glfw3 Added window handle parameter and return value. + * + * @ingroup input + */ +GLFWAPI GLFWcharfun glfwSetCharCallback(GLFWwindow* window, GLFWcharfun callback); + +/*! @brief Sets the Unicode character with modifiers callback. + * + * This function sets the character with modifiers callback of the specified + * window, which is called when a Unicode character is input regardless of what + * modifier keys are used. + * + * The character with modifiers callback is intended for implementing custom + * Unicode character input. For regular Unicode text input, see the + * [character callback](@ref glfwSetCharCallback). Like the character + * callback, the character with modifiers callback deals with characters and is + * keyboard layout dependent. Characters do not map 1:1 to physical keys, as + * a key may produce zero, one or more characters. If you want to know whether + * a specific physical key was pressed or released, see the + * [key callback](@ref glfwSetKeyCallback) instead. + * + * @param[in] window The window whose callback to set. + * @param[in] callback The new callback, or `NULL` to remove the currently set + * callback. + * @return The previously set callback, or `NULL` if no callback was set or an + * [error](@ref error_handling) occurred. + * + * @callback_signature + * @code + * void function_name(GLFWwindow* window, unsigned int codepoint, int mods) + * @endcode + * For more information about the callback parameters, see the + * [function pointer type](@ref GLFWcharmodsfun). + * + * @deprecated Scheduled for removal in version 4.0. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref input_char + * + * @since Added in version 3.1. + * + * @ingroup input + */ +GLFWAPI GLFWcharmodsfun glfwSetCharModsCallback(GLFWwindow* window, GLFWcharmodsfun callback); + +/*! @brief Sets the mouse button callback. + * + * This function sets the mouse button callback of the specified window, which + * is called when a mouse button is pressed or released. + * + * When a window loses input focus, it will generate synthetic mouse button + * release events for all pressed mouse buttons. You can tell these events + * from user-generated events by the fact that the synthetic ones are generated + * after the focus loss event has been processed, i.e. after the + * [window focus callback](@ref glfwSetWindowFocusCallback) has been called. + * + * @param[in] window The window whose callback to set. + * @param[in] callback The new callback, or `NULL` to remove the currently set + * callback. + * @return The previously set callback, or `NULL` if no callback was set or the + * library had not been [initialized](@ref intro_init). + * + * @callback_signature + * @code + * void function_name(GLFWwindow* window, int button, int action, int mods) + * @endcode + * For more information about the callback parameters, see the + * [function pointer type](@ref GLFWmousebuttonfun). + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref input_mouse_button + * + * @since Added in version 1.0. + * @glfw3 Added window handle parameter and return value. + * + * @ingroup input + */ +GLFWAPI GLFWmousebuttonfun glfwSetMouseButtonCallback(GLFWwindow* window, GLFWmousebuttonfun callback); + +/*! @brief Sets the cursor position callback. + * + * This function sets the cursor position callback of the specified window, + * which is called when the cursor is moved. The callback is provided with the + * position, in screen coordinates, relative to the upper-left corner of the + * content area of the window. + * + * @param[in] window The window whose callback to set. + * @param[in] callback The new callback, or `NULL` to remove the currently set + * callback. + * @return The previously set callback, or `NULL` if no callback was set or the + * library had not been [initialized](@ref intro_init). + * + * @callback_signature + * @code + * void function_name(GLFWwindow* window, double xpos, double ypos); + * @endcode + * For more information about the callback parameters, see the + * [function pointer type](@ref GLFWcursorposfun). + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref cursor_pos + * + * @since Added in version 3.0. Replaces `glfwSetMousePosCallback`. + * + * @ingroup input + */ +GLFWAPI GLFWcursorposfun glfwSetCursorPosCallback(GLFWwindow* window, GLFWcursorposfun callback); + +/*! @brief Sets the cursor enter/leave callback. + * + * This function sets the cursor boundary crossing callback of the specified + * window, which is called when the cursor enters or leaves the content area of + * the window. + * + * @param[in] window The window whose callback to set. + * @param[in] callback The new callback, or `NULL` to remove the currently set + * callback. + * @return The previously set callback, or `NULL` if no callback was set or the + * library had not been [initialized](@ref intro_init). + * + * @callback_signature + * @code + * void function_name(GLFWwindow* window, int entered) + * @endcode + * For more information about the callback parameters, see the + * [function pointer type](@ref GLFWcursorenterfun). + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref cursor_enter + * + * @since Added in version 3.0. + * + * @ingroup input + */ +GLFWAPI GLFWcursorenterfun glfwSetCursorEnterCallback(GLFWwindow* window, GLFWcursorenterfun callback); + +/*! @brief Sets the scroll callback. + * + * This function sets the scroll callback of the specified window, which is + * called when a scrolling device is used, such as a mouse wheel or scrolling + * area of a touchpad. + * + * The scroll callback receives all scrolling input, like that from a mouse + * wheel or a touchpad scrolling area. + * + * @param[in] window The window whose callback to set. + * @param[in] callback The new scroll callback, or `NULL` to remove the + * currently set callback. + * @return The previously set callback, or `NULL` if no callback was set or the + * library had not been [initialized](@ref intro_init). + * + * @callback_signature + * @code + * void function_name(GLFWwindow* window, double xoffset, double yoffset) + * @endcode + * For more information about the callback parameters, see the + * [function pointer type](@ref GLFWscrollfun). + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref scrolling + * + * @since Added in version 3.0. Replaces `glfwSetMouseWheelCallback`. + * + * @ingroup input + */ +GLFWAPI GLFWscrollfun glfwSetScrollCallback(GLFWwindow* window, GLFWscrollfun callback); + +/*! @brief Sets the path drop callback. + * + * This function sets the path drop callback of the specified window, which is + * called when one or more dragged paths are dropped on the window. + * + * Because the path array and its strings may have been generated specifically + * for that event, they are not guaranteed to be valid after the callback has + * returned. If you wish to use them after the callback returns, you need to + * make a deep copy. + * + * @param[in] window The window whose callback to set. + * @param[in] callback The new file drop callback, or `NULL` to remove the + * currently set callback. + * @return The previously set callback, or `NULL` if no callback was set or the + * library had not been [initialized](@ref intro_init). + * + * @callback_signature + * @code + * void function_name(GLFWwindow* window, int path_count, const char* paths[]) + * @endcode + * For more information about the callback parameters, see the + * [function pointer type](@ref GLFWdropfun). + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref path_drop + * + * @since Added in version 3.1. + * + * @ingroup input + */ +GLFWAPI GLFWdropfun glfwSetDropCallback(GLFWwindow* window, GLFWdropfun callback); + +/*! @brief Returns whether the specified joystick is present. + * + * This function returns whether the specified joystick is present. + * + * There is no need to call this function before other functions that accept + * a joystick ID, as they all check for presence before performing any other + * work. + * + * @param[in] jid The [joystick](@ref joysticks) to query. + * @return `GLFW_TRUE` if the joystick is present, or `GLFW_FALSE` otherwise. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED, @ref + * GLFW_INVALID_ENUM and @ref GLFW_PLATFORM_ERROR. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref joystick + * + * @since Added in version 3.0. Replaces `glfwGetJoystickParam`. + * + * @ingroup input + */ +GLFWAPI int glfwJoystickPresent(int jid); + +/*! @brief Returns the values of all axes of the specified joystick. + * + * This function returns the values of all axes of the specified joystick. + * Each element in the array is a value between -1.0 and 1.0. + * + * If the specified joystick is not present this function will return `NULL` + * but will not generate an error. This can be used instead of first calling + * @ref glfwJoystickPresent. + * + * @param[in] jid The [joystick](@ref joysticks) to query. + * @param[out] count Where to store the number of axis values in the returned + * array. This is set to zero if the joystick is not present or an error + * occurred. + * @return An array of axis values, or `NULL` if the joystick is not present or + * an [error](@ref error_handling) occurred. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED, @ref + * GLFW_INVALID_ENUM and @ref GLFW_PLATFORM_ERROR. + * + * @pointer_lifetime The returned array is allocated and freed by GLFW. You + * should not free it yourself. It is valid until the specified joystick is + * disconnected or the library is terminated. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref joystick_axis + * + * @since Added in version 3.0. Replaces `glfwGetJoystickPos`. + * + * @ingroup input + */ +GLFWAPI const float* glfwGetJoystickAxes(int jid, int* count); + +/*! @brief Returns the state of all buttons of the specified joystick. + * + * This function returns the state of all buttons of the specified joystick. + * Each element in the array is either `GLFW_PRESS` or `GLFW_RELEASE`. + * + * For backward compatibility with earlier versions that did not have @ref + * glfwGetJoystickHats, the button array also includes all hats, each + * represented as four buttons. The hats are in the same order as returned by + * __glfwGetJoystickHats__ and are in the order _up_, _right_, _down_ and + * _left_. To disable these extra buttons, set the @ref + * GLFW_JOYSTICK_HAT_BUTTONS init hint before initialization. + * + * If the specified joystick is not present this function will return `NULL` + * but will not generate an error. This can be used instead of first calling + * @ref glfwJoystickPresent. + * + * @param[in] jid The [joystick](@ref joysticks) to query. + * @param[out] count Where to store the number of button states in the returned + * array. This is set to zero if the joystick is not present or an error + * occurred. + * @return An array of button states, or `NULL` if the joystick is not present + * or an [error](@ref error_handling) occurred. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED, @ref + * GLFW_INVALID_ENUM and @ref GLFW_PLATFORM_ERROR. + * + * @pointer_lifetime The returned array is allocated and freed by GLFW. You + * should not free it yourself. It is valid until the specified joystick is + * disconnected or the library is terminated. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref joystick_button + * + * @since Added in version 2.2. + * @glfw3 Changed to return a dynamic array. + * + * @ingroup input + */ +GLFWAPI const unsigned char* glfwGetJoystickButtons(int jid, int* count); + +/*! @brief Returns the state of all hats of the specified joystick. + * + * This function returns the state of all hats of the specified joystick. + * Each element in the array is one of the following values: + * + * Name | Value + * ---- | ----- + * `GLFW_HAT_CENTERED` | 0 + * `GLFW_HAT_UP` | 1 + * `GLFW_HAT_RIGHT` | 2 + * `GLFW_HAT_DOWN` | 4 + * `GLFW_HAT_LEFT` | 8 + * `GLFW_HAT_RIGHT_UP` | `GLFW_HAT_RIGHT` \| `GLFW_HAT_UP` + * `GLFW_HAT_RIGHT_DOWN` | `GLFW_HAT_RIGHT` \| `GLFW_HAT_DOWN` + * `GLFW_HAT_LEFT_UP` | `GLFW_HAT_LEFT` \| `GLFW_HAT_UP` + * `GLFW_HAT_LEFT_DOWN` | `GLFW_HAT_LEFT` \| `GLFW_HAT_DOWN` + * + * The diagonal directions are bitwise combinations of the primary (up, right, + * down and left) directions and you can test for these individually by ANDing + * it with the corresponding direction. + * + * @code + * if (hats[2] & GLFW_HAT_RIGHT) + * { + * // State of hat 2 could be right-up, right or right-down + * } + * @endcode + * + * If the specified joystick is not present this function will return `NULL` + * but will not generate an error. This can be used instead of first calling + * @ref glfwJoystickPresent. + * + * @param[in] jid The [joystick](@ref joysticks) to query. + * @param[out] count Where to store the number of hat states in the returned + * array. This is set to zero if the joystick is not present or an error + * occurred. + * @return An array of hat states, or `NULL` if the joystick is not present + * or an [error](@ref error_handling) occurred. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED, @ref + * GLFW_INVALID_ENUM and @ref GLFW_PLATFORM_ERROR. + * + * @pointer_lifetime The returned array is allocated and freed by GLFW. You + * should not free it yourself. It is valid until the specified joystick is + * disconnected, this function is called again for that joystick or the library + * is terminated. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref joystick_hat + * + * @since Added in version 3.3. + * + * @ingroup input + */ +GLFWAPI const unsigned char* glfwGetJoystickHats(int jid, int* count); + +/*! @brief Returns the name of the specified joystick. + * + * This function returns the name, encoded as UTF-8, of the specified joystick. + * The returned string is allocated and freed by GLFW. You should not free it + * yourself. + * + * If the specified joystick is not present this function will return `NULL` + * but will not generate an error. This can be used instead of first calling + * @ref glfwJoystickPresent. + * + * @param[in] jid The [joystick](@ref joysticks) to query. + * @return The UTF-8 encoded name of the joystick, or `NULL` if the joystick + * is not present or an [error](@ref error_handling) occurred. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED, @ref + * GLFW_INVALID_ENUM and @ref GLFW_PLATFORM_ERROR. + * + * @pointer_lifetime The returned string is allocated and freed by GLFW. You + * should not free it yourself. It is valid until the specified joystick is + * disconnected or the library is terminated. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref joystick_name + * + * @since Added in version 3.0. + * + * @ingroup input + */ +GLFWAPI const char* glfwGetJoystickName(int jid); + +/*! @brief Returns the SDL compatible GUID of the specified joystick. + * + * This function returns the SDL compatible GUID, as a UTF-8 encoded + * hexadecimal string, of the specified joystick. The returned string is + * allocated and freed by GLFW. You should not free it yourself. + * + * The GUID is what connects a joystick to a gamepad mapping. A connected + * joystick will always have a GUID even if there is no gamepad mapping + * assigned to it. + * + * If the specified joystick is not present this function will return `NULL` + * but will not generate an error. This can be used instead of first calling + * @ref glfwJoystickPresent. + * + * The GUID uses the format introduced in SDL 2.0.5. This GUID tries to + * uniquely identify the make and model of a joystick but does not identify + * a specific unit, e.g. all wired Xbox 360 controllers will have the same + * GUID on that platform. The GUID for a unit may vary between platforms + * depending on what hardware information the platform specific APIs provide. + * + * @param[in] jid The [joystick](@ref joysticks) to query. + * @return The UTF-8 encoded GUID of the joystick, or `NULL` if the joystick + * is not present or an [error](@ref error_handling) occurred. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED, @ref + * GLFW_INVALID_ENUM and @ref GLFW_PLATFORM_ERROR. + * + * @pointer_lifetime The returned string is allocated and freed by GLFW. You + * should not free it yourself. It is valid until the specified joystick is + * disconnected or the library is terminated. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref gamepad + * + * @since Added in version 3.3. + * + * @ingroup input + */ +GLFWAPI const char* glfwGetJoystickGUID(int jid); + +/*! @brief Sets the user pointer of the specified joystick. + * + * This function sets the user-defined pointer of the specified joystick. The + * current value is retained until the joystick is disconnected. The initial + * value is `NULL`. + * + * This function may be called from the joystick callback, even for a joystick + * that is being disconnected. + * + * @param[in] jid The joystick whose pointer to set. + * @param[in] pointer The new value. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED. + * + * @thread_safety This function may be called from any thread. Access is not + * synchronized. + * + * @sa @ref joystick_userptr + * @sa @ref glfwGetJoystickUserPointer + * + * @since Added in version 3.3. + * + * @ingroup input + */ +GLFWAPI void glfwSetJoystickUserPointer(int jid, void* pointer); + +/*! @brief Returns the user pointer of the specified joystick. + * + * This function returns the current value of the user-defined pointer of the + * specified joystick. The initial value is `NULL`. + * + * This function may be called from the joystick callback, even for a joystick + * that is being disconnected. + * + * @param[in] jid The joystick whose pointer to return. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED. + * + * @thread_safety This function may be called from any thread. Access is not + * synchronized. + * + * @sa @ref joystick_userptr + * @sa @ref glfwSetJoystickUserPointer + * + * @since Added in version 3.3. + * + * @ingroup input + */ +GLFWAPI void* glfwGetJoystickUserPointer(int jid); + +/*! @brief Returns whether the specified joystick has a gamepad mapping. + * + * This function returns whether the specified joystick is both present and has + * a gamepad mapping. + * + * If the specified joystick is present but does not have a gamepad mapping + * this function will return `GLFW_FALSE` but will not generate an error. Call + * @ref glfwJoystickPresent to check if a joystick is present regardless of + * whether it has a mapping. + * + * @param[in] jid The [joystick](@ref joysticks) to query. + * @return `GLFW_TRUE` if a joystick is both present and has a gamepad mapping, + * or `GLFW_FALSE` otherwise. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref + * GLFW_INVALID_ENUM. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref gamepad + * @sa @ref glfwGetGamepadState + * + * @since Added in version 3.3. + * + * @ingroup input + */ +GLFWAPI int glfwJoystickIsGamepad(int jid); + +/*! @brief Sets the joystick configuration callback. + * + * This function sets the joystick configuration callback, or removes the + * currently set callback. This is called when a joystick is connected to or + * disconnected from the system. + * + * For joystick connection and disconnection events to be delivered on all + * platforms, you need to call one of the [event processing](@ref events) + * functions. Joystick disconnection may also be detected and the callback + * called by joystick functions. The function will then return whatever it + * returns if the joystick is not present. + * + * @param[in] callback The new callback, or `NULL` to remove the currently set + * callback. + * @return The previously set callback, or `NULL` if no callback was set or the + * library had not been [initialized](@ref intro_init). + * + * @callback_signature + * @code + * void function_name(int jid, int event) + * @endcode + * For more information about the callback parameters, see the + * [function pointer type](@ref GLFWjoystickfun). + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref joystick_event + * + * @since Added in version 3.2. + * + * @ingroup input + */ +GLFWAPI GLFWjoystickfun glfwSetJoystickCallback(GLFWjoystickfun callback); + +/*! @brief Adds the specified SDL_GameControllerDB gamepad mappings. + * + * This function parses the specified ASCII encoded string and updates the + * internal list with any gamepad mappings it finds. This string may + * contain either a single gamepad mapping or many mappings separated by + * newlines. The parser supports the full format of the `gamecontrollerdb.txt` + * source file including empty lines and comments. + * + * See @ref gamepad_mapping for a description of the format. + * + * If there is already a gamepad mapping for a given GUID in the internal list, + * it will be replaced by the one passed to this function. If the library is + * terminated and re-initialized the internal list will revert to the built-in + * default. + * + * @param[in] string The string containing the gamepad mappings. + * @return `GLFW_TRUE` if successful, or `GLFW_FALSE` if an + * [error](@ref error_handling) occurred. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref + * GLFW_INVALID_VALUE. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref gamepad + * @sa @ref glfwJoystickIsGamepad + * @sa @ref glfwGetGamepadName + * + * @since Added in version 3.3. + * + * @ingroup input + */ +GLFWAPI int glfwUpdateGamepadMappings(const char* string); + +/*! @brief Returns the human-readable gamepad name for the specified joystick. + * + * This function returns the human-readable name of the gamepad from the + * gamepad mapping assigned to the specified joystick. + * + * If the specified joystick is not present or does not have a gamepad mapping + * this function will return `NULL` but will not generate an error. Call + * @ref glfwJoystickPresent to check whether it is present regardless of + * whether it has a mapping. + * + * @param[in] jid The [joystick](@ref joysticks) to query. + * @return The UTF-8 encoded name of the gamepad, or `NULL` if the + * joystick is not present, does not have a mapping or an + * [error](@ref error_handling) occurred. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref GLFW_INVALID_ENUM. + * + * @pointer_lifetime The returned string is allocated and freed by GLFW. You + * should not free it yourself. It is valid until the specified joystick is + * disconnected, the gamepad mappings are updated or the library is terminated. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref gamepad + * @sa @ref glfwJoystickIsGamepad + * + * @since Added in version 3.3. + * + * @ingroup input + */ +GLFWAPI const char* glfwGetGamepadName(int jid); + +/*! @brief Retrieves the state of the specified joystick remapped as a gamepad. + * + * This function retrieves the state of the specified joystick remapped to + * an Xbox-like gamepad. + * + * If the specified joystick is not present or does not have a gamepad mapping + * this function will return `GLFW_FALSE` but will not generate an error. Call + * @ref glfwJoystickPresent to check whether it is present regardless of + * whether it has a mapping. + * + * The Guide button may not be available for input as it is often hooked by the + * system or the Steam client. + * + * Not all devices have all the buttons or axes provided by @ref + * GLFWgamepadstate. Unavailable buttons and axes will always report + * `GLFW_RELEASE` and 0.0 respectively. + * + * @param[in] jid The [joystick](@ref joysticks) to query. + * @param[out] state The gamepad input state of the joystick. + * @return `GLFW_TRUE` if successful, or `GLFW_FALSE` if no joystick is + * connected, it has no gamepad mapping or an [error](@ref error_handling) + * occurred. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref + * GLFW_INVALID_ENUM. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref gamepad + * @sa @ref glfwUpdateGamepadMappings + * @sa @ref glfwJoystickIsGamepad + * + * @since Added in version 3.3. + * + * @ingroup input + */ +GLFWAPI int glfwGetGamepadState(int jid, GLFWgamepadstate* state); + +/*! @brief Sets the clipboard to the specified string. + * + * This function sets the system clipboard to the specified, UTF-8 encoded + * string. + * + * @param[in] window Deprecated. Any valid window or `NULL`. + * @param[in] string A UTF-8 encoded string. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref + * GLFW_PLATFORM_ERROR. + * + * @remark @win32 The clipboard on Windows has a single global lock for reading and + * writing. GLFW tries to acquire it a few times, which is almost always enough. If it + * cannot acquire the lock then this function emits @ref GLFW_PLATFORM_ERROR and returns. + * It is safe to try this multiple times. + * + * @pointer_lifetime The specified string is copied before this function + * returns. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref clipboard + * @sa @ref glfwGetClipboardString + * + * @since Added in version 3.0. + * + * @ingroup input + */ +GLFWAPI void glfwSetClipboardString(GLFWwindow* window, const char* string); + +/*! @brief Returns the contents of the clipboard as a string. + * + * This function returns the contents of the system clipboard, if it contains + * or is convertible to a UTF-8 encoded string. If the clipboard is empty or + * if its contents cannot be converted, `NULL` is returned and a @ref + * GLFW_FORMAT_UNAVAILABLE error is generated. + * + * @param[in] window Deprecated. Any valid window or `NULL`. + * @return The contents of the clipboard as a UTF-8 encoded string, or `NULL` + * if an [error](@ref error_handling) occurred. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED, @ref + * GLFW_FORMAT_UNAVAILABLE and @ref GLFW_PLATFORM_ERROR. + * + * @remark @win32 The clipboard on Windows has a single global lock for reading and + * writing. GLFW tries to acquire it a few times, which is almost always enough. If it + * cannot acquire the lock then this function emits @ref GLFW_PLATFORM_ERROR and returns. + * It is safe to try this multiple times. + * + * @pointer_lifetime The returned string is allocated and freed by GLFW. You + * should not free it yourself. It is valid until the next call to @ref + * glfwGetClipboardString or @ref glfwSetClipboardString, or until the library + * is terminated. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref clipboard + * @sa @ref glfwSetClipboardString + * + * @since Added in version 3.0. + * + * @ingroup input + */ +GLFWAPI const char* glfwGetClipboardString(GLFWwindow* window); + +/*! @brief Returns the GLFW time. + * + * This function returns the current GLFW time, in seconds. Unless the time + * has been set using @ref glfwSetTime it measures time elapsed since GLFW was + * initialized. + * + * This function and @ref glfwSetTime are helper functions on top of @ref + * glfwGetTimerFrequency and @ref glfwGetTimerValue. + * + * The resolution of the timer is system dependent, but is usually on the order + * of a few micro- or nanoseconds. It uses the highest-resolution monotonic + * time source on each operating system. + * + * @return The current time, in seconds, or zero if an + * [error](@ref error_handling) occurred. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED. + * + * @thread_safety This function may be called from any thread. Reading and + * writing of the internal base time is not atomic, so it needs to be + * externally synchronized with calls to @ref glfwSetTime. + * + * @sa @ref time + * + * @since Added in version 1.0. + * + * @ingroup input + */ +GLFWAPI double glfwGetTime(void); + +/*! @brief Sets the GLFW time. + * + * This function sets the current GLFW time, in seconds. The value must be + * a positive finite number less than or equal to 18446744073.0, which is + * approximately 584.5 years. + * + * This function and @ref glfwGetTime are helper functions on top of @ref + * glfwGetTimerFrequency and @ref glfwGetTimerValue. + * + * @param[in] time The new value, in seconds. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref + * GLFW_INVALID_VALUE. + * + * @remark The upper limit of GLFW time is calculated as + * floor((264 - 1) / 109) and is due to implementations + * storing nanoseconds in 64 bits. The limit may be increased in the future. + * + * @thread_safety This function may be called from any thread. Reading and + * writing of the internal base time is not atomic, so it needs to be + * externally synchronized with calls to @ref glfwGetTime. + * + * @sa @ref time + * + * @since Added in version 2.2. + * + * @ingroup input + */ +GLFWAPI void glfwSetTime(double time); + +/*! @brief Returns the current value of the raw timer. + * + * This function returns the current value of the raw timer, measured in + * 1 / frequency seconds. To get the frequency, call @ref + * glfwGetTimerFrequency. + * + * @return The value of the timer, or zero if an + * [error](@ref error_handling) occurred. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED. + * + * @thread_safety This function may be called from any thread. + * + * @sa @ref time + * @sa @ref glfwGetTimerFrequency + * + * @since Added in version 3.2. + * + * @ingroup input + */ +GLFWAPI uint64_t glfwGetTimerValue(void); + +/*! @brief Returns the frequency, in Hz, of the raw timer. + * + * This function returns the frequency, in Hz, of the raw timer. + * + * @return The frequency of the timer, in Hz, or zero if an + * [error](@ref error_handling) occurred. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED. + * + * @thread_safety This function may be called from any thread. + * + * @sa @ref time + * @sa @ref glfwGetTimerValue + * + * @since Added in version 3.2. + * + * @ingroup input + */ +GLFWAPI uint64_t glfwGetTimerFrequency(void); + +/*! @brief Makes the context of the specified window current for the calling + * thread. + * + * This function makes the OpenGL or OpenGL ES context of the specified window + * current on the calling thread. It can also detach the current context from + * the calling thread without making a new one current by passing in `NULL`. + * + * A context must only be made current on a single thread at a time and each + * thread can have only a single current context at a time. Making a context + * current detaches any previously current context on the calling thread. + * + * When moving a context between threads, you must detach it (make it + * non-current) on the old thread before making it current on the new one. + * + * By default, making a context non-current implicitly forces a pipeline flush. + * On machines that support `GL_KHR_context_flush_control`, you can control + * whether a context performs this flush by setting the + * [GLFW_CONTEXT_RELEASE_BEHAVIOR](@ref GLFW_CONTEXT_RELEASE_BEHAVIOR_hint) + * hint. + * + * The specified window must have an OpenGL or OpenGL ES context. Specifying + * a window without a context will generate a @ref GLFW_NO_WINDOW_CONTEXT + * error. + * + * @param[in] window The window whose context to make current, or `NULL` to + * detach the current context. + * + * @remarks If the previously current context was created via a different + * context creation API than the one passed to this function, GLFW will still + * detach the previous one from its API before making the new one current. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED, @ref + * GLFW_NO_WINDOW_CONTEXT and @ref GLFW_PLATFORM_ERROR. + * + * @thread_safety This function may be called from any thread. + * + * @sa @ref context_current + * @sa @ref glfwGetCurrentContext + * + * @since Added in version 3.0. + * + * @ingroup context + */ +GLFWAPI void glfwMakeContextCurrent(GLFWwindow* window); + +/*! @brief Returns the window whose context is current on the calling thread. + * + * This function returns the window whose OpenGL or OpenGL ES context is + * current on the calling thread. + * + * @return The window whose context is current, or `NULL` if no window's + * context is current. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED. + * + * @thread_safety This function may be called from any thread. + * + * @sa @ref context_current + * @sa @ref glfwMakeContextCurrent + * + * @since Added in version 3.0. + * + * @ingroup context + */ +GLFWAPI GLFWwindow* glfwGetCurrentContext(void); + +/*! @brief Swaps the front and back buffers of the specified window. + * + * This function swaps the front and back buffers of the specified window when + * rendering with OpenGL or OpenGL ES. If the swap interval is greater than + * zero, the GPU driver waits the specified number of screen updates before + * swapping the buffers. + * + * The specified window must have an OpenGL or OpenGL ES context. Specifying + * a window without a context will generate a @ref GLFW_NO_WINDOW_CONTEXT + * error. + * + * This function does not apply to Vulkan. If you are rendering with Vulkan, + * see `vkQueuePresentKHR` instead. + * + * @param[in] window The window whose buffers to swap. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED, @ref + * GLFW_NO_WINDOW_CONTEXT and @ref GLFW_PLATFORM_ERROR. + * + * @remark __EGL:__ The context of the specified window must be current on the + * calling thread. + * + * @thread_safety This function may be called from any thread. + * + * @sa @ref buffer_swap + * @sa @ref glfwSwapInterval + * + * @since Added in version 1.0. + * @glfw3 Added window handle parameter. + * + * @ingroup window + */ +GLFWAPI void glfwSwapBuffers(GLFWwindow* window); + +/*! @brief Sets the swap interval for the current context. + * + * This function sets the swap interval for the current OpenGL or OpenGL ES + * context, i.e. the number of screen updates to wait from the time @ref + * glfwSwapBuffers was called before swapping the buffers and returning. This + * is sometimes called _vertical synchronization_, _vertical retrace + * synchronization_ or just _vsync_. + * + * A context that supports either of the `WGL_EXT_swap_control_tear` and + * `GLX_EXT_swap_control_tear` extensions also accepts _negative_ swap + * intervals, which allows the driver to swap immediately even if a frame + * arrives a little bit late. You can check for these extensions with @ref + * glfwExtensionSupported. + * + * A context must be current on the calling thread. Calling this function + * without a current context will cause a @ref GLFW_NO_CURRENT_CONTEXT error. + * + * This function does not apply to Vulkan. If you are rendering with Vulkan, + * see the present mode of your swapchain instead. + * + * @param[in] interval The minimum number of screen updates to wait for + * until the buffers are swapped by @ref glfwSwapBuffers. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED, @ref + * GLFW_NO_CURRENT_CONTEXT and @ref GLFW_PLATFORM_ERROR. + * + * @remark This function is not called during context creation, leaving the + * swap interval set to whatever is the default for that API. This is done + * because some swap interval extensions used by GLFW do not allow the swap + * interval to be reset to zero once it has been set to a non-zero value. + * + * @remark Some GPU drivers do not honor the requested swap interval, either + * because of a user setting that overrides the application's request or due to + * bugs in the driver. + * + * @thread_safety This function may be called from any thread. + * + * @sa @ref buffer_swap + * @sa @ref glfwSwapBuffers + * + * @since Added in version 1.0. + * + * @ingroup context + */ +GLFWAPI void glfwSwapInterval(int interval); + +/*! @brief Returns whether the specified extension is available. + * + * This function returns whether the specified + * [API extension](@ref context_glext) is supported by the current OpenGL or + * OpenGL ES context. It searches both for client API extension and context + * creation API extensions. + * + * A context must be current on the calling thread. Calling this function + * without a current context will cause a @ref GLFW_NO_CURRENT_CONTEXT error. + * + * As this functions retrieves and searches one or more extension strings each + * call, it is recommended that you cache its results if it is going to be used + * frequently. The extension strings will not change during the lifetime of + * a context, so there is no danger in doing this. + * + * This function does not apply to Vulkan. If you are using Vulkan, see @ref + * glfwGetRequiredInstanceExtensions, `vkEnumerateInstanceExtensionProperties` + * and `vkEnumerateDeviceExtensionProperties` instead. + * + * @param[in] extension The ASCII encoded name of the extension. + * @return `GLFW_TRUE` if the extension is available, or `GLFW_FALSE` + * otherwise. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED, @ref + * GLFW_NO_CURRENT_CONTEXT, @ref GLFW_INVALID_VALUE and @ref + * GLFW_PLATFORM_ERROR. + * + * @thread_safety This function may be called from any thread. + * + * @sa @ref context_glext + * @sa @ref glfwGetProcAddress + * + * @since Added in version 1.0. + * + * @ingroup context + */ +GLFWAPI int glfwExtensionSupported(const char* extension); + +/*! @brief Returns the address of the specified function for the current + * context. + * + * This function returns the address of the specified OpenGL or OpenGL ES + * [core or extension function](@ref context_glext), if it is supported + * by the current context. + * + * A context must be current on the calling thread. Calling this function + * without a current context will cause a @ref GLFW_NO_CURRENT_CONTEXT error. + * + * This function does not apply to Vulkan. If you are rendering with Vulkan, + * see @ref glfwGetInstanceProcAddress, `vkGetInstanceProcAddr` and + * `vkGetDeviceProcAddr` instead. + * + * @param[in] procname The ASCII encoded name of the function. + * @return The address of the function, or `NULL` if an + * [error](@ref error_handling) occurred. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED, @ref + * GLFW_NO_CURRENT_CONTEXT and @ref GLFW_PLATFORM_ERROR. + * + * @remark The address of a given function is not guaranteed to be the same + * between contexts. + * + * @remark This function may return a non-`NULL` address despite the + * associated version or extension not being available. Always check the + * context version or extension string first. + * + * @pointer_lifetime The returned function pointer is valid until the context + * is destroyed or the library is terminated. + * + * @thread_safety This function may be called from any thread. + * + * @sa @ref context_glext + * @sa @ref glfwExtensionSupported + * + * @since Added in version 1.0. + * + * @ingroup context + */ +GLFWAPI GLFWglproc glfwGetProcAddress(const char* procname); + +/*! @brief Returns whether the Vulkan loader and an ICD have been found. + * + * This function returns whether the Vulkan loader and any minimally functional + * ICD have been found. + * + * The availability of a Vulkan loader and even an ICD does not by itself guarantee that + * surface creation or even instance creation is possible. Call @ref + * glfwGetRequiredInstanceExtensions to check whether the extensions necessary for Vulkan + * surface creation are available and @ref glfwGetPhysicalDevicePresentationSupport to + * check whether a queue family of a physical device supports image presentation. + * + * @return `GLFW_TRUE` if Vulkan is minimally available, or `GLFW_FALSE` + * otherwise. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED. + * + * @thread_safety This function may be called from any thread. + * + * @sa @ref vulkan_support + * + * @since Added in version 3.2. + * + * @ingroup vulkan + */ +GLFWAPI int glfwVulkanSupported(void); + +/*! @brief Returns the Vulkan instance extensions required by GLFW. + * + * This function returns an array of names of Vulkan instance extensions required + * by GLFW for creating Vulkan surfaces for GLFW windows. If successful, the + * list will always contain `VK_KHR_surface`, so if you don't require any + * additional extensions you can pass this list directly to the + * `VkInstanceCreateInfo` struct. + * + * If Vulkan is not available on the machine, this function returns `NULL` and + * generates a @ref GLFW_API_UNAVAILABLE error. Call @ref glfwVulkanSupported + * to check whether Vulkan is at least minimally available. + * + * If Vulkan is available but no set of extensions allowing window surface + * creation was found, this function returns `NULL`. You may still use Vulkan + * for off-screen rendering and compute work. + * + * @param[out] count Where to store the number of extensions in the returned + * array. This is set to zero if an error occurred. + * @return An array of ASCII encoded extension names, or `NULL` if an + * [error](@ref error_handling) occurred. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref + * GLFW_API_UNAVAILABLE. + * + * @remark Additional extensions may be required by future versions of GLFW. + * You should check if any extensions you wish to enable are already in the + * returned array, as it is an error to specify an extension more than once in + * the `VkInstanceCreateInfo` struct. + * + * @pointer_lifetime The returned array is allocated and freed by GLFW. You + * should not free it yourself. It is guaranteed to be valid only until the + * library is terminated. + * + * @thread_safety This function may be called from any thread. + * + * @sa @ref vulkan_ext + * @sa @ref glfwCreateWindowSurface + * + * @since Added in version 3.2. + * + * @ingroup vulkan + */ +GLFWAPI const char** glfwGetRequiredInstanceExtensions(uint32_t* count); + +#if defined(VK_VERSION_1_0) + +/*! @brief Returns the address of the specified Vulkan instance function. + * + * This function returns the address of the specified Vulkan core or extension + * function for the specified instance. If instance is set to `NULL` it can + * return any function exported from the Vulkan loader, including at least the + * following functions: + * + * - `vkEnumerateInstanceExtensionProperties` + * - `vkEnumerateInstanceLayerProperties` + * - `vkCreateInstance` + * - `vkGetInstanceProcAddr` + * + * If Vulkan is not available on the machine, this function returns `NULL` and + * generates a @ref GLFW_API_UNAVAILABLE error. Call @ref glfwVulkanSupported + * to check whether Vulkan is at least minimally available. + * + * This function is equivalent to calling `vkGetInstanceProcAddr` with + * a platform-specific query of the Vulkan loader as a fallback. + * + * @param[in] instance The Vulkan instance to query, or `NULL` to retrieve + * functions related to instance creation. + * @param[in] procname The ASCII encoded name of the function. + * @return The address of the function, or `NULL` if an + * [error](@ref error_handling) occurred. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref + * GLFW_API_UNAVAILABLE. + * + * @pointer_lifetime The returned function pointer is valid until the library + * is terminated. + * + * @thread_safety This function may be called from any thread. + * + * @sa @ref vulkan_proc + * + * @since Added in version 3.2. + * + * @ingroup vulkan + */ +GLFWAPI GLFWvkproc glfwGetInstanceProcAddress(VkInstance instance, const char* procname); + +/*! @brief Returns whether the specified queue family can present images. + * + * This function returns whether the specified queue family of the specified + * physical device supports presentation to the platform GLFW was built for. + * + * If Vulkan or the required window surface creation instance extensions are + * not available on the machine, or if the specified instance was not created + * with the required extensions, this function returns `GLFW_FALSE` and + * generates a @ref GLFW_API_UNAVAILABLE error. Call @ref glfwVulkanSupported + * to check whether Vulkan is at least minimally available and @ref + * glfwGetRequiredInstanceExtensions to check what instance extensions are + * required. + * + * @param[in] instance The instance that the physical device belongs to. + * @param[in] device The physical device that the queue family belongs to. + * @param[in] queuefamily The index of the queue family to query. + * @return `GLFW_TRUE` if the queue family supports presentation, or + * `GLFW_FALSE` otherwise. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED, @ref + * GLFW_API_UNAVAILABLE and @ref GLFW_PLATFORM_ERROR. + * + * @remark @macos This function currently always returns `GLFW_TRUE`, as the + * `VK_MVK_macos_surface` and `VK_EXT_metal_surface` extensions do not provide + * a `vkGetPhysicalDevice*PresentationSupport` type function. + * + * @thread_safety This function may be called from any thread. For + * synchronization details of Vulkan objects, see the Vulkan specification. + * + * @sa @ref vulkan_present + * + * @since Added in version 3.2. + * + * @ingroup vulkan + */ +GLFWAPI int glfwGetPhysicalDevicePresentationSupport(VkInstance instance, VkPhysicalDevice device, uint32_t queuefamily); + +/*! @brief Creates a Vulkan surface for the specified window. + * + * This function creates a Vulkan surface for the specified window. + * + * If the Vulkan loader or at least one minimally functional ICD were not found, + * this function returns `VK_ERROR_INITIALIZATION_FAILED` and generates a @ref + * GLFW_API_UNAVAILABLE error. Call @ref glfwVulkanSupported to check whether + * Vulkan is at least minimally available. + * + * If the required window surface creation instance extensions are not + * available or if the specified instance was not created with these extensions + * enabled, this function returns `VK_ERROR_EXTENSION_NOT_PRESENT` and + * generates a @ref GLFW_API_UNAVAILABLE error. Call @ref + * glfwGetRequiredInstanceExtensions to check what instance extensions are + * required. + * + * The window surface cannot be shared with another API so the window must + * have been created with the [client api hint](@ref GLFW_CLIENT_API_attrib) + * set to `GLFW_NO_API` otherwise it generates a @ref GLFW_INVALID_VALUE error + * and returns `VK_ERROR_NATIVE_WINDOW_IN_USE_KHR`. + * + * The window surface must be destroyed before the specified Vulkan instance. + * It is the responsibility of the caller to destroy the window surface. GLFW + * does not destroy it for you. Call `vkDestroySurfaceKHR` to destroy the + * surface. + * + * @param[in] instance The Vulkan instance to create the surface in. + * @param[in] window The window to create the surface for. + * @param[in] allocator The allocator to use, or `NULL` to use the default + * allocator. + * @param[out] surface Where to store the handle of the surface. This is set + * to `VK_NULL_HANDLE` if an error occurred. + * @return `VK_SUCCESS` if successful, or a Vulkan error code if an + * [error](@ref error_handling) occurred. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED, @ref + * GLFW_API_UNAVAILABLE, @ref GLFW_PLATFORM_ERROR and @ref GLFW_INVALID_VALUE + * + * @remark If an error occurs before the creation call is made, GLFW returns + * the Vulkan error code most appropriate for the error. Appropriate use of + * @ref glfwVulkanSupported and @ref glfwGetRequiredInstanceExtensions should + * eliminate almost all occurrences of these errors. + * + * @remark @macos GLFW prefers the `VK_EXT_metal_surface` extension, with the + * `VK_MVK_macos_surface` extension as a fallback. The name of the selected + * extension, if any, is included in the array returned by @ref + * glfwGetRequiredInstanceExtensions. + * + * @remark @macos This function creates and sets a `CAMetalLayer` instance for + * the window content view, which is required for MoltenVK to function. + * + * @remark @x11 By default GLFW prefers the `VK_KHR_xcb_surface` extension, + * with the `VK_KHR_xlib_surface` extension as a fallback. You can make + * `VK_KHR_xlib_surface` the preferred extension by setting the + * [GLFW_X11_XCB_VULKAN_SURFACE](@ref GLFW_X11_XCB_VULKAN_SURFACE_hint) init + * hint. The name of the selected extension, if any, is included in the array + * returned by @ref glfwGetRequiredInstanceExtensions. + * + * @thread_safety This function may be called from any thread. For + * synchronization details of Vulkan objects, see the Vulkan specification. + * + * @sa @ref vulkan_surface + * @sa @ref glfwGetRequiredInstanceExtensions + * + * @since Added in version 3.2. + * + * @ingroup vulkan + */ +GLFWAPI VkResult glfwCreateWindowSurface(VkInstance instance, GLFWwindow* window, const VkAllocationCallbacks* allocator, VkSurfaceKHR* surface); + +#endif /*VK_VERSION_1_0*/ + + +/************************************************************************* + * Global definition cleanup + *************************************************************************/ + +/* ------------------- BEGIN SYSTEM/COMPILER SPECIFIC -------------------- */ + +#ifdef GLFW_WINGDIAPI_DEFINED + #undef WINGDIAPI + #undef GLFW_WINGDIAPI_DEFINED +#endif + +#ifdef GLFW_CALLBACK_DEFINED + #undef CALLBACK + #undef GLFW_CALLBACK_DEFINED +#endif + +/* Some OpenGL related headers need GLAPIENTRY, but it is unconditionally + * defined by some gl.h variants (OpenBSD) so define it after if needed. + */ +#ifndef GLAPIENTRY + #define GLAPIENTRY APIENTRY + #define GLFW_GLAPIENTRY_DEFINED +#endif + +/* -------------------- END SYSTEM/COMPILER SPECIFIC --------------------- */ + + +#ifdef __cplusplus +} +#endif + +#endif /* _glfw3_h_ */ + diff --git a/Dynamic libraries/include/GLFW/glfw3native.h b/Dynamic libraries/include/GLFW/glfw3native.h new file mode 100644 index 0000000..92f0d32 --- /dev/null +++ b/Dynamic libraries/include/GLFW/glfw3native.h @@ -0,0 +1,663 @@ +/************************************************************************* + * GLFW 3.4 - www.glfw.org + * A library for OpenGL, window and input + *------------------------------------------------------------------------ + * Copyright (c) 2002-2006 Marcus Geelnard + * Copyright (c) 2006-2018 Camilla Löwy + * + * 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. + * + *************************************************************************/ + +#ifndef _glfw3_native_h_ +#define _glfw3_native_h_ + +#ifdef __cplusplus +extern "C" { +#endif + + +/************************************************************************* + * Doxygen documentation + *************************************************************************/ + +/*! @file glfw3native.h + * @brief The header of the native access functions. + * + * This is the header file of the native access functions. See @ref native for + * more information. + */ +/*! @defgroup native Native access + * @brief Functions related to accessing native handles. + * + * **By using the native access functions you assert that you know what you're + * doing and how to fix problems caused by using them. If you don't, you + * shouldn't be using them.** + * + * Before the inclusion of @ref glfw3native.h, you may define zero or more + * window system API macro and zero or more context creation API macros. + * + * The chosen backends must match those the library was compiled for. Failure + * to do this will cause a link-time error. + * + * The available window API macros are: + * * `GLFW_EXPOSE_NATIVE_WIN32` + * * `GLFW_EXPOSE_NATIVE_COCOA` + * * `GLFW_EXPOSE_NATIVE_X11` + * * `GLFW_EXPOSE_NATIVE_WAYLAND` + * + * The available context API macros are: + * * `GLFW_EXPOSE_NATIVE_WGL` + * * `GLFW_EXPOSE_NATIVE_NSGL` + * * `GLFW_EXPOSE_NATIVE_GLX` + * * `GLFW_EXPOSE_NATIVE_EGL` + * * `GLFW_EXPOSE_NATIVE_OSMESA` + * + * These macros select which of the native access functions that are declared + * and which platform-specific headers to include. It is then up your (by + * definition platform-specific) code to handle which of these should be + * defined. + * + * If you do not want the platform-specific headers to be included, define + * `GLFW_NATIVE_INCLUDE_NONE` before including the @ref glfw3native.h header. + * + * @code + * #define GLFW_EXPOSE_NATIVE_WIN32 + * #define GLFW_EXPOSE_NATIVE_WGL + * #define GLFW_NATIVE_INCLUDE_NONE + * #include + * @endcode + */ + + +/************************************************************************* + * System headers and types + *************************************************************************/ + +#if !defined(GLFW_NATIVE_INCLUDE_NONE) + + #if defined(GLFW_EXPOSE_NATIVE_WIN32) || defined(GLFW_EXPOSE_NATIVE_WGL) + /* This is a workaround for the fact that glfw3.h needs to export APIENTRY (for + * example to allow applications to correctly declare a GL_KHR_debug callback) + * but windows.h assumes no one will define APIENTRY before it does + */ + #if defined(GLFW_APIENTRY_DEFINED) + #undef APIENTRY + #undef GLFW_APIENTRY_DEFINED + #endif + #include + #endif + + #if defined(GLFW_EXPOSE_NATIVE_COCOA) || defined(GLFW_EXPOSE_NATIVE_NSGL) + #if defined(__OBJC__) + #import + #else + #include + #include + #endif + #endif + + #if defined(GLFW_EXPOSE_NATIVE_X11) || defined(GLFW_EXPOSE_NATIVE_GLX) + #include + #include + #endif + + #if defined(GLFW_EXPOSE_NATIVE_WAYLAND) + #include + #endif + + #if defined(GLFW_EXPOSE_NATIVE_WGL) + /* WGL is declared by windows.h */ + #endif + #if defined(GLFW_EXPOSE_NATIVE_NSGL) + /* NSGL is declared by Cocoa.h */ + #endif + #if defined(GLFW_EXPOSE_NATIVE_GLX) + /* This is a workaround for the fact that glfw3.h defines GLAPIENTRY because by + * default it also acts as an OpenGL header + * However, glx.h will include gl.h, which will define it unconditionally + */ + #if defined(GLFW_GLAPIENTRY_DEFINED) + #undef GLAPIENTRY + #undef GLFW_GLAPIENTRY_DEFINED + #endif + #include + #endif + #if defined(GLFW_EXPOSE_NATIVE_EGL) + #include + #endif + #if defined(GLFW_EXPOSE_NATIVE_OSMESA) + /* This is a workaround for the fact that glfw3.h defines GLAPIENTRY because by + * default it also acts as an OpenGL header + * However, osmesa.h will include gl.h, which will define it unconditionally + */ + #if defined(GLFW_GLAPIENTRY_DEFINED) + #undef GLAPIENTRY + #undef GLFW_GLAPIENTRY_DEFINED + #endif + #include + #endif + +#endif /*GLFW_NATIVE_INCLUDE_NONE*/ + + +/************************************************************************* + * Functions + *************************************************************************/ + +#if defined(GLFW_EXPOSE_NATIVE_WIN32) +/*! @brief Returns the adapter device name of the specified monitor. + * + * @return The UTF-8 encoded adapter device name (for example `\\.\DISPLAY1`) + * of the specified monitor, or `NULL` if an [error](@ref error_handling) + * occurred. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref + * GLFW_PLATFORM_UNAVAILABLE. + * + * @thread_safety This function may be called from any thread. Access is not + * synchronized. + * + * @since Added in version 3.1. + * + * @ingroup native + */ +GLFWAPI const char* glfwGetWin32Adapter(GLFWmonitor* monitor); + +/*! @brief Returns the display device name of the specified monitor. + * + * @return The UTF-8 encoded display device name (for example + * `\\.\DISPLAY1\Monitor0`) of the specified monitor, or `NULL` if an + * [error](@ref error_handling) occurred. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref + * GLFW_PLATFORM_UNAVAILABLE. + * + * @thread_safety This function may be called from any thread. Access is not + * synchronized. + * + * @since Added in version 3.1. + * + * @ingroup native + */ +GLFWAPI const char* glfwGetWin32Monitor(GLFWmonitor* monitor); + +/*! @brief Returns the `HWND` of the specified window. + * + * @return The `HWND` of the specified window, or `NULL` if an + * [error](@ref error_handling) occurred. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref + * GLFW_PLATFORM_UNAVAILABLE. + * + * @remark The `HDC` associated with the window can be queried with the + * [GetDC](https://docs.microsoft.com/en-us/windows/win32/api/winuser/nf-winuser-getdc) + * function. + * @code + * HDC dc = GetDC(glfwGetWin32Window(window)); + * @endcode + * This DC is private and does not need to be released. + * + * @thread_safety This function may be called from any thread. Access is not + * synchronized. + * + * @since Added in version 3.0. + * + * @ingroup native + */ +GLFWAPI HWND glfwGetWin32Window(GLFWwindow* window); +#endif + +#if defined(GLFW_EXPOSE_NATIVE_WGL) +/*! @brief Returns the `HGLRC` of the specified window. + * + * @return The `HGLRC` of the specified window, or `NULL` if an + * [error](@ref error_handling) occurred. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED, @ref + * GLFW_PLATFORM_UNAVAILABLE and @ref GLFW_NO_WINDOW_CONTEXT. + * + * @remark The `HDC` associated with the window can be queried with the + * [GetDC](https://docs.microsoft.com/en-us/windows/win32/api/winuser/nf-winuser-getdc) + * function. + * @code + * HDC dc = GetDC(glfwGetWin32Window(window)); + * @endcode + * This DC is private and does not need to be released. + * + * @thread_safety This function may be called from any thread. Access is not + * synchronized. + * + * @since Added in version 3.0. + * + * @ingroup native + */ +GLFWAPI HGLRC glfwGetWGLContext(GLFWwindow* window); +#endif + +#if defined(GLFW_EXPOSE_NATIVE_COCOA) +/*! @brief Returns the `CGDirectDisplayID` of the specified monitor. + * + * @return The `CGDirectDisplayID` of the specified monitor, or + * `kCGNullDirectDisplay` if an [error](@ref error_handling) occurred. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref + * GLFW_PLATFORM_UNAVAILABLE. + * + * @thread_safety This function may be called from any thread. Access is not + * synchronized. + * + * @since Added in version 3.1. + * + * @ingroup native + */ +GLFWAPI CGDirectDisplayID glfwGetCocoaMonitor(GLFWmonitor* monitor); + +/*! @brief Returns the `NSWindow` of the specified window. + * + * @return The `NSWindow` of the specified window, or `nil` if an + * [error](@ref error_handling) occurred. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref + * GLFW_PLATFORM_UNAVAILABLE. + * + * @thread_safety This function may be called from any thread. Access is not + * synchronized. + * + * @since Added in version 3.0. + * + * @ingroup native + */ +GLFWAPI id glfwGetCocoaWindow(GLFWwindow* window); + +/*! @brief Returns the `NSView` of the specified window. + * + * @return The `NSView` of the specified window, or `nil` if an + * [error](@ref error_handling) occurred. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref + * GLFW_PLATFORM_UNAVAILABLE. + * + * @thread_safety This function may be called from any thread. Access is not + * synchronized. + * + * @since Added in version 3.4. + * + * @ingroup native + */ +GLFWAPI id glfwGetCocoaView(GLFWwindow* window); +#endif + +#if defined(GLFW_EXPOSE_NATIVE_NSGL) +/*! @brief Returns the `NSOpenGLContext` of the specified window. + * + * @return The `NSOpenGLContext` of the specified window, or `nil` if an + * [error](@ref error_handling) occurred. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED, @ref + * GLFW_PLATFORM_UNAVAILABLE and @ref GLFW_NO_WINDOW_CONTEXT. + * + * @thread_safety This function may be called from any thread. Access is not + * synchronized. + * + * @since Added in version 3.0. + * + * @ingroup native + */ +GLFWAPI id glfwGetNSGLContext(GLFWwindow* window); +#endif + +#if defined(GLFW_EXPOSE_NATIVE_X11) +/*! @brief Returns the `Display` used by GLFW. + * + * @return The `Display` used by GLFW, or `NULL` if an + * [error](@ref error_handling) occurred. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref + * GLFW_PLATFORM_UNAVAILABLE. + * + * @thread_safety This function may be called from any thread. Access is not + * synchronized. + * + * @since Added in version 3.0. + * + * @ingroup native + */ +GLFWAPI Display* glfwGetX11Display(void); + +/*! @brief Returns the `RRCrtc` of the specified monitor. + * + * @return The `RRCrtc` of the specified monitor, or `None` if an + * [error](@ref error_handling) occurred. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref + * GLFW_PLATFORM_UNAVAILABLE. + * + * @thread_safety This function may be called from any thread. Access is not + * synchronized. + * + * @since Added in version 3.1. + * + * @ingroup native + */ +GLFWAPI RRCrtc glfwGetX11Adapter(GLFWmonitor* monitor); + +/*! @brief Returns the `RROutput` of the specified monitor. + * + * @return The `RROutput` of the specified monitor, or `None` if an + * [error](@ref error_handling) occurred. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref + * GLFW_PLATFORM_UNAVAILABLE. + * + * @thread_safety This function may be called from any thread. Access is not + * synchronized. + * + * @since Added in version 3.1. + * + * @ingroup native + */ +GLFWAPI RROutput glfwGetX11Monitor(GLFWmonitor* monitor); + +/*! @brief Returns the `Window` of the specified window. + * + * @return The `Window` of the specified window, or `None` if an + * [error](@ref error_handling) occurred. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref + * GLFW_PLATFORM_UNAVAILABLE. + * + * @thread_safety This function may be called from any thread. Access is not + * synchronized. + * + * @since Added in version 3.0. + * + * @ingroup native + */ +GLFWAPI Window glfwGetX11Window(GLFWwindow* window); + +/*! @brief Sets the current primary selection to the specified string. + * + * @param[in] string A UTF-8 encoded string. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED, @ref + * GLFW_PLATFORM_UNAVAILABLE and @ref GLFW_PLATFORM_ERROR. + * + * @pointer_lifetime The specified string is copied before this function + * returns. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref clipboard + * @sa glfwGetX11SelectionString + * @sa glfwSetClipboardString + * + * @since Added in version 3.3. + * + * @ingroup native + */ +GLFWAPI void glfwSetX11SelectionString(const char* string); + +/*! @brief Returns the contents of the current primary selection as a string. + * + * If the selection is empty or if its contents cannot be converted, `NULL` + * is returned and a @ref GLFW_FORMAT_UNAVAILABLE error is generated. + * + * @return The contents of the selection as a UTF-8 encoded string, or `NULL` + * if an [error](@ref error_handling) occurred. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED, @ref + * GLFW_PLATFORM_UNAVAILABLE and @ref GLFW_PLATFORM_ERROR. + * + * @pointer_lifetime The returned string is allocated and freed by GLFW. You + * should not free it yourself. It is valid until the next call to @ref + * glfwGetX11SelectionString or @ref glfwSetX11SelectionString, or until the + * library is terminated. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref clipboard + * @sa glfwSetX11SelectionString + * @sa glfwGetClipboardString + * + * @since Added in version 3.3. + * + * @ingroup native + */ +GLFWAPI const char* glfwGetX11SelectionString(void); +#endif + +#if defined(GLFW_EXPOSE_NATIVE_GLX) +/*! @brief Returns the `GLXContext` of the specified window. + * + * @return The `GLXContext` of the specified window, or `NULL` if an + * [error](@ref error_handling) occurred. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED, @ref + * GLFW_NO_WINDOW_CONTEXT and @ref GLFW_PLATFORM_UNAVAILABLE. + * + * @thread_safety This function may be called from any thread. Access is not + * synchronized. + * + * @since Added in version 3.0. + * + * @ingroup native + */ +GLFWAPI GLXContext glfwGetGLXContext(GLFWwindow* window); + +/*! @brief Returns the `GLXWindow` of the specified window. + * + * @return The `GLXWindow` of the specified window, or `None` if an + * [error](@ref error_handling) occurred. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED, @ref + * GLFW_NO_WINDOW_CONTEXT and @ref GLFW_PLATFORM_UNAVAILABLE. + * + * @thread_safety This function may be called from any thread. Access is not + * synchronized. + * + * @since Added in version 3.2. + * + * @ingroup native + */ +GLFWAPI GLXWindow glfwGetGLXWindow(GLFWwindow* window); +#endif + +#if defined(GLFW_EXPOSE_NATIVE_WAYLAND) +/*! @brief Returns the `struct wl_display*` used by GLFW. + * + * @return The `struct wl_display*` used by GLFW, or `NULL` if an + * [error](@ref error_handling) occurred. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref + * GLFW_PLATFORM_UNAVAILABLE. + * + * @thread_safety This function may be called from any thread. Access is not + * synchronized. + * + * @since Added in version 3.2. + * + * @ingroup native + */ +GLFWAPI struct wl_display* glfwGetWaylandDisplay(void); + +/*! @brief Returns the `struct wl_output*` of the specified monitor. + * + * @return The `struct wl_output*` of the specified monitor, or `NULL` if an + * [error](@ref error_handling) occurred. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref + * GLFW_PLATFORM_UNAVAILABLE. + * + * @thread_safety This function may be called from any thread. Access is not + * synchronized. + * + * @since Added in version 3.2. + * + * @ingroup native + */ +GLFWAPI struct wl_output* glfwGetWaylandMonitor(GLFWmonitor* monitor); + +/*! @brief Returns the main `struct wl_surface*` of the specified window. + * + * @return The main `struct wl_surface*` of the specified window, or `NULL` if + * an [error](@ref error_handling) occurred. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref + * GLFW_PLATFORM_UNAVAILABLE. + * + * @thread_safety This function may be called from any thread. Access is not + * synchronized. + * + * @since Added in version 3.2. + * + * @ingroup native + */ +GLFWAPI struct wl_surface* glfwGetWaylandWindow(GLFWwindow* window); +#endif + +#if defined(GLFW_EXPOSE_NATIVE_EGL) +/*! @brief Returns the `EGLDisplay` used by GLFW. + * + * @return The `EGLDisplay` used by GLFW, or `EGL_NO_DISPLAY` if an + * [error](@ref error_handling) occurred. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED. + * + * @remark Because EGL is initialized on demand, this function will return + * `EGL_NO_DISPLAY` until the first context has been created via EGL. + * + * @thread_safety This function may be called from any thread. Access is not + * synchronized. + * + * @since Added in version 3.0. + * + * @ingroup native + */ +GLFWAPI EGLDisplay glfwGetEGLDisplay(void); + +/*! @brief Returns the `EGLContext` of the specified window. + * + * @return The `EGLContext` of the specified window, or `EGL_NO_CONTEXT` if an + * [error](@ref error_handling) occurred. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref + * GLFW_NO_WINDOW_CONTEXT. + * + * @thread_safety This function may be called from any thread. Access is not + * synchronized. + * + * @since Added in version 3.0. + * + * @ingroup native + */ +GLFWAPI EGLContext glfwGetEGLContext(GLFWwindow* window); + +/*! @brief Returns the `EGLSurface` of the specified window. + * + * @return The `EGLSurface` of the specified window, or `EGL_NO_SURFACE` if an + * [error](@ref error_handling) occurred. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref + * GLFW_NO_WINDOW_CONTEXT. + * + * @thread_safety This function may be called from any thread. Access is not + * synchronized. + * + * @since Added in version 3.0. + * + * @ingroup native + */ +GLFWAPI EGLSurface glfwGetEGLSurface(GLFWwindow* window); +#endif + +#if defined(GLFW_EXPOSE_NATIVE_OSMESA) +/*! @brief Retrieves the color buffer associated with the specified window. + * + * @param[in] window The window whose color buffer to retrieve. + * @param[out] width Where to store the width of the color buffer, or `NULL`. + * @param[out] height Where to store the height of the color buffer, or `NULL`. + * @param[out] format Where to store the OSMesa pixel format of the color + * buffer, or `NULL`. + * @param[out] buffer Where to store the address of the color buffer, or + * `NULL`. + * @return `GLFW_TRUE` if successful, or `GLFW_FALSE` if an + * [error](@ref error_handling) occurred. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref + * GLFW_NO_WINDOW_CONTEXT. + * + * @thread_safety This function may be called from any thread. Access is not + * synchronized. + * + * @since Added in version 3.3. + * + * @ingroup native + */ +GLFWAPI int glfwGetOSMesaColorBuffer(GLFWwindow* window, int* width, int* height, int* format, void** buffer); + +/*! @brief Retrieves the depth buffer associated with the specified window. + * + * @param[in] window The window whose depth buffer to retrieve. + * @param[out] width Where to store the width of the depth buffer, or `NULL`. + * @param[out] height Where to store the height of the depth buffer, or `NULL`. + * @param[out] bytesPerValue Where to store the number of bytes per depth + * buffer element, or `NULL`. + * @param[out] buffer Where to store the address of the depth buffer, or + * `NULL`. + * @return `GLFW_TRUE` if successful, or `GLFW_FALSE` if an + * [error](@ref error_handling) occurred. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref + * GLFW_NO_WINDOW_CONTEXT. + * + * @thread_safety This function may be called from any thread. Access is not + * synchronized. + * + * @since Added in version 3.3. + * + * @ingroup native + */ +GLFWAPI int glfwGetOSMesaDepthBuffer(GLFWwindow* window, int* width, int* height, int* bytesPerValue, void** buffer); + +/*! @brief Returns the `OSMesaContext` of the specified window. + * + * @return The `OSMesaContext` of the specified window, or `NULL` if an + * [error](@ref error_handling) occurred. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref + * GLFW_NO_WINDOW_CONTEXT. + * + * @thread_safety This function may be called from any thread. Access is not + * synchronized. + * + * @since Added in version 3.3. + * + * @ingroup native + */ +GLFWAPI OSMesaContext glfwGetOSMesaContext(GLFWwindow* window); +#endif + +#ifdef __cplusplus +} +#endif + +#endif /* _glfw3_native_h_ */ + diff --git a/Dynamic libraries/include/KHR/khrplatform.h b/Dynamic libraries/include/KHR/khrplatform.h new file mode 100644 index 0000000..0164644 --- /dev/null +++ b/Dynamic libraries/include/KHR/khrplatform.h @@ -0,0 +1,311 @@ +#ifndef __khrplatform_h_ +#define __khrplatform_h_ + +/* +** Copyright (c) 2008-2018 The Khronos Group Inc. +** +** Permission is hereby granted, free of charge, to any person obtaining a +** copy of this software and/or associated documentation files (the +** "Materials"), to deal in the Materials without restriction, including +** without limitation the rights to use, copy, modify, merge, publish, +** distribute, sublicense, and/or sell copies of the Materials, and to +** permit persons to whom the Materials are furnished to do so, subject to +** the following conditions: +** +** The above copyright notice and this permission notice shall be included +** in all copies or substantial portions of the Materials. +** +** THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY +** CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, +** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE +** MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS. +*/ + +/* Khronos platform-specific types and definitions. + * + * The master copy of khrplatform.h is maintained in the Khronos EGL + * Registry repository at https://github.com/KhronosGroup/EGL-Registry + * The last semantic modification to khrplatform.h was at commit ID: + * 67a3e0864c2d75ea5287b9f3d2eb74a745936692 + * + * Adopters may modify this file to suit their platform. Adopters are + * encouraged to submit platform specific modifications to the Khronos + * group so that they can be included in future versions of this file. + * Please submit changes by filing pull requests or issues on + * the EGL Registry repository linked above. + * + * + * See the Implementer's Guidelines for information about where this file + * should be located on your system and for more details of its use: + * http://www.khronos.org/registry/implementers_guide.pdf + * + * This file should be included as + * #include + * by Khronos client API header files that use its types and defines. + * + * The types in khrplatform.h should only be used to define API-specific types. + * + * Types defined in khrplatform.h: + * khronos_int8_t signed 8 bit + * khronos_uint8_t unsigned 8 bit + * khronos_int16_t signed 16 bit + * khronos_uint16_t unsigned 16 bit + * khronos_int32_t signed 32 bit + * khronos_uint32_t unsigned 32 bit + * khronos_int64_t signed 64 bit + * khronos_uint64_t unsigned 64 bit + * khronos_intptr_t signed same number of bits as a pointer + * khronos_uintptr_t unsigned same number of bits as a pointer + * khronos_ssize_t signed size + * khronos_usize_t unsigned size + * khronos_float_t signed 32 bit floating point + * khronos_time_ns_t unsigned 64 bit time in nanoseconds + * khronos_utime_nanoseconds_t unsigned time interval or absolute time in + * nanoseconds + * khronos_stime_nanoseconds_t signed time interval in nanoseconds + * khronos_boolean_enum_t enumerated boolean type. This should + * only be used as a base type when a client API's boolean type is + * an enum. Client APIs which use an integer or other type for + * booleans cannot use this as the base type for their boolean. + * + * Tokens defined in khrplatform.h: + * + * KHRONOS_FALSE, KHRONOS_TRUE Enumerated boolean false/true values. + * + * KHRONOS_SUPPORT_INT64 is 1 if 64 bit integers are supported; otherwise 0. + * KHRONOS_SUPPORT_FLOAT is 1 if floats are supported; otherwise 0. + * + * Calling convention macros defined in this file: + * KHRONOS_APICALL + * KHRONOS_APIENTRY + * KHRONOS_APIATTRIBUTES + * + * These may be used in function prototypes as: + * + * KHRONOS_APICALL void KHRONOS_APIENTRY funcname( + * int arg1, + * int arg2) KHRONOS_APIATTRIBUTES; + */ + +#if defined(__SCITECH_SNAP__) && !defined(KHRONOS_STATIC) +# define KHRONOS_STATIC 1 +#endif + +/*------------------------------------------------------------------------- + * Definition of KHRONOS_APICALL + *------------------------------------------------------------------------- + * This precedes the return type of the function in the function prototype. + */ +#if defined(KHRONOS_STATIC) + /* If the preprocessor constant KHRONOS_STATIC is defined, make the + * header compatible with static linking. */ +# define KHRONOS_APICALL +#elif defined(_WIN32) +# define KHRONOS_APICALL __declspec(dllimport) +#elif defined (__SYMBIAN32__) +# define KHRONOS_APICALL IMPORT_C +#elif defined(__ANDROID__) +# define KHRONOS_APICALL __attribute__((visibility("default"))) +#else +# define KHRONOS_APICALL +#endif + +/*------------------------------------------------------------------------- + * Definition of KHRONOS_APIENTRY + *------------------------------------------------------------------------- + * This follows the return type of the function and precedes the function + * name in the function prototype. + */ +#if defined(_WIN32) && !defined(_WIN32_WCE) && !defined(__SCITECH_SNAP__) + /* Win32 but not WinCE */ +# define KHRONOS_APIENTRY __stdcall +#else +# define KHRONOS_APIENTRY +#endif + +/*------------------------------------------------------------------------- + * Definition of KHRONOS_APIATTRIBUTES + *------------------------------------------------------------------------- + * This follows the closing parenthesis of the function prototype arguments. + */ +#if defined (__ARMCC_2__) +#define KHRONOS_APIATTRIBUTES __softfp +#else +#define KHRONOS_APIATTRIBUTES +#endif + +/*------------------------------------------------------------------------- + * basic type definitions + *-----------------------------------------------------------------------*/ +#if (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L) || defined(__GNUC__) || defined(__SCO__) || defined(__USLC__) + + +/* + * Using + */ +#include +typedef int32_t khronos_int32_t; +typedef uint32_t khronos_uint32_t; +typedef int64_t khronos_int64_t; +typedef uint64_t khronos_uint64_t; +#define KHRONOS_SUPPORT_INT64 1 +#define KHRONOS_SUPPORT_FLOAT 1 +/* + * To support platform where unsigned long cannot be used interchangeably with + * inptr_t (e.g. CHERI-extended ISAs), we can use the stdint.h intptr_t. + * Ideally, we could just use (u)intptr_t everywhere, but this could result in + * ABI breakage if khronos_uintptr_t is changed from unsigned long to + * unsigned long long or similar (this results in different C++ name mangling). + * To avoid changes for existing platforms, we restrict usage of intptr_t to + * platforms where the size of a pointer is larger than the size of long. + */ +#if defined(__SIZEOF_LONG__) && defined(__SIZEOF_POINTER__) +#if __SIZEOF_POINTER__ > __SIZEOF_LONG__ +#define KHRONOS_USE_INTPTR_T +#endif +#endif + +#elif defined(__VMS ) || defined(__sgi) + +/* + * Using + */ +#include +typedef int32_t khronos_int32_t; +typedef uint32_t khronos_uint32_t; +typedef int64_t khronos_int64_t; +typedef uint64_t khronos_uint64_t; +#define KHRONOS_SUPPORT_INT64 1 +#define KHRONOS_SUPPORT_FLOAT 1 + +#elif defined(_WIN32) && !defined(__SCITECH_SNAP__) + +/* + * Win32 + */ +typedef __int32 khronos_int32_t; +typedef unsigned __int32 khronos_uint32_t; +typedef __int64 khronos_int64_t; +typedef unsigned __int64 khronos_uint64_t; +#define KHRONOS_SUPPORT_INT64 1 +#define KHRONOS_SUPPORT_FLOAT 1 + +#elif defined(__sun__) || defined(__digital__) + +/* + * Sun or Digital + */ +typedef int khronos_int32_t; +typedef unsigned int khronos_uint32_t; +#if defined(__arch64__) || defined(_LP64) +typedef long int khronos_int64_t; +typedef unsigned long int khronos_uint64_t; +#else +typedef long long int khronos_int64_t; +typedef unsigned long long int khronos_uint64_t; +#endif /* __arch64__ */ +#define KHRONOS_SUPPORT_INT64 1 +#define KHRONOS_SUPPORT_FLOAT 1 + +#elif 0 + +/* + * Hypothetical platform with no float or int64 support + */ +typedef int khronos_int32_t; +typedef unsigned int khronos_uint32_t; +#define KHRONOS_SUPPORT_INT64 0 +#define KHRONOS_SUPPORT_FLOAT 0 + +#else + +/* + * Generic fallback + */ +#include +typedef int32_t khronos_int32_t; +typedef uint32_t khronos_uint32_t; +typedef int64_t khronos_int64_t; +typedef uint64_t khronos_uint64_t; +#define KHRONOS_SUPPORT_INT64 1 +#define KHRONOS_SUPPORT_FLOAT 1 + +#endif + + +/* + * Types that are (so far) the same on all platforms + */ +typedef signed char khronos_int8_t; +typedef unsigned char khronos_uint8_t; +typedef signed short int khronos_int16_t; +typedef unsigned short int khronos_uint16_t; + +/* + * Types that differ between LLP64 and LP64 architectures - in LLP64, + * pointers are 64 bits, but 'long' is still 32 bits. Win64 appears + * to be the only LLP64 architecture in current use. + */ +#ifdef KHRONOS_USE_INTPTR_T +typedef intptr_t khronos_intptr_t; +typedef uintptr_t khronos_uintptr_t; +#elif defined(_WIN64) +typedef signed long long int khronos_intptr_t; +typedef unsigned long long int khronos_uintptr_t; +#else +typedef signed long int khronos_intptr_t; +typedef unsigned long int khronos_uintptr_t; +#endif + +#if defined(_WIN64) +typedef signed long long int khronos_ssize_t; +typedef unsigned long long int khronos_usize_t; +#else +typedef signed long int khronos_ssize_t; +typedef unsigned long int khronos_usize_t; +#endif + +#if KHRONOS_SUPPORT_FLOAT +/* + * Float type + */ +typedef float khronos_float_t; +#endif + +#if KHRONOS_SUPPORT_INT64 +/* Time types + * + * These types can be used to represent a time interval in nanoseconds or + * an absolute Unadjusted System Time. Unadjusted System Time is the number + * of nanoseconds since some arbitrary system event (e.g. since the last + * time the system booted). The Unadjusted System Time is an unsigned + * 64 bit value that wraps back to 0 every 584 years. Time intervals + * may be either signed or unsigned. + */ +typedef khronos_uint64_t khronos_utime_nanoseconds_t; +typedef khronos_int64_t khronos_stime_nanoseconds_t; +#endif + +/* + * Dummy value used to pad enum types to 32 bits. + */ +#ifndef KHRONOS_MAX_ENUM +#define KHRONOS_MAX_ENUM 0x7FFFFFFF +#endif + +/* + * Enumerated boolean type + * + * Values other than zero should be considered to be true. Therefore + * comparisons should not be made against KHRONOS_TRUE. + */ +typedef enum { + KHRONOS_FALSE = 0, + KHRONOS_TRUE = 1, + KHRONOS_BOOLEAN_ENUM_FORCE_SIZE = KHRONOS_MAX_ENUM +} khronos_boolean_enum_t; + +#endif /* __khrplatform_h_ */ diff --git a/Dynamic libraries/include/glad/glad.h b/Dynamic libraries/include/glad/glad.h new file mode 100644 index 0000000..335a43b --- /dev/null +++ b/Dynamic libraries/include/glad/glad.h @@ -0,0 +1,2129 @@ +/* + + OpenGL loader generated by glad 0.1.36 on Mon Feb 16 17:34:00 2026. + + Language/Generator: C/C++ + Specification: gl + APIs: gl=3.3 + Profile: core + Extensions: + + Loader: True + Local files: False + Omit khrplatform: False + Reproducible: False + + Commandline: + --profile="core" --api="gl=3.3" --generator="c" --spec="gl" --extensions="" + Online: + https://glad.dav1d.de/#profile=core&language=c&specification=gl&loader=on&api=gl%3D3.3 +*/ + + +#ifndef __glad_h_ +#define __glad_h_ + +#ifdef __gl_h_ +#error OpenGL header already included, remove this include, glad already provides it +#endif +#define __gl_h_ + +#if defined(_WIN32) && !defined(APIENTRY) && !defined(__CYGWIN__) && !defined(__SCITECH_SNAP__) +#define APIENTRY __stdcall +#endif + +#ifndef APIENTRY +#define APIENTRY +#endif +#ifndef APIENTRYP +#define APIENTRYP APIENTRY * +#endif + +#ifndef GLAPIENTRY +#define GLAPIENTRY APIENTRY +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +struct gladGLversionStruct { + int major; + int minor; +}; + +typedef void* (* GLADloadproc)(const char *name); + +#ifndef GLAPI +# if defined(GLAD_GLAPI_EXPORT) +# if defined(_WIN32) || defined(__CYGWIN__) +# if defined(GLAD_GLAPI_EXPORT_BUILD) +# if defined(__GNUC__) +# define GLAPI __attribute__ ((dllexport)) extern +# else +# define GLAPI __declspec(dllexport) extern +# endif +# else +# if defined(__GNUC__) +# define GLAPI __attribute__ ((dllimport)) extern +# else +# define GLAPI __declspec(dllimport) extern +# endif +# endif +# elif defined(__GNUC__) && defined(GLAD_GLAPI_EXPORT_BUILD) +# define GLAPI __attribute__ ((visibility ("default"))) extern +# else +# define GLAPI extern +# endif +# else +# define GLAPI extern +# endif +#endif + +GLAPI struct gladGLversionStruct GLVersion; + +GLAPI int gladLoadGL(void); + +GLAPI int gladLoadGLLoader(GLADloadproc); + +#include +typedef unsigned int GLenum; +typedef unsigned char GLboolean; +typedef unsigned int GLbitfield; +typedef void GLvoid; +typedef khronos_int8_t GLbyte; +typedef khronos_uint8_t GLubyte; +typedef khronos_int16_t GLshort; +typedef khronos_uint16_t GLushort; +typedef int GLint; +typedef unsigned int GLuint; +typedef khronos_int32_t GLclampx; +typedef int GLsizei; +typedef khronos_float_t GLfloat; +typedef khronos_float_t GLclampf; +typedef double GLdouble; +typedef double GLclampd; +typedef void *GLeglClientBufferEXT; +typedef void *GLeglImageOES; +typedef char GLchar; +typedef char GLcharARB; +#ifdef __APPLE__ +typedef void *GLhandleARB; +#else +typedef unsigned int GLhandleARB; +#endif +typedef khronos_uint16_t GLhalf; +typedef khronos_uint16_t GLhalfARB; +typedef khronos_int32_t GLfixed; +typedef khronos_intptr_t GLintptr; +typedef khronos_intptr_t GLintptrARB; +typedef khronos_ssize_t GLsizeiptr; +typedef khronos_ssize_t GLsizeiptrARB; +typedef khronos_int64_t GLint64; +typedef khronos_int64_t GLint64EXT; +typedef khronos_uint64_t GLuint64; +typedef khronos_uint64_t GLuint64EXT; +typedef struct __GLsync *GLsync; +struct _cl_context; +struct _cl_event; +typedef void (APIENTRY *GLDEBUGPROC)(GLenum source,GLenum type,GLuint id,GLenum severity,GLsizei length,const GLchar *message,const void *userParam); +typedef void (APIENTRY *GLDEBUGPROCARB)(GLenum source,GLenum type,GLuint id,GLenum severity,GLsizei length,const GLchar *message,const void *userParam); +typedef void (APIENTRY *GLDEBUGPROCKHR)(GLenum source,GLenum type,GLuint id,GLenum severity,GLsizei length,const GLchar *message,const void *userParam); +typedef void (APIENTRY *GLDEBUGPROCAMD)(GLuint id,GLenum category,GLenum severity,GLsizei length,const GLchar *message,void *userParam); +typedef unsigned short GLhalfNV; +typedef GLintptr GLvdpauSurfaceNV; +typedef void (APIENTRY *GLVULKANPROCNV)(void); +#define GL_DEPTH_BUFFER_BIT 0x00000100 +#define GL_STENCIL_BUFFER_BIT 0x00000400 +#define GL_COLOR_BUFFER_BIT 0x00004000 +#define GL_FALSE 0 +#define GL_TRUE 1 +#define GL_POINTS 0x0000 +#define GL_LINES 0x0001 +#define GL_LINE_LOOP 0x0002 +#define GL_LINE_STRIP 0x0003 +#define GL_TRIANGLES 0x0004 +#define GL_TRIANGLE_STRIP 0x0005 +#define GL_TRIANGLE_FAN 0x0006 +#define GL_NEVER 0x0200 +#define GL_LESS 0x0201 +#define GL_EQUAL 0x0202 +#define GL_LEQUAL 0x0203 +#define GL_GREATER 0x0204 +#define GL_NOTEQUAL 0x0205 +#define GL_GEQUAL 0x0206 +#define GL_ALWAYS 0x0207 +#define GL_ZERO 0 +#define GL_ONE 1 +#define GL_SRC_COLOR 0x0300 +#define GL_ONE_MINUS_SRC_COLOR 0x0301 +#define GL_SRC_ALPHA 0x0302 +#define GL_ONE_MINUS_SRC_ALPHA 0x0303 +#define GL_DST_ALPHA 0x0304 +#define GL_ONE_MINUS_DST_ALPHA 0x0305 +#define GL_DST_COLOR 0x0306 +#define GL_ONE_MINUS_DST_COLOR 0x0307 +#define GL_SRC_ALPHA_SATURATE 0x0308 +#define GL_NONE 0 +#define GL_FRONT_LEFT 0x0400 +#define GL_FRONT_RIGHT 0x0401 +#define GL_BACK_LEFT 0x0402 +#define GL_BACK_RIGHT 0x0403 +#define GL_FRONT 0x0404 +#define GL_BACK 0x0405 +#define GL_LEFT 0x0406 +#define GL_RIGHT 0x0407 +#define GL_FRONT_AND_BACK 0x0408 +#define GL_NO_ERROR 0 +#define GL_INVALID_ENUM 0x0500 +#define GL_INVALID_VALUE 0x0501 +#define GL_INVALID_OPERATION 0x0502 +#define GL_OUT_OF_MEMORY 0x0505 +#define GL_CW 0x0900 +#define GL_CCW 0x0901 +#define GL_POINT_SIZE 0x0B11 +#define GL_POINT_SIZE_RANGE 0x0B12 +#define GL_POINT_SIZE_GRANULARITY 0x0B13 +#define GL_LINE_SMOOTH 0x0B20 +#define GL_LINE_WIDTH 0x0B21 +#define GL_LINE_WIDTH_RANGE 0x0B22 +#define GL_LINE_WIDTH_GRANULARITY 0x0B23 +#define GL_POLYGON_MODE 0x0B40 +#define GL_POLYGON_SMOOTH 0x0B41 +#define GL_CULL_FACE 0x0B44 +#define GL_CULL_FACE_MODE 0x0B45 +#define GL_FRONT_FACE 0x0B46 +#define GL_DEPTH_RANGE 0x0B70 +#define GL_DEPTH_TEST 0x0B71 +#define GL_DEPTH_WRITEMASK 0x0B72 +#define GL_DEPTH_CLEAR_VALUE 0x0B73 +#define GL_DEPTH_FUNC 0x0B74 +#define GL_STENCIL_TEST 0x0B90 +#define GL_STENCIL_CLEAR_VALUE 0x0B91 +#define GL_STENCIL_FUNC 0x0B92 +#define GL_STENCIL_VALUE_MASK 0x0B93 +#define GL_STENCIL_FAIL 0x0B94 +#define GL_STENCIL_PASS_DEPTH_FAIL 0x0B95 +#define GL_STENCIL_PASS_DEPTH_PASS 0x0B96 +#define GL_STENCIL_REF 0x0B97 +#define GL_STENCIL_WRITEMASK 0x0B98 +#define GL_VIEWPORT 0x0BA2 +#define GL_DITHER 0x0BD0 +#define GL_BLEND_DST 0x0BE0 +#define GL_BLEND_SRC 0x0BE1 +#define GL_BLEND 0x0BE2 +#define GL_LOGIC_OP_MODE 0x0BF0 +#define GL_DRAW_BUFFER 0x0C01 +#define GL_READ_BUFFER 0x0C02 +#define GL_SCISSOR_BOX 0x0C10 +#define GL_SCISSOR_TEST 0x0C11 +#define GL_COLOR_CLEAR_VALUE 0x0C22 +#define GL_COLOR_WRITEMASK 0x0C23 +#define GL_DOUBLEBUFFER 0x0C32 +#define GL_STEREO 0x0C33 +#define GL_LINE_SMOOTH_HINT 0x0C52 +#define GL_POLYGON_SMOOTH_HINT 0x0C53 +#define GL_UNPACK_SWAP_BYTES 0x0CF0 +#define GL_UNPACK_LSB_FIRST 0x0CF1 +#define GL_UNPACK_ROW_LENGTH 0x0CF2 +#define GL_UNPACK_SKIP_ROWS 0x0CF3 +#define GL_UNPACK_SKIP_PIXELS 0x0CF4 +#define GL_UNPACK_ALIGNMENT 0x0CF5 +#define GL_PACK_SWAP_BYTES 0x0D00 +#define GL_PACK_LSB_FIRST 0x0D01 +#define GL_PACK_ROW_LENGTH 0x0D02 +#define GL_PACK_SKIP_ROWS 0x0D03 +#define GL_PACK_SKIP_PIXELS 0x0D04 +#define GL_PACK_ALIGNMENT 0x0D05 +#define GL_MAX_TEXTURE_SIZE 0x0D33 +#define GL_MAX_VIEWPORT_DIMS 0x0D3A +#define GL_SUBPIXEL_BITS 0x0D50 +#define GL_TEXTURE_1D 0x0DE0 +#define GL_TEXTURE_2D 0x0DE1 +#define GL_TEXTURE_WIDTH 0x1000 +#define GL_TEXTURE_HEIGHT 0x1001 +#define GL_TEXTURE_BORDER_COLOR 0x1004 +#define GL_DONT_CARE 0x1100 +#define GL_FASTEST 0x1101 +#define GL_NICEST 0x1102 +#define GL_BYTE 0x1400 +#define GL_UNSIGNED_BYTE 0x1401 +#define GL_SHORT 0x1402 +#define GL_UNSIGNED_SHORT 0x1403 +#define GL_INT 0x1404 +#define GL_UNSIGNED_INT 0x1405 +#define GL_FLOAT 0x1406 +#define GL_CLEAR 0x1500 +#define GL_AND 0x1501 +#define GL_AND_REVERSE 0x1502 +#define GL_COPY 0x1503 +#define GL_AND_INVERTED 0x1504 +#define GL_NOOP 0x1505 +#define GL_XOR 0x1506 +#define GL_OR 0x1507 +#define GL_NOR 0x1508 +#define GL_EQUIV 0x1509 +#define GL_INVERT 0x150A +#define GL_OR_REVERSE 0x150B +#define GL_COPY_INVERTED 0x150C +#define GL_OR_INVERTED 0x150D +#define GL_NAND 0x150E +#define GL_SET 0x150F +#define GL_TEXTURE 0x1702 +#define GL_COLOR 0x1800 +#define GL_DEPTH 0x1801 +#define GL_STENCIL 0x1802 +#define GL_STENCIL_INDEX 0x1901 +#define GL_DEPTH_COMPONENT 0x1902 +#define GL_RED 0x1903 +#define GL_GREEN 0x1904 +#define GL_BLUE 0x1905 +#define GL_ALPHA 0x1906 +#define GL_RGB 0x1907 +#define GL_RGBA 0x1908 +#define GL_POINT 0x1B00 +#define GL_LINE 0x1B01 +#define GL_FILL 0x1B02 +#define GL_KEEP 0x1E00 +#define GL_REPLACE 0x1E01 +#define GL_INCR 0x1E02 +#define GL_DECR 0x1E03 +#define GL_VENDOR 0x1F00 +#define GL_RENDERER 0x1F01 +#define GL_VERSION 0x1F02 +#define GL_EXTENSIONS 0x1F03 +#define GL_NEAREST 0x2600 +#define GL_LINEAR 0x2601 +#define GL_NEAREST_MIPMAP_NEAREST 0x2700 +#define GL_LINEAR_MIPMAP_NEAREST 0x2701 +#define GL_NEAREST_MIPMAP_LINEAR 0x2702 +#define GL_LINEAR_MIPMAP_LINEAR 0x2703 +#define GL_TEXTURE_MAG_FILTER 0x2800 +#define GL_TEXTURE_MIN_FILTER 0x2801 +#define GL_TEXTURE_WRAP_S 0x2802 +#define GL_TEXTURE_WRAP_T 0x2803 +#define GL_REPEAT 0x2901 +#define GL_COLOR_LOGIC_OP 0x0BF2 +#define GL_POLYGON_OFFSET_UNITS 0x2A00 +#define GL_POLYGON_OFFSET_POINT 0x2A01 +#define GL_POLYGON_OFFSET_LINE 0x2A02 +#define GL_POLYGON_OFFSET_FILL 0x8037 +#define GL_POLYGON_OFFSET_FACTOR 0x8038 +#define GL_TEXTURE_BINDING_1D 0x8068 +#define GL_TEXTURE_BINDING_2D 0x8069 +#define GL_TEXTURE_INTERNAL_FORMAT 0x1003 +#define GL_TEXTURE_RED_SIZE 0x805C +#define GL_TEXTURE_GREEN_SIZE 0x805D +#define GL_TEXTURE_BLUE_SIZE 0x805E +#define GL_TEXTURE_ALPHA_SIZE 0x805F +#define GL_DOUBLE 0x140A +#define GL_PROXY_TEXTURE_1D 0x8063 +#define GL_PROXY_TEXTURE_2D 0x8064 +#define GL_R3_G3_B2 0x2A10 +#define GL_RGB4 0x804F +#define GL_RGB5 0x8050 +#define GL_RGB8 0x8051 +#define GL_RGB10 0x8052 +#define GL_RGB12 0x8053 +#define GL_RGB16 0x8054 +#define GL_RGBA2 0x8055 +#define GL_RGBA4 0x8056 +#define GL_RGB5_A1 0x8057 +#define GL_RGBA8 0x8058 +#define GL_RGB10_A2 0x8059 +#define GL_RGBA12 0x805A +#define GL_RGBA16 0x805B +#define GL_UNSIGNED_BYTE_3_3_2 0x8032 +#define GL_UNSIGNED_SHORT_4_4_4_4 0x8033 +#define GL_UNSIGNED_SHORT_5_5_5_1 0x8034 +#define GL_UNSIGNED_INT_8_8_8_8 0x8035 +#define GL_UNSIGNED_INT_10_10_10_2 0x8036 +#define GL_TEXTURE_BINDING_3D 0x806A +#define GL_PACK_SKIP_IMAGES 0x806B +#define GL_PACK_IMAGE_HEIGHT 0x806C +#define GL_UNPACK_SKIP_IMAGES 0x806D +#define GL_UNPACK_IMAGE_HEIGHT 0x806E +#define GL_TEXTURE_3D 0x806F +#define GL_PROXY_TEXTURE_3D 0x8070 +#define GL_TEXTURE_DEPTH 0x8071 +#define GL_TEXTURE_WRAP_R 0x8072 +#define GL_MAX_3D_TEXTURE_SIZE 0x8073 +#define GL_UNSIGNED_BYTE_2_3_3_REV 0x8362 +#define GL_UNSIGNED_SHORT_5_6_5 0x8363 +#define GL_UNSIGNED_SHORT_5_6_5_REV 0x8364 +#define GL_UNSIGNED_SHORT_4_4_4_4_REV 0x8365 +#define GL_UNSIGNED_SHORT_1_5_5_5_REV 0x8366 +#define GL_UNSIGNED_INT_8_8_8_8_REV 0x8367 +#define GL_UNSIGNED_INT_2_10_10_10_REV 0x8368 +#define GL_BGR 0x80E0 +#define GL_BGRA 0x80E1 +#define GL_MAX_ELEMENTS_VERTICES 0x80E8 +#define GL_MAX_ELEMENTS_INDICES 0x80E9 +#define GL_CLAMP_TO_EDGE 0x812F +#define GL_TEXTURE_MIN_LOD 0x813A +#define GL_TEXTURE_MAX_LOD 0x813B +#define GL_TEXTURE_BASE_LEVEL 0x813C +#define GL_TEXTURE_MAX_LEVEL 0x813D +#define GL_SMOOTH_POINT_SIZE_RANGE 0x0B12 +#define GL_SMOOTH_POINT_SIZE_GRANULARITY 0x0B13 +#define GL_SMOOTH_LINE_WIDTH_RANGE 0x0B22 +#define GL_SMOOTH_LINE_WIDTH_GRANULARITY 0x0B23 +#define GL_ALIASED_LINE_WIDTH_RANGE 0x846E +#define GL_TEXTURE0 0x84C0 +#define GL_TEXTURE1 0x84C1 +#define GL_TEXTURE2 0x84C2 +#define GL_TEXTURE3 0x84C3 +#define GL_TEXTURE4 0x84C4 +#define GL_TEXTURE5 0x84C5 +#define GL_TEXTURE6 0x84C6 +#define GL_TEXTURE7 0x84C7 +#define GL_TEXTURE8 0x84C8 +#define GL_TEXTURE9 0x84C9 +#define GL_TEXTURE10 0x84CA +#define GL_TEXTURE11 0x84CB +#define GL_TEXTURE12 0x84CC +#define GL_TEXTURE13 0x84CD +#define GL_TEXTURE14 0x84CE +#define GL_TEXTURE15 0x84CF +#define GL_TEXTURE16 0x84D0 +#define GL_TEXTURE17 0x84D1 +#define GL_TEXTURE18 0x84D2 +#define GL_TEXTURE19 0x84D3 +#define GL_TEXTURE20 0x84D4 +#define GL_TEXTURE21 0x84D5 +#define GL_TEXTURE22 0x84D6 +#define GL_TEXTURE23 0x84D7 +#define GL_TEXTURE24 0x84D8 +#define GL_TEXTURE25 0x84D9 +#define GL_TEXTURE26 0x84DA +#define GL_TEXTURE27 0x84DB +#define GL_TEXTURE28 0x84DC +#define GL_TEXTURE29 0x84DD +#define GL_TEXTURE30 0x84DE +#define GL_TEXTURE31 0x84DF +#define GL_ACTIVE_TEXTURE 0x84E0 +#define GL_MULTISAMPLE 0x809D +#define GL_SAMPLE_ALPHA_TO_COVERAGE 0x809E +#define GL_SAMPLE_ALPHA_TO_ONE 0x809F +#define GL_SAMPLE_COVERAGE 0x80A0 +#define GL_SAMPLE_BUFFERS 0x80A8 +#define GL_SAMPLES 0x80A9 +#define GL_SAMPLE_COVERAGE_VALUE 0x80AA +#define GL_SAMPLE_COVERAGE_INVERT 0x80AB +#define GL_TEXTURE_CUBE_MAP 0x8513 +#define GL_TEXTURE_BINDING_CUBE_MAP 0x8514 +#define GL_TEXTURE_CUBE_MAP_POSITIVE_X 0x8515 +#define GL_TEXTURE_CUBE_MAP_NEGATIVE_X 0x8516 +#define GL_TEXTURE_CUBE_MAP_POSITIVE_Y 0x8517 +#define GL_TEXTURE_CUBE_MAP_NEGATIVE_Y 0x8518 +#define GL_TEXTURE_CUBE_MAP_POSITIVE_Z 0x8519 +#define GL_TEXTURE_CUBE_MAP_NEGATIVE_Z 0x851A +#define GL_PROXY_TEXTURE_CUBE_MAP 0x851B +#define GL_MAX_CUBE_MAP_TEXTURE_SIZE 0x851C +#define GL_COMPRESSED_RGB 0x84ED +#define GL_COMPRESSED_RGBA 0x84EE +#define GL_TEXTURE_COMPRESSION_HINT 0x84EF +#define GL_TEXTURE_COMPRESSED_IMAGE_SIZE 0x86A0 +#define GL_TEXTURE_COMPRESSED 0x86A1 +#define GL_NUM_COMPRESSED_TEXTURE_FORMATS 0x86A2 +#define GL_COMPRESSED_TEXTURE_FORMATS 0x86A3 +#define GL_CLAMP_TO_BORDER 0x812D +#define GL_BLEND_DST_RGB 0x80C8 +#define GL_BLEND_SRC_RGB 0x80C9 +#define GL_BLEND_DST_ALPHA 0x80CA +#define GL_BLEND_SRC_ALPHA 0x80CB +#define GL_POINT_FADE_THRESHOLD_SIZE 0x8128 +#define GL_DEPTH_COMPONENT16 0x81A5 +#define GL_DEPTH_COMPONENT24 0x81A6 +#define GL_DEPTH_COMPONENT32 0x81A7 +#define GL_MIRRORED_REPEAT 0x8370 +#define GL_MAX_TEXTURE_LOD_BIAS 0x84FD +#define GL_TEXTURE_LOD_BIAS 0x8501 +#define GL_INCR_WRAP 0x8507 +#define GL_DECR_WRAP 0x8508 +#define GL_TEXTURE_DEPTH_SIZE 0x884A +#define GL_TEXTURE_COMPARE_MODE 0x884C +#define GL_TEXTURE_COMPARE_FUNC 0x884D +#define GL_BLEND_COLOR 0x8005 +#define GL_BLEND_EQUATION 0x8009 +#define GL_CONSTANT_COLOR 0x8001 +#define GL_ONE_MINUS_CONSTANT_COLOR 0x8002 +#define GL_CONSTANT_ALPHA 0x8003 +#define GL_ONE_MINUS_CONSTANT_ALPHA 0x8004 +#define GL_FUNC_ADD 0x8006 +#define GL_FUNC_REVERSE_SUBTRACT 0x800B +#define GL_FUNC_SUBTRACT 0x800A +#define GL_MIN 0x8007 +#define GL_MAX 0x8008 +#define GL_BUFFER_SIZE 0x8764 +#define GL_BUFFER_USAGE 0x8765 +#define GL_QUERY_COUNTER_BITS 0x8864 +#define GL_CURRENT_QUERY 0x8865 +#define GL_QUERY_RESULT 0x8866 +#define GL_QUERY_RESULT_AVAILABLE 0x8867 +#define GL_ARRAY_BUFFER 0x8892 +#define GL_ELEMENT_ARRAY_BUFFER 0x8893 +#define GL_ARRAY_BUFFER_BINDING 0x8894 +#define GL_ELEMENT_ARRAY_BUFFER_BINDING 0x8895 +#define GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING 0x889F +#define GL_READ_ONLY 0x88B8 +#define GL_WRITE_ONLY 0x88B9 +#define GL_READ_WRITE 0x88BA +#define GL_BUFFER_ACCESS 0x88BB +#define GL_BUFFER_MAPPED 0x88BC +#define GL_BUFFER_MAP_POINTER 0x88BD +#define GL_STREAM_DRAW 0x88E0 +#define GL_STREAM_READ 0x88E1 +#define GL_STREAM_COPY 0x88E2 +#define GL_STATIC_DRAW 0x88E4 +#define GL_STATIC_READ 0x88E5 +#define GL_STATIC_COPY 0x88E6 +#define GL_DYNAMIC_DRAW 0x88E8 +#define GL_DYNAMIC_READ 0x88E9 +#define GL_DYNAMIC_COPY 0x88EA +#define GL_SAMPLES_PASSED 0x8914 +#define GL_SRC1_ALPHA 0x8589 +#define GL_BLEND_EQUATION_RGB 0x8009 +#define GL_VERTEX_ATTRIB_ARRAY_ENABLED 0x8622 +#define GL_VERTEX_ATTRIB_ARRAY_SIZE 0x8623 +#define GL_VERTEX_ATTRIB_ARRAY_STRIDE 0x8624 +#define GL_VERTEX_ATTRIB_ARRAY_TYPE 0x8625 +#define GL_CURRENT_VERTEX_ATTRIB 0x8626 +#define GL_VERTEX_PROGRAM_POINT_SIZE 0x8642 +#define GL_VERTEX_ATTRIB_ARRAY_POINTER 0x8645 +#define GL_STENCIL_BACK_FUNC 0x8800 +#define GL_STENCIL_BACK_FAIL 0x8801 +#define GL_STENCIL_BACK_PASS_DEPTH_FAIL 0x8802 +#define GL_STENCIL_BACK_PASS_DEPTH_PASS 0x8803 +#define GL_MAX_DRAW_BUFFERS 0x8824 +#define GL_DRAW_BUFFER0 0x8825 +#define GL_DRAW_BUFFER1 0x8826 +#define GL_DRAW_BUFFER2 0x8827 +#define GL_DRAW_BUFFER3 0x8828 +#define GL_DRAW_BUFFER4 0x8829 +#define GL_DRAW_BUFFER5 0x882A +#define GL_DRAW_BUFFER6 0x882B +#define GL_DRAW_BUFFER7 0x882C +#define GL_DRAW_BUFFER8 0x882D +#define GL_DRAW_BUFFER9 0x882E +#define GL_DRAW_BUFFER10 0x882F +#define GL_DRAW_BUFFER11 0x8830 +#define GL_DRAW_BUFFER12 0x8831 +#define GL_DRAW_BUFFER13 0x8832 +#define GL_DRAW_BUFFER14 0x8833 +#define GL_DRAW_BUFFER15 0x8834 +#define GL_BLEND_EQUATION_ALPHA 0x883D +#define GL_MAX_VERTEX_ATTRIBS 0x8869 +#define GL_VERTEX_ATTRIB_ARRAY_NORMALIZED 0x886A +#define GL_MAX_TEXTURE_IMAGE_UNITS 0x8872 +#define GL_FRAGMENT_SHADER 0x8B30 +#define GL_VERTEX_SHADER 0x8B31 +#define GL_MAX_FRAGMENT_UNIFORM_COMPONENTS 0x8B49 +#define GL_MAX_VERTEX_UNIFORM_COMPONENTS 0x8B4A +#define GL_MAX_VARYING_FLOATS 0x8B4B +#define GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS 0x8B4C +#define GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS 0x8B4D +#define GL_SHADER_TYPE 0x8B4F +#define GL_FLOAT_VEC2 0x8B50 +#define GL_FLOAT_VEC3 0x8B51 +#define GL_FLOAT_VEC4 0x8B52 +#define GL_INT_VEC2 0x8B53 +#define GL_INT_VEC3 0x8B54 +#define GL_INT_VEC4 0x8B55 +#define GL_BOOL 0x8B56 +#define GL_BOOL_VEC2 0x8B57 +#define GL_BOOL_VEC3 0x8B58 +#define GL_BOOL_VEC4 0x8B59 +#define GL_FLOAT_MAT2 0x8B5A +#define GL_FLOAT_MAT3 0x8B5B +#define GL_FLOAT_MAT4 0x8B5C +#define GL_SAMPLER_1D 0x8B5D +#define GL_SAMPLER_2D 0x8B5E +#define GL_SAMPLER_3D 0x8B5F +#define GL_SAMPLER_CUBE 0x8B60 +#define GL_SAMPLER_1D_SHADOW 0x8B61 +#define GL_SAMPLER_2D_SHADOW 0x8B62 +#define GL_DELETE_STATUS 0x8B80 +#define GL_COMPILE_STATUS 0x8B81 +#define GL_LINK_STATUS 0x8B82 +#define GL_VALIDATE_STATUS 0x8B83 +#define GL_INFO_LOG_LENGTH 0x8B84 +#define GL_ATTACHED_SHADERS 0x8B85 +#define GL_ACTIVE_UNIFORMS 0x8B86 +#define GL_ACTIVE_UNIFORM_MAX_LENGTH 0x8B87 +#define GL_SHADER_SOURCE_LENGTH 0x8B88 +#define GL_ACTIVE_ATTRIBUTES 0x8B89 +#define GL_ACTIVE_ATTRIBUTE_MAX_LENGTH 0x8B8A +#define GL_FRAGMENT_SHADER_DERIVATIVE_HINT 0x8B8B +#define GL_SHADING_LANGUAGE_VERSION 0x8B8C +#define GL_CURRENT_PROGRAM 0x8B8D +#define GL_POINT_SPRITE_COORD_ORIGIN 0x8CA0 +#define GL_LOWER_LEFT 0x8CA1 +#define GL_UPPER_LEFT 0x8CA2 +#define GL_STENCIL_BACK_REF 0x8CA3 +#define GL_STENCIL_BACK_VALUE_MASK 0x8CA4 +#define GL_STENCIL_BACK_WRITEMASK 0x8CA5 +#define GL_PIXEL_PACK_BUFFER 0x88EB +#define GL_PIXEL_UNPACK_BUFFER 0x88EC +#define GL_PIXEL_PACK_BUFFER_BINDING 0x88ED +#define GL_PIXEL_UNPACK_BUFFER_BINDING 0x88EF +#define GL_FLOAT_MAT2x3 0x8B65 +#define GL_FLOAT_MAT2x4 0x8B66 +#define GL_FLOAT_MAT3x2 0x8B67 +#define GL_FLOAT_MAT3x4 0x8B68 +#define GL_FLOAT_MAT4x2 0x8B69 +#define GL_FLOAT_MAT4x3 0x8B6A +#define GL_SRGB 0x8C40 +#define GL_SRGB8 0x8C41 +#define GL_SRGB_ALPHA 0x8C42 +#define GL_SRGB8_ALPHA8 0x8C43 +#define GL_COMPRESSED_SRGB 0x8C48 +#define GL_COMPRESSED_SRGB_ALPHA 0x8C49 +#define GL_COMPARE_REF_TO_TEXTURE 0x884E +#define GL_CLIP_DISTANCE0 0x3000 +#define GL_CLIP_DISTANCE1 0x3001 +#define GL_CLIP_DISTANCE2 0x3002 +#define GL_CLIP_DISTANCE3 0x3003 +#define GL_CLIP_DISTANCE4 0x3004 +#define GL_CLIP_DISTANCE5 0x3005 +#define GL_CLIP_DISTANCE6 0x3006 +#define GL_CLIP_DISTANCE7 0x3007 +#define GL_MAX_CLIP_DISTANCES 0x0D32 +#define GL_MAJOR_VERSION 0x821B +#define GL_MINOR_VERSION 0x821C +#define GL_NUM_EXTENSIONS 0x821D +#define GL_CONTEXT_FLAGS 0x821E +#define GL_COMPRESSED_RED 0x8225 +#define GL_COMPRESSED_RG 0x8226 +#define GL_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT 0x00000001 +#define GL_RGBA32F 0x8814 +#define GL_RGB32F 0x8815 +#define GL_RGBA16F 0x881A +#define GL_RGB16F 0x881B +#define GL_VERTEX_ATTRIB_ARRAY_INTEGER 0x88FD +#define GL_MAX_ARRAY_TEXTURE_LAYERS 0x88FF +#define GL_MIN_PROGRAM_TEXEL_OFFSET 0x8904 +#define GL_MAX_PROGRAM_TEXEL_OFFSET 0x8905 +#define GL_CLAMP_READ_COLOR 0x891C +#define GL_FIXED_ONLY 0x891D +#define GL_MAX_VARYING_COMPONENTS 0x8B4B +#define GL_TEXTURE_1D_ARRAY 0x8C18 +#define GL_PROXY_TEXTURE_1D_ARRAY 0x8C19 +#define GL_TEXTURE_2D_ARRAY 0x8C1A +#define GL_PROXY_TEXTURE_2D_ARRAY 0x8C1B +#define GL_TEXTURE_BINDING_1D_ARRAY 0x8C1C +#define GL_TEXTURE_BINDING_2D_ARRAY 0x8C1D +#define GL_R11F_G11F_B10F 0x8C3A +#define GL_UNSIGNED_INT_10F_11F_11F_REV 0x8C3B +#define GL_RGB9_E5 0x8C3D +#define GL_UNSIGNED_INT_5_9_9_9_REV 0x8C3E +#define GL_TEXTURE_SHARED_SIZE 0x8C3F +#define GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH 0x8C76 +#define GL_TRANSFORM_FEEDBACK_BUFFER_MODE 0x8C7F +#define GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS 0x8C80 +#define GL_TRANSFORM_FEEDBACK_VARYINGS 0x8C83 +#define GL_TRANSFORM_FEEDBACK_BUFFER_START 0x8C84 +#define GL_TRANSFORM_FEEDBACK_BUFFER_SIZE 0x8C85 +#define GL_PRIMITIVES_GENERATED 0x8C87 +#define GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN 0x8C88 +#define GL_RASTERIZER_DISCARD 0x8C89 +#define GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS 0x8C8A +#define GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS 0x8C8B +#define GL_INTERLEAVED_ATTRIBS 0x8C8C +#define GL_SEPARATE_ATTRIBS 0x8C8D +#define GL_TRANSFORM_FEEDBACK_BUFFER 0x8C8E +#define GL_TRANSFORM_FEEDBACK_BUFFER_BINDING 0x8C8F +#define GL_RGBA32UI 0x8D70 +#define GL_RGB32UI 0x8D71 +#define GL_RGBA16UI 0x8D76 +#define GL_RGB16UI 0x8D77 +#define GL_RGBA8UI 0x8D7C +#define GL_RGB8UI 0x8D7D +#define GL_RGBA32I 0x8D82 +#define GL_RGB32I 0x8D83 +#define GL_RGBA16I 0x8D88 +#define GL_RGB16I 0x8D89 +#define GL_RGBA8I 0x8D8E +#define GL_RGB8I 0x8D8F +#define GL_RED_INTEGER 0x8D94 +#define GL_GREEN_INTEGER 0x8D95 +#define GL_BLUE_INTEGER 0x8D96 +#define GL_RGB_INTEGER 0x8D98 +#define GL_RGBA_INTEGER 0x8D99 +#define GL_BGR_INTEGER 0x8D9A +#define GL_BGRA_INTEGER 0x8D9B +#define GL_SAMPLER_1D_ARRAY 0x8DC0 +#define GL_SAMPLER_2D_ARRAY 0x8DC1 +#define GL_SAMPLER_1D_ARRAY_SHADOW 0x8DC3 +#define GL_SAMPLER_2D_ARRAY_SHADOW 0x8DC4 +#define GL_SAMPLER_CUBE_SHADOW 0x8DC5 +#define GL_UNSIGNED_INT_VEC2 0x8DC6 +#define GL_UNSIGNED_INT_VEC3 0x8DC7 +#define GL_UNSIGNED_INT_VEC4 0x8DC8 +#define GL_INT_SAMPLER_1D 0x8DC9 +#define GL_INT_SAMPLER_2D 0x8DCA +#define GL_INT_SAMPLER_3D 0x8DCB +#define GL_INT_SAMPLER_CUBE 0x8DCC +#define GL_INT_SAMPLER_1D_ARRAY 0x8DCE +#define GL_INT_SAMPLER_2D_ARRAY 0x8DCF +#define GL_UNSIGNED_INT_SAMPLER_1D 0x8DD1 +#define GL_UNSIGNED_INT_SAMPLER_2D 0x8DD2 +#define GL_UNSIGNED_INT_SAMPLER_3D 0x8DD3 +#define GL_UNSIGNED_INT_SAMPLER_CUBE 0x8DD4 +#define GL_UNSIGNED_INT_SAMPLER_1D_ARRAY 0x8DD6 +#define GL_UNSIGNED_INT_SAMPLER_2D_ARRAY 0x8DD7 +#define GL_QUERY_WAIT 0x8E13 +#define GL_QUERY_NO_WAIT 0x8E14 +#define GL_QUERY_BY_REGION_WAIT 0x8E15 +#define GL_QUERY_BY_REGION_NO_WAIT 0x8E16 +#define GL_BUFFER_ACCESS_FLAGS 0x911F +#define GL_BUFFER_MAP_LENGTH 0x9120 +#define GL_BUFFER_MAP_OFFSET 0x9121 +#define GL_DEPTH_COMPONENT32F 0x8CAC +#define GL_DEPTH32F_STENCIL8 0x8CAD +#define GL_FLOAT_32_UNSIGNED_INT_24_8_REV 0x8DAD +#define GL_INVALID_FRAMEBUFFER_OPERATION 0x0506 +#define GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING 0x8210 +#define GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE 0x8211 +#define GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE 0x8212 +#define GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE 0x8213 +#define GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE 0x8214 +#define GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE 0x8215 +#define GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE 0x8216 +#define GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE 0x8217 +#define GL_FRAMEBUFFER_DEFAULT 0x8218 +#define GL_FRAMEBUFFER_UNDEFINED 0x8219 +#define GL_DEPTH_STENCIL_ATTACHMENT 0x821A +#define GL_MAX_RENDERBUFFER_SIZE 0x84E8 +#define GL_DEPTH_STENCIL 0x84F9 +#define GL_UNSIGNED_INT_24_8 0x84FA +#define GL_DEPTH24_STENCIL8 0x88F0 +#define GL_TEXTURE_STENCIL_SIZE 0x88F1 +#define GL_TEXTURE_RED_TYPE 0x8C10 +#define GL_TEXTURE_GREEN_TYPE 0x8C11 +#define GL_TEXTURE_BLUE_TYPE 0x8C12 +#define GL_TEXTURE_ALPHA_TYPE 0x8C13 +#define GL_TEXTURE_DEPTH_TYPE 0x8C16 +#define GL_UNSIGNED_NORMALIZED 0x8C17 +#define GL_FRAMEBUFFER_BINDING 0x8CA6 +#define GL_DRAW_FRAMEBUFFER_BINDING 0x8CA6 +#define GL_RENDERBUFFER_BINDING 0x8CA7 +#define GL_READ_FRAMEBUFFER 0x8CA8 +#define GL_DRAW_FRAMEBUFFER 0x8CA9 +#define GL_READ_FRAMEBUFFER_BINDING 0x8CAA +#define GL_RENDERBUFFER_SAMPLES 0x8CAB +#define GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE 0x8CD0 +#define GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME 0x8CD1 +#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL 0x8CD2 +#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE 0x8CD3 +#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER 0x8CD4 +#define GL_FRAMEBUFFER_COMPLETE 0x8CD5 +#define GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT 0x8CD6 +#define GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT 0x8CD7 +#define GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER 0x8CDB +#define GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER 0x8CDC +#define GL_FRAMEBUFFER_UNSUPPORTED 0x8CDD +#define GL_MAX_COLOR_ATTACHMENTS 0x8CDF +#define GL_COLOR_ATTACHMENT0 0x8CE0 +#define GL_COLOR_ATTACHMENT1 0x8CE1 +#define GL_COLOR_ATTACHMENT2 0x8CE2 +#define GL_COLOR_ATTACHMENT3 0x8CE3 +#define GL_COLOR_ATTACHMENT4 0x8CE4 +#define GL_COLOR_ATTACHMENT5 0x8CE5 +#define GL_COLOR_ATTACHMENT6 0x8CE6 +#define GL_COLOR_ATTACHMENT7 0x8CE7 +#define GL_COLOR_ATTACHMENT8 0x8CE8 +#define GL_COLOR_ATTACHMENT9 0x8CE9 +#define GL_COLOR_ATTACHMENT10 0x8CEA +#define GL_COLOR_ATTACHMENT11 0x8CEB +#define GL_COLOR_ATTACHMENT12 0x8CEC +#define GL_COLOR_ATTACHMENT13 0x8CED +#define GL_COLOR_ATTACHMENT14 0x8CEE +#define GL_COLOR_ATTACHMENT15 0x8CEF +#define GL_COLOR_ATTACHMENT16 0x8CF0 +#define GL_COLOR_ATTACHMENT17 0x8CF1 +#define GL_COLOR_ATTACHMENT18 0x8CF2 +#define GL_COLOR_ATTACHMENT19 0x8CF3 +#define GL_COLOR_ATTACHMENT20 0x8CF4 +#define GL_COLOR_ATTACHMENT21 0x8CF5 +#define GL_COLOR_ATTACHMENT22 0x8CF6 +#define GL_COLOR_ATTACHMENT23 0x8CF7 +#define GL_COLOR_ATTACHMENT24 0x8CF8 +#define GL_COLOR_ATTACHMENT25 0x8CF9 +#define GL_COLOR_ATTACHMENT26 0x8CFA +#define GL_COLOR_ATTACHMENT27 0x8CFB +#define GL_COLOR_ATTACHMENT28 0x8CFC +#define GL_COLOR_ATTACHMENT29 0x8CFD +#define GL_COLOR_ATTACHMENT30 0x8CFE +#define GL_COLOR_ATTACHMENT31 0x8CFF +#define GL_DEPTH_ATTACHMENT 0x8D00 +#define GL_STENCIL_ATTACHMENT 0x8D20 +#define GL_FRAMEBUFFER 0x8D40 +#define GL_RENDERBUFFER 0x8D41 +#define GL_RENDERBUFFER_WIDTH 0x8D42 +#define GL_RENDERBUFFER_HEIGHT 0x8D43 +#define GL_RENDERBUFFER_INTERNAL_FORMAT 0x8D44 +#define GL_STENCIL_INDEX1 0x8D46 +#define GL_STENCIL_INDEX4 0x8D47 +#define GL_STENCIL_INDEX8 0x8D48 +#define GL_STENCIL_INDEX16 0x8D49 +#define GL_RENDERBUFFER_RED_SIZE 0x8D50 +#define GL_RENDERBUFFER_GREEN_SIZE 0x8D51 +#define GL_RENDERBUFFER_BLUE_SIZE 0x8D52 +#define GL_RENDERBUFFER_ALPHA_SIZE 0x8D53 +#define GL_RENDERBUFFER_DEPTH_SIZE 0x8D54 +#define GL_RENDERBUFFER_STENCIL_SIZE 0x8D55 +#define GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE 0x8D56 +#define GL_MAX_SAMPLES 0x8D57 +#define GL_FRAMEBUFFER_SRGB 0x8DB9 +#define GL_HALF_FLOAT 0x140B +#define GL_MAP_READ_BIT 0x0001 +#define GL_MAP_WRITE_BIT 0x0002 +#define GL_MAP_INVALIDATE_RANGE_BIT 0x0004 +#define GL_MAP_INVALIDATE_BUFFER_BIT 0x0008 +#define GL_MAP_FLUSH_EXPLICIT_BIT 0x0010 +#define GL_MAP_UNSYNCHRONIZED_BIT 0x0020 +#define GL_COMPRESSED_RED_RGTC1 0x8DBB +#define GL_COMPRESSED_SIGNED_RED_RGTC1 0x8DBC +#define GL_COMPRESSED_RG_RGTC2 0x8DBD +#define GL_COMPRESSED_SIGNED_RG_RGTC2 0x8DBE +#define GL_RG 0x8227 +#define GL_RG_INTEGER 0x8228 +#define GL_R8 0x8229 +#define GL_R16 0x822A +#define GL_RG8 0x822B +#define GL_RG16 0x822C +#define GL_R16F 0x822D +#define GL_R32F 0x822E +#define GL_RG16F 0x822F +#define GL_RG32F 0x8230 +#define GL_R8I 0x8231 +#define GL_R8UI 0x8232 +#define GL_R16I 0x8233 +#define GL_R16UI 0x8234 +#define GL_R32I 0x8235 +#define GL_R32UI 0x8236 +#define GL_RG8I 0x8237 +#define GL_RG8UI 0x8238 +#define GL_RG16I 0x8239 +#define GL_RG16UI 0x823A +#define GL_RG32I 0x823B +#define GL_RG32UI 0x823C +#define GL_VERTEX_ARRAY_BINDING 0x85B5 +#define GL_SAMPLER_2D_RECT 0x8B63 +#define GL_SAMPLER_2D_RECT_SHADOW 0x8B64 +#define GL_SAMPLER_BUFFER 0x8DC2 +#define GL_INT_SAMPLER_2D_RECT 0x8DCD +#define GL_INT_SAMPLER_BUFFER 0x8DD0 +#define GL_UNSIGNED_INT_SAMPLER_2D_RECT 0x8DD5 +#define GL_UNSIGNED_INT_SAMPLER_BUFFER 0x8DD8 +#define GL_TEXTURE_BUFFER 0x8C2A +#define GL_MAX_TEXTURE_BUFFER_SIZE 0x8C2B +#define GL_TEXTURE_BINDING_BUFFER 0x8C2C +#define GL_TEXTURE_BUFFER_DATA_STORE_BINDING 0x8C2D +#define GL_TEXTURE_RECTANGLE 0x84F5 +#define GL_TEXTURE_BINDING_RECTANGLE 0x84F6 +#define GL_PROXY_TEXTURE_RECTANGLE 0x84F7 +#define GL_MAX_RECTANGLE_TEXTURE_SIZE 0x84F8 +#define GL_R8_SNORM 0x8F94 +#define GL_RG8_SNORM 0x8F95 +#define GL_RGB8_SNORM 0x8F96 +#define GL_RGBA8_SNORM 0x8F97 +#define GL_R16_SNORM 0x8F98 +#define GL_RG16_SNORM 0x8F99 +#define GL_RGB16_SNORM 0x8F9A +#define GL_RGBA16_SNORM 0x8F9B +#define GL_SIGNED_NORMALIZED 0x8F9C +#define GL_PRIMITIVE_RESTART 0x8F9D +#define GL_PRIMITIVE_RESTART_INDEX 0x8F9E +#define GL_COPY_READ_BUFFER 0x8F36 +#define GL_COPY_WRITE_BUFFER 0x8F37 +#define GL_UNIFORM_BUFFER 0x8A11 +#define GL_UNIFORM_BUFFER_BINDING 0x8A28 +#define GL_UNIFORM_BUFFER_START 0x8A29 +#define GL_UNIFORM_BUFFER_SIZE 0x8A2A +#define GL_MAX_VERTEX_UNIFORM_BLOCKS 0x8A2B +#define GL_MAX_GEOMETRY_UNIFORM_BLOCKS 0x8A2C +#define GL_MAX_FRAGMENT_UNIFORM_BLOCKS 0x8A2D +#define GL_MAX_COMBINED_UNIFORM_BLOCKS 0x8A2E +#define GL_MAX_UNIFORM_BUFFER_BINDINGS 0x8A2F +#define GL_MAX_UNIFORM_BLOCK_SIZE 0x8A30 +#define GL_MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS 0x8A31 +#define GL_MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS 0x8A32 +#define GL_MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS 0x8A33 +#define GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT 0x8A34 +#define GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH 0x8A35 +#define GL_ACTIVE_UNIFORM_BLOCKS 0x8A36 +#define GL_UNIFORM_TYPE 0x8A37 +#define GL_UNIFORM_SIZE 0x8A38 +#define GL_UNIFORM_NAME_LENGTH 0x8A39 +#define GL_UNIFORM_BLOCK_INDEX 0x8A3A +#define GL_UNIFORM_OFFSET 0x8A3B +#define GL_UNIFORM_ARRAY_STRIDE 0x8A3C +#define GL_UNIFORM_MATRIX_STRIDE 0x8A3D +#define GL_UNIFORM_IS_ROW_MAJOR 0x8A3E +#define GL_UNIFORM_BLOCK_BINDING 0x8A3F +#define GL_UNIFORM_BLOCK_DATA_SIZE 0x8A40 +#define GL_UNIFORM_BLOCK_NAME_LENGTH 0x8A41 +#define GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS 0x8A42 +#define GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES 0x8A43 +#define GL_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER 0x8A44 +#define GL_UNIFORM_BLOCK_REFERENCED_BY_GEOMETRY_SHADER 0x8A45 +#define GL_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER 0x8A46 +#define GL_INVALID_INDEX 0xFFFFFFFF +#define GL_CONTEXT_CORE_PROFILE_BIT 0x00000001 +#define GL_CONTEXT_COMPATIBILITY_PROFILE_BIT 0x00000002 +#define GL_LINES_ADJACENCY 0x000A +#define GL_LINE_STRIP_ADJACENCY 0x000B +#define GL_TRIANGLES_ADJACENCY 0x000C +#define GL_TRIANGLE_STRIP_ADJACENCY 0x000D +#define GL_PROGRAM_POINT_SIZE 0x8642 +#define GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS 0x8C29 +#define GL_FRAMEBUFFER_ATTACHMENT_LAYERED 0x8DA7 +#define GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS 0x8DA8 +#define GL_GEOMETRY_SHADER 0x8DD9 +#define GL_GEOMETRY_VERTICES_OUT 0x8916 +#define GL_GEOMETRY_INPUT_TYPE 0x8917 +#define GL_GEOMETRY_OUTPUT_TYPE 0x8918 +#define GL_MAX_GEOMETRY_UNIFORM_COMPONENTS 0x8DDF +#define GL_MAX_GEOMETRY_OUTPUT_VERTICES 0x8DE0 +#define GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS 0x8DE1 +#define GL_MAX_VERTEX_OUTPUT_COMPONENTS 0x9122 +#define GL_MAX_GEOMETRY_INPUT_COMPONENTS 0x9123 +#define GL_MAX_GEOMETRY_OUTPUT_COMPONENTS 0x9124 +#define GL_MAX_FRAGMENT_INPUT_COMPONENTS 0x9125 +#define GL_CONTEXT_PROFILE_MASK 0x9126 +#define GL_DEPTH_CLAMP 0x864F +#define GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION 0x8E4C +#define GL_FIRST_VERTEX_CONVENTION 0x8E4D +#define GL_LAST_VERTEX_CONVENTION 0x8E4E +#define GL_PROVOKING_VERTEX 0x8E4F +#define GL_TEXTURE_CUBE_MAP_SEAMLESS 0x884F +#define GL_MAX_SERVER_WAIT_TIMEOUT 0x9111 +#define GL_OBJECT_TYPE 0x9112 +#define GL_SYNC_CONDITION 0x9113 +#define GL_SYNC_STATUS 0x9114 +#define GL_SYNC_FLAGS 0x9115 +#define GL_SYNC_FENCE 0x9116 +#define GL_SYNC_GPU_COMMANDS_COMPLETE 0x9117 +#define GL_UNSIGNALED 0x9118 +#define GL_SIGNALED 0x9119 +#define GL_ALREADY_SIGNALED 0x911A +#define GL_TIMEOUT_EXPIRED 0x911B +#define GL_CONDITION_SATISFIED 0x911C +#define GL_WAIT_FAILED 0x911D +#define GL_TIMEOUT_IGNORED 0xFFFFFFFFFFFFFFFF +#define GL_SYNC_FLUSH_COMMANDS_BIT 0x00000001 +#define GL_SAMPLE_POSITION 0x8E50 +#define GL_SAMPLE_MASK 0x8E51 +#define GL_SAMPLE_MASK_VALUE 0x8E52 +#define GL_MAX_SAMPLE_MASK_WORDS 0x8E59 +#define GL_TEXTURE_2D_MULTISAMPLE 0x9100 +#define GL_PROXY_TEXTURE_2D_MULTISAMPLE 0x9101 +#define GL_TEXTURE_2D_MULTISAMPLE_ARRAY 0x9102 +#define GL_PROXY_TEXTURE_2D_MULTISAMPLE_ARRAY 0x9103 +#define GL_TEXTURE_BINDING_2D_MULTISAMPLE 0x9104 +#define GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY 0x9105 +#define GL_TEXTURE_SAMPLES 0x9106 +#define GL_TEXTURE_FIXED_SAMPLE_LOCATIONS 0x9107 +#define GL_SAMPLER_2D_MULTISAMPLE 0x9108 +#define GL_INT_SAMPLER_2D_MULTISAMPLE 0x9109 +#define GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE 0x910A +#define GL_SAMPLER_2D_MULTISAMPLE_ARRAY 0x910B +#define GL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY 0x910C +#define GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY 0x910D +#define GL_MAX_COLOR_TEXTURE_SAMPLES 0x910E +#define GL_MAX_DEPTH_TEXTURE_SAMPLES 0x910F +#define GL_MAX_INTEGER_SAMPLES 0x9110 +#define GL_VERTEX_ATTRIB_ARRAY_DIVISOR 0x88FE +#define GL_SRC1_COLOR 0x88F9 +#define GL_ONE_MINUS_SRC1_COLOR 0x88FA +#define GL_ONE_MINUS_SRC1_ALPHA 0x88FB +#define GL_MAX_DUAL_SOURCE_DRAW_BUFFERS 0x88FC +#define GL_ANY_SAMPLES_PASSED 0x8C2F +#define GL_SAMPLER_BINDING 0x8919 +#define GL_RGB10_A2UI 0x906F +#define GL_TEXTURE_SWIZZLE_R 0x8E42 +#define GL_TEXTURE_SWIZZLE_G 0x8E43 +#define GL_TEXTURE_SWIZZLE_B 0x8E44 +#define GL_TEXTURE_SWIZZLE_A 0x8E45 +#define GL_TEXTURE_SWIZZLE_RGBA 0x8E46 +#define GL_TIME_ELAPSED 0x88BF +#define GL_TIMESTAMP 0x8E28 +#define GL_INT_2_10_10_10_REV 0x8D9F +#ifndef GL_VERSION_1_0 +#define GL_VERSION_1_0 1 +GLAPI int GLAD_GL_VERSION_1_0; +typedef void (APIENTRYP PFNGLCULLFACEPROC)(GLenum mode); +GLAPI PFNGLCULLFACEPROC glad_glCullFace; +#define glCullFace glad_glCullFace +typedef void (APIENTRYP PFNGLFRONTFACEPROC)(GLenum mode); +GLAPI PFNGLFRONTFACEPROC glad_glFrontFace; +#define glFrontFace glad_glFrontFace +typedef void (APIENTRYP PFNGLHINTPROC)(GLenum target, GLenum mode); +GLAPI PFNGLHINTPROC glad_glHint; +#define glHint glad_glHint +typedef void (APIENTRYP PFNGLLINEWIDTHPROC)(GLfloat width); +GLAPI PFNGLLINEWIDTHPROC glad_glLineWidth; +#define glLineWidth glad_glLineWidth +typedef void (APIENTRYP PFNGLPOINTSIZEPROC)(GLfloat size); +GLAPI PFNGLPOINTSIZEPROC glad_glPointSize; +#define glPointSize glad_glPointSize +typedef void (APIENTRYP PFNGLPOLYGONMODEPROC)(GLenum face, GLenum mode); +GLAPI PFNGLPOLYGONMODEPROC glad_glPolygonMode; +#define glPolygonMode glad_glPolygonMode +typedef void (APIENTRYP PFNGLSCISSORPROC)(GLint x, GLint y, GLsizei width, GLsizei height); +GLAPI PFNGLSCISSORPROC glad_glScissor; +#define glScissor glad_glScissor +typedef void (APIENTRYP PFNGLTEXPARAMETERFPROC)(GLenum target, GLenum pname, GLfloat param); +GLAPI PFNGLTEXPARAMETERFPROC glad_glTexParameterf; +#define glTexParameterf glad_glTexParameterf +typedef void (APIENTRYP PFNGLTEXPARAMETERFVPROC)(GLenum target, GLenum pname, const GLfloat *params); +GLAPI PFNGLTEXPARAMETERFVPROC glad_glTexParameterfv; +#define glTexParameterfv glad_glTexParameterfv +typedef void (APIENTRYP PFNGLTEXPARAMETERIPROC)(GLenum target, GLenum pname, GLint param); +GLAPI PFNGLTEXPARAMETERIPROC glad_glTexParameteri; +#define glTexParameteri glad_glTexParameteri +typedef void (APIENTRYP PFNGLTEXPARAMETERIVPROC)(GLenum target, GLenum pname, const GLint *params); +GLAPI PFNGLTEXPARAMETERIVPROC glad_glTexParameteriv; +#define glTexParameteriv glad_glTexParameteriv +typedef void (APIENTRYP PFNGLTEXIMAGE1DPROC)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const void *pixels); +GLAPI PFNGLTEXIMAGE1DPROC glad_glTexImage1D; +#define glTexImage1D glad_glTexImage1D +typedef void (APIENTRYP PFNGLTEXIMAGE2DPROC)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void *pixels); +GLAPI PFNGLTEXIMAGE2DPROC glad_glTexImage2D; +#define glTexImage2D glad_glTexImage2D +typedef void (APIENTRYP PFNGLDRAWBUFFERPROC)(GLenum buf); +GLAPI PFNGLDRAWBUFFERPROC glad_glDrawBuffer; +#define glDrawBuffer glad_glDrawBuffer +typedef void (APIENTRYP PFNGLCLEARPROC)(GLbitfield mask); +GLAPI PFNGLCLEARPROC glad_glClear; +#define glClear glad_glClear +typedef void (APIENTRYP PFNGLCLEARCOLORPROC)(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); +GLAPI PFNGLCLEARCOLORPROC glad_glClearColor; +#define glClearColor glad_glClearColor +typedef void (APIENTRYP PFNGLCLEARSTENCILPROC)(GLint s); +GLAPI PFNGLCLEARSTENCILPROC glad_glClearStencil; +#define glClearStencil glad_glClearStencil +typedef void (APIENTRYP PFNGLCLEARDEPTHPROC)(GLdouble depth); +GLAPI PFNGLCLEARDEPTHPROC glad_glClearDepth; +#define glClearDepth glad_glClearDepth +typedef void (APIENTRYP PFNGLSTENCILMASKPROC)(GLuint mask); +GLAPI PFNGLSTENCILMASKPROC glad_glStencilMask; +#define glStencilMask glad_glStencilMask +typedef void (APIENTRYP PFNGLCOLORMASKPROC)(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha); +GLAPI PFNGLCOLORMASKPROC glad_glColorMask; +#define glColorMask glad_glColorMask +typedef void (APIENTRYP PFNGLDEPTHMASKPROC)(GLboolean flag); +GLAPI PFNGLDEPTHMASKPROC glad_glDepthMask; +#define glDepthMask glad_glDepthMask +typedef void (APIENTRYP PFNGLDISABLEPROC)(GLenum cap); +GLAPI PFNGLDISABLEPROC glad_glDisable; +#define glDisable glad_glDisable +typedef void (APIENTRYP PFNGLENABLEPROC)(GLenum cap); +GLAPI PFNGLENABLEPROC glad_glEnable; +#define glEnable glad_glEnable +typedef void (APIENTRYP PFNGLFINISHPROC)(void); +GLAPI PFNGLFINISHPROC glad_glFinish; +#define glFinish glad_glFinish +typedef void (APIENTRYP PFNGLFLUSHPROC)(void); +GLAPI PFNGLFLUSHPROC glad_glFlush; +#define glFlush glad_glFlush +typedef void (APIENTRYP PFNGLBLENDFUNCPROC)(GLenum sfactor, GLenum dfactor); +GLAPI PFNGLBLENDFUNCPROC glad_glBlendFunc; +#define glBlendFunc glad_glBlendFunc +typedef void (APIENTRYP PFNGLLOGICOPPROC)(GLenum opcode); +GLAPI PFNGLLOGICOPPROC glad_glLogicOp; +#define glLogicOp glad_glLogicOp +typedef void (APIENTRYP PFNGLSTENCILFUNCPROC)(GLenum func, GLint ref, GLuint mask); +GLAPI PFNGLSTENCILFUNCPROC glad_glStencilFunc; +#define glStencilFunc glad_glStencilFunc +typedef void (APIENTRYP PFNGLSTENCILOPPROC)(GLenum fail, GLenum zfail, GLenum zpass); +GLAPI PFNGLSTENCILOPPROC glad_glStencilOp; +#define glStencilOp glad_glStencilOp +typedef void (APIENTRYP PFNGLDEPTHFUNCPROC)(GLenum func); +GLAPI PFNGLDEPTHFUNCPROC glad_glDepthFunc; +#define glDepthFunc glad_glDepthFunc +typedef void (APIENTRYP PFNGLPIXELSTOREFPROC)(GLenum pname, GLfloat param); +GLAPI PFNGLPIXELSTOREFPROC glad_glPixelStoref; +#define glPixelStoref glad_glPixelStoref +typedef void (APIENTRYP PFNGLPIXELSTOREIPROC)(GLenum pname, GLint param); +GLAPI PFNGLPIXELSTOREIPROC glad_glPixelStorei; +#define glPixelStorei glad_glPixelStorei +typedef void (APIENTRYP PFNGLREADBUFFERPROC)(GLenum src); +GLAPI PFNGLREADBUFFERPROC glad_glReadBuffer; +#define glReadBuffer glad_glReadBuffer +typedef void (APIENTRYP PFNGLREADPIXELSPROC)(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void *pixels); +GLAPI PFNGLREADPIXELSPROC glad_glReadPixels; +#define glReadPixels glad_glReadPixels +typedef void (APIENTRYP PFNGLGETBOOLEANVPROC)(GLenum pname, GLboolean *data); +GLAPI PFNGLGETBOOLEANVPROC glad_glGetBooleanv; +#define glGetBooleanv glad_glGetBooleanv +typedef void (APIENTRYP PFNGLGETDOUBLEVPROC)(GLenum pname, GLdouble *data); +GLAPI PFNGLGETDOUBLEVPROC glad_glGetDoublev; +#define glGetDoublev glad_glGetDoublev +typedef GLenum (APIENTRYP PFNGLGETERRORPROC)(void); +GLAPI PFNGLGETERRORPROC glad_glGetError; +#define glGetError glad_glGetError +typedef void (APIENTRYP PFNGLGETFLOATVPROC)(GLenum pname, GLfloat *data); +GLAPI PFNGLGETFLOATVPROC glad_glGetFloatv; +#define glGetFloatv glad_glGetFloatv +typedef void (APIENTRYP PFNGLGETINTEGERVPROC)(GLenum pname, GLint *data); +GLAPI PFNGLGETINTEGERVPROC glad_glGetIntegerv; +#define glGetIntegerv glad_glGetIntegerv +typedef const GLubyte * (APIENTRYP PFNGLGETSTRINGPROC)(GLenum name); +GLAPI PFNGLGETSTRINGPROC glad_glGetString; +#define glGetString glad_glGetString +typedef void (APIENTRYP PFNGLGETTEXIMAGEPROC)(GLenum target, GLint level, GLenum format, GLenum type, void *pixels); +GLAPI PFNGLGETTEXIMAGEPROC glad_glGetTexImage; +#define glGetTexImage glad_glGetTexImage +typedef void (APIENTRYP PFNGLGETTEXPARAMETERFVPROC)(GLenum target, GLenum pname, GLfloat *params); +GLAPI PFNGLGETTEXPARAMETERFVPROC glad_glGetTexParameterfv; +#define glGetTexParameterfv glad_glGetTexParameterfv +typedef void (APIENTRYP PFNGLGETTEXPARAMETERIVPROC)(GLenum target, GLenum pname, GLint *params); +GLAPI PFNGLGETTEXPARAMETERIVPROC glad_glGetTexParameteriv; +#define glGetTexParameteriv glad_glGetTexParameteriv +typedef void (APIENTRYP PFNGLGETTEXLEVELPARAMETERFVPROC)(GLenum target, GLint level, GLenum pname, GLfloat *params); +GLAPI PFNGLGETTEXLEVELPARAMETERFVPROC glad_glGetTexLevelParameterfv; +#define glGetTexLevelParameterfv glad_glGetTexLevelParameterfv +typedef void (APIENTRYP PFNGLGETTEXLEVELPARAMETERIVPROC)(GLenum target, GLint level, GLenum pname, GLint *params); +GLAPI PFNGLGETTEXLEVELPARAMETERIVPROC glad_glGetTexLevelParameteriv; +#define glGetTexLevelParameteriv glad_glGetTexLevelParameteriv +typedef GLboolean (APIENTRYP PFNGLISENABLEDPROC)(GLenum cap); +GLAPI PFNGLISENABLEDPROC glad_glIsEnabled; +#define glIsEnabled glad_glIsEnabled +typedef void (APIENTRYP PFNGLDEPTHRANGEPROC)(GLdouble n, GLdouble f); +GLAPI PFNGLDEPTHRANGEPROC glad_glDepthRange; +#define glDepthRange glad_glDepthRange +typedef void (APIENTRYP PFNGLVIEWPORTPROC)(GLint x, GLint y, GLsizei width, GLsizei height); +GLAPI PFNGLVIEWPORTPROC glad_glViewport; +#define glViewport glad_glViewport +#endif +#ifndef GL_VERSION_1_1 +#define GL_VERSION_1_1 1 +GLAPI int GLAD_GL_VERSION_1_1; +typedef void (APIENTRYP PFNGLDRAWARRAYSPROC)(GLenum mode, GLint first, GLsizei count); +GLAPI PFNGLDRAWARRAYSPROC glad_glDrawArrays; +#define glDrawArrays glad_glDrawArrays +typedef void (APIENTRYP PFNGLDRAWELEMENTSPROC)(GLenum mode, GLsizei count, GLenum type, const void *indices); +GLAPI PFNGLDRAWELEMENTSPROC glad_glDrawElements; +#define glDrawElements glad_glDrawElements +typedef void (APIENTRYP PFNGLPOLYGONOFFSETPROC)(GLfloat factor, GLfloat units); +GLAPI PFNGLPOLYGONOFFSETPROC glad_glPolygonOffset; +#define glPolygonOffset glad_glPolygonOffset +typedef void (APIENTRYP PFNGLCOPYTEXIMAGE1DPROC)(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border); +GLAPI PFNGLCOPYTEXIMAGE1DPROC glad_glCopyTexImage1D; +#define glCopyTexImage1D glad_glCopyTexImage1D +typedef void (APIENTRYP PFNGLCOPYTEXIMAGE2DPROC)(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border); +GLAPI PFNGLCOPYTEXIMAGE2DPROC glad_glCopyTexImage2D; +#define glCopyTexImage2D glad_glCopyTexImage2D +typedef void (APIENTRYP PFNGLCOPYTEXSUBIMAGE1DPROC)(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width); +GLAPI PFNGLCOPYTEXSUBIMAGE1DPROC glad_glCopyTexSubImage1D; +#define glCopyTexSubImage1D glad_glCopyTexSubImage1D +typedef void (APIENTRYP PFNGLCOPYTEXSUBIMAGE2DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height); +GLAPI PFNGLCOPYTEXSUBIMAGE2DPROC glad_glCopyTexSubImage2D; +#define glCopyTexSubImage2D glad_glCopyTexSubImage2D +typedef void (APIENTRYP PFNGLTEXSUBIMAGE1DPROC)(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void *pixels); +GLAPI PFNGLTEXSUBIMAGE1DPROC glad_glTexSubImage1D; +#define glTexSubImage1D glad_glTexSubImage1D +typedef void (APIENTRYP PFNGLTEXSUBIMAGE2DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels); +GLAPI PFNGLTEXSUBIMAGE2DPROC glad_glTexSubImage2D; +#define glTexSubImage2D glad_glTexSubImage2D +typedef void (APIENTRYP PFNGLBINDTEXTUREPROC)(GLenum target, GLuint texture); +GLAPI PFNGLBINDTEXTUREPROC glad_glBindTexture; +#define glBindTexture glad_glBindTexture +typedef void (APIENTRYP PFNGLDELETETEXTURESPROC)(GLsizei n, const GLuint *textures); +GLAPI PFNGLDELETETEXTURESPROC glad_glDeleteTextures; +#define glDeleteTextures glad_glDeleteTextures +typedef void (APIENTRYP PFNGLGENTEXTURESPROC)(GLsizei n, GLuint *textures); +GLAPI PFNGLGENTEXTURESPROC glad_glGenTextures; +#define glGenTextures glad_glGenTextures +typedef GLboolean (APIENTRYP PFNGLISTEXTUREPROC)(GLuint texture); +GLAPI PFNGLISTEXTUREPROC glad_glIsTexture; +#define glIsTexture glad_glIsTexture +#endif +#ifndef GL_VERSION_1_2 +#define GL_VERSION_1_2 1 +GLAPI int GLAD_GL_VERSION_1_2; +typedef void (APIENTRYP PFNGLDRAWRANGEELEMENTSPROC)(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void *indices); +GLAPI PFNGLDRAWRANGEELEMENTSPROC glad_glDrawRangeElements; +#define glDrawRangeElements glad_glDrawRangeElements +typedef void (APIENTRYP PFNGLTEXIMAGE3DPROC)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void *pixels); +GLAPI PFNGLTEXIMAGE3DPROC glad_glTexImage3D; +#define glTexImage3D glad_glTexImage3D +typedef void (APIENTRYP PFNGLTEXSUBIMAGE3DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *pixels); +GLAPI PFNGLTEXSUBIMAGE3DPROC glad_glTexSubImage3D; +#define glTexSubImage3D glad_glTexSubImage3D +typedef void (APIENTRYP PFNGLCOPYTEXSUBIMAGE3DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height); +GLAPI PFNGLCOPYTEXSUBIMAGE3DPROC glad_glCopyTexSubImage3D; +#define glCopyTexSubImage3D glad_glCopyTexSubImage3D +#endif +#ifndef GL_VERSION_1_3 +#define GL_VERSION_1_3 1 +GLAPI int GLAD_GL_VERSION_1_3; +typedef void (APIENTRYP PFNGLACTIVETEXTUREPROC)(GLenum texture); +GLAPI PFNGLACTIVETEXTUREPROC glad_glActiveTexture; +#define glActiveTexture glad_glActiveTexture +typedef void (APIENTRYP PFNGLSAMPLECOVERAGEPROC)(GLfloat value, GLboolean invert); +GLAPI PFNGLSAMPLECOVERAGEPROC glad_glSampleCoverage; +#define glSampleCoverage glad_glSampleCoverage +typedef void (APIENTRYP PFNGLCOMPRESSEDTEXIMAGE3DPROC)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void *data); +GLAPI PFNGLCOMPRESSEDTEXIMAGE3DPROC glad_glCompressedTexImage3D; +#define glCompressedTexImage3D glad_glCompressedTexImage3D +typedef void (APIENTRYP PFNGLCOMPRESSEDTEXIMAGE2DPROC)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void *data); +GLAPI PFNGLCOMPRESSEDTEXIMAGE2DPROC glad_glCompressedTexImage2D; +#define glCompressedTexImage2D glad_glCompressedTexImage2D +typedef void (APIENTRYP PFNGLCOMPRESSEDTEXIMAGE1DPROC)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const void *data); +GLAPI PFNGLCOMPRESSEDTEXIMAGE1DPROC glad_glCompressedTexImage1D; +#define glCompressedTexImage1D glad_glCompressedTexImage1D +typedef void (APIENTRYP PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *data); +GLAPI PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC glad_glCompressedTexSubImage3D; +#define glCompressedTexSubImage3D glad_glCompressedTexSubImage3D +typedef void (APIENTRYP PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *data); +GLAPI PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC glad_glCompressedTexSubImage2D; +#define glCompressedTexSubImage2D glad_glCompressedTexSubImage2D +typedef void (APIENTRYP PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC)(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void *data); +GLAPI PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC glad_glCompressedTexSubImage1D; +#define glCompressedTexSubImage1D glad_glCompressedTexSubImage1D +typedef void (APIENTRYP PFNGLGETCOMPRESSEDTEXIMAGEPROC)(GLenum target, GLint level, void *img); +GLAPI PFNGLGETCOMPRESSEDTEXIMAGEPROC glad_glGetCompressedTexImage; +#define glGetCompressedTexImage glad_glGetCompressedTexImage +#endif +#ifndef GL_VERSION_1_4 +#define GL_VERSION_1_4 1 +GLAPI int GLAD_GL_VERSION_1_4; +typedef void (APIENTRYP PFNGLBLENDFUNCSEPARATEPROC)(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha); +GLAPI PFNGLBLENDFUNCSEPARATEPROC glad_glBlendFuncSeparate; +#define glBlendFuncSeparate glad_glBlendFuncSeparate +typedef void (APIENTRYP PFNGLMULTIDRAWARRAYSPROC)(GLenum mode, const GLint *first, const GLsizei *count, GLsizei drawcount); +GLAPI PFNGLMULTIDRAWARRAYSPROC glad_glMultiDrawArrays; +#define glMultiDrawArrays glad_glMultiDrawArrays +typedef void (APIENTRYP PFNGLMULTIDRAWELEMENTSPROC)(GLenum mode, const GLsizei *count, GLenum type, const void *const*indices, GLsizei drawcount); +GLAPI PFNGLMULTIDRAWELEMENTSPROC glad_glMultiDrawElements; +#define glMultiDrawElements glad_glMultiDrawElements +typedef void (APIENTRYP PFNGLPOINTPARAMETERFPROC)(GLenum pname, GLfloat param); +GLAPI PFNGLPOINTPARAMETERFPROC glad_glPointParameterf; +#define glPointParameterf glad_glPointParameterf +typedef void (APIENTRYP PFNGLPOINTPARAMETERFVPROC)(GLenum pname, const GLfloat *params); +GLAPI PFNGLPOINTPARAMETERFVPROC glad_glPointParameterfv; +#define glPointParameterfv glad_glPointParameterfv +typedef void (APIENTRYP PFNGLPOINTPARAMETERIPROC)(GLenum pname, GLint param); +GLAPI PFNGLPOINTPARAMETERIPROC glad_glPointParameteri; +#define glPointParameteri glad_glPointParameteri +typedef void (APIENTRYP PFNGLPOINTPARAMETERIVPROC)(GLenum pname, const GLint *params); +GLAPI PFNGLPOINTPARAMETERIVPROC glad_glPointParameteriv; +#define glPointParameteriv glad_glPointParameteriv +typedef void (APIENTRYP PFNGLBLENDCOLORPROC)(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); +GLAPI PFNGLBLENDCOLORPROC glad_glBlendColor; +#define glBlendColor glad_glBlendColor +typedef void (APIENTRYP PFNGLBLENDEQUATIONPROC)(GLenum mode); +GLAPI PFNGLBLENDEQUATIONPROC glad_glBlendEquation; +#define glBlendEquation glad_glBlendEquation +#endif +#ifndef GL_VERSION_1_5 +#define GL_VERSION_1_5 1 +GLAPI int GLAD_GL_VERSION_1_5; +typedef void (APIENTRYP PFNGLGENQUERIESPROC)(GLsizei n, GLuint *ids); +GLAPI PFNGLGENQUERIESPROC glad_glGenQueries; +#define glGenQueries glad_glGenQueries +typedef void (APIENTRYP PFNGLDELETEQUERIESPROC)(GLsizei n, const GLuint *ids); +GLAPI PFNGLDELETEQUERIESPROC glad_glDeleteQueries; +#define glDeleteQueries glad_glDeleteQueries +typedef GLboolean (APIENTRYP PFNGLISQUERYPROC)(GLuint id); +GLAPI PFNGLISQUERYPROC glad_glIsQuery; +#define glIsQuery glad_glIsQuery +typedef void (APIENTRYP PFNGLBEGINQUERYPROC)(GLenum target, GLuint id); +GLAPI PFNGLBEGINQUERYPROC glad_glBeginQuery; +#define glBeginQuery glad_glBeginQuery +typedef void (APIENTRYP PFNGLENDQUERYPROC)(GLenum target); +GLAPI PFNGLENDQUERYPROC glad_glEndQuery; +#define glEndQuery glad_glEndQuery +typedef void (APIENTRYP PFNGLGETQUERYIVPROC)(GLenum target, GLenum pname, GLint *params); +GLAPI PFNGLGETQUERYIVPROC glad_glGetQueryiv; +#define glGetQueryiv glad_glGetQueryiv +typedef void (APIENTRYP PFNGLGETQUERYOBJECTIVPROC)(GLuint id, GLenum pname, GLint *params); +GLAPI PFNGLGETQUERYOBJECTIVPROC glad_glGetQueryObjectiv; +#define glGetQueryObjectiv glad_glGetQueryObjectiv +typedef void (APIENTRYP PFNGLGETQUERYOBJECTUIVPROC)(GLuint id, GLenum pname, GLuint *params); +GLAPI PFNGLGETQUERYOBJECTUIVPROC glad_glGetQueryObjectuiv; +#define glGetQueryObjectuiv glad_glGetQueryObjectuiv +typedef void (APIENTRYP PFNGLBINDBUFFERPROC)(GLenum target, GLuint buffer); +GLAPI PFNGLBINDBUFFERPROC glad_glBindBuffer; +#define glBindBuffer glad_glBindBuffer +typedef void (APIENTRYP PFNGLDELETEBUFFERSPROC)(GLsizei n, const GLuint *buffers); +GLAPI PFNGLDELETEBUFFERSPROC glad_glDeleteBuffers; +#define glDeleteBuffers glad_glDeleteBuffers +typedef void (APIENTRYP PFNGLGENBUFFERSPROC)(GLsizei n, GLuint *buffers); +GLAPI PFNGLGENBUFFERSPROC glad_glGenBuffers; +#define glGenBuffers glad_glGenBuffers +typedef GLboolean (APIENTRYP PFNGLISBUFFERPROC)(GLuint buffer); +GLAPI PFNGLISBUFFERPROC glad_glIsBuffer; +#define glIsBuffer glad_glIsBuffer +typedef void (APIENTRYP PFNGLBUFFERDATAPROC)(GLenum target, GLsizeiptr size, const void *data, GLenum usage); +GLAPI PFNGLBUFFERDATAPROC glad_glBufferData; +#define glBufferData glad_glBufferData +typedef void (APIENTRYP PFNGLBUFFERSUBDATAPROC)(GLenum target, GLintptr offset, GLsizeiptr size, const void *data); +GLAPI PFNGLBUFFERSUBDATAPROC glad_glBufferSubData; +#define glBufferSubData glad_glBufferSubData +typedef void (APIENTRYP PFNGLGETBUFFERSUBDATAPROC)(GLenum target, GLintptr offset, GLsizeiptr size, void *data); +GLAPI PFNGLGETBUFFERSUBDATAPROC glad_glGetBufferSubData; +#define glGetBufferSubData glad_glGetBufferSubData +typedef void * (APIENTRYP PFNGLMAPBUFFERPROC)(GLenum target, GLenum access); +GLAPI PFNGLMAPBUFFERPROC glad_glMapBuffer; +#define glMapBuffer glad_glMapBuffer +typedef GLboolean (APIENTRYP PFNGLUNMAPBUFFERPROC)(GLenum target); +GLAPI PFNGLUNMAPBUFFERPROC glad_glUnmapBuffer; +#define glUnmapBuffer glad_glUnmapBuffer +typedef void (APIENTRYP PFNGLGETBUFFERPARAMETERIVPROC)(GLenum target, GLenum pname, GLint *params); +GLAPI PFNGLGETBUFFERPARAMETERIVPROC glad_glGetBufferParameteriv; +#define glGetBufferParameteriv glad_glGetBufferParameteriv +typedef void (APIENTRYP PFNGLGETBUFFERPOINTERVPROC)(GLenum target, GLenum pname, void **params); +GLAPI PFNGLGETBUFFERPOINTERVPROC glad_glGetBufferPointerv; +#define glGetBufferPointerv glad_glGetBufferPointerv +#endif +#ifndef GL_VERSION_2_0 +#define GL_VERSION_2_0 1 +GLAPI int GLAD_GL_VERSION_2_0; +typedef void (APIENTRYP PFNGLBLENDEQUATIONSEPARATEPROC)(GLenum modeRGB, GLenum modeAlpha); +GLAPI PFNGLBLENDEQUATIONSEPARATEPROC glad_glBlendEquationSeparate; +#define glBlendEquationSeparate glad_glBlendEquationSeparate +typedef void (APIENTRYP PFNGLDRAWBUFFERSPROC)(GLsizei n, const GLenum *bufs); +GLAPI PFNGLDRAWBUFFERSPROC glad_glDrawBuffers; +#define glDrawBuffers glad_glDrawBuffers +typedef void (APIENTRYP PFNGLSTENCILOPSEPARATEPROC)(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass); +GLAPI PFNGLSTENCILOPSEPARATEPROC glad_glStencilOpSeparate; +#define glStencilOpSeparate glad_glStencilOpSeparate +typedef void (APIENTRYP PFNGLSTENCILFUNCSEPARATEPROC)(GLenum face, GLenum func, GLint ref, GLuint mask); +GLAPI PFNGLSTENCILFUNCSEPARATEPROC glad_glStencilFuncSeparate; +#define glStencilFuncSeparate glad_glStencilFuncSeparate +typedef void (APIENTRYP PFNGLSTENCILMASKSEPARATEPROC)(GLenum face, GLuint mask); +GLAPI PFNGLSTENCILMASKSEPARATEPROC glad_glStencilMaskSeparate; +#define glStencilMaskSeparate glad_glStencilMaskSeparate +typedef void (APIENTRYP PFNGLATTACHSHADERPROC)(GLuint program, GLuint shader); +GLAPI PFNGLATTACHSHADERPROC glad_glAttachShader; +#define glAttachShader glad_glAttachShader +typedef void (APIENTRYP PFNGLBINDATTRIBLOCATIONPROC)(GLuint program, GLuint index, const GLchar *name); +GLAPI PFNGLBINDATTRIBLOCATIONPROC glad_glBindAttribLocation; +#define glBindAttribLocation glad_glBindAttribLocation +typedef void (APIENTRYP PFNGLCOMPILESHADERPROC)(GLuint shader); +GLAPI PFNGLCOMPILESHADERPROC glad_glCompileShader; +#define glCompileShader glad_glCompileShader +typedef GLuint (APIENTRYP PFNGLCREATEPROGRAMPROC)(void); +GLAPI PFNGLCREATEPROGRAMPROC glad_glCreateProgram; +#define glCreateProgram glad_glCreateProgram +typedef GLuint (APIENTRYP PFNGLCREATESHADERPROC)(GLenum type); +GLAPI PFNGLCREATESHADERPROC glad_glCreateShader; +#define glCreateShader glad_glCreateShader +typedef void (APIENTRYP PFNGLDELETEPROGRAMPROC)(GLuint program); +GLAPI PFNGLDELETEPROGRAMPROC glad_glDeleteProgram; +#define glDeleteProgram glad_glDeleteProgram +typedef void (APIENTRYP PFNGLDELETESHADERPROC)(GLuint shader); +GLAPI PFNGLDELETESHADERPROC glad_glDeleteShader; +#define glDeleteShader glad_glDeleteShader +typedef void (APIENTRYP PFNGLDETACHSHADERPROC)(GLuint program, GLuint shader); +GLAPI PFNGLDETACHSHADERPROC glad_glDetachShader; +#define glDetachShader glad_glDetachShader +typedef void (APIENTRYP PFNGLDISABLEVERTEXATTRIBARRAYPROC)(GLuint index); +GLAPI PFNGLDISABLEVERTEXATTRIBARRAYPROC glad_glDisableVertexAttribArray; +#define glDisableVertexAttribArray glad_glDisableVertexAttribArray +typedef void (APIENTRYP PFNGLENABLEVERTEXATTRIBARRAYPROC)(GLuint index); +GLAPI PFNGLENABLEVERTEXATTRIBARRAYPROC glad_glEnableVertexAttribArray; +#define glEnableVertexAttribArray glad_glEnableVertexAttribArray +typedef void (APIENTRYP PFNGLGETACTIVEATTRIBPROC)(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name); +GLAPI PFNGLGETACTIVEATTRIBPROC glad_glGetActiveAttrib; +#define glGetActiveAttrib glad_glGetActiveAttrib +typedef void (APIENTRYP PFNGLGETACTIVEUNIFORMPROC)(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name); +GLAPI PFNGLGETACTIVEUNIFORMPROC glad_glGetActiveUniform; +#define glGetActiveUniform glad_glGetActiveUniform +typedef void (APIENTRYP PFNGLGETATTACHEDSHADERSPROC)(GLuint program, GLsizei maxCount, GLsizei *count, GLuint *shaders); +GLAPI PFNGLGETATTACHEDSHADERSPROC glad_glGetAttachedShaders; +#define glGetAttachedShaders glad_glGetAttachedShaders +typedef GLint (APIENTRYP PFNGLGETATTRIBLOCATIONPROC)(GLuint program, const GLchar *name); +GLAPI PFNGLGETATTRIBLOCATIONPROC glad_glGetAttribLocation; +#define glGetAttribLocation glad_glGetAttribLocation +typedef void (APIENTRYP PFNGLGETPROGRAMIVPROC)(GLuint program, GLenum pname, GLint *params); +GLAPI PFNGLGETPROGRAMIVPROC glad_glGetProgramiv; +#define glGetProgramiv glad_glGetProgramiv +typedef void (APIENTRYP PFNGLGETPROGRAMINFOLOGPROC)(GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog); +GLAPI PFNGLGETPROGRAMINFOLOGPROC glad_glGetProgramInfoLog; +#define glGetProgramInfoLog glad_glGetProgramInfoLog +typedef void (APIENTRYP PFNGLGETSHADERIVPROC)(GLuint shader, GLenum pname, GLint *params); +GLAPI PFNGLGETSHADERIVPROC glad_glGetShaderiv; +#define glGetShaderiv glad_glGetShaderiv +typedef void (APIENTRYP PFNGLGETSHADERINFOLOGPROC)(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog); +GLAPI PFNGLGETSHADERINFOLOGPROC glad_glGetShaderInfoLog; +#define glGetShaderInfoLog glad_glGetShaderInfoLog +typedef void (APIENTRYP PFNGLGETSHADERSOURCEPROC)(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *source); +GLAPI PFNGLGETSHADERSOURCEPROC glad_glGetShaderSource; +#define glGetShaderSource glad_glGetShaderSource +typedef GLint (APIENTRYP PFNGLGETUNIFORMLOCATIONPROC)(GLuint program, const GLchar *name); +GLAPI PFNGLGETUNIFORMLOCATIONPROC glad_glGetUniformLocation; +#define glGetUniformLocation glad_glGetUniformLocation +typedef void (APIENTRYP PFNGLGETUNIFORMFVPROC)(GLuint program, GLint location, GLfloat *params); +GLAPI PFNGLGETUNIFORMFVPROC glad_glGetUniformfv; +#define glGetUniformfv glad_glGetUniformfv +typedef void (APIENTRYP PFNGLGETUNIFORMIVPROC)(GLuint program, GLint location, GLint *params); +GLAPI PFNGLGETUNIFORMIVPROC glad_glGetUniformiv; +#define glGetUniformiv glad_glGetUniformiv +typedef void (APIENTRYP PFNGLGETVERTEXATTRIBDVPROC)(GLuint index, GLenum pname, GLdouble *params); +GLAPI PFNGLGETVERTEXATTRIBDVPROC glad_glGetVertexAttribdv; +#define glGetVertexAttribdv glad_glGetVertexAttribdv +typedef void (APIENTRYP PFNGLGETVERTEXATTRIBFVPROC)(GLuint index, GLenum pname, GLfloat *params); +GLAPI PFNGLGETVERTEXATTRIBFVPROC glad_glGetVertexAttribfv; +#define glGetVertexAttribfv glad_glGetVertexAttribfv +typedef void (APIENTRYP PFNGLGETVERTEXATTRIBIVPROC)(GLuint index, GLenum pname, GLint *params); +GLAPI PFNGLGETVERTEXATTRIBIVPROC glad_glGetVertexAttribiv; +#define glGetVertexAttribiv glad_glGetVertexAttribiv +typedef void (APIENTRYP PFNGLGETVERTEXATTRIBPOINTERVPROC)(GLuint index, GLenum pname, void **pointer); +GLAPI PFNGLGETVERTEXATTRIBPOINTERVPROC glad_glGetVertexAttribPointerv; +#define glGetVertexAttribPointerv glad_glGetVertexAttribPointerv +typedef GLboolean (APIENTRYP PFNGLISPROGRAMPROC)(GLuint program); +GLAPI PFNGLISPROGRAMPROC glad_glIsProgram; +#define glIsProgram glad_glIsProgram +typedef GLboolean (APIENTRYP PFNGLISSHADERPROC)(GLuint shader); +GLAPI PFNGLISSHADERPROC glad_glIsShader; +#define glIsShader glad_glIsShader +typedef void (APIENTRYP PFNGLLINKPROGRAMPROC)(GLuint program); +GLAPI PFNGLLINKPROGRAMPROC glad_glLinkProgram; +#define glLinkProgram glad_glLinkProgram +typedef void (APIENTRYP PFNGLSHADERSOURCEPROC)(GLuint shader, GLsizei count, const GLchar *const*string, const GLint *length); +GLAPI PFNGLSHADERSOURCEPROC glad_glShaderSource; +#define glShaderSource glad_glShaderSource +typedef void (APIENTRYP PFNGLUSEPROGRAMPROC)(GLuint program); +GLAPI PFNGLUSEPROGRAMPROC glad_glUseProgram; +#define glUseProgram glad_glUseProgram +typedef void (APIENTRYP PFNGLUNIFORM1FPROC)(GLint location, GLfloat v0); +GLAPI PFNGLUNIFORM1FPROC glad_glUniform1f; +#define glUniform1f glad_glUniform1f +typedef void (APIENTRYP PFNGLUNIFORM2FPROC)(GLint location, GLfloat v0, GLfloat v1); +GLAPI PFNGLUNIFORM2FPROC glad_glUniform2f; +#define glUniform2f glad_glUniform2f +typedef void (APIENTRYP PFNGLUNIFORM3FPROC)(GLint location, GLfloat v0, GLfloat v1, GLfloat v2); +GLAPI PFNGLUNIFORM3FPROC glad_glUniform3f; +#define glUniform3f glad_glUniform3f +typedef void (APIENTRYP PFNGLUNIFORM4FPROC)(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3); +GLAPI PFNGLUNIFORM4FPROC glad_glUniform4f; +#define glUniform4f glad_glUniform4f +typedef void (APIENTRYP PFNGLUNIFORM1IPROC)(GLint location, GLint v0); +GLAPI PFNGLUNIFORM1IPROC glad_glUniform1i; +#define glUniform1i glad_glUniform1i +typedef void (APIENTRYP PFNGLUNIFORM2IPROC)(GLint location, GLint v0, GLint v1); +GLAPI PFNGLUNIFORM2IPROC glad_glUniform2i; +#define glUniform2i glad_glUniform2i +typedef void (APIENTRYP PFNGLUNIFORM3IPROC)(GLint location, GLint v0, GLint v1, GLint v2); +GLAPI PFNGLUNIFORM3IPROC glad_glUniform3i; +#define glUniform3i glad_glUniform3i +typedef void (APIENTRYP PFNGLUNIFORM4IPROC)(GLint location, GLint v0, GLint v1, GLint v2, GLint v3); +GLAPI PFNGLUNIFORM4IPROC glad_glUniform4i; +#define glUniform4i glad_glUniform4i +typedef void (APIENTRYP PFNGLUNIFORM1FVPROC)(GLint location, GLsizei count, const GLfloat *value); +GLAPI PFNGLUNIFORM1FVPROC glad_glUniform1fv; +#define glUniform1fv glad_glUniform1fv +typedef void (APIENTRYP PFNGLUNIFORM2FVPROC)(GLint location, GLsizei count, const GLfloat *value); +GLAPI PFNGLUNIFORM2FVPROC glad_glUniform2fv; +#define glUniform2fv glad_glUniform2fv +typedef void (APIENTRYP PFNGLUNIFORM3FVPROC)(GLint location, GLsizei count, const GLfloat *value); +GLAPI PFNGLUNIFORM3FVPROC glad_glUniform3fv; +#define glUniform3fv glad_glUniform3fv +typedef void (APIENTRYP PFNGLUNIFORM4FVPROC)(GLint location, GLsizei count, const GLfloat *value); +GLAPI PFNGLUNIFORM4FVPROC glad_glUniform4fv; +#define glUniform4fv glad_glUniform4fv +typedef void (APIENTRYP PFNGLUNIFORM1IVPROC)(GLint location, GLsizei count, const GLint *value); +GLAPI PFNGLUNIFORM1IVPROC glad_glUniform1iv; +#define glUniform1iv glad_glUniform1iv +typedef void (APIENTRYP PFNGLUNIFORM2IVPROC)(GLint location, GLsizei count, const GLint *value); +GLAPI PFNGLUNIFORM2IVPROC glad_glUniform2iv; +#define glUniform2iv glad_glUniform2iv +typedef void (APIENTRYP PFNGLUNIFORM3IVPROC)(GLint location, GLsizei count, const GLint *value); +GLAPI PFNGLUNIFORM3IVPROC glad_glUniform3iv; +#define glUniform3iv glad_glUniform3iv +typedef void (APIENTRYP PFNGLUNIFORM4IVPROC)(GLint location, GLsizei count, const GLint *value); +GLAPI PFNGLUNIFORM4IVPROC glad_glUniform4iv; +#define glUniform4iv glad_glUniform4iv +typedef void (APIENTRYP PFNGLUNIFORMMATRIX2FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +GLAPI PFNGLUNIFORMMATRIX2FVPROC glad_glUniformMatrix2fv; +#define glUniformMatrix2fv glad_glUniformMatrix2fv +typedef void (APIENTRYP PFNGLUNIFORMMATRIX3FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +GLAPI PFNGLUNIFORMMATRIX3FVPROC glad_glUniformMatrix3fv; +#define glUniformMatrix3fv glad_glUniformMatrix3fv +typedef void (APIENTRYP PFNGLUNIFORMMATRIX4FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +GLAPI PFNGLUNIFORMMATRIX4FVPROC glad_glUniformMatrix4fv; +#define glUniformMatrix4fv glad_glUniformMatrix4fv +typedef void (APIENTRYP PFNGLVALIDATEPROGRAMPROC)(GLuint program); +GLAPI PFNGLVALIDATEPROGRAMPROC glad_glValidateProgram; +#define glValidateProgram glad_glValidateProgram +typedef void (APIENTRYP PFNGLVERTEXATTRIB1DPROC)(GLuint index, GLdouble x); +GLAPI PFNGLVERTEXATTRIB1DPROC glad_glVertexAttrib1d; +#define glVertexAttrib1d glad_glVertexAttrib1d +typedef void (APIENTRYP PFNGLVERTEXATTRIB1DVPROC)(GLuint index, const GLdouble *v); +GLAPI PFNGLVERTEXATTRIB1DVPROC glad_glVertexAttrib1dv; +#define glVertexAttrib1dv glad_glVertexAttrib1dv +typedef void (APIENTRYP PFNGLVERTEXATTRIB1FPROC)(GLuint index, GLfloat x); +GLAPI PFNGLVERTEXATTRIB1FPROC glad_glVertexAttrib1f; +#define glVertexAttrib1f glad_glVertexAttrib1f +typedef void (APIENTRYP PFNGLVERTEXATTRIB1FVPROC)(GLuint index, const GLfloat *v); +GLAPI PFNGLVERTEXATTRIB1FVPROC glad_glVertexAttrib1fv; +#define glVertexAttrib1fv glad_glVertexAttrib1fv +typedef void (APIENTRYP PFNGLVERTEXATTRIB1SPROC)(GLuint index, GLshort x); +GLAPI PFNGLVERTEXATTRIB1SPROC glad_glVertexAttrib1s; +#define glVertexAttrib1s glad_glVertexAttrib1s +typedef void (APIENTRYP PFNGLVERTEXATTRIB1SVPROC)(GLuint index, const GLshort *v); +GLAPI PFNGLVERTEXATTRIB1SVPROC glad_glVertexAttrib1sv; +#define glVertexAttrib1sv glad_glVertexAttrib1sv +typedef void (APIENTRYP PFNGLVERTEXATTRIB2DPROC)(GLuint index, GLdouble x, GLdouble y); +GLAPI PFNGLVERTEXATTRIB2DPROC glad_glVertexAttrib2d; +#define glVertexAttrib2d glad_glVertexAttrib2d +typedef void (APIENTRYP PFNGLVERTEXATTRIB2DVPROC)(GLuint index, const GLdouble *v); +GLAPI PFNGLVERTEXATTRIB2DVPROC glad_glVertexAttrib2dv; +#define glVertexAttrib2dv glad_glVertexAttrib2dv +typedef void (APIENTRYP PFNGLVERTEXATTRIB2FPROC)(GLuint index, GLfloat x, GLfloat y); +GLAPI PFNGLVERTEXATTRIB2FPROC glad_glVertexAttrib2f; +#define glVertexAttrib2f glad_glVertexAttrib2f +typedef void (APIENTRYP PFNGLVERTEXATTRIB2FVPROC)(GLuint index, const GLfloat *v); +GLAPI PFNGLVERTEXATTRIB2FVPROC glad_glVertexAttrib2fv; +#define glVertexAttrib2fv glad_glVertexAttrib2fv +typedef void (APIENTRYP PFNGLVERTEXATTRIB2SPROC)(GLuint index, GLshort x, GLshort y); +GLAPI PFNGLVERTEXATTRIB2SPROC glad_glVertexAttrib2s; +#define glVertexAttrib2s glad_glVertexAttrib2s +typedef void (APIENTRYP PFNGLVERTEXATTRIB2SVPROC)(GLuint index, const GLshort *v); +GLAPI PFNGLVERTEXATTRIB2SVPROC glad_glVertexAttrib2sv; +#define glVertexAttrib2sv glad_glVertexAttrib2sv +typedef void (APIENTRYP PFNGLVERTEXATTRIB3DPROC)(GLuint index, GLdouble x, GLdouble y, GLdouble z); +GLAPI PFNGLVERTEXATTRIB3DPROC glad_glVertexAttrib3d; +#define glVertexAttrib3d glad_glVertexAttrib3d +typedef void (APIENTRYP PFNGLVERTEXATTRIB3DVPROC)(GLuint index, const GLdouble *v); +GLAPI PFNGLVERTEXATTRIB3DVPROC glad_glVertexAttrib3dv; +#define glVertexAttrib3dv glad_glVertexAttrib3dv +typedef void (APIENTRYP PFNGLVERTEXATTRIB3FPROC)(GLuint index, GLfloat x, GLfloat y, GLfloat z); +GLAPI PFNGLVERTEXATTRIB3FPROC glad_glVertexAttrib3f; +#define glVertexAttrib3f glad_glVertexAttrib3f +typedef void (APIENTRYP PFNGLVERTEXATTRIB3FVPROC)(GLuint index, const GLfloat *v); +GLAPI PFNGLVERTEXATTRIB3FVPROC glad_glVertexAttrib3fv; +#define glVertexAttrib3fv glad_glVertexAttrib3fv +typedef void (APIENTRYP PFNGLVERTEXATTRIB3SPROC)(GLuint index, GLshort x, GLshort y, GLshort z); +GLAPI PFNGLVERTEXATTRIB3SPROC glad_glVertexAttrib3s; +#define glVertexAttrib3s glad_glVertexAttrib3s +typedef void (APIENTRYP PFNGLVERTEXATTRIB3SVPROC)(GLuint index, const GLshort *v); +GLAPI PFNGLVERTEXATTRIB3SVPROC glad_glVertexAttrib3sv; +#define glVertexAttrib3sv glad_glVertexAttrib3sv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4NBVPROC)(GLuint index, const GLbyte *v); +GLAPI PFNGLVERTEXATTRIB4NBVPROC glad_glVertexAttrib4Nbv; +#define glVertexAttrib4Nbv glad_glVertexAttrib4Nbv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4NIVPROC)(GLuint index, const GLint *v); +GLAPI PFNGLVERTEXATTRIB4NIVPROC glad_glVertexAttrib4Niv; +#define glVertexAttrib4Niv glad_glVertexAttrib4Niv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4NSVPROC)(GLuint index, const GLshort *v); +GLAPI PFNGLVERTEXATTRIB4NSVPROC glad_glVertexAttrib4Nsv; +#define glVertexAttrib4Nsv glad_glVertexAttrib4Nsv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4NUBPROC)(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w); +GLAPI PFNGLVERTEXATTRIB4NUBPROC glad_glVertexAttrib4Nub; +#define glVertexAttrib4Nub glad_glVertexAttrib4Nub +typedef void (APIENTRYP PFNGLVERTEXATTRIB4NUBVPROC)(GLuint index, const GLubyte *v); +GLAPI PFNGLVERTEXATTRIB4NUBVPROC glad_glVertexAttrib4Nubv; +#define glVertexAttrib4Nubv glad_glVertexAttrib4Nubv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4NUIVPROC)(GLuint index, const GLuint *v); +GLAPI PFNGLVERTEXATTRIB4NUIVPROC glad_glVertexAttrib4Nuiv; +#define glVertexAttrib4Nuiv glad_glVertexAttrib4Nuiv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4NUSVPROC)(GLuint index, const GLushort *v); +GLAPI PFNGLVERTEXATTRIB4NUSVPROC glad_glVertexAttrib4Nusv; +#define glVertexAttrib4Nusv glad_glVertexAttrib4Nusv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4BVPROC)(GLuint index, const GLbyte *v); +GLAPI PFNGLVERTEXATTRIB4BVPROC glad_glVertexAttrib4bv; +#define glVertexAttrib4bv glad_glVertexAttrib4bv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4DPROC)(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w); +GLAPI PFNGLVERTEXATTRIB4DPROC glad_glVertexAttrib4d; +#define glVertexAttrib4d glad_glVertexAttrib4d +typedef void (APIENTRYP PFNGLVERTEXATTRIB4DVPROC)(GLuint index, const GLdouble *v); +GLAPI PFNGLVERTEXATTRIB4DVPROC glad_glVertexAttrib4dv; +#define glVertexAttrib4dv glad_glVertexAttrib4dv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4FPROC)(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w); +GLAPI PFNGLVERTEXATTRIB4FPROC glad_glVertexAttrib4f; +#define glVertexAttrib4f glad_glVertexAttrib4f +typedef void (APIENTRYP PFNGLVERTEXATTRIB4FVPROC)(GLuint index, const GLfloat *v); +GLAPI PFNGLVERTEXATTRIB4FVPROC glad_glVertexAttrib4fv; +#define glVertexAttrib4fv glad_glVertexAttrib4fv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4IVPROC)(GLuint index, const GLint *v); +GLAPI PFNGLVERTEXATTRIB4IVPROC glad_glVertexAttrib4iv; +#define glVertexAttrib4iv glad_glVertexAttrib4iv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4SPROC)(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w); +GLAPI PFNGLVERTEXATTRIB4SPROC glad_glVertexAttrib4s; +#define glVertexAttrib4s glad_glVertexAttrib4s +typedef void (APIENTRYP PFNGLVERTEXATTRIB4SVPROC)(GLuint index, const GLshort *v); +GLAPI PFNGLVERTEXATTRIB4SVPROC glad_glVertexAttrib4sv; +#define glVertexAttrib4sv glad_glVertexAttrib4sv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4UBVPROC)(GLuint index, const GLubyte *v); +GLAPI PFNGLVERTEXATTRIB4UBVPROC glad_glVertexAttrib4ubv; +#define glVertexAttrib4ubv glad_glVertexAttrib4ubv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4UIVPROC)(GLuint index, const GLuint *v); +GLAPI PFNGLVERTEXATTRIB4UIVPROC glad_glVertexAttrib4uiv; +#define glVertexAttrib4uiv glad_glVertexAttrib4uiv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4USVPROC)(GLuint index, const GLushort *v); +GLAPI PFNGLVERTEXATTRIB4USVPROC glad_glVertexAttrib4usv; +#define glVertexAttrib4usv glad_glVertexAttrib4usv +typedef void (APIENTRYP PFNGLVERTEXATTRIBPOINTERPROC)(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void *pointer); +GLAPI PFNGLVERTEXATTRIBPOINTERPROC glad_glVertexAttribPointer; +#define glVertexAttribPointer glad_glVertexAttribPointer +#endif +#ifndef GL_VERSION_2_1 +#define GL_VERSION_2_1 1 +GLAPI int GLAD_GL_VERSION_2_1; +typedef void (APIENTRYP PFNGLUNIFORMMATRIX2X3FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +GLAPI PFNGLUNIFORMMATRIX2X3FVPROC glad_glUniformMatrix2x3fv; +#define glUniformMatrix2x3fv glad_glUniformMatrix2x3fv +typedef void (APIENTRYP PFNGLUNIFORMMATRIX3X2FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +GLAPI PFNGLUNIFORMMATRIX3X2FVPROC glad_glUniformMatrix3x2fv; +#define glUniformMatrix3x2fv glad_glUniformMatrix3x2fv +typedef void (APIENTRYP PFNGLUNIFORMMATRIX2X4FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +GLAPI PFNGLUNIFORMMATRIX2X4FVPROC glad_glUniformMatrix2x4fv; +#define glUniformMatrix2x4fv glad_glUniformMatrix2x4fv +typedef void (APIENTRYP PFNGLUNIFORMMATRIX4X2FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +GLAPI PFNGLUNIFORMMATRIX4X2FVPROC glad_glUniformMatrix4x2fv; +#define glUniformMatrix4x2fv glad_glUniformMatrix4x2fv +typedef void (APIENTRYP PFNGLUNIFORMMATRIX3X4FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +GLAPI PFNGLUNIFORMMATRIX3X4FVPROC glad_glUniformMatrix3x4fv; +#define glUniformMatrix3x4fv glad_glUniformMatrix3x4fv +typedef void (APIENTRYP PFNGLUNIFORMMATRIX4X3FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +GLAPI PFNGLUNIFORMMATRIX4X3FVPROC glad_glUniformMatrix4x3fv; +#define glUniformMatrix4x3fv glad_glUniformMatrix4x3fv +#endif +#ifndef GL_VERSION_3_0 +#define GL_VERSION_3_0 1 +GLAPI int GLAD_GL_VERSION_3_0; +typedef void (APIENTRYP PFNGLCOLORMASKIPROC)(GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a); +GLAPI PFNGLCOLORMASKIPROC glad_glColorMaski; +#define glColorMaski glad_glColorMaski +typedef void (APIENTRYP PFNGLGETBOOLEANI_VPROC)(GLenum target, GLuint index, GLboolean *data); +GLAPI PFNGLGETBOOLEANI_VPROC glad_glGetBooleani_v; +#define glGetBooleani_v glad_glGetBooleani_v +typedef void (APIENTRYP PFNGLGETINTEGERI_VPROC)(GLenum target, GLuint index, GLint *data); +GLAPI PFNGLGETINTEGERI_VPROC glad_glGetIntegeri_v; +#define glGetIntegeri_v glad_glGetIntegeri_v +typedef void (APIENTRYP PFNGLENABLEIPROC)(GLenum target, GLuint index); +GLAPI PFNGLENABLEIPROC glad_glEnablei; +#define glEnablei glad_glEnablei +typedef void (APIENTRYP PFNGLDISABLEIPROC)(GLenum target, GLuint index); +GLAPI PFNGLDISABLEIPROC glad_glDisablei; +#define glDisablei glad_glDisablei +typedef GLboolean (APIENTRYP PFNGLISENABLEDIPROC)(GLenum target, GLuint index); +GLAPI PFNGLISENABLEDIPROC glad_glIsEnabledi; +#define glIsEnabledi glad_glIsEnabledi +typedef void (APIENTRYP PFNGLBEGINTRANSFORMFEEDBACKPROC)(GLenum primitiveMode); +GLAPI PFNGLBEGINTRANSFORMFEEDBACKPROC glad_glBeginTransformFeedback; +#define glBeginTransformFeedback glad_glBeginTransformFeedback +typedef void (APIENTRYP PFNGLENDTRANSFORMFEEDBACKPROC)(void); +GLAPI PFNGLENDTRANSFORMFEEDBACKPROC glad_glEndTransformFeedback; +#define glEndTransformFeedback glad_glEndTransformFeedback +typedef void (APIENTRYP PFNGLBINDBUFFERRANGEPROC)(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size); +GLAPI PFNGLBINDBUFFERRANGEPROC glad_glBindBufferRange; +#define glBindBufferRange glad_glBindBufferRange +typedef void (APIENTRYP PFNGLBINDBUFFERBASEPROC)(GLenum target, GLuint index, GLuint buffer); +GLAPI PFNGLBINDBUFFERBASEPROC glad_glBindBufferBase; +#define glBindBufferBase glad_glBindBufferBase +typedef void (APIENTRYP PFNGLTRANSFORMFEEDBACKVARYINGSPROC)(GLuint program, GLsizei count, const GLchar *const*varyings, GLenum bufferMode); +GLAPI PFNGLTRANSFORMFEEDBACKVARYINGSPROC glad_glTransformFeedbackVaryings; +#define glTransformFeedbackVaryings glad_glTransformFeedbackVaryings +typedef void (APIENTRYP PFNGLGETTRANSFORMFEEDBACKVARYINGPROC)(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name); +GLAPI PFNGLGETTRANSFORMFEEDBACKVARYINGPROC glad_glGetTransformFeedbackVarying; +#define glGetTransformFeedbackVarying glad_glGetTransformFeedbackVarying +typedef void (APIENTRYP PFNGLCLAMPCOLORPROC)(GLenum target, GLenum clamp); +GLAPI PFNGLCLAMPCOLORPROC glad_glClampColor; +#define glClampColor glad_glClampColor +typedef void (APIENTRYP PFNGLBEGINCONDITIONALRENDERPROC)(GLuint id, GLenum mode); +GLAPI PFNGLBEGINCONDITIONALRENDERPROC glad_glBeginConditionalRender; +#define glBeginConditionalRender glad_glBeginConditionalRender +typedef void (APIENTRYP PFNGLENDCONDITIONALRENDERPROC)(void); +GLAPI PFNGLENDCONDITIONALRENDERPROC glad_glEndConditionalRender; +#define glEndConditionalRender glad_glEndConditionalRender +typedef void (APIENTRYP PFNGLVERTEXATTRIBIPOINTERPROC)(GLuint index, GLint size, GLenum type, GLsizei stride, const void *pointer); +GLAPI PFNGLVERTEXATTRIBIPOINTERPROC glad_glVertexAttribIPointer; +#define glVertexAttribIPointer glad_glVertexAttribIPointer +typedef void (APIENTRYP PFNGLGETVERTEXATTRIBIIVPROC)(GLuint index, GLenum pname, GLint *params); +GLAPI PFNGLGETVERTEXATTRIBIIVPROC glad_glGetVertexAttribIiv; +#define glGetVertexAttribIiv glad_glGetVertexAttribIiv +typedef void (APIENTRYP PFNGLGETVERTEXATTRIBIUIVPROC)(GLuint index, GLenum pname, GLuint *params); +GLAPI PFNGLGETVERTEXATTRIBIUIVPROC glad_glGetVertexAttribIuiv; +#define glGetVertexAttribIuiv glad_glGetVertexAttribIuiv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI1IPROC)(GLuint index, GLint x); +GLAPI PFNGLVERTEXATTRIBI1IPROC glad_glVertexAttribI1i; +#define glVertexAttribI1i glad_glVertexAttribI1i +typedef void (APIENTRYP PFNGLVERTEXATTRIBI2IPROC)(GLuint index, GLint x, GLint y); +GLAPI PFNGLVERTEXATTRIBI2IPROC glad_glVertexAttribI2i; +#define glVertexAttribI2i glad_glVertexAttribI2i +typedef void (APIENTRYP PFNGLVERTEXATTRIBI3IPROC)(GLuint index, GLint x, GLint y, GLint z); +GLAPI PFNGLVERTEXATTRIBI3IPROC glad_glVertexAttribI3i; +#define glVertexAttribI3i glad_glVertexAttribI3i +typedef void (APIENTRYP PFNGLVERTEXATTRIBI4IPROC)(GLuint index, GLint x, GLint y, GLint z, GLint w); +GLAPI PFNGLVERTEXATTRIBI4IPROC glad_glVertexAttribI4i; +#define glVertexAttribI4i glad_glVertexAttribI4i +typedef void (APIENTRYP PFNGLVERTEXATTRIBI1UIPROC)(GLuint index, GLuint x); +GLAPI PFNGLVERTEXATTRIBI1UIPROC glad_glVertexAttribI1ui; +#define glVertexAttribI1ui glad_glVertexAttribI1ui +typedef void (APIENTRYP PFNGLVERTEXATTRIBI2UIPROC)(GLuint index, GLuint x, GLuint y); +GLAPI PFNGLVERTEXATTRIBI2UIPROC glad_glVertexAttribI2ui; +#define glVertexAttribI2ui glad_glVertexAttribI2ui +typedef void (APIENTRYP PFNGLVERTEXATTRIBI3UIPROC)(GLuint index, GLuint x, GLuint y, GLuint z); +GLAPI PFNGLVERTEXATTRIBI3UIPROC glad_glVertexAttribI3ui; +#define glVertexAttribI3ui glad_glVertexAttribI3ui +typedef void (APIENTRYP PFNGLVERTEXATTRIBI4UIPROC)(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w); +GLAPI PFNGLVERTEXATTRIBI4UIPROC glad_glVertexAttribI4ui; +#define glVertexAttribI4ui glad_glVertexAttribI4ui +typedef void (APIENTRYP PFNGLVERTEXATTRIBI1IVPROC)(GLuint index, const GLint *v); +GLAPI PFNGLVERTEXATTRIBI1IVPROC glad_glVertexAttribI1iv; +#define glVertexAttribI1iv glad_glVertexAttribI1iv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI2IVPROC)(GLuint index, const GLint *v); +GLAPI PFNGLVERTEXATTRIBI2IVPROC glad_glVertexAttribI2iv; +#define glVertexAttribI2iv glad_glVertexAttribI2iv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI3IVPROC)(GLuint index, const GLint *v); +GLAPI PFNGLVERTEXATTRIBI3IVPROC glad_glVertexAttribI3iv; +#define glVertexAttribI3iv glad_glVertexAttribI3iv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI4IVPROC)(GLuint index, const GLint *v); +GLAPI PFNGLVERTEXATTRIBI4IVPROC glad_glVertexAttribI4iv; +#define glVertexAttribI4iv glad_glVertexAttribI4iv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI1UIVPROC)(GLuint index, const GLuint *v); +GLAPI PFNGLVERTEXATTRIBI1UIVPROC glad_glVertexAttribI1uiv; +#define glVertexAttribI1uiv glad_glVertexAttribI1uiv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI2UIVPROC)(GLuint index, const GLuint *v); +GLAPI PFNGLVERTEXATTRIBI2UIVPROC glad_glVertexAttribI2uiv; +#define glVertexAttribI2uiv glad_glVertexAttribI2uiv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI3UIVPROC)(GLuint index, const GLuint *v); +GLAPI PFNGLVERTEXATTRIBI3UIVPROC glad_glVertexAttribI3uiv; +#define glVertexAttribI3uiv glad_glVertexAttribI3uiv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI4UIVPROC)(GLuint index, const GLuint *v); +GLAPI PFNGLVERTEXATTRIBI4UIVPROC glad_glVertexAttribI4uiv; +#define glVertexAttribI4uiv glad_glVertexAttribI4uiv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI4BVPROC)(GLuint index, const GLbyte *v); +GLAPI PFNGLVERTEXATTRIBI4BVPROC glad_glVertexAttribI4bv; +#define glVertexAttribI4bv glad_glVertexAttribI4bv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI4SVPROC)(GLuint index, const GLshort *v); +GLAPI PFNGLVERTEXATTRIBI4SVPROC glad_glVertexAttribI4sv; +#define glVertexAttribI4sv glad_glVertexAttribI4sv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI4UBVPROC)(GLuint index, const GLubyte *v); +GLAPI PFNGLVERTEXATTRIBI4UBVPROC glad_glVertexAttribI4ubv; +#define glVertexAttribI4ubv glad_glVertexAttribI4ubv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI4USVPROC)(GLuint index, const GLushort *v); +GLAPI PFNGLVERTEXATTRIBI4USVPROC glad_glVertexAttribI4usv; +#define glVertexAttribI4usv glad_glVertexAttribI4usv +typedef void (APIENTRYP PFNGLGETUNIFORMUIVPROC)(GLuint program, GLint location, GLuint *params); +GLAPI PFNGLGETUNIFORMUIVPROC glad_glGetUniformuiv; +#define glGetUniformuiv glad_glGetUniformuiv +typedef void (APIENTRYP PFNGLBINDFRAGDATALOCATIONPROC)(GLuint program, GLuint color, const GLchar *name); +GLAPI PFNGLBINDFRAGDATALOCATIONPROC glad_glBindFragDataLocation; +#define glBindFragDataLocation glad_glBindFragDataLocation +typedef GLint (APIENTRYP PFNGLGETFRAGDATALOCATIONPROC)(GLuint program, const GLchar *name); +GLAPI PFNGLGETFRAGDATALOCATIONPROC glad_glGetFragDataLocation; +#define glGetFragDataLocation glad_glGetFragDataLocation +typedef void (APIENTRYP PFNGLUNIFORM1UIPROC)(GLint location, GLuint v0); +GLAPI PFNGLUNIFORM1UIPROC glad_glUniform1ui; +#define glUniform1ui glad_glUniform1ui +typedef void (APIENTRYP PFNGLUNIFORM2UIPROC)(GLint location, GLuint v0, GLuint v1); +GLAPI PFNGLUNIFORM2UIPROC glad_glUniform2ui; +#define glUniform2ui glad_glUniform2ui +typedef void (APIENTRYP PFNGLUNIFORM3UIPROC)(GLint location, GLuint v0, GLuint v1, GLuint v2); +GLAPI PFNGLUNIFORM3UIPROC glad_glUniform3ui; +#define glUniform3ui glad_glUniform3ui +typedef void (APIENTRYP PFNGLUNIFORM4UIPROC)(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3); +GLAPI PFNGLUNIFORM4UIPROC glad_glUniform4ui; +#define glUniform4ui glad_glUniform4ui +typedef void (APIENTRYP PFNGLUNIFORM1UIVPROC)(GLint location, GLsizei count, const GLuint *value); +GLAPI PFNGLUNIFORM1UIVPROC glad_glUniform1uiv; +#define glUniform1uiv glad_glUniform1uiv +typedef void (APIENTRYP PFNGLUNIFORM2UIVPROC)(GLint location, GLsizei count, const GLuint *value); +GLAPI PFNGLUNIFORM2UIVPROC glad_glUniform2uiv; +#define glUniform2uiv glad_glUniform2uiv +typedef void (APIENTRYP PFNGLUNIFORM3UIVPROC)(GLint location, GLsizei count, const GLuint *value); +GLAPI PFNGLUNIFORM3UIVPROC glad_glUniform3uiv; +#define glUniform3uiv glad_glUniform3uiv +typedef void (APIENTRYP PFNGLUNIFORM4UIVPROC)(GLint location, GLsizei count, const GLuint *value); +GLAPI PFNGLUNIFORM4UIVPROC glad_glUniform4uiv; +#define glUniform4uiv glad_glUniform4uiv +typedef void (APIENTRYP PFNGLTEXPARAMETERIIVPROC)(GLenum target, GLenum pname, const GLint *params); +GLAPI PFNGLTEXPARAMETERIIVPROC glad_glTexParameterIiv; +#define glTexParameterIiv glad_glTexParameterIiv +typedef void (APIENTRYP PFNGLTEXPARAMETERIUIVPROC)(GLenum target, GLenum pname, const GLuint *params); +GLAPI PFNGLTEXPARAMETERIUIVPROC glad_glTexParameterIuiv; +#define glTexParameterIuiv glad_glTexParameterIuiv +typedef void (APIENTRYP PFNGLGETTEXPARAMETERIIVPROC)(GLenum target, GLenum pname, GLint *params); +GLAPI PFNGLGETTEXPARAMETERIIVPROC glad_glGetTexParameterIiv; +#define glGetTexParameterIiv glad_glGetTexParameterIiv +typedef void (APIENTRYP PFNGLGETTEXPARAMETERIUIVPROC)(GLenum target, GLenum pname, GLuint *params); +GLAPI PFNGLGETTEXPARAMETERIUIVPROC glad_glGetTexParameterIuiv; +#define glGetTexParameterIuiv glad_glGetTexParameterIuiv +typedef void (APIENTRYP PFNGLCLEARBUFFERIVPROC)(GLenum buffer, GLint drawbuffer, const GLint *value); +GLAPI PFNGLCLEARBUFFERIVPROC glad_glClearBufferiv; +#define glClearBufferiv glad_glClearBufferiv +typedef void (APIENTRYP PFNGLCLEARBUFFERUIVPROC)(GLenum buffer, GLint drawbuffer, const GLuint *value); +GLAPI PFNGLCLEARBUFFERUIVPROC glad_glClearBufferuiv; +#define glClearBufferuiv glad_glClearBufferuiv +typedef void (APIENTRYP PFNGLCLEARBUFFERFVPROC)(GLenum buffer, GLint drawbuffer, const GLfloat *value); +GLAPI PFNGLCLEARBUFFERFVPROC glad_glClearBufferfv; +#define glClearBufferfv glad_glClearBufferfv +typedef void (APIENTRYP PFNGLCLEARBUFFERFIPROC)(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil); +GLAPI PFNGLCLEARBUFFERFIPROC glad_glClearBufferfi; +#define glClearBufferfi glad_glClearBufferfi +typedef const GLubyte * (APIENTRYP PFNGLGETSTRINGIPROC)(GLenum name, GLuint index); +GLAPI PFNGLGETSTRINGIPROC glad_glGetStringi; +#define glGetStringi glad_glGetStringi +typedef GLboolean (APIENTRYP PFNGLISRENDERBUFFERPROC)(GLuint renderbuffer); +GLAPI PFNGLISRENDERBUFFERPROC glad_glIsRenderbuffer; +#define glIsRenderbuffer glad_glIsRenderbuffer +typedef void (APIENTRYP PFNGLBINDRENDERBUFFERPROC)(GLenum target, GLuint renderbuffer); +GLAPI PFNGLBINDRENDERBUFFERPROC glad_glBindRenderbuffer; +#define glBindRenderbuffer glad_glBindRenderbuffer +typedef void (APIENTRYP PFNGLDELETERENDERBUFFERSPROC)(GLsizei n, const GLuint *renderbuffers); +GLAPI PFNGLDELETERENDERBUFFERSPROC glad_glDeleteRenderbuffers; +#define glDeleteRenderbuffers glad_glDeleteRenderbuffers +typedef void (APIENTRYP PFNGLGENRENDERBUFFERSPROC)(GLsizei n, GLuint *renderbuffers); +GLAPI PFNGLGENRENDERBUFFERSPROC glad_glGenRenderbuffers; +#define glGenRenderbuffers glad_glGenRenderbuffers +typedef void (APIENTRYP PFNGLRENDERBUFFERSTORAGEPROC)(GLenum target, GLenum internalformat, GLsizei width, GLsizei height); +GLAPI PFNGLRENDERBUFFERSTORAGEPROC glad_glRenderbufferStorage; +#define glRenderbufferStorage glad_glRenderbufferStorage +typedef void (APIENTRYP PFNGLGETRENDERBUFFERPARAMETERIVPROC)(GLenum target, GLenum pname, GLint *params); +GLAPI PFNGLGETRENDERBUFFERPARAMETERIVPROC glad_glGetRenderbufferParameteriv; +#define glGetRenderbufferParameteriv glad_glGetRenderbufferParameteriv +typedef GLboolean (APIENTRYP PFNGLISFRAMEBUFFERPROC)(GLuint framebuffer); +GLAPI PFNGLISFRAMEBUFFERPROC glad_glIsFramebuffer; +#define glIsFramebuffer glad_glIsFramebuffer +typedef void (APIENTRYP PFNGLBINDFRAMEBUFFERPROC)(GLenum target, GLuint framebuffer); +GLAPI PFNGLBINDFRAMEBUFFERPROC glad_glBindFramebuffer; +#define glBindFramebuffer glad_glBindFramebuffer +typedef void (APIENTRYP PFNGLDELETEFRAMEBUFFERSPROC)(GLsizei n, const GLuint *framebuffers); +GLAPI PFNGLDELETEFRAMEBUFFERSPROC glad_glDeleteFramebuffers; +#define glDeleteFramebuffers glad_glDeleteFramebuffers +typedef void (APIENTRYP PFNGLGENFRAMEBUFFERSPROC)(GLsizei n, GLuint *framebuffers); +GLAPI PFNGLGENFRAMEBUFFERSPROC glad_glGenFramebuffers; +#define glGenFramebuffers glad_glGenFramebuffers +typedef GLenum (APIENTRYP PFNGLCHECKFRAMEBUFFERSTATUSPROC)(GLenum target); +GLAPI PFNGLCHECKFRAMEBUFFERSTATUSPROC glad_glCheckFramebufferStatus; +#define glCheckFramebufferStatus glad_glCheckFramebufferStatus +typedef void (APIENTRYP PFNGLFRAMEBUFFERTEXTURE1DPROC)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level); +GLAPI PFNGLFRAMEBUFFERTEXTURE1DPROC glad_glFramebufferTexture1D; +#define glFramebufferTexture1D glad_glFramebufferTexture1D +typedef void (APIENTRYP PFNGLFRAMEBUFFERTEXTURE2DPROC)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level); +GLAPI PFNGLFRAMEBUFFERTEXTURE2DPROC glad_glFramebufferTexture2D; +#define glFramebufferTexture2D glad_glFramebufferTexture2D +typedef void (APIENTRYP PFNGLFRAMEBUFFERTEXTURE3DPROC)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset); +GLAPI PFNGLFRAMEBUFFERTEXTURE3DPROC glad_glFramebufferTexture3D; +#define glFramebufferTexture3D glad_glFramebufferTexture3D +typedef void (APIENTRYP PFNGLFRAMEBUFFERRENDERBUFFERPROC)(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer); +GLAPI PFNGLFRAMEBUFFERRENDERBUFFERPROC glad_glFramebufferRenderbuffer; +#define glFramebufferRenderbuffer glad_glFramebufferRenderbuffer +typedef void (APIENTRYP PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC)(GLenum target, GLenum attachment, GLenum pname, GLint *params); +GLAPI PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC glad_glGetFramebufferAttachmentParameteriv; +#define glGetFramebufferAttachmentParameteriv glad_glGetFramebufferAttachmentParameteriv +typedef void (APIENTRYP PFNGLGENERATEMIPMAPPROC)(GLenum target); +GLAPI PFNGLGENERATEMIPMAPPROC glad_glGenerateMipmap; +#define glGenerateMipmap glad_glGenerateMipmap +typedef void (APIENTRYP PFNGLBLITFRAMEBUFFERPROC)(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter); +GLAPI PFNGLBLITFRAMEBUFFERPROC glad_glBlitFramebuffer; +#define glBlitFramebuffer glad_glBlitFramebuffer +typedef void (APIENTRYP PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC)(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height); +GLAPI PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC glad_glRenderbufferStorageMultisample; +#define glRenderbufferStorageMultisample glad_glRenderbufferStorageMultisample +typedef void (APIENTRYP PFNGLFRAMEBUFFERTEXTURELAYERPROC)(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer); +GLAPI PFNGLFRAMEBUFFERTEXTURELAYERPROC glad_glFramebufferTextureLayer; +#define glFramebufferTextureLayer glad_glFramebufferTextureLayer +typedef void * (APIENTRYP PFNGLMAPBUFFERRANGEPROC)(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access); +GLAPI PFNGLMAPBUFFERRANGEPROC glad_glMapBufferRange; +#define glMapBufferRange glad_glMapBufferRange +typedef void (APIENTRYP PFNGLFLUSHMAPPEDBUFFERRANGEPROC)(GLenum target, GLintptr offset, GLsizeiptr length); +GLAPI PFNGLFLUSHMAPPEDBUFFERRANGEPROC glad_glFlushMappedBufferRange; +#define glFlushMappedBufferRange glad_glFlushMappedBufferRange +typedef void (APIENTRYP PFNGLBINDVERTEXARRAYPROC)(GLuint array); +GLAPI PFNGLBINDVERTEXARRAYPROC glad_glBindVertexArray; +#define glBindVertexArray glad_glBindVertexArray +typedef void (APIENTRYP PFNGLDELETEVERTEXARRAYSPROC)(GLsizei n, const GLuint *arrays); +GLAPI PFNGLDELETEVERTEXARRAYSPROC glad_glDeleteVertexArrays; +#define glDeleteVertexArrays glad_glDeleteVertexArrays +typedef void (APIENTRYP PFNGLGENVERTEXARRAYSPROC)(GLsizei n, GLuint *arrays); +GLAPI PFNGLGENVERTEXARRAYSPROC glad_glGenVertexArrays; +#define glGenVertexArrays glad_glGenVertexArrays +typedef GLboolean (APIENTRYP PFNGLISVERTEXARRAYPROC)(GLuint array); +GLAPI PFNGLISVERTEXARRAYPROC glad_glIsVertexArray; +#define glIsVertexArray glad_glIsVertexArray +#endif +#ifndef GL_VERSION_3_1 +#define GL_VERSION_3_1 1 +GLAPI int GLAD_GL_VERSION_3_1; +typedef void (APIENTRYP PFNGLDRAWARRAYSINSTANCEDPROC)(GLenum mode, GLint first, GLsizei count, GLsizei instancecount); +GLAPI PFNGLDRAWARRAYSINSTANCEDPROC glad_glDrawArraysInstanced; +#define glDrawArraysInstanced glad_glDrawArraysInstanced +typedef void (APIENTRYP PFNGLDRAWELEMENTSINSTANCEDPROC)(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount); +GLAPI PFNGLDRAWELEMENTSINSTANCEDPROC glad_glDrawElementsInstanced; +#define glDrawElementsInstanced glad_glDrawElementsInstanced +typedef void (APIENTRYP PFNGLTEXBUFFERPROC)(GLenum target, GLenum internalformat, GLuint buffer); +GLAPI PFNGLTEXBUFFERPROC glad_glTexBuffer; +#define glTexBuffer glad_glTexBuffer +typedef void (APIENTRYP PFNGLPRIMITIVERESTARTINDEXPROC)(GLuint index); +GLAPI PFNGLPRIMITIVERESTARTINDEXPROC glad_glPrimitiveRestartIndex; +#define glPrimitiveRestartIndex glad_glPrimitiveRestartIndex +typedef void (APIENTRYP PFNGLCOPYBUFFERSUBDATAPROC)(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size); +GLAPI PFNGLCOPYBUFFERSUBDATAPROC glad_glCopyBufferSubData; +#define glCopyBufferSubData glad_glCopyBufferSubData +typedef void (APIENTRYP PFNGLGETUNIFORMINDICESPROC)(GLuint program, GLsizei uniformCount, const GLchar *const*uniformNames, GLuint *uniformIndices); +GLAPI PFNGLGETUNIFORMINDICESPROC glad_glGetUniformIndices; +#define glGetUniformIndices glad_glGetUniformIndices +typedef void (APIENTRYP PFNGLGETACTIVEUNIFORMSIVPROC)(GLuint program, GLsizei uniformCount, const GLuint *uniformIndices, GLenum pname, GLint *params); +GLAPI PFNGLGETACTIVEUNIFORMSIVPROC glad_glGetActiveUniformsiv; +#define glGetActiveUniformsiv glad_glGetActiveUniformsiv +typedef void (APIENTRYP PFNGLGETACTIVEUNIFORMNAMEPROC)(GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformName); +GLAPI PFNGLGETACTIVEUNIFORMNAMEPROC glad_glGetActiveUniformName; +#define glGetActiveUniformName glad_glGetActiveUniformName +typedef GLuint (APIENTRYP PFNGLGETUNIFORMBLOCKINDEXPROC)(GLuint program, const GLchar *uniformBlockName); +GLAPI PFNGLGETUNIFORMBLOCKINDEXPROC glad_glGetUniformBlockIndex; +#define glGetUniformBlockIndex glad_glGetUniformBlockIndex +typedef void (APIENTRYP PFNGLGETACTIVEUNIFORMBLOCKIVPROC)(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint *params); +GLAPI PFNGLGETACTIVEUNIFORMBLOCKIVPROC glad_glGetActiveUniformBlockiv; +#define glGetActiveUniformBlockiv glad_glGetActiveUniformBlockiv +typedef void (APIENTRYP PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC)(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformBlockName); +GLAPI PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC glad_glGetActiveUniformBlockName; +#define glGetActiveUniformBlockName glad_glGetActiveUniformBlockName +typedef void (APIENTRYP PFNGLUNIFORMBLOCKBINDINGPROC)(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding); +GLAPI PFNGLUNIFORMBLOCKBINDINGPROC glad_glUniformBlockBinding; +#define glUniformBlockBinding glad_glUniformBlockBinding +#endif +#ifndef GL_VERSION_3_2 +#define GL_VERSION_3_2 1 +GLAPI int GLAD_GL_VERSION_3_2; +typedef void (APIENTRYP PFNGLDRAWELEMENTSBASEVERTEXPROC)(GLenum mode, GLsizei count, GLenum type, const void *indices, GLint basevertex); +GLAPI PFNGLDRAWELEMENTSBASEVERTEXPROC glad_glDrawElementsBaseVertex; +#define glDrawElementsBaseVertex glad_glDrawElementsBaseVertex +typedef void (APIENTRYP PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC)(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void *indices, GLint basevertex); +GLAPI PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC glad_glDrawRangeElementsBaseVertex; +#define glDrawRangeElementsBaseVertex glad_glDrawRangeElementsBaseVertex +typedef void (APIENTRYP PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC)(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLint basevertex); +GLAPI PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC glad_glDrawElementsInstancedBaseVertex; +#define glDrawElementsInstancedBaseVertex glad_glDrawElementsInstancedBaseVertex +typedef void (APIENTRYP PFNGLMULTIDRAWELEMENTSBASEVERTEXPROC)(GLenum mode, const GLsizei *count, GLenum type, const void *const*indices, GLsizei drawcount, const GLint *basevertex); +GLAPI PFNGLMULTIDRAWELEMENTSBASEVERTEXPROC glad_glMultiDrawElementsBaseVertex; +#define glMultiDrawElementsBaseVertex glad_glMultiDrawElementsBaseVertex +typedef void (APIENTRYP PFNGLPROVOKINGVERTEXPROC)(GLenum mode); +GLAPI PFNGLPROVOKINGVERTEXPROC glad_glProvokingVertex; +#define glProvokingVertex glad_glProvokingVertex +typedef GLsync (APIENTRYP PFNGLFENCESYNCPROC)(GLenum condition, GLbitfield flags); +GLAPI PFNGLFENCESYNCPROC glad_glFenceSync; +#define glFenceSync glad_glFenceSync +typedef GLboolean (APIENTRYP PFNGLISSYNCPROC)(GLsync sync); +GLAPI PFNGLISSYNCPROC glad_glIsSync; +#define glIsSync glad_glIsSync +typedef void (APIENTRYP PFNGLDELETESYNCPROC)(GLsync sync); +GLAPI PFNGLDELETESYNCPROC glad_glDeleteSync; +#define glDeleteSync glad_glDeleteSync +typedef GLenum (APIENTRYP PFNGLCLIENTWAITSYNCPROC)(GLsync sync, GLbitfield flags, GLuint64 timeout); +GLAPI PFNGLCLIENTWAITSYNCPROC glad_glClientWaitSync; +#define glClientWaitSync glad_glClientWaitSync +typedef void (APIENTRYP PFNGLWAITSYNCPROC)(GLsync sync, GLbitfield flags, GLuint64 timeout); +GLAPI PFNGLWAITSYNCPROC glad_glWaitSync; +#define glWaitSync glad_glWaitSync +typedef void (APIENTRYP PFNGLGETINTEGER64VPROC)(GLenum pname, GLint64 *data); +GLAPI PFNGLGETINTEGER64VPROC glad_glGetInteger64v; +#define glGetInteger64v glad_glGetInteger64v +typedef void (APIENTRYP PFNGLGETSYNCIVPROC)(GLsync sync, GLenum pname, GLsizei count, GLsizei *length, GLint *values); +GLAPI PFNGLGETSYNCIVPROC glad_glGetSynciv; +#define glGetSynciv glad_glGetSynciv +typedef void (APIENTRYP PFNGLGETINTEGER64I_VPROC)(GLenum target, GLuint index, GLint64 *data); +GLAPI PFNGLGETINTEGER64I_VPROC glad_glGetInteger64i_v; +#define glGetInteger64i_v glad_glGetInteger64i_v +typedef void (APIENTRYP PFNGLGETBUFFERPARAMETERI64VPROC)(GLenum target, GLenum pname, GLint64 *params); +GLAPI PFNGLGETBUFFERPARAMETERI64VPROC glad_glGetBufferParameteri64v; +#define glGetBufferParameteri64v glad_glGetBufferParameteri64v +typedef void (APIENTRYP PFNGLFRAMEBUFFERTEXTUREPROC)(GLenum target, GLenum attachment, GLuint texture, GLint level); +GLAPI PFNGLFRAMEBUFFERTEXTUREPROC glad_glFramebufferTexture; +#define glFramebufferTexture glad_glFramebufferTexture +typedef void (APIENTRYP PFNGLTEXIMAGE2DMULTISAMPLEPROC)(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations); +GLAPI PFNGLTEXIMAGE2DMULTISAMPLEPROC glad_glTexImage2DMultisample; +#define glTexImage2DMultisample glad_glTexImage2DMultisample +typedef void (APIENTRYP PFNGLTEXIMAGE3DMULTISAMPLEPROC)(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations); +GLAPI PFNGLTEXIMAGE3DMULTISAMPLEPROC glad_glTexImage3DMultisample; +#define glTexImage3DMultisample glad_glTexImage3DMultisample +typedef void (APIENTRYP PFNGLGETMULTISAMPLEFVPROC)(GLenum pname, GLuint index, GLfloat *val); +GLAPI PFNGLGETMULTISAMPLEFVPROC glad_glGetMultisamplefv; +#define glGetMultisamplefv glad_glGetMultisamplefv +typedef void (APIENTRYP PFNGLSAMPLEMASKIPROC)(GLuint maskNumber, GLbitfield mask); +GLAPI PFNGLSAMPLEMASKIPROC glad_glSampleMaski; +#define glSampleMaski glad_glSampleMaski +#endif +#ifndef GL_VERSION_3_3 +#define GL_VERSION_3_3 1 +GLAPI int GLAD_GL_VERSION_3_3; +typedef void (APIENTRYP PFNGLBINDFRAGDATALOCATIONINDEXEDPROC)(GLuint program, GLuint colorNumber, GLuint index, const GLchar *name); +GLAPI PFNGLBINDFRAGDATALOCATIONINDEXEDPROC glad_glBindFragDataLocationIndexed; +#define glBindFragDataLocationIndexed glad_glBindFragDataLocationIndexed +typedef GLint (APIENTRYP PFNGLGETFRAGDATAINDEXPROC)(GLuint program, const GLchar *name); +GLAPI PFNGLGETFRAGDATAINDEXPROC glad_glGetFragDataIndex; +#define glGetFragDataIndex glad_glGetFragDataIndex +typedef void (APIENTRYP PFNGLGENSAMPLERSPROC)(GLsizei count, GLuint *samplers); +GLAPI PFNGLGENSAMPLERSPROC glad_glGenSamplers; +#define glGenSamplers glad_glGenSamplers +typedef void (APIENTRYP PFNGLDELETESAMPLERSPROC)(GLsizei count, const GLuint *samplers); +GLAPI PFNGLDELETESAMPLERSPROC glad_glDeleteSamplers; +#define glDeleteSamplers glad_glDeleteSamplers +typedef GLboolean (APIENTRYP PFNGLISSAMPLERPROC)(GLuint sampler); +GLAPI PFNGLISSAMPLERPROC glad_glIsSampler; +#define glIsSampler glad_glIsSampler +typedef void (APIENTRYP PFNGLBINDSAMPLERPROC)(GLuint unit, GLuint sampler); +GLAPI PFNGLBINDSAMPLERPROC glad_glBindSampler; +#define glBindSampler glad_glBindSampler +typedef void (APIENTRYP PFNGLSAMPLERPARAMETERIPROC)(GLuint sampler, GLenum pname, GLint param); +GLAPI PFNGLSAMPLERPARAMETERIPROC glad_glSamplerParameteri; +#define glSamplerParameteri glad_glSamplerParameteri +typedef void (APIENTRYP PFNGLSAMPLERPARAMETERIVPROC)(GLuint sampler, GLenum pname, const GLint *param); +GLAPI PFNGLSAMPLERPARAMETERIVPROC glad_glSamplerParameteriv; +#define glSamplerParameteriv glad_glSamplerParameteriv +typedef void (APIENTRYP PFNGLSAMPLERPARAMETERFPROC)(GLuint sampler, GLenum pname, GLfloat param); +GLAPI PFNGLSAMPLERPARAMETERFPROC glad_glSamplerParameterf; +#define glSamplerParameterf glad_glSamplerParameterf +typedef void (APIENTRYP PFNGLSAMPLERPARAMETERFVPROC)(GLuint sampler, GLenum pname, const GLfloat *param); +GLAPI PFNGLSAMPLERPARAMETERFVPROC glad_glSamplerParameterfv; +#define glSamplerParameterfv glad_glSamplerParameterfv +typedef void (APIENTRYP PFNGLSAMPLERPARAMETERIIVPROC)(GLuint sampler, GLenum pname, const GLint *param); +GLAPI PFNGLSAMPLERPARAMETERIIVPROC glad_glSamplerParameterIiv; +#define glSamplerParameterIiv glad_glSamplerParameterIiv +typedef void (APIENTRYP PFNGLSAMPLERPARAMETERIUIVPROC)(GLuint sampler, GLenum pname, const GLuint *param); +GLAPI PFNGLSAMPLERPARAMETERIUIVPROC glad_glSamplerParameterIuiv; +#define glSamplerParameterIuiv glad_glSamplerParameterIuiv +typedef void (APIENTRYP PFNGLGETSAMPLERPARAMETERIVPROC)(GLuint sampler, GLenum pname, GLint *params); +GLAPI PFNGLGETSAMPLERPARAMETERIVPROC glad_glGetSamplerParameteriv; +#define glGetSamplerParameteriv glad_glGetSamplerParameteriv +typedef void (APIENTRYP PFNGLGETSAMPLERPARAMETERIIVPROC)(GLuint sampler, GLenum pname, GLint *params); +GLAPI PFNGLGETSAMPLERPARAMETERIIVPROC glad_glGetSamplerParameterIiv; +#define glGetSamplerParameterIiv glad_glGetSamplerParameterIiv +typedef void (APIENTRYP PFNGLGETSAMPLERPARAMETERFVPROC)(GLuint sampler, GLenum pname, GLfloat *params); +GLAPI PFNGLGETSAMPLERPARAMETERFVPROC glad_glGetSamplerParameterfv; +#define glGetSamplerParameterfv glad_glGetSamplerParameterfv +typedef void (APIENTRYP PFNGLGETSAMPLERPARAMETERIUIVPROC)(GLuint sampler, GLenum pname, GLuint *params); +GLAPI PFNGLGETSAMPLERPARAMETERIUIVPROC glad_glGetSamplerParameterIuiv; +#define glGetSamplerParameterIuiv glad_glGetSamplerParameterIuiv +typedef void (APIENTRYP PFNGLQUERYCOUNTERPROC)(GLuint id, GLenum target); +GLAPI PFNGLQUERYCOUNTERPROC glad_glQueryCounter; +#define glQueryCounter glad_glQueryCounter +typedef void (APIENTRYP PFNGLGETQUERYOBJECTI64VPROC)(GLuint id, GLenum pname, GLint64 *params); +GLAPI PFNGLGETQUERYOBJECTI64VPROC glad_glGetQueryObjecti64v; +#define glGetQueryObjecti64v glad_glGetQueryObjecti64v +typedef void (APIENTRYP PFNGLGETQUERYOBJECTUI64VPROC)(GLuint id, GLenum pname, GLuint64 *params); +GLAPI PFNGLGETQUERYOBJECTUI64VPROC glad_glGetQueryObjectui64v; +#define glGetQueryObjectui64v glad_glGetQueryObjectui64v +typedef void (APIENTRYP PFNGLVERTEXATTRIBDIVISORPROC)(GLuint index, GLuint divisor); +GLAPI PFNGLVERTEXATTRIBDIVISORPROC glad_glVertexAttribDivisor; +#define glVertexAttribDivisor glad_glVertexAttribDivisor +typedef void (APIENTRYP PFNGLVERTEXATTRIBP1UIPROC)(GLuint index, GLenum type, GLboolean normalized, GLuint value); +GLAPI PFNGLVERTEXATTRIBP1UIPROC glad_glVertexAttribP1ui; +#define glVertexAttribP1ui glad_glVertexAttribP1ui +typedef void (APIENTRYP PFNGLVERTEXATTRIBP1UIVPROC)(GLuint index, GLenum type, GLboolean normalized, const GLuint *value); +GLAPI PFNGLVERTEXATTRIBP1UIVPROC glad_glVertexAttribP1uiv; +#define glVertexAttribP1uiv glad_glVertexAttribP1uiv +typedef void (APIENTRYP PFNGLVERTEXATTRIBP2UIPROC)(GLuint index, GLenum type, GLboolean normalized, GLuint value); +GLAPI PFNGLVERTEXATTRIBP2UIPROC glad_glVertexAttribP2ui; +#define glVertexAttribP2ui glad_glVertexAttribP2ui +typedef void (APIENTRYP PFNGLVERTEXATTRIBP2UIVPROC)(GLuint index, GLenum type, GLboolean normalized, const GLuint *value); +GLAPI PFNGLVERTEXATTRIBP2UIVPROC glad_glVertexAttribP2uiv; +#define glVertexAttribP2uiv glad_glVertexAttribP2uiv +typedef void (APIENTRYP PFNGLVERTEXATTRIBP3UIPROC)(GLuint index, GLenum type, GLboolean normalized, GLuint value); +GLAPI PFNGLVERTEXATTRIBP3UIPROC glad_glVertexAttribP3ui; +#define glVertexAttribP3ui glad_glVertexAttribP3ui +typedef void (APIENTRYP PFNGLVERTEXATTRIBP3UIVPROC)(GLuint index, GLenum type, GLboolean normalized, const GLuint *value); +GLAPI PFNGLVERTEXATTRIBP3UIVPROC glad_glVertexAttribP3uiv; +#define glVertexAttribP3uiv glad_glVertexAttribP3uiv +typedef void (APIENTRYP PFNGLVERTEXATTRIBP4UIPROC)(GLuint index, GLenum type, GLboolean normalized, GLuint value); +GLAPI PFNGLVERTEXATTRIBP4UIPROC glad_glVertexAttribP4ui; +#define glVertexAttribP4ui glad_glVertexAttribP4ui +typedef void (APIENTRYP PFNGLVERTEXATTRIBP4UIVPROC)(GLuint index, GLenum type, GLboolean normalized, const GLuint *value); +GLAPI PFNGLVERTEXATTRIBP4UIVPROC glad_glVertexAttribP4uiv; +#define glVertexAttribP4uiv glad_glVertexAttribP4uiv +typedef void (APIENTRYP PFNGLVERTEXP2UIPROC)(GLenum type, GLuint value); +GLAPI PFNGLVERTEXP2UIPROC glad_glVertexP2ui; +#define glVertexP2ui glad_glVertexP2ui +typedef void (APIENTRYP PFNGLVERTEXP2UIVPROC)(GLenum type, const GLuint *value); +GLAPI PFNGLVERTEXP2UIVPROC glad_glVertexP2uiv; +#define glVertexP2uiv glad_glVertexP2uiv +typedef void (APIENTRYP PFNGLVERTEXP3UIPROC)(GLenum type, GLuint value); +GLAPI PFNGLVERTEXP3UIPROC glad_glVertexP3ui; +#define glVertexP3ui glad_glVertexP3ui +typedef void (APIENTRYP PFNGLVERTEXP3UIVPROC)(GLenum type, const GLuint *value); +GLAPI PFNGLVERTEXP3UIVPROC glad_glVertexP3uiv; +#define glVertexP3uiv glad_glVertexP3uiv +typedef void (APIENTRYP PFNGLVERTEXP4UIPROC)(GLenum type, GLuint value); +GLAPI PFNGLVERTEXP4UIPROC glad_glVertexP4ui; +#define glVertexP4ui glad_glVertexP4ui +typedef void (APIENTRYP PFNGLVERTEXP4UIVPROC)(GLenum type, const GLuint *value); +GLAPI PFNGLVERTEXP4UIVPROC glad_glVertexP4uiv; +#define glVertexP4uiv glad_glVertexP4uiv +typedef void (APIENTRYP PFNGLTEXCOORDP1UIPROC)(GLenum type, GLuint coords); +GLAPI PFNGLTEXCOORDP1UIPROC glad_glTexCoordP1ui; +#define glTexCoordP1ui glad_glTexCoordP1ui +typedef void (APIENTRYP PFNGLTEXCOORDP1UIVPROC)(GLenum type, const GLuint *coords); +GLAPI PFNGLTEXCOORDP1UIVPROC glad_glTexCoordP1uiv; +#define glTexCoordP1uiv glad_glTexCoordP1uiv +typedef void (APIENTRYP PFNGLTEXCOORDP2UIPROC)(GLenum type, GLuint coords); +GLAPI PFNGLTEXCOORDP2UIPROC glad_glTexCoordP2ui; +#define glTexCoordP2ui glad_glTexCoordP2ui +typedef void (APIENTRYP PFNGLTEXCOORDP2UIVPROC)(GLenum type, const GLuint *coords); +GLAPI PFNGLTEXCOORDP2UIVPROC glad_glTexCoordP2uiv; +#define glTexCoordP2uiv glad_glTexCoordP2uiv +typedef void (APIENTRYP PFNGLTEXCOORDP3UIPROC)(GLenum type, GLuint coords); +GLAPI PFNGLTEXCOORDP3UIPROC glad_glTexCoordP3ui; +#define glTexCoordP3ui glad_glTexCoordP3ui +typedef void (APIENTRYP PFNGLTEXCOORDP3UIVPROC)(GLenum type, const GLuint *coords); +GLAPI PFNGLTEXCOORDP3UIVPROC glad_glTexCoordP3uiv; +#define glTexCoordP3uiv glad_glTexCoordP3uiv +typedef void (APIENTRYP PFNGLTEXCOORDP4UIPROC)(GLenum type, GLuint coords); +GLAPI PFNGLTEXCOORDP4UIPROC glad_glTexCoordP4ui; +#define glTexCoordP4ui glad_glTexCoordP4ui +typedef void (APIENTRYP PFNGLTEXCOORDP4UIVPROC)(GLenum type, const GLuint *coords); +GLAPI PFNGLTEXCOORDP4UIVPROC glad_glTexCoordP4uiv; +#define glTexCoordP4uiv glad_glTexCoordP4uiv +typedef void (APIENTRYP PFNGLMULTITEXCOORDP1UIPROC)(GLenum texture, GLenum type, GLuint coords); +GLAPI PFNGLMULTITEXCOORDP1UIPROC glad_glMultiTexCoordP1ui; +#define glMultiTexCoordP1ui glad_glMultiTexCoordP1ui +typedef void (APIENTRYP PFNGLMULTITEXCOORDP1UIVPROC)(GLenum texture, GLenum type, const GLuint *coords); +GLAPI PFNGLMULTITEXCOORDP1UIVPROC glad_glMultiTexCoordP1uiv; +#define glMultiTexCoordP1uiv glad_glMultiTexCoordP1uiv +typedef void (APIENTRYP PFNGLMULTITEXCOORDP2UIPROC)(GLenum texture, GLenum type, GLuint coords); +GLAPI PFNGLMULTITEXCOORDP2UIPROC glad_glMultiTexCoordP2ui; +#define glMultiTexCoordP2ui glad_glMultiTexCoordP2ui +typedef void (APIENTRYP PFNGLMULTITEXCOORDP2UIVPROC)(GLenum texture, GLenum type, const GLuint *coords); +GLAPI PFNGLMULTITEXCOORDP2UIVPROC glad_glMultiTexCoordP2uiv; +#define glMultiTexCoordP2uiv glad_glMultiTexCoordP2uiv +typedef void (APIENTRYP PFNGLMULTITEXCOORDP3UIPROC)(GLenum texture, GLenum type, GLuint coords); +GLAPI PFNGLMULTITEXCOORDP3UIPROC glad_glMultiTexCoordP3ui; +#define glMultiTexCoordP3ui glad_glMultiTexCoordP3ui +typedef void (APIENTRYP PFNGLMULTITEXCOORDP3UIVPROC)(GLenum texture, GLenum type, const GLuint *coords); +GLAPI PFNGLMULTITEXCOORDP3UIVPROC glad_glMultiTexCoordP3uiv; +#define glMultiTexCoordP3uiv glad_glMultiTexCoordP3uiv +typedef void (APIENTRYP PFNGLMULTITEXCOORDP4UIPROC)(GLenum texture, GLenum type, GLuint coords); +GLAPI PFNGLMULTITEXCOORDP4UIPROC glad_glMultiTexCoordP4ui; +#define glMultiTexCoordP4ui glad_glMultiTexCoordP4ui +typedef void (APIENTRYP PFNGLMULTITEXCOORDP4UIVPROC)(GLenum texture, GLenum type, const GLuint *coords); +GLAPI PFNGLMULTITEXCOORDP4UIVPROC glad_glMultiTexCoordP4uiv; +#define glMultiTexCoordP4uiv glad_glMultiTexCoordP4uiv +typedef void (APIENTRYP PFNGLNORMALP3UIPROC)(GLenum type, GLuint coords); +GLAPI PFNGLNORMALP3UIPROC glad_glNormalP3ui; +#define glNormalP3ui glad_glNormalP3ui +typedef void (APIENTRYP PFNGLNORMALP3UIVPROC)(GLenum type, const GLuint *coords); +GLAPI PFNGLNORMALP3UIVPROC glad_glNormalP3uiv; +#define glNormalP3uiv glad_glNormalP3uiv +typedef void (APIENTRYP PFNGLCOLORP3UIPROC)(GLenum type, GLuint color); +GLAPI PFNGLCOLORP3UIPROC glad_glColorP3ui; +#define glColorP3ui glad_glColorP3ui +typedef void (APIENTRYP PFNGLCOLORP3UIVPROC)(GLenum type, const GLuint *color); +GLAPI PFNGLCOLORP3UIVPROC glad_glColorP3uiv; +#define glColorP3uiv glad_glColorP3uiv +typedef void (APIENTRYP PFNGLCOLORP4UIPROC)(GLenum type, GLuint color); +GLAPI PFNGLCOLORP4UIPROC glad_glColorP4ui; +#define glColorP4ui glad_glColorP4ui +typedef void (APIENTRYP PFNGLCOLORP4UIVPROC)(GLenum type, const GLuint *color); +GLAPI PFNGLCOLORP4UIVPROC glad_glColorP4uiv; +#define glColorP4uiv glad_glColorP4uiv +typedef void (APIENTRYP PFNGLSECONDARYCOLORP3UIPROC)(GLenum type, GLuint color); +GLAPI PFNGLSECONDARYCOLORP3UIPROC glad_glSecondaryColorP3ui; +#define glSecondaryColorP3ui glad_glSecondaryColorP3ui +typedef void (APIENTRYP PFNGLSECONDARYCOLORP3UIVPROC)(GLenum type, const GLuint *color); +GLAPI PFNGLSECONDARYCOLORP3UIVPROC glad_glSecondaryColorP3uiv; +#define glSecondaryColorP3uiv glad_glSecondaryColorP3uiv +#endif + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/Dynamic libraries/src/glad.c b/Dynamic libraries/src/glad.c new file mode 100644 index 0000000..2513d67 --- /dev/null +++ b/Dynamic libraries/src/glad.c @@ -0,0 +1,1140 @@ +/* + + OpenGL loader generated by glad 0.1.36 on Mon Feb 16 17:34:00 2026. + + Language/Generator: C/C++ + Specification: gl + APIs: gl=3.3 + Profile: core + Extensions: + + Loader: True + Local files: False + Omit khrplatform: False + Reproducible: False + + Commandline: + --profile="core" --api="gl=3.3" --generator="c" --spec="gl" --extensions="" + Online: + https://glad.dav1d.de/#profile=core&language=c&specification=gl&loader=on&api=gl%3D3.3 +*/ + +#include +#include +#include +#include + +static void* get_proc(const char *namez); + +#if defined(_WIN32) || defined(__CYGWIN__) +#ifndef _WINDOWS_ +#undef APIENTRY +#endif +#include +static HMODULE libGL; + +typedef void* (APIENTRYP PFNWGLGETPROCADDRESSPROC_PRIVATE)(const char*); +static PFNWGLGETPROCADDRESSPROC_PRIVATE gladGetProcAddressPtr; + +#ifdef _MSC_VER +#ifdef __has_include + #if __has_include() + #define HAVE_WINAPIFAMILY 1 + #endif +#elif _MSC_VER >= 1700 && !_USING_V110_SDK71_ + #define HAVE_WINAPIFAMILY 1 +#endif +#endif + +#ifdef HAVE_WINAPIFAMILY + #include + #if !WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) && WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) + #define IS_UWP 1 + #endif +#endif + +static +int open_gl(void) { +#ifndef IS_UWP + libGL = LoadLibraryW(L"opengl32.dll"); + if(libGL != NULL) { + void (* tmp)(void); + tmp = (void(*)(void)) GetProcAddress(libGL, "wglGetProcAddress"); + gladGetProcAddressPtr = (PFNWGLGETPROCADDRESSPROC_PRIVATE) tmp; + return gladGetProcAddressPtr != NULL; + } +#endif + + return 0; +} + +static +void close_gl(void) { + if(libGL != NULL) { + FreeLibrary((HMODULE) libGL); + libGL = NULL; + } +} +#else +#include +static void* libGL; + +#if !defined(__APPLE__) && !defined(__HAIKU__) +typedef void* (APIENTRYP PFNGLXGETPROCADDRESSPROC_PRIVATE)(const char*); +static PFNGLXGETPROCADDRESSPROC_PRIVATE gladGetProcAddressPtr; +#endif + +static +int open_gl(void) { +#ifdef __APPLE__ + static const char *NAMES[] = { + "../Frameworks/OpenGL.framework/OpenGL", + "/Library/Frameworks/OpenGL.framework/OpenGL", + "/System/Library/Frameworks/OpenGL.framework/OpenGL", + "/System/Library/Frameworks/OpenGL.framework/Versions/Current/OpenGL" + }; +#else + static const char *NAMES[] = {"libGL.so.1", "libGL.so"}; +#endif + + unsigned int index = 0; + for(index = 0; index < (sizeof(NAMES) / sizeof(NAMES[0])); index++) { + libGL = dlopen(NAMES[index], RTLD_NOW | RTLD_GLOBAL); + + if(libGL != NULL) { +#if defined(__APPLE__) || defined(__HAIKU__) + return 1; +#else + gladGetProcAddressPtr = (PFNGLXGETPROCADDRESSPROC_PRIVATE)dlsym(libGL, + "glXGetProcAddressARB"); + return gladGetProcAddressPtr != NULL; +#endif + } + } + + return 0; +} + +static +void close_gl(void) { + if(libGL != NULL) { + dlclose(libGL); + libGL = NULL; + } +} +#endif + +static +void* get_proc(const char *namez) { + void* result = NULL; + if(libGL == NULL) return NULL; + +#if !defined(__APPLE__) && !defined(__HAIKU__) + if(gladGetProcAddressPtr != NULL) { + result = gladGetProcAddressPtr(namez); + } +#endif + if(result == NULL) { +#if defined(_WIN32) || defined(__CYGWIN__) + result = (void*)GetProcAddress((HMODULE) libGL, namez); +#else + result = dlsym(libGL, namez); +#endif + } + + return result; +} + +int gladLoadGL(void) { + int status = 0; + + if(open_gl()) { + status = gladLoadGLLoader(&get_proc); + close_gl(); + } + + return status; +} + +struct gladGLversionStruct GLVersion = { 0, 0 }; + +#if defined(GL_ES_VERSION_3_0) || defined(GL_VERSION_3_0) +#define _GLAD_IS_SOME_NEW_VERSION 1 +#endif + +static int max_loaded_major; +static int max_loaded_minor; + +static const char *exts = NULL; +static int num_exts_i = 0; +static char **exts_i = NULL; + +static int get_exts(void) { +#ifdef _GLAD_IS_SOME_NEW_VERSION + if(max_loaded_major < 3) { +#endif + exts = (const char *)glGetString(GL_EXTENSIONS); +#ifdef _GLAD_IS_SOME_NEW_VERSION + } else { + int index; + + num_exts_i = 0; + glGetIntegerv(GL_NUM_EXTENSIONS, &num_exts_i); + if (num_exts_i > 0) { + exts_i = (char **)malloc((size_t)num_exts_i * (sizeof *exts_i)); + } + + if (exts_i == NULL) { + return 0; + } + + for(index = 0; index < num_exts_i; index++) { + const char *gl_str_tmp = (const char*)glGetStringi(GL_EXTENSIONS, index); + size_t len = strlen(gl_str_tmp); + + char *local_str = (char*)malloc((len+1) * sizeof(char)); + if(local_str != NULL) { + memcpy(local_str, gl_str_tmp, (len+1) * sizeof(char)); + } + exts_i[index] = local_str; + } + } +#endif + return 1; +} + +static void free_exts(void) { + if (exts_i != NULL) { + int index; + for(index = 0; index < num_exts_i; index++) { + free((char *)exts_i[index]); + } + free((void *)exts_i); + exts_i = NULL; + } +} + +static int has_ext(const char *ext) { +#ifdef _GLAD_IS_SOME_NEW_VERSION + if(max_loaded_major < 3) { +#endif + const char *extensions; + const char *loc; + const char *terminator; + extensions = exts; + if(extensions == NULL || ext == NULL) { + return 0; + } + + while(1) { + loc = strstr(extensions, ext); + if(loc == NULL) { + return 0; + } + + terminator = loc + strlen(ext); + if((loc == extensions || *(loc - 1) == ' ') && + (*terminator == ' ' || *terminator == '\0')) { + return 1; + } + extensions = terminator; + } +#ifdef _GLAD_IS_SOME_NEW_VERSION + } else { + int index; + if(exts_i == NULL) return 0; + for(index = 0; index < num_exts_i; index++) { + const char *e = exts_i[index]; + + if(exts_i[index] != NULL && strcmp(e, ext) == 0) { + return 1; + } + } + } +#endif + + return 0; +} +int GLAD_GL_VERSION_1_0 = 0; +int GLAD_GL_VERSION_1_1 = 0; +int GLAD_GL_VERSION_1_2 = 0; +int GLAD_GL_VERSION_1_3 = 0; +int GLAD_GL_VERSION_1_4 = 0; +int GLAD_GL_VERSION_1_5 = 0; +int GLAD_GL_VERSION_2_0 = 0; +int GLAD_GL_VERSION_2_1 = 0; +int GLAD_GL_VERSION_3_0 = 0; +int GLAD_GL_VERSION_3_1 = 0; +int GLAD_GL_VERSION_3_2 = 0; +int GLAD_GL_VERSION_3_3 = 0; +PFNGLACTIVETEXTUREPROC glad_glActiveTexture = NULL; +PFNGLATTACHSHADERPROC glad_glAttachShader = NULL; +PFNGLBEGINCONDITIONALRENDERPROC glad_glBeginConditionalRender = NULL; +PFNGLBEGINQUERYPROC glad_glBeginQuery = NULL; +PFNGLBEGINTRANSFORMFEEDBACKPROC glad_glBeginTransformFeedback = NULL; +PFNGLBINDATTRIBLOCATIONPROC glad_glBindAttribLocation = NULL; +PFNGLBINDBUFFERPROC glad_glBindBuffer = NULL; +PFNGLBINDBUFFERBASEPROC glad_glBindBufferBase = NULL; +PFNGLBINDBUFFERRANGEPROC glad_glBindBufferRange = NULL; +PFNGLBINDFRAGDATALOCATIONPROC glad_glBindFragDataLocation = NULL; +PFNGLBINDFRAGDATALOCATIONINDEXEDPROC glad_glBindFragDataLocationIndexed = NULL; +PFNGLBINDFRAMEBUFFERPROC glad_glBindFramebuffer = NULL; +PFNGLBINDRENDERBUFFERPROC glad_glBindRenderbuffer = NULL; +PFNGLBINDSAMPLERPROC glad_glBindSampler = NULL; +PFNGLBINDTEXTUREPROC glad_glBindTexture = NULL; +PFNGLBINDVERTEXARRAYPROC glad_glBindVertexArray = NULL; +PFNGLBLENDCOLORPROC glad_glBlendColor = NULL; +PFNGLBLENDEQUATIONPROC glad_glBlendEquation = NULL; +PFNGLBLENDEQUATIONSEPARATEPROC glad_glBlendEquationSeparate = NULL; +PFNGLBLENDFUNCPROC glad_glBlendFunc = NULL; +PFNGLBLENDFUNCSEPARATEPROC glad_glBlendFuncSeparate = NULL; +PFNGLBLITFRAMEBUFFERPROC glad_glBlitFramebuffer = NULL; +PFNGLBUFFERDATAPROC glad_glBufferData = NULL; +PFNGLBUFFERSUBDATAPROC glad_glBufferSubData = NULL; +PFNGLCHECKFRAMEBUFFERSTATUSPROC glad_glCheckFramebufferStatus = NULL; +PFNGLCLAMPCOLORPROC glad_glClampColor = NULL; +PFNGLCLEARPROC glad_glClear = NULL; +PFNGLCLEARBUFFERFIPROC glad_glClearBufferfi = NULL; +PFNGLCLEARBUFFERFVPROC glad_glClearBufferfv = NULL; +PFNGLCLEARBUFFERIVPROC glad_glClearBufferiv = NULL; +PFNGLCLEARBUFFERUIVPROC glad_glClearBufferuiv = NULL; +PFNGLCLEARCOLORPROC glad_glClearColor = NULL; +PFNGLCLEARDEPTHPROC glad_glClearDepth = NULL; +PFNGLCLEARSTENCILPROC glad_glClearStencil = NULL; +PFNGLCLIENTWAITSYNCPROC glad_glClientWaitSync = NULL; +PFNGLCOLORMASKPROC glad_glColorMask = NULL; +PFNGLCOLORMASKIPROC glad_glColorMaski = NULL; +PFNGLCOLORP3UIPROC glad_glColorP3ui = NULL; +PFNGLCOLORP3UIVPROC glad_glColorP3uiv = NULL; +PFNGLCOLORP4UIPROC glad_glColorP4ui = NULL; +PFNGLCOLORP4UIVPROC glad_glColorP4uiv = NULL; +PFNGLCOMPILESHADERPROC glad_glCompileShader = NULL; +PFNGLCOMPRESSEDTEXIMAGE1DPROC glad_glCompressedTexImage1D = NULL; +PFNGLCOMPRESSEDTEXIMAGE2DPROC glad_glCompressedTexImage2D = NULL; +PFNGLCOMPRESSEDTEXIMAGE3DPROC glad_glCompressedTexImage3D = NULL; +PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC glad_glCompressedTexSubImage1D = NULL; +PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC glad_glCompressedTexSubImage2D = NULL; +PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC glad_glCompressedTexSubImage3D = NULL; +PFNGLCOPYBUFFERSUBDATAPROC glad_glCopyBufferSubData = NULL; +PFNGLCOPYTEXIMAGE1DPROC glad_glCopyTexImage1D = NULL; +PFNGLCOPYTEXIMAGE2DPROC glad_glCopyTexImage2D = NULL; +PFNGLCOPYTEXSUBIMAGE1DPROC glad_glCopyTexSubImage1D = NULL; +PFNGLCOPYTEXSUBIMAGE2DPROC glad_glCopyTexSubImage2D = NULL; +PFNGLCOPYTEXSUBIMAGE3DPROC glad_glCopyTexSubImage3D = NULL; +PFNGLCREATEPROGRAMPROC glad_glCreateProgram = NULL; +PFNGLCREATESHADERPROC glad_glCreateShader = NULL; +PFNGLCULLFACEPROC glad_glCullFace = NULL; +PFNGLDELETEBUFFERSPROC glad_glDeleteBuffers = NULL; +PFNGLDELETEFRAMEBUFFERSPROC glad_glDeleteFramebuffers = NULL; +PFNGLDELETEPROGRAMPROC glad_glDeleteProgram = NULL; +PFNGLDELETEQUERIESPROC glad_glDeleteQueries = NULL; +PFNGLDELETERENDERBUFFERSPROC glad_glDeleteRenderbuffers = NULL; +PFNGLDELETESAMPLERSPROC glad_glDeleteSamplers = NULL; +PFNGLDELETESHADERPROC glad_glDeleteShader = NULL; +PFNGLDELETESYNCPROC glad_glDeleteSync = NULL; +PFNGLDELETETEXTURESPROC glad_glDeleteTextures = NULL; +PFNGLDELETEVERTEXARRAYSPROC glad_glDeleteVertexArrays = NULL; +PFNGLDEPTHFUNCPROC glad_glDepthFunc = NULL; +PFNGLDEPTHMASKPROC glad_glDepthMask = NULL; +PFNGLDEPTHRANGEPROC glad_glDepthRange = NULL; +PFNGLDETACHSHADERPROC glad_glDetachShader = NULL; +PFNGLDISABLEPROC glad_glDisable = NULL; +PFNGLDISABLEVERTEXATTRIBARRAYPROC glad_glDisableVertexAttribArray = NULL; +PFNGLDISABLEIPROC glad_glDisablei = NULL; +PFNGLDRAWARRAYSPROC glad_glDrawArrays = NULL; +PFNGLDRAWARRAYSINSTANCEDPROC glad_glDrawArraysInstanced = NULL; +PFNGLDRAWBUFFERPROC glad_glDrawBuffer = NULL; +PFNGLDRAWBUFFERSPROC glad_glDrawBuffers = NULL; +PFNGLDRAWELEMENTSPROC glad_glDrawElements = NULL; +PFNGLDRAWELEMENTSBASEVERTEXPROC glad_glDrawElementsBaseVertex = NULL; +PFNGLDRAWELEMENTSINSTANCEDPROC glad_glDrawElementsInstanced = NULL; +PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC glad_glDrawElementsInstancedBaseVertex = NULL; +PFNGLDRAWRANGEELEMENTSPROC glad_glDrawRangeElements = NULL; +PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC glad_glDrawRangeElementsBaseVertex = NULL; +PFNGLENABLEPROC glad_glEnable = NULL; +PFNGLENABLEVERTEXATTRIBARRAYPROC glad_glEnableVertexAttribArray = NULL; +PFNGLENABLEIPROC glad_glEnablei = NULL; +PFNGLENDCONDITIONALRENDERPROC glad_glEndConditionalRender = NULL; +PFNGLENDQUERYPROC glad_glEndQuery = NULL; +PFNGLENDTRANSFORMFEEDBACKPROC glad_glEndTransformFeedback = NULL; +PFNGLFENCESYNCPROC glad_glFenceSync = NULL; +PFNGLFINISHPROC glad_glFinish = NULL; +PFNGLFLUSHPROC glad_glFlush = NULL; +PFNGLFLUSHMAPPEDBUFFERRANGEPROC glad_glFlushMappedBufferRange = NULL; +PFNGLFRAMEBUFFERRENDERBUFFERPROC glad_glFramebufferRenderbuffer = NULL; +PFNGLFRAMEBUFFERTEXTUREPROC glad_glFramebufferTexture = NULL; +PFNGLFRAMEBUFFERTEXTURE1DPROC glad_glFramebufferTexture1D = NULL; +PFNGLFRAMEBUFFERTEXTURE2DPROC glad_glFramebufferTexture2D = NULL; +PFNGLFRAMEBUFFERTEXTURE3DPROC glad_glFramebufferTexture3D = NULL; +PFNGLFRAMEBUFFERTEXTURELAYERPROC glad_glFramebufferTextureLayer = NULL; +PFNGLFRONTFACEPROC glad_glFrontFace = NULL; +PFNGLGENBUFFERSPROC glad_glGenBuffers = NULL; +PFNGLGENFRAMEBUFFERSPROC glad_glGenFramebuffers = NULL; +PFNGLGENQUERIESPROC glad_glGenQueries = NULL; +PFNGLGENRENDERBUFFERSPROC glad_glGenRenderbuffers = NULL; +PFNGLGENSAMPLERSPROC glad_glGenSamplers = NULL; +PFNGLGENTEXTURESPROC glad_glGenTextures = NULL; +PFNGLGENVERTEXARRAYSPROC glad_glGenVertexArrays = NULL; +PFNGLGENERATEMIPMAPPROC glad_glGenerateMipmap = NULL; +PFNGLGETACTIVEATTRIBPROC glad_glGetActiveAttrib = NULL; +PFNGLGETACTIVEUNIFORMPROC glad_glGetActiveUniform = NULL; +PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC glad_glGetActiveUniformBlockName = NULL; +PFNGLGETACTIVEUNIFORMBLOCKIVPROC glad_glGetActiveUniformBlockiv = NULL; +PFNGLGETACTIVEUNIFORMNAMEPROC glad_glGetActiveUniformName = NULL; +PFNGLGETACTIVEUNIFORMSIVPROC glad_glGetActiveUniformsiv = NULL; +PFNGLGETATTACHEDSHADERSPROC glad_glGetAttachedShaders = NULL; +PFNGLGETATTRIBLOCATIONPROC glad_glGetAttribLocation = NULL; +PFNGLGETBOOLEANI_VPROC glad_glGetBooleani_v = NULL; +PFNGLGETBOOLEANVPROC glad_glGetBooleanv = NULL; +PFNGLGETBUFFERPARAMETERI64VPROC glad_glGetBufferParameteri64v = NULL; +PFNGLGETBUFFERPARAMETERIVPROC glad_glGetBufferParameteriv = NULL; +PFNGLGETBUFFERPOINTERVPROC glad_glGetBufferPointerv = NULL; +PFNGLGETBUFFERSUBDATAPROC glad_glGetBufferSubData = NULL; +PFNGLGETCOMPRESSEDTEXIMAGEPROC glad_glGetCompressedTexImage = NULL; +PFNGLGETDOUBLEVPROC glad_glGetDoublev = NULL; +PFNGLGETERRORPROC glad_glGetError = NULL; +PFNGLGETFLOATVPROC glad_glGetFloatv = NULL; +PFNGLGETFRAGDATAINDEXPROC glad_glGetFragDataIndex = NULL; +PFNGLGETFRAGDATALOCATIONPROC glad_glGetFragDataLocation = NULL; +PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC glad_glGetFramebufferAttachmentParameteriv = NULL; +PFNGLGETINTEGER64I_VPROC glad_glGetInteger64i_v = NULL; +PFNGLGETINTEGER64VPROC glad_glGetInteger64v = NULL; +PFNGLGETINTEGERI_VPROC glad_glGetIntegeri_v = NULL; +PFNGLGETINTEGERVPROC glad_glGetIntegerv = NULL; +PFNGLGETMULTISAMPLEFVPROC glad_glGetMultisamplefv = NULL; +PFNGLGETPROGRAMINFOLOGPROC glad_glGetProgramInfoLog = NULL; +PFNGLGETPROGRAMIVPROC glad_glGetProgramiv = NULL; +PFNGLGETQUERYOBJECTI64VPROC glad_glGetQueryObjecti64v = NULL; +PFNGLGETQUERYOBJECTIVPROC glad_glGetQueryObjectiv = NULL; +PFNGLGETQUERYOBJECTUI64VPROC glad_glGetQueryObjectui64v = NULL; +PFNGLGETQUERYOBJECTUIVPROC glad_glGetQueryObjectuiv = NULL; +PFNGLGETQUERYIVPROC glad_glGetQueryiv = NULL; +PFNGLGETRENDERBUFFERPARAMETERIVPROC glad_glGetRenderbufferParameteriv = NULL; +PFNGLGETSAMPLERPARAMETERIIVPROC glad_glGetSamplerParameterIiv = NULL; +PFNGLGETSAMPLERPARAMETERIUIVPROC glad_glGetSamplerParameterIuiv = NULL; +PFNGLGETSAMPLERPARAMETERFVPROC glad_glGetSamplerParameterfv = NULL; +PFNGLGETSAMPLERPARAMETERIVPROC glad_glGetSamplerParameteriv = NULL; +PFNGLGETSHADERINFOLOGPROC glad_glGetShaderInfoLog = NULL; +PFNGLGETSHADERSOURCEPROC glad_glGetShaderSource = NULL; +PFNGLGETSHADERIVPROC glad_glGetShaderiv = NULL; +PFNGLGETSTRINGPROC glad_glGetString = NULL; +PFNGLGETSTRINGIPROC glad_glGetStringi = NULL; +PFNGLGETSYNCIVPROC glad_glGetSynciv = NULL; +PFNGLGETTEXIMAGEPROC glad_glGetTexImage = NULL; +PFNGLGETTEXLEVELPARAMETERFVPROC glad_glGetTexLevelParameterfv = NULL; +PFNGLGETTEXLEVELPARAMETERIVPROC glad_glGetTexLevelParameteriv = NULL; +PFNGLGETTEXPARAMETERIIVPROC glad_glGetTexParameterIiv = NULL; +PFNGLGETTEXPARAMETERIUIVPROC glad_glGetTexParameterIuiv = NULL; +PFNGLGETTEXPARAMETERFVPROC glad_glGetTexParameterfv = NULL; +PFNGLGETTEXPARAMETERIVPROC glad_glGetTexParameteriv = NULL; +PFNGLGETTRANSFORMFEEDBACKVARYINGPROC glad_glGetTransformFeedbackVarying = NULL; +PFNGLGETUNIFORMBLOCKINDEXPROC glad_glGetUniformBlockIndex = NULL; +PFNGLGETUNIFORMINDICESPROC glad_glGetUniformIndices = NULL; +PFNGLGETUNIFORMLOCATIONPROC glad_glGetUniformLocation = NULL; +PFNGLGETUNIFORMFVPROC glad_glGetUniformfv = NULL; +PFNGLGETUNIFORMIVPROC glad_glGetUniformiv = NULL; +PFNGLGETUNIFORMUIVPROC glad_glGetUniformuiv = NULL; +PFNGLGETVERTEXATTRIBIIVPROC glad_glGetVertexAttribIiv = NULL; +PFNGLGETVERTEXATTRIBIUIVPROC glad_glGetVertexAttribIuiv = NULL; +PFNGLGETVERTEXATTRIBPOINTERVPROC glad_glGetVertexAttribPointerv = NULL; +PFNGLGETVERTEXATTRIBDVPROC glad_glGetVertexAttribdv = NULL; +PFNGLGETVERTEXATTRIBFVPROC glad_glGetVertexAttribfv = NULL; +PFNGLGETVERTEXATTRIBIVPROC glad_glGetVertexAttribiv = NULL; +PFNGLHINTPROC glad_glHint = NULL; +PFNGLISBUFFERPROC glad_glIsBuffer = NULL; +PFNGLISENABLEDPROC glad_glIsEnabled = NULL; +PFNGLISENABLEDIPROC glad_glIsEnabledi = NULL; +PFNGLISFRAMEBUFFERPROC glad_glIsFramebuffer = NULL; +PFNGLISPROGRAMPROC glad_glIsProgram = NULL; +PFNGLISQUERYPROC glad_glIsQuery = NULL; +PFNGLISRENDERBUFFERPROC glad_glIsRenderbuffer = NULL; +PFNGLISSAMPLERPROC glad_glIsSampler = NULL; +PFNGLISSHADERPROC glad_glIsShader = NULL; +PFNGLISSYNCPROC glad_glIsSync = NULL; +PFNGLISTEXTUREPROC glad_glIsTexture = NULL; +PFNGLISVERTEXARRAYPROC glad_glIsVertexArray = NULL; +PFNGLLINEWIDTHPROC glad_glLineWidth = NULL; +PFNGLLINKPROGRAMPROC glad_glLinkProgram = NULL; +PFNGLLOGICOPPROC glad_glLogicOp = NULL; +PFNGLMAPBUFFERPROC glad_glMapBuffer = NULL; +PFNGLMAPBUFFERRANGEPROC glad_glMapBufferRange = NULL; +PFNGLMULTIDRAWARRAYSPROC glad_glMultiDrawArrays = NULL; +PFNGLMULTIDRAWELEMENTSPROC glad_glMultiDrawElements = NULL; +PFNGLMULTIDRAWELEMENTSBASEVERTEXPROC glad_glMultiDrawElementsBaseVertex = NULL; +PFNGLMULTITEXCOORDP1UIPROC glad_glMultiTexCoordP1ui = NULL; +PFNGLMULTITEXCOORDP1UIVPROC glad_glMultiTexCoordP1uiv = NULL; +PFNGLMULTITEXCOORDP2UIPROC glad_glMultiTexCoordP2ui = NULL; +PFNGLMULTITEXCOORDP2UIVPROC glad_glMultiTexCoordP2uiv = NULL; +PFNGLMULTITEXCOORDP3UIPROC glad_glMultiTexCoordP3ui = NULL; +PFNGLMULTITEXCOORDP3UIVPROC glad_glMultiTexCoordP3uiv = NULL; +PFNGLMULTITEXCOORDP4UIPROC glad_glMultiTexCoordP4ui = NULL; +PFNGLMULTITEXCOORDP4UIVPROC glad_glMultiTexCoordP4uiv = NULL; +PFNGLNORMALP3UIPROC glad_glNormalP3ui = NULL; +PFNGLNORMALP3UIVPROC glad_glNormalP3uiv = NULL; +PFNGLPIXELSTOREFPROC glad_glPixelStoref = NULL; +PFNGLPIXELSTOREIPROC glad_glPixelStorei = NULL; +PFNGLPOINTPARAMETERFPROC glad_glPointParameterf = NULL; +PFNGLPOINTPARAMETERFVPROC glad_glPointParameterfv = NULL; +PFNGLPOINTPARAMETERIPROC glad_glPointParameteri = NULL; +PFNGLPOINTPARAMETERIVPROC glad_glPointParameteriv = NULL; +PFNGLPOINTSIZEPROC glad_glPointSize = NULL; +PFNGLPOLYGONMODEPROC glad_glPolygonMode = NULL; +PFNGLPOLYGONOFFSETPROC glad_glPolygonOffset = NULL; +PFNGLPRIMITIVERESTARTINDEXPROC glad_glPrimitiveRestartIndex = NULL; +PFNGLPROVOKINGVERTEXPROC glad_glProvokingVertex = NULL; +PFNGLQUERYCOUNTERPROC glad_glQueryCounter = NULL; +PFNGLREADBUFFERPROC glad_glReadBuffer = NULL; +PFNGLREADPIXELSPROC glad_glReadPixels = NULL; +PFNGLRENDERBUFFERSTORAGEPROC glad_glRenderbufferStorage = NULL; +PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC glad_glRenderbufferStorageMultisample = NULL; +PFNGLSAMPLECOVERAGEPROC glad_glSampleCoverage = NULL; +PFNGLSAMPLEMASKIPROC glad_glSampleMaski = NULL; +PFNGLSAMPLERPARAMETERIIVPROC glad_glSamplerParameterIiv = NULL; +PFNGLSAMPLERPARAMETERIUIVPROC glad_glSamplerParameterIuiv = NULL; +PFNGLSAMPLERPARAMETERFPROC glad_glSamplerParameterf = NULL; +PFNGLSAMPLERPARAMETERFVPROC glad_glSamplerParameterfv = NULL; +PFNGLSAMPLERPARAMETERIPROC glad_glSamplerParameteri = NULL; +PFNGLSAMPLERPARAMETERIVPROC glad_glSamplerParameteriv = NULL; +PFNGLSCISSORPROC glad_glScissor = NULL; +PFNGLSECONDARYCOLORP3UIPROC glad_glSecondaryColorP3ui = NULL; +PFNGLSECONDARYCOLORP3UIVPROC glad_glSecondaryColorP3uiv = NULL; +PFNGLSHADERSOURCEPROC glad_glShaderSource = NULL; +PFNGLSTENCILFUNCPROC glad_glStencilFunc = NULL; +PFNGLSTENCILFUNCSEPARATEPROC glad_glStencilFuncSeparate = NULL; +PFNGLSTENCILMASKPROC glad_glStencilMask = NULL; +PFNGLSTENCILMASKSEPARATEPROC glad_glStencilMaskSeparate = NULL; +PFNGLSTENCILOPPROC glad_glStencilOp = NULL; +PFNGLSTENCILOPSEPARATEPROC glad_glStencilOpSeparate = NULL; +PFNGLTEXBUFFERPROC glad_glTexBuffer = NULL; +PFNGLTEXCOORDP1UIPROC glad_glTexCoordP1ui = NULL; +PFNGLTEXCOORDP1UIVPROC glad_glTexCoordP1uiv = NULL; +PFNGLTEXCOORDP2UIPROC glad_glTexCoordP2ui = NULL; +PFNGLTEXCOORDP2UIVPROC glad_glTexCoordP2uiv = NULL; +PFNGLTEXCOORDP3UIPROC glad_glTexCoordP3ui = NULL; +PFNGLTEXCOORDP3UIVPROC glad_glTexCoordP3uiv = NULL; +PFNGLTEXCOORDP4UIPROC glad_glTexCoordP4ui = NULL; +PFNGLTEXCOORDP4UIVPROC glad_glTexCoordP4uiv = NULL; +PFNGLTEXIMAGE1DPROC glad_glTexImage1D = NULL; +PFNGLTEXIMAGE2DPROC glad_glTexImage2D = NULL; +PFNGLTEXIMAGE2DMULTISAMPLEPROC glad_glTexImage2DMultisample = NULL; +PFNGLTEXIMAGE3DPROC glad_glTexImage3D = NULL; +PFNGLTEXIMAGE3DMULTISAMPLEPROC glad_glTexImage3DMultisample = NULL; +PFNGLTEXPARAMETERIIVPROC glad_glTexParameterIiv = NULL; +PFNGLTEXPARAMETERIUIVPROC glad_glTexParameterIuiv = NULL; +PFNGLTEXPARAMETERFPROC glad_glTexParameterf = NULL; +PFNGLTEXPARAMETERFVPROC glad_glTexParameterfv = NULL; +PFNGLTEXPARAMETERIPROC glad_glTexParameteri = NULL; +PFNGLTEXPARAMETERIVPROC glad_glTexParameteriv = NULL; +PFNGLTEXSUBIMAGE1DPROC glad_glTexSubImage1D = NULL; +PFNGLTEXSUBIMAGE2DPROC glad_glTexSubImage2D = NULL; +PFNGLTEXSUBIMAGE3DPROC glad_glTexSubImage3D = NULL; +PFNGLTRANSFORMFEEDBACKVARYINGSPROC glad_glTransformFeedbackVaryings = NULL; +PFNGLUNIFORM1FPROC glad_glUniform1f = NULL; +PFNGLUNIFORM1FVPROC glad_glUniform1fv = NULL; +PFNGLUNIFORM1IPROC glad_glUniform1i = NULL; +PFNGLUNIFORM1IVPROC glad_glUniform1iv = NULL; +PFNGLUNIFORM1UIPROC glad_glUniform1ui = NULL; +PFNGLUNIFORM1UIVPROC glad_glUniform1uiv = NULL; +PFNGLUNIFORM2FPROC glad_glUniform2f = NULL; +PFNGLUNIFORM2FVPROC glad_glUniform2fv = NULL; +PFNGLUNIFORM2IPROC glad_glUniform2i = NULL; +PFNGLUNIFORM2IVPROC glad_glUniform2iv = NULL; +PFNGLUNIFORM2UIPROC glad_glUniform2ui = NULL; +PFNGLUNIFORM2UIVPROC glad_glUniform2uiv = NULL; +PFNGLUNIFORM3FPROC glad_glUniform3f = NULL; +PFNGLUNIFORM3FVPROC glad_glUniform3fv = NULL; +PFNGLUNIFORM3IPROC glad_glUniform3i = NULL; +PFNGLUNIFORM3IVPROC glad_glUniform3iv = NULL; +PFNGLUNIFORM3UIPROC glad_glUniform3ui = NULL; +PFNGLUNIFORM3UIVPROC glad_glUniform3uiv = NULL; +PFNGLUNIFORM4FPROC glad_glUniform4f = NULL; +PFNGLUNIFORM4FVPROC glad_glUniform4fv = NULL; +PFNGLUNIFORM4IPROC glad_glUniform4i = NULL; +PFNGLUNIFORM4IVPROC glad_glUniform4iv = NULL; +PFNGLUNIFORM4UIPROC glad_glUniform4ui = NULL; +PFNGLUNIFORM4UIVPROC glad_glUniform4uiv = NULL; +PFNGLUNIFORMBLOCKBINDINGPROC glad_glUniformBlockBinding = NULL; +PFNGLUNIFORMMATRIX2FVPROC glad_glUniformMatrix2fv = NULL; +PFNGLUNIFORMMATRIX2X3FVPROC glad_glUniformMatrix2x3fv = NULL; +PFNGLUNIFORMMATRIX2X4FVPROC glad_glUniformMatrix2x4fv = NULL; +PFNGLUNIFORMMATRIX3FVPROC glad_glUniformMatrix3fv = NULL; +PFNGLUNIFORMMATRIX3X2FVPROC glad_glUniformMatrix3x2fv = NULL; +PFNGLUNIFORMMATRIX3X4FVPROC glad_glUniformMatrix3x4fv = NULL; +PFNGLUNIFORMMATRIX4FVPROC glad_glUniformMatrix4fv = NULL; +PFNGLUNIFORMMATRIX4X2FVPROC glad_glUniformMatrix4x2fv = NULL; +PFNGLUNIFORMMATRIX4X3FVPROC glad_glUniformMatrix4x3fv = NULL; +PFNGLUNMAPBUFFERPROC glad_glUnmapBuffer = NULL; +PFNGLUSEPROGRAMPROC glad_glUseProgram = NULL; +PFNGLVALIDATEPROGRAMPROC glad_glValidateProgram = NULL; +PFNGLVERTEXATTRIB1DPROC glad_glVertexAttrib1d = NULL; +PFNGLVERTEXATTRIB1DVPROC glad_glVertexAttrib1dv = NULL; +PFNGLVERTEXATTRIB1FPROC glad_glVertexAttrib1f = NULL; +PFNGLVERTEXATTRIB1FVPROC glad_glVertexAttrib1fv = NULL; +PFNGLVERTEXATTRIB1SPROC glad_glVertexAttrib1s = NULL; +PFNGLVERTEXATTRIB1SVPROC glad_glVertexAttrib1sv = NULL; +PFNGLVERTEXATTRIB2DPROC glad_glVertexAttrib2d = NULL; +PFNGLVERTEXATTRIB2DVPROC glad_glVertexAttrib2dv = NULL; +PFNGLVERTEXATTRIB2FPROC glad_glVertexAttrib2f = NULL; +PFNGLVERTEXATTRIB2FVPROC glad_glVertexAttrib2fv = NULL; +PFNGLVERTEXATTRIB2SPROC glad_glVertexAttrib2s = NULL; +PFNGLVERTEXATTRIB2SVPROC glad_glVertexAttrib2sv = NULL; +PFNGLVERTEXATTRIB3DPROC glad_glVertexAttrib3d = NULL; +PFNGLVERTEXATTRIB3DVPROC glad_glVertexAttrib3dv = NULL; +PFNGLVERTEXATTRIB3FPROC glad_glVertexAttrib3f = NULL; +PFNGLVERTEXATTRIB3FVPROC glad_glVertexAttrib3fv = NULL; +PFNGLVERTEXATTRIB3SPROC glad_glVertexAttrib3s = NULL; +PFNGLVERTEXATTRIB3SVPROC glad_glVertexAttrib3sv = NULL; +PFNGLVERTEXATTRIB4NBVPROC glad_glVertexAttrib4Nbv = NULL; +PFNGLVERTEXATTRIB4NIVPROC glad_glVertexAttrib4Niv = NULL; +PFNGLVERTEXATTRIB4NSVPROC glad_glVertexAttrib4Nsv = NULL; +PFNGLVERTEXATTRIB4NUBPROC glad_glVertexAttrib4Nub = NULL; +PFNGLVERTEXATTRIB4NUBVPROC glad_glVertexAttrib4Nubv = NULL; +PFNGLVERTEXATTRIB4NUIVPROC glad_glVertexAttrib4Nuiv = NULL; +PFNGLVERTEXATTRIB4NUSVPROC glad_glVertexAttrib4Nusv = NULL; +PFNGLVERTEXATTRIB4BVPROC glad_glVertexAttrib4bv = NULL; +PFNGLVERTEXATTRIB4DPROC glad_glVertexAttrib4d = NULL; +PFNGLVERTEXATTRIB4DVPROC glad_glVertexAttrib4dv = NULL; +PFNGLVERTEXATTRIB4FPROC glad_glVertexAttrib4f = NULL; +PFNGLVERTEXATTRIB4FVPROC glad_glVertexAttrib4fv = NULL; +PFNGLVERTEXATTRIB4IVPROC glad_glVertexAttrib4iv = NULL; +PFNGLVERTEXATTRIB4SPROC glad_glVertexAttrib4s = NULL; +PFNGLVERTEXATTRIB4SVPROC glad_glVertexAttrib4sv = NULL; +PFNGLVERTEXATTRIB4UBVPROC glad_glVertexAttrib4ubv = NULL; +PFNGLVERTEXATTRIB4UIVPROC glad_glVertexAttrib4uiv = NULL; +PFNGLVERTEXATTRIB4USVPROC glad_glVertexAttrib4usv = NULL; +PFNGLVERTEXATTRIBDIVISORPROC glad_glVertexAttribDivisor = NULL; +PFNGLVERTEXATTRIBI1IPROC glad_glVertexAttribI1i = NULL; +PFNGLVERTEXATTRIBI1IVPROC glad_glVertexAttribI1iv = NULL; +PFNGLVERTEXATTRIBI1UIPROC glad_glVertexAttribI1ui = NULL; +PFNGLVERTEXATTRIBI1UIVPROC glad_glVertexAttribI1uiv = NULL; +PFNGLVERTEXATTRIBI2IPROC glad_glVertexAttribI2i = NULL; +PFNGLVERTEXATTRIBI2IVPROC glad_glVertexAttribI2iv = NULL; +PFNGLVERTEXATTRIBI2UIPROC glad_glVertexAttribI2ui = NULL; +PFNGLVERTEXATTRIBI2UIVPROC glad_glVertexAttribI2uiv = NULL; +PFNGLVERTEXATTRIBI3IPROC glad_glVertexAttribI3i = NULL; +PFNGLVERTEXATTRIBI3IVPROC glad_glVertexAttribI3iv = NULL; +PFNGLVERTEXATTRIBI3UIPROC glad_glVertexAttribI3ui = NULL; +PFNGLVERTEXATTRIBI3UIVPROC glad_glVertexAttribI3uiv = NULL; +PFNGLVERTEXATTRIBI4BVPROC glad_glVertexAttribI4bv = NULL; +PFNGLVERTEXATTRIBI4IPROC glad_glVertexAttribI4i = NULL; +PFNGLVERTEXATTRIBI4IVPROC glad_glVertexAttribI4iv = NULL; +PFNGLVERTEXATTRIBI4SVPROC glad_glVertexAttribI4sv = NULL; +PFNGLVERTEXATTRIBI4UBVPROC glad_glVertexAttribI4ubv = NULL; +PFNGLVERTEXATTRIBI4UIPROC glad_glVertexAttribI4ui = NULL; +PFNGLVERTEXATTRIBI4UIVPROC glad_glVertexAttribI4uiv = NULL; +PFNGLVERTEXATTRIBI4USVPROC glad_glVertexAttribI4usv = NULL; +PFNGLVERTEXATTRIBIPOINTERPROC glad_glVertexAttribIPointer = NULL; +PFNGLVERTEXATTRIBP1UIPROC glad_glVertexAttribP1ui = NULL; +PFNGLVERTEXATTRIBP1UIVPROC glad_glVertexAttribP1uiv = NULL; +PFNGLVERTEXATTRIBP2UIPROC glad_glVertexAttribP2ui = NULL; +PFNGLVERTEXATTRIBP2UIVPROC glad_glVertexAttribP2uiv = NULL; +PFNGLVERTEXATTRIBP3UIPROC glad_glVertexAttribP3ui = NULL; +PFNGLVERTEXATTRIBP3UIVPROC glad_glVertexAttribP3uiv = NULL; +PFNGLVERTEXATTRIBP4UIPROC glad_glVertexAttribP4ui = NULL; +PFNGLVERTEXATTRIBP4UIVPROC glad_glVertexAttribP4uiv = NULL; +PFNGLVERTEXATTRIBPOINTERPROC glad_glVertexAttribPointer = NULL; +PFNGLVERTEXP2UIPROC glad_glVertexP2ui = NULL; +PFNGLVERTEXP2UIVPROC glad_glVertexP2uiv = NULL; +PFNGLVERTEXP3UIPROC glad_glVertexP3ui = NULL; +PFNGLVERTEXP3UIVPROC glad_glVertexP3uiv = NULL; +PFNGLVERTEXP4UIPROC glad_glVertexP4ui = NULL; +PFNGLVERTEXP4UIVPROC glad_glVertexP4uiv = NULL; +PFNGLVIEWPORTPROC glad_glViewport = NULL; +PFNGLWAITSYNCPROC glad_glWaitSync = NULL; +static void load_GL_VERSION_1_0(GLADloadproc load) { + if(!GLAD_GL_VERSION_1_0) return; + glad_glCullFace = (PFNGLCULLFACEPROC)load("glCullFace"); + glad_glFrontFace = (PFNGLFRONTFACEPROC)load("glFrontFace"); + glad_glHint = (PFNGLHINTPROC)load("glHint"); + glad_glLineWidth = (PFNGLLINEWIDTHPROC)load("glLineWidth"); + glad_glPointSize = (PFNGLPOINTSIZEPROC)load("glPointSize"); + glad_glPolygonMode = (PFNGLPOLYGONMODEPROC)load("glPolygonMode"); + glad_glScissor = (PFNGLSCISSORPROC)load("glScissor"); + glad_glTexParameterf = (PFNGLTEXPARAMETERFPROC)load("glTexParameterf"); + glad_glTexParameterfv = (PFNGLTEXPARAMETERFVPROC)load("glTexParameterfv"); + glad_glTexParameteri = (PFNGLTEXPARAMETERIPROC)load("glTexParameteri"); + glad_glTexParameteriv = (PFNGLTEXPARAMETERIVPROC)load("glTexParameteriv"); + glad_glTexImage1D = (PFNGLTEXIMAGE1DPROC)load("glTexImage1D"); + glad_glTexImage2D = (PFNGLTEXIMAGE2DPROC)load("glTexImage2D"); + glad_glDrawBuffer = (PFNGLDRAWBUFFERPROC)load("glDrawBuffer"); + glad_glClear = (PFNGLCLEARPROC)load("glClear"); + glad_glClearColor = (PFNGLCLEARCOLORPROC)load("glClearColor"); + glad_glClearStencil = (PFNGLCLEARSTENCILPROC)load("glClearStencil"); + glad_glClearDepth = (PFNGLCLEARDEPTHPROC)load("glClearDepth"); + glad_glStencilMask = (PFNGLSTENCILMASKPROC)load("glStencilMask"); + glad_glColorMask = (PFNGLCOLORMASKPROC)load("glColorMask"); + glad_glDepthMask = (PFNGLDEPTHMASKPROC)load("glDepthMask"); + glad_glDisable = (PFNGLDISABLEPROC)load("glDisable"); + glad_glEnable = (PFNGLENABLEPROC)load("glEnable"); + glad_glFinish = (PFNGLFINISHPROC)load("glFinish"); + glad_glFlush = (PFNGLFLUSHPROC)load("glFlush"); + glad_glBlendFunc = (PFNGLBLENDFUNCPROC)load("glBlendFunc"); + glad_glLogicOp = (PFNGLLOGICOPPROC)load("glLogicOp"); + glad_glStencilFunc = (PFNGLSTENCILFUNCPROC)load("glStencilFunc"); + glad_glStencilOp = (PFNGLSTENCILOPPROC)load("glStencilOp"); + glad_glDepthFunc = (PFNGLDEPTHFUNCPROC)load("glDepthFunc"); + glad_glPixelStoref = (PFNGLPIXELSTOREFPROC)load("glPixelStoref"); + glad_glPixelStorei = (PFNGLPIXELSTOREIPROC)load("glPixelStorei"); + glad_glReadBuffer = (PFNGLREADBUFFERPROC)load("glReadBuffer"); + glad_glReadPixels = (PFNGLREADPIXELSPROC)load("glReadPixels"); + glad_glGetBooleanv = (PFNGLGETBOOLEANVPROC)load("glGetBooleanv"); + glad_glGetDoublev = (PFNGLGETDOUBLEVPROC)load("glGetDoublev"); + glad_glGetError = (PFNGLGETERRORPROC)load("glGetError"); + glad_glGetFloatv = (PFNGLGETFLOATVPROC)load("glGetFloatv"); + glad_glGetIntegerv = (PFNGLGETINTEGERVPROC)load("glGetIntegerv"); + glad_glGetString = (PFNGLGETSTRINGPROC)load("glGetString"); + glad_glGetTexImage = (PFNGLGETTEXIMAGEPROC)load("glGetTexImage"); + glad_glGetTexParameterfv = (PFNGLGETTEXPARAMETERFVPROC)load("glGetTexParameterfv"); + glad_glGetTexParameteriv = (PFNGLGETTEXPARAMETERIVPROC)load("glGetTexParameteriv"); + glad_glGetTexLevelParameterfv = (PFNGLGETTEXLEVELPARAMETERFVPROC)load("glGetTexLevelParameterfv"); + glad_glGetTexLevelParameteriv = (PFNGLGETTEXLEVELPARAMETERIVPROC)load("glGetTexLevelParameteriv"); + glad_glIsEnabled = (PFNGLISENABLEDPROC)load("glIsEnabled"); + glad_glDepthRange = (PFNGLDEPTHRANGEPROC)load("glDepthRange"); + glad_glViewport = (PFNGLVIEWPORTPROC)load("glViewport"); +} +static void load_GL_VERSION_1_1(GLADloadproc load) { + if(!GLAD_GL_VERSION_1_1) return; + glad_glDrawArrays = (PFNGLDRAWARRAYSPROC)load("glDrawArrays"); + glad_glDrawElements = (PFNGLDRAWELEMENTSPROC)load("glDrawElements"); + glad_glPolygonOffset = (PFNGLPOLYGONOFFSETPROC)load("glPolygonOffset"); + glad_glCopyTexImage1D = (PFNGLCOPYTEXIMAGE1DPROC)load("glCopyTexImage1D"); + glad_glCopyTexImage2D = (PFNGLCOPYTEXIMAGE2DPROC)load("glCopyTexImage2D"); + glad_glCopyTexSubImage1D = (PFNGLCOPYTEXSUBIMAGE1DPROC)load("glCopyTexSubImage1D"); + glad_glCopyTexSubImage2D = (PFNGLCOPYTEXSUBIMAGE2DPROC)load("glCopyTexSubImage2D"); + glad_glTexSubImage1D = (PFNGLTEXSUBIMAGE1DPROC)load("glTexSubImage1D"); + glad_glTexSubImage2D = (PFNGLTEXSUBIMAGE2DPROC)load("glTexSubImage2D"); + glad_glBindTexture = (PFNGLBINDTEXTUREPROC)load("glBindTexture"); + glad_glDeleteTextures = (PFNGLDELETETEXTURESPROC)load("glDeleteTextures"); + glad_glGenTextures = (PFNGLGENTEXTURESPROC)load("glGenTextures"); + glad_glIsTexture = (PFNGLISTEXTUREPROC)load("glIsTexture"); +} +static void load_GL_VERSION_1_2(GLADloadproc load) { + if(!GLAD_GL_VERSION_1_2) return; + glad_glDrawRangeElements = (PFNGLDRAWRANGEELEMENTSPROC)load("glDrawRangeElements"); + glad_glTexImage3D = (PFNGLTEXIMAGE3DPROC)load("glTexImage3D"); + glad_glTexSubImage3D = (PFNGLTEXSUBIMAGE3DPROC)load("glTexSubImage3D"); + glad_glCopyTexSubImage3D = (PFNGLCOPYTEXSUBIMAGE3DPROC)load("glCopyTexSubImage3D"); +} +static void load_GL_VERSION_1_3(GLADloadproc load) { + if(!GLAD_GL_VERSION_1_3) return; + glad_glActiveTexture = (PFNGLACTIVETEXTUREPROC)load("glActiveTexture"); + glad_glSampleCoverage = (PFNGLSAMPLECOVERAGEPROC)load("glSampleCoverage"); + glad_glCompressedTexImage3D = (PFNGLCOMPRESSEDTEXIMAGE3DPROC)load("glCompressedTexImage3D"); + glad_glCompressedTexImage2D = (PFNGLCOMPRESSEDTEXIMAGE2DPROC)load("glCompressedTexImage2D"); + glad_glCompressedTexImage1D = (PFNGLCOMPRESSEDTEXIMAGE1DPROC)load("glCompressedTexImage1D"); + glad_glCompressedTexSubImage3D = (PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC)load("glCompressedTexSubImage3D"); + glad_glCompressedTexSubImage2D = (PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC)load("glCompressedTexSubImage2D"); + glad_glCompressedTexSubImage1D = (PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC)load("glCompressedTexSubImage1D"); + glad_glGetCompressedTexImage = (PFNGLGETCOMPRESSEDTEXIMAGEPROC)load("glGetCompressedTexImage"); +} +static void load_GL_VERSION_1_4(GLADloadproc load) { + if(!GLAD_GL_VERSION_1_4) return; + glad_glBlendFuncSeparate = (PFNGLBLENDFUNCSEPARATEPROC)load("glBlendFuncSeparate"); + glad_glMultiDrawArrays = (PFNGLMULTIDRAWARRAYSPROC)load("glMultiDrawArrays"); + glad_glMultiDrawElements = (PFNGLMULTIDRAWELEMENTSPROC)load("glMultiDrawElements"); + glad_glPointParameterf = (PFNGLPOINTPARAMETERFPROC)load("glPointParameterf"); + glad_glPointParameterfv = (PFNGLPOINTPARAMETERFVPROC)load("glPointParameterfv"); + glad_glPointParameteri = (PFNGLPOINTPARAMETERIPROC)load("glPointParameteri"); + glad_glPointParameteriv = (PFNGLPOINTPARAMETERIVPROC)load("glPointParameteriv"); + glad_glBlendColor = (PFNGLBLENDCOLORPROC)load("glBlendColor"); + glad_glBlendEquation = (PFNGLBLENDEQUATIONPROC)load("glBlendEquation"); +} +static void load_GL_VERSION_1_5(GLADloadproc load) { + if(!GLAD_GL_VERSION_1_5) return; + glad_glGenQueries = (PFNGLGENQUERIESPROC)load("glGenQueries"); + glad_glDeleteQueries = (PFNGLDELETEQUERIESPROC)load("glDeleteQueries"); + glad_glIsQuery = (PFNGLISQUERYPROC)load("glIsQuery"); + glad_glBeginQuery = (PFNGLBEGINQUERYPROC)load("glBeginQuery"); + glad_glEndQuery = (PFNGLENDQUERYPROC)load("glEndQuery"); + glad_glGetQueryiv = (PFNGLGETQUERYIVPROC)load("glGetQueryiv"); + glad_glGetQueryObjectiv = (PFNGLGETQUERYOBJECTIVPROC)load("glGetQueryObjectiv"); + glad_glGetQueryObjectuiv = (PFNGLGETQUERYOBJECTUIVPROC)load("glGetQueryObjectuiv"); + glad_glBindBuffer = (PFNGLBINDBUFFERPROC)load("glBindBuffer"); + glad_glDeleteBuffers = (PFNGLDELETEBUFFERSPROC)load("glDeleteBuffers"); + glad_glGenBuffers = (PFNGLGENBUFFERSPROC)load("glGenBuffers"); + glad_glIsBuffer = (PFNGLISBUFFERPROC)load("glIsBuffer"); + glad_glBufferData = (PFNGLBUFFERDATAPROC)load("glBufferData"); + glad_glBufferSubData = (PFNGLBUFFERSUBDATAPROC)load("glBufferSubData"); + glad_glGetBufferSubData = (PFNGLGETBUFFERSUBDATAPROC)load("glGetBufferSubData"); + glad_glMapBuffer = (PFNGLMAPBUFFERPROC)load("glMapBuffer"); + glad_glUnmapBuffer = (PFNGLUNMAPBUFFERPROC)load("glUnmapBuffer"); + glad_glGetBufferParameteriv = (PFNGLGETBUFFERPARAMETERIVPROC)load("glGetBufferParameteriv"); + glad_glGetBufferPointerv = (PFNGLGETBUFFERPOINTERVPROC)load("glGetBufferPointerv"); +} +static void load_GL_VERSION_2_0(GLADloadproc load) { + if(!GLAD_GL_VERSION_2_0) return; + glad_glBlendEquationSeparate = (PFNGLBLENDEQUATIONSEPARATEPROC)load("glBlendEquationSeparate"); + glad_glDrawBuffers = (PFNGLDRAWBUFFERSPROC)load("glDrawBuffers"); + glad_glStencilOpSeparate = (PFNGLSTENCILOPSEPARATEPROC)load("glStencilOpSeparate"); + glad_glStencilFuncSeparate = (PFNGLSTENCILFUNCSEPARATEPROC)load("glStencilFuncSeparate"); + glad_glStencilMaskSeparate = (PFNGLSTENCILMASKSEPARATEPROC)load("glStencilMaskSeparate"); + glad_glAttachShader = (PFNGLATTACHSHADERPROC)load("glAttachShader"); + glad_glBindAttribLocation = (PFNGLBINDATTRIBLOCATIONPROC)load("glBindAttribLocation"); + glad_glCompileShader = (PFNGLCOMPILESHADERPROC)load("glCompileShader"); + glad_glCreateProgram = (PFNGLCREATEPROGRAMPROC)load("glCreateProgram"); + glad_glCreateShader = (PFNGLCREATESHADERPROC)load("glCreateShader"); + glad_glDeleteProgram = (PFNGLDELETEPROGRAMPROC)load("glDeleteProgram"); + glad_glDeleteShader = (PFNGLDELETESHADERPROC)load("glDeleteShader"); + glad_glDetachShader = (PFNGLDETACHSHADERPROC)load("glDetachShader"); + glad_glDisableVertexAttribArray = (PFNGLDISABLEVERTEXATTRIBARRAYPROC)load("glDisableVertexAttribArray"); + glad_glEnableVertexAttribArray = (PFNGLENABLEVERTEXATTRIBARRAYPROC)load("glEnableVertexAttribArray"); + glad_glGetActiveAttrib = (PFNGLGETACTIVEATTRIBPROC)load("glGetActiveAttrib"); + glad_glGetActiveUniform = (PFNGLGETACTIVEUNIFORMPROC)load("glGetActiveUniform"); + glad_glGetAttachedShaders = (PFNGLGETATTACHEDSHADERSPROC)load("glGetAttachedShaders"); + glad_glGetAttribLocation = (PFNGLGETATTRIBLOCATIONPROC)load("glGetAttribLocation"); + glad_glGetProgramiv = (PFNGLGETPROGRAMIVPROC)load("glGetProgramiv"); + glad_glGetProgramInfoLog = (PFNGLGETPROGRAMINFOLOGPROC)load("glGetProgramInfoLog"); + glad_glGetShaderiv = (PFNGLGETSHADERIVPROC)load("glGetShaderiv"); + glad_glGetShaderInfoLog = (PFNGLGETSHADERINFOLOGPROC)load("glGetShaderInfoLog"); + glad_glGetShaderSource = (PFNGLGETSHADERSOURCEPROC)load("glGetShaderSource"); + glad_glGetUniformLocation = (PFNGLGETUNIFORMLOCATIONPROC)load("glGetUniformLocation"); + glad_glGetUniformfv = (PFNGLGETUNIFORMFVPROC)load("glGetUniformfv"); + glad_glGetUniformiv = (PFNGLGETUNIFORMIVPROC)load("glGetUniformiv"); + glad_glGetVertexAttribdv = (PFNGLGETVERTEXATTRIBDVPROC)load("glGetVertexAttribdv"); + glad_glGetVertexAttribfv = (PFNGLGETVERTEXATTRIBFVPROC)load("glGetVertexAttribfv"); + glad_glGetVertexAttribiv = (PFNGLGETVERTEXATTRIBIVPROC)load("glGetVertexAttribiv"); + glad_glGetVertexAttribPointerv = (PFNGLGETVERTEXATTRIBPOINTERVPROC)load("glGetVertexAttribPointerv"); + glad_glIsProgram = (PFNGLISPROGRAMPROC)load("glIsProgram"); + glad_glIsShader = (PFNGLISSHADERPROC)load("glIsShader"); + glad_glLinkProgram = (PFNGLLINKPROGRAMPROC)load("glLinkProgram"); + glad_glShaderSource = (PFNGLSHADERSOURCEPROC)load("glShaderSource"); + glad_glUseProgram = (PFNGLUSEPROGRAMPROC)load("glUseProgram"); + glad_glUniform1f = (PFNGLUNIFORM1FPROC)load("glUniform1f"); + glad_glUniform2f = (PFNGLUNIFORM2FPROC)load("glUniform2f"); + glad_glUniform3f = (PFNGLUNIFORM3FPROC)load("glUniform3f"); + glad_glUniform4f = (PFNGLUNIFORM4FPROC)load("glUniform4f"); + glad_glUniform1i = (PFNGLUNIFORM1IPROC)load("glUniform1i"); + glad_glUniform2i = (PFNGLUNIFORM2IPROC)load("glUniform2i"); + glad_glUniform3i = (PFNGLUNIFORM3IPROC)load("glUniform3i"); + glad_glUniform4i = (PFNGLUNIFORM4IPROC)load("glUniform4i"); + glad_glUniform1fv = (PFNGLUNIFORM1FVPROC)load("glUniform1fv"); + glad_glUniform2fv = (PFNGLUNIFORM2FVPROC)load("glUniform2fv"); + glad_glUniform3fv = (PFNGLUNIFORM3FVPROC)load("glUniform3fv"); + glad_glUniform4fv = (PFNGLUNIFORM4FVPROC)load("glUniform4fv"); + glad_glUniform1iv = (PFNGLUNIFORM1IVPROC)load("glUniform1iv"); + glad_glUniform2iv = (PFNGLUNIFORM2IVPROC)load("glUniform2iv"); + glad_glUniform3iv = (PFNGLUNIFORM3IVPROC)load("glUniform3iv"); + glad_glUniform4iv = (PFNGLUNIFORM4IVPROC)load("glUniform4iv"); + glad_glUniformMatrix2fv = (PFNGLUNIFORMMATRIX2FVPROC)load("glUniformMatrix2fv"); + glad_glUniformMatrix3fv = (PFNGLUNIFORMMATRIX3FVPROC)load("glUniformMatrix3fv"); + glad_glUniformMatrix4fv = (PFNGLUNIFORMMATRIX4FVPROC)load("glUniformMatrix4fv"); + glad_glValidateProgram = (PFNGLVALIDATEPROGRAMPROC)load("glValidateProgram"); + glad_glVertexAttrib1d = (PFNGLVERTEXATTRIB1DPROC)load("glVertexAttrib1d"); + glad_glVertexAttrib1dv = (PFNGLVERTEXATTRIB1DVPROC)load("glVertexAttrib1dv"); + glad_glVertexAttrib1f = (PFNGLVERTEXATTRIB1FPROC)load("glVertexAttrib1f"); + glad_glVertexAttrib1fv = (PFNGLVERTEXATTRIB1FVPROC)load("glVertexAttrib1fv"); + glad_glVertexAttrib1s = (PFNGLVERTEXATTRIB1SPROC)load("glVertexAttrib1s"); + glad_glVertexAttrib1sv = (PFNGLVERTEXATTRIB1SVPROC)load("glVertexAttrib1sv"); + glad_glVertexAttrib2d = (PFNGLVERTEXATTRIB2DPROC)load("glVertexAttrib2d"); + glad_glVertexAttrib2dv = (PFNGLVERTEXATTRIB2DVPROC)load("glVertexAttrib2dv"); + glad_glVertexAttrib2f = (PFNGLVERTEXATTRIB2FPROC)load("glVertexAttrib2f"); + glad_glVertexAttrib2fv = (PFNGLVERTEXATTRIB2FVPROC)load("glVertexAttrib2fv"); + glad_glVertexAttrib2s = (PFNGLVERTEXATTRIB2SPROC)load("glVertexAttrib2s"); + glad_glVertexAttrib2sv = (PFNGLVERTEXATTRIB2SVPROC)load("glVertexAttrib2sv"); + glad_glVertexAttrib3d = (PFNGLVERTEXATTRIB3DPROC)load("glVertexAttrib3d"); + glad_glVertexAttrib3dv = (PFNGLVERTEXATTRIB3DVPROC)load("glVertexAttrib3dv"); + glad_glVertexAttrib3f = (PFNGLVERTEXATTRIB3FPROC)load("glVertexAttrib3f"); + glad_glVertexAttrib3fv = (PFNGLVERTEXATTRIB3FVPROC)load("glVertexAttrib3fv"); + glad_glVertexAttrib3s = (PFNGLVERTEXATTRIB3SPROC)load("glVertexAttrib3s"); + glad_glVertexAttrib3sv = (PFNGLVERTEXATTRIB3SVPROC)load("glVertexAttrib3sv"); + glad_glVertexAttrib4Nbv = (PFNGLVERTEXATTRIB4NBVPROC)load("glVertexAttrib4Nbv"); + glad_glVertexAttrib4Niv = (PFNGLVERTEXATTRIB4NIVPROC)load("glVertexAttrib4Niv"); + glad_glVertexAttrib4Nsv = (PFNGLVERTEXATTRIB4NSVPROC)load("glVertexAttrib4Nsv"); + glad_glVertexAttrib4Nub = (PFNGLVERTEXATTRIB4NUBPROC)load("glVertexAttrib4Nub"); + glad_glVertexAttrib4Nubv = (PFNGLVERTEXATTRIB4NUBVPROC)load("glVertexAttrib4Nubv"); + glad_glVertexAttrib4Nuiv = (PFNGLVERTEXATTRIB4NUIVPROC)load("glVertexAttrib4Nuiv"); + glad_glVertexAttrib4Nusv = (PFNGLVERTEXATTRIB4NUSVPROC)load("glVertexAttrib4Nusv"); + glad_glVertexAttrib4bv = (PFNGLVERTEXATTRIB4BVPROC)load("glVertexAttrib4bv"); + glad_glVertexAttrib4d = (PFNGLVERTEXATTRIB4DPROC)load("glVertexAttrib4d"); + glad_glVertexAttrib4dv = (PFNGLVERTEXATTRIB4DVPROC)load("glVertexAttrib4dv"); + glad_glVertexAttrib4f = (PFNGLVERTEXATTRIB4FPROC)load("glVertexAttrib4f"); + glad_glVertexAttrib4fv = (PFNGLVERTEXATTRIB4FVPROC)load("glVertexAttrib4fv"); + glad_glVertexAttrib4iv = (PFNGLVERTEXATTRIB4IVPROC)load("glVertexAttrib4iv"); + glad_glVertexAttrib4s = (PFNGLVERTEXATTRIB4SPROC)load("glVertexAttrib4s"); + glad_glVertexAttrib4sv = (PFNGLVERTEXATTRIB4SVPROC)load("glVertexAttrib4sv"); + glad_glVertexAttrib4ubv = (PFNGLVERTEXATTRIB4UBVPROC)load("glVertexAttrib4ubv"); + glad_glVertexAttrib4uiv = (PFNGLVERTEXATTRIB4UIVPROC)load("glVertexAttrib4uiv"); + glad_glVertexAttrib4usv = (PFNGLVERTEXATTRIB4USVPROC)load("glVertexAttrib4usv"); + glad_glVertexAttribPointer = (PFNGLVERTEXATTRIBPOINTERPROC)load("glVertexAttribPointer"); +} +static void load_GL_VERSION_2_1(GLADloadproc load) { + if(!GLAD_GL_VERSION_2_1) return; + glad_glUniformMatrix2x3fv = (PFNGLUNIFORMMATRIX2X3FVPROC)load("glUniformMatrix2x3fv"); + glad_glUniformMatrix3x2fv = (PFNGLUNIFORMMATRIX3X2FVPROC)load("glUniformMatrix3x2fv"); + glad_glUniformMatrix2x4fv = (PFNGLUNIFORMMATRIX2X4FVPROC)load("glUniformMatrix2x4fv"); + glad_glUniformMatrix4x2fv = (PFNGLUNIFORMMATRIX4X2FVPROC)load("glUniformMatrix4x2fv"); + glad_glUniformMatrix3x4fv = (PFNGLUNIFORMMATRIX3X4FVPROC)load("glUniformMatrix3x4fv"); + glad_glUniformMatrix4x3fv = (PFNGLUNIFORMMATRIX4X3FVPROC)load("glUniformMatrix4x3fv"); +} +static void load_GL_VERSION_3_0(GLADloadproc load) { + if(!GLAD_GL_VERSION_3_0) return; + glad_glColorMaski = (PFNGLCOLORMASKIPROC)load("glColorMaski"); + glad_glGetBooleani_v = (PFNGLGETBOOLEANI_VPROC)load("glGetBooleani_v"); + glad_glGetIntegeri_v = (PFNGLGETINTEGERI_VPROC)load("glGetIntegeri_v"); + glad_glEnablei = (PFNGLENABLEIPROC)load("glEnablei"); + glad_glDisablei = (PFNGLDISABLEIPROC)load("glDisablei"); + glad_glIsEnabledi = (PFNGLISENABLEDIPROC)load("glIsEnabledi"); + glad_glBeginTransformFeedback = (PFNGLBEGINTRANSFORMFEEDBACKPROC)load("glBeginTransformFeedback"); + glad_glEndTransformFeedback = (PFNGLENDTRANSFORMFEEDBACKPROC)load("glEndTransformFeedback"); + glad_glBindBufferRange = (PFNGLBINDBUFFERRANGEPROC)load("glBindBufferRange"); + glad_glBindBufferBase = (PFNGLBINDBUFFERBASEPROC)load("glBindBufferBase"); + glad_glTransformFeedbackVaryings = (PFNGLTRANSFORMFEEDBACKVARYINGSPROC)load("glTransformFeedbackVaryings"); + glad_glGetTransformFeedbackVarying = (PFNGLGETTRANSFORMFEEDBACKVARYINGPROC)load("glGetTransformFeedbackVarying"); + glad_glClampColor = (PFNGLCLAMPCOLORPROC)load("glClampColor"); + glad_glBeginConditionalRender = (PFNGLBEGINCONDITIONALRENDERPROC)load("glBeginConditionalRender"); + glad_glEndConditionalRender = (PFNGLENDCONDITIONALRENDERPROC)load("glEndConditionalRender"); + glad_glVertexAttribIPointer = (PFNGLVERTEXATTRIBIPOINTERPROC)load("glVertexAttribIPointer"); + glad_glGetVertexAttribIiv = (PFNGLGETVERTEXATTRIBIIVPROC)load("glGetVertexAttribIiv"); + glad_glGetVertexAttribIuiv = (PFNGLGETVERTEXATTRIBIUIVPROC)load("glGetVertexAttribIuiv"); + glad_glVertexAttribI1i = (PFNGLVERTEXATTRIBI1IPROC)load("glVertexAttribI1i"); + glad_glVertexAttribI2i = (PFNGLVERTEXATTRIBI2IPROC)load("glVertexAttribI2i"); + glad_glVertexAttribI3i = (PFNGLVERTEXATTRIBI3IPROC)load("glVertexAttribI3i"); + glad_glVertexAttribI4i = (PFNGLVERTEXATTRIBI4IPROC)load("glVertexAttribI4i"); + glad_glVertexAttribI1ui = (PFNGLVERTEXATTRIBI1UIPROC)load("glVertexAttribI1ui"); + glad_glVertexAttribI2ui = (PFNGLVERTEXATTRIBI2UIPROC)load("glVertexAttribI2ui"); + glad_glVertexAttribI3ui = (PFNGLVERTEXATTRIBI3UIPROC)load("glVertexAttribI3ui"); + glad_glVertexAttribI4ui = (PFNGLVERTEXATTRIBI4UIPROC)load("glVertexAttribI4ui"); + glad_glVertexAttribI1iv = (PFNGLVERTEXATTRIBI1IVPROC)load("glVertexAttribI1iv"); + glad_glVertexAttribI2iv = (PFNGLVERTEXATTRIBI2IVPROC)load("glVertexAttribI2iv"); + glad_glVertexAttribI3iv = (PFNGLVERTEXATTRIBI3IVPROC)load("glVertexAttribI3iv"); + glad_glVertexAttribI4iv = (PFNGLVERTEXATTRIBI4IVPROC)load("glVertexAttribI4iv"); + glad_glVertexAttribI1uiv = (PFNGLVERTEXATTRIBI1UIVPROC)load("glVertexAttribI1uiv"); + glad_glVertexAttribI2uiv = (PFNGLVERTEXATTRIBI2UIVPROC)load("glVertexAttribI2uiv"); + glad_glVertexAttribI3uiv = (PFNGLVERTEXATTRIBI3UIVPROC)load("glVertexAttribI3uiv"); + glad_glVertexAttribI4uiv = (PFNGLVERTEXATTRIBI4UIVPROC)load("glVertexAttribI4uiv"); + glad_glVertexAttribI4bv = (PFNGLVERTEXATTRIBI4BVPROC)load("glVertexAttribI4bv"); + glad_glVertexAttribI4sv = (PFNGLVERTEXATTRIBI4SVPROC)load("glVertexAttribI4sv"); + glad_glVertexAttribI4ubv = (PFNGLVERTEXATTRIBI4UBVPROC)load("glVertexAttribI4ubv"); + glad_glVertexAttribI4usv = (PFNGLVERTEXATTRIBI4USVPROC)load("glVertexAttribI4usv"); + glad_glGetUniformuiv = (PFNGLGETUNIFORMUIVPROC)load("glGetUniformuiv"); + glad_glBindFragDataLocation = (PFNGLBINDFRAGDATALOCATIONPROC)load("glBindFragDataLocation"); + glad_glGetFragDataLocation = (PFNGLGETFRAGDATALOCATIONPROC)load("glGetFragDataLocation"); + glad_glUniform1ui = (PFNGLUNIFORM1UIPROC)load("glUniform1ui"); + glad_glUniform2ui = (PFNGLUNIFORM2UIPROC)load("glUniform2ui"); + glad_glUniform3ui = (PFNGLUNIFORM3UIPROC)load("glUniform3ui"); + glad_glUniform4ui = (PFNGLUNIFORM4UIPROC)load("glUniform4ui"); + glad_glUniform1uiv = (PFNGLUNIFORM1UIVPROC)load("glUniform1uiv"); + glad_glUniform2uiv = (PFNGLUNIFORM2UIVPROC)load("glUniform2uiv"); + glad_glUniform3uiv = (PFNGLUNIFORM3UIVPROC)load("glUniform3uiv"); + glad_glUniform4uiv = (PFNGLUNIFORM4UIVPROC)load("glUniform4uiv"); + glad_glTexParameterIiv = (PFNGLTEXPARAMETERIIVPROC)load("glTexParameterIiv"); + glad_glTexParameterIuiv = (PFNGLTEXPARAMETERIUIVPROC)load("glTexParameterIuiv"); + glad_glGetTexParameterIiv = (PFNGLGETTEXPARAMETERIIVPROC)load("glGetTexParameterIiv"); + glad_glGetTexParameterIuiv = (PFNGLGETTEXPARAMETERIUIVPROC)load("glGetTexParameterIuiv"); + glad_glClearBufferiv = (PFNGLCLEARBUFFERIVPROC)load("glClearBufferiv"); + glad_glClearBufferuiv = (PFNGLCLEARBUFFERUIVPROC)load("glClearBufferuiv"); + glad_glClearBufferfv = (PFNGLCLEARBUFFERFVPROC)load("glClearBufferfv"); + glad_glClearBufferfi = (PFNGLCLEARBUFFERFIPROC)load("glClearBufferfi"); + glad_glGetStringi = (PFNGLGETSTRINGIPROC)load("glGetStringi"); + glad_glIsRenderbuffer = (PFNGLISRENDERBUFFERPROC)load("glIsRenderbuffer"); + glad_glBindRenderbuffer = (PFNGLBINDRENDERBUFFERPROC)load("glBindRenderbuffer"); + glad_glDeleteRenderbuffers = (PFNGLDELETERENDERBUFFERSPROC)load("glDeleteRenderbuffers"); + glad_glGenRenderbuffers = (PFNGLGENRENDERBUFFERSPROC)load("glGenRenderbuffers"); + glad_glRenderbufferStorage = (PFNGLRENDERBUFFERSTORAGEPROC)load("glRenderbufferStorage"); + glad_glGetRenderbufferParameteriv = (PFNGLGETRENDERBUFFERPARAMETERIVPROC)load("glGetRenderbufferParameteriv"); + glad_glIsFramebuffer = (PFNGLISFRAMEBUFFERPROC)load("glIsFramebuffer"); + glad_glBindFramebuffer = (PFNGLBINDFRAMEBUFFERPROC)load("glBindFramebuffer"); + glad_glDeleteFramebuffers = (PFNGLDELETEFRAMEBUFFERSPROC)load("glDeleteFramebuffers"); + glad_glGenFramebuffers = (PFNGLGENFRAMEBUFFERSPROC)load("glGenFramebuffers"); + glad_glCheckFramebufferStatus = (PFNGLCHECKFRAMEBUFFERSTATUSPROC)load("glCheckFramebufferStatus"); + glad_glFramebufferTexture1D = (PFNGLFRAMEBUFFERTEXTURE1DPROC)load("glFramebufferTexture1D"); + glad_glFramebufferTexture2D = (PFNGLFRAMEBUFFERTEXTURE2DPROC)load("glFramebufferTexture2D"); + glad_glFramebufferTexture3D = (PFNGLFRAMEBUFFERTEXTURE3DPROC)load("glFramebufferTexture3D"); + glad_glFramebufferRenderbuffer = (PFNGLFRAMEBUFFERRENDERBUFFERPROC)load("glFramebufferRenderbuffer"); + glad_glGetFramebufferAttachmentParameteriv = (PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC)load("glGetFramebufferAttachmentParameteriv"); + glad_glGenerateMipmap = (PFNGLGENERATEMIPMAPPROC)load("glGenerateMipmap"); + glad_glBlitFramebuffer = (PFNGLBLITFRAMEBUFFERPROC)load("glBlitFramebuffer"); + glad_glRenderbufferStorageMultisample = (PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC)load("glRenderbufferStorageMultisample"); + glad_glFramebufferTextureLayer = (PFNGLFRAMEBUFFERTEXTURELAYERPROC)load("glFramebufferTextureLayer"); + glad_glMapBufferRange = (PFNGLMAPBUFFERRANGEPROC)load("glMapBufferRange"); + glad_glFlushMappedBufferRange = (PFNGLFLUSHMAPPEDBUFFERRANGEPROC)load("glFlushMappedBufferRange"); + glad_glBindVertexArray = (PFNGLBINDVERTEXARRAYPROC)load("glBindVertexArray"); + glad_glDeleteVertexArrays = (PFNGLDELETEVERTEXARRAYSPROC)load("glDeleteVertexArrays"); + glad_glGenVertexArrays = (PFNGLGENVERTEXARRAYSPROC)load("glGenVertexArrays"); + glad_glIsVertexArray = (PFNGLISVERTEXARRAYPROC)load("glIsVertexArray"); +} +static void load_GL_VERSION_3_1(GLADloadproc load) { + if(!GLAD_GL_VERSION_3_1) return; + glad_glDrawArraysInstanced = (PFNGLDRAWARRAYSINSTANCEDPROC)load("glDrawArraysInstanced"); + glad_glDrawElementsInstanced = (PFNGLDRAWELEMENTSINSTANCEDPROC)load("glDrawElementsInstanced"); + glad_glTexBuffer = (PFNGLTEXBUFFERPROC)load("glTexBuffer"); + glad_glPrimitiveRestartIndex = (PFNGLPRIMITIVERESTARTINDEXPROC)load("glPrimitiveRestartIndex"); + glad_glCopyBufferSubData = (PFNGLCOPYBUFFERSUBDATAPROC)load("glCopyBufferSubData"); + glad_glGetUniformIndices = (PFNGLGETUNIFORMINDICESPROC)load("glGetUniformIndices"); + glad_glGetActiveUniformsiv = (PFNGLGETACTIVEUNIFORMSIVPROC)load("glGetActiveUniformsiv"); + glad_glGetActiveUniformName = (PFNGLGETACTIVEUNIFORMNAMEPROC)load("glGetActiveUniformName"); + glad_glGetUniformBlockIndex = (PFNGLGETUNIFORMBLOCKINDEXPROC)load("glGetUniformBlockIndex"); + glad_glGetActiveUniformBlockiv = (PFNGLGETACTIVEUNIFORMBLOCKIVPROC)load("glGetActiveUniformBlockiv"); + glad_glGetActiveUniformBlockName = (PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC)load("glGetActiveUniformBlockName"); + glad_glUniformBlockBinding = (PFNGLUNIFORMBLOCKBINDINGPROC)load("glUniformBlockBinding"); + glad_glBindBufferRange = (PFNGLBINDBUFFERRANGEPROC)load("glBindBufferRange"); + glad_glBindBufferBase = (PFNGLBINDBUFFERBASEPROC)load("glBindBufferBase"); + glad_glGetIntegeri_v = (PFNGLGETINTEGERI_VPROC)load("glGetIntegeri_v"); +} +static void load_GL_VERSION_3_2(GLADloadproc load) { + if(!GLAD_GL_VERSION_3_2) return; + glad_glDrawElementsBaseVertex = (PFNGLDRAWELEMENTSBASEVERTEXPROC)load("glDrawElementsBaseVertex"); + glad_glDrawRangeElementsBaseVertex = (PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC)load("glDrawRangeElementsBaseVertex"); + glad_glDrawElementsInstancedBaseVertex = (PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC)load("glDrawElementsInstancedBaseVertex"); + glad_glMultiDrawElementsBaseVertex = (PFNGLMULTIDRAWELEMENTSBASEVERTEXPROC)load("glMultiDrawElementsBaseVertex"); + glad_glProvokingVertex = (PFNGLPROVOKINGVERTEXPROC)load("glProvokingVertex"); + glad_glFenceSync = (PFNGLFENCESYNCPROC)load("glFenceSync"); + glad_glIsSync = (PFNGLISSYNCPROC)load("glIsSync"); + glad_glDeleteSync = (PFNGLDELETESYNCPROC)load("glDeleteSync"); + glad_glClientWaitSync = (PFNGLCLIENTWAITSYNCPROC)load("glClientWaitSync"); + glad_glWaitSync = (PFNGLWAITSYNCPROC)load("glWaitSync"); + glad_glGetInteger64v = (PFNGLGETINTEGER64VPROC)load("glGetInteger64v"); + glad_glGetSynciv = (PFNGLGETSYNCIVPROC)load("glGetSynciv"); + glad_glGetInteger64i_v = (PFNGLGETINTEGER64I_VPROC)load("glGetInteger64i_v"); + glad_glGetBufferParameteri64v = (PFNGLGETBUFFERPARAMETERI64VPROC)load("glGetBufferParameteri64v"); + glad_glFramebufferTexture = (PFNGLFRAMEBUFFERTEXTUREPROC)load("glFramebufferTexture"); + glad_glTexImage2DMultisample = (PFNGLTEXIMAGE2DMULTISAMPLEPROC)load("glTexImage2DMultisample"); + glad_glTexImage3DMultisample = (PFNGLTEXIMAGE3DMULTISAMPLEPROC)load("glTexImage3DMultisample"); + glad_glGetMultisamplefv = (PFNGLGETMULTISAMPLEFVPROC)load("glGetMultisamplefv"); + glad_glSampleMaski = (PFNGLSAMPLEMASKIPROC)load("glSampleMaski"); +} +static void load_GL_VERSION_3_3(GLADloadproc load) { + if(!GLAD_GL_VERSION_3_3) return; + glad_glBindFragDataLocationIndexed = (PFNGLBINDFRAGDATALOCATIONINDEXEDPROC)load("glBindFragDataLocationIndexed"); + glad_glGetFragDataIndex = (PFNGLGETFRAGDATAINDEXPROC)load("glGetFragDataIndex"); + glad_glGenSamplers = (PFNGLGENSAMPLERSPROC)load("glGenSamplers"); + glad_glDeleteSamplers = (PFNGLDELETESAMPLERSPROC)load("glDeleteSamplers"); + glad_glIsSampler = (PFNGLISSAMPLERPROC)load("glIsSampler"); + glad_glBindSampler = (PFNGLBINDSAMPLERPROC)load("glBindSampler"); + glad_glSamplerParameteri = (PFNGLSAMPLERPARAMETERIPROC)load("glSamplerParameteri"); + glad_glSamplerParameteriv = (PFNGLSAMPLERPARAMETERIVPROC)load("glSamplerParameteriv"); + glad_glSamplerParameterf = (PFNGLSAMPLERPARAMETERFPROC)load("glSamplerParameterf"); + glad_glSamplerParameterfv = (PFNGLSAMPLERPARAMETERFVPROC)load("glSamplerParameterfv"); + glad_glSamplerParameterIiv = (PFNGLSAMPLERPARAMETERIIVPROC)load("glSamplerParameterIiv"); + glad_glSamplerParameterIuiv = (PFNGLSAMPLERPARAMETERIUIVPROC)load("glSamplerParameterIuiv"); + glad_glGetSamplerParameteriv = (PFNGLGETSAMPLERPARAMETERIVPROC)load("glGetSamplerParameteriv"); + glad_glGetSamplerParameterIiv = (PFNGLGETSAMPLERPARAMETERIIVPROC)load("glGetSamplerParameterIiv"); + glad_glGetSamplerParameterfv = (PFNGLGETSAMPLERPARAMETERFVPROC)load("glGetSamplerParameterfv"); + glad_glGetSamplerParameterIuiv = (PFNGLGETSAMPLERPARAMETERIUIVPROC)load("glGetSamplerParameterIuiv"); + glad_glQueryCounter = (PFNGLQUERYCOUNTERPROC)load("glQueryCounter"); + glad_glGetQueryObjecti64v = (PFNGLGETQUERYOBJECTI64VPROC)load("glGetQueryObjecti64v"); + glad_glGetQueryObjectui64v = (PFNGLGETQUERYOBJECTUI64VPROC)load("glGetQueryObjectui64v"); + glad_glVertexAttribDivisor = (PFNGLVERTEXATTRIBDIVISORPROC)load("glVertexAttribDivisor"); + glad_glVertexAttribP1ui = (PFNGLVERTEXATTRIBP1UIPROC)load("glVertexAttribP1ui"); + glad_glVertexAttribP1uiv = (PFNGLVERTEXATTRIBP1UIVPROC)load("glVertexAttribP1uiv"); + glad_glVertexAttribP2ui = (PFNGLVERTEXATTRIBP2UIPROC)load("glVertexAttribP2ui"); + glad_glVertexAttribP2uiv = (PFNGLVERTEXATTRIBP2UIVPROC)load("glVertexAttribP2uiv"); + glad_glVertexAttribP3ui = (PFNGLVERTEXATTRIBP3UIPROC)load("glVertexAttribP3ui"); + glad_glVertexAttribP3uiv = (PFNGLVERTEXATTRIBP3UIVPROC)load("glVertexAttribP3uiv"); + glad_glVertexAttribP4ui = (PFNGLVERTEXATTRIBP4UIPROC)load("glVertexAttribP4ui"); + glad_glVertexAttribP4uiv = (PFNGLVERTEXATTRIBP4UIVPROC)load("glVertexAttribP4uiv"); + glad_glVertexP2ui = (PFNGLVERTEXP2UIPROC)load("glVertexP2ui"); + glad_glVertexP2uiv = (PFNGLVERTEXP2UIVPROC)load("glVertexP2uiv"); + glad_glVertexP3ui = (PFNGLVERTEXP3UIPROC)load("glVertexP3ui"); + glad_glVertexP3uiv = (PFNGLVERTEXP3UIVPROC)load("glVertexP3uiv"); + glad_glVertexP4ui = (PFNGLVERTEXP4UIPROC)load("glVertexP4ui"); + glad_glVertexP4uiv = (PFNGLVERTEXP4UIVPROC)load("glVertexP4uiv"); + glad_glTexCoordP1ui = (PFNGLTEXCOORDP1UIPROC)load("glTexCoordP1ui"); + glad_glTexCoordP1uiv = (PFNGLTEXCOORDP1UIVPROC)load("glTexCoordP1uiv"); + glad_glTexCoordP2ui = (PFNGLTEXCOORDP2UIPROC)load("glTexCoordP2ui"); + glad_glTexCoordP2uiv = (PFNGLTEXCOORDP2UIVPROC)load("glTexCoordP2uiv"); + glad_glTexCoordP3ui = (PFNGLTEXCOORDP3UIPROC)load("glTexCoordP3ui"); + glad_glTexCoordP3uiv = (PFNGLTEXCOORDP3UIVPROC)load("glTexCoordP3uiv"); + glad_glTexCoordP4ui = (PFNGLTEXCOORDP4UIPROC)load("glTexCoordP4ui"); + glad_glTexCoordP4uiv = (PFNGLTEXCOORDP4UIVPROC)load("glTexCoordP4uiv"); + glad_glMultiTexCoordP1ui = (PFNGLMULTITEXCOORDP1UIPROC)load("glMultiTexCoordP1ui"); + glad_glMultiTexCoordP1uiv = (PFNGLMULTITEXCOORDP1UIVPROC)load("glMultiTexCoordP1uiv"); + glad_glMultiTexCoordP2ui = (PFNGLMULTITEXCOORDP2UIPROC)load("glMultiTexCoordP2ui"); + glad_glMultiTexCoordP2uiv = (PFNGLMULTITEXCOORDP2UIVPROC)load("glMultiTexCoordP2uiv"); + glad_glMultiTexCoordP3ui = (PFNGLMULTITEXCOORDP3UIPROC)load("glMultiTexCoordP3ui"); + glad_glMultiTexCoordP3uiv = (PFNGLMULTITEXCOORDP3UIVPROC)load("glMultiTexCoordP3uiv"); + glad_glMultiTexCoordP4ui = (PFNGLMULTITEXCOORDP4UIPROC)load("glMultiTexCoordP4ui"); + glad_glMultiTexCoordP4uiv = (PFNGLMULTITEXCOORDP4UIVPROC)load("glMultiTexCoordP4uiv"); + glad_glNormalP3ui = (PFNGLNORMALP3UIPROC)load("glNormalP3ui"); + glad_glNormalP3uiv = (PFNGLNORMALP3UIVPROC)load("glNormalP3uiv"); + glad_glColorP3ui = (PFNGLCOLORP3UIPROC)load("glColorP3ui"); + glad_glColorP3uiv = (PFNGLCOLORP3UIVPROC)load("glColorP3uiv"); + glad_glColorP4ui = (PFNGLCOLORP4UIPROC)load("glColorP4ui"); + glad_glColorP4uiv = (PFNGLCOLORP4UIVPROC)load("glColorP4uiv"); + glad_glSecondaryColorP3ui = (PFNGLSECONDARYCOLORP3UIPROC)load("glSecondaryColorP3ui"); + glad_glSecondaryColorP3uiv = (PFNGLSECONDARYCOLORP3UIVPROC)load("glSecondaryColorP3uiv"); +} +static int find_extensionsGL(void) { + if (!get_exts()) return 0; + (void)&has_ext; + free_exts(); + return 1; +} + +static void find_coreGL(void) { + + /* Thank you @elmindreda + * https://github.com/elmindreda/greg/blob/master/templates/greg.c.in#L176 + * https://github.com/glfw/glfw/blob/master/src/context.c#L36 + */ + int i, major, minor; + + const char* version; + const char* prefixes[] = { + "OpenGL ES-CM ", + "OpenGL ES-CL ", + "OpenGL ES ", + NULL + }; + + version = (const char*) glGetString(GL_VERSION); + if (!version) return; + + for (i = 0; prefixes[i]; i++) { + const size_t length = strlen(prefixes[i]); + if (strncmp(version, prefixes[i], length) == 0) { + version += length; + break; + } + } + +/* PR #18 */ +#ifdef _MSC_VER + sscanf_s(version, "%d.%d", &major, &minor); +#else + sscanf(version, "%d.%d", &major, &minor); +#endif + + GLVersion.major = major; GLVersion.minor = minor; + max_loaded_major = major; max_loaded_minor = minor; + GLAD_GL_VERSION_1_0 = (major == 1 && minor >= 0) || major > 1; + GLAD_GL_VERSION_1_1 = (major == 1 && minor >= 1) || major > 1; + GLAD_GL_VERSION_1_2 = (major == 1 && minor >= 2) || major > 1; + GLAD_GL_VERSION_1_3 = (major == 1 && minor >= 3) || major > 1; + GLAD_GL_VERSION_1_4 = (major == 1 && minor >= 4) || major > 1; + GLAD_GL_VERSION_1_5 = (major == 1 && minor >= 5) || major > 1; + GLAD_GL_VERSION_2_0 = (major == 2 && minor >= 0) || major > 2; + GLAD_GL_VERSION_2_1 = (major == 2 && minor >= 1) || major > 2; + GLAD_GL_VERSION_3_0 = (major == 3 && minor >= 0) || major > 3; + GLAD_GL_VERSION_3_1 = (major == 3 && minor >= 1) || major > 3; + GLAD_GL_VERSION_3_2 = (major == 3 && minor >= 2) || major > 3; + GLAD_GL_VERSION_3_3 = (major == 3 && minor >= 3) || major > 3; + if (GLVersion.major > 3 || (GLVersion.major >= 3 && GLVersion.minor >= 3)) { + max_loaded_major = 3; + max_loaded_minor = 3; + } +} + +int gladLoadGLLoader(GLADloadproc load) { + GLVersion.major = 0; GLVersion.minor = 0; + glGetString = (PFNGLGETSTRINGPROC)load("glGetString"); + if(glGetString == NULL) return 0; + if(glGetString(GL_VERSION) == NULL) return 0; + find_coreGL(); + load_GL_VERSION_1_0(load); + load_GL_VERSION_1_1(load); + load_GL_VERSION_1_2(load); + load_GL_VERSION_1_3(load); + load_GL_VERSION_1_4(load); + load_GL_VERSION_1_5(load); + load_GL_VERSION_2_0(load); + load_GL_VERSION_2_1(load); + load_GL_VERSION_3_0(load); + load_GL_VERSION_3_1(load); + load_GL_VERSION_3_2(load); + load_GL_VERSION_3_3(load); + + if (!find_extensionsGL()) return 0; + return GLVersion.major != 0 || GLVersion.minor != 0; +} + diff --git a/Dynamic libraries/src/lib/.vscode/tasks.json b/Dynamic libraries/src/lib/.vscode/tasks.json new file mode 100644 index 0000000..369abdf --- /dev/null +++ b/Dynamic libraries/src/lib/.vscode/tasks.json @@ -0,0 +1,32 @@ +{ + "version": "2.0.0", + "tasks": [ + { + "type": "cppbuild", + "label": "C/C++: g++.exe build active file", + "command": "C:/path/to/g++.exe", + "args": [ + "-g", + "-std=c++17", + "-I${workspaceFolder}/include", + "-L${workspaceFolder}/lib", + "${workspaceFolder}/src/main.cpp", + "${workspaceFolder}/src/glad.c", + "-lglfw3dll", + "-o", + "${workspaceFolder}/cutable.exe" + ], + "options": { + "cwd": "${workspaceFolder}" + }, + "problemMatcher": [ + "$gcc" + ], + "group": { + "kind": "build", + "isDefault": true + }, + "detail": "compiler: C:/C:/path/to/g++.exe" + } + ] +} \ No newline at end of file diff --git a/Dynamic libraries/src/lib/libglfw3dll.a b/Dynamic libraries/src/lib/libglfw3dll.a new file mode 100644 index 0000000000000000000000000000000000000000..535cd3b8e40d346050f0246e073ad0c018f7641d GIT binary patch literal 89452 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 xTeq@%VRN!rsBCj&XS +#include + +int main() +{ + + int a = glfwInit(); + std::cout << a << std::endl; + + std::cin.get(); +} \ No newline at end of file