BRL-CAD: librt geometry, raytracing

{(_p)->idb_magic = RT_DB_INTERNAL_MAGIC; \
        (_p)->idb_type = -1; (_p)->idb_ptr = GENPTR_NULL;\
        (_p)->idb_avs.magic = -1;}

{ \
        RT_CK_HIT(_hitp); \
        RT_CK_SOLTAB(_stp); \
        (_stp)->st_meth->ft_norm(_hitp, _stp, (_hitp)->hit_rayp); }

{ \
        RT_CK_HIT(_hitp); \
        RT_CK_SOLTAB(_stp); \
        RT_CK_FUNCTAB((_stp)->st_meth); \
        (_stp)->st_meth->ft_norm(_hitp, _stp, (_hitp)->hit_rayp); \
        if( _flipflag )  { \
                VREVERSE( _normal, (_hitp)->hit_normal ); \
        } else { \
                VMOVE( _normal, (_hitp)->hit_normal ); \
        } \
 }

{ \
        RT_CK_HIT(_hitp); \
        RT_CK_SOLTAB(_stp); \
        RT_CK_FUNCTAB((_stp)->st_meth); \
        (_stp)->st_meth->ft_curve( _curvp, _hitp, _stp ); \
        if( _flipflag )  { \
                (_curvp)->crv_c1 = - (_curvp)->crv_c1; \
                (_curvp)->crv_c2 = - (_curvp)->crv_c2; \
        } \
 }

{ \
        RT_CK_HIT(_hitp); \
        RT_CK_SOLTAB(_stp); \
        RT_CK_FUNCTAB((_stp)->st_meth); \
        (_stp)->st_meth->ft_uv( ap, _stp, _hitp, uvp ); }

{ \
        while( !BU_LIST_WHILE((p),seg,&((res)->re_seg)) || !(p) ) \
                rt_get_seg(res); \
        BU_LIST_DEQUEUE( &((p)->l) ); \
        (p)->l.forw = (p)->l.back = BU_LIST_NULL; \
        (p)->seg_in.hit_magic = (p)->seg_out.hit_magic = RT_HIT_MAGIC; \
        res->re_segget++; }

{ \
        RT_CHECK_SEG(p); \
        BU_LIST_INSERT( &((res)->re_seg), &((p)->l) ); \
        res->re_segfree++; }

{ \
        register struct seg *_a; \
        while( BU_LIST_WHILE( _a, seg, &((_segheadp)->l) ) )  { \
                BU_LIST_DEQUEUE( &(_a->l) ); \
                RT_FREE_SEG( _a, _res ); \
        } }

{ \
        GET_PT(ip,new,res); \
        memcpy((char *)(&(new)->RT_PT_MIDDLE_START), (char *)(&(old)->RT_PT_MIDDLE_START), RT_PT_MIDDLE_LEN(old) ); \
        (new)->pt_overlap_reg = NULL; \
        bu_ptbl_cat( &(new)->pt_seglist, &(old)->pt_seglist );  }

{\
        GET_PT(ip,p,res); \
        memset( ((char *) &(p)->RT_PT_MIDDLE_START), 0, RT_PT_MIDDLE_LEN(p) ); }

{ \
        if( BU_LIST_NON_EMPTY_P(p, partition, &res->re_parthead) )  { \
                BU_LIST_DEQUEUE((struct bu_list *)(p)); \
                bu_ptbl_reset( &(p)->pt_seglist ); \
        } else { \
                (p) = (struct partition *)bu_calloc(1, sizeof(struct partition), "struct partition"); \
                (p)->pt_magic = PT_MAGIC; \
                bu_ptbl_init( &(p)->pt_seglist, 42, "pt_seglist ptbl" ); \
                (res)->re_partlen++; \
        } \
        res->re_partget++; }

{ \
        BU_LIST_APPEND( &(res->re_parthead), (struct bu_list *)(p) ); \
        if( (p)->pt_overlap_reg )  { \
                bu_free( (genptr_t)((p)->pt_overlap_reg), "pt_overlap_reg" );\
                (p)->pt_overlap_reg = NULL; \
        } \
        res->re_partfree++; }

