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