glitch3d 0.5.0.0 → 0.5.0.1

data/lib/glitch3d/bpy/canvas/lyfe.py

@@ -5,7 +5,7 @@ sys.path.append(os.path.dirname(os.path.dirname(__file__)))
 import helpers
 
 class Lyfe(canvas.Canvas):
-    SIZE = 5
+    SIZE = 4
 
     def render(self):
         self.cubes = helpers.build_composite_object('Cube', self.SIZE-1, 0.5)
@@ -13,7 +13,6 @@ class Lyfe(canvas.Canvas):
           for b in a:
             for c in b:
               c.location += mathutils.Vector((self.SIZE/2, self.SIZE/2, self.SIZE/2))
-        # code.interact(local=dict(globals(), **locals()))
         self.cells = [[[ 0 for i in range(self.SIZE)] for k in range(self.SIZE)] for j in range(self.SIZE)]
         self.next_generation = [[[ 0 for i in range(self.SIZE)] for k in range(self.SIZE)] for j in range(self.SIZE)]
 
@@ -52,7 +51,6 @@ class Lyfe(canvas.Canvas):
                                 x_index = (x + i + self.SIZE) % self.SIZE
                                 y_index = (y + j + self.SIZE) % self.SIZE
                                 z_index = (z + k + self.SIZE) % self.SIZE
-                                # code.interact(local=dict(globals(), **locals()))
                                 if not( x_index == x and y_index == y and z_index == z):
                                     neighbors_alive_count += self.cells[x_index][y_index][z_index]
                     if self.cells[x][y][z] == 1 and neighbors_alive_count > 6:

data/lib/glitch3d/bpy/canvas/metaballs.py

@@ -8,10 +8,13 @@ sys.path.append(os.path.dirname(os.path.dirname(__file__)))
 import helpers
 
 class Metaballs(canvas.Canvas):
+
+  TYPES =  ['BALL', 'CAPSULE', 'PLANE', 'ELLIPSOID', 'CUBE']
+
   def render(self):
-    diameter = 8.0
+    diameter = 4.0
     sz = 2.125 / diameter
-    latitude = 16
+    latitude = 10
     longitude = latitude * 2
     invlatitude = 1.0 / (latitude - 1)
     current_frame = 0
@@ -23,12 +26,13 @@ class Metaballs(canvas.Canvas):
     center = Vector((0.0, 0.0, 0.0))
     baseaxis = Vector((0.0, 1.0, 0.0))
     axis = Vector((0.0, 0.0, 0.0))
-    elemtypes = ['BALL', 'CAPSULE', 'PLANE', 'ELLIPSOID', 'CUBE']
-    mbdata = bpy.data.metaballs.new('SphereData')
+    metaball_type = random.choice(self.TYPES)
+    mbdata = bpy.data.metaballs.new('meta_balls')
     mbdata.render_resolution = 0.075
-    mbdata.resolution = 0.2
-    mbobj = bpy.data.objects.new("Sphere", mbdata)
+    mbdata.resolution = 0.1
+    mbobj = bpy.data.objects.new("meta_bollocks", mbdata)
     bpy.context.scene.objects.link(mbobj)
+    helpers.assign_material(mbobj, helpers.random_material(self.MATERIALS_NAMES))
     for i in range(0, latitude, 1):
         phi = pi * (i + 1) * invlatitude
         pt.z = cos(phi) * diameter
@@ -36,7 +40,7 @@ class Metaballs(canvas.Canvas):
             theta = TWOPI * j / longitude
             pt.y = center.y + sin(phi) * sin(theta) * diameter
             pt.x = center.x + sin(phi) * cos(theta) * diameter
-            mbelm = mbdata.elements.new(type=elemtypes[0])
+            mbelm = mbdata.elements.new(type=metaball_type)
             mbelm.co = (latitude, longitude, 6)
             mbelm.radius = 0.15 + sz * abs(sin(phi)) * 1.85
             mbelm.stiffness = 1.0

data/lib/glitch3d/bpy/canvas/sphere.py

@@ -9,8 +9,9 @@ import helpers
 
 class Sphere(canvas.Canvas):
   def render(self):
-    diameter = 8.0
+    diameter = 4.0
     sz = 2.125 / diameter
+    base_object = helpers.infer_primitive(random.choice(self.PRIMITIVES), location = (100, 100, 100), radius=sz)
     latitude = 16
     longitude = latitude * 2
     invlatitude = 1.0 / (latitude - 1)
@@ -19,11 +20,7 @@ class Sphere(canvas.Canvas):
     jprc = 0.0
     phi = 0.0
     theta = 0.0
-    currframe = 0
-    fcount = 10
-    invfcount = 1.0 / (fcount - 1)
-    frange = bpy.context.scene.frame_end - bpy.context.scene.frame_start
-    fincr = ceil(frange * invfcount)
+    invfcount = 1.0 / (self.NUMBER_OF_FRAMES - 1)
     # Animate center of the sphere.
     center = Vector((0.0, 0.0, 0.0))
     startcenter = Vector((0.0, -4.0, 0.0))
@@ -41,52 +38,40 @@ class Sphere(canvas.Canvas):
     for i in range(0, latitude, 1):
         iprc = i * invlatitude
         phi = pi * (i + 1) * invlatitude
-        sinphi = sin(phi)
-        cosphi = cos(phi)
-        rad = 0.01 + sz * abs(sinphi) * 0.99
-        pt.z = cosphi * diameter
+        rad = 0.01 + sz * abs(sin(phi)) * 0.99
+        pt.z = cos(phi) * diameter
         for j in range(0, longitude, 1):
             jprc = j * invlongitude
             theta = TWOPI * j / longitude
