easybpy.py

#region INFO
'''
    == EasyBPY 0.3.0 == (WIP)
    Managed by Curtis Holt
    https://curtisholt.online/links
    ---
    This purpose of this module is to simplify the use of the Blender API
    (bpy) by creating an extra layer of abstraction that is more human-
    readable, memorizable and reduces the user's exposure to complex code 
    paths.
    EasyBPY can be added to Blender by installing it into the:
                ../scripts/modules
    folder in the user preferences. The file can also be re-packaged with
    any other addon, so long as the developer respects the limitations of
    the GPL license, outlined below.

    Please note that this file has been structurally designed to be used
    with text region folding, which can be used in Visual Studio Code by
    pressing CTRL+K+0. Treat the region folds like chapters of a book.
'''
def easybpy_version(): # [ ]
    return "0.3.0"
'''
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
'''
#endregion
#region IMPORTS
import bpy
import bpy.types
from mathutils import Vector, Matrix, Euler
import math
import random
#endregion
#region RENDER SETTINGS
def set_render_engine_to_cycles(): # [4.2]
    get_scene().render.engine = 'CYCLES'

def set_render_engine_cycles():  # [4.2]
    set_render_engine_to_cycles()

def set_render_engine_to_eevee():  # [4.2]
    get_scene().render.engine = 'BLENDER_EEVEE_NEXT'

def set_render_engine_eevee():  # [4.2]
    set_render_engine_to_eevee()

def render_image(use_view = False):  # [4.2]
    bpy.ops.render.render(use_viewport=use_view)
    return bpy.data.images['Render Result']

def render_animation(use_view = False):  # [4.2]
    bpy.ops.render.render(animation=True, use_viewport=use_view)

def set_render_resolution(x, y):  # [4.2]
    get_scene().render.resolution_x = x
    get_scene().render.resolution_y = y

def get_render_resolution():  # [4.2]
    reslist = []
    reslist.append(get_scene().render.resolution_x)
    reslist.append(get_scene().render.resolution_y)
    return reslist

def render_resolution(x = None, y = None):  # [4.2]
    if x is not None and y is not None:
        set_render_resolution(x,y)
    else:
        return get_render_resolution()

def set_render_resolution_percentage(percent):  # [4.2]
    get_scene().render.resolution_percentage = percent

def set_render_percentage(percent = None):  # [4.2]
    set_render_resolution_percentage(percent)

def set_render_percent(percent = None):  # [4.2]
    set_render_resolution_percentage(percent)

def get_render_resolution_percentage():  # [4.2]
    return get_scene().render.resolution_percentage

def render_resolution_percentage(percent = None):  # [4.2]
    if percent is not None:
        set_render_resolution_percentage(percent)
    else:
        return get_render_resolution_percentage()

def render_resolution_percent(percent = None):  # [4.2]
    if percent is not None:
        set_render_resolution_percentage(percent)
    else:
        return get_render_resolution_percentage()

def set_render_pixel_aspect_ratio(x, y):  # [4.2]
    get_scene().render.pixel_aspect_x = x
    get_scene().render.pixel_aspect_y = y

def get_render_pixel_aspect_ratio():  # [4.2]
    aspectlist = []
    aspectlist.append(get_scene().render.pixel_aspect_x)
    aspectlist.append(get_scene().render.pixel_aspect_y)
    return aspectlist

def render_aspect_ratio(x = None, y = None):  # [4.2]
    if x is not None and y is not None:
        set_render_pixel_aspect_ratio(x,y)
    else:
        return get_render_pixel_aspect_ratio()

def current_frame(val = None):  # [4.2]
    if val is None:
        return get_scene().frame_current
    else:
        get_scene().frame_current = val

def set_frame(val = None):  # [4.2]
    current_frame(val)

def frame_start(val = None):  # [4.2]
    if val is None:
        return get_scene().frame_start
    else:
        get_scene().frame_start = val

def frame_end(val = None):  # [4.2]
    if val is None:
        return get_scene().frame_end
    else:
        get_scene().frame_end = val

def set_current_frame(val = None):  # [4.2]
    current_frame(val)

def set_frame_start(val = None):  # [4.2]
    frame_start(val)

def set_frame_end(val = None):  # [4.2]
    frame_end(val)

def set_start_frame(val = None):  # [4.2]
    frame_start(val)

def set_end_frame(val = None):  # [4.2]
    frame_end(val)

def set_frame_interval(start = None, end = None):  # [4.2]
    frame_start(start)
    frame_end(end)

def set_frame_step(val):  # [4.2]
    get_scene().frame_step = val

def set_render_fps(val, base = 1.0):  # [4.2]
    get_scene().render.fps = val
    get_scene().render.fps_base = base
#endregion
#region APPENDING / LINKING
def append(file, category, object): # [4.2] # Example: append("path/to/file.blend", 'Material', 'PBR Material')
    if '\\' in file:
        #fpath = file.replace('\\', '/') => Not viable for numeric folders.
        print("Please use forward slashes in path string.")
    else:
        if isinstance(object, list) is False:
            object = [object]
        for o in object:
            filepath = file + "\\" + category + "\\" + o
            directory = file + "\\" + category + "\\"
            filename = o
            bpy.ops.wm.append(filepath = filepath, directory = directory, filename = filename)

def append_brush(file, name): # [ ]
    append(file, "Brush", name)

def append_collection(file, name): # [ ]
    append(file, "Collection", name)
    
def append_freestyle_line_style(file, name): # [ ]
    append(file, "FreestyleLineStyle", name)

def append_image(file, name): # [ ]
    append(file, "Image", name)
    
def append_material(file, name): # [ ]
    append(file, "Material", name)
    
def append_mesh(file, name): # [ ]
    append(file, "Mesh", name)

def append_node_tree(file, name): # [ ]
    append(file, "NodeTree", name)

def append_object(file, name): # [ ]
    append(file, "Object", name)

def append_scene(file, name): # [ ]
    append(file, "Scene", name)

def append_text(file, name): # [ ]
    append(file, "Text", name)

def append_texture(file, name): # [ ]
    append(file, "Texture", name)

def append_workspace(file, name): # [ ]
    append(file, "Workspace", name)

def append_world(file, name): # [ ]
    append(file, "World", name)

def link(file, category, object): # [ ]
    if '\\' in file:
        #fpath = file.replace('\\', '/') => Not viable for numeric folders.
        print("Please use forward slashes in path string.")
    else:
        if isinstance(object, list) is False:
            object = [object]
        for o in object:
            filepath = file + "\\" + category + "\\" + o
            directory = file + "\\" + category + "\\"
            filename = o
            bpy.ops.wm.link(filepath = filepath, directory = directory, filename = filename)

def link_brush(file, name): # [ ]
    link(file, "Brush", name)

def link_collection(file, name): # [ ]
    link(file, "Collection", name)
    
def link_freestyle_line_style(file, name): # [ ]
    link(file, "FreestyleLineStyle", name)

def link_image(file, name): # [ ]
    link(file, "Image", name)
    
def link_material(file, name): # [ ]
    link(file, "Material", name)
    
def link_mesh(file, name): # [ ]
    link(file, "Mesh", name)

def link_node_tree(file, name): # [ ]
    link(file, "NodeTree", name)

def link_object(file, name): # [ ]
    link(file, "Object", name)

def link_scene(file, name): # [ ]
    link(file, "Scene", name)

def link_text(file, name): # [ ]
    link(file, "Text", name)

def link_texture(file, name): # [ ]
    link(file, "Texture", name)

def link_workspace(file, name): # [ ]
    link(file, "Workspace", name)

def link_world(file, name): # [ ]
    link(file, "World", name)

#endregion
#region OBJECTS
def create_object(name = None, col = None): # [ ]
    if name is None:
        name = "New Object"
    m = bpy.data.meshes.new(name)
    o = bpy.data.objects.new(name, m)
    col_ref = None
    # Assess col
    if col == None:
        col_ref=bpy.context.view_layer.active_layer_collection.collection
    elif is_string(col):
        if col in bpy.data.collections:
            col_ref = bpy.data.collections[col]
        else:
            col_ref = create_collection(col)
    else:
        col_ref = col
    col_ref.objects.link(o)
    return o

def copy_object(tocopy, col = None): # [ ]
    # Set up vars
    new_obj = None
    to_copy = get_object(tocopy)
    col_ref = None
    
    # Assess col
    if col == None:
        col_ref = get_active_collection()
    elif is_string(col):
        if collection_exists(col):
            col_ref = get_collection(col)
        else:
            col_ref = create_collection(col)
    else:
        col_ref = col
    # Perform action
    new_obj = to_copy.copy()
    if new_obj.data is not None:
        new_obj.data = to_copy.data.copy()
    new_obj.animation_data_clear()
    col_ref.objects.link(new_obj)
    return new_obj

def get_active_object(): # [ ]
    return bpy.context.active_object

def set_active_object(ref=None): # [ ]
    objref = get_object(ref)
    bpy.context.view_layer.objects.active = objref 

def clear_active_object(): # [ ]
    bpy.context.view_layer.objects.active = None

def active_object(): # [ ]
    return get_active_object()

def get_selected_object(): # [ ]
    return get_active_object()

def selected_object(): # [ ]
    return get_selected_object()

def ao(): # [ ]
    return get_active_object()

def so(): # [ ]
    return get_selected_objects()

def get_selected_objects(): # [ ]
    return bpy.context.selected_objects

def get_all_objects(): # [ ]
    return bpy.data.objects

def get_list_of_objects(): # [ ]
    get_all_objects()

def select_object(ref, make_active=True): # [ ]
    objref = get_object(ref)
    objref.select_set(True)
    if make_active:
        bpy.context.view_layer.objects.active = objref

def select_objects(ref): # [ ]
    objref = get_objects(ref)
    for o in objref:
        o.select_set(True)
    return objref

def selected_objects(): # [ ]
    return get_selected_objects()

def select_all_objects(col = None): # [ ]
    if col == None:
        for co in bpy.context.scene.objects:
            co.select_set(True)
    else:
        col_ref = None
        if is_string(col):
            if collection_exists(col):
                col_ref = get_collection(col)
        else:
            col_ref = col
        for c in col_ref.objects:
            c.select_set(True)

def select_only(ref = None): # [ ]
    objref = get_object(ref)
    deselect_all_objects()
    select_object(objref, True)

def deselect_object(ref): # [ ]
    objref = get_object(ref)
    objref.select_set(False)

def deselect_all_objects(): # [ ]
    for ob in so():
        ob.select_set(False)

def delete_selected_objects(): # [ ]
    bpy.ops.object.delete()

def delete_object(ref = None): # [ ]
    objref = get_object(ref)
    bpy.data.objects.remove(objref, do_unlink=True)

def delete_objects(objlist = None): # [ ]
    objlist = get_objects()
    for obj in objlist:
        ref = get_object(obj)
        bpy.data.objects.remove(ref, do_unlink=True)

def duplicate_object(tocopy,col): # [ ]
    return copy_object(tocopy,col)

def instance_object(ref, newname = None, col = None): # [ ]
    deselect_all_objects()
    select_object(ref)
    bpy.ops.object.duplicate_move_linked()
    o = selected_object()
    if newname is not None:
        o.name = newname
    if col is not None:
        link_object_to_collection(o,col)
    return o

def get_object(ref): # [ ]
    objref = None
    if ref is None:
        objref = ao()
    else:
        if is_string(ref):
            if object_exists(ref):
                objref = bpy.data.objects[ref]
        else:
            objref = ref
    return objref

def get_obj(ref): # [ ]
    return get_object(ref)

def get_objects(ref = None): # [ ]
    objref = []
    if ref is None:
        objref = so()
    else:
        if isinstance(ref, list):
            if len(ref) > 0:
                if isinstance(ref[0], bpy.types.Object):
                    objref = ref
                elif isinstance(ref[0], str):
                    for ob_name in ref:
                        if object_exists(ob_name):
                            objref.append(bpy.data.objects[ob_name])
        elif is_string(ref):
            if object_exists(ref):
                objref.append(bpy.data.objects[ref])
        elif isinstance(ref, bpy.types.Object) :
            objref.append(ref)
    return objref

def get_objs(ref = None): # [ ]
    return get_objects(ref)

def get_median_point_of_objects(objs): # [ ]
    point_loc = Vector()
    for obj in objs:
        point_loc += obj.location
    point_loc /= len(objs)
    return point_loc

def object_exists(ref): # [ ]
    if is_string(ref):
        if ref in bpy.data.objects:
            return True
        else:
            return False
    # redundant but for safety
    else:
        if ref.name in bpy.data.objects:
            return True
        else:
            return False

def rename_object(obj, newname): # [ ]
    objref = None
    # obj is string
    if is_string(obj):
        objref = get_object(obj)
    else:
        objref = obj
    # set name - only if string
    if is_string(newname):
        objref.name = newname
        return True
    else:
        return False

def get_parent(ref = None): # [ ]
    return get_object(ref).parent

def get_children(ref = None): # [ ]
    return get_object(ref).children

def set_parent(child = None,parent = None): # [ ]
    child = get_object(child)
    parent = get_object(parent)
    child.parent = parent 
    child.matrix_parent_inverse = parent.matrix_world.inverted()

def clear_parent(ref = None, keep_location = True): # [ ]
    ref = get_object(ref)
    loc = ref.matrix_world.to_translation()
    print(loc)
    ref.parent = None
    if keep_location:
        ref.location = loc

def get_bounding_box(ref = None): # [ ]
    return get_object(ref).bound_box

def get_bounding_box_corners(ref = None): # [ ]
    return [ref.matrix_world @ Vector(corner) for corner in get_bounding_box(ref)]
#endregion
#region OBJECTS - CONVERSION
def convert_to_mesh(ref): # [ ]
    objref = get_object(ref)
    deselect_all_objects()
    select_object(objref)
    bpy.ops.object.convert(target='MESH')

def convert_to_grease_pencil(ref): # [ ]
    objref = get_object(ref)
    deselect_all_objects()
    select_object(objref)
    bpy.ops.object.convert(target='GPENCIL')

def convert_to_curve(ref): # [ ]
    objref = get_object(ref)
    deselect_all_objects()
    select_object(objref)
    bpy.ops.object.convert(target='CURVE')
#endregion
#region OBJECTS - SELECTION
def select_all_meshes(): # [ ]
    bpy.ops.object.select_by_type(type='MESH')

def select_all_curves(): # [ ]
    bpy.ops.object.select_by_type(type='CURVE')

def select_all_surfaces(): # [ ]
    bpy.ops.object.select_by_type(type='SURFACE')

def select_all_metas(): # [ ]
    bpy.ops.object.select_by_type(type='META')

def select_all_text(): # [ ]
    bpy.ops.object.select_by_type(type='FONT')

def select_all_hair(): # [ ]
    bpy.ops.object.select_by_type(type='HAIR')

def select_all_point_clouds(): # [ ]
    bpy.ops.object.select_by_type(type='POINTCLOUD')

def select_all_volumes(): # [ ]
    bpy.ops.object.select_by_type(type='VOLUME')

def select_all_armatures(): # [ ]
    bpy.ops.object.select_by_type(type='ARMATURE')

def select_all_lattices(): # [ ]
    bpy.ops.object.select_by_type(type='LATTICE')

def select_all_empties(): # [ ]
    bpy.ops.object.select_by_type(type='EMPTY')

def select_all_grease_pencils(): # [ ]
    bpy.ops.object.select_by_type(type='GPENCIL')

def select_all_cameras(): # [ ]
    bpy.ops.object.select_by_type(type='CAMERA')

