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)
