Added ability to remotely specify camera frustum, cleaned up config code

direct/src/cluster/ClusterClient.py

@@ -11,12 +11,26 @@ from ClusterMsgs import *
 import time
 
 class ClusterConfigItem:
-    def __init__(self, serverFunction, serverName, pos, hpr, port):
+    def __init__(self, serverFunction, serverName, port):
         self.serverName = serverName
         self.serverFunction = serverFunction
-        self.xyz = pos
-        self.hpr = hpr
         self.port = port
+        # Camera Offset
+        self.xyz = Vec3(0)
+        self.hpr = Vec3(0)
+        # Camera Frustum Data
+        self.fFrustum = 0
+        self.focalLength = None
+        self.filmSize = None
+        self.filmOffset = None
+    def setCamOffset(self, xyz, hpr):
+        self.xyz = xyz
+        self.hpr = hpr
+    def setCamFrustum(self, focalLength, filmSize, filmOffset):
+        self.fFrustum = 1
+        self.focalLength = focalLength
+        self.filmSize = filmSize
+        self.filmOffset = filmOffset
 
 class DisplayConnection:
     def __init__(self,qcm,serverName,port,msgHandler):
@@ -43,6 +57,18 @@ class DisplayConnection:
         datagram = self.msgHandler.makeCamOffsetDatagram(xyz, hpr)
         self.cw.send(datagram, self.tcpConn)
 
+    def sendCamFrustum(self,focalLength, filmSize, filmOffset):
+        ClusterManager.notify.debug("send cam frustum...")
+        ClusterManager.notify.debug(
+            (("packet %d" % self.msgHandler.packetNumber) +
+             (" fl, fs, fo=%0.3f, (%0.3f, %0.3f), (%0.3f, %0.3f)" %
+              (focalLength, filmSize[0], filmSize[1],
+               filmOffset[0], filmOffset[1])))
+            )
+        datagram = self.msgHandler.makeCamFrustumDatagram(
+            focalLength, filmSize, filmOffset)
+        self.cw.send(datagram, self.tcpConn)
+
     def sendMoveCam(self,xyz,hpr):
         ClusterManager.notify.debug("send cam move...")
         ClusterManager.notify.debug( ("packet %d xyz,hpr=%f %f %f %f %f %f" %
@@ -84,6 +110,10 @@ class ClusterManager(DirectObject.DirectObject):
                                      serverConfig.port)) )
             else:
                 server.sendCamOffset(serverConfig.xyz,serverConfig.hpr)
+                if serverConfig.fFrustum:
+                    server.sendCamFrustum(serverConfig.focalLength,
+                                          serverConfig.filmSize,
+                                          serverConfig.filmOffset)
                 self.serverList.append(server)
         self.startMoveCamTask()
 

direct/src/cluster/ClusterConfig.py

@@ -11,18 +11,81 @@ import string
 # Note: If server chan-config consists of multiple display regions
 # each display region can have an additional offset as specified in
 # DirectCamConfig.py