def select_all_lights(): # [ ]
    bpy.ops.object.select_by_type(type='LIGHT')

def select_all_speakers(): # [ ]
    bpy.ops.object.select_by_type(type='SPEAKER')

def select_all_light_probes(): # [ ]
    bpy.ops.object.select_by_type(type='LIGHT_PROBE')

def invert_selection(): # [ ]
    bpy.ops.object.select_all(action='INVERT')

def get_objects_with_modifiers(): # [ ]
    objlist = []
    for obj in bpy.data.objects:
        if len(obj.modifiers) > 0:
            objlist.append(obj)
    return objlist

def select_objects_with_modifiers(): # [ ]
    deselect_all_objects()
    for obj in bpy.data.objects:
        if len(obj.modifiers) > 0:
            select_object(obj)

# Custom Selection
def get_objects_including(include, case_sensitive = True): # [ ]
    objlist = []
    for o in bpy.context.view_layer.objects:
        if case_sensitive is True:
            if include in o.name:
                objlist.append(o)
        else:
            if (include.lower() in o.name) or (include.upper() in o.name) or (include in o.name):
                objlist.append(o)
    return objlist

def select_objects_including(include, case_sensitive = True): # [ ]
    for o in bpy.context.view_layer.objects:
        if case_sensitive is True:
            if include in o.name:
                o.select_set(True)
        else:
            if (include.lower() in o.name) or (include.upper() in o.name) or (include in o.name):
                o.select_set(True)

def get_objects_by_vertex(count = 0, mode="EQUAL"): # [ ]
    cmode = mode.upper()
    objlist = []
    for o in bpy.data.objects:
        if isinstance(o.data, bpy.types.Mesh):
            # o.data / len(o.data.vertices)
            if cmode == "EQUAL" or cmode == "SAME":
                if len(o.data.vertices) == count:
                    objlist.append(o)
            if cmode == "GREATER" or cmode == "MORE":
                if len(o.data.vertices) > count:
                    objlist.append(o)
            if cmode == "LESS" or cmode == "FEWER":
                if len(o.data.vertices) < count:
                    objlist.append(o)
    return objlist

def select_objects_by_vertex(count = 0, mode="EQUAL"): # [ ]
    objs = get_objects_by_vertex(count, mode)
    for o in objs:
        o.select_set(True)

#endregion
#region OBJECTS - PRIMITIVES
# Mesh
def create_plane(): # [ ]
    bpy.ops.mesh.primitive_plane_add()
    return active_object()

def create_cube(): # [ ]
    bpy.ops.mesh.primitive_cube_add()
    return active_object()

def create_circle(): # [ ]
    bpy.ops.mesh.primitive_circle_add()
    return active_object()

def create_cylinder(): # [ ]
    bpy.ops.mesh.primitive_cylinder_add()
    return active_object()

def create_uv_sphere(): # [ ]
    bpy.ops.mesh.primitive_uv_sphere_add()
    return active_object()

def create_sphere(): # [ ]
    return create_uv_sphere()

def create_ico_sphere(): # [ ]
    bpy.ops.mesh.primitive_ico_sphere_add()
    return active_object()

def create_cone(): # [ ]
    bpy.ops.mesh.primitive_cone_add()
    return active_object()

def create_torus(): # [ ]
    bpy.ops.mesh.primitive_torus_add()
    return active_object()

def create_grid(): # [ ]
    bpy.ops.mesh.primitive_grid_add()
    return active_object()

def create_suzanne(): # [ ]
    bpy.ops.mesh.primitive_monkey_add()
    return active_object()

def create_monkey(): # [ ]
    return create_suzanne()

# Curve
def create_bezier_curve(): # [ ]
    bpy.ops.curve.primitive_bezier_curve_add()
    return active_object()

def create_bezier(): # [ ]
    return create_bezier_curve()

def create_circle_curve(): # [ ]
    bpy.ops.curve.primitive_bezier_circle_add()
    return active_object()

def create_nurbs_curve(): # [ ]
    bpy.ops.curve.primitive_nurbs_curve_add()
    return active_object()

def create_nurbs_circle(): # [ ]
    bpy.ops.curve.primitive_nurbs_circle_add()
    return active_object()

def create_nurbs_path(): # [ ]
    bpy.ops.curve.primitive_nurbs_path_add()
    return active_object()

def create_path(): # [ ]
    return create_nurbs_path()

# Surface
def create_nurbs_curve_surface(): # [ ]
    bpy.ops.surface.primitive_nurbs_surface_curve_add()
    return active_object()

def create_curve_surface(): # [ ]
    return create_nurbs_curve_surface()

def create_nurbs_circle_surface(): # [ ]
    bpy.ops.surface.primitive_nurbs_surface_circle_add()
    return active_object()

def create_circle_surface(): # [ ]
    return create_nurbs_circle_surface()

def create_nurbs_surface(): # [ ]
    bpy.ops.surface.primitive_nurbs_surface_surface_add()
    return active_object()

def create_nurbs_cylinder_surface(): # [ ]
    bpy.ops.surface.primitive_nurbs_surface_cylinder_add()
    return active_object()

def create_cylinder_surface(): # [ ]
    return create_nurbs_cylinder_surface()

def create_nurbs_sphere_surface(): # [ ]
    bpy.ops.surface.primitive_nurbs_surface_sphere_add()
    return active_object()

def create_sphere_surface(): # [ ]
    return create_nurbs_sphere_surface()

def create_nurbs_torus_surface(): # [ ]
    bpy.ops.surface.primitive_nurbs_surface_torus_add()
    return active_object()

def create_torus_surface(): # [ ]
    return create_nurbs_torus_surface()

# Metaball
def create_metaball(): # [ ]
    bpy.ops.object.metaball_add(type='BALL')
    active_object()

def create_metaball_capsule(): # [ ]
    bpy.ops.object.metaball_add(type='CAPSULE')
    active_object()

def create_metaball_plane(): # [ ]
    bpy.ops.object.metaball_add(type='PLANE')
    active_object()

def create_metaball_ellipsoid(): # [ ]
    bpy.ops.object.metaball_add(type='ELLIPSOID')
    active_object()

def create_metaball_cube(): # [ ]
    bpy.ops.object.metaball_add(type='CUBE')
    active_object()

# Text
def create_text_object(): # [ ]
    bpy.ops.object.text_add()
    return active_object()

def create_text(): # [ ]
    return create_text_object()
#endregion
#region OBJECTS - CONSTRAINTS
def add_constraint(type, ref = None, name = ""): # [ ]
    objref = get_object(ref)
    new_con = objref.constraints.new(type)
    if name : 
        new_con.name = name
    for area in bpy.context.screen.areas:
        if area.type == 'PROPERTIES':
            area.tag_redraw()
    return new_con

def get_constraint(name, ref = None): # [ ]
    objref = get_object(ref)

    if name in objref.constraints:
        return objref.constraints[name]
    else:
        return None

def get_constraints_by_type(type,ref = None): # [ ]
    objref = get_object(ref)
    constraints = [con for con in objref.constraints if con.type == type]
    return constraints

def remove_constraint(name = None, ref = None): # [ ]
    objref = get_object(ref)

    if name is not None:
        if is_string(name):
            if name in objref.constraints:
                mod = get_constraint(name,objref)
                objref.constraints.remove(mod)
        else:
            objref.constraints.remove(name)
    else:
        remove_constraint(objref.constraints[0])
    
    for area in bpy.context.screen.areas:
        if area.type == 'PROPERTIES':
            area.tag_redraw()

def add_camera_solver_constraint(ref = None, name = ""): # [ ]
    return add_constraint('CAMERA_SOLVER', ref, name)

def add_follow_track_constraint(ref = None, name = ""): # [ ]
    return add_constraint('FOLLOW_TRACK', ref, name)

def add_object_solver_constraint(ref = None, name = ""): # [ ]
    return add_constraint('OBJECT_SOLVER', ref, name)

def add_copy_location_constraint(ref = None, name = ""): # [ ]
    return add_constraint('COPY_LOCATION', ref, name)

def add_copy_rotation_constraint(ref = None, name = ""): # [ ]
    return add_constraint('COPY_ROTATION', ref, name)

def add_copy_scale_constraint(ref = None, name = ""): # [ ]
    return add_constraint('COPY_SCALE', ref, name)

def add_copy_transforms_constraint(ref = None, name = ""): # [ ]
    return add_constraint('COPY_TRANSFORMS', ref, name)

def add_limit_distance_constraint(ref = None, name = ""): # [ ]
    return add_constraint('LIMIT_DISTANCE', ref, name)

def add_limit_location_constraint(ref = None, name = ""): # [ ]
    return add_constraint('LIMIT_LOCATION', ref, name)

def add_limit_rotation_constraint(ref = None, name = ""): # [ ]
    return add_constraint('LIMIT_ROTATION', ref, name)

def add_limit_scale_constraint(ref = None, name = ""): # [ ]
    return add_constraint('LIMIT_SCALE', ref, name)

def add_maintain_volume_constraint(ref = None, name = ""): # [ ]
    return add_constraint('MAINTAIN_VOLUME', ref, name)

def add_transform_constraint(ref = None, name = ""): # [ ]
    return add_constraint('TRANSFORM', ref, name)

def add_transformation_constraint(ref = None, name = ""): # [ ]
    return add_constraint('TRANSFORM', ref, name)

def add_transform_cache_constraint(ref = None, name = ""): # [ ]
    return add_constraint('TRANSFORM_CACHE', ref, name)

def add_clamp_to_constraint(ref = None, name = ""): # [ ]
    return add_constraint('CLAMP_TO', ref, name)

def add_damped_track_constraint(ref = None, name = ""): # [ ]
    return add_constraint('DAMPED_TRACK', ref, name)

def add_locked_track_constraint(ref = None, name = ""): # [ ]
    return add_constraint('LOCKED_TRACK', ref, name)

def add_stretch_to_constraint(ref = None, name = ""): # [ ]
    return add_constraint('STRETCH_TO', ref, name)

def add_track_to_constraint(ref = None, name = ""): # [ ]
    return add_constraint('TRACK_TO', ref, name)

def add_action_constraint(ref = None, name = ""): # [ ]
    return add_constraint('ACTION', ref, name)

def add_armature_constraint(ref = None, name = ""): # [ ]
    return add_constraint('ARMATURE', ref, name)

def add_child_of_constraint(ref = None, name = ""): # [ ]
    return add_constraint('CHILD_OF', ref, name)

def add_floor_constraint(ref = None, name = ""): # [ ]
    return add_constraint('FLOOR', ref, name)

def add_follow_path_constraint(ref = None, name = ""): # [ ]
    return add_constraint('FOLLOW_PATH', ref, name)

def add_pivot_constraint(ref = None, name = ""): # [ ]
    return add_constraint('PIVOT', ref, name)

def add_shrinkwrap_constraint(ref = None, name = ""): # [ ]
    return add_constraint('SHRINKWRAP', ref, name)
#endregion
#region MODES
def set_mode(ref=None, newmode=None,): # [ ]
    if newmode is not None:
        objref = get_object(ref)
        bpy.context.view_layer.objects.active = objref
        bpy.ops.object.mode_set(mode=newmode)

def get_mode(): # [ ]
    return bpy.context.mode

def set_object_mode(ref=None): # [ ]
    set_mode(ref, 'OBJECT')

def object_mode(ref=None): # [ ]
    set_object_mode(ref)

def set_edit_mode(ref=None): # [ ]
    set_mode(ref, 'EDIT')

def edit_mode(ref=None): # [ ]
    set_edit_mode(ref)

def set_sculpt_mode(ref=None): # [ ]
    set_mode(ref, 'SCULPT')

def sculpt_mode(ref=None): # [ ]
    set_sculpt_mode(ref)

def set_vertex_paint_mode(ref=None): # [ ]
    set_mode(ref, 'VERTEX_PAINT')

def vertex_paint_mode(ref=None): # [ ]
    set_vertex_paint_mode(ref)

def set_weight_paint_mode(ref=None): # [ ]
    set_mode(ref, 'WEIGHT_PAINT')

def weight_paint_mode(ref=None): # [ ]
    set_weight_paint_mode(ref)

def set_texture_paint_mode(ref=None): # [ ]
    set_mode(ref, 'TEXTURE_PAINT')

def texture_paint_mode(ref=None): # [ ]
    set_texture_paint_mode(ref)

def set_pose_mode(ref=None): # [ ]
    set_mode(ref, 'POSE')

def pose_mode(ref=None): # [ ]
    set_pose_mode(ref) 
#endregion
#region SCENES
def get_scene(): # [ ]
    return bpy.context.scene
#endregion
#region VISIBILITY
def hide_object(ref=None): # [ ]
    objs = get_objects(ref)
    for obj in objs:
        obj.hide_set(True)

def hide(ref = None): # [ ]
    hide_object(ref)

def show_object(ref = None): # [ ]
    objs = get_objects(ref)
    for obj in objs:
        obj.hide_set(False)

def show(ref = None): # [ ]
    show_object(ref)

def unhide(ref = None): # [ ]
    show_object(ref)

def unhide_object(ref = None): # [ ]
    show_object(ref)

def hide_in_viewport(ref): # [ ]
    objs = get_objects(ref)
    for obj in objs:
        obj.hide_viewport = True

def show_in_viewport(ref): # [ ]
    objs = get_objects(ref)
    for obj in objs:
        obj.hide_viewport = False

def unhide_in_viewport(ref): # [ ]
    show_in_viewport(ref)

def hide_in_render(ref): # [ ]
    objs = get_objects(ref)
    for obj in objs:
        obj.hide_render = True

def show_in_render(ref): # [ ]
    objs = get_objects(ref)
    for obj in objs:
        obj.hide_render = False

def unhide_in_render(ref): # [ ]
    show_in_render(ref)

def display_as_bounds(ref): # [ ]
    objs = get_objects(ref)
    for obj in objs:
        obj.display_type = 'BOUNDS'

def display_as_textured(ref): # [ ]
    objs = get_objects(ref)
    for obj in objs:
        obj.display_type = 'TEXTURED'

def display_as_solid(ref): # [ ]
    objs = get_objects(ref)
    for obj in objs:
        obj.display_type = 'SOLID'

def display_as_wire(ref): # [ ]
    objs = get_objects(ref)
    for obj in objs:
        obj.display_type = 'WIRE'
#endregion
#region TRANSFORMATIONS
def location(ref = None, loc = None): # [ ]
    objref = get_object(ref)
    if loc is not None:
        objref.location = Vector((loc[0],loc[1],loc[2]))
    else:
        return objref.location

def rotation(ref = None, rot = None): # [ ]
    objref = get_object(ref)
    if rot is not None:
        objref.rotation_euler = Vector((rot[0],rot[1],rot[2]))
    else:
        return objref.rotation_euler
            
def scale(ref = None, scale = None): # [ ]
    objref = get_object(ref)
    if scale is not None:
        objref.scale = Vector((scale[0],scale[1],scale[2]))
    else:
        return objref.scale

def dimensions(ref = None, dim = None): # [ ]
    objref = get_object(ref)
    if dim is not None:
        objref.dimensions = Vector((dim[0],dim[1],dim[2]))
    else:
        return objref.dimensions

# Applying Transformations:

def apply_location(ref = None): # [ ]
    if ref is not None:
        deselect_all_objects()
        select_object(ref)
    bpy.ops.object.transform_apply(location=True, rotation=False, scale=False)

def apply_rotation(ref = None): # [ ]
    if ref is not None:
        deselect_all_objects()
        select_object(ref)
    bpy.ops.object.transform_apply(location=False, rotation=True, scale=False)

