CM3D2 Converter.misc_RENDER_PT_render API documentation

bl_idname = 'render.render_cm3d2_icon'

bl_label = 'CM3D2メニュー用のアイコンをレンダリング'

bl_description = 'CM3D2内のアイコン画像に使用できそうな画像をレンダリングします'

bl_options = {'REGISTER', 'UNDO'}

items = [('FACE_TEXTURE', '面のテクスチャで', '', 'FACESEL_HLT', 1), ('NOW_MATERIAL', '今のマテリアルで', '', 'MATERIAL', 2)]

mode: <_PropertyDeferred, <built-in function EnumProperty>, {'items': [('FACE_TEXTURE', '面のテクスチャで', '', 'FACESEL_HLT', 1), ('NOW_MATERIAL', '今のマテリアルで', '', 'MATERIAL', 2)], 'name': 'モード', 'default': 'FACE_TEXTURE', 'attr': 'mode'}> = <_PropertyDeferred, <built-in function EnumProperty>, {'items': [('FACE_TEXTURE', '面のテクスチャで', '', 'FACESEL_HLT', 1), ('NOW_MATERIAL', '今のマテリアルで', '', 'MATERIAL', 2)], 'name': 'モード', 'default': 'FACE_TEXTURE', 'attr': 'mode'}>

use_freestyle: <_PropertyDeferred, <built-in function BoolProperty>, {'name': '輪郭線を描画', 'default': True, 'attr': 'use_freestyle'}> = <_PropertyDeferred, <built-in function BoolProperty>, {'name': '輪郭線を描画', 'default': True, 'attr': 'use_freestyle'}>

line_thickness: <_PropertyDeferred, <built-in function FloatProperty>, {'name': '線の太さ', 'default': 0.2, 'min': 0, 'max': 0.5, 'soft_min': 0, 'soft_max': 0.5, 'step': 10, 'precision': 2, 'subtype': 'PIXEL', 'attr': 'line_thickness'}> = <_PropertyDeferred, <built-in function FloatProperty>, {'name': '線の太さ', 'default': 0.2, 'min': 0, 'max': 0.5, 'soft_min': 0, 'soft_max': 0.5, 'step': 10, 'precision': 2, 'subtype': 'PIXEL', 'attr': 'line_thickness'}>

line_color: <_PropertyDeferred, <built-in function FloatVectorProperty>, {'name': '線の色', 'default': (0, 0, 0), 'min': 0, 'max': 1, 'soft_min': 0, 'soft_max': 1, 'step': 10, 'precision': 2, 'subtype': 'COLOR', 'size': 3, 'attr': 'line_color'}> = <_PropertyDeferred, <built-in function FloatVectorProperty>, {'name': '線の色', 'default': (0, 0, 0), 'min': 0, 'max': 1, 'soft_min': 0, 'soft_max': 1, 'step': 10, 'precision': 2, 'subtype': 'COLOR', 'size': 3, 'attr': 'line_color'}>

resolution: <_PropertyDeferred, <built-in function IntProperty>, {'name': '解像度', 'default': 80, 'min': 10, 'max': 800, 'soft_min': 10, 'soft_max': 800, 'subtype': 'PIXEL', 'attr': 'resolution'}> = <_PropertyDeferred, <built-in function IntProperty>, {'name': '解像度', 'default': 80, 'min': 10, 'max': 800, 'soft_min': 10, 'soft_max': 800, 'subtype': 'PIXEL', 'attr': 'resolution'}>

camera_angle: <_PropertyDeferred, <built-in function FloatVectorProperty>, {'name': 'カメラ角度', 'default': (0.576667, 0.576667, 0.578715), 'min': -10, 'max': 10, 'soft_min': -10, 'soft_max': 10, 'step': 1, 'precision': 2, 'subtype': 'DIRECTION', 'size': 3, 'attr': 'camera_angle'}> = <_PropertyDeferred, <built-in function FloatVectorProperty>, {'name': 'カメラ角度', 'default': (0.576667, 0.576667, 0.578715), 'min': -10, 'max': 10, 'soft_min': -10, 'soft_max': 10, 'step': 1, 'precision': 2, 'subtype': 'DIRECTION', 'size': 3, 'attr': 'camera_angle'}>

