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 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 create_node(self):
node = core.GeomNode(self.name)
for geom in self.get_geoms():
self.add_geom(node, geom)
return 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 reset(self):
if self._display is not None:
self._display_node = None
self._display.remove_node()
self._display = None
self._seen.clear()
if not self._map_scene.is_empty():
self._display_node = core.GeomNode("target_debug")
self._display = self._map_scene.attach_new_node(self._display_node)
self._display.set_transparency(True)
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 _init_trajectory(self):
# Create dots on ground
self.traj_dots_np = []
small_dot = self._create_dot_geom(1, 20)
big_dot = self._create_dot_geom(2, 50)
for i in range(12):
frame_idx = 10 * (i - 6)
geom_node = core.GeomNode('TrajPosFrame' + str(frame_idx))
geom_node.addGeom(big_dot)
nodepath = self.model_np.attachNewNode(geom_node)
nodepath.set_color(0.7, 0.4, 0.4)
nodepath.hide()
self.traj_dots_np.append(nodepath)
for j in range(1, 10):
frame_idx = 10 * (i - 6) + j
geom_node = core.GeomNode('TrajPosFrame' + str(frame_idx))
geom_node.addGeom(small_dot)
nodepath = self.model_np.attachNewNode(geom_node)
nodepath.set_color(0.7, 0.6, 0.6)
nodepath.hide()
self.traj_dots_np.append(nodepath)
# Create arrows
self.traj_arrs_np = []
arrow = self._create_arrow_geom(0.15)
for i in range(12):
frame_idx = 10 * (i - 6)
geom_node = core.GeomNode('TrajDirFrame' + str(frame_idx))
geom_node.addGeom(arrow)
nodepath = self.model_np.attachNewNode(geom_node)
nodepath.set_render_mode_thickness(3)
nodepath.set_color(0.7, 0.4, 0.4)
nodepath.hide()
self.traj_arrs_np.append(nodepath)
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 __init__(self,
render=None,
sprite_map='',
sprite_layout=(8, 8),
loop=True,
pool_size=1024,
check_bounds=False,
scale=0.02):
self.render = render or base.render
self.check_bounds = check_bounds
self.scale = scale
tex = base.loader.load_texture(sprite_map)
tex.set_minfilter(core.SamplerState.FT_nearest)
tex.set_magfilter(core.SamplerState.FT_nearest)
tex.set_wrap_u(core.SamplerState.WM_repeat if loop else core.
SamplerState.WM_clamp)
tex.set_wrap_v(core.SamplerState.WM_repeat)
self.geom_node = core.GeomNode('fireworks')
path = self.render.attach_new_node(self.geom_node)
path.set_render_mode_thickness(32)
path.set_texture(tex)
path.set_tex_gen(core.TextureStage.get_default(),
core.TexGenAttrib.M_point_sprite)
path.set_antialias(core.AntialiasAttrib.M_point)
path.set_depth_test(True)
path.set_depth_write(True)
path.set_z(1.0)
path.set_transparency(core.TransparencyAttrib.M_binary)
path.set_shader(
core.Shader.load(core.Shader.SL_GLSL, 'assets/shaders/bullet.vert',
'assets/shaders/bullet.frag'))
path.set_shader_input('sprite_layout', sprite_layout)
self.sprite_layout = sprite_layout
self.root = path
self._generate_pool(pool_size)
self.patterns = []
self.pool_usage = core.SparseArray()
self.clock = 0
self.colliders = []
self.accept('window-event', self._update_size)
self._update_size(base.win)
def make_z_grid(
camera_collection: cameras.Cameras,
name: str,
thickness: float,
segment_count: int,
colour: core.Vec4,
):
cache_path = f"bloom/pre_cache/vertical_{name}.bam"
if os.path.exists(cache_path):
return camera_collection.load_model_into_scene(cache_path)
grid_node = core.GeomNode(name)
grid: core.NodePath = camera_collection.scene.attach_new_node(grid_node)
half_segment_count = int(segment_count / 2)
cell_segments = core.LineSegs()
cell_segments.set_thickness(thickness)
cell_segments.set_color(colour)
cell_segments.draw_to(0, 0, -half_segment_count)
cell_segments.draw_to(0, 0, half_segment_count)
cell_segments.create(grid_node)
for z in range(segment_count):
cell_segments = core.LineSegs()
cell_segments.set_thickness(thickness)
cell_segments.set_color(colour)
offset = z - half_segment_count
cell_segments.draw_to(-0.125, -0.125, offset)
cell_segments.draw_to(-0.125, 0.125, offset)
cell_segments.draw_to(0.125, 0.125, offset)
cell_segments.draw_to(0.125, -0.125, offset)
cell_segments.draw_to(-0.125, -0.125, offset)
cell_segments.create(grid_node)
grid.flatten_strong()
grid.set_transparency(True)
grid.write_bam_file(cache_path)
return grid
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 __init__(
self,
start_sector: EditorSector,
camera_collection: cameras.Cameras,
clipping_debug: core.NodePath,
sector_offset=core.Point3(0, 0, 0),
):
self._start_sector = start_sector
self._clip_buffer = numpy.array([WallBunch.ABSOLUTE_MAX_Z] *
self._CLIP_WIDTH).astype("float32")
self._camera_collection = camera_collection
self._transformation_matrix = (
core.Mat4.translate_mat(-sector_offset.x, -sector_offset.y, 0) *
self._camera_collection.get_clipping_transform())
self._visible_sectors: typing.Set[EditorSector] = set()
self._sector_offset = sector_offset
self._clipping_debug = clipping_debug
if constants.PORTALS_DEBUGGING_ENABLED:
self._inverse_transformation_matrix = core.Mat4()
self._inverse_transformation_matrix.invert_from(
self._transformation_matrix)
self._clip_view: core.NodePath = self._clipping_debug.attach_new_node(
"clip_view")
self._clip_view.set_transparency(True)
self._clip_view.set_bin("fixed", constants.FRONT_MOST)
self._clip_card_maker = core.CardMaker("clip_view")
self._clip_buffer_colours = numpy.array(
[[0, 0, 0]] * self._CLIP_WIDTH).astype("float32")
self._debug_colour_index = 0
self._debug_geometry_node = core.GeomNode("clipper")
self._debug_geometry: core.NodePath = self._clipping_debug.attach_new_node(
self._debug_geometry_node)
self._debug_geometry.set_depth_write(False)
self._debug_geometry.set_depth_test(False)
self._debug_geometry.set_bin("fixed", constants.FRONT_MOST)
self._debug_geometry.set_transparency(True)
inverse_projection = core.Mat4().invert_from(
self._transformation_matrix)
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 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 make_grid(
camera_collection: cameras.Cameras,
name: str,
thickness: float,
line_count: int,
colour: core.Vec4,
):
cache_path = f"bloom/pre_cache/{name}.bam"
if os.path.exists(cache_path):
return camera_collection.load_model_into_scene(cache_path)
grid_node = core.GeomNode(name)
grid: core.NodePath = camera_collection.scene.attach_new_node(grid_node)
half_line_count = int(line_count / 2)
for x in range(line_count):
for y in range(line_count):
cell_segments = core.LineSegs()
cell_segments.set_thickness(thickness)
cell_segments.set_color(colour)
offset_x = x - half_line_count
offset_y = y - half_line_count
cell_segments.draw_to(offset_x, offset_y, 0)
cell_segments.draw_to(offset_x, offset_y + 1, 0)
cell_segments.draw_to(offset_x + 1, offset_y + 1, 0)
cell_segments.draw_to(offset_x + 1, offset_y, 0)
cell_segments.draw_to(offset_x, offset_y, 0)
cell_segments.create(grid_node)
grid.flatten_strong()
grid.set_transparency(True)
grid.write_bam_file(cache_path)
return grid
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 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 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 __init__(self, models):
ShowBase.ShowBase.__init__(self)
self.models = models
unique_meshes = set(m.mesh for m in models)
mesh2nodepath = {}
for mesh in unique_meshes:
scene_members = pcore.getSceneMembers(mesh)
rotateNode = p3d.GeomNode("rotater")
rotatePath = p3d.NodePath(rotateNode)
matrix = numpy.identity(4)
if mesh.assetInfo.upaxis == collada.asset.UP_AXIS.X_UP:
r = collada.scene.RotateTransform(0, 1, 0, 90)
matrix = r.matrix
elif mesh.assetInfo.upaxis == collada.asset.UP_AXIS.Y_UP:
r = collada.scene.RotateTransform(1, 0, 0, 90)
matrix = r.matrix
rotatePath.setMat(p3d.Mat4(*matrix.T.flatten().tolist()))
rbc = p3d.RigidBodyCombiner('combiner')
rbcPath = rotatePath.attachNewNode(rbc)
for geom, renderstate, mat4 in scene_members:
node = p3d.GeomNode("primitive")
node.addGeom(geom)
if renderstate is not None:
node.setGeomState(0, renderstate)
geomPath = rbcPath.attachNewNode(node)
geomPath.setMat(mat4)
rbc.collect()
mesh2nodepath[mesh] = centerAndScale(
rotatePath, print_bounds.getBoundsInfo(mesh))
scenepath = render.attachNewNode("scene")
for model in self.models:
np = mesh2nodepath[model.mesh]
instance = scenepath.attachNewNode("model")
np.instanceTo(instance)
instance.setPos(model.x, model.y, model.z)
instance.setScale(model.scale, model.scale, model.scale)
q = p3d.Quat()
q.setI(model.orient_x)
q.setJ(model.orient_y)
q.setK(model.orient_z)
q.setR(model.orient_w)
instance.setQuat(q)
base.camLens.setFar(sys.maxint)
base.camLens.setNear(8.0)
pcore.attachLights(render)
render.setShaderAuto()
render.setTransparency(p3d.TransparencyAttrib.MDual, 1)
render.setAntialias(p3d.AntialiasAttrib.MAuto)
controls.KeyboardMovement()
controls.ButtonUtils(scenepath)
controls.MouseDrag(scenepath)
controls.MouseCamera()
controls.MouseScaleZoom(scenepath)
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 node(self):
geom = core.Geom(self._vdata)
geom.add_primitive(self._prim)
node = core.GeomNode(self._name)
node.add_geom(geom)
return node
