vcs.maemo.org Git - neverball/blob - share/solid.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 <SDL.h>
  16 #include <SDL_rwops.h>
  17 #include <SDL_image.h>
  18
  19 #include <stdio.h>
  20 #include <stdlib.h>
  21 #include <string.h>
  22 #include <math.h>
  23
  24 #include "glext.h"
  25 #include "vec3.h"
  26 #include "geom.h" /* Only for height constants! */
  27 #include "base_image.h"
  28 #include "solid.h"
  29 #include "base_config.h"
  30 #include "binary.h"
  31
  32 #define MAGIC 0x4F425251        /* SOL file magic number (should not change). */
  33 #define SOL_VERSION  5          /* SOL file format version (can change).      */
  34
  35 #define LARGE 1.0e+5f
  36
  37 /*---------------------------------------------------------------------------*/
  38
  39 static float erp(float t)
  40 {
  41     return 3.0f * t * t - 2.0f * t * t * t;
  42 }
  43
  44 static float derp(float t)
  45 {
  46     return 6.0f * t     - 6.0f * t * t;
  47 }
  48
  49 static void sol_body_v(float v[3],
  50                        const struct s_file *fp,
  51                        const struct s_body *bp)
  52 {
  53     if (bp->pi >= 0 && fp->pv[bp->pi].f)
  54     {
  55         const struct s_path *pp = fp->pv + bp->pi;
  56         const struct s_path *pq = fp->pv + pp->pi;
  57
  58         v_sub(v, pq->p, pp->p);
  59         v_scl(v, v, 1.0f / pp->t);
  60
  61         v_scl(v, v, derp(bp->t / pp->t));
  62     }
  63     else
  64     {
  65         v[0] = 0.0f;
  66         v[1] = 0.0f;
  67         v[2] = 0.0f;
  68     }
  69 }
  70
  71 void sol_body_p(float p[3],
  72                 const struct s_file *fp,
  73                 const struct s_body *bp)
  74 {
  75     float v[3];
  76
  77     if (bp->pi >= 0)
  78     {
  79         const struct s_path *pp = fp->pv + bp->pi;
  80         const struct s_path *pq = fp->pv + pp->pi;
  81
  82         v_sub(v, pq->p, pp->p);
  83         v_mad(p, pp->p, v, erp(bp->t / pp->t));
  84     }
  85     else
  86     {
  87         p[0] = 0.0f;
  88         p[1] = 0.0f;
  89         p[2] = 0.0f;
  90     }
  91 }
  92
  93 /*---------------------------------------------------------------------------*/
  94
  95 static void sol_load_mtrl(FILE *fin, struct s_mtrl *mp)
  96 {
  97     get_array(fin,  mp->a, 4);
  98     get_array(fin,  mp->d, 4);
  99     get_array(fin,  mp->s, 4);
 100     get_array(fin,  mp->e, 4);
 101     get_array(fin,  mp->h, 1);
 102     get_index(fin, &mp->fl);
 103
 104     fread(mp->f, 1, PATHMAX, fin);
 105 }
 106
 107 static void sol_load_vert(FILE *fin, struct s_vert *vp)
 108 {
 109     get_array(fin,  vp->p, 3);
 110 }
 111
 112 static void sol_load_edge(FILE *fin, struct s_edge *ep)
 113 {
 114     get_index(fin, &ep->vi);
 115     get_index(fin, &ep->vj);
 116 }
 117
 118 static void sol_load_side(FILE *fin, struct s_side *sp)
 119 {
 120     get_array(fin,  sp->n, 3);
 121     get_float(fin, &sp->d);
 122 }
 123
 124 static void sol_load_texc(FILE *fin, struct s_texc *tp)
 125 {
 126     get_array(fin,  tp->u, 2);
 127 }
 128
 129 static void sol_load_geom(FILE *fin, struct s_geom *gp)
 130 {
 131     get_index(fin, &gp->mi);
 132     get_index(fin, &gp->ti);
 133     get_index(fin, &gp->si);
 134     get_index(fin, &gp->vi);
 135     get_index(fin, &gp->tj);
 136     get_index(fin, &gp->sj);
 137     get_index(fin, &gp->vj);
 138     get_index(fin, &gp->tk);
 139     get_index(fin, &gp->sk);
 140     get_index(fin, &gp->vk);
 141 }
 142
 143 static void sol_load_lump(FILE *fin, struct s_lump *lp)
 144 {
 145     get_index(fin, &lp->fl);
 146     get_index(fin, &lp->v0);
 147     get_index(fin, &lp->vc);
 148     get_index(fin, &lp->e0);
 149     get_index(fin, &lp->ec);
 150     get_index(fin, &lp->g0);
 151     get_index(fin, &lp->gc);
 152     get_index(fin, &lp->s0);
 153     get_index(fin, &lp->sc);
 154 }
 155
 156 static void sol_load_node(FILE *fin, struct s_node *np)
 157 {
 158     get_index(fin, &np->si);
 159     get_index(fin, &np->ni);
 160     get_index(fin, &np->nj);
 161     get_index(fin, &np->l0);
 162     get_index(fin, &np->lc);
 163 }
 164
 165 static void sol_load_path(FILE *fin, struct s_path *pp)
 166 {
 167     get_array(fin,  pp->p, 3);
 168     get_float(fin, &pp->t);
 169     get_index(fin, &pp->pi);
 170     get_index(fin, &pp->f);
 171 }
 172
 173 static void sol_load_body(FILE *fin, struct s_body *bp)
 174 {
 175     get_index(fin, &bp->pi);
 176     get_index(fin, &bp->ni);
 177     get_index(fin, &bp->l0);
 178     get_index(fin, &bp->lc);
 179     get_index(fin, &bp->g0);
 180     get_index(fin, &bp->gc);
 181 }
 182
 183 static void sol_load_coin(FILE *fin, struct s_coin *cp)
 184 {
 185     get_array(fin,  cp->p, 3);
 186     get_index(fin, &cp->n);
 187 }
 188
 189 static void sol_load_goal(FILE *fin, struct s_goal *zp)
 190 {
 191     get_array(fin,  zp->p, 3);
 192     get_float(fin, &zp->r);
 193     get_index(fin, &zp->s);
 194     get_index(fin, &zp->c);
 195 }
 196
 197 static void sol_load_swch(FILE *fin, struct s_swch *xp)
 198 {
 199     get_array(fin,  xp->p, 3);
 200     get_float(fin, &xp->r);
 201     get_index(fin, &xp->pi);
 202     get_float(fin, &xp->t0);
 203     get_float(fin, &xp->t);
 204     get_index(fin, &xp->f0);
 205     get_index(fin, &xp->f);
 206     get_index(fin, &xp->i);
 207 }
 208
 209 static void sol_load_bill(FILE *fin, struct s_bill *rp)
 210 {
 211     get_index(fin, &rp->fl);
 212     get_index(fin, &rp->mi);
 213     get_float(fin, &rp->t);
 214     get_float(fin, &rp->d);
 215     get_array(fin,  rp->w,  3);
 216     get_array(fin,  rp->h,  3);
 217     get_array(fin,  rp->rx, 3);
 218     get_array(fin,  rp->ry, 3);
 219     get_array(fin,  rp->rz, 3);
 220 }
 221
 222 static void sol_load_jump(FILE *fin, struct s_jump *jp)
 223 {
 224     get_array(fin,  jp->p, 3);
 225     get_array(fin,  jp->q, 3);
 226     get_float(fin, &jp->r);
 227 }
 228
 229 static void sol_load_ball(FILE *fin, struct s_ball *bp)
 230 {
 231     get_array(fin,  bp->e[0], 3);
 232     get_array(fin,  bp->e[1], 3);
 233     get_array(fin,  bp->e[2], 3);
 234     get_array(fin,  bp->p,    3);
 235     get_float(fin, &bp->r);
 236     get_float(fin, &bp->a);
 237 }
 238
 239 static void sol_load_view(FILE *fin, struct s_view *wp)
 240 {
 241     get_array(fin,  wp->p, 3);
 242     get_array(fin,  wp->q, 3);
 243 }
 244
 245 static int sol_load_file(FILE *fin, struct s_file *fp)
 246 {
 247     int i;
 248     int magic;
 249     int version;
 250
 251     get_index(fin, &magic);
 252     get_index(fin, &version);
 253
 254     if (magic != MAGIC || version != SOL_VERSION)
 255         return 0;
 256
 257     get_index(fin, &fp->mc);
 258     get_index(fin, &fp->vc);
 259     get_index(fin, &fp->ec);
 260     get_index(fin, &fp->sc);
 261     get_index(fin, &fp->tc);
 262     get_index(fin, &fp->gc);
 263     get_index(fin, &fp->lc);
 264     get_index(fin, &fp->nc);
 265     get_index(fin, &fp->pc);
 266     get_index(fin, &fp->bc);
 267     get_index(fin, &fp->cc);
 268     get_index(fin, &fp->zc);
 269     get_index(fin, &fp->jc);
 270     get_index(fin, &fp->xc);
 271     get_index(fin, &fp->rc);
 272     get_index(fin, &fp->uc);
 273     get_index(fin, &fp->wc);
 274     get_index(fin, &fp->ic);
 275     get_index(fin, &fp->ac);
 276
 277     if (fp->mc)
 278         fp->mv = (struct s_mtrl *) calloc(fp->mc, sizeof (struct s_mtrl));
 279     if (fp->vc)
 280         fp->vv = (struct s_vert *) calloc(fp->vc, sizeof (struct s_vert));
 281     if (fp->ec)
 282         fp->ev = (struct s_edge *) calloc(fp->ec, sizeof (struct s_edge));
 283     if (fp->sc)
 284         fp->sv = (struct s_side *) calloc(fp->sc, sizeof (struct s_side));
 285     if (fp->tc)
 286         fp->tv = (struct s_texc *) calloc(fp->tc, sizeof (struct s_texc));
 287     if (fp->gc)
 288         fp->gv = (struct s_geom *) calloc(fp->gc, sizeof (struct s_geom));
 289     if (fp->lc)
 290         fp->lv = (struct s_lump *) calloc(fp->lc, sizeof (struct s_lump));
 291     if (fp->nc)
 292         fp->nv = (struct s_node *) calloc(fp->nc, sizeof (struct s_node));
 293     if (fp->pc)
 294         fp->pv = (struct s_path *) calloc(fp->pc, sizeof (struct s_path));
 295     if (fp->bc)
 296         fp->bv = (struct s_body *) calloc(fp->bc, sizeof (struct s_body));
 297     if (fp->cc)
 298         fp->cv = (struct s_coin *) calloc(fp->cc, sizeof (struct s_coin));
 299     if (fp->zc)
 300         fp->zv = (struct s_goal *) calloc(fp->zc, sizeof (struct s_goal));
 301     if (fp->jc)
 302         fp->jv = (struct s_jump *) calloc(fp->jc, sizeof (struct s_jump));
 303     if (fp->xc)
 304         fp->xv = (struct s_swch *) calloc(fp->xc, sizeof (struct s_swch));
 305     if (fp->rc)
 306         fp->rv = (struct s_bill *) calloc(fp->rc, sizeof (struct s_bill));
 307     if (fp->uc)
 308         fp->uv = (struct s_ball *) calloc(fp->uc, sizeof (struct s_ball));
 309     if (fp->wc)
 310         fp->wv = (struct s_view *) calloc(fp->wc, sizeof (struct s_view));
 311     if (fp->ic)
 312         fp->iv = (int           *) calloc(fp->ic, sizeof (int));
 313     if (fp->ac)
 314         fp->av = (char          *) calloc(fp->ac, sizeof (char));
 315
 316     for (i = 0; i < fp->mc; i++) sol_load_mtrl(fin, fp->mv + i);
 317     for (i = 0; i < fp->vc; i++) sol_load_vert(fin, fp->vv + i);
 318     for (i = 0; i < fp->ec; i++) sol_load_edge(fin, fp->ev + i);
 319     for (i = 0; i < fp->sc; i++) sol_load_side(fin, fp->sv + i);
 320     for (i = 0; i < fp->tc; i++) sol_load_texc(fin, fp->tv + i);
 321     for (i = 0; i < fp->gc; i++) sol_load_geom(fin, fp->gv + i);
 322     for (i = 0; i < fp->lc; i++) sol_load_lump(fin, fp->lv + i);
 323     for (i = 0; i < fp->nc; i++) sol_load_node(fin, fp->nv + i);
 324     for (i = 0; i < fp->pc; i++) sol_load_path(fin, fp->pv + i);
 325     for (i = 0; i < fp->bc; i++) sol_load_body(fin, fp->bv + i);
 326     for (i = 0; i < fp->cc; i++) sol_load_coin(fin, fp->cv + i);
 327     for (i = 0; i < fp->zc; i++) sol_load_goal(fin, fp->zv + i);
 328     for (i = 0; i < fp->jc; i++) sol_load_jump(fin, fp->jv + i);
 329     for (i = 0; i < fp->xc; i++) sol_load_swch(fin, fp->xv + i);
 330     for (i = 0; i < fp->rc; i++) sol_load_bill(fin, fp->rv + i);
 331     for (i = 0; i < fp->uc; i++) sol_load_ball(fin, fp->uv + i);
 332     for (i = 0; i < fp->wc; i++) sol_load_view(fin, fp->wv + i);
 333     for (i = 0; i < fp->ic; i++) get_index(fin, fp->iv + i);
 334
 335     if (fp->ac) fread(fp->av, 1, fp->ac, fin);
 336
 337     return 1;
 338 }
 339
 340 int sol_load_only_file(struct s_file *fp, const char *filename)
 341 {
 342     FILE *fin;
 343     int res = 0;
 344
 345     if ((fin = fopen(filename, FMODE_RB)))
 346     {
 347         res = sol_load_file(fin, fp);
 348         fclose(fin);
 349     }
 350     return res;
 351 }
 352
 353 /*---------------------------------------------------------------------------*/
 354
 355 static void sol_stor_mtrl(FILE *fout, struct s_mtrl *mp)
 356 {
 357     put_array(fout,  mp->a, 4);
 358     put_array(fout,  mp->d, 4);
 359     put_array(fout,  mp->s, 4);
 360     put_array(fout,  mp->e, 4);
 361     put_array(fout,  mp->h, 1);
 362     put_index(fout, &mp->fl);
 363
 364     fwrite(mp->f, 1, PATHMAX, fout);
 365 }
 366
 367 static void sol_stor_vert(FILE *fout, struct s_vert *vp)
 368 {
 369     put_array(fout,  vp->p, 3);
 370 }
 371
 372 static void sol_stor_edge(FILE *fout, struct s_edge *ep)
 373 {
 374     put_index(fout, &ep->vi);
 375     put_index(fout, &ep->vj);
 376 }
 377
 378 static void sol_stor_side(FILE *fout, struct s_side *sp)
 379 {
 380     put_array(fout,  sp->n, 3);
 381     put_float(fout, &sp->d);
 382 }
 383
 384 static void sol_stor_texc(FILE *fout, struct s_texc *tp)
 385 {
 386     put_array(fout,  tp->u, 2);
 387 }
 388
 389 static void sol_stor_geom(FILE *fout, struct s_geom *gp)
 390 {
 391     put_index(fout, &gp->mi);
 392     put_index(fout, &gp->ti);
 393     put_index(fout, &gp->si);
 394     put_index(fout, &gp->vi);
 395     put_index(fout, &gp->tj);
 396     put_index(fout, &gp->sj);
 397     put_index(fout, &gp->vj);
 398     put_index(fout, &gp->tk);
 399     put_index(fout, &gp->sk);
 400     put_index(fout, &gp->vk);
 401 }
 402
 403 static void sol_stor_lump(FILE *fout, struct s_lump *lp)
 404 {
 405     put_index(fout, &lp->fl);
 406     put_index(fout, &lp->v0);
 407     put_index(fout, &lp->vc);
 408     put_index(fout, &lp->e0);
 409     put_index(fout, &lp->ec);
 410     put_index(fout, &lp->g0);
 411     put_index(fout, &lp->gc);
 412     put_index(fout, &lp->s0);
 413     put_index(fout, &lp->sc);
 414 }
 415
 416 static void sol_stor_node(FILE *fout, struct s_node *np)
 417 {
 418     put_index(fout, &np->si);
 419     put_index(fout, &np->ni);
 420     put_index(fout, &np->nj);
 421     put_index(fout, &np->l0);
 422     put_index(fout, &np->lc);
 423 }
 424
 425 static void sol_stor_path(FILE *fout, struct s_path *pp)
 426 {
 427     put_array(fout,  pp->p, 3);
 428     put_float(fout, &pp->t);
 429     put_index(fout, &pp->pi);
 430     put_index(fout, &pp->f);
 431 }
 432
 433 static void sol_stor_body(FILE *fout, struct s_body *bp)
 434 {
 435     put_index(fout, &bp->pi);
 436     put_index(fout, &bp->ni);
 437     put_index(fout, &bp->l0);
 438     put_index(fout, &bp->lc);
 439     put_index(fout, &bp->g0);
 440     put_index(fout, &bp->gc);
 441 }
 442
 443 static void sol_stor_coin(FILE *fout, struct s_coin *cp)
 444 {
 445     put_array(fout,  cp->p, 3);
 446     put_index(fout, &cp->n);
 447 }
 448
 449 static void sol_stor_goal(FILE *fout, struct s_goal *zp)
 450 {
 451     put_array(fout,  zp->p, 3);
 452     put_float(fout, &zp->r);
 453     put_index(fout, &zp->s);
 454     put_index(fout, &zp->c);
 455 }
 456
 457 static void sol_stor_swch(FILE *fout, struct s_swch *xp)
 458 {
 459     put_array(fout,  xp->p, 3);
 460     put_float(fout, &xp->r);
 461     put_index(fout, &xp->pi);
 462     put_float(fout, &xp->t0);
 463     put_float(fout, &xp->t);
 464     put_index(fout, &xp->f0);
 465     put_index(fout, &xp->f);
 466     put_index(fout, &xp->i);
 467 }
 468
 469 static void sol_stor_bill(FILE *fout, struct s_bill *rp)
 470 {
 471     put_index(fout, &rp->fl);
 472     put_index(fout, &rp->mi);
 473     put_float(fout, &rp->t);
 474     put_float(fout, &rp->d);
 475     put_array(fout,  rp->w,  3);
 476     put_array(fout,  rp->h,  3);
 477     put_array(fout,  rp->rx, 3);
 478     put_array(fout,  rp->ry, 3);
 479     put_array(fout,  rp->rz, 3);
 480 }
 481
 482 static void sol_stor_jump(FILE *fout, struct s_jump *jp)
 483 {
 484     put_array(fout,  jp->p, 3);
 485     put_array(fout,  jp->q, 3);
 486     put_float(fout, &jp->r);
 487 }
 488
 489 static void sol_stor_ball(FILE *fout, struct s_ball *bp)
 490 {
 491     put_array(fout,  bp->e[0], 3);
 492     put_array(fout,  bp->e[1], 3);
 493     put_array(fout,  bp->e[2], 3);
 494     put_array(fout,  bp->p,    3);
 495     put_float(fout, &bp->r);
 496     put_float(fout, &bp->a);
 497 }
 498
 499 static void sol_stor_view(FILE *fout, struct s_view *wp)
 500 {
 501     put_array(fout,  wp->p, 3);
 502     put_array(fout,  wp->q, 3);
 503 }
 504
 505 static void sol_stor_file(FILE *fin, struct s_file *fp)
 506 {
 507     int i;
 508     int magic   = MAGIC;
 509     int version = SOL_VERSION;
 510
 511     put_index(fin, &magic);
 512     put_index(fin, &version);
 513
 514     put_index(fin, &fp->mc);
 515     put_index(fin, &fp->vc);
 516     put_index(fin, &fp->ec);
 517     put_index(fin, &fp->sc);
 518     put_index(fin, &fp->tc);
 519     put_index(fin, &fp->gc);
 520     put_index(fin, &fp->lc);
 521     put_index(fin, &fp->nc);
 522     put_index(fin, &fp->pc);
 523     put_index(fin, &fp->bc);
 524     put_index(fin, &fp->cc);
 525     put_index(fin, &fp->zc);
 526     put_index(fin, &fp->jc);
 527     put_index(fin, &fp->xc);
 528     put_index(fin, &fp->rc);
 529     put_index(fin, &fp->uc);
 530     put_index(fin, &fp->wc);
 531     put_index(fin, &fp->ic);
 532     put_index(fin, &fp->ac);
 533
 534     for (i = 0; i < fp->mc; i++) sol_stor_mtrl(fin, fp->mv + i);
 535     for (i = 0; i < fp->vc; i++) sol_stor_vert(fin, fp->vv + i);
 536     for (i = 0; i < fp->ec; i++) sol_stor_edge(fin, fp->ev + i);
 537     for (i = 0; i < fp->sc; i++) sol_stor_side(fin, fp->sv + i);
 538     for (i = 0; i < fp->tc; i++) sol_stor_texc(fin, fp->tv + i);
 539     for (i = 0; i < fp->gc; i++) sol_stor_geom(fin, fp->gv + i);
 540     for (i = 0; i < fp->lc; i++) sol_stor_lump(fin, fp->lv + i);
 541     for (i = 0; i < fp->nc; i++) sol_stor_node(fin, fp->nv + i);
 542     for (i = 0; i < fp->pc; i++) sol_stor_path(fin, fp->pv + i);
 543     for (i = 0; i < fp->bc; i++) sol_stor_body(fin, fp->bv + i);
 544     for (i = 0; i < fp->cc; i++) sol_stor_coin(fin, fp->cv + i);
 545     for (i = 0; i < fp->zc; i++) sol_stor_goal(fin, fp->zv + i);
 546     for (i = 0; i < fp->jc; i++) sol_stor_jump(fin, fp->jv + i);
 547     for (i = 0; i < fp->xc; i++) sol_stor_swch(fin, fp->xv + i);
 548     for (i = 0; i < fp->rc; i++) sol_stor_bill(fin, fp->rv + i);
 549     for (i = 0; i < fp->uc; i++) sol_stor_ball(fin, fp->uv + i);
 550     for (i = 0; i < fp->wc; i++) sol_stor_view(fin, fp->wv + i);
 551     for (i = 0; i < fp->ic; i++) put_index(fin, fp->iv + i);
 552
 553     fwrite(fp->av, 1, fp->ac, fin);
 554 }
 555
 556 /*---------------------------------------------------------------------------*/
 557
 558 int sol_stor(struct s_file *fp, const char *filename)
 559 {
 560     FILE *fout;
 561
 562     if ((fout = fopen(filename, FMODE_WB)))
 563     {
 564         sol_stor_file(fout, fp);
 565         fclose(fout);
 566
 567         return 1;
 568     }
 569     return 0;
 570 }
 571
 572 void sol_free(struct s_file *fp)
 573 {
 574     if (fp->mv) free(fp->mv);
 575     if (fp->vv) free(fp->vv);
 576     if (fp->ev) free(fp->ev);
 577     if (fp->sv) free(fp->sv);
 578     if (fp->tv) free(fp->tv);
 579     if (fp->gv) free(fp->gv);
 580     if (fp->lv) free(fp->lv);
 581     if (fp->nv) free(fp->nv);
 582     if (fp->pv) free(fp->pv);
 583     if (fp->bv) free(fp->bv);
 584     if (fp->cv) free(fp->cv);
 585     if (fp->zv) free(fp->zv);
 586     if (fp->jv) free(fp->jv);
 587     if (fp->xv) free(fp->xv);
 588     if (fp->rv) free(fp->rv);
 589     if (fp->uv) free(fp->uv);
 590     if (fp->wv) free(fp->wv);
 591     if (fp->av) free(fp->av);
 592     if (fp->iv) free(fp->iv);
 593
 594     memset(fp, 0, sizeof (struct s_file));
 595 }
 596
 597 /*---------------------------------------------------------------------------*/
 598 /* Solves (p + v * t) . (p + v * t) == r * r for smallest t.                 */
 599
 600 static float v_sol(const float p[3], const float v[3], float r)
 601 {
 602     float a = v_dot(v, v);
 603     float b = v_dot(v, p) * 2.0f;
 604     float c = v_dot(p, p) - r * r;
 605     float d = b * b - 4.0f * a * c;
 606
 607     if (a == 0.0f) return LARGE;
 608     if (d <  0.0f) return LARGE;
 609
 610     if (d == 0.0f)
 611         return -b * 0.5f / a;
 612     else
 613     {
 614         float t0 = 0.5f * (-b - fsqrtf(d)) / a;
 615         float t1 = 0.5f * (-b + fsqrtf(d)) / a;
 616         float t  = (t0 < t1) ? t0 : t1;
 617
 618         return (t < 0.0f) ? LARGE : t;
 619     }
 620 }
 621
 622 /*---------------------------------------------------------------------------*/
 623
 624 /*
 625  * Compute the  earliest time  and position of  the intersection  of a
 626  * sphere and a vertex.
 627  *
 628  * The sphere has radius R and moves along vector V from point P.  The
 629  * vertex moves  along vector  W from point  Q in a  coordinate system
 630  * based at O.
 631  */
 632 static float v_vert(float Q[3],
 633                     const float o[3],
 634                     const float q[3],
 635                     const float w[3],
 636                     const float p[3],
 637                     const float v[3], float r)
 638 {
 639     float O[3], P[3], V[3];
 640     float t = LARGE;
 641
 642     v_add(O, o, q);
 643     v_sub(P, p, O);
 644     v_sub(V, v, w);
 645
 646     if (v_dot(P, V) < 0.0f)
 647     {
 648         t = v_sol(P, V, r);
 649
 650         if (t < LARGE)
 651             v_mad(Q, O, w, t);
 652     }
 653     return t;
 654 }
 655
 656 /*
 657  * Compute the  earliest time  and position of  the intersection  of a
 658  * sphere and an edge.
 659  *
 660  * The sphere has radius R and moves along vector V from point P.  The
 661  * edge moves along vector W from point Q in a coordinate system based
 662  * at O.  The edge extends along the length of vector U.
 663  */
 664 static float v_edge(float Q[3],
 665                     const float o[3],
 666                     const float q[3],
 667                     const float u[3],
 668                     const float w[3],
 669                     const float p[3],
 670                     const float v[3], float r)
 671 {
 672     float d[3], e[3];
 673     float P[3], V[3];
 674     float du, eu, uu, s, t;
 675
 676     v_sub(d, p, o);
 677     v_sub(d, d, q);
 678     v_sub(e, v, w);
 679
 680     du = v_dot(d, u);
 681     eu = v_dot(e, u);
 682     uu = v_dot(u, u);
 683
 684     v_mad(P, d, u, -du / uu);
 685     v_mad(V, e, u, -eu / uu);
 686
 687     t = v_sol(P, V, r);
 688     s = (du + eu * t) / uu;
 689
 690     if (0.0f < t && t < LARGE && 0.0f < s && s < 1.0f)
 691     {
 692         v_mad(d, o, w, t);
 693         v_mad(e, q, u, s);
 694         v_add(Q, e, d);
 695     }
 696     else
 697         t = LARGE;
 698
 699     return t;
 700 }
 701
 702 /*
 703  * Compute  the earlist  time and  position of  the intersection  of a
 704  * sphere and a plane.
 705  *
 706  * The sphere has radius R and moves along vector V from point P.  The
 707  * plane  oves  along  vector  W.   The  plane has  normal  N  and  is
 708  * positioned at distance D from the origin O along that normal.
 709  */
 710 static float v_side(float Q[3],
 711                     const float o[3],
 712                     const float w[3],
 713                     const float n[3], float d,
 714                     const float p[3],
 715                     const float v[3], float r)
 716 {
 717     float vn = v_dot(v, n);
 718     float wn = v_dot(w, n);
 719     float t  = LARGE;
 720
 721     if (vn - wn <= 0.0f)
 722     {
 723         float on = v_dot(o, n);
 724         float pn = v_dot(p, n);
 725
 726         float u = (r + d + on - pn) / (vn - wn);
 727         float a = (    d + on - pn) / (vn - wn);
 728
 729         if (0.0f <= u)
 730         {
 731             t = u;
 732
 733             v_mad(Q, p, v, +t);
 734             v_mad(Q, Q, n, -r);
 735         }
 736         else if (0.0f <= a)
 737         {
 738             t = 0;
 739
 740             v_mad(Q, p, v, +t);
 741             v_mad(Q, Q, n, -r);
 742         }
 743     }
 744     return t;
 745 }
 746
 747 /*---------------------------------------------------------------------------*/
 748
 749 /*
 750  * Compute the new  linear and angular velocities of  a bouncing ball.
 751  * Q  gives the  position  of the  point  of impact  and  W gives  the
 752  * velocity of the object being impacted.
 753  */
 754 static float sol_bounce(struct s_ball *up,
 755                         const float q[3],
 756                         const float w[3], float dt)
 757 {
 758     const float kb = 1.10f;
 759     const float ke = 0.70f;
 760     const float km = 0.20f;
 761
 762     float n[3], r[3], d[3], u[3], vn, wn, xn, yn;
 763     float *p = up->p;
 764     float *v = up->v;
 765
 766     /* Find the normal of the impact. */
 767
 768     v_sub(r, p, q);
 769     v_sub(d, v, w);
 770     v_nrm(n, r);
 771
 772     /* Find the new angular velocity. */
 773
 774     v_crs(up->w, d, r);
 775     v_scl(up->w, up->w, -1.0f / (up->r * up->r));
 776
 777     /* Find the new linear velocity. */
 778
 779     vn = v_dot(v, n);
 780     wn = v_dot(w, n);
 781     xn = (vn < 0.0f) ? -vn * ke : vn;
 782     yn = (wn > 0.0f) ?  wn * kb : wn;
 783
 784     v_mad(u, w, n, -wn);
 785     v_mad(v, v, n, -vn);
 786     v_mad(v, v, u, +km * dt);
 787     v_mad(v, v, n, xn + yn);
 788
 789     v_mad(p, q, n, up->r);
 790
 791     /* Return the "energy" of the impact, to determine the sound amplitude. */
 792
 793     return fabsf(v_dot(n, d));
 794 }
 795
 796 /*---------------------------------------------------------------------------*/
 797
 798 /*
 799  * Compute the states of all switches after DT seconds have passed.
 800  */
 801 static void sol_swch_step(struct s_file *fp, float dt)
 802 {
 803     int xi;
 804
 805     for (xi = 0; xi < fp->xc; xi++)
 806     {
 807         struct s_swch *xp = fp->xv + xi;
 808
 809         if (xp->t > 0)
 810         {
 811             xp->t -= dt;
 812
 813             if (xp->t <= 0)
 814             {
 815                 int pi = xp->pi;
 816                 int pj = xp->pi;
 817
 818                 do  /* Tortoise and hare cycle traverser. */
 819                 {
 820                     fp->pv[pi].f = xp->f0;
 821                     fp->pv[pj].f = xp->f0;
 822
 823                     pi = fp->pv[pi].pi;
 824                     pj = fp->pv[pj].pi;
 825                     pj = fp->pv[pj].pi;
 826                 }
 827                 while (pi != pj);
 828
 829                 xp->f = xp->f0;
 830             }
 831         }
 832     }
 833 }
 834
 835 /*
 836  * Compute the positions of all bodies after DT seconds have passed.
 837  */
 838 static void sol_body_step(struct s_file *fp, float dt)
 839 {
 840     int i;
 841
 842     for (i = 0; i < fp->bc; i++)
 843     {
 844         struct s_body *bp = fp->bv + i;
 845         struct s_path *pp = fp->pv + bp->pi;
 846
 847         if (bp->pi >= 0 && pp->f)
 848         {
 849             bp->t += dt;
 850
 851             if (bp->t >= pp->t)
 852             {
 853                 bp->t -= pp->t;
 854                 bp->pi = pp->pi;
 855             }
 856         }
 857     }
 858 }
 859
 860 /*
 861  * Compute the positions of all balls after DT seconds have passed.
 862  */
 863 static void sol_ball_step(struct s_file *fp, float dt)
 864 {
 865     int i;
 866
 867     for (i = 0; i < fp->uc; i++)
 868     {
 869         struct s_ball *up = fp->uv + i;
 870
 871         v_mad(up->p, up->p, up->v, dt);
 872
 873         if (v_len(up->w) > 0.0f)
 874         {
 875             float M[16];
 876             float w[3];
 877             float e[3][3];
 878
 879             v_nrm(w, up->w);
 880             m_rot(M, w, v_len(up->w) * dt);
 881
 882             m_vxfm(e[0], M, up->e[0]);
 883             m_vxfm(e[1], M, up->e[1]);
 884             m_vxfm(e[2], M, up->e[2]);
 885
 886             v_crs(up->e[2], e[0], e[1]);
 887             v_crs(up->e[1], e[2], e[0]);
 888             v_crs(up->e[0], e[1], e[2]);
 889
 890             v_nrm(up->e[0], up->e[0]);
 891             v_nrm(up->e[1], up->e[1]);
 892             v_nrm(up->e[2], up->e[2]);
 893         }
 894     }
 895 }
 896
 897 /*---------------------------------------------------------------------------*/
 898
 899 static float sol_test_vert(float dt,
 900                            float T[3],
 901                            const struct s_ball *up,
 902                            const struct s_vert *vp,
 903                            const float o[3],
 904                            const float w[3])
 905 {
 906     return v_vert(T, o, vp->p, w, up->p, up->v, up->r);
 907 }
 908
 909 static float sol_test_edge(float dt,
 910                            float T[3],
 911                            const struct s_ball *up,
 912                            const struct s_file *fp,
 913                            const struct s_edge *ep,
 914                            const float o[3],
 915                            const float w[3])
 916 {
 917     float q[3];
 918     float u[3];
 919
 920     v_cpy(q, fp->vv[ep->vi].p);
 921     v_sub(u, fp->vv[ep->vj].p,
 922           fp->vv[ep->vi].p);
 923
 924     return v_edge(T, o, q, u, w, up->p, up->v, up->r);
 925 }
 926
 927 static float sol_test_side(float dt,
 928                            float T[3],
 929                            const struct s_ball *up,
 930                            const struct s_file *fp,
 931                            const struct s_lump *lp,
 932                            const struct s_side *sp,
 933                            const float o[3],
 934                            const float w[3])
 935 {
 936     float t = v_side(T, o, w, sp->n, sp->d, up->p, up->v, up->r);
 937     int i;
 938
 939     if (t < dt)
 940         for (i = 0; i < lp->sc; i++)
 941         {
 942             const struct s_side *sq = fp->sv + fp->iv[lp->s0 + i];
 943
 944             if (sp != sq &&
 945                 v_dot(T, sq->n) -
 946                 v_dot(o, sq->n) -
 947                 v_dot(w, sq->n) * t > sq->d)
 948                 return LARGE;
 949         }
 950     return t;
 951 }
 952
 953 /*---------------------------------------------------------------------------*/
 954
 955 static float sol_test_fore(float dt,
 956                            const struct s_ball *up,
 957                            const struct s_side *sp,
 958                            const float o[3],
 959                            const float w[3])
 960 {
 961     float q[3];
 962
 963     /* If the ball is not behind the plane, the test passes. */
 964
 965     v_sub(q, up->p, o);
 966
 967     if (v_dot(q, sp->n) - sp->d + up->r >= 0)
 968         return 1;
 969
 970     /* if the ball is behind the plane but will hit before dt, test passes. */
 971     /*
 972       if (v_side(q, o, w, sp->n, sp->d, up->p, up->v, up->r) < dt)
 973       return 1;
 974     */
 975     /* If the ball is behind but moving toward the plane, test passes. */
 976
 977     if (v_dot(up->v, sp->n) > 0)
 978         return 1;
 979
 980
 981     /* Else, test fails. */
 982
 983     return 0;
 984 }
 985
 986 static float sol_test_back(float dt,
 987                            const struct s_ball *up,
 988                            const struct s_side *sp,
 989                            const float o[3],
 990                            const float w[3])
 991 {
 992     float q[3];
 993
 994     /* If the ball is not in front of the plane, the test passes. */
 995
 996     v_sub(q, up->p, o);
 997
 998     if (v_dot(q, sp->n) - sp->d - up->r <= 0)
 999         return 1;
1000
1001     /* if the ball is behind the plane but will hit before dt, test passes. */
1002     /*
1003       if (v_side(q, o, w, sp->n, sp->d, up->p, up->v, up->r) < dt)
1004       return 1;
1005     */
1006     /* If the ball is in front but moving toward the plane, test passes. */
1007
1008     if (v_dot(up->v, sp->n) < 0)
1009         return 1;
1010
1011
1012     /* Else, test fails. */
1013
1014     return 0;
1015 }
1016
1017 /*---------------------------------------------------------------------------*/
1018
1019 static float sol_test_lump(float dt,
1020                            float T[3],
1021                            const struct s_ball *up,
1022                            const struct s_file *fp,
1023                            const struct s_lump *lp,
1024                            const float o[3],
1025                            const float w[3])
1026 {
1027     float U[3] = {0.0f, 0.0f, 0.0f}; /* init value only to avoid gcc warnings */
1028     float u, t = dt;
1029     int i;
1030
1031     /* Short circuit a non-solid lump. */
1032
1033     if (lp->fl & L_DETAIL) return t;
1034
1035     /* Test all verts */
1036
1037     if (up->r > 0.0f)
1038         for (i = 0; i < lp->vc; i++)
1039         {
1040             const struct s_vert *vp = fp->vv + fp->iv[lp->v0 + i];
1041
1042             if ((u = sol_test_vert(t, U, up, vp, o, w)) < t)
1043             {
1044                 v_cpy(T, U);
1045                 t = u;
1046             }
1047         }
1048
1049     /* Test all edges */
1050
1051     if (up->r > 0.0f)
1052         for (i = 0; i < lp->ec; i++)
1053         {
1054             const struct s_edge *ep = fp->ev + fp->iv[lp->e0 + i];
1055
1056             if ((u = sol_test_edge(t, U, up, fp, ep, o, w)) < t)
1057             {
1058                 v_cpy(T, U);
1059                 t = u;
1060             }
1061         }
1062
1063     /* Test all sides */
1064
1065     for (i = 0; i < lp->sc; i++)
1066     {
1067         const struct s_side *sp = fp->sv + fp->iv[lp->s0 + i];
1068
1069         if ((u = sol_test_side(t, U, up, fp, lp, sp, o, w)) < t)
1070         {
1071             v_cpy(T, U);
1072             t = u;
1073         }
1074     }
1075     return t;
1076 }
1077
1078 static float sol_test_node(float dt,
1079                            float T[3],
1080                            const struct s_ball *up,
1081                            const struct s_file *fp,
1082                            const struct s_node *np,
1083                            const float o[3],
1084                            const float w[3])
1085 {
1086     float U[3], u, t = dt;
1087     int i;
1088
1089     /* Test all lumps */
1090
1091     for (i = 0; i < np->lc; i++)
1092     {
1093         const struct s_lump *lp = fp->lv + np->l0 + i;
1094
1095         if ((u = sol_test_lump(t, U, up, fp, lp, o, w)) < t)
1096         {
1097             v_cpy(T, U);
1098             t = u;
1099         }
1100     }
1101
1102     /* Test in front of this node */
1103
1104     if (np->ni >= 0 && sol_test_fore(t, up, fp->sv + np->si, o, w))
1105     {
1106         const struct s_node *nq = fp->nv + np->ni;
1107
1108         if ((u = sol_test_node(t, U, up, fp, nq, o, w)) < t)
1109         {
1110             v_cpy(T, U);
1111             t = u;
1112         }
1113     }
1114
1115     /* Test behind this node */
1116
1117     if (np->nj >= 0 && sol_test_back(t, up, fp->sv + np->si, o, w))
1118     {
1119         const struct s_node *nq = fp->nv + np->nj;
1120
1121         if ((u = sol_test_node(t, U, up, fp, nq, o, w)) < t)
1122         {
1123             v_cpy(T, U);
1124             t = u;
1125         }
1126     }
1127
1128     return t;
1129 }
1130
1131 static float sol_test_body(float dt,
1132                            float T[3], float V[3],
1133                            const struct s_ball *up,
1134                            const struct s_file *fp,
1135                            const struct s_body *bp)
1136 {
1137     float U[3], O[3], W[3], u, t = dt;
1138
1139     const struct s_node *np = fp->nv + bp->ni;
1140
1141     sol_body_p(O, fp, bp);
1142     sol_body_v(W, fp, bp);
1143
1144     if ((u = sol_test_node(t, U, up, fp, np, O, W)) < t)
1145     {
1146         v_cpy(T, U);
1147         v_cpy(V, W);
1148         t = u;
1149     }
1150     return t;
1151 }
1152
1153 static float sol_test_file(float dt,
1154                            float T[3], float V[3],
1155                            const struct s_ball *up,
1156                            const struct s_file *fp)
1157 {
1158     float U[3], W[3], u, t = dt;
1159     int i;
1160
1161     for (i = 0; i < fp->bc; i++)
1162     {
1163         const struct s_body *bp = fp->bv + i;
1164
1165         if ((u = sol_test_body(t, U, W, up, fp, bp)) < t)
1166         {
1167             v_cpy(T, U);
1168             v_cpy(V, W);
1169             t = u;
1170         }
1171     }
1172     return t;
1173 }
1174
1175 /*---------------------------------------------------------------------------*/
1176
1177 /*
1178  * Step the physics forward DT  seconds under the influence of gravity
1179  * vector G.  If the ball gets pinched between two moving solids, this
1180  * loop might not terminate.  It  is better to do something physically
1181  * impossible than  to lock up the game.   So, if we make  more than C
1182  * iterations, punt it.
1183  */
1184
1185 float sol_step(struct s_file *fp, const float *g, float dt, int ui, int *m)
1186 {
1187     float P[3], V[3], v[3], r[3], d, e, nt, b = 0.0f, tt = dt;
1188     int c = 16;
1189
1190     if (ui < fp->uc)
1191     {
1192         struct s_ball *up = fp->uv + ui;
1193
1194         /* If the ball is in contact with a surface, apply friction. */
1195
1196         v_cpy(v, up->v);
1197         v_cpy(up->v, g);
1198
1199         if (m && sol_test_file(tt, P, V, up, fp) < 0.0005f)
1200         {
1201             v_cpy(up->v, v);
1202             v_sub(r, P, up->p);
1203
1204             if ((d = v_dot(r, g) / (v_len(r) * v_len(g))) > 0.999f)
1205             {
1206                 if ((e = (v_len(up->v) - dt)) > 0.0f)
1207                 {
1208                     /* Scale the linear velocity. */
1209
1210                     v_nrm(up->v, up->v);
1211                     v_scl(up->v, up->v, e);
1212
1213                     /* Scale the angular velocity. */
1214
1215                     v_sub(v, V, up->v);
1216                     v_crs(up->w, v, r);
1217                     v_scl(up->w, up->w, -1.0f / (up->r * up->r));
1218                 }
1219                 else
1220                 {
1221                     /* Friction has brought the ball to a stop. */
1222
1223                     up->v[0] = 0.0f;
1224                     up->v[1] = 0.0f;
1225                     up->v[2] = 0.0f;
1226
1227                     (*m)++;
1228                 }
1229             }
1230             else v_mad(up->v, v, g, tt);
1231         }
1232         else v_mad(up->v, v, g, tt);
1233
1234         /* Test for collision. */
1235
1236         while (c > 0 && tt > 0 && tt > (nt = sol_test_file(tt, P, V, up, fp)))
1237         {
1238             sol_body_step(fp, nt);
1239             sol_swch_step(fp, nt);
1240             sol_ball_step(fp, nt);
1241
1242             tt -= nt;
1243
1244             if (b < (d = sol_bounce(up, P, V, nt)))
1245                 b = d;
1246
1247             c--;
1248         }
1249
1250         sol_body_step(fp, tt);
1251         sol_swch_step(fp, tt);
1252         sol_ball_step(fp, tt);
1253     }
1254     return b;
1255 }
1256
1257 /*---------------------------------------------------------------------------*/
1258
1259 int sol_coin_test(struct s_file *fp, float *p, float coin_r)
1260 {
1261     const float *ball_p = fp->uv->p;
1262     const float  ball_r = fp->uv->r;
1263     int ci, n;
1264
1265     for (ci = 0; ci < fp->cc; ci++)
1266     {
1267         float r[3];
1268
1269         r[0] = ball_p[0] - fp->cv[ci].p[0];
1270         r[1] = ball_p[1] - fp->cv[ci].p[1];
1271         r[2] = ball_p[2] - fp->cv[ci].p[2];
1272
1273         if (fp->cv[ci].n > 0 && v_len(r) < ball_r + coin_r)
1274         {
1275             p[0] = fp->cv[ci].p[0];
1276             p[1] = fp->cv[ci].p[1];
1277             p[2] = fp->cv[ci].p[2];
1278
1279             n = fp->cv[ci].n;
1280             fp->cv[ci].n = 0;
1281
1282             return n;
1283         }
1284     }
1285     return 0;
1286 }
1287
1288 struct s_goal *sol_goal_test(struct s_file *fp, float *p, int ui)
1289 {
1290     const float *ball_p = fp->uv[ui].p;
1291     const float  ball_r = fp->uv[ui].r;
1292     int zi;
1293
1294     for (zi = 0; zi < fp->zc; zi++)
1295     {
1296         float r[3];
1297
1298         r[0] = ball_p[0] - fp->zv[zi].p[0];
1299         r[1] = ball_p[2] - fp->zv[zi].p[2];
1300         r[2] = 0;
1301
1302         if (v_len(r) < fp->zv[zi].r * 1.1 - ball_r &&
1303             ball_p[1] > fp->zv[zi].p[1] &&
1304             ball_p[1] < fp->zv[zi].p[1] + GOAL_HEIGHT / 2)
1305         {
1306             p[0] = fp->zv[zi].p[0];
1307             p[1] = fp->zv[zi].p[1];
1308             p[2] = fp->zv[zi].p[2];
1309
1310             return &fp->zv[zi];
1311         }
1312     }
1313     return NULL;
1314 }
1315
1316 int sol_jump_test(struct s_file *fp, float *p, int ui)
1317 /* Test if the ball ui is inside a jump. */
1318 /* Return 1 if yes and fill p with the destination position. */
1319 /* Return 0 if no. */
1320 /* Return 2 if the ball is on the border of a jump. */
1321 {
1322     const float *ball_p = fp->uv[ui].p;
1323     const float  ball_r = fp->uv[ui].r;
1324     int ji;
1325     float l;
1326     int res = 0;
1327
1328     for (ji = 0; ji < fp->jc; ji++)
1329     {
1330         float r[3];
1331
1332         r[0] = ball_p[0] - fp->jv[ji].p[0];
1333         r[1] = ball_p[2] - fp->jv[ji].p[2];
1334         r[2] = 0;
1335
1336         l = v_len(r) - fp->jv[ji].r;
1337         if (l < 0 &&
1338             ball_p[1] > fp->jv[ji].p[1] &&
1339             ball_p[1] < fp->jv[ji].p[1] + JUMP_HEIGHT / 2)
1340         {
1341             if (l < - ball_r )
1342             {
1343                 p[0] = fp->jv[ji].q[0] + (ball_p[0] - fp->jv[ji].p[0]);
1344                 p[1] = fp->jv[ji].q[1] + (ball_p[1] - fp->jv[ji].p[1]);
1345                 p[2] = fp->jv[ji].q[2] + (ball_p[2] - fp->jv[ji].p[2]);
1346
1347                 return 1;
1348             }
1349             else
1350                 res = 2;
1351         }
1352     }
1353     return res;
1354 }
1355
1356 int sol_swch_test(struct s_file *fp, int ui)
1357 /* In the SOL fp, test and process the event the ball ui enters a switch.
1358  * Return 1 if a visible switch is activated, return 0 otherwise (no switch is
1359  * activated or only invisible switchs) */
1360 {
1361     const float *ball_p = fp->uv[ui].p;
1362     const float  ball_r = fp->uv[ui].r;
1363     int xi;
1364     float l;
1365     int res = 0; /* result */
1366
1367     for (xi = 0; xi < fp->xc; xi++)
1368     {
1369         struct s_swch *xp = fp->xv + xi;
1370
1371         if (xp->t0 == 0 || xp->f == xp->f0)
1372         {
1373             float r[3];
1374
1375             r[0] = ball_p[0] - xp->p[0];
1376             r[1] = ball_p[2] - xp->p[2];
1377             r[2] = 0;
1378
1379             l = v_len(r) - xp->r;
1380             if (l < ball_r &&
1381                 ball_p[1] > xp->p[1] &&
1382                 ball_p[1] < xp->p[1] + SWCH_HEIGHT / 2)
1383             {
1384                 if (!xp->e && l < - ball_r)
1385                 {
1386                     int pi = xp->pi;
1387                     int pj = xp->pi;
1388
1389                     /* The ball enter */
1390                     if (xp->t0 == 0)
1391                         xp->e = 1;
1392
1393                     /* Toggle the state, update the path. */
1394
1395                     xp->f = xp->f ? 0 : 1;
1396
1397                     do  /* Tortoise and hare cycle traverser. */
1398                     {
1399                         fp->pv[pi].f = xp->f;
1400                         fp->pv[pj].f = xp->f;
1401
1402                         pi = fp->pv[pi].pi;
1403                         pj = fp->pv[pj].pi;
1404                         pj = fp->pv[pj].pi;
1405                     }
1406                     while (pi != pj);
1407
1408                     /* It toggled to non-default state, start the timer. */
1409
1410                     if (xp->f != xp->f0)
1411                         xp->t  = xp->t0;
1412
1413                     /* If visible, set the result */
1414                     if (!xp->i)
1415                         res = 1;
1416                 }
1417             }
1418             else if (xp->e)
1419                 /* A ball go out */
1420                 xp->e = 0;
1421         }
1422     }
1423     return res;
1424 }
1425
1426 /*---------------------------------------------------------------------------*/
1427
1428 void put_file_state(FILE *fout, struct s_file *fp)
1429 {
1430     /* Write the position and orientation of the ball. */
1431
1432     put_array(fout, fp->uv[0].p,    3);
1433     put_array(fout, fp->uv[0].e[0], 3);
1434     put_array(fout, fp->uv[0].e[1], 3);
1435 }
1436
1437 void get_file_state(FILE *fin, struct s_file *fp)
1438 {
1439     /* Read the position and orientation of the ball. */
1440
1441     get_array(fin, fp->uv[0].p,    3);
1442     get_array(fin, fp->uv[0].e[0], 3);
1443     get_array(fin, fp->uv[0].e[1], 3);
1444
1445     /* Compute the 3rd vector of the ball orientatian basis. */
1446
1447     v_crs(fp->uv[0].e[2], fp->uv[0].e[0], fp->uv[0].e[1]);
1448 }
1449
1450 /*---------------------------------------------------------------------------*/
1451