Rendering for stereoscopic and reassembly for headset

#!/usr/bin/python

#
# Copied from http://www.cs.utk.edu/~seelab/powerwall/files/tiles.conf
#

# -----------------------------------------------------------------------------
# SETUP
# -----------------------------------------------------------------------------
import sys
import os
import string

# OpenGL Application might need head node to be DISPLAY :0
os.environ['DISPLAY'] = ':0.0'

# -----------------------------------------------------------------------------
# OPTIONS
# -----------------------------------------------------------------------------

crsite_file = sys.argv[1]

# -----------------------------------------------------------------------------
# CRSITE
# -----------------------------------------------------------------------------
if not os.access (crsite_file, os.F_OK):
   print '%s cannot read file %s.' % (sys.argv[0], crsite_file)
   sys.exit (1)

f = open (crsite_file, 'r')
exec (f.read())
f.close()

# fetch environment for Chromium based on environment
cr_path = crsite["chromium"]
os.environ['LD_LIBRARY_PATH'] = cr_path + '/lib/Linux'

sys.path.append (cr_path + "/mothership/server")
from mothership import *

# -----------------------------------------------------------------------------
# CHROMIUM STUFF
# -----------------------------------------------------------------------------
# create mothership
cr = CR()
cr.MTU (9048 * 1024)

TILE_COLS = 2  # don't change these unless you overhaul LayoutTiles()
TILE_ROWS = 1
TILE_WIDTH = 1400
TILE_HEIGHT = 1024
EYE_NAMES = [ "left", "right" ]

# 1696x480 for helmet
MAX_TILE_WIDTH = 2560
MAX_TILE_HEIGHT = 1024

REASSEMBLE = 1   # use readback SPUs and downstream render SPU
REASSEMBLE_HOST = "vr-master"
RENDER_BACK = 1  # render back into app window
RESIZABLE = 0    # track client window size changes
FULLSCREEN = 1
BORDERLESS = 1
DLIST_BBOX = 1
LAZY_DLIST = 1

# This is a callback which we register with spu.TileLayoutFunction()
def LayoutTiles(muralWidth, muralHeight):
	"""Return list of tuples of new tiles for the given mural size.
	Each tuple is of the form (serverIndex, x, y, width, height)."""

	if muralWidth > MAX_TILE_WIDTH * TILE_COLS:
			print "Warning: mural size is too wide!"
			muralWidth = MAX_TILE_WIDTH * TILE_COLS
	if muralHeight > MAX_TILE_HEIGHT * TILE_ROWS:
			print "Warning: mural size is too tall!"
			muralHeight = MAX_TILE_HEIGHT * TILE_ROWS

	# four tiles
	w = muralWidth / 4
	h = muralHeight / 4
	t0 = (0, 0, 0, w, h) # lower-left
	t1 = (1, w, 0, muralWidth - w, h) # lower-right
	t2 = (1, 0, h, w, muralHeight - h) # upper-left
	t3 = (0, w, h, muralWidth - w, muralHeight - h) # upper-right

	tiles = []
	tiles.append(t0)
	tiles.append(t1)
	tiles.append(t2)
	tiles.append(t3)
	return tiles

# The application node (tilesort SPU)
tilesortspu = SPU( 'tilesort' )
tilesortspu.TileLayoutFunction( LayoutTiles )
#tilesortspu.Conf('broadcast', '1')
tilesortspu.Conf('bucket_mode', 'Frustum')
tilesortspu.Conf('auto_dlist_bbox',DLIST_BBOX)
tilesortspu.Conf('lazy_send_dlists',LAZY_DLIST)
tilesortspu.Conf('stereo_mode', "Passive")

# -----------------------------------------------------------------------------
# HANDLE LOCAL APPLICATIONS
# -----------------------------------------------------------------------------

render_nodes = crsite["render_nodes"]

for local in crsite["local_run"]:
 
  machine = render_nodes[local[0] - 1][0]
  os.system('/usr/bin/ssh ' + machine + ' "/bin/sh -c \'source $HOME/.bashrc; ' + local[1] + '\'" &')
  os.system('sleep 1')

# -----------------------------------------------------------------------------
# HANDLE CLIENT NODE
# -----------------------------------------------------------------------------

