main/editor/objpage.c

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