delta pos; isRendering

direct/src/showbase/ControlManager.py

@@ -68,7 +68,11 @@ class ControlManager:
         inputState.watch("jump", "alt-control", "alt-control-up")
         inputState.watch("jump", "shift-control", "shift-control-up")
         
-        inputState.watch("shift", "shift", "shift-up")
+        inputState.watch("slideLeft", "home", "home-up")
+        inputState.watch("slideRight", "end", "end-up")
+        inputState.watch("levitateUp", "page_up", "page_up-up")
+        inputState.watch("levitateDown", "page_down", "page_down-up")
+        inputState.watch("run", "shift", "shift-up")
         
         # FYI, ghost mode uses jump for slide.
         inputState.watch("slide", "slide-is-disabled", "slide-is-disabled")
@@ -77,13 +81,13 @@ class ControlManager:
         #inputState.watch("slideLeft", "control-arrow_left", "control-arrow_left-up")
         #inputState.watch("slideLeft", "alt-arrow_left", "alt-arrow_left-up")
         #inputState.watch("slideLeft", "shift-arrow_left", "shift-arrow_left-up")
-        inputState.watch("slideLeft", "slide-is-disabled", "slide-is-disabled")
+        #inputState.watch("slideLeft", "slide-is-disabled", "slide-is-disabled")
         
         #inputState.watch("slideRight", "shift-arrow_right", "shift-arrow_right-up")
         #inputState.watch("slideRight", "control-arrow_right", "control-arrow_right-up")
         #inputState.watch("slideRight", "alt-arrow_right", "alt-arrow_right-up")
         #inputState.watch("slideRight", "shift-arrow_right", "shift-arrow_right-up")
-        inputState.watch("slideRight", "slide-is-disabled", "slide-is-disabled")
+        #inputState.watch("slideRight", "slide-is-disabled", "slide-is-disabled")
 
 
     def add(self, controls, name="basic"):
@@ -223,8 +227,8 @@ class ControlManager:
             self.devControls.disableAvatarControls()
             self.devControls.setCollisionsActive(0)
 
-        self.walkControls.setCollisionsActive(1)
+        #self.walkControls.setCollisionsActive(1)
-        self.walkControls.enableAvatarControls()
+        #self.walkControls.enableAvatarControls()
 
     def deleteCollisions(self):
         assert(self.debugPrint("deleteCollisions()"))

direct/src/showbase/DevWalker.py

@@ -75,18 +75,22 @@ class DevWalker(DirectObject.DirectObject):
         reverse = inputState.isSet("reverse")
         turnLeft = inputState.isSet("turnLeft")
         turnRight = inputState.isSet("turnRight")
-        shift = inputState.isSet("shift")
+        slideLeft = inputState.isSet("slideLeft")
+        slideRight = inputState.isSet("slideRight")
+        levitateUp = inputState.isSet("levitateUp")
+        levitateDown = inputState.isSet("levitateDown")
+        run = inputState.isSet("run") and 4.0 or 1.0
         # Determine what the speeds are based on the buttons:
