glitch3d 0.2.2.3 → 0.2.2.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b4f2f6d21ae96e8105a1c6da16f6e1fb2838f1d9
-  data.tar.gz: d9860cd506ad2b7c87ea43f3da5527a0282402c1
+  metadata.gz: a15b6ba339b081828a44dfb59587d73745cecfbc
+  data.tar.gz: 4b7d71946ca52bf70a562a9ec457b9a72cbdded8
 SHA512:
-  metadata.gz: d980c45b765663cd5aa61736b6f79b82b9d75993efec48806e668e800077ab41ec513a4b99ee2b6be7d3a4d21b6df0d6c33bc803992995e24e4b23084e685c7c
-  data.tar.gz: 1db6e37de5e965a3ea6ff0526c4bdfb0be99d1c7782f39668c8c9ea876985ff02ded591c2ec76f5cf3378e0d76e7cbc0065c376b914c1e47e70546331abef6e8
+  metadata.gz: c5c5fd02a892349daf3b9fa218d9782a79804e1b8feb26d92a56903bb4a821d2aaef940d5c304ed35df34adcca3fde11708898c37f99b71b8a277cc5b77402a5
+  data.tar.gz: 6fa00d4f1fd9ada772c01a6a145e42348ca23717c4497c74539d3d9766895284240acc52bdb6768316d743a9e445ea40e40c51eb48fd3471a30bfcf5ebec3aa7

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

@@ -0,0 +1,73 @@
+# Load props
+bpy.ops.import_scene.obj(filepath = os.path.join(FIXTURES_FOLDER_PATH + 'm4a1.obj'), use_edges=True)
+m4a1 = bpy.data.objects['m4a1']
+m4a1.location = rand_location()
+m4a1.scale = (0.5, 0.5, 0.5)
+props.append(m4a1)
+
+# Add props
+rand_primitive = random.choice(PRIMITIVES)
+build_composite_object(rand_primitive, 4, 1)
+
+# Set up virtual displays
+bpy.ops.mesh.primitive_grid_add(x_subdivisions=100, y_subdivisions=100, location=(0, 6, 2))
+display1 = bpy.data.objects['Grid']
+bpy.ops.mesh.primitive_grid_add(x_subdivisions=100, y_subdivisions=100, location=(6, 0, 2))
+display2 = bpy.data.objects['Grid.001']
+
+bpy.data.groups.new('Displays')
+bpy.data.groups['Displays'].objects.link(display1)
+bpy.data.groups['Displays'].objects.link(display2)
+
+display1.rotation_euler.x += math.radians(90)
+display1.rotation_euler.z -= math.radians(90)
+display2.rotation_euler.x += math.radians(90)
+display2.rotation_euler.y += math.radians(90)
+display2.rotation_euler.z += math.radians(120)
+
+for display in bpy.data.groups['Displays'].objects:
+    display.rotation_euler.x += math.radians(90)
+    display.scale = DISPLAY_SCALE
+    texture_object(display)
+    make_texture_object_transparent(display)
+    unwrap_model(display)
+    glitch(display)
+
+glitch(m4a1)
+make_object_gradient_fabulous(m4a1, rand_color(), rand_color())
+
+# Make floor
+bpy.ops.mesh.primitive_plane_add(location=(0, 0, -2))
+floor = last_added_object('PLANE')
+bpy.data.groups['Plane'].objects.link(floor)
+floor.scale = (20,20,20)
+subdivide(floor, 8)
+displace(floor)
+texture_object(floor)
+
+OCEAN = add_ocean(10, 20)
+
+# Create lines as backdrop
+bpy.data.groups.new('Lines')
+for j in range(0,20):
+    for i in range(0, 20):
+        new_line = create_line('line' + str(uuid.uuid1()), series(30), 0.003, (j, -10, 2))
+        new_line.location.z += i / 3
+
+# Add flying letters, lmao
+for index in range(1, len(WORDS)):
+    new_object = spawn_text()
+    props.append(new_object)
+    text_scale = random.uniform(0.75, 3)
+    make_object_glossy(new_object, rand_color(), 0.0)
+    new_object.scale = (text_scale, text_scale, text_scale)
+    new_object.location = rand_location()
+    # pivot text to make it readable by camera
+    new_object.rotation_euler.x += math.radians(90)
+    new_object.rotation_euler.z += math.radians(90)
+
+for plane in bpy.data.groups['Plane'].objects:
+    unwrap_model(plane)
+
+for obj in WIREFRAMES:
+    wireframize(obj)

data/lib/glitch3d/bpy/helpers.py

@@ -1,29 +1,18 @@
-import bpy
-import argparse
-import datetime
-import bmesh
-import random
-import code
-import math
-import mathutils
-import random
-import uuid
-import sys
-import logging
-import string
-import colorsys
-import numpy
-
-REFLECTOR_SCALE = random.uniform(4, 6)
-REFLECTOR_STRENGTH = random.uniform(8, 12)
-REFLECTOR_LOCATION_PADDING = random.uniform(10, 12)
-WIREFRAME_THICKNESS = random.uniform(0.008, 0.01)
-DISPLACEMENT_AMPLITUDE = random.uniform(0.06, 0.08)
-REPLACE_TARGET = '6'
-REPLACEMENT = '2'
-ORIGIN  = (0,0,0)
-NUMBER_OF_FRAMES = 100
+# DISCLAIMER: all of this could be done in a much more intelligent way (with more Python knowledge)
+# This is just what works for now for the needs of my current project
 
