#include #include #include #include #include #include #include /*{{{ banner*/ /* ************************************************** Copyright DIVISION Limited (c) 1994 All rights reserved File : dpl.c Project : dpl interface host / platform independent section Author : PJA Date : 22/06/94 Function: Implements the host section of the dpl interface History : Rev 1.1, 22 / 06 / 1994 **************************** */ /*}}} */ /*{{{ statics holding dpl state*/ static dpl_SCENE the_scene; static dpl_cache_mode __dpl_cache_mode; static dpl_FILEPATH *geometry_filepath=NULL; static dpl_FILEPATH *texture_filepath =NULL; /* needs to be visible to dpl_host */ int32 dpl_WarningLevel=0; static int32 dpl_inited=0; static char dpl_errmess[256]; static int dpl_err=0; /*}}} */ /*{{{ errors*/ #define check_inited(ret) if (dpl_inited == 0) return ret #define check_inited_noret() if (dpl_inited == 0) return /* interface should just STOP on error */ #define dpl_error dpl_inited=0; dpl_err=1; sprintf /*}}} */ /*{{{ support functions*/ #define inc_ref(node) if (node) ((dpl_node *) node)->ref_count++; #define dec_ref(node) if (node) ((dpl_node *) node)->ref_count--; #define uncover(n) \ if (((dpl_node *)(n))->hidden) dpl_Unhide(n) #define do_flush (__dpl_cache_mode == dpl_cache_mode_write_thru) #define flush_node(n) if (do_flush) dpl_Flush(n) /*{{{ static dpl_list *new_list ( dpl_node *item )*/ static dpl_list *new_list ( dpl_node *item ) { dpl_list *l; l=malloc(sizeof(dpl_list)); if (l) { init_list (l, item ); return l; } else return NULL; } /*}}} */ /*{{{ void init_list ( dpl_list *list, dpl_node *item )*/ static void init_list ( dpl_list *list, dpl_node *item ) { if (list) { list->next=NULL; list->prev=NULL; list->item=item; list->type_check=item->type_check; } else { dpl_error ( dpl_errmess, "Attempt to init NULL list\n" ); } } /*}}} */ /*{{{ void init_superlist ( dpl_superlist *list, dpl_type type )*/ static void init_superlist ( dpl_node *node, dpl_superlist *list, dpl_type type ) { if (list) { list->dplnode=node; list->last_accessed=NULL; list->tail=NULL; list->head=NULL; } else { dpl_error ( dpl_errmess, "Attempt to init NULL superlist\n" ); } } /*}}} */ /*{{{ static dpl_node *get_first ( dpl_superlist *list )*/ static dpl_node *get_first ( dpl_superlist *list ) { if (list) { list->last_accessed=list->head; if (list->head) return list->head->item; else return NULL; } else { dpl_error ( dpl_errmess, "Attempt to get first on NULL superlist\n" ); return NULL; } } /*}}} */ /*{{{ static void *get_next ( dpl_superlist *list )*/ static void *get_next ( dpl_superlist *list ) { dpl_list *last=list->last_accessed; if (last) { last=last->next; list->last_accessed=last; if (last) return last->item; else return NULL; } else { dpl_error ( dpl_errmess, "Attempt to get next on NULL superlist\n" ); return NULL; } } /*}}} */ /*{{{ static void add_item ( dpl_superlist *list, dpl_node *item )*/ static void add_item ( dpl_superlist *list, dpl_node *item ) { if (list) { dpl_list *l=new_list(item); /* do ghost operation */ ghost_dpl_add_list_item ( list, item ); /* add to tail */ if (list->head == list->tail) { if (list->head) { /* just one item in list - make me tail */ list->tail->next=l; l->next=NULL; l->prev=list->tail; list->tail=l; } else { /* no items in list - make me head and tail */ list->head=l; list->tail=l; } } else { list->tail->next=l; l->prev=list->tail; l->next=NULL; list->tail=l; } l->item=item; item->ref_count++; } else { dpl_error ( dpl_errmess, "Attempt to add to NULL superlist\n" ); } } /*}}} */ /*{{{ static dpl_list *find_item ( dpl_superlist *list, dpl_node *item )*/ static dpl_list * find_item ( dpl_superlist *list, dpl_node *item ) { if (list) { dpl_list *l=list->head; if (l) { while (l->item != item) { l=l->next; if (l==NULL) { return NULL; } } return l; } return NULL; } else { dpl_error ( dpl_errmess, "Attempt to find item in NULL superlist\n" ); return NULL; } } /*}}} */ /*{{{ unlink_superlist_item ( dpl_superlist *list, dpl_list *l )*/ static void unlink_superlist_item ( dpl_superlist *list, dpl_list *l ) { /* l points at list item to remove */ if (l==list->head) { /* I am head of list */ if (list->head == list->tail) { list->head=NULL; list->tail=NULL; } else { /* I am head of list */ list->head=l->next; if (l->next) l->next->prev=NULL; } } else { l->prev->next=l->next; if (l->next) { l->next->prev=l->prev; } } } /*}}} */ /*{{{ static void remove_item ( dpl_superlist *list, dpl_node *item )*/ static void remove_item ( dpl_superlist *list, dpl_node *item ) { if (list) { dpl_list *l; if (l=find_item(list, item )) { ghost_dpl_remove_list_item ( list, item ); unlink_superlist_item ( list, l ); item->ref_count--; free(l); } else { dpl_error ( dpl_errmess, "item 0x%x type %d not found in list\n", item, item->type_check ); } } else { dpl_error ( dpl_errmess, "Attempt to remove from NULL superlist\n" ); } } /*}}} */ /*{{{ static dpl_node *new_node ( int size_in_bytes, dpl_type type )*/ static dpl_node *new_node ( int32 size_in_bytes, dpl_type type, int32 (*init)( struct s_dplnode *)) { dpl_node *new=(dpl_node *) malloc(size_in_bytes); new->type_check=type; new->hidden=0; new->ref_count=0; ghost_dpl_bind_functions ( new ); new->ghost_create(new); init(new); new->flush(new); new->app_specific=NULL; return new; } /*}}} */ /*{{{ static void free_node ( dpl_node *n)*/ static int free_node ( dpl_node *n) { if (n->ref_count==0) { (n->ghost_delete)(n); free ( n ); return 0; } else { if (dpl_WarningLevel > 1) printf ("Not deleting node 0x%x, %d refs remain\n", n, n->ref_count ); return n->ref_count; } } /*}}} */ #define dpl_name_hash 16 static dpl_superlist super_hash[dpl_name_hash]; /*{{{ dpl_hash_name ( char *name )*/ static dpl_superlist * dpl_hash_name ( char *name ) { check_inited(NULL); if (name) { int hash, l=strlen(name); hash=((int) name[0] + (int) name[l] + (int) name[l/2]); hash&=(dpl_name_hash-1); return &super_hash[hash]; } else { dpl_error ( dpl_errmess, "Attempt to hash NULL name\n" ); return NULL; } } /*}}} */ /*{{{ dpl_init_nametable ( void )*/ static void dpl_init_nametable ( void ) { int i; for (i=0; izone_list, dpl_type_zone ); init_superlist ( node, &t->view_list, dpl_type_view ); return; } /*}}} */ /*{{{ dpl_init_zone ( dpl_node * node)*/ dpl_init_zone ( dpl_node * node) { typeize(dpl_ZONE, node); t->root = NULL; t->lmodel = NULL; t->enable = 1; return; } /*}}} */ /*{{{ dpl_init_view ( dpl_node * node)*/ dpl_init_view ( dpl_node * node) { typeize(dpl_VIEW, node); t->enable=1; t->x1 = 1; t->x0 =-1; t->y1 = 1; t->y0 =-1; t->zeye= 1; init_superlist ( node, &t->zone_list, dpl_type_zone ); identity (t->matrix); return; } /*}}} */ /*{{{ dpl_init_lmodel ( dpl_node * node)*/ dpl_init_lmodel ( dpl_node * node) { typeize(dpl_LMODEL, node); init_superlist ( node, &t->light_list, dpl_type_light ); return; } /*}}} */ /*{{{ dpl_init_light ( dpl_node * node)*/ dpl_init_light ( dpl_node * node) { typeize(dpl_LIGHT, node); t->dcs=NULL; t->light_type=dpl_light_type_disable; return; } /*}}} */ /*{{{ dpl_init_ramp ( dpl_node * node)*/ dpl_init_ramp ( dpl_node * node) { typeize(dpl_RAMP, node); t->color0[0]=0.0f; t->color0[1]=0.0f; t->color0[2]=0.0f; t->color1[0]=0.999f; t->color1[1]=0.999f; t->color1[2]=0.999f; return; } /*}}} */ /*{{{ dpl_init_material ( dpl_node * node)*/ dpl_init_material ( dpl_node * node) { typeize(dpl_MATERIAL, node); t->texture = NULL; t->ambient[0]=1.0f; t->ambient[1]=0.0f; t->ambient[2]=0.0f; t->diffuse[0]=1.0f; t->diffuse[1]=0.0f; t->diffuse[2]=0.0f; t->opacity[0]=1.0f; t->opacity[1]=1.0f; t->opacity[2]=1.0f; t->specular[0]=0.0f; t->specular[1]=0.0f; t->specular[2]=0.0f; t->specular[3]=0.0f; t->ramp=NULL; return; } /*}}} */ /*{{{ dpl_init_texmap ( dpl_node * node)*/ dpl_init_texmap ( dpl_node * node) { typeize(dpl_TEXMAP, node); t->texels=NULL; t->u_size=0; t->v_size=0; t->bits_per_texel=0; return; } /*}}} */ /*{{{ dpl_init_texture ( dpl_node * node)*/ dpl_init_texture ( dpl_node * node) { typeize(dpl_TEXTURE, node); t->texmap=NULL; t->minify=0; t->magnify=0; t->alpha=0; t->wrap_u=0; t->wrap_v=0; t->detail=0; t->u0=0.0f; t->v0=0.0f; t->du=0.0f; t->dv=0.0f; t->animate_time=0.0f; t->animate_behaviour=0; return; } /*}}} */ /*{{{ dpl_init_instance ( dpl_node * node)*/ dpl_init_instance ( dpl_node * node) { typeize(dpl_INSTANCE, node); t->dcs=NULL; t->billboard=0; t->intersectmode=dpl_isect_mode_none; t->object=NULL; t->forcelod=NULL; t->f_material=NULL; t->b_material=NULL; t->f_texture=NULL; t->b_texture=NULL; return; } /*}}} */ /*{{{ dpl_init_object ( dpl_node * node)*/ dpl_init_object ( dpl_node * node) { typeize(dpl_OBJECT, node); init_superlist ( node, &t->lod_list, dpl_type_lod ); return; } /*}}} */ /*{{{ dpl_init_lod ( dpl_node * node)*/ dpl_init_lod ( dpl_node * node) { typeize(dpl_LOD, node); t->switch_in =-1.0f; t->switch_out=-1.0f; t->parent=NULL; t->bounds[0][0] = 0.0f; t->bounds[0][1] = 0.0f; t->bounds[0][2] = 0.0f; t->bounds[0][3] = 1.0f; t->bounds[1][0] = 0.0f; t->bounds[1][1] = 0.0f; t->bounds[1][2] = 0.0f; t->bounds[1][3] = 1.0f; init_superlist ( node, &t->geogroup_list, dpl_type_geogroup ); return; } /*}}} */ /*{{{ dpl_init_geogroup ( dpl_node * node)*/ dpl_init_geogroup ( dpl_node * node) { typeize(dpl_GEOGROUP, node); t->f_material=NULL; t->b_material=NULL; t->bounds[0][0] = 0.0f; t->bounds[0][1] = 0.0f; t->bounds[0][2] = 0.0f; t->bounds[0][3] = 1.0f; t->bounds[1][0] = 0.0f; t->bounds[1][1] = 0.0f; t->bounds[1][2] = 0.0f; t->bounds[1][3] = 1.0f; t->parent=NULL; init_superlist ( node, &t->geometry_list, dpl_type_geometry ); return; } /*}}} */ /*{{{ dpl_init_geometry ( dpl_node * node)*/ dpl_init_geometry ( dpl_node * node) { typeize(dpl_GEOMETRY, node); t->geometry_type = dpl_g_type_empty; t->connections = NULL; t->vertices = NULL; t->parent = NULL; return; } /*}}} */ /*{{{ dpl_init_dcs ( dpl_node * node)*/ dpl_init_dcs (dpl_node * node) { typeize(dpl_DCS, node); t->parent = NULL; t->child = NULL; t->sibling = NULL; t->node = NULL; t->identity = 0; t->enable = dcs_node_enable | dcs_subtree_enable; identity (t->matrix); return; } /*}}} */ /*{{{ dpl_init_nameitem ( dpl_node * node)*/ dpl_init_nameitem ( dpl_node * node) { typeize(dpl_NAME, node); t->item=NULL; t->name=NULL; return; } /*}}} */ /*{{{ dpl_init_filepath ( dpl_node *node )*/ static void dpl_init_filepath ( dpl_node *node ) { typeize(dpl_FILEPATH, node); init_superlist ( NULL, &t->path_list, dpl_type_pathitem ); init_superlist ( NULL, &t->extn_list, dpl_type_extnitem ); } /*}}} */ /*{{{ static void dpl_init_pathitem ( dpl_node *node )*/ static void dpl_init_pathitem ( dpl_node *node ) { typeize(dpl_PATHITEM, node); t->path=NULL; } /*}}} */ /*{{{ static void dpl_init_extnitem ( dpl_node *node )*/ static void dpl_init_extnitem ( dpl_node *node ) { typeize(dpl_EXTNITEM, node); t->extn=NULL; t->load_ext=NULL; } /*}}} */ /*}}} */ /*{{{ bounding geometry*/ /*{{{ static void minimax_point ( dpl_POINT mini, dpl_POINT maxi, dpl_POINT p )*/ static void minimax_point ( dpl_POINT mini, dpl_POINT maxi, dpl_POINT p ) { if (p[0] < mini[0]) mini[0]=p[0]; if (p[1] < mini[1]) mini[1]=p[1]; if (p[2] < mini[2]) mini[2]=p[2]; if (p[0] > maxi[0]) maxi[0]=p[0]; if (p[1] > maxi[1]) maxi[1]=p[1]; if (p[2] > maxi[2]) maxi[2]=p[2]; } /*}}} */ /*{{{ static void mini_point ( dpl_POINT mini, dpl_POINT p )*/ static void mini_point ( dpl_POINT mini, dpl_POINT p ) { if (p[0] < mini[0]) mini[0]=p[0]; if (p[1] < mini[1]) mini[1]=p[1]; if (p[2] < mini[2]) mini[2]=p[2]; } /*}}} */ /*{{{ static void maxi_point ( dpl_POINT maxi, dpl_POINT p )*/ static void maxi_point ( dpl_POINT maxi, dpl_POINT p ) { if (p[0] > maxi[0]) maxi[0]=p[0]; if (p[1] > maxi[1]) maxi[1]=p[1]; if (p[2] > maxi[2]) maxi[2]=p[2]; } /*}}} */ /*{{{ static void bound_geometry ( dpl_POINT mini, dpl_POINT maxi,*/ static void bound_geometry ( dpl_POINT mini, dpl_POINT maxi, dpl_GEOMETRY *geo, int first ) { if (geo) { uncover(geo); if (geo->geometry_type==dpl_g_type_spheres) { dpl_error ( dpl_errmess, "cant bound spheres yet\n" ); return; } else if (geo->geometry_type==dpl_g_type_string) { dpl_error ( dpl_errmess, "cant bound spheres yet\n" ); return; } else { dpl_VERTEX_LIST *vl=geo->vertices; dpl_VERTEX *vert; if (vl) { while (vl) { int i; vert=&vl->vertices[0]; for (i=0; in_vertices;i++ ) { if (first) { first=0; memcpy ( mini, vert->position, sizeof(dpl_POINT)); memcpy ( maxi, mini, sizeof(dpl_POINT)); } else { minimax_point ( mini, maxi, vert->position ); } vert++; } vl=vl->next; } } else { dpl_error ( dpl_errmess, "attempt to bound geometry with NULL vertices\n" ); return; } } } else { dpl_error ( dpl_errmess, "attempt to bound NULL geometry\n" ); return; } } /*}}} */ /*}}} */ /*{{{ DPL API ====> list management*/ /*{{{ dpl_AddZoneToScene ( dpl_ZONE *z )*/ void dpl_AddZoneToScene ( dpl_ZONE *z ) { add_item ( &the_scene.zone_list, (dpl_node *) z ); } /*}}} */ /*{{{ dpl_AddViewToScene ( dpl_VIEW *v )*/ void dpl_AddViewToScene ( dpl_VIEW *v ) { add_item ( &the_scene.view_list, (dpl_node *) v ); } /*}}} */ /*{{{ dpl_AddZoneToView ( dpl_VIEW *v, dpl_ZONE *z )*/ void dpl_AddZoneToView ( dpl_VIEW *v, dpl_ZONE *z ) { add_item ( &v->zone_list, (dpl_node *) z ); } /*}}} */ /*{{{ dpl_AddLightToLmodel ( dpl_LMODEL *lm, dpl_LIGHT *l )*/ void dpl_AddLightToLmodel ( dpl_LMODEL *lm, dpl_LIGHT *l ) { add_item ( &lm->light_list, (dpl_node *) l ); } /*}}} */ /*{{{ dpl_AddLodToObject ( dpl_OBJECT *o, dpl_LOD *lod )*/ void dpl_AddLodToObject ( dpl_OBJECT *o, dpl_LOD *lod ) { add_item ( &o->lod_list, (dpl_node *) lod ); lod->parent=o; } /*}}} */ /*{{{ dpl_AddGeogroupToLod ( dpl_LOD *l, dpl_GEOGROUP *gg )*/ void dpl_AddGeogroupToLod ( dpl_LOD *l, dpl_GEOGROUP *gg ) { add_item ( &l->geogroup_list, (dpl_node *) gg ); gg->parent=l; } /*}}} */ /*{{{ dpl_AddGeometryToGeogroup ( dpl_GEOGROUP *gg, dpl_GEOMETRY *g )*/ void dpl_AddGeometryToGeogroup ( dpl_GEOGROUP *gg, dpl_GEOMETRY *g ) { add_item ( &gg->geometry_list, (dpl_node *) g ); g->parent=gg; } /*}}} */ /*{{{ dpl_AddPathToFilepath ( dpl_FILEPATH *fp, dpl_PATHITEM *pi )*/ void dpl_AddPathToFilepath ( dpl_FILEPATH *fp, dpl_PATHITEM *pi ) { add_item ( &fp->path_list, (dpl_node *) pi ); } /*}}} */ /*{{{ dpl_AddExtToFilepath ( dpl_FILEPATH *fp, dpl_EXTNITEM *ei )*/ void dpl_AddExtToFilepath ( dpl_FILEPATH *fp, dpl_EXTNITEM *ei ) { add_item ( &fp->extn_list, (dpl_node *) ei ); } /*}}} */ /*{{{ dpl_RemoveZoneFromScene ( dpl_ZONE *z )*/ void dpl_RemoveZoneFromScene ( dpl_ZONE *z ) { remove_item ( &the_scene.zone_list, (dpl_node *) z ); } /*}}} */ /*{{{ dpl_RemoveViewFromScene ( dpl_VIEW *v )*/ void dpl_RemoveViewFromScene ( dpl_VIEW *v ) { remove_item ( &the_scene.view_list, (dpl_node *) v ); } /*}}} */ /*{{{ dpl_RemoveZoneFromView ( dpl_VIEW *v, dpl_ZONE *z )*/ void dpl_RemoveZoneFromView ( dpl_VIEW *v, dpl_ZONE *z ) { remove_item ( &v->zone_list, (dpl_node *) z ); } /*}}} */ /*{{{ dpl_RemoveLightFromLmodel ( dpl_LMODEL *lm, dpl_LIGHT *l )*/ void dpl_RemoveLightFromLmodel ( dpl_LMODEL *lm, dpl_LIGHT *l ) { remove_item ( &lm->light_list, (dpl_node *) l ); } /*}}} */ /*{{{ dpl_RemoveLodFromObject ( dpl_OBJECT *o, dpl_LOD *lod )*/ void dpl_RemoveLodFromObject ( dpl_OBJECT *o, dpl_LOD *lod ) { remove_item ( &o->lod_list, (dpl_node *) lod ); } /*}}} */ /*{{{ dpl_RemoveGeogroupFromLod ( dpl_LOD *l, dpl_GEOGROUP *gg )*/ void dpl_RemoveGeogroupFromLod ( dpl_LOD *l, dpl_GEOGROUP *gg ) { remove_item ( &l->geogroup_list, (dpl_node *) gg ); } /*}}} */ /*{{{ dpl_RemoveGeometryFromGeogroup ( dpl_GEOGROUP *gg, dpl_GEOMETRY *g )*/ void dpl_RemoveGeometryFromGeogroup ( dpl_GEOGROUP *gg, dpl_GEOMETRY *g ) { remove_item ( &gg->geometry_list, (dpl_node *) g ); } /*}}} */ /*{{{ dpl_RemovePathFromFilepath ( dpl_FILEPATH *fp, dpl_PATHITEM *pi )*/ void dpl_RemovePathFromFilepath ( dpl_FILEPATH *fp, dpl_PATHITEM *pi ) { remove_item ( &fp->path_list, (dpl_node *) pi ); } /*}}} */ /*{{{ dpl_RemoveExtFromFilepath ( dpl_FILEPATH *fp, dpl_EXTNITEM *ei )*/ void dpl_RemoveExtFromFilepath ( dpl_FILEPATH *fp, dpl_EXTNITEM *ei ) { remove_item ( &fp->extn_list, (dpl_node *) ei ); } /*}}} */ /*}}} */ /*{{{ DPL API ====> tree management*/ /*{{{ dpl_NestDCS ( dpl_DCS *parent, dpl_DCS *child )*/ void dpl_NestDCS ( dpl_DCS *parent, dpl_DCS *child ) { if (parent) { if (child) { uncover ( parent ); uncover ( child ); if (parent->child) { dpl_error ( dpl_errmess, "parent 0x%x already has child 0x%x in NestDCS\n", parent, child ); return; } if (child->parent) { dpl_error ( dpl_errmess, "child 0x%x already has parent 0x%x in NestDCS\n", child, parent ); } child->parent=parent; parent->child=child; parent->dplnode.ref_count++; child->dplnode.ref_count++; /* do ghost operation */ ghost_dpl_nest_dcs ( parent, child ); } else { dpl_error ( dpl_errmess, "attempt to Nest 0x%x with a NULL child\n", parent ); return; } } else { dpl_error ( dpl_errmess, "attempt to Nest 0x%x to a NULL parent\n", child ); return; } } /*}}} */ /*{{{ dpl_LinkDCS ( dpl_DCS *bro, dpl_DCS *sis )*/ void dpl_LinkDCS ( dpl_DCS *bro, dpl_DCS *sis ) { if (bro) { if (sis) { uncover ( bro ); uncover ( sis ); if (bro->sibling) { dpl_error ( dpl_errmess, "bro 0x%x already has sibling 0x%x in LinkDCS\n", bro, sis ); return; } if (sis->parent) { dpl_error ( dpl_errmess, "sis 0x%x already has bro 0x%x in LinkDCS\n", sis, bro ); } sis->parent=bro; bro->sibling=sis; sis->dplnode.ref_count++; bro->dplnode.ref_count++; /* do ghost operation */ ghost_dpl_link_dcs ( bro, sis ); } else { dpl_error ( dpl_errmess, "attempt to Link 0x%x with a NULL sis\n", bro ); return; } } else { dpl_error ( dpl_errmess, "attempt to Link 0x%x to a NULL bro\n", sis ); return; } } /*}}} */ /*{{{ dpl_PruneDCS ( dpl_DCS *node )*/ void dpl_PruneDCS ( dpl_DCS *node ) { if (node) { dpl_DCS *daddy; uncover ( node ); daddy=node->parent; if (daddy) { daddy->dplnode.ref_count--; node->dplnode.ref_count--; if (daddy->child == node) { node->parent=NULL; daddy->child=NULL; } else if (daddy->sibling == node) { node->parent =NULL; daddy->sibling=NULL; } else { dpl_error ( dpl_errmess, "badly formed tree discovered in PruneDCS 0x%x\n", node ); return; } ghost_dpl_prune_dcs ( daddy, node ); } else { dpl_error ( dpl_errmess, "attempt to prune DCS 0x%x has no parent\n", node ); return; } } else { dpl_error ( dpl_errmess, "attempt to prune NULL DCS\n" ); return; } } /*}}} */ /*}}} */ /*{{{ DPL API ====> SCENE functions*/ /*{{{ dpl_DrawScene ( void )*/ void dpl_DrawScene ( int32 double_buffered ) { check_inited_noret(); ghost_dpl_draw_scene ( double_buffered ); } /*}}} */ /*{{{ dpl_DrawSceneComplete ( void )*/ int32 dpl_DrawSceneComplete ( void ) { check_inited(1); return ghost_dpl_draw_scene_complete (); } /*}}} */ /*{{{ dpl_WaitSceneComplete ( void )*/ void dpl_WaitSceneComplete ( void ) { check_inited_noret(); ghost_dpl_wait_draw_scene_complete (); } /*}}} */ /*{{{ dpl_GetSceneFirstZone ( void )*/ dpl_ZONE * dpl_GetSceneFirstZone ( void ) { check_inited(NULL); uncover ( &the_scene ); return (dpl_ZONE *) get_first ( &the_scene.zone_list ); } /*}}} */ /*{{{ dpl_GetSceneNextZone ( void )*/ dpl_ZONE * dpl_GetSceneNextZone ( void ) { check_inited(NULL); uncover ( &the_scene ); return (dpl_ZONE *) get_next ( &the_scene.zone_list ); } /*}}} */ /*}}} */ /*{{{ DPL API ====> ZONE functions*/ /*{{{ dpl_NewZone ( void )*/ dpl_ZONE * dpl_NewZone ( void ) { check_inited(NULL); return (dpl_ZONE*) new_node ( sizeof(dpl_ZONE), dpl_type_zone, dpl_init_zone ); } /*}}} */ /*{{{ dpl_DeleteZone ( dpl_ZONE *z )*/ void dpl_DeleteZone ( dpl_ZONE *z ) { check_inited_noret(); if (z) { uncover ( z ); dec_ref ( z->root ); dec_ref ( z->lmodel ); free_node ( (dpl_node *) z ); } else { dpl_error ( dpl_errmess, "Attempt to delete NULL zone\n" ); } } /*}}} */ /*{{{ dpl_GetZoneRootDcs ( dpl_ZONE *z )*/ dpl_DCS * dpl_GetZoneRootDcs ( dpl_ZONE *z ) { check_inited(NULL); if (z) { uncover ( z ); return z->root; } else { dpl_error ( dpl_errmess, "Attempt to GetZoneRootDcs NULL zone\n" ); return NULL; } } /*}}} */ /*{{{ dpl_SetZoneRootDcs ( dpl_ZONE *z, dpl_DCS *h )*/ void dpl_SetZoneRootDcs ( dpl_ZONE *z, dpl_DCS *h ) { check_inited_noret(); if (z) { uncover ( z ); z->root=h; flush_node(z); } else { dpl_error ( dpl_errmess, "SetZoneRootDcs on NULL zone\n" ); } } /*}}} */ /*{{{ dpl_GetZoneLmodel ( dpl_ZONE *z )*/ dpl_LMODEL * dpl_GetZoneLmodel ( dpl_ZONE *z ) { check_inited(NULL); if (z) return (dpl_LMODEL *) z->lmodel; else { dpl_error ( dpl_errmess, "Attempt to GetZoneLmodel on NULL zone\n" ); return NULL; } } /*}}} */ /*{{{ dpl_SetZoneLmodel ( dpl_ZONE *z, dpl_LMODEL *lm )*/ void dpl_SetZoneLmodel ( dpl_ZONE *z, dpl_LMODEL *lm ) { check_inited_noret(); if (z) { z->lmodel=lm; flush_node(z); } else { dpl_error ( dpl_errmess, "Attempt to SetZoneLmodel on NULL zone\n" ); } } /*}}} */ /*{{{ dpl_GetZoneEnable ( dpl_ZONE *z )*/ int32 dpl_GetZoneEnable ( dpl_ZONE *z ) { check_inited(0); if (z) return z->enable; else { dpl_error ( dpl_errmess, "Attempt to GetZoneEnable on NULL zone\n" ); return 0; } } /*}}} */ /*{{{ dpl_SetZoneEnable ( dpl_ZONE *z, int32 i )*/ void dpl_SetZoneEnable ( dpl_ZONE *z, int32 i ) { check_inited_noret(); if (z) { z->enable=i; flush_node(z); } else { dpl_error ( dpl_errmess, "Attempt to SetZoneEnable on NULL zone\n" ); } } /*}}} */ /*}}} */ /*{{{ DPL API ====> DCS functions*/ /*{{{ dpl_NewDcs ( void )*/ dpl_DCS * dpl_NewDcs ( void ) { check_inited(NULL); return (dpl_DCS *) new_node ( sizeof(dpl_DCS), dpl_type_dcs, dpl_init_dcs ); } /*}}} */ /*{{{ dpl_DeleteDcs ( dpl_DCS *h )*/ void dpl_DeleteDcs ( dpl_DCS *h ) { check_inited_noret(); if (h) { uncover(h); dec_ref(h->node); dec_ref(h->parent); dec_ref(h->sibling); dec_ref(h->child); free_node ( (dpl_node *) h ); } else { dpl_error ( dpl_errmess, "Attempt to Delete NULL DCS\n" ); } } /*}}} */ /*{{{ dpl_GetDcsLinkage ( dpl_DCS *node, dpl_DCS **parent,*/ void dpl_GetDcsLinkage ( dpl_DCS *node, dpl_DCS **parent, dpl_DCS **child, dpl_DCS **sibling ) { check_inited_noret(); if (node) { uncover ( node ); *child =node->child; *sibling=node->sibling; *parent =node->parent; } else { dpl_error ( dpl_errmess, "Attempt to GetDcsLinkage on NULL DCS\n" ); } } /*}}} */ /*{{{ dpl_SetDcsNode ( dpl_DCS *hnode, dpl_node *cnode )*/ void dpl_SetDcsNode ( dpl_DCS *hnode, dpl_node *cnode ) { dpl_LIGHT *l=(dpl_LIGHT *) cnode; dpl_INSTANCE *i=(dpl_INSTANCE *) cnode; check_inited_noret(); if (hnode) { uncover ( hnode ); dec_ref ( hnode->node ); if (cnode) { switch (cnode->type_check) { case dpl_type_light: uncover ( cnode ); l->dcs=hnode; break; case dpl_type_instance: uncover ( cnode ); i->dcs=hnode; break; default: dpl_error ( dpl_errmess, "wrong type 0x%x for SetDcsNode\n", cnode->type_check ); break; } } hnode->node=cnode; flush_node(hnode); inc_ref ( cnode ); } else { dpl_error ( dpl_errmess, "Attempt to SetDcsNode on NULL DCS\n" ); } } /*}}} */ /*{{{ dpl_GetDcsNode ( dpl_DCS *hnode )*/ dpl_node * dpl_GetDcsNode ( dpl_DCS *hnode ) { check_inited(NULL); if (hnode) { uncover(hnode); return hnode->node; } else { dpl_error ( dpl_errmess, "Attempt to GetDcsNode on NULL DCS\n" ); return NULL; } } /*}}} */ /*{{{ dpl_SetDcsMatrix ( dpl_DCS *hnode, dpl_MATRIX *m )*/ void dpl_SetDcsMatrix ( dpl_DCS *hnode, dpl_MATRIX *m ) { check_inited_noret(); if (hnode) { uncover ( hnode ); if (m) { memcpy ( hnode->matrix, m, sizeof(dpl_MATRIX)); flush_node(hnode); } else { dpl_error ( dpl_errmess, "Attempt to SetDcsMatrix with NULL matrix\n" ); } } else { dpl_error ( dpl_errmess, "Attempt to SetDcsMatrix on NULL DCS\n" ); } } /*}}} */ /*{{{ dpl_GetDcsMatrix ( dpl_DCS *hnode, dpl_MATRIX m )*/ void dpl_GetDcsMatrix ( dpl_DCS *hnode, dpl_MATRIX m ) { check_inited_noret(); if (hnode) { uncover(hnode); if (m) { memcpy ( m, hnode->matrix, sizeof(dpl_MATRIX)); } else { dpl_error ( dpl_errmess, "Attempt to GetDcsMatrix into NULL matrix\n" ); } } else { dpl_error ( dpl_errmess, "Attempt to GetDcsMatrix on NULL DCS\n" ); } } /*}}} */ /*{{{ dpl_GetDcsNodeType ( dpl_DCS *hnode )*/ dpl_type dpl_GetDcsNodeType ( dpl_DCS *hnode ) { check_inited(dpl_type_error); if (hnode) { uncover (hnode); if (hnode->node) { uncover (hnode->node); return hnode->node->type_check; } else return dpl_type_error; } else { dpl_error ( dpl_errmess, "Attempt to GetDcsNodeType on NULL DCS\n" ); return dpl_type_error; } } /*}}} */ /*{{{ dpl_SetDcsNodeEnable ( dpl_DCS *hnode, int32 enable )*/ void dpl_SetDcsNodeEnable ( dpl_DCS *hnode, int32 enable ) { check_inited_noret(); if (hnode) { if (enable) hnode->enable|= dcs_node_enable; else hnode->enable&=~dcs_node_enable; flush_node(hnode); } else { dpl_error ( dpl_errmess, "Attempt to SetDcsNodeEnable on NULL DCS\n" ); } } /*}}} */ /*{{{ dpl_SetDcsSubtreeEnable ( dpl_DCS *hnode, int32 enable )*/ void dpl_SetDcsSubtreeEnable ( dpl_DCS *hnode, int32 enable ) { check_inited_noret(); if (hnode) { if (enable) hnode->enable|= dcs_subtree_enable; else hnode->enable&=~dcs_subtree_enable; flush_node(hnode); } else { dpl_error ( dpl_errmess, "Attempt to SetDcsSubtreeEnable on NULL DCS\n" ); } } /*}}} */ /*{{{ dpl_GetDcsNodeEnable ( dpl_DCS *hnode )*/ int32 dpl_GetDcsNodeEnable ( dpl_DCS *hnode ) { check_inited(0); if (hnode) { if (hnode->enable & dcs_node_enable) return 1; else return 0; } else { dpl_error ( dpl_errmess, "Attempt to GetDcsNodeEnable on NULL DCS\n" ); return 0; } } /*}}} */ /*{{{ dpl_GetDcsSubtreeEnable ( dpl_DCS *hnode )*/ int32 dpl_GetDcsSubtreeEnable ( dpl_DCS *hnode ) { check_inited(0); if (hnode) { if (hnode->enable & dcs_subtree_enable) return 1; else return 0; } else { dpl_error ( dpl_errmess, "Attempt to GetDcsSubtreeEnable on NULL DCS\n" ); return 0; } } /*}}} */ /*}}} */ /*{{{ DPL API ====> INSTANCE functions*/ /*{{{ dpl_NewInstance ( void )*/ dpl_INSTANCE * dpl_NewInstance ( void ) { check_inited(NULL); return (dpl_INSTANCE *) new_node ( sizeof(dpl_INSTANCE), dpl_type_instance, dpl_init_instance ); } /*}}} */ /*{{{ dpl_DeleteInstance ( dpl_INSTANCE *i )*/ void dpl_DeleteInstance ( dpl_INSTANCE *i ) { check_inited_noret(); if (i) { uncover(i); dec_ref(i->object); dec_ref(i->forcelod); dec_ref(i->f_material); dec_ref(i->b_material); dec_ref(i->f_texture ); dec_ref(i->b_texture ); free_node ( (dpl_node *) i); } else { dpl_error ( dpl_errmess, "Attempt to Delete NULL instance\n" ); } } /*}}} */ /*{{{ dpl_SetInstanceObject ( dpl_INSTANCE *i, dpl_OBJECT *o )*/ void dpl_SetInstanceObject ( dpl_INSTANCE *i, dpl_OBJECT *o ) { check_inited_noret(); if (i) { uncover(i); dec_ref (i->object); i->object=o; flush_node(i); inc_ref ( o ); } else { dpl_error ( dpl_errmess, "Attempt to SetInstanceObject on NULL inst\n" ); } } /*}}} */ /*{{{ dpl_GetInstanceObject ( dpl_INSTANCE *i )*/ dpl_OBJECT * dpl_GetInstanceObject ( dpl_INSTANCE *i ) { check_inited(NULL); if (i) return (i->object); else { dpl_error ( dpl_errmess, "Attempt to GetInstanceObject on NULL object\n" ); return NULL; } } /*}}} */ /*{{{ dpl_SetInstanceFrontMaterial ( dpl_INSTANCE * i, dpl_MATERIAL *m )*/ void dpl_SetInstanceFrontMaterial ( dpl_INSTANCE * i, dpl_MATERIAL *m ) { check_inited_noret(); if (i) { uncover(i); dec_ref (i->f_material); i->f_material=m; flush_node(i); inc_ref ( m ); } else { dpl_error ( dpl_errmess, "Attempt to SetInstanceFrontMtl on NULL inst\n" ); } } /*}}} */ /*{{{ dpl_GetInstanceFrontMaterial ( dpl_INSTANCE *i )*/ dpl_MATERIAL * dpl_GetInstanceFrontMaterial ( dpl_INSTANCE *i ) { check_inited(NULL); if (i) return i->f_material; else { dpl_error ( dpl_errmess, "Attempt to GetInstFrontMtl on NULL inst\n" ); return NULL; } } /*}}} */ /*{{{ dpl_SetInstanceBackMaterial ( dpl_INSTANCE *i, dpl_MATERIAL *m )*/ void dpl_SetInstanceBackMaterial ( dpl_INSTANCE *i, dpl_MATERIAL *m ) { check_inited_noret(); if (i) { uncover(i); dec_ref (i->b_material); i->b_material=m; inc_ref ( m ); flush_node(i); } else { dpl_error ( dpl_errmess, "Attempt to SetInstanceBackMtl on NULL inst\n" ); } } /*}}} */ /*{{{ dpl_GetInstanceBackMaterial ( dpl_INSTANCE *i )*/ dpl_MATERIAL * dpl_GetInstanceBackMaterial ( dpl_INSTANCE *i ) { check_inited(NULL); if (i) return i->b_material; else { dpl_error ( dpl_errmess, "Attempt to GetInstFrontMtl on NULL inst\n" ); return NULL; } } /*}}} */ /*{{{ dpl_SetInstanceFrontTexture ( dpl_INSTANCE *i, dpl_TEXTURE *t )*/ void dpl_SetInstanceFrontTexture ( dpl_INSTANCE *i, dpl_TEXTURE *t ) { check_inited_noret(); if (i) { uncover(i); dec_ref (i->f_texture); i->f_texture=t; inc_ref ( t ); flush_node(i); } else { dpl_error ( dpl_errmess, "Attempt to SetInstanceFrontTex on NULL inst\n" ); } } /*}}} */ /*{{{ dpl_GetInstanceFrontTexture ( dpl_INSTANCE *i )*/ dpl_TEXTURE * dpl_GetInstanceFrontTexture ( dpl_INSTANCE *i ) { check_inited(NULL); if (i) return i->f_texture; else { dpl_error ( dpl_errmess, "Attempt to GetInstFrontTex on NULL inst\n" ); return NULL; } } /*}}} */ /*{{{ dpl_SetInstanceBackTexture ( dpl_INSTANCE *i, dpl_TEXTURE *t )*/ void dpl_SetInstanceBackTexture ( dpl_INSTANCE *i, dpl_TEXTURE *t ) { check_inited_noret(); if (i) { uncover(i); dec_ref (i->b_texture); i->b_texture=t; inc_ref ( t ); flush_node(i); } else { dpl_error ( dpl_errmess, "Attempt to SetInstanceBackTex on NULL inst\n" ); } } /*}}} */ /*{{{ dpl_GetInstanceBackTexture ( dpl_INSTANCE *i )*/ dpl_TEXTURE * dpl_GetInstanceBackTexture ( dpl_INSTANCE *i ) { check_inited(NULL); if (i) return i->b_texture; else { dpl_error ( dpl_errmess, "Attempt to GetInstBackTex on NULL inst\n" ); return NULL; } } /*}}} */ /*{{{ dpl_SetInstanceForceLOD ( dpl_INSTANCE *i, dpl_LOD *l )*/ void dpl_SetInstanceForceLOD ( dpl_INSTANCE *i, dpl_LOD *l ) { check_inited_noret(); if (i) { uncover(i); dec_ref (i->forcelod); i->forcelod=l; inc_ref ( l ); flush_node(i); } else { dpl_error ( dpl_errmess, "Attempt to SetInstForceLOD on NULL inst\n" ); } } /*}}} */ /*{{{ dpl_GetInstanceForceLOD ( dpl_INSTANCE *i )*/ dpl_LOD * dpl_GetInstanceForceLOD ( dpl_INSTANCE *i ) { check_inited(NULL); if (i) { uncover(i); return i->forcelod; } else { dpl_error ( dpl_errmess, "Attempt to GetInstForceLOD on NULL inst\n" ); return NULL; } } /*}}} */ /*{{{ dpl_SetInstanceBillboard ( dpl_INSTANCE *i, int32 b )*/ void dpl_SetInstanceBillboard ( dpl_INSTANCE *i, int32 b ) { check_inited_noret(); if (i) { uncover(i); i->billboard=b; flush_node(i); } else { dpl_error ( dpl_errmess, "Attempt to SetInstBillboard on NULL inst\n" ); } } /*}}} */ /*{{{ dpl_GetInstanceBillboard ( dpl_INSTANCE *i )*/ int32 dpl_GetInstanceBillboard ( dpl_INSTANCE *i ) { check_inited(0); if (i) { uncover(i); return i->billboard; } else { dpl_error ( dpl_errmess, "Attempt to GetInstBillboard on NULL inst\n" ); return NULL; } } /*}}} */ /*{{{ dpl_SetInstanceIntersect ( dpl_INSTANCE *i, dpl_isect_mode m )*/ void dpl_SetInstanceIntersect ( dpl_INSTANCE *i, dpl_isect_mode m ) { check_inited_noret(); if (i) { uncover(i); i->intersectmode=m; flush_node(i); } else { dpl_error ( dpl_errmess, "Attempt to SetInstIntersect on NULL inst\n" ); } } /*}}} */ /*{{{ dpl_GetInstanceIntersect ( dpl_INSTANCE *i )*/ dpl_isect_mode dpl_GetInstanceIntersect ( dpl_INSTANCE *i ) { check_inited(0); if (i) { uncover(i); return i->intersectmode; } else { dpl_error ( dpl_errmess, "Attempt to GetInstIntersect on NULL inst\n" ); return dpl_isect_mode_error; } if (i) return i->intersectmode; else return dpl_isect_mode_none; } /*}}} */ /*}}} */ /*{{{ DPL API ====> LIGHT functions*/ /*{{{ dpl_NewLmodel ( void )*/ dpl_LMODEL * dpl_NewLmodel ( void ) { check_inited(NULL); return (dpl_LMODEL *) new_node ( sizeof(dpl_LMODEL), dpl_type_lmodel, dpl_init_lmodel ); } /*}}} */ /*{{{ dpl_DeleteLmodel ( dpl_LMODEL *lm )*/ void dpl_DeleteLmodel ( dpl_LMODEL *lm ) { check_inited_noret(); if (lm) { uncover ( lm ); free_node ( (dpl_node *) lm ); } else { dpl_error ( dpl_errmess, "Attempt to delete NULL Lmodel\n" ); } } /*}}} */ /*{{{ dpl_GetLmodelFirstLight ( dpl_LMODEL *lm )*/ dpl_LIGHT * dpl_GetLmodelFirstLight ( dpl_LMODEL *lm ) { check_inited(NULL); if (lm) { uncover(lm); return (dpl_LIGHT *) get_first ( &lm->light_list ); } else { dpl_error ( dpl_errmess, "Attempt to GetLmodelFirstLight on NULL Lmodel\n" ); return NULL; } } /*}}} */ /*{{{ dpl_GetLmodelNextLight ( dpl_LMODEL *lm )*/ dpl_LIGHT * dpl_GetLmodelNextLight ( dpl_LMODEL *lm ) { check_inited(NULL); if (lm) { uncover (lm); return (dpl_LIGHT *) get_next ( &lm->light_list ); } else { dpl_error ( dpl_errmess, "Attempt to GetLmodelNextLight on NULL Lmodel\n" ); return NULL; } } /*}}} */ /*{{{ dpl_NewLight ( void )*/ dpl_LIGHT * dpl_NewLight ( void ) { check_inited(NULL); return (dpl_LIGHT *) new_node ( sizeof(dpl_LIGHT), dpl_type_light, dpl_init_light ); } /*}}} */ /*{{{ dpl_DeleteLight ( dpl_LIGHT *l )*/ void dpl_DeleteLight ( dpl_LIGHT *l ) { check_inited_noret(); if (l) { uncover ( l ); dec_ref ( l->dcs ); free_node ( (dpl_node *) l ); } else { dpl_error ( dpl_errmess, "Attempt to delete NULL light\n" ); } } /*}}} */ /*{{{ dpl_SetLightType ( dpl_LIGHT *l, dpl_light_type t )*/ void dpl_SetLightType ( dpl_LIGHT *l, dpl_light_type t ) { check_inited_noret(); if (l) { uncover(l); l->light_type=t; flush_node(l); } else { dpl_error ( dpl_errmess, "Attempt to SetLightType on NULL light\n" ); } } /*}}} */ /*{{{ dpl_GetLightType ( dpl_LIGHT *l )*/ dpl_light_type dpl_GetLightType ( dpl_LIGHT *l ) { check_inited(dpl_light_type_error); if (l) { uncover(l); return l->light_type; } else { dpl_error ( dpl_errmess, "Attempt to GetLightType on NULL light\n" ); return dpl_light_type_error; } } /*}}} */ /*{{{ dpl_SetLightColor ( dpl_LIGHT *l, float32 r, float32 g, float32 b )*/ void dpl_SetLightColor ( dpl_LIGHT *l, float32 r, float32 g, float32 b ) { check_inited_noret(); if (l) { uncover(l); l->color[0]=r; l->color[1]=g; l->color[2]=b; flush_node(l); } else { dpl_error ( dpl_errmess, "Attempt to SetLightColor on NULL light\n" ); } } /*}}} */ /*{{{ dpl_GetLightColor ( dpl_LIGHT *l, float32 *r, float32 *g, float32 *b )*/ void dpl_GetLightColor ( dpl_LIGHT *l, float32 *r, float32 *g, float32 *b ) { check_inited_noret(); if (l) { uncover(l); *r=l->color[0]; *g=l->color[1]; *b=l->color[2]; } else { dpl_error ( dpl_errmess, "Attempt to GetLightColor on NULL light\n" ); } } /*}}} */ /*{{{ dpl_SetLightRadii ( dpl_LIGHT *l, float32 r0, float32 r1 )*/ void dpl_SetLightRadii ( dpl_LIGHT *l, float32 r0, float32 r1 ) { check_inited_noret(); if (l) { uncover(l); l->radius[0]=r0; l->radius[1]=r1; flush_node(l); } else { dpl_error ( dpl_errmess, "Attempt to SetLightRadii on NULL light\n" ); } } /*}}} */ /*{{{ dpl_GetLightRadii ( dpl_LIGHT *l, float32 *r0,float32 *r1 )*/ void dpl_GetLightRadii ( dpl_LIGHT *l, float32 *r0,float32 *r1 ) { check_inited_noret(); if (l) { uncover(l); *r0=l->radius[0]; *r1=l->radius[1]; } else { dpl_error ( dpl_errmess, "Attempt to GetLightRadii on NULL light\n" ); } } /*}}} */ /*{{{ dpl_SetLightUmbra ( dpl_LIGHT *l, float32 th1, float32 th2 )*/ void dpl_SetLightUmbra ( dpl_LIGHT *l, float32 th1, float32 th2 ) { check_inited_noret(); if (l) { uncover(l); l->umbra[0]=th1; l->umbra[1]=th2; flush_node(l); } else { dpl_error ( dpl_errmess, "Attempt to SetLightUmbra on NULL light\n" ); } } /*}}} */ /*{{{ dpl_GetLightUmbra ( dpl_LIGHT *l, float32 *th1, float32 *th2 )*/ void dpl_GetLightUmbra ( dpl_LIGHT *l, float32 *th1, float32 *th2 ) { check_inited_noret(); if (l) { uncover(l); *th1=l->umbra[0]; *th2=l->umbra[1]; } else { dpl_error ( dpl_errmess, "Attempt to GetLightUmbra on NULL light\n" ); } } /*}}} */ /*}}} */ /*{{{ DPL API ====> VIEW functions*/ /*{{{ dpl_NewView ( void )*/ dpl_VIEW * dpl_NewView ( void ) { check_inited(NULL); return (dpl_VIEW *) new_node ( sizeof(dpl_VIEW), dpl_type_view, dpl_init_view ); } /*}}} */ /*{{{ dpl_DeleteView ( dpl_VIEW *v )*/ void dpl_DeleteView ( dpl_VIEW *v ) { check_inited_noret(); if (v) { uncover ( v ); free_node ( (dpl_node *) v ); } else { dpl_error ( dpl_errmess, "Attempt to delete NULL view\n" ); } } /*}}} */ /*{{{ dpl_SetViewMatrix ( dpl_VIEW *v, dpl_MATRIX m )*/ void dpl_SetViewMatrix ( dpl_VIEW *v, dpl_MATRIX m ) { check_inited_noret(); if (v && m) { uncover ( v ); memcpy ( v->matrix, m, sizeof(dpl_MATRIX)); flush_node(v); } else if (m) { dpl_error ( dpl_errmess, "Attempt to SetViewMatrix on NULL view\n" ); } else { dpl_error ( dpl_errmess, "Attempt to SetViewMatrix on NULL matrix\n" ); } } /*}}} */ /*{{{ dpl_GetViewMatrix ( dpl_VIEW *v, dpl_MATRIX m )*/ void dpl_GetViewMatrix ( dpl_VIEW *v, dpl_MATRIX m ) { check_inited_noret(); if (v && m) { uncover ( v ); memcpy ( v, v->matrix, sizeof(dpl_MATRIX)); } else if (m) { dpl_error ( dpl_errmess, "Attempt to GetViewMatrix on NULL view\n" ); } else { dpl_error ( dpl_errmess, "Attempt to GetViewMatrix on NULL matrix\n" ); } } /*}}} */ /*{{{ dpl_SetViewClipPlanes ( dpl_VIEW *v, float32 hither, float32 yon )*/ void dpl_SetViewClipPlanes ( dpl_VIEW *v, float32 hither, float32 yon ) { check_inited_noret(); if (v) { uncover(v); v->hither_clip=hither; v->yon_clip =yon; flush_node(v); } else { dpl_error ( dpl_errmess, "Attempt to SetViewClipplanes on NULL matrix\n" ); } } /*}}} */ /*{{{ dpl_GetViewClipPlanes ( dpl_VIEW *v, float32 *hither, float32 *yon )*/ void dpl_GetViewClipPlanes ( dpl_VIEW *v, float32 *hither, float32 *yon ) { check_inited_noret(); if (v) { uncover(v); *hither=v->hither_clip; *yon =v->yon_clip; } else { dpl_error ( dpl_errmess, "Attempt to GetViewClipplanes on NULL matrix\n" ); } } /*}}} */ /*{{{ dpl_SetViewBackGround ( dpl_VIEW *v, float32 r, float32 g, float32 b )*/ void dpl_SetViewBackGround ( dpl_VIEW *v, float32 r, float32 g, float32 b ) { check_inited_noret(); if (v) { uncover(v); v->back_color[0]=r; v->back_color[1]=g; v->back_color[2]=b; flush_node(v); } else { dpl_error ( dpl_errmess, "Attempt to SetViewBackGround on NULL view\n" ); } } /*}}} */ /*{{{ dpl_GetViewBackGround ( dpl_VIEW *v, float32 *r, float32 *g, float32 *b )*/ void dpl_GetViewBackGround ( dpl_VIEW *v, float32 *r, float32 *g, float32 *b ) { check_inited_noret(); if (v) { uncover(v); *r=v->back_color[0]; *g=v->back_color[1]; *b=v->back_color[2]; } else { dpl_error ( dpl_errmess, "Attempt to GetViewBackGround on NULL view\n" ); } } /*}}} */ /*{{{ dpl_SetViewFog ( dpl_VIEW *v, int32 enable,*/ void dpl_SetViewFog ( dpl_VIEW *v, int32 enable, float32 r, float32 g, float32 b, float32 neer, float32 phar ) { check_inited_noret(); if (v) { uncover(v); v->fog_enable=enable; v->fog[0]=neer; v->fog[1]=phar; v->fog[2]=r; v->fog[3]=g; v->fog[4]=b; flush_node(v); } else { dpl_error ( dpl_errmess, "Attempt to SetViewFog on NULL view\n" ); } } /*}}} */ /*{{{ dpl_GetViewFog ( dpl_VIEW *v, int32 *enable,*/ void dpl_GetViewFog ( dpl_VIEW *v, int32 *enable, float32 *r, float32 *g, float32 *b, float32 *neer, float32 *phar ) { check_inited_noret(); if (v) { uncover(v); *enable=v->fog_enable; *neer=v->fog[0]; *phar=v->fog[1]; *r=v->fog[2]; *g=v->fog[3]; *b=v->fog[4]; } else { dpl_error ( dpl_errmess, "Attempt to GetViewFog on NULL view\n" ); } } /*}}} */ /*{{{ dpl_SetViewProjection ( dpl_VIEW *v,*/ void dpl_SetViewProjection ( dpl_VIEW *v, float32 x_size, float32 y_size, float32 x0, float32 y0, float32 x1, float32 y1, float32 zeye ) { check_inited_noret(); if (v) { uncover(v); v->x_size=x_size; v->y_size=y_size; v->x0=x0; v->y0=y0; v->x1=x1; v->y1=y1; v->zeye=zeye; flush_node(v); } else { dpl_error ( dpl_errmess, "Attempt to SetViewProjn on NULL view\n" ); } } /*}}} */ /*{{{ dpl_GetViewProjection ( dpl_VIEW *v,*/ void dpl_GetViewProjection ( dpl_VIEW *v, float32 *x_size, float32 *y_size, float32 *x0, float32 *y0, float32 *x1, float32 *y1, float32 *zeye ) { check_inited_noret(); if (v) { uncover(v); *x_size=v->x_size; *y_size=v->y_size; *x0=v->x0; *y0=v->y0; *x1=v->x1; *y1=v->y1; *zeye =v->zeye; } else { dpl_error ( dpl_errmess, "Attempt to GetViewProjn on NULL view\n" ); } } /*}}} */ /*}}} */ /*{{{ DPL API ====> MATERIAL functions*/ /*{{{ dpl_NewMaterial ( void )*/ dpl_MATERIAL * dpl_NewMaterial ( void ) { check_inited(NULL); return (dpl_MATERIAL *) new_node ( sizeof(dpl_MATERIAL), dpl_type_material, dpl_init_material ); } /*}}} */ /*{{{ dpl_DeleteMaterial ( dpl_MATERIAL *m )*/ void dpl_DeleteMaterial ( dpl_MATERIAL *m ) { check_inited_noret(); if (m) { uncover ( m ); dec_ref ( m->ramp ); dec_ref ( m->texture ); free_node ( (dpl_node *) m ); } else { dpl_error ( dpl_errmess, "Attempt to delete NULL material\n" ); } } /*}}} */ /*{{{ dpl_SetMaterialEmissive ( dpl_MATERIAL *m, float32 r, float32 g, float32 b )*/ void dpl_SetMaterialEmissive ( dpl_MATERIAL *m, float32 r, float32 g, float32 b ) { check_inited_noret(); if (m) { uncover(m); m->emissive[0]=r; m->emissive[1]=g; m->emissive[2]=b; flush_node(m); } else { dpl_error ( dpl_errmess, "Attempt to SetMtlEmissive on NULL material\n" ); } } /*}}} */ /*{{{ dpl_GetMaterialEmissive ( dpl_MATERIAL *m, float32 *r, float32 *g, float32 *b )*/ void dpl_GetMaterialEmissive ( dpl_MATERIAL *m, float32 *r, float32 *g, float32 *b ) { check_inited_noret(); if (m) { uncover(m); *r=m->emissive[0]; *g=m->emissive[1]; *b=m->emissive[2]; } else { dpl_error ( dpl_errmess, "Attempt to GetMtlEmissive on NULL material\n" ); } } /*}}} */ /*{{{ dpl_SetMaterialAmbient ( dpl_MATERIAL *m, float32 r, float32 g, float32 b )*/ void dpl_SetMaterialAmbient ( dpl_MATERIAL *m, float32 r, float32 g, float32 b ) { check_inited_noret(); if (m) { uncover(m); m->ambient[0]=r; m->ambient[1]=g; m->ambient[2]=b; flush_node(m); } else { dpl_error ( dpl_errmess, "Attempt to SetMtlAmbient on NULL material\n" ); } } /*}}} */ /*{{{ dpl_GetMaterialAmbient ( dpl_MATERIAL *m, float32 *r, float32 *g, float32 *b )*/ void dpl_GetMaterialAmbient ( dpl_MATERIAL *m, float32 *r, float32 *g, float32 *b ) { check_inited_noret(); if (m) { uncover(m); *r=m->ambient[0]; *g=m->ambient[1]; *b=m->ambient[2]; } else { dpl_error ( dpl_errmess, "Attempt to GetMtlAmbient on NULL material\n" ); } } /*}}} */ /*{{{ dpl_SetMaterialDiffuse ( dpl_MATERIAL *m, float32 r, float32 g, float32 b )*/ void dpl_SetMaterialDiffuse ( dpl_MATERIAL *m, float32 r, float32 g, float32 b ) { check_inited_noret(); if (m) { uncover(m); m->diffuse[0]=r; m->diffuse[1]=g; m->diffuse[2]=b; flush_node(m); } else { dpl_error ( dpl_errmess, "Attempt to SetMtlDiffuse on NULL material\n" ); } } /*}}} */ /*{{{ dpl_GetMaterialDiffuse ( dpl_MATERIAL *m, float32 *r, float32 *g, float32 *b )*/ void dpl_GetMaterialDiffuse ( dpl_MATERIAL *m, float32 *r, float32 *g, float32 *b ) { check_inited_noret(); if (m) { uncover(m); *r=m->diffuse[0]; *g=m->diffuse[1]; *b=m->diffuse[2]; } else { dpl_error ( dpl_errmess, "Attempt to GetMtlDiffuse on NULL material\n" ); } } /*}}} */ /*{{{ dpl_SetMaterialSpecular ( dpl_MATERIAL *m, float32 r, float32 g, float32 b,*/ void dpl_SetMaterialSpecular ( dpl_MATERIAL *m, float32 r, float32 g, float32 b, float32 shininess ) { check_inited_noret(); if (m) { uncover(m); m->specular[0]=r; m->specular[1]=g; m->specular[2]=b; m->specular[3]=shininess; flush_node(m); } else { dpl_error ( dpl_errmess, "Attempt to SetMtlSpecular on NULL material\n" ); } } /*}}} */ /*{{{ dpl_GetMaterialSpecular ( dpl_MATERIAL *m, float32 *r, float32 *g, float32 *b,*/ void dpl_GetMaterialSpecular ( dpl_MATERIAL *m, float32 *r, float32 *g, float32 *b, float32 *shininess ) { check_inited_noret(); if (m) { uncover(m); *r=m->specular[0]; *g=m->specular[1]; *b=m->specular[2]; *shininess=m->specular[3]; } else { dpl_error ( dpl_errmess, "Attempt to GetMtlSpecular on NULL material\n" ); } } /*}}} */ /*{{{ dpl_SetMaterialOpacity ( dpl_MATERIAL *m, float32 r, float32 g, float32 b )*/ void dpl_SetMaterialOpacity ( dpl_MATERIAL *m, float32 r, float32 g, float32 b ) { check_inited_noret(); if (m) { uncover(m); m->opacity[0]=r; m->opacity[1]=g; m->opacity[2]=b; flush_node(m); } else { dpl_error ( dpl_errmess, "Attempt to SetMtlOpacity on NULL material\n" ); } } /*}}} */ /*{{{ dpl_GetMaterialOpacity ( dpl_MATERIAL *m, float32 *r, float32 *g, float32 *b )*/ void dpl_GetMaterialOpacity ( dpl_MATERIAL *m, float32 *r, float32 *g, float32 *b ) { check_inited_noret(); if (m) { uncover(m); *r=m->opacity[0]; *g=m->opacity[1]; *b=m->opacity[2]; } else { dpl_error ( dpl_errmess, "Attempt to GetMtlOpacity on NULL material\n" ); } } /*}}} */ /*{{{ dpl_SetMaterialTexture ( dpl_MATERIAL *m, dpl_TEXTURE *t )*/ void dpl_SetMaterialTexture ( dpl_MATERIAL *m, dpl_TEXTURE *t ) { check_inited_noret(); if (m) { uncover ( m ); dec_ref ( m->texture ); m->texture=t; inc_ref ( t ); flush_node(m); } else { dpl_error ( dpl_errmess, "Attempt to GetZoneRootDcs NULL zone\n" ); } } /*}}} */ /*{{{ dpl_GetMaterialTexture ( dpl_MATERIAL *m )*/ dpl_TEXTURE * dpl_GetMaterialTexture ( dpl_MATERIAL *m ) { check_inited(NULL); if (m) { uncover ( m ); return m->texture; } else { dpl_error ( dpl_errmess, "Attempt to GetMaterialTexture on NULL mtl\n" ); return NULL; } } /*}}} */ /*}}} */ /*{{{ DPL API ====> RAMP functions*/ /*{{{ dpl_NewRamp ( void )*/ dpl_RAMP * dpl_NewRamp ( void ) { check_inited(NULL); return (dpl_RAMP *) new_node ( sizeof(dpl_RAMP), dpl_type_ramp, dpl_init_ramp ); } /*}}} */ /*{{{ dpl_DeleteRamp ( dpl_RAMP *m )*/ void dpl_DeleteRamp ( dpl_RAMP *m ) { check_inited_noret(); if (m) { uncover ( m ); free_node ( (dpl_node *) m ); } else { dpl_error ( dpl_errmess, "Attempt to delete NULL ramp\n" ); } } /*}}} */ /*{{{ dpl_SetRampColors ( dpl_RAMP *m, float r0,float g0, float b0,*/ void dpl_SetRampColors ( dpl_RAMP *m, float r0,float g0, float b0, float r1, float g1, float b1 ) { check_inited_noret(); if (m) { uncover(m); m->color0[0]=r0; m->color0[1]=g0; m->color0[2]=b0; m->color1[0]=r1; m->color1[1]=g1; m->color1[2]=b1; flush_node(m); } else { dpl_error ( dpl_errmess, "Attempt to SetRampColors on NULL ramp\n" ); } } /*}}} */ /*{{{ dpl_GetRampColors ( dpl_RAMP *m, float *r0,float *g0, float *b0,*/ void dpl_GetRampColors ( dpl_RAMP *m, float *r0,float *g0, float *b0, float *r1, float *g1, float *b1 ) { check_inited_noret(); if (m) { uncover(m); *r0=m->color0[0]; *g0=m->color0[1]; *b0=m->color0[2]; *r1=m->color1[0]; *g1=m->color1[1]; *b1=m->color1[2]; } else { dpl_error ( dpl_errmess, "Attempt to GetRampColors on NULL ramp\n" ); } } /*}}} */ /*}}} */ /*{{{ DPL API ====> TEXTURE functions*/ /*{{{ dpl_NewTexMap ( void )*/ dpl_TEXMAP * dpl_NewTexMap ( void ) { check_inited(NULL); return (dpl_TEXMAP *) new_node ( sizeof(dpl_TEXMAP), dpl_type_texmap, dpl_init_texmap ); } /*}}} */ /*{{{ dpl_DeleteTexMap ( dpl_TEXMAP *tm )*/ void dpl_DeleteTexMap ( dpl_TEXMAP *tm ) { check_inited_noret(); if (tm) { uncover ( tm ); if (tm->texels) free(tm->texels); free_node ( (dpl_node *) tm ); } else { dpl_error ( dpl_errmess, "Attempt to delete NULL texmap\n" ); } } /*}}} */ /*{{{ dpl_SetTexMapEdgeSize ( dpl_TEXMAP *tm, int32 u, int32 v )*/ void dpl_SetTexMapEdgeSize ( dpl_TEXMAP *tm, int32 u, int32 v ) { check_inited_noret(); } /*}}} */ /*{{{ dpl_GetTexMapEdgeSize ( dpl_TEXMAP *tm, int32 *u, int32 *v )*/ void dpl_GetTexMapEdgeSize ( dpl_TEXMAP *tm, int32 *u, int32 *v ) { check_inited_noret(); } /*}}} */ /*{{{ dpl_SetTexMapTexelSize ( dpl_TEXMAP *tm, int32 bytes_per_pixel )*/ void dpl_SetTexMapTexelSize ( dpl_TEXMAP *tm, int32 bytes_per_pixel ) { check_inited_noret(); } /*}}} */ /*{{{ dpl_GetTexMapTexelSize ( dpl_TEXMAP *tm )*/ int32 dpl_GetTexMapTexelSize ( dpl_TEXMAP *tm ) { check_inited(0); return 0; } /*}}} */ /*{{{ dpl_SetTexMapTexels ( dpl_TEXMAP *tm,*/ void dpl_SetTexMapTexels ( dpl_TEXMAP *tm, int32 *texels, int32 u_size, int32 v_size, int32 mode ) { if (tm) { uncover ( tm ); if (tm->texels) free(tm->texels); if (ghost_dpl_set_texmap_texels ( tm, texels, u_size, v_size, mode ) == 0) { dpl_error ( dpl_errmess, "Failed to perform remote set_texmap_texels\n" ); return; } tm->texels=texels; tm->u_size=u_size; tm->v_size=v_size; flush_node(tm); } else { dpl_error ( dpl_errmess, "Attempt to SetTexmapTexels on NULL texmap\n" ); } check_inited_noret(); } /*}}} */ /*{{{ dpl_NewTexture ( void )*/ dpl_TEXTURE * dpl_NewTexture ( void ) { check_inited(NULL); return (dpl_TEXTURE *) new_node ( sizeof(dpl_TEXTURE), dpl_type_texture, dpl_init_texture ); } /*}}} */ /*{{{ dpl_DeleteTexture ( dpl_TEXTURE *t )*/ void dpl_DeleteTexture ( dpl_TEXTURE *t ) { check_inited_noret(); if (t) { uncover ( t ); dec_ref ( t->texmap ); free_node ( (dpl_node *) t ); } else { dpl_error ( dpl_errmess, "Attempt to delete NULL texture\n" ); } } /*}}} */ /*{{{ dpl_SetTextureMode ( dpl_TEXTURE *t, int32 m )*/ void dpl_SetTextureMode ( dpl_TEXTURE *t, int32 m ) { check_inited_noret(); } /*}}} */ /*{{{ dpl_GetTextureMode ( dpl_TEXTURE *t )*/ int32 dpl_GetTextureMode ( dpl_TEXTURE *t ) { check_inited(0); return 0; } /*}}} */ /*{{{ dpl_LoadTexmap ( dpl_TEXMAP *o, char *fname )*/ int32 dpl_LoadTexmap ( dpl_TEXMAP *o, char *fname ) { char *full_name; load_function load; check_inited(0); if (full_name = dpl_FindTextureFile(fname, &load)) { if (load) return load ( &o->dplnode, full_name); else return load_svt ( &o->dplnode, full_name ); } else return 0; } /*}}} */ /*}}} */ /*{{{ DPL API ====> FILEPATH CONTROL functions*/ /*{{{ dpl_NewFilePath ( void )*/ dpl_FILEPATH * dpl_NewFilePath ( void ) { check_inited(NULL); return (dpl_FILEPATH*) new_node ( sizeof(dpl_FILEPATH), dpl_type_filepath, dpl_init_filepath ); } /*}}} */ /*{{{ dpl_NewPathItem ( void )*/ dpl_PATHITEM * dpl_NewPathItem ( void ) { check_inited(NULL); return (dpl_PATHITEM*) new_node ( sizeof(dpl_PATHITEM), dpl_type_pathitem, dpl_init_pathitem ); } /*}}} */ /*{{{ dpl_NewExtnItem ( void )*/ dpl_EXTNITEM * dpl_NewExtnItem ( void ) { check_inited(NULL); return (dpl_EXTNITEM*) new_node ( sizeof(dpl_EXTNITEM), dpl_type_extnitem, dpl_init_extnitem ); } /*}}} */ /*{{{ dpl_DeleteFilePath ( dpl_FILEPATH *fp )*/ void dpl_DeleteFilePath ( dpl_FILEPATH *fp ) { check_inited_noret(); if (fp) { uncover ( fp ); free_node ( (dpl_node *) fp ); } else { dpl_error ( dpl_errmess, "Attempt to delete NULL filepath\n" ); } } /*}}} */ /*{{{ dpl_DeletePathItem ( dpl_PATHITEM *fp )*/ void dpl_DeletePathItem ( dpl_PATHITEM *fp ) { check_inited_noret(); if (fp) { uncover ( fp ); free_node ( (dpl_node *) fp ); } else { dpl_error ( dpl_errmess, "Attempt to delete NULL pathitem\n" ); } } /*}}} */ /*{{{ dpl_DeleteExtnItem ( dpl_PATHITEM *fp )*/ void dpl_DeleteExtnItem ( dpl_PATHITEM *fp ) { check_inited_noret(); if (fp) { uncover ( fp ); free_node ( (dpl_node *) fp ); } else { dpl_error ( dpl_errmess, "Attempt to delete NULL extnitem\n" ); } } /*}}} */ /*{{{ dpl_SetPathItemPath ( dpl_PATHITEM *i, char *s )*/ void dpl_SetPathItemPath ( dpl_PATHITEM *i, char *s ) { check_inited_noret(); if (i) { uncover(i); i->path=s; } else { dpl_error ( dpl_errmess, "Attempt to SetPathItemPath on NULL item\n" ); } } /*}}} */ /*{{{ dpl_GetPathItemPath ( dpl_PATHITEM *p )*/ char * dpl_GetPathItemPath ( dpl_PATHITEM *p ) { check_inited(NULL); if (p) { uncover(p); return (p->path); } else { dpl_error ( dpl_errmess, "Attempt to GetPthItemPath on NULL item\n" ); return NULL; } } /*}}} */ /*{{{ dpl_SetExtnItemExtn ( dpl_EXTNITEM *p, char *s )*/ void dpl_SetExtnItemExtn ( dpl_EXTNITEM *p, char *s ) { check_inited_noret(); if (p) { uncover(p); p->extn=s; } else { dpl_error ( dpl_errmess, "Attempt to SetExtnItemExtn on NULL item\n" ); } } /*}}} */ /*{{{ dpl_GetExtnItemExtn ( dpl_EXTNITEM *p )*/ char * dpl_GetExtnItemExtn ( dpl_EXTNITEM *p ) { check_inited(NULL); if (p) { uncover(p); return (p->extn); } else { dpl_error ( dpl_errmess, "Attempt to GetExtnItemExtn on NULL item\n" ); return NULL; } } /*}}} */ /*{{{ dpl_SetExtnItemLoadFunc ( dpl_EXTNITEM *p, load_function l )*/ void dpl_SetExtnItemLoadFunc ( dpl_EXTNITEM *p, load_function l ) { check_inited_noret(); if (p) { uncover(p); p->load_ext=l; } else { dpl_error ( dpl_errmess, "Attempt to SetExtnItemLoadFunc on NULL item\n" ); } } /*}}} */ /*{{{ dpl_GetExtnItemLoadFunc ( dpl_EXTNITEM *p )*/ load_function dpl_GetExtnItemLoadFunc ( dpl_EXTNITEM *p ) { check_inited(NULL); if (p) return (p->load_ext); else { dpl_error ( dpl_errmess, "Attempt to GetExtnItemLoadFunc on NULL item\n" ); return NULL; } } /*}}} */ /*{{{ dpl_SetGeometryFilePath ( dpl_FILEPATH *fp )*/ void dpl_SetGeometryFilePath ( dpl_FILEPATH *fp ) { check_inited_noret(); if (fp) geometry_filepath=fp; else { dpl_error ( dpl_errmess, "Attempt to SetFilePath with NULL\n" ); } } /*}}} */ /*{{{ dpl_GetGeometryFilePath ( void )*/ dpl_FILEPATH * dpl_GetGeometryFilePath ( void ) { check_inited(NULL); return geometry_filepath; } /*}}} */ /*{{{ dpl_SetTextureFilePath ( dpl_FILEPATH *fp )*/ void dpl_SetTextureFilePath ( dpl_FILEPATH *fp ) { check_inited_noret(); if (fp) texture_filepath=fp; else { dpl_error ( dpl_errmess, "Attempt to SetFilePath with NULL\n" ); } } /*}}} */ /*{{{ dpl_GetTextureFilePath ( void )*/ dpl_FILEPATH * dpl_GetTextureFilePath ( void ) { check_inited(NULL); return texture_filepath; } /*}}} */ static char *found=NULL; /*{{{ dpl_FindFile ( dpl_FILEPATH *fp, char *root_name )*/ char * dpl_FindFile ( dpl_FILEPATH *filepath, char *root_name, load_function *load ) { dpl_list *extn_list, *path_list; dpl_EXTNITEM *extn_item; dpl_PATHITEM *path_item; FILE *fp; char *path_str, *extn_str; check_inited(NULL); if (found==NULL) found=malloc(256); if (filepath == NULL) { if (load) *load=NULL; printf ("returning null due to null filepath\n" ); return root_name; } if (root_name) { for (path_list=filepath->path_list.head; path_list; path_list=path_list->next ) { path_item=(dpl_PATHITEM *) path_list->item; if (path_item) { for (extn_list=filepath->extn_list.head; extn_list; extn_list=extn_list->next ) { extn_item=(dpl_EXTNITEM *) extn_list->item; if (extn_item) { if (path_item->path) path_str=path_item->path; else path_str=""; if (extn_item->extn) extn_str=extn_item->extn; else extn_str=""; /* does path:root:extn exist? */ if (strstr( root_name, ".")) { sprintf ( found, "%s%c%s", path_str, dpl_path_separator, root_name ); } else { sprintf ( found, "%s%c%s.%s", path_str, dpl_path_separator, root_name, extn_str ); } if (fp=fopen ("rb", found )) { char t[16]; fread ( t, 1, 16, fp ); fclose(fp); *load=extn_item->load_ext; return found; } } } } } } else { dpl_error ( dpl_errmess, "attempt to FindFile from NULL root\n"); if (load) *load=NULL; return NULL; } printf ("returning root due to failure to find\n" ); return root_name; } /*}}} */ /*{{{ dpl_FindGeometryFile ( char *root_name )*/ char * dpl_FindGeometryFile ( char *root_name, load_function *load ) { char *name; check_inited(NULL); printf ("find geometry file %s\n", root_name ); return dpl_FindFile ( geometry_filepath, root_name, load ); } /*}}} */ /*{{{ dpl_FindTextureFile ( char *root_name )*/ char * dpl_FindTextureFile ( char *root_name, load_function *load ) { check_inited(NULL); printf ("find texture file %s\n", root_name ); return dpl_FindFile ( texture_filepath, root_name, load ); } /*}}} */ /*}}} */ /*{{{ DPL API ====> GEOMETRY functions*/ /*{{{ dpl_NewObject ( void )*/ dpl_OBJECT * dpl_NewObject ( void ) { check_inited(NULL); return (dpl_OBJECT *) new_node ( sizeof(dpl_OBJECT), dpl_type_object, dpl_init_object ); } /*}}} */ /*{{{ dpl_NewLod ( void )*/ dpl_LOD * dpl_NewLod ( void ) { check_inited(NULL); return (dpl_LOD *) new_node ( sizeof(dpl_LOD), dpl_type_lod, dpl_init_lod ); } /*}}} */ /*{{{ dpl_NewGeogroup ( void )*/ dpl_GEOGROUP * dpl_NewGeogroup ( void ) { check_inited(NULL); return (dpl_GEOGROUP *) new_node ( sizeof(dpl_GEOGROUP), dpl_type_geogroup, dpl_init_geogroup ); } /*}}} */ /*{{{ dpl_NewGeometry ( void )*/ dpl_GEOMETRY * dpl_NewGeometry ( void ) { check_inited(NULL); return (dpl_GEOMETRY *) new_node ( sizeof(dpl_GEOMETRY), dpl_type_geometry, dpl_init_geometry ); } /*}}} */ /*{{{ dpl_GetObjectFirstLod ( dpl_OBJECT *o )*/ dpl_LOD * dpl_GetObjectFirstLod ( dpl_OBJECT *o ) { check_inited(NULL); if (o) { uncover ( o ); return (dpl_LOD *) get_first ( &o->lod_list ); } else { dpl_error ( dpl_errmess, "Attempt to get LOD from NULL object\n" ); return NULL; } } /*}}} */ /*{{{ dpl_GetObjectNextLod ( dpl_OBJECT *o )*/ dpl_LOD * dpl_GetObjectNextLod ( dpl_OBJECT *o ) { check_inited(NULL); if (o) { uncover ( o ); return (dpl_LOD *) get_next ( &o->lod_list ); } else { dpl_error ( dpl_errmess, "Attempt to get LOD from NULL object\n" ); return NULL; } } /*}}} */ /*{{{ dpl_DeleteObject ( dpl_OBJECT *o )*/ void dpl_DeleteObject ( dpl_OBJECT *o ) { check_inited_noret(); if (o) { uncover ( o ); free_node ( (dpl_node *) o ); } else { dpl_error ( dpl_errmess, "Attempt to delete NULL object\n" ); } } /*}}} */ /*{{{ dpl_DeleteLod ( dpl_LOD *o )*/ void dpl_DeleteLod ( dpl_LOD *o ) { check_inited_noret(); if (o) { uncover ( o ); free_node ( (dpl_node *) o ); } else { dpl_error ( dpl_errmess, "Attempt to delete NULL lod\n" ); } } /*}}} */ /*{{{ dpl_DeleteGeogroup ( dpl_GEOGROUP *o )*/ void dpl_DeleteGeogroup ( dpl_GEOGROUP *o ) { check_inited_noret(); if (o) { uncover ( o ); free_node ( (dpl_node *) o ); } else { dpl_error ( dpl_errmess, "Attempt to delete NULL geogroup\n" ); } } /*}}} */ /*{{{ dpl_DeleteGeometry ( dpl_GEOMETRY *o )*/ void dpl_DeleteGeometry ( dpl_GEOMETRY *o ) { check_inited_noret(); if (o) { uncover ( o ); free_node ( (dpl_node *) o ); } else { dpl_error ( dpl_errmess, "Attempt to delete NULL geometry\n" ); } } /*}}} */ /*{{{ dpl_SetGeometryGeotype ( dpl_GEOMETRY *g, dpl_geo_type gt )*/ void dpl_SetGeometryGeotype ( dpl_GEOMETRY *g, dpl_geo_type gt ) { check_inited_noret(); if (g) { uncover(g); g->geometry_type=gt; flush_node(g); } else { dpl_error ( dpl_errmess, "Attempt to SetGeometryGeotype on NULL geometry\n" ); } } /*}}} */ /*{{{ dpl_GetGeometryGeotype ( dpl_GEOMETRY *g )*/ dpl_geo_type dpl_GetGeometryGeotype ( dpl_GEOMETRY *g ) { check_inited(NULL); if (g) return (g->geometry_type); else { dpl_error ( dpl_errmess, "Attempt to GetGeometryGeotype on NULL geometry\n" ); return dpl_g_type_error; } } /*}}} */ /*{{{ dpl_SetGeometryVertices ( dpl_GEOMETRY *g, dpl_VERTEX_LIST *v )*/ int32 dpl_SetGeometryVertices ( dpl_GEOMETRY *g, dpl_VERTEX_LIST *v, dpl_CONNECTION_LIST *con ) { /* the call to SetGeometryVertices squirts the geometric data at the i860 */ int nv=0, nc=0; dpl_VERTEX_LIST *vv=v; dpl_CONNECTION_LIST *cc=con; check_inited(0); if (g) { uncover(g); while (vv) { nv+=vv->n_vertices; vv=vv->next; } while (cc) { nc+=cc->n_connections; cc=cc->next; } if (ghost_dpl_set_geometry_vertices ( g, v, con, nv, nc ) == 0) { dpl_error ( dpl_errmess, "Failed to perform remote set_geometry_vertices\n" ); return 0; } g->vertices=v; g->connections=con; return 1; } else { dpl_error ( dpl_errmess, "Attempt to SetGeometryVertices on NULL geometry\n" ); return 0; } } /*}}} */ /*{{{ dpl_NewVertices ( int n_vertices )*/ dpl_VERTEX_LIST * dpl_NewVertices ( int n_vertices ) { dpl_VERTEX_LIST *head=NULL, *prevl=NULL, *vl; dpl_VERTEX *v, *prev=NULL; int i; if (n_vertices > 0) { while (n_vertices > 0) { vl=(dpl_VERTEX_LIST *) malloc(sizeof(dpl_VERTEX_LIST)); if (vl == NULL) { dpl_error ( dpl_errmess, "Failed to allocate vertex list\n" ); return NULL; } vl->next=NULL; if (prevl == NULL) { head=vl; } else { prevl->next=vl; } prevl=vl; if (n_vertices > DPL_VERTICES_PER_BLOCK) vl->n_vertices=DPL_VERTICES_PER_BLOCK; else vl->n_vertices=n_vertices; n_vertices-=DPL_VERTICES_PER_BLOCK; /* now chain together vertices in this block */ for (i=0; in_vertices; i++ ) { v=&vl->vertices[i]; if (prev) prev->next=v; prev=v; v->next=NULL; } } return head; } else { dpl_error ( dpl_errmess, "Attempt to allocate 0 vertices\n" ); return NULL; } } /*}}} */ /*{{{ dpl_NewConnections ( int n_connections )*/ dpl_CONNECTION_LIST * dpl_NewConnections ( int n_connections ) { dpl_CONNECTION_LIST *head=NULL, *prevcl=NULL, *cl; dpl_CONNECTION *c, *prev=NULL; int i; if (n_connections > 0) { while (n_connections > 0) { cl=(dpl_CONNECTION_LIST *) malloc(sizeof(dpl_CONNECTION_LIST)); if (cl == NULL) { dpl_error ( dpl_errmess, "Failed to allocate connection list\n" ); return NULL; } cl->next=NULL; if (prevcl == NULL) head=cl; else prevcl->next=cl; prevcl=cl; if (n_connections > DPL_CONNECTIONS_PER_BLOCK) cl->n_connections=DPL_CONNECTIONS_PER_BLOCK; else cl->n_connections=n_connections; n_connections-=DPL_CONNECTIONS_PER_BLOCK; /* now chain together vertices in this block */ for (i=0; in_connections; i++ ) { c=&cl->connections[i]; if (prev) prev->next=c; prev=c; c->next=NULL; } } return head; } else { dpl_error ( dpl_errmess, "Attempt to allocate 0 connections\n" ); return NULL; } } /*}}} */ /*{{{ dpl_GetGeometryNumVertices ( dpl_GEOMETRY *g )*/ int32 dpl_GetGeometryNumVertices ( dpl_GEOMETRY *g ) { int32 nv=0; dpl_VERTEX_LIST *vl; if (g) { uncover ( g ); vl=g->vertices; while (vl) { nv+=vl->n_vertices; vl=vl->next; } return nv; } else { dpl_error ( dpl_errmess, "Attempt to GetGeometryNumVertices on NULL geometry\n" ); return 0; } } /*}}} */ /*{{{ dpl_GetGeometryVertex ( dpl_GEOMETRY *g, int vertex_index )*/ dpl_VERTEX * dpl_GetGeometryVertex ( dpl_GEOMETRY *g, int vertex_index ) { dpl_VERTEX_LIST *vl; if (g) { uncover ( g ); vl=g->vertices; if (vl) { while (vertex_index>vl->n_vertices) { vertex_index-=vl->n_vertices; vl=vl->next; if (vl==NULL) { dpl_error ( dpl_errmess, "GetGeometryVertex : index beyond end of list\n" ); return NULL; } } return &vl->vertices[vertex_index]; } else { dpl_error ( dpl_errmess, "Attempt to GetGeometryVertex on NULL vertices\n" ); return NULL; } } else { dpl_error ( dpl_errmess, "Attempt to GetGeometryVertex on NULL geometry\n" ); return NULL; } } /*}}} */ /*{{{ dpl_GetGeometryNumConnections ( dpl_GEOMETRY *g )*/ int32 dpl_GetGeometryNumConnections ( dpl_GEOMETRY *g ) { int32 nv=0; dpl_CONNECTION_LIST *vl; if (g) { uncover ( g ); vl=g->connections; while (vl) { nv+=vl->n_connections; vl=vl->next; } return nv; } else { dpl_error ( dpl_errmess, "Attempt to GetGeometryNumConnections on NULL geometry\n" ); return 0; } } /*}}} */ /*{{{ dpl_GetGeometryConnection ( dpl_GEOMETRY *g, int vertex_index )*/ dpl_CONNECTION * dpl_GetGeometryConnection ( dpl_GEOMETRY *g, int vertex_index ) { dpl_CONNECTION_LIST *vl; if (g) { uncover ( g ); vl=g->connections; if (vl) { while (vertex_index>vl->n_connections) { vertex_index-=vl->n_connections; vl=vl->next; if (vl==NULL) { dpl_error ( dpl_errmess, "GetGeometryConnection : index beyond end of list\n" ); return NULL; } } return &vl->connections[vertex_index]; } else { dpl_error ( dpl_errmess, "Attempt to GetGeometryConnection on NULL connection\n" ); return NULL; } } else { dpl_error ( dpl_errmess, "Attempt to GetGeometryConnection on NULL geometry\n" ); return NULL; } } /*}}} */ /*{{{ dpl_BoundGeogroup ( dpl_GEOGROUP *gg )*/ void dpl_BoundGeogroup ( dpl_GEOGROUP *gg ) { dpl_POINT mini={0,0,0,0}, maxi={0,0,0,0}; dpl_GEOMETRY *geo; int first=1; check_inited_noret(); if (gg) { uncover(gg); geo=(dpl_GEOMETRY *) get_first ( &gg->geometry_list ); while (geo) { bound_geometry ( mini, maxi, geo, first ); first=0; geo=(dpl_GEOMETRY *) get_next ( &gg->geometry_list ); } memcpy ( gg->bounds[0], mini, sizeof(dpl_POINT)); memcpy ( gg->bounds[1], maxi, sizeof(dpl_POINT)); flush_node(gg); } else { dpl_error ( dpl_errmess, "Attempt to Bound NULL geogroup\n" ); } } /*}}} */ /*{{{ dpl_BoundLod ( dpl_LOD *lod )*/ void dpl_BoundLod ( dpl_LOD *lod ) { dpl_GEOGROUP *geo; check_inited_noret(); if (lod) { uncover(lod); geo=(dpl_GEOGROUP *) get_first ( &lod->geogroup_list ); if (geo) { uncover(geo); memcpy ( lod->bounds[0], geo->bounds[0], sizeof(dpl_POINT)); memcpy ( lod->bounds[1], geo->bounds[1], sizeof(dpl_POINT)); geo=(dpl_GEOGROUP *) get_next ( &lod->geogroup_list ); while (geo) { uncover(geo); mini_point ( lod->bounds[0], geo->bounds[0] ); maxi_point ( lod->bounds[1], geo->bounds[1] ); geo=(dpl_GEOGROUP *) get_next ( &lod->geogroup_list ); } } flush_node(lod); } else { dpl_error ( dpl_errmess, "Attempt to Bound NULL lod\n" ); } } /*}}} */ /*{{{ dpl_LoadObject ( dpl_OBJECT *o, char *fname )*/ int32 dpl_LoadObject ( dpl_OBJECT *o, char *fname ) { char *full_name; load_function load=NULL; check_inited(0); if (o) { if (full_name = dpl_FindGeometryFile(fname, &load)) { printf ("dpl_LoadObject - name=%s\n", full_name ); if (load) { printf ("calling embedded function\n"); return load ( &o->dplnode, full_name); } else { return load_b2z ( &o->dplnode, full_name ); } } else { dpl_error ( dpl_errmess, "FindGeometryFile returned NULL\n"); return 0; } } else { dpl_error ( dpl_errmess, "attempt to dpl_LoadObject into a NULL object\n"); return 0; } } /*}}} */ /*{{{ dpl_MorphObject ( dpl_OBJECT *morphed,*/ void dpl_MorphObject ( dpl_OBJECT *morphed, dpl_OBJECT *a, dpl_OBJECT *b, float32 alpha ) { check_inited_noret(); ghost_dpl_morph_object ( morphed, a, b, alpha ); } /*}}} */ /*}}} */ /*{{{ DPL API ====> 2-D DISPLAYLIST functions*/ /*}}} */ /*{{{ DPL API ====> NAMETABLE ACCESS functions*/ /*{{{ dpl_NewName ( void )*/ dpl_NAME * dpl_NewName ( void ) { check_inited(NULL); return (dpl_NAME *) new_node ( sizeof(dpl_NAME), dpl_type_nameitem, dpl_init_nameitem ); } /*}}} */ /*{{{ dpl_DeleteName ( dpl_NAME *n )*/ void dpl_DeleteName ( dpl_NAME *n ) { check_inited_noret(); if (n) { uncover ( n ); if (n->name) free ( n->name); dec_ref ( n->item ); free_node ( (dpl_node *) n ); } else { dpl_error ( dpl_errmess, "Attempt to delete NULL name\n" ); } } /*}}} */ /*{{{ dpl_SetNameString ( dpl_NAME *n, char * s )*/ void dpl_SetNameString ( dpl_NAME *n, char * s ) { check_inited_noret(); if (n) { uncover(n); if (n->name) free(n->name); if (s) { n->name=malloc ( 1 + strlen(s)); strcpy ( n->name, s ); } } else { dpl_error ( dpl_errmess, "Attempt to SetNameString on NULL name\n" ); } } /*}}} */ /*{{{ dpl_SetNameNode ( dpl_NAME *n, dpl_node *dn )*/ void dpl_SetNameNode ( dpl_NAME *n, dpl_node *dn ) { check_inited_noret(); if (n) { uncover(n); dec_ref (n->item ); n->item=dn; inc_ref (dn); } else { dpl_error ( dpl_errmess, "Attempt to SetNameNode on NULL name\n" ); } } /*}}} */ /*{{{ dpl_AddNameToNametable ( dpl_NAME *n )*/ void dpl_AddNameToNametable ( dpl_NAME *n ) { check_inited_noret(); if (n->name) { dpl_superlist *sl=dpl_hash_name ( n->name ); add_item ( sl, (dpl_node *) n ); } else { dpl_error ( dpl_errmess, "Attempt to add name with NULL string to name table\n" ); } } /*}}} */ /*{{{ dpl_RemoveNameFromNametable ( dpl_NAME *n )*/ void dpl_RemoveNameFromNametable ( dpl_NAME *n ) { if (n->name) { dpl_superlist *sl=dpl_hash_name ( n->name ); remove_item ( sl, (dpl_node *) n ); } else { dpl_error ( dpl_errmess, "Attempt to remove name with NULL string from name table\n" ); } } /*}}} */ /*{{{ dpl_NameNode ( dpl_node *n, char *s )*/ void dpl_NameNode ( dpl_node *n, char *s ) { check_inited_noret(); if (n && s) { dpl_NAME *name = dpl_NewName(); dpl_SetNameNode ( name, n ); dpl_SetNameString ( name, s ); dpl_AddNameToNameTable ( name ); } else { dpl_error ( dpl_errmess, "Attempt to name NULL node\n" ); } } /*}}} */ /*{{{ dpl_ClearNameTable ( void )*/ void dpl_ClearNameTable ( void ) { int i; for (i=0; ihead; l; l=l->next ) { dec_ref(l->item); dpl_DeleteName ( (dpl_NAME *) l->item ); free(l); } init_superlist ( NULL, sl, dpl_type_nameitem ); } } /*}}} */ /*{{{ dpl_FindNamedNode ( char *str )*/ dpl_node * dpl_FindNamedNode ( char *str ) { dpl_superlist *sl; dpl_list *l; dpl_NAME *n; int look=1; check_inited(NULL); sl=dpl_hash_name ( str ); n=(dpl_NAME *) get_first ( sl ); while (n) { if (strcmp(n->name, str) == 0) return n->item; n=(dpl_NAME *) get_next ( sl ); } return NULL; } /*}}} */ /*{{{ dpl_FindNamedTypedNode ( dpl_type t, char *str )*/ dpl_node * dpl_FindNamedTypedNode ( dpl_type t, char *str ) { dpl_superlist *sl; dpl_list *l; dpl_NAME *n; int look=1; check_inited(NULL); sl=dpl_hash_name ( str ); n=(dpl_NAME *) get_first ( sl ); while (n) { if (strcmp(n->name, str) == 0) { if (n->item->type_check == t) return n->item; } n=(dpl_NAME *) get_next ( sl ); } return NULL; } /*}}} */ /*}}} */ /*{{{ DPL API ====> GENERAL CONTROL functions*/ /*{{{ dpl_SetWarningLevel ( int32 w )*/ void dpl_SetWarningLevel ( int32 w ) { dpl_WarningLevel=w; } /*}}} */ /*{{{ dpl_GetWarningLevel ( void )*/ int32 dpl_GetWarningLevel ( void ) { check_inited(0); return dpl_WarningLevel; } /*}}} */ /*{{{ dpl_Init ( int32 argc, char **argv )*/ int32 dpl_Init ( char *dpl_arg ) { if (dpl_inited) return 0; else { /* allow any host functions I call to operate ! */ dpl_inited=1; /* do ghost operation */ ghost_dpl_init ( dpl_arg ); /* init SCENE structure */ dpl_init_scene ((dpl_node *) (&the_scene) ); /* init nametable stuff */ dpl_init_nametable (); __dpl_cache_mode=dpl_cache_mode_write_thru; } return 1; } /*}}} */ /*{{{ dpl_Exit ( int32 exit_code )*/ void dpl_Exit ( int32 exit_code ) { check_inited_noret(); } /*}}} */ /*{{{ dpl_SetCacheMode ( dpl_cache_mode m )*/ void dpl_SetCacheMode ( dpl_cache_mode m ) { check_inited_noret(); __dpl_cache_mode=m; } /*}}} */ /*{{{ dpl_GetCacheMode ()*/ dpl_cache_mode dpl_GetCacheMode () { check_inited(dpl_cache_mode_error); return __dpl_cache_mode; } /*}}} */ /*{{{ dpl_Statistics ( void )*/ dpl_STATISTICS dpl_Statistics ( void ) { dpl_STATISTICS fred; check_inited(fred); ghost_dpl_statistics ( &fred ); return fred; } /*}}} */ /*{{{ dpl_Version ( void )*/ dpl_VERSION dpl_Version ( void ) { dpl_VERSION version; version.major_version=1; version.minor_version=0; strcpy ( version.detailed, "dpl 05/jul/94" ); ghost_dpl_version ( & version ); return version; } /*}}} */ /*{{{ dpl_Status ( void )*/ char * dpl_Status ( void ) { static char *dpl_ok_mess = "dpl status is dpl_ok\n"; if (dpl_err) return dpl_errmess; else return dpl_ok_mess; } /*}}} */ /*{{{ dpl_ReadFrameStore ( int32 *pixels, int32 x, int32 y, int32 n_pixels )*/ void dpl_ReadFrameStore ( int32 *pixels, int32 x, int32 y, int32 n_pixels ) { check_inited_noret(); ghost_dpl_readpixels ( pixels, x, y, n_pixels ); } /*}}} */ /*{{{ dpl_SectVector ( float32 x0, float32 y0, float32 z0,*/ dpl_INSTANCE * dpl_SectVector ( dpl_POINT sect, float32 x0, float32 y0, float32 z0, float32 x1, float32 y1, float32 z1 ) { check_inited(NULL); return ghost_dpl_sectvector ( sect, x0, y0, z0, x1, y1, z1 ); } /*}}} */ /*{{{ dpl_SectPixel ( int32 x, int32 y )*/ dpl_INSTANCE * dpl_SectPixel ( dpl_POINT sect, float32 x, float32 y ) { check_inited(NULL); return ghost_dpl_sectpixel ( sect, x, y ); } /*}}} */ /*}}} */