BRL-CAD
grip.c
Go to the documentation of this file.
1 /* G R I P . C
2  * BRL-CAD
3  *
4  * Copyright (c) 1993-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 primitives */
21 /** @{ */
22 /** @file primitives/grip/grip.c
23  *
24  * Intersect a ray with a "grip" and return nothing.
25  *
26  * A GRIP is defined by a direction normal, a center and a
27  * height/magnitude vector. The center is the control point used for
28  * all grip movements.
29  *
30  * All Ray intersections return "missed"
31  *
32  * The bounding box for a grip is empty.
33  *
34  */
35 
36 #include "common.h"
37 
38 #include <stddef.h>
39 #include <math.h>
40 #include "bio.h"
41 
42 #include "bu/cv.h"
43 #include "vmath.h"
44 #include "rtgeom.h"
45 #include "raytrace.h"
46 #include "nmg.h"
47 #include "db.h"
48 
49 #include "../../librt_private.h"
50 
51 
52 struct grip_specific {
53  uint32_t grip_magic;
54  vect_t grip_center;
55  vect_t grip_normal;
57 };
58 #define GRIP_NULL ((struct grip_specific *)0)
59 
60 const struct bu_structparse rt_grp_parse[] = {
61  { "%f", 3, "V", bu_offsetofarray(struct rt_grip_internal, center, fastf_t, X), BU_STRUCTPARSE_FUNC_NULL, NULL, NULL },
62  { "%f", 3, "N", bu_offsetofarray(struct rt_grip_internal, normal, fastf_t, X), BU_STRUCTPARSE_FUNC_NULL, NULL, NULL },
63  { "%f", 1, "L", bu_offsetof(struct rt_grip_internal, mag), BU_STRUCTPARSE_FUNC_NULL, NULL, NULL },
64  { {'\0', '\0', '\0', '\0'}, 0, (char *)NULL, 0, BU_STRUCTPARSE_FUNC_NULL, NULL, NULL }
65 };
66 
67 
68 int
69 rt_grp_prep(struct soltab *stp, struct rt_db_internal *ip, struct rt_i *rtip)
70 {
71  struct rt_grip_internal *gip;
72  struct grip_specific *gripp;
73 
74  if (rtip) RT_CK_RTI(rtip);
75 
76  gip = (struct rt_grip_internal *)ip->idb_ptr;
77  RT_GRIP_CK_MAGIC(gip);
78 
79  BU_GET(gripp, struct grip_specific);
80  stp->st_specific = (void *)gripp;
81 
82  VMOVE(gripp->grip_normal, gip->normal);
83  VMOVE(gripp->grip_center, gip->center);
84  gripp->grip_mag = gip->mag;
85 
86  /* No bounding sphere or bounding RPP is possible */
87  VSETALL(stp->st_min, 0.0);
88  VSETALL(stp->st_max, 0.0);
89 
90  stp->st_aradius = 0.0;
91  stp->st_bradius = 0.0;
92  return 0; /* OK */
93 }
94 
95 
96 void
97 rt_grp_print(const struct soltab *stp)
98 {
99  const struct grip_specific *gripp = (struct grip_specific *)stp->st_specific;
100 
101  if (gripp == GRIP_NULL) {
102  bu_log("grip(%s): no data?\n", stp->st_name);
103  return;
104  }
105  VPRINT("Center", gripp->grip_center);
106  VPRINT("Normal", gripp->grip_normal);
107  bu_log("mag = %f\n", gripp->grip_mag);
108 }
109 
110 
111 /**
112  * Function -
113  * Shoot a ray at a GRIP
114  *
115  * Algorithm -
116  * The intersection distance is computed.
117  *
118  * Returns -
119  * 0 MISS
120  * >0 HIT
121  */
122 int
123 rt_grp_shot(struct soltab *stp, struct xray *rp, struct application *ap, struct seg *UNUSED(seghead))
124 {
125  if (stp) RT_CK_SOLTAB(stp);
126  if (rp) RT_CK_RAY(rp);
127  if (ap) RT_CK_APPLICATION(ap);
128 
129  return 0; /* this has got to be the easiest.. no hit, no surfno,
130  * no nada.
131  */
132 }
133 
134 
135 /**
136  * Given ONE ray distance, return the normal and entry/exit point.
137  * The normal is already filled in.
138  */
139 void
140 rt_grp_norm(struct hit *hitp, struct soltab *stp, struct xray *rp)
141 {
142  if (hitp) RT_CK_HIT(hitp);
143  if (stp) RT_CK_SOLTAB(stp);
144  if (rp) RT_CK_RAY(rp);
145 
146  bu_bomb("rt_grp_norm: grips should never be hit.\n");
147 }
148 
149 
150 /**
151  * Return the "curvature" of the grip.
152  */
153 void
154 rt_grp_curve(struct curvature *cvp, struct hit *hitp, struct soltab *stp)
155 {
156  if (!cvp) return;
157  if (hitp) RT_CK_HIT(hitp);
158  if (stp) RT_CK_SOLTAB(stp);
159 
160  bu_bomb("rt_grp_curve: nobody should be asking for curve of a grip.\n");
161 }
162 
163 
164 /**
165  * For a hit on a face of an HALF, return the (u, v) coordinates of
166  * the hit point. 0 <= u, v <= 1. u extends along the Xbase
167  * direction. v extends along the "Ybase" direction. Note that a
168  * "toroidal" map is established, varying each from 0 up to 1 and then
169  * back down to 0 again.
170  */
171 void
172 rt_grp_uv(struct application *ap, struct soltab *stp, struct hit *hitp, struct uvcoord *uvp)
173 {
174  if (ap) RT_CK_APPLICATION(ap);
175  if (stp) RT_CK_SOLTAB(stp);
176  if (hitp) RT_CK_HIT(hitp);
177  if (!uvp) return;
178 
179  bu_bomb("rt_grp_uv: nobody should be asking for UV of a grip.\n");
180 }
181 
182 
183 void
184 rt_grp_free(struct soltab *stp)
185 {
186  struct grip_specific *gripp = (struct grip_specific *)stp->st_specific;
187 
188  BU_PUT(gripp, struct grip_specific);
189 }
190 
191 
192 /**
193  * We represent a GRIP as a pyramid. The center describes where the
194  * center of the base is. The normal describes which direction the
195  * tip of the pyramid is. Mag describes the distance from the center
196  * to the tip. 1/4 of the width is the length of a base side.
197  *
198  */
199 int
200 rt_grp_plot(struct bu_list *vhead, struct rt_db_internal *ip, const struct rt_tess_tol *UNUSED(ttol), const struct bn_tol *UNUSED(tol), const struct rt_view_info *UNUSED(info))
201 {
202  struct rt_grip_internal *gip;
203  vect_t xbase, ybase; /* perpendiculars to normal */
204  vect_t x_1, x_2;
205  vect_t y_1, y_2;
206  vect_t tip;
207 
208  BU_CK_LIST_HEAD(vhead);
209  RT_CK_DB_INTERNAL(ip);
210  gip = (struct rt_grip_internal *)ip->idb_ptr;
211  RT_GRIP_CK_MAGIC(gip);
212 
213  /* The use of "x" and "y" here is not related to the axis */
214  bn_vec_perp(xbase, gip->normal);
215  VCROSS(ybase, xbase, gip->normal);
216 
217  /* Arrange for the cross to be 2 meters across */
218  VUNITIZE(xbase);
219  VUNITIZE(ybase);
220  VSCALE(xbase, xbase, gip->mag/4.0);
221  VSCALE(ybase, ybase, gip->mag/4.0);
222 
223  VADD2(x_1, gip->center, xbase);
224  VSUB2(x_2, gip->center, xbase);
225  VADD2(y_1, gip->center, ybase);
226  VSUB2(y_2, gip->center, ybase);
227 
228  RT_ADD_VLIST(vhead, x_1, BN_VLIST_LINE_MOVE); /* the base */
229  RT_ADD_VLIST(vhead, y_1, BN_VLIST_LINE_DRAW);
230  RT_ADD_VLIST(vhead, x_2, BN_VLIST_LINE_DRAW);
231  RT_ADD_VLIST(vhead, y_2, BN_VLIST_LINE_DRAW);
232  RT_ADD_VLIST(vhead, x_1, BN_VLIST_LINE_DRAW);
233 
234  VSCALE(tip, gip->normal, gip->mag);
235  VADD2(tip, gip->center, tip);
236 
237  RT_ADD_VLIST(vhead, x_1, BN_VLIST_LINE_MOVE); /* the sides */
238  RT_ADD_VLIST(vhead, tip, BN_VLIST_LINE_DRAW);
239  RT_ADD_VLIST(vhead, x_2, BN_VLIST_LINE_DRAW);
240  RT_ADD_VLIST(vhead, y_1, BN_VLIST_LINE_MOVE);
241  RT_ADD_VLIST(vhead, tip, BN_VLIST_LINE_DRAW);
242  RT_ADD_VLIST(vhead, y_2, BN_VLIST_LINE_DRAW);
243  return 0;
244 }
245 
246 
247 /**
248  * Returns -
249  * -1 failure
250  * 0 success
251  */
252 int
253 rt_grp_import4(struct rt_db_internal *ip, const struct bu_external *ep, const fastf_t *mat, const struct db_i *dbip)
254 {
255  struct rt_grip_internal *gip;
256  union record *rp;
257 
258  fastf_t orig_eqn[3*3];
259  double f, t;
260 
261  if (dbip) RT_CK_DBI(dbip);
262 
263  BU_CK_EXTERNAL(ep);
264  rp = (union record *)ep->ext_buf;
265  if (rp->u_id != ID_SOLID) {
266  bu_log("rt_grp_import4: defective record, id=x%x\n", rp->u_id);
267  return -1;
268  }
269 
270  RT_CK_DB_INTERNAL(ip);
271  ip->idb_major_type = DB5_MAJORTYPE_BRLCAD;
272  ip->idb_type = ID_GRIP;
273  ip->idb_meth = &OBJ[ID_GRIP];
274  BU_ALLOC(ip->idb_ptr, struct rt_grip_internal);
275 
276  gip = (struct rt_grip_internal *)ip->idb_ptr;
277  gip->magic = RT_GRIP_INTERNAL_MAGIC;
278 
279  flip_fastf_float(orig_eqn, rp->s.s_values, 3, dbip->dbi_version < 0 ? 1 : 0); /* 2 floats to many */
280 
281  /* Transform the point, and the normal */
282  if (mat == NULL) mat = bn_mat_identity;
283  MAT4X3PNT(gip->center, mat, &orig_eqn[0]);
284  MAT4X3VEC(gip->normal, mat, &orig_eqn[3]);
285  if (NEAR_ZERO(mat[15], 0.001)) {
286  bu_bomb("rt_grip_import4, scale factor near zero.");
287  }
288  gip->mag = orig_eqn[6]/mat[15];
289 
290  /* Verify that normal has unit length */
291  f = MAGNITUDE(gip->normal);
292  if (f <= SMALL) {
293  bu_log("rt_grp_import4: bad normal, len=%g\n", f);
294  return -1; /* BAD */
295  }
296  t = f - 1.0;
297  if (!NEAR_ZERO(t, 0.001)) {
298  /* Restore normal to unit length */
299  f = 1/f;
300  VSCALE(gip->normal, gip->normal, f);
301  }
302  return 0; /* OK */
303 }
304 
305 
306 int
307 rt_grp_export4(struct bu_external *ep, const struct rt_db_internal *ip, double UNUSED(local2mm), const struct db_i *dbip)
308 {
309  struct rt_grip_internal *gip;
310  union record *rec;
311 
312  if (dbip) RT_CK_DBI(dbip);
313 
314  RT_CK_DB_INTERNAL(ip);
315  if (ip->idb_type != ID_GRIP) return -1;
316  gip = (struct rt_grip_internal *)ip->idb_ptr;
317  RT_GRIP_CK_MAGIC(gip);
318 
319  BU_CK_EXTERNAL(ep);
320  ep->ext_nbytes = sizeof(union record);
321  ep->ext_buf = (uint8_t *)bu_calloc(1, ep->ext_nbytes, "grip external");
322  rec = (union record *)ep->ext_buf;
323 
324  rec->s.s_id = ID_SOLID;
325  rec->s.s_type = GRP;
326  VMOVE(&rec->s.s_grip_N, gip->normal);
327  VMOVE(&rec->s.s_grip_C, gip->center);
328  rec->s.s_grip_m = gip->mag;
329 
330  return 0;
331 }
332 
333 
334 int
335 rt_grp_import5(struct rt_db_internal *ip, const struct bu_external *ep, const fastf_t *mat, const struct db_i *dbip)
336 {
337  struct rt_grip_internal *gip;
338  double f, t;
339 
340  /* must be double for import and export */
341  double vec[7];
342 
343  if (dbip) RT_CK_DBI(dbip);
344  RT_CK_DB_INTERNAL(ip);
345  BU_CK_EXTERNAL(ep);
346 
348 
349  ip->idb_major_type = DB5_MAJORTYPE_BRLCAD;
350  ip->idb_type = ID_GRIP;
351  ip->idb_meth = &OBJ[ID_GRIP];
352  BU_ALLOC(ip->idb_ptr, struct rt_grip_internal);
353 
354  gip = (struct rt_grip_internal *)ip->idb_ptr;
355  gip->magic = RT_GRIP_INTERNAL_MAGIC;
356 
357  /* Convert from database (network) to internal (host) format */
358  bu_cv_ntohd((unsigned char *)vec, ep->ext_buf, 7);
359 
360  /* Transform the point, and the normal */
361  if (mat == NULL) mat = bn_mat_identity;
362  MAT4X3PNT(gip->center, mat, &vec[0]);
363  MAT4X3VEC(gip->normal, mat, &vec[3]);
364  if (NEAR_ZERO(mat[15], 0.001)) {
365  bu_bomb("rt_grip_import5, scale factor near zero.");
366  }
367  gip->mag = vec[6]/mat[15];
368 
369  /* Verify that normal has unit length */
370  f = MAGNITUDE(gip->normal);
371  if (f <= SMALL) {
372  bu_log("rt_grp_import4: bad normal, len=%g\n", f);
373  return -1; /* BAD */
374  }
375  t = f - 1.0;
376  if (!NEAR_ZERO(t, 0.001)) {
377  /* Restore normal to unit length */
378  f = 1/f;
379  VSCALE(gip->normal, gip->normal, f);
380  }
381  return 0; /* OK */
382 }
383 
384 
385 int
386 rt_grp_export5(struct bu_external *ep, const struct rt_db_internal *ip, double local2mm, const struct db_i *dbip)
387 {
388  struct rt_grip_internal *gip;
389 
390  /* must be double for import and export */
391  double vec[7];
392 
393  if (dbip) RT_CK_DBI(dbip);
394 
395  RT_CK_DB_INTERNAL(ip);
396  if (ip->idb_type != ID_GRIP) return -1;
397  gip = (struct rt_grip_internal *)ip->idb_ptr;
398  RT_GRIP_CK_MAGIC(gip);
399 
400  BU_CK_EXTERNAL(ep);
402  ep->ext_buf = (uint8_t *)bu_malloc(ep->ext_nbytes, "grip external");
403 
404  VSCALE(&vec[0], gip->center, local2mm);
405  VMOVE(&vec[3], gip->normal);
406  vec[6] = gip->mag * local2mm;
407 
408  /* Convert from internal (host) to database (network) format */
409  bu_cv_htond(ep->ext_buf, (unsigned char *)vec, 7);
410 
411  return 0;
412 }
413 
414 
415 /**
416  * Make human-readable formatted presentation of this solid. First
417  * line describes type of solid. Additional lines are indented one
418  * tab, and give parameter values.
419  */
420 int
421 rt_grp_describe(struct bu_vls *str, const struct rt_db_internal *ip, int verbose, double mm2local)
422 {
423  struct rt_grip_internal *gip = (struct rt_grip_internal *)ip->idb_ptr;
424  char buf[256];
425 
426  RT_GRIP_CK_MAGIC(gip);
427  bu_vls_strcat(str, "grip\n");
428 
429  sprintf(buf, "\tN (%g, %g, %g)\n",
430  V3INTCLAMPARGS(gip->normal)); /* should have unit length */
431 
432  bu_vls_strcat(str, buf);
433 
434  if (!verbose)
435  return 0;
436 
437  sprintf(buf, "\tC (%g %g %g) mag=%g\n",
438  INTCLAMP(gip->center[0]*mm2local),
439  INTCLAMP(gip->center[1]*mm2local),
440  INTCLAMP(gip->center[2]*mm2local),
441  INTCLAMP(gip->mag*mm2local));
442  bu_vls_strcat(str, buf);
443 
444  return 0;
445 }
446 
447 
448 /**
449  * Free the storage associated with the rt_db_internal version of this
450  * solid.
451  */
452 void
454 {
455  RT_CK_DB_INTERNAL(ip);
456 
457  bu_free(ip->idb_ptr, "grip ifree");
458  ip->idb_ptr = ((void *)0);
459 }
460 
461 
462 int
463 rt_grp_tess(struct nmgregion **r, struct model *m, struct rt_db_internal *ip, const struct rt_tess_tol *UNUSED(ttol), const struct bn_tol *UNUSED(tol))
464 {
465  struct rt_grip_internal *gip;
466 
467  if (r) *r = NULL;
468  if (m) NMG_CK_MODEL(m);
469 
470  RT_CK_DB_INTERNAL(ip);
471  gip = (struct rt_grip_internal *)ip->idb_ptr;
472  RT_GRIP_CK_MAGIC(gip);
473 
474  /* XXX tess routine needed */
475  return -1;
476 }
477 
478 
479 int
480 rt_grp_params(struct pc_pc_set *UNUSED(ps), const struct rt_db_internal *ip)
481 {
482  if (ip) RT_CK_DB_INTERNAL(ip);
483 
484  return 0; /* OK */
485 }
486 
487 
488 /** @} */
489 /*
490  * Local Variables:
491  * mode: C
492  * tab-width: 8
493  * indent-tabs-mode: t
494  * c-file-style: "stroustrup"
495  * End:
496  * ex: shiftwidth=4 tabstop=8
497  */
Definition: raytrace.h:800
int rt_grp_import4(struct rt_db_internal *ip, const struct bu_external *ep, const fastf_t *mat, const struct db_i *dbip)
Definition: grip.c:253
void bu_log(const char *,...) _BU_ATTR_PRINTF12
Definition: log.c:176
#define SIZEOF_NETWORK_DOUBLE
Definition: cv.h:48
Definition: list.h:118
#define SMALL
Definition: defines.h:351
#define RT_CK_APPLICATION(_p)
Definition: raytrace.h:1675
#define RT_CK_RTI(_p)
Definition: raytrace.h:1833
const mat_t bn_mat_identity
Matrix and vector functionality.
Definition: mat.c:46
void bu_vls_strcat(struct bu_vls *vp, const char *s)
Definition: vls.c:368
#define ID_GRIP
Pseudo Solid Grip.
Definition: raytrace.h:480
#define VSETALL(a, s)
Definition: color.c:54
Definition: raytrace.h:215
fastf_t grip_mag
Definition: grip.c:56
Definition: pc.h:108
Definition: raytrace.h:368
#define BU_ASSERT_LONG(_lhs, _relation, _rhs)
Definition: defines.h:240
Definition: raytrace.h:248
fastf_t st_aradius
Radius of APPROXIMATING sphere.
Definition: raytrace.h:433
int rt_grp_describe(struct bu_vls *str, const struct rt_db_internal *ip, int verbose, double mm2local)
Definition: grip.c:421
Header file for the BRL-CAD common definitions.
#define RT_CK_RAY(_p)
Definition: raytrace.h:224
void flip_fastf_float(fastf_t *ff, const dbfloat_t *fp, int n, int flip)
Definition: db_flip.c:74
int rt_grp_prep(struct soltab *stp, struct rt_db_internal *ip, struct rt_i *rtip)
Definition: grip.c:69
void bu_cv_htond(unsigned char *out, const unsigned char *in, size_t count)
void rt_grp_uv(struct application *ap, struct soltab *stp, struct hit *hitp, struct uvcoord *uvp)
Definition: grip.c:172
int rt_grp_tess(struct nmgregion **r, struct model *m, struct rt_db_internal *ip, const struct rt_tess_tol *ttol, const struct bn_tol *tol)
Definition: grip.c:463
void * bu_malloc(size_t siz, const char *str)
Definition: malloc.c:314
int rt_grp_export4(struct bu_external *ep, const struct rt_db_internal *ip, double local2mm, const struct db_i *dbip)
Definition: grip.c:307
if(share_geom)
Definition: nmg_mod.c:3829
int idb_major_type
Definition: raytrace.h:192
Definition: color.c:49
void rt_grp_print(const struct soltab *stp)
Definition: grip.c:97
void rt_grp_curve(struct curvature *cvp, struct hit *hitp, struct soltab *stp)
Definition: grip.c:154
void rt_grp_free(struct soltab *stp)
Definition: grip.c:184
void rt_grp_ifree(struct rt_db_internal *ip)
Definition: grip.c:453
#define RT_ADD_VLIST(hd, pnt, draw)
Definition: raytrace.h:1865
#define GRIP_NULL
Definition: grip.c:58
#define RT_CK_DB_INTERNAL(_p)
Definition: raytrace.h:207
#define BU_ALLOC(_ptr, _type)
Definition: malloc.h:223
void * bu_calloc(size_t nelem, size_t elsize, const char *str)
Definition: malloc.c:321
fastf_t st_bradius
Radius of BOUNDING sphere.
Definition: raytrace.h:434
#define RT_CK_HIT(_p)
Definition: raytrace.h:259
#define BN_VLIST_LINE_MOVE
Definition: vlist.h:82
const struct rt_functab * idb_meth
for ft_ifree(), etc.
Definition: raytrace.h:194
#define RT_GRIP_INTERNAL_MAGIC
Definition: magic.h:95
#define NEAR_ZERO(val, epsilon)
Definition: color.c:55
uint8_t * ext_buf
Definition: parse.h:216
#define BU_GET(_ptr, _type)
Definition: malloc.h:201
point_t st_max
max X, Y, Z of bounding RPP
Definition: raytrace.h:438
#define BN_VLIST_LINE_DRAW
Definition: vlist.h:83
uint32_t grip_magic
Definition: grip.c:53
int rt_grp_params(struct pc_pc_set *ps, const struct rt_db_internal *ip)
Definition: grip.c:480
#define UNUSED(parameter)
Definition: common.h:239
#define BU_PUT(_ptr, _type)
Definition: malloc.h:215
const struct bu_structparse rt_grp_parse[]
Definition: grip.c:60
Support for uniform tolerances.
Definition: tol.h:71
int rt_grp_shot(struct soltab *stp, struct xray *rp, struct application *ap, struct seg *seghead)
Definition: grip.c:123
#define bu_offsetofarray(_t, _a, _d, _i)
Definition: parse.h:65
#define BU_STRUCTPARSE_FUNC_NULL
Definition: parse.h:153
#define bu_offsetof(_t, _m)
Definition: parse.h:64
#define RT_CK_DBI(_p)
Definition: raytrace.h:829
void * idb_ptr
Definition: raytrace.h:195
point_t st_min
min X, Y, Z of bounding RPP
Definition: raytrace.h:437
void bu_cv_ntohd(unsigned char *out, const unsigned char *in, size_t count)
const struct rt_functab OBJ[]
Definition: table.c:159
int rt_grp_export5(struct bu_external *ep, const struct rt_db_internal *ip, double local2mm, const struct db_i *dbip)
Definition: grip.c:386
vect_t grip_normal
Definition: grip.c:55
#define RT_CK_SOLTAB(_p)
Definition: raytrace.h:453
void * st_specific
-> ID-specific (private) struct
Definition: raytrace.h:435
int rt_grp_plot(struct bu_list *vhead, struct rt_db_internal *ip, const struct rt_tess_tol *ttol, const struct bn_tol *tol, const struct rt_view_info *info)
Definition: grip.c:200
vect_t grip_center
Definition: grip.c:54
int dbi_version
PRIVATE: use db_version()
Definition: raytrace.h:824
void bn_vec_perp(vect_t new_vec, const vect_t old_vec)
Definition: mat.c:616
void bu_free(void *ptr, const char *str)
Definition: malloc.c:328
#define BU_CK_LIST_HEAD(_p)
Definition: list.h:142
#define BU_CK_EXTERNAL(_p)
Definition: parse.h:224
void rt_grp_norm(struct hit *hitp, struct soltab *stp, struct xray *rp)
Definition: grip.c:140
size_t ext_nbytes
Definition: parse.h:210
HIDDEN void verbose(struct human_data_t *dude)
Definition: human.c:2008
Definition: vls.h:56
void bu_bomb(const char *str) _BU_ATTR_NORETURN
Definition: bomb.c:91
double fastf_t
Definition: defines.h:300
#define VPRINT(a, b)
Definition: raytrace.h:1881
int rt_grp_import5(struct rt_db_internal *ip, const struct bu_external *ep, const fastf_t *mat, const struct db_i *dbip)
Definition: grip.c:335