def readExtraMapsFromFile(self):
doc = c4d.documents.GetActiveDocument()
docMaterials = doc.GetMaterials()
for mat in docMaterials:
matName = mat.GetName()
extraMapBump = self.findTextInFile(matName, "bump")
extraMapBump2 = self.findTextInFile(matName, "bump2")
if extraMapBump == None and extraMapBump2 != None:
extraMapBump = extraMapBump2
extraMapNormal = self.findTextInFile(matName, "Normal_Map_Map")
if extraMapNormal != None and extraMapBump == None:
extraMapBump = extraMapNormal
if extraMapBump != None:
mat[c4d.MATERIAL_USE_BUMP] = True
shda = c4d.BaseList2D(c4d.Xbitmap)
shda[c4d.BITMAPSHADER_FILENAME] = extraMapBump
mat[c4d.MATERIAL_BUMP_SHADER] = shda
mat.InsertShader(shda)
extraMapNormal = self.findTextInFile(matName, "Normal_Map_Map")
if extraMapNormal != None:
mat[c4d.MATERIAL_USE_NORMAL] = True
shda = c4d.BaseList2D(c4d.Xbitmap)
shda[c4d.BITMAPSHADER_FILENAME] = extraMapNormal
mat[c4d.MATERIAL_NORMAL_SHADER] = shda
mat.InsertShader(shda)
extraMapSpec = self.findTextInFile(matName, "Glossy_Layered_Weight_Map")
extraMapSpec2 = self.findTextInFile(matName, "spec")
extraMapGlossy = self.findTextInFile(matName, "Metallicity_Map")
if extraMapSpec2 != None and extraMapSpec == None:
extraMapSpec = extraMapSpec2
if extraMapGlossy != None and extraMapSpec == None:
extraMapSpec = extraMapGlossy
if extraMapSpec != None:
mat[c4d.MATERIAL_USE_REFLECTION] = True
shda = c4d.BaseList2D(c4d.Xbitmap)
shda[c4d.BITMAPSHADER_FILENAME] = extraMapSpec
layer = mat.GetReflectionLayerIndex(0)
mat[layer.GetDataID() + c4d.REFLECTION_LAYER_TRANS_TEXTURE] = shda
mat.InsertShader(shda)
try:
mat[layer.GetDataID() + c4d.REFLECTION_LAYER_MAIN_DISTRIBUTION] = 4
except:
pass
extraMapGlossyRough = self.findTextInFile(matName, "Glossy_Roughness_Map")
if extraMapGlossyRough != None:
mat[c4d.MATERIAL_USE_REFLECTION] = True
shda = c4d.BaseList2D(c4d.Xbitmap)
shda[c4d.BITMAPSHADER_FILENAME] = extraMapGlossyRough
layer = mat.GetReflectionLayerIndex(0)
mat[
layer.GetDataID() + c4d.REFLECTION_LAYER_MAIN_SHADER_ROUGHNESS
] = shda
try:
mat.InsertShader(shda)
mat[layer.GetDataID() + c4d.REFLECTION_LAYER_MAIN_DISTRIBUTION] = 4
except:
pass
def createChildRenderData(rd, suffix=False, set_active=False):
''' Inserts a new RenderData as a child to an existing one, including a name suffix.'''
if rd.GetUp():
msg = 'Warning: This Render Data is already a child of an existing one. Canceling operation...'
gui.MessageDialog(msg)
return False
doc = c4d.documents.GetActiveDocument()
doc.StartUndo()
child_rdata = c4d.documents.RenderData()
child_rdata.SetData(rd.GetData())
doc.InsertRenderData(child_rdata, pred=rd)
doc.AddUndo(c4d.UNDOTYPE_NEW, rd)
child_rdata.InsertUnder(rd)
for multipass in ObjectIterator(rd.GetFirstMultipass()):
new_mpass = c4d.BaseList2D(c4d.Zmultipass)
new_mpass.GetDataInstance()[
c4d.MULTIPASSOBJECT_TYPE] = multipass.GetType()
new_mpass.SetData(multipass.GetData())
child_rdata.InsertMultipass(new_mpass)
for videopost in ObjectIterator(rd.GetFirstVideoPost()):
new_vpost = c4d.BaseList2D(videopost.GetType())
new_vpost.SetData(videopost.GetData())
child_rdata.InsertVideoPost(new_vpost)
if (type(suffix) == str):
name = '{} {}'.format(child_rdata.GetName(), suffix)
child_rdata.SetName(name)
if (set_active): doc.SetActiveRenderData(child_rdata)
c4d.EventAdd()
doc.EndUndo()
return child_rdata
def create_texture(mat, path):
path = str(path)
path = os.path.abspath(path)
texture = c4d.BaseList2D(c4d.Xbitmap)
texture[c4d.BITMAPSHADER_FILENAME] = path
mat.InsertShader(texture)
return texture
def Load(self, mat, texture_dir, texture):
if not mat or not texture_dir or not texture:
return False
# Split filename at "-", " ", or "_"
chunk_source = texture.lower()
chunk_source = chunk_source.replace("-", "_")
chunk_source = chunk_source.replace(" ", "_")
chunks = chunk_source.split("_")
# See if any of the chunks match existing tokens
is_match = False
for token in self.tokens:
if token in chunks:
is_match = True
break
if not is_match:
return False
# Load texture into Mat
mat[self.channel_id] = True
shader = c4d.BaseList2D(c4d.Xbitmap)
shader[c4d.BITMAPSHADER_FILENAME] = os.path.join(texture_dir, texture)
mat.InsertShader(shader)
mat[self.shader_id] = shader
self.loaded = True
return True
def createUtilityPass(take=None):
''' Create a utility pass version of the passed take. If no take is passed, it will create one
for the main take.'''
doc = c4d.documents.GetActiveDocument()
td = doc.GetTakeData()
parent_rdata = doc.GetActiveRenderData()
# use the main take if none is passed
if (take == None):
take = td.GetMainTake()
# make the take active and create a child render data to attach to it
new_take = core.take('{}_util'.format(take.GetName()), set_active=True)
child_rdata = core.createChildRenderData(parent_rdata, suffix='UTIL', set_active=True)
new_take.SetRenderData(td, child_rdata)
self.clearAllMultipasses()
# modify renderdata for 32-bit exr w/ data passes
render_data = database.getProduction('DEFAULT')
for multipass_id in render_data['passes_util']:
mp_obj = c4d.BaseList2D(c4d.Zmultipass)
mp_obj.GetDataInstance()[c4d.MULTIPASSOBJECT_TYPE] = eval(multipass_id)
child_rdata.InsertMultipass(mp_obj)
for attribute in render_data['image_settings_util']:
child_rdata[eval(attribute)] = render_data['image_settings_util'][attribute]
return (take, child_rdata)
def main():
# Creates a Standard C4D Material
mat = c4d.Material()
if mat is None:
raise RuntimeError("Failed to create a new default material.")
# Creates a bitmap shader
sha = c4d.BaseList2D(c4d.Xbitmap)
if sha is None:
raise RuntimeError("Failed to create a bitmap shader.")
# Defines the path of the bitmap shader
sha[c4d.BITMAPSHADER_FILENAME] = "FileName"
# Defines the material color shader to new created one.
mat[c4d.MATERIAL_COLOR_SHADER] = sha
# Inserts the shader into the material
mat.InsertShader(sha)
# Inserts a material in the active doc
doc.InsertMaterial(mat)
# Pushes an update event to Cinema 4D
c4d.EventAdd()
def fixGenEyes(self, path):
folder_DazToC4D_res = RES_DIR # Adds the res folder to the path
folder_DazToC4D_xtra = os.path.join(
folder_DazToC4D_res, "xtra") # Adds the res folder to the path
file_G3_IrisFixMap = os.path.join(folder_DazToC4D_xtra,
"G3_Iris_Alpha.psd")
destination_G3_IrisFixMap = os.path.join(path, "G3_Iris_Alpha.psd")
try:
copyfile(file_G3_IrisFixMap, destination_G3_IrisFixMap)
except:
print("Iris Map transfer...Skipped.")
doc = c4d.documents.GetActiveDocument()
docMaterials = doc.GetMaterials()
for mat in docMaterials:
if "Iris" in mat.GetName():
matDiffuseMap = ""
try:
matDiffuseMap = mat[c4d.MATERIAL_COLOR_SHADER][
c4d.BITMAPSHADER_FILENAME]
except:
pass
skipThis = False
if "3duG3FTG2_Eyes" in matDiffuseMap:
skipThis = True
if skipThis == False and os.path.exists(
destination_G3_IrisFixMap):
mat[c4d.MATERIAL_USE_ALPHA] = True
shda = c4d.BaseList2D(c4d.Xbitmap)
shda[c4d.BITMAPSHADER_FILENAME] = destination_G3_IrisFixMap
mat[c4d.MATERIAL_ALPHA_SHADER] = shda
mat.InsertShader(shda)
def changeTexture(mat, tex_path, channel=c4d.MATERIAL_COLOR_SHADER):
''' Changes the texture on a material's specified channel. Defaults to the color channel.
C:\Program Files\MAXON\CINEMA 4D R17\resource\modules\c4dplugin\description\mmaterial.h '''
doc = c4d.documents.GetActiveDocument()
if isinstance(mat, str):
for mat_ in MaterialIterator(doc()):
if mat_.GetName() == mat:
mat = mat_
break
if not isinstance(mat, c4d.Material):
return
doc.StartUndo()
if type(channel) == int:
tex = c4d.BaseList2D(c4d.Xbitmap)
doc.AddUndo(c4d.UNDOTYPE_CHANGE, tex)
tex[c4d.BITMAPSHADER_FILENAME] = tex_path
mat[channel] = tex
mat.InsertShader(tex)
elif channel == ('refl' or 'reflection'):
refl_shd = mat.GetAllReflectionShaders()
for rs in refl_shd:
doc.AddUndo(c4d.UNDOTYPE_CHANGE, rs)
rs[c4d.BITMAPSHADER_FILENAME] = tex_path
mat.Message(c4d.MSG_UPDATE)
mat.Update(1, 1)
c4d.EventAdd()
c4d.EndUndo()
return True
def enableObjectBuffer(obid):
''' Insert an object buffer into the active render data, with the passed id'''
doc = c4d.documents.GetActiveDocument()
rd = doc.GetActiveRenderData()
ob = c4d.BaseList2D(c4d.Zmultipass)
ob.GetDataInstance()[c4d.MULTIPASSOBJECT_TYPE] = c4d.VPBUFFER_OBJECTBUFFER
ob[c4d.MULTIPASSOBJECT_OBJECTBUFFER] = obid
rd.InsertMultipass(ob)
c4d.EventAdd()
def makeTextureShader(self, filepath, alpha_only=False):
sha = c4d.BaseList2D(c4d.Xbitmap)
sha[c4d.BITMAPSHADER_FILENAME] = filepath
if alpha_only:
ls = c4d.LayerSet()
ls.SetMode(c4d.LAYERSETMODE_LAYERALPHA)
sha[c4d.BITMAPSHADER_LAYERSET] = ls
return sha
def make_color_shader(first_frame_path, start_frame=0, end_frame=0, fps=30):
color = c4d.BaseList2D(c4d.Xbitmap)
flg = c4d.DESCFLAGS_SET_NONE
color.SetParameter(c4d.BITMAPSHADER_FILENAME, first_frame_path, flg)
color.SetParameter(c4d.BITMAPSHADER_TIMING_FROM, start_frame, flg)
color.SetParameter(c4d.BITMAPSHADER_TIMING_TO, end_frame, flg)
color.SetParameter(c4d.BITMAPSHADER_TIMING_FPS, fps, flg)
color.SetParameter(c4d.BITMAPSHADER_TIMING_TIMING,
c4d.BITMAPSHADER_TIMING_TIMING_FRAME, flg)
return color
def Transparency(material, texture_set_name, texture_path, refraction):
#Local Texture Path
if (texture_path == doc.GetDocumentPath()):
texture_path = ''
else:
texture_path = texture_path + '\\'
#Transparency
material[c4d.MATERIAL_USE_TRANSPARENCY] = 1
material[c4d.MATERIAL_TRANSPARENCY_REFRACTION] = refraction
#Transparency Shader
transparency_shader = c4d.BaseList2D(c4d.Xbitmap)
transparency_shader[c4d.BITMAPSHADER_INTERPOLATION] = 0
transparency_shader[c4d.BITMAPSHADER_COLORPROFILE] = 1
material.InsertShader(transparency_shader)
#Reflection Layer
material.RemoveReflectionLayerIndex(0)
reflection_layer = material.GetReflectionLayerTrans().GetDataID()
#Reflection Settings
material[c4d.REFLECTION_LAYER_MAIN_DISTRIBUTION + reflection_layer] = 3
material[c4d.REFLECTION_LAYER_MAIN_ADDITIVE + reflection_layer] = 2
material[c4d.REFLECTION_LAYER_MAIN_VALUE_SPECULAR + reflection_layer] = 0
material[c4d.REFLECTION_LAYER_MAIN_VALUE_ROUGHNESS + reflection_layer] = 1
#Roughness Shader
roughness_shader = c4d.BaseList2D(c4d.Xbitmap)
roughness_shader[
c4d.
BITMAPSHADER_FILENAME] = texture_path + texture_set_name + '_Glossiness.png'
roughness_shader[c4d.BITMAPSHADER_INTERPOLATION] = 0
roughness_shader[c4d.BITMAPSHADER_COLORPROFILE] = 1
roughness_shader[c4d.BITMAPSHADER_BLACKPOINT] = 1
roughness_shader[c4d.BITMAPSHADER_WHITEPOINT] = 0
material.InsertShader(roughness_shader)
material[c4d.REFLECTION_LAYER_MAIN_SHADER_ROUGHNESS +
reflection_layer] = roughness_shader
return material
def _bmp_shader(doc,
filepath='',
channel=c4d.MATERIAL_LUMINANCE_SHADER,
material=None):
shader = c4d.BaseList2D(c4d.Xbitmap)
material[channel] = shader
shader[c4d.BITMAPSHADER_FILENAME] = str(filepath)
material.InsertShader(shader)
doc.AddUndo(c4d.UNDOTYPE_NEW, shader)
def creer_mat(fn, nom, alpha=False):
mat = c4d.BaseMaterial(c4d.Mmaterial)
mat.SetName(nom)
doc.InsertMaterial(mat)
shd = c4d.BaseList2D(c4d.Xbitmap)
shd[c4d.BITMAPSHADER_FILENAME] = fn
mat[c4d.MATERIAL_COLOR_SHADER] = shd
mat.InsertShader(shd)
mat[c4d.MATERIAL_USE_SPECULAR] = False
if alpha:
mat[c4d.MATERIAL_USE_ALPHA] = True
shda = c4d.BaseList2D(c4d.Xbitmap)
shda[c4d.BITMAPSHADER_FILENAME] = fn
mat[c4d.MATERIAL_ALPHA_SHADER] = shda
mat.InsertShader(shda)
mat.Message(c4d.MSG_UPDATE)
mat.Update(True, True)
return mat
def test_Append(self):
example_list = utilities.create_example_daglist()
new_object = c4d.BaseList2D(c4d.Onull)
new_object.SetName("NewItem_Null")
example_list.Append(dag.DagAtom(new_object))
result = example_list.Get("NewItem_Null").GetName()
result_expected = "NewItem_Null"
self.assertEqual(result, result_expected)
def main():
BaseDraw = doc.GetActiveBaseDraw()
#Add Sketch And Toon if it's not there and required and set up the defaults
if c4d.modules.CheckSketch(): #if Sketch and Toon is installed && it is wanted. set it up and use it (Do the check)
rd = doc.GetActiveRenderData() # Get the current renderdata
vp = rd.GetFirstVideoPost() # Get the first Video Post in the Renderdata object
if vp == None:
SketchEffect = c4d.BaseList2D(1011015) # set a baseList2D with the ID of Sketch and Toon
rd.InsertVideoPost(SketchEffect) #insert the S&T video post
vp = rd.GetFirstVideoPost()
BrowseRD(vp, True) #Run the Function
if vp.GetName() == "Sketch and Toon": #if S&T was found, the rdata name var should be "Sketch and Toon"...
SketchEffect = vp #Set the "SketchEffect" variable to the current S&T
else: #if not, set the "SketchEffect" to a NEW S&T videopost
SketchEffect = c4d.BaseList2D(1011015) # set a baseList2D with the ID of Sketch and Toon
rd.InsertVideoPost(SketchEffect) #insert the S&T video post
SketchEffect[c4d.OUTLINEMAT_SHADING_BACK] = 0
SketchEffect[c4d.OUTLINEMAT_SHADING_OBJECT_MODEL] = 1
gradient=SketchEffect[c4d.OUTLINEMAT_SHADING_GRADQUANT]
print gradient.GetData(c4d.GRADIENT_INTERPOLATION),"ID"
count = 5 #larger than 1!!!!
offset = 1 / float(count)
posOff = 1 / float(count + 1)
gradient.FlushKnots()
for i in range(0,count + 1):
print offset * i
gradient.InsertKnot(c4d.Vector(i * offset), 1.0, posOff * i)
#gradient.InsertKnot()#Vector(i * 10),i * 10,i * 10,0,i)
print gradient.GetKnotCount()
gradient.SetData(c4d.GRADIENT_INTERPOLATION,5)
SketchEffect[c4d.OUTLINEMAT_SHADING_GRADQUANT]=gradient
#Remove Sketch Tags and Replace?
#Make Sketch Mat?
c4d.EventAdd()
def test_Insert(self):
example_list = utilities.create_example_daglist()
new_object = c4d.BaseList2D(c4d.Onull)
new_object.SetName("NewItem_Null")
example_list.Insert(0, dag.DagAtom(new_object))
result = [x.GetName() for x in example_list]
result_expected = ["NewItem_Null"
] + [f"BaseObject_{x}_Null" for x in range(1, 11)]
self.assertListEqual(result, result_expected)
def CreateShader(shaderType, name="Shader"): """ Creates a new C4D Shader. Args: shaderType: The type of the shader. See https://github.com/GeorgeAdamon/pyc4d_helpers/blob/master/useful_tables/Shader%20Types.md [optional] name (str): The name of the Shader. Returns: The shader if succesful, else None """ shader = c4d.BaseList2D(shaderType) shader.SetName(name) return shader
def main():
p = c4d.BaseObject(c4d.Oplane)
p[c4d.PRIM_PLANE_SUBW] = 50
p[c4d.PRIM_PLANE_SUBH] = 50
dis = c4d.BaseObject(1018685)
noise = c4d.BaseList2D(c4d.Xnoise)
noise[c4d.SLA_NOISE_SEED] = r.randrange(100000)
dis[c4d.ID_MG_SHADER_SHADER] = noise
dis.InsertShader(noise)
dis.InsertUnder(p)
red = c4d.BaseObject(c4d.Opolyreduction)
red.InsertUnderLast(p)
f = c4d.BaseObject(c4d.Oformula)
f[c4d.FORMULAOBJECT_EFFECT] = 0
f[c4d.FORMULAOBJECT_FY] = "0"
f.InsertUnderLast(p)
sds = c4d.BaseObject(c4d.Osds)
sds[c4d.SDSOBJECT_SUBRAY_CM] = 1
doc.InsertObject(sds)
p.InsertUnder(sds)
s = c4d.BaseObject(1024529)
s.InsertUnderLast(p)
doc.SetActiveObject(p)
c4d.CallCommand(12233, 12233)
p.Remove()
p = sds.GetDown()
doc.SetActiveObject(p)
c4d.CallCommand(16351)
c4d.CallCommand(13323, 13323)
c4d.CallCommand(12559, 12559)
doc.SetActiveObject(sds)
c4d.CallCommand(12236)
c4d.CallCommand(440000043, 440000043)
c4d.CallCommand(12187)
c4d.CallCommand(13323, 13323)
c4d.CallCommand(12559, 12559)
c4d.CallCommand(12479, 12479)
c4d.CallCommand(12109, 12109)
c4d.EventAdd()
def test_serialize_baselist2d_as_dict(self):
base_object = c4d.BaseList2D(c4d.Onull)
base_object.SetName("Foobar")
result = serialize.serialize_baselist2d_as_dict(base_object)
result_expected = {
"instance_of": "c4d.BaseList2D",
"name": "Foobar",
"type": c4d.Onull,
"data": {},
}
try:
dictutils.assert_is_subset(result_expected, result)
except exceptions.ComparisonBaseError as e:
raise AssertionError(e) from e
def alphaCheck(mat,bm,img,anim,frames,fps):
alphaCheck = bm.GetChannelCount()
### check if image has alpha channel
if alphaCheck > 0:
### Create alpha shader
alpha_texture = c4d.BaseList2D(c4d.Xbitmap)
alpha_texture[c4d.BITMAPSHADER_FILENAME] = img
if anim == True:
alpha_texture[c4d.BITMAPSHADER_TIMING_TO] = frames
alpha_texture[c4d.BITMAPSHADER_TIMING_FPS] = float(fps)
mat[c4d.MATERIAL_ALPHA_SHADER]= alpha_texture
mat.InsertShader(alpha_texture)
doc.AddUndo(c4d.UNDOTYPE_NEW, alpha_texture)
else:
pass
def to_c4d_shader(self, alpha_only=False):
sha = c4d.BaseList2D(c4d.Xbitmap)
sha[c4d.BITMAPSHADER_FILENAME] = self.filepath
if alpha_only:
ls = c4d.LayerSet()
ls.SetMode(c4d.LAYERSETMODE_LAYERALPHA)
sha[c4d.BITMAPSHADER_LAYERSET] = ls
# Barely support texture filtering
if self.sampler.min_filter in (
9728, 9984) or self.sampler.mag_filter in (9728, 9984):
sha[c4d.
BITMAPSHADER_INTERPOLATION] = c4d.BITMAPSHADER_INTERPOLATION_NONE
return sha
def addObjectBuffers(the_buffers, rd):
rd[c4d.RDATA_MULTIPASS_ENABLE] = True # Enable the Multi-Pass option
for ob in the_buffers:
buffer = c4d.BaseList2D(c4d.Zmultipass) # New multipass.
buffer.GetDataInstance(
)[c4d.
MULTIPASSOBJECT_TYPE] = c4d.VPBUFFER_OBJECTBUFFER # Type Object Buffer
buffer.SetName("Object Buffer " + str(ob))
buffer[c4d.MULTIPASSOBJECT_OBJECTBUFFER] = ob
rd.InsertMultipass(buffer)
doc.AddUndo(c4d.UNDOTYPE_NEW, buffer)
rd.Message(c4d.MSG_UPDATE)
c4d.EventAdd()
def _create_texture_node(self, path, sg_publish_data):
"""
Create a file texture node for a texture
:param path: Path to file.
:param sg_publish_data: Shotgun data dictionary with all the standard
publish fields.
:returns: The newly created file node
"""
doc = c4d.documents.GetActiveDocument()
file_node = c4d.BaseList2D(c4d.Xbitmap)
file_node[c4d.BITMAPSHADER_FILENAME] = path
doc.InsertShader(file_node)
c4d.EventAdd()
return file_node
def setRenderToPhysical():
try:
rdata = doc.GetActiveRenderData()
vpost = rdata.GetFirstVideoPost()
rdata[c4d.RDATA_RENDERENGINE] = c4d.RDATA_RENDERENGINE_PHYSICAL
while vpost:
if vpost.CheckType(c4d.VPxmbsampler):
break
vpost = vpost.GetNext()
if not vpost:
vpost = c4d.BaseList2D(c4d.VPxmbsampler)
rdata.InsertVideoPost(vpost)
c4d.EventAdd()
except:
pass
def set_up_translucency(self, mat, prop):
lib = texture_library
if self.is_sss(prop):
doc = c4d.documents.GetActiveDocument()
sss = c4d.BaseList2D(c4d.Xxmbsubsurface)
mat[c4d.MATERIAL_USE_LUMINANCE] = True
mat[c4d.MATERIAL_LUMINANCE_SHADER] = sss
doc.InsertShader(sss)
for prop_name in lib["sss"]["Name"]:
if prop_name in prop.keys():
if prop[prop_name]["Texture"] != "":
path = prop[prop_name]["Texture"]
texture = StdMaterials.create_texture(mat, path)
sss[c4d.XMBSUBSURFACESHADER_SHADER] = texture
for prop_name in lib["sss-color"]["Name"]:
if prop_name in prop.keys():
hex_str = prop[prop_name]["Value"]
hex_str = self.check_value("hex", hex_str)
color = convert_color(hex_str)
vector = c4d.Vector(color[0], color[1], color[2])
sss[c4d.XMBSUBSURFACESHADER_DIFFUSE] = vector
for prop_name in lib["sss-strength"]["Name"]:
if prop_name in prop.keys():
strength = prop[prop_name]["Value"]
strength = self.check_value("float", strength)
sss[c4d.XMBSUBSURFACESHADER_STRENGTH] = (
strength * self.sss_value / 10
)
for prop_name in lib["transmitted-color"]["Name"]:
if prop_name in prop.keys():
hex_str = prop[prop_name]["Value"]
hex_str = self.check_value("hex", hex_str)
color = convert_color(hex_str)
vector = c4d.Vector(color[0], color[1], color[2])
mat[c4d.MATERIAL_LUMINANCE_COLOR] = vector
for prop_name in lib["transmitted-strength"]["Name"]:
if prop_name in prop.keys():
strength = prop[prop_name]["Value"]
strength = self.check_value("float", strength)
mat[c4d.MATERIAL_LUMINANCE_BRIGHTNESS] = strength
def creerTexture(self, relatif=False, win=False):
self.mat = c4d.BaseMaterial(c4d.Mmaterial)
self.doc.InsertMaterial(self.mat)
self.doc.AddUndo(c4d.UNDOTYPE_NEW, self.mat)
shd = c4d.BaseList2D(c4d.Xbitmap)
#ATENTION au backslash suivi de t ou de p cela est consid\r\ comme tab ou
fn = self.fn
if WIN:
fn = self.fn.decode('cp1252').encode('utf-8')
if is_in_doc_path(fn, self.doc):
shd[c4d.BITMAPSHADER_FILENAME] = os.path.basename(fn)
else:
shd[c4d.BITMAPSHADER_FILENAME] = fn
self.mat[c4d.MATERIAL_COLOR_SHADER] = shd
self.mat.InsertShader(shd)
self.mat[c4d.MATERIAL_PREVIEWSIZE] = 12 #taille de pr\visualisation
self.mat.SetName(os.path.basename(fn)[:-4])
self.mat.Message(c4d.MSG_UPDATE)
self.mat.Update(True, True)
def doSetup(self, **overridePlayblastParams):
doc = c4d.documents.GetActiveDocument()
if overridePlayblastParams.get('multilayer'):
destination = "../images/$prj/$take/Main/$take_$prj_Main_"
multilayer = 1
else:
destination = "../images/$prj/$take/$take_$prj"
multilayer = 0
rdata = doc.GetFirstRenderData()
listOfRs = []
while rdata:
rdata = rdata.GetNext()
if rdata:
listOfRs.append(rdata.GetName())
if 'Octane' in overridePlayblastParams.get('engine'):
if 'shotgun_render' not in listOfRs:
rd = c4d.documents.RenderData()
rd_bc = rd.GetDataInstance()
rd_bc[c4d.RDATA_RENDERENGINE] = 1029525
octane_vp = c4d.BaseList2D(1029525)
rd.InsertVideoPost(octane_vp)
c4d.StopAllThreads()
doc.InsertRenderDataLast(rd)
rd.SetName('shotgun_render')
rd[c4d.RDATA_SAVEIMAGE] = 0
doc.SetActiveRenderData(rd)
OctaneRenderer = rd.GetFirstVideoPost()
OctaneRenderer[c4d.SET_PASSES_ENABLED] = 1
OctaneRenderer[c4d.SET_PASSES_SAVE_MAINPASS] = 1
OctaneRenderer[c4d.SET_PASSES_SAVEPATH] = destination
OctaneRenderer[c4d.SET_PASSES_MULTILAYER] = multilayer
OctaneRenderer[c4d.SET_PASSES_MAKEFOLDER] = 1
OctaneRenderer[c4d.SET_PASSES_EXR_COMPR] = 3
c4d.EventAdd()
def specificFiguresFixes(self):
doc = c4d.documents.GetActiveDocument()
figureModel = ""
def findMatName(matToFind):
matFound = None
sceneMats = doc.GetMaterials()
for mat in sceneMats:
matName = mat.GetName()
if matToFind in matName:
matFound = mat
return matFound
return matFound
# TOON GENERATION 2
doc = documents.GetActiveDocument()
sceneMats = doc.GetMaterials()
# ZOMBIE ... GEN3...
if findMatName("Cornea") != None and findMatName(
"EyeMoisture") == None:
mat = findMatName("Cornea")
mat[c4d.MATERIAL_USE_ALPHA] = False
for mat in sceneMats:
matName = mat.GetName()
if "Eyelashes" in matName:
if mat[c4d.MATERIAL_ALPHA_SHADER] == None:
try:
shaderColor = c4d.BaseList2D(
c4d.Xcolor
) # create a bitmap shader for the material
mat.InsertShader(shaderColor)
mat[c4d.MATERIAL_USE_ALPHA] = True
mat[c4d.MATERIAL_ALPHA_SHADER] = shaderColor
mat[c4d.MATERIAL_ALPHA_SHADER][
c4d.COLORSHADER_BRIGHTNESS] = 0.0
except:
pass
c4d.EventAdd()
def materialShader(mat,img,anim,frame,fps,coloverride):
shdr_texture = c4d.BaseList2D(c4d.Xbitmap)
shdr_texture[c4d.BITMAPSHADER_FILENAME] = img
if coloverride == True:
mat[c4d.MATERIAL_COLOR_SHADER]= shdr_texture
else:
mat[c4d.MATERIAL_LUMINANCE_SHADER]= shdr_texture
if anim == True:
shdr_texture[c4d.BITMAPSHADER_TIMING_TO] = frame
shdr_texture[c4d.BITMAPSHADER_TIMING_FPS] = float(fps)
mat.InsertShader(shdr_texture)
#create bitmap
bm = c4d.bitmaps.BaseBitmap()
bm.InitWith(img)
getsize = bm.GetSize()
x = getsize[0]
y = getsize[1]
alphaCheck(mat,bm,img,anim,frame,fps)
bmSize = [x,y]
doc.AddUndo(c4d.UNDOTYPE_NEW, shdr_texture)
return bmSize
