Cube Art

import bpy
import pdb
import random
import math
from math import sin, cos, radians
from bpy.props import *
class MyOperator(bpy.types.Operator):
""" for cube art """
bl_idname = "object.my_operator"
bl_label = "My cube art operator"
bl_options = {'REGISTER', 'UNDO'}
# properties
spacing : FloatProperty(
name="Spacing",
description="Spacing between cubes",
default=2.1,
min=0,
max=7.0
)
cube_count : IntProperty(
name="cube count",
description="A number of cubes",
default=25,
min=1,
max=100
)
width_of_spiral : FloatProperty(
name="Width of spiral",
description="Width of the spiral",
default=1,
min=0,
max=999.0
)
height_of_spiral : FloatProperty(
name="Height of spiral",
description="Height of the spiral",
default=1,
min=0.1,
max=999.0
)
def spiral_equation( self, t ):

""" returns (x, y, z) coordinates of a spiral """
x = self.width_of_spiral*cos(t) * self.spacing
y = self.width_of_spiral*sin(t) * self.spacing
z = self.height_of_spiral*t * self.spacing
return (x, y, z)
def generate_random_bright_color():
""" generates random bright color """
# Generate random RGB values between 0 and 1
r = random.random()
g = random.random()
b = random.random()
# Increase brightness by setting the maximum channel value to 1

max_val = max(r, g, b)
r /= max_val
g /= max_val
b /= max_val
return (r, g, b)
def get_material( self, input_name ,input_color ):

""" Creates material if doesn't exist """
material = bpy.data.materials.get(input_name)
if material is None:
material = bpy.data.materials.new(name=input_name)
material.diffuse_color = input_color
return material
def spawn_art( self, collecion_name ):

""" creates a cubes and lights art """
art_collection = bpy.data.collections.new(collecion_name) # create a
collection
bpy.context.scene.collection.children.link(art_collection) # child of the
scene collection
material_1 = self.get_material("Material.001", (0, .905, .702)) # RGB

values for #00E7B3
material_2 = self.get_material("Material.002", (.098, .216, .247)) # RGB
values for #18383F
for t in range(0, self.cube_count):

# agle = radians( random.randint(0, 360) )
# for x in range(5):
# z = abs( sin(agle) * 4) * random.random() * 1.2
coor = self.spiral_equation(t)
# Create a cube object

bpy.ops.mesh.primitive_cube_add(size=2, location=coor)
cube_object = bpy.context.object
# Unlink the cube from the Scene collection

bpy.context.collection.objects.unlink(cube_object)
# Assign the cube to current collection
art_collection.objects.link(cube_object)
# Assign a random material to the cube

if random.random() < 0.33:
cube_object.data.materials.append(material_1)
else:
cube_object.data.materials.append(material_2)
# agle += radians(9*1)
def remove_collection(collection_name):
pdb.set_trace()
# Get the collection
collection = bpy.data.collections.get(collection_name)
if collection is not None:

# Delete objects in the collection
for obj in collection.objects:
bpy.data.objects.remove(obj, do_unlink=True)
# Delete lights in the collection (not Main lights)
lights_to_remove = [obj for obj in bpy.data.objects if obj.type ==
'LIGHT' and not obj.name.startswith("Main_light")]
for light_obj in lights_to_remove:
bpy.data.lights.remove(light_obj.data, do_unlink=True)
bpy.data.objects.remove(light_obj, do_unlink=True)
# Unlink and remove the collection

bpy.data.collections.remove(collection, do_unlink=True)
def execute(self, context):

# self.remove_collection("Art")
self.spawn_art("Art")
return {'FINISHED'}
def menu_func(self, context):

self.layout.operator(MyOperator.bl_idname, text=MyOperator.bl_label)
# Register and add to the "object" menu (required to also use F3 search "Simple
Object Operator" for quick access).
def register():
bpy.utils.register_class(MyOperator)
bpy.types.VIEW3D_MT_object.append(menu_func)
def unregister():
bpy.utils.unregister_class(MyOperator)
bpy.types.VIEW3D_MT_object.remove(menu_func)
if __name__ == "__main__":
register()
# test call
bpy.ops.object.my_operator()
import bpy
import random
SPACING = 2
def delete_cylinders():
# Iterate over all objects in the scene
for obj in bpy.context.scene.objects:
if obj.type == 'MESH' and obj.data.name.startswith('Cylinder'):
bpy.data.objects.remove(obj, do_unlink=True)
def rock_chunk(x_s , y_s , z_s):

hexagons = []
for x in range(2):
for y in range(15):
loc = (x_s + x * SPACING, y_s + y * SPACING, random.random() * 2 +
z_s)
bpy.ops.mesh.primitive_cylinder_add( location=loc, scale=(1, 1, 9),
vertices = 6)
if (y + 1) % 10:
loc = location=(x_s + x * SPACING, y_s + y * SPACING,
random.random() * 2 +z_s)
bpy.ops.mesh.primitive_cylinder_add( location=loc, scale=(1, 1, 9),
vertices = 6)
hexagon = bpy.context.object
hexagons.append(hexagon)
bpy.ops.object.select_all(action='DESELECT')
if hexagons is not []:
for hexagon in hexagons:
hexagon.select_set(True)
bpy.context.view_layer.objects.active = hexagons[0]
bpy.ops.object.join()
dal = 50
delete_cylinders()
for y in range(4):
rock_chunk(5 , y*dal , 0)
rock_chunk(-5 , y*dal , 0)
rock_chunk(4 , y*dal , -15)

rock_chunk(-4 , y*dal , -15)

rock_chunk(3 , 5+y*dal, -20)

rock_chunk(-3, 5+y*dal, -20)

Cube Art

Uploaded by

Copyright:

Available Formats

Cube Art

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Cube Art

Uploaded by

Copyright:

Available Formats

import bpy

def spiral_equation( self, t ):

# Increase brightness by setting the maximum channel value to 1

def get_material( self, input_name ,input_color ):

def spawn_art( self, collecion_name ):

material_1 = self.get_material("Material.001", (0, .905, .702)) # RGB

for t in range(0, self.cube_count):

# Create a cube object

# Unlink the cube from the Scene collection

# Assign a random material to the cube

if collection is not None:

# Unlink and remove the collection

def execute(self, context):

def menu_func(self, context):

def rock_chunk(x_s , y_s , z_s):

rock_chunk(4 , y*dal , -15)

rock_chunk(3 , y*dal , 20)

rock_chunk(3 , 5+y*dal, -20)

You might also like