material.cpp 130 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610161116121613161416151616161716181619162016211622162316241625162616271628162916301631163216331634163516361637163816391640164116421643164416451646164716481649165016511652165316541655165616571658165916601661166216631664166516661667166816691670167116721673167416751676167716781679168016811682168316841685168616871688168916901691169216931694169516961697169816991700170117021703170417051706170717081709171017111712171317141715171617171718171917201721172217231724172517261727172817291730173117321733173417351736173717381739174017411742174317441745174617471748174917501751175217531754175517561757175817591760176117621763176417651766176717681769177017711772177317741775177617771778177917801781178217831784178517861787178817891790179117921793179417951796179717981799180018011802180318041805180618071808180918101811181218131814181518161817181818191820182118221823182418251826182718281829183018311832183318341835183618371838183918401841184218431844184518461847184818491850185118521853185418551856185718581859186018611862186318641865186618671868186918701871187218731874187518761877187818791880188118821883188418851886188718881889189018911892189318941895189618971898189919001901190219031904190519061907190819091910191119121913191419151916191719181919192019211922192319241925192619271928192919301931193219331934193519361937193819391940194119421943194419451946194719481949195019511952195319541955195619571958195919601961196219631964196519661967196819691970197119721973197419751976197719781979198019811982198319841985198619871988198919901991199219931994199519961997199819992000200120022003200420052006200720082009201020112012201320142015201620172018201920202021202220232024202520262027202820292030203120322033203420352036203720382039204020412042204320442045204620472048204920502051205220532054205520562057205820592060206120622063206420652066206720682069207020712072207320742075207620772078207920802081208220832084208520862087208820892090209120922093209420952096209720982099210021012102210321042105210621072108210921102111211221132114211521162117211821192120212121222123212421252126212721282129213021312132213321342135213621372138213921402141214221432144214521462147214821492150215121522153215421552156215721582159216021612162216321642165216621672168216921702171217221732174217521762177217821792180218121822183218421852186218721882189219021912192219321942195219621972198219922002201220222032204220522062207220822092210221122122213221422152216221722182219222022212222222322242225222622272228222922302231223222332234223522362237223822392240224122422243224422452246224722482249225022512252225322542255225622572258225922602261226222632264226522662267226822692270227122722273227422752276227722782279228022812282228322842285228622872288228922902291229222932294229522962297229822992300230123022303230423052306230723082309231023112312231323142315231623172318231923202321232223232324232523262327232823292330233123322333233423352336233723382339234023412342234323442345234623472348234923502351235223532354235523562357235823592360236123622363236423652366236723682369237023712372237323742375237623772378237923802381238223832384238523862387238823892390239123922393239423952396239723982399240024012402240324042405240624072408240924102411241224132414241524162417241824192420242124222423242424252426242724282429243024312432243324342435243624372438243924402441244224432444244524462447244824492450245124522453245424552456245724582459246024612462246324642465246624672468246924702471247224732474247524762477247824792480248124822483248424852486248724882489249024912492249324942495249624972498249925002501250225032504250525062507250825092510251125122513251425152516251725182519252025212522252325242525252625272528252925302531253225332534253525362537253825392540254125422543254425452546254725482549255025512552255325542555255625572558255925602561256225632564256525662567256825692570257125722573257425752576257725782579258025812582258325842585258625872588258925902591259225932594259525962597259825992600260126022603260426052606260726082609261026112612261326142615261626172618261926202621262226232624262526262627262826292630263126322633263426352636263726382639264026412642264326442645264626472648264926502651265226532654265526562657265826592660266126622663266426652666266726682669267026712672267326742675267626772678267926802681268226832684268526862687268826892690269126922693269426952696269726982699270027012702270327042705270627072708270927102711271227132714271527162717271827192720272127222723272427252726272727282729273027312732273327342735273627372738273927402741274227432744274527462747274827492750275127522753275427552756275727582759276027612762276327642765276627672768276927702771277227732774277527762777277827792780278127822783278427852786278727882789279027912792279327942795279627972798279928002801280228032804280528062807280828092810281128122813281428152816281728182819282028212822282328242825282628272828282928302831283228332834283528362837283828392840284128422843284428452846284728482849285028512852285328542855285628572858285928602861286228632864286528662867286828692870287128722873287428752876287728782879288028812882288328842885288628872888288928902891289228932894289528962897289828992900290129022903290429052906290729082909291029112912291329142915291629172918291929202921292229232924292529262927292829292930293129322933293429352936293729382939294029412942294329442945294629472948294929502951295229532954295529562957295829592960296129622963296429652966296729682969297029712972297329742975297629772978297929802981298229832984298529862987298829892990299129922993299429952996299729982999300030013002300330043005300630073008300930103011301230133014301530163017301830193020302130223023302430253026302730283029303030313032303330343035303630373038303930403041304230433044304530463047304830493050305130523053305430553056305730583059306030613062306330643065306630673068306930703071307230733074307530763077307830793080308130823083308430853086308730883089309030913092309330943095309630973098309931003101310231033104310531063107310831093110311131123113311431153116311731183119312031213122312331243125312631273128312931303131313231333134313531363137313831393140314131423143314431453146314731483149315031513152315331543155315631573158315931603161316231633164316531663167316831693170317131723173317431753176317731783179318031813182318331843185318631873188318931903191319231933194319531963197319831993200320132023203320432053206320732083209321032113212321332143215321632173218
  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. #include "scene/scene_string_names.h"
  37. void Material::set_next_pass(const Ref<Material> &p_pass) {
  38. for (Ref<Material> pass_child = p_pass; pass_child != nullptr; pass_child = pass_child->get_next_pass()) {
  39. ERR_FAIL_COND_MSG(pass_child == this, "Can't set as next_pass one of its parents to prevent crashes due to recursive loop.");
  40. }
  41. if (next_pass == p_pass) {
  42. return;
  43. }
  44. next_pass = p_pass;
  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. Ref<Material> Material::get_next_pass() const {
  52. return next_pass;
  53. }
  54. void Material::set_render_priority(int p_priority) {
  55. ERR_FAIL_COND(p_priority < RENDER_PRIORITY_MIN);
  56. ERR_FAIL_COND(p_priority > RENDER_PRIORITY_MAX);
  57. render_priority = p_priority;
  58. RS::get_singleton()->material_set_render_priority(material, p_priority);
  59. }
  60. int Material::get_render_priority() const {
  61. return render_priority;
  62. }
  63. RID Material::get_rid() const {
  64. return material;
  65. }
  66. void Material::_validate_property(PropertyInfo &p_property) const {
  67. if (!_can_do_next_pass() && p_property.name == "next_pass") {
  68. p_property.usage = PROPERTY_USAGE_NONE;
  69. }
  70. if (!_can_use_render_priority() && p_property.name == "render_priority") {
  71. p_property.usage = PROPERTY_USAGE_NONE;
  72. }
  73. }
  74. void Material::_mark_initialized(const Callable &p_queue_shader_change_callable) {
  75. // If this is happening as part of resource loading, it is not safe to queue the update
  76. // as an addition to the dirty list, unless the load is happening on the main thread.
  77. if (ResourceLoader::is_within_load() && Thread::get_caller_id() != Thread::get_main_id()) {
  78. DEV_ASSERT(init_state != INIT_STATE_READY);
  79. if (init_state == INIT_STATE_UNINITIALIZED) { // Prevent queueing twice.
  80. // Let's mark this material as being initialized.
  81. init_state = INIT_STATE_INITIALIZING;
  82. // Knowing that the ResourceLoader will eventually feed deferred calls into the main message queue, let's do these:
  83. // 1. Queue setting the init state to INIT_STATE_READY finally.
  84. callable_mp(this, &Material::_mark_initialized).bind(p_queue_shader_change_callable).call_deferred();
  85. // 2. Queue an individual update of this material.
  86. p_queue_shader_change_callable.call_deferred();
  87. }
  88. } else {
  89. // Straightforward conditions.
  90. init_state = INIT_STATE_READY;
  91. p_queue_shader_change_callable.callv(Array());
  92. }
  93. }
  94. void Material::inspect_native_shader_code() {
  95. SceneTree *st = Object::cast_to<SceneTree>(OS::get_singleton()->get_main_loop());
  96. RID shader = get_shader_rid();
  97. if (st && shader.is_valid()) {
  98. st->call_group_flags(SceneTree::GROUP_CALL_DEFERRED, "_native_shader_source_visualizer", "_inspect_shader", shader);
  99. }
  100. }
  101. RID Material::get_shader_rid() const {
  102. RID ret;
  103. GDVIRTUAL_REQUIRED_CALL(_get_shader_rid, ret);
  104. return ret;
  105. }
  106. Shader::Mode Material::get_shader_mode() const {
  107. Shader::Mode ret = Shader::MODE_MAX;
  108. GDVIRTUAL_REQUIRED_CALL(_get_shader_mode, ret);
  109. return ret;
  110. }
  111. bool Material::_can_do_next_pass() const {
  112. bool ret = false;
  113. GDVIRTUAL_CALL(_can_do_next_pass, ret);
  114. return ret;
  115. }
  116. bool Material::_can_use_render_priority() const {
  117. bool ret = false;
  118. GDVIRTUAL_CALL(_can_use_render_priority, ret);
  119. return ret;
  120. }
  121. Ref<Resource> Material::create_placeholder() const {
  122. Ref<PlaceholderMaterial> placeholder;
  123. placeholder.instantiate();
  124. return placeholder;
  125. }
  126. void Material::_bind_methods() {
  127. ClassDB::bind_method(D_METHOD("set_next_pass", "next_pass"), &Material::set_next_pass);
  128. ClassDB::bind_method(D_METHOD("get_next_pass"), &Material::get_next_pass);
  129. ClassDB::bind_method(D_METHOD("set_render_priority", "priority"), &Material::set_render_priority);
  130. ClassDB::bind_method(D_METHOD("get_render_priority"), &Material::get_render_priority);
  131. ClassDB::bind_method(D_METHOD("inspect_native_shader_code"), &Material::inspect_native_shader_code);
  132. ClassDB::set_method_flags(get_class_static(), _scs_create("inspect_native_shader_code"), METHOD_FLAGS_DEFAULT | METHOD_FLAG_EDITOR);
  133. ClassDB::bind_method(D_METHOD("create_placeholder"), &Material::create_placeholder);
  134. 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");
  135. ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "next_pass", PROPERTY_HINT_RESOURCE_TYPE, "Material"), "set_next_pass", "get_next_pass");
  136. BIND_CONSTANT(RENDER_PRIORITY_MAX);
  137. BIND_CONSTANT(RENDER_PRIORITY_MIN);
  138. GDVIRTUAL_BIND(_get_shader_rid)
  139. GDVIRTUAL_BIND(_get_shader_mode)
  140. GDVIRTUAL_BIND(_can_do_next_pass)
  141. GDVIRTUAL_BIND(_can_use_render_priority)
  142. }
  143. Material::Material() {
  144. material = RenderingServer::get_singleton()->material_create();
  145. render_priority = 0;
  146. }
  147. Material::~Material() {
  148. ERR_FAIL_NULL(RenderingServer::get_singleton());
  149. RenderingServer::get_singleton()->free(material);
  150. }
  151. ///////////////////////////////////
  152. bool ShaderMaterial::_set(const StringName &p_name, const Variant &p_value) {
  153. if (shader.is_valid()) {
  154. const StringName *sn = remap_cache.getptr(p_name);
  155. if (sn) {
  156. set_shader_parameter(*sn, p_value);
  157. return true;
  158. }
  159. String s = p_name;
  160. if (s.begins_with("shader_parameter/")) {
  161. String param = s.replace_first("shader_parameter/", "");
  162. remap_cache[s] = param;
  163. set_shader_parameter(param, p_value);
  164. return true;
  165. }
  166. #ifndef DISABLE_DEPRECATED
  167. // Compatibility remaps are only needed here.
  168. if (s.begins_with("param/")) {
  169. s = s.replace_first("param/", "shader_parameter/");
  170. } else if (s.begins_with("shader_param/")) {
  171. s = s.replace_first("shader_param/", "shader_parameter/");
  172. } else if (s.begins_with("shader_uniform/")) {
  173. s = s.replace_first("shader_uniform/", "shader_parameter/");
  174. } else {
  175. return false; // Not a shader parameter.
  176. }
  177. 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.");
  178. String param = s.replace_first("shader_parameter/", "");
  179. remap_cache[s] = param;
  180. set_shader_parameter(param, p_value);
  181. return true;
  182. #endif
  183. }
  184. return false;
  185. }
  186. bool ShaderMaterial::_get(const StringName &p_name, Variant &r_ret) const {
  187. if (shader.is_valid()) {
  188. const StringName *sn = remap_cache.getptr(p_name);
  189. if (sn) {
  190. // Only return a parameter if it was previously set.
  191. r_ret = get_shader_parameter(*sn);
  192. return true;
  193. }
  194. }
  195. return false;
  196. }
  197. void ShaderMaterial::_get_property_list(List<PropertyInfo> *p_list) const {
  198. if (!shader.is_null()) {
  199. List<PropertyInfo> list;
  200. shader->get_shader_uniform_list(&list, true);
  201. HashMap<String, HashMap<String, List<PropertyInfo>>> groups;
  202. LocalVector<Pair<String, LocalVector<String>>> vgroups;
  203. {
  204. HashMap<String, List<PropertyInfo>> none_subgroup;
  205. none_subgroup.insert("<None>", List<PropertyInfo>());
  206. groups.insert("<None>", none_subgroup);
  207. }
  208. String last_group = "<None>";
  209. String last_subgroup = "<None>";
  210. bool is_none_group_undefined = true;
  211. bool is_none_group = true;
  212. for (List<PropertyInfo>::Element *E = list.front(); E; E = E->next()) {
  213. if (E->get().usage == PROPERTY_USAGE_GROUP) {
  214. if (!E->get().name.is_empty()) {
  215. Vector<String> vgroup = E->get().name.split("::");
  216. last_group = vgroup[0];
  217. if (vgroup.size() > 1) {
  218. last_subgroup = vgroup[1];
  219. } else {
  220. last_subgroup = "<None>";
  221. }
  222. is_none_group = false;
  223. if (!groups.has(last_group)) {
  224. PropertyInfo info;
  225. info.usage = PROPERTY_USAGE_GROUP;
  226. info.name = last_group.capitalize();
  227. info.hint_string = "shader_parameter/";
  228. List<PropertyInfo> none_subgroup;
  229. none_subgroup.push_back(info);
  230. HashMap<String, List<PropertyInfo>> subgroup_map;
  231. subgroup_map.insert("<None>", none_subgroup);
  232. groups.insert(last_group, subgroup_map);
  233. vgroups.push_back(Pair<String, LocalVector<String>>(last_group, { "<None>" }));
  234. }
  235. if (!groups[last_group].has(last_subgroup)) {
  236. PropertyInfo info;
  237. info.usage = PROPERTY_USAGE_SUBGROUP;
  238. info.name = last_subgroup.capitalize();
  239. info.hint_string = "shader_parameter/";
  240. List<PropertyInfo> subgroup;
  241. subgroup.push_back(info);
  242. groups[last_group].insert(last_subgroup, subgroup);
  243. for (Pair<String, LocalVector<String>> &group : vgroups) {
  244. if (group.first == last_group) {
  245. group.second.push_back(last_subgroup);
  246. break;
  247. }
  248. }
  249. }
  250. } else {
  251. last_group = "<None>";
  252. last_subgroup = "<None>";
  253. is_none_group = true;
  254. }
  255. continue; // Pass group.
  256. }
  257. if (is_none_group_undefined && is_none_group) {
  258. is_none_group_undefined = false;
  259. PropertyInfo info;
  260. info.usage = PROPERTY_USAGE_GROUP;
  261. info.name = "Shader Parameters";
  262. info.hint_string = "shader_parameter/";
  263. groups["<None>"]["<None>"].push_back(info);
  264. vgroups.push_back(Pair<String, LocalVector<String>>("<None>", { "<None>" }));
  265. }
  266. const bool is_uniform_cached = param_cache.has(E->get().name);
  267. bool is_uniform_type_compatible = true;
  268. if (is_uniform_cached) {
  269. // Check if the uniform Variant type changed, for example vec3 to vec4.
  270. const Variant &cached = param_cache.get(E->get().name);
  271. if (cached.is_array()) {
  272. // Allow some array conversions for backwards compatibility.
  273. is_uniform_type_compatible = Variant::can_convert(E->get().type, cached.get_type());
  274. } else {
  275. is_uniform_type_compatible = E->get().type == cached.get_type();
  276. }
  277. if (is_uniform_type_compatible && E->get().type == Variant::OBJECT && cached.get_type() == Variant::OBJECT) {
  278. // Check if the Object class (hint string) changed, for example Texture2D sampler to Texture3D.
  279. // Allow inheritance, Texture2D type sampler should also accept CompressedTexture2D.
  280. Object *cached_obj = cached;
  281. if (!cached_obj->is_class(E->get().hint_string)) {
  282. is_uniform_type_compatible = false;
  283. }
  284. }
  285. }
  286. PropertyInfo info = E->get();
  287. info.name = "shader_parameter/" + info.name;
  288. if (!is_uniform_cached || !is_uniform_type_compatible) {
  289. // Property has never been edited or its type changed, retrieve with default value.
  290. Variant default_value = RenderingServer::get_singleton()->shader_get_parameter_default(shader->get_rid(), E->get().name);
  291. param_cache.insert(E->get().name, default_value);
  292. remap_cache.insert(info.name, E->get().name);
  293. }
  294. groups[last_group][last_subgroup].push_back(info);
  295. }
  296. for (const Pair<String, LocalVector<String>> &group_pair : vgroups) {
  297. String group = group_pair.first;
  298. for (const String &subgroup : group_pair.second) {
  299. List<PropertyInfo> &prop_infos = groups[group][subgroup];
  300. for (List<PropertyInfo>::Element *item = prop_infos.front(); item; item = item->next()) {
  301. p_list->push_back(item->get());
  302. }
  303. }
  304. }
  305. }
  306. }
  307. bool ShaderMaterial::_property_can_revert(const StringName &p_name) const {
  308. if (shader.is_valid()) {
  309. const StringName *pr = remap_cache.getptr(p_name);
  310. if (pr) {
  311. Variant default_value = RenderingServer::get_singleton()->shader_get_parameter_default(shader->get_rid(), *pr);
  312. Variant current_value = get_shader_parameter(*pr);
  313. return default_value.get_type() != Variant::NIL && default_value != current_value;
  314. }
  315. }
  316. return false;
  317. }
  318. bool ShaderMaterial::_property_get_revert(const StringName &p_name, Variant &r_property) const {
  319. if (shader.is_valid()) {
  320. const StringName *pr = remap_cache.getptr(p_name);
  321. if (*pr) {
  322. r_property = RenderingServer::get_singleton()->shader_get_parameter_default(shader->get_rid(), *pr);
  323. return true;
  324. }
  325. }
  326. return false;
  327. }
  328. void ShaderMaterial::set_shader(const Ref<Shader> &p_shader) {
  329. // Only connect/disconnect the signal when running in the editor.
  330. // This can be a slow operation, and `notify_property_list_changed()` (which is called by `_shader_changed()`)
  331. // does nothing in non-editor builds anyway. See GH-34741 for details.
  332. if (shader.is_valid() && Engine::get_singleton()->is_editor_hint()) {
  333. shader->disconnect_changed(callable_mp(this, &ShaderMaterial::_shader_changed));
  334. }
  335. shader = p_shader;
  336. RID rid;
  337. if (shader.is_valid()) {
  338. rid = shader->get_rid();
  339. if (Engine::get_singleton()->is_editor_hint()) {
  340. shader->connect_changed(callable_mp(this, &ShaderMaterial::_shader_changed));
  341. }
  342. }
  343. RS::get_singleton()->material_set_shader(_get_material(), rid);
  344. notify_property_list_changed(); //properties for shader exposed
  345. emit_changed();
  346. }
  347. Ref<Shader> ShaderMaterial::get_shader() const {
  348. return shader;
  349. }
  350. void ShaderMaterial::set_shader_parameter(const StringName &p_param, const Variant &p_value) {
  351. if (p_value.get_type() == Variant::NIL) {
  352. param_cache.erase(p_param);
  353. RS::get_singleton()->material_set_param(_get_material(), p_param, Variant());
  354. } else {
  355. Variant *v = param_cache.getptr(p_param);
  356. if (!v) {
  357. // Never assigned, also update the remap cache.
  358. remap_cache["shader_parameter/" + p_param.operator String()] = p_param;
  359. param_cache.insert(p_param, p_value);
  360. } else {
  361. *v = p_value;
  362. }
  363. if (p_value.get_type() == Variant::OBJECT) {
  364. RID tex_rid = p_value;
  365. if (tex_rid == RID()) {
  366. param_cache.erase(p_param);
  367. RS::get_singleton()->material_set_param(_get_material(), p_param, Variant());
  368. } else {
  369. RS::get_singleton()->material_set_param(_get_material(), p_param, tex_rid);
  370. }
  371. } else {
  372. RS::get_singleton()->material_set_param(_get_material(), p_param, p_value);
  373. }
  374. }
  375. }
  376. Variant ShaderMaterial::get_shader_parameter(const StringName &p_param) const {
  377. if (param_cache.has(p_param)) {
  378. return param_cache[p_param];
  379. } else {
  380. return Variant();
  381. }
  382. }
  383. void ShaderMaterial::_shader_changed() {
  384. notify_property_list_changed(); //update all properties
  385. }
  386. void ShaderMaterial::_bind_methods() {
  387. ClassDB::bind_method(D_METHOD("set_shader", "shader"), &ShaderMaterial::set_shader);
  388. ClassDB::bind_method(D_METHOD("get_shader"), &ShaderMaterial::get_shader);
  389. ClassDB::bind_method(D_METHOD("set_shader_parameter", "param", "value"), &ShaderMaterial::set_shader_parameter);
  390. ClassDB::bind_method(D_METHOD("get_shader_parameter", "param"), &ShaderMaterial::get_shader_parameter);
  391. ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "shader", PROPERTY_HINT_RESOURCE_TYPE, "Shader"), "set_shader", "get_shader");
  392. }
  393. void ShaderMaterial::get_argument_options(const StringName &p_function, int p_idx, List<String> *r_options) const {
  394. String f = p_function.operator String();
  395. if ((f == "get_shader_parameter" || f == "set_shader_parameter") && p_idx == 0) {
  396. if (shader.is_valid()) {
  397. List<PropertyInfo> pl;
  398. shader->get_shader_uniform_list(&pl);
  399. for (const PropertyInfo &E : pl) {
  400. r_options->push_back(E.name.replace_first("shader_parameter/", "").quote());
  401. }
  402. }
  403. }
  404. Material::get_argument_options(p_function, p_idx, r_options);
  405. }
  406. bool ShaderMaterial::_can_do_next_pass() const {
  407. return shader.is_valid() && shader->get_mode() == Shader::MODE_SPATIAL;
  408. }
  409. bool ShaderMaterial::_can_use_render_priority() const {
  410. return shader.is_valid() && shader->get_mode() == Shader::MODE_SPATIAL;
  411. }
  412. Shader::Mode ShaderMaterial::get_shader_mode() const {
  413. if (shader.is_valid()) {
  414. return shader->get_mode();
  415. } else {
  416. return Shader::MODE_SPATIAL;
  417. }
  418. }
  419. RID ShaderMaterial::get_shader_rid() const {
  420. if (shader.is_valid()) {
  421. return shader->get_rid();
  422. } else {
  423. return RID();
  424. }
  425. }
  426. ShaderMaterial::ShaderMaterial() {
  427. }
  428. ShaderMaterial::~ShaderMaterial() {
  429. }
  430. /////////////////////////////////
  431. Mutex BaseMaterial3D::material_mutex;
  432. SelfList<BaseMaterial3D>::List BaseMaterial3D::dirty_materials;
  433. HashMap<BaseMaterial3D::MaterialKey, BaseMaterial3D::ShaderData, BaseMaterial3D::MaterialKey> BaseMaterial3D::shader_map;
  434. BaseMaterial3D::ShaderNames *BaseMaterial3D::shader_names = nullptr;
  435. void BaseMaterial3D::init_shaders() {
  436. shader_names = memnew(ShaderNames);
  437. shader_names->albedo = "albedo";
  438. shader_names->specular = "specular";
  439. shader_names->roughness = "roughness";
  440. shader_names->metallic = "metallic";
  441. shader_names->emission = "emission";
  442. shader_names->emission_energy = "emission_energy";
  443. shader_names->normal_scale = "normal_scale";
  444. shader_names->rim = "rim";
  445. shader_names->rim_tint = "rim_tint";
  446. shader_names->clearcoat = "clearcoat";
  447. shader_names->clearcoat_roughness = "clearcoat_roughness";
  448. shader_names->anisotropy = "anisotropy_ratio";
  449. shader_names->heightmap_scale = "heightmap_scale";
  450. shader_names->subsurface_scattering_strength = "subsurface_scattering_strength";
  451. shader_names->backlight = "backlight";
  452. shader_names->refraction = "refraction";
  453. shader_names->point_size = "point_size";
  454. shader_names->uv1_scale = "uv1_scale";
  455. shader_names->uv1_offset = "uv1_offset";
  456. shader_names->uv2_scale = "uv2_scale";
  457. shader_names->uv2_offset = "uv2_offset";
  458. shader_names->uv1_blend_sharpness = "uv1_blend_sharpness";
  459. shader_names->uv2_blend_sharpness = "uv2_blend_sharpness";
  460. shader_names->particles_anim_h_frames = "particles_anim_h_frames";
  461. shader_names->particles_anim_v_frames = "particles_anim_v_frames";
  462. shader_names->particles_anim_loop = "particles_anim_loop";
  463. shader_names->heightmap_min_layers = "heightmap_min_layers";
  464. shader_names->heightmap_max_layers = "heightmap_max_layers";
  465. shader_names->heightmap_flip = "heightmap_flip";
  466. shader_names->grow = "grow";
  467. shader_names->ao_light_affect = "ao_light_affect";
  468. shader_names->proximity_fade_distance = "proximity_fade_distance";
  469. shader_names->distance_fade_min = "distance_fade_min";
  470. shader_names->distance_fade_max = "distance_fade_max";
  471. shader_names->msdf_pixel_range = "msdf_pixel_range";
  472. shader_names->msdf_outline_size = "msdf_outline_size";
  473. shader_names->metallic_texture_channel = "metallic_texture_channel";
  474. shader_names->ao_texture_channel = "ao_texture_channel";
  475. shader_names->clearcoat_texture_channel = "clearcoat_texture_channel";
  476. shader_names->rim_texture_channel = "rim_texture_channel";
  477. shader_names->heightmap_texture_channel = "heightmap_texture_channel";
  478. shader_names->refraction_texture_channel = "refraction_texture_channel";
  479. shader_names->transmittance_color = "transmittance_color";
  480. shader_names->transmittance_depth = "transmittance_depth";
  481. shader_names->transmittance_boost = "transmittance_boost";
  482. shader_names->texture_names[TEXTURE_ALBEDO] = "texture_albedo";
  483. shader_names->texture_names[TEXTURE_METALLIC] = "texture_metallic";
  484. shader_names->texture_names[TEXTURE_ROUGHNESS] = "texture_roughness";
  485. shader_names->texture_names[TEXTURE_EMISSION] = "texture_emission";
  486. shader_names->texture_names[TEXTURE_NORMAL] = "texture_normal";
  487. shader_names->texture_names[TEXTURE_RIM] = "texture_rim";
  488. shader_names->texture_names[TEXTURE_CLEARCOAT] = "texture_clearcoat";
  489. shader_names->texture_names[TEXTURE_FLOWMAP] = "texture_flowmap";
  490. shader_names->texture_names[TEXTURE_AMBIENT_OCCLUSION] = "texture_ambient_occlusion";
  491. shader_names->texture_names[TEXTURE_HEIGHTMAP] = "texture_heightmap";
  492. shader_names->texture_names[TEXTURE_SUBSURFACE_SCATTERING] = "texture_subsurface_scattering";
  493. shader_names->texture_names[TEXTURE_SUBSURFACE_TRANSMITTANCE] = "texture_subsurface_transmittance";
  494. shader_names->texture_names[TEXTURE_BACKLIGHT] = "texture_backlight";
  495. shader_names->texture_names[TEXTURE_REFRACTION] = "texture_refraction";
  496. shader_names->texture_names[TEXTURE_DETAIL_MASK] = "texture_detail_mask";
  497. shader_names->texture_names[TEXTURE_DETAIL_ALBEDO] = "texture_detail_albedo";
  498. shader_names->texture_names[TEXTURE_DETAIL_NORMAL] = "texture_detail_normal";
  499. shader_names->texture_names[TEXTURE_ORM] = "texture_orm";
  500. shader_names->alpha_scissor_threshold = "alpha_scissor_threshold";
  501. shader_names->alpha_hash_scale = "alpha_hash_scale";
  502. shader_names->alpha_antialiasing_edge = "alpha_antialiasing_edge";
  503. shader_names->albedo_texture_size = "albedo_texture_size";
  504. }
  505. HashMap<uint64_t, Ref<StandardMaterial3D>> BaseMaterial3D::materials_for_2d;
  506. void BaseMaterial3D::finish_shaders() {
  507. materials_for_2d.clear();
  508. dirty_materials.clear();
  509. memdelete(shader_names);
  510. shader_names = nullptr;
  511. }
  512. void BaseMaterial3D::_update_shader() {
  513. dirty_materials.remove(&element);
  514. MaterialKey mk = _compute_key();
  515. if (mk == current_key) {
  516. return; //no update required in the end
  517. }
  518. if (shader_map.has(current_key)) {
  519. shader_map[current_key].users--;
  520. if (shader_map[current_key].users == 0) {
  521. //deallocate shader, as it's no longer in use
  522. RS::get_singleton()->free(shader_map[current_key].shader);
  523. shader_map.erase(current_key);
  524. }
  525. }
  526. current_key = mk;
  527. if (shader_map.has(mk)) {
  528. RS::get_singleton()->material_set_shader(_get_material(), shader_map[mk].shader);
  529. shader_map[mk].users++;
  530. return;
  531. }
  532. String texfilter_str;
  533. // Force linear filtering for the heightmap texture, as the heightmap effect
  534. // looks broken with nearest-neighbor filtering (with and without Deep Parallax).
  535. String texfilter_height_str;
  536. switch (texture_filter) {
  537. case TEXTURE_FILTER_NEAREST:
  538. texfilter_str = "filter_nearest";
  539. texfilter_height_str = "filter_linear";
  540. break;
  541. case TEXTURE_FILTER_LINEAR:
  542. texfilter_str = "filter_linear";
  543. texfilter_height_str = "filter_linear";
  544. break;
  545. case TEXTURE_FILTER_NEAREST_WITH_MIPMAPS:
  546. texfilter_str = "filter_nearest_mipmap";
  547. texfilter_height_str = "filter_linear_mipmap";
  548. break;
  549. case TEXTURE_FILTER_LINEAR_WITH_MIPMAPS:
  550. texfilter_str = "filter_linear_mipmap";
  551. texfilter_height_str = "filter_linear_mipmap";
  552. break;
  553. case TEXTURE_FILTER_NEAREST_WITH_MIPMAPS_ANISOTROPIC:
  554. texfilter_str = "filter_nearest_mipmap_anisotropic";
  555. texfilter_height_str = "filter_linear_mipmap_anisotropic";
  556. break;
  557. case TEXTURE_FILTER_LINEAR_WITH_MIPMAPS_ANISOTROPIC:
  558. texfilter_str = "filter_linear_mipmap_anisotropic";
  559. texfilter_height_str = "filter_linear_mipmap_anisotropic";
  560. break;
  561. case TEXTURE_FILTER_MAX:
  562. break; // Internal value, skip.
  563. }
  564. if (flags[FLAG_USE_TEXTURE_REPEAT]) {
  565. texfilter_str += ",repeat_enable";
  566. texfilter_height_str += ",repeat_enable";
  567. } else {
  568. texfilter_str += ",repeat_disable";
  569. texfilter_height_str += ",repeat_disable";
  570. }
  571. //must create a shader!
  572. // Add a comment to describe the shader origin (useful when converting to ShaderMaterial).
  573. String code = vformat(
  574. "// NOTE: Shader automatically converted from " VERSION_NAME " " VERSION_FULL_CONFIG "'s %s.\n\n",
  575. orm ? "ORMMaterial3D" : "StandardMaterial3D");
  576. code += "shader_type spatial;\nrender_mode ";
  577. switch (blend_mode) {
  578. case BLEND_MODE_MIX:
  579. code += "blend_mix";
  580. break;
  581. case BLEND_MODE_ADD:
  582. code += "blend_add";
  583. break;
  584. case BLEND_MODE_SUB:
  585. code += "blend_sub";
  586. break;
  587. case BLEND_MODE_MUL:
  588. code += "blend_mul";
  589. break;
  590. case BLEND_MODE_MAX:
  591. break; // Internal value, skip.
  592. }
  593. DepthDrawMode ddm = depth_draw_mode;
  594. if (features[FEATURE_REFRACTION]) {
  595. ddm = DEPTH_DRAW_ALWAYS;
  596. }
  597. switch (ddm) {
  598. case DEPTH_DRAW_OPAQUE_ONLY:
  599. code += ",depth_draw_opaque";
  600. break;
  601. case DEPTH_DRAW_ALWAYS:
  602. code += ",depth_draw_always";
  603. break;
  604. case DEPTH_DRAW_DISABLED:
  605. code += ",depth_draw_never";
  606. break;
  607. case DEPTH_DRAW_MAX:
  608. break; // Internal value, skip.
  609. }
  610. switch (cull_mode) {
  611. case CULL_BACK:
  612. code += ",cull_back";
  613. break;
  614. case CULL_FRONT:
  615. code += ",cull_front";
  616. break;
  617. case CULL_DISABLED:
  618. code += ",cull_disabled";
  619. break;
  620. case CULL_MAX:
  621. break; // Internal value, skip.
  622. }
  623. switch (diffuse_mode) {
  624. case DIFFUSE_BURLEY:
  625. code += ",diffuse_burley";
  626. break;
  627. case DIFFUSE_LAMBERT:
  628. code += ",diffuse_lambert";
  629. break;
  630. case DIFFUSE_LAMBERT_WRAP:
  631. code += ",diffuse_lambert_wrap";
  632. break;
  633. case DIFFUSE_TOON:
  634. code += ",diffuse_toon";
  635. break;
  636. case DIFFUSE_MAX:
  637. break; // Internal value, skip.
  638. }
  639. switch (specular_mode) {
  640. case SPECULAR_SCHLICK_GGX:
  641. code += ",specular_schlick_ggx";
  642. break;
  643. case SPECULAR_TOON:
  644. code += ",specular_toon";
  645. break;
  646. case SPECULAR_DISABLED:
  647. code += ",specular_disabled";
  648. break;
  649. case SPECULAR_MAX:
  650. break; // Internal value, skip.
  651. }
  652. if (features[FEATURE_SUBSURFACE_SCATTERING] && flags[FLAG_SUBSURFACE_MODE_SKIN]) {
  653. code += ",sss_mode_skin";
  654. }
  655. if (shading_mode == SHADING_MODE_UNSHADED) {
  656. code += ",unshaded";
  657. }
  658. if (flags[FLAG_DISABLE_DEPTH_TEST]) {
  659. code += ",depth_test_disabled";
  660. }
  661. if (flags[FLAG_PARTICLE_TRAILS_MODE]) {
  662. code += ",particle_trails";
  663. }
  664. if (shading_mode == SHADING_MODE_PER_VERTEX) {
  665. code += ",vertex_lighting";
  666. }
  667. if (flags[FLAG_DONT_RECEIVE_SHADOWS]) {
  668. code += ",shadows_disabled";
  669. }
  670. if (flags[FLAG_DISABLE_AMBIENT_LIGHT]) {
  671. code += ",ambient_light_disabled";
  672. }
  673. if (flags[FLAG_USE_SHADOW_TO_OPACITY]) {
  674. code += ",shadow_to_opacity";
  675. }
  676. if (flags[FLAG_DISABLE_FOG]) {
  677. code += ",fog_disabled";
  678. }
  679. if (transparency == TRANSPARENCY_ALPHA_DEPTH_PRE_PASS) {
  680. code += ",depth_prepass_alpha";
  681. }
  682. // Although its technically possible to do alpha antialiasing without using alpha hash or alpha scissor,
  683. // it is restricted in the base material because it has no use, and abusing it with regular Alpha blending can
  684. // saturate the MSAA mask
  685. if (transparency == TRANSPARENCY_ALPHA_HASH || transparency == TRANSPARENCY_ALPHA_SCISSOR) {
  686. // alpha antialiasing is only useful in ALPHA_HASH or ALPHA_SCISSOR
  687. if (alpha_antialiasing_mode == ALPHA_ANTIALIASING_ALPHA_TO_COVERAGE) {
  688. code += ",alpha_to_coverage";
  689. } else if (alpha_antialiasing_mode == ALPHA_ANTIALIASING_ALPHA_TO_COVERAGE_AND_TO_ONE) {
  690. code += ",alpha_to_coverage_and_one";
  691. }
  692. }
  693. code += ";\n";
  694. code += "uniform vec4 albedo : source_color;\n";
  695. code += "uniform sampler2D texture_albedo : source_color," + texfilter_str + ";\n";
  696. if (grow_enabled) {
  697. code += "uniform float grow;\n";
  698. }
  699. if (proximity_fade_enabled) {
  700. code += "uniform float proximity_fade_distance;\n";
  701. }
  702. if (distance_fade != DISTANCE_FADE_DISABLED) {
  703. code += "uniform float distance_fade_min;\n";
  704. code += "uniform float distance_fade_max;\n";
  705. }
  706. if (flags[FLAG_ALBEDO_TEXTURE_MSDF]) {
  707. code += "uniform float msdf_pixel_range;\n";
  708. code += "uniform float msdf_outline_size;\n";
  709. }
  710. // alpha scissor is only valid if there is not antialiasing edge
  711. // alpha hash is valid whenever, but not with alpha scissor
  712. if (transparency == TRANSPARENCY_ALPHA_SCISSOR) {
  713. code += "uniform float alpha_scissor_threshold;\n";
  714. } else if (transparency == TRANSPARENCY_ALPHA_HASH) {
  715. code += "uniform float alpha_hash_scale;\n";
  716. }
  717. // if alpha antialiasing isn't off, add in the edge variable
  718. if (alpha_antialiasing_mode != ALPHA_ANTIALIASING_OFF &&
  719. (transparency == TRANSPARENCY_ALPHA_SCISSOR || transparency == TRANSPARENCY_ALPHA_HASH)) {
  720. code += "uniform float alpha_antialiasing_edge;\n";
  721. code += "uniform ivec2 albedo_texture_size;\n";
  722. }
  723. code += "uniform float point_size : hint_range(0,128);\n";
  724. //TODO ALL HINTS
  725. if (!orm) {
  726. code += "uniform float roughness : hint_range(0,1);\n";
  727. code += "uniform sampler2D texture_metallic : hint_default_white," + texfilter_str + ";\n";
  728. code += "uniform vec4 metallic_texture_channel;\n";
  729. switch (roughness_texture_channel) {
  730. case TEXTURE_CHANNEL_RED: {
  731. code += "uniform sampler2D texture_roughness : hint_roughness_r," + texfilter_str + ";\n";
  732. } break;
  733. case TEXTURE_CHANNEL_GREEN: {
  734. code += "uniform sampler2D texture_roughness : hint_roughness_g," + texfilter_str + ";\n";
  735. } break;
  736. case TEXTURE_CHANNEL_BLUE: {
  737. code += "uniform sampler2D texture_roughness : hint_roughness_b," + texfilter_str + ";\n";
  738. } break;
  739. case TEXTURE_CHANNEL_ALPHA: {
  740. code += "uniform sampler2D texture_roughness : hint_roughness_a," + texfilter_str + ";\n";
  741. } break;
  742. case TEXTURE_CHANNEL_GRAYSCALE: {
  743. code += "uniform sampler2D texture_roughness : hint_roughness_gray," + texfilter_str + ";\n";
  744. } break;
  745. case TEXTURE_CHANNEL_MAX:
  746. break; // Internal value, skip.
  747. }
  748. code += "uniform float specular;\n";
  749. code += "uniform float metallic;\n";
  750. } else {
  751. code += "uniform sampler2D texture_orm : hint_roughness_g," + texfilter_str + ";\n";
  752. }
  753. if (billboard_mode == BILLBOARD_PARTICLES) {
  754. code += "uniform int particles_anim_h_frames;\n";
  755. code += "uniform int particles_anim_v_frames;\n";
  756. code += "uniform bool particles_anim_loop;\n";
  757. }
  758. if (features[FEATURE_EMISSION]) {
  759. code += "uniform sampler2D texture_emission : source_color, hint_default_black," + texfilter_str + ";\n";
  760. code += "uniform vec4 emission : source_color;\n";
  761. code += "uniform float emission_energy;\n";
  762. }
  763. if (features[FEATURE_REFRACTION]) {
  764. code += "uniform sampler2D texture_refraction : " + texfilter_str + ";\n";
  765. code += "uniform float refraction : hint_range(-16,16);\n";
  766. code += "uniform vec4 refraction_texture_channel;\n";
  767. }
  768. if (features[FEATURE_REFRACTION]) {
  769. code += "uniform sampler2D screen_texture : hint_screen_texture, repeat_disable, filter_linear_mipmap;";
  770. }
  771. if (proximity_fade_enabled) {
  772. code += "uniform sampler2D depth_texture : hint_depth_texture, repeat_disable, filter_nearest;";
  773. }
  774. if (features[FEATURE_NORMAL_MAPPING]) {
  775. code += "uniform sampler2D texture_normal : hint_roughness_normal," + texfilter_str + ";\n";
  776. code += "uniform float normal_scale : hint_range(-16,16);\n";
  777. }
  778. if (features[FEATURE_RIM]) {
  779. code += "uniform float rim : hint_range(0,1);\n";
  780. code += "uniform float rim_tint : hint_range(0,1);\n";
  781. code += "uniform sampler2D texture_rim : hint_default_white," + texfilter_str + ";\n";
  782. }
  783. if (features[FEATURE_CLEARCOAT]) {
  784. code += "uniform float clearcoat : hint_range(0,1);\n";
  785. code += "uniform float clearcoat_roughness : hint_range(0,1);\n";
  786. code += "uniform sampler2D texture_clearcoat : hint_default_white," + texfilter_str + ";\n";
  787. }
  788. if (features[FEATURE_ANISOTROPY]) {
  789. code += "uniform float anisotropy_ratio : hint_range(0,256);\n";
  790. code += "uniform sampler2D texture_flowmap : hint_anisotropy," + texfilter_str + ";\n";
  791. }
  792. if (features[FEATURE_AMBIENT_OCCLUSION]) {
  793. code += "uniform sampler2D texture_ambient_occlusion : hint_default_white, " + texfilter_str + ";\n";
  794. code += "uniform vec4 ao_texture_channel;\n";
  795. code += "uniform float ao_light_affect;\n";
  796. }
  797. if (features[FEATURE_DETAIL]) {
  798. code += "uniform sampler2D texture_detail_albedo : source_color," + texfilter_str + ";\n";
  799. code += "uniform sampler2D texture_detail_normal : hint_normal," + texfilter_str + ";\n";
  800. code += "uniform sampler2D texture_detail_mask : hint_default_white," + texfilter_str + ";\n";
  801. }
  802. if (features[FEATURE_SUBSURFACE_SCATTERING]) {
  803. code += "uniform float subsurface_scattering_strength : hint_range(0,1);\n";
  804. code += "uniform sampler2D texture_subsurface_scattering : hint_default_white," + texfilter_str + ";\n";
  805. }
  806. if (features[FEATURE_SUBSURFACE_TRANSMITTANCE]) {
  807. code += "uniform vec4 transmittance_color : source_color;\n";
  808. code += "uniform float transmittance_depth;\n";
  809. code += "uniform sampler2D texture_subsurface_transmittance : hint_default_white," + texfilter_str + ";\n";
  810. code += "uniform float transmittance_boost;\n";
  811. }
  812. if (features[FEATURE_BACKLIGHT]) {
  813. code += "uniform vec4 backlight : source_color;\n";
  814. code += "uniform sampler2D texture_backlight : hint_default_black," + texfilter_str + ";\n";
  815. }
  816. if (features[FEATURE_HEIGHT_MAPPING]) {
  817. code += "uniform sampler2D texture_heightmap : hint_default_black," + texfilter_height_str + ";\n";
  818. code += "uniform float heightmap_scale;\n";
  819. code += "uniform int heightmap_min_layers;\n";
  820. code += "uniform int heightmap_max_layers;\n";
  821. code += "uniform vec2 heightmap_flip;\n";
  822. }
  823. if (flags[FLAG_UV1_USE_TRIPLANAR]) {
  824. code += "varying vec3 uv1_triplanar_pos;\n";
  825. }
  826. if (flags[FLAG_UV2_USE_TRIPLANAR]) {
  827. code += "varying vec3 uv2_triplanar_pos;\n";
  828. }
  829. if (flags[FLAG_UV1_USE_TRIPLANAR]) {
  830. code += "uniform float uv1_blend_sharpness;\n";
  831. code += "varying vec3 uv1_power_normal;\n";
  832. }
  833. if (flags[FLAG_UV2_USE_TRIPLANAR]) {
  834. code += "uniform float uv2_blend_sharpness;\n";
  835. code += "varying vec3 uv2_power_normal;\n";
  836. }
  837. code += "uniform vec3 uv1_scale;\n";
  838. code += "uniform vec3 uv1_offset;\n";
  839. code += "uniform vec3 uv2_scale;\n";
  840. code += "uniform vec3 uv2_offset;\n";
  841. code += "\n\n";
  842. code += "void vertex() {\n";
  843. if (flags[FLAG_SRGB_VERTEX_COLOR]) {
  844. code += " if (!OUTPUT_IS_SRGB) {\n";
  845. code += " COLOR.rgb = mix(pow((COLOR.rgb + vec3(0.055)) * (1.0 / (1.0 + 0.055)), vec3(2.4)), COLOR.rgb * (1.0 / 12.92), lessThan(COLOR.rgb, vec3(0.04045)));\n";
  846. code += " }\n";
  847. }
  848. if (flags[FLAG_USE_POINT_SIZE]) {
  849. code += " POINT_SIZE=point_size;\n";
  850. }
  851. if (shading_mode == SHADING_MODE_PER_VERTEX) {
  852. code += " ROUGHNESS=roughness;\n";
  853. }
  854. if (!flags[FLAG_UV1_USE_TRIPLANAR]) {
  855. code += " UV=UV*uv1_scale.xy+uv1_offset.xy;\n";
  856. }
  857. switch (billboard_mode) {
  858. case BILLBOARD_DISABLED: {
  859. } break;
  860. case BILLBOARD_ENABLED: {
  861. code += " MODELVIEW_MATRIX = VIEW_MATRIX * mat4(INV_VIEW_MATRIX[0], INV_VIEW_MATRIX[1], INV_VIEW_MATRIX[2], MODEL_MATRIX[3]);\n";
  862. if (flags[FLAG_BILLBOARD_KEEP_SCALE]) {
  863. code += " MODELVIEW_MATRIX = MODELVIEW_MATRIX * mat4(vec4(length(MODEL_MATRIX[0].xyz), 0.0, 0.0, 0.0), vec4(0.0, length(MODEL_MATRIX[1].xyz), 0.0, 0.0), vec4(0.0, 0.0, length(MODEL_MATRIX[2].xyz), 0.0), vec4(0.0, 0.0, 0.0, 1.0));\n";
  864. }
  865. code += " MODELVIEW_NORMAL_MATRIX = mat3(MODELVIEW_MATRIX);\n";
  866. } break;
  867. case BILLBOARD_FIXED_Y: {
  868. code += " MODELVIEW_MATRIX = VIEW_MATRIX * mat4(vec4(normalize(cross(vec3(0.0, 1.0, 0.0), INV_VIEW_MATRIX[2].xyz)), 0.0), vec4(0.0, 1.0, 0.0, 0.0), vec4(normalize(cross(INV_VIEW_MATRIX[0].xyz, vec3(0.0, 1.0, 0.0))), 0.0), MODEL_MATRIX[3]);\n";
  869. if (flags[FLAG_BILLBOARD_KEEP_SCALE]) {
  870. code += " MODELVIEW_MATRIX = MODELVIEW_MATRIX * mat4(vec4(length(MODEL_MATRIX[0].xyz), 0.0, 0.0, 0.0),vec4(0.0, length(MODEL_MATRIX[1].xyz), 0.0, 0.0), vec4(0.0, 0.0, length(MODEL_MATRIX[2].xyz), 0.0), vec4(0.0, 0.0, 0.0, 1.0));\n";
  871. }
  872. code += " MODELVIEW_NORMAL_MATRIX = mat3(MODELVIEW_MATRIX);\n";
  873. } break;
  874. case BILLBOARD_PARTICLES: {
  875. //make billboard
  876. code += " mat4 mat_world = mat4(normalize(INV_VIEW_MATRIX[0]), normalize(INV_VIEW_MATRIX[1]) ,normalize(INV_VIEW_MATRIX[2]), MODEL_MATRIX[3]);\n";
  877. //rotate by rotation
  878. code += " mat_world = mat_world * mat4(vec4(cos(INSTANCE_CUSTOM.x), -sin(INSTANCE_CUSTOM.x), 0.0, 0.0), vec4(sin(INSTANCE_CUSTOM.x), cos(INSTANCE_CUSTOM.x), 0.0, 0.0), vec4(0.0, 0.0, 1.0, 0.0), vec4(0.0, 0.0, 0.0, 1.0));\n";
  879. //set modelview
  880. code += " MODELVIEW_MATRIX = VIEW_MATRIX * mat_world;\n";
  881. if (flags[FLAG_BILLBOARD_KEEP_SCALE]) {
  882. code += " MODELVIEW_MATRIX = MODELVIEW_MATRIX * mat4(vec4(length(MODEL_MATRIX[0].xyz), 0.0, 0.0, 0.0),vec4(0.0, length(MODEL_MATRIX[1].xyz), 0.0, 0.0), vec4(0.0, 0.0, length(MODEL_MATRIX[2].xyz), 0.0), vec4(0.0, 0.0, 0.0, 1.0));\n";
  883. }
  884. //set modelview normal
  885. code += " MODELVIEW_NORMAL_MATRIX = mat3(MODELVIEW_MATRIX);\n";
  886. //handle animation
  887. code += " float h_frames = float(particles_anim_h_frames);\n";
  888. code += " float v_frames = float(particles_anim_v_frames);\n";
  889. code += " float particle_total_frames = float(particles_anim_h_frames * particles_anim_v_frames);\n";
  890. code += " float particle_frame = floor(INSTANCE_CUSTOM.z * float(particle_total_frames));\n";
  891. code += " if (!particles_anim_loop) {\n";
  892. code += " particle_frame = clamp(particle_frame, 0.0, particle_total_frames - 1.0);\n";
  893. code += " } else {\n";
  894. code += " particle_frame = mod(particle_frame, particle_total_frames);\n";
  895. code += " }\n";
  896. code += " UV /= vec2(h_frames, v_frames);\n";
  897. code += " UV += vec2(mod(particle_frame, h_frames) / h_frames, floor((particle_frame + 0.5) / h_frames) / v_frames);\n";
  898. } break;
  899. case BILLBOARD_MAX:
  900. break; // Internal value, skip.
  901. }
  902. if (flags[FLAG_FIXED_SIZE]) {
  903. code += " if (PROJECTION_MATRIX[3][3] != 0.0) {\n";
  904. //orthogonal matrix, try to do about the same
  905. //with viewport size
  906. code += " float h = abs(1.0 / (2.0 * PROJECTION_MATRIX[1][1]));\n";
  907. code += " float sc = (h * 2.0); //consistent with Y-fov\n";
  908. code += " MODELVIEW_MATRIX[0]*=sc;\n";
  909. code += " MODELVIEW_MATRIX[1]*=sc;\n";
  910. code += " MODELVIEW_MATRIX[2]*=sc;\n";
  911. code += " } else {\n";
  912. //just scale by depth
  913. code += " float sc = -(MODELVIEW_MATRIX)[3].z;\n";
  914. code += " MODELVIEW_MATRIX[0]*=sc;\n";
  915. code += " MODELVIEW_MATRIX[1]*=sc;\n";
  916. code += " MODELVIEW_MATRIX[2]*=sc;\n";
  917. code += " }\n";
  918. }
  919. if (detail_uv == DETAIL_UV_2 && !flags[FLAG_UV2_USE_TRIPLANAR]) {
  920. code += " UV2=UV2*uv2_scale.xy+uv2_offset.xy;\n";
  921. }
  922. if (flags[FLAG_UV1_USE_TRIPLANAR] || flags[FLAG_UV2_USE_TRIPLANAR]) {
  923. //generate tangent and binormal in world space
  924. if (flags[FLAG_UV1_USE_WORLD_TRIPLANAR]) {
  925. code += " vec3 normal = MODEL_NORMAL_MATRIX * NORMAL;\n";
  926. } else {
  927. code += " vec3 normal = NORMAL;\n";
  928. }
  929. code += " TANGENT = vec3(0.0,0.0,-1.0) * abs(normal.x);\n";
  930. code += " TANGENT+= vec3(1.0,0.0,0.0) * abs(normal.y);\n";
  931. code += " TANGENT+= vec3(1.0,0.0,0.0) * abs(normal.z);\n";
  932. if (flags[FLAG_UV1_USE_WORLD_TRIPLANAR]) {
  933. code += " TANGENT = inverse(MODEL_NORMAL_MATRIX) * normalize(TANGENT);\n";
  934. } else {
  935. code += " TANGENT = normalize(TANGENT);\n";
  936. }
  937. code += " BINORMAL = vec3(0.0,1.0,0.0) * abs(normal.x);\n";
  938. code += " BINORMAL+= vec3(0.0,0.0,-1.0) * abs(normal.y);\n";
  939. code += " BINORMAL+= vec3(0.0,1.0,0.0) * abs(normal.z);\n";
  940. if (flags[FLAG_UV1_USE_WORLD_TRIPLANAR]) {
  941. code += " BINORMAL = inverse(MODEL_NORMAL_MATRIX) * normalize(BINORMAL);\n";
  942. } else {
  943. code += " BINORMAL = normalize(BINORMAL);\n";
  944. }
  945. }
  946. if (flags[FLAG_UV1_USE_TRIPLANAR]) {
  947. if (flags[FLAG_UV1_USE_WORLD_TRIPLANAR]) {
  948. code += " uv1_power_normal=pow(abs(normal),vec3(uv1_blend_sharpness));\n";
  949. code += " uv1_triplanar_pos = (MODEL_MATRIX * vec4(VERTEX, 1.0f)).xyz * uv1_scale + uv1_offset;\n";
  950. } else {
  951. code += " uv1_power_normal=pow(abs(NORMAL),vec3(uv1_blend_sharpness));\n";
  952. code += " uv1_triplanar_pos = VERTEX * uv1_scale + uv1_offset;\n";
  953. }
  954. code += " uv1_power_normal/=dot(uv1_power_normal,vec3(1.0));\n";
  955. code += " uv1_triplanar_pos *= vec3(1.0,-1.0, 1.0);\n";
  956. }
  957. if (flags[FLAG_UV2_USE_TRIPLANAR]) {
  958. if (flags[FLAG_UV2_USE_WORLD_TRIPLANAR]) {
  959. code += " uv2_power_normal=pow(abs(mat3(MODEL_MATRIX) * NORMAL), vec3(uv2_blend_sharpness));\n";
  960. code += " uv2_triplanar_pos = (MODEL_MATRIX * vec4(VERTEX, 1.0f)).xyz * uv2_scale + uv2_offset;\n";
  961. } else {
  962. code += " uv2_power_normal=pow(abs(NORMAL), vec3(uv2_blend_sharpness));\n";
  963. code += " uv2_triplanar_pos = VERTEX * uv2_scale + uv2_offset;\n";
  964. }
  965. code += " uv2_power_normal/=dot(uv2_power_normal,vec3(1.0));\n";
  966. code += " uv2_triplanar_pos *= vec3(1.0,-1.0, 1.0);\n";
  967. }
  968. if (grow_enabled) {
  969. code += " VERTEX+=NORMAL*grow;\n";
  970. }
  971. code += "}\n";
  972. code += "\n\n";
  973. if (flags[FLAG_ALBEDO_TEXTURE_MSDF]) {
  974. code += "float msdf_median(float r, float g, float b, float a) {\n";
  975. code += " return min(max(min(r, g), min(max(r, g), b)), a);\n";
  976. code += "}\n";
  977. }
  978. code += "\n\n";
  979. if (flags[FLAG_UV1_USE_TRIPLANAR] || flags[FLAG_UV2_USE_TRIPLANAR]) {
  980. code += "vec4 triplanar_texture(sampler2D p_sampler,vec3 p_weights,vec3 p_triplanar_pos) {\n";
  981. code += " vec4 samp=vec4(0.0);\n";
  982. code += " samp+= texture(p_sampler,p_triplanar_pos.xy) * p_weights.z;\n";
  983. code += " samp+= texture(p_sampler,p_triplanar_pos.xz) * p_weights.y;\n";
  984. code += " samp+= texture(p_sampler,p_triplanar_pos.zy * vec2(-1.0,1.0)) * p_weights.x;\n";
  985. code += " return samp;\n";
  986. code += "}\n";
  987. }
  988. code += "\n\n";
  989. code += "void fragment() {\n";
  990. if (!flags[FLAG_UV1_USE_TRIPLANAR]) {
  991. code += " vec2 base_uv = UV;\n";
  992. }
  993. 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])) {
  994. code += " vec2 base_uv2 = UV2;\n";
  995. }
  996. if (features[FEATURE_HEIGHT_MAPPING] && flags[FLAG_UV1_USE_TRIPLANAR]) {
  997. // Display both resource name and albedo texture name.
  998. // Materials are often built-in to scenes, so displaying the resource name alone may not be meaningful.
  999. // On the other hand, albedo textures are almost always external to the scene.
  1000. if (textures[TEXTURE_ALBEDO].is_valid()) {
  1001. 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()));
  1002. } else if (!get_path().is_empty()) {
  1003. WARN_PRINT(vformat("%s: Height mapping is not supported on triplanar materials. Ignoring height mapping in favor of triplanar mapping.", get_path()));
  1004. } else {
  1005. // Resource wasn't saved yet.
  1006. WARN_PRINT("Height mapping is not supported on triplanar materials. Ignoring height mapping in favor of triplanar mapping.");
  1007. }
  1008. }
  1009. if (!RenderingServer::get_singleton()->is_low_end() && features[FEATURE_HEIGHT_MAPPING] && !flags[FLAG_UV1_USE_TRIPLANAR]) { //heightmap not supported with triplanar
  1010. code += " {\n";
  1011. code += " vec3 view_dir = normalize(normalize(-VERTEX + EYE_OFFSET) * mat3(TANGENT * heightmap_flip.x, -BINORMAL * heightmap_flip.y, NORMAL));\n"; // binormal is negative due to mikktspace, flip 'unflips' it ;-)
  1012. if (deep_parallax) {
  1013. code += " float num_layers = mix(float(heightmap_max_layers),float(heightmap_min_layers), abs(dot(vec3(0.0, 0.0, 1.0), view_dir)));\n";
  1014. code += " float layer_depth = 1.0 / num_layers;\n";
  1015. code += " float current_layer_depth = 0.0;\n";
  1016. // Multiply the heightmap scale by 0.01 to improve heightmap scale usability.
  1017. code += " vec2 P = view_dir.xy * heightmap_scale * 0.01;\n";
  1018. code += " vec2 delta = P / num_layers;\n";
  1019. code += " vec2 ofs = base_uv;\n";
  1020. if (flags[FLAG_INVERT_HEIGHTMAP]) {
  1021. code += " float depth = texture(texture_heightmap, ofs).r;\n";
  1022. } else {
  1023. code += " float depth = 1.0 - texture(texture_heightmap, ofs).r;\n";
  1024. }
  1025. code += " float current_depth = 0.0;\n";
  1026. code += " while(current_depth < depth) {\n";
  1027. code += " ofs -= delta;\n";
  1028. if (flags[FLAG_INVERT_HEIGHTMAP]) {
  1029. code += " depth = texture(texture_heightmap, ofs).r;\n";
  1030. } else {
  1031. code += " depth = 1.0 - texture(texture_heightmap, ofs).r;\n";
  1032. }
  1033. code += " current_depth += layer_depth;\n";
  1034. code += " }\n";
  1035. code += " vec2 prev_ofs = ofs + delta;\n";
  1036. code += " float after_depth = depth - current_depth;\n";
  1037. if (flags[FLAG_INVERT_HEIGHTMAP]) {
  1038. code += " float before_depth = texture(texture_heightmap, prev_ofs).r - current_depth + layer_depth;\n";
  1039. } else {
  1040. code += " float before_depth = ( 1.0 - texture(texture_heightmap, prev_ofs).r ) - current_depth + layer_depth;\n";
  1041. }
  1042. code += " float weight = after_depth / (after_depth - before_depth);\n";
  1043. code += " ofs = mix(ofs,prev_ofs,weight);\n";
  1044. } else {
  1045. if (flags[FLAG_INVERT_HEIGHTMAP]) {
  1046. code += " float depth = texture(texture_heightmap, base_uv).r;\n";
  1047. } else {
  1048. code += " float depth = 1.0 - texture(texture_heightmap, base_uv).r;\n";
  1049. }
  1050. // Use offset limiting to improve the appearance of non-deep parallax.
  1051. // This reduces the impression of depth, but avoids visible warping in the distance.
  1052. // Multiply the heightmap scale by 0.01 to improve heightmap scale usability.
  1053. code += " vec2 ofs = base_uv - view_dir.xy * depth * heightmap_scale * 0.01;\n";
  1054. }
  1055. code += " base_uv=ofs;\n";
  1056. if (features[FEATURE_DETAIL] && detail_uv == DETAIL_UV_2) {
  1057. code += " base_uv2-=ofs;\n";
  1058. }
  1059. code += " }\n";
  1060. }
  1061. if (flags[FLAG_USE_POINT_SIZE]) {
  1062. code += " vec4 albedo_tex = texture(texture_albedo,POINT_COORD);\n";
  1063. } else {
  1064. if (flags[FLAG_UV1_USE_TRIPLANAR]) {
  1065. code += " vec4 albedo_tex = triplanar_texture(texture_albedo,uv1_power_normal,uv1_triplanar_pos);\n";
  1066. } else {
  1067. code += " vec4 albedo_tex = texture(texture_albedo,base_uv);\n";
  1068. }
  1069. }
  1070. if (flags[FLAG_ALBEDO_TEXTURE_MSDF]) {
  1071. code += " {\n";
  1072. code += " albedo_tex.rgb = mix(vec3(1.0 + 0.055) * pow(albedo_tex.rgb, vec3(1.0 / 2.4)) - vec3(0.055), vec3(12.92) * albedo_tex.rgb.rgb, lessThan(albedo_tex.rgb, vec3(0.0031308)));\n";
  1073. code += " vec2 msdf_size = vec2(msdf_pixel_range) / vec2(textureSize(texture_albedo, 0));\n";
  1074. if (flags[FLAG_USE_POINT_SIZE]) {
  1075. code += " vec2 dest_size = vec2(1.0) / fwidth(POINT_COORD);\n";
  1076. } else {
  1077. if (flags[FLAG_UV1_USE_TRIPLANAR]) {
  1078. code += " vec2 dest_size = vec2(1.0) / fwidth(uv1_triplanar_pos);\n";
  1079. } else {
  1080. code += " vec2 dest_size = vec2(1.0) / fwidth(base_uv);\n";
  1081. }
  1082. }
  1083. code += " float px_size = max(0.5 * dot(msdf_size, dest_size), 1.0);\n";
  1084. code += " float d = msdf_median(albedo_tex.r, albedo_tex.g, albedo_tex.b, albedo_tex.a) - 0.5;\n";
  1085. code += " if (msdf_outline_size > 0.0) {\n";
  1086. code += " float cr = clamp(msdf_outline_size, 0.0, msdf_pixel_range / 2.0) / msdf_pixel_range;\n";
  1087. code += " albedo_tex.a = clamp((d + cr) * px_size, 0.0, 1.0);\n";
  1088. code += " } else {\n";
  1089. code += " albedo_tex.a = clamp(d * px_size + 0.5, 0.0, 1.0);\n";
  1090. code += " }\n";
  1091. code += " albedo_tex.rgb = vec3(1.0);\n";
  1092. code += " }\n";
  1093. } else if (flags[FLAG_ALBEDO_TEXTURE_FORCE_SRGB]) {
  1094. code += " albedo_tex.rgb = mix(pow((albedo_tex.rgb + vec3(0.055)) * (1.0 / (1.0 + 0.055)),vec3(2.4)),albedo_tex.rgb.rgb * (1.0 / 12.92),lessThan(albedo_tex.rgb,vec3(0.04045)));\n";
  1095. }
  1096. if (flags[FLAG_ALBEDO_FROM_VERTEX_COLOR]) {
  1097. code += " albedo_tex *= COLOR;\n";
  1098. }
  1099. code += " ALBEDO = albedo.rgb * albedo_tex.rgb;\n";
  1100. if (!orm) {
  1101. if (flags[FLAG_UV1_USE_TRIPLANAR]) {
  1102. code += " float metallic_tex = dot(triplanar_texture(texture_metallic,uv1_power_normal,uv1_triplanar_pos),metallic_texture_channel);\n";
  1103. } else {
  1104. code += " float metallic_tex = dot(texture(texture_metallic,base_uv),metallic_texture_channel);\n";
  1105. }
  1106. code += " METALLIC = metallic_tex * metallic;\n";
  1107. switch (roughness_texture_channel) {
  1108. case TEXTURE_CHANNEL_RED: {
  1109. code += " vec4 roughness_texture_channel = vec4(1.0,0.0,0.0,0.0);\n";
  1110. } break;
  1111. case TEXTURE_CHANNEL_GREEN: {
  1112. code += " vec4 roughness_texture_channel = vec4(0.0,1.0,0.0,0.0);\n";
  1113. } break;
  1114. case TEXTURE_CHANNEL_BLUE: {
  1115. code += " vec4 roughness_texture_channel = vec4(0.0,0.0,1.0,0.0);\n";
  1116. } break;
  1117. case TEXTURE_CHANNEL_ALPHA: {
  1118. code += " vec4 roughness_texture_channel = vec4(0.0,0.0,0.0,1.0);\n";
  1119. } break;
  1120. case TEXTURE_CHANNEL_GRAYSCALE: {
  1121. code += " vec4 roughness_texture_channel = vec4(0.333333,0.333333,0.333333,0.0);\n";
  1122. } break;
  1123. case TEXTURE_CHANNEL_MAX:
  1124. break; // Internal value, skip.
  1125. }
  1126. if (flags[FLAG_UV1_USE_TRIPLANAR]) {
  1127. code += " float roughness_tex = dot(triplanar_texture(texture_roughness,uv1_power_normal,uv1_triplanar_pos),roughness_texture_channel);\n";
  1128. } else {
  1129. code += " float roughness_tex = dot(texture(texture_roughness,base_uv),roughness_texture_channel);\n";
  1130. }
  1131. code += " ROUGHNESS = roughness_tex * roughness;\n";
  1132. code += " SPECULAR = specular;\n";
  1133. } else {
  1134. if (flags[FLAG_UV1_USE_TRIPLANAR]) {
  1135. code += " vec4 orm_tex = triplanar_texture(texture_orm,uv1_power_normal,uv1_triplanar_pos);\n";
  1136. } else {
  1137. code += " vec4 orm_tex = texture(texture_orm,base_uv);\n";
  1138. }
  1139. code += " ROUGHNESS = orm_tex.g;\n";
  1140. code += " METALLIC = orm_tex.b;\n";
  1141. }
  1142. if (features[FEATURE_NORMAL_MAPPING]) {
  1143. if (flags[FLAG_UV1_USE_TRIPLANAR]) {
  1144. code += " NORMAL_MAP = triplanar_texture(texture_normal,uv1_power_normal,uv1_triplanar_pos).rgb;\n";
  1145. } else {
  1146. code += " NORMAL_MAP = texture(texture_normal,base_uv).rgb;\n";
  1147. }
  1148. code += " NORMAL_MAP_DEPTH = normal_scale;\n";
  1149. }
  1150. if (features[FEATURE_EMISSION]) {
  1151. if (flags[FLAG_EMISSION_ON_UV2]) {
  1152. if (flags[FLAG_UV2_USE_TRIPLANAR]) {
  1153. code += " vec3 emission_tex = triplanar_texture(texture_emission,uv2_power_normal,uv2_triplanar_pos).rgb;\n";
  1154. } else {
  1155. code += " vec3 emission_tex = texture(texture_emission,base_uv2).rgb;\n";
  1156. }
  1157. } else {
  1158. if (flags[FLAG_UV1_USE_TRIPLANAR]) {
  1159. code += " vec3 emission_tex = triplanar_texture(texture_emission,uv1_power_normal,uv1_triplanar_pos).rgb;\n";
  1160. } else {
  1161. code += " vec3 emission_tex = texture(texture_emission,base_uv).rgb;\n";
  1162. }
  1163. }
  1164. if (emission_op == EMISSION_OP_ADD) {
  1165. code += " EMISSION = (emission.rgb+emission_tex)*emission_energy;\n";
  1166. } else {
  1167. code += " EMISSION = (emission.rgb*emission_tex)*emission_energy;\n";
  1168. }
  1169. }
  1170. if (features[FEATURE_REFRACTION]) {
  1171. if (features[FEATURE_NORMAL_MAPPING]) {
  1172. code += " vec3 unpacked_normal = NORMAL_MAP;\n";
  1173. code += " unpacked_normal.xy = unpacked_normal.xy * 2.0 - 1.0;\n";
  1174. code += " unpacked_normal.z = sqrt(max(0.0, 1.0 - dot(unpacked_normal.xy, unpacked_normal.xy)));\n";
  1175. code += " vec3 ref_normal = normalize( mix(NORMAL,TANGENT * unpacked_normal.x + BINORMAL * unpacked_normal.y + NORMAL * unpacked_normal.z,NORMAL_MAP_DEPTH) );\n";
  1176. } else {
  1177. code += " vec3 ref_normal = NORMAL;\n";
  1178. }
  1179. if (flags[FLAG_UV1_USE_TRIPLANAR]) {
  1180. 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";
  1181. } else {
  1182. code += " vec2 ref_ofs = SCREEN_UV - ref_normal.xy * dot(texture(texture_refraction,base_uv),refraction_texture_channel) * refraction;\n";
  1183. }
  1184. code += " float ref_amount = 1.0 - albedo.a * albedo_tex.a;\n";
  1185. code += " EMISSION += textureLod(screen_texture,ref_ofs,ROUGHNESS * 8.0).rgb * ref_amount * EXPOSURE;\n";
  1186. code += " ALBEDO *= 1.0 - ref_amount;\n";
  1187. code += " ALPHA = 1.0;\n";
  1188. } else if (transparency != TRANSPARENCY_DISABLED || flags[FLAG_USE_SHADOW_TO_OPACITY] || (distance_fade == DISTANCE_FADE_PIXEL_ALPHA) || proximity_fade_enabled) {
  1189. code += " ALPHA *= albedo.a * albedo_tex.a;\n";
  1190. }
  1191. if (transparency == TRANSPARENCY_ALPHA_HASH) {
  1192. code += " ALPHA_HASH_SCALE = alpha_hash_scale;\n";
  1193. } else if (transparency == TRANSPARENCY_ALPHA_SCISSOR) {
  1194. code += " ALPHA_SCISSOR_THRESHOLD = alpha_scissor_threshold;\n";
  1195. }
  1196. if (alpha_antialiasing_mode != ALPHA_ANTIALIASING_OFF && (transparency == TRANSPARENCY_ALPHA_HASH || transparency == TRANSPARENCY_ALPHA_SCISSOR)) {
  1197. code += " ALPHA_ANTIALIASING_EDGE = alpha_antialiasing_edge;\n";
  1198. code += " ALPHA_TEXTURE_COORDINATE = UV * vec2(albedo_texture_size);\n";
  1199. }
  1200. if (proximity_fade_enabled) {
  1201. code += " float depth_tex = textureLod(depth_texture,SCREEN_UV,0.0).r;\n";
  1202. code += " vec4 world_pos = INV_PROJECTION_MATRIX * vec4(SCREEN_UV*2.0-1.0,depth_tex,1.0);\n";
  1203. code += " world_pos.xyz/=world_pos.w;\n";
  1204. code += " ALPHA*=clamp(1.0-smoothstep(world_pos.z+proximity_fade_distance,world_pos.z,VERTEX.z),0.0,1.0);\n";
  1205. }
  1206. if (distance_fade != DISTANCE_FADE_DISABLED) {
  1207. // Use the slightly more expensive circular fade (distance to the object) instead of linear
  1208. // (Z distance), so that the fade is always the same regardless of the camera angle.
  1209. if ((distance_fade == DISTANCE_FADE_OBJECT_DITHER || distance_fade == DISTANCE_FADE_PIXEL_DITHER)) {
  1210. if (!RenderingServer::get_singleton()->is_low_end()) {
  1211. code += " {\n";
  1212. if (distance_fade == DISTANCE_FADE_OBJECT_DITHER) {
  1213. code += " float fade_distance = length((VIEW_MATRIX * MODEL_MATRIX[3]));\n";
  1214. } else {
  1215. code += " float fade_distance = length(VERTEX);\n";
  1216. }
  1217. // Use interleaved gradient noise, which is fast but still looks good.
  1218. code += " const vec3 magic = vec3(0.06711056f, 0.00583715f, 52.9829189f);";
  1219. code += " float fade = clamp(smoothstep(distance_fade_min, distance_fade_max, fade_distance), 0.0, 1.0);\n";
  1220. // Use a hard cap to prevent a few stray pixels from remaining when past the fade-out distance.
  1221. code += " if (fade < 0.001 || fade < fract(magic.z * fract(dot(FRAGCOORD.xy, magic.xy)))) {\n";
  1222. code += " discard;\n";
  1223. code += " }\n";
  1224. code += " }\n\n";
  1225. }
  1226. } else {
  1227. code += " ALPHA *= clamp(smoothstep(distance_fade_min, distance_fade_max, length(VERTEX)), 0.0, 1.0);\n";
  1228. }
  1229. }
  1230. if (features[FEATURE_RIM]) {
  1231. if (flags[FLAG_UV1_USE_TRIPLANAR]) {
  1232. code += " vec2 rim_tex = triplanar_texture(texture_rim,uv1_power_normal,uv1_triplanar_pos).xy;\n";
  1233. } else {
  1234. code += " vec2 rim_tex = texture(texture_rim,base_uv).xy;\n";
  1235. }
  1236. code += " RIM = rim*rim_tex.x;";
  1237. code += " RIM_TINT = rim_tint*rim_tex.y;\n";
  1238. }
  1239. if (features[FEATURE_CLEARCOAT]) {
  1240. if (flags[FLAG_UV1_USE_TRIPLANAR]) {
  1241. code += " vec2 clearcoat_tex = triplanar_texture(texture_clearcoat,uv1_power_normal,uv1_triplanar_pos).xy;\n";
  1242. } else {
  1243. code += " vec2 clearcoat_tex = texture(texture_clearcoat,base_uv).xy;\n";
  1244. }
  1245. code += " CLEARCOAT = clearcoat*clearcoat_tex.x;";
  1246. code += " CLEARCOAT_ROUGHNESS = clearcoat_roughness*clearcoat_tex.y;\n";
  1247. }
  1248. if (features[FEATURE_ANISOTROPY]) {
  1249. if (flags[FLAG_UV1_USE_TRIPLANAR]) {
  1250. code += " vec3 anisotropy_tex = triplanar_texture(texture_flowmap,uv1_power_normal,uv1_triplanar_pos).rga;\n";
  1251. } else {
  1252. code += " vec3 anisotropy_tex = texture(texture_flowmap,base_uv).rga;\n";
  1253. }
  1254. code += " ANISOTROPY = anisotropy_ratio*anisotropy_tex.b;\n";
  1255. code += " ANISOTROPY_FLOW = anisotropy_tex.rg*2.0-1.0;\n";
  1256. }
  1257. if (features[FEATURE_AMBIENT_OCCLUSION]) {
  1258. if (!orm) {
  1259. if (flags[FLAG_AO_ON_UV2]) {
  1260. if (flags[FLAG_UV2_USE_TRIPLANAR]) {
  1261. code += " AO = dot(triplanar_texture(texture_ambient_occlusion,uv2_power_normal,uv2_triplanar_pos),ao_texture_channel);\n";
  1262. } else {
  1263. code += " AO = dot(texture(texture_ambient_occlusion,base_uv2),ao_texture_channel);\n";
  1264. }
  1265. } else {
  1266. if (flags[FLAG_UV1_USE_TRIPLANAR]) {
  1267. code += " AO = dot(triplanar_texture(texture_ambient_occlusion,uv1_power_normal,uv1_triplanar_pos),ao_texture_channel);\n";
  1268. } else {
  1269. code += " AO = dot(texture(texture_ambient_occlusion,base_uv),ao_texture_channel);\n";
  1270. }
  1271. }
  1272. } else {
  1273. code += " AO = orm_tex.r;\n";
  1274. }
  1275. code += " AO_LIGHT_AFFECT = ao_light_affect;\n";
  1276. }
  1277. if (features[FEATURE_SUBSURFACE_SCATTERING]) {
  1278. if (flags[FLAG_UV1_USE_TRIPLANAR]) {
  1279. code += " float sss_tex = triplanar_texture(texture_subsurface_scattering,uv1_power_normal,uv1_triplanar_pos).r;\n";
  1280. } else {
  1281. code += " float sss_tex = texture(texture_subsurface_scattering,base_uv).r;\n";
  1282. }
  1283. code += " SSS_STRENGTH=subsurface_scattering_strength*sss_tex;\n";
  1284. }
  1285. if (features[FEATURE_SUBSURFACE_TRANSMITTANCE]) {
  1286. if (flags[FLAG_UV1_USE_TRIPLANAR]) {
  1287. code += " vec4 trans_color_tex = triplanar_texture(texture_subsurface_transmittance,uv1_power_normal,uv1_triplanar_pos);\n";
  1288. } else {
  1289. code += " vec4 trans_color_tex = texture(texture_subsurface_transmittance,base_uv);\n";
  1290. }
  1291. code += " SSS_TRANSMITTANCE_COLOR=transmittance_color*trans_color_tex;\n";
  1292. code += " SSS_TRANSMITTANCE_DEPTH=transmittance_depth;\n";
  1293. code += " SSS_TRANSMITTANCE_BOOST=transmittance_boost;\n";
  1294. }
  1295. if (features[FEATURE_BACKLIGHT]) {
  1296. if (flags[FLAG_UV1_USE_TRIPLANAR]) {
  1297. code += " vec3 backlight_tex = triplanar_texture(texture_backlight,uv1_power_normal,uv1_triplanar_pos).rgb;\n";
  1298. } else {
  1299. code += " vec3 backlight_tex = texture(texture_backlight,base_uv).rgb;\n";
  1300. }
  1301. code += " BACKLIGHT = (backlight.rgb+backlight_tex);\n";
  1302. }
  1303. if (features[FEATURE_DETAIL]) {
  1304. bool triplanar = (flags[FLAG_UV1_USE_TRIPLANAR] && detail_uv == DETAIL_UV_1) || (flags[FLAG_UV2_USE_TRIPLANAR] && detail_uv == DETAIL_UV_2);
  1305. if (triplanar) {
  1306. String tp_uv = detail_uv == DETAIL_UV_1 ? "uv1" : "uv2";
  1307. code += " vec4 detail_tex = triplanar_texture(texture_detail_albedo," + tp_uv + "_power_normal," + tp_uv + "_triplanar_pos);\n";
  1308. code += " vec4 detail_norm_tex = triplanar_texture(texture_detail_normal," + tp_uv + "_power_normal," + tp_uv + "_triplanar_pos);\n";
  1309. } else {
  1310. String det_uv = detail_uv == DETAIL_UV_1 ? "base_uv" : "base_uv2";
  1311. code += " vec4 detail_tex = texture(texture_detail_albedo," + det_uv + ");\n";
  1312. code += " vec4 detail_norm_tex = texture(texture_detail_normal," + det_uv + ");\n";
  1313. }
  1314. if (flags[FLAG_UV1_USE_TRIPLANAR]) {
  1315. code += " vec4 detail_mask_tex = triplanar_texture(texture_detail_mask,uv1_power_normal,uv1_triplanar_pos);\n";
  1316. } else {
  1317. code += " vec4 detail_mask_tex = texture(texture_detail_mask,base_uv);\n";
  1318. }
  1319. switch (detail_blend_mode) {
  1320. case BLEND_MODE_MIX: {
  1321. code += " vec3 detail = mix(ALBEDO.rgb,detail_tex.rgb,detail_tex.a);\n";
  1322. } break;
  1323. case BLEND_MODE_ADD: {
  1324. code += " vec3 detail = mix(ALBEDO.rgb,ALBEDO.rgb+detail_tex.rgb,detail_tex.a);\n";
  1325. } break;
  1326. case BLEND_MODE_SUB: {
  1327. code += " vec3 detail = mix(ALBEDO.rgb,ALBEDO.rgb-detail_tex.rgb,detail_tex.a);\n";
  1328. } break;
  1329. case BLEND_MODE_MUL: {
  1330. code += " vec3 detail = mix(ALBEDO.rgb,ALBEDO.rgb*detail_tex.rgb,detail_tex.a);\n";
  1331. } break;
  1332. case BLEND_MODE_MAX:
  1333. break; // Internal value, skip.
  1334. }
  1335. code += " vec3 detail_norm = mix(NORMAL_MAP,detail_norm_tex.rgb,detail_tex.a);\n";
  1336. code += " NORMAL_MAP = mix(NORMAL_MAP,detail_norm,detail_mask_tex.r);\n";
  1337. code += " ALBEDO.rgb = mix(ALBEDO.rgb,detail,detail_mask_tex.r);\n";
  1338. }
  1339. code += "}\n";
  1340. ShaderData shader_data;
  1341. shader_data.shader = RS::get_singleton()->shader_create();
  1342. shader_data.users = 1;
  1343. RS::get_singleton()->shader_set_code(shader_data.shader, code);
  1344. shader_map[mk] = shader_data;
  1345. RS::get_singleton()->material_set_shader(_get_material(), shader_data.shader);
  1346. }
  1347. void BaseMaterial3D::flush_changes() {
  1348. MutexLock lock(material_mutex);
  1349. while (dirty_materials.first()) {
  1350. dirty_materials.first()->self()->_update_shader();
  1351. }
  1352. }
  1353. void BaseMaterial3D::_queue_shader_change() {
  1354. MutexLock lock(material_mutex);
  1355. if (_is_initialized() && !element.in_list()) {
  1356. dirty_materials.add(&element);
  1357. }
  1358. }
  1359. bool BaseMaterial3D::_is_shader_dirty() const {
  1360. MutexLock lock(material_mutex);
  1361. return element.in_list();
  1362. }
  1363. void BaseMaterial3D::set_albedo(const Color &p_albedo) {
  1364. albedo = p_albedo;
  1365. RS::get_singleton()->material_set_param(_get_material(), shader_names->albedo, p_albedo);
  1366. }
  1367. Color BaseMaterial3D::get_albedo() const {
  1368. return albedo;
  1369. }
  1370. void BaseMaterial3D::set_specular(float p_specular) {
  1371. specular = p_specular;
  1372. RS::get_singleton()->material_set_param(_get_material(), shader_names->specular, p_specular);
  1373. }
  1374. float BaseMaterial3D::get_specular() const {
  1375. return specular;
  1376. }
  1377. void BaseMaterial3D::set_roughness(float p_roughness) {
  1378. roughness = p_roughness;
  1379. RS::get_singleton()->material_set_param(_get_material(), shader_names->roughness, p_roughness);
  1380. }
  1381. float BaseMaterial3D::get_roughness() const {
  1382. return roughness;
  1383. }
  1384. void BaseMaterial3D::set_metallic(float p_metallic) {
  1385. metallic = p_metallic;
  1386. RS::get_singleton()->material_set_param(_get_material(), shader_names->metallic, p_metallic);
  1387. }
  1388. float BaseMaterial3D::get_metallic() const {
  1389. return metallic;
  1390. }
  1391. void BaseMaterial3D::set_emission(const Color &p_emission) {
  1392. emission = p_emission;
  1393. RS::get_singleton()->material_set_param(_get_material(), shader_names->emission, p_emission);
  1394. }
  1395. Color BaseMaterial3D::get_emission() const {
  1396. return emission;
  1397. }
  1398. void BaseMaterial3D::set_emission_energy_multiplier(float p_emission_energy_multiplier) {
  1399. emission_energy_multiplier = p_emission_energy_multiplier;
  1400. if (GLOBAL_GET("rendering/lights_and_shadows/use_physical_light_units")) {
  1401. RS::get_singleton()->material_set_param(_get_material(), shader_names->emission_energy, p_emission_energy_multiplier * emission_intensity);
  1402. } else {
  1403. RS::get_singleton()->material_set_param(_get_material(), shader_names->emission_energy, p_emission_energy_multiplier);
  1404. }
  1405. }
  1406. float BaseMaterial3D::get_emission_energy_multiplier() const {
  1407. return emission_energy_multiplier;
  1408. }
  1409. void BaseMaterial3D::set_emission_intensity(float p_emission_intensity) {
  1410. ERR_FAIL_COND_EDMSG(!GLOBAL_GET("rendering/lights_and_shadows/use_physical_light_units"), "Cannot set material emission intensity when Physical Light Units disabled.");
  1411. emission_intensity = p_emission_intensity;
  1412. RS::get_singleton()->material_set_param(_get_material(), shader_names->emission_energy, emission_energy_multiplier * emission_intensity);
  1413. }
  1414. float BaseMaterial3D::get_emission_intensity() const {
  1415. return emission_intensity;
  1416. }
  1417. void BaseMaterial3D::set_normal_scale(float p_normal_scale) {
  1418. normal_scale = p_normal_scale;
  1419. RS::get_singleton()->material_set_param(_get_material(), shader_names->normal_scale, p_normal_scale);
  1420. }
  1421. float BaseMaterial3D::get_normal_scale() const {
  1422. return normal_scale;
  1423. }
  1424. void BaseMaterial3D::set_rim(float p_rim) {
  1425. rim = p_rim;
  1426. RS::get_singleton()->material_set_param(_get_material(), shader_names->rim, p_rim);
  1427. }
  1428. float BaseMaterial3D::get_rim() const {
  1429. return rim;
  1430. }
  1431. void BaseMaterial3D::set_rim_tint(float p_rim_tint) {
  1432. rim_tint = p_rim_tint;
  1433. RS::get_singleton()->material_set_param(_get_material(), shader_names->rim_tint, p_rim_tint);
  1434. }
  1435. float BaseMaterial3D::get_rim_tint() const {
  1436. return rim_tint;
  1437. }
  1438. void BaseMaterial3D::set_ao_light_affect(float p_ao_light_affect) {
  1439. ao_light_affect = p_ao_light_affect;
  1440. RS::get_singleton()->material_set_param(_get_material(), shader_names->ao_light_affect, p_ao_light_affect);
  1441. }
  1442. float BaseMaterial3D::get_ao_light_affect() const {
  1443. return ao_light_affect;
  1444. }
  1445. void BaseMaterial3D::set_clearcoat(float p_clearcoat) {
  1446. clearcoat = p_clearcoat;
  1447. RS::get_singleton()->material_set_param(_get_material(), shader_names->clearcoat, p_clearcoat);
  1448. }
  1449. float BaseMaterial3D::get_clearcoat() const {
  1450. return clearcoat;
  1451. }
  1452. void BaseMaterial3D::set_clearcoat_roughness(float p_clearcoat_roughness) {
  1453. clearcoat_roughness = p_clearcoat_roughness;
  1454. RS::get_singleton()->material_set_param(_get_material(), shader_names->clearcoat_roughness, p_clearcoat_roughness);
  1455. }
  1456. float BaseMaterial3D::get_clearcoat_roughness() const {
  1457. return clearcoat_roughness;
  1458. }
  1459. void BaseMaterial3D::set_anisotropy(float p_anisotropy) {
  1460. anisotropy = p_anisotropy;
  1461. RS::get_singleton()->material_set_param(_get_material(), shader_names->anisotropy, p_anisotropy);
  1462. }
  1463. float BaseMaterial3D::get_anisotropy() const {
  1464. return anisotropy;
  1465. }
  1466. void BaseMaterial3D::set_heightmap_scale(float p_heightmap_scale) {
  1467. heightmap_scale = p_heightmap_scale;
  1468. RS::get_singleton()->material_set_param(_get_material(), shader_names->heightmap_scale, p_heightmap_scale);
  1469. }
  1470. float BaseMaterial3D::get_heightmap_scale() const {
  1471. return heightmap_scale;
  1472. }
  1473. void BaseMaterial3D::set_subsurface_scattering_strength(float p_subsurface_scattering_strength) {
  1474. subsurface_scattering_strength = p_subsurface_scattering_strength;
  1475. RS::get_singleton()->material_set_param(_get_material(), shader_names->subsurface_scattering_strength, subsurface_scattering_strength);
  1476. }
  1477. float BaseMaterial3D::get_subsurface_scattering_strength() const {
  1478. return subsurface_scattering_strength;
  1479. }
  1480. void BaseMaterial3D::set_transmittance_color(const Color &p_color) {
  1481. transmittance_color = p_color;
  1482. RS::get_singleton()->material_set_param(_get_material(), shader_names->transmittance_color, p_color);
  1483. }
  1484. Color BaseMaterial3D::get_transmittance_color() const {
  1485. return transmittance_color;
  1486. }
  1487. void BaseMaterial3D::set_transmittance_depth(float p_depth) {
  1488. transmittance_depth = p_depth;
  1489. RS::get_singleton()->material_set_param(_get_material(), shader_names->transmittance_depth, p_depth);
  1490. }
  1491. float BaseMaterial3D::get_transmittance_depth() const {
  1492. return transmittance_depth;
  1493. }
  1494. void BaseMaterial3D::set_transmittance_boost(float p_boost) {
  1495. transmittance_boost = p_boost;
  1496. RS::get_singleton()->material_set_param(_get_material(), shader_names->transmittance_boost, p_boost);
  1497. }
  1498. float BaseMaterial3D::get_transmittance_boost() const {
  1499. return transmittance_boost;
  1500. }
  1501. void BaseMaterial3D::set_backlight(const Color &p_backlight) {
  1502. backlight = p_backlight;
  1503. RS::get_singleton()->material_set_param(_get_material(), shader_names->backlight, backlight);
  1504. }
  1505. Color BaseMaterial3D::get_backlight() const {
  1506. return backlight;
  1507. }
  1508. void BaseMaterial3D::set_refraction(float p_refraction) {
  1509. refraction = p_refraction;
  1510. RS::get_singleton()->material_set_param(_get_material(), shader_names->refraction, refraction);
  1511. }
  1512. float BaseMaterial3D::get_refraction() const {
  1513. return refraction;
  1514. }
  1515. void BaseMaterial3D::set_detail_uv(DetailUV p_detail_uv) {
  1516. if (detail_uv == p_detail_uv) {
  1517. return;
  1518. }
  1519. detail_uv = p_detail_uv;
  1520. _queue_shader_change();
  1521. }
  1522. BaseMaterial3D::DetailUV BaseMaterial3D::get_detail_uv() const {
  1523. return detail_uv;
  1524. }
  1525. void BaseMaterial3D::set_blend_mode(BlendMode p_mode) {
  1526. if (blend_mode == p_mode) {
  1527. return;
  1528. }
  1529. blend_mode = p_mode;
  1530. _queue_shader_change();
  1531. }
  1532. BaseMaterial3D::BlendMode BaseMaterial3D::get_blend_mode() const {
  1533. return blend_mode;
  1534. }
  1535. void BaseMaterial3D::set_detail_blend_mode(BlendMode p_mode) {
  1536. detail_blend_mode = p_mode;
  1537. _queue_shader_change();
  1538. }
  1539. BaseMaterial3D::BlendMode BaseMaterial3D::get_detail_blend_mode() const {
  1540. return detail_blend_mode;
  1541. }
  1542. void BaseMaterial3D::set_transparency(Transparency p_transparency) {
  1543. if (transparency == p_transparency) {
  1544. return;
  1545. }
  1546. transparency = p_transparency;
  1547. _queue_shader_change();
  1548. notify_property_list_changed();
  1549. }
  1550. BaseMaterial3D::Transparency BaseMaterial3D::get_transparency() const {
  1551. return transparency;
  1552. }
  1553. void BaseMaterial3D::set_alpha_antialiasing(AlphaAntiAliasing p_alpha_aa) {
  1554. if (alpha_antialiasing_mode == p_alpha_aa) {
  1555. return;
  1556. }
  1557. alpha_antialiasing_mode = p_alpha_aa;
  1558. _queue_shader_change();
  1559. notify_property_list_changed();
  1560. }
  1561. BaseMaterial3D::AlphaAntiAliasing BaseMaterial3D::get_alpha_antialiasing() const {
  1562. return alpha_antialiasing_mode;
  1563. }
  1564. void BaseMaterial3D::set_shading_mode(ShadingMode p_shading_mode) {
  1565. if (shading_mode == p_shading_mode) {
  1566. return;
  1567. }
  1568. shading_mode = p_shading_mode;
  1569. _queue_shader_change();
  1570. notify_property_list_changed();
  1571. }
  1572. BaseMaterial3D::ShadingMode BaseMaterial3D::get_shading_mode() const {
  1573. return shading_mode;
  1574. }
  1575. void BaseMaterial3D::set_depth_draw_mode(DepthDrawMode p_mode) {
  1576. if (depth_draw_mode == p_mode) {
  1577. return;
  1578. }
  1579. depth_draw_mode = p_mode;
  1580. _queue_shader_change();
  1581. }
  1582. BaseMaterial3D::DepthDrawMode BaseMaterial3D::get_depth_draw_mode() const {
  1583. return depth_draw_mode;
  1584. }
  1585. void BaseMaterial3D::set_cull_mode(CullMode p_mode) {
  1586. if (cull_mode == p_mode) {
  1587. return;
  1588. }
  1589. cull_mode = p_mode;
  1590. _queue_shader_change();
  1591. }
  1592. BaseMaterial3D::CullMode BaseMaterial3D::get_cull_mode() const {
  1593. return cull_mode;
  1594. }
  1595. void BaseMaterial3D::set_diffuse_mode(DiffuseMode p_mode) {
  1596. if (diffuse_mode == p_mode) {
  1597. return;
  1598. }
  1599. diffuse_mode = p_mode;
  1600. _queue_shader_change();
  1601. }
  1602. BaseMaterial3D::DiffuseMode BaseMaterial3D::get_diffuse_mode() const {
  1603. return diffuse_mode;
  1604. }
  1605. void BaseMaterial3D::set_specular_mode(SpecularMode p_mode) {
  1606. if (specular_mode == p_mode) {
  1607. return;
  1608. }
  1609. specular_mode = p_mode;
  1610. _queue_shader_change();
  1611. }
  1612. BaseMaterial3D::SpecularMode BaseMaterial3D::get_specular_mode() const {
  1613. return specular_mode;
  1614. }
  1615. void BaseMaterial3D::set_flag(Flags p_flag, bool p_enabled) {
  1616. ERR_FAIL_INDEX(p_flag, FLAG_MAX);
  1617. if (flags[p_flag] == p_enabled) {
  1618. return;
  1619. }
  1620. flags[p_flag] = p_enabled;
  1621. if (
  1622. p_flag == FLAG_USE_SHADOW_TO_OPACITY ||
  1623. p_flag == FLAG_USE_TEXTURE_REPEAT ||
  1624. p_flag == FLAG_SUBSURFACE_MODE_SKIN ||
  1625. p_flag == FLAG_USE_POINT_SIZE ||
  1626. p_flag == FLAG_UV1_USE_TRIPLANAR ||
  1627. p_flag == FLAG_UV2_USE_TRIPLANAR) {
  1628. notify_property_list_changed();
  1629. }
  1630. if (p_flag == FLAG_PARTICLE_TRAILS_MODE) {
  1631. update_configuration_warning();
  1632. }
  1633. _queue_shader_change();
  1634. }
  1635. bool BaseMaterial3D::get_flag(Flags p_flag) const {
  1636. ERR_FAIL_INDEX_V(p_flag, FLAG_MAX, false);
  1637. return flags[p_flag];
  1638. }
  1639. void BaseMaterial3D::set_feature(Feature p_feature, bool p_enabled) {
  1640. ERR_FAIL_INDEX(p_feature, FEATURE_MAX);
  1641. if (features[p_feature] == p_enabled) {
  1642. return;
  1643. }
  1644. features[p_feature] = p_enabled;
  1645. notify_property_list_changed();
  1646. _queue_shader_change();
  1647. }
  1648. bool BaseMaterial3D::get_feature(Feature p_feature) const {
  1649. ERR_FAIL_INDEX_V(p_feature, FEATURE_MAX, false);
  1650. return features[p_feature];
  1651. }
  1652. void BaseMaterial3D::set_texture(TextureParam p_param, const Ref<Texture2D> &p_texture) {
  1653. ERR_FAIL_INDEX(p_param, TEXTURE_MAX);
  1654. textures[p_param] = p_texture;
  1655. Variant rid = p_texture.is_valid() ? Variant(p_texture->get_rid()) : Variant();
  1656. RS::get_singleton()->material_set_param(_get_material(), shader_names->texture_names[p_param], rid);
  1657. if (p_texture.is_valid() && p_param == TEXTURE_ALBEDO) {
  1658. RS::get_singleton()->material_set_param(_get_material(), shader_names->albedo_texture_size,
  1659. Vector2i(p_texture->get_width(), p_texture->get_height()));
  1660. }
  1661. notify_property_list_changed();
  1662. _queue_shader_change();
  1663. }
  1664. Ref<Texture2D> BaseMaterial3D::get_texture(TextureParam p_param) const {
  1665. ERR_FAIL_INDEX_V(p_param, TEXTURE_MAX, Ref<Texture2D>());
  1666. return textures[p_param];
  1667. }
  1668. Ref<Texture2D> BaseMaterial3D::get_texture_by_name(StringName p_name) const {
  1669. for (int i = 0; i < (int)BaseMaterial3D::TEXTURE_MAX; i++) {
  1670. TextureParam param = TextureParam(i);
  1671. if (p_name == shader_names->texture_names[param]) {
  1672. return textures[param];
  1673. }
  1674. }
  1675. return Ref<Texture2D>();
  1676. }
  1677. void BaseMaterial3D::set_texture_filter(TextureFilter p_filter) {
  1678. texture_filter = p_filter;
  1679. _queue_shader_change();
  1680. }
  1681. BaseMaterial3D::TextureFilter BaseMaterial3D::get_texture_filter() const {
  1682. return texture_filter;
  1683. }
  1684. void BaseMaterial3D::_validate_feature(const String &text, Feature feature, PropertyInfo &property) const {
  1685. if (property.name.begins_with(text) && property.name != text + "_enabled" && !features[feature]) {
  1686. property.usage = PROPERTY_USAGE_NO_EDITOR;
  1687. }
  1688. }
  1689. void BaseMaterial3D::_validate_property(PropertyInfo &p_property) const {
  1690. _validate_feature("normal", FEATURE_NORMAL_MAPPING, p_property);
  1691. _validate_feature("emission", FEATURE_EMISSION, p_property);
  1692. _validate_feature("rim", FEATURE_RIM, p_property);
  1693. _validate_feature("clearcoat", FEATURE_CLEARCOAT, p_property);
  1694. _validate_feature("anisotropy", FEATURE_ANISOTROPY, p_property);
  1695. _validate_feature("ao", FEATURE_AMBIENT_OCCLUSION, p_property);
  1696. _validate_feature("heightmap", FEATURE_HEIGHT_MAPPING, p_property);
  1697. _validate_feature("subsurf_scatter", FEATURE_SUBSURFACE_SCATTERING, p_property);
  1698. _validate_feature("backlight", FEATURE_BACKLIGHT, p_property);
  1699. _validate_feature("refraction", FEATURE_REFRACTION, p_property);
  1700. _validate_feature("detail", FEATURE_DETAIL, p_property);
  1701. if (p_property.name == "emission_intensity" && !GLOBAL_GET("rendering/lights_and_shadows/use_physical_light_units")) {
  1702. p_property.usage = PROPERTY_USAGE_NONE;
  1703. }
  1704. if (p_property.name.begins_with("particles_anim_") && billboard_mode != BILLBOARD_PARTICLES) {
  1705. p_property.usage = PROPERTY_USAGE_NONE;
  1706. }
  1707. if (p_property.name == "billboard_keep_scale" && billboard_mode == BILLBOARD_DISABLED) {
  1708. p_property.usage = PROPERTY_USAGE_NO_EDITOR;
  1709. }
  1710. if (p_property.name == "grow_amount" && !grow_enabled) {
  1711. p_property.usage = PROPERTY_USAGE_NO_EDITOR;
  1712. }
  1713. if (p_property.name == "point_size" && !flags[FLAG_USE_POINT_SIZE]) {
  1714. p_property.usage = PROPERTY_USAGE_NO_EDITOR;
  1715. }
  1716. if (p_property.name == "proximity_fade_distance" && !proximity_fade_enabled) {
  1717. p_property.usage = PROPERTY_USAGE_NO_EDITOR;
  1718. }
  1719. if (p_property.name == "msdf_pixel_range" && !flags[FLAG_ALBEDO_TEXTURE_MSDF]) {
  1720. p_property.usage = PROPERTY_USAGE_NO_EDITOR;
  1721. }
  1722. if (p_property.name == "msdf_outline_size" && !flags[FLAG_ALBEDO_TEXTURE_MSDF]) {
  1723. p_property.usage = PROPERTY_USAGE_NO_EDITOR;
  1724. }
  1725. if ((p_property.name == "distance_fade_max_distance" || p_property.name == "distance_fade_min_distance") && distance_fade == DISTANCE_FADE_DISABLED) {
  1726. p_property.usage = PROPERTY_USAGE_NO_EDITOR;
  1727. }
  1728. if ((p_property.name == "uv1_triplanar_sharpness" || p_property.name == "uv1_world_triplanar") && !flags[FLAG_UV1_USE_TRIPLANAR]) {
  1729. p_property.usage = PROPERTY_USAGE_NO_EDITOR;
  1730. }
  1731. if ((p_property.name == "uv2_triplanar_sharpness" || p_property.name == "uv2_world_triplanar") && !flags[FLAG_UV2_USE_TRIPLANAR]) {
  1732. p_property.usage = PROPERTY_USAGE_NO_EDITOR;
  1733. }
  1734. // you can only enable anti-aliasing (in materials) on alpha scissor and alpha hash
  1735. const bool can_select_aa = (transparency == TRANSPARENCY_ALPHA_SCISSOR || transparency == TRANSPARENCY_ALPHA_HASH);
  1736. // alpha anti aliasiasing is only enabled when you can select aa
  1737. const bool alpha_aa_enabled = (alpha_antialiasing_mode != ALPHA_ANTIALIASING_OFF) && can_select_aa;
  1738. // alpha scissor slider isn't needed when alpha antialiasing is enabled
  1739. if (p_property.name == "alpha_scissor_threshold" && transparency != TRANSPARENCY_ALPHA_SCISSOR) {
  1740. p_property.usage = PROPERTY_USAGE_NONE;
  1741. }
  1742. // alpha hash scale slider is only needed if transparency is alpha hash
  1743. if (p_property.name == "alpha_hash_scale" && transparency != TRANSPARENCY_ALPHA_HASH) {
  1744. p_property.usage = PROPERTY_USAGE_NONE;
  1745. }
  1746. if (p_property.name == "alpha_antialiasing_mode" && !can_select_aa) {
  1747. p_property.usage = PROPERTY_USAGE_NONE;
  1748. }
  1749. // we can't choose an antialiasing mode if alpha isn't possible
  1750. if (p_property.name == "alpha_antialiasing_edge" && !alpha_aa_enabled) {
  1751. p_property.usage = PROPERTY_USAGE_NONE;
  1752. }
  1753. if (p_property.name == "blend_mode" && alpha_aa_enabled) {
  1754. p_property.usage = PROPERTY_USAGE_NONE;
  1755. }
  1756. if ((p_property.name == "heightmap_min_layers" || p_property.name == "heightmap_max_layers") && !deep_parallax) {
  1757. p_property.usage = PROPERTY_USAGE_NONE;
  1758. }
  1759. if (flags[FLAG_SUBSURFACE_MODE_SKIN] && (p_property.name == "subsurf_scatter_transmittance_color" || p_property.name == "subsurf_scatter_transmittance_texture")) {
  1760. p_property.usage = PROPERTY_USAGE_NONE;
  1761. }
  1762. if (orm) {
  1763. if (p_property.name == "shading_mode") {
  1764. // Vertex not supported in ORM mode, since no individual roughness.
  1765. p_property.hint_string = "Unshaded,Per-Pixel";
  1766. }
  1767. if (p_property.name.begins_with("roughness") || p_property.name.begins_with("metallic") || p_property.name.begins_with("ao_texture")) {
  1768. p_property.usage = PROPERTY_USAGE_NONE;
  1769. }
  1770. } else {
  1771. if (p_property.name == "orm_texture") {
  1772. p_property.usage = PROPERTY_USAGE_NONE;
  1773. }
  1774. }
  1775. if (shading_mode != SHADING_MODE_PER_PIXEL) {
  1776. if (shading_mode != SHADING_MODE_PER_VERTEX) {
  1777. //these may still work per vertex
  1778. if (p_property.name.begins_with("ao")) {
  1779. p_property.usage = PROPERTY_USAGE_NONE;
  1780. }
  1781. if (p_property.name.begins_with("emission")) {
  1782. p_property.usage = PROPERTY_USAGE_NONE;
  1783. }
  1784. if (p_property.name.begins_with("metallic")) {
  1785. p_property.usage = PROPERTY_USAGE_NONE;
  1786. }
  1787. if (p_property.name.begins_with("rim")) {
  1788. p_property.usage = PROPERTY_USAGE_NONE;
  1789. }
  1790. if (p_property.name.begins_with("roughness")) {
  1791. p_property.usage = PROPERTY_USAGE_NONE;
  1792. }
  1793. if (p_property.name.begins_with("subsurf_scatter")) {
  1794. p_property.usage = PROPERTY_USAGE_NONE;
  1795. }
  1796. }
  1797. //these definitely only need per pixel
  1798. if (p_property.name.begins_with("anisotropy")) {
  1799. p_property.usage = PROPERTY_USAGE_NONE;
  1800. }
  1801. if (p_property.name.begins_with("clearcoat")) {
  1802. p_property.usage = PROPERTY_USAGE_NONE;
  1803. }
  1804. if (p_property.name.begins_with("normal")) {
  1805. p_property.usage = PROPERTY_USAGE_NONE;
  1806. }
  1807. if (p_property.name.begins_with("backlight")) {
  1808. p_property.usage = PROPERTY_USAGE_NONE;
  1809. }
  1810. if (p_property.name.begins_with("transmittance")) {
  1811. p_property.usage = PROPERTY_USAGE_NONE;
  1812. }
  1813. }
  1814. }
  1815. void BaseMaterial3D::set_point_size(float p_point_size) {
  1816. point_size = p_point_size;
  1817. RS::get_singleton()->material_set_param(_get_material(), shader_names->point_size, p_point_size);
  1818. }
  1819. float BaseMaterial3D::get_point_size() const {
  1820. return point_size;
  1821. }
  1822. void BaseMaterial3D::set_uv1_scale(const Vector3 &p_scale) {
  1823. uv1_scale = p_scale;
  1824. RS::get_singleton()->material_set_param(_get_material(), shader_names->uv1_scale, p_scale);
  1825. }
  1826. Vector3 BaseMaterial3D::get_uv1_scale() const {
  1827. return uv1_scale;
  1828. }
  1829. void BaseMaterial3D::set_uv1_offset(const Vector3 &p_offset) {
  1830. uv1_offset = p_offset;
  1831. RS::get_singleton()->material_set_param(_get_material(), shader_names->uv1_offset, p_offset);
  1832. }
  1833. Vector3 BaseMaterial3D::get_uv1_offset() const {
  1834. return uv1_offset;
  1835. }
  1836. void BaseMaterial3D::set_uv1_triplanar_blend_sharpness(float p_sharpness) {
  1837. // Negative values or values higher than 150 can result in NaNs, leading to broken rendering.
  1838. uv1_triplanar_sharpness = CLAMP(p_sharpness, 0.0, 150.0);
  1839. RS::get_singleton()->material_set_param(_get_material(), shader_names->uv1_blend_sharpness, uv1_triplanar_sharpness);
  1840. }
  1841. float BaseMaterial3D::get_uv1_triplanar_blend_sharpness() const {
  1842. return uv1_triplanar_sharpness;
  1843. }
  1844. void BaseMaterial3D::set_uv2_scale(const Vector3 &p_scale) {
  1845. uv2_scale = p_scale;
  1846. RS::get_singleton()->material_set_param(_get_material(), shader_names->uv2_scale, p_scale);
  1847. }
  1848. Vector3 BaseMaterial3D::get_uv2_scale() const {
  1849. return uv2_scale;
  1850. }
  1851. void BaseMaterial3D::set_uv2_offset(const Vector3 &p_offset) {
  1852. uv2_offset = p_offset;
  1853. RS::get_singleton()->material_set_param(_get_material(), shader_names->uv2_offset, p_offset);
  1854. }
  1855. Vector3 BaseMaterial3D::get_uv2_offset() const {
  1856. return uv2_offset;
  1857. }
  1858. void BaseMaterial3D::set_uv2_triplanar_blend_sharpness(float p_sharpness) {
  1859. // Negative values or values higher than 150 can result in NaNs, leading to broken rendering.
  1860. uv2_triplanar_sharpness = CLAMP(p_sharpness, 0.0, 150.0);
  1861. RS::get_singleton()->material_set_param(_get_material(), shader_names->uv2_blend_sharpness, uv2_triplanar_sharpness);
  1862. }
  1863. float BaseMaterial3D::get_uv2_triplanar_blend_sharpness() const {
  1864. return uv2_triplanar_sharpness;
  1865. }
  1866. void BaseMaterial3D::set_billboard_mode(BillboardMode p_mode) {
  1867. billboard_mode = p_mode;
  1868. _queue_shader_change();
  1869. notify_property_list_changed();
  1870. }
  1871. BaseMaterial3D::BillboardMode BaseMaterial3D::get_billboard_mode() const {
  1872. return billboard_mode;
  1873. }
  1874. void BaseMaterial3D::set_particles_anim_h_frames(int p_frames) {
  1875. particles_anim_h_frames = p_frames;
  1876. RS::get_singleton()->material_set_param(_get_material(), shader_names->particles_anim_h_frames, p_frames);
  1877. }
  1878. int BaseMaterial3D::get_particles_anim_h_frames() const {
  1879. return particles_anim_h_frames;
  1880. }
  1881. void BaseMaterial3D::set_particles_anim_v_frames(int p_frames) {
  1882. particles_anim_v_frames = p_frames;
  1883. RS::get_singleton()->material_set_param(_get_material(), shader_names->particles_anim_v_frames, p_frames);
  1884. }
  1885. int BaseMaterial3D::get_particles_anim_v_frames() const {
  1886. return particles_anim_v_frames;
  1887. }
  1888. void BaseMaterial3D::set_particles_anim_loop(bool p_loop) {
  1889. particles_anim_loop = p_loop;
  1890. RS::get_singleton()->material_set_param(_get_material(), shader_names->particles_anim_loop, particles_anim_loop);
  1891. }
  1892. bool BaseMaterial3D::get_particles_anim_loop() const {
  1893. return particles_anim_loop;
  1894. }
  1895. void BaseMaterial3D::set_heightmap_deep_parallax(bool p_enable) {
  1896. deep_parallax = p_enable;
  1897. _queue_shader_change();
  1898. notify_property_list_changed();
  1899. }
  1900. bool BaseMaterial3D::is_heightmap_deep_parallax_enabled() const {
  1901. return deep_parallax;
  1902. }
  1903. void BaseMaterial3D::set_heightmap_deep_parallax_min_layers(int p_layer) {
  1904. deep_parallax_min_layers = p_layer;
  1905. RS::get_singleton()->material_set_param(_get_material(), shader_names->heightmap_min_layers, p_layer);
  1906. }
  1907. int BaseMaterial3D::get_heightmap_deep_parallax_min_layers() const {
  1908. return deep_parallax_min_layers;
  1909. }
  1910. void BaseMaterial3D::set_heightmap_deep_parallax_max_layers(int p_layer) {
  1911. deep_parallax_max_layers = p_layer;
  1912. RS::get_singleton()->material_set_param(_get_material(), shader_names->heightmap_max_layers, p_layer);
  1913. }
  1914. int BaseMaterial3D::get_heightmap_deep_parallax_max_layers() const {
  1915. return deep_parallax_max_layers;
  1916. }
  1917. void BaseMaterial3D::set_heightmap_deep_parallax_flip_tangent(bool p_flip) {
  1918. heightmap_parallax_flip_tangent = p_flip;
  1919. RS::get_singleton()->material_set_param(_get_material(), shader_names->heightmap_flip, Vector2(heightmap_parallax_flip_tangent ? -1 : 1, heightmap_parallax_flip_binormal ? -1 : 1));
  1920. }
  1921. bool BaseMaterial3D::get_heightmap_deep_parallax_flip_tangent() const {
  1922. return heightmap_parallax_flip_tangent;
  1923. }
  1924. void BaseMaterial3D::set_heightmap_deep_parallax_flip_binormal(bool p_flip) {
  1925. heightmap_parallax_flip_binormal = p_flip;
  1926. RS::get_singleton()->material_set_param(_get_material(), shader_names->heightmap_flip, Vector2(heightmap_parallax_flip_tangent ? -1 : 1, heightmap_parallax_flip_binormal ? -1 : 1));
  1927. }
  1928. bool BaseMaterial3D::get_heightmap_deep_parallax_flip_binormal() const {
  1929. return heightmap_parallax_flip_binormal;
  1930. }
  1931. void BaseMaterial3D::set_grow_enabled(bool p_enable) {
  1932. grow_enabled = p_enable;
  1933. _queue_shader_change();
  1934. notify_property_list_changed();
  1935. }
  1936. bool BaseMaterial3D::is_grow_enabled() const {
  1937. return grow_enabled;
  1938. }
  1939. void BaseMaterial3D::set_alpha_scissor_threshold(float p_threshold) {
  1940. alpha_scissor_threshold = p_threshold;
  1941. RS::get_singleton()->material_set_param(_get_material(), shader_names->alpha_scissor_threshold, p_threshold);
  1942. }
  1943. float BaseMaterial3D::get_alpha_scissor_threshold() const {
  1944. return alpha_scissor_threshold;
  1945. }
  1946. void BaseMaterial3D::set_alpha_hash_scale(float p_scale) {
  1947. alpha_hash_scale = p_scale;
  1948. RS::get_singleton()->material_set_param(_get_material(), shader_names->alpha_hash_scale, p_scale);
  1949. }
  1950. float BaseMaterial3D::get_alpha_hash_scale() const {
  1951. return alpha_hash_scale;
  1952. }
  1953. void BaseMaterial3D::set_alpha_antialiasing_edge(float p_edge) {
  1954. alpha_antialiasing_edge = p_edge;
  1955. RS::get_singleton()->material_set_param(_get_material(), shader_names->alpha_antialiasing_edge, p_edge);
  1956. }
  1957. float BaseMaterial3D::get_alpha_antialiasing_edge() const {
  1958. return alpha_antialiasing_edge;
  1959. }
  1960. void BaseMaterial3D::set_grow(float p_grow) {
  1961. grow = p_grow;
  1962. RS::get_singleton()->material_set_param(_get_material(), shader_names->grow, p_grow);
  1963. }
  1964. float BaseMaterial3D::get_grow() const {
  1965. return grow;
  1966. }
  1967. static Plane _get_texture_mask(BaseMaterial3D::TextureChannel p_channel) {
  1968. static const Plane masks[5] = {
  1969. Plane(1, 0, 0, 0),
  1970. Plane(0, 1, 0, 0),
  1971. Plane(0, 0, 1, 0),
  1972. Plane(0, 0, 0, 1),
  1973. Plane(0.3333333, 0.3333333, 0.3333333, 0),
  1974. };
  1975. return masks[p_channel];
  1976. }
  1977. void BaseMaterial3D::set_metallic_texture_channel(TextureChannel p_channel) {
  1978. ERR_FAIL_INDEX(p_channel, 5);
  1979. metallic_texture_channel = p_channel;
  1980. RS::get_singleton()->material_set_param(_get_material(), shader_names->metallic_texture_channel, _get_texture_mask(p_channel));
  1981. }
  1982. BaseMaterial3D::TextureChannel BaseMaterial3D::get_metallic_texture_channel() const {
  1983. return metallic_texture_channel;
  1984. }
  1985. void BaseMaterial3D::set_roughness_texture_channel(TextureChannel p_channel) {
  1986. ERR_FAIL_INDEX(p_channel, 5);
  1987. roughness_texture_channel = p_channel;
  1988. _queue_shader_change();
  1989. }
  1990. BaseMaterial3D::TextureChannel BaseMaterial3D::get_roughness_texture_channel() const {
  1991. return roughness_texture_channel;
  1992. }
  1993. void BaseMaterial3D::set_ao_texture_channel(TextureChannel p_channel) {
  1994. ERR_FAIL_INDEX(p_channel, 5);
  1995. ao_texture_channel = p_channel;
  1996. RS::get_singleton()->material_set_param(_get_material(), shader_names->ao_texture_channel, _get_texture_mask(p_channel));
  1997. }
  1998. BaseMaterial3D::TextureChannel BaseMaterial3D::get_ao_texture_channel() const {
  1999. return ao_texture_channel;
  2000. }
  2001. void BaseMaterial3D::set_refraction_texture_channel(TextureChannel p_channel) {
  2002. ERR_FAIL_INDEX(p_channel, 5);
  2003. refraction_texture_channel = p_channel;
  2004. RS::get_singleton()->material_set_param(_get_material(), shader_names->refraction_texture_channel, _get_texture_mask(p_channel));
  2005. }
  2006. BaseMaterial3D::TextureChannel BaseMaterial3D::get_refraction_texture_channel() const {
  2007. return refraction_texture_channel;
  2008. }
  2009. 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) {
  2010. uint64_t key = 0;
  2011. key |= ((int8_t)p_shaded & 0x01) << 0;
  2012. key |= ((int8_t)p_transparency & 0x07) << 1; // Bits 1-3.
  2013. key |= ((int8_t)p_double_sided & 0x01) << 4;
  2014. key |= ((int8_t)p_billboard & 0x01) << 5;
  2015. key |= ((int8_t)p_billboard_y & 0x01) << 6;
  2016. key |= ((int8_t)p_msdf & 0x01) << 7;
  2017. key |= ((int8_t)p_no_depth & 0x01) << 8;
  2018. key |= ((int8_t)p_fixed_size & 0x01) << 9;
  2019. key |= ((int8_t)p_filter & 0x07) << 10; // Bits 10-12.
  2020. key |= ((int8_t)p_alpha_antialiasing_mode & 0x07) << 13; // Bits 13-15.
  2021. if (materials_for_2d.has(key)) {
  2022. if (r_shader_rid) {
  2023. *r_shader_rid = materials_for_2d[key]->get_shader_rid();
  2024. }
  2025. return materials_for_2d[key];
  2026. }
  2027. Ref<StandardMaterial3D> material;
  2028. material.instantiate();
  2029. material->set_shading_mode(p_shaded ? SHADING_MODE_PER_PIXEL : SHADING_MODE_UNSHADED);
  2030. material->set_transparency(p_transparency);
  2031. material->set_cull_mode(p_double_sided ? CULL_DISABLED : CULL_BACK);
  2032. material->set_flag(FLAG_SRGB_VERTEX_COLOR, true);
  2033. material->set_flag(FLAG_ALBEDO_FROM_VERTEX_COLOR, true);
  2034. material->set_flag(FLAG_ALBEDO_TEXTURE_MSDF, p_msdf);
  2035. material->set_flag(FLAG_DISABLE_DEPTH_TEST, p_no_depth);
  2036. material->set_flag(FLAG_FIXED_SIZE, p_fixed_size);
  2037. material->set_alpha_antialiasing(p_alpha_antialiasing_mode);
  2038. material->set_texture_filter(p_filter);
  2039. if (p_billboard || p_billboard_y) {
  2040. material->set_flag(FLAG_BILLBOARD_KEEP_SCALE, true);
  2041. material->set_billboard_mode(p_billboard_y ? BILLBOARD_FIXED_Y : BILLBOARD_ENABLED);
  2042. }
  2043. materials_for_2d[key] = material;
  2044. if (r_shader_rid) {
  2045. *r_shader_rid = materials_for_2d[key]->get_shader_rid();
  2046. }
  2047. return materials_for_2d[key];
  2048. }
  2049. void BaseMaterial3D::set_on_top_of_alpha() {
  2050. set_transparency(TRANSPARENCY_DISABLED);
  2051. set_render_priority(RENDER_PRIORITY_MAX);
  2052. set_flag(FLAG_DISABLE_DEPTH_TEST, true);
  2053. }
  2054. void BaseMaterial3D::set_proximity_fade_enabled(bool p_enable) {
  2055. proximity_fade_enabled = p_enable;
  2056. _queue_shader_change();
  2057. notify_property_list_changed();
  2058. }
  2059. bool BaseMaterial3D::is_proximity_fade_enabled() const {
  2060. return proximity_fade_enabled;
  2061. }
  2062. void BaseMaterial3D::set_proximity_fade_distance(float p_distance) {
  2063. proximity_fade_distance = p_distance;
  2064. RS::get_singleton()->material_set_param(_get_material(), shader_names->proximity_fade_distance, p_distance);
  2065. }
  2066. float BaseMaterial3D::get_proximity_fade_distance() const {
  2067. return proximity_fade_distance;
  2068. }
  2069. void BaseMaterial3D::set_msdf_pixel_range(float p_range) {
  2070. msdf_pixel_range = p_range;
  2071. RS::get_singleton()->material_set_param(_get_material(), shader_names->msdf_pixel_range, p_range);
  2072. }
  2073. float BaseMaterial3D::get_msdf_pixel_range() const {
  2074. return msdf_pixel_range;
  2075. }
  2076. void BaseMaterial3D::set_msdf_outline_size(float p_size) {
  2077. msdf_outline_size = p_size;
  2078. RS::get_singleton()->material_set_param(_get_material(), shader_names->msdf_outline_size, p_size);
  2079. }
  2080. float BaseMaterial3D::get_msdf_outline_size() const {
  2081. return msdf_outline_size;
  2082. }
  2083. void BaseMaterial3D::set_distance_fade(DistanceFadeMode p_mode) {
  2084. distance_fade = p_mode;
  2085. _queue_shader_change();
  2086. notify_property_list_changed();
  2087. }
  2088. BaseMaterial3D::DistanceFadeMode BaseMaterial3D::get_distance_fade() const {
  2089. return distance_fade;
  2090. }
  2091. void BaseMaterial3D::set_distance_fade_max_distance(float p_distance) {
  2092. distance_fade_max_distance = p_distance;
  2093. RS::get_singleton()->material_set_param(_get_material(), shader_names->distance_fade_max, distance_fade_max_distance);
  2094. }
  2095. float BaseMaterial3D::get_distance_fade_max_distance() const {
  2096. return distance_fade_max_distance;
  2097. }
  2098. void BaseMaterial3D::set_distance_fade_min_distance(float p_distance) {
  2099. distance_fade_min_distance = p_distance;
  2100. RS::get_singleton()->material_set_param(_get_material(), shader_names->distance_fade_min, distance_fade_min_distance);
  2101. }
  2102. float BaseMaterial3D::get_distance_fade_min_distance() const {
  2103. return distance_fade_min_distance;
  2104. }
  2105. void BaseMaterial3D::set_emission_operator(EmissionOperator p_op) {
  2106. if (emission_op == p_op) {
  2107. return;
  2108. }
  2109. emission_op = p_op;
  2110. _queue_shader_change();
  2111. }
  2112. BaseMaterial3D::EmissionOperator BaseMaterial3D::get_emission_operator() const {
  2113. return emission_op;
  2114. }
  2115. RID BaseMaterial3D::get_shader_rid() const {
  2116. MutexLock lock(material_mutex);
  2117. if (element.in_list()) { // _is_shader_dirty() would create anoder mutex lock
  2118. ((BaseMaterial3D *)this)->_update_shader();
  2119. }
  2120. ERR_FAIL_COND_V(!shader_map.has(current_key), RID());
  2121. return shader_map[current_key].shader;
  2122. }
  2123. Shader::Mode BaseMaterial3D::get_shader_mode() const {
  2124. return Shader::MODE_SPATIAL;
  2125. }
  2126. void BaseMaterial3D::_bind_methods() {
  2127. static_assert(sizeof(MaterialKey) == 16, "MaterialKey should be 16 bytes");
  2128. ClassDB::bind_method(D_METHOD("set_albedo", "albedo"), &BaseMaterial3D::set_albedo);
  2129. ClassDB::bind_method(D_METHOD("get_albedo"), &BaseMaterial3D::get_albedo);
  2130. ClassDB::bind_method(D_METHOD("set_transparency", "transparency"), &BaseMaterial3D::set_transparency);
  2131. ClassDB::bind_method(D_METHOD("get_transparency"), &BaseMaterial3D::get_transparency);
  2132. ClassDB::bind_method(D_METHOD("set_alpha_antialiasing", "alpha_aa"), &BaseMaterial3D::set_alpha_antialiasing);
  2133. ClassDB::bind_method(D_METHOD("get_alpha_antialiasing"), &BaseMaterial3D::get_alpha_antialiasing);
  2134. ClassDB::bind_method(D_METHOD("set_alpha_antialiasing_edge", "edge"), &BaseMaterial3D::set_alpha_antialiasing_edge);
  2135. ClassDB::bind_method(D_METHOD("get_alpha_antialiasing_edge"), &BaseMaterial3D::get_alpha_antialiasing_edge);
  2136. ClassDB::bind_method(D_METHOD("set_shading_mode", "shading_mode"), &BaseMaterial3D::set_shading_mode);
  2137. ClassDB::bind_method(D_METHOD("get_shading_mode"), &BaseMaterial3D::get_shading_mode);
  2138. ClassDB::bind_method(D_METHOD("set_specular", "specular"), &BaseMaterial3D::set_specular);
  2139. ClassDB::bind_method(D_METHOD("get_specular"), &BaseMaterial3D::get_specular);
  2140. ClassDB::bind_method(D_METHOD("set_metallic", "metallic"), &BaseMaterial3D::set_metallic);
  2141. ClassDB::bind_method(D_METHOD("get_metallic"), &BaseMaterial3D::get_metallic);
  2142. ClassDB::bind_method(D_METHOD("set_roughness", "roughness"), &BaseMaterial3D::set_roughness);
  2143. ClassDB::bind_method(D_METHOD("get_roughness"), &BaseMaterial3D::get_roughness);
  2144. ClassDB::bind_method(D_METHOD("set_emission", "emission"), &BaseMaterial3D::set_emission);
  2145. ClassDB::bind_method(D_METHOD("get_emission"), &BaseMaterial3D::get_emission);
  2146. ClassDB::bind_method(D_METHOD("set_emission_energy_multiplier", "emission_energy_multiplier"), &BaseMaterial3D::set_emission_energy_multiplier);
  2147. ClassDB::bind_method(D_METHOD("get_emission_energy_multiplier"), &BaseMaterial3D::get_emission_energy_multiplier);
  2148. ClassDB::bind_method(D_METHOD("set_emission_intensity", "emission_energy_multiplier"), &BaseMaterial3D::set_emission_intensity);
  2149. ClassDB::bind_method(D_METHOD("get_emission_intensity"), &BaseMaterial3D::get_emission_intensity);
  2150. ClassDB::bind_method(D_METHOD("set_normal_scale", "normal_scale"), &BaseMaterial3D::set_normal_scale);
  2151. ClassDB::bind_method(D_METHOD("get_normal_scale"), &BaseMaterial3D::get_normal_scale);
  2152. ClassDB::bind_method(D_METHOD("set_rim", "rim"), &BaseMaterial3D::set_rim);
  2153. ClassDB::bind_method(D_METHOD("get_rim"), &BaseMaterial3D::get_rim);
  2154. ClassDB::bind_method(D_METHOD("set_rim_tint", "rim_tint"), &BaseMaterial3D::set_rim_tint);
  2155. ClassDB::bind_method(D_METHOD("get_rim_tint"), &BaseMaterial3D::get_rim_tint);
  2156. ClassDB::bind_method(D_METHOD("set_clearcoat", "clearcoat"), &BaseMaterial3D::set_clearcoat);
  2157. ClassDB::bind_method(D_METHOD("get_clearcoat"), &BaseMaterial3D::get_clearcoat);
  2158. ClassDB::bind_method(D_METHOD("set_clearcoat_roughness", "clearcoat_roughness"), &BaseMaterial3D::set_clearcoat_roughness);
  2159. ClassDB::bind_method(D_METHOD("get_clearcoat_roughness"), &BaseMaterial3D::get_clearcoat_roughness);
  2160. ClassDB::bind_method(D_METHOD("set_anisotropy", "anisotropy"), &BaseMaterial3D::set_anisotropy);
  2161. ClassDB::bind_method(D_METHOD("get_anisotropy"), &BaseMaterial3D::get_anisotropy);
  2162. ClassDB::bind_method(D_METHOD("set_heightmap_scale", "heightmap_scale"), &BaseMaterial3D::set_heightmap_scale);
  2163. ClassDB::bind_method(D_METHOD("get_heightmap_scale"), &BaseMaterial3D::get_heightmap_scale);
  2164. ClassDB::bind_method(D_METHOD("set_subsurface_scattering_strength", "strength"), &BaseMaterial3D::set_subsurface_scattering_strength);
  2165. ClassDB::bind_method(D_METHOD("get_subsurface_scattering_strength"), &BaseMaterial3D::get_subsurface_scattering_strength);
  2166. ClassDB::bind_method(D_METHOD("set_transmittance_color", "color"), &BaseMaterial3D::set_transmittance_color);
  2167. ClassDB::bind_method(D_METHOD("get_transmittance_color"), &BaseMaterial3D::get_transmittance_color);
  2168. ClassDB::bind_method(D_METHOD("set_transmittance_depth", "depth"), &BaseMaterial3D::set_transmittance_depth);
  2169. ClassDB::bind_method(D_METHOD("get_transmittance_depth"), &BaseMaterial3D::get_transmittance_depth);
  2170. ClassDB::bind_method(D_METHOD("set_transmittance_boost", "boost"), &BaseMaterial3D::set_transmittance_boost);
  2171. ClassDB::bind_method(D_METHOD("get_transmittance_boost"), &BaseMaterial3D::get_transmittance_boost);
  2172. ClassDB::bind_method(D_METHOD("set_backlight", "backlight"), &BaseMaterial3D::set_backlight);
  2173. ClassDB::bind_method(D_METHOD("get_backlight"), &BaseMaterial3D::get_backlight);
  2174. ClassDB::bind_method(D_METHOD("set_refraction", "refraction"), &BaseMaterial3D::set_refraction);
  2175. ClassDB::bind_method(D_METHOD("get_refraction"), &BaseMaterial3D::get_refraction);
  2176. ClassDB::bind_method(D_METHOD("set_point_size", "point_size"), &BaseMaterial3D::set_point_size);
  2177. ClassDB::bind_method(D_METHOD("get_point_size"), &BaseMaterial3D::get_point_size);
  2178. ClassDB::bind_method(D_METHOD("set_detail_uv", "detail_uv"), &BaseMaterial3D::set_detail_uv);
  2179. ClassDB::bind_method(D_METHOD("get_detail_uv"), &BaseMaterial3D::get_detail_uv);
  2180. ClassDB::bind_method(D_METHOD("set_blend_mode", "blend_mode"), &BaseMaterial3D::set_blend_mode);
  2181. ClassDB::bind_method(D_METHOD("get_blend_mode"), &BaseMaterial3D::get_blend_mode);
  2182. ClassDB::bind_method(D_METHOD("set_depth_draw_mode", "depth_draw_mode"), &BaseMaterial3D::set_depth_draw_mode);
  2183. ClassDB::bind_method(D_METHOD("get_depth_draw_mode"), &BaseMaterial3D::get_depth_draw_mode);
  2184. ClassDB::bind_method(D_METHOD("set_cull_mode", "cull_mode"), &BaseMaterial3D::set_cull_mode);
  2185. ClassDB::bind_method(D_METHOD("get_cull_mode"), &BaseMaterial3D::get_cull_mode);
  2186. ClassDB::bind_method(D_METHOD("set_diffuse_mode", "diffuse_mode"), &BaseMaterial3D::set_diffuse_mode);
  2187. ClassDB::bind_method(D_METHOD("get_diffuse_mode"), &BaseMaterial3D::get_diffuse_mode);
  2188. ClassDB::bind_method(D_METHOD("set_specular_mode", "specular_mode"), &BaseMaterial3D::set_specular_mode);
  2189. ClassDB::bind_method(D_METHOD("get_specular_mode"), &BaseMaterial3D::get_specular_mode);
  2190. ClassDB::bind_method(D_METHOD("set_flag", "flag", "enable"), &BaseMaterial3D::set_flag);
  2191. ClassDB::bind_method(D_METHOD("get_flag", "flag"), &BaseMaterial3D::get_flag);
  2192. ClassDB::bind_method(D_METHOD("set_texture_filter", "mode"), &BaseMaterial3D::set_texture_filter);
  2193. ClassDB::bind_method(D_METHOD("get_texture_filter"), &BaseMaterial3D::get_texture_filter);
  2194. ClassDB::bind_method(D_METHOD("set_feature", "feature", "enable"), &BaseMaterial3D::set_feature);
  2195. ClassDB::bind_method(D_METHOD("get_feature", "feature"), &BaseMaterial3D::get_feature);
  2196. ClassDB::bind_method(D_METHOD("set_texture", "param", "texture"), &BaseMaterial3D::set_texture);
  2197. ClassDB::bind_method(D_METHOD("get_texture", "param"), &BaseMaterial3D::get_texture);
  2198. ClassDB::bind_method(D_METHOD("set_detail_blend_mode", "detail_blend_mode"), &BaseMaterial3D::set_detail_blend_mode);
  2199. ClassDB::bind_method(D_METHOD("get_detail_blend_mode"), &BaseMaterial3D::get_detail_blend_mode);
  2200. ClassDB::bind_method(D_METHOD("set_uv1_scale", "scale"), &BaseMaterial3D::set_uv1_scale);
  2201. ClassDB::bind_method(D_METHOD("get_uv1_scale"), &BaseMaterial3D::get_uv1_scale);
  2202. ClassDB::bind_method(D_METHOD("set_uv1_offset", "offset"), &BaseMaterial3D::set_uv1_offset);
  2203. ClassDB::bind_method(D_METHOD("get_uv1_offset"), &BaseMaterial3D::get_uv1_offset);
  2204. ClassDB::bind_method(D_METHOD("set_uv1_triplanar_blend_sharpness", "sharpness"), &BaseMaterial3D::set_uv1_triplanar_blend_sharpness);
  2205. ClassDB::bind_method(D_METHOD("get_uv1_triplanar_blend_sharpness"), &BaseMaterial3D::get_uv1_triplanar_blend_sharpness);
  2206. ClassDB::bind_method(D_METHOD("set_uv2_scale", "scale"), &BaseMaterial3D::set_uv2_scale);
  2207. ClassDB::bind_method(D_METHOD("get_uv2_scale"), &BaseMaterial3D::get_uv2_scale);
  2208. ClassDB::bind_method(D_METHOD("set_uv2_offset", "offset"), &BaseMaterial3D::set_uv2_offset);
  2209. ClassDB::bind_method(D_METHOD("get_uv2_offset"), &BaseMaterial3D::get_uv2_offset);
  2210. ClassDB::bind_method(D_METHOD("set_uv2_triplanar_blend_sharpness", "sharpness"), &BaseMaterial3D::set_uv2_triplanar_blend_sharpness);
  2211. ClassDB::bind_method(D_METHOD("get_uv2_triplanar_blend_sharpness"), &BaseMaterial3D::get_uv2_triplanar_blend_sharpness);
  2212. ClassDB::bind_method(D_METHOD("set_billboard_mode", "mode"), &BaseMaterial3D::set_billboard_mode);
  2213. ClassDB::bind_method(D_METHOD("get_billboard_mode"), &BaseMaterial3D::get_billboard_mode);
  2214. ClassDB::bind_method(D_METHOD("set_particles_anim_h_frames", "frames"), &BaseMaterial3D::set_particles_anim_h_frames);
  2215. ClassDB::bind_method(D_METHOD("get_particles_anim_h_frames"), &BaseMaterial3D::get_particles_anim_h_frames);
  2216. ClassDB::bind_method(D_METHOD("set_particles_anim_v_frames", "frames"), &BaseMaterial3D::set_particles_anim_v_frames);
  2217. ClassDB::bind_method(D_METHOD("get_particles_anim_v_frames"), &BaseMaterial3D::get_particles_anim_v_frames);
  2218. ClassDB::bind_method(D_METHOD("set_particles_anim_loop", "loop"), &BaseMaterial3D::set_particles_anim_loop);
  2219. ClassDB::bind_method(D_METHOD("get_particles_anim_loop"), &BaseMaterial3D::get_particles_anim_loop);
  2220. ClassDB::bind_method(D_METHOD("set_heightmap_deep_parallax", "enable"), &BaseMaterial3D::set_heightmap_deep_parallax);
  2221. ClassDB::bind_method(D_METHOD("is_heightmap_deep_parallax_enabled"), &BaseMaterial3D::is_heightmap_deep_parallax_enabled);
  2222. ClassDB::bind_method(D_METHOD("set_heightmap_deep_parallax_min_layers", "layer"), &BaseMaterial3D::set_heightmap_deep_parallax_min_layers);
  2223. ClassDB::bind_method(D_METHOD("get_heightmap_deep_parallax_min_layers"), &BaseMaterial3D::get_heightmap_deep_parallax_min_layers);
  2224. ClassDB::bind_method(D_METHOD("set_heightmap_deep_parallax_max_layers", "layer"), &BaseMaterial3D::set_heightmap_deep_parallax_max_layers);
  2225. ClassDB::bind_method(D_METHOD("get_heightmap_deep_parallax_max_layers"), &BaseMaterial3D::get_heightmap_deep_parallax_max_layers);
  2226. ClassDB::bind_method(D_METHOD("set_heightmap_deep_parallax_flip_tangent", "flip"), &BaseMaterial3D::set_heightmap_deep_parallax_flip_tangent);
  2227. ClassDB::bind_method(D_METHOD("get_heightmap_deep_parallax_flip_tangent"), &BaseMaterial3D::get_heightmap_deep_parallax_flip_tangent);
  2228. ClassDB::bind_method(D_METHOD("set_heightmap_deep_parallax_flip_binormal", "flip"), &BaseMaterial3D::set_heightmap_deep_parallax_flip_binormal);
  2229. ClassDB::bind_method(D_METHOD("get_heightmap_deep_parallax_flip_binormal"), &BaseMaterial3D::get_heightmap_deep_parallax_flip_binormal);
  2230. ClassDB::bind_method(D_METHOD("set_grow", "amount"), &BaseMaterial3D::set_grow);
  2231. ClassDB::bind_method(D_METHOD("get_grow"), &BaseMaterial3D::get_grow);
  2232. ClassDB::bind_method(D_METHOD("set_emission_operator", "operator"), &BaseMaterial3D::set_emission_operator);
  2233. ClassDB::bind_method(D_METHOD("get_emission_operator"), &BaseMaterial3D::get_emission_operator);
  2234. ClassDB::bind_method(D_METHOD("set_ao_light_affect", "amount"), &BaseMaterial3D::set_ao_light_affect);
  2235. ClassDB::bind_method(D_METHOD("get_ao_light_affect"), &BaseMaterial3D::get_ao_light_affect);
  2236. ClassDB::bind_method(D_METHOD("set_alpha_scissor_threshold", "threshold"), &BaseMaterial3D::set_alpha_scissor_threshold);
  2237. ClassDB::bind_method(D_METHOD("get_alpha_scissor_threshold"), &BaseMaterial3D::get_alpha_scissor_threshold);
  2238. ClassDB::bind_method(D_METHOD("set_alpha_hash_scale", "threshold"), &BaseMaterial3D::set_alpha_hash_scale);
  2239. ClassDB::bind_method(D_METHOD("get_alpha_hash_scale"), &BaseMaterial3D::get_alpha_hash_scale);
  2240. ClassDB::bind_method(D_METHOD("set_grow_enabled", "enable"), &BaseMaterial3D::set_grow_enabled);
  2241. ClassDB::bind_method(D_METHOD("is_grow_enabled"), &BaseMaterial3D::is_grow_enabled);
  2242. ClassDB::bind_method(D_METHOD("set_metallic_texture_channel", "channel"), &BaseMaterial3D::set_metallic_texture_channel);
  2243. ClassDB::bind_method(D_METHOD("get_metallic_texture_channel"), &BaseMaterial3D::get_metallic_texture_channel);
  2244. ClassDB::bind_method(D_METHOD("set_roughness_texture_channel", "channel"), &BaseMaterial3D::set_roughness_texture_channel);
  2245. ClassDB::bind_method(D_METHOD("get_roughness_texture_channel"), &BaseMaterial3D::get_roughness_texture_channel);
  2246. ClassDB::bind_method(D_METHOD("set_ao_texture_channel", "channel"), &BaseMaterial3D::set_ao_texture_channel);
  2247. ClassDB::bind_method(D_METHOD("get_ao_texture_channel"), &BaseMaterial3D::get_ao_texture_channel);
  2248. ClassDB::bind_method(D_METHOD("set_refraction_texture_channel", "channel"), &BaseMaterial3D::set_refraction_texture_channel);
  2249. ClassDB::bind_method(D_METHOD("get_refraction_texture_channel"), &BaseMaterial3D::get_refraction_texture_channel);
  2250. ClassDB::bind_method(D_METHOD("set_proximity_fade_enabled", "enabled"), &BaseMaterial3D::set_proximity_fade_enabled);
  2251. ClassDB::bind_method(D_METHOD("is_proximity_fade_enabled"), &BaseMaterial3D::is_proximity_fade_enabled);
  2252. ClassDB::bind_method(D_METHOD("set_proximity_fade_distance", "distance"), &BaseMaterial3D::set_proximity_fade_distance);
  2253. ClassDB::bind_method(D_METHOD("get_proximity_fade_distance"), &BaseMaterial3D::get_proximity_fade_distance);
  2254. ClassDB::bind_method(D_METHOD("set_msdf_pixel_range", "range"), &BaseMaterial3D::set_msdf_pixel_range);
  2255. ClassDB::bind_method(D_METHOD("get_msdf_pixel_range"), &BaseMaterial3D::get_msdf_pixel_range);
  2256. ClassDB::bind_method(D_METHOD("set_msdf_outline_size", "size"), &BaseMaterial3D::set_msdf_outline_size);
  2257. ClassDB::bind_method(D_METHOD("get_msdf_outline_size"), &BaseMaterial3D::get_msdf_outline_size);
  2258. ClassDB::bind_method(D_METHOD("set_distance_fade", "mode"), &BaseMaterial3D::set_distance_fade);
  2259. ClassDB::bind_method(D_METHOD("get_distance_fade"), &BaseMaterial3D::get_distance_fade);
  2260. ClassDB::bind_method(D_METHOD("set_distance_fade_max_distance", "distance"), &BaseMaterial3D::set_distance_fade_max_distance);
  2261. ClassDB::bind_method(D_METHOD("get_distance_fade_max_distance"), &BaseMaterial3D::get_distance_fade_max_distance);
  2262. ClassDB::bind_method(D_METHOD("set_distance_fade_min_distance", "distance"), &BaseMaterial3D::set_distance_fade_min_distance);
  2263. ClassDB::bind_method(D_METHOD("get_distance_fade_min_distance"), &BaseMaterial3D::get_distance_fade_min_distance);
  2264. ADD_GROUP("Transparency", "");
  2265. ADD_PROPERTY(PropertyInfo(Variant::INT, "transparency", PROPERTY_HINT_ENUM, "Disabled,Alpha,Alpha Scissor,Alpha Hash,Depth Pre-Pass"), "set_transparency", "get_transparency");
  2266. ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "alpha_scissor_threshold", PROPERTY_HINT_RANGE, "0,1,0.001"), "set_alpha_scissor_threshold", "get_alpha_scissor_threshold");
  2267. ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "alpha_hash_scale", PROPERTY_HINT_RANGE, "0,2,0.01"), "set_alpha_hash_scale", "get_alpha_hash_scale");
  2268. ADD_PROPERTY(PropertyInfo(Variant::INT, "alpha_antialiasing_mode", PROPERTY_HINT_ENUM, "Disabled,Alpha Edge Blend,Alpha Edge Clip"), "set_alpha_antialiasing", "get_alpha_antialiasing");
  2269. ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "alpha_antialiasing_edge", PROPERTY_HINT_RANGE, "0,1,0.01"), "set_alpha_antialiasing_edge", "get_alpha_antialiasing_edge");
  2270. ADD_PROPERTY(PropertyInfo(Variant::INT, "blend_mode", PROPERTY_HINT_ENUM, "Mix,Add,Subtract,Multiply"), "set_blend_mode", "get_blend_mode");
  2271. ADD_PROPERTY(PropertyInfo(Variant::INT, "cull_mode", PROPERTY_HINT_ENUM, "Back,Front,Disabled"), "set_cull_mode", "get_cull_mode");
  2272. ADD_PROPERTY(PropertyInfo(Variant::INT, "depth_draw_mode", PROPERTY_HINT_ENUM, "Opaque Only,Always,Never"), "set_depth_draw_mode", "get_depth_draw_mode");
  2273. ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "no_depth_test"), "set_flag", "get_flag", FLAG_DISABLE_DEPTH_TEST);
  2274. ADD_GROUP("Shading", "");
  2275. ADD_PROPERTY(PropertyInfo(Variant::INT, "shading_mode", PROPERTY_HINT_ENUM, "Unshaded,Per-Pixel,Per-Vertex"), "set_shading_mode", "get_shading_mode");
  2276. ADD_PROPERTY(PropertyInfo(Variant::INT, "diffuse_mode", PROPERTY_HINT_ENUM, "Burley,Lambert,Lambert Wrap,Toon"), "set_diffuse_mode", "get_diffuse_mode");
  2277. ADD_PROPERTY(PropertyInfo(Variant::INT, "specular_mode", PROPERTY_HINT_ENUM, "SchlickGGX,Toon,Disabled"), "set_specular_mode", "get_specular_mode");
  2278. ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "disable_ambient_light"), "set_flag", "get_flag", FLAG_DISABLE_AMBIENT_LIGHT);
  2279. ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "disable_fog"), "set_flag", "get_flag", FLAG_DISABLE_FOG);
  2280. ADD_GROUP("Vertex Color", "vertex_color");
  2281. ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "vertex_color_use_as_albedo"), "set_flag", "get_flag", FLAG_ALBEDO_FROM_VERTEX_COLOR);
  2282. ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "vertex_color_is_srgb"), "set_flag", "get_flag", FLAG_SRGB_VERTEX_COLOR);
  2283. ADD_GROUP("Albedo", "albedo_");
  2284. ADD_PROPERTY(PropertyInfo(Variant::COLOR, "albedo_color"), "set_albedo", "get_albedo");
  2285. ADD_PROPERTYI(PropertyInfo(Variant::OBJECT, "albedo_texture", PROPERTY_HINT_RESOURCE_TYPE, "Texture2D"), "set_texture", "get_texture", TEXTURE_ALBEDO);
  2286. ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "albedo_texture_force_srgb"), "set_flag", "get_flag", FLAG_ALBEDO_TEXTURE_FORCE_SRGB);
  2287. ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "albedo_texture_msdf"), "set_flag", "get_flag", FLAG_ALBEDO_TEXTURE_MSDF);
  2288. ADD_GROUP("ORM", "orm_");
  2289. ADD_PROPERTYI(PropertyInfo(Variant::OBJECT, "orm_texture", PROPERTY_HINT_RESOURCE_TYPE, "Texture2D"), "set_texture", "get_texture", TEXTURE_ORM);
  2290. ADD_GROUP("Metallic", "metallic_");
  2291. ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "metallic", PROPERTY_HINT_RANGE, "0,1,0.01"), "set_metallic", "get_metallic");
  2292. ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "metallic_specular", PROPERTY_HINT_RANGE, "0,1,0.01"), "set_specular", "get_specular");
  2293. ADD_PROPERTYI(PropertyInfo(Variant::OBJECT, "metallic_texture", PROPERTY_HINT_RESOURCE_TYPE, "Texture2D"), "set_texture", "get_texture", TEXTURE_METALLIC);
  2294. ADD_PROPERTY(PropertyInfo(Variant::INT, "metallic_texture_channel", PROPERTY_HINT_ENUM, "Red,Green,Blue,Alpha,Gray"), "set_metallic_texture_channel", "get_metallic_texture_channel");
  2295. ADD_GROUP("Roughness", "roughness_");
  2296. ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "roughness", PROPERTY_HINT_RANGE, "0,1,0.01"), "set_roughness", "get_roughness");
  2297. ADD_PROPERTYI(PropertyInfo(Variant::OBJECT, "roughness_texture", PROPERTY_HINT_RESOURCE_TYPE, "Texture2D"), "set_texture", "get_texture", TEXTURE_ROUGHNESS);
  2298. ADD_PROPERTY(PropertyInfo(Variant::INT, "roughness_texture_channel", PROPERTY_HINT_ENUM, "Red,Green,Blue,Alpha,Gray"), "set_roughness_texture_channel", "get_roughness_texture_channel");
  2299. ADD_GROUP("Emission", "emission_");
  2300. ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "emission_enabled"), "set_feature", "get_feature", FEATURE_EMISSION);
  2301. ADD_PROPERTY(PropertyInfo(Variant::COLOR, "emission", PROPERTY_HINT_COLOR_NO_ALPHA), "set_emission", "get_emission");
  2302. 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");
  2303. 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");
  2304. ADD_PROPERTY(PropertyInfo(Variant::INT, "emission_operator", PROPERTY_HINT_ENUM, "Add,Multiply"), "set_emission_operator", "get_emission_operator");
  2305. ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "emission_on_uv2"), "set_flag", "get_flag", FLAG_EMISSION_ON_UV2);
  2306. ADD_PROPERTYI(PropertyInfo(Variant::OBJECT, "emission_texture", PROPERTY_HINT_RESOURCE_TYPE, "Texture2D"), "set_texture", "get_texture", TEXTURE_EMISSION);
  2307. ADD_GROUP("Normal Map", "normal_");
  2308. ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "normal_enabled"), "set_feature", "get_feature", FEATURE_NORMAL_MAPPING);
  2309. ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "normal_scale", PROPERTY_HINT_RANGE, "-16,16,0.01"), "set_normal_scale", "get_normal_scale");
  2310. ADD_PROPERTYI(PropertyInfo(Variant::OBJECT, "normal_texture", PROPERTY_HINT_RESOURCE_TYPE, "Texture2D"), "set_texture", "get_texture", TEXTURE_NORMAL);
  2311. ADD_GROUP("Rim", "rim_");
  2312. ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "rim_enabled"), "set_feature", "get_feature", FEATURE_RIM);
  2313. ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "rim", PROPERTY_HINT_RANGE, "0,1,0.01"), "set_rim", "get_rim");
  2314. ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "rim_tint", PROPERTY_HINT_RANGE, "0,1,0.01"), "set_rim_tint", "get_rim_tint");
  2315. ADD_PROPERTYI(PropertyInfo(Variant::OBJECT, "rim_texture", PROPERTY_HINT_RESOURCE_TYPE, "Texture2D"), "set_texture", "get_texture", TEXTURE_RIM);
  2316. ADD_GROUP("Clearcoat", "clearcoat_");
  2317. ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "clearcoat_enabled"), "set_feature", "get_feature", FEATURE_CLEARCOAT);
  2318. ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "clearcoat", PROPERTY_HINT_RANGE, "0,1,0.01"), "set_clearcoat", "get_clearcoat");
  2319. ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "clearcoat_roughness", PROPERTY_HINT_RANGE, "0,1,0.01"), "set_clearcoat_roughness", "get_clearcoat_roughness");
  2320. ADD_PROPERTYI(PropertyInfo(Variant::OBJECT, "clearcoat_texture", PROPERTY_HINT_RESOURCE_TYPE, "Texture2D"), "set_texture", "get_texture", TEXTURE_CLEARCOAT);
  2321. ADD_GROUP("Anisotropy", "anisotropy_");
  2322. ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "anisotropy_enabled"), "set_feature", "get_feature", FEATURE_ANISOTROPY);
  2323. ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "anisotropy", PROPERTY_HINT_RANGE, "-1,1,0.01"), "set_anisotropy", "get_anisotropy");
  2324. ADD_PROPERTYI(PropertyInfo(Variant::OBJECT, "anisotropy_flowmap", PROPERTY_HINT_RESOURCE_TYPE, "Texture2D"), "set_texture", "get_texture", TEXTURE_FLOWMAP);
  2325. ADD_GROUP("Ambient Occlusion", "ao_");
  2326. ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "ao_enabled"), "set_feature", "get_feature", FEATURE_AMBIENT_OCCLUSION);
  2327. ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "ao_light_affect", PROPERTY_HINT_RANGE, "0,1,0.01"), "set_ao_light_affect", "get_ao_light_affect");
  2328. ADD_PROPERTYI(PropertyInfo(Variant::OBJECT, "ao_texture", PROPERTY_HINT_RESOURCE_TYPE, "Texture2D"), "set_texture", "get_texture", TEXTURE_AMBIENT_OCCLUSION);
  2329. ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "ao_on_uv2"), "set_flag", "get_flag", FLAG_AO_ON_UV2);
  2330. ADD_PROPERTY(PropertyInfo(Variant::INT, "ao_texture_channel", PROPERTY_HINT_ENUM, "Red,Green,Blue,Alpha,Gray"), "set_ao_texture_channel", "get_ao_texture_channel");
  2331. ADD_GROUP("Height", "heightmap_");
  2332. ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "heightmap_enabled"), "set_feature", "get_feature", FEATURE_HEIGHT_MAPPING);
  2333. ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "heightmap_scale", PROPERTY_HINT_RANGE, "-16,16,0.001"), "set_heightmap_scale", "get_heightmap_scale");
  2334. ADD_PROPERTY(PropertyInfo(Variant::BOOL, "heightmap_deep_parallax"), "set_heightmap_deep_parallax", "is_heightmap_deep_parallax_enabled");
  2335. 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");
  2336. 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");
  2337. ADD_PROPERTY(PropertyInfo(Variant::BOOL, "heightmap_flip_tangent"), "set_heightmap_deep_parallax_flip_tangent", "get_heightmap_deep_parallax_flip_tangent");
  2338. ADD_PROPERTY(PropertyInfo(Variant::BOOL, "heightmap_flip_binormal"), "set_heightmap_deep_parallax_flip_binormal", "get_heightmap_deep_parallax_flip_binormal");
  2339. ADD_PROPERTYI(PropertyInfo(Variant::OBJECT, "heightmap_texture", PROPERTY_HINT_RESOURCE_TYPE, "Texture2D"), "set_texture", "get_texture", TEXTURE_HEIGHTMAP);
  2340. ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "heightmap_flip_texture"), "set_flag", "get_flag", FLAG_INVERT_HEIGHTMAP);
  2341. ADD_GROUP("Subsurface Scattering", "subsurf_scatter_");
  2342. ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "subsurf_scatter_enabled"), "set_feature", "get_feature", FEATURE_SUBSURFACE_SCATTERING);
  2343. ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "subsurf_scatter_strength", PROPERTY_HINT_RANGE, "0,1,0.01"), "set_subsurface_scattering_strength", "get_subsurface_scattering_strength");
  2344. ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "subsurf_scatter_skin_mode"), "set_flag", "get_flag", FLAG_SUBSURFACE_MODE_SKIN);
  2345. ADD_PROPERTYI(PropertyInfo(Variant::OBJECT, "subsurf_scatter_texture", PROPERTY_HINT_RESOURCE_TYPE, "Texture2D"), "set_texture", "get_texture", TEXTURE_SUBSURFACE_SCATTERING);
  2346. ADD_SUBGROUP("Transmittance", "subsurf_scatter_transmittance_");
  2347. ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "subsurf_scatter_transmittance_enabled"), "set_feature", "get_feature", FEATURE_SUBSURFACE_TRANSMITTANCE);
  2348. ADD_PROPERTY(PropertyInfo(Variant::COLOR, "subsurf_scatter_transmittance_color"), "set_transmittance_color", "get_transmittance_color");
  2349. ADD_PROPERTYI(PropertyInfo(Variant::OBJECT, "subsurf_scatter_transmittance_texture", PROPERTY_HINT_RESOURCE_TYPE, "Texture2D"), "set_texture", "get_texture", TEXTURE_SUBSURFACE_TRANSMITTANCE);
  2350. 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");
  2351. ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "subsurf_scatter_transmittance_boost", PROPERTY_HINT_RANGE, "0.00,1.0,0.01"), "set_transmittance_boost", "get_transmittance_boost");
  2352. ADD_GROUP("Back Lighting", "backlight_");
  2353. ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "backlight_enabled"), "set_feature", "get_feature", FEATURE_BACKLIGHT);
  2354. ADD_PROPERTY(PropertyInfo(Variant::COLOR, "backlight", PROPERTY_HINT_COLOR_NO_ALPHA), "set_backlight", "get_backlight");
  2355. ADD_PROPERTYI(PropertyInfo(Variant::OBJECT, "backlight_texture", PROPERTY_HINT_RESOURCE_TYPE, "Texture2D"), "set_texture", "get_texture", TEXTURE_BACKLIGHT);
  2356. ADD_GROUP("Refraction", "refraction_");
  2357. ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "refraction_enabled"), "set_feature", "get_feature", FEATURE_REFRACTION);
  2358. ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "refraction_scale", PROPERTY_HINT_RANGE, "-1,1,0.01"), "set_refraction", "get_refraction");
  2359. ADD_PROPERTYI(PropertyInfo(Variant::OBJECT, "refraction_texture", PROPERTY_HINT_RESOURCE_TYPE, "Texture2D"), "set_texture", "get_texture", TEXTURE_REFRACTION);
  2360. ADD_PROPERTY(PropertyInfo(Variant::INT, "refraction_texture_channel", PROPERTY_HINT_ENUM, "Red,Green,Blue,Alpha,Gray"), "set_refraction_texture_channel", "get_refraction_texture_channel");
  2361. ADD_GROUP("Detail", "detail_");
  2362. ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "detail_enabled"), "set_feature", "get_feature", FEATURE_DETAIL);
  2363. ADD_PROPERTYI(PropertyInfo(Variant::OBJECT, "detail_mask", PROPERTY_HINT_RESOURCE_TYPE, "Texture2D"), "set_texture", "get_texture", TEXTURE_DETAIL_MASK);
  2364. ADD_PROPERTY(PropertyInfo(Variant::INT, "detail_blend_mode", PROPERTY_HINT_ENUM, "Mix,Add,Subtract,Multiply"), "set_detail_blend_mode", "get_detail_blend_mode");
  2365. ADD_PROPERTY(PropertyInfo(Variant::INT, "detail_uv_layer", PROPERTY_HINT_ENUM, "UV1,UV2"), "set_detail_uv", "get_detail_uv");
  2366. ADD_PROPERTYI(PropertyInfo(Variant::OBJECT, "detail_albedo", PROPERTY_HINT_RESOURCE_TYPE, "Texture2D"), "set_texture", "get_texture", TEXTURE_DETAIL_ALBEDO);
  2367. ADD_PROPERTYI(PropertyInfo(Variant::OBJECT, "detail_normal", PROPERTY_HINT_RESOURCE_TYPE, "Texture2D"), "set_texture", "get_texture", TEXTURE_DETAIL_NORMAL);
  2368. ADD_GROUP("UV1", "uv1_");
  2369. ADD_PROPERTY(PropertyInfo(Variant::VECTOR3, "uv1_scale", PROPERTY_HINT_LINK), "set_uv1_scale", "get_uv1_scale");
  2370. ADD_PROPERTY(PropertyInfo(Variant::VECTOR3, "uv1_offset"), "set_uv1_offset", "get_uv1_offset");
  2371. ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "uv1_triplanar"), "set_flag", "get_flag", FLAG_UV1_USE_TRIPLANAR);
  2372. ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "uv1_triplanar_sharpness", PROPERTY_HINT_EXP_EASING), "set_uv1_triplanar_blend_sharpness", "get_uv1_triplanar_blend_sharpness");
  2373. ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "uv1_world_triplanar"), "set_flag", "get_flag", FLAG_UV1_USE_WORLD_TRIPLANAR);
  2374. ADD_GROUP("UV2", "uv2_");
  2375. ADD_PROPERTY(PropertyInfo(Variant::VECTOR3, "uv2_scale", PROPERTY_HINT_LINK), "set_uv2_scale", "get_uv2_scale");
  2376. ADD_PROPERTY(PropertyInfo(Variant::VECTOR3, "uv2_offset"), "set_uv2_offset", "get_uv2_offset");
  2377. ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "uv2_triplanar"), "set_flag", "get_flag", FLAG_UV2_USE_TRIPLANAR);
  2378. ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "uv2_triplanar_sharpness", PROPERTY_HINT_EXP_EASING), "set_uv2_triplanar_blend_sharpness", "get_uv2_triplanar_blend_sharpness");
  2379. ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "uv2_world_triplanar"), "set_flag", "get_flag", FLAG_UV2_USE_WORLD_TRIPLANAR);
  2380. ADD_GROUP("Sampling", "texture_");
  2381. 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");
  2382. ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "texture_repeat"), "set_flag", "get_flag", FLAG_USE_TEXTURE_REPEAT);
  2383. ADD_GROUP("Shadows", "");
  2384. ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "disable_receive_shadows"), "set_flag", "get_flag", FLAG_DONT_RECEIVE_SHADOWS);
  2385. ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "shadow_to_opacity"), "set_flag", "get_flag", FLAG_USE_SHADOW_TO_OPACITY);
  2386. ADD_GROUP("Billboard", "billboard_");
  2387. ADD_PROPERTY(PropertyInfo(Variant::INT, "billboard_mode", PROPERTY_HINT_ENUM, "Disabled,Enabled,Y-Billboard,Particle Billboard"), "set_billboard_mode", "get_billboard_mode");
  2388. ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "billboard_keep_scale"), "set_flag", "get_flag", FLAG_BILLBOARD_KEEP_SCALE);
  2389. ADD_GROUP("Particles Anim", "particles_anim_");
  2390. 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");
  2391. 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");
  2392. ADD_PROPERTY(PropertyInfo(Variant::BOOL, "particles_anim_loop"), "set_particles_anim_loop", "get_particles_anim_loop");
  2393. ADD_GROUP("Grow", "grow_");
  2394. ADD_PROPERTY(PropertyInfo(Variant::BOOL, "grow"), "set_grow_enabled", "is_grow_enabled");
  2395. ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "grow_amount", PROPERTY_HINT_RANGE, "-16,16,0.001,suffix:m"), "set_grow", "get_grow");
  2396. ADD_GROUP("Transform", "");
  2397. ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "fixed_size"), "set_flag", "get_flag", FLAG_FIXED_SIZE);
  2398. ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "use_point_size"), "set_flag", "get_flag", FLAG_USE_POINT_SIZE);
  2399. ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "point_size", PROPERTY_HINT_RANGE, "0.1,128,0.1,suffix:px"), "set_point_size", "get_point_size");
  2400. ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "use_particle_trails"), "set_flag", "get_flag", FLAG_PARTICLE_TRAILS_MODE);
  2401. ADD_GROUP("Proximity Fade", "proximity_fade_");
  2402. ADD_PROPERTY(PropertyInfo(Variant::BOOL, "proximity_fade_enabled"), "set_proximity_fade_enabled", "is_proximity_fade_enabled");
  2403. ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "proximity_fade_distance", PROPERTY_HINT_RANGE, "0,4096,0.01,suffix:m"), "set_proximity_fade_distance", "get_proximity_fade_distance");
  2404. ADD_GROUP("MSDF", "msdf_");
  2405. ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "msdf_pixel_range", PROPERTY_HINT_RANGE, "1,100,1"), "set_msdf_pixel_range", "get_msdf_pixel_range");
  2406. ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "msdf_outline_size", PROPERTY_HINT_RANGE, "0,250,1"), "set_msdf_outline_size", "get_msdf_outline_size");
  2407. ADD_GROUP("Distance Fade", "distance_fade_");
  2408. ADD_PROPERTY(PropertyInfo(Variant::INT, "distance_fade_mode", PROPERTY_HINT_ENUM, "Disabled,PixelAlpha,PixelDither,ObjectDither"), "set_distance_fade", "get_distance_fade");
  2409. 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");
  2410. 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");
  2411. BIND_ENUM_CONSTANT(TEXTURE_ALBEDO);
  2412. BIND_ENUM_CONSTANT(TEXTURE_METALLIC);
  2413. BIND_ENUM_CONSTANT(TEXTURE_ROUGHNESS);
  2414. BIND_ENUM_CONSTANT(TEXTURE_EMISSION);
  2415. BIND_ENUM_CONSTANT(TEXTURE_NORMAL);
  2416. BIND_ENUM_CONSTANT(TEXTURE_RIM);
  2417. BIND_ENUM_CONSTANT(TEXTURE_CLEARCOAT);
  2418. BIND_ENUM_CONSTANT(TEXTURE_FLOWMAP);
  2419. BIND_ENUM_CONSTANT(TEXTURE_AMBIENT_OCCLUSION);
  2420. BIND_ENUM_CONSTANT(TEXTURE_HEIGHTMAP);
  2421. BIND_ENUM_CONSTANT(TEXTURE_SUBSURFACE_SCATTERING);
  2422. BIND_ENUM_CONSTANT(TEXTURE_SUBSURFACE_TRANSMITTANCE);
  2423. BIND_ENUM_CONSTANT(TEXTURE_BACKLIGHT);
  2424. BIND_ENUM_CONSTANT(TEXTURE_REFRACTION);
  2425. BIND_ENUM_CONSTANT(TEXTURE_DETAIL_MASK);
  2426. BIND_ENUM_CONSTANT(TEXTURE_DETAIL_ALBEDO);
  2427. BIND_ENUM_CONSTANT(TEXTURE_DETAIL_NORMAL);
  2428. BIND_ENUM_CONSTANT(TEXTURE_ORM);
  2429. BIND_ENUM_CONSTANT(TEXTURE_MAX);
  2430. BIND_ENUM_CONSTANT(TEXTURE_FILTER_NEAREST);
  2431. BIND_ENUM_CONSTANT(TEXTURE_FILTER_LINEAR);
  2432. BIND_ENUM_CONSTANT(TEXTURE_FILTER_NEAREST_WITH_MIPMAPS);
  2433. BIND_ENUM_CONSTANT(TEXTURE_FILTER_LINEAR_WITH_MIPMAPS);
  2434. BIND_ENUM_CONSTANT(TEXTURE_FILTER_NEAREST_WITH_MIPMAPS_ANISOTROPIC);
  2435. BIND_ENUM_CONSTANT(TEXTURE_FILTER_LINEAR_WITH_MIPMAPS_ANISOTROPIC);
  2436. BIND_ENUM_CONSTANT(TEXTURE_FILTER_MAX);
  2437. BIND_ENUM_CONSTANT(DETAIL_UV_1);
  2438. BIND_ENUM_CONSTANT(DETAIL_UV_2);
  2439. BIND_ENUM_CONSTANT(TRANSPARENCY_DISABLED);
  2440. BIND_ENUM_CONSTANT(TRANSPARENCY_ALPHA);
  2441. BIND_ENUM_CONSTANT(TRANSPARENCY_ALPHA_SCISSOR);
  2442. BIND_ENUM_CONSTANT(TRANSPARENCY_ALPHA_HASH);
  2443. BIND_ENUM_CONSTANT(TRANSPARENCY_ALPHA_DEPTH_PRE_PASS);
  2444. BIND_ENUM_CONSTANT(TRANSPARENCY_MAX);
  2445. BIND_ENUM_CONSTANT(SHADING_MODE_UNSHADED);
  2446. BIND_ENUM_CONSTANT(SHADING_MODE_PER_PIXEL);
  2447. BIND_ENUM_CONSTANT(SHADING_MODE_PER_VERTEX);
  2448. BIND_ENUM_CONSTANT(SHADING_MODE_MAX);
  2449. BIND_ENUM_CONSTANT(FEATURE_EMISSION);
  2450. BIND_ENUM_CONSTANT(FEATURE_NORMAL_MAPPING);
  2451. BIND_ENUM_CONSTANT(FEATURE_RIM);
  2452. BIND_ENUM_CONSTANT(FEATURE_CLEARCOAT);
  2453. BIND_ENUM_CONSTANT(FEATURE_ANISOTROPY);
  2454. BIND_ENUM_CONSTANT(FEATURE_AMBIENT_OCCLUSION);
  2455. BIND_ENUM_CONSTANT(FEATURE_HEIGHT_MAPPING);
  2456. BIND_ENUM_CONSTANT(FEATURE_SUBSURFACE_SCATTERING);
  2457. BIND_ENUM_CONSTANT(FEATURE_SUBSURFACE_TRANSMITTANCE);
  2458. BIND_ENUM_CONSTANT(FEATURE_BACKLIGHT);
  2459. BIND_ENUM_CONSTANT(FEATURE_REFRACTION);
  2460. BIND_ENUM_CONSTANT(FEATURE_DETAIL);
  2461. BIND_ENUM_CONSTANT(FEATURE_MAX);
  2462. BIND_ENUM_CONSTANT(BLEND_MODE_MIX);
  2463. BIND_ENUM_CONSTANT(BLEND_MODE_ADD);
  2464. BIND_ENUM_CONSTANT(BLEND_MODE_SUB);
  2465. BIND_ENUM_CONSTANT(BLEND_MODE_MUL);
  2466. BIND_ENUM_CONSTANT(ALPHA_ANTIALIASING_OFF);
  2467. BIND_ENUM_CONSTANT(ALPHA_ANTIALIASING_ALPHA_TO_COVERAGE);
  2468. BIND_ENUM_CONSTANT(ALPHA_ANTIALIASING_ALPHA_TO_COVERAGE_AND_TO_ONE);
  2469. BIND_ENUM_CONSTANT(DEPTH_DRAW_OPAQUE_ONLY);
  2470. BIND_ENUM_CONSTANT(DEPTH_DRAW_ALWAYS);
  2471. BIND_ENUM_CONSTANT(DEPTH_DRAW_DISABLED);
  2472. BIND_ENUM_CONSTANT(CULL_BACK);
  2473. BIND_ENUM_CONSTANT(CULL_FRONT);
  2474. BIND_ENUM_CONSTANT(CULL_DISABLED);
  2475. BIND_ENUM_CONSTANT(FLAG_DISABLE_DEPTH_TEST);
  2476. BIND_ENUM_CONSTANT(FLAG_ALBEDO_FROM_VERTEX_COLOR);
  2477. BIND_ENUM_CONSTANT(FLAG_SRGB_VERTEX_COLOR);
  2478. BIND_ENUM_CONSTANT(FLAG_USE_POINT_SIZE);
  2479. BIND_ENUM_CONSTANT(FLAG_FIXED_SIZE);
  2480. BIND_ENUM_CONSTANT(FLAG_BILLBOARD_KEEP_SCALE);
  2481. BIND_ENUM_CONSTANT(FLAG_UV1_USE_TRIPLANAR);
  2482. BIND_ENUM_CONSTANT(FLAG_UV2_USE_TRIPLANAR);
  2483. BIND_ENUM_CONSTANT(FLAG_UV1_USE_WORLD_TRIPLANAR);
  2484. BIND_ENUM_CONSTANT(FLAG_UV2_USE_WORLD_TRIPLANAR);
  2485. BIND_ENUM_CONSTANT(FLAG_AO_ON_UV2);
  2486. BIND_ENUM_CONSTANT(FLAG_EMISSION_ON_UV2);
  2487. BIND_ENUM_CONSTANT(FLAG_ALBEDO_TEXTURE_FORCE_SRGB);
  2488. BIND_ENUM_CONSTANT(FLAG_DONT_RECEIVE_SHADOWS);
  2489. BIND_ENUM_CONSTANT(FLAG_DISABLE_AMBIENT_LIGHT);
  2490. BIND_ENUM_CONSTANT(FLAG_USE_SHADOW_TO_OPACITY);
  2491. BIND_ENUM_CONSTANT(FLAG_USE_TEXTURE_REPEAT);
  2492. BIND_ENUM_CONSTANT(FLAG_INVERT_HEIGHTMAP);
  2493. BIND_ENUM_CONSTANT(FLAG_SUBSURFACE_MODE_SKIN);
  2494. BIND_ENUM_CONSTANT(FLAG_PARTICLE_TRAILS_MODE);
  2495. BIND_ENUM_CONSTANT(FLAG_ALBEDO_TEXTURE_MSDF);
  2496. BIND_ENUM_CONSTANT(FLAG_DISABLE_FOG);
  2497. BIND_ENUM_CONSTANT(FLAG_MAX);
  2498. BIND_ENUM_CONSTANT(DIFFUSE_BURLEY);
  2499. BIND_ENUM_CONSTANT(DIFFUSE_LAMBERT);
  2500. BIND_ENUM_CONSTANT(DIFFUSE_LAMBERT_WRAP);
  2501. BIND_ENUM_CONSTANT(DIFFUSE_TOON);
  2502. BIND_ENUM_CONSTANT(SPECULAR_SCHLICK_GGX);
  2503. BIND_ENUM_CONSTANT(SPECULAR_TOON);
  2504. BIND_ENUM_CONSTANT(SPECULAR_DISABLED);
  2505. BIND_ENUM_CONSTANT(BILLBOARD_DISABLED);
  2506. BIND_ENUM_CONSTANT(BILLBOARD_ENABLED);
  2507. BIND_ENUM_CONSTANT(BILLBOARD_FIXED_Y);
  2508. BIND_ENUM_CONSTANT(BILLBOARD_PARTICLES);
  2509. BIND_ENUM_CONSTANT(TEXTURE_CHANNEL_RED);
  2510. BIND_ENUM_CONSTANT(TEXTURE_CHANNEL_GREEN);
  2511. BIND_ENUM_CONSTANT(TEXTURE_CHANNEL_BLUE);
  2512. BIND_ENUM_CONSTANT(TEXTURE_CHANNEL_ALPHA);
  2513. BIND_ENUM_CONSTANT(TEXTURE_CHANNEL_GRAYSCALE);
  2514. BIND_ENUM_CONSTANT(EMISSION_OP_ADD);
  2515. BIND_ENUM_CONSTANT(EMISSION_OP_MULTIPLY);
  2516. BIND_ENUM_CONSTANT(DISTANCE_FADE_DISABLED);
  2517. BIND_ENUM_CONSTANT(DISTANCE_FADE_PIXEL_ALPHA);
  2518. BIND_ENUM_CONSTANT(DISTANCE_FADE_PIXEL_DITHER);
  2519. BIND_ENUM_CONSTANT(DISTANCE_FADE_OBJECT_DITHER);
  2520. }
  2521. BaseMaterial3D::BaseMaterial3D(bool p_orm) :
  2522. element(this) {
  2523. orm = p_orm;
  2524. // Initialize to the same values as the shader
  2525. set_albedo(Color(1.0, 1.0, 1.0, 1.0));
  2526. set_specular(0.5);
  2527. set_roughness(1.0);
  2528. set_metallic(0.0);
  2529. set_emission(Color(0, 0, 0));
  2530. set_emission_energy_multiplier(1.0);
  2531. set_normal_scale(1);
  2532. set_rim(1.0);
  2533. set_rim_tint(0.5);
  2534. set_clearcoat(1);
  2535. set_clearcoat_roughness(0.5);
  2536. set_anisotropy(0);
  2537. set_heightmap_scale(5.0);
  2538. set_subsurface_scattering_strength(0);
  2539. set_backlight(Color(0, 0, 0));
  2540. set_transmittance_color(Color(1, 1, 1, 1));
  2541. set_transmittance_depth(0.1);
  2542. set_transmittance_boost(0.0);
  2543. set_refraction(0.05);
  2544. set_point_size(1);
  2545. set_uv1_offset(Vector3(0, 0, 0));
  2546. set_uv1_scale(Vector3(1, 1, 1));
  2547. set_uv1_triplanar_blend_sharpness(1);
  2548. set_uv2_offset(Vector3(0, 0, 0));
  2549. set_uv2_scale(Vector3(1, 1, 1));
  2550. set_uv2_triplanar_blend_sharpness(1);
  2551. set_billboard_mode(BILLBOARD_DISABLED);
  2552. set_particles_anim_h_frames(1);
  2553. set_particles_anim_v_frames(1);
  2554. set_particles_anim_loop(false);
  2555. set_transparency(TRANSPARENCY_DISABLED);
  2556. set_alpha_antialiasing(ALPHA_ANTIALIASING_OFF);
  2557. // Alpha scissor threshold of 0.5 matches the glTF specification and Label3D default.
  2558. // <https://www.khronos.org/registry/glTF/specs/2.0/glTF-2.0.html#_material_alphacutoff>
  2559. set_alpha_scissor_threshold(0.5);
  2560. set_alpha_hash_scale(1.0);
  2561. set_alpha_antialiasing_edge(0.3);
  2562. set_proximity_fade_distance(1);
  2563. set_distance_fade_min_distance(0);
  2564. set_distance_fade_max_distance(10);
  2565. set_ao_light_affect(0.0);
  2566. set_metallic_texture_channel(TEXTURE_CHANNEL_RED);
  2567. set_roughness_texture_channel(TEXTURE_CHANNEL_RED);
  2568. set_ao_texture_channel(TEXTURE_CHANNEL_RED);
  2569. set_refraction_texture_channel(TEXTURE_CHANNEL_RED);
  2570. set_grow(0.0);
  2571. set_msdf_pixel_range(4.0);
  2572. set_msdf_outline_size(0.0);
  2573. set_heightmap_deep_parallax_min_layers(8);
  2574. set_heightmap_deep_parallax_max_layers(32);
  2575. set_heightmap_deep_parallax_flip_tangent(false); //also sets binormal
  2576. flags[FLAG_ALBEDO_TEXTURE_MSDF] = false;
  2577. flags[FLAG_USE_TEXTURE_REPEAT] = true;
  2578. current_key.invalid_key = 1;
  2579. _mark_initialized(callable_mp(this, &BaseMaterial3D::_queue_shader_change));
  2580. }
  2581. BaseMaterial3D::~BaseMaterial3D() {
  2582. ERR_FAIL_NULL(RenderingServer::get_singleton());
  2583. MutexLock lock(material_mutex);
  2584. if (shader_map.has(current_key)) {
  2585. shader_map[current_key].users--;
  2586. if (shader_map[current_key].users == 0) {
  2587. //deallocate shader, as it's no longer in use
  2588. RS::get_singleton()->free(shader_map[current_key].shader);
  2589. shader_map.erase(current_key);
  2590. }
  2591. RS::get_singleton()->material_set_shader(_get_material(), RID());
  2592. }
  2593. }
  2594. //////////////////////
  2595. #ifndef DISABLE_DEPRECATED
  2596. // Kept for compatibility from 3.x to 4.0.
  2597. bool StandardMaterial3D::_set(const StringName &p_name, const Variant &p_value) {
  2598. if (p_name == "flags_transparent") {
  2599. bool transparent = p_value;
  2600. if (transparent) {
  2601. set_transparency(TRANSPARENCY_ALPHA);
  2602. }
  2603. return true;
  2604. } else if (p_name == "flags_unshaded") {
  2605. bool unshaded = p_value;
  2606. if (unshaded) {
  2607. set_shading_mode(SHADING_MODE_UNSHADED);
  2608. }
  2609. return true;
  2610. } else if (p_name == "flags_vertex_lighting") {
  2611. bool vertex_lit = p_value;
  2612. if (vertex_lit && get_shading_mode() != SHADING_MODE_UNSHADED) {
  2613. set_shading_mode(SHADING_MODE_PER_VERTEX);
  2614. }
  2615. return true;
  2616. } else if (p_name == "params_use_alpha_scissor") {
  2617. bool use_scissor = p_value;
  2618. if (use_scissor) {
  2619. set_transparency(TRANSPARENCY_ALPHA_SCISSOR);
  2620. }
  2621. return true;
  2622. } else if (p_name == "params_use_alpha_hash") {
  2623. bool use_hash = p_value;
  2624. if (use_hash) {
  2625. set_transparency(TRANSPARENCY_ALPHA_HASH);
  2626. }
  2627. return true;
  2628. } else if (p_name == "params_depth_draw_mode") {
  2629. int mode = p_value;
  2630. if (mode == 3) {
  2631. set_transparency(TRANSPARENCY_ALPHA_DEPTH_PRE_PASS);
  2632. }
  2633. return true;
  2634. } else if (p_name == "depth_enabled") {
  2635. bool enabled = p_value;
  2636. if (enabled) {
  2637. set_feature(FEATURE_HEIGHT_MAPPING, true);
  2638. set_flag(FLAG_INVERT_HEIGHTMAP, true);
  2639. }
  2640. return true;
  2641. } else {
  2642. static const Pair<const char *, const char *> remaps[] = {
  2643. { "flags_use_shadow_to_opacity", "shadow_to_opacity" },
  2644. { "flags_use_shadow_to_opacity", "shadow_to_opacity" },
  2645. { "flags_no_depth_test", "no_depth_test" },
  2646. { "flags_use_point_size", "use_point_size" },
  2647. { "flags_fixed_size", "fixed_size" },
  2648. { "flags_albedo_tex_force_srgb", "albedo_texture_force_srgb" },
  2649. { "flags_do_not_receive_shadows", "disable_receive_shadows" },
  2650. { "flags_disable_ambient_light", "disable_ambient_light" },
  2651. { "params_diffuse_mode", "diffuse_mode" },
  2652. { "params_specular_mode", "specular_mode" },
  2653. { "params_blend_mode", "blend_mode" },
  2654. { "params_cull_mode", "cull_mode" },
  2655. { "params_depth_draw_mode", "params_depth_draw_mode" },
  2656. { "params_point_size", "point_size" },
  2657. { "params_billboard_mode", "billboard_mode" },
  2658. { "params_billboard_keep_scale", "billboard_keep_scale" },
  2659. { "params_grow", "grow" },
  2660. { "params_grow_amount", "grow_amount" },
  2661. { "params_alpha_scissor_threshold", "alpha_scissor_threshold" },
  2662. { "params_alpha_hash_scale", "alpha_hash_scale" },
  2663. { "params_alpha_antialiasing_edge", "alpha_antialiasing_edge" },
  2664. { "depth_scale", "heightmap_scale" },
  2665. { "depth_deep_parallax", "heightmap_deep_parallax" },
  2666. { "depth_min_layers", "heightmap_min_layers" },
  2667. { "depth_max_layers", "heightmap_max_layers" },
  2668. { "depth_flip_tangent", "heightmap_flip_tangent" },
  2669. { "depth_flip_binormal", "heightmap_flip_binormal" },
  2670. { "depth_texture", "heightmap_texture" },
  2671. { "emission_energy", "emission_energy_multiplier" },
  2672. { nullptr, nullptr },
  2673. };
  2674. int idx = 0;
  2675. while (remaps[idx].first) {
  2676. if (p_name == remaps[idx].first) {
  2677. set(remaps[idx].second, p_value);
  2678. return true;
  2679. }
  2680. idx++;
  2681. }
  2682. WARN_PRINT("Godot 3.x SpatialMaterial remapped parameter not found: " + String(p_name));
  2683. return true;
  2684. }
  2685. }
  2686. #endif // DISABLE_DEPRECATED
  2687. ///////////////////////