check in Samir's changes for make street along curve

direct/src/leveleditor/LevelEditor.py

@@ -792,7 +792,7 @@ class LevelEditor(NodePath, PandaObject):
             self.traversalOn()
 
     def configureDriveModeCollisionData(self):
-        """
+        """initializeCollisions(self)
         Set up the local avatar for collisions
         """
         # Set up the collision sphere
@@ -1488,6 +1488,7 @@ class LevelEditor(NodePath, PandaObject):
         self.createNewGroup(type = 'vis')
 
     def createNewGroup(self, type = 'dna'):
+        print "createNewGroup"
         """ Create a new DNA Node group under the active parent """
         # Create a new DNA Node group
         if type == 'dna':
@@ -1538,6 +1539,7 @@ class LevelEditor(NodePath, PandaObject):
         self.initDNANode(newDNALandmarkBuilding)
 
     def addProp(self, propType):
+        print "addProp %s " % propType
         # Record new prop type
         self.setCurrent('prop_texture', propType)
         # And create new prop
@@ -1575,11 +1577,13 @@ class LevelEditor(NodePath, PandaObject):
     def createDoor(self, type):
         if (type == 'landmark_door'):
             newDNADoor = DNADoor('door')
+            print "createDoor %s" % type
             if not (self.getCurrent('door_double_texture')):
                 doorStyles = self.styleManager.attributeDictionary['door_double_texture'].getList()[1:]
                 defaultDoorStyle = whrandom.choice(doorStyles)
                 self.setCurrent('door_double_texture', defaultDoorStyle)
             newDNADoor.setCode(self.getCurrent('door_double_texture'))
+            print "doorcolor = %s" % self.getCurrent('door_color')
             newDNADoor.setColor(self.getCurrent('door_color'))
         elif (type == 'door'):
             newDNADoor = DNAFlatDoor('door')
@@ -2368,7 +2372,7 @@ class LevelEditor(NodePath, PandaObject):
         # Also move the camera
         taskMgr.remove('autoMoveDelay')
         handlesToCam = direct.widget.getPos(direct.camera)
-        handlesToCam = handlesToCam * (direct.dr.near/handlesToCam[1])
+        handlesToCam = handlesToCam * ( direct.dr.near/handlesToCam[1])
         if ((abs(handlesToCam[0]) > (direct.dr.nearWidth * 0.4)) or
             (abs(handlesToCam[2]) > (direct.dr.nearHeight * 0.4))):
             taskMgr.remove('manipulateCamera')
@@ -3373,6 +3377,16 @@ class LevelEditor(NodePath, PandaObject):
         self.reparentStreetBuildings(self.NPToplevel)
         return newGroup
 
+    def makeNewBuildingGroup(self, sequenceNum, side):
+        print "-------------------------- new building group %s ------------------------" % sequenceNum
+        # Now create a new group with just the buildings
+        self.addGroup(self.NPToplevel)
+        newGroup = self.NPParent
+        groupName = 'Buildings_' + side + "-" + str(sequenceNum)
+        newGroup.setName(groupName)
+        self.setName(newGroup, groupName)
+        direct.setActiveParent(newGroup)
+
     def adjustPropChildren(self, nodePath, maxPropOffset = -4):
         for np in nodePath.getChildrenAsList():
             dnaNode = self.findDNANode(np)
@@ -3446,65 +3460,183 @@ class LevelEditor(NodePath, PandaObject):
             parent = self.panel.component('hull'))
         if streetCurveFilename:
             modelFile = loader.loadModel(Filename.fromOsSpecific(streetCurveFilename))
-            curve = modelFile.find('**/+ClassicNurbsCurve')
+            #curves = modelFile.findAllMatches('**/+ClassicNurbsCurve').asList()
-            if not curve.isEmpty():
+            curves = {'inner':[], 'outer':[]}
-                return curve.node()
+            curvesInner = modelFile.findAllMatches('**/*curve_inner*').asList()
-            else:
+            curvesOuter = modelFile.findAllMatches('**/*curve_outer*').asList()
-                return None
+            # return an ordered list
+            for i in range(len(curvesInner)):
+                curve = modelFile.find('**/*curve_inner_'+str(i))
+                if not curve.isEmpty():
+                    # Mark whether it is a section of buildings or trees
+                    curveType = curve.getName().split("_")[0]
+                    curves['inner'].append([curve.node(),curveType])
+            for i in range(len(curvesOuter)):
+                curve = modelFile.find('**/*curve_outer_'+str(i))
+                if not curve.isEmpty():
+                    # Mark whether it is a section of buildings or trees
+                    curveType = curve.getName().split("_")[0]
+                    curves['outer'].append([curve.node(),curveType])
+            print "loaded curves: %s" % curves
+            return curves
         else:
             return None
 
     def duplicateFlatBuilding(self, oldDNANode):
         # Yes, make a new copy of the dnaNode
+        print "a"
         dnaNode = oldDNANode.__class__(oldDNANode)
+        print "b"
         dnaNode.setWidth(oldDNANode.getWidth())
         # Add the DNA to the active parent
+        print "c"
         self.DNAParent.add(dnaNode)
         # And create the geometry
+        print "d %s" % (oldDNANode)
         newNodePath = dnaNode.traverse(self.NPParent, DNASTORE, 1)
+        print "e"
         return newNodePath
 
+    def getBldg(self, bldgIndex, bldgs):
+        numBldgs = len(bldgs)
+        if bldgIndex < numBldgs:
+            # Use original
+            print "using original bldg"
+            bldg = bldgs[bldgIndex]
+            bldgIndex += 1
+        else:
+            # Make a copy
+            oldBldg = bldgs[bldgIndex % numBldgs]
+            bldgIndex += 1
+
+            oldBldg.select()
+            oldDNANode = self.findDNANode(oldBldg)
+            nodeClass = DNAGetClassType(oldDNANode)
+            if nodeClass.eq(DNA_LANDMARK_BUILDING):
+                print "making landmark copy"
+                # Remove white and dark grey doors from color list
+                colorList = self.getAttribute('door_color').getList()
+                colorList = colorList[1:3] + colorList[4:len(colorList)]
+                # Set a random door color
+                doorColor = whrandom.choice(colorList)
+                self.setCurrent('door_color', doorColor)
+                self.addLandmark(oldDNANode.getCode(), oldDNANode.getBuildingType())
+                bldg = self.lastNodePath
+            else:
+                print "making flatbuilding copy"
+                bldg = self.duplicateFlatBuilding(oldDNANode)
+        return bldg, bldgIndex
+        
     def makeStreetAlongCurve(self):
-        curve = self.loadStreetCurve()
+        curves = self.loadStreetCurve()
-        if curve == None:
+        if curves == None:
             return
+
         direct.grid.fXyzSnap = 0
         direct.grid.fHprSnap = 0
         self.panel.fPlaneSnap.set(0)
         bldgGroup = self.consolidateStreetBuildings()
         bldgs = bldgGroup.getChildrenAsList()
-        currT = 0
+
-        endT = curve.getMaxT()
+        # streetWidth puts buildings on the edge of the street, not the middle
         currPoint = Point3(0)
         bldgIndex = 0
-        numBldgs = len(bldgs)
+
-        while currT < endT:
+        # Populate buildings on both sides of the street
-            if bldgIndex < numBldgs:
+        sides = ['inner', 'outer']
-                # Use original
+        maxGroupWidth = 500
-                bldg = bldgs[bldgIndex]
+        for side in sides:
-                bldgIndex += 1
+            print "Building street for %s side" % side
-            else:
+            # Subdivide the curve into different groups.  
-                # Make a copy
+            bldgGroupIndex = 0
-                oldBldg = bldgs[bldgIndex % numBldgs]
+            curGroupWidth = 0
-                bldgIndex += 1
+            self.makeNewBuildingGroup(bldgGroupIndex, side)
-                oldBldg.select()
+            
-                oldDNANode = self.findDNANode(oldBldg)
+            for curve, curveType in curves[side]:
-                nodeClass = DNAGetClassType(oldDNANode)
+                print "----------------- curve(%s): %s --------------- " % (side, curve)
-                if nodeClass.eq(DNA_LANDMARK_BUILDING):
+                currT = 0
-                    self.addLandmark(oldDNANode.getCode(), oldDNANode.getBuildingType())
+                endT = curve.getMaxT()
-                    bldg = self.lastNodePath
+
-                else:
+                while currT < endT:
-                    bldg = self.duplicateFlatBuilding(oldDNANode)
+                    if curveType == 'urban':
-            curve.getPoint(currT, currPoint)
+                        bldg, bldgIndex = self.getBldg(bldgIndex, bldgs)
-            bldg.setPos(currPoint)
+                        curve.getPoint(currT, currPoint)
-            bldgWidth = self.getBuildingWidth(bldg)
+
-            # Adjust grid orientation based upon next point along curve
+                        if side == "inner":
-            print bldgIndex, currT
+                            heading = 90
-            currT, currPoint = self.findBldgEndPoint(bldgWidth, curve, currT, currPoint, rd = 0)
+                        else:
-            bldg.lookAt(currPoint)
+                            heading = -90
-            bldg.setH(bldg, 90)
+                        bldg.setPos(currPoint)
-            self.updateSelectedPose([bldg])
+                        bldgWidth = self.getBuildingWidth(bldg)
-            self.adjustPropChildren(bldg)
+
+                        curGroupWidth += bldgWidth
+                        # Adjust grid orientation based upon next point along curve
+                        currT, currPoint = self.findBldgEndPoint(bldgWidth, curve, currT, currPoint, rd = 0)
+                        bldg.lookAt(Point3(currPoint))
+                        bldg.setH(bldg, heading)
+
+                        # Shift building forward if it is on the out track, since we just turned it away from
+                        # the direction of the track
+                        if side == "outer":
+                            bldg.setPos(currPoint)
+
+                        self.updateSelectedPose([bldg])
+                        self.adjustPropChildren(bldg)
+                        direct.reparent(bldg, fWrt = 1)
+                        print bldgIndex
+                    elif curveType == 'trees':
+                        curve.getPoint(currT, currPoint)
+                        # trees are spaced anywhere from 40-80 ft apart
+                        treeWidth = whrandom.randint(40,80)
+                        curGroupWidth += treeWidth
+                        # Adjust grid orientation based upon next point along curve
+                        currT, currPoint = self.findBldgEndPoint(treeWidth, curve, currT, currPoint, rd = 0)
+                        
+                        # Add some trees
+                        tree = whrandom.choice(["prop_tree_small_ul",
+                                                "prop_tree_small_ur",
+                                                "prop_tree_large_ur",
+                                                "prop_tree_large_ul"])
+                        self.addProp(tree)
+                        for selectedNode in direct.selected:
+                            # Move it
+                            selectedNode.setPos(currPoint)
+                            # Snap objects to grid and update DNA if necessary
+                            self.updateSelectedPose(direct.selected.getSelectedAsList())
+                    elif curveType == 'bridge':
+                        # Don't add any dna for the bridge sections, but add the length
+                        # of the bridge so we can increment our building groups correctly
+                        print "adding bridge (%s), curT = %s" % (side, currT)
+                        bridgeWidth = 1050
+                        curGroupWidth += bridgeWidth
+                        #currT, currPoint = self.findBldgEndPoint(bridgeWidth, curve, currT, currPoint, rd = 0)
+                        print "currT after adding bridge = %s" % currT
+                        # force move to next curve
+                        currT = endT + 1
+                    elif curveType == 'tunnel':
+                        # Don't add any dna for the tunnel sections, but add the length
+                        # of the bridge so we can increment our building groups correctly
+                        print "adding tunnel (%s), curT = %s" % (side, currT)
+                        tunnelWidth = 775
+                        curGroupWidth += tunnelWidth
+                        #currT, currPoint = self.findBldgEndPoint(tunnelWidth, curve, currT, currPoint, rd = 0)
+                        print "currT after adding tunnel = %s" % currT
+                        # force move to next curve
+                        currT = endT + 1
+                    
+                    # Check if we need a new group yet
+                    if curGroupWidth > maxGroupWidth:
+                        print "curGroupWidth %s > %s" % (curGroupWidth, maxGroupWidth)
+                        diffGroup = curGroupWidth - maxGroupWidth
+                        while diffGroup > 0:
+                            bldgGroupIndex += 1
+                            self.makeNewBuildingGroup(bldgGroupIndex, side)
+                            print "adding group %s (%s)" % (bldgGroupIndex, diffGroup)
+                            diffGroup -= maxGroupWidth
+                        curGroupWidth = 0
+                    print currT, curGroupWidth
+
+                        
 
     def findBldgEndPoint(self, bldgWidth, curve, currT, currPoint,
                          startT = None, endT = None, tolerance = 0.1, rd = 0):
@@ -3539,7 +3671,6 @@ class LevelEditor(NodePath, PandaObject):
             else:
                 return self.findBldgEndPoint(bldgWidth, curve, currT, currPoint, startT = midT, endT = endT,
                                              rd = rd + 1)
-
 class LevelStyleManager:
     """Class which reads in style files and manages class variables"""
     def __init__(self):