diff -urN rt_v29/Makefile rt_v30/Makefile
--- rt_v29/Makefile	2018-04-30 01:49:22.000000000 +0900
+++ rt_v30/Makefile	2018-05-01 23:19:45.000000000 +0900
@@ -1,17 +1,19 @@
 CC = gcc
 CFLAGS += -Wall
-OBJS = dat.o val.o sock.o lstx.o ax.o cylx.o fcx.o vecs.o line.o v.o mt.o ut.o
+LIBS = -lm -lpthread
+OBJS = img.o dat.o val.o sock.o lstx.o ax.o cylx.o fcx.o vecs.o line.o v.o mt.o ut.o
 
-#all: cross rt
-all: cross
+all: cross rt
 
 cross: cross.c $(OBJS)
-	gcc -DSRV_CROSS -o $@ cross.c $(OBJS) -lm
+	gcc -DSRV_CROSS -o $@ cross.c $(OBJS) $(LIBS)
 
 rt: rt.c cross.c $(OBJS)
-	gcc -DSRV_RT -o $@ rt.c cross.o $(OBJS) -lm
+	gcc -DSRV_RT -o $@ rt.c cross.c $(OBJS) $(LIBS)
 
 clean:
 	rm -f cross rt
-	rm -f *.o *~
+	rm -f *.o *~ *.pyc
+	rm -rf __pycache__
+	find . -type d -name 'out*' | xargs rm -rf
 # EOF
diff -urN rt_v29/bin.py rt_v30/bin.py
--- rt_v29/bin.py	2018-04-30 01:48:34.000000000 +0900
+++ rt_v30/bin.py	2018-05-01 23:19:45.000000000 +0900
@@ -12,10 +12,16 @@
 import fcx
 import lstx
 
-pack_i4 = lambda i: struct.pack('=i', i)
+pack_i4 = lambda i: struct.pack( '=i', int(i) )
 
 unpack_i4 = lambda s: ( struct.unpack_from('=i', s)[0], s[4:] )
 
+pack_bool = lambda v: pack_i4( int(v) )
+
+def unpack_bool(s):
+	(i, s) = unpack_i4(s)
+	return ( bool(i), s )
+
 def pack_col(col):
 	if col == []:
 		col = [-1,-1,-1]
@@ -134,6 +140,7 @@
 	('reflect', 'f8'),
 	('reflact', 'f8'),
 	('density', 'f8'),
+	('reflect_backside', 'bool'),
 ]
 
 pack_rtd = lambda rtd: pack_dic(rtd, rtd_k_nm_lst)
@@ -169,7 +176,7 @@
 	return (ltd, s)
 
 nms = [
-	'i4', 'col', 'bytes', 'str', 'np64', 'f8',
+	'i4', 'bool', 'col', 'bytes', 'str', 'np64', 'f8',
 	'xyz', 'line', 'vs',
 	'ax', 'cx', 'fx', 'xx', 'lx',
 	'rtd', 'ltd',
diff -urN rt_v29/cmd.py rt_v30/cmd.py
--- rt_v29/cmd.py	1970-01-01 09:00:00.000000000 +0900
+++ rt_v30/cmd.py	2018-05-01 22:13:25.000000000 +0900
@@ -0,0 +1,43 @@
+#!/usr/bin/env python
+
+import sys
+import socket
+import threading
+import subprocess
+
+arg_s = lambda k, def_val='': next( ( s[ len(k)+1: ] for s in sys.argv if s.startswith(k+'=') ), def_val )
+arg_v = lambda fs, k, def_val: ( lambda s: fs(s) if s else def_val )( arg_s(k) )
+arg_i = lambda k, def_val: arg_v( int, k, def_val )
+
+def cmd_exec(cmd):
+	try:
+		return subprocess.check_output(cmd, shell=True)
+	except:
+		return ''
+
+def recv_nl(sock):
+	s = b''
+	while True:
+		s += sock.recv(4096)
+		if s[-1:] == b'\n':
+			break
+	return s[:-1]
+
+def func(sock):
+	s = recv_nl(sock)
+	sock.sendall( cmd_exec(s) )
+	#sock.shutdown(socket.SHUT_RDWR)
+	sock.close()
+
+if __name__ == "__main__":
+	port = arg_i('port', 7788)
+	sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+	sock.bind(('localhost', port))
+	sock.listen(5)
+
+	while True:
+		(csock, addr) = sock.accept()
+		th = threading.Thread( target=func, args=(csock,) )
+		th.daemon = True
+		th.start()
+# EOF
diff -urN rt_v29/cross.c rt_v30/cross.c
--- rt_v29/cross.c	2018-04-30 01:29:14.000000000 +0900
+++ rt_v30/cross.c	2018-05-01 23:19:45.000000000 +0900
@@ -296,7 +296,7 @@
 }
 
 void
