glitch3d 0.2.3.2 → 0.2.3.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 285f80bfd141184bf964f5ca7708bed223d8fe77
-  data.tar.gz: 97d76d9d5fa444da5f01eed306ee2ed23ee7d67f
+  metadata.gz: 246e3f5ad753205a1da7847ad49660d5760bccc2
+  data.tar.gz: 059bdda653c3cac77696c54204fa0e8710c23185
 SHA512:
-  metadata.gz: 02cbe99d66f1b7f828c733d6f0a7b591afc11b4259b4ca6346a60eb76ec5e13f7f791a788122e6fb418e21e103bdb9a224388c69ef2a75b907d236661233b746
-  data.tar.gz: 6f33a8578b384790942034d8996fa83f81e4e9ab219269154dbd820c9d9902dbd08ca2d3bb2a07d7275aaa7983285fcd6ce9bdce5fc7e27b544355a0961ab68d
+  metadata.gz: 21e27d27c995d89cf1aa4f8b84878622280a2689b43b95b308a9aafb1292d2a611a966dd28b9de4df0b6fb50d406d22fdefb35c536466a6413200232ec582486
+  data.tar.gz: 2f395fa7b47217d5bec2e1390fefb8a966811d62c956dba2a88277e2070705be879b8e4ce9e20459083769b1d987f604f318df77007c867d3df6d6ad1385ec06

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

@@ -1,33 +1,38 @@
 ######################
 ## FLUID SIMULATION ##
 ######################
-context.scene.frame_end = NUMBER_OF_FRAMES
+SCENE.frame_end = NUMBER_OF_FRAMES
+
+RADIUS=20
 
 # Container
-bpy.ops.mesh.primitive_cube_add(location=(0, 0, -0.4),radius=7)
-container = bpy.data.objects['Cube']
+bpy.ops.mesh.primitive_cube_add(location=(0, 0, -0.4),radius=RADIUS)
+container = last_added_object('CUBE')
 container.name = 'Container'
 container.modifiers.new(name='container', type='FLUID_SIMULATION')
 container.modifiers['container'].settings.type = 'DOMAIN'
-container.modifiers['container'].settings.generate_particles = 0.1
-make_object_gradient_fabulous(container, rand_color(), rand_color())
-# make_object_glossy(container)
+container.modifiers['container'].settings.generate_particles = 0.06
 container.modifiers['container'].settings.surface_subdivisions = 100
-container.location = (0, 0, 7)
+container.modifiers['container'].settings.viscosity_exponent = 6
+container.modifiers['container'].settings.viscosity_base = 1.0
+container.modifiers['container'].settings.simulation_scale = 1
+
+container.location = (0, 0, 0)
 
 # Emitter of fluid
-bpy.ops.mesh.primitive_uv_sphere_add(location=(0,0,10))
+bpy.ops.mesh.primitive_uv_sphere_add(location=(0,0,((RADIUS/2) - 1)))
 emitter = bpy.data.objects['Sphere']
+emitter.cycles_visibility.camera = False
 emitter.name = 'Emitter'
 emitter.modifiers.new(name='emitter', type='FLUID_SIMULATION')
 emitter.modifiers['emitter'].settings.type = 'INFLOW'
-emitter.modifiers['emitter'].settings.inflow_velocity = mathutils.Vector((0, 0, -1))
+emitter.modifiers['emitter'].settings.inflow_velocity = mathutils.Vector((0, 0.5, -2))
 emitter.scale = (0.5, 0.5, 0.5)
 
-SUBJECT.modifiers.new(name='obstacle', type='FLUID_SIMULATION')
-SUBJECT.modifiers['obstacle'].settings.type = 'OBSTACLE'
-SUBJECT.modifiers['obstacle'].settings.volume_initialization = 'BOTH'
-SUBJECT.modifiers['obstacle'].settings.partial_slip_factor = 0.15
+# make_object_transparent(container)
+make_object_gradient_fabulous(container, rand_color(), rand_color())
+make_object_fluid_collider(SUBJECT)
+make_object_fluid_collider(OCEAN[0])
 
 # Bake animation
 bpy.ops.fluid.bake({'scene': context.scene, 'active_object': container})

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

@@ -7,7 +7,12 @@ props.append(m4a1)
 
 # Add props
 rand_primitive = random.choice(PRIMITIVES)
-build_composite_object(rand_primitive, 4, 1)
+elements = build_composite_object(rand_primitive, 4, 1)
+
+for l1 in elements:
+    for l2 in l1:
+        for obj in l2:
+            WIREFRAMES.append(obj)
 
 # Set up virtual displays
 bpy.ops.mesh.primitive_grid_add(x_subdivisions=100, y_subdivisions=100, location=(0, 6, 2))
@@ -38,9 +43,9 @@ 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)
+bpy.data.groups['Planes'].objects.link(floor)
 floor.scale = (20,20,20)
-subdivide(floor, int(random.uniform(0, 7)))
+subdivide(floor, int(random.uniform(3, 7)))
 displace(floor)
 texture_object(floor)
 
@@ -62,11 +67,8 @@ for index in range(1, len(WORDS)):
     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:
+for plane in bpy.data.groups['Planes'].objects:
     unwrap_model(plane)
 
 for obj in WIREFRAMES:

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

@@ -1,62 +1,54 @@
 # Game of life inspired scene
-w = 40
-f = 1
-bpy.ops.anim.change_frame( frame = f )
+SIZE = 10
+DURATION=NUMBER_OF_FRAMES
+SCENE.frame_start = 0
+SCENE.frame_end = DURATION
+cubes = build_grid_object('CUBE', SIZE-1, 0.5, 1)
 
-cubes = [[ 0 for i in range(w)] for j in range(w)]
-for x in range(w):
-    for y in range(w):
-        bpy.ops.mesh.primitive_cube_add( location=(x * 2, y * 2, 0 ))
-        cubes[x][y] = bpy.context.active_object
-        cubes[x][y].data.materials.append( mat );
-        cubes[x][y].scale=(.1,.1,.1)
-        bpy.ops.anim.keyframe_insert_menu( type='Scaling')
-
-cells = [[ 0 for i in range(w)] for j in range(w)]
-nextGen = [[ 0 for i in range(w)] for j in range(w)]
+cells = [[ 0 for i in range(SIZE)] for j in range(SIZE)]
+next_generation = [[ 0 for i in range(SIZE)] for j in range(SIZE)]
 
-cells[16][14] = 1
-cells[16][15] = 1
-cells[15][15] = 1
-cells[15][17] = 1
-cells[16][16] = 1
-cells[17][15] = 1
-cells[17][17] = 1
-cells[16][17] = 1
+for x in range(SIZE):
+    for y in range(SIZE):
+        cubes[x][y].scale=(.1,.1,.1)
+        cells[x][y] = random.choice(range(2))
+        make_object_gradient_fabulous(cubes[x][y], rand_color(), rand_color())
 
-for l in range(50):
-    f += 5
-    bpy.ops.anim.change_frame( frame = f )
-    for x in range(w):
-        row = ""
-        for y in range(w):
-            nb = 0
+def adjust_scale():
+    for x in range(SIZE):
+        for y in range(SIZE):
+            if  cells[x][y] == 1 :
+                cubes[x][y].scale=(random.uniform(0.4, 0.6), random.uniform(0.4, 0.6), random.uniform(0.4, 0.6))
+            else:
+                cubes[x][y].scale=(.2,.2,.2)
+            for line in cubes:
+                add_frame(line)
+
+def life(l):
+    print("Life in " + str(l))
+    for x in range(SIZE):
+        for y in range(SIZE):
+            neighbors_alive_count = 0
             for i in range(-1,2):
                 for j in range( -1, 2):
-                    xx = (x + i + w) % w
-                    yy = (y + j + w) % w
-
-                    if not( xx == x and yy == y):
-                        nb += cells[xx][yy]
-
-            if ( cells[x][y] == 1 and (nb == 2 or nb == 3)):
-                nextGen[x][y] = 1
-            elif ( cells[x][y] == 0 and nb == 3 ):
-                nextGen[x][y] = 1
-            else:
-                nextGen[x][y] = 0
-
-            n = cubes[x][y]
-            bpy.context.scene.objects.active = n
-            n.select = True
-            if  cells[x][y] == 1 :
-                #row += 'X'
-                cubes[x][y].scale=(1,1,1)
+                    x_index = (x + i + SIZE) % SIZE
+                    y_index = (y + j + SIZE) % SIZE
+                    if not( x_index == x and y_index == y):
+                        neighbors_alive_count += cells[x_index][y_index]
+            if ( cells[x][y] == 1 and (neighbors_alive_count == 2 or neighbors_alive_count == 3)):
+                next_generation[x][y] = 1
+            elif ( cells[x][y] == 0 and neighbors_alive_count == 3 ):
+                next_generation[x][y] = 1
             else:
-                #row += '.'
-                cubes[x][y].scale=(.1,.1,.1)
-            bpy.ops.anim.keyframe_insert_menu( type='Scaling')
+                next_generation[x][y] = 0
+    for x in range(SIZE):
+        for y in range(SIZE):
+            cells[x][y] = next_generation[x][y]
+    adjust_scale()
+
+print("Synthetic life begin")
+adjust_scale()
+for l in range(DURATION):
+    SCENE.frame_set(l)
+    life(l)
 
-    for x in range( w ):
-        for y in range(w):
-            cells[x][y] = nextGen[x][y]

data/lib/glitch3d/bpy/helpers.py

@@ -14,7 +14,7 @@ PRIMITIVES = ['PYRAMID', 'CUBE']
 props = []
 YELLOW = (1, 0.7, 0.1, 1)
 GREY = (0.2, 0.2, 0.2 ,1)
-BLUE = (0.1, 0.1, 0.8, 1)
+BLUE = (0.1, 0.1, 0.8, 0.4)
 PINK = (0.8, 0.2, 0.7, 1.0)
 WORDS = string.ascii_lowercase
 
@@ -23,20 +23,16 @@ def pry():
     sys.exit("Aborting execution")
 
 # Helper methods
-def look_at(object):
+def look_at(obj):
     location_camera = CAMERA.matrix_world.to_translation()
-    location_object = object.matrix_world.to_translation()
+    location_object = obj.matrix_world.to_translation()
     direction = location_object - location_camera
     rot_quat = direction.to_track_quat('-Z', 'Y')
     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(filepath):
     print('Camera now at location: ' + camera_location_string(CAMERA) + ' / rotation: ' + camera_rotation_string(CAMERA))
-    bpy.context.scene.render.filepath = filepath
+    SCENE.render.filepath = filepath
     if animate:
         return bpy.ops.render.render(animation=animate, write_still=True)
     bpy.ops.render.render(write_still=True)
@@ -82,7 +78,7 @@ def rand_scale_vector():
 def unwrap_model(obj):
     if obj.name.startswith('Camera') or obj.name.startswith('Text') or obj.name.startswith('Cube'):
         return False
-    context.scene.objects.active = obj
+    SCENE.objects.active = obj
     bpy.ops.object.mode_set(mode='EDIT')
     bpy.ops.uv.unwrap()
     bpy.ops.object.mode_set(mode='OBJECT')
@@ -93,8 +89,8 @@ def camera_rotation_string(camera):
 def camera_location_string(camera):
     return str(int(camera.location.x)) + ' ' + str(int(camera.location.y)) + ' ' + str(int(camera.location.z))
 
-def assign_material(SUBJECT, material):
-    SUBJECT.data.materials.append(material)
+def assign_material(obj, material):
+    obj.data.materials.append(material)
 
 # Returns a new Cycles material with default DiffuseBsdf node linked to output
 def create_cycles_material():
@@ -152,13 +148,19 @@ def make_texture_object_transparent(obj, color = (1,1,1,0.5), intensity = 0.25):
     add.inputs[0].default_value = intensity
     trans.inputs[0].default_value = color
 
+def make_object_transparent(obj):
+    material = bpy.data.materials.new('Transparent Material - ' + str(uuid.uuid1()))
+    material.use_nodes = True
+    trans = material.node_tree.nodes.new('ShaderNodeBsdfTransparent')
+    trans.inputs[0].default_value = rand_color()
+    assign_node_to_output(material, trans)
+    assign_material(obj, material)
+
 def make_object_emitter(obj, emission_strength):
     emissive_material = bpy.data.materials.new('Emissive Material #' + str(uuid.uuid1()))
     emissive_material.use_nodes = True
     emission_node = emissive_material.node_tree.nodes.new('ShaderNodeEmission')