def apply_scale(ref = None): # [ ]
    if ref is not None:
        deselect_all_objects()
        select_object(ref)
    bpy.ops.object.transform_apply(location=False, rotation=False, scale=True)

def apply_all_transforms(ref = None): # [ ]
    if ref is not None:
        deselect_all_objects()
        select_object(ref)
    bpy.ops.object.transform_apply(location=True, rotation=True, scale=True)

def apply_rotation_and_scale(ref = None): # [ ]
    if ref is not None:
        deselect_all_objects()
        select_object(ref)
    bpy.ops.object.transform_apply(location=False, rotation=True, scale=True)

# Translations:

def translate_vector(vec = Vector(), ref = None): # [ ]
    objs = make_obj_list(ref)
    for obj in objs:
        obj.location[0] += vec[0]
        obj.location[1] += vec[1]
        obj.location[2] += vec[2]

def translate_along_axis(val, axis, ref = None): # [ ]
    objs = make_obj_list(ref)
    axis.normalize()
    for obj in objs:
        obj.location[0] += (val * axis[0])
        obj.location[1] += (val * axis[1])
        obj.location[2] += (val * axis[2])

def move_along_axis(val, axis, ref = None): # [ ]
    translate_along_axis(val, axis, ref)

def translate_along_x(val, ref = None): # [ ]
    translate_along_axis(val, Vector((1.0,0.0,0.0)), ref)

def move_along_x(val, ref = None): # [ ]
    translate_along_x(val, ref)

def translate_along_y(val, ref = None): # [ ]
    translate_along_axis(val, Vector((0.0,1.0,0.0)), ref)

def move_along_y(val, ref = None): # [ ]
    translate_along_y(val, ref)

def translate_along_z(val, ref = None): # [ ]
    translate_along_axis(val, Vector((0.0,0.0,1.0)), ref)

def move_along_z(val, ref = None): # [ ]
    translate_along_z(val, ref)

def translate_along_global_x(val, ref = None): # [ ]
    translate_along_x(val, ref)

def move_along_global_x(val, ref = None): # [ ]
    translate_along_x(val, ref)

def translate_along_global_y(val, ref = None): # [ ]
    translate_along_y(val, ref)

def move_along_global_y(val, ref = None): # [ ]
    translate_along_y(val, ref)

def translate_along_global_z(val, ref = None): # [ ]
    translate_along_z(val, ref)

def move_along_global_z(val, ref = None): # [ ]
    translate_along_z(val, ref)

def translate_in_x(val, ref = None): # [ ]
    translate_along_x(val, ref)

def move_in_x(val, ref = None): # [ ]
    translate_along_x(val, ref)

def translate_in_y(val, ref = None): # [ ]
    translate_along_y(val, ref)

def move_in_y(val, ref = None): # [ ]
    translate_along_y(val, ref)

def translate_in_z(val, ref = None): # [ ]
    translate_along_z(val, ref)

def move_in_z(val, ref = None): # [ ]
    translate_along_z(val, ref)

def translate_along_local_axis(val, axis, ref = None): # [ ]
    objs = make_obj_list(ref)
    axis.normalize()
    for obj in objs:
        tempaxis = axis.copy()
        tempaxis.rotate(obj.rotation_euler)
        obj.location[0] += (val * tempaxis[0])
        obj.location[1] += (val * tempaxis[1])
        obj.location[2] += (val * tempaxis[2])

def translate_along_local_x(val, ref = None): # [ ]
    translate_along_local_axis(val, Vector((1.0,0.0,0.0)), ref)

def move_along_local_x(val, ref = None): # [ ]
    translate_along_local_x(val, ref)

def translate_along_local_y(val, ref = None): # [ ]
    translate_along_local_axis(val, Vector((0.0,1.0,0.0)), ref)

def move_along_local_y(val, ref = None): # [ ]
    translate_along_local_y(val, ref)

def translate_along_local_z(val, ref = None): # [ ]
    translate_along_local_axis(val, Vector((0.0,0.0,1.0)), ref)

def move_along_local_z(val, ref = None): # [ ]
    translate_along_local_z(val, ref)

# Rotations:

def rotate_vector(vec = Vector(), ref = None): # [ ]
    objs = make_obj_list(ref)
    for obj in objs:
        obj.rotation_euler[0] += vec[0]
        obj.rotation_euler[1] += vec[1]
        obj.rotation_euler[2] += vec[2]

def rotate_around_axis(deg, axis = Vector(), ref = None, point = None): # [ ]
    objs = make_obj_list(ref)
    pointref = None
    if point is None:
        if get_scene().tool_settings.transform_pivot_point == 'MEDIAN_POINT':
            pointref = get_median_point_of_objects(objs)
        elif get_scene().tool_settings.transform_pivot_point == 'CURSOR':
            pointref = get_cursor_location()
        else:
            pointref = get_median_point_of_objects(objs)
    else:
        pointref = point
    axis.normalize()
    for obj in objs:
        mat = (Matrix.Translation(pointref) @ Matrix.Rotation(math.radians(deg), 4, axis) @ Matrix.Translation(-pointref))
        obj.matrix_world = mat @ obj.matrix_world

def rotate_around_global_x(deg, ref = None, point = None): # [ ]
    rotate_around_axis(deg, Vector((1.0,0.0,0.0)), ref, point)

def rotate_around_global_y(deg, ref = None, point = None): # [ ]
    rotate_around_axis(deg, Vector((0.0,1.0,0.0)), ref, point)

def rotate_around_global_z(deg, ref = None, point = None): # [ ]
    rotate_around_axis(deg, Vector((0.0,0.0,1.0)), ref, point)

def rotate_around_x(deg, ref = None,point = None): # [ ]
    rotate_around_global_x(deg, ref, point)

def rotate_around_y(deg, ref = None,point = None): # [ ]
    rotate_around_global_y(deg, ref, point)

def rotate_around_z(deg, ref = None,point = None): # [ ]
    rotate_around_global_z(deg, ref, point)

def rotate_in_x(deg, ref = None,point = None): # [ ]
    rotate_around_global_x(deg, ref, point)

def rotate_in_y(deg, ref = None,point = None): # [ ]
    rotate_around_global_y(deg, ref, point)

def rotate_in_z(deg, ref = None,point = None): # [ ]
    rotate_around_global_z(deg, ref, point)

def rotate_around_local_axis(deg, axis = Vector(), ref = None, point = None): # [ ]
    objs = make_obj_list(ref)
    pointref = None
    if point is None:
        if get_scene().tool_settings.transform_pivot_point == 'MEDIAN_POINT':
            pointref = get_median_point_of_objects(objs)
        elif get_scene().tool_settings.transform_pivot_point == 'CURSOR':
            pointref = get_cursor_location()
        else:
            pointref = get_median_point_of_objects(objs)
    else:
        pointref = point
    
    axis.normalize()
    for obj in objs:
        tempaxis = axis.copy()
        tempaxis.rotate(obj.rotation_euler)
        mat = (Matrix.Translation(pointref) @ Matrix.Rotation(math.radians(deg), 4, tempaxis) @ Matrix.Translation(-pointref))
        obj.matrix_world = mat @ obj.matrix_world

def rotate_around_local_x(deg, ref = None, point = None): # [ ]
    rotate_around_local_axis(deg, Vector((1.0,0.0,0.0)), ref, point)

def rotate_around_local_y(deg, ref = None, point = None): # [ ]
    rotate_around_local_axis(deg, Vector((0.0,1.0,0.0)), ref, point)

def rotate_around_local_z(deg, ref = None, point = None): # [ ]
    rotate_around_local_axis(deg, Vector((0.0,0.0,1.0)), ref, point)

# Scaling:

def scale_vector(vec, ref = None): # [ ]
    objs = make_obj_list(ref)
    for obj in objs:
        obj = get_object(ref)
        obj.scale[0] *= vec[0]
        obj.scale[1] *= vec[1]
        obj.scale[2] *= vec[2]

def scale_uniform(val, ref = None): # [ ]
    scale_vector(Vector((val, val, val)), ref)

def scale_along_axis(val, axis, ref = None, point = None): # [ ]
    objs = make_obj_list(ref)
    pointref = None
    if point is None:
        if get_scene().tool_settings.transform_pivot_point == 'MEDIAN_POINT':
            pointref = get_median_point_of_objects(objs)
        elif get_scene().tool_settings.transform_pivot_point == 'CURSOR':
            pointref = get_cursor_location()
        else:
            pointref = get_median_point_of_objects(objs)
    else:
        pointref = point

    axis.normalize()
    temp = Vector()
    temp[0] = 1 + ((val - 1)/(1 - 0)) * (axis[0] - 0)
    temp[1] = 1 + ((val - 1)/(1 - 0)) * (axis[1] - 0)
    temp[2] = 1 + ((val - 1)/(1 - 0)) * (axis[2] - 0)
    for obj in objs:
        obj.scale[0] *= temp[0]
        obj.scale[1] *= temp[1]
        obj.scale[2] *= temp[2]
        
        tempaxis = axis.copy()
        tempaxis.rotate(obj.rotation_euler)
        fac = (obj.location - pointref).dot(tempaxis) * (val-1)
        translate_along_axis(fac, tempaxis, obj)

def scale_along_x(val, ref = None, point = None): # [ ]
    scale_along_axis(val, Vector((1.0, 0.0, 0.0)), ref, point)

def scale_along_y(val, ref = None, point = None): # [ ]
    scale_along_axis(val, Vector((0.0, 1.0, 0.0)), ref, point)

def scale_along_z(val, ref = None, point = None): # [ ]
    scale_along_axis(val, Vector((0.0, 0.0, 1.0)), ref, point)

def scale_along_local_x(val, ref = None, point = None): # [ ]
    scale_along_axis(val, Vector((1.0, 0.0, 0.0)), ref, point)

def scale_along_local_y(val, ref = None, point = None): # [ ]
    scale_along_axis(val, Vector((0.0, 1.0, 0.0)), ref, point)

def scale_along_local_z(val, ref = None, point = None): # [ ]
    scale_along_axis(val, Vector((0.0, 0.0, 1.0)), ref, point)

def scale_in_x(val, ref = None, point = None): # [ ]
    scale_along_axis(val, Vector((1.0, 0.0, 0.0)), ref, point)

def scale_in_y(val, ref = None, point = None): # [ ]
    scale_along_axis(val, Vector((0.0, 1.0, 0.0)), ref, point)

def scale_in_z(val, ref = None, point = None): # [ ]
    scale_along_axis(val, Vector((0.0, 0.0, 1.0)), ref, point)

def scale_along_global_axis(val, axis, ref = None, point = None): # [ ]
    objs = make_obj_list(ref)
    pointref = None
    if point is None:
        if get_scene().tool_settings.transform_pivot_point == 'MEDIAN_POINT':
            point = get_median_point_of_objects(objs)
        elif get_scene().tool_settings.transform_pivot_point == 'CURSOR':
            point = get_cursor_location()
        else:
            point = get_median_point_of_objects(objs)
    else:
        pointref = point
    for obj in objs:
        loc, rot, scale = obj.matrix_world.decompose()
        loc_mat = Matrix.Translation(loc)
        new_loc_mat = loc_mat.copy()
        new_loc_mat.invert()
        obj.matrix_world = new_loc_mat @ obj.matrix_world
        orig_rot = obj.rotation_euler.copy()
        orig_loc = obj.location
        obj.matrix_world = Matrix.Scale(val, 4, axis) @ obj.matrix_world
        obj.matrix_world = loc_mat @ obj.matrix_world
        obj.rotation_euler = orig_rot
        fac = (obj.location - point).dot(axis) * (val-1)
        translate_along_axis(fac, axis, obj)

def scale_along_global_x(val, ref = None, point = None): # [ ]
    scale_along_global_axis(val, Vector((1.0, 0.0, 0.0)), ref, point)

def scale_along_global_y(val, ref = None, point = None): # [ ]
    scale_along_global_axis(val, Vector((0.0, 1.0, 0.0)), ref, point)

def scale_along_global_z(val, ref = None, point = None): # [ ]
    scale_along_global_axis(val, Vector((0.0, 0.0, 1.0)), ref, point)

#Need to be revised, not working as expected
def scale_perpendicular_to_x(val, ref = None, point = None): # [ ]
    objs = make_obj_list(ref)
    pointref = None
    if point is None:
        if get_scene().tool_settings.transform_pivot_point == 'MEDIAN_POINT':
            pointref = get_median_point_of_objects(objs)
        elif get_scene().tool_settings.transform_pivot_point == 'CURSOR':
            pointref = get_cursor_location()
        else:
            pointref = get_median_point_of_objects(objs)
    else:
        pointref = point
    
    for obj in objs:
        scale_vector(Vector((1.0, val, val)), obj)
        axis = (obj.location - pointref) * Vector((0.0, 1.0, 1.0))
        fac = axis.magnitude * (val-1)
        translate_along_axis(fac, axis, obj)

def scale_perpendicular_to_y(val, ref = None, point = None): # [ ]
    objs = make_obj_list(ref)
    pointref = None
    if point is None:
        if get_scene().tool_settings.transform_pivot_point == 'MEDIAN_POINT':
            pointref = get_median_point_of_objects(objs)
        elif get_scene().tool_settings.transform_pivot_point == 'CURSOR':
            pointref = get_cursor_location()
        else:
            pointref = get_median_point_of_objects(objs)
    else:
        pointref = point
    
    for obj in objs:
        scale_vector(Vector((val, 1.0, val)), obj)
        axis = (obj.location - pointref) * Vector((1.0, 0.0, 1.0))
        fac = axis.magnitude * (val-1)
        translate_along_axis(fac, axis, obj)

def scale_perpendicular_to_z(val, ref = None, point = None): # [ ]
    objs = make_obj_list(ref)
    pointref = None
    if point is None:
        if get_scene().tool_settings.transform_pivot_point == 'MEDIAN_POINT':
            pointref = get_median_point_of_objects(objs)
        elif get_scene().tool_settings.transform_pivot_point == 'CURSOR':
            pointref = get_cursor_location()
        else:
            pointref = get_median_point_of_objects(objs)
    else:
        pointref = point
    
    for obj in objs:
        scale_vector(Vector((val, val, 1.0)), obj)
        axis = (obj.location - pointref) * Vector((1.0, 1.0, 0.0))
        fac = axis.magnitude * (val-1)
        translate_along_axis(fac, axis, obj)
#endregion
#region ANIMATION / KEYFRAMES
# Example: path is the object and property is 'location'
def add_keyframe(path, property, frame = None): # [ ]
    if frame is None:
        frame = current_frame()
    path.keyframe_insert(data_path=property,frame=frame)
    keyframes = []
    for i in range(len(path.animation_data.action.fcurves)):
        fcurve = path.animation_data.action.fcurves.find(property,index=i)
        if fcurve is not None:
            for keyframe in fcurve.keyframe_points:
                if keyframe.co[0] == frame:
                    keyframes.append(keyframe)
    
    # Updating Interface:
    for area in bpy.context.screen.areas:
        area.tag_redraw()
        
    return keyframes if len(keyframes) > 1 else keyframes[0] 
    
def remove_keyframe(keyframes): # [ ]
    if type(keyframes) is not list:
        keyframes = [keyframes]
    for keyframe in keyframes:
        fcurves = keyframe.id_data.fcurves
        for fcurve in fcurves:    
            for keyframe1 in fcurve.keyframe_points:
                if keyframe1 == keyframe:
                    fcurve.keyframe_points.remove(keyframe)
            if len(fcurve.keyframe_points) == 0:
                fcurves.remove(fcurve)

        # Updating Interface:
        for area in bpy.context.screen.areas:
            area.tag_redraw()

