Animations - Creating a Curve2IPO wizard

[Grogyan]

Found some interesting data, that if some could verify for me

[[BezTriple
[-22.731007, -0.970000, 0.000000]
[1.000000, -0.970000, 0.000000]
[24.731007, -70000, 0.000000],

I've reformatted this slightly from how its shown but its the same, its just easier to read like this

Anyway the first line is for the first handle
the second is for the knot
the third is for the second handle

I don't know what the 3rd value in the matrix is for its just plain zero

The first float in each array in the matrix corresponds to time
the second responds to I think the extent on that axis relative to the objects centre

the second float is the frame number followed by its extent on the axis

The third array is the same as the first but with different extents it has

so now that I think I have the value of that curve, must remember that I cannot feed this back into the append function as its layout is completely different from what it expects

[Christian Walther]

Found some interesting data, that if some could verify for me

I'm not sure what your question is, due to lack of question marks in your post, but I assume it's this:

I don't know what the 3rd value in the matrix is for its just plain zero

That's the third dimension. For a curve in 3D space it would be the Z coordinate. Since Ipo curves live in a 2-dimensional space, it's unused here. As you observed, the first dimension is time, and the second is whatever quantity the curve describes.

(At least that's what I assume, based on my experimentation. I don't have this on any authority.)

[Nadnerb]

Yes, this is how the bezier handles are stored (or at least returned in the python interface) I would have assumed you knew this following all the work you've done so far, but then I haven't been following this very closely.

A bezTriple has multiple methods of accessing the same data. You can get only the points on the curve (or "knots") from bezTriple.pt, which returns [time, value], or you can get the entire handle via bezTriple.vec

bezTriple.vec[0] and [2] return the outer handles, which are in the same coordinate space as the points on the curve, and are returned as [time, value, 0]

bezTriple.vec[1] is the same as bezTriple.pt (except with an extra zero at the end, since it's returning lists of 3 floats)

Some rather old documentation

[Grogyan]

Ah, ok I was quite confused as to why I keep reading similar scripts and they have only 1 float, cause the compiler complains that its not a tuple -> usually something i've done wrong

Its pretty late tonight to work on it, will see what happens tomorrow or the weekend

Will feeding data for that handle actually show up in the Ipo, the API isn't too clear on that?

[Grogyan]

Back to work now on this script, and I have been getting some help from BlenderArtists, and I reckon the script is getting better with each little thing I learn about it.

I do think I have nailed that BezTriple problem down, thanks to FunkyWrym, just gonna try some revisions to the code

[Grogyan]

Woohoo, Grogyan does a happy dance, it works, it works!!!

Code that did it is

Code: Select all

# Store all bezier points
         H1_X = nCurvePoints.vec[0][0]
         H1_Y = nCurvePoints.vec[0][0]
         H1_Z = nCurvePoints.vec[0][2]
         P_X = nCurvePoints.vec[1][0]
         P_Y = nCurvePoints.vec[1][1]
         P_Z = nCurvePoints.vec[1][2]
         H2_X = nCurvePoints.vec[2][0]
         H2_Y = nCurvePoints.vec[2][1]
         H2_Z = nCurvePoints.vec[2][2]
      
         # make 3 BezTriples, and mke sure their handles are FREE
         # pass eacch of these 3 new BezTriples for X, Y and Z
         # to theirrelevant IPO's
         myIPOCurveX = Blender.BezTriple.New(myCurrentPathLen - 5, H1_X, 0, myCurrentPathLen, P_X, 0, myCurrentPathLen + 5, H2_X, 0)
         myIPOCurveY = Blender.BezTriple.New(myCurrentPathLen - 5, H1_Y, 0, myCurrentPathLen, P_Y, 0, myCurrentPathLen + 5, H2_Y, 0)
         myIPOCurveX.handleTypes = (Blender.BezTriple.HandleTypes.FREE, Blender.BezTriple.HandleTypes.FREE)
         myIPOCurveY.handleTypes = (Blender.BezTriple.HandleTypes.FREE, Blender.BezTriple.HandleTypes.FREE)
         myIPOCurveLoc_X.append(myIPOCurveX)
         myIPOCurveLoc_Y.append(myIPOCurveY)


This is one battle that is nearly over, in the above example I have forced the time base for the handles, as I now have that problem on my hands, but at least this is a victory, thanks all

[Grogyan]

Done a little more refinement, I suppose I should upload my example code, till I can migrate it over to the trunk

Location of an object mostly follows the drawn curve, ie it follows the X and Z axes but not the Y axis, and i'm not sure why

[Grogyan]

I havn't made much progress in a while now because of this weird anomaly of the Y axis.
I was hoping to have this sorted before taking on complex algorithms. Even so I can't even visualize why its happening, let alon how to fix it.

Here is the code that kinda works, if you aren't downloading it already from the SVN

Code: Select all

#!BPY

# A script to convert a curve to an IPO curve which can be used by an object to simulate the path it is flying

# Specifically designed to help with GoW_PyPrp plugin
"""
Name: 'Curve2IPO'
Blender: 246
Group: 'Wizards'
Tooltip: 'Make IPO curves from path'
"""
# ==============================================
#
#         ToDo
#
#   1) Move the else statement
#      to the end so that that section is skipped
#      when the condition isn't true
#      -> DONE
#
#   2) Put in a check object type in before the
#      first if statement, the else goes at the end
#      -> DONE
#
#   3) Put in a check for if its cyclic or not,
#      if it is true then save copy of the first
#      BezTriple and apply it after the for loop
#
#   4) Apply the BezTriple of locations to the IPO
#      window
#
#   5) Add to the IPO window the folowing blocks
#      dRotX, dRotY, dRotZ and Time where time is
#      the slow down or speed up at certain sections
#      though this is probably redundant and just
#      maintain a constand speed
#   
#   6) Work out an algorithm for the above
#      but don't for get that rotation is divided
#      by 10, eg 90 degres becomes 9 degrees
#      but test it out first.
#
#   7) Set the curves' datablock name as the
#      objects'
#      -> DONE
#
# ==============================================

import Blender
import math
from math import *

print"\n\n\n#################################################"
print"   Attempting to run script"
print"##############################################\n"

# Get the currently selected object
myCurve = Blender.Object.GetSelected()[0]

# Create variable and get the type of object   
myObjectType = myCurve.getType()

if myObjectType == 'Curve':
   print"   -> Object is a %s" % myObjectType
      
   myCurveData = Blender.Curve.Get()[0]
   myCurveFlag1 = myCurveData.getFlag()

   # Standard bit mask for bit 3
   if myCurveFlag1 and 0x08: #  Is "CurvePath" flag set
      print"   -> Curve flag bit 3 at 0x00001000 is set, value is: %x " % (myCurveFlag1 and 0x08)

      # Get the object name of the curve
      myCurveName = myCurve.getName()
      #myCurveBez = Blender.Object.Get(myCurve)   # Get data of curve
      
      # Initialize what will be the name of the IPO's
      myIPOCurveSet =  myCurve.getName()
      
      # Get the length of the curve in frames
      myPathLength = myCurveData.getPathLen()
      
      # Create variables myPathIter, myCurrentPathLen
      # and initialize them to a known value
      myPathIter = myCurrentPathLen = myPathLength
      
      #myIPOCurves = myIPOCurves.LOC[x]
      myIPOCurveSet = Blender.Ipo.New('Object', myCurveName) # Attmpting  to get the Curve name same as IPO curve set
      
      #####################################
      #handleTypes = (Blender.BezTriple.HandleTypes.FREE, Blender.BezTriple.HandleTypes.FREE)
      #####################################
      
      # Get the name of the data block
      myCurveData = myCurve.data
      
      myCyclicTest = myCurveData.isCyclic()
      if myCyclicTest == True:
         print"   -> Curve is cyclic"
      else:
         print"   -> Curve is not cyclic"
      
      # Set the name of the data block as the
      # objects' name
      myCurveData.setName(myCurveName)
      
      # Create the variable and intialize it to 0
      myCurvePoints = 0
      # Old way -> myCurvePoints = myCurveData.__getitem__(myCurvePoints)
      myCurvePoints = myCurveData[myCurvePoints]    

      # can't be bothered how to figure out how
      # use get curve length function in the API
      # its just as easy to write a loop to calculate it
      myNumberOfPoints = 0
      for iNumberOfPoints in myCurvePoints:
         myNumberOfPoints = myNumberOfPoints + 1.0
      myPathIter = myPathLength / myNumberOfPoints
      
      myHandleIter = myPathIter / (myNumberOfPoints * 2.0)
      myHandleIter = ceil (myHandleIter)
         
      print "\n##############################################"
      print "Curve name: %s " % myCurveName
      print "Curve data: %s " % myCurveData
      print "Ipo curves: %s " % myIPOCurveSet
      print "Ipo length: %s " % myPathLength
      print "Path iteration constant: %s" % myPathIter
      print "##############################################\n"   

      # Create LocX, LocY, and LocZ Ipo curves in our new Curve Object
      # and store them so we can access them later
      myIPOCurveLoc_X = myIPOCurveSet.addCurve('dLocX')
      myIPOCurveLoc_Y = myIPOCurveSet.addCurve('dLocY')
      myIPOCurveLoc_Z = myIPOCurveSet.addCurve('dLocZ')
      myIPOCurveRot_X = myIPOCurveSet.addCurve('dRotX')
      myIPOCurveRot_Y = myIPOCurveSet.addCurve('dRotY')
      myIPOCurveRot_Z = myIPOCurveSet.addCurve('dRotZ')
      #myIPOCurveSpeed = myIPOCurveSet.addCurve('Time')
         
      myBezPointNumber = 1
      myCurrentPathLen = 1
      for nCurvePoints in myCurvePoints:
         
         # Copy the first set of co-ordinates
         # ready for a isCyclic condtion
         if myBezPointNumber == 0:
            myFirstCoods = nCurvePoints
         
         # Apparently  BezTriple outputs 9 floats for each handle/knot in 3D space
         # so print out each float value
         print"\n##############################################"
         print"Bezier point number: %s" % myBezPointNumber
         print"Out of a total: %s" % myNumberOfPoints
         print"Current iteration at frame: %s\n" %  myCurrentPathLen
         print"H1x: %s " % nCurvePoints.vec[0][0]
         print"H1y: %s " % nCurvePoints.vec[0][1]
         print"H1z: %s " % nCurvePoints.vec[0][2]
         print"\n"
         print"Px: %s " % nCurvePoints.vec[1][0]
         print"Py: %s " % nCurvePoints.vec[1][1]
         print"Pz: %s " % nCurvePoints.vec[1][2]
         print"\n"
         print"H2x: %s " % nCurvePoints.vec[2][0]
         print"H2y: %s " % nCurvePoints.vec[2][1]
         print"H2z: %s " % nCurvePoints.vec[2][2]
         print"##############################################\n"
   
         # Store all bezier points
         H1_X = nCurvePoints.vec[0][0]
         H1_Y = nCurvePoints.vec[0][0]
         H1_Z = nCurvePoints.vec[0][2]
         P_X = nCurvePoints.vec[1][0]
         P_Y = nCurvePoints.vec[1][1]
         P_Z = nCurvePoints.vec[1][2]
         H2_X = nCurvePoints.vec[2][0]
         H2_Y = nCurvePoints.vec[2][1]
         H2_Z = nCurvePoints.vec[2][2]
      
         # make 3 BezTriples, and mke sure their handles are FREE
         # pass eacch of these 3 new BezTriples for X, Y and Z
         # to their relevant IPO's
         myIPOCurveX = Blender.BezTriple.New(myCurrentPathLen - myHandleIter, H1_X, 0, myCurrentPathLen, P_X, 0, myCurrentPathLen + myHandleIter, H2_X, 0)
         myIPOCurveY = Blender.BezTriple.New(myCurrentPathLen - myHandleIter, H1_Y, 0, myCurrentPathLen, P_Y, 0, myCurrentPathLen + myHandleIter, H2_Y, 0)
         myIPOCurveZ = Blender.BezTriple.New(myCurrentPathLen - myHandleIter, H1_Z, 0, myCurrentPathLen, P_Z, 0, myCurrentPathLen + myHandleIter, H2_Z, 0)
         
         myIPOCurveX.handleTypes = (Blender.BezTriple.HandleTypes.FREE, Blender.BezTriple.HandleTypes.FREE)
         myIPOCurveY.handleTypes = (Blender.BezTriple.HandleTypes.FREE, Blender.BezTriple.HandleTypes.FREE)
         myIPOCurveZ.handleTypes = (Blender.BezTriple.HandleTypes.FREE, Blender.BezTriple.HandleTypes.FREE)
         
         myIPOCurveLoc_X.append(myIPOCurveX)
         myIPOCurveLoc_Y.append(myIPOCurveY)
         myIPOCurveLoc_Z.append(myIPOCurveZ)
         
         #myIPOCurveSpeed.append((myCurrentPathLen, 30))
         # Must be done last in the for loop
         myBezPointNumber = myBezPointNumber + 1
         myCurrentPathLen = myPathIter * myBezPointNumber
   
         
   
         myIPOCurveLoc_X.recalc()
         myIPOCurveLoc_Y.recalc()
         myIPOCurveLoc_Z.recalc()
   
   else:
      Blender.Draw.PupMenu("Curve is not a Path")
      print"   -> Curve flag bit 3 at 0x00001000 is NOT set, value is: %x " % (myCurveFlag1 and 0x08)       

else:
   Blender.Draw.PupMenu("Object is not a curve")
   print"   -> Object is a %s" % myObjectType


[Grogyan]

I have found the problem, and its not with my code, phew!

The problem lies withing the API when appending a BexTriple to the IPO widow, for some reason it would use the value of the X coordinate as the Y coordinate of the FIRST handle of each curve in the curve object

Confusing I know, and I really only found it today

Now I just have to wait for a fix then download the automated build of Blender when the fix is done

So now I stand on the edge of a very deep crevice, bezier rotation curves, uuuugh

[Grogyan]

I've fixed the problem - small typo in my code been there for so long that I had completely missed hundreds of times

So while the script now animates objects EXACTLY round a path, there is one small problem, that i'm hoping Lontahv will be able to help me with.
PyPrp is coded with IPO curves for global world space, where as the script I have written outputs IPO curves based on the local space of the original curve object.

After that, i'll proceed with the rotation curves, though I don't know how hard that will be.
I'm thinking that I an do it by standard Trig on the current and next points in a segment.

It will be by far the hardest, no matter which way i'll do it