aycore.h

Go to the documentation of this file.

#ifndef __aycore_h__
#define __aycore_h__
/*
 * Ayam, a free 3D modeler for the RenderMan interface.
 *
 * Ayam is copyrighted 1998-2005 by Randolf Schultz
 * (randolf.schultz@gmail.com) and others.
 *
 * All rights reserved.
 *
 * See the file License for details.
 *
 */

/* aycore.h - prototypes of core functions */


/* bbc.c */

int ay_bbc_get(ay_object *o, double *bbox);

int ay_bbc_fromarr(double *arr, int len, int stride, double *bbox);

int ay_bbc_fromlist(ay_object *o, int update, double *bbox);

int ay_bbc_gettcmd(ClientData clientData, Tcl_Interp *interp,
                   int argc, char *argv[]);

/* clear.c */

int ay_clear_scene(void);

int ay_clear_scenetcmd(ClientData clientData, Tcl_Interp *interp,
                       int argc, char *argv[]);


/* clevel.c */

void ay_clevel_set(ay_object *o);

int ay_clevel_find(ay_object *c, ay_object *o, int *found);

int ay_clevel_add(ay_object *o);

void ay_clevel_del(void);

void ay_clevel_delall(void);

void ay_clevel_gotop(void);

int ay_clevel_gotoptcmd(ClientData clientData, Tcl_Interp *interp,
                        int argc, char *argv[]);

int ay_clevel_gouptcmd(ClientData clientData, Tcl_Interp *interp,
                       int argc, char *argv[]);

int ay_clevel_godowntcmd(ClientData clientData, Tcl_Interp *interp,
                         int argc, char *argv[]);

int ay_clevel_gettcmd(ClientData clientData, Tcl_Interp *interp,
                      int argc, char *argv[]);

int ay_clevel_cltcmd(ClientData clientData, Tcl_Interp *interp,
                     int argc, char *argv[]);

int ay_clevel_getparentpatch(ay_object **p);

int ay_clevel_getparentbounds(double *uvmm);


/* clipb.c */

int ay_clipb_clear(char *fname);

int ay_clipb_cleartcmd(ClientData clientData, Tcl_Interp *interp,
                       int argc, char *argv[]);

int ay_clipb_copytcmd(ClientData clientData, Tcl_Interp *interp,
                      int argc, char *argv[]);

int ay_clipb_cuttcmd(ClientData clientData, Tcl_Interp *interp,
                     int argc, char *argv[]);

int ay_clipb_pastetcmd(ClientData clientData, Tcl_Interp *interp,
                       int argc, char *argv[]);

int ay_clipb_replacetcmd(ClientData clientData, Tcl_Interp *interp,
                         int argc, char *argv[]);

int ay_clipb_hmovtcmd(ClientData clientData, Tcl_Interp *interp,
                      int argc, char *argv[]);

void ay_clipb_prepend(ay_object *o, char *fname);


/* comp.c */

int ay_comp_strcase(const char *s1, const char *s2);

int ay_comp_register(ay_comparecb *compcb, unsigned int type_id);

int ay_comp_init(void);

int ay_comp_objects(ay_object *o1, ay_object *o2);

int ay_comp_trafos(ay_object *o1, ay_object *o2);

int ay_comp_tags(ay_object *o1, ay_object *o2);


/* convert.c */

int ay_convert_register(ay_convertcb *convcb, unsigned int type_id);

int ay_convert_object(ay_object *o, int in_place);

int ay_convert_objecttcmd(ClientData clientData, Tcl_Interp *interp,
                          int argc, char *argv[]);

int ay_convert_nptoolobj(ay_object *o, ay_object *p, ay_object *cb,
                         int in_place);

int ay_convert_nptoolobjwithholes(ay_object *o, ay_object *p, ay_object *cb,
                                  int in_place);


/* draw.c */

void ay_draw_object(struct Togl *togl, ay_object *o, int selected);

int ay_draw_view(struct Togl *togl, int draw_offset);

void ay_draw_grid(struct Togl *togl);

void ay_draw_arrow(struct Togl *togl, double *from, double *to);

void ay_draw_bgimage(struct Togl *togl);

void ay_draw_needredraw(ay_list_object *oldsel, ay_list_object *newsel,
                        int *result);

void ay_draw_trimview(ay_view_object *view);

void ay_draw_rectangle(int winwidth, int winheight,
                       double xmin, double ymin,
                       double xmax, double ymax);

void ay_draw_cs(struct Togl *togl, int mode);

void ay_draw_mark(struct Togl *togl);

int ay_draw_registerdacb(ay_drawcb *dacb, unsigned int type_id);

void ay_draw_silhouettes(struct Togl *togl, unsigned char *silimg);

void ay_draw_selmp(ay_object *o, int is_rat, ay_mpoint *mp);

void ay_draw_rhombus(double *pnt);

void ay_draw_linestrip(struct Togl *togl, int n, int stride, double *cv);

void ay_draw_axis(struct Togl *togl, int axis);


/* error.c */

void ay_error(int code, const char *where, const char *what);

int ay_error_tcmd(ClientData clientData, Tcl_Interp *interp,
                  int argc, char *argv[]);

int ay_error_openlog(void);

int ay_error_closelog(void);

void ay_error_writelog(char *message);

int ay_error_logtcmd(ClientData clientData, Tcl_Interp *interp,
                     int argc, char *argv[]);

int  ay_error_outtcmd(ClientData clientData, Tcl_Interp *interp,
                      int argc, char *argv[]);

void ay_error_glucb(GLenum err);

int ay_error_reportdrange(char *fname, char *pname, double lb, double ub);

int ay_error_reportirange(char *fname, char *pname, int lb, int ub);