-            sintheta = sin(theta)
-            costheta = cos(theta)
-            pt.y = center.y + sinphi * sintheta * diameter
-            pt.x = center.x + sinphi * costheta * diameter
-            bpy.ops.mesh.primitive_cube_add(location=pt, radius=rad)
-            current = bpy.context.object
-            current.name = 'Cube ({0:0>2d}, {1:0>2d})'.format(i, j)
+            pt.y = center.y + sin(phi) * sin(theta) * diameter
+            pt.x = center.x + sin(phi) * cos(theta) * diameter
+            current = helpers.duplicate_object(base_object)
+            current.location = pt
+            current.name = 'Object ({0:0>2d}, {1:0>2d})'.format(i, j)
             current.data.name = 'Mesh ({0:0>2d}, {1:0>2d})'.format(i, j)
             current.rotation_euler = (0.0, phi, theta)
-            # Append a material.
-            mat = bpy.data.materials.new(name='Material ({0:0>2d}, {1:0>2d})'.format(i, j))
-            mat.diffuse_color = colorsys.hsv_to_rgb(jprc, 1.0 - iprc, 1.0)
-            current.data.materials.append(mat)
-            # Append a bevel modifier to each cube for polish.
-            bpy.ops.object.modifier_add(type='BEVEL')
-            bpy.context.object.modifiers['Bevel'].segments = 2
-            bpy.context.object.modifiers['Bevel'].width = 0.03
-            self.vecrotatex(theta, baseaxis, axis)
-            currframe = bpy.context.scene.frame_start
+            helpers.assign_material(current, helpers.random_material(self.MATERIALS_NAMES))
+            axis = self.vecrotatex(theta, baseaxis)
             currot = startrot
             center = startcenter
-            for f in range(0, fcount, 1):
-                fprc = f / (fcount - 1)
+            for f in range(0, self.NUMBER_OF_FRAMES, 1):
+                fprc = f / (self.NUMBER_OF_FRAMES - 1)
                 osc = abs(sin(TWOPI * fprc))
-                bpy.context.scene.frame_set(currframe)
+                bpy.context.scene.frame_set(f)
                 center = startcenter.lerp(stopcenter, osc)
                 current.location = helpers.rotate_vector(TWOPI * fprc, axis, pt)
                 current.keyframe_insert(data_path='location')
                 currot = startrot.slerp(stoprot, jprc * fprc)
                 current.rotation_euler = currot.to_euler()
                 current.keyframe_insert(data_path='rotation_euler')
-                mat.diffuse_color = colorsys.hsv_to_rgb(jprc, osc, 1.0)
-                mat.keyframe_insert(data_path='diffuse_color')
-                currframe += fincr
 
-  def vecrotatex(self, angle, vin, vout):
-    cosa = cos(angle)
-    sina = sin(angle)
+  # Rotate vector by a given angle from a starting vector and return a new vector
+  # Trigonometry:
+  #  x' = x cos θ − y sin θ
+  #  y' = x sin θ + y cos θ
+  def vecrotatex(self, angle, vin):
+    vout = Vector((0.0, 0.0, 0.0))
     vout.x = vin.x
-    vout.y = cosa * vin.y - sina * vin.z
-    vout.z = cosa * vin.z + sina * vin.y
+    vout.y = cos(angle) * vin.y - sin(angle) * vin.z
+    vout.z = cos(angle) * vin.z + sin(angle) * vin.y
     return vout

data/lib/glitch3d/bpy/canvas/waves.py

@@ -7,49 +7,34 @@ sys.path.append(os.path.dirname(os.path.dirname(__file__)))
 import helpers
 
 class Waves(canvas.Canvas):
+
+  COUNT=5
+
   def render(self):
-    # Number of cubes.
-    count = 16
+    count = self.COUNT
     # Size of grid.
     extents = 8.0
-    # Spacing between cubes.
-    padding = 0.002
-    # Size of each cube.
     # The height of each cube will be animated, so we'll specify the minimum and maximum scale.
-    sz = (extents / count) - padding
+    sz = (extents / count)
+    base_object = helpers.infer_primitive(random.choice(self.PRIMITIVES), location = (100, 100, 100), radius=sz)
+    helpers.assign_material(base_object, helpers.random_material(self.MATERIALS_NAMES))
     minsz = sz * 0.25
     maxsz = sz * extents
-    diffsz = maxsz - minsz
     # To convert abstract grid position within loop to real-world coordinate.
     jprc = 0.0
     kprc = 0.0
     countf = 1.0 / (count - 1)
     diffex = extents * 2
-    # Position of each cube.
     y = 0.0
     x = 0.0
-    # Center of grid.
     centerz = 0.0
     centery = 0.0
     centerx = 0.0
-    # Distances of cube from center.
     # The maximum possible distance is used to normalize the distance.
     rise = 0.0
     run = 0.0
     normdist = 0.0
     maxdist = sqrt(2 * extents * extents)
-    # For animation, track current frame, specify desired number of key frames.
-    currframe = 0
-    fcount = 10
-    invfcount = 1.0 / (fcount - 1)
-    # If the default frame range is 0, then default to 1 .. 150.
-    frange = bpy.context.scene.frame_end - bpy.context.scene.frame_start
-    if frange == 0:
-      bpy.context.scene.frame_end = 150
-      bpy.context.scene.frame_start = 0
-      frange = 150
-    # Number of keyframes per frame.
-    fincr = ceil(frange * invfcount)
     # For generating the wave.
     offset = 0.0
     angle = 0.0
@@ -71,29 +56,18 @@ class Waves(canvas.Canvas):
         # Remap the normalized distance to a range -PI .. PI
         normdist = sqrt(rise + run) / maxdist
         offset = -TWOPI * normdist + pi
