kopia lustrzana https://github.com/a1studmuffin/SpaceshipGenerator
820 wiersze
34 KiB
Python
820 wiersze
34 KiB
Python
#
|
|
# spaceship_generator.py
|
|
#
|
|
# This is a Blender script that uses procedural generation to create
|
|
# textured 3D spaceship models. Tested with Blender 2.77a.
|
|
#
|
|
# michael@spaceduststudios.com
|
|
# https://github.com/a1studmuffin/SpaceshipGenerator
|
|
#
|
|
|
|
import sys
|
|
import os
|
|
import os.path
|
|
import bpy
|
|
import bmesh
|
|
import datetime
|
|
from math import sqrt, radians, pi, cos, sin
|
|
from mathutils import Vector, Matrix
|
|
from random import random, seed, uniform, randint, randrange
|
|
from enum import IntEnum
|
|
from colorsys import hls_to_rgb
|
|
|
|
DIR = os.path.dirname(os.path.abspath(__file__))
|
|
|
|
def resource_path(*path_components):
|
|
return os.path.join(DIR, *path_components)
|
|
|
|
# Deletes all existing spaceships and unused materials from the scene
|
|
def reset_scene():
|
|
for item in bpy.data.objects:
|
|
item.select = item.name.startswith('Spaceship')
|
|
bpy.ops.object.delete()
|
|
for material in bpy.data.materials:
|
|
if not material.users:
|
|
bpy.data.materials.remove(material)
|
|
for texture in bpy.data.textures:
|
|
if not texture.users:
|
|
bpy.data.textures.remove(texture)
|
|
|
|
# Extrudes a face along its normal by translate_forwards units.
|
|
# Returns the new face, and optionally fills out extruded_face_list
|
|
# with all the additional side faces created from the extrusion.
|
|
def extrude_face(bm, face, translate_forwards=0.0, extruded_face_list=None):
|
|
new_faces = bmesh.ops.extrude_discrete_faces(bm, faces=[face])['faces']
|
|
if extruded_face_list != None:
|
|
extruded_face_list += new_faces[:]
|
|
new_face = new_faces[0]
|
|
bmesh.ops.translate(bm,
|
|
vec=new_face.normal * translate_forwards,
|
|
verts=new_face.verts)
|
|
return new_face
|
|
|
|
# Similar to extrude_face, except corrigates the geometry to create "ribs".
|
|
# Returns the new face.
|
|
def ribbed_extrude_face(bm, face, translate_forwards, num_ribs=3, rib_scale=0.9):
|
|
translate_forwards_per_rib = translate_forwards / float(num_ribs)
|
|
new_face = face
|
|
for i in range(num_ribs):
|
|
new_face = extrude_face(bm, new_face, translate_forwards_per_rib * 0.25)
|
|
new_face = extrude_face(bm, new_face, 0.0)
|
|
scale_face(bm, new_face, rib_scale, rib_scale, rib_scale)
|
|
new_face = extrude_face(bm, new_face, translate_forwards_per_rib * 0.5)
|
|
new_face = extrude_face(bm, new_face, 0.0)
|
|
scale_face(bm, new_face, 1 / rib_scale, 1 / rib_scale, 1 / rib_scale)
|
|
new_face = extrude_face(bm, new_face, translate_forwards_per_rib * 0.25)
|
|
return new_face
|
|
|
|
# Scales a face in local face space. Ace!
|
|
def scale_face(bm, face, scale_x, scale_y, scale_z):
|
|
face_space = get_face_matrix(face)
|
|
face_space.invert()
|
|
bmesh.ops.scale(bm,
|
|
vec=Vector((scale_x, scale_y, scale_z)),
|
|
space=face_space,
|
|
verts=face.verts)
|
|
|
|
# Returns a rough 4x4 transform matrix for a face (doesn't handle
|
|
# distortion/shear) with optional position override.
|
|
def get_face_matrix(face, pos=None):
|
|
x_axis = (face.verts[1].co - face.verts[0].co).normalized()
|
|
z_axis = -face.normal
|
|
y_axis = z_axis.cross(x_axis)
|
|
if not pos:
|
|
pos = face.calc_center_bounds()
|
|
|
|
# Construct a 4x4 matrix from axes + position:
|
|
# http://i.stack.imgur.com/3TnQP.png
|
|
mat = Matrix()
|
|
mat[0][0] = x_axis.x
|
|
mat[1][0] = x_axis.y
|
|
mat[2][0] = x_axis.z
|
|
mat[3][0] = 0
|
|
mat[0][1] = y_axis.x
|
|
mat[1][1] = y_axis.y
|
|
mat[2][1] = y_axis.z
|
|
mat[3][1] = 0
|
|
mat[0][2] = z_axis.x
|
|
mat[1][2] = z_axis.y
|
|
mat[2][2] = z_axis.z
|
|
mat[3][2] = 0
|
|
mat[0][3] = pos.x
|
|
mat[1][3] = pos.y
|
|
mat[2][3] = pos.z
|
|
mat[3][3] = 1
|
|
return mat
|
|
|
|
# Returns the rough length and width of a quad face.
|
|
# Assumes a perfect rectangle, but close enough.
|
|
def get_face_width_and_height(face):
|
|
if not face.is_valid or len(face.verts[:]) < 4:
|
|
return -1, -1
|
|
width = (face.verts[0].co - face.verts[1].co).length
|
|
height = (face.verts[2].co - face.verts[1].co).length
|
|
return width, height
|
|
|
|
# Returns the rough aspect ratio of a face. Always >= 1.
|
|
def get_aspect_ratio(face):
|
|
if not face.is_valid:
|
|
return 1.0
|
|
face_aspect_ratio = max(0.01, face.edges[0].calc_length() / face.edges[1].calc_length())
|
|
if face_aspect_ratio < 1.0:
|
|
face_aspect_ratio = 1.0 / face_aspect_ratio
|
|
return face_aspect_ratio
|
|
|
|
# Returns true if this face is pointing behind the ship
|
|
def is_rear_face(face):
|
|
return face.normal.x < -0.95
|
|
|
|
# Given a face, splits it into a uniform grid and extrudes each grid face
|
|
# out and back in again, making an exhaust shape.
|
|
def add_exhaust_to_face(bm, face):
|
|
if not face.is_valid:
|
|
return
|
|
|
|
# The more square the face is, the more grid divisions it might have
|
|
num_cuts = randint(1, int(4 - get_aspect_ratio(face)))
|
|
result = bmesh.ops.subdivide_edges(bm,
|
|
edges=face.edges[:],
|
|
cuts=num_cuts,
|
|
fractal=0.02,
|
|
use_grid_fill=True)
|
|
|
|
exhaust_length = uniform(0.1, 0.2)
|
|
scale_outer = 1 / uniform(1.3, 1.6)
|
|
scale_inner = 1 / uniform(1.05, 1.1)
|
|
for face in result['geom']:
|
|
if isinstance(face, bmesh.types.BMFace):
|
|
if is_rear_face(face):
|
|
face.material_index = Material.hull_dark
|
|
face = extrude_face(bm, face, exhaust_length)
|
|
scale_face(bm, face, scale_outer, scale_outer, scale_outer)
|
|
extruded_face_list = []
|
|
face = extrude_face(bm, face, -exhaust_length * 0.9, extruded_face_list)
|
|
for extruded_face in extruded_face_list:
|
|
extruded_face.material_index = Material.exhaust_burn
|
|
scale_face(bm, face, scale_inner, scale_inner, scale_inner)
|
|
|
|
# Given a face, splits it up into a smaller uniform grid and extrudes each grid cell.
|
|
def add_grid_to_face(bm, face):
|
|
if not face.is_valid:
|
|
return
|
|
result = bmesh.ops.subdivide_edges(bm,
|
|
edges=face.edges[:],
|
|
cuts=randint(2, 4),
|
|
fractal=0.02,
|
|
use_grid_fill=True,
|
|
use_single_edge=False)
|
|
grid_length = uniform(0.025, 0.15)
|
|
scale = 0.8
|
|
for face in result['geom']:
|
|
if isinstance(face, bmesh.types.BMFace):
|
|
material_index = Material.hull_lights if random() > 0.5 else Material.hull
|
|
extruded_face_list = []
|
|
face = extrude_face(bm, face, grid_length, extruded_face_list)
|
|
for extruded_face in extruded_face_list:
|
|
if abs(face.normal.z) < 0.707: # side face
|
|
extruded_face.material_index = material_index
|
|
scale_face(bm, face, scale, scale, scale)
|
|
|
|
# Given a face, adds some cylinders along it in a grid pattern.
|
|
def add_cylinders_to_face(bm, face):
|
|
if not face.is_valid or len(face.verts[:]) < 4:
|
|
return
|
|
horizontal_step = randint(1, 3)
|
|
vertical_step = randint(1, 3)
|
|
num_segments = randint(6, 12)
|
|
face_width, face_height = get_face_width_and_height(face)
|
|
cylinder_depth = 1.3 * min(face_width / (horizontal_step + 2),
|
|
face_height / (vertical_step + 2))
|
|
cylinder_size = cylinder_depth * 0.5
|
|
for h in range(horizontal_step):
|
|
top = face.verts[0].co.lerp(
|
|
face.verts[1].co, (h + 1) / float(horizontal_step + 1))
|
|
bottom = face.verts[3].co.lerp(
|
|
face.verts[2].co, (h + 1) / float(horizontal_step + 1))
|
|
for v in range(vertical_step):
|
|
pos = top.lerp(bottom, (v + 1) / float(vertical_step + 1))
|
|
cylinder_matrix = get_face_matrix(face, pos) @ \
|
|
Matrix.Rotation(radians(90), 3, 'X').to_4x4()
|
|
bmesh.ops.create_cone(bm,
|
|
cap_ends=True,
|
|
cap_tris=False,
|
|
segments=num_segments,
|
|
diameter1=cylinder_size,
|
|
diameter2=cylinder_size,
|
|
depth=cylinder_depth,
|
|
matrix=cylinder_matrix)
|
|
|
|
# Given a face, adds some weapon turrets to it in a grid pattern.
|
|
# Each turret will have a random orientation.
|
|
def add_weapons_to_face(bm, face):
|
|
if not face.is_valid or len(face.verts[:]) < 4:
|
|
return
|
|
horizontal_step = randint(1, 2)
|
|
vertical_step = randint(1, 2)
|
|
num_segments = 16
|
|
face_width, face_height = get_face_width_and_height(face)
|
|
weapon_size = 0.5 * min(face_width / (horizontal_step + 2),
|
|
face_height / (vertical_step + 2))
|
|
weapon_depth = weapon_size * 0.2
|
|
for h in range(horizontal_step):
|
|
top = face.verts[0].co.lerp(
|
|
face.verts[1].co, (h + 1) / float(horizontal_step + 1))
|
|
bottom = face.verts[3].co.lerp(
|
|
face.verts[2].co, (h + 1) / float(horizontal_step + 1))
|
|
for v in range(vertical_step):
|
|
pos = top.lerp(bottom, (v + 1) / float(vertical_step + 1))
|
|
face_matrix = get_face_matrix(face, pos + face.normal * weapon_depth * 0.5) @ \
|
|
Matrix.Rotation(radians(uniform(0, 90)), 3, 'Z').to_4x4()
|
|
|
|
# Turret foundation
|
|
bmesh.ops.create_cone(bm,
|
|
cap_ends=True,
|
|
cap_tris=False,
|
|
segments=num_segments,
|
|
diameter1=weapon_size * 0.9,
|
|
diameter2=weapon_size,
|
|
depth=weapon_depth,
|
|
matrix=face_matrix)
|
|
|
|
# Turret left guard
|
|
left_guard_mat = face_matrix @ \
|
|
Matrix.Rotation(radians(90), 3, 'Y').to_4x4() @ \
|
|
Matrix.Translation(Vector((0, 0, weapon_size * 0.6))).to_4x4()
|
|
bmesh.ops.create_cone(bm,
|
|
cap_ends=True,
|
|
cap_tris=False,
|
|
segments=num_segments,
|
|
diameter1=weapon_size * 0.6,
|
|
diameter2=weapon_size * 0.5,
|
|
depth=weapon_depth * 2,
|
|
matrix=left_guard_mat)
|
|
|
|
# Turret right guard
|
|
right_guard_mat = face_matrix @ \
|
|
Matrix.Rotation(radians(90), 3, 'Y').to_4x4() @ \
|
|
Matrix.Translation(Vector((0, 0, weapon_size * -0.6))).to_4x4()
|
|
bmesh.ops.create_cone(bm,
|
|
cap_ends=True,
|
|
cap_tris=False,
|
|
segments=num_segments,
|
|
diameter1=weapon_size * 0.5,
|
|
diameter2=weapon_size * 0.6,
|
|
depth=weapon_depth * 2,
|
|
matrix=right_guard_mat)
|
|
|
|
# Turret housing
|
|
upward_angle = uniform(0, 45)
|
|
turret_house_mat = face_matrix @ \
|
|
Matrix.Rotation(radians(upward_angle), 3, 'X').to_4x4() @ \
|
|
Matrix.Translation(Vector((0, weapon_size * -0.4, 0))).to_4x4()
|
|
bmesh.ops.create_cone(bm,
|
|
cap_ends=True,
|
|
cap_tris=False,
|
|
segments=8,
|
|
diameter1=weapon_size * 0.4,
|
|
diameter2=weapon_size * 0.4,
|
|
depth=weapon_depth * 5,
|
|
matrix=turret_house_mat)
|
|
|
|
# Turret barrels L + R
|
|
bmesh.ops.create_cone(bm,
|
|
cap_ends=True,
|
|
cap_tris=False,
|
|
segments=8,
|
|
diameter1=weapon_size * 0.1,
|
|
diameter2=weapon_size * 0.1,
|
|
depth=weapon_depth * 6,
|
|
matrix=turret_house_mat @ \
|
|
Matrix.Translation(Vector((weapon_size * 0.2, 0, -weapon_size))).to_4x4())
|
|
bmesh.ops.create_cone(bm,
|
|
cap_ends=True,
|
|
cap_tris=False,
|
|
segments=8,
|
|
diameter1=weapon_size * 0.1,
|
|
diameter2=weapon_size * 0.1,
|
|
depth=weapon_depth * 6,
|
|
matrix=turret_house_mat @ \
|
|
Matrix.Translation(Vector((weapon_size * -0.2, 0, -weapon_size))).to_4x4())
|
|
|
|
# Given a face, adds a sphere on the surface, partially inset.
|
|
def add_sphere_to_face(bm, face):
|
|
if not face.is_valid:
|
|
return
|
|
face_width, face_height = get_face_width_and_height(face)
|
|
sphere_size = uniform(0.4, 1.0) * min(face_width, face_height)
|
|
sphere_matrix = get_face_matrix(face,
|
|
face.calc_center_bounds() - face.normal * \
|
|
uniform(0, sphere_size * 0.5))
|
|
result = bmesh.ops.create_icosphere(bm,
|
|
subdivisions=3,
|
|
diameter=sphere_size,
|
|
matrix=sphere_matrix)
|
|
for vert in result['verts']:
|
|
for face in vert.link_faces:
|
|
face.material_index = Material.hull
|
|
|
|
# Given a face, adds some pointy intimidating antennas.
|
|
def add_surface_antenna_to_face(bm, face):
|
|
if not face.is_valid or len(face.verts[:]) < 4:
|
|
return
|
|
horizontal_step = randint(4, 10)
|
|
vertical_step = randint(4, 10)
|
|
for h in range(horizontal_step):
|
|
top = face.verts[0].co.lerp(
|
|
face.verts[1].co, (h + 1) / float(horizontal_step + 1))
|
|
bottom = face.verts[3].co.lerp(
|
|
face.verts[2].co, (h + 1) / float(horizontal_step + 1))
|
|
for v in range(vertical_step):
|
|
if random() > 0.9:
|
|
pos = top.lerp(bottom, (v + 1) / float(vertical_step + 1))
|
|
face_size = sqrt(face.calc_area())
|
|
depth = uniform(0.1, 1.5) * face_size
|
|
depth_short = depth * uniform(0.02, 0.15)
|
|
base_diameter = uniform(0.005, 0.05)
|
|
|
|
material_index = Material.hull if random() > 0.5 else Material.hull_dark
|
|
|
|
# Spire
|
|
num_segments = uniform(3, 6)
|
|
result = bmesh.ops.create_cone(bm,
|
|
cap_ends=False,
|
|
cap_tris=False,
|
|
segments=num_segments,
|
|
diameter1=0,
|
|
diameter2=base_diameter,
|
|
depth=depth,
|
|
matrix=get_face_matrix(face, pos + face.normal * depth * 0.5))
|
|
for vert in result['verts']:
|
|
for vert_face in vert.link_faces:
|
|
vert_face.material_index = material_index
|
|
|
|
# Base
|
|
result = bmesh.ops.create_cone(bm,
|
|
cap_ends=True,
|
|
cap_tris=False,
|
|
segments=num_segments,
|
|
diameter1=base_diameter * uniform(1, 1.5),
|
|
diameter2=base_diameter * uniform(1.5, 2),
|
|
depth=depth_short,
|
|
matrix=get_face_matrix(face, pos + face.normal * depth_short * 0.45))
|
|
for vert in result['verts']:
|
|
for vert_face in vert.link_faces:
|
|
vert_face.material_index = material_index
|
|
|
|
# Given a face, adds a glowing "landing pad" style disc.
|
|
def add_disc_to_face(bm, face):
|
|
if not face.is_valid:
|
|
return
|
|
face_width, face_height = get_face_width_and_height(face)
|
|
depth = 0.125 * min(face_width, face_height)
|
|
bmesh.ops.create_cone(bm,
|
|
cap_ends=True,
|
|
cap_tris=False,
|
|
segments=32,
|
|
diameter1=depth * 3,
|
|
diameter2=depth * 4,
|
|
depth=depth,
|
|
matrix=get_face_matrix(face, face.calc_center_bounds() + face.normal * depth * 0.5))
|
|
result = bmesh.ops.create_cone(bm,
|
|
cap_ends=False,
|
|
cap_tris=False,
|
|
segments=32,
|
|
diameter1=depth * 1.25,
|
|
diameter2=depth * 2.25,
|
|
depth=0.0,
|
|
matrix=get_face_matrix(face, face.calc_center_bounds() + face.normal * depth * 1.05))
|
|
for vert in result['verts']:
|
|
for face in vert.link_faces:
|
|
face.material_index = Material.glow_disc
|
|
|
|
class Material(IntEnum):
|
|
hull = 0 # Plain spaceship hull
|
|
hull_lights = 1 # Spaceship hull with emissive windows
|
|
hull_dark = 2 # Plain Spaceship hull, darkened
|
|
exhaust_burn = 3 # Emissive engine burn material
|
|
glow_disc = 4 # Emissive landing pad disc material
|
|
|
|
|
|
# Returns shader node
|
|
def getShaderNode(mat):
|
|
ntree = mat.node_tree
|
|
node_out = ntree.get_output_node('EEVEE')
|
|
shader_node = node_out.inputs['Surface'].links[0].from_node
|
|
return shader_node
|
|
|
|
def getShaderInput(mat, name):
|
|
shaderNode = getShaderNode(mat)
|
|
return shaderNode.inputs[name]
|
|
|
|
# Adds a hull normal map texture slot to a material.
|
|
def add_hull_normal_map(mat, hull_normal_map):
|
|
ntree = mat.node_tree
|
|
shader = getShaderNode(mat)
|
|
links = ntree.links
|
|
|
|
teximage_node = ntree.nodes.new('ShaderNodeTexImage')
|
|
teximage_node.image = hull_normal_map
|
|
teximage_node.image.colorspace_settings.name = 'Raw'
|
|
teximage_node.projection ='BOX'
|
|
tex_coords_node = ntree.nodes.new('ShaderNodeTexCoord')
|
|
links.new(tex_coords_node.outputs['Object'], teximage_node.inputs['Vector'])
|
|
normalMap_node = ntree.nodes.new('ShaderNodeNormalMap')
|
|
links.new(teximage_node.outputs[0], normalMap_node.inputs['Color'])
|
|
links.new(normalMap_node.outputs['Normal'], shader.inputs['Normal'])
|
|
return tex_coords_node
|
|
|
|
|
|
|
|
# Sets some basic properties for a hull material.
|
|
def set_hull_mat_basics(mat, color, hull_normal_map):
|
|
shader_node = getShaderNode(mat)
|
|
shader_node.inputs["Specular"].default_value = 0.1
|
|
shader_node.inputs["Base Color"].default_value = color
|
|
|
|
return add_hull_normal_map(mat, hull_normal_map)
|
|
|
|
# Creates all our materials and returns them as a list.
|
|
def create_materials():
|
|
ret = []
|
|
|
|
for material in Material:
|
|
mat = bpy.data.materials.new(name=material.name)
|
|
mat.use_nodes = True
|
|
ret.append(mat)
|
|
|
|
# Choose a base color for the spaceship hull
|
|
hull_base_color = hls_to_rgb(
|
|
random(), uniform(0.05, 0.5), uniform(0, 0.25))
|
|
hull_base_color = (hull_base_color[0], hull_base_color[1], hull_base_color[2], 1.0)
|
|
|
|
# Load up the hull normal map
|
|
hull_normal_map = bpy.data.images.load(resource_path('textures', 'hull_normal.png'), check_existing=True)
|
|
|
|
|
|
# Build the hull texture
|
|
mat = ret[Material.hull]
|
|
set_hull_mat_basics(mat, hull_base_color, hull_normal_map)
|
|
|
|
# Build the hull_lights texture
|
|
mat = ret[Material.hull_lights]
|
|
tex_coords_node = set_hull_mat_basics(mat, hull_base_color, hull_normal_map)
|
|
ntree = mat.node_tree
|
|
shader_node = getShaderNode(mat)
|
|
links = ntree.links
|
|
|
|
# Add a diffuse layer that sets the window color
|
|
hull_lights_diffuse_map = bpy.data.images.load(resource_path('textures', 'hull_lights_diffuse.png'), check_existing=True)
|
|
teximage_diff_node = ntree.nodes.new('ShaderNodeTexImage')
|
|
teximage_diff_node.image = hull_lights_diffuse_map
|
|
teximage_diff_node.projection ='BOX'
|
|
links.new(tex_coords_node.outputs['Object'], teximage_diff_node.inputs['Vector'])
|
|
RGB_node = ntree.nodes.new('ShaderNodeRGB')
|
|
RGB_node.outputs[0].default_value = hull_base_color
|
|
mix_node = ntree.nodes.new('ShaderNodeMixRGB')
|
|
links.new(RGB_node.outputs[0], mix_node.inputs[1])
|
|
links.new(teximage_diff_node.outputs[0], mix_node.inputs[2])
|
|
links.new(teximage_diff_node.outputs[1], mix_node.inputs[0])
|
|
links.new(mix_node.outputs[0], shader_node.inputs["Base Color"])
|
|
|
|
|
|
|
|
# Add an emissive layer that lights up the windows
|
|
hull_lights_emessive_map = bpy.data.images.load(resource_path('textures', 'hull_lights_emit.png'), check_existing=True)
|
|
teximage_emit_node = ntree.nodes.new('ShaderNodeTexImage')
|
|
teximage_emit_node.image = hull_lights_emessive_map
|
|
teximage_emit_node.projection ='BOX'
|
|
links.new(tex_coords_node.outputs['Object'], teximage_emit_node.inputs['Vector'])
|
|
links.new(teximage_emit_node.outputs[0], shader_node.inputs["Emission"])
|
|
|
|
|
|
|
|
# Build the hull_dark texture
|
|
mat = ret[Material.hull_dark]
|
|
set_hull_mat_basics(mat, [0.3 * x for x in hull_base_color], hull_normal_map)
|
|
|
|
# Choose a glow color for the exhaust + glow discs
|
|
glow_color = hls_to_rgb(random(), uniform(0.5, 1), 1)
|
|
glow_color = (glow_color[0], glow_color[1], glow_color[2], 1.0)
|
|
|
|
# # Build the exhaust_burn texture
|
|
mat = ret[Material.exhaust_burn]
|
|
shader_node = getShaderNode(mat)
|
|
shader_node.inputs["Emission"].default_value = glow_color
|
|
|
|
# # Build the glow_disc texture
|
|
mat = ret[Material.glow_disc]
|
|
shader_node = getShaderNode(mat)
|
|
shader_node.inputs["Emission"].default_value = glow_color
|
|
|
|
return ret
|
|
|
|
# Generates a textured spaceship mesh and returns the object.
|
|
# Just uses global cube texture coordinates rather than generating UVs.
|
|
# Takes an optional random seed value to generate a specific spaceship.
|
|
# Allows overriding of some parameters that affect generation.
|
|
def generate_spaceship(random_seed='',
|
|
num_hull_segments_min=3,
|
|
num_hull_segments_max=6,
|
|
create_asymmetry_segments=True,
|
|
num_asymmetry_segments_min=1,
|
|
num_asymmetry_segments_max=5,
|
|
create_face_detail=True,
|
|
allow_horizontal_symmetry=True,
|
|
allow_vertical_symmetry=False,
|
|
apply_bevel_modifier=True,
|
|
assign_materials=True):
|
|
if random_seed:
|
|
seed(random_seed)
|
|
|
|
# Let's start with a unit BMesh cube scaled randomly
|
|
bm = bmesh.new()
|
|
bmesh.ops.create_cube(bm, size=1)
|
|
scale_vector = Vector(
|
|
(uniform(0.75, 2.0), uniform(0.75, 2.0), uniform(0.75, 2.0)))
|
|
bmesh.ops.scale(bm, vec=scale_vector, verts=bm.verts)
|
|
|
|
# Extrude out the hull along the X axis, adding some semi-random perturbations
|
|
for face in bm.faces[:]:
|
|
if abs(face.normal.x) > 0.5:
|
|
hull_segment_length = uniform(0.3, 1)
|
|
num_hull_segments = randrange(num_hull_segments_min, num_hull_segments_max)
|
|
hull_segment_range = range(num_hull_segments)
|
|
for i in hull_segment_range:
|
|
is_last_hull_segment = i == hull_segment_range[-1]
|
|
val = random()
|
|
if val > 0.1:
|
|
# Most of the time, extrude out the face with some random deviations
|
|
face = extrude_face(bm, face, hull_segment_length)
|
|
if random() > 0.75:
|
|
face = extrude_face(
|
|
bm, face, hull_segment_length * 0.25)
|
|
|
|
# Maybe apply some scaling
|
|
if random() > 0.5:
|
|
sy = uniform(1.2, 1.5)
|
|
sz = uniform(1.2, 1.5)
|
|
if is_last_hull_segment or random() > 0.5:
|
|
sy = 1 / sy
|
|
sz = 1 / sz
|
|
scale_face(bm, face, 1, sy, sz)
|
|
|
|
# Maybe apply some sideways translation
|
|
if random() > 0.5:
|
|
sideways_translation = Vector(
|
|
(0, 0, uniform(0.1, 0.4) * scale_vector.z * hull_segment_length))
|
|
if random() > 0.5:
|
|
sideways_translation = -sideways_translation
|
|
bmesh.ops.translate(bm,
|
|
vec=sideways_translation,
|
|
verts=face.verts)
|
|
|
|
# Maybe add some rotation around Y axis
|
|
if random() > 0.5:
|
|
angle = 5
|
|
if random() > 0.5:
|
|
angle = -angle
|
|
bmesh.ops.rotate(bm,
|
|
verts=face.verts,
|
|
cent=(0, 0, 0),
|
|
matrix=Matrix.Rotation(radians(angle), 3, 'Y'))
|
|
else:
|
|
# Rarely, create a ribbed section of the hull
|
|
rib_scale = uniform(0.75, 0.95)
|
|
face = ribbed_extrude_face(
|
|
bm, face, hull_segment_length, randint(2, 4), rib_scale)
|
|
|
|
# Add some large asymmetrical sections of the hull that stick out
|
|
if create_asymmetry_segments:
|
|
for face in bm.faces[:]:
|
|
# Skip any long thin faces as it'll probably look stupid
|
|
if get_aspect_ratio(face) > 4:
|
|
continue
|
|
if random() > 0.85:
|
|
hull_piece_length = uniform(0.1, 0.4)
|
|
for i in range(randrange(num_asymmetry_segments_min, num_asymmetry_segments_max)):
|
|
face = extrude_face(bm, face, hull_piece_length)
|
|
|
|
# Maybe apply some scaling
|
|
if random() > 0.25:
|
|
s = 1 / uniform(1.1, 1.5)
|
|
scale_face(bm, face, s, s, s)
|
|
|
|
# Now the basic hull shape is built, let's categorize + add detail to all the faces
|
|
if create_face_detail:
|
|
engine_faces = []
|
|
grid_faces = []
|
|
antenna_faces = []
|
|
weapon_faces = []
|
|
sphere_faces = []
|
|
disc_faces = []
|
|
cylinder_faces = []
|
|
for face in bm.faces[:]:
|
|
# Skip any long thin faces as it'll probably look stupid
|
|
if get_aspect_ratio(face) > 3:
|
|
continue
|
|
|
|
# Spin the wheel! Let's categorize + assign some materials
|
|
val = random()
|
|
if is_rear_face(face): # rear face
|
|
if not engine_faces or val > 0.75:
|
|
engine_faces.append(face)
|
|
elif val > 0.5:
|
|
cylinder_faces.append(face)
|
|
elif val > 0.25:
|
|
grid_faces.append(face)
|
|
else:
|
|
face.material_index = Material.hull_lights
|
|
elif face.normal.x > 0.9: # front face
|
|
if face.normal.dot(face.calc_center_bounds()) > 0 and val > 0.7:
|
|
antenna_faces.append(face) # front facing antenna
|
|
face.material_index = Material.hull_lights
|
|
elif val > 0.4:
|
|
grid_faces.append(face)
|
|
else:
|
|
face.material_index = Material.hull_lights
|
|
elif face.normal.z > 0.9: # top face
|
|
if face.normal.dot(face.calc_center_bounds()) > 0 and val > 0.7:
|
|
antenna_faces.append(face) # top facing antenna
|
|
elif val > 0.6:
|
|
grid_faces.append(face)
|
|
elif val > 0.3:
|
|
cylinder_faces.append(face)
|
|
elif face.normal.z < -0.9: # bottom face
|
|
if val > 0.75:
|
|
disc_faces.append(face)
|
|
elif val > 0.5:
|
|
grid_faces.append(face)
|
|
elif val > 0.25:
|
|
weapon_faces.append(face)
|
|
elif abs(face.normal.y) > 0.9: # side face
|
|
if not weapon_faces or val > 0.75:
|
|
weapon_faces.append(face)
|
|
elif val > 0.6:
|
|
grid_faces.append(face)
|
|
elif val > 0.4:
|
|
sphere_faces.append(face)
|
|
else:
|
|
face.material_index = Material.hull_lights
|
|
|
|
# Now we've categorized, let's actually add the detail
|
|
for face in engine_faces:
|
|
add_exhaust_to_face(bm, face)
|
|
|
|
for face in grid_faces:
|
|
add_grid_to_face(bm, face)
|
|
|
|
for face in antenna_faces:
|
|
add_surface_antenna_to_face(bm, face)
|
|
|
|
for face in weapon_faces:
|
|
add_weapons_to_face(bm, face)
|
|
|
|
for face in sphere_faces:
|
|
add_sphere_to_face(bm, face)
|
|
|
|
for face in disc_faces:
|
|
add_disc_to_face(bm, face)
|
|
|
|
for face in cylinder_faces:
|
|
add_cylinders_to_face(bm, face)
|
|
|
|
# Apply horizontal symmetry sometimes
|
|
if allow_horizontal_symmetry and random() > 0.5:
|
|
bmesh.ops.symmetrize(bm, input=bm.verts[:] + bm.edges[:] + bm.faces[:], direction="Y")
|
|
|
|
# Apply vertical symmetry sometimes - this can cause spaceship "islands", so disabled by default
|
|
if allow_vertical_symmetry and random() > 0.5:
|
|
bmesh.ops.symmetrize(bm, input=bm.verts[:] + bm.edges[:] + bm.faces[:], direction="Z")
|
|
|
|
# Finish up, write the bmesh into a new mesh
|
|
me = bpy.data.meshes.new('Mesh')
|
|
bm.to_mesh(me)
|
|
bm.free()
|
|
|
|
# Add the mesh to the scene
|
|
scene = bpy.context.scene
|
|
obj = bpy.data.objects.new('Spaceship', me)
|
|
# scene.objects.link(obj)
|
|
scene.collection.objects.link(obj)
|
|
|
|
# Select and make active
|
|
bpy.context.view_layer.objects.active = obj
|
|
obj.select_set(True)
|
|
# scene.objects.active = obj
|
|
# obj.select = True
|
|
|
|
# Recenter the object to its center of mass
|
|
bpy.ops.object.origin_set(type='ORIGIN_CENTER_OF_MASS')
|
|
ob = bpy.context.object
|
|
ob.location = (0, 0, 0)
|
|
|
|
# Add a fairly broad bevel modifier to angularize shape
|
|
if apply_bevel_modifier:
|
|
bevel_modifier = ob.modifiers.new('Bevel', 'BEVEL')
|
|
bevel_modifier.width = uniform(5, 20)
|
|
bevel_modifier.offset_type = 'PERCENT'
|
|
bevel_modifier.segments = 2
|
|
bevel_modifier.profile = 0.25
|
|
bevel_modifier.limit_method = 'NONE'
|
|
|
|
# Add materials to the spaceship
|
|
me = ob.data
|
|
materials = create_materials()
|
|
# materials = []
|
|
for mat in materials:
|
|
if assign_materials:
|
|
me.materials.append(mat)
|
|
else:
|
|
me.materials.append(bpy.data.materials.new(name="Material"))
|
|
|
|
return obj
|
|
|
|
if __name__ == "__main__":
|
|
|
|
# When true, this script will generate a single spaceship in the scene.
|
|
# When false, this script will render multiple movie frames showcasing lots of ships.
|
|
generate_single_spaceship = True
|
|
|
|
if generate_single_spaceship:
|
|
# Reset the scene, generate a single spaceship and focus on it
|
|
reset_scene()
|
|
customseed = '' # add anything here to generate the same spaceship
|
|
obj = generate_spaceship(customseed)
|
|
|
|
# View the selected object in all views
|
|
for area in bpy.context.screen.areas:
|
|
if area.type == 'VIEW_3D':
|
|
ctx = bpy.context.copy()
|
|
ctx['area'] = area
|
|
ctx['region'] = area.regions[-1]
|
|
bpy.ops.view3d.view_selected(ctx)
|
|
else:
|
|
# Export a movie showcasing many different kinds of ships
|
|
|
|
# Settings
|
|
output_path = '' # leave empty to use script folder
|
|
total_movie_duration = 16
|
|
total_spaceship_duration = 1
|
|
yaw_rate = 45 # degrees/sec
|
|
yaw_offset = 220 # degrees/sec
|
|
camera_pole_rate = 1
|
|
camera_pole_pitch_min = 15 # degrees
|
|
camera_pole_pitch_max = 30 # degrees
|
|
camera_pole_pitch_offset = 0 # degrees
|
|
camera_pole_length = 10
|
|
camera_refocus_object_every_frame = False
|
|
fov = 60 # degrees
|
|
fps = 30
|
|
res_x = 1920
|
|
res_y = 1080
|
|
|
|
# Batch render the movie frames
|
|
inv_fps = 1/float(fps)
|
|
movie_duration = 0
|
|
spaceship_duration = total_spaceship_duration
|
|
scene = bpy.data.scenes["Scene"]
|
|
scene.render.resolution_x = res_x
|
|
scene.render.resolution_y = res_y
|
|
scene.camera.rotation_mode = 'XYZ'
|
|
scene.camera.data.angle = radians(fov)
|
|
frame = 0
|
|
timestamp = datetime.datetime.now().strftime('%Y%m%d_%H%M%S')
|
|
while movie_duration < total_movie_duration:
|
|
movie_duration += inv_fps
|
|
spaceship_duration += inv_fps
|
|
if spaceship_duration >= total_spaceship_duration:
|
|
spaceship_duration -= total_spaceship_duration
|
|
|
|
# Generate a new spaceship
|
|
reset_scene()
|
|
obj = generate_spaceship()
|
|
|
|
# look for a mirror plane in the scene, and position it just underneath the ship if found
|
|
lowest_z = centre = min((Vector(b).z for b in obj.bound_box))
|
|
plane_obj = bpy.data.objects['Plane'] if 'Plane' in bpy.data.objects else None
|
|
if plane_obj:
|
|
plane_obj.location.z = lowest_z - 0.3
|
|
|
|
# Position and orient the camera
|
|
rad = radians(yaw_offset + (yaw_rate * movie_duration))
|
|
camera_pole_pitch_lerp = 0.5 * (1 + cos(camera_pole_rate * movie_duration)) # 0-1
|
|
camera_pole_pitch = camera_pole_pitch_max * camera_pole_pitch_lerp + \
|
|
camera_pole_pitch_min * (1 - camera_pole_pitch_lerp)
|
|
scene.camera.rotation_euler = (radians(90 - camera_pole_pitch + camera_pole_pitch_offset), 0, rad)
|
|
scene.camera.location = (sin(rad) * camera_pole_length,
|
|
cos(rad) * -camera_pole_length,
|
|
sin(radians(camera_pole_pitch))*camera_pole_length)
|
|
if camera_refocus_object_every_frame:
|
|
bpy.ops.view3d.camera_to_view_selected()
|
|
|
|
# Render the scene to disk
|
|
script_path = bpy.context.space_data.text.filepath if bpy.context.space_data else __file__
|
|
folder = output_path if output_path else os.path.split(os.path.realpath(script_path))[0]
|
|
filename = os.path.join('renders', timestamp, timestamp + '_' + str(frame).zfill(5) + '.png')
|
|
bpy.data.scenes['Scene'].render.filepath = os.path.join(folder, filename)
|
|
print('Rendering frame ' + str(frame) + '...')
|
|
bpy.ops.render.render(write_still=True)
|
|
frame += 1
|