def delete_animation_data(ref = None): # [ ]
    objs = get_objects(ref)
    for obj in objs:
        obj.animation_data_clear()
#endregion
#region DRIVERS
def add_driver(path,property,index=-1): # [ ]
    fcurves = path.driver_add(property,index)
    for area in bpy.context.screen.areas:   #update interface
        area.tag_redraw()
    if type(fcurves) is list:
        return [fcurve.driver for fcurve in fcurves]
    return fcurves.driver

def remove_driver(driver): # [ ]
    for fcurve in driver.id_data.animation_data.drivers: 
        if fcurve.driver == driver:
            driver.id_data.animation_data.drivers.remove(fcurve)
#endregion
#region 3D CURSOR
def selection_to_cursor_without_offset(): # [ ]
    bpy.ops.view3d.snap_selected_to_cursor(use_offset=False)

def selection_to_cursor_with_offset(): # [ ]
    bpy.ops.view3d.snap_selected_to_cursor(use_offset=True)

def cursor_to_world_origin(): # [ ]
    bpy.ops.view3d.snap_cursor_to_center()

def cursor_to_selection(): # [ ]
    bpy.ops.view3d.snap_cursor_to_selected()

def cursor_to_active(): # [ ]
    bpy.ops.view3d.snap_cursor_to_selected()

def selection_to_grid(): # [ ]
    bpy.ops.view3d.snap_selected_to_grid()

def selection_to_active(): # [ ]
    bpy.ops.view3d.snap_selected_to_active()

def cursor_to_grid(): # [ ]
    bpy.ops.view3d.snap_cursor_to_grid()
    
def get_cursor_location(): # [ ]
    return bpy.context.scene.cursor.location

def set_cursor_location(newloc): # [ ]
    bpy.context.scene.cursor.location = newloc

def get_cursor_rotation(): # [ ]
    return bpy.context.scene.cursor.rotation_euler

def get_cursor_rotation_mode(): # [ ]
    return bpy.context.scene.cursor.rotation_mode

#endregion
#region PIVOT POINT
def set_pivot_point_to_cursor(): # [ ]
    get_scene().tool_settings.transform_pivot_point = 'CURSOR'

def set_pivot_point_to_median(): # [ ]
    get_scene().tool_settings.transform_pivot_point = 'MEDIAN_POINT'

def set_pivot_point_to_individual_origins(): # [ ]
    get_scene().tool_settings.transform_pivot_point = 'INDIVIDUAL_ORIGINS'

def set_pivot_point_to_active_element(): # [ ]
    get_scene().tool_settings.transform_pivot_point = 'ACTIVE_ELEMENT'

def set_pivot_point_to_bounding_box_center(): # [ ]
    get_scene().tool_settings.transform_pivot_point = 'BOUNDING_BOX_CENTER'
#endregion
#region ORIGINS
def set_geometry_to_origin(ref = None): # [ ]
    objref = get_object(ref)
    if objref is not None:
        select_object(objref)
    bpy.ops.object.origin_set(type='GEOMETRY_ORIGIN')

def geometry_to_origin(ref = None): # [ ]
    set_geometry_to_origin(ref)

def set_origin_to_geometry(ref = None): # [ ]
    objref = get_object(ref)
    if objref is not None:
        select_object(objref)
    bpy.ops.object.origin_set(type='ORIGIN_GEOMETRY')

def origin_to_geometry(ref = None): # [ ]
    set_origin_to_geometry(ref)

def set_origin_to_cursor(ref = None): # [ ]
    objref = get_object(ref)
    if objref is not None:
        select_object(objref)
    bpy.ops.object.origin_set(type='ORIGIN_CURSOR')

def origin_to_cursor(ref = None): # [ ]
    set_origin_to_cursor(ref)

def set_origin_to_centermass_surface(ref = None): # [ ]
    objref = get_object(ref)
    if objref is not None:
        select_object(objref)
    bpy.ops.object.origin_set(type='ORIGIN_CENTER_OF_MASS')

def origin_to_centermass_surface(ref = None): # [ ]
    set_origin_to_centermass_surface(ref)

def set_origin_to_centermass_volume(ref = None): # [ ]
    objref = get_object(ref)
    if objref is not None:
        select_object(objref)
    bpy.ops.object.origin_set(type='ORIGIN_CENTER_OF_VOLUME')

def origin_to_centermass_volume(ref = None): # [ ]
    set_origin_to_centermass_volume(ref)
#endregion
#region SHADING
def shade_object_smooth(ref = None): # [ ]
    objref = None
    if ref is not None:
        if is_string(ref):
            objref = get_object(ref)
        else:
            objref = ref
    else:
        # nothing supplied, use so
        objref = selected_object()
    deselect_all_objects()
    select_object(objref)
    bpy.ops.object.shade_smooth()

def shade_smooth(ref = None): # [ ]
    shade_object_smooth(ref)

def shade_object_flat(ref = None): # [ ]
    objref = None
    if ref is not None:
        if is_string(ref):
            objref = get_object(ref)
        else:
            objref = ref
    else:
        # nothing supplied, use so
        objref = selected_object()
    deselect_all_objects()
    select_object(objref)
    bpy.ops.object.shade_flat()

def shade_flat(ref = None): # [ ]
    shade_object_flat(ref)

def set_smooth_angle(ref, degrees = 60): # [ ]
    objref = None
    if is_string(ref):
        objref = get_object(ref)
    else:
        objref = ref
    if objref.data.use_auto_smooth == False:
        objref.data.use_auto_smooth = True
    objref.data.auto_smooth_angle = math.radians(degrees)
#endregion
#region LIGHTING
def get_light(ref): # [ ]
    obj = get_object(ref)
    return obj.data

def light_power(val = 0, ref = None): # [ ]
    objlist = []
    if ref is None:
        objlist = so()
    else:
        objlist = [ref]
    for o in objlist:
        o.data.energy = val

def light_intensity(val = 0, ref = None): # [ ]
    light_power(val,ref)

def light_power_add(val = 0, ref = None): # [ ]
    objlist = []
    if ref is None:
        objlist = so()
    else:
        objlist = [ref]
    for o in objlist:
        o.data.energy += val

def light_intensity_add(val = 0, ref = None): # [ ]
    light_power_add(val,ref)

def light_power_multiply(val = 0, ref = None): # [ ]
    objlist = []
    if ref is None:
        objlist = so()
    else:
        objlist = [ref]
    for o in objlist:
        o.data.energy *= val

def light_intensity_multiply(val = 0, ref = None): # [ ]
    light_power_multiply(val,ref)
#endregion
#region MESHES
def create_mesh(name): # [ ]
    return bpy.data.meshes.new(name)

def get_all_meshes(): # [ ]
    return bpy.data.meshes

def get_vertices(ref): # [ ]
    if is_string(ref):
        return get_object(ref).data.vertices
    else:
        return ref.data.vertices

def get_edges(ref): # [ ]
    if is_string(ref):
        return get_object(ref).data.edges
    else:
        return ref.data.edges

def get_faces(ref): # [ ]
    return get_polygons(ref)

def get_polygons(ref): # [ ]
    if is_string(ref):
        return get_object(ref).data.polygons
    else:
        return ref.data.polygons

def get_mesh_from_object(ref): # [ ]
    objref = None
    if is_string(ref):
        objref = get_object(ref)
    else:
        objref = ref
    return objref.data

def get_selected_vertices(ref = None): # [ ]
    ref = get_object(ref)
    tmp_mode = ref.mode
    select_object(ref)
    bpy.ops.object.mode_set(mode='OBJECT')
    selected_vertices = [v for v in ref.data.vertices if v.select]
    bpy.ops.object.mode_set(mode=tmp_mode)
    return selected_vertices

def get_selected_verts(ref = None): # [ ]
    return get_selected_vertices(ref)

def get_selected_edges(ref = None): # [ ]
    ref = get_object(ref)
    tmp_mode = ref.mode
    select_object(ref)
    bpy.ops.object.mode_set(mode='OBJECT')
    selected_edges = [e for e in ref.data.edges if e.select]
    bpy.ops.object.mode_set(mode=tmp_mode)
    return selected_edges

def get_selected_faces(ref = None): # [ ]
    ref = get_object(ref)
    tmp_mode = ref.mode
    select_object(ref)
    bpy.ops.object.mode_set(mode='OBJECT')
    selected_faces = [f for f in ref.data.polygons if f.select]
    bpy.ops.object.mode_set(mode=tmp_mode)
    return selected_faces
#endregion
#region CURVES
def get_curve_points(ref = None): # [ ]
    obj = get_object(ref)
    points = []
    for spline in obj.data.splines:
        for point in (*spline.points, *spline.bezier_points):
            points.append(point)
    return points

def get_selected_curve_points(ref = None): # [ ]
    obj = get_object(ref)
    points = []
    for spline in obj.data.splines:
        if spline.type == "NURBS":
            for point in spline.points:
                if point.select:
                    points.append(point)
        if spline.type == "BEZIER":
            for point in spline.points:
                if point.select_control_point:
                    points.append(point)
    return points
#endregion
#region VERTEX GROUPS
''' FUTURE UPDATE
def create_vertex_group(ref, group_name): # [ ]
    ref.vertex_groups.new(name=group_name)
    return ref.vertex_groups[group_name]

def delete_vertex_group(ref, group_name): # [ ]
    pass
'''
#endregion
#region SHAPE KEYS
def add_shape_key(name = None, ref = None): # [ ]
    objref = get_object(ref)
    if name:
        sk = objref.shape_key_add(name = name)
    else:
        sk = objref.shape_key_add()
    return sk

def get_shape_key(name_or_index = 0, ref = None): # [ ]
    objref = get_object(ref)
    sk = None
    if(objref.data.shape_keys):
        sk = objref.data.shape_keys.key_blocks[name_or_index]
    return sk

def get_all_shape_keys(ref = None): # [ ]
    objref = get_object(ref)
    return list(objref.data.shape_keys.key_blocks)

def remove_shape_key(shape_key, ref = None): # [ ]
    objref = get_object(ref)
    if isinstance(shape_key, bpy.types.ShapeKey):
        objref.shape_key_remove(shape_key)
    elif isinstance(shape_key, str) or isinstance(shape_key, int):
        sk_ref = get_shape_key(shape_key,objref)
        objref.shape_key_remove(sk_ref)
    else:
        print('Invalid Input')

def remove_all_shape_keys(ref = None): # [ ]
    objref = get_object(ref)
    objref.shape_key_clear()

def get_active_shape_key(ref = None): # [ ]
    objref = get_object(ref)
    return objref.active_shape_key

def get_shape_keys(ref = None): # [ ]
    return get_all_shape_keys(ref)

def remove_shape_keys(ref = None): # [ ]
    return remove_all_shape_keys(ref)
#endregion
#region PARTICLE SYSTEMS
def get_particle_systems(ref): # [ ]
    objref = get_object(ref)
    return objref.particle_systems
#endregion
#region COLLECTIONS
def create_collection(name): # [ ]
    if not collection_exists(name):
        bpy.data.collections.new(name)
        colref = bpy.data.collections[name]
        bpy.context.scene.collection.children.link(colref)
        return colref
    return False

def delete_collection(col, delete_objects = False, link_objects = False): # [ ]
    colref = None
    if is_string(col):
            colref = get_collection(col)
    else:
        colref = col

    if delete_objects:
        deselect_all_objects()
        if len(colref.objects) > 0:
            for co in colref.objects:
                if co.name in bpy.context.view_layer.objects:
                    co.select_set(True)
            delete_selected_objects()
    else:
        deselect_all_objects()
        if len(colref.objects) > 0:
            if link_objects:
                for co in colref.objects:
                    bpy.context.scene.collection.objects.link(co)

    bpy.data.collections.remove(colref)

def delete_objects_in_collection(col): # [ ]
    # setting up colref
    colref = None
    # col is a string
    if collection_exists(col):
        if is_string(col):
            colref = get_collection(col)
        else:
            colref = col
    # delete all objects in colref
    deselect_all_objects()
    for co in colref.objects:
        co.select_set(True)
    delete_selected_objects()

def delete_hierarchy(col): # [ ]
    colref = None
    if is_string(col):
        colref = get_collection(col)
    else:
        colref = col
    for co in colref.children:
        if isinstance(co, bpy.types.Collection):
            delete_hierarchy(co)
    deselect_all_objects()
    delete_objects_in_collection(colref)
    delete_collection(colref, False)

def duplicate_collection(col): # [ ]
    colref = None
    if is_string(col):
        colref = get_collection(col)
    else:
        colref = col
    new_name = "Copy of " + colref.name
    new_col = create_collection(new_name)
    to_copy = get_objects_from_collection(colref.name)
    for o in to_copy:
        copy_object(o,new_col)
    return get_collection(new_name)

def get_objects_from_collection(col): # [ ]
    if is_string(col):
        return bpy.data.collections[col].objects
    else:
        return col.objects

def get_collection(ref = None): # [ ]
    if ref is None:
        return bpy.context.view_layer.active_layer_collection.collection
    else:
        if is_string(ref):
            if ref in bpy.data.collections:
                return bpy.data.collections[ref]
            else:
                return False
        else:
            return ref

def get_col(ref = None): # [ ]
    return get_collection(ref)

def get_active_collection(): # [ ]
    return bpy.context.view_layer.active_layer_collection.collection

def set_active_collection(ref): # [ ]
    colref = None
    if is_string(ref):
        colref = get_collection(ref)
    else:
        colref = ref
    hir = bpy.context.view_layer.layer_collection
    search_layer_collection_in_hierarchy_and_set_active(colref, hir)

def select_collection(ref): # [ ]
    set_active_collection(ref)

def hide_collection_viewport(ref=None): # [ ]
    col = get_collection(ref)
    col.hide_viewport = True

# most people will probably expect the viewport collection to be hidden with this function name
def hide_collection(ref=None): # [ ]
    hide_collection_viewport(ref)

def hide_collection_render(ref=None): # [ ]
    col = get_collection(ref)
    col.hide_render = True

def hide_collection_select(ref=None): # [ ]
    col = get_collection(ref)
    col.hide_select = True

def show_collection_viewport(ref=None): # [ ]
    col = get_collection(ref)
    col.hide_viewport = False

# most people will probably expect the viewport collection to be unhidden with this function name
def show_collection(ref=None): # [ ]
    show_collection_viewport(ref)

def show_collection_render(ref=None): # [ ]
    col = get_collection(ref)
    col.hide_render = False

def show_collection_select(ref=None): # [ ]
    col = get_collection(ref)
    col.hide_select = False

def unhide_collection_viewport(ref=None): # [ ]
    show_collection_viewport(ref)

# most people will probably expect the viewport collection to be hidden with this function name
def unhide_collection(ref=None): # [ ]
    unhide_collection_viewport(ref)

def unhide_collection_render(ref=None): # [ ]
    show_collection_render(ref)

def unhide_collection_select(ref=None): # [ ]
    show_collection_select(ref)

# Dev Function
def search_layer_collection_in_hierarchy_and_set_active(colref, hir): # [ ]
    if isinstance(hir, bpy.types.LayerCollection):
        if hir.collection == colref:
            bpy.context.view_layer.active_layer_collection = hir
        else:
            for child in hir.children:
                search_layer_collection_in_hierarchy_and_set_active(colref, child)

def get_all_collections(): # [ ]
    return bpy.data.collections

