Blender V5.3
eevee_test.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2023 Blender Authors
2 *
3 * SPDX-License-Identifier: Apache-2.0 */
4
5#include "testing/testing.h"
6
7#include "GPU_batch.hh"
8#include "GPU_batch_utils.hh"
9#include "GPU_capabilities.hh"
10#include "GPU_context.hh"
11#include "draw_shader.hh"
12#include "draw_testing.hh"
19
20namespace blender::draw {
21
22using namespace blender::eevee;
23
24/* Replace with template version that is not GPU only. */
27
29{
31 ShadowTileMapDataBuf tilemaps_data = {"tilemaps_data"};
32 ShadowTileDataBuf tiles_data = {"tiles_data"};
33 ShadowTileMapClipBuf tilemaps_clip = {"tilemaps_clip"};
34 ShadowPageCacheBuf pages_cached_data_ = {"pages_cached_data_"};
35
36 int tiles_index = 1;
37 int tile_lod0 = tiles_index * SHADOW_TILEDATA_PER_TILEMAP + 5;
38 int tile_lod1 = tile_lod0 + square_i(SHADOW_TILEMAP_RES);
39
40 {
41 ShadowTileMapData tilemap = {};
42 tilemap.tiles_index = tiles_index * SHADOW_TILEDATA_PER_TILEMAP;
43 tilemap.grid_shift = int2(SHADOW_TILEMAP_RES);
45
46 tilemaps_data.append(tilemap);
47
48 tilemaps_data.push_update();
49 }
50 {
52
53 tile.page = uint3(1, 2, 0);
54 tile.is_used = true;
55 tile.do_update = true;
56 tiles_data[tile_lod0] = shadow_tile_pack(tile);
57
58 tile.page = uint3(3, 2, 4);
59 tile.is_used = false;
60 tile.do_update = false;
61 tiles_data[tile_lod1] = shadow_tile_pack(tile);
62
63 tiles_data.push_update();
64 }
65
66 gpu::Shader *sh = GPU_shader_create_from_info_name("eevee_shadow_tilemap_init");
67
68 PassSimple pass("Test");
69 pass.shader_set(sh);
70 pass.push_constant("reset_used_flag", true);
71 pass.bind_ssbo("tilemaps_buf", tilemaps_data);
72 pass.bind_ssbo("tilemaps_clip_buf", tilemaps_clip);
73 pass.bind_ssbo("tiles_buf", tiles_data);
74 pass.bind_ssbo("pages_cached_buf", pages_cached_data_);
75 pass.dispatch(int3(1, 1, tilemaps_data.size()));
77
78 Manager manager;
79 manager.submit(pass);
80
81 tilemaps_data.read();
82 tiles_data.read();
83
84 EXPECT_EQ(tilemaps_data[0].grid_offset, int2(0));
85 EXPECT_EQ(shadow_tile_unpack(tiles_data[tile_lod0]).page, uint3(1, 2, 0));
86 EXPECT_EQ(shadow_tile_unpack(tiles_data[tile_lod0]).is_used, false);
87 EXPECT_EQ(shadow_tile_unpack(tiles_data[tile_lod0]).do_update, true);
88 EXPECT_EQ(shadow_tile_unpack(tiles_data[tile_lod1]).page, uint3(3, 2, 4));
89 EXPECT_EQ(shadow_tile_unpack(tiles_data[tile_lod1]).is_used, false);
90 EXPECT_EQ(shadow_tile_unpack(tiles_data[tile_lod1]).do_update, true);
91
93
97}
98DRAW_TEST(eevee_shadow_shift_clear)
99
101{
103 ShadowTileMapDataBuf tilemaps_data = {"tilemaps_data"};
104 ShadowTileDataBuf tiles_data = {"tiles_data"};
105 StorageArrayBuffer<ShadowTileMapClip, SHADOW_MAX_TILEMAP> tilemaps_clip = {"tilemaps_clip"};
106 ShadowPageCacheBuf pages_cached_data = {"pages_cached_data"};
107
108 auto tile_co_to_page = [](int2 co) {
109 int page = co.x + co.y * SHADOW_TILEMAP_RES;
110 return uint3((page % SHADOW_PAGE_PER_ROW),
111 (page / SHADOW_PAGE_PER_ROW) % SHADOW_PAGE_PER_COL,
112 (page / SHADOW_PAGE_PER_LAYER));
113 };
114
115 {
116 ShadowTileMapClip clip = {};
117 clip.clip_near_stored = 0.0;
118 clip.clip_far_stored = 1.0;
119 clip.clip_near = 0x00000000; /* floatBitsToOrderedInt(0.0) */
120 clip.clip_far = 0x3F800000; /* floatBitsToOrderedInt(1.0) */
121
122 tilemaps_clip[0] = clip;
123
124 tilemaps_clip.push_update();
125 }
126 {
127 ShadowTileMapData tilemap = {};
128 tilemap.tiles_index = 0;
129 tilemap.clip_data_index = 0;
130 tilemap.grid_shift = int2(-1, 2);
132
133 tilemaps_data.append(tilemap);
134
135 tilemaps_data.push_update();
136 }
137 {
138 ShadowTileData tile = {};
139
140 for (auto x : IndexRange(SHADOW_TILEMAP_RES)) {
141 for (auto y : IndexRange(SHADOW_TILEMAP_RES)) {
142 tile.is_allocated = true;
143 tile.is_rendered = true;
144 tile.do_update = true;
145 tile.page = tile_co_to_page(int2(x, y));
146 tiles_data[x + y * SHADOW_TILEMAP_RES] = shadow_tile_pack(tile);
147 }
148 }
149
150 tiles_data.push_update();
151 }
152
153 gpu::Shader *sh = GPU_shader_create_from_info_name("eevee_shadow_tilemap_init");
154
155 PassSimple pass("Test");
156 pass.shader_set(sh);
157 pass.push_constant("reset_used_flag", true);
158 pass.bind_ssbo("tilemaps_buf", tilemaps_data);
159 pass.bind_ssbo("tilemaps_clip_buf", tilemaps_clip);
160 pass.bind_ssbo("tiles_buf", tiles_data);
161 pass.bind_ssbo("pages_cached_buf", pages_cached_data);
162 pass.dispatch(int3(1, 1, tilemaps_data.size()));
164
165 Manager manager;
166 manager.submit(pass);
167
168 tilemaps_data.read();
169 tiles_data.read();
170
171 EXPECT_EQ(tilemaps_data[0].grid_offset, int2(0));
172 EXPECT_EQ(shadow_tile_unpack(tiles_data[0]).page,
173 tile_co_to_page(int2(SHADOW_TILEMAP_RES - 1, 2)));
174 EXPECT_EQ(shadow_tile_unpack(tiles_data[0]).do_update, true);
175 EXPECT_EQ(shadow_tile_unpack(tiles_data[0]).is_rendered, false);
176 EXPECT_EQ(shadow_tile_unpack(tiles_data[0]).is_allocated, true);
177 EXPECT_EQ(shadow_tile_unpack(tiles_data[1]).page, tile_co_to_page(int2(0, 2)));
178 EXPECT_EQ(shadow_tile_unpack(tiles_data[1]).do_update, false);
179 EXPECT_EQ(shadow_tile_unpack(tiles_data[1]).is_rendered, false);
180 EXPECT_EQ(shadow_tile_unpack(tiles_data[1]).is_allocated, true);
181 EXPECT_EQ(shadow_tile_unpack(tiles_data[0 + SHADOW_TILEMAP_RES * 2]).page,
182 tile_co_to_page(int2(SHADOW_TILEMAP_RES - 1, 4)));
183 EXPECT_EQ(shadow_tile_unpack(tiles_data[0 + SHADOW_TILEMAP_RES * 2]).do_update, true);
184 EXPECT_EQ(shadow_tile_unpack(tiles_data[0 + SHADOW_TILEMAP_RES * 2]).is_rendered, false);
185 EXPECT_EQ(shadow_tile_unpack(tiles_data[0 + SHADOW_TILEMAP_RES * 2]).is_allocated, true);
186 EXPECT_EQ(shadow_tile_unpack(tiles_data[1 + SHADOW_TILEMAP_RES * 2]).page,
187 tile_co_to_page(int2(0, 4)));
188 EXPECT_EQ(shadow_tile_unpack(tiles_data[1 + SHADOW_TILEMAP_RES * 2]).do_update, false);
189 EXPECT_EQ(shadow_tile_unpack(tiles_data[1 + SHADOW_TILEMAP_RES * 2]).is_rendered, false);
190 EXPECT_EQ(shadow_tile_unpack(tiles_data[1 + SHADOW_TILEMAP_RES * 2]).is_allocated, true);
191
193
194 GPU_shader_free(sh);
197}
198DRAW_TEST(eevee_shadow_shift)
199
201{
203 using namespace blender::math;
204 StorageVectorBuffer<uint, 128> past_casters_updated = {"PastCastersUpdated"};
205 StorageVectorBuffer<uint, 128> curr_casters_updated = {"CurrCastersUpdated"};
206
207 Manager manager;
208 {
209 /* Simulate 1 object moving and 1 object static with changing resource index. */
212 float3(1.0f), Quaternion::identity(), float3(0.5f));
213 float3 half_extent = float3(0.24f, 0.249f, 0.001f);
214
215 {
216 manager.begin_sync();
217 ResourceHandle hdl = manager.resource_handle(obmat, float3(0.5f, 0.5f, -1.0f), half_extent);
218 manager.resource_handle(obmat2);
219 manager.end_sync();
220 past_casters_updated.append(hdl.index());
221 past_casters_updated.push_update();
222 }
223 {
224 manager.begin_sync();
225 manager.resource_handle(obmat2);
226 ResourceHandle hdl = manager.resource_handle(obmat, float3(-1.0f, 0.5f, -1.0f), half_extent);
227 manager.end_sync();
228 curr_casters_updated.append(hdl.index());
229 curr_casters_updated.push_update();
230 }
231 }
232
233 ShadowTileMapDataBuf tilemaps_data = {"tilemaps_data"};
234 ShadowTileDataBuf tiles_data = {"tiles_data"};
235 tiles_data.clear_to_zero();
236
237 {
238 ShadowTileMap tilemap(0 * SHADOW_TILEDATA_PER_TILEMAP);
240 tilemaps_data.append(tilemap);
241 }
242 {
243 ShadowTileMap tilemap(1 * SHADOW_TILEDATA_PER_TILEMAP);
245 tilemaps_data.append(tilemap);
246 }
247
248 tilemaps_data.push_update();
249
250 gpu::Shader *sh = GPU_shader_create_from_info_name("eevee_shadow_tag_update");
252 "eevee_shadow_tag_update_propagate");
253
254 gpu::Batch *box_batch = GPU_batch_unit_cube();
255
256 gpu::FrameBuffer *fb = GPU_framebuffer_create("empty_tagging_fb");
257 GPU_framebuffer_default_size(fb, SHADOW_TILEMAP_RES, SHADOW_TILEMAP_RES);
258
259 PassSimple pass("Test");
260 pass.shader_set(sh);
261 pass.framebuffer_set(&fb);
262 pass.push_constant("tilemap_count", int(tilemaps_data.size()));
263 pass.bind_ssbo("tilemaps_buf", tilemaps_data);
264 pass.bind_ssbo("tiles_buf", tiles_data);
265 pass.bind_ssbo("bounds_buf", &manager.bounds_buf.previous());
266 pass.bind_ssbo("resource_ids_buf", past_casters_updated);
267 pass.draw(box_batch, past_casters_updated.size() * tilemaps_data.size());
268 pass.bind_ssbo("bounds_buf", &manager.bounds_buf.current());
269 pass.bind_ssbo("resource_ids_buf", curr_casters_updated);
270 pass.draw(box_batch, curr_casters_updated.size() * tilemaps_data.size());
272
273 pass.shader_set(sh_propagate);
274 pass.bind_ssbo("tilemaps_buf", tilemaps_data);
275 pass.bind_ssbo("tiles_buf", tiles_data);
276 pass.dispatch(int3(1, 1, tilemaps_data.size()));
278
279 draw::View view("Test");
281 math::projection::orthographic(-1.0f, 1.0f, -1.0f, 1.0f, -1.0f, 1.0f));
282
283 manager.submit(pass, view);
284
285 tiles_data.read();
286
288 StringRefNull expected_lod0 =
289 "--------------------------------"
290 "--------------------------------"
291 "--------------------------------"
292 "--------------------------------"
293 "--------------------------------"
294 "--------------------------------"
295 "--------------------------------"
296 "--------------------------------"
297 "--------------------------------"
298 "--------------------------------"
299 "--------------------------------"
300 "--------------------------------"
301 "--------------------------------"
302 "--------------------------------"
303 "--------------------------------"
304 "--------------------------------"
305 "--------------------------------"
306 "--------------------------------"
307 "--------------------------------"
308 "xxxxx--------------xxxxxxxxxx---"
309 "xxxxx--------------xxxxxxxxxx---"
310 "xxxxx--------------xxxxxxxxxx---"
311 "xxxxx--------------xxxxxxxxxx---"
312 "xxxxx--------------xxxxxxxxxx---"
313 "xxxxx--------------xxxxxxxxxx---"
314 "xxxxx--------------xxxxxxxxxx---"
315 "xxxxx--------------xxxxxxxxxx---"
316 "xxxxx--------------xxxxxxxxxx---"
317 "xxxxx--------------xxxxxxxxxx---"
318 "--------------------------------"
319 "--------------------------------"
320 "--------------------------------";
321 StringRefNull expected_lod1 =
322 "----------------"
323 "----------------"
324 "----------------"
325 "----------------"
326 "----------------"
327 "----------------"
328 "----------------"
329 "----------------"
330 "----------------"
331 "xxx------xxxxxx-"
332 "xxx------xxxxxx-"
333 "xxx------xxxxxx-"
334 "xxx------xxxxxx-"
335 "xxx------xxxxxx-"
336 "xxx------xxxxxx-"
337 "----------------";
338 StringRefNull expected_lod2 =
339 "--------"
340 "--------"
341 "--------"
342 "--------"
343 "xx--xxxx"
344 "xx--xxxx"
345 "xx--xxxx"
346 "xx--xxxx";
347 StringRefNull expected_lod3 =
348 "----"
349 "----"
350 "x-xx"
351 "x-xx";
352 StringRefNull expected_lod4 =
353 "--"
354 "xx";
355 StringRefNull expected_lod5 = "x";
356 const uint lod0_len = SHADOW_TILEMAP_LOD0_LEN;
357 const uint lod1_len = SHADOW_TILEMAP_LOD1_LEN;
358 const uint lod2_len = SHADOW_TILEMAP_LOD2_LEN;
359 const uint lod3_len = SHADOW_TILEMAP_LOD3_LEN;
360 const uint lod4_len = SHADOW_TILEMAP_LOD4_LEN;
361 const uint lod5_len = SHADOW_TILEMAP_LOD5_LEN;
362
363 auto stringify_result = [&](uint start, uint len) -> std::string {
364 std::string result;
365 for (auto i : IndexRange(start, len)) {
366 result += (shadow_tile_unpack(tiles_data[i]).do_update) ? "x" : "-";
367 }
368 return result;
369 };
370
371 EXPECT_EQ(stringify_result(0, lod0_len), expected_lod0);
372 EXPECT_EQ(stringify_result(lod0_len, lod1_len), expected_lod1);
373 EXPECT_EQ(stringify_result(lod0_len + lod1_len, lod2_len), expected_lod2);
374 EXPECT_EQ(stringify_result(lod0_len + lod1_len + lod2_len, lod3_len), expected_lod3);
375 EXPECT_EQ(stringify_result(lod0_len + lod1_len + lod2_len + lod3_len, lod4_len), expected_lod4);
376 EXPECT_EQ(stringify_result(lod0_len + lod1_len + lod2_len + lod3_len + lod4_len, lod5_len),
377 expected_lod5);
378
380
381 GPU_shader_free(sh);
382 GPU_shader_free(sh_propagate);
385 GPU_BATCH_DISCARD_SAFE(box_batch);
387}
388DRAW_TEST(eevee_shadow_tag_update)
389
391{
393 ShadowTileMapDataBuf tilemaps_data = {"tilemaps_data"};
394 ShadowTileDataBuf tiles_data = {"tiles_data"};
395 ShadowPageHeapBuf pages_free_data = {"PagesFreeBuf"};
396 ShadowPageCacheBuf pages_cached_data = {"PagesCachedBuf"};
397 ShadowPagesInfoDataBuf pages_infos_data = {"PagesInfosBuf"};
398
399 int tiles_index = 1;
400 int tile_orphaned_cached = tiles_index * SHADOW_TILEDATA_PER_TILEMAP + 5;
401 int tile_orphaned_allocated = tiles_index * SHADOW_TILEDATA_PER_TILEMAP + 6;
402 int tile_used_cached = tiles_index * SHADOW_TILEDATA_PER_TILEMAP + 260;
403 int tile_used_allocated = tiles_index * SHADOW_TILEDATA_PER_TILEMAP + 32;
404 int tile_used_unallocated = tiles_index * SHADOW_TILEDATA_PER_TILEMAP + 64;
405 int tile_unused_cached = tiles_index * SHADOW_TILEDATA_PER_TILEMAP + 9;
406 int tile_unused_allocated = tiles_index * SHADOW_TILEDATA_PER_TILEMAP + 8;
407 int page_free_count = SHADOW_MAX_PAGE - 6;
408
409 for (uint i : IndexRange(2, page_free_count)) {
410 uint3 page = uint3((i % SHADOW_PAGE_PER_ROW),
411 (i / SHADOW_PAGE_PER_ROW) % SHADOW_PAGE_PER_COL,
412 (i / SHADOW_PAGE_PER_LAYER));
413 pages_free_data[i] = shadow_page_pack(page);
414 }
415 pages_free_data.push_update();
416
417 pages_infos_data.page_free_count = page_free_count;
418 pages_infos_data.page_alloc_count = 0;
419 pages_infos_data.page_cached_next = 2u;
420 pages_infos_data.page_cached_start = 0u;
421 pages_infos_data.page_cached_end = 2u;
422 pages_infos_data.push_update();
423
424 for (uint i : IndexRange(pages_cached_data.size())) {
425 pages_cached_data[i] = uint2(-1, -1);
426 }
427 pages_cached_data[0] = uint2(0, tile_orphaned_cached);
428 pages_cached_data[1] = uint2(1, tile_used_cached);
429 pages_cached_data.push_update();
430
431 {
432 ShadowTileData tile = {};
433
434 tiles_data.clear_to_zero();
435 tiles_data.read();
436
437 /* is_orphaned = true */
438 tile.is_used = false;
439 tile.do_update = true;
440
441 tile.is_cached = true;
442 tile.is_allocated = false;
443 tiles_data[tile_orphaned_cached] = shadow_tile_pack(tile);
444
445 tile.is_cached = false;
446 tile.is_allocated = true;
447 tiles_data[tile_orphaned_allocated] = shadow_tile_pack(tile);
448
449 /* is_orphaned = false */
450 tile.do_update = false;
451 tile.is_used = true;
452
453 tile.is_cached = true;
454 tile.is_allocated = false;
455 tiles_data[tile_used_cached] = shadow_tile_pack(tile);
456
457 tile.is_cached = false;
458 tile.is_allocated = true;
459 tiles_data[tile_used_allocated] = shadow_tile_pack(tile);
460
461 tile.is_cached = false;
462 tile.is_allocated = false;
463 tiles_data[tile_used_unallocated] = shadow_tile_pack(tile);
464
465 tile.is_used = false;
466 tile.is_cached = true;
467 tile.is_allocated = false;
468 tiles_data[tile_unused_cached] = shadow_tile_pack(tile);
469
470 tile.is_cached = false;
471 tile.is_allocated = true;
472 tiles_data[tile_unused_allocated] = shadow_tile_pack(tile);
473
474 tiles_data.push_update();
475 }
476 {
477 ShadowTileMapData tilemap = {};
478 tilemap.tiles_index = tiles_index * SHADOW_TILEDATA_PER_TILEMAP;
479 tilemaps_data.append(tilemap);
480 tilemaps_data.push_update();
481 }
482
483 gpu::Shader *sh = GPU_shader_create_from_info_name("eevee_shadow_page_free");
484
485 PassSimple pass("Test");
486 pass.shader_set(sh);
487 pass.bind_ssbo("tilemaps_buf", tilemaps_data);
488 pass.bind_ssbo("tiles_buf", tiles_data);
489 pass.bind_ssbo("pages_infos_buf", pages_infos_data);
490 pass.bind_ssbo("pages_free_buf", pages_free_data);
491 pass.bind_ssbo("pages_cached_buf", pages_cached_data);
492 pass.dispatch(int3(1, 1, tilemaps_data.size()));
494
495 Manager manager;
496 manager.submit(pass);
497
498 tiles_data.read();
499 pages_infos_data.read();
500
501 EXPECT_EQ(shadow_tile_unpack(tiles_data[tile_orphaned_cached]).is_cached, false);
502 EXPECT_EQ(shadow_tile_unpack(tiles_data[tile_orphaned_cached]).is_allocated, false);
503 EXPECT_EQ(shadow_tile_unpack(tiles_data[tile_orphaned_allocated]).is_cached, false);
504 EXPECT_EQ(shadow_tile_unpack(tiles_data[tile_orphaned_allocated]).is_allocated, false);
505 EXPECT_EQ(shadow_tile_unpack(tiles_data[tile_used_cached]).is_cached, false);
506 EXPECT_EQ(shadow_tile_unpack(tiles_data[tile_used_cached]).is_allocated, true);
507 EXPECT_EQ(shadow_tile_unpack(tiles_data[tile_used_allocated]).is_cached, false);
508 EXPECT_EQ(shadow_tile_unpack(tiles_data[tile_used_allocated]).is_allocated, true);
509 EXPECT_EQ(shadow_tile_unpack(tiles_data[tile_used_unallocated]).is_cached, false);
510 EXPECT_EQ(shadow_tile_unpack(tiles_data[tile_used_unallocated]).is_allocated, false);
511 EXPECT_EQ(shadow_tile_unpack(tiles_data[tile_unused_cached]).is_cached, true);
512 EXPECT_EQ(shadow_tile_unpack(tiles_data[tile_unused_cached]).is_allocated, false);
513 EXPECT_EQ(shadow_tile_unpack(tiles_data[tile_unused_allocated]).is_cached, true);
514 EXPECT_EQ(shadow_tile_unpack(tiles_data[tile_unused_allocated]).is_allocated, false);
515 EXPECT_EQ(pages_infos_data.page_alloc_count, 1);
516 EXPECT_EQ(pages_infos_data.page_free_count, page_free_count + 2);
517 EXPECT_EQ(pages_infos_data.page_cached_next, 3);
518 EXPECT_EQ(pages_infos_data.page_cached_end, 2);
519
521
522 GPU_shader_free(sh);
525}
526DRAW_TEST(eevee_shadow_free)
527
529 private:
530 ShadowTileDataBuf tiles_data = {"tiles_data"};
531 ShadowPageHeapBuf pages_free_data = {"PagesFreeBuf"};
532 ShadowPageCacheBuf pages_cached_data = {"PagesCachedBuf"};
533 ShadowPagesInfoDataBuf pages_infos_data = {"PagesInfosBuf"};
534 StorageBuffer<DispatchCommand> clear_dispatch_buf;
535 StorageBuffer<DrawCommand> tile_draw_buf;
536 ShadowStatisticsBuf statistics_buf = {"statistics_buf"};
537
538 public:
539 TestDefrag(int allocation_count,
540 int descriptor_offset,
542 StringRefNull expect)
543 {
544 for (uint i : IndexRange(SHADOW_MAX_PAGE)) {
545 uint2 page = {i % SHADOW_PAGE_PER_ROW, i / SHADOW_PAGE_PER_ROW};
546 pages_free_data[i] = page.x | (page.y << 16u);
547 }
548
549 for (uint i : IndexRange(tiles_data.size())) {
550 tiles_data[i] = 0;
551 }
552
553 int free_count = SHADOW_MAX_PAGE;
554 int tile_index = 0;
555
556 for (uint i : IndexRange(pages_cached_data.size())) {
557 pages_cached_data[i] = uint2(-1, -1);
558 }
559
560 int cached_index = descriptor_offset;
561 int hole_count = 0;
562 int inserted_count = 0;
563 ShadowTileData tile = {};
564 tile.is_cached = true;
565 for (char c : descriptor) {
566 switch (c) {
567 case 'c':
568 tile.cache_index = cached_index++ % SHADOW_MAX_PAGE;
569 pages_cached_data[tile.cache_index] = uint2(pages_free_data[--free_count], tile_index);
570 tiles_data[tile_index++] = shadow_tile_pack(tile);
571 break;
572 case 'f':
573 pages_cached_data[cached_index++ % SHADOW_MAX_PAGE] = uint2(-1, -1);
574 hole_count++;
575 break;
576 case 'i':
577 tile.cache_index = (cached_index + inserted_count++) % SHADOW_MAX_PAGE;
578 pages_cached_data[tile.cache_index] = uint2(pages_free_data[--free_count], tile_index);
579 tiles_data[tile_index++] = shadow_tile_pack(tile);
580 break;
581 default:
582 break;
583 }
584 }
585
586 pages_infos_data.page_alloc_count = allocation_count;
587 pages_infos_data.page_cached_next = cached_index + inserted_count;
588 pages_infos_data.page_free_count = free_count;
589 pages_infos_data.page_cached_start = descriptor_offset;
590 pages_infos_data.page_cached_end = cached_index;
591
592 tiles_data.push_update();
593 pages_infos_data.push_update();
594 pages_free_data.push_update();
595 pages_cached_data.push_update();
596
597 gpu::Shader *sh = GPU_shader_create_from_info_name("eevee_shadow_page_defrag");
598
599 PassSimple pass("Test");
600 pass.shader_set(sh);
601 pass.bind_ssbo("tiles_buf", tiles_data);
602 pass.bind_ssbo("pages_infos_buf", pages_infos_data);
603 pass.bind_ssbo("pages_free_buf", pages_free_data);
604 pass.bind_ssbo("pages_cached_buf", pages_cached_data);
605 pass.bind_ssbo("clear_dispatch_buf", clear_dispatch_buf);
606 pass.bind_ssbo("tile_draw_buf", tile_draw_buf);
607 pass.bind_ssbo("statistics_buf", statistics_buf);
608 pass.dispatch(int3(1, 1, 1));
610
611 Manager manager;
612 manager.submit(pass);
613
614 tiles_data.read();
615 pages_cached_data.read();
616 pages_infos_data.read();
617
618 std::string result;
619 int expect_cached_len = 0;
620 for (auto i : IndexRange(descriptor_offset, descriptor.size())) {
621 if (pages_cached_data[i % SHADOW_MAX_PAGE].y != -1) {
622 result += 'c';
623 expect_cached_len++;
624 }
625 else {
626 result += 'f';
627 }
628 }
629 EXPECT_EQ(expect, result);
630
631 allocation_count = min_ii(allocation_count, SHADOW_MAX_PAGE);
632
633 int additional_pages = max_ii(0, allocation_count - free_count);
634 int expected_free_count = max_ii(free_count, allocation_count);
635 int expected_start = descriptor_offset + hole_count + additional_pages;
636 int result_cached_len = pages_infos_data.page_cached_end - pages_infos_data.page_cached_start;
637
638 if (expected_start > SHADOW_MAX_PAGE) {
639 expected_start -= SHADOW_MAX_PAGE;
640 }
641
642 EXPECT_EQ(expected_free_count, pages_infos_data.page_free_count);
643 EXPECT_EQ(expected_start, pages_infos_data.page_cached_start);
644 EXPECT_EQ(expect_cached_len, result_cached_len);
645 EXPECT_EQ(pages_infos_data.page_cached_end, pages_infos_data.page_cached_next);
646
648
649 GPU_shader_free(sh);
651 }
652};
653
655{
656 TestDefrag(0, 0, "cfi", "fcc");
657 TestDefrag(0, 0, "fci", "fcc");
658 TestDefrag(0, 47, "ccfcffccfcfciiiii", "fffffcccccccccccc");
659 TestDefrag(10, SHADOW_MAX_PAGE - 5, "ccfcffccfcfciiiii", "fffffcccccccccccc");
660 TestDefrag(SHADOW_MAX_PAGE - 8, 30, "ccfcffccfcfciiiii", "fffffffffcccccccc");
661 TestDefrag(SHADOW_MAX_PAGE - 4, 30, "ccfcffccfcfciiiii", "fffffffffffffcccc");
662 /* Over allocation but should not crash. */
663 TestDefrag(SHADOW_MAX_PAGE + 4, 30, "ccfcffccfcfciiiii", "fffffffffffffffff");
664}
665DRAW_TEST(eevee_shadow_defrag)
666
668 private:
669 ShadowTileMapDataBuf tilemaps_data = {"tilemaps_data"};
670 ShadowTileDataBuf tiles_data = {"tiles_data"};
671 ShadowPageHeapBuf pages_free_data = {"PagesFreeBuf"};
672 ShadowPageCacheBuf pages_cached_data = {"PagesCachedBuf"};
673 ShadowPagesInfoDataBuf pages_infos_data = {"PagesInfosBuf"};
674 ShadowStatisticsBuf statistics_buf = {"statistics_buf"};
675
676 public:
677 TestAlloc(int page_free_count)
678 {
680 int tiles_index = 1;
681
682 for (int i : IndexRange(SHADOW_MAX_TILE)) {
683 tiles_data[i] = 0;
684 }
685
686 for (uint i : IndexRange(0, page_free_count)) {
687 uint2 page = {i % SHADOW_PAGE_PER_ROW, i / SHADOW_PAGE_PER_ROW};
688 pages_free_data[i] = page.x | (page.y << 16u);
689 }
690 pages_free_data.push_update();
691 pages_cached_data.push_update();
692
693 pages_infos_data.page_free_count = page_free_count;
694 pages_infos_data.page_alloc_count = 1;
695 pages_infos_data.page_cached_next = 0u;
696 pages_infos_data.page_cached_start = 0u;
697 pages_infos_data.page_cached_end = 0u;
698 pages_infos_data.push_update();
699
700 statistics_buf.view_needed_count = 0;
701 statistics_buf.push_update();
702
703 int tile_allocated = tiles_index * SHADOW_TILEDATA_PER_TILEMAP + 5;
704 int tile_free = tiles_index * SHADOW_TILEDATA_PER_TILEMAP + 6;
705
706 {
707 ShadowTileData tile = {};
708
709 tile.is_used = true;
710 tile.do_update = false;
711
712 tile.is_cached = false;
713 tile.is_allocated = false;
714 tiles_data[tile_free] = shadow_tile_pack(tile);
715
716 tile.is_cached = false;
717 tile.is_allocated = true;
718 tiles_data[tile_allocated] = shadow_tile_pack(tile);
719
720 tiles_data.push_update();
721 }
722 {
723 ShadowTileMapData tilemap = {};
724 tilemap.tiles_index = tiles_index * SHADOW_TILEDATA_PER_TILEMAP;
725 tilemaps_data.append(tilemap);
726 tilemaps_data.push_update();
727 }
728
729 gpu::Shader *sh = GPU_shader_create_from_info_name("eevee_shadow_page_allocate");
730
731 PassSimple pass("Test");
732 pass.shader_set(sh);
733 pass.bind_ssbo("tilemaps_buf", tilemaps_data);
734 pass.bind_ssbo("tiles_buf", tiles_data);
735 pass.bind_ssbo("pages_infos_buf", pages_infos_data);
736 pass.bind_ssbo("pages_free_buf", pages_free_data);
737 pass.bind_ssbo("pages_cached_buf", pages_cached_data);
738 pass.bind_ssbo("statistics_buf", statistics_buf);
739 pass.dispatch(int3(1, 1, tilemaps_data.size()));
741
742 Manager manager;
743 manager.submit(pass);
744
745 tiles_data.read();
746 pages_infos_data.read();
747
748 bool alloc_success = page_free_count >= 1;
749
750 EXPECT_EQ(shadow_tile_unpack(tiles_data[tile_free]).do_update, alloc_success);
751 EXPECT_EQ(shadow_tile_unpack(tiles_data[tile_free]).is_allocated, alloc_success);
752 EXPECT_EQ(shadow_tile_unpack(tiles_data[tile_allocated]).do_update, false);
753 EXPECT_EQ(shadow_tile_unpack(tiles_data[tile_allocated]).is_allocated, true);
754 EXPECT_EQ(pages_infos_data.page_free_count, page_free_count - 1);
755
757
758 GPU_shader_free(sh);
761 }
762};
763
765{
766 {
767 TestAlloc test(SHADOW_MAX_PAGE);
768 }
769 {
770 TestAlloc test(1);
771 }
772 {
773 TestAlloc test(0);
774 }
775}
776DRAW_TEST(eevee_shadow_alloc)
777
779{
781 GTEST_SKIP() << "Device does not support multi viewport.";
782 }
783
785 ShadowTileMapDataBuf tilemaps_data = {"tilemaps_data"};
786 ShadowTileDataBuf tiles_data = {"tiles_data"};
787 ShadowPageHeapBuf pages_free_data = {"PagesFreeBuf"};
788 ShadowPageCacheBuf pages_cached_data = {"PagesCachedBuf"};
789 ShadowPagesInfoDataBuf pages_infos_data = {"PagesInfosBuf"};
790 ShadowStatisticsBuf statistics_buf = {"statistics_buf"};
791 ShadowRenderViewBuf render_views_buf = {"render_views_buf"};
793 "tilemaps_clip"};
794
795 const uint lod0_len = SHADOW_TILEMAP_LOD0_LEN;
796 const uint lod1_len = SHADOW_TILEMAP_LOD1_LEN;
797 const uint lod2_len = SHADOW_TILEMAP_LOD2_LEN;
798 const uint lod3_len = SHADOW_TILEMAP_LOD3_LEN;
799 const uint lod4_len = SHADOW_TILEMAP_LOD4_LEN;
800
801 const uint lod0_ofs = 0;
802 const uint lod1_ofs = lod0_len;
803 const uint lod2_ofs = lod1_ofs + lod1_len;
804 const uint lod3_ofs = lod2_ofs + lod2_len;
805 const uint lod4_ofs = lod3_ofs + lod3_len;
806 const uint lod5_ofs = lod4_ofs + lod4_len;
807
808 for (auto i : IndexRange(SHADOW_TILEDATA_PER_TILEMAP)) {
809 tiles_data[i] = SHADOW_NO_DATA;
810 }
811
812 {
813 ShadowTileData tile = {};
814 tile.is_used = true;
815 tile.is_allocated = true;
816
817 tile.page = uint3(1, 0, 0);
818 tile.do_update = false;
819 tiles_data[lod0_ofs] = shadow_tile_pack(tile);
820
821 tile.page = uint3(2, 0, 0);
822 tile.do_update = false;
823 tiles_data[lod1_ofs] = shadow_tile_pack(tile);
824
825 tile.page = uint3(3, 0, 0);
826 tile.do_update = true;
827 tiles_data[lod2_ofs] = shadow_tile_pack(tile);
828
829 tile.page = uint3(4, 0, 0);
830 tile.do_update = true;
831 tiles_data[lod3_ofs] = shadow_tile_pack(tile);
832
833 tile.page = uint3(5, 0, 0);
834 tile.do_update = true;
835 tiles_data[lod4_ofs] = shadow_tile_pack(tile);
836
837 tile.page = uint3(6, 0, 0);
838 tile.do_update = true;
839 tiles_data[lod5_ofs] = shadow_tile_pack(tile);
840
841 tile.page = uint3(7, 0, 0);
842 tile.do_update = true;
843 tiles_data[lod0_ofs + 31] = shadow_tile_pack(tile);
844
845 tile.page = uint3(0, 1, 0);
846 tile.do_update = true;
847 tiles_data[lod3_ofs + 8] = shadow_tile_pack(tile);
848
849 tile.page = uint3(1, 1, 0);
850 tile.do_update = true;
851 tiles_data[lod0_ofs + 32 * 16 - 8] = shadow_tile_pack(tile);
852
853 tiles_data.push_update();
854 }
855 {
856 ShadowTileMapData tilemap = {};
857 tilemap.viewmat = float4x4::identity();
858 tilemap.tiles_index = 0;
859 tilemap.clip_data_index = 0;
860 tilemap.clip_far = 10.0f;
861 tilemap.clip_near = 1.0f;
862 tilemap.half_size = 1.0f;
864 tilemaps_data.append(tilemap);
865
866 tilemaps_data.push_update();
867 }
868 {
869 ShadowTileMapClip clip = {};
870 clip.clip_far_stored = 10.0f;
871 clip.clip_near_stored = 1.0f;
872 tilemaps_clip[0] = clip;
873 tilemaps_clip.push_update();
874 }
875 {
876 statistics_buf.view_needed_count = 0;
877 statistics_buf.push_update();
878 }
879 {
880 pages_infos_data.page_free_count = -5;
881 pages_infos_data.page_alloc_count = 0;
882 pages_infos_data.page_cached_next = 0u;
883 pages_infos_data.page_cached_start = 0u;
884 pages_infos_data.page_cached_end = 0u;
885 pages_infos_data.push_update();
886 }
887
888 Texture tilemap_tx = {"tilemap_tx"};
889 tilemap_tx.ensure_2d(gpu::TextureFormat::UINT_32,
890 int2(SHADOW_TILEMAP_RES),
893 tilemap_tx.clear(uint4(0));
894
895 StorageArrayBuffer<ViewMatrices, DRW_VIEW_MAX> shadow_multi_view_buf = {"ShadowMultiView"};
896 StorageBuffer<DispatchCommand> clear_dispatch_buf;
897 StorageBuffer<DrawCommand> tile_draw_buf;
898 StorageArrayBuffer<uint, SHADOW_MAX_PAGE> dst_coord_buf = {"dst_coord_buf"};
899 StorageArrayBuffer<uint, SHADOW_MAX_PAGE> src_coord_buf = {"src_coord_buf"};
900 StorageArrayBuffer<uint, SHADOW_RENDER_MAP_SIZE> render_map_buf = {"render_map_buf"};
901 StorageArrayBuffer<uint, SHADOW_VIEW_MAX> viewport_index_buf = {"viewport_index_buf"};
902
903 GPU_storagebuf_clear(render_map_buf, 0xFFFFFFFFu);
904 clear_dispatch_buf.clear_to_zero();
905
906 gpu::Shader *sh = GPU_shader_create_from_info_name("eevee_shadow_tilemap_finalize");
907 PassSimple pass("Test");
908 pass.shader_set(sh);
909 pass.bind_ssbo("tilemaps_buf", tilemaps_data);
910 pass.bind_ssbo("tiles_buf", tiles_data);
911 pass.bind_ssbo("pages_infos_buf", pages_infos_data);
912 pass.bind_ssbo("statistics_buf", statistics_buf);
913 pass.bind_ssbo("view_infos_buf", shadow_multi_view_buf);
914 pass.bind_ssbo("render_view_buf", render_views_buf);
915 pass.bind_ssbo("tilemaps_clip_buf", tilemaps_clip);
916 pass.bind_image("tilemaps_img", tilemap_tx);
917 pass.push_constant("use_multi_viewport", GPU_multi_viewport_support());
918 pass.dispatch(int3(1, 1, tilemaps_data.size()));
920
921 gpu::Shader *sh2 = GPU_shader_create_from_info_name("eevee_shadow_tilemap_rendermap");
922 pass.shader_set(sh2);
923 pass.bind_ssbo("statistics_buf", statistics_buf);
924 pass.bind_ssbo("render_view_buf", render_views_buf);
925 pass.bind_ssbo("tiles_buf", tiles_data);
926 pass.bind_ssbo("clear_dispatch_buf", clear_dispatch_buf);
927 pass.bind_ssbo("tile_draw_buf", tile_draw_buf);
928 pass.bind_ssbo("dst_coord_buf", &dst_coord_buf);
929 pass.bind_ssbo("src_coord_buf", &src_coord_buf);
930 pass.bind_ssbo("render_map_buf", &render_map_buf);
931 pass.dispatch(int3(1, 1, SHADOW_VIEW_MAX));
933
934 Manager manager;
935 manager.submit(pass);
936
937 {
938 /* Check output views. */
939 shadow_multi_view_buf.read();
940
941 for (auto i : IndexRange(5)) {
942 EXPECT_EQ(shadow_multi_view_buf[i].viewmat, float4x4::identity());
943 EXPECT_EQ(shadow_multi_view_buf[i].viewinv, float4x4::identity());
944 }
945
946 EXPECT_EQ(shadow_multi_view_buf[0].winmat,
947 math::projection::perspective(-1.0f, 1.0f, -1.0f, 1.0f, 1.0f, 10.0f));
948 EXPECT_EQ(shadow_multi_view_buf[1].winmat,
949 math::projection::perspective(-1.0f, 0.0f, -1.0f, 0.0f, 1.0f, 10.0f));
950 EXPECT_EQ(shadow_multi_view_buf[2].winmat,
951 math::projection::perspective(-1.0f, 1.0f, -1.0f, 1.0f, 1.0f, 10.0f));
952 EXPECT_EQ(shadow_multi_view_buf[3].winmat,
953 math::projection::perspective(-1.0f, -0.75f, -1.0f, -0.75f, 1.0f, 10.0f));
954 EXPECT_EQ(shadow_multi_view_buf[4].winmat,
955 math::projection::perspective(0.5f, 1.5f, -1.0f, 0.0f, 1.0f, 10.0f));
956 }
957
958 {
959 uint *pixels = tilemap_tx.read<uint32_t>(GPU_DATA_UINT);
960
961 std::string result;
962 for (auto y : IndexRange(SHADOW_TILEMAP_RES)) {
963 for (auto x : IndexRange(SHADOW_TILEMAP_RES)) {
964 ShadowTileData tile = shadow_tile_unpack(pixels[y * SHADOW_TILEMAP_RES + x]);
965 result += std::to_string(tile.page.x + tile.page.y * SHADOW_PAGE_PER_ROW);
966 }
967 }
968
969 MEM_SAFE_DELETE(pixels);
970
972 StringRefNull expected_pages =
973 "12334444555555556666666666666667"
974 "22334444555555556666666666666666"
975 "33334444555555556666666666666666"
976 "33334444555555556666666666666666"
977 "44444444555555556666666666666666"
978 "44444444555555556666666666666666"
979 "44444444555555556666666666666666"
980 "44444444555555556666666666666666"
981 "55555555555555556666666666666666"
982 "55555555555555556666666666666666"
983 "55555555555555556666666666666666"
984 "55555555555555556666666666666666"
985 "55555555555555556666666666666666"
986 "55555555555555556666666666666666"
987 "55555555555555556666666666666666"
988 "55555555555555556666666696666666"
989 "88888888666666666666666666666666"
990 "88888888666666666666666666666666"
991 "88888888666666666666666666666666"
992 "88888888666666666666666666666666"
993 "88888888666666666666666666666666"
994 "88888888666666666666666666666666"
995 "88888888666666666666666666666666"
996 "88888888666666666666666666666666"
997 "66666666666666666666666666666666"
998 "66666666666666666666666666666666"
999 "66666666666666666666666666666666"
1000 "66666666666666666666666666666666"
1001 "66666666666666666666666666666666"
1002 "66666666666666666666666666666666"
1003 "66666666666666666666666666666666"
1004 "66666666666666666666666666666666";
1005
1006 EXPECT_EQ(expected_pages, result);
1007 }
1008
1009 {
1010 auto stringify_view = [](Span<uint> data) -> std::string {
1011 std::string result;
1012 for (auto x : data) {
1013 result += (x == 0u) ? 'x' : ((x == 0xFFFFFFFFu) ? '-' : '0' + (x % 10));
1014 }
1015 return result;
1016 };
1017
1019 StringRefNull expected_view0 =
1020 "6-------------------------------"
1021 "--------------------------------"
1022 "--------------------------------"
1023 "--------------------------------"
1024 "--------------------------------"
1025 "--------------------------------"
1026 "--------------------------------"
1027 "--------------------------------"
1028 "--------------------------------"
1029 "--------------------------------"
1030 "--------------------------------"
1031 "--------------------------------"
1032 "--------------------------------"
1033 "--------------------------------"
1034 "--------------------------------"
1035 "--------------------------------"
1036 "--------------------------------"
1037 "--------------------------------"
1038 "--------------------------------"
1039 "--------------------------------"
1040 "--------------------------------"
1041 "--------------------------------"
1042 "--------------------------------"
1043 "--------------------------------"
1044 "--------------------------------"
1045 "--------------------------------"
1046 "--------------------------------"
1047 "--------------------------------"
1048 "--------------------------------"
1049 "--------------------------------"
1050 "--------------------------------"
1051 "--------------------------------";
1052
1053 StringRefNull expected_view1 =
1054 "5-------------------------------"
1055 "--------------------------------"
1056 "--------------------------------"
1057 "--------------------------------"
1058 "--------------------------------"
1059 "--------------------------------"
1060 "--------------------------------"
1061 "--------------------------------"
1062 "--------------------------------"
1063 "--------------------------------"
1064 "--------------------------------"
1065 "--------------------------------"
1066 "--------------------------------"
1067 "--------------------------------"
1068 "--------------------------------"
1069 "--------------------------------"
1070 "--------------------------------"
1071 "--------------------------------"
1072 "--------------------------------"
1073 "--------------------------------"
1074 "--------------------------------"
1075 "--------------------------------"
1076 "--------------------------------"
1077 "--------------------------------"
1078 "--------------------------------"
1079 "--------------------------------"
1080 "--------------------------------"
1081 "--------------------------------"
1082 "--------------------------------"
1083 "--------------------------------"
1084 "--------------------------------"
1085 "--------------------------------";
1086
1087 StringRefNull expected_view2 =
1088 "4-------------------------------"
1089 "--------------------------------"
1090 "8-------------------------------"
1091 "--------------------------------"
1092 "--------------------------------"
1093 "--------------------------------"
1094 "--------------------------------"
1095 "--------------------------------"
1096 "--------------------------------"
1097 "--------------------------------"
1098 "--------------------------------"
1099 "--------------------------------"
1100 "--------------------------------"
1101 "--------------------------------"
1102 "--------------------------------"
1103 "--------------------------------"
1104 "--------------------------------"
1105 "--------------------------------"
1106 "--------------------------------"
1107 "--------------------------------"
1108 "--------------------------------"
1109 "--------------------------------"
1110 "--------------------------------"
1111 "--------------------------------"
1112 "--------------------------------"
1113 "--------------------------------"
1114 "--------------------------------"
1115 "--------------------------------"
1116 "--------------------------------"
1117 "--------------------------------"
1118 "--------------------------------"
1119 "--------------------------------";
1120
1121 StringRefNull expected_view3 =
1122 "3-------------------------------"
1123 "--------------------------------"
1124 "--------------------------------"
1125 "--------------------------------"
1126 "--------------------------------"
1127 "--------------------------------"
1128 "--------------------------------"
1129 "--------------------------------"
1130 "--------------------------------"
1131 "--------------------------------"
1132 "--------------------------------"
1133 "--------------------------------"
1134 "--------------------------------"
1135 "--------------------------------"
1136 "--------------------------------"
1137 "--------------------------------"
1138 "--------------------------------"
1139 "--------------------------------"
1140 "--------------------------------"
1141 "--------------------------------"
1142 "--------------------------------"
1143 "--------------------------------"
1144 "--------------------------------"
1145 "--------------------------------"
1146 "--------------------------------"
1147 "--------------------------------"
1148 "--------------------------------"
1149 "--------------------------------"
1150 "--------------------------------"
1151 "--------------------------------"
1152 "--------------------------------"
1153 "--------------------------------";
1154
1155 StringRefNull expected_view4 =
1156 "-------7------------------------"
1157 "--------------------------------"
1158 "--------------------------------"
1159 "--------------------------------"
1160 "--------------------------------"
1161 "--------------------------------"
1162 "--------------------------------"
1163 "--------------------------------"
1164 "--------------------------------"
1165 "--------------------------------"
1166 "--------------------------------"
1167 "--------------------------------"
1168 "--------------------------------"
1169 "--------------------------------"
1170 "--------------------------------"
1171 "9-------------------------------"
1172 "--------------------------------"
1173 "--------------------------------"
1174 "--------------------------------"
1175 "--------------------------------"
1176 "--------------------------------"
1177 "--------------------------------"
1178 "--------------------------------"
1179 "--------------------------------"
1180 "--------------------------------"
1181 "--------------------------------"
1182 "--------------------------------"
1183 "--------------------------------"
1184 "--------------------------------"
1185 "--------------------------------"
1186 "--------------------------------"
1187 "--------------------------------";
1188
1189 render_map_buf.read();
1190
1191 EXPECT_EQ(stringify_view(Span<uint>(&render_map_buf[SHADOW_TILEMAP_LOD0_LEN * 0],
1192 SHADOW_TILEMAP_LOD0_LEN)),
1193 expected_view0);
1194 EXPECT_EQ(stringify_view(Span<uint>(&render_map_buf[SHADOW_TILEMAP_LOD0_LEN * 1],
1195 SHADOW_TILEMAP_LOD0_LEN)),
1196 expected_view1);
1197 EXPECT_EQ(stringify_view(Span<uint>(&render_map_buf[SHADOW_TILEMAP_LOD0_LEN * 2],
1198 SHADOW_TILEMAP_LOD0_LEN)),
1199 expected_view2);
1200 EXPECT_EQ(stringify_view(Span<uint>(&render_map_buf[SHADOW_TILEMAP_LOD0_LEN * 3],
1201 SHADOW_TILEMAP_LOD0_LEN)),
1202 expected_view3);
1203 EXPECT_EQ(stringify_view(Span<uint>(&render_map_buf[SHADOW_TILEMAP_LOD0_LEN * 4],
1204 SHADOW_TILEMAP_LOD0_LEN)),
1205 expected_view4);
1206 }
1207
1208 pages_infos_data.read();
1209 EXPECT_EQ(pages_infos_data.page_free_count, 0);
1210
1211 statistics_buf.read();
1212 EXPECT_EQ(statistics_buf.view_needed_count, 5);
1213
1215
1216 GPU_shader_free(sh);
1217 GPU_shader_free(sh2);
1220}
1221DRAW_TEST(eevee_shadow_finalize)
1222
1224{
1225 Vector<uint> test_values{0x00000000u, 0x00000001u, 0x0000000Fu, 0x000000FFu, 0xABCDEF01u,
1226 0xAAAAAAAAu, 0xBBBBBBBBu, 0xCCCCCCCCu, 0xDDDDDDDDu, 0xEEEEEEEEu,
1227 0xFFFFFFFFu, 0xDEADBEEFu, 0x8BADF00Du, 0xABADCAFEu, 0x0D15EA5Eu,
1228 0xFEE1DEADu, 0xDEADC0DEu, 0xC00010FFu, 0xBBADBEEFu, 0xBAAAAAADu};
1229
1230 for (auto value : test_values) {
1231 EXPECT_EQ(shadow_page_unpack(value),
1232 shadow_page_unpack(shadow_page_pack(shadow_page_unpack(value))));
1233
1234 EXPECT_EQ(shadow_lod_offset_unpack(value),
1235 shadow_lod_offset_unpack(shadow_lod_offset_pack(shadow_lod_offset_unpack(value))));
1236
1237 ShadowTileData expected_tile = shadow_tile_unpack(value);
1238 ShadowTileData result_tile = shadow_tile_unpack(shadow_tile_pack(expected_tile));
1239 EXPECT_EQ(expected_tile.page, result_tile.page);
1240 EXPECT_EQ(expected_tile.cache_index, result_tile.cache_index);
1241 EXPECT_EQ(expected_tile.is_used, result_tile.is_used);
1242 EXPECT_EQ(expected_tile.do_update, result_tile.do_update);
1243 EXPECT_EQ(expected_tile.is_allocated, result_tile.is_allocated);
1244 EXPECT_EQ(expected_tile.is_rendered, result_tile.is_rendered);
1245 EXPECT_EQ(expected_tile.is_cached, result_tile.is_cached);
1246
1247 ShadowSamplingTile expected_sampling_tile = shadow_sampling_tile_unpack(value);
1248 ShadowSamplingTile result_sampling_tile = shadow_sampling_tile_unpack(
1249 shadow_sampling_tile_pack(expected_sampling_tile));
1250 EXPECT_EQ(expected_sampling_tile.page, result_sampling_tile.page);
1251 EXPECT_EQ(expected_sampling_tile.lod, result_sampling_tile.lod);
1252 EXPECT_EQ(expected_sampling_tile.lod_offset, result_sampling_tile.lod_offset);
1253 EXPECT_EQ(expected_sampling_tile.is_valid, result_sampling_tile.is_valid);
1254 }
1255}
1256DRAW_TEST(eevee_shadow_tile_packing)
1257
1259{
1261
1262 Vector<uint32_t> tilemap_data(SHADOW_TILEMAP_RES * SHADOW_TILEMAP_RES * SHADOW_TILEMAP_PER_ROW);
1263 tilemap_data.fill(0);
1264
1265 auto pixel_get = [&](int x, int y, int tilemap_index) -> uint32_t & {
1266 /* NOTE: assumes that tilemap_index is < SHADOW_TILEMAP_PER_ROW. */
1267 return tilemap_data[y * SHADOW_TILEMAP_RES * SHADOW_TILEMAP_PER_ROW + x +
1268 tilemap_index * SHADOW_TILEMAP_RES];
1269 };
1271 tile.lod = 0;
1272 tile.lod_offset = uint2(0);
1273 tile.is_valid = true;
1274 tile.page = uint3(1, 0, 0);
1275 pixel_get(16, 16, 2) = shadow_sampling_tile_pack(tile);
1276 tile.page = uint3(2, 0, 0);
1277 pixel_get(17, 16, 2) = shadow_sampling_tile_pack(tile);
1278 tile.page = uint3(3, 0, 0);
1279 pixel_get(20, 20, 1) = shadow_sampling_tile_pack(tile);
1280 tile.page = uint3(4, 0, 0);
1281 pixel_get(17, 16, 0) = shadow_sampling_tile_pack(tile);
1282
1283 Texture tilemap_tx = {"tilemap_tx"};
1286 int2 tilemap_res(SHADOW_TILEMAP_RES * SHADOW_TILEMAP_PER_ROW, SHADOW_TILEMAP_RES);
1287 tilemap_tx.ensure_2d(gpu::TextureFormat::UINT_32, tilemap_res, usage);
1289 tilemap_tx, GPU_DATA_UINT, tilemap_data.data(), 0, 0, 0, tilemap_res.x, tilemap_res.y, 0);
1290
1291 /* Setup one directional light with 3 tilemaps. Fill only the needed data. */
1292 LightData light;
1293 light.type = LIGHT_SUN;
1294 light.sun.clipmap_lod_min = 0;
1295 light.sun.clipmap_lod_max = 2;
1296 /* Shift LOD0 by 1 tile towards bottom. */
1297 light.sun.clipmap_base_offset_neg = int2(0, 1 << 0);
1298 /* Shift LOD1 by 1 tile towards right. */
1299 light.sun.clipmap_base_offset_pos = int2(1 << 1, 0);
1300 light.tilemap_index = 0;
1301
1302 LightDataBuf culling_light_buf = {"Lights_culled"};
1303 culling_light_buf[0] = light;
1304 culling_light_buf.push_update();
1305
1306 LightCullingDataBuf culling_data_buf = {"LightCull_data"};
1307 culling_data_buf.local_lights_len = 0;
1308 culling_data_buf.sun_lights_len = 1;
1309 culling_data_buf.items_count = 1;
1310 culling_data_buf.push_update();
1311
1312 /* Needed for validation. But not used since we use directionals. */
1313 LightCullingZbinBuf culling_zbin_buf = {"LightCull_zbin"};
1314 LightCullingTileBuf culling_tile_buf = {"LightCull_tile"};
1315 ShadowTileMapDataBuf tilemaps_data = {"tilemaps_data"};
1316
1317 gpu::Shader *sh = GPU_shader_create_from_info_name("eevee_shadow_tilemap_amend");
1318
1319 PassSimple pass("Test");
1320 pass.shader_set(sh);
1321 pass.bind_image("tilemaps_img", tilemap_tx);
1322 pass.bind_ssbo("tilemaps_buf", tilemaps_data);
1323 pass.bind_ssbo(LIGHT_CULL_BUF_SLOT, culling_data_buf);
1324 pass.bind_ssbo(LIGHT_BUF_SLOT, culling_light_buf);
1325 pass.bind_ssbo(LIGHT_ZBIN_BUF_SLOT, culling_zbin_buf);
1326 pass.bind_ssbo(LIGHT_TILE_BUF_SLOT, culling_tile_buf);
1327 pass.bind_ssbo("light_buf_write", culling_light_buf);
1328 pass.dispatch(int3(1));
1330
1331 draw::View view("Test");
1332 view.sync(float4x4::identity(),
1333 math::projection::orthographic(-1.0f, 1.0f, -1.0f, 1.0f, -1.0f, 1.0f));
1334
1335 Manager manager;
1336 manager.submit(pass, view);
1337
1338 {
1339 uint *pixels = tilemap_tx.read<uint32_t>(GPU_DATA_UINT);
1340
1341 auto stringify_tilemap = [&](int tilemap_index) -> std::string {
1342 std::string result;
1343 for (auto y : IndexRange(SHADOW_TILEMAP_RES)) {
1344 for (auto x : IndexRange(SHADOW_TILEMAP_RES)) {
1345 /* NOTE: assumes that tilemap_index is < SHADOW_TILEMAP_PER_ROW. */
1346 int tile_ofs = y * SHADOW_TILEMAP_RES * SHADOW_TILEMAP_PER_ROW + x +
1347 tilemap_index * SHADOW_TILEMAP_RES;
1348 ShadowSamplingTile tile = shadow_sampling_tile_unpack(pixels[tile_ofs]);
1349 result += std::to_string(tile.page.x + tile.page.y * SHADOW_PAGE_PER_ROW);
1350 if (x + 1 == SHADOW_TILEMAP_RES / 2) {
1351 result += " ";
1352 }
1353 }
1354 result += "\n";
1355 if (y + 1 == SHADOW_TILEMAP_RES / 2) {
1356 result += "\n";
1357 }
1358 }
1359 return result;
1360 };
1361
1362 auto stringify_lod = [&](int tilemap_index) -> std::string {
1363 std::string result;
1364 for (auto y : IndexRange(SHADOW_TILEMAP_RES)) {
1365 for (auto x : IndexRange(SHADOW_TILEMAP_RES)) {
1366 /* NOTE: assumes that tilemap_index is < SHADOW_TILEMAP_PER_ROW. */
1367 int tile_ofs = y * SHADOW_TILEMAP_RES * SHADOW_TILEMAP_PER_ROW + x +
1368 tilemap_index * SHADOW_TILEMAP_RES;
1369 ShadowSamplingTile tile = shadow_sampling_tile_unpack(pixels[tile_ofs]);
1370 result += std::to_string(tile.lod);
1371 if (x + 1 == SHADOW_TILEMAP_RES / 2) {
1372 result += " ";
1373 }
1374 }
1375 result += "\n";
1376 if (y + 1 == SHADOW_TILEMAP_RES / 2) {
1377 result += "\n";
1378 }
1379 }
1380 return result;
1381 };
1382
1383 auto stringify_offset = [&](int tilemap_index) -> std::string {
1384 std::string result;
1385 for (auto y : IndexRange(SHADOW_TILEMAP_RES)) {
1386 for (auto x : IndexRange(SHADOW_TILEMAP_RES)) {
1387 /* NOTE: assumes that tilemap_index is < SHADOW_TILEMAP_PER_ROW. */
1388 int tile_ofs = y * SHADOW_TILEMAP_RES * SHADOW_TILEMAP_PER_ROW + x +
1389 tilemap_index * SHADOW_TILEMAP_RES;
1390 ShadowSamplingTile tile = shadow_sampling_tile_unpack(pixels[tile_ofs]);
1391 result += std::to_string(tile.lod_offset.x + tile.lod_offset.y);
1392 if (x + 1 == SHADOW_TILEMAP_RES / 2) {
1393 result += " ";
1394 }
1395 }
1396 result += "\n";
1397 if (y + 1 == SHADOW_TILEMAP_RES / 2) {
1398 result += "\n";
1399 }
1400 }
1401 return result;
1402 };
1403
1405
1406 StringRefNull expected_pages_lod2 =
1407 "0000000000000000 0000000000000000\n"
1408 "0000000000000000 0000000000000000\n"
1409 "0000000000000000 0000000000000000\n"
1410 "0000000000000000 0000000000000000\n"
1411 "0000000000000000 0000000000000000\n"
1412 "0000000000000000 0000000000000000\n"
1413 "0000000000000000 0000000000000000\n"
1414 "0000000000000000 0000000000000000\n"
1415 "0000000000000000 0000000000000000\n"
1416 "0000000000000000 0000000000000000\n"
1417 "0000000000000000 0000000000000000\n"
1418 "0000000000000000 0000000000000000\n"
1419 "0000000000000000 0000000000000000\n"
1420 "0000000000000000 0000000000000000\n"
1421 "0000000000000000 0000000000000000\n"
1422 "0000000000000000 0000000000000000\n"
1423 "\n"
1424 "0000000000000000 1200000000000000\n"
1425 "0000000000000000 0000000000000000\n"
1426 "0000000000000000 0000000000000000\n"
1427 "0000000000000000 0000000000000000\n"
1428 "0000000000000000 0000000000000000\n"
1429 "0000000000000000 0000000000000000\n"
1430 "0000000000000000 0000000000000000\n"
1431 "0000000000000000 0000000000000000\n"
1432 "0000000000000000 0000000000000000\n"
1433 "0000000000000000 0000000000000000\n"
1434 "0000000000000000 0000000000000000\n"
1435 "0000000000000000 0000000000000000\n"
1436 "0000000000000000 0000000000000000\n"
1437 "0000000000000000 0000000000000000\n"
1438 "0000000000000000 0000000000000000\n"
1439 "0000000000000000 0000000000000000\n";
1440
1441 StringRefNull expected_pages_lod1 =
1442 "0000000000000000 0000000000000000\n"
1443 "0000000000000000 0000000000000000\n"
1444 "0000000000000000 0000000000000000\n"
1445 "0000000000000000 0000000000000000\n"
1446 "0000000000000000 0000000000000000\n"
1447 "0000000000000000 0000000000000000\n"
1448 "0000000000000000 0000000000000000\n"
1449 "0000000000000000 0000000000000000\n"
1450 "0000000000000000 0000000000000000\n"
1451 "0000000000000000 0000000000000000\n"
1452 "0000000000000000 0000000000000000\n"
1453 "0000000000000000 0000000000000000\n"
1454 "0000000000000000 0000000000000000\n"
1455 "0000000000000000 0000000000000000\n"
1456 "0000000000000000 0000000000000000\n"
1457 "0000000000000000 0000000000000000\n"
1458 "\n"
1459 "0000000000000001 1220000000000000\n"
1460 "0000000000000001 1220000000000000\n"
1461 "0000000000000000 0000000000000000\n"
1462 "0000000000000000 0000000000000000\n"
1463 "0000000000000000 0000300000000000\n"
1464 "0000000000000000 0000000000000000\n"
1465 "0000000000000000 0000000000000000\n"
1466 "0000000000000000 0000000000000000\n"
1467 "0000000000000000 0000000000000000\n"
1468 "0000000000000000 0000000000000000\n"
1469 "0000000000000000 0000000000000000\n"
1470 "0000000000000000 0000000000000000\n"
1471 "0000000000000000 0000000000000000\n"
1472 "0000000000000000 0000000000000000\n"
1473 "0000000000000000 0000000000000000\n"
1474 "0000000000000000 0000000000000000\n";
1475
1476 StringRefNull expected_pages_lod0 =
1477 "0000000000000000 0000000000000000\n"
1478 "0000000000000000 0000000000000000\n"
1479 "0000000000000000 0000000000000000\n"
1480 "0000000000000000 0000000000000000\n"
1481 "0000000000000000 0000000000000000\n"
1482 "0000000000000000 0000000000000000\n"
1483 "0000000000000000 0000000000000000\n"
1484 "0000000000000000 0000000000000000\n"
1485 "0000000000000000 0000000000000000\n"
1486 "0000000000000000 0000000000000000\n"
1487 "0000000000000000 0000000000000000\n"
1488 "0000000000000000 0000000000000000\n"
1489 "0000000000000000 0000000000000000\n"
1490 "0000000000000000 0000000000000000\n"
1491 "0000000000000000 0000000000000000\n"
1492 "0000000000000000 0000000000000000\n"
1493 "\n"
1494 "0000000000000000 0400000000000000\n"
1495 "0000000000000011 1122220000000000\n"
1496 "0000000000000011 1122220000000000\n"
1497 "0000000000000011 1122220000000000\n"
1498 "0000000000000011 1122220000000000\n"
1499 "0000000000000000 0000000000000000\n"
1500 "0000000000000000 0000000000000000\n"
1501 "0000000000000000 0000000000000000\n"
1502 "0000000000000000 0000000000000000\n"
1503 "0000000000000000 0000000033000000\n"
1504 "0000000000000000 0000000033000000\n"
1505 "0000000000000000 0000000000000000\n"
1506 "0000000000000000 0000000000000000\n"
1507 "0000000000000000 0000000000000000\n"
1508 "0000000000000000 0000000000000000\n"
1509 "0000000000000000 0000000000000000\n";
1510
1511 EXPECT_EQ(expected_pages_lod2, stringify_tilemap(2));
1512 EXPECT_EQ(expected_pages_lod1, stringify_tilemap(1));
1513 EXPECT_EQ(expected_pages_lod0, stringify_tilemap(0));
1514
1515 StringRefNull expected_lod_lod0 =
1516 "0000000000000000 0000000000000000\n"
1517 "0000000000000000 0000000000000000\n"
1518 "0000000000000000 0000000000000000\n"
1519 "0000000000000000 0000000000000000\n"
1520 "0000000000000000 0000000000000000\n"
1521 "0000000000000000 0000000000000000\n"
1522 "0000000000000000 0000000000000000\n"
1523 "0000000000000000 0000000000000000\n"
1524 "0000000000000000 0000000000000000\n"
1525 "0000000000000000 0000000000000000\n"
1526 "0000000000000000 0000000000000000\n"
1527 "0000000000000000 0000000000000000\n"
1528 "0000000000000000 0000000000000000\n"
1529 "0000000000000000 0000000000000000\n"
1530 "0000000000000000 0000000000000000\n"
1531 "0000000000000000 0000000000000000\n"
1532 "\n"
1533 "0000000000000000 0000000000000000\n"
1534 "0000000000000022 2222220000000000\n"
1535 "0000000000000022 2222220000000000\n"
1536 "0000000000000022 2222220000000000\n"
1537 "0000000000000022 2222220000000000\n"
1538 "0000000000000000 0000000000000000\n"
1539 "0000000000000000 0000000000000000\n"
1540 "0000000000000000 0000000000000000\n"
1541 "0000000000000000 0000000000000000\n"
1542 "0000000000000000 0000000011000000\n"
1543 "0000000000000000 0000000011000000\n"
1544 "0000000000000000 0000000000000000\n"
1545 "0000000000000000 0000000000000000\n"
1546 "0000000000000000 0000000000000000\n"
1547 "0000000000000000 0000000000000000\n"
1548 "0000000000000000 0000000000000000\n";
1549
1550 EXPECT_EQ(expected_lod_lod0, stringify_lod(0));
1551
1552 /* Offset for each axis are added together in this test. */
1553 StringRefNull expected_offset_lod0 =
1554 "0000000000000000 0000000000000000\n"
1555 "0000000000000000 0000000000000000\n"
1556 "0000000000000000 0000000000000000\n"
1557 "0000000000000000 0000000000000000\n"
1558 "0000000000000000 0000000000000000\n"
1559 "0000000000000000 0000000000000000\n"
1560 "0000000000000000 0000000000000000\n"
1561 "0000000000000000 0000000000000000\n"
1562 "0000000000000000 0000000000000000\n"
1563 "0000000000000000 0000000000000000\n"
1564 "0000000000000000 0000000000000000\n"
1565 "0000000000000000 0000000000000000\n"
1566 "0000000000000000 0000000000000000\n"
1567 "0000000000000000 0000000000000000\n"
1568 "0000000000000000 0000000000000000\n"
1569 "0000000000000000 0000000000000000\n"
1570 "\n"
1571 "0000000000000000 0000000000000000\n"
1572 "0000000000000055 5555550000000000\n"
1573 "0000000000000055 5555550000000000\n"
1574 "0000000000000055 5555550000000000\n"
1575 "0000000000000055 5555550000000000\n"
1576 "0000000000000000 0000000000000000\n"
1577 "0000000000000000 0000000000000000\n"
1578 "0000000000000000 0000000000000000\n"
1579 "0000000000000000 0000000000000000\n"
1580 "0000000000000000 0000000011000000\n"
1581 "0000000000000000 0000000011000000\n"
1582 "0000000000000000 0000000000000000\n"
1583 "0000000000000000 0000000000000000\n"
1584 "0000000000000000 0000000000000000\n"
1585 "0000000000000000 0000000000000000\n"
1586 "0000000000000000 0000000000000000\n";
1587
1588 EXPECT_EQ(expected_offset_lod0, stringify_offset(0));
1589 MEM_SAFE_DELETE(pixels);
1590 }
1591
1593
1594 GPU_shader_free(sh);
1597}
1598DRAW_TEST(eevee_shadow_tilemap_amend)
1599
1600static void test_eevee_shadow_page_mask_ex(int max_view_per_tilemap)
1601{
1603 ShadowTileMapDataBuf tilemaps_data = {"tilemaps_data"};
1604 ShadowTileDataBuf tiles_data = {"tiles_data"};
1605
1606 {
1607 ShadowTileMap tilemap(0);
1608 tilemap.sync_cubeface(LIGHT_OMNI_SPHERE, float4x4::identity(), 0.01f, 1.0f, Z_NEG);
1609 tilemaps_data.append(tilemap);
1610 }
1611
1612 const uint lod0_len = SHADOW_TILEMAP_LOD0_LEN;
1613 const uint lod1_len = SHADOW_TILEMAP_LOD1_LEN;
1614 const uint lod2_len = SHADOW_TILEMAP_LOD2_LEN;
1615 const uint lod3_len = SHADOW_TILEMAP_LOD3_LEN;
1616 const uint lod4_len = SHADOW_TILEMAP_LOD4_LEN;
1617 const uint lod5_len = SHADOW_TILEMAP_LOD5_LEN;
1618
1619 const uint lod0_ofs = 0;
1620 const uint lod1_ofs = lod0_ofs + lod0_len;
1621 const uint lod2_ofs = lod1_ofs + lod1_len;
1622 const uint lod3_ofs = lod2_ofs + lod2_len;
1623 const uint lod4_ofs = lod3_ofs + lod3_len;
1624 const uint lod5_ofs = lod4_ofs + lod4_len;
1625
1626 {
1627 ShadowTileData tile = {};
1628 /* Init all LOD to true. */
1629 for (auto i : IndexRange(SHADOW_TILEDATA_PER_TILEMAP)) {
1630 tile.is_used = true;
1631 tile.do_update = true;
1632 tiles_data[i] = shadow_tile_pack(tile);
1633 }
1634
1635 /* Init all of LOD0 to false. */
1636 for (auto i : IndexRange(square_i(SHADOW_TILEMAP_RES))) {
1637 tile.is_used = false;
1638 tile.do_update = false;
1639 tiles_data[i] = shadow_tile_pack(tile);
1640 }
1641
1642 /* Bottom Left of the LOD0 to true. */
1643 for (auto y : IndexRange((SHADOW_TILEMAP_RES / 2))) {
1644 for (auto x : IndexRange((SHADOW_TILEMAP_RES / 2) + 1)) {
1645 tile.is_used = true;
1646 tile.do_update = true;
1647 tiles_data[x + y * SHADOW_TILEMAP_RES] = shadow_tile_pack(tile);
1648 }
1649 }
1650
1651 /* All Bottom of the LOD0 to true. */
1652 for (auto x : IndexRange(SHADOW_TILEMAP_RES)) {
1653 tile.is_used = true;
1654 tile.do_update = true;
1655 tiles_data[x] = shadow_tile_pack(tile);
1656 }
1657
1658 /* Bottom Left of the LOD1 to false. */
1659 /* Should still cover bottom LODs since it is itself fully masked */
1660 for (auto y : IndexRange((SHADOW_TILEMAP_RES / 8))) {
1661 for (auto x : IndexRange((SHADOW_TILEMAP_RES / 8))) {
1662 tile.is_used = false;
1663 tile.do_update = false;
1664 tiles_data[x + y * (SHADOW_TILEMAP_RES / 2) + lod0_len] = shadow_tile_pack(tile);
1665 }
1666 }
1667
1668 /* Top right Center of the LOD1 to false. */
1669 /* Should un-cover 1 LOD2 tile. */
1670 {
1671 int x = SHADOW_TILEMAP_RES / 4;
1672 int y = SHADOW_TILEMAP_RES / 4;
1673 tile.is_used = false;
1674 tile.do_update = false;
1675 tiles_data[x + y * (SHADOW_TILEMAP_RES / 2) + lod0_len] = shadow_tile_pack(tile);
1676 }
1677
1678 tiles_data.push_update();
1679 }
1680
1681 tilemaps_data.push_update();
1682
1683 gpu::Shader *sh = GPU_shader_create_from_info_name("eevee_shadow_page_mask");
1684
1685 PassSimple pass("Test");
1686 pass.shader_set(sh);
1687 pass.push_constant("max_view_per_tilemap", max_view_per_tilemap);
1688 pass.bind_ssbo("tilemaps_buf", tilemaps_data);
1689 pass.bind_ssbo("tiles_buf", tiles_data);
1690 pass.dispatch(int3(1, 1, tilemaps_data.size()));
1691
1692 Manager manager;
1693 manager.submit(pass);
1695
1696 tiles_data.read();
1697
1699 StringRefNull expected_lod0 =
1700 "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
1701 "xxxxxxxxxxxxxxxxx---------------"
1702 "xxxxxxxxxxxxxxxxx---------------"
1703 "xxxxxxxxxxxxxxxxx---------------"
1704 "xxxxxxxxxxxxxxxxx---------------"
1705 "xxxxxxxxxxxxxxxxx---------------"
1706 "xxxxxxxxxxxxxxxxx---------------"
1707 "xxxxxxxxxxxxxxxxx---------------"
1708 "xxxxxxxxxxxxxxxxx---------------"
1709 "xxxxxxxxxxxxxxxxx---------------"
1710 "xxxxxxxxxxxxxxxxx---------------"
1711 "xxxxxxxxxxxxxxxxx---------------"
1712 "xxxxxxxxxxxxxxxxx---------------"
1713 "xxxxxxxxxxxxxxxxx---------------"
1714 "xxxxxxxxxxxxxxxxx---------------"
1715 "xxxxxxxxxxxxxxxxx---------------"
1716 "--------------------------------"
1717 "--------------------------------"
1718 "--------------------------------"
1719 "--------------------------------"
1720 "--------------------------------"
1721 "--------------------------------"
1722 "--------------------------------"
1723 "--------------------------------"
1724 "--------------------------------"
1725 "--------------------------------"
1726 "--------------------------------"
1727 "--------------------------------"
1728 "--------------------------------"
1729 "--------------------------------"
1730 "--------------------------------"
1731 "--------------------------------";
1732 StringRefNull expected_lod1 =
1733 "--------xxxxxxxx"
1734 "--------xxxxxxxx"
1735 "--------xxxxxxxx"
1736 "--------xxxxxxxx"
1737 "--------xxxxxxxx"
1738 "--------xxxxxxxx"
1739 "--------xxxxxxxx"
1740 "--------xxxxxxxx"
1741 "xxxxxxxx-xxxxxxx"
1742 "xxxxxxxxxxxxxxxx"
1743 "xxxxxxxxxxxxxxxx"
1744 "xxxxxxxxxxxxxxxx"
1745 "xxxxxxxxxxxxxxxx"
1746 "xxxxxxxxxxxxxxxx"
1747 "xxxxxxxxxxxxxxxx"
1748 "xxxxxxxxxxxxxxxx";
1749 StringRefNull expected_lod1_collapsed =
1750 "xxxxxxxxxxxxxxxx"
1751 "xxxxxxxxxxxxxxxx"
1752 "xxxxxxxxxxxxxxxx"
1753 "xxxxxxxxxxxxxxxx"
1754 "xxxxxxxxxxxxxxxx"
1755 "xxxxxxxxxxxxxxxx"
1756 "xxxxxxxxxxxxxxxx"
1757 "xxxxxxxxxxxxxxxx"
1758 "xxxxxxxx-xxxxxxx"
1759 "xxxxxxxxxxxxxxxx"
1760 "xxxxxxxxxxxxxxxx"
1761 "xxxxxxxxxxxxxxxx"
1762 "xxxxxxxxxxxxxxxx"
1763 "xxxxxxxxxxxxxxxx"
1764 "xxxxxxxxxxxxxxxx"
1765 "xxxxxxxxxxxxxxxx";
1766 StringRefNull expected_lod2 =
1767 "--------"
1768 "--------"
1769 "--------"
1770 "--------"
1771 "----x---"
1772 "--------"
1773 "--------"
1774 "--------";
1775 StringRefNull expected_lod2_collapsed =
1776 "xxxxxxxx"
1777 "xxxxxxxx"
1778 "xxxxxxxx"
1779 "xxxxxxxx"
1780 "xxxxxxxx"
1781 "xxxxxxxx"
1782 "xxxxxxxx"
1783 "xxxxxxxx";
1784 StringRefNull expected_lod3 =
1785 "----"
1786 "----"
1787 "----"
1788 "----";
1789 StringRefNull expected_lod4 =
1790 "--"
1791 "--";
1792 StringRefNull expected_lod5 = "-";
1793
1794 auto stringify_result = [&](uint start, uint len) -> std::string {
1795 std::string result;
1796 for (auto i : IndexRange(start, len)) {
1797 result += (shadow_tile_unpack(tiles_data[i]).is_used) ? "x" : "-";
1798 }
1799 return result;
1800 };
1801
1802 auto empty_result = [&](uint len) -> std::string {
1803 std::string result;
1804 for ([[maybe_unused]] const int i : IndexRange(len)) {
1805 result += "-";
1806 }
1807 return result;
1808 };
1809
1810 if (max_view_per_tilemap >= 3) {
1811 EXPECT_EQ(stringify_result(lod0_ofs, lod0_len), expected_lod0);
1812 }
1813 else {
1814 EXPECT_EQ(stringify_result(lod0_ofs, lod0_len), empty_result(lod0_len));
1815 }
1816
1817 if (max_view_per_tilemap > 2) {
1818 EXPECT_EQ(stringify_result(lod1_ofs, lod1_len), expected_lod1);
1819 }
1820 else if (max_view_per_tilemap == 2) {
1821 EXPECT_EQ(stringify_result(lod1_ofs, lod1_len), expected_lod1_collapsed);
1822 }
1823 else {
1824 EXPECT_EQ(stringify_result(lod1_ofs, lod1_len), empty_result(lod1_len));
1825 }
1826
1827 if (max_view_per_tilemap > 1) {
1828 EXPECT_EQ(stringify_result(lod2_ofs, lod2_len), expected_lod2);
1829 }
1830 else if (max_view_per_tilemap == 1) {
1831 EXPECT_EQ(stringify_result(lod2_ofs, lod2_len), expected_lod2_collapsed);
1832 }
1833 else {
1834 EXPECT_EQ(stringify_result(lod2_ofs, lod2_len), empty_result(lod2_len));
1835 }
1836 EXPECT_EQ(stringify_result(lod3_ofs, lod3_len), expected_lod3);
1837 EXPECT_EQ(stringify_result(lod4_ofs, lod4_len), expected_lod4);
1838 EXPECT_EQ(stringify_result(lod5_ofs, lod5_len), expected_lod5);
1839
1841
1842 GPU_shader_free(sh);
1845}
1846
1848{
1849 /* Expect default behavior. */
1851 /* Expect default behavior. */
1853 /* Expect LOD0 merged into LOD1. */
1855 /* Expect LOD0 and LOD1 merged into LOD2. */
1857}
1858DRAW_TEST(eevee_shadow_page_mask)
1859
1861{
1863 StorageArrayBuffer<int> list_start_buf = {"list_start_buf"};
1864 StorageVectorBuffer<Surfel> surfel_buf = {"surfel_buf"};
1865 CaptureInfoBuf capture_info_buf = {"capture_info_buf"};
1866 SurfelListInfoBuf list_info_buf = {"list_info_buf"};
1867 StorageArrayBuffer<int> list_counter_buf = {"list_counter_buf"};
1868 StorageArrayBuffer<int> list_range_buf = {"list_range_buf"};
1869 StorageArrayBuffer<float> list_item_distance_buf = {"list_item_distance_buf"};
1870 StorageArrayBuffer<int> list_item_surfel_id_buf = {"list_item_surfel_id_buf"};
1871 StorageArrayBuffer<int> sorted_surfel_id_buf = {"sorted_surfel_id_buf"};
1872
1876 {
1877 Surfel surfel;
1878 surfel.normal = {0.0f, 0.0f, 1.0f};
1879 /* NOTE: Expected link assumes linear increasing processing order [0->5]. But this is
1880 * multithreaded and we can't know the execution order in advance. */
1881 /* 0: Project to (1, 0) = list 1. Next = -1; Previous = 3. */
1882 surfel.position = {1.1f, 0.1f, 0.1f};
1883 surfel_buf.append(surfel);
1884 /* 1: Project to (1, 0) = list 1. Next = 2; Previous = -1. */
1885 surfel.position = {1.1f, 0.2f, 0.5f};
1886 surfel_buf.append(surfel);
1887 /* 2: Project to (1, 0) = list 1. Next = 3; Previous = 1. */
1888 surfel.position = {1.1f, 0.3f, 0.3f};
1889 surfel_buf.append(surfel);
1890 /* 3: Project to (1, 0) = list 1. Next = 0; Previous = 2. */
1891 surfel.position = {1.2f, 0.4f, 0.2f};
1892 surfel_buf.append(surfel);
1893 /* 4: Project to (1, 1) = list 3. Next = -1; Previous = -1. */
1894 surfel.position = {1.0f, 1.0f, 0.5f};
1895 surfel_buf.append(surfel);
1896 /* 5: Project to (0, 1) = list 2. Next = -1; Previous = -1. */
1897 surfel.position = {0.1f, 1.1f, 0.5f};
1898 surfel_buf.append(surfel);
1899 /* 6: Project to (0, 1) = list 2. Next = -1; Previous = -1. Disconnected because coplanar */
1900 surfel.position = {0.2f, 1.1f, 0.5f};
1901 surfel_buf.append(surfel);
1902
1903 surfel_buf.push_update();
1904 }
1905 {
1906 capture_info_buf.surfel_len = surfel_buf.size();
1907 capture_info_buf.push_update();
1908 }
1909 {
1910 list_info_buf.ray_grid_size = int2(2);
1911 list_info_buf.list_max = list_info_buf.ray_grid_size.x * list_info_buf.ray_grid_size.y;
1912 list_info_buf.push_update();
1913 }
1914 {
1915 list_start_buf.resize(ceil_to_multiple_u(list_info_buf.list_max, 4u));
1916 list_start_buf.push_update();
1917 GPU_storagebuf_clear(list_start_buf, -1);
1918 }
1919 {
1920 list_counter_buf.resize(ceil_to_multiple_u(list_info_buf.list_max, 4u));
1921 list_counter_buf.push_update();
1922 GPU_storagebuf_clear(list_counter_buf, 0);
1923 }
1924 {
1925 list_range_buf.resize(ceil_to_multiple_u(list_info_buf.list_max * 2, 4u));
1926 list_range_buf.push_update();
1927 GPU_storagebuf_clear(list_range_buf, -1);
1928 }
1929 {
1930 list_item_distance_buf.resize(ceil_to_multiple_u(capture_info_buf.surfel_len, 4u));
1931 list_item_surfel_id_buf.resize(ceil_to_multiple_u(capture_info_buf.surfel_len, 4u));
1932 sorted_surfel_id_buf.resize(ceil_to_multiple_u(capture_info_buf.surfel_len, 4u));
1933 GPU_storagebuf_clear(list_item_distance_buf, -1);
1934 GPU_storagebuf_clear(list_item_surfel_id_buf, -1);
1935 GPU_storagebuf_clear(sorted_surfel_id_buf, -1);
1936 }
1937
1938 /* Top-down view. */
1939 View view = {"RayProjectionView"};
1941
1942 gpu::Shader *sh_build = GPU_shader_create_from_info_name("eevee_surfel_list_build");
1943 gpu::Shader *sh_flatten = GPU_shader_create_from_info_name("eevee_surfel_list_flatten");
1944 gpu::Shader *sh_prefix = GPU_shader_create_from_info_name("eevee_surfel_list_prefix");
1945 gpu::Shader *sh_prepare = GPU_shader_create_from_info_name("eevee_surfel_list_prepare");
1946 gpu::Shader *sh_sort = GPU_shader_create_from_info_name("eevee_surfel_list_sort");
1947
1948 PassSimple pass("Build_and_Sort");
1949 pass.shader_set(sh_prepare);
1950 pass.bind_ssbo("list_counter_buf", list_counter_buf);
1951 pass.bind_ssbo("list_info_buf", list_info_buf);
1952 pass.bind_ssbo("surfel_buf", surfel_buf);
1953 pass.bind_ssbo("capture_info_buf", capture_info_buf);
1954 pass.dispatch(int3(1, 1, 1));
1956
1957 pass.shader_set(sh_prefix);
1958 pass.bind_ssbo("list_counter_buf", list_counter_buf);
1959 pass.bind_ssbo("list_range_buf", list_range_buf);
1960 pass.bind_ssbo("list_info_buf", list_info_buf);
1961 pass.bind_ssbo("surfel_buf", surfel_buf);
1962 pass.bind_ssbo("capture_info_buf", capture_info_buf);
1963 pass.dispatch(int3(1, 1, 1));
1965
1966 pass.shader_set(sh_flatten);
1967 pass.bind_ssbo("list_counter_buf", list_counter_buf);
1968 pass.bind_ssbo("list_range_buf", list_range_buf);
1969 pass.bind_ssbo("list_item_distance_buf", list_item_distance_buf);
1970 pass.bind_ssbo("list_item_surfel_id_buf", list_item_surfel_id_buf);
1971 pass.bind_ssbo("list_info_buf", list_info_buf);
1972 pass.bind_ssbo("surfel_buf", surfel_buf);
1973 pass.bind_ssbo("capture_info_buf", capture_info_buf);
1974 pass.dispatch(int3(1, 1, 1));
1976
1977 pass.shader_set(sh_sort);
1978 pass.bind_ssbo("list_range_buf", list_range_buf);
1979 pass.bind_ssbo("list_item_surfel_id_buf", list_item_surfel_id_buf);
1980 pass.bind_ssbo("list_item_distance_buf", list_item_distance_buf);
1981 pass.bind_ssbo("sorted_surfel_id_buf", sorted_surfel_id_buf);
1982 pass.bind_ssbo("list_info_buf", list_info_buf);
1983 pass.bind_ssbo("surfel_buf", surfel_buf);
1984 pass.bind_ssbo("capture_info_buf", capture_info_buf);
1985 pass.dispatch(int3(1, 1, 1));
1987
1988 pass.shader_set(sh_build);
1989 pass.bind_ssbo("list_start_buf", list_start_buf);
1990 pass.bind_ssbo("list_range_buf", list_range_buf);
1991 pass.bind_ssbo("sorted_surfel_id_buf", sorted_surfel_id_buf);
1992 pass.bind_ssbo("list_info_buf", list_info_buf);
1993 pass.bind_ssbo("surfel_buf", surfel_buf);
1994 pass.bind_ssbo("capture_info_buf", capture_info_buf);
1995 pass.dispatch(int3(1, 1, 1));
1997
1998 Manager manager;
1999 manager.submit(pass, view);
2000
2001 list_start_buf.read();
2002 surfel_buf.read();
2003
2004 /* Expect surfel list. */
2005 Vector<int> expect_link_next = {-1, +2, +3, +0, -1, -1, -1};
2006 Vector<int> expect_link_prev = {+3, -1, +1, +2, -1, -1, -1};
2007
2008 Vector<int> link_next, link_prev;
2009 for (const auto &surfel : Span<Surfel>(surfel_buf.data(), surfel_buf.size())) {
2010 link_next.append(surfel.next);
2011 link_prev.append(surfel.prev);
2012 }
2013
2014 Vector<int> expect_list_start = {-1, 1, 5, 4};
2015 EXPECT_EQ_SPAN<int>(expect_list_start, list_start_buf);
2016 EXPECT_EQ_SPAN<int>(expect_link_next, link_next);
2017 EXPECT_EQ_SPAN<int>(expect_link_prev, link_prev);
2018
2020
2021 GPU_shader_free(sh_build);
2022 GPU_shader_free(sh_flatten);
2023 GPU_shader_free(sh_prefix);
2024 GPU_shader_free(sh_prepare);
2025 GPU_shader_free(sh_sort);
2028}
2029DRAW_TEST(eevee_surfel_list)
2030
2032{
2034
2035 Manager manager;
2036
2037 /* Check if LUT generation matches the header version. */
2038 auto brdf_ggx_gen = Precompute(manager, LUT_GGX_BRDF_SPLIT_SUM, {64, 64, 1}).data<float3>();
2039 auto btdf_ggx_gen = Precompute(manager, LUT_GGX_BTDF_IOR_GT_ONE, {64, 64, 16}).data<float1>();
2040 auto bsdf_ggx_gen = Precompute(manager, LUT_GGX_BSDF_SPLIT_SUM, {64, 64, 16}).data<float3>();
2041 auto burley_gen = Precompute(manager, LUT_BURLEY_SSS_PROFILE, {64, 1, 1}).data<float1>();
2042 auto rand_walk_gen = Precompute(manager, LUT_RANDOM_WALK_SSS_PROFILE, {64, 1, 1}).data<float1>();
2043
2044 Span<float3> brdf_ggx_lut((const float3 *)&eevee::lut::brdf_ggx, 64 * 64);
2045 Span<float1> btdf_ggx_lut((const float1 *)&eevee::lut::btdf_ggx, 64 * 64 * 16);
2046 Span<float3> bsdf_ggx_lut((const float3 *)&eevee::lut::bsdf_ggx, 64 * 64 * 16);
2047 Span<float1> burley_sss_lut((const float1 *)&eevee::lut::burley_sss_profile, 64);
2048 Span<float1> rand_walk_lut((const float1 *)&eevee::lut::random_walk_sss_profile, 64);
2049
2050 const float eps = 3e-3f;
2051 EXPECT_NEAR_ARRAY_ND(brdf_ggx_lut.data(), brdf_ggx_gen.data(), brdf_ggx_gen.size(), 3, eps);
2052 EXPECT_NEAR_ARRAY_ND(btdf_ggx_lut.data(), btdf_ggx_gen.data(), btdf_ggx_gen.size(), 1, eps);
2053 EXPECT_NEAR_ARRAY_ND(bsdf_ggx_lut.data(), bsdf_ggx_gen.data(), bsdf_ggx_gen.size(), 3, eps);
2054 EXPECT_NEAR_ARRAY_ND(burley_gen.data(), burley_sss_lut.data(), burley_sss_lut.size(), 1, eps);
2055 EXPECT_NEAR_ARRAY_ND(rand_walk_gen.data(), rand_walk_lut.data(), rand_walk_lut.size(), 1, eps);
2056
2058}
2059DRAW_TEST(eevee_lut_gen)
2060
2061} // namespace blender::draw
#define GPU_BATCH_DISCARD_SAFE(batch)
Definition GPU_batch.hh:199
#define GPU_FRAMEBUFFER_FREE_SAFE(fb)
constexpr IndexRange()=default
constexpr const T * data() const
Definition BLI_span.hh:219
constexpr int64_t size() const
Definition BLI_span.hh:256
void append(const T &value)
void fill(const T &value) const
void begin_sync(Object *object_active=nullptr)
SwapChain< ObjectBoundsBuf, 2 > bounds_buf
void submit(PassSimple &pass, View &view)
ResourceHandleRange resource_handle(const ObjectRef &ref, float inflate_bounds=0.0f)
TestAlloc(int page_free_count)
TestDefrag(int allocation_count, int descriptor_offset, StringRefNull descriptor, StringRefNull expect)
bool ensure_2d(gpu::TextureFormat format, int2 extent, eGPUTextureUsage usage=GPU_TEXTURE_USAGE_GENERAL, const float *data=nullptr, int mip_len=1)
void clear(float4 values)
T * read(eGPUDataFormat format, int miplvl=0)
void sync(const float4x4 &view_mat, const float4x4 &win_mat, int view_id=0)
Definition draw_view.cc:27
void framebuffer_set(gpu::FrameBuffer **framebuffer)
void shader_set(gpu::Shader *shader)
void bind_image(const char *name, gpu::Texture *image)
void dispatch(int group_len)
void barrier(GPUBarrier type)
void push_constant(const char *name, const float &data)
void bind_ssbo(const char *name, gpu::StorageBuf *buffer)
void draw(gpu::Batch *batch, uint instance_len=-1, uint vertex_len=-1, uint vertex_first=-1, ResourceIDRange res_id={}, uint custom_id=0)
Definition draw_pass.hh:906
Precompute(draw::Manager &manager, PrecomputeType type, int3 table_extent)
#define DRAW_TEST(test_name)
#define LIGHT_BUF_SLOT
#define LIGHT_ZBIN_BUF_SLOT
#define LIGHT_TILE_BUF_SLOT
#define LIGHT_CULL_BUF_SLOT
float4x4 from_loc_rot_scale(float3 location, EulerXYZ rotation, float3 scale)
const int tile_index
const ccl_global KernelWorkTile * tile
ccl_device_inline dual1 len(const ccl_private dual< T > &a)
Definition math_dual.h:263
detail::Pass< command::DrawCommandBuf > PassSimple
static void test_eevee_shadow_free()
static void test_eevee_surfel_list()
static void test_eevee_shadow_tilemap_amend()
static void test_eevee_lut_gen()
static void test_eevee_shadow_defrag()
static void test_eevee_shadow_finalize()
static void test_eevee_shadow_tag_update()
static void test_eevee_shadow_shift()
static void test_eevee_shadow_alloc()
static void test_eevee_shadow_page_mask()
static void test_eevee_shadow_page_mask_ex(int max_view_per_tilemap)
static void test_eevee_shadow_shift_clear()
Definition eevee_test.cc:28
static void test_eevee_shadow_tile_packing()
const float burley_sss_profile[64][1]
const float brdf_ggx[64][64][3]
const float random_walk_sss_profile[64][1]
const float btdf_ggx[16][64][64][1]
const float bsdf_ggx[16][64][64][3]
draw::StorageArrayBuffer< LightData, LIGHT_CHUNK > LightDataBuf
draw::StorageBuffer< ShadowPagesInfoData > ShadowPagesInfoDataBuf
draw::StorageArrayBuffer< ShadowTileDataPacked, SHADOW_MAX_TILE, true > ShadowTileDataBuf
draw::StorageArrayBuffer< ShadowTileMapClip, SHADOW_MAX_TILEMAP, true > ShadowTileMapClipBuf
draw::StorageArrayBuffer< uint, CULLING_ZBIN_COUNT, true > LightCullingZbinBuf
draw::StorageArrayBuffer< uint2, SHADOW_MAX_PAGE, true > ShadowPageCacheBuf
draw::StorageArrayBuffer< uint, LIGHT_CHUNK, true > LightCullingTileBuf
draw::StorageArrayBuffer< ShadowRenderView, SHADOW_VIEW_MAX, true > ShadowRenderViewBuf
draw::StorageBuffer< LightCullingData > LightCullingDataBuf
draw::StorageBuffer< SurfelListInfoData > SurfelListInfoBuf
draw::StorageBuffer< CaptureInfoData > CaptureInfoBuf
draw::StorageBuffer< ShadowStatistics > ShadowStatisticsBuf
draw::StorageVectorBuffer< ShadowTileMapData, SHADOW_MAX_TILEMAP > ShadowTileMapDataBuf
draw::StorageVectorBuffer< uint, SHADOW_MAX_PAGE > ShadowPageHeapBuf
MatBase< T, 4, 4 > orthographic(T left, T right, T bottom, T top, T near_clip, T far_clip)
Create an orthographic projection matrix using OpenGL coordinate convention: Maps each axis range to ...
MatBase< T, 4, 4 > perspective(T left, T right, T bottom, T top, T near_clip, T far_clip)
Create a perspective projection matrix using OpenGL coordinate convention: Maps each axis range to [-...
VecBase< uint32_t, 2 > uint2
VecBase< float, 1 > float1
unsigned int uint
Definition BKE_text.h:55
MINLINE int square_i(int a)
BLI_INLINE float fb(float length, float L)
VecBase< uint32_t, 4 > uint4
gpu::Shader * GPU_shader_create_from_info_name(const char *info_name)
gpu::Batch * GPU_batch_unit_cube() ATTR_WARN_UNUSED_RESULT
MINLINE int max_ii(int a, int b)
VecBase< uint32_t, 3 > uint3
void GPU_render_begin()
MatBase< float, 4, 4 > float4x4
void GPU_storagebuf_clear(gpu::StorageBuf *ssbo, uint32_t clear_value)
void GPU_texture_update_sub(gpu::Texture *texture, eGPUDataFormat data_format, const void *pixels, int offset_x, int offset_y, int offset_z, int width, int height, int depth, uint unpack_row_length=0)
unsigned int uint32_t
Definition BKE_text.h:81
VecBase< int32_t, 2 > int2
VecBase< int32_t, 3 > int3
void DRW_shaders_free()
@ GPU_TEXTURE_USAGE_SHADER_READ
@ GPU_TEXTURE_USAGE_SHADER_WRITE
@ GPU_TEXTURE_USAGE_HOST_READ
void GPU_render_end()
void GPU_memory_barrier(GPUBarrier barrier)
Definition gpu_state.cc:305
BMesh const char void * data
void GPU_shader_unbind()
@ GPU_BARRIER_BUFFER_UPDATE
Definition GPU_state.hh:59
@ GPU_BARRIER_SHADER_STORAGE
Definition GPU_state.hh:51
@ GPU_BARRIER_TEXTURE_UPDATE
Definition GPU_state.hh:42
gpu::FrameBuffer * GPU_framebuffer_create(const char *name)
EXPECT_EQ(BLI_expr_pylike_eval(expr, nullptr, 0, &result), EXPR_PYLIKE_INVALID)
void GPU_framebuffer_default_size(gpu::FrameBuffer *fb, int width, int height)
bool GPU_multi_viewport_support()
MINLINE uint ceil_to_multiple_u(uint a, uint b)
void GPU_shader_free(gpu::Shader *shader)
VecBase< float, 3 > float3
MINLINE int min_ii(int a, int b)
const btScalar eps
Definition poly34.cpp:11
static Quaternion identity()
enum eShadowProjectionType projection_type
void sync_orthographic(const float4x4 &object_mat_, int2 origin_offset, int clipmap_level, eShadowProjectionType projection_type_, uint2 shadow_set_membership_=~uint2(0))
void sync_cubeface(eLightType light_type_, const float4x4 &object_mat, float near, float far, eCubeFace face, uint2 shadow_set_membership_=~uint2(0))