main/segment.h

   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-1999 PARALLAX SOFTWARE CORPORATION.  ALL RIGHTS RESERVED.
  12 */
  13
  14 #ifndef _SEGMENT_H
  15 #define _SEGMENT_H
  16
  17 #include        "pstypes.h"
  18 #include        "fix.h"
  19 #include "vecmat.h"
  20 //#include "3d.h"
  21 //#include "inferno.h"
  22
  23 // Version 1 - Initial version
  24 // Version 2 - Mike changed some shorts to bytes in segments, so incompatible!
  25
  26 #define SIDE_IS_QUAD    1                       // render side as quadrilateral
  27 #define SIDE_IS_TRI_02  2                       // render side as two triangles, triangulated along edge from 0 to 2
  28 #define SIDE_IS_TRI_13  3                       // render side as two triangles, triangulated along edge from 1 to 3
  29
  30 // Set maximum values for segment and face data structures.
  31 #define MAX_VERTICES_PER_SEGMENT        8
  32 #define MAX_SIDES_PER_SEGMENT           6
  33 #define MAX_VERTICES_PER_POLY           4
  34 #define WLEFT                                                           0
  35 #define WTOP                                                            1
  36 #define WRIGHT                                                  2
  37 #define WBOTTOM                                                 3
  38 #define WBACK                                                           4
  39 #define WFRONT                                                  5
  40
  41 #if defined(SHAREWARE)
  42   #define       MAX_SEGMENTS                                    800
  43   #define       MAX_SEGMENT_VERTICES                    2800
  44 #else
  45   #define       MAX_SEGMENTS                                    900
  46   #define       MAX_SEGMENT_VERTICES                    3600
  47 #endif
  48
  49 //normal everyday vertices
  50
  51 #define DEFAULT_LIGHTING                        0                       // (F1_0/2)
  52
  53 #ifdef EDITOR   //verts for the new segment
  54   #define       NUM_NEW_SEG_VERTICES            8
  55   #define       NEW_SEGMENT_VERTICES            (MAX_SEGMENT_VERTICES)
  56   #define       MAX_VERTICES                            (MAX_SEGMENT_VERTICES+NUM_NEW_SEG_VERTICES)
  57 #else           //No editor
  58   #define       MAX_VERTICES                            (MAX_SEGMENT_VERTICES)
  59 #endif
  60
  61 //      Returns true if segnum references a child, else returns false.
  62 //      Note that -1 means no connection, -2 means a connection to the outside world.
  63 #define IS_CHILD(segnum) (segnum > -1)
  64
  65 //Structure for storing u,v,light values.
  66 //NOTE: this structure should be the same as the one in 3d.h
  67 typedef struct uvl {
  68         fix u,v,l;
  69 } uvl;
  70
  71 #ifdef COMPACT_SEGS
  72 typedef struct side {
  73         byte            type;                                                                   // replaces num_faces and tri_edge, 1 = quad, 2 = 0:2 triangulation, 3 = 1:3 triangulation
  74         ubyte           pad;                                                                    //keep us longword alligned
  75         short           wall_num;
  76         short           tmap_num;
  77         short           tmap_num2;
  78         uvl             uvls[4];
  79         // vms_vector   normals[2];                                             // 2 normals, if quadrilateral, both the same.
  80 } side;
  81 #else
  82 typedef struct side {
  83         byte            type;                                                                   // replaces num_faces and tri_edge, 1 = quad, 2 = 0:2 triangulation, 3 = 1:3 triangulation
  84         ubyte           pad;                                                                    //keep us longword alligned
  85         short           wall_num;
  86         short           tmap_num;
  87         short           tmap_num2;
  88         uvl             uvls[4];
  89         vms_vector      normals[2];                                             // 2 normals, if quadrilateral, both the same.
  90 } side;
  91 #endif
  92
  93 typedef struct segment {
  94         #ifdef  EDITOR
  95         short           segnum;                                                         // segment number, not sure what it means
  96         #endif
  97         side            sides[MAX_SIDES_PER_SEGMENT];   // 6 sides
  98         short           children[MAX_SIDES_PER_SEGMENT];        // indices of 6 children segments, front, left, top, right, bottom, back
  99         short           verts[MAX_VERTICES_PER_SEGMENT];        // vertex ids of 4 front and 4 back vertices
 100         #ifdef  EDITOR
 101         short           group;                                                          // group number to which the segment belongs.
 102         short           objects;                                                                // pointer to objects in this segment
 103         #else
 104         int             objects;                                                                // pointer to objects in this segment
 105         #endif
 106
 107 // -- Moved to segment2 to make this struct 512 bytes long --
 108 //      ubyte           special;                                                                // what type of center this is
 109 //      byte            matcen_num;                                                     //      which center segment is associated with.
 110 //      short           value;
 111 //      fix             static_light;                                           //average static light in segment
 112 //      #ifndef EDITOR
 113 //      short           pad;                    //make structure longword aligned
 114 //      #endif
 115 } segment;
 116
 117 #define S2F_AMBIENT_WATER               0x01
 118 #define S2F_AMBIENT_LAVA                0x02
 119
 120 typedef struct segment2 {
 121         ubyte           special;
 122         byte            matcen_num;
 123         byte            value;
 124         ubyte           s2_flags;
 125         fix             static_light;
 126 } segment2;
 127
 128 //values for special field
 129 #define SEGMENT_IS_NOTHING                      0
 130 #define SEGMENT_IS_FUELCEN                      1
 131 #define SEGMENT_IS_REPAIRCEN            2
 132 #define SEGMENT_IS_CONTROLCEN           3
 133 #define SEGMENT_IS_ROBOTMAKER           4
 134 #define SEGMENT_IS_GOAL_BLUE            5
 135 #define SEGMENT_IS_GOAL_RED             6
 136 #define MAX_CENTER_TYPES                        7
 137
 138 #ifdef COMPACT_SEGS
 139 extern void get_side_normal(segment *sp, int sidenum, int normal_num, vms_vector * vm );
 140 extern void get_side_normals(segment *sp, int sidenum, vms_vector * vm1, vms_vector *vm2 );
 141 #endif
 142
 143 //      Local segment data.
 144 //      This is stuff specific to a segment that does not need to get written to disk.
 145 //      This is a handy separation because we can add to this structure without obsoleting
 146 //      existing data on disk.
 147 #define SS_REPAIR_CENTER        0x01                            //      Bitmask for this segment being part of repair center.
 148
 149 //--repair-- typedef struct {
 150 //--repair--    int     special_type;
 151 //--repair--    short   special_segment;                                                // if special_type indicates repair center, this is the base of the repair center
 152 //--repair-- } lsegment;
 153
 154 typedef struct {
 155         int             num_segments;
 156         int             num_vertices;
 157         short           segments[MAX_SEGMENTS];
 158         short           vertices[MAX_VERTICES];
 159 } group;
 160
 161 // Globals from mglobal.c
 162 extern  vms_vector      Vertices[];
 163 extern  segment         Segments[];
 164 extern  segment2                Segment2s[];
 165 extern  int                     Num_segments;
 166 extern  int                     Num_vertices;
 167
 168 extern  byte            Side_to_verts[MAX_SIDES_PER_SEGMENT][4];        // Side_to_verts[my_side] is list of vertices forming side my_side.
 169 extern  int             Side_to_verts_int[MAX_SIDES_PER_SEGMENT][4];    // Side_to_verts[my_side] is list of vertices forming side my_side.
 170 extern  char            Side_opposite[];                                                                        // Side_opposite[my_side] returns side opposite cube from my_side.
 171
 172 #define SEG_PTR_2_NUM(segptr) (Assert((unsigned) (segptr-Segments)<MAX_SEGMENTS),(segptr)-Segments)
 173
 174 //      New stuff, 10/14/95: For shooting out lights and monitors.
 175 //      Light cast upon vert_light vertices in segnum:sidenum by some light
 176 typedef struct {
 177         short   segnum;
 178         byte    sidenum;
 179         byte    dummy;
 180         ubyte   vert_light[4];
 181 } delta_light;
 182
 183 //      Light at segnum:sidenum casts light on count sides beginning at index (in array Delta_lights)
 184 typedef struct {
 185         short   segnum;
 186         byte    sidenum;
 187         byte    count;
 188         short   index;
 189 } dl_index;
 190
 191 #define MAX_DL_INDICES          500
 192 #define MAX_DELTA_LIGHTS        10000
 193
 194 #define DL_SCALE                                2048            //      Divide light to allow 3 bits integer, 5 bits fraction.
 195
 196 extern  dl_index                Dl_indices[MAX_DL_INDICES];
 197 extern  delta_light Delta_lights[MAX_DELTA_LIGHTS];
 198 extern  int                     Num_static_lights;
 199
 200 extern int subtract_light(int segnum, int sidenum);
 201 extern int add_light(int segnum, int sidenum);
 202 extern void restore_all_lights_in_mine(void);
 203 extern void clear_light_subtracted(void);
 204
 205 extern ubyte Light_subtracted[MAX_SEGMENTS];
 206
 207 // ----------------------------------------------------------------------------------------------------------
 208 // --------------------------  Segment interrogation functions ------------------------
 209 //       Do NOT read the segment data structure directly.  Use these functions instead.
 210 //                      The segment data structure is GUARANTEED to change MANY TIMES.  If you read the
 211 //                      segment data structure directly, your code will break, I PROMISE IT!
 212 //      Return a pointer to the list of vertex indices for the current segment in vp and
 213 //      the number of vertices in *nv.
 214 extern void med_get_vertex_list(segment *s,int *nv,short **vp);
 215
 216 //      Return a pointer to the list of vertex indices for face facenum in vp and
 217 //      the number of vertices in *nv.
 218 extern void med_get_face_vertex_list(segment *s,int side, int facenum,int *nv,short **vp);
 219
 220 //      Set *nf = number of faces in segment s.
 221 extern void med_get_num_faces(segment *s,int *nf);
 222
 223 void med_validate_segment_side(segment *sp,int side);
 224
 225 // Delete segment function added for curves.c
 226 extern int med_delete_segment(segment *sp);
 227
 228 //      Delete segment from group
 229 extern void delete_segment_from_group(int segment_num, int group_num);
 230
 231 //      Add segment to group
 232 extern void add_segment_to_group(int segment_num, int group_num);
 233
 234 // Verify that all vertices are legal.
 235 extern void med_check_all_vertices();
 236
 237 #endif
 238