summaryrefslogtreecommitdiffhomepage
path: root/Stars45/Physical.h
blob: b9a9be5e40b212f1adc0dafd640e7e59b678d279 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
/*  Starshatter: The Open Source Project
    Copyright (c) 2021-2022, Starshatter: The Open Source Project Contributors
    Copyright (c) 2011-2012, Starshatter OpenSource Distribution Contributors
    Copyright (c) 1997-2006, Destroyer Studios LLC.

    AUTHOR:       John DiCamillo


    OVERVIEW
    ========
    Abstract Physical Object
*/

#ifndef Physical_h
#define Physical_h

#include "Types.h"
#include "Geometry.h"
#include "Camera.h"

// +--------------------------------------------------------------------+

class Director;
class Graphic;
class Light;

// +--------------------------------------------------------------------+

class Physical
{
public:
    static const char* TYPENAME() { return "Physical"; }

    Physical();
    Physical(const char* n, int t=0);
    virtual ~Physical();

    int operator == (const Physical& p) const { return id == p.id; }

    // Integration Loop Control:
    static void       SetSubFrameLength(double seconds) { sub_frame = seconds; }
    static double     GetSubFrameLength()               { return sub_frame;    }

    // operations
    virtual void      ExecFrame(double seconds);
    virtual void      AeroFrame(double seconds);
    virtual void      ArcadeFrame(double seconds);

    virtual void      AngularFrame(double seconds);
    virtual void      LinearFrame(double seconds);

    virtual void      CalcFlightPath();

    virtual void      MoveTo(const Point& new_loc);
    virtual void      TranslateBy(const Point& ref);
    virtual void      ApplyForce(const Point& force);
    virtual void      ApplyTorque(const Point& torque);
    virtual void      SetThrust(double t);
    virtual void      SetTransX(double t);
    virtual void      SetTransY(double t);
    virtual void      SetTransZ(double t);
    virtual void      SetHeading(double r, double p, double y);
    virtual void      LookAt(const Point& dst);
    virtual void      ApplyRoll(double roll_acc);
    virtual void      ApplyPitch(double pitch_acc);
    virtual void      ApplyYaw(double yaw_acc);

    virtual int       CollidesWith(Physical& o);
    static  void      ElasticCollision(Physical& a, Physical& b);
    static  void      InelasticCollision(Physical& a, Physical& b);
    static  void      SemiElasticCollision(Physical& a, Physical& b);
    virtual void      InflictDamage(double damage, int type = 0);

    // accessors:
    int               Identity()  const { return id;         }
    int               Type()      const { return obj_type;   }
    const char*       Name()      const { return name;       }

    Point             Location()  const { return cam.Pos();  }
    Point             Heading()   const { return cam.vpn();  }
    Point             LiftLine()  const { return cam.vup();  }
    Point             BeamLine()  const { return cam.vrt();  }
    Point             Velocity()  const { return velocity + arcade_velocity; }
    Point             Acceleration()
    const { return accel;      }
    double            Thrust()    const { return thrust;     }
    double            TransX()    const { return trans_x;    }
    double            TransY()    const { return trans_y;    }
    double            TransZ()    const { return trans_z;    }
    double            Drag()      const { return drag;       }

    double            Roll()      const { return roll;       }
    double            Pitch()     const { return pitch;      }
    double            Yaw()       const { return yaw;        }
    Point             Rotation()  const { return Point(dp,dr,dy); }

    double            Alpha()     const { return alpha;      }

    double            FlightPathYawAngle()    const { return flight_path_yaw;     }
    double            FlightPathPitchAngle()  const { return flight_path_pitch;   }

    double            Radius()    const { return radius;     }
    double            Mass()      const { return mass;       }
    double            Integrity() const { return integrity;  }
    double            Life()      const { return life;       }

    double            Shake()     const { return shake;      }
    const Point&      Vibration() const { return vibration;  }

    const Camera&     Cam()       const { return cam;        }
    Graphic*          Rep()       const { return rep;        }
    Light*            LightSrc()  const { return light;      }

    Director*         GetDirector() const { return dir;      }

    // mutators:
    virtual void      SetAngularRates(double  r, double  p, double  y);
    virtual void      GetAngularRates(double& r, double& p, double& y);
    virtual void      SetAngularDrag(double  r, double  p, double  y);
    virtual void      GetAngularDrag(double& r, double& p, double& y);
    virtual void      GetAngularThrust(double& r, double& p, double& y);
    virtual void      SetVelocity(const Point& v) { velocity = v; }
    virtual void      SetAbsoluteOrientation(double roll, double pitch, double yaw);
    virtual void      CloneCam(const Camera& cam);
    virtual void      SetDrag(double d) { drag = (float) d; }

    virtual void      SetPrimary(const Point& loc, double mass);
    virtual void      SetGravity(double g);
    virtual void      SetBaseDensity(double d);

    virtual double    GetBaseDensity()  const { return Do; }
    virtual double    GetDensity()      const;

    enum { NAMELEN = 48 };

protected:
    static int        id_key;

    // identification:
    int               id;
    int               obj_type;
    char              name[NAMELEN];

    // position, velocity, and acceleration:
    Camera            cam;
    Point             velocity;
    Point             arcade_velocity;
    Point             accel;
    float             thrust;
    float             trans_x;
    float             trans_y;
    float             trans_z;
    float             drag;

    // attitude and angular velocity:
    float             roll,   pitch,  yaw;
    float             dr,     dp,     dy;
    float             dr_acc, dp_acc, dy_acc;
    float             dr_drg, dp_drg, dy_drg;

    float             flight_path_yaw;
    float             flight_path_pitch;

    // gravitation:
    Point             primary_loc;
    double            primary_mass;

    // aerodynamics:
    float             g_accel;    // acceleration due to gravity (constant)
    float             Do;         // atmospheric density at sea level
    float             CL;         // base coefficient of lift
    float             CD;         // base coefficient of drag
    float             alpha;      // current angle of attack (radians)
    float             stall;      // stall angle of attack (radians)
    bool              lat_thrust; // lateral thrusters enabled in aero mode?
    bool              straight;

    // vibration:
    float             shake;
    Point             vibration;

    // scale factors for ApplyXxx():
    float             roll_rate, pitch_rate, yaw_rate;

    // physical properties:
    double            life;
    float             radius;
    float             mass;
    float             integrity;

    // graphic representation:
    Graphic*          rep;
    Light*            light;

    // AI or human controller:
    Director*         dir;        // null implies an autonomous object

    static double sub_frame;
};

// +--------------------------------------------------------------------+

#endif  // Physical_h