material.cpp 150 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845184618471848184918501851185218531854185518561857185818591860186118621863186418651866186718681869187018711872187318741875187618771878187918801881188218831884188518861887188818891890189118921893189418951896189718981899190019011902190319041905190619071908190919101911191219131914191519161917191819191920192119221923192419251926192719281929193019311932193319341935193619371938193919401941194219431944194519461947194819491950195119521953195419551956195719581959196019611962196319641965196619671968196919701971197219731974197519761977197819791980198119821983198419851986198719881989199019911992199319941995199619971998199920002001200220032004200520062007200820092010201120122013201420152016201720182019202020212022202320242025202620272028202920302031203220332034203520362037203820392040204120422043204420452046204720482049205020512052205320542055205620572058205920602061206220632064206520662067206820692070207120722073207420752076207720782079208020812082208320842085208620872088208920902091209220932094209520962097209820992100210121022103210421052106210721082109211021112112211321142115211621172118211921202121212221232124212521262127212821292130213121322133213421352136213721382139214021412142214321442145214621472148214921502151215221532154215521562157215821592160216121622163216421652166216721682169217021712172217321742175217621772178217921802181218221832184218521862187218821892190219121922193219421952196219721982199220022012202220322042205220622072208220922102211221222132214221522162217221822192220222122222223222422252226222722282229223022312232223322342235223622372238223922402241224222432244224522462247224822492250225122522253225422552256225722582259226022612262226322642265226622672268226922702271227222732274227522762277227822792280228122822283228422852286228722882289229022912292229322942295229622972298229923002301230223032304230523062307230823092310231123122313231423152316231723182319232023212322232323242325232623272328232923302331233223332334233523362337233823392340234123422343234423452346234723482349235023512352235323542355235623572358235923602361236223632364236523662367236823692370237123722373237423752376237723782379238023812382238323842385238623872388238923902391239223932394239523962397239823992400240124022403240424052406240724082409241024112412241324142415241624172418241924202421242224232424242524262427242824292430243124322433243424352436243724382439244024412442244324442445244624472448244924502451245224532454245524562457245824592460246124622463246424652466246724682469247024712472247324742475247624772478247924802481248224832484248524862487248824892490249124922493249424952496249724982499250025012502250325042505250625072508250925102511251225132514251525162517251825192520252125222523252425252526252725282529253025312532253325342535253625372538253925402541254225432544254525462547254825492550255125522553255425552556255725582559256025612562256325642565256625672568256925702571257225732574257525762577257825792580258125822583258425852586258725882589259025912592259325942595259625972598259926002601260226032604260526062607260826092610261126122613261426152616261726182619262026212622262326242625262626272628262926302631263226332634263526362637263826392640264126422643264426452646264726482649265026512652265326542655265626572658265926602661266226632664266526662667266826692670267126722673267426752676267726782679268026812682268326842685268626872688268926902691269226932694269526962697269826992700270127022703270427052706270727082709271027112712271327142715271627172718271927202721272227232724272527262727272827292730273127322733273427352736273727382739274027412742274327442745274627472748274927502751275227532754275527562757275827592760276127622763276427652766276727682769277027712772277327742775277627772778277927802781278227832784278527862787278827892790279127922793279427952796279727982799280028012802280328042805280628072808280928102811281228132814281528162817281828192820282128222823282428252826282728282829283028312832283328342835283628372838283928402841284228432844284528462847284828492850285128522853285428552856285728582859286028612862286328642865286628672868286928702871287228732874287528762877287828792880288128822883288428852886288728882889289028912892289328942895289628972898289929002901290229032904290529062907290829092910291129122913291429152916291729182919292029212922292329242925292629272928292929302931293229332934293529362937293829392940294129422943294429452946294729482949295029512952295329542955295629572958295929602961296229632964296529662967296829692970297129722973297429752976297729782979298029812982298329842985298629872988298929902991299229932994299529962997299829993000300130023003300430053006300730083009301030113012301330143015301630173018301930203021302230233024302530263027302830293030303130323033303430353036303730383039304030413042304330443045304630473048304930503051305230533054305530563057305830593060306130623063306430653066306730683069307030713072307330743075307630773078307930803081308230833084308530863087308830893090309130923093309430953096309730983099310031013102310331043105310631073108310931103111311231133114311531163117311831193120312131223123312431253126312731283129313031313132313331343135313631373138313931403141314231433144314531463147314831493150315131523153315431553156315731583159316031613162316331643165316631673168316931703171317231733174317531763177317831793180318131823183318431853186318731883189319031913192319331943195319631973198319932003201320232033204320532063207320832093210321132123213321432153216321732183219322032213222322332243225322632273228322932303231323232333234323532363237323832393240324132423243324432453246324732483249325032513252325332543255325632573258325932603261326232633264326532663267326832693270327132723273327432753276327732783279328032813282328332843285328632873288328932903291329232933294329532963297329832993300330133023303330433053306330733083309331033113312331333143315331633173318331933203321332233233324332533263327332833293330333133323333333433353336333733383339334033413342334333443345334633473348334933503351335233533354335533563357335833593360336133623363336433653366336733683369337033713372337333743375337633773378337933803381338233833384338533863387338833893390339133923393339433953396339733983399340034013402340334043405340634073408340934103411341234133414341534163417341834193420342134223423342434253426342734283429343034313432343334343435343634373438343934403441344234433444344534463447344834493450345134523453345434553456345734583459346034613462346334643465346634673468346934703471347234733474347534763477347834793480348134823483348434853486348734883489349034913492349334943495349634973498349935003501350235033504350535063507350835093510351135123513351435153516351735183519352035213522352335243525352635273528352935303531353235333534353535363537353835393540354135423543354435453546354735483549355035513552355335543555355635573558355935603561356235633564356535663567356835693570357135723573357435753576357735783579358035813582358335843585358635873588358935903591359235933594359535963597359835993600360136023603360436053606360736083609361036113612361336143615361636173618361936203621362236233624362536263627362836293630363136323633363436353636363736383639364036413642364336443645364636473648364936503651365236533654365536563657365836593660366136623663366436653666366736683669367036713672367336743675367636773678367936803681368236833684368536863687368836893690369136923693369436953696369736983699370037013702370337043705370637073708370937103711371237133714371537163717371837193720372137223723372437253726372737283729373037313732373337343735373637373738373937403741374237433744374537463747374837493750375137523753375437553756375737583759376037613762376337643765376637673768376937703771377237733774377537763777377837793780378137823783378437853786378737883789379037913792379337943795379637973798379938003801380238033804380538063807380838093810381138123813381438153816381738183819382038213822382338243825382638273828382938303831383238333834383538363837383838393840384138423843384438453846384738483849385038513852385338543855385638573858385938603861386238633864386538663867386838693870387138723873387438753876387738783879388038813882388338843885388638873888388938903891389238933894389538963897389838993900390139023903390439053906390739083909391039113912391339143915391639173918391939203921392239233924392539263927392839293930393139323933393439353936393739383939394039413942394339443945394639473948394939503951395239533954395539563957395839593960396139623963396439653966396739683969397039713972397339743975397639773978397939803981398239833984398539863987398839893990399139923993399439953996399739983999400040014002400340044005400640074008400940104011401240134014401540164017401840194020402140224023402440254026402740284029403040314032403340344035403640374038403940404041404240434044404540464047404840494050405140524053405440554056405740584059406040614062406340644065406640674068406940704071407240734074407540764077407840794080408140824083408440854086408740884089409040914092409340944095409640974098409941004101410241034104410541064107410841094110
  1. /**************************************************************************/
  2. /* material.cpp */
  3. /**************************************************************************/
  4. /* This file is part of: */
  5. /* GODOT ENGINE */
  6. /* https://godotengine.org */
  7. /**************************************************************************/
  8. /* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
  9. /* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */
  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 "material.h"
  31. #include "core/config/engine.h"
  32. #include "core/config/project_settings.h"
  33. #include "core/error/error_macros.h"
  34. #include "core/version.h"
  35. #include "scene/main/scene_tree.h"
  36. void Material::set_next_pass(const Ref<Material> &p_pass) {
  37. for (Ref<Material> pass_child = p_pass; pass_child.is_valid(); pass_child = pass_child->get_next_pass()) {
  38. ERR_FAIL_COND_MSG(pass_child == this, "Can't set as next_pass one of its parents to prevent crashes due to recursive loop.");
  39. }
  40. if (next_pass == p_pass) {
  41. return;
  42. }
  43. next_pass = p_pass;
  44. if (material.is_valid()) {
  45. RID next_pass_rid;
  46. if (next_pass.is_valid()) {
  47. next_pass_rid = next_pass->get_rid();
  48. }
  49. RS::get_singleton()->material_set_next_pass(material, next_pass_rid);
  50. }
  51. }
  52. Ref<Material> Material::get_next_pass() const {
  53. return next_pass;
  54. }
  55. void Material::set_render_priority(int p_priority) {
  56. ERR_FAIL_COND(p_priority < RENDER_PRIORITY_MIN);
  57. ERR_FAIL_COND(p_priority > RENDER_PRIORITY_MAX);
  58. render_priority = p_priority;
  59. if (material.is_valid()) {
  60. RS::get_singleton()->material_set_render_priority(material, p_priority);
  61. }
  62. }
  63. int Material::get_render_priority() const {
  64. return render_priority;
  65. }
  66. RID Material::get_rid() const {
  67. return material;
  68. }
  69. void Material::_validate_property(PropertyInfo &p_property) const {
  70. if (!_can_do_next_pass() && p_property.name == "next_pass") {
  71. p_property.usage = PROPERTY_USAGE_NONE;
  72. }
  73. if (!_can_use_render_priority() && p_property.name == "render_priority") {
  74. p_property.usage = PROPERTY_USAGE_NONE;
  75. }
  76. }
  77. void Material::_mark_ready() {
  78. init_state = INIT_STATE_READY;
  79. }
  80. void Material::_mark_initialized(const Callable &p_add_to_dirty_list, const Callable &p_update_shader) {
  81. // If this is happening as part of resource loading, it is not safe to queue the update
  82. // as an addition to the dirty list. It would be if the load is happening on the main thread,
  83. // but even so we'd rather perform the update directly instead of using the dirty list.
  84. if (ResourceLoader::is_within_load()) {
  85. DEV_ASSERT(init_state != INIT_STATE_READY);
  86. if (init_state == INIT_STATE_UNINITIALIZED) { // Prevent queueing twice.
  87. if (p_update_shader.is_valid()) {
  88. init_state = INIT_STATE_INITIALIZING;
  89. callable_mp(this, &Material::_mark_ready).call_deferred();
  90. p_update_shader.call_deferred();
  91. } else {
  92. init_state = INIT_STATE_READY;
  93. }
  94. }
  95. } else {
  96. // Straightforward conditions.
  97. init_state = INIT_STATE_READY;
  98. p_add_to_dirty_list.call();
  99. }
  100. }
  101. void Material::inspect_native_shader_code() {
  102. SceneTree *st = Object::cast_to<SceneTree>(OS::get_singleton()->get_main_loop());
  103. RID shader = get_shader_rid();
  104. if (st && shader.is_valid()) {
  105. st->call_group_flags(SceneTree::GROUP_CALL_DEFERRED, "_native_shader_source_visualizer", "_inspect_shader", shader);
  106. }
  107. }
  108. RID Material::get_shader_rid() const {
  109. RID ret;
  110. GDVIRTUAL_CALL(_get_shader_rid, ret);
  111. return ret;
  112. }
  113. Shader::Mode Material::get_shader_mode() const {
  114. Shader::Mode ret = Shader::MODE_MAX;
  115. GDVIRTUAL_CALL(_get_shader_mode, ret);
  116. return ret;
  117. }
  118. bool Material::_can_do_next_pass() const {
  119. bool ret = false;
  120. GDVIRTUAL_CALL(_can_do_next_pass, ret);
  121. return ret;
  122. }
  123. bool Material::_can_use_render_priority() const {
  124. bool ret = false;
  125. GDVIRTUAL_CALL(_can_use_render_priority, ret);
  126. return ret;
  127. }
  128. Ref<Resource> Material::create_placeholder() const {
  129. Ref<PlaceholderMaterial> placeholder;
  130. placeholder.instantiate();
  131. return placeholder;
  132. }
  133. void Material::_bind_methods() {
  134. ClassDB::bind_method(D_METHOD("set_next_pass", "next_pass"), &Material::set_next_pass);
  135. ClassDB::bind_method(D_METHOD("get_next_pass"), &Material::get_next_pass);
  136. ClassDB::bind_method(D_METHOD("set_render_priority", "priority"), &Material::set_render_priority);
  137. ClassDB::bind_method(D_METHOD("get_render_priority"), &Material::get_render_priority);
  138. ClassDB::bind_method(D_METHOD("inspect_native_shader_code"), &Material::inspect_native_shader_code);
  139. ClassDB::set_method_flags(get_class_static(), StringName("inspect_native_shader_code"), METHOD_FLAGS_DEFAULT | METHOD_FLAG_EDITOR);
  140. ClassDB::bind_method(D_METHOD("create_placeholder"), &Material::create_placeholder);
  141. ADD_PROPERTY(PropertyInfo(Variant::INT, "render_priority", PROPERTY_HINT_RANGE, itos(RENDER_PRIORITY_MIN) + "," + itos(RENDER_PRIORITY_MAX) + ",1"), "set_render_priority", "get_render_priority");
  142. ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "next_pass", PROPERTY_HINT_RESOURCE_TYPE, "Material"), "set_next_pass", "get_next_pass");
  143. BIND_CONSTANT(RENDER_PRIORITY_MAX);
  144. BIND_CONSTANT(RENDER_PRIORITY_MIN);
  145. GDVIRTUAL_BIND(_get_shader_rid)
  146. GDVIRTUAL_BIND(_get_shader_mode)
  147. GDVIRTUAL_BIND(_can_do_next_pass)
  148. GDVIRTUAL_BIND(_can_use_render_priority)
  149. }
  150. Material::Material() {
  151. render_priority = 0;
  152. }
  153. Material::~Material() {
  154. if (material.is_valid()) {
  155. ERR_FAIL_NULL(RenderingServer::get_singleton());
  156. RenderingServer::get_singleton()->free(material);
  157. }
  158. }
  159. ///////////////////////////////////
  160. bool ShaderMaterial::_set(const StringName &p_name, const Variant &p_value) {
  161. if (shader.is_valid()) {
  162. const StringName *sn = remap_cache.getptr(p_name);
  163. if (sn) {
  164. set_shader_parameter(*sn, p_value);
  165. return true;
  166. }
  167. String s = p_name;
  168. if (s.begins_with("shader_parameter/")) {
  169. String param = s.replace_first("shader_parameter/", "");
  170. remap_cache[s] = param;
  171. set_shader_parameter(param, p_value);
  172. return true;
  173. }
  174. #ifndef DISABLE_DEPRECATED
  175. // Compatibility remaps are only needed here.
  176. if (s.begins_with("param/")) {
  177. s = s.replace_first("param/", "shader_parameter/");
  178. } else if (s.begins_with("shader_param/")) {
  179. s = s.replace_first("shader_param/", "shader_parameter/");
  180. } else if (s.begins_with("shader_uniform/")) {
  181. s = s.replace_first("shader_uniform/", "shader_parameter/");
  182. } else {
  183. return false; // Not a shader parameter.
  184. }
  185. WARN_PRINT("This material (containing shader with path: '" + shader->get_path() + "') uses an old deprecated parameter names. Consider re-saving this resource (or scene which contains it) in order for it to continue working in future versions.");
  186. String param = s.replace_first("shader_parameter/", "");
  187. remap_cache[s] = param;
  188. set_shader_parameter(param, p_value);
  189. return true;
  190. #endif
  191. }
  192. return false;
  193. }
  194. bool ShaderMaterial::_get(const StringName &p_name, Variant &r_ret) const {
  195. if (shader.is_valid()) {
  196. const StringName *sn = remap_cache.getptr(p_name);
  197. if (sn) {
  198. // Only return a parameter if it was previously set.
  199. r_ret = get_shader_parameter(*sn);
  200. return true;
  201. }
  202. }
  203. return false;
  204. }
  205. void ShaderMaterial::_get_property_list(List<PropertyInfo> *p_list) const {
  206. if (shader.is_valid()) {
  207. List<PropertyInfo> list;
  208. shader->get_shader_uniform_list(&list, true);
  209. HashMap<String, HashMap<String, List<PropertyInfo>>> groups;
  210. LocalVector<Pair<String, LocalVector<String>>> vgroups;
  211. {
  212. HashMap<String, List<PropertyInfo>> none_subgroup;
  213. none_subgroup.insert("<None>", List<PropertyInfo>());
  214. groups.insert("<None>", none_subgroup);
  215. }
  216. String last_group = "<None>";
  217. String last_subgroup = "<None>";
  218. bool is_none_group_undefined = true;
  219. bool is_none_group = true;
  220. for (const PropertyInfo &pi : list) {
  221. if (pi.usage == PROPERTY_USAGE_GROUP) {
  222. if (!pi.name.is_empty()) {
  223. Vector<String> vgroup = pi.name.split("::");
  224. last_group = vgroup[0];
  225. if (vgroup.size() > 1) {
  226. last_subgroup = vgroup[1];
  227. } else {
  228. last_subgroup = "<None>";
  229. }
  230. is_none_group = false;
  231. if (!groups.has(last_group)) {
  232. PropertyInfo info;
  233. info.usage = PROPERTY_USAGE_GROUP;
  234. info.name = last_group.capitalize();
  235. info.hint_string = "shader_parameter/";
  236. List<PropertyInfo> none_subgroup;
  237. none_subgroup.push_back(info);
  238. HashMap<String, List<PropertyInfo>> subgroup_map;
  239. subgroup_map.insert("<None>", none_subgroup);
  240. groups.insert(last_group, subgroup_map);
  241. vgroups.push_back(Pair<String, LocalVector<String>>(last_group, { "<None>" }));
  242. }
  243. if (!groups[last_group].has(last_subgroup)) {
  244. PropertyInfo info;
  245. info.usage = PROPERTY_USAGE_SUBGROUP;
  246. info.name = last_subgroup.capitalize();
  247. info.hint_string = "shader_parameter/";
  248. List<PropertyInfo> subgroup;
  249. subgroup.push_back(info);
  250. groups[last_group].insert(last_subgroup, subgroup);
  251. for (Pair<String, LocalVector<String>> &group : vgroups) {
  252. if (group.first == last_group) {
  253. group.second.push_back(last_subgroup);
  254. break;
  255. }
  256. }
  257. }
  258. } else {
  259. last_group = "<None>";
  260. last_subgroup = "<None>";
  261. is_none_group = true;
  262. }
  263. continue; // Pass group.
  264. }
  265. if (is_none_group_undefined && is_none_group) {
  266. is_none_group_undefined = false;
  267. PropertyInfo info;
  268. info.usage = PROPERTY_USAGE_GROUP;
  269. info.name = "Shader Parameters";
  270. info.hint_string = "shader_parameter/";
  271. groups["<None>"]["<None>"].push_back(info);
  272. vgroups.push_back(Pair<String, LocalVector<String>>("<None>", { "<None>" }));
  273. }
  274. const bool is_uniform_cached = param_cache.has(pi.name);
  275. bool is_uniform_type_compatible = true;
  276. if (is_uniform_cached) {
  277. // Check if the uniform Variant type changed, for example vec3 to vec4.
  278. const Variant &cached = param_cache.get(pi.name);
  279. if (cached.is_array()) {
  280. // Allow some array conversions for backwards compatibility.
  281. is_uniform_type_compatible = Variant::can_convert(pi.type, cached.get_type());
  282. } else {
  283. is_uniform_type_compatible = pi.type == cached.get_type();
  284. }
  285. #ifndef DISABLE_DEPRECATED
  286. // PackedFloat32Array -> PackedVector4Array conversion.
  287. if (!is_uniform_type_compatible && pi.type == Variant::PACKED_VECTOR4_ARRAY && cached.get_type() == Variant::PACKED_FLOAT32_ARRAY) {
  288. PackedVector4Array varray;
  289. PackedFloat32Array array = (PackedFloat32Array)cached;
  290. for (int i = 0; i + 3 < array.size(); i += 4) {
  291. varray.push_back(Vector4(array[i], array[i + 1], array[i + 2], array[i + 3]));
  292. }
  293. param_cache.insert(pi.name, varray);
  294. is_uniform_type_compatible = true;
  295. }
  296. #endif
  297. if (is_uniform_type_compatible && pi.type == Variant::OBJECT && cached.get_type() == Variant::OBJECT) {
  298. // Check if the Object class (hint string) changed, for example Texture2D sampler to Texture3D.
  299. // Allow inheritance, Texture2D type sampler should also accept CompressedTexture2D.
  300. Object *cached_obj = cached;
  301. if (!cached_obj->is_class(pi.hint_string)) {
  302. is_uniform_type_compatible = false;
  303. }
  304. }
  305. }
  306. PropertyInfo info = pi;
  307. info.name = "shader_parameter/" + info.name;
  308. if (!is_uniform_cached || !is_uniform_type_compatible) {
  309. // Property has never been edited or its type changed, retrieve with default value.
  310. Variant default_value = RenderingServer::get_singleton()->shader_get_parameter_default(shader->get_rid(), pi.name);
  311. param_cache.insert(pi.name, default_value);
  312. remap_cache.insert(info.name, pi.name);
  313. }
  314. groups[last_group][last_subgroup].push_back(info);
  315. }
  316. for (const Pair<String, LocalVector<String>> &group_pair : vgroups) {
  317. String group = group_pair.first;
  318. for (const String &subgroup : group_pair.second) {
  319. List<PropertyInfo> &prop_infos = groups[group][subgroup];
  320. for (const PropertyInfo &item : prop_infos) {
  321. p_list->push_back(item);
  322. }
  323. }
  324. }
  325. }
  326. }
  327. bool ShaderMaterial::_property_can_revert(const StringName &p_name) const {
  328. if (shader.is_valid()) {
  329. if (remap_cache.has(p_name)) {
  330. return true;
  331. }
  332. const String sname = p_name;
  333. return sname == "render_priority" || sname == "next_pass";
  334. }
  335. return false;
  336. }
  337. bool ShaderMaterial::_property_get_revert(const StringName &p_name, Variant &r_property) const {
  338. if (shader.is_valid()) {
  339. const StringName *pr = remap_cache.getptr(p_name);
  340. if (pr) {
  341. r_property = RenderingServer::get_singleton()->shader_get_parameter_default(shader->get_rid(), *pr);
  342. return true;
  343. } else if (p_name == "render_priority") {
  344. r_property = 0;
  345. return true;
  346. } else if (p_name == "next_pass") {
  347. r_property = Variant();
  348. return true;
  349. }
  350. }
  351. return false;
  352. }
  353. void ShaderMaterial::set_shader(const Ref<Shader> &p_shader) {
  354. // Only connect/disconnect the signal when running in the editor.
  355. // This can be a slow operation, and `notify_property_list_changed()` (which is called by `_shader_changed()`)
  356. // does nothing in non-editor builds anyway. See GH-34741 for details.
  357. if (shader.is_valid() && Engine::get_singleton()->is_editor_hint()) {
  358. shader->disconnect_changed(callable_mp(this, &ShaderMaterial::_shader_changed));
  359. }
  360. shader = p_shader;
  361. RID rid;
  362. if (shader.is_valid()) {
  363. rid = shader->get_rid();
  364. if (Engine::get_singleton()->is_editor_hint()) {
  365. shader->connect_changed(callable_mp(this, &ShaderMaterial::_shader_changed));
  366. }
  367. }
  368. RID material_rid = _get_material();
  369. if (material_rid.is_valid()) {
  370. RS::get_singleton()->material_set_shader(material_rid, rid);
  371. }
  372. notify_property_list_changed(); //properties for shader exposed
  373. emit_changed();
  374. }
  375. Ref<Shader> ShaderMaterial::get_shader() const {
  376. return shader;
  377. }
  378. void ShaderMaterial::set_shader_parameter(const StringName &p_param, const Variant &p_value) {
  379. RID material_rid = _get_material();
  380. if (p_value.get_type() == Variant::NIL) {
  381. param_cache.erase(p_param);
  382. if (material_rid.is_valid()) {
  383. RS::get_singleton()->material_set_param(material_rid, p_param, Variant());
  384. }
  385. } else {
  386. Variant *v = param_cache.getptr(p_param);
  387. if (!v) {
  388. // Never assigned, also update the remap cache.
  389. remap_cache["shader_parameter/" + p_param.operator String()] = p_param;
  390. param_cache.insert(p_param, p_value);
  391. } else {
  392. *v = p_value;
  393. }
  394. if (p_value.get_type() == Variant::OBJECT) {
  395. RID tex_rid = p_value;
  396. if (tex_rid == RID()) {
  397. param_cache.erase(p_param);
  398. if (material_rid.is_valid()) {
  399. RS::get_singleton()->material_set_param(material_rid, p_param, Variant());
  400. }
  401. } else if (material_rid.is_valid()) {
  402. RS::get_singleton()->material_set_param(material_rid, p_param, tex_rid);
  403. }
  404. } else if (material_rid.is_valid()) {
  405. RS::get_singleton()->material_set_param(material_rid, p_param, p_value);
  406. }
  407. }
  408. }
  409. Variant ShaderMaterial::get_shader_parameter(const StringName &p_param) const {
  410. if (param_cache.has(p_param)) {
  411. return param_cache[p_param];
  412. } else {
  413. return Variant();
  414. }
  415. }
  416. void ShaderMaterial::_shader_changed() {
  417. notify_property_list_changed(); //update all properties
  418. }
  419. void ShaderMaterial::_check_material_rid() const {
  420. MutexLock lock(material_rid_mutex);
  421. if (_get_material().is_null()) {
  422. RID shader_rid = shader.is_valid() ? shader->get_rid() : RID();
  423. RID next_pass_rid;
  424. if (get_next_pass().is_valid()) {
  425. next_pass_rid = get_next_pass()->get_rid();
  426. }
  427. _set_material(RS::get_singleton()->material_create_from_shader(next_pass_rid, get_render_priority(), shader_rid));
  428. for (KeyValue<StringName, Variant> param : param_cache) {
  429. if (param.value.get_type() == Variant::OBJECT) {
  430. RID tex_rid = param.value;
  431. if (tex_rid.is_valid()) {
  432. RS::get_singleton()->material_set_param(_get_material(), param.key, tex_rid);
  433. } else {
  434. RS::get_singleton()->material_set_param(_get_material(), param.key, Variant());
  435. }
  436. } else {
  437. RS::get_singleton()->material_set_param(_get_material(), param.key, param.value);
  438. }
  439. }
  440. }
  441. }
  442. void ShaderMaterial::_bind_methods() {
  443. ClassDB::bind_method(D_METHOD("set_shader", "shader"), &ShaderMaterial::set_shader);
  444. ClassDB::bind_method(D_METHOD("get_shader"), &ShaderMaterial::get_shader);
  445. ClassDB::bind_method(D_METHOD("set_shader_parameter", "param", "value"), &ShaderMaterial::set_shader_parameter);
  446. ClassDB::bind_method(D_METHOD("get_shader_parameter", "param"), &ShaderMaterial::get_shader_parameter);
  447. ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "shader", PROPERTY_HINT_RESOURCE_TYPE, "Shader"), "set_shader", "get_shader");
  448. }
  449. #ifdef TOOLS_ENABLED
  450. void ShaderMaterial::get_argument_options(const StringName &p_function, int p_idx, List<String> *r_options) const {
  451. const String pf = p_function;
  452. if (p_idx == 0 && (pf == "get_shader_parameter" || pf == "set_shader_parameter")) {
  453. if (shader.is_valid()) {
  454. List<PropertyInfo> pl;
  455. shader->get_shader_uniform_list(&pl);
  456. for (const PropertyInfo &E : pl) {
  457. r_options->push_back(E.name.replace_first("shader_parameter/", "").quote());
  458. }
  459. }
  460. }
  461. Material::get_argument_options(p_function, p_idx, r_options);
  462. }
  463. #endif
  464. bool ShaderMaterial::_can_do_next_pass() const {
  465. return shader.is_valid() && shader->get_mode() == Shader::MODE_SPATIAL;
  466. }
  467. bool ShaderMaterial::_can_use_render_priority() const {
  468. return shader.is_valid() && shader->get_mode() == Shader::MODE_SPATIAL;
  469. }
  470. Shader::Mode ShaderMaterial::get_shader_mode() const {
  471. if (shader.is_valid()) {
  472. return shader->get_mode();
  473. } else {
  474. return Shader::MODE_SPATIAL;
  475. }
  476. }
  477. RID ShaderMaterial::get_rid() const {
  478. _check_material_rid();
  479. return Material::get_rid();
  480. }
  481. RID ShaderMaterial::get_shader_rid() const {
  482. if (shader.is_valid()) {
  483. return shader->get_rid();
  484. } else {
  485. return RID();
  486. }
  487. }
  488. ShaderMaterial::ShaderMaterial() {
  489. // Material RID will be empty until it is required.
  490. }
  491. ShaderMaterial::~ShaderMaterial() {
  492. }
  493. /////////////////////////////////
  494. HashMap<BaseMaterial3D::MaterialKey, BaseMaterial3D::ShaderData, BaseMaterial3D::MaterialKey> BaseMaterial3D::shader_map;
  495. Mutex BaseMaterial3D::shader_map_mutex;
  496. BaseMaterial3D::ShaderNames *BaseMaterial3D::shader_names = nullptr;
  497. Mutex BaseMaterial3D::material_mutex;
  498. SelfList<BaseMaterial3D>::List BaseMaterial3D::dirty_materials;
  499. void BaseMaterial3D::init_shaders() {
  500. shader_names = memnew(ShaderNames);
  501. shader_names->albedo = "albedo";
  502. shader_names->specular = "specular";
  503. shader_names->roughness = "roughness";
  504. shader_names->metallic = "metallic";
  505. shader_names->emission = "emission";
  506. shader_names->emission_energy = "emission_energy";
  507. shader_names->normal_scale = "normal_scale";
  508. shader_names->rim = "rim";
  509. shader_names->rim_tint = "rim_tint";
  510. shader_names->clearcoat = "clearcoat";
  511. shader_names->clearcoat_roughness = "clearcoat_roughness";
  512. shader_names->anisotropy = "anisotropy_ratio";
  513. shader_names->heightmap_scale = "heightmap_scale";
  514. shader_names->subsurface_scattering_strength = "subsurface_scattering_strength";
  515. shader_names->backlight = "backlight";
  516. shader_names->refraction = "refraction";
  517. shader_names->point_size = "point_size";
  518. shader_names->uv1_scale = "uv1_scale";
  519. shader_names->uv1_offset = "uv1_offset";
  520. shader_names->uv2_scale = "uv2_scale";
  521. shader_names->uv2_offset = "uv2_offset";
  522. shader_names->uv1_blend_sharpness = "uv1_blend_sharpness";
  523. shader_names->uv2_blend_sharpness = "uv2_blend_sharpness";
  524. shader_names->particles_anim_h_frames = "particles_anim_h_frames";
  525. shader_names->particles_anim_v_frames = "particles_anim_v_frames";
  526. shader_names->particles_anim_loop = "particles_anim_loop";
  527. shader_names->heightmap_min_layers = "heightmap_min_layers";
  528. shader_names->heightmap_max_layers = "heightmap_max_layers";
  529. shader_names->heightmap_flip = "heightmap_flip";
  530. shader_names->grow = "grow";
  531. shader_names->ao_light_affect = "ao_light_affect";
  532. shader_names->proximity_fade_distance = "proximity_fade_distance";
  533. shader_names->distance_fade_min = "distance_fade_min";
  534. shader_names->distance_fade_max = "distance_fade_max";
  535. shader_names->msdf_pixel_range = "msdf_pixel_range";
  536. shader_names->msdf_outline_size = "msdf_outline_size";
  537. shader_names->metallic_texture_channel = "metallic_texture_channel";
  538. shader_names->ao_texture_channel = "ao_texture_channel";
  539. shader_names->clearcoat_texture_channel = "clearcoat_texture_channel";
  540. shader_names->rim_texture_channel = "rim_texture_channel";
  541. shader_names->heightmap_texture_channel = "heightmap_texture_channel";
  542. shader_names->refraction_texture_channel = "refraction_texture_channel";
  543. shader_names->transmittance_color = "transmittance_color";
  544. shader_names->transmittance_depth = "transmittance_depth";
  545. shader_names->transmittance_boost = "transmittance_boost";
  546. shader_names->texture_names[TEXTURE_ALBEDO] = "texture_albedo";
  547. shader_names->texture_names[TEXTURE_METALLIC] = "texture_metallic";
  548. shader_names->texture_names[TEXTURE_ROUGHNESS] = "texture_roughness";
  549. shader_names->texture_names[TEXTURE_EMISSION] = "texture_emission";
  550. shader_names->texture_names[TEXTURE_NORMAL] = "texture_normal";
  551. shader_names->texture_names[TEXTURE_BENT_NORMAL] = "texture_bent_normal";
  552. shader_names->texture_names[TEXTURE_RIM] = "texture_rim";
  553. shader_names->texture_names[TEXTURE_CLEARCOAT] = "texture_clearcoat";
  554. shader_names->texture_names[TEXTURE_FLOWMAP] = "texture_flowmap";
  555. shader_names->texture_names[TEXTURE_AMBIENT_OCCLUSION] = "texture_ambient_occlusion";
  556. shader_names->texture_names[TEXTURE_HEIGHTMAP] = "texture_heightmap";
  557. shader_names->texture_names[TEXTURE_SUBSURFACE_SCATTERING] = "texture_subsurface_scattering";
  558. shader_names->texture_names[TEXTURE_SUBSURFACE_TRANSMITTANCE] = "texture_subsurface_transmittance";
  559. shader_names->texture_names[TEXTURE_BACKLIGHT] = "texture_backlight";
  560. shader_names->texture_names[TEXTURE_REFRACTION] = "texture_refraction";
  561. shader_names->texture_names[TEXTURE_DETAIL_MASK] = "texture_detail_mask";
  562. shader_names->texture_names[TEXTURE_DETAIL_ALBEDO] = "texture_detail_albedo";
  563. shader_names->texture_names[TEXTURE_DETAIL_NORMAL] = "texture_detail_normal";
  564. shader_names->texture_names[TEXTURE_ORM] = "texture_orm";
  565. shader_names->alpha_scissor_threshold = "alpha_scissor_threshold";
  566. shader_names->alpha_hash_scale = "alpha_hash_scale";
  567. shader_names->alpha_antialiasing_edge = "alpha_antialiasing_edge";
  568. shader_names->albedo_texture_size = "albedo_texture_size";
  569. shader_names->z_clip_scale = "z_clip_scale";
  570. shader_names->fov_override = "fov_override";
  571. }
  572. HashMap<uint64_t, Ref<StandardMaterial3D>> BaseMaterial3D::materials_for_2d;
  573. void BaseMaterial3D::finish_shaders() {
  574. materials_for_2d.clear();
  575. dirty_materials.clear();
  576. memdelete(shader_names);
  577. shader_names = nullptr;
  578. }
  579. void BaseMaterial3D::_update_shader() {
  580. if (!_is_initialized()) {
  581. _mark_ready();
  582. }
  583. MaterialKey mk = _compute_key();
  584. if (mk == current_key) {
  585. return; //no update required in the end
  586. }
  587. {
  588. MutexLock lock(shader_map_mutex);
  589. ShaderData *v = shader_map.getptr(current_key);
  590. if (v) {
  591. v->users--;
  592. if (v->users == 0) {
  593. // Deallocate shader which is no longer in use.
  594. shader_rid = RID();
  595. RS::get_singleton()->free(v->shader);
  596. shader_map.erase(current_key);
  597. }
  598. }
  599. current_key = mk;
  600. v = shader_map.getptr(mk);
  601. if (v) {
  602. shader_rid = v->shader;
  603. v->users++;
  604. if (_get_material().is_valid()) {
  605. RS::get_singleton()->material_set_shader(_get_material(), shader_rid);
  606. }
  607. return;
  608. }
  609. }
  610. // From this point, it is possible that multiple threads requesting the same key will
  611. // race to create the shader. The winner, which is the one found in shader_map, will be
  612. // used. The losers will free their shader.
  613. String texfilter_str;
  614. // Force linear filtering for the heightmap texture, as the heightmap effect
  615. // looks broken with nearest-neighbor filtering (with and without Deep Parallax).
  616. String texfilter_height_str;
  617. switch (texture_filter) {
  618. case TEXTURE_FILTER_NEAREST:
  619. texfilter_str = "filter_nearest";
  620. texfilter_height_str = "filter_linear";
  621. break;
  622. case TEXTURE_FILTER_LINEAR:
  623. texfilter_str = "filter_linear";
  624. texfilter_height_str = "filter_linear";
  625. break;
  626. case TEXTURE_FILTER_NEAREST_WITH_MIPMAPS:
  627. texfilter_str = "filter_nearest_mipmap";
  628. texfilter_height_str = "filter_linear_mipmap";
  629. break;
  630. case TEXTURE_FILTER_LINEAR_WITH_MIPMAPS:
  631. texfilter_str = "filter_linear_mipmap";
  632. texfilter_height_str = "filter_linear_mipmap";
  633. break;
  634. case TEXTURE_FILTER_NEAREST_WITH_MIPMAPS_ANISOTROPIC:
  635. texfilter_str = "filter_nearest_mipmap_anisotropic";
  636. texfilter_height_str = "filter_linear_mipmap_anisotropic";
  637. break;
  638. case TEXTURE_FILTER_LINEAR_WITH_MIPMAPS_ANISOTROPIC:
  639. texfilter_str = "filter_linear_mipmap_anisotropic";
  640. texfilter_height_str = "filter_linear_mipmap_anisotropic";
  641. break;
  642. case TEXTURE_FILTER_MAX:
  643. break; // Internal value, skip.
  644. }
  645. if (flags[FLAG_USE_TEXTURE_REPEAT]) {
  646. texfilter_str += ", repeat_enable";
  647. texfilter_height_str += ", repeat_enable";
  648. } else {
  649. texfilter_str += ", repeat_disable";
  650. texfilter_height_str += ", repeat_disable";
  651. }
  652. // Add a comment to describe the shader origin (useful when converting to ShaderMaterial).
  653. String code = vformat(
  654. "// NOTE: Shader automatically converted from " GODOT_VERSION_NAME " " GODOT_VERSION_FULL_CONFIG "'s %s.\n\n",
  655. orm ? "ORMMaterial3D" : "StandardMaterial3D");
  656. // Define shader type and render mode based on property values.
  657. code += "shader_type spatial;\nrender_mode ";
  658. switch (blend_mode) {
  659. case BLEND_MODE_MIX:
  660. code += "blend_mix";
  661. break;
  662. case BLEND_MODE_ADD:
  663. code += "blend_add";
  664. break;
  665. case BLEND_MODE_SUB:
  666. code += "blend_sub";
  667. break;
  668. case BLEND_MODE_MUL:
  669. code += "blend_mul";
  670. break;
  671. case BLEND_MODE_PREMULT_ALPHA:
  672. code += "blend_premul_alpha";
  673. break;
  674. case BLEND_MODE_MAX:
  675. break; // Internal value, skip.
  676. }
  677. DepthDrawMode ddm = depth_draw_mode;
  678. if (features[FEATURE_REFRACTION]) {
  679. ddm = DEPTH_DRAW_ALWAYS;
  680. }
  681. switch (ddm) {
  682. case DEPTH_DRAW_OPAQUE_ONLY:
  683. code += ", depth_draw_opaque";
  684. break;
  685. case DEPTH_DRAW_ALWAYS:
  686. code += ", depth_draw_always";
  687. break;
  688. case DEPTH_DRAW_DISABLED:
  689. code += ", depth_draw_never";
  690. break;
  691. case DEPTH_DRAW_MAX:
  692. break; // Internal value, skip.
  693. }
  694. switch (cull_mode) {
  695. case CULL_BACK:
  696. code += ", cull_back";
  697. break;
  698. case CULL_FRONT:
  699. code += ", cull_front";
  700. break;
  701. case CULL_DISABLED:
  702. code += ", cull_disabled";
  703. break;
  704. case CULL_MAX:
  705. break; // Internal value, skip.
  706. }
  707. switch (diffuse_mode) {
  708. case DIFFUSE_BURLEY:
  709. code += ", diffuse_burley";
  710. break;
  711. case DIFFUSE_LAMBERT:
  712. code += ", diffuse_lambert";
  713. break;
  714. case DIFFUSE_LAMBERT_WRAP:
  715. code += ", diffuse_lambert_wrap";
  716. break;
  717. case DIFFUSE_TOON:
  718. code += ", diffuse_toon";
  719. break;
  720. case DIFFUSE_MAX:
  721. break; // Internal value, skip.
  722. }
  723. switch (specular_mode) {
  724. case SPECULAR_SCHLICK_GGX:
  725. code += ", specular_schlick_ggx";
  726. break;
  727. case SPECULAR_TOON:
  728. code += ", specular_toon";
  729. break;
  730. case SPECULAR_DISABLED:
  731. code += ", specular_disabled";
  732. break;
  733. case SPECULAR_MAX:
  734. break; // Internal value, skip.
  735. }
  736. if (features[FEATURE_SUBSURFACE_SCATTERING] && flags[FLAG_SUBSURFACE_MODE_SKIN]) {
  737. code += ", sss_mode_skin";
  738. }
  739. if (shading_mode == SHADING_MODE_UNSHADED) {
  740. code += ", unshaded";
  741. }
  742. if (flags[FLAG_DISABLE_DEPTH_TEST]) {
  743. code += ", depth_test_disabled";
  744. } else {
  745. switch (depth_test) {
  746. case DEPTH_TEST_DEFAULT:
  747. // depth_test_default is the default behavior, no need to emit it here.
  748. break;
  749. case DEPTH_TEST_INVERTED:
  750. code += ", depth_test_inverted";
  751. break;
  752. case DEPTH_TEST_MAX:
  753. break; // Internal value, skip.
  754. }
  755. }
  756. if (flags[FLAG_PARTICLE_TRAILS_MODE]) {
  757. code += ", particle_trails";
  758. }
  759. if (shading_mode == SHADING_MODE_PER_VERTEX) {
  760. code += ", vertex_lighting";
  761. }
  762. if (flags[FLAG_DONT_RECEIVE_SHADOWS]) {
  763. code += ", shadows_disabled";
  764. }
  765. if (flags[FLAG_DISABLE_AMBIENT_LIGHT]) {
  766. code += ", ambient_light_disabled";
  767. }
  768. if (flags[FLAG_USE_SHADOW_TO_OPACITY]) {
  769. code += ", shadow_to_opacity";
  770. }
  771. if (flags[FLAG_DISABLE_FOG]) {
  772. code += ", fog_disabled";
  773. }
  774. if (flags[FLAG_DISABLE_SPECULAR_OCCLUSION]) {
  775. code += ", specular_occlusion_disabled";
  776. }
  777. if (transparency == TRANSPARENCY_ALPHA_DEPTH_PRE_PASS) {
  778. code += ", depth_prepass_alpha";
  779. }
  780. // Although it's technically possible to do alpha antialiasing without using alpha hash or alpha scissor,
  781. // it is restricted in the base material because it has no use, and abusing it with regular Alpha blending can
  782. // saturate the MSAA mask.
  783. if (transparency == TRANSPARENCY_ALPHA_HASH || transparency == TRANSPARENCY_ALPHA_SCISSOR) {
  784. // Alpha antialiasing is only useful with ALPHA_HASH or ALPHA_SCISSOR.
  785. if (alpha_antialiasing_mode == ALPHA_ANTIALIASING_ALPHA_TO_COVERAGE) {
  786. code += ", alpha_to_coverage";
  787. } else if (alpha_antialiasing_mode == ALPHA_ANTIALIASING_ALPHA_TO_COVERAGE_AND_TO_ONE) {
  788. code += ", alpha_to_coverage_and_one";
  789. }
  790. }
  791. code += ";\n";
  792. if (stencil_mode != STENCIL_MODE_DISABLED && stencil_flags != 0) {
  793. code += "stencil_mode ";
  794. if (stencil_flags & STENCIL_FLAG_READ) {
  795. code += "read";
  796. }
  797. if (stencil_flags & STENCIL_FLAG_WRITE) {
  798. if (stencil_flags & STENCIL_FLAG_READ) {
  799. code += ", ";
  800. }
  801. code += "write";
  802. }
  803. if (stencil_flags & STENCIL_FLAG_WRITE_DEPTH_FAIL) {
  804. if (stencil_flags & (STENCIL_FLAG_READ | STENCIL_FLAG_WRITE)) {
  805. code += ", ";
  806. }
  807. code += "write_depth_fail";
  808. }
  809. switch (stencil_compare) {
  810. case STENCIL_COMPARE_ALWAYS:
  811. code += ", compare_always";
  812. break;
  813. case STENCIL_COMPARE_LESS:
  814. code += ", compare_less";
  815. break;
  816. case STENCIL_COMPARE_EQUAL:
  817. code += ", compare_equal";
  818. break;
  819. case STENCIL_COMPARE_LESS_OR_EQUAL:
  820. code += ", compare_less_or_equal";
  821. break;
  822. case STENCIL_COMPARE_GREATER:
  823. code += ", compare_greater";
  824. break;
  825. case STENCIL_COMPARE_NOT_EQUAL:
  826. code += ", compare_not_equal";
  827. break;
  828. case STENCIL_COMPARE_GREATER_OR_EQUAL:
  829. code += ", compare_greater_or_equal";
  830. break;
  831. case STENCIL_COMPARE_MAX:
  832. break;
  833. }
  834. code += vformat(", %s;\n", stencil_reference);
  835. }
  836. // Generate list of uniforms.
  837. code += vformat(R"(
  838. uniform vec4 albedo : source_color;
  839. uniform sampler2D texture_albedo : source_color, %s;
  840. )",
  841. texfilter_str);
  842. if (grow_enabled) {
  843. code += "uniform float grow : hint_range(-16.0, 16.0, 0.001);\n";
  844. }
  845. if (proximity_fade_enabled) {
  846. code += "uniform float proximity_fade_distance : hint_range(0.0, 4096.0, 0.01);\n";
  847. }
  848. if (distance_fade != DISTANCE_FADE_DISABLED) {
  849. code += R"(
  850. uniform float distance_fade_min : hint_range(0.0, 4096.0, 0.01);
  851. uniform float distance_fade_max : hint_range(0.0, 4096.0, 0.01);
  852. )";
  853. }
  854. if (flags[FLAG_ALBEDO_TEXTURE_MSDF] && flags[FLAG_UV1_USE_TRIPLANAR]) {
  855. String msg = "MSDF is not supported on triplanar materials. Ignoring MSDF in favor of triplanar mapping.";
  856. if (textures[TEXTURE_ALBEDO].is_valid()) {
  857. WARN_PRINT(vformat("%s (albedo %s): " + msg, get_path(), textures[TEXTURE_ALBEDO]->get_path()));
  858. } else if (!get_path().is_empty()) {
  859. WARN_PRINT(vformat("%s: " + msg, get_path()));
  860. } else {
  861. WARN_PRINT(msg);
  862. }
  863. }
  864. if (flags[FLAG_ALBEDO_TEXTURE_MSDF] && !flags[FLAG_UV1_USE_TRIPLANAR]) {
  865. code += R"(
  866. uniform float msdf_pixel_range : hint_range(1.0, 100.0, 1.0);
  867. uniform float msdf_outline_size : hint_range(0.0, 250.0, 1.0);
  868. )";
  869. }
  870. // Alpha scissor is only valid if there is no antialiasing edge.
  871. // Alpha hash is valid whenever, but not with alpha scissor.
  872. if (transparency == TRANSPARENCY_ALPHA_SCISSOR) {
  873. code += "uniform float alpha_scissor_threshold : hint_range(0.0, 1.0, 0.001);\n";
  874. } else if (transparency == TRANSPARENCY_ALPHA_HASH) {
  875. code += "uniform float alpha_hash_scale : hint_range(0.0, 2.0, 0.01);\n";
  876. }
  877. // If alpha antialiasing isn't off, add in the edge variable.
  878. if (alpha_antialiasing_mode != ALPHA_ANTIALIASING_OFF &&
  879. (transparency == TRANSPARENCY_ALPHA_SCISSOR || transparency == TRANSPARENCY_ALPHA_HASH)) {
  880. code += "uniform float alpha_antialiasing_edge : hint_range(0.0, 1.0, 0.01);\n";
  881. }
  882. code += "uniform ivec2 albedo_texture_size;\n";
  883. code += "uniform float point_size : hint_range(0.1, 128.0, 0.1);\n";
  884. if (!orm) {
  885. code += vformat(R"(
  886. uniform float roughness : hint_range(0.0, 1.0);
  887. uniform sampler2D texture_metallic : hint_default_white, %s;
  888. uniform vec4 metallic_texture_channel;
  889. )",
  890. texfilter_str);
  891. switch (roughness_texture_channel) {
  892. case TEXTURE_CHANNEL_RED: {
  893. code += vformat("uniform sampler2D texture_roughness : hint_roughness_r, %s;\n", texfilter_str);
  894. } break;
  895. case TEXTURE_CHANNEL_GREEN: {
  896. code += vformat("uniform sampler2D texture_roughness : hint_roughness_g, %s;\n", texfilter_str);
  897. } break;
  898. case TEXTURE_CHANNEL_BLUE: {
  899. code += vformat("uniform sampler2D texture_roughness : hint_roughness_b, %s;\n", texfilter_str);
  900. } break;
  901. case TEXTURE_CHANNEL_ALPHA: {
  902. code += vformat("uniform sampler2D texture_roughness : hint_roughness_a, %s;\n", texfilter_str);
  903. } break;
  904. case TEXTURE_CHANNEL_GRAYSCALE: {
  905. code += vformat("uniform sampler2D texture_roughness : hint_roughness_gray, %s;\n", texfilter_str);
  906. } break;
  907. case TEXTURE_CHANNEL_MAX:
  908. break; // Internal value, skip.
  909. }
  910. code += R"(
  911. uniform float specular : hint_range(0.0, 1.0, 0.01);
  912. uniform float metallic : hint_range(0.0, 1.0, 0.01);
  913. )";
  914. } else {
  915. code += "uniform sampler2D texture_orm : hint_roughness_g, " + texfilter_str + ";\n";
  916. }
  917. if (billboard_mode == BILLBOARD_PARTICLES) {
  918. code += R"(
  919. uniform int particles_anim_h_frames : hint_range(1, 128);
  920. uniform int particles_anim_v_frames : hint_range(1, 128);
  921. uniform bool particles_anim_loop;
  922. )";
  923. }
  924. if (features[FEATURE_EMISSION]) {
  925. code += vformat(R"(
  926. uniform sampler2D texture_emission : source_color, hint_default_black, %s;
  927. uniform vec4 emission : source_color;
  928. uniform float emission_energy : hint_range(0.0, 100.0, 0.01);
  929. )",
  930. texfilter_str);
  931. }
  932. if (features[FEATURE_REFRACTION]) {
  933. code += vformat(R"(
  934. uniform sampler2D texture_refraction : %s;
  935. uniform float refraction : hint_range(-1.0, 1.0, 0.001);
  936. uniform vec4 refraction_texture_channel;
  937. )",
  938. texfilter_str);
  939. }
  940. if (features[FEATURE_REFRACTION]) {
  941. code += "uniform sampler2D screen_texture : hint_screen_texture, repeat_disable, filter_linear_mipmap;\n";
  942. }
  943. if (features[FEATURE_REFRACTION] || proximity_fade_enabled) {
  944. code += "uniform sampler2D depth_texture : hint_depth_texture, repeat_disable, filter_nearest;\n";
  945. }
  946. if (features[FEATURE_NORMAL_MAPPING]) {
  947. code += vformat(R"(
  948. uniform sampler2D texture_normal : hint_roughness_normal, %s;
  949. uniform float normal_scale : hint_range(-16.0, 16.0);
  950. )",
  951. texfilter_str);
  952. }
  953. if (features[FEATURE_BENT_NORMAL_MAPPING]) {
  954. code += vformat(R"(
  955. uniform sampler2D texture_bent_normal : hint_roughness_normal, %s;
  956. )",
  957. texfilter_str);
  958. }
  959. if (features[FEATURE_RIM]) {
  960. code += vformat(R"(
  961. uniform float rim : hint_range(0.0, 1.0, 0.01);
  962. uniform float rim_tint : hint_range(0.0, 1.0, 0.01);
  963. uniform sampler2D texture_rim : hint_default_white, %s;
  964. )",
  965. texfilter_str);
  966. }
  967. if (features[FEATURE_CLEARCOAT]) {
  968. code += vformat(R"(
  969. uniform float clearcoat : hint_range(0.0, 1.0, 0.01);
  970. uniform float clearcoat_roughness : hint_range(0.0, 1.0, 0.01);
  971. uniform sampler2D texture_clearcoat : hint_default_white, %s;
  972. )",
  973. texfilter_str);
  974. }
  975. if (features[FEATURE_ANISOTROPY]) {
  976. code += vformat(R"(
  977. uniform float anisotropy_ratio : hint_range(0.0, 1.0, 0.01);
  978. uniform sampler2D texture_flowmap : hint_anisotropy, %s;
  979. )",
  980. texfilter_str);
  981. }
  982. if (features[FEATURE_AMBIENT_OCCLUSION]) {
  983. code += vformat(R"(
  984. uniform sampler2D texture_ambient_occlusion : hint_default_white, %s;
  985. uniform vec4 ao_texture_channel;
  986. uniform float ao_light_affect : hint_range(0.0, 1.0, 0.01);
  987. )",
  988. texfilter_str);
  989. }
  990. if (features[FEATURE_DETAIL]) {
  991. code += vformat(R"(
  992. uniform sampler2D texture_detail_albedo : source_color, %s;
  993. uniform sampler2D texture_detail_normal : hint_normal, %s;
  994. uniform sampler2D texture_detail_mask : hint_default_white, %s;
  995. )",
  996. texfilter_str, texfilter_str, texfilter_str);
  997. }
  998. if (features[FEATURE_SUBSURFACE_SCATTERING]) {
  999. code += vformat(R"(
  1000. uniform float subsurface_scattering_strength : hint_range(0.0, 1.0, 0.01);
  1001. uniform sampler2D texture_subsurface_scattering : hint_default_white, %s;
  1002. )",
  1003. texfilter_str);
  1004. }
  1005. if (features[FEATURE_SUBSURFACE_TRANSMITTANCE]) {
  1006. code += vformat(R"(
  1007. uniform vec4 transmittance_color : source_color;
  1008. uniform float transmittance_depth : hint_range(0.001, 8.0, 0.001);
  1009. uniform sampler2D texture_subsurface_transmittance : hint_default_white, %s;
  1010. uniform float transmittance_boost : hint_range(0.0, 1.0, 0.01);
  1011. )",
  1012. texfilter_str);
  1013. }
  1014. if (features[FEATURE_BACKLIGHT]) {
  1015. code += vformat(R"(
  1016. uniform vec4 backlight : source_color;
  1017. uniform sampler2D texture_backlight : hint_default_black, %s;
  1018. )",
  1019. texfilter_str);
  1020. }
  1021. if (features[FEATURE_HEIGHT_MAPPING]) {
  1022. code += vformat(R"(
  1023. uniform sampler2D texture_heightmap : hint_default_black, %s;
  1024. uniform float heightmap_scale : hint_range(-16.0, 16.0, 0.001);
  1025. uniform int heightmap_min_layers : hint_range(1, 64);
  1026. uniform int heightmap_max_layers : hint_range(1, 64);
  1027. uniform vec2 heightmap_flip;
  1028. )",
  1029. texfilter_height_str);
  1030. }
  1031. if (flags[FLAG_UV1_USE_TRIPLANAR]) {
  1032. code += "varying vec3 uv1_triplanar_pos;\n";
  1033. }
  1034. if (flags[FLAG_UV2_USE_TRIPLANAR]) {
  1035. code += "varying vec3 uv2_triplanar_pos;\n";
  1036. }
  1037. if (flags[FLAG_UV1_USE_TRIPLANAR]) {
  1038. code += R"(
  1039. uniform float uv1_blend_sharpness : hint_range(0.0, 150.0, 0.001);
  1040. varying vec3 uv1_power_normal;
  1041. )";
  1042. }
  1043. if (flags[FLAG_UV2_USE_TRIPLANAR]) {
  1044. code += R"(uniform float uv2_blend_sharpness : hint_range(0.0, 150.0, 0.001);
  1045. varying vec3 uv2_power_normal;
  1046. )";
  1047. }
  1048. code += R"(
  1049. uniform vec3 uv1_scale;
  1050. uniform vec3 uv1_offset;
  1051. uniform vec3 uv2_scale;
  1052. uniform vec3 uv2_offset;
  1053. )";
  1054. if (flags[FLAG_USE_Z_CLIP_SCALE]) {
  1055. code += "uniform float z_clip_scale : hint_range(0.01, 1.0, 0.01);\n";
  1056. }
  1057. if (flags[FLAG_USE_FOV_OVERRIDE]) {
  1058. code += "uniform float fov_override : hint_range(1.0, 179.0, 0.1);\n";
  1059. }
  1060. // Generate vertex shader.
  1061. code += R"(
  1062. void vertex() {)";
  1063. if (flags[FLAG_SRGB_VERTEX_COLOR]) {
  1064. code += R"(
  1065. // Vertex Color is sRGB: Enabled
  1066. if (!OUTPUT_IS_SRGB) {
  1067. COLOR.rgb = mix(
  1068. pow((COLOR.rgb + vec3(0.055)) * (1.0 / (1.0 + 0.055)), vec3(2.4)),
  1069. COLOR.rgb * (1.0 / 12.92),
  1070. lessThan(COLOR.rgb, vec3(0.04045)));
  1071. }
  1072. )";
  1073. }
  1074. if (flags[FLAG_USE_POINT_SIZE]) {
  1075. code += R"(
  1076. // Use Point Size: Enabled
  1077. POINT_SIZE = point_size;
  1078. )";
  1079. }
  1080. if (shading_mode == SHADING_MODE_PER_VERTEX) {
  1081. code += R"(
  1082. // Shading Mode: Per Vertex
  1083. ROUGHNESS = roughness;
  1084. )";
  1085. }
  1086. if (!flags[FLAG_UV1_USE_TRIPLANAR]) {
  1087. code += R"(
  1088. UV = UV * uv1_scale.xy + uv1_offset.xy;
  1089. )";
  1090. }
  1091. if (detail_uv == DETAIL_UV_2 && !flags[FLAG_UV2_USE_TRIPLANAR]) {
  1092. // Don't add a newline if the UV assignment above is already performed,
  1093. // so that UV1 and UV2 are closer to each other.
  1094. if (flags[FLAG_UV1_USE_TRIPLANAR]) {
  1095. code += "\n";
  1096. }
  1097. code += R"( // Detail UV Layer: UV2
  1098. UV2 = UV2 * uv2_scale.xy + uv2_offset.xy;
  1099. )";
  1100. }
  1101. switch (billboard_mode) {
  1102. case BILLBOARD_DISABLED: {
  1103. } break;
  1104. case BILLBOARD_ENABLED: {
  1105. // `MAIN_CAM_INV_VIEW_MATRIX` is inverse of the camera, even on shadow passes.
  1106. // This ensures the billboard faces the camera when casting shadows.
  1107. code += R"(
  1108. // Billboard Mode: Enabled
  1109. MODELVIEW_MATRIX = VIEW_MATRIX * mat4(
  1110. MAIN_CAM_INV_VIEW_MATRIX[0],
  1111. MAIN_CAM_INV_VIEW_MATRIX[1],
  1112. MAIN_CAM_INV_VIEW_MATRIX[2],
  1113. MODEL_MATRIX[3]);
  1114. )";
  1115. if (flags[FLAG_BILLBOARD_KEEP_SCALE]) {
  1116. code += R"(
  1117. // Billboard Keep Scale: Enabled
  1118. MODELVIEW_MATRIX = MODELVIEW_MATRIX * mat4(
  1119. vec4(length(MODEL_MATRIX[0].xyz), 0.0, 0.0, 0.0),
  1120. vec4(0.0, length(MODEL_MATRIX[1].xyz), 0.0, 0.0),
  1121. vec4(0.0, 0.0, length(MODEL_MATRIX[2].xyz), 0.0),
  1122. vec4(0.0, 0.0, 0.0, 1.0));
  1123. )";
  1124. }
  1125. code += " MODELVIEW_NORMAL_MATRIX = mat3(MODELVIEW_MATRIX);\n";
  1126. } break;
  1127. case BILLBOARD_FIXED_Y: {
  1128. // `MAIN_CAM_INV_VIEW_MATRIX` is inverse of the camera, even on shadow passes.
  1129. // This ensures the billboard faces the camera when casting shadows.
  1130. code += R"(
  1131. // Billboard Mode: Y-Billboard
  1132. MODELVIEW_MATRIX = VIEW_MATRIX * mat4(
  1133. vec4(normalize(cross(vec3(0.0, 1.0, 0.0), MAIN_CAM_INV_VIEW_MATRIX[2].xyz)), 0.0),
  1134. vec4(0.0, 1.0, 0.0, 0.0),
  1135. vec4(normalize(cross(MAIN_CAM_INV_VIEW_MATRIX[0].xyz, vec3(0.0, 1.0, 0.0))), 0.0),
  1136. MODEL_MATRIX[3]);
  1137. )";
  1138. if (flags[FLAG_BILLBOARD_KEEP_SCALE]) {
  1139. code += R"(
  1140. // Billboard Keep Scale: Enabled
  1141. MODELVIEW_MATRIX = MODELVIEW_MATRIX * mat4(
  1142. vec4(length(MODEL_MATRIX[0].xyz), 0.0, 0.0, 0.0),
  1143. vec4(0.0, length(MODEL_MATRIX[1].xyz), 0.0, 0.0),
  1144. vec4(0.0, 0.0, length(MODEL_MATRIX[2].xyz), 0.0),
  1145. vec4(0.0, 0.0, 0.0, 1.0));
  1146. )";
  1147. }
  1148. code += " MODELVIEW_NORMAL_MATRIX = mat3(MODELVIEW_MATRIX);\n";
  1149. } break;
  1150. case BILLBOARD_PARTICLES: {
  1151. // Make billboard and rotated by rotation.
  1152. code += R"(
  1153. // Billboard Mode: Particles
  1154. mat4 mat_world = mat4(
  1155. normalize(INV_VIEW_MATRIX[0]),
  1156. normalize(INV_VIEW_MATRIX[1]),
  1157. normalize(INV_VIEW_MATRIX[2]),
  1158. MODEL_MATRIX[3]);
  1159. mat_world = mat_world * mat4(
  1160. vec4(cos(INSTANCE_CUSTOM.x), -sin(INSTANCE_CUSTOM.x), 0.0, 0.0),
  1161. vec4(sin(INSTANCE_CUSTOM.x), cos(INSTANCE_CUSTOM.x), 0.0, 0.0),
  1162. vec4(0.0, 0.0, 1.0, 0.0),
  1163. vec4(0.0, 0.0, 0.0, 1.0));
  1164. )";
  1165. // Set modelview.
  1166. code += " MODELVIEW_MATRIX = VIEW_MATRIX * mat_world;\n";
  1167. if (flags[FLAG_BILLBOARD_KEEP_SCALE]) {
  1168. code += R"(
  1169. // Billboard Keep Scale: Enabled
  1170. MODELVIEW_MATRIX = MODELVIEW_MATRIX * mat4(
  1171. vec4(length(MODEL_MATRIX[0].xyz), 0.0, 0.0, 0.0),
  1172. vec4(0.0, length(MODEL_MATRIX[1].xyz), 0.0, 0.0),
  1173. vec4(0.0, 0.0, length(MODEL_MATRIX[2].xyz), 0.0),
  1174. vec4(0.0, 0.0, 0.0, 1.0));
  1175. )";
  1176. }
  1177. // Set modelview normal and handle animation.
  1178. code += R"(
  1179. MODELVIEW_NORMAL_MATRIX = mat3(MODELVIEW_MATRIX);
  1180. float h_frames = float(particles_anim_h_frames);
  1181. float v_frames = float(particles_anim_v_frames);
  1182. float particle_total_frames = float(particles_anim_h_frames * particles_anim_v_frames);
  1183. float particle_frame = floor(INSTANCE_CUSTOM.z * float(particle_total_frames));
  1184. if (!particles_anim_loop) {
  1185. particle_frame = clamp(particle_frame, 0.0, particle_total_frames - 1.0);
  1186. } else {
  1187. particle_frame = mod(particle_frame, particle_total_frames);
  1188. }
  1189. UV /= vec2(h_frames, v_frames);
  1190. UV += vec2(mod(particle_frame, h_frames) / h_frames, floor((particle_frame + 0.5) / h_frames) / v_frames);
  1191. )";
  1192. } break;
  1193. case BILLBOARD_MAX:
  1194. break; // Internal value, skip.
  1195. }
  1196. if (flags[FLAG_FIXED_SIZE]) {
  1197. code += R"(
  1198. // Fixed Size: Enabled
  1199. if (PROJECTION_MATRIX[3][3] != 0.0) {
  1200. // Orthogonal matrix; try to do about the same with viewport size.
  1201. float h = abs(1.0 / (2.0 * PROJECTION_MATRIX[1][1]));
  1202. // Consistent with vertical FOV (Keep Height).
  1203. float sc = (h * 2.0);
  1204. MODELVIEW_MATRIX[0] *= sc;
  1205. MODELVIEW_MATRIX[1] *= sc;
  1206. MODELVIEW_MATRIX[2] *= sc;
  1207. } else {
  1208. // Scale by depth.
  1209. float sc = -(MODELVIEW_MATRIX)[3].z;
  1210. MODELVIEW_MATRIX[0] *= sc;
  1211. MODELVIEW_MATRIX[1] *= sc;
  1212. MODELVIEW_MATRIX[2] *= sc;
  1213. }
  1214. )";
  1215. }
  1216. if (flags[FLAG_UV1_USE_TRIPLANAR] || flags[FLAG_UV2_USE_TRIPLANAR]) {
  1217. // Generate tangent and binormal in world space.
  1218. if (flags[FLAG_UV1_USE_WORLD_TRIPLANAR]) {
  1219. code += R"(
  1220. vec3 normal = MODEL_NORMAL_MATRIX * NORMAL;
  1221. )";
  1222. } else {
  1223. code += R"(
  1224. vec3 normal = NORMAL;
  1225. )";
  1226. }
  1227. code += R"(
  1228. TANGENT = vec3(0.0, 0.0, -1.0) * abs(normal.x);
  1229. TANGENT += vec3(1.0, 0.0, 0.0) * abs(normal.y);
  1230. TANGENT += vec3(1.0, 0.0, 0.0) * abs(normal.z);
  1231. )";
  1232. if (flags[FLAG_UV1_USE_WORLD_TRIPLANAR]) {
  1233. code += " TANGENT = inverse(MODEL_NORMAL_MATRIX) * normalize(TANGENT);\n";
  1234. } else {
  1235. code += " TANGENT = normalize(TANGENT);\n";
  1236. }
  1237. code += R"(
  1238. BINORMAL = vec3(0.0, 1.0, 0.0) * abs(normal.x);
  1239. BINORMAL += vec3(0.0, 0.0, -1.0) * abs(normal.y);
  1240. BINORMAL += vec3(0.0, 1.0, 0.0) * abs(normal.z);
  1241. )";
  1242. if (flags[FLAG_UV1_USE_WORLD_TRIPLANAR]) {
  1243. code += " BINORMAL = inverse(MODEL_NORMAL_MATRIX) * normalize(BINORMAL);\n";
  1244. } else {
  1245. code += " BINORMAL = normalize(BINORMAL);\n";
  1246. }
  1247. }
  1248. if (flags[FLAG_UV1_USE_TRIPLANAR]) {
  1249. if (flags[FLAG_UV1_USE_WORLD_TRIPLANAR]) {
  1250. code += R"(
  1251. // UV1 Triplanar: Enabled (with World Triplanar)
  1252. uv1_power_normal = pow(abs(normal), vec3(uv1_blend_sharpness));
  1253. uv1_triplanar_pos = (MODEL_MATRIX * vec4(VERTEX, 1.0)).xyz * uv1_scale + uv1_offset;
  1254. )";
  1255. } else {
  1256. code += R"(
  1257. // UV1 Triplanar: Enabled
  1258. uv1_power_normal = pow(abs(NORMAL), vec3(uv1_blend_sharpness));
  1259. uv1_triplanar_pos = VERTEX * uv1_scale + uv1_offset;
  1260. )";
  1261. }
  1262. code += R"( uv1_power_normal /= dot(uv1_power_normal, vec3(1.0));
  1263. uv1_triplanar_pos *= vec3(1.0, -1.0, 1.0);
  1264. )";
  1265. }
  1266. if (flags[FLAG_UV2_USE_TRIPLANAR]) {
  1267. if (flags[FLAG_UV2_USE_WORLD_TRIPLANAR]) {
  1268. code += R"(
  1269. // UV2 Triplanar: Enabled (with World Triplanar)
  1270. uv2_power_normal = pow(abs(mat3(MODEL_MATRIX) * NORMAL), vec3(uv2_blend_sharpness));
  1271. uv2_triplanar_pos = (MODEL_MATRIX * vec4(VERTEX, 1.0)).xyz * uv2_scale + uv2_offset;
  1272. )";
  1273. } else {
  1274. code += R"(
  1275. // UV2 Triplanar: Enabled
  1276. uv2_power_normal = pow(abs(NORMAL), vec3(uv2_blend_sharpness));
  1277. uv2_triplanar_pos = VERTEX * uv2_scale + uv2_offset;
  1278. )";
  1279. }
  1280. code += R"( uv2_power_normal /= dot(uv2_power_normal, vec3(1.0));
  1281. uv2_triplanar_pos *= vec3(1.0, -1.0, 1.0);
  1282. )";
  1283. }
  1284. if (grow_enabled) {
  1285. code += R"(
  1286. // Grow: Enabled
  1287. VERTEX += NORMAL * grow;
  1288. )";
  1289. }
  1290. if (flags[FLAG_USE_Z_CLIP_SCALE]) {
  1291. code += R"(
  1292. Z_CLIP_SCALE = z_clip_scale;
  1293. )";
  1294. }
  1295. if (flags[FLAG_USE_FOV_OVERRIDE]) {
  1296. code += R"(
  1297. if (!IN_SHADOW_PASS) {
  1298. float flip_y = sign(PROJECTION_MATRIX[1][1]);
  1299. float aspect = PROJECTION_MATRIX[1][1] / PROJECTION_MATRIX[0][0];
  1300. float f = flip_y / tan(fov_override * PI / 360.0);
  1301. PROJECTION_MATRIX[0][0] = f / aspect;
  1302. PROJECTION_MATRIX[1][1] = f;
  1303. }
  1304. )";
  1305. }
  1306. // End of the vertex shader function.
  1307. code += "}\n";
  1308. if (flags[FLAG_ALBEDO_TEXTURE_MSDF] && !flags[FLAG_UV1_USE_TRIPLANAR]) {
  1309. code += R"(
  1310. float msdf_median(float r, float g, float b, float a) {
  1311. return min(max(min(r, g), min(max(r, g), b)), a);
  1312. }
  1313. )";
  1314. }
  1315. if (flags[FLAG_UV1_USE_TRIPLANAR] || flags[FLAG_UV2_USE_TRIPLANAR]) {
  1316. code += R"(
  1317. vec4 triplanar_texture(sampler2D p_sampler, vec3 p_weights, vec3 p_triplanar_pos) {
  1318. vec4 samp = vec4(0.0);
  1319. samp += texture(p_sampler, p_triplanar_pos.xy) * p_weights.z;
  1320. samp += texture(p_sampler, p_triplanar_pos.xz) * p_weights.y;
  1321. samp += texture(p_sampler, p_triplanar_pos.zy * vec2(-1.0, 1.0)) * p_weights.x;
  1322. return samp;
  1323. }
  1324. )";
  1325. }
  1326. // Generate fragment shader.
  1327. code += R"(
  1328. void fragment() {)";
  1329. if (!flags[FLAG_UV1_USE_TRIPLANAR]) {
  1330. code += R"(
  1331. vec2 base_uv = UV;
  1332. )";
  1333. }
  1334. if ((features[FEATURE_DETAIL] && detail_uv == DETAIL_UV_2) || (features[FEATURE_AMBIENT_OCCLUSION] && flags[FLAG_AO_ON_UV2]) || (features[FEATURE_EMISSION] && flags[FLAG_EMISSION_ON_UV2])) {
  1335. // Don't add a newline if the UV assignment above is already performed,
  1336. // so that UV1 and UV2 are closer to each other.
  1337. if (flags[FLAG_UV1_USE_TRIPLANAR]) {
  1338. code += "\n";
  1339. }
  1340. code += R"( vec2 base_uv2 = UV2;
  1341. )";
  1342. }
  1343. if (features[FEATURE_HEIGHT_MAPPING] && flags[FLAG_UV1_USE_TRIPLANAR]) {
  1344. // Display both resource name and albedo texture name.
  1345. // Materials are often built-in to scenes, so displaying the resource name alone may not be meaningful.
  1346. // On the other hand, albedo textures are almost always external to the scene.
  1347. if (textures[TEXTURE_ALBEDO].is_valid()) {
  1348. WARN_PRINT(vformat("%s (albedo %s): Height mapping is not supported on triplanar materials. Ignoring height mapping in favor of triplanar mapping.", get_path(), textures[TEXTURE_ALBEDO]->get_path()));
  1349. } else if (!get_path().is_empty()) {
  1350. WARN_PRINT(vformat("%s: Height mapping is not supported on triplanar materials. Ignoring height mapping in favor of triplanar mapping.", get_path()));
  1351. } else {
  1352. // Resource wasn't saved yet.
  1353. WARN_PRINT("Height mapping is not supported on triplanar materials. Ignoring height mapping in favor of triplanar mapping.");
  1354. }
  1355. }
  1356. // Heightmapping isn't supported at the same time as triplanar mapping.
  1357. if (features[FEATURE_HEIGHT_MAPPING] && !flags[FLAG_UV1_USE_TRIPLANAR]) {
  1358. // Binormal is negative due to mikktspace. Flipping it "unflips" it.
  1359. code += R"(
  1360. {
  1361. // Height: Enabled
  1362. vec3 view_dir = normalize(normalize(-VERTEX + EYE_OFFSET) * mat3(TANGENT * heightmap_flip.x, -BINORMAL * heightmap_flip.y, NORMAL));
  1363. )";
  1364. if (deep_parallax) {
  1365. // Multiply the heightmap scale by 0.01 to improve heightmap scale usability.
  1366. code += R"(
  1367. // Height Deep Parallax: Enabled
  1368. float num_layers = mix(float(heightmap_max_layers), float(heightmap_min_layers), abs(dot(vec3(0.0, 0.0, 1.0), view_dir)));
  1369. float layer_depth = 1.0 / num_layers;
  1370. float current_layer_depth = 0.0;
  1371. vec2 p = view_dir.xy * heightmap_scale * 0.01;
  1372. vec2 delta = p / num_layers;
  1373. vec2 ofs = base_uv;
  1374. )";
  1375. if (flags[FLAG_INVERT_HEIGHTMAP]) {
  1376. code += " float depth = texture(texture_heightmap, ofs).r;\n";
  1377. } else {
  1378. code += " float depth = 1.0 - texture(texture_heightmap, ofs).r;\n";
  1379. }
  1380. code += R"(
  1381. float current_depth = 0.0;
  1382. while (current_depth < depth) {
  1383. ofs -= delta;
  1384. )";
  1385. if (flags[FLAG_INVERT_HEIGHTMAP]) {
  1386. code += " depth = texture(texture_heightmap, ofs).r;\n";
  1387. } else {
  1388. code += " depth = 1.0 - texture(texture_heightmap, ofs).r;\n";
  1389. }
  1390. code += R"(
  1391. current_depth += layer_depth;
  1392. }
  1393. vec2 prev_ofs = ofs + delta;
  1394. float after_depth = depth - current_depth;
  1395. )";
  1396. if (flags[FLAG_INVERT_HEIGHTMAP]) {
  1397. code += " float before_depth = texture(texture_heightmap, prev_ofs).r - current_depth + layer_depth;\n";
  1398. } else {
  1399. code += " float before_depth = (1.0 - texture(texture_heightmap, prev_ofs).r) - current_depth + layer_depth;\n";
  1400. }
  1401. code += R"(
  1402. float weight = after_depth / (after_depth - before_depth);
  1403. ofs = mix(ofs, prev_ofs, weight);
  1404. )";
  1405. } else {
  1406. if (flags[FLAG_INVERT_HEIGHTMAP]) {
  1407. code += " float depth = texture(texture_heightmap, base_uv).r;\n";
  1408. } else {
  1409. code += " float depth = 1.0 - texture(texture_heightmap, base_uv).r;\n";
  1410. }
  1411. // Use offset limiting to improve the appearance of non-deep parallax.
  1412. // This reduces the impression of depth, but avoids visible warping in the distance.
  1413. // Multiply the heightmap scale by 0.01 to improve heightmap scale usability.
  1414. code += " vec2 ofs = base_uv - view_dir.xy * depth * heightmap_scale * 0.01;\n";
  1415. }
  1416. code += " base_uv = ofs;\n";
  1417. if (features[FEATURE_DETAIL] && detail_uv == DETAIL_UV_2) {
  1418. code += " base_uv2 -= ofs;\n";
  1419. }
  1420. code += " }\n";
  1421. }
  1422. if (flags[FLAG_USE_POINT_SIZE]) {
  1423. code += R"(
  1424. // Use Point Size: Enabled
  1425. vec4 albedo_tex = texture(texture_albedo, POINT_COORD);
  1426. )";
  1427. } else {
  1428. if (flags[FLAG_UV1_USE_TRIPLANAR]) {
  1429. code += R"(
  1430. vec4 albedo_tex = triplanar_texture(texture_albedo, uv1_power_normal, uv1_triplanar_pos);
  1431. )";
  1432. } else {
  1433. code += R"(
  1434. vec4 albedo_tex = texture(texture_albedo, base_uv);
  1435. )";
  1436. }
  1437. }
  1438. if (flags[FLAG_ALBEDO_TEXTURE_MSDF] && !flags[FLAG_UV1_USE_TRIPLANAR]) {
  1439. code += R"(
  1440. {
  1441. // Albedo Texture MSDF: Enabled
  1442. albedo_tex.rgb = mix(
  1443. vec3(1.0 + 0.055) * pow(albedo_tex.rgb, vec3(1.0 / 2.4)) - vec3(0.055),
  1444. vec3(12.92) * albedo_tex.rgb,
  1445. lessThan(albedo_tex.rgb, vec3(0.0031308)));
  1446. vec2 msdf_size = vec2(msdf_pixel_range) / vec2(albedo_texture_size);
  1447. )";
  1448. if (flags[FLAG_USE_POINT_SIZE]) {
  1449. code += " vec2 dest_size = vec2(1.0) / fwidth(POINT_COORD);\n";
  1450. } else {
  1451. code += " vec2 dest_size = vec2(1.0) / fwidth(base_uv);\n";
  1452. }
  1453. code += R"(
  1454. float px_size = max(0.5 * dot(msdf_size, dest_size), 1.0);
  1455. float d = msdf_median(albedo_tex.r, albedo_tex.g, albedo_tex.b, albedo_tex.a) - 0.5;
  1456. if (msdf_outline_size > 0.0) {
  1457. float cr = clamp(msdf_outline_size, 0.0, msdf_pixel_range / 2.0) / msdf_pixel_range;
  1458. albedo_tex.a = clamp((d + cr) * px_size, 0.0, 1.0);
  1459. } else {
  1460. albedo_tex.a = clamp(d * px_size + 0.5, 0.0, 1.0);
  1461. }
  1462. albedo_tex.rgb = vec3(1.0);
  1463. }
  1464. )";
  1465. } else if (flags[FLAG_ALBEDO_TEXTURE_FORCE_SRGB]) {
  1466. code += R"(
  1467. // Albedo Texture Force sRGB: Enabled
  1468. albedo_tex.rgb = mix(
  1469. pow((albedo_tex.rgb + vec3(0.055)) * (1.0 / (1.0 + 0.055)), vec3(2.4)),
  1470. albedo_tex.rgb.rgb * (1.0 / 12.92),
  1471. lessThan(albedo_tex.rgb, vec3(0.04045)));
  1472. )";
  1473. }
  1474. if (flags[FLAG_ALBEDO_FROM_VERTEX_COLOR]) {
  1475. code += R"(
  1476. // Vertex Color Use as Albedo: Enabled
  1477. albedo_tex *= COLOR;
  1478. )";
  1479. }
  1480. code += " ALBEDO = albedo.rgb * albedo_tex.rgb;\n";
  1481. if (!orm) {
  1482. if (flags[FLAG_UV1_USE_TRIPLANAR]) {
  1483. code += R"(
  1484. float metallic_tex = dot(triplanar_texture(texture_metallic, uv1_power_normal, uv1_triplanar_pos), metallic_texture_channel);
  1485. )";
  1486. } else {
  1487. code += R"(
  1488. float metallic_tex = dot(texture(texture_metallic, base_uv), metallic_texture_channel);
  1489. )";
  1490. }
  1491. code += R"( METALLIC = metallic_tex * metallic;
  1492. SPECULAR = specular;
  1493. )";
  1494. switch (roughness_texture_channel) {
  1495. case TEXTURE_CHANNEL_RED: {
  1496. code += R"(
  1497. vec4 roughness_texture_channel = vec4(1.0, 0.0, 0.0, 0.0);
  1498. )";
  1499. } break;
  1500. case TEXTURE_CHANNEL_GREEN: {
  1501. code += R"(
  1502. vec4 roughness_texture_channel = vec4(0.0, 1.0, 0.0, 0.0);
  1503. )";
  1504. } break;
  1505. case TEXTURE_CHANNEL_BLUE: {
  1506. code += R"(
  1507. vec4 roughness_texture_channel = vec4(0.0, 0.0, 1.0, 0.0);
  1508. )";
  1509. } break;
  1510. case TEXTURE_CHANNEL_ALPHA: {
  1511. code += R"(
  1512. vec4 roughness_texture_channel = vec4(0.0, 0.0, 0.0, 1.0);
  1513. )";
  1514. } break;
  1515. case TEXTURE_CHANNEL_GRAYSCALE: {
  1516. code += R"(
  1517. vec4 roughness_texture_channel = vec4(0.333333, 0.333333, 0.333333, 0.0);
  1518. )";
  1519. } break;
  1520. case TEXTURE_CHANNEL_MAX:
  1521. break; // Internal value, skip.
  1522. }
  1523. if (flags[FLAG_UV1_USE_TRIPLANAR]) {
  1524. code += " float roughness_tex = dot(triplanar_texture(texture_roughness, uv1_power_normal, uv1_triplanar_pos), roughness_texture_channel);\n";
  1525. } else {
  1526. code += " float roughness_tex = dot(texture(texture_roughness, base_uv), roughness_texture_channel);\n";
  1527. }
  1528. code += R"( ROUGHNESS = roughness_tex * roughness;
  1529. )";
  1530. } else {
  1531. if (flags[FLAG_UV1_USE_TRIPLANAR]) {
  1532. code += R"(
  1533. vec4 orm_tex = triplanar_texture(texture_orm, uv1_power_normal, uv1_triplanar_pos);
  1534. )";
  1535. } else {
  1536. code += R"(
  1537. vec4 orm_tex = texture(texture_orm, base_uv);
  1538. )";
  1539. }
  1540. code += R"( ROUGHNESS = orm_tex.g;
  1541. METALLIC = orm_tex.b;
  1542. )";
  1543. }
  1544. if (features[FEATURE_NORMAL_MAPPING]) {
  1545. code += R"(
  1546. // Normal Map: Enabled
  1547. )";
  1548. if (flags[FLAG_UV1_USE_TRIPLANAR]) {
  1549. code += " NORMAL_MAP = triplanar_texture(texture_normal, uv1_power_normal, uv1_triplanar_pos).rgb;\n";
  1550. } else {
  1551. code += " NORMAL_MAP = texture(texture_normal, base_uv).rgb;\n";
  1552. }
  1553. code += " NORMAL_MAP_DEPTH = normal_scale;\n";
  1554. }
  1555. if (features[FEATURE_BENT_NORMAL_MAPPING]) {
  1556. code += R"(
  1557. // Bent Normal Map: Enabled
  1558. )";
  1559. if (flags[FLAG_UV1_USE_TRIPLANAR]) {
  1560. code += " BENT_NORMAL_MAP = triplanar_texture(texture_bent_normal, uv1_power_normal, uv1_triplanar_pos).rgb;\n";
  1561. } else {
  1562. code += " BENT_NORMAL_MAP = texture(texture_bent_normal, base_uv).rgb;\n";
  1563. }
  1564. }
  1565. if (features[FEATURE_EMISSION]) {
  1566. code += R"(
  1567. // Emission: Enabled
  1568. )";
  1569. if (flags[FLAG_EMISSION_ON_UV2]) {
  1570. if (flags[FLAG_UV2_USE_TRIPLANAR]) {
  1571. code += " vec3 emission_tex = triplanar_texture(texture_emission, uv2_power_normal, uv2_triplanar_pos).rgb;\n";
  1572. } else {
  1573. code += " vec3 emission_tex = texture(texture_emission, base_uv2).rgb;\n";
  1574. }
  1575. } else {
  1576. if (flags[FLAG_UV1_USE_TRIPLANAR]) {
  1577. code += " vec3 emission_tex = triplanar_texture(texture_emission, uv1_power_normal, uv1_triplanar_pos).rgb;\n";
  1578. } else {
  1579. code += " vec3 emission_tex = texture(texture_emission, base_uv).rgb;\n";
  1580. }
  1581. }
  1582. if (emission_op == EMISSION_OP_ADD) {
  1583. code += R"( // Emission Operator: Add
  1584. EMISSION = (emission.rgb + emission_tex) * emission_energy;
  1585. )";
  1586. } else {
  1587. code += R"( // Emission Operator: Multiply
  1588. EMISSION = (emission.rgb * emission_tex) * emission_energy;
  1589. )";
  1590. }
  1591. }
  1592. if (features[FEATURE_REFRACTION]) {
  1593. if (features[FEATURE_NORMAL_MAPPING]) {
  1594. code += R"(
  1595. // Refraction: Enabled (with normal map texture)
  1596. vec3 unpacked_normal = NORMAL_MAP;
  1597. unpacked_normal.xy = unpacked_normal.xy * 2.0 - 1.0;
  1598. unpacked_normal.z = sqrt(max(0.0, 1.0 - dot(unpacked_normal.xy, unpacked_normal.xy)));
  1599. vec3 ref_normal = normalize(mix(
  1600. NORMAL,
  1601. TANGENT * unpacked_normal.x + BINORMAL * unpacked_normal.y + NORMAL * unpacked_normal.z,
  1602. NORMAL_MAP_DEPTH));
  1603. )";
  1604. } else {
  1605. code += R"(
  1606. // Refraction: Enabled
  1607. vec3 ref_normal = NORMAL;
  1608. )";
  1609. }
  1610. if (flags[FLAG_UV1_USE_TRIPLANAR]) {
  1611. code += " vec2 ref_ofs = SCREEN_UV - ref_normal.xy * dot(triplanar_texture(texture_refraction, uv1_power_normal, uv1_triplanar_pos), refraction_texture_channel) * refraction;\n";
  1612. } else {
  1613. code += " vec2 ref_ofs = SCREEN_UV - ref_normal.xy * dot(texture(texture_refraction, base_uv), refraction_texture_channel) * refraction;\n";
  1614. }
  1615. code += R"(
  1616. float ref_amount = 1.0 - albedo.a * albedo_tex.a;
  1617. float refraction_depth_tex = textureLod(depth_texture, ref_ofs, 0.0).r;
  1618. vec4 refraction_view_pos = INV_PROJECTION_MATRIX * vec4(SCREEN_UV * 2.0 - 1.0, refraction_depth_tex, 1.0);
  1619. refraction_view_pos.xyz /= refraction_view_pos.w;
  1620. // If the depth buffer is lower then the model's Z position, use the refracted UV, otherwise use the normal screen UV.
  1621. // At low depth differences, decrease refraction intensity to avoid sudden discontinuities.
  1622. EMISSION += textureLod(screen_texture, mix(SCREEN_UV, ref_ofs, smoothstep(0.0, 1.0, VERTEX.z - refraction_view_pos.z)), ROUGHNESS * 8.0).rgb * ref_amount * EXPOSURE;
  1623. ALBEDO *= 1.0 - ref_amount;
  1624. // Force transparency on the material (required for refraction).
  1625. ALPHA = 1.0;
  1626. )";
  1627. } else if (transparency != TRANSPARENCY_DISABLED || flags[FLAG_USE_SHADOW_TO_OPACITY] || (distance_fade == DISTANCE_FADE_PIXEL_ALPHA) || proximity_fade_enabled) {
  1628. code += " ALPHA *= albedo.a * albedo_tex.a;\n";
  1629. }
  1630. if (transparency == TRANSPARENCY_ALPHA_HASH) {
  1631. code += " ALPHA_HASH_SCALE = alpha_hash_scale;\n";
  1632. } else if (transparency == TRANSPARENCY_ALPHA_SCISSOR) {
  1633. code += " ALPHA_SCISSOR_THRESHOLD = alpha_scissor_threshold;\n";
  1634. }
  1635. if (alpha_antialiasing_mode != ALPHA_ANTIALIASING_OFF && (transparency == TRANSPARENCY_ALPHA_HASH || transparency == TRANSPARENCY_ALPHA_SCISSOR)) {
  1636. code += " ALPHA_ANTIALIASING_EDGE = alpha_antialiasing_edge;\n";
  1637. code += " ALPHA_TEXTURE_COORDINATE = UV * vec2(albedo_texture_size);\n";
  1638. }
  1639. if (proximity_fade_enabled) {
  1640. code += R"(
  1641. // Proximity Fade: Enabled
  1642. float proximity_depth_tex = textureLod(depth_texture, SCREEN_UV, 0.0).r;
  1643. vec4 proximity_view_pos = INV_PROJECTION_MATRIX * vec4(SCREEN_UV * 2.0 - 1.0, proximity_depth_tex, 1.0);
  1644. proximity_view_pos.xyz /= proximity_view_pos.w;
  1645. ALPHA *= clamp(1.0 - smoothstep(proximity_view_pos.z + proximity_fade_distance, proximity_view_pos.z, VERTEX.z), 0.0, 1.0);
  1646. )";
  1647. }
  1648. if (distance_fade != DISTANCE_FADE_DISABLED) {
  1649. // Use the slightly more expensive circular fade (distance to the object) instead of linear
  1650. // (Z distance), so that the fade is always the same regardless of the camera angle.
  1651. if ((distance_fade == DISTANCE_FADE_OBJECT_DITHER || distance_fade == DISTANCE_FADE_PIXEL_DITHER)) {
  1652. code += "\n {";
  1653. if (distance_fade == DISTANCE_FADE_OBJECT_DITHER) {
  1654. code += R"(
  1655. // Distance Fade: Object Dither
  1656. float fade_distance = length((VIEW_MATRIX * MODEL_MATRIX[3]));
  1657. )";
  1658. } else {
  1659. code += R"(
  1660. // Distance Fade: Pixel Dither
  1661. float fade_distance = length(VERTEX);
  1662. )";
  1663. }
  1664. code += R"(
  1665. // Use interleaved gradient noise, which is fast but still looks good.
  1666. const vec3 magic = vec3(0.06711056, 0.00583715, 52.9829189);
  1667. float fade = clamp(smoothstep(distance_fade_min, distance_fade_max, fade_distance), 0.0, 1.0);
  1668. // Use a hard cap to prevent a few stray pixels from remaining when past the fade-out distance.
  1669. if (fade < 0.001 || fade < fract(magic.z * fract(dot(FRAGCOORD.xy, magic.xy)))) {
  1670. discard;
  1671. }
  1672. }
  1673. )";
  1674. } else {
  1675. code += R"(
  1676. // Distance Fade: Pixel Alpha
  1677. ALPHA *= clamp(smoothstep(distance_fade_min, distance_fade_max, length(VERTEX)), 0.0, 1.0);
  1678. )";
  1679. }
  1680. }
  1681. if (features[FEATURE_RIM]) {
  1682. code += R"(
  1683. // Rim: Enabled
  1684. )";
  1685. if (flags[FLAG_UV1_USE_TRIPLANAR]) {
  1686. code += " vec2 rim_tex = triplanar_texture(texture_rim, uv1_power_normal, uv1_triplanar_pos).xy;\n";
  1687. } else {
  1688. code += " vec2 rim_tex = texture(texture_rim, base_uv).xy;\n";
  1689. }
  1690. code += R"( RIM = rim * rim_tex.x;
  1691. RIM_TINT = rim_tint * rim_tex.y;
  1692. )";
  1693. }
  1694. if (features[FEATURE_CLEARCOAT]) {
  1695. code += R"(
  1696. // Clearcoat: Enabled
  1697. )";
  1698. if (flags[FLAG_UV1_USE_TRIPLANAR]) {
  1699. code += " vec2 clearcoat_tex = triplanar_texture(texture_clearcoat, uv1_power_normal, uv1_triplanar_pos).xy;\n";
  1700. } else {
  1701. code += " vec2 clearcoat_tex = texture(texture_clearcoat, base_uv).xy;\n";
  1702. }
  1703. code += R"( CLEARCOAT = clearcoat * clearcoat_tex.x;
  1704. CLEARCOAT_ROUGHNESS = clearcoat_roughness * clearcoat_tex.y;
  1705. )";
  1706. }
  1707. if (features[FEATURE_ANISOTROPY]) {
  1708. code += R"(
  1709. // Anisotropy: Enabled
  1710. )";
  1711. if (flags[FLAG_UV1_USE_TRIPLANAR]) {
  1712. code += " vec3 anisotropy_tex = triplanar_texture(texture_flowmap, uv1_power_normal, uv1_triplanar_pos).rga;\n";
  1713. } else {
  1714. code += " vec3 anisotropy_tex = texture(texture_flowmap, base_uv).rga;\n";
  1715. }
  1716. code += R"( ANISOTROPY = anisotropy_ratio * anisotropy_tex.b;
  1717. ANISOTROPY_FLOW = anisotropy_tex.rg * 2.0 - 1.0;
  1718. )";
  1719. }
  1720. if (features[FEATURE_AMBIENT_OCCLUSION]) {
  1721. code += R"(
  1722. // Ambient Occlusion: Enabled
  1723. )";
  1724. if (!orm) {
  1725. if (flags[FLAG_AO_ON_UV2]) {
  1726. if (flags[FLAG_UV2_USE_TRIPLANAR]) {
  1727. code += " AO = dot(triplanar_texture(texture_ambient_occlusion, uv2_power_normal, uv2_triplanar_pos), ao_texture_channel);\n";
  1728. } else {
  1729. code += " AO = dot(texture(texture_ambient_occlusion, base_uv2), ao_texture_channel);\n";
  1730. }
  1731. } else {
  1732. if (flags[FLAG_UV1_USE_TRIPLANAR]) {
  1733. code += " AO = dot(triplanar_texture(texture_ambient_occlusion, uv1_power_normal, uv1_triplanar_pos), ao_texture_channel);\n";
  1734. } else {
  1735. code += " AO = dot(texture(texture_ambient_occlusion, base_uv), ao_texture_channel);\n";
  1736. }
  1737. }
  1738. } else {
  1739. code += " AO = orm_tex.r;\n";
  1740. }
  1741. code += " AO_LIGHT_AFFECT = ao_light_affect;\n";
  1742. }
  1743. if (features[FEATURE_SUBSURFACE_SCATTERING]) {
  1744. code += R"(
  1745. // Subsurface Scattering: Enabled
  1746. )";
  1747. if (flags[FLAG_UV1_USE_TRIPLANAR]) {
  1748. code += " float sss_tex = triplanar_texture(texture_subsurface_scattering, uv1_power_normal, uv1_triplanar_pos).r;\n";
  1749. } else {
  1750. code += " float sss_tex = texture(texture_subsurface_scattering, base_uv).r;\n";
  1751. }
  1752. code += " SSS_STRENGTH = subsurface_scattering_strength * sss_tex;\n";
  1753. }
  1754. if (features[FEATURE_SUBSURFACE_TRANSMITTANCE]) {
  1755. code += R"(
  1756. // Subsurface Scattering Transmittance: Enabled
  1757. )";
  1758. if (flags[FLAG_UV1_USE_TRIPLANAR]) {
  1759. code += " vec4 trans_color_tex = triplanar_texture(texture_subsurface_transmittance, uv1_power_normal, uv1_triplanar_pos);\n";
  1760. } else {
  1761. code += " vec4 trans_color_tex = texture(texture_subsurface_transmittance, base_uv);\n";
  1762. }
  1763. code += " SSS_TRANSMITTANCE_COLOR = transmittance_color * trans_color_tex;\n";
  1764. code += R"( SSS_TRANSMITTANCE_DEPTH = transmittance_depth;
  1765. SSS_TRANSMITTANCE_BOOST = transmittance_boost;
  1766. )";
  1767. }
  1768. if (features[FEATURE_BACKLIGHT]) {
  1769. code += R"(
  1770. // Backlight: Enabled
  1771. )";
  1772. if (flags[FLAG_UV1_USE_TRIPLANAR]) {
  1773. code += " vec3 backlight_tex = triplanar_texture(texture_backlight, uv1_power_normal, uv1_triplanar_pos).rgb;\n";
  1774. } else {
  1775. code += " vec3 backlight_tex = texture(texture_backlight, base_uv).rgb;\n";
  1776. }
  1777. code += " BACKLIGHT = (backlight.rgb + backlight_tex);\n";
  1778. }
  1779. if (features[FEATURE_DETAIL]) {
  1780. code += R"(
  1781. // Detail: Enabled
  1782. )";
  1783. const bool triplanar = (flags[FLAG_UV1_USE_TRIPLANAR] && detail_uv == DETAIL_UV_1) || (flags[FLAG_UV2_USE_TRIPLANAR] && detail_uv == DETAIL_UV_2);
  1784. if (triplanar) {
  1785. const String tp_uv = detail_uv == DETAIL_UV_1 ? "uv1" : "uv2";
  1786. code += vformat(R"( vec4 detail_tex = triplanar_texture(texture_detail_albedo, %s_power_normal, %s_triplanar_pos);
  1787. vec4 detail_norm_tex = triplanar_texture(texture_detail_normal, %s_power_normal, %s_triplanar_pos);
  1788. )",
  1789. tp_uv, tp_uv, tp_uv, tp_uv);
  1790. } else {
  1791. const String det_uv = detail_uv == DETAIL_UV_1 ? "base_uv" : "base_uv2";
  1792. code += vformat(R"( vec4 detail_tex = texture(texture_detail_albedo, %s);
  1793. vec4 detail_norm_tex = texture(texture_detail_normal, %s);
  1794. )",
  1795. det_uv, det_uv);
  1796. }
  1797. if (flags[FLAG_UV1_USE_TRIPLANAR]) {
  1798. code += " vec4 detail_mask_tex = triplanar_texture(texture_detail_mask, uv1_power_normal, uv1_triplanar_pos);\n";
  1799. } else {
  1800. code += " vec4 detail_mask_tex = texture(texture_detail_mask, base_uv);\n";
  1801. }
  1802. switch (detail_blend_mode) {
  1803. case BLEND_MODE_MIX: {
  1804. code += R"(
  1805. // Detail Blend Mode: Mix
  1806. vec3 detail = mix(ALBEDO.rgb, detail_tex.rgb, detail_tex.a);
  1807. )";
  1808. } break;
  1809. case BLEND_MODE_ADD: {
  1810. code += R"(
  1811. // Detail Blend Mode: Add
  1812. vec3 detail = mix(ALBEDO.rgb, ALBEDO.rgb + detail_tex.rgb, detail_tex.a);
  1813. )";
  1814. } break;
  1815. case BLEND_MODE_SUB: {
  1816. code += R"(
  1817. // Detail Blend Mode: Subtract
  1818. vec3 detail = mix(ALBEDO.rgb, ALBEDO.rgb - detail_tex.rgb, detail_tex.a);
  1819. )";
  1820. } break;
  1821. case BLEND_MODE_MUL: {
  1822. code += R"(
  1823. // Detail Blend Mode: Multiply
  1824. vec3 detail = mix(ALBEDO.rgb, ALBEDO.rgb * detail_tex.rgb, detail_tex.a);
  1825. )";
  1826. } break;
  1827. case BLEND_MODE_PREMULT_ALPHA: {
  1828. // This is unlikely to ever be used for detail textures, and in order for it to function in the editor, another bit must be used in MaterialKey,
  1829. // but there are only 5 bits left, so I'm going to leave this disabled unless it's actually requested.
  1830. //code += "\tvec3 detail = (1.0-detail_tex.a)*ALBEDO.rgb+detail_tex.rgb;\n";
  1831. } break;
  1832. case BLEND_MODE_MAX:
  1833. break; // Internal value, skip.
  1834. }
  1835. code += R"( vec3 detail_norm = mix(NORMAL_MAP, detail_norm_tex.rgb, detail_tex.a);
  1836. NORMAL_MAP = mix(NORMAL_MAP, detail_norm, detail_mask_tex.r);
  1837. ALBEDO.rgb = mix(ALBEDO.rgb, detail, detail_mask_tex.r);
  1838. )";
  1839. }
  1840. code += "}\n";
  1841. // We must create the shader outside the shader_map_mutex to avoid potential deadlocks with
  1842. // other tasks in the WorkerThreadPool simultaneously creating materials, which
  1843. // may also hold the shared shader_map_mutex lock.
  1844. RID new_shader = RS::get_singleton()->shader_create_from_code(code);
  1845. MutexLock lock(shader_map_mutex);
  1846. ShaderData *v = shader_map.getptr(mk);
  1847. if (unlikely(v)) {
  1848. // We raced and managed to create the same key concurrently, so we'll free the shader we just created,
  1849. // given we know it isn't used, and use the winner.
  1850. RS::get_singleton()->free(new_shader);
  1851. } else {
  1852. ShaderData shader_data;
  1853. shader_data.shader = new_shader;
  1854. // ShaderData will be inserted with a users count of 0, but we
  1855. // increment unconditionally outside this if block, whilst still under lock.
  1856. v = &shader_map.insert(mk, shader_data)->value;
  1857. }
  1858. shader_rid = v->shader;
  1859. v->users++;
  1860. if (_get_material().is_valid()) {
  1861. RS::get_singleton()->material_set_shader(_get_material(), shader_rid);
  1862. }
  1863. }
  1864. void BaseMaterial3D::_check_material_rid() {
  1865. MutexLock lock(material_rid_mutex);
  1866. if (_get_material().is_null()) {
  1867. RID next_pass_rid;
  1868. if (get_next_pass().is_valid()) {
  1869. next_pass_rid = get_next_pass()->get_rid();
  1870. }
  1871. _set_material(RS::get_singleton()->material_create_from_shader(next_pass_rid, get_render_priority(), shader_rid));
  1872. for (KeyValue<StringName, Variant> param : pending_params) {
  1873. RS::get_singleton()->material_set_param(_get_material(), param.key, param.value);
  1874. }
  1875. pending_params.clear();
  1876. }
  1877. }
  1878. void BaseMaterial3D::flush_changes() {
  1879. SelfList<BaseMaterial3D>::List copy;
  1880. {
  1881. MutexLock lock(material_mutex);
  1882. while (SelfList<BaseMaterial3D> *E = dirty_materials.first()) {
  1883. dirty_materials.remove(E);
  1884. copy.add(E);
  1885. }
  1886. }
  1887. while (SelfList<BaseMaterial3D> *E = copy.first()) {
  1888. E->self()->_update_shader();
  1889. copy.remove(E);
  1890. }
  1891. }
  1892. void BaseMaterial3D::_queue_shader_change() {
  1893. if (!_is_initialized()) {
  1894. return;
  1895. }
  1896. MutexLock lock(material_mutex);
  1897. if (!element.in_list()) {
  1898. dirty_materials.add(&element);
  1899. }
  1900. }
  1901. void BaseMaterial3D::_material_set_param(const StringName &p_name, const Variant &p_value) {
  1902. if (_get_material().is_valid()) {
  1903. RS::get_singleton()->material_set_param(_get_material(), p_name, p_value);
  1904. } else {
  1905. pending_params[p_name] = p_value;
  1906. }
  1907. }
  1908. void BaseMaterial3D::set_albedo(const Color &p_albedo) {
  1909. albedo = p_albedo;
  1910. _material_set_param(shader_names->albedo, p_albedo);
  1911. }
  1912. Color BaseMaterial3D::get_albedo() const {
  1913. return albedo;
  1914. }
  1915. void BaseMaterial3D::set_specular(float p_specular) {
  1916. specular = p_specular;
  1917. _material_set_param(shader_names->specular, p_specular);
  1918. }
  1919. float BaseMaterial3D::get_specular() const {
  1920. return specular;
  1921. }
  1922. void BaseMaterial3D::set_roughness(float p_roughness) {
  1923. roughness = p_roughness;
  1924. _material_set_param(shader_names->roughness, p_roughness);
  1925. }
  1926. float BaseMaterial3D::get_roughness() const {
  1927. return roughness;
  1928. }
  1929. void BaseMaterial3D::set_metallic(float p_metallic) {
  1930. metallic = p_metallic;
  1931. _material_set_param(shader_names->metallic, p_metallic);
  1932. }
  1933. float BaseMaterial3D::get_metallic() const {
  1934. return metallic;
  1935. }
  1936. void BaseMaterial3D::set_emission(const Color &p_emission) {
  1937. emission = p_emission;
  1938. _material_set_param(shader_names->emission, p_emission);
  1939. }
  1940. Color BaseMaterial3D::get_emission() const {
  1941. return emission;
  1942. }
  1943. void BaseMaterial3D::set_emission_energy_multiplier(float p_emission_energy_multiplier) {
  1944. emission_energy_multiplier = p_emission_energy_multiplier;
  1945. if (GLOBAL_GET_CACHED(bool, "rendering/lights_and_shadows/use_physical_light_units")) {
  1946. _material_set_param(shader_names->emission_energy, p_emission_energy_multiplier * emission_intensity);
  1947. } else {
  1948. _material_set_param(shader_names->emission_energy, p_emission_energy_multiplier);
  1949. }
  1950. }
  1951. float BaseMaterial3D::get_emission_energy_multiplier() const {
  1952. return emission_energy_multiplier;
  1953. }
  1954. void BaseMaterial3D::set_emission_intensity(float p_emission_intensity) {
  1955. ERR_FAIL_COND_EDMSG(!GLOBAL_GET_CACHED(bool, "rendering/lights_and_shadows/use_physical_light_units"), "Cannot set material emission intensity when Physical Light Units disabled.");
  1956. emission_intensity = p_emission_intensity;
  1957. _material_set_param(shader_names->emission_energy, emission_energy_multiplier * emission_intensity);
  1958. }
  1959. float BaseMaterial3D::get_emission_intensity() const {
  1960. return emission_intensity;
  1961. }
  1962. void BaseMaterial3D::set_normal_scale(float p_normal_scale) {
  1963. normal_scale = p_normal_scale;
  1964. _material_set_param(shader_names->normal_scale, p_normal_scale);
  1965. }
  1966. float BaseMaterial3D::get_normal_scale() const {
  1967. return normal_scale;
  1968. }
  1969. void BaseMaterial3D::set_rim(float p_rim) {
  1970. rim = p_rim;
  1971. _material_set_param(shader_names->rim, p_rim);
  1972. }
  1973. float BaseMaterial3D::get_rim() const {
  1974. return rim;
  1975. }
  1976. void BaseMaterial3D::set_rim_tint(float p_rim_tint) {
  1977. rim_tint = p_rim_tint;
  1978. _material_set_param(shader_names->rim_tint, p_rim_tint);
  1979. }
  1980. float BaseMaterial3D::get_rim_tint() const {
  1981. return rim_tint;
  1982. }
  1983. void BaseMaterial3D::set_ao_light_affect(float p_ao_light_affect) {
  1984. ao_light_affect = p_ao_light_affect;
  1985. _material_set_param(shader_names->ao_light_affect, p_ao_light_affect);
  1986. }
  1987. float BaseMaterial3D::get_ao_light_affect() const {
  1988. return ao_light_affect;
  1989. }
  1990. void BaseMaterial3D::set_clearcoat(float p_clearcoat) {
  1991. clearcoat = p_clearcoat;
  1992. _material_set_param(shader_names->clearcoat, p_clearcoat);
  1993. }
  1994. float BaseMaterial3D::get_clearcoat() const {
  1995. return clearcoat;
  1996. }
  1997. void BaseMaterial3D::set_clearcoat_roughness(float p_clearcoat_roughness) {
  1998. clearcoat_roughness = p_clearcoat_roughness;
  1999. _material_set_param(shader_names->clearcoat_roughness, p_clearcoat_roughness);
  2000. }
  2001. float BaseMaterial3D::get_clearcoat_roughness() const {
  2002. return clearcoat_roughness;
  2003. }
  2004. void BaseMaterial3D::set_anisotropy(float p_anisotropy) {
  2005. anisotropy = p_anisotropy;
  2006. _material_set_param(shader_names->anisotropy, p_anisotropy);
  2007. }
  2008. float BaseMaterial3D::get_anisotropy() const {
  2009. return anisotropy;
  2010. }
  2011. void BaseMaterial3D::set_heightmap_scale(float p_heightmap_scale) {
  2012. heightmap_scale = p_heightmap_scale;
  2013. _material_set_param(shader_names->heightmap_scale, p_heightmap_scale);
  2014. }
  2015. float BaseMaterial3D::get_heightmap_scale() const {
  2016. return heightmap_scale;
  2017. }
  2018. void BaseMaterial3D::set_subsurface_scattering_strength(float p_subsurface_scattering_strength) {
  2019. subsurface_scattering_strength = p_subsurface_scattering_strength;
  2020. _material_set_param(shader_names->subsurface_scattering_strength, subsurface_scattering_strength);
  2021. }
  2022. float BaseMaterial3D::get_subsurface_scattering_strength() const {
  2023. return subsurface_scattering_strength;
  2024. }
  2025. void BaseMaterial3D::set_transmittance_color(const Color &p_color) {
  2026. transmittance_color = p_color;
  2027. _material_set_param(shader_names->transmittance_color, p_color);
  2028. }
  2029. Color BaseMaterial3D::get_transmittance_color() const {
  2030. return transmittance_color;
  2031. }
  2032. void BaseMaterial3D::set_transmittance_depth(float p_depth) {
  2033. transmittance_depth = p_depth;
  2034. _material_set_param(shader_names->transmittance_depth, p_depth);
  2035. }
  2036. float BaseMaterial3D::get_transmittance_depth() const {
  2037. return transmittance_depth;
  2038. }
  2039. void BaseMaterial3D::set_transmittance_boost(float p_boost) {
  2040. transmittance_boost = p_boost;
  2041. _material_set_param(shader_names->transmittance_boost, p_boost);
  2042. }
  2043. float BaseMaterial3D::get_transmittance_boost() const {
  2044. return transmittance_boost;
  2045. }
  2046. void BaseMaterial3D::set_backlight(const Color &p_backlight) {
  2047. backlight = p_backlight;
  2048. _material_set_param(shader_names->backlight, backlight);
  2049. }
  2050. Color BaseMaterial3D::get_backlight() const {
  2051. return backlight;
  2052. }
  2053. void BaseMaterial3D::set_refraction(float p_refraction) {
  2054. refraction = p_refraction;
  2055. _material_set_param(shader_names->refraction, refraction);
  2056. }
  2057. float BaseMaterial3D::get_refraction() const {
  2058. return refraction;
  2059. }
  2060. void BaseMaterial3D::set_detail_uv(DetailUV p_detail_uv) {
  2061. if (detail_uv == p_detail_uv) {
  2062. return;
  2063. }
  2064. detail_uv = p_detail_uv;
  2065. _queue_shader_change();
  2066. }
  2067. BaseMaterial3D::DetailUV BaseMaterial3D::get_detail_uv() const {
  2068. return detail_uv;
  2069. }
  2070. void BaseMaterial3D::set_blend_mode(BlendMode p_mode) {
  2071. if (blend_mode == p_mode) {
  2072. return;
  2073. }
  2074. blend_mode = p_mode;
  2075. _queue_shader_change();
  2076. }
  2077. BaseMaterial3D::BlendMode BaseMaterial3D::get_blend_mode() const {
  2078. return blend_mode;
  2079. }
  2080. void BaseMaterial3D::set_detail_blend_mode(BlendMode p_mode) {
  2081. detail_blend_mode = p_mode;
  2082. _queue_shader_change();
  2083. }
  2084. BaseMaterial3D::BlendMode BaseMaterial3D::get_detail_blend_mode() const {
  2085. return detail_blend_mode;
  2086. }
  2087. void BaseMaterial3D::set_transparency(Transparency p_transparency) {
  2088. if (transparency == p_transparency) {
  2089. return;
  2090. }
  2091. transparency = p_transparency;
  2092. _queue_shader_change();
  2093. notify_property_list_changed();
  2094. }
  2095. BaseMaterial3D::Transparency BaseMaterial3D::get_transparency() const {
  2096. return transparency;
  2097. }
  2098. void BaseMaterial3D::set_alpha_antialiasing(AlphaAntiAliasing p_alpha_aa) {
  2099. if (alpha_antialiasing_mode == p_alpha_aa) {
  2100. return;
  2101. }
  2102. alpha_antialiasing_mode = p_alpha_aa;
  2103. _queue_shader_change();
  2104. notify_property_list_changed();
  2105. }
  2106. BaseMaterial3D::AlphaAntiAliasing BaseMaterial3D::get_alpha_antialiasing() const {
  2107. return alpha_antialiasing_mode;
  2108. }
  2109. void BaseMaterial3D::set_shading_mode(ShadingMode p_shading_mode) {
  2110. if (shading_mode == p_shading_mode) {
  2111. return;
  2112. }
  2113. shading_mode = p_shading_mode;
  2114. _queue_shader_change();
  2115. notify_property_list_changed();
  2116. }
  2117. BaseMaterial3D::ShadingMode BaseMaterial3D::get_shading_mode() const {
  2118. return shading_mode;
  2119. }
  2120. void BaseMaterial3D::set_depth_draw_mode(DepthDrawMode p_mode) {
  2121. if (depth_draw_mode == p_mode) {
  2122. return;
  2123. }
  2124. depth_draw_mode = p_mode;
  2125. _queue_shader_change();
  2126. }
  2127. BaseMaterial3D::DepthDrawMode BaseMaterial3D::get_depth_draw_mode() const {
  2128. return depth_draw_mode;
  2129. }
  2130. void BaseMaterial3D::set_depth_test(DepthTest p_func) {
  2131. if (depth_test == p_func) {
  2132. return;
  2133. }
  2134. depth_test = p_func;
  2135. _queue_shader_change();
  2136. }
  2137. BaseMaterial3D::DepthTest BaseMaterial3D::get_depth_test() const {
  2138. return depth_test;
  2139. }
  2140. void BaseMaterial3D::set_cull_mode(CullMode p_mode) {
  2141. if (cull_mode == p_mode) {
  2142. return;
  2143. }
  2144. cull_mode = p_mode;
  2145. _queue_shader_change();
  2146. }
  2147. BaseMaterial3D::CullMode BaseMaterial3D::get_cull_mode() const {
  2148. return cull_mode;
  2149. }
  2150. void BaseMaterial3D::set_diffuse_mode(DiffuseMode p_mode) {
  2151. if (diffuse_mode == p_mode) {
  2152. return;
  2153. }
  2154. diffuse_mode = p_mode;
  2155. _queue_shader_change();
  2156. }
  2157. BaseMaterial3D::DiffuseMode BaseMaterial3D::get_diffuse_mode() const {
  2158. return diffuse_mode;
  2159. }
  2160. void BaseMaterial3D::set_specular_mode(SpecularMode p_mode) {
  2161. if (specular_mode == p_mode) {
  2162. return;
  2163. }
  2164. specular_mode = p_mode;
  2165. _queue_shader_change();
  2166. }
  2167. BaseMaterial3D::SpecularMode BaseMaterial3D::get_specular_mode() const {
  2168. return specular_mode;
  2169. }
  2170. void BaseMaterial3D::set_flag(Flags p_flag, bool p_enabled) {
  2171. ERR_FAIL_INDEX(p_flag, FLAG_MAX);
  2172. if (flags[p_flag] == p_enabled) {
  2173. return;
  2174. }
  2175. flags[p_flag] = p_enabled;
  2176. if (
  2177. p_flag == FLAG_USE_SHADOW_TO_OPACITY ||
  2178. p_flag == FLAG_USE_TEXTURE_REPEAT ||
  2179. p_flag == FLAG_SUBSURFACE_MODE_SKIN ||
  2180. p_flag == FLAG_USE_POINT_SIZE ||
  2181. p_flag == FLAG_UV1_USE_TRIPLANAR ||
  2182. p_flag == FLAG_UV2_USE_TRIPLANAR ||
  2183. p_flag == FLAG_USE_Z_CLIP_SCALE ||
  2184. p_flag == FLAG_USE_FOV_OVERRIDE ||
  2185. p_flag == FLAG_DISABLE_DEPTH_TEST) {
  2186. notify_property_list_changed();
  2187. }
  2188. if (p_flag == FLAG_PARTICLE_TRAILS_MODE) {
  2189. update_configuration_warning();
  2190. }
  2191. _queue_shader_change();
  2192. }
  2193. bool BaseMaterial3D::get_flag(Flags p_flag) const {
  2194. ERR_FAIL_INDEX_V(p_flag, FLAG_MAX, false);
  2195. return flags[p_flag];
  2196. }
  2197. void BaseMaterial3D::set_feature(Feature p_feature, bool p_enabled) {
  2198. ERR_FAIL_INDEX(p_feature, FEATURE_MAX);
  2199. if (features[p_feature] == p_enabled) {
  2200. return;
  2201. }
  2202. features[p_feature] = p_enabled;
  2203. _queue_shader_change();
  2204. }
  2205. bool BaseMaterial3D::get_feature(Feature p_feature) const {
  2206. ERR_FAIL_INDEX_V(p_feature, FEATURE_MAX, false);
  2207. return features[p_feature];
  2208. }
  2209. void BaseMaterial3D::set_texture(TextureParam p_param, const Ref<Texture2D> &p_texture) {
  2210. ERR_FAIL_INDEX(p_param, TEXTURE_MAX);
  2211. textures[p_param] = p_texture;
  2212. Variant rid = p_texture.is_valid() ? Variant(p_texture->get_rid()) : Variant();
  2213. _material_set_param(shader_names->texture_names[p_param], rid);
  2214. if (p_texture.is_valid() && p_param == TEXTURE_ALBEDO) {
  2215. _material_set_param(shader_names->albedo_texture_size, Vector2i(p_texture->get_width(), p_texture->get_height()));
  2216. }
  2217. notify_property_list_changed();
  2218. _queue_shader_change();
  2219. }
  2220. Ref<Texture2D> BaseMaterial3D::get_texture(TextureParam p_param) const {
  2221. ERR_FAIL_INDEX_V(p_param, TEXTURE_MAX, Ref<Texture2D>());
  2222. return textures[p_param];
  2223. }
  2224. Ref<Texture2D> BaseMaterial3D::get_texture_by_name(const StringName &p_name) const {
  2225. for (int i = 0; i < (int)BaseMaterial3D::TEXTURE_MAX; i++) {
  2226. TextureParam param = TextureParam(i);
  2227. if (p_name == shader_names->texture_names[param]) {
  2228. return textures[param];
  2229. }
  2230. }
  2231. return Ref<Texture2D>();
  2232. }
  2233. void BaseMaterial3D::set_texture_filter(TextureFilter p_filter) {
  2234. texture_filter = p_filter;
  2235. _queue_shader_change();
  2236. }
  2237. BaseMaterial3D::TextureFilter BaseMaterial3D::get_texture_filter() const {
  2238. return texture_filter;
  2239. }
  2240. void BaseMaterial3D::_validate_property(PropertyInfo &p_property) const {
  2241. if (p_property.name == "emission_intensity" && !GLOBAL_GET_CACHED(bool, "rendering/lights_and_shadows/use_physical_light_units")) {
  2242. p_property.usage = PROPERTY_USAGE_NONE;
  2243. }
  2244. if (p_property.name.begins_with("particles_anim_") && billboard_mode != BILLBOARD_PARTICLES) {
  2245. p_property.usage = PROPERTY_USAGE_NONE;
  2246. }
  2247. if (Engine::get_singleton()->is_editor_hint()) {
  2248. if (p_property.name == "billboard_keep_scale" && billboard_mode == BILLBOARD_DISABLED) {
  2249. p_property.usage = PROPERTY_USAGE_NO_EDITOR;
  2250. }
  2251. if (p_property.name == "grow_amount" && !grow_enabled) {
  2252. p_property.usage = PROPERTY_USAGE_NO_EDITOR;
  2253. }
  2254. if (p_property.name == "point_size" && !flags[FLAG_USE_POINT_SIZE]) {
  2255. p_property.usage = PROPERTY_USAGE_NO_EDITOR;
  2256. }
  2257. if (p_property.name == "proximity_fade_distance" && !proximity_fade_enabled) {
  2258. p_property.usage = PROPERTY_USAGE_NO_EDITOR;
  2259. }
  2260. if (p_property.name == "msdf_pixel_range" && !flags[FLAG_ALBEDO_TEXTURE_MSDF]) {
  2261. p_property.usage = PROPERTY_USAGE_NO_EDITOR;
  2262. }
  2263. if (p_property.name == "msdf_outline_size" && !flags[FLAG_ALBEDO_TEXTURE_MSDF]) {
  2264. p_property.usage = PROPERTY_USAGE_NO_EDITOR;
  2265. }
  2266. if ((p_property.name == "distance_fade_max_distance" || p_property.name == "distance_fade_min_distance") && distance_fade == DISTANCE_FADE_DISABLED) {
  2267. p_property.usage = PROPERTY_USAGE_NO_EDITOR;
  2268. }
  2269. if ((p_property.name == "uv1_triplanar_sharpness" || p_property.name == "uv1_world_triplanar") && !flags[FLAG_UV1_USE_TRIPLANAR]) {
  2270. p_property.usage = PROPERTY_USAGE_NO_EDITOR;
  2271. }
  2272. if ((p_property.name == "uv2_triplanar_sharpness" || p_property.name == "uv2_world_triplanar") && !flags[FLAG_UV2_USE_TRIPLANAR]) {
  2273. p_property.usage = PROPERTY_USAGE_NO_EDITOR;
  2274. }
  2275. if (p_property.name == "z_clip_scale" && !flags[FLAG_USE_Z_CLIP_SCALE]) {
  2276. p_property.usage = PROPERTY_USAGE_NO_EDITOR;
  2277. }
  2278. if (p_property.name == "fov_override" && !flags[FLAG_USE_FOV_OVERRIDE]) {
  2279. p_property.usage = PROPERTY_USAGE_NO_EDITOR;
  2280. }
  2281. }
  2282. // you can only enable anti-aliasing (in materials) on alpha scissor and alpha hash
  2283. const bool can_select_aa = (transparency == TRANSPARENCY_ALPHA_SCISSOR || transparency == TRANSPARENCY_ALPHA_HASH);
  2284. // alpha anti aliasiasing is only enabled when you can select aa
  2285. const bool alpha_aa_enabled = (alpha_antialiasing_mode != ALPHA_ANTIALIASING_OFF) && can_select_aa;
  2286. // alpha scissor slider isn't needed when alpha antialiasing is enabled
  2287. if (p_property.name == "alpha_scissor_threshold" && transparency != TRANSPARENCY_ALPHA_SCISSOR) {
  2288. p_property.usage = PROPERTY_USAGE_NONE;
  2289. }
  2290. // alpha hash scale slider is only needed if transparency is alpha hash
  2291. if (p_property.name == "alpha_hash_scale" && transparency != TRANSPARENCY_ALPHA_HASH) {
  2292. p_property.usage = PROPERTY_USAGE_NONE;
  2293. }
  2294. if (p_property.name == "alpha_antialiasing_mode" && !can_select_aa) {
  2295. p_property.usage = PROPERTY_USAGE_NONE;
  2296. }
  2297. // we can't choose an antialiasing mode if alpha isn't possible
  2298. if (p_property.name == "alpha_antialiasing_edge" && !alpha_aa_enabled) {
  2299. p_property.usage = PROPERTY_USAGE_NONE;
  2300. }
  2301. if (p_property.name == "blend_mode" && alpha_aa_enabled) {
  2302. p_property.usage = PROPERTY_USAGE_NONE;
  2303. }
  2304. if ((p_property.name == "heightmap_min_layers" || p_property.name == "heightmap_max_layers") && !deep_parallax) {
  2305. p_property.usage = PROPERTY_USAGE_NONE;
  2306. }
  2307. if (Engine::get_singleton()->is_editor_hint()) {
  2308. if (p_property.name == "depth_test" && flags[FLAG_DISABLE_DEPTH_TEST]) {
  2309. p_property.usage = PROPERTY_USAGE_NO_EDITOR;
  2310. }
  2311. if (p_property.name == "stencil_reference" && stencil_mode == STENCIL_MODE_DISABLED) {
  2312. p_property.usage = PROPERTY_USAGE_NO_EDITOR;
  2313. }
  2314. if ((p_property.name == "stencil_flags" || p_property.name == "stencil_compare") && stencil_mode != STENCIL_MODE_CUSTOM) {
  2315. p_property.usage = PROPERTY_USAGE_NO_EDITOR;
  2316. }
  2317. if (p_property.name == "stencil_color" && stencil_mode != STENCIL_MODE_OUTLINE && stencil_mode != STENCIL_MODE_XRAY) {
  2318. p_property.usage = PROPERTY_USAGE_NO_EDITOR;
  2319. }
  2320. if (p_property.name == "stencil_outline_thickness" && stencil_mode != STENCIL_MODE_OUTLINE) {
  2321. p_property.usage = PROPERTY_USAGE_NO_EDITOR;
  2322. }
  2323. }
  2324. if (flags[FLAG_SUBSURFACE_MODE_SKIN] && (p_property.name == "subsurf_scatter_transmittance_color" || p_property.name == "subsurf_scatter_transmittance_texture")) {
  2325. p_property.usage = PROPERTY_USAGE_NONE;
  2326. }
  2327. if (orm) {
  2328. if (p_property.name == "shading_mode") {
  2329. // Vertex not supported in ORM mode, since no individual roughness.
  2330. p_property.hint_string = "Unshaded,Per-Pixel";
  2331. }
  2332. if (p_property.name.begins_with("roughness") || p_property.name.begins_with("metallic") || p_property.name.begins_with("ao_texture")) {
  2333. p_property.usage = PROPERTY_USAGE_NONE;
  2334. }
  2335. } else {
  2336. if (p_property.name == "orm_texture") {
  2337. p_property.usage = PROPERTY_USAGE_NONE;
  2338. }
  2339. }
  2340. if (shading_mode != SHADING_MODE_PER_PIXEL) {
  2341. if (shading_mode != SHADING_MODE_PER_VERTEX) {
  2342. //these may still work per vertex
  2343. if (p_property.name.begins_with("ao")) {
  2344. p_property.usage = PROPERTY_USAGE_NONE;
  2345. }
  2346. if (p_property.name.begins_with("emission")) {
  2347. p_property.usage = PROPERTY_USAGE_NONE;
  2348. }
  2349. if (p_property.name.begins_with("metallic")) {
  2350. p_property.usage = PROPERTY_USAGE_NONE;
  2351. }
  2352. if (p_property.name.begins_with("rim")) {
  2353. p_property.usage = PROPERTY_USAGE_NONE;
  2354. }
  2355. if (p_property.name.begins_with("roughness")) {
  2356. p_property.usage = PROPERTY_USAGE_NONE;
  2357. }
  2358. if (p_property.name.begins_with("subsurf_scatter")) {
  2359. p_property.usage = PROPERTY_USAGE_NONE;
  2360. }
  2361. }
  2362. //these definitely only need per pixel
  2363. if (p_property.name.begins_with("anisotropy")) {
  2364. p_property.usage = PROPERTY_USAGE_NONE;
  2365. }
  2366. if (p_property.name.begins_with("clearcoat")) {
  2367. p_property.usage = PROPERTY_USAGE_NONE;
  2368. }
  2369. if (p_property.name.begins_with("normal")) {
  2370. p_property.usage = PROPERTY_USAGE_NONE;
  2371. }
  2372. if (p_property.name.begins_with("bent_normal")) {
  2373. p_property.usage = PROPERTY_USAGE_NONE;
  2374. }
  2375. if (p_property.name.begins_with("backlight")) {
  2376. p_property.usage = PROPERTY_USAGE_NONE;
  2377. }
  2378. if (p_property.name.begins_with("transmittance")) {
  2379. p_property.usage = PROPERTY_USAGE_NONE;
  2380. }
  2381. }
  2382. }
  2383. void BaseMaterial3D::set_point_size(float p_point_size) {
  2384. point_size = p_point_size;
  2385. _material_set_param(shader_names->point_size, p_point_size);
  2386. }
  2387. float BaseMaterial3D::get_point_size() const {
  2388. return point_size;
  2389. }
  2390. void BaseMaterial3D::set_uv1_scale(const Vector3 &p_scale) {
  2391. uv1_scale = p_scale;
  2392. _material_set_param(shader_names->uv1_scale, p_scale);
  2393. }
  2394. Vector3 BaseMaterial3D::get_uv1_scale() const {
  2395. return uv1_scale;
  2396. }
  2397. void BaseMaterial3D::set_uv1_offset(const Vector3 &p_offset) {
  2398. uv1_offset = p_offset;
  2399. _material_set_param(shader_names->uv1_offset, p_offset);
  2400. }
  2401. Vector3 BaseMaterial3D::get_uv1_offset() const {
  2402. return uv1_offset;
  2403. }
  2404. void BaseMaterial3D::set_uv1_triplanar_blend_sharpness(float p_sharpness) {
  2405. // Negative values or values higher than 150 can result in NaNs, leading to broken rendering.
  2406. uv1_triplanar_sharpness = CLAMP(p_sharpness, 0.0, 150.0);
  2407. _material_set_param(shader_names->uv1_blend_sharpness, uv1_triplanar_sharpness);
  2408. }
  2409. float BaseMaterial3D::get_uv1_triplanar_blend_sharpness() const {
  2410. return uv1_triplanar_sharpness;
  2411. }
  2412. void BaseMaterial3D::set_uv2_scale(const Vector3 &p_scale) {
  2413. uv2_scale = p_scale;
  2414. _material_set_param(shader_names->uv2_scale, p_scale);
  2415. }
  2416. Vector3 BaseMaterial3D::get_uv2_scale() const {
  2417. return uv2_scale;
  2418. }
  2419. void BaseMaterial3D::set_uv2_offset(const Vector3 &p_offset) {
  2420. uv2_offset = p_offset;
  2421. _material_set_param(shader_names->uv2_offset, p_offset);
  2422. }
  2423. Vector3 BaseMaterial3D::get_uv2_offset() const {
  2424. return uv2_offset;
  2425. }
  2426. void BaseMaterial3D::set_uv2_triplanar_blend_sharpness(float p_sharpness) {
  2427. // Negative values or values higher than 150 can result in NaNs, leading to broken rendering.
  2428. uv2_triplanar_sharpness = CLAMP(p_sharpness, 0.0, 150.0);
  2429. _material_set_param(shader_names->uv2_blend_sharpness, uv2_triplanar_sharpness);
  2430. }
  2431. float BaseMaterial3D::get_uv2_triplanar_blend_sharpness() const {
  2432. return uv2_triplanar_sharpness;
  2433. }
  2434. void BaseMaterial3D::set_billboard_mode(BillboardMode p_mode) {
  2435. billboard_mode = p_mode;
  2436. _queue_shader_change();
  2437. notify_property_list_changed();
  2438. }
  2439. BaseMaterial3D::BillboardMode BaseMaterial3D::get_billboard_mode() const {
  2440. return billboard_mode;
  2441. }
  2442. void BaseMaterial3D::set_particles_anim_h_frames(int p_frames) {
  2443. particles_anim_h_frames = p_frames;
  2444. _material_set_param(shader_names->particles_anim_h_frames, p_frames);
  2445. }
  2446. int BaseMaterial3D::get_particles_anim_h_frames() const {
  2447. return particles_anim_h_frames;
  2448. }
  2449. void BaseMaterial3D::set_particles_anim_v_frames(int p_frames) {
  2450. particles_anim_v_frames = p_frames;
  2451. _material_set_param(shader_names->particles_anim_v_frames, p_frames);
  2452. }
  2453. int BaseMaterial3D::get_particles_anim_v_frames() const {
  2454. return particles_anim_v_frames;
  2455. }
  2456. void BaseMaterial3D::set_particles_anim_loop(bool p_loop) {
  2457. particles_anim_loop = p_loop;
  2458. _material_set_param(shader_names->particles_anim_loop, particles_anim_loop);
  2459. }
  2460. bool BaseMaterial3D::get_particles_anim_loop() const {
  2461. return particles_anim_loop;
  2462. }
  2463. void BaseMaterial3D::set_heightmap_deep_parallax(bool p_enable) {
  2464. deep_parallax = p_enable;
  2465. _queue_shader_change();
  2466. notify_property_list_changed();
  2467. }
  2468. bool BaseMaterial3D::is_heightmap_deep_parallax_enabled() const {
  2469. return deep_parallax;
  2470. }
  2471. void BaseMaterial3D::set_heightmap_deep_parallax_min_layers(int p_layer) {
  2472. deep_parallax_min_layers = p_layer;
  2473. _material_set_param(shader_names->heightmap_min_layers, p_layer);
  2474. }
  2475. int BaseMaterial3D::get_heightmap_deep_parallax_min_layers() const {
  2476. return deep_parallax_min_layers;
  2477. }
  2478. void BaseMaterial3D::set_heightmap_deep_parallax_max_layers(int p_layer) {
  2479. deep_parallax_max_layers = p_layer;
  2480. _material_set_param(shader_names->heightmap_max_layers, p_layer);
  2481. }
  2482. int BaseMaterial3D::get_heightmap_deep_parallax_max_layers() const {
  2483. return deep_parallax_max_layers;
  2484. }
  2485. void BaseMaterial3D::set_heightmap_deep_parallax_flip_tangent(bool p_flip) {
  2486. heightmap_parallax_flip_tangent = p_flip;
  2487. _material_set_param(shader_names->heightmap_flip, Vector2(heightmap_parallax_flip_tangent ? -1 : 1, heightmap_parallax_flip_binormal ? -1 : 1));
  2488. }
  2489. bool BaseMaterial3D::get_heightmap_deep_parallax_flip_tangent() const {
  2490. return heightmap_parallax_flip_tangent;
  2491. }
  2492. void BaseMaterial3D::set_heightmap_deep_parallax_flip_binormal(bool p_flip) {
  2493. heightmap_parallax_flip_binormal = p_flip;
  2494. _material_set_param(shader_names->heightmap_flip, Vector2(heightmap_parallax_flip_tangent ? -1 : 1, heightmap_parallax_flip_binormal ? -1 : 1));
  2495. }
  2496. bool BaseMaterial3D::get_heightmap_deep_parallax_flip_binormal() const {
  2497. return heightmap_parallax_flip_binormal;
  2498. }
  2499. void BaseMaterial3D::set_grow_enabled(bool p_enable) {
  2500. grow_enabled = p_enable;
  2501. _queue_shader_change();
  2502. notify_property_list_changed();
  2503. }
  2504. bool BaseMaterial3D::is_grow_enabled() const {
  2505. return grow_enabled;
  2506. }
  2507. void BaseMaterial3D::set_alpha_scissor_threshold(float p_threshold) {
  2508. alpha_scissor_threshold = p_threshold;
  2509. _material_set_param(shader_names->alpha_scissor_threshold, p_threshold);
  2510. }
  2511. float BaseMaterial3D::get_alpha_scissor_threshold() const {
  2512. return alpha_scissor_threshold;
  2513. }
  2514. void BaseMaterial3D::set_alpha_hash_scale(float p_scale) {
  2515. alpha_hash_scale = p_scale;
  2516. _material_set_param(shader_names->alpha_hash_scale, p_scale);
  2517. }
  2518. float BaseMaterial3D::get_alpha_hash_scale() const {
  2519. return alpha_hash_scale;
  2520. }
  2521. void BaseMaterial3D::set_alpha_antialiasing_edge(float p_edge) {
  2522. alpha_antialiasing_edge = p_edge;
  2523. _material_set_param(shader_names->alpha_antialiasing_edge, p_edge);
  2524. }
  2525. float BaseMaterial3D::get_alpha_antialiasing_edge() const {
  2526. return alpha_antialiasing_edge;
  2527. }
  2528. void BaseMaterial3D::set_grow(float p_grow) {
  2529. grow = p_grow;
  2530. _material_set_param(shader_names->grow, p_grow);
  2531. }
  2532. float BaseMaterial3D::get_grow() const {
  2533. return grow;
  2534. }
  2535. static Vector4 _get_texture_mask(BaseMaterial3D::TextureChannel p_channel) {
  2536. static const Vector4 masks[5] = {
  2537. Vector4(1, 0, 0, 0),
  2538. Vector4(0, 1, 0, 0),
  2539. Vector4(0, 0, 1, 0),
  2540. Vector4(0, 0, 0, 1),
  2541. Vector4(0.3333333, 0.3333333, 0.3333333, 0),
  2542. };
  2543. return masks[p_channel];
  2544. }
  2545. void BaseMaterial3D::set_metallic_texture_channel(TextureChannel p_channel) {
  2546. ERR_FAIL_INDEX(p_channel, 5);
  2547. metallic_texture_channel = p_channel;
  2548. _material_set_param(shader_names->metallic_texture_channel, _get_texture_mask(p_channel));
  2549. }
  2550. BaseMaterial3D::TextureChannel BaseMaterial3D::get_metallic_texture_channel() const {
  2551. return metallic_texture_channel;
  2552. }
  2553. void BaseMaterial3D::set_roughness_texture_channel(TextureChannel p_channel) {
  2554. ERR_FAIL_INDEX(p_channel, 5);
  2555. roughness_texture_channel = p_channel;
  2556. _queue_shader_change();
  2557. }
  2558. BaseMaterial3D::TextureChannel BaseMaterial3D::get_roughness_texture_channel() const {
  2559. return roughness_texture_channel;
  2560. }
  2561. void BaseMaterial3D::set_ao_texture_channel(TextureChannel p_channel) {
  2562. ERR_FAIL_INDEX(p_channel, 5);
  2563. ao_texture_channel = p_channel;
  2564. _material_set_param(shader_names->ao_texture_channel, _get_texture_mask(p_channel));
  2565. }
  2566. BaseMaterial3D::TextureChannel BaseMaterial3D::get_ao_texture_channel() const {
  2567. return ao_texture_channel;
  2568. }
  2569. void BaseMaterial3D::set_refraction_texture_channel(TextureChannel p_channel) {
  2570. ERR_FAIL_INDEX(p_channel, 5);
  2571. refraction_texture_channel = p_channel;
  2572. _material_set_param(shader_names->refraction_texture_channel, _get_texture_mask(p_channel));
  2573. }
  2574. BaseMaterial3D::TextureChannel BaseMaterial3D::get_refraction_texture_channel() const {
  2575. return refraction_texture_channel;
  2576. }
  2577. void BaseMaterial3D::set_z_clip_scale(float p_z_clip_scale) {
  2578. z_clip_scale = p_z_clip_scale;
  2579. _material_set_param(shader_names->z_clip_scale, p_z_clip_scale);
  2580. }
  2581. float BaseMaterial3D::get_z_clip_scale() const {
  2582. return z_clip_scale;
  2583. }
  2584. void BaseMaterial3D::set_fov_override(float p_fov_override) {
  2585. fov_override = p_fov_override;
  2586. _material_set_param(shader_names->fov_override, p_fov_override);
  2587. }
  2588. float BaseMaterial3D::get_fov_override() const {
  2589. return fov_override;
  2590. }
  2591. Ref<Material> BaseMaterial3D::get_material_for_2d(bool p_shaded, Transparency p_transparency, bool p_double_sided, bool p_billboard, bool p_billboard_y, bool p_msdf, bool p_no_depth, bool p_fixed_size, TextureFilter p_filter, AlphaAntiAliasing p_alpha_antialiasing_mode, RID *r_shader_rid) {
  2592. uint64_t key = 0;
  2593. key |= ((int8_t)p_shaded & 0x01) << 0;
  2594. key |= ((int8_t)p_transparency & 0x07) << 1; // Bits 1-3.
  2595. key |= ((int8_t)p_double_sided & 0x01) << 4;
  2596. key |= ((int8_t)p_billboard & 0x01) << 5;
  2597. key |= ((int8_t)p_billboard_y & 0x01) << 6;
  2598. key |= ((int8_t)p_msdf & 0x01) << 7;
  2599. key |= ((int8_t)p_no_depth & 0x01) << 8;
  2600. key |= ((int8_t)p_fixed_size & 0x01) << 9;
  2601. key |= ((int8_t)p_filter & 0x07) << 10; // Bits 10-12.
  2602. key |= ((int8_t)p_alpha_antialiasing_mode & 0x07) << 13; // Bits 13-15.
  2603. if (materials_for_2d.has(key)) {
  2604. if (r_shader_rid) {
  2605. *r_shader_rid = materials_for_2d[key]->get_shader_rid();
  2606. }
  2607. return materials_for_2d[key];
  2608. }
  2609. Ref<StandardMaterial3D> material;
  2610. material.instantiate();
  2611. material->set_shading_mode(p_shaded ? SHADING_MODE_PER_PIXEL : SHADING_MODE_UNSHADED);
  2612. material->set_transparency(p_transparency);
  2613. material->set_cull_mode(p_double_sided ? CULL_DISABLED : CULL_BACK);
  2614. material->set_flag(FLAG_SRGB_VERTEX_COLOR, true);
  2615. material->set_flag(FLAG_ALBEDO_FROM_VERTEX_COLOR, true);
  2616. material->set_flag(FLAG_ALBEDO_TEXTURE_MSDF, p_msdf);
  2617. material->set_flag(FLAG_DISABLE_DEPTH_TEST, p_no_depth);
  2618. material->set_flag(FLAG_FIXED_SIZE, p_fixed_size);
  2619. material->set_alpha_antialiasing(p_alpha_antialiasing_mode);
  2620. material->set_texture_filter(p_filter);
  2621. if (p_billboard || p_billboard_y) {
  2622. material->set_flag(FLAG_BILLBOARD_KEEP_SCALE, true);
  2623. material->set_billboard_mode(p_billboard_y ? BILLBOARD_FIXED_Y : BILLBOARD_ENABLED);
  2624. }
  2625. materials_for_2d[key] = material;
  2626. if (r_shader_rid) {
  2627. *r_shader_rid = materials_for_2d[key]->get_shader_rid();
  2628. }
  2629. return materials_for_2d[key];
  2630. }
  2631. void BaseMaterial3D::set_on_top_of_alpha() {
  2632. set_transparency(TRANSPARENCY_DISABLED);
  2633. set_render_priority(RENDER_PRIORITY_MAX);
  2634. set_flag(FLAG_DISABLE_DEPTH_TEST, true);
  2635. }
  2636. void BaseMaterial3D::set_proximity_fade_enabled(bool p_enable) {
  2637. proximity_fade_enabled = p_enable;
  2638. _queue_shader_change();
  2639. notify_property_list_changed();
  2640. }
  2641. bool BaseMaterial3D::is_proximity_fade_enabled() const {
  2642. return proximity_fade_enabled;
  2643. }
  2644. void BaseMaterial3D::set_proximity_fade_distance(float p_distance) {
  2645. proximity_fade_distance = MAX(p_distance, 0.01);
  2646. _material_set_param(shader_names->proximity_fade_distance, proximity_fade_distance);
  2647. }
  2648. float BaseMaterial3D::get_proximity_fade_distance() const {
  2649. return proximity_fade_distance;
  2650. }
  2651. void BaseMaterial3D::set_msdf_pixel_range(float p_range) {
  2652. msdf_pixel_range = p_range;
  2653. _material_set_param(shader_names->msdf_pixel_range, p_range);
  2654. }
  2655. float BaseMaterial3D::get_msdf_pixel_range() const {
  2656. return msdf_pixel_range;
  2657. }
  2658. void BaseMaterial3D::set_msdf_outline_size(float p_size) {
  2659. msdf_outline_size = p_size;
  2660. _material_set_param(shader_names->msdf_outline_size, p_size);
  2661. }
  2662. float BaseMaterial3D::get_msdf_outline_size() const {
  2663. return msdf_outline_size;
  2664. }
  2665. void BaseMaterial3D::set_distance_fade(DistanceFadeMode p_mode) {
  2666. distance_fade = p_mode;
  2667. _queue_shader_change();
  2668. notify_property_list_changed();
  2669. }
  2670. BaseMaterial3D::DistanceFadeMode BaseMaterial3D::get_distance_fade() const {
  2671. return distance_fade;
  2672. }
  2673. void BaseMaterial3D::set_distance_fade_max_distance(float p_distance) {
  2674. distance_fade_max_distance = p_distance;
  2675. _material_set_param(shader_names->distance_fade_max, distance_fade_max_distance);
  2676. }
  2677. float BaseMaterial3D::get_distance_fade_max_distance() const {
  2678. return distance_fade_max_distance;
  2679. }
  2680. void BaseMaterial3D::set_distance_fade_min_distance(float p_distance) {
  2681. distance_fade_min_distance = p_distance;
  2682. _material_set_param(shader_names->distance_fade_min, distance_fade_min_distance);
  2683. }
  2684. float BaseMaterial3D::get_distance_fade_min_distance() const {
  2685. return distance_fade_min_distance;
  2686. }
  2687. void BaseMaterial3D::set_emission_operator(EmissionOperator p_op) {
  2688. if (emission_op == p_op) {
  2689. return;
  2690. }
  2691. emission_op = p_op;
  2692. _queue_shader_change();
  2693. }
  2694. BaseMaterial3D::EmissionOperator BaseMaterial3D::get_emission_operator() const {
  2695. return emission_op;
  2696. }
  2697. RID BaseMaterial3D::get_rid() const {
  2698. const_cast<BaseMaterial3D *>(this)->_update_shader();
  2699. const_cast<BaseMaterial3D *>(this)->_check_material_rid();
  2700. return _get_material();
  2701. }
  2702. void BaseMaterial3D::_prepare_stencil_effect() {
  2703. const Ref<Material> current_next_pass = get_next_pass();
  2704. if (stencil_mode == STENCIL_MODE_DISABLED || stencil_mode == STENCIL_MODE_CUSTOM) {
  2705. if (current_next_pass.is_valid() && current_next_pass->has_meta("_stencil_owned")) {
  2706. set_next_pass(current_next_pass->get_next_pass());
  2707. }
  2708. return;
  2709. }
  2710. Ref<BaseMaterial3D> stencil_next_pass;
  2711. if (current_next_pass.is_null() || !current_next_pass->has_meta("_stencil_owned")) {
  2712. stencil_next_pass = Ref<BaseMaterial3D>(memnew(StandardMaterial3D));
  2713. stencil_next_pass->set_meta("_stencil_owned", true);
  2714. stencil_next_pass->set_next_pass(current_next_pass);
  2715. set_next_pass(stencil_next_pass);
  2716. } else {
  2717. stencil_next_pass = current_next_pass;
  2718. }
  2719. switch (stencil_mode) {
  2720. case STENCIL_MODE_DISABLED:
  2721. break;
  2722. case STENCIL_MODE_OUTLINE:
  2723. set_stencil_flags(STENCIL_FLAG_WRITE);
  2724. set_stencil_compare(STENCIL_COMPARE_ALWAYS);
  2725. stencil_next_pass->set_render_priority(get_render_priority() + 1);
  2726. stencil_next_pass->set_shading_mode(SHADING_MODE_UNSHADED);
  2727. stencil_next_pass->set_transparency(TRANSPARENCY_ALPHA);
  2728. stencil_next_pass->set_flag(FLAG_DISABLE_DEPTH_TEST, false);
  2729. stencil_next_pass->set_grow_enabled(true);
  2730. stencil_next_pass->set_grow(stencil_effect_outline_thickness);
  2731. stencil_next_pass->set_albedo(stencil_effect_color);
  2732. stencil_next_pass->set_stencil_mode(STENCIL_MODE_CUSTOM);
  2733. stencil_next_pass->set_stencil_flags(STENCIL_FLAG_READ);
  2734. stencil_next_pass->set_stencil_compare(STENCIL_COMPARE_NOT_EQUAL);
  2735. stencil_next_pass->set_stencil_reference(stencil_reference);
  2736. break;
  2737. case STENCIL_MODE_XRAY:
  2738. set_stencil_flags(STENCIL_FLAG_WRITE);
  2739. set_stencil_compare(STENCIL_COMPARE_ALWAYS);
  2740. stencil_next_pass->set_render_priority(get_render_priority() + 1);
  2741. stencil_next_pass->set_shading_mode(SHADING_MODE_UNSHADED);
  2742. stencil_next_pass->set_transparency(TRANSPARENCY_ALPHA);
  2743. stencil_next_pass->set_flag(FLAG_DISABLE_DEPTH_TEST, true);
  2744. stencil_next_pass->set_grow_enabled(false);
  2745. stencil_next_pass->set_grow(0);
  2746. stencil_next_pass->set_albedo(stencil_effect_color);
  2747. stencil_next_pass->set_stencil_mode(STENCIL_MODE_CUSTOM);
  2748. stencil_next_pass->set_stencil_flags(STENCIL_FLAG_READ);
  2749. stencil_next_pass->set_stencil_compare(STENCIL_COMPARE_NOT_EQUAL);
  2750. stencil_next_pass->set_stencil_reference(stencil_reference);
  2751. break;
  2752. case STENCIL_MODE_CUSTOM:
  2753. break;
  2754. case STENCIL_MODE_MAX:
  2755. break;
  2756. }
  2757. }
  2758. Ref<BaseMaterial3D> BaseMaterial3D::_get_stencil_next_pass() const {
  2759. const Ref<Material> current_next_pass = get_next_pass();
  2760. Ref<BaseMaterial3D> stencil_next_pass;
  2761. if (current_next_pass.is_valid() && current_next_pass->has_meta("_stencil_owned")) {
  2762. stencil_next_pass = current_next_pass;
  2763. }
  2764. return stencil_next_pass;
  2765. }
  2766. void BaseMaterial3D::set_stencil_mode(StencilMode p_stencil_mode) {
  2767. if (stencil_mode == p_stencil_mode) {
  2768. return;
  2769. }
  2770. stencil_mode = p_stencil_mode;
  2771. _prepare_stencil_effect();
  2772. _queue_shader_change();
  2773. notify_property_list_changed();
  2774. }
  2775. BaseMaterial3D::StencilMode BaseMaterial3D::get_stencil_mode() const {
  2776. return stencil_mode;
  2777. }
  2778. void BaseMaterial3D::set_stencil_flags(int p_stencil_flags) {
  2779. if (stencil_flags == p_stencil_flags) {
  2780. return;
  2781. }
  2782. // If enabling read while already writing, switch to read only.
  2783. if ((p_stencil_flags & STENCIL_FLAG_READ) && (stencil_flags & (STENCIL_FLAG_WRITE | STENCIL_FLAG_WRITE_DEPTH_FAIL))) {
  2784. p_stencil_flags = p_stencil_flags & STENCIL_FLAG_READ;
  2785. }
  2786. // If enabling write while already reading, switch to write or write_depth_fail.
  2787. if ((p_stencil_flags & (STENCIL_FLAG_WRITE | STENCIL_FLAG_WRITE_DEPTH_FAIL)) && (stencil_flags & STENCIL_FLAG_READ)) {
  2788. p_stencil_flags = p_stencil_flags & (STENCIL_FLAG_WRITE | STENCIL_FLAG_WRITE_DEPTH_FAIL);
  2789. }
  2790. // If enabling read+write while already doing neither, only allow read.
  2791. if ((p_stencil_flags & STENCIL_FLAG_READ) && (p_stencil_flags & (STENCIL_FLAG_WRITE | STENCIL_FLAG_WRITE_DEPTH_FAIL))) {
  2792. p_stencil_flags = p_stencil_flags & STENCIL_FLAG_READ;
  2793. }
  2794. stencil_flags = p_stencil_flags;
  2795. _queue_shader_change();
  2796. }
  2797. int BaseMaterial3D::get_stencil_flags() const {
  2798. return stencil_flags;
  2799. }
  2800. void BaseMaterial3D::set_stencil_compare(BaseMaterial3D::StencilCompare p_op) {
  2801. if (stencil_compare == p_op) {
  2802. return;
  2803. }
  2804. stencil_compare = p_op;
  2805. _queue_shader_change();
  2806. }
  2807. BaseMaterial3D::StencilCompare BaseMaterial3D::get_stencil_compare() const {
  2808. return stencil_compare;
  2809. }
  2810. void BaseMaterial3D::set_stencil_reference(int p_reference) {
  2811. if (stencil_reference == p_reference) {
  2812. return;
  2813. }
  2814. stencil_reference = p_reference;
  2815. _queue_shader_change();
  2816. Ref<BaseMaterial3D> stencil_next_pass = _get_stencil_next_pass();
  2817. if (stencil_next_pass.is_valid()) {
  2818. stencil_next_pass->set_stencil_reference(p_reference);
  2819. }
  2820. }
  2821. int BaseMaterial3D::get_stencil_reference() const {
  2822. return stencil_reference;
  2823. }
  2824. void BaseMaterial3D::set_stencil_effect_color(const Color &p_color) {
  2825. if (stencil_effect_color == p_color) {
  2826. return;
  2827. }
  2828. stencil_effect_color = p_color;
  2829. Ref<BaseMaterial3D> stencil_next_pass = _get_stencil_next_pass();
  2830. if (stencil_next_pass.is_valid()) {
  2831. stencil_next_pass->set_albedo(p_color);
  2832. }
  2833. }
  2834. Color BaseMaterial3D::get_stencil_effect_color() const {
  2835. return stencil_effect_color;
  2836. }
  2837. void BaseMaterial3D::set_stencil_effect_outline_thickness(float p_outline_thickness) {
  2838. if (stencil_effect_outline_thickness == p_outline_thickness) {
  2839. return;
  2840. }
  2841. stencil_effect_outline_thickness = p_outline_thickness;
  2842. Ref<BaseMaterial3D> stencil_next_pass = _get_stencil_next_pass();
  2843. if (stencil_next_pass.is_valid()) {
  2844. stencil_next_pass->set_grow(p_outline_thickness);
  2845. }
  2846. }
  2847. float BaseMaterial3D::get_stencil_effect_outline_thickness() const {
  2848. return stencil_effect_outline_thickness;
  2849. }
  2850. RID BaseMaterial3D::get_shader_rid() const {
  2851. const_cast<BaseMaterial3D *>(this)->_update_shader();
  2852. return shader_rid;
  2853. }
  2854. Shader::Mode BaseMaterial3D::get_shader_mode() const {
  2855. return Shader::MODE_SPATIAL;
  2856. }
  2857. void BaseMaterial3D::_bind_methods() {
  2858. static_assert(sizeof(MaterialKey) == 16, "MaterialKey should be 16 bytes");
  2859. ClassDB::bind_method(D_METHOD("set_albedo", "albedo"), &BaseMaterial3D::set_albedo);
  2860. ClassDB::bind_method(D_METHOD("get_albedo"), &BaseMaterial3D::get_albedo);
  2861. ClassDB::bind_method(D_METHOD("set_transparency", "transparency"), &BaseMaterial3D::set_transparency);
  2862. ClassDB::bind_method(D_METHOD("get_transparency"), &BaseMaterial3D::get_transparency);
  2863. ClassDB::bind_method(D_METHOD("set_alpha_antialiasing", "alpha_aa"), &BaseMaterial3D::set_alpha_antialiasing);
  2864. ClassDB::bind_method(D_METHOD("get_alpha_antialiasing"), &BaseMaterial3D::get_alpha_antialiasing);
  2865. ClassDB::bind_method(D_METHOD("set_alpha_antialiasing_edge", "edge"), &BaseMaterial3D::set_alpha_antialiasing_edge);
  2866. ClassDB::bind_method(D_METHOD("get_alpha_antialiasing_edge"), &BaseMaterial3D::get_alpha_antialiasing_edge);
  2867. ClassDB::bind_method(D_METHOD("set_shading_mode", "shading_mode"), &BaseMaterial3D::set_shading_mode);
  2868. ClassDB::bind_method(D_METHOD("get_shading_mode"), &BaseMaterial3D::get_shading_mode);
  2869. ClassDB::bind_method(D_METHOD("set_specular", "specular"), &BaseMaterial3D::set_specular);
  2870. ClassDB::bind_method(D_METHOD("get_specular"), &BaseMaterial3D::get_specular);
  2871. ClassDB::bind_method(D_METHOD("set_metallic", "metallic"), &BaseMaterial3D::set_metallic);
  2872. ClassDB::bind_method(D_METHOD("get_metallic"), &BaseMaterial3D::get_metallic);
  2873. ClassDB::bind_method(D_METHOD("set_roughness", "roughness"), &BaseMaterial3D::set_roughness);
  2874. ClassDB::bind_method(D_METHOD("get_roughness"), &BaseMaterial3D::get_roughness);
  2875. ClassDB::bind_method(D_METHOD("set_emission", "emission"), &BaseMaterial3D::set_emission);
  2876. ClassDB::bind_method(D_METHOD("get_emission"), &BaseMaterial3D::get_emission);
  2877. ClassDB::bind_method(D_METHOD("set_emission_energy_multiplier", "emission_energy_multiplier"), &BaseMaterial3D::set_emission_energy_multiplier);
  2878. ClassDB::bind_method(D_METHOD("get_emission_energy_multiplier"), &BaseMaterial3D::get_emission_energy_multiplier);
  2879. ClassDB::bind_method(D_METHOD("set_emission_intensity", "emission_energy_multiplier"), &BaseMaterial3D::set_emission_intensity);
  2880. ClassDB::bind_method(D_METHOD("get_emission_intensity"), &BaseMaterial3D::get_emission_intensity);
  2881. ClassDB::bind_method(D_METHOD("set_normal_scale", "normal_scale"), &BaseMaterial3D::set_normal_scale);
  2882. ClassDB::bind_method(D_METHOD("get_normal_scale"), &BaseMaterial3D::get_normal_scale);
  2883. ClassDB::bind_method(D_METHOD("set_rim", "rim"), &BaseMaterial3D::set_rim);
  2884. ClassDB::bind_method(D_METHOD("get_rim"), &BaseMaterial3D::get_rim);
  2885. ClassDB::bind_method(D_METHOD("set_rim_tint", "rim_tint"), &BaseMaterial3D::set_rim_tint);
  2886. ClassDB::bind_method(D_METHOD("get_rim_tint"), &BaseMaterial3D::get_rim_tint);
  2887. ClassDB::bind_method(D_METHOD("set_clearcoat", "clearcoat"), &BaseMaterial3D::set_clearcoat);
  2888. ClassDB::bind_method(D_METHOD("get_clearcoat"), &BaseMaterial3D::get_clearcoat);
  2889. ClassDB::bind_method(D_METHOD("set_clearcoat_roughness", "clearcoat_roughness"), &BaseMaterial3D::set_clearcoat_roughness);
  2890. ClassDB::bind_method(D_METHOD("get_clearcoat_roughness"), &BaseMaterial3D::get_clearcoat_roughness);
  2891. ClassDB::bind_method(D_METHOD("set_anisotropy", "anisotropy"), &BaseMaterial3D::set_anisotropy);
  2892. ClassDB::bind_method(D_METHOD("get_anisotropy"), &BaseMaterial3D::get_anisotropy);
  2893. ClassDB::bind_method(D_METHOD("set_heightmap_scale", "heightmap_scale"), &BaseMaterial3D::set_heightmap_scale);
  2894. ClassDB::bind_method(D_METHOD("get_heightmap_scale"), &BaseMaterial3D::get_heightmap_scale);
  2895. ClassDB::bind_method(D_METHOD("set_subsurface_scattering_strength", "strength"), &BaseMaterial3D::set_subsurface_scattering_strength);
  2896. ClassDB::bind_method(D_METHOD("get_subsurface_scattering_strength"), &BaseMaterial3D::get_subsurface_scattering_strength);
  2897. ClassDB::bind_method(D_METHOD("set_transmittance_color", "color"), &BaseMaterial3D::set_transmittance_color);
  2898. ClassDB::bind_method(D_METHOD("get_transmittance_color"), &BaseMaterial3D::get_transmittance_color);
  2899. ClassDB::bind_method(D_METHOD("set_transmittance_depth", "depth"), &BaseMaterial3D::set_transmittance_depth);
  2900. ClassDB::bind_method(D_METHOD("get_transmittance_depth"), &BaseMaterial3D::get_transmittance_depth);
  2901. ClassDB::bind_method(D_METHOD("set_transmittance_boost", "boost"), &BaseMaterial3D::set_transmittance_boost);
  2902. ClassDB::bind_method(D_METHOD("get_transmittance_boost"), &BaseMaterial3D::get_transmittance_boost);
  2903. ClassDB::bind_method(D_METHOD("set_backlight", "backlight"), &BaseMaterial3D::set_backlight);
  2904. ClassDB::bind_method(D_METHOD("get_backlight"), &BaseMaterial3D::get_backlight);
  2905. ClassDB::bind_method(D_METHOD("set_refraction", "refraction"), &BaseMaterial3D::set_refraction);
  2906. ClassDB::bind_method(D_METHOD("get_refraction"), &BaseMaterial3D::get_refraction);
  2907. ClassDB::bind_method(D_METHOD("set_point_size", "point_size"), &BaseMaterial3D::set_point_size);
  2908. ClassDB::bind_method(D_METHOD("get_point_size"), &BaseMaterial3D::get_point_size);
  2909. ClassDB::bind_method(D_METHOD("set_detail_uv", "detail_uv"), &BaseMaterial3D::set_detail_uv);
  2910. ClassDB::bind_method(D_METHOD("get_detail_uv"), &BaseMaterial3D::get_detail_uv);
  2911. ClassDB::bind_method(D_METHOD("set_blend_mode", "blend_mode"), &BaseMaterial3D::set_blend_mode);
  2912. ClassDB::bind_method(D_METHOD("get_blend_mode"), &BaseMaterial3D::get_blend_mode);
  2913. ClassDB::bind_method(D_METHOD("set_depth_draw_mode", "depth_draw_mode"), &BaseMaterial3D::set_depth_draw_mode);
  2914. ClassDB::bind_method(D_METHOD("get_depth_draw_mode"), &BaseMaterial3D::get_depth_draw_mode);
  2915. ClassDB::bind_method(D_METHOD("set_depth_test", "depth_test"), &BaseMaterial3D::set_depth_test);
  2916. ClassDB::bind_method(D_METHOD("get_depth_test"), &BaseMaterial3D::get_depth_test);
  2917. ClassDB::bind_method(D_METHOD("set_cull_mode", "cull_mode"), &BaseMaterial3D::set_cull_mode);
  2918. ClassDB::bind_method(D_METHOD("get_cull_mode"), &BaseMaterial3D::get_cull_mode);
  2919. ClassDB::bind_method(D_METHOD("set_diffuse_mode", "diffuse_mode"), &BaseMaterial3D::set_diffuse_mode);
  2920. ClassDB::bind_method(D_METHOD("get_diffuse_mode"), &BaseMaterial3D::get_diffuse_mode);
  2921. ClassDB::bind_method(D_METHOD("set_specular_mode", "specular_mode"), &BaseMaterial3D::set_specular_mode);
  2922. ClassDB::bind_method(D_METHOD("get_specular_mode"), &BaseMaterial3D::get_specular_mode);
  2923. ClassDB::bind_method(D_METHOD("set_flag", "flag", "enable"), &BaseMaterial3D::set_flag);
  2924. ClassDB::bind_method(D_METHOD("get_flag", "flag"), &BaseMaterial3D::get_flag);
  2925. ClassDB::bind_method(D_METHOD("set_texture_filter", "mode"), &BaseMaterial3D::set_texture_filter);
  2926. ClassDB::bind_method(D_METHOD("get_texture_filter"), &BaseMaterial3D::get_texture_filter);
  2927. ClassDB::bind_method(D_METHOD("set_feature", "feature", "enable"), &BaseMaterial3D::set_feature);
  2928. ClassDB::bind_method(D_METHOD("get_feature", "feature"), &BaseMaterial3D::get_feature);
  2929. ClassDB::bind_method(D_METHOD("set_texture", "param", "texture"), &BaseMaterial3D::set_texture);
  2930. ClassDB::bind_method(D_METHOD("get_texture", "param"), &BaseMaterial3D::get_texture);
  2931. ClassDB::bind_method(D_METHOD("set_detail_blend_mode", "detail_blend_mode"), &BaseMaterial3D::set_detail_blend_mode);
  2932. ClassDB::bind_method(D_METHOD("get_detail_blend_mode"), &BaseMaterial3D::get_detail_blend_mode);
  2933. ClassDB::bind_method(D_METHOD("set_uv1_scale", "scale"), &BaseMaterial3D::set_uv1_scale);
  2934. ClassDB::bind_method(D_METHOD("get_uv1_scale"), &BaseMaterial3D::get_uv1_scale);
  2935. ClassDB::bind_method(D_METHOD("set_uv1_offset", "offset"), &BaseMaterial3D::set_uv1_offset);
  2936. ClassDB::bind_method(D_METHOD("get_uv1_offset"), &BaseMaterial3D::get_uv1_offset);
  2937. ClassDB::bind_method(D_METHOD("set_uv1_triplanar_blend_sharpness", "sharpness"), &BaseMaterial3D::set_uv1_triplanar_blend_sharpness);
  2938. ClassDB::bind_method(D_METHOD("get_uv1_triplanar_blend_sharpness"), &BaseMaterial3D::get_uv1_triplanar_blend_sharpness);
  2939. ClassDB::bind_method(D_METHOD("set_uv2_scale", "scale"), &BaseMaterial3D::set_uv2_scale);
  2940. ClassDB::bind_method(D_METHOD("get_uv2_scale"), &BaseMaterial3D::get_uv2_scale);
  2941. ClassDB::bind_method(D_METHOD("set_uv2_offset", "offset"), &BaseMaterial3D::set_uv2_offset);
  2942. ClassDB::bind_method(D_METHOD("get_uv2_offset"), &BaseMaterial3D::get_uv2_offset);
  2943. ClassDB::bind_method(D_METHOD("set_uv2_triplanar_blend_sharpness", "sharpness"), &BaseMaterial3D::set_uv2_triplanar_blend_sharpness);
  2944. ClassDB::bind_method(D_METHOD("get_uv2_triplanar_blend_sharpness"), &BaseMaterial3D::get_uv2_triplanar_blend_sharpness);
  2945. ClassDB::bind_method(D_METHOD("set_billboard_mode", "mode"), &BaseMaterial3D::set_billboard_mode);
  2946. ClassDB::bind_method(D_METHOD("get_billboard_mode"), &BaseMaterial3D::get_billboard_mode);
  2947. ClassDB::bind_method(D_METHOD("set_particles_anim_h_frames", "frames"), &BaseMaterial3D::set_particles_anim_h_frames);
  2948. ClassDB::bind_method(D_METHOD("get_particles_anim_h_frames"), &BaseMaterial3D::get_particles_anim_h_frames);
  2949. ClassDB::bind_method(D_METHOD("set_particles_anim_v_frames", "frames"), &BaseMaterial3D::set_particles_anim_v_frames);
  2950. ClassDB::bind_method(D_METHOD("get_particles_anim_v_frames"), &BaseMaterial3D::get_particles_anim_v_frames);
  2951. ClassDB::bind_method(D_METHOD("set_particles_anim_loop", "loop"), &BaseMaterial3D::set_particles_anim_loop);
  2952. ClassDB::bind_method(D_METHOD("get_particles_anim_loop"), &BaseMaterial3D::get_particles_anim_loop);
  2953. ClassDB::bind_method(D_METHOD("set_heightmap_deep_parallax", "enable"), &BaseMaterial3D::set_heightmap_deep_parallax);
  2954. ClassDB::bind_method(D_METHOD("is_heightmap_deep_parallax_enabled"), &BaseMaterial3D::is_heightmap_deep_parallax_enabled);
  2955. ClassDB::bind_method(D_METHOD("set_heightmap_deep_parallax_min_layers", "layer"), &BaseMaterial3D::set_heightmap_deep_parallax_min_layers);
  2956. ClassDB::bind_method(D_METHOD("get_heightmap_deep_parallax_min_layers"), &BaseMaterial3D::get_heightmap_deep_parallax_min_layers);
  2957. ClassDB::bind_method(D_METHOD("set_heightmap_deep_parallax_max_layers", "layer"), &BaseMaterial3D::set_heightmap_deep_parallax_max_layers);
  2958. ClassDB::bind_method(D_METHOD("get_heightmap_deep_parallax_max_layers"), &BaseMaterial3D::get_heightmap_deep_parallax_max_layers);
  2959. ClassDB::bind_method(D_METHOD("set_heightmap_deep_parallax_flip_tangent", "flip"), &BaseMaterial3D::set_heightmap_deep_parallax_flip_tangent);
  2960. ClassDB::bind_method(D_METHOD("get_heightmap_deep_parallax_flip_tangent"), &BaseMaterial3D::get_heightmap_deep_parallax_flip_tangent);
  2961. ClassDB::bind_method(D_METHOD("set_heightmap_deep_parallax_flip_binormal", "flip"), &BaseMaterial3D::set_heightmap_deep_parallax_flip_binormal);
  2962. ClassDB::bind_method(D_METHOD("get_heightmap_deep_parallax_flip_binormal"), &BaseMaterial3D::get_heightmap_deep_parallax_flip_binormal);
  2963. ClassDB::bind_method(D_METHOD("set_grow", "amount"), &BaseMaterial3D::set_grow);
  2964. ClassDB::bind_method(D_METHOD("get_grow"), &BaseMaterial3D::get_grow);
  2965. ClassDB::bind_method(D_METHOD("set_emission_operator", "operator"), &BaseMaterial3D::set_emission_operator);
  2966. ClassDB::bind_method(D_METHOD("get_emission_operator"), &BaseMaterial3D::get_emission_operator);
  2967. ClassDB::bind_method(D_METHOD("set_ao_light_affect", "amount"), &BaseMaterial3D::set_ao_light_affect);
  2968. ClassDB::bind_method(D_METHOD("get_ao_light_affect"), &BaseMaterial3D::get_ao_light_affect);
  2969. ClassDB::bind_method(D_METHOD("set_alpha_scissor_threshold", "threshold"), &BaseMaterial3D::set_alpha_scissor_threshold);
  2970. ClassDB::bind_method(D_METHOD("get_alpha_scissor_threshold"), &BaseMaterial3D::get_alpha_scissor_threshold);
  2971. ClassDB::bind_method(D_METHOD("set_alpha_hash_scale", "threshold"), &BaseMaterial3D::set_alpha_hash_scale);
  2972. ClassDB::bind_method(D_METHOD("get_alpha_hash_scale"), &BaseMaterial3D::get_alpha_hash_scale);
  2973. ClassDB::bind_method(D_METHOD("set_grow_enabled", "enable"), &BaseMaterial3D::set_grow_enabled);
  2974. ClassDB::bind_method(D_METHOD("is_grow_enabled"), &BaseMaterial3D::is_grow_enabled);
  2975. ClassDB::bind_method(D_METHOD("set_metallic_texture_channel", "channel"), &BaseMaterial3D::set_metallic_texture_channel);
  2976. ClassDB::bind_method(D_METHOD("get_metallic_texture_channel"), &BaseMaterial3D::get_metallic_texture_channel);
  2977. ClassDB::bind_method(D_METHOD("set_roughness_texture_channel", "channel"), &BaseMaterial3D::set_roughness_texture_channel);
  2978. ClassDB::bind_method(D_METHOD("get_roughness_texture_channel"), &BaseMaterial3D::get_roughness_texture_channel);
  2979. ClassDB::bind_method(D_METHOD("set_ao_texture_channel", "channel"), &BaseMaterial3D::set_ao_texture_channel);
  2980. ClassDB::bind_method(D_METHOD("get_ao_texture_channel"), &BaseMaterial3D::get_ao_texture_channel);
  2981. ClassDB::bind_method(D_METHOD("set_refraction_texture_channel", "channel"), &BaseMaterial3D::set_refraction_texture_channel);
  2982. ClassDB::bind_method(D_METHOD("get_refraction_texture_channel"), &BaseMaterial3D::get_refraction_texture_channel);
  2983. ClassDB::bind_method(D_METHOD("set_proximity_fade_enabled", "enabled"), &BaseMaterial3D::set_proximity_fade_enabled);
  2984. ClassDB::bind_method(D_METHOD("is_proximity_fade_enabled"), &BaseMaterial3D::is_proximity_fade_enabled);
  2985. ClassDB::bind_method(D_METHOD("set_proximity_fade_distance", "distance"), &BaseMaterial3D::set_proximity_fade_distance);
  2986. ClassDB::bind_method(D_METHOD("get_proximity_fade_distance"), &BaseMaterial3D::get_proximity_fade_distance);
  2987. ClassDB::bind_method(D_METHOD("set_msdf_pixel_range", "range"), &BaseMaterial3D::set_msdf_pixel_range);
  2988. ClassDB::bind_method(D_METHOD("get_msdf_pixel_range"), &BaseMaterial3D::get_msdf_pixel_range);
  2989. ClassDB::bind_method(D_METHOD("set_msdf_outline_size", "size"), &BaseMaterial3D::set_msdf_outline_size);
  2990. ClassDB::bind_method(D_METHOD("get_msdf_outline_size"), &BaseMaterial3D::get_msdf_outline_size);
  2991. ClassDB::bind_method(D_METHOD("set_distance_fade", "mode"), &BaseMaterial3D::set_distance_fade);
  2992. ClassDB::bind_method(D_METHOD("get_distance_fade"), &BaseMaterial3D::get_distance_fade);
  2993. ClassDB::bind_method(D_METHOD("set_distance_fade_max_distance", "distance"), &BaseMaterial3D::set_distance_fade_max_distance);
  2994. ClassDB::bind_method(D_METHOD("get_distance_fade_max_distance"), &BaseMaterial3D::get_distance_fade_max_distance);
  2995. ClassDB::bind_method(D_METHOD("set_distance_fade_min_distance", "distance"), &BaseMaterial3D::set_distance_fade_min_distance);
  2996. ClassDB::bind_method(D_METHOD("get_distance_fade_min_distance"), &BaseMaterial3D::get_distance_fade_min_distance);
  2997. ClassDB::bind_method(D_METHOD("set_z_clip_scale", "scale"), &BaseMaterial3D::set_z_clip_scale);
  2998. ClassDB::bind_method(D_METHOD("get_z_clip_scale"), &BaseMaterial3D::get_z_clip_scale);
  2999. ClassDB::bind_method(D_METHOD("set_fov_override", "scale"), &BaseMaterial3D::set_fov_override);
  3000. ClassDB::bind_method(D_METHOD("get_fov_override"), &BaseMaterial3D::get_fov_override);
  3001. ClassDB::bind_method(D_METHOD("set_stencil_mode", "stencil_mode"), &BaseMaterial3D::set_stencil_mode);
  3002. ClassDB::bind_method(D_METHOD("get_stencil_mode"), &BaseMaterial3D::get_stencil_mode);
  3003. ClassDB::bind_method(D_METHOD("set_stencil_flags", "stencil_flags"), &BaseMaterial3D::set_stencil_flags);
  3004. ClassDB::bind_method(D_METHOD("get_stencil_flags"), &BaseMaterial3D::get_stencil_flags);
  3005. ClassDB::bind_method(D_METHOD("set_stencil_compare", "stencil_compare"), &BaseMaterial3D::set_stencil_compare);
  3006. ClassDB::bind_method(D_METHOD("get_stencil_compare"), &BaseMaterial3D::get_stencil_compare);
  3007. ClassDB::bind_method(D_METHOD("set_stencil_reference", "stencil_reference"), &BaseMaterial3D::set_stencil_reference);
  3008. ClassDB::bind_method(D_METHOD("get_stencil_reference"), &BaseMaterial3D::get_stencil_reference);
  3009. ClassDB::bind_method(D_METHOD("set_stencil_effect_color", "stencil_color"), &BaseMaterial3D::set_stencil_effect_color);
  3010. ClassDB::bind_method(D_METHOD("get_stencil_effect_color"), &BaseMaterial3D::get_stencil_effect_color);
  3011. ClassDB::bind_method(D_METHOD("set_stencil_effect_outline_thickness", "stencil_outline_thickness"), &BaseMaterial3D::set_stencil_effect_outline_thickness);
  3012. ClassDB::bind_method(D_METHOD("get_stencil_effect_outline_thickness"), &BaseMaterial3D::get_stencil_effect_outline_thickness);
  3013. ADD_GROUP("Transparency", "");
  3014. ADD_PROPERTY(PropertyInfo(Variant::INT, "transparency", PROPERTY_HINT_ENUM, "Disabled,Alpha,Alpha Scissor,Alpha Hash,Depth Pre-Pass"), "set_transparency", "get_transparency");
  3015. ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "alpha_scissor_threshold", PROPERTY_HINT_RANGE, "0,1,0.001"), "set_alpha_scissor_threshold", "get_alpha_scissor_threshold");
  3016. ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "alpha_hash_scale", PROPERTY_HINT_RANGE, "0,2,0.01"), "set_alpha_hash_scale", "get_alpha_hash_scale");
  3017. ADD_PROPERTY(PropertyInfo(Variant::INT, "alpha_antialiasing_mode", PROPERTY_HINT_ENUM, "Disabled,Alpha Edge Blend,Alpha Edge Clip"), "set_alpha_antialiasing", "get_alpha_antialiasing");
  3018. ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "alpha_antialiasing_edge", PROPERTY_HINT_RANGE, "0,1,0.01"), "set_alpha_antialiasing_edge", "get_alpha_antialiasing_edge");
  3019. ADD_PROPERTY(PropertyInfo(Variant::INT, "blend_mode", PROPERTY_HINT_ENUM, "Mix,Add,Subtract,Multiply,Premultiplied Alpha"), "set_blend_mode", "get_blend_mode");
  3020. ADD_PROPERTY(PropertyInfo(Variant::INT, "cull_mode", PROPERTY_HINT_ENUM, "Back,Front,Disabled"), "set_cull_mode", "get_cull_mode");
  3021. ADD_PROPERTY(PropertyInfo(Variant::INT, "depth_draw_mode", PROPERTY_HINT_ENUM, "Opaque Only,Always,Never"), "set_depth_draw_mode", "get_depth_draw_mode");
  3022. ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "no_depth_test"), "set_flag", "get_flag", FLAG_DISABLE_DEPTH_TEST);
  3023. ADD_PROPERTY(PropertyInfo(Variant::INT, "depth_test", PROPERTY_HINT_ENUM, "Default,Inverted"), "set_depth_test", "get_depth_test");
  3024. ADD_GROUP("Shading", "");
  3025. ADD_PROPERTY(PropertyInfo(Variant::INT, "shading_mode", PROPERTY_HINT_ENUM, "Unshaded,Per-Pixel,Per-Vertex"), "set_shading_mode", "get_shading_mode");
  3026. ADD_PROPERTY(PropertyInfo(Variant::INT, "diffuse_mode", PROPERTY_HINT_ENUM, "Burley,Lambert,Lambert Wrap,Toon"), "set_diffuse_mode", "get_diffuse_mode");
  3027. ADD_PROPERTY(PropertyInfo(Variant::INT, "specular_mode", PROPERTY_HINT_ENUM, "SchlickGGX,Toon,Disabled"), "set_specular_mode", "get_specular_mode");
  3028. ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "disable_ambient_light"), "set_flag", "get_flag", FLAG_DISABLE_AMBIENT_LIGHT);
  3029. ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "disable_fog"), "set_flag", "get_flag", FLAG_DISABLE_FOG);
  3030. ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "disable_specular_occlusion"), "set_flag", "get_flag", FLAG_DISABLE_SPECULAR_OCCLUSION);
  3031. ADD_GROUP("Vertex Color", "vertex_color");
  3032. ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "vertex_color_use_as_albedo"), "set_flag", "get_flag", FLAG_ALBEDO_FROM_VERTEX_COLOR);
  3033. ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "vertex_color_is_srgb"), "set_flag", "get_flag", FLAG_SRGB_VERTEX_COLOR);
  3034. ADD_GROUP("Albedo", "albedo_");
  3035. ADD_PROPERTY(PropertyInfo(Variant::COLOR, "albedo_color"), "set_albedo", "get_albedo");
  3036. ADD_PROPERTYI(PropertyInfo(Variant::OBJECT, "albedo_texture", PROPERTY_HINT_RESOURCE_TYPE, "Texture2D"), "set_texture", "get_texture", TEXTURE_ALBEDO);
  3037. ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "albedo_texture_force_srgb"), "set_flag", "get_flag", FLAG_ALBEDO_TEXTURE_FORCE_SRGB);
  3038. ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "albedo_texture_msdf"), "set_flag", "get_flag", FLAG_ALBEDO_TEXTURE_MSDF);
  3039. ADD_GROUP("ORM", "orm_");
  3040. ADD_PROPERTYI(PropertyInfo(Variant::OBJECT, "orm_texture", PROPERTY_HINT_RESOURCE_TYPE, "Texture2D"), "set_texture", "get_texture", TEXTURE_ORM);
  3041. ADD_GROUP("Metallic", "metallic_");
  3042. ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "metallic", PROPERTY_HINT_RANGE, "0,1,0.01"), "set_metallic", "get_metallic");
  3043. ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "metallic_specular", PROPERTY_HINT_RANGE, "0,1,0.01"), "set_specular", "get_specular");
  3044. ADD_PROPERTYI(PropertyInfo(Variant::OBJECT, "metallic_texture", PROPERTY_HINT_RESOURCE_TYPE, "Texture2D"), "set_texture", "get_texture", TEXTURE_METALLIC);
  3045. ADD_PROPERTY(PropertyInfo(Variant::INT, "metallic_texture_channel", PROPERTY_HINT_ENUM, "Red,Green,Blue,Alpha,Gray"), "set_metallic_texture_channel", "get_metallic_texture_channel");
  3046. ADD_GROUP("Roughness", "roughness_");
  3047. ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "roughness", PROPERTY_HINT_RANGE, "0,1,0.01"), "set_roughness", "get_roughness");
  3048. ADD_PROPERTYI(PropertyInfo(Variant::OBJECT, "roughness_texture", PROPERTY_HINT_RESOURCE_TYPE, "Texture2D"), "set_texture", "get_texture", TEXTURE_ROUGHNESS);
  3049. ADD_PROPERTY(PropertyInfo(Variant::INT, "roughness_texture_channel", PROPERTY_HINT_ENUM, "Red,Green,Blue,Alpha,Gray"), "set_roughness_texture_channel", "get_roughness_texture_channel");
  3050. ADD_GROUP("Emission", "emission_");
  3051. ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "emission_enabled", PROPERTY_HINT_GROUP_ENABLE), "set_feature", "get_feature", FEATURE_EMISSION);
  3052. ADD_PROPERTY(PropertyInfo(Variant::COLOR, "emission", PROPERTY_HINT_COLOR_NO_ALPHA), "set_emission", "get_emission");
  3053. ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "emission_energy_multiplier", PROPERTY_HINT_RANGE, "0,16,0.01,or_greater"), "set_emission_energy_multiplier", "get_emission_energy_multiplier");
  3054. ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "emission_intensity", PROPERTY_HINT_RANGE, "0,100000.0,0.01,or_greater,suffix:nt"), "set_emission_intensity", "get_emission_intensity");
  3055. ADD_PROPERTY(PropertyInfo(Variant::INT, "emission_operator", PROPERTY_HINT_ENUM, "Add,Multiply"), "set_emission_operator", "get_emission_operator");
  3056. ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "emission_on_uv2"), "set_flag", "get_flag", FLAG_EMISSION_ON_UV2);
  3057. ADD_PROPERTYI(PropertyInfo(Variant::OBJECT, "emission_texture", PROPERTY_HINT_RESOURCE_TYPE, "Texture2D"), "set_texture", "get_texture", TEXTURE_EMISSION);
  3058. ADD_GROUP("Normal Map", "normal_");
  3059. ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "normal_enabled", PROPERTY_HINT_GROUP_ENABLE), "set_feature", "get_feature", FEATURE_NORMAL_MAPPING);
  3060. ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "normal_scale", PROPERTY_HINT_RANGE, "-16,16,0.01"), "set_normal_scale", "get_normal_scale");
  3061. ADD_PROPERTYI(PropertyInfo(Variant::OBJECT, "normal_texture", PROPERTY_HINT_RESOURCE_TYPE, "Texture2D"), "set_texture", "get_texture", TEXTURE_NORMAL);
  3062. ADD_GROUP("Bent Normal Map", "bent_normal_");
  3063. ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "bent_normal_enabled", PROPERTY_HINT_GROUP_ENABLE), "set_feature", "get_feature", FEATURE_BENT_NORMAL_MAPPING);
  3064. ADD_PROPERTYI(PropertyInfo(Variant::OBJECT, "bent_normal_texture", PROPERTY_HINT_RESOURCE_TYPE, "Texture2D"), "set_texture", "get_texture", TEXTURE_BENT_NORMAL);
  3065. ADD_GROUP("Rim", "rim_");
  3066. ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "rim_enabled", PROPERTY_HINT_GROUP_ENABLE), "set_feature", "get_feature", FEATURE_RIM);
  3067. ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "rim", PROPERTY_HINT_RANGE, "0,1,0.01"), "set_rim", "get_rim");
  3068. ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "rim_tint", PROPERTY_HINT_RANGE, "0,1,0.01"), "set_rim_tint", "get_rim_tint");
  3069. ADD_PROPERTYI(PropertyInfo(Variant::OBJECT, "rim_texture", PROPERTY_HINT_RESOURCE_TYPE, "Texture2D"), "set_texture", "get_texture", TEXTURE_RIM);
  3070. ADD_GROUP("Clearcoat", "clearcoat_");
  3071. ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "clearcoat_enabled", PROPERTY_HINT_GROUP_ENABLE), "set_feature", "get_feature", FEATURE_CLEARCOAT);
  3072. ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "clearcoat", PROPERTY_HINT_RANGE, "0,1,0.01"), "set_clearcoat", "get_clearcoat");
  3073. ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "clearcoat_roughness", PROPERTY_HINT_RANGE, "0,1,0.01"), "set_clearcoat_roughness", "get_clearcoat_roughness");
  3074. ADD_PROPERTYI(PropertyInfo(Variant::OBJECT, "clearcoat_texture", PROPERTY_HINT_RESOURCE_TYPE, "Texture2D"), "set_texture", "get_texture", TEXTURE_CLEARCOAT);
  3075. ADD_GROUP("Anisotropy", "anisotropy_");
  3076. ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "anisotropy_enabled", PROPERTY_HINT_GROUP_ENABLE), "set_feature", "get_feature", FEATURE_ANISOTROPY);
  3077. ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "anisotropy", PROPERTY_HINT_RANGE, "-1,1,0.01"), "set_anisotropy", "get_anisotropy");
  3078. ADD_PROPERTYI(PropertyInfo(Variant::OBJECT, "anisotropy_flowmap", PROPERTY_HINT_RESOURCE_TYPE, "Texture2D"), "set_texture", "get_texture", TEXTURE_FLOWMAP);
  3079. ADD_GROUP("Ambient Occlusion", "ao_");
  3080. ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "ao_enabled", PROPERTY_HINT_GROUP_ENABLE), "set_feature", "get_feature", FEATURE_AMBIENT_OCCLUSION);
  3081. ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "ao_light_affect", PROPERTY_HINT_RANGE, "0,1,0.01"), "set_ao_light_affect", "get_ao_light_affect");
  3082. ADD_PROPERTYI(PropertyInfo(Variant::OBJECT, "ao_texture", PROPERTY_HINT_RESOURCE_TYPE, "Texture2D"), "set_texture", "get_texture", TEXTURE_AMBIENT_OCCLUSION);
  3083. ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "ao_on_uv2"), "set_flag", "get_flag", FLAG_AO_ON_UV2);
  3084. ADD_PROPERTY(PropertyInfo(Variant::INT, "ao_texture_channel", PROPERTY_HINT_ENUM, "Red,Green,Blue,Alpha,Gray"), "set_ao_texture_channel", "get_ao_texture_channel");
  3085. ADD_GROUP("Height", "heightmap_");
  3086. ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "heightmap_enabled", PROPERTY_HINT_GROUP_ENABLE), "set_feature", "get_feature", FEATURE_HEIGHT_MAPPING);
  3087. ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "heightmap_scale", PROPERTY_HINT_RANGE, "-16,16,0.001"), "set_heightmap_scale", "get_heightmap_scale");
  3088. ADD_PROPERTY(PropertyInfo(Variant::BOOL, "heightmap_deep_parallax"), "set_heightmap_deep_parallax", "is_heightmap_deep_parallax_enabled");
  3089. ADD_PROPERTY(PropertyInfo(Variant::INT, "heightmap_min_layers", PROPERTY_HINT_RANGE, "1,64,1"), "set_heightmap_deep_parallax_min_layers", "get_heightmap_deep_parallax_min_layers");
  3090. ADD_PROPERTY(PropertyInfo(Variant::INT, "heightmap_max_layers", PROPERTY_HINT_RANGE, "1,64,1"), "set_heightmap_deep_parallax_max_layers", "get_heightmap_deep_parallax_max_layers");
  3091. ADD_PROPERTY(PropertyInfo(Variant::BOOL, "heightmap_flip_tangent"), "set_heightmap_deep_parallax_flip_tangent", "get_heightmap_deep_parallax_flip_tangent");
  3092. ADD_PROPERTY(PropertyInfo(Variant::BOOL, "heightmap_flip_binormal"), "set_heightmap_deep_parallax_flip_binormal", "get_heightmap_deep_parallax_flip_binormal");
  3093. ADD_PROPERTYI(PropertyInfo(Variant::OBJECT, "heightmap_texture", PROPERTY_HINT_RESOURCE_TYPE, "Texture2D"), "set_texture", "get_texture", TEXTURE_HEIGHTMAP);
  3094. ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "heightmap_flip_texture"), "set_flag", "get_flag", FLAG_INVERT_HEIGHTMAP);
  3095. ADD_GROUP("Subsurf Scatter", "subsurf_scatter_");
  3096. ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "subsurf_scatter_enabled", PROPERTY_HINT_GROUP_ENABLE), "set_feature", "get_feature", FEATURE_SUBSURFACE_SCATTERING);
  3097. ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "subsurf_scatter_strength", PROPERTY_HINT_RANGE, "0,1,0.01"), "set_subsurface_scattering_strength", "get_subsurface_scattering_strength");
  3098. ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "subsurf_scatter_skin_mode"), "set_flag", "get_flag", FLAG_SUBSURFACE_MODE_SKIN);
  3099. ADD_PROPERTYI(PropertyInfo(Variant::OBJECT, "subsurf_scatter_texture", PROPERTY_HINT_RESOURCE_TYPE, "Texture2D"), "set_texture", "get_texture", TEXTURE_SUBSURFACE_SCATTERING);
  3100. ADD_SUBGROUP("Transmittance", "subsurf_scatter_transmittance_");
  3101. ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "subsurf_scatter_transmittance_enabled", PROPERTY_HINT_GROUP_ENABLE), "set_feature", "get_feature", FEATURE_SUBSURFACE_TRANSMITTANCE);
  3102. ADD_PROPERTY(PropertyInfo(Variant::COLOR, "subsurf_scatter_transmittance_color"), "set_transmittance_color", "get_transmittance_color");
  3103. ADD_PROPERTYI(PropertyInfo(Variant::OBJECT, "subsurf_scatter_transmittance_texture", PROPERTY_HINT_RESOURCE_TYPE, "Texture2D"), "set_texture", "get_texture", TEXTURE_SUBSURFACE_TRANSMITTANCE);
  3104. ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "subsurf_scatter_transmittance_depth", PROPERTY_HINT_RANGE, "0.001,8,0.001,or_greater"), "set_transmittance_depth", "get_transmittance_depth");
  3105. ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "subsurf_scatter_transmittance_boost", PROPERTY_HINT_RANGE, "0.00,1.0,0.01"), "set_transmittance_boost", "get_transmittance_boost");
  3106. ADD_GROUP("Back Lighting", "backlight_");
  3107. ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "backlight_enabled", PROPERTY_HINT_GROUP_ENABLE), "set_feature", "get_feature", FEATURE_BACKLIGHT);
  3108. ADD_PROPERTY(PropertyInfo(Variant::COLOR, "backlight", PROPERTY_HINT_COLOR_NO_ALPHA), "set_backlight", "get_backlight");
  3109. ADD_PROPERTYI(PropertyInfo(Variant::OBJECT, "backlight_texture", PROPERTY_HINT_RESOURCE_TYPE, "Texture2D"), "set_texture", "get_texture", TEXTURE_BACKLIGHT);
  3110. ADD_GROUP("Refraction", "refraction_");
  3111. ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "refraction_enabled", PROPERTY_HINT_GROUP_ENABLE), "set_feature", "get_feature", FEATURE_REFRACTION);
  3112. ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "refraction_scale", PROPERTY_HINT_RANGE, "-1,1,0.01"), "set_refraction", "get_refraction");
  3113. ADD_PROPERTYI(PropertyInfo(Variant::OBJECT, "refraction_texture", PROPERTY_HINT_RESOURCE_TYPE, "Texture2D"), "set_texture", "get_texture", TEXTURE_REFRACTION);
  3114. ADD_PROPERTY(PropertyInfo(Variant::INT, "refraction_texture_channel", PROPERTY_HINT_ENUM, "Red,Green,Blue,Alpha,Gray"), "set_refraction_texture_channel", "get_refraction_texture_channel");
  3115. ADD_GROUP("Detail", "detail_");
  3116. ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "detail_enabled", PROPERTY_HINT_GROUP_ENABLE), "set_feature", "get_feature", FEATURE_DETAIL);
  3117. ADD_PROPERTYI(PropertyInfo(Variant::OBJECT, "detail_mask", PROPERTY_HINT_RESOURCE_TYPE, "Texture2D"), "set_texture", "get_texture", TEXTURE_DETAIL_MASK);
  3118. ADD_PROPERTY(PropertyInfo(Variant::INT, "detail_blend_mode", PROPERTY_HINT_ENUM, "Mix,Add,Subtract,Multiply"), "set_detail_blend_mode", "get_detail_blend_mode");
  3119. ADD_PROPERTY(PropertyInfo(Variant::INT, "detail_uv_layer", PROPERTY_HINT_ENUM, "UV1,UV2"), "set_detail_uv", "get_detail_uv");
  3120. ADD_PROPERTYI(PropertyInfo(Variant::OBJECT, "detail_albedo", PROPERTY_HINT_RESOURCE_TYPE, "Texture2D"), "set_texture", "get_texture", TEXTURE_DETAIL_ALBEDO);
  3121. ADD_PROPERTYI(PropertyInfo(Variant::OBJECT, "detail_normal", PROPERTY_HINT_RESOURCE_TYPE, "Texture2D"), "set_texture", "get_texture", TEXTURE_DETAIL_NORMAL);
  3122. ADD_GROUP("UV1", "uv1_");
  3123. ADD_PROPERTY(PropertyInfo(Variant::VECTOR3, "uv1_scale", PROPERTY_HINT_LINK), "set_uv1_scale", "get_uv1_scale");
  3124. ADD_PROPERTY(PropertyInfo(Variant::VECTOR3, "uv1_offset"), "set_uv1_offset", "get_uv1_offset");
  3125. ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "uv1_triplanar"), "set_flag", "get_flag", FLAG_UV1_USE_TRIPLANAR);
  3126. ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "uv1_triplanar_sharpness", PROPERTY_HINT_EXP_EASING), "set_uv1_triplanar_blend_sharpness", "get_uv1_triplanar_blend_sharpness");
  3127. ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "uv1_world_triplanar"), "set_flag", "get_flag", FLAG_UV1_USE_WORLD_TRIPLANAR);
  3128. ADD_GROUP("UV2", "uv2_");
  3129. ADD_PROPERTY(PropertyInfo(Variant::VECTOR3, "uv2_scale", PROPERTY_HINT_LINK), "set_uv2_scale", "get_uv2_scale");
  3130. ADD_PROPERTY(PropertyInfo(Variant::VECTOR3, "uv2_offset"), "set_uv2_offset", "get_uv2_offset");
  3131. ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "uv2_triplanar"), "set_flag", "get_flag", FLAG_UV2_USE_TRIPLANAR);
  3132. ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "uv2_triplanar_sharpness", PROPERTY_HINT_EXP_EASING), "set_uv2_triplanar_blend_sharpness", "get_uv2_triplanar_blend_sharpness");
  3133. ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "uv2_world_triplanar"), "set_flag", "get_flag", FLAG_UV2_USE_WORLD_TRIPLANAR);
  3134. ADD_GROUP("Sampling", "texture_");
  3135. ADD_PROPERTY(PropertyInfo(Variant::INT, "texture_filter", PROPERTY_HINT_ENUM, "Nearest,Linear,Nearest Mipmap,Linear Mipmap,Nearest Mipmap Anisotropic,Linear Mipmap Anisotropic"), "set_texture_filter", "get_texture_filter");
  3136. ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "texture_repeat"), "set_flag", "get_flag", FLAG_USE_TEXTURE_REPEAT);
  3137. ADD_GROUP("Shadows", "");
  3138. ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "disable_receive_shadows"), "set_flag", "get_flag", FLAG_DONT_RECEIVE_SHADOWS);
  3139. ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "shadow_to_opacity"), "set_flag", "get_flag", FLAG_USE_SHADOW_TO_OPACITY);
  3140. ADD_GROUP("Billboard", "billboard_");
  3141. ADD_PROPERTY(PropertyInfo(Variant::INT, "billboard_mode", PROPERTY_HINT_ENUM, "Disabled,Enabled,Y-Billboard,Particle Billboard"), "set_billboard_mode", "get_billboard_mode");
  3142. ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "billboard_keep_scale"), "set_flag", "get_flag", FLAG_BILLBOARD_KEEP_SCALE);
  3143. ADD_GROUP("Particles Anim", "particles_anim_");
  3144. ADD_PROPERTY(PropertyInfo(Variant::INT, "particles_anim_h_frames", PROPERTY_HINT_RANGE, "1,128,1"), "set_particles_anim_h_frames", "get_particles_anim_h_frames");
  3145. ADD_PROPERTY(PropertyInfo(Variant::INT, "particles_anim_v_frames", PROPERTY_HINT_RANGE, "1,128,1"), "set_particles_anim_v_frames", "get_particles_anim_v_frames");
  3146. ADD_PROPERTY(PropertyInfo(Variant::BOOL, "particles_anim_loop"), "set_particles_anim_loop", "get_particles_anim_loop");
  3147. ADD_GROUP("Grow", "grow_");
  3148. ADD_PROPERTY(PropertyInfo(Variant::BOOL, "grow"), "set_grow_enabled", "is_grow_enabled");
  3149. ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "grow_amount", PROPERTY_HINT_RANGE, "-16,16,0.001,suffix:m"), "set_grow", "get_grow");
  3150. ADD_GROUP("Transform", "");
  3151. ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "fixed_size"), "set_flag", "get_flag", FLAG_FIXED_SIZE);
  3152. ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "use_point_size"), "set_flag", "get_flag", FLAG_USE_POINT_SIZE);
  3153. ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "point_size", PROPERTY_HINT_RANGE, "0.1,128,0.1,suffix:px"), "set_point_size", "get_point_size");
  3154. ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "use_particle_trails"), "set_flag", "get_flag", FLAG_PARTICLE_TRAILS_MODE);
  3155. ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "use_z_clip_scale"), "set_flag", "get_flag", FLAG_USE_Z_CLIP_SCALE);
  3156. ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "z_clip_scale", PROPERTY_HINT_RANGE, "0.01,1.0,0.01"), "set_z_clip_scale", "get_z_clip_scale");
  3157. ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "use_fov_override"), "set_flag", "get_flag", FLAG_USE_FOV_OVERRIDE);
  3158. ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "fov_override", PROPERTY_HINT_RANGE, "1,179,0.1,degrees"), "set_fov_override", "get_fov_override");
  3159. ADD_GROUP("Proximity Fade", "proximity_fade_");
  3160. ADD_PROPERTY(PropertyInfo(Variant::BOOL, "proximity_fade_enabled"), "set_proximity_fade_enabled", "is_proximity_fade_enabled");
  3161. ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "proximity_fade_distance", PROPERTY_HINT_RANGE, "0.01,4096,0.01,suffix:m"), "set_proximity_fade_distance", "get_proximity_fade_distance");
  3162. ADD_GROUP("MSDF", "msdf_");
  3163. ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "msdf_pixel_range", PROPERTY_HINT_RANGE, "1,100,1"), "set_msdf_pixel_range", "get_msdf_pixel_range");
  3164. ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "msdf_outline_size", PROPERTY_HINT_RANGE, "0,250,1"), "set_msdf_outline_size", "get_msdf_outline_size");
  3165. ADD_GROUP("Distance Fade", "distance_fade_");
  3166. ADD_PROPERTY(PropertyInfo(Variant::INT, "distance_fade_mode", PROPERTY_HINT_ENUM, "Disabled,PixelAlpha,PixelDither,ObjectDither"), "set_distance_fade", "get_distance_fade");
  3167. ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "distance_fade_min_distance", PROPERTY_HINT_RANGE, "0,4096,0.01,suffix:m"), "set_distance_fade_min_distance", "get_distance_fade_min_distance");
  3168. ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "distance_fade_max_distance", PROPERTY_HINT_RANGE, "0,4096,0.01,suffix:m"), "set_distance_fade_max_distance", "get_distance_fade_max_distance");
  3169. ADD_GROUP("Stencil", "stencil_");
  3170. ADD_PROPERTY(PropertyInfo(Variant::INT, "stencil_mode", PROPERTY_HINT_ENUM, "Disabled,Outline,X-Ray,Custom"), "set_stencil_mode", "get_stencil_mode");
  3171. ADD_PROPERTY(PropertyInfo(Variant::INT, "stencil_flags", PROPERTY_HINT_FLAGS, "Read,Write,Write Depth Fail"), "set_stencil_flags", "get_stencil_flags");
  3172. ADD_PROPERTY(PropertyInfo(Variant::INT, "stencil_compare", PROPERTY_HINT_ENUM, "Always,Less,Equal,Less Or Equal,Greater,Not Equal,Greater Or Equal"), "set_stencil_compare", "get_stencil_compare");
  3173. ADD_PROPERTY(PropertyInfo(Variant::INT, "stencil_reference", PROPERTY_HINT_RANGE, "0,255,1"), "set_stencil_reference", "get_stencil_reference");
  3174. ADD_PROPERTY(PropertyInfo(Variant::COLOR, "stencil_color", PROPERTY_HINT_NONE), "set_stencil_effect_color", "get_stencil_effect_color");
  3175. ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "stencil_outline_thickness", PROPERTY_HINT_RANGE, "0,1,0.001,or_greater,suffix:m"), "set_stencil_effect_outline_thickness", "get_stencil_effect_outline_thickness");
  3176. BIND_ENUM_CONSTANT(TEXTURE_ALBEDO);
  3177. BIND_ENUM_CONSTANT(TEXTURE_METALLIC);
  3178. BIND_ENUM_CONSTANT(TEXTURE_ROUGHNESS);
  3179. BIND_ENUM_CONSTANT(TEXTURE_EMISSION);
  3180. BIND_ENUM_CONSTANT(TEXTURE_NORMAL);
  3181. BIND_ENUM_CONSTANT(TEXTURE_BENT_NORMAL);
  3182. BIND_ENUM_CONSTANT(TEXTURE_RIM);
  3183. BIND_ENUM_CONSTANT(TEXTURE_CLEARCOAT);
  3184. BIND_ENUM_CONSTANT(TEXTURE_FLOWMAP);
  3185. BIND_ENUM_CONSTANT(TEXTURE_AMBIENT_OCCLUSION);
  3186. BIND_ENUM_CONSTANT(TEXTURE_HEIGHTMAP);
  3187. BIND_ENUM_CONSTANT(TEXTURE_SUBSURFACE_SCATTERING);
  3188. BIND_ENUM_CONSTANT(TEXTURE_SUBSURFACE_TRANSMITTANCE);
  3189. BIND_ENUM_CONSTANT(TEXTURE_BACKLIGHT);
  3190. BIND_ENUM_CONSTANT(TEXTURE_REFRACTION);
  3191. BIND_ENUM_CONSTANT(TEXTURE_DETAIL_MASK);
  3192. BIND_ENUM_CONSTANT(TEXTURE_DETAIL_ALBEDO);
  3193. BIND_ENUM_CONSTANT(TEXTURE_DETAIL_NORMAL);
  3194. BIND_ENUM_CONSTANT(TEXTURE_ORM);
  3195. BIND_ENUM_CONSTANT(TEXTURE_MAX);
  3196. BIND_ENUM_CONSTANT(TEXTURE_FILTER_NEAREST);
  3197. BIND_ENUM_CONSTANT(TEXTURE_FILTER_LINEAR);
  3198. BIND_ENUM_CONSTANT(TEXTURE_FILTER_NEAREST_WITH_MIPMAPS);
  3199. BIND_ENUM_CONSTANT(TEXTURE_FILTER_LINEAR_WITH_MIPMAPS);
  3200. BIND_ENUM_CONSTANT(TEXTURE_FILTER_NEAREST_WITH_MIPMAPS_ANISOTROPIC);
  3201. BIND_ENUM_CONSTANT(TEXTURE_FILTER_LINEAR_WITH_MIPMAPS_ANISOTROPIC);
  3202. BIND_ENUM_CONSTANT(TEXTURE_FILTER_MAX);
  3203. BIND_ENUM_CONSTANT(DETAIL_UV_1);
  3204. BIND_ENUM_CONSTANT(DETAIL_UV_2);
  3205. BIND_ENUM_CONSTANT(TRANSPARENCY_DISABLED);
  3206. BIND_ENUM_CONSTANT(TRANSPARENCY_ALPHA);
  3207. BIND_ENUM_CONSTANT(TRANSPARENCY_ALPHA_SCISSOR);
  3208. BIND_ENUM_CONSTANT(TRANSPARENCY_ALPHA_HASH);
  3209. BIND_ENUM_CONSTANT(TRANSPARENCY_ALPHA_DEPTH_PRE_PASS);
  3210. BIND_ENUM_CONSTANT(TRANSPARENCY_MAX);
  3211. BIND_ENUM_CONSTANT(SHADING_MODE_UNSHADED);
  3212. BIND_ENUM_CONSTANT(SHADING_MODE_PER_PIXEL);
  3213. BIND_ENUM_CONSTANT(SHADING_MODE_PER_VERTEX);
  3214. BIND_ENUM_CONSTANT(SHADING_MODE_MAX);
  3215. BIND_ENUM_CONSTANT(FEATURE_EMISSION);
  3216. BIND_ENUM_CONSTANT(FEATURE_NORMAL_MAPPING);
  3217. BIND_ENUM_CONSTANT(FEATURE_RIM);
  3218. BIND_ENUM_CONSTANT(FEATURE_CLEARCOAT);
  3219. BIND_ENUM_CONSTANT(FEATURE_ANISOTROPY);
  3220. BIND_ENUM_CONSTANT(FEATURE_AMBIENT_OCCLUSION);
  3221. BIND_ENUM_CONSTANT(FEATURE_HEIGHT_MAPPING);
  3222. BIND_ENUM_CONSTANT(FEATURE_SUBSURFACE_SCATTERING);
  3223. BIND_ENUM_CONSTANT(FEATURE_SUBSURFACE_TRANSMITTANCE);
  3224. BIND_ENUM_CONSTANT(FEATURE_BACKLIGHT);
  3225. BIND_ENUM_CONSTANT(FEATURE_REFRACTION);
  3226. BIND_ENUM_CONSTANT(FEATURE_DETAIL);
  3227. BIND_ENUM_CONSTANT(FEATURE_BENT_NORMAL_MAPPING);
  3228. BIND_ENUM_CONSTANT(FEATURE_MAX);
  3229. BIND_ENUM_CONSTANT(BLEND_MODE_MIX);
  3230. BIND_ENUM_CONSTANT(BLEND_MODE_ADD);
  3231. BIND_ENUM_CONSTANT(BLEND_MODE_SUB);
  3232. BIND_ENUM_CONSTANT(BLEND_MODE_MUL);
  3233. BIND_ENUM_CONSTANT(BLEND_MODE_PREMULT_ALPHA);
  3234. BIND_ENUM_CONSTANT(ALPHA_ANTIALIASING_OFF);
  3235. BIND_ENUM_CONSTANT(ALPHA_ANTIALIASING_ALPHA_TO_COVERAGE);
  3236. BIND_ENUM_CONSTANT(ALPHA_ANTIALIASING_ALPHA_TO_COVERAGE_AND_TO_ONE);
  3237. BIND_ENUM_CONSTANT(DEPTH_DRAW_OPAQUE_ONLY);
  3238. BIND_ENUM_CONSTANT(DEPTH_DRAW_ALWAYS);
  3239. BIND_ENUM_CONSTANT(DEPTH_DRAW_DISABLED);
  3240. BIND_ENUM_CONSTANT(DEPTH_TEST_DEFAULT);
  3241. BIND_ENUM_CONSTANT(DEPTH_TEST_INVERTED);
  3242. BIND_ENUM_CONSTANT(CULL_BACK);
  3243. BIND_ENUM_CONSTANT(CULL_FRONT);
  3244. BIND_ENUM_CONSTANT(CULL_DISABLED);
  3245. BIND_ENUM_CONSTANT(FLAG_DISABLE_DEPTH_TEST);
  3246. BIND_ENUM_CONSTANT(FLAG_ALBEDO_FROM_VERTEX_COLOR);
  3247. BIND_ENUM_CONSTANT(FLAG_SRGB_VERTEX_COLOR);
  3248. BIND_ENUM_CONSTANT(FLAG_USE_POINT_SIZE);
  3249. BIND_ENUM_CONSTANT(FLAG_FIXED_SIZE);
  3250. BIND_ENUM_CONSTANT(FLAG_BILLBOARD_KEEP_SCALE);
  3251. BIND_ENUM_CONSTANT(FLAG_UV1_USE_TRIPLANAR);
  3252. BIND_ENUM_CONSTANT(FLAG_UV2_USE_TRIPLANAR);
  3253. BIND_ENUM_CONSTANT(FLAG_UV1_USE_WORLD_TRIPLANAR);
  3254. BIND_ENUM_CONSTANT(FLAG_UV2_USE_WORLD_TRIPLANAR);
  3255. BIND_ENUM_CONSTANT(FLAG_AO_ON_UV2);
  3256. BIND_ENUM_CONSTANT(FLAG_EMISSION_ON_UV2);
  3257. BIND_ENUM_CONSTANT(FLAG_ALBEDO_TEXTURE_FORCE_SRGB);
  3258. BIND_ENUM_CONSTANT(FLAG_DONT_RECEIVE_SHADOWS);
  3259. BIND_ENUM_CONSTANT(FLAG_DISABLE_AMBIENT_LIGHT);
  3260. BIND_ENUM_CONSTANT(FLAG_USE_SHADOW_TO_OPACITY);
  3261. BIND_ENUM_CONSTANT(FLAG_USE_TEXTURE_REPEAT);
  3262. BIND_ENUM_CONSTANT(FLAG_INVERT_HEIGHTMAP);
  3263. BIND_ENUM_CONSTANT(FLAG_SUBSURFACE_MODE_SKIN);
  3264. BIND_ENUM_CONSTANT(FLAG_PARTICLE_TRAILS_MODE);
  3265. BIND_ENUM_CONSTANT(FLAG_ALBEDO_TEXTURE_MSDF);
  3266. BIND_ENUM_CONSTANT(FLAG_DISABLE_FOG);
  3267. BIND_ENUM_CONSTANT(FLAG_DISABLE_SPECULAR_OCCLUSION);
  3268. BIND_ENUM_CONSTANT(FLAG_USE_Z_CLIP_SCALE);
  3269. BIND_ENUM_CONSTANT(FLAG_USE_FOV_OVERRIDE);
  3270. BIND_ENUM_CONSTANT(FLAG_MAX);
  3271. BIND_ENUM_CONSTANT(DIFFUSE_BURLEY);
  3272. BIND_ENUM_CONSTANT(DIFFUSE_LAMBERT);
  3273. BIND_ENUM_CONSTANT(DIFFUSE_LAMBERT_WRAP);
  3274. BIND_ENUM_CONSTANT(DIFFUSE_TOON);
  3275. BIND_ENUM_CONSTANT(SPECULAR_SCHLICK_GGX);
  3276. BIND_ENUM_CONSTANT(SPECULAR_TOON);
  3277. BIND_ENUM_CONSTANT(SPECULAR_DISABLED);
  3278. BIND_ENUM_CONSTANT(BILLBOARD_DISABLED);
  3279. BIND_ENUM_CONSTANT(BILLBOARD_ENABLED);
  3280. BIND_ENUM_CONSTANT(BILLBOARD_FIXED_Y);
  3281. BIND_ENUM_CONSTANT(BILLBOARD_PARTICLES);
  3282. BIND_ENUM_CONSTANT(TEXTURE_CHANNEL_RED);
  3283. BIND_ENUM_CONSTANT(TEXTURE_CHANNEL_GREEN);
  3284. BIND_ENUM_CONSTANT(TEXTURE_CHANNEL_BLUE);
  3285. BIND_ENUM_CONSTANT(TEXTURE_CHANNEL_ALPHA);
  3286. BIND_ENUM_CONSTANT(TEXTURE_CHANNEL_GRAYSCALE);
  3287. BIND_ENUM_CONSTANT(EMISSION_OP_ADD);
  3288. BIND_ENUM_CONSTANT(EMISSION_OP_MULTIPLY);
  3289. BIND_ENUM_CONSTANT(DISTANCE_FADE_DISABLED);
  3290. BIND_ENUM_CONSTANT(DISTANCE_FADE_PIXEL_ALPHA);
  3291. BIND_ENUM_CONSTANT(DISTANCE_FADE_PIXEL_DITHER);
  3292. BIND_ENUM_CONSTANT(DISTANCE_FADE_OBJECT_DITHER);
  3293. BIND_ENUM_CONSTANT(STENCIL_MODE_DISABLED);
  3294. BIND_ENUM_CONSTANT(STENCIL_MODE_OUTLINE);
  3295. BIND_ENUM_CONSTANT(STENCIL_MODE_XRAY);
  3296. BIND_ENUM_CONSTANT(STENCIL_MODE_CUSTOM);
  3297. BIND_ENUM_CONSTANT(STENCIL_FLAG_READ);
  3298. BIND_ENUM_CONSTANT(STENCIL_FLAG_WRITE);
  3299. BIND_ENUM_CONSTANT(STENCIL_FLAG_WRITE_DEPTH_FAIL);
  3300. BIND_ENUM_CONSTANT(STENCIL_COMPARE_ALWAYS);
  3301. BIND_ENUM_CONSTANT(STENCIL_COMPARE_LESS);
  3302. BIND_ENUM_CONSTANT(STENCIL_COMPARE_EQUAL);
  3303. BIND_ENUM_CONSTANT(STENCIL_COMPARE_LESS_OR_EQUAL);
  3304. BIND_ENUM_CONSTANT(STENCIL_COMPARE_GREATER);
  3305. BIND_ENUM_CONSTANT(STENCIL_COMPARE_NOT_EQUAL);
  3306. BIND_ENUM_CONSTANT(STENCIL_COMPARE_GREATER_OR_EQUAL);
  3307. }
  3308. BaseMaterial3D::BaseMaterial3D(bool p_orm) :
  3309. element(this) {
  3310. orm = p_orm;
  3311. // Initialize to the same values as the shader
  3312. set_albedo(Color(1.0, 1.0, 1.0, 1.0));
  3313. set_specular(0.5);
  3314. set_roughness(1.0);
  3315. set_metallic(0.0);
  3316. set_emission(Color(0, 0, 0));
  3317. set_emission_energy_multiplier(1.0);
  3318. set_normal_scale(1);
  3319. set_rim(1.0);
  3320. set_rim_tint(0.5);
  3321. set_clearcoat(1);
  3322. set_clearcoat_roughness(0.5);
  3323. set_anisotropy(0);
  3324. set_heightmap_scale(5.0);
  3325. set_subsurface_scattering_strength(0);
  3326. set_backlight(Color(0, 0, 0));
  3327. set_transmittance_color(Color(1, 1, 1, 1));
  3328. set_transmittance_depth(0.1);
  3329. set_transmittance_boost(0.0);
  3330. set_refraction(0.05);
  3331. set_point_size(1);
  3332. set_uv1_offset(Vector3(0, 0, 0));
  3333. set_uv1_scale(Vector3(1, 1, 1));
  3334. set_uv1_triplanar_blend_sharpness(1);
  3335. set_uv2_offset(Vector3(0, 0, 0));
  3336. set_uv2_scale(Vector3(1, 1, 1));
  3337. set_uv2_triplanar_blend_sharpness(1);
  3338. set_billboard_mode(BILLBOARD_DISABLED);
  3339. set_particles_anim_h_frames(1);
  3340. set_particles_anim_v_frames(1);
  3341. set_particles_anim_loop(false);
  3342. set_transparency(TRANSPARENCY_DISABLED);
  3343. set_alpha_antialiasing(ALPHA_ANTIALIASING_OFF);
  3344. // Alpha scissor threshold of 0.5 matches the glTF specification and Label3D default.
  3345. // <https://www.khronos.org/registry/glTF/specs/2.0/glTF-2.0.html#_material_alphacutoff>
  3346. set_alpha_scissor_threshold(0.5);
  3347. set_alpha_hash_scale(1.0);
  3348. set_alpha_antialiasing_edge(0.3);
  3349. set_proximity_fade_distance(1);
  3350. set_distance_fade_min_distance(0);
  3351. set_distance_fade_max_distance(10);
  3352. set_ao_light_affect(0.0);
  3353. set_metallic_texture_channel(TEXTURE_CHANNEL_RED);
  3354. set_roughness_texture_channel(TEXTURE_CHANNEL_RED);
  3355. set_ao_texture_channel(TEXTURE_CHANNEL_RED);
  3356. set_refraction_texture_channel(TEXTURE_CHANNEL_RED);
  3357. set_grow(0.0);
  3358. set_msdf_pixel_range(4.0);
  3359. set_msdf_outline_size(0.0);
  3360. set_heightmap_deep_parallax_min_layers(8);
  3361. set_heightmap_deep_parallax_max_layers(32);
  3362. set_heightmap_deep_parallax_flip_tangent(false); //also sets binormal
  3363. set_z_clip_scale(1.0);
  3364. set_fov_override(75.0);
  3365. set_stencil_mode(STENCIL_MODE_DISABLED);
  3366. flags[FLAG_ALBEDO_TEXTURE_MSDF] = false;
  3367. flags[FLAG_USE_TEXTURE_REPEAT] = true;
  3368. current_key.invalid_key = 1;
  3369. }
  3370. BaseMaterial3D::~BaseMaterial3D() {
  3371. ERR_FAIL_NULL(RS::get_singleton());
  3372. {
  3373. MutexLock lock(shader_map_mutex);
  3374. if (shader_map.has(current_key)) {
  3375. shader_map[current_key].users--;
  3376. if (shader_map[current_key].users == 0) {
  3377. // Deallocate shader which is no longer in use.
  3378. RS::get_singleton()->free(shader_map[current_key].shader);
  3379. shader_map.erase(current_key);
  3380. }
  3381. }
  3382. }
  3383. if (_get_material().is_valid()) {
  3384. RS::get_singleton()->material_set_shader(_get_material(), RID());
  3385. }
  3386. }
  3387. //////////////////////
  3388. #ifndef DISABLE_DEPRECATED
  3389. // Kept for compatibility from 3.x to 4.0.
  3390. bool StandardMaterial3D::_set(const StringName &p_name, const Variant &p_value) {
  3391. if (p_name == "flags_transparent") {
  3392. bool transparent = p_value;
  3393. if (transparent) {
  3394. set_transparency(TRANSPARENCY_ALPHA);
  3395. }
  3396. return true;
  3397. } else if (p_name == "flags_unshaded") {
  3398. bool unshaded = p_value;
  3399. if (unshaded) {
  3400. set_shading_mode(SHADING_MODE_UNSHADED);
  3401. }
  3402. return true;
  3403. } else if (p_name == "flags_vertex_lighting") {
  3404. bool vertex_lit = p_value;
  3405. if (vertex_lit && get_shading_mode() != SHADING_MODE_UNSHADED) {
  3406. set_shading_mode(SHADING_MODE_PER_VERTEX);
  3407. }
  3408. return true;
  3409. } else if (p_name == "params_use_alpha_scissor") {
  3410. bool use_scissor = p_value;
  3411. if (use_scissor) {
  3412. set_transparency(TRANSPARENCY_ALPHA_SCISSOR);
  3413. }
  3414. return true;
  3415. } else if (p_name == "params_use_alpha_hash") {
  3416. bool use_hash = p_value;
  3417. if (use_hash) {
  3418. set_transparency(TRANSPARENCY_ALPHA_HASH);
  3419. }
  3420. return true;
  3421. } else if (p_name == "params_depth_draw_mode") {
  3422. int mode = p_value;
  3423. if (mode == 3) {
  3424. set_transparency(TRANSPARENCY_ALPHA_DEPTH_PRE_PASS);
  3425. }
  3426. return true;
  3427. } else if (p_name == "depth_enabled") {
  3428. bool enabled = p_value;
  3429. if (enabled) {
  3430. set_feature(FEATURE_HEIGHT_MAPPING, true);
  3431. set_flag(FLAG_INVERT_HEIGHTMAP, true);
  3432. }
  3433. return true;
  3434. } else {
  3435. static const Pair<const char *, const char *> remaps[] = {
  3436. { "flags_use_shadow_to_opacity", "shadow_to_opacity" },
  3437. { "flags_use_shadow_to_opacity", "shadow_to_opacity" },
  3438. { "flags_no_depth_test", "no_depth_test" },
  3439. { "flags_use_point_size", "use_point_size" },
  3440. { "flags_fixed_size", "fixed_size" },
  3441. { "flags_albedo_tex_force_srgb", "albedo_texture_force_srgb" },
  3442. { "flags_do_not_receive_shadows", "disable_receive_shadows" },
  3443. { "flags_disable_ambient_light", "disable_ambient_light" },
  3444. { "params_diffuse_mode", "diffuse_mode" },
  3445. { "params_specular_mode", "specular_mode" },
  3446. { "params_blend_mode", "blend_mode" },
  3447. { "params_cull_mode", "cull_mode" },
  3448. { "params_depth_draw_mode", "params_depth_draw_mode" },
  3449. { "params_point_size", "point_size" },
  3450. { "params_billboard_mode", "billboard_mode" },
  3451. { "params_billboard_keep_scale", "billboard_keep_scale" },
  3452. { "params_grow", "grow" },
  3453. { "params_grow_amount", "grow_amount" },
  3454. { "params_alpha_scissor_threshold", "alpha_scissor_threshold" },
  3455. { "params_alpha_hash_scale", "alpha_hash_scale" },
  3456. { "params_alpha_antialiasing_edge", "alpha_antialiasing_edge" },
  3457. { "depth_scale", "heightmap_scale" },
  3458. { "depth_deep_parallax", "heightmap_deep_parallax" },
  3459. { "depth_min_layers", "heightmap_min_layers" },
  3460. { "depth_max_layers", "heightmap_max_layers" },
  3461. { "depth_flip_tangent", "heightmap_flip_tangent" },
  3462. { "depth_flip_binormal", "heightmap_flip_binormal" },
  3463. { "depth_texture", "heightmap_texture" },
  3464. { "emission_energy", "emission_energy_multiplier" },
  3465. { nullptr, nullptr },
  3466. };
  3467. int idx = 0;
  3468. while (remaps[idx].first) {
  3469. if (p_name == remaps[idx].first) {
  3470. set(remaps[idx].second, p_value);
  3471. return true;
  3472. }
  3473. idx++;
  3474. }
  3475. WARN_PRINT("Godot 3.x SpatialMaterial remapped parameter not found: " + String(p_name));
  3476. return true;
  3477. }
  3478. }
  3479. #endif // DISABLE_DEPRECATED
  3480. ///////////////////////