/**
* The external format is:
* V point
* A vector
* B vector
* C vector
*/
int
rt_superell_export5(struct bu_external *ep, const struct rt_db_internal *ip, double local2mm, const struct db_i *dbip)
{
struct rt_superell_internal *eip;
/* must be double for import and export */
double vec[ELEMENTS_PER_VECT*4 + 2];
if (dbip) RT_CK_DBI(dbip);
RT_CK_DB_INTERNAL(ip);
if (ip->idb_type != ID_SUPERELL) return -1;
eip = (struct rt_superell_internal *)ip->idb_ptr;
RT_SUPERELL_CK_MAGIC(eip);
BU_CK_EXTERNAL(ep);
ep->ext_nbytes = SIZEOF_NETWORK_DOUBLE * (ELEMENTS_PER_VECT*4 + 2);
ep->ext_buf = (uint8_t *)bu_malloc(ep->ext_nbytes, "superell external");
/* scale 'em into local buffer */
VSCALE(&vec[0*ELEMENTS_PER_VECT], eip->v, local2mm);
VSCALE(&vec[1*ELEMENTS_PER_VECT], eip->a, local2mm);
VSCALE(&vec[2*ELEMENTS_PER_VECT], eip->b, local2mm);
VSCALE(&vec[3*ELEMENTS_PER_VECT], eip->c, local2mm);
vec[4*ELEMENTS_PER_VECT] = eip->n;
vec[4*ELEMENTS_PER_VECT + 1] = eip->e;
/* Convert from internal (host) to database (network) format */
bu_cv_htond(ep->ext_buf, (unsigned char *)vec, ELEMENTS_PER_VECT*4 + 2);
return 0;
}
/**
* Export an XXX from internal form to external format. Note that
* this means converting all integers to Big-Endian format and
* floating point data to IEEE double.
*
* Apply the transformation to mm units as well.
*/
int
rt_xxx_export5(struct bu_external *ep, const struct rt_db_internal *ip, double local2mm, const struct db_i *dbip)
{
struct rt_xxx_internal *xxx_ip;
/* must be double for import and export */
double vec[ELEMENTS_PER_VECT];
RT_CK_DB_INTERNAL(ip);
if (ip->idb_type != ID_XXX) return -1;
xxx_ip = (struct rt_xxx_internal *)ip->idb_ptr;
RT_XXX_CK_MAGIC(xxx_ip);
if (dbip) RT_CK_DBI(dbip);
BU_CK_EXTERNAL(ep);
ep->ext_nbytes = SIZEOF_NETWORK_DOUBLE * ELEMENTS_PER_VECT;
ep->ext_buf = (void *)bu_calloc(1, ep->ext_nbytes, "xxx external");
/* Since libwdb users may want to operate in units other than mm,
* we offer the opportunity to scale the solid (to get it into mm)
* on the way out.
*/
VSCALE(vec, xxx_ip->v, local2mm);
/* Convert from internal (host) to database (network) format */
bu_cv_htond(ep->ext_buf, (unsigned char *)vec, ELEMENTS_PER_VECT);
return 0;
}
int
rt_arbn_export4(struct bu_external *ep, const struct rt_db_internal *ip, double local2mm, const struct db_i *dbip)
{
struct rt_arbn_internal *aip;
union record *rec;
size_t ngrans;
size_t i;
/* scaling buffer must be double, not fastf_t */
double *sbuf;
double *sp;
if (dbip) RT_CK_DBI(dbip);
RT_CK_DB_INTERNAL(ip);
if (ip->idb_type != ID_ARBN) return -1;
aip = (struct rt_arbn_internal *)ip->idb_ptr;
RT_ARBN_CK_MAGIC(aip);
if (aip->neqn <= 0) return -1;
/*
* The network format for a double is 8 bytes and there are 4
* doubles per plane equation.
*/
ngrans = (aip->neqn * 8 * ELEMENTS_PER_PLANE + sizeof(union record)-1) /
sizeof(union record);
BU_CK_EXTERNAL(ep);
ep->ext_nbytes = (ngrans + 1) * sizeof(union record);
ep->ext_buf = (uint8_t *)bu_calloc(1, ep->ext_nbytes, "arbn external");
rec = (union record *)ep->ext_buf;
rec[0].n.n_id = DBID_ARBN;
*(uint32_t *)rec[0].n.n_neqn = htonl(aip->neqn);
*(uint32_t *)rec[0].n.n_grans = htonl(ngrans);
/* Take the data from the caller, and scale it, into sbuf */
sp = sbuf = (double *)bu_malloc(
aip->neqn * sizeof(double) * ELEMENTS_PER_PLANE, "arbn temp");
for (i = 0; i < aip->neqn; i++) {
/* Normal is unscaled, should have unit length; d is scaled */
*sp++ = aip->eqn[i][X];
*sp++ = aip->eqn[i][Y];
*sp++ = aip->eqn[i][Z];
*sp++ = aip->eqn[i][W] * local2mm;
}
bu_cv_htond((unsigned char *)&rec[1], (unsigned char *)sbuf, aip->neqn * ELEMENTS_PER_PLANE);
bu_free((char *)sbuf, "arbn temp");
return 0; /* OK */
}
int
rt_arbn_export5(struct bu_external *ep, const struct rt_db_internal *ip, double local2mm, const struct db_i *dbip)
{
struct rt_arbn_internal *aip;
size_t i;
int double_count;
int byte_count;
/* must be double for export */
double *vec;
double *sp;
RT_CK_DB_INTERNAL(ip);
if (dbip) RT_CK_DBI(dbip);
if (ip->idb_type != ID_ARBN) return -1;
aip = (struct rt_arbn_internal *)ip->idb_ptr;
RT_ARBN_CK_MAGIC(aip);
if (aip->neqn <= 0) return -1;
double_count = aip->neqn * ELEMENTS_PER_PLANE;
byte_count = double_count * SIZEOF_NETWORK_DOUBLE;
BU_CK_EXTERNAL(ep);
ep->ext_nbytes = SIZEOF_NETWORK_LONG + byte_count;
ep->ext_buf = (uint8_t *)bu_malloc(ep->ext_nbytes, "arbn external");
*(uint32_t *)ep->ext_buf = htonl(aip->neqn);
/* Take the data from the caller, and scale it, into vec */
sp = vec = (double *)bu_malloc(byte_count, "arbn temp");
for (i = 0; i < aip->neqn; i++) {
/* Normal is unscaled, should have unit length; d is scaled */
*sp++ = aip->eqn[i][X];
*sp++ = aip->eqn[i][Y];
*sp++ = aip->eqn[i][Z];
*sp++ = aip->eqn[i][W] * local2mm;
}
/* Convert from internal (host) to database (network) format */
bu_cv_htond((unsigned char *)ep->ext_buf + SIZEOF_NETWORK_LONG, (unsigned char *)vec, double_count);
bu_free((char *)vec, "arbn temp");
return 0; /* OK */
}
/**
* storage is something like
* long numpoints
* long method
* fastf_t threshold
* fastf_t X1 (start point)
* fastf_t Y1
* fastf_t Z1
* fastf_t fldstr1
* fastf_t sweat1 (end point)
* fastf_t X2 (start point)
* ...
*/
int
rt_metaball_export5(struct bu_external *ep, const struct rt_db_internal *ip, double local2mm, const struct db_i *dbip)
{
struct rt_metaball_internal *mb;
struct wdb_metaballpt *mbpt;
int metaball_count = 0, i = 1;
/* must be double for import and export */
double *buf = NULL;
if (dbip) RT_CK_DBI(dbip);
RT_CK_DB_INTERNAL(ip);
if (ip->idb_type != ID_METABALL)
return -1;
mb = (struct rt_metaball_internal *)ip->idb_ptr;
RT_METABALL_CK_MAGIC(mb);
if (mb->metaball_ctrl_head.magic == 0) return -1;
/* Count number of points */
for (BU_LIST_FOR(mbpt, wdb_metaballpt, &mb->metaball_ctrl_head)) metaball_count++;
BU_CK_EXTERNAL(ep);
ep->ext_nbytes = SIZEOF_NETWORK_DOUBLE*(1+5*metaball_count) + 2*SIZEOF_NETWORK_LONG;
ep->ext_buf = (uint8_t *)bu_malloc(ep->ext_nbytes, "metaball external");
if (ep->ext_buf == NULL)
bu_bomb("Failed to allocate DB space!\n");
*(uint32_t *)ep->ext_buf = htonl(metaball_count);
*(uint32_t *)(ep->ext_buf + SIZEOF_NETWORK_LONG) = htonl(mb->method);
/* pack the point data */
buf = (double *)bu_malloc((metaball_count*5+1)*SIZEOF_NETWORK_DOUBLE, "rt_metaball_export5: buf");
buf[0] = mb->threshold;
for (BU_LIST_FOR(mbpt, wdb_metaballpt, &mb->metaball_ctrl_head), i+=5) {
VSCALE(&buf[i], mbpt->coord, local2mm);
buf[i+3] = mbpt->fldstr * local2mm;
buf[i+4] = mbpt->sweat;
}
bu_cv_htond((unsigned char *)ep->ext_buf + 2*SIZEOF_NETWORK_LONG, (unsigned char *)buf, 1 + 5 * metaball_count);
bu_free(buf, "rt_metaball_export5: buf");
return 0;
}
void
three_dcoord_out(FILE *fp, fastf_t *m)
{
unsigned char buf[3*8];
double p1[3];
double p2[3];
size_t ret;
ret = fread(buf, 1, 3*8, fp);
if (ret < 3*8)
perror("fread");
bu_cv_ntohd((unsigned char *)p1, buf, 3);
MAT4X3PNT(p2, m, p1);
bu_cv_htond(buf, (unsigned char *)p2, 3);
ret = fwrite(buf, 1, 3*8, stdout);
if (ret < 3*8)
perror("fwrite");
}
/**
* Export an REVOLVE from internal form to external format. Note that
* this means converting all integers to Big-Endian format and
* floating point data to IEEE double.
*
* Apply the transformation to mm units as well.
*/
int
rt_revolve_export5(struct bu_external *ep, const struct rt_db_internal *ip, double local2mm, const struct db_i *dbip)
{
struct rt_revolve_internal *rip;
/* must be double for import and export */
double vec[ELEMENTS_PER_VECT*3 + 1];
unsigned char *ptr;
if (dbip) RT_CK_DBI(dbip);
RT_CK_DB_INTERNAL(ip);
if (ip->idb_type != ID_REVOLVE) return -1;
rip = (struct rt_revolve_internal *)ip->idb_ptr;
RT_REVOLVE_CK_MAGIC(rip);
BU_CK_EXTERNAL(ep);
ep->ext_nbytes = SIZEOF_NETWORK_DOUBLE * (ELEMENTS_PER_VECT*3 + 1) + bu_vls_strlen(&rip->sketch_name) + 1;
ep->ext_buf = (uint8_t *)bu_calloc(1, ep->ext_nbytes, "revolve external");
ptr = (unsigned char *)ep->ext_buf;
/* Since libwdb users may want to operate in units other than mm,
* we offer the opportunity to scale the solid (to get it into mm)
* on the way out.
*/
VSCALE(&vec[0*3], rip->v3d, local2mm);
VSCALE(&vec[1*3], rip->axis3d, local2mm);
VSCALE(&vec[2*3], rip->r, local2mm);
vec[9] = rip->ang;
bu_cv_htond(ptr, (unsigned char *)vec, ELEMENTS_PER_VECT*3 + 1);
ptr += (ELEMENTS_PER_VECT*3 + 1) * SIZEOF_NETWORK_DOUBLE;
bu_strlcpy((char *)ptr, bu_vls_addr(&rip->sketch_name), bu_vls_strlen(&rip->sketch_name) + 1);
return 0;
}
