https://posfie.com/@timekagura?sort=0&page=1
# Copied: 2026-03-24 21:03:00
import bpy
import bmesh
import webbrowser
import math
import mathutils
import time
from bpy.props import FloatVectorProperty, FloatProperty, BoolProperty, PointerProperty, StringProperty, EnumProperty, IntProperty
from bpy.types import Operator, Panel, PropertyGroup
from datetime import datetime
# ==============================================================================
# 【 基本設定エリア 】
# ==============================================================================
PREFIX = "ShapeTorus20260324"
ADDON_NAME = "zionad 520[ Shape-Torus ]"
TAB_NAME = "[ Shape Torus copy ] "
PANEL_TITLE = "Multi-Shape Generator"
AUTHOR = "zionadchat"
# ★ このスクリプト自身のID
SOURCE_ID_TAG = "### ZIONAD_SOURCE_ID: SHAPE_TORUS_2026_03_24_V9_MULTI_SHAPE ###"
# ==============================================================================
# システム初期化 & ID管理
# ==============================================================================
bl_info = {
"name": f"{ADDON_NAME} {PREFIX}",
"author": AUTHOR,
"version": (9, 0, 0),
"blender": (3, 0, 0),
"location": "3D View > Sidebar",
"description": f"Multi-Shape Torus Generator (Cube, Square, Circle, Ellipse) - {PREFIX}",
"category": "3D View",
}
OP_PREFIX = PREFIX.lower()
PROPS_NAME = f"{PREFIX}_props"
ADDON_LINKS = (
{"label": "Prefix トーラス正方形 20260324", "url": "<https://www.notion.so/Prefix-20260324-32df5dacaf4380528980db6a989d6306>"},
)
# ==============================================================================
# デフォルト値設定
# ==============================================================================
# <BEGIN_DICT>
CURRENT_DEFAULTS = {
"show_preview": True,
"show_guide": True,
"torus_color": (0.0391, 0.8000, 0.1647, 1.0000),
"torus_loc": (0.0000, 0.0000, 0.0000),
"torus_rot": (0.0000, 0.0000, 0.0000),
"base_shape": "SQUARE",
"torus_plane": "XY",
"size_x": 10.0000,
"size_y": 5.0000,
"corner_radius": 0.0000,
"minor_radius": 0.5000,
"major_segments": 32,
"corner_segments": 8,
"minor_segments": 16,
}
# <END_DICT>
# ==============================================================================
# データ クリーンアップ管理
# ==============================================================================
PREVIEW_COL_NAME = f"{PREFIX}_Preview_Zone"
PREVIEW_OBJ_NAME = f"[Preview] Shape_{PREFIX}"
PREVIEW_GUIDE_NAME = f"[Preview] Guide_{PREFIX}"
PREVIEW_MAT_NAME = f"PreviewMat_{PREFIX}"
def cleanup_preview_data():
for name in[PREVIEW_OBJ_NAME, PREVIEW_GUIDE_NAME]:
obj = bpy.data.objects.get(name)
if obj:
mesh = obj.data
bpy.data.objects.remove(obj, do_unlink=True)
if mesh and mesh.users == 0:
bpy.data.meshes.remove(mesh)
meshes_to_remove =[m for m in bpy.data.meshes if m.name.startswith(f"PreviewMesh_{PREFIX}")]
for m in meshes_to_remove:
if m.users == 0:
bpy.data.meshes.remove(m)
mat = bpy.data.materials.get(PREVIEW_MAT_NAME)
if mat and mat.users == 0:
bpy.data.materials.remove(mat)
col = bpy.data.collections.get(PREVIEW_COL_NAME)
if col and len(col.objects) == 0:
bpy.data.collections.remove(col)
def cleanup_old_materials(prefix="Mat_UniqueShape", limit=50):
mats =[m for m in bpy.data.materials if m.name.startswith(prefix)]
if len(mats) > limit:
for m in mats[:-limit]:
if m.users == 0:
bpy.data.materials.remove(m)
# ==============================================================================
# ガイド生成エンジン
# ==============================================================================
def create_square_guide_bmesh(bm, size):
S = size / 2.0
v1 = bm.verts.new((S, S, 0))
v2 = bm.verts.new((-S, S, 0))
v3 = bm.verts.new((-S, -S, 0))
v4 = bm.verts.new((S, -S, 0))
bm.verts.ensure_lookup_table()
bm.edges.new((v1, v2))
bm.edges.new((v2, v3))
bm.edges.new((v3, v4))
bm.edges.new((v4, v1))
return bm
def create_cube_guide_bmesh(bm, size):
geom = bmesh.ops.create_cube(bm, size=size)
faces =[f for f in bm.faces]
bmesh.ops.delete(bm, geom=faces, context='FACES_ONLY')
return bm
def create_ellipse_guide_bmesh(bm, size_x, size_y, segments=64):
a = size_x / 2.0
b = size_y / 2.0
verts =[]
for i in range(segments):
t = i * 2.0 * math.pi / segments
verts.append(bm.verts.new((a * math.cos(t), b * math.sin(t), 0)))
bm.verts.ensure_lookup_table()
for i in range(segments):
bm.edges.new((verts[i], verts[(i + 1) % segments]))
return bm
# ==============================================================================
# メッシュ生成エンジン
# ==============================================================================
def create_ellipse_torus_bmesh(bm, size_x, size_y, minor_radius, major_segments, minor_segments):
""" 円・楕円のトーラスを生成する（正確な法線計算付き） """
a = size_x / 2.0
b = size_y / 2.0
rings =[]
for i in range(major_segments):
t = i * 2.0 * math.pi / major_segments
x = a * math.cos(t)
y = b * math.sin(t)
p = mathutils.Vector((x, y, 0))
# 楕円の接線の直交ベクトル(外向き法線)を計算
nx = b * math.cos(t)
ny = a * math.sin(t)
n = mathutils.Vector((nx, ny, 0)).normalized()
up = mathutils.Vector((0, 0, 1))
ring =[]
for j in range(minor_segments):
theta = j * 2.0 * math.pi / minor_segments
offset = n * (minor_radius * math.cos(theta)) + up * (minor_radius * math.sin(theta))
ring.append(bm.verts.new(p + offset))
rings.append(ring)
bm.verts.ensure_lookup_table()
edge_loops = []
for ring in rings:
edges =[]
for j in range(minor_segments):
v1 = ring[j]
v2 = ring[(j + 1) % minor_segments]
edges.append(bm.edges.new((v1, v2)))
edge_loops.append(edges)
bm.edges.ensure_lookup_table()
for i in range(major_segments):
next_i = (i + 1) % major_segments
try:
bmesh.ops.bridge_loops(bm, edges=edge_loops[i] + edge_loops[next_i])
except Exception:
pass
bmesh.ops.remove_doubles(bm, verts=bm.verts, dist=1e-5)
for f in bm.faces:
f.smooth = True
if bm.faces:
bmesh.ops.recalc_face_normals(bm, faces=bm.faces)
return bm
def create_square_torus_bmesh(bm, size, corner_radius, minor_radius, corner_segments, minor_segments):
half_size = size / 2.0
actual_corner_radius = min(max(corner_radius, 0.0), half_size)
rings =[]
EPS = 1e-6
if actual_corner_radius < EPS:
L = half_size
corners =[
(mathutils.Vector((L, L, 0)), mathutils.Vector((1, 1, 0)).normalized()),
(mathutils.Vector((-L, L, 0)), mathutils.Vector((-1, 1, 0)).normalized()),
(mathutils.Vector((-L, -L, 0)), mathutils.Vector((-1, -1, 0)).normalized()),
(mathutils.Vector((L, -L, 0)), mathutils.Vector((1, -1, 0)).normalized())
]
scale_xy = 1.0 / math.cos(math.pi / 4)
for p, n in corners:
b = mathutils.Vector((0, 0, 1))
ring =[]
for j in range(minor_segments):
theta = j * 2.0 * math.pi / minor_segments
offset = n * (minor_radius * math.cos(theta) * scale_xy) + b * (minor_radius * math.sin(theta))
ring.append(bm.verts.new(p + offset))
rings.append(ring)
else:
L = half_size - actual_corner_radius
pts = []
for q in range(4):
cx = L if q in[0, 3] else -L
cy = L if q in [0, 1] else -L
for i in range(corner_segments + 1):
angle = q * (math.pi / 2) + i * (math.pi / 2) / corner_segments
x = cx + actual_corner_radius * math.cos(angle)
y = cy + actual_corner_radius * math.sin(angle)
pts.append((mathutils.Vector((x, y, 0)), mathutils.Vector((math.cos(angle), math.sin(angle), 0))))
unique_pts =[]
for p, n in pts:
if not unique_pts or (unique_pts[-1][0] - p).length > EPS:
unique_pts.append((p, n))
if len(unique_pts) > 1 and (unique_pts[-1][0] - unique_pts[0][0]).length < EPS:
unique_pts.pop()
for p, n in unique_pts:
b = mathutils.Vector((0, 0, 1))
ring =[]
for j in range(minor_segments):
theta = j * 2.0 * math.pi / minor_segments
offset = n * (minor_radius * math.cos(theta)) + b * (minor_radius * math.sin(theta))
ring.append(bm.verts.new(p + offset))
rings.append(ring)
bm.verts.ensure_lookup_table()
total_rings = len(rings)
if total_rings < 3: return bm
edge_loops = []
for ring in rings:
edges =[]
for j in range(minor_segments):
v1 = ring[j]
v2 = ring[(j + 1) % minor_segments]
edges.append(bm.edges.new((v1, v2)))
edge_loops.append(edges)
bm.edges.ensure_lookup_table()
for i in range(total_rings):
next_i = (i + 1) % total_rings
try:
bmesh.ops.bridge_loops(bm, edges=edge_loops[i] + edge_loops[next_i])
except Exception:
pass
bmesh.ops.remove_doubles(bm, verts=bm.verts, dist=1e-5)
for f in bm.faces: f.smooth = True
if bm.faces: bmesh.ops.recalc_face_normals(bm, faces=bm.faces)
return bm
def create_cube_framework_bmesh(bm, size, minor_radius, minor_segments):
L = size / 2.0
verts_co =[
mathutils.Vector(( L, L, L)), mathutils.Vector((-L, L, L)),
mathutils.Vector((-L, -L, L)), mathutils.Vector(( L, -L, L)),
mathutils.Vector(( L, L, -L)), mathutils.Vector((-L, L, -L)),
mathutils.Vector((-L, -L, -L)), mathutils.Vector(( L, -L, -L)),
]
edges_idx =[
(0,1), (1,2), (2,3), (3,0),
(4,5), (5,6), (6,7), (7,4),
(0,4), (1,5), (2,6), (3,7)
]
for co in verts_co:
geom = bmesh.ops.create_uvsphere(bm, u_segments=minor_segments, v_segments=max(minor_segments//2, 3), radius=minor_radius)
bmesh.ops.translate(bm, verts=geom['verts'], vec=co)
for idx1, idx2 in edges_idx:
v1 = verts_co[idx1]
v2 = verts_co[idx2]
dist = (v1 - v2).length
center = (v1 + v2) / 2.0
geom = bmesh.ops.create_cone(
bm, cap_ends=False, cap_tris=False, segments=minor_segments,
radius1=minor_radius, radius2=minor_radius, depth=dist
)
axis = (v1 - v2).normalized()
rot = mathutils.Vector((0,0,1)).rotation_difference(axis)
bmesh.ops.transform(bm, matrix=rot.to_matrix().to_4x4(), verts=geom['verts'])
bmesh.ops.translate(bm, verts=geom['verts'], vec=center)
bmesh.ops.remove_doubles(bm, verts=bm.verts, dist=1e-5)
for f in bm.faces: f.smooth = True
if bm.faces: bmesh.ops.recalc_face_normals(bm, faces=bm.faces)
return bm
def apply_auto_smooth(mesh):
if bpy.app.version < (4, 1, 0):
try:
if hasattr(mesh, "use_auto_smooth"):
mesh.use_auto_smooth = True
mesh.auto_smooth_angle = math.radians(30)
except AttributeError:
pass
# ==============================================================================
# マテリアル作成ロジック
# ==============================================================================
def create_unique_material(color, name_prefix="Mat_UniqueShape"):
timestamp = datetime.now().strftime('%M%S%f')[:5]
mat_name = f"{name_prefix}_{timestamp}"
mat = bpy.data.materials.new(name=mat_name)
mat.use_nodes = True
mat.blend_method = 'BLEND'
if mat.use_nodes:
tree = mat.node_tree
tree.nodes.clear()
bsdf = tree.nodes.new("ShaderNodeBsdfPrincipled")
bsdf.location = (0, 0)
out = tree.nodes.new("ShaderNodeOutputMaterial")
out.location = (300, 0)
tree.links.new(bsdf.outputs[0], out.inputs[0])
if "Base Color" in bsdf.inputs:
bsdf.inputs['Base Color'].default_value = color
if "Alpha" in bsdf.inputs:
bsdf.inputs['Alpha'].default_value = color[3]
cleanup_old_materials(name_prefix)
return mat
def get_or_create_preview_material():
mat = bpy.data.materials.get(PREVIEW_MAT_NAME)
if not mat:
mat = bpy.data.materials.new(name=PREVIEW_MAT_NAME)
mat.use_nodes = True
mat.blend_method = 'BLEND'
return mat
def update_preview_material(mat, color):
if mat.use_nodes:
bsdf = None
for node in mat.node_tree.nodes:
if node.type == 'BSDF_PRINCIPLED':
bsdf = node; break
if not bsdf:
mat.node_tree.nodes.clear()
bsdf = mat.node_tree.nodes.new("ShaderNodeBsdfPrincipled")
out = mat.node_tree.nodes.new("ShaderNodeOutputMaterial")
mat.node_tree.links.new(bsdf.outputs[0], out.inputs[0])
if "Base Color" in bsdf.inputs: bsdf.inputs["Base Color"].default_value = color
if "Alpha" in bsdf.inputs: bsdf.inputs["Alpha"].default_value = color[3]
# ==============================================================================
# プレビュー用ロジック
# ==============================================================================
def get_transform_matrix(props):
rot_matrix = mathutils.Matrix.Identity(4)
if props.torus_plane == 'YZ':
rot_matrix = mathutils.Matrix.Rotation(math.radians(90.0), 4, 'Y')
elif props.torus_plane == 'ZX':
rot_matrix = mathutils.Matrix.Rotation(math.radians(-90.0), 4, 'X')
user_rot = mathutils.Euler((
math.radians(props.torus_rot[0]),
math.radians(props.torus_rot[1]),
math.radians(props.torus_rot[2])
), 'XYZ').to_matrix().to_4x4()
loc_matrix = mathutils.Matrix.Translation(mathutils.Vector(props.torus_loc))
return loc_matrix @ user_rot @ rot_matrix
def generate_shape_bmesh(bm, props):
size_x = min(max(props.size_x, 0.01), 10000.0)
size_y = min(max(props.size_y, 0.01), 10000.0)
minor_radius = min(max(props.minor_radius, 0.001), 5000.0)
if props.base_shape == 'CUBE':
create_cube_framework_bmesh(bm, size_x, minor_radius, props.minor_segments)
elif props.base_shape == 'SQUARE':
create_square_torus_bmesh(bm, size_x, props.corner_radius, minor_radius, props.corner_segments, props.minor_segments)
elif props.base_shape == 'CIRCLE':
create_ellipse_torus_bmesh(bm, size_x, size_x, minor_radius, props.major_segments, props.minor_segments)
elif props.base_shape == 'ELLIPSE':
create_ellipse_torus_bmesh(bm, size_x, size_y, minor_radius, props.major_segments, props.minor_segments)
def generate_guide_bmesh(bm_g, props):
if props.base_shape == 'CUBE':
create_cube_guide_bmesh(bm_g, props.size_x)
elif props.base_shape == 'SQUARE':
create_square_guide_bmesh(bm_g, props.size_x)
elif props.base_shape == 'CIRCLE':
create_ellipse_guide_bmesh(bm_g, props.size_x, props.size_x, segments=props.major_segments)
elif props.base_shape == 'ELLIPSE':
create_ellipse_guide_bmesh(bm_g, props.size_x, props.size_y, segments=props.major_segments)
def update_preview_geometry(context):
props = getattr(context.scene, PROPS_NAME, None)
if not props: return
col = bpy.data.collections.get(PREVIEW_COL_NAME)
if not col:
col = bpy.data.collections.new(PREVIEW_COL_NAME)
if col.name not in context.scene.collection.children:
context.scene.collection.children.link(col)
obj = bpy.data.objects.get(PREVIEW_OBJ_NAME)
guide_obj = bpy.data.objects.get(PREVIEW_GUIDE_NAME)
if not props.show_preview:
if obj: bpy.data.objects.remove(obj, do_unlink=True)
if guide_obj: bpy.data.objects.remove(guide_obj, do_unlink=True)
return
final_matrix = get_transform_matrix(props)
scene_mesh_name = f"PreviewMesh_{PREFIX}_{context.scene.name}"
bm = bmesh.new()
try:
generate_shape_bmesh(bm, props)
bmesh.ops.transform(bm, matrix=final_matrix, verts=bm.verts)
mesh = bpy.data.meshes.get(scene_mesh_name)
if not mesh: mesh = bpy.data.meshes.new(scene_mesh_name)
else: mesh.clear_geometry()
bm.to_mesh(mesh)
apply_auto_smooth(mesh)
mesh.update(calc_edges=True)
finally:
bm.free()
if not obj:
obj = bpy.data.objects.new(PREVIEW_OBJ_NAME, mesh)
col.objects.link(obj)
elif obj.data != mesh:
obj.data = mesh
mat = get_or_create_preview_material()
update_preview_material(mat, props.torus_color)
if not obj.data.materials: obj.data.materials.append(mat)
else: obj.data.materials[0] = mat
if props.show_guide:
bm_g = bmesh.new()
try:
generate_guide_bmesh(bm_g, props)
bmesh.ops.transform(bm_g, matrix=final_matrix, verts=bm_g.verts)
guide_mesh_name = scene_mesh_name + "_Guide"
mesh_g = bpy.data.meshes.get(guide_mesh_name)
if not mesh_g: mesh_g = bpy.data.meshes.new(guide_mesh_name)
else: mesh_g.clear_geometry()
bm_g.to_mesh(mesh_g)
mesh_g.update(calc_edges=True)
finally:
bm_g.free()
if not guide_obj:
guide_obj = bpy.data.objects.new(PREVIEW_GUIDE_NAME, mesh_g)
col.objects.link(guide_obj)
elif guide_obj.data != mesh_g:
guide_obj.data = mesh_g
guide_obj.display_type = 'WIRE'
guide_obj.show_in_front = True
else:
if guide_obj: bpy.data.objects.remove(guide_obj, do_unlink=True)
_timer = None
_last_update_time = 0
def delayed_update():
global _timer, _last_update_time
_timer = None
now = time.time()
if now - _last_update_time < 0.05:
if _timer is None: _timer = bpy.app.timers.register(delayed_update, first_interval=0.05)
return None
_last_update_time = now
ctx = bpy.context
if not ctx or not ctx.scene: return None
if ctx.object and ctx.object.mode != 'OBJECT': return None
update_preview_geometry(ctx)
return None
def on_update(self, context):
global _timer
if _timer is None: _timer = bpy.app.timers.register(delayed_update, first_interval=0.05)
# ==============================================================================
# PROPERTIES
# ==============================================================================
class PG_TorusProps(PropertyGroup):
show_preview: BoolProperty(name="Show Preview", default=CURRENT_DEFAULTS['show_preview'], update=on_update)
show_guide: BoolProperty(name="Show Guide", default=CURRENT_DEFAULTS['show_guide'], update=on_update)
torus_color: FloatVectorProperty(name="Color", subtype='COLOR', size=4, min=0, max=1, default=CURRENT_DEFAULTS['torus_color'], update=on_update)
# ★ Shape と Plane の完全分離
base_shape: EnumProperty(
name="Shape",
items=[('CUBE', "Cube (3D)", ""), ('SQUARE', "Square", ""), ('CIRCLE', "Circle", ""), ('ELLIPSE', "Ellipse", "")],
default=CURRENT_DEFAULTS['base_shape'], update=on_update
)
torus_plane: EnumProperty(
name="Plane",
items=[('XY', "XY Plane", ""), ('YZ', "YZ Plane", ""), ('ZX', "ZX Plane", "")],
default=CURRENT_DEFAULTS['torus_plane'], update=on_update
)
torus_loc: FloatVectorProperty(name="Location", size=3, default=CURRENT_DEFAULTS['torus_loc'], update=on_update)
torus_rot: FloatVectorProperty(name="Rotation (Deg)", size=3, default=CURRENT_DEFAULTS['torus_rot'], update=on_update)
size_x: FloatProperty(name="Size", default=CURRENT_DEFAULTS['size_x'], min=0.1, max=10000.0, update=on_update)
size_y: FloatProperty(name="Size Y", default=CURRENT_DEFAULTS['size_y'], min=0.1, max=10000.0, update=on_update)
corner_radius: FloatProperty(name="Corner Radius", default=CURRENT_DEFAULTS['corner_radius'], min=0.0, max=5000.0, update=on_update)
minor_radius: FloatProperty(name="Tube Thickness", default=CURRENT_DEFAULTS['minor_radius'], min=0.01, max=5000.0, update=on_update)
major_segments: IntProperty(name="Resolution", default=CURRENT_DEFAULTS['major_segments'], min=3, soft_max=128, update=on_update)
corner_segments: IntProperty(name="Corner Segs", default=CURRENT_DEFAULTS['corner_segments'], min=1, soft_max=128, update=on_update)
minor_segments: IntProperty(name="Tube Segs", default=CURRENT_DEFAULTS['minor_segments'], min=3, soft_max=128, update=on_update)
# ==============================================================================
# OPERATORS
# ==============================================================================
class OT_CreateTorus(Operator):
bl_idname = f"{OP_PREFIX}.create_torus"
bl_label = "Create Shape Torus"
bl_options = {'REGISTER', 'UNDO'}
def execute(self, context):
props = getattr(context.scene, PROPS_NAME, None)
bm = bmesh.new()
generate_shape_bmesh(bm, props)
final_matrix = get_transform_matrix(props)
bmesh.ops.transform(bm, matrix=final_matrix, verts=bm.verts)
mesh = bpy.data.meshes.new(f"Shape_Mesh")
bm.to_mesh(mesh)
bm.free()
apply_auto_smooth(mesh)
name_dict = {'CUBE': "CubeFrame", 'SQUARE': "SqTorus", 'CIRCLE': "CircTorus", 'ELLIPSE': "ElpsTorus"}
prefix_name = name_dict.get(props.base_shape, "Shape")
obj = bpy.data.objects.new(f"{prefix_name}_{datetime.now().strftime('%H%M%S')}", mesh)
if context.collection: context.collection.objects.link(obj)
else: context.scene.collection.objects.link(obj)
unique_mat = create_unique_material(props.torus_color, "Mat_Unique")
obj.data.materials.append(unique_mat)
bpy.ops.object.select_all(action='DESELECT')
obj.select_set(True)
context.view_layer.objects.active = obj
self.report({'INFO'}, f"Created {prefix_name} Successfully!")
return {'FINISHED'}
class OT_CopyFullScript(Operator):
bl_idname = f"{OP_PREFIX}.copy_script"
bl_label = "Copy Script"
def execute(self, context):
props = getattr(context.scene, PROPS_NAME, None)
target_text = None
for t in bpy.data.texts:
if SOURCE_ID_TAG in t.as_string(): target_text = t; break
if not target_text:
self.report({'WARNING'}, "Source script not found in Text Editor.")
return {'CANCELLED'}
code = target_text.as_string()
c, l, r = props.torus_color, props.torus_loc, props.torus_rot
new_dict = "CURRENT_DEFAULTS = {\n"
new_dict += f' "show_preview": {props.show_preview},\n'
new_dict += f' "show_guide": {props.show_guide},\n'
new_dict += f' "torus_color": ({c[0]:.4f}, {c[1]:.4f}, {c[2]:.4f}, {c[3]:.4f}),\n'
new_dict += f' "torus_loc": ({l[0]:.4f}, {l[1]:.4f}, {l[2]:.4f}),\n'
new_dict += f' "torus_rot": ({r[0]:.4f}, {r[1]:.4f}, {r[2]:.4f}),\n'
new_dict += f' "base_shape": "{props.base_shape}",\n'
new_dict += f' "torus_plane": "{props.torus_plane}",\n'
new_dict += f' "size_x": {props.size_x:.4f},\n'
new_dict += f' "size_y": {props.size_y:.4f},\n'
new_dict += f' "corner_radius": {props.corner_radius:.4f},\n'
new_dict += f' "minor_radius": {props.minor_radius:.4f},\n'
new_dict += f' "major_segments": {props.major_segments},\n'
new_dict += f' "corner_segments": {props.corner_segments},\n'
new_dict += f' "minor_segments": {props.minor_segments},\n'
new_dict += "}\n"
try:
tag_start = "# <BEGIN" + "_DICT>"
tag_end = "# <END" + "_DICT>"
if tag_start not in code or tag_end not in code:
self.report({'ERROR'}, "DICT tags missing! Script might be corrupted.")
return {'CANCELLED'}
pre_code, rest = code.split(tag_start, 1)
_, post_code = rest.split(tag_end, 1)
final_code = pre_code + tag_start + "\n" + new_dict + tag_end + post_code
if SOURCE_ID_TAG not in final_code:
self.report({'ERROR'}, "Critical Error: SOURCE_ID_TAG lost during copy.")
return {'CANCELLED'}
lines = final_code.split("\n")
if len(lines) > 0 and lines[0].startswith("# Copied:"):
lines[0] = f"# Copied: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}"
context.window_manager.clipboard = "\n".join(lines)
self.report({'INFO'}, "Code copied safely!")
except Exception as e:
self.report({'ERROR'}, f"Copy failed: {e}")
return {'CANCELLED'}
return {'FINISHED'}
class OT_Reset(Operator):
bl_idname = f"{OP_PREFIX}.reset"
bl_label = "Reset Transform"
def execute(self, context):
p = getattr(context.scene, PROPS_NAME)
p.torus_loc = (0,0,0); p.torus_rot = (0,0,0)
p.torus_plane = 'XY'; p.base_shape = 'SQUARE'
p.size_x = 10.0; p.size_y = 5.0
p.corner_radius = 0.0; p.minor_radius = 0.5
return {'FINISHED'}
class OT_OpenUrl(Operator):
bl_idname = f"{OP_PREFIX}.open_url"; bl_label = "Open URL"; url: StringProperty()
def execute(self, context): webbrowser.open(self.url); return {'FINISHED'}
class OT_RemoveAddon(Operator):
bl_idname = f"{OP_PREFIX}.remove_addon"; bl_label = "Remove Addon"
def execute(self, context):
bpy.app.timers.register(lambda: unregister(), first_interval=0.1)
return {'FINISHED'}
# ==============================================================================
# PANELS
# ==============================================================================
class PT_MainPanel(Panel):
bl_label = PANEL_TITLE
bl_idname = f"{PREFIX}_PT_main"
bl_space_type = 'VIEW_3D'; bl_region_type = 'UI'; bl_category = TAB_NAME
def draw(self, context):
layout = self.layout
props = getattr(context.scene, PROPS_NAME, None)
if not props: layout.label(text="Reload Script"); return
row = layout.row()
row.scale_y = 1.2
row.operator(OT_CopyFullScript.bl_idname, icon='COPY_ID', text="Copy Code with Values")
layout.separator()
layout.prop(props, "show_preview", icon='RESTRICT_VIEW_OFF' if props.show_preview else 'RESTRICT_VIEW_ON')
box = layout.box()
if not props.show_preview: box.label(text="Preview is Hidden", icon='INFO')
box.prop(props, "torus_color")
# ★ Shape と Plane の独立選択UI
col = box.column(align=True)
col.prop(props, "base_shape")
col.prop(props, "torus_plane")
col.separator()
col.prop(props, "torus_loc")
col.prop(props, "torus_rot")
box.separator()
box.prop(props, "show_guide", icon='MESH_GRID', text="Show Guide Wire")
# ★ 形状に応じたスマートなサイズ・UI切り替え
col_s = box.column(align=True)
if props.base_shape == 'ELLIPSE':
col_s.prop(props, "size_x", text="Size X")
col_s.prop(props, "size_y", text="Size Y")
else:
col_s.prop(props, "size_x", text="Size")
row_cr = col_s.row()
row_cr.enabled = (props.base_shape == 'SQUARE')
row_cr.prop(props, "corner_radius")
if props.corner_radius <= 0.001 and props.base_shape == 'SQUARE':
row_cr.label(text="[90° Mode]", icon='SNAP_VERTEX')
col_s.prop(props, "minor_radius")
row_seg = box.row()
if props.base_shape in['CIRCLE', 'ELLIPSE']:
row_seg.prop(props, "major_segments", text="Resolution")
elif props.base_shape == 'SQUARE':
row_seg.prop(props, "corner_segments", text="Corner Segs")
else:
row_seg.label(text="[Cube has fixed corners]")
row_s2 = box.row()
row_s2.prop(props, "minor_segments")
box.operator(OT_Reset.bl_idname, icon='LOOP_BACK')
layout.separator()
col_exec = layout.column()
col_exec.scale_y = 1.5
icons = {'CUBE': 'MESH_CUBE', 'SQUARE': 'MESH_PLANE', 'CIRCLE': 'MESH_CIRCLE', 'ELLIPSE': 'MESH_CIRCLE'}
texts = {'CUBE': "Create Cube Frame", 'SQUARE': "Create Square Torus", 'CIRCLE': "Create Circle Torus", 'ELLIPSE': "Create Ellipse Torus"}
col_exec.operator(OT_CreateTorus.bl_idname, icon=icons.get(props.base_shape, 'MESH_TORUS'), text=texts.get(props.base_shape, "Create Torus"))
class PT_LinksPanel(Panel):
bl_label = "Links"; bl_idname = f"{PREFIX}_PT_links"; bl_space_type = 'VIEW_3D'; bl_region_type = 'UI'; bl_category = TAB_NAME; bl_options = {'DEFAULT_CLOSED'}
def draw(self, context):
for l in ADDON_LINKS: self.layout.operator(OT_OpenUrl.bl_idname, text=l["label"]).url = l["url"]
class PT_RemovePanel(Panel):
bl_label = "System"; bl_idname = f"{PREFIX}_PT_remove"; bl_space_type = 'VIEW_3D'; bl_region_type = 'UI'; bl_category = TAB_NAME; bl_options = {'DEFAULT_CLOSED'}
def draw(self, context): self.layout.operator(OT_RemoveAddon.bl_idname, icon='CANCEL', text="Remove Addon")
# ==============================================================================
# REGISTER
# ==============================================================================
classes = (PG_TorusProps, OT_CreateTorus, OT_CopyFullScript, OT_Reset, OT_OpenUrl, OT_RemoveAddon, PT_MainPanel, PT_LinksPanel, PT_RemovePanel)
def auto_open_sidebar():
try:
for window in bpy.context.window_manager.windows:
for area in window.screen.areas:
if area.type == 'VIEW_3D':
for space in area.spaces:
if space.type == 'VIEW_3D':
if not space.show_region_ui: space.show_region_ui = True
except: pass
return None
def register():
for c in classes:
try: bpy.utils.register_class(c)
except ValueError: pass
setattr(bpy.types.Scene, PROPS_NAME, PointerProperty(type=PG_TorusProps))
bpy.app.timers.register(auto_open_sidebar, first_interval=0.1)
def unregister():
global _timer
if _timer is not None:
try: bpy.app.timers.unregister(_timer)
except Exception: pass
_timer = None
cleanup_preview_data()
if hasattr(bpy.types.Scene, PROPS_NAME): delattr(bpy.types.Scene, PROPS_NAME)
for c in reversed(classes):
try: bpy.utils.unregister_class(c)
except ValueError: pass
if __name__ == "__main__":
register()