-ClientConfigs = {'mono-modelcave-pipe0': [ [Vec3(0),Vec3(0)] ],
-                 'single-server': [ [Vec3(0),Vec3(0)] ],
-                 'two-server'   : [ [Vec3(0),Vec3(-60,0,0)],
-                                    [Vec3(0),Vec3(60,0,0)]
-                                    ],
-                 'cavetest'     : [ [Vec3(0), Vec3(0)],
-                                    [Vec3(0), Vec3(0)],
-                                    [Vec3(0), Vec3(0)],
-                                    [Vec3(0), Vec3(0)]
-                                    ],
-                 }
-
+ClientConfigs = {
+    'mono-modelcave-pipe0': [{'pos' : Vec3(0),
+                              'hpr' : Vec3(0)}
+                             ],
+    'single-server'       : [{'pos' : Vec3(0),
+                              'hpr' : Vec3(0)}
+                             ],
+    'two-server'          : [{'pos' : Vec3(0),
+                              'hpr' : Vec3(-60,0,0)},
+                             {'pos' : Vec3(0),
+                              'hpr' : Vec3(60,0,0)}
+                             ],
+    'cavetest'            : [{'pos' : Vec3(-0.105, -0.020, 5.000),
+                              'hpr' : Vec3(51.213, 0.000, 0.000),
+                              'focal length' : 0.809,
+                              'film size' : (1.000, 0.831),
+                              'film offset' : (0.000, 0.173),
+                              },
+                             {'pos' : Vec3(-0.105, -0.020, 5.000),
+                              'hpr' : Vec3(-0.370, 0.000, 0.000),
+                              'focal length' : 0.815,
+                              'film size' : (1.000, 0.831),
+                              'film offset' : (0.000, 0.173),
+                              },
+                             {'pos' : Vec3(-0.105, -0.020, 5.000),
+                              'hpr' : Vec3(-51.675, 0.000, 0.000),
+                              'focal length' : 0.820,
+                              'film size' : (1.000, 0.830),
+                              'film offset' : (-0.000, 0.173),
+                              },
+                             {'pos' : Vec3(0.105, -0.020, 5.000),
+                              'hpr' : Vec3(51.675, 0.000, 0.000),
+                              'focal length' : 0.820,
+                              'film size' : (1.000, 0.830),
+                              'film offset' : (0.000, 0.173),
+                              },
+                             ],
+    'cavetest-all'        : [{'pos' : Vec3(-0.105, -0.020, 5.000),
+                              'hpr' : Vec3(51.213, 0.000, 0.000),
+                              'focal length' : 0.809,
+                              'film size' : (1.000, 0.831),
+                              'film offset' : (0.000, 0.173),
+                              },
+                             {'pos' : Vec3(-0.105, -0.020, 5.000),
+                              'hpr' : Vec3(-0.370, 0.000, 0.000),
+                              'focal length' : 0.815,
+                              'film size' : (1.000, 0.831),
+                              'film offset' : (0.000, 0.173),
+                              },
+                             {'pos' : Vec3(-0.105, -0.020, 5.000),
+                              'hpr' : Vec3(-51.675, 0.000, 0.000),
+                              'focal length' : 0.820,
+                              'film size' : (1.000, 0.830),
+                              'film offset' : (-0.000, 0.173),
+                              },
+                             {'pos' : Vec3(0.105, -0.020, 5.000),
+                              'hpr' : Vec3(51.675, 0.000, 0.000),
+                              'focal length' : 0.820,
+                              'film size' : (1.000, 0.830),
+                              'film offset' : (0.000, 0.173),
+                              },
+                             {'pos' : Vec3(0.105, -0.020, 5.000),
+                              'hpr' : Vec3(0.370, 0.000, 0.000),
+                              'focal length' : 0.815,
+                              'film size' : (1.000, 0.831),
+                              'film offset' : (0.000, 0.173),
+                              },
+                             {'pos' : Vec3(0.105, -0.020, 5.000),
+                              'hpr' : Vec3(-51.213, 0.000, 0.000),
+                              'focal length' : 0.809,
+                              'film size' : (1.000, 0.831),
+                              'film offset' : (-0.000, 0.173),
+                              },
+                             ],
+    }
 
 def createClusterManager():
     # setup camera offsets based on cluster-config
@@ -35,9 +98,10 @@ def createClusterManager():
         return None
     # Get display config for each server in the cluster
     displayConfigs = []
-    configData = ClientConfigs[clusterConfig]
-    numConfigs = len(configData)
+    configList = ClientConfigs[clusterConfig]
+    numConfigs = len(configList)
     for i in range(numConfigs):
+        configData = configList[i]
         serverConfigName = 'display%d' % i
         serverString = base.config.GetString(serverConfigName, '')
         if serverString == '':
@@ -53,14 +117,21 @@ def createClusterManager():
             else:
                 # Use default port
                 port = CLUSTER_PORT
-            displayConfigs.append(ClusterConfigItem(
+            cci = ClusterConfigItem(
                 serverConfigName,
                 serverName,
-                # Pos Offset
-                configData[i][0],
-                # Hpr Offset
-                configData[i][1],
-                port))
+                port)
+            # Init Cam Offset
+            pos = configData.get('pos', Vec3(0))
+            hpr = configData.get('hpr', Vec3(0))
+            cci.setCamOffset(pos, hpr)
+            # Init Frustum if specified
+            fl = configData.get('focalLength', None)
+            fs = configData.get('filmSize', None)
+            fo = configData.get('filmOffset', None)
+            if fl and fs and fo:
+                cci.setCamFrustum(fl, fs, fo)
+            displayConfigs.append(cci)
     # Create Cluster Managers (opening connections to servers)
     # Are the servers going to be synced?
     synced = base.config.GetBool('sync-display', 0)

direct/src/cluster/ClusterMsgs.py

@@ -10,9 +10,10 @@
 #these are the types of messages that are currently supported.
 CLUSTER_NOTHING    = -1
 CLUSTER_CAM_OFFSET = 1
-CLUSTER_POS_UPDATE = 2
-CLUSTER_SWAP_READY = 3
-CLUSTER_SWAP_NOW   = 4
+CLUSTER_CAM_FRUSTUM = 2
+CLUSTER_POS_UPDATE = 3
+CLUSTER_SWAP_READY = 4
+CLUSTER_SWAP_NOW   = 5
 
 #Port number for cluster rendering
 CLUSTER_PORT = 1970
@@ -89,6 +90,18 @@ class MsgHandler:
         datagram.addFloat32(hpr[2])
         return datagram
 
