diff -urN rt_v10/cg.py rt_v11/cg.py
--- rt_v10/cg.py	2018-03-24 12:41:14.000000000 +0900
+++ rt_v11/cg.py	2018-03-25 11:58:52.000000000 +0900
@@ -14,6 +14,7 @@
 import way
 import wf
 import rt
+import dat
 
 def if_not_set_opt(d, k, v):
 	ut.if_not_set(d, k, v)
@@ -42,6 +43,21 @@
 
 	kind = d.get('kind')
 
+	if kind == 'poly_n':
+		n = d.get('n', 3)
+		deg = 360.0 / n
+		rad = mt.deg_to_rad(deg/2)
+		h = math.cos(rad)
+		b = math.sin(rad)
+
+		def poly_n_f(i):
+			d_ = d.copy()
+			d_['kind'] = 'triangle'
+			d_['l2m'] = [ ax.slide_y(-1), ax.zoom([b,h,1]), ax.rot_z(deg*i)  ] + d_.get( 'l2m', [] )
+			return d_setup( d_ )
+
+		return sum( map( poly_n_f, range(n) ), [] )
+
 	if kind == 'cube':
 		def cube_f( (l, deg) ):
 			d_ = d.copy()
@@ -53,6 +69,167 @@
 			(line.y1, 90), (line.y1, -90)
 		]
 		return sum( map( cube_f, rots ), [] )
