Debian Codegraph @

modules/lsp-ws-lib/src/test/mtest/display/r3d.cpp

raw
1 /*
2 * Copyright (C) 2025 Linux Studio Plugins Project <https://lsp-plug.in/>
3 * (C) 2025 Vladimir Sadovnikov <[email protected]>
4 *
5 * This file is part of lsp-ws-lib
6 * Created on: 25 июл. 2022 г.
7 *
8 * lsp-ws-lib is free software: you can redistribute it and/or modify
9 * it under the terms of the GNU Lesser General Public License as published by
10 * the Free Software Foundation, either version 3 of the License, or
11 * any later version.
12 *
13 * lsp-ws-lib is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU Lesser General Public License for more details.
17 *
18 * You should have received a copy of the GNU Lesser General Public License
19 * along with lsp-ws-lib. If not, see <https://www.gnu.org/licenses/>.
20 */
21
22 #include <lsp-plug.in/ws/factory.h>
23 #include <lsp-plug.in/ws/IEventHandler.h>
24 #include <lsp-plug.in/ws/IR3DBackend.h>
25 #include <lsp-plug.in/stdlib/math.h>
26 #include <lsp-plug.in/test-fw/mtest.h>
27
28 #define FRAME_PERIOD (1000 / 25) /* Launch at 25 Hz rate */
29
30 namespace lsp
31 {
32 namespace
33 {
34 #define D3(x, y, z) { x, y, z, 1.0f }
35 #define V3(dx, dy, dz) { dx, dy, dz, 0.0f }
36 #define C3(r, g, b) { r, g, b, 0.0f }
37
38 typedef struct axis_point3d_t
39 {
40 r3d::dot4_t v;
41 r3d::color_t c;
42 } axis_point3d_t;
43
44 static axis_point3d_t axis_lines[] =
45 {
46 // X axis (red)
47 { { 0.0f, 0.0f, 0.0f, 1.0f }, { 1.0f, 0.0f, 0.0f, 1.0f } },
48 { { 2.0f, 0.0f, 0.0f, 1.0f }, { 1.0f, 0.0f, 0.0f, 1.0f } },
49 // Y axis (green)
50 { { 0.0f, 0.0f, 0.0f, 1.0f }, { 0.0f, 1.0f, 0.0f, 1.0f } },
51 { { 0.0f, 2.0f, 0.0f, 1.0f }, { 0.0f, 1.0f, 0.0f, 1.0f } },
52 // Z axis (blue)
53 { { 0.0f, 0.0f, 0.0f, 1.0f }, { 0.0f, 0.0f, 1.0f, 1.0f } },
54 { { 0.0f, 0.0f, 2.0f, 1.0f }, { 0.0f, 0.0f, 1.0f, 1.0f } }
55 };
56
57 static axis_point3d_t dot[] = {
58 { { 0.0f, 0.0f, 0.0f, 1.0f}, { 1.0f, 1.0f, 1.0f, 1.0f } }
59 };
60
61 // 3D mesh data for box: vertex, normal, color
62 static r3d::dot4_t box_vertex[] =
63 {
64 D3( 1.0f, 1.0f, 1.0f ),
65 D3( -1.0f, 1.0f, 1.0f ),
66 D3( -1.0f, -1.0f, 1.0f ),
67 D3( 1.0f, -1.0f, 1.0f ),
68
69 D3( 1.0f, 1.0f, -1.0f ),
70 D3( -1.0f, 1.0f, -1.0f ),
71 D3( -1.0f, -1.0f, -1.0f ),
72 D3( 1.0f, -1.0f, -1.0f )
73 };
74
75 static r3d::color_t box_colors[] =
76 {
77 C3( 1.0f, 0.0f, 0.0f ),
78 C3( 0.0f, 1.0f, 0.0f ),
79 C3( 0.0f, 0.0f, 1.0f ),
80 C3( 1.0f, 1.0f, 0.0f ),
81
82 C3( 1.0f, 0.0f, 1.0f ),
83 C3( 0.0f, 1.0f, 1.0f ),
84 C3( 1.0f, 1.0f, 1.0f ),
85 C3( 0.5f, 0.5f, 0.5f )
86 };
87
88 static r3d::vec4_t box_normal[] =
89 {
90 V3( 1.0f, 0.0f, 0.0f ),
91 V3( -1.0f, 0.0f, 0.0f ),
92 V3( 0.0f, 1.0f, 0.0f ),
93 V3( 0.0f, -1.0f, 0.0f ),
94 V3( 0.0f, 0.0f, 1.0f ),
95 V3( 0.0f, 0.0f, -1.0f )
96 };
97
98 // Indices
99 static uint32_t box_vertex_idx[] =
100 {
101 0, 1, 2, 0, 2, 3,
102 0, 4, 5, 0, 5, 1,
103 1, 5, 6, 1, 6, 2,
104 0, 3, 7, 0, 7, 4,
105 3, 2, 6, 3, 6, 7,
106 5, 4, 7, 5, 7, 6
107 };
108
109 static uint32_t box_normal_idx[] =
110 {
111 4, 4, 4, 4, 4, 4,
112 2, 2, 2, 2, 2, 2,
113 1, 1, 1, 1, 1, 1,
114 0, 0, 0, 0, 0, 0,
115 3, 3, 3, 3, 3, 3,
116 5, 5, 5, 5, 5, 5,
117 };
118
119 #ifdef ARCH_LE
120 static void abgr32_to_prgba32(void *dst, const void *src, size_t count)
121 {
122 const uint32_t *s = reinterpret_cast<const uint32_t *>(src);
123 uint32_t *d = reinterpret_cast<uint32_t *>(dst);
124
125 for (size_t i=0; i<count; ++i)
126 {
127 uint32_t c = s[i];
128 d[i] = 0xff000000 | c;
129 }
130 }
131 #else /* ARCH_BE */
132 static void abgr32_to_prgba32(void *dst, const void *src, size_t count)
133 {
134 const uint32_t *s = reinterpret_cast<const uint32_t *>(src);
135 uint32_t *d = reinterpret_cast<uint32_t *>(dst);
136
137 for (size_t i=0; i<count; ++i)
138 {
139 uint32_t c = s[i];
140 d[i] = 0x000000ff | c;
141 }
142 }
143 #endif
144
145 static void init_point_xyz(r3d::dot4_t *p, float x, float y, float z)
146 {
147 p->x = x;
148 p->y = y;
149 p->z = z;
150 p->w = 1.0f;
151 }
152
153 static void init_vector_dxyz(r3d::vec4_t *v, float dx, float dy, float dz)
154 {
155 v->dx = dx;
156 v->dy = dy;
157 v->dz = dz;
158 v->dw = 0.0f;
159 }
160
161 void init_vector_p2(r3d::vec4_t *v, const r3d::dot4_t *p1, const r3d::dot4_t *p2)
162 {
163 v->dx = p2->x - p1->x;
164 v->dy = p2->y - p1->y;
165 v->dz = p2->z - p1->z;
166 v->dw = 0.0f;
167 }
168
169 static void init_matrix_identity(r3d::mat4_t *m)
170 {
171 float *v = m->m;
172
173 v[0] = 1.0f;
174 v[1] = 0.0f;
175 v[2] = 0.0f;
176 v[3] = 0.0f;
177
178 v[4] = 0.0f;
179 v[5] = 1.0f;
180 v[6] = 0.0f;
181 v[7] = 0.0f;
182
183 v[8] = 0.0f;
184 v[9] = 0.0f;
185 v[10] = 1.0f;
186 v[11] = 0.0f;
187
188 v[12] = 0.0f;
189 v[13] = 0.0f;
190 v[14] = 0.0f;
191 v[15] = 1.0f;
192 }
193
194 static void init_matrix_rotate_z(r3d::mat4_t *m, float angle)
195 {
196 float s = sinf(angle);
197 float c = cosf(angle);
198 float *M = m->m;
199
200 M[0] = c;
201 M[1] = s;
202 M[2] = 0.0f;
203 M[3] = 0.0f;
204 M[4] = -s;
205 M[5] = c;
206 M[6] = 0.0f;
207 M[7] = 0.0f;
208 M[8] = 0.0f;
209 M[9] = 0.0f;
210 M[10] = 1.0f;
211 M[11] = 0.0f;
212 M[12] = 0.0f;
213 M[13] = 0.0f;
214 M[14] = 0.0f;
215 M[15] = 1.0f;
216 }
217
218 static void init_matrix_translate(r3d::mat4_t *m, float dx, float dy, float dz)
219 {
220 float *v = m->m;
221
222 v[0] = 1.0f;
223 v[1] = 0.0f;
224 v[2] = 0.0f;
225 v[3] = 0.0f;
226
227 v[4] = 0.0f;
228 v[5] = 1.0f;
229 v[6] = 0.0f;
230 v[7] = 0.0f;
231
232 v[8] = 0.0f;
233 v[9] = 0.0f;
234 v[10] = 1.0f;
235 v[11] = 0.0f;
236
237 v[12] = dx;
238 v[13] = dy;
239 v[14] = dz;
240 v[15] = 1.0;
241 }
242
243 static void init_matrix_frustum(r3d::mat4_t *m, float left, float right, float bottom, float top, float znear, float zfar)
244 {
245 float *M = m->m;
246 M[0] = 2.0f * znear / (right - left);
247 M[1] = 0.0f;
248 M[2] = 0.0f;
249 M[3] = 0.0f;
250
251 M[4] = 0.0f;
252 M[5] = 2.0f * znear / (top - bottom);
253 M[6] = 0.0f;
254 M[7] = 0.0f;
255
256 M[8] = (right + left) / (right - left);
257 M[9] = (top + bottom) / (top - bottom);
258 M[10] = - (zfar + znear) / (zfar - znear);
259 M[11] = -1.0f;
260
261 M[12] = 0.0f;
262 M[13] = 0.0f;
263 M[14] = -2.0f * zfar * znear / (zfar - znear);
264 M[15] = 0.0f;
265 }
266
267 static void init_matrix_lookat_p1v2(r3d::mat4_t *m, const r3d::dot4_t *pov, const r3d::vec4_t *fwd, const r3d::vec4_t *up)
268 {
269 r3d::vec4_t f, s, u;
270 float fw, fs;
271
272 // Normalize forward vector
273 fw = sqrtf(fwd->dx*fwd->dx + fwd->dy*fwd->dy + fwd->dz*fwd->dz);
274 f.dx = fwd->dx / fw;
275 f.dy = fwd->dy / fw;
276 f.dz = fwd->dz / fw;
277 f.dw = 0.0f;
278
279 // Compute and normalize side vector
280 s.dx = f.dy*up->dz - f.dz*up->dy;
281 s.dy = f.dz*up->dx - f.dx*up->dz;
282 s.dz = f.dx*up->dy - f.dy*up->dx;
283 s.dw = 0.0f;
284
285 fs = sqrtf(s.dx*s.dx + s.dy*s.dy + s.dz*s.dz);
286 s.dx /= fs;
287 s.dy /= fs;
288 s.dz /= fs;
289
290 // Compute orthogonal up vector
291 u.dx = f.dy*s.dz - f.dz*s.dy;
292 u.dy = f.dz*s.dx - f.dx*s.dz;
293 u.dz = f.dx*s.dy - f.dy*s.dx;
294 u.dw = 0.0f;
295
296 // Fill matrix
297 float *M = m->m;
298 M[0] = s.dx;
299 M[1] = u.dx;
300 M[2] = f.dx;
301 M[3] = 0.0f;
302
303 M[4] = s.dy;
304 M[5] = u.dy;
305 M[6] = f.dy;
306 M[7] = 0.0f;
307
308 M[8] = s.dz;
309 M[9] = u.dz;
310 M[10] = f.dz;
311 M[11] = 0.0f;
312
313 M[12] = -(s.dx*pov->x + s.dy*pov->y + s.dz*pov->z);
314 M[13] = -(u.dx*pov->x + u.dy*pov->y + u.dz*pov->z);
315 M[14] = -(f.dx*pov->x + f.dy*pov->y + f.dz*pov->z);
316 M[15] = 1.0f;
317 }
318 } /* namespace */
319 } /* namespace lsp */
320
321 MTEST_BEGIN("ws.display", r3d)
322
323 class Handler: public ws::IEventHandler
324 {
325 private:
326 test_type_t *pTest;
327 ws::IWindow *pWnd;
328 ws::IR3DBackend *pBackend;
329 ws::taskid_t nTaskId;
330
331 r3d::mat4_t sWorld;
332 r3d::mat4_t sView;
333 r3d::mat4_t sProj;
334
335 size_t nPeriod;
336 size_t nYaw;
337 size_t nStep;
338
339 float fFov;
340 r3d::dot4_t sPov;
341 r3d::dot4_t sDst;
342 r3d::vec4_t sTop;
343
344 bool bOversampling;
345
346 protected:
347 static status_t execute_timer(ws::timestamp_t sched, ws::timestamp_t time, void *arg)
348 {
349 Handler *pthis = static_cast<Handler *>(arg);
350 if (pthis == NULL)
351 return STATUS_OK;
352
353 pthis->nTaskId = -1;
354 pthis->on_timer();
355 pthis->launch(time + FRAME_PERIOD);
356
357 return STATUS_OK;
358 }
359
360 public:
361 inline Handler(test_type_t *test, ws::IWindow *wnd, ws::IR3DBackend *r3d)
362 {
363 pTest = test;
364 pWnd = wnd;
365 pBackend = r3d;
366 nTaskId = -1;
367
368 nPeriod = 0x100000;
369 nYaw = 0;
370 nStep = (nPeriod * FRAME_PERIOD) / 10000.0f;
371
372 fFov = 70.0f;
373
374 bOversampling= false;
375
376 init_point_xyz(&sPov, 3.0f, 0.6f, 2.1f);
377 init_point_xyz(&sDst, 0.0f, 0.0f, 0.0f);
378 init_vector_dxyz(&sTop, 0.0f, 0.0f, -1.0f);
379 init_matrix_identity(&sWorld);
380 }
381
382 void launch(ws::timestamp_t deadline = 0)
383 {
384 nTaskId = pWnd->display()->submit_task(deadline, execute_timer, this);
385 }
386
387 void stop()
388 {
389 if (nTaskId >= 0)
390 pWnd->display()->cancel_task(nTaskId);
391 }
392
393 public:
394 void on_timer()
395 {
396 // Update mesh matrix
397 nYaw = (nYaw + nStep) % nPeriod;
398 float yaw = (2.0f * M_PI * nYaw) / float(nPeriod);
399
400 init_matrix_rotate_z(&sWorld, -yaw);
401
402 // Query area for redraw
403 pWnd->invalidate();
404 }
405
406 void draw(ws::IR3DBackend *r3d)
407 {
408 ssize_t vx, vy, vw, vh;
409 r3d::mat4_t mat;
410
411 r3d->get_location(&vx, &vy, &vw, &vh);
412
413 // Compute frustum matrix
414 float aspect = float(vw)/float(vh);
415 float zNear = 0.1f;
416 float zFar = 1000.0f;
417
418 float fH = tanf( fFov * M_PI / 360.0f) * zNear;
419 float fW = fH * aspect;
420 init_matrix_frustum(&sProj, -fW, fW, -fH, fH, zNear, zFar);
421
422 // Compute view matrix
423 r3d::vec4_t dir;
424 init_vector_p2(&dir, &sDst, &sPov);
425 init_matrix_lookat_p1v2(&sView, &sPov, &dir, &sTop);
426
427 // Update matrices
428 r3d->set_matrix(r3d::MATRIX_WORLD, &sWorld);
429 r3d->set_matrix(r3d::MATRIX_PROJECTION, &sProj);
430 r3d->set_matrix(r3d::MATRIX_VIEW, &sView);
431
432 // Now we can perform rendering
433 // Set Light parameters
434 r3d::light_t light;
435
436 light.type = r3d::LIGHT_SPOT;
437 light.position = sPov;
438 light.direction.dx = -dir.dx;
439 light.direction.dy = -dir.dy;
440 light.direction.dz = -dir.dz;
441 light.direction.dw = 0.0f;
442
443 light.ambient.r = 0.5f;
444 light.ambient.g = 0.5f;
445 light.ambient.b = 0.5f;
446 light.ambient.a = 1.0f;
447
448 light.diffuse.r = 0.5f;
449 light.diffuse.g = 0.5f;
450 light.diffuse.b = 0.5f;
451 light.diffuse.a = 1.0f;
452
453 light.specular.r = 0.5f;
454 light.specular.g = 0.5f;
455 light.specular.b = 0.5f;
456 light.specular.a = 1.0f;
457
458 light.constant = 1.0f;
459 light.linear = 0.0f;
460 light.quadratic = 0.0f;
461 light.cutoff = 180.0f;
462
463 // Enable/disable lighting
464 r3d->set_lights(&light, 1);
465
466 r3d::buffer_t buf;
467
468 // Draw axes
469 r3d::init_buffer(&buf);
470
471 buf.type = r3d::PRIMITIVE_LINES;
472 buf.width = 2.0f * (1.0f + bOversampling);
473 buf.count = sizeof(axis_lines) / (sizeof(axis_point3d_t) * 2);
474 buf.flags = 0;
475
476 buf.vertex.data = &axis_lines[0].v;
477 buf.vertex.stride = sizeof(axis_point3d_t);
478
479 buf.color.data = &axis_lines[0].c;
480 buf.color.stride = sizeof(axis_point3d_t);
481
482 r3d->draw_primitives(&buf);
483
484 // Draw dot
485 r3d::init_buffer(&buf);
486
487 init_matrix_translate(&mat, 1.5f, 1.5f, 1.5f);
488
489 buf.model = mat;
490 buf.type = r3d::PRIMITIVE_POINTS;
491 buf.width = 8.0f * (1.0f + bOversampling);
492 buf.count = 1;
493 buf.flags = 0;
494
495 buf.vertex.data = &dot[0].v;
496 buf.vertex.stride = sizeof(axis_point3d_t);
497
498 buf.color.data = &dot[0].c;
499 buf.color.stride = sizeof(axis_point3d_t);
500
501 r3d->draw_primitives(&buf);
502
503 // Draw box
504 r3d::init_buffer(&buf);
505
506 buf.type = r3d::PRIMITIVE_TRIANGLES;
507 buf.width = 1.0f;
508 buf.count = sizeof(box_vertex_idx) / (sizeof(uint32_t) * 3);
509 buf.flags = r3d::BUFFER_LIGHTING;
510
511 buf.vertex.data = box_vertex;
512 buf.vertex.stride = sizeof(r3d::vec4_t);
513 buf.vertex.index = box_vertex_idx;
514
515 buf.normal.data = box_normal;
516 buf.normal.stride = sizeof(r3d::vec4_t);
517 buf.normal.index = box_normal_idx;
518
519 buf.color.data = box_colors;
520 buf.color.stride = sizeof(r3d::color_t);
521 buf.color.index = box_vertex_idx;
522
523 r3d->draw_primitives(&buf);
524 }
525
526 virtual status_t handle_event(const ws::event_t *ev) override
527 {
528 switch (ev->nType)
529 {
530 case ws::UIE_MOUSE_SCROLL:
531 {
532 bOversampling = ! bOversampling;
533 pTest->printf("Oversampling: %s\n", (bOversampling) ? "ON" : "OFF");
534 break;
535 }
536
537 case ws::UIE_REDRAW:
538 {
539 Color c(1.0f, 1.0f, 1.0f);
540 ws::ISurface *s = pWnd->get_surface();
541 if (s == NULL)
542 return STATUS_OK;
543
544 size_t ww = pWnd->width() - 16;
545 size_t wh = pWnd->height() - 16;
546 size_t rw = ww * (1 + bOversampling);
547 size_t rh = wh * (1 + bOversampling);
548
549 // Perform drawing
550 s->begin();
551 {
552 // Set background color for backend
553 if (pBackend != NULL)
554 {
555 r3d::color_t rc;
556 rc.r = 0.0f;
557 rc.g = 0.0f;
558 rc.b = 0.0f;
559 rc.a = 1.0f;
560 pBackend->set_bg_color(&rc);
561
562 // Locate the backend
563 pBackend->locate(8, 8, rw, rh);
564 pWnd->display()->sync();
565
566 // Allocate buffer for drawing
567 size_t count = rw * rh;
568 size_t stride = rw * sizeof(uint32_t);
569 uint8_t *buf = static_cast<uint8_t *>(malloc(count * sizeof(uint32_t)));
570 lsp_finally{ free(buf); };
571
572 pBackend->begin_draw();
573 draw(pBackend);
574 pBackend->sync();
575 pBackend->read_pixels(buf, r3d::PIXEL_BGRA);
576 pBackend->end_draw();
577
578 // Draw the contents of the data read from the R3D content
579 abgr32_to_prgba32(buf, buf, count);
580
581 s->clear(c);
582 s->draw_raw(buf, rw, rh, stride,
583 8, 8, float(ww) / float(rw), float(wh) / float(rh), 0.0f);
584 }
585 else
586 s->clear(c);
587 }
588 s->end();
589
590 return STATUS_OK;
591 }
592
593 case ws::UIE_CLOSE:
594 {
595 pWnd->hide();
596 pWnd->display()->quit_main();
597 break;
598 }
599
600 default:
601 return IEventHandler::handle_event(ev);
602 }
603
604 return STATUS_OK;
605 }
606 };
607
608 MTEST_MAIN
609 {
610 ws::IDisplay *dpy = ws::create_display(0, NULL);
611 MTEST_ASSERT(dpy != NULL);
612 lsp_finally { ws::free_display(dpy); };
613
614 ws::IWindow *wnd = dpy->create_window();
615 MTEST_ASSERT(wnd != NULL);
616 lsp_finally {
617 wnd->destroy();
618 delete wnd;
619 };
620
621 MTEST_ASSERT(wnd->init() == STATUS_OK);
622 MTEST_ASSERT(wnd->set_caption("Test 3D rendering") == STATUS_OK);
623 MTEST_ASSERT(wnd->set_window_actions(ws::WA_ALL) == STATUS_OK);
624 MTEST_ASSERT(wnd->resize(320, 200) == STATUS_OK);
625 MTEST_ASSERT(wnd->set_size_constraints(320, 200, 640, 400) == STATUS_OK);
626
627 ws::IR3DBackend *r3d = dpy->create_r3d_backend(wnd);
628 MTEST_ASSERT(r3d != NULL);
629 lsp_finally {
630 r3d->destroy();
631 delete r3d;
632 };
633
634 Handler h(this, wnd, r3d);
635 h.launch();
636 lsp_finally{ h.stop(); };
637
638 wnd->set_handler(&h);
639
640 MTEST_ASSERT(wnd->show() == STATUS_OK);
641
642 MTEST_ASSERT(dpy->main() == STATUS_OK);
643 }
644
645 MTEST_END
646
647
648
649
650