-        self.speed=shift and (
+        self.speed=(
                 (forward and self.avatarControlForwardSpeed or 
                 reverse and -self.avatarControlReverseSpeed))
-        self.liftSpeed=not shift and (
+        self.liftSpeed=(
-                (forward and self.avatarControlForwardSpeed or 
+                (levitateUp and self.avatarControlForwardSpeed or 
-                reverse and -self.avatarControlReverseSpeed))
+                levitateDown and -self.avatarControlReverseSpeed))
-        self.slideSpeed=not shift and (
+        self.slideSpeed=(
-                (turnLeft and -self.avatarControlForwardSpeed) or 
+                (slideLeft and -self.avatarControlForwardSpeed) or 
-                (turnRight and self.avatarControlForwardSpeed))
+                (slideRight and self.avatarControlForwardSpeed))
-        self.rotationSpeed=shift and (
+        self.rotationSpeed=(
                 (turnLeft and self.avatarControlRotateSpeed) or
                 (turnRight and -self.avatarControlRotateSpeed))
             
@@ -94,9 +98,9 @@ class DevWalker(DirectObject.DirectObject):
         if self.speed or self.liftSpeed or self.slideSpeed or self.rotationSpeed:
             # How far did we move based on the amount of time elapsed?
             dt=min(ClockObject.getGlobalClock().getDt(), 0.1)
-            distance = dt * self.speed
+            distance = dt * self.speed * run
-            lift = dt * self.liftSpeed
+            lift = dt * self.liftSpeed * run
-            slideDistance = dt * self.slideSpeed
+            slideDistance = dt * self.slideSpeed * run
             rotation = dt * self.rotationSpeed
 
             # Take a step in the direction of our previous heading.

direct/src/showbase/GravityWalker.py

@@ -52,8 +52,12 @@ class GravityWalker(DirectObject.DirectObject):
         self.avatarControlReverseSpeed=0
         self.avatarControlRotateSpeed=0
         self.getAirborneHeight=None
+        
+        self.priorParent=Vec3(0)
         self.__oldPosDelta=Vec3(0)
         self.__oldDt=0
+        
+        self.moving=0
         self.speed=0.0
         self.rotationSpeed=0.0
         self.slideSpeed=0.0
@@ -213,8 +217,8 @@ class GravityWalker(DirectObject.DirectObject):
 
         self.setCollisionsActive(1)
 
-    def setAirborneHeightFunc(self, getAirborneHeight):
+    def setAirborneHeightFunc(self, unused_parameter):
-        self.getAirborneHeight = getAirborneHeight
+        self.getAirborneHeight = self.lifter.getAirborneHeight
 
     def setAvatarPhysicsIndicator(self, indicator):
         """
@@ -236,6 +240,8 @@ class GravityWalker(DirectObject.DirectObject):
         del self.pusher
         del self.event
         del self.lifter
+        
+        del self.getAirborneHeight
 
     def setCollisionsActive(self, active = 1):
         assert(self.debugPrint("collisionsActive(active=%s)"%(active,)))
@@ -264,7 +270,10 @@ class GravityWalker(DirectObject.DirectObject):
         as floor, but are nearly vertical.  This ray is
         a hack to help deal with the cliff.
         """
-        if self.lifter.isInOuterSpace():
+        if (base.isRendering
+                and self.collisionsActive
+                and self.moving
+                and self.lifter.isInOuterSpace()):
             temp = self.cRayNodePath.getZ()
             self.cRayNodePath.setZ(14.0)
             self.oneTimeCollide()
@@ -325,6 +334,9 @@ class GravityWalker(DirectObject.DirectObject):
                 (turnLeft and self.avatarControlRotateSpeed) or
                 (turnRight and -self.avatarControlRotateSpeed))
 
+        if self.needToDeltaPos:
+            self.setPriorParentVector()
+            self.needToDeltaPos = 0
         if self.wantDebugIndicator:
             onScreenDebug.add("airborneHeight", self.lifter.getAirborneHeight()) #*#
             onScreenDebug.add("falling", self.falling) #*#
@@ -343,14 +355,15 @@ class GravityWalker(DirectObject.DirectObject):
         if self.lifter.isOnGround():
             if self.isAirborne:
                 self.isAirborne = 0
+                self.priorParent = Vec3(0)
                 impact = self.lifter.getImpactVelocity()
                 if impact < -30.0:
                     messenger.send("jumpHardLand")
-                    self.startJumpDelay(0.1)
+                    self.startJumpDelay(0.3)
                 else:
                     messenger.send("jumpLand")
                     if impact < -5.0:
-                        self.startJumpDelay(0.05)
+                        self.startJumpDelay(0.2)
                     # else, ignore the little potholes.
             if jump and self.mayJump:
                 # ...the jump button is down and we're close
@@ -363,10 +376,14 @@ class GravityWalker(DirectObject.DirectObject):
         #    if self.lifter.getAirborneHeight() > 10000.0:
         #        assert(0)
 
+        self.__oldPosDelta = self.avatarNodePath.getPosDelta(render)
+        # How far did we move based on the amount of time elapsed?
+        self.__oldDt = ClockObject.getGlobalClock().getDt()
+        dt=min(self.__oldDt, 0.1)
+
         # Check to see if we're moving at all:
-        if self.speed or self.slideSpeed or self.rotationSpeed:
+        self.moving = self.speed or self.slideSpeed or self.rotationSpeed or (self.priorParent!=Vec3.zero())
-            # How far did we move based on the amount of time elapsed?
+        if self.moving:
-            dt=min(ClockObject.getGlobalClock().getDt(), 0.1)
             distance = dt * self.speed
             slideDistance = dt * self.slideSpeed
             rotation = dt * self.rotationSpeed
@@ -374,11 +391,11 @@ class GravityWalker(DirectObject.DirectObject):
             # Take a step in the direction of our previous heading.
             self.vel=Vec3(Vec3.forward() * distance + 
                           Vec3.right() * slideDistance)
-            if self.vel != Vec3.zero():
+            if self.vel != Vec3.zero() or self.priorParent != Vec3.zero():
                 # rotMat is the rotation matrix corresponding to
                 # our previous heading.
                 rotMat=Mat3.rotateMatNormaxis(self.avatarNodePath.getH(), Vec3.up())
-                step=rotMat.xform(self.vel)
+                step=rotMat.xform(self.vel) + (self.priorParent * dt)
                 self.avatarNodePath.setFluidPos(Point3(
                         self.avatarNodePath.getPos()+step))
             self.avatarNodePath.setH(self.avatarNodePath.getH()+rotation)
@@ -392,25 +409,22 @@ class GravityWalker(DirectObject.DirectObject):
         self.needToDeltaPos = 1
     
     def setPriorParentVector(self):
-        assert(self.debugPrint("doDeltaPos()"))
+        assert(self.debugPrint("setPriorParentVector()"))
-        
-        print "self.__oldDt", self.__oldDt, "self.__oldPosDelta", self.__oldPosDelta
         if __debug__:
             onScreenDebug.add("__oldDt", "% 10.4f"%self.__oldDt)
             onScreenDebug.add("self.__oldPosDelta",
                               self.__oldPosDelta.pPrintValues())
-        
+        velocity = self.__oldPosDelta*(1.0/self.__oldDt)
-        velocity = self.__oldPosDelta*(1/self.__oldDt)*4.0 # *4.0 is a hack
+        self.priorParent = Vec3(velocity)
-        assert(self.debugPrint("  __oldPosDelta=%s"%(self.__oldPosDelta,)))
+        self.priorParent.setZ(0.0) # The lifter handles the z value.
-        assert(self.debugPrint("  velocity=%s"%(velocity,)))
-        self.priorParent.setVector(Vec3(velocity))
         if __debug__:
             if self.wantDebugIndicator:
-                onScreenDebug.add("velocity", velocity.pPrintValues())
+                onScreenDebug.add("priorParent", self.priorParent.pPrintValues())
     
     def reset(self):
         assert(self.debugPrint("reset()"))
         self.lifter.setVelocity(0.0)
+        self.priorParent=Vec3(0.0)
 
     def enableAvatarControls(self):
         """

direct/src/showbase/PhysicsWalker.py

@@ -348,6 +348,8 @@ class PhysicsWalker(DirectObject.DirectObject):
         del self.cSphereNodePath
 
         del self.pusher
+        
+        del self.getAirborneHeight
 
     def setCollisionsActive(self, active = 1):
         assert(self.debugPrint("collisionsActive(active=%s)"%(active,)))
@@ -410,9 +412,9 @@ class PhysicsWalker(DirectObject.DirectObject):
         reverse = inputState.isSet("reverse")
         turnLeft = inputState.isSet("turnLeft")
         turnRight = inputState.isSet("turnRight")
-        slide = inputState.isSet("slide")
+        slide = 0#inputState.isSet("slide")
-        slideLeft = inputState.isSet("slideLeft")
+        slideLeft = 0#inputState.isSet("slideLeft")
-        slideRight = inputState.isSet("slideRight")
+        slideRight = 0#inputState.isSet("slideRight")
         jump = inputState.isSet("jump")
         # Determine what the speeds are based on the buttons:
         self.__speed=(forward and self.avatarControlForwardSpeed or 

direct/src/showbase/ShowBase.py

@@ -67,6 +67,12 @@ class ShowBase(DirectObject.DirectObject):
         # the program by closing the main window.
         self.exitFunc = None
 
+        # There are times when we are not drawing anything new to the
+        # screen, but we were grinding away on all the collision loops
+        # and shadow stuff and actually rendering.  This is to test
+        # not doing some of that:
+        self.isRendering = 0
+        
         taskMgr.taskTimerVerbose = self.config.GetBool('task-timer-verbose', 0)
         taskMgr.extendedExceptions = self.config.GetBool('extended-exceptions', 0)
         
@@ -831,34 +837,37 @@ class ShowBase(DirectObject.DirectObject):
     def shadowCollisionLoop(self, state):
         # run the collision traversal if we have a
         # CollisionTraverser set.
-        if self.shadowTrav:
+        if self.isRendering:
-            self.shadowTrav.traverse(self.render)
+            if self.shadowTrav:
+                self.shadowTrav.traverse(self.render)
         return Task.cont
 
     def collisionloop(self, state):
         # run the collision traversal if we have a
         # CollisionTraverser set.
-        if self.cTrav:
+        if self.isRendering:
-            self.cTrav.traverse(self.render)
+            if self.cTrav:
-        if self.appTrav:
+                self.cTrav.traverse(self.render)
-            self.appTrav.traverse(self.render)
+            if self.appTrav:
+                self.appTrav.traverse(self.render)
         return Task.cont
 
     def igloop(self, state):
-        if __debug__:
+        if self.isRendering:
-            # We render the watch variables for the onScreenDebug as soon
+            if __debug__:
-            # as we reasonably can before the renderFrame().
+                # We render the watch variables for the onScreenDebug as soon
-            onScreenDebug.render()
+                # as we reasonably can before the renderFrame().
+                onScreenDebug.render()
 
-        # Finally, render the frame.
+            # Finally, render the frame.
-        self.graphicsEngine.renderFrame()
+            self.graphicsEngine.renderFrame()
-        if self.clusterSyncFlag:
+            if self.clusterSyncFlag:
-            self.graphicsEngine.syncFrame()
+                self.graphicsEngine.syncFrame()
 
-        if __debug__:
+            if __debug__:
-            # We clear the text buffer for the onScreenDebug as soon
+                # We clear the text buffer for the onScreenDebug as soon
-            # as we reasonably can after the renderFrame().
+                # as we reasonably can after the renderFrame().
-            onScreenDebug.clear()
+                onScreenDebug.clear()
     
         if self.mainWinMinimized:
             # If the main window is minimized, slow down the app a bit
@@ -876,6 +885,10 @@ class ShowBase(DirectObject.DirectObject):
         throwNewFrame()
         return Task.cont
 
+    def setRendering(self, isRendering):
+        self.isRendering = isRendering
+        print "** base.isRendering=%s **"%isRendering
+
     def restart(self):
         self.shutdown()
         # resetPrevTransform goes at the very beginning of the frame.