renderer_scene_render_forward.cpp 122 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845184618471848184918501851185218531854185518561857185818591860186118621863186418651866186718681869187018711872187318741875187618771878187918801881188218831884188518861887188818891890189118921893189418951896189718981899190019011902190319041905190619071908190919101911191219131914191519161917191819191920192119221923192419251926192719281929193019311932193319341935193619371938193919401941194219431944194519461947194819491950195119521953195419551956195719581959196019611962196319641965196619671968196919701971197219731974197519761977197819791980198119821983198419851986198719881989199019911992199319941995199619971998199920002001200220032004200520062007200820092010201120122013201420152016201720182019202020212022202320242025202620272028202920302031203220332034203520362037203820392040204120422043204420452046204720482049205020512052205320542055205620572058205920602061206220632064206520662067206820692070207120722073207420752076207720782079208020812082208320842085208620872088208920902091209220932094209520962097209820992100210121022103210421052106210721082109211021112112211321142115211621172118211921202121212221232124212521262127212821292130213121322133213421352136213721382139214021412142214321442145214621472148214921502151215221532154215521562157215821592160216121622163216421652166216721682169217021712172217321742175217621772178217921802181218221832184218521862187218821892190219121922193219421952196219721982199220022012202220322042205220622072208220922102211221222132214221522162217221822192220222122222223222422252226222722282229223022312232223322342235223622372238223922402241224222432244224522462247224822492250225122522253225422552256225722582259226022612262226322642265226622672268226922702271227222732274227522762277227822792280228122822283228422852286228722882289229022912292229322942295229622972298229923002301230223032304230523062307230823092310231123122313231423152316231723182319232023212322232323242325232623272328232923302331233223332334233523362337233823392340234123422343234423452346234723482349235023512352235323542355235623572358235923602361236223632364236523662367236823692370237123722373237423752376237723782379238023812382238323842385238623872388238923902391239223932394239523962397239823992400240124022403240424052406240724082409241024112412241324142415241624172418241924202421242224232424242524262427242824292430243124322433243424352436243724382439244024412442244324442445244624472448244924502451245224532454245524562457245824592460246124622463246424652466246724682469247024712472247324742475247624772478247924802481248224832484248524862487248824892490249124922493249424952496249724982499250025012502250325042505250625072508250925102511251225132514251525162517251825192520252125222523252425252526252725282529253025312532253325342535253625372538253925402541254225432544254525462547254825492550255125522553255425552556255725582559256025612562256325642565256625672568256925702571257225732574257525762577257825792580258125822583258425852586258725882589259025912592259325942595259625972598259926002601260226032604260526062607260826092610261126122613261426152616261726182619262026212622262326242625262626272628262926302631263226332634263526362637263826392640264126422643264426452646264726482649265026512652265326542655265626572658265926602661266226632664266526662667266826692670267126722673267426752676267726782679268026812682268326842685268626872688268926902691269226932694269526962697269826992700270127022703270427052706270727082709271027112712271327142715271627172718271927202721272227232724272527262727272827292730273127322733273427352736273727382739274027412742274327442745274627472748274927502751275227532754275527562757275827592760276127622763276427652766276727682769277027712772277327742775277627772778277927802781278227832784278527862787278827892790279127922793279427952796279727982799280028012802280328042805280628072808280928102811281228132814281528162817281828192820282128222823282428252826282728282829283028312832283328342835283628372838283928402841284228432844284528462847284828492850285128522853285428552856285728582859286028612862286328642865286628672868286928702871287228732874287528762877287828792880288128822883288428852886288728882889289028912892289328942895289628972898289929002901290229032904290529062907290829092910291129122913291429152916291729182919292029212922292329242925292629272928292929302931293229332934293529362937293829392940294129422943294429452946294729482949295029512952295329542955295629572958295929602961296229632964296529662967296829692970297129722973297429752976297729782979298029812982298329842985298629872988298929902991299229932994299529962997299829993000300130023003300430053006300730083009301030113012301330143015301630173018301930203021302230233024302530263027302830293030303130323033303430353036303730383039304030413042304330443045304630473048304930503051305230533054305530563057305830593060306130623063306430653066
  1. /*************************************************************************/
  2. /* renderer_scene_render_forward.cpp */
  3. /*************************************************************************/
  4. /* This file is part of: */
  5. /* GODOT ENGINE */
  6. /* https://godotengine.org */
  7. /*************************************************************************/
  8. /* Copyright (c) 2007-2020 Juan Linietsky, Ariel Manzur. */
  9. /* Copyright (c) 2014-2020 Godot Engine contributors (cf. AUTHORS.md). */
  10. /* */
  11. /* Permission is hereby granted, free of charge, to any person obtaining */
  12. /* a copy of this software and associated documentation files (the */
  13. /* "Software"), to deal in the Software without restriction, including */
  14. /* without limitation the rights to use, copy, modify, merge, publish, */
  15. /* distribute, sublicense, and/or sell copies of the Software, and to */
  16. /* permit persons to whom the Software is furnished to do so, subject to */
  17. /* the following conditions: */
  18. /* */
  19. /* The above copyright notice and this permission notice shall be */
  20. /* included in all copies or substantial portions of the Software. */
  21. /* */
  22. /* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
  23. /* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
  24. /* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
  25. /* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
  26. /* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
  27. /* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
  28. /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
  29. /*************************************************************************/
  30. #include "renderer_scene_render_forward.h"
  31. #include "core/config/project_settings.h"
  32. #include "servers/rendering/rendering_device.h"
  33. #include "servers/rendering/rendering_server_default.h"
  34. /* SCENE SHADER */
  35. void RendererSceneRenderForward::ShaderData::set_code(const String &p_code) {
  36. //compile
  37. code = p_code;
  38. valid = false;
  39. ubo_size = 0;
  40. uniforms.clear();
  41. uses_screen_texture = false;
  42. if (code == String()) {
  43. return; //just invalid, but no error
  44. }
  45. ShaderCompilerRD::GeneratedCode gen_code;
  46. int blend_mode = BLEND_MODE_MIX;
  47. int depth_testi = DEPTH_TEST_ENABLED;
  48. int alpha_antialiasing_mode = ALPHA_ANTIALIASING_OFF;
  49. int cull = CULL_BACK;
  50. uses_point_size = false;
  51. uses_alpha = false;
  52. uses_blend_alpha = false;
  53. uses_depth_pre_pass = false;
  54. uses_discard = false;
  55. uses_roughness = false;
  56. uses_normal = false;
  57. bool wireframe = false;
  58. unshaded = false;
  59. uses_vertex = false;
  60. uses_sss = false;
  61. uses_transmittance = false;
  62. uses_screen_texture = false;
  63. uses_depth_texture = false;
  64. uses_normal_texture = false;
  65. uses_time = false;
  66. writes_modelview_or_projection = false;
  67. uses_world_coordinates = false;
  68. int depth_drawi = DEPTH_DRAW_OPAQUE;
  69. ShaderCompilerRD::IdentifierActions actions;
  70. actions.render_mode_values["blend_add"] = Pair<int *, int>(&blend_mode, BLEND_MODE_ADD);
  71. actions.render_mode_values["blend_mix"] = Pair<int *, int>(&blend_mode, BLEND_MODE_MIX);
  72. actions.render_mode_values["blend_sub"] = Pair<int *, int>(&blend_mode, BLEND_MODE_SUB);
  73. actions.render_mode_values["blend_mul"] = Pair<int *, int>(&blend_mode, BLEND_MODE_MUL);
  74. actions.render_mode_values["alpha_to_coverage"] = Pair<int *, int>(&alpha_antialiasing_mode, ALPHA_ANTIALIASING_ALPHA_TO_COVERAGE);
  75. actions.render_mode_values["alpha_to_coverage_and_one"] = Pair<int *, int>(&alpha_antialiasing_mode, ALPHA_ANTIALIASING_ALPHA_TO_COVERAGE_AND_TO_ONE);
  76. actions.render_mode_values["depth_draw_never"] = Pair<int *, int>(&depth_drawi, DEPTH_DRAW_DISABLED);
  77. actions.render_mode_values["depth_draw_opaque"] = Pair<int *, int>(&depth_drawi, DEPTH_DRAW_OPAQUE);
  78. actions.render_mode_values["depth_draw_always"] = Pair<int *, int>(&depth_drawi, DEPTH_DRAW_ALWAYS);
  79. actions.render_mode_values["depth_test_disabled"] = Pair<int *, int>(&depth_testi, DEPTH_TEST_DISABLED);
  80. actions.render_mode_values["cull_disabled"] = Pair<int *, int>(&cull, CULL_DISABLED);
  81. actions.render_mode_values["cull_front"] = Pair<int *, int>(&cull, CULL_FRONT);
  82. actions.render_mode_values["cull_back"] = Pair<int *, int>(&cull, CULL_BACK);
  83. actions.render_mode_flags["unshaded"] = &unshaded;
  84. actions.render_mode_flags["wireframe"] = &wireframe;
  85. actions.usage_flag_pointers["ALPHA"] = &uses_alpha;
  86. actions.render_mode_flags["depth_prepass_alpha"] = &uses_depth_pre_pass;
  87. actions.usage_flag_pointers["SSS_STRENGTH"] = &uses_sss;
  88. actions.usage_flag_pointers["SSS_TRANSMITTANCE_DEPTH"] = &uses_transmittance;
  89. actions.usage_flag_pointers["SCREEN_TEXTURE"] = &uses_screen_texture;
  90. actions.usage_flag_pointers["DEPTH_TEXTURE"] = &uses_depth_texture;
  91. actions.usage_flag_pointers["NORMAL_TEXTURE"] = &uses_normal_texture;
  92. actions.usage_flag_pointers["DISCARD"] = &uses_discard;
  93. actions.usage_flag_pointers["TIME"] = &uses_time;
  94. actions.usage_flag_pointers["ROUGHNESS"] = &uses_roughness;
  95. actions.usage_flag_pointers["NORMAL"] = &uses_normal;
  96. actions.usage_flag_pointers["NORMALMAP"] = &uses_normal;
  97. actions.usage_flag_pointers["POINT_SIZE"] = &uses_point_size;
  98. actions.usage_flag_pointers["POINT_COORD"] = &uses_point_size;
  99. actions.write_flag_pointers["MODELVIEW_MATRIX"] = &writes_modelview_or_projection;
  100. actions.write_flag_pointers["PROJECTION_MATRIX"] = &writes_modelview_or_projection;
  101. actions.write_flag_pointers["VERTEX"] = &uses_vertex;
  102. actions.uniforms = &uniforms;
  103. RendererSceneRenderForward *scene_singleton = (RendererSceneRenderForward *)RendererSceneRenderForward::singleton;
  104. Error err = scene_singleton->shader.compiler.compile(RS::SHADER_SPATIAL, code, &actions, path, gen_code);
  105. ERR_FAIL_COND(err != OK);
  106. if (version.is_null()) {
  107. version = scene_singleton->shader.scene_shader.version_create();
  108. }
  109. depth_draw = DepthDraw(depth_drawi);
  110. depth_test = DepthTest(depth_testi);
  111. #if 0
  112. print_line("**compiling shader:");
  113. print_line("**defines:\n");
  114. for (int i = 0; i < gen_code.defines.size(); i++) {
  115. print_line(gen_code.defines[i]);
  116. }
  117. print_line("\n**uniforms:\n" + gen_code.uniforms);
  118. print_line("\n**vertex_globals:\n" + gen_code.vertex_global);
  119. print_line("\n**vertex_code:\n" + gen_code.vertex);
  120. print_line("\n**fragment_globals:\n" + gen_code.fragment_global);
  121. print_line("\n**fragment_code:\n" + gen_code.fragment);
  122. print_line("\n**light_code:\n" + gen_code.light);
  123. #endif
  124. scene_singleton->shader.scene_shader.version_set_code(version, gen_code.uniforms, gen_code.vertex_global, gen_code.vertex, gen_code.fragment_global, gen_code.light, gen_code.fragment, gen_code.defines);
  125. ERR_FAIL_COND(!scene_singleton->shader.scene_shader.version_is_valid(version));
  126. ubo_size = gen_code.uniform_total_size;
  127. ubo_offsets = gen_code.uniform_offsets;
  128. texture_uniforms = gen_code.texture_uniforms;
  129. //blend modes
  130. // if any form of Alpha Antialiasing is enabled, set the blend mode to alpha to coverage
  131. if (alpha_antialiasing_mode != ALPHA_ANTIALIASING_OFF) {
  132. blend_mode = BLEND_MODE_ALPHA_TO_COVERAGE;
  133. }
  134. RD::PipelineColorBlendState::Attachment blend_attachment;
  135. switch (blend_mode) {
  136. case BLEND_MODE_MIX: {
  137. blend_attachment.enable_blend = true;
  138. blend_attachment.alpha_blend_op = RD::BLEND_OP_ADD;
  139. blend_attachment.color_blend_op = RD::BLEND_OP_ADD;
  140. blend_attachment.src_color_blend_factor = RD::BLEND_FACTOR_SRC_ALPHA;
  141. blend_attachment.dst_color_blend_factor = RD::BLEND_FACTOR_ONE_MINUS_SRC_ALPHA;
  142. blend_attachment.src_alpha_blend_factor = RD::BLEND_FACTOR_ONE;
  143. blend_attachment.dst_alpha_blend_factor = RD::BLEND_FACTOR_ONE_MINUS_SRC_ALPHA;
  144. } break;
  145. case BLEND_MODE_ADD: {
  146. blend_attachment.enable_blend = true;
  147. blend_attachment.alpha_blend_op = RD::BLEND_OP_ADD;
  148. blend_attachment.color_blend_op = RD::BLEND_OP_ADD;
  149. blend_attachment.src_color_blend_factor = RD::BLEND_FACTOR_SRC_ALPHA;
  150. blend_attachment.dst_color_blend_factor = RD::BLEND_FACTOR_ONE;
  151. blend_attachment.src_alpha_blend_factor = RD::BLEND_FACTOR_SRC_ALPHA;
  152. blend_attachment.dst_alpha_blend_factor = RD::BLEND_FACTOR_ONE;
  153. uses_blend_alpha = true; //force alpha used because of blend
  154. } break;
  155. case BLEND_MODE_SUB: {
  156. blend_attachment.enable_blend = true;
  157. blend_attachment.alpha_blend_op = RD::BLEND_OP_SUBTRACT;
  158. blend_attachment.color_blend_op = RD::BLEND_OP_SUBTRACT;
  159. blend_attachment.src_color_blend_factor = RD::BLEND_FACTOR_SRC_ALPHA;
  160. blend_attachment.dst_color_blend_factor = RD::BLEND_FACTOR_ONE;
  161. blend_attachment.src_alpha_blend_factor = RD::BLEND_FACTOR_SRC_ALPHA;
  162. blend_attachment.dst_alpha_blend_factor = RD::BLEND_FACTOR_ONE;
  163. uses_blend_alpha = true; //force alpha used because of blend
  164. } break;
  165. case BLEND_MODE_MUL: {
  166. blend_attachment.enable_blend = true;
  167. blend_attachment.alpha_blend_op = RD::BLEND_OP_ADD;
  168. blend_attachment.color_blend_op = RD::BLEND_OP_ADD;
  169. blend_attachment.src_color_blend_factor = RD::BLEND_FACTOR_DST_COLOR;
  170. blend_attachment.dst_color_blend_factor = RD::BLEND_FACTOR_ZERO;
  171. blend_attachment.src_alpha_blend_factor = RD::BLEND_FACTOR_DST_ALPHA;
  172. blend_attachment.dst_alpha_blend_factor = RD::BLEND_FACTOR_ZERO;
  173. uses_blend_alpha = true; //force alpha used because of blend
  174. } break;
  175. case BLEND_MODE_ALPHA_TO_COVERAGE: {
  176. blend_attachment.enable_blend = true;
  177. blend_attachment.alpha_blend_op = RD::BLEND_OP_ADD;
  178. blend_attachment.color_blend_op = RD::BLEND_OP_ADD;
  179. blend_attachment.src_color_blend_factor = RD::BLEND_FACTOR_SRC_ALPHA;
  180. blend_attachment.dst_color_blend_factor = RD::BLEND_FACTOR_ONE_MINUS_SRC_ALPHA;
  181. blend_attachment.src_alpha_blend_factor = RD::BLEND_FACTOR_ONE;
  182. blend_attachment.dst_alpha_blend_factor = RD::BLEND_FACTOR_ZERO;
  183. }
  184. }
  185. RD::PipelineColorBlendState blend_state_blend;
  186. blend_state_blend.attachments.push_back(blend_attachment);
  187. RD::PipelineColorBlendState blend_state_opaque = RD::PipelineColorBlendState::create_disabled(1);
  188. RD::PipelineColorBlendState blend_state_opaque_specular = RD::PipelineColorBlendState::create_disabled(2);
  189. RD::PipelineColorBlendState blend_state_depth_normal_roughness = RD::PipelineColorBlendState::create_disabled(1);
  190. RD::PipelineColorBlendState blend_state_depth_normal_roughness_giprobe = RD::PipelineColorBlendState::create_disabled(2);
  191. //update pipelines
  192. RD::PipelineDepthStencilState depth_stencil_state;
  193. if (depth_test != DEPTH_TEST_DISABLED) {
  194. depth_stencil_state.enable_depth_test = true;
  195. depth_stencil_state.depth_compare_operator = RD::COMPARE_OP_LESS_OR_EQUAL;
  196. depth_stencil_state.enable_depth_write = depth_draw != DEPTH_DRAW_DISABLED ? true : false;
  197. }
  198. for (int i = 0; i < CULL_VARIANT_MAX; i++) {
  199. RD::PolygonCullMode cull_mode_rd_table[CULL_VARIANT_MAX][3] = {
  200. { RD::POLYGON_CULL_DISABLED, RD::POLYGON_CULL_FRONT, RD::POLYGON_CULL_BACK },
  201. { RD::POLYGON_CULL_DISABLED, RD::POLYGON_CULL_BACK, RD::POLYGON_CULL_FRONT },
  202. { RD::POLYGON_CULL_DISABLED, RD::POLYGON_CULL_DISABLED, RD::POLYGON_CULL_DISABLED }
  203. };
  204. RD::PolygonCullMode cull_mode_rd = cull_mode_rd_table[i][cull];
  205. for (int j = 0; j < RS::PRIMITIVE_MAX; j++) {
  206. RD::RenderPrimitive primitive_rd_table[RS::PRIMITIVE_MAX] = {
  207. RD::RENDER_PRIMITIVE_POINTS,
  208. RD::RENDER_PRIMITIVE_LINES,
  209. RD::RENDER_PRIMITIVE_LINESTRIPS,
  210. RD::RENDER_PRIMITIVE_TRIANGLES,
  211. RD::RENDER_PRIMITIVE_TRIANGLE_STRIPS,
  212. };
  213. RD::RenderPrimitive primitive_rd = uses_point_size ? RD::RENDER_PRIMITIVE_POINTS : primitive_rd_table[j];
  214. for (int k = 0; k < SHADER_VERSION_MAX; k++) {
  215. if (!static_cast<RendererSceneRenderForward *>(singleton)->shader.scene_shader.is_variant_enabled(k)) {
  216. continue;
  217. }
  218. RD::PipelineRasterizationState raster_state;
  219. raster_state.cull_mode = cull_mode_rd;
  220. raster_state.wireframe = wireframe;
  221. RD::PipelineColorBlendState blend_state;
  222. RD::PipelineDepthStencilState depth_stencil = depth_stencil_state;
  223. RD::PipelineMultisampleState multisample_state;
  224. if (uses_alpha || uses_blend_alpha) {
  225. // only allow these flags to go through if we have some form of msaa
  226. if (alpha_antialiasing_mode == ALPHA_ANTIALIASING_ALPHA_TO_COVERAGE) {
  227. multisample_state.enable_alpha_to_coverage = true;
  228. } else if (alpha_antialiasing_mode == ALPHA_ANTIALIASING_ALPHA_TO_COVERAGE_AND_TO_ONE) {
  229. multisample_state.enable_alpha_to_coverage = true;
  230. multisample_state.enable_alpha_to_one = true;
  231. }
  232. if (k == SHADER_VERSION_COLOR_PASS || k == SHADER_VERSION_COLOR_PASS_WITH_FORWARD_GI || k == SHADER_VERSION_LIGHTMAP_COLOR_PASS) {
  233. blend_state = blend_state_blend;
  234. if (depth_draw == DEPTH_DRAW_OPAQUE) {
  235. depth_stencil.enable_depth_write = false; //alpha does not draw depth
  236. }
  237. } else if (uses_depth_pre_pass && (k == SHADER_VERSION_DEPTH_PASS || k == SHADER_VERSION_DEPTH_PASS_DP || k == SHADER_VERSION_DEPTH_PASS_WITH_NORMAL_AND_ROUGHNESS || k == SHADER_VERSION_DEPTH_PASS_WITH_MATERIAL)) {
  238. if (k == SHADER_VERSION_DEPTH_PASS || k == SHADER_VERSION_DEPTH_PASS_DP) {
  239. //none, blend state contains nothing
  240. } else if (k == SHADER_VERSION_DEPTH_PASS_WITH_MATERIAL) {
  241. blend_state = RD::PipelineColorBlendState::create_disabled(5); //writes to normal and roughness in opaque way
  242. } else {
  243. blend_state = blend_state_opaque; //writes to normal and roughness in opaque way
  244. }
  245. } else {
  246. pipelines[i][j][k].clear();
  247. continue; // do not use this version (will error if using it is attempted)
  248. }
  249. } else {
  250. if (k == SHADER_VERSION_COLOR_PASS || k == SHADER_VERSION_COLOR_PASS_WITH_FORWARD_GI || k == SHADER_VERSION_LIGHTMAP_COLOR_PASS) {
  251. blend_state = blend_state_opaque;
  252. } else if (k == SHADER_VERSION_DEPTH_PASS || k == SHADER_VERSION_DEPTH_PASS_DP) {
  253. //none, leave empty
  254. } else if (k == SHADER_VERSION_DEPTH_PASS_WITH_NORMAL_AND_ROUGHNESS) {
  255. blend_state = blend_state_depth_normal_roughness;
  256. } else if (k == SHADER_VERSION_DEPTH_PASS_WITH_NORMAL_AND_ROUGHNESS_AND_GIPROBE) {
  257. blend_state = blend_state_depth_normal_roughness_giprobe;
  258. } else if (k == SHADER_VERSION_DEPTH_PASS_WITH_MATERIAL) {
  259. blend_state = RD::PipelineColorBlendState::create_disabled(5); //writes to normal and roughness in opaque way
  260. } else if (k == SHADER_VERSION_DEPTH_PASS_WITH_SDF) {
  261. blend_state = RD::PipelineColorBlendState(); //no color targets for SDF
  262. } else {
  263. //specular write
  264. blend_state = blend_state_opaque_specular;
  265. depth_stencil.enable_depth_test = false;
  266. depth_stencil.enable_depth_write = false;
  267. }
  268. }
  269. RID shader_variant = scene_singleton->shader.scene_shader.version_get_shader(version, k);
  270. pipelines[i][j][k].setup(shader_variant, primitive_rd, raster_state, multisample_state, depth_stencil, blend_state, 0);
  271. }
  272. }
  273. }
  274. valid = true;
  275. }
  276. void RendererSceneRenderForward::ShaderData::set_default_texture_param(const StringName &p_name, RID p_texture) {
  277. if (!p_texture.is_valid()) {
  278. default_texture_params.erase(p_name);
  279. } else {
  280. default_texture_params[p_name] = p_texture;
  281. }
  282. }
  283. void RendererSceneRenderForward::ShaderData::get_param_list(List<PropertyInfo> *p_param_list) const {
  284. Map<int, StringName> order;
  285. for (Map<StringName, ShaderLanguage::ShaderNode::Uniform>::Element *E = uniforms.front(); E; E = E->next()) {
  286. if (E->get().scope != ShaderLanguage::ShaderNode::Uniform::SCOPE_LOCAL) {
  287. continue;
  288. }
  289. if (E->get().texture_order >= 0) {
  290. order[E->get().texture_order + 100000] = E->key();
  291. } else {
  292. order[E->get().order] = E->key();
  293. }
  294. }
  295. for (Map<int, StringName>::Element *E = order.front(); E; E = E->next()) {
  296. PropertyInfo pi = ShaderLanguage::uniform_to_property_info(uniforms[E->get()]);
  297. pi.name = E->get();
  298. p_param_list->push_back(pi);
  299. }
  300. }
  301. void RendererSceneRenderForward::ShaderData::get_instance_param_list(List<RendererStorage::InstanceShaderParam> *p_param_list) const {
  302. for (Map<StringName, ShaderLanguage::ShaderNode::Uniform>::Element *E = uniforms.front(); E; E = E->next()) {
  303. if (E->get().scope != ShaderLanguage::ShaderNode::Uniform::SCOPE_INSTANCE) {
  304. continue;
  305. }
  306. RendererStorage::InstanceShaderParam p;
  307. p.info = ShaderLanguage::uniform_to_property_info(E->get());
  308. p.info.name = E->key(); //supply name
  309. p.index = E->get().instance_index;
  310. p.default_value = ShaderLanguage::constant_value_to_variant(E->get().default_value, E->get().type, E->get().hint);
  311. p_param_list->push_back(p);
  312. }
  313. }
  314. bool RendererSceneRenderForward::ShaderData::is_param_texture(const StringName &p_param) const {
  315. if (!uniforms.has(p_param)) {
  316. return false;
  317. }
  318. return uniforms[p_param].texture_order >= 0;
  319. }
  320. bool RendererSceneRenderForward::ShaderData::is_animated() const {
  321. return false;
  322. }
  323. bool RendererSceneRenderForward::ShaderData::casts_shadows() const {
  324. return false;
  325. }
  326. Variant RendererSceneRenderForward::ShaderData::get_default_parameter(const StringName &p_parameter) const {
  327. if (uniforms.has(p_parameter)) {
  328. ShaderLanguage::ShaderNode::Uniform uniform = uniforms[p_parameter];
  329. Vector<ShaderLanguage::ConstantNode::Value> default_value = uniform.default_value;
  330. return ShaderLanguage::constant_value_to_variant(default_value, uniform.type, uniform.hint);
  331. }
  332. return Variant();
  333. }
  334. RendererSceneRenderForward::ShaderData::ShaderData() {
  335. valid = false;
  336. uses_screen_texture = false;
  337. }
  338. RendererSceneRenderForward::ShaderData::~ShaderData() {
  339. RendererSceneRenderForward *scene_singleton = (RendererSceneRenderForward *)RendererSceneRenderForward::singleton;
  340. ERR_FAIL_COND(!scene_singleton);
  341. //pipeline variants will clear themselves if shader is gone
  342. if (version.is_valid()) {
  343. scene_singleton->shader.scene_shader.version_free(version);
  344. }
  345. }
  346. RendererStorageRD::ShaderData *RendererSceneRenderForward::_create_shader_func() {
  347. ShaderData *shader_data = memnew(ShaderData);
  348. return shader_data;
  349. }
  350. void RendererSceneRenderForward::MaterialData::set_render_priority(int p_priority) {
  351. priority = p_priority - RS::MATERIAL_RENDER_PRIORITY_MIN; //8 bits
  352. }
  353. void RendererSceneRenderForward::MaterialData::set_next_pass(RID p_pass) {
  354. next_pass = p_pass;
  355. }
  356. void RendererSceneRenderForward::MaterialData::update_parameters(const Map<StringName, Variant> &p_parameters, bool p_uniform_dirty, bool p_textures_dirty) {
  357. RendererSceneRenderForward *scene_singleton = (RendererSceneRenderForward *)RendererSceneRenderForward::singleton;
  358. if ((uint32_t)ubo_data.size() != shader_data->ubo_size) {
  359. p_uniform_dirty = true;
  360. if (uniform_buffer.is_valid()) {
  361. RD::get_singleton()->free(uniform_buffer);
  362. uniform_buffer = RID();
  363. }
  364. ubo_data.resize(shader_data->ubo_size);
  365. if (ubo_data.size()) {
  366. uniform_buffer = RD::get_singleton()->uniform_buffer_create(ubo_data.size());
  367. memset(ubo_data.ptrw(), 0, ubo_data.size()); //clear
  368. }
  369. //clear previous uniform set
  370. if (uniform_set.is_valid() && RD::get_singleton()->uniform_set_is_valid(uniform_set)) {
  371. RD::get_singleton()->free(uniform_set);
  372. uniform_set = RID();
  373. }
  374. }
  375. //check whether buffer changed
  376. if (p_uniform_dirty && ubo_data.size()) {
  377. update_uniform_buffer(shader_data->uniforms, shader_data->ubo_offsets.ptr(), p_parameters, ubo_data.ptrw(), ubo_data.size(), false);
  378. RD::get_singleton()->buffer_update(uniform_buffer, 0, ubo_data.size(), ubo_data.ptrw());
  379. }
  380. uint32_t tex_uniform_count = shader_data->texture_uniforms.size();
  381. if ((uint32_t)texture_cache.size() != tex_uniform_count) {
  382. texture_cache.resize(tex_uniform_count);
  383. p_textures_dirty = true;
  384. //clear previous uniform set
  385. if (uniform_set.is_valid() && RD::get_singleton()->uniform_set_is_valid(uniform_set)) {
  386. RD::get_singleton()->free(uniform_set);
  387. uniform_set = RID();
  388. }
  389. }
  390. if (p_textures_dirty && tex_uniform_count) {
  391. update_textures(p_parameters, shader_data->default_texture_params, shader_data->texture_uniforms, texture_cache.ptrw(), true);
  392. }
  393. if (shader_data->ubo_size == 0 && shader_data->texture_uniforms.size() == 0) {
  394. // This material does not require an uniform set, so don't create it.
  395. return;
  396. }
  397. if (!p_textures_dirty && uniform_set.is_valid() && RD::get_singleton()->uniform_set_is_valid(uniform_set)) {
  398. //no reason to update uniform set, only UBO (or nothing) was needed to update
  399. return;
  400. }
  401. Vector<RD::Uniform> uniforms;
  402. {
  403. if (shader_data->ubo_size) {
  404. RD::Uniform u;
  405. u.uniform_type = RD::UNIFORM_TYPE_UNIFORM_BUFFER;
  406. u.binding = 0;
  407. u.ids.push_back(uniform_buffer);
  408. uniforms.push_back(u);
  409. }
  410. const RID *textures = texture_cache.ptrw();
  411. for (uint32_t i = 0; i < tex_uniform_count; i++) {
  412. RD::Uniform u;
  413. u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
  414. u.binding = 1 + i;
  415. u.ids.push_back(textures[i]);
  416. uniforms.push_back(u);
  417. }
  418. }
  419. uniform_set = RD::get_singleton()->uniform_set_create(uniforms, scene_singleton->shader.scene_shader.version_get_shader(shader_data->version, 0), MATERIAL_UNIFORM_SET);
  420. }
  421. RendererSceneRenderForward::MaterialData::~MaterialData() {
  422. if (uniform_set.is_valid() && RD::get_singleton()->uniform_set_is_valid(uniform_set)) {
  423. RD::get_singleton()->free(uniform_set);
  424. }
  425. if (uniform_buffer.is_valid()) {
  426. RD::get_singleton()->free(uniform_buffer);
  427. }
  428. }
  429. RendererStorageRD::MaterialData *RendererSceneRenderForward::_create_material_func(ShaderData *p_shader) {
  430. MaterialData *material_data = memnew(MaterialData);
  431. material_data->shader_data = p_shader;
  432. material_data->last_frame = false;
  433. //update will happen later anyway so do nothing.
  434. return material_data;
  435. }
  436. RendererSceneRenderForward::RenderBufferDataForward::~RenderBufferDataForward() {
  437. clear();
  438. }
  439. void RendererSceneRenderForward::RenderBufferDataForward::ensure_specular() {
  440. if (!specular.is_valid()) {
  441. RD::TextureFormat tf;
  442. tf.format = RD::DATA_FORMAT_R16G16B16A16_SFLOAT;
  443. tf.width = width;
  444. tf.height = height;
  445. tf.usage_bits = RD::TEXTURE_USAGE_SAMPLING_BIT | RD::TEXTURE_USAGE_STORAGE_BIT;
  446. if (msaa != RS::VIEWPORT_MSAA_DISABLED) {
  447. tf.usage_bits |= RD::TEXTURE_USAGE_CAN_COPY_TO_BIT;
  448. } else {
  449. tf.usage_bits |= RD::TEXTURE_USAGE_COLOR_ATTACHMENT_BIT;
  450. }
  451. specular = RD::get_singleton()->texture_create(tf, RD::TextureView());
  452. if (msaa == RS::VIEWPORT_MSAA_DISABLED) {
  453. {
  454. Vector<RID> fb;
  455. fb.push_back(color);
  456. fb.push_back(specular);
  457. fb.push_back(depth);
  458. color_specular_fb = RD::get_singleton()->framebuffer_create(fb);
  459. }
  460. {
  461. Vector<RID> fb;
  462. fb.push_back(specular);
  463. specular_only_fb = RD::get_singleton()->framebuffer_create(fb);
  464. }
  465. } else {
  466. tf.samples = texture_samples;
  467. tf.usage_bits = RD::TEXTURE_USAGE_COLOR_ATTACHMENT_BIT | RD::TEXTURE_USAGE_CAN_COPY_FROM_BIT;
  468. specular_msaa = RD::get_singleton()->texture_create(tf, RD::TextureView());
  469. {
  470. Vector<RID> fb;
  471. fb.push_back(color_msaa);
  472. fb.push_back(specular_msaa);
  473. fb.push_back(depth_msaa);
  474. color_specular_fb = RD::get_singleton()->framebuffer_create(fb);
  475. }
  476. {
  477. Vector<RID> fb;
  478. fb.push_back(specular_msaa);
  479. specular_only_fb = RD::get_singleton()->framebuffer_create(fb);
  480. }
  481. }
  482. }
  483. }
  484. void RendererSceneRenderForward::RenderBufferDataForward::ensure_gi() {
  485. if (!reflection_buffer.is_valid()) {
  486. RD::TextureFormat tf;
  487. tf.format = RD::DATA_FORMAT_R16G16B16A16_SFLOAT;
  488. tf.width = width;
  489. tf.height = height;
  490. tf.usage_bits = RD::TEXTURE_USAGE_SAMPLING_BIT | RD::TEXTURE_USAGE_STORAGE_BIT;
  491. reflection_buffer = RD::get_singleton()->texture_create(tf, RD::TextureView());
  492. ambient_buffer = RD::get_singleton()->texture_create(tf, RD::TextureView());
  493. }
  494. }
  495. void RendererSceneRenderForward::RenderBufferDataForward::ensure_giprobe() {
  496. if (!giprobe_buffer.is_valid()) {
  497. RD::TextureFormat tf;
  498. tf.format = RD::DATA_FORMAT_R8G8_UINT;
  499. tf.width = width;
  500. tf.height = height;
  501. tf.usage_bits = RD::TEXTURE_USAGE_SAMPLING_BIT;
  502. if (msaa != RS::VIEWPORT_MSAA_DISABLED) {
  503. RD::TextureFormat tf_aa = tf;
  504. tf_aa.usage_bits |= RD::TEXTURE_USAGE_COLOR_ATTACHMENT_BIT;
  505. tf_aa.samples = texture_samples;
  506. giprobe_buffer_msaa = RD::get_singleton()->texture_create(tf_aa, RD::TextureView());
  507. } else {
  508. tf.usage_bits |= RD::TEXTURE_USAGE_COLOR_ATTACHMENT_BIT;
  509. }
  510. tf.usage_bits |= RD::TEXTURE_USAGE_STORAGE_BIT;
  511. giprobe_buffer = RD::get_singleton()->texture_create(tf, RD::TextureView());
  512. Vector<RID> fb;
  513. if (msaa != RS::VIEWPORT_MSAA_DISABLED) {
  514. fb.push_back(depth_msaa);
  515. fb.push_back(normal_roughness_buffer_msaa);
  516. fb.push_back(giprobe_buffer_msaa);
  517. } else {
  518. fb.push_back(depth);
  519. fb.push_back(normal_roughness_buffer);
  520. fb.push_back(giprobe_buffer);
  521. }
  522. depth_normal_roughness_giprobe_fb = RD::get_singleton()->framebuffer_create(fb);
  523. }
  524. }
  525. void RendererSceneRenderForward::RenderBufferDataForward::clear() {
  526. if (ambient_buffer != RID() && ambient_buffer != color) {
  527. RD::get_singleton()->free(ambient_buffer);
  528. ambient_buffer = RID();
  529. }
  530. if (reflection_buffer != RID() && reflection_buffer != specular) {
  531. RD::get_singleton()->free(reflection_buffer);
  532. reflection_buffer = RID();
  533. }
  534. if (giprobe_buffer != RID()) {
  535. RD::get_singleton()->free(giprobe_buffer);
  536. giprobe_buffer = RID();
  537. if (giprobe_buffer_msaa.is_valid()) {
  538. RD::get_singleton()->free(giprobe_buffer_msaa);
  539. giprobe_buffer_msaa = RID();
  540. }
  541. depth_normal_roughness_giprobe_fb = RID();
  542. }
  543. if (color_msaa.is_valid()) {
  544. RD::get_singleton()->free(color_msaa);
  545. color_msaa = RID();
  546. }
  547. if (depth_msaa.is_valid()) {
  548. RD::get_singleton()->free(depth_msaa);
  549. depth_msaa = RID();
  550. }
  551. if (specular.is_valid()) {
  552. if (specular_msaa.is_valid()) {
  553. RD::get_singleton()->free(specular_msaa);
  554. specular_msaa = RID();
  555. }
  556. RD::get_singleton()->free(specular);
  557. specular = RID();
  558. }
  559. color = RID();
  560. depth = RID();
  561. color_specular_fb = RID();
  562. specular_only_fb = RID();
  563. color_fb = RID();
  564. depth_fb = RID();
  565. if (normal_roughness_buffer.is_valid()) {
  566. RD::get_singleton()->free(normal_roughness_buffer);
  567. if (normal_roughness_buffer_msaa.is_valid()) {
  568. RD::get_singleton()->free(normal_roughness_buffer_msaa);
  569. normal_roughness_buffer_msaa = RID();
  570. }
  571. normal_roughness_buffer = RID();
  572. depth_normal_roughness_fb = RID();
  573. }
  574. if (!render_sdfgi_uniform_set.is_null() && RD::get_singleton()->uniform_set_is_valid(render_sdfgi_uniform_set)) {
  575. RD::get_singleton()->free(render_sdfgi_uniform_set);
  576. }
  577. }
  578. void RendererSceneRenderForward::RenderBufferDataForward::configure(RID p_color_buffer, RID p_depth_buffer, int p_width, int p_height, RS::ViewportMSAA p_msaa) {
  579. clear();
  580. msaa = p_msaa;
  581. width = p_width;
  582. height = p_height;
  583. color = p_color_buffer;
  584. depth = p_depth_buffer;
  585. if (p_msaa == RS::VIEWPORT_MSAA_DISABLED) {
  586. {
  587. Vector<RID> fb;
  588. fb.push_back(p_color_buffer);
  589. fb.push_back(depth);
  590. color_fb = RD::get_singleton()->framebuffer_create(fb);
  591. }
  592. {
  593. Vector<RID> fb;
  594. fb.push_back(depth);
  595. depth_fb = RD::get_singleton()->framebuffer_create(fb);
  596. }
  597. } else {
  598. RD::TextureFormat tf;
  599. tf.format = RD::DATA_FORMAT_R16G16B16A16_SFLOAT;
  600. tf.width = p_width;
  601. tf.height = p_height;
  602. tf.texture_type = RD::TEXTURE_TYPE_2D;
  603. tf.usage_bits = RD::TEXTURE_USAGE_COLOR_ATTACHMENT_BIT | RD::TEXTURE_USAGE_CAN_COPY_FROM_BIT | RD::TEXTURE_USAGE_SAMPLING_BIT;
  604. RD::TextureSamples ts[RS::VIEWPORT_MSAA_MAX] = {
  605. RD::TEXTURE_SAMPLES_1,
  606. RD::TEXTURE_SAMPLES_2,
  607. RD::TEXTURE_SAMPLES_4,
  608. RD::TEXTURE_SAMPLES_8,
  609. RD::TEXTURE_SAMPLES_16
  610. };
  611. texture_samples = ts[p_msaa];
  612. tf.samples = texture_samples;
  613. color_msaa = RD::get_singleton()->texture_create(tf, RD::TextureView());
  614. tf.format = RD::get_singleton()->texture_is_format_supported_for_usage(RD::DATA_FORMAT_D24_UNORM_S8_UINT, RD::TEXTURE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT) ? RD::DATA_FORMAT_D24_UNORM_S8_UINT : RD::DATA_FORMAT_D32_SFLOAT_S8_UINT;
  615. tf.usage_bits = RD::TEXTURE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT | RD::TEXTURE_USAGE_CAN_COPY_FROM_BIT | RD::TEXTURE_USAGE_SAMPLING_BIT;
  616. depth_msaa = RD::get_singleton()->texture_create(tf, RD::TextureView());
  617. {
  618. Vector<RID> fb;
  619. fb.push_back(color_msaa);
  620. fb.push_back(depth_msaa);
  621. color_fb = RD::get_singleton()->framebuffer_create(fb);
  622. }
  623. {
  624. Vector<RID> fb;
  625. fb.push_back(depth_msaa);
  626. depth_fb = RD::get_singleton()->framebuffer_create(fb);
  627. }
  628. }
  629. }
  630. void RendererSceneRenderForward::_allocate_normal_roughness_texture(RenderBufferDataForward *rb) {
  631. if (rb->normal_roughness_buffer.is_valid()) {
  632. return;
  633. }
  634. RD::TextureFormat tf;
  635. tf.format = RD::DATA_FORMAT_R8G8B8A8_UNORM;
  636. tf.width = rb->width;
  637. tf.height = rb->height;
  638. tf.usage_bits = RD::TEXTURE_USAGE_SAMPLING_BIT;
  639. if (rb->msaa != RS::VIEWPORT_MSAA_DISABLED) {
  640. tf.usage_bits |= RD::TEXTURE_USAGE_CAN_COPY_TO_BIT | RD::TEXTURE_USAGE_STORAGE_BIT;
  641. } else {
  642. tf.usage_bits |= RD::TEXTURE_USAGE_COLOR_ATTACHMENT_BIT;
  643. }
  644. rb->normal_roughness_buffer = RD::get_singleton()->texture_create(tf, RD::TextureView());
  645. if (rb->msaa == RS::VIEWPORT_MSAA_DISABLED) {
  646. Vector<RID> fb;
  647. fb.push_back(rb->depth);
  648. fb.push_back(rb->normal_roughness_buffer);
  649. rb->depth_normal_roughness_fb = RD::get_singleton()->framebuffer_create(fb);
  650. } else {
  651. tf.usage_bits = RD::TEXTURE_USAGE_COLOR_ATTACHMENT_BIT | RD::TEXTURE_USAGE_CAN_COPY_FROM_BIT | RD::TEXTURE_USAGE_SAMPLING_BIT;
  652. tf.samples = rb->texture_samples;
  653. rb->normal_roughness_buffer_msaa = RD::get_singleton()->texture_create(tf, RD::TextureView());
  654. Vector<RID> fb;
  655. fb.push_back(rb->depth_msaa);
  656. fb.push_back(rb->normal_roughness_buffer_msaa);
  657. rb->depth_normal_roughness_fb = RD::get_singleton()->framebuffer_create(fb);
  658. }
  659. _render_buffers_clear_uniform_set(rb);
  660. }
  661. RendererSceneRenderRD::RenderBufferData *RendererSceneRenderForward::_create_render_buffer_data() {
  662. return memnew(RenderBufferDataForward);
  663. }
  664. bool RendererSceneRenderForward::free(RID p_rid) {
  665. if (RendererSceneRenderRD::free(p_rid)) {
  666. return true;
  667. }
  668. return false;
  669. }
  670. void RendererSceneRenderForward::_fill_instances(RenderList::Element **p_elements, int p_element_count, bool p_for_depth, bool p_has_sdfgi, bool p_has_opaque_gi) {
  671. uint32_t lightmap_captures_used = 0;
  672. for (int i = 0; i < p_element_count; i++) {
  673. const RenderList::Element *e = p_elements[i];
  674. InstanceData &id = scene_state.instances[i];
  675. bool store_transform = true;
  676. id.flags = 0;
  677. id.mask = e->instance->layer_mask;
  678. id.instance_uniforms_ofs = e->instance->instance_allocated_shader_parameters_offset >= 0 ? e->instance->instance_allocated_shader_parameters_offset : 0;
  679. if (e->instance->base_type == RS::INSTANCE_MULTIMESH) {
  680. id.flags |= INSTANCE_DATA_FLAG_MULTIMESH;
  681. uint32_t stride;
  682. if (storage->multimesh_get_transform_format(e->instance->base) == RS::MULTIMESH_TRANSFORM_2D) {
  683. id.flags |= INSTANCE_DATA_FLAG_MULTIMESH_FORMAT_2D;
  684. stride = 2;
  685. } else {
  686. stride = 3;
  687. }
  688. if (storage->multimesh_uses_colors(e->instance->base)) {
  689. id.flags |= INSTANCE_DATA_FLAG_MULTIMESH_HAS_COLOR;
  690. stride += 1;
  691. }
  692. if (storage->multimesh_uses_custom_data(e->instance->base)) {
  693. id.flags |= INSTANCE_DATA_FLAG_MULTIMESH_HAS_CUSTOM_DATA;
  694. stride += 1;
  695. }
  696. id.flags |= (stride << INSTANCE_DATA_FLAGS_MULTIMESH_STRIDE_SHIFT);
  697. } else if (e->instance->base_type == RS::INSTANCE_PARTICLES) {
  698. id.flags |= INSTANCE_DATA_FLAG_MULTIMESH;
  699. uint32_t stride;
  700. if (false) { // 2D particles
  701. id.flags |= INSTANCE_DATA_FLAG_MULTIMESH_FORMAT_2D;
  702. stride = 2;
  703. } else {
  704. stride = 3;
  705. }
  706. id.flags |= INSTANCE_DATA_FLAG_MULTIMESH_HAS_COLOR;
  707. stride += 1;
  708. id.flags |= INSTANCE_DATA_FLAG_MULTIMESH_HAS_CUSTOM_DATA;
  709. stride += 1;
  710. id.flags |= (stride << INSTANCE_DATA_FLAGS_MULTIMESH_STRIDE_SHIFT);
  711. if (!storage->particles_is_using_local_coords(e->instance->base)) {
  712. store_transform = false;
  713. }
  714. } else if (e->instance->base_type == RS::INSTANCE_MESH) {
  715. if (e->instance->skeleton.is_valid()) {
  716. id.flags |= INSTANCE_DATA_FLAG_SKELETON;
  717. }
  718. }
  719. if (store_transform) {
  720. RendererStorageRD::store_transform(e->instance->transform, id.transform);
  721. RendererStorageRD::store_transform(Transform(e->instance->transform.basis.inverse().transposed()), id.normal_transform);
  722. } else {
  723. RendererStorageRD::store_transform(Transform(), id.transform);
  724. RendererStorageRD::store_transform(Transform(), id.normal_transform);
  725. }
  726. if (p_for_depth) {
  727. id.gi_offset = 0xFFFFFFFF;
  728. continue;
  729. }
  730. if (e->instance->lightmap) {
  731. int32_t lightmap_index = storage->lightmap_get_array_index(e->instance->lightmap->base);
  732. if (lightmap_index >= 0) {
  733. id.gi_offset = lightmap_index;
  734. id.gi_offset |= e->instance->lightmap_slice_index << 12;
  735. id.gi_offset |= e->instance->lightmap_cull_index << 20;
  736. id.lightmap_uv_scale[0] = e->instance->lightmap_uv_scale.position.x;
  737. id.lightmap_uv_scale[1] = e->instance->lightmap_uv_scale.position.y;
  738. id.lightmap_uv_scale[2] = e->instance->lightmap_uv_scale.size.width;
  739. id.lightmap_uv_scale[3] = e->instance->lightmap_uv_scale.size.height;
  740. id.flags |= INSTANCE_DATA_FLAG_USE_LIGHTMAP;
  741. if (storage->lightmap_uses_spherical_harmonics(e->instance->lightmap->base)) {
  742. id.flags |= INSTANCE_DATA_FLAG_USE_SH_LIGHTMAP;
  743. }
  744. } else {
  745. id.gi_offset = 0xFFFFFFFF;
  746. }
  747. } else if (!e->instance->lightmap_sh.empty()) {
  748. if (lightmap_captures_used < scene_state.max_lightmap_captures) {
  749. const Color *src_capture = e->instance->lightmap_sh.ptr();
  750. LightmapCaptureData &lcd = scene_state.lightmap_captures[lightmap_captures_used];
  751. for (int j = 0; j < 9; j++) {
  752. lcd.sh[j * 4 + 0] = src_capture[j].r;
  753. lcd.sh[j * 4 + 1] = src_capture[j].g;
  754. lcd.sh[j * 4 + 2] = src_capture[j].b;
  755. lcd.sh[j * 4 + 3] = src_capture[j].a;
  756. }
  757. id.flags |= INSTANCE_DATA_FLAG_USE_LIGHTMAP_CAPTURE;
  758. id.gi_offset = lightmap_captures_used;
  759. lightmap_captures_used++;
  760. }
  761. } else {
  762. if (p_has_opaque_gi) {
  763. id.flags |= INSTANCE_DATA_FLAG_USE_GI_BUFFERS;
  764. }
  765. if (!low_end && !e->instance->gi_probe_instances.empty()) {
  766. uint32_t written = 0;
  767. for (int j = 0; j < e->instance->gi_probe_instances.size(); j++) {
  768. RID probe = e->instance->gi_probe_instances[j];
  769. uint32_t index = gi_probe_instance_get_render_index(probe);
  770. if (written == 0) {
  771. id.gi_offset = index;
  772. id.flags |= INSTANCE_DATA_FLAG_USE_GIPROBE;
  773. written = 1;
  774. } else {
  775. id.gi_offset = index << 16;
  776. written = 2;
  777. break;
  778. }
  779. }
  780. if (written == 0) {
  781. id.gi_offset = 0xFFFFFFFF;
  782. } else if (written == 1) {
  783. id.gi_offset |= 0xFFFF0000;
  784. }
  785. } else {
  786. if (p_has_sdfgi && (e->instance->baked_light || e->instance->dynamic_gi)) {
  787. id.flags |= INSTANCE_DATA_FLAG_USE_SDFGI;
  788. }
  789. id.gi_offset = 0xFFFFFFFF;
  790. }
  791. }
  792. }
  793. RD::get_singleton()->buffer_update(scene_state.instance_buffer, 0, sizeof(InstanceData) * p_element_count, scene_state.instances, true);
  794. if (lightmap_captures_used) {
  795. RD::get_singleton()->buffer_update(scene_state.lightmap_capture_buffer, 0, sizeof(LightmapCaptureData) * lightmap_captures_used, scene_state.lightmap_captures, true);
  796. }
  797. }
  798. /// RENDERING ///
  799. void RendererSceneRenderForward::_render_list(RenderingDevice::DrawListID p_draw_list, RenderingDevice::FramebufferFormatID p_framebuffer_Format, RenderList::Element **p_elements, int p_element_count, bool p_reverse_cull, PassMode p_pass_mode, bool p_no_gi, RID p_render_pass_uniform_set, bool p_force_wireframe, const Vector2 &p_uv_offset) {
  800. RD::DrawListID draw_list = p_draw_list;
  801. RD::FramebufferFormatID framebuffer_format = p_framebuffer_Format;
  802. //global scope bindings
  803. RD::get_singleton()->draw_list_bind_uniform_set(draw_list, render_base_uniform_set, SCENE_UNIFORM_SET);
  804. RD::get_singleton()->draw_list_bind_uniform_set(draw_list, p_render_pass_uniform_set, RENDER_PASS_UNIFORM_SET);
  805. RD::get_singleton()->draw_list_bind_uniform_set(draw_list, default_vec4_xform_uniform_set, TRANSFORMS_UNIFORM_SET);
  806. MaterialData *prev_material = nullptr;
  807. RID prev_vertex_array_rd;
  808. RID prev_index_array_rd;
  809. RID prev_pipeline_rd;
  810. RID prev_xforms_uniform_set;
  811. PushConstant push_constant;
  812. zeromem(&push_constant, sizeof(PushConstant));
  813. push_constant.bake_uv2_offset[0] = p_uv_offset.x;
  814. push_constant.bake_uv2_offset[1] = p_uv_offset.y;
  815. for (int i = 0; i < p_element_count; i++) {
  816. const RenderList::Element *e = p_elements[i];
  817. MaterialData *material = e->material;
  818. ShaderData *shader = material->shader_data;
  819. RID xforms_uniform_set;
  820. //find cull variant
  821. ShaderData::CullVariant cull_variant;
  822. if (p_pass_mode == PASS_MODE_DEPTH_MATERIAL || p_pass_mode == PASS_MODE_SDF || ((p_pass_mode == PASS_MODE_SHADOW || p_pass_mode == PASS_MODE_SHADOW_DP) && e->instance->cast_shadows == RS::SHADOW_CASTING_SETTING_DOUBLE_SIDED)) {
  823. cull_variant = ShaderData::CULL_VARIANT_DOUBLE_SIDED;
  824. } else {
  825. bool mirror = e->instance->mirror;
  826. if (p_reverse_cull) {
  827. mirror = !mirror;
  828. }
  829. cull_variant = mirror ? ShaderData::CULL_VARIANT_REVERSED : ShaderData::CULL_VARIANT_NORMAL;
  830. }
  831. //find primitive and vertex format
  832. RS::PrimitiveType primitive;
  833. switch (e->instance->base_type) {
  834. case RS::INSTANCE_MESH: {
  835. primitive = storage->mesh_surface_get_primitive(e->instance->base, e->surface_index);
  836. if (e->instance->skeleton.is_valid()) {
  837. xforms_uniform_set = storage->skeleton_get_3d_uniform_set(e->instance->skeleton, default_shader_rd, TRANSFORMS_UNIFORM_SET);
  838. }
  839. } break;
  840. case RS::INSTANCE_MULTIMESH: {
  841. RID mesh = storage->multimesh_get_mesh(e->instance->base);
  842. ERR_CONTINUE(!mesh.is_valid()); //should be a bug
  843. primitive = storage->mesh_surface_get_primitive(mesh, e->surface_index);
  844. xforms_uniform_set = storage->multimesh_get_3d_uniform_set(e->instance->base, default_shader_rd, TRANSFORMS_UNIFORM_SET);
  845. } break;
  846. case RS::INSTANCE_IMMEDIATE: {
  847. ERR_CONTINUE(true); //should be a bug
  848. } break;
  849. case RS::INSTANCE_PARTICLES: {
  850. RID mesh = storage->particles_get_draw_pass_mesh(e->instance->base, e->surface_index >> 16);
  851. ERR_CONTINUE(!mesh.is_valid()); //should be a bug
  852. primitive = storage->mesh_surface_get_primitive(mesh, e->surface_index & 0xFFFF);
  853. xforms_uniform_set = storage->particles_get_instance_buffer_uniform_set(e->instance->base, default_shader_rd, TRANSFORMS_UNIFORM_SET);
  854. } break;
  855. default: {
  856. ERR_CONTINUE(true); //should be a bug
  857. }
  858. }
  859. ShaderVersion shader_version = SHADER_VERSION_MAX; // Assigned to silence wrong -Wmaybe-initialized.
  860. switch (p_pass_mode) {
  861. case PASS_MODE_COLOR:
  862. case PASS_MODE_COLOR_TRANSPARENT: {
  863. if (e->uses_lightmap) {
  864. shader_version = SHADER_VERSION_LIGHTMAP_COLOR_PASS;
  865. } else if (e->uses_forward_gi) {
  866. shader_version = SHADER_VERSION_COLOR_PASS_WITH_FORWARD_GI;
  867. } else {
  868. shader_version = SHADER_VERSION_COLOR_PASS;
  869. }
  870. } break;
  871. case PASS_MODE_COLOR_SPECULAR: {
  872. if (e->uses_lightmap) {
  873. shader_version = SHADER_VERSION_LIGHTMAP_COLOR_PASS_WITH_SEPARATE_SPECULAR;
  874. } else {
  875. shader_version = SHADER_VERSION_COLOR_PASS_WITH_SEPARATE_SPECULAR;
  876. }
  877. } break;
  878. case PASS_MODE_SHADOW:
  879. case PASS_MODE_DEPTH: {
  880. shader_version = SHADER_VERSION_DEPTH_PASS;
  881. } break;
  882. case PASS_MODE_SHADOW_DP: {
  883. shader_version = SHADER_VERSION_DEPTH_PASS_DP;
  884. } break;
  885. case PASS_MODE_DEPTH_NORMAL_ROUGHNESS: {
  886. shader_version = SHADER_VERSION_DEPTH_PASS_WITH_NORMAL_AND_ROUGHNESS;
  887. } break;
  888. case PASS_MODE_DEPTH_NORMAL_ROUGHNESS_GIPROBE: {
  889. shader_version = SHADER_VERSION_DEPTH_PASS_WITH_NORMAL_AND_ROUGHNESS_AND_GIPROBE;
  890. } break;
  891. case PASS_MODE_DEPTH_MATERIAL: {
  892. shader_version = SHADER_VERSION_DEPTH_PASS_WITH_MATERIAL;
  893. } break;
  894. case PASS_MODE_SDF: {
  895. shader_version = SHADER_VERSION_DEPTH_PASS_WITH_SDF;
  896. } break;
  897. }
  898. PipelineCacheRD *pipeline = nullptr;
  899. pipeline = &shader->pipelines[cull_variant][primitive][shader_version];
  900. RD::VertexFormatID vertex_format = -1;
  901. RID vertex_array_rd;
  902. RID index_array_rd;
  903. switch (e->instance->base_type) {
  904. case RS::INSTANCE_MESH: {
  905. storage->mesh_surface_get_arrays_and_format(e->instance->base, e->surface_index, pipeline->get_vertex_input_mask(), vertex_array_rd, index_array_rd, vertex_format);
  906. } break;
  907. case RS::INSTANCE_MULTIMESH: {
  908. RID mesh = storage->multimesh_get_mesh(e->instance->base);
  909. ERR_CONTINUE(!mesh.is_valid()); //should be a bug
  910. storage->mesh_surface_get_arrays_and_format(mesh, e->surface_index, pipeline->get_vertex_input_mask(), vertex_array_rd, index_array_rd, vertex_format);
  911. } break;
  912. case RS::INSTANCE_IMMEDIATE: {
  913. ERR_CONTINUE(true); //should be a bug
  914. } break;
  915. case RS::INSTANCE_PARTICLES: {
  916. RID mesh = storage->particles_get_draw_pass_mesh(e->instance->base, e->surface_index >> 16);
  917. ERR_CONTINUE(!mesh.is_valid()); //should be a bug
  918. storage->mesh_surface_get_arrays_and_format(mesh, e->surface_index & 0xFFFF, pipeline->get_vertex_input_mask(), vertex_array_rd, index_array_rd, vertex_format);
  919. } break;
  920. default: {
  921. ERR_CONTINUE(true); //should be a bug
  922. }
  923. }
  924. if (prev_vertex_array_rd != vertex_array_rd) {
  925. RD::get_singleton()->draw_list_bind_vertex_array(draw_list, vertex_array_rd);
  926. prev_vertex_array_rd = vertex_array_rd;
  927. }
  928. if (prev_index_array_rd != index_array_rd) {
  929. if (index_array_rd.is_valid()) {
  930. RD::get_singleton()->draw_list_bind_index_array(draw_list, index_array_rd);
  931. }
  932. prev_index_array_rd = index_array_rd;
  933. }
  934. RID pipeline_rd = pipeline->get_render_pipeline(vertex_format, framebuffer_format, p_force_wireframe);
  935. if (pipeline_rd != prev_pipeline_rd) {
  936. // checking with prev shader does not make so much sense, as
  937. // the pipeline may still be different.
  938. RD::get_singleton()->draw_list_bind_render_pipeline(draw_list, pipeline_rd);
  939. prev_pipeline_rd = pipeline_rd;
  940. }
  941. if (xforms_uniform_set.is_valid() && prev_xforms_uniform_set != xforms_uniform_set) {
  942. RD::get_singleton()->draw_list_bind_uniform_set(draw_list, xforms_uniform_set, TRANSFORMS_UNIFORM_SET);
  943. prev_xforms_uniform_set = xforms_uniform_set;
  944. }
  945. if (material != prev_material) {
  946. //update uniform set
  947. if (material->uniform_set.is_valid()) {
  948. RD::get_singleton()->draw_list_bind_uniform_set(draw_list, material->uniform_set, MATERIAL_UNIFORM_SET);
  949. }
  950. prev_material = material;
  951. }
  952. push_constant.index = i;
  953. RD::get_singleton()->draw_list_set_push_constant(draw_list, &push_constant, sizeof(PushConstant));
  954. switch (e->instance->base_type) {
  955. case RS::INSTANCE_MESH: {
  956. RD::get_singleton()->draw_list_draw(draw_list, index_array_rd.is_valid());
  957. } break;
  958. case RS::INSTANCE_MULTIMESH: {
  959. uint32_t instances = storage->multimesh_get_instances_to_draw(e->instance->base);
  960. RD::get_singleton()->draw_list_draw(draw_list, index_array_rd.is_valid(), instances);
  961. } break;
  962. case RS::INSTANCE_IMMEDIATE: {
  963. } break;
  964. case RS::INSTANCE_PARTICLES: {
  965. uint32_t instances = storage->particles_get_amount(e->instance->base);
  966. RD::get_singleton()->draw_list_draw(draw_list, index_array_rd.is_valid(), instances);
  967. } break;
  968. default: {
  969. ERR_CONTINUE(true); //should be a bug
  970. }
  971. }
  972. }
  973. }
  974. void RendererSceneRenderForward::_setup_environment(RID p_environment, RID p_render_buffers, const CameraMatrix &p_cam_projection, const Transform &p_cam_transform, RID p_reflection_probe, bool p_no_fog, const Size2 &p_screen_pixel_size, RID p_shadow_atlas, bool p_flip_y, const Color &p_default_bg_color, float p_znear, float p_zfar, bool p_opaque_render_buffers, bool p_pancake_shadows) {
  975. //CameraMatrix projection = p_cam_projection;
  976. //projection.flip_y(); // Vulkan and modern APIs use Y-Down
  977. CameraMatrix correction;
  978. correction.set_depth_correction(p_flip_y);
  979. CameraMatrix projection = correction * p_cam_projection;
  980. //store camera into ubo
  981. RendererStorageRD::store_camera(projection, scene_state.ubo.projection_matrix);
  982. RendererStorageRD::store_camera(projection.inverse(), scene_state.ubo.inv_projection_matrix);
  983. RendererStorageRD::store_transform(p_cam_transform, scene_state.ubo.camera_matrix);
  984. RendererStorageRD::store_transform(p_cam_transform.affine_inverse(), scene_state.ubo.inv_camera_matrix);
  985. scene_state.ubo.z_far = p_zfar;
  986. scene_state.ubo.z_near = p_znear;
  987. scene_state.ubo.pancake_shadows = p_pancake_shadows;
  988. RendererStorageRD::store_soft_shadow_kernel(directional_penumbra_shadow_kernel_get(), scene_state.ubo.directional_penumbra_shadow_kernel);
  989. RendererStorageRD::store_soft_shadow_kernel(directional_soft_shadow_kernel_get(), scene_state.ubo.directional_soft_shadow_kernel);
  990. RendererStorageRD::store_soft_shadow_kernel(penumbra_shadow_kernel_get(), scene_state.ubo.penumbra_shadow_kernel);
  991. RendererStorageRD::store_soft_shadow_kernel(soft_shadow_kernel_get(), scene_state.ubo.soft_shadow_kernel);
  992. scene_state.ubo.directional_penumbra_shadow_samples = directional_penumbra_shadow_samples_get();
  993. scene_state.ubo.directional_soft_shadow_samples = directional_soft_shadow_samples_get();
  994. scene_state.ubo.penumbra_shadow_samples = penumbra_shadow_samples_get();
  995. scene_state.ubo.soft_shadow_samples = soft_shadow_samples_get();
  996. scene_state.ubo.screen_pixel_size[0] = p_screen_pixel_size.x;
  997. scene_state.ubo.screen_pixel_size[1] = p_screen_pixel_size.y;
  998. if (p_shadow_atlas.is_valid()) {
  999. Vector2 sas = shadow_atlas_get_size(p_shadow_atlas);
  1000. scene_state.ubo.shadow_atlas_pixel_size[0] = 1.0 / sas.x;
  1001. scene_state.ubo.shadow_atlas_pixel_size[1] = 1.0 / sas.y;
  1002. }
  1003. {
  1004. Vector2 dss = directional_shadow_get_size();
  1005. scene_state.ubo.directional_shadow_pixel_size[0] = 1.0 / dss.x;
  1006. scene_state.ubo.directional_shadow_pixel_size[1] = 1.0 / dss.y;
  1007. }
  1008. //time global variables
  1009. scene_state.ubo.time = time;
  1010. scene_state.ubo.gi_upscale_for_msaa = false;
  1011. scene_state.ubo.volumetric_fog_enabled = false;
  1012. scene_state.ubo.fog_enabled = false;
  1013. if (p_render_buffers.is_valid()) {
  1014. RenderBufferDataForward *render_buffers = (RenderBufferDataForward *)render_buffers_get_data(p_render_buffers);
  1015. if (render_buffers->msaa != RS::VIEWPORT_MSAA_DISABLED) {
  1016. scene_state.ubo.gi_upscale_for_msaa = true;
  1017. }
  1018. if (render_buffers_has_volumetric_fog(p_render_buffers)) {
  1019. scene_state.ubo.volumetric_fog_enabled = true;
  1020. float fog_end = render_buffers_get_volumetric_fog_end(p_render_buffers);
  1021. if (fog_end > 0.0) {
  1022. scene_state.ubo.volumetric_fog_inv_length = 1.0 / fog_end;
  1023. } else {
  1024. scene_state.ubo.volumetric_fog_inv_length = 1.0;
  1025. }
  1026. float fog_detail_spread = render_buffers_get_volumetric_fog_detail_spread(p_render_buffers); //reverse lookup
  1027. if (fog_detail_spread > 0.0) {
  1028. scene_state.ubo.volumetric_fog_detail_spread = 1.0 / fog_detail_spread;
  1029. } else {
  1030. scene_state.ubo.volumetric_fog_detail_spread = 1.0;
  1031. }
  1032. }
  1033. }
  1034. #if 0
  1035. if (p_render_buffers.is_valid() && render_buffers_is_sdfgi_enabled(p_render_buffers)) {
  1036. scene_state.ubo.sdfgi_cascade_count = render_buffers_get_sdfgi_cascade_count(p_render_buffers);
  1037. scene_state.ubo.sdfgi_probe_axis_size = render_buffers_get_sdfgi_cascade_probe_count(p_render_buffers);
  1038. scene_state.ubo.sdfgi_cascade_probe_size[0] = scene_state.ubo.sdfgi_probe_axis_size - 1; //float version for performance
  1039. scene_state.ubo.sdfgi_cascade_probe_size[1] = scene_state.ubo.sdfgi_probe_axis_size - 1;
  1040. scene_state.ubo.sdfgi_cascade_probe_size[2] = scene_state.ubo.sdfgi_probe_axis_size - 1;
  1041. float csize = render_buffers_get_sdfgi_cascade_size(p_render_buffers);
  1042. scene_state.ubo.sdfgi_probe_to_uvw = 1.0 / float(scene_state.ubo.sdfgi_cascade_probe_size[0]);
  1043. float occ_bias = 0.0;
  1044. scene_state.ubo.sdfgi_occlusion_bias = occ_bias / csize;
  1045. scene_state.ubo.sdfgi_use_occlusion = render_buffers_is_sdfgi_using_occlusion(p_render_buffers);
  1046. scene_state.ubo.sdfgi_energy = render_buffers_get_sdfgi_energy(p_render_buffers);
  1047. float cascade_voxel_size = (csize / scene_state.ubo.sdfgi_cascade_probe_size[0]);
  1048. float occlusion_clamp = (cascade_voxel_size - 0.5) / cascade_voxel_size;
  1049. scene_state.ubo.sdfgi_occlusion_clamp[0] = occlusion_clamp;
  1050. scene_state.ubo.sdfgi_occlusion_clamp[1] = occlusion_clamp;
  1051. scene_state.ubo.sdfgi_occlusion_clamp[2] = occlusion_clamp;
  1052. scene_state.ubo.sdfgi_normal_bias = (render_buffers_get_sdfgi_normal_bias(p_render_buffers) / csize) * scene_state.ubo.sdfgi_cascade_probe_size[0];
  1053. //vec2 tex_pixel_size = 1.0 / vec2(ivec2( (OCT_SIZE+2) * params.probe_axis_size * params.probe_axis_size, (OCT_SIZE+2) * params.probe_axis_size ) );
  1054. //vec3 probe_uv_offset = (ivec3(OCT_SIZE+2,OCT_SIZE+2,(OCT_SIZE+2) * params.probe_axis_size)) * tex_pixel_size.xyx;
  1055. uint32_t oct_size = sdfgi_get_lightprobe_octahedron_size();
  1056. scene_state.ubo.sdfgi_lightprobe_tex_pixel_size[0] = 1.0 / ((oct_size + 2) * scene_state.ubo.sdfgi_probe_axis_size * scene_state.ubo.sdfgi_probe_axis_size);
  1057. scene_state.ubo.sdfgi_lightprobe_tex_pixel_size[1] = 1.0 / ((oct_size + 2) * scene_state.ubo.sdfgi_probe_axis_size);
  1058. scene_state.ubo.sdfgi_lightprobe_tex_pixel_size[2] = 1.0;
  1059. scene_state.ubo.sdfgi_probe_uv_offset[0] = float(oct_size + 2) * scene_state.ubo.sdfgi_lightprobe_tex_pixel_size[0];
  1060. scene_state.ubo.sdfgi_probe_uv_offset[1] = float(oct_size + 2) * scene_state.ubo.sdfgi_lightprobe_tex_pixel_size[1];
  1061. scene_state.ubo.sdfgi_probe_uv_offset[2] = float((oct_size + 2) * scene_state.ubo.sdfgi_probe_axis_size) * scene_state.ubo.sdfgi_lightprobe_tex_pixel_size[0];
  1062. scene_state.ubo.sdfgi_occlusion_renormalize[0] = 0.5;
  1063. scene_state.ubo.sdfgi_occlusion_renormalize[1] = 1.0;
  1064. scene_state.ubo.sdfgi_occlusion_renormalize[2] = 1.0 / float(scene_state.ubo.sdfgi_cascade_count);
  1065. for (uint32_t i = 0; i < scene_state.ubo.sdfgi_cascade_count; i++) {
  1066. SceneState::UBO::SDFGICascade &c = scene_state.ubo.sdfgi_cascades[i];
  1067. Vector3 pos = render_buffers_get_sdfgi_cascade_offset(p_render_buffers, i);
  1068. pos -= p_cam_transform.origin; //make pos local to camera, to reduce numerical error
  1069. c.position[0] = pos.x;
  1070. c.position[1] = pos.y;
  1071. c.position[2] = pos.z;
  1072. c.to_probe = 1.0 / render_buffers_get_sdfgi_cascade_probe_size(p_render_buffers, i);
  1073. Vector3i probe_ofs = render_buffers_get_sdfgi_cascade_probe_offset(p_render_buffers, i);
  1074. c.probe_world_offset[0] = probe_ofs.x;
  1075. c.probe_world_offset[1] = probe_ofs.y;
  1076. c.probe_world_offset[2] = probe_ofs.z;
  1077. }
  1078. }
  1079. #endif
  1080. if (get_debug_draw_mode() == RS::VIEWPORT_DEBUG_DRAW_UNSHADED) {
  1081. scene_state.ubo.use_ambient_light = true;
  1082. scene_state.ubo.ambient_light_color_energy[0] = 1;
  1083. scene_state.ubo.ambient_light_color_energy[1] = 1;
  1084. scene_state.ubo.ambient_light_color_energy[2] = 1;
  1085. scene_state.ubo.ambient_light_color_energy[3] = 1.0;
  1086. scene_state.ubo.use_ambient_cubemap = false;
  1087. scene_state.ubo.use_reflection_cubemap = false;
  1088. scene_state.ubo.ssao_enabled = false;
  1089. } else if (is_environment(p_environment)) {
  1090. RS::EnvironmentBG env_bg = environment_get_background(p_environment);
  1091. RS::EnvironmentAmbientSource ambient_src = environment_get_ambient_source(p_environment);
  1092. float bg_energy = environment_get_bg_energy(p_environment);
  1093. scene_state.ubo.ambient_light_color_energy[3] = bg_energy;
  1094. scene_state.ubo.ambient_color_sky_mix = environment_get_ambient_sky_contribution(p_environment);
  1095. //ambient
  1096. if (ambient_src == RS::ENV_AMBIENT_SOURCE_BG && (env_bg == RS::ENV_BG_CLEAR_COLOR || env_bg == RS::ENV_BG_COLOR)) {
  1097. Color color = env_bg == RS::ENV_BG_CLEAR_COLOR ? p_default_bg_color : environment_get_bg_color(p_environment);
  1098. color = color.to_linear();
  1099. scene_state.ubo.ambient_light_color_energy[0] = color.r * bg_energy;
  1100. scene_state.ubo.ambient_light_color_energy[1] = color.g * bg_energy;
  1101. scene_state.ubo.ambient_light_color_energy[2] = color.b * bg_energy;
  1102. scene_state.ubo.use_ambient_light = true;
  1103. scene_state.ubo.use_ambient_cubemap = false;
  1104. } else {
  1105. float energy = environment_get_ambient_light_energy(p_environment);
  1106. Color color = environment_get_ambient_light_color(p_environment);
  1107. color = color.to_linear();
  1108. scene_state.ubo.ambient_light_color_energy[0] = color.r * energy;
  1109. scene_state.ubo.ambient_light_color_energy[1] = color.g * energy;
  1110. scene_state.ubo.ambient_light_color_energy[2] = color.b * energy;
  1111. Basis sky_transform = environment_get_sky_orientation(p_environment);
  1112. sky_transform = sky_transform.inverse() * p_cam_transform.basis;
  1113. RendererStorageRD::store_transform_3x3(sky_transform, scene_state.ubo.radiance_inverse_xform);
  1114. scene_state.ubo.use_ambient_cubemap = (ambient_src == RS::ENV_AMBIENT_SOURCE_BG && env_bg == RS::ENV_BG_SKY) || ambient_src == RS::ENV_AMBIENT_SOURCE_SKY;
  1115. scene_state.ubo.use_ambient_light = scene_state.ubo.use_ambient_cubemap || ambient_src == RS::ENV_AMBIENT_SOURCE_COLOR;
  1116. }
  1117. //specular
  1118. RS::EnvironmentReflectionSource ref_src = environment_get_reflection_source(p_environment);
  1119. if ((ref_src == RS::ENV_REFLECTION_SOURCE_BG && env_bg == RS::ENV_BG_SKY) || ref_src == RS::ENV_REFLECTION_SOURCE_SKY) {
  1120. scene_state.ubo.use_reflection_cubemap = true;
  1121. } else {
  1122. scene_state.ubo.use_reflection_cubemap = false;
  1123. }
  1124. scene_state.ubo.ssao_enabled = p_opaque_render_buffers && environment_is_ssao_enabled(p_environment);
  1125. scene_state.ubo.ssao_ao_affect = environment_get_ssao_ao_affect(p_environment);
  1126. scene_state.ubo.ssao_light_affect = environment_get_ssao_light_affect(p_environment);
  1127. Color ao_color = environment_get_ao_color(p_environment).to_linear();
  1128. scene_state.ubo.ao_color[0] = ao_color.r;
  1129. scene_state.ubo.ao_color[1] = ao_color.g;
  1130. scene_state.ubo.ao_color[2] = ao_color.b;
  1131. scene_state.ubo.ao_color[3] = ao_color.a;
  1132. scene_state.ubo.fog_enabled = environment_is_fog_enabled(p_environment);
  1133. scene_state.ubo.fog_density = environment_get_fog_density(p_environment);
  1134. scene_state.ubo.fog_height = environment_get_fog_height(p_environment);
  1135. scene_state.ubo.fog_height_density = environment_get_fog_height_density(p_environment);
  1136. if (scene_state.ubo.fog_height_density >= 0.0001) {
  1137. scene_state.ubo.fog_height_density = 1.0 / scene_state.ubo.fog_height_density;
  1138. }
  1139. scene_state.ubo.fog_aerial_perspective = environment_get_fog_aerial_perspective(p_environment);
  1140. Color fog_color = environment_get_fog_light_color(p_environment).to_linear();
  1141. float fog_energy = environment_get_fog_light_energy(p_environment);
  1142. scene_state.ubo.fog_light_color[0] = fog_color.r * fog_energy;
  1143. scene_state.ubo.fog_light_color[1] = fog_color.g * fog_energy;
  1144. scene_state.ubo.fog_light_color[2] = fog_color.b * fog_energy;
  1145. scene_state.ubo.fog_sun_scatter = environment_get_fog_sun_scatter(p_environment);
  1146. } else {
  1147. if (p_reflection_probe.is_valid() && storage->reflection_probe_is_interior(reflection_probe_instance_get_probe(p_reflection_probe))) {
  1148. scene_state.ubo.use_ambient_light = false;
  1149. } else {
  1150. scene_state.ubo.use_ambient_light = true;
  1151. Color clear_color = p_default_bg_color;
  1152. clear_color = clear_color.to_linear();
  1153. scene_state.ubo.ambient_light_color_energy[0] = clear_color.r;
  1154. scene_state.ubo.ambient_light_color_energy[1] = clear_color.g;
  1155. scene_state.ubo.ambient_light_color_energy[2] = clear_color.b;
  1156. scene_state.ubo.ambient_light_color_energy[3] = 1.0;
  1157. }
  1158. scene_state.ubo.use_ambient_cubemap = false;
  1159. scene_state.ubo.use_reflection_cubemap = false;
  1160. scene_state.ubo.ssao_enabled = false;
  1161. }
  1162. scene_state.ubo.roughness_limiter_enabled = p_opaque_render_buffers && screen_space_roughness_limiter_is_active();
  1163. scene_state.ubo.roughness_limiter_amount = screen_space_roughness_limiter_get_amount();
  1164. scene_state.ubo.roughness_limiter_limit = screen_space_roughness_limiter_get_limit();
  1165. RD::get_singleton()->buffer_update(scene_state.uniform_buffer, 0, sizeof(SceneState::UBO), &scene_state.ubo, true);
  1166. }
  1167. void RendererSceneRenderForward::_add_geometry(InstanceBase *p_instance, uint32_t p_surface, RID p_material, PassMode p_pass_mode, uint32_t p_geometry_index, bool p_using_sdfgi) {
  1168. RID m_src;
  1169. m_src = p_instance->material_override.is_valid() ? p_instance->material_override : p_material;
  1170. if (unlikely(get_debug_draw_mode() != RS::VIEWPORT_DEBUG_DRAW_DISABLED)) {
  1171. if (get_debug_draw_mode() == RS::VIEWPORT_DEBUG_DRAW_OVERDRAW) {
  1172. m_src = overdraw_material;
  1173. } else if (get_debug_draw_mode() == RS::VIEWPORT_DEBUG_DRAW_LIGHTING) {
  1174. m_src = default_material;
  1175. }
  1176. }
  1177. MaterialData *material = nullptr;
  1178. if (m_src.is_valid()) {
  1179. material = (MaterialData *)storage->material_get_data(m_src, RendererStorageRD::SHADER_TYPE_3D);
  1180. if (!material || !material->shader_data->valid) {
  1181. material = nullptr;
  1182. }
  1183. }
  1184. if (!material) {
  1185. material = (MaterialData *)storage->material_get_data(default_material, RendererStorageRD::SHADER_TYPE_3D);
  1186. m_src = default_material;
  1187. }
  1188. ERR_FAIL_COND(!material);
  1189. _add_geometry_with_material(p_instance, p_surface, material, m_src, p_pass_mode, p_geometry_index, p_using_sdfgi);
  1190. while (material->next_pass.is_valid()) {
  1191. material = (MaterialData *)storage->material_get_data(material->next_pass, RendererStorageRD::SHADER_TYPE_3D);
  1192. if (!material || !material->shader_data->valid) {
  1193. break;
  1194. }
  1195. _add_geometry_with_material(p_instance, p_surface, material, material->next_pass, p_pass_mode, p_geometry_index, p_using_sdfgi);
  1196. }
  1197. }
  1198. void RendererSceneRenderForward::_add_geometry_with_material(InstanceBase *p_instance, uint32_t p_surface, MaterialData *p_material, RID p_material_rid, PassMode p_pass_mode, uint32_t p_geometry_index, bool p_using_sdfgi) {
  1199. bool has_read_screen_alpha = p_material->shader_data->uses_screen_texture || p_material->shader_data->uses_depth_texture || p_material->shader_data->uses_normal_texture;
  1200. bool has_base_alpha = (p_material->shader_data->uses_alpha || has_read_screen_alpha);
  1201. bool has_blend_alpha = p_material->shader_data->uses_blend_alpha;
  1202. bool has_alpha = has_base_alpha || has_blend_alpha;
  1203. if (p_material->shader_data->uses_sss) {
  1204. scene_state.used_sss = true;
  1205. }
  1206. if (p_material->shader_data->uses_screen_texture) {
  1207. scene_state.used_screen_texture = true;
  1208. }
  1209. if (p_material->shader_data->uses_depth_texture) {
  1210. scene_state.used_depth_texture = true;
  1211. }
  1212. if (p_material->shader_data->uses_normal_texture) {
  1213. scene_state.used_normal_texture = true;
  1214. }
  1215. if (p_pass_mode != PASS_MODE_COLOR && p_pass_mode != PASS_MODE_COLOR_SPECULAR) {
  1216. if (has_blend_alpha || has_read_screen_alpha || (has_base_alpha && !p_material->shader_data->uses_depth_pre_pass) || p_material->shader_data->depth_draw == ShaderData::DEPTH_DRAW_DISABLED || p_material->shader_data->depth_test == ShaderData::DEPTH_TEST_DISABLED || p_instance->cast_shadows == RS::SHADOW_CASTING_SETTING_OFF) {
  1217. //conditions in which no depth pass should be processed
  1218. return;
  1219. }
  1220. if ((p_pass_mode != PASS_MODE_DEPTH_MATERIAL && p_pass_mode != PASS_MODE_SDF) && !p_material->shader_data->writes_modelview_or_projection && !p_material->shader_data->uses_vertex && !p_material->shader_data->uses_discard && !p_material->shader_data->uses_depth_pre_pass) {
  1221. //shader does not use discard and does not write a vertex position, use generic material
  1222. if (p_pass_mode == PASS_MODE_SHADOW || p_pass_mode == PASS_MODE_DEPTH) {
  1223. p_material = (MaterialData *)storage->material_get_data(default_material, RendererStorageRD::SHADER_TYPE_3D);
  1224. } else if ((p_pass_mode == PASS_MODE_DEPTH_NORMAL_ROUGHNESS || p_pass_mode == PASS_MODE_DEPTH_NORMAL_ROUGHNESS_GIPROBE) && !p_material->shader_data->uses_normal && !p_material->shader_data->uses_roughness) {
  1225. p_material = (MaterialData *)storage->material_get_data(default_material, RendererStorageRD::SHADER_TYPE_3D);
  1226. }
  1227. }
  1228. has_alpha = false;
  1229. }
  1230. has_alpha = has_alpha || p_material->shader_data->depth_test == ShaderData::DEPTH_TEST_DISABLED;
  1231. RenderList::Element *e = has_alpha ? render_list.add_alpha_element() : render_list.add_element();
  1232. if (!e) {
  1233. return;
  1234. }
  1235. e->instance = p_instance;
  1236. e->material = p_material;
  1237. e->surface_index = p_surface;
  1238. e->sort_key = 0;
  1239. if (e->material->last_pass != render_pass) {
  1240. if (!RD::get_singleton()->uniform_set_is_valid(e->material->uniform_set)) {
  1241. //uniform set no longer valid, probably a texture changed
  1242. storage->material_force_update_textures(p_material_rid, RendererStorageRD::SHADER_TYPE_3D);
  1243. }
  1244. e->material->last_pass = render_pass;
  1245. e->material->index = scene_state.current_material_index++;
  1246. if (e->material->shader_data->last_pass != render_pass) {
  1247. e->material->shader_data->last_pass = scene_state.current_material_index++;
  1248. e->material->shader_data->index = scene_state.current_shader_index++;
  1249. }
  1250. }
  1251. e->geometry_index = p_geometry_index;
  1252. e->material_index = e->material->index;
  1253. e->uses_instancing = e->instance->base_type == RS::INSTANCE_MULTIMESH;
  1254. e->uses_lightmap = e->instance->lightmap != nullptr || !e->instance->lightmap_sh.empty();
  1255. e->uses_forward_gi = has_alpha && (e->instance->gi_probe_instances.size() || p_using_sdfgi);
  1256. e->shader_index = e->shader_index;
  1257. e->depth_layer = e->instance->depth_layer;
  1258. e->priority = p_material->priority;
  1259. if (p_material->shader_data->uses_time) {
  1260. RenderingServerDefault::redraw_request();
  1261. }
  1262. }
  1263. void RendererSceneRenderForward::_fill_render_list(InstanceBase **p_cull_result, int p_cull_count, PassMode p_pass_mode, bool p_using_sdfgi) {
  1264. scene_state.current_shader_index = 0;
  1265. scene_state.current_material_index = 0;
  1266. scene_state.used_sss = false;
  1267. scene_state.used_screen_texture = false;
  1268. scene_state.used_normal_texture = false;
  1269. scene_state.used_depth_texture = false;
  1270. uint32_t geometry_index = 0;
  1271. //fill list
  1272. for (int i = 0; i < p_cull_count; i++) {
  1273. InstanceBase *inst = p_cull_result[i];
  1274. //add geometry for drawing
  1275. switch (inst->base_type) {
  1276. case RS::INSTANCE_MESH: {
  1277. const RID *materials = nullptr;
  1278. uint32_t surface_count;
  1279. materials = storage->mesh_get_surface_count_and_materials(inst->base, surface_count);
  1280. if (!materials) {
  1281. continue; //nothing to do
  1282. }
  1283. const RID *inst_materials = inst->materials.ptr();
  1284. for (uint32_t j = 0; j < surface_count; j++) {
  1285. RID material = inst_materials[j].is_valid() ? inst_materials[j] : materials[j];
  1286. uint32_t surface_index = storage->mesh_surface_get_render_pass_index(inst->base, j, render_pass, &geometry_index);
  1287. _add_geometry(inst, j, material, p_pass_mode, surface_index, p_using_sdfgi);
  1288. }
  1289. //mesh->last_pass=frame;
  1290. } break;
  1291. case RS::INSTANCE_MULTIMESH: {
  1292. if (storage->multimesh_get_instances_to_draw(inst->base) == 0) {
  1293. //not visible, 0 instances
  1294. continue;
  1295. }
  1296. RID mesh = storage->multimesh_get_mesh(inst->base);
  1297. if (!mesh.is_valid()) {
  1298. continue;
  1299. }
  1300. const RID *materials = nullptr;
  1301. uint32_t surface_count;
  1302. materials = storage->mesh_get_surface_count_and_materials(mesh, surface_count);
  1303. if (!materials) {
  1304. continue; //nothing to do
  1305. }
  1306. for (uint32_t j = 0; j < surface_count; j++) {
  1307. uint32_t surface_index = storage->mesh_surface_get_multimesh_render_pass_index(mesh, j, render_pass, &geometry_index);
  1308. _add_geometry(inst, j, materials[j], p_pass_mode, surface_index, p_using_sdfgi);
  1309. }
  1310. } break;
  1311. #if 0
  1312. case RS::INSTANCE_IMMEDIATE: {
  1313. RasterizerStorageGLES3::Immediate *immediate = storage->immediate_owner.getornull(inst->base);
  1314. ERR_CONTINUE(!immediate);
  1315. _add_geometry(immediate, inst, nullptr, -1, p_depth_pass, p_shadow_pass);
  1316. } break;
  1317. #endif
  1318. case RS::INSTANCE_PARTICLES: {
  1319. int draw_passes = storage->particles_get_draw_passes(inst->base);
  1320. for (int j = 0; j < draw_passes; j++) {
  1321. RID mesh = storage->particles_get_draw_pass_mesh(inst->base, j);
  1322. if (!mesh.is_valid())
  1323. continue;
  1324. const RID *materials = nullptr;
  1325. uint32_t surface_count;
  1326. materials = storage->mesh_get_surface_count_and_materials(mesh, surface_count);
  1327. if (!materials) {
  1328. continue; //nothing to do
  1329. }
  1330. for (uint32_t k = 0; k < surface_count; k++) {
  1331. uint32_t surface_index = storage->mesh_surface_get_particles_render_pass_index(mesh, j, render_pass, &geometry_index);
  1332. _add_geometry(inst, (j << 16) | k, materials[j], p_pass_mode, surface_index, p_using_sdfgi);
  1333. }
  1334. }
  1335. } break;
  1336. default: {
  1337. }
  1338. }
  1339. }
  1340. }
  1341. void RendererSceneRenderForward::_setup_lightmaps(InstanceBase **p_lightmap_cull_result, int p_lightmap_cull_count, const Transform &p_cam_transform) {
  1342. uint32_t lightmaps_used = 0;
  1343. for (int i = 0; i < p_lightmap_cull_count; i++) {
  1344. if (i >= (int)scene_state.max_lightmaps) {
  1345. break;
  1346. }
  1347. InstanceBase *lm = p_lightmap_cull_result[i];
  1348. Basis to_lm = lm->transform.basis.inverse() * p_cam_transform.basis;
  1349. to_lm = to_lm.inverse().transposed(); //will transform normals
  1350. RendererStorageRD::store_transform_3x3(to_lm, scene_state.lightmaps[i].normal_xform);
  1351. lm->lightmap_cull_index = i;
  1352. lightmaps_used++;
  1353. }
  1354. if (lightmaps_used > 0) {
  1355. RD::get_singleton()->buffer_update(scene_state.lightmap_buffer, 0, sizeof(LightmapData) * lightmaps_used, scene_state.lightmaps, true);
  1356. }
  1357. }
  1358. void RendererSceneRenderForward::_render_scene(RID p_render_buffer, const Transform &p_cam_transform, const CameraMatrix &p_cam_projection, bool p_cam_ortogonal, InstanceBase **p_cull_result, int p_cull_count, int p_directional_light_count, RID *p_gi_probe_cull_result, int p_gi_probe_cull_count, InstanceBase **p_lightmap_cull_result, int p_lightmap_cull_count, RID p_environment, RID p_camera_effects, RID p_shadow_atlas, RID p_reflection_atlas, RID p_reflection_probe, int p_reflection_probe_pass, const Color &p_default_bg_color) {
  1359. RenderBufferDataForward *render_buffer = nullptr;
  1360. if (p_render_buffer.is_valid()) {
  1361. render_buffer = (RenderBufferDataForward *)render_buffers_get_data(p_render_buffer);
  1362. }
  1363. //first of all, make a new render pass
  1364. render_pass++;
  1365. //fill up ubo
  1366. RENDER_TIMESTAMP("Setup 3D Scene");
  1367. if (p_reflection_probe.is_valid()) {
  1368. scene_state.ubo.reflection_multiplier = 0.0;
  1369. } else {
  1370. scene_state.ubo.reflection_multiplier = 1.0;
  1371. }
  1372. //scene_state.ubo.subsurface_scatter_width = subsurface_scatter_size;
  1373. Vector2 vp_he = p_cam_projection.get_viewport_half_extents();
  1374. scene_state.ubo.viewport_size[0] = vp_he.x;
  1375. scene_state.ubo.viewport_size[1] = vp_he.y;
  1376. scene_state.ubo.directional_light_count = p_directional_light_count;
  1377. Size2 screen_pixel_size;
  1378. Size2i screen_size;
  1379. RID opaque_framebuffer;
  1380. RID opaque_specular_framebuffer;
  1381. RID depth_framebuffer;
  1382. RID alpha_framebuffer;
  1383. PassMode depth_pass_mode = PASS_MODE_DEPTH;
  1384. Vector<Color> depth_pass_clear;
  1385. bool using_separate_specular = false;
  1386. bool using_ssr = false;
  1387. bool using_sdfgi = false;
  1388. bool using_giprobe = false;
  1389. if (render_buffer) {
  1390. screen_pixel_size.width = 1.0 / render_buffer->width;
  1391. screen_pixel_size.height = 1.0 / render_buffer->height;
  1392. screen_size.x = render_buffer->width;
  1393. screen_size.y = render_buffer->height;
  1394. opaque_framebuffer = render_buffer->color_fb;
  1395. if (!low_end && p_gi_probe_cull_count > 0) {
  1396. using_giprobe = true;
  1397. render_buffer->ensure_gi();
  1398. }
  1399. if (!p_environment.is_valid() && using_giprobe) {
  1400. depth_pass_mode = PASS_MODE_DEPTH_NORMAL_ROUGHNESS_GIPROBE;
  1401. } else if (p_environment.is_valid() && (environment_is_ssr_enabled(p_environment) || environment_is_sdfgi_enabled(p_environment) || using_giprobe)) {
  1402. if (environment_is_sdfgi_enabled(p_environment)) {
  1403. depth_pass_mode = using_giprobe ? PASS_MODE_DEPTH_NORMAL_ROUGHNESS_GIPROBE : PASS_MODE_DEPTH_NORMAL_ROUGHNESS; // also giprobe
  1404. using_sdfgi = true;
  1405. render_buffer->ensure_gi();
  1406. } else {
  1407. depth_pass_mode = using_giprobe ? PASS_MODE_DEPTH_NORMAL_ROUGHNESS_GIPROBE : PASS_MODE_DEPTH_NORMAL_ROUGHNESS;
  1408. }
  1409. if (environment_is_ssr_enabled(p_environment)) {
  1410. render_buffer->ensure_specular();
  1411. using_separate_specular = true;
  1412. using_ssr = true;
  1413. opaque_specular_framebuffer = render_buffer->color_specular_fb;
  1414. }
  1415. } else if (p_environment.is_valid() && (environment_is_ssao_enabled(p_environment) || get_debug_draw_mode() == RS::VIEWPORT_DEBUG_DRAW_NORMAL_BUFFER)) {
  1416. depth_pass_mode = PASS_MODE_DEPTH_NORMAL_ROUGHNESS;
  1417. }
  1418. switch (depth_pass_mode) {
  1419. case PASS_MODE_DEPTH: {
  1420. depth_framebuffer = render_buffer->depth_fb;
  1421. } break;
  1422. case PASS_MODE_DEPTH_NORMAL_ROUGHNESS: {
  1423. _allocate_normal_roughness_texture(render_buffer);
  1424. depth_framebuffer = render_buffer->depth_normal_roughness_fb;
  1425. depth_pass_clear.push_back(Color(0.5, 0.5, 0.5, 0));
  1426. } break;
  1427. case PASS_MODE_DEPTH_NORMAL_ROUGHNESS_GIPROBE: {
  1428. _allocate_normal_roughness_texture(render_buffer);
  1429. render_buffer->ensure_giprobe();
  1430. depth_framebuffer = render_buffer->depth_normal_roughness_giprobe_fb;
  1431. depth_pass_clear.push_back(Color(0.5, 0.5, 0.5, 0));
  1432. depth_pass_clear.push_back(Color(0, 0, 0, 0));
  1433. } break;
  1434. default: {
  1435. };
  1436. }
  1437. alpha_framebuffer = opaque_framebuffer;
  1438. } else if (p_reflection_probe.is_valid()) {
  1439. uint32_t resolution = reflection_probe_instance_get_resolution(p_reflection_probe);
  1440. screen_pixel_size.width = 1.0 / resolution;
  1441. screen_pixel_size.height = 1.0 / resolution;
  1442. screen_size.x = resolution;
  1443. screen_size.y = resolution;
  1444. opaque_framebuffer = reflection_probe_instance_get_framebuffer(p_reflection_probe, p_reflection_probe_pass);
  1445. depth_framebuffer = reflection_probe_instance_get_depth_framebuffer(p_reflection_probe, p_reflection_probe_pass);
  1446. alpha_framebuffer = opaque_framebuffer;
  1447. if (storage->reflection_probe_is_interior(reflection_probe_instance_get_probe(p_reflection_probe))) {
  1448. p_environment = RID(); //no environment on interiors
  1449. }
  1450. } else {
  1451. ERR_FAIL(); //bug?
  1452. }
  1453. _setup_lightmaps(p_lightmap_cull_result, p_lightmap_cull_count, p_cam_transform);
  1454. _setup_environment(p_environment, p_render_buffer, p_cam_projection, p_cam_transform, p_reflection_probe, p_reflection_probe.is_valid(), screen_pixel_size, p_shadow_atlas, !p_reflection_probe.is_valid(), p_default_bg_color, p_cam_projection.get_z_near(), p_cam_projection.get_z_far(), false);
  1455. _update_render_base_uniform_set(); //may have changed due to the above (light buffer enlarged, as an example)
  1456. render_list.clear();
  1457. _fill_render_list(p_cull_result, p_cull_count, PASS_MODE_COLOR, using_sdfgi);
  1458. bool using_sss = !low_end && render_buffer && scene_state.used_sss && sub_surface_scattering_get_quality() != RS::SUB_SURFACE_SCATTERING_QUALITY_DISABLED;
  1459. if (using_sss) {
  1460. using_separate_specular = true;
  1461. render_buffer->ensure_specular();
  1462. using_separate_specular = true;
  1463. opaque_specular_framebuffer = render_buffer->color_specular_fb;
  1464. }
  1465. RID radiance_texture;
  1466. bool draw_sky = false;
  1467. bool draw_sky_fog_only = false;
  1468. Color clear_color;
  1469. bool keep_color = false;
  1470. if (get_debug_draw_mode() == RS::VIEWPORT_DEBUG_DRAW_OVERDRAW) {
  1471. clear_color = Color(0, 0, 0, 1); //in overdraw mode, BG should always be black
  1472. } else if (is_environment(p_environment)) {
  1473. RS::EnvironmentBG bg_mode = environment_get_background(p_environment);
  1474. float bg_energy = environment_get_bg_energy(p_environment);
  1475. switch (bg_mode) {
  1476. case RS::ENV_BG_CLEAR_COLOR: {
  1477. clear_color = p_default_bg_color;
  1478. clear_color.r *= bg_energy;
  1479. clear_color.g *= bg_energy;
  1480. clear_color.b *= bg_energy;
  1481. if (render_buffers_has_volumetric_fog(p_render_buffer) || environment_is_fog_enabled(p_environment)) {
  1482. draw_sky_fog_only = true;
  1483. storage->material_set_param(sky_scene_state.fog_material, "clear_color", Variant(clear_color.to_linear()));
  1484. }
  1485. } break;
  1486. case RS::ENV_BG_COLOR: {
  1487. clear_color = environment_get_bg_color(p_environment);
  1488. clear_color.r *= bg_energy;
  1489. clear_color.g *= bg_energy;
  1490. clear_color.b *= bg_energy;
  1491. if (render_buffers_has_volumetric_fog(p_render_buffer) || environment_is_fog_enabled(p_environment)) {
  1492. draw_sky_fog_only = true;
  1493. storage->material_set_param(sky_scene_state.fog_material, "clear_color", Variant(clear_color.to_linear()));
  1494. }
  1495. } break;
  1496. case RS::ENV_BG_SKY: {
  1497. draw_sky = true;
  1498. } break;
  1499. case RS::ENV_BG_CANVAS: {
  1500. keep_color = true;
  1501. } break;
  1502. case RS::ENV_BG_KEEP: {
  1503. keep_color = true;
  1504. } break;
  1505. case RS::ENV_BG_CAMERA_FEED: {
  1506. } break;
  1507. default: {
  1508. }
  1509. }
  1510. // setup sky if used for ambient, reflections, or background
  1511. if (draw_sky || draw_sky_fog_only || environment_get_reflection_source(p_environment) == RS::ENV_REFLECTION_SOURCE_SKY || environment_get_ambient_source(p_environment) == RS::ENV_AMBIENT_SOURCE_SKY) {
  1512. RENDER_TIMESTAMP("Setup Sky");
  1513. CameraMatrix projection = p_cam_projection;
  1514. if (p_reflection_probe.is_valid()) {
  1515. CameraMatrix correction;
  1516. correction.set_depth_correction(true);
  1517. projection = correction * p_cam_projection;
  1518. }
  1519. _setup_sky(p_environment, p_render_buffer, projection, p_cam_transform, screen_size);
  1520. RID sky = environment_get_sky(p_environment);
  1521. if (sky.is_valid()) {
  1522. _update_sky(p_environment, projection, p_cam_transform);
  1523. radiance_texture = sky_get_radiance_texture_rd(sky);
  1524. } else {
  1525. // do not try to draw sky if invalid
  1526. draw_sky = false;
  1527. }
  1528. }
  1529. } else {
  1530. clear_color = p_default_bg_color;
  1531. }
  1532. RID rp_uniform_set = _setup_render_pass_uniform_set(p_render_buffer, radiance_texture, p_shadow_atlas, p_reflection_atlas, p_gi_probe_cull_result, p_gi_probe_cull_count);
  1533. render_list.sort_by_key(false);
  1534. _fill_instances(render_list.elements, render_list.element_count, false, false, using_sdfgi || using_giprobe);
  1535. bool debug_giprobes = get_debug_draw_mode() == RS::VIEWPORT_DEBUG_DRAW_GI_PROBE_ALBEDO || get_debug_draw_mode() == RS::VIEWPORT_DEBUG_DRAW_GI_PROBE_LIGHTING || get_debug_draw_mode() == RS::VIEWPORT_DEBUG_DRAW_GI_PROBE_EMISSION;
  1536. bool debug_sdfgi_probes = get_debug_draw_mode() == RS::VIEWPORT_DEBUG_DRAW_SDFGI_PROBES;
  1537. bool depth_pre_pass = !low_end && depth_framebuffer.is_valid();
  1538. bool using_ssao = depth_pre_pass && p_render_buffer.is_valid() && p_environment.is_valid() && environment_is_ssao_enabled(p_environment);
  1539. bool continue_depth = false;
  1540. if (depth_pre_pass) { //depth pre pass
  1541. RENDER_TIMESTAMP("Render Depth Pre-Pass");
  1542. bool finish_depth = using_ssao || using_sdfgi || using_giprobe;
  1543. RD::DrawListID draw_list = RD::get_singleton()->draw_list_begin(depth_framebuffer, RD::INITIAL_ACTION_CLEAR, RD::FINAL_ACTION_READ, RD::INITIAL_ACTION_CLEAR, finish_depth ? RD::FINAL_ACTION_READ : RD::FINAL_ACTION_CONTINUE, depth_pass_clear);
  1544. _render_list(draw_list, RD::get_singleton()->framebuffer_get_format(depth_framebuffer), render_list.elements, render_list.element_count, false, depth_pass_mode, render_buffer == nullptr, rp_uniform_set, get_debug_draw_mode() == RS::VIEWPORT_DEBUG_DRAW_WIREFRAME);
  1545. RD::get_singleton()->draw_list_end();
  1546. if (render_buffer && render_buffer->msaa != RS::VIEWPORT_MSAA_DISABLED) {
  1547. RENDER_TIMESTAMP("Resolve Depth Pre-Pass");
  1548. if (depth_pass_mode == PASS_MODE_DEPTH_NORMAL_ROUGHNESS || depth_pass_mode == PASS_MODE_DEPTH_NORMAL_ROUGHNESS_GIPROBE) {
  1549. static int texture_samples[RS::VIEWPORT_MSAA_MAX] = { 1, 2, 4, 8, 16 };
  1550. storage->get_effects()->resolve_gi(render_buffer->depth_msaa, render_buffer->normal_roughness_buffer_msaa, using_giprobe ? render_buffer->giprobe_buffer_msaa : RID(), render_buffer->depth, render_buffer->normal_roughness_buffer, using_giprobe ? render_buffer->giprobe_buffer : RID(), Vector2i(render_buffer->width, render_buffer->height), texture_samples[render_buffer->msaa]);
  1551. } else if (finish_depth) {
  1552. RD::get_singleton()->texture_resolve_multisample(render_buffer->depth_msaa, render_buffer->depth, true);
  1553. }
  1554. }
  1555. continue_depth = !finish_depth;
  1556. }
  1557. if (using_ssao) {
  1558. _process_ssao(p_render_buffer, p_environment, render_buffer->normal_roughness_buffer, p_cam_projection);
  1559. }
  1560. if (using_sdfgi || using_giprobe) {
  1561. _process_gi(p_render_buffer, render_buffer->normal_roughness_buffer, render_buffer->ambient_buffer, render_buffer->reflection_buffer, render_buffer->giprobe_buffer, p_environment, p_cam_projection, p_cam_transform, p_gi_probe_cull_result, p_gi_probe_cull_count);
  1562. }
  1563. _setup_environment(p_environment, p_render_buffer, p_cam_projection, p_cam_transform, p_reflection_probe, p_reflection_probe.is_valid(), screen_pixel_size, p_shadow_atlas, !p_reflection_probe.is_valid(), p_default_bg_color, p_cam_projection.get_z_near(), p_cam_projection.get_z_far(), p_render_buffer.is_valid());
  1564. RENDER_TIMESTAMP("Render Opaque Pass");
  1565. bool can_continue_color = !scene_state.used_screen_texture && !using_ssr && !using_sss;
  1566. bool can_continue_depth = !scene_state.used_depth_texture && !using_ssr && !using_sss;
  1567. {
  1568. bool will_continue_color = (can_continue_color || draw_sky || draw_sky_fog_only || debug_giprobes || debug_sdfgi_probes);
  1569. bool will_continue_depth = (can_continue_depth || draw_sky || draw_sky_fog_only || debug_giprobes || debug_sdfgi_probes);
  1570. //regular forward for now
  1571. Vector<Color> c;
  1572. if (using_separate_specular) {
  1573. Color cc = clear_color.to_linear();
  1574. cc.a = 0; //subsurf scatter must be 0
  1575. c.push_back(cc);
  1576. c.push_back(Color(0, 0, 0, 0));
  1577. } else {
  1578. c.push_back(clear_color.to_linear());
  1579. }
  1580. RID framebuffer = using_separate_specular ? opaque_specular_framebuffer : opaque_framebuffer;
  1581. RD::DrawListID draw_list = RD::get_singleton()->draw_list_begin(framebuffer, keep_color ? RD::INITIAL_ACTION_KEEP : RD::INITIAL_ACTION_CLEAR, will_continue_color ? RD::FINAL_ACTION_CONTINUE : RD::FINAL_ACTION_READ, depth_pre_pass ? (continue_depth ? RD::INITIAL_ACTION_KEEP : RD::INITIAL_ACTION_CONTINUE) : RD::INITIAL_ACTION_CLEAR, will_continue_depth ? RD::FINAL_ACTION_CONTINUE : RD::FINAL_ACTION_READ, c, 1.0, 0);
  1582. _render_list(draw_list, RD::get_singleton()->framebuffer_get_format(framebuffer), render_list.elements, render_list.element_count, false, using_separate_specular ? PASS_MODE_COLOR_SPECULAR : PASS_MODE_COLOR, render_buffer == nullptr, rp_uniform_set, get_debug_draw_mode() == RS::VIEWPORT_DEBUG_DRAW_WIREFRAME);
  1583. RD::get_singleton()->draw_list_end();
  1584. if (will_continue_color && using_separate_specular) {
  1585. // close the specular framebuffer, as it's no longer used
  1586. draw_list = RD::get_singleton()->draw_list_begin(render_buffer->specular_only_fb, RD::INITIAL_ACTION_CONTINUE, RD::FINAL_ACTION_READ, RD::INITIAL_ACTION_CONTINUE, RD::FINAL_ACTION_CONTINUE);
  1587. RD::get_singleton()->draw_list_end();
  1588. }
  1589. }
  1590. if (debug_giprobes) {
  1591. //debug giprobes
  1592. bool will_continue_color = (can_continue_color || draw_sky || draw_sky_fog_only);
  1593. bool will_continue_depth = (can_continue_depth || draw_sky || draw_sky_fog_only);
  1594. CameraMatrix dc;
  1595. dc.set_depth_correction(true);
  1596. CameraMatrix cm = (dc * p_cam_projection) * CameraMatrix(p_cam_transform.affine_inverse());
  1597. RD::DrawListID draw_list = RD::get_singleton()->draw_list_begin(opaque_framebuffer, RD::INITIAL_ACTION_CONTINUE, will_continue_color ? RD::FINAL_ACTION_CONTINUE : RD::FINAL_ACTION_READ, RD::INITIAL_ACTION_CONTINUE, will_continue_depth ? RD::FINAL_ACTION_CONTINUE : RD::FINAL_ACTION_READ);
  1598. for (int i = 0; i < p_gi_probe_cull_count; i++) {
  1599. _debug_giprobe(p_gi_probe_cull_result[i], draw_list, opaque_framebuffer, cm, get_debug_draw_mode() == RS::VIEWPORT_DEBUG_DRAW_GI_PROBE_LIGHTING, get_debug_draw_mode() == RS::VIEWPORT_DEBUG_DRAW_GI_PROBE_EMISSION, 1.0);
  1600. }
  1601. RD::get_singleton()->draw_list_end();
  1602. }
  1603. if (debug_sdfgi_probes) {
  1604. //debug giprobes
  1605. bool will_continue_color = (can_continue_color || draw_sky || draw_sky_fog_only);
  1606. bool will_continue_depth = (can_continue_depth || draw_sky || draw_sky_fog_only);
  1607. CameraMatrix dc;
  1608. dc.set_depth_correction(true);
  1609. CameraMatrix cm = (dc * p_cam_projection) * CameraMatrix(p_cam_transform.affine_inverse());
  1610. RD::DrawListID draw_list = RD::get_singleton()->draw_list_begin(opaque_framebuffer, RD::INITIAL_ACTION_CONTINUE, will_continue_color ? RD::FINAL_ACTION_CONTINUE : RD::FINAL_ACTION_READ, RD::INITIAL_ACTION_CONTINUE, will_continue_depth ? RD::FINAL_ACTION_CONTINUE : RD::FINAL_ACTION_READ);
  1611. _debug_sdfgi_probes(p_render_buffer, draw_list, opaque_framebuffer, cm);
  1612. RD::get_singleton()->draw_list_end();
  1613. }
  1614. if (draw_sky || draw_sky_fog_only) {
  1615. RENDER_TIMESTAMP("Render Sky");
  1616. CameraMatrix projection = p_cam_projection;
  1617. if (p_reflection_probe.is_valid()) {
  1618. CameraMatrix correction;
  1619. correction.set_depth_correction(true);
  1620. projection = correction * p_cam_projection;
  1621. }
  1622. _draw_sky(can_continue_color, can_continue_depth, opaque_framebuffer, p_environment, projection, p_cam_transform);
  1623. }
  1624. if (render_buffer && !can_continue_color && render_buffer->msaa != RS::VIEWPORT_MSAA_DISABLED) {
  1625. RD::get_singleton()->texture_resolve_multisample(render_buffer->color_msaa, render_buffer->color, true);
  1626. if (using_separate_specular) {
  1627. RD::get_singleton()->texture_resolve_multisample(render_buffer->specular_msaa, render_buffer->specular, true);
  1628. }
  1629. }
  1630. if (render_buffer && !can_continue_depth && render_buffer->msaa != RS::VIEWPORT_MSAA_DISABLED) {
  1631. RD::get_singleton()->texture_resolve_multisample(render_buffer->depth_msaa, render_buffer->depth, true);
  1632. }
  1633. if (using_separate_specular) {
  1634. if (using_sss) {
  1635. RENDER_TIMESTAMP("Sub Surface Scattering");
  1636. _process_sss(p_render_buffer, p_cam_projection);
  1637. }
  1638. if (using_ssr) {
  1639. RENDER_TIMESTAMP("Screen Space Reflection");
  1640. _process_ssr(p_render_buffer, render_buffer->color_fb, render_buffer->normal_roughness_buffer, render_buffer->specular, render_buffer->specular, Color(0, 0, 0, 1), p_environment, p_cam_projection, render_buffer->msaa == RS::VIEWPORT_MSAA_DISABLED);
  1641. } else {
  1642. //just mix specular back
  1643. RENDER_TIMESTAMP("Merge Specular");
  1644. storage->get_effects()->merge_specular(render_buffer->color_fb, render_buffer->specular, render_buffer->msaa == RS::VIEWPORT_MSAA_DISABLED ? RID() : render_buffer->color, RID());
  1645. }
  1646. }
  1647. RENDER_TIMESTAMP("Render Transparent Pass");
  1648. _setup_environment(p_environment, p_render_buffer, p_cam_projection, p_cam_transform, p_reflection_probe, p_reflection_probe.is_valid(), screen_pixel_size, p_shadow_atlas, !p_reflection_probe.is_valid(), p_default_bg_color, p_cam_projection.get_z_near(), p_cam_projection.get_z_far(), false);
  1649. render_list.sort_by_reverse_depth_and_priority(true);
  1650. _fill_instances(&render_list.elements[render_list.max_elements - render_list.alpha_element_count], render_list.alpha_element_count, false, using_sdfgi);
  1651. {
  1652. RD::DrawListID draw_list = RD::get_singleton()->draw_list_begin(alpha_framebuffer, can_continue_color ? RD::INITIAL_ACTION_CONTINUE : RD::INITIAL_ACTION_KEEP, RD::FINAL_ACTION_READ, can_continue_depth ? RD::INITIAL_ACTION_CONTINUE : RD::INITIAL_ACTION_KEEP, RD::FINAL_ACTION_READ);
  1653. _render_list(draw_list, RD::get_singleton()->framebuffer_get_format(alpha_framebuffer), &render_list.elements[render_list.max_elements - render_list.alpha_element_count], render_list.alpha_element_count, false, PASS_MODE_COLOR, render_buffer == nullptr, rp_uniform_set, get_debug_draw_mode() == RS::VIEWPORT_DEBUG_DRAW_WIREFRAME);
  1654. RD::get_singleton()->draw_list_end();
  1655. }
  1656. if (render_buffer && render_buffer->msaa != RS::VIEWPORT_MSAA_DISABLED) {
  1657. RD::get_singleton()->texture_resolve_multisample(render_buffer->color_msaa, render_buffer->color, true);
  1658. }
  1659. }
  1660. void RendererSceneRenderForward::_render_shadow(RID p_framebuffer, InstanceBase **p_cull_result, int p_cull_count, const CameraMatrix &p_projection, const Transform &p_transform, float p_zfar, float p_bias, float p_normal_bias, bool p_use_dp, bool p_use_dp_flip, bool p_use_pancake) {
  1661. RENDER_TIMESTAMP("Setup Rendering Shadow");
  1662. _update_render_base_uniform_set();
  1663. render_pass++;
  1664. scene_state.ubo.dual_paraboloid_side = p_use_dp_flip ? -1 : 1;
  1665. _setup_environment(RID(), RID(), p_projection, p_transform, RID(), true, Vector2(1, 1), RID(), true, Color(), 0, p_zfar, false, p_use_pancake);
  1666. render_list.clear();
  1667. PassMode pass_mode = p_use_dp ? PASS_MODE_SHADOW_DP : PASS_MODE_SHADOW;
  1668. _fill_render_list(p_cull_result, p_cull_count, pass_mode);
  1669. RID rp_uniform_set = _setup_render_pass_uniform_set(RID(), RID(), RID(), RID(), nullptr, 0);
  1670. RENDER_TIMESTAMP("Render Shadow");
  1671. render_list.sort_by_key(false);
  1672. _fill_instances(render_list.elements, render_list.element_count, true);
  1673. {
  1674. //regular forward for now
  1675. RD::DrawListID draw_list = RD::get_singleton()->draw_list_begin(p_framebuffer, RD::INITIAL_ACTION_CLEAR, RD::FINAL_ACTION_READ, RD::INITIAL_ACTION_CLEAR, RD::FINAL_ACTION_READ);
  1676. _render_list(draw_list, RD::get_singleton()->framebuffer_get_format(p_framebuffer), render_list.elements, render_list.element_count, p_use_dp_flip, pass_mode, true, rp_uniform_set);
  1677. RD::get_singleton()->draw_list_end();
  1678. }
  1679. }
  1680. void RendererSceneRenderForward::_render_particle_collider_heightfield(RID p_fb, const Transform &p_cam_transform, const CameraMatrix &p_cam_projection, InstanceBase **p_cull_result, int p_cull_count) {
  1681. RENDER_TIMESTAMP("Setup Render Collider Heightfield");
  1682. _update_render_base_uniform_set();
  1683. render_pass++;
  1684. scene_state.ubo.dual_paraboloid_side = 0;
  1685. _setup_environment(RID(), RID(), p_cam_projection, p_cam_transform, RID(), true, Vector2(1, 1), RID(), true, Color(), 0, p_cam_projection.get_z_far(), false, false);
  1686. render_list.clear();
  1687. PassMode pass_mode = PASS_MODE_SHADOW;
  1688. _fill_render_list(p_cull_result, p_cull_count, pass_mode);
  1689. RID rp_uniform_set = _setup_render_pass_uniform_set(RID(), RID(), RID(), RID(), nullptr, 0);
  1690. RENDER_TIMESTAMP("Render Collider Heightield");
  1691. render_list.sort_by_key(false);
  1692. _fill_instances(render_list.elements, render_list.element_count, true);
  1693. {
  1694. //regular forward for now
  1695. RD::DrawListID draw_list = RD::get_singleton()->draw_list_begin(p_fb, RD::INITIAL_ACTION_CLEAR, RD::FINAL_ACTION_READ, RD::INITIAL_ACTION_CLEAR, RD::FINAL_ACTION_READ);
  1696. _render_list(draw_list, RD::get_singleton()->framebuffer_get_format(p_fb), render_list.elements, render_list.element_count, false, pass_mode, true, rp_uniform_set);
  1697. RD::get_singleton()->draw_list_end();
  1698. }
  1699. }
  1700. void RendererSceneRenderForward::_render_material(const Transform &p_cam_transform, const CameraMatrix &p_cam_projection, bool p_cam_ortogonal, InstanceBase **p_cull_result, int p_cull_count, RID p_framebuffer, const Rect2i &p_region) {
  1701. RENDER_TIMESTAMP("Setup Rendering Material");
  1702. _update_render_base_uniform_set();
  1703. render_pass++;
  1704. scene_state.ubo.dual_paraboloid_side = 0;
  1705. scene_state.ubo.material_uv2_mode = true;
  1706. _setup_environment(RID(), RID(), p_cam_projection, p_cam_transform, RID(), true, Vector2(1, 1), RID(), false, Color(), 0, 0);
  1707. render_list.clear();
  1708. PassMode pass_mode = PASS_MODE_DEPTH_MATERIAL;
  1709. _fill_render_list(p_cull_result, p_cull_count, pass_mode);
  1710. RID rp_uniform_set = _setup_render_pass_uniform_set(RID(), RID(), RID(), RID(), nullptr, 0);
  1711. RENDER_TIMESTAMP("Render Material");
  1712. render_list.sort_by_key(false);
  1713. _fill_instances(render_list.elements, render_list.element_count, true);
  1714. {
  1715. //regular forward for now
  1716. Vector<Color> clear;
  1717. clear.push_back(Color(0, 0, 0, 0));
  1718. clear.push_back(Color(0, 0, 0, 0));
  1719. clear.push_back(Color(0, 0, 0, 0));
  1720. clear.push_back(Color(0, 0, 0, 0));
  1721. clear.push_back(Color(0, 0, 0, 0));
  1722. RD::DrawListID draw_list = RD::get_singleton()->draw_list_begin(p_framebuffer, RD::INITIAL_ACTION_CLEAR, RD::FINAL_ACTION_READ, RD::INITIAL_ACTION_CLEAR, RD::FINAL_ACTION_READ, clear, 1.0, 0, p_region);
  1723. _render_list(draw_list, RD::get_singleton()->framebuffer_get_format(p_framebuffer), render_list.elements, render_list.element_count, true, pass_mode, true, rp_uniform_set);
  1724. RD::get_singleton()->draw_list_end();
  1725. }
  1726. }
  1727. void RendererSceneRenderForward::_render_uv2(InstanceBase **p_cull_result, int p_cull_count, RID p_framebuffer, const Rect2i &p_region) {
  1728. RENDER_TIMESTAMP("Setup Rendering UV2");
  1729. _update_render_base_uniform_set();
  1730. render_pass++;
  1731. scene_state.ubo.dual_paraboloid_side = 0;
  1732. scene_state.ubo.material_uv2_mode = true;
  1733. _setup_environment(RID(), RID(), CameraMatrix(), Transform(), RID(), true, Vector2(1, 1), RID(), false, Color(), 0, 0);
  1734. render_list.clear();
  1735. PassMode pass_mode = PASS_MODE_DEPTH_MATERIAL;
  1736. _fill_render_list(p_cull_result, p_cull_count, pass_mode);
  1737. RID rp_uniform_set = _setup_render_pass_uniform_set(RID(), RID(), RID(), RID(), nullptr, 0);
  1738. RENDER_TIMESTAMP("Render Material");
  1739. render_list.sort_by_key(false);
  1740. _fill_instances(render_list.elements, render_list.element_count, true);
  1741. {
  1742. //regular forward for now
  1743. Vector<Color> clear;
  1744. clear.push_back(Color(0, 0, 0, 0));
  1745. clear.push_back(Color(0, 0, 0, 0));
  1746. clear.push_back(Color(0, 0, 0, 0));
  1747. clear.push_back(Color(0, 0, 0, 0));
  1748. clear.push_back(Color(0, 0, 0, 0));
  1749. RD::DrawListID draw_list = RD::get_singleton()->draw_list_begin(p_framebuffer, RD::INITIAL_ACTION_CLEAR, RD::FINAL_ACTION_READ, RD::INITIAL_ACTION_CLEAR, RD::FINAL_ACTION_READ, clear, 1.0, 0, p_region);
  1750. const int uv_offset_count = 9;
  1751. static const Vector2 uv_offsets[uv_offset_count] = {
  1752. Vector2(-1, 1),
  1753. Vector2(1, 1),
  1754. Vector2(1, -1),
  1755. Vector2(-1, -1),
  1756. Vector2(-1, 0),
  1757. Vector2(1, 0),
  1758. Vector2(0, -1),
  1759. Vector2(0, 1),
  1760. Vector2(0, 0),
  1761. };
  1762. for (int i = 0; i < uv_offset_count; i++) {
  1763. Vector2 ofs = uv_offsets[i];
  1764. ofs.x /= p_region.size.width;
  1765. ofs.y /= p_region.size.height;
  1766. _render_list(draw_list, RD::get_singleton()->framebuffer_get_format(p_framebuffer), render_list.elements, render_list.element_count, true, pass_mode, true, rp_uniform_set, true, ofs); //first wireframe, for pseudo conservative
  1767. }
  1768. _render_list(draw_list, RD::get_singleton()->framebuffer_get_format(p_framebuffer), render_list.elements, render_list.element_count, true, pass_mode, true, rp_uniform_set, false); //second regular triangles
  1769. RD::get_singleton()->draw_list_end();
  1770. }
  1771. }
  1772. void RendererSceneRenderForward::_render_sdfgi(RID p_render_buffers, const Vector3i &p_from, const Vector3i &p_size, const AABB &p_bounds, InstanceBase **p_cull_result, int p_cull_count, const RID &p_albedo_texture, const RID &p_emission_texture, const RID &p_emission_aniso_texture, const RID &p_geom_facing_texture) {
  1773. RENDER_TIMESTAMP("Render SDFGI");
  1774. _update_render_base_uniform_set();
  1775. RenderBufferDataForward *render_buffer = (RenderBufferDataForward *)render_buffers_get_data(p_render_buffers);
  1776. ERR_FAIL_COND(!render_buffer);
  1777. render_pass++;
  1778. render_list.clear();
  1779. PassMode pass_mode = PASS_MODE_SDF;
  1780. _fill_render_list(p_cull_result, p_cull_count, pass_mode);
  1781. render_list.sort_by_key(false);
  1782. _fill_instances(render_list.elements, render_list.element_count, true);
  1783. RID rp_uniform_set = _setup_sdfgi_render_pass_uniform_set(p_albedo_texture, p_emission_texture, p_emission_aniso_texture, p_geom_facing_texture);
  1784. Vector3 half_extents = p_bounds.size * 0.5;
  1785. Vector3 center = p_bounds.position + half_extents;
  1786. Vector<RID> sbs;
  1787. sbs.push_back(p_albedo_texture);
  1788. sbs.push_back(p_emission_texture);
  1789. sbs.push_back(p_emission_aniso_texture);
  1790. sbs.push_back(p_geom_facing_texture);
  1791. //print_line("re-render " + p_from + " - " + p_size + " bounds " + p_bounds);
  1792. for (int i = 0; i < 3; i++) {
  1793. scene_state.ubo.sdf_offset[i] = p_from[i];
  1794. scene_state.ubo.sdf_size[i] = p_size[i];
  1795. }
  1796. for (int i = 0; i < 3; i++) {
  1797. Vector3 axis;
  1798. axis[i] = 1.0;
  1799. Vector3 up, right;
  1800. int right_axis = (i + 1) % 3;
  1801. int up_axis = (i + 2) % 3;
  1802. up[up_axis] = 1.0;
  1803. right[right_axis] = 1.0;
  1804. Size2i fb_size;
  1805. fb_size.x = p_size[right_axis];
  1806. fb_size.y = p_size[up_axis];
  1807. Transform cam_xform;
  1808. cam_xform.origin = center + axis * half_extents;
  1809. cam_xform.basis.set_axis(0, right);
  1810. cam_xform.basis.set_axis(1, up);
  1811. cam_xform.basis.set_axis(2, axis);
  1812. //print_line("pass: " + itos(i) + " xform " + cam_xform);
  1813. float h_size = half_extents[right_axis];
  1814. float v_size = half_extents[up_axis];
  1815. float d_size = half_extents[i] * 2.0;
  1816. CameraMatrix camera_proj;
  1817. camera_proj.set_orthogonal(-h_size, h_size, -v_size, v_size, 0, d_size);
  1818. //print_line("pass: " + itos(i) + " cam hsize: " + rtos(h_size) + " vsize: " + rtos(v_size) + " dsize " + rtos(d_size));
  1819. Transform to_bounds;
  1820. to_bounds.origin = p_bounds.position;
  1821. to_bounds.basis.scale(p_bounds.size);
  1822. RendererStorageRD::store_transform(to_bounds.affine_inverse() * cam_xform, scene_state.ubo.sdf_to_bounds);
  1823. _setup_environment(RID(), RID(), camera_proj, cam_xform, RID(), true, Vector2(1, 1), RID(), false, Color(), 0, 0);
  1824. Map<Size2i, RID>::Element *E = sdfgi_framebuffer_size_cache.find(fb_size);
  1825. if (!E) {
  1826. RID fb = RD::get_singleton()->framebuffer_create_empty(fb_size);
  1827. E = sdfgi_framebuffer_size_cache.insert(fb_size, fb);
  1828. }
  1829. RD::DrawListID draw_list = RD::get_singleton()->draw_list_begin(E->get(), RD::INITIAL_ACTION_DROP, RD::FINAL_ACTION_DISCARD, RD::INITIAL_ACTION_DROP, RD::FINAL_ACTION_DISCARD, Vector<Color>(), 1.0, 0, Rect2(), sbs);
  1830. _render_list(draw_list, RD::get_singleton()->framebuffer_get_format(E->get()), render_list.elements, render_list.element_count, true, pass_mode, true, rp_uniform_set, false); //second regular triangles
  1831. RD::get_singleton()->draw_list_end();
  1832. }
  1833. }
  1834. void RendererSceneRenderForward::_base_uniforms_changed() {
  1835. if (!render_base_uniform_set.is_null() && RD::get_singleton()->uniform_set_is_valid(render_base_uniform_set)) {
  1836. RD::get_singleton()->free(render_base_uniform_set);
  1837. }
  1838. render_base_uniform_set = RID();
  1839. }
  1840. void RendererSceneRenderForward::_update_render_base_uniform_set() {
  1841. if (render_base_uniform_set.is_null() || !RD::get_singleton()->uniform_set_is_valid(render_base_uniform_set) || (lightmap_texture_array_version != storage->lightmap_array_get_version())) {
  1842. if (render_base_uniform_set.is_valid() && RD::get_singleton()->uniform_set_is_valid(render_base_uniform_set)) {
  1843. RD::get_singleton()->free(render_base_uniform_set);
  1844. }
  1845. lightmap_texture_array_version = storage->lightmap_array_get_version();
  1846. Vector<RD::Uniform> uniforms;
  1847. {
  1848. RD::Uniform u;
  1849. u.uniform_type = RD::UNIFORM_TYPE_SAMPLER;
  1850. u.binding = 1;
  1851. u.ids.resize(12);
  1852. RID *ids_ptr = u.ids.ptrw();
  1853. ids_ptr[0] = storage->sampler_rd_get_default(RS::CANVAS_ITEM_TEXTURE_FILTER_NEAREST, RS::CANVAS_ITEM_TEXTURE_REPEAT_DISABLED);
  1854. ids_ptr[1] = storage->sampler_rd_get_default(RS::CANVAS_ITEM_TEXTURE_FILTER_LINEAR, RS::CANVAS_ITEM_TEXTURE_REPEAT_DISABLED);
  1855. ids_ptr[2] = storage->sampler_rd_get_default(RS::CANVAS_ITEM_TEXTURE_FILTER_NEAREST_WITH_MIPMAPS, RS::CANVAS_ITEM_TEXTURE_REPEAT_DISABLED);
  1856. ids_ptr[3] = storage->sampler_rd_get_default(RS::CANVAS_ITEM_TEXTURE_FILTER_LINEAR_WITH_MIPMAPS, RS::CANVAS_ITEM_TEXTURE_REPEAT_DISABLED);
  1857. ids_ptr[4] = storage->sampler_rd_get_default(RS::CANVAS_ITEM_TEXTURE_FILTER_NEAREST_WITH_MIPMAPS_ANISOTROPIC, RS::CANVAS_ITEM_TEXTURE_REPEAT_DISABLED);
  1858. ids_ptr[5] = storage->sampler_rd_get_default(RS::CANVAS_ITEM_TEXTURE_FILTER_LINEAR_WITH_MIPMAPS_ANISOTROPIC, RS::CANVAS_ITEM_TEXTURE_REPEAT_DISABLED);
  1859. ids_ptr[6] = storage->sampler_rd_get_default(RS::CANVAS_ITEM_TEXTURE_FILTER_NEAREST, RS::CANVAS_ITEM_TEXTURE_REPEAT_ENABLED);
  1860. ids_ptr[7] = storage->sampler_rd_get_default(RS::CANVAS_ITEM_TEXTURE_FILTER_LINEAR, RS::CANVAS_ITEM_TEXTURE_REPEAT_ENABLED);
  1861. ids_ptr[8] = storage->sampler_rd_get_default(RS::CANVAS_ITEM_TEXTURE_FILTER_NEAREST_WITH_MIPMAPS, RS::CANVAS_ITEM_TEXTURE_REPEAT_ENABLED);
  1862. ids_ptr[9] = storage->sampler_rd_get_default(RS::CANVAS_ITEM_TEXTURE_FILTER_LINEAR_WITH_MIPMAPS, RS::CANVAS_ITEM_TEXTURE_REPEAT_ENABLED);
  1863. ids_ptr[10] = storage->sampler_rd_get_default(RS::CANVAS_ITEM_TEXTURE_FILTER_NEAREST_WITH_MIPMAPS_ANISOTROPIC, RS::CANVAS_ITEM_TEXTURE_REPEAT_ENABLED);
  1864. ids_ptr[11] = storage->sampler_rd_get_default(RS::CANVAS_ITEM_TEXTURE_FILTER_LINEAR_WITH_MIPMAPS_ANISOTROPIC, RS::CANVAS_ITEM_TEXTURE_REPEAT_ENABLED);
  1865. uniforms.push_back(u);
  1866. }
  1867. {
  1868. RD::Uniform u;
  1869. u.binding = 2;
  1870. u.uniform_type = RD::UNIFORM_TYPE_SAMPLER;
  1871. u.ids.push_back(shadow_sampler);
  1872. uniforms.push_back(u);
  1873. }
  1874. {
  1875. RD::Uniform u;
  1876. u.binding = 3;
  1877. u.uniform_type = RD::UNIFORM_TYPE_UNIFORM_BUFFER;
  1878. u.ids.push_back(scene_state.uniform_buffer);
  1879. uniforms.push_back(u);
  1880. }
  1881. {
  1882. RD::Uniform u;
  1883. u.binding = 4;
  1884. u.uniform_type = RD::UNIFORM_TYPE_STORAGE_BUFFER;
  1885. u.ids.push_back(scene_state.instance_buffer);
  1886. uniforms.push_back(u);
  1887. }
  1888. {
  1889. RD::Uniform u;
  1890. u.binding = 5;
  1891. u.uniform_type = RD::UNIFORM_TYPE_STORAGE_BUFFER;
  1892. u.ids.push_back(get_positional_light_buffer());
  1893. uniforms.push_back(u);
  1894. }
  1895. {
  1896. RD::Uniform u;
  1897. u.binding = 6;
  1898. u.uniform_type = RD::UNIFORM_TYPE_STORAGE_BUFFER;
  1899. u.ids.push_back(get_reflection_probe_buffer());
  1900. uniforms.push_back(u);
  1901. }
  1902. {
  1903. RD::Uniform u;
  1904. u.binding = 7;
  1905. u.uniform_type = RD::UNIFORM_TYPE_UNIFORM_BUFFER;
  1906. u.ids.push_back(get_directional_light_buffer());
  1907. uniforms.push_back(u);
  1908. }
  1909. {
  1910. RD::Uniform u;
  1911. u.binding = 10;
  1912. u.uniform_type = RD::UNIFORM_TYPE_STORAGE_BUFFER;
  1913. u.ids.push_back(scene_state.lightmap_buffer);
  1914. uniforms.push_back(u);
  1915. }
  1916. {
  1917. RD::Uniform u;
  1918. u.binding = 11;
  1919. u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
  1920. u.ids = storage->lightmap_array_get_textures();
  1921. uniforms.push_back(u);
  1922. }
  1923. {
  1924. RD::Uniform u;
  1925. u.binding = 12;
  1926. u.uniform_type = RD::UNIFORM_TYPE_STORAGE_BUFFER;
  1927. u.ids.push_back(scene_state.lightmap_capture_buffer);
  1928. uniforms.push_back(u);
  1929. }
  1930. {
  1931. RD::Uniform u;
  1932. u.binding = 13;
  1933. u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
  1934. RID decal_atlas = storage->decal_atlas_get_texture();
  1935. u.ids.push_back(decal_atlas);
  1936. uniforms.push_back(u);
  1937. }
  1938. {
  1939. RD::Uniform u;
  1940. u.binding = 14;
  1941. u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
  1942. RID decal_atlas = storage->decal_atlas_get_texture_srgb();
  1943. u.ids.push_back(decal_atlas);
  1944. uniforms.push_back(u);
  1945. }
  1946. {
  1947. RD::Uniform u;
  1948. u.binding = 15;
  1949. u.uniform_type = RD::UNIFORM_TYPE_STORAGE_BUFFER;
  1950. u.ids.push_back(get_decal_buffer());
  1951. uniforms.push_back(u);
  1952. }
  1953. {
  1954. RD::Uniform u;
  1955. u.binding = 16;
  1956. u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
  1957. u.ids.push_back(get_cluster_builder_texture());
  1958. uniforms.push_back(u);
  1959. }
  1960. {
  1961. RD::Uniform u;
  1962. u.binding = 17;
  1963. u.uniform_type = RD::UNIFORM_TYPE_STORAGE_BUFFER;
  1964. u.ids.push_back(get_cluster_builder_indices_buffer());
  1965. uniforms.push_back(u);
  1966. }
  1967. {
  1968. RD::Uniform u;
  1969. u.binding = 18;
  1970. u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
  1971. if (directional_shadow_get_texture().is_valid()) {
  1972. u.ids.push_back(directional_shadow_get_texture());
  1973. } else {
  1974. u.ids.push_back(storage->texture_rd_get_default(RendererStorageRD::DEFAULT_RD_TEXTURE_WHITE));
  1975. }
  1976. uniforms.push_back(u);
  1977. }
  1978. {
  1979. RD::Uniform u;
  1980. u.uniform_type = RD::UNIFORM_TYPE_STORAGE_BUFFER;
  1981. u.binding = 19;
  1982. u.ids.push_back(storage->global_variables_get_storage_buffer());
  1983. uniforms.push_back(u);
  1984. }
  1985. if (!low_end) {
  1986. RD::Uniform u;
  1987. u.uniform_type = RD::UNIFORM_TYPE_UNIFORM_BUFFER;
  1988. u.binding = 20;
  1989. u.ids.push_back(sdfgi_get_ubo());
  1990. uniforms.push_back(u);
  1991. }
  1992. render_base_uniform_set = RD::get_singleton()->uniform_set_create(uniforms, default_shader_rd, SCENE_UNIFORM_SET);
  1993. }
  1994. }
  1995. RID RendererSceneRenderForward::_setup_render_pass_uniform_set(RID p_render_buffers, RID p_radiance_texture, RID p_shadow_atlas, RID p_reflection_atlas, RID *p_gi_probe_cull_result, int p_gi_probe_cull_count) {
  1996. if (render_pass_uniform_set.is_valid() && RD::get_singleton()->uniform_set_is_valid(render_pass_uniform_set)) {
  1997. RD::get_singleton()->free(render_pass_uniform_set);
  1998. }
  1999. RenderBufferDataForward *rb = nullptr;
  2000. if (p_render_buffers.is_valid()) {
  2001. rb = (RenderBufferDataForward *)render_buffers_get_data(p_render_buffers);
  2002. }
  2003. //default render buffer and scene state uniform set
  2004. Vector<RD::Uniform> uniforms;
  2005. {
  2006. RID radiance_texture;
  2007. if (p_radiance_texture.is_valid()) {
  2008. radiance_texture = p_radiance_texture;
  2009. } else {
  2010. radiance_texture = storage->texture_rd_get_default(is_using_radiance_cubemap_array() ? RendererStorageRD::DEFAULT_RD_TEXTURE_CUBEMAP_ARRAY_BLACK : RendererStorageRD::DEFAULT_RD_TEXTURE_CUBEMAP_BLACK);
  2011. }
  2012. RD::Uniform u;
  2013. u.binding = 0;
  2014. u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
  2015. u.ids.push_back(radiance_texture);
  2016. uniforms.push_back(u);
  2017. }
  2018. {
  2019. RID ref_texture = p_reflection_atlas.is_valid() ? reflection_atlas_get_texture(p_reflection_atlas) : RID();
  2020. RD::Uniform u;
  2021. u.binding = 1;
  2022. u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
  2023. if (ref_texture.is_valid()) {
  2024. u.ids.push_back(ref_texture);
  2025. } else {
  2026. u.ids.push_back(storage->texture_rd_get_default(RendererStorageRD::DEFAULT_RD_TEXTURE_CUBEMAP_ARRAY_BLACK));
  2027. }
  2028. uniforms.push_back(u);
  2029. }
  2030. {
  2031. RD::Uniform u;
  2032. u.binding = 2;
  2033. u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
  2034. RID texture;
  2035. if (p_shadow_atlas.is_valid()) {
  2036. texture = shadow_atlas_get_texture(p_shadow_atlas);
  2037. }
  2038. if (!texture.is_valid()) {
  2039. texture = storage->texture_rd_get_default(RendererStorageRD::DEFAULT_RD_TEXTURE_WHITE);
  2040. }
  2041. u.ids.push_back(texture);
  2042. uniforms.push_back(u);
  2043. }
  2044. {
  2045. RD::Uniform u;
  2046. u.binding = 3;
  2047. u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
  2048. u.ids.resize(MAX_GI_PROBES);
  2049. RID default_tex = storage->texture_rd_get_default(RendererStorageRD::DEFAULT_RD_TEXTURE_3D_WHITE);
  2050. for (int i = 0; i < MAX_GI_PROBES; i++) {
  2051. if (i < p_gi_probe_cull_count) {
  2052. RID tex = gi_probe_instance_get_texture(p_gi_probe_cull_result[i]);
  2053. if (!tex.is_valid()) {
  2054. tex = default_tex;
  2055. }
  2056. u.ids.write[i] = tex;
  2057. } else {
  2058. u.ids.write[i] = default_tex;
  2059. }
  2060. }
  2061. uniforms.push_back(u);
  2062. }
  2063. {
  2064. RD::Uniform u;
  2065. u.binding = 4;
  2066. u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
  2067. RID texture = false && rb && rb->depth.is_valid() ? rb->depth : storage->texture_rd_get_default(RendererStorageRD::DEFAULT_RD_TEXTURE_WHITE);
  2068. u.ids.push_back(texture);
  2069. uniforms.push_back(u);
  2070. }
  2071. {
  2072. RD::Uniform u;
  2073. u.binding = 5;
  2074. u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
  2075. RID bbt = rb ? render_buffers_get_back_buffer_texture(p_render_buffers) : RID();
  2076. RID texture = bbt.is_valid() ? bbt : storage->texture_rd_get_default(RendererStorageRD::DEFAULT_RD_TEXTURE_BLACK);
  2077. u.ids.push_back(texture);
  2078. uniforms.push_back(u);
  2079. }
  2080. if (!low_end) {
  2081. {
  2082. RD::Uniform u;
  2083. u.binding = 6;
  2084. u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
  2085. RID texture = rb && rb->normal_roughness_buffer.is_valid() ? rb->normal_roughness_buffer : storage->texture_rd_get_default(RendererStorageRD::DEFAULT_RD_TEXTURE_NORMAL);
  2086. u.ids.push_back(texture);
  2087. uniforms.push_back(u);
  2088. }
  2089. {
  2090. RD::Uniform u;
  2091. u.binding = 7;
  2092. u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
  2093. RID aot = rb ? render_buffers_get_ao_texture(p_render_buffers) : RID();
  2094. RID texture = aot.is_valid() ? aot : storage->texture_rd_get_default(RendererStorageRD::DEFAULT_RD_TEXTURE_BLACK);
  2095. u.ids.push_back(texture);
  2096. uniforms.push_back(u);
  2097. }
  2098. {
  2099. RD::Uniform u;
  2100. u.binding = 8;
  2101. u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
  2102. RID texture = rb && rb->ambient_buffer.is_valid() ? rb->ambient_buffer : storage->texture_rd_get_default(RendererStorageRD::DEFAULT_RD_TEXTURE_BLACK);
  2103. u.ids.push_back(texture);
  2104. uniforms.push_back(u);
  2105. }
  2106. {
  2107. RD::Uniform u;
  2108. u.binding = 9;
  2109. u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
  2110. RID texture = rb && rb->reflection_buffer.is_valid() ? rb->reflection_buffer : storage->texture_rd_get_default(RendererStorageRD::DEFAULT_RD_TEXTURE_BLACK);
  2111. u.ids.push_back(texture);
  2112. uniforms.push_back(u);
  2113. }
  2114. {
  2115. RD::Uniform u;
  2116. u.binding = 10;
  2117. u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
  2118. RID t;
  2119. if (rb && render_buffers_is_sdfgi_enabled(p_render_buffers)) {
  2120. t = render_buffers_get_sdfgi_irradiance_probes(p_render_buffers);
  2121. } else {
  2122. t = storage->texture_rd_get_default(RendererStorageRD::DEFAULT_RD_TEXTURE_2D_ARRAY_WHITE);
  2123. }
  2124. u.ids.push_back(t);
  2125. uniforms.push_back(u);
  2126. }
  2127. {
  2128. RD::Uniform u;
  2129. u.binding = 11;
  2130. u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
  2131. if (rb && render_buffers_is_sdfgi_enabled(p_render_buffers)) {
  2132. u.ids.push_back(render_buffers_get_sdfgi_occlusion_texture(p_render_buffers));
  2133. } else {
  2134. u.ids.push_back(storage->texture_rd_get_default(RendererStorageRD::DEFAULT_RD_TEXTURE_3D_WHITE));
  2135. }
  2136. uniforms.push_back(u);
  2137. }
  2138. {
  2139. RD::Uniform u;
  2140. u.binding = 12;
  2141. u.uniform_type = RD::UNIFORM_TYPE_UNIFORM_BUFFER;
  2142. u.ids.push_back(rb ? render_buffers_get_default_gi_probe_buffer() : render_buffers_get_gi_probe_buffer(p_render_buffers));
  2143. uniforms.push_back(u);
  2144. }
  2145. {
  2146. RD::Uniform u;
  2147. u.binding = 13;
  2148. u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
  2149. RID vfog = RID();
  2150. if (rb && render_buffers_has_volumetric_fog(p_render_buffers)) {
  2151. vfog = render_buffers_get_volumetric_fog_texture(p_render_buffers);
  2152. if (vfog.is_null()) {
  2153. vfog = storage->texture_rd_get_default(RendererStorageRD::DEFAULT_RD_TEXTURE_3D_WHITE);
  2154. }
  2155. } else {
  2156. vfog = storage->texture_rd_get_default(RendererStorageRD::DEFAULT_RD_TEXTURE_3D_WHITE);
  2157. }
  2158. u.ids.push_back(vfog);
  2159. uniforms.push_back(u);
  2160. }
  2161. }
  2162. render_pass_uniform_set = RD::get_singleton()->uniform_set_create(uniforms, default_shader_rd, RENDER_PASS_UNIFORM_SET);
  2163. return render_pass_uniform_set;
  2164. }
  2165. RID RendererSceneRenderForward::_setup_sdfgi_render_pass_uniform_set(RID p_albedo_texture, RID p_emission_texture, RID p_emission_aniso_texture, RID p_geom_facing_texture) {
  2166. if (sdfgi_pass_uniform_set.is_valid() && RD::get_singleton()->uniform_set_is_valid(sdfgi_pass_uniform_set)) {
  2167. RD::get_singleton()->free(sdfgi_pass_uniform_set);
  2168. }
  2169. Vector<RD::Uniform> uniforms;
  2170. {
  2171. // No radiance texture.
  2172. RID radiance_texture = storage->texture_rd_get_default(is_using_radiance_cubemap_array() ? RendererStorageRD::DEFAULT_RD_TEXTURE_CUBEMAP_ARRAY_BLACK : RendererStorageRD::DEFAULT_RD_TEXTURE_CUBEMAP_BLACK);
  2173. RD::Uniform u;
  2174. u.binding = 0;
  2175. u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
  2176. u.ids.push_back(radiance_texture);
  2177. uniforms.push_back(u);
  2178. }
  2179. {
  2180. // No reflection atlas.
  2181. RID ref_texture = storage->texture_rd_get_default(RendererStorageRD::DEFAULT_RD_TEXTURE_CUBEMAP_ARRAY_BLACK);
  2182. RD::Uniform u;
  2183. u.binding = 1;
  2184. u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
  2185. u.ids.push_back(ref_texture);
  2186. uniforms.push_back(u);
  2187. }
  2188. {
  2189. // No shadow atlas.
  2190. RD::Uniform u;
  2191. u.binding = 2;
  2192. u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
  2193. RID texture = storage->texture_rd_get_default(RendererStorageRD::DEFAULT_RD_TEXTURE_WHITE);
  2194. u.ids.push_back(texture);
  2195. uniforms.push_back(u);
  2196. }
  2197. {
  2198. // No GIProbes
  2199. RD::Uniform u;
  2200. u.binding = 3;
  2201. u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
  2202. u.ids.resize(MAX_GI_PROBES);
  2203. RID default_tex = storage->texture_rd_get_default(RendererStorageRD::DEFAULT_RD_TEXTURE_3D_WHITE);
  2204. for (int i = 0; i < MAX_GI_PROBES; i++) {
  2205. u.ids.write[i] = default_tex;
  2206. }
  2207. uniforms.push_back(u);
  2208. }
  2209. // actual sdfgi stuff
  2210. {
  2211. RD::Uniform u;
  2212. u.uniform_type = RD::UNIFORM_TYPE_IMAGE;
  2213. u.binding = 4;
  2214. u.ids.push_back(p_albedo_texture);
  2215. uniforms.push_back(u);
  2216. }
  2217. {
  2218. RD::Uniform u;
  2219. u.uniform_type = RD::UNIFORM_TYPE_IMAGE;
  2220. u.binding = 5;
  2221. u.ids.push_back(p_emission_texture);
  2222. uniforms.push_back(u);
  2223. }
  2224. {
  2225. RD::Uniform u;
  2226. u.uniform_type = RD::UNIFORM_TYPE_IMAGE;
  2227. u.binding = 6;
  2228. u.ids.push_back(p_emission_aniso_texture);
  2229. uniforms.push_back(u);
  2230. }
  2231. {
  2232. RD::Uniform u;
  2233. u.uniform_type = RD::UNIFORM_TYPE_IMAGE;
  2234. u.binding = 7;
  2235. u.ids.push_back(p_geom_facing_texture);
  2236. uniforms.push_back(u);
  2237. }
  2238. sdfgi_pass_uniform_set = RD::get_singleton()->uniform_set_create(uniforms, default_shader_rd, RENDER_PASS_UNIFORM_SET);
  2239. return sdfgi_pass_uniform_set;
  2240. }
  2241. void RendererSceneRenderForward::_render_buffers_clear_uniform_set(RenderBufferDataForward *rb) {
  2242. }
  2243. void RendererSceneRenderForward::_render_buffers_uniform_set_changed(RID p_render_buffers) {
  2244. RenderBufferDataForward *rb = (RenderBufferDataForward *)render_buffers_get_data(p_render_buffers);
  2245. _render_buffers_clear_uniform_set(rb);
  2246. }
  2247. RID RendererSceneRenderForward::_render_buffers_get_normal_texture(RID p_render_buffers) {
  2248. RenderBufferDataForward *rb = (RenderBufferDataForward *)render_buffers_get_data(p_render_buffers);
  2249. return rb->normal_roughness_buffer;
  2250. }
  2251. RID RendererSceneRenderForward::_render_buffers_get_ambient_texture(RID p_render_buffers) {
  2252. RenderBufferDataForward *rb = (RenderBufferDataForward *)render_buffers_get_data(p_render_buffers);
  2253. return rb->ambient_buffer;
  2254. }
  2255. RID RendererSceneRenderForward::_render_buffers_get_reflection_texture(RID p_render_buffers) {
  2256. RenderBufferDataForward *rb = (RenderBufferDataForward *)render_buffers_get_data(p_render_buffers);
  2257. return rb->reflection_buffer;
  2258. }
  2259. RendererSceneRenderForward *RendererSceneRenderForward::singleton = nullptr;
  2260. void RendererSceneRenderForward::set_time(double p_time, double p_step) {
  2261. time = p_time;
  2262. RendererSceneRenderRD::set_time(p_time, p_step);
  2263. }
  2264. RendererSceneRenderForward::RendererSceneRenderForward(RendererStorageRD *p_storage) :
  2265. RendererSceneRenderRD(p_storage) {
  2266. singleton = this;
  2267. low_end = is_low_end();
  2268. storage = p_storage;
  2269. /* SCENE SHADER */
  2270. {
  2271. String defines;
  2272. if (low_end) {
  2273. defines += "\n#define LOW_END_MODE \n";
  2274. }
  2275. defines += "\n#define MAX_ROUGHNESS_LOD " + itos(get_roughness_layers() - 1) + ".0\n";
  2276. if (is_using_radiance_cubemap_array()) {
  2277. defines += "\n#define USE_RADIANCE_CUBEMAP_ARRAY \n";
  2278. }
  2279. defines += "\n#define SDFGI_OCT_SIZE " + itos(sdfgi_get_lightprobe_octahedron_size()) + "\n";
  2280. defines += "\n#define MAX_DIRECTIONAL_LIGHT_DATA_STRUCTS " + itos(get_max_directional_lights()) + "\n";
  2281. {
  2282. //lightmaps
  2283. scene_state.max_lightmaps = storage->lightmap_array_get_size();
  2284. defines += "\n#define MAX_LIGHTMAP_TEXTURES " + itos(scene_state.max_lightmaps) + "\n";
  2285. defines += "\n#define MAX_LIGHTMAPS " + itos(scene_state.max_lightmaps) + "\n";
  2286. scene_state.lightmaps = memnew_arr(LightmapData, scene_state.max_lightmaps);
  2287. scene_state.lightmap_buffer = RD::get_singleton()->storage_buffer_create(sizeof(LightmapData) * scene_state.max_lightmaps);
  2288. }
  2289. {
  2290. //captures
  2291. scene_state.max_lightmap_captures = 2048;
  2292. scene_state.lightmap_captures = memnew_arr(LightmapCaptureData, scene_state.max_lightmap_captures);
  2293. scene_state.lightmap_capture_buffer = RD::get_singleton()->storage_buffer_create(sizeof(LightmapCaptureData) * scene_state.max_lightmap_captures);
  2294. }
  2295. {
  2296. defines += "\n#define MATERIAL_UNIFORM_SET " + itos(MATERIAL_UNIFORM_SET) + "\n";
  2297. }
  2298. Vector<String> shader_versions;
  2299. shader_versions.push_back("\n#define MODE_RENDER_DEPTH\n");
  2300. shader_versions.push_back("\n#define MODE_RENDER_DEPTH\n#define MODE_DUAL_PARABOLOID\n");
  2301. shader_versions.push_back("\n#define MODE_RENDER_DEPTH\n#define MODE_RENDER_NORMAL_ROUGHNESS\n");
  2302. shader_versions.push_back("\n#define MODE_RENDER_DEPTH\n#define MODE_RENDER_NORMAL_ROUGHNESS\n#define MODE_RENDER_GIPROBE\n");
  2303. shader_versions.push_back("\n#define MODE_RENDER_DEPTH\n#define MODE_RENDER_MATERIAL\n");
  2304. shader_versions.push_back("\n#define MODE_RENDER_DEPTH\n#define MODE_RENDER_SDF\n");
  2305. shader_versions.push_back("");
  2306. shader_versions.push_back("\n#define USE_FORWARD_GI\n");
  2307. shader_versions.push_back("\n#define MODE_MULTIPLE_RENDER_TARGETS\n");
  2308. shader_versions.push_back("\n#define USE_LIGHTMAP\n");
  2309. shader_versions.push_back("\n#define MODE_MULTIPLE_RENDER_TARGETS\n#define USE_LIGHTMAP\n");
  2310. shader.scene_shader.initialize(shader_versions, defines);
  2311. if (is_low_end()) {
  2312. //disable the high end versions
  2313. shader.scene_shader.set_variant_enabled(SHADER_VERSION_DEPTH_PASS_WITH_NORMAL_AND_ROUGHNESS, false);
  2314. shader.scene_shader.set_variant_enabled(SHADER_VERSION_DEPTH_PASS_WITH_NORMAL_AND_ROUGHNESS_AND_GIPROBE, false);
  2315. shader.scene_shader.set_variant_enabled(SHADER_VERSION_DEPTH_PASS_WITH_SDF, false);
  2316. shader.scene_shader.set_variant_enabled(SHADER_VERSION_COLOR_PASS_WITH_FORWARD_GI, false);
  2317. shader.scene_shader.set_variant_enabled(SHADER_VERSION_COLOR_PASS_WITH_SEPARATE_SPECULAR, false);
  2318. shader.scene_shader.set_variant_enabled(SHADER_VERSION_LIGHTMAP_COLOR_PASS_WITH_SEPARATE_SPECULAR, false);
  2319. }
  2320. }
  2321. storage->shader_set_data_request_function(RendererStorageRD::SHADER_TYPE_3D, _create_shader_funcs);
  2322. storage->material_set_data_request_function(RendererStorageRD::SHADER_TYPE_3D, _create_material_funcs);
  2323. {
  2324. //shader compiler
  2325. ShaderCompilerRD::DefaultIdentifierActions actions;
  2326. actions.renames["WORLD_MATRIX"] = "world_matrix";
  2327. actions.renames["WORLD_NORMAL_MATRIX"] = "world_normal_matrix";
  2328. actions.renames["INV_CAMERA_MATRIX"] = "scene_data.inv_camera_matrix";
  2329. actions.renames["CAMERA_MATRIX"] = "scene_data.camera_matrix";
  2330. actions.renames["PROJECTION_MATRIX"] = "projection_matrix";
  2331. actions.renames["INV_PROJECTION_MATRIX"] = "scene_data.inv_projection_matrix";
  2332. actions.renames["MODELVIEW_MATRIX"] = "modelview";
  2333. actions.renames["MODELVIEW_NORMAL_MATRIX"] = "modelview_normal";
  2334. actions.renames["VERTEX"] = "vertex";
  2335. actions.renames["NORMAL"] = "normal";
  2336. actions.renames["TANGENT"] = "tangent";
  2337. actions.renames["BINORMAL"] = "binormal";
  2338. actions.renames["POSITION"] = "position";
  2339. actions.renames["UV"] = "uv_interp";
  2340. actions.renames["UV2"] = "uv2_interp";
  2341. actions.renames["COLOR"] = "color_interp";
  2342. actions.renames["POINT_SIZE"] = "gl_PointSize";
  2343. actions.renames["INSTANCE_ID"] = "gl_InstanceIndex";
  2344. actions.renames["ALPHA_SCISSOR_THRESHOLD"] = "alpha_scissor_threshold";
  2345. actions.renames["ALPHA_HASH_SCALE"] = "alpha_hash_scale";
  2346. actions.renames["ALPHA_ANTIALIASING_EDGE"] = "alpha_antialiasing_edge";
  2347. actions.renames["ALPHA_TEXTURE_COORDINATE"] = "alpha_texture_coordinate";
  2348. //builtins
  2349. actions.renames["TIME"] = "scene_data.time";
  2350. actions.renames["VIEWPORT_SIZE"] = "scene_data.viewport_size";
  2351. actions.renames["FRAGCOORD"] = "gl_FragCoord";
  2352. actions.renames["FRONT_FACING"] = "gl_FrontFacing";
  2353. actions.renames["NORMALMAP"] = "normalmap";
  2354. actions.renames["NORMALMAP_DEPTH"] = "normaldepth";
  2355. actions.renames["ALBEDO"] = "albedo";
  2356. actions.renames["ALPHA"] = "alpha";
  2357. actions.renames["METALLIC"] = "metallic";
  2358. actions.renames["SPECULAR"] = "specular";
  2359. actions.renames["ROUGHNESS"] = "roughness";
  2360. actions.renames["RIM"] = "rim";
  2361. actions.renames["RIM_TINT"] = "rim_tint";
  2362. actions.renames["CLEARCOAT"] = "clearcoat";
  2363. actions.renames["CLEARCOAT_GLOSS"] = "clearcoat_gloss";
  2364. actions.renames["ANISOTROPY"] = "anisotropy";
  2365. actions.renames["ANISOTROPY_FLOW"] = "anisotropy_flow";
  2366. actions.renames["SSS_STRENGTH"] = "sss_strength";
  2367. actions.renames["SSS_TRANSMITTANCE_COLOR"] = "transmittance_color";
  2368. actions.renames["SSS_TRANSMITTANCE_DEPTH"] = "transmittance_depth";
  2369. actions.renames["SSS_TRANSMITTANCE_CURVE"] = "transmittance_curve";
  2370. actions.renames["SSS_TRANSMITTANCE_BOOST"] = "transmittance_boost";
  2371. actions.renames["BACKLIGHT"] = "backlight";
  2372. actions.renames["AO"] = "ao";
  2373. actions.renames["AO_LIGHT_AFFECT"] = "ao_light_affect";
  2374. actions.renames["EMISSION"] = "emission";
  2375. actions.renames["POINT_COORD"] = "gl_PointCoord";
  2376. actions.renames["INSTANCE_CUSTOM"] = "instance_custom";
  2377. actions.renames["SCREEN_UV"] = "screen_uv";
  2378. actions.renames["SCREEN_TEXTURE"] = "color_buffer";
  2379. actions.renames["DEPTH_TEXTURE"] = "depth_buffer";
  2380. actions.renames["NORMAL_ROUGHNESS_TEXTURE"] = "normal_roughness_buffer";
  2381. actions.renames["DEPTH"] = "gl_FragDepth";
  2382. actions.renames["OUTPUT_IS_SRGB"] = "true";
  2383. actions.renames["FOG"] = "custom_fog";
  2384. actions.renames["RADIANCE"] = "custom_radiance";
  2385. actions.renames["IRRADIANCE"] = "custom_irradiance";
  2386. actions.renames["BONE_INDICES"] = "bone_attrib";
  2387. actions.renames["BONE_WEIGHTS"] = "weight_attrib";
  2388. actions.renames["CUSTOM0"] = "custom0_attrib";
  2389. actions.renames["CUSTOM1"] = "custom1_attrib";
  2390. actions.renames["CUSTOM2"] = "custom2_attrib";
  2391. actions.renames["CUSTOM3"] = "custom3_attrib";
  2392. //for light
  2393. actions.renames["VIEW"] = "view";
  2394. actions.renames["LIGHT_COLOR"] = "light_color";
  2395. actions.renames["LIGHT"] = "light";
  2396. actions.renames["ATTENUATION"] = "attenuation";
  2397. actions.renames["SHADOW_ATTENUATION"] = "shadow_attenuation";
  2398. actions.renames["DIFFUSE_LIGHT"] = "diffuse_light";
  2399. actions.renames["SPECULAR_LIGHT"] = "specular_light";
  2400. actions.usage_defines["TANGENT"] = "#define TANGENT_USED\n";
  2401. actions.usage_defines["BINORMAL"] = "@TANGENT";
  2402. actions.usage_defines["RIM"] = "#define LIGHT_RIM_USED\n";
  2403. actions.usage_defines["RIM_TINT"] = "@RIM";
  2404. actions.usage_defines["CLEARCOAT"] = "#define LIGHT_CLEARCOAT_USED\n";
  2405. actions.usage_defines["CLEARCOAT_GLOSS"] = "@CLEARCOAT";
  2406. actions.usage_defines["ANISOTROPY"] = "#define LIGHT_ANISOTROPY_USED\n";
  2407. actions.usage_defines["ANISOTROPY_FLOW"] = "@ANISOTROPY";
  2408. actions.usage_defines["AO"] = "#define AO_USED\n";
  2409. actions.usage_defines["AO_LIGHT_AFFECT"] = "#define AO_USED\n";
  2410. actions.usage_defines["UV"] = "#define UV_USED\n";
  2411. actions.usage_defines["UV2"] = "#define UV2_USED\n";
  2412. actions.usage_defines["BONE_INDICES"] = "#define BONES_USED\n";
  2413. actions.usage_defines["BONE_WEIGHTS"] = "#define WEIGHTS_USED\n";
  2414. actions.usage_defines["CUSTOM0"] = "#define CUSTOM0\n";
  2415. actions.usage_defines["CUSTOM1"] = "#define CUSTOM1\n";
  2416. actions.usage_defines["CUSTOM2"] = "#define CUSTOM2\n";
  2417. actions.usage_defines["CUSTOM3"] = "#define CUSTOM3\n";
  2418. actions.usage_defines["NORMALMAP"] = "#define NORMALMAP_USED\n";
  2419. actions.usage_defines["NORMALMAP_DEPTH"] = "@NORMALMAP";
  2420. actions.usage_defines["COLOR"] = "#define COLOR_USED\n";
  2421. actions.usage_defines["INSTANCE_CUSTOM"] = "#define ENABLE_INSTANCE_CUSTOM\n";
  2422. actions.usage_defines["POSITION"] = "#define OVERRIDE_POSITION\n";
  2423. actions.usage_defines["ALPHA_SCISSOR_THRESHOLD"] = "#define ALPHA_SCISSOR_USED\n";
  2424. actions.usage_defines["ALPHA_HASH_SCALE"] = "#define ALPHA_HASH_USED\n";
  2425. actions.usage_defines["ALPHA_ANTIALIASING_EDGE"] = "#define ALPHA_ANTIALIASING_EDGE_USED\n";
  2426. actions.usage_defines["ALPHA_TEXTURE_COORDINATE"] = "@ALPHA_ANTIALIASING_EDGE";
  2427. actions.usage_defines["SSS_STRENGTH"] = "#define ENABLE_SSS\n";
  2428. actions.usage_defines["SSS_TRANSMITTANCE_DEPTH"] = "#define ENABLE_TRANSMITTANCE\n";
  2429. actions.usage_defines["BACKLIGHT"] = "#define LIGHT_BACKLIGHT_USED\n";
  2430. actions.usage_defines["SCREEN_TEXTURE"] = "#define SCREEN_TEXTURE_USED\n";
  2431. actions.usage_defines["SCREEN_UV"] = "#define SCREEN_UV_USED\n";
  2432. actions.usage_defines["DIFFUSE_LIGHT"] = "#define USE_LIGHT_SHADER_CODE\n";
  2433. actions.usage_defines["SPECULAR_LIGHT"] = "#define USE_LIGHT_SHADER_CODE\n";
  2434. actions.usage_defines["FOG"] = "#define CUSTOM_FOG_USED\n";
  2435. actions.usage_defines["RADIANCE"] = "#define CUSTOM_RADIANCE_USED\n";
  2436. actions.usage_defines["IRRADIANCE"] = "#define CUSTOM_IRRADIANCE_USED\n";
  2437. actions.render_mode_defines["skip_vertex_transform"] = "#define SKIP_TRANSFORM_USED\n";
  2438. actions.render_mode_defines["world_vertex_coords"] = "#define VERTEX_WORLD_COORDS_USED\n";
  2439. actions.render_mode_defines["ensure_correct_normals"] = "#define ENSURE_CORRECT_NORMALS\n";
  2440. actions.render_mode_defines["cull_front"] = "#define DO_SIDE_CHECK\n";
  2441. actions.render_mode_defines["cull_disabled"] = "#define DO_SIDE_CHECK\n";
  2442. bool force_lambert = GLOBAL_GET("rendering/quality/shading/force_lambert_over_burley");
  2443. if (!force_lambert) {
  2444. actions.render_mode_defines["diffuse_burley"] = "#define DIFFUSE_BURLEY\n";
  2445. }
  2446. actions.render_mode_defines["diffuse_oren_nayar"] = "#define DIFFUSE_OREN_NAYAR\n";
  2447. actions.render_mode_defines["diffuse_lambert_wrap"] = "#define DIFFUSE_LAMBERT_WRAP\n";
  2448. actions.render_mode_defines["diffuse_toon"] = "#define DIFFUSE_TOON\n";
  2449. actions.render_mode_defines["sss_mode_skin"] = "#define SSS_MODE_SKIN\n";
  2450. bool force_blinn = GLOBAL_GET("rendering/quality/shading/force_blinn_over_ggx");
  2451. if (!force_blinn) {
  2452. actions.render_mode_defines["specular_schlick_ggx"] = "#define SPECULAR_SCHLICK_GGX\n";
  2453. } else {
  2454. actions.render_mode_defines["specular_schlick_ggx"] = "#define SPECULAR_BLINN\n";
  2455. }
  2456. actions.render_mode_defines["specular_blinn"] = "#define SPECULAR_BLINN\n";
  2457. actions.render_mode_defines["specular_phong"] = "#define SPECULAR_PHONG\n";
  2458. actions.render_mode_defines["specular_toon"] = "#define SPECULAR_TOON\n";
  2459. actions.render_mode_defines["specular_disabled"] = "#define SPECULAR_DISABLED\n";
  2460. actions.render_mode_defines["shadows_disabled"] = "#define SHADOWS_DISABLED\n";
  2461. actions.render_mode_defines["ambient_light_disabled"] = "#define AMBIENT_LIGHT_DISABLED\n";
  2462. actions.render_mode_defines["shadow_to_opacity"] = "#define USE_SHADOW_TO_OPACITY\n";
  2463. actions.render_mode_defines["unshaded"] = "#define MODE_UNSHADED\n";
  2464. actions.sampler_array_name = "material_samplers";
  2465. actions.base_texture_binding_index = 1;
  2466. actions.texture_layout_set = MATERIAL_UNIFORM_SET;
  2467. actions.base_uniform_string = "material.";
  2468. actions.base_varying_index = 10;
  2469. actions.default_filter = ShaderLanguage::FILTER_LINEAR_MIPMAP;
  2470. actions.default_repeat = ShaderLanguage::REPEAT_ENABLE;
  2471. actions.global_buffer_array_variable = "global_variables.data";
  2472. actions.instance_uniform_index_variable = "instances.data[instance_index].instance_uniforms_ofs";
  2473. shader.compiler.initialize(actions);
  2474. }
  2475. //render list
  2476. render_list.max_elements = GLOBAL_DEF_RST("rendering/limits/rendering/max_renderable_elements", (int)128000);
  2477. render_list.init();
  2478. render_pass = 0;
  2479. {
  2480. scene_state.max_instances = render_list.max_elements;
  2481. scene_state.instances = memnew_arr(InstanceData, scene_state.max_instances);
  2482. scene_state.instance_buffer = RD::get_singleton()->storage_buffer_create(sizeof(InstanceData) * scene_state.max_instances);
  2483. }
  2484. scene_state.uniform_buffer = RD::get_singleton()->uniform_buffer_create(sizeof(SceneState::UBO));
  2485. {
  2486. //default material and shader
  2487. default_shader = storage->shader_create();
  2488. storage->shader_set_code(default_shader, "shader_type spatial; void vertex() { ROUGHNESS = 0.8; } void fragment() { ALBEDO=vec3(0.6); ROUGHNESS=0.8; METALLIC=0.2; } \n");
  2489. default_material = storage->material_create();
  2490. storage->material_set_shader(default_material, default_shader);
  2491. MaterialData *md = (MaterialData *)storage->material_get_data(default_material, RendererStorageRD::SHADER_TYPE_3D);
  2492. default_shader_rd = shader.scene_shader.version_get_shader(md->shader_data->version, SHADER_VERSION_COLOR_PASS);
  2493. if (!low_end) {
  2494. default_shader_sdfgi_rd = shader.scene_shader.version_get_shader(md->shader_data->version, SHADER_VERSION_DEPTH_PASS_WITH_SDF);
  2495. }
  2496. }
  2497. {
  2498. overdraw_material_shader = storage->shader_create();
  2499. storage->shader_set_code(overdraw_material_shader, "shader_type spatial;\nrender_mode blend_add,unshaded;\n void fragment() { ALBEDO=vec3(0.4,0.8,0.8); ALPHA=0.2; }");
  2500. overdraw_material = storage->material_create();
  2501. storage->material_set_shader(overdraw_material, overdraw_material_shader);
  2502. wireframe_material_shader = storage->shader_create();
  2503. storage->shader_set_code(wireframe_material_shader, "shader_type spatial;\nrender_mode wireframe,unshaded;\n void fragment() { ALBEDO=vec3(0.0,0.0,0.0); }");
  2504. wireframe_material = storage->material_create();
  2505. storage->material_set_shader(wireframe_material, wireframe_material_shader);
  2506. }
  2507. {
  2508. default_vec4_xform_buffer = RD::get_singleton()->storage_buffer_create(256);
  2509. Vector<RD::Uniform> uniforms;
  2510. RD::Uniform u;
  2511. u.uniform_type = RD::UNIFORM_TYPE_STORAGE_BUFFER;
  2512. u.ids.push_back(default_vec4_xform_buffer);
  2513. u.binding = 0;
  2514. uniforms.push_back(u);
  2515. default_vec4_xform_uniform_set = RD::get_singleton()->uniform_set_create(uniforms, default_shader_rd, TRANSFORMS_UNIFORM_SET);
  2516. }
  2517. {
  2518. RD::SamplerState sampler;
  2519. sampler.mag_filter = RD::SAMPLER_FILTER_LINEAR;
  2520. sampler.min_filter = RD::SAMPLER_FILTER_LINEAR;
  2521. sampler.enable_compare = true;
  2522. sampler.compare_op = RD::COMPARE_OP_LESS;
  2523. shadow_sampler = RD::get_singleton()->sampler_create(sampler);
  2524. }
  2525. }
  2526. RendererSceneRenderForward::~RendererSceneRenderForward() {
  2527. directional_shadow_atlas_set_size(0);
  2528. //clear base uniform set if still valid
  2529. if (render_pass_uniform_set.is_valid() && RD::get_singleton()->uniform_set_is_valid(render_pass_uniform_set)) {
  2530. RD::get_singleton()->free(render_pass_uniform_set);
  2531. }
  2532. if (sdfgi_pass_uniform_set.is_valid() && RD::get_singleton()->uniform_set_is_valid(sdfgi_pass_uniform_set)) {
  2533. RD::get_singleton()->free(sdfgi_pass_uniform_set);
  2534. }
  2535. RD::get_singleton()->free(default_vec4_xform_buffer);
  2536. RD::get_singleton()->free(shadow_sampler);
  2537. storage->free(wireframe_material_shader);
  2538. storage->free(overdraw_material_shader);
  2539. storage->free(default_shader);
  2540. storage->free(wireframe_material);
  2541. storage->free(overdraw_material);
  2542. storage->free(default_material);
  2543. {
  2544. RD::get_singleton()->free(scene_state.uniform_buffer);
  2545. RD::get_singleton()->free(scene_state.instance_buffer);
  2546. RD::get_singleton()->free(scene_state.lightmap_buffer);
  2547. RD::get_singleton()->free(scene_state.lightmap_capture_buffer);
  2548. memdelete_arr(scene_state.instances);
  2549. memdelete_arr(scene_state.lightmaps);
  2550. memdelete_arr(scene_state.lightmap_captures);
  2551. }
  2552. while (sdfgi_framebuffer_size_cache.front()) {
  2553. RD::get_singleton()->free(sdfgi_framebuffer_size_cache.front()->get());
  2554. sdfgi_framebuffer_size_cache.erase(sdfgi_framebuffer_size_cache.front());
  2555. }
  2556. }