glitch3d 0.2.2.8 → 0.2.2.9

data/image.py

@@ -0,0 +1,32 @@
+# Make a mosaic with images
+import sys
+import os
+from PIL import Image
+
+RES_X = 5000
+RES_Y = 5000
+path = './renders/'
+files = [path + f for f in os.listdir(path) if os.path.isfile(os.path.join(path, f))]
+images = map(Image.open, files)
+widths, heights = zip(*(i.size for i in images))
+
+total_width = images[0].size[0] * 4
+total_height = total_width
+
+res = Image.new('RGB', (total_height,total_width))
+print('stitching ' + str(len(files)) + ' images')
+
+x_offset = 0
+y_offset = 0
+for file in files:
+    print(file)
+    image = Image.open(file)
+    print(image.size)
+    res.paste(image, (x_offset, y_offset))
+    x_offset += image.size[0]
+    if x_offset > total_width:
+      print('reset')
+      y_offset += image.size[1]
+      x_offset = 0
+
+res.save('./mosaic.png')

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

@@ -0,0 +1,33 @@
+######################
+## FLUID SIMULATION ##
+######################
+animate = True
+context.scene.frame_end = NUMBER_OF_FRAMES
+
+# Container
+bpy.ops.mesh.primitive_cube_add(location=(0, 0, -0.4),radius=7)
+container = bpy.data.objects['Cube']
+container.name = 'Container'
+container.modifiers.new(name='container', type='FLUID_SIMULATION')
+container.modifiers['container'].settings.type = 'DOMAIN'
+container.modifiers['container'].settings.generate_particles = 1
+make_object_gradient_fabulous(container, rand_color(), rand_color())
+container.location = (0, 0, 7)
+
+# Emitter of fluid
+bpy.ops.mesh.primitive_uv_sphere_add(location=(0,0,10))
+emitter = bpy.data.objects['Sphere']
+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.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.surface_subdivisions = 6
+SUBJECT.modifiers['obstacle'].settings.partial_slip_factor = 0.15
+
+# Bake animation
+bpy.ops.fluid.bake({'scene': context.scene, 'active_object': container})

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

@@ -48,10 +48,11 @@ texture_object(floor)
 OCEAN = add_ocean(10, 20)
 
 # Create lines as backdrop
-bpy.data.groups.new('Lines')
+LINES = bpy.data.groups['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))
+        bpy.data.groups['Lines'].objects.link(new_line)
         new_line.location.z += i / 3
 
 # Add flying letters, lmao

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

@@ -0,0 +1,62 @@
+# Game of life inspired scene
+w = 40
+f = 1
+bpy.ops.anim.change_frame( frame = f )
+
+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[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 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
+            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)
+            else:
+                #row += '.'
+                cubes[x][y].scale=(.1,.1,.1)
+            bpy.ops.anim.keyframe_insert_menu( type='Scaling')
+
+    for x in range( w ):
+        for y in range(w):
+            cells[x][y] = nextGen[x][y]

data/lib/glitch3d/bpy/helpers.py

@@ -1,6 +1,3 @@
-# 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)
@@ -20,8 +17,6 @@ GREY = (0.2, 0.2, 0.2 ,1)
 BLUE = (0.1, 0.1, 0.8, 1)
 PINK = (0.8, 0.2, 0.7, 1.0)
 WORDS = string.ascii_lowercase
-WIREFRAMES = []
-VORONOIED = []
 
 def debug():
     code.interact(local=dict(globals(), **locals()))
@@ -46,14 +41,14 @@ def shoot(filepath):
         return bpy.ops.render.render(animation=animate, write_still=True)
     bpy.ops.render.render(write_still=True)
 
-def output_name(index, model_path):
-    if animate == True:
+def output_name(model_path, index = 0):
+    if animate:
         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(SUBJECT, index):
-    SUBJECT.rotation_euler[2] = math.radians(index * (360.0 / shots_number))
+def rotate(model_object, index):
+    model_object.rotation_euler.z = math.radians(index * (360.0 / shots_number))
 
 # RGB 0 -> 1
 def rand_color_value():
@@ -204,11 +199,10 @@ def duplicate_object(obj):
 
 def random_text():
     global WORDS
-    chosen_word = random.choice(WORDS)
-    return chosen_word
+    return random.choice(WORDS)
 
 def create_mesh(name, verts, faces, location):
-    mesh_data = bpy.data.meshes.new("cube_mesh_data")
+    mesh_data = bpy.data.meshes.new("mesh_data")
     mesh_data.from_pydata(verts, [], faces)
     mesh_data.update()
     obj = bpy.data.objects.new(name, mesh_data)
@@ -219,7 +213,7 @@ def create_mesh(name, verts, faces, location):
 def spawn_text():
     identifier = str(uuid.uuid1())
     new_curve = bpy.data.curves.new(type="FONT",name="Curve - " + identifier)
-    new_curve.extrude = 0.12
+    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)
@@ -329,20 +323,19 @@ def clone(obj):
     context.scene.objects.link(new_obj)
     return new_obj
 