def get_list_of_collections(): # [ ]
    return get_all_collections()

def link_object_to_collection(ref, col): # [ ]
    if is_string(col):
        objref = get_object(ref)
        bpy.data.collections[col].objects.link(objref)
    else:
        # Check for bad return argument
        if isinstance(col, bool)!=True:
            objref = get_object(ref)
            col.objects.link(objref)

def link_objects_to_collection(ref, col): # [ ]
    objs = get_objects(ref)
    if is_string(col):
        for o in objs:
            bpy.data.collections[col].objects.link(o)
    else:
        for o in objs:
            col.objects.link(o)

def unlink_object_from_collection(ref, col): # [ ]
    if is_string(col):
        objref = get_object(ref)
        bpy.data.collections[col].objects.unlink(objref)
    else:
        objref = get_object(ref)
        col.objects.unlink(objref)

def unlink_objects_from_collection(ref, col): # [ ]
    objs = get_objects(ref)
    colref = None
    if is_string(col):
        colref = get_collection(col)
    else:
        colref = col
    for o in objs:
        colref.objects.unlink(o)

def move_object_to_collection(ref, col): # [ ]
    objref = get_object(ref)
    colref = None
    if is_string(col):
        colref = get_collection(col)
    else:
        colref = col

    cols = objref.users_collection
    for c in cols:
        c.objects.unlink(objref)
    link_object_to_collection(objref, colref)

def move_objects_to_collection(ref, col): # [ ]
    objs = get_objects(ref)
    colref = None
    if is_string(col):
        colref = get_collection(col)
    else:
        colref = col
    for o in objs:
        for c in o.users_collection:
            c.objects.unlink(o)
        link_object_to_collection(o, colref)

def get_object_collection(ref): # [ ]
    objref = get_object(ref)
    return objref.users_collection[0]

def get_object_collections(ref): # [ ]
    objref = get_object(ref)
    return objref.users_collection

def collection_exists(col): # [ ]
    if is_string(col):
        return col in bpy.data.collections
    return col.name in bpy.data.collections
#endregion
#region MATERIALS
def create_material(name): # [ ]
    return bpy.data.materials.new(name)

def material_exists(ref): # [ ]
    if is_string(ref):
        return ref in bpy.data.materials
    # safety
    return ref.name in bpy.data.materials

def delete_material(ref): # [ ]
    matref = None
    if is_string(ref):
        matref = get_material(ref)
    else:
        matref = ref
    bpy.data.materials.remove(matref)

def get_material(matname = None): # [ ]
    if matname is None:
        active = ao()
        if len(active.material_slots) > 0:
            return active.material_slots[0].material
    else:
        for m in bpy.data.materials:
            if m.name == matname:
                return m

def add_material_to_object(ref, mat): # [ ]
    objref = None
    matref = None
    if is_string(ref):
        objref = get_object(ref)
    else:
        objref = ref
    
    if is_string(mat):
        matref = get_material(mat)
    else:
        matref = mat

    if matref is not None:
        objref.data.materials.append(matref)

def remove_material_from_object(ref, matname): # [ ]
    objref = None
    if is_string(ref):
        objref = get_object(ref)
    else:
        objref = ref

    matindex = objref.data.materials.find(matname)
    if matname in objref.data.materials:
        objref.data.materials.pop(index=matindex)

def remove_material(ref, matname): # [ ]
    return remove_material_from_object(ref, matname)

def remove_materials(ref = None): # [ ]
    objrefs = get_objects(ref)
    for o in objrefs:
        if len(o.material_slots) > 0:
            names = []
            for m in o.material_slots:
                names.append(m.name)
            for n in names:
                remove_material_from_object(o,n)
                
def remove_all_materials(ref = None): # [ ]
    remove_materials(ref)

def remove_unused_material_slots(ref = None): # [ ]
    objrefs = get_objects(ref)
    for o in objrefs:
        data = o.data
        tmp = data.materials.items()
        data.materials.clear()
        for item in tmp:
            data.materials.append(item[1])

def remove_unused_slots(ref = None): # [ ]
    remove_unused_material_slots(ref)

def get_all_materials(): # [ ]
    return bpy.data.materials

def get_materials(ref = None): # [ ]
    if ref is not None:
        get_materials_from_object(ref)
    else:
        return bpy.data.materials

def get_material_from_object(ref): # [ ]
    objref = get_object(ref)
    return objref.material_slots[0].material

def get_materials_from_object(ref): # [ ]
    objref = get_object(ref)
    mat_list = []
    mats = objref.material_slots
    for m in mats:
        mat_list.append(m.material)
    return mat_list

def get_material_names_from_object(ref): # [ ]
    objref = get_object(ref)
    name_list = []
    mats = objref.material_slots
    for m in mats:
        name_list.append(m.name)
    return name_list
#endregion
#region NODES
def set_material_use_nodes(matref, value): # [ ]
    matref.use_nodes = value

def set_material_to_use_nodes(matref=None, value=None): # [ ]
    set_material_use_nodes(matref,value)

def get_material_nodes(ref): # [ ]
    mat = get_material(ref)
    return mat.node_tree.nodes

def get_node(nodes,ref): # [ ]
    if is_string(ref):
        for n in nodes:
            if n.name == ref:
                return n
    else:
        return ref

def get_nodes(mat): # [ ]
    node_tree = mat.node_tree
    if node_tree:
      return node_tree.nodes 

def get_node_tree(matref, make_tree = True): # [ ]
    matref.use_nodes = make_tree
    return matref.node_tree

def get_node_group(name): # [ ]
    if name in bpy.data.node_groups:
        return bpy.data.node_groups[name]

def get_all_node_groups(): # [ ]
    return bpy.data.node_groups

def create_node(nodes, nodetype): # [ ]
    return nodes.new(type=nodetype)

def delete_node(nodes, ref): # [ ]
    noderef = get_node(nodes, ref)
    if noderef is not None:
        nodes.remove(noderef)

def get_node_links(matref): # [ ]
    return matref.node_tree.links

def create_node_link(point1, point2): # [ ]
    links = point1.id_data.links
    return links.new(point1,point2)

def create_link(point1 = None, point2 = None): # [ ]
    return create_node_link(point1, point2)

def get_index_of_output(node, name): # [ ]
    index = None
    i = 0
    while i < len(node.outputs):
        if node.outputs[i].name == name:
            index = i
        i += 1
    return index

def get_index_of_input(node, name): # [ ]
    index = None
    i = 0
    while i < len(node.inputs):
        if node.inputs[i].name == name:
            index = i
        i += 1
    return index

# World Nodes
def get_world_nodes(index=None): # [ ]
    if index is not None:
        return bpy.data.worlds[index].node_tree.nodes
    else:
        return bpy.data.worlds[0].node_tree.nodes

#endregion
#region TEXTURES AND IMAGES
def create_texture(name="Texture", type='CLOUDS'): # [ ]
    if type is not None:
        return bpy.data.textures.new(name, type.upper())
    
def get_texture(ref): # [ ]
    if is_string(ref):
        if ref in bpy.data.textures:
            return bpy.data.textures[ref]
    else:
        return ref

def get_all_textures(): # [ ]
    return bpy.data.textures

def get_list_of_textures(): # [ ]
    return get_all_textures()

def rename_texture(ref, name): # [ ]
    texref = get_texture(ref)
    if name is not None:
        texref.name = name

def delete_texture(ref): # [ ]
    if is_string(ref):
        bpy.data.textures.remove(get_texture(ref))
    else:
        bpy.data.textures.remove(ref)

def create_image(name = 'Image', width = 1024, height = 1024): # [ ]
    return bpy.data.images.new(name = name, width = width, height = height)

def get_image(ref): # [ ]
    if is_string(ref):
        if ref in bpy.data.images:
            return bpy.data.images[ref]
    else:
        return ref

def get_all_images(): # [ ]
    return bpy.data.images

def get_list_of_images(): # [ ]
    return get_all_images()

def rename_image(ref, name): # [ ]
    imgref = get_image(ref)
    if name is not None:
        imgref.name = name

def delete_image(ref): # [ ]
    if is_string(ref):
        bpy.data.images.remove(get_image(ref))
    else:
        bpy.data.images.remove(ref)
#endregion
#region MODIFIERS 
def add_modifier(ref = None, name = "Modifier", id="SUBSURF"): # [ ]
    objrefs = get_objects(ref)
    new_mods = []
    for o in objrefs:
        new_mod = o.modifiers.new(name, id)
        new_mods.append(new_mod)

    for area in bpy.context.screen.areas:
        if area.type == 'PROPERTIES':
            area.tag_redraw()
    
    if len(new_mods)>1:
        return new_mods
    else:
        return new_mods[0]

def get_modifier(ref, name): # [ ]
    objref = get_object(ref)

    # we assume name is string
    if name in objref.modifiers:
        return objref.modifiers[name]
    else:
        return False

def remove_modifier(ref = None, name = None): # [ ]
    objref = get_object(ref)
    if name is not None:
        if is_string(name):
            if name in objref.modifiers:
                mod = get_modifier(objref,name)
                objref.modifiers.remove(mod)
        else:
            objref.modifiers.remove(name)
    else:
        objref.modifiers.remove(objref.modifiers[0])
    
    for area in bpy.context.screen.areas:
        if area.type == 'PROPERTIES':
            area.tag_redraw()

def remove_modifiers(ref = None): # [ ]
    objref = get_objects(ref)
    for o in objref:
        for m in o.modifiers:
            o.modifiers.remove(m)

def remove_all_modifiers(ref = None): # [ ]
    remove_modifiers(ref)

def apply_all_modifiers(ref = None): # [ ]
    objref = get_object(ref)
    select_object(objref)
    for mod in objref.modifiers:
        bpy.ops.object.modifier_apply(modifier=mod.name)

def apply_modifiers(ref = None): # [ ]
    apply_all_modifiers(ref)

# Specific Modifiers
def add_data_transfer(ref=None, modname = "DataTransfer"): # [ ]
    return add_modifier(ref,modname,'DATA_TRANSFER')

def add_mesh_cache(ref=None, modname = "MeshCache"): # [ ]
    return add_modifier(ref,modname,'MESH_CACHE')

def add_mesh_sequence_cache(ref=None, modname = "MeshSequenceCache"): # [ ]
    return add_modifier(ref,modname,'MESH_SEQUENCE_CACHE')

def add_normal_edit(ref=None, modname = "NormalEdit"): # [ ]
    return add_modifier(ref,modname,'NORMAL_EDIT')

def add_weighted_normal(ref=None, modname = "WeightedNormal"): # [ ]
    return add_modifier(ref,modname,'WEIGHTED_NORMAL')

def add_uv_project(ref=None, modname = "UVProject"): # [ ]
    return add_modifier(ref,modname,'UV_PROJECT')

def add_uv_warp(ref=None, modname = "Warp"): # [ ]
    return add_modifier(ref,modname,'UV_WARP')

def add_vertex_weight_edit(ref=None, modname = "VertexWeightEdit"): # [ ]
    return add_modifier(ref,modname,'VERTEX_WEIGHT_EDIT')

def add_vertex_weight_mix(ref=None, modname = "VertexWeightMix"): # [ ]
    return add_modifier(ref,modname,'VERTEX_WEIGHT_MIX')

def add_vertex_weight_proximity(ref=None, modname = "VertexWeightProximity"): # [ ]
    return add_modifier(ref,modname,'VERTEX_WEIGHT_PROXIMITY')

def add_array(ref=None, modname = "Array"): # [ ]
    return add_modifier(ref,modname,'ARRAY')

def add_bevel(ref=None, modname = "Bevel"): # [ ]
    return add_modifier(ref,modname,'BEVEL')

def add_boolean(ref=None, modname = "Boolean"): # [ ]
    return add_modifier(ref,modname,'BOOLEAN')

def add_build(ref=None, modname = "Build"): # [ ]
    return add_modifier(ref,modname,'BUILD')

def add_decimate(ref=None, modname = "Decimate"): # [ ]
    return add_modifier(ref,modname,'DECIMATE')

def add_edge_split(ref=None, modname = "EdgeSplit"): # [ ]
    return add_modifier(ref,modname,'EDGE_SPLIT')

def add_mask(ref=None, modname = "Mask"): # [ ]
    return add_modifier(ref,modname,'MASK')

def add_mirror(ref=None, modname = "Mirror"): # [ ]
    return add_modifier(ref,modname,'MIRROR')

def add_multires(ref=None, modname = "Multires"): # [ ]
    return add_modifier(ref,modname,'MULTIRES')

def add_remesh(ref=None, modname = "Remesh"): # [ ]
    return add_modifier(ref,modname,'REMESH')

def add_screw(ref=None, modname = "Screw"): # [ ]
    return add_modifier(ref,modname,'SCREW')

def add_skin(ref=None, modname = "Skin"): # [ ]
    return add_modifier(ref,modname,'SKIN')

def add_solidify(ref=None, modname = "Solidify"): # [ ]
    return add_modifier(ref,modname,'SOLIDIFY')

def add_subsurf(ref=None, modname = "Subsurf"): # [ ]
    return add_modifier(ref,modname,'SUBSURF')

def add_triangulate(ref=None, modname = "Triangulate"): # [ ]
    return add_modifier(ref,modname,'TRIANGULATE')

def add_weld(ref=None, modname = "Weld"): # [ ]
    return add_modifier(ref,modname,'WELD')

def add_wireframe(ref=None, modname = "Wireframe"): # [ ]
    return add_modifier(ref,modname,'WIREFRAME')

def add_armature(ref=None, modname = "Armature"): # [ ]
    return add_modifier(ref,modname,'ARMATURE')

def add_cast(ref=None, modname = "Cast"): # [ ]
    return add_modifier(ref,modname,'CAST')

def add_curve(ref=None, modname = "Curve"): # [ ]
    return add_modifier(ref,modname,'CURVE')

def add_displace(ref=None, modname = "Displace"): # [ ]
    return add_modifier(ref,modname,'DISPLACE')

def add_hook(ref=None, modname = "Hook"): # [ ]
    return add_modifier(ref,modname,'HOOK')

def add_laplacian_deform(ref=None, modname = "LaplacianDeform"): # [ ]
    return add_modifier(ref,modname,'LAPLACIANDEFORM')

def add_lattice(ref=None, modname = "Lattice"): # [ ]
    return add_modifier(ref,modname,'LATTICE')

def add_mesh_deform(ref=None, modname = "Deform"): # [ ]
    return add_modifier(ref,modname,'MESH_DEFORM')

def add_shrinkwrap(ref=None, modname = "Shrinkwrap"): # [ ]
    return add_modifier(ref,modname,'SHRINKWRAP')

def add_simple_deform(ref=None, modname = "SimpleDeform"): # [ ]
    return add_modifier(ref,modname,'SIMPLE_DEFORM')

def add_smooth(ref=None, modname = "Smooth"): # [ ]
    return add_modifier(ref,modname,'SMOOTH')

def add_corrective_smooth(ref=None, modname = "CorrectiveSmooth"): # [ ]
    return add_modifier(ref,modname,'CORRECTIVE_SMOOTH')

def add_laplacian_smooth(ref=None, modname = "LaplacianSmooth"): # [ ]
    return add_modifier(ref,modname,'LAPLACIANSMOOTH')

def add_surface_deform(ref=None, modname = "SurfaceDeform"): # [ ]
    return add_modifier(ref,modname,'SURFACE_DEFORM')

def add_warp(ref=None, modname = "Warp"): # [ ]
    return add_modifier(ref,modname,'WARP')

