Esempio n. 1
0
 def makeStepVal(name, start, end, steps, locks=self._moveLock):
     """
     This function gets called in event time, not right now!
     """
     if name in locks:
         # Special case
         # We set =end on every frame if the end is a function (lambda).
         return None
     elif isinstance(end, (tuple, list)):
         # Assume these are 3D values.
         return div3D(
             diff3D(start, end),
             steps
         )
     elif isinstance(end, FunctionType):
         # Evaluate lambdas here:
         # in clocktime this is the start of movement.
         # This can only lead to confusion.
         print "self:", self
         print "kwargs:", kwargs
         print "name:", name
         print "end:", end
         assert (False)
     else:
         return float(end - start) / steps
Esempio n. 2
0
    def midpoint(self):
        """
        Edge.midpoint() -> (float,float,float)
        Returns the midpoint of this edge as a position tuple.
        """
        from utilities import add3D, div3D

        sum = add3D(self.source.pos, self.target.pos)
        return div3D(sum, 2.0)
Esempio n. 3
0
    def arrangeStepwise(self, graph, vertices, newPos, duration, wait=0.0, tween=True):
        """
        Arrange the vertices of the graph into a new layout
        specified by an indexed list of new positions newPos.
        The vertices will be positioned one at a time.
        """
        assert (len(newPos) == len(vertices))
        delay = float(duration) / len(vertices)

        from math import floor

        if tween:
            if delay > (1.0 / self.parent.fps):
                # No sense tweening faster than the frame rate can keep up
                stepsPerVert = int(floor(delay / (1.0 / self.parent.fps)))
                totalMove = [diff3D(a, b) for a, b in zip([x.pos for x in vertices], newPos)]
                partialMove = [div3D(x, stepsPerVert) for x in totalMove]
            else:
                tween = False

        accum = wait

        for i in range(len(vertices)):
            if tween:
                accum += delay / stepsPerVert
                for step in range(stepsPerVert - 1):
                    self.post(accum,
                              objects=(
                              vertices[i],
                              ),
                              props=(
                              (
                              'pos',
                              add3D(vertices[i].pos, mult3D(partialMove[i], (step + 1))),
                              ),
                              ),
                              changeGraph=graph,
                    )
                    accum += delay / stepsPerVert
            else:
                accum += delay
            self.post(accum,
                      objects=(
                      vertices[i],
                      ),
                      props=(
                      ('pos', newPos[i]),
                      ),
                      changeGraph=graph,
            )

        self.signal()
Esempio n. 4
0
    def perspCameraLookatMove(self, camera, newPos, fixLook, duration, wait=0.0):
        """
        Moves the camera smoothly to a new position and orientation.
        If newLook is None, does not change the orientation of the camera.
        If newPos is None, does not change the position of the camera.
        """
        from camera import Camera, OrthoCamera, X_AXIS, Y_AXIS, Z_AXIS

        assert (not isinstance(camera, OrthoCamera))

        fixLook = self.normalizePos(fixLook)
        steps = int(duration * self.parent.fps)

        deltaPos = diff3D(camera.pos, newPos)
        stepPos = div3D(deltaPos, steps)

        accum = wait
        delay = 1.0 / self.parent.fps

        # Set up the animation
        for i in range(steps - 1):
            accum += delay

            self.post(accum,
                      objects=(camera,),
                      props=(
                      ( 'pos', add3D(camera.pos, mult3D(stepPos, i + 1)) ),
                      ( 'lookAt', fixLook),
                      ),
                      call=(
                      ('absrotate', (Y_AXIS, stepYaw), {}),
                      ('rotate', (X_AXIS, stepPitch), {}),
                      ),
            )

        # Finish up in the correct place
        accum += delay
        self.post(accum,
                  objects=(camera,),
                  props=(
                  ('pos', newPos),
                  ('lookAt', fixLook),
                  ),
        )

        self.signal()
Esempio n. 5
0
    def arrangeMorph(self, graph, vertices, newPos, duration, wait=0.0):
        """
        Arrange the vertices of the graph into a new layout
        specified by an indexed list of new positions newPos.
        The vertices will be positioned simultaneously (smooth morph)
        """
        assert (len(newPos) == len(vertices))

        accum = wait

        steps = int(duration * self.parent.fps)
        delay = 1.0 / self.parent.fps

        d = [div3D(diff3D(a.pos, b), steps) for a, b in zip(vertices, newPos)]

        for i in range(steps - 1):
            accum += delay
            self.post(accum,
                      objects=vertices,
                      multiprops=(
                      (
                      'pos',
                      [add3D(a.pos, mult3D(b, i + 1)) for a, b in zip(vertices, d)]
                      ),
                      ),
                      changeGraph=graph,
            )

        accum += delay
        self.post(accum,
                  objects=vertices,
                  multiprops=(
                  ('pos', newPos),
                  ),
                  changeGraph=graph,
        )
        self.signal()
Esempio n. 6
0
    def perspCameraMove(self, camera, newPos=None, newLook=None, duration=1.0, wait=0.0):
        """
        Moves the camera smoothly to a new position and orientation.
        If newLook is None, does not change the orientation of the camera.
        If newPos is None, does not change the position of the camera.
        """
        from camera import Camera, OrthoCamera, X_AXIS, Y_AXIS, Z_AXIS

        assert (not isinstance(camera, OrthoCamera))

        newCam = Camera()
        if newPos != None:
            newCam.pos = self.normalizePos(newPos)
        else:
            newCam.pos = camera.pos
        if newLook != None:
            newCam.lookAt = self.normalizePos(newLook)
        else:
            newCam.lookAt = camera.lookAt

        steps = int(duration * self.parent.fps)

        (oldTheta, oldPhi) = camera.polar()
        (newTheta, newPhi) = newCam.polar()

        deltaYaw = newTheta - oldTheta
        deltaPitch = newPhi - oldPhi
        deltaPos = diff3D(camera.pos, newCam.pos)

        # Check to make sure we're coming around the short side
        if deltaYaw > 180.0:
            deltaYaw = deltaYaw - 360.0
        elif deltaYaw < -180.0:
            deltaYaw = deltaYaw + 360.0
        print "DeltaYaw", deltaYaw

        stepYaw = deltaYaw / steps
        stepPitch = deltaPitch / steps
        stepPos = div3D(deltaPos, steps)

        accum = wait
        delay = 1.0 / self.parent.fps

        # Set up the animation
        for i in range(steps - 1):
            accum += delay

            self.post(accum,
                      objects=(
                      camera,
                      ),
                      props=(
                      (
                      'pos',
                      add3D(camera.pos, mult3D(stepPos, i + 1)),
                      ),
                      ),
                      call=(
                      ('absrotate', (Y_AXIS, stepYaw), {}),
                      ('rotate', (X_AXIS, stepPitch), {}),
                      ),
            )

        # Finish up in the correct place
        accum += delay
        self.post(accum,
                  objects=(camera,),
                  props=(
                  ('pos', newCam.pos),
                  ('lookAt', newCam.lookAt),
                  ),
        )

        self.signal()