public-mirrors/3b1b-manim
1
0
Fork 0
mirror of https://github.com/3b1b/manim.git synced 2025-09-01 00:48:45 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

Cleanup VMobject shader wrapper methods

Browse source 
Deleting those which are no longer needed
This commit is contained in:
Grant Sanderson 2023-01-16 11:50:31 -08:00
parent 74b42a6eb5
commit bdcfbc39ec
1 changed files with 43 additions and 83 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

126
manimlib/mobject/types/vectorized_mobject.py
View file

@ -64,18 +64,8 @@ class VMobject(Mobject):
('orientation', np.float32, (1,)), ('orientation', np.float32, (1,)),
('vert_index', np.float32, (1,)), ('vert_index', np.float32, (1,)),
]) ])
fill_dtype: np.dtype = np.dtype([ fill_data_names = ['point', 'fill_rgba', 'orientation', 'vert_index']
('point', np.float32, (3,)), stroke_data_names = ['point', 'stroke_rgba', 'stroke_width', 'joint_angle']
('fill_rgba', np.float32, (4,)),
('orientation', np.float32, (1,)),
('vert_index', np.float32, (1,)),
])
stroke_dtype: np.dtype = np.dtype([
('point', np.float32, (3,)),
('stroke_rgba', np.float32, (4,)),
('stroke_width', np.float32, (1,)),
('joint_angle', np.float32, (1,)),
])
fill_render_primitive: int = moderngl.TRIANGLES fill_render_primitive: int = moderngl.TRIANGLES
stroke_render_primitive: int = moderngl.TRIANGLE_STRIP stroke_render_primitive: int = moderngl.TRIANGLE_STRIP
@ -1175,17 +1165,25 @@ class VMobject(Mobject):
# For shaders # For shaders
def init_shader_data(self): def init_shader_data(self):
self.fill_data = np.zeros(0, dtype=self.fill_dtype) dtype = self.shader_dtype
self.stroke_data = np.zeros(0, dtype=self.stroke_dtype) fill_dtype, stroke_dtype = (
np.dtype([
(name, dtype[name].base, dtype[name].shape)
for name in names
])
for names in [self.fill_data_names, self.stroke_data_names]
)
fill_data = np.zeros(0, dtype=fill_dtype)
stroke_data = np.zeros(0, dtype=stroke_dtype)
self.fill_shader_wrapper = ShaderWrapper( self.fill_shader_wrapper = ShaderWrapper(
vert_data=self.fill_data, vert_data=fill_data,
vert_indices=np.zeros(0, dtype='i4'), vert_indices=np.zeros(0, dtype='i4'),
uniforms=self.uniforms, uniforms=self.uniforms,
shader_folder=self.fill_shader_folder, shader_folder=self.fill_shader_folder,
render_primitive=self.fill_render_primitive, render_primitive=self.fill_render_primitive,
) )
self.stroke_shader_wrapper = ShaderWrapper( self.stroke_shader_wrapper = ShaderWrapper(
vert_data=self.stroke_data, vert_data=stroke_data,
uniforms=self.uniforms, uniforms=self.uniforms,
shader_folder=self.stroke_shader_folder, shader_folder=self.stroke_shader_folder,
render_primitive=self.stroke_render_primitive, render_primitive=self.stroke_render_primitive,
@ -1193,89 +1191,51 @@ class VMobject(Mobject):
self.back_stroke_shader_wrapper = self.stroke_shader_wrapper.copy() self.back_stroke_shader_wrapper = self.stroke_shader_wrapper.copy()
def refresh_shader_wrapper_id(self): def refresh_shader_wrapper_id(self):
for wrapper in [self.fill_shader_wrapper, self.stroke_shader_wrapper]: for wrapper in self.get_shader_wrapper_list():
wrapper.refresh_id() wrapper.refresh_id()
return self return self
def get_fill_shader_wrapper(self) -> ShaderWrapper:
self.fill_shader_wrapper.vert_indices = self.get_triangulation()
self.fill_shader_wrapper.vert_data = self.get_fill_shader_data()
self.fill_shader_wrapper.uniforms = self.get_uniforms()
self.fill_shader_wrapper.depth_test = self.depth_test
return self.fill_shader_wrapper
def get_stroke_shader_wrapper(self) -> ShaderWrapper:
self.stroke_shader_wrapper.vert_data = self.get_stroke_shader_data()
self.stroke_shader_wrapper.uniforms = self.get_uniforms()
self.stroke_shader_wrapper.depth_test = self.depth_test
return self.stroke_shader_wrapper
def get_shader_wrapper_list(self) -> list[ShaderWrapper]: def get_shader_wrapper_list(self) -> list[ShaderWrapper]:
family = self.family_members_with_points()
fill_names = self.fill_data_names
stroke_names = self.stroke_data_names
# Build up data lists # Build up data lists
fill_submobs = [] fill_datas = []
stroke_submobs = [] fill_indices = []
bstroke_submobs = [] stroke_datas = []
for submob in self.family_members_with_points(): back_stroke_data = []
for submob in family:
if submob.has_fill(): if submob.has_fill():
fill_submobs.append(submob) fill_datas.append(submob.data[fill_names])
fill_indices.append(submob.get_triangulation())
if submob.has_stroke(): if submob.has_stroke():
if submob.draw_stroke_behind_fill: if submob.draw_stroke_behind_fill:
bstroke_submobs.append(submob) lst = back_stroke_data
else: else:
stroke_submobs.append(submob) lst = stroke_datas
lst.append(submob.data[stroke_names])
fill_names = list(self.fill_data.dtype.names) # Set data array to be one longer than number of points,
self.fill_shader_wrapper.read_in( # with a dummy vertex added at the end. This is to ensure
[sm.data[fill_names] for sm in fill_submobs], # it can be safely stacked onto other stroke data arrays.
[sm.get_fill_shader_vert_indices() for sm in fill_submobs], lst.append(submob.data[stroke_names][-1:])
)
self.stroke_shader_wrapper.read_in(
[sm.get_stroke_shader_data() for sm in stroke_submobs],
)
self.back_stroke_shader_wrapper.read_in(
[sm.get_stroke_shader_data() for sm in bstroke_submobs],
)
shader_wrappers = [ shader_wrappers = [
self.back_stroke_shader_wrapper, self.back_stroke_shader_wrapper.read_in(back_stroke_data),
self.fill_shader_wrapper, self.fill_shader_wrapper.read_in(fill_datas, fill_indices),
self.stroke_shader_wrapper self.stroke_shader_wrapper.read_in(stroke_datas),
] ]
for sw in shader_wrappers: for sw in shader_wrappers:
# TODO, handle depth test and uniforms... # Assume uniforms of the first family member
pass sw.uniforms = family[0].get_uniforms()
sw.depth_test = family[0].depth_test
return [sw for sw in shader_wrappers if len(sw.vert_data) > 0] return [sw for sw in shader_wrappers if len(sw.vert_data) > 0]
def get_stroke_shader_data(self) -> np.ndarray:
# Set data array to be one longer than number of points,
# with a dummy vertex added at the end. This is to ensure
# it can be safely stacked onto other stroke data arrays.
n = len(self.data)
size = n + 1 if n > 0 else 0
self.stroke_data = resize_array(self.stroke_data, size)
if n == 0:
return self.stroke_data
self.get_joint_angles() # Recomputes, only if refresh is needed
for key in self.stroke_data.dtype.names:
self.stroke_data[key][:n] = self.data[key]
self.stroke_data[-1] = self.stroke_data[-2]
return self.stroke_data
def get_fill_shader_data(self) -> np.ndarray:
self.fill_data = resize_array(self.fill_data, len(self.data))
for key in self.fill_data.dtype.names:
self.fill_data[key][:] = self.data[key]
return self.fill_data
def refresh_shader_data(self): def refresh_shader_data(self):
self.get_fill_shader_data() for submob in self.get_family():
self.get_stroke_shader_data() submob.get_joint_angles()
self.get_shader_wrapper_list()
def get_fill_shader_vert_indices(self) -> np.ndarray:
return self.get_triangulation()
class VGroup(VMobject): class VGroup(VMobject):