int ay_error_reportobject(int ecode, char *fname, ay_object *o);

void ay_error_reportnan(char *fname, char *pname);

int ay_error_printglerrortcmd(ClientData clientData, Tcl_Interp *interp,
                              int argc, char *argv[]);


/* geom.c */

int ay_geom_intersectlines3D(double *p1, double *t1,
                             double *p2, double *t2,
                             double *p);

int ay_geom_intersectlines2D(double *p1, double *t1,
                             double *p2, double *t2,
                             double *p);

void ay_geom_pointstoplane(double x1, double y1, double z1,
                           double x2, double y2, double z2,
                           double x3, double y3, double z3,
                           double *A, double *B, double *C, double *D);

void ay_geom_normalfrom3pnts(double *p1, double *p2, double *p3, double *n);

void ay_geom_normalfrom4pnts(double *p1, double *p2, double *p3, double *p4,
                             double *n);

int ay_geom_extractmiddlepoint(int mode, double *cv, int cvlen, int cvstride,
                               double **tcv, double *result);

int ay_geom_extractmeannormal(double *cv, int cvlen, int cvstride,
                              double *m, double *result);

void ay_geom_scalecog(double scale, double *cv, int len, int stride);

int ay_geom_computecccenter(double *A, double *B, double *C, double *c);


/* instt.c */

int ay_instt_createoidht(ay_object *o);

void ay_instt_connect(ay_object *o, ay_object **last);

int ay_instt_createoid(char **dest);

int ay_instt_createorigids(ay_object *o);

int ay_instt_createinstanceids(ay_object *o);

int ay_instt_clearoidtags(ay_object *o);

void ay_instt_removeinstances(ay_object **o, ay_object *m);

void ay_instt_clearclipboard(ay_object *o);

int ay_instt_wribiarchives(char *file, ay_object *o);

int ay_instt_resolvetcmd(ClientData clientData, Tcl_Interp *interp,
                         int argc, char *argv[]);

int ay_instt_checkinstance(ay_object *o, ay_object *target,
                           ay_object *instance, int *check_this_tree);

int ay_instt_check(ay_object *o, ay_object *target);

int ay_instt_getmastertcmd(ClientData clientData, Tcl_Interp *interp,
                           int argc, char *argv[]);

void ay_instt_countrefs(ay_object *o, ay_object *m, unsigned int *refs);

void ay_instt_countrefslist(ay_list_object *l, ay_object *m,
                            unsigned int *refs);

void ay_instt_init(Tcl_Interp *interp);


/* interpol.c */

int ay_interpol_2DA4DIC(ay_nurbpatch_object *np, int w, int h,
                        double *st, double *en, double *ta);

int ay_interpol_1DA4DIC(ay_nurbcurve_object *nc, int len, double *st,
                        double *en, double *ta);

int ay_interpol_1DA4D(double p, int len, double *st, double *en, double *ta);

int ay_interpol_1DA1D(double p, int len, double *st, double *en, double *ta);

void ay_interpol_trafos(double p, ay_object *o1, ay_object *o2, ay_object *ta);

int ay_interpol_ncurves(double p, ay_object *c1, ay_object *c2, ay_object *ic,
                        ay_object **ta);

int ay_interpol_curvestcmd(ClientData clientData, Tcl_Interp *interp,
                           int argc, char *argv[]);


int ay_interpol_npatches(double r, ay_object *p1, ay_object *p2,
                         ay_object *ic, ay_object **ta);

int ay_interpol_surfacestcmd(ClientData clientData, Tcl_Interp *interp,
                             int argc, char *argv[]);


/* notify.c */

int ay_notify_register(ay_notifycb *notcb, unsigned int type_id);

int ay_notify_parent(void);

int ay_notify_object(ay_object *o);

int ay_notify_parentof(ay_object *o, int silent);

int ay_notify_objecttcmd(ClientData clientData, Tcl_Interp *interp,
                         int argc, char *argv[]);

int ay_notify_findparents(ay_object *o, ay_object *r,
                          ay_list_object **parents);

int ay_notify_complete(ay_object *r);

void ay_notify_block(int scope, int block);

int ay_notify_objectsafetcmd(ClientData clientData, Tcl_Interp *interp,
                             int argc, char *argv[]);

/* ns.c */

Tk_RestrictAction ay_ns_restrictall(ClientData clientData,
                                    XEvent *eventPtr);

void ay_ns_execute(ay_object *o, ay_tag *tag);

int ay_ns_disable(ay_tag *tag);

void ay_ns_init(Tcl_Interp *interp);


/* oact.c */

int ay_oact_parseargs(struct Togl *togl, int argc, char *argv[], char *fname,
                      double *winx, double *winy,
                      double *owinx, double *owiny);

int ay_oact_movetcb(struct Togl *togl, int argc, char *argv[]);

int ay_oact_rottcb(struct Togl *togl, int argc, char *argv[]);

int ay_oact_rotatcb(struct Togl *togl, int argc, char *argv[]);

int ay_oact_sc1DXcb(struct Togl *togl, int argc, char *argv[]);

int ay_oact_sc1DXAcb(struct Togl *togl, int argc, char *argv[]);

int ay_oact_sc1DYcb(struct Togl *togl, int argc, char *argv[]);

int ay_oact_sc1DYAcb(struct Togl *togl, int argc, char *argv[]);

int ay_oact_sc1DZcb(struct Togl *togl, int argc, char *argv[]);

int ay_oact_sc1DZAcb(struct Togl *togl, int argc, char *argv[]);

int ay_oact_sc2Dcb(struct Togl *togl, int argc, char *argv[]);

int ay_oact_sc3Dcb(struct Togl *togl, int argc, char *argv[]);

int ay_oact_str2Dcb(struct Togl *togl, int argc, char *argv[]);