-    # Set color
     emission_node.inputs[0].default_value = rand_color()
-    # Set strength
     emission_node.inputs[1].default_value = emission_strength
     assign_node_to_output(emissive_material, emission_node)
     assign_material(obj, emissive_material)
@@ -194,7 +196,7 @@ def texture_object(obj):
 def duplicate_object(obj):
     new_object = obj.copy()
     new_object.data = obj.data.copy()
-    context.scene.objects.link(new_object)
+    SCENE.objects.link(new_object)
     return new_object
 
 def random_text():
@@ -207,7 +209,7 @@ def create_mesh(name, verts, faces, location):
     mesh_data.update()
     obj = bpy.data.objects.new(name, mesh_data)
     obj.location = location
-    context.scene.objects.link(obj)
+    SCENE.objects.link(obj)
     return obj
 
 def spawn_text():
@@ -216,11 +218,11 @@ def spawn_text():
     new_curve.extrude = 0.11
     new_text = bpy.data.objects.new("Text - " + identifier, new_curve)
     new_text.data.body = random_text()
-    context.scene.objects.link(new_text)
+    SCENE.objects.link(new_text)
     return new_text
 
 def wireframize(obj):
-    context.scene.objects.active = obj
+    SCENE.objects.active = obj
     bpy.ops.object.modifier_add(type='WIREFRAME')
     obj.modifiers['Wireframe'].thickness = WIREFRAME_THICKNESS
     make_object_emitter(obj, 2)
@@ -234,13 +236,14 @@ def series(length):
     return list(map(lambda x: (0, x, math.cos(x)), pitched_array(0.0, length, 0.1)))
 
 def randomize_reflectors_colors():
-    for r in bpy.data.groups['Plane'].objects:
+    for r in bpy.data.groups['Reflectors'].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)
     WIREFRAMES.append(last_added_object(obj))
     group_add(obj, last_added_object(obj))
+    return last_added_object(obj)
 
 def infer_primitive(obj, **kwargs):
     if obj == 'CUBE':
@@ -268,22 +271,28 @@ def last_object_group(group_name):
     return bpy.data.groups[group_name.lower().title()].objects[-1]
 
 def build_composite_object(obj, size, radius):
-    build_grid_object(obj, size, -size, radius)
+    res = []
+    res.append(build_grid_object(obj, size, -size, radius))
     for z in range(0, size):
-        build_grid_object(obj, size, last_object_group(obj).location.z + 2 * radius, radius)
+        res.append(build_grid_object(obj, size, last_object_group(obj).location.z + 2 * radius, radius))
+    return res
 
 def build_grid_object(obj, size, z_index, radius):
-    build_object_line(obj, size, z_index, -size, radius)
+    res = []
+    res.append(build_object_line(obj, size, z_index, -size, radius))
     for y in range(0, size):
-        build_object_line(obj, size, z_index, last_object_group(obj).location.y + 2 * radius, radius)
+        res.append(build_object_line(obj, size, z_index, last_object_group(obj).location.y + 2 * radius, radius))
+    return res
 
 def build_object_line(obj, size, z_index, y_index, radius):
-    add_object(obj, -size, y_index, z_index, radius)
+    res = []
+    res.append(add_object(obj, -size, y_index, z_index, radius))
     for x in range(0, size):
         new_obj = duplicate_object(last_object_group(obj))
-        WIREFRAMES.append(new_obj)
         group_add(obj, new_obj)
+        res.append(new_obj)
         new_obj.location = ((last_object_group(obj).location.x + 2 * radius), y_index, z_index)
+    return res
 
 # Displace vertex by random offset
 def displace_vector(vector):
@@ -309,9 +318,9 @@ def displace(object):
         vertex.co = displace_vector(vertex.co)
 
 def subdivide(object, cuts):
-    if context.scene.objects.active != object:
-        context.scene.objects.active = object
-    assert context.scene.objects.active == object
+    if SCENE.objects.active != object:
+        SCENE.objects.active = object
+    assert SCENE.objects.active == object
     bpy.ops.object.mode_set(mode='EDIT')
     for index in range(0, cuts):
         bpy.ops.mesh.subdivide(cuts)