+REFLECTOR_SCALE = random.uniform(5, 8)
+REFLECTOR_STRENGTH = random.uniform(10, 15)
+REFLECTOR_LOCATION_PADDING = random.uniform(10, 12)
+WIREFRAME_THICKNESS = random.uniform(0.006, 0.02)
+DISPLACEMENT_AMPLITUDE = random.uniform(0.02, 0.1)
+REPLACE_TARGET = str(random.uniform(0, 9))
+REPLACEMENT = str(random.uniform(0, 9))
+ORIGIN  = (0,0,2)
+NUMBER_OF_FRAMES = 400
+SCATTER_INTENSITY = 0.015
+ABSORPTION_INTENSITY = 0.25
+DISPLAY_SCALE = (2, 2, 2)
 PRIMITIVES = ['PYRAMID', 'CUBE']
 props = []
 YELLOW = (1, 0.7, 0.1, 1)
@@ -32,39 +21,40 @@ BLUE = (0.1, 0.1, 0.8, 1)
 PINK = (0.8, 0.2, 0.7, 1.0)
 WORDS = string.ascii_lowercase
 WIREFRAMES = []
-
-context = bpy.context
+VORONOIED = []
 
 def debug():
     code.interact(local=dict(globals(), **locals()))
     sys.exit("Aborting execution")
 
 # Helper methods
-def look_at(camera_object, point):
-    location_camera = camera_object.matrix_world.to_translation()
-    location_point = point.matrix_world.to_translation()
-    direction = location_point - location_camera
+def look_at(object):
+    location_camera = CAMERA.matrix_world.to_translation()
+    location_object = object.matrix_world.to_translation()
+    direction = location_object - location_camera
     rot_quat = direction.to_track_quat('-Z', 'Y')
-    camera_object.rotation_euler = rot_quat.to_euler()
+    CAMERA.rotation_euler = rot_quat.to_euler()
 
 def empty_materials():
     for material in bpy.data.materials.keys():
         bpy.data.materials.remove(object.data.materials[material])
 
-def shoot(animate, camera, model_object, filepath):
+def shoot(model_object, filepath):
     directory = os.path.dirname('./renders')
     if not os.path.exists(directory):
       os.makedirs(directory)
-    look_at(camera, model_object)
-    print('Camera now at location: ' + camera_location_string(camera) + ' / rotation: ' + camera_rotation_string(camera))
+    look_at(model_object)
+    print('Camera now at location: ' + camera_location_string(CAMERA) + ' / rotation: ' + camera_rotation_string(CAMERA))
     bpy.context.scene.render.filepath = filepath
     if animate:
-        bpy.context.scene.render.filepath = './renders/animation-' + str(uuid.uuid1()) + '/'
         return bpy.ops.render.render(animation=animate)
     bpy.ops.render.render(write_still=True)
 
 def output_name(index, model_path):
-    return './renders/' + os.path.splitext(model_path)[0].split('/')[-1] + '_' + str(index) + '_' + str(datetime.date.today()) + '_' + str(mode) + '.png'
+    if animate == True:
+        return './renders/' + os.path.splitext(model_path)[0].split('/')[-1] + '_' + str(index) + '_' + str(datetime.date.today()) + '_' + str(mode) + '.avi'
+    else:
+        return './renders/' + os.path.splitext(model_path)[0].split('/')[-1] + '_' + str(index) + '_' + str(datetime.date.today()) + '_' + str(mode) + '.png'
 
 def rotate(model_object, index):
     model_object.rotation_euler[2] = math.radians(index * (360.0 / shots_number))
@@ -80,7 +70,7 @@ def rand_rotation():
     return (rand_rotation_value(), rand_rotation_value(), rand_rotation_value())
 
 def rand_rotation_value():
-    return round(random.uniform(0, 1), 10)
+    return round(math.radians(random.uniform(0, 60), 10))
 
 def rand_rotation():
     return (random.uniform(0, 20), random.uniform(0, 20), random.uniform(0, 20))
@@ -106,20 +96,6 @@ def unwrap_model(obj):
     bpy.ops.uv.unwrap()
     bpy.ops.object.mode_set(mode='OBJECT')
 
-def get_args():
-    parser = argparse.ArgumentParser()
-    # get all script args
-    _, all_arguments = parser.parse_known_args()
-    double_dash_index = all_arguments.index('--')
-    script_args = all_arguments[double_dash_index + 1: ]
-    # add parser rules
-    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")
-    parsed_script_args, _ = parser.parse_known_args(script_args)
-    return parsed_script_args
-
 def camera_rotation_string(camera):
     return str(int(camera.rotation_euler.x)) + ' ' + str(int(camera.rotation_euler.y)) + ' ' + str(int(camera.rotation_euler.z))
 
@@ -161,13 +137,12 @@ def mix_nodes(material, node1, node2):
     material.node_tree.links.new(mix.inputs[2], node2.outputs[0])
     assign_node_to_output(material, mix)
 
