def __init__(self,
name: str = 'cube_mesh',
wireframe_thickness: float = 5) -> None:
self.name = name
self.__vertex_data_format = GeomVertexFormat.getV3n3()
self.__vertex_data = GeomVertexData(name, self.__vertex_data_format,
Geom.UHStatic)
self.geom = Geom(self.__vertex_data)
self.__triangles = GeomTriangles(Geom.UHStatic)
self.__triangle_data = self.__triangles.modifyVertices()
self.__vertex = GeomVertexWriter(self.__vertex_data, 'vertex')
self.__normal = GeomVertexWriter(self.__vertex_data, 'normal')
self.__face_count = 0
def add_face(face: Face) -> None:
self.__make_face(face)
self.__make_face(Face.LEFT)
self.__make_face(Face.RIGHT)
self.__make_face(Face.BACK)
self.__make_face(Face.FRONT)
self.__make_face(Face.BOTTOM)
self.__make_face(Face.TOP)
self.__triangles.close_primitive()
self.geom.add_primitive(self.__triangles)
def is_connected(x, y, z, x1, y1, z1):
return (abs(x - x1) == 1 and abs(y - y1) != 1 and abs(z - z1) != 1) or \
(abs(x - x1) != 1 and abs(y - y1) == 1 and abs(z - z1) != 1) or \
(abs(x - x1) != 1 and abs(y - y1) != 1 and abs(z - z1) == 1)
ls = LineSegs()
ls.set_thickness(wireframe_thickness)
arr_x = [0, 0, 0, 0, 1, 1, 1, 1]
arr_y = [0, 0, 1, 1, 1, 1, 0, 0]
arr_z = [0, -1, -1, 0, 0, -1, -1, 0]
for pos1 in range(len(arr_x) - 1):
for pos2 in range(pos1, len(arr_x)):
x = arr_x[pos1]
y = arr_y[pos1]
z = arr_z[pos1]
x1 = arr_x[pos2]
y1 = arr_y[pos2]
z1 = arr_z[pos2]
if (is_connected(x, y, z, x1, y1, z1)):
ls.move_to(x, y, z)
ls.draw_to(x1, y1, z1)
self.__wireframe_node = ls.create()
def draw_lines(base):
linesegs = LineSegs("lines")
# Border
xs, ys = base.map_size
sequence = SequenceNode("border")
for color in ((0, 0, 0.4, 1), (0, 0, 0.5, 1), (0, 0, 0.6, 1), (0, 0, 0.5,
1)):
linesegs.set_color(color)
linesegs.set_thickness(3)
linesegs.move_to((-xs, 0, 0))
linesegs.draw_to((-xs, ys, 0))
linesegs.draw_to((xs, ys, 0))
linesegs.draw_to((xs, 0, 0))
linesegs.draw_to((-xs, 0, 0))
lines = linesegs.create()
sequence.add_child(lines)
sequence.loop(True)
sequence.set_frame_rate(30)
base.border = render.attach_new_node(sequence)
for i in range(2):
n = NodePath("border")
base.border.instance_to(n)
n.reparent_to(render)
n.set_z(-(i * 5))
# Mine cross
base.models["lines"] = {}
base.models["lines"]["cross"] = NodePath("cross")
sequence = SequenceNode("cross")
for color in ((1, 0, 0, 1), (1, 0, 1, 1), (0, 1, 0, 1), (1, 1, 0, 1)):
linesegs.set_thickness(3)
linesegs.move_to((1, 0, 0))
linesegs.draw_to((-1, 0, 0))
linesegs.move_to((0, 1, 0))
linesegs.draw_to((0, -1, 0))
linesegs.set_color(color)
lines = linesegs.create()
sequence.add_child(lines)
sequence.loop(True)
sequence.set_frame_rate(60)
base.models["lines"]["cross"].attach_new_node(sequence)
base.linesegs = linesegs
def draw_path(self, current_position, path):
from panda3d.core import LineSegs, Vec4, Vec3
path = [Vec3(*v) for v in path]
segments = LineSegs()
segments.set_thickness(2.0)
segments.set_color((1, 1, 0, 1))
segments.move_to(current_position)
for point in path:
segments.draw_to(point)
if self._path_node:
self._path_node.remove_node()
node = segments.create()
self._path_node = render.attach_new_node(node)
self._replan_timer = Timer(1.5)
self._replan_timer.on_target = self._replan
def __init__(self, *args, **kwargs) -> None:
super().__init__(*args,
**exclude_from_dict(kwargs, ["wireframe_thickness"]))
wireframe_thickness: float = kwargs[
"wireframe_thickness"] if "wireframe_thickness" in kwargs else 5
def is_connected(x, y, z, x1, y1, z1):
return (abs(x - x1) == 1 and abs(y - y1) != 1 and abs(z - z1) != 1) or \
(abs(x - x1) != 1 and abs(y - y1) == 1 and abs(z - z1) != 1) or \
(abs(x - x1) != 1 and abs(y - y1) != 1 and abs(z - z1) == 1)
ls = LineSegs()
ls.set_thickness(wireframe_thickness)
for i, j, k in np.ndindex(self.structure.shape):
if bool(self.structure[i, j, k] & self.mask):
self.arr_x = [0, 0, 0, 0, 1, 1, 1, 1]
self.arr_y = [0, 0, 1, 1, 1, 1, 0, 0]
self.arr_z = [0, -1, -1, 0, 0, -1, -1, 0]
for pos1 in range(len(self.arr_x) - 1):
for pos2 in range(pos1, len(self.arr_x)):
x = self.arr_x[pos1] + i
y = self.arr_y[pos1] + j
z = self.arr_z[pos1] + k
x1 = self.arr_x[pos2] + i
y1 = self.arr_y[pos2] + j
z1 = self.arr_z[pos2] + k
if (is_connected(x, y, z, x1, y1, z1)):
ls.move_to(x, y, z)
ls.draw_to(x1, y1, z1)
self.wireframe.attach_new_node(ls.create())
for idx in np.ndindex(self.structure.shape):
if bool(self.structure[idx] & self.mask):
self._add_cube_faces(idx)
self._triangles.close_primitive()
self.mesh.add_primitive(self._triangles)
def line_art(sd, stemlet_length, stemlet_diameter, rest_segments, style):
segs = LineSegs()
segs.set_thickness(2.0)
if style.stem:
segs.set_color(style.stem)
segs.move_to(0, 0, 0)
segs.draw_to(0, 0, stemlet_length)
# Ring around base
if style.ring:
# Segment base ring
segs.set_color(style.ring)
for r in range(style.ring_segs):
from_v = r / style.ring_segs * 2 * math.pi
to_v = (r + 1) / style.ring_segs * 2 * math.pi
segs.move_to(
math.sin(from_v) * stemlet_diameter,
math.cos(from_v) * stemlet_diameter,
0,
)
segs.draw_to(
math.sin(to_v) * stemlet_diameter,
math.cos(to_v) * stemlet_diameter,
0,
)
# Endcap ring
if rest_segments == 1:
for r in range(style.ring_segs):
from_v = r / style.ring_segs * 2 * math.pi
to_v = (r + 1) / style.ring_segs * 2 * math.pi
segs.move_to(
math.sin(from_v) * stemlet_diameter,
math.cos(from_v) * stemlet_diameter,
stemlet_length,
)
segs.draw_to(
math.sin(to_v) * stemlet_diameter,
math.cos(to_v) * stemlet_diameter,
stemlet_length,
)
# Bark
if style.bark:
segs.set_color(style.bark)
for r in range(style.ring_segs):
lobing = 1 + math.sin(2 * math.pi * sd.lobes * r / style.ring_segs)
v = r / style.ring_segs * 2 * math.pi
segs.move_to(
math.sin(v) * stemlet_diameter * lobing,
math.cos(v) * stemlet_diameter * lobing,
0,
)
segs.draw_to(
math.sin(v) * stemlet_diameter * lobing,
math.cos(v) * stemlet_diameter * lobing,
stemlet_length,
)
# x/y indicators
if style.xyz_at_top:
indicator_z = stemlet_length
else:
indicator_z = 0.0
if style.x:
segs.set_color(style.x)
segs.move_to(0, 0, indicator_z)
segs.draw_to(stemlet_diameter, 0, indicator_z)
if style.y:
segs.set_color(style.y)
segs.move_to(0, 0, indicator_z)
segs.draw_to(0, stemlet_diameter, indicator_z)
return segs.create()
class Renderer():
__roots: List[NodePath]
__draw_nps: List[NodePath]
__circles: List[Tuple[int, float, Geom]]
__thicknesses: List[float]
__line_segs: LineSegs
def __init__(self, root: NodePath) -> None:
self.__roots = [root]
self.__draw_nps = []
self.__circles = []
self.__thicknesses = [2.5]
self.__line_segs = LineSegs()
self.__line_segs.set_thickness(2.5)
def push_root(self, np: NodePath) -> None:
assert isinstance(np, NodePath)
self.render()
self.__roots.append(np)
def pop_root(self) -> NodePath:
self.render()
return self.__roots.pop()
def push_line_thickness(self, thickness: float) -> None:
self.__render_lines()
self.__thicknesses.append(thickness)
self.__line_segs.set_thickness(thickness)
def pop_line_thickness(self) -> float:
self.__render_lines()
self.__line_segs.set_thickness(self.__thicknesses[-2])
return self.__thicknesses.pop()
@property
def line_segs(self) -> LineSegs:
return self.__line_segs
@property
def root(self) -> NodePath:
return self.__roots[-1]
def render(self) -> None:
self.__render_lines()
def __render_lines(self) -> None:
if not self.__line_segs.is_empty():
n = self.__line_segs.create()
self.root.attach_new_node(n)
def draw_line(self, colour: Colour, p1: Point, p2: Point) -> None:
ls = self.__line_segs
ls.set_color(*colour)
ls.move_to(*p1)
ls.draw_to(*p2)
def draw_sphere(self, p: Point, colour: Colour = WHITE, scale: float = 0.2) -> None:
np = loader.load_model("models/misc/sphere.egg")
np.set_color(*colour)
np.reparent_to(self.root)
np.set_pos(*p)
np.set_scale(scale)
def draw_arc(self, p: Point, angle_rads: float = 2 * math.pi, nsteps: int = 16, radius: float = 0.06, colour: Colour = WHITE) -> None:
ls = self.__line_segs
ls.set_color(*colour)
x, y, z = p
ls.move_to(x + radius, y, z)
for i in range(nsteps + 1):
a = angle_rads * i / nsteps
ty = math.sin(a) * radius + y
tx = math.cos(a) * radius + x
ls.draw_to(tx, ty, z)
def draw_circle(self, p: Point, *args, **kwargs) -> None:
self.draw_arc(p, 2 * math.pi, *args, **kwargs)
def draw_circle_filled(self, p: Point, nsteps=16, radius: float = 0.06, colour: Colour = WHITE) -> None:
gn = GeomNode("circle")
exists: bool = False
for cn, cr, cg in self.__circles:
if cn == nsteps and cr == radius:
exists = True
gn.add_geom(cg)
break
if not exists:
self.__circles.append((nsteps, radius, BuildGeometry.addCircle(gn, nsteps, radius, colour)))
np = self.root.attach_new_node(gn)
np.set_pos(*p)
np.set_color(*colour)