camera_move: <_PropertyDeferred, <built-in function FloatVectorProperty>, {'name': 'カメラ移動', 'default': (0, 0), 'min': -10, 'max': 10, 'soft_min': -10, 'soft_max': 10, 'step': 10, 'precision': 2, 'subtype': 'XYZ', 'size': 2, 'attr': 'camera_move'}> = <_PropertyDeferred, <built-in function FloatVectorProperty>, {'name': 'カメラ移動', 'default': (0, 0), 'min': -10, 'max': 10, 'soft_min': -10, 'soft_max': 10, 'step': 10, 'precision': 2, 'subtype': 'XYZ', 'size': 2, 'attr': 'camera_move'}>

zoom_multi: <_PropertyDeferred, <built-in function IntProperty>, {'name': 'ズーム倍率', 'default': 100, 'min': 10, 'max': 190, 'soft_min': 10, 'soft_max': 190, 'step': 10, 'subtype': 'PERCENTAGE', 'attr': 'zoom_multi'}> = <_PropertyDeferred, <built-in function IntProperty>, {'name': 'ズーム倍率', 'default': 100, 'min': 10, 'max': 190, 'soft_min': 10, 'soft_max': 190, 'step': 10, 'subtype': 'PERCENTAGE', 'attr': 'zoom_multi'}>

use_background_color: <_PropertyDeferred, <built-in function BoolProperty>, {'name': '背景を使用', 'default': True, 'attr': 'use_background_color'}> = <_PropertyDeferred, <built-in function BoolProperty>, {'name': '背景を使用', 'default': True, 'attr': 'use_background_color'}>

background_color: <_PropertyDeferred, <built-in function FloatVectorProperty>, {'name': '背景色', 'default': (1, 1, 1), 'min': 0, 'max': 1, 'soft_min': 0, 'soft_max': 1, 'step': 10, 'precision': 2, 'subtype': 'COLOR', 'size': 3, 'attr': 'background_color'}> = <_PropertyDeferred, <built-in function FloatVectorProperty>, {'name': '背景色', 'default': (1, 1, 1), 'min': 0, 'max': 1, 'soft_min': 0, 'soft_max': 1, 'step': 10, 'precision': 2, 'subtype': 'COLOR', 'size': 3, 'attr': 'background_color'}>

is_round_background: <_PropertyDeferred, <built-in function BoolProperty>, {'name': '隅を丸める', 'default': True, 'attr': 'is_round_background'}> = <_PropertyDeferred, <built-in function BoolProperty>, {'name': '隅を丸める', 'default': True, 'attr': 'is_round_background'}>

layer_image: <_PropertyDeferred, <built-in function StringProperty>, {'name': '重ねる画像', 'default': '', 'attr': 'layer_image'}> = <_PropertyDeferred, <built-in function StringProperty>, {'name': '重ねる画像', 'default': '', 'attr': 'layer_image'}>

@classmethod

def poll(cls, context): View Source

48    @classmethod
49    def poll(cls, context):
50        obs = context.selected_objects
51        if len(obs):
52            for ob in obs:
53                if ob.type == 'MESH':
54                    return True
55        return False

def invoke(self, context, event): View Source

57    def invoke(self, context, event):
58        obs = context.selected_objects
59        for ob in obs:
60            if ob.type != 'MESH':
61                continue
62            me = ob.data
63            uv = compat.get_active_uv(me)
64            if uv and uv.data[0]:
65                self.mode = 'FACE_TEXTURE'
66                break
67        else:
68            self.mode = 'NOW_MATERIAL'
69
70        if 'render_cm3d2_icon_background_color' in context.scene:
71            try:
72                color = str(context.scene['render_cm3d2_icon_background_color']).split(",")
73                if len(color) == 3:
74                    self.background_color[0] = float(color[0])
75                    self.background_color[1] = float(color[1])
76                    self.background_color[2] = float(color[2])
77            except:
78                pass
79        if 'render_cm3d2_icon_background_color_layer_image' in context.scene:
80            self.layer_image = context.scene['render_cm3d2_icon_background_color_layer_image']
81
82        return context.window_manager.invoke_props_dialog(self)