-        # Add grid world position to cube local position.
-        bpy.ops.mesh.primitive_cube_add(location=(centerx + x, centery + y, centerz), radius=sz)
-        # Remember and rename the current object being edited.
-        current = bpy.context.object
-        current.name = 'Cube ({0:0>2d}, {1:0>2d})'.format(k, j)
+        current = helpers.duplicate_object(base_object)
+        current.location = (centerx + x, centery + y, centerz)
+        current.name = 'Object ({0:0>2d}, {1:0>2d})'.format(k, j)
         current.data.name = 'Mesh ({0:0>2d}, {1:0>2d})'.format(k, j)
-        # Create a material and add it to the current object.
-        mat = bpy.data.materials.new(name='Material ({0:0>2d}, {1:0>2d})'.format(k, j))
-        mat.diffuse_color = colorsys.hsv_to_rgb(normdist, 0.875, 1.0)
-        current.data.materials.append(mat)
-        # Track the current key frame.
-        currframe = bpy.context.scene.frame_start
-        for f in range(0, fcount, 1):
+        for f in range(0, self.NUMBER_OF_FRAMES, 1):
           # Convert the keyframe into an angle.
-          fprc = f * invfcount
+          fprc = f * 1.0 / (self.NUMBER_OF_FRAMES - 1)
           angle = TWOPI * fprc
           # Set the scene to the current frame.
-          bpy.context.scene.frame_set(currframe)
+          bpy.context.scene.frame_set(f)
           # Change the scale.
           # sin returns a value in the range -1 .. 1. abs changes the range to 0 .. 1.
           # The values are remapped to the desired scale with min + percent * (max - min).
-          current.scale[2] = minsz + abs(sin(offset + angle)) * diffsz
-          # Insert the key frame for the scale property.
-          current.keyframe_insert(data_path='scale', index=2)
-          # Advance by the keyframe increment to the next keyframe.
-          currframe += fincr
+          current.scale.z = minsz + abs(sin(offset + angle)) * (maxsz - minsz)
+          helpers.add_frame([current], ['scale'])

data/lib/glitch3d/bpy/helpers.py

@@ -1,7 +1,6 @@
-import sys, code, random, os, math, bpy, numpy, uuid, mathutils
+import sys, code, random, os, math, bpy, numpy, uuid, mathutils, subprocess
 
 def pry(globs=globals(), locs=locals()):
-    import sys
     code.interact(local=dict(globs, **locs))
     sys.exit("Aborting execution")
 
@@ -38,6 +37,12 @@ def apply_displacement(obj, height_map_folder, strength = 0.2, subdivisions = 2)
     displace.texture = new_texture
     displace.strength = strength
 
+def decimate(obj):
+  modifier = obj.modifiers.new(name='decimate', type='DECIMATE')
+  modifier.decimate_type = 'DISSOLVE'
+  bpy.context.scene.objects.active = obj
+  bpy.ops.object.modifier_apply(modifier="decimate")
+
 def look_at(obj):
     location_camera = CAMERA.matrix_world.to_translation()
     location_object = obj.matrix_world.to_translation()
@@ -61,7 +66,9 @@ def output_name(model_path, index = 0):
 def rand_color_value():
     return random.uniform(0, 255) / 255
 
-def rand_location(boundary):
+def rand_location(boundary, positive = False):
+    if positive:
+      return (random.uniform(0, boundary), random.uniform(0, boundary), random.uniform(0, boundary))
     return (random.uniform(-boundary, boundary), random.uniform(-boundary, boundary), random.uniform(-boundary, boundary))
 
 def rand_rotation():
@@ -102,8 +109,9 @@ def assign_material(obj, material):
         obj.data.materials[0] = material
     return material
 
-def random_material(materials_list):
-    return fetch_material(random.choice(materials_list))
+def random_material(materials_list, blacklist = [ 'Smoke Domain Material' ]):
+    eligible_materials = list(set(materials_list) - set(blacklist))
+    return fetch_material(random.choice(eligible_materials))
 
 # Returns a new Cycles material with default DiffuseBsdf node linked to output
 def create_cycles_material(name = 'object_material_', clean=False):
@@ -368,7 +376,6 @@ def duplicate_object(obj):
     new_object.data = obj.data.copy()
     new_object.animation_data_clear()
     new_object.cycles_visibility.camera = True
-    # assign_material(new_object, obj.data.materials[-1])
     bpy.context.scene.objects.link(new_object)
     return new_object
 
@@ -382,53 +389,58 @@ def random_text(file_path):
     return lines[random.randrange(len(lines))]
 
 def add_faces(obj):
-    vertices = []
-    for v in obj.data.vertices:
-        vertices.append(v.co)
-    new_obj = create_mesh(obj.name, vertices, random_faces(vertices), obj.location)
-    bpy.data.objects.remove(obj, do_unlink=True)
-    return new_obj
+  vertices = []
+  for v in obj.data.vertices:
+      vertices.append(v.co)
+  new_obj = create_mesh(obj.name, vertices, random_faces(vertices), obj.location)
+  bpy.data.objects.remove(obj, do_unlink=True)
+  return new_obj
 
 def random_faces(vertices):
-    faces = []
-    for i in range(int(len(vertices)/100)):
-        target = vertices[random.choice((range(len(vertices))))]
-        if (random.randint(0, 1) == 1):
-            faces.append(((target + 2), int(target / 6), int(target - 1), target))
-        else:
-            faces.append((int(target / 6), int(target - 1), target))
-    return faces
+  faces = []
+  for i in range(int(len(vertices)/100)):
+      target = vertices[random.choice((range(len(vertices))))]
+      if (random.randint(0, 1) == 1):
+          faces.append(((target + 2), int(target / 6), int(target - 1), target))
+      else:
+          faces.append((int(target / 6), int(target - 1), target))
+  return faces
 
 ############
 # <geometry>
 ############
 
 def center(obj):
