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