renderer_canvas_render_rd.cpp 106 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648164916501651165216531654165516561657165816591660166116621663166416651666166716681669167016711672167316741675167616771678167916801681168216831684168516861687168816891690169116921693169416951696169716981699170017011702170317041705170617071708170917101711171217131714171517161717171817191720172117221723172417251726172717281729173017311732173317341735173617371738173917401741174217431744174517461747174817491750175117521753175417551756175717581759176017611762176317641765176617671768176917701771177217731774177517761777177817791780178117821783178417851786178717881789179017911792179317941795179617971798179918001801180218031804180518061807180818091810181118121813181418151816181718181819182018211822182318241825182618271828182918301831183218331834183518361837183818391840184118421843184418451846184718481849185018511852185318541855185618571858185918601861186218631864186518661867186818691870187118721873187418751876187718781879188018811882188318841885188618871888188918901891189218931894189518961897189818991900190119021903190419051906190719081909191019111912191319141915191619171918191919201921192219231924192519261927192819291930193119321933193419351936193719381939194019411942194319441945194619471948194919501951195219531954195519561957195819591960196119621963196419651966196719681969197019711972197319741975197619771978197919801981198219831984198519861987198819891990199119921993199419951996199719981999200020012002200320042005200620072008200920102011201220132014201520162017201820192020202120222023202420252026202720282029203020312032203320342035203620372038203920402041204220432044204520462047204820492050205120522053205420552056205720582059206020612062206320642065206620672068206920702071207220732074207520762077207820792080208120822083208420852086208720882089209020912092209320942095209620972098209921002101210221032104210521062107210821092110211121122113211421152116211721182119212021212122212321242125212621272128212921302131213221332134213521362137213821392140214121422143214421452146214721482149215021512152215321542155215621572158215921602161216221632164216521662167216821692170217121722173217421752176217721782179218021812182218321842185218621872188218921902191219221932194219521962197219821992200220122022203220422052206220722082209221022112212221322142215221622172218221922202221222222232224222522262227222822292230223122322233223422352236223722382239224022412242224322442245224622472248224922502251225222532254225522562257225822592260226122622263226422652266226722682269227022712272227322742275227622772278227922802281228222832284228522862287228822892290229122922293229422952296229722982299230023012302230323042305230623072308230923102311231223132314231523162317231823192320232123222323232423252326232723282329233023312332233323342335233623372338233923402341234223432344234523462347234823492350235123522353235423552356235723582359236023612362236323642365236623672368236923702371237223732374237523762377237823792380238123822383238423852386238723882389239023912392239323942395239623972398239924002401240224032404240524062407240824092410241124122413241424152416241724182419242024212422242324242425242624272428242924302431243224332434243524362437243824392440244124422443244424452446244724482449245024512452245324542455245624572458245924602461246224632464246524662467246824692470247124722473247424752476247724782479248024812482248324842485248624872488248924902491249224932494249524962497249824992500250125022503250425052506250725082509251025112512251325142515251625172518251925202521252225232524252525262527252825292530253125322533253425352536253725382539254025412542254325442545254625472548254925502551255225532554255525562557255825592560256125622563256425652566256725682569257025712572257325742575257625772578257925802581258225832584258525862587258825892590259125922593259425952596259725982599260026012602260326042605260626072608260926102611261226132614261526162617261826192620262126222623262426252626262726282629263026312632263326342635263626372638263926402641264226432644264526462647264826492650265126522653265426552656265726582659266026612662266326642665266626672668266926702671267226732674267526762677267826792680268126822683268426852686268726882689269026912692269326942695269626972698269927002701270227032704270527062707270827092710271127122713271427152716271727182719272027212722272327242725272627272728272927302731273227332734273527362737273827392740274127422743274427452746274727482749275027512752275327542755275627572758275927602761276227632764276527662767276827692770277127722773277427752776277727782779278027812782278327842785278627872788278927902791279227932794279527962797279827992800280128022803280428052806280728082809281028112812281328142815281628172818281928202821282228232824282528262827282828292830
  1. /*************************************************************************/
  2. /* renderer_canvas_render_rd.cpp */
  3. /*************************************************************************/
  4. /* This file is part of: */
  5. /* GODOT ENGINE */
  6. /* https://godotengine.org */
  7. /*************************************************************************/
  8. /* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur. */
  9. /* Copyright (c) 2014-2022 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_canvas_render_rd.h"
  31. #include "core/config/project_settings.h"
  32. #include "core/math/geometry_2d.h"
  33. #include "core/math/math_defs.h"
  34. #include "core/math/math_funcs.h"
  35. #include "renderer_compositor_rd.h"
  36. #include "servers/rendering/renderer_rd/storage_rd/material_storage.h"
  37. #include "servers/rendering/renderer_rd/storage_rd/particles_storage.h"
  38. #include "servers/rendering/renderer_rd/storage_rd/texture_storage.h"
  39. #include "servers/rendering/rendering_server_default.h"
  40. void RendererCanvasRenderRD::_update_transform_2d_to_mat4(const Transform2D &p_transform, float *p_mat4) {
  41. p_mat4[0] = p_transform.columns[0][0];
  42. p_mat4[1] = p_transform.columns[0][1];
  43. p_mat4[2] = 0;
  44. p_mat4[3] = 0;
  45. p_mat4[4] = p_transform.columns[1][0];
  46. p_mat4[5] = p_transform.columns[1][1];
  47. p_mat4[6] = 0;
  48. p_mat4[7] = 0;
  49. p_mat4[8] = 0;
  50. p_mat4[9] = 0;
  51. p_mat4[10] = 1;
  52. p_mat4[11] = 0;
  53. p_mat4[12] = p_transform.columns[2][0];
  54. p_mat4[13] = p_transform.columns[2][1];
  55. p_mat4[14] = 0;
  56. p_mat4[15] = 1;
  57. }
  58. void RendererCanvasRenderRD::_update_transform_2d_to_mat2x4(const Transform2D &p_transform, float *p_mat2x4) {
  59. p_mat2x4[0] = p_transform.columns[0][0];
  60. p_mat2x4[1] = p_transform.columns[1][0];
  61. p_mat2x4[2] = 0;
  62. p_mat2x4[3] = p_transform.columns[2][0];
  63. p_mat2x4[4] = p_transform.columns[0][1];
  64. p_mat2x4[5] = p_transform.columns[1][1];
  65. p_mat2x4[6] = 0;
  66. p_mat2x4[7] = p_transform.columns[2][1];
  67. }
  68. void RendererCanvasRenderRD::_update_transform_2d_to_mat2x3(const Transform2D &p_transform, float *p_mat2x3) {
  69. p_mat2x3[0] = p_transform.columns[0][0];
  70. p_mat2x3[1] = p_transform.columns[0][1];
  71. p_mat2x3[2] = p_transform.columns[1][0];
  72. p_mat2x3[3] = p_transform.columns[1][1];
  73. p_mat2x3[4] = p_transform.columns[2][0];
  74. p_mat2x3[5] = p_transform.columns[2][1];
  75. }
  76. void RendererCanvasRenderRD::_update_transform_to_mat4(const Transform3D &p_transform, float *p_mat4) {
  77. p_mat4[0] = p_transform.basis.rows[0][0];
  78. p_mat4[1] = p_transform.basis.rows[1][0];
  79. p_mat4[2] = p_transform.basis.rows[2][0];
  80. p_mat4[3] = 0;
  81. p_mat4[4] = p_transform.basis.rows[0][1];
  82. p_mat4[5] = p_transform.basis.rows[1][1];
  83. p_mat4[6] = p_transform.basis.rows[2][1];
  84. p_mat4[7] = 0;
  85. p_mat4[8] = p_transform.basis.rows[0][2];
  86. p_mat4[9] = p_transform.basis.rows[1][2];
  87. p_mat4[10] = p_transform.basis.rows[2][2];
  88. p_mat4[11] = 0;
  89. p_mat4[12] = p_transform.origin.x;
  90. p_mat4[13] = p_transform.origin.y;
  91. p_mat4[14] = p_transform.origin.z;
  92. p_mat4[15] = 1;
  93. }
  94. RendererCanvasRender::PolygonID RendererCanvasRenderRD::request_polygon(const Vector<int> &p_indices, const Vector<Point2> &p_points, const Vector<Color> &p_colors, const Vector<Point2> &p_uvs, const Vector<int> &p_bones, const Vector<float> &p_weights) {
  95. // Care must be taken to generate array formats
  96. // in ways where they could be reused, so we will
  97. // put single-occuring elements first, and repeated
  98. // elements later. This way the generated formats are
  99. // the same no matter the length of the arrays.
  100. // This dramatically reduces the amount of pipeline objects
  101. // that need to be created for these formats.
  102. RendererRD::MeshStorage *mesh_storage = RendererRD::MeshStorage::get_singleton();
  103. uint32_t vertex_count = p_points.size();
  104. uint32_t stride = 2; //vertices always repeat
  105. if ((uint32_t)p_colors.size() == vertex_count || p_colors.size() == 1) {
  106. stride += 4;
  107. }
  108. if ((uint32_t)p_uvs.size() == vertex_count) {
  109. stride += 2;
  110. }
  111. if ((uint32_t)p_bones.size() == vertex_count * 4 && (uint32_t)p_weights.size() == vertex_count * 4) {
  112. stride += 4;
  113. }
  114. uint32_t buffer_size = stride * p_points.size();
  115. Vector<uint8_t> polygon_buffer;
  116. polygon_buffer.resize(buffer_size * sizeof(float));
  117. Vector<RD::VertexAttribute> descriptions;
  118. descriptions.resize(5);
  119. Vector<RID> buffers;
  120. buffers.resize(5);
  121. {
  122. uint8_t *r = polygon_buffer.ptrw();
  123. float *fptr = reinterpret_cast<float *>(r);
  124. uint32_t *uptr = reinterpret_cast<uint32_t *>(r);
  125. uint32_t base_offset = 0;
  126. { //vertices
  127. RD::VertexAttribute vd;
  128. vd.format = RD::DATA_FORMAT_R32G32_SFLOAT;
  129. vd.offset = base_offset * sizeof(float);
  130. vd.location = RS::ARRAY_VERTEX;
  131. vd.stride = stride * sizeof(float);
  132. descriptions.write[0] = vd;
  133. const Vector2 *points_ptr = p_points.ptr();
  134. for (uint32_t i = 0; i < vertex_count; i++) {
  135. fptr[base_offset + i * stride + 0] = points_ptr[i].x;
  136. fptr[base_offset + i * stride + 1] = points_ptr[i].y;
  137. }
  138. base_offset += 2;
  139. }
  140. //colors
  141. if ((uint32_t)p_colors.size() == vertex_count || p_colors.size() == 1) {
  142. RD::VertexAttribute vd;
  143. vd.format = RD::DATA_FORMAT_R32G32B32A32_SFLOAT;
  144. vd.offset = base_offset * sizeof(float);
  145. vd.location = RS::ARRAY_COLOR;
  146. vd.stride = stride * sizeof(float);
  147. descriptions.write[1] = vd;
  148. if (p_colors.size() == 1) {
  149. Color color = p_colors[0];
  150. for (uint32_t i = 0; i < vertex_count; i++) {
  151. fptr[base_offset + i * stride + 0] = color.r;
  152. fptr[base_offset + i * stride + 1] = color.g;
  153. fptr[base_offset + i * stride + 2] = color.b;
  154. fptr[base_offset + i * stride + 3] = color.a;
  155. }
  156. } else {
  157. const Color *color_ptr = p_colors.ptr();
  158. for (uint32_t i = 0; i < vertex_count; i++) {
  159. fptr[base_offset + i * stride + 0] = color_ptr[i].r;
  160. fptr[base_offset + i * stride + 1] = color_ptr[i].g;
  161. fptr[base_offset + i * stride + 2] = color_ptr[i].b;
  162. fptr[base_offset + i * stride + 3] = color_ptr[i].a;
  163. }
  164. }
  165. base_offset += 4;
  166. } else {
  167. RD::VertexAttribute vd;
  168. vd.format = RD::DATA_FORMAT_R32G32B32A32_SFLOAT;
  169. vd.offset = 0;
  170. vd.location = RS::ARRAY_COLOR;
  171. vd.stride = 0;
  172. descriptions.write[1] = vd;
  173. buffers.write[1] = mesh_storage->mesh_get_default_rd_buffer(RendererRD::MeshStorage::DEFAULT_RD_BUFFER_COLOR);
  174. }
  175. //uvs
  176. if ((uint32_t)p_uvs.size() == vertex_count) {
  177. RD::VertexAttribute vd;
  178. vd.format = RD::DATA_FORMAT_R32G32_SFLOAT;
  179. vd.offset = base_offset * sizeof(float);
  180. vd.location = RS::ARRAY_TEX_UV;
  181. vd.stride = stride * sizeof(float);
  182. descriptions.write[2] = vd;
  183. const Vector2 *uv_ptr = p_uvs.ptr();
  184. for (uint32_t i = 0; i < vertex_count; i++) {
  185. fptr[base_offset + i * stride + 0] = uv_ptr[i].x;
  186. fptr[base_offset + i * stride + 1] = uv_ptr[i].y;
  187. }
  188. base_offset += 2;
  189. } else {
  190. RD::VertexAttribute vd;
  191. vd.format = RD::DATA_FORMAT_R32G32_SFLOAT;
  192. vd.offset = 0;
  193. vd.location = RS::ARRAY_TEX_UV;
  194. vd.stride = 0;
  195. descriptions.write[2] = vd;
  196. buffers.write[2] = mesh_storage->mesh_get_default_rd_buffer(RendererRD::MeshStorage::DEFAULT_RD_BUFFER_TEX_UV);
  197. }
  198. //bones
  199. if ((uint32_t)p_indices.size() == vertex_count * 4 && (uint32_t)p_weights.size() == vertex_count * 4) {
  200. RD::VertexAttribute vd;
  201. vd.format = RD::DATA_FORMAT_R16G16B16A16_UINT;
  202. vd.offset = base_offset * sizeof(float);
  203. vd.location = RS::ARRAY_BONES;
  204. vd.stride = stride * sizeof(float);
  205. descriptions.write[3] = vd;
  206. const int *bone_ptr = p_bones.ptr();
  207. for (uint32_t i = 0; i < vertex_count; i++) {
  208. uint16_t *bone16w = (uint16_t *)&uptr[base_offset + i * stride];
  209. bone16w[0] = bone_ptr[i * 4 + 0];
  210. bone16w[1] = bone_ptr[i * 4 + 1];
  211. bone16w[2] = bone_ptr[i * 4 + 2];
  212. bone16w[3] = bone_ptr[i * 4 + 3];
  213. }
  214. base_offset += 2;
  215. } else {
  216. RD::VertexAttribute vd;
  217. vd.format = RD::DATA_FORMAT_R32G32B32A32_UINT;
  218. vd.offset = 0;
  219. vd.location = RS::ARRAY_BONES;
  220. vd.stride = 0;
  221. descriptions.write[3] = vd;
  222. buffers.write[3] = mesh_storage->mesh_get_default_rd_buffer(RendererRD::MeshStorage::DEFAULT_RD_BUFFER_BONES);
  223. }
  224. //weights
  225. if ((uint32_t)p_weights.size() == vertex_count * 4) {
  226. RD::VertexAttribute vd;
  227. vd.format = RD::DATA_FORMAT_R16G16B16A16_UNORM;
  228. vd.offset = base_offset * sizeof(float);
  229. vd.location = RS::ARRAY_WEIGHTS;
  230. vd.stride = stride * sizeof(float);
  231. descriptions.write[4] = vd;
  232. const float *weight_ptr = p_weights.ptr();
  233. for (uint32_t i = 0; i < vertex_count; i++) {
  234. uint16_t *weight16w = (uint16_t *)&uptr[base_offset + i * stride];
  235. weight16w[0] = CLAMP(weight_ptr[i * 4 + 0] * 65535, 0, 65535);
  236. weight16w[1] = CLAMP(weight_ptr[i * 4 + 1] * 65535, 0, 65535);
  237. weight16w[2] = CLAMP(weight_ptr[i * 4 + 2] * 65535, 0, 65535);
  238. weight16w[3] = CLAMP(weight_ptr[i * 4 + 3] * 65535, 0, 65535);
  239. }
  240. base_offset += 2;
  241. } else {
  242. RD::VertexAttribute vd;
  243. vd.format = RD::DATA_FORMAT_R32G32B32A32_SFLOAT;
  244. vd.offset = 0;
  245. vd.location = RS::ARRAY_WEIGHTS;
  246. vd.stride = 0;
  247. descriptions.write[4] = vd;
  248. buffers.write[4] = mesh_storage->mesh_get_default_rd_buffer(RendererRD::MeshStorage::DEFAULT_RD_BUFFER_WEIGHTS);
  249. }
  250. //check that everything is as it should be
  251. ERR_FAIL_COND_V(base_offset != stride, 0); //bug
  252. }
  253. RD::VertexFormatID vertex_id = RD::get_singleton()->vertex_format_create(descriptions);
  254. ERR_FAIL_COND_V(vertex_id == RD::INVALID_ID, 0);
  255. PolygonBuffers pb;
  256. pb.vertex_buffer = RD::get_singleton()->vertex_buffer_create(polygon_buffer.size(), polygon_buffer);
  257. for (int i = 0; i < descriptions.size(); i++) {
  258. if (buffers[i] == RID()) { //if put in vertex, use as vertex
  259. buffers.write[i] = pb.vertex_buffer;
  260. }
  261. }
  262. pb.vertex_array = RD::get_singleton()->vertex_array_create(p_points.size(), vertex_id, buffers);
  263. if (p_indices.size()) {
  264. //create indices, as indices were requested
  265. Vector<uint8_t> index_buffer;
  266. index_buffer.resize(p_indices.size() * sizeof(int32_t));
  267. {
  268. uint8_t *w = index_buffer.ptrw();
  269. memcpy(w, p_indices.ptr(), sizeof(int32_t) * p_indices.size());
  270. }
  271. pb.index_buffer = RD::get_singleton()->index_buffer_create(p_indices.size(), RD::INDEX_BUFFER_FORMAT_UINT32, index_buffer);
  272. pb.indices = RD::get_singleton()->index_array_create(pb.index_buffer, 0, p_indices.size());
  273. }
  274. pb.vertex_format_id = vertex_id;
  275. PolygonID id = polygon_buffers.last_id++;
  276. polygon_buffers.polygons[id] = pb;
  277. return id;
  278. }
  279. void RendererCanvasRenderRD::free_polygon(PolygonID p_polygon) {
  280. PolygonBuffers *pb_ptr = polygon_buffers.polygons.getptr(p_polygon);
  281. ERR_FAIL_COND(!pb_ptr);
  282. PolygonBuffers &pb = *pb_ptr;
  283. if (pb.indices.is_valid()) {
  284. RD::get_singleton()->free(pb.indices);
  285. }
  286. if (pb.index_buffer.is_valid()) {
  287. RD::get_singleton()->free(pb.index_buffer);
  288. }
  289. RD::get_singleton()->free(pb.vertex_array);
  290. RD::get_singleton()->free(pb.vertex_buffer);
  291. polygon_buffers.polygons.erase(p_polygon);
  292. }
  293. ////////////////////
  294. void RendererCanvasRenderRD::_bind_canvas_texture(RD::DrawListID p_draw_list, RID p_texture, RS::CanvasItemTextureFilter p_base_filter, RS::CanvasItemTextureRepeat p_base_repeat, RID &r_last_texture, PushConstant &push_constant, Size2 &r_texpixel_size) {
  295. if (p_texture == RID()) {
  296. p_texture = default_canvas_texture;
  297. }
  298. if (r_last_texture == p_texture) {
  299. return; //nothing to do, its the same
  300. }
  301. RID uniform_set;
  302. Color specular_shininess;
  303. Size2i size;
  304. bool use_normal;
  305. bool use_specular;
  306. bool success = RendererRD::TextureStorage::get_singleton()->canvas_texture_get_uniform_set(p_texture, p_base_filter, p_base_repeat, shader.default_version_rd_shader, CANVAS_TEXTURE_UNIFORM_SET, uniform_set, size, specular_shininess, use_normal, use_specular);
  307. //something odd happened
  308. if (!success) {
  309. _bind_canvas_texture(p_draw_list, default_canvas_texture, p_base_filter, p_base_repeat, r_last_texture, push_constant, r_texpixel_size);
  310. return;
  311. }
  312. RD::get_singleton()->draw_list_bind_uniform_set(p_draw_list, uniform_set, CANVAS_TEXTURE_UNIFORM_SET);
  313. if (specular_shininess.a < 0.999) {
  314. push_constant.flags |= FLAGS_DEFAULT_SPECULAR_MAP_USED;
  315. } else {
  316. push_constant.flags &= ~FLAGS_DEFAULT_SPECULAR_MAP_USED;
  317. }
  318. if (use_normal) {
  319. push_constant.flags |= FLAGS_DEFAULT_NORMAL_MAP_USED;
  320. } else {
  321. push_constant.flags &= ~FLAGS_DEFAULT_NORMAL_MAP_USED;
  322. }
  323. push_constant.specular_shininess = uint32_t(CLAMP(specular_shininess.a * 255.0, 0, 255)) << 24;
  324. push_constant.specular_shininess |= uint32_t(CLAMP(specular_shininess.b * 255.0, 0, 255)) << 16;
  325. push_constant.specular_shininess |= uint32_t(CLAMP(specular_shininess.g * 255.0, 0, 255)) << 8;
  326. push_constant.specular_shininess |= uint32_t(CLAMP(specular_shininess.r * 255.0, 0, 255));
  327. r_texpixel_size.x = 1.0 / float(size.x);
  328. r_texpixel_size.y = 1.0 / float(size.y);
  329. push_constant.color_texture_pixel_size[0] = r_texpixel_size.x;
  330. push_constant.color_texture_pixel_size[1] = r_texpixel_size.y;
  331. r_last_texture = p_texture;
  332. }
  333. void RendererCanvasRenderRD::_render_item(RD::DrawListID p_draw_list, RID p_render_target, const Item *p_item, RD::FramebufferFormatID p_framebuffer_format, const Transform2D &p_canvas_transform_inverse, Item *&current_clip, Light *p_lights, PipelineVariants *p_pipeline_variants) {
  334. //create an empty push constant
  335. RendererRD::TextureStorage *texture_storage = RendererRD::TextureStorage::get_singleton();
  336. RendererRD::MeshStorage *mesh_storage = RendererRD::MeshStorage::get_singleton();
  337. RendererRD::ParticlesStorage *particles_storage = RendererRD::ParticlesStorage::get_singleton();
  338. RS::CanvasItemTextureFilter current_filter = default_filter;
  339. RS::CanvasItemTextureRepeat current_repeat = default_repeat;
  340. if (p_item->texture_filter != RS::CANVAS_ITEM_TEXTURE_FILTER_DEFAULT) {
  341. current_filter = p_item->texture_filter;
  342. }
  343. if (p_item->texture_repeat != RS::CANVAS_ITEM_TEXTURE_REPEAT_DEFAULT) {
  344. current_repeat = p_item->texture_repeat;
  345. }
  346. PushConstant push_constant;
  347. Transform2D base_transform = p_canvas_transform_inverse * p_item->final_transform;
  348. Transform2D draw_transform;
  349. _update_transform_2d_to_mat2x3(base_transform, push_constant.world);
  350. Color base_color = p_item->final_modulate;
  351. for (int i = 0; i < 4; i++) {
  352. push_constant.modulation[i] = 0;
  353. push_constant.ninepatch_margins[i] = 0;
  354. push_constant.src_rect[i] = 0;
  355. push_constant.dst_rect[i] = 0;
  356. }
  357. push_constant.flags = 0;
  358. push_constant.color_texture_pixel_size[0] = 0;
  359. push_constant.color_texture_pixel_size[1] = 0;
  360. push_constant.pad[0] = 0;
  361. push_constant.pad[1] = 0;
  362. push_constant.lights[0] = 0;
  363. push_constant.lights[1] = 0;
  364. push_constant.lights[2] = 0;
  365. push_constant.lights[3] = 0;
  366. uint32_t base_flags = 0;
  367. uint16_t light_count = 0;
  368. PipelineLightMode light_mode;
  369. {
  370. Light *light = p_lights;
  371. while (light) {
  372. if (light->render_index_cache >= 0 && p_item->light_mask & light->item_mask && p_item->z_final >= light->z_min && p_item->z_final <= light->z_max && p_item->global_rect_cache.intersects_transformed(light->xform_cache, light->rect_cache)) {
  373. uint32_t light_index = light->render_index_cache;
  374. push_constant.lights[light_count >> 2] |= light_index << ((light_count & 3) * 8);
  375. light_count++;
  376. if (light_count == MAX_LIGHTS_PER_ITEM) {
  377. break;
  378. }
  379. }
  380. light = light->next_ptr;
  381. }
  382. base_flags |= light_count << FLAGS_LIGHT_COUNT_SHIFT;
  383. }
  384. light_mode = (light_count > 0 || using_directional_lights) ? PIPELINE_LIGHT_MODE_ENABLED : PIPELINE_LIGHT_MODE_DISABLED;
  385. PipelineVariants *pipeline_variants = p_pipeline_variants;
  386. bool reclip = false;
  387. RID last_texture;
  388. Size2 texpixel_size;
  389. bool skipping = false;
  390. const Item::Command *c = p_item->commands;
  391. while (c) {
  392. if (skipping && c->type != Item::Command::TYPE_ANIMATION_SLICE) {
  393. c = c->next;
  394. continue;
  395. }
  396. push_constant.flags = base_flags | (push_constant.flags & (FLAGS_DEFAULT_NORMAL_MAP_USED | FLAGS_DEFAULT_SPECULAR_MAP_USED)); //reset on each command for sanity, keep canvastexture binding config
  397. switch (c->type) {
  398. case Item::Command::TYPE_RECT: {
  399. const Item::CommandRect *rect = static_cast<const Item::CommandRect *>(c);
  400. if (rect->flags & CANVAS_RECT_TILE) {
  401. current_repeat = RenderingServer::CanvasItemTextureRepeat::CANVAS_ITEM_TEXTURE_REPEAT_ENABLED;
  402. }
  403. //bind pipeline
  404. if (rect->flags & CANVAS_RECT_LCD) {
  405. RID pipeline = pipeline_variants->variants[light_mode][PIPELINE_VARIANT_QUAD_LCD_BLEND].get_render_pipeline(RD::INVALID_ID, p_framebuffer_format);
  406. RD::get_singleton()->draw_list_bind_render_pipeline(p_draw_list, pipeline);
  407. RD::get_singleton()->draw_list_set_blend_constants(p_draw_list, rect->modulate);
  408. } else {
  409. RID pipeline = pipeline_variants->variants[light_mode][PIPELINE_VARIANT_QUAD].get_render_pipeline(RD::INVALID_ID, p_framebuffer_format);
  410. RD::get_singleton()->draw_list_bind_render_pipeline(p_draw_list, pipeline);
  411. }
  412. //bind textures
  413. _bind_canvas_texture(p_draw_list, rect->texture, current_filter, current_repeat, last_texture, push_constant, texpixel_size);
  414. Rect2 src_rect;
  415. Rect2 dst_rect;
  416. if (rect->texture != RID()) {
  417. src_rect = (rect->flags & CANVAS_RECT_REGION) ? Rect2(rect->source.position * texpixel_size, rect->source.size * texpixel_size) : Rect2(0, 0, 1, 1);
  418. dst_rect = Rect2(rect->rect.position, rect->rect.size);
  419. if (dst_rect.size.width < 0) {
  420. dst_rect.position.x += dst_rect.size.width;
  421. dst_rect.size.width *= -1;
  422. }
  423. if (dst_rect.size.height < 0) {
  424. dst_rect.position.y += dst_rect.size.height;
  425. dst_rect.size.height *= -1;
  426. }
  427. if (rect->flags & CANVAS_RECT_FLIP_H) {
  428. src_rect.size.x *= -1;
  429. }
  430. if (rect->flags & CANVAS_RECT_FLIP_V) {
  431. src_rect.size.y *= -1;
  432. }
  433. if (rect->flags & CANVAS_RECT_TRANSPOSE) {
  434. push_constant.flags |= FLAGS_TRANSPOSE_RECT;
  435. }
  436. if (rect->flags & CANVAS_RECT_CLIP_UV) {
  437. push_constant.flags |= FLAGS_CLIP_RECT_UV;
  438. }
  439. } else {
  440. dst_rect = Rect2(rect->rect.position, rect->rect.size);
  441. if (dst_rect.size.width < 0) {
  442. dst_rect.position.x += dst_rect.size.width;
  443. dst_rect.size.width *= -1;
  444. }
  445. if (dst_rect.size.height < 0) {
  446. dst_rect.position.y += dst_rect.size.height;
  447. dst_rect.size.height *= -1;
  448. }
  449. src_rect = Rect2(0, 0, 1, 1);
  450. }
  451. if (rect->flags & CANVAS_RECT_MSDF) {
  452. push_constant.flags |= FLAGS_USE_MSDF;
  453. push_constant.msdf[0] = rect->px_range; // Pixel range.
  454. push_constant.msdf[1] = rect->outline; // Outline size.
  455. push_constant.msdf[2] = 0.f; // Reserved.
  456. push_constant.msdf[3] = 0.f; // Reserved.
  457. } else if (rect->flags & CANVAS_RECT_LCD) {
  458. push_constant.flags |= FLAGS_USE_LCD;
  459. }
  460. push_constant.modulation[0] = rect->modulate.r * base_color.r;
  461. push_constant.modulation[1] = rect->modulate.g * base_color.g;
  462. push_constant.modulation[2] = rect->modulate.b * base_color.b;
  463. push_constant.modulation[3] = rect->modulate.a * base_color.a;
  464. push_constant.src_rect[0] = src_rect.position.x;
  465. push_constant.src_rect[1] = src_rect.position.y;
  466. push_constant.src_rect[2] = src_rect.size.width;
  467. push_constant.src_rect[3] = src_rect.size.height;
  468. push_constant.dst_rect[0] = dst_rect.position.x;
  469. push_constant.dst_rect[1] = dst_rect.position.y;
  470. push_constant.dst_rect[2] = dst_rect.size.width;
  471. push_constant.dst_rect[3] = dst_rect.size.height;
  472. RD::get_singleton()->draw_list_set_push_constant(p_draw_list, &push_constant, sizeof(PushConstant));
  473. RD::get_singleton()->draw_list_bind_index_array(p_draw_list, shader.quad_index_array);
  474. RD::get_singleton()->draw_list_draw(p_draw_list, true);
  475. } break;
  476. case Item::Command::TYPE_NINEPATCH: {
  477. const Item::CommandNinePatch *np = static_cast<const Item::CommandNinePatch *>(c);
  478. //bind pipeline
  479. {
  480. RID pipeline = pipeline_variants->variants[light_mode][PIPELINE_VARIANT_NINEPATCH].get_render_pipeline(RD::INVALID_ID, p_framebuffer_format);
  481. RD::get_singleton()->draw_list_bind_render_pipeline(p_draw_list, pipeline);
  482. }
  483. //bind textures
  484. _bind_canvas_texture(p_draw_list, np->texture, current_filter, current_repeat, last_texture, push_constant, texpixel_size);
  485. Rect2 src_rect;
  486. Rect2 dst_rect(np->rect.position.x, np->rect.position.y, np->rect.size.x, np->rect.size.y);
  487. if (np->texture == RID()) {
  488. texpixel_size = Size2(1, 1);
  489. src_rect = Rect2(0, 0, 1, 1);
  490. } else {
  491. if (np->source != Rect2()) {
  492. src_rect = Rect2(np->source.position.x * texpixel_size.width, np->source.position.y * texpixel_size.height, np->source.size.x * texpixel_size.width, np->source.size.y * texpixel_size.height);
  493. push_constant.color_texture_pixel_size[0] = 1.0 / np->source.size.width;
  494. push_constant.color_texture_pixel_size[1] = 1.0 / np->source.size.height;
  495. } else {
  496. src_rect = Rect2(0, 0, 1, 1);
  497. }
  498. }
  499. push_constant.modulation[0] = np->color.r * base_color.r;
  500. push_constant.modulation[1] = np->color.g * base_color.g;
  501. push_constant.modulation[2] = np->color.b * base_color.b;
  502. push_constant.modulation[3] = np->color.a * base_color.a;
  503. push_constant.src_rect[0] = src_rect.position.x;
  504. push_constant.src_rect[1] = src_rect.position.y;
  505. push_constant.src_rect[2] = src_rect.size.width;
  506. push_constant.src_rect[3] = src_rect.size.height;
  507. push_constant.dst_rect[0] = dst_rect.position.x;
  508. push_constant.dst_rect[1] = dst_rect.position.y;
  509. push_constant.dst_rect[2] = dst_rect.size.width;
  510. push_constant.dst_rect[3] = dst_rect.size.height;
  511. push_constant.flags |= int(np->axis_x) << FLAGS_NINEPATCH_H_MODE_SHIFT;
  512. push_constant.flags |= int(np->axis_y) << FLAGS_NINEPATCH_V_MODE_SHIFT;
  513. if (np->draw_center) {
  514. push_constant.flags |= FLAGS_NINEPACH_DRAW_CENTER;
  515. }
  516. push_constant.ninepatch_margins[0] = np->margin[SIDE_LEFT];
  517. push_constant.ninepatch_margins[1] = np->margin[SIDE_TOP];
  518. push_constant.ninepatch_margins[2] = np->margin[SIDE_RIGHT];
  519. push_constant.ninepatch_margins[3] = np->margin[SIDE_BOTTOM];
  520. RD::get_singleton()->draw_list_set_push_constant(p_draw_list, &push_constant, sizeof(PushConstant));
  521. RD::get_singleton()->draw_list_bind_index_array(p_draw_list, shader.quad_index_array);
  522. RD::get_singleton()->draw_list_draw(p_draw_list, true);
  523. // Restore if overridden.
  524. push_constant.color_texture_pixel_size[0] = texpixel_size.x;
  525. push_constant.color_texture_pixel_size[1] = texpixel_size.y;
  526. } break;
  527. case Item::Command::TYPE_POLYGON: {
  528. const Item::CommandPolygon *polygon = static_cast<const Item::CommandPolygon *>(c);
  529. PolygonBuffers *pb = polygon_buffers.polygons.getptr(polygon->polygon.polygon_id);
  530. ERR_CONTINUE(!pb);
  531. //bind pipeline
  532. {
  533. static const PipelineVariant variant[RS::PRIMITIVE_MAX] = { PIPELINE_VARIANT_ATTRIBUTE_POINTS, PIPELINE_VARIANT_ATTRIBUTE_LINES, PIPELINE_VARIANT_ATTRIBUTE_LINES_STRIP, PIPELINE_VARIANT_ATTRIBUTE_TRIANGLES, PIPELINE_VARIANT_ATTRIBUTE_TRIANGLE_STRIP };
  534. ERR_CONTINUE(polygon->primitive < 0 || polygon->primitive >= RS::PRIMITIVE_MAX);
  535. RID pipeline = pipeline_variants->variants[light_mode][variant[polygon->primitive]].get_render_pipeline(pb->vertex_format_id, p_framebuffer_format);
  536. RD::get_singleton()->draw_list_bind_render_pipeline(p_draw_list, pipeline);
  537. }
  538. if (polygon->primitive == RS::PRIMITIVE_LINES) {
  539. //not supported in most hardware, so pointless
  540. //RD::get_singleton()->draw_list_set_line_width(p_draw_list, polygon->line_width);
  541. }
  542. //bind textures
  543. _bind_canvas_texture(p_draw_list, polygon->texture, current_filter, current_repeat, last_texture, push_constant, texpixel_size);
  544. push_constant.modulation[0] = base_color.r;
  545. push_constant.modulation[1] = base_color.g;
  546. push_constant.modulation[2] = base_color.b;
  547. push_constant.modulation[3] = base_color.a;
  548. for (int j = 0; j < 4; j++) {
  549. push_constant.src_rect[j] = 0;
  550. push_constant.dst_rect[j] = 0;
  551. push_constant.ninepatch_margins[j] = 0;
  552. }
  553. RD::get_singleton()->draw_list_set_push_constant(p_draw_list, &push_constant, sizeof(PushConstant));
  554. RD::get_singleton()->draw_list_bind_vertex_array(p_draw_list, pb->vertex_array);
  555. if (pb->indices.is_valid()) {
  556. RD::get_singleton()->draw_list_bind_index_array(p_draw_list, pb->indices);
  557. }
  558. RD::get_singleton()->draw_list_draw(p_draw_list, pb->indices.is_valid());
  559. } break;
  560. case Item::Command::TYPE_PRIMITIVE: {
  561. const Item::CommandPrimitive *primitive = static_cast<const Item::CommandPrimitive *>(c);
  562. //bind pipeline
  563. {
  564. static const PipelineVariant variant[4] = { PIPELINE_VARIANT_PRIMITIVE_POINTS, PIPELINE_VARIANT_PRIMITIVE_LINES, PIPELINE_VARIANT_PRIMITIVE_TRIANGLES, PIPELINE_VARIANT_PRIMITIVE_TRIANGLES };
  565. ERR_CONTINUE(primitive->point_count == 0 || primitive->point_count > 4);
  566. RID pipeline = pipeline_variants->variants[light_mode][variant[primitive->point_count - 1]].get_render_pipeline(RD::INVALID_ID, p_framebuffer_format);
  567. RD::get_singleton()->draw_list_bind_render_pipeline(p_draw_list, pipeline);
  568. }
  569. //bind textures
  570. _bind_canvas_texture(p_draw_list, RID(), current_filter, current_repeat, last_texture, push_constant, texpixel_size);
  571. RD::get_singleton()->draw_list_bind_index_array(p_draw_list, primitive_arrays.index_array[MIN(3u, primitive->point_count) - 1]);
  572. for (uint32_t j = 0; j < MIN(3u, primitive->point_count); j++) {
  573. push_constant.points[j * 2 + 0] = primitive->points[j].x;
  574. push_constant.points[j * 2 + 1] = primitive->points[j].y;
  575. push_constant.uvs[j * 2 + 0] = primitive->uvs[j].x;
  576. push_constant.uvs[j * 2 + 1] = primitive->uvs[j].y;
  577. Color col = primitive->colors[j] * base_color;
  578. push_constant.colors[j * 2 + 0] = (uint32_t(Math::make_half_float(col.g)) << 16) | Math::make_half_float(col.r);
  579. push_constant.colors[j * 2 + 1] = (uint32_t(Math::make_half_float(col.a)) << 16) | Math::make_half_float(col.b);
  580. }
  581. RD::get_singleton()->draw_list_set_push_constant(p_draw_list, &push_constant, sizeof(PushConstant));
  582. RD::get_singleton()->draw_list_draw(p_draw_list, true);
  583. if (primitive->point_count == 4) {
  584. for (uint32_t j = 1; j < 3; j++) {
  585. //second half of triangle
  586. push_constant.points[j * 2 + 0] = primitive->points[j + 1].x;
  587. push_constant.points[j * 2 + 1] = primitive->points[j + 1].y;
  588. push_constant.uvs[j * 2 + 0] = primitive->uvs[j + 1].x;
  589. push_constant.uvs[j * 2 + 1] = primitive->uvs[j + 1].y;
  590. Color col = primitive->colors[j + 1] * base_color;
  591. push_constant.colors[j * 2 + 0] = (uint32_t(Math::make_half_float(col.g)) << 16) | Math::make_half_float(col.r);
  592. push_constant.colors[j * 2 + 1] = (uint32_t(Math::make_half_float(col.a)) << 16) | Math::make_half_float(col.b);
  593. }
  594. RD::get_singleton()->draw_list_set_push_constant(p_draw_list, &push_constant, sizeof(PushConstant));
  595. RD::get_singleton()->draw_list_draw(p_draw_list, true);
  596. }
  597. } break;
  598. case Item::Command::TYPE_MESH:
  599. case Item::Command::TYPE_MULTIMESH:
  600. case Item::Command::TYPE_PARTICLES: {
  601. RID mesh;
  602. RID mesh_instance;
  603. RID texture;
  604. Color modulate(1, 1, 1, 1);
  605. float world_backup[6];
  606. int instance_count = 1;
  607. for (int j = 0; j < 6; j++) {
  608. world_backup[j] = push_constant.world[j];
  609. }
  610. if (c->type == Item::Command::TYPE_MESH) {
  611. const Item::CommandMesh *m = static_cast<const Item::CommandMesh *>(c);
  612. mesh = m->mesh;
  613. mesh_instance = m->mesh_instance;
  614. texture = m->texture;
  615. modulate = m->modulate;
  616. _update_transform_2d_to_mat2x3(base_transform * draw_transform * m->transform, push_constant.world);
  617. } else if (c->type == Item::Command::TYPE_MULTIMESH) {
  618. const Item::CommandMultiMesh *mm = static_cast<const Item::CommandMultiMesh *>(c);
  619. RID multimesh = mm->multimesh;
  620. mesh = mesh_storage->multimesh_get_mesh(multimesh);
  621. texture = mm->texture;
  622. if (mesh_storage->multimesh_get_transform_format(multimesh) != RS::MULTIMESH_TRANSFORM_2D) {
  623. break;
  624. }
  625. instance_count = mesh_storage->multimesh_get_instances_to_draw(multimesh);
  626. if (instance_count == 0) {
  627. break;
  628. }
  629. RID uniform_set = mesh_storage->multimesh_get_2d_uniform_set(multimesh, shader.default_version_rd_shader, TRANSFORMS_UNIFORM_SET);
  630. RD::get_singleton()->draw_list_bind_uniform_set(p_draw_list, uniform_set, TRANSFORMS_UNIFORM_SET);
  631. push_constant.flags |= 1; //multimesh, trails disabled
  632. if (mesh_storage->multimesh_uses_colors(multimesh)) {
  633. push_constant.flags |= FLAGS_INSTANCING_HAS_COLORS;
  634. }
  635. if (mesh_storage->multimesh_uses_custom_data(multimesh)) {
  636. push_constant.flags |= FLAGS_INSTANCING_HAS_CUSTOM_DATA;
  637. }
  638. } else if (c->type == Item::Command::TYPE_PARTICLES) {
  639. const Item::CommandParticles *pt = static_cast<const Item::CommandParticles *>(c);
  640. ERR_BREAK(particles_storage->particles_get_mode(pt->particles) != RS::PARTICLES_MODE_2D);
  641. particles_storage->particles_request_process(pt->particles);
  642. if (particles_storage->particles_is_inactive(pt->particles)) {
  643. break;
  644. }
  645. RenderingServerDefault::redraw_request(); // active particles means redraw request
  646. bool local_coords = true;
  647. int dpc = particles_storage->particles_get_draw_passes(pt->particles);
  648. if (dpc == 0) {
  649. break; //nothing to draw
  650. }
  651. uint32_t divisor = 1;
  652. instance_count = particles_storage->particles_get_amount(pt->particles, divisor);
  653. RID uniform_set = particles_storage->particles_get_instance_buffer_uniform_set(pt->particles, shader.default_version_rd_shader, TRANSFORMS_UNIFORM_SET);
  654. RD::get_singleton()->draw_list_bind_uniform_set(p_draw_list, uniform_set, TRANSFORMS_UNIFORM_SET);
  655. push_constant.flags |= divisor;
  656. instance_count /= divisor;
  657. push_constant.flags |= FLAGS_INSTANCING_HAS_COLORS;
  658. push_constant.flags |= FLAGS_INSTANCING_HAS_CUSTOM_DATA;
  659. mesh = particles_storage->particles_get_draw_pass_mesh(pt->particles, 0); //higher ones are ignored
  660. texture = pt->texture;
  661. if (particles_storage->particles_has_collision(pt->particles) && texture_storage->render_target_is_sdf_enabled(p_render_target)) {
  662. //pass collision information
  663. Transform2D xform;
  664. if (local_coords) {
  665. xform = p_item->final_transform;
  666. } else {
  667. xform = p_canvas_transform_inverse;
  668. }
  669. RID sdf_texture = texture_storage->render_target_get_sdf_texture(p_render_target);
  670. Rect2 to_screen;
  671. {
  672. Rect2 sdf_rect = texture_storage->render_target_get_sdf_rect(p_render_target);
  673. to_screen.size = Vector2(1.0 / sdf_rect.size.width, 1.0 / sdf_rect.size.height);
  674. to_screen.position = -sdf_rect.position * to_screen.size;
  675. }
  676. particles_storage->particles_set_canvas_sdf_collision(pt->particles, true, xform, to_screen, sdf_texture);
  677. } else {
  678. particles_storage->particles_set_canvas_sdf_collision(pt->particles, false, Transform2D(), Rect2(), RID());
  679. }
  680. }
  681. if (mesh.is_null()) {
  682. break;
  683. }
  684. _bind_canvas_texture(p_draw_list, texture, current_filter, current_repeat, last_texture, push_constant, texpixel_size);
  685. uint32_t surf_count = mesh_storage->mesh_get_surface_count(mesh);
  686. static const PipelineVariant variant[RS::PRIMITIVE_MAX] = { PIPELINE_VARIANT_ATTRIBUTE_POINTS, PIPELINE_VARIANT_ATTRIBUTE_LINES, PIPELINE_VARIANT_ATTRIBUTE_LINES_STRIP, PIPELINE_VARIANT_ATTRIBUTE_TRIANGLES, PIPELINE_VARIANT_ATTRIBUTE_TRIANGLE_STRIP };
  687. push_constant.modulation[0] = base_color.r * modulate.r;
  688. push_constant.modulation[1] = base_color.g * modulate.g;
  689. push_constant.modulation[2] = base_color.b * modulate.b;
  690. push_constant.modulation[3] = base_color.a * modulate.a;
  691. for (int j = 0; j < 4; j++) {
  692. push_constant.src_rect[j] = 0;
  693. push_constant.dst_rect[j] = 0;
  694. push_constant.ninepatch_margins[j] = 0;
  695. }
  696. for (uint32_t j = 0; j < surf_count; j++) {
  697. void *surface = mesh_storage->mesh_get_surface(mesh, j);
  698. RS::PrimitiveType primitive = mesh_storage->mesh_surface_get_primitive(surface);
  699. ERR_CONTINUE(primitive < 0 || primitive >= RS::PRIMITIVE_MAX);
  700. uint32_t input_mask = pipeline_variants->variants[light_mode][variant[primitive]].get_vertex_input_mask();
  701. RID vertex_array;
  702. RD::VertexFormatID vertex_format = RD::INVALID_FORMAT_ID;
  703. if (mesh_instance.is_valid()) {
  704. mesh_storage->mesh_instance_surface_get_vertex_arrays_and_format(mesh_instance, j, input_mask, vertex_array, vertex_format);
  705. } else {
  706. mesh_storage->mesh_surface_get_vertex_arrays_and_format(surface, input_mask, vertex_array, vertex_format);
  707. }
  708. RID pipeline = pipeline_variants->variants[light_mode][variant[primitive]].get_render_pipeline(vertex_format, p_framebuffer_format);
  709. RD::get_singleton()->draw_list_bind_render_pipeline(p_draw_list, pipeline);
  710. RID index_array = mesh_storage->mesh_surface_get_index_array(surface, 0);
  711. if (index_array.is_valid()) {
  712. RD::get_singleton()->draw_list_bind_index_array(p_draw_list, index_array);
  713. }
  714. RD::get_singleton()->draw_list_bind_vertex_array(p_draw_list, vertex_array);
  715. RD::get_singleton()->draw_list_set_push_constant(p_draw_list, &push_constant, sizeof(PushConstant));
  716. RD::get_singleton()->draw_list_draw(p_draw_list, index_array.is_valid(), instance_count);
  717. }
  718. for (int j = 0; j < 6; j++) {
  719. push_constant.world[j] = world_backup[j];
  720. }
  721. } break;
  722. case Item::Command::TYPE_TRANSFORM: {
  723. const Item::CommandTransform *transform = static_cast<const Item::CommandTransform *>(c);
  724. draw_transform = transform->xform;
  725. _update_transform_2d_to_mat2x3(base_transform * transform->xform, push_constant.world);
  726. } break;
  727. case Item::Command::TYPE_CLIP_IGNORE: {
  728. const Item::CommandClipIgnore *ci = static_cast<const Item::CommandClipIgnore *>(c);
  729. if (current_clip) {
  730. if (ci->ignore != reclip) {
  731. if (ci->ignore) {
  732. RD::get_singleton()->draw_list_disable_scissor(p_draw_list);
  733. reclip = true;
  734. } else {
  735. RD::get_singleton()->draw_list_enable_scissor(p_draw_list, current_clip->final_clip_rect);
  736. reclip = false;
  737. }
  738. }
  739. }
  740. } break;
  741. case Item::Command::TYPE_ANIMATION_SLICE: {
  742. const Item::CommandAnimationSlice *as = static_cast<const Item::CommandAnimationSlice *>(c);
  743. double current_time = RendererCompositorRD::singleton->get_total_time();
  744. double local_time = Math::fposmod(current_time - as->offset, as->animation_length);
  745. skipping = !(local_time >= as->slice_begin && local_time < as->slice_end);
  746. RenderingServerDefault::redraw_request(); // animation visible means redraw request
  747. } break;
  748. }
  749. c = c->next;
  750. }
  751. if (current_clip && reclip) {
  752. //will make it re-enable clipping if needed afterwards
  753. current_clip = nullptr;
  754. }
  755. }
  756. RID RendererCanvasRenderRD::_create_base_uniform_set(RID p_to_render_target, bool p_backbuffer) {
  757. RendererRD::TextureStorage *texture_storage = RendererRD::TextureStorage::get_singleton();
  758. RendererRD::MaterialStorage *material_storage = RendererRD::MaterialStorage::get_singleton();
  759. //re create canvas state
  760. Vector<RD::Uniform> uniforms;
  761. {
  762. RD::Uniform u;
  763. u.uniform_type = RD::UNIFORM_TYPE_UNIFORM_BUFFER;
  764. u.binding = 1;
  765. u.append_id(state.canvas_state_buffer);
  766. uniforms.push_back(u);
  767. }
  768. {
  769. RD::Uniform u;
  770. u.uniform_type = RD::UNIFORM_TYPE_UNIFORM_BUFFER;
  771. u.binding = 2;
  772. u.append_id(state.lights_uniform_buffer);
  773. uniforms.push_back(u);
  774. }
  775. {
  776. RD::Uniform u;
  777. u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
  778. u.binding = 3;
  779. u.append_id(RendererRD::TextureStorage::get_singleton()->decal_atlas_get_texture());
  780. uniforms.push_back(u);
  781. }
  782. {
  783. RD::Uniform u;
  784. u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
  785. u.binding = 4;
  786. u.append_id(state.shadow_texture);
  787. uniforms.push_back(u);
  788. }
  789. {
  790. RD::Uniform u;
  791. u.uniform_type = RD::UNIFORM_TYPE_SAMPLER;
  792. u.binding = 5;
  793. u.append_id(state.shadow_sampler);
  794. uniforms.push_back(u);
  795. }
  796. {
  797. RD::Uniform u;
  798. u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
  799. u.binding = 6;
  800. RID screen;
  801. if (p_backbuffer) {
  802. screen = texture_storage->render_target_get_rd_texture(p_to_render_target);
  803. } else {
  804. screen = texture_storage->render_target_get_rd_backbuffer(p_to_render_target);
  805. if (screen.is_null()) { //unallocated backbuffer
  806. screen = RendererRD::TextureStorage::get_singleton()->texture_rd_get_default(RendererRD::TextureStorage::DEFAULT_RD_TEXTURE_WHITE);
  807. }
  808. }
  809. u.append_id(screen);
  810. uniforms.push_back(u);
  811. }
  812. {
  813. RD::Uniform u;
  814. u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
  815. u.binding = 7;
  816. RID sdf = texture_storage->render_target_get_sdf_texture(p_to_render_target);
  817. u.append_id(sdf);
  818. uniforms.push_back(u);
  819. }
  820. {
  821. //needs samplers for the material (uses custom textures) create them
  822. Vector<RID> ids;
  823. ids.resize(12);
  824. RID *ids_ptr = ids.ptrw();
  825. ids_ptr[0] = material_storage->sampler_rd_get_default(RS::CANVAS_ITEM_TEXTURE_FILTER_NEAREST, RS::CANVAS_ITEM_TEXTURE_REPEAT_DISABLED);
  826. ids_ptr[1] = material_storage->sampler_rd_get_default(RS::CANVAS_ITEM_TEXTURE_FILTER_LINEAR, RS::CANVAS_ITEM_TEXTURE_REPEAT_DISABLED);
  827. ids_ptr[2] = material_storage->sampler_rd_get_default(RS::CANVAS_ITEM_TEXTURE_FILTER_NEAREST_WITH_MIPMAPS, RS::CANVAS_ITEM_TEXTURE_REPEAT_DISABLED);
  828. ids_ptr[3] = material_storage->sampler_rd_get_default(RS::CANVAS_ITEM_TEXTURE_FILTER_LINEAR_WITH_MIPMAPS, RS::CANVAS_ITEM_TEXTURE_REPEAT_DISABLED);
  829. ids_ptr[4] = material_storage->sampler_rd_get_default(RS::CANVAS_ITEM_TEXTURE_FILTER_NEAREST_WITH_MIPMAPS_ANISOTROPIC, RS::CANVAS_ITEM_TEXTURE_REPEAT_DISABLED);
  830. ids_ptr[5] = material_storage->sampler_rd_get_default(RS::CANVAS_ITEM_TEXTURE_FILTER_LINEAR_WITH_MIPMAPS_ANISOTROPIC, RS::CANVAS_ITEM_TEXTURE_REPEAT_DISABLED);
  831. ids_ptr[6] = material_storage->sampler_rd_get_default(RS::CANVAS_ITEM_TEXTURE_FILTER_NEAREST, RS::CANVAS_ITEM_TEXTURE_REPEAT_ENABLED);
  832. ids_ptr[7] = material_storage->sampler_rd_get_default(RS::CANVAS_ITEM_TEXTURE_FILTER_LINEAR, RS::CANVAS_ITEM_TEXTURE_REPEAT_ENABLED);
  833. ids_ptr[8] = material_storage->sampler_rd_get_default(RS::CANVAS_ITEM_TEXTURE_FILTER_NEAREST_WITH_MIPMAPS, RS::CANVAS_ITEM_TEXTURE_REPEAT_ENABLED);
  834. ids_ptr[9] = material_storage->sampler_rd_get_default(RS::CANVAS_ITEM_TEXTURE_FILTER_LINEAR_WITH_MIPMAPS, RS::CANVAS_ITEM_TEXTURE_REPEAT_ENABLED);
  835. ids_ptr[10] = material_storage->sampler_rd_get_default(RS::CANVAS_ITEM_TEXTURE_FILTER_NEAREST_WITH_MIPMAPS_ANISOTROPIC, RS::CANVAS_ITEM_TEXTURE_REPEAT_ENABLED);
  836. ids_ptr[11] = material_storage->sampler_rd_get_default(RS::CANVAS_ITEM_TEXTURE_FILTER_LINEAR_WITH_MIPMAPS_ANISOTROPIC, RS::CANVAS_ITEM_TEXTURE_REPEAT_ENABLED);
  837. RD::Uniform u(RD::UNIFORM_TYPE_SAMPLER, 8, ids);
  838. uniforms.push_back(u);
  839. }
  840. {
  841. RD::Uniform u;
  842. u.uniform_type = RD::UNIFORM_TYPE_STORAGE_BUFFER;
  843. u.binding = 9;
  844. u.append_id(RendererRD::MaterialStorage::get_singleton()->global_shader_uniforms_get_storage_buffer());
  845. uniforms.push_back(u);
  846. }
  847. RID uniform_set = RD::get_singleton()->uniform_set_create(uniforms, shader.default_version_rd_shader, BASE_UNIFORM_SET);
  848. if (p_backbuffer) {
  849. texture_storage->render_target_set_backbuffer_uniform_set(p_to_render_target, uniform_set);
  850. } else {
  851. texture_storage->render_target_set_framebuffer_uniform_set(p_to_render_target, uniform_set);
  852. }
  853. return uniform_set;
  854. }
  855. void RendererCanvasRenderRD::_render_items(RID p_to_render_target, int p_item_count, const Transform2D &p_canvas_transform_inverse, Light *p_lights, bool p_to_backbuffer) {
  856. RendererRD::MaterialStorage *material_storage = RendererRD::MaterialStorage::get_singleton();
  857. RendererRD::TextureStorage *texture_storage = RendererRD::TextureStorage::get_singleton();
  858. Item *current_clip = nullptr;
  859. Transform2D canvas_transform_inverse = p_canvas_transform_inverse;
  860. RID framebuffer;
  861. RID fb_uniform_set;
  862. bool clear = false;
  863. Vector<Color> clear_colors;
  864. if (p_to_backbuffer) {
  865. framebuffer = texture_storage->render_target_get_rd_backbuffer_framebuffer(p_to_render_target);
  866. fb_uniform_set = texture_storage->render_target_get_backbuffer_uniform_set(p_to_render_target);
  867. } else {
  868. framebuffer = texture_storage->render_target_get_rd_framebuffer(p_to_render_target);
  869. if (texture_storage->render_target_is_clear_requested(p_to_render_target)) {
  870. clear = true;
  871. clear_colors.push_back(texture_storage->render_target_get_clear_request_color(p_to_render_target));
  872. texture_storage->render_target_disable_clear_request(p_to_render_target);
  873. }
  874. #ifndef _MSC_VER
  875. #warning TODO obtain from framebuffer format eventually when this is implemented
  876. #endif
  877. fb_uniform_set = texture_storage->render_target_get_framebuffer_uniform_set(p_to_render_target);
  878. }
  879. if (fb_uniform_set.is_null() || !RD::get_singleton()->uniform_set_is_valid(fb_uniform_set)) {
  880. fb_uniform_set = _create_base_uniform_set(p_to_render_target, p_to_backbuffer);
  881. }
  882. RD::FramebufferFormatID fb_format = RD::get_singleton()->framebuffer_get_format(framebuffer);
  883. RD::DrawListID draw_list = RD::get_singleton()->draw_list_begin(framebuffer, clear ? RD::INITIAL_ACTION_CLEAR : RD::INITIAL_ACTION_KEEP, RD::FINAL_ACTION_READ, RD::INITIAL_ACTION_KEEP, RD::FINAL_ACTION_DISCARD, clear_colors);
  884. RD::get_singleton()->draw_list_bind_uniform_set(draw_list, fb_uniform_set, BASE_UNIFORM_SET);
  885. RD::get_singleton()->draw_list_bind_uniform_set(draw_list, state.default_transforms_uniform_set, TRANSFORMS_UNIFORM_SET);
  886. RID prev_material;
  887. PipelineVariants *pipeline_variants = &shader.pipeline_variants;
  888. for (int i = 0; i < p_item_count; i++) {
  889. Item *ci = items[i];
  890. if (current_clip != ci->final_clip_owner) {
  891. current_clip = ci->final_clip_owner;
  892. //setup clip
  893. if (current_clip) {
  894. RD::get_singleton()->draw_list_enable_scissor(draw_list, current_clip->final_clip_rect);
  895. } else {
  896. RD::get_singleton()->draw_list_disable_scissor(draw_list);
  897. }
  898. }
  899. RID material = ci->material_owner == nullptr ? ci->material : ci->material_owner->material;
  900. if (material.is_null() && ci->canvas_group != nullptr) {
  901. material = default_canvas_group_material;
  902. }
  903. if (material != prev_material) {
  904. CanvasMaterialData *material_data = nullptr;
  905. if (material.is_valid()) {
  906. material_data = static_cast<CanvasMaterialData *>(material_storage->material_get_data(material, RendererRD::MaterialStorage::SHADER_TYPE_2D));
  907. }
  908. if (material_data) {
  909. if (material_data->shader_data->version.is_valid() && material_data->shader_data->valid) {
  910. pipeline_variants = &material_data->shader_data->pipeline_variants;
  911. // Update uniform set.
  912. if (material_data->uniform_set.is_valid() && RD::get_singleton()->uniform_set_is_valid(material_data->uniform_set)) { // Material may not have a uniform set.
  913. RD::get_singleton()->draw_list_bind_uniform_set(draw_list, material_data->uniform_set, MATERIAL_UNIFORM_SET);
  914. }
  915. } else {
  916. pipeline_variants = &shader.pipeline_variants;
  917. }
  918. } else {
  919. pipeline_variants = &shader.pipeline_variants;
  920. }
  921. }
  922. _render_item(draw_list, p_to_render_target, ci, fb_format, canvas_transform_inverse, current_clip, p_lights, pipeline_variants);
  923. prev_material = material;
  924. }
  925. RD::get_singleton()->draw_list_end();
  926. }
  927. void RendererCanvasRenderRD::canvas_render_items(RID p_to_render_target, Item *p_item_list, const Color &p_modulate, Light *p_light_list, Light *p_directional_light_list, const Transform2D &p_canvas_transform, RenderingServer::CanvasItemTextureFilter p_default_filter, RenderingServer::CanvasItemTextureRepeat p_default_repeat, bool p_snap_2d_vertices_to_pixel, bool &r_sdf_used) {
  928. RendererRD::TextureStorage *texture_storage = RendererRD::TextureStorage::get_singleton();
  929. RendererRD::MaterialStorage *material_storage = RendererRD::MaterialStorage::get_singleton();
  930. RendererRD::MeshStorage *mesh_storage = RendererRD::MeshStorage::get_singleton();
  931. r_sdf_used = false;
  932. int item_count = 0;
  933. //setup canvas state uniforms if needed
  934. Transform2D canvas_transform_inverse = p_canvas_transform.affine_inverse();
  935. //setup directional lights if exist
  936. uint32_t light_count = 0;
  937. uint32_t directional_light_count = 0;
  938. {
  939. Light *l = p_directional_light_list;
  940. uint32_t index = 0;
  941. while (l) {
  942. if (index == state.max_lights_per_render) {
  943. l->render_index_cache = -1;
  944. l = l->next_ptr;
  945. continue;
  946. }
  947. CanvasLight *clight = canvas_light_owner.get_or_null(l->light_internal);
  948. if (!clight) { //unused or invalid texture
  949. l->render_index_cache = -1;
  950. l = l->next_ptr;
  951. ERR_CONTINUE(!clight);
  952. }
  953. Vector2 canvas_light_dir = l->xform_cache.columns[1].normalized();
  954. state.light_uniforms[index].position[0] = -canvas_light_dir.x;
  955. state.light_uniforms[index].position[1] = -canvas_light_dir.y;
  956. _update_transform_2d_to_mat2x4(clight->shadow.directional_xform, state.light_uniforms[index].shadow_matrix);
  957. state.light_uniforms[index].height = l->height; //0..1 here
  958. for (int i = 0; i < 4; i++) {
  959. state.light_uniforms[index].shadow_color[i] = uint8_t(CLAMP(int32_t(l->shadow_color[i] * 255.0), 0, 255));
  960. state.light_uniforms[index].color[i] = l->color[i];
  961. }
  962. state.light_uniforms[index].color[3] = l->energy; //use alpha for energy, so base color can go separate
  963. if (state.shadow_fb.is_valid()) {
  964. state.light_uniforms[index].shadow_pixel_size = (1.0 / state.shadow_texture_size) * (1.0 + l->shadow_smooth);
  965. state.light_uniforms[index].shadow_z_far_inv = 1.0 / clight->shadow.z_far;
  966. state.light_uniforms[index].shadow_y_ofs = clight->shadow.y_offset;
  967. } else {
  968. state.light_uniforms[index].shadow_pixel_size = 1.0;
  969. state.light_uniforms[index].shadow_z_far_inv = 1.0;
  970. state.light_uniforms[index].shadow_y_ofs = 0;
  971. }
  972. state.light_uniforms[index].flags = l->blend_mode << LIGHT_FLAGS_BLEND_SHIFT;
  973. state.light_uniforms[index].flags |= l->shadow_filter << LIGHT_FLAGS_FILTER_SHIFT;
  974. if (clight->shadow.enabled) {
  975. state.light_uniforms[index].flags |= LIGHT_FLAGS_HAS_SHADOW;
  976. }
  977. l->render_index_cache = index;
  978. index++;
  979. l = l->next_ptr;
  980. }
  981. light_count = index;
  982. directional_light_count = light_count;
  983. using_directional_lights = directional_light_count > 0;
  984. }
  985. //setup lights if exist
  986. {
  987. Light *l = p_light_list;
  988. uint32_t index = light_count;
  989. while (l) {
  990. if (index == state.max_lights_per_render) {
  991. l->render_index_cache = -1;
  992. l = l->next_ptr;
  993. continue;
  994. }
  995. CanvasLight *clight = canvas_light_owner.get_or_null(l->light_internal);
  996. if (!clight) { //unused or invalid texture
  997. l->render_index_cache = -1;
  998. l = l->next_ptr;
  999. ERR_CONTINUE(!clight);
  1000. }
  1001. Transform2D to_light_xform = (p_canvas_transform * l->light_shader_xform).affine_inverse();
  1002. Vector2 canvas_light_pos = p_canvas_transform.xform(l->xform.get_origin()); //convert light position to canvas coordinates, as all computation is done in canvas coords to avoid precision loss
  1003. state.light_uniforms[index].position[0] = canvas_light_pos.x;
  1004. state.light_uniforms[index].position[1] = canvas_light_pos.y;
  1005. _update_transform_2d_to_mat2x4(to_light_xform, state.light_uniforms[index].matrix);
  1006. _update_transform_2d_to_mat2x4(l->xform_cache.affine_inverse(), state.light_uniforms[index].shadow_matrix);
  1007. state.light_uniforms[index].height = l->height * (p_canvas_transform.columns[0].length() + p_canvas_transform.columns[1].length()) * 0.5; //approximate height conversion to the canvas size, since all calculations are done in canvas coords to avoid precision loss
  1008. for (int i = 0; i < 4; i++) {
  1009. state.light_uniforms[index].shadow_color[i] = uint8_t(CLAMP(int32_t(l->shadow_color[i] * 255.0), 0, 255));
  1010. state.light_uniforms[index].color[i] = l->color[i];
  1011. }
  1012. state.light_uniforms[index].color[3] = l->energy; //use alpha for energy, so base color can go separate
  1013. if (state.shadow_fb.is_valid()) {
  1014. state.light_uniforms[index].shadow_pixel_size = (1.0 / state.shadow_texture_size) * (1.0 + l->shadow_smooth);
  1015. state.light_uniforms[index].shadow_z_far_inv = 1.0 / clight->shadow.z_far;
  1016. state.light_uniforms[index].shadow_y_ofs = clight->shadow.y_offset;
  1017. } else {
  1018. state.light_uniforms[index].shadow_pixel_size = 1.0;
  1019. state.light_uniforms[index].shadow_z_far_inv = 1.0;
  1020. state.light_uniforms[index].shadow_y_ofs = 0;
  1021. }
  1022. state.light_uniforms[index].flags = l->blend_mode << LIGHT_FLAGS_BLEND_SHIFT;
  1023. state.light_uniforms[index].flags |= l->shadow_filter << LIGHT_FLAGS_FILTER_SHIFT;
  1024. if (clight->shadow.enabled) {
  1025. state.light_uniforms[index].flags |= LIGHT_FLAGS_HAS_SHADOW;
  1026. }
  1027. if (clight->texture.is_valid()) {
  1028. Rect2 atlas_rect = RendererRD::TextureStorage::get_singleton()->decal_atlas_get_texture_rect(clight->texture);
  1029. state.light_uniforms[index].atlas_rect[0] = atlas_rect.position.x;
  1030. state.light_uniforms[index].atlas_rect[1] = atlas_rect.position.y;
  1031. state.light_uniforms[index].atlas_rect[2] = atlas_rect.size.width;
  1032. state.light_uniforms[index].atlas_rect[3] = atlas_rect.size.height;
  1033. } else {
  1034. state.light_uniforms[index].atlas_rect[0] = 0;
  1035. state.light_uniforms[index].atlas_rect[1] = 0;
  1036. state.light_uniforms[index].atlas_rect[2] = 0;
  1037. state.light_uniforms[index].atlas_rect[3] = 0;
  1038. }
  1039. l->render_index_cache = index;
  1040. index++;
  1041. l = l->next_ptr;
  1042. }
  1043. light_count = index;
  1044. }
  1045. if (light_count > 0) {
  1046. RD::get_singleton()->buffer_update(state.lights_uniform_buffer, 0, sizeof(LightUniform) * light_count, &state.light_uniforms[0]);
  1047. }
  1048. {
  1049. //update canvas state uniform buffer
  1050. State::Buffer state_buffer;
  1051. Size2i ssize = texture_storage->render_target_get_size(p_to_render_target);
  1052. Transform3D screen_transform;
  1053. screen_transform.translate_local(-(ssize.width / 2.0f), -(ssize.height / 2.0f), 0.0f);
  1054. screen_transform.scale(Vector3(2.0f / ssize.width, 2.0f / ssize.height, 1.0f));
  1055. _update_transform_to_mat4(screen_transform, state_buffer.screen_transform);
  1056. _update_transform_2d_to_mat4(p_canvas_transform, state_buffer.canvas_transform);
  1057. Transform2D normal_transform = p_canvas_transform;
  1058. normal_transform.columns[0].normalize();
  1059. normal_transform.columns[1].normalize();
  1060. normal_transform.columns[2] = Vector2();
  1061. _update_transform_2d_to_mat4(normal_transform, state_buffer.canvas_normal_transform);
  1062. state_buffer.canvas_modulate[0] = p_modulate.r;
  1063. state_buffer.canvas_modulate[1] = p_modulate.g;
  1064. state_buffer.canvas_modulate[2] = p_modulate.b;
  1065. state_buffer.canvas_modulate[3] = p_modulate.a;
  1066. Size2 render_target_size = texture_storage->render_target_get_size(p_to_render_target);
  1067. state_buffer.screen_pixel_size[0] = 1.0 / render_target_size.x;
  1068. state_buffer.screen_pixel_size[1] = 1.0 / render_target_size.y;
  1069. state_buffer.time = state.time;
  1070. state_buffer.use_pixel_snap = p_snap_2d_vertices_to_pixel;
  1071. state_buffer.directional_light_count = directional_light_count;
  1072. Vector2 canvas_scale = p_canvas_transform.get_scale();
  1073. state_buffer.sdf_to_screen[0] = render_target_size.width / canvas_scale.x;
  1074. state_buffer.sdf_to_screen[1] = render_target_size.height / canvas_scale.y;
  1075. state_buffer.screen_to_sdf[0] = 1.0 / state_buffer.sdf_to_screen[0];
  1076. state_buffer.screen_to_sdf[1] = 1.0 / state_buffer.sdf_to_screen[1];
  1077. Rect2 sdf_rect = texture_storage->render_target_get_sdf_rect(p_to_render_target);
  1078. Rect2 sdf_tex_rect(sdf_rect.position / canvas_scale, sdf_rect.size / canvas_scale);
  1079. state_buffer.sdf_to_tex[0] = 1.0 / sdf_tex_rect.size.width;
  1080. state_buffer.sdf_to_tex[1] = 1.0 / sdf_tex_rect.size.height;
  1081. state_buffer.sdf_to_tex[2] = -sdf_tex_rect.position.x / sdf_tex_rect.size.width;
  1082. state_buffer.sdf_to_tex[3] = -sdf_tex_rect.position.y / sdf_tex_rect.size.height;
  1083. //print_line("w: " + itos(ssize.width) + " s: " + rtos(canvas_scale));
  1084. state_buffer.tex_to_sdf = 1.0 / ((canvas_scale.x + canvas_scale.y) * 0.5);
  1085. RD::get_singleton()->buffer_update(state.canvas_state_buffer, 0, sizeof(State::Buffer), &state_buffer);
  1086. }
  1087. { //default filter/repeat
  1088. default_filter = p_default_filter;
  1089. default_repeat = p_default_repeat;
  1090. }
  1091. Item *ci = p_item_list;
  1092. //fill the list until rendering is possible.
  1093. bool material_screen_texture_cached = false;
  1094. bool material_screen_texture_mipmaps_cached = false;
  1095. Rect2 back_buffer_rect;
  1096. bool backbuffer_copy = false;
  1097. bool backbuffer_gen_mipmaps = false;
  1098. Item *canvas_group_owner = nullptr;
  1099. bool update_skeletons = false;
  1100. bool time_used = false;
  1101. bool backbuffer_cleared = false;
  1102. while (ci) {
  1103. if (ci->copy_back_buffer && canvas_group_owner == nullptr) {
  1104. backbuffer_copy = true;
  1105. if (ci->copy_back_buffer->full) {
  1106. back_buffer_rect = Rect2();
  1107. } else {
  1108. back_buffer_rect = ci->copy_back_buffer->rect;
  1109. }
  1110. }
  1111. RID material = ci->material_owner == nullptr ? ci->material : ci->material_owner->material;
  1112. if (material.is_valid()) {
  1113. CanvasMaterialData *md = static_cast<CanvasMaterialData *>(material_storage->material_get_data(material, RendererRD::MaterialStorage::SHADER_TYPE_2D));
  1114. if (md && md->shader_data->valid) {
  1115. if (md->shader_data->uses_screen_texture && canvas_group_owner == nullptr) {
  1116. if (!material_screen_texture_cached) {
  1117. backbuffer_copy = true;
  1118. back_buffer_rect = Rect2();
  1119. backbuffer_gen_mipmaps = md->shader_data->uses_screen_texture_mipmaps;
  1120. } else if (!material_screen_texture_mipmaps_cached) {
  1121. backbuffer_gen_mipmaps = md->shader_data->uses_screen_texture_mipmaps;
  1122. }
  1123. }
  1124. if (md->shader_data->uses_sdf) {
  1125. r_sdf_used = true;
  1126. }
  1127. if (md->shader_data->uses_time) {
  1128. time_used = true;
  1129. }
  1130. }
  1131. }
  1132. if (ci->skeleton.is_valid()) {
  1133. const Item::Command *c = ci->commands;
  1134. while (c) {
  1135. if (c->type == Item::Command::TYPE_MESH) {
  1136. const Item::CommandMesh *cm = static_cast<const Item::CommandMesh *>(c);
  1137. if (cm->mesh_instance.is_valid()) {
  1138. mesh_storage->mesh_instance_check_for_update(cm->mesh_instance);
  1139. update_skeletons = true;
  1140. }
  1141. }
  1142. c = c->next;
  1143. }
  1144. }
  1145. if (ci->canvas_group_owner != nullptr) {
  1146. if (canvas_group_owner == nullptr) {
  1147. // Canvas group begins here, render until before this item
  1148. if (update_skeletons) {
  1149. mesh_storage->update_mesh_instances();
  1150. update_skeletons = false;
  1151. }
  1152. _render_items(p_to_render_target, item_count, canvas_transform_inverse, p_light_list);
  1153. item_count = 0;
  1154. Rect2i group_rect = ci->canvas_group_owner->global_rect_cache;
  1155. if (ci->canvas_group_owner->canvas_group->mode == RS::CANVAS_GROUP_MODE_OPAQUE) {
  1156. texture_storage->render_target_copy_to_back_buffer(p_to_render_target, group_rect, false);
  1157. } else if (!backbuffer_cleared) {
  1158. texture_storage->render_target_clear_back_buffer(p_to_render_target, Rect2i(), Color(0, 0, 0, 0));
  1159. backbuffer_cleared = true;
  1160. }
  1161. backbuffer_copy = false;
  1162. canvas_group_owner = ci->canvas_group_owner; //continue until owner found
  1163. }
  1164. ci->canvas_group_owner = nullptr; //must be cleared
  1165. }
  1166. if (!backbuffer_cleared && canvas_group_owner == nullptr && ci->canvas_group != nullptr && !backbuffer_copy) {
  1167. texture_storage->render_target_clear_back_buffer(p_to_render_target, Rect2i(), Color(0, 0, 0, 0));
  1168. backbuffer_cleared = true;
  1169. }
  1170. if (ci == canvas_group_owner) {
  1171. if (update_skeletons) {
  1172. mesh_storage->update_mesh_instances();
  1173. update_skeletons = false;
  1174. }
  1175. _render_items(p_to_render_target, item_count, canvas_transform_inverse, p_light_list, true);
  1176. item_count = 0;
  1177. if (ci->canvas_group->blur_mipmaps) {
  1178. texture_storage->render_target_gen_back_buffer_mipmaps(p_to_render_target, ci->global_rect_cache);
  1179. }
  1180. canvas_group_owner = nullptr;
  1181. }
  1182. if (backbuffer_copy) {
  1183. //render anything pending, including clearing if no items
  1184. if (update_skeletons) {
  1185. mesh_storage->update_mesh_instances();
  1186. update_skeletons = false;
  1187. }
  1188. _render_items(p_to_render_target, item_count, canvas_transform_inverse, p_light_list);
  1189. item_count = 0;
  1190. texture_storage->render_target_copy_to_back_buffer(p_to_render_target, back_buffer_rect, backbuffer_gen_mipmaps);
  1191. backbuffer_copy = false;
  1192. backbuffer_gen_mipmaps = false;
  1193. material_screen_texture_cached = true; // After a backbuffer copy, screen texture makes no further copies.
  1194. material_screen_texture_mipmaps_cached = backbuffer_gen_mipmaps;
  1195. }
  1196. if (backbuffer_gen_mipmaps) {
  1197. texture_storage->render_target_gen_back_buffer_mipmaps(p_to_render_target, back_buffer_rect);
  1198. backbuffer_gen_mipmaps = false;
  1199. material_screen_texture_mipmaps_cached = true;
  1200. }
  1201. items[item_count++] = ci;
  1202. if (!ci->next || item_count == MAX_RENDER_ITEMS - 1) {
  1203. if (update_skeletons) {
  1204. mesh_storage->update_mesh_instances();
  1205. update_skeletons = false;
  1206. }
  1207. _render_items(p_to_render_target, item_count, canvas_transform_inverse, p_light_list);
  1208. //then reset
  1209. item_count = 0;
  1210. }
  1211. ci = ci->next;
  1212. }
  1213. if (time_used) {
  1214. RenderingServerDefault::redraw_request();
  1215. }
  1216. }
  1217. RID RendererCanvasRenderRD::light_create() {
  1218. CanvasLight canvas_light;
  1219. return canvas_light_owner.make_rid(canvas_light);
  1220. }
  1221. void RendererCanvasRenderRD::light_set_texture(RID p_rid, RID p_texture) {
  1222. RendererRD::TextureStorage *texture_storage = RendererRD::TextureStorage::get_singleton();
  1223. CanvasLight *cl = canvas_light_owner.get_or_null(p_rid);
  1224. ERR_FAIL_COND(!cl);
  1225. if (cl->texture == p_texture) {
  1226. return;
  1227. }
  1228. if (cl->texture.is_valid()) {
  1229. texture_storage->texture_remove_from_decal_atlas(cl->texture);
  1230. }
  1231. cl->texture = p_texture;
  1232. if (cl->texture.is_valid()) {
  1233. texture_storage->texture_add_to_decal_atlas(cl->texture);
  1234. }
  1235. }
  1236. void RendererCanvasRenderRD::light_set_use_shadow(RID p_rid, bool p_enable) {
  1237. CanvasLight *cl = canvas_light_owner.get_or_null(p_rid);
  1238. ERR_FAIL_COND(!cl);
  1239. cl->shadow.enabled = p_enable;
  1240. }
  1241. void RendererCanvasRenderRD::_update_shadow_atlas() {
  1242. if (state.shadow_fb == RID()) {
  1243. //ah, we lack the shadow texture..
  1244. RD::get_singleton()->free(state.shadow_texture); //erase placeholder
  1245. Vector<RID> fb_textures;
  1246. { //texture
  1247. RD::TextureFormat tf;
  1248. tf.texture_type = RD::TEXTURE_TYPE_2D;
  1249. tf.width = state.shadow_texture_size;
  1250. tf.height = state.max_lights_per_render * 2;
  1251. tf.usage_bits = RD::TEXTURE_USAGE_COLOR_ATTACHMENT_BIT | RD::TEXTURE_USAGE_SAMPLING_BIT;
  1252. tf.format = RD::DATA_FORMAT_R32_SFLOAT;
  1253. state.shadow_texture = RD::get_singleton()->texture_create(tf, RD::TextureView());
  1254. fb_textures.push_back(state.shadow_texture);
  1255. }
  1256. {
  1257. RD::TextureFormat tf;
  1258. tf.texture_type = RD::TEXTURE_TYPE_2D;
  1259. tf.width = state.shadow_texture_size;
  1260. tf.height = state.max_lights_per_render * 2;
  1261. tf.usage_bits = RD::TEXTURE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT;
  1262. tf.format = RD::DATA_FORMAT_D32_SFLOAT;
  1263. //chunks to write
  1264. state.shadow_depth_texture = RD::get_singleton()->texture_create(tf, RD::TextureView());
  1265. fb_textures.push_back(state.shadow_depth_texture);
  1266. }
  1267. state.shadow_fb = RD::get_singleton()->framebuffer_create(fb_textures);
  1268. }
  1269. }
  1270. void RendererCanvasRenderRD::light_update_shadow(RID p_rid, int p_shadow_index, const Transform2D &p_light_xform, int p_light_mask, float p_near, float p_far, LightOccluderInstance *p_occluders) {
  1271. CanvasLight *cl = canvas_light_owner.get_or_null(p_rid);
  1272. ERR_FAIL_COND(!cl->shadow.enabled);
  1273. _update_shadow_atlas();
  1274. cl->shadow.z_far = p_far;
  1275. cl->shadow.y_offset = float(p_shadow_index * 2 + 1) / float(state.max_lights_per_render * 2);
  1276. Vector<Color> cc;
  1277. cc.push_back(Color(p_far, p_far, p_far, 1.0));
  1278. for (int i = 0; i < 4; i++) {
  1279. //make sure it remains orthogonal, makes easy to read angle later
  1280. //light.basis.scale(Vector3(to_light.elements[0].length(),to_light.elements[1].length(),1));
  1281. Rect2i rect((state.shadow_texture_size / 4) * i, p_shadow_index * 2, (state.shadow_texture_size / 4), 2);
  1282. RD::InitialAction initial_action = i == 0 ? RD::INITIAL_ACTION_CLEAR_REGION : RD::INITIAL_ACTION_CLEAR_REGION_CONTINUE;
  1283. RD::DrawListID draw_list = RD::get_singleton()->draw_list_begin(state.shadow_fb, initial_action, i != 3 ? RD::FINAL_ACTION_CONTINUE : RD::FINAL_ACTION_READ, initial_action, RD::FINAL_ACTION_DISCARD, cc, 1.0, 0, rect);
  1284. Projection projection;
  1285. {
  1286. real_t fov = 90;
  1287. real_t nearp = p_near;
  1288. real_t farp = p_far;
  1289. real_t aspect = 1.0;
  1290. real_t ymax = nearp * Math::tan(Math::deg_to_rad(fov * 0.5));
  1291. real_t ymin = -ymax;
  1292. real_t xmin = ymin * aspect;
  1293. real_t xmax = ymax * aspect;
  1294. projection.set_frustum(xmin, xmax, ymin, ymax, nearp, farp);
  1295. }
  1296. Vector3 cam_target = Basis(Vector3(0, 0, Math_TAU * ((i + 3) / 4.0))).xform(Vector3(0, 1, 0));
  1297. projection = projection * Projection(Transform3D().looking_at(cam_target, Vector3(0, 0, -1)).affine_inverse());
  1298. ShadowRenderPushConstant push_constant;
  1299. for (int y = 0; y < 4; y++) {
  1300. for (int x = 0; x < 4; x++) {
  1301. push_constant.projection[y * 4 + x] = projection.matrix[y][x];
  1302. }
  1303. }
  1304. static const Vector2 directions[4] = { Vector2(1, 0), Vector2(0, 1), Vector2(-1, 0), Vector2(0, -1) };
  1305. push_constant.direction[0] = directions[i].x;
  1306. push_constant.direction[1] = directions[i].y;
  1307. push_constant.z_far = p_far;
  1308. push_constant.pad = 0;
  1309. LightOccluderInstance *instance = p_occluders;
  1310. while (instance) {
  1311. OccluderPolygon *co = occluder_polygon_owner.get_or_null(instance->occluder);
  1312. if (!co || co->index_array.is_null() || !(p_light_mask & instance->light_mask)) {
  1313. instance = instance->next;
  1314. continue;
  1315. }
  1316. _update_transform_2d_to_mat2x4(p_light_xform * instance->xform_cache, push_constant.modelview);
  1317. RD::get_singleton()->draw_list_bind_render_pipeline(draw_list, shadow_render.render_pipelines[co->cull_mode]);
  1318. RD::get_singleton()->draw_list_bind_vertex_array(draw_list, co->vertex_array);
  1319. RD::get_singleton()->draw_list_bind_index_array(draw_list, co->index_array);
  1320. RD::get_singleton()->draw_list_set_push_constant(draw_list, &push_constant, sizeof(ShadowRenderPushConstant));
  1321. RD::get_singleton()->draw_list_draw(draw_list, true);
  1322. instance = instance->next;
  1323. }
  1324. RD::get_singleton()->draw_list_end();
  1325. }
  1326. }
  1327. void RendererCanvasRenderRD::light_update_directional_shadow(RID p_rid, int p_shadow_index, const Transform2D &p_light_xform, int p_light_mask, float p_cull_distance, const Rect2 &p_clip_rect, LightOccluderInstance *p_occluders) {
  1328. CanvasLight *cl = canvas_light_owner.get_or_null(p_rid);
  1329. ERR_FAIL_COND(!cl->shadow.enabled);
  1330. _update_shadow_atlas();
  1331. Vector2 light_dir = p_light_xform.columns[1].normalized();
  1332. Vector2 center = p_clip_rect.get_center();
  1333. float to_edge_distance = ABS(light_dir.dot(p_clip_rect.get_support(light_dir)) - light_dir.dot(center));
  1334. Vector2 from_pos = center - light_dir * (to_edge_distance + p_cull_distance);
  1335. float distance = to_edge_distance * 2.0 + p_cull_distance;
  1336. float half_size = p_clip_rect.size.length() * 0.5; //shadow length, must keep this no matter the angle
  1337. cl->shadow.z_far = distance;
  1338. cl->shadow.y_offset = float(p_shadow_index * 2 + 1) / float(state.max_lights_per_render * 2);
  1339. Transform2D to_light_xform;
  1340. to_light_xform[2] = from_pos;
  1341. to_light_xform[1] = light_dir;
  1342. to_light_xform[0] = -light_dir.orthogonal();
  1343. to_light_xform.invert();
  1344. Vector<Color> cc;
  1345. cc.push_back(Color(1, 1, 1, 1));
  1346. Rect2i rect(0, p_shadow_index * 2, state.shadow_texture_size, 2);
  1347. RD::DrawListID draw_list = RD::get_singleton()->draw_list_begin(state.shadow_fb, RD::INITIAL_ACTION_CLEAR_REGION, RD::FINAL_ACTION_READ, RD::INITIAL_ACTION_CLEAR_REGION, RD::FINAL_ACTION_DISCARD, cc, 1.0, 0, rect);
  1348. Projection projection;
  1349. projection.set_orthogonal(-half_size, half_size, -0.5, 0.5, 0.0, distance);
  1350. projection = projection * Projection(Transform3D().looking_at(Vector3(0, 1, 0), Vector3(0, 0, -1)).affine_inverse());
  1351. ShadowRenderPushConstant push_constant;
  1352. for (int y = 0; y < 4; y++) {
  1353. for (int x = 0; x < 4; x++) {
  1354. push_constant.projection[y * 4 + x] = projection.matrix[y][x];
  1355. }
  1356. }
  1357. push_constant.direction[0] = 0.0;
  1358. push_constant.direction[1] = 1.0;
  1359. push_constant.z_far = distance;
  1360. push_constant.pad = 0;
  1361. LightOccluderInstance *instance = p_occluders;
  1362. while (instance) {
  1363. OccluderPolygon *co = occluder_polygon_owner.get_or_null(instance->occluder);
  1364. if (!co || co->index_array.is_null() || !(p_light_mask & instance->light_mask)) {
  1365. instance = instance->next;
  1366. continue;
  1367. }
  1368. _update_transform_2d_to_mat2x4(to_light_xform * instance->xform_cache, push_constant.modelview);
  1369. RD::get_singleton()->draw_list_bind_render_pipeline(draw_list, shadow_render.render_pipelines[co->cull_mode]);
  1370. RD::get_singleton()->draw_list_bind_vertex_array(draw_list, co->vertex_array);
  1371. RD::get_singleton()->draw_list_bind_index_array(draw_list, co->index_array);
  1372. RD::get_singleton()->draw_list_set_push_constant(draw_list, &push_constant, sizeof(ShadowRenderPushConstant));
  1373. RD::get_singleton()->draw_list_draw(draw_list, true);
  1374. instance = instance->next;
  1375. }
  1376. RD::get_singleton()->draw_list_end();
  1377. Transform2D to_shadow;
  1378. to_shadow.columns[0].x = 1.0 / -(half_size * 2.0);
  1379. to_shadow.columns[2].x = 0.5;
  1380. cl->shadow.directional_xform = to_shadow * to_light_xform;
  1381. }
  1382. void RendererCanvasRenderRD::render_sdf(RID p_render_target, LightOccluderInstance *p_occluders) {
  1383. RendererRD::TextureStorage *texture_storage = RendererRD::TextureStorage::get_singleton();
  1384. RID fb = texture_storage->render_target_get_sdf_framebuffer(p_render_target);
  1385. Rect2i rect = texture_storage->render_target_get_sdf_rect(p_render_target);
  1386. Transform2D to_sdf;
  1387. to_sdf.columns[0] *= rect.size.width;
  1388. to_sdf.columns[1] *= rect.size.height;
  1389. to_sdf.columns[2] = rect.position;
  1390. Transform2D to_clip;
  1391. to_clip.columns[0] *= 2.0;
  1392. to_clip.columns[1] *= 2.0;
  1393. to_clip.columns[2] = -Vector2(1.0, 1.0);
  1394. to_clip = to_clip * to_sdf.affine_inverse();
  1395. Vector<Color> cc;
  1396. cc.push_back(Color(0, 0, 0, 0));
  1397. RD::DrawListID draw_list = RD::get_singleton()->draw_list_begin(fb, RD::INITIAL_ACTION_CLEAR, RD::FINAL_ACTION_READ, RD::INITIAL_ACTION_CLEAR, RD::FINAL_ACTION_DISCARD, cc);
  1398. Projection projection;
  1399. ShadowRenderPushConstant push_constant;
  1400. for (int y = 0; y < 4; y++) {
  1401. for (int x = 0; x < 4; x++) {
  1402. push_constant.projection[y * 4 + x] = projection.matrix[y][x];
  1403. }
  1404. }
  1405. push_constant.direction[0] = 0.0;
  1406. push_constant.direction[1] = 0.0;
  1407. push_constant.z_far = 0;
  1408. push_constant.pad = 0;
  1409. LightOccluderInstance *instance = p_occluders;
  1410. while (instance) {
  1411. OccluderPolygon *co = occluder_polygon_owner.get_or_null(instance->occluder);
  1412. if (!co || co->sdf_index_array.is_null()) {
  1413. instance = instance->next;
  1414. continue;
  1415. }
  1416. _update_transform_2d_to_mat2x4(to_clip * instance->xform_cache, push_constant.modelview);
  1417. RD::get_singleton()->draw_list_bind_render_pipeline(draw_list, shadow_render.sdf_render_pipelines[co->sdf_is_lines ? SHADOW_RENDER_SDF_LINES : SHADOW_RENDER_SDF_TRIANGLES]);
  1418. RD::get_singleton()->draw_list_bind_vertex_array(draw_list, co->sdf_vertex_array);
  1419. RD::get_singleton()->draw_list_bind_index_array(draw_list, co->sdf_index_array);
  1420. RD::get_singleton()->draw_list_set_push_constant(draw_list, &push_constant, sizeof(ShadowRenderPushConstant));
  1421. RD::get_singleton()->draw_list_draw(draw_list, true);
  1422. instance = instance->next;
  1423. }
  1424. RD::get_singleton()->draw_list_end();
  1425. texture_storage->render_target_sdf_process(p_render_target); //done rendering, process it
  1426. }
  1427. RID RendererCanvasRenderRD::occluder_polygon_create() {
  1428. OccluderPolygon occluder;
  1429. occluder.line_point_count = 0;
  1430. occluder.sdf_point_count = 0;
  1431. occluder.sdf_index_count = 0;
  1432. occluder.cull_mode = RS::CANVAS_OCCLUDER_POLYGON_CULL_DISABLED;
  1433. return occluder_polygon_owner.make_rid(occluder);
  1434. }
  1435. void RendererCanvasRenderRD::occluder_polygon_set_shape(RID p_occluder, const Vector<Vector2> &p_points, bool p_closed) {
  1436. OccluderPolygon *oc = occluder_polygon_owner.get_or_null(p_occluder);
  1437. ERR_FAIL_COND(!oc);
  1438. Vector<Vector2> lines;
  1439. if (p_points.size()) {
  1440. int lc = p_points.size() * 2;
  1441. lines.resize(lc - (p_closed ? 0 : 2));
  1442. {
  1443. Vector2 *w = lines.ptrw();
  1444. const Vector2 *r = p_points.ptr();
  1445. int max = lc / 2;
  1446. if (!p_closed) {
  1447. max--;
  1448. }
  1449. for (int i = 0; i < max; i++) {
  1450. Vector2 a = r[i];
  1451. Vector2 b = r[(i + 1) % (lc / 2)];
  1452. w[i * 2 + 0] = a;
  1453. w[i * 2 + 1] = b;
  1454. }
  1455. }
  1456. }
  1457. if (oc->line_point_count != lines.size() && oc->vertex_array.is_valid()) {
  1458. RD::get_singleton()->free(oc->vertex_array);
  1459. RD::get_singleton()->free(oc->vertex_buffer);
  1460. RD::get_singleton()->free(oc->index_array);
  1461. RD::get_singleton()->free(oc->index_buffer);
  1462. oc->vertex_array = RID();
  1463. oc->vertex_buffer = RID();
  1464. oc->index_array = RID();
  1465. oc->index_buffer = RID();
  1466. oc->line_point_count = lines.size();
  1467. }
  1468. if (lines.size()) {
  1469. Vector<uint8_t> geometry;
  1470. Vector<uint8_t> indices;
  1471. int lc = lines.size();
  1472. geometry.resize(lc * 6 * sizeof(float));
  1473. indices.resize(lc * 3 * sizeof(uint16_t));
  1474. {
  1475. uint8_t *vw = geometry.ptrw();
  1476. float *vwptr = reinterpret_cast<float *>(vw);
  1477. uint8_t *iw = indices.ptrw();
  1478. uint16_t *iwptr = (uint16_t *)iw;
  1479. const Vector2 *lr = lines.ptr();
  1480. const int POLY_HEIGHT = 16384;
  1481. for (int i = 0; i < lc / 2; i++) {
  1482. vwptr[i * 12 + 0] = lr[i * 2 + 0].x;
  1483. vwptr[i * 12 + 1] = lr[i * 2 + 0].y;
  1484. vwptr[i * 12 + 2] = POLY_HEIGHT;
  1485. vwptr[i * 12 + 3] = lr[i * 2 + 1].x;
  1486. vwptr[i * 12 + 4] = lr[i * 2 + 1].y;
  1487. vwptr[i * 12 + 5] = POLY_HEIGHT;
  1488. vwptr[i * 12 + 6] = lr[i * 2 + 1].x;
  1489. vwptr[i * 12 + 7] = lr[i * 2 + 1].y;
  1490. vwptr[i * 12 + 8] = -POLY_HEIGHT;
  1491. vwptr[i * 12 + 9] = lr[i * 2 + 0].x;
  1492. vwptr[i * 12 + 10] = lr[i * 2 + 0].y;
  1493. vwptr[i * 12 + 11] = -POLY_HEIGHT;
  1494. iwptr[i * 6 + 0] = i * 4 + 0;
  1495. iwptr[i * 6 + 1] = i * 4 + 1;
  1496. iwptr[i * 6 + 2] = i * 4 + 2;
  1497. iwptr[i * 6 + 3] = i * 4 + 2;
  1498. iwptr[i * 6 + 4] = i * 4 + 3;
  1499. iwptr[i * 6 + 5] = i * 4 + 0;
  1500. }
  1501. }
  1502. //if same buffer len is being set, just use BufferSubData to avoid a pipeline flush
  1503. if (oc->vertex_array.is_null()) {
  1504. //create from scratch
  1505. //vertices
  1506. oc->vertex_buffer = RD::get_singleton()->vertex_buffer_create(lc * 6 * sizeof(real_t), geometry);
  1507. Vector<RID> buffer;
  1508. buffer.push_back(oc->vertex_buffer);
  1509. oc->vertex_array = RD::get_singleton()->vertex_array_create(4 * lc / 2, shadow_render.vertex_format, buffer);
  1510. //indices
  1511. oc->index_buffer = RD::get_singleton()->index_buffer_create(3 * lc, RD::INDEX_BUFFER_FORMAT_UINT16, indices);
  1512. oc->index_array = RD::get_singleton()->index_array_create(oc->index_buffer, 0, 3 * lc);
  1513. } else {
  1514. //update existing
  1515. const uint8_t *vr = geometry.ptr();
  1516. RD::get_singleton()->buffer_update(oc->vertex_buffer, 0, geometry.size(), vr);
  1517. const uint8_t *ir = indices.ptr();
  1518. RD::get_singleton()->buffer_update(oc->index_buffer, 0, indices.size(), ir);
  1519. }
  1520. }
  1521. // sdf
  1522. Vector<int> sdf_indices;
  1523. if (p_points.size()) {
  1524. if (p_closed) {
  1525. sdf_indices = Geometry2D::triangulate_polygon(p_points);
  1526. oc->sdf_is_lines = false;
  1527. } else {
  1528. int max = p_points.size();
  1529. sdf_indices.resize(max * 2);
  1530. int *iw = sdf_indices.ptrw();
  1531. for (int i = 0; i < max; i++) {
  1532. iw[i * 2 + 0] = i;
  1533. iw[i * 2 + 1] = (i + 1) % max;
  1534. }
  1535. oc->sdf_is_lines = true;
  1536. }
  1537. }
  1538. if (oc->sdf_index_count != sdf_indices.size() && oc->sdf_point_count != p_points.size() && oc->sdf_vertex_array.is_valid()) {
  1539. RD::get_singleton()->free(oc->sdf_vertex_array);
  1540. RD::get_singleton()->free(oc->sdf_vertex_buffer);
  1541. RD::get_singleton()->free(oc->sdf_index_array);
  1542. RD::get_singleton()->free(oc->sdf_index_buffer);
  1543. oc->sdf_vertex_array = RID();
  1544. oc->sdf_vertex_buffer = RID();
  1545. oc->sdf_index_array = RID();
  1546. oc->sdf_index_buffer = RID();
  1547. oc->sdf_index_count = sdf_indices.size();
  1548. oc->sdf_point_count = p_points.size();
  1549. oc->sdf_is_lines = false;
  1550. }
  1551. if (sdf_indices.size()) {
  1552. if (oc->sdf_vertex_array.is_null()) {
  1553. //create from scratch
  1554. //vertices
  1555. oc->sdf_vertex_buffer = RD::get_singleton()->vertex_buffer_create(p_points.size() * 2 * sizeof(real_t), p_points.to_byte_array());
  1556. oc->sdf_index_buffer = RD::get_singleton()->index_buffer_create(sdf_indices.size(), RD::INDEX_BUFFER_FORMAT_UINT32, sdf_indices.to_byte_array());
  1557. oc->sdf_index_array = RD::get_singleton()->index_array_create(oc->sdf_index_buffer, 0, sdf_indices.size());
  1558. Vector<RID> buffer;
  1559. buffer.push_back(oc->sdf_vertex_buffer);
  1560. oc->sdf_vertex_array = RD::get_singleton()->vertex_array_create(p_points.size(), shadow_render.sdf_vertex_format, buffer);
  1561. //indices
  1562. } else {
  1563. //update existing
  1564. RD::get_singleton()->buffer_update(oc->sdf_vertex_buffer, 0, sizeof(real_t) * 2 * p_points.size(), p_points.ptr());
  1565. RD::get_singleton()->buffer_update(oc->sdf_index_buffer, 0, sdf_indices.size() * sizeof(int32_t), sdf_indices.ptr());
  1566. }
  1567. }
  1568. }
  1569. void RendererCanvasRenderRD::occluder_polygon_set_cull_mode(RID p_occluder, RS::CanvasOccluderPolygonCullMode p_mode) {
  1570. OccluderPolygon *oc = occluder_polygon_owner.get_or_null(p_occluder);
  1571. ERR_FAIL_COND(!oc);
  1572. oc->cull_mode = p_mode;
  1573. }
  1574. void RendererCanvasRenderRD::CanvasShaderData::set_path_hint(const String &p_path) {
  1575. path = p_path;
  1576. }
  1577. void RendererCanvasRenderRD::CanvasShaderData::set_code(const String &p_code) {
  1578. //compile
  1579. code = p_code;
  1580. valid = false;
  1581. ubo_size = 0;
  1582. uniforms.clear();
  1583. uses_screen_texture = false;
  1584. uses_screen_texture_mipmaps = false;
  1585. uses_sdf = false;
  1586. uses_time = false;
  1587. if (code.is_empty()) {
  1588. return; //just invalid, but no error
  1589. }
  1590. ShaderCompiler::GeneratedCode gen_code;
  1591. int blend_mode = BLEND_MODE_MIX;
  1592. ShaderCompiler::IdentifierActions actions;
  1593. actions.entry_point_stages["vertex"] = ShaderCompiler::STAGE_VERTEX;
  1594. actions.entry_point_stages["fragment"] = ShaderCompiler::STAGE_FRAGMENT;
  1595. actions.entry_point_stages["light"] = ShaderCompiler::STAGE_FRAGMENT;
  1596. actions.render_mode_values["blend_add"] = Pair<int *, int>(&blend_mode, BLEND_MODE_ADD);
  1597. actions.render_mode_values["blend_mix"] = Pair<int *, int>(&blend_mode, BLEND_MODE_MIX);
  1598. actions.render_mode_values["blend_sub"] = Pair<int *, int>(&blend_mode, BLEND_MODE_SUB);
  1599. actions.render_mode_values["blend_mul"] = Pair<int *, int>(&blend_mode, BLEND_MODE_MUL);
  1600. actions.render_mode_values["blend_premul_alpha"] = Pair<int *, int>(&blend_mode, BLEND_MODE_PMALPHA);
  1601. actions.render_mode_values["blend_disabled"] = Pair<int *, int>(&blend_mode, BLEND_MODE_DISABLED);
  1602. actions.usage_flag_pointers["SCREEN_TEXTURE"] = &uses_screen_texture;
  1603. actions.usage_flag_pointers["texture_sdf"] = &uses_sdf;
  1604. actions.usage_flag_pointers["TIME"] = &uses_time;
  1605. actions.uniforms = &uniforms;
  1606. RendererCanvasRenderRD *canvas_singleton = static_cast<RendererCanvasRenderRD *>(RendererCanvasRender::singleton);
  1607. Error err = canvas_singleton->shader.compiler.compile(RS::SHADER_CANVAS_ITEM, code, &actions, path, gen_code);
  1608. ERR_FAIL_COND_MSG(err != OK, "Shader compilation failed.");
  1609. uses_screen_texture_mipmaps = gen_code.uses_screen_texture_mipmaps;
  1610. if (version.is_null()) {
  1611. version = canvas_singleton->shader.canvas_shader.version_create();
  1612. }
  1613. #if 0
  1614. print_line("**compiling shader:");
  1615. print_line("**defines:\n");
  1616. for (int i = 0; i < gen_code.defines.size(); i++) {
  1617. print_line(gen_code.defines[i]);
  1618. }
  1619. HashMap<String, String>::Iterator el = gen_code.code.begin();
  1620. while (el) {
  1621. print_line("\n**code " + el->key + ":\n" + el->value);
  1622. ++el;
  1623. }
  1624. print_line("\n**uniforms:\n" + gen_code.uniforms);
  1625. print_line("\n**vertex_globals:\n" + gen_code.stage_globals[ShaderCompiler::STAGE_VERTEX]);
  1626. print_line("\n**fragment_globals:\n" + gen_code.stage_globals[ShaderCompiler::STAGE_FRAGMENT]);
  1627. #endif
  1628. canvas_singleton->shader.canvas_shader.version_set_code(version, gen_code.code, gen_code.uniforms, gen_code.stage_globals[ShaderCompiler::STAGE_VERTEX], gen_code.stage_globals[ShaderCompiler::STAGE_FRAGMENT], gen_code.defines);
  1629. ERR_FAIL_COND(!canvas_singleton->shader.canvas_shader.version_is_valid(version));
  1630. ubo_size = gen_code.uniform_total_size;
  1631. ubo_offsets = gen_code.uniform_offsets;
  1632. texture_uniforms = gen_code.texture_uniforms;
  1633. //update them pipelines
  1634. RD::PipelineColorBlendState::Attachment attachment;
  1635. switch (blend_mode) {
  1636. case BLEND_MODE_DISABLED: {
  1637. // nothing to do here, disabled by default
  1638. } break;
  1639. case BLEND_MODE_MIX: {
  1640. attachment.enable_blend = true;
  1641. attachment.color_blend_op = RD::BLEND_OP_ADD;
  1642. attachment.src_color_blend_factor = RD::BLEND_FACTOR_SRC_ALPHA;
  1643. attachment.dst_color_blend_factor = RD::BLEND_FACTOR_ONE_MINUS_SRC_ALPHA;
  1644. attachment.alpha_blend_op = RD::BLEND_OP_ADD;
  1645. attachment.src_alpha_blend_factor = RD::BLEND_FACTOR_ONE;
  1646. attachment.dst_alpha_blend_factor = RD::BLEND_FACTOR_ONE_MINUS_SRC_ALPHA;
  1647. } break;
  1648. case BLEND_MODE_ADD: {
  1649. attachment.enable_blend = true;
  1650. attachment.alpha_blend_op = RD::BLEND_OP_ADD;
  1651. attachment.color_blend_op = RD::BLEND_OP_ADD;
  1652. attachment.src_color_blend_factor = RD::BLEND_FACTOR_SRC_ALPHA;
  1653. attachment.dst_color_blend_factor = RD::BLEND_FACTOR_ONE;
  1654. attachment.src_alpha_blend_factor = RD::BLEND_FACTOR_SRC_ALPHA;
  1655. attachment.dst_alpha_blend_factor = RD::BLEND_FACTOR_ONE;
  1656. } break;
  1657. case BLEND_MODE_SUB: {
  1658. attachment.enable_blend = true;
  1659. attachment.alpha_blend_op = RD::BLEND_OP_SUBTRACT;
  1660. attachment.color_blend_op = RD::BLEND_OP_SUBTRACT;
  1661. attachment.src_color_blend_factor = RD::BLEND_FACTOR_SRC_ALPHA;
  1662. attachment.dst_color_blend_factor = RD::BLEND_FACTOR_ONE;
  1663. attachment.src_alpha_blend_factor = RD::BLEND_FACTOR_SRC_ALPHA;
  1664. attachment.dst_alpha_blend_factor = RD::BLEND_FACTOR_ONE;
  1665. } break;
  1666. case BLEND_MODE_MUL: {
  1667. attachment.enable_blend = true;
  1668. attachment.alpha_blend_op = RD::BLEND_OP_ADD;
  1669. attachment.color_blend_op = RD::BLEND_OP_ADD;
  1670. attachment.src_color_blend_factor = RD::BLEND_FACTOR_DST_COLOR;
  1671. attachment.dst_color_blend_factor = RD::BLEND_FACTOR_ZERO;
  1672. attachment.src_alpha_blend_factor = RD::BLEND_FACTOR_DST_ALPHA;
  1673. attachment.dst_alpha_blend_factor = RD::BLEND_FACTOR_ZERO;
  1674. } break;
  1675. case BLEND_MODE_PMALPHA: {
  1676. attachment.enable_blend = true;
  1677. attachment.alpha_blend_op = RD::BLEND_OP_ADD;
  1678. attachment.color_blend_op = RD::BLEND_OP_ADD;
  1679. attachment.src_color_blend_factor = RD::BLEND_FACTOR_ONE;
  1680. attachment.dst_color_blend_factor = RD::BLEND_FACTOR_ONE_MINUS_SRC_ALPHA;
  1681. attachment.src_alpha_blend_factor = RD::BLEND_FACTOR_ONE;
  1682. attachment.dst_alpha_blend_factor = RD::BLEND_FACTOR_ONE_MINUS_SRC_ALPHA;
  1683. } break;
  1684. }
  1685. RD::PipelineColorBlendState blend_state;
  1686. blend_state.attachments.push_back(attachment);
  1687. RD::PipelineColorBlendState::Attachment attachment_lcd;
  1688. attachment_lcd.enable_blend = true;
  1689. attachment_lcd.alpha_blend_op = RD::BLEND_OP_ADD;
  1690. attachment_lcd.color_blend_op = RD::BLEND_OP_ADD;
  1691. attachment_lcd.src_color_blend_factor = RD::BLEND_FACTOR_CONSTANT_COLOR;
  1692. attachment_lcd.dst_color_blend_factor = RD::BLEND_FACTOR_ONE_MINUS_SRC_COLOR;
  1693. attachment_lcd.src_alpha_blend_factor = RD::BLEND_FACTOR_ONE;
  1694. attachment_lcd.dst_alpha_blend_factor = RD::BLEND_FACTOR_ONE_MINUS_SRC_ALPHA;
  1695. RD::PipelineColorBlendState blend_state_lcd;
  1696. blend_state_lcd.attachments.push_back(attachment_lcd);
  1697. //update pipelines
  1698. for (int i = 0; i < PIPELINE_LIGHT_MODE_MAX; i++) {
  1699. for (int j = 0; j < PIPELINE_VARIANT_MAX; j++) {
  1700. RD::RenderPrimitive primitive[PIPELINE_VARIANT_MAX] = {
  1701. RD::RENDER_PRIMITIVE_TRIANGLES,
  1702. RD::RENDER_PRIMITIVE_TRIANGLES,
  1703. RD::RENDER_PRIMITIVE_TRIANGLES,
  1704. RD::RENDER_PRIMITIVE_LINES,
  1705. RD::RENDER_PRIMITIVE_POINTS,
  1706. RD::RENDER_PRIMITIVE_TRIANGLES,
  1707. RD::RENDER_PRIMITIVE_TRIANGLE_STRIPS,
  1708. RD::RENDER_PRIMITIVE_LINES,
  1709. RD::RENDER_PRIMITIVE_LINESTRIPS,
  1710. RD::RENDER_PRIMITIVE_POINTS,
  1711. RD::RENDER_PRIMITIVE_TRIANGLES,
  1712. };
  1713. ShaderVariant shader_variants[PIPELINE_LIGHT_MODE_MAX][PIPELINE_VARIANT_MAX] = {
  1714. {
  1715. //non lit
  1716. SHADER_VARIANT_QUAD,
  1717. SHADER_VARIANT_NINEPATCH,
  1718. SHADER_VARIANT_PRIMITIVE,
  1719. SHADER_VARIANT_PRIMITIVE,
  1720. SHADER_VARIANT_PRIMITIVE_POINTS,
  1721. SHADER_VARIANT_ATTRIBUTES,
  1722. SHADER_VARIANT_ATTRIBUTES,
  1723. SHADER_VARIANT_ATTRIBUTES,
  1724. SHADER_VARIANT_ATTRIBUTES,
  1725. SHADER_VARIANT_ATTRIBUTES_POINTS,
  1726. SHADER_VARIANT_QUAD,
  1727. },
  1728. {
  1729. //lit
  1730. SHADER_VARIANT_QUAD_LIGHT,
  1731. SHADER_VARIANT_NINEPATCH_LIGHT,
  1732. SHADER_VARIANT_PRIMITIVE_LIGHT,
  1733. SHADER_VARIANT_PRIMITIVE_LIGHT,
  1734. SHADER_VARIANT_PRIMITIVE_POINTS_LIGHT,
  1735. SHADER_VARIANT_ATTRIBUTES_LIGHT,
  1736. SHADER_VARIANT_ATTRIBUTES_LIGHT,
  1737. SHADER_VARIANT_ATTRIBUTES_LIGHT,
  1738. SHADER_VARIANT_ATTRIBUTES_LIGHT,
  1739. SHADER_VARIANT_ATTRIBUTES_POINTS_LIGHT,
  1740. SHADER_VARIANT_QUAD_LIGHT,
  1741. },
  1742. };
  1743. RID shader_variant = canvas_singleton->shader.canvas_shader.version_get_shader(version, shader_variants[i][j]);
  1744. if (j == PIPELINE_VARIANT_QUAD_LCD_BLEND) {
  1745. pipeline_variants.variants[i][j].setup(shader_variant, primitive[j], RD::PipelineRasterizationState(), RD::PipelineMultisampleState(), RD::PipelineDepthStencilState(), blend_state_lcd, RD::DYNAMIC_STATE_BLEND_CONSTANTS);
  1746. } else {
  1747. pipeline_variants.variants[i][j].setup(shader_variant, primitive[j], RD::PipelineRasterizationState(), RD::PipelineMultisampleState(), RD::PipelineDepthStencilState(), blend_state, 0);
  1748. }
  1749. }
  1750. }
  1751. valid = true;
  1752. }
  1753. void RendererCanvasRenderRD::CanvasShaderData::set_default_texture_parameter(const StringName &p_name, RID p_texture, int p_index) {
  1754. if (!p_texture.is_valid()) {
  1755. if (default_texture_params.has(p_name) && default_texture_params[p_name].has(p_index)) {
  1756. default_texture_params[p_name].erase(p_index);
  1757. if (default_texture_params[p_name].is_empty()) {
  1758. default_texture_params.erase(p_name);
  1759. }
  1760. }
  1761. } else {
  1762. if (!default_texture_params.has(p_name)) {
  1763. default_texture_params[p_name] = HashMap<int, RID>();
  1764. }
  1765. default_texture_params[p_name][p_index] = p_texture;
  1766. }
  1767. }
  1768. void RendererCanvasRenderRD::CanvasShaderData::get_shader_uniform_list(List<PropertyInfo> *p_param_list) const {
  1769. HashMap<int, StringName> order;
  1770. for (const KeyValue<StringName, ShaderLanguage::ShaderNode::Uniform> &E : uniforms) {
  1771. if (E.value.scope != ShaderLanguage::ShaderNode::Uniform::SCOPE_LOCAL ||
  1772. E.value.hint == ShaderLanguage::ShaderNode::Uniform::HINT_SCREEN_TEXTURE ||
  1773. E.value.hint == ShaderLanguage::ShaderNode::Uniform::HINT_NORMAL_ROUGHNESS_TEXTURE ||
  1774. E.value.hint == ShaderLanguage::ShaderNode::Uniform::HINT_DEPTH_TEXTURE) {
  1775. // Don't expose any of these.
  1776. continue;
  1777. }
  1778. if (E.value.texture_order >= 0) {
  1779. order[E.value.texture_order + 100000] = E.key;
  1780. } else {
  1781. order[E.value.order] = E.key;
  1782. }
  1783. }
  1784. String last_group;
  1785. for (const KeyValue<int, StringName> &E : order) {
  1786. String group = uniforms[E.value].group;
  1787. if (!uniforms[E.value].subgroup.is_empty()) {
  1788. group += "::" + uniforms[E.value].subgroup;
  1789. }
  1790. if (group != last_group) {
  1791. PropertyInfo pi;
  1792. pi.usage = PROPERTY_USAGE_GROUP;
  1793. pi.name = group;
  1794. p_param_list->push_back(pi);
  1795. last_group = group;
  1796. }
  1797. PropertyInfo pi = ShaderLanguage::uniform_to_property_info(uniforms[E.value]);
  1798. pi.name = E.value;
  1799. p_param_list->push_back(pi);
  1800. }
  1801. }
  1802. void RendererCanvasRenderRD::CanvasShaderData::get_instance_param_list(List<RendererMaterialStorage::InstanceShaderParam> *p_param_list) const {
  1803. for (const KeyValue<StringName, ShaderLanguage::ShaderNode::Uniform> &E : uniforms) {
  1804. if (E.value.scope != ShaderLanguage::ShaderNode::Uniform::SCOPE_INSTANCE) {
  1805. continue;
  1806. }
  1807. RendererMaterialStorage::InstanceShaderParam p;
  1808. p.info = ShaderLanguage::uniform_to_property_info(E.value);
  1809. p.info.name = E.key; //supply name
  1810. p.index = E.value.instance_index;
  1811. p.default_value = ShaderLanguage::constant_value_to_variant(E.value.default_value, E.value.type, E.value.array_size, E.value.hint);
  1812. p_param_list->push_back(p);
  1813. }
  1814. }
  1815. bool RendererCanvasRenderRD::CanvasShaderData::is_parameter_texture(const StringName &p_param) const {
  1816. if (!uniforms.has(p_param)) {
  1817. return false;
  1818. }
  1819. return uniforms[p_param].texture_order >= 0;
  1820. }
  1821. bool RendererCanvasRenderRD::CanvasShaderData::is_animated() const {
  1822. return false;
  1823. }
  1824. bool RendererCanvasRenderRD::CanvasShaderData::casts_shadows() const {
  1825. return false;
  1826. }
  1827. Variant RendererCanvasRenderRD::CanvasShaderData::get_default_parameter(const StringName &p_parameter) const {
  1828. if (uniforms.has(p_parameter)) {
  1829. ShaderLanguage::ShaderNode::Uniform uniform = uniforms[p_parameter];
  1830. Vector<ShaderLanguage::ConstantNode::Value> default_value = uniform.default_value;
  1831. return ShaderLanguage::constant_value_to_variant(default_value, uniform.type, uniform.array_size, uniform.hint);
  1832. }
  1833. return Variant();
  1834. }
  1835. RS::ShaderNativeSourceCode RendererCanvasRenderRD::CanvasShaderData::get_native_source_code() const {
  1836. RendererCanvasRenderRD *canvas_singleton = static_cast<RendererCanvasRenderRD *>(RendererCanvasRender::singleton);
  1837. return canvas_singleton->shader.canvas_shader.version_get_native_source_code(version);
  1838. }
  1839. RendererCanvasRenderRD::CanvasShaderData::~CanvasShaderData() {
  1840. RendererCanvasRenderRD *canvas_singleton = static_cast<RendererCanvasRenderRD *>(RendererCanvasRender::singleton);
  1841. ERR_FAIL_COND(!canvas_singleton);
  1842. //pipeline variants will clear themselves if shader is gone
  1843. if (version.is_valid()) {
  1844. canvas_singleton->shader.canvas_shader.version_free(version);
  1845. }
  1846. }
  1847. RendererRD::MaterialStorage::ShaderData *RendererCanvasRenderRD::_create_shader_func() {
  1848. CanvasShaderData *shader_data = memnew(CanvasShaderData);
  1849. return shader_data;
  1850. }
  1851. bool RendererCanvasRenderRD::CanvasMaterialData::update_parameters(const HashMap<StringName, Variant> &p_parameters, bool p_uniform_dirty, bool p_textures_dirty) {
  1852. RendererCanvasRenderRD *canvas_singleton = static_cast<RendererCanvasRenderRD *>(RendererCanvasRender::singleton);
  1853. return update_parameters_uniform_set(p_parameters, p_uniform_dirty, p_textures_dirty, shader_data->uniforms, shader_data->ubo_offsets.ptr(), shader_data->texture_uniforms, shader_data->default_texture_params, shader_data->ubo_size, uniform_set, canvas_singleton->shader.canvas_shader.version_get_shader(shader_data->version, 0), MATERIAL_UNIFORM_SET, false);
  1854. }
  1855. RendererCanvasRenderRD::CanvasMaterialData::~CanvasMaterialData() {
  1856. free_parameters_uniform_set(uniform_set);
  1857. }
  1858. RendererRD::MaterialStorage::MaterialData *RendererCanvasRenderRD::_create_material_func(CanvasShaderData *p_shader) {
  1859. CanvasMaterialData *material_data = memnew(CanvasMaterialData);
  1860. material_data->shader_data = p_shader;
  1861. //update will happen later anyway so do nothing.
  1862. return material_data;
  1863. }
  1864. void RendererCanvasRenderRD::set_time(double p_time) {
  1865. state.time = p_time;
  1866. }
  1867. void RendererCanvasRenderRD::update() {
  1868. }
  1869. RendererCanvasRenderRD::RendererCanvasRenderRD() {
  1870. RendererRD::TextureStorage *texture_storage = RendererRD::TextureStorage::get_singleton();
  1871. RendererRD::MaterialStorage *material_storage = RendererRD::MaterialStorage::get_singleton();
  1872. { //create default samplers
  1873. default_samplers.default_filter = RS::CANVAS_ITEM_TEXTURE_FILTER_LINEAR;
  1874. default_samplers.default_repeat = RS::CANVAS_ITEM_TEXTURE_REPEAT_DISABLED;
  1875. }
  1876. { //shader variants
  1877. String global_defines;
  1878. uint64_t uniform_max_size = RD::get_singleton()->limit_get(RD::LIMIT_MAX_UNIFORM_BUFFER_SIZE);
  1879. if (uniform_max_size < 65536) {
  1880. //Yes, you guessed right, ARM again
  1881. state.max_lights_per_render = 64;
  1882. global_defines += "#define MAX_LIGHTS 64\n";
  1883. } else {
  1884. state.max_lights_per_render = DEFAULT_MAX_LIGHTS_PER_RENDER;
  1885. global_defines += "#define MAX_LIGHTS " + itos(DEFAULT_MAX_LIGHTS_PER_RENDER) + "\n";
  1886. }
  1887. state.light_uniforms = memnew_arr(LightUniform, state.max_lights_per_render);
  1888. Vector<String> variants;
  1889. //non light variants
  1890. variants.push_back(""); //none by default is first variant
  1891. variants.push_back("#define USE_NINEPATCH\n"); //ninepatch is the second variant
  1892. variants.push_back("#define USE_PRIMITIVE\n"); //primitive is the third
  1893. variants.push_back("#define USE_PRIMITIVE\n#define USE_POINT_SIZE\n"); //points need point size
  1894. variants.push_back("#define USE_ATTRIBUTES\n"); // attributes for vertex arrays
  1895. variants.push_back("#define USE_ATTRIBUTES\n#define USE_POINT_SIZE\n"); //attributes with point size
  1896. //light variants
  1897. variants.push_back("#define USE_LIGHTING\n"); //none by default is first variant
  1898. variants.push_back("#define USE_LIGHTING\n#define USE_NINEPATCH\n"); //ninepatch is the second variant
  1899. variants.push_back("#define USE_LIGHTING\n#define USE_PRIMITIVE\n"); //primitive is the third
  1900. variants.push_back("#define USE_LIGHTING\n#define USE_PRIMITIVE\n#define USE_POINT_SIZE\n"); //points need point size
  1901. variants.push_back("#define USE_LIGHTING\n#define USE_ATTRIBUTES\n"); // attributes for vertex arrays
  1902. variants.push_back("#define USE_LIGHTING\n#define USE_ATTRIBUTES\n#define USE_POINT_SIZE\n"); //attributes with point size
  1903. shader.canvas_shader.initialize(variants, global_defines);
  1904. shader.default_version = shader.canvas_shader.version_create();
  1905. shader.default_version_rd_shader = shader.canvas_shader.version_get_shader(shader.default_version, SHADER_VARIANT_QUAD);
  1906. RD::PipelineColorBlendState blend_state;
  1907. RD::PipelineColorBlendState::Attachment blend_attachment;
  1908. blend_attachment.enable_blend = true;
  1909. blend_attachment.color_blend_op = RD::BLEND_OP_ADD;
  1910. blend_attachment.src_color_blend_factor = RD::BLEND_FACTOR_SRC_ALPHA;
  1911. blend_attachment.dst_color_blend_factor = RD::BLEND_FACTOR_ONE_MINUS_SRC_ALPHA;
  1912. blend_attachment.alpha_blend_op = RD::BLEND_OP_ADD;
  1913. blend_attachment.src_alpha_blend_factor = RD::BLEND_FACTOR_ONE;
  1914. blend_attachment.dst_alpha_blend_factor = RD::BLEND_FACTOR_ONE_MINUS_SRC_ALPHA;
  1915. blend_state.attachments.push_back(blend_attachment);
  1916. RD::PipelineColorBlendState::Attachment attachment_lcd;
  1917. attachment_lcd.enable_blend = true;
  1918. attachment_lcd.alpha_blend_op = RD::BLEND_OP_ADD;
  1919. attachment_lcd.color_blend_op = RD::BLEND_OP_ADD;
  1920. attachment_lcd.src_color_blend_factor = RD::BLEND_FACTOR_CONSTANT_COLOR;
  1921. attachment_lcd.dst_color_blend_factor = RD::BLEND_FACTOR_ONE_MINUS_SRC_COLOR;
  1922. attachment_lcd.src_alpha_blend_factor = RD::BLEND_FACTOR_ONE;
  1923. attachment_lcd.dst_alpha_blend_factor = RD::BLEND_FACTOR_ONE_MINUS_SRC_ALPHA;
  1924. RD::PipelineColorBlendState blend_state_lcd;
  1925. blend_state_lcd.attachments.push_back(attachment_lcd);
  1926. for (int i = 0; i < PIPELINE_LIGHT_MODE_MAX; i++) {
  1927. for (int j = 0; j < PIPELINE_VARIANT_MAX; j++) {
  1928. RD::RenderPrimitive primitive[PIPELINE_VARIANT_MAX] = {
  1929. RD::RENDER_PRIMITIVE_TRIANGLES,
  1930. RD::RENDER_PRIMITIVE_TRIANGLES,
  1931. RD::RENDER_PRIMITIVE_TRIANGLES,
  1932. RD::RENDER_PRIMITIVE_LINES,
  1933. RD::RENDER_PRIMITIVE_POINTS,
  1934. RD::RENDER_PRIMITIVE_TRIANGLES,
  1935. RD::RENDER_PRIMITIVE_TRIANGLE_STRIPS,
  1936. RD::RENDER_PRIMITIVE_LINES,
  1937. RD::RENDER_PRIMITIVE_LINESTRIPS,
  1938. RD::RENDER_PRIMITIVE_POINTS,
  1939. RD::RENDER_PRIMITIVE_TRIANGLES,
  1940. };
  1941. ShaderVariant shader_variants[PIPELINE_LIGHT_MODE_MAX][PIPELINE_VARIANT_MAX] = {
  1942. {
  1943. //non lit
  1944. SHADER_VARIANT_QUAD,
  1945. SHADER_VARIANT_NINEPATCH,
  1946. SHADER_VARIANT_PRIMITIVE,
  1947. SHADER_VARIANT_PRIMITIVE,
  1948. SHADER_VARIANT_PRIMITIVE_POINTS,
  1949. SHADER_VARIANT_ATTRIBUTES,
  1950. SHADER_VARIANT_ATTRIBUTES,
  1951. SHADER_VARIANT_ATTRIBUTES,
  1952. SHADER_VARIANT_ATTRIBUTES,
  1953. SHADER_VARIANT_ATTRIBUTES_POINTS,
  1954. SHADER_VARIANT_QUAD,
  1955. },
  1956. {
  1957. //lit
  1958. SHADER_VARIANT_QUAD_LIGHT,
  1959. SHADER_VARIANT_NINEPATCH_LIGHT,
  1960. SHADER_VARIANT_PRIMITIVE_LIGHT,
  1961. SHADER_VARIANT_PRIMITIVE_LIGHT,
  1962. SHADER_VARIANT_PRIMITIVE_POINTS_LIGHT,
  1963. SHADER_VARIANT_ATTRIBUTES_LIGHT,
  1964. SHADER_VARIANT_ATTRIBUTES_LIGHT,
  1965. SHADER_VARIANT_ATTRIBUTES_LIGHT,
  1966. SHADER_VARIANT_ATTRIBUTES_LIGHT,
  1967. SHADER_VARIANT_ATTRIBUTES_POINTS_LIGHT,
  1968. SHADER_VARIANT_QUAD_LIGHT,
  1969. },
  1970. };
  1971. RID shader_variant = shader.canvas_shader.version_get_shader(shader.default_version, shader_variants[i][j]);
  1972. if (j == PIPELINE_VARIANT_QUAD_LCD_BLEND) {
  1973. shader.pipeline_variants.variants[i][j].setup(shader_variant, primitive[j], RD::PipelineRasterizationState(), RD::PipelineMultisampleState(), RD::PipelineDepthStencilState(), blend_state_lcd, RD::DYNAMIC_STATE_BLEND_CONSTANTS);
  1974. } else {
  1975. shader.pipeline_variants.variants[i][j].setup(shader_variant, primitive[j], RD::PipelineRasterizationState(), RD::PipelineMultisampleState(), RD::PipelineDepthStencilState(), blend_state, 0);
  1976. }
  1977. }
  1978. }
  1979. }
  1980. {
  1981. //shader compiler
  1982. ShaderCompiler::DefaultIdentifierActions actions;
  1983. actions.renames["VERTEX"] = "vertex";
  1984. actions.renames["LIGHT_VERTEX"] = "light_vertex";
  1985. actions.renames["SHADOW_VERTEX"] = "shadow_vertex";
  1986. actions.renames["UV"] = "uv";
  1987. actions.renames["POINT_SIZE"] = "gl_PointSize";
  1988. actions.renames["MODEL_MATRIX"] = "model_matrix";
  1989. actions.renames["CANVAS_MATRIX"] = "canvas_data.canvas_transform";
  1990. actions.renames["SCREEN_MATRIX"] = "canvas_data.screen_transform";
  1991. actions.renames["TIME"] = "canvas_data.time";
  1992. actions.renames["PI"] = _MKSTR(Math_PI);
  1993. actions.renames["TAU"] = _MKSTR(Math_TAU);
  1994. actions.renames["E"] = _MKSTR(Math_E);
  1995. actions.renames["AT_LIGHT_PASS"] = "false";
  1996. actions.renames["INSTANCE_CUSTOM"] = "instance_custom";
  1997. actions.renames["COLOR"] = "color";
  1998. actions.renames["NORMAL"] = "normal";
  1999. actions.renames["NORMAL_MAP"] = "normal_map";
  2000. actions.renames["NORMAL_MAP_DEPTH"] = "normal_map_depth";
  2001. actions.renames["TEXTURE"] = "color_texture";
  2002. actions.renames["TEXTURE_PIXEL_SIZE"] = "draw_data.color_texture_pixel_size";
  2003. actions.renames["NORMAL_TEXTURE"] = "normal_texture";
  2004. actions.renames["SPECULAR_SHININESS_TEXTURE"] = "specular_texture";
  2005. actions.renames["SPECULAR_SHININESS"] = "specular_shininess";
  2006. actions.renames["SCREEN_UV"] = "screen_uv";
  2007. actions.renames["SCREEN_TEXTURE"] = "screen_texture";
  2008. actions.renames["SCREEN_PIXEL_SIZE"] = "canvas_data.screen_pixel_size";
  2009. actions.renames["FRAGCOORD"] = "gl_FragCoord";
  2010. actions.renames["POINT_COORD"] = "gl_PointCoord";
  2011. actions.renames["INSTANCE_ID"] = "gl_InstanceIndex";
  2012. actions.renames["VERTEX_ID"] = "gl_VertexIndex";
  2013. actions.renames["LIGHT_POSITION"] = "light_position";
  2014. actions.renames["LIGHT_DIRECTION"] = "light_direction";
  2015. actions.renames["LIGHT_IS_DIRECTIONAL"] = "is_directional";
  2016. actions.renames["LIGHT_COLOR"] = "light_color";
  2017. actions.renames["LIGHT_ENERGY"] = "light_energy";
  2018. actions.renames["LIGHT"] = "light";
  2019. actions.renames["SHADOW_MODULATE"] = "shadow_modulate";
  2020. actions.renames["texture_sdf"] = "texture_sdf";
  2021. actions.renames["texture_sdf_normal"] = "texture_sdf_normal";
  2022. actions.renames["sdf_to_screen_uv"] = "sdf_to_screen_uv";
  2023. actions.renames["screen_uv_to_sdf"] = "screen_uv_to_sdf";
  2024. actions.usage_defines["COLOR"] = "#define COLOR_USED\n";
  2025. actions.usage_defines["SCREEN_TEXTURE"] = "#define SCREEN_TEXTURE_USED\n";
  2026. actions.usage_defines["SCREEN_UV"] = "#define SCREEN_UV_USED\n";
  2027. actions.usage_defines["SCREEN_PIXEL_SIZE"] = "@SCREEN_UV";
  2028. actions.usage_defines["NORMAL"] = "#define NORMAL_USED\n";
  2029. actions.usage_defines["NORMAL_MAP"] = "#define NORMAL_MAP_USED\n";
  2030. actions.usage_defines["LIGHT"] = "#define LIGHT_SHADER_CODE_USED\n";
  2031. actions.usage_defines["SPECULAR_SHININESS"] = "#define SPECULAR_SHININESS_USED\n";
  2032. actions.render_mode_defines["skip_vertex_transform"] = "#define SKIP_TRANSFORM_USED\n";
  2033. actions.render_mode_defines["unshaded"] = "#define MODE_UNSHADED\n";
  2034. actions.render_mode_defines["light_only"] = "#define MODE_LIGHT_ONLY\n";
  2035. actions.custom_samplers["TEXTURE"] = "texture_sampler";
  2036. actions.custom_samplers["NORMAL_TEXTURE"] = "texture_sampler";
  2037. actions.custom_samplers["SPECULAR_SHININESS_TEXTURE"] = "texture_sampler";
  2038. actions.custom_samplers["SCREEN_TEXTURE"] = "material_samplers[3]"; //mipmap and filter for screen texture
  2039. actions.sampler_array_name = "material_samplers";
  2040. actions.base_texture_binding_index = 1;
  2041. actions.texture_layout_set = MATERIAL_UNIFORM_SET;
  2042. actions.base_uniform_string = "material.";
  2043. actions.default_filter = ShaderLanguage::FILTER_LINEAR;
  2044. actions.default_repeat = ShaderLanguage::REPEAT_DISABLE;
  2045. actions.base_varying_index = 4;
  2046. actions.global_buffer_array_variable = "global_shader_uniforms.data";
  2047. shader.compiler.initialize(actions);
  2048. }
  2049. { //shadow rendering
  2050. Vector<String> versions;
  2051. versions.push_back("\n#define MODE_SHADOW\n"); //shadow
  2052. versions.push_back("\n#define MODE_SDF\n"); //sdf
  2053. shadow_render.shader.initialize(versions);
  2054. {
  2055. Vector<RD::AttachmentFormat> attachments;
  2056. RD::AttachmentFormat af_color;
  2057. af_color.format = RD::DATA_FORMAT_R32_SFLOAT;
  2058. af_color.usage_flags = RD::TEXTURE_USAGE_SAMPLING_BIT | RD::TEXTURE_USAGE_COLOR_ATTACHMENT_BIT;
  2059. attachments.push_back(af_color);
  2060. RD::AttachmentFormat af_depth;
  2061. af_depth.format = RD::DATA_FORMAT_D32_SFLOAT;
  2062. af_depth.usage_flags = RD::TEXTURE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT;
  2063. attachments.push_back(af_depth);
  2064. shadow_render.framebuffer_format = RD::get_singleton()->framebuffer_format_create(attachments);
  2065. }
  2066. {
  2067. Vector<RD::AttachmentFormat> attachments;
  2068. RD::AttachmentFormat af_color;
  2069. af_color.format = RD::DATA_FORMAT_R8_UNORM;
  2070. af_color.usage_flags = RD::TEXTURE_USAGE_SAMPLING_BIT | RD::TEXTURE_USAGE_STORAGE_BIT | RD::TEXTURE_USAGE_COLOR_ATTACHMENT_BIT;
  2071. attachments.push_back(af_color);
  2072. shadow_render.sdf_framebuffer_format = RD::get_singleton()->framebuffer_format_create(attachments);
  2073. }
  2074. //pipelines
  2075. Vector<RD::VertexAttribute> vf;
  2076. RD::VertexAttribute vd;
  2077. vd.format = sizeof(real_t) == sizeof(float) ? RD::DATA_FORMAT_R32G32B32_SFLOAT : RD::DATA_FORMAT_R64G64B64_SFLOAT;
  2078. vd.location = 0;
  2079. vd.offset = 0;
  2080. vd.stride = sizeof(real_t) * 3;
  2081. vf.push_back(vd);
  2082. shadow_render.vertex_format = RD::get_singleton()->vertex_format_create(vf);
  2083. vd.format = sizeof(real_t) == sizeof(float) ? RD::DATA_FORMAT_R32G32_SFLOAT : RD::DATA_FORMAT_R64G64_SFLOAT;
  2084. vd.stride = sizeof(real_t) * 2;
  2085. vf.write[0] = vd;
  2086. shadow_render.sdf_vertex_format = RD::get_singleton()->vertex_format_create(vf);
  2087. shadow_render.shader_version = shadow_render.shader.version_create();
  2088. for (int i = 0; i < 3; i++) {
  2089. RD::PipelineRasterizationState rs;
  2090. rs.cull_mode = i == 0 ? RD::POLYGON_CULL_DISABLED : (i == 1 ? RD::POLYGON_CULL_FRONT : RD::POLYGON_CULL_BACK);
  2091. RD::PipelineDepthStencilState ds;
  2092. ds.enable_depth_write = true;
  2093. ds.enable_depth_test = true;
  2094. ds.depth_compare_operator = RD::COMPARE_OP_LESS;
  2095. shadow_render.render_pipelines[i] = RD::get_singleton()->render_pipeline_create(shadow_render.shader.version_get_shader(shadow_render.shader_version, SHADOW_RENDER_MODE_SHADOW), shadow_render.framebuffer_format, shadow_render.vertex_format, RD::RENDER_PRIMITIVE_TRIANGLES, rs, RD::PipelineMultisampleState(), ds, RD::PipelineColorBlendState::create_disabled(), 0);
  2096. }
  2097. for (int i = 0; i < 2; i++) {
  2098. shadow_render.sdf_render_pipelines[i] = RD::get_singleton()->render_pipeline_create(shadow_render.shader.version_get_shader(shadow_render.shader_version, SHADOW_RENDER_MODE_SDF), shadow_render.sdf_framebuffer_format, shadow_render.sdf_vertex_format, i == 0 ? RD::RENDER_PRIMITIVE_TRIANGLES : RD::RENDER_PRIMITIVE_LINES, RD::PipelineRasterizationState(), RD::PipelineMultisampleState(), RD::PipelineDepthStencilState(), RD::PipelineColorBlendState::create_disabled(), 0);
  2099. }
  2100. }
  2101. { //bindings
  2102. state.canvas_state_buffer = RD::get_singleton()->uniform_buffer_create(sizeof(State::Buffer));
  2103. state.lights_uniform_buffer = RD::get_singleton()->uniform_buffer_create(sizeof(LightUniform) * state.max_lights_per_render);
  2104. RD::SamplerState shadow_sampler_state;
  2105. shadow_sampler_state.mag_filter = RD::SAMPLER_FILTER_LINEAR;
  2106. shadow_sampler_state.min_filter = RD::SAMPLER_FILTER_LINEAR;
  2107. shadow_sampler_state.repeat_u = RD::SAMPLER_REPEAT_MODE_REPEAT; //shadow wrap around
  2108. shadow_sampler_state.compare_op = RD::COMPARE_OP_GREATER;
  2109. shadow_sampler_state.enable_compare = true;
  2110. state.shadow_sampler = RD::get_singleton()->sampler_create(shadow_sampler_state);
  2111. }
  2112. {
  2113. //polygon buffers
  2114. polygon_buffers.last_id = 1;
  2115. }
  2116. { // default index buffer
  2117. Vector<uint8_t> pv;
  2118. pv.resize(6 * 4);
  2119. {
  2120. uint8_t *w = pv.ptrw();
  2121. int *p32 = (int *)w;
  2122. p32[0] = 0;
  2123. p32[1] = 1;
  2124. p32[2] = 2;
  2125. p32[3] = 0;
  2126. p32[4] = 2;
  2127. p32[5] = 3;
  2128. }
  2129. shader.quad_index_buffer = RD::get_singleton()->index_buffer_create(6, RenderingDevice::INDEX_BUFFER_FORMAT_UINT32, pv);
  2130. shader.quad_index_array = RD::get_singleton()->index_array_create(shader.quad_index_buffer, 0, 6);
  2131. }
  2132. { //primitive
  2133. primitive_arrays.index_array[0] = shader.quad_index_array = RD::get_singleton()->index_array_create(shader.quad_index_buffer, 0, 1);
  2134. primitive_arrays.index_array[1] = shader.quad_index_array = RD::get_singleton()->index_array_create(shader.quad_index_buffer, 0, 2);
  2135. primitive_arrays.index_array[2] = shader.quad_index_array = RD::get_singleton()->index_array_create(shader.quad_index_buffer, 0, 3);
  2136. primitive_arrays.index_array[3] = shader.quad_index_array = RD::get_singleton()->index_array_create(shader.quad_index_buffer, 0, 6);
  2137. }
  2138. { //default skeleton buffer
  2139. shader.default_skeleton_uniform_buffer = RD::get_singleton()->uniform_buffer_create(sizeof(SkeletonUniform));
  2140. SkeletonUniform su;
  2141. _update_transform_2d_to_mat4(Transform2D(), su.skeleton_inverse);
  2142. _update_transform_2d_to_mat4(Transform2D(), su.skeleton_transform);
  2143. RD::get_singleton()->buffer_update(shader.default_skeleton_uniform_buffer, 0, sizeof(SkeletonUniform), &su);
  2144. shader.default_skeleton_texture_buffer = RD::get_singleton()->texture_buffer_create(32, RD::DATA_FORMAT_R32G32B32A32_SFLOAT);
  2145. }
  2146. {
  2147. //default shadow texture to keep uniform set happy
  2148. RD::TextureFormat tf;
  2149. tf.texture_type = RD::TEXTURE_TYPE_2D;
  2150. tf.width = 4;
  2151. tf.height = 4;
  2152. tf.usage_bits = RD::TEXTURE_USAGE_SAMPLING_BIT;
  2153. tf.format = RD::DATA_FORMAT_R32_SFLOAT;
  2154. state.shadow_texture = RD::get_singleton()->texture_create(tf, RD::TextureView());
  2155. }
  2156. {
  2157. Vector<RD::Uniform> uniforms;
  2158. {
  2159. RD::Uniform u;
  2160. u.uniform_type = RD::UNIFORM_TYPE_STORAGE_BUFFER;
  2161. u.binding = 0;
  2162. u.append_id(RendererRD::MeshStorage::get_singleton()->get_default_rd_storage_buffer());
  2163. uniforms.push_back(u);
  2164. }
  2165. state.default_transforms_uniform_set = RD::get_singleton()->uniform_set_create(uniforms, shader.default_version_rd_shader, TRANSFORMS_UNIFORM_SET);
  2166. }
  2167. default_canvas_texture = texture_storage->canvas_texture_allocate();
  2168. texture_storage->canvas_texture_initialize(default_canvas_texture);
  2169. state.shadow_texture_size = GLOBAL_GET("rendering/2d/shadow_atlas/size");
  2170. //create functions for shader and material
  2171. material_storage->shader_set_data_request_function(RendererRD::MaterialStorage::SHADER_TYPE_2D, _create_shader_funcs);
  2172. material_storage->material_set_data_request_function(RendererRD::MaterialStorage::SHADER_TYPE_2D, _create_material_funcs);
  2173. state.time = 0;
  2174. {
  2175. default_canvas_group_shader = material_storage->shader_allocate();
  2176. material_storage->shader_initialize(default_canvas_group_shader);
  2177. material_storage->shader_set_code(default_canvas_group_shader, R"(
  2178. // Default CanvasGroup shader.
  2179. shader_type canvas_item;
  2180. void fragment() {
  2181. vec4 c = textureLod(SCREEN_TEXTURE, SCREEN_UV, 0.0);
  2182. if (c.a > 0.0001) {
  2183. c.rgb /= c.a;
  2184. }
  2185. COLOR *= c;
  2186. }
  2187. )");
  2188. default_canvas_group_material = material_storage->material_allocate();
  2189. material_storage->material_initialize(default_canvas_group_material);
  2190. material_storage->material_set_shader(default_canvas_group_material, default_canvas_group_shader);
  2191. }
  2192. static_assert(sizeof(PushConstant) == 128);
  2193. }
  2194. bool RendererCanvasRenderRD::free(RID p_rid) {
  2195. if (canvas_light_owner.owns(p_rid)) {
  2196. CanvasLight *cl = canvas_light_owner.get_or_null(p_rid);
  2197. ERR_FAIL_COND_V(!cl, false);
  2198. light_set_use_shadow(p_rid, false);
  2199. canvas_light_owner.free(p_rid);
  2200. } else if (occluder_polygon_owner.owns(p_rid)) {
  2201. occluder_polygon_set_shape(p_rid, Vector<Vector2>(), false);
  2202. occluder_polygon_owner.free(p_rid);
  2203. } else {
  2204. return false;
  2205. }
  2206. return true;
  2207. }
  2208. void RendererCanvasRenderRD::set_shadow_texture_size(int p_size) {
  2209. p_size = nearest_power_of_2_templated(p_size);
  2210. if (p_size == state.shadow_texture_size) {
  2211. return;
  2212. }
  2213. state.shadow_texture_size = p_size;
  2214. if (state.shadow_fb.is_valid()) {
  2215. RD::get_singleton()->free(state.shadow_texture);
  2216. RD::get_singleton()->free(state.shadow_depth_texture);
  2217. state.shadow_fb = RID();
  2218. {
  2219. //create a default shadow texture to keep uniform set happy (and that it gets erased when a new one is created)
  2220. RD::TextureFormat tf;
  2221. tf.texture_type = RD::TEXTURE_TYPE_2D;
  2222. tf.width = 4;
  2223. tf.height = 4;
  2224. tf.usage_bits = RD::TEXTURE_USAGE_SAMPLING_BIT;
  2225. tf.format = RD::DATA_FORMAT_R32_SFLOAT;
  2226. state.shadow_texture = RD::get_singleton()->texture_create(tf, RD::TextureView());
  2227. }
  2228. }
  2229. }
  2230. RendererCanvasRenderRD::~RendererCanvasRenderRD() {
  2231. RendererRD::MaterialStorage *material_storage = RendererRD::MaterialStorage::get_singleton();
  2232. //canvas state
  2233. material_storage->material_free(default_canvas_group_material);
  2234. material_storage->shader_free(default_canvas_group_shader);
  2235. {
  2236. if (state.canvas_state_buffer.is_valid()) {
  2237. RD::get_singleton()->free(state.canvas_state_buffer);
  2238. }
  2239. memdelete_arr(state.light_uniforms);
  2240. RD::get_singleton()->free(state.lights_uniform_buffer);
  2241. RD::get_singleton()->free(shader.default_skeleton_uniform_buffer);
  2242. RD::get_singleton()->free(shader.default_skeleton_texture_buffer);
  2243. }
  2244. //shadow rendering
  2245. {
  2246. shadow_render.shader.version_free(shadow_render.shader_version);
  2247. //this will also automatically clear all pipelines
  2248. RD::get_singleton()->free(state.shadow_sampler);
  2249. }
  2250. //bindings
  2251. //shaders
  2252. shader.canvas_shader.version_free(shader.default_version);
  2253. //buffers
  2254. {
  2255. RD::get_singleton()->free(shader.quad_index_array);
  2256. RD::get_singleton()->free(shader.quad_index_buffer);
  2257. //primitives are erase by dependency
  2258. }
  2259. if (state.shadow_fb.is_valid()) {
  2260. RD::get_singleton()->free(state.shadow_depth_texture);
  2261. }
  2262. RD::get_singleton()->free(state.shadow_texture);
  2263. RendererRD::TextureStorage::get_singleton()->canvas_texture_free(default_canvas_texture);
  2264. //pipelines don't need freeing, they are all gone after shaders are gone
  2265. }