def main(): # Checks if selected object is valid if op is None: raise ValueError("op is none, please select one object.") # Creates a default Cinema 4D Material, the created material only exist in the memory mat = c4d.BaseMaterial(c4d.Mmaterial) if mat is None: raise RuntimeError("Failed to create a new BaseMaterial.") # Inserts the material in the active document doc.InsertMaterial(mat) # Checks if there is already a texture tag on the active object, if not creates it textureTag = op.GetTag(c4d.Ttexture) if not textureTag: textureTag = op.MakeTag(c4d.Ttexture) # If the texture tag is not available at this point, something went wrong if textureTag is None: raise RuntimeError("Failed to retrieve the texture tag.") # Links the newly created material from the textureTag Material link parameter textureTag[c4d.TEXTURETAG_MATERIAL] = mat # Pushes an update event to Cinema 4D c4d.EventAdd()
def create_standard_environment(doc, name, filepath): doc.StartUndo() # Create our Material for Sky Object mat = c4d.BaseMaterial(c4d.Mmaterial) mat.SetName(name) mat[c4d.MATERIAL_USE_COLOR] = False mat[c4d.MATERIAL_USE_LUMINANCE] = True mat[c4d.MATERIAL_USE_REFLECTION] = False mat[c4d.MATERIAL_PREVIEWSIZE] = c4d.MATERIAL_PREVIEWSIZE_1024 _bmp_shader(doc, filepath, c4d.MATERIAL_LUMINANCE_SHADER, mat) doc.InsertMaterial(mat) doc.AddUndo(c4d.UNDOTYPE_NEW, mat) # mat.Message(c4d.MSG_UPDATE) # mat.Update(True, True) # Create Sky Object sky = c4d.BaseObject(c4d.Osky) sky.SetName(name) doc.InsertObject(sky) doc.AddUndo(c4d.UNDOTYPE_NEW, sky) # Create Texture Tag and set our Material tag = c4d.BaseTag(c4d.Ttexture) sky.InsertTag(tag) tag.SetMaterial(mat) doc.AddUndo(c4d.UNDOTYPE_NEW, tag) doc.EndUndo() c4d.EventAdd()
def main(): doc.StartUndo() folder = s.LoadDialog(c4d.FILESELECTTYPE_ANYTHING, 'Select image folder', c4d.FILESELECT_DIRECTORY, '') if not folder: return files = os.listdir(folder) for f in files: mat = c4d.BaseMaterial(c4d.Mmaterial) mat[c4d.MATERIAL_USE_REFLECTION] = 0 mat[c4d.MATERIAL_USE_ALPHA] = 1 shd = c4d.BaseShader(c4d.Xbitmap) shd[c4d.BITMAPSHADER_FILENAME] = folder + "\\" + f alpha = c4d.BaseShader(c4d.Xbitmap) alpha[c4d.BITMAPSHADER_FILENAME] = folder + "\\" + f mat[c4d.MATERIAL_COLOR_SHADER] = shd mat[c4d.MATERIAL_ALPHA_SHADER] = alpha mat.InsertShader(shd) mat.InsertShader(alpha) mat.Message(c4d.MSG_UPDATE) mat.Update(True, True) doc.InsertMaterial(mat) doc.AddUndo(c4d.UNDOTYPE_NEW, mat) c4d.EventAdd() doc.EndUndo()
def CreateMaterials(rootShaders, displacements, links): # {ArnoldNode: GvNode} shaderMap = {} for i, rootShader in enumerate(rootShaders): if not rootShader or not rootShader.IsValid(): continue rootShaderType = rootShader.GetNodeEntryName() rootShaderName = rootShader.GetName() PrintInfo("Create material for %s (%s)" % (rootShaderName, rootShaderType)) # create material mat = c4d.BaseMaterial(ARNOLD_SHADER_NETWORK) if mat is None: PrintError("Failed to create material") continue mat.SetName("ASN_%02d" % (i + 1)) doc.InsertMaterial(mat) # create root shader rootShaderNode = shaderMap.get(rootShader) if rootShaderNode is None: rootShaderNode = CreateShader(mat, rootShader, BEAUTY_ROOT_POSX, BEAUTY_ROOT_POSY) if rootShaderNode is None: PrintError("Failed to create shader %s (%s)" % (rootShaderName, rootShaderType)) continue shaderMap[rootShader] = rootShaderNode SetRootShader(mat, rootShaderNode, ARNOLD_BEAUTY_PORT_ID) # create links CreateLinks(mat, rootShader, links, shaderMap, BEAUTY_ROOT_POSX, BEAUTY_ROOT_POSY, True) # displacement root dispRootShader = displacements.get(rootShader) if dispRootShader and dispRootShader.IsValid(): dispRootShaderType = dispRootShader.GetNodeEntryName() dispRootShaderName = dispRootShader.GetName() PrintInfo("Add displacement") dispRootShaderNode = shaderMap.get(dispRootShader) if dispRootShaderNode is None: dispRootShaderNode = CreateShader(mat, dispRootShader, DISPLACEMENT_ROOT_POSX, DISPLACEMENT_ROOT_POSY) if dispRootShaderNode is None: PrintError( "Failed to create displacement shader %s (%s)" % dispRootShaderName, dispRootShaderType) continue shaderMap[dispRootShader] = dispRootShaderNode SetRootShader(mat, dispRootShaderNode, ARNOLD_DISPLACEMENT_PORT_ID) # displacement links CreateLinks(mat, dispRootShader, links, shaderMap, DISPLACEMENT_ROOT_POSX, DISPLACEMENT_ROOT_POSY, False)
def SetMatProperty(matName, value, targetId, targetDoc): DebugPrint(' -> Inserting "' + str(value) + '" as "' + MTL_KEYWORDS_NAMES[targetId] + '" of material "' + matName + '".') mat = targetDoc.SearchMaterial(matName) # If material not found, create it if mat == None: mat = c4d.BaseMaterial(c4d.Mmaterial) mat.SetName(matName) targetDoc.InsertMaterial(mat) # Cancel if material could not be found or created if mat == None: DebugPrint( ' ERROR: COULD NEITHER FIND NOR ALLOCATE TARGET MATERIAL!') return # Add undo targetDoc.AddUndo(c4d.UNDOTYPE_CHANGE, mat) # Set property mat[targetId] = value * MTL_KEYWORDS_MUL[targetId] # Activate channel mat[MTL_KEYWORDS_USE[targetId]] = True if targetId == c4d.MATERIAL_SPECULAR_WIDTH: if value == 0.0: mat[MTL_KEYWORDS_USE[targetId]] = False DebugPrint('Turning Spec off cuz 0 width') # Update material mat.Update(True, True)
def CreateMaterialForNodeSpace(nodespaceId): # Create a baseMaterial first mat = c4d.BaseMaterial(c4d.Mmaterial) if mat is None: raise ValueError("Cannot create a BaseMaterial.") # Retrieve the reference of the material as a node material. nodeMaterial = mat.GetNodeMaterialReference() if nodeMaterial is None: raise ValueError("Cannot retrieve nodeMaterial reference.") # Add a graph for the space Id addedGraph = nodeMaterial.AddGraph(nodespaceId) if addedGraph is None: raise ValueError("Cannot add a GraphNode for this NodeSpace.") # Retrieve the Nimbus reference for a specific NodeSpace nimbusRef = mat.GetNimbusRef(nodespaceId) if nimbusRef is None: raise ValueError( "Cannot retrieve the nimbus reference for that NodeSpace.") # Retrieve the graph corresponding to that NodeSpace. graph = nimbusRef.GetGraph() if graph is None: raise ValueError("Cannot retrieve the graph of this nimbus NodeSpace.") # Retrieve the root of the graph root = graph.GetRoot() # Insert the material in the document doc.InsertMaterial(mat) return root
def CreateC4DMaterial(self): # create a standard C4D material newMaterial = c4d.BaseMaterial(c4d.Mmaterial) newMaterial.SetName(self.materialName) return newMaterial
def CreateVRayMaterial(self): # create a VRay material newMaterial = c4d.BaseMaterial(VrayAdvancedMaterial) newMaterial.SetName(self.materialName) if self.diffuseEnabled: pass if self.specularEnabled: pass if self.refractionEnabled: pass if self.opacityEnabled: pass if self.emissionEnabled: pass if self.bumpEnabled: pass return newMaterial
def CreateOctaneMaterial(self): # create an octane material newMaterial = c4d.BaseMaterial(ID_OCTANE_DIFFUSE_MATERIAL) newMaterial[OCT_MATERIAL_TYPE] = 2516 # universal material newMaterial.SetName(self.materialName) return newMaterial
def main(): # Retrieves active material mat = doc.GetActiveMaterial() if mat is None: return # Checks active material is a standard material if not mat.IsInstanceOf(c4d.Mmaterial): return # The active material's color color = mat.GetParameter(c4d.MATERIAL_COLOR_COLOR, c4d.DESCFLAGS_GET_0) if color is None: return # Calculates the complementary color res = cc.ColorHarmonyGetComplementary(color, False) # Retrieves the complementary color complementaryColor = res[1] # Creates a new material with complementary color complementaryMat = c4d.BaseMaterial(c4d.Mmaterial) if complementaryMat is None: return # Sets the complementary color as material's color complementaryMat.SetParameter(c4d.MATERIAL_COLOR_COLOR, complementaryColor, c4d.DESCFLAGS_SET_0) #Inserts the material with complementary color into the active document doc.InsertMaterial(complementaryMat) c4d.EventAdd()
def importVox(path): #parse file with open(path, 'rb') as f: #check filetype bytes = f.read(4) file_id = struct.unpack(">4s", bytes) if file_id[0] == 'VOX ': #init material list matlist = [] BaseCube = c4d.BaseObject(c4d.Ocube) BaseCube[c4d.PRIM_CUBE_DOFILLET] = True BaseCube[c4d.PRIM_CUBE_FRAD] = 8 BaseCube[c4d.PRIM_CUBE_SUBF] = 1 doc.InsertObject(BaseCube) #skip header f.seek(56) #read number of voxels, stuct.unpack parses binary data to variables bytes = f.read(4) numvoxels = struct.unpack('<I', bytes) #iterate through voxels for x in range(0, numvoxels[0]): #read voxels, ( each voxel : 1 byte x 4 : x, y, z, colorIndex ) x numVoxels bytes = f.read(4) voxel = struct.unpack('<bbbB', bytes) #generate Cube and set position, change to 'Oinstance' for instances MyCube = c4d.BaseObject(c4d.Oinstance) MyCube[c4d.INSTANCEOBJECT_RENDERINSTANCE] = True MyCube[c4d.INSTANCEOBJECT_LINK] = BaseCube MyCube.SetAbsPos( c4d.Vector(-voxel[1] * 200, voxel[2] * 200, voxel[0] * 200)) #update material list, generate new material only if it isn't in the list yet matid = voxel[3] if matid not in matlist: matlist.append(matid) myMat = c4d.BaseMaterial(c4d.Mmaterial) myMat.SetName(str(matid)) myMat[c4d.MATERIAL_COLOR_COLOR] = c4d.Vector( random.random(), random.random(), random.random()) doc.InsertMaterial(myMat) #assign material to voxel and insert everything into the scene mat = doc.SearchMaterial(str(matid)) textag = c4d.TextureTag() textag.SetMaterial(mat) MyCube.InsertTag(textag) doc.InsertObject(MyCube) else: gui.MessageDialog('Not a .VOX file')
def convertMat(self, sourceMat, matType="Std"): self.matType = matType print("----- Converting : " + sourceMat.GetName() + " -----") matName = sourceMat.GetName() mat = None if matType == "Std": mat = c4d.BaseMaterial(5703) self.MatNameAdd = "_STD" elif matType == "Vray": mat = c4d.BaseMaterial(1038954) self.MatNameAdd = "_VR" elif matType == "Redshift": mat = RedshiftMaterial() self.MatNameAdd = "_RS" elif matType == "Octane": mat = c4d.BaseMaterial(1029501) self.MatNameAdd = "_OCT" elif matType == "Corona": mat = c4d.BaseMaterial(1032100) self.MatNameAdd = "_CRNA" mat.SetName(matName + self.MatNameAdd) self.NewMatList.append([sourceMat, mat]) self.convertShader(sourceMat, mat) if mat == None: return False mat.Message(c4d.MSG_UPDATE) mat.Update(True, True) doc = c4d.documents.GetActiveDocument() doc.InsertMaterial(mat) c4d.EventAdd() print("----- Converted : " + matName + " : " + mat.GetName() + " -----") bc = c4d.BaseContainer() c4d.gui.GetInputState(c4d.BFM_INPUT_MOUSE, c4d.BFM_INPUT_CHANNEL, bc) return True
def matbasecontainercopy(): mat = doc.GetActiveMaterial() bc = mat.GetData() newmat = c4d.BaseMaterial(ARNOLD_SHADER_NETWORK) newmat.SetData(bc, add=False) doc.InsertMaterial(newmat) c4d.EventAdd()
def _byplay_plane_material(self): name = u"Byplay Plane" for mat in self.doc.GetMaterials(): if mat.GetName() == name: return mat mat = c4d.BaseMaterial(c4d.Mshadowcatcher) mat.SetName(name) self.doc.InsertMaterial(mat) return mat
def main(): # Defines the initials state of the scene (the state that will be restored if the user do an "Undo") doc.StartUndo() # Creates few objects, tag, material to be inserted into the document later null = c4d.BaseObject(c4d.Onull) cube = c4d.BaseObject(c4d.Ocube) textureTag = c4d.BaseTag(c4d.Ttexture) mat = c4d.BaseMaterial(c4d.Mmaterial) if null is None or cube is None or textureTag is None or mat is None: raise RuntimeError( "Failed to create null or cube or textureTag or mat") # Inserts a Material into the active document doc.InsertMaterial(mat) doc.AddUndo(c4d.UNDOTYPE_NEW, mat) # Inserts both objects doc.InsertObject(null) doc.AddUndo(c4d.UNDOTYPE_NEW, null) # Inserts both objects doc.InsertObject(cube) doc.AddUndo(c4d.UNDOTYPE_NEW, cube) # Inserts the Texture Tag to the cube object cube.InsertTag(textureTag) doc.AddUndo(c4d.UNDOTYPE_NEW, textureTag) # Defines the material used in the Texture Tag to our material doc.AddUndo(c4d.UNDOTYPE_CHANGE, textureTag) textureTag[c4d.TEXTURETAG_MATERIAL] = mat # Ends the first Undo step, so when the user will press Undo 1 time the document will be restored to this scene state. doc.EndUndo() # Defines another Undo step (so if the user want to go to the initial state he have to press Undo twice) doc.StartUndo() # Moves the cube object under the Null Object doc.AddUndo(c4d.UNDOTYPE_HIERARCHY_PSR, cube) cube.Remove() cube.InsertUnderLast(null) # Delete the Texture Tag doc.AddUndo(c4d.UNDOTYPE_DELETE, textureTag) textureTag.Remove() # Defines the final state of the scene doc.EndUndo() # Pushes an update event to Cinema 4D c4d.EventAdd()
def main(): eazymat = doc.GetActiveMaterial() if not eazymat: newmat = c4d.BaseMaterial(5703) doc.InsertMaterial(newmat) doc.AddUndo(c4d.UNDOTYPE_NEW, newmat) c4d.EventAdd() newmat[c4d.MATERIAL_COLOR_COLOR] = randomColor() newmat.SetBit(c4d.BIT_ACTIVE) if eazymat: eazymat[c4d.MATERIAL_COLOR_COLOR] = randomColor()
def CreateArnoldMaterial(self): # create an Arnold Shader Network newMaterial = c4d.BaseMaterial(ARNOLD_SHADER_NETWORK) newMaterial.SetName(self.materialName) # crete and attach Arnold Standard Shader rootShader = CreateArnoldShader(self.newMaterial, C4DAIN_STANDARD_SURFACE, 0, 50) SetRootShader(newMaterial, rootShader, ARNOLD_BEAUTY_PORT_ID) return newMaterial
def InsertTexture(fBase, fName, matName, targetId, targetDoc , flipNormalY): DebugPrint(' -> Inserting "' + fName + '" into channel "' + MTL_KEYWORDS_NAMES[targetId] + '" of material "' + matName + '".') mat = targetDoc.SearchMaterial(matName) # If material not found, create it if mat == None: mat = c4d.BaseMaterial(c4d.Mmaterial) mat.SetName(matName) targetDoc.AddUndo(c4d.UNDOTYPE_NEW, mat) targetDoc.InsertMaterial(mat) # Cancel if material could not be found or created if mat == None: DebugPrint(' ERROR: COULD NEITHER FIND NOR ALLOCATE TARGET MATERIAL!') return # Create a new bitmap shader, insert texture tShader = c4d.BaseShader(c4d.Xbitmap) if tShader == None: DebugPrint(' ERROR: COULD NOT ALLOCATE BITMAP SHADER!') return fSlash = '/' fPath = str(fBase) + str(fSlash) + str(fName) tShader[c4d.BITMAPSHADER_FILENAME] = fPath # # Add undo targetDoc.AddUndo(c4d.UNDOTYPE_CHANGE, mat) # Activate channel mat[MTL_KEYWORDS_USE[targetId]] = True # Insert texture into channel mat[targetId] = tShader # Insert shader into node tree mat.InsertShader(tShader) # Special cases if targetId == c4d.MATERIAL_ALPHA_SHADER: # If we set an alpha map and the format is PNG of TIFF, it's likely to have an alpha channel, so we switch off "Image Alpha" if fName.endswith(('.tif','.tiff','.png','.tga')): mat[c4d.MATERIAL_ALPHA_IMAGEALPHA] = False #flip normals if needed if flipNormalY == 1: mat[c4d.MATERIAL_NORMAL_REVERSEY] = True # Update material mat.Update(True, True)
def _create_bg(self): bg_obj = create_object(self.doc, u"Background {}".format(self.recording_id), c4d.Obackground) bg_mat = c4d.BaseMaterial(c4d.Mmaterial) assign_shader_color( bg_mat, make_color_shader( self.recording_storage.first_frame_path(self.recording_id), 1, self.frame_count, self.fps)) assign_material_frontal(self.doc, bg_obj, bg_mat) bg_mat.SetName(bg_obj.GetName()) return bg_mat
def _create_sky(self, path): sky_obj = create_object(self.doc, u"Sky {}".format(self.recording_id), c4d.Osky) sky_mat = c4d.BaseMaterial(c4d.Mmaterial) assign_shader_luminance(sky_mat, make_color_shader(path)) assign_material_spherical(self.doc, sky_obj, sky_mat) sky_mat.SetName(sky_obj.GetName()) sky_mat.SetChannelState(c4d.CHANNEL_COLOR, False) sky_mat.SetChannelState(c4d.CHANNEL_LUMINANCE, True) sky_obj[c4d.ID_BASEOBJECT_VISIBILITY_EDITOR] = c4d.OBJECT_OFF comp_tag = self._add_compositing(sky_obj) comp_tag[c4d.COMPOSITINGTAG_SEENBYCAMERA] = False return sky_obj
def createMaterial(name=None, color=None): ''' Create a new material. ''' doc = c4d.documents.GetActiveDocument() mat = c4d.BaseMaterial(c4d.Mmaterial) doc.StartUndo() doc.InsertMaterial(mat) if (name): mat.SetName(name) if (color): changeColor(mat, color) doc.AddUndo(c4d.UNDOTYPE_NEW, mat) c4d.EventAdd() doc.EndUndo() return mat
def main(): fn = s.LoadDialog(c4d.FILESELECTTYPE_ANYTHING, "Select reference file", c4d.FILESELECT_LOAD) if fn == None: return None res = g.InputDialog("Resolution", "1280x720") width = float(res.split("x")[0]) height = float(res.split("x")[1]) ren = doc.GetActiveRenderData() zpos = ren[c4d.RDATA_XRES_VIRTUAL] c4d.CallCommand(12544) # Create new viewport bd = doc.GetActiveBaseDraw() cam = c4d.BaseObject(c4d.Ocamera) cam.SetName("REFERENCE_CAMERA") cam[c4d.CAMERAOBJECT_TARGETDISTANCE] = width cam[c4d.ID_BASEOBJECT_VISIBILITY_RENDER] = 2 doc.InsertObject(cam) plane = c4d.BaseObject(c4d.Oplane) plane[c4d.ID_BASEOBJECT_VISIBILITY_RENDER] = 2 plane.SetName("REFERENCE_PLANE") plane[c4d.PRIM_AXIS] = 5 plane[c4d.PRIM_PLANE_SUBW] = 1 plane[c4d.PRIM_PLANE_SUBH] = 1 plane[c4d.PRIM_PLANE_WIDTH] = width plane[c4d.PRIM_PLANE_HEIGHT] = height plane[c4d.ID_BASEOBJECT_REL_POSITION, c4d.VECTOR_Z] = zpos plane.InsertUnder(cam) mat = c4d.BaseMaterial(c4d.Mmaterial) mat.SetName("REFERENCE_MATERIAL") mat[c4d.MATERIAL_USE_REFLECTION] = 0 mat[c4d.MATERIAL_ANIMATEPREVIEW] = 1 color = c4d.BaseShader(c4d.Xbitmap) color[c4d.BITMAPSHADER_FILENAME] = fn doc.ExecutePasses(None, 0, 1, 1, 0) c4d.CallButton(color, c4d.BITMAPSHADER_CALCULATE) mat[c4d.MATERIAL_COLOR_SHADER] = color mat.InsertShader(color) mat.Message(c4d.MSG_UPDATE) mat.Update(True, True) doc.InsertMaterial(mat) t = c4d.BaseTag(5616) plane.InsertTag(t) tag = plane.GetFirstTag() tag[c4d.TEXTURETAG_MATERIAL] = mat tag[c4d.TEXTURETAG_PROJECTION] = 6 bd[c4d.BASEDRAW_DATA_TINTBORDER_OPACITY] = 1 bd[c4d.BASEDRAW_DATA_CAMERA] = cam bd[c4d.BASEDRAW_TITLE] = "REFERENCE_VIEWPORT" cam[c4d.ID_BASEOBJECT_REL_POSITION, c4d.VECTOR_X] = 5000000 c4d.EventAdd()
def Material(img,coloverride): #create material mat = c4d.BaseMaterial(5703) if coloverride == True: mat[c4d.MATERIAL_USE_COLOR] = True mat[c4d.MATERIAL_USE_LUMINANCE] = False else: mat[c4d.MATERIAL_USE_COLOR] = False mat[c4d.MATERIAL_USE_LUMINANCE] = True mat[c4d.MATERIAL_USE_ALPHA] = True mat[c4d.MATERIAL_USE_REFLECTION] = False mat[c4d.MATERIAL_PREVIEWSIZE] = + 12 mat[c4d.MATERIAL_ANIMATEPREVIEW] = True doc.AddUndo(c4d.UNDOTYPE_NEW, mat) doc.InsertMaterial(mat) return mat
def main(): # Create a baseMaterial first mat = c4d.BaseMaterial(c4d.Mmaterial) if mat is None: raise ValueError("Cannot create a BaseMaterial") # Retrieve the reference of the material as a node Material nodeMaterial = mat.GetNodeMaterialReference() if nodeMaterial is None: raise ValueError("Cannot retrieve nodeMaterial reference") # Retrieve the current node space Id nodespaceId = c4d.GetActiveNodeSpaceId() # Add a graph for the space Id addedGraph = nodeMaterial.AddGraph(nodespaceId) if addedGraph is None: raise ValueError("Cannot add a graphnode for this nodespace") # Retrieve the Nimbus reference for a specific node space nimbusRef = mat.GetNimbusRef(nodespaceId) if nimbusRef is None: raise ValueError("Cannot retrieve the nimbus ref for that node space") # Retrieve the graph corresponding to that node space graph = nimbusRef.GetGraph() if graph is None: raise ValueError("Cannot retrieve the graph of this nimbus ref") # Retrieve the end node of this graph endNodePath = nimbusRef.GetPath( maxon.frameworks.nodespace.NIMBUS_PATH.MATERIALENDNODE) # Solo the end node nimbusRef.SetPath(maxon.frameworks.nodespace.NIMBUS_PATH.SOLO, endNodePath) # Retrieve the solo node of this graph soloNodePath = nodeMaterial.GetSoloNodePath(nodespaceId) print(endNodePath == soloNodePath) # Insert the material In the document doc.InsertMaterial(mat) # Pushes an update event to Cinema 4D c4d.EventAdd()
def create_octane_specular_material(material): mat = c4d.BaseMaterial(constants.ID_OCTANE_DIFFUSE_MATERIAL) mat[c4d.OCT_MATERIAL_TYPE] = constants.ID_OCTANE_SPECULAR_TYPE projection = create_octane_projection() for material_type, texture_path in material.get_paths().items(): is_float = material_parser.PARSER_DATA[material_type].is_float() shader = None if material_type is constants.DISPLACEMENT: shader = create_octane_displacement(texture_path, projection) else: shader = create_octane_image_texture(texture_path, is_float, material_type == constants.GLOSS, projection) mat[material_parser.PARSER_DATA[material_type].get_material_id()] = shader mat.InsertShader(shader) mat.SetName(material.get_name()) return mat
def main(): doc.StartUndo() folder = s.LoadDialog(c4d.FILESELECTTYPE_ANYTHING, 'Select image folder', c4d.FILESELECT_DIRECTORY, '') if not folder: return files = os.listdir(folder) for f in files: mat = c4d.BaseMaterial(c4d.Mmaterial) path = folder + "\\" + f # enable or disable channels mat[c4d.MATERIAL_USE_REFLECTION] = 0 mat[c4d.MATERIAL_USE_LUMINANCE] = 1 mat[c4d.MATERIAL_USE_ALPHA] = 1 # color channel color = c4d.BaseShader(c4d.Xbitmap) color[c4d.BITMAPSHADER_FILENAME] = path mat[c4d.MATERIAL_COLOR_SHADER] = color # luminance channel luminance = c4d.BaseShader(c4d.Xbitmap) luminance[c4d.BITMAPSHADER_FILENAME] = path mat[c4d.MATERIAL_LUMINANCE_SHADER] = luminance # alpha channel alpha = c4d.BaseShader(c4d.Xbitmap) alpha[c4d.BITMAPSHADER_FILENAME] = path mat[c4d.MATERIAL_ALPHA_SHADER] = alpha # assign shaders to material mat.InsertShader(color) mat.InsertShader(luminance) mat.InsertShader(alpha) # other stuff mat.Message(c4d.MSG_UPDATE) mat.Update(True, True) matname = f.split(".")[0] mat.SetName(matname) doc.InsertMaterial(mat) doc.AddUndo(c4d.UNDOTYPE_NEW, mat) c4d.EventAdd() doc.EndUndo()
def main(): doc = c4d.documents.GetActiveDocument() # Get active Cinema 4D document doc.StartUndo() # Start recording undos folder = s.LoadDialog(c4d.FILESELECTTYPE_ANYTHING, 'Select image folder', c4d.FILESELECT_DIRECTORY, '') if not folder: return try: # Try to execute following script files = os.listdir(folder) for f in files: # Loop through files mat = c4d.BaseMaterial(c4d.Mmaterial) path = folder + "\\" + f mat[c4d.MATERIAL_USE_REFLECTION] = 0 # Disable reflection channel # Color channel color = c4d.BaseShader(c4d.Xbitmap) color[c4d.BITMAPSHADER_FILENAME] = path mat[c4d.MATERIAL_COLOR_SHADER] = color # Luminance channel luminance = c4d.BaseShader(c4d.Xbitmap) luminance[c4d.BITMAPSHADER_FILENAME] = path mat[c4d.MATERIAL_LUMINANCE_SHADER] = luminance # Alpha channel alpha = c4d.BaseShader(c4d.Xbitmap) alpha[c4d.BITMAPSHADER_FILENAME] = path mat[c4d.MATERIAL_ALPHA_SHADER] = alpha # Assign shaders to material mat.InsertShader(color) # Insert shader to color channel mat.InsertShader(luminance) # Insert shader to luminance channel mat.InsertShader(alpha) # Insert shader to alpha channel # Other stuff mat.Message(c4d.MSG_UPDATE) mat.Update(True, True) # Update material matname = f.split(".")[0] # Get material name from file path mat.SetName(matname) # Set material name doc.InsertMaterial(mat) # Insert new material to document doc.AddUndo(c4d.UNDOTYPE_NEW, mat) # Add undo command for inserting new material except: # If something went wrong pass # Do nothing doc.EndUndo() # Stop recording undos c4d.EventAdd() # Refresh Cinema 4D
def main(): doc.StartUndo() hexcolor = c4d.gui.InputDialog("HEX-color") rgb = hex_to_rgb(hexcolor) color = c4d.Vector( float(rgb[0]) / 255, float(rgb[1]) / 255, float(rgb[2]) / 255) mat = c4d.BaseMaterial(c4d.Mmaterial) mat[c4d.MATERIAL_COLOR_COLOR] = color mat.Message(c4d.MSG_UPDATE) mat.Update(True, True) mat.SetName(str(hexcolor)) doc.InsertMaterial(mat) doc.AddUndo(c4d.UNDOTYPE_NEW, mat) c4d.EventAdd() doc.EndUndo()
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 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