/*
* Erase all currently displayed geometry and draw the specified object(s)
*
* Usage:
* blast object(s)
*
*/
int
ged_blast(struct ged *gedp, int argc, const char *argv[])
{
static const char *usage = "object(s)";
GED_CHECK_DATABASE_OPEN(gedp, GED_ERROR);
GED_CHECK_DRAWABLE(gedp, GED_ERROR);
GED_CHECK_ARGC_GT_0(gedp, argc, GED_ERROR);
/* initialize result */
bu_vls_trunc(gedp->ged_result_str, 0);
/* must be wanting help */
if (argc == 1) {
bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage);
return GED_HELP;
}
/* First, clear the screen */
{
const char *av[2];
av[0] = "zap";
av[1] = (char *)0;
ged_zap(gedp, 1, av);
}
/* Draw the new object(s) */
return ged_draw(gedp, argc, argv);
}
int
ged_cat(struct ged *gedp, int argc, const char *argv[])
{
struct directory *dp;
int arg;
static const char *usage = "<objects>";
GED_CHECK_DATABASE_OPEN(gedp, GED_ERROR);
GED_CHECK_ARGC_GT_0(gedp, argc, GED_ERROR);
/* initialize result */
bu_vls_trunc(gedp->ged_result_str, 0);
/* must be wanting help */
if (argc == 1) {
bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage);
return GED_HELP;
}
for (arg = 1; arg < argc; arg++) {
if ((dp = db_lookup(gedp->ged_wdbp->dbip, argv[arg], LOOKUP_NOISY)) == RT_DIR_NULL)
continue;
_ged_do_list(gedp, dp, 0); /* non-verbose */
}
return GED_OK;
}
/**
* Given a point in model space coordinates (in mm) convert it to view
* (screen) coordinates which must be scaled to correspond to actual
* screen coordinates. If no input coordinates are supplied, the
* model2view matrix is displayed.
*/
int
ged_model2view(struct ged *gedp, int argc, const char *argv[])
{
point_t view_pt;
double model_pt[3]; /* intentionally double for scan */
static const char *usage = "[x y z]";
GED_CHECK_DATABASE_OPEN(gedp, GED_ERROR);
GED_CHECK_VIEW(gedp, GED_ERROR);
GED_CHECK_ARGC_GT_0(gedp, argc, GED_ERROR);
/* initialize result */
bu_vls_trunc(gedp->ged_result_str, 0);
/* get the model2view matrix */
if (argc == 1) {
bn_encode_mat(gedp->ged_result_str, gedp->ged_gvp->gv_model2view);
return GED_OK;
}
if (argc != 4
|| sscanf(argv[1], "%lf", &model_pt[X]) != 1
|| sscanf(argv[2], "%lf", &model_pt[Y]) != 1
|| sscanf(argv[3], "%lf", &model_pt[Z]) != 1)
{
bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage);
return GED_ERROR;
}
MAT4X3PNT(view_pt, gedp->ged_gvp->gv_model2view, model_pt);
bn_encode_vect(gedp->ged_result_str, view_pt);
return GED_OK;
}
int
ged_debuglib(struct ged *gedp, int argc, const char *argv[])
{
static const char *usage = "[hex_code]";
GED_CHECK_DATABASE_OPEN(gedp, GED_ERROR);
GED_CHECK_ARGC_GT_0(gedp, argc, GED_ERROR);
/* initialize result */
bu_vls_trunc(gedp->ged_result_str, 0);
if (argc > 2) {
bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage);
return GED_ERROR;
}
/* get librt's debug bit vector */
if (argc == 1) {
bu_vls_printb(gedp->ged_result_str, "Possible flags", 0xffffffffL, DEBUG_FORMAT);
bu_vls_printf(gedp->ged_result_str, "\n");
} else {
/* set librt's debug bit vector */
if (sscanf(argv[1], "%x", (unsigned int *)&rt_g.debug) != 1) {
bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage);
return GED_ERROR;
}
if (RT_G_DEBUG) bu_debug |= BU_DEBUG_COREDUMP;
}
bu_vls_printb(gedp->ged_result_str, "librt RT_G_DEBUG", RT_G_DEBUG, DEBUG_FORMAT);
bu_vls_printf(gedp->ged_result_str, "\n");
return GED_OK;
}
int
ged_form(struct ged *gedp, int argc, const char *argv[])
{
const struct rt_functab *ftp;
static const char *usage = "type";
GED_CHECK_DATABASE_OPEN(gedp, GED_ERROR);
GED_CHECK_ARGC_GT_0(gedp, argc, GED_ERROR);
/* initialize result */
bu_vls_trunc(gedp->ged_result_str, 0);
/* must be wanting help */
if (argc == 1) {
bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage);
return GED_HELP;
}
if (argc != 2) {
bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage);
return GED_ERROR;
}
if ((ftp = rt_get_functab_by_label(argv[1])) == NULL) {
bu_vls_printf(gedp->ged_result_str, "There is no geometric object type \"%s\".", argv[1]);
return GED_ERROR;
}
if (!ftp->ft_form) {
return GED_ERROR;
}
return ftp->ft_form(gedp->ged_result_str, ftp);
}
int
ged_model2view_lu(struct ged *gedp, int argc, const char *argv[])
{
fastf_t f;
point_t view_pt;
double model_pt[3]; /* intentionally double for scan */
static const char *usage = "x y z";
GED_CHECK_DATABASE_OPEN(gedp, GED_ERROR);
GED_CHECK_VIEW(gedp, GED_ERROR);
GED_CHECK_ARGC_GT_0(gedp, argc, GED_ERROR);
/* initialize result */
bu_vls_trunc(gedp->ged_result_str, 0);
if (argc != 4)
goto bad;
if (sscanf(argv[1], "%lf", &model_pt[X]) != 1 ||
sscanf(argv[2], "%lf", &model_pt[Y]) != 1 ||
sscanf(argv[3], "%lf", &model_pt[Z]) != 1)
goto bad;
VSCALE(model_pt, model_pt, gedp->ged_wdbp->dbip->dbi_local2base);
MAT4X3PNT(view_pt, gedp->ged_gvp->gv_model2view, model_pt);
f = gedp->ged_gvp->gv_scale * gedp->ged_wdbp->dbip->dbi_base2local;
VSCALE(view_pt, view_pt, f);
bn_encode_vect(gedp->ged_result_str, view_pt);
return GED_OK;
bad:
bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage);
return GED_ERROR;
}
/*
* Returns the views eyemodel
*
* Usage:
* get_eyemodel
*
*/
int
ged_get_eyemodel(struct ged *gedp, int argc, const char *argv[])
{
quat_t quat;
vect_t eye_model;
GED_CHECK_DATABASE_OPEN(gedp, GED_ERROR);
GED_CHECK_DRAWABLE(gedp, GED_ERROR);
GED_CHECK_VIEW(gedp, GED_ERROR);
GED_CHECK_ARGC_GT_0(gedp, argc, GED_ERROR);
/* initialize result */
bu_vls_trunc(gedp->ged_result_str, 0);
if (argc != 1) {
bu_vls_printf(gedp->ged_result_str, "Usage: %s", argv[0]);
return GED_ERROR;
}
_ged_rt_set_eye_model(gedp, eye_model);
quat_mat2quat(quat, gedp->ged_gvp->gv_rotation);
bu_vls_printf(gedp->ged_result_str, "viewsize %.15e;\n", gedp->ged_gvp->gv_size);
bu_vls_printf(gedp->ged_result_str, "orientation %.15e %.15e %.15e %.15e;\n",
V4ARGS(quat));
bu_vls_printf(gedp->ged_result_str, "eye_pt %.15e %.15e %.15e;\n",
eye_model[X], eye_model[Y], eye_model[Z]);
return GED_OK;
}
int
ged_zoom(struct ged *gedp, int argc, const char *argv[])
{
int ret;
double sf = 1.0;
GED_CHECK_VIEW(gedp, GED_ERROR);
GED_CHECK_ARGC_GT_0(gedp, argc, GED_ERROR);
/* initialize result */
bu_vls_trunc(gedp->ged_result_str, 0);
/* must be wanting help */
if (argc != 2) {
bu_vls_printf(gedp->ged_result_str, "Usage: %s scale_factor", argv[0]);
return (argc == 1) ? GED_HELP : GED_ERROR;
}
/* get the scale factor */
ret = sscanf(argv[1], "%lf", &sf);
if (ret != 1 || sf < SMALL_FASTF || sf > INFINITY) {
bu_vls_printf(gedp->ged_result_str, "ERROR: bad scale factor [%s]", argv[1]);
return GED_ERROR;
}
return zoom(gedp, sf);
}
int
ged_echo(struct ged *gedp, int argc, const char *argv[])
{
int i;
static const char *usage = "args";
GED_CHECK_DATABASE_OPEN(gedp, GED_ERROR);
GED_CHECK_ARGC_GT_0(gedp, argc, GED_ERROR);
/* initialize result */
bu_vls_trunc(gedp->ged_result_str, 0);
/* must be wanting help */
if (argc == 1) {
bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage);
return GED_HELP;
}
for (i = 1; i < argc; i++) {
bu_vls_printf(gedp->ged_result_str, "%s%s", i == 1 ? "" : " ", argv[i]);
}
bu_vls_printf(gedp->ged_result_str, "\n");
return GED_OK;
}
int
ged_find_botpt_nearest_pt(struct ged *gedp, int argc, const char *argv[])
{
static const char *usage = "bot view_xyz";
struct rt_db_internal intern;
struct rt_bot_internal *botip;
mat_t mat;
int nearest_pt;
vect_t view;
/* must be double for scanf */
double scan[ELEMENTS_PER_VECT];
GED_CHECK_DATABASE_OPEN(gedp, GED_ERROR);
GED_CHECK_VIEW(gedp, GED_ERROR);
GED_CHECK_ARGC_GT_0(gedp, argc, GED_ERROR);
/* initialize result */
bu_vls_trunc(gedp->ged_result_str, 0);
/* must be wanting help */
if (argc == 1) {
bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage);
return GED_HELP;
}
if (argc != 3) {
bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage);
return GED_ERROR;
}
if (bu_sscanf(argv[2], "%lf %lf %lf", &scan[X], &scan[Y], &scan[Z]) != 3) {
bu_vls_printf(gedp->ged_result_str, "%s: bad view location - %s", argv[0], argv[2]);
return GED_ERROR;
}
if (wdb_import_from_path2(gedp->ged_result_str, &intern, argv[1], gedp->ged_wdbp, mat) == GED_ERROR) {
bu_vls_printf(gedp->ged_result_str, "%s: failed to find %s", argv[0], argv[1]);
return GED_ERROR;
}
if (intern.idb_major_type != DB5_MAJORTYPE_BRLCAD ||
intern.idb_minor_type != DB5_MINORTYPE_BRLCAD_BOT) {
bu_vls_printf(gedp->ged_result_str, "Object is not a BOT");
rt_db_free_internal(&intern);
return GED_ERROR;
}
botip = (struct rt_bot_internal *)intern.idb_ptr;
VMOVE(view, scan); /* convert double to fastf_t */
nearest_pt = rt_bot_find_v_nearest_pt2(botip, view, gedp->ged_gvp->gv_model2view);
bu_vls_printf(gedp->ged_result_str, "%d", nearest_pt);
rt_db_free_internal(&intern);
return GED_OK;
}
int
ged_v2m_point(struct ged *gedp, int argc, const char *argv[])
{
point_t view;
point_t model;
static const char *usage = "x y z";
GED_CHECK_DATABASE_OPEN(gedp, GED_ERROR);
GED_CHECK_VIEW(gedp, GED_ERROR);
GED_CHECK_ARGC_GT_0(gedp, argc, GED_ERROR);
/* initialize result */
bu_vls_trunc(gedp->ged_result_str, 0);
/* must be wanting help */
if (argc == 1) {
bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage);
return GED_HELP;
}
if (argc != 2 && argc != 4) {
bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage);
return GED_ERROR;
}
if (argc == 2) {
if (bn_decode_vect(view, argv[1]) != 3) {
bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage);
return GED_ERROR;
}
} else {
double scan[3];
if (sscanf(argv[1], "%lf", &scan[X]) != 1) {
bu_vls_printf(gedp->ged_result_str, "ged_m2v_point: bad X value - %s\n", argv[1]);
return GED_ERROR;
}
if (sscanf(argv[2], "%lf", &scan[Y]) != 1) {
bu_vls_printf(gedp->ged_result_str, "ged_m2v_point: bad Y value - %s\n", argv[2]);
return GED_ERROR;
}
if (sscanf(argv[3], "%lf", &scan[Z]) != 1) {
bu_vls_printf(gedp->ged_result_str, "ged_m2v_point: bad Z value - %s\n", argv[3]);
return GED_ERROR;
}
/* convert from double to fastf_t */
VMOVE(view, scan);
}
/* Convert the incoming view point to a model point */
MAT4X3PNT(model, gedp->ged_gvp->gv_view2model, view);
bn_encode_vect(gedp->ged_result_str, model);
return GED_OK;
}
int
ged_setview(struct ged *gedp, int argc, const char *argv[])
{
vect_t rvec;
static const char *usage = "x y z";
GED_CHECK_DATABASE_OPEN(gedp, GED_ERROR);
GED_CHECK_VIEW(gedp, GED_ERROR);
GED_CHECK_ARGC_GT_0(gedp, argc, GED_ERROR);
/* initialize result */
bu_vls_trunc(gedp->ged_result_str, 0);
/* must be wanting help */
if (argc == 1) {
bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage);
return GED_HELP;
}
if (argc != 2 && argc != 4) {
bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage);
return GED_ERROR;
}
/* set view center */
if (argc == 2) {
if (bn_decode_vect(rvec, argv[1]) != 3) {
bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage);
return GED_ERROR;
}
} else {
double scan[3];
if (sscanf(argv[1], "%lf", &scan[X]) != 1) {
bu_vls_printf(gedp->ged_result_str, "ged_setview: bad X value - %s\n", argv[1]);
return GED_ERROR;
}
if (sscanf(argv[2], "%lf", &scan[Y]) != 1) {
bu_vls_printf(gedp->ged_result_str, "ged_setview: bad Y value - %s\n", argv[2]);
return GED_ERROR;
}
if (sscanf(argv[3], "%lf", &scan[Z]) != 1) {
bu_vls_printf(gedp->ged_result_str, "ged_setview: bad Z value - %s\n", argv[3]);
return GED_ERROR;
}
/* convert from double to fastf_t */
VMOVE(rvec, scan);
}
bn_mat_angles(gedp->ged_gvp->gv_rotation, rvec[X], rvec[Y], rvec[Z]);
ged_view_update(gedp->ged_gvp);
return GED_OK;
}
/*
* Illuminate/highlight database object
*
* Usage:
* illum [-n] obj
*
*/
int
ged_illum(struct ged *gedp, int argc, const char *argv[])
{
struct display_list *gdlp;
struct display_list *next_gdlp;
int found = 0;
int illum = 1;
static const char *usage = "[-n] obj";
GED_CHECK_DATABASE_OPEN(gedp, GED_ERROR);
GED_CHECK_DRAWABLE(gedp, GED_ERROR);
GED_CHECK_ARGC_GT_0(gedp, argc, GED_ERROR);
/* initialize result */
bu_vls_trunc(gedp->ged_result_str, 0);
/* must be wanting help */
if (argc == 1) {
bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage);
return GED_HELP;
}
if (argc == 3) {
if (argv[1][0] == '-' && argv[1][1] == 'n')
illum = 0;
else
goto bad;
--argc;
++argv;
}
if (argc != 2)
goto bad;
gdlp = BU_LIST_NEXT(display_list, gedp->ged_gdp->gd_headDisplay);
while (BU_LIST_NOT_HEAD(gdlp, gedp->ged_gdp->gd_headDisplay)) {
next_gdlp = BU_LIST_PNEXT(display_list, gdlp);
found += dl_set_illum(gdlp, argv[1], illum);
gdlp = next_gdlp;
}
if (!found) {
bu_vls_printf(gedp->ged_result_str, "illum: %s not found", argv[1]);
return GED_ERROR;
}
return GED_OK;
bad:
bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage);
return GED_ERROR;
}
int
ged_scale_args(struct ged *gedp, int argc, const char *argv[], fastf_t *sf1, fastf_t *sf2, fastf_t *sf3)
{
static const char *usage = "sf (or) sfx sfy sfz";
int ret = GED_OK, args_read;
double scan;
GED_CHECK_DATABASE_OPEN(gedp, GED_ERROR);
GED_CHECK_VIEW(gedp, GED_ERROR);
GED_CHECK_ARGC_GT_0(gedp, argc, GED_ERROR);
/* initialize result */
bu_vls_trunc(gedp->ged_result_str, 0);
/* must be wanting help */
if (argc == 1) {
bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage);
return GED_HELP;
}
if (argc != 2 && argc != 4) {
bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage);
return GED_ERROR;
}
if (argc == 2) {
if (!sf1 || sscanf(argv[1], "%lf", &scan) != 1) {
bu_vls_printf(gedp->ged_result_str, "\nbad scale factor '%s'", argv[1]);
return GED_ERROR;
}
*sf1 = scan;
} else {
args_read = sscanf(argv[1], "%lf", &scan);
if (!sf1 || args_read != 1) {
bu_vls_printf(gedp->ged_result_str, "\nbad x scale factor '%s'", argv[1]);
ret = GED_ERROR;
}
*sf1 = scan;
args_read = sscanf(argv[2], "%lf", &scan);
if (!sf2 || args_read != 1) {
bu_vls_printf(gedp->ged_result_str, "\nbad y scale factor '%s'", argv[2]);
ret = GED_ERROR;
}
*sf2 = scan;
args_read = sscanf(argv[3], "%lf", &scan);
if (!sf3 || args_read != 1) {
bu_vls_printf(gedp->ged_result_str, "\nbad z scale factor '%s'", argv[3]);
ret = GED_ERROR;
}
*sf3 = scan;
}
return ret;
}
/*
* List the objects currently prepped for drawing
*
* Usage:
* who [r(eal)|p(hony)|b(oth)]
*
*/
int
ged_who(struct ged *gedp, int argc, const char *argv[])
{
struct ged_display_list *gdlp;
int skip_real, skip_phony;
static const char *usage = "[r(eal)|p(hony)|b(oth)]";
GED_CHECK_DATABASE_OPEN(gedp, GED_ERROR);
GED_CHECK_DRAWABLE(gedp, GED_ERROR);
GED_CHECK_ARGC_GT_0(gedp, argc, GED_ERROR);
/* initialize result */
bu_vls_trunc(gedp->ged_result_str, 0);
if (2 < argc) {
bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage);
return GED_ERROR;
}
skip_real = 0;
skip_phony = 1;
if (argc == 2) {
switch (argv[1][0]) {
case 'b':
skip_real = 0;
skip_phony = 0;
break;
case 'p':
skip_real = 1;
skip_phony = 0;
break;
case 'r':
skip_real = 0;
skip_phony = 1;
break;
default:
bu_vls_printf(gedp->ged_result_str, "ged_who: argument not understood\n");
return GED_ERROR;
}
}
for (BU_LIST_FOR(gdlp, ged_display_list, gedp->ged_gdp->gd_headDisplay)) {
if (gdlp->gdl_dp->d_addr == RT_DIR_PHONY_ADDR) {
if (skip_phony) continue;
} else {
if (skip_real) continue;
}
bu_vls_printf(gedp->ged_result_str, "%s ", bu_vls_addr(&gdlp->gdl_path));
}
return GED_OK;
}
int
ged_wcodes(struct ged *gedp, int argc, const char *argv[])
{
int i;
int status;
FILE *fp;
struct directory *dp;
static const char *usage = "filename object(s)";
GED_CHECK_DATABASE_OPEN(gedp, GED_ERROR);
GED_CHECK_ARGC_GT_0(gedp, argc, GED_ERROR);
/* initialize result */
bu_vls_trunc(gedp->ged_result_str, 0);
/* must be wanting help */
if (argc == 1) {
bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage);
return GED_HELP;
}
if (argc == 2) {
bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage);
return GED_ERROR;
}
if ((fp = fopen(argv[1], "w")) == NULL) {
bu_vls_printf(gedp->ged_result_str, "%s: Failed to open file - %s",
argv[0], argv[1]);
return GED_ERROR;
}
path = (struct directory **)bu_calloc(PATH_STEP, sizeof(struct directory *), "alloc initial path");
path_capacity = PATH_STEP;
for (i = 2; i < argc; ++i) {
if ((dp = db_lookup(gedp->ged_wdbp->dbip, argv[i], LOOKUP_NOISY)) != RT_DIR_NULL) {
status = wcodes_printcodes(gedp, fp, dp, 0);
if (status == GED_ERROR) {
(void)fclose(fp);
return GED_ERROR;
}
}
}
(void)fclose(fp);
bu_free(path, "dealloc path");
path = NULL;
path_capacity = 0;
return GED_OK;
}
int
ged_get_bot_edges(struct ged *gedp, int argc, const char *argv[])
{
static const char *usage = "bot";
struct rt_db_internal intern;
struct rt_bot_internal *botip;
mat_t mat;
size_t edge_count;
size_t *edge_list;
GED_CHECK_DATABASE_OPEN(gedp, GED_ERROR);
GED_CHECK_ARGC_GT_0(gedp, argc, GED_ERROR);
/* initialize result */
bu_vls_trunc(gedp->ged_result_str, 0);
/* must be wanting help */
if (argc == 1) {
bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage);
return GED_HELP;
}
if (argc != 2) {
bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage);
return GED_ERROR;
}
if (wdb_import_from_path2(gedp->ged_result_str, &intern, argv[1], gedp->ged_wdbp, mat) == GED_ERROR) {
bu_vls_printf(gedp->ged_result_str, "%s: failed to find %s", argv[0], argv[1]);
return GED_ERROR;
}
if (intern.idb_major_type != DB5_MAJORTYPE_BRLCAD ||
intern.idb_minor_type != DB5_MINORTYPE_BRLCAD_BOT) {
bu_vls_printf(gedp->ged_result_str, "Object is not a BOT");
rt_db_free_internal(&intern);
return GED_ERROR;
}
botip = (struct rt_bot_internal *)intern.idb_ptr;
if ((edge_count = rt_bot_get_edge_list(botip, &edge_list)) > 0) {
size_t i;
for (i = 0; i < edge_count; i++)
bu_vls_printf(gedp->ged_result_str, "{%zu %zu} ", edge_list[i*2], edge_list[i*2+1]);
bu_free(edge_list, "bot edge list");
}
rt_db_free_internal(&intern);
return GED_OK;
}
int
ged_killall(struct ged *gedp, int argc, const char *argv[])
{
int nflag;
int ret;
static const char *usage = "[-n] object(s)";
GED_CHECK_DATABASE_OPEN(gedp, GED_ERROR);
GED_CHECK_DRAWABLE(gedp, GED_ERROR);
GED_CHECK_READ_ONLY(gedp, GED_ERROR);
GED_CHECK_ARGC_GT_0(gedp, argc, GED_ERROR);
/* initialize result */
bu_vls_trunc(gedp->ged_result_str, 0);
/* must be wanting help */
if (argc == 1) {
bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage);
return GED_HELP;
}
/* Process the -n option */
if (argc > 1 && argv[1][0] == '-' && argv[1][1] == 'n' && argv[1][2] == '\0') {
int i;
nflag = 1;
/* Objects that would be killed are in the first sublist */
bu_vls_printf(gedp->ged_result_str, "{");
for (i = 2; i < argc; i++)
bu_vls_printf(gedp->ged_result_str, "%s ", argv[i]);
bu_vls_printf(gedp->ged_result_str, "} {");
} else
nflag = 0;
gedp->ged_internal_call = 1;
if ((ret = ged_killrefs(gedp, argc, argv)) != GED_OK) {
gedp->ged_internal_call = 0;
bu_vls_printf(gedp->ged_result_str, "KILL skipped because of earlier errors.\n");
return ret;
}
gedp->ged_internal_call = 0;
if (nflag) {
/* Close the sublist of objects that reference the would-be killed objects. */
bu_vls_printf(gedp->ged_result_str, "}");
return GED_OK;
}
/* ALL references removed...now KILL the object[s] */
/* reuse argv[] */
argv[0] = "kill";
return ged_kill(gedp, argc, argv);
}
int
ged_bot_flip(struct ged *gedp, int argc, const char *argv[])
{
int i;
struct directory *dp;
struct rt_db_internal intern;
struct rt_bot_internal *bot;
static const char *usage = "bot [bot2 bot3 ...]";
GED_CHECK_DATABASE_OPEN(gedp, GED_ERROR);
GED_CHECK_READ_ONLY(gedp, GED_ERROR);
GED_CHECK_ARGC_GT_0(gedp, argc, GED_ERROR);
/* initialize result */
bu_vls_trunc(gedp->ged_result_str, 0);
/* must be wanting help */
if (argc == 1) {
bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage);
return GED_HELP;
}
for (i = 1; i < argc; ++i) {
/* Skip past any path elements */
char *obj = (char *)bu_calloc(strlen(argv[i]), sizeof(char), "ged_bot_flip obj");
bu_basename(obj, argv[i]);
if (BU_STR_EQUAL(obj, ".")) {
/* malformed path, lookup using exactly what was provided */
bu_free(obj, "free bu_basename");
obj = bu_strdup(argv[i]);
}
if ((dp = db_lookup(gedp->ged_wdbp->dbip, obj, LOOKUP_QUIET)) == RT_DIR_NULL) {
bu_vls_printf(gedp->ged_result_str, "%s: db_lookup(%s) error\n", argv[0], obj);
} else {
GED_DB_GET_INTERNAL(gedp, &intern, dp, bn_mat_identity, &rt_uniresource, GED_ERROR);
if (intern.idb_major_type != DB5_MAJORTYPE_BRLCAD || intern.idb_minor_type != DB5_MINORTYPE_BRLCAD_BOT) {
bu_vls_printf(gedp->ged_result_str, "%s: %s is not a BOT solid!\n", argv[0], obj);
} else {
bot = (struct rt_bot_internal *)intern.idb_ptr;
rt_bot_flip(bot);
GED_DB_PUT_INTERNAL(gedp, dp, &intern, gedp->ged_wdbp->wdb_resp, GED_ERROR);
}
}
bu_free(obj, "free obj");
}
return GED_OK;
}
/**
* Checks for the existence of a specified object.
*/
int
ged_exists(struct ged *gedp, int argc, const char *argv_orig[])
{
/* struct directory *dp;*/
static const char *usage = "object";
struct exists_data ed;
struct bu_vls message = BU_VLS_INIT_ZERO;
int result;
char **argv = bu_dup_argv(argc, argv_orig);
GED_CHECK_DATABASE_OPEN(gedp, GED_ERROR);
GED_CHECK_ARGC_GT_0(gedp, argc, GED_ERROR);
/* initialize result */
bu_vls_trunc(gedp->ged_result_str, 0);
/* must be wanting help */
if (argc == 1) {
bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv_orig[0], usage);
return GED_HELP;
}
/*
if (argc != 2) {
bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv_orig[0], usage);
return GED_ERROR;
}
*/
ed.t_wp = &argv[1];
ed.gedp = gedp;
ed.t_wp_op = NULL;
ed.message = &message;
result = oexpr(t_lex(*(ed.t_wp), &ed), &ed);
if (result)
bu_vls_printf(gedp->ged_result_str, "1");
else
bu_vls_printf(gedp->ged_result_str, "0");
if (bu_vls_strlen(ed.message) > 0) {
bu_vls_printf(gedp->ged_result_str, "%s", bu_vls_addr(ed.message));
bu_vls_free(&message);
return GED_ERROR;
}
bu_vls_free(&message);
if (*(ed.t_wp) != NULL && *++(ed.t_wp) != NULL) {
return GED_ERROR;
} else {
return GED_OK;
}
}
int
ged_adjust(struct ged *gedp, int argc, const char *argv[])
{
int status;
struct directory *dp;
char *name;
struct rt_db_internal intern;
static const char *usage = "object attr value ?attr value?";
GED_CHECK_DATABASE_OPEN(gedp, GED_ERROR);
GED_CHECK_READ_ONLY(gedp, GED_ERROR);
GED_CHECK_ARGC_GT_0(gedp, argc, GED_ERROR);
/* initialize result */
bu_vls_trunc(gedp->ged_result_str, 0);
/* must be wanting help */
if (argc == 1) {
bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage);
return GED_HELP;
}
if (argc < 4) {
bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage);
return GED_ERROR;
}
name = (char *)argv[1];
GED_DB_LOOKUP(gedp, dp, name, LOOKUP_QUIET, GED_ERROR);
GED_DB_GET_INTERNAL(gedp, &intern, dp, (matp_t)NULL, &rt_uniresource, GED_ERROR);
RT_CK_DB_INTERNAL(&intern);
/* Find out what type of object we are dealing with and tweak it. */
RT_CK_FUNCTAB(intern.idb_meth);
if (!intern.idb_meth->ft_adjust) {
bu_vls_printf(gedp->ged_result_str, "wdb_export(%s) adjust failure", name);
return GED_ERROR;
}
status = intern.idb_meth->ft_adjust(gedp->ged_result_str, &intern, argc-2, argv+2);
if (status == GED_OK && wdb_put_internal(gedp->ged_wdbp, name, &intern, 1.0) < 0) {
bu_vls_printf(gedp->ged_result_str, "wdb_export(%s) failure", name);
rt_db_free_internal(&intern);
return GED_ERROR;
}
return GED_OK;
}
int
ged_orient(struct ged *gedp, int argc, const char *argv[])
{
quat_t quat;
static const char *usage = "quat";
GED_CHECK_DATABASE_OPEN(gedp, GED_ERROR);
GED_CHECK_VIEW(gedp, GED_ERROR);
GED_CHECK_ARGC_GT_0(gedp, argc, GED_ERROR);
/* initialize result */
bu_vls_trunc(gedp->ged_result_str, 0);
/* must be wanting help */
if (argc == 1) {
bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage);
return GED_HELP;
}
if (argc != 2 && argc != 5) {
bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage);
return GED_ERROR;
}
/* set view orientation */
if (argc == 2) {
if (bn_decode_quat(quat, argv[1]) != 4) {
bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage);
return GED_ERROR;
}
} else {
int i;
for (i = 1; i < 5; ++i) {
double scan;
if (sscanf(argv[i], "%lf", &scan) != 1) {
bu_vls_printf(gedp->ged_result_str, "ged_orient: bad value - %s\n", argv[i-1]);
return GED_ERROR;
}
/* convert from double to fastf_t */
quat[i-1] = scan;
}
}
quat_quat2mat(gedp->ged_gvp->gv_rotation, quat);
ged_view_update(gedp->ged_gvp);
return GED_OK;
}
int
ged_bot_condense(struct ged *gedp, int argc, const char *argv[])
{
struct directory *old_dp, *new_dp;
struct rt_db_internal intern;
struct rt_bot_internal *bot;
int count2=0;
static const char *usage = "new_bot old_bot";
GED_CHECK_DATABASE_OPEN(gedp, GED_ERROR);
GED_CHECK_READ_ONLY(gedp, GED_ERROR);
GED_CHECK_ARGC_GT_0(gedp, argc, GED_ERROR);
/* initialize result */
bu_vls_trunc(gedp->ged_result_str, 0);
/* must be wanting help */
if (argc == 1) {
bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage);
return GED_HELP;
}
if (argc != 3) {
bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage);
return GED_ERROR;
}
GED_DB_LOOKUP(gedp, old_dp, argv[2], LOOKUP_NOISY, GED_ERROR & GED_QUIET);
GED_DB_GET_INTERNAL(gedp, &intern, old_dp, bn_mat_identity, &rt_uniresource, GED_ERROR);
if (intern.idb_major_type != DB5_MAJORTYPE_BRLCAD || intern.idb_minor_type != DB5_MINORTYPE_BRLCAD_BOT) {
bu_vls_printf(gedp->ged_result_str, "%s: %s is not a BOT solid!\n", argv[0], argv[2]);
return GED_ERROR;
}
bot = (struct rt_bot_internal *)intern.idb_ptr;
RT_BOT_CK_MAGIC(bot);
count2 = rt_bot_condense(bot);
bu_vls_printf(gedp->ged_result_str, "%s: %d dead vertices eliminated\n", argv[0], count2);
GED_DB_DIRADD(gedp, new_dp, argv[1], RT_DIR_PHONY_ADDR, 0, RT_DIR_SOLID, (void *)&intern.idb_type, GED_ERROR);
GED_DB_PUT_INTERNAL(gedp, new_dp, &intern, &rt_uniresource, GED_ERROR);
return GED_OK;
}
int
ged_copy(struct ged *gedp, int argc, const char *argv[])
{
struct directory *from_dp;
struct bu_external external;
static const char *usage = "from to";
GED_CHECK_DATABASE_OPEN(gedp, GED_ERROR);
GED_CHECK_READ_ONLY(gedp, GED_ERROR);
GED_CHECK_ARGC_GT_0(gedp, argc, GED_ERROR);
/* initialize result */
bu_vls_trunc(gedp->ged_result_str, 0);
/* must be wanting help */
if (argc == 1) {
bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage);
return GED_HELP;
}
if (argc != 3) {
bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage);
return GED_ERROR;
}
GED_DB_LOOKUP(gedp, from_dp, argv[1], LOOKUP_NOISY, GED_ERROR & GED_QUIET);
GED_CHECK_EXISTS(gedp, argv[2], LOOKUP_QUIET, GED_ERROR);
if (db_get_external(&external, from_dp, gedp->ged_wdbp->dbip)) {
bu_vls_printf(gedp->ged_result_str, "Database read error, aborting\n");
return GED_ERROR;
}
if (wdb_export_external(gedp->ged_wdbp, &external, argv[2],
from_dp->d_flags, from_dp->d_minor_type) < 0) {
bu_free_external(&external);
bu_vls_printf(gedp->ged_result_str,
"Failed to write new object (%s) to database - aborting!!\n",
argv[2]);
return GED_ERROR;
}
bu_free_external(&external);
return GED_OK;
}
int
ged_edcolor(struct ged *gedp, int argc, const char *argv[])
{
GED_CHECK_DATABASE_OPEN(gedp, GED_ERROR);
GED_CHECK_READ_ONLY(gedp, GED_ERROR);
GED_CHECK_ARGC_GT_0(gedp, argc, GED_ERROR);
/* initialize result */
bu_vls_trunc(gedp->ged_result_str, 0);
if (argc != 3) {
bu_vls_printf(gedp->ged_result_str, "Usage: %s", argv[0]);
return GED_ERROR;
}
return edcolor(gedp, argc, argv);
}
int
ged_savekey(struct ged *gedp, int argc, const char *argv[])
{
FILE *fp;
fastf_t timearg;
vect_t eye_model;
vect_t temp;
static const char *usage = "file [time]";
GED_CHECK_DATABASE_OPEN(gedp, GED_ERROR);
GED_CHECK_VIEW(gedp, GED_ERROR);
GED_CHECK_ARGC_GT_0(gedp, argc, GED_ERROR);
/* initialize result */
bu_vls_trunc(gedp->ged_result_str, 0);
/* must be wanting help */
if (argc == 1) {
bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage);
return GED_HELP;
}
if (argc < 2 || 3 < argc) {
bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage);
return GED_ERROR;
}
if ((fp = fopen(argv[1], "a")) == NULL) {
perror(argv[1]);
return TCL_ERROR;
}
if (argc > 2) {
timearg = atof(argv[2]);
fprintf(fp, "%f\n", timearg);
}
/*
* Eye is in conventional place.
*/
VSET(temp, 0.0, 0.0, 1.0);
MAT4X3PNT(eye_model, gedp->ged_gvp->gv_view2model, temp);
savekey_rt_oldwrite(gedp, fp, eye_model);
(void)fclose(fp);
return GED_OK;
}
int
ged_debugmem(struct ged *gedp, int argc, const char *argv[])
{
GED_CHECK_DATABASE_OPEN(gedp, GED_ERROR);
GED_CHECK_ARGC_GT_0(gedp, argc, GED_ERROR);
/* initialize result */
bu_vls_trunc(gedp->ged_result_str, 0);
if (argc != 1) {
bu_vls_printf(gedp->ged_result_str, "Usage: %s", argv[0]);
return GED_ERROR;
}
bu_prmem("Invoked via libged");
return GED_OK;
}
int
ged_size(struct ged *gedp, int argc, const char *argv[])
{
/* intentionally double for scan */
double size;
static const char *usage = "[s]";
GED_CHECK_DATABASE_OPEN(gedp, GED_ERROR);
GED_CHECK_VIEW(gedp, GED_ERROR);
GED_CHECK_ARGC_GT_0(gedp, argc, GED_ERROR);
/* initialize result */
bu_vls_trunc(gedp->ged_result_str, 0);
/* get view size */
if (argc == 1) {
bu_vls_printf(gedp->ged_result_str, "%g",
gedp->ged_gvp->gv_size * gedp->ged_wdbp->dbip->dbi_base2local);
return GED_OK;
}
/* set view size */
if (argc == 2) {
if (sscanf(argv[1], "%lf", &size) != 1
|| size <= 0
|| ZERO(size))
{
bu_vls_printf(gedp->ged_result_str, "bad size - %s", argv[1]);
return GED_ERROR;
}
gedp->ged_gvp->gv_size = gedp->ged_wdbp->dbip->dbi_local2base * size;
if (gedp->ged_gvp->gv_size < RT_MINVIEWSIZE)
gedp->ged_gvp->gv_size = RT_MINVIEWSIZE;
gedp->ged_gvp->gv_isize = 1.0 / gedp->ged_gvp->gv_size;
gedp->ged_gvp->gv_scale = 0.5 * gedp->ged_gvp->gv_size;
ged_view_update(gedp->ged_gvp);
return GED_OK;
}
bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage);
return GED_ERROR;
}
int
ged_perspective(struct ged *gedp, int argc, const char *argv[])
{
/* intentionally double for scan */
double perspective;
static const char *usage = "[angle]";
GED_CHECK_DATABASE_OPEN(gedp, GED_ERROR);
GED_CHECK_VIEW(gedp, GED_ERROR);
GED_CHECK_ARGC_GT_0(gedp, argc, GED_ERROR);
/* initialize result */
bu_vls_trunc(gedp->ged_result_str, 0);
/* get the perspective angle */
if (argc == 1) {
bu_vls_printf(gedp->ged_result_str, "%g", gedp->ged_gvp->gv_perspective);
return GED_OK;
}
/* set perspective angle */
if (argc == 2) {
if (sscanf(argv[1], "%lf", &perspective) != 1) {
bu_vls_printf(gedp->ged_result_str, "bad perspective angle - %s", argv[1]);
return GED_ERROR;
}
gedp->ged_gvp->gv_perspective = perspective;
if (SMALL_FASTF < gedp->ged_gvp->gv_perspective) {
ged_persp_mat(gedp->ged_gvp->gv_pmat, gedp->ged_gvp->gv_perspective,
(fastf_t)1.0f, (fastf_t)0.01f, (fastf_t)1.0e10f, (fastf_t)1.0f);
} else {
MAT_COPY(gedp->ged_gvp->gv_pmat, bn_mat_identity);
}
ged_view_update(gedp->ged_gvp);
return GED_OK;
}
bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage);
return GED_ERROR;
}
int
ged_reopen(struct ged *gedp, int argc, const char *argv[])
{
struct db_i *dbip;
static const char *usage = "[filename]";
GED_CHECK_DATABASE_OPEN(gedp, GED_ERROR);
GED_CHECK_ARGC_GT_0(gedp, argc, GED_ERROR);
/* initialize result */
bu_vls_trunc(gedp->ged_result_str, 0);
/* get database filename */
if (argc == 1) {
bu_vls_printf(gedp->ged_result_str, "%s", gedp->ged_wdbp->dbip->dbi_filename);
return GED_OK;
}
/* set database filename */
if (argc == 2) {
char *av[2];
if ((dbip = _ged_open_dbip(argv[1], 0)) == DBI_NULL) {
bu_vls_printf(gedp->ged_result_str, "ged_reopen: failed to open %s\n", argv[1]);
return GED_ERROR;
}
av[0] = "zap";
av[1] = (char *)0;
ged_zap(gedp, 1, (const char **)av);
/* close current database */
db_close(gedp->ged_wdbp->dbip);
gedp->ged_wdbp->dbip = dbip;
bu_vls_printf(gedp->ged_result_str, "%s", gedp->ged_wdbp->dbip->dbi_filename);
return GED_OK;
}
bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage);
return GED_ERROR;
}