-    bpy.context.scene.objects.active = obj
-    bpy.ops.object.transform_apply(location=False, rotation=True, scale=True)
-    bpy.ops.object.origin_set(type="ORIGIN_CENTER_OF_MASS")
-    local_bounding_box_center = 0.125 * sum((mathutils.Vector(b) for b in obj.bound_box), mathutils.Vector())
-    obj.location -= local_bounding_box_center
-    return obj
-
-def resize(obj, pace = 0.05, minimum = 3.0, maximum = 8.0):
-    print("Resizing: " + obj.name)
-    assert minimum < maximum
-    obj.scale = (1,1,1)
-    scale_multiplier =  max(obj.dimensions) / (maximum - minimum)
-    if max(obj.dimensions) > maximum:
-      init_scale = obj.scale
-      obj.scale = init_scale - init_scale * scale_multiplier # downscale
-      if obj.scale.x < 0:
-        obj.scale = init_scale * scale_multiplier
-    else:
-      obj.scale = obj.scale + obj.scale * scale_multiplier # upscale
+  bpy.context.scene.objects.active = obj
+  bpy.ops.object.transform_apply(location=False, rotation=True, scale=True)
+  bpy.ops.object.origin_set(type="ORIGIN_CENTER_OF_MASS")
+  local_bounding_box_center = 0.125 * sum((mathutils.Vector(b) for b in obj.bound_box), mathutils.Vector())
+  obj.location -= local_bounding_box_center
+  obj.location = (0, 0, 0)
+  return obj
+
+def resize(obj, minimum = 4.0, maximum = 8.0):
+  print("Resizing: " + obj.name)
+  init_scale = obj.scale
+  assert minimum < maximum
+  scale_multiplier =init_scale.x / (max(obj.dimensions) / (maximum - minimum))
+  if max(obj.dimensions) > maximum:
+    print("Downscaling by: " + str(scale_multiplier))
+    while max(obj.dimensions) > maximum:
+      obj.scale = init_scale + mathutils.Vector((- scale_multiplier, - scale_multiplier, - scale_multiplier))
+      bpy.ops.wm.redraw_timer(type='DRAW', iterations=1)
+  elif max(obj.dimensions) < minimum:
+    print("Upscaling by: " + str(scale_multiplier))
+    while max(obj.dimensions) < minimum:
+      obj.scale = obj.scale + mathutils.Vector((scale_multiplier, scale_multiplier, scale_multiplier))
+      bpy.ops.wm.redraw_timer(type='DRAW', iterations=1)
 
 def extrude(obj, thickness=0.05):
     bpy.context.scene.objects.active = obj
     bpy.ops.object.mode_set(mode='EDIT')
     bpy.ops.mesh.extrude_region_move(MESH_OT_extrude_region={"mirror":False}, TRANSFORM_OT_translate={"value":(thickness, 0, 0), "constraint_orientation":'GLOBAL', "mirror":True, "proportional":'DISABLED', "proportional_edit_falloff":'SMOOTH', "proportional_size":1, "snap":False, "snap_target":'CLOSEST', "snap_point":(0, 0, 0), "snap_align":False, "snap_normal":(0, 0, 0), "gpencil_strokes":False, "texture_space":False, "remove_on_cancel":False, "release_confirm":False, "use_accurate":False})
     bpy.ops.object.mode_set(mode='OBJECT')
+    bpy.ops.object.select_all(action='DESELECT')
 
 def create_line(name, point_list, color, thickness = 0.002, location = (0,0,0)):
     line_data = bpy.data.curves.new(name=name,type='CURVE')
@@ -468,7 +480,7 @@ def pitched_array(minimum, maximum, pitch):
 
 def create_mesh(name, verts, faces, location, edges=[]):
     mesh_data = bpy.data.meshes.new("mesh_data")
-    faces = faces if len(faces) == 0 else random_faces(verts)
+    faces = faces if (len(faces) == 0 or len(faces) > 0) else random_faces(verts)
     mesh_data.from_pydata(verts, edges, faces)
     mesh_data.update()
     obj = bpy.data.objects.new(name, mesh_data)
@@ -520,4 +532,22 @@ def rotate_vector(angle, axis, vin):
 
 #############
 # </geometry>
+#############
+
+
+#############
+# <physics>
+#############
+
+def add_rigid_body(objs=[], type = 'ACTIVE', mass=2.0):
+  for obj in objs:
+    obj.select = True
+  bpy.ops.rigidbody.objects_add(type='ACTIVE')
+  for obj in objs:
+    if type == 'ACTIVE':
+      obj.rigid_body.mass = mass
+    obj.rigid_body.collision_shape = 'MESH'
+
+#############
+# </physics>
 #############

data/lib/glitch3d/bpy/main.py

@@ -1,27 +1,30 @@
 # Rendering script
 # Run by calling the blender executable with -b -P <script_name>
 # Use `pry()` to pry into the script
-import argparse, random, math, os, code
+import sys, argparse, random, math, os, code, requests
 
 def get_args():
