Newer
Older
def poll(cls, context):
engine = context.scene.render.engine
mat = context.material
return (
mat
and mat.pov.type == "SURFACE"
and (engine in cls.COMPAT_ENGINES)
and not (mat.pov.material_use_nodes or mat.use_nodes)
)
def draw_header(self, context):
mat = context.material
Maurice Raybaud
committed
if mat.pov.caustics_enable:
self.layout.prop(
mat.pov, "caustics_enable", text="", icon="PMARKER_SEL"
)
Maurice Raybaud
committed
else:
self.layout.prop(
mat.pov, "caustics_enable", text="", icon="PMARKER"
)
def draw(self, context):
layout = self.layout
mat = context.material
Bastien Montagne
committed
layout.active = mat.pov.caustics_enable
Maurice Raybaud
committed
col = layout.column()
Bastien Montagne
committed
if mat.pov.caustics_enable:
Maurice Raybaud
committed
col.prop(mat.pov, "refraction_caustics")
if mat.pov.refraction_caustics:
col.prop(mat.pov, "refraction_type", text="")
Maurice Raybaud
committed
if mat.pov.refraction_type == "1":
col.prop(mat.pov, "fake_caustics_power", slider=True)
elif mat.pov.refraction_type == "2":
col.prop(mat.pov, "photons_dispersion", slider=True)
col.prop(mat.pov, "photons_dispersion_samples", slider=True)
Bastien Montagne
committed
col.prop(mat.pov, "photons_reflection")
if (
not mat.pov.refraction_caustics
and not mat.pov.photons_reflection
):
col = layout.column()
col.alignment = 'CENTER'
col.label(text="Caustics override is on, ")
col.label(text="but you didn't chose any !")
class MATERIAL_PT_strand(MaterialButtonsPanel, Panel):
"""Use this class to define Blender strand antialiasing buttons."""
bl_label = "Strand"
bl_options = {'DEFAULT_CLOSED'}
COMPAT_ENGINES = {'POVRAY_RENDER'}
@classmethod
def poll(cls, context):
mat = context.material
engine = context.scene.render.engine
return (
mat
and (mat.pov.type in {'SURFACE', 'WIRE', 'HALO'})
and (engine in cls.COMPAT_ENGINES)
)
def draw(self, context):
layout = self.layout
mat = context.material # don't use node material
tan = mat.strand
split = layout.split()
col = split.column()
sub = col.column(align=True)
sub.label(text="Size:")
sub.prop(tan, "root_size", text="Root")
sub.prop(tan, "tip_size", text="Tip")
sub.prop(tan, "size_min", text="Minimum")
sub.prop(tan, "use_blender_units")
sub = col.column()
sub.active = not mat.pov.use_shadeless
sub.prop(tan, "use_tangent_shading")
col.prop(tan, "shape")
col = split.column()
col.label(text="Shading:")
col.prop(tan, "width_fade")
ob = context.object
if ob and ob.type == 'MESH':
col.prop_search(
tan, "uv_layer", ob.data, "tessface_uv_textures", text=""
)
else:
col.prop(tan, "uv_layer", text="")
col.separator()
sub = col.column()
sub.active = not mat.pov.use_shadeless
sub.label(text="Surface diffuse:")
sub = col.column()
sub.prop(tan, "blend_distance", text="Distance")
class MATERIAL_PT_POV_replacement_text(MaterialButtonsPanel, Panel):
"""Use this class to define pov custom code declared name field."""
Maurice Raybaud
committed
bl_label = "Custom POV Code"
Campbell Barton
committed
COMPAT_ENGINES = {'POVRAY_RENDER'}
Maurice Raybaud
committed
def draw(self, context):
layout = self.layout
mat = context.material
Maurice Raybaud
committed
col.label(text="Replace properties with:")
Bastien Montagne
committed
col.prop(mat.pov, "replacement_text", text="")
Maurice Raybaud
committed
class TEXTURE_MT_POV_specials(bpy.types.Menu):
"""Use this class to define pov texture slot operations buttons."""
bl_label = "Texture Specials"
COMPAT_ENGINES = {'POVRAY_RENDER'}
def draw(self, context):
layout = self.layout
layout.operator("texture.slot_copy", icon='COPYDOWN')
layout.operator("texture.slot_paste", icon='PASTEDOWN')
class TEXTURE_UL_POV_texture_slots(bpy.types.UIList):
"""Use this class to show pov texture slots list.""" # used?
COMPAT_ENGINES = {'POVRAY_RENDER'}
def draw_item(
self, context, layout, data, item, icon, active_data, active_propname
):
# draw_item must handle the three layout types... Usually 'DEFAULT' and 'COMPACT' can share the same code.
if self.layout_type in {'DEFAULT', 'COMPACT'}:
# You should always start your row layout by a label (icon + text), or a non-embossed text field,
# this will also make the row easily selectable in the list! The later also enables ctrl-click rename.
# We use icon_value of label, as our given icon is an integer value, not an enum ID.
# Note "data" names should never be translated!
if slot:
layout.prop(
item, "texture", text="", emboss=False, icon='TEXTURE'
)
else:
layout.label(text="New", translate=False, icon_value=icon)
# 'GRID' layout type should be as compact as possible (typically a single icon!).
elif self.layout_type in {'GRID'}:
layout.alignment = 'CENTER'
layout.label(text="", icon_value=icon)
class MATERIAL_TEXTURE_SLOTS_UL_List(UIList):
"""Texture Slots UIList."""
def draw_item(self, context, layout, material, item, icon, active_data,
material_texture_list_index, index):
material = context.material#.pov
active_data = material
#tex = context.texture #may be needed later?
# We could write some code to decide which icon to use here...
custom_icon = 'TEXTURE'
# Make sure your code supports all 3 layout types
if self.layout_type in {'DEFAULT', 'COMPACT'}:
layout.label(item.name, icon = custom_icon)
elif self.layout_type in {'GRID'}:
layout.alignment = 'CENTER'
layout.label("", icon = custom_icon)
class WORLD_TEXTURE_SLOTS_UL_List(UIList):
"""Use this class to show pov texture slots list.""" # XXX Not used yet
def draw_item(
self,
context,
layout,
world,
item,
icon,
active_data,
active_texture_index,
index,
):
world = context.world # .pov
# tex = context.texture #may be needed later?
# We could write some code to decide which icon to use here...
custom_icon = 'TEXTURE'
# Make sure your code supports all 3 layout types
if self.layout_type in {'DEFAULT', 'COMPACT'}:
layout.label(item.name, icon=custom_icon)
elif self.layout_type in {'GRID'}:
layout.alignment = 'CENTER'
layout.label("", icon=custom_icon)
class MATERIAL_TEXTURE_SLOTS_UL_POV_layerlist(bpy.types.UIList):
"""Use this class to show pov texture slots list."""
index: bpy.props.IntProperty(name='index')
# foo = random prop
def draw_item(
self, context, layout, data, item, icon, active_data, active_propname
):
ob = data
slot = item
# draw_item must handle the three layout types... Usually 'DEFAULT' and 'COMPACT' can share the same code.
if self.layout_type in {'DEFAULT', 'COMPACT'}:
# You should always start your row layout by a label (icon + text), or a non-embossed text field,
# this will also make the row easily selectable in the list! The later also enables ctrl-click rename.
# We use icon_value of label, as our given icon is an integer value, not an enum ID.
# Note "data" names should never be translated!
if slot:
layout.prop(
item, "texture", text="", emboss=False, icon='TEXTURE'
)
else:
layout.label(text="New", translate=False, icon_value=icon)
# 'GRID' layout type should be as compact as possible (typically a single icon!).
elif self.layout_type in {'GRID'}:
layout.alignment = 'CENTER'
layout.label(text="", icon_value=icon)
class TEXTURE_PT_POV_context_texture(TextureButtonsPanel, Panel):
"""Use this class to show pov texture context buttons."""
bl_label = ""
bl_options = {'HIDE_HEADER'}
COMPAT_ENGINES = {'POVRAY_RENDER'}
@classmethod
def poll(cls, context):
engine = context.scene.render.engine
return engine in cls.COMPAT_ENGINES
# if not (hasattr(context, "texture_slot") or hasattr(context, "texture_node")):
# return False
return (
context.material
or context.world
or context.light
or context.texture
or context.line_style
or context.particle_system
or isinstance(context.space_data.pin_id, ParticleSettings)
or context.texture_user
) and (engine in cls.COMPAT_ENGINES)
def draw(self, context):
layout = self.layout
scene = context.scene
layout.prop(scene, "texture_context", expand=True)
if scene.texture_context == 'MATERIAL':
mat = context.scene.view_layers[
"View Layer"
].objects.active.active_material
row.template_list(
"MATERIAL_TEXTURE_SLOTS_UL_POV_layerlist",
"",
mat,
"pov_texture_slots",
mat.pov,
"active_texture_index",
)
col.operator("pov.textureslotadd", icon='ADD', text='')
col.operator("pov.textureslotremove", icon='REMOVE', text='')
if mat.pov_texture_slots:
index = mat.pov.active_texture_index
slot = mat.pov_texture_slots[index]
povtex = slot.name
tex = bpy.data.textures[povtex]
col.prop(tex, 'use_fake_user', text='')
layout.label(text='Find texture:')
layout.prop_search(
slot, 'texture_search', bpy.data, 'textures', text=''
)
# for i in range(18): # length of material texture slots
# mat.pov_texture_slots.add()
# Commented out below is a reminder of what existed in Blender Internal
slot = getattr(context, "texture_slot", None)
node = getattr(context, "texture_node", None)
space = context.space_data
mtl = getattr(context, "material", None)
if mtl != None:
wld = getattr(context, "world", None)
if wld != None:
lgt = getattr(context, "light", None)
if lgt != None:
#idblock = context.particle_system.settings
tex = getattr(context, "texture", None)
if tex != None:
idblock = scene.pov#pov_context_tex_datablock(context)
2342
2343
2344
2345
2346
2347
2348
2349
2350
2351
2352
2353
2354
2355
2356
2357
2358
2359
2360
2361
2362
2363
2364
2365
2366
2367
2368
2369
2370
2371
2372
2373
2374
2375
2376
2377
2378
2379
2380
2381
2382
pin_id = space.pin_id
#spacedependant.use_limited_texture_context = True
if space.use_pin_id and not isinstance(pin_id, Texture):
idblock = id_tex_datablock(pin_id)
pin_id = None
if not space.use_pin_id:
layout.row().prop(spacedependant, "texture_context", expand=True)
pin_id = None
if spacedependant.texture_context == 'OTHER':
if not pin_id:
layout.template_texture_user()
user = context.texture_user
if user or pin_id:
layout.separator()
row = layout.row()
if pin_id:
row.template_ID(space, "pin_id")
else:
propname = context.texture_user_property.identifier
row.template_ID(user, propname, new="texture.new")
if tex:
split = layout.split(factor=0.2)
if tex.use_nodes:
if slot:
split.label(text="Output:")
split.prop(slot, "output_node", text="")
else:
split.label(text="Type:")
split.prop(tex, "type", text="")
return
tex_collection = (pin_id is None) and (node is None) and (spacedependant.texture_context not in ('LINESTYLE','OTHER'))
if tex_collection:
pov = getattr(context, "pov", None)
active_texture_index = getattr(spacedependant, "active_texture_index", None)
print(active_texture_index)
row = layout.row()
row.template_list("TEXTURE_UL_texslots", "", idblock, "texture_slots",
idblock, "active_texture_index", rows=2, maxrows=16, type="DEFAULT")
# row.template_list("WORLD_TEXTURE_SLOTS_UL_List", "texture_slots", world,
# world.texture_slots, world, "active_texture_index", rows=2)
col = row.column(align=True)
col.operator("texture.slot_move", text="", icon='TRIA_UP').type = 'UP'
col.operator("texture.slot_move", text="", icon='TRIA_DOWN').type = 'DOWN'
col.menu("TEXTURE_MT_POV_specials", icon='DOWNARROW_HLT', text="")
if tex_collection:
layout.template_ID(idblock, "active_texture", new="texture.new")
elif node:
layout.template_ID(node, "texture", new="texture.new")
elif idblock:
layout.template_ID(idblock, "texture", new="texture.new")
if pin_id:
layout.template_ID(space, "pin_id")
if tex:
split = layout.split(factor=0.2)
if tex.use_nodes:
if slot:
split.label(text="Output:")
split.prop(slot, "output_node", text="")
else:
split.label(text="Type:")
class TEXTURE_PT_colors(TextureButtonsPanel, Panel):
"""Use this class to show pov color ramps."""
2426
2427
2428
2429
2430
2431
2432
2433
2434
2435
2436
2437
2438
2439
2440
2441
2442
2443
2444
2445
2446
2447
2448
2449
2450
2451
2452
2453
2454
2455
2456
bl_label = "Colors"
bl_options = {'DEFAULT_CLOSED'}
COMPAT_ENGINES = {'POVRAY_RENDER'}
def draw(self, context):
layout = self.layout
tex = context.texture
layout.prop(tex, "use_color_ramp", text="Ramp")
if tex.use_color_ramp:
layout.template_color_ramp(tex, "color_ramp", expand=True)
split = layout.split()
col = split.column()
col.label(text="RGB Multiply:")
sub = col.column(align=True)
sub.prop(tex, "factor_red", text="R")
sub.prop(tex, "factor_green", text="G")
sub.prop(tex, "factor_blue", text="B")
col = split.column()
col.label(text="Adjust:")
col.prop(tex, "intensity")
col.prop(tex, "contrast")
col.prop(tex, "saturation")
col = layout.column()
col.prop(tex, "use_clamp", text="Clamp")
class MATERIAL_OT_POV_texture_slot_add(Operator):
"""Use this class for the add texture slot button."""
bl_idname = "pov.textureslotadd"
bl_label = "Add"
bl_description = "Add texture_slot"
bl_options = {'REGISTER', 'UNDO'}
COMPAT_ENGINES = {'POVRAY_RENDER'}
def execute(self, context):
tex = bpy.data.textures.new(name='Texture', type='IMAGE')
tex.use_fake_user = True
ob = context.scene.view_layers["View Layer"].objects.active
slot = ob.active_material.pov_texture_slots.add()
slot.name = tex.name
slot.texture = tex.name
return {'FINISHED'}
class MATERIAL_OT_POV_texture_slot_remove(Operator):
"""Use this class for the remove texture slot button."""
bl_idname = "pov.textureslotremove"
bl_label = "Remove"
bl_description = "Remove texture_slot"
bl_options = {'REGISTER', 'UNDO'}
COMPAT_ENGINES = {'POVRAY_RENDER'}
def execute(self, context):
pass
# tex = bpy.data.textures.new()
# tex_slot = context.object.active_material.pov_texture_slots.add()
# tex_slot.name = tex.name
return {'FINISHED'}
"""Use this class to show pov texture slots panel."""
COMPAT_ENGINES = {'POVRAY_RENDER'}
@classmethod
def poll(cls, context):
if not hasattr(context, "pov_texture_slot"):
return False
engine = context.scene.render.engine
return TextureButtonsPanel.poll(cls, context) and (
engine in cls.COMPAT_ENGINES
)
class TEXTURE_PT_POV_type(TextureButtonsPanel, Panel):
"""Use this class to define pov texture type buttons."""
bl_label = "POV Textures"
COMPAT_ENGINES = {'POVRAY_RENDER'}
bl_options = {'HIDE_HEADER'}
Maurice Raybaud
committed
def draw(self, context):
layout = self.layout
tex = context.texture
split.label(text="POV:")
split.prop(tex.pov, "tex_pattern_type", text="")
# row = layout.row()
# row.template_list("WORLD_TEXTURE_SLOTS_UL_List", "texture_slots", world,
# world.texture_slots, world, "active_texture_index")
class TEXTURE_PT_POV_preview(TextureButtonsPanel, Panel):
"""Use this class to define pov texture preview panel."""
bl_label = "Preview"
COMPAT_ENGINES = {'POVRAY_RENDER'}
bl_options = {'HIDE_HEADER'}
@classmethod
def poll(cls, context):
engine = context.scene.render.engine
if not hasattr(context, "pov_texture_slot"):
tex = context.texture
mat = bpy.context.active_object.active_material
return (
tex
and (tex.pov.tex_pattern_type != 'emulator')
and (engine in cls.COMPAT_ENGINES)
)
def draw(self, context):
tex = context.texture
slot = getattr(context, "pov_texture_slot", None)
idblock = pov_context_tex_datablock(context)
layout = self.layout
# if idblock:
# layout.template_preview(tex, parent=idblock, slot=slot)
if tex.pov.tex_pattern_type != 'emulator':
layout.operator("tex.preview_update")
else:
layout.template_preview(tex, slot=slot)
class TEXTURE_PT_POV_parameters(TextureButtonsPanel, Panel):
"""Use this class to define pov texture pattern buttons."""
bl_label = "POV Pattern Options"
COMPAT_ENGINES = {'POVRAY_RENDER'}
def draw(self, context):
mat = bpy.context.active_object.active_material
layout = self.layout
tex = context.texture
if tex is not None and tex.pov.tex_pattern_type != 'emulator':
if tex.pov.tex_pattern_type == 'agate':
layout.prop(
tex.pov, "modifier_turbulence", text="Agate Turbulence"
)
if tex.pov.tex_pattern_type in {'spiral1', 'spiral2'}:
layout.prop(tex.pov, "modifier_numbers", text="Number of arms")
if tex.pov.tex_pattern_type == 'tiling':
layout.prop(tex.pov, "modifier_numbers", text="Pattern number")
if tex.pov.tex_pattern_type == 'magnet':
layout.prop(tex.pov, "magnet_style", text="Magnet style")
if tex.pov.tex_pattern_type == 'quilted':
row = layout.row(align=align)
row.prop(tex.pov, "modifier_control0", text="Control0")
row.prop(tex.pov, "modifier_control1", text="Control1")
if tex.pov.tex_pattern_type == 'brick':
col = layout.column(align=align)
row = col.row()
row.prop(tex.pov, "brick_size_x", text="Brick size X")
row.prop(tex.pov, "brick_size_y", text="Brick size Y")
row.prop(tex.pov, "brick_size_z", text="Brick size Z")
row.prop(tex.pov, "brick_mortar", text="Brick mortar")
if tex.pov.tex_pattern_type in {'julia', 'mandel', 'magnet'}:
col = layout.column(align=align)
if tex.pov.tex_pattern_type == 'julia':
row = col.row()
row.prop(tex.pov, "julia_complex_1", text="Complex 1")
row.prop(tex.pov, "julia_complex_2", text="Complex 2")
if (
tex.pov.tex_pattern_type == 'magnet'
and tex.pov.magnet_style == 'julia'
):
row = col.row()
row.prop(tex.pov, "julia_complex_1", text="Complex 1")
row.prop(tex.pov, "julia_complex_2", text="Complex 2")
row = col.row()
if tex.pov.tex_pattern_type in {'julia', 'mandel'}:
row.prop(tex.pov, "f_exponent", text="Exponent")
row.prop(tex.pov, "magnet_type", text="Type")
row.prop(tex.pov, "f_iter", text="Iterations")
row.prop(tex.pov, "f_ior", text="Interior")
row.prop(tex.pov, "f_ior_fac", text="Factor I")
row.prop(tex.pov, "f_eor", text="Exterior")
row.prop(tex.pov, "f_eor_fac", text="Factor E")
layout.label(text="Gradient orientation:")
column_flow = layout.column_flow(columns=3, align=True)
column_flow.prop(tex.pov, "grad_orient_x", text="X")
column_flow.prop(tex.pov, "grad_orient_y", text="Y")
column_flow.prop(tex.pov, "grad_orient_z", text="Z")
if tex.pov.tex_pattern_type == 'pavement':
layout.prop(
tex.pov, "pave_sides", text="Pavement:number of sides"
)
col = layout.column(align=align)
column_flow = col.column_flow(columns=3, align=True)
column_flow.prop(tex.pov, "pave_tiles", text="Tiles")
2642
2643
2644
2645
2646
2647
2648
2649
2650
2651
2652
2653
2654
2655
2656
2657
2658
2659
2660
2661
2662
2663
2664
2665
if tex.pov.pave_sides == '4' and tex.pov.pave_tiles == 6:
column_flow.prop(tex.pov, "pave_pat_35", text="Pattern")
if tex.pov.pave_sides == '6' and tex.pov.pave_tiles == 5:
column_flow.prop(tex.pov, "pave_pat_22", text="Pattern")
if tex.pov.pave_sides == '4' and tex.pov.pave_tiles == 5:
column_flow.prop(tex.pov, "pave_pat_12", text="Pattern")
if tex.pov.pave_sides == '3' and tex.pov.pave_tiles == 6:
column_flow.prop(tex.pov, "pave_pat_12", text="Pattern")
if tex.pov.pave_sides == '6' and tex.pov.pave_tiles == 4:
column_flow.prop(tex.pov, "pave_pat_7", text="Pattern")
if tex.pov.pave_sides == '4' and tex.pov.pave_tiles == 4:
column_flow.prop(tex.pov, "pave_pat_5", text="Pattern")
if tex.pov.pave_sides == '3' and tex.pov.pave_tiles == 5:
column_flow.prop(tex.pov, "pave_pat_4", text="Pattern")
if tex.pov.pave_sides == '6' and tex.pov.pave_tiles == 3:
column_flow.prop(tex.pov, "pave_pat_3", text="Pattern")
if tex.pov.pave_sides == '3' and tex.pov.pave_tiles == 4:
column_flow.prop(tex.pov, "pave_pat_3", text="Pattern")
if tex.pov.pave_sides == '4' and tex.pov.pave_tiles == 3:
column_flow.prop(tex.pov, "pave_pat_2", text="Pattern")
if tex.pov.pave_sides == '6' and tex.pov.pave_tiles == 6:
column_flow.label(text="!!! 5 tiles!")
column_flow.prop(tex.pov, "pave_form", text="Form")
if tex.pov.tex_pattern_type == 'function':
layout.prop(tex.pov, "func_list", text="Functions")
if (
tex.pov.tex_pattern_type == 'function'
and tex.pov.func_list != "NONE"
):
func = None
if tex.pov.func_list in {"f_noise3d", "f_ph", "f_r", "f_th"}:
func = 0
2674
2675
2676
2677
2678
2679
2680
2681
2682
2683
2684
2685
2686
2687
2688
2689
2690
2691
2692
2693
2694
2695
2696
2697
2698
2699
2700
2701
2702
2703
if tex.pov.func_list in {
"f_comma",
"f_crossed_trough",
"f_cubic_saddle",
"f_cushion",
"f_devils_curve",
"f_enneper",
"f_glob",
"f_heart",
"f_hex_x",
"f_hex_y",
"f_hunt_surface",
"f_klein_bottle",
"f_kummer_surface_v1",
"f_lemniscate_of_gerono",
"f_mitre",
"f_nodal_cubic",
"f_noise_generator",
"f_odd",
"f_paraboloid",
"f_pillow",
"f_piriform",
"f_quantum",
"f_quartic_paraboloid",
"f_quartic_saddle",
"f_sphere",
"f_steiners_roman",
"f_torus_gumdrop",
"f_umbrella",
}:
if tex.pov.func_list in {
"f_bicorn",
"f_bifolia",
"f_boy_surface",
"f_superellipsoid",
"f_torus",
}:
if tex.pov.func_list in {
"f_ellipsoid",
"f_folium_surface",
"f_hyperbolic_torus",
"f_kampyle_of_eudoxus",
"f_parabolic_torus",
"f_quartic_cylinder",
"f_torus2",
}:
if tex.pov.func_list in {
"f_blob2",
"f_cross_ellipsoids",
"f_flange_cover",
"f_isect_ellipsoids",
"f_kummer_surface_v2",
"f_ovals_of_cassini",
"f_rounded_box",
"f_spikes_2d",
"f_strophoid",
}:
if tex.pov.func_list in {
"f_algbr_cyl1",
"f_algbr_cyl2",
"f_algbr_cyl3",
"f_algbr_cyl4",
"f_blob",
"f_mesh1",
"f_poly4",
"f_spikes",
}:
if tex.pov.func_list in {
"f_devils_curve_2d",
"f_dupin_cyclid",
"f_folium_surface_2d",
"f_hetero_mf",
"f_kampyle_of_eudoxus_2d",
"f_lemniscate_of_gerono_2d",
"f_polytubes",
"f_ridge",
"f_ridged_mf",
"f_spiral",
"f_witch_of_agnesi",
}:
if tex.pov.func_list in {
"f_helix1",
"f_helix2",
"f_piriform_2d",
"f_strophoid_2d",
}:
func = 7
if tex.pov.func_list == "f_helical_torus":
func = 8
column_flow = layout.column_flow(columns=3, align=True)
column_flow.prop(tex.pov, "func_plus_x", text="")
column_flow.prop(tex.pov, "func_x", text="Value")
column_flow = layout.column_flow(columns=3, align=True)
column_flow.prop(tex.pov, "func_plus_y", text="")
column_flow.prop(tex.pov, "func_y", text="Value")
column_flow = layout.column_flow(columns=3, align=True)
column_flow.prop(tex.pov, "func_plus_z", text="")
column_flow.prop(tex.pov, "func_z", text="Value")
row = layout.row(align=align)
if func > 0:
row.prop(tex.pov, "func_P0", text="P0")
if func > 1:
row.prop(tex.pov, "func_P1", text="P1")
row = layout.row(align=align)
if func > 2:
row.prop(tex.pov, "func_P2", text="P2")
if func > 3:
row.prop(tex.pov, "func_P3", text="P3")
row = layout.row(align=align)
if func > 4:
row.prop(tex.pov, "func_P4", text="P4")
if func > 5:
row.prop(tex.pov, "func_P5", text="P5")
row = layout.row(align=align)
if func > 6:
row.prop(tex.pov, "func_P6", text="P6")
if func > 7:
row.prop(tex.pov, "func_P7", text="P7")
row = layout.row(align=align)
row.prop(tex.pov, "func_P8", text="P8")
row.prop(tex.pov, "func_P9", text="P9")
###################################################End Patterns############################
layout.prop(tex.pov, "warp_types", text="Warp types") # warp
if tex.pov.warp_types == "TOROIDAL":
layout.prop(
tex.pov, "warp_tor_major_radius", text="Major radius"
)
if tex.pov.warp_types not in {"CUBIC", "NONE"}:
layout.prop(
tex.pov, "warp_orientation", text="Warp orientation"
)
col = layout.column(align=align)
row = col.row()
row.prop(tex.pov, "warp_dist_exp", text="Distance exponent")
row = col.row()
row.prop(tex.pov, "modifier_frequency", text="Frequency")
row.prop(tex.pov, "modifier_phase", text="Phase")
row.label(text="Offset:")
row.label(text="Scale:")
row.label(text="Rotate:")
col = layout.column(align=align)
row = col.row()
row.prop(tex.pov, "tex_mov_x", text="X")
row.prop(tex.pov, "tex_scale_x", text="X")
row.prop(tex.pov, "tex_rot_x", text="X")
row.prop(tex.pov, "tex_mov_y", text="Y")
row.prop(tex.pov, "tex_scale_y", text="Y")
row.prop(tex.pov, "tex_rot_y", text="Y")
row.prop(tex.pov, "tex_mov_z", text="Z")
row.prop(tex.pov, "tex_scale_z", text="Z")
row.prop(tex.pov, "tex_rot_z", text="Z")
row.label(text="Turbulence:")
col = layout.column(align=align)
row = col.row()
row.prop(tex.pov, "warp_turbulence_x", text="X")
row.prop(tex.pov, "modifier_octaves", text="Octaves")
row.prop(tex.pov, "warp_turbulence_y", text="Y")
row.prop(tex.pov, "modifier_lambda", text="Lambda")
row.prop(tex.pov, "warp_turbulence_z", text="Z")
row.prop(tex.pov, "modifier_omega", text="Omega")
class TEXTURE_PT_POV_influence(TextureSlotPanel, Panel):
"""Use this class to define pov texture influence buttons."""
bl_label = "Influence"
COMPAT_ENGINES = {'POVRAY_RENDER'}
bl_space_type = 'PROPERTIES'
bl_region_type = 'WINDOW'
# bl_context = 'texture'
idblock = pov_context_tex_datablock(context)
if (
isinstance(idblock, Brush)
and bpy.context.scene.texture_context == 'OTHER'
): # XXX replace by isinstance(idblock, bpy.types.Brush) and ...
# if not getattr(context, "pov_texture_slot", None):
return engine in cls.COMPAT_ENGINES
def draw(self, context):
layout = self.layout
idblock = pov_context_tex_datablock(context)
# tex = context.pov_texture_slot
mat = bpy.context.active_object.active_material
texslot = mat.pov_texture_slots[
mat.active_texture_index
] # bpy.data.textures[mat.active_texture_index]
tex = bpy.data.textures[
mat.pov_texture_slots[mat.active_texture_index].texture
]
def factor_but(layout, toggle, factor, name):
row = layout.row(align=True)
row.prop(texslot, toggle, text="")
sub.active = getattr(texslot, toggle)
sub.prop(texslot, factor, text=name, slider=True)
return sub # XXX, temp. use_map_normal needs to override.
if isinstance(idblock, Material):
split = layout.split()
if idblock.pov.type in {'SURFACE', 'WIRE'}:
split = layout.split()
col = split.column()
col.label(text="Diffuse:")
factor_but(
col, "use_map_diffuse", "diffuse_factor", "Intensity"
)
factor_but(
col,
"use_map_color_diffuse",
"diffuse_color_factor",
"Color",
)
factor_but(col, "use_map_alpha", "alpha_factor", "Alpha")
factor_but(
col,
"use_map_translucency",
"translucency_factor",
"Translucency",
)
factor_but(
col, "use_map_specular", "specular_factor", "Intensity"
)
factor_but(
col, "use_map_color_spec", "specular_color_factor", "Color"
)
factor_but(
col, "use_map_hardness", "hardness_factor", "Hardness"
)
col = split.column()
col.label(text="Shading:")
factor_but(col, "use_map_ambient", "ambient_factor", "Ambient")
factor_but(col, "use_map_emit", "emit_factor", "Emit")
factor_but(col, "use_map_mirror", "mirror_factor", "Mirror")
factor_but(col, "use_map_raymir", "raymir_factor", "Ray Mirror")
col.label(text="Geometry:")
# XXX replace 'or' when displacement is fixed to not rely on normal influence value.
sub_tmp = factor_but(
col, "use_map_normal", "normal_factor", "Normal"
)
sub_tmp.active = (
texslot.use_map_normal or texslot.use_map_displacement
)
# END XXX
factor_but(col, "use_map_warp", "warp_factor", "Warp")
factor_but(
col,
"use_map_displacement",
"displacement_factor",
"Displace",
)
# ~ sub.active = texslot.use_map_translucency or texslot.map_emit or texslot.map_alpha or texslot.map_raymir or texslot.map_hardness or texslot.map_ambient or texslot.map_specularity or texslot.map_reflection or texslot.map_mirror
# ~ sub.prop(texslot, "default_value", text="Amount", slider=True)
elif idblock.pov.type == 'HALO':
layout.label(text="Halo:")
split = layout.split()
col = split.column()
factor_but(
col,
"use_map_color_diffuse",
"diffuse_color_factor",
"Color",
)
factor_but(col, "use_map_alpha", "alpha_factor", "Alpha")
col = split.column()
factor_but(col, "use_map_raymir", "raymir_factor", "Size")
factor_but(
col, "use_map_hardness", "hardness_factor", "Hardness"
)
factor_but(
col, "use_map_translucency", "translucency_factor", "Add"
)
elif idblock.pov.type == 'VOLUME':
layout.label(text="Volume:")
split = layout.split()
col = split.column()
factor_but(col, "use_map_density", "density_factor", "Density")
factor_but(
col, "use_map_emission", "emission_factor", "Emission"
)
factor_but(
col, "use_map_scatter", "scattering_factor", "Scattering"