def createFolderNull(name, selColor, selProtect, selSeparator, selIcon,
selLayer, customColor):
global hierarchy # Access to global dictionary (hierarchy)
doc = c4d.documents.GetActiveDocument() # Get active Cinema 4D document
doc.StartUndo() # Start recording undos
# Separator null code
separatorTagCode = "import c4d\n\
def check(baseWeight, string):\n\
weight = getWeight(string)\n\
pp = True\n\
while weight > baseWeight:\n\
if pp == True:\n\
string = string[:-1]\n\
pp = False\n\
elif pp == False:\n\
string = string[1:]\n\
pp = True\n\
weight = getWeight(string)\n\
return string\n\
\n\
def insert_string(org_string, string, pos=None):\n\
if pos is None:\n\
pos = int(len(org_string) / 2)\n\
return org_string[:pos] + ' ' + string + ' ' + org_string[pos:]\n\
\n\
def getWeight(st): # Unit\n\
weight = 0\n\
for s in st:\n\
if s in 'W@': weight += 3.4\n\
elif s in 'M½': weight += 3.2\n\
elif s in 'OÖÓÒÔmw%&': weight += 3\n\
elif s in 'DGHNQUÚÙÛÜ+=^><~': weight += 2.5\n\
elif s in 'AÁÀÂÅÄCRVbdrghnoöóòôpqu#': weight += 2.4\n\
elif s in '0123456789BEÉÈÊËFKPSTXZaáàäâåeéèëêk$€£¤': weight += 2\n\
elif s in 'LYcsvxyz?*§_': weight += 1.6\n\
elif s in 'Jfrt-\"/\\\\': weight += 1.5\n\
elif s in 'Iijl.,:!|[](){}\\'´` ': weight += 1\n\
return weight\n\
\n\
def main():\n\
width = op.GetObject()[c4d.ID_USERDATA,3]\n\
style = op.GetObject()[c4d.ID_USERDATA,2]\n\
\n\
if style == 0:\n\
char = '-'\n\
baseStr = char*int(width)\n\
elif style == 1:\n\
char = '='\n\
baseStr = char*int(((width+8)/2))\n\
elif style == 2:\n\
char = '_'\n\
baseStr = char*int((width-3))\n\
elif style == 3:\n\
char = '~'\n\
baseStr = char*int(((width+8)/2))\n\
\n\
baseWeight = getWeight(baseStr)\n\
nameStr = op.GetObject()[c4d.ID_USERDATA,1]\n\
newName = check(baseWeight, insert_string(baseStr, nameStr))\n\
op.GetObject().SetName(newName)"
autoLayerTagCode = "import c4d\n\
def FindParent(op, parent):\n\
while op.GetUp() is not None:\n\
op = op.GetUp()\n\
if op == parent:\n\
return op\n\
return op\n\
\n\
def GetNext(op):\n\
if op is None: return None\n\
if op.GetDown():\n\
return op.GetDown()\n\
while not op.GetNext() and op.GetUp():\n\
op = op.GetUp()\n\
return op.GetNext()\n\
\n\
def CollectAllChildren(op):\n\
root = op\n\
if op is None: return\n\
collected = []\n\
while op:\n\
if FindParent(op, root) == root:\n\
collected.append(op)\n\
op = GetNext(op)\n\
return collected\n\
\n\
def main():\n\
obj = op.GetObject()\n\
children = obj.GetChildren()\n\
layer = obj[c4d.ID_LAYER_LINK]\n\
if layer is None: return False\n\
allChildren = CollectAllChildren(obj)\n\
for child in allChildren:\n\
child[c4d.ID_LAYER_LINK] = layer"
# Choose color and icon
randRed = random.random()
randGreen = random.random()
randBlue = random.random()
randomColor = c4d.Vector(randRed, randGreen, randBlue)
colors = {
COL_BLUE:
c4d.Vector(float(3.0 / 255.0), float(169.0 / 255.0),
float(244.0 / 255.0)), # Blue
COL_FUCHIA:
c4d.Vector(float(233.0 / 255.0), float(30.0 / 255.0),
float(99.0 / 255.0)), # Fuchia
COL_GREEN:
c4d.Vector(float(76.0 / 255.0), float(175.0 / 255.0),
float(80.0 / 255.0)), # Green
COL_ORANGE:
c4d.Vector(float(255.0 / 255.0), float(152.0 / 255.0),
float(1.0 / 255.0)), # Orange
COL_SEANCE:
c4d.Vector(float(156.0 / 255.0), float(39.0 / 255.0),
float(176.0 / 255.0)), # Seance
COL_RED:
c4d.Vector(float(244.0 / 255.0), float(67.0 / 255.0),
float(54.0 / 255.0)), # Red
COL_YELLOW:
c4d.Vector(float(255.0 / 255.0), float(193.0 / 255.0),
float(7.0 / 255.0)), # Yellow
COL_DARK:
c4d.Vector(float(40.0 / 255.0), float(40.0 / 255.0),
float(40.0 / 255.0)), # Dark
COL_BRIGHT:
c4d.Vector(float(180.0 / 255.0), float(180.0 / 255.0),
float(180.0 / 255.0)), # Bright
COL_DARKBLUE:
c4d.Vector(float(63.0 / 255.0), float(81.0 / 255.0),
float(181.0 / 255.0)), # Dark Blue
COL_PURPLEHEART:
c4d.Vector(float(103.0 / 255.0), float(58.0 / 255.0),
float(183.0 / 255.0)), # Purple Heart
COL_RANDOM:
randomColor, # Random color
COL_CUSTOM:
customColor # Custom color
}
icons = {
ICO_FOLDER: "1052837", # Folder
ICO_OPEN: "1052838", # Open folder
ICO_CIRCLE: "17106", # Circle
ICO_STAR: "170141", # Star
ICO_NULL: "5140", # Null
ICO_BIN: "12109" # Trash can
}
color = colors[selColor] # Get selected color
icon = icons[selIcon] # Get selected icon
# Null object
c4dver, c4dbuild = GetC4DVersion()
null = c4d.BaseObject(c4d.Onull) # Initialize a null object
null.SetName(name) # Set null object's name
null[c4d.NULLOBJECT_DISPLAY] = 14 # Display: None
if (c4dver > 20):
null[c4d.ID_BASELIST_ICON_FILE] = icon # Folder icon
null[c4d.ID_BASELIST_ICON_COLORIZE_MODE] = 1 # Icon Color: Custom
null[c4d.ID_BASELIST_ICON_COLOR] = color
else:
null[c4d.NULLOBJECT_ICONCOL] = True
null[c4d.ID_BASEOBJECT_USECOLOR] = 2 # Display Color: On
null[c4d.ID_BASEOBJECT_COLOR] = color
# Protection tag
if selProtect == True:
protectionTag = c4d.BaseTag(5629) # Initialize a protection tag
null.InsertTag(protectionTag) # Insert tag to the object
if (selLayer != LAY_NONE):
layerRoot = doc.GetLayerObjectRoot() # Get layer object root
layer = c4d.documents.LayerObject() # Initialize a layer object
layer.SetName(name) # Set layer's name
layer[c4d.ID_LAYER_COLOR] = color # Set layer's color
layer.InsertUnder(layerRoot) # Insert layer to layer root
doc.AddUndo(c4d.UNDOTYPE_NEW,
layer) # Record undo for creating a new layer
null[c4d.ID_LAYER_LINK] = layer # Set layer to the null
# Separator tag
if selSeparator == True:
separatorTag = c4d.BaseTag(1022749) # Initialize a python tag
separatorTag[c4d.TPYTHON_CODE] = separatorTagCode
null.InsertTag(separatorTag) # Put the tag to the null
CreateUserDataString(null, "Name",
name) # Crete user data string input
CreateUserDataCycle(
null, "Style", 0,
['-', '=', '_', '~']) # Create user data cycle data
CreateUserDataInteger(null, "Width",
40) # Create user data integer stuff
separatorTag[c4d.ID_BASELIST_NAME] = "Separator"
# Other stuff
doc.AddUndo(c4d.UNDOTYPE_NEW,
null) # Add undo command for creating a new object
doc.InsertObject(null) # Insert null object to the document
selection = doc.GetActiveObjects(0) # Get active selection
if len(selection) != 0: # If there are selected objects
null.InsertBefore(selection[0]) # Move null
hierarchy = BuildHierarchy() # Build hierarchy
for s in selection: # Iterate through selected objects
doc.AddUndo(c4d.UNDOTYPE_CHANGE, s) # Add undo for changing object
mat = s.GetMg() # Get global matrix
s.InsertUnderLast(null) # Move under the null object
s.SetMg(mat) # Set global matrix
s.DelBit(c4d.BIT_ACTIVE) # Deselect object
# If object doesn't have a layer -> add it
if (selLayer == LAY_ADD):
objectLayer = s.GetLayerObject(doc) # Get object's layer
if objectLayer == None: # If object does not already have a layer
s[c4d.ID_LAYER_LINK] = layer # Set layer to the object
children = FindChildren(s, 0, True) # Get children
for child in children: # Iterate through children
objectLayer = child.GetLayerObject(
doc) # Get object's layer
if objectLayer == None: # If object does not already have a layer
child[c4d.
ID_LAYER_LINK] = layer # Set layer to the object
# Force add layers
if (selLayer == LAY_OVER):
s[c4d.ID_LAYER_LINK] = layer # Set layer to the object
children = FindChildren(s, 0, True)
for child in children:
child[c4d.ID_LAYER_LINK] = layer # Set layer to the object
# Auto layer python tag
if (selLayer == LAY_AUTOTAG):
autoLayerTag = c4d.BaseTag(1022749) # Initialize a python tag
autoLayerTag[c4d.TPYTHON_CODE] = autoLayerTagCode
null.InsertTag(autoLayerTag) # Put the tag to the null
autoLayerTag[c4d.ID_BASELIST_NAME] = "Auto Layer"
null.SetBit(c4d.BIT_ACTIVE) # Select null
doc.EndUndo() # Stop recording undos
c4d.EventAdd() # Refresh Cinema 4D
def main():
# Initialize colors ----------------------
gradients = [
[c4d.Vector(0.2196, 0.2196, 0.2196),
c4d.Vector(0.298, 0.298, 0.298)], # 0 Cinema 4D
[c4d.Vector(0.741, 0.773, 0.776),
c4d.Vector(0.4, 0.494, 0.545)], # 1 Houdini
[c4d.Vector(0.082, 0.086, 0.09),
c4d.Vector(0.525, 0.608, 0.69)], # 2 Maya
[c4d.Vector(0.357, 0.357, 0.357),
c4d.Vector(0.525, 0.525, 0.525)], # 3 Legacy
[c4d.Vector(0.08, 0.08, 0.08),
c4d.Vector(0, 0, 0)]
] # 4 Dark
presets = {
'cinema 4d': gradients[0],
'default': gradients[0],
'new': gradients[0],
'c4d': gradients[0],
'houdini': gradients[1],
'hou': gradients[1],
'maya': gradients[2],
'legacy': gradients[3],
'old': gradients[3],
'dark': gradients[4]
}
keyMod = GetKeyMod() # Get keymodifier
# Action
if keyMod == "None": # If there is no keymodifier
# Get current color
cg1 = c4d.GetViewColor(c4d.VIEWCOLOR_C4DBACKGROUND_GRAD1)
cg2 = c4d.GetViewColor(c4d.VIEWCOLOR_C4DBACKGROUND_GRAD2)
# Temporary change
c4d.SetViewColor(c4d.VIEWCOLOR_C4DBACKGROUND_GRAD1,
presets['houdini'][0])
c4d.SetViewColor(c4d.VIEWCOLOR_C4DBACKGROUND_GRAD2,
presets['houdini'][1])
spot = None
last = False
for i, grad in enumerate(gradients): # Iterate through colors
if (cg1 == grad[0]) and (cg2 == grad[1]):
spot = i
if i == len(gradients) - 1:
last = True
if spot == None:
c4d.SetViewColor(c4d.VIEWCOLOR_C4DBACKGROUND_GRAD1,
gradients[0][0])
c4d.SetViewColor(c4d.VIEWCOLOR_C4DBACKGROUND_GRAD2,
gradients[0][1])
else:
if last == False:
c4d.SetViewColor(c4d.VIEWCOLOR_C4DBACKGROUND_GRAD1,
gradients[spot + 1][0])
c4d.SetViewColor(c4d.VIEWCOLOR_C4DBACKGROUND_GRAD2,
gradients[spot + 1][1])
if last == True:
c4d.SetViewColor(c4d.VIEWCOLOR_C4DBACKGROUND_GRAD1,
gradients[0][0])
c4d.SetViewColor(c4d.VIEWCOLOR_C4DBACKGROUND_GRAD2,
gradients[0][1])
pass
# If shift pressed
if keyMod == "Shift": # New Cinema 4D (Default gradient)
c4d.SetViewColor(c4d.VIEWCOLOR_C4DBACKGROUND_GRAD1,
presets['default'][0])
c4d.SetViewColor(c4d.VIEWCOLOR_C4DBACKGROUND_GRAD2,
presets['default'][1])
# If control pressed
if keyMod == "Ctrl": # Dark theme
c4d.SetViewColor(c4d.VIEWCOLOR_C4DBACKGROUND_GRAD1, presets['dark'][0])
c4d.SetViewColor(c4d.VIEWCOLOR_C4DBACKGROUND_GRAD2, presets['dark'][1])
# If alt pressed, cycle through user gradients
if keyMod == "Alt":
path, fn = os.path.split(__file__) # Get path of the script
data = os.path.join(path, 'AR_ViewportGradients.txt') # data file path
userGradients = []
f = open(data.decode("utf-8")) # Open the file for reading
for line in f: # Iterate through every row
line = line.split(",") # Split by comma
rgbA = HexToRgb(str(line[0])) # Get first rgb
rgbB = HexToRgb(str(line[1])) # Get last rgb
colorA = c4d.Vector(
float(rgbA[0]) / 255,
float(rgbA[1]) / 255,
float(rgbA[2]) / 255) # Convert rgb to c4d form
colorB = c4d.Vector(
float(rgbB[0]) / 255,
float(rgbB[1]) / 255,
float(rgbB[2]) / 255)
userGradients.append([colorA, colorB]) # Add colors to the list
# Figure out current spot, if using user gradients
cg1 = c4d.GetViewColor(c4d.VIEWCOLOR_C4DBACKGROUND_GRAD1)
cg2 = c4d.GetViewColor(c4d.VIEWCOLOR_C4DBACKGROUND_GRAD2)
spot = None
last = False
for i, grad in enumerate(userGradients): # Iterate through colors
if (cg1 == grad[0]) and (cg2 == grad[1]):
spot = i
if i == len(userGradients) - 1:
last = True
if spot == None:
c4d.SetViewColor(c4d.VIEWCOLOR_C4DBACKGROUND_GRAD1,
userGradients[0][0])
c4d.SetViewColor(c4d.VIEWCOLOR_C4DBACKGROUND_GRAD2,
userGradients[0][1])
else:
if last == False:
c4d.SetViewColor(c4d.VIEWCOLOR_C4DBACKGROUND_GRAD1,
userGradients[spot + 1][0])
c4d.SetViewColor(c4d.VIEWCOLOR_C4DBACKGROUND_GRAD2,
userGradients[spot + 1][1])
if last == True:
c4d.SetViewColor(c4d.VIEWCOLOR_C4DBACKGROUND_GRAD1,
userGradients[0][0])
c4d.SetViewColor(c4d.VIEWCOLOR_C4DBACKGROUND_GRAD2,
userGradients[0][1])
f.close() # Close the file
pass
# If alt + control + shift pressed, open dat-file
if keyMod == "Alt+Ctrl+Shift":
path, fn = os.path.split(__file__) # Get path of the script
data = os.path.join(path, 'AR_ViewportGradients.txt') # data file path
storage.GeExecuteFile(
data) # Open data file for editing user gradients
pass
# If alt + control + shift pressed, open dat-file
if keyMod == "Alt+Ctrl":
name = gui.InputDialog("Prestet name", "").lower() # Input dialog
if name is None: return
if name is "": return
c4d.SetViewColor(c4d.VIEWCOLOR_C4DBACKGROUND_GRAD1, presets[name][0])
c4d.SetViewColor(c4d.VIEWCOLOR_C4DBACKGROUND_GRAD2, presets[name][1])
pass
c4d.EventAdd() # Update
import c4d
import requests
from pprint import pprint
CONTAINER_ORIGIN = 1026473
O_DEFAUT = c4d.Vector(2500000.00, 0.0, 1120000.00)
ID_SITG_RASTER_VUE_HAUT_CMD = 1056566
ID_SITG_RASTER_VUE_HAUT_MSGDATA = 1056565
ID_ENABLED = 1
ID_URL_EXTRACT_IMG = 2
ID_LAYERID = 3
ID_BBOX = 4 #bbox sous forme de string
ID_SIZE = 5 #taille de l'image a extraire sous forme de string larg,haut
URL_DEFAULT = 'https://ge.ch/sitgags2/rest/services/RASTER/ORTHOPHOTOS_HISTORIQUES/MapServer'
LAYERID_DAFAULT = 0
BBOX_DEFAULT = '2498577.226970822,1117523.9690901646,2500345.956204395,1119078.0240631981'
# Script state in the menu or the command palette
# Return True or c4d.CMD_ENABLED to enable, False or 0 to disable
# Alternatively return c4d.CMD_ENABLED|c4d.CMD_VALUE to enable and check/mark
#def state():
# return True
class ESRI_api_rest(object):
def __init__(self, url_base):
self.url_base = url_base
def main():
null01name = doc.SearchObject("measure 01 y")
null02name = doc.SearchObject("measure 02 y")
selection = doc.GetActiveObjects(c4d.GETACTIVEOBJECTFLAGS_0)
if null01name == None or null02name == None:
# Create measure NULLs
null01 = c4d.BaseObject(c4d.Onull)
null01[c4d.NULLOBJECT_DISPLAY] = 13
null01[c4d.NULLOBJECT_ORIENTATION] = 3
null01[c4d.ID_BASELIST_NAME] = "measure 01 y"
null01[c4d.ID_BASEOBJECT_USECOLOR] = 2
null01[c4d.ID_BASEOBJECT_COLOR] = c4d.Vector(0, 255, 0)
null02 = c4d.BaseObject(c4d.Onull)
null02[c4d.NULLOBJECT_DISPLAY] = 13
null02[c4d.NULLOBJECT_ORIENTATION] = 3
null02[c4d.ID_BASELIST_NAME] = "measure 02 y"
null02[c4d.ID_BASEOBJECT_USECOLOR] = 2
null02[c4d.ID_BASEOBJECT_COLOR] = c4d.Vector(255, 0, 0)
null02[c4d.ID_BASEOBJECT_REL_POSITION, c4d.VECTOR_Y] = 50
doc.StartUndo()
# Insert NULL objects
doc.AddUndo(c4d.UNDOTYPE_NEW, null01)
doc.InsertObject(null01)
doc.AddUndo(c4d.UNDOTYPE_NEW, null02)
doc.InsertObject(null02)
doc.EndUndo()
# Unfold Hierarchy
null02.InsertUnder(null01)
null01.SetBit(c4d.BIT_ACTIVE)
c4d.CallCommand(100004802) # Unfold Selected
# Create protection tags
pronull02 = null02.MakeTag(c4d.Tprotection)
pronull02[c4d.PROTECTION_P_Y] = False
else:
if len(selection) > 1:
gui.MessageDialog("Select only the image plane.")
elif len(selection) == 1:
if op.GetType() == 5168:
doc.StartUndo()
distance = float(null02name[c4d.ID_BASEOBJECT_REL_POSITION,
c4d.VECTOR_Y])
distanceinput = float(
c4d.gui.InputDialog("Set Distance").replace(',', '.'))
#added by J Garcia
distance = abs(distance)
factor = distance / distanceinput
gui.RenameDialog(factor)
width = op[c4d.PRIM_PLANE_WIDTH]
height = op[c4d.PRIM_PLANE_HEIGHT]
newwidth = width / factor
newheight = height / factor
doc.AddUndo(c4d.UNDOTYPE_CHANGE, op)
op[c4d.PRIM_PLANE_HEIGHT] = newheight
op[c4d.PRIM_PLANE_WIDTH] = newwidth
doc.AddUndo(c4d.UNDOTYPE_CHANGE, null01name)
null01name.SetAbsPos(null01name.GetAbsPos() / factor)
null01name[c4d.NULLOBJECT_RADIUS] = null01name[
c4d.NULLOBJECT_RADIUS] / factor
doc.AddUndo(c4d.UNDOTYPE_CHANGE, null02name)
null02name[c4d.ID_BASEOBJECT_REL_POSITION,
c4d.VECTOR_Y] = distance / factor
null02name[c4d.NULLOBJECT_RADIUS] = null02name[
c4d.NULLOBJECT_RADIUS] / factor
doc.EndUndo()
else:
gui.MessageDialog("Select the image plane.")
else:
gui.MessageDialog("Select the image plane.")
c4d.EventAdd()
def main():
objs = doc.GetActiveObjects(c4d.GETACTIVEOBJECTFLAGS_CHILDREN)
if len(objs) < 2:
print 'Must select main character null, and character body mesh'
return
fchild = objs[0].GetDown()
if not fchild:
return
upperFaceRig = doc.SearchObject('upperFaceRig')
lowerFaceRig = doc.SearchObject('lowerFaceRig')
if upperFaceRig and lowerFaceRig:
rig = c4d.BaseObject(c4d.Onull)
rig.InsertBefore(fchild)
rig.SetName('faceRig')
doc.StartUndo()
child = upperFaceRig.GetDown()
leyelidupperCtrl = None
leyelidlowerCtrl = None
reyelidupperCtrl = None
reyelidlowerCtrl = None
if child:
while (child):
if 'rEyelidUpper' in child.GetName():
if reyelidupperCtrl:
constrainToCtrl(child, reyelidupperCtrl)
else:
reyelidupperCtrl = createCtrl(rig, child, 1,
'rEyelidUpper_CTRL',
c4d.Vector(0, .5, 0))
constrainToCtrl(child, reyelidupperCtrl)
elif 'lEyelidUpper' in child.GetName():
if leyelidupperCtrl:
constrainToCtrl(child, leyelidupperCtrl)
else:
leyelidupperCtrl = createCtrl(rig, child, 1,
'lEyelidUpper_CTRL',
c4d.Vector(0, .5, 0))
constrainToCtrl(child, leyelidupperCtrl)
elif 'rEyelidLower' in child.GetName():
if reyelidlowerCtrl:
constrainToCtrl(child, reyelidlowerCtrl)
else:
reyelidlowerCtrl = createCtrl(rig, child, 1,
'rEyelidLower_CTRL',
c4d.Vector(0, -.5, 0))
constrainToCtrl(child, reyelidlowerCtrl)
elif 'lEyelidLower' in child.GetName():
if leyelidlowerCtrl:
constrainToCtrl(child, leyelidlowerCtrl)
else:
leyelidlowerCtrl = createCtrl(rig, child, 1,
'lEyelidLower_CTRL',
c4d.Vector(0, -.5, 0))
constrainToCtrl(child, leyelidlowerCtrl)
elif 'lEyelidInner' in child.GetName():
ctrl = createCtrl(rig, child, off=c4d.Vector(1, 0, 0))
constrainToCtrl(child, ctrl)
elif 'lEyelidOuter' in child.GetName():
ctrl = createCtrl(rig, child, off=c4d.Vector(-1, 0, 0))
constrainToCtrl(child, ctrl)
elif 'rEyelidInner' in child.GetName():
ctrl = createCtrl(rig, child, off=c4d.Vector(1, 0, 0))
constrainToCtrl(child, ctrl)
elif 'rEyelidOuter' in child.GetName():
ctrl = createCtrl(rig, child, off=c4d.Vector(-1, 0, 0))
constrainToCtrl(child, ctrl)
else:
ctrl = createCtrl(rig, child)
constrainToCtrl(child, ctrl)
child = child.GetNext()
child = lowerFaceRig.GetDown()
if child:
# we want to create the jaw, lower face objects go underneath it
lowerJaw = doc.SearchObject('lowerJaw')
if lowerJaw:
chin = doc.SearchObject(
'Chin') # it's in a similar position to the chin
if chin:
chinPos = chin.GetAbsPos()
jawPos = lowerJaw.GetAbsPos()
cOff = chinPos - jawPos
cOff.y -= .8
cOff.z -= 1.5
jawCtrl = createCtrl(rig, lowerJaw, type=2, off=cOff)
constrainToCtrl(lowerJaw, jawCtrl)
while (child):
ctrl = createCtrl(jawCtrl, child)
constrainToCtrl(child, ctrl)
child = child.GetNext()
tag = objs[1].GetTag(c4d.Tposemorph)
if tag:
loutils.createUserDataLink(objs[0], 'mesh', val=objs[1])
mCnt = tag.GetMorphCount()
for i in range(mCnt):
morph = tag.GetMorph(i)
loutils.createUserDataFloatSlider(objs[0], morph.GetName())
pTag = objs[0].MakeTag(c4d.Tpython)
pTag[
c4d.
TPYTHON_CODE] = 'import c4d\r\n\r\ndef main():\r\n obj = op.GetObject()\r\n mesh = obj[c4d.ID_USERDATA, 1]\r\n tag = mesh.GetTag(c4d.Tposemorph)\r\n mCnt = tag.GetMorphCount()\r\n for i in range(mCnt):\r\n morph = tag.GetMorph(i)\r\n uData = obj[c4d.ID_USERDATA, i+2]\r\n tag[4000,1001+(100*(i))] = uData'
doc.EndUndo()
c4d.EventAdd()
class MetaEnv(object):
NodeColor = c4d.Vector(0.537, 0.443, 0.984)
# Environment
Env = "Environment"
EnvSky = "PhysicalSky"
class MetaMath(object):
NodeColor = c4d.Vector(0.333, 1, 0.635)
#Math
MathAbs = "RSMathAbs"
MathAdd = "RSMathAdd"
MathACos = "RSMathACos"
MathASin = "RSMathASin"
MathATan2 = "RSMathATan2"
MathATan = "RSMathATan"
MathBias = "RSMathBias"
MathRange = "RSMathRange"
MathCos = "RSMathCos"
MathCrossVector = "RSMathCrossVector"
MathDiv = "RSMathDiv"
MathDotVector = "RSMathDotVector"
MathExp = "RSMathExp"
MathFloor = "RSMathFloor"
MathFrac = "RSMathFrac"
MathGain = "RSMathGain"
MathInv = "RSMathInv"
MathLn = "RSMathLn"
MathLog = "RSMathLog"
MathMax = "RSMathMax"
MathMin = "RSMathMin"
MathMix = "RSMathMix"
MathMod = "RSMathMod"
MathMul = "RSMathMul"
MathNeg = "RSMathNeg"
MathNormalizeVector = "RSMathNormalizeVector"
MathPow = "RSMathPow"
MathRcp = "RSMathRcp"
MathSaturate = "RSMathSaturate"
MathSign = "RSMathSign"
MathSin = "RSMathSin"
MathSqrt = "RSMathSqrt"
MathSub = "RSMathSub"
MathTan = "RSMathTan"
MathAbsVector = "RSMathAbsVector"
MathAddVector = "RSMathAddVector"
MathBiasVector = "RSMathBiasVector"
MathRangeVector = "RSMathRangeVector"
MathDivVector = "RSMathDivVector"
MathExpVector = "RSMathExpVector"
MathFloorVector = "RSMathFloorVector"
MathFracVector = "RSMathFracVector"
MathGainVector = "RSMathGainVector"
MathInvVector = "RSMathInvVector"
MathLengthVector = "RSMathLengthVector"
MathLnVector = "RSMathLnVector"
MathLogVector = "RSMathLogVector"
MathMaxVector = "RSMathMaxVector"
MathMinVector = "RSMathMinVector"
MathMixVector = "RSMathMixVector"
MathModVector = "RSMathModVector"
MathMulVector = "RSMathMulVector"
MathNegVector = "RSMathNegVector"
MathPowVector = "RSMathPowVector"
MathRcpVector = "RSMathRcpVector"
MathSaturateVector = "RSMathSaturateVector"
MathSignVector = "RSMathSignVector"
MathSqrtVector = "RSMathSqrtVector"
MathSubVector = "RSMathSubVector"
MathRSVectorToScalars = "RSVectorToScalars"
def fromObj(obj, origine=c4d.Vector()):
"""renvoie la bbox 2d de l'objet"""
mg = obj.GetMg()
rad = obj.GetRad()
centre = obj.GetMp()
#4 points de la bbox selon orientation de l'objet
pts = [
c4d.Vector(centre.x + rad.x, centre.y + rad.y, centre.z + rad.z) *
mg,
c4d.Vector(centre.x - rad.x, centre.y + rad.y, centre.z + rad.z) *
mg,
c4d.Vector(centre.x - rad.x, centre.y - rad.y, centre.z + rad.z) *
mg,
c4d.Vector(centre.x - rad.x, centre.y - rad.y, centre.z - rad.z) *
mg,
c4d.Vector(centre.x + rad.x, centre.y - rad.y, centre.z - rad.z) *
mg,
c4d.Vector(centre.x + rad.x, centre.y + rad.y, centre.z - rad.z) *
mg,
c4d.Vector(centre.x - rad.x, centre.y + rad.y, centre.z - rad.z) *
mg,
c4d.Vector(centre.x + rad.x, centre.y - rad.y, centre.z + rad.z) *
mg
]
mini = c4d.Vector(min([p.x for p in pts]), min([p.y for p in pts]),
min([p.z for p in pts])) + origine
maxi = c4d.Vector(max([p.x for p in pts]), max([p.y for p in pts]),
max([p.z for p in pts])) + origine
return Bbox(mini, maxi)
# c=epmv.helper.convertColor(colors[f[2]])
# c=numpy.average(numpy.array([c1,c2,c3]),axis=0)
# listecolor.append(c)
# imdraw.polygon(xys, fill=(c[0], c[1], c[2]))
#rectangle need (x1, y1), (x2, y2)
drawGradientLine(c1,c2,c3,xys)
# imdraw.rectangle(box, fill=(c[0], c[1], c[2]))
# if uv[f[0]][0] ==0 and uv[f[0]][1]==0:
# uv[f[0]] = (x,y)
## if uv[f[1]][0] ==0 and uv[f[1]][1]==0:
# uv[f[1]] = (x+s,y+s)
## if uv[f[2]][0] ==0 and uv[f[2]][1]==0:
# uv[f[2]] = (x+s,y)
# listexyz.append(xys)
#next one
tag.SetSlow(i, c4d.Vector((x+2)/sizex,(y+2)/sizey,0),
c4d.Vector((x+s-2)/sizex,(y+s-2)/sizey,0),
c4d.Vector((x+s-2)/sizex,(y+2)/sizey,0),
c4d.Vector((x+s-2)/sizex,(y+2)/sizey,0))
u[f[0]]=(x+2)/sizex
u[f[1]]=(x+s-2)/sizex
u[f[2]]=(x+s-2)/sizex
v[f[0]]=(y+2)/sizey
v[f[1]]=(y+s-2)/sizey
v[f[2]]=(y+2)/sizey
x = x + s
if x >=sizex or x +s >=sizex:
x = 0
y = y + s
# if y >=sizey or y+s >sizey:
def getRandomPointInside(self, y=0):
x = self.min.x + random.random() * self.largeur
z = self.min.z + random.random() * self.hauteur
return c4d.Vector(x, y, z)
def GetCube(self, haut=200):
res = c4d.BaseObject(c4d.Ocube)
taille = c4d.Vector(self.largeur, haut, self.hauteur)
res.SetAbsPos(self.centre)
return res
def fromObj(obj, resolution, origine=c4d.Vector()):
bbx = super(BboxImg, BboxImg).fromObj(obj, origine)
largeur = int(bbx.largeur / resolution)
hauteur = int(bbx.hauteur / resolution)
return BboxImg(bbx.min, bbx.max, largeur, hauteur)
def __init__(self, mini, maxi, px_x, px_y):
super(BboxImg, self).__init__(mini, maxi)
self.px_x = px_x
self.px_y = px_y
self.taille_px = c4d.Vector(self.largeur / px_x, self.hauteur / px_y,
0)
def main():
path2 = #insert here data 2
doc.StartUndo()
#add nulls
add_null("Countrie Spheres")
add_null("CO2")
with open(path2, 'rb') as latlong:
readed = csv.DictReader(latlong, delimiter=',')
pointcounter = 0
for i, row in enumerate(readed):
try:
countrienames = str(row["name"])
countries.append(countrienames)
lonp = float(row["longitude"])*mapscl
latp = float(row["latitude"])*mapscl
null = 0
vecp = c4d.Vector(lonp, null, latp)
vec.append(vecp)
#add sphere
sphereparent = doc.SearchObject("Countrie Spheres")
add_sphere(lonp, latp, sphereparent, countrienames)
#add lathe
latheparent = doc.SearchObject("CO2")
add_lathe(countrienames, vecp, latheparent)
pointcounter = pointcounter +1
except:
#print "Error while reading - {}".format(row)
continue
print vec
print pointcounter
path = #insert here CountriesLatLong
doc.StartUndo()
for x in countries:
points = []
abzug= 0
with open(path, 'rb') as csv_file:
readed = csv.DictReader(csv_file, delimiter=';')
for i, row in enumerate(readed):
try:
radius = float(row[x]) / radiusscale
radiussmall = radius / radiusscale
#ypos = (i) * yabstand
if radius == 0:
ypos = ypos
abzug = abzug +1
else:
ypos = (i-abzug) * yabstand
#Make Postion String for Loft
point = c4d.Vector(0, ypos, radiussmall)
points.append(point)
except:
#print "Error while reading - {}".format(row)
continue
#make last point of spline closed
point = c4d.Vector(0, ypos, 0)
points.append(point)
parent = doc.SearchObject(x)
add_spline(len(points), points, x, parent)
print "Abzug:" + str(abzug)
print points
c4d.EventAdd()
doc.EndUndo()
def CreateLayout(self):
global customColor
c4dver, c4dbuild = GetC4DVersion()
self.SetTitle("Create Folder Null") # Set dialog title
# ----------------------------------------------------------------------------------------
self.GroupBegin(GRP_MEGA, c4d.BFH_CENTER, 1, 2) # Begin 'Mega1' group
self.GroupBorderSpace(5, 5, 5, 5)
# ----------------------------------------------------------------------------------------
# Inputs
if (c4dver > 20):
self.GroupBegin(GRP_MAIN, c4d.BFH_LEFT, 3, 1,
"") # Begin 'Main' group
else:
self.GroupBegin(GRP_MAIN, c4d.BFH_LEFT, 2, 1,
"") # Begin 'Main' group
self.GroupBorderSpace(5, 3, 5, 3)
#self.GroupBorderNoTitle(c4d.BORDER_GROUP_IN)
self.AddEditText(FOL_NAMEINPUT, c4d.BFH_LEFT, initw=250, inith=0)
# Icon
if (c4dver > 20):
self.AddComboBox(FOL_ICONCB, c4d.BFH_LEFT, 50, 13)
self.AddChild(FOL_ICONCB, ICO_FOLDER,
" &i1052837&") # Closed folder
self.AddChild(FOL_ICONCB, ICO_OPEN, " &i1052838&") # Open folder
self.AddChild(FOL_ICONCB, ICO_CIRCLE, " &i17106&") # Circle
self.AddChild(FOL_ICONCB, ICO_STAR, " &i170141&") # Start
self.AddChild(FOL_ICONCB, ICO_NULL, " &i5140&") # Null
self.AddChild(FOL_ICONCB, ICO_BIN, " &i12109&") # Thrash can
# Color
self.AddComboBox(FOL_COLORCB, c4d.BFH_LEFT, 80, 13)
self.AddChild(FOL_COLORCB, COL_CUSTOM, "Custom") # Custom
self.AddChild(FOL_COLORCB, COL_RANDOM, "Random") # Random
self.AddChild(FOL_COLORCB, COL_SEP, "") # Separator line
self.AddChild(FOL_COLORCB, COL_BLUE, "Blue")
self.AddChild(FOL_COLORCB, COL_DARKBLUE, "Dark Blue")
self.AddChild(FOL_COLORCB, COL_FUCHIA, "Fuscia")
self.AddChild(FOL_COLORCB, COL_GREEN, "Green")
self.AddChild(FOL_COLORCB, COL_ORANGE, "Orange")
self.AddChild(FOL_COLORCB, COL_SEANCE, "Seance")
self.AddChild(FOL_COLORCB, COL_PURPLEHEART, "Purple")
self.AddChild(FOL_COLORCB, COL_RED, "Red")
self.AddChild(FOL_COLORCB, COL_YELLOW, "Yellow")
self.AddChild(FOL_COLORCB, COL_DARK, "Dark")
self.AddChild(FOL_COLORCB, COL_BRIGHT, "Bright")
#
self.GroupEnd() # End 'Main' group
self.GroupBegin(GRP_ALT, c4d.BFH_FIT | c4d.BFH_LEFT, 4, 1,
"") # Begin 'Alt' group
#self.GroupBorderSpace(5, 0, 5, 5)
self.GroupBegin(9000, c4d.BFH_RIGHT, 2, 1, "") # Begin 'Alt' group
self.GroupBorderNoTitle(c4d.BORDER_GROUP_IN)
self.GroupBorderSpace(5, 5, 5, 5)
self.AddCheckbox(FOL_PROTECT, c4d.BFH_LEFT, 0, 13, "Protected")
self.AddCheckbox(FOL_SEPARATOR, c4d.BFH_LEFT, 0, 13, "Separator")
self.GroupEnd() # End 'Alt' group
# Layers
self.GroupBegin(9000, c4d.BFH_RIGHT, 2, 1, "") # Begin 'Alt' group
self.GroupBorderNoTitle(c4d.BORDER_GROUP_IN)
self.GroupBorderSpace(5, 3, 5, 3)
self.AddStaticText(FOL_LAYERTEXT, c4d.BFH_RIGHT, 0, 13, "Layers", 0)
self.AddComboBox(FOL_LAYERCB, c4d.BFH_RIGHT, 140, 13)
self.AddChild(FOL_LAYERCB, LAY_NONE, "No Layer")
self.AddChild(FOL_LAYERCB, LAY_FOLDER, "Folder Only")
self.AddChild(FOL_LAYERCB, LAY_ADD, "Add Layer")
self.AddChild(FOL_LAYERCB, LAY_OVER, "Overwrite Layer")
self.AddChild(FOL_LAYERCB, LAY_AUTOTAG, "Autolayer Tag")
self.GroupEnd() # End 'Alt' group
self.GroupEnd() # End 'Alt' group
# Set default options
settings = loadSettings()
self.SetString(FOL_NAMEINPUT, str(settings['setName']))
self.SetInt32(FOL_COLORCB, int(settings['setColor']))
if (c4dver > 20):
self.SetInt32(FOL_ICONCB, int(settings['setIcon']))
self.SetInt32(FOL_LAYERCB, int(settings['setLayer']))
self.SetBool(FOL_PROTECT, int(settings['setProtect']))
self.SetBool(FOL_SEPARATOR, int(settings['setSeparator']))
cRGB = str(settings['setCustom']).split(",")
customColor = c4d.Vector(float(cRGB[0]), float(cRGB[1]),
float(cRGB[2]))
# ----------------------------------------------------------------------------------------
self.GroupEnd() # End 'Mega1' group
# ----------------------------------------------------------------------------------------
self.GroupBegin(GRP_BTN, c4d.BFH_CENTER, 0, 0,
"Buttons") # Begin 'Buttons' group
# Buttons
self.AddButton(BTN_OK, c4d.BFH_LEFT, name="Accept") # Add button
self.AddButton(BTN_CANCEL, c4d.BFH_RIGHT, name="Cancel") # Add button
self.GroupEnd() # End 'Buttons' group
return True
def GetGlobalScale(obj): # Get object's global scale
m = obj.GetMg()
return c4d.Vector(m.v1.GetLength(),
m.v2.GetLength(),
m.v3.GetLength())
class MetaOut(object):
NodeColor = c4d.Vector(0.204, 0.443, 0.682)
# Output
Output = "Output"
def main():
fromObj = c4d.BaseObject(c4d.Onull)
fromObj[c4d.ID_BASELIST_NAME] = "FromLoc"
fromObj[c4d.NULLOBJECT_RADIUS] = 20
toObj = c4d.BaseObject(c4d.Onull)
toObj[c4d.ID_BASELIST_NAME] = "ToLoc"
toObjoff = c4d.Vector(0, 0, 0)
toObjv1 = c4d.Vector(-1, 0, 0)
toObjv2 = c4d.Vector(0, 0.8, 0)
toObjv3 = c4d.Vector(0, 0, -1)
toObj.SetMg(c4d.Matrix(toObjoff, toObjv1, toObjv2, toObjv3))
toObj[c4d.NULLOBJECT_RADIUS] = 16
# Set Pyramid shape of locator
for item in [fromObj, toObj]:
item[c4d.NULLOBJECT_DISPLAY] = 12
item[c4d.NULLOBJECT_ORIENTATION] = 3
sweepObj = c4d.BaseObject(c4d.Osweep)
sweepObj[c4d.ID_BASELIST_NAME] = "Line"
bc1 = c4d.GetCustomDatatypeDefault(c4d.DTYPE_GROUP)
bc1[c4d.DESC_NAME] = "Ray Attribute"
bc1[c4d.DESC_PARENTGROUP] = c4d.DescID(
0) # Put this group as a table of the object
[bc2, bc3] = [
c4d.GetCustomDatatypeDefault(c4d.DTYPE_BASELISTLINK)
for i in range(0, 2)
]
bc2[c4d.DESC_NAME] = "From Object"
bc3[c4d.DESC_NAME] = "To Object"
[bc4, bc5
] = [c4d.GetCustomDatatypeDefault(c4d.DTYPE_REAL) for i in range(0, 2)]
bc4[c4d.DESC_NAME] = "Start Distance"
bc5[c4d.DESC_NAME] = "End Distance"
# Set default spline data
bc6 = c4d.GetCustomDatatypeDefault(c4d.CUSTOMDATATYPE_SPLINE)
bc6[c4d.DESC_NAME] = "Length Ratio Remap"
bc7 = c4d.GetCustomDatatypeDefault(c4d.DTYPE_BOOL)
bc7[c4d.DESC_NAME] = "Positive Z Only"
# Get root user group description ID for other insertions
DesID1 = sweepObj.AddUserData(bc1)
for item in [bc2, bc3, bc4, bc5, bc6, bc7]:
item[c4d.DESC_PARENTGROUP] = DesID1
sweepObj.AddUserData(item)
sweepObj[c4d.ID_USERDATA, 2] = fromObj
sweepObj[c4d.ID_USERDATA, 3] = toObj
sweepObj[c4d.ID_USERDATA, 5] = 500
# Set customized spline user data
initSplineData = c4d.SplineData()
initSplineData.DeleteAllPoints()
initSplineData.MakePointBuffer(4)
for knot in [[0, 0, 0], [1, 0.2, 1], [2, 0.8, 1], [3, 1, 0]]:
initSplineData.SetKnot(
index=knot[0],
vPos=c4d.Vector(knot[1], knot[2], 0),
lFlagsSettings=c4d.FLAG_KNOT_T_KEEPVISUALANGLE,
vTangentLeft=c4d.Vector(-0.05, 0, 0),
vTangentRight=c4d.Vector(0.05, 0, 0),
interpol=c4d.CustomSplineKnotInterpolationBezier)
# Replace default spline data with customized one
sweepObj[c4d.ID_USERDATA, 6] = initSplineData
contourSpline = c4d.BaseObject(c4d.Osplinenside)
contourSpline[c4d.PRIM_NSIDE_RADIUS] = 5
raySpline = c4d.BaseObject(c4d.Ospline)
# Init a 2 points spline
raySpline.ResizeObject(2, 0)
for item in [raySpline, contourSpline]:
item.InsertUnder(sweepObj)
# Core code in python tag
pythonTag = c4d.BaseTag(c4d.Tpython)
pythonTag[c4d.DESC_NAME] = "AutoConnectionUpdater"
pythonTag[c4d.TPYTHON_CODE] = (
"""# Description: A script to create a ray connector to connect two objects
# Author: eZioPan
# Page: github.com/eZioPan
# License: Creative Commons Attribution Share Alike 4.0
import c4d
def main():
sweepObj = op.GetObject()
lineObj = op.GetObject().GetDown().GetNext()
objFrom = sweepObj[c4d.ID_USERDATA,2]
objTo = sweepObj[c4d.ID_USERDATA,3]
startDistance = sweepObj[c4d.ID_USERDATA,4]
endDistance = sweepObj[c4d.ID_USERDATA,5]
mapperSpline = sweepObj[c4d.ID_USERDATA,6]
positiveChecker = sweepObj[c4d.ID_USERDATA,7]
if objFrom == None or objTo == None:
print("Not enough Object")
return None
if startDistance == endDistance:
print("same value at startDistance and endDistance")
return None
objFromPos = objFrom.GetMg().off
objFromZ = objFrom.GetMg().v3
objToPos = objTo.GetMg().off
lineObj.SetPoint(0,objFromPos)
lineObj.SetPoint(1,objToPos)
lineObj.Message(c4d.MSG_UPDATE) # Update point change of object
ratio = 0
# Get distance of two objects in From Object's Z direction
dotProducted = objFromZ.GetNormalized().Dot(objToPos-objFromPos)
if positiveChecker == False or dotProducted > 0:
dis = abs(dotProducted)
ratio = mapperSpline.GetPoint((dis-startDistance)/(endDistance-startDistance))[1]
sweepObj[c4d.SWEEPOBJECT_GROWTH] = ratio
return True
""")
sweepObj.InsertTag(pythonTag)
doc = c4d.documents.GetActiveDocument()
doc.StartUndo()
for item in [sweepObj, toObj, fromObj]:
doc.InsertObject(item)
doc.AddUndo(c4d.UNDOTYPE_NEW, item)
doc.EndUndo()
doc.SetActiveObject(sweepObj, mode=c4d.SELECTION_NEW)
c4d.EventAdd()
class MetaVolume(object):
NodeColor = c4d.Vector(0.361, 0.8, 0.8)
# Volume
Volume = "Volume"
def addAiTag():
camerasList = get_all_objects(doc.GetFirstObject(),
lambda x: x.CheckType(c4d.Ocamera),
[]) # get all cameras from the scene
if not camerasList:
# create a new base camera
camera = create_c4d_obj(c4d.Ocamera, 'Base Camera')
# get viewport cmera
bd = doc.GetActiveBaseDraw()
vcam = bd.GetEditorCamera()
vp_x = vcam[c4d.ID_BASEOBJECT_REL_POSITION, c4d.VECTOR_X]
vp_y = vcam[c4d.ID_BASEOBJECT_REL_POSITION, c4d.VECTOR_Y]
vp_z = vcam[c4d.ID_BASEOBJECT_REL_POSITION, c4d.VECTOR_Z]
vr_x = vcam[c4d.ID_BASEOBJECT_REL_ROTATION, c4d.VECTOR_X]
vr_y = vcam[c4d.ID_BASEOBJECT_REL_ROTATION, c4d.VECTOR_Y]
vr_z = vcam[c4d.ID_BASEOBJECT_REL_ROTATION, c4d.VECTOR_Z]
# set new camera position based on viewport camera
camera[c4d.ID_BASEOBJECT_REL_POSITION] = c4d.Vector(vp_x, vp_y, vp_z)
camera[c4d.ID_BASEOBJECT_REL_ROTATION] = c4d.Vector(vr_x, vr_y, vr_z)
# add the new camera to cameralists
camerasList.append(camera)
for obj in camerasList:
obj_tags = obj.GetTags()
if not obj_tags:
cam_tag = obj.MakeTag(C4DAIN_TAG) # new camera tag
else:
obj_tags_types = []
for tag in obj_tags:
obj_tags_types.append(tag.GetType())
if tag.GetType() == C4DAIN_TAG:
cam_tag = tag
if not C4DAIN_TAG in obj_tags_types:
cam_tag = obj.MakeTag(C4DAIN_TAG)
if cam_tag[c4d.AITAG_CAMERA_USE_TYPE] == False:
cam_tag[c4d.AITAG_CAMERA_USE_TYPE] = True
cam_tag[c4d.AITAG_CAMERA_TYPE] = C4DAIN_PERSP_CAMERA
# cam settings definitions based on each camera type
if cam_tag[c4d.AITAG_CAMERA_TYPE] == C4DAIN_CYL_CAMERA: # cyl camera
CAMERA_SHUTTER_START = C4DAIP_CYL_CAMERA_SHUTTER_START
CAMERA_SHUTTER_END = C4DAIP_CYL_CAMERA_SHUTTER_END
elif cam_tag[
c4d.
AITAG_CAMERA_TYPE] == C4DAIN_FISHEYE_CAMERA: # fisheye camera
CAMERA_SHUTTER_START = C4DAIP_FISHEYE_CAMERA_SHUTTER_START
CAMERA_SHUTTER_END = C4DAIP_FISHEYE_CAMERA_SHUTTER_END
elif cam_tag[
c4d.AITAG_CAMERA_TYPE] == C4DAIN_ORTHO_CAMERA: # ortho camera
CAMERA_SHUTTER_START = C4DAIP_ORTHO_CAMERA_SHUTTER_START
CAMERA_SHUTTER_END = C4DAIP_ORTHO_CAMERA_SHUTTER_END
elif cam_tag[
c4d.
AITAG_CAMERA_TYPE] == C4DAIN_SPHERICAL_CAMERA: # spherical camera
CAMERA_SHUTTER_START = C4DAIP_SPHERICAL_CAMERA_SHUTTER_START
CAMERA_SHUTTER_END = C4DAIP_SPHERICAL_CAMERA_SHUTTER_END
elif cam_tag[c4d.AITAG_CAMERA_TYPE] == C4DAIN_VR_CAMERA: # vr camera
CAMERA_SHUTTER_START = C4DAIP_VR_CAMERA_SHUTTER_START
CAMERA_SHUTTER_END = C4DAIP_VR_CAMERA_SHUTTER_END
else: # persp camera
CAMERA_SHUTTER_START = C4DAIP_PERSP_CAMERA_SHUTTER_START
CAMERA_SHUTTER_END = C4DAIP_PERSP_CAMERA_SHUTTER_END
# motion vector settings
cam_tag[c4d.C4DAI_CAMERA_CUSTOM_SHUTTER] = True
cam_tag[CAMERA_SHUTTER_START] = 0.5
cam_tag[CAMERA_SHUTTER_END] = 0.5
return cam_tag
def getAvaragePosition(objects):
cumulative_position = c4d.Vector(0, 0, 0)
for obj in objects:
cumulative_position += obj.GetAbsPos()
return cumulative_position / len(objects)
def main():
# find the Arnold video post data
arnoldRenderSettings = GetArnoldRenderSettings()
if arnoldRenderSettings is None:
raise BaseException("Failed to find Arnold render settings")
# set Arnold as the active render engine
rdata = doc.GetActiveRenderData()
rdata[c4d.RDATA_RENDERENGINE] = ARNOLD_RENDERER
# Open the options dialog to let users choose their options.
dlg = OptionsDialog()
dlg.Open(c4d.DLG_TYPE_MODAL, defaultw=300, defaulth=50)
if not dlg.ok:
return
# AOV shaders dialog excecution
dialog = dlg.findCName
pdialog = dlg.findPName
if pdialog == IDC_POINTSOP01:
pdialog = True
else:
pdialog = False
# facing ratio - get ID
C4DAIN_FACING_RATIO = hashid('facing_ratio')
# main AOVs IDs
shaders_AOVs_names = [
'UV', 'Wireframe', 'AO', 'Crypto', 'Fresnel', 'mblur', 'Checkerboard'
]
AOV_types = ['RGB', 'Float', 'Int', 'RGBA']
# main definitions for shaders, materials and AOVs
if dialog == IDC_AOV_00:
shader_AOV_name = shaders_AOVs_names[0]
shader = C4DAIN_UTILITY
AOV_type = AOV_types[0] # RGB
elif dialog == IDC_AOV_01:
shader_AOV_name = shaders_AOVs_names[1]
shader = C4DAIN_WIREFRAME
AOV_type = AOV_types[2] # int
elif dialog == IDC_AOV_02:
shader_AOV_name = shaders_AOVs_names[2]
shader = C4DAIN_AMBIENT_OCCLUSION
AOV_type = AOV_types[1] # float
elif dialog == IDC_AOV_03:
shader_AOV_name = shaders_AOVs_names[3]
shader = C4DAIN_CRYPTOMATTE
AOV_type = AOV_types[0] # RGB
elif dialog == IDC_AOV_04:
shader_AOV_name = shaders_AOVs_names[4]
shader = C4DAIN_FACING_RATIO
AOV_type = AOV_types[1] # float
elif dialog == IDC_AOV_05:
shader_AOV_name = shaders_AOVs_names[5]
shader = C4DAIN_MOTION_VECTOR
AOV_type = AOV_types[0] # RGB
elif dialog == IDC_AOV_06:
shader_AOV_name = shaders_AOVs_names[6]
shader = C4DAIN_CHECKERBOARD
AOV_type = AOV_types[1] # float
else:
shader_AOV_name = 'none'
# create material
mat = doc.SearchMaterial(shader_AOV_name)
if mat is None:
mat = c4d.BaseMaterial(ARNOLD_SHADER_NETWORK)
if mat is None:
raise Exception("Failed to create material")
mat.SetName(shader_AOV_name)
doc.InsertMaterial(mat)
mat_exist = False
mat[c4d.ID_LAYER_LINK] = addLayer('AOV Shaders',
c4d.Vector(1, 0.5, 0.5))
# agregar material al layer
else:
mat_exist = True
# create AOV shaders null
addAOV_null('AOV shaders',
addLayer('_Arnold Drivers_', c4d.Vector(0.8, 0.2, 0.4)), mat)
# add the shader to the AOV shader list
aovShaders = arnoldRenderSettings.GetData().GetData(
C4DAIP_OPTIONS_AOV_SHADERS)
isMaterialAdded = False
for i in range(0, aovShaders.GetObjectCount()):
if aovShaders.ObjectFromIndex(doc, i) == mat:
isMaterialAdded = True
break
if isMaterialAdded is False:
aovShaders.InsertObject(mat, 0)
arnoldRenderSettings[C4DAIP_OPTIONS_AOV_SHADERS] = aovShaders
# drivers operations
displayDriver = addDriver("<display driver>", C4DAIN_DRIVER_C4D_DISPLAY)
if shader_AOV_name is 'Crypto':
if displayDriver:
addAov(displayDriver, "crypto_asset")
addAov(displayDriver, "crypto_object")
addAov(displayDriver, "crypto_material")
cryptoDriver = addDriver("Crypto", C4DAIN_DRIVER_EXR)
if cryptoDriver:
addAov(cryptoDriver, "crypto_asset")
addAov(cryptoDriver, "crypto_object")
addAov(cryptoDriver, "crypto_material")
else:
if displayDriver:
addAov(displayDriver, shader_AOV_name)
# extra info driver
if not pdialog:
if not shader_AOV_name == 'Crypto':
exrDriver = addDriver("info", C4DAIN_DRIVER_EXR)
if exrDriver:
addAov(exrDriver, shader_AOV_name)
# shaders operations
if not mat_exist:
# create main shaders
shader_AOV = CreateArnoldShader(mat, shader, 0, 50)
if shader_AOV is None:
raise Exception("Failed to create shader_AOV shader")
# cryptomatte exception
if shader_AOV_name is 'Crypto':
SetRootShader(mat, shader_AOV, ARNOLD_BEAUTY_PORT_ID)
else:
# get write shader type
if AOV_type is AOV_types[1]: # float
wirte_shader_type = C4DAIN_AOV_WRITE_FLOAT
wirte_shader_input = C4DAIN_AOV_WRITE_FLOAT_AOV_INPUT
write_shader_AOVname = C4DAIN_AOV_WRITE_FLOAT_AOV_NAME
elif AOV_type is AOV_types[2]: # int
wirte_shader_type = C4DAIN_AOV_WRITE_INT
wirte_shader_input = C4DAIN_AOV_WRITE_INT_AOV_INPUT
write_shader_AOVname = C4DAIN_AOV_WRITE_INT_AOV_NAME
else: # RGB
wirte_shader_type = C4DAIN_AOV_WRITE_RGB
wirte_shader_input = C4DAIN_AOV_WRITE_RGB_AOV_INPUT
write_shader_AOVname = C4DAIN_AOV_WRITE_RGB_AOV_NAME
# create write AOV shaders
write_shader = CreateArnoldShader(mat, wirte_shader_type, 150, 100)
if write_shader is None:
raise Exception("Failed to create write_AOV shader")
# set shader parameters
write_shader.SetName("Write_" + shader_AOV_name + "_AOV")
write_shader.GetOpContainerInstance().SetString(
write_shader_AOVname, shader_AOV_name)
# set shader name
shader_AOV.SetName(shader_AOV_name + "_AOV")
# patameters for each AOV shader
if shader_AOV_name is shaders_AOVs_names[0]: # UV
shader_AOV.GetOpContainerInstance().SetInt32(
C4DAIP_UTILITY_SHADE_MODE, C4DAIP_UTILITY_SHADE_MODE__FLAT)
shader_AOV.GetOpContainerInstance().SetInt32(
C4DAIP_UTILITY_COLOR_MODE, C4DAIP_UTILITY_COLOR_MODE__UV)
elif shader_AOV_name is shaders_AOVs_names[1]: # wireframe
shader_AOV.GetOpContainerInstance().SetFloat(
C4DAIP_WIREFRAME_LINE_WIDTH, 0.75)
shader_AOV.GetOpContainerInstance().SetInt32(
C4DAIP_WIREFRAME_EDGE_TYPE, 1)
elif shader_AOV_name is shaders_AOVs_names[2]: # AO
shader_AOV.GetOpContainerInstance().SetInt32(
C4DAIP_AMBIENT_OCCLUSION_SAMPLES, 4)
elif shader_AOV_name is shaders_AOVs_names[3]: # crypto
None
elif shader_AOV_name is shaders_AOVs_names[4]: # fresnel
shader_AOV.GetOpContainerInstance().SetBool(
C4DAIP_FACING_RATIO_INVERT, True)
elif shader_AOV_name is shaders_AOVs_names[5]: # motion vector
shader_AOV.GetOpContainerInstance().SetBool(
C4DAIP_MOTION_VECTOR_RAW, True)
shader_AOV.GetOpContainerInstance().SetFloat(
C4DAIP_MOTION_VECTOR_MAX_DISPLACE, 0)
elif shader_AOV_name is shaders_AOVs_names[6]: # checkerboard
shader_AOV.GetOpContainerInstance().SetInt32(
C4DAIP_CHECKERBOARD_U_FREQUENCY, 5)
shader_AOV.GetOpContainerInstance().SetInt32(
C4DAIP_CHECKERBOARD_V_FREQUENCY, 5)
else:
None
# connect shaders
SetRootShader(mat, write_shader, ARNOLD_BEAUTY_PORT_ID)
AddConnection(mat, shader_AOV, write_shader, wirte_shader_input)
else:
None
# motion vector additional settings
if shader_AOV_name is shaders_AOVs_names[5]: # motion vector
mblur_question = c4d.gui.QuestionDialog(
'do you want to make a camera an render setting for motion blur?')
if mblur_question is True:
arnold_mblur_rendersettings()
addAiTag()
aovs = get_all_objects(doc.GetFirstObject(),
lambda x: x.CheckType(ARNOLD_AOV),
[]) # get all cameras from the scene
for aov in aovs:
if aov[c4d.ID_BASELIST_NAME] == 'mblur':
aov[c4d.C4DAI_AOV_DATATYPE] = 7 # vector AOV
else:
None
else:
None
# redraw
c4d.EventAdd(c4d.EVENT_FORCEREDRAW)
def main():
md = mo.GeGetMoData(op)
if not md: return False
cnt = md.GetCount()
scl = op[c4d.ID_USERDATA, 2]
anim = op[c4d.ID_USERDATA, 3]
mode = op[c4d.ID_USERDATA, 4]
torus_R = op[c4d.ID_USERDATA, 6]
torus_p = op[c4d.ID_USERDATA, 7]
torus_q = op[c4d.ID_USERDATA, 8]
liss_k = op[c4d.ID_USERDATA, 11]
liss_l = op[c4d.ID_USERDATA, 12]
speed = op[c4d.ID_USERDATA, 10]
off_mode = op[c4d.ID_USERDATA, 5]
offset = op[c4d.ID_USERDATA, 13]
#matrix list of clones
marr = md.GetArray(c4d.MODATA_MATRIX)
pos = c4d.Vector()
#extract the current time if the "Animate" attribute is enabled
if anim:
time = doc.GetTime().Get()
else:
time = 0
#iter through all clones
for i in xrange(0, cnt):
if off_mode:
itime = (offset / (100 * cnt)) * 2 * math.pi * i + (speed * time)
else:
itime = i + (speed * time)
if mode == 1: #Trefoil Knot A
pos = c4d.Vector(
scl * (2 + math.cos(3 * itime)) * math.cos(2 * itime),
scl * (2 + math.cos(3 * itime)) * math.sin(2 * itime),
scl * math.sin(3 * itime))
elif mode == 2: #Trefoil Knot B
pos = c4d.Vector(
-scl * math.cos(itime) - 0.2 * scl * math.cos(5 * itime) +
1.5 * scl * math.sin(2 * itime),
-1.5 * scl * math.cos(2 * itime) + scl * math.sin(itime) -
0.2 * scl * math.sin(5 * itime), scl * math.cos(3 * itime))
elif mode == 3: #Achterknoten
pos = c4d.Vector(
scl * math.cos(itime) + scl * math.cos(3 * itime),
0.6 * scl * math.sin(itime) + scl * math.sin(3 * itime),
0.4 * scl * math.sin(3 * itime) - scl * math.sin(6 * itime))
elif mode == 4: #Torus
pos = c4d.Vector((2 * scl + torus_R * math.cos(torus_p * itime)) *
math.cos(torus_q * itime),
(2 * scl + torus_R * math.cos(torus_p * itime)) *
math.sin(torus_q * itime),
torus_R * math.sin(torus_p * itime))
elif mode == 5: #Lissajous
pos = c4d.Vector(scl * math.cos(liss_k.x * itime + liss_l.x),
scl * math.cos(liss_k.y * itime + liss_l.y),
scl * math.cos(liss_k.z * itime + liss_l.z))
#set the position of the clone
marr[i].off = pos
#handle the modified matrix list back to mograph
md.SetArray(c4d.MODATA_MATRIX, marr, True)
def insertObject(pX, pY, pZ, pWidth, pHeight, pDepth, pIndex):
#INSERT A CUBE
obj = c4d.BaseObject(c4d.Ocube)
obj[c4d.PRIM_CUBE_SUBX] = 2
obj[c4d.PRIM_CUBE_SUBY] = 2
obj[c4d.PRIM_CUBE_SUBZ] = 2
obj[c4d.PRIM_CUBE_LEN] = c4d.Vector(pWidth, pHeight, pDepth)
res = utils.SendModelingCommand(command=c4d.MCOMMAND_CURRENTSTATETOOBJECT,
list=[obj],
mode=c4d.MODELINGCOMMANDMODE_ALL,
bc=c4d.BaseContainer(),
doc=doc)[0]
res[c4d.ID_BASEOBJECT_REL_POSITION, c4d.VECTOR_X] = pX
res[c4d.ID_BASEOBJECT_REL_POSITION, c4d.VECTOR_Y] = pY
res[c4d.ID_BASEOBJECT_REL_POSITION, c4d.VECTOR_Z] = pZ
res[c4d.ID_BASELIST_NAME] = "cuby_" + str(pIndex)
doc.InsertObject(res)
doc.SetActiveObject(res, c4d.SELECTION_NEW)
c4d.EventAdd()
#EXTRUDE THE SURFACES TO RANDOM LENGTHS
sel = res.GetPolygonS()
c4d.CallCommand(12187) # Polygons
saveToPath = "D:\_projects\3d_sandbox\cubic_transformations\render\cuby_"
outerCounter = 1
innerCounter = 1
#PASS 1 - CREATE A BASE SHAPE
for growthCounter in range(0, 10):
for f in range(0, 23):
c4d.CallCommand(13324) # Deselect All
sel.Select(f)
c4d.CallCommand(1011183) # Extrude
getTool()[c4d.MDATA_EXTRUDE_OFFSET] = randrange(10, 40) * 1.0
fireAction(obj)
#print(saveToPath + str(outerCounter) + "_" + str(innerCounter))
#time.sleep(1)
innerCounter = innerCounter + 1
outerCounter = outerCounter + 1
'''
doc[c4d.RDATA_PATH] = "D:\_projects\3d_sandbox\cubic_transformations\render\cuby_" + str(growthCounter) + str(f)
c4d.CallCommand(465003525) # Add to Render Queue...
c4d.CallCommand(465003513) # Start Rendering
'''
#PASS 2 - ADD EXTRUSIONS TO RANDOM FACES
sel = res.GetPolygonS()
c4d.CallCommand(12187) # Polygons
for f in range(0, 100):
c4d.CallCommand(13324) # Deselect All
sel.Select(f)
#INNER EXTRUDE
c4d.CallCommand(450000004) # Extrude Inner
getTool()[c4d.MDATA_EXTRUDEINNER_OFFSET] = randrange(2, 30) * 1.0
fireAction(obj)
#OUTER
c4d.CallCommand(1011183) # Extrude
getTool()[c4d.MDATA_EXTRUDE_OFFSET] = randrange(9, 30) * -1.0
fireAction(obj)
#PASS 3 - ADD EXTRUSIONS TO RANDOM FACES
sel = res.GetPolygonS()
c4d.CallCommand(12187) # Polygons
for f in range(0, 100):
c4d.CallCommand(13324) # Deselect All
sel.Select(f)
#INNER EXTRUDE
c4d.CallCommand(450000004) # Extrude Inner
getTool()[c4d.MDATA_EXTRUDEINNER_OFFSET] = randrange(2, 8) * 1.0
fireAction(obj)
#OUTER
c4d.CallCommand(1011183) # Extrude
getTool()[c4d.MDATA_EXTRUDE_OFFSET] = randrange(3, 20) * -1.0
fireAction(obj)
#PASS 4 - ADD EXTRUSIONS TO RANDOM FACES
sel = res.GetPolygonS()
c4d.CallCommand(12187) # Polygons
for f in range(0, 100):
c4d.CallCommand(13324) # Deselect All
sel.Select(f)
#INNER EXTRUDE
c4d.CallCommand(450000004) # Extrude Inner
getTool()[c4d.MDATA_EXTRUDEINNER_OFFSET] = randrange(1, 6) * 1.0
fireAction(obj)
#OUTER
c4d.CallCommand(1011183) # Extrude
getTool()[c4d.MDATA_EXTRUDE_OFFSET] = randrange(1, 8) * -1.0
fireAction(obj)
#kick out a render
doc[c4d.RDATA_PATH] = ""
c4d.CallCommand(12098) # Save
c4d.CallCommand(12099) # Render to Picture Viewer
return obj
def polyselectionbreak(bdoc, bobj):
if not bobj: return
obj = bobj # the modeling commands change the bobj so we need to store this
gMatrix = bobj.GetMg()
tag = obj.GetFirstTag()
newChildren = []
while tag:
if tag.GetType() == c4d.Tpolygonselection:
# deselect all polygons
polyselection = obj.GetPolygonS()
polyselection.DeselectAll()
# select polygons from selection tag
tagselection = tag.GetBaseSelect()
tagselection.CopyTo(polyselection)
#split: polygonselection to a new object
sec = utils.SendModelingCommand(
command=c4d.MCOMMAND_SPLIT,
list=[obj],
mode=c4d.MODELINGCOMMANDMODE_POLYGONSELECTION,
doc=bdoc)
if isinstance(sec, list):
sec[0].SetName(tag.GetName())
sec[0][c4d.ID_BASEOBJECT_REL_POSITION] = c4d.Vector(0, 0, 0)
sec[0][c4d.ID_BASEOBJECT_REL_ROTATION] = c4d.Vector(0, 0, 0)
# remove polyselections and textures from the split and find a material to keep
secTag = sec[0].GetTag(c4d.Tpolygonselection)
while secTag:
secTag.Remove()
secTag = sec[0].GetTag(c4d.Tpolygonselection)
secTag = sec[0].GetFirstTag()
while secTag:
oldSecTag = None
if secTag.GetType() == c4d.Ttexture:
if secTag[c4d.TEXTURETAG_RESTRICTION] == tag.GetName():
secTag[c4d.TEXTURETAG_RESTRICTION] = ''
else:
oldSecTag = secTag
secTag = secTag.GetNext()
if oldSecTag:
oldSecTag.Remove()
## loop through tags and find any texture tags that have the selection and delete
oldMatTag = None
matTag = obj.GetFirstTag()
while matTag:
if matTag.GetType() == c4d.Ttexture:
if matTag[c4d.TEXTURETAG_RESTRICTION] == tag.GetName():
oldMatTag = matTag
matTag = matTag.GetNext()
if oldMatTag:
oldMatTag.Remove()
newChildren.append(sec[0])
##delete the polygons from selectiontag
utils.SendModelingCommand(
command=c4d.MCOMMAND_DELETE,
list=[obj],
mode=c4d.MODELINGCOMMANDMODE_POLYGONSELECTION,
doc=bdoc)
else:
print('split failed for ' + tag.GetName())
continue
tag = tag.GetNext()
# remove selection tags
tag = obj.GetTag(c4d.Tpolygonselection)
while tag:
tag.Remove()
tag = obj.GetTag(c4d.Tpolygonselection)
# Optimize in order to remove loose points
options = c4d.BaseContainer()
options[c4d.MDATA_OPTIMIZE_TOLERANCE] = 0.001
options[c4d.MDATA_OPTIMIZE_POINTS] = True
options[c4d.MDATA_OPTIMIZE_POLYGONS] = False
options[c4d.MDATA_OPTIMIZE_UNUSEDPOINTS] = True
utils.SendModelingCommand(c4d.MCOMMAND_OPTIMIZE,
list=[obj],
mode=c4d.MODELINGCOMMANDMODE_ALL,
bc=options,
doc=obj.GetDocument())
if (obj.GetPolygonCount() == 0): # no more polys
if (
obj.GetChildren() > 0
): # there are children remove this and replace with null then readd the children
objNull = c4d.BaseObject(c4d.Onull)
objNull.SetName(obj.GetName())
objParent = obj.GetUp()
obj.Remove()
obj = objNull
bdoc.InsertObject(obj, objParent)
obj.SetMg(gMatrix)
elif (
obj.GetChildren() == 0
): # No children, we don't want a parent remain so let's axe this
objParent = obj.GetUp()
obj.Remove()
obj = objParent
for child in newChildren:
child.InsertUnder(obj)
c4d.EventAdd()
ICO_OPEN = 5002
ICO_CIRCLE = 5003
ICO_STAR = 5004
ICO_NULL = 5005
ICO_BIN = 5006
LAY_FOLDER = 6001
LAY_ADD = 6002
LAY_OVER = 6003
LAY_NONE = 6004
LAY_AUTOTAG = 6005
BTN_OK = 7001
BTN_CANCEL = 7002
customColor = c4d.Vector(0, 0, 0)
# Functions
def GetC4DVersion():
c4dversion = c4d.GetC4DVersion()
releaseVersion = int(str(c4dversion)[:2])
buildVersion = int(str(c4dversion)[:2])
return releaseVersion, buildVersion
def CreateUserDataString(obj, name, link, parentGroup=None, shortname=None):
if obj is None: return False
if shortname is None: shortname = name
bc = c4d.GetCustomDatatypeDefault(c4d.DTYPE_STRING)
bc[c4d.DESC_NAME] = name
def color(self, id):
col = self.GetColorRGB(id)
return c4d.Vector(col['r'], col['g'], col['b']) ^ c4d.Vector(1.0 / 255)
def getData():
obj = op.GetObject()
cdn = []
clonedList = []
levels = {}
boxes = []
getAllChildren(obj.GetDown(), cdn, clonedList)
chunkDims = getChunksize()
#set to frame 0
doc.SetTime(c4d.BaseTime(0, doc.GetFps()))
renderFrame()
Chunks = OrderedDict({})
bounds = {
"minX": None,
"maxX": None,
"minY": None,
"maxY": None,
"minZ": None,
"maxZ": None
}
for el in cdn:
specs = getBlockType(el, chunkDims, boxes, levels)
chunk_id = getPosition(el[c4d.ID_BASEOBJECT_REL_POSITION], chunkDims)
calcWorldBounds(bounds, chunk_id[0])
currChunk = str(chunk_id[0][0]) + "," + str(
chunk_id[0][1]) + "," + str(chunk_id[0][2])
if currChunk not in Chunks:
Chunks[currChunk] = []
Chunks[currChunk].append([chunk_id[1], specs])
#set char position of chunks in file
strChunks = stringify(Chunks)
worldDims = getChunksize()
chunkSizes = worldDims["chunks"] = {}
for level in levels:
l = levels[level]
l['w'] = l.pop('X', None) - l['x'] + 1
l['l'] = l.pop('Z', None) - l['z'] + 1
l['h'] = l.pop('Y', None) - l['y'] + 1
levels[0] = {'s': 0}
worldDims['levels'] = levels
for chk in Chunks:
strChunk = stringify(Chunks[chk])
start = strChunks.find(strChunk)
chunkSizes[chk] = [start, len(strChunk) + start]
worldDims.update(bounds)
for box in boxes:
pos = box[1][c4d.ID_BASEOBJECT_REL_POSITION]
pos = c4d.Vector(pos)
pos.y -= 1
res = getPosition(pos, chunkDims)
chkName = ','.join(map(str, res[0]))
if chkName in Chunks:
for block in Chunks[chkName]:
if res[1] == block[0] and len(block[1]) > 1:
if block[1][1] in [3, 4, 5]:
box[0][2] = block[1][1]
break
#print getPosition(x, y, z, chunkDims)
#removed clones that got made to object
for o in clonedList:
o.Remove()
return {"worldInfo": worldDims, "chunks": Chunks}
