git.mutantstargoat.com Git - andemo/blob - src/demosys.c

   1 #include <stdio.h>
   2 #include <string.h>
   3 #include "demo.h"
   4 #include "demosys.h"
   5 #include "treestore.h"
   6 #include "assfile.h"
   7 #include "rbtree.h"
   8 #include "darray.h"
   9
  10 void regscr_testa(void);
  11 void regscr_testb(void);
  12
  13 static void proc_screen_script(struct demoscreen *scr, struct ts_node *node);
  14 static void proc_track(struct ts_node *node, const char *pname);
  15 static long io_read(void *buf, size_t bytes, void *uptr);
  16
  17
  18 int dsys_init(const char *fname)
  19 {
  20         int i;
  21         struct ts_io io = {0};
  22         struct ts_node *ts, *tsnode;
  23         struct demoscreen *scr;
  24
  25         memset(&dsys, 0, sizeof dsys);
  26         if(!(dsys.trackmap = rb_create(RB_KEY_STRING))) {
  27                 return -1;
  28         }
  29         dsys.track = darr_alloc(0, sizeof *dsys.track);
  30         dsys.value = darr_alloc(0, sizeof *dsys.value);
  31
  32         regscr_testa();
  33         regscr_testb();
  34
  35         for(i=0; i<dsys.num_screens; i++) {
  36                 if(dsys.screens[i]->init() == -1) {
  37                         fprintf(stderr, "failed to initialize demo screen: %s\n", dsys.screens[i]->name);
  38                         return -1;
  39                 }
  40         }
  41
  42         if(!fname || !(io.data = ass_fopen(fname, "rb"))) {
  43                 dsys_run_screen(dsys.screens[0]);
  44                 return 0;
  45         }
  46         io.read = io_read;
  47
  48         if(!(ts = ts_load_io(&io)) || strcmp(ts->name, "demo") != 0) {
  49                 ass_fclose(io.data);
  50                 fprintf(stderr, "failed to read demoscript\n");
  51                 return -1;
  52         }
  53
  54         tsnode = ts->child_list;
  55         while(tsnode) {
  56                 if(strcmp(tsnode->name, "screen") == 0 &&
  57                                 (scr = dsys_find_screen(ts_get_attr_str(tsnode, "name", 0)))) {
  58                         proc_screen_script(scr, tsnode);
  59
  60                 } else if(strcmp(tsnode->name, "track") == 0) {
  61                         proc_track(tsnode, 0);
  62                 }
  63                 tsnode = tsnode->next;
  64         }
  65
  66         ass_fclose(io.data);
  67         return 0;
  68 }
  69
  70 static void proc_screen_script(struct demoscreen *scr, struct ts_node *node)
  71 {
  72         struct ts_node *sub;
  73         struct ts_attr *attr;
  74         long tm;
  75
  76         attr = node->attr_list;
  77         while(attr) {
  78                 if(sscanf(attr->name, "key_%ld", &tm) == 1 && attr->val.type == TS_NUMBER) {
  79                         anm_set_value(&scr->track, tm, attr->val.fnum);
  80                 }
  81                 attr = attr->next;
  82         }
  83
  84         sub = node->child_list;
  85         while(sub) {
  86                 if(strcmp(sub->name, "track") == 0) {
  87                         proc_track(sub, scr->name);
  88                 }
  89                 sub = sub->next;
  90         }
  91 }
  92
  93 static void proc_track(struct ts_node *node, const char *pname)
  94 {
  95         char *name, *buf;
  96         struct ts_attr *attr;
  97         long tm;
  98         int tidx;
  99         struct anm_track *trk;
 100
 101         if(!(name = (char*)ts_get_attr_str(node, "name", 0))) {
 102                 return;
 103         }
 104         if(pname) {
 105                 buf = alloca(strlen(name) + strlen(pname) + 2);
 106                 sprintf(buf, "%s.%s", pname, name);
 107                 name = buf;
 108         }
 109
 110         if((tidx = dsys_add_track(name)) == -1) {
 111                 return;
 112         }
 113         trk = dsys.track + tidx;
 114
 115         attr = node->attr_list;
 116         while(attr) {
 117                 if(sscanf(attr->name, "key_%ld", &tm) == 1 && attr->val.type == TS_NUMBER) {
 118                         anm_set_value(trk, tm, attr->val.fnum);
 119                 }
 120                 attr = attr->next;
 121         }
 122 }
 123
 124 static long io_read(void *buf, size_t bytes, void *uptr)
 125 {
 126         return ass_fread(buf, 1, bytes, uptr);
 127 }
 128
 129
 130 void dsys_destroy(void)
 131 {
 132         int i;
 133
 134         for(i=0; i<dsys.num_screens; i++) {
 135                 anm_destroy_track(&dsys.screens[i]->track);
 136                 if(dsys.screens[i]->destroy) {
 137                         dsys.screens[i]->destroy();
 138                 }
 139         }
 140         dsys.num_screens = 0;
 141
 142         darr_free(dsys.track);
 143         darr_free(dsys.value);
 144         rb_free(dsys.trackmap);
 145 }
 146
 147 void dsys_update(void)
 148 {
 149         int i, j, sort_needed = 0;
 150         struct demoscreen *scr;
 151
 152         dsys.tmsec = time_msec;
 153
 154         dsys.num_act = 0;
 155         for(i=0; i<dsys.num_screens; i++) {
 156                 scr = dsys.screens[i];
 157                 scr->vis = anm_get_value(&scr->track, dsys.tmsec);
 158
 159                 if(scr->vis > 0.0f) {
 160                         if(!scr->active) {
 161                                 if(scr->start) scr->start();
 162                                 scr->active = 1;
 163                         }
 164                         if(scr->update) scr->update(dsys.tmsec);
 165
 166                         if(dsys.num_act && scr->prio != dsys.act[dsys.num_act - 1]->prio) {
 167                                 sort_needed = 1;
 168                         }
 169                         dsys.act[dsys.num_act++] = scr;
 170                 } else {
 171                         if(scr->active) {
 172                                 if(scr->stop) scr->stop();
 173                                 scr->active = 0;
 174                         }
 175                 }
 176         }
 177
 178         if(sort_needed) {
 179                 for(i=0; i<dsys.num_act; i++) {
 180                         for(j=i+1; j<dsys.num_act; j++) {
 181                                 if(dsys.act[j]->prio > dsys.act[j - 1]->prio) {
 182                                         void *tmp = dsys.act[j];
 183                                         dsys.act[j] = dsys.act[j - 1];
 184                                         dsys.act[j - 1] = tmp;
 185                                 }
 186                         }
 187                 }
 188         }
 189
 190         /* evaluate tracks */
 191         for(i=0; i<dsys.num_tracks; i++) {
 192                 dsys.value[i] = anm_get_value(dsys.track + i, dsys.tmsec);
 193         }
 194 }
 195
 196 /* TODO: do something about draw ordering of the active screens */
 197 void dsys_draw(void)
 198 {
 199         int i;
 200         for(i=0; i<dsys.num_act; i++) {
 201                 dsys.act[i]->draw();
 202         }
 203 }
 204
 205 void dsys_run(void)
 206 {
 207 }
 208
 209 void dsys_stop(void)
 210 {
 211 }
 212
 213 void dsys_seek_abs(long tm)
 214 {
 215 }
 216
 217 void dsys_seek_rel(long dt)
 218 {
 219 }
 220
 221 void dsys_seek_norm(float t)
 222 {
 223 }
 224
 225
 226 struct demoscreen *dsys_find_screen(const char *name)
 227 {
 228         int i;
 229
 230         if(!name) return 0;
 231
 232         for(i=0; i<dsys.num_screens; i++) {
 233                 if(strcmp(dsys.screens[i]->name, name) == 0) {
 234                         return dsys.screens[i];
 235                 }
 236         }
 237         return 0;
 238 }
 239
 240 void dsys_run_screen(struct demoscreen *scr)
 241 {
 242         int i;
 243
 244         if(!scr) return;
 245         if(dsys.num_act == 1 && dsys.act[0] == scr) return;
 246
 247         for(i=0; i<dsys.num_act; i++) {
 248                 if(dsys.act[i]->stop) dsys.act[i]->stop();
 249                 dsys.act[i]->active = 0;
 250         }
 251
 252         dsys.act[0] = scr;
 253         dsys.num_act = 1;
 254
 255         if(scr->start) scr->start();
 256         scr->active = 1;
 257 }
 258
 259
 260 int dsys_add_screen(struct demoscreen *scr)
 261 {
 262         if(!scr->name || !scr->init || !scr->draw) {
 263                 fprintf(stderr, "dsys_add_screen: invalid screen\n");
 264                 return -1;
 265         }
 266         if(anm_init_track(&scr->track) == -1) {
 267                 fprintf(stderr, "dsys_add_screen: failed to initialize keyframe track\n");
 268                 return -1;
 269         }
 270         anm_set_track_interpolator(&scr->track, ANM_INTERP_LINEAR);
 271         anm_set_track_extrapolator(&scr->track, ANM_EXTRAP_CLAMP);
 272         anm_set_track_default(&scr->track, 0);
 273
 274         dsys.screens[dsys.num_screens++] = scr;
 275         return 0;
 276 }
 277
 278 int dsys_add_track(const char *name)
 279 {
 280         struct anm_track trk;
 281         int idx;
 282
 283         if(rb_find(dsys.trackmap, (char*)name)) {
 284                 fprintf(stderr, "ignoring duplicate track: %s\n", name);
 285                 return -1;
 286         }
 287
 288         idx = darr_size(dsys.track);
 289         darr_push(dsys.track, &trk);
 290         darr_pushf(dsys.value, 0);
 291
 292         anm_init_track(dsys.track + idx);
 293
 294         if(rb_insert(dsys.trackmap, (char*)name, (void*)(intptr_t)idx) == -1) {
 295                 fprintf(stderr, "failed to insert to track map: %s\n", name);
 296                 abort();
 297         }
 298         dsys.num_tracks = idx + 1;
 299         return idx;
 300 }
 301
 302 int dsys_find_track(const char *name)
 303 {
 304         struct rbnode *n = rb_find(dsys.trackmap, (char*)name);
 305         if(!n) return -1;
 306
 307         return (intptr_t)n->data;
 308 }
 309
 310 float dsys_value(const char *name)
 311 {
 312         int idx = dsys_find_track(name);
 313         return idx == -1 ? 0.0f : dsys.value[idx];
 314 }