-def make_object_glossy(obj, color):
+def make_object_glossy(obj, color = (PINK), roughness = 0.2):
     material = bpy.data.materials.new('Glossy Material - ' + str(uuid.uuid1()))
     material.use_nodes = True
     glossy_node = material.node_tree.nodes.new('ShaderNodeBsdfGlossy')
     glossy_node.inputs[0].default_value = color
-    # roughness
-    glossy_node.inputs[1].default_value = 0.2
+    glossy_node.inputs[1].default_value = roughness
     assign_node_to_output(material, glossy_node)
     assign_material(obj, material)
 
@@ -175,13 +150,16 @@ def make_object_reflector(obj):
     obj.scale = (REFLECTOR_SCALE, REFLECTOR_SCALE, REFLECTOR_SCALE)
     make_object_emitter(obj, REFLECTOR_STRENGTH)
 
-def make_object_transparent(obj, color):
-    material = bpy.data.materials.new('Transparent Material - ' + str(uuid.uuid1()))
-    material.use_nodes = True
-    node = material.node_tree.nodes.new('ShaderNodeBsdfTransparent')
-    node.inputs[0].default_value = color
-    assign_node_to_output(material, node)
-    assign_material(obj, material)
+def make_texture_object_transparent(obj, color = (1,1,1,0.5), intensity = 0.25):
+    material = obj.data.materials[-1]
+    emission_node = material.node_tree.nodes['Emission']
+    trans = material.node_tree.nodes.new('ShaderNodeBsdfTransparent')
+    add = material.node_tree.nodes.new('ShaderNodeMixShader')
+    material.node_tree.links.new(emission_node.outputs[0], add.inputs[0])
+    material.node_tree.links.new(trans.outputs[0], add.inputs[1])
+    material.node_tree.links.new(emission_node.outputs[0], add.inputs[0])
+    add.inputs[0].default_value = intensity
+    trans.inputs[0].default_value = color
 
 def make_object_emitter(obj, emission_strength):
     emissive_material = bpy.data.materials.new('Emissive Material #' + str(uuid.uuid1()))
@@ -209,6 +187,14 @@ def make_object_gradient_fabulous(obj, color1, color2):
     mixer_node.inputs['Color1'].default_value = color1
     mixer_node.inputs['Color2'].default_value = color2
 
+def voronoize(obj, scale = 5.0):
+    material = obj.data.materials[-1]
+    texture_node = material.node_tree.nodes.new('ShaderNodeTexVoronoi')
+    material.node_tree.links.new(texture_node.outputs['Color'], material.node_tree.nodes['Glossy BSDF'].inputs['Color'])
+    texture_node.coloring = 'CELLS'
+    texture_node.inputs[1].default_value = scale
+    VORONOIED.append(obj)
+
 def texture_object(obj):
     new_material = create_cycles_material()
     assign_texture_to_material(new_material, random_texture())
@@ -258,8 +244,8 @@ def series(length):
     return list(map(lambda x: (0, x, math.cos(x)), numpy.arange(0.0, length, 0.1)))
 
 def randomize_reflectors_colors():
-    reflector1.data.materials[-1].node_tree.nodes['Emission'].inputs[0].default_value = rand_color()
-    reflector2.data.materials[-1].node_tree.nodes['Emission'].inputs[0].default_value = rand_color()
+    for r in bpy.data.groups['Plane'].objects:
+        r.data.materials[-1].node_tree.nodes['Emission'].inputs[0].default_value = rand_color()
 
 def add_object(obj, x, y, z, radius):
     infer_primitive(obj, location=(x, y, z), radius=radius)
@@ -314,8 +300,8 @@ def displace_vector(vector):
     return mathutils.Vector((vector.x + random.uniform(-DISPLACEMENT_AMPLITUDE, DISPLACEMENT_AMPLITUDE), vector.y + random.uniform(-DISPLACEMENT_AMPLITUDE, DISPLACEMENT_AMPLITUDE), vector.z + random.uniform(-DISPLACEMENT_AMPLITUDE, DISPLACEMENT_AMPLITUDE)))
 
 # Replace vertex coordinate everywhere
-def find_and_replace(vector):
-    return mathutils.Vector((float(str(vector.x).replace(REPLACE_TARGET, REPLACEMENT)), float(str(vector.y).replace(REPLACE_TARGET, REPLACEMENT)), float(str(vector.z).replace(REPLACE_TARGET, REPLACEMENT))))
+def find_and_replace(vector, target = random.uniform(0,9), replacement = random.uniform(0,9)):
+    return mathutils.Vector((float(str(vector.x).replace(target, replacement)), float(str(vector.y).replace(target, replacement)), float(str(vector.z).replace(target, replacement))))
 
 def glitch(object):
     bpy.ops.object.mode_set(mode='OBJECT')
@@ -360,7 +346,7 @@ def add_ocean(spatial_size, resolution):
     wireframize(shadow)
     shadow.name = 'ocean'
     ocean.name = 'ocean'
-    return ocean
+    return [ocean, shadow]
 
 # Delete current objects
 def flush_all_objects():