def draw(self, context): View Source

 84    def draw(self, context):
 85        self.layout.prop(self, 'resolution', icon=compat.icon('FILE_IMAGE'), slider=True)
 86        col = self.layout.column(align=True)
 87        col.label(text="テクスチャ参照方法", icon=compat.icon('SHADING_TEXTURE'))
 88        row = col.row()
 89        row.prop(self, 'mode', icon=compat.icon('SHADING_TEXTURE'), expand=True)
 90        self.layout.separator()
 91
 92        row = compat.layout_split(self.layout, factor=1 / 3, align=True)
 93        row.prop(self, 'use_freestyle', icon='LINE_DATA', text="輪郭線")
 94        row.prop(self, 'line_thickness', icon='ARROW_LEFTRIGHT', slider=True, text="")
 95        row.prop(self, 'line_color', icon='COLOR', text="")
 96        self.layout.separator()
 97
 98        col = self.layout.column(align=True)
 99        col.label(text="カメラ角度", icon='FILE_REFRESH')
100        col.prop(self, 'camera_angle', text="")
101        self.layout.prop(self, 'camera_move', icon='ARROW_LEFTRIGHT')
102        self.layout.prop(self, 'zoom_multi', icon='VIEWZOOM', slider=True)
103        self.layout.separator()
104
105        row = compat.layout_split(self.layout, factor=0.333333333, align=True)
106        row.prop(self, 'use_background_color', icon='WORLD')
107        row.prop(self, 'background_color', icon='COLOR', text="")
108        row.prop(self, 'is_round_background', icon=compat.icon('CLIPUV_DEHLT'))
109
110        self.layout.separator()
111        self.layout.prop_search(self, 'layer_image', context.blend_data, "images", icon='MOD_UVPROJECT')

def execute(self, context): View Source