int ay_oact_sc2DAcb(struct Togl *togl, int argc, char *argv[]);

int ay_oact_str2DAcb(struct Togl *togl, int argc, char *argv[]);

int ay_oact_sc3DAcb(struct Togl *togl, int argc, char *argv[]);


/* object.c */

void ay_object_defaults(ay_object *o);

void ay_object_place(ay_object *o, int place_at);

void ay_object_align(ay_object *o, int align_to);

int ay_object_placetcmd(ClientData clientData, Tcl_Interp *interp,
                        int argc, char *argv[]);

int ay_object_aligntcmd(ClientData clientData, Tcl_Interp *interp,
                        int argc, char *argv[]);

int ay_object_create(unsigned int index, ay_object **o);

int ay_object_createargs(unsigned int index, int argc, char **argv,
                         ay_object **o);

int ay_object_createtcmd(ClientData clientData, Tcl_Interp *interp,
                         int argc, char *argv[]);

int ay_object_delete(ay_object *o);

int ay_object_deletemulti(ay_object *o, int force);

int ay_object_deletetcmd(ClientData clientData, Tcl_Interp *interp,
                         int argc, char *argv[]);

void ay_object_link(ay_object *o);

void ay_object_unlink(ay_object *o);

char *ay_object_gettypename(unsigned int index);


char *ay_object_getname(ay_object *o);

int ay_object_setnametcmd(ClientData clientData, Tcl_Interp *interp,
                          int argc, char *argv[]);

int ay_object_copy(ay_object *src, ay_object **dst);

int ay_object_copymulti(ay_object *src, ay_object **dst);

int ay_object_ishastcmd(ClientData clientData, Tcl_Interp *interp,
                        int argc, char *argv[]);

int ay_object_gettypetcmd(ClientData clientData, Tcl_Interp *interp,
                          int argc, char *argv[]);

int ay_object_getnametcmd(ClientData clientData, Tcl_Interp *interp,
                          int argc, char *argv[]);

int ay_object_crtendlevel(ay_object **o);

int ay_object_replace(ay_object *src, ay_object *dst);

unsigned int ay_object_count(ay_object *o);

int ay_object_candelete(ay_object *p, ay_object *o);

int ay_object_candeletelist(ay_list_object *l, ay_object *o);

int ay_object_getpathname(ay_object *o, ay_object *h,
                          size_t *totallen, int *found, char **result);

int ay_object_find(ay_object *o, ay_object *h);


/* otype.c */

int ay_otype_registercore(char *name,
                          ay_createcb  *crtcb,
                          ay_deletecb  *delcb,
                          ay_copycb    *copycb,
                          ay_drawcb    *drawcb,
                          ay_drawcb    *drawhcb,
                          ay_drawcb    *shadecb,
                          ay_propcb    *setpropcb,
                          ay_propcb    *getpropcb,
                          ay_getpntcb  *getpntcb,
                          ay_readcb    *readcb,
                          ay_writecb   *writecb,
                          ay_wribcb    *wribcb,
                          ay_bbccb     *bbccb,
                          unsigned int type_index);

int ay_otype_register(char *name,
                      ay_createcb  *crtcb,
                      ay_deletecb  *delcb,
                      ay_copycb    *copycb,
                      ay_drawcb    *drawcb,
                      ay_drawcb    *drawhcb,
                      ay_drawcb    *shadecb,
                      ay_propcb    *setpropcb,
                      ay_propcb    *getpropcb,
                      ay_getpntcb  *getpntcb,
                      ay_readcb    *readcb,
                      ay_writecb   *writecb,
                      ay_wribcb    *wribcb,
                      ay_bbccb     *bbccb,
                      unsigned int *type_index);

unsigned int *ay_otype_getpointer(unsigned int id);

int ay_otype_init();


/* matt.c */

void ay_matt_init(Tcl_Interp *interp);

int ay_matt_registermaterial(char *name, ay_mat_object *mat);

int ay_matt_deregister(char *name);

int ay_matt_getmaterial(char *name, ay_mat_object **material);

void ay_matt_removeallrefs(ay_object *o);

void ay_matt_removerefs(ay_object *o, ay_mat_object *material);

void ay_matt_removecliprefs(ay_object *o);

void ay_matt_connect(ay_object *o);

int ay_matt_creatematerialids(ay_object *o);

int ay_matt_clearmaterialids(ay_object *o);

int ay_matt_wrib(ay_object *o);

void ay_matt_nomaterial(unsigned int type);

int ay_matt_mayhavematerial(unsigned int type);

void ay_matt_clearshaders(ay_mat_object *material);

int ay_matt_getregisteredtcmd(ClientData clientData, Tcl_Interp *interp,
                              int argc, char *argv[]);

int ay_matt_set(char *matname, ay_object *o);


/* pact.c */

void ay_pact_clearpointedit(ay_pointedit *pe);

double ay_pact_getminlevelscale();

int ay_pact_getpoint(int mode, ay_object *o, double *obj, ay_pointedit *pe);

int ay_pact_pickpoint(ay_object *o, ay_view_object *view,
                      double minlevelscale, double *obj, ay_pointedit *pe);

int ay_pact_seltcb(struct Togl *togl, int argc, char *argv[]);

int ay_pact_selboundtcb(struct Togl *togl, int argc, char *argv[]);

int ay_pact_insertptcb(struct Togl *togl, int argc, char *argv[]);

int ay_pact_deleteptcb(struct Togl *togl, int argc, char *argv[]);

int ay_pact_startpetcb(struct Togl *togl, int argc, char *argv[]);

int ay_pact_pentcb(struct Togl *togl, int argc, char *argv[]);

void ay_pact_griddify(double *n, double grid);