+    def makeCamFrustumDatagram(self,focalLength, filmSize, filmOffset):
+        datagram = Datagram.Datagram()
+        datagram.addUint32(self.packetNumber)
+        self.packetNumber = self.packetNumber + 1
+        datagram.addUint8(CLUSTER_CAM_FRUSTUM)
+        datagram.addFloat32(focalLength)
+        datagram.addFloat32(filmSize[0])
+        datagram.addFloat32(filmSize[1])
+        datagram.addFloat32(filmOffset[0])
+        datagram.addFloat32(filmOffset[1])
+        return datagram
+
     def makeMoveCamDatagram(self,xyz,hpr):
         datagram = Datagram.Datagram()
         datagram.addUint32(self.packetNumber)

direct/src/cluster/ClusterServer.py

@@ -35,6 +35,7 @@ class ClusterServer(DirectObject.DirectObject):
         print self.tcpRendezvous
         self.cameraGroup = cameraGroup
         self.camera = camera
+        self.lens = camera.node().getLens()
         self.qcl.addConnection(self.tcpRendezvous)
         self.msgHandler = MsgHandler(ClusterServer.MSG_NUM,self.notify)
         self.startListenerPollTask()
@@ -89,39 +90,52 @@ class ClusterServer(DirectObject.DirectObject):
         return availGetVal
 
     def handleCamOffset(self,dgi):
-            x=dgi.getFloat32()
-            y=dgi.getFloat32()
-            z=dgi.getFloat32()
-            h=dgi.getFloat32()
-            p=dgi.getFloat32()
-            r=dgi.getFloat32()
-            self.notify.debug(('  new offset=%f %f %f  %f %f %f' %
-                              (x,y,z,h,p,r)))
-            self.posOffset = Vec3(x,y,z)
-            self.hprOffset = Vec3(h,p,r)
+        x=dgi.getFloat32()
+        y=dgi.getFloat32()
+        z=dgi.getFloat32()
+        h=dgi.getFloat32()
+        p=dgi.getFloat32()
+        r=dgi.getFloat32()
+        self.notify.debug(('  new offset=%f %f %f  %f %f %f' %
+                           (x,y,z,h,p,r)))
+        self.posOffset = Vec3(x,y,z)
+        self.hprOffset = Vec3(h,p,r)
+        
+    def handleCamFrustum(self,dgi):
+        focalLength=dgi.getFloat32()
+        filmSize=(dgi.getFloat32(), dgi.getFloat32())
+        filmOffset=(dgi.getFloat32(),dgi.getFloat32())
+        self.notify.debug('  fl, fs, fo=%f, (%f, %f), (%f, %f)' %
+                          (focalLength, filmSize[0], filmSize[1],
+                           filmOffset[0], filmOffset[1]))
+        self.lens.setFocalLength(focalLength)
+        self.lens.setFilmSize(filmSize[0], filmSize[1])
+        self.lens.setFilmOffset(filmOffset[0], filmOffset[1])
 
     def handleCamMovement(self,dgi):
-            x=dgi.getFloat32()
-            y=dgi.getFloat32()
-            z=dgi.getFloat32()
-            h=dgi.getFloat32()
-            p=dgi.getFloat32()
-            r=dgi.getFloat32()
-            self.notify.debug(('  new position=%f %f %f  %f %f %f' %
-                              (x,y,z,h,p,r)))
-            finalX = x + self.posOffset[0]
-            finalY = y + self.posOffset[1]
-            finalZ = z + self.posOffset[2]
-            finalH = h + self.hprOffset[0]
-            finalP = p + self.hprOffset[1]
-            finalR = r + self.hprOffset[2]
-            self.cameraGroup.setPosHpr(render,finalX,finalY,finalZ,
-                                       finalH,finalP,finalR)
-
+        x=dgi.getFloat32()
+        y=dgi.getFloat32()
+        z=dgi.getFloat32()
+        h=dgi.getFloat32()
+        p=dgi.getFloat32()
+        r=dgi.getFloat32()
+        self.notify.debug(('  new position=%f %f %f  %f %f %f' %
+                           (x,y,z,h,p,r)))
+        finalX = x + self.posOffset[0]
+        finalY = y + self.posOffset[1]
+        finalZ = z + self.posOffset[2]
+        finalH = h + self.hprOffset[0]
+        finalP = p + self.hprOffset[1]
+        finalR = r + self.hprOffset[2]
+        self.cameraGroup.setPosHpr(render,finalX,finalY,finalZ,
+                                   finalH,finalP,finalR)
+        
     def handleDatagram(self, datagram):
-        (type, dgi) = msgHandler.nonBlockingRead(self.qcr)
+        (type, dgi) = self.msgHandler.nonBlockingRead(self.qcr)
         if type==CLUSTER_CAM_OFFSET:
             self.handleCamOffset(dgi)
+        elif type==CLUSTER_CAM_FRUSTUM:
+            self.handleCamFrustum(dgi)
         elif type==CLUSTER_POS_UPDATE:
             self.handleCamMovement(dgi)
         elif type==CLUSTER_SWAP_READY: