def addValueAtFrame(xtrack, ytrack, ztrack, XYFrameNum, ZFrameNum, fps,
valueVec):
# linear interpolation
animation_interpolation_val = 465001092
# Add a key to each CubeSat linear position tracks
xtrack = xtrack.GetCurve()
xkey = xtrack.AddKey(c4d.BaseTime(XYFrameNum, fps))['key']
xkey.SetValue(xtrack, valueVec[0])
# set the track position variation to linear
c4d.CallCommand(animation_interpolation_val)
ytrack = ytrack.GetCurve()
ykey = ytrack.AddKey(c4d.BaseTime(XYFrameNum, fps))['key']
ykey.SetValue(ytrack, valueVec[1])
# set the track position variation to linear
c4d.CallCommand(animation_interpolation_val)
ztrack = ztrack.GetCurve()
zkey = ztrack.AddKey(c4d.BaseTime(ZFrameNum, fps))['key']
zkey.SetValue(ztrack, valueVec[2])
# set the track position variation to linear
c4d.CallCommand(animation_interpolation_val)
def main():
c4d.StopAllThreads()
doc = c4d.documents.GetActiveDocument()
fps = doc.GetFps()
fromTime = doc.GetMinTime().GetFrame(fps)
toTime = doc.GetMaxTime().GetFrame(fps)
animLength = toTime - fromTime + 1
filePath = c4d.storage.SaveDialog()
filePath, objName = os.path.split(filePath)
objName = objName + "_"
filePath = filePath + "\\"
for f in range(0, animLength):
doc.SetTime(c4d.BaseTime(fromTime, fps) + c4d.BaseTime(f, fps))
c4d.EventAdd(c4d.EVENT_FORCEREDRAW)
c4d.DrawViews(c4d.DRAWFLAGS_FORCEFULLREDRAW)
c4d.StatusSetText("Exporting " + str(f) + " of " + str(animLength))
c4d.StatusSetBar(100.0 * f / animLength)
c4d.CallCommand(16768, 16768)
c4d.CallCommand(100004794, 100004794)
c4d.CallCommand(100004787)
fileName = filePath + objName + str(f) + ".obj"
savingresult = c4d.documents.SaveDocument(doc, fileName,
c4d.SAVEDOCUMENTFLAGS_0,
c4d.FORMAT_OBJ2EXPORT)
c4d.CallCommand(12105, 12105)
c4d.CallCommand(12105, 12105)
c4d.CallCommand(12105, 12105)
c4d.StatusClear()
gui.MessageDialog('Exporting to' + filePath + ' done')
def main():
random.seed(24)
PS = doc.GetParticleSystem()
cframe = doc.GetTime().GetFrame(doc.GetFps()) #10->300,1->30
N = PS.NumParticles()
if cframe == 0:
ids = range(N)
life = [c4d.BaseTime(10.0)] * N
map(PS.SetLife, ids, life)
else:
#set default ages for everyone
ids = range(N)
dval = 0.
ages = [c4d.BaseTime(dval)] * N
map(PS.SetAge, ids, ages)
#randomly change life on a pacth, always same patch?
ids = range(int(N / 3), int(N / 2))
nN = int(len(ids))
val = cframe / 30.0 #random.random()*10.0
ages = [c4d.BaseTime(val)] * nN
map(PS.SetAge, ids, ages)
ids = range(int(N / 2), int(N))
nN = int(len(ids))
val = cframe / 60.0 #random.random()*10.0
ages = [c4d.BaseTime(val)] * nN
map(PS.SetAge, ids, ages)
def SequenceTracks(keyMod):
tracks = GetTracks() # Get selected tracks
prevTrack = tracks[0] # Get the first selected track
prevOut = prevTrack.GetCurve().GetEndTime() # Get out time
if keyMod == "None":
gap = c4d.BaseTime(1.0 / doc.GetFps())
elif keyMod == "Shift":
inp = gui.InputDialog('Gap') # Store user given value
gap = c4d.BaseTime(1.0 / doc.GetFps() * float(inp)) # Gap
elif keyMod == "Ctrl":
tracks.reverse()
gap = c4d.BaseTime(1.0 / doc.GetFps())
elif keyMod == "Ctrl+Shift":
tracks.reverse()
inp = gui.InputDialog('Gap') # Store user given value
gap = c4d.BaseTime(1.0 / doc.GetFps() * float(inp)) # Gap
for i in range(1, len(tracks)): # Iterate through tracks
curve = tracks[i].GetCurve() # Get current curve
startTime = curve.GetStartTime()
endTime = curve.GetEndTime()
sub = prevOut - (startTime - gap) # Get time subtraction
if sub.Get() < 0: # If subtraction is negative
sub = (startTime - gap) - prevOut # New subtraction
for i in range(0, sub.GetFrame(doc.GetFps())):
MoveKeys(curve, -1) # Move keys one frame to the left
else: # Otherwise
for i in range(0, sub.GetFrame(doc.GetFps())):
MoveKeys(curve, 1) # Move keys one frame to the right
prevOut = curve.GetEndTime() # Get new out time
def main():
# Creates the object in memory
obj = c4d.BaseObject(c4d.Ocube)
# Creates the track in memory. Defined by it's DescID
trackY = c4d.CTrack(obj, c4d.DescID(c4d.DescLevel(c4d.ID_BASEOBJECT_POSITION, c4d.DTYPE_VECTOR, 0),
c4d.DescLevel(c4d.VECTOR_Y, c4d.DTYPE_REAL, 0)))
# Gets curves for the track
curveY = trackY.GetCurve()
# Creates a key in the Y curve with value 0 at 0 frame with a spline interpolation
keyA, keyAIndex = CreateKey(curveY, c4d.BaseTime(0), value=0, interpolation=c4d.CINTERPOLATION_SPLINE)
# Retrieves time at frame 10
keyBTime = c4d.BaseTime(10, doc.GetFps())
# Creates another key in the Y curve with value 100 at 10 frame with a spline interpolation
keyB, keyBIndex = CreateKey(curveY, keyBTime, value=100, interpolation=c4d.CINTERPOLATION_SPLINE)
# Inserts the track containing the Y curve to the object
obj.InsertTrackSorted(trackY)
# Inserts the object in document
doc.InsertObject(obj)
# Pushes an update event to Cinema 4D
c4d.EventAdd()
def push_key(curve, key, key_data):
key.SetTime(curve, c4d.BaseTime(key_data[0]))
key.SetValue(curve, key_data[1])
key.SetInterpolation(curve, INTERPOLATION[key_data[6]])
key.SetTimeLeft(curve, c4d.BaseTime(key_data[2]))
key.SetTimeRight(curve, c4d.BaseTime(key_data[4]))
key.SetValueLeft(curve, key_data[3])
key.SetValueRight(curve, key_data[5])
return key
def new_rig(obj, cachetype):
#create a Python tag and attach it to the selected tag's object
pythontag = c4d.BaseTag(c4d.Tpython)
#set the Python code inside the tag
pythontag[
c4d.TPYTHON_CODE] = copyright + pythontagcode + pythontagcode_dict[
cachetype]
#add userdata to the Python tag
userdata = c4d.GetCustomDataTypeDefault(c4d.DTYPE_REAL)
userdata[c4d.DESC_NAME] = "Frame"
pythontag.AddUserData(userdata)
pythontag[c4d.ID_USERDATA, 1] = 0.0
#add an animation track to the userdata we just created
track = c4d.CTrack(
pythontag,
c4d.DescID(c4d.DescLevel(c4d.ID_USERDATA, c4d.DTYPE_SUBCONTAINER, 0),
c4d.DescLevel(1, c4d.DTYPE_REAL, 0)))
pythontag.InsertTrackSorted(track)
#get the curve of our new track (we'll attach keyframes to this curve)
curve = track.GetCurve()
#make some keyframes, setting their time, value and curve
key1 = c4d.CKey()
key1.SetTime(curve, doc.GetMinTime())
key1.SetValue(curve, doc.GetMinTime().Get() * doc.GetFps())
key1.SetTimeRight(curve, c4d.BaseTime(0.5))
key2 = c4d.CKey()
key2.SetTime(curve, doc.GetMaxTime())
key2.SetValue(curve, doc.GetMaxTime().Get() * doc.GetFps())
key2.SetTimeLeft(curve, c4d.BaseTime(-0.5))
#add the keyframes to the curve
curve.InsertKey(key1)
curve.InsertKey(key2)
#set the Python tag's priority
priority = c4d.PriorityData()
priority.SetPriorityValue(c4d.PRIORITYVALUE_MODE, c4d.CYCLE_GENERATORS)
priority.SetPriorityValue(c4d.PRIORITYVALUE_PRIORITY, -1)
pythontag[c4d.EXPRESSION_PRIORITY] = priority
#add the Python tag to the selected object, and add an undo
doc.StartUndo()
obj.InsertTag(pythontag)
doc.AddUndo(c4d.UNDOTYPE_NEW, pythontag)
doc.EndUndo()
c4d.EventAdd(c4d.EVENT_FORCEREDRAW)
print "Cache retimer successfully added to " + obj.GetName() + "!"
def SetKeys(keyData, keyMod):
tracks = GetKeys(keyMod) # Get selected keys
for track in tracks:
keys = track[1]
for i, k in enumerate(keys): # Iterate through tracks
diff = 1.0
if i < len(keyData) - 1: # Not the last key
valueDiffRef = float(keyData[i]['value']) - float(
keyData[i + 1]['value'])
valueDiffOrig = k.GetValue() - k.GetNext().GetValue()
if valueDiffRef != 0:
if valueDiffOrig != 0:
diff = valueDiffOrig / valueDiffRef # Fixed
if i == len(keyData) - 1: # The last key
valueDiffRef = float(keyData[i - 1]['value']) - float(
keyData[i]['value'])
valueDiffOrig = k.GetPred().GetValue() - k.GetValue()
if valueDiffRef != 0:
if valueDiffOrig != 0:
diff = valueDiffOrig / valueDiffRef # Fixed
print "end diff " + str(diff)
leftValue = float(keyData[i]['leftvalue']) * diff
rightValue = float(keyData[i]['rightvalue']) * diff
leftTime = c4d.BaseTime(float(keyData[i]['lefttime']))
rightTime = c4d.BaseTime(float(keyData[i]['righttime']))
doc.AddUndo(c4d.UNDOTYPE_CHANGE, k) # Record undo
curve = k.GetCurve()
k.SetInterpolation(curve, c4d.CINTERPOLATION_SPLINE)
k.ChangeNBit(c4d.NBIT_CKEY_AUTO,
CheckBit(keyData[i]['autotan'])) # Auto Tangents
k.SetAutomaticTangentMode(curve, int(keyData[i]['slope'])) # Slope
k.ChangeNBit(c4d.NBIT_CKEY_CLAMP,
CheckBit(keyData[i]['clamp'])) # Clamp
k.ChangeNBit(c4d.NBIT_CKEY_REMOVEOVERSHOOT,
CheckBit(
keyData[i]['overshoot'])) # Remove Overshooting
k.ChangeNBit(c4d.NBIT_CKEY_WEIGHTEDTANGENT,
CheckBit(keyData[i]['weighted'])) # Weighted Tangent
k.ChangeNBit(
c4d.NBIT_CKEY_LOCK_O,
CheckBit(keyData[i]['locktanangles'])) # Lock Tangent Angles
k.ChangeNBit(
c4d.NBIT_CKEY_LOCK_L,
CheckBit(keyData[i]['locktanlengths'])) # Lock Tangent Lengths
k.ChangeNBit(c4d.NBIT_CKEY_KEEPVISUALANGLE,
CheckBit(
keyData[i]['keepvisangle'])) # Keep Visual Angle
k.SetValueLeft(curve, leftValue)
k.SetValueRight(curve, rightValue)
k.SetTimeLeft(curve, leftTime)
k.SetTimeRight(curve, rightTime)
def main():
# Retrieves the FPS of the document
fps = doc.GetFps()
# Creates a first marker
firstMarker = c4d.documents.AddMarker(doc, None, c4d.BaseTime(30, fps), "First Marker")
# Creates a second marker with a duration of 5 frame
secondMarker = c4d.documents.AddMarker(doc, None, c4d.BaseTime(27, fps), "Second Marker")
secondMarker[c4d.TLMARKER_LENGTH] = c4d.BaseTime(5, fps)
# Pushes an update event to Cinema 4D
c4d.EventAdd()
def Execute(self, tag, doc, op, bt, priority, flags):
dname = doc.GetDocumentName()
if hasattr(c4d, 'mv'):
if c4d.mv.has_key(dname):
self.epmv = c4d.mv[dname]
self.mv = self.epmv.mv
else:
self.epmv = None
self.mv = None
#print "rexectute", self.mv
else:
self.epmv = None
self.mv = None
sel = doc.GetSelection()
if hasattr(self.mv, 'art'):
vp = doc.GetActiveBaseDraw()
self.epmv.helper.updateImage(self.mv, viewport=vp)
if self.epmv.synchro_timeline:
traj = self.epmv.gui.current_traj
t = c4d.BaseTime()
fps = doc.GetFps()
#getCurrent time
frame = doc.GetTime().GetFrame(fps)
st, ft = self.epmv.synchro_ratio
if (frame % ft) == 0:
step = frame * st
self.epmv.helper.updateData(self.epmv, traj, step)
# self.epmv.gui.updateViewer()
else:
self.epmv.helper.updateCoordFromObj(self.mv, sel, debug=True)
#this update should recognise the displayed object and update consequently
#like update bond geometry,loft ss, constraint the move ? calcul_energy?
return c4d.EXECUTIONRESULT_OK
def main():
path = s.LoadDialog(c4d.FILESELECTTYPE_ANYTHING, "Sound file", c4d.FILESELECT_LOAD)
folderPath, fileName = os.path.split(path)
doc = c4d.documents.GetActiveDocument() # Get active Cinema 4D document
time = c4d.BaseTime(doc.GetTime().Get()) # Get current time
null = c4d.BaseObject(c4d.Onull) # Initialize a null
null.SetName("Sound: "+fileName) # Set name
null[c4d.NULLOBJECT_DISPLAY] = 14 # Set 'Display' to 'None'
null[c4d.ID_BASELIST_ICON_FILE] = "440000255" # Set icon
null[c4d.ID_BASELIST_ICON_COLORIZE_MODE] = 2 # Set 'Icon Color' to 'Display Color'
null[c4d.ID_BASEOBJECT_USECOLOR] = 2 # Set 'Display Color' to 'On'
null[c4d.ID_BASEOBJECT_COLOR] = c4d.Vector(140.0/255.0, 203.0/255.0, 1.0)
null[c4d.ID_BASELIST_ICON_COLOR] = c4d.Vector(140.0/255.0, 203.0/255.0, 1.0)
doc.InsertObject(null) # Insert null to the document
desc = c4d.DescID(c4d.DescLevel(c4d.CTsound, c4d.CTsound, 0))
SoundTrack = c4d.CTrack(null, desc) # Initialize a sound Track
null.InsertTrackSorted(SoundTrack) # Insert the sound track to the object
SoundTrack[c4d.CID_SOUND_NAME] = path # Set sou
SoundTrack[c4d.CID_SOUND_START] = time
c4d.EventAdd()
def main():
global tp
global doc
global frame
global bpos
global bvel
frame = doc.GetTime().GetFrame(doc.GetFps())
if frame==0:
tp.FreeAllParticles()
tp.AllocParticles(boids_number)
lt = c4d.BaseTime(1000)
bpos = []
bvel = []
for i in tp.GetParticles():
tp.SetLife(i, lt)
bpos.append(tp.Position(i))
bvel.append(tp.Velocity(i))
moveboids(i)
set_target()
movetarget()
def resetAllObjectsAtBeginning(objList=None):
for curObj in objList:
#if curObj.GetTag(c4d.Tweights):#
#c4d.documents.GetActiveDocument().SetActiveObject(curObj)
#c4d.CallCommand(1019937)
#c4d.DrawViews( c4d.DA_ONLY_ACTIVE_VIEW|c4d.DA_NO_THREAD|c4d.DA_NO_REDUCTION|c4d.DA_STATICBREAK )
#c4d.GeSyncMessage(c4d.EVMSG_TIMECHANGED)
#c4d.documents.GetActiveDocument().SetTime(c4d.documents.GetActiveDocument().GetTime())
#c4d.EventAdd(c4d.EVENT_ANIMATE)
if curObj.GetTag(c4d.Tposemorph):# reset morphtags
all_tags=curObj.GetTags()#get all tags applied to object
for morphtag in all_tags:#do for each tag:
if morphtag.GetType()==c4d.Tposemorph:#do if the tag is a morphtag
if morphtag.GetMode()==1:#do if the tag is in animation-mode:
exportData.doc.SetTime(c4d.BaseTime(0, exportData.doc.GetFps()))
c4d.DrawViews( c4d.DA_ONLY_ACTIVE_VIEW|c4d.DA_NO_THREAD|c4d.DA_NO_REDUCTION|c4d.DA_STATICBREAK )
c4d.GeSyncMessage(c4d.EVMSG_TIMECHANGED)
exportData.doc.SetTime(exportData.doc.GetTime())
c4d.EventAdd(c4d.EVENT_ANIMATE)
for track in morphtag.GetCTracks():
curve = track.GetCurve()
if curve.GetKeyCount()==0:
pass#print "skipped morphpose"
if curve.GetKeyCount()>0:
curve.GetKey(0).SetValue(curve,0.0)
resetAllObjectsAtBeginning(curObj.GetChildren())
def Bake(source, target):
""" Bake function """
doc = c4d.documents.GetActiveDocument() # Get active Cinema 4D document
fps = doc.GetFps() # Get Frame Rate
startFrame = doc.GetLoopMinTime().GetFrame(fps) # Get first frame of Preview Range
endFrame = doc.GetLoopMaxTime().GetFrame(fps) # Get last frame of Preview Range
desc = c4d.DescID(c4d.DescLevel(c4d.CTpla, c4d.CTpla, 0))
PLAtrack = c4d.CTrack(target, desc) # Initialize a PLA track
target.InsertTrackSorted(PLAtrack) # Insert PLA track to the object
curve = PLAtrack.GetCurve() # Get Curve of the CTrack
for i in range(startFrame, endFrame+1): # Iterate through Preview Range
SetCurrentFrame(i, doc) # Set current frame
frame = doc.GetTime().GetFrame(fps) # Get current frame
points = source.GetAllPoints()
#key.SetValue(curve, value)
#key.SetGeData(curve, value) # Keyframe value needs to be set with SetGeData
currentTime = c4d.BaseTime(frame, fps) # Get current time
#points = source.GetAllPoints()
key = curve.AddKey(currentTime)["key"]
target.SetAllPoints(points)
target.Message(c4d.MSG_UPDATE)
PLAtrack.FillKey(doc, target, key)
def _goToFrame(self, frame):
time = c4d.BaseTime(frame, self.fps)
self.doc.SetTime(time)
self.doc.ExecutePasses(
None, True, True, True,
c4d.BUILDFLAGS_0) #try BUILDFLAGS_INTERNALRENDERER
c4d.GeSyncMessage(c4d.EVMSG_TIMECHANGED) #update timeline
def SetCurrentFrame(frame, doc):
""" Changes editor's current frame to """
doc.SetTime(c4d.BaseTime(float(frame)/doc.GetFps())) # Set current time to given frame
doc.ExecutePasses(None, True, True, True, 0) # Animate the current frame of the document
c4d.GeSyncMessage(c4d.EVMSG_TIMECHANGED) # Send a synchronous event message that time has changed
return
def main():
fps = doc.GetFps() #get fps number
frame = 0 #set the start frame
maxFrame = doc.GetLoopMaxTime().GetFrame(fps) #get all frame
#For each frame
while frame != maxFrame + 1:
doc.SetTime(c4d.BaseTime(frame, fps)) #change time
c4d.EventAdd() #Update scene
c4d.DrawViews(c4d.DRAWFLAGS_FORCEFULLREDRAW) #ask to redraw the view
c4d.GeSyncMessage(c4d.EVMSG_TIMECHANGED
) #send message to c4d we have change the time
camera = doc.SearchObject("Camera.1")
xform = camera.GetMg()
pos = xform.Mul(c4d.Vector(0, 0, 0))
target = xform.Mul(c4d.Vector(0, 0, 1))
# pos = camera.GetAbsPos()
# rotationmatrix = c4d.utils.HPBToMatrix(camera.GetAbsRot())
# target = pos + rotationmatrix.MulV(c4d.Vector(0,0,1))
print(str(pos))
print(str(target))
# rotate (0,0,1) by GetAbsRot to get a target point that the camera is pointing at.
frame += 1 #define the next frame
c4d.EventAdd() #Update scene
def set_matrix(self, matrix, frame):
"""
:type frame: int
:param frame:
:type: Matrix
:param matrix:
:return:
"""
transform = [
matrix.get().off,
c4d.utils.MatrixToHPB(matrix.get(),
self.__object.GetRotationOrder()),
matrix.get().GetScale()
]
for i_type in range(3):
for i_dir in range(3):
desc_id = c4d.DescID(
c4d.DescLevel(ID_TYPES[i_type], c4d.DTYPE_VECTOR, 0),
c4d.DescLevel(ID_DIRS[i_dir], c4d.DTYPE_REAL, 0))
track = self.__object.FindCTrack(desc_id)
if track is None:
track = c4d.CTrack(self.__object, desc_id)
self.__object.InsertTrackSorted(track)
curve = track.GetCurve()
key = curve.AddKey(c4d.BaseTime(frame, get_fps()))['key']
if key is None:
print('Error: Failed to add keys!')
continue
track.FillKey(context_doc, self.__object, key)
key.SetValue(curve, transform[i_type][i_dir])
def main():
# Saves current time
ctime = doc.GetTime()
# Retrieves BaseTime of frame 5, 20
start = 5
end = 20
# Loops through the frames
for frame in range(start, end + 1):
# Sets the Status Bar
c4d.StatusSetBar(100.0 * float(frame - start) / float(end - start))
# Changes the time of the document
doc.SetTime(c4d.BaseTime(frame, doc.GetFps()))
# Updates timeline
c4d.GeSyncMessage(c4d.EVMSG_TIMECHANGED)
# Redraws the viewport and regenerate the cache object
c4d.DrawViews(c4d.DRAWFLAGS_ONLY_ACTIVE_VIEW | c4d.DRAWFLAGS_NO_THREAD
| c4d.DRAWFLAGS_STATICBREAK)
# Do the stuff for each frame here you may be interested in BaseDocument.Polygonize()
print("Frame {0}".format(frame))
# Sets the time back to the original time.
doc.SetTime(ctime)
# Pushes an update event to Cinema 4D
c4d.EventAdd(c4d.EVENT_ANIMATE)
# Clears the Status Bar
c4d.StatusClear()
def MoveKeys(curve, shift=1):
shift = c4d.BaseTime(
(1.0 / doc.GetFps()) * shift) # Get one frame in BaseTime
keyCount = curve.GetKeyCount() # Get count of keyframes
for i in range(0, keyCount): # Iterate through keyframe indicies
oldTime = curve.GetKey(i).GetTime() # Get keyframe's current time
newTime = oldTime + shift
curve.MoveKey(newTime, i, None, True, False) # Move keyframe
def timeadvance(Advance): # Define a function called "timeadvance", which will act as a container for the script to be implemented in other scripts.
CurrentTime = doc.GetTime() # Define CurrentTime to look at the current time in the document
CurrentFrame = CurrentTime.GetFrame(doc.GetFps()) # Define CurrentFrame to calculate the current frame number based on the frame rate of the document
FPS = doc[c4d.DOCUMENT_FPS] # Define FPS to look at the current document's fps setting
NewFrame = CurrentFrame + Advance # Define NewFrame to add the current frame with the number of frames to advance forward
Time = c4d.BaseTime(NewFrame,FPS) # Define Time to find the new frame location based on the combination of the current frame, the number of frames to advance, and the fps setting of the document
doc.SetTime(Time) # Move the playhead to the newly referenced location in the timeline
c4d.EventAdd() # Refresh the scene to update the change
def set_frame_range(self, in_frame=None, out_frame=None, **kwargs):
"""
set_frame_range will set the frame range using `in_frame` and `out_frame`
:param int in_frame: in_frame for the current context
(e.g. the current shot, current asset etc)
:param int out_frame: out_frame for the current context
(e.g. the current shot, current asset etc)
"""
doc = c4d.documents.GetActiveDocument()
fps = doc[c4d.DOCUMENT_FPS]
head_in_frame = kwargs.get('head_in_frame')
tail_out_frame = kwargs.get('tail_out_frame')
if head_in_frame:
# Set Handles if exists
doc[c4d.DOCUMENT_MINTIME] = c4d.BaseTime(head_in_frame, fps)
else:
doc[c4d.DOCUMENT_MINTIME] = c4d.BaseTime(in_frame, fps)
if tail_out_frame:
# Set Handles if exists
doc[c4d.DOCUMENT_MAXTIME] = c4d.BaseTime(tail_out_frame, fps)
else:
doc[c4d.DOCUMENT_MAXTIME] = c4d.BaseTime(out_frame, fps)
# Set Project Preview MIN/MAX Time
doc[c4d.DOCUMENT_LOOPMINTIME] = c4d.BaseTime(in_frame, fps)
doc[c4d.DOCUMENT_LOOPMAXTIME] = c4d.BaseTime(out_frame, fps)
doc[c4d.DOCUMENT_LOOPMINTIME] = c4d.BaseTime(in_frame, fps)
return True
def main():
c4d.StopAllThreads()
doc = c4d.documents.GetActiveDocument()
fps = doc.GetFps()
fromTime = doc.GetMinTime().GetFrame(fps)
toTime = doc.GetMaxTime().GetFrame(fps)
animLength = toTime - fromTime + 1
filePath = c4d.storage.SaveDialog()
filePath, objName = os.path.split(filePath)
objName = objName + "_"
filePath = filePath + "\\"
for f in range(0,animLength):
c4d.EventAdd(c4d.EVENT_FORCEREDRAW)
c4d.DrawViews(c4d.DRAWFLAGS_FORCEFULLREDRAW)
c4d.StatusSetText("Exporting " + str(f) + " of " + str(animLength))
c4d.StatusSetBar(100.0*f/animLength)
objs = doc.GetActiveObjects(c4d.GETACTIVEOBJECTFLAGS_CHILDREN)
# Get a fresh, temporary document with only the selected objects
docTemp = c4d.documents.IsolateObjects(doc, objs)
docTemp.SetTime(c4d.BaseTime(fromTime,fps) + c4d.BaseTime(f,fps))
if docTemp == None:
return
# Set project scale
unitScale = c4d.UnitScaleData()
unitScale.SetUnitScale(1.0, c4d.DOCUMENT_UNIT_M)
bc = c4d.BaseContainer()
bc[c4d.DOCUMENT_DOCUNIT] = unitScale
docTemp.SetDocumentData(c4d. DOCUMENTSETTINGS_DOCUMENT, bc)
fileName = filePath+objName+str(f)+".obj"
savingresult = c4d.documents.SaveDocument(docTemp,fileName,c4d.SAVEDOCUMENTFLAGS_0,c4d.FORMAT_OBJ2EXPORT)
c4d.documents.KillDocument(docTemp)
c4d.StatusClear()
gui.MessageDialog( 'Exporting to'+filePath+' done' )
def Bake(source, target):
""" Bake function """
doc = c4d.documents.GetActiveDocument() # Get active Cinema 4D document
fps = doc.GetFps() # Get Frame Rate
startFrame = doc.GetLoopMinTime().GetFrame(
fps) # Get first frame of Preview Range
endFrame = doc.GetLoopMaxTime().GetFrame(
fps) # Get last frame of Preview Range
for i in range(startFrame, endFrame + 1): # Iterate through Preview Range
SetCurrentFrame(i, doc) # Set current frame
frame = doc.GetTime().GetFrame(fps) # Get current frame
dataVault = [
[903, c4d.DTYPE_REAL, 1000, c4d.DTYPE_VECTOR],
[903, c4d.DTYPE_REAL, 1001, c4d.DTYPE_VECTOR],
[903, c4d.DTYPE_REAL, 1002, c4d.DTYPE_VECTOR], # Position
[904, c4d.DTYPE_REAL, 1000, c4d.DTYPE_VECTOR],
[904, c4d.DTYPE_REAL, 1001, c4d.DTYPE_VECTOR],
[904, c4d.DTYPE_REAL, 1002, c4d.DTYPE_VECTOR], # Rotation
[905, c4d.DTYPE_REAL, 1000, c4d.DTYPE_VECTOR],
[905, c4d.DTYPE_REAL, 1001, c4d.DTYPE_VECTOR],
[905, c4d.DTYPE_REAL, 1002, c4d.DTYPE_VECTOR], # Scale
]
for data in dataVault: # Iterate through data vault
if len(data) == 2: # Float
desc = c4d.DescID(c4d.DescLevel(data[0], data[1], 0))
value = source[data[0]]
if len(data) == 4: # Vector
desc = c4d.DescID(c4d.DescLevel(data[0], data[3], 0),
c4d.DescLevel(data[2], data[1], 0))
value = source[data[0], data[2]]
track = target.FindCTrack(desc) # Try to find CTrack
if not track: # If CTrack does not exists
track = c4d.CTrack(target, desc) # Initialize CTrack
target.InsertTrackSorted(track) # Insert CTrack to the object
curve = track.GetCurve() # Get Curve of the CTrack
currentTime = c4d.BaseTime(frame, fps) # Get current time
key = curve.AddKey(currentTime)["key"]
track.FillKey(doc, target, key)
if data[1] == c4d.DTYPE_REAL: # Float
key.SetValue(curve, value)
else: # If boolean or integer
key.SetValue(curve, value)
key.SetGeData(
curve,
value) # Keyframe value needs to be set with SetGeData
def set_key(curve, key_data):
key = curve.FindKey(c4d.BaseTime(
key_data[0])) # Check for an existing keyframe
if key:
key = push_key(curve, key["key"], key_data)
new = False
else:
key = push_key(curve, c4d.CKey(), key_data)
new = True
if new:
curve.InsertKey(key)
c4d.EventAdd()
def gotoframe(
GoToFrame
): # Define a function called "gotoframe", which will act as a container for the script to be implemented in other scripts.
FPS = doc[
c4d.
DOCUMENT_FPS] # Define FPS to look at the current document's fps setting
Time = c4d.BaseTime(
GoToFrame, FPS
) # Define Time to find the new frame location based on the combination of the current frame, the number of frames to advance, and the fps setting of the document
doc.SetTime(
Time
) # Move the playhead to the newly referenced location in the timeline
c4d.EventAdd() # Refresh the scene to update the change
def execute(self,
operation,
head_in_frame=None,
in_frame=None,
out_frame=None,
tail_out_frame=None,
**kwargs):
"""
Main hook entry point
:operation: String
Frame operation to perform
:in_frame: int
in_frame for the current context (e.g. the current shot,
current asset etc)
:out_frame: int
out_frame for the current context (e.g. the current shot,
current asset etc)
:returns: Depends on operation:
'set_frame_range' - Returns if the operation was succesfull
'get_frame_range' - Returns the frame range in the form
(in_frame, out_frame)
"""
doc = c4d.documents.GetActiveDocument()
fps = doc[c4d.DOCUMENT_FPS]
if operation == "get_frame_range":
current_in, current_out = doc[c4d.DOCUMENT_MINTIME].GetFrame(
fps), doc[c4d.DOCUMENT_MAXTIME].GetFrame(fps)
return (current_in, current_out)
elif operation == "set_frame_range":
# Set Project MIN/MAX Time
if head_in_frame:
# Set Handles if exists
doc[c4d.DOCUMENT_MINTIME] = c4d.BaseTime(head_in_frame, fps)
else:
doc[c4d.DOCUMENT_MINTIME] = c4d.BaseTime(in_frame, fps)
if tail_out_frame:
# Set Handles if exists
doc[c4d.DOCUMENT_MAXTIME] = c4d.BaseTime(tail_out_frame, fps)
else:
doc[c4d.DOCUMENT_MAXTIME] = c4d.BaseTime(out_frame, fps)
# Set Project Preview MIN/MAX Time
doc[c4d.DOCUMENT_LOOPMINTIME] = c4d.BaseTime(in_frame, fps)
doc[c4d.DOCUMENT_LOOPMAXTIME] = c4d.BaseTime(out_frame, fps)
doc[c4d.DOCUMENT_LOOPMINTIME] = c4d.BaseTime(in_frame, fps)
return True
def main():
# Saves current time
ctime = doc.GetTime()
# Retrieves BaseTime of frame 5, 20
start = 5
end = 20
# Marks the state of the document as the initial step of our undo process
doc.StartUndo()
# Loops through the frames
for frame in xrange(start, end + 1):
# Changes the time of the document
doc.SetTime(c4d.BaseTime(frame, doc.GetFps()))
# Executes the document, so animation, dynamics, expression are calculated and cached are build accordingly
buildflag = c4d.BUILDFLAGS_NONE if c4d.GetC4DVersion(
) > 20000 else c4d.BUILDFLAGS_0
doc.ExecutePasses(None, True, True, True, buildflag)
# For each cache objects of our current selected object
for obj in DeformedPolygonCacheIterator(op):
# Calculates the position of the point 88 in world space
pos = obj.GetPoint(88) * obj.GetMg()
# Creates a null for each frame and each cache
null = c4d.BaseObject(c4d.Onull)
null.SetName(str(frame))
# Inserts the objects into the documents
doc.AddUndo(c4d.UNDOTYPE_NEW, null)
doc.InsertObject(null)
# Defines the position of the null with the position of the point from the deformed mesh
null.SetAbsPos(pos)
# Sets the time back to the original time.
doc.SetTime(ctime)
# Executes the document, so animation, dynamics, expression are calculated and cached are build accordingly
buildflag = c4d.BUILDFLAGS_NONE if c4d.GetC4DVersion(
) > 20000 else c4d.BUILDFLAGS_0
doc.ExecutePasses(None, True, True, True, buildflag)
# Marks the state of the document as the final step of our undo process
doc.EndUndo()
# Pushes an update event to Cinema 4D
c4d.EventAdd(c4d.EVENT_ANIMATE)
def DistributeKeys(keyMod, step):
tracks = GetKeys() # Get selected keys
for track in tracks:
keys = track[1]
for i, k in enumerate(keys): # Iterate through tracks
curve = k.GetCurve() # Get the curve
firstKeyTime = keys[0].GetTime().Get()
lastKeyTime = keys[-1].GetTime().Get()
if i != 0: # If not first run
if keyMod == "None":
time = firstKeyTime + (lastKeyTime - firstKeyTime) / (len(keys)-1) * (i) # Distribution algorithm
elif keyMod == "Shift":
time = firstKeyTime + float(step)/doc.GetFps() * (i) # Distribution algorithm
index = curve.FindKey(k.GetTime())["idx"] # Get correct index
curve.MoveKey(c4d.BaseTime(time), index, None, True, False) # Move keyframe
def main():
# Which frame to sample. Grab this from the userattr of the tag!
obj = op.GetObject()
pytag = obj.GetFirstTag()
# Gotcha - when rendering tags get reordered and coffee tag might not come first,
# so walk the f*****g linked list until we arrive at the tag
# while(pytag):
# if(instanceof(pytag, c4d.PythonTag)):
# break
# pytag = pytag.GetNext()
# Float attr ID_USERDATA:1
at = 5 #pytag[c4d.ID_USERDATA, 1]
# Sample FPS once
fps = doc.GetFps()
# We need to pass a BaseTime object to the track sampler
# and we create it with the SECONDS
seconds = at / fps
atTime = c4d.BaseTime(seconds)
# Positions
myT = obj.GetFirstCTrack()
posX = myT.GetValue(doc, atTime, fps)
myT = myT.GetNext()
posY = myT.GetValue(doc, atTime, fps)
myT = myT.GetNext()
posZ = myT.GetValue(doc, atTime, fps)
# Then rotations
myT = myT.GetNext()
rotH = myT.GetValue(doc, atTime, fps)
myT = myT.GetNext()
rotP = myT.GetValue(doc, atTime, fps)
myT = myT.GetNext()
rotB = myT.GetValue(doc, atTime, fps)
posVec = c4d.Vector(posX, posY, posZ)
rotVec = c4d.Vector(rotH, rotP, rotB)
obj.SetRelPos(posVec)
obj.SetRelRot(rotVec)