void ay_pact_flashpoint(int ignore_old, int multiple, double *pnt, ay_object *o);

int ay_pact_petcb(struct Togl *togl, int argc, char *argv[]);

int ay_pact_wetcb(struct Togl *togl, int argc, char *argv[]);

int ay_pact_wrtcb(struct Togl *togl, int argc, char *argv[]);

int ay_pact_snaptogridcb(struct Togl *togl, int argc, char *argv[]);

int ay_pact_snaptomarkcb(struct Togl *togl, int argc, char *argv[]);

int ay_pact_multiptcb(struct Togl *togl, int argc, char *argv[]);

int ay_pact_insertac(ay_acurve_object *curve, int *index,
                     double *objXYZ, int edit);

int ay_pact_insertnc(ay_nurbcurve_object *curve, int *index,
                     double *objXYZ, int edit);

int ay_pact_deleteac(ay_acurve_object *acurve, int *index,
                     double *objXYZ);

int ay_pact_deletenc(ay_nurbcurve_object *curve, int *index, double *objXYZ);

int ay_pact_registerinsert(ay_inspntcb *inscb, unsigned int type_id);

int ay_pact_registerdelete(ay_delpntcb *delcb, unsigned int type_id);

int ay_pact_init(Tcl_Interp *interp);


/* peek.c */

int ay_peek_register(ay_peekcb *peekcb, unsigned int type_id);

ay_object *ay_peek_singleobject(ay_object *o, unsigned int type);

int ay_peek_object(ay_object *o, unsigned int type, ay_object ***objrefs,
                   double **transforms);

int ay_peek_settag(ay_object *o, ay_object *p);


/* pomesht.c */

int ay_pomesht_destroy(ay_pomesh_object *pomesh);

int ay_pomesht_tesselate(ay_pomesh_object *pomesh);

int ay_pomesht_tesselatesel(ay_pomesh_object *pomesh);

int ay_pomesht_merge(int merge_pv_tags, ay_list_object *list,
                     ay_object **result);

int ay_pomesht_mergetcmd(ClientData clientData, Tcl_Interp *interp,
                         int argc, char *argv[]);

int ay_pomesht_optimizecoords(ay_pomesh_object *pomesh, double normal_epsilon,
                              ay_point *selp,
                              unsigned int *ois, unsigned int *oislen);

int ay_pomesht_optimizetcmd(ClientData clientData, Tcl_Interp *interp,
                            int argc, char *argv[]);

int ay_pomesht_tosdmesh(ay_pomesh_object *pomesh, ay_sdmesh_object **sdmesh);

int ay_pomesht_splitface(ay_pomesh_object *pomesh, unsigned int f,
                         ay_pomesh_object *target);

int ay_pomesht_split(ay_pomesh_object *pomesh,
                     ay_pomesh_object **result);

int ay_pomesht_splittcmd(ClientData clientData, Tcl_Interp *interp,
                         int argc, char *argv[]);

int ay_pomesht_genfacenormals(ay_pomesh_object *po, double **result);

int ay_pomesht_gensmoothnormals(ay_pomesh_object *po, double **result);

int ay_pomesht_remsmoothnormals(ay_pomesh_object *po);

int ay_pomesht_gennormtcmd(ClientData clientData, Tcl_Interp *interp,
                           int argc, char *argv[]);

void ay_pomesht_fliploops(ay_pomesh_object *po);

void ay_pomesht_flipnormals(ay_pomesh_object *po);

int ay_pomesht_connecttcmd(ClientData clientData, Tcl_Interp *interp,
                           int argc, char *argv[]);

int ay_pomesht_selectbound(ay_pomesh_object *po, ay_point *selp);

int ay_pomesht_applytrafo(ay_object *o);

int ay_pomesht_hasonlyngons(ay_pomesh_object *po, unsigned int n);

int ay_pomesht_quadrangulatetcmd(ClientData clientData, Tcl_Interp *interp,
                                 int argc, char *argv[]);

int ay_pomesht_selectface(ay_object *o, unsigned int face, int mode);

int ay_pomesht_pickfacecb(struct Togl *togl, int argc, char *argv[]);

int ay_pomesht_drawself(struct Togl *togl, ay_object *o);

int ay_pomesht_selfacetcmd(ClientData clientData, Tcl_Interp *interp,
                           int argc, char *argv[]);


/* prefs.c */

int ay_prefs_gettcmd(ClientData clientData, Tcl_Interp *interp,
                     int argc, char *argv[]);

int ay_prefs_settcmd(ClientData clientData, Tcl_Interp *interp,
                     int argc, char *argv[]);


/* prop.c */

int ay_prop_gettcmd(ClientData clientData, Tcl_Interp *interp,
                    int argc, char *argv[]);

int ay_prop_settcmd(ClientData clientData, Tcl_Interp *interp,
                    int argc, char *argv[]);

int ay_prop_gettrafotcmd(ClientData clientData, Tcl_Interp *interp,
                         int argc, char *argv[]);

int ay_prop_settrafotcmd(ClientData clientData, Tcl_Interp *interp,
                         int argc, char *argv[]);

int ay_prop_getattrtcmd(ClientData clientData, Tcl_Interp *interp,
                        int argc, char *argv[]);

int ay_prop_setattrtcmd(ClientData clientData, Tcl_Interp *interp,
                        int argc, char *argv[]);

int ay_prop_getmattcmd(ClientData clientData, Tcl_Interp *interp,
                       int argc, char *argv[]);

int ay_prop_setmattcmd(ClientData clientData, Tcl_Interp *interp,
                       int argc, char *argv[]);

int ay_prop_getnpinfo(Tcl_Interp *interp, char *n1, ay_object *o);

