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