+
+	if kind == 'tri_prism_side':
+		d0 = d.copy()
+		d0['kind'] = 'square'
+		d0['l2m'] = [ ax.rot_x(90) ] + d0.get( 'l2m', [] )
+
+		d1 = d.copy()
+		d1['kind'] = 'square'
+		zm = math.sqrt(2) / 2
+		d1['l2m'] = [ ax.rot_x(-90), ax.slide_x(-1), ax.zoom_x(zm), ax.rot_z(-45), ax.slide_x(1) ] + d1.get( 'l2m', [] )
+
+		d2 = d.copy()
+		d2['kind'] = 'square'
+		d2['l2m'] = [ ax.rot_x(-90), ax.slide_x(1), ax.zoom_x(zm), ax.rot_z(45), ax.slide_x(-1) ] + d2.get( 'l2m', [] )
+
+		return sum( map( d_setup, [d0,d1,d2] ), [] )
+
+	if kind == 'tri_prism':
+		d0 = d.copy()
+		d0['kind'] = 'tri_prism_side'
+
+		d1 = d.copy()
+		d1['kind'] = 'triangle'
+		d1['l2m'] = [ ax.slide_z(1) ] + d1.get( 'l2m', [] )
+
+		d2 = d.copy()
+		d2['kind'] = 'triangle'
+		d2['l2m'] = [ ax.slide_z(1), ax.zoom_z(-1) ] + d2.get( 'l2m', [] )
+
+		return sum( map( d_setup, [d0,d1,d2] ), [] )
+
+	if kind == 'poly_n_prism_side':
+		n = d.get('n', 3)
+		deg = 360.0 / n
+		rad = mt.deg_to_rad(deg/2)
+		h = math.cos(rad)
+		b = math.sin(rad)
+
+		def poly_n_prism_side_f(i):
+			d_ = d.copy()
+			d_['kind'] = 'square'
+			d_['l2m'] = [ ax.rot_x(90), ax.zoom_x(b), ax.slide_y(-h), ax.rot_z(deg*i) ] + d_.get( 'l2m', [] )
+			return d_setup( d_ )
+
+		return sum( map( poly_n_prism_side_f, range(n) ), [] )
+
+	if kind == 'poly_n_prism':
+		d0 = d.copy()
+		d0['kind'] = 'poly_n_prism_side'
+
+		d1 = d.copy()
+		d1['kind'] = 'poly_n'
+		d1['l2m'] = [ ax.slide_z(1) ] + d1.get( 'l2m', [] )
+
+		d2 = d.copy()
+		d2['kind'] = 'poly_n'
+		d2['l2m'] = [ ax.slide_z(1), ax.zoom_z(-1) ] + d2.get( 'l2m', [] )
+
+		return sum( map( d_setup, [d0,d1,d2] ), [] )
+
+	if kind == 'four_pyramid_side':
+		n = 4
+		zm = math.sqrt(2)
+
+		def four_pyramid_side_f(i):
+			d_ = d.copy()
+			d_['kind'] = 'triangle'
+			d_['l2m'] = [ ax.zoom_y(zm), ax.rot_x(45), ax.slide_y(-1), ax.rot_z(90*i) ] + d_.get( 'l2m', [] )
+			return d_setup( d_ )
+
+		return sum( map( four_pyramid_side_f, range(n) ), [] )
+
+	if kind == 'four_pyramid':
+		d0 = d.copy()
+		d0['kind'] = 'four_pyramid_side'
+
+		d1 = d.copy()
+		d1['kind'] = 'square'
+		d1['l2m'] = [ ax.zoom_z(-1) ] + d1.get( 'l2m', [] )
+
+		return sum( map( d_setup, [d0,d1] ), [] )
+
+	if kind == 'tri_pyramid_side':
+		d0 = d.copy()
+		d0['kind'] = 'triangle'
+		d0['l2m'] = [ ax.rot_x(90) ] + d0.get( 'l2m', [] )
+
+		h = math.sqrt( 1 + 0.5 )
+		b = math.sqrt(2)/2
+		deg = mt.rad_to_deg( math.atan2(1, b) )
+
+		d1 = d.copy()
+		d1['kind'] = 'triangle'
+		d1['l2m'] = [ ax.zoom([b,h,1]), ax.rot_x(deg), ax.rot_z(90+45), ax.slide([0.5,0.5,0]) ] + d1.get( 'l2m', [] )
+
+		d2 = d.copy()
+		d2['kind'] = 'triangle'
+		d2['l2m'] = [ ax.zoom([b,h,1]), ax.rot_x(deg), ax.rot_z(-90-45), ax.slide([-0.5,0.5,0]) ] + d2.get( 'l2m', [] )
+
+		return sum( map( d_setup, [d0,d1, d2] ), [] )
+
+	if kind == 'tri_pyramid':
+		d0 = d.copy()
+		d0['kind'] = 'tri_pyramid_side'
+
+		d1 = d.copy()
+		d1['kind'] = 'triangle'
+		d1['l2m'] = [ ax.zoom_z(-1) ] + d1.get( 'l2m', [] )
+
+		return sum( map( d_setup, [d0,d1] ), [] )
+
+	if kind == 'poly_n_pyramid_side':
+		n = d.get('n', 3)
+		deg = 360.0 / n
+		rad = mt.deg_to_rad(deg/2)
+		h = math.cos(rad)
+		b = math.sin(rad)
+		h2 = math.sqrt(1 + h*h)
+		deg2 = mt.rad_to_deg( math.atan2(1, h) )
+
+		def poly_n_pyramid_side_f(i):
+			d_ = d.copy()
+			d_['kind'] = 'triangle'
+			d_['l2m'] = [ ax.zoom([b,h2,1]), ax.rot_x(deg2), ax.slide_y(-h), ax.rot_z(deg*i)  ] + d_.get( 'l2m', [] )
+			return d_setup( d_ )
+
+		return sum( map( poly_n_pyramid_side_f, range(n) ), [] )
+
+	if kind == 'poly_n_pyramid':
+		d0 = d.copy()
+		d0['kind'] = 'poly_n_pyramid_side'
+
+		d1 = d.copy()
+		d1['kind'] = 'poly_n'
+		d1['l2m'] = [ ax.zoom_z(-1) ] + d1.get( 'l2m', [] )
+
+		return sum( map( d_setup, [d0,d1] ), [] )
+
+	if kind == 'pipe':
+		d0 = d.copy()
+		d0['kind'] = 'pipe_side'
+
+		d1 = d.copy()
+		d1['kind'] = 'circle'
+		d1['l2m'] = [ ax.slide_z(1) ] + d1.get( 'l2m', [] )
+
+		d2 = d.copy()
+		d2['kind'] = 'circle'
+		d2['l2m'] = [ ax.slide_z(1), ax.zoom_z(-1) ] + d2.get( 'l2m', [] )
+
+		return sum( map( d_setup, [d0,d1,d2] ), [] )
+
+	if kind == 'cone':
+		d0 = d.copy()
+		d0['kind'] = 'cone_side'
+
+		d1 = d.copy()
+		d1['kind'] = 'circle'
+		d1['l2m'] = [ ax.zoom_z(-1) ] + d1.get( 'l2m', [] )
+
+		return sum( map( d_setup, [d0,d1] ), [] )
 	###
 
 	if_not_set_opt( d, 'l2m', [] )
@@ -66,33 +243,9 @@
 
 if __name__ == "__main__":
 
-	copen = 'copen-090419.jpg'
-	beat = 'beat.jpg'
+	data = sum( map( d_setup, dat.data ), [] )
 