@@ -400,14 +386,31 @@ def build_pyramid(width=random.uniform(1,3), length=random.uniform(1,3), height=
     faces.append([3,0,4])
     return create_mesh('Pyramid ' + str(uuid.uuid1()), verts, faces, location)
 
-def dance_routine():
-    camera_object.location.x = INITIAL_CAMERA_LOCATION[0] + round(random.uniform(-2, 2), 10)
-    camera_object.location.y = INITIAL_CAMERA_LOCATION[1] + round(random.uniform(-2, 2), 10)
+def move_ocean(ocean):
+    ocean.modifiers['Ocean'].time += 1.5
+    ocean.modifiers['Ocean'].random_seed = round(random.uniform(0, 100))
+    ocean.modifers['Ocean'].choppiness += 0.3
+
+def camera_path(pitch):
+    res = []
+    initial_z = INITIAL_CAMERA_LOCATION[2]
+    initial_x = INITIAL_CAMERA_LOCATION[0]
+    for y in numpy.arange(initial_x, -initial_x, pitch):
+        res.append((initial_x, y, initial_z))
+    for x in numpy.arange(initial_x, -initial_x, pitch):
+        res.append((x,-initial_x, initial_z))
+    for y in numpy.arange(-initial_x, initial_x, pitch):
+        res.append((-initial_x, y, initial_z))
+    for x in numpy.arange(-initial_x, initial_x, pitch):
+        res.append((x, initial_x, initial_z))
+    return res
+
+def still_routine():
+    CAMERA.location.x = INITIAL_CAMERA_LOCATION[0] + round(random.uniform(-2, 2), 10)
+    CAMERA.location.y = INITIAL_CAMERA_LOCATION[1] + round(random.uniform(-2, 2), 10)
     randomize_reflectors_colors()
-    OCEAN.modifiers['Ocean'].time += 1
-    OCEAN.modifiers['Ocean'].random_seed = round(random.uniform(0, 100))
-    make_object_glossy(OCEAN, rand_color())
-    OCEAN.modifiers['Ocean'].choppiness += 0.3
+    map(move_ocean, OCEAN)
+    map(make_object_glossy, OCEAN)
     rotate(model_object, index)
     for l in bpy.data.groups['Lines'].objects:
         rotation = rand_rotation()
@@ -416,13 +419,31 @@ def dance_routine():
         prop.location = rand_location()
         prop.rotation_euler = rand_rotation()
     for obj in WIREFRAMES:
-        rotate(obj, index)
-        obj.location.z += round(random.uniform(-1, 1), 10)
-        obj.rotation_euler.z += math.radians(round(random.uniform(0, 90)))
+        obj.location = rand_location()
+        obj.rotation_euler = rand_rotation()
     for display in bpy.data.groups['Displays'].objects:
         display.location = rand_location()
         rotate(display, index)
 
+def animation_routine(frame):
+    assert len(camera_path) >= NUMBER_OF_FRAMES
+    CAMERA.location = camera_path[frame]
+    randomize_reflectors_colors()
+    map(move_ocean, OCEAN)
+    map(make_object_glossy, OCEAN)
+    glitch(model_object)
+    model_object.rotation_euler.z += math.radians(4)
+    for l in bpy.data.groups['Lines'].objects:
+        l.rotation_euler.x += math.radians(5)
+        l.rotation_euler.z += math.radians(5)
+    for prop in props:
+        prop.rotation_euler.x += math.radians(5)
+    for obj in WIREFRAMES:
+        obj.location.z += 0.1
+        obj.rotation_euler.z += math.radians(5)
+    for display in bpy.data.groups['Displays'].objects:
+        display.rotation_euler.x += math.radians(3)
+
 def create_line(name, point_list, thickness = 0.002, location = (0, -10, 0)):
     # setup basic line data
     line_data = bpy.data.curves.new(name=name,type='CURVE')
@@ -435,8 +456,30 @@ def create_line(name, point_list, thickness = 0.002, location = (0, -10, 0)):
     for idx in range(len(point_list)):
         polyline.points[idx].co = (point_list[idx])+(1.0,)
     # create an object that uses the linedata
-    line = bpy.data.objects.new('LineOne', line_data)
+    line = bpy.data.objects.new('line' + str(uuid.uuid1()), line_data)
     bpy.context.scene.objects.link(line)
     line.location = location
     make_object_emitter(line, 0.8)
     return line
+
+def add_spotlight(location, intensity, radians):
+    bpy.ops.object.lamp_add(type='SPOT', radius=1.0, view_align=False, location=location)
+    spot = last_added_object('Spot')
+    spot.data.node_tree.nodes['Emission'].inputs[1].default_value = intensity
+    spot.data.spot_size = radians
+    return spot
+
+def make_world_volumetric(world, scatter_intensity = SCATTER_INTENSITY, absorption_intensity = ABSORPTION_INTENSITY):
+    assert world.use_nodes == True
+    output = world.node_tree.nodes['World Output']
+    bg_node = world.node_tree.nodes.new('ShaderNodeBackground')
+    absorption_node = world.node_tree.nodes.new('ShaderNodeVolumeAbsorption')
+    scatter_node = world.node_tree.nodes.new('ShaderNodeVolumeScatter')
+    add_shader = world.node_tree.nodes.new('ShaderNodeAddShader')
+    world.node_tree.links.new(add_shader.outputs[0], output.inputs['Volume'])
+    world.node_tree.links.new(bg_node.outputs['Background'], output.inputs['Surface'])
+    world.node_tree.links.new(scatter_node.outputs[0], add_shader.inputs[0])
+    world.node_tree.links.new(absorption_node.outputs[0], add_shader.inputs[1])
+    scatter_node.inputs['Density'].default_value = SCATTER_INTENSITY
+    absorption_node.inputs['Density'].default_value = ABSORPTION_INTENSITY
+    bg_node.inputs[0].default_value = rand_color()

data/lib/glitch3d/bpy/lighting.py

@@ -0,0 +1,32 @@
+def let_there_be_light(scene):
+  add_spotlight((0, 0, 12), 14000, math.radians(60))
+  spot1 = add_spotlight((0, 8, 4), 8000, math.radians(60))
+  spot2 = add_spotlight((0, -8, 4), 8000, math.radians(60))
+  spot1.rotation_euler.x -= math.radians(90)
+  spot2.rotation_euler.x += math.radians(90)
+
+  bpy.ops.mesh.primitive_plane_add(location=(0,8 + REFLECTOR_LOCATION_PADDING, 0))
+  bpy.ops.mesh.primitive_plane_add(location=(8 + REFLECTOR_LOCATION_PADDING,0,0))
+  bpy.ops.mesh.primitive_plane_add(location=(0, 0, 30))
+
+  reflector1 = bpy.data.objects['Plane']
+  reflector2 = bpy.data.objects['Plane.001']
+  reflector3 = bpy.data.objects['Plane.002']
+
+  bpy.data.groups.new('Plane')
+  bpy.data.groups['Plane'].objects.link(reflector1)
+  bpy.data.groups['Plane'].objects.link(reflector2)
+  bpy.data.groups['Plane'].objects.link(reflector3)
+
+  reflector2.rotation_euler.x += math.radians(90)
+  reflector1.rotation_euler.x += math.radians(90)
+  reflector2.rotation_euler.z += math.radians(90)
+
+  make_object_reflector(reflector1)
+  make_object_reflector(reflector2)
+  make_object_reflector(reflector3)
+
+  world = bpy.data.worlds.new('A Brave New World')
+  world.use_nodes = True
+  make_world_volumetric(world)
+  scene.world = world

data/lib/glitch3d/bpy/main.py

@@ -0,0 +1,135 @@
+# Rendering script
+# Run by calling the blender executable with -b -P <script_name>
+# Use `debug()` to pry into the script
+
+import argparse
+
+DEBUG=False
+
+def get_args():
+    parser = argparse.ArgumentParser()
+    # get all script args
+    _, all_arguments = parser.parse_known_args()
+    double_dash_index = all_arguments.index('--')
+    script_args = all_arguments[double_dash_index + 1: ]
+    # add parser rules
+    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
+    parsed_script_args, _ = parser.parse_known_args(script_args)
+    return parsed_script_args
+
+args = get_args()
+file = args.file
+mode = args.mode
+path = str(args.path)
+animate = (args.animate == 'True')
+shots_number = int(args.shots_number)
+
+import os
+import bpy
+import datetime
+import bmesh
+import random
+import math
+import mathutils
+import random
+import uuid
+import sys
+import logging
+import string
+import colorsys
+import numpy
+import code
+
+# DEBUG = True
+if DEBUG:
+    shots_number = 2
+    import os
+    mode = 'low'
+    animate = False
+    file = "/Users/pascal/dev/glitch3d/fixtures/skull.obj"
+    path = "/Users/pascal/dev/glitch3d/lib/"
+
+exec(open(os.path.join(path + '/glitch3d/bpy', 'helpers.py')).read())
+exec(open(os.path.join(path + '/glitch3d/bpy', 'render_settings.py')).read())
+exec(open(os.path.join(path + '/glitch3d/bpy', 'lighting.py')).read())
+
+DEBUG = False
+FISHEYE = True
+COLORS = rand_color_palette(5)
+INITIAL_CAMERA_LOCATION = (4, 4, 1)
+FIXTURES_FOLDER_PATH = path + '/../fixtures/'
+TEXTURE_FOLDER_PATH = FIXTURES_FOLDER_PATH + 'textures/'
+
+# Scene
+context = bpy.context
+new_scene = bpy.data.scenes.new("Automated Render Scene")
+bpy.ops.scene.delete() # Delete old scene
+context.screen.scene = new_scene # selects the new scene as the current one
+
+flush_all_objects()
+
+camera_data = bpy.data.cameras['Camera']
+bpy.data.objects.new('Camera', object_data=camera_data)
+CAMERA = bpy.data.objects['Camera']
+new_scene.objects.link(CAMERA)
+context.scene.camera = CAMERA
+CAMERA.location = INITIAL_CAMERA_LOCATION
+
+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
+
+render_settings(context.scene, animate, mode)
+
+# Initialize groups
+for primitive in PRIMITIVES:
+    bpy.data.groups.new(primitive.lower().title())
+
+# Load model
+model_path = os.path.join(file)
+bpy.ops.import_scene.obj(filepath = model_path, use_edges=True)
+model_object = bpy.data.objects[1]
+model_object.select = True
+bpy.ops.object.origin_set(type="ORIGIN_CENTER_OF_MASS")
+model_object.location = ORIGIN
+make_object_glossy(model_object, YELLOW, 0.1)
+voronoize(model_object)
+
+let_there_be_light(context.scene)
+
+exec(open(os.path.join(path + '/glitch3d/bpy/canvas', 'dreamatorium.py')).read())
+
+print('Rendering images with resolution: ' + str(context.scene.render.resolution_x) + ' x ' + str(context.scene.render.resolution_y))
+
+if animate:
+    print('ANIMATION RENDERING BEGIN')
+    context.scene.frame_start = 0
+    context.scene.frame_end   = NUMBER_OF_FRAMES
+    bpy.ops.screen.frame_jump(end=False)
+    camera_path = camera_path(0.08)
+
+    for frame in range(0, NUMBER_OF_FRAMES):
+        bpy.context.scene.frame_set(frame)
+        animation_routine(frame - 1)
+        for ob in context.scene.objects:
+            ob.keyframe_insert(data_path="location", index=-1)
+    bpy.ops.screen.frame_jump(end=False)
+    shoot(model_object, output_name(index, model_path))
+
+else:
+    print('STILL RENDERING BEGIN')
+    for index in range(0, int(shots_number)):
+        print("-------------------------- " + str(index) + " --------------------------")
+        still_routine()
+        shoot(model_object, output_name(index, model_path))
+
+
+print('FINISHED ¯\_(ツ)_/¯')

data/lib/glitch3d/bpy/render_settings.py

@@ -0,0 +1,26 @@
+def render_settings(scene, animate, mode):
+    scene.render.resolution_x = 2000
+    scene.render.resolution_y = 2000
+    scene.render.engine = 'CYCLES'
+    scene.render.resolution_percentage = 25
+
+    # bpy.scene.cycles.device = 'GPU'
+    scene.render.image_settings.compression = 0
+    scene.cycles.samples = 25
+    scene.cycles.max_bounces = 1
+    scene.cycles.min_bounces = 1
+    scene.cycles.caustics_reflective = False
+    scene.cycles.caustics_refractive = False
+    scene.render.tile_x = 32
+    scene.render.tile_y = 32
+    scene.render.image_settings.color_mode ='RGBA'
+
+    if animate:
+        scene.render.image_settings.file_format='H264'
+    else:
+        scene.render.image_settings.file_format='PNG'
+
+    if mode == 'high':
+        scene.render.image_settings.compression = 90
+        scene.cycles.samples = 400
+        scene.render.resolution_percentage = 100

data/lib/glitch3d/version.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 module Glitch3d
-  VERSION = '0.2.2.3'
+  VERSION = '0.2.2.5'
 end

data/lib/glitch3d.rb

@@ -15,7 +15,7 @@ module Glitch3d
   CHUNK_SIZE=20
 
   BLENDER_EXECUTABLE_PATH = ENV['BLENDER_EXECUTABLE_PATH'].freeze
-  RENDERING_SCRIPT_PATH = File.dirname(__FILE__) + '/glitch3d/bpy/rendering.py'
+  RENDERING_SCRIPT_PATH = File.dirname(__FILE__) + '/glitch3d/bpy/main.py'
 
   def clean_model(source_file)
     self.class.include Glitch3d::None
@@ -28,7 +28,7 @@ module Glitch3d
   # @param String source_file, 3d model file to take as input
   # @param Hash args, parameters { 'stuff' => 'shit' }
   def process_model(source_file, args = nil)
-    source_file =  File.dirname(__FILE__) + '/../fixtures/cube.obj' if source_file.nil?
+    source_file = random_fixture if source_file.nil?
     args = Hash[ARGV.join(' ').scan(/--?([^=\s]+)(?:=(\S+))?/)] if args.nil?
     return clean_model(source_file) if args['clean']
 
@@ -37,6 +37,12 @@ module Glitch3d
       return nil
     end
 
+    if args.has_key?('animate')
+      args['animate'] = 'true'
+    else
+      args['animate'] = 'false'
+    end
+
     raise 'Set Blender executable path in your env variables before using glitch3d' if BLENDER_EXECUTABLE_PATH.nil?
     self.class.include infer_strategy(args['mode'] || 'default')
     @quality = args['quality'] || 'low'
@@ -45,7 +51,17 @@ module Glitch3d
     model_name = File.basename(source_file, '.obj')
     target_file = base_file_name + '_glitched.obj'
     create_glitched_file(glitch(read_source(source_file)), target_file, model_name)
-    render(target_file, args['shots-number'] || 6) unless args['no-render']
+    render(args, target_file, args['shots-number'] || 6) unless args['no-render']
+  end
+
+  def random_fixture
+    @fixtures_path = File.dirname(__FILE__) + '/../fixtures'
+    fixtures = []
+    Dir.foreach(@fixtures_path) do |item|
+      next if item == '.' or item == '..' or item.end_with?('_glitched.obj') or !item.end_with?('.obj')
+      fixtures << @fixtures_path + '/' + item
+    end
+    fixtures.sample
   end
 
   def infer_strategy(mode)
@@ -135,7 +151,8 @@ module Glitch3d
     boundaries.flatten.map(&:abs).max.abs > BOUNDARY_LIMIT
   end
 
-  def render(file_path, shots_number)
+  def render(initial_args, file_path, shots_number)
+    raise 'Animation arg not boolean' unless eval(initial_args['animate']).is_a?(FalseClass) || eval(initial_args['animate']).is_a?(TrueClass)
     args = [
       BLENDER_EXECUTABLE_PATH,
       '-b',
@@ -149,7 +166,9 @@ module Glitch3d
       '-m',
       @quality,
       '-p',
-      File.dirname(__FILE__).to_s
+      File.dirname(__FILE__).to_s,
+      '-a',
+      initial_args['animate'].capitalize
     ]
     raise 'Make sure Blender is correctly installed' unless system(*args)
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: glitch3d
 version: !ruby/object:Gem::Version
-  version: 0.2.2.3
+  version: 0.2.2.5
 platform: ruby
 authors:
 - pskl
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-09-29 00:00:00.000000000 Z
+date: 2017-10-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -88,7 +88,7 @@ files:
 - bin/setup
 - fixtures/brain.obj
 - fixtures/cube.obj
-- fixtures/demo.png
+- fixtures/dude.jpg
 - fixtures/face.obj
 - fixtures/m4a1.obj
 - fixtures/male_head.obj
@@ -106,8 +106,11 @@ files:
 - fixtures/textures/vapor.jpg
 - glitch3d.gemspec
 - lib/glitch3d.rb
+- lib/glitch3d/bpy/canvas/dreamatorium.py
 - lib/glitch3d/bpy/helpers.py
-- lib/glitch3d/bpy/rendering.py
+- lib/glitch3d/bpy/lighting.py
+- lib/glitch3d/bpy/main.py
+- lib/glitch3d/bpy/render_settings.py
 - lib/glitch3d/objects/face.rb
 - lib/glitch3d/objects/vertex.rb
 - lib/glitch3d/strategies/default.rb

data/lib/glitch3d/bpy/rendering.py

@@ -1,236 +0,0 @@
-# Rendering script
-# Run by calling the blender executable with -b -P <script_name>
-# Disclaimer: I never did Python before so this is mostly hacks
-#
-# process:
-# 1) Load model given as a parameter
-# 2) Create emitting surfaces to act as lamps
-# 3) Create camera
-# 4) Rotate model and shoot image at each step
-#
-# Use `debug()` to pry into the script
-import os
-exec(open(os.path.join(os.path.dirname(__file__), 'helpers.py')).read())
-
-# Arguments parsing
-args = get_args()
-file = args.file
-mode = args.mode
-path = str(args.path)
-shots_number = int(args.shots_number)
-
-FIXTURES_FOLDER_PATH = path + '/../fixtures/'
-
-DEBUG = False
-FISHEYE = True
-COLORS = rand_color_palette(5)
-INITIAL_CAMERA_LOCATION = (4, 4, 1)
-ANIMATE = False
-
-# DEBUG = True
-if DEBUG:
-    shots_number = 2
-    import os
-    mode = 'low'
-    file = "/Users/pascal/dev/glitch3d/fixtures/skull.obj"
-    FIXTURES_FOLDER_PATH = "/Users/pascal/dev/glitch3d/fixtures/"
-
-TEXTURE_FOLDER_PATH = FIXTURES_FOLDER_PATH + 'textures/'
-
-# Scene
-new_scene = bpy.data.scenes.new("Automated Render Scene")
-bpy.ops.scene.delete() # Delete old scene
-context.screen.scene = new_scene # selects the new scene as the current one
-
-# Initialize groups
-for primitive in PRIMITIVES:
-    bpy.data.groups.new(primitive.lower().title())
-
-# Render settings
-context.scene.render.resolution_x = 2000
-context.scene.render.resolution_y = 2000
-context.scene.render.engine = 'CYCLES'
-context.scene.render.resolution_percentage = 25
-# uncomment if GPU
-# bpy.context.scene.cycles.device = 'GPU'
-context.scene.render.image_settings.compression = 0
-context.scene.cycles.samples = 25
-context.scene.render.image_settings.color_mode ='RGBA'
-context.scene.render.image_settings.file_format='PNG'
-
-if mode == 'high':
-    context.scene.render.image_settings.compression = 90
-    context.scene.cycles.samples = 400
-    context.scene.render.resolution_percentage = 100
-
-# Add background to world
-
-# This shit doesnt work in v 2.76
-# bpy.data.worlds.remove(bpy.data.worlds[0])
-world = bpy.data.worlds.new('A Brave New World')
-world.use_nodes = True
-world_node_tree = world.node_tree
-context.scene.world = world
-
-# Clean slate
-flush_all_objects()
-
-# Load model
-model_path = os.path.join(file)
-
-bpy.ops.import_scene.obj(filepath = model_path, use_edges=True)
-model_object = bpy.data.objects[0]
-
-# Load props
-bpy.ops.import_scene.obj(filepath = os.path.join(FIXTURES_FOLDER_PATH + 'm4a1.obj'), use_edges=True)
-m4a1 = bpy.data.objects['m4a1']
-m4a1.location = rand_location()
-m4a1.scale = (0.5, 0.5, 0.5)
-props.append(m4a1)
-
-# Use center of mass to center object
-model_object.select = True
-bpy.ops.object.origin_set(type="ORIGIN_CENTER_OF_MASS")
-model_object.location = ORIGIN
-make_object_glossy(model_object, YELLOW)
-
-# Add props
-rand_primitive = random.choice(PRIMITIVES)
-build_composite_object(rand_primitive, 4, 1)
-
-# --------------
-# Create camera
-# --------------
-camera_data = bpy.data.cameras.new('Camera')
-bpy.data.objects.new('Camera', object_data=camera_data)
-camera_object = bpy.data.objects['Camera']
-new_scene.objects.link(camera_object)
-camera_object.location = INITIAL_CAMERA_LOCATION
-
-if FISHEYE:
-    camera_object.data.type = 'PANO'
-    camera_object.data.cycles.panorama_type = 'FISHEYE_EQUISOLID'
-    camera_object.data.cycles.fisheye_lens = 12
-    camera_object.data.cycles.fisheye_fov = 2.5
-    camera_object.data.sensor_width = 20
-    camera_object.data.sensor_height = 20
-
-# Add reflectors
-bpy.ops.mesh.primitive_plane_add(location=(0,8 + REFLECTOR_LOCATION_PADDING, 0))
-bpy.ops.mesh.primitive_plane_add(location=(8 + REFLECTOR_LOCATION_PADDING,0,0))
-bpy.ops.mesh.primitive_plane_add(location=(0, 0, 20))
-bpy.ops.mesh.primitive_plane_add(location=(0, 0, -2))
-
-reflector1 = bpy.data.objects['Plane']
-reflector2 = bpy.data.objects['Plane.001']
-reflector3 = bpy.data.objects['Plane.002']
-
-bpy.data.groups.new('Plane')
-bpy.data.groups['Plane'].objects.link(reflector1)
-bpy.data.groups['Plane'].objects.link(reflector2)
-bpy.data.groups['Plane'].objects.link(reflector3)
-
-reflector2.rotation_euler.x += math.radians(90)
-reflector1.rotation_euler.x += math.radians(90)
-reflector2.rotation_euler.z += math.radians(90)
-
-make_object_reflector(reflector1)
-make_object_reflector(reflector2)
-make_object_reflector(reflector3)
-
-# Set up virtual displays
-bpy.ops.mesh.primitive_grid_add(x_subdivisions=100, y_subdivisions=100, location=(0, 6, 2))
-display1 = bpy.data.objects['Grid']
-bpy.ops.mesh.primitive_grid_add(x_subdivisions=100, y_subdivisions=100, location=(6, 0, 2))
-display2 = bpy.data.objects['Grid.001']
-
-bpy.data.groups.new('Displays')
-bpy.data.groups['Displays'].objects.link(display1)
-bpy.data.groups['Displays'].objects.link(display2)
-
-display1.rotation_euler.x += math.radians(90)
-display1.rotation_euler.z -= math.radians(90)
-display2.rotation_euler.x += math.radians(90)
-display2.rotation_euler.y += math.radians(90)
-display2.rotation_euler.z += math.radians(120)
-
-for display in bpy.data.groups['Displays'].objects:
-    display.rotation_euler.x += math.radians(90)
-    display.scale = (3,3,3)
-    texture_object(display)
-    unwrap_model(display)
-    glitch(display)
-
-glitch(m4a1)
-make_object_gradient_fabulous(m4a1, rand_color(), rand_color())
-
-# Adjust camera
-context.scene.camera = camera_object
-look_at(camera_object, model_object)
-
-# Make floor
-floor = bpy.data.objects['Plane.003']
-bpy.data.groups['Plane'].objects.link(floor)
-floor.scale = (20,20,20)
-subdivide(floor, 8)
-displace(floor)
-texture_object(floor)
-
-OCEAN = add_ocean(10, 20)
-
-# Create lines
-bpy.data.groups.new('Lines')
-for i in range(0, 20):
-    new_line = create_line('line' + str(uuid.uuid1()), series(30))
-    new_line.location.z += i / 6
-
-for index in range(1, len(WORDS)):
-    new_object = spawn_text()
-    props.append(new_object)
-    text_scale = random.uniform(0.75, 2)
-    make_object_glossy(new_object, GREY)
-    new_object.scale = (text_scale, text_scale, text_scale)
-    new_object.location = rand_location()
-    # pivot text to make it readable by camera
-    new_object.rotation_euler.x += math.radians(90)
-    new_object.rotation_euler.z += math.radians(90)
-
-for plane in bpy.data.groups['Plane'].objects:
-    unwrap_model(plane)
-
-for obj in WIREFRAMES:
-    wireframize(obj)
-
-look_at(camera_object, model_object)
-model_object.location.z += 2
-
-# ------
-# Shoot
-# ------
-print('Rendering images with resolution: ' + str(context.scene.render.resolution_x) + ' x ' + str(context.scene.render.resolution_y))
-
-if ANIMATE:
-    print('ANIMATION RENDERING BEGIN')
-    context.scene.frame_start = 0
-    context.scene.frame_end   = NUMBER_OF_FRAMES
-    bpy.ops.screen.frame_jump(end=False)
-
-    for frame in range(1, NUMBER_OF_FRAMES):
-        bpy.context.scene.frame_set(frame)
-
-        dance_routine()
-
-        for ob in context.scene.objects:
-            ob.keyframe_insert(data_path="location", index=-1)
-
-    bpy.ops.screen.frame_jump(end=False)
-    shoot(True, camera_object, model_object, output_name(index, model_path))
-else:
-    print('STILL RENDERING BEGIN')
-    for index in range(0, int(shots_number)):
-        print("-------------------------- " + str(index) + " --------------------------")
-        shoot(False, camera_object, model_object, output_name(index, model_path))
-        dance_routine()
-
-
-print('FINISHED ¯\_(ツ)_/¯')