shader_language.cpp 119 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610161116121613161416151616161716181619162016211622162316241625162616271628162916301631163216331634163516361637163816391640164116421643164416451646164716481649165016511652165316541655165616571658165916601661166216631664166516661667166816691670167116721673167416751676167716781679168016811682168316841685168616871688168916901691169216931694169516961697169816991700170117021703170417051706170717081709171017111712171317141715171617171718171917201721172217231724172517261727172817291730173117321733173417351736173717381739174017411742174317441745174617471748174917501751175217531754175517561757175817591760176117621763176417651766176717681769177017711772177317741775177617771778177917801781178217831784178517861787178817891790179117921793179417951796179717981799180018011802180318041805180618071808180918101811181218131814181518161817181818191820182118221823182418251826182718281829183018311832183318341835183618371838183918401841184218431844184518461847184818491850185118521853185418551856185718581859186018611862186318641865186618671868186918701871187218731874187518761877187818791880188118821883188418851886188718881889189018911892189318941895189618971898189919001901190219031904190519061907190819091910191119121913191419151916191719181919192019211922192319241925192619271928192919301931193219331934193519361937193819391940194119421943194419451946194719481949195019511952195319541955195619571958195919601961196219631964196519661967196819691970197119721973197419751976197719781979198019811982198319841985198619871988198919901991199219931994199519961997199819992000200120022003200420052006200720082009201020112012201320142015201620172018201920202021202220232024202520262027202820292030203120322033203420352036203720382039204020412042204320442045204620472048204920502051205220532054205520562057205820592060206120622063206420652066206720682069207020712072207320742075207620772078207920802081208220832084208520862087208820892090209120922093209420952096209720982099210021012102210321042105210621072108210921102111211221132114211521162117211821192120212121222123212421252126212721282129213021312132213321342135213621372138213921402141214221432144214521462147214821492150215121522153215421552156215721582159216021612162216321642165216621672168216921702171217221732174217521762177217821792180218121822183218421852186218721882189219021912192219321942195219621972198219922002201220222032204220522062207220822092210221122122213221422152216221722182219222022212222222322242225222622272228222922302231223222332234223522362237223822392240224122422243224422452246224722482249225022512252225322542255225622572258225922602261226222632264226522662267226822692270227122722273227422752276227722782279228022812282228322842285228622872288228922902291229222932294229522962297229822992300230123022303230423052306230723082309231023112312231323142315231623172318231923202321232223232324232523262327232823292330233123322333233423352336233723382339234023412342234323442345234623472348234923502351235223532354235523562357235823592360236123622363236423652366236723682369237023712372237323742375237623772378237923802381238223832384238523862387238823892390239123922393239423952396239723982399240024012402240324042405240624072408240924102411241224132414241524162417241824192420242124222423242424252426242724282429243024312432243324342435243624372438243924402441244224432444244524462447244824492450245124522453245424552456245724582459246024612462246324642465246624672468246924702471247224732474247524762477247824792480248124822483248424852486248724882489249024912492249324942495249624972498249925002501250225032504250525062507250825092510251125122513251425152516251725182519252025212522252325242525252625272528252925302531253225332534253525362537253825392540254125422543254425452546254725482549255025512552255325542555255625572558255925602561256225632564256525662567256825692570257125722573257425752576257725782579258025812582258325842585258625872588258925902591259225932594259525962597259825992600260126022603260426052606260726082609261026112612261326142615261626172618261926202621262226232624262526262627262826292630263126322633263426352636263726382639264026412642264326442645264626472648264926502651265226532654265526562657265826592660266126622663266426652666266726682669267026712672267326742675267626772678267926802681268226832684268526862687268826892690269126922693269426952696269726982699270027012702270327042705270627072708270927102711271227132714271527162717271827192720272127222723272427252726272727282729273027312732273327342735273627372738273927402741274227432744274527462747274827492750275127522753275427552756275727582759276027612762276327642765276627672768276927702771277227732774277527762777277827792780278127822783278427852786278727882789279027912792279327942795279627972798279928002801280228032804280528062807280828092810281128122813281428152816281728182819282028212822282328242825282628272828282928302831283228332834283528362837283828392840284128422843284428452846284728482849285028512852285328542855285628572858285928602861286228632864286528662867286828692870287128722873287428752876287728782879288028812882288328842885288628872888288928902891289228932894289528962897289828992900290129022903290429052906290729082909291029112912291329142915291629172918291929202921292229232924292529262927292829292930293129322933293429352936293729382939294029412942294329442945294629472948294929502951295229532954295529562957295829592960296129622963296429652966296729682969297029712972297329742975297629772978297929802981298229832984298529862987298829892990299129922993299429952996299729982999300030013002300330043005300630073008300930103011301230133014301530163017301830193020302130223023302430253026302730283029303030313032303330343035303630373038303930403041304230433044304530463047304830493050305130523053305430553056305730583059306030613062306330643065306630673068306930703071307230733074307530763077307830793080308130823083308430853086308730883089309030913092309330943095309630973098309931003101310231033104310531063107310831093110311131123113311431153116311731183119312031213122312331243125312631273128312931303131313231333134313531363137313831393140314131423143314431453146314731483149315031513152315331543155315631573158315931603161316231633164316531663167316831693170317131723173317431753176317731783179318031813182318331843185318631873188318931903191319231933194319531963197319831993200320132023203320432053206320732083209321032113212321332143215321632173218321932203221322232233224322532263227322832293230323132323233323432353236323732383239324032413242324332443245324632473248324932503251325232533254325532563257325832593260326132623263326432653266326732683269327032713272327332743275327632773278327932803281328232833284328532863287328832893290329132923293329432953296329732983299330033013302330333043305330633073308330933103311331233133314331533163317331833193320332133223323332433253326332733283329333033313332333333343335333633373338333933403341334233433344334533463347334833493350335133523353335433553356335733583359336033613362336333643365336633673368336933703371337233733374337533763377337833793380338133823383338433853386338733883389339033913392339333943395339633973398339934003401340234033404340534063407340834093410341134123413341434153416341734183419342034213422342334243425342634273428342934303431343234333434343534363437343834393440344134423443344434453446344734483449345034513452345334543455345634573458345934603461346234633464346534663467346834693470347134723473347434753476347734783479348034813482348334843485348634873488348934903491349234933494349534963497349834993500350135023503350435053506350735083509351035113512351335143515351635173518351935203521352235233524352535263527352835293530353135323533353435353536353735383539354035413542354335443545354635473548354935503551355235533554355535563557355835593560356135623563356435653566356735683569357035713572357335743575357635773578357935803581358235833584358535863587358835893590359135923593359435953596359735983599360036013602360336043605360636073608360936103611361236133614361536163617361836193620362136223623362436253626362736283629363036313632363336343635363636373638363936403641364236433644364536463647364836493650365136523653365436553656365736583659366036613662366336643665366636673668366936703671367236733674367536763677367836793680368136823683368436853686368736883689369036913692369336943695369636973698369937003701370237033704370537063707370837093710371137123713371437153716371737183719372037213722372337243725372637273728372937303731373237333734373537363737373837393740374137423743374437453746374737483749375037513752375337543755375637573758375937603761376237633764376537663767376837693770377137723773377437753776377737783779378037813782378337843785378637873788378937903791379237933794379537963797379837993800380138023803380438053806380738083809381038113812381338143815381638173818381938203821382238233824382538263827382838293830383138323833383438353836383738383839384038413842384338443845384638473848384938503851385238533854385538563857385838593860386138623863386438653866386738683869387038713872387338743875387638773878387938803881388238833884388538863887388838893890389138923893389438953896389738983899390039013902390339043905390639073908390939103911391239133914391539163917391839193920392139223923392439253926392739283929393039313932393339343935393639373938393939403941394239433944394539463947394839493950395139523953395439553956395739583959396039613962396339643965396639673968396939703971397239733974397539763977397839793980398139823983398439853986398739883989399039913992399339943995399639973998399940004001400240034004400540064007400840094010401140124013401440154016401740184019402040214022402340244025402640274028402940304031403240334034403540364037403840394040404140424043404440454046404740484049405040514052405340544055405640574058405940604061406240634064406540664067406840694070407140724073407440754076407740784079408040814082408340844085408640874088408940904091409240934094409540964097409840994100410141024103410441054106410741084109411041114112411341144115411641174118411941204121412241234124412541264127412841294130413141324133413441354136413741384139414041414142414341444145414641474148414941504151415241534154415541564157415841594160416141624163416441654166416741684169417041714172417341744175417641774178417941804181418241834184418541864187418841894190419141924193419441954196419741984199420042014202420342044205420642074208420942104211421242134214421542164217421842194220422142224223422442254226422742284229423042314232423342344235423642374238423942404241424242434244
  1. /*************************************************************************/
  2. /* shader_language.cpp */
  3. /*************************************************************************/
  4. /* This file is part of: */
  5. /* GODOT ENGINE */
  6. /* https://godotengine.org */
  7. /*************************************************************************/
  8. /* Copyright (c) 2007-2017 Juan Linietsky, Ariel Manzur. */
  9. /* Copyright (c) 2014-2017 Godot Engine contributors (cf. AUTHORS.md) */
  10. /* */
  11. /* Permission is hereby granted, free of charge, to any person obtaining */
  12. /* a copy of this software and associated documentation files (the */
  13. /* "Software"), to deal in the Software without restriction, including */
  14. /* without limitation the rights to use, copy, modify, merge, publish, */
  15. /* distribute, sublicense, and/or sell copies of the Software, and to */
  16. /* permit persons to whom the Software is furnished to do so, subject to */
  17. /* the following conditions: */
  18. /* */
  19. /* The above copyright notice and this permission notice shall be */
  20. /* included in all copies or substantial portions of the Software. */
  21. /* */
  22. /* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
  23. /* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
  24. /* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
  25. /* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
  26. /* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
  27. /* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
  28. /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
  29. /*************************************************************************/
  30. #include "shader_language.h"
  31. #include "os/os.h"
  32. #include "print_string.h"
  33. static bool _is_text_char(CharType c) {
  34. return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9') || c == '_';
  35. }
  36. static bool _is_number(CharType c) {
  37. return (c >= '0' && c <= '9');
  38. }
  39. static bool _is_hex(CharType c) {
  40. return (c >= '0' && c <= '9') || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F');
  41. }
  42. String ShaderLanguage::get_operator_text(Operator p_op) {
  43. static const char *op_names[OP_MAX] = { "==",
  44. "!=",
  45. "<",
  46. "<=",
  47. ">",
  48. ">=",
  49. "&&",
  50. "||",
  51. "!",
  52. "-",
  53. "+",
  54. "-",
  55. "*",
  56. "/",
  57. "%",
  58. "<<",
  59. ">>",
  60. "=",
  61. "+=",
  62. "-=",
  63. "*=",
  64. "/=",
  65. "%=",
  66. "<<=",
  67. ">>=",
  68. "&=",
  69. "|=",
  70. "^=",
  71. "&",
  72. "|",
  73. "^",
  74. "~",
  75. "++",
  76. "--",
  77. "?",
  78. ":",
  79. "++",
  80. "--",
  81. "()",
  82. "construct",
  83. "index" };
  84. return op_names[p_op];
  85. }
  86. const char *ShaderLanguage::token_names[TK_MAX] = {
  87. "EMPTY",
  88. "IDENTIFIER",
  89. "TRUE",
  90. "FALSE",
  91. "REAL_CONSTANT",
  92. "INT_CONSTANT",
  93. "TYPE_VOID",
  94. "TYPE_BOOL",
  95. "TYPE_BVEC2",
  96. "TYPE_BVEC3",
  97. "TYPE_BVEC4",
  98. "TYPE_INT",
  99. "TYPE_IVEC2",
  100. "TYPE_IVEC3",
  101. "TYPE_IVEC4",
  102. "TYPE_UINT",
  103. "TYPE_UVEC2",
  104. "TYPE_UVEC3",
  105. "TYPE_UVEC4",
  106. "TYPE_FLOAT",
  107. "TYPE_VEC2",
  108. "TYPE_VEC3",
  109. "TYPE_VEC4",
  110. "TYPE_MAT2",
  111. "TYPE_MAT3",
  112. "TYPE_MAT4",
  113. "TYPE_SAMPLER2D",
  114. "TYPE_ISAMPLER2D",
  115. "TYPE_USAMPLER2D",
  116. "TYPE_SAMPLERCUBE",
  117. "PRECISION_LOW",
  118. "PRECISION_MID",
  119. "PRECISION_HIGH",
  120. "OP_EQUAL",
  121. "OP_NOT_EQUAL",
  122. "OP_LESS",
  123. "OP_LESS_EQUAL",
  124. "OP_GREATER",
  125. "OP_GREATER_EQUAL",
  126. "OP_AND",
  127. "OP_OR",
  128. "OP_NOT",
  129. "OP_ADD",
  130. "OP_SUB",
  131. "OP_MUL",
  132. "OP_DIV",
  133. "OP_MOD",
  134. "OP_SHIFT_LEFT",
  135. "OP_SHIFT_RIGHT",
  136. "OP_ASSIGN",
  137. "OP_ASSIGN_ADD",
  138. "OP_ASSIGN_SUB",
  139. "OP_ASSIGN_MUL",
  140. "OP_ASSIGN_DIV",
  141. "OP_ASSIGN_MOD",
  142. "OP_ASSIGN_SHIFT_LEFT",
  143. "OP_ASSIGN_SHIFT_RIGHT",
  144. "OP_ASSIGN_BIT_AND",
  145. "OP_ASSIGN_BIT_OR",
  146. "OP_ASSIGN_BIT_XOR",
  147. "OP_BIT_AND",
  148. "OP_BIT_OR",
  149. "OP_BIT_XOR",
  150. "OP_BIT_INVERT",
  151. "OP_INCREMENT",
  152. "OP_DECREMENT",
  153. "CF_IF",
  154. "CF_ELSE",
  155. "CF_FOR",
  156. "CF_WHILE",
  157. "CF_DO",
  158. "CF_SWITCH",
  159. "CF_CASE",
  160. "CF_BREAK",
  161. "CF_CONTINUE",
  162. "CF_RETURN",
  163. "CF_DISCARD",
  164. "BRACKET_OPEN",
  165. "BRACKET_CLOSE",
  166. "CURLY_BRACKET_OPEN",
  167. "CURLY_BRACKET_CLOSE",
  168. "PARENTHESIS_OPEN",
  169. "PARENTHESIS_CLOSE",
  170. "QUESTION",
  171. "COMMA",
  172. "COLON",
  173. "SEMICOLON",
  174. "PERIOD",
  175. "UNIFORM",
  176. "VARYING",
  177. "IN",
  178. "OUT",
  179. "INOUT",
  180. "RENDER_MODE",
  181. "HINT_WHITE_TEXTURE",
  182. "HINT_BLACK_TEXTURE",
  183. "HINT_NORMAL_TEXTURE",
  184. "HINT_ANISO_TEXTURE",
  185. "HINT_ALBEDO_TEXTURE",
  186. "HINT_BLACK_ALBEDO_TEXTURE",
  187. "HINT_COLOR",
  188. "HINT_RANGE",
  189. "SHADER_TYPE",
  190. "CURSOR",
  191. "ERROR",
  192. "EOF",
  193. };
  194. String ShaderLanguage::get_token_text(Token p_token) {
  195. String name = token_names[p_token.type];
  196. if (p_token.type == TK_INT_CONSTANT || p_token.type == TK_REAL_CONSTANT) {
  197. name += "(" + rtos(p_token.constant) + ")";
  198. } else if (p_token.type == TK_IDENTIFIER) {
  199. name += "(" + String(p_token.text) + ")";
  200. } else if (p_token.type == TK_ERROR) {
  201. name += "(" + String(p_token.text) + ")";
  202. }
  203. return name;
  204. }
  205. ShaderLanguage::Token ShaderLanguage::_make_token(TokenType p_type, const StringName &p_text) {
  206. Token tk;
  207. tk.type = p_type;
  208. tk.text = p_text;
  209. tk.line = tk_line;
  210. if (tk.type == TK_ERROR) {
  211. _set_error(p_text);
  212. }
  213. return tk;
  214. }
  215. const ShaderLanguage::KeyWord ShaderLanguage::keyword_list[] = {
  216. { TK_TRUE, "true" },
  217. { TK_FALSE, "false" },
  218. { TK_TYPE_VOID, "void" },
  219. { TK_TYPE_BOOL, "bool" },
  220. { TK_TYPE_BVEC2, "bvec2" },
  221. { TK_TYPE_BVEC3, "bvec3" },
  222. { TK_TYPE_BVEC4, "bvec4" },
  223. { TK_TYPE_INT, "int" },
  224. { TK_TYPE_IVEC2, "ivec2" },
  225. { TK_TYPE_IVEC3, "ivec3" },
  226. { TK_TYPE_IVEC4, "ivec4" },
  227. { TK_TYPE_UINT, "uint" },
  228. { TK_TYPE_UVEC2, "uvec2" },
  229. { TK_TYPE_UVEC3, "uvec3" },
  230. { TK_TYPE_UVEC4, "uvec4" },
  231. { TK_TYPE_FLOAT, "float" },
  232. { TK_TYPE_VEC2, "vec2" },
  233. { TK_TYPE_VEC3, "vec3" },
  234. { TK_TYPE_VEC4, "vec4" },
  235. { TK_TYPE_MAT2, "mat2" },
  236. { TK_TYPE_MAT3, "mat3" },
  237. { TK_TYPE_MAT4, "mat4" },
  238. { TK_TYPE_SAMPLER2D, "sampler2D" },
  239. { TK_TYPE_ISAMPLER2D, "isampler2D" },
  240. { TK_TYPE_USAMPLER2D, "usampler2D" },
  241. { TK_TYPE_SAMPLERCUBE, "samplerCube" },
  242. { TK_PRECISION_LOW, "lowp" },
  243. { TK_PRECISION_MID, "mediump" },
  244. { TK_PRECISION_HIGH, "highp" },
  245. { TK_CF_IF, "if" },
  246. { TK_CF_ELSE, "else" },
  247. { TK_CF_FOR, "for" },
  248. { TK_CF_WHILE, "while" },
  249. { TK_CF_DO, "do" },
  250. { TK_CF_SWITCH, "switch" },
  251. { TK_CF_CASE, "case" },
  252. { TK_CF_BREAK, "break" },
  253. { TK_CF_CONTINUE, "continue" },
  254. { TK_CF_RETURN, "return" },
  255. { TK_CF_DISCARD, "discard" },
  256. { TK_UNIFORM, "uniform" },
  257. { TK_VARYING, "varying" },
  258. { TK_ARG_IN, "in" },
  259. { TK_ARG_OUT, "out" },
  260. { TK_ARG_INOUT, "inout" },
  261. { TK_RENDER_MODE, "render_mode" },
  262. { TK_HINT_WHITE_TEXTURE, "hint_white" },
  263. { TK_HINT_BLACK_TEXTURE, "hint_black" },
  264. { TK_HINT_NORMAL_TEXTURE, "hint_normal" },
  265. { TK_HINT_ANISO_TEXTURE, "hint_aniso" },
  266. { TK_HINT_ALBEDO_TEXTURE, "hint_albedo" },
  267. { TK_HINT_BLACK_ALBEDO_TEXTURE, "hint_black_albedo" },
  268. { TK_HINT_COLOR, "hint_color" },
  269. { TK_HINT_RANGE, "hint_range" },
  270. { TK_SHADER_TYPE, "shader_type" },
  271. { TK_ERROR, NULL }
  272. };
  273. ShaderLanguage::Token ShaderLanguage::_get_token() {
  274. #define GETCHAR(m_idx) (((char_idx + m_idx) < code.length()) ? code[char_idx + m_idx] : CharType(0))
  275. while (true) {
  276. char_idx++;
  277. switch (GETCHAR(-1)) {
  278. case 0:
  279. return _make_token(TK_EOF);
  280. case 0xFFFF:
  281. return _make_token(TK_CURSOR); //for completion
  282. case '\t':
  283. case '\r':
  284. case ' ':
  285. continue;
  286. case '\n':
  287. tk_line++;
  288. continue;
  289. case '/': {
  290. switch (GETCHAR(0)) {
  291. case '*': { // block comment
  292. char_idx++;
  293. while (true) {
  294. if (GETCHAR(0) == 0) {
  295. return _make_token(TK_EOF);
  296. }
  297. if (GETCHAR(0) == '*' && GETCHAR(1) == '/') {
  298. char_idx += 2;
  299. break;
  300. } else if (GETCHAR(0) == '\n') {
  301. tk_line++;
  302. }
  303. char_idx++;
  304. }
  305. } break;
  306. case '/': { // line comment skip
  307. while (true) {
  308. if (GETCHAR(0) == '\n') {
  309. char_idx++;
  310. break;
  311. }
  312. if (GETCHAR(0) == 0) {
  313. return _make_token(TK_EOF);
  314. }
  315. char_idx++;
  316. }
  317. } break;
  318. case '=': { // diveq
  319. char_idx++;
  320. return _make_token(TK_OP_ASSIGN_DIV);
  321. } break;
  322. default:
  323. return _make_token(TK_OP_DIV);
  324. }
  325. continue; //a comment, continue to next token
  326. } break;
  327. case '=': {
  328. if (GETCHAR(0) == '=') {
  329. char_idx++;
  330. return _make_token(TK_OP_EQUAL);
  331. }
  332. return _make_token(TK_OP_ASSIGN);
  333. } break;
  334. case '<': {
  335. if (GETCHAR(0) == '=') {
  336. char_idx++;
  337. return _make_token(TK_OP_LESS_EQUAL);
  338. } else if (GETCHAR(0) == '<') {
  339. char_idx++;
  340. if (GETCHAR(0) == '=') {
  341. char_idx++;
  342. return _make_token(TK_OP_ASSIGN_SHIFT_LEFT);
  343. }
  344. return _make_token(TK_OP_SHIFT_LEFT);
  345. }
  346. return _make_token(TK_OP_LESS);
  347. } break;
  348. case '>': {
  349. if (GETCHAR(0) == '=') {
  350. char_idx++;
  351. return _make_token(TK_OP_GREATER_EQUAL);
  352. } else if (GETCHAR(0) == '>') {
  353. char_idx++;
  354. if (GETCHAR(0) == '=') {
  355. char_idx++;
  356. return _make_token(TK_OP_ASSIGN_SHIFT_RIGHT);
  357. }
  358. return _make_token(TK_OP_SHIFT_RIGHT);
  359. }
  360. return _make_token(TK_OP_GREATER);
  361. } break;
  362. case '!': {
  363. if (GETCHAR(0) == '=') {
  364. char_idx++;
  365. return _make_token(TK_OP_NOT_EQUAL);
  366. }
  367. return _make_token(TK_OP_NOT);
  368. } break;
  369. //case '"' //string - no strings in shader
  370. //case '\'' //string - no strings in shader
  371. case '{':
  372. return _make_token(TK_CURLY_BRACKET_OPEN);
  373. case '}':
  374. return _make_token(TK_CURLY_BRACKET_CLOSE);
  375. case '[':
  376. return _make_token(TK_BRACKET_OPEN);
  377. case ']':
  378. return _make_token(TK_BRACKET_CLOSE);
  379. case '(':
  380. return _make_token(TK_PARENTHESIS_OPEN);
  381. case ')':
  382. return _make_token(TK_PARENTHESIS_CLOSE);
  383. case ',':
  384. return _make_token(TK_COMMA);
  385. case ';':
  386. return _make_token(TK_SEMICOLON);
  387. case '?':
  388. return _make_token(TK_QUESTION);
  389. case ':':
  390. return _make_token(TK_COLON);
  391. case '^':
  392. return _make_token(TK_OP_BIT_XOR);
  393. case '~':
  394. return _make_token(TK_OP_BIT_INVERT);
  395. case '&': {
  396. if (GETCHAR(0) == '=') {
  397. char_idx++;
  398. return _make_token(TK_OP_ASSIGN_BIT_AND);
  399. } else if (GETCHAR(0) == '&') {
  400. char_idx++;
  401. return _make_token(TK_OP_AND);
  402. }
  403. return _make_token(TK_OP_BIT_AND);
  404. } break;
  405. case '|': {
  406. if (GETCHAR(0) == '=') {
  407. char_idx++;
  408. return _make_token(TK_OP_ASSIGN_BIT_OR);
  409. } else if (GETCHAR(0) == '|') {
  410. char_idx++;
  411. return _make_token(TK_OP_OR);
  412. }
  413. return _make_token(TK_OP_BIT_OR);
  414. } break;
  415. case '*': {
  416. if (GETCHAR(0) == '=') {
  417. char_idx++;
  418. return _make_token(TK_OP_ASSIGN_MUL);
  419. }
  420. return _make_token(TK_OP_MUL);
  421. } break;
  422. case '+': {
  423. if (GETCHAR(0) == '=') {
  424. char_idx++;
  425. return _make_token(TK_OP_ASSIGN_ADD);
  426. } else if (GETCHAR(0) == '+') {
  427. char_idx++;
  428. return _make_token(TK_OP_INCREMENT);
  429. }
  430. return _make_token(TK_OP_ADD);
  431. } break;
  432. case '-': {
  433. if (GETCHAR(0) == '=') {
  434. char_idx++;
  435. return _make_token(TK_OP_ASSIGN_SUB);
  436. } else if (GETCHAR(0) == '-') {
  437. char_idx++;
  438. return _make_token(TK_OP_DECREMENT);
  439. }
  440. return _make_token(TK_OP_SUB);
  441. } break;
  442. case '%': {
  443. if (GETCHAR(0) == '=') {
  444. char_idx++;
  445. return _make_token(TK_OP_ASSIGN_MOD);
  446. }
  447. return _make_token(TK_OP_MOD);
  448. } break;
  449. default: {
  450. char_idx--; //go back one, since we have no idea what this is
  451. if (_is_number(GETCHAR(0)) || (GETCHAR(0) == '.' && _is_number(GETCHAR(1)))) {
  452. // parse number
  453. bool period_found = false;
  454. bool exponent_found = false;
  455. bool hexa_found = false;
  456. bool sign_found = false;
  457. bool minus_exponent_found = false;
  458. String str;
  459. int i = 0;
  460. while (true) {
  461. if (GETCHAR(i) == '.') {
  462. if (period_found || exponent_found)
  463. return _make_token(TK_ERROR, "Invalid numeric constant");
  464. period_found = true;
  465. } else if (GETCHAR(i) == 'x') {
  466. if (hexa_found || str.length() != 1 || str[0] != '0')
  467. return _make_token(TK_ERROR, "Invalid numeric constant");
  468. hexa_found = true;
  469. } else if (GETCHAR(i) == 'e') {
  470. if (hexa_found || exponent_found)
  471. return _make_token(TK_ERROR, "Invalid numeric constant");
  472. exponent_found = true;
  473. } else if (_is_number(GETCHAR(i))) {
  474. //all ok
  475. } else if (hexa_found && _is_hex(GETCHAR(i))) {
  476. } else if ((GETCHAR(i) == '-' || GETCHAR(i) == '+') && exponent_found) {
  477. if (sign_found)
  478. return _make_token(TK_ERROR, "Invalid numeric constant");
  479. sign_found = true;
  480. if (GETCHAR(i) == '-')
  481. minus_exponent_found = true;
  482. } else
  483. break;
  484. str += CharType(GETCHAR(i));
  485. i++;
  486. }
  487. if (!_is_number(str[str.length() - 1]))
  488. return _make_token(TK_ERROR, "Invalid numeric constant");
  489. char_idx += str.length();
  490. Token tk;
  491. if (period_found || minus_exponent_found)
  492. tk.type = TK_REAL_CONSTANT;
  493. else
  494. tk.type = TK_INT_CONSTANT;
  495. if (!str.is_valid_float()) {
  496. return _make_token(TK_ERROR, "Invalid numeric constant");
  497. }
  498. tk.constant = str.to_double();
  499. tk.line = tk_line;
  500. return tk;
  501. }
  502. if (GETCHAR(0) == '.') {
  503. //parse period
  504. char_idx++;
  505. return _make_token(TK_PERIOD);
  506. }
  507. if (_is_text_char(GETCHAR(0))) {
  508. // parse identifier
  509. String str;
  510. while (_is_text_char(GETCHAR(0))) {
  511. str += CharType(GETCHAR(0));
  512. char_idx++;
  513. }
  514. //see if keyword
  515. //should be converted to a static map
  516. int idx = 0;
  517. while (keyword_list[idx].text) {
  518. if (str == keyword_list[idx].text) {
  519. return _make_token(keyword_list[idx].token);
  520. }
  521. idx++;
  522. }
  523. return _make_token(TK_IDENTIFIER, str);
  524. }
  525. if (GETCHAR(0) > 32)
  526. return _make_token(TK_ERROR, "Tokenizer: Unknown character #" + itos(GETCHAR(0)) + ": '" + String::chr(GETCHAR(0)) + "'");
  527. else
  528. return _make_token(TK_ERROR, "Tokenizer: Unknown character #" + itos(GETCHAR(0)));
  529. } break;
  530. }
  531. }
  532. ERR_PRINT("BUG");
  533. return Token();
  534. }
  535. String ShaderLanguage::token_debug(const String &p_code) {
  536. clear();
  537. code = p_code;
  538. String output;
  539. Token tk = _get_token();
  540. while (tk.type != TK_EOF && tk.type != TK_ERROR) {
  541. output += itos(tk_line) + ": " + get_token_text(tk) + "\n";
  542. tk = _get_token();
  543. }
  544. return output;
  545. }
  546. bool ShaderLanguage::is_token_datatype(TokenType p_type) {
  547. return (
  548. p_type == TK_TYPE_VOID ||
  549. p_type == TK_TYPE_BOOL ||
  550. p_type == TK_TYPE_BVEC2 ||
  551. p_type == TK_TYPE_BVEC3 ||
  552. p_type == TK_TYPE_BVEC4 ||
  553. p_type == TK_TYPE_INT ||
  554. p_type == TK_TYPE_IVEC2 ||
  555. p_type == TK_TYPE_IVEC3 ||
  556. p_type == TK_TYPE_IVEC4 ||
  557. p_type == TK_TYPE_UINT ||
  558. p_type == TK_TYPE_UVEC2 ||
  559. p_type == TK_TYPE_UVEC3 ||
  560. p_type == TK_TYPE_UVEC4 ||
  561. p_type == TK_TYPE_FLOAT ||
  562. p_type == TK_TYPE_VEC2 ||
  563. p_type == TK_TYPE_VEC3 ||
  564. p_type == TK_TYPE_VEC4 ||
  565. p_type == TK_TYPE_MAT2 ||
  566. p_type == TK_TYPE_MAT3 ||
  567. p_type == TK_TYPE_MAT4 ||
  568. p_type == TK_TYPE_SAMPLER2D ||
  569. p_type == TK_TYPE_ISAMPLER2D ||
  570. p_type == TK_TYPE_USAMPLER2D ||
  571. p_type == TK_TYPE_SAMPLERCUBE);
  572. }
  573. ShaderLanguage::DataType ShaderLanguage::get_token_datatype(TokenType p_type) {
  574. return DataType(p_type - TK_TYPE_VOID);
  575. }
  576. bool ShaderLanguage::is_token_precision(TokenType p_type) {
  577. return (
  578. p_type == TK_PRECISION_LOW ||
  579. p_type == TK_PRECISION_MID ||
  580. p_type == TK_PRECISION_HIGH);
  581. }
  582. ShaderLanguage::DataPrecision ShaderLanguage::get_token_precision(TokenType p_type) {
  583. if (p_type == TK_PRECISION_LOW)
  584. return PRECISION_LOWP;
  585. else if (p_type == TK_PRECISION_HIGH)
  586. return PRECISION_HIGHP;
  587. else
  588. return PRECISION_MEDIUMP;
  589. }
  590. String ShaderLanguage::get_datatype_name(DataType p_type) {
  591. switch (p_type) {
  592. case TYPE_VOID: return "void";
  593. case TYPE_BOOL: return "bool";
  594. case TYPE_BVEC2: return "bvec2";
  595. case TYPE_BVEC3: return "bvec3";
  596. case TYPE_BVEC4: return "bvec4";
  597. case TYPE_INT: return "int";
  598. case TYPE_IVEC2: return "ivec2";
  599. case TYPE_IVEC3: return "ivec3";
  600. case TYPE_IVEC4: return "ivec4";
  601. case TYPE_UINT: return "uint";
  602. case TYPE_UVEC2: return "uvec2";
  603. case TYPE_UVEC3: return "uvec3";
  604. case TYPE_UVEC4: return "uvec4";
  605. case TYPE_FLOAT: return "float";
  606. case TYPE_VEC2: return "vec2";
  607. case TYPE_VEC3: return "vec3";
  608. case TYPE_VEC4: return "vec4";
  609. case TYPE_MAT2: return "mat2";
  610. case TYPE_MAT3: return "mat3";
  611. case TYPE_MAT4: return "mat4";
  612. case TYPE_SAMPLER2D: return "sampler2D";
  613. case TYPE_ISAMPLER2D: return "isampler2D";
  614. case TYPE_USAMPLER2D: return "usampler2D";
  615. case TYPE_SAMPLERCUBE: return "samplerCube";
  616. }
  617. return "";
  618. }
  619. bool ShaderLanguage::is_token_nonvoid_datatype(TokenType p_type) {
  620. return is_token_datatype(p_type) && p_type != TK_TYPE_VOID;
  621. }
  622. void ShaderLanguage::clear() {
  623. current_function = StringName();
  624. completion_type = COMPLETION_NONE;
  625. completion_block = NULL;
  626. completion_function = StringName();
  627. error_line = 0;
  628. tk_line = 1;
  629. char_idx = 0;
  630. error_set = false;
  631. error_str = "";
  632. while (nodes) {
  633. Node *n = nodes;
  634. nodes = nodes->next;
  635. memdelete(n);
  636. }
  637. }
  638. bool ShaderLanguage::_find_identifier(const BlockNode *p_block, const Map<StringName, DataType> &p_builtin_types, const StringName &p_identifier, DataType *r_data_type, IdentifierType *r_type) {
  639. if (p_builtin_types.has(p_identifier)) {
  640. if (r_data_type) {
  641. *r_data_type = p_builtin_types[p_identifier];
  642. }
  643. if (r_type) {
  644. *r_type = IDENTIFIER_BUILTIN_VAR;
  645. }
  646. return true;
  647. }
  648. FunctionNode *function = NULL;
  649. while (p_block) {
  650. if (p_block->variables.has(p_identifier)) {
  651. if (r_data_type) {
  652. *r_data_type = p_block->variables[p_identifier].type;
  653. }
  654. if (r_type) {
  655. *r_type = IDENTIFIER_LOCAL_VAR;
  656. }
  657. return true;
  658. }
  659. if (p_block->parent_function) {
  660. function = p_block->parent_function;
  661. break;
  662. } else {
  663. ERR_FAIL_COND_V(!p_block->parent_block, false);
  664. p_block = p_block->parent_block;
  665. }
  666. }
  667. if (function) {
  668. for (int i = 0; i < function->arguments.size(); i++) {
  669. if (function->arguments[i].name == p_identifier) {
  670. if (r_data_type) {
  671. *r_data_type = function->arguments[i].type;
  672. }
  673. if (r_type) {
  674. *r_type = IDENTIFIER_FUNCTION_ARGUMENT;
  675. }
  676. return true;
  677. }
  678. }
  679. }
  680. if (shader->varyings.has(p_identifier)) {
  681. if (r_data_type) {
  682. *r_data_type = shader->varyings[p_identifier].type;
  683. }
  684. if (r_type) {
  685. *r_type = IDENTIFIER_VARYING;
  686. }
  687. return true;
  688. }
  689. if (shader->uniforms.has(p_identifier)) {
  690. if (r_data_type) {
  691. *r_data_type = shader->uniforms[p_identifier].type;
  692. }
  693. if (r_type) {
  694. *r_type = IDENTIFIER_UNIFORM;
  695. }
  696. return true;
  697. }
  698. for (int i = 0; i < shader->functions.size(); i++) {
  699. if (!shader->functions[i].callable)
  700. continue;
  701. if (shader->functions[i].name == p_identifier) {
  702. if (r_data_type) {
  703. *r_data_type = shader->functions[i].function->return_type;
  704. }
  705. if (r_type) {
  706. *r_type = IDENTIFIER_FUNCTION;
  707. }
  708. }
  709. }
  710. return false;
  711. }
  712. bool ShaderLanguage::_validate_operator(OperatorNode *p_op, DataType *r_ret_type) {
  713. bool valid = false;
  714. DataType ret_type;
  715. switch (p_op->op) {
  716. case OP_EQUAL:
  717. case OP_NOT_EQUAL: {
  718. DataType na = p_op->arguments[0]->get_datatype();
  719. DataType nb = p_op->arguments[1]->get_datatype();
  720. valid = na == nb;
  721. ret_type = TYPE_BOOL;
  722. } break;
  723. case OP_LESS:
  724. case OP_LESS_EQUAL:
  725. case OP_GREATER:
  726. case OP_GREATER_EQUAL: {
  727. DataType na = p_op->arguments[0]->get_datatype();
  728. DataType nb = p_op->arguments[1]->get_datatype();
  729. valid = na == nb && (na == TYPE_UINT || na == TYPE_INT || na == TYPE_FLOAT);
  730. ret_type = TYPE_BOOL;
  731. } break;
  732. case OP_AND:
  733. case OP_OR: {
  734. DataType na = p_op->arguments[0]->get_datatype();
  735. DataType nb = p_op->arguments[1]->get_datatype();
  736. valid = na == nb && na == TYPE_BOOL;
  737. ret_type = TYPE_BOOL;
  738. } break;
  739. case OP_NOT: {
  740. DataType na = p_op->arguments[0]->get_datatype();
  741. valid = na == TYPE_BOOL;
  742. ret_type = TYPE_BOOL;
  743. } break;
  744. case OP_INCREMENT:
  745. case OP_DECREMENT:
  746. case OP_POST_INCREMENT:
  747. case OP_POST_DECREMENT:
  748. case OP_NEGATE: {
  749. DataType na = p_op->arguments[0]->get_datatype();
  750. valid = na > TYPE_BOOL && na < TYPE_MAT2;
  751. ret_type = na;
  752. } break;
  753. case OP_ADD:
  754. case OP_SUB:
  755. case OP_MUL:
  756. case OP_DIV: {
  757. DataType na = p_op->arguments[0]->get_datatype();
  758. DataType nb = p_op->arguments[1]->get_datatype();
  759. if (na > nb) {
  760. //make things easier;
  761. SWAP(na, nb);
  762. }
  763. if (na == nb) {
  764. valid = (na > TYPE_BOOL && na <= TYPE_MAT4);
  765. ret_type = na;
  766. } else if (na == TYPE_INT && nb == TYPE_IVEC2) {
  767. valid = true;
  768. ret_type = TYPE_IVEC2;
  769. } else if (na == TYPE_INT && nb == TYPE_IVEC3) {
  770. valid = true;
  771. ret_type = TYPE_IVEC3;
  772. } else if (na == TYPE_INT && nb == TYPE_IVEC4) {
  773. valid = true;
  774. ret_type = TYPE_IVEC4;
  775. } else if (na == TYPE_UINT && nb == TYPE_UVEC2) {
  776. valid = true;
  777. ret_type = TYPE_UVEC2;
  778. } else if (na == TYPE_UINT && nb == TYPE_UVEC3) {
  779. valid = true;
  780. ret_type = TYPE_UVEC3;
  781. } else if (na == TYPE_UINT && nb == TYPE_UVEC4) {
  782. valid = true;
  783. ret_type = TYPE_UVEC4;
  784. } else if (na == TYPE_FLOAT && nb == TYPE_VEC2) {
  785. valid = true;
  786. ret_type = TYPE_VEC2;
  787. } else if (na == TYPE_FLOAT && nb == TYPE_VEC3) {
  788. valid = true;
  789. ret_type = TYPE_VEC3;
  790. } else if (na == TYPE_FLOAT && nb == TYPE_VEC4) {
  791. valid = true;
  792. ret_type = TYPE_VEC4;
  793. } else if (p_op->op == OP_MUL && na == TYPE_FLOAT && nb == TYPE_MAT2) {
  794. valid = true;
  795. ret_type = TYPE_MAT2;
  796. } else if (p_op->op == OP_MUL && na == TYPE_FLOAT && nb == TYPE_MAT3) {
  797. valid = true;
  798. ret_type = TYPE_MAT3;
  799. } else if (p_op->op == OP_MUL && na == TYPE_FLOAT && nb == TYPE_MAT4) {
  800. valid = true;
  801. ret_type = TYPE_MAT4;
  802. } else if (p_op->op == OP_MUL && na == TYPE_VEC2 && nb == TYPE_MAT2) {
  803. valid = true;
  804. ret_type = TYPE_VEC2;
  805. } else if (p_op->op == OP_MUL && na == TYPE_VEC3 && nb == TYPE_MAT3) {
  806. valid = true;
  807. ret_type = TYPE_VEC3;
  808. } else if (p_op->op == OP_MUL && na == TYPE_VEC4 && nb == TYPE_MAT4) {
  809. valid = true;
  810. ret_type = TYPE_VEC4;
  811. }
  812. } break;
  813. case OP_ASSIGN_MOD:
  814. case OP_MOD: {
  815. /*
  816. * The operator modulus (%) operates on signed or unsigned integers or integer vectors. The operand
  817. * types must both be signed or both be unsigned. The operands cannot be vectors of differing size. If
  818. * one operand is a scalar and the other vector, then the scalar is applied component-wise to the vector,
  819. * resulting in the same type as the vector. If both are vectors of the same size, the result is computed
  820. * component-wise.
  821. */
  822. DataType na = p_op->arguments[0]->get_datatype();
  823. DataType nb = p_op->arguments[1]->get_datatype();
  824. if (na == TYPE_INT && nb == TYPE_INT) {
  825. valid = true;
  826. ret_type = TYPE_INT;
  827. } else if (na == TYPE_IVEC2 && nb == TYPE_INT) {
  828. valid = true;
  829. ret_type = TYPE_IVEC2;
  830. } else if (na == TYPE_IVEC3 && nb == TYPE_INT) {
  831. valid = true;
  832. ret_type = TYPE_IVEC3;
  833. } else if (na == TYPE_IVEC4 && nb == TYPE_INT) {
  834. valid = true;
  835. ret_type = TYPE_IVEC4;
  836. } else if (na == TYPE_IVEC2 && nb == TYPE_IVEC2) {
  837. valid = true;
  838. ret_type = TYPE_IVEC2;
  839. } else if (na == TYPE_IVEC3 && nb == TYPE_IVEC3) {
  840. valid = true;
  841. ret_type = TYPE_IVEC3;
  842. } else if (na == TYPE_IVEC4 && nb == TYPE_IVEC4) {
  843. valid = true;
  844. ret_type = TYPE_IVEC4;
  845. /////
  846. } else if (na == TYPE_UINT && nb == TYPE_UINT) {
  847. valid = true;
  848. ret_type = TYPE_UINT;
  849. } else if (na == TYPE_UVEC2 && nb == TYPE_UINT) {
  850. valid = true;
  851. ret_type = TYPE_UVEC2;
  852. } else if (na == TYPE_UVEC3 && nb == TYPE_UINT) {
  853. valid = true;
  854. ret_type = TYPE_UVEC3;
  855. } else if (na == TYPE_UVEC4 && nb == TYPE_UINT) {
  856. valid = true;
  857. ret_type = TYPE_UVEC4;
  858. } else if (na == TYPE_UVEC2 && nb == TYPE_UVEC2) {
  859. valid = true;
  860. ret_type = TYPE_UVEC2;
  861. } else if (na == TYPE_UVEC3 && nb == TYPE_UVEC3) {
  862. valid = true;
  863. ret_type = TYPE_UVEC3;
  864. } else if (na == TYPE_UVEC4 && nb == TYPE_UVEC4) {
  865. valid = true;
  866. ret_type = TYPE_UVEC4;
  867. }
  868. } break;
  869. case OP_ASSIGN_SHIFT_LEFT:
  870. case OP_ASSIGN_SHIFT_RIGHT:
  871. case OP_SHIFT_LEFT:
  872. case OP_SHIFT_RIGHT: {
  873. DataType na = p_op->arguments[0]->get_datatype();
  874. DataType nb = p_op->arguments[1]->get_datatype();
  875. if (na == TYPE_INT && nb == TYPE_INT) {
  876. valid = true;
  877. ret_type = TYPE_INT;
  878. } else if (na == TYPE_IVEC2 && nb == TYPE_INT) {
  879. valid = true;
  880. ret_type = TYPE_IVEC2;
  881. } else if (na == TYPE_IVEC3 && nb == TYPE_INT) {
  882. valid = true;
  883. ret_type = TYPE_IVEC3;
  884. } else if (na == TYPE_IVEC4 && nb == TYPE_INT) {
  885. valid = true;
  886. ret_type = TYPE_IVEC4;
  887. } else if (na == TYPE_IVEC2 && nb == TYPE_IVEC2) {
  888. valid = true;
  889. ret_type = TYPE_IVEC2;
  890. } else if (na == TYPE_IVEC3 && nb == TYPE_IVEC3) {
  891. valid = true;
  892. ret_type = TYPE_IVEC3;
  893. } else if (na == TYPE_IVEC4 && nb == TYPE_IVEC4) {
  894. valid = true;
  895. ret_type = TYPE_IVEC4;
  896. } else if (na == TYPE_UINT && nb == TYPE_UINT) {
  897. valid = true;
  898. ret_type = TYPE_UINT;
  899. } else if (na == TYPE_UVEC2 && nb == TYPE_UINT) {
  900. valid = true;
  901. ret_type = TYPE_UVEC2;
  902. } else if (na == TYPE_UVEC3 && nb == TYPE_UINT) {
  903. valid = true;
  904. ret_type = TYPE_UVEC3;
  905. } else if (na == TYPE_UVEC4 && nb == TYPE_UINT) {
  906. valid = true;
  907. ret_type = TYPE_UVEC4;
  908. } else if (na == TYPE_UVEC2 && nb == TYPE_UVEC2) {
  909. valid = true;
  910. ret_type = TYPE_UVEC2;
  911. } else if (na == TYPE_UVEC3 && nb == TYPE_UVEC3) {
  912. valid = true;
  913. ret_type = TYPE_UVEC3;
  914. } else if (na == TYPE_UVEC4 && nb == TYPE_UVEC4) {
  915. valid = true;
  916. ret_type = TYPE_UVEC4;
  917. }
  918. } break;
  919. case OP_ASSIGN: {
  920. DataType na = p_op->arguments[0]->get_datatype();
  921. DataType nb = p_op->arguments[1]->get_datatype();
  922. valid = na == nb;
  923. ret_type = na;
  924. } break;
  925. case OP_ASSIGN_ADD:
  926. case OP_ASSIGN_SUB:
  927. case OP_ASSIGN_MUL:
  928. case OP_ASSIGN_DIV: {
  929. DataType na = p_op->arguments[0]->get_datatype();
  930. DataType nb = p_op->arguments[1]->get_datatype();
  931. if (na == nb) {
  932. valid = (na > TYPE_BOOL && na < TYPE_MAT2) || (p_op->op == OP_ASSIGN_MUL && na >= TYPE_MAT2 && na <= TYPE_MAT4);
  933. ret_type = na;
  934. } else if (na == TYPE_IVEC2 && nb == TYPE_INT) {
  935. valid = true;
  936. ret_type = TYPE_IVEC2;
  937. } else if (na == TYPE_IVEC3 && nb == TYPE_INT) {
  938. valid = true;
  939. ret_type = TYPE_IVEC3;
  940. } else if (na == TYPE_IVEC4 && nb == TYPE_INT) {
  941. valid = true;
  942. ret_type = TYPE_IVEC4;
  943. } else if (na == TYPE_UVEC2 && nb == TYPE_UINT) {
  944. valid = true;
  945. ret_type = TYPE_UVEC2;
  946. } else if (na == TYPE_UVEC3 && nb == TYPE_UINT) {
  947. valid = true;
  948. ret_type = TYPE_UVEC3;
  949. } else if (na == TYPE_UVEC4 && nb == TYPE_UINT) {
  950. valid = true;
  951. ret_type = TYPE_UVEC4;
  952. } else if (na == TYPE_VEC2 && nb == TYPE_FLOAT) {
  953. valid = true;
  954. ret_type = TYPE_VEC2;
  955. } else if (na == TYPE_VEC3 && nb == TYPE_FLOAT) {
  956. valid = true;
  957. ret_type = TYPE_VEC3;
  958. } else if (na == TYPE_VEC4 && nb == TYPE_FLOAT) {
  959. valid = true;
  960. ret_type = TYPE_VEC4;
  961. } else if (p_op->op == OP_ASSIGN_MUL && na == TYPE_MAT2 && nb == TYPE_VEC2) {
  962. valid = true;
  963. ret_type = TYPE_MAT2;
  964. } else if (p_op->op == OP_ASSIGN_MUL && na == TYPE_MAT3 && nb == TYPE_VEC3) {
  965. valid = true;
  966. ret_type = TYPE_MAT3;
  967. } else if (p_op->op == OP_ASSIGN_MUL && na == TYPE_MAT4 && nb == TYPE_VEC4) {
  968. valid = true;
  969. ret_type = TYPE_MAT4;
  970. }
  971. } break;
  972. case OP_ASSIGN_BIT_AND:
  973. case OP_ASSIGN_BIT_OR:
  974. case OP_ASSIGN_BIT_XOR:
  975. case OP_BIT_AND:
  976. case OP_BIT_OR:
  977. case OP_BIT_XOR: {
  978. /*
  979. * The bitwise operators and (&), exclusive-or (^), and inclusive-or (|). The operands must be of type
  980. * signed or unsigned integers or integer vectors. The operands cannot be vectors of differing size. If
  981. * one operand is a scalar and the other a vector, the scalar is applied component-wise to the vector,
  982. * resulting in the same type as the vector. The fundamental types of the operands (signed or unsigned)
  983. * must match.
  984. */
  985. DataType na = p_op->arguments[0]->get_datatype();
  986. DataType nb = p_op->arguments[1]->get_datatype();
  987. if (na > nb && p_op->op >= OP_BIT_AND) {
  988. //can swap for non assign
  989. SWAP(na, nb);
  990. }
  991. if (na == TYPE_INT && nb == TYPE_INT) {
  992. valid = true;
  993. ret_type = TYPE_INT;
  994. } else if (na == TYPE_IVEC2 && nb == TYPE_INT) {
  995. valid = true;
  996. ret_type = TYPE_IVEC2;
  997. } else if (na == TYPE_IVEC3 && nb == TYPE_INT) {
  998. valid = true;
  999. ret_type = TYPE_IVEC3;
  1000. } else if (na == TYPE_IVEC4 && nb == TYPE_INT) {
  1001. valid = true;
  1002. ret_type = TYPE_IVEC4;
  1003. } else if (na == TYPE_IVEC2 && nb == TYPE_IVEC2) {
  1004. valid = true;
  1005. ret_type = TYPE_IVEC2;
  1006. } else if (na == TYPE_IVEC3 && nb == TYPE_IVEC3) {
  1007. valid = true;
  1008. ret_type = TYPE_IVEC3;
  1009. } else if (na == TYPE_IVEC4 && nb == TYPE_IVEC4) {
  1010. valid = true;
  1011. ret_type = TYPE_IVEC4;
  1012. /////
  1013. } else if (na == TYPE_UINT && nb == TYPE_UINT) {
  1014. valid = true;
  1015. ret_type = TYPE_UINT;
  1016. } else if (na == TYPE_UVEC2 && nb == TYPE_UINT) {
  1017. valid = true;
  1018. ret_type = TYPE_UVEC2;
  1019. } else if (na == TYPE_UVEC3 && nb == TYPE_UINT) {
  1020. valid = true;
  1021. ret_type = TYPE_UVEC3;
  1022. } else if (na == TYPE_UVEC4 && nb == TYPE_UINT) {
  1023. valid = true;
  1024. ret_type = TYPE_UVEC4;
  1025. } else if (na == TYPE_UVEC2 && nb == TYPE_UVEC2) {
  1026. valid = true;
  1027. ret_type = TYPE_UVEC2;
  1028. } else if (na == TYPE_UVEC3 && nb == TYPE_UVEC3) {
  1029. valid = true;
  1030. ret_type = TYPE_UVEC3;
  1031. } else if (na == TYPE_UVEC4 && nb == TYPE_UVEC4) {
  1032. valid = true;
  1033. ret_type = TYPE_UVEC4;
  1034. }
  1035. } break;
  1036. case OP_BIT_INVERT: { //unaries
  1037. DataType na = p_op->arguments[0]->get_datatype();
  1038. valid = na >= TYPE_INT && na < TYPE_FLOAT;
  1039. ret_type = na;
  1040. } break;
  1041. case OP_SELECT_IF: {
  1042. DataType na = p_op->arguments[0]->get_datatype();
  1043. DataType nb = p_op->arguments[1]->get_datatype();
  1044. DataType nc = p_op->arguments[2]->get_datatype();
  1045. valid = na == TYPE_BOOL && (nb == nc);
  1046. ret_type = nb;
  1047. } break;
  1048. default: {
  1049. ERR_FAIL_V(false);
  1050. }
  1051. }
  1052. if (r_ret_type)
  1053. *r_ret_type = ret_type;
  1054. return valid;
  1055. }
  1056. const ShaderLanguage::BuiltinFuncDef ShaderLanguage::builtin_func_defs[] = {
  1057. //constructors
  1058. { "bool", TYPE_BOOL, { TYPE_BOOL, TYPE_VOID } },
  1059. { "bvec2", TYPE_BVEC2, { TYPE_BOOL, TYPE_VOID } },
  1060. { "bvec2", TYPE_BVEC2, { TYPE_BOOL, TYPE_BOOL, TYPE_VOID } },
  1061. { "bvec3", TYPE_BVEC3, { TYPE_BOOL, TYPE_VOID } },
  1062. { "bvec3", TYPE_BVEC3, { TYPE_BOOL, TYPE_BOOL, TYPE_BOOL, TYPE_VOID } },
  1063. { "bvec3", TYPE_BVEC3, { TYPE_BVEC2, TYPE_BOOL, TYPE_VOID } },
  1064. { "bvec3", TYPE_BVEC3, { TYPE_BOOL, TYPE_BVEC2, TYPE_VOID } },
  1065. { "bvec4", TYPE_BVEC4, { TYPE_BOOL, TYPE_VOID } },
  1066. { "bvec4", TYPE_BVEC4, { TYPE_BOOL, TYPE_BOOL, TYPE_BOOL, TYPE_BOOL, TYPE_VOID } },
  1067. { "bvec4", TYPE_BVEC4, { TYPE_BOOL, TYPE_BVEC2, TYPE_BOOL, TYPE_VOID } },
  1068. { "bvec4", TYPE_BVEC4, { TYPE_BVEC2, TYPE_BOOL, TYPE_BOOL, TYPE_VOID } },
  1069. { "bvec4", TYPE_BVEC4, { TYPE_BOOL, TYPE_BOOL, TYPE_BVEC2, TYPE_VOID } },
  1070. { "bvec4", TYPE_BVEC4, { TYPE_BOOL, TYPE_BVEC3, TYPE_VOID } },
  1071. { "bvec4", TYPE_BVEC4, { TYPE_BVEC3, TYPE_BOOL, TYPE_VOID } },
  1072. { "bvec4", TYPE_BVEC4, { TYPE_BVEC2, TYPE_BVEC2, TYPE_VOID } },
  1073. { "float", TYPE_FLOAT, { TYPE_FLOAT, TYPE_VOID } },
  1074. { "vec2", TYPE_VEC2, { TYPE_FLOAT, TYPE_VOID } },
  1075. { "vec2", TYPE_VEC2, { TYPE_FLOAT, TYPE_FLOAT, TYPE_VOID } },
  1076. { "vec3", TYPE_VEC3, { TYPE_FLOAT, TYPE_VOID } },
  1077. { "vec3", TYPE_VEC3, { TYPE_FLOAT, TYPE_FLOAT, TYPE_FLOAT, TYPE_VOID } },
  1078. { "vec3", TYPE_VEC3, { TYPE_VEC2, TYPE_FLOAT, TYPE_VOID } },
  1079. { "vec3", TYPE_VEC3, { TYPE_FLOAT, TYPE_VEC2, TYPE_VOID } },
  1080. { "vec4", TYPE_VEC4, { TYPE_FLOAT, TYPE_VOID } },
  1081. { "vec4", TYPE_VEC4, { TYPE_FLOAT, TYPE_FLOAT, TYPE_FLOAT, TYPE_FLOAT, TYPE_VOID } },
  1082. { "vec4", TYPE_VEC4, { TYPE_FLOAT, TYPE_VEC2, TYPE_FLOAT, TYPE_VOID } },
  1083. { "vec4", TYPE_VEC4, { TYPE_VEC2, TYPE_FLOAT, TYPE_FLOAT, TYPE_VOID } },
  1084. { "vec4", TYPE_VEC4, { TYPE_FLOAT, TYPE_FLOAT, TYPE_VEC2, TYPE_VOID } },
  1085. { "vec4", TYPE_VEC4, { TYPE_FLOAT, TYPE_VEC3, TYPE_VOID } },
  1086. { "vec4", TYPE_VEC4, { TYPE_VEC3, TYPE_FLOAT, TYPE_VOID } },
  1087. { "vec4", TYPE_VEC4, { TYPE_VEC2, TYPE_VEC2, TYPE_VOID } },
  1088. { "int", TYPE_INT, { TYPE_INT, TYPE_VOID } },
  1089. { "ivec2", TYPE_IVEC2, { TYPE_INT, TYPE_VOID } },
  1090. { "ivec2", TYPE_IVEC2, { TYPE_INT, TYPE_INT, TYPE_VOID } },
  1091. { "ivec3", TYPE_IVEC3, { TYPE_INT, TYPE_VOID } },
  1092. { "ivec3", TYPE_IVEC3, { TYPE_INT, TYPE_INT, TYPE_INT, TYPE_VOID } },
  1093. { "ivec3", TYPE_IVEC3, { TYPE_IVEC2, TYPE_INT, TYPE_VOID } },
  1094. { "ivec3", TYPE_IVEC3, { TYPE_INT, TYPE_IVEC2, TYPE_VOID } },
  1095. { "ivec4", TYPE_IVEC4, { TYPE_INT, TYPE_VOID } },
  1096. { "ivec4", TYPE_IVEC4, { TYPE_INT, TYPE_INT, TYPE_INT, TYPE_INT, TYPE_VOID } },
  1097. { "ivec4", TYPE_IVEC4, { TYPE_INT, TYPE_IVEC2, TYPE_INT, TYPE_VOID } },
  1098. { "ivec4", TYPE_IVEC4, { TYPE_IVEC2, TYPE_INT, TYPE_INT, TYPE_VOID } },
  1099. { "ivec4", TYPE_IVEC4, { TYPE_INT, TYPE_INT, TYPE_IVEC2, TYPE_VOID } },
  1100. { "ivec4", TYPE_IVEC4, { TYPE_INT, TYPE_IVEC3, TYPE_VOID } },
  1101. { "ivec4", TYPE_IVEC4, { TYPE_IVEC3, TYPE_INT, TYPE_VOID } },
  1102. { "ivec4", TYPE_IVEC4, { TYPE_IVEC2, TYPE_IVEC2, TYPE_VOID } },
  1103. { "uint", TYPE_UINT, { TYPE_UINT, TYPE_VOID } },
  1104. { "uvec2", TYPE_UVEC2, { TYPE_UINT, TYPE_VOID } },
  1105. { "uvec2", TYPE_UVEC2, { TYPE_UINT, TYPE_UINT, TYPE_VOID } },
  1106. { "uvec3", TYPE_UVEC3, { TYPE_UINT, TYPE_VOID } },
  1107. { "uvec3", TYPE_UVEC3, { TYPE_UINT, TYPE_UINT, TYPE_UINT, TYPE_VOID } },
  1108. { "uvec3", TYPE_UVEC3, { TYPE_UVEC2, TYPE_UINT, TYPE_VOID } },
  1109. { "uvec3", TYPE_UVEC3, { TYPE_UINT, TYPE_UVEC2, TYPE_VOID } },
  1110. { "uvec4", TYPE_UVEC4, { TYPE_UINT, TYPE_VOID } },
  1111. { "uvec4", TYPE_UVEC4, { TYPE_UINT, TYPE_UINT, TYPE_UINT, TYPE_UINT, TYPE_VOID } },
  1112. { "uvec4", TYPE_UVEC4, { TYPE_UINT, TYPE_UVEC2, TYPE_UINT, TYPE_VOID } },
  1113. { "uvec4", TYPE_UVEC4, { TYPE_UVEC2, TYPE_UINT, TYPE_UINT, TYPE_VOID } },
  1114. { "uvec4", TYPE_UVEC4, { TYPE_UINT, TYPE_UINT, TYPE_UVEC2, TYPE_VOID } },
  1115. { "uvec4", TYPE_UVEC4, { TYPE_UINT, TYPE_UVEC3, TYPE_VOID } },
  1116. { "uvec4", TYPE_UVEC4, { TYPE_UVEC3, TYPE_UINT, TYPE_VOID } },
  1117. { "uvec4", TYPE_UVEC4, { TYPE_UVEC2, TYPE_UVEC2, TYPE_VOID } },
  1118. { "mat2", TYPE_MAT2, { TYPE_VEC2, TYPE_VEC2, TYPE_VOID } },
  1119. { "mat3", TYPE_MAT3, { TYPE_VEC3, TYPE_VEC3, TYPE_VEC3, TYPE_VOID } },
  1120. { "mat4", TYPE_MAT4, { TYPE_VEC4, TYPE_VEC4, TYPE_VEC4, TYPE_VEC4, TYPE_VOID } },
  1121. { "mat2", TYPE_MAT2, { TYPE_FLOAT, TYPE_VOID } },
  1122. { "mat3", TYPE_MAT3, { TYPE_FLOAT, TYPE_VOID } },
  1123. { "mat4", TYPE_MAT4, { TYPE_FLOAT, TYPE_VOID } },
  1124. //conversion scalars
  1125. { "int", TYPE_INT, { TYPE_BOOL, TYPE_VOID } },
  1126. { "int", TYPE_INT, { TYPE_INT, TYPE_VOID } },
  1127. { "int", TYPE_INT, { TYPE_UINT, TYPE_VOID } },
  1128. { "int", TYPE_INT, { TYPE_FLOAT, TYPE_VOID } },
  1129. { "float", TYPE_FLOAT, { TYPE_BOOL, TYPE_VOID } },
  1130. { "float", TYPE_FLOAT, { TYPE_INT, TYPE_VOID } },
  1131. { "float", TYPE_FLOAT, { TYPE_UINT, TYPE_VOID } },
  1132. { "float", TYPE_FLOAT, { TYPE_FLOAT, TYPE_VOID } },
  1133. { "uint", TYPE_UINT, { TYPE_BOOL, TYPE_VOID } },
  1134. { "uint", TYPE_UINT, { TYPE_INT, TYPE_VOID } },
  1135. { "uint", TYPE_UINT, { TYPE_UINT, TYPE_VOID } },
  1136. { "uint", TYPE_UINT, { TYPE_FLOAT, TYPE_VOID } },
  1137. { "bool", TYPE_BOOL, { TYPE_BOOL, TYPE_VOID } },
  1138. { "bool", TYPE_BOOL, { TYPE_INT, TYPE_VOID } },
  1139. { "bool", TYPE_BOOL, { TYPE_UINT, TYPE_VOID } },
  1140. { "bool", TYPE_BOOL, { TYPE_FLOAT, TYPE_VOID } },
  1141. //conversion vectors
  1142. { "ivec2", TYPE_IVEC2, { TYPE_BVEC2, TYPE_VOID } },
  1143. { "ivec2", TYPE_IVEC2, { TYPE_IVEC2, TYPE_VOID } },
  1144. { "ivec2", TYPE_IVEC2, { TYPE_UVEC2, TYPE_VOID } },
  1145. { "ivec2", TYPE_IVEC2, { TYPE_VEC2, TYPE_VOID } },
  1146. { "vec2", TYPE_VEC2, { TYPE_BVEC2, TYPE_VOID } },
  1147. { "vec2", TYPE_VEC2, { TYPE_IVEC2, TYPE_VOID } },
  1148. { "vec2", TYPE_VEC2, { TYPE_UVEC2, TYPE_VOID } },
  1149. { "vec2", TYPE_VEC2, { TYPE_VEC2, TYPE_VOID } },
  1150. { "uvec2", TYPE_UVEC2, { TYPE_BVEC2, TYPE_VOID } },
  1151. { "uvec2", TYPE_UVEC2, { TYPE_IVEC2, TYPE_VOID } },
  1152. { "uvec2", TYPE_UVEC2, { TYPE_UVEC2, TYPE_VOID } },
  1153. { "uvec2", TYPE_UVEC2, { TYPE_VEC2, TYPE_VOID } },
  1154. { "bvec2", TYPE_BVEC2, { TYPE_BVEC2, TYPE_VOID } },
  1155. { "bvec2", TYPE_BVEC2, { TYPE_IVEC2, TYPE_VOID } },
  1156. { "bvec2", TYPE_BVEC2, { TYPE_UVEC2, TYPE_VOID } },
  1157. { "bvec2", TYPE_BVEC2, { TYPE_VEC2, TYPE_VOID } },
  1158. { "ivec3", TYPE_IVEC3, { TYPE_BVEC3, TYPE_VOID } },
  1159. { "ivec3", TYPE_IVEC3, { TYPE_IVEC3, TYPE_VOID } },
  1160. { "ivec3", TYPE_IVEC3, { TYPE_UVEC3, TYPE_VOID } },
  1161. { "ivec3", TYPE_IVEC3, { TYPE_VEC3, TYPE_VOID } },
  1162. { "vec3", TYPE_VEC3, { TYPE_BVEC3, TYPE_VOID } },
  1163. { "vec3", TYPE_VEC3, { TYPE_IVEC3, TYPE_VOID } },
  1164. { "vec3", TYPE_VEC3, { TYPE_UVEC3, TYPE_VOID } },
  1165. { "vec3", TYPE_VEC3, { TYPE_VEC3, TYPE_VOID } },
  1166. { "uvec3", TYPE_UVEC3, { TYPE_BVEC3, TYPE_VOID } },
  1167. { "uvec3", TYPE_UVEC3, { TYPE_IVEC3, TYPE_VOID } },
  1168. { "uvec3", TYPE_UVEC3, { TYPE_UVEC3, TYPE_VOID } },
  1169. { "uvec3", TYPE_UVEC3, { TYPE_VEC3, TYPE_VOID } },
  1170. { "bvec3", TYPE_BVEC3, { TYPE_BVEC3, TYPE_VOID } },
  1171. { "bvec3", TYPE_BVEC3, { TYPE_IVEC3, TYPE_VOID } },
  1172. { "bvec3", TYPE_BVEC3, { TYPE_UVEC3, TYPE_VOID } },
  1173. { "bvec3", TYPE_BVEC3, { TYPE_VEC3, TYPE_VOID } },
  1174. { "ivec4", TYPE_IVEC4, { TYPE_BVEC4, TYPE_VOID } },
  1175. { "ivec4", TYPE_IVEC4, { TYPE_IVEC4, TYPE_VOID } },
  1176. { "ivec4", TYPE_IVEC4, { TYPE_UVEC4, TYPE_VOID } },
  1177. { "ivec4", TYPE_IVEC4, { TYPE_VEC4, TYPE_VOID } },
  1178. { "vec4", TYPE_VEC4, { TYPE_BVEC4, TYPE_VOID } },
  1179. { "vec4", TYPE_VEC4, { TYPE_IVEC4, TYPE_VOID } },
  1180. { "vec4", TYPE_VEC4, { TYPE_UVEC4, TYPE_VOID } },
  1181. { "vec4", TYPE_VEC4, { TYPE_VEC4, TYPE_VOID } },
  1182. { "uvec4", TYPE_UVEC4, { TYPE_BVEC4, TYPE_VOID } },
  1183. { "uvec4", TYPE_UVEC4, { TYPE_IVEC4, TYPE_VOID } },
  1184. { "uvec4", TYPE_UVEC4, { TYPE_UVEC4, TYPE_VOID } },
  1185. { "uvec4", TYPE_UVEC4, { TYPE_VEC4, TYPE_VOID } },
  1186. { "bvec4", TYPE_BVEC4, { TYPE_BVEC4, TYPE_VOID } },
  1187. { "bvec4", TYPE_BVEC4, { TYPE_IVEC4, TYPE_VOID } },
  1188. { "bvec4", TYPE_BVEC4, { TYPE_UVEC4, TYPE_VOID } },
  1189. { "bvec4", TYPE_BVEC4, { TYPE_VEC4, TYPE_VOID } },
  1190. //builtins - trigonometry
  1191. { "sin", TYPE_FLOAT, { TYPE_FLOAT, TYPE_VOID } },
  1192. { "cos", TYPE_FLOAT, { TYPE_FLOAT, TYPE_VOID } },
  1193. { "tan", TYPE_FLOAT, { TYPE_FLOAT, TYPE_VOID } },
  1194. { "asin", TYPE_FLOAT, { TYPE_FLOAT, TYPE_VOID } },
  1195. { "acos", TYPE_FLOAT, { TYPE_FLOAT, TYPE_VOID } },
  1196. { "atan", TYPE_FLOAT, { TYPE_FLOAT, TYPE_VOID } },
  1197. { "atan2", TYPE_FLOAT, { TYPE_FLOAT, TYPE_FLOAT, TYPE_VOID } },
  1198. { "sinh", TYPE_FLOAT, { TYPE_FLOAT, TYPE_VOID } },
  1199. { "cosh", TYPE_FLOAT, { TYPE_FLOAT, TYPE_VOID } },
  1200. { "tanh", TYPE_FLOAT, { TYPE_FLOAT, TYPE_VOID } },
  1201. //builtins - exponential
  1202. { "pow", TYPE_FLOAT, { TYPE_FLOAT, TYPE_FLOAT, TYPE_VOID } },
  1203. { "pow", TYPE_VEC2, { TYPE_VEC2, TYPE_VEC2, TYPE_VOID } },
  1204. { "pow", TYPE_VEC3, { TYPE_VEC3, TYPE_VEC3, TYPE_VOID } },
  1205. { "pow", TYPE_VEC4, { TYPE_VEC4, TYPE_VEC4, TYPE_VOID } },
  1206. { "exp", TYPE_FLOAT, { TYPE_FLOAT, TYPE_VOID } },
  1207. { "exp", TYPE_VEC2, { TYPE_VEC2, TYPE_VOID } },
  1208. { "exp", TYPE_VEC3, { TYPE_VEC3, TYPE_VOID } },
  1209. { "exp", TYPE_VEC4, { TYPE_VEC4, TYPE_VOID } },
  1210. { "log", TYPE_FLOAT, { TYPE_FLOAT, TYPE_VOID } },
  1211. { "log", TYPE_VEC2, { TYPE_VEC2, TYPE_VOID } },
  1212. { "log", TYPE_VEC3, { TYPE_VEC3, TYPE_VOID } },
  1213. { "log", TYPE_VEC4, { TYPE_VEC4, TYPE_VOID } },
  1214. { "sqrt", TYPE_FLOAT, { TYPE_FLOAT, TYPE_VOID } },
  1215. { "sqrt", TYPE_VEC2, { TYPE_VEC2, TYPE_VOID } },
  1216. { "sqrt", TYPE_VEC3, { TYPE_VEC3, TYPE_VOID } },
  1217. { "sqrt", TYPE_VEC4, { TYPE_VEC4, TYPE_VOID } },
  1218. { "inversesqrt", TYPE_FLOAT, { TYPE_FLOAT, TYPE_VOID } },
  1219. { "inversesqrt", TYPE_VEC2, { TYPE_VEC2, TYPE_VOID } },
  1220. { "inversesqrt", TYPE_VEC3, { TYPE_VEC3, TYPE_VOID } },
  1221. { "inversesqrt", TYPE_VEC4, { TYPE_VEC4, TYPE_VOID } },
  1222. //builtins - common
  1223. { "abs", TYPE_FLOAT, { TYPE_FLOAT, TYPE_VOID } },
  1224. { "abs", TYPE_VEC2, { TYPE_VEC2, TYPE_VOID } },
  1225. { "abs", TYPE_VEC3, { TYPE_VEC3, TYPE_VOID } },
  1226. { "abs", TYPE_VEC4, { TYPE_VEC4, TYPE_VOID } },
  1227. { "abs", TYPE_INT, { TYPE_INT, TYPE_VOID } },
  1228. { "abs", TYPE_IVEC2, { TYPE_IVEC2, TYPE_VOID } },
  1229. { "abs", TYPE_IVEC3, { TYPE_IVEC3, TYPE_VOID } },
  1230. { "abs", TYPE_IVEC4, { TYPE_IVEC4, TYPE_VOID } },
  1231. { "abs", TYPE_UINT, { TYPE_UINT, TYPE_VOID } },
  1232. { "abs", TYPE_UVEC2, { TYPE_UVEC2, TYPE_VOID } },
  1233. { "abs", TYPE_UVEC3, { TYPE_UVEC3, TYPE_VOID } },
  1234. { "abs", TYPE_UVEC4, { TYPE_UVEC4, TYPE_VOID } },
  1235. { "sign", TYPE_FLOAT, { TYPE_FLOAT, TYPE_VOID } },
  1236. { "sign", TYPE_VEC2, { TYPE_VEC2, TYPE_VOID } },
  1237. { "sign", TYPE_VEC3, { TYPE_VEC3, TYPE_VOID } },
  1238. { "sign", TYPE_VEC4, { TYPE_VEC4, TYPE_VOID } },
  1239. { "sign", TYPE_INT, { TYPE_INT, TYPE_VOID } },
  1240. { "sign", TYPE_IVEC2, { TYPE_IVEC2, TYPE_VOID } },
  1241. { "sign", TYPE_IVEC3, { TYPE_IVEC3, TYPE_VOID } },
  1242. { "sign", TYPE_IVEC4, { TYPE_IVEC4, TYPE_VOID } },
  1243. { "floor", TYPE_FLOAT, { TYPE_FLOAT, TYPE_VOID } },
  1244. { "floor", TYPE_VEC2, { TYPE_VEC2, TYPE_VOID } },
  1245. { "floor", TYPE_VEC3, { TYPE_VEC3, TYPE_VOID } },
  1246. { "floor", TYPE_VEC4, { TYPE_VEC4, TYPE_VOID } },
  1247. { "trunc", TYPE_FLOAT, { TYPE_FLOAT, TYPE_VOID } },
  1248. { "trunc", TYPE_VEC2, { TYPE_VEC2, TYPE_VOID } },
  1249. { "trunc", TYPE_VEC3, { TYPE_VEC3, TYPE_VOID } },
  1250. { "trunc", TYPE_VEC4, { TYPE_VEC4, TYPE_VOID } },
  1251. { "round", TYPE_FLOAT, { TYPE_FLOAT, TYPE_VOID } },
  1252. { "round", TYPE_VEC2, { TYPE_VEC2, TYPE_VOID } },
  1253. { "round", TYPE_VEC3, { TYPE_VEC3, TYPE_VOID } },
  1254. { "round", TYPE_VEC4, { TYPE_VEC4, TYPE_VOID } },
  1255. { "ceil", TYPE_FLOAT, { TYPE_FLOAT, TYPE_VOID } },
  1256. { "ceil", TYPE_VEC2, { TYPE_VEC2, TYPE_VOID } },
  1257. { "ceil", TYPE_VEC3, { TYPE_VEC3, TYPE_VOID } },
  1258. { "ceil", TYPE_VEC4, { TYPE_VEC4, TYPE_VOID } },
  1259. { "fract", TYPE_FLOAT, { TYPE_FLOAT, TYPE_VOID } },
  1260. { "fract", TYPE_VEC2, { TYPE_VEC2, TYPE_VOID } },
  1261. { "fract", TYPE_VEC3, { TYPE_VEC3, TYPE_VOID } },
  1262. { "fract", TYPE_VEC4, { TYPE_VEC4, TYPE_VOID } },
  1263. { "mod", TYPE_FLOAT, { TYPE_FLOAT, TYPE_FLOAT, TYPE_VOID } },
  1264. { "mod", TYPE_VEC2, { TYPE_VEC2, TYPE_VEC2, TYPE_VOID } },
  1265. { "mod", TYPE_VEC2, { TYPE_VEC2, TYPE_FLOAT, TYPE_VOID } },
  1266. { "mod", TYPE_VEC3, { TYPE_VEC3, TYPE_VEC3, TYPE_VOID } },
  1267. { "mod", TYPE_VEC3, { TYPE_VEC3, TYPE_FLOAT, TYPE_VOID } },
  1268. { "mod", TYPE_VEC4, { TYPE_VEC4, TYPE_VEC4, TYPE_VOID } },
  1269. { "mod", TYPE_VEC4, { TYPE_VEC4, TYPE_FLOAT, TYPE_VOID } },
  1270. { "modf", TYPE_FLOAT, { TYPE_FLOAT, TYPE_FLOAT, TYPE_VOID } },
  1271. { "modf", TYPE_VEC2, { TYPE_VEC2, TYPE_VEC2, TYPE_VOID } },
  1272. { "modf", TYPE_VEC3, { TYPE_VEC3, TYPE_VEC3, TYPE_VOID } },
  1273. { "modf", TYPE_VEC4, { TYPE_VEC4, TYPE_VEC4, TYPE_VOID } },
  1274. { "min", TYPE_FLOAT, { TYPE_FLOAT, TYPE_FLOAT, TYPE_VOID } },
  1275. { "min", TYPE_VEC2, { TYPE_VEC2, TYPE_VEC2, TYPE_VOID } },
  1276. { "min", TYPE_VEC3, { TYPE_VEC3, TYPE_VEC3, TYPE_VOID } },
  1277. { "min", TYPE_VEC4, { TYPE_VEC4, TYPE_VEC4, TYPE_VOID } },
  1278. { "min", TYPE_INT, { TYPE_INT, TYPE_INT, TYPE_VOID } },
  1279. { "min", TYPE_IVEC2, { TYPE_IVEC2, TYPE_IVEC2, TYPE_VOID } },
  1280. { "min", TYPE_IVEC3, { TYPE_IVEC3, TYPE_IVEC3, TYPE_VOID } },
  1281. { "min", TYPE_IVEC4, { TYPE_IVEC4, TYPE_IVEC4, TYPE_VOID } },
  1282. { "min", TYPE_UINT, { TYPE_UINT, TYPE_UINT, TYPE_VOID } },
  1283. { "min", TYPE_UVEC2, { TYPE_UVEC2, TYPE_UVEC2, TYPE_VOID } },
  1284. { "min", TYPE_UVEC3, { TYPE_UVEC3, TYPE_UVEC3, TYPE_VOID } },
  1285. { "min", TYPE_UVEC4, { TYPE_UVEC4, TYPE_UVEC4, TYPE_VOID } },
  1286. { "max", TYPE_FLOAT, { TYPE_FLOAT, TYPE_FLOAT, TYPE_VOID } },
  1287. { "max", TYPE_VEC2, { TYPE_VEC2, TYPE_VEC2, TYPE_VOID } },
  1288. { "max", TYPE_VEC3, { TYPE_VEC3, TYPE_VEC3, TYPE_VOID } },
  1289. { "max", TYPE_VEC4, { TYPE_VEC4, TYPE_VEC4, TYPE_VOID } },
  1290. { "max", TYPE_INT, { TYPE_INT, TYPE_INT, TYPE_VOID } },
  1291. { "max", TYPE_IVEC2, { TYPE_IVEC2, TYPE_IVEC2, TYPE_VOID } },
  1292. { "max", TYPE_IVEC3, { TYPE_IVEC3, TYPE_IVEC3, TYPE_VOID } },
  1293. { "max", TYPE_IVEC4, { TYPE_IVEC4, TYPE_IVEC4, TYPE_VOID } },
  1294. { "max", TYPE_UINT, { TYPE_UINT, TYPE_UINT, TYPE_VOID } },
  1295. { "max", TYPE_UVEC2, { TYPE_UVEC2, TYPE_UVEC2, TYPE_VOID } },
  1296. { "max", TYPE_UVEC3, { TYPE_UVEC3, TYPE_UVEC3, TYPE_VOID } },
  1297. { "max", TYPE_UVEC4, { TYPE_UVEC4, TYPE_UVEC4, TYPE_VOID } },
  1298. { "clamp", TYPE_FLOAT, { TYPE_FLOAT, TYPE_FLOAT, TYPE_FLOAT, TYPE_VOID } },
  1299. { "clamp", TYPE_VEC2, { TYPE_VEC2, TYPE_VEC2, TYPE_VEC2, TYPE_VOID } },
  1300. { "clamp", TYPE_VEC3, { TYPE_VEC3, TYPE_VEC3, TYPE_VEC3, TYPE_VOID } },
  1301. { "clamp", TYPE_VEC4, { TYPE_VEC4, TYPE_VEC4, TYPE_VEC4, TYPE_VOID } },
  1302. { "clamp", TYPE_VEC2, { TYPE_VEC2, TYPE_FLOAT, TYPE_FLOAT, TYPE_VOID } },
  1303. { "clamp", TYPE_VEC3, { TYPE_VEC3, TYPE_FLOAT, TYPE_FLOAT, TYPE_VOID } },
  1304. { "clamp", TYPE_VEC4, { TYPE_VEC4, TYPE_FLOAT, TYPE_FLOAT, TYPE_VOID } },
  1305. { "clamp", TYPE_INT, { TYPE_INT, TYPE_INT, TYPE_INT, TYPE_VOID } },
  1306. { "clamp", TYPE_IVEC2, { TYPE_IVEC2, TYPE_IVEC2, TYPE_IVEC2, TYPE_VOID } },
  1307. { "clamp", TYPE_IVEC3, { TYPE_IVEC3, TYPE_IVEC3, TYPE_IVEC3, TYPE_VOID } },
  1308. { "clamp", TYPE_IVEC4, { TYPE_IVEC4, TYPE_IVEC4, TYPE_IVEC4, TYPE_VOID } },
  1309. { "clamp", TYPE_IVEC2, { TYPE_IVEC2, TYPE_INT, TYPE_INT, TYPE_VOID } },
  1310. { "clamp", TYPE_IVEC3, { TYPE_IVEC3, TYPE_INT, TYPE_INT, TYPE_VOID } },
  1311. { "clamp", TYPE_IVEC4, { TYPE_IVEC4, TYPE_INT, TYPE_INT, TYPE_VOID } },
  1312. { "clamp", TYPE_UINT, { TYPE_UINT, TYPE_UINT, TYPE_UINT, TYPE_VOID } },
  1313. { "clamp", TYPE_UVEC2, { TYPE_UVEC2, TYPE_UVEC2, TYPE_UVEC2, TYPE_VOID } },
  1314. { "clamp", TYPE_UVEC3, { TYPE_UVEC3, TYPE_UVEC3, TYPE_UVEC3, TYPE_VOID } },
  1315. { "clamp", TYPE_UVEC4, { TYPE_UVEC4, TYPE_UVEC4, TYPE_UVEC4, TYPE_VOID } },
  1316. { "clamp", TYPE_UVEC2, { TYPE_UVEC2, TYPE_UINT, TYPE_UINT, TYPE_VOID } },
  1317. { "clamp", TYPE_UVEC3, { TYPE_UVEC3, TYPE_UINT, TYPE_UINT, TYPE_VOID } },
  1318. { "clamp", TYPE_UVEC4, { TYPE_UVEC4, TYPE_UINT, TYPE_UINT, TYPE_VOID } },
  1319. { "mix", TYPE_FLOAT, { TYPE_FLOAT, TYPE_FLOAT, TYPE_FLOAT, TYPE_VOID } },
  1320. { "mix", TYPE_FLOAT, { TYPE_FLOAT, TYPE_FLOAT, TYPE_BOOL, TYPE_VOID } },
  1321. { "mix", TYPE_VEC2, { TYPE_VEC2, TYPE_VEC2, TYPE_FLOAT, TYPE_VOID } },
  1322. { "mix", TYPE_VEC2, { TYPE_VEC2, TYPE_VEC2, TYPE_BOOL, TYPE_VOID } },
  1323. { "mix", TYPE_VEC2, { TYPE_VEC2, TYPE_VEC2, TYPE_BVEC2, TYPE_VOID } },
  1324. { "mix", TYPE_VEC2, { TYPE_VEC2, TYPE_VEC2, TYPE_VEC2, TYPE_VOID } },
  1325. { "mix", TYPE_VEC3, { TYPE_VEC3, TYPE_VEC3, TYPE_FLOAT, TYPE_VOID } },
  1326. { "mix", TYPE_VEC3, { TYPE_VEC3, TYPE_VEC3, TYPE_BOOL, TYPE_VOID } },
  1327. { "mix", TYPE_VEC3, { TYPE_VEC3, TYPE_VEC3, TYPE_BVEC3, TYPE_VOID } },
  1328. { "mix", TYPE_VEC3, { TYPE_VEC3, TYPE_VEC3, TYPE_VEC3, TYPE_VOID } },
  1329. { "mix", TYPE_VEC4, { TYPE_VEC4, TYPE_VEC4, TYPE_FLOAT, TYPE_VOID } },
  1330. { "mix", TYPE_VEC4, { TYPE_VEC4, TYPE_VEC4, TYPE_BOOL, TYPE_VOID } },
  1331. { "mix", TYPE_VEC4, { TYPE_VEC4, TYPE_VEC4, TYPE_BVEC3, TYPE_VOID } },
  1332. { "mix", TYPE_VEC4, { TYPE_VEC4, TYPE_VEC4, TYPE_VEC4, TYPE_VOID } },
  1333. { "step", TYPE_FLOAT, { TYPE_FLOAT, TYPE_FLOAT, TYPE_VOID } },
  1334. { "step", TYPE_VEC2, { TYPE_VEC2, TYPE_VEC2, TYPE_VOID } },
  1335. { "step", TYPE_VEC3, { TYPE_VEC3, TYPE_VEC3, TYPE_VOID } },
  1336. { "step", TYPE_VEC4, { TYPE_VEC4, TYPE_VEC4, TYPE_VOID } },
  1337. { "step", TYPE_VEC2, { TYPE_FLOAT, TYPE_VEC2, TYPE_VOID } },
  1338. { "step", TYPE_VEC3, { TYPE_FLOAT, TYPE_VEC3, TYPE_VOID } },
  1339. { "step", TYPE_VEC4, { TYPE_FLOAT, TYPE_VEC4, TYPE_VOID } },
  1340. { "smoothstep", TYPE_FLOAT, { TYPE_FLOAT, TYPE_FLOAT, TYPE_FLOAT, TYPE_VOID } },
  1341. { "smoothstep", TYPE_VEC2, { TYPE_VEC2, TYPE_VEC2, TYPE_VEC2, TYPE_VOID } },
  1342. { "smoothstep", TYPE_VEC3, { TYPE_VEC3, TYPE_VEC3, TYPE_VEC3, TYPE_VOID } },
  1343. { "smoothstep", TYPE_VEC4, { TYPE_VEC4, TYPE_VEC4, TYPE_VEC4, TYPE_VOID } },
  1344. { "smoothstep", TYPE_VEC2, { TYPE_FLOAT, TYPE_FLOAT, TYPE_VEC2, TYPE_VOID } },
  1345. { "smoothstep", TYPE_VEC3, { TYPE_FLOAT, TYPE_FLOAT, TYPE_VEC3, TYPE_VOID } },
  1346. { "smoothstep", TYPE_VEC4, { TYPE_FLOAT, TYPE_FLOAT, TYPE_VEC4, TYPE_VOID } },
  1347. { "isnan", TYPE_BOOL, { TYPE_FLOAT, TYPE_VOID } },
  1348. { "isnan", TYPE_BOOL, { TYPE_VEC2, TYPE_VOID } },
  1349. { "isnan", TYPE_BOOL, { TYPE_VEC3, TYPE_VOID } },
  1350. { "isnan", TYPE_BOOL, { TYPE_VEC4, TYPE_VOID } },
  1351. { "isinf", TYPE_BOOL, { TYPE_FLOAT, TYPE_VOID } },
  1352. { "isinf", TYPE_BOOL, { TYPE_VEC2, TYPE_VOID } },
  1353. { "isinf", TYPE_BOOL, { TYPE_VEC3, TYPE_VOID } },
  1354. { "isinf", TYPE_BOOL, { TYPE_VEC4, TYPE_VOID } },
  1355. { "floatBitsToInt", TYPE_INT, { TYPE_FLOAT, TYPE_VOID } },
  1356. { "floatBitsToInt", TYPE_IVEC2, { TYPE_VEC2, TYPE_VOID } },
  1357. { "floatBitsToInt", TYPE_IVEC3, { TYPE_VEC3, TYPE_VOID } },
  1358. { "floatBitsToInt", TYPE_IVEC4, { TYPE_VEC4, TYPE_VOID } },
  1359. { "floatBitsToUInt", TYPE_UINT, { TYPE_FLOAT, TYPE_VOID } },
  1360. { "floatBitsToUInt", TYPE_UVEC2, { TYPE_VEC2, TYPE_VOID } },
  1361. { "floatBitsToUInt", TYPE_UVEC3, { TYPE_VEC3, TYPE_VOID } },
  1362. { "floatBitsToUInt", TYPE_UVEC4, { TYPE_VEC4, TYPE_VOID } },
  1363. { "intBitsToFloat", TYPE_FLOAT, { TYPE_INT, TYPE_VOID } },
  1364. { "intBitsToFloat", TYPE_VEC2, { TYPE_IVEC2, TYPE_VOID } },
  1365. { "intBitsToFloat", TYPE_VEC3, { TYPE_IVEC3, TYPE_VOID } },
  1366. { "intBitsToFloat", TYPE_VEC4, { TYPE_IVEC4, TYPE_VOID } },
  1367. { "uintBitsToFloat", TYPE_FLOAT, { TYPE_UINT, TYPE_VOID } },
  1368. { "uintBitsToFloat", TYPE_VEC2, { TYPE_UVEC2, TYPE_VOID } },
  1369. { "uintBitsToFloat", TYPE_VEC3, { TYPE_UVEC3, TYPE_VOID } },
  1370. { "uintBitsToFloat", TYPE_VEC4, { TYPE_UVEC4, TYPE_VOID } },
  1371. //builtins - geometric
  1372. { "length", TYPE_FLOAT, { TYPE_VEC2, TYPE_VOID } },
  1373. { "length", TYPE_FLOAT, { TYPE_VEC3, TYPE_VOID } },
  1374. { "length", TYPE_FLOAT, { TYPE_VEC4, TYPE_VOID } },
  1375. { "distance", TYPE_FLOAT, { TYPE_VEC2, TYPE_VEC2, TYPE_VOID } },
  1376. { "distance", TYPE_FLOAT, { TYPE_VEC3, TYPE_VEC3, TYPE_VOID } },
  1377. { "distance", TYPE_FLOAT, { TYPE_VEC4, TYPE_VEC4, TYPE_VOID } },
  1378. { "dot", TYPE_FLOAT, { TYPE_VEC2, TYPE_VEC2, TYPE_VOID } },
  1379. { "dot", TYPE_FLOAT, { TYPE_VEC3, TYPE_VEC3, TYPE_VOID } },
  1380. { "dot", TYPE_FLOAT, { TYPE_VEC4, TYPE_VEC4, TYPE_VOID } },
  1381. { "cross", TYPE_VEC3, { TYPE_VEC3, TYPE_VEC3, TYPE_VOID } },
  1382. { "normalize", TYPE_VEC2, { TYPE_VEC2, TYPE_VOID } },
  1383. { "normalize", TYPE_VEC3, { TYPE_VEC3, TYPE_VOID } },
  1384. { "normalize", TYPE_VEC4, { TYPE_VEC4, TYPE_VOID } },
  1385. { "reflect", TYPE_VEC3, { TYPE_VEC3, TYPE_VEC3, TYPE_VOID } },
  1386. { "refract", TYPE_VEC3, { TYPE_VEC3, TYPE_VEC3, TYPE_FLOAT, TYPE_VOID } },
  1387. { "faceforward", TYPE_VEC2, { TYPE_VEC2, TYPE_VEC2, TYPE_VEC2, TYPE_VOID } },
  1388. { "faceforward", TYPE_VEC3, { TYPE_VEC3, TYPE_VEC3, TYPE_VEC3, TYPE_VOID } },
  1389. { "faceforward", TYPE_VEC4, { TYPE_VEC4, TYPE_VEC4, TYPE_VEC4, TYPE_VOID } },
  1390. { "matrixCompMult", TYPE_MAT2, { TYPE_MAT2, TYPE_MAT2, TYPE_VOID } },
  1391. { "matrixCompMult", TYPE_MAT3, { TYPE_MAT3, TYPE_MAT3, TYPE_VOID } },
  1392. { "matrixCompMult", TYPE_MAT4, { TYPE_MAT4, TYPE_MAT4, TYPE_VOID } },
  1393. { "outerProduct", TYPE_MAT2, { TYPE_VEC2, TYPE_VEC2, TYPE_VOID } },
  1394. { "outerProduct", TYPE_MAT3, { TYPE_VEC3, TYPE_VEC3, TYPE_VOID } },
  1395. { "outerProduct", TYPE_MAT4, { TYPE_VEC4, TYPE_VEC4, TYPE_VOID } },
  1396. { "transpose", TYPE_MAT2, { TYPE_MAT2, TYPE_VOID } },
  1397. { "transpose", TYPE_MAT3, { TYPE_MAT3, TYPE_VOID } },
  1398. { "transpose", TYPE_MAT4, { TYPE_MAT4, TYPE_VOID } },
  1399. { "determinant", TYPE_FLOAT, { TYPE_MAT2, TYPE_VOID } },
  1400. { "determinant", TYPE_FLOAT, { TYPE_MAT3, TYPE_VOID } },
  1401. { "determinant", TYPE_FLOAT, { TYPE_MAT4, TYPE_VOID } },
  1402. { "inverse", TYPE_MAT2, { TYPE_MAT2, TYPE_VOID } },
  1403. { "inverse", TYPE_MAT3, { TYPE_MAT3, TYPE_VOID } },
  1404. { "inverse", TYPE_MAT4, { TYPE_MAT4, TYPE_VOID } },
  1405. { "lessThan", TYPE_BVEC2, { TYPE_VEC2, TYPE_VEC2, TYPE_VOID } },
  1406. { "lessThan", TYPE_BVEC3, { TYPE_VEC3, TYPE_VEC3, TYPE_VOID } },
  1407. { "lessThan", TYPE_BVEC4, { TYPE_VEC4, TYPE_VEC4, TYPE_VOID } },
  1408. { "lessThan", TYPE_BVEC2, { TYPE_IVEC2, TYPE_IVEC2, TYPE_VOID } },
  1409. { "lessThan", TYPE_BVEC3, { TYPE_IVEC3, TYPE_IVEC3, TYPE_VOID } },
  1410. { "lessThan", TYPE_BVEC4, { TYPE_IVEC4, TYPE_IVEC4, TYPE_VOID } },
  1411. { "lessThan", TYPE_BVEC2, { TYPE_UVEC2, TYPE_UVEC2, TYPE_VOID } },
  1412. { "lessThan", TYPE_BVEC3, { TYPE_UVEC3, TYPE_UVEC3, TYPE_VOID } },
  1413. { "lessThan", TYPE_BVEC4, { TYPE_UVEC4, TYPE_UVEC4, TYPE_VOID } },
  1414. { "greaterThan", TYPE_BVEC2, { TYPE_VEC2, TYPE_VEC2, TYPE_VOID } },
  1415. { "greaterThan", TYPE_BVEC3, { TYPE_VEC3, TYPE_VEC3, TYPE_VOID } },
  1416. { "greaterThan", TYPE_BVEC4, { TYPE_VEC4, TYPE_VEC4, TYPE_VOID } },
  1417. { "greaterThan", TYPE_BVEC2, { TYPE_IVEC2, TYPE_IVEC2, TYPE_VOID } },
  1418. { "greaterThan", TYPE_BVEC3, { TYPE_IVEC3, TYPE_IVEC3, TYPE_VOID } },
  1419. { "greaterThan", TYPE_BVEC4, { TYPE_IVEC4, TYPE_IVEC4, TYPE_VOID } },
  1420. { "greaterThan", TYPE_BVEC2, { TYPE_UVEC2, TYPE_UVEC2, TYPE_VOID } },
  1421. { "greaterThan", TYPE_BVEC3, { TYPE_UVEC3, TYPE_UVEC3, TYPE_VOID } },
  1422. { "greaterThan", TYPE_BVEC4, { TYPE_UVEC4, TYPE_UVEC4, TYPE_VOID } },
  1423. { "lessThanEqual", TYPE_BVEC2, { TYPE_VEC2, TYPE_VEC2, TYPE_VOID } },
  1424. { "lessThanEqual", TYPE_BVEC3, { TYPE_VEC3, TYPE_VEC3, TYPE_VOID } },
  1425. { "lessThanEqual", TYPE_BVEC4, { TYPE_VEC4, TYPE_VEC4, TYPE_VOID } },
  1426. { "lessThanEqual", TYPE_BVEC2, { TYPE_IVEC2, TYPE_IVEC2, TYPE_VOID } },
  1427. { "lessThanEqual", TYPE_BVEC3, { TYPE_IVEC3, TYPE_IVEC3, TYPE_VOID } },
  1428. { "lessThanEqual", TYPE_BVEC4, { TYPE_IVEC4, TYPE_IVEC4, TYPE_VOID } },
  1429. { "lessThanEqual", TYPE_BVEC2, { TYPE_UVEC2, TYPE_UVEC2, TYPE_VOID } },
  1430. { "lessThanEqual", TYPE_BVEC3, { TYPE_UVEC3, TYPE_UVEC3, TYPE_VOID } },
  1431. { "lessThanEqual", TYPE_BVEC4, { TYPE_UVEC4, TYPE_UVEC4, TYPE_VOID } },
  1432. { "greaterThanEqual", TYPE_BVEC2, { TYPE_VEC2, TYPE_VEC2, TYPE_VOID } },
  1433. { "greaterThanEqual", TYPE_BVEC3, { TYPE_VEC3, TYPE_VEC3, TYPE_VOID } },
  1434. { "greaterThanEqual", TYPE_BVEC4, { TYPE_VEC4, TYPE_VEC4, TYPE_VOID } },
  1435. { "greaterThanEqual", TYPE_BVEC2, { TYPE_IVEC2, TYPE_IVEC2, TYPE_VOID } },
  1436. { "greaterThanEqual", TYPE_BVEC3, { TYPE_IVEC3, TYPE_IVEC3, TYPE_VOID } },
  1437. { "greaterThanEqual", TYPE_BVEC4, { TYPE_IVEC4, TYPE_IVEC4, TYPE_VOID } },
  1438. { "greaterThanEqual", TYPE_BVEC2, { TYPE_UVEC2, TYPE_UVEC2, TYPE_VOID } },
  1439. { "greaterThanEqual", TYPE_BVEC3, { TYPE_UVEC3, TYPE_UVEC3, TYPE_VOID } },
  1440. { "greaterThanEqual", TYPE_BVEC4, { TYPE_UVEC4, TYPE_UVEC4, TYPE_VOID } },
  1441. { "equal", TYPE_BVEC2, { TYPE_VEC2, TYPE_VEC2, TYPE_VOID } },
  1442. { "equal", TYPE_BVEC3, { TYPE_VEC3, TYPE_VEC3, TYPE_VOID } },
  1443. { "equal", TYPE_BVEC4, { TYPE_VEC4, TYPE_VEC4, TYPE_VOID } },
  1444. { "equal", TYPE_BVEC2, { TYPE_IVEC2, TYPE_IVEC2, TYPE_VOID } },
  1445. { "equal", TYPE_BVEC3, { TYPE_IVEC3, TYPE_IVEC3, TYPE_VOID } },
  1446. { "equal", TYPE_BVEC4, { TYPE_IVEC4, TYPE_IVEC4, TYPE_VOID } },
  1447. { "equal", TYPE_BVEC2, { TYPE_UVEC2, TYPE_UVEC2, TYPE_VOID } },
  1448. { "equal", TYPE_BVEC3, { TYPE_UVEC3, TYPE_UVEC3, TYPE_VOID } },
  1449. { "equal", TYPE_BVEC4, { TYPE_UVEC4, TYPE_UVEC4, TYPE_VOID } },
  1450. { "equal", TYPE_BVEC2, { TYPE_BVEC2, TYPE_BVEC2, TYPE_VOID } },
  1451. { "equal", TYPE_BVEC3, { TYPE_BVEC3, TYPE_BVEC3, TYPE_VOID } },
  1452. { "equal", TYPE_BVEC4, { TYPE_BVEC4, TYPE_BVEC4, TYPE_VOID } },
  1453. { "notEqual", TYPE_BVEC2, { TYPE_VEC2, TYPE_VEC2, TYPE_VOID } },
  1454. { "notEqual", TYPE_BVEC3, { TYPE_VEC3, TYPE_VEC3, TYPE_VOID } },
  1455. { "notEqual", TYPE_BVEC4, { TYPE_VEC4, TYPE_VEC4, TYPE_VOID } },
  1456. { "notEqual", TYPE_BVEC2, { TYPE_IVEC2, TYPE_IVEC2, TYPE_VOID } },
  1457. { "notEqual", TYPE_BVEC3, { TYPE_IVEC3, TYPE_IVEC3, TYPE_VOID } },
  1458. { "notEqual", TYPE_BVEC4, { TYPE_IVEC4, TYPE_IVEC4, TYPE_VOID } },
  1459. { "notEqual", TYPE_BVEC2, { TYPE_UVEC2, TYPE_UVEC2, TYPE_VOID } },
  1460. { "notEqual", TYPE_BVEC3, { TYPE_UVEC3, TYPE_UVEC3, TYPE_VOID } },
  1461. { "notEqual", TYPE_BVEC4, { TYPE_UVEC4, TYPE_UVEC4, TYPE_VOID } },
  1462. { "notEqual", TYPE_BVEC2, { TYPE_BVEC2, TYPE_BVEC2, TYPE_VOID } },
  1463. { "notEqual", TYPE_BVEC3, { TYPE_BVEC3, TYPE_BVEC3, TYPE_VOID } },
  1464. { "notEqual", TYPE_BVEC4, { TYPE_BVEC4, TYPE_BVEC4, TYPE_VOID } },
  1465. { "any", TYPE_BOOL, { TYPE_BVEC2, TYPE_VOID } },
  1466. { "any", TYPE_BOOL, { TYPE_BVEC3, TYPE_VOID } },
  1467. { "any", TYPE_BOOL, { TYPE_BVEC4, TYPE_VOID } },
  1468. { "all", TYPE_BOOL, { TYPE_BVEC2, TYPE_VOID } },
  1469. { "all", TYPE_BOOL, { TYPE_BVEC3, TYPE_VOID } },
  1470. { "all", TYPE_BOOL, { TYPE_BVEC4, TYPE_VOID } },
  1471. { "not", TYPE_BOOL, { TYPE_BVEC2, TYPE_VOID } },
  1472. { "not", TYPE_BOOL, { TYPE_BVEC3, TYPE_VOID } },
  1473. { "not", TYPE_BOOL, { TYPE_BVEC4, TYPE_VOID } },
  1474. //builtins - texture
  1475. { "textureSize", TYPE_IVEC2, { TYPE_SAMPLER2D, TYPE_INT, TYPE_VOID } },
  1476. { "textureSize", TYPE_IVEC2, { TYPE_ISAMPLER2D, TYPE_INT, TYPE_VOID } },
  1477. { "textureSize", TYPE_IVEC2, { TYPE_USAMPLER2D, TYPE_INT, TYPE_VOID } },
  1478. { "textureSize", TYPE_IVEC2, { TYPE_SAMPLERCUBE, TYPE_INT, TYPE_VOID } },
  1479. { "texture", TYPE_VEC4, { TYPE_SAMPLER2D, TYPE_VEC2, TYPE_VOID } },
  1480. { "texture", TYPE_VEC4, { TYPE_SAMPLER2D, TYPE_VEC2, TYPE_FLOAT, TYPE_VOID } },
  1481. { "texture", TYPE_UVEC4, { TYPE_USAMPLER2D, TYPE_VEC2, TYPE_VOID } },
  1482. { "texture", TYPE_UVEC4, { TYPE_USAMPLER2D, TYPE_VEC2, TYPE_FLOAT, TYPE_VOID } },
  1483. { "texture", TYPE_IVEC4, { TYPE_ISAMPLER2D, TYPE_VEC2, TYPE_VOID } },
  1484. { "texture", TYPE_IVEC4, { TYPE_ISAMPLER2D, TYPE_VEC2, TYPE_FLOAT, TYPE_VOID } },
  1485. { "texture", TYPE_VEC4, { TYPE_SAMPLERCUBE, TYPE_VEC3, TYPE_VOID } },
  1486. { "texture", TYPE_VEC4, { TYPE_SAMPLERCUBE, TYPE_VEC3, TYPE_FLOAT, TYPE_VOID } },
  1487. { "textureProj", TYPE_VEC4, { TYPE_SAMPLER2D, TYPE_VEC3, TYPE_VOID } },
  1488. { "textureProj", TYPE_VEC4, { TYPE_SAMPLER2D, TYPE_VEC4, TYPE_VOID } },
  1489. { "textureProj", TYPE_VEC4, { TYPE_SAMPLER2D, TYPE_VEC3, TYPE_FLOAT, TYPE_VOID } },
  1490. { "textureProj", TYPE_VEC4, { TYPE_SAMPLER2D, TYPE_VEC4, TYPE_FLOAT, TYPE_VOID } },
  1491. { "textureProj", TYPE_IVEC4, { TYPE_ISAMPLER2D, TYPE_VEC3, TYPE_VOID } },
  1492. { "textureProj", TYPE_IVEC4, { TYPE_ISAMPLER2D, TYPE_VEC4, TYPE_VOID } },
  1493. { "textureProj", TYPE_IVEC4, { TYPE_ISAMPLER2D, TYPE_VEC3, TYPE_FLOAT, TYPE_VOID } },
  1494. { "textureProj", TYPE_IVEC4, { TYPE_ISAMPLER2D, TYPE_VEC4, TYPE_FLOAT, TYPE_VOID } },
  1495. { "textureProj", TYPE_UVEC4, { TYPE_USAMPLER2D, TYPE_VEC3, TYPE_VOID } },
  1496. { "textureProj", TYPE_UVEC4, { TYPE_USAMPLER2D, TYPE_VEC4, TYPE_VOID } },
  1497. { "textureProj", TYPE_UVEC4, { TYPE_USAMPLER2D, TYPE_VEC3, TYPE_FLOAT, TYPE_VOID } },
  1498. { "textureProj", TYPE_UVEC4, { TYPE_USAMPLER2D, TYPE_VEC4, TYPE_FLOAT, TYPE_VOID } },
  1499. { "textureLod", TYPE_VEC4, { TYPE_SAMPLER2D, TYPE_VEC2, TYPE_FLOAT, TYPE_VOID } },
  1500. { "textureLod", TYPE_IVEC4, { TYPE_ISAMPLER2D, TYPE_VEC2, TYPE_FLOAT, TYPE_VOID } },
  1501. { "textureLod", TYPE_UVEC4, { TYPE_USAMPLER2D, TYPE_VEC2, TYPE_FLOAT, TYPE_VOID } },
  1502. { "textureLod", TYPE_VEC4, { TYPE_SAMPLERCUBE, TYPE_VEC3, TYPE_FLOAT, TYPE_VOID } },
  1503. { "texelFetch", TYPE_VEC4, { TYPE_SAMPLER2D, TYPE_IVEC2, TYPE_INT, TYPE_VOID } },
  1504. { "texelFetch", TYPE_IVEC4, { TYPE_ISAMPLER2D, TYPE_IVEC2, TYPE_INT, TYPE_VOID } },
  1505. { "texelFetch", TYPE_UVEC4, { TYPE_USAMPLER2D, TYPE_IVEC2, TYPE_INT, TYPE_VOID } },
  1506. { "textureProjLod", TYPE_VEC4, { TYPE_SAMPLER2D, TYPE_VEC3, TYPE_FLOAT, TYPE_VOID } },
  1507. { "textureProjLod", TYPE_VEC4, { TYPE_SAMPLER2D, TYPE_VEC4, TYPE_FLOAT, TYPE_VOID } },
  1508. { "textureProjLod", TYPE_IVEC4, { TYPE_ISAMPLER2D, TYPE_VEC3, TYPE_FLOAT, TYPE_VOID } },
  1509. { "textureProjLod", TYPE_IVEC4, { TYPE_ISAMPLER2D, TYPE_VEC4, TYPE_FLOAT, TYPE_VOID } },
  1510. { "textureProjLod", TYPE_UVEC4, { TYPE_USAMPLER2D, TYPE_VEC3, TYPE_FLOAT, TYPE_VOID } },
  1511. { "textureProjLod", TYPE_UVEC4, { TYPE_USAMPLER2D, TYPE_VEC4, TYPE_FLOAT, TYPE_VOID } },
  1512. { "textureGrad", TYPE_VEC4, { TYPE_SAMPLER2D, TYPE_VEC2, TYPE_VEC2, TYPE_VEC2, TYPE_VOID } },
  1513. { "textureGrad", TYPE_IVEC4, { TYPE_ISAMPLER2D, TYPE_VEC2, TYPE_VEC2, TYPE_VEC2, TYPE_VOID } },
  1514. { "textureGrad", TYPE_UVEC4, { TYPE_USAMPLER2D, TYPE_VEC2, TYPE_VEC2, TYPE_VEC2, TYPE_VOID } },
  1515. { "textureGrad", TYPE_VEC4, { TYPE_SAMPLERCUBE, TYPE_VEC3, TYPE_VEC3, TYPE_VEC3, TYPE_VOID } },
  1516. { "dFdx", TYPE_FLOAT, { TYPE_FLOAT, TYPE_VOID } },
  1517. { "dFdx", TYPE_VEC2, { TYPE_VEC2, TYPE_VOID } },
  1518. { "dFdx", TYPE_VEC3, { TYPE_VEC3, TYPE_VOID } },
  1519. { "dFdx", TYPE_VEC4, { TYPE_VEC4, TYPE_VOID } },
  1520. { "dFdy", TYPE_FLOAT, { TYPE_FLOAT, TYPE_VOID } },
  1521. { "dFdy", TYPE_VEC2, { TYPE_VEC2, TYPE_VOID } },
  1522. { "dFdy", TYPE_VEC3, { TYPE_VEC3, TYPE_VOID } },
  1523. { "dFdy", TYPE_VEC4, { TYPE_VEC4, TYPE_VOID } },
  1524. { "fwidth", TYPE_FLOAT, { TYPE_FLOAT, TYPE_VOID } },
  1525. { "fwidth", TYPE_VEC2, { TYPE_VEC2, TYPE_VOID } },
  1526. { "fwidth", TYPE_VEC3, { TYPE_VEC3, TYPE_VOID } },
  1527. { "fwidth", TYPE_VEC4, { TYPE_VEC4, TYPE_VOID } },
  1528. { NULL, TYPE_VOID, { TYPE_VOID } }
  1529. };
  1530. bool ShaderLanguage::_validate_function_call(BlockNode *p_block, OperatorNode *p_func, DataType *r_ret_type) {
  1531. ERR_FAIL_COND_V(p_func->op != OP_CALL && p_func->op != OP_CONSTRUCT, NULL);
  1532. Vector<DataType> args;
  1533. ERR_FAIL_COND_V(p_func->arguments[0]->type != Node::TYPE_VARIABLE, NULL);
  1534. StringName name = static_cast<VariableNode *>(p_func->arguments[0])->name.operator String();
  1535. bool all_const = true;
  1536. for (int i = 1; i < p_func->arguments.size(); i++) {
  1537. if (p_func->arguments[i]->type != Node::TYPE_CONSTANT)
  1538. all_const = false;
  1539. args.push_back(p_func->arguments[i]->get_datatype());
  1540. }
  1541. int argcount = args.size();
  1542. bool failed_builtin = false;
  1543. if (argcount <= 4) {
  1544. // test builtins
  1545. int idx = 0;
  1546. while (builtin_func_defs[idx].name) {
  1547. if (name == builtin_func_defs[idx].name) {
  1548. failed_builtin = true;
  1549. bool fail = false;
  1550. for (int i = 0; i < argcount; i++) {
  1551. if (get_scalar_type(args[i]) == args[i] && p_func->arguments[i + 1]->type == Node::TYPE_CONSTANT && convert_constant(static_cast<ConstantNode *>(p_func->arguments[i + 1]), builtin_func_defs[idx].args[i])) {
  1552. //all good
  1553. } else if (args[i] != builtin_func_defs[idx].args[i]) {
  1554. fail = true;
  1555. break;
  1556. }
  1557. }
  1558. if (!fail && argcount < 4 && builtin_func_defs[idx].args[argcount] != TYPE_VOID)
  1559. fail = true; //make sure the number of arguments matches
  1560. if (!fail) {
  1561. if (r_ret_type)
  1562. *r_ret_type = builtin_func_defs[idx].rettype;
  1563. return true;
  1564. }
  1565. }
  1566. idx++;
  1567. }
  1568. }
  1569. if (failed_builtin) {
  1570. String err = "Invalid arguments for built-in function: " + String(name) + "(";
  1571. for (int i = 0; i < argcount; i++) {
  1572. if (i > 0)
  1573. err += ",";
  1574. if (p_func->arguments[i + 1]->type == Node::TYPE_CONSTANT && p_func->arguments[i + 1]->get_datatype() == TYPE_INT && static_cast<ConstantNode *>(p_func->arguments[i + 1])->values[0].sint < 0) {
  1575. err += "-";
  1576. }
  1577. err += get_datatype_name(args[i]);
  1578. }
  1579. err += ")";
  1580. _set_error(err);
  1581. return false;
  1582. }
  1583. #if 0
  1584. if (found_builtin) {
  1585. if (p_func->op==OP_CONSTRUCT && all_const) {
  1586. Vector<float> cdata;
  1587. for(int i=0;i<argcount;i++) {
  1588. Variant v = static_cast<ConstantNode*>(p_func->arguments[i+1])->value;
  1589. switch(v.get_type()) {
  1590. case Variant::REAL: cdata.push_back(v); break;
  1591. case Variant::INT: cdata.push_back(v); break;
  1592. case Variant::VECTOR2: { Vector2 v2=v; cdata.push_back(v2.x); cdata.push_back(v2.y); } break;
  1593. case Variant::VECTOR3: { Vector3 v3=v; cdata.push_back(v3.x); cdata.push_back(v3.y); cdata.push_back(v3.z);} break;
  1594. case Variant::PLANE: { Plane v4=v; cdata.push_back(v4.normal.x); cdata.push_back(v4.normal.y); cdata.push_back(v4.normal.z); cdata.push_back(v4.d); } break;
  1595. default: ERR_FAIL_V(NULL);
  1596. }
  1597. }
  1598. ConstantNode *cn = parser.create_node<ConstantNode>(p_func->parent);
  1599. Variant data;
  1600. switch(p_func->return_cache) {
  1601. case TYPE_FLOAT: data = cdata[0]; break;
  1602. case TYPE_VEC2:
  1603. if (cdata.size()==1)
  1604. data = Vector2(cdata[0],cdata[0]);
  1605. else
  1606. data = Vector2(cdata[0],cdata[1]);
  1607. break;
  1608. case TYPE_VEC3:
  1609. if (cdata.size()==1)
  1610. data = Vector3(cdata[0],cdata[0],cdata[0]);
  1611. else
  1612. data = Vector3(cdata[0],cdata[1],cdata[2]);
  1613. break;
  1614. case TYPE_VEC4:
  1615. if (cdata.size()==1)
  1616. data = Plane(cdata[0],cdata[0],cdata[0],cdata[0]);
  1617. else
  1618. data = Plane(cdata[0],cdata[1],cdata[2],cdata[3]);
  1619. break;
  1620. }
  1621. cn->datatype=p_func->return_cache;
  1622. cn->value=data;
  1623. return cn;
  1624. }
  1625. return p_func;
  1626. }
  1627. #endif
  1628. // try existing functions..
  1629. StringName exclude_function;
  1630. BlockNode *block = p_block;
  1631. while (block) {
  1632. if (block->parent_function) {
  1633. exclude_function = block->parent_function->name;
  1634. }
  1635. block = block->parent_block;
  1636. }
  1637. if (name == exclude_function) {
  1638. _set_error("Recursion is not allowed");
  1639. return false;
  1640. }
  1641. for (int i = 0; i < shader->functions.size(); i++) {
  1642. if (name != shader->functions[i].name)
  1643. continue;
  1644. if (!shader->functions[i].callable) {
  1645. _set_error("Function '" + String(name) + " can't be called from source code.");
  1646. return false;
  1647. }
  1648. FunctionNode *pfunc = shader->functions[i].function;
  1649. if (pfunc->arguments.size() != args.size())
  1650. continue;
  1651. bool fail = false;
  1652. for (int i = 0; i < args.size(); i++) {
  1653. if (get_scalar_type(args[i]) == args[i] && p_func->arguments[i + 1]->type == Node::TYPE_CONSTANT && convert_constant(static_cast<ConstantNode *>(p_func->arguments[i + 1]), pfunc->arguments[i].type)) {
  1654. //all good
  1655. } else if (args[i] != pfunc->arguments[i].type) {
  1656. fail = true;
  1657. break;
  1658. }
  1659. }
  1660. if (!fail) {
  1661. if (r_ret_type)
  1662. *r_ret_type = pfunc->return_type;
  1663. return true;
  1664. }
  1665. }
  1666. return false;
  1667. }
  1668. bool ShaderLanguage::_parse_function_arguments(BlockNode *p_block, const Map<StringName, DataType> &p_builtin_types, OperatorNode *p_func, int *r_complete_arg) {
  1669. TkPos pos = _get_tkpos();
  1670. Token tk = _get_token();
  1671. if (tk.type == TK_PARENTHESIS_CLOSE) {
  1672. return true;
  1673. }
  1674. _set_tkpos(pos);
  1675. while (true) {
  1676. if (r_complete_arg) {
  1677. pos = _get_tkpos();
  1678. tk = _get_token();
  1679. if (tk.type == TK_CURSOR) {
  1680. *r_complete_arg = p_func->arguments.size() - 1;
  1681. } else {
  1682. _set_tkpos(pos);
  1683. }
  1684. }
  1685. Node *arg = _parse_and_reduce_expression(p_block, p_builtin_types);
  1686. if (!arg) {
  1687. return false;
  1688. }
  1689. p_func->arguments.push_back(arg);
  1690. tk = _get_token();
  1691. if (tk.type == TK_PARENTHESIS_CLOSE) {
  1692. return true;
  1693. } else if (tk.type != TK_COMMA) {
  1694. // something is broken
  1695. _set_error("Expected ',' or ')' after argument");
  1696. return false;
  1697. }
  1698. }
  1699. return true;
  1700. }
  1701. bool ShaderLanguage::is_token_operator(TokenType p_type) {
  1702. return (p_type == TK_OP_EQUAL ||
  1703. p_type == TK_OP_NOT_EQUAL ||
  1704. p_type == TK_OP_LESS ||
  1705. p_type == TK_OP_LESS_EQUAL ||
  1706. p_type == TK_OP_GREATER ||
  1707. p_type == TK_OP_GREATER_EQUAL ||
  1708. p_type == TK_OP_AND ||
  1709. p_type == TK_OP_OR ||
  1710. p_type == TK_OP_NOT ||
  1711. p_type == TK_OP_ADD ||
  1712. p_type == TK_OP_SUB ||
  1713. p_type == TK_OP_MUL ||
  1714. p_type == TK_OP_DIV ||
  1715. p_type == TK_OP_MOD ||
  1716. p_type == TK_OP_SHIFT_LEFT ||
  1717. p_type == TK_OP_SHIFT_RIGHT ||
  1718. p_type == TK_OP_ASSIGN ||
  1719. p_type == TK_OP_ASSIGN_ADD ||
  1720. p_type == TK_OP_ASSIGN_SUB ||
  1721. p_type == TK_OP_ASSIGN_MUL ||
  1722. p_type == TK_OP_ASSIGN_DIV ||
  1723. p_type == TK_OP_ASSIGN_MOD ||
  1724. p_type == TK_OP_ASSIGN_SHIFT_LEFT ||
  1725. p_type == TK_OP_ASSIGN_SHIFT_RIGHT ||
  1726. p_type == TK_OP_ASSIGN_BIT_AND ||
  1727. p_type == TK_OP_ASSIGN_BIT_OR ||
  1728. p_type == TK_OP_ASSIGN_BIT_XOR ||
  1729. p_type == TK_OP_BIT_AND ||
  1730. p_type == TK_OP_BIT_OR ||
  1731. p_type == TK_OP_BIT_XOR ||
  1732. p_type == TK_OP_BIT_INVERT ||
  1733. p_type == TK_OP_INCREMENT ||
  1734. p_type == TK_OP_DECREMENT ||
  1735. p_type == TK_QUESTION ||
  1736. p_type == TK_COLON);
  1737. }
  1738. bool ShaderLanguage::convert_constant(ConstantNode *p_constant, DataType p_to_type, ConstantNode::Value *p_value) {
  1739. if (p_constant->datatype == p_to_type) {
  1740. if (p_value) {
  1741. for (int i = 0; i < p_constant->values.size(); i++) {
  1742. p_value[i] = p_constant->values[i];
  1743. }
  1744. }
  1745. return true;
  1746. } else if (p_constant->datatype == TYPE_INT && p_to_type == TYPE_FLOAT) {
  1747. if (p_value) {
  1748. p_value->real = p_constant->values[0].sint;
  1749. }
  1750. return true;
  1751. } else if (p_constant->datatype == TYPE_UINT && p_to_type == TYPE_FLOAT) {
  1752. if (p_value) {
  1753. p_value->real = p_constant->values[0].uint;
  1754. }
  1755. return true;
  1756. } else if (p_constant->datatype == TYPE_INT && p_to_type == TYPE_UINT) {
  1757. if (p_constant->values[0].sint < 0) {
  1758. return false;
  1759. }
  1760. if (p_value) {
  1761. p_value->uint = p_constant->values[0].sint;
  1762. }
  1763. return true;
  1764. } else if (p_constant->datatype == TYPE_UINT && p_to_type == TYPE_INT) {
  1765. if (p_constant->values[0].uint > 0x7FFFFFFF) {
  1766. return false;
  1767. }
  1768. if (p_value) {
  1769. p_value->sint = p_constant->values[0].uint;
  1770. }
  1771. return true;
  1772. } else
  1773. return false;
  1774. }
  1775. bool ShaderLanguage::is_scalar_type(DataType p_type) {
  1776. return p_type == TYPE_BOOL || p_type == TYPE_INT || p_type == TYPE_UINT || p_type == TYPE_FLOAT;
  1777. }
  1778. bool ShaderLanguage::is_sampler_type(DataType p_type) {
  1779. return p_type == TYPE_SAMPLER2D || p_type == TYPE_ISAMPLER2D || p_type == TYPE_USAMPLER2D || p_type == TYPE_SAMPLERCUBE;
  1780. }
  1781. void ShaderLanguage::get_keyword_list(List<String> *r_keywords) {
  1782. Set<String> kws;
  1783. int idx = 0;
  1784. while (keyword_list[idx].text) {
  1785. kws.insert(keyword_list[idx].text);
  1786. idx++;
  1787. }
  1788. idx = 0;
  1789. while (builtin_func_defs[idx].name) {
  1790. kws.insert(builtin_func_defs[idx].name);
  1791. idx++;
  1792. }
  1793. for (Set<String>::Element *E = kws.front(); E; E = E->next()) {
  1794. r_keywords->push_back(E->get());
  1795. }
  1796. }
  1797. void ShaderLanguage::get_builtin_funcs(List<String> *r_keywords) {
  1798. Set<String> kws;
  1799. int idx = 0;
  1800. while (builtin_func_defs[idx].name) {
  1801. kws.insert(builtin_func_defs[idx].name);
  1802. idx++;
  1803. }
  1804. for (Set<String>::Element *E = kws.front(); E; E = E->next()) {
  1805. r_keywords->push_back(E->get());
  1806. }
  1807. }
  1808. ShaderLanguage::DataType ShaderLanguage::get_scalar_type(DataType p_type) {
  1809. static const DataType scalar_types[] = {
  1810. TYPE_VOID,
  1811. TYPE_BOOL,
  1812. TYPE_BOOL,
  1813. TYPE_BOOL,
  1814. TYPE_BOOL,
  1815. TYPE_INT,
  1816. TYPE_INT,
  1817. TYPE_INT,
  1818. TYPE_INT,
  1819. TYPE_UINT,
  1820. TYPE_UINT,
  1821. TYPE_UINT,
  1822. TYPE_UINT,
  1823. TYPE_FLOAT,
  1824. TYPE_FLOAT,
  1825. TYPE_FLOAT,
  1826. TYPE_FLOAT,
  1827. TYPE_FLOAT,
  1828. TYPE_FLOAT,
  1829. TYPE_FLOAT,
  1830. TYPE_FLOAT,
  1831. TYPE_INT,
  1832. TYPE_UINT,
  1833. TYPE_FLOAT,
  1834. };
  1835. return scalar_types[p_type];
  1836. }
  1837. bool ShaderLanguage::_get_completable_identifier(BlockNode *p_block, CompletionType p_type, StringName &identifier) {
  1838. identifier = StringName();
  1839. TkPos pos;
  1840. Token tk = _get_token();
  1841. if (tk.type == TK_IDENTIFIER) {
  1842. identifier = tk.text;
  1843. pos = _get_tkpos();
  1844. tk = _get_token();
  1845. }
  1846. if (tk.type == TK_CURSOR) {
  1847. completion_type = p_type;
  1848. completion_line = tk_line;
  1849. completion_block = p_block;
  1850. pos = _get_tkpos();
  1851. tk = _get_token();
  1852. if (tk.type == TK_IDENTIFIER) {
  1853. identifier = identifier.operator String() + tk.text.operator String();
  1854. } else {
  1855. _set_tkpos(pos);
  1856. }
  1857. return true;
  1858. } else if (identifier != StringName()) {
  1859. _set_tkpos(pos);
  1860. }
  1861. return false;
  1862. }
  1863. ShaderLanguage::Node *ShaderLanguage::_parse_expression(BlockNode *p_block, const Map<StringName, DataType> &p_builtin_types) {
  1864. Vector<Expression> expression;
  1865. //Vector<TokenType> operators;
  1866. while (true) {
  1867. Node *expr = NULL;
  1868. TkPos prepos = _get_tkpos();
  1869. Token tk = _get_token();
  1870. TkPos pos = _get_tkpos();
  1871. if (tk.type == TK_PARENTHESIS_OPEN) {
  1872. //handle subexpression
  1873. expr = _parse_and_reduce_expression(p_block, p_builtin_types);
  1874. if (!expr)
  1875. return NULL;
  1876. tk = _get_token();
  1877. if (tk.type != TK_PARENTHESIS_CLOSE) {
  1878. _set_error("Expected ')' in expression");
  1879. return NULL;
  1880. }
  1881. } else if (tk.type == TK_REAL_CONSTANT) {
  1882. ConstantNode *constant = alloc_node<ConstantNode>();
  1883. ConstantNode::Value v;
  1884. v.real = tk.constant;
  1885. constant->values.push_back(v);
  1886. constant->datatype = TYPE_FLOAT;
  1887. expr = constant;
  1888. } else if (tk.type == TK_INT_CONSTANT) {
  1889. ConstantNode *constant = alloc_node<ConstantNode>();
  1890. ConstantNode::Value v;
  1891. v.sint = tk.constant;
  1892. constant->values.push_back(v);
  1893. constant->datatype = TYPE_INT;
  1894. expr = constant;
  1895. } else if (tk.type == TK_TRUE) {
  1896. //print_line("found true");
  1897. //handle true constant
  1898. ConstantNode *constant = alloc_node<ConstantNode>();
  1899. ConstantNode::Value v;
  1900. v.boolean = true;
  1901. constant->values.push_back(v);
  1902. constant->datatype = TYPE_BOOL;
  1903. expr = constant;
  1904. } else if (tk.type == TK_FALSE) {
  1905. //handle false constant
  1906. ConstantNode *constant = alloc_node<ConstantNode>();
  1907. ConstantNode::Value v;
  1908. v.boolean = false;
  1909. constant->values.push_back(v);
  1910. constant->datatype = TYPE_BOOL;
  1911. expr = constant;
  1912. } else if (tk.type == TK_TYPE_VOID) {
  1913. //make sure void is not used in expression
  1914. _set_error("Void value not allowed in Expression");
  1915. return NULL;
  1916. } else if (is_token_nonvoid_datatype(tk.type)) {
  1917. //basic type constructor
  1918. OperatorNode *func = alloc_node<OperatorNode>();
  1919. func->op = OP_CONSTRUCT;
  1920. if (is_token_precision(tk.type)) {
  1921. func->return_precision_cache = get_token_precision(tk.type);
  1922. tk = _get_token();
  1923. }
  1924. VariableNode *funcname = alloc_node<VariableNode>();
  1925. funcname->name = get_datatype_name(get_token_datatype(tk.type));
  1926. func->arguments.push_back(funcname);
  1927. tk = _get_token();
  1928. if (tk.type != TK_PARENTHESIS_OPEN) {
  1929. _set_error("Expected '(' after type name");
  1930. return NULL;
  1931. }
  1932. int carg = -1;
  1933. bool ok = _parse_function_arguments(p_block, p_builtin_types, func, &carg);
  1934. if (carg >= 0) {
  1935. completion_type = COMPLETION_CALL_ARGUMENTS;
  1936. completion_line = tk_line;
  1937. completion_block = p_block;
  1938. completion_function = funcname->name;
  1939. completion_argument = carg;
  1940. }
  1941. if (!ok)
  1942. return NULL;
  1943. if (!_validate_function_call(p_block, func, &func->return_cache)) {
  1944. _set_error("No matching constructor found for: '" + String(funcname->name) + "'");
  1945. return NULL;
  1946. }
  1947. //validate_Function_call()
  1948. expr = _reduce_expression(p_block, func);
  1949. } else if (tk.type == TK_IDENTIFIER) {
  1950. _set_tkpos(prepos);
  1951. StringName identifier;
  1952. _get_completable_identifier(p_block, COMPLETION_IDENTIFIER, identifier);
  1953. tk = _get_token();
  1954. if (tk.type == TK_PARENTHESIS_OPEN) {
  1955. //a function
  1956. StringName name = identifier;
  1957. OperatorNode *func = alloc_node<OperatorNode>();
  1958. func->op = OP_CALL;
  1959. VariableNode *funcname = alloc_node<VariableNode>();
  1960. funcname->name = name;
  1961. func->arguments.push_back(funcname);
  1962. int carg = -1;
  1963. bool ok = _parse_function_arguments(p_block, p_builtin_types, func, &carg);
  1964. //test if function was parsed first
  1965. for (int i = 0; i < shader->functions.size(); i++) {
  1966. if (shader->functions[i].name == name) {
  1967. //add to current function as dependency
  1968. for (int j = 0; j < shader->functions.size(); j++) {
  1969. if (shader->functions[j].name == current_function) {
  1970. shader->functions[j].uses_function.insert(name);
  1971. break;
  1972. }
  1973. }
  1974. break;
  1975. }
  1976. }
  1977. if (carg >= 0) {
  1978. completion_type = COMPLETION_CALL_ARGUMENTS;
  1979. completion_line = tk_line;
  1980. completion_block = p_block;
  1981. completion_function = funcname->name;
  1982. completion_argument = carg;
  1983. }
  1984. if (!ok)
  1985. return NULL;
  1986. if (!_validate_function_call(p_block, func, &func->return_cache)) {
  1987. _set_error("No matching function found for: '" + String(funcname->name) + "'");
  1988. return NULL;
  1989. }
  1990. expr = func;
  1991. } else {
  1992. //an identifier
  1993. _set_tkpos(pos);
  1994. DataType data_type;
  1995. IdentifierType ident_type;
  1996. if (!_find_identifier(p_block, p_builtin_types, identifier, &data_type, &ident_type)) {
  1997. _set_error("Unknown identifier in expression: " + String(identifier));
  1998. return NULL;
  1999. }
  2000. if (ident_type == IDENTIFIER_FUNCTION) {
  2001. _set_error("Can't use function as identifier: " + String(identifier));
  2002. return NULL;
  2003. }
  2004. VariableNode *varname = alloc_node<VariableNode>();
  2005. varname->name = identifier;
  2006. varname->datatype_cache = data_type;
  2007. expr = varname;
  2008. }
  2009. } else if (tk.type == TK_OP_ADD) {
  2010. continue; //this one does nothing
  2011. } else if (tk.type == TK_OP_SUB || tk.type == TK_OP_NOT || tk.type == TK_OP_BIT_INVERT || tk.type == TK_OP_INCREMENT || tk.type == TK_OP_DECREMENT) {
  2012. Expression e;
  2013. e.is_op = true;
  2014. switch (tk.type) {
  2015. case TK_OP_SUB: e.op = OP_NEGATE; break;
  2016. case TK_OP_NOT: e.op = OP_NOT; break;
  2017. case TK_OP_BIT_INVERT: e.op = OP_BIT_INVERT; break;
  2018. case TK_OP_INCREMENT: e.op = OP_INCREMENT; break;
  2019. case TK_OP_DECREMENT: e.op = OP_DECREMENT; break;
  2020. default: ERR_FAIL_V(NULL);
  2021. }
  2022. expression.push_back(e);
  2023. continue;
  2024. } else {
  2025. _set_error("Expected expression, found: " + get_token_text(tk));
  2026. return NULL;
  2027. //nothing
  2028. }
  2029. ERR_FAIL_COND_V(!expr, NULL);
  2030. /* OK now see what's NEXT to the operator.. */
  2031. /* OK now see what's NEXT to the operator.. */
  2032. /* OK now see what's NEXT to the operator.. */
  2033. while (true) {
  2034. TkPos pos = _get_tkpos();
  2035. tk = _get_token();
  2036. if (tk.type == TK_PERIOD) {
  2037. StringName identifier;
  2038. if (_get_completable_identifier(p_block, COMPLETION_INDEX, identifier)) {
  2039. completion_base = expr->get_datatype();
  2040. }
  2041. if (identifier == StringName()) {
  2042. _set_error("Expected identifier as member");
  2043. return NULL;
  2044. }
  2045. DataType dt = expr->get_datatype();
  2046. String ident = identifier;
  2047. bool ok = true;
  2048. DataType member_type;
  2049. switch (dt) {
  2050. case TYPE_BVEC2:
  2051. case TYPE_IVEC2:
  2052. case TYPE_UVEC2:
  2053. case TYPE_VEC2: {
  2054. int l = ident.length();
  2055. if (l == 1) {
  2056. member_type = DataType(dt - 1);
  2057. } else if (l == 2) {
  2058. member_type = dt;
  2059. } else {
  2060. ok = false;
  2061. break;
  2062. }
  2063. const CharType *c = ident.ptr();
  2064. for (int i = 0; i < l; i++) {
  2065. switch (c[i]) {
  2066. case 'r':
  2067. case 'g':
  2068. case 'x':
  2069. case 'y':
  2070. break;
  2071. default:
  2072. ok = false;
  2073. break;
  2074. }
  2075. }
  2076. } break;
  2077. case TYPE_BVEC3:
  2078. case TYPE_IVEC3:
  2079. case TYPE_UVEC3:
  2080. case TYPE_VEC3: {
  2081. int l = ident.length();
  2082. if (l == 1) {
  2083. member_type = DataType(dt - 2);
  2084. } else if (l == 2) {
  2085. member_type = DataType(dt - 1);
  2086. } else if (l == 3) {
  2087. member_type = dt;
  2088. } else {
  2089. ok = false;
  2090. break;
  2091. }
  2092. const CharType *c = ident.ptr();
  2093. for (int i = 0; i < l; i++) {
  2094. switch (c[i]) {
  2095. case 'r':
  2096. case 'g':
  2097. case 'b':
  2098. case 'x':
  2099. case 'y':
  2100. case 'z':
  2101. break;
  2102. default:
  2103. ok = false;
  2104. break;
  2105. }
  2106. }
  2107. } break;
  2108. case TYPE_BVEC4:
  2109. case TYPE_IVEC4:
  2110. case TYPE_UVEC4:
  2111. case TYPE_VEC4: {
  2112. int l = ident.length();
  2113. if (l == 1) {
  2114. member_type = DataType(dt - 3);
  2115. } else if (l == 2) {
  2116. member_type = DataType(dt - 2);
  2117. } else if (l == 3) {
  2118. member_type = DataType(dt - 1);
  2119. } else if (l == 4) {
  2120. member_type = dt;
  2121. } else {
  2122. ok = false;
  2123. break;
  2124. }
  2125. const CharType *c = ident.ptr();
  2126. for (int i = 0; i < l; i++) {
  2127. switch (c[i]) {
  2128. case 'r':
  2129. case 'g':
  2130. case 'b':
  2131. case 'a':
  2132. case 'x':
  2133. case 'y':
  2134. case 'z':
  2135. case 'w':
  2136. break;
  2137. default:
  2138. ok = false;
  2139. break;
  2140. }
  2141. }
  2142. } break;
  2143. default: {
  2144. ok = false;
  2145. }
  2146. }
  2147. if (!ok) {
  2148. _set_error("Invalid member for " + get_datatype_name(dt) + " expression: ." + ident);
  2149. return NULL;
  2150. }
  2151. MemberNode *mn = alloc_node<MemberNode>();
  2152. mn->basetype = dt;
  2153. mn->datatype = member_type;
  2154. mn->name = ident;
  2155. mn->owner = expr;
  2156. expr = mn;
  2157. //todo
  2158. //member (period) has priority over any operator
  2159. //creates a subindexing expression in place
  2160. /*} else if (tk.type==TK_BRACKET_OPEN) {
  2161. //todo
  2162. //subindexing has priority over any operator
  2163. //creates a subindexing expression in place
  2164. */
  2165. } else if (tk.type == TK_BRACKET_OPEN) {
  2166. Node *index = _parse_and_reduce_expression(p_block, p_builtin_types);
  2167. if (index->get_datatype() != TYPE_INT && index->get_datatype() != TYPE_UINT) {
  2168. _set_error("Only integer datatypes are allowed for indexing");
  2169. return NULL;
  2170. }
  2171. bool index_valid = false;
  2172. DataType member_type = TYPE_VOID;
  2173. switch (expr->get_datatype()) {
  2174. case TYPE_BVEC2:
  2175. case TYPE_VEC2:
  2176. case TYPE_IVEC2:
  2177. case TYPE_UVEC2:
  2178. case TYPE_MAT2:
  2179. if (index->type == Node::TYPE_CONSTANT) {
  2180. uint32_t index_constant = static_cast<ConstantNode *>(index)->values[0].uint;
  2181. if (index_constant >= 2) {
  2182. _set_error("Index out of range (0-1)");
  2183. return NULL;
  2184. }
  2185. } else {
  2186. _set_error("Only integer constants are allowed as index at the moment");
  2187. return NULL;
  2188. }
  2189. index_valid = true;
  2190. switch (expr->get_datatype()) {
  2191. case TYPE_BVEC2: member_type = TYPE_BOOL; break;
  2192. case TYPE_VEC2: member_type = TYPE_FLOAT; break;
  2193. case TYPE_IVEC2: member_type = TYPE_INT; break;
  2194. case TYPE_UVEC2: member_type = TYPE_UINT; break;
  2195. case TYPE_MAT2: member_type = TYPE_VEC2; break;
  2196. }
  2197. break;
  2198. case TYPE_BVEC3:
  2199. case TYPE_VEC3:
  2200. case TYPE_IVEC3:
  2201. case TYPE_UVEC3:
  2202. case TYPE_MAT3:
  2203. if (index->type == Node::TYPE_CONSTANT) {
  2204. uint32_t index_constant = static_cast<ConstantNode *>(index)->values[0].uint;
  2205. if (index_constant >= 3) {
  2206. _set_error("Index out of range (0-2)");
  2207. return NULL;
  2208. }
  2209. } else {
  2210. _set_error("Only integer constants are allowed as index at the moment");
  2211. return NULL;
  2212. }
  2213. index_valid = true;
  2214. switch (expr->get_datatype()) {
  2215. case TYPE_BVEC3: member_type = TYPE_BOOL; break;
  2216. case TYPE_VEC3: member_type = TYPE_FLOAT; break;
  2217. case TYPE_IVEC3: member_type = TYPE_INT; break;
  2218. case TYPE_UVEC3: member_type = TYPE_UINT; break;
  2219. case TYPE_MAT3: member_type = TYPE_VEC3; break;
  2220. }
  2221. break;
  2222. case TYPE_BVEC4:
  2223. case TYPE_VEC4:
  2224. case TYPE_IVEC4:
  2225. case TYPE_UVEC4:
  2226. case TYPE_MAT4:
  2227. if (index->type == Node::TYPE_CONSTANT) {
  2228. uint32_t index_constant = static_cast<ConstantNode *>(index)->values[0].uint;
  2229. if (index_constant >= 4) {
  2230. _set_error("Index out of range (0-3)");
  2231. return NULL;
  2232. }
  2233. } else {
  2234. _set_error("Only integer constants are allowed as index at the moment");
  2235. return NULL;
  2236. }
  2237. index_valid = true;
  2238. switch (expr->get_datatype()) {
  2239. case TYPE_BVEC4: member_type = TYPE_BOOL; break;
  2240. case TYPE_VEC4: member_type = TYPE_FLOAT; break;
  2241. case TYPE_IVEC4: member_type = TYPE_INT; break;
  2242. case TYPE_UVEC4: member_type = TYPE_UINT; break;
  2243. case TYPE_MAT4: member_type = TYPE_VEC4; break;
  2244. }
  2245. break;
  2246. default: {
  2247. _set_error("Object of type '" + get_datatype_name(expr->get_datatype()) + "' can't be indexed");
  2248. return NULL;
  2249. }
  2250. }
  2251. if (!index_valid) {
  2252. _set_error("Invalid index");
  2253. return NULL;
  2254. }
  2255. OperatorNode *op = alloc_node<OperatorNode>();
  2256. op->op = OP_INDEX;
  2257. op->return_cache = member_type;
  2258. op->arguments.push_back(expr);
  2259. op->arguments.push_back(index);
  2260. expr = op;
  2261. tk = _get_token();
  2262. if (tk.type != TK_BRACKET_CLOSE) {
  2263. _set_error("Expected ']' after indexing expression");
  2264. return NULL;
  2265. }
  2266. } else if (tk.type == TK_OP_INCREMENT || tk.type == TK_OP_DECREMENT) {
  2267. OperatorNode *op = alloc_node<OperatorNode>();
  2268. op->op = tk.type == TK_OP_DECREMENT ? OP_POST_DECREMENT : OP_POST_INCREMENT;
  2269. op->arguments.push_back(expr);
  2270. if (!_validate_operator(op, &op->return_cache)) {
  2271. _set_error("Invalid base type for increment/decrement operator");
  2272. return NULL;
  2273. }
  2274. expr = op;
  2275. } else {
  2276. _set_tkpos(pos);
  2277. break;
  2278. }
  2279. }
  2280. Expression e;
  2281. e.is_op = false;
  2282. e.node = expr;
  2283. expression.push_back(e);
  2284. pos = _get_tkpos();
  2285. tk = _get_token();
  2286. if (is_token_operator(tk.type)) {
  2287. Expression o;
  2288. o.is_op = true;
  2289. switch (tk.type) {
  2290. case TK_OP_EQUAL: o.op = OP_EQUAL; break;
  2291. case TK_OP_NOT_EQUAL: o.op = OP_NOT_EQUAL; break;
  2292. case TK_OP_LESS: o.op = OP_LESS; break;
  2293. case TK_OP_LESS_EQUAL: o.op = OP_LESS_EQUAL; break;
  2294. case TK_OP_GREATER: o.op = OP_GREATER; break;
  2295. case TK_OP_GREATER_EQUAL: o.op = OP_GREATER_EQUAL; break;
  2296. case TK_OP_AND: o.op = OP_AND; break;
  2297. case TK_OP_OR: o.op = OP_OR; break;
  2298. case TK_OP_ADD: o.op = OP_ADD; break;
  2299. case TK_OP_SUB: o.op = OP_SUB; break;
  2300. case TK_OP_MUL: o.op = OP_MUL; break;
  2301. case TK_OP_DIV: o.op = OP_DIV; break;
  2302. case TK_OP_MOD: o.op = OP_MOD; break;
  2303. case TK_OP_SHIFT_LEFT: o.op = OP_SHIFT_LEFT; break;
  2304. case TK_OP_SHIFT_RIGHT: o.op = OP_SHIFT_RIGHT; break;
  2305. case TK_OP_ASSIGN: o.op = OP_ASSIGN; break;
  2306. case TK_OP_ASSIGN_ADD: o.op = OP_ASSIGN_ADD; break;
  2307. case TK_OP_ASSIGN_SUB: o.op = OP_ASSIGN_SUB; break;
  2308. case TK_OP_ASSIGN_MUL: o.op = OP_ASSIGN_MUL; break;
  2309. case TK_OP_ASSIGN_DIV: o.op = OP_ASSIGN_DIV; break;
  2310. case TK_OP_ASSIGN_MOD: o.op = OP_ASSIGN_MOD; break;
  2311. case TK_OP_ASSIGN_SHIFT_LEFT: o.op = OP_ASSIGN_SHIFT_LEFT; break;
  2312. case TK_OP_ASSIGN_SHIFT_RIGHT: o.op = OP_ASSIGN_SHIFT_RIGHT; break;
  2313. case TK_OP_ASSIGN_BIT_AND: o.op = OP_ASSIGN_BIT_AND; break;
  2314. case TK_OP_ASSIGN_BIT_OR: o.op = OP_ASSIGN_BIT_OR; break;
  2315. case TK_OP_ASSIGN_BIT_XOR: o.op = OP_ASSIGN_BIT_XOR; break;
  2316. case TK_OP_BIT_AND: o.op = OP_BIT_AND; break;
  2317. case TK_OP_BIT_OR: o.op = OP_BIT_OR; break;
  2318. case TK_OP_BIT_XOR: o.op = OP_BIT_XOR; break;
  2319. case TK_QUESTION: o.op = OP_SELECT_IF; break;
  2320. case TK_COLON: o.op = OP_SELECT_ELSE; break;
  2321. default: {
  2322. _set_error("Invalid token for operator: " + get_token_text(tk));
  2323. return NULL;
  2324. }
  2325. }
  2326. expression.push_back(o);
  2327. } else {
  2328. _set_tkpos(pos); //something else, so rollback and end
  2329. break;
  2330. }
  2331. }
  2332. /* Reduce the set set of expressions and place them in an operator tree, respecting precedence */
  2333. while (expression.size() > 1) {
  2334. int next_op = -1;
  2335. int min_priority = 0xFFFFF;
  2336. bool is_unary = false;
  2337. bool is_ternary = false;
  2338. for (int i = 0; i < expression.size(); i++) {
  2339. if (!expression[i].is_op) {
  2340. continue;
  2341. }
  2342. bool unary = false;
  2343. bool ternary = false;
  2344. int priority;
  2345. switch (expression[i].op) {
  2346. case OP_EQUAL: priority = 8; break;
  2347. case OP_NOT_EQUAL: priority = 8; break;
  2348. case OP_LESS: priority = 7; break;
  2349. case OP_LESS_EQUAL: priority = 7; break;
  2350. case OP_GREATER: priority = 7; break;
  2351. case OP_GREATER_EQUAL: priority = 7; break;
  2352. case OP_AND: priority = 12; break;
  2353. case OP_OR: priority = 14; break;
  2354. case OP_NOT:
  2355. priority = 3;
  2356. unary = true;
  2357. break;
  2358. case OP_NEGATE:
  2359. priority = 3;
  2360. unary = true;
  2361. break;
  2362. case OP_ADD: priority = 5; break;
  2363. case OP_SUB: priority = 5; break;
  2364. case OP_MUL: priority = 4; break;
  2365. case OP_DIV: priority = 4; break;
  2366. case OP_MOD: priority = 4; break;
  2367. case OP_SHIFT_LEFT: priority = 6; break;
  2368. case OP_SHIFT_RIGHT: priority = 6; break;
  2369. case OP_ASSIGN: priority = 16; break;
  2370. case OP_ASSIGN_ADD: priority = 16; break;
  2371. case OP_ASSIGN_SUB: priority = 16; break;
  2372. case OP_ASSIGN_MUL: priority = 16; break;
  2373. case OP_ASSIGN_DIV: priority = 16; break;
  2374. case OP_ASSIGN_MOD: priority = 16; break;
  2375. case OP_ASSIGN_SHIFT_LEFT: priority = 16; break;
  2376. case OP_ASSIGN_SHIFT_RIGHT: priority = 16; break;
  2377. case OP_ASSIGN_BIT_AND: priority = 16; break;
  2378. case OP_ASSIGN_BIT_OR: priority = 16; break;
  2379. case OP_ASSIGN_BIT_XOR: priority = 16; break;
  2380. case OP_BIT_AND: priority = 9; break;
  2381. case OP_BIT_OR: priority = 11; break;
  2382. case OP_BIT_XOR: priority = 10; break;
  2383. case OP_BIT_INVERT:
  2384. priority = 3;
  2385. unary = true;
  2386. break;
  2387. case OP_INCREMENT:
  2388. priority = 3;
  2389. unary = true;
  2390. break;
  2391. case OP_DECREMENT:
  2392. priority = 3;
  2393. unary = true;
  2394. break;
  2395. case OP_SELECT_IF:
  2396. priority = 15;
  2397. ternary = true;
  2398. break;
  2399. case OP_SELECT_ELSE:
  2400. priority = 15;
  2401. ternary = true;
  2402. break;
  2403. default:
  2404. ERR_FAIL_V(NULL); //unexpected operator
  2405. }
  2406. if (priority < min_priority) {
  2407. // < is used for left to right (default)
  2408. // <= is used for right to left
  2409. next_op = i;
  2410. min_priority = priority;
  2411. is_unary = unary;
  2412. is_ternary = ternary;
  2413. }
  2414. }
  2415. ERR_FAIL_COND_V(next_op == -1, NULL);
  2416. // OK! create operator..
  2417. // OK! create operator..
  2418. if (is_unary) {
  2419. int expr_pos = next_op;
  2420. while (expression[expr_pos].is_op) {
  2421. expr_pos++;
  2422. if (expr_pos == expression.size()) {
  2423. //can happen..
  2424. _set_error("Unexpected end of expression..");
  2425. return NULL;
  2426. }
  2427. }
  2428. //consecutively do unary opeators
  2429. for (int i = expr_pos - 1; i >= next_op; i--) {
  2430. OperatorNode *op = alloc_node<OperatorNode>();
  2431. op->op = expression[i].op;
  2432. op->arguments.push_back(expression[i + 1].node);
  2433. expression[i].is_op = false;
  2434. expression[i].node = op;
  2435. if (!_validate_operator(op, &op->return_cache)) {
  2436. String at;
  2437. for (int i = 0; i < op->arguments.size(); i++) {
  2438. if (i > 0)
  2439. at += " and ";
  2440. at += get_datatype_name(op->arguments[i]->get_datatype());
  2441. }
  2442. _set_error("Invalid arguments to unary operator '" + get_operator_text(op->op) + "' :" + at);
  2443. return NULL;
  2444. }
  2445. expression.remove(i + 1);
  2446. }
  2447. } else if (is_ternary) {
  2448. if (next_op < 1 || next_op >= (expression.size() - 1)) {
  2449. _set_error("Parser bug..");
  2450. ERR_FAIL_V(NULL);
  2451. }
  2452. if (next_op + 2 >= expression.size() || !expression[next_op + 2].is_op || expression[next_op + 2].op != OP_SELECT_ELSE) {
  2453. _set_error("Mising matching ':' for select operator");
  2454. return NULL;
  2455. }
  2456. OperatorNode *op = alloc_node<OperatorNode>();
  2457. op->op = expression[next_op].op;
  2458. op->arguments.push_back(expression[next_op - 1].node);
  2459. op->arguments.push_back(expression[next_op + 1].node);
  2460. op->arguments.push_back(expression[next_op + 3].node);
  2461. expression[next_op - 1].is_op = false;
  2462. expression[next_op - 1].node = op;
  2463. if (!_validate_operator(op, &op->return_cache)) {
  2464. String at;
  2465. for (int i = 0; i < op->arguments.size(); i++) {
  2466. if (i > 0)
  2467. at += " and ";
  2468. at += get_datatype_name(op->arguments[i]->get_datatype());
  2469. }
  2470. _set_error("Invalid argument to ternary ?: operator: " + at);
  2471. return NULL;
  2472. }
  2473. for (int i = 0; i < 4; i++) {
  2474. expression.remove(next_op);
  2475. }
  2476. } else {
  2477. if (next_op < 1 || next_op >= (expression.size() - 1)) {
  2478. _set_error("Parser bug..");
  2479. ERR_FAIL_V(NULL);
  2480. }
  2481. OperatorNode *op = alloc_node<OperatorNode>();
  2482. op->op = expression[next_op].op;
  2483. if (expression[next_op - 1].is_op) {
  2484. _set_error("Parser bug..");
  2485. ERR_FAIL_V(NULL);
  2486. }
  2487. if (expression[next_op + 1].is_op) {
  2488. // this is not invalid and can really appear
  2489. // but it becomes invalid anyway because no binary op
  2490. // can be followed by a unary op in a valid combination,
  2491. // due to how precedence works, unaries will always disappear first
  2492. _set_error("Parser bug..");
  2493. }
  2494. op->arguments.push_back(expression[next_op - 1].node); //expression goes as left
  2495. op->arguments.push_back(expression[next_op + 1].node); //next expression goes as right
  2496. expression[next_op - 1].node = op;
  2497. //replace all 3 nodes by this operator and make it an expression
  2498. if (!_validate_operator(op, &op->return_cache)) {
  2499. String at;
  2500. for (int i = 0; i < op->arguments.size(); i++) {
  2501. if (i > 0)
  2502. at += " and ";
  2503. at += get_datatype_name(op->arguments[i]->get_datatype());
  2504. }
  2505. _set_error("Invalid arguments to operator '" + get_operator_text(op->op) + "' :" + at);
  2506. return NULL;
  2507. }
  2508. expression.remove(next_op);
  2509. expression.remove(next_op);
  2510. }
  2511. }
  2512. return expression[0].node;
  2513. }
  2514. ShaderLanguage::Node *ShaderLanguage::_reduce_expression(BlockNode *p_block, ShaderLanguage::Node *p_node) {
  2515. if (p_node->type != Node::TYPE_OPERATOR)
  2516. return p_node;
  2517. //for now only reduce simple constructors
  2518. OperatorNode *op = static_cast<OperatorNode *>(p_node);
  2519. if (op->op == OP_CONSTRUCT) {
  2520. ERR_FAIL_COND_V(op->arguments[0]->type != Node::TYPE_VARIABLE, p_node);
  2521. DataType base = get_scalar_type(op->get_datatype());
  2522. Vector<ConstantNode::Value> values;
  2523. for (int i = 1; i < op->arguments.size(); i++) {
  2524. op->arguments[i] = _reduce_expression(p_block, op->arguments[i]);
  2525. if (op->arguments[i]->type == Node::TYPE_CONSTANT) {
  2526. ConstantNode *cn = static_cast<ConstantNode *>(op->arguments[i]);
  2527. if (get_scalar_type(cn->datatype) == base) {
  2528. for (int j = 0; j < cn->values.size(); j++) {
  2529. values.push_back(cn->values[j]);
  2530. }
  2531. } else if (get_scalar_type(cn->datatype) == cn->datatype) {
  2532. ConstantNode::Value v;
  2533. if (!convert_constant(cn, base, &v)) {
  2534. return p_node;
  2535. }
  2536. values.push_back(v);
  2537. } else {
  2538. return p_node;
  2539. }
  2540. } else {
  2541. return p_node;
  2542. }
  2543. }
  2544. ConstantNode *cn = alloc_node<ConstantNode>();
  2545. cn->datatype = op->get_datatype();
  2546. cn->values = values;
  2547. return cn;
  2548. } else if (op->op == OP_NEGATE) {
  2549. op->arguments[0] = _reduce_expression(p_block, op->arguments[0]);
  2550. if (op->arguments[0]->type == Node::TYPE_CONSTANT) {
  2551. ConstantNode *cn = static_cast<ConstantNode *>(op->arguments[0]);
  2552. DataType base = get_scalar_type(cn->datatype);
  2553. Vector<ConstantNode::Value> values;
  2554. for (int i = 0; i < cn->values.size(); i++) {
  2555. ConstantNode::Value nv;
  2556. switch (base) {
  2557. case TYPE_BOOL: {
  2558. nv.boolean = !cn->values[i].boolean;
  2559. } break;
  2560. case TYPE_INT: {
  2561. nv.sint = -cn->values[i].sint;
  2562. } break;
  2563. case TYPE_UINT: {
  2564. nv.uint = -cn->values[i].uint;
  2565. } break;
  2566. case TYPE_FLOAT: {
  2567. nv.real = -cn->values[i].real;
  2568. } break;
  2569. default: {}
  2570. }
  2571. values.push_back(nv);
  2572. }
  2573. cn->values = values;
  2574. return cn;
  2575. }
  2576. }
  2577. return p_node;
  2578. }
  2579. ShaderLanguage::Node *ShaderLanguage::_parse_and_reduce_expression(BlockNode *p_block, const Map<StringName, DataType> &p_builtin_types) {
  2580. ShaderLanguage::Node *expr = _parse_expression(p_block, p_builtin_types);
  2581. if (!expr) //errored
  2582. return NULL;
  2583. expr = _reduce_expression(p_block, expr);
  2584. return expr;
  2585. }
  2586. Error ShaderLanguage::_parse_block(BlockNode *p_block, const Map<StringName, DataType> &p_builtin_types, bool p_just_one, bool p_can_break, bool p_can_continue) {
  2587. while (true) {
  2588. TkPos pos = _get_tkpos();
  2589. Token tk = _get_token();
  2590. if (tk.type == TK_CURLY_BRACKET_CLOSE) { //end of block
  2591. if (p_just_one) {
  2592. _set_error("Unexpected '}'");
  2593. return ERR_PARSE_ERROR;
  2594. }
  2595. return OK;
  2596. } else if (is_token_precision(tk.type) || is_token_nonvoid_datatype(tk.type)) {
  2597. DataPrecision precision = PRECISION_DEFAULT;
  2598. if (is_token_precision(tk.type)) {
  2599. precision = get_token_precision(tk.type);
  2600. tk = _get_token();
  2601. if (!is_token_nonvoid_datatype(tk.type)) {
  2602. _set_error("Expected datatype after precission");
  2603. return ERR_PARSE_ERROR;
  2604. }
  2605. }
  2606. DataType type = get_token_datatype(tk.type);
  2607. tk = _get_token();
  2608. VariableDeclarationNode *vardecl = alloc_node<VariableDeclarationNode>();
  2609. vardecl->datatype = type;
  2610. vardecl->precision = precision;
  2611. p_block->statements.push_back(vardecl);
  2612. while (true) {
  2613. if (tk.type != TK_IDENTIFIER) {
  2614. _set_error("Expected identifier after type");
  2615. return ERR_PARSE_ERROR;
  2616. }
  2617. StringName name = tk.text;
  2618. if (_find_identifier(p_block, p_builtin_types, name)) {
  2619. _set_error("Redefinition of '" + String(name) + "'");
  2620. return ERR_PARSE_ERROR;
  2621. }
  2622. BlockNode::Variable var;
  2623. var.type = type;
  2624. var.precision = precision;
  2625. var.line = tk_line;
  2626. p_block->variables[name] = var;
  2627. VariableDeclarationNode::Declaration decl;
  2628. decl.name = name;
  2629. decl.initializer = NULL;
  2630. tk = _get_token();
  2631. if (tk.type == TK_OP_ASSIGN) {
  2632. //variable creted with assignment! must parse an expression
  2633. Node *n = _parse_and_reduce_expression(p_block, p_builtin_types);
  2634. if (!n)
  2635. return ERR_PARSE_ERROR;
  2636. decl.initializer = n;
  2637. if (var.type != n->get_datatype()) {
  2638. _set_error("Invalid assignment of '" + get_datatype_name(n->get_datatype()) + "' to '" + get_datatype_name(var.type) + "'");
  2639. return ERR_PARSE_ERROR;
  2640. }
  2641. tk = _get_token();
  2642. }
  2643. vardecl->declarations.push_back(decl);
  2644. if (tk.type == TK_COMMA) {
  2645. tk = _get_token();
  2646. //another variable
  2647. } else if (tk.type == TK_SEMICOLON) {
  2648. break;
  2649. } else {
  2650. _set_error("Expected ',' or ';' after variable");
  2651. return ERR_PARSE_ERROR;
  2652. }
  2653. }
  2654. } else if (tk.type == TK_CURLY_BRACKET_OPEN) {
  2655. //a sub block, just because..
  2656. BlockNode *block = alloc_node<BlockNode>();
  2657. block->parent_block = p_block;
  2658. _parse_block(block, p_builtin_types, false, p_can_break, p_can_continue);
  2659. p_block->statements.push_back(block);
  2660. } else if (tk.type == TK_CF_IF) {
  2661. //if () {}
  2662. tk = _get_token();
  2663. if (tk.type != TK_PARENTHESIS_OPEN) {
  2664. _set_error("Expected '(' after if");
  2665. return ERR_PARSE_ERROR;
  2666. }
  2667. ControlFlowNode *cf = alloc_node<ControlFlowNode>();
  2668. cf->flow_op = FLOW_OP_IF;
  2669. Node *n = _parse_and_reduce_expression(p_block, p_builtin_types);
  2670. if (!n)
  2671. return ERR_PARSE_ERROR;
  2672. tk = _get_token();
  2673. if (tk.type != TK_PARENTHESIS_CLOSE) {
  2674. _set_error("Expected ')' after expression");
  2675. return ERR_PARSE_ERROR;
  2676. }
  2677. BlockNode *block = alloc_node<BlockNode>();
  2678. block->parent_block = p_block;
  2679. cf->expressions.push_back(n);
  2680. cf->blocks.push_back(block);
  2681. p_block->statements.push_back(cf);
  2682. Error err = _parse_block(block, p_builtin_types, true, p_can_break, p_can_continue);
  2683. if (err)
  2684. return err;
  2685. pos = _get_tkpos();
  2686. tk = _get_token();
  2687. if (tk.type == TK_CF_ELSE) {
  2688. block = alloc_node<BlockNode>();
  2689. block->parent_block = p_block;
  2690. cf->blocks.push_back(block);
  2691. err = _parse_block(block, p_builtin_types, true, p_can_break, p_can_continue);
  2692. } else {
  2693. _set_tkpos(pos); //rollback
  2694. }
  2695. } else if (tk.type == TK_CF_WHILE) {
  2696. //if () {}
  2697. tk = _get_token();
  2698. if (tk.type != TK_PARENTHESIS_OPEN) {
  2699. _set_error("Expected '(' after while");
  2700. return ERR_PARSE_ERROR;
  2701. }
  2702. ControlFlowNode *cf = alloc_node<ControlFlowNode>();
  2703. cf->flow_op = FLOW_OP_WHILE;
  2704. Node *n = _parse_and_reduce_expression(p_block, p_builtin_types);
  2705. if (!n)
  2706. return ERR_PARSE_ERROR;
  2707. tk = _get_token();
  2708. if (tk.type != TK_PARENTHESIS_CLOSE) {
  2709. _set_error("Expected ')' after expression");
  2710. return ERR_PARSE_ERROR;
  2711. }
  2712. BlockNode *block = alloc_node<BlockNode>();
  2713. block->parent_block = p_block;
  2714. cf->expressions.push_back(n);
  2715. cf->blocks.push_back(block);
  2716. p_block->statements.push_back(cf);
  2717. Error err = _parse_block(block, p_builtin_types, true, true, true);
  2718. if (err)
  2719. return err;
  2720. } else if (tk.type == TK_CF_FOR) {
  2721. //if () {}
  2722. tk = _get_token();
  2723. if (tk.type != TK_PARENTHESIS_OPEN) {
  2724. _set_error("Expected '(' after for");
  2725. return ERR_PARSE_ERROR;
  2726. }
  2727. ControlFlowNode *cf = alloc_node<ControlFlowNode>();
  2728. cf->flow_op = FLOW_OP_FOR;
  2729. BlockNode *init_block = alloc_node<BlockNode>();
  2730. init_block->parent_block = p_block;
  2731. init_block->single_statement = true;
  2732. cf->blocks.push_back(init_block);
  2733. if (_parse_block(init_block, p_builtin_types, true, false, false) != OK) {
  2734. return ERR_PARSE_ERROR;
  2735. }
  2736. Node *n = _parse_and_reduce_expression(init_block, p_builtin_types);
  2737. if (!n)
  2738. return ERR_PARSE_ERROR;
  2739. if (n->get_datatype() != TYPE_BOOL) {
  2740. _set_error("Middle expression is expected to be boolean.");
  2741. return ERR_PARSE_ERROR;
  2742. }
  2743. tk = _get_token();
  2744. if (tk.type != TK_SEMICOLON) {
  2745. _set_error("Expected ';' after middle expression");
  2746. return ERR_PARSE_ERROR;
  2747. }
  2748. cf->expressions.push_back(n);
  2749. n = _parse_and_reduce_expression(init_block, p_builtin_types);
  2750. if (!n)
  2751. return ERR_PARSE_ERROR;
  2752. cf->expressions.push_back(n);
  2753. tk = _get_token();
  2754. if (tk.type != TK_PARENTHESIS_CLOSE) {
  2755. _set_error("Expected ')' after third expression");
  2756. return ERR_PARSE_ERROR;
  2757. }
  2758. BlockNode *block = alloc_node<BlockNode>();
  2759. block->parent_block = p_block;
  2760. cf->blocks.push_back(block);
  2761. p_block->statements.push_back(cf);
  2762. Error err = _parse_block(block, p_builtin_types, true, true, true);
  2763. if (err)
  2764. return err;
  2765. } else if (tk.type == TK_CF_RETURN) {
  2766. //check return type
  2767. BlockNode *b = p_block;
  2768. while (b && !b->parent_function) {
  2769. b = b->parent_block;
  2770. }
  2771. if (!b) {
  2772. _set_error("Bug");
  2773. return ERR_BUG;
  2774. }
  2775. ControlFlowNode *flow = alloc_node<ControlFlowNode>();
  2776. flow->flow_op = FLOW_OP_RETURN;
  2777. pos = _get_tkpos();
  2778. tk = _get_token();
  2779. if (tk.type == TK_SEMICOLON) {
  2780. //all is good
  2781. if (b->parent_function->return_type != TYPE_VOID) {
  2782. _set_error("Expected return with expression of type '" + get_datatype_name(b->parent_function->return_type) + "'");
  2783. return ERR_PARSE_ERROR;
  2784. }
  2785. } else {
  2786. _set_tkpos(pos); //rollback, wants expression
  2787. Node *expr = _parse_and_reduce_expression(p_block, p_builtin_types);
  2788. if (!expr)
  2789. return ERR_PARSE_ERROR;
  2790. if (b->parent_function->return_type != expr->get_datatype()) {
  2791. _set_error("Expected return expression of type '" + get_datatype_name(b->parent_function->return_type) + "'");
  2792. return ERR_PARSE_ERROR;
  2793. }
  2794. tk = _get_token();
  2795. if (tk.type != TK_SEMICOLON) {
  2796. _set_error("Expected ';' after return expression");
  2797. return ERR_PARSE_ERROR;
  2798. }
  2799. flow->expressions.push_back(expr);
  2800. }
  2801. p_block->statements.push_back(flow);
  2802. } else if (tk.type == TK_CF_DISCARD) {
  2803. //check return type
  2804. BlockNode *b = p_block;
  2805. while (b && !b->parent_function) {
  2806. b = b->parent_block;
  2807. }
  2808. if (!b) {
  2809. _set_error("Bug");
  2810. return ERR_BUG;
  2811. }
  2812. if (!b->parent_function->can_discard) {
  2813. _set_error("Use of 'discard' is not allowed here.");
  2814. return ERR_PARSE_ERROR;
  2815. }
  2816. ControlFlowNode *flow = alloc_node<ControlFlowNode>();
  2817. flow->flow_op = FLOW_OP_DISCARD;
  2818. pos = _get_tkpos();
  2819. tk = _get_token();
  2820. if (tk.type != TK_SEMICOLON) {
  2821. //all is good
  2822. _set_error("Expected ';' after discard");
  2823. }
  2824. p_block->statements.push_back(flow);
  2825. } else if (tk.type == TK_CF_BREAK) {
  2826. if (!p_can_break) {
  2827. //all is good
  2828. _set_error("Breaking is not allowed here");
  2829. }
  2830. ControlFlowNode *flow = alloc_node<ControlFlowNode>();
  2831. flow->flow_op = FLOW_OP_BREAK;
  2832. pos = _get_tkpos();
  2833. tk = _get_token();
  2834. if (tk.type != TK_SEMICOLON) {
  2835. //all is good
  2836. _set_error("Expected ';' after break");
  2837. }
  2838. p_block->statements.push_back(flow);
  2839. } else if (tk.type == TK_CF_CONTINUE) {
  2840. if (!p_can_break) {
  2841. //all is good
  2842. _set_error("Contiuning is not allowed here");
  2843. }
  2844. ControlFlowNode *flow = alloc_node<ControlFlowNode>();
  2845. flow->flow_op = FLOW_OP_CONTINUE;
  2846. pos = _get_tkpos();
  2847. tk = _get_token();
  2848. if (tk.type != TK_SEMICOLON) {
  2849. //all is good
  2850. _set_error("Expected ';' after continue");
  2851. }
  2852. p_block->statements.push_back(flow);
  2853. } else {
  2854. //nothng else, so expression
  2855. _set_tkpos(pos); //rollback
  2856. Node *expr = _parse_and_reduce_expression(p_block, p_builtin_types);
  2857. if (!expr)
  2858. return ERR_PARSE_ERROR;
  2859. p_block->statements.push_back(expr);
  2860. tk = _get_token();
  2861. if (tk.type != TK_SEMICOLON) {
  2862. _set_error("Expected ';' after statement");
  2863. return ERR_PARSE_ERROR;
  2864. }
  2865. }
  2866. if (p_just_one)
  2867. break;
  2868. }
  2869. return OK;
  2870. }
  2871. Error ShaderLanguage::_parse_shader(const Map<StringName, FunctionInfo> &p_functions, const Set<String> &p_render_modes, const Set<String> &p_shader_types) {
  2872. Token tk = _get_token();
  2873. if (tk.type != TK_SHADER_TYPE) {
  2874. _set_error("Expected 'shader_type' at the beginning of shader.");
  2875. return ERR_PARSE_ERROR;
  2876. }
  2877. tk = _get_token();
  2878. if (tk.type != TK_IDENTIFIER) {
  2879. _set_error("Expected identifier after 'shader_type', indicating type of shader.");
  2880. return ERR_PARSE_ERROR;
  2881. }
  2882. String shader_type_identifier;
  2883. shader_type_identifier = tk.text;
  2884. if (!p_shader_types.has(shader_type_identifier)) {
  2885. String valid;
  2886. for (Set<String>::Element *E = p_shader_types.front(); E; E = E->next()) {
  2887. if (valid != String()) {
  2888. valid += ", ";
  2889. }
  2890. valid += "'" + E->get() + "'";
  2891. }
  2892. _set_error("Invalid shader type, valid types are: " + valid);
  2893. return ERR_PARSE_ERROR;
  2894. }
  2895. tk = _get_token();
  2896. if (tk.type != TK_SEMICOLON) {
  2897. _set_error("Expected ';' after 'shader_type <type>'.");
  2898. }
  2899. tk = _get_token();
  2900. int texture_uniforms = 0;
  2901. int uniforms = 0;
  2902. while (tk.type != TK_EOF) {
  2903. switch (tk.type) {
  2904. case TK_RENDER_MODE: {
  2905. while (true) {
  2906. StringName mode;
  2907. _get_completable_identifier(NULL, COMPLETION_RENDER_MODE, mode);
  2908. if (mode == StringName()) {
  2909. _set_error("Expected identifier for render mode");
  2910. return ERR_PARSE_ERROR;
  2911. }
  2912. if (!p_render_modes.has(mode)) {
  2913. _set_error("Invalid render mode: '" + String(mode) + "'");
  2914. return ERR_PARSE_ERROR;
  2915. }
  2916. if (shader->render_modes.find(mode) != -1) {
  2917. _set_error("Duplicate render mode: '" + String(mode) + "'");
  2918. return ERR_PARSE_ERROR;
  2919. }
  2920. shader->render_modes.push_back(mode);
  2921. tk = _get_token();
  2922. if (tk.type == TK_COMMA) {
  2923. //all good, do nothing
  2924. } else if (tk.type == TK_SEMICOLON) {
  2925. break; //done
  2926. } else {
  2927. _set_error("Unexpected token: " + get_token_text(tk));
  2928. return ERR_PARSE_ERROR;
  2929. }
  2930. }
  2931. } break;
  2932. case TK_UNIFORM:
  2933. case TK_VARYING: {
  2934. bool uniform = tk.type == TK_UNIFORM;
  2935. DataPrecision precision = PRECISION_DEFAULT;
  2936. DataType type;
  2937. StringName name;
  2938. tk = _get_token();
  2939. if (is_token_precision(tk.type)) {
  2940. precision = get_token_precision(tk.type);
  2941. tk = _get_token();
  2942. }
  2943. if (!is_token_datatype(tk.type)) {
  2944. _set_error("Expected datatype. ");
  2945. return ERR_PARSE_ERROR;
  2946. }
  2947. type = get_token_datatype(tk.type);
  2948. if (type == TYPE_VOID) {
  2949. _set_error("void datatype not allowed here");
  2950. return ERR_PARSE_ERROR;
  2951. }
  2952. if (!uniform && type < TYPE_FLOAT && type > TYPE_VEC4) { // FIXME: always false! should it be || instead?
  2953. _set_error("Invalid type for varying, only float,vec2,vec3,vec4 allowed.");
  2954. return ERR_PARSE_ERROR;
  2955. }
  2956. tk = _get_token();
  2957. if (tk.type != TK_IDENTIFIER) {
  2958. _set_error("Expected identifier!");
  2959. return ERR_PARSE_ERROR;
  2960. }
  2961. name = tk.text;
  2962. if (_find_identifier(NULL, Map<StringName, DataType>(), name)) {
  2963. _set_error("Redefinition of '" + String(name) + "'");
  2964. return ERR_PARSE_ERROR;
  2965. }
  2966. if (uniform) {
  2967. ShaderNode::Uniform uniform;
  2968. if (is_sampler_type(type)) {
  2969. uniform.texture_order = texture_uniforms++;
  2970. uniform.order = -1;
  2971. } else {
  2972. uniform.texture_order = -1;
  2973. uniform.order = uniforms++;
  2974. }
  2975. uniform.type = type;
  2976. uniform.precission = precision;
  2977. //todo parse default value
  2978. tk = _get_token();
  2979. if (tk.type == TK_OP_ASSIGN) {
  2980. Node *expr = _parse_and_reduce_expression(NULL, Map<StringName, DataType>());
  2981. if (!expr)
  2982. return ERR_PARSE_ERROR;
  2983. if (expr->type != Node::TYPE_CONSTANT) {
  2984. _set_error("Expected constant expression after '='");
  2985. return ERR_PARSE_ERROR;
  2986. }
  2987. ConstantNode *cn = static_cast<ConstantNode *>(expr);
  2988. uniform.default_value.resize(cn->values.size());
  2989. if (!convert_constant(cn, uniform.type, uniform.default_value.ptr())) {
  2990. _set_error("Can't convert constant to " + get_datatype_name(uniform.type));
  2991. return ERR_PARSE_ERROR;
  2992. }
  2993. tk = _get_token();
  2994. }
  2995. if (tk.type == TK_COLON) {
  2996. //hint
  2997. tk = _get_token();
  2998. if (tk.type == TK_HINT_WHITE_TEXTURE) {
  2999. uniform.hint = ShaderNode::Uniform::HINT_WHITE;
  3000. } else if (tk.type == TK_HINT_BLACK_TEXTURE) {
  3001. uniform.hint = ShaderNode::Uniform::HINT_BLACK;
  3002. } else if (tk.type == TK_HINT_NORMAL_TEXTURE) {
  3003. uniform.hint = ShaderNode::Uniform::HINT_NORMAL;
  3004. } else if (tk.type == TK_HINT_ANISO_TEXTURE) {
  3005. uniform.hint = ShaderNode::Uniform::HINT_ANISO;
  3006. } else if (tk.type == TK_HINT_ALBEDO_TEXTURE) {
  3007. uniform.hint = ShaderNode::Uniform::HINT_ALBEDO;
  3008. } else if (tk.type == TK_HINT_BLACK_ALBEDO_TEXTURE) {
  3009. uniform.hint = ShaderNode::Uniform::HINT_BLACK_ALBEDO;
  3010. } else if (tk.type == TK_HINT_COLOR) {
  3011. if (type != TYPE_VEC4) {
  3012. _set_error("Color hint is for vec4 only");
  3013. return ERR_PARSE_ERROR;
  3014. }
  3015. uniform.hint = ShaderNode::Uniform::HINT_COLOR;
  3016. } else if (tk.type == TK_HINT_RANGE) {
  3017. uniform.hint = ShaderNode::Uniform::HINT_RANGE;
  3018. if (type != TYPE_FLOAT && type != TYPE_INT) {
  3019. _set_error("Range hint is for float and int only");
  3020. return ERR_PARSE_ERROR;
  3021. }
  3022. tk = _get_token();
  3023. if (tk.type != TK_PARENTHESIS_OPEN) {
  3024. _set_error("Expected '(' after hint_range");
  3025. return ERR_PARSE_ERROR;
  3026. }
  3027. tk = _get_token();
  3028. float sign = 1.0;
  3029. if (tk.type == TK_OP_SUB) {
  3030. sign = -1.0;
  3031. tk = _get_token();
  3032. }
  3033. if (tk.type != TK_REAL_CONSTANT && tk.type != TK_INT_CONSTANT) {
  3034. _set_error("Expected integer constant");
  3035. return ERR_PARSE_ERROR;
  3036. }
  3037. uniform.hint_range[0] = tk.constant;
  3038. uniform.hint_range[0] *= sign;
  3039. tk = _get_token();
  3040. if (tk.type != TK_COMMA) {
  3041. _set_error("Expected ',' after integer constant");
  3042. return ERR_PARSE_ERROR;
  3043. }
  3044. tk = _get_token();
  3045. sign = 1.0;
  3046. if (tk.type == TK_OP_SUB) {
  3047. sign = -1.0;
  3048. tk = _get_token();
  3049. }
  3050. if (tk.type != TK_REAL_CONSTANT && tk.type != TK_INT_CONSTANT) {
  3051. _set_error("Expected integer constant after ','");
  3052. return ERR_PARSE_ERROR;
  3053. }
  3054. uniform.hint_range[1] = tk.constant;
  3055. uniform.hint_range[1] *= sign;
  3056. tk = _get_token();
  3057. if (tk.type == TK_COMMA) {
  3058. tk = _get_token();
  3059. if (tk.type != TK_REAL_CONSTANT && tk.type != TK_INT_CONSTANT) {
  3060. _set_error("Expected integer constant after ','");
  3061. return ERR_PARSE_ERROR;
  3062. }
  3063. uniform.hint_range[2] = tk.constant;
  3064. tk = _get_token();
  3065. } else {
  3066. if (type == TYPE_INT) {
  3067. uniform.hint_range[2] = 1;
  3068. } else {
  3069. uniform.hint_range[2] = 0.001;
  3070. }
  3071. }
  3072. if (tk.type != TK_PARENTHESIS_CLOSE) {
  3073. _set_error("Expected ','");
  3074. return ERR_PARSE_ERROR;
  3075. }
  3076. } else {
  3077. _set_error("Expected valid type hint after ':'.");
  3078. }
  3079. if (uniform.hint != ShaderNode::Uniform::HINT_RANGE && uniform.hint != ShaderNode::Uniform::HINT_NONE && uniform.hint != ShaderNode::Uniform::HINT_COLOR && type <= TYPE_MAT4) {
  3080. _set_error("This hint is only for sampler types");
  3081. return ERR_PARSE_ERROR;
  3082. }
  3083. tk = _get_token();
  3084. }
  3085. shader->uniforms[name] = uniform;
  3086. if (tk.type != TK_SEMICOLON) {
  3087. _set_error("Expected ';'");
  3088. return ERR_PARSE_ERROR;
  3089. }
  3090. } else {
  3091. ShaderNode::Varying varying;
  3092. varying.type = type;
  3093. varying.precission = precision;
  3094. shader->varyings[name] = varying;
  3095. tk = _get_token();
  3096. if (tk.type != TK_SEMICOLON) {
  3097. _set_error("Expected ';'");
  3098. return ERR_PARSE_ERROR;
  3099. }
  3100. }
  3101. } break;
  3102. default: {
  3103. //function
  3104. DataPrecision precision = PRECISION_DEFAULT;
  3105. DataType type;
  3106. StringName name;
  3107. if (is_token_precision(tk.type)) {
  3108. precision = get_token_precision(tk.type);
  3109. tk = _get_token();
  3110. }
  3111. if (!is_token_datatype(tk.type)) {
  3112. _set_error("Expected function, uniform or varying ");
  3113. return ERR_PARSE_ERROR;
  3114. }
  3115. type = get_token_datatype(tk.type);
  3116. _get_completable_identifier(NULL, COMPLETION_MAIN_FUNCTION, name);
  3117. if (name == StringName()) {
  3118. _set_error("Expected function name after datatype");
  3119. return ERR_PARSE_ERROR;
  3120. }
  3121. if (_find_identifier(NULL, Map<StringName, DataType>(), name)) {
  3122. _set_error("Redefinition of '" + String(name) + "'");
  3123. return ERR_PARSE_ERROR;
  3124. }
  3125. tk = _get_token();
  3126. if (tk.type != TK_PARENTHESIS_OPEN) {
  3127. _set_error("Expected '(' after identifier");
  3128. return ERR_PARSE_ERROR;
  3129. }
  3130. Map<StringName, DataType> builtin_types;
  3131. if (p_functions.has(name)) {
  3132. builtin_types = p_functions[name].built_ins;
  3133. }
  3134. ShaderNode::Function function;
  3135. function.callable = !p_functions.has(name);
  3136. function.name = name;
  3137. FunctionNode *func_node = alloc_node<FunctionNode>();
  3138. function.function = func_node;
  3139. shader->functions.push_back(function);
  3140. func_node->name = name;
  3141. func_node->return_type = type;
  3142. func_node->return_precision = precision;
  3143. if (p_functions.has(name)) {
  3144. func_node->can_discard = p_functions[name].can_discard;
  3145. }
  3146. func_node->body = alloc_node<BlockNode>();
  3147. func_node->body->parent_function = func_node;
  3148. tk = _get_token();
  3149. while (true) {
  3150. if (tk.type == TK_PARENTHESIS_CLOSE) {
  3151. break;
  3152. }
  3153. ArgumentQualifier qualifier = ARGUMENT_QUALIFIER_IN;
  3154. if (tk.type == TK_ARG_IN) {
  3155. qualifier = ARGUMENT_QUALIFIER_IN;
  3156. tk = _get_token();
  3157. } else if (tk.type == TK_ARG_OUT) {
  3158. qualifier = ARGUMENT_QUALIFIER_OUT;
  3159. tk = _get_token();
  3160. } else if (tk.type == TK_ARG_INOUT) {
  3161. qualifier = ARGUMENT_QUALIFIER_INOUT;
  3162. tk = _get_token();
  3163. }
  3164. DataType ptype;
  3165. StringName pname;
  3166. DataPrecision pprecision = PRECISION_DEFAULT;
  3167. if (is_token_precision(tk.type)) {
  3168. pprecision = get_token_precision(tk.type);
  3169. tk = _get_token();
  3170. }
  3171. if (!is_token_datatype(tk.type)) {
  3172. _set_error("Expected a valid datatype for argument");
  3173. return ERR_PARSE_ERROR;
  3174. }
  3175. ptype = get_token_datatype(tk.type);
  3176. if (ptype == TYPE_VOID) {
  3177. _set_error("void not allowed in argument");
  3178. return ERR_PARSE_ERROR;
  3179. }
  3180. tk = _get_token();
  3181. if (tk.type != TK_IDENTIFIER) {
  3182. _set_error("Expected identifier for argument name");
  3183. return ERR_PARSE_ERROR;
  3184. }
  3185. pname = tk.text;
  3186. if (_find_identifier(func_node->body, builtin_types, pname)) {
  3187. _set_error("Redefinition of '" + String(pname) + "'");
  3188. return ERR_PARSE_ERROR;
  3189. }
  3190. FunctionNode::Argument arg;
  3191. arg.type = ptype;
  3192. arg.name = pname;
  3193. arg.precision = pprecision;
  3194. arg.qualifier = qualifier;
  3195. func_node->arguments.push_back(arg);
  3196. tk = _get_token();
  3197. if (tk.type == TK_COMMA) {
  3198. tk = _get_token();
  3199. //do none and go on
  3200. } else if (tk.type != TK_PARENTHESIS_CLOSE) {
  3201. _set_error("Expected ',' or ')' after identifier");
  3202. return ERR_PARSE_ERROR;
  3203. }
  3204. }
  3205. if (p_functions.has(name)) {
  3206. //if one of the core functions, make sure they are of the correct form
  3207. if (func_node->arguments.size() > 0) {
  3208. _set_error("Function '" + String(name) + "' expects no arguments.");
  3209. return ERR_PARSE_ERROR;
  3210. }
  3211. if (func_node->return_type != TYPE_VOID) {
  3212. _set_error("Function '" + String(name) + "' must be of void return type.");
  3213. return ERR_PARSE_ERROR;
  3214. }
  3215. }
  3216. //all good let's parse inside the function!
  3217. tk = _get_token();
  3218. if (tk.type != TK_CURLY_BRACKET_OPEN) {
  3219. _set_error("Expected '{' to begin function");
  3220. return ERR_PARSE_ERROR;
  3221. }
  3222. current_function = name;
  3223. Error err = _parse_block(func_node->body, builtin_types);
  3224. if (err)
  3225. return err;
  3226. current_function = StringName();
  3227. }
  3228. }
  3229. tk = _get_token();
  3230. }
  3231. return OK;
  3232. }
  3233. String ShaderLanguage::get_shader_type(const String &p_code) {
  3234. bool reading_type = false;
  3235. String cur_identifier;
  3236. for (int i = 0; i < p_code.length(); i++) {
  3237. if (p_code[i] == ';') {
  3238. break;
  3239. } else if (p_code[i] <= 32) {
  3240. if (cur_identifier != String()) {
  3241. if (!reading_type) {
  3242. if (cur_identifier != "shader_type") {
  3243. return String();
  3244. }
  3245. reading_type = true;
  3246. cur_identifier = String();
  3247. } else {
  3248. return cur_identifier;
  3249. }
  3250. }
  3251. } else {
  3252. cur_identifier += String::chr(p_code[i]);
  3253. }
  3254. }
  3255. if (reading_type)
  3256. return cur_identifier;
  3257. return String();
  3258. }
  3259. Error ShaderLanguage::compile(const String &p_code, const Map<StringName, FunctionInfo> &p_functions, const Set<String> &p_render_modes, const Set<String> &p_shader_types) {
  3260. clear();
  3261. code = p_code;
  3262. nodes = NULL;
  3263. shader = alloc_node<ShaderNode>();
  3264. Error err = _parse_shader(p_functions, p_render_modes, p_shader_types);
  3265. if (err != OK) {
  3266. return err;
  3267. }
  3268. return OK;
  3269. }
  3270. Error ShaderLanguage::complete(const String &p_code, const Map<StringName, FunctionInfo> &p_functions, const Set<String> &p_render_modes, const Set<String> &p_shader_types, List<String> *r_options, String &r_call_hint) {
  3271. clear();
  3272. code = p_code;
  3273. nodes = NULL;
  3274. shader = alloc_node<ShaderNode>();
  3275. Error err = _parse_shader(p_functions, p_render_modes, p_shader_types);
  3276. if (err != OK)
  3277. ERR_PRINT("Failed to parse shader");
  3278. switch (completion_type) {
  3279. case COMPLETION_NONE: {
  3280. //do none
  3281. return ERR_PARSE_ERROR;
  3282. } break;
  3283. case COMPLETION_RENDER_MODE: {
  3284. for (const Set<String>::Element *E = p_render_modes.front(); E; E = E->next()) {
  3285. r_options->push_back(E->get());
  3286. }
  3287. return OK;
  3288. } break;
  3289. case COMPLETION_MAIN_FUNCTION: {
  3290. for (const Map<StringName, FunctionInfo>::Element *E = p_functions.front(); E; E = E->next()) {
  3291. r_options->push_back(E->key());
  3292. }
  3293. return OK;
  3294. } break;
  3295. case COMPLETION_IDENTIFIER:
  3296. case COMPLETION_FUNCTION_CALL: {
  3297. bool comp_ident = completion_type == COMPLETION_IDENTIFIER;
  3298. Set<String> matches;
  3299. StringName skip_function;
  3300. BlockNode *block = completion_block;
  3301. while (block) {
  3302. if (comp_ident) {
  3303. for (const Map<StringName, BlockNode::Variable>::Element *E = block->variables.front(); E; E = E->next()) {
  3304. if (E->get().line < completion_line) {
  3305. matches.insert(E->key());
  3306. }
  3307. }
  3308. }
  3309. if (block->parent_function) {
  3310. if (comp_ident) {
  3311. for (int i = 0; i < block->parent_function->arguments.size(); i++) {
  3312. matches.insert(block->parent_function->arguments[i].name);
  3313. }
  3314. }
  3315. skip_function = block->parent_function->name;
  3316. }
  3317. block = block->parent_block;
  3318. }
  3319. if (comp_ident && skip_function != StringName() && p_functions.has(skip_function)) {
  3320. for (Map<StringName, DataType>::Element *E = p_functions[skip_function].built_ins.front(); E; E = E->next()) {
  3321. matches.insert(E->key());
  3322. }
  3323. }
  3324. if (comp_ident) {
  3325. for (const Map<StringName, ShaderNode::Varying>::Element *E = shader->varyings.front(); E; E = E->next()) {
  3326. matches.insert(E->key());
  3327. }
  3328. for (const Map<StringName, ShaderNode::Uniform>::Element *E = shader->uniforms.front(); E; E = E->next()) {
  3329. matches.insert(E->key());
  3330. }
  3331. }
  3332. for (int i = 0; i < shader->functions.size(); i++) {
  3333. if (!shader->functions[i].callable || shader->functions[i].name == skip_function)
  3334. continue;
  3335. matches.insert(String(shader->functions[i].name) + "(");
  3336. }
  3337. int idx = 0;
  3338. while (builtin_func_defs[idx].name) {
  3339. matches.insert(String(builtin_func_defs[idx].name) + "(");
  3340. idx++;
  3341. }
  3342. for (Set<String>::Element *E = matches.front(); E; E = E->next()) {
  3343. r_options->push_back(E->get());
  3344. }
  3345. return OK;
  3346. } break;
  3347. case COMPLETION_CALL_ARGUMENTS: {
  3348. for (int i = 0; i < shader->functions.size(); i++) {
  3349. if (!shader->functions[i].callable)
  3350. continue;
  3351. if (shader->functions[i].name == completion_function) {
  3352. String calltip;
  3353. calltip += get_datatype_name(shader->functions[i].function->return_type);
  3354. calltip += " ";
  3355. calltip += shader->functions[i].name;
  3356. calltip += "(";
  3357. for (int j = 0; j < shader->functions[i].function->arguments.size(); j++) {
  3358. if (j > 0)
  3359. calltip += ", ";
  3360. else
  3361. calltip += " ";
  3362. if (j == completion_argument) {
  3363. calltip += CharType(0xFFFF);
  3364. }
  3365. calltip += get_datatype_name(shader->functions[i].function->arguments[j].type);
  3366. calltip += " ";
  3367. calltip += shader->functions[i].function->arguments[j].name;
  3368. if (j == completion_argument) {
  3369. calltip += CharType(0xFFFF);
  3370. }
  3371. }
  3372. if (shader->functions[i].function->arguments.size())
  3373. calltip += " ";
  3374. calltip += ")";
  3375. r_call_hint = calltip;
  3376. return OK;
  3377. }
  3378. }
  3379. int idx = 0;
  3380. String calltip;
  3381. while (builtin_func_defs[idx].name) {
  3382. if (completion_function == builtin_func_defs[idx].name) {
  3383. if (calltip.length())
  3384. calltip += "\n";
  3385. calltip += get_datatype_name(builtin_func_defs[idx].rettype);
  3386. calltip += " ";
  3387. calltip += builtin_func_defs[idx].name;
  3388. calltip += "(";
  3389. bool found_arg = false;
  3390. for (int i = 0; i < 4; i++) {
  3391. if (builtin_func_defs[idx].args[i] == TYPE_VOID)
  3392. break;
  3393. if (i > 0)
  3394. calltip += ", ";
  3395. else
  3396. calltip += " ";
  3397. if (i == completion_argument) {
  3398. calltip += CharType(0xFFFF);
  3399. }
  3400. calltip += get_datatype_name(builtin_func_defs[idx].args[i]);
  3401. if (i == completion_argument) {
  3402. calltip += CharType(0xFFFF);
  3403. }
  3404. found_arg = true;
  3405. }
  3406. if (found_arg)
  3407. calltip += " ";
  3408. calltip += ")";
  3409. }
  3410. idx++;
  3411. }
  3412. r_call_hint = calltip;
  3413. return OK;
  3414. } break;
  3415. case COMPLETION_INDEX: {
  3416. const char colv[4] = { 'r', 'g', 'b', 'a' };
  3417. const char coordv[4] = { 'x', 'y', 'z', 'w' };
  3418. int limit = 0;
  3419. switch (completion_base) {
  3420. case TYPE_BVEC2:
  3421. case TYPE_IVEC2:
  3422. case TYPE_UVEC2:
  3423. case TYPE_VEC2: {
  3424. limit = 2;
  3425. } break;
  3426. case TYPE_BVEC3:
  3427. case TYPE_IVEC3:
  3428. case TYPE_UVEC3:
  3429. case TYPE_VEC3: {
  3430. limit = 3;
  3431. } break;
  3432. case TYPE_BVEC4:
  3433. case TYPE_IVEC4:
  3434. case TYPE_UVEC4:
  3435. case TYPE_VEC4: {
  3436. limit = 4;
  3437. } break;
  3438. case TYPE_MAT2: limit = 2; break;
  3439. case TYPE_MAT3: limit = 3; break;
  3440. case TYPE_MAT4: limit = 4; break;
  3441. default: {}
  3442. }
  3443. for (int i = 0; i < limit; i++) {
  3444. r_options->push_back(String::chr(colv[i]));
  3445. r_options->push_back(String::chr(coordv[i]));
  3446. }
  3447. } break;
  3448. }
  3449. return ERR_PARSE_ERROR;
  3450. }
  3451. String ShaderLanguage::get_error_text() {
  3452. return error_str;
  3453. }
  3454. int ShaderLanguage::get_error_line() {
  3455. return error_line;
  3456. }
  3457. ShaderLanguage::ShaderNode *ShaderLanguage::get_shader() {
  3458. return shader;
  3459. }
  3460. ShaderLanguage::ShaderLanguage() {
  3461. nodes = NULL;
  3462. }
  3463. ShaderLanguage::~ShaderLanguage() {
  3464. clear();
  3465. }