for client in crsite["client_nodes"]:

  # setup a tilesort SPU
  tilesort_spu = SPU ('tilesort')
  tilesort_spu.Conf('bucket_mode','Frustum')

  # If one monitor, turn off sync for performance
  if len(client[2]) == 1:
    tilesort_spu.Conf('sync_on_swap', 0)
    tilesort_spu.Conf('sync_on_finish', 0)

  # setup a client/application node
  client_node = CRApplicationNode (client[0])
  client_node.Conf('track_window_visibility',1) # Useful for Performer to clean up temporary windows

  # set starting directory and executable for client
  client_node.StartDir(client[3])
  client_node.SetApplication (client[4])

  client_node.AutoStart ('/usr/bin/ssh ' + client[0] + ' /bin/sh -c \'source $HOME/.bashrc; ' + cr_path + '/bin/Linux/crappfaker\'')
  client_node.AddSPU (tilesort_spu)

  if client[5] != 0:
    client_node.Conf ('match_window_count', client[5])

  w = 0
  h = client[1][1] - 1

# -----------------------------------------------------------------------------
# HANDLE RENDERING NODES
# -----------------------------------------------------------------------------
  #for i in client[2]:
  for row in range(TILE_ROWS):
    for eye in range(2): # starts at 0
      for col in range(TILE_COLS):
	if eye == 1:
		# Right eye
		index = ( row * TILE_COLS + col ) + 2
	else:
		# Left eye
		index = row * TILE_COLS + col
	print index
        machine = render_nodes[index]

        # Set the render nodes to send their data back to the client
        readbackspu = SPU( 'readback' )
        readbackspu.Conf( 'extract_alpha', 0 )
        readbackspu.Conf( 'extract_depth', 0)
        readbackspu.Conf( 'title', 'readback SPU %d' %index )

        # each tile will do some rendering
        render_spu = SPU ('render')
        render_spu.Conf ('display_string', ':0.0')
        #render_spu.Conf ('window_geometry', machine[1])
        render_spu.Conf ('ontop', 1)
        render_spu.Conf ('fullscreen', FULLSCREEN)

        # set up a rendering node
        node = CRNetworkNode (machine[0])
	node.AddTile( col*TILE_WIDTH, (TILE_ROWS-row-1)*TILE_HEIGHT, TILE_WIDTH, TILE_HEIGHT )
	node.Conf('optimize_bucket',2)
	node.Conf('overlap_blending','blend')
	node.Conf('stereo_view', EYE_NAMES[eye])
  
        #node.AddTile (machine[1][2]*w, machine[1][3]*h, machine[1][2], machine[1][3])
        node.AddSPU( readbackspu )
        #packspu = SPU( 'pack' )
        #node.AddSPU( packspu )
        #packspu.AddServer( client_node, protocol='tcpip' )

        w = w + 1
        if w == client[1][0]:
          w = 0
          h = h - 1

        #if options.dist_texture:
        #   tex_spu = SPU ('dist_texture')
        #   node.AddSPU (tex_spu)

        node.AddSPU (render_spu)

        node.AutoStart ('/usr/bin/ssh ' + machine[0] + ' source $HOME/.bashrc && crserver')

        # add rendering node to mothership
        cr.AddNode (node)
        tilesort_spu.AddServer (node, protocol='tcpip', port=7000 + index)

  cr.AddNode (client_node)

#
# Create render node on client for reassembly
#
  render_node = CRNetworkNode()
  renderspu = SPU('render')
  renderspu.Conf('render_to_app_window', 1)
  renderspu.Conf('fullscreen',FULLSCREEN)
  renderspu.Conf('borderless',BORDERLESS)
  renderspu.Conf('resizable',RESIZABLE)
  renderspu.Conf('ontop',1)
  render_node.Conf('only_swap_once', 1)
  render_node.AddSPU(renderspu)

  cr.AddNode( render_node )
  render_node.AutoStart('/usr/bin/ssh ' + client[0] + ' source $HOME/.bashrc && crserver')

cr.Go()

# -----------------------------------------------------------------------------
# CLEAN UP
# -----------------------------------------------------------------------------

#Remove crserver, crappfaker, or opengl program
print "Killing"

#Kill all crserver and crappfaker
for client in crsite["client_nodes"]:

  #Connect to each server node and kill crserver
  for i in client[2]:
    os.system('/usr/bin/ssh ' + render_nodes[i-1][0] + ' killall -9 crserver')

  os.system('/usr/bin/ssh ' + client[0] + ' killall -9 crappfaker')
  program = string.split(client[4])
  os.system('/usr/bin/ssh ' + client[0] + ' killall -9 -e ' + program[0])

#Kill all programs that running locally on cluster
for local in crsite["local_run"]:
  
  machine = render_nodes[local[0] - 1][0]
  program = string.split(local[1])
  os.system('/usr/bin/ssh ' + machine + ' killall -9 -e ' + program[0])