-def add_ocean(spatial_size, resolution):
-    bpy.ops.mesh.primitive_cube_add(location=(0, 0, -1),radius=1)
+def add_ocean(spatial_size, resolution, depth = 100, scale=(4,4,4)):
+    bpy.ops.mesh.primitive_cube_add(location=(0, 0, -0.4),radius=1)
     ocean = last_added_object('CUBE')
-    context.scene.objects.active = ocean
-    ocean.scale = (2,2,2)
-    bpy.ops.object.modifier_add(type='OCEAN')
+    ocean.scale = scale
+    ocean.modifiers.new(name='Ocean', type='OCEAN')
     ocean.modifiers["Ocean"].spatial_size = spatial_size
     ocean.modifiers["Ocean"].resolution = resolution
+    ocean.modifiers["Ocean"].depth = depth
     make_object_glossy(ocean, rand_color())
     make_object_gradient_fabulous(ocean, rand_color(), rand_color())
     mix_nodes(ocean.data.materials[0], ocean.data.materials[0].node_tree.nodes['Diffuse BSDF'], ocean.data.materials[0].node_tree.nodes['Glossy BSDF'])
     shadow = clone(ocean)
-    shadow.location.x += 2
-    shadow.location.y += 1
+    shadow.location += mathutils.Vector((1,1,-0.4))
     wireframize(shadow)
     shadow.name = 'shadow'
     ocean.name = 'ocean'
@@ -387,11 +380,14 @@ def build_pyramid(width=random.uniform(1,3), length=random.uniform(1,3), height=
     return create_mesh('Pyramid ' + str(uuid.uuid1()), verts, faces, location)
 
 def move_ocean(ocean):
-    ocean.modifiers['Ocean'].time += 1.5
+    if animate:
+        ocean.modifiers['Ocean'].time += 0.01
+    else:
+        ocean.modifiers['Ocean'].time += 2
     ocean.modifiers['Ocean'].random_seed = round(random.uniform(0, 100))
-    ocean.modifers['Ocean'].choppiness += 0.3
+    ocean.modifers['Ocean'].choppiness += random.uniform(0, 1.15)
 
-def camera_path(pitch = 0.0001):
+def camera_path(pitch = 0.01):
     res = []
     initial_z = INITIAL_CAMERA_LOCATION[2]
     initial_x = INITIAL_CAMERA_LOCATION[0]
@@ -405,16 +401,17 @@ def camera_path(pitch = 0.0001):
         res.append((x, initial_x, initial_z))
     return res
 
-def pitched_array(min, max, pitch):
-    return list(map(lambda x: (min + pitch * x), range(int((max - min) / pitch))))
+def pitched_array(minimum, maximum, pitch):
+    return list(map(lambda x: (minimum + pitch * x), range(int((maximum - minimum) / pitch))))
 
-def still_routine():
+def still_routine(index = 1):
     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()
     map(move_ocean, OCEAN)
     map(make_object_glossy, OCEAN)
     rotate(SUBJECT, index)
+    CAMERA.rotation_euler.y += math.radians(round(random.uniform(-30, +30)))
     for l in bpy.data.groups['Lines'].objects:
         rotation = rand_rotation()
         l.rotation_euler = rotation
@@ -422,31 +419,35 @@ def still_routine():
         prop.location = rand_location()
         prop.rotation_euler = rand_rotation()
     for obj in WIREFRAMES:
-        obj.location = rand_location()
+        # obj.location = rand_location()
+        obj.location += mathutils.Vector((1,1,1))
         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]
+    assert len(CAMERA_PATH) >= NUMBER_OF_FRAMES
+    CAMERA.location = CAMERA_PATH[frame]
     look_at(SUBJECT)
     randomize_reflectors_colors()
-    map(move_ocean, OCEAN)
-    map(make_object_glossy, OCEAN)
+    if OCEAN:
+        map(move_ocean, OCEAN)
+        map(make_object_glossy, OCEAN)
     glitch(SUBJECT)
     SUBJECT.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)
+    if props:
+        for prop in props:
+            prop.rotation_euler.x += math.radians(5)
+    if WIREFRAMES:
+        for obj in WIREFRAMES:
+            obj.location += mathutils.Vector((0.1, 0.1, 0.1))
+            obj.rotation_euler.rotate(mathutils.Euler((math.radians(2), math.radians(2), math.radians(5)), 'XYZ'))
+    # for display in bpy.data.groups['Displays'].objects:
+    #     display.rotation_euler.x += math.radians(2)
 
 def create_line(name, point_list, thickness = 0.002, location = (0, -10, 0)):
     # setup basic line data

data/lib/glitch3d/bpy/main.py

@@ -1,11 +1,11 @@
 # Rendering script
 # Run by calling the blender executable with -b -P <script_name>
 # Use `debug()` 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
 
-DEBUG=False
-
 def get_args():
     parser = argparse.ArgumentParser()
     # get all script args
@@ -28,7 +28,11 @@ path = str(args.path)
 animate = (args.animate == 'True')
 shots_number = int(args.shots_number)
 