int ay_prop_getncinfo(Tcl_Interp *interp, char *n1, ay_object *o);

int ay_prop_parseexpression(Tcl_Obj *to, char *fname, double oldval,
                            double *newval);


/* provide.c */

int ay_provide_register(ay_providecb  *provcb, unsigned int type_id);

int ay_provide_object(ay_object *o, unsigned int type, ay_object **result);

int ay_provide_nptoolobj(ay_object *o, unsigned int type,
                         ay_object *npatch, ay_object *cb,
                         ay_object **result);


/* pv.c */

int ay_pv_filltokpar(ay_object *o, int declare, int start,
                     int *added, RtToken tokens[], RtPointer parms[]);

int ay_pv_add(ay_object *o,
              const char *name, const char *detail, const char *type,
              int datalen, int stride, void *data);

int ay_pv_merge(ay_tag *t1, ay_tag *t2, ay_tag **mt);

int ay_pv_mergeinto(ay_tag *t1, ay_tag *t2);

int ay_pv_cmpndt(ay_tag *t1, ay_tag *t2);

int ay_pv_checkndt(ay_tag *t, const char *name, const char *detail,
                   const char *type);

int ay_pv_getdetail(ay_tag *t, char **detail);

int ay_pv_gettype(ay_tag *t);

int ay_pv_convert(ay_tag *tag, int type, unsigned int *datalen, void **data);

int ay_pv_getst(ay_object *o, char *mys, char *myt, int type, void **data,
                unsigned int *datalen);

int ay_pv_getvc(ay_object *o, char *myc, int stride,
                unsigned int *datalen, void **data);

int ay_pv_count(ay_object *o);

void ay_pv_fixnumelems(char *buf, unsigned int numelems);

void ay_pv_init(Tcl_Interp *interp);


/* quat.c */

void ay_quat_axistoquat(double a[3], double phi, double q[4]);

void ay_quat_norm(double q[4]);

void ay_quat_add(double q1[4], double q2[4], double dest[4]);

void ay_quat_torotmatrix(double q[4], double m[16]);

void ay_quat_toeuler(double q[4], double euler[3]);

void ay_quat_slerp(double t, double q1[4], double q2[4], double r[4]);

double ay_quat_dot(double q1[4], double q2[4]);

void ay_quat_inv(double q[4]);


/* read.c */

int ay_read_string(FILE *fileptr, char **result);

int ay_read_unistring(FILE *fileptr, Tcl_UniChar **result);

int ay_read_skip(FILE *fileptr);

int ay_read_header(FILE *fileptr);

int ay_read_attributes(FILE *fileptr, ay_object *o);

int ay_read_tags(FILE *fileptr, ay_object *o);

int ay_read_shader(FILE *fileptr, ay_shader **result);

int ay_read_object(FILE *fileptr);

int ay_read_scene(Tcl_Interp *interp, char *filename, int insert);

int ay_read_replacetcmd(ClientData clientData, Tcl_Interp *interp,
                        int argc, char *argv[]);

int ay_read_inserttcmd(ClientData clientData, Tcl_Interp *interp,
                       int argc, char *argv[]);


/* riattr.c */

int ay_riattr_wrib(ay_object *o);

void ay_riattr_init(Tcl_Interp *interp);


/* riopt.c */

int ay_riopt_wrib(ay_object *o);

void ay_riopt_init(Tcl_Interp *interp);


/* sdmesht.c */

int ay_sdmesht_tesselate(ay_sdmesh_object *sdmesh);

int ay_sdmesht_topolymesh(ay_sdmesh_object *sdmesh, ay_pomesh_object **pomesh);


/* sel.c */

void ay_sel_free(int clear_selflag);

int ay_sel_add(ay_object *o, int set_selflag);

int ay_sel_selobtcmd(ClientData clientData, Tcl_Interp *interp,
                     int argc, char *argv[]);

int ay_sel_getseltcmd(ClientData clientData, Tcl_Interp *interp,
                      int argc, char *argv[]);

int ay_sel_hsltcmd(ClientData clientData, Tcl_Interp *interp,
                   int argc, char *argv[]);

int ay_sel_hsptcmd(ClientData clientData, Tcl_Interp *interp,
                   int argc, char *argv[]);

void ay_sel_clearselflag(ay_object *o);

void ay_sel_clean();


/* selp.c */

void ay_selp_clear(ay_object *o);

void ay_selp_copy(ay_point *pnt, ay_point **res);

int ay_selp_selall(ay_object *o);

int ay_selp_applytrafotcmd(ClientData clientData, Tcl_Interp *interp,
                           int argc, char *argv[]);

int ay_selp_invert(ay_object *o);

int ay_selp_inverttcmd(ClientData clientData, Tcl_Interp *interp,
                       int argc, char *argv[]);

int ay_selp_center(ay_point *p, int dim, double *center);

int ay_selp_getcenter(ay_point *p, int mode, double *center);

int ay_selp_centertcmd(ClientData clientData, Tcl_Interp *interp,
                       int argc, char *argv[]);

int ay_selp_sel(ay_object *o, unsigned int indiceslen, unsigned int *indices);

int ay_selp_seltcmd(ClientData clientData, Tcl_Interp *interp,
                    int argc, char *argv[]);

int ay_selp_rem(ay_object *o, unsigned int index);

int ay_selp_ins(ay_object *o, unsigned int index);

int ay_selp_getpnts(int mode, ay_object *o, double *p, ay_pointedit *pe,
                    int readonly, int arrlen, int stride, int ishom,
                    double *arr);

void ay_selp_selectmpnc(ay_object *o, int select_all);

void ay_selp_normalize(ay_object *o, int digits);

int ay_selp_collapsetcmd(ClientData clientData, Tcl_Interp *interp,
                         int argc, char *argv[]);