def add_wave(ref=None, modname = "Wave"): # [ ]
    mod = add_modifier(ref,modname,'WAVE')
    mod.time_offset = random.random() * get_scene().render.fps
    return mod

def add_cloth(ref=None, modname = "Cloth"): # [ ]
    return add_modifier(ref,modname,'CLOTH')

def add_collision(ref=None, modname = "Collision"): # [ ]
    return add_modifier(ref,modname,'COLLISION')

def add_dynamic_paint(ref=None, modname = "DynamicPaint"): # [ ]
    return add_modifier(ref,modname,'DYNAMIC_PAINT')

def add_explode(ref=None, modname = "Explode"): # [ ]
    return add_modifier(ref,modname,'EXPLODE')

def add_fluid(ref=None, modname = "Fluid"): # [ ]
    return add_modifier(ref,modname,'FLUID')

def add_ocean(ref=None, modname = "Ocean"): # [ ]
    return add_modifier(ref,modname,'OCEAN')

def add_particle_instance(ref=None, modname = "ParticleInstance"): # [ ]
    return add_modifier(ref,modname,'PARTICLE_INSTANCE')

def add_particle_system(ref=None, modname = "ParticleSystem"): # [ ]
    return add_modifier(ref,modname,'PARTICLE_SYSTEM')

def add_soft_body(ref=None, modname = "SoftBody"): # [ ]
    return add_modifier(ref,modname,'SOFT_BODY')

def add_surface(ref=None, modname = ""): # [ ]
    return add_modifier(ref,modname,'SURFACE')

def add_simulation(ref=None, modname = ""): # [ ]
    return add_modifier(ref,modname,'SIMULATION')
#endregion
#region PHYSICS
def add_force_field_physics(ref=None): # [ ]
    objref = get_object(ref)
    bpy.context.view_layer.objects.active = objref
    if objref.field.type == 'NONE':
        bpy.ops.object.forcefield_toggle()

def add_collision_physics(ref=None): # [ ]
    add_collision(ref)

def add_cloth_physics(ref=None): # [ ]
    add_cloth(ref)

def add_dynamic_paint_physics(ref=None): # [ ]
    add_dynamic_paint(ref)

def add_soft_body_physics(ref=None): # [ ]
    add_soft_body(ref)

def add_fluid_physics(ref=None): # [ ]
    add_fluid(ref)

def add_rigid_body_physics(ref=None): # [ ]
    objref = get_object(ref)
    bpy.context.view_layer.objects.active = objref
    bpy.ops.rigidbody.object_add()

def add_rigid_body_constraint_physics(ref=None): # [ ]
    objref = get_object(ref)
    bpy.context.view_layer.objects.active = objref
    bpy.ops.rigidbody.constraint_add()
#endregion
#region PHYSICS - FLUIDS
def set_fluid_type(fluidtype = None): # [ ]
    ftype = bpy.context.object.modifiers["Fluid"].fluid_type
    if fluidtype is not None:
        if fluidtype == "NONE":
            ftype = "NONE"
        if fluidtype == "DOMAIN":
            ftype = "DOMAIN"
        if fluidtype == "FLOW":
            ftype = "FLOW"
        if fluidtype == "EFFECTOR":
            ftype = "EFFECTOR"
    else:
        ftype = "NONE"

# Effector Parameters 
def fluid_effector_type(type): # [ ]
    bpy.context.object.modifiers["Fluid"].effector_settings.effector_type = type

def fluid_effector_subsample_value(value): # [ ]
    intvalue = int(value)
    bpy.context.object.modifiers["Fluid"].effector_settings.subframes = intvalue

def fluid_effector_thickness_value(value): # [ ]
    intvalue = int(value)
    bpy.context.object.modifiers["Fluid"].effector_settings.surface_distance = intvalue

# Use effector, 1 = on 0 = off
def fluid_effector_use_toggle(fbool): # [ ]
    if value.upper() == 'FALSE':
        h =bool(False)
    elif value.upper() == 'TRUE':
        h =bool(True)
    bpy.context.object.modifiers["Fluid"].effector_settings.use_effector = h

# Is Planar, 1 = on 0 = off
def fluid_effector_is_planar(fbool): # [ ]
    if value.upper() == 'FALSE':
        h =bool(False)
    elif value.upper() == 'TRUE':
        h =bool(True)
    bpy.context.object.modifiers["Fluid"].effector_settings.use_plane_init = h

def fluid_effector_velocity(value): # [ ]
    intvalue = int(value)
    bpy.context.object.modifiers["Fluid"].effector_settings.velocity_factor = intvalue

def fluid_effector_guide_mode(value): # [ ]
    if value == 'MAXIMUM' or value == 'MAX':
        bpy.context.object.modifiers["Fluid"].effector_settings.guide_mode = 'MAXIMUM'
    if value == 'MINIMUM' or value == 'MIN':
        bpy.context.object.modifiers["Fluid"].effector_settings.guide_mode = 'MINIMUM'
    if value == 'OVERRIDE' or value == 'OVER':
        bpy.context.object.modifiers["Fluid"].effector_settings.guide_mode = 'OVERRIDE'
    if value == 'AVERAGED' or value == 'MEAN':
        bpy.context.object.modifiers["Fluid"].effector_settings.guide_mode = 'AVERAGED'

# Type Flow Parameters
def fluid_set_flow_type(flowtype = None): # [ ]
    ftype = bpy.context.object.modifiers["Fluid"].flow_settings.flow_type
    if flowtype is not None:
        if flowtype == "SMOKE":
            ftype = "SMOKE"
        if flowtype == "FIRE":
            ftype = "FIRE"
        if flowtype == "LIQUID" or flowtype == "FLUID":
            ftype = "LIQUID"
        if flowtype == "SMOKE_FIRE" or flowtype == "FIRE_SMOKE" or flowtype == "BOTH":
            ftype = "BOTH"
    else:
        ftype = "LIQUID"

def flow_set_behavior(value): # [ ]
    bpy.context.object.modifiers["Fluid"].flow_settings.flow_behavior = value

def flow_use_flow_toggle(value): # [ ]
    if value.upper() == 'FALSE':
        h =bool(False)
    elif value.upper() == 'TRUE':
        h =bool(True)
    bpy.context.object.modifiers["Fluid"].flow_settings.use_inflow = h

def flow_source(value): # [ ]
    if value == 'PARTICLE SYSTEM':
        value = 'PARTICLES'
    bpy.context.object.modifiers["Fluid"].flow_settings.flow_source = value

def flow_smoke_colour_rgb(r,g,b): # [ ]
    print(r+g+b)
    rfloat = float(r)
    gfloat = float(g)
    bfloat = float(b)
    bpy.context.object.modifiers["Fluid"].flow_settings.smoke_color = (rfloat,gfloat,bfloat)

def flow_absolute_density(value): # [ ]
    bool = int(value)
    bpy.context.object.modifiers["Fluid"].flow_settings.use_absolute = bool

def flow_initial_temp(value): # [ ]
    temp = int(value)
    bpy.context.object.modifiers["Fluid"].flow_settings.temperature = temp

def flow_density(value): # [ ]
    density = int(value)
    bpy.context.object.modifiers["Fluid"].flow_settings.density = density

def flow_vertexgroup(value): # [ ]
    bpy.context.object.modifiers["Fluid"].flow_settings.density_vertex_group = value

# Particle System
def flow_particle_system_select(value): # [ ]
    bpy.context.object.modifiers["Fluid"].flow_settings.particle_system = bpy.data.objects["Cube"].particle_systems[value]

def flow_particle_set_size_toggle(value): # [ ]
    if value.upper() == 'FALSE':
        h =bool(False)
    elif value.upper() == 'TRUE':
        h =bool(True)
    bpy.context.object.modifiers["Fluid"].flow_settings.use_particle_size = h

def flow_set_particle_size(value): # [ ]
    size = float(value)
    bpy.context.object.modifiers["Fluid"].flow_settings.particle_size = size

# Intial Velocity
def flow_initial_velocity_toggle(value): # [ ]
    if value.upper() == 'FALSE':
        h =bool(False)
    elif value.upper() == 'TRUE':
        h =bool(True)
    bpy.context.object.modifiers["Fluid"].flow_settings.use_initial_velocity = h

def flow_initial_velocity_value(value): # [ ]
    velocity = float(value)
    bpy.context.object.modifiers["Fluid"].flow_settings.velocity_factor = velocity

# Domains
def fluid_set_domain_type(domaintype = None): # [ ]
    dtype = bpy.context.object.modifiers["Fluid"].domain_settings.domain_type
    if domaintype is not None:
        if domaintype == "GAS":
            dtype = "GAS"
        if domaintype == "LIQUID":
            dtype = "LIQUID"
    else:
        dtype = "LIQUID"

# Global Fluid Settings
def fluid_domain_set_resolution(value): # [ ]
    res = int(value)
    bpy.context.object.modifiers["Fluid"].domain_settings.resolution_max = res

def fluid_domain_time_scale(value): # [ ]
    timespeed = float(value)
    bpy.context.object.modifiers["Fluid"].domain_settings.time_scale = timespeed

def fluid_domain_set_cfl(value): # [ ]
    CFL = float(value)
    bpy.context.object.modifiers["Fluid"].domain_settings.cfl_condition = CFL

def fluid_domain_set_timesteps_max(value): # [ ]
    timestep = int(value)
    bpy.context.object.modifiers["Fluid"].domain_settings.timesteps_max = timestep

def fluid_domain_set_timesteps_min(value): # [ ]
    timestep = int(value)
    bpy.context.object.modifiers["Fluid"].domain_settings.timesteps_min = timestep

# Border Collisions
def fluid_domain_border_colisions(side,toggle): # [ ]
    bool = int(toggle)
    if side == 'top' or side == 'TOP':
        bpy.context.object.modifiers["Fluid"].domain_settings.use_collision_border_top = bool
    if side == 'back' or side == 'BACK':
        bpy.context.object.modifiers["Fluid"].domain_settings.use_collision_border_back = bool
    if side == 'front' or side == 'FRONT':
        bpy.context.object.modifiers["Fluid"].domain_settings.use_collision_border_front = bool
    if side == 'right' or side == 'RIGHT':
        bpy.context.object.modifiers["Fluid"].domain_settings.use_collision_border_right = bool
    if side == 'left' or side == 'LEFT':
        bpy.context.object.modifiers["Fluid"].domain_settings.use_collision_border_left = bool
    if side == 'bottom' or side == 'BOTTOM':
        bpy.context.object.modifiers["Fluid"].domain_settings.use_collision_border_bottom = bool

# Caches      
def fluid_domain_cache_folder(value): # [ ]
    bpy.context.object.modifiers["Fluid"].domain_settings.cache_directory = value

def fluid_simulation_start(value): # [ ]
    start = int(value)
    bpy.context.object.modifiers["Fluid"].domain_settings.cache_frame_start = start

def fluid_simulation_end(value): # [ ]
    end = int(value)
    bpy.context.object.modifiers["Fluid"].domain_settings.cache_frame_end = end

def fluid_simulation_offset(value): # [ ]
    end = int(value)
    bpy.context.object.modifiers["Fluid"].domain_settings.cache_frame_offset = end

def fluid_cache_type(value): # [ ]
    bpy.context.object.modifiers["Fluid"].domain_settings.cache_type = value
    #use REPLAY, MODULAR, and ALL

def fluid_cache_continue_toggle(value): # [ ]
    if value.upper() == 'FALSE':
        h =bool(False)
    elif value.upper() == 'TRUE':
        h =bool(True)
    bpy.context.object.modifiers["Fluid"].domain_settings.cache_resumable = h

def fluid_cache_format(value): # [ ]
    if value.lower() == 'openvdb':
        bpy.context.object.modifiers["Fluid"].domain_settings.cache_data_format = 'OPENVDB'
    if value.lower() == 'uni cache':
        bpy.context.object.modifiers["Fluid"].domain_settings.cache_data_format = 'UNI'

def fluid_cache_compress_type(value): # [ ]
    if value.lower() == 'zip':
        bpy.context.object.modifiers["Fluid"].domain_settings.openvdb_cache_compress_type = 'ZIP'
    if value.lower() == 'blosc':
        bpy.context.object.modifiers["Fluid"].domain_settings.openvdb_cache_compress_type = 'BLOSC'
    if value.lower() == 'none':
        bpy.context.object.modifiers["Fluid"].domain_settings.openvdb_cache_compress_type = 'NONE'

def fluid_cache_precision(value): # [ ]
    print(value)
    if value.lower() == 'half':
        value = "16"
    if value.lower() == 'full':
        value = "32"
    bpy.context.object.modifiers["Fluid"].domain_settings.openvdb_data_depth = value

#Collections 
def fluid_flow_collection(value): # [ ]
    bpy.context.object.modifiers["Fluid"].domain_settings.fluid_group = bpy.data.collections[value]

def fluid_flow_effectorn(value): # [ ]
    bpy.context.object.modifiers["Fluid"].domain_settings.effector_group = bpy.data.collections[value]

#Guides
def fluid_domain_guides_toggle(value): # [ ]
    if value.upper() == 'FALSE':
        h =bool(False)
    elif value.upper() == 'TRUE':
        h =bool(True)
    bpy.context.object.modifiers["Fluid"].domain_settings.use_guide = h

def fluid_domain_guide_weight(value): # [ ]
    val = float(value)
    bpy.context.object.modifiers["Fluid"].domain_settings.guide_alpha = val

def fluid_domain_guides_size(value): # [ ]
    val = int(value)
    bpy.context.object.modifiers["Fluid"].domain_settings.guide_beta = val

def fluid_domain_guides_velocity(value): # [ ]
    val = float(value)
    bpy.context.object.modifiers["Fluid"].domain_settings.guide_vel_factor = val

def fluid_domain_guides_source(value): # [ ]
    bpy.context.object.modifiers["Fluid"].domain_settings.guide_source = value.upper()

# Field Weights
def fluid_field_weights_collection(value): # [ ]
    bpy.context.object.modifiers["Fluid"].domain_settings.effector_weights.collection = bpy.data.collections[value]

def fluid_field_weights_gravity(value): # [ ]
    val = float(value)
    bpy.context.object.modifiers["Fluid"].domain_settings.effector_weights.gravity = val

def fluid_field_weights_all(value): # [ ]
    val = float(value)
    bpy.context.object.modifiers["Fluid"].domain_settings.effector_weights.all = val

def fluid_field_weights_force(value): # [ ]
    val = float(value)
    bpy.context.object.modifiers["Fluid"].domain_settings.effector_weights.force = val

def fluid_field_weights_vortex(value): # [ ]
    val = float(value)
    bpy.context.object.modifiers["Fluid"].domain_settings.effector_weights.vortex = val

def fluid_field_weights_magnetic(value): # [ ]
    val = float(value)
    bpy.context.object.modifiers["Fluid"].domain_settings.effector_weights.magnetic = val

def fluid_field_weights_harmonic(value): # [ ]
    val = float(value)
    bpy.context.object.modifiers["Fluid"].domain_settings.effector_weights.harmonic = val

def fluid_field_weights_charge(value): # [ ]
    val = float(value)
    bpy.context.object.modifiers["Fluid"].domain_settings.effector_weights.charge = val

def fluid_field_weights_lennardjones(value): # [ ]
    val = float(value)
    bpy.context.object.modifiers["Fluid"].domain_settings.effector_weights.lennardjones = val

def fluid_field_weights_wind(value): # [ ]
    val = float(value)
    bpy.context.object.modifiers["Fluid"].domain_settings.effector_weights.wind = val

