main/editor/objpage.c

   1 /*
   2 THE COMPUTER CODE CONTAINED HEREIN IS THE SOLE PROPERTY OF PARALLAX
   3 SOFTWARE CORPORATION ("PARALLAX").  PARALLAX, IN DISTRIBUTING THE CODE TO
   4 END-USERS, AND SUBJECT TO ALL OF THE TERMS AND CONDITIONS HEREIN, GRANTS A
   5 ROYALTY-FREE, PERPETUAL LICENSE TO SUCH END-USERS FOR USE BY SUCH END-USERS
   6 IN USING, DISPLAYING,  AND CREATING DERIVATIVE WORKS THEREOF, SO LONG AS
   7 SUCH USE, DISPLAY OR CREATION IS FOR NON-COMMERCIAL, ROYALTY OR REVENUE
   8 FREE PURPOSES.  IN NO EVENT SHALL THE END-USER USE THE COMPUTER CODE
   9 CONTAINED HEREIN FOR REVENUE-BEARING PURPOSES.  THE END-USER UNDERSTANDS
  10 AND AGREES TO THE TERMS HEREIN AND ACCEPTS THE SAME BY USE OF THIS FILE.
  11 COPYRIGHT 1993-1998 PARALLAX SOFTWARE CORPORATION.  ALL RIGHTS RESERVED.
  12 */
  13
  14 /*
  15  *
  16  * object selection stuff.
  17  *
  18  */
  19
  20 // Num_robot_types -->  N_polygon_models
  21 // Cur_robot_type --> Cur_robot_type
  22 // Texture[Cur_robot_type]->bitmap  ---> robot_bms[robot_bm_nums[ Cur_robot_type ] ]
  23
  24 #ifdef HAVE_CONFIG_H
  25 #include "conf.h"
  26 #endif
  27
  28 #include <stdlib.h>
  29 #include <stdio.h>
  30
  31
  32 #include "inferno.h"
  33 #include "editor.h"                     // For TMAP_CURBOX??????
  34 #include "gr.h"                         // For canves, font stuff
  35 #include "ui.h"                         // For UI_GADGET stuff
  36 #include "mono.h"                               // For debugging
  37 #include "error.h"
  38
  39
  40 #define OBJS_PER_PAGE 8
  41
  42 static UI_GADGET_USERBOX * ObjBox[OBJS_PER_PAGE];
  43 static UI_GADGET_USERBOX * ObjCurrent;
  44
  45 static int ObjectPage = 0;
  46
  47 //static char Description[8][20] = { "Pig", "Star", "Little\nJosh", "Big\nJosh", "Flying\nPig", "Flying\nStar",
  48 //"Little\nFlying\nJosh", "Big\nFlying\nJosh" };
  49
  50 //static grs_canvas * ObjnameCanvas;
  51 //static char object_filename[13];
  52
  53 //static void objpage_print_name( char name[13] ) {
  54 //       short w,h,aw;
  55 //
  56 //    gr_set_current_canvas( ObjnameCanvas );
  57 //    gr_get_string_size( name, &w, &h, &aw );
  58 //    gr_string( 0, 0, name );
  59 //       //gr_set_fontcolor( CBLACK, CWHITE );
  60 //}
  61
  62 //static void objpage_display_name( char *format, ... ) {
  63 //      va_list ap;
  64 //
  65 //      va_start(ap, format);
  66 //   vsprintf(object_filename, format, ap);
  67 //      va_end(ap);
  68 //
  69 //   objpage_print_name(object_filename);
  70 //
  71 //}
  72
  73 #include "maths.h"
  74 #include "3d.h"
  75 #include "inferno.h"
  76 #include "texmap.h"
  77
  78
  79 vms_angvec objpage_view_orient;
  80 fix objpage_view_dist;
  81
  82 //this is bad to have the extern, but this snapshot stuff is special
  83 extern int polyobj_lighting;
  84
  85
  86 //canvas set
  87 void draw_object_picture(int id, vms_angvec *orient_angles, int type)
  88 {
  89
  90         if (id >= Num_object_subtypes)
  91                 return;
  92
  93         switch (type) {
  94
  95                 case OBJ_HOSTAGE:
  96                         PIGGY_PAGE_IN(Vclip[Hostage_vclip_num[id]].frames[0]);
  97                         gr_bitmap(0,0,&GameBitmaps[Vclip[Hostage_vclip_num[id]].frames[0].index]);
  98                         break;
  99
 100                 case OBJ_POWERUP:
 101                         if ( Powerup_info[id].vclip_num > -1 )  {
 102                                 PIGGY_PAGE_IN(Vclip[Powerup_info[id].vclip_num].frames[0]);
 103                                 gr_bitmap(0,0,&GameBitmaps[Vclip[Powerup_info[id].vclip_num].frames[0].index]);
 104                         }
 105                         break;
 106
 107                 case OBJ_PLAYER:
 108                         draw_model_picture(Player_ship->model_num,orient_angles);               // Draw a poly model below
 109                         break;
 110
 111                 case OBJ_ROBOT:
 112                         draw_model_picture(Robot_info[id].model_num,orient_angles);     // Draw a poly model below
 113                         break;
 114
 115                 case OBJ_CNTRLCEN:
 116                 case OBJ_CLUTTER:
 117                         draw_model_picture(Reactors[id].model_num, orient_angles);
 118                         break;
 119                 default:
 120                         //Int3();       // Invalid type!!!
 121                         return;
 122         }
 123
 124 }
 125
 126 void redraw_current_object()
 127 {
 128         grs_canvas * cc;
 129
 130         cc = grd_curcanv;
 131         gr_set_current_canvas(ObjCurrent->canvas);
 132         draw_object_picture(Cur_object_id, &objpage_view_orient, Cur_object_type);
 133         gr_set_current_canvas(cc);
 134 }
 135
 136 void gr_label_box( int i)
 137 {
 138
 139         gr_clear_canvas(BM_XRGB(0,0,0));
 140         draw_object_picture(i, &objpage_view_orient, Cur_object_type);
 141
 142 //      char s[20];
 143 //      sprintf( s, " %d ", i );
 144 //      gr_clear_canvas( BM_XRGB(0,15,0) );
 145 //      gr_set_fontcolor( CWHITE, BM_XRGB(0,15,0) );
 146 //      ui_string_centered(  grd_curcanv->cv_bitmap.bm_w/2, grd_curcanv->cv_bitmap.bm_h/2, Description[i] );
 147 }
 148
 149 int objpage_goto_first()
 150 {
 151         int i;
 152
 153         ObjectPage=0;
 154         for (i=0;  i<OBJS_PER_PAGE; i++ ) {
 155                 gr_set_current_canvas(ObjBox[i]->canvas);
 156                 if (i+ObjectPage*OBJS_PER_PAGE < Num_object_subtypes ) {
 157                         //gr_ubitmap(0,0, robot_bms[robot_bm_nums[ i+ObjectPage*OBJS_PER_PAGE ] ] );
 158                         gr_label_box(i+ObjectPage*OBJS_PER_PAGE );
 159                 } else
 160                         gr_clear_canvas( CGREY );
 161         }
 162
 163         return 1;
 164 }
 165
 166 int objpage_goto_last()
 167 {
 168         int i;
 169
 170         ObjectPage=(Num_object_subtypes)/OBJS_PER_PAGE;
 171         for (i=0;  i<OBJS_PER_PAGE; i++ )
 172         {
 173                 gr_set_current_canvas(ObjBox[i]->canvas);
 174                 if (i+ObjectPage*OBJS_PER_PAGE < Num_object_subtypes )
 175                 {
 176                         //gr_ubitmap(0,0, robot_bms[robot_bm_nums[ i+ObjectPage*OBJS_PER_PAGE ] ] );
 177                         gr_label_box(i+ObjectPage*OBJS_PER_PAGE );
 178                 } else {
 179                         gr_clear_canvas( CGREY );
 180                 }
 181         }
 182         return 1;
 183 }
 184
 185 static int objpage_goto_prev()
 186 {
 187         int i;
 188         if (ObjectPage > 0) {
 189                 ObjectPage--;
 190                 for (i=0;  i<OBJS_PER_PAGE; i++ )
 191                 {
 192                         gr_set_current_canvas(ObjBox[i]->canvas);
 193                         if (i+ObjectPage*OBJS_PER_PAGE < Num_object_subtypes)
 194                         {
 195                                 //gr_ubitmap(0,0, robot_bms[robot_bm_nums[ i+ObjectPage*OBJS_PER_PAGE ] ] );
 196                                 gr_label_box(i+ObjectPage*OBJS_PER_PAGE );
 197                         } else {
 198                                 gr_clear_canvas( CGREY );
 199                         }
 200                 }
 201         }
 202         return 1;
 203 }
 204
 205 static int objpage_goto_next()
 206 {
 207         int i;
 208         if ((ObjectPage+1)*OBJS_PER_PAGE < Num_object_subtypes) {
 209                 ObjectPage++;
 210                 for (i=0;  i<OBJS_PER_PAGE; i++ )
 211                 {
 212                         gr_set_current_canvas(ObjBox[i]->canvas);
 213                         if (i+ObjectPage*OBJS_PER_PAGE < Num_object_subtypes)
 214                         {
 215                                 //gr_ubitmap(0,0, robot_bms[robot_bm_nums[ i+ObjectPage*OBJS_PER_PAGE ] ] );
 216                                 gr_label_box(i+ObjectPage*OBJS_PER_PAGE );
 217                         } else {
 218                                 gr_clear_canvas( CGREY );
 219                         }
 220                 }
 221         }
 222         return 1;
 223 }
 224
 225 int objpage_grab_current(int n)
 226 {
 227         int i;
 228
 229         if ((n < 0) || (n >= Num_object_subtypes)) return 0;
 230
 231         ObjectPage = n / OBJS_PER_PAGE;
 232
 233         if (ObjectPage*OBJS_PER_PAGE < Num_object_subtypes) {
 234                 for (i=0;  i<OBJS_PER_PAGE; i++ )
 235                 {
 236                         gr_set_current_canvas(ObjBox[i]->canvas);
 237                         if (i + ObjectPage*OBJS_PER_PAGE < Num_object_subtypes)
 238                         {
 239                                 //gr_ubitmap(0,0, robot_bms[robot_bm_nums[ i+ObjectPage*OBJS_PER_PAGE ] ] );
 240                                 gr_label_box(i+ObjectPage*OBJS_PER_PAGE );
 241                         } else {
 242                                 gr_clear_canvas( CGREY );
 243                         }
 244                 }
 245         }
 246
 247         Cur_object_id = n;
 248         gr_set_current_canvas(ObjCurrent->canvas);
 249         //gr_ubitmap(0,0, robot_bms[robot_bm_nums[ Cur_robot_type ] ] );
 250         gr_label_box(Cur_object_id);
 251
 252         //objpage_display_name( Texture[Cur_robot_type]->filename );
 253
 254         return 1;
 255 }
 256
 257 int objpage_goto_next_object()
 258 {
 259         // there should be a pop-up menu for this
 260         switch (Cur_object_type)
 261         {
 262                 case OBJ_ROBOT:
 263                         Cur_object_type = OBJ_HOSTAGE;
 264                         Num_object_subtypes = 1;
 265                         break;
 266
 267                 case OBJ_HOSTAGE:
 268                         Cur_object_type = OBJ_PLAYER;
 269                         Num_object_subtypes = 1;        // can have anarchy/coop, but this is handled automatically
 270                         break;
 271
 272                 case OBJ_PLAYER:
 273                         Cur_object_type = OBJ_POWERUP;
 274                         Num_object_subtypes = N_powerup_types;
 275                         break;
 276
 277                 case OBJ_POWERUP:
 278                         Cur_object_type = OBJ_CNTRLCEN;
 279                         Num_object_subtypes = Num_reactors;
 280                         break;
 281
 282                 case OBJ_CNTRLCEN:
 283                 default:
 284                         Cur_object_type = OBJ_ROBOT;
 285                         Num_object_subtypes = N_robot_types;
 286                         break;
 287         }
 288
 289         objpage_grab_current(0);
 290
 291         return 1;
 292
 293 }
 294
 295 #define OBJBOX_X        (TMAPBOX_X)     //location of first one
 296 #define OBJBOX_Y        (OBJCURBOX_Y - 24 )
 297 #define OBJBOX_W        64
 298 #define OBJBOX_H        64
 299
 300 #define DELTA_ANG 0x800
 301
 302 int objpage_increase_pitch()
 303 {
 304         objpage_view_orient.p += DELTA_ANG;
 305         redraw_current_object();
 306         return 1;
 307 }
 308
 309 int objpage_decrease_pitch()
 310 {
 311         objpage_view_orient.p -= DELTA_ANG;
 312         redraw_current_object();
 313         return 1;
 314 }
 315
 316 int objpage_increase_heading()
 317 {
 318         objpage_view_orient.h += DELTA_ANG;
 319         redraw_current_object();
 320         return 1;
 321 }
 322
 323 int objpage_decrease_heading()
 324 {
 325         objpage_view_orient.h -= DELTA_ANG;
 326         redraw_current_object();
 327         return 1;
 328 }
 329
 330 int objpage_increase_bank()
 331 {
 332         objpage_view_orient.b += DELTA_ANG;
 333         redraw_current_object();
 334         return 1;
 335 }
 336
 337 int objpage_decrease_bank()
 338 {
 339         objpage_view_orient.b -= DELTA_ANG;
 340         redraw_current_object();
 341         return 1;
 342 }
 343
 344 int objpage_increase_z()
 345 {
 346         objpage_view_dist -= 0x8000;
 347         redraw_current_object();
 348         return 1;
 349 }
 350
 351 int objpage_decrease_z()
 352 {
 353         objpage_view_dist += 0x8000;
 354         redraw_current_object();
 355         return 1;
 356 }
 357
 358 int objpage_reset_orient()
 359 {
 360         objpage_view_orient.p = 0;
 361         objpage_view_orient.b = 0;
 362         objpage_view_orient.h = -0x8000;
 363         //objpage_view_dist = DEFAULT_VIEW_DIST;
 364         redraw_current_object();
 365         return 1;
 366 }
 367
 368
 369 // INIT TEXTURE STUFF
 370
 371 void objpage_init( UI_WINDOW *win )
 372 {
 373         int i;
 374
 375         //Num_total_object_types = N_polygon_models + N_hostage_types + N_powerup_types;
 376         //Assert (N_polygon_models < MAX_POLYGON_MODELS);
 377         //Assert (Num_total_object_types < MAX_OBJTYPE );
 378         //Assert (N_hostage_types < MAX_HOSTAGE_TYPES );
 379         //Assert (N_powerup_types < MAX_POWERUP_TYPES );
 380         // Assert (N_robot_types < MAX_ROBOTS);
 381
 382         ui_add_gadget_button( win, OBJCURBOX_X + 00, OBJCURBOX_Y - 27, 30, 20, "<<", objpage_goto_prev );
 383         ui_add_gadget_button( win, OBJCURBOX_X + 32, OBJCURBOX_Y - 27, 30, 20, ">>", objpage_goto_next );
 384
 385         ui_add_gadget_button( win, OBJCURBOX_X + 00, OBJCURBOX_Y - 54, 30, 20, "B", objpage_goto_first );
 386         ui_add_gadget_button( win, OBJCURBOX_X + 32, OBJCURBOX_Y - 54, 30, 20, "E", objpage_goto_last );
 387
 388         ui_add_gadget_button( win, OBJCURBOX_X + 25, OBJCURBOX_Y + 62, 22, 13, "P-", objpage_decrease_pitch );
 389         ui_add_gadget_button( win, OBJCURBOX_X + 25, OBJCURBOX_Y + 90, 22, 13, "P+", objpage_increase_pitch );
 390         ui_add_gadget_button( win, OBJCURBOX_X + 00, OBJCURBOX_Y + 90, 22, 13, "B-", objpage_decrease_bank );
 391         ui_add_gadget_button( win, OBJCURBOX_X + 50, OBJCURBOX_Y + 90, 22, 13, "B+", objpage_increase_bank );
 392         ui_add_gadget_button( win, OBJCURBOX_X + 00, OBJCURBOX_Y + 76, 22, 13, "H-", objpage_decrease_heading );
 393         ui_add_gadget_button( win, OBJCURBOX_X + 50, OBJCURBOX_Y + 76, 22, 13, "H+", objpage_increase_heading );
 394         ui_add_gadget_button( win, OBJCURBOX_X + 00, OBJCURBOX_Y + 62, 22, 13, "Z+", objpage_increase_z );
 395         ui_add_gadget_button( win, OBJCURBOX_X + 50, OBJCURBOX_Y + 62, 22, 13, "Z-", objpage_decrease_z );
 396         ui_add_gadget_button( win, OBJCURBOX_X + 25, OBJCURBOX_Y + 76, 22, 13, "R", objpage_reset_orient );
 397
 398         for (i=0;i<OBJS_PER_PAGE;i++)
 399                 ObjBox[i] = ui_add_gadget_userbox( win, OBJBOX_X + (i/2)*(2+OBJBOX_W), OBJBOX_Y + (i%2)*(2+OBJBOX_H), OBJBOX_W, OBJBOX_H);
 400
 401         ObjCurrent = ui_add_gadget_userbox( win, OBJCURBOX_X, OBJCURBOX_Y-5, 64, 64 );
 402
 403         objpage_reset_orient();
 404
 405         for (i=0;  i<OBJS_PER_PAGE; i++ )
 406         {
 407                 gr_set_current_canvas(ObjBox[i]->canvas);
 408                 if (i+ObjectPage*OBJS_PER_PAGE < Num_object_subtypes)
 409                 {
 410                                 //gr_ubitmap(0,0, robot_bms[robot_bm_nums[ i+ObjectPage*OBJS_PER_PAGE ] ] );
 411                                 gr_label_box(i+ObjectPage*OBJS_PER_PAGE );
 412                 } else {
 413                         gr_clear_canvas( CGREY );
 414                 }
 415         }
 416
 417 // Don't reset robot_type when we return to editor.
 418 //      Cur_robot_type = ObjectPage*OBJS_PER_PAGE;
 419         gr_set_current_canvas(ObjCurrent->canvas);
 420         //gr_ubitmap(0,0, robot_bms[robot_bm_nums[ Cur_robot_type ] ] );
 421         gr_label_box(Cur_object_id);
 422
 423         //ObjnameCanvas = gr_create_sub_canvas(&grd_curscreen->sc_canvas, OBJCURBOX_X , OBJCURBOX_Y + OBJBOX_H + 10, 100, 20);
 424         //gr_set_current_canvas( ObjnameCanvas );
 425         //gr_set_curfont( ui_small_font );
 426    //gr_set_fontcolor( CBLACK, CWHITE );
 427         //objpage_display_name( Texture[Cur_robot_type]->filename );
 428
 429 }
 430
 431 void objpage_close()
 432 {
 433         //gr_free_sub_canvas(ObjnameCanvas);
 434 }
 435
 436
 437 // DO TEXTURE STUFF
 438
 439 void objpage_do()
 440 {
 441         int i;
 442
 443         for (i=0; i<OBJS_PER_PAGE; i++ )
 444         {
 445                 if (ObjBox[i]->b1_clicked && (i+ObjectPage*OBJS_PER_PAGE < Num_object_subtypes))
 446                 {
 447                         Cur_object_id = i+ObjectPage*OBJS_PER_PAGE;
 448                         gr_set_current_canvas(ObjCurrent->canvas);
 449                         //gr_ubitmap(0,0, robot_bms[robot_bm_nums[ Cur_robot_type ] ] );
 450                         gr_label_box(Cur_object_id);
 451                         //objpage_display_name( Texture[Cur_robot_type]->filename );
 452                 }
 453         }
 454 }