diff -urN rt_v24/Makefile rt_v25/Makefile --- rt_v24/Makefile 2018-04-18 10:36:13.000000000 +0900 +++ rt_v25/Makefile 2018-04-19 22:49:00.000000000 +0900 @@ -1,6 +1,6 @@ CC = gcc CFLAGS += -Wall -OBJS = sock.o cross.o lstx.o ax.o cylx.o fcx.o vecs.o line.o v.o mt.o +OBJS = sock.o rt.o cross.o lstx.o ax.o cylx.o fcx.o vecs.o line.o v.o mt.o all: sock diff -urN rt_v24/bin.py rt_v25/bin.py --- rt_v24/bin.py 1970-01-01 09:00:00.000000000 +0900 +++ rt_v25/bin.py 2018-04-20 01:37:14.000000000 +0900 @@ -0,0 +1,144 @@ +#!/usr/bin/env python + +import numpy as np +import struct +import six +import ut +import mt +import line +import vecs +import ax +import cylx +import fcx +import lstx + +pack_i4 = lambda i: struct.pack('=i', i) + +unpack_i4 = lambda s: ( struct.unpack_from('=i', s)[0], s[4:] ) + +pack_np64 = lambda np64_arr: np64_arr.tobytes() if six.PY3 else bytes( np.getbuffer(np64_arr) ) + +unpack_np64 = lambda s, n: ( np.frombuffer( s[:8*n], dtype=np.float64 ), s[8*n:] ) + +pack_f8 = lambda d: pack_np64( np.float64(d) ) + +def unpack_f8(s): + (a, s) = unpack_np64(s, 1) + return (a[0], s) + +pack_p = lambda p: pack_np64(p) + +unpack_p = lambda s: unpack_np64(s, 3) + +pack_line = lambda l: pack_p(l.p) + pack_p(l.v) + +def unpack_line(s): + (p, s) = unpack_p(s) + (v, s) = unpack_p(s) + return ( line.new(p, v), s ) + +pack_vs = lambda vs: pack_np64(vs.v3) + +def unpack_vs(s): + (v3, s) = unpack_np64(s, 3*3) + return ( vecs.new( v3.reshape(3,3) ), s ) + +pack_ax = lambda ax: pack_p(ax.p) + pack_vs(ax.vs) + +def unpack_ax(s): + (p, s) = unpack_p(s) + (vs, s) = unpack_vs(s) + return ( ax.new(p, vs), s ) + +pack_cx = lambda cx: pack_f8(cx.r) + pack_i4(cx.rev) + +def unpack_cx(s): + (r, s) = unpack_f8(s) + (rev, s) = unpack_i4(s) + return ( cylx.new(r, rev), s ) + +pack_fx = lambda fx: pack_f8(fx.dz) + pack_i4(fx,rev) + +def unpack_fx(s): + (dz, s) = unpack_f8(s) + (rev, s) = unpack_i4(s) + return ( fcx.new(dz, rev), s ) + +def pack_xx(x): + f = { 'ax': pack_ax, 'cylx': pack_cx, 'fcx': pack_fx }.get(x.typ) + return pack_i4( lstx.typs.index(x.typ) ) + f(x) + +def unpack_xx(s): + (ti, s) = unpack_i4(s) + f = { 'ax': unpack_ax, 'cylx': unpack_cx, 'fcx': unpack_fx }.get( lstx.typs[ti] ) + return f(s) + +pack_lx = lambda lst: pack_i4( len(lst) ) + b''.join( map( pack_xx, lst ) ) + +def unpack_lx(s): + (n, s) = unpack_i4(s) + lst = [] + for i in range(n): + (x, s) = unpack_xx(s) + lst.append(x) + return (lst, s) + +def pack_dic(dic, k_nm_lst): + return b''.join( ut.map_up( lambda k, nm: nm_dic_pack.get(nm)( dic.get(k) ), k_nm_lst ) ) + +def unpack_dic(s, k_nm_lst): + dic = {} + for (k, nm) in k_nm_lst: + ( dic[k], s ) = nm_dic_unpack.get(nm)(s) + return (dic, s) + +rtd_k_nm_lst = [ + ('base', 'f8'), + ('diff', 'f8'), + ('reflect', 'f8'), + ('reflact', 'f8'), + ('density', 'f8'), +] + +pack_rtd = lambda rtd: pack_dic(rtd, rtd_k_nm_lst) + +unpack_rtd = lambda s: unpack_dic(s, rtd_k_nm_lst) + + +# lights ltd + +ltd_pvs = [ 'p', 'v' ] + +ltd_k_nm_lst = [ + ('pvi', 'i4'), + ('dmy', 'i4'), + ('p', 'p'), + ('v', 'p'), + ('e', 'f8'), +] + +def pack_ltd(ltd): + k = 'p' if 'p' in ltd else 'v' + dic = { + 'pvi': ltd_pvs.index(k), + 'dmy': 0, + 'p': ltd.get( 'p', mt.zero ), + 'v': ltd.get( 'v', mt.arr([0,0,-1]) ), + 'e': ltd.get( 'e', 1.0 ), + } + return pack_dic(dic, ltd_k_nm_lst) + +def unpack_ltd(s): + (dic, s) = unpack_dic(s, ltd_k_nm_lst) + k = ltd_pvs[ dic.get('pvi') ] + ltd = { k: dic.get(k), 'e': dic.get('e') } + return (ltd, s) + +nms = [ + 'i4', 'np64', 'f8', 'p', 'line', 'vs', 'ax', 'cx', 'fx', 'xx', + 'lx', 'rtd', 'ltd', +] +nm_dic_pack = dict( map( lambda nm: ( nm, eval('pack_' + nm) ), nms ) ) +nm_dic_unpack = dict( map( lambda nm: ( nm, eval('unpack_' + nm) ), nms ) ) + +# EOF diff -urN rt_v24/cg.py rt_v25/cg.py --- rt_v24/cg.py 2018-04-18 13:37:03.000000000 +0900 +++ rt_v25/cg.py 2018-04-19 22:50:57.000000000 +0900 @@ -255,14 +255,13 @@ data = sum( map( d_setup, dat.data ), [] ) + lights = dat.lights + if 'use_srv' in sys.argv: sock.server_boot( len(data) ) sock.client.conn() - for (i, d) in enumerate(data): - ax_ = d.get('l2g')[0] - sock.client.add( i, d.get('kind'), ax_ ) - - lights = dat.lights + sock.client.add_data(data) + sock.client.add_lights(lights) (w, h) = ( ut.arg_i('w', 640) , ut.arg_i('h', 480) ) div = ut.arg_i('div', 1) diff -urN rt_v24/cross.h rt_v25/cross.h --- rt_v24/cross.h 2018-04-18 16:46:28.000000000 +0900 +++ rt_v25/cross.h 2018-04-19 22:02:29.000000000 +0900 @@ -3,6 +3,7 @@ #include "mt.h" #include "ax.h" +#include "dat.h" struct cross_ret{ double t; @@ -12,6 +13,7 @@ double nv[3]; double eyev[3]; double ang_nv_eyev; + double diff; }; int plane_z0(struct cross_ret *ret); @@ -27,13 +29,6 @@ int pipe_side(int eq_d, struct cross_ret *ret); int cone_side(int eq_d, struct cross_ret *ret); -#define KIND_SQUARE 0 -#define KIND_CIRCLE 1 -#define KIND_TRIANGLE 2 -#define KIND_BALL 3 -#define KIND_PIPE_SIDE 4 -#define KIND_CONE_SIDE 5 - int cross_cross(int kind_idx, struct ax *l2g, int eq_d, struct line *l_g, struct cross_ret *ret); void cross_nv(int kind_idx, struct ax *l2g, struct line *l_g, struct cross_ret *ret); diff -urN rt_v24/dat.h rt_v25/dat.h --- rt_v24/dat.h 1970-01-01 09:00:00.000000000 +0900 +++ rt_v25/dat.h 2018-04-20 01:12:42.000000000 +0900 @@ -0,0 +1,36 @@ +#ifndef __DAT_H__ +#define __DAT_H__ 1 + +#include "lstx.h" +#include "rt.h" + +#define KIND_SQUARE 0 +#define KIND_CIRCLE 1 +#define KIND_TRIANGLE 2 +#define KIND_BALL 3 +#define KIND_PIPE_SIDE 4 +#define KIND_CONE_SIDE 5 + +struct data{ + int ki; + struct lstx l2g; + struct rtd rtd; +}; + +#define LTD_TYP_P 0 +#define LTD_TYP_V 1 + +struct ltd{ + int typ; + int dmy; /* for padding */ + double p[3]; + double v[3]; + double e; +}; + +struct lights{ + int n; + struct ltd *lst; +}; + +#endif diff -urN rt_v24/lstx.c rt_v25/lstx.c --- rt_v24/lstx.c 2018-04-18 10:57:47.000000000 +0900 +++ rt_v25/lstx.c 2018-04-19 22:16:14.000000000 +0900 @@ -1,17 +1,17 @@ #include "lstx.h" void -lstx_tr_p_one(struct lstx *lx, int d, double *p, double *rp) +xx_tr_p(struct x_x *xx, int d, double *p, double *rp) { - switch(lx->typ){ + switch(xx->typ){ case TYP_AX: - ax_tr_p(&lx->ax, d, p, rp); + ax_tr_p(&xx->ax, d, p, rp); break; case TYP_CX: - cylx_tr_p(&lx->cx, d, p, rp); + cylx_tr_p(&xx->cx, d, p, rp); break; case TYP_FX: - fcx_tr_p(&lx->fx, d, p, rp); + fcx_tr_p(&xx->fx, d, p, rp); break; default: break; @@ -19,13 +19,14 @@ } void -lstx_tr_p(struct lstx *lx, int n, int d, double *p, double *rp) +lstx_tr_p(struct lstx *lx, int d, double *p, double *rp) { - int i, j; + int n, i, j; double p_[3]; + n = lx->n; if(n == 1){ - lstx_tr_p_one(lx, d, p, rp); + xx_tr_p(&lx->lst[0], d, p, rp); return; } @@ -33,7 +34,7 @@ for(i=0; ilst[j], d, p_, rp); } } @@ -42,16 +43,15 @@ { void **pp = (void **)arg; struct lstx *lx = pp[0]; - int n = *(int *)( pp[1] ); int d = *(int *)( pp[2] ); - lstx_tr_p(lx, n, d, p, rp); + lstx_tr_p(lx, d, p, rp); } void -lstx_tr_line(struct lstx *lx, int n, int d, struct line *l, struct line *rl) +lstx_tr_line(struct lstx *lx, int d, struct line *l, struct line *rl) { - void *arg[3] = { lx, &n, &d }; + void *arg[3] = { lx, &d }; line_tr_by_func(l, rl, func, arg); } diff -urN rt_v24/lstx.h rt_v25/lstx.h --- rt_v24/lstx.h 2018-04-18 10:56:31.000000000 +0900 +++ rt_v25/lstx.h 2018-04-19 22:17:05.000000000 +0900 @@ -9,7 +9,7 @@ #define TYP_CX 1 #define TYP_FX 2 -struct lstx{ +struct x_x{ int typ; /* union ... */ @@ -18,8 +18,13 @@ struct fcx fx; }; -void lstx_tr_p_one(struct lstx *lx, int d, double *p, double *rp); -void lstx_tr_p(struct lstx *lx, int n, int d, double *p, double *rp); -void lstx_tr_line(struct lstx *lx, int n, int d, struct line *l, struct line *rl); +struct lstx{ + int n; + struct x_x *lst; +}; + +void xx_tr_p(struct x_x *xx, int d, double *p, double *rp); +void lstx_tr_p(struct lstx *lx, int d, double *p, double *rp); +void lstx_tr_line(struct lstx *lx, int d, struct line *l, struct line *rl); #endif diff -urN rt_v24/lstx.py rt_v25/lstx.py --- rt_v24/lstx.py 2018-04-18 10:35:40.000000000 +0900 +++ rt_v25/lstx.py 2018-04-19 22:49:31.000000000 +0900 @@ -34,4 +34,6 @@ f = dic.get( ut.get_typ(targ, typ), tr_p ) return f(lst, d, targ) +typs = [ 'ax', 'cylx', 'fcx' ] + # EOF diff -urN rt_v24/rt.c rt_v25/rt.c --- rt_v24/rt.c 1970-01-01 09:00:00.000000000 +0900 +++ rt_v25/rt.c 2018-04-19 22:39:21.000000000 +0900 @@ -0,0 +1,40 @@ +#include "rt.h" +#include "dat.h" +#include "cross.h" + +double +rt_calc_diff(struct data *d, struct lights *lights, struct cross_ret *ret) +{ + struct rtd *rtd = &d->rtd; + int i; + double sum = 0; + double *crsp = ret->l_nv_g.p; + double ang_nv_eyev_nega = - ret->ang_nv_eyev; + + if(rtd->diff == 0){ + return 0; + } + + for(i=0; in; i++){ + double ltv[3] = {0,0,-1}; + struct ltd *ltd = &lights->lst[i]; + double ang_nv_lt, ang_nv_lt_nega; + + if(ltd->typ == LTD_TYP_P){ + v_sub(crsp, ltd->p, ltv); + if(dot(ltv, ltv) == 0){ + continue; + } + unit(ltv, ltv); + } + ang_nv_lt = dot(ret->nv, ltv); + ang_nv_lt_nega = -ang_nv_lt; + if(ang_nv_eyev_nega * ang_nv_lt_nega < 0){ + continue; + } + sum += fabs(ang_nv_lt) * ltd->e; + } + return sum * rtd->diff; +} + +/* EOF */ diff -urN rt_v24/rt.h rt_v25/rt.h --- rt_v24/rt.h 1970-01-01 09:00:00.000000000 +0900 +++ rt_v25/rt.h 2018-04-19 22:34:57.000000000 +0900 @@ -0,0 +1,14 @@ +#ifndef __RT_H__ +#define __RT_H__ 1 + +struct rtd{ + double base, diff, reflect, reflact, density; +}; + +struct data; +struct lights; +struct cross_ret; + +double rt_calc_diff(struct data *d, struct lights *lights, struct cross_ret *ret); + +#endif diff -urN rt_v24/rt.py rt_v25/rt.py --- rt_v24/rt.py 2018-04-18 16:41:04.000000000 +0900 +++ rt_v25/rt.py 2018-04-20 01:44:58.000000000 +0900 @@ -83,27 +83,7 @@ col = map_col( crs, rev, video ) col = mt.arr(col) - def diffusivity(): - diff = rtd.get('diff', 0.9) - if not diff: - return 0 - - def f(ltd): - ltv = ltd.get( 'v', mt.arr( [0,0,-1] ) ) - if 'p' in ltd: - ltv = crsp - ltd.get('p') - if all(ltv == 0): - return 0 - ltv = v.unit(ltv) - ang_nv_lt = np.dot( nv, ltv ) - ang_nv_lt_nega = -ang_nv_lt - if ang_nv_eyev_nega * ang_nv_lt_nega < 0: - return 0 - return abs( ang_nv_lt ) * ltd.get('e', 1.0) - - return sum( map( f, lights ) ) * diff - - diff = diffusivity() + diff = crs.get('diff') if use_srv else calc_diff(d, lights, crs) col = col * (base + diff) def reflect_col(): @@ -165,4 +145,33 @@ if col != []: col = np.fmin( col, 255 ) video.set(ix, iy, col) + +# for sock.py server + +def calc_diff(d, lights, crs): + rtd = d.get('rtd', {}) + diff = rtd.get('diff', 0.9) + if not diff: + return 0 + + crsp = crs.get('l_nv_g').p + nv = crs.get('nv') + ang_nv_eyev = crs.get('ang_nv_eyev') + ang_nv_eyev_nega = -ang_nv_eyev + + def f(ltd): + ltv = ltd.get( 'v', mt.arr( [0,0,-1] ) ) + if 'p' in ltd: + ltv = crsp - ltd.get('p') + if all(ltv == 0): + return 0 + ltv = v.unit(ltv) + ang_nv_lt = np.dot( nv, ltv ) + ang_nv_lt_nega = -ang_nv_lt + if ang_nv_eyev_nega * ang_nv_lt_nega < 0: + return 0 + return abs( ang_nv_lt ) * ltd.get('e', 1.0) + + return sum( map( f, lights ) ) * diff + # EOF diff -urN rt_v24/sock.c rt_v25/sock.c --- rt_v24/sock.c 2018-04-18 16:49:17.000000000 +0900 +++ rt_v25/sock.c 2018-04-20 01:14:42.000000000 +0900 @@ -2,21 +2,26 @@ #include #include #include "cross.h" +#include "lstx.h" +#include "rt.h" /* FILE *dbg; */ -struct data{ - int ki; - struct ax l2g; -}; +#define CMD_CLEAR 0 +#define CMD_ADD 1 +#define CMD_ADD_LIGHTS 2 +#define CMD_CROSS 3 +#define CMD_QUIT 4 struct data *data = NULL; int data_n = 0; +struct lights lights = { 0, NULL }; + void alloc(int n) { - int sz = sizeof(*data) * n; + int i, sz = sizeof(*data) * n; if(data){ free(data); @@ -24,6 +29,9 @@ } data = malloc(sz); data_n = n; + for(i=0; iv3); + memcpy(vs->v3, bp, n); bp += n; + vecs_init(vs); /* ! */ + return bp; +} + +char * +unpack_xx(char *bp, struct x_x *xx) +{ + int n; + + n = 4; + memcpy(&xx->typ, bp, n); bp += n; + + switch(xx->typ){ + case TYP_AX: + n = sizeof(xx->ax.p); + memcpy(&xx->ax.p, bp, n); bp += n; + bp = unpack_vs(bp, &xx->ax.vs); + break; + case TYP_CX: + n = sizeof(xx->cx); + memcpy(&xx->cx, bp, n); bp += n; + break; + case TYP_FX: + n = sizeof(xx->fx); + memcpy(&xx->fx, bp, n); bp += n; + break; + default: + break; + } + return bp; +} + +char * +unpack_lx(char *bp, struct lstx *lx) +{ + int n, i; + + n = 4; + memcpy(&lx->n, bp, n); bp += n; + + lx->lst = malloc( sizeof(*lx->lst) * lx->n ); + + for(i=0; in; i++){ + bp = unpack_xx(bp, &lx->lst[i]); } + return bp; } void add(void) { - char buf[ 4 + 4 + 8*3 + 8*3*3 ], *bp = buf; int n, i, ki; - double dbuf[ 3 + 3*3 ]; - struct vecs vs; + char *buf, *bp; - n = sizeof(buf); - fread(buf, 1, n, stdin); + fread(&n, sizeof(int), 1, stdin); + bp = buf = malloc(n); + fread(buf, 1, n, stdin); + n = 4; memcpy(&i, bp, n); bp += n; memcpy(&ki, bp, n); bp += n; - n = sizeof(dbuf); - memcpy(dbuf, bp, n); - data[i].ki = ki; - vecs_new(&vs, &dbuf[3]); - ax_new( &data[i].l2g, &dbuf[0], &vs ); + bp = unpack_lx(bp, &data[i].l2g); + + n = sizeof( data[i].rtd ); + memcpy(&data[i].rtd, bp, n); bp += n; + + if(buf){ + free(buf); + } /* fprintf(dbg, "a %d %d/%f %f %f/%f %f %f,%f %f %f,%f %f %f\n", i, data[i].ki, @@ -76,15 +145,38 @@ } void +add_lights(void) +{ + int n; + char *buf, *bp; + + fread(&n, sizeof(n), 1, stdin); + bp = buf = malloc(n); + + fread(buf, 1, n, stdin); + + n = 4; + memcpy(&lights.n, bp, n); bp += n; + + n = sizeof(*lights.lst) * lights.n; + lights.lst = malloc(n); + + memcpy(lights.lst, bp, n); bp += n; + + if(buf){ + free(buf); + } +} + +void cross_(void) { - int sz_int = 4; - char buf[ sizeof(struct line) + sz_int ], *bp = buf; - int n, i, prev_idx, idx; + char buf[ sizeof(struct line) + sizeof(int) ], *bp = buf; + int n, i, prev_idx, idx, sz; double dbuf[ sizeof(struct line) / sizeof(double) ]; struct line l_g; struct cross_ret ret, ret_; - char sbuf[ sz_int + sizeof(ret) ]; + char sbuf[ sizeof(int) * 2 + sizeof(ret) ]; n = sizeof(buf); fread(buf, 1, n, stdin); @@ -92,7 +184,7 @@ n = sizeof(dbuf); memcpy(dbuf, bp, n); bp += n; - n = sz_int; + n = sizeof(int); memcpy(&prev_idx, bp, n); line_new( &l_g, &dbuf[0], &dbuf[3] ); @@ -102,7 +194,7 @@ for(i=0; i= 0 ){ - cross_nv( data[idx].ki, &data[idx].l2g, &l_g, &ret ); + cross_nv( data[idx].ki, &data[idx].l2g.lst[0].ax, &l_g, &ret ); + ret.diff = rt_calc_diff( &data[idx], &lights, &ret ); } + sz = sizeof(sbuf); bp = sbuf; - n = sz_int; + + n = sizeof(int); + memcpy(bp, &sz, n); bp += n; + memcpy(bp, &idx, n); bp += n; n = sizeof(ret); memcpy(bp, &ret, n); bp += n; - n = sizeof(sbuf); + n = sz; fwrite(sbuf, 1, n, stdout); fflush(stdout); } @@ -140,18 +237,22 @@ n = (i 0 else '' + def send_recv(s, rn): e.sock.sendall(s) - return e.sock.recv(rn) if rn > 0 else '' + return recv(rn) def quit(): - send_recv(b'q', 1) + send_recv( bin.pack_i4( cmds.index('quit') ), 1 ) ut.kill_proc(e.proc) ut.cmd_exec('rm fifo') e.quit = quit - e.clear = lambda : send_recv(b'c', 0) + e.clear = lambda : send_recv( bin.pack_i4( cmds.index('clear') ), 0 ) - def add(i, kind, ax): - s = b'a' - s += pack_i4(i) - s += pack_i4( kinds.index(kind) ) - s += pack_ax(ax) + def add(i, d): + dic = { + 'idx': i, + 'ki': kinds.index( d.get('kind') ), + 'l2g': d.get('l2g'), + 'rtd': d.get('rtd'), + } + s = bin.pack_dic(dic, add_k_nm_lst) + s = bin.pack_i4( cmds.index('add') ) + bin.pack_i4( len(s) ) + s send_recv(s, 0) e.add = add + def add_data(data): + for (i, d) in enumerate(data): + add(i, d) + e.add_data = add_data + + def add_lights(lights): + s = bin.pack_i4( len(lights) ) + for ltd in lights: + s += bin.pack_ltd(ltd) + s = bin.pack_i4( cmds.index('add_lights') ) + bin.pack_i4( len(s) ) + s + send_recv(s, 0) + e.add_lights = add_lights + def cross(l_g, prev_idx=-1): - s = b'x' - s += pack_line(l_g) - s += pack_i4(prev_idx) - - s = send_recv(s, usz) - - (idx, s) = unpack_i4(s) - (t, s) = unpack_f8(s) - (l, s) = unpack_line(s) - (p, s) = unpack_p(s) - (l_nv_g, s) = unpack_line(s) - (nv, s) = unpack_p(s) - (eyev, s) = unpack_p(s) - (ang_nv_eyev, s) = unpack_f8(s) - - return { - 'idx': idx, - 't': t, - 'l': l, - 'p': p, - 'l_nv_g': l_nv_g, - 'nv': nv, - 'eyev': eyev, - 'ang_nv_eyev': ang_nv_eyev, - } + s = bin.pack_i4( cmds.index('cross_') ) + s += bin.pack_line(l_g) + s += bin.pack_i4(prev_idx) + + s = send_recv(s, 4) + s = recv( bin.unpack_i4(s)[0] ) + + (crs, s) = bin.unpack_dic(s, cross_ret_k_nm_lst) + return crs e.cross = cross return e @@ -129,6 +112,7 @@ def new_server(): e = ut.Empty() e.data = [] + e.lights = [] def alloc(n): e.data = [] @@ -149,14 +133,20 @@ err_msg = lambda s: sys.stderr.write(s + '\n') def add(): - s = recv( 4 + 4 + 8*3 + 8*3*3 ) - (i, s) = unpack_i4(s) - (ki, s) = unpack_i4(s) - (ax, s) = unpack_ax(s) - d = e.data[i] - d['kind'] = kinds[ki] - d['l2g'] = [ ax ] + s = recv( bin.unpack_i4( recv(4) )[0] ) + (dic, s) = bin.unpack_dic(s, add_k_nm_lst) + d = e.data[ dic.get('idx') ] + d['kind'] = kinds[ dic.get('ki') ] + d['l2g'] = dic.get('l2g') + d['rtd'] = dic.get('rtd') + def add_lights(): + s = recv( bin.unpack_i4( recv(4) )[0] ) + (n, s) = bin.unpack_i4(s) + for i in range(n): + (ltd, s) = bin.unpack_ltd(s) + e.lights.append(ltd) + e.in_ = [] e.out = [] @@ -167,8 +157,8 @@ send( e.in_.pop(0) ) return - (l_g, s) = unpack_line(s) - (prev_idx, s) = unpack_i4(s) + (l_g, s) = bin.unpack_line(s) + (prev_idx, s) = bin.unpack_i4(s) lst = [] for (i, d) in enumerate(e.data): @@ -189,23 +179,17 @@ 'nv': v.zero, 'eyev': v.zero, 'ang_nv_eyev': 0, + 'diff': 0, } if lst: crs = min( lst, key=lambda crs: crs.get('t') ) cross.nv(crs) - infs = [ - ('idx', pack_i4), - ('t', pack_f8), - ('l', pack_line), - ('p', pack_p), - ('l_nv_g', pack_line), - ('nv', pack_p), - ('eyev', pack_p), - ('ang_nv_eyev', pack_f8), - ] - s = b''.join( ut.map_up( lambda k, f: f( crs.get(k) ), infs ) ) + d = e.data[ crs.get('idx') ] + crs['diff'] = rt.calc_diff(d, e.lights, crs) + s = bin.pack_dic(crs, cross_ret_k_nm_lst) + s = bin.pack_i4( len(s) ) + s send(s) e.out.append(s) @@ -225,8 +209,10 @@ s = f.read() e.in_ = [] while s: - e.in_.append( s[:usz] ) - s = s[usz:] + (n, _) = bin.unpack_i4(s) + sz = 4 + n + e.in_.append( s[:sz] ) + s = s[sz:] def quit(): save() @@ -237,17 +223,20 @@ alloc( ut.arg_i('n', 100) ) load() while True: - cmd = recv(1) - f = { - b'c': clear, - b'a': add, - b'x': cross_, - b'q': quit, - }.get(cmd) - if f: + dic = { + 'clear': clear, + 'add': add, + 'add_lights': add_lights, + 'cross_': cross_, + 'quit': quit, + } + cmd_idx = bin.unpack_i4( recv(4) )[0] + if 0 <= cmd_idx and cmd_idx < len(cmds): + cmd = cmds[ cmd_idx ] + f = dic.get(cmd) f() else: - msg = '?' + ( ' cmd={:02x}' if cmd else '' ) + msg = '?' + ( ' cmd_idx={:02x}' if cmd_idx else '' ) err_msg(msg) sys.exit(1) e.main_loop = main_loop