-    parser = argparse.ArgumentParser()
-    _, all_arguments = parser.parse_known_args()
-    double_dash_index = all_arguments.index('--')
-    script_args = all_arguments[double_dash_index + 1: ]
-    parser.add_argument('-f', '--file', help="obj file to render")
-    parser.add_argument('-n', '--shots-number', help="number of shots desired")
-    parser.add_argument('-m', '--mode', help="quality mode: low | high")
-    parser.add_argument('-p', '--path', help="root path of assets")
-    parser.add_argument('-a', '--animate', help="render animation") # bool
-    parser.add_argument('-frames', '--frames', help="number of frames") # int
-    parser.add_argument('-normals', '--normals', help="normal render") # bool
-    parser.add_argument('-d', '--debug', help="render blank scene with subject for testing purposes") # bool
-    parser.add_argument('-width', '--width', help="width of render") # int
-    parser.add_argument('-eight', '--eight', help="height of render") # int
-    parser.add_argument('-assets', '--assets', help="user assets path") # string
-    parser.add_argument('-canvas', '--canvas', help="selection of canvas modules by name") # string
-    parsed_script_args, _ = parser.parse_known_args(script_args)
-    return parsed_script_args
+  parser = argparse.ArgumentParser()
+  _, all_arguments = parser.parse_known_args()
+  double_dash_index = all_arguments.index('--')
+  script_args = all_arguments[double_dash_index + 1: ]
+  parser.add_argument('-f', '--file', help="obj file to render")
+  parser.add_argument('-n', '--shots-number', help="number of shots desired")
+  parser.add_argument('-m', '--mode', help="quality mode: low | high")
+  parser.add_argument('-p', '--path', help="root path of gem assets")
+  parser.add_argument('-a', '--animate', help="render animation") # bool
+  parser.add_argument('-frames', '--frames', help="number of frames") # int
+  parser.add_argument('-normals', '--normals', help="normal render") # bool
+  parser.add_argument('-d', '--debug', help="render blank scene with subject for testing purposes") # bool
+  parser.add_argument('-width', '--width', help="width of render") # int
+  parser.add_argument('-eight', '--eight', help="height of render") # int
+  parser.add_argument('-assets', '--assets', help="user assets path") # string
+  parser.add_argument('-canvas', '--canvas', help="selection of canvas modules by name") # string
+  parser.add_argument('-post', '--post-process', help="post-processing") # bool
+  parser.add_argument('-webhook', '--webhook', help="webhook url") # string
+  parser.add_argument('-seed', '--seed', help="random seed") # int
+  parsed_script_args, _ = parser.parse_known_args(script_args)
+  return parsed_script_args
 
 args = get_args()
 file = args.file
@@ -32,183 +35,206 @@ animate = (args.animate == 'True')
 shots_number = int(args.shots_number)
 width = int(args.width)
 height = int(args.eight)
+post_process = (args.post_process == 'True')
+assets = args.assets
+webhook = args.webhook
 
 # TODO: add proper args validation cycle
 #####################################
 #####################################
 #####################################
 
