share/solid_vary.h

   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 #ifndef SOLID_VARY_H
  16 #define SOLID_VARY_H
  17
  18 #include "base_config.h"
  19 #include "solid_base.h"
  20
  21 /*
  22  * Varying solid data.
  23  */
  24
  25 /*---------------------------------------------------------------------------*/
  26
  27 struct v_path
  28 {
  29     const struct b_path *base;
  30
  31     int f;                                     /* enable flag                */
  32 };
  33
  34 struct v_body
  35 {
  36     const struct b_body *base;
  37
  38     int mi;
  39     int mj;
  40 };
  41
  42 struct v_move
  43 {
  44     float t;                                   /* time on current path       */
  45     int   tm;                                  /* milliseconds               */
  46
  47     int pi;
  48 };
  49
  50 struct v_item
  51 {
  52     float p[3];                                /* position                   */
  53     int   t;                                   /* type                       */
  54     int   n;                                   /* value                      */
  55 };
  56
  57 struct v_swch
  58 {
  59     const struct b_swch *base;
  60
  61     float t;                                   /* current timer              */
  62     int   tm;                                  /* milliseconds               */
  63     int   f;                                   /* current state              */
  64     int   e;                                   /* is a ball inside it?       */
  65 };
  66
  67 struct v_ball
  68 {
  69     float e[3][3];                             /* basis of orientation       */
  70     float p[3];                                /* position vector            */
  71     float v[3];                                /* velocity vector            */
  72     float w[3];                                /* angular velocity vector    */
  73     float E[3][3];                             /* basis of pendulum          */
  74     float W[3];                                /* angular pendulum velocity  */
  75     float r;                                   /* radius                     */
  76 };
  77
  78 struct s_vary
  79 {
  80     struct s_base *base;
  81
  82     int pc;
  83     int bc;
  84     int mc;
  85     int hc;
  86     int xc;
  87     int uc;
  88
  89     struct v_path *pv;
  90     struct v_body *bv;
  91     struct v_move *mv;
  92     struct v_item *hv;
  93     struct v_swch *xv;
  94     struct v_ball *uv;
  95
  96     /* Accumulator for tracking time in integer milliseconds. */
  97
  98     float ms_accum;
  99 };
 100
 101 /*---------------------------------------------------------------------------*/
 102
 103 int  sol_load_vary(struct s_vary *, struct s_base *);
 104 void sol_free_vary(struct s_vary *);
 105
 106 /*---------------------------------------------------------------------------*/
 107
 108 /*
 109  * Buffers changes to the varying SOL data for interpolation purposes.
 110  */
 111
 112 struct l_move
 113 {
 114     float t;                                   /* time on current path       */
 115
 116     int pi;
 117 };
 118
 119 struct l_ball
 120 {
 121     float e[3][3];                             /* basis of orientation       */
 122     float p[3];                                /* position vector            */
 123     float E[3][3];                             /* basis of pendulum          */
 124     float r;                                   /* radius                     */
 125 };
 126
 127 struct s_lerp
 128 {
 129     struct s_vary *vary;
 130
 131     int mc;
 132     int uc;
 133
 134     struct l_move (*mv)[2];
 135     struct l_ball (*uv)[2];
 136 };
 137
 138 /*---------------------------------------------------------------------------*/
 139
 140 #include "cmd.h"
 141
 142 int  sol_load_lerp(struct s_lerp *, struct s_vary *);
 143 void sol_free_lerp(struct s_lerp *);
 144
 145 void sol_lerp_copy(struct s_lerp *);
 146 void sol_lerp_apply(struct s_lerp *, float);
 147 int  sol_lerp_cmd(struct s_lerp *, struct cmd_state *, const union cmd *);
 148
 149 /*---------------------------------------------------------------------------*/
 150
 151 #endif