int ay_selp_explodetcmd(ClientData clientData, Tcl_Interp *interp,
                        int argc, char *argv[]);

void ay_selp_managelist(ay_object *o, unsigned int *lenptr, double **pntsptr);

int ay_selp_reducetominmax(ay_object *o);

void ay_selp_updatempselection(unsigned int n, ay_point *selp, ay_mpoint *mp);

int ay_selp_find(ay_point *selp, double *point);


/* shade.c */

void ay_shade_object(struct Togl *togl, ay_object *o, int push_name);

int ay_shade_view(struct Togl *togl);


/* shader.c */

#ifdef AYUSESLCARGS

int ay_shader_scanslcsarg(SLC_VISSYMDEF *symbol, Tcl_DString *ds);
#endif


int ay_shader_scanslctcmd(ClientData clientData, Tcl_Interp *interp,
                          int argc, char *argv[]);
#ifdef AYUSESLXARGS

int ay_shader_scanslxsarg(SLX_VISSYMDEF *symbol, Tcl_DString *ds);
#endif

int ay_shader_scanslxtcmd(ClientData clientData, Tcl_Interp *interp,
                          int argc, char *argv[]);

void ay_shader_free(ay_shader *shader);

int ay_shader_copyarg(ay_shader_arg *source, ay_shader_arg **dest);

int ay_shader_copy(ay_shader *source, ay_shader **dest);

int ay_shader_wrib(ay_shader *shader, int type, RtLightHandle *light_handle);

int ay_shader_gettcmd(ClientData clientData, Tcl_Interp *interp,
                      int argc, char *argv[]);

int ay_shader_settcmd(ClientData clientData, Tcl_Interp *interp,
                      int argc, char *argv[]);

int ay_shader_renameforpv(ay_object *o, ay_shader *shader);

void ay_shader_restorename(ay_object *o, ay_shader *shader);


/* table.c */

int ay_table_initftable(ay_ftable *table);

int ay_table_addcallback(ay_ftable *table, ay_voidfp newitem, unsigned int index);

int ay_table_init(ay_otable *table);

int ay_table_additem(ay_otable *table, void *newitem, unsigned int index);


/* tags.c */

void ay_tags_delall(ay_object *o);

void ay_tags_delete(ay_object *o, unsigned int type);

void ay_tags_free(ay_tag *tag);

int ay_tags_copy(ay_tag *source, ay_tag **dest);

int ay_tags_copyall(ay_object *src, ay_object *dst);

void ay_tags_append(ay_object *o, ay_tag *tag);

int ay_tags_register(char *name, unsigned int *result);

int ay_tags_settcmd(ClientData clientData, Tcl_Interp *interp,
                    int argc, char *argv[]);

int ay_tags_addtcmd(ClientData clientData, Tcl_Interp *interp,
                    int argc, char *argv[]);

int ay_tags_gettcmd(ClientData clientData, Tcl_Interp *interp,
                    int argc, char *argv[]);

int ay_tags_hastag(const ay_object *o, const unsigned int tagtype);

int ay_tags_hastcmd(ClientData clientData, Tcl_Interp *interp,
                    int argc, char *argv[]);

void ay_tags_getfirst(const ay_object *o, const unsigned int tagtype,
                      ay_tag **result);

int ay_tags_deletetcmd(ClientData clientData, Tcl_Interp *interp,
                       int argc, char *argv[]);

int ay_tags_parseplist(char *str, int declare, RtInt *argc, RtToken **tokensr,
                       RtPointer **valuesr);

void ay_tags_reconnect(ay_object *o, unsigned int tagtype, char *tagname);

int ay_tags_addnonm(ay_object *o, ay_object *m);

void ay_tags_remnonm(ay_object *o, ay_object *m);

int ay_tags_copyselected(ay_object *src, ay_object *dst,
                         unsigned int *types, int typeslen);

void ay_tags_nltovt(char *str);

void ay_tags_vttonl(char *str);

int ay_tags_registertcmd(ClientData clientData, Tcl_Interp *interp,
                         int argc, char *argv[]);


/* tc.c */

int ay_tc_wrib(ay_object *o);

void ay_tc_init(Tcl_Interp *interp);


/* tcmd.c */

int ay_tcmd_convdlist(Tcl_Interp *interp, char *vname, int *dllen, double **dl);

int ay_tcmd_reverttcmd(ClientData clientData, Tcl_Interp *interp,
                       int argc, char *argv[]);

void ay_tcmd_showhideall(ay_object *o, int val);

int ay_tcmd_showhidetcmd(ClientData clientData, Tcl_Interp *interp,
                         int argc, char *argv[]);

int ay_tcmd_getversionstcmd(ClientData clientData, Tcl_Interp *interp,
                            int argc, char *argv[]);

int ay_tcmd_getbppntfromindex(ay_bpatch_object *patch, int index,
                              double **p);

int ay_tcmd_getpointtcmd(ClientData clientData, Tcl_Interp *interp,
                         int argc, char *argv[]);

int ay_tcmd_getnormaltcmd(ClientData clientData, Tcl_Interp *interp,
                          int argc, char *argv[]);

int ay_tcmd_gettangenttcmd(ClientData clientData, Tcl_Interp *interp,
                           int argc, char *argv[]);

int ay_tcmd_setpointtcmd(ClientData clientData, Tcl_Interp *interp,
                         int argc, char *argv[]);

int ay_tcmd_setnormaltcmd(ClientData clientData, Tcl_Interp *interp,
                          int argc, char *argv[]);

#ifdef AYENABLEWAIT

int ay_tcmd_waitpidtcmd(ClientData clientData, Tcl_Interp *interp,
                        int argc, char *argv[]);
