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 makeVrayShader(slotName, bmpPath): # With Bitmap found: bmpShader = c4d.BaseShader(1026701) bmpShader[c4d.VRAY_SHADERS_LIST] = 10 # Set as Bitmap Shader bc = bmpShader.GetData() # bc[89981968] = 2 # Sets to sRGB but no - leave as default. bc.SetFilename(4999, bmpPath) bmpShader.SetData(bc) mat.InsertShader(bmpShader) if slotName == "diffuse": mat[c4d.VRAYSTDMATERIAL_DIFFUSECOLOR_TEX] = bmpShader if slotName == "mapRough": mat[c4d.VRAYSTDMATERIAL_REFLECTGLOSSINESS_TEX] = bmpShader if slotName == "bump": mat[c4d.VRAYSTDMATERIAL_BUMP_BUMPMAP] = bmpShader try: mat[c4d.VRAYSTDMATERIAL_BUMP_BUMPMAP_MULT] = 0.2 except: pass if slotName == "mapAlpha": mat[c4d.VRAYSTDMATERIAL_OPACITY_TEX] = bmpShader if slotName == "mapSpec": mat[c4d.VRAYSTDMATERIAL_REFLECTCOLOR] = c4d.Vector( 0.0, 0.0, 0.0) mat[c4d.VRAYSTDMATERIAL_REFLECTGLOSSINESS] = 0.7 mat[c4d.VRAYSTDMATERIAL_REFLECTFRESNELIOR_LOCK] = False mat[c4d.VRAYSTDMATERIAL_REFLECTCOLOR_TEX] = bmpShader try: mat[c4d.VRAYSTDMATERIAL_REFLECTCOLOR_TEX][ 107820085] = True # ALPHA_FROM_INTENSITY except: pass
def make_vertex_colors_layer(self, mat, colortag): vtxcolorshader = c4d.BaseShader(1011137) vtxcolorshader.SetParameter(c4d.SLA_DIRTY_VMAP_OBJECT, colortag, c4d.DESCFLAGS_GET_NONE) if not mat.GetParameter(c4d.MATERIAL_COLOR_SHADER, c4d.DESCFLAGS_SET_NONE): mat.SetParameter(c4d.MATERIAL_COLOR_SHADER, vtxcolorshader, c4d.DESCFLAGS_SET_NONE) # check if vertex color already enabled: if not colortag or mat.GetReflectionLayerIndex( 0).GetName() == 'Vertex Colors': return vtx_color_diffuse = mat.AddReflectionLayer() vtx_color_diffuse.SetFlags(c4d.REFLECTION_FLAG_NONE) vtx_color_diffuse.SetName("Vertex Colors") vtxcolorid = vtx_color_diffuse.GetDataID() mat.SetParameter(vtxcolorid + c4d.REFLECTION_LAYER_ENABLED, False, c4d.DESCFLAGS_SET_NONE) refid = vtxcolorid + c4d.REFLECTION_LAYER_MAIN_DISTRIBUTION mat.SetParameter(refid, c4d.REFLECTION_DISTRIBUTION_LAMBERTIAN, c4d.DESCFLAGS_SET_NONE) mat.SetParameter(vtxcolorid + c4d.REFLECTION_LAYER_COLOR_TEXTURE, vtxcolorshader, c4d.DESCFLAGS_SET_NONE) mat.InsertShader(vtxcolorshader)
def first(mats): # collect each material for m in mats: try: m[c4d.OCT_MATERIAL_OPACITY_LINK].GetName() except AttributeError: pass else: if m[c4d.OCT_MATERIAL_OPACITY_LINK].GetName() == "ImageTexture": continue shaders = None shaders = collectShaders(m.GetFirstShader(), shaders) # Get each node in collection for node in shaders: if node.GetName() == "ImageTexture": diffuse = getName(node, "ImageTexture") continue elif node.GetName() == "ColorCorrection": if node.GetDown() in shaders: shaders.remove(node.GetDown()) node.GetDown().Remove() node.Remove() opacity = c4d.BaseShader(ID_OCTANE_IMAGE_TEXTURE) m.InsertShader(opacity) m[c4d.OCT_MATERIAL_OPACITY_LINK] = opacity opacity[c4d.IMAGETEXTURE_FILE] = diffuse[c4d.IMAGETEXTURE_FILE] opacity[c4d.IMAGETEXTURE_MODE] = 2
def main(): # Creates Voronoi Fracture object and inserts it into the active document voronoi = c4d.VoronoiFracture() doc.InsertObject(voronoi) # Creates Cube object and inserts it into the active document cube = c4d.BaseObject(c4d.Ocube) doc.InsertObject(cube) # Makes it editable and finally insert it as child of Voronoi Fracture object editable = utils.SendModelingCommand(c4d.MCOMMAND_MAKEEDITABLE, list=[cube], mode=c4d.MODIFY_ALL, doc=doc) doc.InsertObject(editable[0], parent=voronoi) # Adds a point generator ret = voronoi.AddPointGenerator(c4d.ID_POINTCREATOR_CREATORTYPE_DISTRIBUTION) generator = ret[0] generator[c4d.ID_POINTCREATOR_CREATEDPOINTAMOUNT] = 25 generator[c4d.ID_POINTCREATOR_CREATEPOINTSSEED] = 73519 # Adds a shader generator ret = voronoi.AddPointGenerator(c4d.ID_POINTCREATOR_CREATORTYPE_SHADER) generator = ret[0] # Setups Noise shader noise = c4d.BaseShader(c4d.Xnoise) noise[c4d.SLA_NOISE_NOISE] = c4d.NOISE_OFFSET+c4d.NOISE_VORONOI_3 # Sets the shader for the generator generator[c4d.ID_POINTCREATOR_SHADER_SHADER] = noise generator.InsertShader(noise) generator.Message(c4d.MSG_UPDATE) c4d.EventAdd()
def create_octane_displacement(file_path, projection): shd = c4d.BaseShader(constants.ID_OCTANE_DISPLACEMENT) image_texture = create_octane_image_texture(file_path, True, False, projection) shd[c4d.DISPLACEMENT_TEXTURE] = image_texture shd.InsertShader(image_texture) return shd
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 create_octane_image_texture(file_path, is_float, is_gloss, projection): shd = c4d.BaseShader(constants.ID_OCTANE_IMAGE_TEXTURE) shd[c4d.IMAGETEXTURE_FILE] = file_path shd[c4d.IMAGETEXTURE_MODE] = 1 if is_float else 0 shd[c4d.IMAGETEXTURE_GAMMA] = 2.2 shd[c4d.IMAGETEX_BORDER_MODE] = 0 shd[c4d.IMAGETEXTURE_INVERT] = is_gloss shd[c4d.IMAGETEXTURE_PROJECTION_LINK] = projection shd.InsertShader(projection) return shd
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 MatCreator(matName, dColor, dBright, dBitmap, vAlpha): newmat = c4d.BaseMaterial(c4dMaterial) newmat.SetName(matName) newmat[c4d.MATERIAL_COLOR_COLOR] = dColor newmat[c4d.MATERIAL_COLOR_BRIGHTNESS] = dBright if dBitmap != None: newmat[c4d.MATERIAL_USE_COLOR] dShader = c4d.BaseShader(c4dBitmap) dShader[c4d.BITMAPSHADER_FILENAME] = dBitmap newmat[c4d.MATERIAL_COLOR_SHADER] = dShader newmat.InsertShader(dShader) if vAlpha != None: newmat[c4d.MATERIAL_ALPHA_INVERT] = 1 newmat[c4d.MATERIAL_USE_ALPHA] = 1 aShader = c4d.BaseShader(c4dBitmap) aShader[c4d.BITMAPSHADER_FILENAME] = vAlpha newmat[c4d.MATERIAL_ALPHA_SHADER] = aShader newmat.InsertShader(aShader) doc.AddUndo(c4d.UNDOTYPE_NEW, newmat) doc.InsertMaterial(newmat) return newmat
def main(): # Creates Voronoi Fracture object and inserts it into the active document voronoi = c4d.VoronoiFracture() if voronoi is None: raise MemoryError("Failed to create a Voronoi Fracture object.") doc.InsertObject(voronoi) # Creates Cube object and inserts it into the active document cube = c4d.BaseObject(c4d.Ocube) if cube is None: raise MemoryError("Failed to create a cube.") doc.InsertObject(cube) # Makes it editable and finally insert it as child of Voronoi Fracture object editable = c4d.utils.SendModelingCommand(c4d.MCOMMAND_MAKEEDITABLE, list=[cube], mode=c4d.MODIFY_ALL, doc=doc) if not editable: raise RuntimeError("Failed to do the SendModelingCommand operation.") doc.InsertObject(editable[0], parent=voronoi) # Adds a point generator ret = voronoi.AddPointGenerator( c4d.ID_POINTCREATOR_CREATORTYPE_DISTRIBUTION) if ret is None: raise MemoryError("Failed to create a new point generator.") generator = ret[0] generator[c4d.ID_POINTCREATOR_CREATEDPOINTAMOUNT] = 25 generator[c4d.ID_POINTCREATOR_CREATEPOINTSSEED] = 73519 # Adds a shader generator ret = voronoi.AddPointGenerator(c4d.ID_POINTCREATOR_CREATORTYPE_SHADER) if ret is None: raise MemoryError("Failed to create a new point generator.") generator = ret[0] # Setups Noise shader noise = c4d.BaseShader(c4d.Xnoise) if noise is None: raise MemoryError("Failed to create a noise shader.") noise[c4d.SLA_NOISE_NOISE] = c4d.NOISE_OFFSET + c4d.NOISE_VORONOI_3 # Sets the shader for the generator generator[c4d.ID_POINTCREATOR_SHADER_SHADER] = noise generator.InsertShader(noise) generator.Message(c4d.MSG_UPDATE) # Pushes an update event to Cinema 4D c4d.EventAdd()
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 make_diffuse_layer(self, pbr_metal, mat): # Diffuse: set lambert + baseColor in color + inverted metal in LayerMask diffuse = mat.AddReflectionLayer() diffuse.SetName("BaseColor") diffuseid = diffuse.GetDataID() # To lambert refid = diffuseid + c4d.REFLECTION_LAYER_MAIN_DISTRIBUTION mat.SetParameter(refid, c4d.REFLECTION_DISTRIBUTION_LAMBERTIAN, c4d.DESCFLAGS_SET_NONE) if pbr_metal.base_color_factor: base_color_factor = pbr_metal.base_color_factor base_color = c4d.Vector(base_color_factor[0], base_color_factor[1], base_color_factor[2]) mat.SetParameter(diffuseid + c4d.REFLECTION_LAYER_COLOR_COLOR, base_color, c4d.DESCFLAGS_SET_NONE) # Set base color texture if pbr_metal.base_color_texture: basecolortexshader = self.gltf_textures[ pbr_metal.base_color_texture.index].to_c4d_shader() mat.SetParameter(diffuseid + c4d.REFLECTION_LAYER_COLOR_TEXTURE, basecolortexshader, c4d.DESCFLAGS_SET_NONE) mat.InsertShader(basecolortexshader) # Add inverter colorizer and set metalness texture if pbr_metal.metallic_roughness_texture: metaltexshader = self.gltf_textures[ pbr_metal.metallic_roughness_texture.index].to_c4d_shader() colorizer = c4d.BaseShader(c4d.Xcolorizer) colorizer.SetParameter(c4d.SLA_COLORIZER_TEXTURE, metaltexshader, c4d.DESCFLAGS_SET_NONE) colorizer.InsertShader(metaltexshader) colorizer.SetParameter(c4d.SLA_COLORIZER_INPUT, c4d.SLA_COLORIZER_INPUT_BLUE, c4d.DESCFLAGS_SET_NONE) self.setGradientInvert(colorizer) mat.SetParameter(diffuseid + c4d.REFLECTION_LAYER_TRANS_TEXTURE, colorizer, c4d.DESCFLAGS_SET_NONE) mat.InsertShader(colorizer) # Report metallic factor metallic_factor = pbr_metal.metallic_factor if pbr_metal.metallic_factor is not None else 1.0 mat.SetParameter( diffuseid + c4d.REFLECTION_LAYER_TRANS_MIX_STRENGTH, metallic_factor, c4d.DESCFLAGS_SET_NONE)
def main(): doc.StartUndo() selectedMaterials = doc.GetActiveMaterials() for mat in selectedMaterials: if mat[c4d.MATERIAL_COLOR_SHADER] is not None: texture = mat[c4d.MATERIAL_COLOR_SHADER].GetClone() filterShader = c4d.BaseShader(c4d.Xfilter) filterShader[c4d.SLA_FILTER_SATURATION] = -1 filterShader[c4d.SLA_FILTER_TEXTURE] = texture filterShader.InsertShader(texture) mat[c4d.MATERIAL_ALPHA_SHADER] = filterShader mat.InsertShader(filterShader) if mat[c4d.MATERIAL_USE_REFLECTION]: mat[c4d.MATERIAL_USE_REFLECTION] = False doc.EndUndo() c4d.EventAdd()
def make_specular_layer(self, spec_gloss, mat): reflect = mat.AddReflectionLayer() reflect.SetName("Reflectance_specular") reflectid = reflect.GetDataID() if 'specularFactor' in spec_gloss: spec = spec_gloss['specularFactor'] specularColor = c4d.Vector(spec[0], spec[1], spec[2]) mat.SetParameter(reflectid + c4d.REFLECTION_LAYER_COLOR_COLOR, specularColor, c4d.DESCFLAGS_SET_NONE) if 'specularGlossinessTexture' in spec_gloss: speculartexshader = self.gltf_textures[spec_gloss[ 'specularGlossinessTexture']['index']].to_c4d_shader() mat.SetParameter( reflectid + c4d.REFLECTION_LAYER_MAIN_DISTRIBUTION, c4d.REFLECTION_DISTRIBUTION_GGX, c4d.DESCFLAGS_SET_NONE) mat.SetParameter(reflectid + c4d.REFLECTION_LAYER_COLOR_TEXTURE, speculartexshader, c4d.DESCFLAGS_SET_NONE) mat.InsertShader(speculartexshader) glossinesstexshader = self.gltf_textures[spec_gloss[ 'specularGlossinessTexture']['index']].to_c4d_shader(True) gloss_colorizer = c4d.BaseShader(c4d.Xcolorizer) gloss_colorizer.SetParameter(c4d.SLA_COLORIZER_INPUT, c4d.SLA_COLORIZER_INPUT_LUMINANCE, c4d.DESCFLAGS_SET_NONE) gloss_colorizer.SetParameter(c4d.SLA_COLORIZER_TEXTURE, glossinesstexshader, c4d.DESCFLAGS_SET_NONE) gloss_colorizer.InsertShader(glossinesstexshader) self.setGradientInvert(gloss_colorizer) mat.SetParameter( reflectid + c4d.REFLECTION_LAYER_MAIN_SHADER_ROUGHNESS, gloss_colorizer, c4d.DESCFLAGS_SET_NONE) mat.InsertShader(gloss_colorizer) mat.SetParameter(reflectid + c4d.REFLECTION_LAYER_MAIN_VALUE_ROUGHNESS, spec_gloss.get('glossinessFactor', 1.0), c4d.DESCFLAGS_SET_NONE)
def make_shader(shader, name, index, mat_type): print('shader name: {}'.format(name)) doc = c4d.documents.GetActiveDocument() mat = c4d.BaseMaterial(ID_OCTANE_DIFFUSE_MATERIAL) #DEFINE MATERIAL TYPE mat[c4d.OCT_MATERIAL_TYPE] = mat_type mat[c4d.ID_BASELIST_NAME] = name # TRANSFORM NODE TransN = c4d.BaseShader(ID_OCTANE_TRANSFORM) mat.InsertShader(TransN) # PROJECTION NODE ProjN = c4d.BaseShader(ID_OCTANE_PROJECTION) mat.InsertShader(ProjN) # DIFFUSE SETUP if shader.diffuse: IT = c4d.BaseShader(ID_OCTANE_IMAGE_TEXTURE) mat.InsertShader(IT) mat[c4d.OCT_MATERIAL_DIFFUSE_LINK] = IT # DIFFUSE IMAGE NAMES = Albedo/Col/Color IT[c4d.IMAGETEXTURE_FILE] = shader.diffuse IT[c4d.IMAGETEXTURE_MODE] = 0 IT[c4d.IMAGETEXTURE_GAMMA] = 2.2 IT[c4d.IMAGETEX_BORDER_MODE] = 0 # TRANSFORM IT[c4d.IMAGETEXTURE_TRANSFORM_LINK] = TransN # TRANSFORM IT[c4d.IMAGETEXTURE_PROJECTION_LINK] = ProjN # SPECULAR SETUP if shader.specular: IT = c4d.BaseShader(ID_OCTANE_IMAGE_TEXTURE) mat.InsertShader(IT) mat[c4d.OCT_MATERIAL_SPECULAR_LINK] = IT # SPECULAR IMAGE NAMES = Specular/Gloss IT[c4d.IMAGETEXTURE_FILE] = shader.specular IT[c4d.IMAGETEXTURE_MODE] = 1 IT[c4d.IMAGETEXTURE_GAMMA] = 2.2 IT[c4d.IMAGETEX_BORDER_MODE] = 0 # TRANSFORM IT[c4d.IMAGETEXTURE_TRANSFORM_LINK] = TransN # TRANSFORM IT[c4d.IMAGETEXTURE_PROJECTION_LINK] = ProjN # ROUGHNESS SETUP if shader.roughness: IT = c4d.BaseShader(ID_OCTANE_IMAGE_TEXTURE) mat.InsertShader(IT) mat[c4d.OCT_MATERIAL_ROUGHNESS_LINK] = IT # ROUGHNESS IMAGE NAMES = Roughness/ IT[c4d.IMAGETEXTURE_FILE] = shader.roughness IT[c4d.IMAGETEXTURE_MODE] = 1 IT[c4d.IMAGETEXTURE_GAMMA] = 2.2 IT[c4d.IMAGETEX_BORDER_MODE] = 0 # TRANSFORM IT[c4d.IMAGETEXTURE_TRANSFORM_LINK] = TransN # TRANSFORM IT[c4d.IMAGETEXTURE_PROJECTION_LINK] = ProjN # NORMAL SETUP if shader.normal: IT = c4d.BaseShader(ID_OCTANE_IMAGE_TEXTURE) mat.InsertShader(IT) mat[c4d.OCT_MATERIAL_NORMAL_LINK] = IT # NORMAL IMAGE NAMES = Normal/NRM IT[c4d.IMAGETEXTURE_FILE] = shader.normal IT[c4d.IMAGETEXTURE_MODE] = 0 IT[c4d.IMAGETEXTURE_GAMMA] = 2.2 IT[c4d.IMAGETEX_BORDER_MODE] = 0 # TRANSFORM IT[c4d.IMAGETEXTURE_TRANSFORM_LINK] = TransN # TRANSFORM IT[c4d.IMAGETEXTURE_PROJECTION_LINK] = ProjN else: if shader.bump: IT = c4d.BaseShader(ID_OCTANE_IMAGE_TEXTURE) mat.InsertShader(IT) mat[c4d.OCT_MATERIAL_BUMP_LINK] = IT # NORMAL IMAGE NAMES = BUMP IT[c4d.IMAGETEXTURE_FILE] = shader.bump IT[c4d.IMAGETEXTURE_MODE] = 1 IT[c4d.IMAGETEXTURE_GAMMA] = 2.2 IT[c4d.IMAGETEX_BORDER_MODE] = 0 # TRANSFORM IT[c4d.IMAGETEXTURE_TRANSFORM_LINK] = TransN # TRANSFORM IT[c4d.IMAGETEXTURE_PROJECTION_LINK] = ProjN # OPACITY SETUP if shader.opacity: IT = c4d.BaseShader(ID_OCTANE_IMAGE_TEXTURE) mat.InsertShader(IT) mat[c4d.OCT_MATERIAL_OPACITY_LINK] = IT # OPACITY IMAGE NAMES = ALPHA/OPACITY/TRANSPARENCY IT[c4d.IMAGETEXTURE_FILE] = shader.opacity IT[c4d.IMAGETEXTURE_MODE] = 1 IT[c4d.IMAGETEXTURE_GAMMA] = 2.2 IT[c4d.IMAGETEX_BORDER_MODE] = 0 # TRANSFORM IT[c4d.IMAGETEXTURE_TRANSFORM_LINK] = TransN # TRANSFORM IT[c4d.IMAGETEXTURE_PROJECTION_LINK] = ProjN # DISPLACEMENT SETUP if shader.displacement: IT = c4d.BaseShader(ID_OCTANE_IMAGE_TEXTURE) mat.InsertShader(IT) DISP = c4d.BaseShader(ID_OCTANE_DISPLACEMENT) mat.InsertShader(DISP) DISP[c4d.DISPLACEMENT_INPUT] = IT DISP[c4d.DISPLACEMENT_AMOUNT] = 5 DISP[c4d.DISPLACEMENT_MID] = 0.5 DISP[c4d.DISPLACEMENT_LEVELOFDETAIL] = c4d.DISPLACEMENT_RES_8192 # DISPACEMENT IMAGE NAMES = DISPACEMENT/DEPTH/HEIGHT IT[c4d.IMAGETEXTURE_FILE] = shader.displacement IT[c4d.IMAGETEXTURE_MODE] = 1 IT[c4d.IMAGETEXTURE_GAMMA] = 2.2 IT[c4d.IMAGETEX_BORDER_MODE] = 0 mat[c4d.OCT_MATERIAL_DISPLACEMENT_LINK] = DISP # TRANSFORM IT[c4d.IMAGETEXTURE_TRANSFORM_LINK] = TransN # TRANSFORM IT[c4d.IMAGETEXTURE_PROJECTION_LINK] = ProjN # INDEX SETUP mat[c4d.OCT_MATERIAL_INDEX] = index doc.InsertMaterial(mat)
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 # If no folder, quit the script bc = c4d.BaseContainer() # Initialize a base container keyMod = "None" # Initialize a keyboard modifier status # Button is pressed if c4d.gui.GetInputState(c4d.BFM_INPUT_KEYBOARD, c4d.BFM_INPUT_CHANNEL, bc): if bc[c4d.BFM_INPUT_QUALIFIER] & c4d.QSHIFT: if bc[c4d.BFM_INPUT_QUALIFIER] & c4d.QCTRL: # Ctrl + Shift if bc[c4d. BFM_INPUT_QUALIFIER] & c4d.QALT: # Alt + Ctrl + Shift keyMod = 'Alt+Ctrl+Shift' else: # Shift + Ctrl keyMod = 'Ctrl+Shift' elif bc[c4d.BFM_INPUT_QUALIFIER] & c4d.QALT: # Alt + Shift keyMod = 'Alt+Shift' else: # Shift keyMod = 'Shift' elif bc[c4d.BFM_INPUT_QUALIFIER] & c4d.QCTRL: if bc[c4d.BFM_INPUT_QUALIFIER] & c4d.QALT: # Alt + Ctrl keyMod = 'Alt+Ctrl' else: # Ctrl keyMod = 'Ctrl' elif bc[c4d.BFM_INPUT_QUALIFIER] & c4d.QALT: # Alt keyMod = 'Alt' else: # No keyboard modifiers used keyMod = 'None' try: # Try to execute following script files = os.listdir(folder) for f in files: # Loop through files extension = f.rpartition(".")[-1].lower() formats = [ "tif", "tiff", "psd", "jpg", "jpeg", "png", "exr", "tga" ] # Supported file formats if extension in formats: # If file is supported mat = c4d.BaseMaterial(c4d.Mmaterial) path = os.path.join(folder, f) #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 # Get bitmap size irs = c4d.modules.render.InitRenderStruct( ) # Needed to get shader's bitmap info if color.InitRender(irs) == c4d.INITRENDERRESULT_OK: bitmap = color.GetBitmap() # Get bitmap color.FreeRender( ) # Frees all resources used by this shader if bitmap is not None: # If there is bitmap width = bitmap.GetSize()[ 0] # Get bitmap width in pixels height = bitmap.GetSize()[ 1] # Get bitmap height in pixels # 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.rpartition(".")[ 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 if keyMod == "Shift": # If Shift key pressed - Generate planes and assign materials to them # Create plane plane = c4d.BaseObject( c4d.Oplane) # Initialize plane object plane.SetName( matname) # Set plane's name same as the material name plane[c4d.PRIM_AXIS] = 5 # Set plane's orientation to -z plane[ c4d.PRIM_PLANE_SUBW] = 1 # Set plane's width segments plane[ c4d.PRIM_PLANE_SUBH] = 1 # Set plane's height segments plane[c4d.PRIM_PLANE_WIDTH] = width # Set plane's width plane[c4d.PRIM_PLANE_HEIGHT] = height # Set planes height doc.InsertObject(plane) # Insert plane to document doc.AddUndo( c4d.UNDOTYPE_NEW, plane ) # Add undo command for inserting plane to document # Texture tag t = c4d.BaseTag(5616) # Initialize texture tag plane.InsertTag(t) # Insert texture tag to object tag = plane.GetFirstTag() # Get object's first tag tag[c4d. TEXTURETAG_MATERIAL] = mat # Set material to texture tag tag[c4d. TEXTURETAG_PROJECTION] = 6 # Set texture projection to uvw mapping doc.AddUndo( c4d.UNDOTYPE_NEW, tag ) # Add undo command for inserting texture tag to object except: # If something went wrong pass # Do nothing doc.EndUndo() # Stop recording undos c4d.EventAdd() # Refresh Cinema 4D
def create_octane_projection(): shd = c4d.BaseShader(constants.ID_OCTANE_TEXTURE_PROJECTION) shd[c4d.TEX_PROJECTION_TYPE] = constants.TEX_PROJ_BOX return shd
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 # Get bitmap size irs = c4d.modules.render.InitRenderStruct( ) # Needed to get shader's bitmap info if color.InitRender(irs) == c4d.INITRENDERRESULT_OK: bitmap = color.GetBitmap() # Get bitmap color.FreeRender() # Frees all resources used by this shader if bitmap is not None: # If there is bitmap width = bitmap.GetSize()[0] # Get bitmap width in pixels height = bitmap.GetSize()[1] # Get bitmap height in pixels # 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 # Create plane plane = c4d.BaseObject(c4d.Oplane) # Initialize plane object plane[c4d.PRIM_AXIS] = 5 # Set plane's orientation to -z plane[c4d.PRIM_PLANE_SUBW] = 1 # Set plane's width segments plane[c4d.PRIM_PLANE_SUBH] = 1 # Set plane's height segments plane[c4d.PRIM_PLANE_WIDTH] = width # Set plane's width plane[c4d.PRIM_PLANE_HEIGHT] = height # Set planes height doc.InsertObject(plane) # Insert plane to document doc.AddUndo( c4d.UNDOTYPE_NEW, plane) # Add undo command for inserting plane to document # Texture tag t = c4d.BaseTag(5616) # Initialize texture tag plane.InsertTag(t) # Insert texture tag to object tag = plane.GetFirstTag() # Get object's first tag tag[c4d.TEXTURETAG_MATERIAL] = mat # Set material to texture tag tag[c4d. TEXTURETAG_PROJECTION] = 6 # Set texture projection to uvw mapping doc.AddUndo( c4d.UNDOTYPE_NEW, tag) # Add undo command for inserting texture tag to object except: # If something went wrong pass # Do nothing doc.EndUndo() # Stop recording undos c4d.EventAdd() # Refresh Cinema 4D
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 if flipNormalY == 1: print tShader print "Flipping normal" #Lets adjust refletion channel values while we are here :) refLayer = mat.GetReflectionLayerIndex(0) mat[c4d.REFLECTION_LAYER_MAIN_DISTRIBUTION + refLayer.GetDataID()] = 2 mat[c4d.REFLECTION_LAYER_MAIN_VALUE_ROUGHNESS + refLayer.GetDataID()] = 1 mat[c4d.REFLECTION_LAYER_MAIN_VALUE_REFLECTION + refLayer.GetDataID()] = 1 mat[c4d.REFLECTION_LAYER_MAIN_VALUE_SPECULAR + refLayer.GetDataID()] = 0 mat[c4d.REFLECTION_LAYER_COLOR_BRIGHTNESS + refLayer.GetDataID()] = 0.2 mat[c4d.MATERIAL_NORMAL_REVERSEY] = True # Update material mat.Update(True, True)
def convertToOctane(self): doc = documents.GetActiveDocument() standMats = [] c4d.CallCommand(300001026, 300001026) # Deselect All sceneMats = doc.GetMaterials() for mat in sceneMats: matName = mat.GetName() if mat.GetType() == 5703: standMats.append(mat) mat.SetBit(c4d.BIT_ACTIVE) c4d.EventAdd() if len(standMats) != 0: c4d.CallCommand(1029770, 1029770) # Convert Materials c4d.CallCommand(1035351, 1035351) # Remove Unused Materials c4d.CallCommand(300001026, 300001026) # Deselect All doc = c4d.documents.GetActiveDocument() figureModel = "Genesis8" 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 foundFingerNails = False # If not, assume is Gneesis3... hide Cornea... if findMatName("EyeReflection"): figureModel = "Genesis2" if findMatName("FingerNails"): figureModel = "Genesis3" # FIX MATERIAL NAMES etc... USE THIS FOR ALL CONVERTIONS NOT JUST OCTANE! if findMatName( "1_SkinFace") == None and findMatName("1_Nostril") != None: findMatName("1_Nostril").SetName("1_SkinFace") if findMatName( "3_SkinHand") == None and findMatName("3_SkinFoot") != None: findMatName("3_SkinFoot").SetName("3_ArmsLegs") # //// sceneMats = doc.GetMaterials() for mat in sceneMats: matName = mat.GetName() mat[c4d.OCT_MATERIAL_SPECULAR_COLOR] = c4d.Vector(0.0, 0.0, 0.0) mat[c4d.OCT_MATERIAL_INDEX] = 2 extraMapGlossyRough = dazToC4Dutils().findTextInFile( matName, "Glossy_Roughness_Map") if extraMapGlossyRough != None: ID_OCTANE_IMAGE_TEXTURE = 1029508 shd = c4d.BaseShader(ID_OCTANE_IMAGE_TEXTURE) mat.InsertShader(shd) mat[c4d.OCT_MATERIAL_ROUGHNESS_LINK] = shd shd[c4d.IMAGETEXTURE_FILE] = extraMapGlossyRough shd[c4d.IMAGETEXTURE_MODE] = 0 shd[c4d.IMAGETEXTURE_GAMMA] = 2.2 shd[c4d.IMAGETEX_BORDER_MODE] = 0 doc.InsertMaterial(mat) extraMapSpec = dazToC4Dutils().findTextInFile( matName, "Glossy_Layered_Weight_Map") extraMapSpec2 = dazToC4Dutils().findTextInFile(matName, "spec") extraMapGlossy = dazToC4Dutils().findTextInFile( matName, "Metallicity_Map") if extraMapSpec2 != None and extraMapSpec == None: extraMapSpec = extraMapSpec2 if extraMapGlossy != None and extraMapSpec == None: extraMapSpec = extraMapGlossy if extraMapSpec != None: # c4d.gui.MessageDialog(extraMapGlossyRough) ID_OCTANE_IMAGE_TEXTURE = 1029508 shd = c4d.BaseShader(ID_OCTANE_IMAGE_TEXTURE) mat.InsertShader(shd) mat[c4d.OCT_MATERIAL_SPECULAR_LINK] = shd shd[c4d.IMAGETEXTURE_FILE] = extraMapSpec shd[c4d.IMAGETEXTURE_MODE] = 0 shd[c4d.IMAGETEXTURE_GAMMA] = 2.2 shd[c4d.IMAGETEX_BORDER_MODE] = 0 doc.InsertMaterial(mat) try: mat[c4d.OCT_MATERIAL_BUMP_LINK][ c4d.IMAGETEXTURE_POWER_FLOAT] = 0.1 except: pass try: mat[c4d.OCT_MATERIAL_SPECULAR_FLOAT] = 0.15 except: pass try: mat[c4d.OCT_MATERIAL_ROUGHNESS_FLOAT] = 0.15 except: pass # Transp map fix compensation alpha... try: mat[c4d.OCT_MATERIAL_OPACITY_LINK][ c4d.IMAGETEXTURE_POWER_FLOAT] = 1.5 mat[c4d.OCT_MATERIAL_OPACITY_LINK][ c4d.IMAGETEXTURE_GAMMA] = 1.0 mat[c4d.OCT_MATERIAL_OPACITY_LINK][c4d.IMAGETEXTURE_MODE] = 0 except: pass if "Moisture" in matName or "Cornea" in matName: mat[c4d.OCT_MATERIAL_TYPE] = 2511 mat[c4d.OCT_MATERIAL_DIFFUSE_COLOR] = c4d.Vector(0.0, 0.0, 0.0) mat[c4d.OCT_MATERIAL_SPECULAR_COLOR] = c4d.Vector( 0.0, 0.0, 0.0) mat[c4d.OCT_MATERIAL_SPECULAR_FLOAT] = 1.0 mat[c4d.OCT_MATERIAL_ROUGHNESS_FLOAT] = 0.0 mat[c4d.OCT_MAT_USE_BUMP] = False mat[c4d.OCT_MATERIAL_INDEX] = 6 mat[c4d.OCT_MATERIAL_OPACITY_COLOR] = c4d.Vector(0.0, 0.0, 0.0) mat[c4d.OCT_MATERIAL_OPACITY_FLOAT] = 0.25 mat[c4d.OCT_MATERIAL_OPACITY_LINK] = None if "Sclera" in matName: try: mat[c4d.OCT_MATERIAL_DIFFUSE_LINK][ c4d.IMAGETEXTURE_POWER_FLOAT] = 3.0 mat[c4d.OCT_MATERIAL_DIFFUSE_LINK][ c4d.IMAGETEXTURE_GAMMA] = 2.0 mat[c4d.OCT_MATERIAL_ROUGHNESS_FLOAT] = 0.0 except: pass if "Irises" in matName: try: mat[c4d.OCT_MATERIAL_DIFFUSE_LINK][ c4d.IMAGETEXTURE_POWER_FLOAT] = 2.0 mat[c4d.OCT_MATERIAL_DIFFUSE_LINK][ c4d.IMAGETEXTURE_GAMMA] = 2.0 mat[c4d.OCT_MATERIAL_ROUGHNESS_FLOAT] = 0.0 except: pass if "Teeth" in matName: mat[c4d.OCT_MATERIAL_TYPE] = 2511 mat[c4d.OCT_MATERIAL_DIFFUSE_COLOR] = c4d.Vector(0.0, 0.0, 0.0) mat[c4d.OCT_MATERIAL_SPECULAR_COLOR] = c4d.Vector( 0.0, 0.0, 0.0) mat[c4d.OCT_MATERIAL_SPECULAR_FLOAT] = 1.0 mat[c4d.OCT_MATERIAL_ROUGHNESS_FLOAT] = 0.03 mat[c4d.OCT_MATERIAL_INDEX] = 2 if "Lips" in matName: mat[c4d.OCT_MATERIAL_TYPE] = 2511 mat[c4d.OCT_MATERIAL_DIFFUSE_COLOR] = c4d.Vector(0.0, 0.0, 0.0) mat[c4d.OCT_MATERIAL_SPECULAR_COLOR] = c4d.Vector( 0.0, 0.0, 0.0) mat[c4d.OCT_MATERIAL_SPECULAR_FLOAT] = 0.5 mat[c4d.OCT_MATERIAL_ROUGHNESS_FLOAT] = 0.16 mat[c4d.OCT_MATERIAL_INDEX] = 2 if "Tongue" in matName: mat[c4d.OCT_MATERIAL_TYPE] = 2511 mat[c4d.OCT_MATERIAL_DIFFUSE_COLOR] = c4d.Vector(0.0, 0.0, 0.0) mat[c4d.OCT_MATERIAL_SPECULAR_COLOR] = c4d.Vector( 0.0, 0.0, 0.0) mat[c4d.OCT_MATERIAL_SPECULAR_FLOAT] = 0.20 mat[c4d.OCT_MATERIAL_ROUGHNESS_FLOAT] = 0.10 mat[c4d.OCT_MATERIAL_INDEX] = 6 if "Gums" in matName: mat[c4d.OCT_MATERIAL_TYPE] = 2511 mat[c4d.OCT_MATERIAL_DIFFUSE_COLOR] = c4d.Vector(0.0, 0.0, 0.0) mat[c4d.OCT_MATERIAL_SPECULAR_COLOR] = c4d.Vector( 0.0, 0.0, 0.0) mat[c4d.OCT_MATERIAL_SPECULAR_FLOAT] = 0.8 mat[c4d.OCT_MATERIAL_ROUGHNESS_FLOAT] = 0.21 mat[c4d.OCT_MATERIAL_INDEX] = 2 if "Mouth" in matName: mat[c4d.OCT_MATERIAL_TYPE] = 2511 mat[c4d.OCT_MATERIAL_INDEX] = 5 if "Tear" in matName: mat[c4d.OCT_MATERIAL_TYPE] = 2511 mat[c4d.OCT_MATERIAL_DIFFUSE_COLOR] = c4d.Vector(0.0, 0.0, 0.0) mat[c4d.OCT_MATERIAL_SPECULAR_COLOR] = c4d.Vector( 0.0, 0.0, 0.0) mat[c4d.OCT_MATERIAL_SPECULAR_FLOAT] = 0.8 mat[c4d.OCT_MATERIAL_ROUGHNESS_FLOAT] = 0.0 mat[c4d.OCT_MATERIAL_INDEX] = 8 mat[c4d.OCT_MATERIAL_OPACITY_FLOAT] = 0.25 # GENESIS 1 Patch ---------------------------- if "5_Cornea" in matName: mat[c4d.OCT_MATERIAL_OPACITY_FLOAT] = 0.15 # GENESIS 2 Patches ------------------------- if figureModel == "Genesis2": if "Nostrils" in matName: mat.SetName("Head") if "Sclera" in matName: try: mat[c4d.OCT_MATERIAL_DIFFUSE_LINK][ c4d.IMAGETEXTURE_POWER_FLOAT] = 2.0 except: pass if mat[c4d.OCT_MATERIAL_OPACITY_LINK]: try: mat[c4d.OCT_MATERIAL_OPACITY_LINK][ c4d.IMAGETEXTURE_MODE] = 1 mat[c4d.OCT_MATERIAL_OPACITY_LINK][ c4d.IMAGETEXTURE_GAMMA] = 1.0 except: pass if "EyeReflection" in matName or "Tear" in matName: mat[c4d.OCT_MATERIAL_TYPE] = 2511 # 2511 Glossy mat[c4d.OCT_MATERIAL_DIFFUSE_COLOR] = c4d.Vector( 0.0, 0.0, 0.0) mat[c4d.OCT_MATERIAL_SPECULAR_COLOR] = c4d.Vector( 0.0, 0.0, 0.0) mat[c4d.OCT_MATERIAL_SPECULAR_FLOAT] = 1.0 mat[c4d.OCT_MATERIAL_ROUGHNESS_FLOAT] = 0.0 mat[c4d.OCT_MAT_USE_BUMP] = False mat[c4d.OCT_MATERIAL_INDEX] = 6 mat[c4d.OCT_MATERIAL_OPACITY_COLOR] = c4d.Vector( 0.0, 0.0, 0.0) mat[c4d.OCT_MATERIAL_OPACITY_FLOAT] = 0.20 mat[c4d.OCT_MATERIAL_OPACITY_LINK] = None if "Tear" in matName: mat[c4d.OCT_MATERIAL_OPACITY_FLOAT] = 0.1 mat[c4d.OCT_MATERIAL_INDEX] = 3 if "Lacrimals" in matName: mat[c4d.OCT_MATERIAL_TYPE] = 2511 # 2511 Glossy mat[c4d.OCT_MATERIAL_ROUGHNESS_FLOAT] = 0.0 mat[c4d.OCT_MATERIAL_SPECULAR_FLOAT] = 0.15 mat[c4d.OCT_MATERIAL_INDEX] = 3 try: mat[c4d.OCT_MATERIAL_DIFFUSE_LINK][ c4d.IMAGETEXTURE_POWER_FLOAT] = 2.0 except: pass # GENESIS 3 Patches ------------------------- if figureModel == "Genesis3": if "Cornea" in matName: mat[c4d.OCT_MAT_USE_OPACITY] = True mat[c4d.OCT_MATERIAL_OPACITY_FLOAT] = 0.0 c4d.EventAdd()
def set_alpha(self, material, mat): if material.alpha_mode not in ('BLEND', 'MASK'): mat[c4d.MATERIAL_USE_ALPHA] = 0 return mat[c4d.MATERIAL_USE_ALPHA] = 1 alpha_factor = 1.0 diffuse_alpha_shader = None if material.extensions and 'KHR_materials_pbrSpecularGlossiness' in material.extensions: pbr_specular = material.extensions[ 'KHR_materials_pbrSpecularGlossiness'] alpha_factor = pbr_specular['diffuse_factor'][ 3] if 'diffuse_factor' in pbr_specular else 1.0 if 'diffuseTexture' in pbr_specular: diffuse_alpha_shader = self.gltf_textures[ pbr_specular['diffuseTexture']['index']].to_c4d_shader( alpha_only=True) elif material.pbr_metallic_roughness: pbr_metal = material.pbr_metallic_roughness if pbr_metal.base_color_texture: diffuse_alpha_shader = self.gltf_textures[ pbr_metal.base_color_texture.index].to_c4d_shader( alpha_only=True) if pbr_metal.base_color_factor: alpha_factor = pbr_metal.base_color_factor[ 3] if pbr_metal.base_color_factor else 1.0 if material.alpha_mode == 'BLEND': mat.SetParameter(c4d.MATERIAL_ALPHA_SOFT, True, c4d.DESCFLAGS_SET_NONE) if diffuse_alpha_shader: mat.SetParameter(c4d.MATERIAL_ALPHA_IMAGEALPHA, True, c4d.DESCFLAGS_SET_NONE) diffuse_alpha_shader = diffuse_alpha_shader alpha_colorizer = c4d.BaseShader(c4d.Xcolorizer) alpha_colorizer.SetParameter(c4d.SLA_COLORIZER_TEXTURE, diffuse_alpha_shader, c4d.DESCFLAGS_SET_NONE) alpha_colorizer.InsertShader(diffuse_alpha_shader) alpha_colorizer.SetParameter(c4d.SLA_COLORIZER_INPUT, c4d.SLA_COLORIZER_INPUT_LUMINANCE, c4d.DESCFLAGS_SET_NONE) mat.SetParameter(c4d.MATERIAL_ALPHA_SHADER, alpha_colorizer, c4d.DESCFLAGS_SET_NONE) mat.InsertShader(alpha_colorizer) # Apply factor alpha_color_from_factor = c4d.Vector(alpha_factor, alpha_factor, alpha_factor) self.setGradient(alpha_colorizer, self.COLOR_BLACK, alpha_color_from_factor) else: mat.SetParameter(c4d.MATERIAL_ALPHA_IMAGEALPHA, False, c4d.DESCFLAGS_SET_NONE) alpha_color_shader = c4d.BaseShader(c4d.Xcolor) alpha_color_shader.SetParameter(c4d.COLORSHADER_COLOR, self.COLOR_WHITE, c4d.DESCFLAGS_SET_NONE) alpha_color_shader.SetParameter(c4d.COLORSHADER_BRIGHTNESS, alpha_factor, c4d.DESCFLAGS_SET_NONE) mat.SetParameter(c4d.MATERIAL_ALPHA_SHADER, alpha_color_shader, c4d.DESCFLAGS_SET_NONE) mat.InsertShader(alpha_color_shader) elif material.alpha_mode == 'MASK': # # Masking without texture doesn't really make sense if diffuse_alpha_shader: mat.InsertShader(diffuse_alpha_shader) mat.SetParameter(c4d.MATERIAL_ALPHA_SHADER, diffuse_alpha_shader, c4d.DESCFLAGS_SET_NONE) mat.SetParameter(c4d.MATERIAL_ALPHA_COLOR, self.COLOR_BLACK, c4d.DESCFLAGS_SET_NONE) cutoff = max( material.alpha_cutoff, 0.99 ) # a full white color makes everything fully transparent delta_color = c4d.Vector(cutoff, cutoff, cutoff) mat.SetParameter(c4d.MATERIAL_ALPHA_DELTA, delta_color, c4d.DESCFLAGS_SET_NONE)
def main(): #获取当前.py文件的位置 root_path = os.getcwd() if not root_path: c4d.gui.MessageDialog("Please put this script in a correct path.") return #获取path目录下的文件夹 sub_folders = list() #初始化用于存储文件夹的列表,避免循环结束后被删除 #警告列表(存储导入中出现疑似错误的材质的列表) warnning_list = list() #该循环只进行一次,用于获取root_path路径中的文件夹列表 for root in os.walk(root_path): sub_folders = root[1] #root的第1个元素为其中包含的文件夹 break #只查到了walk配合循环的用法,只好这么用了 print("%s%s%s" % ("Detected folders:", sub_folders, "\n \n ")) #遍历sub_folders中的子文件夹。sub_folders是文件夹内的子文件夹的列表 for cur_folder in sub_folders: print("%s%s" % ("Processing folder:", cur_folder)) #创建并插入材质 new_material = c4d.BaseMaterial(5703) #得到默认材质 new_material.SetName(cur_folder) #材质名称更改为贴图所在文件夹的名称 doc.InsertMaterial(new_material) #向文档中插入材质 print(" %s%s" % ("Material created:", cur_folder)) #遍历文件夹中的文件。files是cur_folder内文件的列表。temp是占位符,用于指定循环的对象,这两项不会被使用 for temp, temp, files in os.walk(cur_folder): #判断files是否为空(即判断文件夹是否为空) if files: #不为空 #遍历files for image in files: print(" %s%s" % ("Processing file:", image)) #使用join函数将路径拼合 #root_path是.py文件所在目录,cur_folder是.py文件所在目录中子目录的名称,image是图像文件的名称 image_path = os.path.join(root_path, cur_folder, image) #判断该文件是否是图像文件。是则进入材质创建流程,否则开始下一轮循环 suffix_flag = 0 #判断该文件后缀是否是与suffix某个元素吻合,全都不是则为0,是则为1 for cur_suffix in suffix: #该文件的后缀名与suffix列表中元素之一吻合,进入材质创建流程 if cur_suffix in image: suffix_flag = 1 #后缀名吻合,更改flag print(" %s%s%s" % ("\"", image, "\" is a image file.")) #判断该图像是否是贴图。是则进入贴图导入流程,否则开始下一轮循环 channel_flag = 0 #判断该图片是否是某通道的图片,任何通道都不是则为0,是则为1 for cur_channel in channel_name: #通过检测该图像是否包含channel列表中的字串来判断是否是贴图 if cur_channel in image: channel_flag = 1 #该图片是某通道的图片,更改flag print(" %s%s%s%s%s" % ("\"", image, "\" is a image of \"", cur_channel, "\" channel.")) print("%s%s" % (" Importing texture:", image)) try: #新建shader并初始化 shader = c4d.BaseShader(c4d.Xbitmap) shader[ c4d. BITMAPSHADER_FILENAME] = image_path except BaseException: #导入出现错误 print("%s%s" % ( " Texture\"", image, "\"import failure !(texture skipped.)" )) break #先判断这是什么通道的文件,再将texture赋予new_material #diffuse通道 if cur_channel == "diffuse": new_material[ c4d.MATERIAL_COLOR_SHADER] = shader new_material.InsertShader(shader) #reflection通道 if cur_channel == "reflection": new_material[ c4d. REFLECTION_LAYER_COLOR_TEXTURE] = shader new_material.InsertShader(shader) #glossiness通道 if cur_channel == "glossiness": new_material[ c4d.MATERIAL_COLOR_SHADER] = shader new_material.InsertShader(shader) #height通道 if cur_channel == "height": new_material[ c4d.MATERIAL_BUMP_SHADER] = shader new_material.InsertShader(shader) #normal通道 if cur_channel == "normal": new_material[ c4d. MATERIAL_NORMAL_SHADER] = shader new_material.InsertShader(shader) c4d.EventAdd() #刷新视图 break #该图片是某个通道的图片,跳出channel循环,不继续将图片与其他通道比对 if channel_flag == 0: print(" %s%s%s" % ( "\"", image, "\"is not an image of any channel !(file skipped.)" )) #该图片不是任何通道的图片 warnning_list.append( (cur_folder, image, "Is not an image of any channel !" )) #向警告列表中添加本材质 break #该文件是图像文件,跳出suffix循环,不继续将文件与其他后缀名比对 if suffix_flag == 0: print(" %s%s%s" % ("\"", image, "\"is not a image file !(file skipped.)") ) #该文件不是任何格式的图片 warnning_list.append( (cur_folder, image, "Is not an image file!")) #向警告列表中添加本材质 else: #files为空,向警告列表中添加本材质 print(" %s%s%s" % ("\"", cur_folder, "\"Is an empty folder !")) #files为空 warnning_list.append( (cur_folder, "Is an empty folder !")) #向警告列表中添加本材质 print("\n ") #在两个文件夹之间换行 print
def main(): fn = s.LoadDialog(c4d.FILESELECTTYPE_ANYTHING, "Select reference file", c4d.FILESELECT_LOAD) # Load file if fn == None: return None # If no file, stop the script # Material mat = c4d.BaseMaterial(c4d.Mmaterial) # Initialize material mat.SetName("REFERENCE_MATERIAL") # Set material name mat[c4d.MATERIAL_USE_REFLECTION] = 0 # Disable reflection channel mat[c4d.MATERIAL_ANIMATEPREVIEW] = 1 # Enable 'Animate Preview' mat[c4d. MATERIAL_PREVIEWSIZE] = 1 # Set 'Texture Preview Size' to 'No Scaling' shader = c4d.BaseShader(c4d.Xbitmap) # Initialize bitmap shader shader[c4d.BITMAPSHADER_FILENAME] = fn # Set bitmap file doc.ExecutePasses(None, 0, 1, 1, 0) # Needed when pressing buttons virtually c4d.CallButton( shader, c4d.BITMAPSHADER_CALCULATE) # Press 'Animation>Calculate' button mat[c4d. MATERIAL_COLOR_SHADER] = shader # Set shader to material's color channel mat.InsertShader(shader) # Insert shader to color channel mat.Message(c4d.MSG_UPDATE) # Update material mat.Update(True, True) # Update material irs = c4d.modules.render.InitRenderStruct( ) # Needed to get shader's bitmap info if shader.InitRender(irs) == c4d.INITRENDERRESULT_OK: bitmap = shader.GetBitmap() # Get bitmap shader.FreeRender() # Frees all resources used by this shader if bitmap is not None: # If there is bitmap width = bitmap.GetSize()[0] # Get bitmap width in pixels height = bitmap.GetSize()[1] # Get bitmap height in pixels doc.InsertMaterial(mat) # Insert material to document # Camera cam = c4d.BaseObject(c4d.Ocamera) # Initialize camera object cam.SetName("REFERENCE_CAMERA") # Set camera name cam[c4d. CAMERAOBJECT_TARGETDISTANCE] = width # Set camera focus to match bitmap width cam[c4d. ID_BASEOBJECT_VISIBILITY_RENDER] = 1 # Set camera's visible in rendeerr to off doc.InsertObject(cam) # Insert camera to document # Plane plane = c4d.BaseObject(c4d.Oplane) # Initialize plane object plane[ c4d. ID_BASEOBJECT_VISIBILITY_RENDER] = 1 # Set plane's visible in renderer to off plane.SetName("REFERENCE_PLANE") # Set plane name plane[c4d.PRIM_AXIS] = 5 # Set plane's orientation to -z plane[c4d.PRIM_PLANE_SUBW] = 1 # Set plane's width segments plane[c4d.PRIM_PLANE_SUBH] = 1 # Set plane's height segments plane[c4d.PRIM_PLANE_WIDTH] = width # Set plane's width plane[c4d.PRIM_PLANE_HEIGHT] = height # Set planes height plane[c4d.ID_BASEOBJECT_REL_POSITION, c4d.VECTOR_Z] = width # Set plane's z position plane.InsertUnder(cam) # Insert plane object under camera object # Tags t = c4d.BaseTag(5616) # Initialize texture tag plane.InsertTag(t) # Insert texture tag to object tag = plane.GetFirstTag() # Get object's first tag tag[c4d.TEXTURETAG_MATERIAL] = mat # Set material to texture tag tag[c4d.TEXTURETAG_PROJECTION] = 6 # Set texture projection to uvw mapping d = c4d.BaseTag(5613) # Initialize display tag d[c4d.DISPLAYTAG_AFFECT_DISPLAYMODE] = True # Use custom shading mode d[c4d.DISPLAYTAG_SDISPLAYMODE] = 7 # Use 'Constant Shading' d[c4d.DISPLAYTAG_AFFECT_TEXTURES] = True # Use textures plane.InsertTag(d) # Insert display tag to object # Base view c4d.CallCommand(12544) # Create new viewport bd = doc.GetActiveBaseDraw() # Get active base draw bd[c4d. BASEDRAW_DATA_TINTBORDER_OPACITY] = 1 # Set tinted borders for base view bd[c4d.BASEDRAW_DATA_CAMERA] = cam # Set base view's camera bd[c4d.BASEDRAW_TITLE] = "REFERENCE_VIEWPORT" # Set base view name cam[c4d.ID_BASEOBJECT_REL_POSITION, c4d.VECTOR_X] = 5000000 # Move camera far away c4d.EventAdd() # Refresh Cinema 4D
def make_dielectric_reflectance_layer(self, pbr_metal, mat): reflect = mat.AddReflectionLayer() reflect.SetName("Reflectance_dielectric") reflectid = reflect.GetDataID() mat.SetParameter(reflectid + c4d.REFLECTION_LAYER_FRESNEL_MODE, c4d.REFLECTION_FRESNEL_DIELECTRIC, c4d.DESCFLAGS_SET_NONE) if pbr_metal.base_color_factor: base_color_factor = pbr_metal.base_color_factor base_color = c4d.Vector(base_color_factor[0], base_color_factor[1], base_color_factor[2]) mat.SetParameter(reflectid + c4d.REFLECTION_LAYER_COLOR_COLOR, base_color, c4d.DESCFLAGS_SET_NONE) if pbr_metal.base_color_texture: basecolortexshader = self.gltf_textures[ pbr_metal.base_color_texture.index].to_c4d_shader() mat.SetParameter( reflectid + c4d.REFLECTION_LAYER_MAIN_DISTRIBUTION, c4d.REFLECTION_DISTRIBUTION_GGX, c4d.DESCFLAGS_SET_NONE) mat.SetParameter(reflectid + c4d.REFLECTION_LAYER_COLOR_TEXTURE, basecolortexshader, c4d.DESCFLAGS_SET_NONE) mat.InsertShader(basecolortexshader) if pbr_metal.metallic_roughness_texture: # Roughness roughnesstexshader = self.gltf_textures[ pbr_metal.metallic_roughness_texture.index].to_c4d_shader() rough_colorizer = c4d.BaseShader(c4d.Xcolorizer) rough_colorizer.SetParameter(c4d.SLA_COLORIZER_INPUT, c4d.SLA_COLORIZER_INPUT_GREEN, c4d.DESCFLAGS_SET_NONE) rough_colorizer.SetParameter(c4d.SLA_COLORIZER_TEXTURE, roughnesstexshader, c4d.DESCFLAGS_SET_NONE) rough_colorizer.InsertShader(roughnesstexshader) self.setGradientBlackWhite(rough_colorizer) mat.SetParameter( reflectid + c4d.REFLECTION_LAYER_MAIN_SHADER_ROUGHNESS, rough_colorizer, c4d.DESCFLAGS_SET_NONE) mat.InsertShader(rough_colorizer) # Metalness metalnesstexshader = self.gltf_textures[ pbr_metal.metallic_roughness_texture.index].to_c4d_shader() metal_colorizer = c4d.BaseShader(c4d.Xcolorizer) metal_colorizer.SetParameter(c4d.SLA_COLORIZER_INPUT, c4d.SLA_COLORIZER_INPUT_BLUE, c4d.DESCFLAGS_SET_NONE) metal_colorizer.SetParameter(c4d.SLA_COLORIZER_TEXTURE, metalnesstexshader, c4d.DESCFLAGS_SET_NONE) metal_colorizer.InsertShader(metalnesstexshader) self.setGradientInvert(metal_colorizer) mat.SetParameter(reflectid + c4d.REFLECTION_LAYER_TRANS_TEXTURE, metal_colorizer, c4d.DESCFLAGS_SET_NONE) mat.InsertShader(metal_colorizer) roughness_factor = pbr_metal.roughness_factor if pbr_metal.roughness_factor is not None else 1.0 mat.SetParameter(reflectid + c4d.REFLECTION_LAYER_MAIN_VALUE_ROUGHNESS, roughness_factor, c4d.DESCFLAGS_SET_NONE)