def make_circle(scene: core.NodePath, position: core.Point3, radius: float,
point_count: int):
vertex_data = _make_vertex_data(point_count)
position_writer = core.GeomVertexWriter(vertex_data, "vertex")
colour_writer = core.GeomVertexWriter(vertex_data, "color")
for index in range(point_count):
theta = (2 * math.pi * index) / point_count
x = math.cos(theta) * radius
y = math.sin(theta) * radius
position_writer.add_data3(position.x + x, position.y + y, position.z)
colour_writer.add_data4(1, 1, 1, 1)
primitive = core.GeomTriangles(core.Geom.UH_static)
for index in range(1, point_count + 1):
point_2 = (index + 1) % point_count
point_3 = (index + 2) % point_count
primitive.add_vertices(0, point_2, point_3)
primitive.close_primitive()
geometry = core.Geom(vertex_data)
geometry.add_primitive(primitive)
geometry_node = core.GeomNode("circle")
geometry_node.add_geom(geometry)
result: core.NodePath = scene.attach_new_node(geometry_node)
result.set_two_sided(True)
result.set_transparency(True)
return result
def render_heightmap(self, heights, cell_size, colours=None):
form = core.GeomVertexFormat.get_v3n3c4()
vdata = core.GeomVertexData('terrain', form, core.Geom.UHStatic)
vdata.setNumRows(len(heights))
vertex = core.GeomVertexWriter(vdata, 'vertex')
normal = core.GeomVertexWriter(vdata, 'normal')
colour = core.GeomVertexWriter(vdata, 'color')
for y in range(heights.shape[1]):
for x in range(heights.shape[0]):
vertex.addData3(x * cell_size, y * cell_size, heights[x][y])
if not colours is None:
r, g, b = colours[x][y]
colour.addData4(r, g, b, 1)
else:
colour.addData4(0.5, 0.5, 0.5, 1)
normal.addData3(calculate_normal(heights, cell_size, x, y))
prim = core.GeomTriangles(core.Geom.UHStatic)
for y in range(heights.shape[1] - 1):
for x in range(heights.shape[0] - 1):
base = x + y * heights.shape[0]
idx = y * heights.shape[0] + x
prim.add_vertices(base, base + heights.shape[0] + 1,
base + heights.shape[0])
prim.add_vertices(base, base + 1, base + heights.shape[0] + 1)
geom = core.Geom(vdata)
geom.addPrimitive(prim)
node = core.GeomNode('gnode')
node.addGeom(geom)
self.render.attachNewNode(node)
def _init_terrain(self):
vertex_data = core.GeomVertexData('Terrain',
core.GeomVertexFormat.getV3n3c4(),
core.Geom.UH_static)
pos = core.GeomVertexWriter(vertex_data, 'vertex')
nrm = core.GeomVertexWriter(vertex_data, 'normal')
col = core.GeomVertexWriter(vertex_data, 'color')
for i in range(self.w):
for j in range(self.h):
pos.addData3f(*self.positions[i, j])
nrm.addData3f(*self.normals[i, j])
col.addData4f(self.colors[i, j], self.colors[i, j],
self.colors[i, j], 1)
triangles = core.GeomTriangles(core.Geom.UH_static)
for i in range(self.w - 1):
for j in range(self.h - 1):
triangles.addVertices(i * self.h + j, i * self.h + (j + 1),
(i + 1) * self.h + j)
triangles.addVertices((i + 1) * self.h + (j + 1),
(i + 1) * self.h + j,
i * self.h + (j + 1))
geom = core.Geom(vertex_data)
geom.addPrimitive(triangles)
geom_node = core.GeomNode('Terrain')
geom_node.addGeom(geom)
self.terrain_np = self.model_np.attachNewNode(geom_node)
def get_widgets_node():
format = core.GeomVertexFormat.get_v3()
vdata = core.GeomVertexData('name', format, core.Geom.UHStatic)
vertex = core.GeomVertexWriter(vdata, 'vertex')
geom = core.Geom(vdata)
node = core.GeomNode('widget_node')
return node
def build(self):
array = self.primitive.modifyVertices()
fmt = array.getArrayFormat().getFormatString()
data = struct.pack(fmt * len(self.indices), *self.indices)
array.modifyHandle().setData(data)
geom = core.Geom(self.master.vertexdata)
geom.addPrimitive(self.primitive)
gnode = core.GeomNode('{}-node'.format(self.name))
gnode.addGeom(geom)
return gnode
def create_cylinder_segment(parent_node, delta_azimuth):
vdata = pcore.GeomVertexData('name', pcore.GeomVertexFormat.getV3t2(),
pcore.Geom.UHDynamic)
vertex_writer = pcore.GeomVertexWriter(vdata, 'vertex')
texcoord_writer = pcore.GeomVertexWriter(vdata, 'texcoord')
prim_wall = pcore.GeomTristrips(pcore.Geom.UHStatic)
unit_count = int(delta_azimuth)
units = 360 #360
#print unit_count
for i in range(unit_count):
angle1 = i / float(units) * 2 * 3.1452 #/float(parts)
angle2 = (i + 1) / float(units) * 2 * 3.1452 #/float(parts)
x1 = math.sin(angle1)
y1 = math.cos(angle1)
x2 = math.sin(angle2)
y2 = math.cos(angle2)
vertex_writer.addData3f(x1, y1, 1 / 2.)
vertex_writer.addData3f(x1, y1, -1 / 2.)
vertex_writer.addData3f(x2, y2, 1 / 2.)
vertex_writer.addData3f(x2, y2, -1 / 2.)
#texcoord_writer.addData2f(i/float(units),1)
#texcoord_writer.addData2f(i/float(units),0)
#texcoord_writer.addData2f((i+1)/float(units),1)
#texcoord_writer.addData2f((i+1)/float(units),0)
texcoord_writer.addData2f(i / float(unit_count), 1)
texcoord_writer.addData2f(i / float(unit_count), 0)
texcoord_writer.addData2f((i + 1) / float(unit_count), 1)
texcoord_writer.addData2f((i + 1) / float(unit_count), 0)
prim_wall.addConsecutiveVertices(i * 4, 4)
prim_wall.closePrimitive()
geom_wall = pcore.Geom(vdata)
geom_wall.addPrimitive(prim_wall)
cylinder_parts = []
cylinder = parent_node.attachNewNode("cylinder")
cylinder_geomnode_part = pcore.GeomNode('cylinder_part')
cylinder_geomnode_part.addGeom(geom_wall)
cylinder_part = cylinder.attachNewNode(cylinder_geomnode_part)
cylinder_parts.append(cylinder_part)
return cylinder
def create_cylinder_parts(parent_node, parts, units):
vdata = pcore.GeomVertexData('name', pcore.GeomVertexFormat.getV3t2(),
pcore.Geom.UHDynamic)
vertex_writer = pcore.GeomVertexWriter(vdata, 'vertex')
texcoord_writer = pcore.GeomVertexWriter(vdata, 'texcoord')
prim_wall = pcore.GeomTristrips(pcore.Geom.UHStatic)
for i in range(units):
angle1 = i / float(units) * 2 * 3.1452 / float(parts)
angle2 = (i + 1) / float(units) * 2 * 3.1452 / float(parts)
x1 = math.sin(angle1)
y1 = math.cos(angle1)
x2 = math.sin(angle2)
y2 = math.cos(angle2)
vertex_writer.addData3f(x1, y1, 0.5)
vertex_writer.addData3f(x1, y1, -0.5)
vertex_writer.addData3f(x2, y2, 0.5)
vertex_writer.addData3f(x2, y2, -0.5)
texcoord_writer.addData2f(i / float(units), 1)
texcoord_writer.addData2f(i / float(units), 0)
texcoord_writer.addData2f((i + 1) / float(units), 1)
texcoord_writer.addData2f((i + 1) / float(units), 0)
prim_wall.addConsecutiveVertices(i * 4, 4)
prim_wall.closePrimitive()
geom_wall = pcore.Geom(vdata)
geom_wall.addPrimitive(prim_wall)
cylinder_parts = []
cylinder = parent_node.attachNewNode("cylinder")
for part in range(parts):
cylinder_geomnode_part = pcore.GeomNode('cylinder_part %d' % part)
cylinder_geomnode_part.addGeom(geom_wall)
cylinder_part = cylinder.attachNewNode(cylinder_geomnode_part)
cylinder_parts.append(cylinder_part)
if parts > 1:
return (cylinder, cylinder_parts)
else:
return cylinder
def _make_fullscreen_quad(self):
tris = p3d.GeomTristrips(p3d.GeomEnums.UH_static)
tris.add_next_vertices(4)
vdata = p3d.GeomVertexData('abc', p3d.GeomVertexFormat.get_empty(),
p3d.GeomEnums.UH_static)
geom = p3d.Geom(vdata)
geom.add_primitive(tris)
geom.set_bounds(p3d.OmniBoundingVolume())
node = p3d.GeomNode(f'{self.name}_fullscreen_quad')
node.add_geom(geom)
return p3d.NodePath(node)
def test_geom_decompose_in_place():
vertex_data = core.GeomVertexData("", empty_format,
core.GeomEnums.UH_static)
prim = core.GeomTristrips(core.GeomEnums.UH_static)
prim.add_vertex(0)
prim.add_vertex(1)
prim.add_vertex(2)
prim.add_vertex(3)
prim.close_primitive()
geom = core.Geom(vertex_data)
geom.add_primitive(prim)
geom.decompose_in_place()
prim = geom.get_primitive(0)
assert tuple(prim.get_vertex_list()) == (0, 1, 2, 2, 1, 3)
def half_screen_quad():
vdata = p3d.GeomVertexData('half_screen_quad',
p3d.GeomVertexFormat.get_v3n3c4t2(),
p3d.Geom.UHStatic)
vdata.set_num_rows(4)
vertex = p3d.GeomVertexWriter(vdata, 'vertex')
normal = p3d.GeomVertexWriter(vdata, 'normal')
color = p3d.GeomVertexWriter(vdata, 'color')
texcoord = p3d.GeomVertexWriter(vdata, 'texcoord')
scale = 10
vertex.addData3f(-scale, 5, scale)
normal.addData3f(0, 1, 0)
color.addData4f(0.1, 0.2, 0.3, 1.0)
texcoord.addData2f(0.0, 0.0)
vertex.addData3f(0, 5, scale)
normal.addData3f(0, 1, 0)
color.addData4f(0.1, 0.2, 0.3, 1.0)
texcoord.addData2f(0.0, 0.1)
vertex.addData3f(0, 5, -scale)
normal.addData3f(0, 1, 0)
color.addData4f(0.1, 0.2, 0.3, 1.0)
texcoord.addData2f(0.0, 0.2)
vertex.addData3f(-scale, 5, -scale)
normal.addData3f(0, 1, 0)
color.addData4f(0.1, 0.2, 0.3, 1.0)
texcoord.addData2f(0.0, 0.3)
prim = p3d.GeomTriangles(p3d.Geom.UHStatic)
prim.addVertices(2, 1, 0)
prim.addVertices(0, 3, 2)
geom = p3d.Geom(vdata)
geom.addPrimitive(prim)
node = p3d.GeomNode('gnode')
node.addGeom(geom)
nodepath = p3d.NodePath(node)
return nodepath
def _make(vformat, vertices, faces):
vdata = p3d.GeomVertexData('#vdata', vformat, p3d.Geom.UHStatic)
vdata.unclean_set_num_rows(len(vertices))
vdata.modify_array_handle(0).set_subdata(0, len(vertices),
vertices.astype(np.float32))
prim = p3d.GeomTriangles(p3d.Geom.UHStatic)
prim.clear_vertices()
for v1, v2, v3 in faces:
prim.add_vertices(v1, v2, v3)
prim.close_primitive()
geom = p3d.Geom(vdata)
geom.add_primitive(prim)
node = p3d.GeomNode('#geom')
node.add_geom(geom)
return node
def _create_arrow_geom(self, headsize):
vertex_data = core.GeomVertexData('Arrows',
core.GeomVertexFormat.getV3(),
core.Geom.UH_static)
pos = core.GeomVertexWriter(vertex_data, 'vertex')
pos.addData3f(0, 0, 0)
pos.addData3f(0, 1, 0)
pos.addData3f(headsize, 1 - headsize, 0)
pos.addData3f(-headsize, 1 - headsize, 0)
lines = core.GeomLines(core.Geom.UH_static)
lines.addVertices(0, 1)
lines.addVertices(1, 2)
lines.addVertices(1, 3)
geom = core.Geom(vertex_data)
geom.addPrimitive(lines)
return geom
def _create_dot_geom(self, dot_rad, n_points):
vertex_data = core.GeomVertexData('DotsRad' + str(dot_rad),
core.GeomVertexFormat.getV3(),
core.Geom.UH_static)
pos = core.GeomVertexWriter(vertex_data, 'vertex')
pos.addData3f(0, 0, 0)
for i in range(n_points):
pos.addData3f(dot_rad * cos(2 * pi * i / n_points),
dot_rad * sin(2 * pi * i / n_points), 0)
triangles = core.GeomTriangles(core.Geom.UH_static)
for i in range(1, n_points):
triangles.addVertices(0, i, i + 1)
triangles.addVertices(0, n_points, 1)
geom = core.Geom(vertex_data)
geom.addPrimitive(triangles)
return geom
def make_arc(
scene: core.NodePath,
position: core.Point3,
radius: float,
theta_degrees: float,
point_count: int,
):
theta_radians = math.radians(theta_degrees)
vertex_data = _make_vertex_data(point_count + 1)
position_writer = core.GeomVertexWriter(vertex_data, "vertex")
colour_writer = core.GeomVertexWriter(vertex_data, "color")
position_writer.add_data3(position.x, position.y, position.z)
colour_writer.add_data4(1, 1, 1, 1)
for index in range(point_count):
theta = (theta_radians * index) / (point_count - 1)
x = math.cos(theta) * radius
y = math.sin(theta) * radius
position_writer.add_data3(position.x + x, position.y + y, position.z)
colour_writer.add_data4(1, 1, 1, 1)
primitive = core.GeomTriangles(core.Geom.UH_static)
total_point_count = point_count + 1
for index in range(point_count):
point_2 = (index + 1) % total_point_count
point_3 = (index + 2) % total_point_count
primitive.add_vertices(0, point_2, point_3)
primitive.close_primitive()
geometry = core.Geom(vertex_data)
geometry.add_primitive(primitive)
geometry_node = core.GeomNode("arc")
geometry_node.add_geom(geometry)
result: core.NodePath = scene.attach_new_node(geometry_node)
result.set_two_sided(True)
result.set_transparency(True)
return result
def test_geom_calc_box_bounds():
# Ensure that it ignores NaN
data = core.GeomVertexData("", core.GeomVertexFormat.get_v3(),
core.Geom.UH_static)
vertex = core.GeomVertexWriter(data, "vertex")
vertex.add_data3((float("NaN"), 0, 0))
vertex.add_data3((1, 1, 1))
vertex.add_data3((1, 1, 2))
prim = core.GeomPoints(core.Geom.UH_static)
prim.add_next_vertices(3)
geom = core.Geom(data)
geom.add_primitive(prim)
geom.set_bounds_type(core.BoundingVolume.BT_box)
bounds = geom.get_bounds()
assert isinstance(bounds, core.BoundingBox)
assert bounds.get_min() == (1, 1, 1)
assert bounds.get_max() == (1, 1, 2)
def test_geom_decompose():
vertex_data = core.GeomVertexData("", empty_format,
core.GeomEnums.UH_static)
prim = core.GeomTristrips(core.GeomEnums.UH_static)
prim.add_vertex(0)
prim.add_vertex(1)
prim.add_vertex(2)
prim.add_vertex(3)
prim.close_primitive()
geom = core.Geom(vertex_data)
geom.add_primitive(prim)
new_geom = geom.decompose()
new_prim = new_geom.get_primitive(0)
assert tuple(new_prim.get_vertex_list()) == (0, 1, 2, 2, 1, 3)
# Old primitive should still be unchanged
assert prim == geom.get_primitive(0)
def get_f_plane_node(v_matrix, list_x, list_y):
format = core.GeomVertexFormat.get_v3c4()
vdata = core.GeomVertexData('name', format, core.Geom.UHStatic)
vertex = core.GeomVertexWriter(vdata, 'vertex')
color = core.GeomVertexWriter(vdata, 'color')
geom = core.Geom(vdata)
node = core.GeomNode('f_node')
num_vertices = 0
for row in v_matrix:
num_vertices += len(row)
# vertices in f_plane + 3 axes
vdata.setNumRows(num_vertices + 6)
add_vertices(v_matrix, vertex, color)
add_lines(list_x, geom)
add_lines(list_y, geom)
add_axes(num_vertices, vertex, color, geom)
node.addGeom(geom)
return node
def cb_update_draw_calls(cbdata):
for np in self.temp_nps:
np.remove_node()
self.temp_nps = []
tex = self.draw_manager._indirect_buffer
gsg = self.win.get_gsg()
if self.graphics_engine.extract_texture_data(tex, gsg):
tex_view = memoryview(tex.get_ram_image()).cast('i')
for call_idx in range(tex.get_x_size()):
i = call_idx * 4
primcount = tex_view[i + 1]
first = tex_view[i + 2]
prims = p3d.GeomPoints(p3d.GeomEnums.UH_dynamic)
prims.add_next_vertices(primcount)
geom = p3d.Geom(vdata)
geom.add_primitive(prims)
geom.set_bounds(p3d.OmniBoundingVolume())
node = p3d.GeomNode('Draw Call {}'.format(call_idx))
node.add_geom(geom)
path = p3d.NodePath(node)
path.set_bin('fixed', 50)
path.set_depth_test(False)
path.set_depth_write(False)
path.set_shader(resolve_shader)
path.set_shader_input('first', first)
window_size = p3d.LVector2i(win_width, win_height)
path.set_shader_input('window_size', window_size)
path.set_shader_input('vertex_cache',
self.mesh_cache.vert_texture)
path.set_shader_input('index_cache',
self.mesh_cache.index_texture)
path.set_shader_input('intersections', self.int_texture)
self.material_cache.bind(path)
path.reparent_to(self.render)
self.temp_nps.append(path)
cbdata.upcall()
def _generate_pool(self, pool_size):
format = core.GeomVertexFormat()
format.add_array(core.GeomVertexFormat.get_v3().get_array(0))
format.add_array(
core.GeomVertexArrayFormat('offset', 2, core.GeomEnums.NT_float32,
core.GeomEnums.C_other, 'rotation', 2,
core.GeomEnums.NT_float32,
core.GeomEnums.C_other))
vdata = core.GeomVertexData(
'piiiyeeew', core.GeomVertexFormat.register_format(format),
core.GeomEnums.UH_static)
vdata.set_num_rows(pool_size)
writer = core.GeomVertexWriter(vdata, 'vertex')
for i in range(pool_size):
writer.set_data3(0, 0, -10000)
prim = core.GeomPoints(core.GeomEnums.UH_static)
prim.add_next_vertices(pool_size)
geom = core.Geom(vdata)
geom.add_primitive(prim)
self.geom_node.remove_all_geoms()
self.geom_node.add_geom(geom)
def add_geom(self, node, geom_obj):
if geom_obj.norms:
if geom_obj.texcoords:
if geom_obj.colors:
gformat = core.GeomVertexFormat.get_v3n3c4t2()
else:
gformat = core.GeomVertexFormat.get_v3n3t2()
else:
gformat = core.GeomVertexFormat.get_v3n3()
elif geom_obj.texcoords:
if geom_obj.colors:
gformat = core.GeomVertexFormat.get_v3c4t2()
else:
gformat = core.GeomVertexFormat.get_v3t2()
elif geom_obj.colors:
gformat = core.GeomVertexFormat.get_v3c4()
else:
gformat = core.GeomVertexFormat.get_v3()
data = core.GeomVertexData(node.getName(), gformat,
core.Geom.UH_static)
vertexWriter = core.GeomVertexWriter(data, 'vertex')
for coord in geom_obj.coords:
vertexWriter.addData3f(coord)
if geom_obj.norms:
normalWriter = core.GeomVertexWriter(data, 'normal')
for coord in geom_obj.coords:
normalWriter.addData3f(coord)
if geom_obj.colors:
colorWriter = core.GeomVertexWriter(data, 'color')
for coord in geom_obj.colors:
colorWriter.addData4f(coord)
for i in range(len(geom_obj.coords) - len(geom_obj.colors)):
colorWriter.addData4f(geom_obj.colors[-1])
if geom_obj.texcoords:
texCoordWriter = core.GeomVertexWriter(data, 'texcoord')
for coord in geom_obj.texcoords:
texCoordWriter.addData2f(coord)
tris = geom_obj.create_primitive()
if not tris:
return
k = 0
if isinstance(geom_obj, GeomPoint):
default_length = 1
else:
default_length = 3
geom = core.Geom(data)
for i in range(geom_obj.num_prims):
if geom_obj.prim_lengths:
length = geom_obj.prim_lengths[i]
else:
length = default_length
if geom_obj.vindex:
for j in range(length):
tris.addVertex(geom_obj.vindex[k + j])
else:
for j in range(length):
tris.addVertex(k + j)
tris.closePrimitive()
geom.addPrimitive(tris)
tris = geom_obj.create_primitive()
k += length
node.addGeom(geom)
def _add_geometry(
self,
all_geometry: sector_geometry.SectorGeometry,
height_callback: typing.Callable[[core.Vec2], float],
x_panning: float,
y_panning: float,
stat: map_data.sector.Stat,
shade: float,
part: sector_geometry.GeometryPart,
):
shade = self._shade_to_colour_channel(shade)
for sub_sector in drawing_sector.Sector(self._walls).get_sub_sectors():
polygon = drawing_sector.Sector.get_wall_bunch_points(sub_sector.outer_wall)
self._cleanup_polygon(polygon)
holes = []
for wall in sub_sector.inner_walls:
hole = drawing_sector.Sector.get_wall_bunch_points(wall)
self._cleanup_polygon(hole)
holes.append(hole)
triangulator = core.Triangulator()
for point in polygon:
index = triangulator.add_vertex(point.x, point.y)
triangulator.add_polygon_vertex(index)
for hole in holes:
triangulator.begin_hole()
for point in hole:
index = triangulator.add_vertex(point.x, point.y)
triangulator.add_hole_vertex(index)
triangulator.triangulate()
vertex_data = core.GeomVertexData(
"shape", constants.VERTEX_FORMAT, core.Geom.UH_static
)
vertex_data.set_num_rows(triangulator.get_num_vertices())
position_writer = core.GeomVertexWriter(vertex_data, "vertex")
colour_writer = core.GeomVertexWriter(vertex_data, "color")
texcoord_writer = core.GeomVertexWriter(vertex_data, "texcoord")
first_wall = self._walls[0]
direction_segment = first_wall.line_segment
first_wall_orthogonal = first_wall.get_orthogonal_vector()
orthogonal_segment = segment.Segment(
first_wall.point_1, first_wall.point_1 + first_wall_orthogonal
)
texture_size = all_geometry.get_tile_dimensions(part.picnum)
if texture_size.x < 1:
texture_size.x = 1
if texture_size.y < 1:
texture_size.y = 1
for point in triangulator.get_vertices():
point_2d = core.Point2(point.x, point.y)
position_writer.add_data3(
point_2d.x, point_2d.y, height_callback(point_2d)
)
colour_writer.add_data4(shade, shade, shade, 1)
if stat.align:
new_y = direction_segment.get_point_distance(
point_2d, ignore_on_line=True
)
new_x = orthogonal_segment.get_point_distance(
point_2d, ignore_on_line=True
)
point_2d = core.Point2(new_x, new_y)
if stat.swapxy:
y_offset = point_2d.x + x_panning
x_offset = point_2d.y + y_panning
else:
x_offset = point_2d.x + x_panning
y_offset = point_2d.y + y_panning
if stat.xflip:
x_offset = -x_offset
if stat.yflip:
y_offset = -y_offset
texture_coordinate_x = (x_offset / texture_size.x) / 16
texture_coordinate_y = (y_offset / texture_size.y) / 16
if stat.expand:
texture_coordinate_x *= 2
texture_coordinate_y *= 2
texcoord_writer.add_data2(texture_coordinate_x, texture_coordinate_y)
primitive = core.GeomTriangles(core.Geom.UH_static)
if part.is_floor:
for triangle_index in range(triangulator.get_num_triangles()):
primitive.add_vertices(
triangulator.get_triangle_v2(triangle_index),
triangulator.get_triangle_v1(triangle_index),
triangulator.get_triangle_v0(triangle_index),
)
else:
for triangle_index in range(triangulator.get_num_triangles()):
primitive.add_vertices(
triangulator.get_triangle_v0(triangle_index),
triangulator.get_triangle_v1(triangle_index),
triangulator.get_triangle_v2(triangle_index),
)
primitive.close_primitive()
geometry = core.Geom(vertex_data)
geometry.add_primitive(primitive)
if not stat.parallax and part.picnum != 504:
all_geometry.add_geometry(geometry, part)
else:
part.node = None
all_geometry.add_highlight_geometry(geometry, part.part)
def create_sphere(parent_node, units):
vdata = pcore.GeomVertexData('name', pcore.GeomVertexFormat.getV3t2(),
pcore.Geom.UHDynamic)
vertex_writer = pcore.GeomVertexWriter(vdata, 'vertex')
texcoord_writer = pcore.GeomVertexWriter(vdata, 'texcoord')
prim_wall = pcore.GeomTriangles(pcore.Geom.UHStatic)
vertex_count = 0
for i in range(units):
phi1 = i / float(units) * 2 * 3.1452
phi2 = (i + 1) / float(units) * 2 * 3.1452
for j in range(int(np.floor(units / 2))):
theta1 = j / float(units / 2) * 1 * 3.1452
theta2 = (j + 1) / float(units / 2) * 1 * 3.1452
x1 = math.cos(phi1) * math.sin(theta1)
y1 = math.sin(phi1) * math.sin(theta1)
z1 = math.cos(theta1)
x2 = math.cos(phi2) * math.sin(theta1)
y2 = math.sin(phi2) * math.sin(theta1)
z2 = math.cos(theta1)
x3 = math.cos(phi1) * math.sin(theta2)
y3 = math.sin(phi1) * math.sin(theta2)
z3 = math.cos(theta2)
x4 = math.cos(phi2) * math.sin(theta2)
y4 = math.sin(phi2) * math.sin(theta2)
z4 = math.cos(theta2)
vertex_writer.addData3f(x1, y1, z1)
vertex_writer.addData3f(x2, y2, z2)
vertex_writer.addData3f(x3, y3, z3)
texcoord_writer.addData2f(
math.sin(theta1) * math.cos(phi1),
math.sin(theta1) * math.sin(phi1))
texcoord_writer.addData2f(
math.sin(theta1) * math.cos(phi2),
math.sin(theta1) * math.sin(phi2))
texcoord_writer.addData2f(
math.sin(theta2) * math.cos(phi1),
math.sin(theta2) * math.sin(phi1))
vertex_count = vertex_count + 3
prim_wall.addConsecutiveVertices(vertex_count - 3, 3)
prim_wall.closePrimitive()
vertex_writer.addData3f(x2, y2, z2)
vertex_writer.addData3f(x3, y3, z3)
vertex_writer.addData3f(x4, y4, z4)
texcoord_writer.addData2f(
math.sin(theta1) * math.cos(phi2),
math.sin(theta1) * math.sin(phi2))
texcoord_writer.addData2f(
math.sin(theta2) * math.cos(phi1),
math.sin(theta2) * math.sin(phi1))
texcoord_writer.addData2f(
math.sin(theta2) * math.cos(phi2),
math.sin(theta2) * math.sin(phi2))
vertex_count = vertex_count + 3
prim_wall.addConsecutiveVertices(vertex_count - 3, 3)
prim_wall.closePrimitive()
geom_wall = pcore.Geom(vdata)
geom_wall.addPrimitive(prim_wall)
sphere = parent_node.attachNewNode("sphere")
sphere_geomnode = pcore.GeomNode("sphere")
sphere_geomnode.addGeom(geom_wall)
sphere_model = sphere.attachNewNode(sphere_geomnode)
return (sphere, sphere_model)
def node(self):
geom = core.Geom(self._vdata)
geom.add_primitive(self._prim)
node = core.GeomNode(self._name)
node.add_geom(geom)
return node
def drawLine(self, x1, y1, z1, x2, y2, z2):
# axis
vdata_line = pcore.GeomVertexData('vdata_line',
pcore.GeomVertexFormat.getV3(),
pcore.Geom.UHDynamic)
vertex_writer = pcore.GeomVertexWriter(vdata_line, 'vertex')
prim_line = pcore.GeomLines(pcore.Geom.UHStatic)
vertex_writer.addData3f(x1, y1, z1)
vertex_writer.addData3f(x2, y2, z2)
prim_line.addConsecutiveVertices(0, 2)
prim_line.closePrimitive()
geom_line = pcore.Geom(vdata_line)
geom_line.addPrimitive(prim_line)
line = self.cosy.attachNewNode("line")
line_geomnode = pcore.GeomNode("line")
line_geomnode.addGeom(geom_line)
line_model = line.attachNewNode(line_geomnode)
line.setRenderModeThickness(2)
# points
length = math.sqrt((x2 - x1)**2 + (y2 - y1)**2 + (z2 - z1)**2)
u1 = (x2 - x1) / length
u2 = (y2 - y1) / length
u3 = (z2 - z1) / length
vdata_points = pcore.GeomVertexData('vdata_points',
pcore.GeomVertexFormat.getV3(),
pcore.Geom.UHDynamic)
point_writer = pcore.GeomVertexWriter(vdata_points, 'vertex')
prim_points = pcore.GeomPoints(pcore.Geom.UHStatic)
for i in range(int(length)):
point_writer.addData3f(i * u1, i * u2, i * u3)
prim_points.addConsecutiveVertices(i, 1)
prim_points.closePrimitive()
#prim_points.addConsecutiveVertices(0, int(length))
#prim_points.closePrimitive()
geom_points = pcore.Geom(vdata_points)
geom_points.addPrimitive(prim_points)
points = self.cosy.attachNewNode("points")
points_geomnode = pcore.GeomNode("points")
points_geomnode.addGeom(geom_points)
points_model = points.attachNewNode(points_geomnode)
points.setRenderModeThickness(3)
return (line, line_model, points, points_model)
def render_color_pixel(region, state, vertex_color=None):
"""Renders a fragment using the specified render settings, and returns the
resulting color value."""
# Skip auto-shader tests if we don't support Cg shaders.
if not region.window.gsg.supports_basic_shaders:
sattr = state.get_attrib(core.ShaderAttrib)
if sattr and sattr.auto_shader():
pytest.skip("Cannot test auto-shader without Cg shader support")
# Set up the scene with a blank card rendering at specified distance.
scene = core.NodePath("root")
scene.set_attrib(core.DepthTestAttrib.make(core.RenderAttrib.M_always))
camera = scene.attach_new_node(core.Camera("camera"))
camera.node().get_lens(0).set_near_far(1, 3)
camera.node().set_cull_bounds(core.OmniBoundingVolume())
if vertex_color is not None:
format = core.GeomVertexFormat.get_v3cp()
else:
format = core.GeomVertexFormat.get_v3()
vdata = core.GeomVertexData("card", format, core.Geom.UH_static)
vdata.unclean_set_num_rows(4)
vertex = core.GeomVertexWriter(vdata, "vertex")
vertex.set_data3(core.Vec3.rfu(-1, 0, 1))
vertex.set_data3(core.Vec3.rfu(-1, 0, -1))
vertex.set_data3(core.Vec3.rfu(1, 0, 1))
vertex.set_data3(core.Vec3.rfu(1, 0, -1))
if vertex_color is not None:
color = core.GeomVertexWriter(vdata, "color")
color.set_data4(vertex_color)
color.set_data4(vertex_color)
color.set_data4(vertex_color)
color.set_data4(vertex_color)
strip = core.GeomTristrips(core.Geom.UH_static)
strip.set_shade_model(core.Geom.SM_uniform)
strip.add_next_vertices(4)
strip.close_primitive()
geom = core.Geom(vdata)
geom.add_primitive(strip)
gnode = core.GeomNode("card")
gnode.add_geom(geom, state)
card = scene.attach_new_node(gnode)
card.set_pos(0, 2, 0)
card.set_scale(60)
region.active = True
region.camera = camera
color_texture = core.Texture("color")
region.window.add_render_texture(color_texture,
core.GraphicsOutput.RTM_copy_ram,
core.GraphicsOutput.RTP_color)
region.window.engine.render_frame()
region.window.clear_render_textures()
col = core.LColor()
color_texture.peek().lookup(col, 0.5, 0.5)
return col
def _make_wall_part(
self,
all_geometry: sector_geometry.SectorGeometry,
peg: float,
floor_z_at_point_callback: typing.Callable[[core.Point2], float],
ceiling_z_at_point_callback: typing.Callable[[core.Point2], float],
part: sector_geometry.GeometryPart,
stat: map_data.wall.Stat = None,
):
if stat is None:
stat = self._wall.wall.stat
point_1_bottom = floor_z_at_point_callback(self.point_1)
point_2_bottom = floor_z_at_point_callback(self.point_2)
point_1_top = ceiling_z_at_point_callback(self.point_1)
point_2_top = ceiling_z_at_point_callback(self.point_2)
if point_1_top < point_1_bottom or point_2_top < point_2_bottom:
vertex_data = core.GeomVertexData(part.part,
constants.VERTEX_FORMAT,
core.Geom.UH_static)
vertex_data.set_num_rows(4)
position_writer = core.GeomVertexWriter(vertex_data, "vertex")
colour_write = core.GeomVertexWriter(vertex_data, "color")
texcoord_writer = core.GeomVertexWriter(vertex_data, "texcoord")
shade = self._shade_to_colour_channel(self.shade)
colour_write.add_data4(shade, shade, shade, 1)
colour_write.add_data4(shade, shade, shade, 1)
colour_write.add_data4(shade, shade, shade, 1)
colour_write.add_data4(shade, shade, shade, 1)
texture_size = all_geometry.get_tile_dimensions(part.picnum)
if texture_size.x < 1:
texture_size.x = 1
if texture_size.y < 1:
texture_size.y = 1
if stat.xflip:
texture_size.x = -texture_size.x
if stat.yflip:
texture_size.y = -texture_size.y
uv_1, uv_2, uv_3, uv_4 = self._get_texture_coordinates(
texture_size,
peg,
point_1_bottom,
point_1_top,
point_2_bottom,
point_2_top,
)
position_writer.add_data3(self.point_1.x, self.point_1.y,
point_1_bottom)
texcoord_writer.add_data2(uv_1)
position_writer.add_data3(self.point_1.x, self.point_1.y,
point_1_top)
texcoord_writer.add_data2(uv_2)
position_writer.add_data3(self.point_2.x, self.point_2.y,
point_2_top)
texcoord_writer.add_data2(uv_3)
position_writer.add_data3(self.point_2.x, self.point_2.y,
point_2_bottom)
texcoord_writer.add_data2(uv_4)
primitive = core.GeomTriangles(core.Geom.UH_static)
primitive.add_vertices(0, 2, 1)
primitive.add_vertices(0, 3, 2)
primitive.close_primitive()
geometry = core.Geom(vertex_data)
geometry.add_primitive(primitive)
all_geometry.add_geometry(geometry, part)
all_geometry.add_highlight_geometry(geometry,
f"{self._name}_{part.part}")
return True
return False
