Fix compilation with gmqcc.
[xonotic/xonotic-data.pk3dir.git] / qcsrc / csqcmodellib / interpolate.qc
1 /*
2  * Copyright (c) 2011 Rudolf Polzer
3  *
4  * Permission is hereby granted, free of charge, to any person obtaining a copy
5  * of this software and associated documentation files (the "Software"), to
6  * deal in the Software without restriction, including without limitation the
7  * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
8  * sell copies of the Software, and to permit persons to whom the Software is
9  * furnished to do so, subject to the following conditions:
10  *
11  * The above copyright notice and this permission notice shall be included in
12  * all copies or substantial portions of the Software.
13  *
14  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
15  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
17  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
18  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
19  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
20  * IN THE SOFTWARE.
21  */
22
23 .vector iorigin1, iorigin2;
24 .vector ivelocity1, ivelocity2;
25 .vector iforward1, iforward2;
26 .vector iup1, iup2;
27 .vector ivforward1, ivforward2;
28 .vector ivup1, ivup2;
29 .float itime1, itime2;
30 void InterpolateOrigin_Reset()
31 {
32         self.iflags &= ~IFLAG_INTERNALMASK;
33         self.itime1 = self.itime2 = 0;
34 }
35 void InterpolateOrigin_Note()
36 {
37         float dt;
38         float f0;
39
40         dt = time - self.itime2;
41
42         f0 = self.iflags;
43         if(self.iflags & IFLAG_PREVALID)
44                 self.iflags |= IFLAG_VALID;
45         else
46                 self.iflags |= IFLAG_PREVALID;
47
48         if(self.iflags & IFLAG_ORIGIN)
49         {
50                 self.iorigin1 = self.iorigin2;
51                 self.iorigin2 = self.origin;
52         }
53
54         if(self.iflags & IFLAG_AUTOANGLES)
55                 if(self.iorigin2 != self.iorigin1)
56                         self.angles = vectoangles(self.iorigin2 - self.iorigin1);
57
58         if(self.iflags & IFLAG_AUTOVELOCITY)
59                 if(self.itime2 != self.itime1)
60                         self.velocity = (self.iorigin2 - self.iorigin1) * (1.0 / (self.itime2 - self.itime1));
61
62         if(self.iflags & IFLAG_ANGLES)
63         {
64                 fixedmakevectors(self.angles);
65                 if(f0 & IFLAG_VALID)
66                 {
67                         self.iforward1 = self.iforward2;
68                         self.iup1 = self.iup2;
69                 }
70                 else
71                 {
72                         self.iforward1 = v_forward;
73                         self.iup1 = v_up;
74                 }
75                 self.iforward2 = v_forward;
76                 self.iup2 = v_up;
77         }
78
79         if(self.iflags & IFLAG_V_ANGLE)
80         {
81                 fixedmakevectors(self.v_angle);
82                 if(f0 & IFLAG_VALID)
83                 {
84                         self.ivforward1 = self.ivforward2;
85                         self.ivup1 = self.ivup2;
86                 }
87                 else
88                 {
89                         self.ivforward1 = v_forward;
90                         self.ivup1 = v_up;
91                 }
92                 self.ivforward2 = v_forward;
93                 self.ivup2 = v_up;
94         }
95         else if(self.iflags & IFLAG_V_ANGLE_X)
96         {
97                 self.ivforward1_x = self.ivforward2_x;
98                 self.ivforward2_x = self.v_angle_x;
99         }
100
101         if(self.iflags & IFLAG_VELOCITY)
102         {
103                 self.ivelocity1 = self.ivelocity2;
104                 self.ivelocity2 = self.velocity;
105         }
106
107         if(self.iflags & IFLAG_TELEPORTED)
108         {
109                 self.iflags &= ~IFLAG_TELEPORTED;
110                 self.itime1 = self.itime2 = time; // don't lerp
111         }
112         else if(vlen(self.iorigin2 - self.iorigin1) > 1000)
113         {
114                 self.itime1 = self.itime2 = time; // don't lerp
115         }
116         else if((self.iflags & IFLAG_VELOCITY) && (vlen(self.ivelocity2 - self.ivelocity1) > 1000))
117         {
118                 self.itime1 = self.itime2 = time; // don't lerp
119         }
120         else if(dt >= 0.2)
121         {
122                 self.itime1 = self.itime2 = time;
123         }
124         else
125         {
126                 self.itime1 = serverprevtime;
127                 self.itime2 = time;
128         }
129 }
130 void InterpolateOrigin_Do()
131 {
132         vector forward, up;
133         if(self.itime1 && self.itime2 && self.itime1 != self.itime2)
134         {
135                 float f;
136                 f = bound(0, (time - self.itime1) / (self.itime2 - self.itime1), 1 + autocvar_cl_lerpexcess);
137                 if(self.iflags & IFLAG_ORIGIN)
138                         setorigin(self, (1 - f) * self.iorigin1 + f * self.iorigin2);
139                 if(self.iflags & IFLAG_ANGLES)
140                 {
141                         forward = (1 - f) * self.iforward1 + f * self.iforward2;
142                         up = (1 - f) * self.iup1 + f * self.iup2;
143                         self.angles = fixedvectoangles2(forward, up);
144                 }
145                 if(self.iflags & IFLAG_V_ANGLE)
146                 {
147                         forward = (1 - f) * self.ivforward1 + f * self.ivforward2;
148                         up = (1 - f) * self.ivup1 + f * self.ivup2;
149                         self.v_angle = fixedvectoangles2(forward, up);
150                 }
151                 else if(self.iflags & IFLAG_V_ANGLE_X)
152                         self.v_angle_x = (1 - f) * self.ivforward1_x + f * self.ivforward2_x;
153                 if(self.iflags & IFLAG_VELOCITY)
154                         self.velocity = (1 - f) * self.ivelocity1 + f * self.ivelocity2;
155         }
156 }
157 void InterpolateOrigin_Undo()
158 {
159         if(self.iflags & IFLAG_ORIGIN)
160                 setorigin(self, self.iorigin2);
161         if(self.iflags & IFLAG_ANGLES)
162                 self.angles = fixedvectoangles2(self.iforward2, self.iup2);
163         if(self.iflags & IFLAG_V_ANGLE)
164                 self.v_angle = fixedvectoangles2(self.ivforward2, self.ivup2);
165         else if(self.iflags & IFLAG_V_ANGLE_X)
166                 self.v_angle_x = self.ivforward2_x;
167         if(self.iflags & IFLAG_VELOCITY)
168                 self.velocity = self.ivelocity2;
169 }
170