diff -urN rt_v51/cg.py rt_v52/cg.py --- rt_v51/cg.py 2018-06-04 23:11:09.000000000 +0900 +++ rt_v52/cg.py 2018-06-15 21:57:23.000000000 +0900 @@ -40,16 +40,17 @@ eye_f = way.liss_eye() wh2eye = lstx.opt( [ ax.wh_map(w, h), fcx.new(dz), ax.zoom_z(-1), ax.rot_x(90) ] ) + init_sec = ut.arg_f('init_sec', 0.0) dep_sec = True n = cnt.n while cnt.up(): i = cnt.cur() sec = cnt.cur_sec() - eye2g = ax.new_line( eye_f(sec) ) + eye2g = ax.new_line( eye_f(init_sec + sec) ) if dep_sec: - dep_sec = dat.setup(sec) + dep_sec = dat.setup(init_sec + sec) if 'wf' not in sys.argv: rt.del_cache() f = rt.draw diff -urN rt_v51/cool_car_cut.yaml rt_v52/cool_car_cut.yaml --- rt_v51/cool_car_cut.yaml 1970-01-01 09:00:00.000000000 +0900 +++ rt_v52/cool_car_cut.yaml 2018-06-15 21:57:23.000000000 +0900 @@ -0,0 +1,187 @@ +defs: + mov4: IMG_3999_4.mov + rtd_A: { base: 0.1, diff: 0, reflect: 0.5, reflact: 0.5, density: 2 } + rtd_a: { base: 0.1, diff: 0.3, reflect: 0.5, reflact: 0.2, density: 2 } + rtd_B: { base: 0.7, diff: 0.3 } + rtd_C: { base: 0.7, diff: 0.3, reflect: 0.5 } + transp: { base: 0, diff: 0.1, reflact: 0.9 } + + dark: [50,50,50] + red: [50,50,200] + + way1: 'way.get([(-1,1),(0,8),(0,1),(1,1),(0,8),(0,1),(-1,None)], sec)' + way2: 'way.get([(1,2),(1,1),(0.01,1),(1,1),(0.01,1),(1,1),(0.01,1),(1,2),(1,None)], sec)' + + sec10: '(lambda v: (v-int(v))*10.0)(sec/10.0)' + +big_ball: +- kind: ball + rtd: { diff: 0.3 } + maps: + - fn: '*mov4' + fn_r: '*mov4' + t2m: [ ax.zoom_all(2), ax.rot_x(90) ] + - fn: '*mov4' + fn_r: '*mov4' + t2m: [ ax.zoom_all(2), ax.rot_x(90), ax.rot_z(180) ] + m2g: [ ax.zoom_all(1000) ] + +ship_1: +- kind: ball + m2g: + - '@ax.slide_x( way1 )' + - 'ax.zoom([200,100,25])' + +ship_2: +- kind: ball + m2g: + - '@ax.slide_y( way1 )' + - 'ax.zoom([130,140,100])' + +ship_3: +- kind: ball + m2g: + - '@ax.slide_z( way1 )' + - 'ax.zoom([500,70,50])' + +ship: +- kind: and + args: + - kind: exports + exports: [ ship_1, ship_2, ship_3 ] + rtd: '*rtd_a' + def_col: '*red' + +ship_shadow: +- kind: xor + args: + - kind: exports + exports: [ ship_1, ship_2, ship_3 ] + rtd: '*transp' + +bottom: +- kind: cube + rtd: '*rtd_C' + def_col: '*dark' + m2g: + - 'ax.zoom([160,120,50])' + - ax.slide_z(30) + +room: +- kind: and + not: True + args: + - kind: cube + rtd: '*rtd_C' + def_col: '*dark' + m2g: + - 'ax.zoom([40,55,25])' + - 'ax.slide([-10,0,10])' + - kind: pipe + rtd: '*rtd_C' + def_col: '*dark' + m2g: + - ax.zoom_all(1.1) + - 'ax.zoom([40,55,50])' + - 'ax.slide([-10,0,10])' + +tire_house: +- kind: pipe + not: True + rtd: '*rtd_C' + def_col: '*dark' + m2g: + - ax.zoom_z(0.8) + - ax.rot_x(90) + - ax.zoom_all(24) + - 'ax.slide([90,55,-10])' + rxs: + - [ m2g, append, 2, [ ax.zoom_y(-1) ] ] + - [ m2g, append, 2, [ ax.zoom_x(-1) ] ] + +body: +- kind: and + args: + - kind: exports + exports: [ ship, bottom, room, tire_house ] + +tire: +- kind: pipe + rtd: '*rtd_a' + def_col: '*dark' + m2g: + - ax.zoom_z(0.6) + - ax.rot_x(90) + - ax.zoom_all(20) + - 'ax.slide([90,55,-10])' + rxs: + - [ m2g, append, 2, [ ax.zoom_y(-1) ] ] + - [ m2g, append, 2, [ ax.zoom_x(-1) ] ] + +shield: +- kind: and + args: + - kind: ball + rtd: '*rtd_A' + m2g: + - ax.zoom_all(170) + - kind: ball + not: True + rtd: '*rtd_A' + m2g: + - ax.zoom_all(168) + - kind: cube + m2g: + - 'ax.zoom([100,50,20])' + - ax.rot_y(-20) + - 'ax.slide([100,0,120])' + m2g: + - 'ax.slide([-80,0,-90])' + +lamp: +- kind: pipe + rtd: '*rtd_A' + m2g: + - 'ax.zoom([10,10,3])' + - ax.rot_y(90) + - 'ax.slide([125,50,0])' + rxs: + - [ m2g, append, 2, [ ax.zoom_y(-1) ] ] + +cool_car: +- kind: or + args: + - kind: exports + exports: [ body, tire, shield, lamp ] + +cut_cube: +- kind: cube + rtd: '*transp' + m2g: + - '@ax.zoom_x( way2 )' + - '@ax.rot_z( 90 if 4 < sec10 and sec10 < 6 else 0 )' + - '@ax.rot_y( 90 if 6 < sec10 and sec10 < 8 else 0 )' + - 'ax.zoom([130,70,70])' + + # shield hight + # 20+50*math.sin(math.pi*20/180)+120-90 = 67.10100716628344 + +car_etc: +- kind: and + args: + - kind: exports + exports: [ cool_car, cut_cube ] +- kind: export + export: ship_shadow + +all: +- kind: export + export: big_ball + +- kind: export + export: car_etc + m2g: + - ax.zoom_all(0.2) + - ax.rot_z(180) + +# EOF diff -urN rt_v51/cool_car_r.yaml rt_v52/cool_car_r.yaml --- rt_v51/cool_car_r.yaml 1970-01-01 09:00:00.000000000 +0900 +++ rt_v52/cool_car_r.yaml 2018-06-15 21:57:23.000000000 +0900 @@ -0,0 +1,149 @@ +defs: + mov4: IMG_3999_4.mov + rtd_A: { base: 0.1, diff: 0, reflect: 0.5, reflact: 0.5, density: 2 } + rtd_a: { base: 0.1, diff: 0.3, reflect: 0.5, reflact: 0.2, density: 2 } + rtd_B: { base: 0.7, diff: 0.3 } + rtd_C: { base: 0.7, diff: 0.3, reflect: 0.5 } + dark: [50,50,50] + red: [50,50,200] + +big_ball: +- kind: ball + rtd: { diff: 0.3 } + maps: + - fn: '*mov4' + fn_r: '*mov4' + t2m: [ ax.zoom_all(2), ax.rot_x(90) ] + - fn: '*mov4' + fn_r: '*mov4' + t2m: [ ax.zoom_all(2), ax.rot_x(90), ax.rot_z(180) ] + m2g: [ ax.zoom_all(1000) ] + +body: +- kind: and + + # ship + args: + - kind: ball + rtd: '*rtd_a' + def_col: '*red' + m2g: + - 'ax.zoom([200,100,25])' + - kind: ball + rtd: '*rtd_a' + def_col: '*red' + m2g: + - 'ax.zoom([130,140,100])' + - kind: ball + rtd: '*rtd_a' + def_col: '*red' + m2g: + - 'ax.zoom([500,70,50])' + + # bottom + - kind: cube + rtd: '*rtd_C' + def_col: '*dark' + m2g: + - 'ax.zoom([160,120,50])' + - ax.slide_z(30) + + # room + - kind: and + not: True + args: + - kind: cube + rtd: '*rtd_C' + def_col: '*dark' + m2g: + - 'ax.zoom([40,55,25])' + - 'ax.slide([-10,0,10])' + - kind: pipe + rtd: '*rtd_C' + def_col: '*dark' + m2g: + - ax.zoom_all(1.1) + - 'ax.zoom([40,55,50])' + - 'ax.slide([-10,0,10])' + + # tire house + - kind: pipe + not: True + rtd: '*rtd_C' + def_col: '*dark' + m2g: + - ax.zoom_z(0.8) + - ax.rot_x(90) + - ax.zoom_all(24) + - 'ax.slide([90,55,-10])' + rxs: + - [ m2g, append, 2, [ ax.zoom_y(-1) ] ] + - [ m2g, append, 2, [ ax.zoom_x(-1) ] ] + +tire: +- kind: pipe + rtd: '*rtd_a' + def_col: '*dark' + m2g: + - ax.zoom_z(0.6) + - ax.rot_x(90) + - ax.zoom_all(20) + - 'ax.slide([90,55,-10])' + rxs: + - [ m2g, append, 2, [ ax.zoom_y(-1) ] ] + - [ m2g, append, 2, [ ax.zoom_x(-1) ] ] + +shield: +- kind: and + args: + - kind: ball + rtd: '*rtd_A' + m2g: + - ax.zoom_all(170) + - kind: ball + not: True + rtd: '*rtd_a' + m2g: + - ax.zoom_all(168) + - kind: cube + m2g: + - 'ax.zoom([100,50,20])' + - ax.rot_y(-20) + - 'ax.slide([100,0,120])' + m2g: + - 'ax.slide([-80,0,-90])' + +lamp: +- kind: pipe + rtd: '*rtd_A' + m2g: + - 'ax.zoom([10,10,3])' + - ax.rot_y(90) + - 'ax.slide([125,50,0])' + rxs: + - [ m2g, append, 2, [ ax.zoom_y(-1) ] ] + +cool_car: +- kind: export + export: body + +- kind: export + export: tire + +- kind: export + export: shield + +- kind: export + export: lamp + +all: +- kind: export + export: big_ball + +- kind: export + export: cool_car + m2g: + - ax.zoom_all(0.2) + - ax.rot_z(180) + +# EOF diff -urN rt_v51/cross.c rt_v52/cross.c --- rt_v51/cross.c 2018-06-14 01:04:12.000000000 +0900 +++ rt_v52/cross.c 2018-06-15 21:57:23.000000000 +0900 @@ -88,20 +88,15 @@ n = quadratic_formula(a, b, c, ts); + if(n == 0){ + return 0; + } if(ret->use_ts_only){ - ret->ts_n = 0; - if(eq_d){ - return ret->ts_n; - } for(i=0; its[ ret->ts_n++ ] = ts[i]; } return ret->ts_n; } - - if(n == 0){ - return 0; - } if(n > 1 && eq_d){ if( fabs(ts[0]) < fabs(ts[1]) ){ ts[0] = ts[1]; @@ -145,20 +140,15 @@ n = quadratic_formula(a, b, c, ts); + if(n == 0){ + return 0; + } if(ret->use_ts_only){ - ret->ts_n = 0; - if(eq_d){ - return ret->ts_n; - } for(i=0; its[ ret->ts_n++ ] = ts[i]; } return ret->ts_n; } - - if(n == 0){ - return 0; - } if(n > 1 && eq_d){ if( fabs(ts[0]) < fabs(ts[1]) ){ ts[0] = ts[1]; @@ -215,11 +205,10 @@ n = quadratic_formula(a, b, c, ts); + if(n == 0){ + return 0; + } if(ret->use_ts_only){ - ret->ts_n = 0; - if(eq_d){ - return ret->ts_n; - } for(i=0; ip); if( 0p[2] && ret->p[2]<1 ){ @@ -228,10 +217,6 @@ } return ret->ts_n; } - - if(n == 0){ - return 0; - } if(n > 1 && eq_d){ if( fabs(ts[0]) < fabs(ts[1]) ){ ts[0] = ts[1]; @@ -284,17 +269,8 @@ { if(ret->use_ts_only){ ret->ts_n = 0; - } - - switch(kind_idx){ - case KIND_SQUARE: - case KIND_CIRCLE: - case KIND_TRIANGLE: - if(eq_d){ - return 0; - } - default: - break; + }else if( is_plane(kind_idx) && eq_d ){ + return 0; } lstx_tr_line(l2g, G2L, l_g, &ret->l); @@ -402,19 +378,6 @@ } static int -get_idx_of_id(struct data *data, int id) -{ - int i; - - for(i=0; in; i++){ - if(data->lst[i].id == id){ - return i; - } - } - return -1; -} - -static int is_op_area_none(int op, struct area *a) { int v = -1; @@ -432,13 +395,47 @@ return v != -1 && area_is_all(a, v); } +static void +cross_op_ins(struct line *l_g, int prev_idx, struct data *data, struct area *a, struct cross_ret *r) +{ + struct data_one *d = &data->lst[r->idx]; + int n = r->ts_n; + + area_init(a, 0); + if(n == 0){ + if(is_plane(d->kind) && r->l.p[2] < 0){ + area_not(a); + } + }else if(n == 1){ + r->t = r->ts[0]; + line_on_line_p( &r->l, r->t, r->p ); + cross_get_nv( d->kind, &d->l2g, l_g, 0, r ); + r->flags = 0; + area_ins( a, r->t, r, sizeof(*r) ); + if(r->ang_nv_eyev > 0){ + area_not(a); + } + }else{ /* n == 2 */ + int i; + for(i=0; i<2; i++){ + r->t = r->ts[i]; + line_on_line_p( &r->l, r->t, r->p ); + r->flags = 0; + if( prev_idx == r->idx && fabs(r->t) < fabs(r->ts[1-i]) ){ + r->flags |= CROSS_FLAG_PREV; + } + area_ins( a, r->t, r, sizeof(*r) ); + } + } +} + static int cross_op(struct line *l_g, int prev_idx, struct data *data, int p_i, struct area *ret_a) { struct data_one *pd = &data->lst[p_i]; int op = kind_to_op(pd->kind); - int i, j, k, n; - int v = op == AREA_OP_AND ? 1 : 0; + int i, j; + int v = (op == AREA_OP_AND) ? 1 : 0; area_init(ret_a, v); @@ -447,7 +444,7 @@ struct data_one *d; struct area a; - j = get_idx_of_id(data, id); + j = data_get_idx(id); if(j < 0){ continue; } @@ -462,30 +459,9 @@ struct cross_ret r; r.use_ts_only = 1; - n = cross_cross_one( d->kind, &d->l2g, prev_idx == j, l_g, &r ); - + cross_cross_one( d->kind, &d->l2g, prev_idx == j, l_g, &r ); r.idx = j; - area_init(&a, 0); - - if(n == 0){ - if(is_plane(d->kind) && r.l.p[2] < 0){ - area_init(&a, 1); - } - }else if(n == 1){ - r.t = r.ts[0]; - line_on_line_p(&r.l, r.t, r.p); - cross_get_nv( d->kind, &d->l2g, l_g, 0, &r ); - area_ins(&a, r.t, &r, sizeof(r)); - if(r.ang_nv_eyev > 0){ - area_not(&a); - } - }else{ - for(k=0; k<2; k++){ - r.t = r.ts[k]; - line_on_line_p(&r.l, r.t, r.p); - area_ins(&a, r.t, &r, sizeof(r)); - } - } + cross_op_ins(l_g, prev_idx, data, &a, &r); } if(d->not){ @@ -502,11 +478,18 @@ } static int +node_get_flags(struct node *p) +{ + struct cross_ret *r = (struct cross_ret *)p->d; + return r->flags; +} + +static int my_area_sel(struct area *a, struct cross_ret *ret) { struct node *p = a->p; - while(p && p->t <= 0){ + while( p && ( p->t <= 0 || (node_get_flags(p) & CROSS_FLAG_PREV) ) ){ p = p->next; } if(p){ diff -urN rt_v51/cross.h rt_v52/cross.h --- rt_v51/cross.h 2018-06-08 00:23:05.000000000 +0900 +++ rt_v52/cross.h 2018-06-15 21:57:23.000000000 +0900 @@ -14,15 +14,17 @@ double t; struct line l; double p[3]; -/* - double diff; -*/ + int flags; + /* for kind 'and' */ int use_ts_only; int ts_n; double ts[2]; }; +/* flags */ +#define CROSS_FLAG_PREV (1<<0) + int plane_z0(struct cross_ret *ret); int plane_z0_xy_cond(int (*xy_cond_f)(double x, double y), struct cross_ret *ret); int square_xy(double x, double y); diff -urN rt_v51/dat.c rt_v52/dat.c --- rt_v51/dat.c 2018-06-14 01:14:50.000000000 +0900 +++ rt_v52/dat.c 2018-06-15 21:57:59.000000000 +0900 @@ -154,6 +154,39 @@ return bp; } +/**/ + +static struct ut_itbl data_itbl = { 0, NULL, NULL, { 0, -1, NULL, NULL } }; + +static void +data_itbl_alloc() +{ + int i, n = data.n; + int *tbl = malloc( sizeof(*tbl) * n ); + for(i=0; ilst[i]); } FREE_LST(*data, "data"); + + data_itbl_free(); } void diff -urN rt_v51/dat.h rt_v52/dat.h --- rt_v51/dat.h 2018-06-14 01:14:50.000000000 +0900 +++ rt_v52/dat.h 2018-06-15 21:58:11.000000000 +0900 @@ -71,6 +71,8 @@ char *unpack_data_one(char *bp, struct data_one *d); +int data_get_idx(int id); + struct data *data_get(void); struct lights *lights_get(void); diff -urN rt_v51/dat.py rt_v52/dat.py --- rt_v51/dat.py 2018-06-14 01:39:46.000000000 +0900 +++ rt_v52/dat.py 2018-06-15 21:57:23.000000000 +0900 @@ -34,28 +34,18 @@ v = val.cli.geti(v) d[k] = v -ds_copy = lambda ds: ut.map_lst( lambda d: d.copy(), ds ) - -def ds_copy_k(d, k): - if k in d: - d[k] = ds_copy( d.get(k, []) ) - def lst_copy_r(lst): return ut.map_lst( lambda v: lst_copy_r(v) if type(v) == list else v, lst ) -def lst_copy_k(d, k): +def k_update_if_has(d, k, update_func): if k in d: - d[k] = lst_copy_r( d.get(k) ) + d[k] = update_func( d.get(k) ) def d_copy(d): d = d.copy() - ds_copy_k(d, 'maps') - lst_copy_k(d, 'rxs') - - k = 'args' - if k in d: - d[k] = ut.map_lst( d_copy, d.get(k) ) - + k_update_if_has( d, 'maps', lambda lst: ut.map_lst( lambda d: d.copy(), lst ) ) + k_update_if_has( d, 'rxs', lst_copy_r ) + k_update_if_has( d, 'args', lambda lst: ut.map_lst( d_copy, lst ) ) return d def m_setup(d, m): @@ -377,11 +367,35 @@ return ret_lst( [d0,d1], f ) ### + if kind == 'exports': + lst = [] + exports = if_has_pop(d, 'exports', []) + for export in exports: + d_ = d_copy(d) + d_['kind'] = 'export' + d_['export'] = export + lst.append(d_) + return data_setup_exp( lst, in_op ) + if kind == 'export': lst = ydic.get( if_has_pop(d, 'export', ''), [] ) - d['kind'] = 'or' - d['args'] = lst - return d_setup(d, in_op) + lst = ut.map_lst( d_copy, lst ) + + l2g = if_has_pop(d, 'l2m', []) + if_has_pop(d, 'm2g', []) + + for d_ in lst: + d_['maps'] = d_.get('maps', []) + d.get('maps', []) + + for k in [ 'def_col', 'def_col_r', 'rtd' ]: + if k not in d_ and k in d: + d_[k] = d.get(k) + + if d.get('not', False): + d_['not'] = not d_.get('not', False) + + d_['m2g'] = d_.get('m2g', []) + l2g + + return data_setup_exp( lst, in_op ) ### if 'rxs' in d: @@ -411,8 +425,12 @@ ds = [] for d_ in args: - #d_['m2g'] = d_.get('m2g', []) + l2g d_['maps'] = d_.get('maps', []) + d.get('maps', []) + + for k in [ 'def_col', 'def_col_r', 'rtd' ]: + if k not in d_ and k in d: + d_[k] = d.get(k) + ds += d_setup(d_, True) if 'children' not in d: # ! @@ -446,15 +464,15 @@ d_['m2g'] = d_.get('m2g', []) + l2g setup_m2g(data, d_) -def setup_kind(d): +def setup_etc(d): + # kind if not val.cli.has_prop('kinds'): val.cli.set_prop( 'kinds', '[str]', kinds ) kind = d.get('kind') if type(kind) != int: d['kind'] = kinds.index(kind) - return d -def setup_ids(d): + # ids k = 'id' if k not in d: d[k] = get_id() @@ -464,16 +482,14 @@ k = 'children' if k not in d: d[k] = [] - return d -def setup_def_col(d): + # def_col if 'def_col' not in d: d['def_col'] = [128,128,128] if 'def_col_r' not in d: d['def_col_r'] = d.get('def_col') - return d -def setup_rtd(d): + # rtd def_rtd = { 'base': 0.3, 'diff': 0.9, 'reflect': 0, 'reflact': 0, 'density': 1.0, 'reflect_backside': False } if 'rtd' not in d: d['rtd'] = def_rtd @@ -481,19 +497,18 @@ for k in def_rtd.keys(): if k not in rtd: rtd[k] = def_rtd.get(k) - return d -def setup_not_hide(d): + # not hide for k in ['not', 'hide']: if k not in d: d[k] = False # default - return d -def setup_maps(d): + # maps if 'maps' not in d: d['maps'] = [] for m in d.get('maps'): m_setup(d, m) + return d def setup_opt(d): @@ -512,6 +527,7 @@ data_name = ut.arg_s('data_name', 'copen') fn = ut.arg_s('yaml', 'dat.yaml') yd = ut.yaml_load(fn, {}) + yd = ut.defs_str_replace(yd) yd = ut.defs_eval(yd) yd = tm_sft_copy(yd) @@ -527,12 +543,7 @@ #print('data={}'.format( ut.yaml_dump( ut.dic_to_items(data) ) ) ) - data = ut.map_lst( setup_kind, data ) - data = ut.map_lst( setup_ids, data ) - data = ut.map_lst( setup_def_col, data ) - data = ut.map_lst( setup_rtd, data ) - data = ut.map_lst( setup_not_hide, data ) - data = ut.map_lst( setup_maps, data ) + data = ut.map_lst( setup_etc, data ) data = setup_eval_ax(data, sec) data = ut.map_lst( setup_opt, data ) diff -urN rt_v51/ut.c rt_v52/ut.c --- rt_v51/ut.c 2018-05-30 20:09:11.000000000 +0900 +++ rt_v52/ut.c 2018-06-15 21:58:23.000000000 +0900 @@ -185,4 +185,54 @@ return i; } +/**/ + +void +ut_itbl_alloc(struct ut_itbl *t, int n, int *tbl) +{ + int i; + + t->n = n; + t->tbl = tbl; + + t->idxs = malloc( sizeof(*t->idxs) * n ); + for(i=0; iidxs[i] = i; + } + + t->ctbl.n = n; + t->ctbl.chain_max_n = -1; + t->ctbl.tbl = NULL; + t->ctbl.geti = ut_cache_geti_int; + ut_cache_alloc(&t->ctbl); + + for(i=0; ictbl, &tbl[i], sizeof(tbl[i]), &t->idxs[i] ); + } +} + +int +ut_itbl_get_idx(struct ut_itbl *t, int v) +{ + int *p = ut_cache_get(&t->ctbl, &v, sizeof(v)); + return p ? *p : -1; +} + +int +ut_itbl_get_v(struct ut_itbl *t, int i) +{ + return in_range(i, t->n) ? t->tbl[i] : -1; +} + +void +ut_itbl_free(struct ut_itbl *t) +{ + ut_cache_free(&t->ctbl); + + if(t->idxs){ + free(t->idxs); + t->idxs = NULL; + } +} + /* EOF */ diff -urN rt_v51/ut.h rt_v52/ut.h --- rt_v51/ut.h 2018-05-30 20:09:11.000000000 +0900 +++ rt_v52/ut.h 2018-06-15 21:58:23.000000000 +0900 @@ -45,4 +45,18 @@ int ut_cache_geti_int(void *k, int ksz); int ut_cache_geti_str(void *k, int ksz); +/**/ + +struct ut_itbl{ + int n; + int *tbl; + int *idxs; + struct ut_cache_tbl ctbl; +}; + +void ut_itbl_alloc(struct ut_itbl *t, int n, int *tbl); +int ut_itbl_get_idx(struct ut_itbl *t, int v); +int ut_itbl_get_v(struct ut_itbl *t, int i); +void ut_itbl_free(struct ut_itbl *t); + #endif diff -urN rt_v51/ut.py rt_v52/ut.py --- rt_v51/ut.py 2018-06-14 00:00:31.000000000 +0900 +++ rt_v52/ut.py 2018-06-15 21:57:23.000000000 +0900 @@ -292,23 +292,26 @@ return map_lst( items_to_dic, o ) return o -def defs_eval(d): +def defs_str_replace(d, top_mark='@', do_eval=False, del_defs=False): # sample yaml # # defs: - # foo: 123 - # bar: 456 + # foo: abc + # bar: hello # data: - # k1: "*foo" - # k2: "* foo + bar - 1" + # k1: "@bar world" + # k2: "@foo mart, bar" defs_stk = [] def defs_x(s): for d in defs_stk: - if s in d: - v = d.get(s) - return "'{}'".format(v) if type(v) == str else str(v) + if s not in d: + continue + v = d.get(s) + if type(v) != str: + return str(v) + return "'{}'".format(v) if do_eval else v return s def f(o): @@ -320,15 +323,24 @@ ks = list( o.keys() ) if 'defs' in ks: defs = o.get('defs') - ks.remove('defs') + if del_defs: + ks.remove('defs') defs_stk.insert(0, defs) d = dict( map_lst( lambda k: ( k, f( o.get(k) ) ), ks ) ) if defs: defs_stk.pop(0) return d - if t == str and o.startswith('*'): - return eval( ' '.join( map( defs_x, o[1:].split(' ') ) ) ) + if t == str and o.startswith(top_mark): + s = o[1:] # split top_mark + bak = '' + while s != bak: + bak = s + s = ' '.join( map( defs_x, s.split(' ') ) ) + return eval(s) if do_eval else s return o return f(d) + +defs_eval = lambda d: defs_str_replace(d, top_mark='*', do_eval=True, del_defs=True) + # EOF diff -urN rt_v51/way.py rt_v52/way.py --- rt_v51/way.py 2018-06-11 23:39:01.000000000 +0900 +++ rt_v52/way.py 2018-06-15 21:57:23.000000000 +0900 @@ -93,8 +93,7 @@ return lambda t, itp3=True: liss(ps, pe, t3)(t + add_t, itp3) return liss_get('eye'+k) - init_sec = ut.arg_f('init_sec', 0.0) - return lambda t, itp3=True: line.new_p2( f('p')(t+init_sec, itp3), f('t')(t+init_sec, itp3) ) + return lambda t, itp3=True: line.new_p2( f('p')(t, itp3), f('t')(t, itp3) ) def test(lst, itp3=False, end_t=4, stp_t=0.25): print( lst, 'itp3=', itp3 )