113    def execute(self, context):
114        c = self.background_color[:]
115        context.scene['render_cm3d2_icon_background_color'] = ",".join([str(c[0]), str(c[1]), str(c[2])])
116        context.scene['render_cm3d2_icon_background_color_layer_image'] = self.layer_image
117
118        override = context.copy()
119        obs = context.selected_objects
120
121        material_restores, pre_mate_settings = None, None
122        if self.mode == 'FACE_TEXTURE':
123            material_restores = []
124            temp_mates = []
125            for ob in obs:
126                material_restores.append(common.material_restore(ob))
127                override['object'] = ob
128                bpy.ops.object.material_slot_add(override)
129                if len(ob.material_slots) > 0:
130                    temp_mate = context.blend_data.materials.new("temp")
131                    ob.material_slots[0].material = temp_mate
132                    if compat.IS_LEGACY:
133                        temp_mate.use_shadeless = True
134                        temp_mate.use_face_texture = True
135                        temp_mate.use_transparency = True
136                        temp_mate.alpha = 0.0
137                        temp_mate.use_face_texture_alpha = True
138                    temp_mates.append(temp_mate)
139
140        elif self.mode == 'NOW_MATERIAL':
141            if compat.IS_LEGACY:
142                pre_mate_settings = []
143                for ob in obs:
144                    setting = []
145                    for slot in ob.material_slots:
146                        if not slot.material:
147                            continue
148                        mate = slot.material
149                        setting.append([mate, mate.use_shadeless])
150                        mate.use_shadeless = True
151                    pre_mate_settings.append(setting)
152
153        xs, ys, zs = [], [], []
154        if compat.IS_LEGACY:
155            for ob in obs:
156                if ob.type == 'MESH':
157                    temp_me = ob.to_mesh(context.scene, apply_modifiers=True, settings='PREVIEW')
158                    for vert in temp_me.vertices:
159                        co = ob.matrix_world * vert.co
160                        xs.append(co.x)
161                        ys.append(co.y)
162                        zs.append(co.z)
163                    common.remove_data(temp_me)
164        else:
165            depsgraph = context.evaluated_depsgraph_get()
166            for ob in obs:
167                if ob.type == 'MESH':
168                    # depsgraphから取得されたob_eval: すべてのmodifierを考慮
169                    ob_eval = ob.evaluated_get(depsgraph)
170                    temp_me = ob_eval.to_mesh()
171                    for vert in temp_me.vertices:
172                        co = ob.matrix_world @ vert.co
173                        xs.append(co.x)
174                        ys.append(co.y)
175                        zs.append(co.z)
176                    ob_eval.to_mesh_clear()
177
178        center_co = mathutils.Vector((0, 0, 0))
179        center_co.x = (min(xs) + max(xs)) / 2.0
180        center_co.y = (min(ys) + max(ys)) / 2.0
181        center_co.z = (min(zs) + max(zs)) / 2.0
182
183        hide_render_restore = common.hide_render_restore()
184        pre_scene_camera = context.scene.camera
185        temp_camera = context.blend_data.cameras.new("render_cm3d2_icon_temp")
186        temp_camera_ob = context.blend_data.objects.new("render_cm3d2_icon_temp", temp_camera)
187        try:
188            maxs = [-999, -999, -999]
189            mins = [999, 999, 999]
190            for ob in obs:
191                for i in range(8):
192                    for j in range(3):
193                        v = ob.bound_box[i][j]
194                        if maxs[j] < v:
195                            maxs[j] = v
196                        if v < mins[j]:
197                            mins[j] = v
198
199            lens = [maxs[0] - mins[0]]
200            lens.append(maxs[1] - mins[1])
201            lens.append(maxs[2] - mins[2])
202            lens.sort()
203            zoom = lens[-1] * 1.2
204
205            compat.link(context.scene, temp_camera_ob)
206            context.scene.camera = temp_camera_ob
207            temp_camera.type = 'ORTHO'
208            temp_camera.ortho_scale = zoom * (self.zoom_multi * 0.01)
209
210            direct = self.camera_angle.copy()
211            direct.rotate( mathutils.Euler((math.radians(90), 0, 0), 'XYZ') )
212            temp_camera_ob.rotation_mode = 'QUATERNION'
213            temp_camera_ob.rotation_quaternion = direct.to_track_quat('Z', 'Y')
214            temp_camera_ob.location = direct * 10
215            temp_camera_ob.location += center_co
216            vec = mathutils.Vector()
217            vec.x, vec.y = -self.camera_move.x, -self.camera_move.y
218            temp_camera_ob.location += compat.mul(direct.to_track_quat('Z', 'Y'), vec)
219
220            context.scene.render.resolution_x = self.resolution
221            context.scene.render.resolution_y = self.resolution
222            context.scene.render.resolution_percentage = 100
223
224            context.scene.world.light_settings.use_ambient_occlusion = False
225            if compat.IS_LEGACY:
226                context.scene.world.light_settings.ao_blend_type = 'ADD'
227                context.scene.world.light_settings.gather_method = 'RAYTRACE'
228                context.scene.world.light_settings.samples = 10
229
230                context.scene.render.alpha_mode = 'SKY' if self.use_background_color else 'TRANSPARENT'
231                context.scene.world.horizon_color = self.background_color
232            else:
233                # TODO 代替処理
234                pass
235
236            if self.use_freestyle:
237                pre_use_freestyle = context.scene.render.use_freestyle
238                pre_line_thickness = context.scene.render.line_thickness
239                context.scene.render.use_freestyle = True
240                context.scene.render.line_thickness = self.line_thickness
241                if compat.IS_LEGACY:
242                    context.scene.render.layers.active.freestyle_settings.crease_angle = 1.58825
243                    temp_lineset = context.scene.render.layers.active.freestyle_settings.linesets.new("temp")
244                    temp_lineset.linestyle.color = self.line_color
245                else:
246                    # TODO view_layersのactive取得方法
247                    layer = context.scene.view_layers[0]
248                    layer.freestyle_settings.crease_angle = 1.58825
249                    temp_lineset = layer.freestyle_settings.linesets.new("temp")
250                    temp_lineset.linestyle.color = self.line_color
251
252            # コンポジットノード #
253            pre_use_nodes = context.scene.use_nodes
254            context.scene.use_nodes = True
255            node_tree = context.scene.node_tree
256            node_tree.nodes.clear()
257
258            in_node = node_tree.nodes.new('CompositorNodeRLayers')
259            in_node.location = (0, 0)
260
261            img_node = node_tree.nodes.new('CompositorNodeImage')
262            img_node.location = (0, -300)
263            if "Icon Alpha" in context.blend_data.images:
264                icon_alpha_img = context.blend_data.images["Icon Alpha"]
265            else:
266                blend_path = os.path.join(os.path.dirname(__file__), "append_data.blend")
267                with context.blend_data.libraries.load(blend_path) as (data_from, data_to):
268                    data_to.images = ["Icon Alpha"]
269                icon_alpha_img = data_to.images[0]
270            img_node.image = icon_alpha_img
271
272            scale_node = node_tree.nodes.new('CompositorNodeScale')
273            scale_node.location = (250, -300)
274            scale_node.space = 'RENDER_SIZE'
275
276            mix_node = node_tree.nodes.new('CompositorNodeMixRGB')
277            mix_node.location = (500, -100)
278            mix_node.blend_type = 'MULTIPLY'
279
280            alpha_node = node_tree.nodes.new('CompositorNodeSetAlpha')
281            alpha_node.location = (750, 0)
282
283            out_node = node_tree.nodes.new('CompositorNodeComposite')
284            out_node.location = (1500, 0)
285
286            layer_img = None
287            if self.layer_image in context.blend_data.images:
288                layer_img = context.blend_data.images[self.layer_image]
289            if layer_img:
290                layer_img_node = node_tree.nodes.new('CompositorNodeImage')
291                layer_img_node.location = (750, -200)
292                layer_img_node.image = layer_img
293
294                layer_scale_node = node_tree.nodes.new('CompositorNodeScale')
295                layer_scale_node.location = (1000, -200)
296                layer_scale_node.space = 'RENDER_SIZE'
297
298                layer_add_node = node_tree.nodes.new('CompositorNodeAlphaOver')
299                layer_add_node.location = (1250, 0)
300
301                node_tree.links.new(layer_add_node.inputs[1], alpha_node.outputs[0])
302                node_tree.links.new(layer_scale_node.inputs[0], layer_img_node.outputs[0])
303                node_tree.links.new(layer_add_node.inputs[2], layer_scale_node.outputs[0])
304                node_tree.links.new(out_node.inputs[0], layer_add_node.outputs[0])
305            else:
306                node_tree.links.new(out_node.inputs[0], alpha_node.outputs[0])
307
308            node_tree.links.new(alpha_node.inputs[0], in_node.outputs[0])
309            node_tree.links.new(mix_node.inputs[1], in_node.outputs[1])
310            node_tree.links.new(scale_node.inputs[0], img_node.outputs[0])
311            node_tree.links.new(mix_node.inputs[2], scale_node.outputs[0])
312            if self.is_round_background:
313                node_tree.links.new(alpha_node.inputs[1], mix_node.outputs[0])
314            # コンポジットノード #
315
316            bpy.ops.render.render()
317
318            node_tree.nodes.clear()
319            context.scene.use_nodes = False
320            common.remove_data([icon_alpha_img])
321
322            if self.use_freestyle:
323                context.scene.render.use_freestyle = pre_use_freestyle
324                context.scene.render.line_thickness = pre_line_thickness
325                common.remove_data([temp_lineset.linestyle])
326                if compat.IS_LEGACY:
327                    context.scene.render.layers.active.freestyle_settings.linesets.remove(temp_lineset)
328                else:
329                    layer = context.scene.view_layers[0]
330                    layer.freestyle_settings.linesets.remove(temp_lineset)
331
332            img = context.blend_data.images["Render Result"]
333            tex_basename = common.remove_serial_number(context.active_object.name.split('.')[0])
334            img['tex Name'] = tex_basename + "_i_.tex"
335            img['cm3d2_path'] = common.BASE_PATH_TEX + tex_basename + "_i_.png"
336            area = common.get_request_area(context, 'IMAGE_EDITOR')
337            common.set_area_space_attr(area, 'image', img)
338
339        finally:
340            common.remove_data([temp_camera_ob, temp_camera])
341            context.scene.camera = pre_scene_camera
342
343            hide_render_restore.restore()
344            if material_restores:
345                for material_restore in material_restores:
346                    material_restore.restore()
347                common.remove_data(temp_mates)
348            if pre_mate_settings:
349                for ob_mate in pre_mate_settings:
350                    for mate, is_shadeless in ob_mate:
351                        mate.use_shadeless = is_shadeless
352
353        return {'FINISHED'}

bl_rna = <bpy_struct, Struct("RENDER_OT_render_cm3d2_icon")>

CM3D2 Converter.misc_RENDER_PT_render

Inherited Members