share/solid_vary.c

   1 /*
   2  * Copyright (C) 2003 Robert Kooima
   3  *
   4  * NEVERBALL is  free software; you can redistribute  it and/or modify
   5  * it under the  terms of the GNU General  Public License as published
   6  * by the Free  Software Foundation; either version 2  of the License,
   7  * or (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful, but
  10  * WITHOUT  ANY  WARRANTY;  without   even  the  implied  warranty  of
  11  * MERCHANTABILITY or  FITNESS FOR A PARTICULAR PURPOSE.   See the GNU
  12  * General Public License for more details.
  13  */
  14
  15 #include <stdlib.h>
  16
  17 #include "solid_vary.h"
  18 #include "common.h"
  19 #include "vec3.h"
  20
  21 /*---------------------------------------------------------------------------*/
  22
  23 int sol_load_vary(struct s_vary *fp, struct s_base *base)
  24 {
  25     int i;
  26
  27     memset(fp, 0, sizeof (*fp));
  28
  29     fp->base = base;
  30
  31     if (fp->base->pc)
  32     {
  33         fp->pv = calloc(fp->base->pc, sizeof (*fp->pv));
  34         fp->pc = fp->base->pc;
  35
  36         for (i = 0; i < fp->base->pc; i++)
  37         {
  38             struct v_path *pp = fp->pv + i;
  39             struct b_path *pq = fp->base->pv + i;
  40
  41             pp->base = pq;
  42             pp->f    = pq->f;
  43         }
  44     }
  45
  46     if (fp->base->bc)
  47     {
  48         struct alloc mv;
  49
  50         fp->bv = calloc(fp->base->bc, sizeof (*fp->bv));
  51         fp->bc = fp->base->bc;
  52
  53         alloc_new(&mv, sizeof (*fp->mv), (void **) &fp->mv, &fp->mc);
  54
  55         for (i = 0; i < fp->base->bc; i++)
  56         {
  57             struct b_body *bbody = fp->base->bv + i;
  58             struct v_body *vbody = fp->bv + i;
  59             struct v_move *vmove;
  60
  61             vbody->base = bbody;
  62
  63             vbody->mi = -1;
  64             vbody->mj = -1;
  65
  66             if (bbody->pi >= 0 && (vmove = alloc_add(&mv)))
  67             {
  68                 memset(vmove, 0, sizeof (*vmove));
  69
  70                 vbody->mi = fp->mc - 1;
  71                 vmove->pi = bbody->pi;
  72             }
  73
  74             if (bbody->pj == bbody->pi)
  75             {
  76                 vbody->mj = vbody->mi;
  77             }
  78             else if (bbody->pj >= 0 && (vmove = alloc_add(&mv)))
  79             {
  80                 memset(vmove, 0, sizeof (*vmove));
  81
  82                 vbody->mj = fp->mc - 1;
  83                 vmove->pi = bbody->pj;
  84             }
  85         }
  86     }
  87
  88     if (fp->base->hc)
  89     {
  90         fp->hv = calloc(fp->base->hc, sizeof (*fp->hv));
  91         fp->hc = fp->base->hc;
  92
  93         for (i = 0; i < fp->base->hc; i++)
  94         {
  95             struct v_item *hp = fp->hv + i;
  96             struct b_item *hq = fp->base->hv + i;
  97
  98             v_cpy(hp->p, hq->p);
  99
 100             hp->t = hq->t;
 101             hp->n = hq->n;
 102         }
 103     }
 104
 105     if (fp->base->xc)
 106     {
 107         fp->xv = calloc(fp->base->xc, sizeof (*fp->xv));
 108         fp->xc = fp->base->xc;
 109
 110         for (i = 0; i < fp->base->xc; i++)
 111         {
 112             struct v_swch *xp = fp->xv + i;
 113             struct b_swch *xq = fp->base->xv + i;
 114
 115             xp->base = xq;
 116             xp->t    = xq->t;
 117             xp->tm   = xq->tm;
 118             xp->f    = xq->f;
 119         }
 120     }
 121
 122     if (fp->base->uc)
 123     {
 124         fp->uv = calloc(fp->base->uc, sizeof (*fp->uv));
 125         fp->uc = fp->base->uc;
 126
 127         for (i = 0; i < fp->base->uc; i++)
 128         {
 129             struct v_ball *up = fp->uv + i;
 130             struct b_ball *uq = fp->base->uv + i;
 131
 132             v_cpy(up->p, uq->p);
 133
 134             up->r = uq->r;
 135
 136             up->E[0][0] = up->e[0][0] = 1.0f;
 137             up->E[0][1] = up->e[0][1] = 0.0f;
 138             up->E[0][2] = up->e[0][2] = 0.0f;
 139
 140             up->E[1][0] = up->e[1][0] = 0.0f;
 141             up->E[1][1] = up->e[1][1] = 1.0f;
 142             up->E[1][2] = up->e[1][2] = 0.0f;
 143
 144             up->E[2][0] = up->e[2][0] = 0.0f;
 145             up->E[2][1] = up->e[2][1] = 0.0f;
 146             up->E[2][2] = up->e[2][2] = 1.0f;
 147         }
 148     }
 149
 150     return 1;
 151 }
 152
 153 void sol_free_vary(struct s_vary *fp)
 154 {
 155     free(fp->pv);
 156     free(fp->bv);
 157     free(fp->mv);
 158     free(fp->hv);
 159     free(fp->xv);
 160     free(fp->uv);
 161
 162     memset(fp, 0, sizeof (*fp));
 163 }
 164
 165 /*---------------------------------------------------------------------------*/
 166
 167 int sol_vary_cmd(struct s_vary *fp, struct cmd_state *cs, const union cmd *cmd)
 168 {
 169     struct v_ball *up;
 170     int rc = 0;
 171
 172     switch (cmd->type)
 173     {
 174     case CMD_MAKE_BALL:
 175         if ((up = realloc(fp->uv, sizeof (*up) * (fp->uc + 1))))
 176         {
 177             fp->uv = up;
 178             cs->curr_ball = fp->uc;
 179             fp->uc++;
 180             rc = 1;
 181         }
 182         break;
 183
 184     case CMD_CLEAR_BALLS:
 185         free(fp->uv);
 186         fp->uv = NULL;
 187         fp->uc = 0;
 188         break;
 189
 190     default:
 191         break;
 192     }
 193
 194     return rc;
 195 }
 196
 197 /*---------------------------------------------------------------------------*/
 198
 199 #define CURR 0
 200 #define PREV 1
 201
 202 int sol_lerp_cmd(struct s_lerp *fp, struct cmd_state *cs, const union cmd *cmd)
 203 {
 204     struct l_ball (*uv)[2];
 205     struct l_ball *up;
 206
 207     int idx, mi, i;
 208     int rc = 0;
 209
 210     switch (cmd->type)
 211     {
 212     case CMD_MAKE_BALL:
 213         if ((uv = realloc(fp->uv, sizeof (*uv) * (fp->uc + 1))))
 214         {
 215             fp->uv = uv;
 216
 217             /* Update varying state. */
 218
 219             if (sol_vary_cmd(fp->vary, cs, cmd))
 220             {
 221                 fp->uc++;
 222                 rc = 1;
 223             }
 224         }
 225         break;
 226
 227     case CMD_MOVE_PATH:
 228         if ((mi = cmd->movepath.mi) >= 0 && mi < fp->mc)
 229         {
 230             /* Be extra paranoid. */
 231
 232             if ((idx = cmd->movepath.pi) >= 0 && idx < fp->vary->base->pc)
 233                 fp->mv[mi][CURR].pi = idx;
 234         }
 235         break;
 236
 237     case CMD_MOVE_TIME:
 238         if ((mi = cmd->movetime.mi) >= 0 && mi < fp->mc)
 239         {
 240             fp->mv[mi][CURR].t = cmd->movetime.t;
 241         }
 242         break;
 243
 244     case CMD_BODY_PATH:
 245         /* Backward compatibility: update linear mover only. */
 246
 247         if ((idx = cmd->bodypath.bi) >= 0 && idx < fp->vary->bc &&
 248             (mi = fp->vary->bv[idx].mi) >= 0)
 249         {
 250             /* Be EXTRA paranoid. */
 251
 252             if ((idx = cmd->bodypath.pi) >= 0 && idx < fp->vary->base->pc)
 253                 fp->mv[mi][CURR].pi = idx;
 254         }
 255         break;
 256
 257     case CMD_BODY_TIME:
 258         /* Same as CMD_BODY_PATH. */
 259
 260         if ((idx = cmd->bodytime.bi) >= 0 && idx < fp->vary->bc &&
 261             (mi = fp->vary->bv[idx].mi) >= 0)
 262         {
 263             fp->mv[mi][CURR].t = cmd->bodytime.t;
 264         }
 265         break;
 266
 267     case CMD_BALL_RADIUS:
 268         fp->uv[cs->curr_ball][CURR].r = cmd->ballradius.r;
 269         break;
 270
 271     case CMD_CLEAR_BALLS:
 272         free(fp->uv);
 273         fp->uv = NULL;
 274         fp->uc = 0;
 275
 276         sol_vary_cmd(fp->vary, cs, cmd);
 277
 278         break;
 279
 280     case CMD_BALL_POSITION:
 281         up = &fp->uv[cs->curr_ball][CURR];
 282         v_cpy(up->p, cmd->ballpos.p);
 283         break;
 284
 285     case CMD_BALL_BASIS:
 286         up = &fp->uv[cs->curr_ball][CURR];
 287         v_cpy(up->e[0], cmd->ballbasis.e[0]);
 288         v_cpy(up->e[1], cmd->ballbasis.e[1]);
 289         v_crs(up->e[2], up->e[0], up->e[1]);
 290         break;
 291
 292     case CMD_BALL_PEND_BASIS:
 293         up = &fp->uv[cs->curr_ball][CURR];
 294         v_cpy(up->E[0], cmd->ballpendbasis.E[0]);
 295         v_cpy(up->E[1], cmd->ballpendbasis.E[1]);
 296         v_crs(up->E[2], up->E[0], up->E[1]);
 297         break;
 298
 299     case CMD_STEP_SIMULATION:
 300         /*
 301          * Step each mover ahead. This  way we cut down on replay size
 302          * significantly  while  still  keeping  things in  sync  with
 303          * occasional CMD_MOVE_PATH and CMD_MOVE_TIME.
 304          */
 305
 306         for (i = 0; i < fp->mc; i++)
 307         {
 308             struct l_move *mp = &fp->mv[i][CURR];
 309
 310             if (mp->pi >= 0 && fp->vary->pv[mp->pi].f)
 311                 mp->t += cmd->stepsim.dt;
 312         }
 313         break;
 314
 315     default:
 316         break;
 317     }
 318
 319     return rc;
 320 }
 321
 322 void sol_lerp_copy(struct s_lerp *fp)
 323 {
 324     int i;
 325
 326     for (i = 0; i < fp->mc; i++)
 327         fp->mv[i][PREV] = fp->mv[i][CURR];
 328
 329     for (i = 0; i < fp->uc; i++)
 330         fp->uv[i][PREV] = fp->uv[i][CURR];
 331 }
 332
 333 void sol_lerp_apply(struct s_lerp *fp, float a)
 334 {
 335     int i;
 336
 337     for (i = 0; i < fp->mc; i++)
 338     {
 339         if (fp->mv[i][PREV].pi == fp->mv[i][CURR].pi)
 340             fp->vary->mv[i].t = flerp(fp->mv[i][PREV].t, fp->mv[i][CURR].t, a);
 341         else
 342             fp->vary->mv[i].t = fp->mv[i][CURR].t * a;
 343
 344         fp->vary->mv[i].pi = fp->mv[i][CURR].pi;
 345     }
 346
 347     for (i = 0; i < fp->uc; i++)
 348     {
 349         e_lerp(fp->vary->uv[i].e, fp->uv[i][PREV].e, fp->uv[i][CURR].e, a);
 350         v_lerp(fp->vary->uv[i].p, fp->uv[i][PREV].p, fp->uv[i][CURR].p, a);
 351         e_lerp(fp->vary->uv[i].E, fp->uv[i][PREV].E, fp->uv[i][CURR].E, a);
 352
 353         fp->vary->uv[i].r = flerp(fp->uv[i][PREV].r, fp->uv[i][CURR].r, a);
 354     }
 355 }
 356
 357 int sol_load_lerp(struct s_lerp *fp, struct s_vary *vary)
 358 {
 359     int i;
 360
 361     fp->vary = vary;
 362
 363     if (fp->vary->mc)
 364     {
 365         fp->mv = calloc(fp->vary->mc, sizeof (*fp->mv));
 366         fp->mc = fp->vary->mc;
 367
 368         for (i = 0; i < fp->vary->mc; i++)
 369             fp->mv[i][CURR].pi = fp->vary->mv[i].pi;
 370     }
 371
 372     if (fp->vary->uc)
 373     {
 374         fp->uv = calloc(fp->vary->uc, sizeof (*fp->uv));
 375         fp->uc = fp->vary->uc;
 376
 377         for (i = 0; i < fp->vary->uc; i++)
 378         {
 379             e_cpy(fp->uv[i][CURR].e, fp->vary->uv[i].e);
 380             v_cpy(fp->uv[i][CURR].p, fp->vary->uv[i].p);
 381             e_cpy(fp->uv[i][CURR].E, fp->vary->uv[i].E);
 382
 383             fp->uv[i][CURR].r = fp->vary->uv[i].r;
 384         }
 385     }
 386
 387     sol_lerp_copy(fp);
 388
 389     return 1;
 390 }
 391
 392 void sol_free_lerp(struct s_lerp *fp)
 393 {
 394     if (fp->mv) free(fp->mv);
 395     if (fp->uv) free(fp->uv);
 396
 397     memset(fp, 0, sizeof (*fp));
 398 }
 399
 400 /*---------------------------------------------------------------------------*/