Better API design for making text datablocks after loading.
[blender.git] / release / scripts / startup / bl_operators / freestyle.py
1 # ##### BEGIN GPL LICENSE BLOCK #####
2 #
3 #  This program is free software; you can redistribute it and/or
4 #  modify it under the terms of the GNU General Public License
5 #  as published by the Free Software Foundation; either version 2
6 #  of the License, or (at your option) any later version.
7 #
8 #  This program is distributed in the hope that it will be useful,
9 #  but WITHOUT ANY WARRANTY; without even the implied warranty of
10 #  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11 #  GNU General Public License for more details.
12 #
13 #  You should have received a copy of the GNU General Public License
14 #  along with this program; if not, write to the Free Software Foundation,
15 #  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
16 #
17 # ##### END GPL LICENSE BLOCK #####
18
19 import sys
20 import bpy
21
22 from bpy.props import (BoolProperty, EnumProperty, StringProperty)
23
24
25 class SCENE_OT_freestyle_fill_range_by_selection(bpy.types.Operator):
26     """Fill the Range Min/Max entries by the min/max distance between selected mesh objects and the source object """
27     """(either a user-specified object or the active camera)"""
28     bl_idname = "scene.freestyle_fill_range_by_selection"
29     bl_label = "Fill Range by Selection"
30     bl_options = {'INTERNAL'}
31
32     type = EnumProperty(name="Type", description="Type of the modifier to work on",
33                         items=(("COLOR", "Color", "Color modifier type"),
34                                ("ALPHA", "Alpha", "Alpha modifier type"),
35                                ("THICKNESS", "Thickness", "Thickness modifier type")))
36     name = StringProperty(name="Name", description="Name of the modifier to work on")
37
38     @classmethod
39     def poll(cls, context):
40         rl = context.scene.render.layers.active
41         return rl and rl.freestyle_settings.linesets.active
42
43     def execute(self, context):
44         rl = context.scene.render.layers.active
45         lineset = rl.freestyle_settings.linesets.active
46         linestyle = lineset.linestyle
47         # Find the modifier to work on
48         if self.type == 'COLOR':
49             m = linestyle.color_modifiers[self.name]
50         elif self.type == 'ALPHA':
51             m = linestyle.alpha_modifiers[self.name]
52         else:
53             m = linestyle.thickness_modifiers[self.name]
54         # Find the source object
55         if m.type == 'DISTANCE_FROM_CAMERA':
56             source = context.scene.camera
57         elif m.type == 'DISTANCE_FROM_OBJECT':
58             if m.target is None:
59                 self.report({'ERROR'}, "Target object not specified")
60                 return {'CANCELLED'}
61             source = m.target
62         else:
63             self.report({'ERROR'}, "Unexpected modifier type: " + m.type)
64             return {'CANCELLED'}
65         # Find selected mesh objects
66         selection = [ob for ob in context.scene.objects if ob.select and ob.type == 'MESH' and ob.name != source.name]
67         if len(selection) > 0:
68             # Compute the min/max distance between selected mesh objects and the source
69             min_dist = sys.float_info.max
70             max_dist = -min_dist
71             for ob in selection:
72                 for vert in ob.data.vertices:
73                     dist = (ob.matrix_world * vert.co - source.location).length
74                     min_dist = min(dist, min_dist)
75                     max_dist = max(dist, max_dist)
76             # Fill the Range Min/Max entries with the computed distances
77             m.range_min = min_dist
78             m.range_max = max_dist
79         return {'FINISHED'}
80
81
82 class SCENE_OT_freestyle_add_edge_marks_to_keying_set(bpy.types.Operator):
83     '''Add the data paths to the Freestyle Edge Mark property of selected edges to the active keying set'''
84     bl_idname = "scene.freestyle_add_edge_marks_to_keying_set"
85     bl_label = "Add Edge Marks to Keying Set"
86     bl_options = {'UNDO'}
87
88     @classmethod
89     def poll(cls, context):
90         ob = context.active_object
91         return (ob and ob.type == 'MESH')
92
93     def execute(self, context):
94         # active keying set
95         scene = context.scene
96         ks = scene.keying_sets.active
97         if ks is None:
98             ks = scene.keying_sets.new(idname="FreestyleEdgeMarkKeyingSet", name="Freestyle Edge Mark Keying Set")
99             ks.bl_description = ""
100         # add data paths to the keying set
101         ob = context.active_object
102         ob_mode = ob.mode
103         mesh = ob.data
104         bpy.ops.object.mode_set(mode='OBJECT', toggle=False)
105         for i, edge in enumerate(mesh.edges):
106             if not edge.hide and edge.select:
107                 path = 'edges[%d].use_freestyle_edge_mark' % i
108                 ks.paths.add(mesh, path, index=0)
109         bpy.ops.object.mode_set(mode=ob_mode, toggle=False)
110         return {'FINISHED'}
111
112
113 class SCENE_OT_freestyle_add_face_marks_to_keying_set(bpy.types.Operator):
114     '''Add the data paths to the Freestyle Face Mark property of selected polygons to the active keying set'''
115     bl_idname = "scene.freestyle_add_face_marks_to_keying_set"
116     bl_label = "Add Face Marks to Keying Set"
117     bl_options = {'UNDO'}
118
119     @classmethod
120     def poll(cls, context):
121         ob = context.active_object
122         return (ob and ob.type == 'MESH')
123
124     def execute(self, context):
125         # active keying set
126         scene = context.scene
127         ks = scene.keying_sets.active
128         if ks is None:
129             ks = scene.keying_sets.new(idname="FreestyleFaceMarkKeyingSet", name="Freestyle Face Mark Keying Set")
130             ks.bl_description = ""
131         # add data paths to the keying set
132         ob = context.active_object
133         ob_mode = ob.mode
134         mesh = ob.data
135         bpy.ops.object.mode_set(mode='OBJECT', toggle=False)
136         for i, polygon in enumerate(mesh.polygons):
137             if not polygon.hide and polygon.select:
138                 path = 'polygons[%d].use_freestyle_face_mark' % i
139                 ks.paths.add(mesh, path, index=0)
140         bpy.ops.object.mode_set(mode=ob_mode, toggle=False)
141         return {'FINISHED'}
142
143
144 class SCENE_OT_freestyle_module_open(bpy.types.Operator):
145     """Open a style module file"""
146     bl_idname = "scene.freestyle_module_open"
147     bl_label = "Open Style Module File"
148     bl_options = {'INTERNAL'}
149
150     filepath = StringProperty(subtype='FILE_PATH')
151
152     make_internal = BoolProperty(
153         name="Make internal",
154         description="Make module file internal after loading",
155         default=True)
156
157     @classmethod
158     def poll(cls, context):
159         rl = context.scene.render.layers.active
160         return rl and rl.freestyle_settings.mode == 'SCRIPT'
161
162     def invoke(self, context, event):
163         self.freestyle_module = context.freestyle_module
164         wm = context.window_manager
165         wm.fileselect_add(self)
166         return {'RUNNING_MODAL'}
167
168     def execute(self, context):
169         text = bpy.data.texts.load(self.filepath, self.make_internal)
170         self.freestyle_module.script = text
171         return {'FINISHED'}