def fluid_field_weights_curve_guide(value): # [ ]
    val = float(value)
    bpy.context.object.modifiers["Fluid"].domain_settings.effector_weights.curve_guide = val

def fluid_field_weights_texture(value): # [ ]
    val = float(value)
    bpy.context.object.modifiers["Fluid"].domain_settings.effector_weights.texture = val

def fluid_field_weights_smoke_flow(value): # [ ]
    val = float(value)
    bpy.context.object.modifiers["Fluid"].domain_settings.effector_weights.smokeflow = val

def fluid_field_weights_turbulence(value): # [ ]
    val = float(value)
    bpy.context.object.modifiers["Fluid"].domain_settings.effector_weights.turbulence = val

def fluid_field_weights_drag(value): # [ ]
    val = float(value)
    bpy.context.object.modifiers["Fluid"].domain_settings.effector_weights.drag = val

def fluid_field_weights_boid(value): # [ ]
    val = float(value)
    bpy.context.object.modifiers["Fluid"].domain_settings.effector_weights.boid = val

# Viewport Display
def fluid_view_thickness(value): # [ ]
    val = float(value)
    bpy.context.object.modifiers["Fluid"].domain_settings.display_thickness = val

def fluid_view_interpolation(value): # [ ]
    bpy.context.object.modifiers["Fluid"].domain_settings.display_interpolation = value.upper()

def fluid_view_slices_voxel(value): # [ ]
    val = float(value)
    bpy.context.object.modifiers["Fluid"].domain_settings.slice_per_voxel = val

def fluid_view_slice_toggle(value): # [ ]
    if value.upper() == 'FALSE':
        h =bool(False)
    elif value.upper() == 'TRUE':
        h =bool(True)
    bpy.context.object.modifiers["Fluid"].domain_settings.use_slice =h

def fluid_view_slice_axis(value): # [ ]
    bpy.context.object.modifiers["Fluid"].domain_settings.slice_axis = value.upper

def fluid_view_slice_position(value): # [ ]
    boolean = float(value)
    bpy.context.object.modifiers["Fluid"].domain_settings.slice_depth = boolean 

def fluid_view_grid_toggle(value): # [ ]
    if value.upper() == 'FALSE':
        h =bool(False)
    elif value.upper() == 'TRUE':
        h =bool(True)
    bpy.context.object.modifiers["Fluid"].domain_settings.use_color_ramp = h

def fluid_view_grid_scale(value): # [ ]
    val = float(value)
    bpy.context.object.modifiers["Fluid"].domain_settings.color_ramp_field_scale = val

def fluid_view_grid_color_position(pos,stop): # [ ]
    val = float(pos)
    position = int(stop)
    bpy.context.active_object.modifiers["Fluid"].domain_settings.color_ramp.elements[position].position= val

def fluid_view_grid_color_hue_interpolation(value): # [ ]
    bpy.context.active_object.modifiers["Fluid"].domain_settings.color_ramp.hue_interpolation = value.upper()

def fluid_view_grid_color(stop,encoding,r,g,b,al): # [ ]
    bpy.context.active_object.modifiers["Fluid"].domain_settings.color_ramp.color_mode = encoding.upper()
    stopint = int(stop)
    red = float(r)
    green = float(b)
    blue = float(g)
    alpha = float(al)
    bpy.context.active_object.modifiers["Fluid"].domain_settings.color_ramp.elements[stopint].color = (red,green,blue,alpha)

def fluid_view_grid_stops_new(value): # [ ]
    val = float(value)
    bpy.context.active_object.modifiers["Fluid"].domain_settings.color_ramp.elements.new(val)

def fluid_view_grid_stops_remove(value): # [ ]
    val = int(value)
    bpy.context.active_object.modifiers["Fluid"].domain_settings.color_ramp.elements.remove( bpy.context.active_object.modifiers["Fluid"].domain_settings.color_ramp.elements[val] )

def fluid_view_vector_dis_toggle(value): # [ ]
    if value.upper() == 'FALSE':
        h =bool(False)
    elif value.upper() == 'TRUE':
        h =bool(True)
    bpy.context.object.modifiers["Fluid"].domain_settings.use_slice = h

def fluid_view_vector_display_type(value): # [ ]
    bpy.context.object.modifiers["Fluid"].domain_settings.vector_display_type = value.upper()

def fluid_view_vector_magnitude(value): # [ ]
    val = int(value)
    bpy.context.object.modifiers["Fluid"].domain_settings.vector_scale_with_magnitude = val

def fluid_view_vector_field(value): # [ ]
    bpy.context.object.modifiers["Fluid"].domain_settings.vector_field = value.upper()

def fluid_view_vector_scale(value): # [ ]
    val = float(value)
    bpy.context.object.modifiers["Fluid"].domain_settings.vector_scale = val

# Gas Domain (not categorized)
def fluid_gas_buoyancy_density(value): # [ ]
    val = float(value)
    bpy.context.object.modifiers["Fluid"].domain_settings.alpha = val

def fluid_gas_buoyancy_heat(value): # [ ]
    val = float(value)
    bpy.context.object.modifiers["Fluid"].domain_settings.beta = val

def fluid_gas_buoyancy_vorticity(value): # [ ]
    val = float(value)
    bpy.context.object.modifiers["Fluid"].domain_settings.vorticity = val

# Dissolve
def fluid_gas_dissolve_toggle(value): # [ ]
    if value.upper() == 'FALSE':
        h =bool(False)
    elif value.upper() == 'TRUE':
        h =bool(True)
    bpy.context.object.modifiers["Fluid"].domain_settings.use_dissolve_smoke = h

def fluid_gas_dissolve_time(value): # [ ]
    val = int(value)
    bpy.context.object.modifiers["Fluid"].domain_settings.dissolve_speed = val

def fluid_gas_dissolve_slow_toggle(value): # [ ]
    if value.upper() == 'FALSE':
        h =bool(False)
    elif value.upper() == 'TRUE':
        h =bool(True)
    bpy.context.object.modifiers["Fluid"].domain_settings.use_dissolve_smoke_log = h

# Noise
def fluid_gas_noise_toggle(value): # [ ]
    if value.upper() == 'FALSE':
        h =bool(False)
    elif value.upper() == 'TRUE':
        h =bool(True)
    bpy.context.object.modifiers["Fluid"].domain_settings.use_noise = h

def fluid_gas_noise_toggle(value): # [ ]
    if value.upper() == 'FALSE':
        h =bool(False)
    elif value.upper() == 'TRUE':
        h =bool(True)
    bpy.context.object.modifiers["Fluid"].domain_settings.noise_scale = h

def fluid_gas_noise_upres_factor(value): # [ ]
    val = int(value)
    bpy.context.object.modifiers["Fluid"].domain_settings.noise_scale = val

def fluid_gas_noise_method(value): # [ ]
    bpy.context.object.modifiers["Fluid"].domain_settings.noise_type = value.upper()

def fluid_gas_noise_strength(value): # [ ]
    val = float(value)
    bpy.context.object.modifiers["Fluid"].domain_settings.noise_strength = val

def fluid_gas_noise_scale(value): # [ ]
    val = float(value)
    bpy.context.object.modifiers["Fluid"].domain_settings.noise_pos_scale = val

def fluid_gas_noise_time(value): # [ ]
    val = float(value)
    bpy.context.object.modifiers["Fluid"].domain_settings.noise_time_anim = val

# Fire
def fluid_gas_fire_reaction_speed(value): # [ ]
    val = float(value)
    bpy.context.object.modifiers["Fluid"].domain_settings.burning_rate = val

def fluid_gas_fire_smoke(value): # [ ]
    val = float(value)
    bpy.context.object.modifiers["Fluid"].domain_settings.flame_smoke = val

def fluid_gas_fire_vorticity(value): # [ ]
    val = float(value)
    bpy.context.object.modifiers["Fluid"].domain_settings.flame_vorticity = val

def fluid_gas_fire_temp_max(value): # [ ]
    val = float(value)
    bpy.context.object.modifiers["Fluid"].domain_settings.flame_max_temp = val

def fluid_gas_fire_temp_min(value): # [ ]
    val = float(value)
    bpy.context.object.modifiers["Fluid"].domain_settings.flame_ignition = val

def fluid_gas_fire_color_rgb(red,green,blue): # [ ]
    r = float(red)
    g = float(green)
    b = float(blue)
    bpy.context.object.modifiers["Fluid"].domain_settings.flame_smoke_color = (r, g, b)

# Fluid
def fluid_fluid_toggle(value): # [ ]
    if value.upper() == 'FALSE':
        h =bool(False)
    elif value.upper() == 'TRUE':
        h =bool(True)
    bpy.context.object.modifiers["Fluid"].domain_settings.use_flip_particles = h

def fluid_fluid_flip_ratio(value): # [ ]
    val = float(value)
    bpy.context.object.modifiers["Fluid"].domain_settings.flip_ratio = val

def fluid_fluid_particle_max(value): # [ ]
    val = int(value)
    bpy.context.object.modifiers["Fluid"].domain_settings.sys_particle_maximum = val

def fluid_fluid_particle_radius(value): # [ ]
    val = float(value)
    bpy.context.object.modifiers["Fluid"].domain_settings.particle_radius = val

def fluid_fluid_particle_sampling(value): # [ ]
    val = int(value)
    bpy.context.object.modifiers["Fluid"].domain_settings.particle_number = val

def fluid_fluid_particle_random(value): # [ ]
    val = float(value)
    bpy.context.object.modifiers["Fluid"].domain_settings.particle_randomness = val

def fluid_fluid_cell_max(value): # [ ]
    val = int(value)
    bpy.context.object.modifiers["Fluid"].domain_settings.particle_max = val

def fluid_fluid_cell_min(value): # [ ]
    val = int(value)
    bpy.context.object.modifiers["Fluid"].domain_settings.particle_min = val

def fluid_fluid_narrow_bandwidth(value): # [ ]
    val = float(value)
    bpy.context.object.modifiers["Fluid"].domain_settings.particle_band_width = val

def fluid_fluid_frac_obs_toggle(value): # [ ]
    if value.upper() == 'FALSE':
        h =bool(False)
    elif value.upper() == 'TRUE':
        h =bool(True)
    bpy.context.object.modifiers["Fluid"].domain_settings.use_fractions = h

def fluid_fluid_obs_distance(value): # [ ]
    val = float(value)
    bpy.context.object.modifiers["Fluid"].domain_settings.fractions_distance = val

def fluid_fluid_obs_threshold(value): # [ ]
    val = float(value)
    bpy.context.object.modifiers["Fluid"].domain_settings.fractions_threshold = val

def fluid_fluid_diffusion_toggle(value): # [ ]
    if value.upper() == 'FALSE':
        h =bool(False)
    elif value.upper() == 'TRUE':
        h =bool(True)
    bpy.context.object.modifiers["Fluid"].domain_settings.use_diffusion = h

def fluid_fluid_diffusion_base(value): # [ ]
    val = float(value)
    bpy.context.object.modifiers["Fluid"].domain_settings.viscosity_base = val

def fluid_fluid_diffusion_exponent(value): # [ ]
    val = int(value)
    bpy.context.object.modifiers["Fluid"].domain_settings.viscosity_exponent = val

def fluid_fluid_diffusion_surface(value): # [ ]
    val = float(value)
    bpy.context.object.modifiers["Fluid"].domain_settings.surface_tension = val

def fluid_fluid_particles_bubbles_toggle(value): # [ ]
    if value.upper() == 'FALSE':
        h =bool(False)
    elif value.upper() == 'TRUE':
        h =bool(True)
    bpy.context.object.modifiers["Fluid"].domain_settings.use_bubble_particles = h

def fluid_fluid_particles_foam_toggle(value): # [ ]
    if value.upper() == 'FALSE':
        h =bool(False)
    elif value.upper() == 'TRUE':
        h =bool(True)
    bpy.context.object.modifiers["Fluid"].domain_settings.use_foam_particles = h

def fluid_fluid_particles_spray_toggle(value): # [ ]
    if value.upper() == 'FALSE':
        h =bool(False)
    elif value.upper() == 'TRUE':
        h =bool(True)
    bpy.context.object.modifiers["Fluid"].domain_settings.use_spray_particles = h

def fluid_fluid_particles_combined_export(value): # [ ]
    value = value.replace(" ", "_")
    value = value.upper()
    print(value)
    bpy.context.object.modifiers["Fluid"].domain_settings.sndparticle_combined_export = value

def fluid_fluid_particles_wave_crest_potential_maximum(value): # [ ]
    val = float(value)
    bpy.context.object.modifiers["Fluid"].domain_settings.sndparticle_potential_max_wavecrest = val

def fluid_fluid_particles_wave_crest_potential_minimum(value): # [ ]
    val = float(value)
    bpy.context.object.modifiers["Fluid"].domain_settings.sndparticle_potential_min_wavecrest = val

def fluid_fluid_particles_traped_air_potential_minimum(value): # [ ]
    val = float(value)
    bpy.context.object.modifiers["Fluid"].domain_settings.sndparticle_potential_max_trappedair = val

def fluid_fluid_particles_kinetic_potential_minimum(value): # [ ]
    val = float(value)
    bpy.context.object.modifiers["Fluid"].domain_settings.sndparticle_potential_max_energy = val

def fluid_fluid_particles_kinetic_potential_minimum(value): # [ ]
    val = float(value)
    bpy.context.object.modifiers["Fluid"].domain_settings.sndparticle_potential_min_energy = val

def fluid_fluid_particles_potential_radius(value): # [ ]
    val = int(value)
    bpy.context.object.modifiers["Fluid"].domain_settings.sndparticle_potential_min_energy = val

def fluid_fluid_particles_particle_update_radius(value): # [ ]
    val = int(value)
    bpy.context.object.modifiers["Fluid"].domain_settings.sndparticle_potential_min_energy = val

def fluid_fluid_particles_wave_crest_particle_sampling(value): # [ ]
    val = int(value)
    bpy.context.object.modifiers["Fluid"].domain_settings.sndparticle_sampling_trappedair = val

def fluid_fluid_particles_traped_air_particle_sampling(value): # [ ]
    val = int(value)
    bpy.context.object.modifiers["Fluid"].domain_settings.sndparticle_sampling_wavecrest = val

def fluid_fluid_particles_particle_life_maximum(value): # [ ]
    val = float(value)
    bpy.context.object.modifiers["Fluid"].domain_settings.sndparticle_life_max = val

def fluid_fluid_particles_particle_life_minimum(value): # [ ]
    val = float(value)
    bpy.context.object.modifiers["Fluid"].domain_settings.sndparticle_life_min = val

def fluid_fluid_particles_bubble_buoyancy(value): # [ ]
    val = float(value)
    bpy.context.object.modifiers["Fluid"].domain_settings.sndparticle_bubble_buoyancy = val

def fluid_fluid_particles_bubble_drag(value): # [ ]
    val = float(value)
    bpy.context.object.modifiers["Fluid"].domain_settings.sndparticle_bubble_drag = val

def fluid_fluid_particles_particles_in_boundary(value): # [ ]
    bpy.context.object.modifiers["Fluid"].domain_settings.sndparticle_boundary = value.upper()

def fluid_fluid_mesh_toggle(value): # [ ]
    if value.upper() == 'FALSE':
        h =bool(False)
    elif value.upper() == 'TRUE':
        h =bool(True)
    bpy.context.object.modifiers["Fluid"].domain_settings.use_mesh = h

def fluid_fluid_mesh_upres(value): # [ ]
    val = int(value)
    bpy.context.object.modifiers["Fluid"].domain_settings.mesh_scale = val

