static void
nmg_to_psurf(struct nmgregion *r, FILE *fp_psurf)
/* NMG region to be converted. */
/* Jack format file to write vertex list to. */
{
int i;
int *map; /* map from v->index to Jack vert # */
struct bu_ptbl vtab; /* vertex table */
map = (int *)bu_calloc(r->m_p->maxindex, sizeof(int *), "Jack vert map");
/* Built list of vertex structs */
nmg_vertex_tabulate( &vtab, &r->l.magic );
/* XXX What to do if 0 vertices? */
/* Print list of unique vertices and convert from mm to cm. */
for (i = 0; i < BU_PTBL_END(&vtab); i++) {
struct vertex *v;
register struct vertex_g *vg;
v = (struct vertex *)BU_PTBL_GET(&vtab, i);
NMG_CK_VERTEX(v);
vg = v->vg_p;
NMG_CK_VERTEX_G(vg);
NMG_INDEX_ASSIGN( map, v, i+1 ); /* map[v->index] = i+1 */
fprintf(fp_psurf, "%f\t%f\t%f\n",
vg->coord[X] / 10.,
vg->coord[Y] / 10.,
vg->coord[Z] / 10.);
}
fprintf(fp_psurf, ";;\n");
jack_faces(r, fp_psurf, map);
bu_ptbl( &vtab, BU_PTBL_FREE, 0 );
bu_free( (char *)map, "Jack vert map" );
}
extern "C" void
rt_nmg_brep(ON_Brep **b, const struct rt_db_internal *ip, const struct bn_tol *tol)
{
struct model *m;
struct nmgregion *r;
struct shell *s;
struct faceuse *fu;
struct loopuse *lu;
struct edgeuse *eu;
int edge_index;
long* brepi;
RT_CK_DB_INTERNAL(ip);
m = (struct model *)ip->idb_ptr;
NMG_CK_MODEL(m);
brepi = static_cast<long*>(bu_malloc(m->maxindex * sizeof(long), "rt_nmg_brep: brepi[]"));
for (int i = 0; i < m->maxindex; i++) brepi[i] = -INT_MAX;
for (BU_LIST_FOR(r, nmgregion, &m->r_hd)) {
for (BU_LIST_FOR(s, shell, &r->s_hd)) {
for (BU_LIST_FOR(fu, faceuse, &s->fu_hd)) {
NMG_CK_FACEUSE(fu);
if (fu->orientation != OT_SAME) continue;
// Need to create ON_NurbsSurface based on plane of
// face in order to have UV space in which to define
// trimming loops. Bounding points are NOT on the
// face plane, so another approach must be used.
//
// General approach: For all loops in the faceuse,
// collect all the vertices. Find the center point of
// all the vertices, and search for the point with the
// greatest distance from that center point. Once
// found, cross the vector between the center point
// and furthest point with the normal of the face and
// scale the resulting vector to have the same length
// as the vector to the furthest point. Add the two
// resulting vectors to find the first corner point.
// Mirror the first corner point across the center to
// find the second corner point. Cross the two
// vectors created by the first two corner points with
// the face normal to get the vectors of the other two
// corners, and scale the resulting vectors to the
// same magnitude as the first two. These four points
// bound all vertices on the plane and form a suitable
// staring point for a UV space, since all points on
// all the edges are equal to or further than the
// distance between the furthest vertex and the center
// point.
// ............. .............
// . .* . .
// . . . . .
// . . . . .
// . . . * .
// . . . . .
// . . . . .
// . . . . .
// . * * . .
// . . . .
// . . . .
// . . . .
// . *. . .
// . ... ...* .
// . .... .... .
// . * .
// ...........................
//
const struct face_g_plane *fg = fu->f_p->g.plane_p;
struct bu_ptbl vert_table;
nmg_tabulate_face_g_verts(&vert_table, fg);
point_t tmppt, center, max_pt;
struct vertex **pt;
VSET(tmppt, 0, 0, 0);
VSET(max_pt, 0, 0, 0);
int ptcnt = 0;
for (BU_PTBL_FOR(pt, (struct vertex **), &vert_table)) {
tmppt[0] += (*pt)->vg_p->coord[0];
tmppt[1] += (*pt)->vg_p->coord[1];
tmppt[2] += (*pt)->vg_p->coord[2];
ptcnt++;
if (brepi[(*pt)->vg_p->index] == -INT_MAX) {
ON_BrepVertex& vert = (*b)->NewVertex((*pt)->vg_p->coord, SMALL_FASTF);
brepi[(*pt)->vg_p->index] = vert.m_vertex_index;
}
}
VSET(center, tmppt[0]/ptcnt, tmppt[1]/ptcnt, tmppt[2]/ptcnt);
fastf_t max_dist = 0.0;
fastf_t curr_dist;
for (BU_PTBL_FOR(pt, (struct vertex **), &vert_table)) {
tmppt[0] = (*pt)->vg_p->coord[0];
tmppt[1] = (*pt)->vg_p->coord[1];
tmppt[2] = (*pt)->vg_p->coord[2];
curr_dist = DIST_PT_PT(center, tmppt);
if (curr_dist > max_dist) {
max_dist = curr_dist;
VMOVE(max_pt, tmppt);
}
}
bu_ptbl_free(&vert_table);
int ccw = 0;
vect_t vtmp, uv1, uv2, uv3, uv4, vnormal;
// If an outer loop is found in the nmg with a cw
// orientation, use a flipped normal to form the NURBS
// surface
for (BU_LIST_FOR(lu, loopuse, &fu->lu_hd)) {
if (lu->orientation == OT_SAME && nmg_loop_is_ccw(lu, fg->N, tol) == -1) ccw = -1;
}
if (ccw != -1) {
VSET(vnormal, fg->N[0], fg->N[1], fg->N[2]);
} else {
VSET(vnormal, -fg->N[0], -fg->N[1], -fg->N[2]);
}
VSUB2(uv1, max_pt, center);
VCROSS(vtmp, uv1, vnormal);
VADD2(uv1, uv1, vtmp);
VCROSS(uv2, uv1, vnormal);
VREVERSE(uv3, uv1);
VCROSS(uv4, uv3, vnormal);
VADD2(uv1, uv1, center);
VADD2(uv2, uv2, center);
VADD2(uv3, uv3, center);
VADD2(uv4, uv4, center);
ON_3dPoint p1 = ON_3dPoint(uv1);
ON_3dPoint p2 = ON_3dPoint(uv2);
ON_3dPoint p3 = ON_3dPoint(uv3);
ON_3dPoint p4 = ON_3dPoint(uv4);
(*b)->m_S.Append(sideSurface(p1, p4, p3, p2));
ON_Surface *surf = (*(*b)->m_S.Last());
int surfindex = (*b)->m_S.Count();
// Now that we have the surface, define the face
ON_BrepFace& face = (*b)->NewFace(surfindex - 1);
// With the surface and the face defined, make
// trimming loops and create faces. To generate UV
// coordinates for each from and to for the
// edgecurves, the UV origin is defined to be v1,
// v1->v2 is defined as the U domain, and v1->v4 is
// defined as the V domain.
vect_t u_axis, v_axis;
VSUB2(u_axis, uv2, uv1);
VSUB2(v_axis, uv4, uv1);
fastf_t u_axis_dist = MAGNITUDE(u_axis);
fastf_t v_axis_dist = MAGNITUDE(v_axis);
// Now that the surface context is set up, add the loops.
for (BU_LIST_FOR(lu, loopuse, &fu->lu_hd)) {
int edges=0;
if (BU_LIST_FIRST_MAGIC(&lu->down_hd) != NMG_EDGEUSE_MAGIC) continue; // loop is a single vertex
ON_BrepLoop::TYPE looptype;
// Check if this is an inner or outer loop
if (lu->orientation == OT_SAME) {
looptype = ON_BrepLoop::outer;
} else {
looptype = ON_BrepLoop::inner;
}
ON_BrepLoop& loop = (*b)->NewLoop(looptype, face);
for (BU_LIST_FOR(eu, edgeuse, &lu->down_hd)) {
++edges;
vect_t ev1, ev2;
struct vertex_g *vg1, *vg2;
vg1 = eu->vu_p->v_p->vg_p;
NMG_CK_VERTEX_G(vg1);
int vert1 = brepi[vg1->index];
VMOVE(ev1, vg1->coord);
vg2 = eu->eumate_p->vu_p->v_p->vg_p;
NMG_CK_VERTEX_G(vg2);
int vert2 = brepi[vg2->index];
VMOVE(ev2, vg2->coord);
// Add edge if not already added
if (brepi[eu->e_p->index] == -INT_MAX) {
/* always add edges with the small vertex index as from */
if (vg1->index > vg2->index) {
int tmpvert = vert1;
vert1 = vert2;
vert2 = tmpvert;
}
// Create and add 3D curve
ON_Curve* c3d = new ON_LineCurve((*b)->m_V[vert1].Point(), (*b)->m_V[vert2].Point());
c3d->SetDomain(0.0, 1.0);
(*b)->m_C3.Append(c3d);
// Create and add 3D edge
ON_BrepEdge& e = (*b)->NewEdge((*b)->m_V[vert1], (*b)->m_V[vert2] , (*b)->m_C3.Count() - 1);
e.m_tolerance = 0.0;
brepi[eu->e_p->index] = e.m_edge_index;
}
// Regardless of whether the edge existed as
// an object, it needs to be added to the
// trimming loop
vect_t u_component, v_component;
ON_3dPoint vg1pt(vg1->coord);
int orientation = 0;
edge_index = brepi[eu->e_p->index];
if (vg1pt != (*b)->m_V[(*b)->m_E[edge_index].m_vi[0]].Point()) {
orientation = 1;
}
// Now, make 2d trimming curves
vect_t vect1, vect2;
VSUB2(vect1, ev1, uv1);
VSUB2(vect2, ev2, uv1);
ON_2dPoint from_uv, to_uv;
double u0, u1, v0, v1;
surf->GetDomain(0, &u0, &u1);
surf->GetDomain(1, &v0, &v1);
VPROJECT(vect1, u_axis, u_component, v_component);
from_uv.y = u0 + MAGNITUDE(u_component)/u_axis_dist*(u1-u0);
from_uv.x = v0 + MAGNITUDE(v_component)/v_axis_dist*(v1-v0);
VPROJECT(vect2, u_axis, u_component, v_component);
to_uv.y = u0 + MAGNITUDE(u_component)/u_axis_dist*(u1-u0);
to_uv.x = v0 + MAGNITUDE(v_component)/v_axis_dist*(v1-v0);
ON_3dPoint S1, S2;
ON_3dVector Su, Sv;
surf->Ev1Der(from_uv.x, from_uv.y, S1, Su, Sv);
surf->Ev1Der(to_uv.x, to_uv.y, S2, Su, Sv);
ON_Curve* c2d = new ON_LineCurve(from_uv, to_uv);
c2d->SetDomain(0.0, 1.0);
int c2i = (*b)->m_C2.Count();
(*b)->m_C2.Append(c2d);
edge_index = brepi[eu->e_p->index];
ON_BrepTrim& trim = (*b)->NewTrim((*b)->m_E[edge_index], orientation, loop, c2i);
trim.m_type = ON_BrepTrim::mated;
trim.m_tolerance[0] = 0.0;
trim.m_tolerance[1] = 0.0;
}
}
}
(*b)->SetTrimIsoFlags();
}
}
bu_free(brepi, "rt_nmg_brep: brepi[]");
}
void
nmg_2_vrml(struct db_tree_state *tsp, const struct db_full_path *pathp, struct model *m)
{
struct mater_info *mater = &tsp->ts_mater;
const struct bn_tol *tol2 = tsp->ts_tol;
struct nmgregion *reg;
struct bu_ptbl verts;
struct vrml_mat mat;
struct bu_vls vls = BU_VLS_INIT_ZERO;
char *tok;
int i;
int first = 1;
int is_light = 0;
point_t ave_pt = VINIT_ZERO;
struct bu_vls shape_name = BU_VLS_INIT_ZERO;
char *full_path;
/* There may be a better way to capture the region_id, than
* getting the rt_comb_internal structure, (and may be a better
* way to capture the rt_comb_internal struct), but for now I just
* copied the method used in select_lights/select_non_lights above,
* could have used a global variable but I noticed none other were
* used, so I didn't want to be the first
*/
struct directory *dp;
struct rt_db_internal intern;
struct rt_comb_internal *comb;
int id;
/* static due to libbu exception handling */
static float r, g, b;
NMG_CK_MODEL(m);
full_path = db_path_to_string(pathp);
RT_CK_FULL_PATH(pathp);
dp = DB_FULL_PATH_CUR_DIR(pathp);
if (!(dp->d_flags & RT_DIR_COMB)) {
return;
}
id = rt_db_get_internal(&intern, dp, dbip, (matp_t)NULL, &rt_uniresource);
if (id < 0) {
bu_log("Cannot internal form of %s\n", dp->d_namep);
return;
}
if (id != ID_COMBINATION) {
bu_log("Directory/database mismatch!\n\t is '%s' a combination or not?\n",
dp->d_namep);
return;
}
comb = (struct rt_comb_internal *)intern.idb_ptr;
RT_CK_COMB(comb);
if (mater->ma_color_valid) {
r = mater->ma_color[0];
g = mater->ma_color[1];
b = mater->ma_color[2];
} else {
r = g = b = 0.5;
}
if (mater->ma_shader) {
tok = strtok(mater->ma_shader, tok_sep);
bu_strlcpy(mat.shader, tok, TXT_NAME_SIZE);
} else {
mat.shader[0] = '\0';
}
mat.shininess = -1;
mat.transparency = -1.0;
mat.lt_fraction = -1.0;
VSETALL(mat.lt_dir, 0.0);
mat.lt_angle = -1.0;
mat.tx_file[0] = '\0';
mat.tx_w = -1;
mat.tx_n = -1;
bu_vls_strcpy(&vls, &mater->ma_shader[strlen(mat.shader)]);
(void)bu_struct_parse(&vls, vrml_mat_parse, (char *)&mat, NULL);
if (bu_strncmp("light", mat.shader, 5) == 0) {
/* this is a light source */
is_light = 1;
} else {
path_2_vrml_id(&shape_name, full_path);
fprintf(fp_out, "\t\tDEF %s Shape {\n", bu_vls_addr(&shape_name));
fprintf(fp_out, "\t\t\t# Component_ID: %ld %s\n", comb->region_id, full_path);
fprintf(fp_out, "\t\t\tappearance Appearance {\n");
if (bu_strncmp("plastic", mat.shader, 7) == 0) {
if (mat.shininess < 0) {
mat.shininess = 10;
}
if (mat.transparency < SMALL_FASTF) {
mat.transparency = 0.0;
}
fprintf(fp_out, "\t\t\t\tmaterial Material {\n");
fprintf(fp_out, "\t\t\t\t\tdiffuseColor %g %g %g \n", r, g, b);
fprintf(fp_out, "\t\t\t\t\tshininess %g\n", 1.0-exp(-(double)mat.shininess/20.0));
if (mat.transparency > SMALL_FASTF) {
fprintf(fp_out, "\t\t\t\t\ttransparency %g\n", mat.transparency);
}
fprintf(fp_out, "\t\t\t\t\tspecularColor %g %g %g \n\t\t\t\t}\n", 1.0, 1.0, 1.0);
} else if (bu_strncmp("glass", mat.shader, 5) == 0) {
if (mat.shininess < 0) {
mat.shininess = 4;
}
if (mat.transparency < SMALL_FASTF) {
mat.transparency = 0.8;
}
fprintf(fp_out, "\t\t\t\tmaterial Material {\n");
fprintf(fp_out, "\t\t\t\t\tdiffuseColor %g %g %g \n", r, g, b);
fprintf(fp_out, "\t\t\t\t\tshininess %g\n", 1.0-exp(-(double)mat.shininess/20.0));
if (mat.transparency > SMALL_FASTF) {
fprintf(fp_out, "\t\t\t\t\ttransparency %g\n", mat.transparency);
}
fprintf(fp_out, "\t\t\t\t\tspecularColor %g %g %g \n\t\t\t\t}\n", 1.0, 1.0, 1.0);
} else if (bu_strncmp("texture", mat.shader, 7) == 0) {
if (mat.tx_w < 0) {
mat.tx_w = 512;
}
if (mat.tx_n < 0) {
mat.tx_n = 512;
}
if (strlen(mat.tx_file)) {
int tex_fd;
unsigned char tex_buf[TXT_BUF_LEN * 3];
if ((tex_fd = open(mat.tx_file, O_RDONLY | O_BINARY)) == (-1)) {
bu_log("Cannot open texture file (%s)\n", mat.tx_file);
perror("g-vrml: ");
} else {
long tex_len;
long bytes_read = 0;
long bytes_to_go = 0;
/* Johns note - need to check (test) the texture stuff */
fprintf(fp_out, "\t\t\t\ttextureTransform TextureTransform {\n");
fprintf(fp_out, "\t\t\t\t\tscale 1.33333 1.33333\n\t\t\t\t}\n");
fprintf(fp_out, "\t\t\t\ttexture PixelTexture {\n");
fprintf(fp_out, "\t\t\t\t\trepeatS TRUE\n");
fprintf(fp_out, "\t\t\t\t\trepeatT TRUE\n");
fprintf(fp_out, "\t\t\t\t\timage %d %d %d\n", mat.tx_w, mat.tx_n, 3);
tex_len = mat.tx_w*mat.tx_n * 3;
while (bytes_read < tex_len) {
int nbytes;
long readval;
bytes_to_go = tex_len - bytes_read;
CLAMP(bytes_to_go, 0, TXT_BUF_LEN * 3);
nbytes = 0;
while (nbytes < bytes_to_go) {
readval = read(tex_fd, &tex_buf[nbytes], bytes_to_go-nbytes);
if (readval < 0) {
perror("READ ERROR");
break;
} else {
nbytes += readval;
}
}
bytes_read += nbytes;
for (i = 0; i < nbytes; i += 3) {
fprintf(fp_out, "\t\t\t0x%02x%02x%02x\n",
tex_buf[i], tex_buf[i+1], tex_buf[i+2]);
}
}
fprintf(fp_out, "\t\t\t\t}\n");
close(tex_fd);
}
}
} else if (mater->ma_color_valid) {
/* no shader specified, but a color is assigned */
fprintf(fp_out, "\t\t\t\tmaterial Material {\n");
fprintf(fp_out, "\t\t\t\t\tdiffuseColor %g %g %g }\n", r, g, b);
} else {
/* If no color was defined set the colors according to the thousands groups */
int thou = comb->region_id / 1000;
thou == 0 ? fprintf(fp_out, "\t\t\tmaterial USE Material_999\n")
: thou == 1 ? fprintf(fp_out, "\t\t\tmaterial USE Material_1999\n")
: thou == 2 ? fprintf(fp_out, "\t\t\tmaterial USE Material_2999\n")
: thou == 3 ? fprintf(fp_out, "\t\t\tmaterial USE Material_3999\n")
: thou == 4 ? fprintf(fp_out, "\t\t\tmaterial USE Material_4999\n")
: thou == 5 ? fprintf(fp_out, "\t\t\tmaterial USE Material_5999\n")
: thou == 6 ? fprintf(fp_out, "\t\t\tmaterial USE Material_6999\n")
: thou == 7 ? fprintf(fp_out, "\t\t\tmaterial USE Material_7999\n")
: thou == 8 ? fprintf(fp_out, "\t\t\tmaterial USE Material_8999\n")
: fprintf(fp_out, "\t\t\tmaterial USE Material_9999\n");
}
}
if (!is_light) {
nmg_triangulate_model(m, tol2);
fprintf(fp_out, "\t\t\t}\n");
fprintf(fp_out, "\t\t\tgeometry IndexedFaceSet {\n");
fprintf(fp_out, "\t\t\t\tcoord Coordinate {\n");
}
/* get list of vertices */
nmg_vertex_tabulate(&verts, &m->magic);
if (!is_light) {
fprintf(fp_out, "\t\t\t\t\tpoint [");
} else {
VSETALL(ave_pt, 0.0);
}
for (i = 0; i < BU_PTBL_END(&verts); i++) {
struct vertex *v;
struct vertex_g *vg;
point_t pt_meters;
v = (struct vertex *)BU_PTBL_GET(&verts, i);
NMG_CK_VERTEX(v);
vg = v->vg_p;
NMG_CK_VERTEX_G(vg);
/* convert to desired units */
VSCALE(pt_meters, vg->coord, scale_factor);
if (is_light) {
VADD2(ave_pt, ave_pt, pt_meters);
}
if (first) {
if (!is_light) {
fprintf(fp_out, " %10.10e %10.10e %10.10e, # point %d\n", V3ARGS(pt_meters), i);
}
first = 0;
} else if (!is_light) {
fprintf(fp_out, "\t\t\t\t\t%10.10e %10.10e %10.10e, # point %d\n", V3ARGS(pt_meters), i);
}
}
if (!is_light) {
fprintf(fp_out, "\t\t\t\t\t]\n\t\t\t\t}\n");
} else {
fastf_t one_over_count;
one_over_count = 1.0/(fastf_t)BU_PTBL_END(&verts);
VSCALE(ave_pt, ave_pt, one_over_count);
}
first = 1;
if (!is_light) {
fprintf(fp_out, "\t\t\t\tcoordIndex [\n");
for (BU_LIST_FOR(reg, nmgregion, &m->r_hd)) {
struct shell *s;
NMG_CK_REGION(reg);
for (BU_LIST_FOR(s, shell, ®->s_hd)) {
struct faceuse *fu;
NMG_CK_SHELL(s);
for (BU_LIST_FOR(fu, faceuse, &s->fu_hd)) {
struct loopuse *lu;
NMG_CK_FACEUSE(fu);
if (fu->orientation != OT_SAME) {
continue;
}
for (BU_LIST_FOR(lu, loopuse, &fu->lu_hd)) {
struct edgeuse *eu;
NMG_CK_LOOPUSE(lu);
if (BU_LIST_FIRST_MAGIC(&lu->down_hd) != NMG_EDGEUSE_MAGIC) {
continue;
}
if (!first) {
fprintf(fp_out, ",\n");
} else {
first = 0;
}
fprintf(fp_out, "\t\t\t\t\t");
for (BU_LIST_FOR(eu, edgeuse, &lu->down_hd)) {
struct vertex *v;
NMG_CK_EDGEUSE(eu);
v = eu->vu_p->v_p;
NMG_CK_VERTEX(v);
fprintf(fp_out, " %d,", bu_ptbl_locate(&verts, (long *)v));
}
fprintf(fp_out, "-1");
}
}
}
}
fprintf(fp_out, "\n\t\t\t\t]\n\t\t\t\tnormalPerVertex FALSE\n");
fprintf(fp_out, "\t\t\t\tconvex FALSE\n");
fprintf(fp_out, "\t\t\t\tcreaseAngle 0.5\n");
fprintf(fp_out, "\t\t\t}\n\t\t}\n");
} else {
/*
* J A C K _ F A C E S
*
* Continues the conversion of an nmg into Jack format. Before
* this routine is called, a list of unique vertices has been
* stored in a heap. Using this heap and the nmg structure, a
* list of face vertices is written to the Jack data base file.
*/
static void
jack_faces(struct nmgregion *r, FILE *fp_psurf, int *map)
/* NMG region to be converted. */
/* Jack format file to write face vertices to. */
{
struct edgeuse *eu;
struct faceuse *fu;
struct loopuse *lu;
struct shell *s;
struct vertex *v;
for (BU_LIST_FOR(s, shell, &r->s_hd)) {
/* Shell is made of faces. */
for (BU_LIST_FOR(fu, faceuse, &s->fu_hd)) {
NMG_CK_FACEUSE(fu);
if (fu->orientation != OT_SAME)
continue;
for (BU_LIST_FOR(lu, loopuse, &fu->lu_hd)) {
NMG_CK_LOOPUSE(lu);
if (BU_LIST_FIRST_MAGIC(&lu->down_hd) == NMG_EDGEUSE_MAGIC) {
for (BU_LIST_FOR(eu, edgeuse, &lu->down_hd)) {
NMG_CK_EDGEUSE(eu);
NMG_CK_EDGE(eu->e_p);
NMG_CK_VERTEXUSE(eu->vu_p);
NMG_CK_VERTEX(eu->vu_p->v_p);
NMG_CK_VERTEX_G(eu->vu_p->v_p->vg_p);
fprintf(fp_psurf, "%d ", NMG_INDEX_GET(map, eu->vu_p->v_p));
}
} else if (BU_LIST_FIRST_MAGIC(&lu->down_hd)
== NMG_VERTEXUSE_MAGIC) {
v = BU_LIST_PNEXT(vertexuse, &lu->down_hd)->v_p;
NMG_CK_VERTEX(v);
NMG_CK_VERTEX_G(v->vg_p);
fprintf(fp_psurf, "%d ", NMG_INDEX_GET(map, v));
} else
bu_log("jack_faces: loopuse mess up! (1)\n");
fprintf(fp_psurf, ";\n");
}
}
/* Shell contains loops. */
for (BU_LIST_FOR(lu, loopuse, &s->lu_hd)) {
NMG_CK_LOOPUSE(lu);
if (BU_LIST_FIRST_MAGIC(&lu->down_hd) == NMG_EDGEUSE_MAGIC) {
for (BU_LIST_FOR(eu, edgeuse, &lu->down_hd)) {
NMG_CK_EDGEUSE(eu);
NMG_CK_EDGE(eu->e_p);
NMG_CK_VERTEXUSE(eu->vu_p);
NMG_CK_VERTEX(eu->vu_p->v_p);
NMG_CK_VERTEX_G(eu->vu_p->v_p->vg_p);
fprintf(fp_psurf, "%d ", NMG_INDEX_GET(map, eu->vu_p->v_p));
}
} else if (BU_LIST_FIRST_MAGIC(&lu->down_hd)
== NMG_VERTEXUSE_MAGIC) {
v = BU_LIST_PNEXT(vertexuse, &lu->down_hd)->v_p;
NMG_CK_VERTEX(v);
NMG_CK_VERTEX_G(v->vg_p);
fprintf(fp_psurf, "%d ", NMG_INDEX_GET(map, v));
} else
bu_log("jack_faces: loopuse mess up! (1)\n");
fprintf(fp_psurf, ";\n");
}
void
nmg_2_vrml(FILE *fp, const struct db_full_path *pathp, struct model *m, struct mater_info *mater)
{
struct nmgregion *reg;
struct bu_ptbl verts;
struct vrml_mat mat;
struct bu_vls vls = BU_VLS_INIT_ZERO;
char *tok;
int i;
int first=1;
int is_light=0;
float r, g, b;
point_t ave_pt;
char *full_path;
/*There may be a better way to capture the region_id, than getting the rt_comb_internal structure,
* (and may be a better way to capture the rt_comb_internal struct), but for now I just copied the
* method used in select_lights/select_non_lights above, could have used a global variable but I noticed
* none other were used, so I didn't want to be the first
*/
struct directory *dp;
struct rt_db_internal intern;
struct rt_comb_internal *comb;
int id;
NMG_CK_MODEL( m );
BARRIER_CHECK;
full_path = db_path_to_string( pathp );
/* replace all occurrences of '.' with '_' */
char_replace(full_path, '.', '_');
RT_CK_FULL_PATH( pathp );
dp = DB_FULL_PATH_CUR_DIR( pathp );
if ( !(dp->d_flags & RT_DIR_COMB) )
return;
id = rt_db_get_internal( &intern, dp, dbip, (matp_t)NULL, &rt_uniresource );
if ( id < 0 )
{
bu_log( "Cannot internal form of %s\n", dp->d_namep );
return;
}
if ( id != ID_COMBINATION )
{
bu_log( "Directory/database mismatch!\n\t is '%s' a combination or not?\n",
dp->d_namep );
return;
}
comb = (struct rt_comb_internal *)intern.idb_ptr;
RT_CK_COMB( comb );
if ( mater->ma_color_valid )
{
r = mater->ma_color[0];
g = mater->ma_color[1];
b = mater->ma_color[2];
}
else
{
r = g = b = 0.5;
}
if ( mater->ma_shader )
{
tok = strtok( mater->ma_shader, tok_sep );
bu_strlcpy( mat.shader, tok, TXT_NAME_SIZE );
}
else
mat.shader[0] = '\0';
mat.shininess = -1;
mat.transparency = -1.0;
mat.lt_fraction = -1.0;
VSETALL( mat.lt_dir, 0.0 );
mat.lt_angle = -1.0;
mat.tx_file[0] = '\0';
mat.tx_w = -1;
mat.tx_n = -1;
bu_vls_strcpy( &vls, &mater->ma_shader[strlen(mat.shader)] );
(void)bu_struct_parse( &vls, vrml_mat_parse, (char *)&mat, NULL);
if ( bu_strncmp( "light", mat.shader, 5 ) == 0 )
{
/* this is a light source */
is_light = 1;
}
else
{
fprintf( fp, "\t<Shape DEF=\"%s\">\n", full_path);
fprintf( fp, "\t\t<Appearance>\n");
if ( bu_strncmp( "plastic", mat.shader, 7 ) == 0 )
{
if ( mat.shininess < 0 )
mat.shininess = 10;
V_MAX(mat.transparency, 0.0);
fprintf( fp, "\t\t\t<Material diffuseColor=\"%g %g %g\" shininess=\"%g\" transparency=\"%g\" specularColor=\"%g %g %g\"/>\n", r, g, b, 1.0-exp(-(double)mat.shininess/20.0), mat.transparency, 1.0, 1.0, 1.0);
}
else if ( bu_strncmp( "glass", mat.shader, 5 ) == 0 )
{
if ( mat.shininess < 0 )
mat.shininess = 4;
if ( mat.transparency < 0.0 )
mat.transparency = 0.8;
fprintf( fp, "\t\t\t<Material diffuseColor=\"%g %g %g\" shininess=\"%g\" transparency=\"%g\" specularColor=\"%g %g %g\"/>\n", r, g, b, 1.0-exp(-(double)mat.shininess/20.0), mat.transparency, 1.0, 1.0, 1.0);
}
else if ( mater->ma_color_valid )
{
fprintf( fp, "\t\t\t<Material diffuseColor=\"%g %g %g\"/>\n", r, g, b);
}
else
{
/* If no color was defined set the colors according to the thousands groups */
int thou = comb->region_id/1000;
thou == 0 ? fprintf( fp, "\t\t\t<Material USE=\"Material_999\"/>\n")
: thou == 1 ? fprintf( fp, "\t\t\t<Material USE=\"Material_1999\"/>\n")
: thou == 2 ? fprintf( fp, "\t\t\t<Material USE=\"Material_2999\"/>\n")
: thou == 3 ? fprintf( fp, "\t\t\t<Material USE=\"Material_3999\"/>\n")
: thou == 4 ? fprintf( fp, "\t\t\t<Material USE=\"Material_4999\"/>\n")
: thou == 5 ? fprintf( fp, "\t\t\t<Material USE=\"Material_5999\"/>\n")
: thou == 6 ? fprintf( fp, "\t\t\t<Material USE=\"Material_6999\"/>\n")
: thou == 7 ? fprintf( fp, "\t\t\t<Material USE=\"Material_7999\"/>\n")
: thou == 8 ? fprintf( fp, "\t\t\t<Material USE=\"Material_8999\"/>\n")
: fprintf( fp, "\t\t\t<Material USE=\"Material_9999\"/>\n");
}
}
if ( !is_light )
{
process_non_light(m);
fprintf( fp, "\t\t</Appearance>\n");
}
/* FIXME: need code to handle light */
/* get list of vertices */
nmg_vertex_tabulate( &verts, &m->magic );
fprintf( fp, "\t\t<IndexedFaceSet coordIndex=\"\n");
first = 1;
if ( !is_light )
{
for ( BU_LIST_FOR( reg, nmgregion, &m->r_hd ) )
{
struct shell *s;
NMG_CK_REGION( reg );
for ( BU_LIST_FOR( s, shell, ®->s_hd ) )
{
struct faceuse *fu;
NMG_CK_SHELL( s );
for ( BU_LIST_FOR( fu, faceuse, &s->fu_hd ) )
{
struct loopuse *lu;
NMG_CK_FACEUSE( fu );
if ( fu->orientation != OT_SAME )
continue;
for ( BU_LIST_FOR( lu, loopuse, &fu->lu_hd ) )
{
struct edgeuse *eu;
NMG_CK_LOOPUSE( lu );
if ( BU_LIST_FIRST_MAGIC( &lu->down_hd ) != NMG_EDGEUSE_MAGIC )
continue;
if ( !first )
fprintf( fp, ",\n" );
else
first = 0;
fprintf( fp, "\t\t\t\t" );
for ( BU_LIST_FOR( eu, edgeuse, &lu->down_hd ) )
{
struct vertex *v;
NMG_CK_EDGEUSE( eu );
v = eu->vu_p->v_p;
NMG_CK_VERTEX( v );
fprintf( fp, " %d,", bu_ptbl_locate( &verts, (long *)v ) );
}
fprintf( fp, "-1" );
}
}
}
}
/* close coordIndex */
fprintf( fp, "\" ");
fprintf( fp, "normalPerVertex=\"false\" ");
fprintf( fp, "convex=\"false\" ");
fprintf( fp, "creaseAngle=\"0.5\" ");
/* close IndexedFaceSet open tag */
fprintf( fp, ">\n");
}
fprintf( fp, "\t\t\t<Coordinate point=\"");
for ( i=0; i<BU_PTBL_END( &verts ); i++ )
{
struct vertex *v;
struct vertex_g *vg;
point_t pt_meters;
v = (struct vertex *)BU_PTBL_GET( &verts, i );
NMG_CK_VERTEX( v );
vg = v->vg_p;
NMG_CK_VERTEX_G( vg );
/* convert to desired units */
VSCALE( pt_meters, vg->coord, scale_factor );
if ( is_light )
VADD2( ave_pt, ave_pt, pt_meters );
if ( first )
{
if ( !is_light )
fprintf( fp, " %10.10e %10.10e %10.10e, ", V3ARGS(pt_meters));
first = 0;
}
else
if ( !is_light )
fprintf( fp, "%10.10e %10.10e %10.10e, ", V3ARGS( pt_meters ));
}
/* close point */
fprintf(fp, "\"");
/* close Coordinate */
fprintf(fp, "/>\n");
/* IndexedFaceSet end tag */
fprintf( fp, "\t\t</IndexedFaceSet>\n");
/* Shape end tag */
fprintf( fp, "\t</Shape>\n");
BARRIER_CHECK;
}
HIDDEN int
nmg_brep_face(ON_Brep **b, const struct faceuse *fu, const struct bn_tol *tol, long *brepi) {
const struct face_g_plane *fg = fu->f_p->g.plane_p;
struct bu_ptbl vert_table;
struct vertex **pt;
int ret = 0;
int pnt_cnt = 0;
int pnt_index = 0;
vect_t u_axis, v_axis;
point_t obr_center;
point_t *points_3d = NULL;
point_t *points_obr = NULL;
struct loopuse *lu;
struct edgeuse *eu;
/* Find out how many points we have, set up any uninitialized ON_Brep vertex
* structures, and prepare a map of NMG index values to the point array indices */
nmg_tabulate_face_g_verts(&vert_table, fg);
for (BU_PTBL_FOR(pt, (struct vertex **), &vert_table)) {
if (brepi[(*pt)->vg_p->index] == -INT_MAX) {
ON_BrepVertex& vert = (*b)->NewVertex((*pt)->vg_p->coord, SMALL_FASTF);
brepi[(*pt)->vg_p->index] = vert.m_vertex_index;
}
pnt_cnt++;
}
/* Prepare the 3D obr input array */
points_3d = (point_t *)bu_calloc(pnt_cnt + 1, sizeof(point_t), "nmg points");
for (BU_PTBL_FOR(pt, (struct vertex **), &vert_table)) {
VSET(points_3d[pnt_index], (*pt)->vg_p->coord[0],(*pt)->vg_p->coord[1],(*pt)->vg_p->coord[2]);
pnt_index++;
}
bu_ptbl_free(&vert_table);
/* Calculate the 3D coplanar oriented bounding rectangle (obr) */
ret += bg_3d_coplanar_obr(&obr_center, &u_axis, &v_axis, (const point_t *)points_3d, pnt_cnt);
if (ret) {
bu_log("Failed to get oriented bounding rectangle for NMG faceuse #%lu\n", fu->index);
return -1;
}
bu_free(points_3d, "done with obr 3d point inputs");
/* Use the obr to define the 3D corner points of the NURBS surface */
points_obr = (point_t *)bu_calloc(3 + 1, sizeof(point_t), "points_3d");
VADD3(points_obr[2], obr_center, u_axis, v_axis);
VSCALE(u_axis, u_axis, -1);
VADD3(points_obr[3], obr_center, u_axis, v_axis);
VSCALE(v_axis, v_axis, -1);
VADD3(points_obr[0], obr_center, u_axis, v_axis);
VSCALE(u_axis, u_axis, -1);
VADD3(points_obr[1], obr_center, u_axis, v_axis);
/* We need to orient our surface correctly according to the NMG - using
* the openNURBS FlipFace function later does not seem to work very
* well. If an outer loop is found in the NMG with a cw orientation,
* factor that in in addition to the fu->f_p->flip flag. */
int ccw = 0;
vect_t vtmp, uv1, uv2, vnormal;
point_t center;
VADD2(center, points_obr[0], points_obr[1]);
VADD2(center, center, points_obr[2]);
VADD2(center, center, points_obr[3]);
VSCALE(center, center, 0.25);
for (BU_LIST_FOR(lu, loopuse, &fu->lu_hd)) {
if (lu->orientation == OT_SAME && nmg_loop_is_ccw(lu, fg->N, tol) == -1) ccw = -1;
}
if (ccw != -1) {
VSET(vnormal, fg->N[0], fg->N[1], fg->N[2]);
} else {
VSET(vnormal, -fg->N[0], -fg->N[1], -fg->N[2]);
}
if (fu->f_p->flip)
VSET(vnormal, -vnormal[0], -vnormal[1], -vnormal[2]);
VSUB2(uv1, points_obr[0], center);
VSUB2(uv2, points_obr[1], center);
VCROSS(vtmp, uv1, uv2);
if (VDOT(vtmp, vnormal) < 0) {
VMOVE(vtmp, points_obr[0]);
VMOVE(points_obr[0], points_obr[1]);
VMOVE(points_obr[1], vtmp);
VMOVE(vtmp, points_obr[3]);
VMOVE(points_obr[3], points_obr[2]);
VMOVE(points_obr[2], vtmp);
}
/* Now that we've got our points correctly oriented for
* the NURBS surface, proceed to create it. */
ON_3dPoint p1 = ON_3dPoint(points_obr[0]);
ON_3dPoint p2 = ON_3dPoint(points_obr[1]);
ON_3dPoint p3 = ON_3dPoint(points_obr[2]);
ON_3dPoint p4 = ON_3dPoint(points_obr[3]);
(*b)->m_S.Append(sideSurface(p1, p2, p3, p4));
ON_Surface *surf = (*(*b)->m_S.Last());
int surfindex = (*b)->m_S.Count();
ON_BrepFace& face = (*b)->NewFace(surfindex - 1);
// With the surface and the face defined, make
// trimming loops and create faces. To generate UV
// coordinates for each from and to for the
// edgecurves, the UV origin is defined to be v1,
// v1->v2 is defined as the U domain, and v1->v4 is
// defined as the V domain.
VSUB2(u_axis, points_obr[2], points_obr[1]);
VSUB2(v_axis, points_obr[0], points_obr[1]);
fastf_t u_axis_dist = MAGNITUDE(u_axis);
fastf_t v_axis_dist = MAGNITUDE(v_axis);
/* Now that we have the surface and the face, add the loops */
for (BU_LIST_FOR(lu, loopuse, &fu->lu_hd)) {
if (BU_LIST_FIRST_MAGIC(&lu->down_hd) != NMG_EDGEUSE_MAGIC) continue; // loop is a single vertex
// Check if this is an inner or outer loop
ON_BrepLoop::TYPE looptype = (lu->orientation == OT_SAME) ? ON_BrepLoop::outer : ON_BrepLoop::inner;
ON_BrepLoop& loop = (*b)->NewLoop(looptype, face);
for (BU_LIST_FOR(eu, edgeuse, &lu->down_hd)) {
vect_t ev1, ev2;
struct vertex_g *vg1 = eu->vu_p->v_p->vg_p;
struct vertex_g *vg2 = eu->eumate_p->vu_p->v_p->vg_p;
NMG_CK_VERTEX_G(vg1);
NMG_CK_VERTEX_G(vg2);
VMOVE(ev1, vg1->coord);
VMOVE(ev2, vg2->coord);
// Add edge if not already added
if (brepi[eu->e_p->index] == -INT_MAX) {
/* always add edges with the small vertex index as from */
int vert1 = (vg1->index <= vg2->index) ? brepi[vg1->index] : brepi[vg2->index];
int vert2 = (vg1->index > vg2->index) ? brepi[vg1->index] : brepi[vg2->index];
// Create and add 3D curve
ON_Curve* c3d = new ON_LineCurve((*b)->m_V[vert1].Point(), (*b)->m_V[vert2].Point());
c3d->SetDomain(0.0, 1.0);
(*b)->m_C3.Append(c3d);
// Create and add 3D edge
ON_BrepEdge& e = (*b)->NewEdge((*b)->m_V[vert1], (*b)->m_V[vert2] , (*b)->m_C3.Count() - 1);
e.m_tolerance = 0.0;
brepi[eu->e_p->index] = e.m_edge_index;
}
// Regardless of whether the edge existed as an object, it needs to be added to the trimming loop
ON_3dPoint vg1pt(vg1->coord);
int orientation = ((vg1pt != (*b)->m_V[(*b)->m_E[(int)brepi[eu->e_p->index]].m_vi[0]].Point())) ? 1 : 0;
// Make a 2d trimming curve, create a trim, and add the trim to the loop
vect_t vect1, vect2, u_component, v_component;
double u0, u1, v0, v1;
ON_2dPoint from_uv, to_uv;
VSUB2(vect1, ev1, points_obr[0]);
VSUB2(vect2, ev2, points_obr[0]);
surf->GetDomain(0, &u0, &u1);
surf->GetDomain(1, &v0, &v1);
VPROJECT(vect1, u_axis, u_component, v_component);
from_uv.y = u0 + MAGNITUDE(u_component)/u_axis_dist*(u1-u0);
from_uv.x = v0 + MAGNITUDE(v_component)/v_axis_dist*(v1-v0);
VPROJECT(vect2, u_axis, u_component, v_component);
to_uv.y = u0 + MAGNITUDE(u_component)/u_axis_dist*(u1-u0);
to_uv.x = v0 + MAGNITUDE(v_component)/v_axis_dist*(v1-v0);
ON_Curve* c2d = new ON_LineCurve(from_uv, to_uv);
c2d->SetDomain(0.0, 1.0);
int c2i = (*b)->m_C2.Count();
(*b)->m_C2.Append(c2d);
ON_BrepTrim& trim = (*b)->NewTrim((*b)->m_E[(int)brepi[eu->e_p->index]], orientation, loop, c2i);
trim.m_type = ON_BrepTrim::mated;
trim.m_tolerance[0] = 0.0;
trim.m_tolerance[1] = 0.0;
}
}
bu_free(points_obr, "Done with obr");
return 0;
}
