refactor
This commit is contained in:
70
operators/__init__.py
Normal file
70
operators/__init__.py
Normal file
@@ -0,0 +1,70 @@
|
||||
"""
|
||||
Text Texture Generator - Operators Module
|
||||
Contains all Blender operators for text texture generation and management.
|
||||
"""
|
||||
|
||||
from .generation_ops import *
|
||||
from .preset_ops import *
|
||||
from .utility_ops import *
|
||||
|
||||
__all__ = []
|
||||
|
||||
# Import all operator classes and add to __all__
|
||||
from .generation_ops import (
|
||||
TEXT_TEXTURE_OT_generate,
|
||||
TEXT_TEXTURE_OT_generate_shader,
|
||||
)
|
||||
|
||||
from .preset_ops import (
|
||||
TEXT_TEXTURE_OT_save_preset,
|
||||
TEXT_TEXTURE_OT_save_preset_enter,
|
||||
TEXT_TEXTURE_OT_load_preset,
|
||||
TEXT_TEXTURE_OT_delete_preset,
|
||||
TEXT_TEXTURE_OT_refresh_presets,
|
||||
TEXT_TEXTURE_OT_export_presets,
|
||||
TEXT_TEXTURE_OT_import_presets,
|
||||
TEXT_TEXTURE_OT_show_migration_report,
|
||||
)
|
||||
|
||||
from .utility_ops import (
|
||||
TEXT_TEXTURE_OT_refresh_preview,
|
||||
TEXT_TEXTURE_OT_view_preview_zoom,
|
||||
TEXT_TEXTURE_OT_open_panel,
|
||||
TEXT_TEXTURE_OT_refresh_fonts,
|
||||
TEXT_TEXTURE_OT_add_overlay,
|
||||
TEXT_TEXTURE_OT_remove_overlay,
|
||||
TEXT_TEXTURE_OT_set_anchor_point,
|
||||
TEXT_TEXTURE_OT_sync_margins,
|
||||
TEXT_TEXTURE_OT_duplicate_overlay,
|
||||
TEXT_TEXTURE_OT_delete_overlay,
|
||||
TEXT_TEXTURE_OT_move_overlay,
|
||||
)
|
||||
|
||||
__all__.extend([
|
||||
# Generation operators
|
||||
'TEXT_TEXTURE_OT_generate',
|
||||
'TEXT_TEXTURE_OT_generate_shader',
|
||||
|
||||
# Preset operators
|
||||
'TEXT_TEXTURE_OT_save_preset',
|
||||
'TEXT_TEXTURE_OT_save_preset_enter',
|
||||
'TEXT_TEXTURE_OT_load_preset',
|
||||
'TEXT_TEXTURE_OT_delete_preset',
|
||||
'TEXT_TEXTURE_OT_refresh_presets',
|
||||
'TEXT_TEXTURE_OT_export_presets',
|
||||
'TEXT_TEXTURE_OT_import_presets',
|
||||
'TEXT_TEXTURE_OT_show_migration_report',
|
||||
|
||||
# Utility operators
|
||||
'TEXT_TEXTURE_OT_refresh_preview',
|
||||
'TEXT_TEXTURE_OT_view_preview_zoom',
|
||||
'TEXT_TEXTURE_OT_open_panel',
|
||||
'TEXT_TEXTURE_OT_refresh_fonts',
|
||||
'TEXT_TEXTURE_OT_add_overlay',
|
||||
'TEXT_TEXTURE_OT_remove_overlay',
|
||||
'TEXT_TEXTURE_OT_set_anchor_point',
|
||||
'TEXT_TEXTURE_OT_sync_margins',
|
||||
'TEXT_TEXTURE_OT_duplicate_overlay',
|
||||
'TEXT_TEXTURE_OT_delete_overlay',
|
||||
'TEXT_TEXTURE_OT_move_overlay',
|
||||
])
|
||||
BIN
operators/__pycache__/__init__.cpython-311.pyc
Normal file
BIN
operators/__pycache__/__init__.cpython-311.pyc
Normal file
Binary file not shown.
595
operators/generation_ops.py
Normal file
595
operators/generation_ops.py
Normal file
@@ -0,0 +1,595 @@
|
||||
"""
|
||||
Generation operators for text texture creation.
|
||||
Contains operators for generating textures and complete shaders.
|
||||
"""
|
||||
|
||||
import bpy
|
||||
from bpy.types import Operator
|
||||
import os
|
||||
import json
|
||||
|
||||
# Import required functions from other modules
|
||||
from ..core.generation_engine import generate_texture_image, generate_preview
|
||||
|
||||
|
||||
class TEXT_TEXTURE_OT_generate(Operator):
|
||||
"""Generate final texture and pack it"""
|
||||
bl_idname = "text_texture.generate"
|
||||
bl_label = "Generate Text Texture"
|
||||
bl_description = "Generate final high-quality texture and pack it into the blend file"
|
||||
bl_options = {'REGISTER', 'UNDO'}
|
||||
|
||||
def execute(self, context):
|
||||
try:
|
||||
props = context.scene.text_texture_props
|
||||
|
||||
# IMPORTANT: Generate at EXACT user-specified dimensions
|
||||
final_width = props.texture_width
|
||||
final_height = props.texture_height
|
||||
|
||||
print(f"Generating texture at {final_width}x{final_height}px")
|
||||
|
||||
# Generate at FULL resolution specified by user
|
||||
result = generate_texture_image(props, final_width, final_height)
|
||||
if not result:
|
||||
self.report({'ERROR'}, "Failed to generate texture image")
|
||||
return {'CANCELLED'}
|
||||
|
||||
# Extract diffuse and normal map images
|
||||
if isinstance(result, tuple):
|
||||
img, normal_map_img = result
|
||||
else:
|
||||
# Backward compatibility
|
||||
img = result
|
||||
normal_map_img = None
|
||||
|
||||
if not img:
|
||||
self.report({'ERROR'}, "Failed to generate diffuse image")
|
||||
return {'CANCELLED'}
|
||||
|
||||
# Create diffuse texture
|
||||
img_name = f"TextTexture_{props.text[:20].replace(' ', '_')}"
|
||||
|
||||
# Remove existing diffuse texture
|
||||
if img_name in bpy.data.images:
|
||||
bpy.data.images.remove(bpy.data.images[img_name])
|
||||
|
||||
# Create new diffuse image with USER SPECIFIED dimensions
|
||||
blender_img = bpy.data.images.new(img_name, final_width, final_height, alpha=True)
|
||||
|
||||
# Convert PIL to Blender for diffuse texture
|
||||
pixels = []
|
||||
for y in range(final_height):
|
||||
for x in range(final_width):
|
||||
r, g, b, a = img.getpixel((x, final_height - 1 - y))
|
||||
pixels.extend([r/255.0, g/255.0, b/255.0, a/255.0])
|
||||
|
||||
blender_img.pixels = pixels
|
||||
blender_img.pack() # PACK FINAL IMAGE
|
||||
|
||||
# Create normal map texture if enabled and generated
|
||||
normal_map_blender_img = None
|
||||
if normal_map_img and props.generate_normal_map:
|
||||
normal_map_name = f"TextTexture_Normal_{props.text[:20].replace(' ', '_')}"
|
||||
|
||||
# Remove existing normal map texture
|
||||
if normal_map_name in bpy.data.images:
|
||||
bpy.data.images.remove(bpy.data.images[normal_map_name])
|
||||
|
||||
# Create new normal map image
|
||||
normal_map_blender_img = bpy.data.images.new(normal_map_name, final_width, final_height, alpha=False)
|
||||
normal_map_blender_img.colorspace_settings.name = 'Non-Color' # Important for normal maps
|
||||
|
||||
# Convert PIL to Blender for normal map
|
||||
normal_pixels = []
|
||||
for y in range(final_height):
|
||||
for x in range(final_width):
|
||||
r, g, b = normal_map_img.getpixel((x, final_height - 1 - y))
|
||||
normal_pixels.extend([r/255.0, g/255.0, b/255.0, 1.0]) # Alpha always 1.0 for normal maps
|
||||
|
||||
normal_map_blender_img.pixels = normal_pixels
|
||||
normal_map_blender_img.pack() # PACK NORMAL MAP
|
||||
print(f"[Normal Map] Created and packed normal map texture: {normal_map_name}")
|
||||
|
||||
# Add to shader
|
||||
if context.space_data and context.space_data.type == 'NODE_EDITOR':
|
||||
if context.space_data.tree_type == 'ShaderNodeTree':
|
||||
material = context.space_data.id
|
||||
if material and material.use_nodes:
|
||||
nodes = material.node_tree.nodes
|
||||
|
||||
# Add diffuse texture node
|
||||
img_node = nodes.new(type='ShaderNodeTexImage')
|
||||
img_node.image = blender_img
|
||||
img_node.location = (0, 0)
|
||||
img_node.select = True
|
||||
nodes.active = img_node
|
||||
|
||||
# Add normal map node if normal map was created
|
||||
if normal_map_blender_img:
|
||||
normal_node = nodes.new(type='ShaderNodeTexImage')
|
||||
normal_node.image = normal_map_blender_img
|
||||
normal_node.location = (0, -300)
|
||||
normal_node.label = "Normal Map"
|
||||
print(f"[Normal Map] Added normal map node to shader editor")
|
||||
|
||||
# Provide comprehensive feedback
|
||||
if normal_map_blender_img:
|
||||
self.report({'INFO'}, f"Generated and packed: {img_name} + {normal_map_blender_img.name} ({final_width}x{final_height}px)")
|
||||
else:
|
||||
self.report({'INFO'}, f"Generated and packed: {img_name} ({final_width}x{final_height}px)")
|
||||
return {'FINISHED'}
|
||||
|
||||
except Exception as e:
|
||||
self.report({'ERROR'}, f"Failed: {str(e)}")
|
||||
return {'CANCELLED'}
|
||||
|
||||
|
||||
class TEXT_TEXTURE_OT_generate_shader(Operator):
|
||||
"""Generate complete shader with text texture"""
|
||||
bl_idname = "text_texture.generate_shader"
|
||||
bl_label = "Generate Shader"
|
||||
bl_description = "Generate a complete material shader with the text texture"
|
||||
bl_options = {'REGISTER', 'UNDO'}
|
||||
|
||||
def execute(self, context):
|
||||
try:
|
||||
props = context.scene.text_texture_props
|
||||
|
||||
# Generate texture first
|
||||
final_width = props.texture_width
|
||||
final_height = props.texture_height
|
||||
|
||||
print(f"Generating shader with texture at {final_width}x{final_height}px")
|
||||
|
||||
result = generate_texture_image(props, final_width, final_height)
|
||||
if not result:
|
||||
self.report({'ERROR'}, "Failed to generate texture image")
|
||||
return {'CANCELLED'}
|
||||
|
||||
# Extract diffuse and normal map images
|
||||
if isinstance(result, tuple):
|
||||
img, normal_map_img = result
|
||||
else:
|
||||
# Backward compatibility
|
||||
img = result
|
||||
normal_map_img = None
|
||||
|
||||
if not img:
|
||||
self.report({'ERROR'}, "Failed to generate diffuse image")
|
||||
return {'CANCELLED'}
|
||||
|
||||
# Create diffuse texture name
|
||||
img_name = f"TextTexture_{props.text[:20].replace(' ', '_')}"
|
||||
|
||||
# Remove existing diffuse texture if it exists
|
||||
if img_name in bpy.data.images:
|
||||
bpy.data.images.remove(bpy.data.images[img_name])
|
||||
|
||||
# Create new diffuse texture
|
||||
blender_img = bpy.data.images.new(img_name, final_width, final_height, alpha=True)
|
||||
|
||||
# Convert PIL to Blender for diffuse texture
|
||||
pixels = []
|
||||
for y in range(final_height):
|
||||
for x in range(final_width):
|
||||
r, g, b, a = img.getpixel((x, final_height - 1 - y))
|
||||
pixels.extend([r/255.0, g/255.0, b/255.0, a/255.0])
|
||||
|
||||
blender_img.pixels = pixels
|
||||
blender_img.pack()
|
||||
|
||||
# Create normal map texture if enabled and generated
|
||||
normal_map_blender_img = None
|
||||
if normal_map_img and props.generate_normal_map:
|
||||
normal_map_name = f"TextTexture_Normal_{props.text[:20].replace(' ', '_')}"
|
||||
|
||||
# Remove existing normal map texture
|
||||
if normal_map_name in bpy.data.images:
|
||||
bpy.data.images.remove(bpy.data.images[normal_map_name])
|
||||
|
||||
# Create new normal map image
|
||||
normal_map_blender_img = bpy.data.images.new(normal_map_name, final_width, final_height, alpha=False)
|
||||
normal_map_blender_img.colorspace_settings.name = 'Non-Color' # Important for normal maps
|
||||
|
||||
# Convert PIL to Blender for normal map
|
||||
normal_pixels = []
|
||||
for y in range(final_height):
|
||||
for x in range(final_width):
|
||||
r, g, b = normal_map_img.getpixel((x, final_height - 1 - y))
|
||||
normal_pixels.extend([r/255.0, g/255.0, b/255.0, 1.0]) # Alpha always 1.0 for normal maps
|
||||
|
||||
normal_map_blender_img.pixels = normal_pixels
|
||||
normal_map_blender_img.pack()
|
||||
print(f"[Normal Map] Created normal map texture for shader: {normal_map_name}")
|
||||
|
||||
# Create or get material using custom name or fallback
|
||||
if props.custom_material_name.strip():
|
||||
material_name = props.custom_material_name.strip()
|
||||
else:
|
||||
# Fallback to text-based naming
|
||||
clean_text = props.text[:15].replace(' ', '_').replace('\n', '_')
|
||||
material_name = f"TextTexture_Mat_{clean_text}"
|
||||
|
||||
if material_name in bpy.data.materials:
|
||||
mat = bpy.data.materials[material_name]
|
||||
# Clear existing nodes
|
||||
mat.node_tree.nodes.clear()
|
||||
else:
|
||||
mat = bpy.data.materials.new(name=material_name)
|
||||
mat.use_nodes = True
|
||||
mat.node_tree.nodes.clear()
|
||||
|
||||
# Set up shader nodes
|
||||
nodes = mat.node_tree.nodes
|
||||
links = mat.node_tree.links
|
||||
|
||||
# Create nodes
|
||||
output_node = nodes.new(type='ShaderNodeOutputMaterial')
|
||||
output_node.location = (400, 0)
|
||||
|
||||
# Shader type based on settings
|
||||
if props.shader_type == 'PRINCIPLED':
|
||||
shader_node = nodes.new(type='ShaderNodeBsdfPrincipled')
|
||||
shader_node.location = (200, 0)
|
||||
|
||||
# Create diffuse texture node
|
||||
tex_node = nodes.new(type='ShaderNodeTexImage')
|
||||
tex_node.image = blender_img
|
||||
tex_node.location = (-200, 0)
|
||||
|
||||
# Connect texture to shader
|
||||
if props.shader_connection == 'BASE_COLOR':
|
||||
links.new(tex_node.outputs['Color'], shader_node.inputs['Base Color'])
|
||||
elif props.shader_connection == 'EMISSION':
|
||||
links.new(tex_node.outputs['Color'], shader_node.inputs['Emission Color'])
|
||||
shader_node.inputs['Emission Strength'].default_value = props.emission_strength
|
||||
elif props.shader_connection == 'ALPHA':
|
||||
links.new(tex_node.outputs['Alpha'], shader_node.inputs['Alpha'])
|
||||
# Also connect color for visibility
|
||||
links.new(tex_node.outputs['Color'], shader_node.inputs['Base Color'])
|
||||
mat.blend_method = 'BLEND'
|
||||
|
||||
# Connect alpha if enabled
|
||||
if props.use_alpha:
|
||||
links.new(tex_node.outputs['Alpha'], shader_node.inputs['Alpha'])
|
||||
mat.blend_method = 'BLEND'
|
||||
|
||||
# Add normal map nodes if normal map was generated
|
||||
if normal_map_blender_img:
|
||||
# Create normal map texture node
|
||||
normal_tex_node = nodes.new(type='ShaderNodeTexImage')
|
||||
normal_tex_node.image = normal_map_blender_img
|
||||
normal_tex_node.location = (-200, -300)
|
||||
normal_tex_node.label = "Normal Map"
|
||||
|
||||
# Create normal map node
|
||||
normal_map_node = nodes.new(type='ShaderNodeNormalMap')
|
||||
normal_map_node.location = (0, -300)
|
||||
|
||||
# Connect normal map texture to normal map node
|
||||
links.new(normal_tex_node.outputs['Color'], normal_map_node.inputs['Color'])
|
||||
|
||||
# Connect normal map node to shader
|
||||
links.new(normal_map_node.outputs['Normal'], shader_node.inputs['Normal'])
|
||||
|
||||
print(f"[Normal Map] Added normal map nodes to Principled BSDF shader")
|
||||
|
||||
# Handle shadow/reflection disabling
|
||||
current_shader = shader_node
|
||||
final_x_location = 400
|
||||
|
||||
# Disable shadows if enabled
|
||||
if props.disable_shadows:
|
||||
# Create light path node
|
||||
light_path_node = nodes.new(type='ShaderNodeLightPath')
|
||||
light_path_node.location = (50, 150)
|
||||
|
||||
# Create transparent BSDF
|
||||
transparent_node = nodes.new(type='ShaderNodeBsdfTransparent')
|
||||
transparent_node.location = (200, 150)
|
||||
|
||||
# Create mix shader for shadows
|
||||
shadow_mix_node = nodes.new(type='ShaderNodeMixShader')
|
||||
shadow_mix_node.location = (350, 50)
|
||||
|
||||
# Connect light path "Is Shadow Ray" to mix factor
|
||||
links.new(light_path_node.outputs['Is Shadow Ray'], shadow_mix_node.inputs['Fac'])
|
||||
|
||||
# Mix principled BSDF with transparent BSDF
|
||||
links.new(current_shader.outputs['BSDF'], shadow_mix_node.inputs[1]) # Shader 1 (not shadow)
|
||||
links.new(transparent_node.outputs['BSDF'], shadow_mix_node.inputs[2]) # Shader 2 (shadow)
|
||||
|
||||
current_shader = shadow_mix_node
|
||||
final_x_location = 500
|
||||
|
||||
# Disable reflections if enabled
|
||||
if props.disable_reflections:
|
||||
# Create or reuse light path node
|
||||
if not props.disable_shadows:
|
||||
light_path_node = nodes.new(type='ShaderNodeLightPath')
|
||||
light_path_node.location = (50, 200)
|
||||
|
||||
# Create transparent BSDF for reflections
|
||||
reflection_transparent_node = nodes.new(type='ShaderNodeBsdfTransparent')
|
||||
reflection_transparent_node.location = (200, 200)
|
||||
|
||||
# Create mix shader for reflections
|
||||
reflection_mix_node = nodes.new(type='ShaderNodeMixShader')
|
||||
reflection_mix_node.location = (final_x_location - 50, 100)
|
||||
|
||||
# Connect light path "Is Reflection Ray" to mix factor
|
||||
links.new(light_path_node.outputs['Is Reflection Ray'], reflection_mix_node.inputs['Fac'])
|
||||
|
||||
# Mix current shader with transparent BSDF
|
||||
links.new(current_shader.outputs['Shader' if props.disable_shadows else 'BSDF'], reflection_mix_node.inputs[1]) # Shader 1 (not reflection)
|
||||
links.new(reflection_transparent_node.outputs['BSDF'], reflection_mix_node.inputs[2]) # Shader 2 (reflection)
|
||||
|
||||
current_shader = reflection_mix_node
|
||||
final_x_location = final_x_location + 50
|
||||
|
||||
# Disable backfacing if enabled
|
||||
if props.disable_backfacing:
|
||||
# Create or reuse light path node
|
||||
if not props.disable_shadows and not props.disable_reflections:
|
||||
light_path_node = nodes.new(type='ShaderNodeLightPath')
|
||||
light_path_node.location = (50, 250)
|
||||
|
||||
# Create geometry node for backfacing detection
|
||||
geometry_node = nodes.new(type='ShaderNodeNewGeometry')
|
||||
geometry_node.location = (50, 300)
|
||||
|
||||
# Create transparent BSDF for backfaces
|
||||
backface_transparent_node = nodes.new(type='ShaderNodeBsdfTransparent')
|
||||
backface_transparent_node.location = (200, 250)
|
||||
|
||||
# Create mix shader for backfaces
|
||||
backface_mix_node = nodes.new(type='ShaderNodeMixShader')
|
||||
backface_mix_node.location = (final_x_location - 50, 150)
|
||||
|
||||
# Connect geometry "Backfacing" to mix factor
|
||||
links.new(geometry_node.outputs['Backfacing'], backface_mix_node.inputs['Fac'])
|
||||
|
||||
# Mix current shader with transparent BSDF
|
||||
current_output = 'Shader' if (props.disable_shadows or props.disable_reflections) else 'BSDF'
|
||||
links.new(current_shader.outputs[current_output], backface_mix_node.inputs[1]) # Shader 1 (front face)
|
||||
links.new(backface_transparent_node.outputs['BSDF'], backface_mix_node.inputs[2]) # Shader 2 (backface)
|
||||
|
||||
current_shader = backface_mix_node
|
||||
final_x_location = final_x_location + 50
|
||||
|
||||
# Update output node position
|
||||
output_node.location = (final_x_location, 0)
|
||||
|
||||
# Connect final shader to output
|
||||
output_socket = 'Shader' if (props.disable_shadows or props.disable_reflections) else 'BSDF'
|
||||
links.new(current_shader.outputs[output_socket], output_node.inputs['Surface'])
|
||||
|
||||
elif props.shader_type == 'EMISSION':
|
||||
shader_node = nodes.new(type='ShaderNodeEmission')
|
||||
shader_node.location = (200, 0)
|
||||
|
||||
# Create texture node
|
||||
tex_node = nodes.new(type='ShaderNodeTexImage')
|
||||
tex_node.image = blender_img
|
||||
tex_node.location = (-200, 0)
|
||||
|
||||
# Connect texture to emission
|
||||
links.new(tex_node.outputs['Color'], shader_node.inputs['Color'])
|
||||
shader_node.inputs['Strength'].default_value = props.emission_strength
|
||||
|
||||
# Handle shadow/reflection disabling
|
||||
current_shader = shader_node
|
||||
final_x_location = 400
|
||||
|
||||
# Disable shadows if enabled
|
||||
if props.disable_shadows:
|
||||
# Create light path node
|
||||
light_path_node = nodes.new(type='ShaderNodeLightPath')
|
||||
light_path_node.location = (50, 150)
|
||||
|
||||
# Create transparent BSDF
|
||||
transparent_node = nodes.new(type='ShaderNodeBsdfTransparent')
|
||||
transparent_node.location = (200, 150)
|
||||
|
||||
# Create mix shader for shadows
|
||||
shadow_mix_node = nodes.new(type='ShaderNodeMixShader')
|
||||
shadow_mix_node.location = (350, 50)
|
||||
|
||||
# Connect light path "Is Shadow Ray" to mix factor
|
||||
links.new(light_path_node.outputs['Is Shadow Ray'], shadow_mix_node.inputs['Fac'])
|
||||
|
||||
# Mix emission with transparent BSDF
|
||||
links.new(current_shader.outputs['Emission'], shadow_mix_node.inputs[1]) # Shader 1 (not shadow)
|
||||
links.new(transparent_node.outputs['BSDF'], shadow_mix_node.inputs[2]) # Shader 2 (shadow)
|
||||
|
||||
current_shader = shadow_mix_node
|
||||
final_x_location = 500
|
||||
|
||||
# Disable reflections if enabled
|
||||
if props.disable_reflections:
|
||||
# Create or reuse light path node
|
||||
if not props.disable_shadows:
|
||||
light_path_node = nodes.new(type='ShaderNodeLightPath')
|
||||
light_path_node.location = (50, 200)
|
||||
|
||||
# Create transparent BSDF for reflections
|
||||
reflection_transparent_node = nodes.new(type='ShaderNodeBsdfTransparent')
|
||||
reflection_transparent_node.location = (200, 200)
|
||||
|
||||
# Create mix shader for reflections
|
||||
reflection_mix_node = nodes.new(type='ShaderNodeMixShader')
|
||||
reflection_mix_node.location = (final_x_location - 50, 100)
|
||||
|
||||
# Connect light path "Is Reflection Ray" to mix factor
|
||||
links.new(light_path_node.outputs['Is Reflection Ray'], reflection_mix_node.inputs['Fac'])
|
||||
|
||||
# Mix current shader with transparent BSDF
|
||||
links.new(current_shader.outputs['Shader' if props.disable_shadows else 'Emission'], reflection_mix_node.inputs[1]) # Shader 1 (not reflection)
|
||||
links.new(reflection_transparent_node.outputs['BSDF'], reflection_mix_node.inputs[2]) # Shader 2 (reflection)
|
||||
|
||||
current_shader = reflection_mix_node
|
||||
final_x_location = final_x_location + 50
|
||||
|
||||
# Update output node position
|
||||
output_node.location = (final_x_location, 0)
|
||||
|
||||
# Connect final shader to output
|
||||
output_socket = 'Shader' if (props.disable_shadows or props.disable_reflections) else 'Emission'
|
||||
links.new(current_shader.outputs[output_socket], output_node.inputs['Surface'])
|
||||
|
||||
elif props.shader_type == 'TRANSPARENT':
|
||||
shader_node = nodes.new(type='ShaderNodeBsdfTransparent')
|
||||
mix_node = nodes.new(type='ShaderNodeMixShader')
|
||||
principled_node = nodes.new(type='ShaderNodeBsdfPrincipled')
|
||||
|
||||
shader_node.location = (200, 100)
|
||||
mix_node.location = (350, 0)
|
||||
principled_node.location = (200, -100)
|
||||
|
||||
# Create texture node
|
||||
tex_node = nodes.new(type='ShaderNodeTexImage')
|
||||
tex_node.image = blender_img
|
||||
tex_node.location = (-200, 0)
|
||||
|
||||
# Connect texture
|
||||
links.new(tex_node.outputs['Color'], principled_node.inputs['Base Color'])
|
||||
links.new(tex_node.outputs['Alpha'], mix_node.inputs['Fac'])
|
||||
|
||||
# Connect shaders to mix
|
||||
links.new(shader_node.outputs['BSDF'], mix_node.inputs[1])
|
||||
links.new(principled_node.outputs['BSDF'], mix_node.inputs[2])
|
||||
|
||||
# Handle shadow/reflection disabling
|
||||
current_shader = mix_node
|
||||
final_x_location = 500
|
||||
|
||||
# Disable shadows if enabled
|
||||
if props.disable_shadows:
|
||||
# Create light path node
|
||||
light_path_node = nodes.new(type='ShaderNodeLightPath')
|
||||
light_path_node.location = (50, 200)
|
||||
|
||||
# Create transparent BSDF for shadows (reuse existing transparent node)
|
||||
shadow_transparent_node = nodes.new(type='ShaderNodeBsdfTransparent')
|
||||
shadow_transparent_node.location = (350, 150)
|
||||
|
||||
# Create mix shader for shadows
|
||||
shadow_mix_node = nodes.new(type='ShaderNodeMixShader')
|
||||
shadow_mix_node.location = (500, 50)
|
||||
|
||||
# Connect light path "Is Shadow Ray" to mix factor
|
||||
links.new(light_path_node.outputs['Is Shadow Ray'], shadow_mix_node.inputs['Fac'])
|
||||
|
||||
# Mix current shader with transparent BSDF
|
||||
links.new(current_shader.outputs['Shader'], shadow_mix_node.inputs[1]) # Shader 1 (not shadow)
|
||||
links.new(shadow_transparent_node.outputs['BSDF'], shadow_mix_node.inputs[2]) # Shader 2 (shadow)
|
||||
|
||||
current_shader = shadow_mix_node
|
||||
final_x_location = 650
|
||||
|
||||
# Disable reflections if enabled
|
||||
if props.disable_reflections:
|
||||
# Create or reuse light path node
|
||||
if not props.disable_shadows:
|
||||
light_path_node = nodes.new(type='ShaderNodeLightPath')
|
||||
light_path_node.location = (50, 250)
|
||||
|
||||
# Create transparent BSDF for reflections
|
||||
reflection_transparent_node = nodes.new(type='ShaderNodeBsdfTransparent')
|
||||
reflection_transparent_node.location = (350, 200)
|
||||
|
||||
# Create mix shader for reflections
|
||||
reflection_mix_node = nodes.new(type='ShaderNodeMixShader')
|
||||
reflection_mix_node.location = (final_x_location - 50, 100)
|
||||
|
||||
# Connect light path "Is Reflection Ray" to mix factor
|
||||
links.new(light_path_node.outputs['Is Reflection Ray'], reflection_mix_node.inputs['Fac'])
|
||||
|
||||
# Mix current shader with transparent BSDF
|
||||
links.new(current_shader.outputs['Shader'], reflection_mix_node.inputs[1]) # Shader 1 (not reflection)
|
||||
links.new(reflection_transparent_node.outputs['BSDF'], reflection_mix_node.inputs[2]) # Shader 2 (reflection)
|
||||
|
||||
current_shader = reflection_mix_node
|
||||
final_x_location = final_x_location + 50
|
||||
|
||||
# Disable backfacing if enabled
|
||||
if props.disable_backfacing:
|
||||
# Create or reuse light path node
|
||||
if not props.disable_shadows and not props.disable_reflections:
|
||||
light_path_node = nodes.new(type='ShaderNodeLightPath')
|
||||
light_path_node.location = (50, 300)
|
||||
|
||||
# Create geometry node for backfacing detection
|
||||
geometry_node = nodes.new(type='ShaderNodeNewGeometry')
|
||||
geometry_node.location = (50, 350)
|
||||
|
||||
# Create transparent BSDF for backfaces
|
||||
backface_transparent_node = nodes.new(type='ShaderNodeBsdfTransparent')
|
||||
backface_transparent_node.location = (350, 300)
|
||||
|
||||
# Create mix shader for backfaces
|
||||
backface_mix_node = nodes.new(type='ShaderNodeMixShader')
|
||||
backface_mix_node.location = (final_x_location + 50, 150)
|
||||
|
||||
# Connect geometry "Backfacing" to mix factor
|
||||
links.new(geometry_node.outputs['Backfacing'], backface_mix_node.inputs['Fac'])
|
||||
|
||||
# Mix current shader with transparent BSDF
|
||||
links.new(current_shader.outputs['Shader'], backface_mix_node.inputs[1]) # Shader 1 (front face)
|
||||
links.new(backface_transparent_node.outputs['BSDF'], backface_mix_node.inputs[2]) # Shader 2 (backface)
|
||||
|
||||
current_shader = backface_mix_node
|
||||
final_x_location = final_x_location + 150
|
||||
|
||||
# Update output node position
|
||||
output_node.location = (final_x_location, 0)
|
||||
|
||||
# Connect final shader to output
|
||||
links.new(current_shader.outputs['Shader'], output_node.inputs['Surface'])
|
||||
|
||||
mat.blend_method = 'BLEND'
|
||||
|
||||
# Assign material to active object if enabled and possible
|
||||
if props.auto_assign_material and context.active_object and context.active_object.type in ['MESH', 'CURVE']:
|
||||
obj = context.active_object
|
||||
# Check if material slot exists, reuse if found, otherwise create new one
|
||||
slot_found = False
|
||||
for i, slot in enumerate(obj.material_slots):
|
||||
if slot.material and slot.material.name == material_name:
|
||||
# Material already exists in a slot, update it
|
||||
obj.material_slots[i].material = mat
|
||||
slot_found = True
|
||||
break
|
||||
|
||||
if not slot_found:
|
||||
# Create new material slot if not found
|
||||
obj.data.materials.append(mat)
|
||||
|
||||
self.report({'INFO'}, f"Generated shader '{material_name}' and assigned to {obj.name}")
|
||||
else:
|
||||
self.report({'INFO'}, f"Generated shader '{material_name}' (assign manually to object)")
|
||||
|
||||
# Switch to Shader Editor if available and set material
|
||||
for area in context.screen.areas:
|
||||
if area.type == 'NODE_EDITOR':
|
||||
for space in area.spaces:
|
||||
if space.type == 'NODE_EDITOR':
|
||||
space.shader_type = 'OBJECT'
|
||||
space.id = mat
|
||||
area.tag_redraw()
|
||||
break
|
||||
|
||||
return {'FINISHED'}
|
||||
|
||||
except Exception as e:
|
||||
self.report({'ERROR'}, f"Shader generation failed: {str(e)}")
|
||||
import traceback
|
||||
traceback.print_exc()
|
||||
return {'CANCELLED'}
|
||||
|
||||
# Export all operator classes for wildcard imports
|
||||
__all__ = [
|
||||
'TEXT_TEXTURE_OT_generate',
|
||||
'TEXT_TEXTURE_OT_generate_shader',
|
||||
]
|
||||
893
operators/preset_ops.py
Normal file
893
operators/preset_ops.py
Normal file
@@ -0,0 +1,893 @@
|
||||
import bpy
|
||||
from bpy.types import Operator
|
||||
from bpy.props import StringProperty, BoolProperty, EnumProperty
|
||||
import os
|
||||
import json
|
||||
import time
|
||||
|
||||
# Import utility functions from main module
|
||||
from ..presets import (
|
||||
get_preset_path, get_persistent_preset_path, get_addon_version,
|
||||
get_blend_file_presets, save_blend_file_preset, delete_blend_file_preset,
|
||||
refresh_presets_sync, ensure_presets_available
|
||||
)
|
||||
from ..utils import bl_info
|
||||
|
||||
class TEXT_TEXTURE_OT_save_preset(Operator):
|
||||
"""Save current settings as preset"""
|
||||
bl_idname = "text_texture.save_preset"
|
||||
bl_label = "Save Preset"
|
||||
bl_description = "Save current settings as preset"
|
||||
bl_options = {'REGISTER', 'UNDO'}
|
||||
|
||||
overwrite: bpy.props.BoolProperty(
|
||||
name="Overwrite",
|
||||
description="Overwrite existing preset",
|
||||
default=False
|
||||
)
|
||||
|
||||
preset_name: bpy.props.StringProperty(
|
||||
name="Preset Name",
|
||||
description="Name of preset to save/overwrite",
|
||||
default=""
|
||||
)
|
||||
|
||||
def execute(self, context):
|
||||
props = context.scene.text_texture_props
|
||||
|
||||
# Use provided preset name or fallback to input field
|
||||
preset_name = self.preset_name.strip() if self.preset_name else props.new_preset_name.strip()
|
||||
if not preset_name:
|
||||
self.report({'ERROR'}, "Please enter a preset name")
|
||||
return {'CANCELLED'}
|
||||
|
||||
# When overwriting from button, update the input field for consistency
|
||||
if self.preset_name and self.preset_name.strip():
|
||||
props.new_preset_name = preset_name
|
||||
|
||||
# Validate preset name characters (avoid filesystem issues)
|
||||
import re
|
||||
# Allow Unicode letters, numbers, spaces, hyphens, underscores, and common accented characters
|
||||
# This pattern supports international characters like ö, ü, ñ, etc.
|
||||
if not re.match(r'^[\w\s\-]+$', preset_name, re.UNICODE):
|
||||
self.report({'ERROR'}, "Preset name contains invalid characters for filesystem compatibility")
|
||||
return {'CANCELLED'}
|
||||
|
||||
# Additional check for filesystem-unsafe characters
|
||||
invalid_chars = ['<', '>', ':', '"', '|', '?', '*', '/', '\\']
|
||||
if any(char in preset_name for char in invalid_chars):
|
||||
self.report({'ERROR'}, f"Preset name cannot contain: {' '.join(invalid_chars)}")
|
||||
return {'CANCELLED'}
|
||||
|
||||
# Check for duplicate names
|
||||
preset_file = os.path.join(get_preset_path(), f"{preset_name}.json")
|
||||
if os.path.exists(preset_file) and not self.overwrite:
|
||||
# Suggest alternative names
|
||||
base_name = preset_name
|
||||
counter = 1
|
||||
suggested_name = f"{base_name}_{counter}"
|
||||
while os.path.exists(os.path.join(get_preset_path(), f"{suggested_name}.json")):
|
||||
counter += 1
|
||||
suggested_name = f"{base_name}_{counter}"
|
||||
|
||||
self.report({'ERROR'}, f"Preset '{preset_name}' already exists. Suggestion: try '{suggested_name}' or delete the existing preset first.")
|
||||
return {'CANCELLED'}
|
||||
|
||||
# DETAILED LOGGING: Current shader properties before saving
|
||||
print(f"[PRESET SAVE DEBUG] ==================== SAVING PRESET: '{preset_name}' ====================")
|
||||
print(f"[PRESET SAVE DEBUG] Current shader properties from props:")
|
||||
print(f"[PRESET SAVE DEBUG] disable_shadows: {props.disable_shadows}")
|
||||
print(f"[PRESET SAVE DEBUG] disable_reflections: {props.disable_reflections}")
|
||||
print(f"[PRESET SAVE DEBUG] disable_backfacing: {props.disable_backfacing}")
|
||||
print(f"[PRESET SAVE DEBUG] shader_type: {props.shader_type}")
|
||||
print(f"[PRESET SAVE DEBUG] shader_connection: {props.shader_connection}")
|
||||
print(f"[PRESET SAVE DEBUG] use_alpha: {props.use_alpha}")
|
||||
print(f"[PRESET SAVE DEBUG] emission_strength: {props.emission_strength}")
|
||||
print(f"[PRESET SAVE DEBUG] auto_assign_material: {props.auto_assign_material}")
|
||||
|
||||
preset_data = {
|
||||
'text': props.text,
|
||||
'texture_width': props.texture_width,
|
||||
'texture_height': props.texture_height,
|
||||
'font_size': props.font_size,
|
||||
'padding': props.padding,
|
||||
'text_color': list(props.text_color),
|
||||
'background_transparent': props.background_transparent,
|
||||
'background_color': list(props.background_color),
|
||||
'font_path': props.font_path,
|
||||
'custom_font_path': props.custom_font_path,
|
||||
'use_custom_font': props.use_custom_font,
|
||||
'text_align': props.text_align,
|
||||
'prepend_text': props.prepend_text,
|
||||
'append_text': props.append_text,
|
||||
'prepend_margin': props.prepend_margin,
|
||||
'append_margin': props.append_margin,
|
||||
'prepend_append_layout': props.prepend_append_layout,
|
||||
'shader_type': props.shader_type,
|
||||
'shader_connection': props.shader_connection,
|
||||
'use_alpha': props.use_alpha,
|
||||
'emission_strength': props.emission_strength,
|
||||
'auto_assign_material': props.auto_assign_material,
|
||||
'disable_shadows': props.disable_shadows,
|
||||
'disable_reflections': props.disable_reflections,
|
||||
'disable_backfacing': props.disable_backfacing,
|
||||
'generate_normal_map': props.generate_normal_map,
|
||||
'normal_map_strength': props.normal_map_strength,
|
||||
'normal_map_blur_radius': props.normal_map_blur_radius,
|
||||
'normal_map_invert': props.normal_map_invert,
|
||||
'enable_multiline': props.enable_multiline,
|
||||
'line_height': props.line_height,
|
||||
'text_alignment': props.text_alignment,
|
||||
'auto_wrap': props.auto_wrap,
|
||||
'wrap_width': props.wrap_width,
|
||||
'max_lines': props.max_lines,
|
||||
'line_spacing_pixels': props.line_spacing_pixels,
|
||||
'enable_stroke': props.enable_stroke,
|
||||
'stroke_width': props.stroke_width,
|
||||
'stroke_position': props.stroke_position,
|
||||
'stroke_color': list(props.stroke_color),
|
||||
'enable_shadow': props.enable_shadow,
|
||||
'shadow_offset_x': props.shadow_offset_x,
|
||||
'shadow_offset_y': props.shadow_offset_y,
|
||||
'shadow_blur': props.shadow_blur,
|
||||
'shadow_color': list(props.shadow_color),
|
||||
'shadow_spread': getattr(props, 'shadow_spread', 1.0),
|
||||
'enable_glow': props.enable_glow,
|
||||
'glow_blur': props.glow_blur,
|
||||
'glow_color': list(props.glow_color),
|
||||
'enable_blur': props.enable_blur,
|
||||
'blur_radius': props.blur_radius,
|
||||
'image_overlays': []
|
||||
}
|
||||
|
||||
# DETAILED LOGGING: Verify shader properties in preset_data
|
||||
print(f"[PRESET SAVE DEBUG] Shader properties in preset_data dictionary:")
|
||||
print(f"[PRESET SAVE DEBUG] disable_shadows: {preset_data.get('disable_shadows', 'NOT FOUND')}")
|
||||
print(f"[PRESET SAVE DEBUG] disable_reflections: {preset_data.get('disable_reflections', 'NOT FOUND')}")
|
||||
print(f"[PRESET SAVE DEBUG] disable_backfacing: {preset_data.get('disable_backfacing', 'NOT FOUND')}")
|
||||
|
||||
# Save overlay data
|
||||
for overlay in props.image_overlays:
|
||||
overlay_data = {
|
||||
'name': overlay.name,
|
||||
'image_path': overlay.image_path,
|
||||
'x_position': overlay.x_position,
|
||||
'y_position': overlay.y_position,
|
||||
'scale': overlay.scale,
|
||||
'rotation': overlay.rotation,
|
||||
'z_index': overlay.z_index,
|
||||
'enabled': overlay.enabled
|
||||
}
|
||||
preset_data['image_overlays'].append(overlay_data)
|
||||
|
||||
try:
|
||||
# Primary: Save to blend file (new system)
|
||||
print(f"[PRESET SAVE DEBUG] Attempting to save to blend file...")
|
||||
blend_success = save_blend_file_preset(preset_name, preset_data)
|
||||
print(f"[PRESET SAVE DEBUG] Blend file save result: {blend_success}")
|
||||
|
||||
# ALWAYS save to persistent storage for cross-blend-file sharing and addon update survival
|
||||
persistent_file = os.path.join(get_persistent_preset_path(), f"{preset_name}.json")
|
||||
print(f"[PRESET SAVE DEBUG] Attempting to save to persistent file: {persistent_file}")
|
||||
persistent_success = True
|
||||
try:
|
||||
with open(persistent_file, 'w') as f:
|
||||
json.dump(preset_data, f, indent=2)
|
||||
print(f"[PRESET SAVE DEBUG] Successfully saved preset '{preset_name}' to persistent storage")
|
||||
|
||||
# VERIFY: Read back the persistent file to confirm shader properties were saved
|
||||
print(f"[PRESET SAVE DEBUG] Verifying persistent file contents...")
|
||||
with open(persistent_file, 'r') as f:
|
||||
saved_data = json.load(f)
|
||||
print(f"[PRESET SAVE DEBUG] Persistent file shader properties verification:")
|
||||
print(f"[PRESET SAVE DEBUG] disable_shadows: {saved_data.get('disable_shadows', 'NOT FOUND')}")
|
||||
print(f"[PRESET SAVE DEBUG] disable_reflections: {saved_data.get('disable_reflections', 'NOT FOUND')}")
|
||||
print(f"[PRESET SAVE DEBUG] disable_backfacing: {saved_data.get('disable_backfacing', 'NOT FOUND')}")
|
||||
|
||||
except Exception as persistent_error:
|
||||
print(f"[PRESET SAVE DEBUG] Warning: Failed to save persistent preset file: {persistent_error}")
|
||||
persistent_success = False
|
||||
|
||||
# Also save to legacy location for backward compatibility (optional)
|
||||
legacy_success = True
|
||||
try:
|
||||
legacy_file = os.path.join(get_preset_path(), f"{preset_name}.json")
|
||||
with open(legacy_file, 'w') as f:
|
||||
json.dump(preset_data, f, indent=2)
|
||||
print(f"[PRESET SAVE DEBUG] Also saved to legacy location for backward compatibility")
|
||||
except Exception as legacy_error:
|
||||
print(f"[PRESET SAVE DEBUG] Note: Could not save to legacy location: {legacy_error}")
|
||||
legacy_success = False
|
||||
|
||||
if not blend_success and not persistent_success:
|
||||
self.report({'ERROR'}, f"Failed to save preset to both blend file and persistent storage")
|
||||
return {'CANCELLED'}
|
||||
|
||||
# Check if preset already exists in the collection and update it
|
||||
existing_preset = None
|
||||
for preset in props.presets:
|
||||
if preset.name == preset_name:
|
||||
existing_preset = preset
|
||||
break
|
||||
|
||||
if not existing_preset:
|
||||
preset = props.presets.add()
|
||||
preset.name = preset_name
|
||||
# Priority: Blend file > Persistent file
|
||||
preset.source = 'BLEND_FILE' if blend_success else 'PERSISTENT_FILE'
|
||||
else:
|
||||
# Update source based on where it was successfully saved
|
||||
existing_preset.source = 'BLEND_FILE' if blend_success else 'PERSISTENT_FILE'
|
||||
|
||||
# Don't clear the input field - keep the name for easy re-saving
|
||||
# props.new_preset_name = "New Preset"
|
||||
|
||||
# Provide clear feedback
|
||||
storage_info = ""
|
||||
if blend_success and persistent_success:
|
||||
storage_info = " (saved to blend file + persistent storage)"
|
||||
elif blend_success:
|
||||
storage_info = " (saved to blend file)"
|
||||
elif persistent_success:
|
||||
storage_info = " (saved to persistent storage)"
|
||||
|
||||
if self.overwrite:
|
||||
self.report({'INFO'}, f"✅ Preset '{preset_name}' updated successfully{storage_info}")
|
||||
else:
|
||||
self.report({'INFO'}, f"✅ Preset '{preset_name}' saved successfully{storage_info}")
|
||||
|
||||
except (OSError, IOError, json.JSONEncodeError) as e:
|
||||
self.report({'ERROR'}, f"Failed to save preset: {str(e)}")
|
||||
return {'CANCELLED'}
|
||||
except Exception as e:
|
||||
self.report({'ERROR'}, f"Unexpected error saving preset: {str(e)}")
|
||||
return {'CANCELLED'}
|
||||
|
||||
return {'FINISHED'}
|
||||
|
||||
def invoke(self, context, event):
|
||||
# Check if preset exists and prompt for overwrite
|
||||
props = context.scene.text_texture_props
|
||||
preset_name = props.new_preset_name.strip()
|
||||
|
||||
if preset_name and preset_name != "New Preset":
|
||||
preset_file = os.path.join(get_preset_path(), f"{preset_name}.json")
|
||||
if os.path.exists(preset_file):
|
||||
return context.window_manager.invoke_confirm(self, event)
|
||||
|
||||
return self.execute(context)
|
||||
|
||||
def draw(self, context):
|
||||
layout = self.layout
|
||||
props = context.scene.text_texture_props
|
||||
preset_name = props.new_preset_name.strip()
|
||||
layout.label(text=f"Overwrite existing preset '{preset_name}'?")
|
||||
|
||||
class TEXT_TEXTURE_OT_save_preset_enter(Operator):
|
||||
"""Save preset when Enter key is pressed in name field"""
|
||||
bl_idname = "text_texture.save_preset_enter"
|
||||
bl_label = "Save Preset (Enter)"
|
||||
bl_description = "Save current settings as preset when Enter is pressed"
|
||||
bl_options = {'REGISTER', 'UNDO'}
|
||||
|
||||
def execute(self, context):
|
||||
# Delegate to the main save preset operator
|
||||
return bpy.ops.text_texture.save_preset('INVOKE_DEFAULT')
|
||||
|
||||
class TEXT_TEXTURE_OT_load_preset(Operator):
|
||||
"""Load preset"""
|
||||
bl_idname = "text_texture.load_preset"
|
||||
bl_label = "Load Preset"
|
||||
bl_description = "Load selected preset"
|
||||
bl_options = {'REGISTER', 'UNDO'}
|
||||
|
||||
preset_name: StringProperty()
|
||||
|
||||
def execute(self, context):
|
||||
props = context.scene.text_texture_props
|
||||
|
||||
# DEFENSIVE PROGRAMMING: Ensure presets are available before loading
|
||||
if not ensure_presets_available():
|
||||
self.report({'ERROR'}, "Failed to ensure presets are loaded - cannot load preset")
|
||||
return {'CANCELLED'}
|
||||
|
||||
# DETAILED LOGGING: Current shader properties before loading
|
||||
print(f"[PRESET LOAD DEBUG] ==================== LOADING PRESET: '{self.preset_name}' ====================")
|
||||
print(f"[PRESET LOAD DEBUG] Current shader properties BEFORE loading:")
|
||||
print(f"[PRESET LOAD DEBUG] disable_shadows: {props.disable_shadows}")
|
||||
print(f"[PRESET LOAD DEBUG] disable_reflections: {props.disable_reflections}")
|
||||
print(f"[PRESET LOAD DEBUG] disable_backfacing: {props.disable_backfacing}")
|
||||
print(f"[PRESET LOAD DEBUG] shader_type: {props.shader_type}")
|
||||
print(f"[PRESET LOAD DEBUG] shader_connection: {props.shader_connection}")
|
||||
|
||||
try:
|
||||
# Three-tier loading priority: Blend File > Persistent File > Legacy File
|
||||
blend_presets = get_blend_file_presets()
|
||||
preset_data = None
|
||||
source = 'BLEND_FILE'
|
||||
|
||||
print(f"[PRESET LOAD DEBUG] Available blend file presets: {list(blend_presets.keys())}")
|
||||
|
||||
if self.preset_name in blend_presets:
|
||||
preset_data = blend_presets[self.preset_name]
|
||||
source = 'BLEND_FILE'
|
||||
print(f"[PRESET LOAD DEBUG] Loading preset '{self.preset_name}' from blend file")
|
||||
print(f"[PRESET LOAD DEBUG] Blend file preset shader properties:")
|
||||
print(f"[PRESET LOAD DEBUG] disable_shadows: {preset_data.get('disable_shadows', 'NOT FOUND')}")
|
||||
print(f"[PRESET LOAD DEBUG] disable_reflections: {preset_data.get('disable_reflections', 'NOT FOUND')}")
|
||||
print(f"[PRESET LOAD DEBUG] disable_backfacing: {preset_data.get('disable_backfacing', 'NOT FOUND')}")
|
||||
else:
|
||||
# Try persistent storage next
|
||||
persistent_file = os.path.join(get_persistent_preset_path(), f"{self.preset_name}.json")
|
||||
print(f"[PRESET LOAD DEBUG] Preset not in blend file, trying persistent file: {persistent_file}")
|
||||
if os.path.exists(persistent_file):
|
||||
with open(persistent_file, 'r') as f:
|
||||
preset_data = json.load(f)
|
||||
source = 'PERSISTENT_FILE'
|
||||
print(f"[PRESET LOAD DEBUG] Loading preset '{self.preset_name}' from persistent file")
|
||||
print(f"[PRESET LOAD DEBUG] Persistent file preset shader properties:")
|
||||
print(f"[PRESET LOAD DEBUG] disable_shadows: {preset_data.get('disable_shadows', 'NOT FOUND')}")
|
||||
print(f"[PRESET LOAD DEBUG] disable_reflections: {preset_data.get('disable_reflections', 'NOT FOUND')}")
|
||||
print(f"[PRESET LOAD DEBUG] disable_backfacing: {preset_data.get('disable_backfacing', 'NOT FOUND')}")
|
||||
else:
|
||||
# Fallback to legacy local file
|
||||
legacy_file = os.path.join(get_preset_path(), f"{self.preset_name}.json")
|
||||
print(f"[PRESET LOAD DEBUG] Preset not in persistent storage, trying legacy file: {legacy_file}")
|
||||
if os.path.exists(legacy_file):
|
||||
with open(legacy_file, 'r') as f:
|
||||
preset_data = json.load(f)
|
||||
source = 'LOCAL_FILE'
|
||||
print(f"[PRESET LOAD DEBUG] Loading preset '{self.preset_name}' from legacy file")
|
||||
print(f"[PRESET LOAD DEBUG] Legacy file preset shader properties:")
|
||||
print(f"[PRESET LOAD DEBUG] disable_shadows: {preset_data.get('disable_shadows', 'NOT FOUND')}")
|
||||
print(f"[PRESET LOAD DEBUG] disable_reflections: {preset_data.get('disable_reflections', 'NOT FOUND')}")
|
||||
print(f"[PRESET LOAD DEBUG] disable_backfacing: {preset_data.get('disable_backfacing', 'NOT FOUND')}")
|
||||
else:
|
||||
print(f"[PRESET LOAD DEBUG] Legacy file does not exist: {legacy_file}")
|
||||
self.report({'ERROR'}, f"Preset not found in any storage location: {self.preset_name}")
|
||||
return {'CANCELLED'}
|
||||
|
||||
if not preset_data:
|
||||
print(f"[PRESET LOAD DEBUG] No preset data found!")
|
||||
self.report({'ERROR'}, f"No data found for preset: {self.preset_name}")
|
||||
return {'CANCELLED'}
|
||||
|
||||
props.is_updating = True
|
||||
|
||||
# Skip loading text to prevent overwriting current text
|
||||
# props.text = preset_data.get('text', props.text)
|
||||
props.texture_width = preset_data.get('texture_width', props.texture_width)
|
||||
props.texture_height = preset_data.get('texture_height', props.texture_height)
|
||||
props.font_size = preset_data.get('font_size', props.font_size)
|
||||
props.padding = preset_data.get('padding', props.padding)
|
||||
props.text_color = preset_data.get('text_color', props.text_color)
|
||||
props.background_transparent = preset_data.get('background_transparent', props.background_transparent)
|
||||
props.background_color = preset_data.get('background_color', props.background_color)
|
||||
props.font_path = preset_data.get('font_path', props.font_path)
|
||||
props.custom_font_path = preset_data.get('custom_font_path', props.custom_font_path)
|
||||
props.use_custom_font = preset_data.get('use_custom_font', props.use_custom_font)
|
||||
props.text_align = preset_data.get('text_align', props.text_align)
|
||||
props.prepend_text = preset_data.get('prepend_text', props.prepend_text)
|
||||
props.append_text = preset_data.get('append_text', props.append_text)
|
||||
props.prepend_margin = preset_data.get('prepend_margin', props.prepend_margin)
|
||||
props.append_margin = preset_data.get('append_margin', props.append_margin)
|
||||
props.prepend_append_layout = preset_data.get('prepend_append_layout', props.prepend_append_layout)
|
||||
|
||||
# DETAILED LOGGING: Shader property loading with before/after values
|
||||
print(f"[PRESET LOAD DEBUG] Loading shader properties...")
|
||||
|
||||
old_shader_type = props.shader_type
|
||||
props.shader_type = preset_data.get('shader_type', props.shader_type)
|
||||
print(f"[PRESET LOAD DEBUG] shader_type: {old_shader_type} -> {props.shader_type}")
|
||||
|
||||
old_shader_connection = props.shader_connection
|
||||
props.shader_connection = preset_data.get('shader_connection', props.shader_connection)
|
||||
print(f"[PRESET LOAD DEBUG] shader_connection: {old_shader_connection} -> {props.shader_connection}")
|
||||
|
||||
old_use_alpha = props.use_alpha
|
||||
props.use_alpha = preset_data.get('use_alpha', props.use_alpha)
|
||||
print(f"[PRESET LOAD DEBUG] use_alpha: {old_use_alpha} -> {props.use_alpha}")
|
||||
|
||||
old_emission_strength = props.emission_strength
|
||||
props.emission_strength = preset_data.get('emission_strength', props.emission_strength)
|
||||
print(f"[PRESET LOAD DEBUG] emission_strength: {old_emission_strength} -> {props.emission_strength}")
|
||||
|
||||
old_auto_assign = props.auto_assign_material
|
||||
props.auto_assign_material = preset_data.get('auto_assign_material', props.auto_assign_material)
|
||||
print(f"[PRESET LOAD DEBUG] auto_assign_material: {old_auto_assign} -> {props.auto_assign_material}")
|
||||
|
||||
# CRITICAL SHADER PROPERTIES - Most detailed logging
|
||||
print(f"[PRESET LOAD DEBUG] ==================== CRITICAL SHADER PROPERTIES ====================")
|
||||
|
||||
old_disable_shadows = props.disable_shadows
|
||||
new_disable_shadows = preset_data.get('disable_shadows', props.disable_shadows)
|
||||
props.disable_shadows = new_disable_shadows
|
||||
print(f"[PRESET LOAD DEBUG] disable_shadows:")
|
||||
print(f"[PRESET LOAD DEBUG] OLD VALUE: {old_disable_shadows} (type: {type(old_disable_shadows)})")
|
||||
print(f"[PRESET LOAD DEBUG] PRESET DATA: {preset_data.get('disable_shadows', 'NOT FOUND')} (type: {type(preset_data.get('disable_shadows', 'N/A'))})")
|
||||
print(f"[PRESET LOAD DEBUG] NEW VALUE: {props.disable_shadows} (type: {type(props.disable_shadows)})")
|
||||
|
||||
old_disable_reflections = props.disable_reflections
|
||||
new_disable_reflections = preset_data.get('disable_reflections', props.disable_reflections)
|
||||
props.disable_reflections = new_disable_reflections
|
||||
print(f"[PRESET LOAD DEBUG] disable_reflections:")
|
||||
print(f"[PRESET LOAD DEBUG] OLD VALUE: {old_disable_reflections} (type: {type(old_disable_reflections)})")
|
||||
print(f"[PRESET LOAD DEBUG] PRESET DATA: {preset_data.get('disable_reflections', 'NOT FOUND')} (type: {type(preset_data.get('disable_reflections', 'N/A'))})")
|
||||
print(f"[PRESET LOAD DEBUG] NEW VALUE: {props.disable_reflections} (type: {type(props.disable_reflections)})")
|
||||
|
||||
old_disable_backfacing = props.disable_backfacing
|
||||
new_disable_backfacing = preset_data.get('disable_backfacing', props.disable_backfacing)
|
||||
props.disable_backfacing = new_disable_backfacing
|
||||
print(f"[PRESET LOAD DEBUG] disable_backfacing:")
|
||||
print(f"[PRESET LOAD DEBUG] OLD VALUE: {old_disable_backfacing} (type: {type(old_disable_backfacing)})")
|
||||
print(f"[PRESET LOAD DEBUG] PRESET DATA: {preset_data.get('disable_backfacing', 'NOT FOUND')} (type: {type(preset_data.get('disable_backfacing', 'N/A'))})")
|
||||
print(f"[PRESET LOAD DEBUG] NEW VALUE: {props.disable_backfacing} (type: {type(props.disable_backfacing)})")
|
||||
|
||||
print(f"[PRESET LOAD DEBUG] ================================================================")
|
||||
|
||||
props.generate_normal_map = preset_data.get('generate_normal_map', props.generate_normal_map)
|
||||
props.normal_map_strength = preset_data.get('normal_map_strength', props.normal_map_strength)
|
||||
props.normal_map_blur_radius = preset_data.get('normal_map_blur_radius', props.normal_map_blur_radius)
|
||||
props.normal_map_invert = preset_data.get('normal_map_invert', props.normal_map_invert)
|
||||
|
||||
# Load multiline settings
|
||||
props.enable_multiline = preset_data.get('enable_multiline', props.enable_multiline)
|
||||
props.line_height = preset_data.get('line_height', props.line_height)
|
||||
props.text_alignment = preset_data.get('text_alignment', props.text_alignment)
|
||||
props.auto_wrap = preset_data.get('auto_wrap', props.auto_wrap)
|
||||
props.wrap_width = preset_data.get('wrap_width', props.wrap_width)
|
||||
props.max_lines = preset_data.get('max_lines', props.max_lines)
|
||||
props.line_spacing_pixels = preset_data.get('line_spacing_pixels', props.line_spacing_pixels)
|
||||
|
||||
# Load stroke settings
|
||||
props.enable_stroke = preset_data.get('enable_stroke', props.enable_stroke)
|
||||
props.stroke_width = preset_data.get('stroke_width', props.stroke_width)
|
||||
props.stroke_position = preset_data.get('stroke_position', props.stroke_position)
|
||||
props.stroke_color = preset_data.get('stroke_color', props.stroke_color)
|
||||
|
||||
# Load shadow/glow settings
|
||||
props.enable_shadow = preset_data.get('enable_shadow', props.enable_shadow)
|
||||
props.shadow_offset_x = preset_data.get('shadow_offset_x', props.shadow_offset_x)
|
||||
props.shadow_offset_y = preset_data.get('shadow_offset_y', props.shadow_offset_y)
|
||||
props.shadow_blur = preset_data.get('shadow_blur', props.shadow_blur)
|
||||
props.shadow_color = preset_data.get('shadow_color', props.shadow_color)
|
||||
# Handle new shadow_spread property with backward compatibility
|
||||
if hasattr(props, 'shadow_spread'):
|
||||
props.shadow_spread = preset_data.get('shadow_spread', 1.0)
|
||||
props.enable_glow = preset_data.get('enable_glow', props.enable_glow)
|
||||
props.glow_blur = preset_data.get('glow_blur', props.glow_blur)
|
||||
props.glow_color = preset_data.get('glow_color', props.glow_color)
|
||||
|
||||
# Load blur settings
|
||||
props.enable_blur = preset_data.get('enable_blur', props.enable_blur)
|
||||
props.blur_radius = preset_data.get('blur_radius', props.blur_radius)
|
||||
|
||||
# Load text fitting settings
|
||||
props.enable_text_fitting = preset_data.get('enable_text_fitting', props.enable_text_fitting)
|
||||
props.text_fitting_mode = preset_data.get('text_fitting_mode', props.text_fitting_mode)
|
||||
props.text_fitting_margin = preset_data.get('text_fitting_margin', props.text_fitting_margin)
|
||||
props.min_font_size = preset_data.get('min_font_size', props.min_font_size)
|
||||
props.max_font_size = preset_data.get('max_font_size', props.max_font_size)
|
||||
|
||||
# Load overlay data
|
||||
props.image_overlays.clear()
|
||||
overlay_data_list = preset_data.get('image_overlays', [])
|
||||
for overlay_data in overlay_data_list:
|
||||
overlay = props.image_overlays.add()
|
||||
overlay.name = overlay_data.get('name', 'Overlay')
|
||||
overlay.image_path = overlay_data.get('image_path', '')
|
||||
overlay.x_position = overlay_data.get('x_position', 0.5)
|
||||
overlay.y_position = overlay_data.get('y_position', 0.5)
|
||||
overlay.scale = overlay_data.get('scale', 1.0)
|
||||
overlay.rotation = overlay_data.get('rotation', 0.0)
|
||||
overlay.z_index = overlay_data.get('z_index', 1)
|
||||
overlay.enabled = overlay_data.get('enabled', True)
|
||||
|
||||
props.is_updating = False
|
||||
|
||||
# FINAL VERIFICATION: Check what the properties actually are after loading
|
||||
print(f"[PRESET LOAD DEBUG] ==================== FINAL VERIFICATION ====================")
|
||||
print(f"[PRESET LOAD DEBUG] Properties AFTER loading preset '{self.preset_name}':")
|
||||
print(f"[PRESET LOAD DEBUG] disable_shadows: {props.disable_shadows} (type: {type(props.disable_shadows)})")
|
||||
print(f"[PRESET LOAD DEBUG] disable_reflections: {props.disable_reflections} (type: {type(props.disable_reflections)})")
|
||||
print(f"[PRESET LOAD DEBUG] disable_backfacing: {props.disable_backfacing} (type: {type(props.disable_backfacing)})")
|
||||
print(f"[PRESET LOAD DEBUG] ================================================================")
|
||||
|
||||
# Always generate preview after loading preset
|
||||
# Import preview generation function
|
||||
from .. import generate_preview
|
||||
generate_preview(context)
|
||||
|
||||
source_info = {
|
||||
'BLEND_FILE': "from blend file",
|
||||
'PERSISTENT_FILE': "from persistent storage",
|
||||
'LOCAL_FILE': "from legacy storage"
|
||||
}.get(source, "from unknown source")
|
||||
self.report({'INFO'}, f"✅ Loaded preset '{self.preset_name}' {source_info}")
|
||||
|
||||
except (OSError, IOError) as e:
|
||||
props.is_updating = False
|
||||
self.report({'ERROR'}, f"Failed to read preset file: {str(e)}")
|
||||
return {'CANCELLED'}
|
||||
except json.JSONDecodeError as e:
|
||||
props.is_updating = False
|
||||
self.report({'ERROR'}, f"Invalid preset file format: {str(e)}")
|
||||
return {'CANCELLED'}
|
||||
except Exception as e:
|
||||
props.is_updating = False
|
||||
self.report({'ERROR'}, f"Unexpected error loading preset: {str(e)}")
|
||||
return {'CANCELLED'}
|
||||
|
||||
return {'FINISHED'}
|
||||
|
||||
class TEXT_TEXTURE_OT_delete_preset(Operator):
|
||||
"""Delete preset"""
|
||||
bl_idname = "text_texture.delete_preset"
|
||||
bl_label = "Delete Preset"
|
||||
bl_description = "Delete selected preset"
|
||||
bl_options = {'REGISTER', 'UNDO'}
|
||||
|
||||
preset_name: StringProperty()
|
||||
|
||||
def execute(self, context):
|
||||
props = context.scene.text_texture_props
|
||||
|
||||
try:
|
||||
# Delete from both blend file and local storage
|
||||
blend_deleted = delete_blend_file_preset(self.preset_name)
|
||||
|
||||
preset_file = os.path.join(get_preset_path(), f"{self.preset_name}.json")
|
||||
local_deleted = False
|
||||
if os.path.exists(preset_file):
|
||||
os.remove(preset_file)
|
||||
local_deleted = True
|
||||
|
||||
if not blend_deleted and not local_deleted:
|
||||
self.report({'WARNING'}, f"Preset '{self.preset_name}' not found in blend file or local storage")
|
||||
|
||||
# Remove from UI list
|
||||
for i, preset in enumerate(props.presets):
|
||||
if preset.name == self.preset_name:
|
||||
props.presets.remove(i)
|
||||
break
|
||||
|
||||
delete_info = []
|
||||
if blend_deleted:
|
||||
delete_info.append("blend file")
|
||||
if local_deleted:
|
||||
delete_info.append("local storage")
|
||||
|
||||
location_text = " and ".join(delete_info) if delete_info else "nowhere (not found)"
|
||||
self.report({'INFO'}, f"🗑️ Deleted preset '{self.preset_name}' from {location_text}")
|
||||
|
||||
except (OSError, IOError) as e:
|
||||
self.report({'ERROR'}, f"Failed to delete preset file: {str(e)}")
|
||||
return {'CANCELLED'}
|
||||
except Exception as e:
|
||||
self.report({'ERROR'}, f"Unexpected error deleting preset: {str(e)}")
|
||||
return {'CANCELLED'}
|
||||
|
||||
return {'FINISHED'}
|
||||
|
||||
def invoke(self, context, event):
|
||||
# Add confirmation dialog for better UX
|
||||
return context.window_manager.invoke_confirm(self, event)
|
||||
|
||||
def draw(self, context):
|
||||
layout = self.layout
|
||||
layout.label(text=f"Delete preset '{self.preset_name}'?")
|
||||
layout.label(text="This action cannot be undone.", icon='ERROR')
|
||||
|
||||
class TEXT_TEXTURE_OT_refresh_presets(Operator):
|
||||
"""Refresh presets from blend file and local storage"""
|
||||
bl_idname = "text_texture.refresh_presets"
|
||||
bl_label = "Refresh Presets"
|
||||
bl_description = "Reload presets from blend file and local storage"
|
||||
bl_options = {'REGISTER', 'UNDO'}
|
||||
|
||||
def execute(self, context):
|
||||
try:
|
||||
# Use the reliable synchronous refresh system
|
||||
success = refresh_presets_sync()
|
||||
|
||||
if success:
|
||||
props = context.scene.text_texture_props
|
||||
total_presets = len(props.presets)
|
||||
|
||||
# Count by source for detailed reporting
|
||||
blend_count = len([p for p in props.presets if p.source == 'BLEND_FILE'])
|
||||
persistent_count = len([p for p in props.presets if p.source == 'PERSISTENT_FILE'])
|
||||
local_count = len([p for p in props.presets if p.source == 'LOCAL_FILE'])
|
||||
|
||||
self.report({'INFO'}, f"✅ Refreshed {total_presets} presets ({blend_count} blend file, {persistent_count} persistent, {local_count} local)")
|
||||
else:
|
||||
self.report({'WARNING'}, "Preset refresh completed with issues - check console for details")
|
||||
|
||||
# Force UI redraw
|
||||
for area in context.screen.areas:
|
||||
area.tag_redraw()
|
||||
|
||||
return {'FINISHED'}
|
||||
|
||||
except Exception as e:
|
||||
self.report({'ERROR'}, f"Failed to refresh presets: {str(e)}")
|
||||
import traceback
|
||||
traceback.print_exc()
|
||||
return {'CANCELLED'}
|
||||
|
||||
class TEXT_TEXTURE_OT_export_presets(Operator):
|
||||
"""Export all presets to a file for backup"""
|
||||
bl_idname = "text_texture.export_presets"
|
||||
bl_label = "Export Presets"
|
||||
bl_description = "Export all presets to a file for backup"
|
||||
bl_options = {'REGISTER', 'UNDO'}
|
||||
|
||||
filepath: StringProperty(
|
||||
name="File Path",
|
||||
description="Path to save preset backup file",
|
||||
subtype='FILE_PATH',
|
||||
default="text_texture_presets_backup.json"
|
||||
)
|
||||
|
||||
def execute(self, context):
|
||||
try:
|
||||
props = context.scene.text_texture_props
|
||||
|
||||
# Collect all presets from all sources
|
||||
all_presets = {}
|
||||
|
||||
# Get blend file presets
|
||||
blend_presets = get_blend_file_presets()
|
||||
for name, data in blend_presets.items():
|
||||
all_presets[name] = {
|
||||
"data": data,
|
||||
"source": "BLEND_FILE"
|
||||
}
|
||||
|
||||
# Get persistent presets
|
||||
persistent_dir = get_persistent_preset_path()
|
||||
if os.path.exists(persistent_dir):
|
||||
for filename in os.listdir(persistent_dir):
|
||||
if filename.endswith('.json'):
|
||||
preset_name = os.path.splitext(filename)[0]
|
||||
if preset_name not in all_presets: # Don't override blend file presets
|
||||
try:
|
||||
with open(os.path.join(persistent_dir, filename), 'r') as f:
|
||||
preset_data = json.load(f)
|
||||
all_presets[preset_name] = {
|
||||
"data": preset_data,
|
||||
"source": "PERSISTENT_FILE"
|
||||
}
|
||||
except (json.JSONDecodeError, OSError) as e:
|
||||
print(f"[TTG] Error reading persistent preset {preset_name}: {e}")
|
||||
|
||||
# Get legacy presets
|
||||
legacy_dir = get_preset_path()
|
||||
if os.path.exists(legacy_dir) and legacy_dir != persistent_dir:
|
||||
for filename in os.listdir(legacy_dir):
|
||||
if filename.endswith('.json'):
|
||||
preset_name = os.path.splitext(filename)[0]
|
||||
if preset_name not in all_presets: # Don't override higher priority presets
|
||||
try:
|
||||
with open(os.path.join(legacy_dir, filename), 'r') as f:
|
||||
preset_data = json.load(f)
|
||||
all_presets[preset_name] = {
|
||||
"data": preset_data,
|
||||
"source": "LOCAL_FILE"
|
||||
}
|
||||
except (json.JSONDecodeError, OSError) as e:
|
||||
print(f"[TTG] Error reading legacy preset {preset_name}: {e}")
|
||||
|
||||
if not all_presets:
|
||||
self.report({'WARNING'}, "No presets found to export")
|
||||
return {'CANCELLED'}
|
||||
|
||||
# Create export data with metadata
|
||||
export_data = {
|
||||
"format_version": "1.0",
|
||||
"addon_version": bl_info["version"],
|
||||
"export_timestamp": time.time(),
|
||||
"presets": all_presets
|
||||
}
|
||||
|
||||
# Write to file
|
||||
with open(self.filepath, 'w') as f:
|
||||
json.dump(export_data, f, indent=2)
|
||||
|
||||
self.report({'INFO'}, f"✅ Exported {len(all_presets)} presets to {os.path.basename(self.filepath)}")
|
||||
return {'FINISHED'}
|
||||
|
||||
except Exception as e:
|
||||
self.report({'ERROR'}, f"Failed to export presets: {str(e)}")
|
||||
return {'CANCELLED'}
|
||||
|
||||
def invoke(self, context, event):
|
||||
# Set default filename with timestamp
|
||||
import datetime
|
||||
timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
|
||||
self.filepath = f"text_texture_presets_backup_{timestamp}.json"
|
||||
|
||||
context.window_manager.fileselect_add(self)
|
||||
return {'RUNNING_MODAL'}
|
||||
|
||||
class TEXT_TEXTURE_OT_import_presets(Operator):
|
||||
"""Import presets from a backup file"""
|
||||
bl_idname = "text_texture.import_presets"
|
||||
bl_label = "Import Presets"
|
||||
bl_description = "Import presets from a backup file"
|
||||
bl_options = {'REGISTER', 'UNDO'}
|
||||
|
||||
filepath: StringProperty(
|
||||
name="File Path",
|
||||
description="Path to preset backup file",
|
||||
subtype='FILE_PATH'
|
||||
)
|
||||
|
||||
import_mode: EnumProperty(
|
||||
name="Import Mode",
|
||||
description="How to handle existing presets with same names",
|
||||
items=[
|
||||
('SKIP', 'Skip Existing', 'Skip presets that already exist'),
|
||||
('OVERWRITE', 'Overwrite', 'Overwrite existing presets'),
|
||||
('RENAME', 'Rename New', 'Rename imported presets if they conflict'),
|
||||
],
|
||||
default='SKIP'
|
||||
)
|
||||
|
||||
import_to_blend: BoolProperty(
|
||||
name="Import to Blend File",
|
||||
description="Import presets to blend file (recommended for portability)",
|
||||
default=True
|
||||
)
|
||||
|
||||
def execute(self, context):
|
||||
try:
|
||||
if not os.path.exists(self.filepath):
|
||||
self.report({'ERROR'}, "Backup file not found")
|
||||
return {'CANCELLED'}
|
||||
|
||||
props = context.scene.text_texture_props
|
||||
|
||||
# Read backup file
|
||||
with open(self.filepath, 'r') as f:
|
||||
import_data = json.load(f)
|
||||
|
||||
# Validate format
|
||||
if "presets" not in import_data:
|
||||
self.report({'ERROR'}, "Invalid backup file format")
|
||||
return {'CANCELLED'}
|
||||
|
||||
imported_presets = import_data["presets"]
|
||||
if not imported_presets:
|
||||
self.report({'WARNING'}, "No presets found in backup file")
|
||||
return {'CANCELLED'}
|
||||
|
||||
# Get existing presets to check for conflicts
|
||||
existing_blend_presets = get_blend_file_presets()
|
||||
existing_preset_names = set(existing_blend_presets.keys())
|
||||
|
||||
# Also check persistent storage
|
||||
persistent_dir = get_persistent_preset_path()
|
||||
if os.path.exists(persistent_dir):
|
||||
for filename in os.listdir(persistent_dir):
|
||||
if filename.endswith('.json'):
|
||||
existing_preset_names.add(os.path.splitext(filename)[0])
|
||||
|
||||
imported_count = 0
|
||||
skipped_count = 0
|
||||
errors = []
|
||||
|
||||
for preset_name, preset_info in imported_presets.items():
|
||||
preset_data = preset_info.get("data", {})
|
||||
|
||||
# Handle conflicts
|
||||
final_name = preset_name
|
||||
if preset_name in existing_preset_names:
|
||||
if self.import_mode == 'SKIP':
|
||||
skipped_count += 1
|
||||
continue
|
||||
elif self.import_mode == 'RENAME':
|
||||
counter = 1
|
||||
base_name = preset_name
|
||||
while final_name in existing_preset_names:
|
||||
final_name = f"{base_name}_imported_{counter}"
|
||||
counter += 1
|
||||
# OVERWRITE mode uses original name
|
||||
|
||||
try:
|
||||
# Import to blend file or persistent storage based on setting
|
||||
if self.import_to_blend:
|
||||
success = save_blend_file_preset(final_name, preset_data)
|
||||
if not success:
|
||||
raise Exception("Failed to save to blend file")
|
||||
else:
|
||||
# Save to persistent storage
|
||||
persistent_file = os.path.join(get_persistent_preset_path(), f"{final_name}.json")
|
||||
with open(persistent_file, 'w') as f:
|
||||
json.dump(preset_data, f, indent=2)
|
||||
|
||||
imported_count += 1
|
||||
|
||||
# Add to UI list if not already present
|
||||
existing_preset = None
|
||||
for preset in props.presets:
|
||||
if preset.name == final_name:
|
||||
existing_preset = preset
|
||||
break
|
||||
|
||||
if not existing_preset:
|
||||
new_preset = props.presets.add()
|
||||
new_preset.name = final_name
|
||||
new_preset.source = 'BLEND_FILE' if self.import_to_blend else 'PERSISTENT_FILE'
|
||||
else:
|
||||
existing_preset.source = 'BLEND_FILE' if self.import_to_blend else 'PERSISTENT_FILE'
|
||||
|
||||
except Exception as e:
|
||||
errors.append(f"{preset_name}: {str(e)}")
|
||||
|
||||
# Report results
|
||||
if imported_count > 0:
|
||||
storage_location = "blend file" if self.import_to_blend else "persistent storage"
|
||||
self.report({'INFO'}, f"✅ Imported {imported_count} presets to {storage_location}")
|
||||
if skipped_count > 0:
|
||||
self.report({'INFO'}, f"⏭️ Skipped {skipped_count} existing presets")
|
||||
else:
|
||||
self.report({'WARNING'}, "No presets were imported")
|
||||
|
||||
if errors:
|
||||
self.report({'WARNING'}, f"Errors importing {len(errors)} presets - check console")
|
||||
for error in errors[:5]: # Show first 5 errors
|
||||
print(f"[TTG] Import error: {error}")
|
||||
|
||||
return {'FINISHED'}
|
||||
|
||||
except Exception as e:
|
||||
self.report({'ERROR'}, f"Failed to import presets: {str(e)}")
|
||||
return {'CANCELLED'}
|
||||
|
||||
def invoke(self, context, event):
|
||||
context.window_manager.fileselect_add(self)
|
||||
return {'RUNNING_MODAL'}
|
||||
|
||||
def draw(self, context):
|
||||
layout = self.layout
|
||||
layout.prop(self, "import_mode")
|
||||
layout.prop(self, "import_to_blend")
|
||||
|
||||
class TEXT_TEXTURE_OT_show_migration_report(Operator):
|
||||
"""Show migration report with backup and upgrade information"""
|
||||
bl_idname = "text_texture.show_migration_report"
|
||||
bl_label = "Show Migration Report"
|
||||
bl_description = "Display information about preset migration and backups"
|
||||
bl_options = {'REGISTER', 'UNDO'}
|
||||
|
||||
def execute(self, context):
|
||||
return {'FINISHED'}
|
||||
|
||||
def invoke(self, context, event):
|
||||
return context.window_manager.invoke_props_dialog(self, width=400)
|
||||
|
||||
def draw(self, context):
|
||||
layout = self.layout
|
||||
layout.label(text="Migration Report", icon='INFO')
|
||||
layout.separator()
|
||||
layout.label(text="This addon has been upgraded to the new preset system.")
|
||||
layout.label(text="Your existing presets have been preserved.")
|
||||
layout.separator()
|
||||
layout.label(text="Features:", icon='CHECKMARK')
|
||||
layout.label(text="• Presets saved in blend files")
|
||||
layout.label(text="• Cross-file preset sharing")
|
||||
layout.label(text="• Automatic backup system")
|
||||
layout.separator()
|
||||
|
||||
# Export all operator classes for wildcard imports
|
||||
__all__ = [
|
||||
'TEXT_TEXTURE_OT_save_preset',
|
||||
'TEXT_TEXTURE_OT_save_preset_enter',
|
||||
'TEXT_TEXTURE_OT_load_preset',
|
||||
'TEXT_TEXTURE_OT_delete_preset',
|
||||
'TEXT_TEXTURE_OT_refresh_presets',
|
||||
'TEXT_TEXTURE_OT_export_presets',
|
||||
'TEXT_TEXTURE_OT_import_presets',
|
||||
'TEXT_TEXTURE_OT_show_migration_report',
|
||||
]
|
||||
607
operators/utility_ops.py
Normal file
607
operators/utility_ops.py
Normal file
@@ -0,0 +1,607 @@
|
||||
"""
|
||||
Text Texture Generator - Utility Operators
|
||||
Handles preview refresh, font refresh, UI operations, overlay management, and positioning utilities.
|
||||
"""
|
||||
|
||||
import bpy
|
||||
from bpy.types import Operator
|
||||
from bpy.props import StringProperty, IntProperty, EnumProperty
|
||||
import os
|
||||
|
||||
# Import functions from parent module
|
||||
try:
|
||||
print("[TTG DEBUG] IMPORT TRACE: Attempting to import from ui.preview...")
|
||||
print("[TTG DEBUG] IMPORT TRACE: Looking for generate_preview in ui.preview module")
|
||||
|
||||
# First, let's see what's actually available in ui.preview
|
||||
from .. import ui
|
||||
print(f"[TTG DEBUG] IMPORT TRACE: ui.preview module contents: {dir(ui.preview)}")
|
||||
|
||||
# Now try the actual import that's failing
|
||||
from ..core.generation_engine import generate_preview
|
||||
print("[TTG DEBUG] IMPORT TRACE: SUCCESS - generate_preview imported from ui.preview")
|
||||
from ..utils.system import get_system_fonts, get_font_enum_items
|
||||
from ..presets.storage_system import refresh_presets_sync, ensure_presets_available
|
||||
from ..utils.constants import sync_margin_values
|
||||
except ImportError as e:
|
||||
print(f"[TTG DEBUG] IMPORT ERROR: Failed to import from ui.preview: {e}")
|
||||
print("[TTG DEBUG] IMPORT TRACE: This confirms generate_preview is NOT in ui.preview")
|
||||
|
||||
# Let's check if it's available in core.generation_engine
|
||||
try:
|
||||
print("[TTG DEBUG] IMPORT TRACE: Attempting fallback import from core.generation_engine...")
|
||||
from ..core.generation_engine import generate_preview
|
||||
print("[TTG DEBUG] IMPORT TRACE: SUCCESS - generate_preview found in core.generation_engine!")
|
||||
from ..utils.system import get_system_fonts, get_font_enum_items
|
||||
from ..presets.storage_system import refresh_presets_sync, ensure_presets_available
|
||||
from ..utils.constants import sync_margin_values
|
||||
print("[TTG DEBUG] IMPORT TRACE: All imports successful with corrected path")
|
||||
except ImportError as fallback_error:
|
||||
print(f"[TTG DEBUG] IMPORT ERROR: Fallback import also failed: {fallback_error}")
|
||||
print(f"[TTG DEBUG] IMPORT ERROR: Original error was: {e}")
|
||||
# Fallback imports for development/testing
|
||||
print("[TTG DEBUG] IMPORT TRACE: Using fallback placeholder functions")
|
||||
def generate_preview(context):
|
||||
print("Fallback generate_preview called")
|
||||
return None
|
||||
def get_system_fonts():
|
||||
return {}
|
||||
def get_font_enum_items():
|
||||
return [("default", "Default Font", "Use system default font", 0)]
|
||||
def refresh_presets_sync():
|
||||
return True
|
||||
def ensure_presets_available():
|
||||
return True
|
||||
def sync_margin_values(props, changed_margin):
|
||||
pass
|
||||
|
||||
|
||||
class TEXT_TEXTURE_OT_refresh_preview(Operator):
|
||||
"""Force refresh the preview"""
|
||||
bl_idname = "text_texture.refresh_preview"
|
||||
bl_label = "Refresh Preview"
|
||||
bl_description = "Force refresh the preview image"
|
||||
bl_options = {'REGISTER', 'UNDO'}
|
||||
|
||||
def execute(self, context):
|
||||
props = context.scene.text_texture_props
|
||||
|
||||
# Clear existing preview first
|
||||
props.preview_image = None
|
||||
|
||||
# Generate new preview
|
||||
result = generate_preview(context)
|
||||
|
||||
if result:
|
||||
self.report({'INFO'}, f"Preview refreshed at {props.preview_size}px")
|
||||
else:
|
||||
self.report({'ERROR'}, "Failed to generate preview - check console for details")
|
||||
|
||||
# Force UI update
|
||||
for area in context.screen.areas:
|
||||
area.tag_redraw()
|
||||
|
||||
return {'FINISHED'}
|
||||
|
||||
|
||||
class TEXT_TEXTURE_OT_view_preview_zoom(Operator):
|
||||
"""Open preview in new Image Editor window with zoom support"""
|
||||
bl_idname = "text_texture.view_preview_zoom"
|
||||
bl_label = "Enable Zoom"
|
||||
bl_description = "Open preview in new Image Editor window with zoom and pan controls"
|
||||
bl_options = {'REGISTER', 'UNDO'}
|
||||
|
||||
def execute(self, context):
|
||||
props = context.scene.text_texture_props
|
||||
|
||||
# Generate preview image when button is clicked
|
||||
print("[TTG] Generating preview on button click...")
|
||||
result = generate_preview(context)
|
||||
|
||||
if not result:
|
||||
self.report({'ERROR'}, "Failed to generate preview")
|
||||
return {'CANCELLED'}
|
||||
|
||||
if not props.preview_image:
|
||||
self.report({'ERROR'}, "No preview image to display")
|
||||
return {'CANCELLED'}
|
||||
|
||||
# Open a new window with Image Editor
|
||||
print(f"[ZOOM] Opening new window for preview image: {props.preview_image.name}")
|
||||
|
||||
try:
|
||||
# Create a new window
|
||||
bpy.ops.screen.userpref_show('INVOKE_DEFAULT')
|
||||
|
||||
# Wait a moment and then change the newly opened window to Image Editor
|
||||
def setup_image_window():
|
||||
# Find the newest window (should be the one we just opened)
|
||||
newest_window = None
|
||||
for window in bpy.context.window_manager.windows:
|
||||
if window.screen.name.startswith("temp"):
|
||||
newest_window = window
|
||||
break
|
||||
|
||||
if not newest_window:
|
||||
# Fallback: use any non-main window
|
||||
for window in bpy.context.window_manager.windows:
|
||||
if window != bpy.context.window:
|
||||
newest_window = window
|
||||
break
|
||||
|
||||
if newest_window:
|
||||
# Set the area type to Image Editor
|
||||
for area in newest_window.screen.areas:
|
||||
if area.type == 'PREFERENCES':
|
||||
area.type = 'IMAGE_EDITOR'
|
||||
print("[ZOOM] Changed area to Image Editor")
|
||||
|
||||
# Set the preview image
|
||||
for space in area.spaces:
|
||||
if space.type == 'IMAGE_EDITOR':
|
||||
space.image = props.preview_image
|
||||
print(f"[ZOOM] Set preview image: {props.preview_image.name}")
|
||||
|
||||
# Set up proper viewing
|
||||
override = {
|
||||
'window': newest_window,
|
||||
'screen': newest_window.screen,
|
||||
'area': area,
|
||||
'region': area.regions[0] if area.regions else None
|
||||
}
|
||||
|
||||
with bpy.context.temp_override(**override):
|
||||
try:
|
||||
bpy.ops.image.view_all(fit_view=True)
|
||||
print("[ZOOM] Applied fit to view")
|
||||
except Exception as e:
|
||||
print(f"[ZOOM] Error applying fit to view: {e}")
|
||||
|
||||
break
|
||||
break
|
||||
|
||||
self.report({'INFO'}, "✅ NEW WINDOW OPENED! Use mouse wheel to zoom, middle-mouse to pan")
|
||||
print("[ZOOM] New window zoom feature activated successfully")
|
||||
else:
|
||||
print("[ZOOM] Could not find new window")
|
||||
self.report({'ERROR'}, "Failed to setup new window")
|
||||
|
||||
return None # Stop timer
|
||||
|
||||
# Use a timer to set up the window after it opens
|
||||
bpy.app.timers.register(setup_image_window, first_interval=0.1)
|
||||
|
||||
except Exception as e:
|
||||
print(f"[ZOOM] Error creating new window: {e}")
|
||||
# Fallback to old behavior if new window creation fails
|
||||
self.report({'WARNING'}, "New window failed, trying area split instead")
|
||||
|
||||
# Find any area to split
|
||||
for area in context.screen.areas:
|
||||
if area.type in ['NODE_EDITOR', 'VIEW_3D', 'PROPERTIES']:
|
||||
print(f"[ZOOM] Fallback: Splitting {area.type} to create Image Editor")
|
||||
|
||||
# Split horizontally to create a new area
|
||||
with context.temp_override(area=area):
|
||||
bpy.ops.screen.area_split(direction='HORIZONTAL', factor=0.6)
|
||||
|
||||
# Find the newly created area
|
||||
for new_area in context.screen.areas:
|
||||
if new_area != area and new_area.y != area.y:
|
||||
new_area.type = 'IMAGE_EDITOR'
|
||||
|
||||
# Set the image in the Image Editor
|
||||
for space in new_area.spaces:
|
||||
if space.type == 'IMAGE_EDITOR':
|
||||
space.image = props.preview_image
|
||||
print("[ZOOM] Fallback: Image set in split Image Editor")
|
||||
break
|
||||
|
||||
# Tag for redraw and fit to view
|
||||
new_area.tag_redraw()
|
||||
override = context.copy()
|
||||
override['area'] = new_area
|
||||
override['region'] = new_area.regions[0]
|
||||
|
||||
with context.temp_override(**override):
|
||||
try:
|
||||
bpy.ops.image.view_all(fit_view=True)
|
||||
print("[ZOOM] Fallback: Fit to view applied")
|
||||
except Exception as e:
|
||||
print(f"[ZOOM] Fallback: Error applying fit to view: {e}")
|
||||
|
||||
self.report({'INFO'}, "✅ ZOOM ENABLED! Use mouse wheel to zoom, middle-mouse to pan")
|
||||
return {'FINISHED'}
|
||||
break
|
||||
|
||||
self.report({'ERROR'}, "Failed to create Image Editor")
|
||||
return {'CANCELLED'}
|
||||
|
||||
return {'FINISHED'}
|
||||
|
||||
|
||||
class TEXT_TEXTURE_OT_open_panel(Operator):
|
||||
"""Open Text Texture Generator panel"""
|
||||
bl_idname = "text_texture.open_panel"
|
||||
bl_label = "Open Text Texture Panel"
|
||||
bl_description = "Open the Text Texture Generator panel in the sidebar"
|
||||
bl_options = {'REGISTER', 'UNDO'}
|
||||
|
||||
def execute(self, context):
|
||||
# Ensure the sidebar is visible
|
||||
for area in context.screen.areas:
|
||||
if area.type == 'VIEW_3D':
|
||||
for space in area.spaces:
|
||||
if space.type == 'VIEW_3D':
|
||||
space.show_region_ui = True
|
||||
# Switch to Tool tab
|
||||
area.tag_redraw()
|
||||
self.report({'INFO'}, "Text Texture panel opened in 3D View sidebar (press N if not visible)")
|
||||
return {'FINISHED'}
|
||||
elif area.type == 'NODE_EDITOR':
|
||||
for space in area.spaces:
|
||||
if space.type == 'NODE_EDITOR':
|
||||
space.show_region_ui = True
|
||||
area.tag_redraw()
|
||||
self.report({'INFO'}, "Text Texture panel opened in Shader Editor sidebar")
|
||||
return {'FINISHED'}
|
||||
|
||||
self.report({'WARNING'}, "Please open a 3D View or Shader Editor first")
|
||||
return {'CANCELLED'}
|
||||
|
||||
|
||||
class TEXT_TEXTURE_OT_refresh_fonts(Operator):
|
||||
"""Refresh fonts"""
|
||||
bl_idname = "text_texture.refresh_fonts"
|
||||
bl_label = "Refresh Fonts"
|
||||
bl_description = "Refresh font list"
|
||||
bl_options = {'REGISTER', 'UNDO'}
|
||||
|
||||
def execute(self, context):
|
||||
if hasattr(get_font_enum_items, 'cached_fonts'):
|
||||
del get_font_enum_items.cached_fonts
|
||||
get_font_enum_items.cached_fonts = get_system_fonts()
|
||||
self.report({'INFO'}, f"Found {len(get_font_enum_items.cached_fonts)} fonts")
|
||||
return {'FINISHED'}
|
||||
|
||||
|
||||
class TEXT_TEXTURE_OT_refresh_presets(Operator):
|
||||
"""Refresh presets from blend file and local storage"""
|
||||
bl_idname = "text_texture.refresh_presets"
|
||||
bl_label = "Refresh Presets"
|
||||
bl_description = "Reload presets from blend file and local storage"
|
||||
bl_options = {'REGISTER', 'UNDO'}
|
||||
|
||||
def execute(self, context):
|
||||
try:
|
||||
# Use the reliable synchronous refresh system
|
||||
success = refresh_presets_sync()
|
||||
|
||||
if success:
|
||||
props = context.scene.text_texture_props
|
||||
total_presets = len(props.presets)
|
||||
|
||||
# Count by source for detailed reporting
|
||||
blend_count = len([p for p in props.presets if p.source == 'BLEND_FILE'])
|
||||
persistent_count = len([p for p in props.presets if p.source == 'PERSISTENT_FILE'])
|
||||
local_count = len([p for p in props.presets if p.source == 'LOCAL_FILE'])
|
||||
|
||||
self.report({'INFO'}, f"✅ Refreshed {total_presets} presets ({blend_count} blend file, {persistent_count} persistent, {local_count} local)")
|
||||
else:
|
||||
self.report({'WARNING'}, "Preset refresh completed with issues - check console for details")
|
||||
|
||||
# Force UI redraw
|
||||
for area in context.screen.areas:
|
||||
area.tag_redraw()
|
||||
|
||||
return {'FINISHED'}
|
||||
|
||||
except Exception as e:
|
||||
self.report({'ERROR'}, f"Failed to refresh presets: {str(e)}")
|
||||
import traceback
|
||||
traceback.print_exc()
|
||||
return {'CANCELLED'}
|
||||
|
||||
|
||||
class TEXT_TEXTURE_OT_add_overlay(Operator):
|
||||
"""Add new image overlay"""
|
||||
bl_idname = "text_texture.add_overlay"
|
||||
bl_label = "Add Overlay"
|
||||
bl_description = "Add new image overlay"
|
||||
bl_options = {'REGISTER', 'UNDO'}
|
||||
|
||||
def execute(self, context):
|
||||
props = context.scene.text_texture_props
|
||||
|
||||
overlay = props.image_overlays.add()
|
||||
overlay.name = f"Overlay {len(props.image_overlays)}"
|
||||
props.active_overlay_index = len(props.image_overlays) - 1
|
||||
|
||||
# Force UI redraw
|
||||
for area in context.screen.areas:
|
||||
area.tag_redraw()
|
||||
|
||||
self.report({'INFO'}, f"Added overlay: {overlay.name}")
|
||||
return {'FINISHED'}
|
||||
|
||||
|
||||
class TEXT_TEXTURE_OT_remove_overlay(Operator):
|
||||
"""Remove active image overlay"""
|
||||
bl_idname = "text_texture.remove_overlay"
|
||||
bl_label = "Remove Overlay"
|
||||
bl_description = "Remove active image overlay"
|
||||
bl_options = {'REGISTER', 'UNDO'}
|
||||
|
||||
def execute(self, context):
|
||||
props = context.scene.text_texture_props
|
||||
|
||||
if props.image_overlays and props.active_overlay_index < len(props.image_overlays):
|
||||
overlay_name = props.image_overlays[props.active_overlay_index].name
|
||||
props.image_overlays.remove(props.active_overlay_index)
|
||||
|
||||
# Update active index
|
||||
if props.active_overlay_index >= len(props.image_overlays) and props.image_overlays:
|
||||
props.active_overlay_index = len(props.image_overlays) - 1
|
||||
|
||||
# Force UI redraw
|
||||
for area in context.screen.areas:
|
||||
area.tag_redraw()
|
||||
|
||||
self.report({'INFO'}, f"Removed overlay: {overlay_name}")
|
||||
else:
|
||||
self.report({'WARNING'}, "No overlay to remove")
|
||||
|
||||
return {'FINISHED'}
|
||||
|
||||
|
||||
class TEXT_TEXTURE_OT_set_anchor_point(Operator):
|
||||
"""Set anchor point for text positioning"""
|
||||
bl_idname = "text_texture.set_anchor_point"
|
||||
bl_label = "Set Anchor Point"
|
||||
bl_description = "Set text anchor position"
|
||||
bl_options = {'REGISTER', 'UNDO'}
|
||||
|
||||
anchor_point: StringProperty()
|
||||
|
||||
def execute(self, context):
|
||||
props = context.scene.text_texture_props
|
||||
props.anchor_point = self.anchor_point
|
||||
return {'FINISHED'}
|
||||
|
||||
|
||||
class TEXT_TEXTURE_OT_sync_margins(Operator):
|
||||
"""Sync margin values when linked"""
|
||||
bl_idname = "text_texture.sync_margins"
|
||||
bl_label = "Sync Margins"
|
||||
bl_description = "Synchronize margin values"
|
||||
bl_options = {'REGISTER', 'UNDO'}
|
||||
|
||||
margin_type: StringProperty()
|
||||
|
||||
def execute(self, context):
|
||||
props = context.scene.text_texture_props
|
||||
sync_margin_values(props, self.margin_type)
|
||||
return {'FINISHED'}
|
||||
|
||||
|
||||
class TEXT_TEXTURE_OT_duplicate_overlay(Operator):
|
||||
"""Duplicate image overlay"""
|
||||
bl_idname = "text_texture.duplicate_overlay"
|
||||
bl_label = "Duplicate Overlay"
|
||||
bl_description = "Duplicate this image overlay"
|
||||
bl_options = {'REGISTER', 'UNDO'}
|
||||
|
||||
overlay_index: IntProperty()
|
||||
|
||||
def execute(self, context):
|
||||
props = context.scene.text_texture_props
|
||||
|
||||
if 0 <= self.overlay_index < len(props.image_overlays):
|
||||
source_overlay = props.image_overlays[self.overlay_index]
|
||||
|
||||
# Debug logging
|
||||
print(f"[DUPLICATE DEBUG] Duplicating overlay '{source_overlay.name}'")
|
||||
print(f"[DUPLICATE DEBUG] Source properties:")
|
||||
print(f"[DUPLICATE DEBUG] image_path: '{source_overlay.image_path}'")
|
||||
print(f"[DUPLICATE DEBUG] enabled: {source_overlay.enabled}")
|
||||
print(f"[DUPLICATE DEBUG] positioning_mode: '{source_overlay.positioning_mode}'")
|
||||
print(f"[DUPLICATE DEBUG] scale: {source_overlay.scale}")
|
||||
print(f"[DUPLICATE DEBUG] z_index: {source_overlay.z_index}")
|
||||
|
||||
new_overlay = props.image_overlays.add()
|
||||
|
||||
# Copy all properties with explicit verification
|
||||
new_overlay.name = f"{source_overlay.name} Copy"
|
||||
new_overlay.image_path = source_overlay.image_path
|
||||
new_overlay.x_position = source_overlay.x_position
|
||||
new_overlay.y_position = source_overlay.y_position
|
||||
new_overlay.scale = source_overlay.scale
|
||||
new_overlay.rotation = source_overlay.rotation
|
||||
# Fix z-index assignment for duplicated overlays to ensure proper visibility
|
||||
# For PREPEND/APPEND overlays, increment z_index to ensure duplicate appears above original
|
||||
# This prevents the duplicate from being rendered behind the original overlay
|
||||
if source_overlay.positioning_mode in ['PREPEND', 'APPEND']:
|
||||
# Increment z_index to ensure proper layering order for duplicated overlay
|
||||
new_overlay.z_index = min(source_overlay.z_index + 1, 10) # Cap at max z_index value
|
||||
print(f"[DUPLICATE DEBUG] Fixed z_index for {source_overlay.positioning_mode} overlay: {source_overlay.z_index} -> {new_overlay.z_index}")
|
||||
else:
|
||||
# For ABSOLUTE overlays, keep same z_index (different positions so no overlap issue)
|
||||
new_overlay.z_index = source_overlay.z_index
|
||||
new_overlay.positioning_mode = source_overlay.positioning_mode
|
||||
new_overlay.text_spacing = source_overlay.text_spacing
|
||||
new_overlay.image_spacing = source_overlay.image_spacing
|
||||
new_overlay.enabled = source_overlay.enabled
|
||||
|
||||
# Verify the copy was successful
|
||||
print(f"[DUPLICATE DEBUG] New overlay properties:")
|
||||
print(f"[DUPLICATE DEBUG] name: '{new_overlay.name}'")
|
||||
print(f"[DUPLICATE DEBUG] image_path: '{new_overlay.image_path}'")
|
||||
print(f"[DUPLICATE DEBUG] enabled: {new_overlay.enabled}")
|
||||
print(f"[DUPLICATE DEBUG] positioning_mode: '{new_overlay.positioning_mode}'")
|
||||
print(f"[DUPLICATE DEBUG] scale: {new_overlay.scale}")
|
||||
print(f"[DUPLICATE DEBUG] z_index: {new_overlay.z_index}")
|
||||
|
||||
# Move to position after source
|
||||
new_index = len(props.image_overlays) - 1
|
||||
target_index = min(self.overlay_index + 1, new_index)
|
||||
|
||||
if new_index != target_index:
|
||||
props.image_overlays.move(new_index, target_index)
|
||||
print(f"[DUPLICATE DEBUG] Moved overlay from index {new_index} to {target_index}")
|
||||
|
||||
props.active_overlay_index = target_index
|
||||
|
||||
# Clear any cached images to force reload
|
||||
print(f"[DUPLICATE DEBUG] Clearing image cache and forcing preview update...")
|
||||
|
||||
# Set the updating flag to prevent recursive updates
|
||||
props.is_updating = True
|
||||
|
||||
try:
|
||||
# Force immediate preview regeneration
|
||||
print(f"[DUPLICATE DEBUG] Generating new preview...")
|
||||
preview_result = generate_preview(context)
|
||||
if preview_result:
|
||||
print(f"[DUPLICATE DEBUG] Preview generated successfully")
|
||||
else:
|
||||
print(f"[DUPLICATE DEBUG] Preview generation failed")
|
||||
|
||||
# Force UI redraw
|
||||
for area in context.screen.areas:
|
||||
area.tag_redraw()
|
||||
|
||||
except Exception as e:
|
||||
print(f"[DUPLICATE DEBUG] Error updating preview: {e}")
|
||||
import traceback
|
||||
traceback.print_exc()
|
||||
finally:
|
||||
props.is_updating = False
|
||||
|
||||
print(f"[DUPLICATE DEBUG] Total overlays now: {len(props.image_overlays)}")
|
||||
print(f"[DUPLICATE DEBUG] Duplication operation completed")
|
||||
|
||||
self.report({'INFO'}, f"✅ Duplicated overlay: {source_overlay.name}")
|
||||
else:
|
||||
self.report({'ERROR'}, "Invalid overlay index")
|
||||
return {'CANCELLED'}
|
||||
|
||||
return {'FINISHED'}
|
||||
|
||||
|
||||
class TEXT_TEXTURE_OT_delete_overlay(Operator):
|
||||
"""Delete image overlay"""
|
||||
bl_idname = "text_texture.delete_overlay"
|
||||
bl_label = "Delete Overlay"
|
||||
bl_description = "Delete this image overlay"
|
||||
bl_options = {'REGISTER', 'UNDO'}
|
||||
|
||||
overlay_index: IntProperty()
|
||||
|
||||
def execute(self, context):
|
||||
props = context.scene.text_texture_props
|
||||
|
||||
print(f"[DELETE DEBUG] Deleting overlay at index {self.overlay_index}")
|
||||
|
||||
if 0 <= self.overlay_index < len(props.image_overlays):
|
||||
overlay_name = props.image_overlays[self.overlay_index].name
|
||||
print(f"[DELETE DEBUG] Deleting overlay: '{overlay_name}'")
|
||||
|
||||
props.image_overlays.remove(self.overlay_index)
|
||||
|
||||
# Update active index
|
||||
if props.active_overlay_index >= len(props.image_overlays) and props.image_overlays:
|
||||
props.active_overlay_index = len(props.image_overlays) - 1
|
||||
elif not props.image_overlays:
|
||||
props.active_overlay_index = 0
|
||||
|
||||
print(f"[DELETE DEBUG] Overlay deleted successfully. Total overlays now: {len(props.image_overlays)}")
|
||||
|
||||
# Force preview update after deletion
|
||||
try:
|
||||
generate_preview(context)
|
||||
print(f"[DELETE DEBUG] Preview updated after deletion")
|
||||
except Exception as e:
|
||||
print(f"[DELETE DEBUG] Error updating preview: {e}")
|
||||
|
||||
# Force UI redraw
|
||||
for area in context.screen.areas:
|
||||
area.tag_redraw()
|
||||
|
||||
self.report({'INFO'}, f"Deleted overlay: {overlay_name}")
|
||||
else:
|
||||
print(f"[DELETE DEBUG] Invalid overlay index: {self.overlay_index}")
|
||||
self.report({'ERROR'}, "Invalid overlay index")
|
||||
return {'CANCELLED'}
|
||||
|
||||
return {'FINISHED'}
|
||||
|
||||
|
||||
class TEXT_TEXTURE_OT_move_overlay(Operator):
|
||||
"""Move image overlay up or down in the list"""
|
||||
bl_idname = "text_texture.move_overlay"
|
||||
bl_label = "Move Overlay"
|
||||
bl_description = "Move overlay up or down in the list"
|
||||
bl_options = {'REGISTER', 'UNDO'}
|
||||
|
||||
overlay_index: IntProperty()
|
||||
direction: EnumProperty(
|
||||
items=[
|
||||
('UP', 'Up', 'Move overlay up in list'),
|
||||
('DOWN', 'Down', 'Move overlay down in list')
|
||||
]
|
||||
)
|
||||
|
||||
def execute(self, context):
|
||||
props = context.scene.text_texture_props
|
||||
|
||||
print(f"[MOVE DEBUG] Moving overlay at index {self.overlay_index} direction: {self.direction}")
|
||||
|
||||
if 0 <= self.overlay_index < len(props.image_overlays):
|
||||
current_index = self.overlay_index
|
||||
new_index = current_index
|
||||
|
||||
if self.direction == 'UP' and current_index > 0:
|
||||
new_index = current_index - 1
|
||||
elif self.direction == 'DOWN' and current_index < len(props.image_overlays) - 1:
|
||||
new_index = current_index + 1
|
||||
|
||||
if new_index != current_index:
|
||||
overlay_name = props.image_overlays[current_index].name
|
||||
props.image_overlays.move(current_index, new_index)
|
||||
props.active_overlay_index = new_index
|
||||
|
||||
print(f"[MOVE DEBUG] Successfully moved overlay '{overlay_name}' from {current_index} to {new_index}")
|
||||
|
||||
# Force preview update after moving (order affects rendering)
|
||||
try:
|
||||
generate_preview(context)
|
||||
print(f"[MOVE DEBUG] Preview updated after move operation")
|
||||
except Exception as e:
|
||||
print(f"[MOVE DEBUG] Error updating preview: {e}")
|
||||
|
||||
self.report({'INFO'}, f"Moved overlay {self.direction.lower()}")
|
||||
else:
|
||||
print(f"[MOVE DEBUG] No movement needed - overlay is already at edge")
|
||||
self.report({'INFO'}, f"Overlay is already at {self.direction.lower()} edge")
|
||||
else:
|
||||
print(f"[MOVE DEBUG] Invalid overlay index: {self.overlay_index}")
|
||||
self.report({'ERROR'}, "Invalid overlay index")
|
||||
return {'CANCELLED'}
|
||||
|
||||
return {'FINISHED'}
|
||||
|
||||
# Export all operator classes for wildcard imports
|
||||
__all__ = [
|
||||
'TEXT_TEXTURE_OT_refresh_preview',
|
||||
'TEXT_TEXTURE_OT_view_preview_zoom',
|
||||
'TEXT_TEXTURE_OT_open_panel',
|
||||
'TEXT_TEXTURE_OT_refresh_fonts',
|
||||
'TEXT_TEXTURE_OT_refresh_presets',
|
||||
'TEXT_TEXTURE_OT_add_overlay',
|
||||
'TEXT_TEXTURE_OT_remove_overlay',
|
||||
'TEXT_TEXTURE_OT_set_anchor_point',
|
||||
'TEXT_TEXTURE_OT_sync_margins',
|
||||
'TEXT_TEXTURE_OT_duplicate_overlay',
|
||||
'TEXT_TEXTURE_OT_delete_overlay',
|
||||
'TEXT_TEXTURE_OT_move_overlay',
|
||||
]
|
||||
Reference in New Issue
Block a user