-	maps = [
-		{ 'fn': 'IMG_3999_3.mov', 'fn_r': 'IMG_3999_4.mov', 't2m': [ ax.zoom_all(3) ] },
-	]
-
-	data = [ {
-		'kind': 'square',
-		'rtd': { 'base': 0.1, 'diff': 1.0, 'reflect': 0.9 },
-		'l2m': [],
-		'maps': maps,
-		'm2g': [ ax.zoom_all(50) ],
-	},{
-		'kind': 'cube',
-		'rtd': { 'base':0.1, 'diff': 0, 'reflect': 0.5, 'reflact': 0.5, 'density': 2 },
-		'def_col': [128,0,0],
-		'l2m': [ ax.zoom_all(20.0/50) ],
-		'm2g': [ ax.zoom_all(50) ],
-	} ]
-
-	data = sum( map( d_setup, data ), [] )
-
-	lights = [
-		{ 'p': v.op1( '*', [1,-1,-1], 30 ), 'e': 2.5 },
-		{ 'p': v.op1( '*', [-1,1,1], 30 ), 'e': 2.5 },
-	]
+	lights = dat.lights
 
 	(w, h) = ( ut.arg_i('w', 640) , ut.arg_i('h', 480) )
 	div = ut.arg_i('div', 1)
diff -urN rt_v10/cross.py rt_v11/cross.py
--- rt_v10/cross.py	2018-03-16 20:38:43.000000000 +0900
+++ rt_v11/cross.py	2018-03-26 18:27:58.000000000 +0900
@@ -77,6 +77,97 @@
 	nv = v.unit(p)
 	return { 't': t, 'nv': nv, 'p': p }
 
+def pipe_side(l, d):
+	# r = 1
+	# -1 < z < 1
+
+	# [x,y,z] = p + t * v
+	# x*x + y*y = 1
+
+	# (px + t * vx)^2
+	# = px^2 + 2 * px * vx * t + vx^2 *t^2
+
+	# (vx^2+vy^2) * t^2
+	# + 2*(px*vx + py*vy) * t
+	# + px^2 + py^2 - 1 = 0
+
+	# at^2 + bt + c = 0
+	# a = vx^2 + vy^2
+	# b = 2 * (px*vx + py*vy)
+	# c = px^2 + py^2 - 1
+
+	(px, py, _) = l.p
+	(vx, vy, _) = l.v
+
+	a = vx*vx + vy*vy
+	b = 2 * (px*vx + py*vy)
+	c = px*px + py*py - 1
+
+	ts = mt.quadratic_formula(a, b, c)
+	ts = sorted( filter( lambda v: v > 0, ts ) )
+	if not ts:
+		return {}
+	tpzs = map( lambda t: ( lambda (x,y,z): (t, [x,y,z], z) )( l.on_line_p(t) ), ts )
+	tpzs = filter( lambda (t,p,z): abs(z) < 1, tpzs )
+	if not tpzs:
+		return {}
+	(t, p, _) = tpzs[0]
+	(px, py, _) = p
+	nv = v.unit( [px,py,0] )
+	return { 't': t, 'nv': nv, 'p': p }
+
+def cone_side(l, d):
+	# 0 < z < 1
+	# r = 1 - z
+
+	# [x,y,z] = p + t * v
+	# x*x + y*y = (1-z)^2 = 1-2z+z^2
+
+	# (px + t * vx)^2
+	# = px^2 + 2 * px * vx * t + vx^2 * t^2
+
+	# (1-z)^2 = 1-2z+z^2
+	# = pz^2 + 2 * pz * vz * t + vz^2 * t^2
+	#   -2 * (pz + vz * t) + 1
+
+	# (vx^2+vy^2) * t^2
+	# + 2*(px*vx + py*vy) * t
+	# + px^2 + py^2 
+	# = pz^2 + 2 * pz * vz * t + vz^2 * t^2
+	#   -2 * (pz + vz * t) + 1
+	# = pz^2 + 2 * (pz - 1) * vz * t + vz^2 * t^2
+	#   -2 * pz + 1
+
+	# (vx^2+vy^2 - vz^2) * t^2
+	# + 2*(px*vx + py*vy + (1 - pz)*vz ) * t
+	# + px^2 + py^2  - pz^2 + 2*pz - 1 = 0
+
+	# at^2 + bt + c = 0
+	# a = vx^2+vy^2 - vz^2
+	# b = 2*(px*vx + py*vy + (1 - pz)*vz )
+	# c = px^2 + py^2  - pz^2 + 2*pz - 1
+
+	(px, py, pz) = l.p
+	(vx, vy, vz) = l.v
+
+	a = vx*vx + vy*vy - vz*vz
+	b = 2 * (px*vx + py*vy + (1 - pz)*vz)
+	c = px*px + py*py - pz*pz + 2*pz - 1
+
+	ts = mt.quadratic_formula(a, b, c)
+	ts = sorted( filter( lambda v: v > 0, ts ) )
+	if not ts:
+		return {}
+	tpzs = map( lambda t: ( lambda (x,y,z): (t, [x,y,z], z) )( l.on_line_p(t) ), ts )
+	tpzs = filter( lambda (t,p,z): 0<z and z<1, tpzs )
+	if not tpzs:
+		return {}
+	(t, p, _) = tpzs[0]
+	(px, py, _) = p
+	(px, py, _) = v.unit( [px,py,0] )
+	nv = v.unit( [px,py,1] )
+	return { 't': t, 'nv': nv, 'p': p }
+
 def cross(l, d):
 	dic = {
 		'square': square,
@@ -84,6 +175,8 @@
 		'triangle': triangle,
 		'poly_n': poly_n,
 		'ball': ball,
+		'pipe_side': pipe_side,
+		'cone_side': cone_side,
 	}
 	f = dic.get( d.get('kind') )
 	if not f:
diff -urN rt_v10/dat.py rt_v11/dat.py
--- rt_v10/dat.py	1970-01-01 09:00:00.000000000 +0900
+++ rt_v11/dat.py	2018-03-27 09:44:30.000000000 +0900
@@ -0,0 +1,100 @@
+#!/usr/bin/env python
+
+import v
+import line
+import ax
+import cylx
+import fcx
+import lstx
+
+copen = 'copen-090419.jpg'
+beat = 'beat.jpg'
+
+maps = [
+	{ 'fn': 'IMG_3999_3.mov', 'fn_r': 'IMG_3999_4.mov', 't2m': [ ax.zoom_all(3) ] },
+]
+
+rtd = { 'base':0.1, 'diff': 0, 'reflect': 0.5, 'reflact': 0.5, 'density': 2 }
+
+data = [ {
+	'kind': 'square',
+	'rtd': { 'base': 0.1, 'diff': 1.0, 'reflect': 0.9 },
+	'l2m': [],
+	'maps': maps,
+	'm2g': [ ax.zoom_all(50) ],
+},{
+	'kind': 'ball',
+	'rtd': rtd,
+	'l2m': [ ax.zoom_all(5), ax.slide([-30,-30,0]) ],
+},{
+	'kind': 'cube',
+	'rtd': rtd,
+	'l2m': [ ax.zoom_all(5), ax.slide([-10,-30,0]) ],
+},{
+	'kind': 'tri_prism_side',
+	'rtd': rtd,
+	'l2m': [ ax.zoom_all(5), ax.slide([10,-30,0]) ],
+},{
+	'kind': 'tri_prism',
+	'rtd': rtd,
+	'l2m': [ ax.zoom_all(5), ax.slide([30,-30,0]) ],
+},{
+	'kind': 'poly_n_prism_side',
+	'n': 5,
+	'rtd': rtd,
+	'l2m': [ ax.zoom_all(5), ax.slide([-30,-10,0]) ],
+},{
+	'kind': 'poly_n_prism',
+	'n': 5,
+	'rtd': rtd,
+	'l2m': [ ax.zoom_all(5), ax.slide([-10,-10,0]) ],
+},{
+	'kind': 'pipe_side',
+	'rtd': rtd,
+	'l2m': [ ax.zoom_all(5), ax.slide([10,-10,0]) ],
+},{
+	'kind': 'pipe',
+	'rtd': rtd,
+	'l2m': [ ax.zoom_all(5), ax.slide([30,-10,0]) ],
+},{
+	'kind': 'four_pyramid_side',
+	'rtd': rtd,
+	'l2m': [ ax.zoom_z(2), ax.slide_z(-1), ax.zoom_all(5), ax.slide([-30,10,0]) ],
+},{
+	'kind': 'four_pyramid',
+	'rtd': rtd,
+	'l2m': [ ax.zoom_z(2), ax.slide_z(-1), ax.zoom_all(5), ax.slide([-10,10,0]) ],
+},{
+	'kind': 'tri_pyramid_side',
+	'rtd': rtd,
+	'l2m': [ ax.zoom_z(2), ax.slide_z(-1), ax.zoom_all(5), ax.slide([10,10,0]) ],
+},{
+	'kind': 'tri_pyramid',
+	'rtd': rtd,
+	'l2m': [ ax.zoom_z(2), ax.slide_z(-1), ax.zoom_all(5), ax.slide([30,10,0]) ],
+},{
+	'kind': 'poly_n_pyramid_side',
+	'n': 5,
+	'rtd': rtd,
+	'l2m': [ ax.zoom_z(2), ax.slide_z(-1), ax.zoom_all(5), ax.slide([-30,30,0]) ],
+},{
+	'kind': 'poly_n_pyramid',
+	'n': 5,
+	'rtd': rtd,
+	'l2m': [ ax.zoom_z(2), ax.slide_z(-1), ax.zoom_all(5), ax.slide([-10,30,0]) ],
+},{
+	'kind': 'cone_side',
+	'rtd': rtd,
+	'l2m': [ ax.zoom_z(2), ax.slide_z(-1), ax.zoom_all(5), ax.slide([10,30,0]) ],
+},{
+	'kind': 'cone',
+	'rtd': rtd,
+	'l2m': [ ax.zoom_z(2), ax.slide_z(-1), ax.zoom_all(5), ax.slide([30,30,0]) ],
+} ]
+
+lights = [
+	{ 'p': v.op1( '*', [1,-1,-1], 30 ), 'e': 2.5 },
+	{ 'p': v.op1( '*', [-1,1,1], 30 ), 'e': 2.5 },
+]
+
+# EOF
diff -urN rt_v10/wf.py rt_v11/wf.py
--- rt_v10/wf.py	2018-03-24 12:35:50.000000000 +0900
+++ rt_v11/wf.py	2018-03-25 12:01:36.000000000 +0900
@@ -6,7 +6,7 @@
 import lstx
 
 def wf_ps_idxs(d):