{ \
                register struct partition *_pp, *_zap; \
                for( _pp = (_headp)->pt_forw; _pp != (_headp);  )  { \
                        _zap = _pp; \
                        _pp = _pp->pt_forw; \
                        BU_LIST_DEQUEUE( (struct bu_list *)(_zap) ); \
                        FREE_PT(_zap, _res); \
                } \
                (_headp)->pt_forw = (_headp)->pt_back = (_headp); \
        }

{ int _i; \
        for( _i = RT_DBNHASH-1; _i >= 0; _i-- )  { \
                for( (_dp) = (_dbip)->dbi_Head[_i]; (_dp); (_dp) = (_dp)->d_forw )  {

{ \
        if( strlen(_name) < sizeof((_dp)->d_shortname) )  {\
                strncpy( (_dp)->d_shortname, (_name), sizeof((_dp)->d_shortname) ); \
                (_dp)->d_namep = (_dp)->d_shortname; \
        } else { \
                (_dp)->d_namep = bu_strdup(_name); /* Calls bu_malloc() */ \
        } }

{ \
        if( (_dp)->d_namep != (_dp)->d_shortname )  \
                bu_free((_dp)->d_namep, "d_namep"); \
        (_dp)->d_namep = NULL; }

{ \
        while( ((_p) = (_res)->re_directory_hd) == NULL ) \
                db_get_directory(_res); \
        (_res)->re_directory_hd = (_p)->d_forw; \
        (_p)->d_forw = NULL; }

{(_p)->magic = RT_DBTR_MAGIC; \
        (_p)->dbip = GENPTR_NULL; (_p)->comb_enter_func = GENPTR_NULL; \
        (_p)->comb_exit_func = GENPTR_NULL; (_p)->leaf_func = GENPTR_NULL; \
        (_p)->resp = GENPTR_NULL; (_p)->client_data = GENPTR_NULL;}

{ \
        if( ((_tp) = (_res)->re_tree_hd) != TREE_NULL )  { \
                (_res)->re_tree_hd = (_tp)->tr_b.tb_left; \
                (_tp)->tr_b.tb_left = TREE_NULL; \
                (_res)->re_tree_get++; \
        } else { \
                GETUNION( _tp, tree ); \
                (_res)->re_tree_malloc++; \
        }\
        }

{ \
                (_tp)->tr_b.tb_left = (_res)->re_tree_hd; \
                (_tp)->tr_b.tb_right = TREE_NULL; \
                (_res)->re_tree_hd = (_tp); \
                (_tp)->tr_b.tb_op = OP_FREE; \
                (_res)->re_tree_free++; \
        }

{ \
                memset( (char *)(_p), 0, sizeof(struct application) ); \
                (_p)->a_magic = RT_AP_MAGIC; \
        }

{if((_ap)->a_zero1||(_ap)->a_zero2) \
                rt_bomb("corrupt application struct"); }

{ \
        register struct bu_list *_head = &((_rti)->rti_solidheads[0]); \
        for( ; _head < &((_rti)->rti_solidheads[RT_DBNHASH]); _head++ ) \
                for( BU_LIST_FOR( _s, soltab, _head ) )  {

if( ssp->rstep[_ax] > 0 ) { \
                ssp->tv[_ax] = t0 + (nu_axis[_ax][_cno].nu_epos - _cval) * \
                                            ssp->inv_dir[_ax]; \
        } else if( ssp->rstep[_ax] < 0 ) { \
                ssp->tv[_ax] = t0 + (nu_axis[_ax][_cno].nu_spos - _cval) * \
                                            ssp->inv_dir[_ax]; \
        } else { \
                ssp->tv[_ax] = INFINITY; \
        }

if( ssp->rstep[_ax] != 0 )  { \
                ssp->tv[_ax] += nu_axis[_ax][_cno].nu_width * \
                        ssp->abs_inv_dir[_ax]; \
        }

{\
        switch (hm->l.magic) { \
        case NMG_RT_HIT_MAGIC: \
        case NMG_RT_HIT_SUB_MAGIC: \
        case NMG_RT_MISS_MAGIC: \
                break; \
        case NMG_MISS_LIST: \
                bu_log("%s[%d]: struct hitmiss has  NMG_MISS_LIST magic #\n",\
                        __FILE__, __LINE__); \
                rt_bomb("NMG_CK_HITMISS: going down in flames\n"); \
        case NMG_HIT_LIST: \
                bu_log("%s[%d]: struct hitmiss has  NMG_MISS_LIST magic #\n",\
                        __FILE__, __LINE__); \
                rt_bomb("NMG_CK_HITMISS: going down in flames\n"); \
        default: \
                bu_log("%s[%d]: bad struct hitmiss magic: %d:(0x%08x)\n", \
                        __FILE__, __LINE__, hm->l.magic, hm->l.magic); \
                rt_bomb("NMG_CK_HITMISS: going down in flames\n"); \
        }\
        if (!hm->hit.hit_private) { \
                bu_log("%s[%d]: NULL hit_private in hitmiss struct\n", \
                        __FILE__, __LINE__); \
                rt_bomb("NMG_CK_HITMISS: going down in flames\n"); \
        } \
}

{ \
    for (BU_LIST_FOR(a_hit, hitmiss, &rd->rd_hit)){NMG_CK_HITMISS(a_hit);} \
    for (BU_LIST_FOR(a_hit, hitmiss, &rd->rd_miss)){NMG_CK_HITMISS(a_hit);} }

{ \
        (_p) = BU_LIST_FIRST( hitmiss, &((_ap)->a_resource->re_nmgfree) ); \
        if( BU_LIST_IS_HEAD( (_p), &((_ap)->a_resource->re_nmgfree ) ) ) \
                (_p) = (struct hitmiss *)bu_calloc(1, sizeof( struct hitmiss ), "hitmiss" ); \
        else \
                BU_LIST_DEQUEUE( &((_p)->l) ); \
        }

{ \
        BU_CK_LIST_HEAD( (_p) ); \
        BU_LIST_APPEND_LIST( &((_ap)->a_resource->re_nmgfree), (_p) ); \
        }

{ \
        bu_log("%s", str); \
        if (rt_g.NMG_debug & DEBUG_NMGRT) rt_bomb("End of diagnostics"); \
        BU_LIST_INIT(&rd->rd_hit); \
        BU_LIST_INIT(&rd->rd_miss); \
        rt_g.NMG_debug |= DEBUG_NMGRT; \
        nmg_isect_ray_model(rd); \
        (void) nmg_ray_segs(rd); \
        rt_bomb("Should have bombed before this\n"); }

{ \
        if(BU_LIST_IS_EMPTY(fp)){ \
                BU_GETSTRUCT(p,solid); \
                db_full_path_init(&(p)->s_fullpath); \
        }else{ \
                p = BU_LIST_NEXT(solid,fp); \
                BU_LIST_DEQUEUE(&((p)->l)); \
                (p)->s_fullpath.fp_len = 0; \
        } \
        BU_LIST_INIT( &((p)->s_vlist) ); }

{ \
        BU_LIST_APPEND(fp, &((p)->l)); \
        RT_FREE_VLIST(&((p)->s_vlist)); }

(p1)=BU_LIST_PNEXT(structure,p2); \
        BU_LIST_NOT_HEAD(p1,hp);\
        (p1)=BU_LIST_PNEXT(structure,p1)

if (_dgop->dgo_wdbp == RT_WDB_NULL) \
        { \
                Tcl_AppendResult(_interp, "Not associated with a database!\n", (char *)NULL); \
                return TCL_ERROR; \
        }

while (*(_cp) != '\0' && \
           *(_cp) != '\n') \
        ++(_cp); \
\
    if (*(_cp) == '\0') \
        _eosFlag = 1; \
    else \
        *(_cp) = '\0';

librt geometry, raytracing

Files

Modules

Data Structures

Defines

Functions

Variables

Detailed Description

Define Documentation

Function Documentation

Variable Documentation


Files
file	light.h
	Declarations related to light sources.
file	mater.h
	Information about mapping between region IDs and material information (colors and outboard database "handles").
file	photonmap.h
	Declarations related to Photon Mapping.
file	raytrace.h
file	solid.h
file	bomb.c
file	bundle.c
file	dg_obj.c
file	fixpt.h
file	global.c
file	htbl.c
file	importFg4Section.c
file	many.c
file	mater.c
file	memalloc.c
file	mkbundle.c
file	nirt.c
file	oslo_calc.c
file	parse.c
file	plane.h
file	pmalloc.c
file	pr.c
file	qray.c
file	regionfix.c
file	roots.c
file	rt_dspline.c
file	spectrum.c
file	storage.c
file	tcl.c
file	track.c
file	tree.c
file	vdraw.c
file	view_obj.c
file	vlist.c
Modules