git.mutantstargoat.com Git - retroray/blob - src/scr_mod.c

   1 /*
   2 RetroRay - integrated standalone vintage modeller/renderer
   3 Copyright (C) 2023  John Tsiombikas <nuclear@mutantstargoat.com>
   4
   5 This program is free software: you can redistribute it and/or modify
   6 it under the terms of the GNU General Public License as published by
   7 the Free Software Foundation, either version 3 of the License, or
   8 (at your option) any later version.
   9
  10 This program is distributed in the hope that it will be useful,
  11 but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 GNU General Public License for more details.
  14
  15 You should have received a copy of the GNU General Public License
  16 along with this program.  If not, see <https://www.gnu.org/licenses/>.
  17 */
  18 #include <assert.h>
  19 #include "gaw/gaw.h"
  20 #include "app.h"
  21 #include "rtk.h"
  22 #include "scene.h"
  23 #include "geom.h"
  24 #include "cmesh.h"
  25 #include "meshgen.h"
  26 #include "font.h"
  27 #include "rend.h"
  28
  29 enum {
  30         TBN_NEW, TBN_OPEN, TBN_SAVE, TBN_SEP1,
  31         TBN_SEL, TBN_MOVE, TBN_ROT, TBN_SCALE, TBN_SEP2,
  32         TBN_ADD, TBN_RM, TBN_SEP3,
  33         TBN_UNION, TBN_ISECT, TBN_DIFF, TBN_SEP4,
  34         TBN_MTL, TBN_REND, TBN_REND_AREA, TBN_VIEWREND, TBN_SEP5, TBN_CFG,
  35
  36         NUM_TOOL_BUTTONS
  37 };
  38 static const char *tbn_icon_name[] = {
  39         "new", "open", "save", 0,
  40         "sel", "move", "rot", "scale", 0,
  41         "add", "remove", 0,
  42         "union", "isect", "diff", 0,
  43         "mtl", "rend", "rend-area", "viewrend", 0, "cfg"
  44 };
  45 static int tbn_icon_pos[][2] = {
  46         {0,0}, {16,0}, {32,0}, {-1,-1},
  47         {48,0}, {64,0}, {80,0}, {96,0}, {-1,-1},
  48         {112,0}, {112,16}, {-1,-1},
  49         {0,16}, {16,16}, {32,16}, {-1,-1},
  50         {48,16}, {64,16}, {64, 32}, {80,16}, {-1,-1}, {96,16}
  51 };
  52 static int tbn_istool[] = {
  53         0, 0, 0, 0,
  54         1, 1, 1, 1, 0,
  55         0, 0, 0,
  56         1, 1, 1, 0,
  57         0, 0, 1, 0, 0, 0
  58 };
  59 static rtk_icon *tbn_icons[NUM_TOOL_BUTTONS];
  60 static rtk_widget *tbn_buttons[NUM_TOOL_BUTTONS];
  61
  62 #define TOOLBAR_HEIGHT  26
  63
  64 enum {
  65         TOOL_SEL, TOOL_MOVE, TOOL_ROT, TOOL_SCALE,
  66         TOOL_UNION, TOOL_ISECT, TOOL_DIFF, TOOL_REND_AREA,
  67         NUM_TOOLS
  68 };
  69 static rtk_widget *tools[NUM_TOOLS];
  70
  71 static int vpdirty;
  72
  73
  74 static int mdl_init(void);
  75 static void mdl_destroy(void);
  76 static int mdl_start(void);
  77 static void mdl_stop(void);
  78 static void mdl_display(void);
  79 static void mdl_reshape(int x, int y);
  80 static void mdl_keyb(int key, int press);
  81 static void mdl_mouse(int bn, int press, int x, int y);
  82 static void mdl_motion(int x, int y);
  83
  84 static void draw_object(struct object *obj);
  85 static void setup_material(struct material *mtl);
  86 static void draw_grid(void);
  87 static void tbn_callback(rtk_widget *w, void *cls);
  88
  89 static void act_settool(int tidx);
  90 static void act_addobj(void);
  91 static void act_rmobj(void);
  92
  93 static void fix_rect(rtk_rect *rect);
  94 static void draw_rband(void);
  95 static void moveobj(struct object *obj, int px0, int py0, int px1, int py1);
  96
  97 static void inval_vport(void);
  98
  99
 100 struct app_screen scr_model = {
 101         "modeller",
 102         mdl_init, mdl_destroy,
 103         mdl_start, mdl_stop,
 104         mdl_display, mdl_reshape,
 105         mdl_keyb, mdl_mouse, mdl_motion
 106 };
 107
 108 static rtk_widget *toolbar;
 109 static rtk_iconsheet *icons;
 110
 111 static struct cmesh *mesh_sph;
 112
 113 static float cam_theta, cam_phi = 20, cam_dist = 8;
 114 static float view_matrix[16], proj_matrix[16];
 115 static float view_matrix_inv[16], proj_matrix_inv[16];
 116 static int viewport[4];
 117 static cgm_ray pickray;
 118
 119 static int cur_tool, prev_tool = -1;
 120 static int selobj = -1;
 121
 122 static rtk_rect rband;
 123 static int rband_valid;
 124
 125 static int rendering;
 126 static rtk_rect rendrect;
 127
 128
 129 static int mdl_init(void)
 130 {
 131         int i, toolidx;
 132         rtk_widget *w;
 133
 134         if(!(icons = rtk_load_iconsheet("data/icons.png"))) {
 135                 errormsg("failed to load iconsheet\n");
 136                 return -1;
 137         }
 138         for(i=0; i<NUM_TOOL_BUTTONS; i++) {
 139                 if(tbn_icon_name[i]) {
 140                         tbn_icons[i] = rtk_define_icon(icons, tbn_icon_name[i],
 141                                         tbn_icon_pos[i][0], tbn_icon_pos[i][1], 16, 16);
 142                 } else {
 143                         tbn_icons[i] = 0;
 144                 }
 145         }
 146
 147         if(!(toolbar = rtk_create_window(0, "toolbar", 0, 0, win_width, TOOLBAR_HEIGHT))) {
 148                 return -1;
 149         }
 150         rtk_win_layout(toolbar, RTK_HBOX);
 151
 152         toolidx = 0;
 153         for(i=0; i<NUM_TOOL_BUTTONS; i++) {
 154                 if(!tbn_icons[i]) {
 155                         rtk_create_separator(toolbar);
 156                 } else {
 157                         if(!(w = rtk_create_iconbutton(toolbar, tbn_icons[i], 0))) {
 158                                 return -1;
 159                         }
 160                         tbn_buttons[i] = w;
 161                         rtk_set_callback(w, tbn_callback, (void*)(intptr_t)i);
 162                         if(tbn_istool[i]) {
 163                                 rtk_bn_mode(w, RTK_TOGGLEBN);
 164                                 tools[toolidx++] = w;
 165                         }
 166                         if(i == TBN_SEL) {
 167                                 rtk_set_value(w, 1);
 168                         }
 169                 }
 170         }
 171         assert(toolidx == NUM_TOOLS);
 172
 173         if(!(mesh_sph = cmesh_alloc())) {
 174                 errormsg("failed to allocate sphere vis mesh\n");
 175                 return -1;
 176         }
 177         gen_sphere(mesh_sph, 1.0f, 16, 8, 1.0f, 1.0f);
 178
 179         vpdirty = 1;
 180         return 0;
 181 }
 182
 183 static void mdl_destroy(void)
 184 {
 185         cmesh_free(mesh_sph);
 186         rtk_free_iconsheet(icons);
 187 }
 188
 189 static int mdl_start(void)
 190 {
 191         gaw_clear_color(0.125, 0.125, 0.125, 1);
 192
 193         gaw_enable(GAW_DEPTH_TEST);
 194         gaw_enable(GAW_CULL_FACE);
 195         gaw_enable(GAW_LIGHTING);
 196         gaw_enable(GAW_LIGHT0);
 197
 198         rend_pan(0, -TOOLBAR_HEIGHT);
 199         return 0;
 200 }
 201
 202 static void mdl_stop(void)
 203 {
 204 }
 205
 206 static void mdl_display(void)
 207 {
 208         int i, num;
 209
 210         /* viewport */
 211         if(vpdirty) {
 212                 gaw_clear(GAW_COLORBUF | GAW_DEPTHBUF);
 213
 214                 gaw_matrix_mode(GAW_MODELVIEW);
 215                 gaw_load_identity();
 216                 gaw_translate(0, 0, -cam_dist);
 217                 gaw_rotate(cam_phi, 1, 0, 0);
 218                 gaw_rotate(cam_theta, 0, 1, 0);
 219                 gaw_get_modelview(view_matrix);
 220                 cgm_mcopy(view_matrix_inv, view_matrix);
 221                 cgm_minverse(view_matrix_inv);
 222
 223                 draw_grid();
 224
 225                 num = scn_num_objects(scn);
 226                 for(i=0; i<num; i++) {
 227                         setup_material(scn->objects[i]->mtl);
 228
 229                         if(i == selobj) {
 230                                 gaw_zoffset(1);
 231                                 gaw_enable(GAW_POLYGON_OFFSET);
 232                                 draw_object(scn->objects[i]);
 233                                 gaw_disable(GAW_POLYGON_OFFSET);
 234
 235                                 gaw_save();
 236                                 gaw_disable(GAW_LIGHTING);
 237                                 gaw_poly_wire();
 238                                 gaw_color3f(0, 1, 0);
 239                                 draw_object(scn->objects[i]);
 240                                 gaw_poly_gouraud();
 241                                 gaw_restore();
 242                         } else {
 243                                 draw_object(scn->objects[i]);
 244                         }
 245                 }
 246                 vpdirty = 0;
 247
 248                 /* dirty all GUI windows */
 249                 rtk_invalidate(toolbar);
 250         }
 251
 252         /* render layer */
 253         if(rendering) {
 254                 if(!render(framebuf)) {
 255                         rendering = 0;
 256                         vpdirty = 1;
 257                 }
 258                 app_redisplay(rendrect.x, rendrect.y, rendrect.width, rendrect.height);
 259         }
 260
 261         /* GUI */
 262         rtk_draw_widget(toolbar);
 263
 264         if(rband_valid) {
 265                 draw_rband();
 266         }
 267 }
 268
 269 static void draw_object(struct object *obj)
 270 {
 271         struct sphere *sph;
 272
 273         if(!obj->xform_valid) {
 274                 calc_object_matrix(obj);
 275         }
 276         gaw_push_matrix();
 277         gaw_mult_matrix(obj->xform);
 278
 279         switch(obj->type) {
 280         case OBJ_SPHERE:
 281                 sph = (struct sphere*)obj;
 282                 gaw_scale(sph->rad, sph->rad, sph->rad);
 283                 cmesh_draw(mesh_sph);
 284                 break;
 285
 286         default:
 287                 break;
 288         }
 289
 290         gaw_pop_matrix();
 291 }
 292
 293 static void setup_material(struct material *mtl)
 294 {
 295         gaw_mtl_diffuse(mtl->kd.x, mtl->kd.y, mtl->kd.z, 1.0f);
 296         gaw_mtl_specular(mtl->ks.x, mtl->ks.y, mtl->ks.z, mtl->shin);
 297         gaw_mtl_emission(mtl->ke.x, mtl->ke.y, mtl->ke.z);
 298 }
 299
 300 static void draw_grid(void)
 301 {
 302         gaw_save();
 303         gaw_disable(GAW_LIGHTING);
 304
 305         gaw_begin(GAW_LINES);
 306         gaw_color3f(0.5, 0, 0);
 307         gaw_vertex3f(0, 0, 0);
 308         gaw_vertex3f(-100, 0, 0);
 309         gaw_vertex3f(0, 0, 0);
 310         gaw_vertex3f(100, 0, 0);
 311         gaw_color3f(0, 0.5, 0);
 312         gaw_vertex3f(0, 0, 0);
 313         gaw_vertex3f(0, 0, -100);
 314         gaw_vertex3f(0, 0, 0);
 315         gaw_vertex3f(0, 0, 100);
 316         gaw_end();
 317
 318         gaw_restore();
 319 }
 320
 321 static void mdl_reshape(int x, int y)
 322 {
 323         float aspect = (float)x / (float)(y - TOOLBAR_HEIGHT);
 324
 325         viewport[0] = 0;
 326         viewport[1] = TOOLBAR_HEIGHT;
 327         viewport[2] = x;
 328         viewport[3] = y - TOOLBAR_HEIGHT;
 329         gaw_viewport(viewport[0], viewport[1], viewport[2], viewport[3]);
 330
 331         gaw_matrix_mode(GAW_PROJECTION);
 332         gaw_load_identity();
 333         gaw_perspective(50, aspect, 0.5, 100.0);
 334         gaw_get_projection(proj_matrix);
 335         cgm_mcopy(proj_matrix_inv, proj_matrix);
 336         cgm_minverse(proj_matrix_inv);
 337
 338         rtk_resize(toolbar, win_width, TOOLBAR_HEIGHT);
 339 }
 340
 341 static void mdl_keyb(int key, int press)
 342 {
 343         if(rtk_input_key(toolbar, key, press)) {
 344                 return;
 345         }
 346
 347         if(press) {
 348                 switch(key) {
 349                 case 27:
 350                         act_settool(TOOL_SEL);
 351                         break;
 352                 case 'g':
 353                         act_settool(TOOL_MOVE);
 354                         break;
 355                 case 'r':
 356                         act_settool(TOOL_ROT);
 357                         break;
 358                 case 's':
 359                         act_settool(TOOL_SCALE);
 360                         break;
 361
 362                 case KEY_F6:
 363                         act_settool(TOOL_REND_AREA);
 364                         break;
 365
 366                 case KEY_DEL:
 367                         act_rmobj();
 368                         break;
 369
 370                 default:
 371                         break;
 372                 }
 373         }
 374 }
 375
 376 static int vpdrag;
 377
 378 static void mdl_mouse(int bn, int press, int x, int y)
 379 {
 380         struct rayhit hit;
 381         if(!vpdrag && rtk_input_mbutton(toolbar, bn, press, x, y)) {
 382                 return;
 383         }
 384
 385         if(press) {
 386                 rband_valid = 0;
 387                 rband.x = x;
 388                 rband.y = y;
 389                 vpdrag |= (1 << bn);
 390         } else {
 391                 vpdrag &= ~(1 << bn);
 392
 393                 if(rband_valid) {
 394                         rband_valid = 0;
 395
 396                         if(cur_tool == TOOL_REND_AREA) {
 397                                 if(prev_tool >= 0) {
 398                                         act_settool(prev_tool);
 399                                 }
 400                                 rendering = 1;
 401                                 rend_size(win_width, win_height);
 402                                 fix_rect(&rband);
 403                                 rendrect = rband;
 404                                 rend_begin(rband.x, rband.y, rband.width, rband.height);
 405                         }
 406                         app_redisplay(rband.x, rband.y, rband.width, rband.height);
 407
 408                 } else if(bn == 0 && x == rband.x && y == rband.y) {
 409                         primray(&pickray, x, y);
 410                         if(scn_intersect(scn, &pickray, &hit)) {
 411                                 int newsel = scn_object_index(scn, hit.obj);
 412                                 if(newsel != selobj) {
 413                                         selobj = newsel;
 414                                         inval_vport();
 415                                 }
 416                         } else {
 417                                 if(selobj != -1) {
 418                                         inval_vport();
 419                                 }
 420                                 selobj = -1;
 421                         }
 422                 }
 423         }
 424 }
 425
 426 static void mdl_motion(int x, int y)
 427 {
 428         int dx, dy;
 429
 430         if(!vpdrag && rtk_input_mmotion(toolbar, x, y)) {
 431                 return;
 432         }
 433
 434         dx = x - mouse_x;
 435         dy = y - mouse_y;
 436
 437         if(modkeys) {
 438                 /* navigation */
 439                 if(mouse_state[0]) {
 440                         cam_theta += dx * 0.5f;
 441                         cam_phi += dy * 0.5f;
 442                         if(cam_phi < -90) cam_phi = -90;
 443                         if(cam_phi > 90) cam_phi = 90;
 444                         inval_vport();
 445                 }
 446
 447                 if(mouse_state[2]) {
 448                         cam_dist += dy * 0.1f;
 449                         if(cam_dist < 0) cam_dist = 0;
 450                         inval_vport();
 451                 }
 452         } else {
 453                 if(mouse_state[0]) {
 454                         switch(cur_tool) {
 455                         case TOOL_SEL:
 456                         case TOOL_REND_AREA:
 457                                 if(rband.x != x || rband.y != y) {
 458                                         rband.width = x - rband.x;
 459                                         rband.height = y - rband.y;
 460                                         rband_valid = 1;
 461                                 }
 462                                 break;
 463
 464                         case TOOL_MOVE:
 465                                 if(selobj >= 0) {
 466                                         struct object *obj = scn->objects[selobj];
 467                                         moveobj(obj, mouse_x, mouse_y, x, y);
 468                                 }
 469                                 break;
 470
 471                         default:
 472                                 break;
 473                         }
 474                 }
 475         }
 476 }
 477
 478 static void add_sphere(void)
 479 {
 480         struct object *obj;
 481
 482         if(!(obj = create_object(OBJ_SPHERE))) {
 483                 return;
 484         }
 485         scn_add_object(scn, obj);
 486 }
 487
 488 static void tbn_callback(rtk_widget *w, void *cls)
 489 {
 490         int id = (intptr_t)cls;
 491
 492         switch(id) {
 493         case TBN_SEL:
 494         case TBN_MOVE:
 495         case TBN_ROT:
 496         case TBN_SCALE:
 497                 act_settool(id - TBN_SEL);
 498                 break;
 499         case TBN_UNION:
 500         case TBN_ISECT:
 501         case TBN_DIFF:
 502                 act_settool(id - TBN_UNION + TOOL_UNION);
 503                 break;
 504         case TBN_REND_AREA:
 505                 act_settool(TOOL_REND_AREA);
 506                 break;
 507
 508         case TBN_ADD:
 509                 act_addobj();
 510                 break;
 511
 512         case TBN_RM:
 513                 act_rmobj();
 514                 break;
 515
 516         default:
 517                 break;
 518         }
 519 }
 520
 521 static void act_settool(int tidx)
 522 {
 523         int i;
 524         rtk_rect r;
 525
 526         prev_tool = cur_tool;
 527         cur_tool = tidx;
 528         for(i=0; i<NUM_TOOLS; i++) {
 529                 if(i == cur_tool) {
 530                         if(!rtk_get_value(tools[i])) {
 531                                 rtk_set_value(tools[i], 1);
 532                                 rtk_get_rect(tools[i], &r);
 533                         }
 534                 } else {
 535                         if(rtk_get_value(tools[i])) {
 536                                 rtk_set_value(tools[i], 0);
 537                                 rtk_get_rect(tools[i], &r);
 538                         }
 539                 }
 540         }
 541 }
 542
 543 static void act_addobj(void)
 544 {
 545         int idx = scn_num_objects(scn);
 546         add_sphere();
 547         selobj = idx;
 548
 549         inval_vport();
 550 }
 551
 552 static void act_rmobj(void)
 553 {
 554         if(selobj >= 0) {
 555                 scn_rm_object(scn, selobj);
 556                 selobj = -1;
 557                 inval_vport();
 558         }
 559 }
 560
 561 static void fix_rect(rtk_rect *rect)
 562 {
 563         int x, y, w, h;
 564
 565         x = rband.x;
 566         y = rband.y;
 567
 568         if(rband.width < 0) {
 569                 w = -rband.width;
 570                 x += rband.width;
 571         } else {
 572                 w = rband.width;
 573         }
 574         if(rband.height < 0) {
 575                 h = -rband.height;
 576                 y += rband.height;
 577         } else {
 578                 h = rband.height;
 579         }
 580
 581         rect->x = x;
 582         rect->y = y;
 583         rect->width = w;
 584         rect->height = h;
 585 }
 586
 587 static void draw_rband(void)
 588 {
 589         int i;
 590         rtk_rect rect;
 591         uint32_t *fbptr, *bptr;
 592
 593         rect = rband;
 594         fix_rect(&rect);
 595
 596         fbptr = framebuf + rect.y * win_width + rect.x;
 597         bptr = fbptr + win_width * (rect.height - 1);
 598
 599         for(i=0; i<rect.width; i++) {
 600                 fbptr[i] ^= 0xffffff;
 601                 bptr[i] ^= 0xffffff;
 602         }
 603         fbptr += win_width;
 604         for(i=0; i<rect.height-2; i++) {
 605                 fbptr[0] ^= 0xffffff;
 606                 fbptr[rect.width - 1] ^= 0xffffff;
 607                 fbptr += win_width;
 608         }
 609         app_redisplay(rect.x, rect.y, rect.width, rect.height);
 610 }
 611
 612 void primray(cgm_ray *ray, int x, int y)
 613 {
 614         float nx, ny;
 615         cgm_vec3 npos, farpt;
 616         float inv_pv[16];
 617
 618         y = win_height - y;
 619         nx = (float)(x - viewport[0]) / (float)viewport[2];
 620         ny = (float)(y - viewport[1]) / (float)viewport[3];
 621
 622         cgm_mcopy(inv_pv, proj_matrix_inv);
 623         cgm_mmul(inv_pv, view_matrix_inv);
 624
 625         cgm_vcons(&npos, nx, ny, 0.0f);
 626         cgm_unproject(&ray->origin, &npos, inv_pv);
 627         npos.z = 1.0f;
 628         cgm_unproject(&farpt, &npos, inv_pv);
 629
 630         ray->dir.x = farpt.x - ray->origin.x;
 631         ray->dir.y = farpt.y - ray->origin.y;
 632         ray->dir.z = farpt.z - ray->origin.z;
 633 }
 634
 635 static void moveobj(struct object *obj, int px0, int py0, int px1, int py1)
 636 {
 637         cgm_ray ray;
 638         float dist;
 639         cgm_vec3 p0, p1;
 640
 641         primray(&ray, px0, py0);
 642         cgm_vnormalize(&ray.dir);
 643         dist = ray_object_dist(&ray, obj);
 644         cgm_raypos(&p0, &ray, dist);
 645         primray(&ray, px1, py1);
 646         cgm_vnormalize(&ray.dir);
 647         cgm_raypos(&p1, &ray, dist);
 648
 649         cgm_vsub(&p1, &p0);
 650         cgm_vadd(&obj->pos, &p1);
 651         obj->xform_valid = 0;
 652
 653         inval_vport();
 654 }
 655
 656 static void inval_vport(void)
 657 {
 658         vpdirty = 1;
 659         app_redisplay(0, 0, 0, 0);
 660 }