@@ -320,7 +329,7 @@ def clone(obj):
     new_obj = obj.copy()
     new_obj.data = obj.data.copy()
     new_obj.animation_data_clear()
-    context.scene.objects.link(new_obj)
+    SCENE.objects.link(new_obj)
     return new_obj
 
 def add_ocean(spatial_size, resolution, depth = 100, scale=(4,4,4)):
@@ -342,9 +351,9 @@ def add_ocean(spatial_size, resolution, depth = 100, scale=(4,4,4)):
     return [ocean, shadow]
 
 # Delete current objects
-def flush_all_objects():
-    for index, obj in enumerate(bpy.data.objects):
-        bpy.data.objects.remove(obj)
+def flush_objects(objs = bpy.data.objects):
+    for obj in objs:
+        bpy.data.objects.remove(obj, do_unlink=True)
 
 # Rotate hue to generate palette
 def adjacent_colors(r, g, b, number):
@@ -453,19 +462,16 @@ def animation_routine(frame):
             display.rotation_euler.x += math.radians(2)
 
 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')
     line_data.dimensions = '3D'
     line_data.fill_mode = 'FULL'
     line_data.bevel_depth = thickness
-    # define points that make the line
     polyline = line_data.splines.new('POLY')
     polyline.points.add(len(point_list)-1)
     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('line' + str(uuid.uuid1()), line_data)
-    bpy.context.scene.objects.link(line)
+    SCENE.objects.link(line)
     line.location = location
     make_object_emitter(line, 0.8)
     return line
@@ -491,3 +497,15 @@ def make_world_volumetric(world, scatter_intensity = SCATTER_INTENSITY, absorpti
     scatter_node.inputs['Density'].default_value = SCATTER_INTENSITY
     absorption_node.inputs['Density'].default_value = ABSORPTION_INTENSITY
     bg_node.inputs[0].default_value = rand_color()
+
+def make_object_fluid_collider(obj):
+    obj.modifiers.new(name='obstacle', type='FLUID_SIMULATION')
+    obj.modifiers['obstacle'].settings.type = 'OBSTACLE'
+    obj.modifiers['obstacle'].settings.volume_initialization = 'BOTH'
+    obj.modifiers['obstacle'].settings.partial_slip_factor = 0.15
+
+def add_frame(collection = bpy.data.objects):
+    for obj in collection:
+        obj.keyframe_insert(data_path="rotation_euler", index=-1)
+        obj.keyframe_insert(data_path="location", index=-1)
+        obj.keyframe_insert(data_path="scale", index=-1)

data/lib/glitch3d/bpy/lighting.py

@@ -1,7 +1,7 @@
 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))
+  add_spotlight((0, 0, 12), 15000, math.radians(70))
+  spot1 = add_spotlight((0, 8, 4), 9000, math.radians(70))
+  spot2 = add_spotlight((0, -8, 4), 9000, math.radians(70))
   spot1.rotation_euler.x -= math.radians(90)
   spot2.rotation_euler.x += math.radians(90)
 
@@ -13,10 +13,10 @@ def let_there_be_light(scene):
   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)
+  for r in [reflector1, reflector2, reflector3]:
+    r.cycles_visibility.camera = False
+    bpy.data.groups['Planes'].objects.link(r)
+    bpy.data.groups['Reflectors'].objects.link(r)
 
   reflector2.rotation_euler.x += math.radians(90)
   reflector1.rotation_euler.x += math.radians(90)

data/lib/glitch3d/bpy/main.py

@@ -1,8 +1,6 @@
 # Rendering script
 # Run by calling the blender executable with -b -P <script_name>
 # Use `pry()` to pry into the script
-# 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
 
 import argparse
 
@@ -49,8 +47,10 @@ exec(open(os.path.join(path + '/glitch3d/bpy', 'lighting.py')).read())
 WIREFRAMES = []
 VORONOIED = []
 OCEAN = []
-bpy.data.groups.new('Lines')
-bpy.data.groups.new('Displays')
+
+for s in ['Lines', 'Displays', 'Reflectors', 'Planes']:
+    bpy.data.groups.new(s)
+
 LINES = bpy.data.groups['Lines'].objects
 for primitive in PRIMITIVES:
     bpy.data.groups.new(primitive.lower().title())