#endif /* AYENABLEWAIT */

#ifdef AYENABLEFEXIT

int ay_tcmd_fastexittcmd(ClientData clientData, Tcl_Interp *interp,
                         int argc, char *argv[]);
#endif /* AYENABLEFEXIT */

int ay_tcmd_withobtcmd(ClientData clientData, Tcl_Interp *interp,
                       int argc, char *argv[]);

int ay_tcmd_registerlang(char *name, unsigned int *result);

int ay_tcmd_getstring(Tcl_Interp *interp, char *arr, char *var, char **result);

int ay_tcmd_getuint(char *str, unsigned int *uint);

int ay_tcmd_menustatetcmd(ClientData clientData, Tcl_Interp *interp,
                          int argc, char *argv[]);

int ay_tcmd_getplanenormaltcmd(ClientData clientData, Tcl_Interp *interp,
                               int argc, char *argv[]);

int ay_tcmd_openclosetcmd(ClientData clientData, Tcl_Interp *interp,
                          int argc, char *argv[]);

int ay_tcmd_refinecoarsentcmd(ClientData clientData, Tcl_Interp *interp,
                              int argc, char *argv[]);

int ay_tcmd_registergeneric(int op, ay_genericcb *cb, unsigned int type_id);

int ay_tcmd_init(Tcl_Interp *interp);

int ay_tcmd_crttoolobjtcmd(ClientData clientData, Tcl_Interp *interp,
                           int argc, char *argv[]);

int ay_tcmd_getpoints(Tcl_Interp *interp, char *fname, char *arg,
                      double **pnts);
#if 0

int ay_tcmd_extendctcmd(ClientData clientData, Tcl_Interp *interp,
                        int argc, char *argv[]);
#endif

/* tgui.c */

void ay_tgui_init(Tcl_Interp *interp);


/* tmp.c */

int ay_tmp_gettcmd(ClientData clientData, Tcl_Interp *interp,
                   int argc, char *argv[]);


/* toglcb.c */

void ay_toglcb_create(struct Togl *togl);

void ay_toglcb_destroy(struct Togl *togl);

void ay_toglcb_reshape(struct Togl *togl);

void ay_toglcb_display(struct Togl *togl);


/* trafo.c */

void ay_trafo_apply3(double *c, double *m);

void ay_trafo_apply3v(double *c, unsigned int clen, unsigned int stride,
                      double *m);

void ay_trafo_apply4(double *c, double *m);

void ay_trafo_apply4v(double *c, unsigned int clen, unsigned int stride,
                      double *m);

void ay_trafo_getparent(ay_list_object *lo, double *tm);

void ay_trafo_getparentinv(ay_list_object *lo, double *tm);

void ay_trafo_getsomeparent(ay_list_object *lo, int what, double *tm);

void ay_trafo_getsomeparentinv(ay_list_object *lo, int what, double *tm);

void ay_trafo_concatparent(ay_list_object *lo);

void ay_trafo_getall(ay_list_object *lo, ay_object *o, double *tm);

int ay_trafo_delegate(ay_object *o);

int ay_trafo_delegatetcmd(ClientData clientData, Tcl_Interp *interp,
                          int argc, char *argv[]);

void ay_trafo_applyall(ay_list_object *lo, ay_object *o, double *p);

void ay_trafo_applyalli(ay_list_object *lo, ay_object *o, double *p);

void ay_trafo_copy(ay_object *src, ay_object *dst);

void ay_trafo_add(ay_object *src, ay_object *dst);

void ay_trafo_defaults(ay_object *o);

int ay_trafo_movtcmd(ClientData clientData, Tcl_Interp *interp,
                     int argc, char *argv[]);

int ay_trafo_scaltcmd(ClientData clientData, Tcl_Interp *interp,
                      int argc, char *argv[]);

int ay_trafo_rottcmd(ClientData clientData, Tcl_Interp *interp,
                     int argc, char *argv[]);

void ay_trafo_multmatrix(double *m1, double *m2);

void ay_trafo_multvectmatrix(double *v, double *m);

int ay_trafo_invmatrix(double *m, double *mi);

int ay_trafo_invgenmatrix(double *m, double *mi);

void ay_trafo_creatematrix(ay_object *o, double *m);

void ay_trafo_decomposematrix(double *m, ay_object *o);

void ay_trafo_identitymatrix(double *m);

int ay_trafo_isidentitymatrix(double *m);

void ay_trafo_translatematrix(double x, double y, double z, double *m);

void ay_trafo_scalematrix(double x, double y, double z, double *m);

void ay_trafo_rotatematrix(double angle, double x, double y, double z,
                           double *m);

void ay_trafo_normalize(ay_object *o, int digits);

int ay_trafo_normalizetcmd(ClientData clientData, Tcl_Interp *interp,
                           int argc, char *argv[]);

double ay_trafo_round(double value, int digits);


/* undo.c */

int ay_undo_init(int buffer_size);

void ay_undo_clear(void);

void ay_undo_clearobj(ay_object *o);

int ay_undo_undotcmd(ClientData clientData, Tcl_Interp *interp,
                     int argc, char *argv[]);


/* vact.c */

int ay_vact_movetcb(struct Togl *togl, int argc, char *argv[]);

int ay_vact_zoomtcb(struct Togl *togl, int argc, char *argv[]);

int ay_vact_moveztcb(struct Togl *togl, int argc, char *argv[]);


/* viewt.c */

void ay_viewt_setupprojection(struct Togl *togl);

void ay_viewt_rotate(ay_view_object *view, double rotx, double roty,
                     double rotz);

void ay_viewt_wintoobj(struct Togl *togl, ay_object *o,
                       double winX, double winY,
                       double *objX, double *objY, double *objZ);