-cross_cross(struct line *l_g, int prev_id, struct cross_ret *ret)
+cross_cross(struct line *l_g, int prev_idx, struct cross_ret *ret)
 {
 	struct data *data;
 	struct cross_ret ret_;
@@ -307,7 +307,7 @@
 	for(i=0; i<data->n; i++){
 		struct data_one *d = &data->lst[i];
 
-		if( !cross_cross_one( d->kind, &d->l2g.lst[0].ax, prev_id == i, l_g, &ret_ ) ){
+		if( !cross_cross_one( d->kind, &d->l2g.lst[0].ax, prev_idx == i, l_g, &ret_ ) ){
 			continue;
 		}
 		if( idx < 0 || ret_.t < ret->t ){
@@ -328,29 +328,14 @@
 	int sz;
 	char *buf = bp;
 
-	sz = sizeof(ret->idx);
-	memcpy(bp, &ret->idx, sz); bp += sz;
-
-	sz = sizeof(ret->l_nv_g);
-	memcpy(bp, &ret->l_nv_g, sz); bp += sz;
-
-	sz = sizeof(ret->nv);
-	memcpy(bp, ret->nv, sz); bp += sz;
-
-	sz = sizeof(ret->eyev);
-	memcpy(bp, ret->eyev, sz); bp += sz;
-
-	sz = sizeof(ret->ang_nv_eyev);
-	memcpy(bp, &ret->ang_nv_eyev, sz); bp += sz;
-
-	sz = sizeof(ret->t);
-	memcpy(bp, &ret->t, sz); bp += sz;
-
-	sz = sizeof(ret->l);
-	memcpy(bp, &ret->l, sz); bp += sz;
-
-	sz = sizeof(ret->p);
-	memcpy(bp, ret->p, sz); bp += sz;
+	bp = COPY_TO_BP(bp, ret->idx);
+	bp = COPY_TO_BP(bp, ret->l_nv_g);
+	bp = COPY_TO_BP_ARR(bp, ret->nv);
+	bp = COPY_TO_BP_ARR(bp, ret->eyev);
+	bp = COPY_TO_BP(bp, ret->ang_nv_eyev);
+	bp = COPY_TO_BP(bp, ret->t);
+	bp = COPY_TO_BP(bp, ret->l);
+	bp = COPY_TO_BP_ARR(bp, ret->p);
 
 	sz = bp - buf;
 	return sz;
@@ -362,23 +347,20 @@
 {
 	int sz;
 	struct line l_g;
-	int prev_id;
-	char buf[ sizeof(l_g) + sizeof(prev_id) ], *bp = buf;
+	int prev_idx;
+	char buf[ sizeof(l_g) + sizeof(prev_idx) ], *bp = buf;
 	struct cross_ret ret, send_buf;
 
 	read(fd, &sz, sizeof(sz));
 	if(sz != sizeof(buf)){
-		fprintf(stderr, "? srv_cross sz=%d sizeof(buf)=%lu\n", sz, sizeof(buf));
+		fprintf(stderr, "? srv_cross sz=%d sizeof(buf)=%d\n", sz, (int)sizeof(buf));
 	}
 	read(fd, buf, sizeof(buf));
 
-	sz = sizeof(l_g);
-	memcpy(&l_g, bp, sz); bp += sz;
-
-	sz = sizeof(prev_id);
-	memcpy(&prev_id, bp, sz); bp += sz;
+	bp = COPY_FROM_BP(bp, l_g);
+	bp = COPY_FROM_BP(bp, prev_idx);
 
-	cross_cross(&l_g, prev_id, &ret);
+	cross_cross(&l_g, prev_idx, &ret);
 
 	sz = pack_cross_ret((char *)&send_buf, &ret);
 	write(fd, &sz, sizeof(sz));
diff -urN rt_v29/cross.h rt_v30/cross.h
--- rt_v29/cross.h	2018-04-29 17:24:13.000000000 +0900
+++ rt_v30/cross.h	2018-05-01 23:19:45.000000000 +0900
@@ -34,6 +34,6 @@
 int cross_cross_one(int kind_idx, struct ax *l2g, int eq_d, struct line *l_g, struct cross_ret *ret);
 void cross_get_nv(int kind_idx, struct ax *l2g, struct line *l_g, struct cross_ret *ret);
 
-void cross_cross(struct line *l_g, int prev_id, struct cross_ret *ret);
+void cross_cross(struct line *l_g, int prev_idx, struct cross_ret *ret);
 
 #endif
diff -urN rt_v29/dat.c rt_v30/dat.c
--- rt_v29/dat.c	2018-04-30 00:02:01.000000000 +0900
+++ rt_v30/dat.c	2018-05-01 23:14:27.000000000 +0900
@@ -6,10 +6,7 @@
 char *
 unpack_vs(char *bp, struct vecs *vs)
 {
-	int n;
-
-	n = sizeof(vs->v3);
-	memcpy(vs->v3, bp, n); bp += n;
+	bp = COPY_FROM_BP_ARR(bp, vs->v3);
 	vecs_init(vs); /* ! */
 	return bp;
 }
@@ -17,24 +14,18 @@
 char *
 unpack_xx(char *bp, struct x_x *xx)
 {
-	int n;
-
-	n = sizeof(xx->typ);
-	memcpy(&xx->typ, bp, n); bp += n;
+	bp = COPY_FROM_BP(bp, xx->typ);
 
 	switch(xx->typ){
 	case TYP_AX:
-		n = sizeof(xx->ax.p);
-		memcpy(&xx->ax.p, bp, n); bp += n;
+		bp = COPY_FROM_BP_ARR(bp, xx->ax.p);
 		bp = unpack_vs(bp, &xx->ax.vs);
 		break;
 	case TYP_CX:
-		n = sizeof(xx->cx);
-		memcpy(&xx->cx, bp, n); bp += n;
+		bp = COPY_FROM_BP(bp, xx->cx);
 		break;
 	case TYP_FX:
-		n = sizeof(xx->fx);
-		memcpy(&xx->fx, bp, n); bp += n;
+		bp = COPY_FROM_BP(bp, xx->fx);
 		break;
 	default:
 		break;
@@ -45,13 +36,10 @@
 char *
 unpack_lx(char *bp, struct lstx *lx)
 {
-	int n, i;
-
-	n = sizeof(lx->n);
-	memcpy(&lx->n, bp, n); bp += n;
-
-	lx->lst = malloc( sizeof(*lx->lst) * lx->n );
+	int i;
 
+	bp = COPY_FROM_BP(bp, lx->n);
+	ALLOC_LST(*lx, "lx");
 	for(i=0; i<lx->n; i++){
 		bp = unpack_xx(bp, &lx->lst[i]);
 	}
@@ -61,36 +49,22 @@
 char *
 unpack_map(char *bp, struct map *m)
 {
-	int n;
-
 	bp = unpack_lx(bp, &m->xyz2g);
-
-	n = sizeof(m->fn);
-	memcpy(&m->fn, bp, n); bp += n;
-
-	n = sizeof(m->fn_r);
-	memcpy(&m->fn_r, bp, n); bp += n;
-
+	bp = COPY_FROM_BP(bp, m->fn);
+	bp = COPY_FROM_BP(bp, m->fn_r);
 	bp = unpack_lx(bp, &m->wh2xyz);
-
-	n = sizeof(m->rep_x);
-	memcpy(&m->rep_x, bp, n); bp += n;
-
-	n = sizeof(m->rep_y);
-	memcpy(&m->rep_y, bp, n); bp += n;
-
+	bp = COPY_FROM_BP(bp, m->rep_x);
+	bp = COPY_FROM_BP(bp, m->rep_y);
 	return bp;
 }
 
 char *
 unpack_maps(char *bp, struct maps *maps)
 {
-	int n, i;
-
-	n = sizeof(maps->n);
-	memcpy(&maps->n, bp, n); bp += n;
+	int i;
 
-	maps->lst = malloc( sizeof(*maps->lst) * maps->n );
+	bp = COPY_FROM_BP(bp, maps->n);
+	ALLOC_LST(*maps, "maps");
 	for(i=0; i<maps->n; i++){
 		bp = unpack_map(bp, &maps->lst[i]);
 	}
@@ -98,22 +72,25 @@
 }
 
 char *
-unpack_data_one(char *bp, struct data_one *d)
+unpack_rtd(char *bp, struct rtd *rtd)
 {
-	int n;
-
-	n = sizeof(d->kind);
-	memcpy(&d->kind, bp, n); bp += n;
+	bp = COPY_FROM_BP(bp, rtd->base);
+	bp = COPY_FROM_BP(bp, rtd->diff);
+	bp = COPY_FROM_BP(bp, rtd->reflect);
+	bp = COPY_FROM_BP(bp, rtd->reflact);
+	bp = COPY_FROM_BP(bp, rtd->density);
+	bp = COPY_FROM_BP(bp, rtd->reflect_backside);
+	return bp;
+}
 
+char *
+unpack_data_one(char *bp, struct data_one *d)
+{
+	bp = COPY_FROM_BP(bp, d->kind);
 	bp = unpack_lx(bp, &d->l2g);
-
-	n = sizeof(d->def_col);
-	memcpy(&d->def_col, bp, n); bp += n;
-
+	bp = COPY_FROM_BP_ARR(bp, d->def_col);
 	bp = unpack_maps(bp, &d->maps);
-
-	n = sizeof(d->rtd);
-	memcpy(&d->rtd, bp, n); bp += n;
+	bp = unpack_rtd(bp, &d->rtd);
 
 	return bp;
 }
@@ -121,13 +98,13 @@
 char *
 unpack_data(char *bp, struct data *data)
 {
-	int n, i;
+	int i;
 
-	n = sizeof(data->n);
-	memcpy(&data->n, bp, n); bp += n;
-
-	data->lst = malloc( sizeof(*data->lst) * data->n );
+	bp = COPY_FROM_BP(bp, data->n);
+	/*fprintf(stderr, "unpack_data n=%d\n", data->n);*/
+	ALLOC_LST(*data, "data");
 	for(i=0; i<data->n; i++){
+		/*hex_dump(bp, 512);*/
 		bp = unpack_data_one(bp, &data->lst[i]);
 	}
 	return bp;
@@ -136,32 +113,20 @@
 char *
 unpack_ltd(char *bp, struct ltd *ltd)
 {
-	int n;
-
-	n = sizeof(ltd->pvi);
-	memcpy(&ltd->pvi, bp, n); bp += n;
-
-	n = sizeof(ltd->p);
-	memcpy(ltd->p, bp, n); bp += n;
-
-	n = sizeof(ltd->v);
-	memcpy(ltd->v, bp, n); bp += n;
-
-	n = sizeof(ltd->e);
-	memcpy(&ltd->e, bp, n); bp += n;
-
+	bp = COPY_FROM_BP(bp, ltd->pvi);
+	bp = COPY_FROM_BP_ARR(bp, ltd->p);
+	bp = COPY_FROM_BP_ARR(bp, ltd->v);
+	bp = COPY_FROM_BP(bp, ltd->e);
 	return bp;
 }
 
 char *
 unpack_lights(char *bp, struct lights *lights)
 {
-	int n, i;
+	int i;
 
-	n = sizeof(lights->n);
-	memcpy(&lights->n, bp, n); bp += n;
-
-	lights->lst = malloc( sizeof(*lights->lst) * lights->n );
+	bp = COPY_FROM_BP(bp, lights->n);
+	ALLOC_LST(*lights, "lights");
 	for(i=0; i<lights->n; i++){
 		bp = unpack_ltd(bp, &lights->lst[i]);
 	}
@@ -183,11 +148,17 @@
 lights_get(void)
 {
 	if(lights.lst == NULL){
-		char *b = get_prop_bytes("lights", NULL);
+		char *b = get_prop("lights", NULL);
 		unpack_lights(b, &lights);
 		free(b);
 	}	
 	return &lights;
 }
 
+struct data_one *
+data_one_get(int idx)
+{
+	return &data_get()->lst[idx];
+}
+
 /* EOF */
diff -urN rt_v29/dat.h rt_v30/dat.h
--- rt_v29/dat.h	2018-04-29 17:22:57.000000000 +0900
+++ rt_v30/dat.h	2018-05-01 23:19:45.000000000 +0900
@@ -53,7 +53,11 @@
 	struct ltd *lst;
 };
 
+char *unpack_data_one(char *bp, struct data_one *d);
+
 struct data *data_get(void);
 struct lights *lights_get(void);
 
+struct data_one *data_one_get(int idx);
+
 #endif
diff -urN rt_v29/dat.py rt_v30/dat.py
--- rt_v29/dat.py	2018-04-27 23:40:43.000000000 +0900
+++ rt_v30/dat.py	2018-05-02 01:00:51.000000000 +0900
@@ -224,7 +224,7 @@
 	if k in d:
 		v = d.get(k)
 		if type(v) == int:
-			retrun
+			return
 		v = val.cli.geti(v)
 	d[k] = v
 
@@ -459,6 +459,13 @@
 	for m in d.get('maps'):
 		m_setup(d, m)
 
+	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
+	rtd = d.get('rtd')
+	for k in def_rtd.keys():
+		if k not in rtd:
+			rtd[k] = def_rtd.get(k)
 
 	kinds = [ 'square', 'circle', 'triangle', 'ball', 'pipe_side', 'cone_side' ]
 	if not val.cli.has_prop('kinds'):
diff -urN rt_v29/img.c rt_v30/img.c
--- rt_v29/img.c	1970-01-01 09:00:00.000000000 +0900
+++ rt_v30/img.c	2018-05-01 23:19:45.000000000 +0900
@@ -0,0 +1,62 @@
+#include "img.h"
+
+#define IMG_WH		0
+#define IMG_COL		1
+
+static int fd = -1;
+
+void
+img_conn(void)
+{
+	char *host = "localhost";
+	int port = SOCK_PORT + 12;
+
+	if(fd < 0){
+		fd = conn_host_port(host, port);
+	}
+	if(fd < 0){
+		fprintf(stderr, "? val boot\n");
+	}
+}
+
+void
+img_close(void)
+{
+	if(fd < 0){
+		return;
+	}
+	close(fd);
+	fd = -1;
+}
+
+void
+img_wh(int fn, int *wh)
+{
+	int cmd = IMG_WH;
+	int rets_sz = sizeof(*wh)*2;
+
+	img_conn();
+	sock_cli_call(fd, cmd, sizeof(fn), (char *)&fn, &rets_sz, (char *)wh);
+}
+
+void
+img_col(int fn, double sec, int x, int y, int *def_col, int rep_x, int rep_y, int *ret_col)
+{
+	int cmd = IMG_COL;
+	int args_sz = sizeof(fn) + sizeof(sec) + sizeof(x) + sizeof(y) + sizeof(*def_col)*3 + sizeof(rep_x) + sizeof(rep_y);
+	char args_buf[ args_sz ], *bp = args_buf;
+
+	img_conn();
+
+	bp = COPY_TO_BP(bp, fn);
+	bp = COPY_TO_BP(bp, sec);
+	bp = COPY_TO_BP(bp, x);
+	bp = COPY_TO_BP(bp, y);
+	bp = COPY_SZ_TO_BP(bp, def_col, sizeof(*def_col)*3);
+	bp = COPY_TO_BP(bp, rep_x);
+	bp = COPY_TO_BP(bp, rep_y);
+
+	sock_cli_call(fd, cmd, args_sz, args_buf, &args_sz, (char *)ret_col);
+}
+
+/* EOF */
diff -urN rt_v29/img.h rt_v30/img.h
--- rt_v29/img.h	1970-01-01 09:00:00.000000000 +0900
+++ rt_v30/img.h	2018-05-01 00:09:19.000000000 +0900
@@ -0,0 +1,13 @@
+#ifndef __IMG_H__
+#define __IMG_H__	1
+
+#include "sock.h"
+
+void img_conn(void);
+void img_close(void);
+
+void img_wh(int fn, int *wh);
+void img_col(int fn, double sec, int x, int y, int *def_col, int rep_x, int rep_y, int *ret_col);
+
+#endif
+
diff -urN rt_v29/line.c rt_v30/line.c
--- rt_v29/line.c	2018-04-17 21:56:00.000000000 +0900
+++ rt_v30/line.c	2018-05-02 00:58:16.000000000 +0900
@@ -29,7 +29,7 @@
 	f(l->p, p, arg);
 	v_add(l->p, l->v, tmp);	
 	f(tmp, tmp2, arg);
-	v_sub(tmp2, l->p, v);
+	v_sub(tmp2, p, v);
 	line_new(rl, p, v);
 }
 
diff -urN rt_v29/lstx.c rt_v30/lstx.c
--- rt_v29/lstx.c	2018-04-19 22:16:14.000000000 +0900
+++ rt_v30/lstx.c	2018-05-01 01:10:00.000000000 +0900
@@ -43,7 +43,7 @@
 {
 	void **pp = (void **)arg;
 	struct lstx *lx = pp[0];
-	int d = *(int *)( pp[2] );
+	int d = *(int *)( pp[1] );
 
 	lstx_tr_p(lx, d, p, rp);
 }
@@ -51,7 +51,7 @@
 void
 lstx_tr_line(struct lstx *lx, int d, struct line *l, struct line *rl)
 {
-	void *arg[3] = { lx, &d };
+	void *arg[] = { lx, &d };
 	line_tr_by_func(l, rl, func, arg);
 }
 
diff -urN rt_v29/rt.c rt_v30/rt.c
--- rt_v29/rt.c	2018-04-29 17:24:34.000000000 +0900
+++ rt_v30/rt.c	2018-05-02 00:59:34.000000000 +0900
@@ -1,11 +1,94 @@
 #include "dat.h"
+#include "img.h"
+#include "cross.h"
 #include "rt.h"
 
+void get_col(struct line *l_g, double sec, double nest_rate, int prev_idx, int *ret_col);
+
+int
+is_no_col(int *col)
+{
+	int i;
+	for(i=0; i<3; i++){
+		if(col[i]<0){
+			return 1;
+		}
+	}
+	return 0;
+}
+
+void
+copy_col(int *d, int *s)
+{
+	memcpy(d, s, sizeof(*d)*3);
+}
+
+void
+add_col(int *d, int *a)
+{
+	int i;
+	for(i=0; i<3; i++){
+		d[i] += a[i];
+	}
+}
+
+void
+map_col(int idx, struct line *l_nv_g, int rev, double sec, int *ret_col)
+{
+	struct data_one *d = data_one_get(idx);
+	int sz, i, fn;
+	int sum_col[3] = {-1,-1,-1};
+
+	if(d->maps.n <= 0){
+		copy_col(ret_col, d->def_col);
+		return;
+	}
+
+	for(i=0; i<d->maps.n; i++){
+		struct map *m = &d->maps.lst[i];
+		struct line nv_line;
+		int fd;
+		double p[3], x, y;
+		int no_col[3] = {-1,-1,-1}, col[3];
+
+		lstx_tr_line(&m->xyz2g, G2L, l_nv_g, &nv_line);
+		if(dot( nv_line.v, v_z1 ) < 0){
+			continue;
+		}
+		fn = rev ? m->fn_r : m->fn;
+		if(fn < 0){
+			continue;
+		}
+		lstx_tr_p(&m->wh2xyz, G2L, nv_line.p, p);
+		x = p[0];
+		y = p[1];
+
+		img_col(fn, sec, (int)x, (int)y, no_col, m->rep_x, m->rep_y, col);
+		if(is_no_col(col)){
+			continue;
+		}
+
+		if(is_no_col(sum_col)){
+			copy_col(sum_col, col);
+		}else{
+			add_col(sum_col, col);
+		}
+	}
+	if(is_no_col(sum_col)){
+		copy_col(ret_col, d->def_col);
+		return;
+	}
+	for(i=0; i<3; i++){
+		ret_col[i] = sum_col[i] < 255 ? sum_col[i] : 255;
+	}
+}
+
 double
-rt_calc_diff(struct data_one *d, double *crsp, double *nv, double ang_nv_eyev)
+calc_diff(int idx, double *crsp, double *nv, double ang_nv_eyev)
 {
+	struct data_one *d = data_one_get(idx);
 	struct rtd *rtd = &d->rtd;
-	double ang_nv_eyev_nega = - ang_nv_eyev;
+	double ang_nv_eyev_nega = -ang_nv_eyev;
 	int i;
 	double sum = 0;
 	struct lights *lights = lights_get();
@@ -19,7 +102,9 @@
 		struct ltd *ltd = &lights->lst[i];
 		double ang_nv_lt, ang_nv_lt_nega;
 
-		if(ltd->pvi == LTD_P){
+		if(ltd->pvi == LTD_V){
+			v_set(ltv, ltd->v);
+		}else if(ltd->pvi == LTD_P){
 			v_sub(crsp, ltd->p, ltv);
 			if(dot(ltv, ltv) == 0){
 				continue;
@@ -36,4 +121,243 @@
 	return sum * rtd->diff;
 }
 
+void
+reflect_col(struct rtd *rtd, double *crsp, double *nv, double *eyev, double ang_nv_eyev,
+	double sec, double nest_rate, int idx, int *ret_col)
+{
+	double ang_nv_eyev_nega = -ang_nv_eyev;
+	double reflect = rtd->reflect;
+	double ref_v[3];
+	struct line ref_l;
+	int no_col[3] = {-1,-1,-1}, col[3], i;
+
+	copy_col(ret_col, no_col);
+	if(reflect == 0){
+		return;
+	}
+	if(ang_nv_eyev_nega < 0 && !rtd->reflect_backside){
+		return;
+	}
+	v_mul(nv, ( 2 * ang_nv_eyev_nega ), ref_v);
+	v_add(ref_v, eyev, ref_v);
+
+	line_new(&ref_l, crsp, ref_v);
+
+	get_col(&ref_l, sec, nest_rate * reflect, idx, col);
+
+	if(is_no_col(col)){
+		return;
+	}
+	for(i=0; i<3; i++){
+		ret_col[i] = col[i] * reflect;
+	}
+}
+
+void
+reflact_v(struct rtd *rtd, double *nv, double *eyev, double ang_nv_eyev, double *ret_v)
+{
+	double density = rtd->density;
+	double cos_v[3], sin_v[3], r_cos_v[3], r_sin_v[3];
+	double sin_len2, cos_len;
+
+	if(density == 1 || fabs(ang_nv_eyev) == 1 || ang_nv_eyev == 0){
+		v_set(ret_v, eyev);
+		return;
+	}
+	v_mul(nv, ang_nv_eyev, cos_v);
+	v_sub(eyev, cos_v, sin_v);
+	if(ang_nv_eyev < 0){
+		density = 1.0 / density;
+	}
+	v_mul(sin_v, density, r_sin_v);
+
+	sin_len2 = dot( r_sin_v, r_sin_v );
+	sin_len2 = sin_len2 < 1 ? sin_len2 : 1;
+	cos_len = sqrt( 1 - sin_len2 );
+	v_mul(cos_v, cos_len / len1( cos_v ), r_cos_v);
+	v_add(r_sin_v, r_cos_v, ret_v);
+	unit(ret_v, ret_v);
+}
+
+void
+reflact_col(struct rtd *rtd, double *crsp, double *nv, double *eyev, double ang_nv_eyev,
+	double sec, double nest_rate, int idx, int *ret_col)
+{
+	double reflact = rtd->reflact;
+	int no_col[3] = {-1,-1,-1}, col[3];
+	double ref_v[3];
+	struct line ref_l;
+	int i;
+
+	copy_col(ret_col, no_col);
+
+	if(reflact ==  0){
+		return;
+	}
+	reflact_v(rtd, nv, eyev, ang_nv_eyev, ref_v);
+	line_new(&ref_l, crsp, ref_v);
+
+	get_col(&ref_l, sec, nest_rate * reflact, idx, col);
+	if(is_no_col(col)){
+		return;
+	}
+	for(i=0; i<3; i++){
+		ret_col[i] = (int)( col[i] * reflact );
+	}
+}
+
+void
+get_col(struct line *l_g, double sec, double nest_rate, int prev_idx, int *ret_col)
+{
+	int no_col[] = {-1,-1,-1}, col[3], col_[3];
+	int idx, rev, i;
+	struct cross_ret crs_ret;
+	struct data_one *d;
+	struct rtd *rtd;
+	double *crsp, *nv, *eyev, ang_nv_eyev, ang_nv_eyev_nega, fcol[3], diff;
+
+	copy_col(ret_col, no_col);
+
+	if(nest_rate < 0.01){
+		return;
+	}
+
+	cross_cross(l_g, prev_idx, &crs_ret);
+	idx = crs_ret.idx;
+	if(idx < 0){
+		return;
+	}
+
+	d = data_one_get(idx);
+	rtd = &d->rtd;
+
+	crsp = crs_ret.l_nv_g.p;
+	nv = crs_ret.nv;
+	eyev = crs_ret.eyev;
+	ang_nv_eyev = crs_ret.ang_nv_eyev;
+
+	ang_nv_eyev_nega = -ang_nv_eyev;
+	rev = ang_nv_eyev_nega < 0;
+
+	map_col(idx, &crs_ret.l_nv_g, rev, sec, col);
+
+	for(i=0; i<3; i++){
+		fcol[i] = col[i];
+	}
+
+	diff = calc_diff(idx, crsp, nv, crs_ret.ang_nv_eyev);
+	v_mul(fcol, rtd->base + diff, fcol);
+
+	reflect_col(rtd, crsp, nv, eyev, ang_nv_eyev, sec, nest_rate, idx, col_);
+	if(!is_no_col(col_)){
+		for(i=0; i<3; i++){
+			fcol[i] += col_[i];
+		}
+	}
+	reflact_col(rtd, crsp, nv, eyev, ang_nv_eyev, sec, nest_rate, idx, col_);
+	if(!is_no_col(col_)){
+		for(i=0; i<3; i++){
+			fcol[i] += col_[i];
+		}
+	}
+	for(i=0; i<3; i++){
+		ret_col[i] = (int)fcol[i];
+	}
+}
+
+#ifdef SRV_RT
+void
+srv_map_col(int fd)
+{
+	int idx;
+	struct line l_nv_g;
+	int rev;
+	double sec;
+	char buf[ sizeof(idx) + sizeof(l_nv_g) + sizeof(rev) + sizeof(sec) ];
+	char *bp = buf;
+	int col[3];
+	int sz;
+
+	read(fd, &sz, sizeof(sz));
+	read(fd, buf, sz);
+
+	bp = COPY_FROM_BP(bp, idx);
+	bp = COPY_FROM_BP(bp, l_nv_g);
+	bp = COPY_FROM_BP(bp, rev);
+	bp = COPY_FROM_BP(bp, sec);
+
+	map_col(idx, &l_nv_g, rev, sec, col);
+
+	sz = sizeof(col);
+	write(fd, &sz, sizeof(sz));
+	write(fd, col, sz);
+}
+
+void
+srv_calc_diff(int fd)
+{
+	int idx;
+	double crsp[3], nv[3], ang_nv_eyev;
+	char buf[ sizeof(idx) + sizeof(crsp) + sizeof(nv) + sizeof(ang_nv_eyev) ];
+	char *bp = buf;
+	int sz;
+	double diff;
+
+	read(fd, &sz, sizeof(sz));
+	read(fd, buf, sz);
+
+	bp = COPY_FROM_BP(bp, idx);
+	bp = COPY_FROM_BP_ARR(bp, crsp);
+	bp = COPY_FROM_BP_ARR(bp, nv);
+	bp = COPY_FROM_BP(bp, ang_nv_eyev);
+
+	diff = calc_diff(idx, crsp, nv, ang_nv_eyev);
+
+	sz = sizeof(diff);
+	write(fd, &sz, sizeof(sz));
+	write(fd, &diff, sz);
+}
+
+void
+srv_get_col(int fd)
+{
+	struct line l_g;
+	double sec, nest_rate;
+	int prev_idx;
+	char buf[ sizeof(l_g) + sizeof(sec) + sizeof(nest_rate) + sizeof(prev_idx) ];
+	char *bp = buf;
+	int col[3], sz;
+
+	read(fd, &sz, sizeof(sz));
+	read(fd, buf, sz);
+
+	bp = COPY_FROM_BP(bp, l_g);
+	bp = COPY_FROM_BP(bp, sec);
+	bp = COPY_FROM_BP(bp, nest_rate);
+	bp = COPY_FROM_BP(bp, prev_idx);
+
+	get_col(&l_g, sec, nest_rate, prev_idx, col);
+
+	sz = sizeof(col);
+	write(fd, &sz, sizeof(sz));
+	write(fd, col, sz);
+}
+
+int
+main(int ac, char **av)
+{
+	int port = SOCK_PORT + 13;
+	void *funcs[] = {
+		srv_map_col,
+		srv_calc_diff,
+		srv_get_col,
+	};
+
+	if(ac >= 2 && strcmp(av[1], "boot") == 0){
+		sock_srv_main_loop(port, sizeof(funcs)/sizeof(*funcs), funcs);
+	}
+	return 0;
+}
+#endif
+
 /* EOF */
diff -urN rt_v29/rt.h rt_v30/rt.h
--- rt_v29/rt.h	2018-04-29 13:00:31.000000000 +0900
+++ rt_v30/rt.h	2018-05-01 23:19:45.000000000 +0900
@@ -3,10 +3,7 @@
 
 struct rtd{
 	double base, diff, reflect, reflact, density;
+	int reflect_backside;
 };
 
-struct data_one;
-
-double rt_calc_diff(struct data_one *d, double *crsp, double *nv, double ang_nv_eyev);
-
 #endif
diff -urN rt_v29/rt.py rt_v30/rt.py
--- rt_v29/rt.py	2018-04-27 23:55:21.000000000 +0900
+++ rt_v30/rt.py	2018-05-02 00:59:47.000000000 +0900
@@ -9,11 +9,20 @@
 import line
 import lstx
 import cross
+import dat
 import sock
 import val
 import img
 
-def map_col(d, l_nv_g, rev, sec):
+srv_dic = {}
+
+data_get = lambda : ut.dic_cache( srv_dic, 'data', lambda : val.cli.get_prop('data') )
+lights_get = lambda : ut.dic_cache( srv_dic, 'lights', lambda : val.cli.get_prop('lights') )
+
+data_one_get = lambda idx: data_get()[idx]
+
+def map_col(idx, l_nv_g, rev, sec):
+	d = data_one_get(idx)
 	def_col = mt.arr( d.get('def_col') )
 
 	if 'maps' not in d:
@@ -39,7 +48,8 @@
 		return def_col
 	return np.fmin( np.sum(cols, axis=0), 255 )
 
-def calc_diff(d, crsp, nv, ang_nv_eyev):
+def calc_diff(idx, crsp, nv, ang_nv_eyev):
+	d = data_one_get(idx)
 	rtd = d.get('rtd', {})
 	diff = rtd.get('diff', 0.9)
 	if not diff:
@@ -60,9 +70,7 @@
 			return 0
 		return abs( ang_nv_lt ) * ltd.get('e', 1.0)
 
-	lights = ut.dic_cache( srv_dic, 'lights', lambda : val.cli.get_prop('lights') )
-
-	return sum( map( f, lights ) ) * diff
+	return sum( map( f, lights_get() ) ) * diff
 
 def reflect_col(rtd, crsp, nv, eyev, ang_nv_eyev, sec, nest_rate, idx):
 	ang_nv_eyev_nega = -ang_nv_eyev
@@ -103,14 +111,12 @@
 
 use_srv = 'use_srv' in sys.argv
 
-srv_dic = {}
-
 def get_col(l_g, sec, nest_rate=1.0, prev_idx=-1):
 	if nest_rate < 0.01:
 		return []
 
-	f = cross.cli.cross_ if use_srv else cross.cross_
-	(idx, l_nv_g, nv, eyev, ang_nv_eyev) = f(l_g, prev_idx)
+	#(idx, l_nv_g, nv, eyev, ang_nv_eyev) = cross.cross_(l_g, prev_idx)
+	(idx, l_nv_g, nv, eyev, ang_nv_eyev) = cross.cli.cross_(l_g, prev_idx)
 
 	if idx < 0:
 		return []
@@ -122,13 +128,15 @@
 	ang_nv_eyev_nega = -ang_nv_eyev
 	rev = ang_nv_eyev_nega < 0
 
-	col = map_col( d, l_nv_g, rev, sec )
+	col = map_col( idx, l_nv_g, rev, sec )
+	#col = cli.map_col( idx, l_nv_g, rev, sec )
+
 	col = mt.arr(col)
 
 	base = rtd.get('base', 0.3)
 
-	#diff = crs.get('diff') if use_srv else calc_diff(d, crsp, nv, ang_nv_eyev)
-	diff = calc_diff(d, crsp, nv, ang_nv_eyev)
+	diff = calc_diff(idx, crsp, nv, ang_nv_eyev)
+	#diff = cli.calc_diff(idx, crsp, nv, ang_nv_eyev)
 	col = col * (base + diff)
 
 	col_ = reflect_col(rtd, crsp, nv, eyev, ang_nv_eyev, sec, nest_rate, idx)
@@ -152,7 +160,7 @@
 		p = lstx.tr_p( wh2g, 'l2g', mt.arr( [ix,iy,-d_] ) )
 		l_g = line.new_p2(eye2g.p, p)
 
-		col = get_col(l_g, sec)
+		col = cli.get_col(l_g, sec, 1.0, -1)
 
 		if col != []:
 			col = np.fmin( col, 255 )
@@ -161,11 +169,14 @@
 ###
 
 cmd_infs = [
+	{ 'cmd': 'map_col', 'func': map_col, 'args': '(i4,line,bool,f8)', 'rets': 'col' },
+	{ 'cmd': 'calc_diff', 'func': calc_diff, 'args': '(i4,xyz,xyz,f8)', 'rets': 'f8' },
 	{ 'cmd': 'get_col', 'func': get_col, 'args': '(line,f8,f8,i4)', 'rets': 'col' },
 ]
 
 sock_inf = {
-	'srv_cmd': './rt.py boot',
+	#'srv_cmd': './rt.py boot',
+	'srv_cmd': './rt boot',
 	'port': sock.port + 13,
 	'pid': -1,
 }
diff -urN rt_v29/sock.c rt_v30/sock.c
--- rt_v29/sock.c	2018-04-30 01:40:12.000000000 +0900
+++ rt_v30/sock.c	2018-05-01 23:12:51.000000000 +0900
@@ -74,15 +74,34 @@
 /**/
 
 char *
+copy_sz(int d, char *bp, void *vp, int sz)
+{
+	if(d == FROM_BP){	
+		memcpy(vp, bp, sz);
+	}else{
+		memcpy(bp, vp, sz);
+	}
+	bp += sz;
+	return bp;
+}
+
+void *
+sock_alloc(int sz, char *id)
+{
+	/*fprintf(stderr, "sock_alloc id=%s sz=%d\n", id, sz);*/
+	return malloc(sz);
+}
+
+char *
 alloc_add_bsz(int usz, int n, char *s, int *ret_sz)
 {
 	int bsz = usz * n;
 	int isz = sizeof(bsz);
-	char *buf = malloc( isz + bsz );
+	char *buf = sock_alloc( isz + bsz, "alloc_add_bsz" );
 	char *bp = buf;
 
-	memcpy(bp, &bsz, isz); bp += isz;
-	memcpy(bp, s, bsz); bp += bsz;
+	bp = COPY_TO_BP(bp, bsz);
+	bp = COPY_SZ_TO_BP(bp, s, bsz);
 
 	if(ret_sz){
 		*ret_sz = isz + bsz;
@@ -90,6 +109,8 @@
 	return buf;
 }
 
+/**/
+
 char *
 sock_cli_call(int fd, int cmd, int args_sz, char *args, int *rets_sz, char *rets)
 {
@@ -106,7 +127,8 @@
 
 	buf = rets;
 	if(rets == NULL || rets_sz == NULL || *rets_sz < sz){
-		buf = malloc(sz);
+		//buf = malloc(sz);
+		buf = sock_alloc(sz, "sock_cli_call");
 	}
 
 	read(fd, buf, sz);
diff -urN rt_v29/sock.h rt_v30/sock.h
--- rt_v29/sock.h	2018-04-29 22:55:06.000000000 +0900
+++ rt_v30/sock.h	2018-05-01 22:49:03.000000000 +0900
@@ -22,8 +22,30 @@
 
 /**/
 
+#define FROM_BP		0
+#define TO_BP		1
+
+char *copy_sz(int d, char *bp, void *vp, int sz);
+
+#define COPY_SZ_FROM_BP(bp, vp, sz)	copy_sz(FROM_BP, bp, vp, sz)
+#define COPY_SZ_TO_BP(bp, vp, sz)	copy_sz(TO_BP, bp, vp, sz)
+#define COPY_FROM_BP(bp, name)		COPY_SZ_FROM_BP(bp, &name, sizeof(name))
+#define COPY_TO_BP(bp, name)		COPY_SZ_TO_BP(bp, &name, sizeof(name))
+#define COPY_FROM_BP_ARR(bp, arr)	COPY_SZ_FROM_BP(bp, arr, sizeof(arr))
+#define COPY_TO_BP_ARR(bp, arr)		COPY_SZ_TO_BP(bp, arr, sizeof(arr))
+
+void *sock_alloc(int sz, char *id);
+
+/*
+	name.n   : int
+	name.lst : type *
+ */
+#define ALLOC_LST(name, id)		do{ (name).lst = sock_alloc( sizeof(*(name).lst) * (name).n, "ALLOC_LST/" id ); }while(0)
+
 char *alloc_add_bsz(int usz, int n, char *s, int *ret_sz);
 
+/**/
+
 char *sock_cli_call(int fd, int cmd, int args_sz, char *args, int *rets_sz, char *rets);
 void sock_srv_main_loop(int port, int func_n, void **funcs);
 
diff -urN rt_v29/test.py rt_v30/test.py
--- rt_v29/test.py	1970-01-01 09:00:00.000000000 +0900
+++ rt_v30/test.py	2018-05-01 23:25:24.000000000 +0900
@@ -0,0 +1,42 @@
+#!/usr/bin/env python
+
+import sys
+import socket
+import threading
+import ut
+
+def conn(sock):
+	try:
+		sock.connect(('localhost', port))
+		print('conn ok')
+	except OSError as err:
+		print('err={}'.format(err))
+		return False
+	return True
+
+def test(sock):
+	sock.sendall(b'pwd\n')
+	print( sock.recv(4096).decode().strip() )
+
+if __name__ == "__main__":
+
+	port = 7788
+	proc = None
+
+	for i in range(2):
+
+		sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+		sock.settimeout(5)
+		if conn(sock):
+			break
+		#sock.shutdown(socket.SHUT_RDWR)
+		sock.close()
+
+		proc = ut.cmd_proc('./cmd.py')
+		ut.sleep(3)
+
+	test(sock)
+
+	if proc:
+		ut.kill_proc(proc)
+# EOF
diff -urN rt_v29/v.c rt_v30/v.c
--- rt_v29/v.c	2018-04-13 20:24:38.000000000 +0900
+++ rt_v30/v.c	2018-05-01 23:19:45.000000000 +0900
@@ -48,6 +48,14 @@
 	*r++ = - *a++;
 }
 
+void
+v_mul(double *v, double n, double *r)
+{
+	*r++ = *v++ *n;
+	*r++ = *v++ *n;
+	*r++ = *v++ *n;
+}
+
 double
 len1(double *v)
 {
diff -urN rt_v29/v.h rt_v30/v.h
--- rt_v29/v.h	2018-04-29 17:17:30.000000000 +0900
+++ rt_v30/v.h	2018-05-01 23:19:45.000000000 +0900
@@ -13,6 +13,7 @@
 void v_add(double *a, double *b, double *r);
 void v_sub(double *a, double *b, double *r);
 void v_neg(double *a, double *r);
+void v_mul(double *v, double n, double *r);
 double len1(double *v);
 void unit(double *s, double *d);
 void cross_product(double *a, double *b, double *r);
diff -urN rt_v29/val.c rt_v30/val.c
--- rt_v29/val.c	2018-04-30 00:02:57.000000000 +0900
+++ rt_v30/val.c	2018-05-01 23:19:45.000000000 +0900
@@ -21,7 +21,7 @@
 #define VAL_GET_PROP_TYP_STR_IDXS	13
 #define VAL_GET_PROP_N_IDXS		14
 
-int fd = -1;
+static int fd = -1;
 
 void
 val_conn(void)
@@ -70,23 +70,22 @@
 char *
 get_prop(char *s, int *ret_sz)
 {
-	int sz, n;
+	int n;
 	char *b = get_prop_bytes(s, NULL), *bp = b;
 	char *ret;
 
 	/* skip typ_str size */
-	sz = sizeof(n);
-	memcpy(&n, bp, sz); bp += sz;
+	bp = COPY_FROM_BP(bp, n);
 
 	/* skip typ_str */
 	bp += n;
 
 	/* skip pkd_bytes size */
-	sz = sizeof(n);
-	memcpy(&n, bp, sz); bp += sz;
+	bp = COPY_FROM_BP(bp, n);
 
 	ret = malloc(n);
-	memcpy(ret, bp, n);
+	bp = COPY_SZ_FROM_BP(bp, ret, n);
+
 	free(b);
 	if(ret_sz){
 		*ret_sz = n;