-import os, bpy, datetime, bmesh, random, math, mathutils, random, uuid, sys, logging, string, colorsys, code
+#####################################
+#####################################
+#####################################
+
+import os, bpy, datetime, random, math, mathutils, random, uuid, sys, logging, string, colorsys, code
 
 # Create directory for renders
 directory = os.path.dirname('./renders')
@@ -39,6 +43,15 @@ 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())
 
+# Create groups
+WIREFRAMES = []
+VORONOIED = []
+OCEAN = []
+bpy.data.groups.new('Lines')
+LINES = bpy.data.groups['Lines'].objects
+for primitive in PRIMITIVES:
+    bpy.data.groups.new(primitive.lower().title())
+
 FISHEYE = True
 COLORS = rand_color_palette(5)
 INITIAL_CAMERA_LOCATION = (3, 3, 1)
@@ -70,10 +83,6 @@ if FISHEYE:
 
 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)
@@ -81,21 +90,25 @@ SUBJECT = bpy.data.objects['glitch3d']
 SUBJECT.select = True
 bpy.ops.object.origin_set(type="ORIGIN_CENTER_OF_MASS")
 SUBJECT.location = ORIGIN
-make_object_glossy(SUBJECT, YELLOW, 0.1)
-voronoize(SUBJECT)
+make_object_glossy(SUBJECT, YELLOW, 0.01)
+# voronoize(SUBJECT)
 
 let_there_be_light(context.scene)
 
 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))
 
+for plane in bpy.data.groups['Plane'].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)
-    camera_path = camera_path(0.08)
+    CAMERA_PATH = camera_path(0.008)
 
     for frame in range(0, NUMBER_OF_FRAMES):
         bpy.context.scene.frame_set(frame)
@@ -104,15 +117,15 @@ if animate:
             obj.keyframe_insert(data_path="rotation_euler", index=-1)
             obj.keyframe_insert(data_path="location", index=-1)
     bpy.ops.screen.frame_jump(end=False)
-    shoot(output_name(index, model_path))
+    shoot(output_name(model_path))
 
 else:
     print('STILL RENDERING BEGIN')
     for index in range(0, int(shots_number)):
         print("-------------------------- " + str(index) + " --------------------------")
-        still_routine()
+        still_routine(index)
         look_at(SUBJECT)
-        shoot(output_name(index, model_path))
+        shoot(output_name(model_path, index))
 
 
 print('FINISHED ¯\_(ツ)_/¯')

data/lib/glitch3d/strategies/default.rb

@@ -9,9 +9,6 @@ module Glitch3d
     end
 
     def alter_faces(faces_objects_array, vertex_objects_array)
-      # (FACE_GLITCH_ITERATION_RATIO * faces_objects_array.count).to_i.times do |_|
-      #   random_element(faces_objects_array).fuck(random_element(vertex_objects_array))
-      # end
       faces_objects_array
     end
   end

data/lib/glitch3d/strategies/find_and_replace.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 module Glitch3d
   module FindAndReplace
-    # Find and replace for vertices
     def alter_vertices(vertices_objects_array)
       @target = rand(9).to_s
       @replacement = rand(9).to_s
@@ -11,7 +10,6 @@ module Glitch3d
       vertices_objects_array
     end
 
-    # Assign some faces to different vertices
     def alter_faces(faces_objects_array, vertices_objects_array)
       faces_objects_array.sample(3) do |face|
         face.v1 = rand(0..vertices_objects_array.size - 1)

data/lib/glitch3d/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: glitch3d
 version: !ruby/object:Gem::Version
-  version: 0.2.2.8
+  version: 0.2.2.9
 platform: ruby
 authors:
 - pskl
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-10-12 00:00:00.000000000 Z
+date: 2017-10-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -89,8 +89,8 @@ files:
 - bin/setup
 - fixtures/brain.obj
 - fixtures/cube.obj
-- fixtures/dude.jpg
 - fixtures/face.obj
+- fixtures/hand.obj
 - fixtures/m4a1.obj
 - fixtures/male_head.obj
 - fixtures/mars.obj
@@ -99,7 +99,9 @@ files:
 - fixtures/textures/afx_face.jpeg
 - fixtures/textures/afx_logo.jpg
 - fixtures/textures/anime.jpg
+- fixtures/textures/btc.jpg
 - fixtures/textures/checkered_texture.jpg
+- fixtures/textures/dude.jpg
 - fixtures/textures/grid.jpg
 - fixtures/textures/kago.jpg
 - fixtures/textures/kawai.jpg
@@ -107,8 +109,11 @@ files:
 - fixtures/textures/spiral.jpg
 - fixtures/textures/vapor.jpg
 - glitch3d.gemspec
+- image.py
 - lib/glitch3d.rb
+- lib/glitch3d/bpy/canvas/aether.py
 - lib/glitch3d/bpy/canvas/dreamatorium.py
+- lib/glitch3d/bpy/canvas/lyfe.py
 - lib/glitch3d/bpy/helpers.py
 - lib/glitch3d/bpy/lighting.py
 - lib/glitch3d/bpy/main.py