def fluid_fluid_mesh_particle_radius(value): # [ ]
    val = float(value)
    bpy.context.object.modifiers["Fluid"].domain_settings.mesh_particle_radius = val

def fluid_fluid_mesh_smooth_pos(value): # [ ]
    val = int(value)
    bpy.context.object.modifiers["Fluid"].domain_settings.mesh_smoothen_pos = val

def fluid_fluid_mesh_smooth_pos(value): # [ ]
    val = int(value)
    bpy.context.object.modifiers["Fluid"].domain_settings.mesh_smoothen_pos = val

def fluid_fluid_mesh_use_speed_vectors(value): # [ ]
    if value.upper() == 'FALSE':
        h =bool(False)
    elif value.upper() == 'TRUE':
        h =bool(True)    
    bpy.context.object.modifiers["Fluid"].domain_settings.use_speed_vectors = h

def fluid_fluid_mesh_generator(value): # [ ]
    if value.upper() == 'FINAL':
        bpy.context.object.modifiers["Fluid"].domain_settings.mesh_generator = 'IMPROVED'
    elif value.upper() == 'PREVIEW':
        bpy.context.object.modifiers["Fluid"].domain_settings.mesh_generator = 'UNION'

def fluid_fluid_mesh_concavity_upper(value): # [ ]
    val = float(value)
    bpy.context.object.modifiers["Fluid"].domain_settings.mesh_concave_upper = val

def fluid_fluid_mesh_concavity_lower(value): # [ ]
    val = float(value)
    bpy.context.object.modifiers["Fluid"].domain_settings.mesh_concave_lower = val

# Adpative Domain
def fluid_domain_adapt_toggle(value): # [ ]
    if value.upper() == 'FALSE':
        h =bool(False)
    elif value.upper() == 'TRUE':
        h =bool(True)
    bpy.context.object.modifiers["Fluid"].domain_settings.use_adaptive_domain = h

def fluid_domain_adapt_res(value): # [ ]
    intval = int(value)
    bpy.context.object.modifiers["Fluid"].domain_settings.additional_res = intval

def fluid_domain_adapt_margin(value): # [ ]
    intval = int(value)
    if intval > 24:
        print("Too high")
    else:
        bpy.context.object.modifiers["Fluid"].domain_settings.adapt_margin = intval

def fluid_domain_adapt_threshold(value): # [ ]
    floatval = float(value)
    if floatval > 1:
        print("Too high")
    else:
        bpy.context.object.modifiers["Fluid"].domain_settings.adapt_threshold = floatval
#endregion
#region PHYSICS - COLLISION
def collision_use(value = True): # [ ]
    bpy.context.object.collision.use = value

def use_collision(value = True): # [ ]
    collision_use(value)

def collision_field_absorption(value): # [ ]
    val = float(value)
    bpy.context.object.collision.absorption = val

def collision_particle_permeability(value): # [ ]
    val = float(value)
    bpy.context.object.collision.permeability = val

def collision_particle_stickiness(value): # [ ]
    val = float(value)
    bpy.context.object.collision.stickiness = val

def collision_particle_kill(value = True): # [ ]
    bpy.context.object.collision.use_particle_kill = value

def collision_particle_friction(value): # [ ]
    val = float(value)
    bpy.context.object.collision.friction_factor = val

def collision_particle_friction_random(value): # [ ]
    val = float(value)
    bpy.context.object.collision.friction_random = val

def collision_particle_damping(value): # [ ]
    val = float(value)
    bpy.context.object.collision.damping_factor = val

def collision_particle_damping_random(value): # [ ]
    val = float(value)
    bpy.context.object.collision.damping_random = val

def collision_soft_cloth_damping(value): # [ ]
    val = float(value)
    bpy.context.object.collision.damping = val

def collision_soft_cloth_friction(value): # [ ]
    val = float(value)
    bpy.context.object.collision.cloth_friction = val

def collision_soft_cloth_thick_out(value): # [ ]
    val = float(value)
    bpy.context.object.collision.thickness_outer = val

def collision_soft_cloth_thick_in(value): # [ ]
    val = float(value)
    bpy.context.object.collision.thickness_inner = val

def collision_soft_cloth_single_side(value = True): # [ ]
    bpy.context.object.collision.use_culling = value
    
def collision_soft_cloth_override_normals(value = True): # [ ]
    bpy.context.object.collision.use_normal = value
#endregion
#region TEXT OBJECTS
def create_text_file(textname): # [ ]
    return bpy.data.texts.new(textname)

def delete_text_file(textname): # [ ]
    if is_string(textname):
        t = bpy.data.texts[textname]
        bpy.data.texts.remove(t)
    else:
        bpy.data.texts.remove(textname)
    
def get_lines_in_text_object(textname): # [ ]
    return bpy.data.texts[textname].lines
#endregion
#region FAKE USERS
def set_fake_user(ref, use = True): # [ ]
    ref.use_fake_user = use

def use_fake_user(ref, use = True): # [ ]
    ref.use_fake_user = use
#endregion
#region DATA CHECKS
def is_string(ref): # [ ]
    if isinstance(ref, str):
        return True
    else:
        return False
#endregion
#region DATA CONSTRUCTORS
def make_vector(data): # [ ]
    return Vector((data[0],data[1],data[2]))
def make_obj_list(ref): # [ ]
    if ref is None:
        return [get_object(ref)]
    return get_objects(ref)
#endregion
#region MISC
def clear_unwanted_data(): # [ ]
    delete_unused_data()
def clear_unused_data(): # [ ]
    #bpy.ops.outliner.orphans_purge()
    delete_unused_data()
def delete_unused_data(): # [ ]
    #bpy.data.orphans_purge() # is considered experimental
    for block in bpy.data.lights:
        if block.users == 0:
            bpy.data.lights.remove(block)
    
    for block in bpy.data.curves:
        if block.users == 0:
            bpy.data.curves.remove(block)
    
    for block in bpy.data.cameras:
        if block.users == 0:
            bpy.data.cameras.remove(block)
            
    for block in bpy.data.meshes:
        if block.users == 0:
            bpy.data.meshes.remove(block)

    for block in bpy.data.materials:
        if block.users == 0:
            bpy.data.materials.remove(block)

    for block in bpy.data.textures:
        if block.users == 0:
            bpy.data.textures.remove(block)

    for block in bpy.data.images:
        if block.users == 0:
            bpy.data.images.remove(block)
def debug_test(): # [ ]
    print("EasyBPY debug output")
#endregion
#region COMMON WORKFLOW FUNCTIONS
def get_objects_containing(ref): # [ ]
    result = []
    for o in bpy.data.objects:
        if ref in o.name:
            result.append(o)
    return result

def select_objects_containing(ref): # [ ]
    objs = select_objects(get_objects_containing(ref))
    return objs

def get_materials_containing(name, ref = None): # [ ]
    results = []
    if ref is not None:
        mats = get_materials_from_object(ref)
        for m in mats:
            if name in m.name:
                results.append(m)
    else:
        for m in bpy.data.materials:
            if name in m.name:
                results.append(m)
    return results

def get_particle_systems_containing(name, ref): # [ ]
    result = []
    ps = get_particle_systems(ref)
    for p in ps:
        if name in p.name:
            result.append(p)
    return result

def organize_outliner(): # [ ]
    d = deselect_all_objects
    c = create_collection
    m = move_objects_to_collection
    ce = collection_exists
    gc = get_collection

    if bpy.context.active_object != None:
        if bpy.context.active_object.mode != 'OBJECT':
            bpy.ops.object.mode_set(mode='OBJECT')

    # Cameras
    d()
    select_all_cameras()
    colname = "Cameras"
    if len(so())>0:
        col = None
        if ce(colname):
            col = gc(colname)
            pass
        else:
            col = c(colname)
        m(so(),col)

    # Lights
    d()
    select_all_lights()
    colname = "Lights"
    if len(so())>0:
        col = None
        if ce(colname):
            col = gc(colname)
            pass
        else:
            col = c(colname)
        m(so(),col)

    # Empties
    d()
    select_all_empties()
    colname = "Empties"
    if len(so())>0:
        col = None
        if ce(colname):
            col = gc(colname)
            pass
        else:
            col = c(colname)
        m(so(),col)

    # Mesh Objects
    d()
    select_all_meshes()
    colname = "Objects"
    if len(so())>0:
        col = None
        if ce(colname):
            col = gc(colname)
            pass
        else:
            col = c(colname)
        m(so(),col)

    # Curves
    d()
    select_all_curves()
    colname = "Curves"
    if len(so())>0:
        col = None
        if ce(colname):
            col = gc(colname)
            pass
        else:
            col = c(colname)
        m(so(),col)
        
    # Surfaces
    d()
    select_all_surfaces()
    colname = "Surfaces"
    if len(so())>0:
        col = None
        if ce(colname):
            col = gc(colname)
            pass
        else:
            col = c(colname)
        m(so(),col)
        
    # Metas
    d()
    select_all_metas()
    colname = "Metas"
    if len(so())>0:
        col = None
        if ce(colname):
            col = gc(colname)
            pass
        else:
            col = c(colname)
        m(so(),col)

    # Text
    d()
    select_all_text()
    colname = "Text"
    if len(so())>0:
        col = None
        if ce(colname):
            col = gc(colname)
            pass
        else:
            col = c(colname)
        m(so(),col)

    # Volumes
    d()
    select_all_volumes()
    colname = "Volumes"
    if len(so())>0:
        col = None
        if ce(colname):
            col = gc(colname)
            pass
        else:
            col = c(colname)
        m(so(),col)

    # Armatures
    d()
    select_all_armatures()
    colname = "Armatures"
    if len(so())>0:
        col = None
        if ce(colname):
            col = gc(colname)
            pass
        else:
            col = c(colname)
        m(so(),col)

    # Lattices
    d()
    select_all_lattices()
    colname = "Lattices"
    if len(so())>0:
        col = None
        if ce(colname):
            col = gc(colname)
            pass
        else:
            col = c(colname)
        m(so(),col)

    # Grease Pencil
    d()
    select_all_grease_pencils()
    colname = "Grease Pencils"
    if len(so())>0:
        col = None
        if ce(colname):
            col = gc(colname)
            pass
        else:
            col = c(colname)
        m(so(),col)

    # Light Probes
    d()
    select_all_light_probes()
    colname = "Light Probes"
    if len(so())>0:
        col = None
        if ce(colname):
            col = gc(colname)
            pass
        else:
            col = c(colname)
        m(so(),col)
    
    # End
    d()

def suffix_convert_dataset(data): # [ ]
    for d in data:
        nn = d.name
        exclude = ["png", "jpg", "jpeg", "tif", "tiff", "bmp", "sgi", "rgb", "bw", "jp2", "j2c", "tga", "cin", "dpx", "exr", "hdr", "webp"]
        if not any(x in nn for x in exclude):
            if '_' in d.name:
                r = d.name.split('_')
                if '.' in r[-1]:
                    r2 = r[-1].split('.')
                    if r2[0].isdigit():
                        val = int(r2[0]) + int(r2[1])
                        nn = r[0] + '_' + str(val)
                        i = 1
                        while nn in data:
                            nn = r[0] + '_' + str(val + i)
                            i += 1
                    else:
                        if r2[1].isdigit():
                            val = int(r2[1])
                            i = 0
                            nn = ""
                            while i < len(r)-1:
                                nn = nn + r[i] + "_"
                                i+=1
                            nn = nn + r2[0] + "_" + str(val)
            else:
                if '.' in d.name:
                    r = d.name.split('.')
                    if r[-1].isdigit():
                        val = int(r[-1])
                        nn = r[0] + '_' + str(val)
                        i = 1
                        while nn in data:
                            nn = r[0] + '_' + str(val + i)
                            i += 1
        d.name = nn

def convert_suffixes_underscore(): # [ ]
    suffix_convert_dataset(bpy.data.meshes)
    suffix_convert_dataset(bpy.data.objects)
    suffix_convert_dataset(bpy.data.textures)
    suffix_convert_dataset(bpy.data.images)
    suffix_convert_dataset(bpy.data.materials)

def convert_suffixes(): # [ ]
    convert_suffixes_underscore()

def trim_view_layer_suffixes(): # [4.2+4.3]
    for o in bpy.context.view_layer.objects:
        if o is None:
            continue
        if o.name.endswith(".001"):
            newname = o.name[:-4]
            if newname in bpy.data.objects:
                #if bpy.app.version >= (4, 3, 0):
                    #o.rename(newname, mode="ALWAYS")
                #else:
                # Rename the existing object to avoid conflict.
                conflicting_object = bpy.data.objects[newname]
                conflicting_object.name = newname + "_old"
                o.name = newname

def add_prefix_to_name(ref, prefix, delim="_"): # [ ]
    objlist = make_obj_list(ref)
    for o in objlist:
        o.name = prefix + delim + o.name

def add_suffix_to_name(ref, suffix, delim="_"): # [ ]
    objlist = make_obj_list(ref)
    for o in objlist:
        o.name = o.name + delim + suffix

def remove_suffix_from_name(ref, delim="_"): # [ ]
    objlist = make_obj_list(ref)
    for o in objlist:
        split = o.name.split(delim)
        o.name = split[0]

def remove_suffix(ref, delim="_"): # [ ]
    remove_suffix_from_name(ref,delim)

def replace_duplicate_nodes(nodes): # [ ]
    for node in nodes:
        # If node is group
        if node.type == 'GROUP':
            # If name has suffix
            if '.' in node.name:
                # Remove suffix
                sname = node.node_tree.name.split('.')
                # If name w/o suffix is node group
                if sname[0] in bpy.data.node_groups:
                    # Set node group to node name w/o suffix
                    node.node_tree = bpy.data.node_groups[sname[0]]

def fix_node_duplicates(): # [ ]
    for m in bpy.data.materials:
        matnodes = get_nodes(m)
        if matnodes:
            replace_duplicate_nodes(matnodes)
    for ng in bpy.data.node_groups:
        ngnodes = ng.nodes
        replace_duplicate_nodes(ngnodes)

def fix_duplicate_nodes(): # [ ]
    fix_node_duplicates()

def random_visibility_keyframes(objects = None, phase_min = 0, phase_max = 75, sustain_min = 5, sustain_max = 100, chance = 6): # [ ]
    # Getting important information:
    end = frame_end()
    # Clearing animation data in preparation for new keyframes:
    for obj in objects:
        show_in_viewport(obj)
        obj.select_set(True)
        bpy.ops.anim.keyframe_clear_v3d()
    # Begin main keyframe generating loop:
    for obj in objects:
        hide_in_viewport(obj)
        hide_in_render(obj)
        obj.keyframe_insert(data_path = "hide_viewport", frame = 0)
        obj.keyframe_insert(data_path = "hide_render", frame = 0)
        chance_num = random.randint(1,10)
        if chance_num > chance:
            count = 0
            while count < end:
                # Begin a phase:
                count += random.randint(phase_min, phase_max)
                if count >= end:
                    break
                else:
                    # Set visibility on:
                    show_in_viewport(obj)
                    show_in_render(obj)
                    obj.keyframe_insert(data_path = "hide_viewport", frame = count)
                    obj.keyframe_insert(data_path = "hide_render", frame = count)
                
                # Sustain a phase:
                count += random.randint(sustain_min, sustain_max)
                if count >= end:
                    break
                else:
                    # Set visibility off:
                    hide_in_viewport(obj)
                    hide_in_render(obj)
                    obj.keyframe_insert(data_path = "hide_viewport", frame = count)
                    obj.keyframe_insert(data_path = "hide_render", frame = count)
#endregion