ANT landscape: complete update, folder system
This commit is contained in:
parent
16dbda9caa
commit
fcab90a6a0
Notes:
blender-bot
2023-02-14 18:07:29 +01:00
Referenced by commit d93ef9e6: Ant landscape, remove original file: mention rBAfcab90a6a004
Referenced by commit d93ef9e6, Ant landscape, remove original file: mention rBAfcab90a6a004
|
|
@ -0,0 +1,757 @@
|
|||
# ##### BEGIN GPL LICENSE BLOCK #####
|
||||
#
|
||||
# This program is free software; you can redistribute it and/or
|
||||
# modify it under the terms of the GNU General Public License
|
||||
# as published by the Free Software Foundation; either version 2
|
||||
# of the License, or (at your option) any later version.
|
||||
#
|
||||
# This program is distributed in the hope that it will be useful,
|
||||
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
# GNU General Public License for more details.
|
||||
#
|
||||
# You should have received a copy of the GNU General Public License
|
||||
# along with this program; if not, write to the Free Software Foundation,
|
||||
# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
#
|
||||
# ##### END GPL LICENSE BLOCK #####
|
||||
|
||||
# Another Noise Tool - Suite
|
||||
# Jim Hazevoet 5/2017
|
||||
|
||||
bl_info = {
|
||||
"name": "A.N.T.Landscape",
|
||||
"author": "Jim Hazevoet",
|
||||
"version": (0, 1, 6),
|
||||
"blender": (2, 77, 0),
|
||||
"location": "View3D > Tool Shelf",
|
||||
"description": "Another Noise Tool: Landscape and Displace",
|
||||
"warning": "",
|
||||
"wiki_url": "https://wiki.blender.org/index.php/Extensions:2.6/Py/"
|
||||
"Scripts/Add_Mesh/ANT_Landscape",
|
||||
"category": "Add Mesh",
|
||||
}
|
||||
|
||||
if "bpy" in locals():
|
||||
import importlib
|
||||
importlib.reload(add_mesh_ant_landscape)
|
||||
importlib.reload(ant_landscape_refresh)
|
||||
importlib.reload(mesh_ant_displace)
|
||||
importlib.reload(ant_functions)
|
||||
else:
|
||||
from ant_landscape import add_mesh_ant_landscape
|
||||
from ant_landscape import ant_landscape_refresh
|
||||
from ant_landscape import mesh_ant_displace
|
||||
from ant_landscape import ant_functions
|
||||
|
||||
import bpy
|
||||
|
||||
from bpy.props import (
|
||||
BoolProperty,
|
||||
FloatProperty,
|
||||
IntProperty,
|
||||
StringProperty,
|
||||
PointerProperty,
|
||||
EnumProperty,
|
||||
)
|
||||
'''
|
||||
from .ant_functions import (
|
||||
draw_ant_refresh,
|
||||
draw_ant_main,
|
||||
draw_ant_noise,
|
||||
draw_ant_displace,
|
||||
)
|
||||
'''
|
||||
|
||||
# ------------------------------------------------------------
|
||||
# Menu and panels
|
||||
|
||||
# Define "Landscape" menu
|
||||
def menu_func_landscape(self, context):
|
||||
self.layout.operator('mesh.landscape_add', text="Landscape", icon="RNDCURVE")
|
||||
|
||||
|
||||
# Landscape Add Panel
|
||||
class panel_func_add_landscape(bpy.types.Panel):
|
||||
bl_space_type = "VIEW_3D"
|
||||
bl_context = "objectmode"
|
||||
bl_region_type = "TOOLS"
|
||||
bl_label = "ANT Landscape"
|
||||
bl_category = "Create"
|
||||
bl_options = {'DEFAULT_CLOSED'}
|
||||
|
||||
def draw(self, context):
|
||||
col = self.layout.column()
|
||||
col.operator('mesh.landscape_add', text="Landscape", icon="RNDCURVE")
|
||||
|
||||
|
||||
# Landscape Tools:
|
||||
class AntLandscapeToolsPanel(bpy.types.Panel):
|
||||
bl_space_type = "VIEW_3D"
|
||||
bl_context = "objectmode"
|
||||
bl_region_type = "TOOLS"
|
||||
bl_label = "ANT Displace/Slopemap"
|
||||
bl_category = "Tools"
|
||||
bl_options = {'DEFAULT_CLOSED'}
|
||||
|
||||
def draw(self, context):
|
||||
layout = self.layout
|
||||
ob = context.active_object
|
||||
if ob and ob.type == 'MESH':
|
||||
box = layout.box()
|
||||
col = box.column()
|
||||
col.label("Mesh:")
|
||||
col.operator('mesh.ant_displace', text="Displace", icon="RNDCURVE")
|
||||
col = box.column()
|
||||
col.operator('mesh.ant_slope_map', icon='GROUP_VERTEX')
|
||||
else:
|
||||
box = layout.box()
|
||||
col = box.column()
|
||||
col.label("Select a Mesh Object")
|
||||
|
||||
|
||||
# Landscape Settings:
|
||||
class AntLandscapeSettingsPanel(bpy.types.Panel):
|
||||
bl_space_type = "VIEW_3D"
|
||||
bl_context = "objectmode"
|
||||
bl_region_type = "TOOLS"
|
||||
bl_category = "Create"
|
||||
bl_options = {'DEFAULT_CLOSED'}
|
||||
bl_label = "ANT Landscape Settings"
|
||||
# bl_space_type = 'PROPERTIES'
|
||||
# bl_region_type = 'WINDOW'
|
||||
# bl_context = "world"
|
||||
|
||||
def draw(self, context):
|
||||
layout = self.layout
|
||||
scene = context.scene
|
||||
ob = bpy.context.active_object
|
||||
|
||||
if ob and ob.ant_landscape.keys():
|
||||
ant = ob.ant_landscape
|
||||
box = layout.box()
|
||||
split = box.column().row().split()
|
||||
split.scale_y = 1.5
|
||||
split.operator('mesh.ant_landscape_regenerate', text="", icon="LOOP_FORWARDS")
|
||||
split.operator('mesh.ant_landscape_refresh', text="", icon="FILE_REFRESH")
|
||||
|
||||
box = layout.box()
|
||||
box.prop(ant, "show_main_settings", toggle=True)
|
||||
if ant.show_main_settings:
|
||||
#row = box.row(align=True)
|
||||
#split = row.split(align=True)
|
||||
#split.prop(ant, "at_cursor", toggle=True, icon_only=True, icon='CURSOR')
|
||||
#split.prop(ant, "smooth_mesh", toggle=True, icon_only=True, icon='SOLID')
|
||||
#split.prop(ant, "sphere_mesh", toggle=True)
|
||||
#split.prop(ant, "tri_face", toggle=True, icon_only=True, icon='MESH_DATA')
|
||||
#box.prop(ant, "ant_terrain_name")
|
||||
#box.prop_search(ant, "land_material", bpy.data, "materials")
|
||||
col = box.column(align=True)
|
||||
col.prop(ant, "subdivision_x")
|
||||
col.prop(ant, "subdivision_y")
|
||||
col = box.column(align=True)
|
||||
if ant.sphere_mesh:
|
||||
col.prop(ant, "mesh_size")
|
||||
else:
|
||||
col.prop(ant, "mesh_size_x")
|
||||
col.prop(ant, "mesh_size_y")
|
||||
|
||||
box = layout.box()
|
||||
box.prop(ant, "show_noise_settings", toggle=True)
|
||||
if ant.show_noise_settings:
|
||||
box.prop(ant, "noise_type")
|
||||
if ant.noise_type == "blender_texture":
|
||||
box.prop_search(ant, "texture_block", bpy.data, "textures")
|
||||
else:
|
||||
box.prop(ant, "basis_type")
|
||||
|
||||
col = box.column(align=True)
|
||||
col.prop(ant, "random_seed")
|
||||
col = box.column(align=True)
|
||||
col.prop(ant, "noise_offset_x")
|
||||
col.prop(ant, "noise_offset_y")
|
||||
col.prop(ant, "noise_offset_z")
|
||||
col.prop(ant, "noise_size_x")
|
||||
col.prop(ant, "noise_size_y")
|
||||
col.prop(ant, "noise_size_z")
|
||||
col = box.column(align=True)
|
||||
col.prop(ant, "noise_size")
|
||||
|
||||
col = box.column(align=True)
|
||||
if ant.noise_type == "multi_fractal":
|
||||
col.prop(ant, "noise_depth")
|
||||
col.prop(ant, "dimension")
|
||||
col.prop(ant, "lacunarity")
|
||||
elif ant.noise_type == "ridged_multi_fractal":
|
||||
col.prop(ant, "noise_depth")
|
||||
col.prop(ant, "dimension")
|
||||
col.prop(ant, "lacunarity")
|
||||
col.prop(ant, "offset")
|
||||
col.prop(ant, "gain")
|
||||
elif ant.noise_type == "hybrid_multi_fractal":
|
||||
col.prop(ant, "noise_depth")
|
||||
col.prop(ant, "dimension")
|
||||
col.prop(ant, "lacunarity")
|
||||
col.prop(ant, "offset")
|
||||
col.prop(ant, "gain")
|
||||
elif ant.noise_type == "hetero_terrain":
|
||||
col.prop(ant, "noise_depth")
|
||||
col.prop(ant, "dimension")
|
||||
col.prop(ant, "lacunarity")
|
||||
col.prop(ant, "offset")
|
||||
elif ant.noise_type == "fractal":
|
||||
col.prop(ant, "noise_depth")
|
||||
col.prop(ant, "dimension")
|
||||
col.prop(ant, "lacunarity")
|
||||
elif ant.noise_type == "turbulence_vector":
|
||||
col.prop(ant, "noise_depth")
|
||||
col.prop(ant, "amplitude")
|
||||
col.prop(ant, "frequency")
|
||||
col.separator()
|
||||
row = col.row(align=True)
|
||||
row.prop(ant, "hard_noise", expand=True)
|
||||
elif ant.noise_type == "variable_lacunarity":
|
||||
box.prop(ant, "vl_basis_type")
|
||||
box.prop(ant, "distortion")
|
||||
elif ant.noise_type == "marble_noise":
|
||||
box.prop(ant, "marble_shape")
|
||||
box.prop(ant, "marble_bias")
|
||||
box.prop(ant, "marble_sharp")
|
||||
col = box.column(align=True)
|
||||
col.prop(ant, "distortion")
|
||||
col.prop(ant, "noise_depth")
|
||||
col.separator()
|
||||
row = col.row(align=True)
|
||||
row.prop(ant, "hard_noise", expand=True)
|
||||
elif ant.noise_type == "shattered_hterrain":
|
||||
col.prop(ant, "noise_depth")
|
||||
col.prop(ant, "dimension")
|
||||
col.prop(ant, "lacunarity")
|
||||
col.prop(ant, "offset")
|
||||
col.prop(ant, "distortion")
|
||||
elif ant.noise_type == "strata_hterrain":
|
||||
col.prop(ant, "noise_depth")
|
||||
col.prop(ant, "dimension")
|
||||
col.prop(ant, "lacunarity")
|
||||
col.prop(ant, "offset")
|
||||
col.prop(ant, "distortion", text="Strata")
|
||||
elif ant.noise_type == "ant_turbulence":
|
||||
col.prop(ant, "noise_depth")
|
||||
col.prop(ant, "amplitude")
|
||||
col.prop(ant, "frequency")
|
||||
col.prop(ant, "distortion")
|
||||
col.separator()
|
||||
row = col.row(align=True)
|
||||
row.prop(ant, "hard_noise", expand=True)
|
||||
elif ant.noise_type == "vl_noise_turbulence":
|
||||
col.prop(ant, "noise_depth")
|
||||
col.prop(ant, "amplitude")
|
||||
col.prop(ant, "frequency")
|
||||
col.prop(ant, "distortion")
|
||||
col.separator()
|
||||
col.prop(ant, "vl_basis_type")
|
||||
col.separator()
|
||||
row = col.row(align=True)
|
||||
row.prop(ant, "hard_noise", expand=True)
|
||||
elif ant.noise_type == "vl_hTerrain":
|
||||
col.prop(ant, "noise_depth")
|
||||
col.prop(ant, "dimension")
|
||||
col.prop(ant, "lacunarity")
|
||||
col.prop(ant, "offset")
|
||||
col.prop(ant, "distortion")
|
||||
col.separator()
|
||||
col.prop(ant, "vl_basis_type")
|
||||
elif ant.noise_type == "distorted_heteroTerrain":
|
||||
col.prop(ant, "noise_depth")
|
||||
col.prop(ant, "dimension")
|
||||
col.prop(ant, "lacunarity")
|
||||
col.prop(ant, "offset")
|
||||
col.prop(ant, "distortion")
|
||||
col.separator()
|
||||
col.prop(ant, "vl_basis_type")
|
||||
elif ant.noise_type == "double_multiFractal":
|
||||
col.prop(ant, "noise_depth")
|
||||
col.prop(ant, "dimension")
|
||||
col.prop(ant, "lacunarity")
|
||||
col.prop(ant, "offset")
|
||||
col.prop(ant, "gain")
|
||||
col.separator()
|
||||
col.prop(ant, "vl_basis_type")
|
||||
elif ant.noise_type == "slick_rock":
|
||||
col.prop(ant, "noise_depth")
|
||||
col.prop(ant, "dimension")
|
||||
col.prop(ant, "lacunarity")
|
||||
col.prop(ant, "gain")
|
||||
col.prop(ant, "offset")
|
||||
col.prop(ant, "distortion")
|
||||
col.separator()
|
||||
col.prop(ant, "vl_basis_type")
|
||||
elif ant.noise_type == "planet_noise":
|
||||
col.prop(ant, "noise_depth")
|
||||
col.separator()
|
||||
row = col.row(align=True)
|
||||
row.prop(ant, "hard_noise", expand=True)
|
||||
|
||||
box = layout.box()
|
||||
box.prop(ant, "show_displace_settings", toggle=True)
|
||||
if ant.show_displace_settings:
|
||||
col = box.column(align=True)
|
||||
row = col.row(align=True).split(0.92, align=True)
|
||||
row.prop(ant, "height")
|
||||
row.prop(ant, "height_invert", toggle=True, text="", icon='ARROW_LEFTRIGHT')
|
||||
col.prop(ant, "height_offset")
|
||||
col.prop(ant, "maximum")
|
||||
col.prop(ant, "minimum")
|
||||
|
||||
if not ant.sphere_mesh:
|
||||
col = box.column()
|
||||
col.prop(ant, "edge_falloff")
|
||||
if ant.edge_falloff is not "0":
|
||||
col = box.column(align=True)
|
||||
col.prop(ant, "edge_level")
|
||||
if ant.edge_falloff in ["2", "3"]:
|
||||
col.prop(ant, "falloff_x")
|
||||
if ant.edge_falloff in ["1", "3"]:
|
||||
col.prop(ant, "falloff_y")
|
||||
|
||||
col = box.column()
|
||||
col.prop(ant, "strata_type")
|
||||
if ant.strata_type is not "0":
|
||||
col = box.column()
|
||||
col.prop(ant, "strata")
|
||||
|
||||
else:
|
||||
box = layout.box()
|
||||
col = box.column()
|
||||
col.label("Select a Landscape Object")
|
||||
|
||||
|
||||
# ------------------------------------------------------------
|
||||
# Properties group
|
||||
class AntLandscapePropertiesGroup(bpy.types.PropertyGroup):
|
||||
|
||||
ant_terrain_name = StringProperty(
|
||||
name="Name",
|
||||
default="Landscape"
|
||||
)
|
||||
land_material = StringProperty(
|
||||
name='Material',
|
||||
default="",
|
||||
description="Terrain material"
|
||||
)
|
||||
water_material = StringProperty(
|
||||
name='Material',
|
||||
default="",
|
||||
description="Water plane material"
|
||||
)
|
||||
texture_block = StringProperty(
|
||||
name="Texture",
|
||||
default=""
|
||||
)
|
||||
at_cursor = BoolProperty(
|
||||
name="Cursor",
|
||||
default=True,
|
||||
description="Place at cursor location",
|
||||
)
|
||||
smooth_mesh = BoolProperty(
|
||||
name="Smooth",
|
||||
default=True,
|
||||
description="Shade smooth"
|
||||
)
|
||||
tri_face = BoolProperty(
|
||||
name="Triangulate",
|
||||
default=False,
|
||||
description="Triangulate faces"
|
||||
)
|
||||
sphere_mesh = BoolProperty(
|
||||
name="Sphere",
|
||||
default=False,
|
||||
description="Generate uv sphere - remove doubles when ready"
|
||||
)
|
||||
subdivision_x = IntProperty(
|
||||
name="Subdivisions X",
|
||||
default=128,
|
||||
min=4,
|
||||
max=6400,
|
||||
description="Mesh X subdivisions"
|
||||
)
|
||||
subdivision_y = IntProperty(
|
||||
default=128,
|
||||
name="Subdivisions Y",
|
||||
min=4,
|
||||
max=6400,
|
||||
description="Mesh Y subdivisions"
|
||||
)
|
||||
mesh_size = FloatProperty(
|
||||
default=2.0,
|
||||
name="Mesh Size",
|
||||
min=0.01,
|
||||
max=100000.0,
|
||||
description="Mesh size"
|
||||
)
|
||||
mesh_size_x = FloatProperty(
|
||||
default=2.0,
|
||||
name="Mesh Size X",
|
||||
min=0.01,
|
||||
description="Mesh x size"
|
||||
)
|
||||
mesh_size_y = FloatProperty(
|
||||
name="Mesh Size Y",
|
||||
default=2.0,
|
||||
min=0.01,
|
||||
description="Mesh y size"
|
||||
)
|
||||
|
||||
random_seed = IntProperty(
|
||||
name="Random Seed",
|
||||
default=0,
|
||||
min=0,
|
||||
description="Randomize noise origin"
|
||||
)
|
||||
noise_offset_x = FloatProperty(
|
||||
name="Offset X",
|
||||
default=0.0,
|
||||
description="Noise X Offset"
|
||||
)
|
||||
noise_offset_y = FloatProperty(
|
||||
name="Offset Y",
|
||||
default=0.0,
|
||||
description="Noise Y Offset"
|
||||
)
|
||||
noise_offset_z = FloatProperty(
|
||||
name="Offset Z",
|
||||
default=0.0,
|
||||
description="Noise Z Offset"
|
||||
)
|
||||
noise_size_x = FloatProperty(
|
||||
default=1.0,
|
||||
name="Size X",
|
||||
min=0.01,
|
||||
max=1000.0,
|
||||
description="Noise x size"
|
||||
)
|
||||
noise_size_y = FloatProperty(
|
||||
name="Size Y",
|
||||
default=1.0,
|
||||
min=0.01,
|
||||
max=1000.0,
|
||||
description="Noise y size"
|
||||
)
|
||||
noise_size_z = FloatProperty(
|
||||
name="Size Z",
|
||||
default=1.0,
|
||||
min=0.01,
|
||||
max=1000.0,
|
||||
description="Noise Z size"
|
||||
)
|
||||
noise_size = FloatProperty(
|
||||
name="Noise Size",
|
||||
default=1.0,
|
||||
min=0.01,
|
||||
max=1000.0,
|
||||
description="Noise size"
|
||||
)
|
||||
noise_type = EnumProperty(
|
||||
name="Noise Type",
|
||||
default='hetero_terrain',
|
||||
description="Noise type",
|
||||
items = [
|
||||
('multi_fractal', "Multi Fractal", "Blender: Multi Fractal algorithm", 0),
|
||||
('ridged_multi_fractal', "Ridged MFractal", "Blender: Ridged Multi Fractal", 1),
|
||||
('hybrid_multi_fractal', "Hybrid MFractal", "Blender: Hybrid Multi Fractal", 2),
|
||||
('hetero_terrain', "Hetero Terrain", "Blender: Hetero Terrain", 3),
|
||||
('fractal', "fBm Fractal", "Blender: fBm - Fractional Browninian motion", 4),
|
||||
('turbulence_vector', "Turbulence", "Blender: Turbulence Vector", 5),
|
||||
('variable_lacunarity', "Distorted Noise", "Blender: Distorted Noise", 6),
|
||||
('marble_noise', "Marble", "A.N.T.: Marble Noise", 7),
|
||||
('shattered_hterrain', "Shattered hTerrain", "A.N.T.: Shattered hTerrain", 8),
|
||||
('strata_hterrain', "Strata hTerrain", "A.N.T: Strata hTerrain", 9),
|
||||
('ant_turbulence', "Another Turbulence", "A.N.T: Turbulence variation", 10),
|
||||
('vl_noise_turbulence', "vlNoise turbulence", "A.N.T: vlNoise turbulence", 11),
|
||||
('vl_hTerrain', "vlNoise hTerrain", "A.N.T: vlNoise hTerrain", 12),
|
||||
('distorted_heteroTerrain', "Distorted hTerrain", "A.N.T distorted hTerrain", 13),
|
||||
('double_multiFractal', "Double MultiFractal", "A.N.T: double multiFractal", 14),
|
||||
('slick_rock', "Slick Rock", "A.N.T: slick rock", 15),
|
||||
('planet_noise', "Planet Noise", "Planet Noise by: Farsthary", 16),
|
||||
('blender_texture', "Blender Texture - Texture Nodes", "Blender texture data block", 17)]
|
||||
)
|
||||
basis_type = EnumProperty(
|
||||
name="Noise Basis",
|
||||
default="0",
|
||||
description="Noise basis algorithms",
|
||||
items = [
|
||||
("0", "Blender", "Blender default noise", 0),
|
||||
("1", "Perlin", "Perlin noise", 1),
|
||||
("2", "New Perlin", "New Perlin noise", 2),
|
||||
("3", "Voronoi F1", "Voronoi F1", 3),
|
||||
("4", "Voronoi F2", "Voronoi F2", 4),
|
||||
("5", "Voronoi F3", "Voronoi F3", 5),
|
||||
("6", "Voronoi F4", "Voronoi F4", 6),
|
||||
("7", "Voronoi F2-F1", "Voronoi F2-F1", 7),
|
||||
("8", "Voronoi Crackle", "Voronoi Crackle", 8),
|
||||
("9", "Cell Noise", "Cell noise", 9)]
|
||||
)
|
||||
vl_basis_type = EnumProperty(
|
||||
name="vlNoise Basis",
|
||||
default="0",
|
||||
description="VLNoise basis algorithms",
|
||||
items = [
|
||||
("0", "Blender", "Blender default noise", 0),
|
||||
("1", "Perlin", "Perlin noise", 1),
|
||||
("2", "New Perlin", "New Perlin noise", 2),
|
||||
("3", "Voronoi F1", "Voronoi F1", 3),
|
||||
("4", "Voronoi F2", "Voronoi F2", 4),
|
||||
("5", "Voronoi F3", "Voronoi F3", 5),
|
||||
("6", "Voronoi F4", "Voronoi F4", 6),
|
||||
("7", "Voronoi F2-F1", "Voronoi F2-F1", 7),
|
||||
("8", "Voronoi Crackle", "Voronoi Crackle", 8),
|
||||
("9", "Cell Noise", "Cell noise", 9)]
|
||||
)
|
||||
distortion = FloatProperty(
|
||||
name="Distortion",
|
||||
default=1.0,
|
||||
min=0.01,
|
||||
max=100.0,
|
||||
description="Distortion amount"
|
||||
)
|
||||
hard_noise = EnumProperty(
|
||||
name="Soft Hard",
|
||||
default="0",
|
||||
description="Soft Noise, Hard noise",
|
||||
items = [
|
||||
("0", "Soft", "Soft Noise", 0),
|
||||
("1", "Hard", "Hard noise", 1)]
|
||||
)
|
||||
noise_depth = IntProperty(
|
||||
name="Depth",
|
||||
default=8,
|
||||
min=0,
|
||||
max=16,
|
||||
description="Noise Depth - number of frequencies in the fBm"
|
||||
)
|
||||
amplitude = FloatProperty(
|
||||
name="Amp",
|
||||
default=0.5,
|
||||
min=0.01,
|
||||
max=1.0,
|
||||
description="Amplitude"
|
||||
)
|
||||
frequency = FloatProperty(
|
||||
name="Freq",
|
||||
default=2.0,
|
||||
min=0.01,
|
||||
max=5.0,
|
||||
description="Frequency"
|
||||
)
|
||||
dimension = FloatProperty(
|
||||
name="Dimension",
|
||||
default=1.0,
|
||||
min=0.01,
|
||||
max=2.0,
|
||||
description="H - fractal dimension of the roughest areas"
|
||||
)
|
||||
lacunarity = FloatProperty(
|
||||
name="Lacunarity",
|
||||
min=0.01,
|
||||
max=6.0,
|
||||
default=2.0,
|
||||
description="Lacunarity - gap between successive frequencies"
|
||||
)
|
||||
offset = FloatProperty(
|
||||
name="Offset",
|
||||
default=1.0,
|
||||
min=0.01,
|
||||
max=6.0,
|
||||
description="Offset - raises the terrain from sea level"
|
||||
)
|
||||
gain = FloatProperty(
|
||||
name="Gain",
|
||||
default=1.0,
|
||||
min=0.01,
|
||||
max=6.0,
|
||||
description="Gain - scale factor"
|
||||
)
|
||||
marble_bias = EnumProperty(
|
||||
name="Bias",
|
||||
default="0",
|
||||
description="Marble bias",
|
||||
items = [
|
||||
("0", "Sin", "Sin", 0),
|
||||
("1", "Cos", "Cos", 1),
|
||||
("2", "Tri", "Tri", 2),
|
||||
("3", "Saw", "Saw", 3)]
|
||||
)
|
||||
marble_sharp = EnumProperty(
|
||||
name="Sharp",
|
||||
default="0",
|
||||
description="Marble sharpness",
|
||||
items = [
|
||||
("0", "Soft", "Soft", 0),
|
||||
("1", "Sharp", "Sharp", 1),
|
||||
("2", "Sharper", "Sharper", 2),
|
||||
("3", "Soft inv.", "Soft", 3),
|
||||
("4", "Sharp inv.", "Sharp", 4),
|
||||
("5", "Sharper inv.", "Sharper", 5)]
|
||||
)
|
||||
marble_shape = EnumProperty(
|
||||
name="Shape",
|
||||
default="0",
|
||||
description="Marble shape",
|
||||
items= [
|
||||
("0", "Default", "Default", 0),
|
||||
("1", "Ring", "Ring", 1),
|
||||
("2", "Swirl", "Swirl", 2),
|
||||
("3", "Bump", "Bump", 3),
|
||||
("4", "Wave", "Wave", 4),
|
||||
("5", "Z", "Z", 5),
|
||||
("6", "Y", "Y", 6),
|
||||
("7", "X", "X", 7)]
|
||||
)
|
||||
height = FloatProperty(
|
||||
name="Height",
|
||||
default=0.5,
|
||||
min=-10000.0,
|
||||
max=10000.0,
|
||||
description="Noise intensity scale"
|
||||
)
|
||||
height_invert = BoolProperty(
|
||||
name="Invert",
|
||||
default=False,
|
||||
description="Height invert",
|
||||
)
|
||||
height_offset = FloatProperty(
|
||||
name="Offset",
|
||||
default=0.0,
|
||||
min=-10000.0,
|
||||
max=10000.0,
|
||||
description="Height offset"
|
||||
)
|
||||
edge_falloff = EnumProperty(
|
||||
name="Falloff",
|
||||
default="3",
|
||||
description="Flatten edges",
|
||||
items = [
|
||||
("0", "None", "None", 0),
|
||||
("1", "Y", "Y Falloff", 1),
|
||||
("2", "X", "X Falloff", 2),
|
||||
("3", "X Y", "X Y Falloff", 3)]
|
||||
)
|
||||
falloff_x = FloatProperty(
|
||||
name="Falloff X",
|
||||
default=4.0,
|
||||
min=0.1,
|
||||
max=100.0,
|
||||
description="Falloff x scale"
|
||||
)
|
||||
falloff_y = FloatProperty(
|
||||
name="Falloff Y",
|
||||
default=4.0,
|
||||
min=0.1,
|
||||
max=100.0,
|
||||
description="Falloff y scale"
|
||||
)
|
||||
edge_level = FloatProperty(
|
||||
name="Edge Level",
|
||||
default=0.0,
|
||||
min=-10000.0,
|
||||
max=10000.0,
|
||||
description="Edge level, sealevel offset"
|
||||
)
|
||||
maximum = FloatProperty(
|
||||
name="Maximum",
|
||||
default=1.0,
|
||||
min=-10000.0,
|
||||
max=10000.0,
|
||||
description="Maximum, flattens terrain at plateau level"
|
||||
)
|
||||
minimum = FloatProperty(
|
||||
name="Minimum",
|
||||
default=-1.0,
|
||||
min=-10000.0,
|
||||
max=10000.0,
|
||||
description="Minimum, flattens terrain at seabed level"
|
||||
)
|
||||
use_vgroup = BoolProperty(
|
||||
name="Vertex Group Weight",
|
||||
default=False,
|
||||
description="Use active vertex group weight"
|
||||
)
|
||||
strata = FloatProperty(
|
||||
name="Amount",
|
||||
default=5.0,
|
||||
min=0.01,
|
||||
max=1000.0,
|
||||
description="Strata layers / terraces"
|
||||
)
|
||||
strata_type = EnumProperty(
|
||||
name="Strata",
|
||||
default="0",
|
||||
description="Strata types",
|
||||
items = [
|
||||
("0", "None", "No strata", 0),
|
||||
("1", "Smooth", "Smooth transitions", 1),
|
||||
("2", "Sharp Sub", "Sharp substract transitions", 2),
|
||||
("3", "Sharp Add", "Sharp add transitions", 3),
|
||||
("4", "Posterize", "Posterize", 4),
|
||||
("5", "Posterize Mix", "Posterize mixed", 5)]
|
||||
)
|
||||
water_plane = BoolProperty(
|
||||
name="Water Plane",
|
||||
default=False,
|
||||
description="Add water plane"
|
||||
)
|
||||
water_level = FloatProperty(
|
||||
name="Level",
|
||||
default=0.01,
|
||||
min=-10000.0,
|
||||
max=10000.0,
|
||||
description="Water level"
|
||||
)
|
||||
remove_double = BoolProperty(
|
||||
name="Remove Doubles",
|
||||
default=False,
|
||||
description="Remove doubles"
|
||||
)
|
||||
show_main_settings = BoolProperty(
|
||||
name="Main Settings",
|
||||
default=True,
|
||||
description="Show settings"
|
||||
)
|
||||
show_noise_settings = BoolProperty(
|
||||
name="Noise Settings",
|
||||
default=True,
|
||||
description="Show noise settings"
|
||||
)
|
||||
show_displace_settings = BoolProperty(
|
||||
name="Displace Settings",
|
||||
default=True,
|
||||
description="Show displace settings"
|
||||
)
|
||||
refresh = BoolProperty(
|
||||
name="Refresh",
|
||||
default=False,
|
||||
description="Refresh"
|
||||
)
|
||||
auto_refresh = BoolProperty(
|
||||
name="Auto",
|
||||
default=True,
|
||||
description="Automatic refresh"
|
||||
)
|
||||
|
||||
|
||||
# ------------------------------------------------------------
|
||||
# Register:
|
||||
|
||||
def register():
|
||||
bpy.utils.register_module(__name__)
|
||||
bpy.types.INFO_MT_mesh_add.append(menu_func_landscape)
|
||||
bpy.types.Object.ant_landscape = PointerProperty(type=AntLandscapePropertiesGroup, name="ANT_Landscape", description="Landscape properties", options={'ANIMATABLE'})
|
||||
|
||||
|
||||
def unregister():
|
||||
bpy.utils.unregister_module(__name__)
|
||||
bpy.types.INFO_MT_mesh_add.remove(menu_func_landscape)
|
||||
#del bpy.types.Object.AntLandscapePropertiesGroup
|
||||
|
||||
if __name__ == "__main__":
|
||||
register()
|
||||
|
|
@ -0,0 +1,668 @@
|
|||
# ##### BEGIN GPL LICENSE BLOCK #####
|
||||
#
|
||||
# This program is free software; you can redistribute it and/or
|
||||
# modify it under the terms of the GNU General Public License
|
||||
# as published by the Free Software Foundation; either version 2
|
||||
# of the License, or (at your option) any later version.
|
||||
#
|
||||
# This program is distributed in the hope that it will be useful,
|
||||
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
# GNU General Public License for more details.
|
||||
#
|
||||
# You should have received a copy of the GNU General Public License
|
||||
# along with this program; if not, write to the Free Software Foundation,
|
||||
# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
#
|
||||
# ##### END GPL LICENSE BLOCK #####
|
||||
|
||||
# Another Noise Tool - Landscape
|
||||
# Jim Hazevoet
|
||||
|
||||
# import modules
|
||||
import bpy
|
||||
from bpy.props import (
|
||||
BoolProperty,
|
||||
EnumProperty,
|
||||
FloatProperty,
|
||||
IntProperty,
|
||||
StringProperty,
|
||||
FloatVectorProperty,
|
||||
)
|
||||
|
||||
from .ant_functions import (
|
||||
grid_gen,
|
||||
sphere_gen,
|
||||
create_mesh_object,
|
||||
store_properties,
|
||||
draw_ant_refresh,
|
||||
draw_ant_main,
|
||||
draw_ant_noise,
|
||||
draw_ant_displace,
|
||||
draw_ant_water,
|
||||
)
|
||||
|
||||
# ------------------------------------------------------------
|
||||
# Add landscape
|
||||
class AntAddLandscape(bpy.types.Operator):
|
||||
bl_idname = "mesh.landscape_add"
|
||||
bl_label = "Another Noise Tool - Landscape"
|
||||
bl_description = "Add landscape mesh"
|
||||
bl_options = {'REGISTER', 'UNDO', 'PRESET'}
|
||||
|
||||
ant_terrain_name = StringProperty(
|
||||
name="Name",
|
||||
default="Landscape"
|
||||
)
|
||||
land_material = StringProperty(
|
||||
name='Material',
|
||||
default="",
|
||||
description="Terrain material"
|
||||
)
|
||||
water_material = StringProperty(
|
||||
name='Material',
|
||||
default="",
|
||||
description="Water plane material"
|
||||
)
|
||||
texture_block = StringProperty(
|
||||
name="Texture",
|
||||
default=""
|
||||
)
|
||||
at_cursor = BoolProperty(
|
||||
name="Cursor",
|
||||
default=True,
|
||||
description="Place at cursor location",
|
||||
)
|
||||
smooth_mesh = BoolProperty(
|
||||
name="Smooth",
|
||||
default=True,
|
||||
description="Shade smooth"
|
||||
)
|
||||
tri_face = BoolProperty(
|
||||
name="Triangulate",
|
||||
default=False,
|
||||
description="Triangulate faces"
|
||||
)
|
||||
sphere_mesh = BoolProperty(
|
||||
name="Sphere",
|
||||
default=False,
|
||||
description="Generate uv sphere - remove doubles when ready"
|
||||
)
|
||||
subdivision_x = IntProperty(
|
||||
name="Subdivisions X",
|
||||
default=128,
|
||||
min=4,
|
||||
max=6400,
|
||||
description="Mesh X subdivisions"
|
||||
)
|
||||
subdivision_y = IntProperty(
|
||||
default=128,
|
||||
name="Subdivisions Y",
|
||||
min=4,
|
||||
max=6400,
|
||||
description="Mesh Y subdivisions"
|
||||
)
|
||||
mesh_size = FloatProperty(
|
||||
default=2.0,
|
||||
name="Mesh Size",
|
||||
min=0.01,
|
||||
max=100000.0,
|
||||
description="Mesh size"
|
||||
)
|
||||
mesh_size_x = FloatProperty(
|
||||
default=2.0,
|
||||
name="Mesh Size X",
|
||||
min=0.01,
|
||||
description="Mesh x size"
|
||||
)
|
||||
mesh_size_y = FloatProperty(
|
||||
name="Mesh Size Y",
|
||||
default=2.0,
|
||||
min=0.01,
|
||||
description="Mesh y size"
|
||||
)
|
||||
|
||||
random_seed = IntProperty(
|
||||
name="Random Seed",
|
||||
default=0,
|
||||
min=0,
|
||||
description="Randomize noise origin"
|
||||
)
|
||||
noise_offset_x = FloatProperty(
|
||||
name="Offset X",
|
||||
default=0.0,
|
||||
description="Noise X Offset"
|
||||
)
|
||||
noise_offset_y = FloatProperty(
|
||||
name="Offset Y",
|
||||
default=0.0,
|
||||
description="Noise Y Offset"
|
||||
)
|
||||
noise_offset_z = FloatProperty(
|
||||
name="Offset Z",
|
||||
default=0.0,
|
||||
description="Noise Z Offset"
|
||||
)
|
||||
noise_size_x = FloatProperty(
|
||||
default=1.0,
|
||||
name="Size X",
|
||||
min=0.01,
|
||||
max=1000.0,
|
||||
description="Noise x size"
|
||||
)
|
||||
noise_size_y = FloatProperty(
|
||||
name="Size Y",
|
||||
default=1.0,
|
||||
min=0.01,
|
||||
max=1000.0,
|
||||
description="Noise y size"
|
||||
)
|
||||
noise_size_z = FloatProperty(
|
||||
name="Size Z",
|
||||
default=1.0,
|
||||
min=0.01,
|
||||
max=1000.0,
|
||||
description="Noise Z size"
|
||||
)
|
||||
noise_size = FloatProperty(
|
||||
name="Noise Size",
|
||||
default=1.0,
|
||||
min=0.01,
|
||||
max=1000.0,
|
||||
description="Noise size"
|
||||
)
|
||||
noise_type = EnumProperty(
|
||||
name="Noise Type",
|
||||
default='hetero_terrain',
|
||||
description="Noise type",
|
||||
items = [
|
||||
('multi_fractal', "Multi Fractal", "Blender: Multi Fractal algorithm", 0),
|
||||
('ridged_multi_fractal', "Ridged MFractal", "Blender: Ridged Multi Fractal", 1),
|
||||
('hybrid_multi_fractal', "Hybrid MFractal", "Blender: Hybrid Multi Fractal", 2),
|
||||
('hetero_terrain', "Hetero Terrain", "Blender: Hetero Terrain", 3),
|
||||
('fractal', "fBm Fractal", "Blender: fBm - Fractional Browninian motion", 4),
|
||||
('turbulence_vector', "Turbulence", "Blender: Turbulence Vector", 5),
|
||||
('variable_lacunarity', "Distorted Noise", "Blender: Distorted Noise", 6),
|
||||
('marble_noise', "Marble", "A.N.T.: Marble Noise", 7),
|
||||
('shattered_hterrain', "Shattered hTerrain", "A.N.T.: Shattered hTerrain", 8),
|
||||
('strata_hterrain', "Strata hTerrain", "A.N.T: Strata hTerrain", 9),
|
||||
('ant_turbulence', "Another Turbulence", "A.N.T: Turbulence variation", 10),
|
||||
('vl_noise_turbulence', "vlNoise turbulence", "A.N.T: vlNoise turbulence", 11),
|
||||
('vl_hTerrain', "vlNoise hTerrain", "A.N.T: vlNoise hTerrain", 12),
|
||||
('distorted_heteroTerrain', "Distorted hTerrain", "A.N.T distorted hTerrain", 13),
|
||||
('double_multiFractal', "Double MultiFractal", "A.N.T: double multiFractal", 14),
|
||||
('slick_rock', "Slick Rock", "A.N.T: slick rock", 15),
|
||||
('planet_noise', "Planet Noise", "Planet Noise by: Farsthary", 16),
|
||||
('blender_texture', "Blender Texture - Texture Nodes", "Blender texture data block", 17)]
|
||||
)
|
||||
basis_type = EnumProperty(
|
||||
name="Noise Basis",
|
||||
default="0",
|
||||
description="Noise basis algorithms",
|
||||
items = [
|
||||
("0", "Blender", "Blender default noise", 0),
|
||||
("1", "Perlin", "Perlin noise", 1),
|
||||
("2", "New Perlin", "New Perlin noise", 2),
|
||||
("3", "Voronoi F1", "Voronoi F1", 3),
|
||||
("4", "Voronoi F2", "Voronoi F2", 4),
|
||||
("5", "Voronoi F3", "Voronoi F3", 5),
|
||||
("6", "Voronoi F4", "Voronoi F4", 6),
|
||||
("7", "Voronoi F2-F1", "Voronoi F2-F1", 7),
|
||||
("8", "Voronoi Crackle", "Voronoi Crackle", 8),
|
||||
("9", "Cell Noise", "Cell noise", 9)]
|
||||
)
|
||||
vl_basis_type = EnumProperty(
|
||||
name="vlNoise Basis",
|
||||
default="0",
|
||||
description="VLNoise basis algorithms",
|
||||
items = [
|
||||
("0", "Blender", "Blender default noise", 0),
|
||||
("1", "Perlin", "Perlin noise", 1),
|
||||
("2", "New Perlin", "New Perlin noise", 2),
|
||||
("3", "Voronoi F1", "Voronoi F1", 3),
|
||||
("4", "Voronoi F2", "Voronoi F2", 4),
|
||||
("5", "Voronoi F3", "Voronoi F3", 5),
|
||||
("6", "Voronoi F4", "Voronoi F4", 6),
|
||||
("7", "Voronoi F2-F1", "Voronoi F2-F1", 7),
|
||||
("8", "Voronoi Crackle", "Voronoi Crackle", 8),
|
||||
("9", "Cell Noise", "Cell noise", 9)]
|
||||
)
|
||||
distortion = FloatProperty(
|
||||
name="Distortion",
|
||||
default=1.0,
|
||||
min=0.01,
|
||||
max=100.0,
|
||||
description="Distortion amount"
|
||||
)
|
||||
hard_noise = EnumProperty(
|
||||
name="Soft Hard",
|
||||
default="0",
|
||||
description="Soft Noise, Hard noise",
|
||||
items = [
|
||||
("0", "Soft", "Soft Noise", 0),
|
||||
("1", "Hard", "Hard noise", 1)]
|
||||
)
|
||||
noise_depth = IntProperty(
|
||||
name="Depth",
|
||||
default=8,
|
||||
min=0,
|
||||
max=16,
|
||||
description="Noise Depth - number of frequencies in the fBm"
|
||||
)
|
||||
amplitude = FloatProperty(
|
||||
name="Amp",
|
||||
default=0.5,
|
||||
min=0.01,
|
||||
max=1.0,
|
||||
description="Amplitude"
|
||||
)
|
||||
frequency = FloatProperty(
|
||||
name="Freq",
|
||||
default=2.0,
|
||||
min=0.01,
|
||||
max=5.0,
|
||||
description="Frequency"
|
||||
)
|
||||
dimension = FloatProperty(
|
||||
name="Dimension",
|
||||
default=1.0,
|
||||
min=0.01,
|
||||
max=2.0,
|
||||
description="H - fractal dimension of the roughest areas"
|
||||
)
|
||||
lacunarity = FloatProperty(
|
||||
name="Lacunarity",
|
||||
min=0.01,
|
||||
max=6.0,
|
||||
default=2.0,
|
||||
description="Lacunarity - gap between successive frequencies"
|
||||
)
|
||||
offset = FloatProperty(
|
||||
name="Offset",
|
||||
default=1.0,
|
||||
min=0.01,
|
||||
max=6.0,
|
||||
description="Offset - raises the terrain from sea level"
|
||||
)
|
||||
gain = FloatProperty(
|
||||
name="Gain",
|
||||
default=1.0,
|
||||
min=0.01,
|
||||
max=6.0,
|
||||
description="Gain - scale factor"
|
||||
)
|
||||
marble_bias = EnumProperty(
|
||||
name="Bias",
|
||||
default="0",
|
||||
description="Marble bias",
|
||||
items = [
|
||||
("0", "Sin", "Sin", 0),
|
||||
("1", "Cos", "Cos", 1),
|
||||
("2", "Tri", "Tri", 2),
|
||||
("3", "Saw", "Saw", 3)]
|
||||
)
|
||||
marble_sharp = EnumProperty(
|
||||
name="Sharp",
|
||||
default="0",
|
||||
description="Marble sharpness",
|
||||
items = [
|
||||
("0", "Soft", "Soft", 0),
|
||||
("1", "Sharp", "Sharp", 1),
|
||||
("2", "Sharper", "Sharper", 2),
|
||||
("3", "Soft inv.", "Soft", 3),
|
||||
("4", "Sharp inv.", "Sharp", 4),
|
||||
("5", "Sharper inv.", "Sharper", 5)]
|
||||
)
|
||||
marble_shape = EnumProperty(
|
||||
name="Shape",
|
||||
default="0",
|
||||
description="Marble shape",
|
||||
items= [
|
||||
("0", "Default", "Default", 0),
|
||||
("1", "Ring", "Ring", 1),
|
||||
("2", "Swirl", "Swirl", 2),
|
||||
("3", "Bump", "Bump", 3),
|
||||
("4", "Wave", "Wave", 4),
|
||||
("5", "Z", "Z", 5),
|
||||
("6", "Y", "Y", 6),
|
||||
("7", "X", "X", 7)]
|
||||
)
|
||||
height = FloatProperty(
|
||||
name="Height",
|
||||
default=0.5,
|
||||
min=-10000.0,
|
||||
max=10000.0,
|
||||
description="Noise intensity scale"
|
||||
)
|
||||
height_invert = BoolProperty(
|
||||
name="Invert",
|
||||
default=False,
|
||||
description="Height invert",
|
||||
)
|
||||
height_offset = FloatProperty(
|
||||
name="Offset",
|
||||
default=0.0,
|
||||
min=-10000.0,
|
||||
max=10000.0,
|
||||
description="Height offset"
|
||||
)
|
||||
edge_falloff = EnumProperty(
|
||||
name="Falloff",
|
||||
default="3",
|
||||
description="Flatten edges",
|
||||
items = [
|
||||
("0", "None", "None", 0),
|
||||
("1", "Y", "Y Falloff", 1),
|
||||
("2", "X", "X Falloff", 2),
|
||||
("3", "X Y", "X Y Falloff", 3)]
|
||||
)
|
||||
falloff_x = FloatProperty(
|
||||
name="Falloff X",
|
||||
default=4.0,
|
||||
min=0.1,
|
||||
max=100.0,
|
||||
description="Falloff x scale"
|
||||
)
|
||||
falloff_y = FloatProperty(
|
||||
name="Falloff Y",
|
||||
default=4.0,
|
||||
min=0.1,
|
||||
max=100.0,
|
||||
description="Falloff y scale"
|
||||
)
|
||||
edge_level = FloatProperty(
|
||||
name="Edge Level",
|
||||
default=0.0,
|
||||
min=-10000.0,
|
||||
max=10000.0,
|
||||
description="Edge level, sealevel offset"
|
||||
)
|
||||
maximum = FloatProperty(
|
||||
name="Maximum",
|
||||
default=1.0,
|
||||
min=-10000.0,
|
||||
max=10000.0,
|
||||
description="Maximum, flattens terrain at plateau level"
|
||||
)
|
||||
minimum = FloatProperty(
|
||||
name="Minimum",
|
||||
default=-1.0,
|
||||
min=-10000.0,
|
||||
max=10000.0,
|
||||
description="Minimum, flattens terrain at seabed level"
|
||||
)
|
||||
use_vgroup = BoolProperty(
|
||||
name="Vertex Group Weight",
|
||||
default=False,
|
||||
description="Use active vertex group weight"
|
||||
)
|
||||
strata = FloatProperty(
|
||||
name="Amount",
|
||||
default=5.0,
|
||||
min=0.01,
|
||||
max=1000.0,
|
||||
description="Strata layers / terraces"
|
||||
)
|
||||
strata_type = EnumProperty(
|
||||
name="Strata",
|
||||
default="0",
|
||||
description="Strata types",
|
||||
items = [
|
||||
("0", "None", "No strata", 0),
|
||||
("1", "Smooth", "Smooth transitions", 1),
|
||||
("2", "Sharp Sub", "Sharp substract transitions", 2),
|
||||
("3", "Sharp Add", "Sharp add transitions", 3),
|
||||
("4", "Posterize", "Posterize", 4),
|
||||
("5", "Posterize Mix", "Posterize mixed", 5)]
|
||||
)
|
||||
water_plane = BoolProperty(
|
||||
name="Water Plane",
|
||||
default=False,
|
||||
description="Add water plane"
|
||||
)
|
||||
water_level = FloatProperty(
|
||||
name="Level",
|
||||
default=0.01,
|
||||
min=-10000.0,
|
||||
max=10000.0,
|
||||
description="Water level"
|
||||
)
|
||||
remove_double = BoolProperty(
|
||||
name="Remove Doubles",
|
||||
default=False,
|
||||
description="Remove doubles"
|
||||
)
|
||||
show_main_settings = BoolProperty(
|
||||
name="Main Settings",
|
||||
default=True,
|
||||
description="Show settings"
|
||||
)
|
||||
show_noise_settings = BoolProperty(
|
||||
name="Noise Settings",
|
||||
default=True,
|
||||
description="Show noise settings"
|
||||
)
|
||||
show_displace_settings = BoolProperty(
|
||||
name="Displace Settings",
|
||||
default=True,
|
||||
description="Show displace settings"
|
||||
)
|
||||
refresh = BoolProperty(
|
||||
name="Refresh",
|
||||
default=False,
|
||||
description="Refresh"
|
||||
)
|
||||
auto_refresh = BoolProperty(
|
||||
name="Auto",
|
||||
default=True,
|
||||
description="Automatic refresh"
|
||||
)
|
||||
|
||||
|
||||
def draw(self, context):
|
||||
draw_ant_refresh(self, context)
|
||||
draw_ant_main(self, context, generate=True)
|
||||
draw_ant_noise(self, context)
|
||||
draw_ant_displace(self, context, generate=True)
|
||||
draw_ant_water(self, context)
|
||||
|
||||
|
||||
def invoke(self, context, event):
|
||||
self.refresh = True
|
||||
return self.execute(context)
|
||||
|
||||
|
||||
def execute(self, context):
|
||||
if not self.refresh:
|
||||
return {'PASS_THROUGH'}
|
||||
|
||||
# turn off undo
|
||||
undo = bpy.context.user_preferences.edit.use_global_undo
|
||||
bpy.context.user_preferences.edit.use_global_undo = False
|
||||
|
||||
# deselect all objects when in object mode
|
||||
if bpy.ops.object.select_all.poll():
|
||||
bpy.ops.object.select_all(action='DESELECT')
|
||||
|
||||
# Properties
|
||||
ant_props = [
|
||||
self.ant_terrain_name,
|
||||
self.at_cursor,
|
||||
self.smooth_mesh,
|
||||
self.tri_face,
|
||||
self.sphere_mesh,
|
||||
self.land_material,
|
||||
self.water_material,
|
||||
self.texture_block,
|
||||
self.subdivision_x,
|
||||
self.subdivision_y,
|
||||
self.mesh_size_x,
|
||||
self.mesh_size_y,
|
||||
self.mesh_size,
|
||||
self.random_seed,
|
||||
self.noise_offset_x,
|
||||
self.noise_offset_y,
|
||||
self.noise_offset_z,
|
||||
self.noise_size_x,
|
||||
self.noise_size_y,
|
||||
self.noise_size_z,
|
||||
self.noise_size,
|
||||
self.noise_type,
|
||||
self.basis_type,
|
||||
self.vl_basis_type,
|
||||
self.distortion,
|
||||
self.hard_noise,
|
||||
self.noise_depth,
|
||||
self.amplitude,
|
||||
self.frequency,
|
||||
self.dimension,
|
||||
self.lacunarity,
|
||||
self.offset,
|
||||
self.gain,
|
||||
self.marble_bias,
|
||||
self.marble_sharp,
|
||||
self.marble_shape,
|
||||
self.height,
|
||||
self.height_invert,
|
||||
self.height_offset,
|
||||
self.maximum,
|
||||
self.minimum,
|
||||
self.edge_falloff,
|
||||
self.edge_level,
|
||||
self.falloff_x,
|
||||
self.falloff_y,
|
||||
self.strata_type,
|
||||
self.strata,
|
||||
self.water_plane,
|
||||
self.water_level,
|
||||
self.use_vgroup,
|
||||
self.remove_double
|
||||
]
|
||||
|
||||
scene = context.scene
|
||||
|
||||
# Main function, create landscape mesh object
|
||||
if self.ant_terrain_name != "":
|
||||
new_name = self.ant_terrain_name
|
||||
else:
|
||||
new_name = "Landscape"
|
||||
|
||||
if self.sphere_mesh:
|
||||
# sphere
|
||||
verts, faces = sphere_gen(
|
||||
self.subdivision_y,
|
||||
self.subdivision_x,
|
||||
self.tri_face,
|
||||
self.mesh_size,
|
||||
ant_props,
|
||||
False,
|
||||
0.0
|
||||
)
|
||||
new_ob = create_mesh_object(context, verts, [], faces, new_name)
|
||||
if self.remove_double:
|
||||
new_ob.select = True
|
||||
bpy.ops.object.mode_set(mode = 'EDIT')
|
||||
bpy.ops.mesh.remove_doubles(threshold=0.0001, use_unselected=False)
|
||||
bpy.ops.object.mode_set(mode = 'OBJECT')
|
||||
else:
|
||||
# grid
|
||||
verts, faces = grid_gen(
|
||||
self.subdivision_x,
|
||||
self.subdivision_y,
|
||||
self.tri_face,
|
||||
self.mesh_size_x,
|
||||
self.mesh_size_y,
|
||||
ant_props,
|
||||
False,
|
||||
0.0
|
||||
)
|
||||
new_ob = create_mesh_object(context, verts, [], faces, new_name)
|
||||
|
||||
new_ob.select = True
|
||||
|
||||
if self.smooth_mesh:
|
||||
bpy.ops.object.shade_smooth()
|
||||
|
||||
if not self.at_cursor:
|
||||
new_ob.object.location = (0.0, 0.0, 0.0)
|
||||
|
||||
# Landscape Material
|
||||
if self.land_material != "" and self.land_material in bpy.data.materials:
|
||||
mat = bpy.data.materials[self.land_material]
|
||||
bpy.context.object.data.materials.append(mat)
|
||||
|
||||
# Water plane
|
||||
if self.water_plane:
|
||||
if self.sphere_mesh:
|
||||
# sphere
|
||||
verts, faces = sphere_gen(
|
||||
self.subdivision_y,
|
||||
self.subdivision_x,
|
||||
self.tri_face,
|
||||
self.mesh_size,
|
||||
ant_props,
|
||||
self.water_plane,
|
||||
self.water_level
|
||||
)
|
||||
wobj = create_mesh_object(context, verts, [], faces, new_name+"_plane")
|
||||
if self.remove_double:
|
||||
wobj.select = True
|
||||
bpy.ops.object.mode_set(mode = 'EDIT')
|
||||
bpy.ops.mesh.remove_doubles(threshold=0.0001, use_unselected=False)
|
||||
bpy.ops.object.mode_set(mode = 'OBJECT')
|
||||
else:
|
||||
# grid
|
||||
verts, faces = grid_gen(
|
||||
2,
|
||||
2,
|
||||
self.tri_face,
|
||||
self.mesh_size_x,
|
||||
self.mesh_size_y,
|
||||
ant_props,
|
||||
self.water_plane,
|
||||
self.water_level
|
||||
)
|
||||
wobj = create_mesh_object(context, verts, [], faces, new_name+"_plane")
|
||||
|
||||
wobj.select = True
|
||||
|
||||
if self.smooth_mesh:
|
||||
bpy.ops.object.shade_smooth()
|
||||
|
||||
if not self.at_cursor:
|
||||
wobj.object.location = (0.0, 0.0, 0.0)
|
||||
|
||||
# Water Material
|
||||
if self.water_material != "" and self.water_material in bpy.data.materials:
|
||||
mat = bpy.data.materials[self.water_material]
|
||||
bpy.context.object.data.materials.append(mat)
|
||||
|
||||
# select landscape and make active
|
||||
new_ob.select = True
|
||||
scene.objects.active = new_ob.object
|
||||
#
|
||||
new_ob = store_properties(self, new_ob.object)
|
||||
|
||||
if self.auto_refresh is False:
|
||||
self.refresh = False
|
||||
|
||||
# restore pre operator undo state
|
||||
context.user_preferences.edit.use_global_undo = undo
|
||||
|
||||
return {'FINISHED'}
|
||||
|
||||
'''
|
||||
# ------------------------------------------------------------
|
||||
# Register:
|
||||
|
||||
def register():
|
||||
bpy.utils.register_module(__name__)
|
||||
|
||||
|
||||
def unregister():
|
||||
bpy.utils.unregister_module(__name__)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
register()
|
||||
'''
|
||||
|
|
@ -0,0 +1,930 @@
|
|||
# ##### BEGIN GPL LICENSE BLOCK #####
|
||||
#
|
||||
# This program is free software; you can redistribute it and/or
|
||||
# modify it under the terms of the GNU General Public License
|
||||
# as published by the Free Software Foundation; either version 2
|
||||
# of the License, or (at your option) any later version.
|
||||
#
|
||||
# This program is distributed in the hope that it will be useful,
|
||||
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
# GNU General Public License for more details.
|
||||
#
|
||||
# You should have received a copy of the GNU General Public License
|
||||
# along with this program; if not, write to the Free Software Foundation,
|
||||
# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
#
|
||||
# ##### END GPL LICENSE BLOCK #####
|
||||
|
||||
# Another Noise Tool - Functions
|
||||
# Jim Hazevoet
|
||||
|
||||
# import modules
|
||||
import bpy
|
||||
from bpy.props import (
|
||||
BoolProperty,
|
||||
FloatProperty,
|
||||
StringProperty,
|
||||
EnumProperty,
|
||||
IntProperty,
|
||||
PointerProperty
|
||||
)
|
||||
from mathutils.noise import (
|
||||
seed_set,
|
||||
turbulence,
|
||||
turbulence_vector,
|
||||
fractal,
|
||||
hybrid_multi_fractal,
|
||||
multi_fractal,
|
||||
ridged_multi_fractal,
|
||||
hetero_terrain,
|
||||
random_unit_vector,
|
||||
variable_lacunarity,
|
||||
)
|
||||
from math import (
|
||||
floor, sqrt,
|
||||
sin, cos, pi,
|
||||
)
|
||||
|
||||
# ------------------------------------------------------------
|
||||
# Create a new mesh (object) from verts/edges/faces.
|
||||
# verts/edges/faces ... List of vertices/edges/faces for the
|
||||
# new mesh (as used in from_pydata).
|
||||
# name ... Name of the new mesh (& object)
|
||||
|
||||
from bpy_extras import object_utils
|
||||
|
||||
def create_mesh_object(context, verts, edges, faces, name):
|
||||
# Create new mesh
|
||||
mesh = bpy.data.meshes.new(name)
|
||||
|
||||
# Make a mesh from a list of verts/edges/faces.
|
||||
mesh.from_pydata(verts, [], faces)
|
||||
|
||||
# Update mesh geometry after adding stuff.
|
||||
mesh.update()
|
||||
|
||||
#new_ob = bpy.data.objects.new(name, mesh)
|
||||
#context.scene.objects.link(new_ob)
|
||||
return object_utils.object_data_add(context, mesh, operator=None)
|
||||
#return new_ob
|
||||
|
||||
|
||||
# Generate XY Grid
|
||||
def grid_gen(sub_d_x, sub_d_y, tri, meshsize_x, meshsize_y, props, water_plane, water_level):
|
||||
verts = []
|
||||
faces = []
|
||||
for i in range (0, sub_d_x):
|
||||
x = meshsize_x * (i / (sub_d_x - 1) - 1 / 2)
|
||||
for j in range(0, sub_d_y):
|
||||
y = meshsize_y * (j / (sub_d_y - 1) - 1 / 2)
|
||||
if water_plane:
|
||||
z = water_level
|
||||
else:
|
||||
z = noise_gen((x, y, 0), props)
|
||||
|
||||
verts.append((x,y,z))
|
||||
|
||||
count = 0
|
||||
for i in range (0, sub_d_y * (sub_d_x - 1)):
|
||||
if count < sub_d_y - 1 :
|
||||
A = i + 1
|
||||
B = i
|
||||
C = (i + sub_d_y)
|
||||
D = (i + sub_d_y) + 1
|
||||
if tri:
|
||||
faces.append((A, B, D))
|
||||
faces.append((B, C, D))
|
||||
else:
|
||||
faces.append((A, B, C, D))
|
||||
count = count + 1
|
||||
else:
|
||||
count = 0
|
||||
|
||||
return verts, faces
|
||||
|
||||
|
||||
# Generate UV Sphere
|
||||
def sphere_gen(sub_d_x, sub_d_y, tri, meshsize, props, water_plane, water_level):
|
||||
verts = []
|
||||
faces = []
|
||||
sub_d_x += 1
|
||||
sub_d_y += 1
|
||||
for i in range(0, sub_d_x):
|
||||
for j in range(0, sub_d_y):
|
||||
u = sin(j * pi * 2 / (sub_d_y - 1)) * cos(-pi / 2 + i * pi / (sub_d_x - 1)) * meshsize / 2
|
||||
v = cos(j * pi * 2 / (sub_d_y - 1)) * cos(-pi / 2 + i * pi / (sub_d_x - 1)) * meshsize / 2
|
||||
w = sin(-pi / 2 + i * pi / (sub_d_x - 1)) * meshsize / 2
|
||||
if water_plane:
|
||||
h = water_level
|
||||
else:
|
||||
h = noise_gen((u, v, w), props) / meshsize
|
||||
verts.append(((u + u * h), (v + v * h), (w + w * h)))
|
||||
|
||||
count = 0
|
||||
for i in range (0, sub_d_y * (sub_d_x - 1)):
|
||||
if count < sub_d_y - 1 :
|
||||
A = i + 1
|
||||
B = i
|
||||
C = (i + sub_d_y)
|
||||
D = (i + sub_d_y) + 1
|
||||
if tri:
|
||||
faces.append((A, B, D))
|
||||
faces.append((B, C, D))
|
||||
else:
|
||||
faces.append((A, B, C, D))
|
||||
count = count + 1
|
||||
else:
|
||||
count = 0
|
||||
|
||||
return verts, faces
|
||||
|
||||
|
||||
# Z normal value to vertex group (Slope map)
|
||||
class AntVgSlopeMap(bpy.types.Operator):
|
||||
bl_idname = "mesh.ant_slope_map"
|
||||
bl_label = "Weight from Slope"
|
||||
bl_description = "A.N.T. Slope Map - z normal value to vertex group weight"
|
||||
bl_options = {'REGISTER', 'UNDO'}
|
||||
|
||||
z_method = EnumProperty(
|
||||
name="Method:",
|
||||
default='SLOPE_Z',
|
||||
items=[
|
||||
('SLOPE_Z', "Slope Z", "Slope for planar mesh"),
|
||||
('SLOPE_XYZ', "Slope XYZ", "Slope for spherical mesh")
|
||||
])
|
||||
group_name = StringProperty(
|
||||
name="Vertex Group Name:",
|
||||
default="Slope",
|
||||
description="Name"
|
||||
)
|
||||
select_flat = BoolProperty(
|
||||
name="Vert Select:",
|
||||
default=True,
|
||||
description="Select vertices on flat surface"
|
||||
)
|
||||
select_range = FloatProperty(
|
||||
name="Vert Select Range:",
|
||||
default=0.0,
|
||||
min=0.0,
|
||||
max=1.0,
|
||||
description="Increase to select more vertices"
|
||||
)
|
||||
|
||||
@classmethod
|
||||
def poll(cls, context):
|
||||
ob = context.object
|
||||
return (ob and ob.type == 'MESH')
|
||||
|
||||
|
||||
def invoke(self, context, event):
|
||||
wm = context.window_manager
|
||||
return wm.invoke_props_dialog(self)
|
||||
|
||||
|
||||
def execute(self, context):
|
||||
message = "Popup Values: %d, %f, %s, %s" % \
|
||||
(self.select_flat, self.select_range, self.group_name, self.z_method)
|
||||
self.report({'INFO'}, message)
|
||||
|
||||
ob = bpy.context.active_object
|
||||
dim = ob.dimensions
|
||||
|
||||
if self.select_flat:
|
||||
bpy.ops.object.mode_set(mode='EDIT')
|
||||
bpy.ops.mesh.select_all(action='DESELECT')
|
||||
bpy.context.tool_settings.mesh_select_mode = [True, False, False]
|
||||
bpy.ops.object.mode_set(mode='OBJECT')
|
||||
|
||||
bpy.ops.object.vertex_group_add()
|
||||
vg_normal = ob.vertex_groups.active
|
||||
|
||||
for v in ob.data.vertices:
|
||||
if self.z_method == 'SLOPE_XYZ':
|
||||
zval = (v.co.normalized() * v.normal.normalized()) * 2 - 1
|
||||
else:
|
||||
zval = v.normal[2]
|
||||
|
||||
vg_normal.add([v.index], zval, 'REPLACE')
|
||||
|
||||
if self.select_flat:
|
||||
if zval >= (1.0 - self.select_range):
|
||||
v.select = True
|
||||
|
||||
vg_normal.name = self.group_name
|
||||
|
||||
return {'FINISHED'}
|
||||
|
||||
|
||||
# ------------------------------------------------------------
|
||||
# A.N.T. Noise:
|
||||
|
||||
# Functions for marble_noise:
|
||||
def sin_bias(a):
|
||||
return 0.5 + 0.5 * sin(a)
|
||||
|
||||
|
||||
def cos_bias(a):
|
||||
return 0.5 + 0.5 * cos(a)
|
||||
|
||||
|
||||
def tri_bias(a):
|
||||
b = 2 * pi
|
||||
a = 1 - 2 * abs(floor((a * (1 / b)) + 0.5) - (a * (1 / b)))
|
||||
return a
|
||||
|
||||
|
||||
def saw_bias(a):
|
||||
b = 2 * pi
|
||||
n = int(a / b)
|
||||
a -= n * b
|
||||
if a < 0:
|
||||
a += b
|
||||
return a / b
|
||||
|
||||
|
||||
def soft(a):
|
||||
return a
|
||||
|
||||
|
||||
def sharp(a):
|
||||
return a**0.5
|
||||
|
||||
|
||||
def sharper(a):
|
||||
return sharp(sharp(a))
|
||||
|
||||
|
||||
def shapes(x, y, z, shape=0):
|
||||
p = pi
|
||||
if shape is 1:
|
||||
# ring
|
||||
x = x * p
|
||||
y = y * p
|
||||
s = cos(x**2 + y**2) / (x**2 + y**2 + 0.5)
|
||||
elif shape is 2:
|
||||
# swirl
|
||||
x = x * p
|
||||
y = y * p
|
||||
s = ((x * sin(x * x + y * y) + y * cos(x * x + y * y)) / (x**2 + y**2 + 0.5))
|
||||
elif shape is 3:
|
||||
# bumps
|
||||
x = x * p
|
||||
y = y * p
|
||||
z = z * p
|
||||
s = 1 - ((cos(x * p) + cos(y * p) + cos(z * p)) - 0.5)
|
||||
elif shape is 4:
|
||||
# wave
|
||||
x = x * p * 2
|
||||
y = y * p * 2
|
||||
s = sin(x + sin(y))
|
||||
elif shape is 5:
|
||||
# x grad.
|
||||
s = (z * p)
|
||||
elif shape is 6:
|
||||
# y grad.
|
||||
s = (y * p)
|
||||
elif shape is 7:
|
||||
# x grad.
|
||||
s = (x * p)
|
||||
else:
|
||||
# marble default
|
||||
s = ((x + y + z) * 5)
|
||||
return s
|
||||
|
||||
|
||||
# marble_noise
|
||||
def marble_noise(x, y, z, origin, size, shape, bias, sharpnes, turb, depth, hard, basis, amp, freq):
|
||||
|
||||
s = shapes(x, y, z, shape)
|
||||
x += origin[0]
|
||||
y += origin[1]
|
||||
z += origin[2]
|
||||
value = s + turb * turbulence_vector((x, y, z), depth, hard, basis)[1]
|
||||
|
||||
if bias is 1:
|
||||
value = cos_bias(value)
|
||||
elif bias is 2:
|
||||
value = tri_bias(value)
|
||||
elif bias is 3:
|
||||
value = saw_bias(value)
|
||||
else:
|
||||
value = sin_bias(value)
|
||||
|
||||
if sharpnes is 1:
|
||||
value = 1.0 - sharp(value)
|
||||
elif sharpnes is 2:
|
||||
value = 1.0 - sharper(value)
|
||||
elif sharpnes is 3:
|
||||
value = soft(value)
|
||||
elif sharpnes is 4:
|
||||
value = sharp(value)
|
||||
elif sharpnes is 5:
|
||||
value = sharper(value)
|
||||
else:
|
||||
value = 1.0 - soft(value)
|
||||
|
||||
return value
|
||||
|
||||
|
||||
# vl_noise_turbulence:
|
||||
def vlnTurbMode(coords, distort, basis, vlbasis, hardnoise):
|
||||
# hard noise
|
||||
if hardnoise:
|
||||
return (abs(-variable_lacunarity(coords, distort, basis, vlbasis)))
|
||||
# soft noise
|
||||
else:
|
||||
return variable_lacunarity(coords, distort, basis, vlbasis)
|
||||
|
||||
|
||||
def vl_noise_turbulence(coords, distort, depth, basis, vlbasis, hardnoise, amp, freq):
|
||||
x, y, z = coords
|
||||
value = vlnTurbMode(coords, distort, basis, vlbasis, hardnoise)
|
||||
i=0
|
||||
for i in range(depth):
|
||||
i+=1
|
||||
value += vlnTurbMode((x * (freq * i), y * (freq * i), z * (freq * i)), distort, basis, vlbasis, hardnoise) * (amp * 0.5 / i)
|
||||
return value
|
||||
|
||||
|
||||
## duo_multiFractal:
|
||||
def double_multiFractal(coords, H, lacunarity, octaves, offset, gain, basis, vlbasis):
|
||||
x, y, z = coords
|
||||
n1 = multi_fractal((x * 1.5 + 1, y * 1.5 + 1, z * 1.5 + 1), 1.0, 1.0, 1.0, basis) * (offset * 0.5)
|
||||
n2 = multi_fractal((x - 1, y - 1, z - 1), H, lacunarity, octaves, vlbasis) * (gain * 0.5)
|
||||
return (n1 * n1 + n2 * n2) * 0.5
|
||||
|
||||
|
||||
## distorted_heteroTerrain:
|
||||
def distorted_heteroTerrain(coords, H, lacunarity, octaves, offset, distort, basis, vlbasis):
|
||||
x, y, z = coords
|
||||
h1 = (hetero_terrain((x, y, z), 1.0, 2.0, 1.0, 1.0, basis) * 0.5)
|
||||
d = h1 * distort
|
||||
h2 = (hetero_terrain((x + d, y + d, z + d), H, lacunarity, octaves, offset, vlbasis) * 0.25)
|
||||
return (h1 * h1 + h2 * h2) * 0.5
|
||||
|
||||
|
||||
## SlickRock:
|
||||
def slick_rock(coords, H, lacunarity, octaves, offset, gain, distort, basis, vlbasis):
|
||||
x, y, z = coords
|
||||
n = multi_fractal((x,y,z), 1.0, 2.0, 2.0, basis) * distort * 0.25
|
||||
r = ridged_multi_fractal((x + n, y + n, z + n), H, lacunarity, octaves, offset + 0.1, gain * 2, vlbasis)
|
||||
return (n + (n * r)) * 0.5
|
||||
|
||||
|
||||
## vlhTerrain
|
||||
def vl_hTerrain(coords, H, lacunarity, octaves, offset, basis, vlbasis, distort):
|
||||
x, y, z = coords
|
||||
ht = hetero_terrain((x, y, z), H, lacunarity, octaves, offset, basis ) * 0.25
|
||||
vl = ht * variable_lacunarity((x, y, z), distort, basis, vlbasis) * 0.5 + 0.5
|
||||
return vl * ht
|
||||
|
||||
|
||||
# another turbulence
|
||||
def ant_turbulence(coords, depth, hardnoise, nbasis, amp, freq, distortion):
|
||||
x, y, z = coords
|
||||
tv = turbulence_vector((x + 1, y + 2, z + 3), depth, hardnoise, nbasis, amp, freq)
|
||||
d = (distortion * tv[0]) * 0.25
|
||||
return (d + ((tv[0] - tv[1]) * (tv[2])**2))
|
||||
|
||||
|
||||
# shattered_hterrain:
|
||||
def shattered_hterrain(coords, H, lacunarity, octaves, offset, distort, basis):
|
||||
x, y, z = coords
|
||||
d = (turbulence_vector(coords, 6, 0, 0)[0] * 0.5 + 0.5) * distort * 0.5
|
||||
t1 = (turbulence_vector((x + d, y + d, z + d), 0, 0, 7)[0] + 0.5)
|
||||
t2 = (hetero_terrain((x * 2, y * 2, z * 2), H, lacunarity, octaves, offset, basis) * 0.5)
|
||||
return ((t1 * t2) + t2 * 0.5) * 0.5
|
||||
|
||||
|
||||
# strata_hterrain
|
||||
def strata_hterrain(coords, H, lacunarity, octaves, offset, distort, basis):
|
||||
x, y, z = coords
|
||||
value = hetero_terrain((x, y, z), H, lacunarity, octaves, offset, basis) * 0.5
|
||||
steps = (sin(value * (distort * 5) * pi) * (0.1 / (distort * 5) * pi))
|
||||
return (value * (1.0 - 0.5) + steps * 0.5)
|
||||
|
||||
|
||||
# Planet Noise by: Farsthary
|
||||
# https://farsthary.com/2010/11/24/new-planet-procedural-texture/
|
||||
def planet_noise(coords, oct=6, hard=0, noisebasis=1, nabla=0.001):
|
||||
x, y, z = coords
|
||||
d = 0.001
|
||||
offset = nabla * 1000
|
||||
x = turbulence((x, y, z), oct, hard, noisebasis)
|
||||
y = turbulence((x + offset, y, z), oct, hard, noisebasis)
|
||||
z = turbulence((x, y + offset, z), oct, hard, noisebasis)
|
||||
xdy = x - turbulence((x, y + d, z), oct, hard, noisebasis)
|
||||
xdz = x - turbulence((x, y, z + d), oct, hard, noisebasis)
|
||||
ydx = y - turbulence((x + d, y, z), oct, hard, noisebasis)
|
||||
ydz = y - turbulence((x, y, z + d), oct, hard, noisebasis)
|
||||
zdx = z - turbulence((x + d, y, z), oct, hard, noisebasis)
|
||||
zdy = z - turbulence((x, y + d, z), oct, hard, noisebasis)
|
||||
return (zdy - ydz), (zdx - xdz), (ydx - xdy)
|
||||
|
||||
|
||||
# ------------------------------------------------------------
|
||||
# landscape_gen
|
||||
def noise_gen(coords, props):
|
||||
|
||||
terrain_name = props[0]
|
||||
cursor = props[1]
|
||||
smooth = props[2]
|
||||
triface = props[3]
|
||||
sphere = props[4]
|
||||
land_mat = props[5]
|
||||
water_mat = props[6]
|
||||
texture_name = props[7]
|
||||
subd_x = props[8]
|
||||
subd_y = props[9]
|
||||
meshsize_x = props[10]
|
||||
meshsize_y = props[11]
|
||||
meshsize = props[12]
|
||||
rseed = props[13]
|
||||
x_offset = props[14]
|
||||
y_offset = props[15]
|
||||
z_offset = props[16]
|
||||
size_x = props[17]
|
||||
size_y = props[18]
|
||||
size_z = props[19]
|
||||
nsize = props[20]
|
||||
ntype = props[21]
|
||||
nbasis = int(props[22])
|
||||
vlbasis = int(props[23])
|
||||
distortion = props[24]
|
||||
hardnoise = int(props[25])
|
||||
depth = props[26]
|
||||
amp = props[27]
|
||||
freq = props[28]
|
||||
dimension = props[29]
|
||||
lacunarity = props[30]
|
||||
offset = props[31]
|
||||
gain = props[32]
|
||||
marblebias = int(props[33])
|
||||
marblesharpnes = int(props[34])
|
||||
marbleshape = int(props[35])
|
||||
height = props[36]
|
||||
height_invert = props[37]
|
||||
height_offset = props[38]
|
||||
maximum = props[39]
|
||||
minimum = props[40]
|
||||
falloff = int(props[41])
|
||||
edge_level = props[42]
|
||||
falloffsize_x = props[43]
|
||||
falloffsize_y = props[44]
|
||||
stratatype = props[45]
|
||||
strata = props[46]
|
||||
addwater = props[47]
|
||||
waterlevel = props[48]
|
||||
|
||||
x, y, z = coords
|
||||
|
||||
# Origin
|
||||
if rseed is 0:
|
||||
origin = x_offset, y_offset, z_offset
|
||||
origin_x = x_offset
|
||||
origin_y = y_offset
|
||||
origin_z = z_offset
|
||||
o_range = 1.0
|
||||
else:
|
||||
# Randomise origin
|
||||
o_range = 10000.0
|
||||
seed_set(rseed)
|
||||
origin = random_unit_vector()
|
||||
ox = (origin[0] * o_range)
|
||||
oy = (origin[1] * o_range)
|
||||
oz = (origin[2] * o_range)
|
||||
origin_x = (ox - (ox / 2)) + x_offset
|
||||
origin_y = (oy - (oy / 2)) + y_offset
|
||||
origin_z = (oz - (oz / 2)) + z_offset
|
||||
|
||||
ncoords = (x / (nsize * size_x) + origin_x, y / (nsize * size_y) + origin_y, z / (nsize * size_z) + origin_z)
|
||||
|
||||
# Noise basis type's
|
||||
if nbasis == 9:
|
||||
nbasis = 14 # Cellnoise
|
||||
if vlbasis == 9:
|
||||
vlbasis = 14
|
||||
|
||||
# Noise type's
|
||||
if ntype in [0, 'multi_fractal']:
|
||||
value = multi_fractal(ncoords, dimension, lacunarity, depth, nbasis) * 0.5
|
||||
|
||||
elif ntype in [1, 'ridged_multi_fractal']:
|
||||
value = ridged_multi_fractal(ncoords, dimension, lacunarity, depth, offset, gain, nbasis) * 0.5
|
||||
|
||||
elif ntype in [2, 'hybrid_multi_fractal']:
|
||||
value = hybrid_multi_fractal(ncoords, dimension, lacunarity, depth, offset, gain, nbasis) * 0.5
|
||||
|
||||
elif ntype in [3, 'hetero_terrain']:
|
||||
value = hetero_terrain(ncoords, dimension, lacunarity, depth, offset, nbasis) * 0.25
|
||||
|
||||
elif ntype in [4, 'fractal']:
|
||||
value = fractal(ncoords, dimension, lacunarity, depth, nbasis)
|
||||
|
||||
elif ntype in [5, 'turbulence_vector']:
|
||||
value = turbulence_vector(ncoords, depth, hardnoise, nbasis, amp, freq)[0]
|
||||
|
||||
elif ntype in [6, 'variable_lacunarity']:
|
||||
value = variable_lacunarity(ncoords, distortion, nbasis, vlbasis)
|
||||
|
||||
elif ntype in [7, 'marble_noise']:
|
||||
value = marble_noise(
|
||||
(ncoords[0] - origin_x + x_offset),
|
||||
(ncoords[1] - origin_y + y_offset),
|
||||
(ncoords[2] - origin_z + z_offset),
|
||||
(origin[0] + x_offset, origin[1] + y_offset, origin[2] + z_offset), nsize,
|
||||
marbleshape, marblebias, marblesharpnes,
|
||||
distortion, depth, hardnoise, nbasis, amp, freq
|
||||
)
|
||||
elif ntype in [8, 'shattered_hterrain']:
|
||||
value = shattered_hterrain(ncoords, dimension, lacunarity, depth, offset, distortion, nbasis)
|
||||
|
||||
elif ntype in [9, 'strata_hterrain']:
|
||||
value = strata_hterrain(ncoords, dimension, lacunarity, depth, offset, distortion, nbasis)
|
||||
|
||||
elif ntype in [10, 'ant_turbulence']:
|
||||
value = ant_turbulence(ncoords, depth, hardnoise, nbasis, amp, freq, distortion)
|
||||
|
||||
elif ntype in [11, 'vl_noise_turbulence']:
|
||||
value = vl_noise_turbulence(ncoords, distortion, depth, nbasis, vlbasis, hardnoise, amp, freq)
|
||||
|
||||
elif ntype in [12, 'vl_hTerrain']:
|
||||
value = vl_hTerrain(ncoords, dimension, lacunarity, depth, offset, nbasis, vlbasis, distortion)
|
||||
|
||||
elif ntype in [13, 'distorted_heteroTerrain']:
|
||||
value = distorted_heteroTerrain(ncoords, dimension, lacunarity, depth, offset, distortion, nbasis, vlbasis)
|
||||
|
||||
elif ntype in [14, 'double_multiFractal']:
|
||||
value = double_multiFractal(ncoords, dimension, lacunarity, depth, offset, gain, nbasis, vlbasis)
|
||||
|
||||
elif ntype in [15, 'slick_rock']:
|
||||
value = slick_rock(ncoords,dimension, lacunarity, depth, offset, gain, distortion, nbasis, vlbasis)
|
||||
|
||||
elif ntype in [16, 'planet_noise']:
|
||||
value = planet_noise(ncoords, depth, hardnoise, nbasis)[2] * 0.5 + 0.5
|
||||
|
||||
elif ntype in [17, 'blender_texture']:
|
||||
if texture_name != "" and texture_name in bpy.data.textures:
|
||||
value = bpy.data.textures[texture_name].evaluate(ncoords)[3]
|
||||
else:
|
||||
value = 0.0
|
||||
else:
|
||||
value = 0.5
|
||||
|
||||
# Adjust height
|
||||
if height_invert:
|
||||
value = (1.0 - value) * height + height_offset
|
||||
else:
|
||||
value = value * height + height_offset
|
||||
|
||||
# Edge falloff:
|
||||
if not sphere:
|
||||
if falloff:
|
||||
ratio_x, ratio_y = abs(x) * 2 / meshsize_x, abs(y) * 2 / meshsize_y
|
||||
fallofftypes = [0,
|
||||
sqrt(ratio_y**falloffsize_y),
|
||||
sqrt(ratio_x**falloffsize_x),
|
||||
sqrt(ratio_x**falloffsize_x + ratio_y**falloffsize_y)
|
||||
]
|
||||
dist = fallofftypes[falloff]
|
||||
value -= edge_level
|
||||
if(dist < 1.0):
|
||||
dist = (dist * dist * (3 - 2 * dist))
|
||||
value = (value - value * dist) + edge_level
|
||||
else:
|
||||
value = edge_level
|
||||
|
||||
# Strata / terrace / layers
|
||||
if stratatype not in [0, "0"]:
|
||||
if stratatype in [1, "1"]:
|
||||
strata = strata / height
|
||||
strata *= 2
|
||||
steps = (sin(value * strata * pi) * (0.1 / strata * pi))
|
||||
value = (value * 0.5 + steps * 0.5) * 2.0
|
||||
|
||||
elif stratatype in [2, "2"]:
|
||||
strata = strata / height
|
||||
steps = -abs(sin(value * strata * pi) * (0.1 / strata * pi))
|
||||
value = (value * 0.5 + steps * 0.5) * 2.0
|
||||
|
||||
elif stratatype in [3, "3"]:
|
||||
strata = strata / height
|
||||
steps = abs(sin(value * strata * pi) * (0.1 / strata * pi))
|
||||
value = (value * 0.5 + steps * 0.5) * 2.0
|
||||
|
||||
elif stratatype in [4, "4"]:
|
||||
strata = strata / height
|
||||
value = int( value * strata ) * 1.0 / strata
|
||||
|
||||
elif stratatype in [5, "5"]:
|
||||
strata = strata / height
|
||||
steps = (int( value * strata ) * 1.0 / strata)
|
||||
value = (value * (1.0 - 0.5) + steps * 0.5)
|
||||
|
||||
# Clamp height min max
|
||||
if (value < minimum):
|
||||
value = minimum
|
||||
if (value > maximum):
|
||||
value = maximum
|
||||
|
||||
return value
|
||||
|
||||
|
||||
# ------------------------------------------------------------
|
||||
# draw properties
|
||||
|
||||
def draw_ant_refresh(self, context):
|
||||
layout = self.layout
|
||||
if self.auto_refresh is False:
|
||||
self.refresh = False
|
||||
elif self.auto_refresh is True:
|
||||
self.refresh = True
|
||||
row = layout.box().row()
|
||||
split = row.split()
|
||||
split.scale_y = 1.5
|
||||
split.prop(self, "auto_refresh", toggle=True, icon_only=True, icon='AUTO')
|
||||
split.prop(self, "refresh", toggle=True, icon_only=True, icon='FILE_REFRESH')
|
||||
|
||||
|
||||
def draw_ant_main(self, context, generate=True):
|
||||
layout = self.layout
|
||||
box = layout.box()
|
||||
box.prop(self, "show_main_settings", toggle=True)
|
||||
if self.show_main_settings:
|
||||
if generate:
|
||||
row = box.row(align=True)
|
||||
split = row.split(align=True)
|
||||
split.prop(self, "at_cursor", toggle=True, icon_only=True, icon='CURSOR')
|
||||
split.prop(self, "smooth_mesh", toggle=True, icon_only=True, icon='SOLID')
|
||||
split.prop(self, "tri_face", toggle=True, icon_only=True, icon='MESH_DATA')
|
||||
|
||||
if not self.sphere_mesh:
|
||||
row = box.row(align=True)
|
||||
row.prop(self, "sphere_mesh", toggle=True)
|
||||
else:
|
||||
row = box.row(align=True)
|
||||
split = row.split(0.5, align=True)
|
||||
split.prop(self, "sphere_mesh", toggle=True)
|
||||
split.prop(self, "remove_double", toggle=True)
|
||||
|
||||
box.prop(self, "ant_terrain_name")
|
||||
box.prop_search(self, "land_material", bpy.data, "materials")
|
||||
|
||||
col = box.column(align=True)
|
||||
col.prop(self, "subdivision_x")
|
||||
col.prop(self, "subdivision_y")
|
||||
col = box.column(align=True)
|
||||
if self.sphere_mesh:
|
||||
col.prop(self, "mesh_size")
|
||||
else:
|
||||
col.prop(self, "mesh_size_x")
|
||||
col.prop(self, "mesh_size_y")
|
||||
|
||||
|
||||
def draw_ant_noise(self, context):
|
||||
layout = self.layout
|
||||
box = layout.box()
|
||||
box.prop(self, "show_noise_settings", toggle=True)
|
||||
if self.show_noise_settings:
|
||||
box.prop(self, "noise_type")
|
||||
if self.noise_type == "blender_texture":
|
||||
box.prop_search(self, "texture_block", bpy.data, "textures")
|
||||
else:
|
||||
box.prop(self, "basis_type")
|
||||
|
||||
col = box.column(align=True)
|
||||
col.prop(self, "random_seed")
|
||||
col = box.column(align=True)
|
||||
col.prop(self, "noise_offset_x")
|
||||
col.prop(self, "noise_offset_y")
|
||||
col.prop(self, "noise_offset_z")
|
||||
col.prop(self, "noise_size_x")
|
||||
col.prop(self, "noise_size_y")
|
||||
col.prop(self, "noise_size_z")
|
||||
col = box.column(align=True)
|
||||
col.prop(self, "noise_size")
|
||||
|
||||
col = box.column(align=True)
|
||||
if self.noise_type == "multi_fractal":
|
||||
col.prop(self, "noise_depth")
|
||||
col.prop(self, "dimension")
|
||||
col.prop(self, "lacunarity")
|
||||
elif self.noise_type == "ridged_multi_fractal":
|
||||
col.prop(self, "noise_depth")
|
||||
col.prop(self, "dimension")
|
||||
col.prop(self, "lacunarity")
|
||||
col.prop(self, "offset")
|
||||
col.prop(self, "gain")
|
||||
elif self.noise_type == "hybrid_multi_fractal":
|
||||
col.prop(self, "noise_depth")
|
||||
col.prop(self, "dimension")
|
||||
col.prop(self, "lacunarity")
|
||||
col.prop(self, "offset")
|
||||
col.prop(self, "gain")
|
||||
elif self.noise_type == "hetero_terrain":
|
||||
col.prop(self, "noise_depth")
|
||||
col.prop(self, "dimension")
|
||||
col.prop(self, "lacunarity")
|
||||
col.prop(self, "offset")
|
||||
elif self.noise_type == "fractal":
|
||||
col.prop(self, "noise_depth")
|
||||
col.prop(self, "dimension")
|
||||
col.prop(self, "lacunarity")
|
||||
elif self.noise_type == "turbulence_vector":
|
||||
col.prop(self, "noise_depth")
|
||||
col.prop(self, "amplitude")
|
||||
col.prop(self, "frequency")
|
||||
col.separator()
|
||||
row = col.row(align=True)
|
||||
row.prop(self, "hard_noise", expand=True)
|
||||
elif self.noise_type == "variable_lacunarity":
|
||||
box.prop(self, "vl_basis_type")
|
||||
box.prop(self, "distortion")
|
||||
elif self.noise_type == "marble_noise":
|
||||
box.prop(self, "marble_shape")
|
||||
box.prop(self, "marble_bias")
|
||||
box.prop(self, "marble_sharp")
|
||||
col = box.column(align=True)
|
||||
col.prop(self, "distortion")
|
||||
col.prop(self, "noise_depth")
|
||||
col.separator()
|
||||
row = col.row(align=True)
|
||||
row.prop(self, "hard_noise", expand=True)
|
||||
elif self.noise_type == "shattered_hterrain":
|
||||
col.prop(self, "noise_depth")
|
||||
col.prop(self, "dimension")
|
||||
col.prop(self, "lacunarity")
|
||||
col.prop(self, "offset")
|
||||
col.prop(self, "distortion")
|
||||
elif self.noise_type == "strata_hterrain":
|
||||
col.prop(self, "noise_depth")
|
||||
col.prop(self, "dimension")
|
||||
col.prop(self, "lacunarity")
|
||||
col.prop(self, "offset")
|
||||
col.prop(self, "distortion", text="Strata")
|
||||
elif self.noise_type == "ant_turbulence":
|
||||
col.prop(self, "noise_depth")
|
||||
col.prop(self, "amplitude")
|
||||
col.prop(self, "frequency")
|
||||
col.prop(self, "distortion")
|
||||
col.separator()
|
||||
row = col.row(align=True)
|
||||
row.prop(self, "hard_noise", expand=True)
|
||||
elif self.noise_type == "vl_noise_turbulence":
|
||||
col.prop(self, "noise_depth")
|
||||
col.prop(self, "amplitude")
|
||||
col.prop(self, "frequency")
|
||||
col.prop(self, "distortion")
|
||||
col.separator()
|
||||
col.prop(self, "vl_basis_type")
|
||||
col.separator()
|
||||
row = col.row(align=True)
|
||||
row.prop(self, "hard_noise", expand=True)
|
||||
elif self.noise_type == "vl_hTerrain":
|
||||
col.prop(self, "noise_depth")
|
||||
col.prop(self, "dimension")
|
||||
col.prop(self, "lacunarity")
|
||||
col.prop(self, "offset")
|
||||
col.prop(self, "distortion")
|
||||
col.separator()
|
||||
col.prop(self, "vl_basis_type")
|
||||
elif self.noise_type == "distorted_heteroTerrain":
|
||||
col.prop(self, "noise_depth")
|
||||
col.prop(self, "dimension")
|
||||
col.prop(self, "lacunarity")
|
||||
col.prop(self, "offset")
|
||||
col.prop(self, "distortion")
|
||||
col.separator()
|
||||
col.prop(self, "vl_basis_type")
|
||||
elif self.noise_type == "double_multiFractal":
|
||||
col.prop(self, "noise_depth")
|
||||
col.prop(self, "dimension")
|
||||
col.prop(self, "lacunarity")
|
||||
col.prop(self, "offset")
|
||||
col.prop(self, "gain")
|
||||
col.separator()
|
||||
col.prop(self, "vl_basis_type")
|
||||
elif self.noise_type == "slick_rock":
|
||||
col.prop(self, "noise_depth")
|
||||
col.prop(self, "dimension")
|
||||
col.prop(self, "lacunarity")
|
||||
col.prop(self, "gain")
|
||||
col.prop(self, "offset")
|
||||
col.prop(self, "distortion")
|
||||
col.separator()
|
||||
col.prop(self, "vl_basis_type")
|
||||
elif self.noise_type == "planet_noise":
|
||||
col.prop(self, "noise_depth")
|
||||
col.separator()
|
||||
row = col.row(align=True)
|
||||
row.prop(self, "hard_noise", expand=True)
|
||||
|
||||
|
||||
def draw_ant_displace(self, context, generate=True):
|
||||
layout = self.layout
|
||||
box = layout.box()
|
||||
box.prop(self, "show_displace_settings", toggle=True)
|
||||
if self.show_displace_settings:
|
||||
col = box.column(align=True)
|
||||
row = col.row(align=True).split(0.92, align=True)
|
||||
row.prop(self, "height")
|
||||
row.prop(self, "height_invert", toggle=True, text="", icon='ARROW_LEFTRIGHT')
|
||||
col.prop(self, "height_offset")
|
||||
col.prop(self, "maximum")
|
||||
col.prop(self, "minimum")
|
||||
if generate:
|
||||
if not self.sphere_mesh:
|
||||
col = box.column()
|
||||
col.prop(self, "edge_falloff")
|
||||
if self.edge_falloff is not "0":
|
||||
col = box.column(align=True)
|
||||
col.prop(self, "edge_level")
|
||||
if self.edge_falloff in ["2", "3"]:
|
||||
col.prop(self, "falloff_x")
|
||||
if self.edge_falloff in ["1", "3"]:
|
||||
col.prop(self, "falloff_y")
|
||||
else:
|
||||
col = box.column(align=False)
|
||||
col.prop(self, "use_vgroup", toggle=True)
|
||||
|
||||
col = box.column()
|
||||
col.prop(self, "strata_type")
|
||||
if self.strata_type is not "0":
|
||||
col = box.column()
|
||||
col.prop(self, "strata")
|
||||
|
||||
|
||||
def draw_ant_water(self, context):
|
||||
layout = self.layout
|
||||
box = layout.box()
|
||||
col = box.column()
|
||||
col.prop(self, "water_plane", toggle=True)
|
||||
if self.water_plane:
|
||||
col = box.column(align=True)
|
||||
col.prop_search(self, "water_material", bpy.data, "materials")
|
||||
col = box.column()
|
||||
col.prop(self, "water_level")
|
||||
|
||||
|
||||
# Store propereties
|
||||
def store_properties(operator, ob):
|
||||
ob.ant_landscape.ant_terrain_name = operator.ant_terrain_name
|
||||
ob.ant_landscape.at_cursor = operator.at_cursor
|
||||
ob.ant_landscape.smooth_mesh = operator.smooth_mesh
|
||||
ob.ant_landscape.tri_face = operator.tri_face
|
||||
ob.ant_landscape.sphere_mesh = operator.sphere_mesh
|
||||
ob.ant_landscape.land_material = operator.land_material
|
||||
ob.ant_landscape.water_material = operator.water_material
|
||||
ob.ant_landscape.texture_block = operator.texture_block
|
||||
ob.ant_landscape.subdivision_x = operator.subdivision_x
|
||||
ob.ant_landscape.subdivision_y = operator.subdivision_y
|
||||
ob.ant_landscape.mesh_size_x = operator.mesh_size_x
|
||||
ob.ant_landscape.mesh_size_y = operator.mesh_size_y
|
||||
ob.ant_landscape.mesh_size = operator.mesh_size
|
||||
ob.ant_landscape.random_seed = operator.random_seed
|
||||
ob.ant_landscape.noise_offset_x = operator.noise_offset_x
|
||||
ob.ant_landscape.noise_offset_y = operator.noise_offset_y
|
||||
ob.ant_landscape.noise_offset_z = operator.noise_offset_z
|
||||
ob.ant_landscape.noise_size_x = operator.noise_size_x
|
||||
ob.ant_landscape.noise_size_y = operator.noise_size_y
|
||||
ob.ant_landscape.noise_size_z = operator.noise_size_z
|
||||
ob.ant_landscape.noise_size = operator.noise_size
|
||||
ob.ant_landscape.noise_type = operator.noise_type
|
||||
ob.ant_landscape.basis_type = operator.basis_type
|
||||
ob.ant_landscape.vl_basis_type = operator.vl_basis_type
|
||||
ob.ant_landscape.distortion = operator.distortion
|
||||
ob.ant_landscape.hard_noise = operator.hard_noise
|
||||
ob.ant_landscape.noise_depth = operator.noise_depth
|
||||
ob.ant_landscape.amplitude = operator.amplitude
|
||||
ob.ant_landscape.frequency = operator.frequency
|
||||
ob.ant_landscape.dimension = operator.dimension
|
||||
ob.ant_landscape.lacunarity = operator.lacunarity
|
||||
ob.ant_landscape.offset = operator.offset
|
||||
ob.ant_landscape.gain = operator.gain
|
||||
ob.ant_landscape.marble_bias = operator.marble_bias
|
||||
ob.ant_landscape.marble_sharp = operator.marble_sharp
|
||||
ob.ant_landscape.marble_shape = operator.marble_shape
|
||||
ob.ant_landscape.height = operator.height
|
||||
ob.ant_landscape.height_invert = operator.height_invert
|
||||
ob.ant_landscape.height_offset = operator.height_offset
|
||||
ob.ant_landscape.maximum = operator.maximum
|
||||
ob.ant_landscape.minimum = operator.minimum
|
||||
ob.ant_landscape.edge_falloff = operator.edge_falloff
|
||||
ob.ant_landscape.edge_level = operator.edge_level
|
||||
ob.ant_landscape.falloff_x = operator.falloff_x
|
||||
ob.ant_landscape.falloff_y = operator.falloff_y
|
||||
ob.ant_landscape.strata_type = operator.strata_type
|
||||
ob.ant_landscape.strata = operator.strata
|
||||
ob.ant_landscape.water_plane = operator.water_plane
|
||||
ob.ant_landscape.water_level = operator.water_level
|
||||
ob.ant_landscape.use_vgroup = operator.use_vgroup
|
||||
ob.ant_landscape.show_main_settings = operator.show_main_settings
|
||||
ob.ant_landscape.show_noise_settings = operator.show_noise_settings
|
||||
ob.ant_landscape.show_displace_settings = operator.show_displace_settings
|
||||
#print("A.N.T. Landscape Object Properties:")
|
||||
#for k in ob.ant_landscape.keys():
|
||||
# print(k, "-", ob.ant_landscape[k])
|
||||
return ob
|
||||
|
||||
|
|
@ -0,0 +1,243 @@
|
|||
# ##### BEGIN GPL LICENSE BLOCK #####
|
||||
#
|
||||
# This program is free software; you can redistribute it and/or
|
||||
# modify it under the terms of the GNU General Public License
|
||||
# as published by the Free Software Foundation; either version 2
|
||||
# of the License, or (at your option) any later version.
|
||||
#
|
||||
# This program is distributed in the hope that it will be useful,
|
||||
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
# GNU General Public License for more details.
|
||||
#
|
||||
# You should have received a copy of the GNU General Public License
|
||||
# along with this program; if not, write to the Free Software Foundation,
|
||||
# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
#
|
||||
# ##### END GPL LICENSE BLOCK #####
|
||||
|
||||
# Another Noise Tool - Landscape Redraw - Regenerate
|
||||
# Jim Hazevoet
|
||||
|
||||
|
||||
# ------------------------------------------------------------
|
||||
# import modules
|
||||
import bpy
|
||||
|
||||
from .ant_functions import (
|
||||
noise_gen,
|
||||
grid_gen,
|
||||
sphere_gen,
|
||||
create_mesh_object,
|
||||
store_properties,
|
||||
)
|
||||
|
||||
# ------------------------------------------------------------
|
||||
# Do refresh - redraw
|
||||
class AntLandscapeRefresh(bpy.types.Operator):
|
||||
bl_idname = "mesh.ant_landscape_refresh"
|
||||
bl_label = "Refresh"
|
||||
bl_description = "Refresh landscape with current settings"
|
||||
bl_options = {'REGISTER', 'UNDO'}
|
||||
|
||||
|
||||
@classmethod
|
||||
def poll(cls, context):
|
||||
ob = bpy.context.active_object
|
||||
return (ob.ant_landscape and not ob.ant_landscape['sphere_mesh'])
|
||||
|
||||
|
||||
def execute(self, context):
|
||||
# turn off undo
|
||||
undo = bpy.context.user_preferences.edit.use_global_undo
|
||||
bpy.context.user_preferences.edit.use_global_undo = False
|
||||
|
||||
# ant object items
|
||||
obj = bpy.context.active_object
|
||||
|
||||
bpy.ops.object.mode_set(mode = 'EDIT')
|
||||
bpy.ops.object.mode_set(mode = 'OBJECT')
|
||||
|
||||
|
||||
if obj and obj.ant_landscape.keys():
|
||||
obi = obj.ant_landscape.items()
|
||||
#print("Refresh A.N.T. Landscape Grid")
|
||||
#for k in obi.keys():
|
||||
# print(k, "-", obi[k])
|
||||
prop = []
|
||||
for i in range(len(obi)):
|
||||
prop.append(obi[i][1])
|
||||
|
||||
# redraw verts
|
||||
mesh = obj.data
|
||||
for v in mesh.vertices:
|
||||
v.co[2] = 0
|
||||
v.co[2] = noise_gen(v.co, prop)
|
||||
mesh.update()
|
||||
else:
|
||||
pass
|
||||
|
||||
# restore pre operator undo state
|
||||
context.user_preferences.edit.use_global_undo = undo
|
||||
|
||||
return {'FINISHED'}
|
||||
|
||||
|
||||
# ------------------------------------------------------------
|
||||
# Do regenerate
|
||||
class AntLandscapeRegenerate(bpy.types.Operator):
|
||||
bl_idname = "mesh.ant_landscape_regenerate"
|
||||
bl_label = "Regenerate"
|
||||
bl_description = "Regenerate landscape with current settings"
|
||||
bl_options = {'REGISTER', 'UNDO'}
|
||||
|
||||
|
||||
@classmethod
|
||||
def poll(cls, context):
|
||||
return bpy.context.active_object.ant_landscape
|
||||
|
||||
|
||||
def execute(self, context):
|
||||
|
||||
# turn off undo
|
||||
undo = bpy.context.user_preferences.edit.use_global_undo
|
||||
bpy.context.user_preferences.edit.use_global_undo = False
|
||||
|
||||
scene = bpy.context.scene
|
||||
# ant object items
|
||||
obj = bpy.context.active_object
|
||||
|
||||
if obj and obj.ant_landscape.keys():
|
||||
ob = obj.ant_landscape
|
||||
obi = ob.items()
|
||||
#print("Regenerate A.N.T. Landscape Grid")
|
||||
#for k in obi.keys():
|
||||
# print(k, "-", obi[k])
|
||||
ant_props = []
|
||||
for i in range(len(obi)):
|
||||
ant_props.append(obi[i][1])
|
||||
|
||||
new_name = ob.ant_terrain_name
|
||||
|
||||
# Main function, create landscape mesh object
|
||||
if ob["sphere_mesh"]:
|
||||
# sphere
|
||||
verts, faces = sphere_gen(
|
||||
ob["subdivision_y"],
|
||||
ob["subdivision_x"],
|
||||
ob["tri_face"],
|
||||
ob["mesh_size"],
|
||||
ant_props,
|
||||
False,
|
||||
0.0
|
||||
)
|
||||
new_ob = create_mesh_object(context, verts, [], faces, new_name).object
|
||||
else:
|
||||
# grid
|
||||
verts, faces = grid_gen(
|
||||
ob["subdivision_x"],
|
||||
ob["subdivision_y"],
|
||||
ob["tri_face"],
|
||||
ob["mesh_size_x"],
|
||||
ob["mesh_size_y"],
|
||||
ant_props,
|
||||
False,
|
||||
0.0
|
||||
)
|
||||
new_ob = create_mesh_object(context, verts, [], faces, new_name).object
|
||||
|
||||
new_ob.select = True
|
||||
|
||||
if ob["smooth_mesh"]:
|
||||
bpy.ops.object.shade_smooth()
|
||||
|
||||
# Landscape Material
|
||||
if ob["land_material"] != "" and ob["land_material"] in bpy.data.materials:
|
||||
mat = bpy.data.materials[ob["land_material"]]
|
||||
bpy.context.object.data.materials.append(mat)
|
||||
|
||||
# Water plane
|
||||
if ob["water_plane"]:
|
||||
if ob["sphere_mesh"]:
|
||||
# sphere
|
||||
verts, faces = sphere_gen(
|
||||
ob["subdivision_y"],
|
||||
ob["subdivision_x"],
|
||||
ob["tri_face"],
|
||||
ob["mesh_size"],
|
||||
ant_props,
|
||||
ob["water_plane"],
|
||||
ob["water_level"]
|
||||
)
|
||||
wobj = create_mesh_object(context, verts, [], faces, new_name+"_plane").object
|
||||
else:
|
||||
# grid
|
||||
verts, faces = grid_gen(
|
||||
2,
|
||||
2,
|
||||
ob["tri_face"],
|
||||
ob["mesh_size_x"],
|
||||
ob["mesh_size_y"],
|
||||
ant_props,
|
||||
ob["water_plane"],
|
||||
ob["water_level"]
|
||||
)
|
||||
wobj = create_mesh_object(context, verts, [], faces, new_name+"_plane").object
|
||||
|
||||
wobj.select = True
|
||||
|
||||
if ob["smooth_mesh"]:
|
||||
bpy.ops.object.shade_smooth()
|
||||
|
||||
# Water Material
|
||||
if ob["water_material"] != "" and ob["water_material"] in bpy.data.materials:
|
||||
mat = bpy.data.materials[ob["water_material"]]
|
||||
bpy.context.object.data.materials.append(mat)
|
||||
|
||||
# Loc Rot Scale
|
||||
if ob["water_plane"]:
|
||||
wobj.location = obj.location
|
||||
wobj.rotation_euler = obj.rotation_euler
|
||||
wobj.scale = obj.scale
|
||||
wobj.select = False
|
||||
|
||||
|
||||
new_ob.location = obj.location
|
||||
new_ob.rotation_euler = obj.rotation_euler
|
||||
new_ob.scale = obj.scale
|
||||
|
||||
# Store props
|
||||
new_ob = store_properties(ob, new_ob)
|
||||
|
||||
# Delete old object
|
||||
new_ob.select = False
|
||||
|
||||
obj.select = True
|
||||
scene.objects.active = obj
|
||||
bpy.ops.object.delete(use_global=False)
|
||||
#scene.update()
|
||||
|
||||
# Select landscape and make active
|
||||
new_ob.select = True
|
||||
scene.objects.active = new_ob
|
||||
|
||||
# restore pre operator undo state
|
||||
context.user_preferences.edit.use_global_undo = undo
|
||||
|
||||
return {'FINISHED'}
|
||||
|
||||
'''
|
||||
# ------------------------------------------------------------
|
||||
# Register:
|
||||
|
||||
def register():
|
||||
bpy.utils.register_module(__name__)
|
||||
|
||||
|
||||
def unregister():
|
||||
bpy.utils.unregister_module(__name__)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
register()
|
||||
'''
|
||||
|
|
@ -0,0 +1,562 @@
|
|||
# ##### BEGIN GPL LICENSE BLOCK #####
|
||||
#
|
||||
# This program is free software; you can redistribute it and/or
|
||||
# modify it under the terms of the GNU General Public License
|
||||
# as published by the Free Software Foundation; either version 2
|
||||
# of the License, or (at your option) any later version.
|
||||
#
|
||||
# This program is distributed in the hope that it will be useful,
|
||||
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
# GNU General Public License for more details.
|
||||
#
|
||||
# You should have received a copy of the GNU General Public License
|
||||
# along with this program; if not, write to the Free Software Foundation,
|
||||
# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
#
|
||||
# ##### END GPL LICENSE BLOCK #####
|
||||
|
||||
# Another Noise Tool - Mesh Displace
|
||||
# Jim Hazevoet
|
||||
|
||||
# ------------------------------------------------------------
|
||||
# import modules
|
||||
import bpy
|
||||
from bpy.props import (
|
||||
BoolProperty,
|
||||
EnumProperty,
|
||||
FloatProperty,
|
||||
IntProperty,
|
||||
StringProperty,
|
||||
FloatVectorProperty,
|
||||
)
|
||||
|
||||
from .ant_functions import (
|
||||
noise_gen,
|
||||
draw_ant_refresh,
|
||||
draw_ant_noise,
|
||||
draw_ant_displace,
|
||||
)
|
||||
|
||||
# ------------------------------------------------------------
|
||||
# Do vert displacement
|
||||
class AntMeshDisplace(bpy.types.Operator):
|
||||
bl_idname = "mesh.ant_displace"
|
||||
bl_label = "Another Noise Tool - Displace"
|
||||
bl_description = "Displace mesh vertices"
|
||||
bl_options = {'REGISTER', 'UNDO', 'PRESET'}
|
||||
|
||||
ant_terrain_name = StringProperty(
|
||||
name="Name",
|
||||
default="Landscape"
|
||||
)
|
||||
land_material = StringProperty(
|
||||
name='Material',
|
||||
default="",
|
||||
description="Terrain material"
|
||||
)
|
||||
water_material = StringProperty(
|
||||
name='Material',
|
||||
default="",
|
||||
description="Water plane material"
|
||||
)
|
||||
texture_block = StringProperty(
|
||||
name="Texture",
|
||||
default=""
|
||||
)
|
||||
at_cursor = BoolProperty(
|
||||
name="Cursor",
|
||||
default=True,
|
||||
description="Place at cursor location",
|
||||
)
|
||||
smooth_mesh = BoolProperty(
|
||||
name="Smooth",
|
||||
default=True,
|
||||
description="Shade smooth"
|
||||
)
|
||||
tri_face = BoolProperty(
|
||||
name="Triangulate",
|
||||
default=False,
|
||||
description="Triangulate faces"
|
||||
)
|
||||
sphere_mesh = BoolProperty(
|
||||
name="Sphere",
|
||||
default=False,
|
||||
description="Generate uv sphere - remove doubles when ready"
|
||||
)
|
||||
subdivision_x = IntProperty(
|
||||
name="Subdivisions X",
|
||||
default=128,
|
||||
min=4,
|
||||
max=6400,
|
||||
description="Mesh X subdivisions"
|
||||
)
|
||||
subdivision_y = IntProperty(
|
||||
default=128,
|
||||
name="Subdivisions Y",
|
||||
min=4,
|
||||
max=6400,
|
||||
description="Mesh Y subdivisions"
|
||||
)
|
||||
mesh_size = FloatProperty(
|
||||
default=2.0,
|
||||
name="Mesh Size",
|
||||
min=0.01,
|
||||
max=100000.0,
|
||||
description="Mesh size"
|
||||
)
|
||||
mesh_size_x = FloatProperty(
|
||||
default=2.0,
|
||||
name="Mesh Size X",
|
||||
min=0.01,
|
||||
description="Mesh x size"
|
||||
)
|
||||
mesh_size_y = FloatProperty(
|
||||
name="Mesh Size Y",
|
||||
default=2.0,
|
||||
min=0.01,
|
||||
description="Mesh y size"
|
||||
)
|
||||
|
||||
random_seed = IntProperty(
|
||||
name="Random Seed",
|
||||
default=0,
|
||||
min=0,
|
||||
description="Randomize noise origin"
|
||||
)
|
||||
noise_offset_x = FloatProperty(
|
||||
name="Offset X",
|
||||
default=0.0,
|
||||
description="Noise X Offset"
|
||||
)
|
||||
noise_offset_y = FloatProperty(
|
||||
name="Offset Y",
|
||||
default=0.0,
|
||||
description="Noise Y Offset"
|
||||
)
|
||||
noise_offset_z = FloatProperty(
|
||||
name="Offset Z",
|
||||
default=0.0,
|
||||
description="Noise Z Offset"
|
||||
)
|
||||
noise_size_x = FloatProperty(
|
||||
default=1.0,
|
||||
name="Size X",
|
||||
min=0.01,
|
||||
max=1000.0,
|
||||
description="Noise x size"
|
||||
)
|
||||
noise_size_y = FloatProperty(
|
||||
name="Size Y",
|
||||
default=1.0,
|
||||
min=0.01,
|
||||
max=1000.0,
|
||||
description="Noise y size"
|
||||
)
|
||||
noise_size_z = FloatProperty(
|
||||
name="Size Z",
|
||||
default=1.0,
|
||||
min=0.01,
|
||||
max=1000.0,
|
||||
description="Noise Z size"
|
||||
)
|
||||
noise_size = FloatProperty(
|
||||
name="Noise Size",
|
||||
default=1.0,
|
||||
min=0.01,
|
||||
max=1000.0,
|
||||
description="Noise size"
|
||||
)
|
||||
noise_type = EnumProperty(
|
||||
name="Noise Type",
|
||||
default='hetero_terrain',
|
||||
description="Noise type",
|
||||
items = [
|
||||
('multi_fractal', "Multi Fractal", "Blender: Multi Fractal algorithm", 0),
|
||||
('ridged_multi_fractal', "Ridged MFractal", "Blender: Ridged Multi Fractal", 1),
|
||||
('hybrid_multi_fractal', "Hybrid MFractal", "Blender: Hybrid Multi Fractal", 2),
|
||||
('hetero_terrain', "Hetero Terrain", "Blender: Hetero Terrain", 3),
|
||||
('fractal', "fBm Fractal", "Blender: fBm - Fractional Browninian motion", 4),
|
||||
('turbulence_vector', "Turbulence", "Blender: Turbulence Vector", 5),
|
||||
('variable_lacunarity', "Distorted Noise", "Blender: Distorted Noise", 6),
|
||||
('marble_noise', "Marble", "A.N.T.: Marble Noise", 7),
|
||||
('shattered_hterrain', "Shattered hTerrain", "A.N.T.: Shattered hTerrain", 8),
|
||||
('strata_hterrain', "Strata hTerrain", "A.N.T: Strata hTerrain", 9),
|
||||
('ant_turbulence', "Another Turbulence", "A.N.T: Turbulence variation", 10),
|
||||
('vl_noise_turbulence', "vlNoise turbulence", "A.N.T: vlNoise turbulence", 11),
|
||||
('vl_hTerrain', "vlNoise hTerrain", "A.N.T: vlNoise hTerrain", 12),
|
||||
('distorted_heteroTerrain', "Distorted hTerrain", "A.N.T distorted hTerrain", 13),
|
||||
('double_multiFractal', "Double MultiFractal", "A.N.T: double multiFractal", 14),
|
||||
('slick_rock', "Slick Rock", "A.N.T: slick rock", 15),
|
||||
('planet_noise', "Planet Noise", "Planet Noise by: Farsthary", 16),
|
||||
('blender_texture', "Blender Texture - Texture Nodes", "Blender texture data block", 17)]
|
||||
)
|
||||
basis_type = EnumProperty(
|
||||
name="Noise Basis",
|
||||
default="0",
|
||||
description="Noise basis algorithms",
|
||||
items = [
|
||||
("0", "Blender", "Blender default noise", 0),
|
||||
("1", "Perlin", "Perlin noise", 1),
|
||||
("2", "New Perlin", "New Perlin noise", 2),
|
||||
("3", "Voronoi F1", "Voronoi F1", 3),
|
||||
("4", "Voronoi F2", "Voronoi F2", 4),
|
||||
("5", "Voronoi F3", "Voronoi F3", 5),
|
||||
("6", "Voronoi F4", "Voronoi F4", 6),
|
||||
("7", "Voronoi F2-F1", "Voronoi F2-F1", 7),
|
||||
("8", "Voronoi Crackle", "Voronoi Crackle", 8),
|
||||
("9", "Cell Noise", "Cell noise", 9)]
|
||||
)
|
||||
vl_basis_type = EnumProperty(
|
||||
name="vlNoise Basis",
|
||||
default="0",
|
||||
description="VLNoise basis algorithms",
|
||||
items = [
|
||||
("0", "Blender", "Blender default noise", 0),
|
||||
("1", "Perlin", "Perlin noise", 1),
|
||||
("2", "New Perlin", "New Perlin noise", 2),
|
||||
("3", "Voronoi F1", "Voronoi F1", 3),
|
||||
("4", "Voronoi F2", "Voronoi F2", 4),
|
||||
("5", "Voronoi F3", "Voronoi F3", 5),
|
||||
("6", "Voronoi F4", "Voronoi F4", 6),
|
||||
("7", "Voronoi F2-F1", "Voronoi F2-F1", 7),
|
||||
("8", "Voronoi Crackle", "Voronoi Crackle", 8),
|
||||
("9", "Cell Noise", "Cell noise", 9)]
|
||||
)
|
||||
distortion = FloatProperty(
|
||||
name="Distortion",
|
||||
default=1.0,
|
||||
min=0.01,
|
||||
max=100.0,
|
||||
description="Distortion amount"
|
||||
)
|
||||
hard_noise = EnumProperty(
|
||||
name="Soft Hard",
|
||||
default="0",
|
||||
description="Soft Noise, Hard noise",
|
||||
items = [
|
||||
("0", "Soft", "Soft Noise", 0),
|
||||
("1", "Hard", "Hard noise", 1)]
|
||||
)
|
||||
noise_depth = IntProperty(
|
||||
name="Depth",
|
||||
default=8,
|
||||
min=0,
|
||||
max=16,
|
||||
description="Noise Depth - number of frequencies in the fBm"
|
||||
)
|
||||
amplitude = FloatProperty(
|
||||
name="Amp",
|
||||
default=0.5,
|
||||
min=0.01,
|
||||
max=1.0,
|
||||
description="Amplitude"
|
||||
)
|
||||
frequency = FloatProperty(
|
||||
name="Freq",
|
||||
default=2.0,
|
||||
min=0.01,
|
||||
max=5.0,
|
||||
description="Frequency"
|
||||
)
|
||||
dimension = FloatProperty(
|
||||
name="Dimension",
|
||||
default=1.0,
|
||||
min=0.01,
|
||||
max=2.0,
|
||||
description="H - fractal dimension of the roughest areas"
|
||||
)
|
||||
lacunarity = FloatProperty(
|
||||
name="Lacunarity",
|
||||
min=0.01,
|
||||
max=6.0,
|
||||
default=2.0,
|
||||
description="Lacunarity - gap between successive frequencies"
|
||||
)
|
||||
offset = FloatProperty(
|
||||
name="Offset",
|
||||
default=1.0,
|
||||
min=0.01,
|
||||
max=6.0,
|
||||
description="Offset - raises the terrain from sea level"
|
||||
)
|
||||
gain = FloatProperty(
|
||||
name="Gain",
|
||||
default=1.0,
|
||||
min=0.01,
|
||||
max=6.0,
|
||||
description="Gain - scale factor"
|
||||
)
|
||||
marble_bias = EnumProperty(
|
||||
name="Bias",
|
||||
default="0",
|
||||
description="Marble bias",
|
||||
items = [
|
||||
("0", "Sin", "Sin", 0),
|
||||
("1", "Cos", "Cos", 1),
|
||||
("2", "Tri", "Tri", 2),
|
||||
("3", "Saw", "Saw", 3)]
|
||||
)
|
||||
marble_sharp = EnumProperty(
|
||||
name="Sharp",
|
||||
default="0",
|
||||
description="Marble sharpness",
|
||||
items = [
|
||||
("0", "Soft", "Soft", 0),
|
||||
("1", "Sharp", "Sharp", 1),
|
||||
("2", "Sharper", "Sharper", 2),
|
||||
("3", "Soft inv.", "Soft", 3),
|
||||
("4", "Sharp inv.", "Sharp", 4),
|
||||
("5", "Sharper inv.", "Sharper", 5)]
|
||||
)
|
||||
marble_shape = EnumProperty(
|
||||
name="Shape",
|
||||
default="0",
|
||||
description="Marble shape",
|
||||
items= [
|
||||
("0", "Default", "Default", 0),
|
||||
("1", "Ring", "Ring", 1),
|
||||
("2", "Swirl", "Swirl", 2),
|
||||
("3", "Bump", "Bump", 3),
|
||||
("4", "Wave", "Wave", 4),
|
||||
("5", "Z", "Z", 5),
|
||||
("6", "Y", "Y", 6),
|
||||
("7", "X", "X", 7)]
|
||||
)
|
||||
height = FloatProperty(
|
||||
name="Height",
|
||||
default=0.5,
|
||||
min=-10000.0,
|
||||
max=10000.0,
|
||||
description="Noise intensity scale"
|
||||
)
|
||||
height_invert = BoolProperty(
|
||||
name="Invert",
|
||||
default=False,
|
||||
description="Height invert",
|
||||
)
|
||||
height_offset = FloatProperty(
|
||||
name="Offset",
|
||||
default=0.0,
|
||||
min=-10000.0,
|
||||
max=10000.0,
|
||||
description="Height offset"
|
||||
)
|
||||
edge_falloff = EnumProperty(
|
||||
name="Falloff",
|
||||
default="0",
|
||||
description="Flatten edges",
|
||||
items = [
|
||||
("0", "None", "None", 0),
|
||||
("1", "Y", "Y Falloff", 1),
|
||||
("2", "X", "X Falloff", 2),
|
||||
("3", "X Y", "X Y Falloff", 3)]
|
||||
)
|
||||
falloff_x = FloatProperty(
|
||||
name="Falloff X",
|
||||
default=4.0,
|
||||
min=0.1,
|
||||
max=100.0,
|
||||
description="Falloff x scale"
|
||||
)
|
||||
falloff_y = FloatProperty(
|
||||
name="Falloff Y",
|
||||
default=4.0,
|
||||
min=0.1,
|
||||
max=100.0,
|
||||
description="Falloff y scale"
|
||||
)
|
||||
edge_level = FloatProperty(
|
||||
name="Edge Level",
|
||||
default=0.0,
|
||||
min=-10000.0,
|
||||
max=10000.0,
|
||||
description="Edge level, sealevel offset"
|
||||
)
|
||||
maximum = FloatProperty(
|
||||
name="Maximum",
|
||||
default=1.0,
|
||||
min=-10000.0,
|
||||
max=10000.0,
|
||||
description="Maximum, flattens terrain at plateau level"
|
||||
)
|
||||
minimum = FloatProperty(
|
||||
name="Minimum",
|
||||
default=-1.0,
|
||||
min=-10000.0,
|
||||
max=10000.0,
|
||||
description="Minimum, flattens terrain at seabed level"
|
||||
)
|
||||
use_vgroup = BoolProperty(
|
||||
name="Vertex Group Weight",
|
||||
default=False,
|
||||
description="Use active vertex group weight"
|
||||
)
|
||||
strata = FloatProperty(
|
||||
name="Amount",
|
||||
default=5.0,
|
||||
min=0.01,
|
||||
max=1000.0,
|
||||
description="Strata layers / terraces"
|
||||
)
|
||||
strata_type = EnumProperty(
|
||||
name="Strata",
|
||||
default="0",
|
||||
description="Strata types",
|
||||
items = [
|
||||
("0", "None", "No strata", 0),
|
||||
("1", "Smooth", "Smooth transitions", 1),
|
||||
("2", "Sharp Sub", "Sharp substract transitions", 2),
|
||||
("3", "Sharp Add", "Sharp add transitions", 3),
|
||||
("4", "Posterize", "Posterize", 4),
|
||||
("5", "Posterize Mix", "Posterize mixed", 5)]
|
||||
)
|
||||
water_plane = BoolProperty(
|
||||
name="Water Plane",
|
||||
default=False,
|
||||
description="Add water plane"
|
||||
)
|
||||
water_level = FloatProperty(
|
||||
name="Level",
|
||||
default=0.01,
|
||||
min=-10000.0,
|
||||
max=10000.0,
|
||||
description="Water level"
|
||||
)
|
||||
remove_double = BoolProperty(
|
||||
name="Remove Doubles",
|
||||
default=False,
|
||||
description="Remove doubles"
|
||||
)
|
||||
show_main_settings = BoolProperty(
|
||||
name="Main Settings",
|
||||
default=True,
|
||||
description="Show settings"
|
||||
)
|
||||
show_noise_settings = BoolProperty(
|
||||
name="Noise Settings",
|
||||
default=True,
|
||||
description="Show noise settings"
|
||||
)
|
||||
show_displace_settings = BoolProperty(
|
||||
name="Displace Settings",
|
||||
default=True,
|
||||
description="Show terrain settings"
|
||||
)
|
||||
refresh = BoolProperty(
|
||||
name="Refresh",
|
||||
default=False,
|
||||
description="Refresh"
|
||||
)
|
||||
auto_refresh = BoolProperty(
|
||||
name="Auto",
|
||||
default=False,
|
||||
description="Automatic refresh"
|
||||
)
|
||||
|
||||
|
||||
def draw(self, context):
|
||||
draw_ant_refresh(self, context)
|
||||
draw_ant_noise(self, context)
|
||||
draw_ant_displace(self, context, generate=False)
|
||||
|
||||
|
||||
@classmethod
|
||||
def poll(cls, context):
|
||||
ob = context.object
|
||||
return (ob and ob.type == 'MESH')
|
||||
|
||||
|
||||
def invoke(self, context, event):
|
||||
self.refresh = True
|
||||
return self.execute(context)
|
||||
|
||||
|
||||
def execute(self, context):
|
||||
if not self.refresh:
|
||||
return {'PASS_THROUGH'}
|
||||
|
||||
# turn off undo
|
||||
undo = bpy.context.user_preferences.edit.use_global_undo
|
||||
bpy.context.user_preferences.edit.use_global_undo = False
|
||||
|
||||
ob = context.object
|
||||
|
||||
# Properties:
|
||||
props = [
|
||||
self.ant_terrain_name,
|
||||
self.at_cursor,
|
||||
self.smooth_mesh,
|
||||
self.tri_face,
|
||||
self.sphere_mesh,
|
||||
self.land_material,
|
||||
self.water_material,
|
||||
self.texture_block,
|
||||
self.subdivision_x,
|
||||
self.subdivision_y,
|
||||
self.mesh_size_x,
|
||||
self.mesh_size_y,
|
||||
self.mesh_size,
|
||||
self.random_seed,
|
||||
self.noise_offset_x,
|
||||
self.noise_offset_y,
|
||||
self.noise_offset_z,
|
||||
self.noise_size_x,
|
||||
self.noise_size_y,
|
||||
self.noise_size_z,
|
||||
self.noise_size,
|
||||
self.noise_type,
|
||||
self.basis_type,
|
||||
self.vl_basis_type,
|
||||
self.distortion,
|
||||
self.hard_noise,
|
||||
self.noise_depth,
|
||||
self.amplitude,
|
||||
self.frequency,
|
||||
self.dimension,
|
||||
self.lacunarity,
|
||||
self.offset,
|
||||
self.gain,
|
||||
self.marble_bias,
|
||||
self.marble_sharp,
|
||||
self.marble_shape,
|
||||
self.height,
|
||||
self.height_invert,
|
||||
self.height_offset,
|
||||
self.maximum,
|
||||
self.minimum,
|
||||
self.edge_falloff,
|
||||
self.edge_level,
|
||||
self.falloff_x,
|
||||
self.falloff_y,
|
||||
self.strata_type,
|
||||
self.strata,
|
||||
self.water_plane,
|
||||
self.water_level,
|
||||
self.use_vgroup
|
||||
]
|
||||
|
||||
# do displace
|
||||
mesh = ob.data
|
||||
|
||||
if self.use_vgroup is True:
|
||||
vertex_group = ob.vertex_groups.active
|
||||
if vertex_group:
|
||||
for v in mesh.vertices:
|
||||
v.co += vertex_group.weight(v.index) * v.normal * noise_gen(v.co, props)
|
||||
|
||||
else:
|
||||
for v in mesh.vertices:
|
||||
v.co += v.normal * noise_gen(v.co, props)
|
||||
mesh.update()
|
||||
|
||||
if bpy.ops.object.shade_smooth == True:
|
||||
bpy.ops.object.shade_smooth()
|
||||
|
||||
if self.auto_refresh is False:
|
||||
self.refresh = False
|
||||
|
||||
# restore pre operator undo state
|
||||
context.user_preferences.edit.use_global_undo = undo
|
||||
|
||||
return {'FINISHED'}
|
||||
|
|
@ -0,0 +1,421 @@
|
|||
# ##### BEGIN GPL LICENSE BLOCK #####
|
||||
#
|
||||
# This program is free software; you can redistribute it and/or
|
||||
# modify it under the terms of the GNU General Public License
|
||||
# as published by the Free Software Foundation; either version 2
|
||||
# of the License, or (at your option) any later version.
|
||||
#
|
||||
# This program is distributed in the hope that it will be useful,
|
||||
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
# GNU General Public License for more details.
|
||||
#
|
||||
# You should have received a copy of the GNU General Public License
|
||||
# along with this program; if not, write to the Free Software Foundation,
|
||||
# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
#
|
||||
# ##### END GPL LICENSE BLOCK #####
|
||||
#---------------------------- LATTICE ALONG SURFACE ---------------------------#
|
||||
#--------------------------------- version 0.3 --------------------------------#
|
||||
# #
|
||||
# Automatically generate and assign a lattice that follows the active surface. #
|
||||
# #
|
||||
# (c) Alessandro Zomparelli #
|
||||
# (2017) #
|
||||
# #
|
||||
# http://www.co-de-it.com/ #
|
||||
# #
|
||||
################################################################################
|
||||
|
||||
import bpy, bmesh
|
||||
from mathutils import Vector, Matrix
|
||||
|
||||
bl_info = {
|
||||
"name": "Lattice",
|
||||
"author": "Alessandro Zomparelli (Co-de-iT)",
|
||||
"version": (0, 3),
|
||||
"blender": (2, 7, 8),
|
||||
"location": "",
|
||||
"description": "Generate a Lattice based on a grid mesh",
|
||||
"warning": "",
|
||||
"wiki_url": "",
|
||||
"tracker_url": "",
|
||||
"category": "Mesh"}
|
||||
|
||||
|
||||
def not_in(element, grid):
|
||||
output = True
|
||||
for loop in grid:
|
||||
if element in loop:
|
||||
output = False
|
||||
break
|
||||
return output
|
||||
|
||||
def grid_from_mesh(mesh, swap_uv):
|
||||
bm = bmesh.new()
|
||||
bm.from_mesh(mesh)
|
||||
verts_grid = []
|
||||
edges_grid = []
|
||||
faces_grid = []
|
||||
|
||||
running_grid = True
|
||||
while running_grid:
|
||||
verts_loop = []
|
||||
edges_loop = []
|
||||
faces_loop = []
|
||||
|
||||
# storing first point
|
||||
verts_candidates = []
|
||||
if len(faces_grid) == 0: verts_candidates = bm.verts # for first loop check all vertices
|
||||
else: verts_candidates = [v for v in bm.faces[faces_grid[-1][0]].verts if not_in(v.index, verts_grid)] # for other loops start form the vertices of the first face the last loop, skipping already used vertices
|
||||
|
||||
# check for last loop
|
||||
is_last = False
|
||||
for vert in verts_candidates:
|
||||
if len(vert.link_faces) == 1: # check if corner vertex
|
||||
vert.select = True
|
||||
verts_loop.append(vert.index)
|
||||
is_last = True
|
||||
break
|
||||
if not is_last:
|
||||
for vert in verts_candidates:
|
||||
new_link_faces = [f for f in vert.link_faces if not_in(f.index, faces_grid)]
|
||||
if len(new_link_faces) < 2: # check if corner vertex
|
||||
vert.select = True
|
||||
verts_loop.append(vert.index)
|
||||
break
|
||||
|
||||
running_loop = len(verts_loop) > 0
|
||||
|
||||
while running_loop:
|
||||
bm.verts.ensure_lookup_table()
|
||||
id = verts_loop[-1]
|
||||
link_edges = bm.verts[id].link_edges
|
||||
# storing second point
|
||||
if len(verts_loop) == 1: # only one vertex stored in the loop
|
||||
if len(faces_grid) == 0: ### first loop ###
|
||||
edge = link_edges[swap_uv] # chose direction
|
||||
for vert in edge.verts:
|
||||
if vert.index != id:
|
||||
vert.select = True
|
||||
verts_loop.append(vert.index) # new vertex
|
||||
edges_loop.append(edge.index) # chosen edge
|
||||
faces_loop.append(edge.link_faces[0].index) # only one face
|
||||
#edge.link_faces[0].select = True
|
||||
else: ### other loops ###
|
||||
for edge in bm.faces[faces_grid[-1][0]].edges: # start from the edges of the first face of the last loop
|
||||
if bm.verts[verts_loop[0]] in edge.verts and bm.verts[verts_grid[-1][0]] not in edge.verts: # chose an edge starting from the first vertex that is not returning back
|
||||
for vert in edge.verts:
|
||||
if vert.index != id:
|
||||
vert.select = True
|
||||
verts_loop.append(vert.index)
|
||||
edges_loop.append(edge.index)
|
||||
for face in edge.link_faces:
|
||||
if not_in(face.index,faces_grid):
|
||||
faces_loop.append(face.index)
|
||||
# continuing the loop
|
||||
else:
|
||||
for edge in link_edges:
|
||||
for vert in edge.verts:
|
||||
store_data = False
|
||||
if not_in(vert.index, verts_grid) and vert.index not in verts_loop:
|
||||
if len(faces_loop) > 0:
|
||||
bm.faces.ensure_lookup_table()
|
||||
if vert not in bm.faces[faces_loop[-1]].verts: store_data = True
|
||||
else:
|
||||
store_data = True
|
||||
if store_data:
|
||||
vert.select = True
|
||||
verts_loop.append(vert.index)
|
||||
edges_loop.append(edge.index)
|
||||
for face in edge.link_faces:
|
||||
if not_in(face.index, faces_grid):
|
||||
faces_loop.append(face.index)
|
||||
break
|
||||
# ending condition
|
||||
if verts_loop[-1] == id or verts_loop[-1] == verts_loop[0]: running_loop = False
|
||||
|
||||
verts_grid.append(verts_loop)
|
||||
edges_grid.append(edges_loop)
|
||||
faces_grid.append(faces_loop)
|
||||
if len(faces_loop) == 0: running_grid = False
|
||||
return verts_grid, edges_grid, faces_grid
|
||||
|
||||
class lattice_along_surface(bpy.types.Operator):
|
||||
bl_idname = "object.lattice_along_surface"
|
||||
bl_label = "Lattice along Surface"
|
||||
bl_description = ("Automatically add a Lattice modifier to the selected "
|
||||
"object, adapting it to the active one.\nThe active "
|
||||
"object must be a rectangular grid compatible with the "
|
||||
"Lattice's topology.")
|
||||
bl_options = {'REGISTER', 'UNDO'}
|
||||
|
||||
set_parent = bpy.props.BoolProperty(
|
||||
name="Set Parent", default=True,
|
||||
description="Automatically set the Lattice as parent")
|
||||
|
||||
flipNormals = bpy.props.BoolProperty(
|
||||
name="Flip Normals", default=False,
|
||||
description="Flip normals direction")
|
||||
|
||||
swapUV = bpy.props.BoolProperty(
|
||||
name="Swap UV", default=False,
|
||||
description="Flip grid's U and V")
|
||||
|
||||
flipU = bpy.props.BoolProperty(
|
||||
name="Flip U", default=False,
|
||||
description="Flip grid's U")
|
||||
|
||||
flipV = bpy.props.BoolProperty(
|
||||
name="Flip V", default=False,
|
||||
description="Flip grid's V")
|
||||
|
||||
flipW = bpy.props.BoolProperty(
|
||||
name="Flip W", default=False,
|
||||
description="Flip grid's W")
|
||||
|
||||
use_groups = bpy.props.BoolProperty(
|
||||
name="Vertex Group", default=False,
|
||||
description="Use active Vertex Group for lattice's thickness")
|
||||
|
||||
high_quality_lattice = bpy.props.BoolProperty(
|
||||
name="High quality", default=True,
|
||||
description="Increase the the subdivisions in normal direction for a "
|
||||
"more correct result")
|
||||
|
||||
hide_lattice = bpy.props.BoolProperty(
|
||||
name="Hide Lattice", default=True,
|
||||
description="Automatically hide the Lattice object")
|
||||
|
||||
scale_x = bpy.props.FloatProperty(
|
||||
name="Scale X", default=1, min=0.001,
|
||||
max=1, description="Object scale")
|
||||
|
||||
scale_y = bpy.props.FloatProperty(
|
||||
name="Scale Y", default=1, min=0.001,
|
||||
max=1, description="Object scale")
|
||||
|
||||
scale_z = bpy.props.FloatProperty(
|
||||
name="Scale Z", default=1, min=0.001,
|
||||
max=1, description="Object scale")
|
||||
|
||||
thickness = bpy.props.FloatProperty(
|
||||
name="Thickness", default=1, soft_min=0,
|
||||
soft_max=5, description="Lattice thickness")
|
||||
|
||||
displace = bpy.props.FloatProperty(
|
||||
name="Displace", default=0, soft_min=-1,
|
||||
soft_max=1, description="Lattice displace")
|
||||
|
||||
def draw(self, context):
|
||||
layout = self.layout
|
||||
col = layout.column(align=True)
|
||||
col.label(text="Thickness:")
|
||||
col.prop(
|
||||
self, "thickness", text="Thickness", icon='NONE', expand=False,
|
||||
slider=True, toggle=False, icon_only=False, event=False,
|
||||
full_event=False, emboss=True, index=-1)
|
||||
col.prop(
|
||||
self, "displace", text="Offset", icon='NONE', expand=False,
|
||||
slider=True, toggle=False, icon_only=False, event=False,
|
||||
full_event=False, emboss=True, index=-1)
|
||||
row = col.row()
|
||||
row.prop(self, "use_groups")
|
||||
col.separator()
|
||||
col.label(text="Scale:")
|
||||
col.prop(
|
||||
self, "scale_x", text="U", icon='NONE', expand=False,
|
||||
slider=True, toggle=False, icon_only=False, event=False,
|
||||
full_event=False, emboss=True, index=-1)
|
||||
col.prop(
|
||||
self, "scale_y", text="V", icon='NONE', expand=False,
|
||||
slider=True, toggle=False, icon_only=False, event=False,
|
||||
full_event=False, emboss=True, index=-1)
|
||||
'''
|
||||
col.prop(
|
||||
self, "scale_z", text="W", icon='NONE', expand=False,
|
||||
slider=True, toggle=False, icon_only=False, event=False,
|
||||
full_event=False, emboss=True, index=-1)
|
||||
'''
|
||||
col.separator()
|
||||
col.label(text="Flip:")
|
||||
row = col.row()
|
||||
row.prop(self, "flipU", text="U")
|
||||
row.prop(self, "flipV", text="V")
|
||||
row.prop(self, "flipW", text="W")
|
||||
col.prop(self, "swapUV")
|
||||
col.prop(self, "flipNormals")
|
||||
col.separator()
|
||||
col.label(text="Lattice Options:")
|
||||
col.prop(self, "high_quality_lattice")
|
||||
col.prop(self, "hide_lattice")
|
||||
col.prop(self, "set_parent")
|
||||
|
||||
def execute(self, context):
|
||||
grid_obj = bpy.context.active_object
|
||||
if grid_obj.type not in ('MESH', 'CURVE', 'SURFACE'):
|
||||
self.report({'ERROR'}, "The surface object is not valid. Only Mesh,"
|
||||
"Curve and Surface objects are allowed.")
|
||||
return {'CANCELLED'}
|
||||
obj = None
|
||||
for o in bpy.context.selected_objects:
|
||||
if o.name != grid_obj.name and o.type in ('MESH', 'CURVE', \
|
||||
'SURFACE', 'FONT'):
|
||||
obj = o
|
||||
o.select = False
|
||||
break
|
||||
try:
|
||||
obj_dim = obj.dimensions
|
||||
obj_me = obj.to_mesh(bpy.context.scene, apply_modifiers=True,
|
||||
settings = 'PREVIEW')
|
||||
except:
|
||||
self.report({'ERROR'}, "The object to deform is not valid. Only "
|
||||
"Mesh, Curve, Surface and Font objects are allowed.")
|
||||
return {'CANCELLED'}
|
||||
|
||||
bpy.ops.object.duplicate_move()
|
||||
grid_obj = bpy.context.active_object
|
||||
bpy.ops.object.transform_apply(location=True, rotation=True, scale=True)
|
||||
grid_mesh = grid_obj.to_mesh(bpy.context.scene, apply_modifiers=True,
|
||||
settings = 'PREVIEW')
|
||||
# CREATING LATTICE
|
||||
min = Vector((0,0,0))
|
||||
max = Vector((0,0,0))
|
||||
first = True
|
||||
for v in obj_me.vertices:
|
||||
vert = obj.matrix_world * v.co
|
||||
if vert[0] < min[0] or first:
|
||||
min[0] = vert[0]
|
||||
if vert[1] < min[1] or first:
|
||||
min[1] = vert[1]
|
||||
if vert[2] < min[2] or first:
|
||||
min[2] = vert[2]
|
||||
if vert[0] > max[0] or first:
|
||||
max[0] = vert[0]
|
||||
if vert[1] > max[1] or first:
|
||||
max[1] = vert[1]
|
||||
if vert[2] > max[2] or first:
|
||||
max[2] = vert[2]
|
||||
first = False
|
||||
bb = max-min
|
||||
lattice_loc = (max+min)/2
|
||||
bpy.ops.object.add(type='LATTICE', view_align=False,
|
||||
enter_editmode=False)
|
||||
lattice = bpy.context.active_object
|
||||
lattice.location = lattice_loc
|
||||
lattice.scale = Vector((bb.x/self.scale_x, bb.y/self.scale_y,
|
||||
bb.z/self.scale_z))
|
||||
if bb.x == 0: lattice.scale.x = 1
|
||||
if bb.y == 0: lattice.scale.y = 1
|
||||
if bb.z == 0: lattice.scale.z = 1
|
||||
bpy.context.scene.objects.active = obj
|
||||
bpy.ops.object.modifier_add(type='LATTICE')
|
||||
obj.modifiers[-1].object = lattice
|
||||
|
||||
# set as parent
|
||||
if self.set_parent:
|
||||
obj.select = True
|
||||
lattice.select = True
|
||||
bpy.context.scene.objects.active = lattice
|
||||
bpy.ops.object.parent_set(type='LATTICE')
|
||||
|
||||
# reading grid structure
|
||||
verts_grid, edges_grid, faces_grid = grid_from_mesh(grid_mesh,
|
||||
swap_uv=self.swapUV)
|
||||
nu = len(verts_grid)
|
||||
nv = len(verts_grid[0])
|
||||
nw = 2
|
||||
scale_normal = self.thickness
|
||||
|
||||
try:
|
||||
lattice.data.points_u = nu
|
||||
lattice.data.points_v = nv
|
||||
lattice.data.points_w = nw
|
||||
for i in range(nu):
|
||||
for j in range(nv):
|
||||
for w in range(nw):
|
||||
if self.use_groups:
|
||||
try:
|
||||
displace = grid_obj.vertex_groups.active.weight(verts_grid[i][j])*scale_normal*bb.z
|
||||
except:
|
||||
displace = scale_normal*bb.z
|
||||
else: displace = scale_normal*bb.z
|
||||
target_point = (grid_mesh.vertices[verts_grid[i][j]].co + grid_mesh.vertices[verts_grid[i][j]].normal*(w + self.displace/2 - 0.5)*displace) - lattice.location
|
||||
if self.flipW: w = 1-w
|
||||
if self.flipU: i = nu-i-1
|
||||
if self.flipV: j = nv-j-1
|
||||
lattice.data.points[i + j*nu + w*nu*nv].co_deform.x = target_point.x / bpy.data.objects[lattice.name].scale.x
|
||||
lattice.data.points[i + j*nu + w*nu*nv].co_deform.y = target_point.y / bpy.data.objects[lattice.name].scale.y
|
||||
lattice.data.points[i + j*nu + w*nu*nv].co_deform.z = target_point.z / bpy.data.objects[lattice.name].scale.z
|
||||
except:
|
||||
bpy.ops.object.mode_set(mode='OBJECT')
|
||||
grid_obj.select = True
|
||||
lattice.select = True
|
||||
obj.select = False
|
||||
bpy.ops.object.delete(use_global=False)
|
||||
bpy.context.scene.objects.active = obj
|
||||
obj.select = True
|
||||
bpy.ops.object.modifier_remove(modifier=obj.modifiers[-1].name)
|
||||
if nu > 64 or nv > 64:
|
||||
self.report({'ERROR'}, "Maximum resolution allowed for Lattice is 64")
|
||||
else:
|
||||
self.report({'ERROR'}, "The grid mesh is not correct")
|
||||
return {'CANCELLED'}
|
||||
|
||||
#grid_obj.data = old_grid_data
|
||||
#print(old_grid_matrix)
|
||||
#grid_obj.matrix_world = old_grid_matrix
|
||||
|
||||
bpy.ops.object.mode_set(mode='OBJECT')
|
||||
grid_obj.select = True
|
||||
lattice.select = False
|
||||
obj.select = False
|
||||
bpy.ops.object.delete(use_global=False)
|
||||
bpy.context.scene.objects.active = lattice
|
||||
lattice.select = True
|
||||
if self.high_quality_lattice: bpy.context.object.data.points_w = 8
|
||||
else: bpy.context.object.data.use_outside = True
|
||||
if self.hide_lattice:
|
||||
bpy.ops.object.hide_view_set(unselected=False)
|
||||
bpy.context.scene.objects.active = obj
|
||||
obj.select = True
|
||||
lattice.select = False
|
||||
if self.flipNormals:
|
||||
try:
|
||||
bpy.ops.object.mode_set(mode='EDIT')
|
||||
bpy.ops.mesh.select_all(action='SELECT')
|
||||
bpy.ops.mesh.flip_normals()
|
||||
bpy.ops.object.mode_set(mode='OBJECT')
|
||||
except:
|
||||
pass
|
||||
return {'FINISHED'}
|
||||
|
||||
|
||||
class lattice_along_surface_panel(bpy.types.Panel):
|
||||
bl_label = "Modifiers Tools"
|
||||
bl_category = "Tools"
|
||||
bl_space_type = "VIEW_3D"
|
||||
bl_region_type = "TOOLS"
|
||||
bl_context = (("objectmode"))
|
||||
|
||||
def draw(self, context):
|
||||
layout = self.layout
|
||||
col = layout.column(align=True)
|
||||
try:
|
||||
col.operator("object.lattice_along_surface", icon="MOD_LATTICE")
|
||||
except:
|
||||
pass
|
||||
|
||||
|
||||
def register():
|
||||
bpy.utils.register_class(lattice_along_surface)
|
||||
bpy.utils.register_class(lattice_along_surface_panel)
|
||||
|
||||
|
||||
def unregister():
|
||||
bpy.utils.unregister_class(lattice_along_surface)
|
||||
bpy.utils.unregister_class(lattice_along_surface_panel)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
register()
|
||||
|
|
@ -1,21 +1,27 @@
|
|||
import bpy
|
||||
op = bpy.context.active_operator
|
||||
|
||||
op.ant_terrain_name = 'Landscape'
|
||||
op.land_material = ''
|
||||
op.water_material = ''
|
||||
op.texture_block = ''
|
||||
op.at_cursor = True
|
||||
op.smooth_mesh = True
|
||||
op.tri_face = False
|
||||
op.sphere_mesh = True
|
||||
op.subdivision_x = 128
|
||||
op.subdivision_x = 256
|
||||
op.subdivision_y = 128
|
||||
op.meshsize = 2.0
|
||||
op.meshsize_x = 2.0
|
||||
op.meshsize_y = 2.0
|
||||
op.mesh_size = 2.0
|
||||
op.mesh_size_x = 2.0
|
||||
op.mesh_size_y = 3.0
|
||||
op.random_seed = 387
|
||||
op.x_offset = 0.0
|
||||
op.y_offset = 0.0
|
||||
op.noise_size = 1.0
|
||||
op.noise_offset_x = 0.0
|
||||
op.noise_offset_y = 0.0
|
||||
op.noise_offset_z = 0.0
|
||||
op.noise_size_x = 1.0
|
||||
op.noise_size_y = 1.0
|
||||
op.noise_size_z = 1.0
|
||||
op.noise_size = 1.0
|
||||
op.noise_type = 'planet_noise'
|
||||
op.basis_type = '3'
|
||||
op.vl_basis_type = '3'
|
||||
|
|
@ -26,29 +32,28 @@ op.amplitude = 0.5
|
|||
op.frequency = 2.0
|
||||
op.dimension = 1.0
|
||||
op.lacunarity = 2.0
|
||||
op.moffset = 1.0
|
||||
op.offset = 1.0
|
||||
op.gain = 1.0
|
||||
op.marble_bias = '0'
|
||||
op.marble_sharp = '0'
|
||||
op.marble_shape = '0'
|
||||
op.height = 1.0
|
||||
op.invert = True
|
||||
op.offset = 0.0
|
||||
op.height_invert = True
|
||||
op.height_offset = 0.0
|
||||
op.edge_falloff = '0'
|
||||
op.falloff_size_x = 4.0
|
||||
op.falloff_size_y = 4.0
|
||||
op.falloff_x = 4.0
|
||||
op.falloff_y = 4.0
|
||||
op.edge_level = 0.0
|
||||
op.maximum = 1.0
|
||||
op.minimum = -1.0
|
||||
op.use_vgroup = False
|
||||
op.strata = 5.0
|
||||
op.strata_type = '3'
|
||||
op.water_plane = False
|
||||
op.water_level = 0.009999999776482582
|
||||
op.use_mat = False
|
||||
op.sel_land_mat = ''
|
||||
op.sel_water_mat = ''
|
||||
op.remove_double = False
|
||||
op.show_main_settings = True
|
||||
op.show_noise_settings = True
|
||||
op.show_terrain_settings = True
|
||||
op.show_displace_settings = True
|
||||
op.refresh = True
|
||||
op.auto_refresh = True
|
||||
op.texture_name = ''
|
||||
|
|
|
|||
|
|
@ -1,21 +1,27 @@
|
|||
import bpy
|
||||
op = bpy.context.active_operator
|
||||
|
||||
op.ant_terrain_name = 'Landscape'
|
||||
op.land_material = ''
|
||||
op.water_material = ''
|
||||
op.texture_block = ''
|
||||
op.at_cursor = True
|
||||
op.smooth_mesh = True
|
||||
op.tri_face = False
|
||||
op.sphere_mesh = False
|
||||
op.subdivision_x = 128
|
||||
op.subdivision_y = 192
|
||||
op.meshsize = 2.0
|
||||
op.meshsize_x = 2.0
|
||||
op.meshsize_y = 3.0
|
||||
op.mesh_size = 2.0
|
||||
op.mesh_size_x = 2.0
|
||||
op.mesh_size_y = 3.0
|
||||
op.random_seed = 1
|
||||
op.x_offset = 0.25
|
||||
op.y_offset = 0.0
|
||||
op.noise_size = 1.5
|
||||
op.noise_offset_x = 0.0
|
||||
op.noise_offset_y = 0.0
|
||||
op.noise_offset_z = 0.0
|
||||
op.noise_size_x = 1.0
|
||||
op.noise_size_y = 1.25
|
||||
op.noise_size_z = 1.0
|
||||
op.noise_size = 1.5
|
||||
op.noise_type = 'marble_noise'
|
||||
op.basis_type = '0'
|
||||
op.vl_basis_type = '0'
|
||||
|
|
@ -26,29 +32,28 @@ op.amplitude = 0.5
|
|||
op.frequency = 2.0
|
||||
op.dimension = 1.0
|
||||
op.lacunarity = 2.0
|
||||
op.moffset = 1.0
|
||||
op.offset = 1.0
|
||||
op.gain = 1.0
|
||||
op.marble_bias = '0'
|
||||
op.marble_sharp = '0'
|
||||
op.marble_shape = '4'
|
||||
op.height = 0.6000000238418579
|
||||
op.invert = False
|
||||
op.offset = -0.059999994933605194
|
||||
op.height_invert = False
|
||||
op.height_offset = 0.0
|
||||
op.edge_falloff = '2'
|
||||
op.falloff_size_x = 4.0
|
||||
op.falloff_size_y = 10.0
|
||||
op.falloff_x = 4.0
|
||||
op.falloff_y = 4.0
|
||||
op.edge_level = 0.15000000596046448
|
||||
op.maximum = 1.0
|
||||
op.minimum = -0.20000000298023224
|
||||
op.use_vgroup = False
|
||||
op.strata = 4.0
|
||||
op.strata_type = '2'
|
||||
op.water_plane = False
|
||||
op.water_level = 0.009999999776482582
|
||||
op.use_mat = False
|
||||
op.sel_land_mat = ''
|
||||
op.sel_water_mat = ''
|
||||
op.remove_double = False
|
||||
op.show_main_settings = True
|
||||
op.show_noise_settings = True
|
||||
op.show_terrain_settings = True
|
||||
op.show_displace_settings = True
|
||||
op.refresh = True
|
||||
op.auto_refresh = True
|
||||
op.texture_name = ''
|
||||
|
|
|
|||
|
|
@ -1,22 +1,28 @@
|
|||
import bpy
|
||||
op = bpy.context.active_operator
|
||||
|
||||
op.ant_terrain_name = 'Landscape'
|
||||
op.land_material = ''
|
||||
op.water_material = ''
|
||||
op.texture_block = ''
|
||||
op.at_cursor = True
|
||||
op.smooth_mesh = True
|
||||
op.tri_face = False
|
||||
op.sphere_mesh = False
|
||||
op.subdivision_x = 128
|
||||
op.subdivision_y = 128
|
||||
op.meshsize = 2.0
|
||||
op.meshsize_x = 2.0
|
||||
op.meshsize_y = 2.0
|
||||
op.mesh_size = 2.0
|
||||
op.mesh_size_x = 2.0
|
||||
op.mesh_size_y = 2.0
|
||||
op.random_seed = 860
|
||||
op.x_offset = 0.0
|
||||
op.y_offset = 0.0
|
||||
op.noise_size = 0.5
|
||||
op.noise_offset_x = 0.0
|
||||
op.noise_offset_y = 0.0
|
||||
op.noise_offset_z = 0.0
|
||||
op.noise_size_x = 1.0
|
||||
op.noise_size_y = 1.0
|
||||
op.noise_type = 'fractal'
|
||||
op.noise_size_z = 1.0
|
||||
op.noise_size = 0.5
|
||||
op.noise_type = 'multi_fractal'
|
||||
op.basis_type = '3'
|
||||
op.vl_basis_type = '0'
|
||||
op.distortion = 1.0
|
||||
|
|
@ -26,29 +32,28 @@ op.amplitude = 0.5
|
|||
op.frequency = 2.0
|
||||
op.dimension = 1.0
|
||||
op.lacunarity = 5.0
|
||||
op.moffset = 1.0
|
||||
op.offset = 1.0
|
||||
op.gain = 1.0
|
||||
op.marble_bias = '0'
|
||||
op.marble_sharp = '0'
|
||||
op.marble_shape = '0'
|
||||
op.height = 0.10000000149011612
|
||||
op.invert = True
|
||||
op.offset = 0.05000000074505806
|
||||
op.height = 0.20000000298023224
|
||||
op.height_invert = True
|
||||
op.height_offset = 0.0
|
||||
op.edge_falloff = '3'
|
||||
op.falloff_size_x = 6.0
|
||||
op.falloff_size_y = 6.0
|
||||
op.falloff_x = 8.0
|
||||
op.falloff_y = 8.0
|
||||
op.edge_level = 0.0
|
||||
op.maximum = 1.0
|
||||
op.minimum = -0.10999999940395355
|
||||
op.minimum = -1.0
|
||||
op.use_vgroup = False
|
||||
op.strata = 5.0
|
||||
op.strata_type = '0'
|
||||
op.water_plane = False
|
||||
op.water_level = 0.009999999776482582
|
||||
op.use_mat = False
|
||||
op.sel_land_mat = ''
|
||||
op.sel_water_mat = ''
|
||||
op.remove_double = False
|
||||
op.show_main_settings = True
|
||||
op.show_noise_settings = True
|
||||
op.show_terrain_settings = True
|
||||
op.show_displace_settings = True
|
||||
op.refresh = True
|
||||
op.auto_refresh = True
|
||||
op.texture_name = ''
|
||||
|
|
|
|||
|
|
@ -1,21 +1,27 @@
|
|||
import bpy
|
||||
op = bpy.context.active_operator
|
||||
|
||||
op.ant_terrain_name = 'Landscape'
|
||||
op.land_material = ''
|
||||
op.water_material = ''
|
||||
op.texture_block = ''
|
||||
op.at_cursor = True
|
||||
op.smooth_mesh = True
|
||||
op.tri_face = False
|
||||
op.sphere_mesh = True
|
||||
op.subdivision_x = 128
|
||||
op.subdivision_x = 256
|
||||
op.subdivision_y = 128
|
||||
op.meshsize = 2.0
|
||||
op.meshsize_x = 2.0
|
||||
op.meshsize_y = 2.0
|
||||
op.mesh_size = 2.0
|
||||
op.mesh_size_x = 2.0
|
||||
op.mesh_size_y = 2.0
|
||||
op.random_seed = 0
|
||||
op.x_offset = 0.0
|
||||
op.y_offset = 0.0
|
||||
op.noise_size = 1.0
|
||||
op.noise_offset_x = 0.0
|
||||
op.noise_offset_y = 0.0
|
||||
op.noise_offset_z = 0.0
|
||||
op.noise_size_x = 1.0
|
||||
op.noise_size_y = 1.0
|
||||
op.noise_size_z = 1.0
|
||||
op.noise_size = 1.0
|
||||
op.noise_type = 'turbulence_vector'
|
||||
op.basis_type = '6'
|
||||
op.vl_basis_type = '0'
|
||||
|
|
@ -26,29 +32,28 @@ op.amplitude = 0.5
|
|||
op.frequency = 2.0
|
||||
op.dimension = 1.0
|
||||
op.lacunarity = 2.0
|
||||
op.moffset = 1.0
|
||||
op.offset = 1.0
|
||||
op.gain = 1.0
|
||||
op.marble_bias = '0'
|
||||
op.marble_sharp = '0'
|
||||
op.marble_shape = '0'
|
||||
op.height = 1.0
|
||||
op.invert = False
|
||||
op.offset = 0.0
|
||||
op.height_invert = False
|
||||
op.height_offset = 0.0
|
||||
op.edge_falloff = '0'
|
||||
op.falloff_size_x = 4.0
|
||||
op.falloff_size_y = 4.0
|
||||
op.falloff_x = 4.0
|
||||
op.falloff_y = 4.0
|
||||
op.edge_level = 0.0
|
||||
op.maximum = 2.0
|
||||
op.minimum = -1.0
|
||||
op.use_vgroup = False
|
||||
op.strata = 5.0
|
||||
op.strata_type = '0'
|
||||
op.water_plane = False
|
||||
op.water_level = 0.009999999776482582
|
||||
op.use_mat = False
|
||||
op.sel_land_mat = ''
|
||||
op.sel_water_mat = ''
|
||||
op.remove_double = False
|
||||
op.show_main_settings = True
|
||||
op.show_noise_settings = True
|
||||
op.show_terrain_settings = True
|
||||
op.show_displace_settings = True
|
||||
op.refresh = True
|
||||
op.auto_refresh = True
|
||||
op.texture_name = ''
|
||||
|
|
|
|||
|
|
@ -1,21 +1,27 @@
|
|||
import bpy
|
||||
op = bpy.context.active_operator
|
||||
|
||||
op.ant_terrain_name = 'Landscape'
|
||||
op.land_material = ''
|
||||
op.water_material = ''
|
||||
op.texture_block = ''
|
||||
op.at_cursor = True
|
||||
op.smooth_mesh = True
|
||||
op.tri_face = False
|
||||
op.sphere_mesh = False
|
||||
op.subdivision_x = 128
|
||||
op.subdivision_y = 128
|
||||
op.meshsize = 2.0
|
||||
op.meshsize_x = 2.0
|
||||
op.meshsize_y = 2.0
|
||||
op.mesh_size = 2.0
|
||||
op.mesh_size_x = 2.0
|
||||
op.mesh_size_y = 2.0
|
||||
op.random_seed = 0
|
||||
op.x_offset = 0.0
|
||||
op.y_offset = 0.0
|
||||
op.noise_size = 1.0
|
||||
op.noise_offset_x = 0.0
|
||||
op.noise_offset_y = 0.0
|
||||
op.noise_offset_z = 0.0
|
||||
op.noise_size_x = 1.0
|
||||
op.noise_size_y = 1.0
|
||||
op.noise_size_z = 1.0
|
||||
op.noise_size = 1.0
|
||||
op.noise_type = 'hetero_terrain'
|
||||
op.basis_type = '0'
|
||||
op.vl_basis_type = '0'
|
||||
|
|
@ -26,29 +32,28 @@ op.amplitude = 0.5
|
|||
op.frequency = 2.0
|
||||
op.dimension = 1.0
|
||||
op.lacunarity = 2.0
|
||||
op.moffset = 1.0
|
||||
op.offset = 1.0
|
||||
op.gain = 1.0
|
||||
op.marble_bias = '0'
|
||||
op.marble_sharp = '0'
|
||||
op.marble_shape = '0'
|
||||
op.height = 0.5
|
||||
op.invert = False
|
||||
op.offset = 0.0
|
||||
op.height_invert = False
|
||||
op.height_offset = 0.0
|
||||
op.edge_falloff = '3'
|
||||
op.falloff_size_x = 4.0
|
||||
op.falloff_size_y = 4.0
|
||||
op.falloff_x = 4.0
|
||||
op.falloff_y = 4.0
|
||||
op.edge_level = 0.0
|
||||
op.maximum = 1.0
|
||||
op.minimum = -0.10999999940395355
|
||||
op.minimum = -1.0
|
||||
op.use_vgroup = False
|
||||
op.strata = 5.0
|
||||
op.strata_type = '0'
|
||||
op.water_plane = False
|
||||
op.water_level = 0.009999999776482582
|
||||
op.use_mat = False
|
||||
op.sel_land_mat = ''
|
||||
op.sel_water_mat = ''
|
||||
op.remove_double = False
|
||||
op.show_main_settings = True
|
||||
op.show_noise_settings = True
|
||||
op.show_terrain_settings = True
|
||||
op.show_displace_settings = True
|
||||
op.refresh = True
|
||||
op.auto_refresh = True
|
||||
op.texture_name = ''
|
||||
|
|
|
|||
|
|
@ -1,21 +1,27 @@
|
|||
import bpy
|
||||
op = bpy.context.active_operator
|
||||
|
||||
op.ant_terrain_name = 'Landscape'
|
||||
op.land_material = ''
|
||||
op.water_material = ''
|
||||
op.texture_block = ''
|
||||
op.at_cursor = True
|
||||
op.smooth_mesh = True
|
||||
op.tri_face = False
|
||||
op.sphere_mesh = False
|
||||
op.subdivision_x = 128
|
||||
op.subdivision_y = 128
|
||||
op.meshsize = 2.0
|
||||
op.meshsize_x = 20.0
|
||||
op.meshsize_y = 20.0
|
||||
op.mesh_size = 2.0
|
||||
op.mesh_size_x = 20.0
|
||||
op.mesh_size_y = 20.0
|
||||
op.random_seed = 0
|
||||
op.x_offset = 0.0
|
||||
op.y_offset = 0.0
|
||||
op.noise_size = 10.0
|
||||
op.noise_offset_x = 0.0
|
||||
op.noise_offset_y = 0.0
|
||||
op.noise_offset_z = 0.0
|
||||
op.noise_size_x = 1.0
|
||||
op.noise_size_y = 1.0
|
||||
op.noise_size_z = 1.0
|
||||
op.noise_size = 10.0
|
||||
op.noise_type = 'hetero_terrain'
|
||||
op.basis_type = '0'
|
||||
op.vl_basis_type = '0'
|
||||
|
|
@ -26,29 +32,28 @@ op.amplitude = 0.5
|
|||
op.frequency = 2.0
|
||||
op.dimension = 1.0
|
||||
op.lacunarity = 2.0
|
||||
op.moffset = 1.0
|
||||
op.offset = 1.0
|
||||
op.gain = 1.0
|
||||
op.marble_bias = '0'
|
||||
op.marble_sharp = '0'
|
||||
op.marble_shape = '0'
|
||||
op.height = 5.0
|
||||
op.invert = False
|
||||
op.offset = 0.0
|
||||
op.height_invert = False
|
||||
op.height_offset = 0.0
|
||||
op.edge_falloff = '3'
|
||||
op.falloff_size_x = 4.0
|
||||
op.falloff_size_y = 4.0
|
||||
op.falloff_x = 4.0
|
||||
op.falloff_y = 4.0
|
||||
op.edge_level = 0.0
|
||||
op.maximum = 10.0
|
||||
op.minimum = -1.0
|
||||
op.use_vgroup = False
|
||||
op.strata = 5.0
|
||||
op.strata_type = '0'
|
||||
op.water_plane = False
|
||||
op.water_level = 0.009999999776482582
|
||||
op.use_mat = False
|
||||
op.sel_land_mat = ''
|
||||
op.sel_water_mat = ''
|
||||
op.remove_double = False
|
||||
op.show_main_settings = True
|
||||
op.show_noise_settings = True
|
||||
op.show_terrain_settings = True
|
||||
op.show_displace_settings = True
|
||||
op.refresh = True
|
||||
op.auto_refresh = True
|
||||
op.texture_name = ''
|
||||
|
|
|
|||
|
|
@ -1,21 +1,27 @@
|
|||
import bpy
|
||||
op = bpy.context.active_operator
|
||||
|
||||
op.ant_terrain_name = 'Landscape'
|
||||
op.land_material = ''
|
||||
op.water_material = ''
|
||||
op.texture_block = ''
|
||||
op.at_cursor = True
|
||||
op.smooth_mesh = True
|
||||
op.tri_face = False
|
||||
op.sphere_mesh = False
|
||||
op.subdivision_x = 128
|
||||
op.subdivision_y = 128
|
||||
op.meshsize = 2.0
|
||||
op.meshsize_x = 2.0
|
||||
op.meshsize_y = 2.0
|
||||
op.mesh_size = 2.0
|
||||
op.mesh_size_x = 2.0
|
||||
op.mesh_size_y = 2.0
|
||||
op.random_seed = 2
|
||||
op.x_offset = 0.0
|
||||
op.y_offset = 0.0
|
||||
op.noise_size = 0.5
|
||||
op.noise_offset_x = 0.0
|
||||
op.noise_offset_y = 0.0
|
||||
op.noise_offset_z = 0.0
|
||||
op.noise_size_x = 1.0
|
||||
op.noise_size_y = 1.0
|
||||
op.noise_size_z = 1.0
|
||||
op.noise_size = 0.5
|
||||
op.noise_type = 'fractal'
|
||||
op.basis_type = '8'
|
||||
op.vl_basis_type = '0'
|
||||
|
|
@ -26,29 +32,28 @@ op.amplitude = 0.5
|
|||
op.frequency = 2.0
|
||||
op.dimension = 1.0
|
||||
op.lacunarity = 2.0
|
||||
op.moffset = 1.0
|
||||
op.offset = 0.009999999776482582
|
||||
op.gain = 1.0
|
||||
op.marble_bias = '0'
|
||||
op.marble_sharp = '0'
|
||||
op.marble_shape = '0'
|
||||
op.height = 0.05000000074505806
|
||||
op.invert = False
|
||||
op.offset = 0.0
|
||||
op.height_invert = False
|
||||
op.height_offset = 0.0
|
||||
op.edge_falloff = '0'
|
||||
op.falloff_size_x = 4.0
|
||||
op.falloff_size_y = 4.0
|
||||
op.falloff_x = 4.0
|
||||
op.falloff_y = 4.0
|
||||
op.edge_level = 0.0
|
||||
op.maximum = 1.0
|
||||
op.minimum = 0.0
|
||||
op.use_vgroup = False
|
||||
op.strata = 5.0
|
||||
op.strata_type = '0'
|
||||
op.water_plane = False
|
||||
op.water_level = 0.009999999776482582
|
||||
op.use_mat = False
|
||||
op.sel_land_mat = ''
|
||||
op.sel_water_mat = ''
|
||||
op.remove_double = False
|
||||
op.show_main_settings = True
|
||||
op.show_noise_settings = True
|
||||
op.show_terrain_settings = True
|
||||
op.show_displace_settings = True
|
||||
op.refresh = True
|
||||
op.auto_refresh = True
|
||||
op.texture_name = ''
|
||||
|
|
|
|||
|
|
@ -1,54 +0,0 @@
|
|||
import bpy
|
||||
op = bpy.context.active_operator
|
||||
|
||||
op.at_cursor = True
|
||||
op.smooth_mesh = True
|
||||
op.tri_face = False
|
||||
op.sphere_mesh = False
|
||||
op.subdivision_x = 128
|
||||
op.subdivision_y = 128
|
||||
op.meshsize = 2.0
|
||||
op.meshsize_x = 2.0
|
||||
op.meshsize_y = 2.0
|
||||
op.random_seed = 8
|
||||
op.x_offset = 0.0
|
||||
op.y_offset = 0.0
|
||||
op.noise_size = 1.5
|
||||
op.noise_size_x = 1.0
|
||||
op.noise_size_y = 1.0
|
||||
op.noise_type = 'turbulence_vector'
|
||||
op.basis_type = '3'
|
||||
op.vl_basis_type = '0'
|
||||
op.distortion = 1.0
|
||||
op.hard_noise = '1'
|
||||
op.noise_depth = 8
|
||||
op.amplitude = 0.5
|
||||
op.frequency = 2.0
|
||||
op.dimension = 1.0
|
||||
op.lacunarity = 2.0
|
||||
op.moffset = 1.0
|
||||
op.gain = 1.0
|
||||
op.marble_bias = '0'
|
||||
op.marble_sharp = '0'
|
||||
op.marble_shape = '0'
|
||||
op.height = 0.4000000059604645
|
||||
op.invert = False
|
||||
op.offset = -0.20000000298023224
|
||||
op.edge_falloff = '3'
|
||||
op.falloff_size_x = 4.0
|
||||
op.falloff_size_y = 4.0
|
||||
op.edge_level = 0.0
|
||||
op.maximum = 1.0
|
||||
op.minimum = -0.10999999940395355
|
||||
op.strata = 5.0
|
||||
op.strata_type = '0'
|
||||
op.water_plane = True
|
||||
op.water_level = -0.019999999552965164
|
||||
op.use_mat = False
|
||||
op.sel_land_mat = ''
|
||||
op.sel_water_mat = ''
|
||||
op.show_noise_settings = True
|
||||
op.show_terrain_settings = True
|
||||
op.refresh = True
|
||||
op.auto_refresh = True
|
||||
op.texture_name = ''
|
||||
|
|
@ -1,24 +1,30 @@
|
|||
import bpy
|
||||
op = bpy.context.active_operator
|
||||
|
||||
op.ant_terrain_name = 'Landscape'
|
||||
op.land_material = ''
|
||||
op.water_material = ''
|
||||
op.texture_block = ''
|
||||
op.at_cursor = True
|
||||
op.smooth_mesh = True
|
||||
op.tri_face = False
|
||||
op.sphere_mesh = False
|
||||
op.subdivision_x = 128
|
||||
op.subdivision_y = 128
|
||||
op.meshsize = 2.0
|
||||
op.meshsize_x = 2.0
|
||||
op.meshsize_y = 2.0
|
||||
op.mesh_size = 2.0
|
||||
op.mesh_size_x = 2.0
|
||||
op.mesh_size_y = 2.0
|
||||
op.random_seed = 3
|
||||
op.x_offset = 0.0
|
||||
op.y_offset = 0.0
|
||||
op.noise_size = 0.75
|
||||
op.noise_offset_x = 0.0
|
||||
op.noise_offset_y = 0.0
|
||||
op.noise_offset_z = 0.0
|
||||
op.noise_size_x = 1.0
|
||||
op.noise_size_y = 1.0
|
||||
op.noise_size_z = 1.0
|
||||
op.noise_size = 0.75
|
||||
op.noise_type = 'ridged_multi_fractal'
|
||||
op.basis_type = '0'
|
||||
op.vl_basis_type = '0'
|
||||
op.vl_basis_type = '7'
|
||||
op.distortion = 1.0
|
||||
op.hard_noise = '0'
|
||||
op.noise_depth = 12
|
||||
|
|
@ -26,29 +32,28 @@ op.amplitude = 0.5
|
|||
op.frequency = 2.0
|
||||
op.dimension = 1.0
|
||||
op.lacunarity = 2.0
|
||||
op.moffset = 0.8500000238418579
|
||||
op.gain = 4.5
|
||||
op.offset = 0.880000114440918
|
||||
op.gain = 4.199997901916504
|
||||
op.marble_bias = '0'
|
||||
op.marble_sharp = '0'
|
||||
op.marble_shape = '0'
|
||||
op.height = 0.5
|
||||
op.invert = False
|
||||
op.offset = 0.20000000298023224
|
||||
op.height_invert = False
|
||||
op.height_offset = 0.25
|
||||
op.edge_falloff = '3'
|
||||
op.falloff_size_x = 2.0
|
||||
op.falloff_size_y = 2.0
|
||||
op.falloff_x = 2.0
|
||||
op.falloff_y = 2.0
|
||||
op.edge_level = 0.0
|
||||
op.maximum = 1.0
|
||||
op.minimum = -0.10999999940395355
|
||||
op.minimum = -1.0
|
||||
op.use_vgroup = False
|
||||
op.strata = 5.0
|
||||
op.strata_type = '0'
|
||||
op.water_plane = False
|
||||
op.water_level = 0.009999999776482582
|
||||
op.use_mat = False
|
||||
op.sel_land_mat = ''
|
||||
op.sel_water_mat = ''
|
||||
op.remove_double = False
|
||||
op.show_main_settings = True
|
||||
op.show_noise_settings = True
|
||||
op.show_terrain_settings = True
|
||||
op.show_displace_settings = True
|
||||
op.refresh = True
|
||||
op.auto_refresh = True
|
||||
op.texture_name = ''
|
||||
|
|
|
|||
|
|
@ -1,21 +1,27 @@
|
|||
import bpy
|
||||
op = bpy.context.active_operator
|
||||
|
||||
op.ant_terrain_name = 'Landscape'
|
||||
op.land_material = ''
|
||||
op.water_material = ''
|
||||
op.texture_block = ''
|
||||
op.at_cursor = True
|
||||
op.smooth_mesh = True
|
||||
op.tri_face = True
|
||||
op.sphere_mesh = True
|
||||
op.subdivision_x = 256
|
||||
op.subdivision_y = 128
|
||||
op.meshsize = 2.0
|
||||
op.meshsize_x = 2.0
|
||||
op.meshsize_y = 2.0
|
||||
op.mesh_size = 2.0
|
||||
op.mesh_size_x = 2.0
|
||||
op.mesh_size_y = 2.0
|
||||
op.random_seed = 0
|
||||
op.x_offset = 0.0
|
||||
op.y_offset = 0.0
|
||||
op.noise_size = 0.5
|
||||
op.noise_offset_x = 0.0
|
||||
op.noise_offset_y = 0.0
|
||||
op.noise_offset_z = 0.0
|
||||
op.noise_size_x = 1.0
|
||||
op.noise_size_y = 1.0
|
||||
op.noise_size_z = 1.0
|
||||
op.noise_size = 0.5
|
||||
op.noise_type = 'planet_noise'
|
||||
op.basis_type = '1'
|
||||
op.vl_basis_type = '0'
|
||||
|
|
@ -26,29 +32,28 @@ op.amplitude = 0.5
|
|||
op.frequency = 2.0
|
||||
op.dimension = 1.0
|
||||
op.lacunarity = 2.0
|
||||
op.moffset = 1.0
|
||||
op.offset = 1.0
|
||||
op.gain = 1.0
|
||||
op.marble_bias = '0'
|
||||
op.marble_sharp = '0'
|
||||
op.marble_shape = '0'
|
||||
op.height = 0.10000000149011612
|
||||
op.invert = False
|
||||
op.offset = 0.0
|
||||
op.height_invert = False
|
||||
op.height_offset = 0.25
|
||||
op.edge_falloff = '0'
|
||||
op.falloff_size_x = 4.0
|
||||
op.falloff_size_y = 4.0
|
||||
op.falloff_x = 2.0
|
||||
op.falloff_y = 2.0
|
||||
op.edge_level = 0.0
|
||||
op.maximum = 1.0
|
||||
op.minimum = -0.10999999940395355
|
||||
op.minimum = -1.0
|
||||
op.use_vgroup = False
|
||||
op.strata = 5.0
|
||||
op.strata_type = '0'
|
||||
op.water_plane = False
|
||||
op.water_level = 0.009999999776482582
|
||||
op.use_mat = False
|
||||
op.sel_land_mat = ''
|
||||
op.sel_water_mat = ''
|
||||
op.remove_double = False
|
||||
op.show_main_settings = True
|
||||
op.show_noise_settings = True
|
||||
op.show_terrain_settings = True
|
||||
op.show_displace_settings = True
|
||||
op.refresh = True
|
||||
op.auto_refresh = True
|
||||
op.texture_name = ''
|
||||
|
|
|
|||
|
|
@ -1,54 +1,59 @@
|
|||
import bpy
|
||||
op = bpy.context.active_operator
|
||||
|
||||
op.ant_terrain_name = 'Landscape'
|
||||
op.land_material = ''
|
||||
op.water_material = ''
|
||||
op.texture_block = ''
|
||||
op.at_cursor = True
|
||||
op.smooth_mesh = True
|
||||
op.tri_face = False
|
||||
op.sphere_mesh = False
|
||||
op.subdivision_x = 128
|
||||
op.subdivision_y = 128
|
||||
op.meshsize = 2.0
|
||||
op.meshsize_x = 2.0
|
||||
op.meshsize_y = 2.0
|
||||
op.random_seed = 285
|
||||
op.x_offset = 0.0
|
||||
op.y_offset = 0.0
|
||||
op.noise_size = 1.0
|
||||
op.mesh_size = 2.0
|
||||
op.mesh_size_x = 2.0
|
||||
op.mesh_size_y = 2.0
|
||||
op.random_seed = 488
|
||||
op.noise_offset_x = 0.0
|
||||
op.noise_offset_y = 0.0
|
||||
op.noise_offset_z = 0.0
|
||||
op.noise_size_x = 1.0
|
||||
op.noise_size_y = 1.0
|
||||
op.noise_type = 'vl_noise_turbulence'
|
||||
op.basis_type = '0'
|
||||
op.vl_basis_type = '0'
|
||||
op.noise_size_z = 1.0
|
||||
op.noise_size = 1.0
|
||||
op.noise_type = 'shattered_hterrain'
|
||||
op.basis_type = '3'
|
||||
op.vl_basis_type = '7'
|
||||
op.distortion = 1.149999976158142
|
||||
op.hard_noise = '1'
|
||||
op.noise_depth = 6
|
||||
op.hard_noise = '0'
|
||||
op.noise_depth = 8
|
||||
op.amplitude = 0.4000000059604645
|
||||
op.frequency = 2.0
|
||||
op.dimension = 1.0
|
||||
op.lacunarity = 2.0
|
||||
op.moffset = 1.0
|
||||
op.gain = 1.5
|
||||
op.offset = 1.0
|
||||
op.gain = 1.0
|
||||
op.marble_bias = '0'
|
||||
op.marble_sharp = '0'
|
||||
op.marble_shape = '0'
|
||||
op.height = 0.4000000059604645
|
||||
op.invert = False
|
||||
op.offset = 0.05000000074505806
|
||||
op.height = 0.5
|
||||
op.height_invert = False
|
||||
op.height_offset = 0.20000000298023224
|
||||
op.edge_falloff = '3'
|
||||
op.falloff_size_x = 2.0
|
||||
op.falloff_size_y = 2.0
|
||||
op.falloff_x = 3.0
|
||||
op.falloff_y = 3.0
|
||||
op.edge_level = 0.0
|
||||
op.maximum = 0.20000000298023224
|
||||
op.minimum = -0.20000000298023224
|
||||
op.strata = 3.0
|
||||
op.strata_type = '3'
|
||||
op.maximum = 0.25
|
||||
op.minimum = 0.0
|
||||
op.use_vgroup = False
|
||||
op.strata = 2.25
|
||||
op.strata_type = '2'
|
||||
op.water_plane = False
|
||||
op.water_level = -0.07999999821186066
|
||||
op.use_mat = False
|
||||
op.sel_land_mat = ''
|
||||
op.sel_water_mat = ''
|
||||
op.remove_double = False
|
||||
op.show_main_settings = True
|
||||
op.show_noise_settings = True
|
||||
op.show_terrain_settings = True
|
||||
op.show_displace_settings = True
|
||||
op.refresh = True
|
||||
op.auto_refresh = True
|
||||
op.texture_name = ''
|
||||
|
|
|
|||
|
|
@ -0,0 +1,59 @@
|
|||
import bpy
|
||||
op = bpy.context.active_operator
|
||||
|
||||
op.ant_terrain_name = 'Landscape'
|
||||
op.land_material = ''
|
||||
op.water_material = ''
|
||||
op.texture_block = ''
|
||||
op.at_cursor = True
|
||||
op.smooth_mesh = True
|
||||
op.tri_face = False
|
||||
op.sphere_mesh = False
|
||||
op.subdivision_x = 128
|
||||
op.subdivision_y = 128
|
||||
op.mesh_size = 2.0
|
||||
op.mesh_size_x = 2.0
|
||||
op.mesh_size_y = 2.0
|
||||
op.random_seed = 75
|
||||
op.noise_offset_x = 0.0
|
||||
op.noise_offset_y = 0.0
|
||||
op.noise_offset_z = 0.0
|
||||
op.noise_size_x = 1.0
|
||||
op.noise_size_y = 1.0
|
||||
op.noise_size_z = 1.0
|
||||
op.noise_size = 1.0
|
||||
op.noise_type = 'slick_rock'
|
||||
op.basis_type = '0'
|
||||
op.vl_basis_type = '7'
|
||||
op.distortion = 1.0
|
||||
op.hard_noise = '0'
|
||||
op.noise_depth = 8
|
||||
op.amplitude = 0.5
|
||||
op.frequency = 2.0
|
||||
op.dimension = 1.0
|
||||
op.lacunarity = 2.0
|
||||
op.offset = 1.100000023841858
|
||||
op.gain = 2.5
|
||||
op.marble_bias = '0'
|
||||
op.marble_sharp = '0'
|
||||
op.marble_shape = '0'
|
||||
op.height = 0.5
|
||||
op.height_invert = False
|
||||
op.height_offset = 0.10000000149011612
|
||||
op.edge_falloff = '3'
|
||||
op.falloff_x = 4.0
|
||||
op.falloff_y = 4.0
|
||||
op.edge_level = 0.0
|
||||
op.maximum = 1.0
|
||||
op.minimum = -1.0
|
||||
op.use_vgroup = False
|
||||
op.strata = 5.0
|
||||
op.strata_type = '0'
|
||||
op.water_plane = False
|
||||
op.water_level = 0.009999999776482582
|
||||
op.remove_double = False
|
||||
op.show_main_settings = True
|
||||
op.show_noise_settings = True
|
||||
op.show_displace_settings = True
|
||||
op.refresh = True
|
||||
op.auto_refresh = True
|
||||
|
|
@ -1,21 +1,27 @@
|
|||
import bpy
|
||||
op = bpy.context.active_operator
|
||||
|
||||
op.ant_terrain_name = 'Landscape'
|
||||
op.land_material = ''
|
||||
op.water_material = ''
|
||||
op.texture_block = ''
|
||||
op.at_cursor = True
|
||||
op.smooth_mesh = True
|
||||
op.tri_face = False
|
||||
op.sphere_mesh = False
|
||||
op.subdivision_x = 128
|
||||
op.subdivision_y = 128
|
||||
op.meshsize = 2.0
|
||||
op.meshsize_x = 2.0
|
||||
op.meshsize_y = 2.0
|
||||
op.mesh_size = 2.0
|
||||
op.mesh_size_x = 2.0
|
||||
op.mesh_size_y = 2.0
|
||||
op.random_seed = 11
|
||||
op.x_offset = 0.0
|
||||
op.y_offset = 0.0
|
||||
op.noise_size = 0.8899999260902405
|
||||
op.noise_offset_x = 0.0
|
||||
op.noise_offset_y = 0.0
|
||||
op.noise_offset_z = 0.0
|
||||
op.noise_size_x = 1.0
|
||||
op.noise_size_y = 1.0
|
||||
op.noise_size_z = 1.0
|
||||
op.noise_size = 0.8899999856948853
|
||||
op.noise_type = 'hybrid_multi_fractal'
|
||||
op.basis_type = '1'
|
||||
op.vl_basis_type = '0'
|
||||
|
|
@ -26,29 +32,28 @@ op.amplitude = 0.5
|
|||
op.frequency = 2.0
|
||||
op.dimension = 0.800000011920929
|
||||
op.lacunarity = 2.2100000381469727
|
||||
op.moffset = 0.6499998569488525
|
||||
op.offset = 0.559999942779541
|
||||
op.gain = 3.0
|
||||
op.marble_bias = '0'
|
||||
op.marble_sharp = '0'
|
||||
op.marble_shape = '0'
|
||||
op.height = 0.2199999988079071
|
||||
op.invert = False
|
||||
op.offset = -0.07999999821186066
|
||||
op.height_invert = False
|
||||
op.height_offset = 0.0
|
||||
op.edge_falloff = '3'
|
||||
op.falloff_size_x = 6.0
|
||||
op.falloff_size_y = 6.0
|
||||
op.falloff_x = 4.0
|
||||
op.falloff_y = 4.0
|
||||
op.edge_level = 0.0
|
||||
op.maximum = 1.0
|
||||
op.minimum = -1.0
|
||||
op.use_vgroup = False
|
||||
op.strata = 2.0
|
||||
op.strata_type = '0'
|
||||
op.water_plane = False
|
||||
op.water_level = 0.009999999776482582
|
||||
op.use_mat = False
|
||||
op.sel_land_mat = ''
|
||||
op.sel_water_mat = ''
|
||||
op.remove_double = False
|
||||
op.show_main_settings = True
|
||||
op.show_noise_settings = True
|
||||
op.show_terrain_settings = True
|
||||
op.show_displace_settings = True
|
||||
op.refresh = True
|
||||
op.auto_refresh = True
|
||||
op.texture_name = ''
|
||||
|
|
|
|||
|
|
@ -1,54 +1,59 @@
|
|||
import bpy
|
||||
op = bpy.context.active_operator
|
||||
|
||||
op.ant_terrain_name = 'Landscape'
|
||||
op.land_material = ''
|
||||
op.water_material = ''
|
||||
op.texture_block = ''
|
||||
op.at_cursor = True
|
||||
op.smooth_mesh = True
|
||||
op.tri_face = False
|
||||
op.sphere_mesh = False
|
||||
op.subdivision_x = 128
|
||||
op.subdivision_y = 128
|
||||
op.meshsize = 2.0
|
||||
op.meshsize_x = 2.0
|
||||
op.meshsize_y = 2.0
|
||||
op.random_seed = 23
|
||||
op.x_offset = 0.0
|
||||
op.y_offset = 0.0
|
||||
op.noise_size = 0.5
|
||||
op.mesh_size = 2.0
|
||||
op.mesh_size_x = 2.0
|
||||
op.mesh_size_y = 2.0
|
||||
op.random_seed = 0
|
||||
op.noise_offset_x = 0.0
|
||||
op.noise_offset_y = 0.0
|
||||
op.noise_offset_z = 0.0
|
||||
op.noise_size_x = 1.0
|
||||
op.noise_size_y = 1.0
|
||||
op.noise_size_z = 1.0
|
||||
op.noise_size = 0.5
|
||||
op.noise_type = 'variable_lacunarity'
|
||||
op.basis_type = '9'
|
||||
op.vl_basis_type = '9'
|
||||
op.distortion = 1.5
|
||||
op.distortion = 2.0
|
||||
op.hard_noise = '0'
|
||||
op.noise_depth = 3
|
||||
op.amplitude = 0.5
|
||||
op.frequency = 2.0
|
||||
op.dimension = 1.0
|
||||
op.lacunarity = 2.0
|
||||
op.moffset = 1.0
|
||||
op.offset = 1.0
|
||||
op.gain = 1.0
|
||||
op.marble_bias = '0'
|
||||
op.marble_sharp = '0'
|
||||
op.marble_shape = '0'
|
||||
op.height = 0.25
|
||||
op.invert = False
|
||||
op.offset = 0.0
|
||||
op.height_invert = False
|
||||
op.height_offset = 0.0
|
||||
op.edge_falloff = '0'
|
||||
op.falloff_size_x = 4.0
|
||||
op.falloff_size_y = 4.0
|
||||
op.falloff_x = 4.0
|
||||
op.falloff_y = 4.0
|
||||
op.edge_level = 0.0
|
||||
op.maximum = 1.0
|
||||
op.minimum = -1.0
|
||||
op.use_vgroup = False
|
||||
op.strata = 2.0
|
||||
op.strata_type = '4'
|
||||
op.water_plane = False
|
||||
op.water_level = 0.009999999776482582
|
||||
op.use_mat = False
|
||||
op.sel_land_mat = ''
|
||||
op.sel_water_mat = ''
|
||||
op.remove_double = False
|
||||
op.show_main_settings = True
|
||||
op.show_noise_settings = True
|
||||
op.show_terrain_settings = True
|
||||
op.show_displace_settings = True
|
||||
op.refresh = True
|
||||
op.auto_refresh = True
|
||||
op.texture_name = ''
|
||||
|
|
|
|||
|
|
@ -1,54 +1,59 @@
|
|||
import bpy
|
||||
op = bpy.context.active_operator
|
||||
|
||||
op.ant_terrain_name = 'Landscape'
|
||||
op.land_material = ''
|
||||
op.water_material = ''
|
||||
op.texture_block = ''
|
||||
op.at_cursor = True
|
||||
op.smooth_mesh = True
|
||||
op.tri_face = False
|
||||
op.sphere_mesh = False
|
||||
op.subdivision_x = 256
|
||||
op.subdivision_y = 256
|
||||
op.meshsize = 2.0
|
||||
op.meshsize_x = 20.0
|
||||
op.meshsize_y = 20.0
|
||||
op.mesh_size = 2.0
|
||||
op.mesh_size_x = 20.0
|
||||
op.mesh_size_y = 20.0
|
||||
op.random_seed = 0
|
||||
op.x_offset = 0.0
|
||||
op.y_offset = 0.0
|
||||
op.noise_size = 3.0
|
||||
op.noise_offset_x = 0.0
|
||||
op.noise_offset_y = 0.0
|
||||
op.noise_offset_z = 0.0
|
||||
op.noise_size_x = 1.0
|
||||
op.noise_size_y = 1.0
|
||||
op.noise_size_z = 1.0
|
||||
op.noise_size = 3.0
|
||||
op.noise_type = 'distorted_heteroTerrain'
|
||||
op.basis_type = '0'
|
||||
op.vl_basis_type = '0'
|
||||
op.distortion = 1.0
|
||||
op.distortion = 0.800000011920929
|
||||
op.hard_noise = '0'
|
||||
op.noise_depth = 8
|
||||
op.amplitude = 0.5
|
||||
op.frequency = 2.0
|
||||
op.dimension = 1.119999885559082
|
||||
op.dimension = 1.0
|
||||
op.lacunarity = 2.0
|
||||
op.moffset = 0.8799998760223389
|
||||
op.offset = 1.0
|
||||
op.gain = 1.0
|
||||
op.marble_bias = '0'
|
||||
op.marble_sharp = '0'
|
||||
op.marble_shape = '0'
|
||||
op.height = 1.0
|
||||
op.invert = False
|
||||
op.offset = 0.0
|
||||
op.height_invert = False
|
||||
op.height_offset = 0.0
|
||||
op.edge_falloff = '0'
|
||||
op.falloff_size_x = 6.0
|
||||
op.falloff_size_y = 6.0
|
||||
op.falloff_x = 4.0
|
||||
op.falloff_y = 4.0
|
||||
op.edge_level = 0.0
|
||||
op.maximum = 5.0
|
||||
op.minimum = -0.5
|
||||
op.use_vgroup = False
|
||||
op.strata = 5.0
|
||||
op.strata_type = '0'
|
||||
op.water_plane = False
|
||||
op.water_level = 0.009999999776482582
|
||||
op.use_mat = False
|
||||
op.sel_land_mat = ''
|
||||
op.sel_water_mat = ''
|
||||
op.remove_double = False
|
||||
op.show_main_settings = True
|
||||
op.show_noise_settings = True
|
||||
op.show_terrain_settings = True
|
||||
op.show_displace_settings = True
|
||||
op.refresh = True
|
||||
op.auto_refresh = True
|
||||
op.texture_name = ''
|
||||
|
|
|
|||
|
|
@ -0,0 +1,59 @@
|
|||
import bpy
|
||||
op = bpy.context.active_operator
|
||||
|
||||
op.ant_terrain_name = 'Landscape'
|
||||
op.land_material = ''
|
||||
op.water_material = ''
|
||||
op.texture_block = ''
|
||||
op.at_cursor = True
|
||||
op.smooth_mesh = True
|
||||
op.tri_face = False
|
||||
op.sphere_mesh = False
|
||||
op.subdivision_x = 128
|
||||
op.subdivision_y = 128
|
||||
op.mesh_size = 2.0
|
||||
op.mesh_size_x = 2.0
|
||||
op.mesh_size_y = 2.0
|
||||
op.random_seed = 56
|
||||
op.noise_offset_x = 0.0
|
||||
op.noise_offset_y = 0.0
|
||||
op.noise_offset_z = 0.0
|
||||
op.noise_size_x = 1.0
|
||||
op.noise_size_y = 1.0
|
||||
op.noise_size_z = 1.0
|
||||
op.noise_size = 1.0
|
||||
op.noise_type = 'vl_noise_turbulence'
|
||||
op.basis_type = '2'
|
||||
op.vl_basis_type = '3'
|
||||
op.distortion = 1.5
|
||||
op.hard_noise = '0'
|
||||
op.noise_depth = 3
|
||||
op.amplitude = 0.5
|
||||
op.frequency = 2.0
|
||||
op.dimension = 1.0
|
||||
op.lacunarity = 2.0
|
||||
op.offset = 0.10000000149011612
|
||||
op.gain = 1.0
|
||||
op.marble_bias = '0'
|
||||
op.marble_sharp = '0'
|
||||
op.marble_shape = '0'
|
||||
op.height = 0.20999999344348907
|
||||
op.height_invert = False
|
||||
op.height_offset = 0.11999999731779099
|
||||
op.edge_falloff = '3'
|
||||
op.falloff_x = 4.0
|
||||
op.falloff_y = 4.0
|
||||
op.edge_level = 0.0
|
||||
op.maximum = 1.0
|
||||
op.minimum = 0.0
|
||||
op.use_vgroup = False
|
||||
op.strata = 5.0
|
||||
op.strata_type = '0'
|
||||
op.water_plane = False
|
||||
op.water_level = 0.009999999776482582
|
||||
op.remove_double = False
|
||||
op.show_main_settings = True
|
||||
op.show_noise_settings = True
|
||||
op.show_displace_settings = True
|
||||
op.refresh = True
|
||||
op.auto_refresh = True
|
||||
|
|
@ -1,22 +1,28 @@
|
|||
import bpy
|
||||
op = bpy.context.active_operator
|
||||
|
||||
op.ant_terrain_name = 'Landscape'
|
||||
op.land_material = ''
|
||||
op.water_material = ''
|
||||
op.texture_block = ''
|
||||
op.at_cursor = True
|
||||
op.smooth_mesh = True
|
||||
op.tri_face = False
|
||||
op.sphere_mesh = False
|
||||
op.subdivision_x = 128
|
||||
op.subdivision_y = 128
|
||||
op.meshsize = 2.0
|
||||
op.meshsize_x = 2.0
|
||||
op.meshsize_y = 2.0
|
||||
op.mesh_size = 2.0
|
||||
op.mesh_size_x = 2.0
|
||||
op.mesh_size_y = 2.0
|
||||
op.random_seed = 111
|
||||
op.x_offset = 0.0
|
||||
op.y_offset = 0.0
|
||||
op.noise_size = 0.5
|
||||
op.noise_offset_x = 0.0
|
||||
op.noise_offset_y = 0.0
|
||||
op.noise_offset_z = 0.0
|
||||
op.noise_size_x = 1.0
|
||||
op.noise_size_y = 1.0
|
||||
op.noise_type = 'fractal'
|
||||
op.noise_size_z = 1.0
|
||||
op.noise_size = 0.5
|
||||
op.noise_type = 'multi_fractal'
|
||||
op.basis_type = '3'
|
||||
op.vl_basis_type = '0'
|
||||
op.distortion = 1.0
|
||||
|
|
@ -26,29 +32,28 @@ op.amplitude = 0.5
|
|||
op.frequency = 2.0
|
||||
op.dimension = 1.0
|
||||
op.lacunarity = 2.0
|
||||
op.moffset = 1.0
|
||||
op.offset = 1.0
|
||||
op.gain = 1.0
|
||||
op.marble_bias = '0'
|
||||
op.marble_sharp = '0'
|
||||
op.marble_shape = '0'
|
||||
op.height = 0.10000000149011612
|
||||
op.invert = True
|
||||
op.offset = 0.10000000149011612
|
||||
op.edge_falloff = '3'
|
||||
op.falloff_size_x = 8.0
|
||||
op.falloff_size_y = 8.0
|
||||
op.height = 0.25
|
||||
op.height_invert = True
|
||||
op.height_offset = 0.0
|
||||
op.edge_falloff = '0'
|
||||
op.falloff_x = 4.0
|
||||
op.falloff_y = 4.0
|
||||
op.edge_level = 0.0
|
||||
op.maximum = 1.0
|
||||
op.minimum = -0.10999999940395355
|
||||
op.minimum = 0.0
|
||||
op.use_vgroup = False
|
||||
op.strata = 5.0
|
||||
op.strata_type = '0'
|
||||
op.water_plane = False
|
||||
op.water_level = 0.009999999776482582
|
||||
op.use_mat = False
|
||||
op.sel_land_mat = ''
|
||||
op.sel_water_mat = ''
|
||||
op.remove_double = False
|
||||
op.show_main_settings = True
|
||||
op.show_noise_settings = True
|
||||
op.show_terrain_settings = True
|
||||
op.show_displace_settings = True
|
||||
op.refresh = True
|
||||
op.auto_refresh = True
|
||||
op.texture_name = ''
|
||||
|
|
|
|||
|
|
@ -1,54 +1,59 @@
|
|||
import bpy
|
||||
op = bpy.context.active_operator
|
||||
|
||||
op.ant_terrain_name = 'Landscape'
|
||||
op.land_material = ''
|
||||
op.water_material = ''
|
||||
op.texture_block = ''
|
||||
op.at_cursor = True
|
||||
op.smooth_mesh = True
|
||||
op.tri_face = False
|
||||
op.sphere_mesh = False
|
||||
op.subdivision_x = 128
|
||||
op.subdivision_y = 128
|
||||
op.meshsize = 2.0
|
||||
op.meshsize_x = 2.0
|
||||
op.meshsize_y = 2.0
|
||||
op.mesh_size = 2.0
|
||||
op.mesh_size_x = 2.0
|
||||
op.mesh_size_y = 2.0
|
||||
op.random_seed = 7
|
||||
op.x_offset = 0.0
|
||||
op.y_offset = 0.0
|
||||
op.noise_size = 1.0
|
||||
op.noise_offset_x = 0.0
|
||||
op.noise_offset_y = 0.0
|
||||
op.noise_offset_z = 0.0
|
||||
op.noise_size_x = 1.0
|
||||
op.noise_size_y = 1.0
|
||||
op.noise_size_z = 1.0
|
||||
op.noise_size = 1.0
|
||||
op.noise_type = 'marble_noise'
|
||||
op.basis_type = '0'
|
||||
op.vl_basis_type = '0'
|
||||
op.distortion = 1.5
|
||||
op.hard_noise = '0'
|
||||
op.noise_depth = 9
|
||||
op.noise_depth = 8
|
||||
op.amplitude = 0.5
|
||||
op.frequency = 2.0
|
||||
op.dimension = 1.0
|
||||
op.lacunarity = 2.0
|
||||
op.moffset = 1.0
|
||||
op.offset = 1.0
|
||||
op.gain = 1.0
|
||||
op.marble_bias = '2'
|
||||
op.marble_sharp = '3'
|
||||
op.marble_shape = '1'
|
||||
op.height = 0.800000011920929
|
||||
op.invert = False
|
||||
op.offset = 0.0
|
||||
op.height_invert = False
|
||||
op.height_offset = 0.0
|
||||
op.edge_falloff = '3'
|
||||
op.falloff_size_x = 2.0
|
||||
op.falloff_size_y = 2.0
|
||||
op.falloff_x = 2.0
|
||||
op.falloff_y = 2.0
|
||||
op.edge_level = 0.0
|
||||
op.maximum = 1.0
|
||||
op.minimum = -1.0
|
||||
op.use_vgroup = False
|
||||
op.strata = 5.0
|
||||
op.strata_type = '0'
|
||||
op.water_plane = False
|
||||
op.water_level = 0.009999999776482582
|
||||
op.use_mat = False
|
||||
op.sel_land_mat = ''
|
||||
op.sel_water_mat = ''
|
||||
op.remove_double = False
|
||||
op.show_main_settings = True
|
||||
op.show_noise_settings = True
|
||||
op.show_terrain_settings = True
|
||||
op.show_displace_settings = True
|
||||
op.refresh = True
|
||||
op.auto_refresh = True
|
||||
op.texture_name = ''
|
||||
|
|
|
|||
Loading…
Reference in New Issue