-	len_to_idxs = lambda n, add=0: map( lambda i: ( i, (i+1)%n ), range(add, add+n) )
+	len_to_idxs = lambda n, add=0: map( lambda i: ( add+i, add+(i+1)%n ), range(n) )
 	rv_ps = lambda ps: ( ps, len_to_idxs( len(ps) ) )
 
 	kind = d.get('kind')
@@ -29,20 +29,17 @@
 		return wf_ps_idxs(d)
 	if kind == 'ball':
 		d = { 'kind': 'circle' }
-		c3 = map( lambda i: wf_ps_idxs(d), range(3) )
-
-		(ps, idxs) = c3[1]
+		(ps, _) = wf_ps_idxs(d)
 		n = len(ps)
-		ps = map( lambda p: ax.rot_x(90).tr('l2g', p), ps )
-		idxs = len_to_idxs(n, n)
-		c3[1] = (ps, idxs)
-
-		(ps, idxs) = c3[2]
-		ps = map( lambda p: ax.rot_y(90).tr('l2g', p), ps )
-		idxs = len_to_idxs(n, 2*n)
-		c3[2] = (ps, idxs)
+		axs = [ [], [ax.rot_x(90)], [ax.rot_y(90)] ]
 
-		return map( lambda xs_lst: sum( xs_lst, [] ), zip(*c3) )
+		def ball_f(i):
+			ps_ = map( lambda p: lstx.tr( axs[i], 'l2g', p ), ps )
+			idxs = len_to_idxs(n, i*n)
+			return (ps_, idxs)
+
+		t = map( ball_f, range(3) )
+		return map( lambda lst: sum( lst, [] ), zip(*t) )
 
 	z_pn = lambda ps: map( lambda (x,y,z): [x,y,1], ps ) + map( lambda (x,y,z): [x,y,-1], ps )
 
@@ -56,6 +53,28 @@
 		d = { 'kind': 'square' }
 		(ps, _) = wf_ps_idxs(d)
 		return mk_prism(ps)
+	if kind =='poly_n_prism':
+		d = { 'kind': 'poly_n', 'n': d.get('n') }
+		(ps, _) = wf_ps_idxs(d)
+		return mk_prism(ps)
+
+	def mk_pyramid(ps):
+		n = len(ps)
+		idxs = len_to_idxs(n) + map( lambda i: (i,n), range(n) )
+		return ( ps + [ [0,0,1] ], idxs )
+
+	if kind =='poly_n_pyramid':
+		d = { 'kind': 'poly_n', 'n': d.get('n') }
+		(ps, _) = wf_ps_idxs(d)
+		return mk_pyramid(ps)
+
+	if kind in [ 'pipe', 'pipe_side' ]:
+		d = { 'kind': 'poly_n_prism', 'n': 16 }
+		return wf_ps_idxs(d)
+
+	if kind in [ 'cone', 'cone_side' ]:
+		d = { 'kind': 'poly_n_pyramid', 'n': 16 }
+		return wf_ps_idxs(d)
 
 	return ([],[])