-
Notifications
You must be signed in to change notification settings - Fork 1
/
grease_mesh_array.py
197 lines (144 loc) · 5.7 KB
/
grease_mesh_array.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
# ##### BEGIN GPL LICENSE BLOCK #####
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software Foundation,
# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
#
# ##### END GPL LICENSE BLOCK #####
bl_info = {
"name": "Grease to Mesh",
"author": "King Goddard Jr",
"version": (1, 0, 0),
"blender": (2, 90, 0),
"location": "3D View",
"description": "make a mesh out of grease Pencil",
"wiki_url": "",
"tracker_url": "",
"category": "Object",
}
import bpy
import math
import pdb
from mathutils import Euler, Matrix, Quaternion, Vector
import numpy
def sel():
return bpy.context.view_layer.objects.selected
def GPframe_set(input=0):
return bpy.context.scene.frame_set(input)
def Linker(context, index, col_name="empty"):
col_child = bpy.context.scene.collection.children
col_obj = bpy.context.scene.collection.objects
col_child_obj = col_child[col_name].objects
assets = [col_child, col_obj, col_child_obj]
return assets[index].link(context)
def ContextSel(self, type):
for obj in selection:
if obj.type == "GPENCIL" and selection.data.active:
return obj
def CurveNew(name="EmptyCurveData"):
CurveData = bpy.data.curves.new(type="CURVE", name=name)
CurveData.dimensions = "3D"
CurveData.resolution_u = 2
return CurveData
def ObjectNew(name="EmptyObjectData", data=None):
object_info = bpy.data.objects.new(name, data)
return object_info
def CollectionNew(name="NewCollection"):
newcol = bpy.data.collections.new(name)
bpy.context.scene.collection.children.link(newcol)
return newcol
"""
CLASSES
"""
class convert_GP_CV(bpy.types.Operator):
"""Add a simple box mesh"""
bl_idname = "gpencil.convert_to_cv"
bl_label = "Create an Array of Meshes from a GP-Layer Timeline"
bl_options = {"REGISTER", "UNDO"}
"""
vars
"""
def execute(self, context):
for obj in bpy.context.selected_objects:
if obj.type == "GPENCIL":
current_gp = bpy.data.grease_pencils[obj.data.name]
active_layer = current_gp.layers.active
GP_frames = current_gp.layers.active.frames
"""
Create a Collection to store the Grease Conversions in.
"""
GP_coll = CollectionNew("{}_Collection".format(active_layer.info))
"""
Start the Loop
"""
for i, GP_frame in enumerate(GP_frames, 0):
"""
add a new curve data of each frame in seq
"""
f = GP_frames[i].frame_number
GPframe_set(f)
cur = CurveNew("GreaseCurve")
cur.name = "00{}_{}_{}_{}".format(
i + 1, active_layer.info, cur.name, f
)
for GP_stroke in GP_frames[i].strokes:
polyline = cur.splines.new("POLY")
cur_points = polyline.points
cur_points.add(len(GP_stroke.points) - 1)
"""
for each separate stroke of the grasepencil on a
frame,add a new polyline,
and assign points to it corresponding with the amount
of points on the stroke.
"""
for n, GP_point in enumerate(GP_stroke.points, 0):
"""
Iterate through all the curve points and place
them where the grease points are placed.
Also add a radius to the points corresponding with
the pressure.
"""
x, y, z = GP_point.co
cur_points[n].co = (x, y, z, 1)
cur_points[n].radius = GP_point.pressure
"""
Returning back to the initial per frame loop,
we bind the curves to an object and then link them
to the new collection.
we also add a curve bevel.
"""
cur.bevel_depth = 0.1
cur_obj = ObjectNew(cur.name, cur)
Linker(cur_obj, 2, GP_coll.name)
return {"FINISHED"}
class HSLU_menu_items(bpy.types.Panel):
bl_idname = "HSLUCUSTOMPLUGINS_PT_GreaseToMesh"
bl_label = "HSLU Custom Plugins"
bl_space_type = "VIEW_3D"
bl_region_type = "UI"
bl_category = "Tool"
def draw(self, context):
layout = self.layout
layout.use_property_split = True
box = layout.box()
col = box.column(align=True)
col.operator("gpencil.convert_to_cv", text="Make GP-Layer Mesh List")
classes = (convert_GP_CV, HSLU_menu_items)
def register():
for cls in classes:
bpy.utils.register_class(cls)
def unregister():
for cls in classes:
bpy.utils.unregister_class(cls)
if __name__ == "__main__":
register()