@@ -64,16 +64,17 @@ 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
+bpy.ops.scene.delete()
+context.screen.scene = new_scene
+SCENE = new_scene
 
-flush_all_objects()
+flush_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
+SCENE.camera = CAMERA
 CAMERA.location = INITIAL_CAMERA_LOCATION
 
 if FISHEYE:
@@ -84,7 +85,7 @@ if FISHEYE:
     CAMERA.data.sensor_width = 20
     CAMERA.data.sensor_height = 20
 
-render_settings(context.scene, animate, mode)
+render_settings(animate, mode)
 
 # Load model
 model_path = os.path.join(file)
@@ -94,32 +95,29 @@ SUBJECT.select = True
 bpy.ops.object.origin_set(type="ORIGIN_CENTER_OF_MASS")
 SUBJECT.location = ORIGIN
 make_object_glossy(SUBJECT, YELLOW, 0.01)
-
-let_there_be_light(context.scene)
+look_at(SUBJECT)
+let_there_be_light(SCENE)
 
 if debug == False:
-    # exec(open(os.path.join(path + '/glitch3d/bpy/canvas', 'dreamatorium.py')).read())
+    exec(open(os.path.join(path + '/glitch3d/bpy/canvas', 'lyfe.py')).read())
+    exec(open(os.path.join(path + '/glitch3d/bpy/canvas', 'dreamatorium.py')).read())
     exec(open(os.path.join(path + '/glitch3d/bpy/canvas', 'aether.py')).read())
 
-    print('Rendering images with resolution: ' + str(context.scene.render.resolution_x) + ' x ' + str(context.scene.render.resolution_y))
+    print('Rendering images with resolution: ' + str(SCENE.render.resolution_x) + ' x ' + str(SCENE.render.resolution_y))
 
-    for plane in bpy.data.groups['Plane'].objects:
+    for plane in bpy.data.groups['Planes'].objects:
         unwrap_model(plane)
 
     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)
+        SCENE.frame_start = 0
+        SCENE.frame_end = NUMBER_OF_FRAMES
         CAMERA_PATH = camera_path(0.008)
 
         for frame in range(0, NUMBER_OF_FRAMES):
-            bpy.context.scene.frame_set(frame)
+            SCENE.frame_set(frame)
             animation_routine(frame - 1)
-            for obj in context.scene.objects:
-                obj.keyframe_insert(data_path="rotation_euler", index=-1)
-                obj.keyframe_insert(data_path="location", index=-1)
-        bpy.ops.screen.frame_jump(end=False)
+            add_frame()
         shoot(output_name(model_path))
 
     else:
@@ -127,8 +125,8 @@ if debug == False:
         for index in range(0, int(shots_number)):
             print("-------------------------- " + str(index) + " --------------------------")
             still_routine(index)
+            SCENE.frame_set(int(SCENE.frame_end/(index+1)))
             look_at(SUBJECT)
-            bpy.context.scene.frame_set(int(context.scene.frame_end/(index+1)))
             shoot(output_name(model_path, index))
 
 

data/lib/glitch3d/bpy/render_settings.py

@@ -1,26 +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
+def render_settings(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'
+    # 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'
+        SCENE.render.image_settings.file_format='AVI_RAW'
     else:
-        scene.render.image_settings.file_format='PNG'
+        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
+        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.3.2'
+  VERSION = '0.2.3.3'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: glitch3d
 version: !ruby/object:Gem::Version
-  version: 0.2.3.2
+  version: 0.2.3.3
 platform: ruby
 authors:
 - pskl
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-10-23 00:00:00.000000000 Z
+date: 2017-11-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -106,8 +106,10 @@ files:
 - fixtures/textures/kago.jpg
 - fixtures/textures/kawai.jpg
 - fixtures/textures/rug.jpg
+- fixtures/textures/slavs.jpg
 - fixtures/textures/spiral.jpg
 - fixtures/textures/vapor.jpg
+- fixtures/textures/woman.jpg
 - glitch3d.gemspec
 - image.py
 - lib/glitch3d.rb