-NUMBER_OF_FRAMES = int(args.frames)
-NORMALS_RENDERING = (args.normals == 'True')
-
-# Randomize module usage at runtime or pick selection from arguments
-canvas_path = os.path.dirname(__file__) + '/canvas'
-MODULES_AVAILABLE = args.canvas.split(",") if args.canvas else [ f[0:-3] for f in os.listdir(canvas_path) if os.path.isfile(os.path.join(canvas_path, f)) and f != 'canvas.py']
-MODULES_ENABLED = MODULES_AVAILABLE if debug or args.canvas else random.sample(MODULES_AVAILABLE, int(random.uniform(0, len(MODULES_AVAILABLE)) + 1))
-print("modules enabled: " + str(list(MODULES_ENABLED)))
-
-FIXTURES_FOLDER_PATH = args.assets if args.assets else path + '/../fixtures/'
-TEXTURE_FOLDER_PATH = FIXTURES_FOLDER_PATH + 'textures/'
-MODELS_FOLDER_PATH = FIXTURES_FOLDER_PATH + 'models/'
-HEIGHT_MAP_FOLDER_PATH = FIXTURES_FOLDER_PATH + 'height_maps/'
-SCENE_NAME = "glitch3d"
-REFLECTOR_SCALE = random.uniform(9, 10)
-REFLECTOR_STRENGTH = random.uniform(12, 15)
-REFLECTOR_LOCATION_PADDING = random.uniform(10, 12)
-REPLACE_TARGET = str(random.uniform(0, 9))
-REPLACEMENT = str(random.uniform(0, 9))
-OSL_ENABLED = True
-ORIGIN  = (0,0,2)
-CANVAS_BOUNDARY = 6
-SCATTER_INTENSITY = 0.015
-ABSORPTION_INTENSITY = 0.25
-DISPLAY_SCALE = (2, 2, 2)
-PRIMITIVES = ['Pyramid', 'Cube']
-YELLOW = (1, 0.7, 0.1, 1)
-GREY = (0.2, 0.2, 0.2 ,1)
-BLUE = (0.1, 0.1, 0.8, 0.4)
-PINK = (0.8, 0.2, 0.7, 1.0)
-RENDER_OUTPUT_PATHS = []
-FIXED_CAMERA = False
-FUNCTIONS = {
-    (lambda x: math.sin(x) * math.cos(20*x)): 4,
-    (lambda x: math.sin(x) * math.sin(20*x)): 3,
-    (lambda x: INITIAL_CAMERA_LOCATION[2]): 2,
-    (lambda x: x) : 2,
-    math.sin : 1,
-    math.cos : 1,
-    (lambda x: 0.5 * math.sin(0.5*x) * math.cos(x)) : 1,
-    (lambda x: random.uniform(1, 10) * math.cos(x) ** 3) : 1,
-    (lambda x: random.uniform(1, 10)) : 1,
-    (lambda x: random.uniform(1, 2) + random.uniform(0.75, 3) * math.sin(random.uniform(0.1, 1)*x) + math.cos(random.uniform(0.75, 5)*x)) : 1,
-    (lambda x: math.sin(math.pi*x) + x + 3 * math.pi) : 1,
-    (lambda x: x**3 + math.cos(x/2)) : 2,
-    (lambda x: random.uniform(1, 10) * math.sin(x)): 3
-}
-
-import importlib.util, os, ntpath, bpy, datetime, math, random, mathutils, random, uuid, sys, logging, string, colorsys, code, numpy
-from subprocess import call
-
-def load_file(file_path):
-    # load and define function and vars in global namespace, yolo
-    exec(open(file_path).read(), globals())
-
-def load_module_path(file_path):
-    print("loading module " + file_path)
-    sys.path.append(os.path.dirname(os.path.expanduser(file_path)))
-
-# Create directory for renders
-directory = os.path.dirname('./renders')
-if not os.path.exists(directory):
-    os.makedirs(directory)
-
-load_file(os.path.join(path + '/glitch3d/bpy/helpers.py'))
-load_file(os.path.join(path + '/glitch3d/bpy/render_settings.py'))
-load_file(os.path.join(path + '/glitch3d/bpy/lighting.py'))
-
-# Create groups
-for s in ['texts', 'lines', 'displays', 'reflectors', 'neons']:
-    bpy.data.groups.new(s)
-for primitive in PRIMITIVES:
-    bpy.data.groups.new(primitive.lower().title())
-
-FISHEYE = True
-COLORS = rand_color_palette(5)
-CAMERA_OFFSET = 5
-INITIAL_CAMERA_LOCATION = (CAMERA_OFFSET, CAMERA_OFFSET, random.uniform(0, 8))
-TEXT_FILE_PATH = FIXTURES_FOLDER_PATH + 'text/strings.txt'
-
-print("Loading materials...")
-MATERIALS_NAMES = []
-load_osl_materials(FIXTURES_FOLDER_PATH + 'osl-shaders/')
-for mat in bpy.data.materials: # merge base scene materials + osl shaders
-    if mat.name != 'emission':
-      MATERIALS_NAMES.append(mat.name)
-print("Detected " + str(len(MATERIALS_NAMES)) + " materials in base scene: " + str(MATERIALS_NAMES))
-
-# Scene
-new_scene = bpy.data.scenes[SCENE_NAME]
-bpy.context.screen.scene = new_scene
-SCENE = new_scene
-SCENE.render.engine = 'CYCLES'
-
-flush_objects()
-
-camera_data = bpy.data.cameras.new(name = 'CAMERA')
-bpy.data.objects.new('CAMERA', object_data=camera_data)
-CAMERA = bpy.data.objects['CAMERA']
-new_scene.objects.link(CAMERA)
-SCENE.camera = CAMERA
-CAMERA.location = INITIAL_CAMERA_LOCATION
-SCENE.frame_start = 0
-SCENE.frame_end = NUMBER_OF_FRAMES
-
-if FISHEYE:
-    CAMERA.data.type = 'PANO'
-    CAMERA.data.cycles.panorama_type = 'FISHEYE_EQUISOLID'
-    CAMERA.data.cycles.fisheye_lens = 12
-    CAMERA.data.cycles.fisheye_fov = 2.5
-    CAMERA.data.sensor_width = 20
-    CAMERA.data.sensor_height = 20
-
-# Load model
-model_path = os.path.join(file)
-bpy.ops.import_scene.obj(filepath = model_path, use_edges=True)
-SUBJECT = bpy.data.objects['0_glitch3d_' + ntpath.basename(file).replace("_glitched.obj", '')]
-SUBJECT.select = True
-center(SUBJECT)
-SUBJECT.location = ORIGIN
-let_there_be_light(SCENE)
-random.shuffle(list(MODULES_ENABLED))
-
-for module in MODULES_ENABLED:
-    load_module_path(os.path.join(path + '/glitch3d/bpy/canvas', module + '.py'))
-    mod = __import__(module)
-    new_canvas = eval("mod." + module[:1].upper() + module[1:] + "(locals())")
-    new_canvas.render()
-
-render_settings(animate, mode, NORMALS_RENDERING, width, height)
-print('Rendering images with resolution: ' + str(SCENE.render.resolution_x) + ' x ' + str(SCENE.render.resolution_y))
-
-CAMERA_PATH = camera_path(NUMBER_OF_FRAMES)
-
-for frame in range(0, NUMBER_OF_FRAMES):
-    bpy.context.scene.frame_set(frame)
-    bpy.context.scene.camera.location = CAMERA_PATH[frame]
-    SUBJECT.rotation_euler.z += math.radians(1)
-    look_at(SUBJECT)
-    add_frame([bpy.context.scene.camera], ["location", "rotation_euler"])
-
-if animate:
-    print('ANIMATION RENDERING BEGIN')
-    output_path = output_name(model_path)
-    print('AVI file -> ' + output_path)
-    shoot(output_path)
-else:
-    print('STILL RENDERING BEGIN')
-    for index in range(0, shots_number):
-        frame_cursor = int(index * (bpy.context.scene.frame_end / shots_number))
-        print('>> FRAME #' + str(frame_cursor))
-        bpy.context.scene.frame_set(int(bpy.context.scene.frame_end/(index+1)))
-        SUBJECT.rotation_euler.z = math.radians(index * (360.0 / shots_number))
-        output_path = output_name(model_path, index)
-        print("-------------------------- " + str(index) + " --------------------------")
-        print("PNG file -> " + output_path)
-        shoot(output_path)
-
-# Save scene as .blend file
-bpy.ops.wm.save_as_mainfile(filepath=output_name(model_path) + '.blend')
-
-print("Files rendered with " + str(NUMBER_OF_FRAMES) + " frames in simulation:")
-for p in RENDER_OUTPUT_PATHS:
-    print(p)
-
-if animate == False and debug == False:
-    call(["python3", os.path.join(path + '/glitch3d/bpy/post-processing/optimize.py')] + [ str(bpy.context.scene.render.resolution_x), str(bpy.context.scene.render.resolution_y) ] + RENDER_OUTPUT_PATHS)
-    call(["python3", os.path.join(path + '/glitch3d/bpy/post-processing/palette.py')] + list(map(str, list(map(tuple, COLORS)))) + [os.path.join(path + '/../fixtures/fonts/helvetica_neue.ttf')])
-    if shots_number > 1:
-      call(["python3", os.path.join(path + '/glitch3d/bpy/post-processing/average.py')] + RENDER_OUTPUT_PATHS)
-    if shots_number > 10:
-        call(["python3", os.path.join(path + '/glitch3d/bpy/post-processing/mosaic.py')])
-print('FINISHED ¯\_(ツ)_/¯')
-sys.exit()
+try:
+  NUMBER_OF_FRAMES = int(args.frames)
+  NORMALS_RENDERING = (args.normals == 'True')
+  random.seed = args.seed
+
+  # Randomize module usage at runtime or pick selection from arguments
+  canvas_path = os.path.dirname(__file__) + '/canvas'
+  MODULES_AVAILABLE = args.canvas.split(",") if args.canvas else [ f[0:-3] for f in os.listdir(canvas_path) if os.path.isfile(os.path.join(canvas_path, f)) and f != 'canvas.py' and f != 'empty.py']
+  MODULES_ENABLED = MODULES_AVAILABLE if debug or args.canvas else random.sample(MODULES_AVAILABLE, int(random.uniform(0, len(MODULES_AVAILABLE)) + 1))
+  print("modules enabled: " + str(list(MODULES_ENABLED)))
+
+  FIXTURES_FOLDER_PATH = assets if assets else path + '/../fixtures/'
+  TEXTURE_FOLDER_PATH = FIXTURES_FOLDER_PATH + 'textures/'
+  MODELS_FOLDER_PATH = FIXTURES_FOLDER_PATH + 'models/'
+  HEIGHT_MAP_FOLDER_PATH = FIXTURES_FOLDER_PATH + 'height_maps/'
+  FONT_FOLDER_PATH = FIXTURES_FOLDER_PATH + 'fonts/'
+  SCENE_NAME = "glitch3d"
+  REFLECTOR_SCALE = random.uniform(9, 10)
+  REFLECTOR_STRENGTH = random.uniform(12, 15)
+  REFLECTOR_LOCATION_PADDING = random.uniform(10, 12)
+  REPLACE_TARGET = str(random.uniform(0, 9))
+  REPLACEMENT = str(random.uniform(0, 9))
+  OSL_ENABLED = True
+  ORIGIN  = (0,0,2)
+  CANVAS_BOUNDARY = 6
+  SCATTER_INTENSITY = 0.015
+  ABSORPTION_INTENSITY = 0.25
+  DISPLAY_SCALE = (2, 2, 2)
+  PRIMITIVES = ['Pyramid', 'Cube']
+  YELLOW = (1, 0.7, 0.1, 1)
+  GREY = (0.2, 0.2, 0.2 ,1)
+  BLUE = (0.1, 0.1, 0.8, 0.4)
+  PINK = (0.8, 0.2, 0.7, 1.0)
+  RENDER_OUTPUT_PATHS = []
+  FIXED_CAMERA = False
+  FUNCTIONS = {
+      (lambda x: math.sin(x) * math.cos(20*x)): 4,
+      (lambda x: math.sin(x) * math.sin(20*x)): 3,
+      (lambda x: INITIAL_CAMERA_LOCATION[2]): 2,
+      (lambda x: x) : 2,
+      math.sin : 1,
+      math.cos : 1,
+      (lambda x: 0.5 * math.sin(0.5*x) * math.cos(x)) : 1,
+      (lambda x: random.uniform(1, 10) * math.cos(x) ** 3) : 1,
+      (lambda x: random.uniform(1, 10)) : 1,
+      (lambda x: random.uniform(1, 2) + random.uniform(0.75, 3) * math.sin(random.uniform(0.1, 1)*x) + math.cos(random.uniform(0.75, 5)*x)) : 1,
+      (lambda x: math.sin(math.pi*x) + x + 3 * math.pi) : 1,
+      (lambda x: x**3 + math.cos(x/2)) : 2,
+      (lambda x: random.uniform(1, 10) * math.sin(x)): 3
+  }
+
+  import importlib.util, os, ntpath, bpy, datetime, math, random, mathutils, random, sys, logging, string, colorsys, code, numpy
+  from subprocess import call
+
+  def load_file(file_path):
+      # load and define function and vars in global namespace, yolo
+      exec(open(file_path).read(), globals())
+
+  def load_module_path(file_path):
+      print("loading module " + file_path)
+      sys.path.append(os.path.dirname(os.path.expanduser(file_path)))
+
+  sys.path.append(os.environ['PYTHON_MODULES_PATH'])
+
+  # Create directory for renders
+  directory = os.path.dirname('./renders')
+  if not os.path.exists(directory):
+      os.makedirs(directory)
+
+  load_file(os.path.join(path + '/glitch3d/bpy/helpers.py'))
+  load_file(os.path.join(path + '/glitch3d/bpy/render_settings.py'))
+  load_file(os.path.join(path + '/glitch3d/bpy/lighting.py'))
+
+  # Create groups
+  for s in ['texts', 'lines', 'displays', 'reflectors', 'neons']:
+      bpy.data.groups.new(s)
+  for primitive in PRIMITIVES:
+      bpy.data.groups.new(primitive.lower().title())
+
+  FISHEYE = random.sample([True, False], 1)
+  COLORS = rand_color_palette(5)
+  CAMERA_OFFSET = 5
+  INITIAL_CAMERA_LOCATION = (CAMERA_OFFSET, CAMERA_OFFSET, random.uniform(0, 8))
+  TEXT_FILE_PATH = FIXTURES_FOLDER_PATH + 'texts/strings.txt'
+
+  print("Loading materials...")
+  MATERIALS_NAMES = []
+  load_osl_materials(FIXTURES_FOLDER_PATH + 'osl_shaders/')
+  for mat in bpy.data.materials: # merge base scene materials + osl shaders
+      if mat.name != 'emission':
+        MATERIALS_NAMES.append(mat.name)
+  print("Detected " + str(len(MATERIALS_NAMES)) + " materials in base scene: " + str(MATERIALS_NAMES))
+
+  # Scene
+  new_scene = bpy.data.scenes[SCENE_NAME]
+  bpy.context.screen.scene = new_scene
+  SCENE = new_scene
+  SCENE.render.engine = 'CYCLES'
+
+  flush_objects()
+
+  camera_data = bpy.data.cameras.new(name = 'CAMERA')
+  bpy.data.objects.new('CAMERA', object_data=camera_data)
+  CAMERA = bpy.data.objects['CAMERA']
+  new_scene.objects.link(CAMERA)
+  SCENE.camera = CAMERA
+  CAMERA.location = INITIAL_CAMERA_LOCATION
+  SCENE.frame_start = 0
+  SCENE.frame_end = NUMBER_OF_FRAMES
+
+  if FISHEYE:
+      CAMERA.data.type = 'PANO'
+      CAMERA.data.cycles.panorama_type = 'FISHEYE_EQUISOLID'
+      CAMERA.data.cycles.fisheye_lens = 12
+      CAMERA.data.cycles.fisheye_fov = 2.5
+      CAMERA.data.sensor_width = 20
+      CAMERA.data.sensor_height = 20
+
+  #####################################
+  #####################################
+  #####################################
+
+  # Load model
+  model_path = os.path.join(file)
+  bpy.ops.import_scene.obj(filepath = model_path, use_edges=True)
+  SUBJECT_NAME = '0_glitch3d_' + ntpath.basename(file).replace("_glitched.obj", '')
+  SUBJECT = bpy.data.objects[SUBJECT_NAME]
+  SUBJECT.select = True
+  center(SUBJECT)
+  SUBJECT.location = ORIGIN
+  let_there_be_light(SCENE)
+  random.shuffle(list(MODULES_ENABLED))
+
+  for module in MODULES_ENABLED:
+      load_module_path(os.path.join(path + '/glitch3d/bpy/canvas', module + '.py'))
+      mod = __import__(module)
+      new_canvas = eval("mod." + module[:1].upper() + module[1:] + "(locals())")
+      new_canvas.render()
+
+  render_settings(animate, mode, NORMALS_RENDERING, width, height, debug)
+  print('Rendering images with resolution: ' + str(SCENE.render.resolution_x) + ' x ' + str(SCENE.render.resolution_y))
+
+  if bpy.context.scene.rigidbody_world:
+    bpy.ops.rigidbody.bake_to_keyframes(frame_start=0, frame_end=NUMBER_OF_FRAMES)
+
+  CAMERA_PATH = camera_path(NUMBER_OF_FRAMES)
+
+  for frame in range(0, NUMBER_OF_FRAMES):
+      bpy.context.scene.frame_set(frame)
+      bpy.context.scene.camera.location = CAMERA_PATH[frame]
+      SUBJECT.rotation_euler.z += math.radians(1)
+      look_at(SUBJECT)
+      add_frame([bpy.context.scene.camera], ["location", "rotation_euler"])
+
+  if animate:
+      print('ANIMATION RENDERING BEGIN')
+      output_path = output_name(model_path)
+      print('AVI file -> ' + output_path)
+      shoot(output_path)
+  else:
+      print('STILL RENDERING BEGIN')
+      for index in range(0, shots_number):
+          frame_cursor = int(index * (bpy.context.scene.frame_end / shots_number))
+          print('>> FRAME #' + str(frame_cursor))
+          bpy.context.scene.frame_set(int(bpy.context.scene.frame_end/(index+1)))
+          SUBJECT.rotation_euler.z = math.radians(index * (360.0 / shots_number))
+          output_path = output_name(model_path, index)
+          print("-------------------------- " + str(index) + " --------------------------")
+          print("PNG file -> " + output_path)
+          shoot(output_path)
+
+  # Save scene as .blend file
+  bpy.ops.wm.save_as_mainfile(filepath=output_name(model_path) + '.blend')
+
+  print("Files rendered with " + str(NUMBER_OF_FRAMES) + " frames in simulation:")
+  for p in RENDER_OUTPUT_PATHS:
+      print(p)
+
+  if post_process:
+      load_file(os.path.join(path + '/glitch3d/bpy/post-processing/optimize.py'))
+      if shots_number > 1:
+        load_file(os.path.join(path + '/glitch3d/bpy/post-processing/average.py'))
+        if shots_number > 10:
+          load_file(os.path.join(path + '/glitch3d/bpy/post-processing/mosaic.py'))
+      load_file(os.path.join(path + '/glitch3d/bpy/post-processing/palette.py'))
+  print('FINISHED ¯\_(ツ)_/¯ with seed: ' + random.seed)
+  sys.exit(0)
+
+except Exception as e:
+  if webhook:
+    requests.post(webhook, data={'error': str(e)})
+  if debug:
+    raise e # See error
+  sys.exit(1) # Just return 1 error code in production