void ay_viewt_winrecttoobj(struct Togl *togl, ay_object *o,
                           double winX, double winY,
                           double winX2, double winY2,
                           double *obj);

void ay_viewt_wintoworld(struct Togl *togl, double winX, double winY,
                         double *worldX, double *worldY, double *worldZ);

int ay_viewt_zoomtoobj(struct Togl *togl, int argc, char *argv[]);

int ay_viewt_align(struct Togl *togl, int argc, char *argv[]);

void ay_viewt_alignlocal(void);

void ay_viewt_redrawall(void);

int ay_viewt_makecurtcb(struct Togl *togl, int argc, char *argv[]);

void ay_viewt_changetype(ay_view_object *view, int type);

int ay_viewt_reshapetcb(struct Togl *togl, int argc, char *argv[]);

int ay_viewt_redrawtcb(struct Togl *togl, int argc, char *argv[]);

int ay_viewt_getconftcb(struct Togl *togl, int argc, char *argv[]);

int ay_viewt_setconftcb(struct Togl *togl, int argc, char *argv[]);

int ay_viewt_updatemark(struct Togl *togl, int local);

void ay_viewt_printmark(ay_view_object *view);

void ay_viewt_updateglobalmark(struct Togl *togl);

void ay_viewt_getglobalmark(double **m);

int ay_viewt_fromcamtcb(struct Togl *togl, int argc, char *argv[]);

int ay_viewt_tocamtcb(struct Togl *togl, int argc, char *argv[]);

void ay_viewt_uprop(ay_view_object *view, int notify);

int ay_viewt_griddify(struct Togl *togl, double *winx, double *winy);

int ay_viewt_droptcb(struct Togl *togl, int argc, char *argv[]);

void ay_viewt_setupintview(int viewnum, ay_object *o, ay_view_object *vtemp);

int ay_viewt_markfromsel(struct Togl *togl);

int ay_viewt_markfromselp(struct Togl *togl, int mode);

int ay_viewt_markfromwin(struct Togl *togl, int argc, char *argv[]);

int ay_viewt_markfromworld(struct Togl *togl, double *world);

int ay_viewt_saveimgtcb(struct Togl *togl, int argc, char *argv[]);

void ay_viewt_warpmouse(struct Togl *togl, double *coord, ay_object *o,
                        double *newwinx, double *newwiny);

void ay_viewt_getrolledup(ay_view_object *view, double *u);

void ay_viewt_worldtowin(double *world, double *win);

int ay_viewt_rendertoviewportcb(struct Togl *togl, int argc, char *argv[]);

void ay_viewt_objrecttoplanes(double *rect, double *plcs);

void ay_viewt_distfromcam(struct Togl *togl, int winx, int winy, double *dist);

void ay_viewt_getcamfromti(ay_tag *tag, int *view_type,
                           ay_camera_object **camera);

void ay_viewt_init(Tcl_Interp *interp);


/* w32t.c */
#ifdef WIN32

int ay_w32t_w32killtcmd(ClientData clientData, Tcl_Interp *interp,
                        int argc, char *argv[]);

int ay_w32t_w32pstcmd(ClientData clientData, Tcl_Interp *interp,
                      int argc, char *argv[]);

FILE *ay_w32t_openpipe(char *pipe);

int ay_w32t_w32screengeomtcmd(ClientData clientData, Tcl_Interp *interp,
                              int argc, char *argv[]);

/* As long as we do not use the return value...
 */
#define snprintf sprintf_s

#endif


/* wrib.c */

int ay_wrib_isprimitive(ay_object *o);

void ay_wrib_aimz(RtPoint direction);

void ay_wrib_placecamera(RtPoint position, RtPoint direction, double roll);

void ay_wrib_rioptions(int searchpathsonly);

int ay_wrib_checklights(ay_object *o);

int ay_wrib_alllights(char *file);

int ay_wrib_rootsh(int imager);

int ay_wrib_defmat(void);

void ay_wrib_trafos(ay_object *o);

int ay_wrib_object(char *file, ay_object *o);

int ay_wrib_toolobject(char *file, ay_object *o, ay_object *t);

int ay_wrib_caporbevel(char *file, ay_object *o, ay_object *c, unsigned int ci);

char *ay_wrib_geniafilename(char *base, char *oi);

int ay_wrib_refobject(char *file, ay_object *o);

int ay_wrib_scene(char *file, char *image, char *driver, char *hider,
                  int temp, int target,
                  double *from, double *to,
                  double roll, double zoom, double nearp, double farp,
                  int width, int height, int type);

int ay_wrib_viewtcb(struct Togl *togl, int argc, char *argv[]);

void ay_wrib_displaytags(int have_ridisplay);

void ay_wrib_hidertags(void);

int ay_wrib_tcmd(ClientData clientData, Tcl_Interp *interp,
                 int argc, char *argv[]);

#ifdef AYENABLEPPREV

int ay_wrib_pprevdraw(ay_view_object *view);

int ay_wrib_pprevopen(ay_view_object *view);

void ay_wrib_pprevclose();
#endif

void ay_wrib_init(Tcl_Interp *interp);


/* write.c */

int ay_write_header(FILE *fileptr);

int ay_write_attributes(FILE *fileptr, ay_object *o);

int ay_write_tags(FILE *fileptr, ay_object *o);

void ay_write_shader(FILE *fileptr, ay_shader *shader);

int ay_write_object(FILE *fileptr, ay_object *o);

int ay_write_scene(char *fname, int selected);

int ay_write_scenetcmd(ClientData clientData, Tcl_Interp *interp,
                       int argc, char *argv[]);

/* ayam.c */

int ay_checkversion(char *fname, char *version_ma, char *version_mi);

#endif /* __aycore_h__ */

---