BRL-CAD
db_anim.c
Go to the documentation of this file.
1 /* D B _ A N I M . C
2  * BRL-CAD
3  *
4  * Copyright (c) 1987-2014 United States Government as represented by
5  * the U.S. Army Research Laboratory.
6  *
7  * This library is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public License
9  * version 2.1 as published by the Free Software Foundation.
10  *
11  * This library is distributed in the hope that it will be useful, but
12  * WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with this file; see the file named COPYING for more
18  * information.
19  */
20 /** @addtogroup dbio */
21 /** @{ */
22 /** @file librt/db_anim.c
23  *
24  * Routines to apply animation directives to geometry database.
25  *
26  */
27 
28 #include "common.h"
29 
30 #include <stdlib.h>
31 #include <string.h>
32 #include <math.h>
33 #include "bio.h"
34 
35 #include "vmath.h"
36 
37 #include "raytrace.h"
38 
39 int
40 db_add_anim(struct db_i *dbip, register struct animate *anp, int root)
41 {
42  register struct animate **headp;
43  struct directory *dp;
44 
45  /* Could validate an_type here */
46 
47  RT_CK_ANIMATE(anp);
48  anp->an_forw = ANIM_NULL;
49  if (root) {
51  bu_log("db_add_anim(%p) root\n", (void *)anp);
52 
53  if (!dbip)
54  bu_bomb("Unexpected NULL dbip encountered in db_add_anim\n");
55 
56  headp = &(dbip->dbi_anroot);
57  } else {
58  dp = DB_FULL_PATH_CUR_DIR(&anp->an_path);
59  if (!dp)
60  return 1;
62  bu_log("db_add_anim(%p) arc %s\n", (void *)anp,
63  dp->d_namep);
64  headp = &(dp->d_animate);
65  }
66 
67  /* Append to list */
68  while (*headp != ANIM_NULL) {
69  RT_CK_ANIMATE(*headp);
70  headp = &((*headp)->an_forw);
71  }
72  *headp = anp;
73  return 0; /* OK */
74 }
75 
76 
77 static char *db_anim_matrix_strings[] = {
78  "(nope)",
79  "ANM_RSTACK",
80  "ANM_RARC",
81  "ANM_LMUL",
82  "ANM_RMUL",
83  "ANM_RBOTH",
84  "eh?"
85 };
86 
87 
88 int
89 db_do_anim(register struct animate *anp, mat_t stack, mat_t arc, struct mater_info *materp)
90 {
91  mat_t temp;
92 
94  bu_log("db_do_anim(%p) ", (void *)anp);
95  if (RT_G_DEBUG&DEBUG_ANIM && !materp) bu_log("(null materp) ");
96  RT_CK_ANIMATE(anp);
97  switch (anp->an_type) {
98  case RT_AN_MATRIX:
99  if (RT_G_DEBUG&DEBUG_ANIM) {
100  int op = anp->an_u.anu_m.anm_op;
101  if (op < 0) op = 0;
102  bu_log("matrix, op=%s (%d)\n",
103  db_anim_matrix_strings[op], op);
105  bn_mat_print("on original arc", arc);
106  bn_mat_print("on original stack", stack);
107  }
108  }
109  switch (anp->an_u.anu_m.anm_op) {
110  case ANM_RSTACK:
111  MAT_COPY(stack, anp->an_u.anu_m.anm_mat);
112  break;
113  case ANM_RARC:
114  MAT_COPY(arc, anp->an_u.anu_m.anm_mat);
115  break;
116  case ANM_RBOTH:
117  MAT_COPY(stack, anp->an_u.anu_m.anm_mat);
118  MAT_IDN(arc);
119  break;
120  case ANM_LMUL:
121  /* arc = DELTA * arc */
122  bn_mat_mul(temp, anp->an_u.anu_m.anm_mat, arc);
123  MAT_COPY(arc, temp);
124  break;
125  case ANM_RMUL:
126  /* arc = arc * DELTA */
127  bn_mat_mul(temp, arc, anp->an_u.anu_m.anm_mat);
128  MAT_COPY(arc, temp);
129  break;
130  default:
131  return -1; /* BAD */
132  }
134  bn_mat_print("arc result", arc);
135  bn_mat_print("stack result", stack);
136  }
137  break;
138  case RT_AN_MATERIAL:
139  if (RT_G_DEBUG&DEBUG_ANIM)
140  bu_log("property\n");
141  /*
142  * if the caller does not care about property, a null
143  * mater pointer is given.
144  */
145  if (!materp) {
146  char *sofar = db_path_to_string(&anp->an_path);
147  bu_log("ERROR db_do_anim(%s) property animation below region, ignored\n", sofar);
148  bu_free(sofar, "path string");
149  break;
150  }
151  if (anp->an_u.anu_p.anp_op == RT_ANP_REPLACE) {
152  if (materp->ma_shader) bu_free((void *)materp->ma_shader, "ma_shader");
153  materp->ma_shader = bu_vls_strdup(&anp->an_u.anu_p.anp_shader);
154  } else if (anp->an_u.anu_p.anp_op == RT_ANP_APPEND) {
155  struct bu_vls str = BU_VLS_INIT_ZERO;
156 
157  bu_vls_strcpy(&str, materp->ma_shader);
158  bu_vls_putc(&str, ' ');
159  bu_vls_vlscat(&str, &anp->an_u.anu_p.anp_shader);
160  if (materp->ma_shader) bu_free((void *)materp->ma_shader, "ma_shader");
161  materp->ma_shader = bu_vls_strgrab(&str);
162  /* bu_vls_free(&str) is done by bu_vls_strgrab() */
163  } else
164  bu_log("Unknown anp_op=%d\n", anp->an_u.anu_p.anp_op);
165  break;
166  case RT_AN_COLOR:
167  if (RT_G_DEBUG&DEBUG_ANIM)
168  bu_log("color\n");
169  /*
170  * if the caller does not care about property, a null
171  * mater pointer is given.
172  */
173  if (!materp) {
174  char *sofar = db_path_to_string(&anp->an_path);
175  bu_log("ERROR db_do_anim(%s) color animation below region, ignored\n", sofar);
176  bu_free(sofar, "path string");
177  break;
178  }
179  materp->ma_color_valid = 1; /* XXX - really override? */
180  materp->ma_color[0] =
181  (((float)anp->an_u.anu_c.anc_rgb[0])+0.5) / 255.0;
182  materp->ma_color[1] =
183  (((float)anp->an_u.anu_c.anc_rgb[1])+0.5) / 255.0;
184  materp->ma_color[2] =
185  (((float)anp->an_u.anu_c.anc_rgb[2])+0.5) / 255.0;
186  break;
187  case RT_AN_TEMPERATURE:
188  if (RT_G_DEBUG&DEBUG_ANIM)
189  bu_log("temperature = %g\n", anp->an_u.anu_t);
190  if (!materp) {
191  char *sofar = db_path_to_string(&anp->an_path);
192  bu_log("ERROR db_do_anim(%s) temperature animation below region, ignored\n", sofar);
193  bu_free(sofar, "path string");
194  break;
195  }
196  materp->ma_temperature = anp->an_u.anu_t;
197  break;
198  default:
199  if (RT_G_DEBUG&DEBUG_ANIM)
200  bu_log("unknown op\n");
201  /* Print something here? */
202  return -1; /* BAD */
203  }
204  return 0; /* OK */
205 }
206 
207 void
208 db_free_1anim(struct animate *anp)
209 {
210  RT_CK_ANIMATE(anp);
211 
212  switch (anp->an_type) {
213  case RT_AN_MATERIAL:
215  break;
216  }
217 
218  db_free_full_path(&anp->an_path);
219  bu_free((char *)anp, "animate");
220 }
221 
222 void
223 db_free_anim(struct db_i *dbip)
224 {
225  register struct animate *anp;
226  register struct directory *dp;
227  register int i;
228 
229  if (!dbip)
230  return;
231 
232  /* Rooted animations */
233  for (anp = dbip->dbi_anroot; anp != ANIM_NULL;) {
234  register struct animate *nextanp;
235  RT_CK_ANIMATE(anp);
236  nextanp = anp->an_forw;
237 
238  db_free_1anim(anp);
239  anp = nextanp;
240  }
241  dbip->dbi_anroot = ANIM_NULL;
242 
243  /* Node animations */
244  for (i=0; i < RT_DBNHASH; i++) {
245  dp = dbip->dbi_Head[i];
246  for (; dp != RT_DIR_NULL; dp = dp->d_forw) {
247  for (anp = dp->d_animate; anp != ANIM_NULL;) {
248  register struct animate *nextanp;
249  RT_CK_ANIMATE(anp);
250  nextanp = anp->an_forw;
251 
252  db_free_1anim(anp);
253  anp = nextanp;
254  }
255  dp->d_animate = ANIM_NULL;
256  }
257  }
258 }
259 
260 
261 struct animate *
262 db_parse_1anim(struct db_i *dbip, int argc, const char *argv[])
263 {
264  struct db_tree_state ts;
265  struct animate *anp;
266  int i;
267 
268  if (!dbip)
269  return NULL;
270 
271  if (argc < 4) {
272  bu_log("db_parse_1anim: not enough arguments\n");
273  return (struct animate *)NULL;
274  }
275 
276  BU_ALLOC(anp, struct animate);
277  anp->magic = ANIMATE_MAGIC;
278 
280  db_full_path_init(&anp->an_path);
281  if (db_follow_path_for_state(&ts, &(anp->an_path), argv[1], LOOKUP_NOISY) < 0)
282  goto bad;
283 
284  if (BU_STR_EQUAL(argv[2], "matrix")) {
285  if (argc < 5) {
286  bu_log("db_parse_1anim: matrix does not have enough arguments\n");
287  goto bad;
288  }
289 
290  anp->an_type = RT_AN_MATRIX;
291  if (BU_STR_EQUAL(argv[3], "rstack"))
292  anp->an_u.anu_m.anm_op = ANM_RSTACK;
293  else if (BU_STR_EQUAL(argv[3], "rarc"))
294  anp->an_u.anu_m.anm_op = ANM_RARC;
295  else if (BU_STR_EQUAL(argv[3], "lmul"))
296  anp->an_u.anu_m.anm_op = ANM_LMUL;
297  else if (BU_STR_EQUAL(argv[3], "rmul"))
298  anp->an_u.anu_m.anm_op = ANM_RMUL;
299  else if (BU_STR_EQUAL(argv[3], "rboth"))
300  anp->an_u.anu_m.anm_op = ANM_RBOTH;
301  else {
302  bu_log("db_parse_1anim: Matrix op '%s' unknown\n",
303  argv[3]);
304  goto bad;
305  }
306 
307  /* Allow some shorthands for the matrix spec */
308  if (BU_STR_EQUAL(argv[4], "translate") ||
309  BU_STR_EQUAL(argv[4], "xlate")) {
310  if (argc < 5+3) {
311  bu_log("db_parse_1anim: matrix %s translate does not have enough arguments, only %d\n",
312  argv[3], argc);
313  goto bad;
314  }
315  MAT_IDN(anp->an_u.anu_m.anm_mat);
316  MAT_DELTAS(anp->an_u.anu_m.anm_mat,
317  atof(argv[5+0]),
318  atof(argv[5+1]),
319  atof(argv[5+2]));
320  } else if (BU_STR_EQUAL(argv[4], "rot")) {
321  if (argc < 5+3) {
322  bu_log("db_parse_1anim: matrix %s rot does not have enough arguments, only %d\n",
323  argv[3], argc);
324  goto bad;
325  }
326  MAT_IDN(anp->an_u.anu_m.anm_mat);
328  atof(argv[5+0]),
329  atof(argv[5+1]),
330  atof(argv[5+2]));
331  } else if (BU_STR_EQUAL(argv[4], "scale")) {
332  fastf_t scale;
333  if (argc < 6) {
334  bu_log("db_parse_1anim: matrix %s scale does not have enough arguments, only %d\n",
335  argv[3], argc);
336  goto bad;
337  }
338  scale = atof(argv[5]);
339  if (ZERO(scale)) {
340  bu_log("db_parse_1anim: matrix %s scale factor is zero\n",
341  argv[3]);
342  goto bad;
343  }
344  MAT_IDN(anp->an_u.anu_m.anm_mat);
345  anp->an_u.anu_m.anm_mat[15] = 1/scale;
346  } else if (BU_STR_EQUAL(argv[4], "scale_about")) {
347  point_t pt;
348  fastf_t scale;
349  if (argc < 5+4) {
350  bu_log("db_parse_1anim: matrix %s scale_about does not have enough arguments, only %d\n",
351  argv[3], argc);
352  goto bad;
353  }
354  VSET(pt,
355  atof(argv[5+0]),
356  atof(argv[5+1]),
357  atof(argv[5+2]));
358  scale = atof(argv[5+3]);
360  pt, scale) < 0) {
361  bu_log("db_parse_1anim: matrix %s scale_about (%g, %g, %g) scale=%g failed\n",
362  argv[3], V3ARGS(pt), scale);
363  goto bad;
364  }
365  } else {
366  if (argc < 20) {
367  bu_log("db_parse_1anim: matrix %s does not have enough arguments, only %d\n",
368  argv[3], argc);
369  goto bad;
370  }
371 
372  /* No keyword, assume full 4x4 matrix */
373  for (i=0; i<16; i++)
374  anp->an_u.anu_m.anm_mat[i] = atof(argv[i+4]);
375  }
376  } else if (BU_STR_EQUAL(argv[2], "material")) {
377  if (argc < 5) {
378  bu_log("db_parse_1anim: material does not have enough arguments, only %d\n", argc);
379  goto bad;
380  }
381 
382  anp->an_type = RT_AN_MATERIAL;
384  if ((BU_STR_EQUAL(argv[3], "replace")) ||
385  (BU_STR_EQUAL(argv[3], "rboth"))) {
387  argc-4, (const char **)&argv[4]);
389  } else if (BU_STR_EQUAL(argv[3], "append")) {
391  argc-4, (const char **)&argv[4]);
393  } else {
394  bu_log("db_parse_1anim: material animation '%s' unknown\n",
395  argv[3]);
396  goto bad;
397  }
398  } else if (BU_STR_EQUAL(argv[2], "color")) {
399  if (argc < 6) {
400  bu_log("db_parse_1anim: color does not have enough arguments, only %d\n", argc);
401  goto bad;
402  }
403 
404  anp->an_type = RT_AN_COLOR;
405  anp->an_u.anu_c.anc_rgb[0] = atoi(argv[3+0]);
406  anp->an_u.anu_c.anc_rgb[1] = atoi(argv[3+1]);
407  anp->an_u.anu_c.anc_rgb[2] = atoi(argv[3+2]);
408  } else if (BU_STR_EQUAL(argv[2], "temperature") ||
409  BU_STR_EQUAL(argv[2], "temp")) {
410  anp->an_type = RT_AN_TEMPERATURE;
411  anp->an_u.anu_t = atof(argv[3]);
412  } else {
413  bu_log("db_parse_1anim: animation type '%s' unknown\n", argv[2]);
414  goto bad;
415  }
417  return anp;
418 bad:
420  db_free_1anim(anp); /* Does db_free_full_path() for us */
421  return (struct animate *)NULL;
422 }
423 
424 int db_parse_anim(struct db_i *dbip,
425  int argc,
426  const char **argv)
427 {
428  struct animate *anp;
429  int at_root = 0;
430 
431  anp = db_parse_1anim(dbip, argc, argv);
432  if (!anp)
433  return -1; /* BAD */
434 
435  if (argv[1][0] == '/')
436  at_root = 1;
437 
438  if (anp->an_path.fp_len > 1)
439  at_root = 0;
440 
441  if (db_add_anim(dbip, anp, at_root) < 0) {
442  return -1; /* BAD */
443  }
444  return 0; /* OK */
445 }
446 void
447 db_write_anim(FILE *fop, struct animate *anp)
448 {
449  char *thepath;
450  int i;
451 
452  if (!fop)
453  return;
454 
455  RT_CK_ANIMATE(anp);
456 
457  thepath = db_path_to_string(&(anp->an_path));
458  if (RT_G_DEBUG&DEBUG_ANIM) {
459  bu_log("db_write_anim: Writing %s\n", thepath);
460  }
461 
462  fprintf(fop, "anim %s ", thepath);
463  bu_free(thepath, "path string");
464 
465  switch (anp->an_type) {
466  case RT_AN_MATRIX:
467  fputs("matrix ", fop);
468  switch (anp->an_u.anu_m.anm_op) {
469  case ANM_RSTACK:
470  fputs("rstack\n", fop);
471  break;
472  case ANM_RARC:
473  fputs("rarc\n", fop);
474  break;
475  case ANM_LMUL:
476  fputs("lmul\n", fop);
477  break;
478  case ANM_RMUL:
479  fputs("rmul\n", fop);
480  break;
481  case ANM_RBOTH:
482  fputs("rboth\n", fop);
483  break;
484  default:
485  fputs("unknown\n", fop);
486  bu_log("db_write_anim: unknown matrix operation\n");
487  }
488  for (i=0; i<16; i++) {
489  fprintf(fop, " %.15e", anp->an_u.anu_m.anm_mat[i]);
490  if ((i == 15) || ((i&3) == 3)) {
491  fputs("\n", fop);
492  }
493  }
494  break;
495  case RT_AN_MATERIAL:
496  fputs("material ", fop);
497  switch (anp->an_u.anu_p.anp_op) {
498  case RT_ANP_REPLACE:
499  fputs("replace ", fop);
500  break;
501  case RT_ANP_APPEND:
502  fputs("append ", fop);
503  break;
504  default:
505  bu_log("db_write_anim: unknown property operation.\n");
506  break;
507  }
508  break;
509  case RT_AN_COLOR:
510  fprintf(fop, "color %d %d %d", anp->an_u.anu_c.anc_rgb[0],
511  anp->an_u.anu_c.anc_rgb[1], anp->an_u.anu_c.anc_rgb[2]);
512  break;
513  case RT_AN_SOLID:
514  break;
515  default:
516  bu_log("db_write_anim: Unknown animate type.\n");
517  }
518  fputs(";\n", fop);
519  return;
520 }
521 
522 
523 /** @} */
524 /*
525  * Local Variables:
526  * mode: C
527  * tab-width: 8
528  * indent-tabs-mode: t
529  * c-file-style: "stroustrup"
530  * End:
531  * ex: shiftwidth=4 tabstop=8
532  */
#define ANM_RARC
Replace arc matrix.
Definition: raytrace.h:1317
int an_type
AN_MATRIX, AN_COLOR...
Definition: raytrace.h:1340
void bu_vls_init(struct bu_vls *vp)
Definition: vls.c:56
char * d_namep
pointer to name string
Definition: raytrace.h:859
Definition: raytrace.h:800
void bu_log(const char *,...) _BU_ATTR_PRINTF12
Definition: log.c:176
struct bu_vls anp_shader
Update string.
Definition: raytrace.h:1325
#define RT_DBNHASH
hash table is an array of linked lists with this many array pointer elements (Memory use for 32-bit: ...
Definition: raytrace.h:755
size_t fp_len
Definition: db_fullpath.h:44
float ma_temperature
positive ==> degrees Kelvin
Definition: raytrace.h:523
int db_parse_anim(struct db_i *dbip, int argc, const char **argv)
Definition: db_anim.c:424
#define VSET(a, b, c, d)
Definition: color.c:53
#define ANM_RMUL
Right (leaf side) mul.
Definition: raytrace.h:1319
#define RT_ANP_REPLACE
Replace shader string.
Definition: raytrace.h:1327
#define ANIM_NULL
Definition: raytrace.h:1354
void db_free_db_tree_state(struct db_tree_state *tsp)
Definition: db_tree.c:76
void db_free_anim(struct db_i *dbip)
Definition: db_anim.c:223
#define ANM_LMUL
Left (root side) mul.
Definition: raytrace.h:1318
Header file for the BRL-CAD common definitions.
#define ANM_RBOTH
Replace stack, arc=Idn.
Definition: raytrace.h:1320
#define DB_FULL_PATH_CUR_DIR(_pp)
Definition: db_fullpath.h:51
char ma_color_valid
non-0 ==> ma_color is non-default
Definition: raytrace.h:524
struct directory * d_forw
link to next dir entry
Definition: raytrace.h:864
int anc_rgb[3]
New color.
Definition: raytrace.h:1332
void db_full_path_init(struct db_full_path *pathp)
Definition: db_fullpath.c:40
#define RT_ANP_APPEND
Append to shader string.
Definition: raytrace.h:1328
#define RT_AN_MATRIX
Matrix animation.
Definition: raytrace.h:1348
void bu_vls_free(struct bu_vls *vp)
Definition: vls.c:248
struct resource rt_uniresource
default. Defined in librt/globals.c
Definition: globals.c:41
#define RT_G_DEBUG
Definition: raytrace.h:1718
int anm_op
ANM_RSTACK, ANM_RARC...
Definition: raytrace.h:1313
#define RT_AN_COLOR
Material color anim.
Definition: raytrace.h:1350
void bn_mat_print(const char *title, const mat_t m)
Definition: mat.c:81
int bn_mat_scale_about_pt(mat_t mat, const point_t pt, const double scale)
Definition: mat.c:884
void db_write_anim(FILE *fop, struct animate *anp)
Definition: db_anim.c:447
struct animate * an_forw
forward link
Definition: raytrace.h:1338
void db_init_db_tree_state(struct db_tree_state *tsp, struct db_i *dbip, struct resource *resp)
Definition: db_tree.c:93
#define BU_ALLOC(_ptr, _type)
Definition: malloc.h:223
#define ANIMATE_MAGIC
Definition: magic.h:196
struct anim_mat anu_m
Definition: raytrace.h:1342
char * bu_vls_strgrab(struct bu_vls *vp)
Definition: vls.c:290
void bu_vls_from_argv(struct bu_vls *vp, int argc, const char *argv[])
Definition: vls.c:532
#define ANM_RSTACK
Replace stacked matrix.
Definition: raytrace.h:1316
#define V3ARGS(a)
Definition: color.c:56
void db_free_full_path(struct db_full_path *pp)
Definition: db_fullpath.c:473
char * ma_shader
shader name & parms
Definition: raytrace.h:527
#define RT_AN_MATERIAL
Material property anim.
Definition: raytrace.h:1349
struct animate * db_parse_1anim(struct db_i *dbip, int argc, const char *argv[])
Definition: db_anim.c:262
char * bu_vls_strdup(const struct bu_vls *vp)
Definition: vls.c:274
Definition: joint.h:84
void bn_mat_mul(mat_t o, const mat_t a, const mat_t b)
void db_free_1anim(struct animate *anp)
Definition: db_anim.c:208
char * db_path_to_string(const struct db_full_path *pp)
Definition: db_fullpath.c:191
void bn_mat_angles(mat_t mat, double alpha, double beta, double ggamma)
#define DEBUG_ANIM_FULL
11 Animation matrices
Definition: raytrace.h:94
#define DEBUG_ANIM
10 Animation
Definition: raytrace.h:93
struct rt_anim_color anu_c
Definition: raytrace.h:1344
uint32_t magic
magic number
Definition: raytrace.h:1337
#define RT_AN_TEMPERATURE
Region temperature.
Definition: raytrace.h:1352
float ma_color[3]
explicit color: 0..1
Definition: raytrace.h:522
struct db_full_path an_path
(sub)-path pattern
Definition: raytrace.h:1339
#define ZERO(val)
Definition: units.c:38
struct directory * dbi_Head[RT_DBNHASH]
Definition: raytrace.h:814
mat_t anm_mat
Matrix.
Definition: raytrace.h:1314
#define RT_DIR_NULL
Definition: raytrace.h:875
#define LOOKUP_NOISY
Definition: raytrace.h:892
int anp_op
RT_ANP_REPLACE, etc.
Definition: raytrace.h:1324
#define RT_CK_ANIMATE(_p)
Definition: raytrace.h:1355
struct animate * d_animate
link to animation
Definition: raytrace.h:865
int db_do_anim(register struct animate *anp, mat_t stack, mat_t arc, struct mater_info *materp)
Definition: db_anim.c:89
void bu_vls_strcpy(struct bu_vls *vp, const char *s)
Definition: vls.c:310
void bu_free(void *ptr, const char *str)
Definition: malloc.c:328
#define BU_VLS_INIT_ZERO
Definition: vls.h:84
void bu_vls_vlscat(struct bu_vls *dest, const struct bu_vls *src)
Definition: vls.c:415
int db_add_anim(struct db_i *dbip, register struct animate *anp, int root)
Definition: db_anim.c:40
Definition: vls.h:56
void bu_bomb(const char *str) _BU_ATTR_NORETURN
Definition: bomb.c:91
int db_follow_path_for_state(struct db_tree_state *tsp, struct db_full_path *pathp, const char *orig_str, int noisy)
Definition: db_tree.c:839
double fastf_t
Definition: defines.h:300
void bu_vls_putc(struct bu_vls *vp, int c)
Definition: vls.c:666
struct animate * dbi_anroot
PRIVATE: heads list of anim at root lvl.
Definition: raytrace.h:821
union animate::animate_specific an_u
#define RT_AN_SOLID
Solid parameter anim.
Definition: raytrace.h:1351
struct rt_anim_property anu_p
Definition: raytrace.h:1343
#define BU_STR_EQUAL(s1, s2)
Definition: str.h:126