class RotationAxis(VisibleObject): default_shown = False ignore_light = True def __init__(self, body): VisibleObject.__init__(self, body.get_ascii_name() + '-axis') self.body = body def create_instance(self): self.vertexData = GeomVertexData('vertexData', GeomVertexFormat.getV3(), Geom.UHStatic) self.vertexWriter = GeomVertexWriter(self.vertexData, 'vertex') radius = 1.0 top = LPoint3d(0, 0, radius * 1.25) north_pole = LPoint3d(0, 0, radius) south_pole = LPoint3d(0, 0, -radius) bottom = LPoint3d(0, 0, -radius * 1.25) self.vertexWriter.addData3f(*top) self.vertexWriter.addData3f(*north_pole) self.vertexWriter.addData3f(*south_pole) self.vertexWriter.addData3f(*bottom) self.lines = GeomLines(Geom.UHStatic) self.lines.addVertex(0) self.lines.addVertex(1) self.lines.addVertex(2) self.lines.addVertex(3) self.lines.closePrimitive() self.geom = Geom(self.vertexData) self.geom.addPrimitive(self.lines) self.node = GeomNode(self.body.get_ascii_name() + '-axis') self.node.addGeom(self.geom) self.instance = NodePath(self.node) self.instance.setRenderModeThickness(settings.axis_thickness) self.instance.setColor(self.parent.get_orbit_color()) self.instance.setAntialias(AntialiasAttrib.MMultisample) self.instance.reparentTo(self.context.annotation) def check_settings(self): self.set_shown(settings.show_rotation_axis) def check_visibility(self, pixel_size): if self.parent.shown: distance_to_obs = self.parent.distance_to_obs if distance_to_obs > 0.0: size = self.parent.get_apparent_radius() / (distance_to_obs * pixel_size) else: size = 0.0 self.visible = size > settings.axis_fade else: self.visible = False def update_instance(self, camera_pos, orientation): if self.instance: self.place_instance(self.instance, self.parent) def get_scale(self): return self.body.get_scale()
def __init__(self, max_r): self.max_r = max_r format = GeomVertexFormat.getV3c4() vdata = GeomVertexData('point', format, Geom.UHDynamic) self._pos_writer = GeomVertexWriter(vdata, 'vertex') self._color_writer = GeomVertexWriter(vdata, 'color') line_num = 60 vdata.setNumRows(line_num) angles = np.linspace(0, np.pi * 2 - np.pi * 2 / line_num, line_num) other_rgba = (0., 0., 0.3, 0.1) other2_rgba = (0.1, 0.1, 0.4, 0.4) axis_rgba = (0.2, 0.2, 0.5, 1.0) max_r = 250 for indx, angle in enumerate(angles): if indx % 5 == 0: rgba = axis_rgba else: rgba = other_rgba self._pos_writer.addData3d(0, 0, 0.) self._color_writer.addData4f(rgba[0], rgba[1], rgba[2], rgba[3]) self._pos_writer.addData3d(max_r * np.sin(angle), max_r * np.cos(angle), 0.) self._color_writer.addData4f(rgba[0], rgba[1], rgba[2], rgba[3]) grnd_prmtv = GeomLines(Geom.UHStatic) grnd_prmtv.addConsecutiveVertices(0, 2 * line_num) grnd_prmtv.closePrimitive() ground_geom = Geom(vdata) ground_geom.addPrimitive(grnd_prmtv) snode = GeomNode('ground_lines') snode.addGeom(ground_geom) self.points_node = base.render.attachNewNode(snode) self.points_node.setTwoSided(True) for rad in range(int(max_r)): color = axis_rgba pp = makeArc(angleDegrees=360, numSteps=160, scale=rad, color=color) tn = TextNode('dd') tn.setText(str(rad)) tn.setTextScale(0.2) tn.setTextColor(color) text_geom = GeomNode('text') text_geom.addChild(tn) tp = NodePath(text_geom) tp.setPos((0, rad - 0.2, 0)) tp.setHpr((0, -90, 0)) tp.reparentTo(self.points_node) pp.reparentTo(self.points_node)
def update_geometry(self): # The geosphere itself vertex = GeomVertexWriter(self.sphere_vdata, 'vertex') normal = GeomVertexWriter(self.sphere_vdata, 'normal') # u_map and v_map are in [-pi, pi] u_map_list = [(float(u) / float(self.res[0]) - 0.5) * 2.0 * pi for u in range(0, self.res[0] + 1)] v_map_list = [(float(v) / float(self.res[1]) - 0.5) * 2.0 * pi for v in range(0, self.res[1] + 1)] if self.unwrap_state == 0.0: # Flat map for v_map in v_map_list: for u_map in u_map_list: vertex.addData3f(u_map, 0.0, v_map / 2.0) normal.addData3f(0.0, -1.0, 0.0) else: # Non-flat map sphere_radius = 1.0 / self.unwrap_state sphere_offset = sphere_radius - self.unwrap_state for v_map in v_map_list: for u_map in u_map_list: u_sphere = u_map / sphere_radius v_sphere = v_map / sphere_radius # And this, kids, is why you should pay attention in trigonometry. v_x, v_y, v_z = sin(u_sphere) * cos(v_sphere/2.0) * sphere_radius, \ -cos(u_sphere) * cos(v_sphere/2.0) * sphere_radius + sphere_offset, \ sin(v_sphere / 2.0) * sphere_radius n_x_un, n_y_un, n_z_un = v_x, sphere_offset - v_y, v_z # FIXME: This is a lie. length = sqrt(n_x_un**2 + n_y_un**2 + n_z_un**2) n_x, n_y, n_z = n_x_un / length, n_y_un / length, n_z_un / length vertex.addData3f(v_x, v_y, v_z) normal.addData3f(n_x, n_y, n_z) # The connections between bases segs_per_connection = 30 vertex = GeomVertexWriter(self.connections_vdata, 'vertex') color = GeomVertexWriter(self.connections_vdata, 'color') for c_1_uv, c_2_uv in self.connections: # s will be [0.0, 1.0] for s in [float(c)/float(segs_per_connection+1) for c in range(0, segs_per_connection+2)]: u = (c_1_uv[0] * s) + (c_2_uv[0] * (1.0 - s)) v = (c_1_uv[1] * s) + (c_2_uv[1] * (1.0 - s)) (v_x, v_y, v_z), (n_x, n_y, n_z) = self.uv_to_xyz(u, v) min_height = 0.0001 * (1.0 - self.unwrap_state) max_height = (0.2 - min_height) * self.unwrap_state seg_height = (1.0 - (abs(s-0.5) * 2.0)**2.0) * max_height + min_height vertex.addData3f(v_x + n_x*seg_height, v_y + n_y*seg_height, v_z + n_z*seg_height) color.addData4f(1, 1, 1, 1) for c in range(0, len(self.connections)): for s in range(0, segs_per_connection+1): seg = GeomLines(Geom.UHDynamic) seg.addVertices(c*(segs_per_connection+2) + s, c*(segs_per_connection+2) + s + 1) seg.closePrimitive() self.connections_geom.addPrimitive(seg)
def makeGeomNode(): vdata = GeomVertexData('handleData', GeomVertexFormat.getV3(), Geom.UHStatic) v = GeomVertexWriter(vdata, 'vertex') length = 1.0 gapLen = 0.2 coneLen = 0.18 coneRad = 0.06 circRes = 10 v.addData3f(0, 0, -length/2.0) # back cone butt v.addData3f(0, 0, -length/2.0 + coneLen) # back cone point v.addData3f(0, 0, -gapLen/2.0) v.addData3f(0, 0, gapLen/2.0) v.addData3f(0, 0, length/2.0 - coneLen) # front cone butt v.addData3f(0, 0, length/2.0) # font cone point # Add vertices for the cone's circles. for z in [-length/2.0, length/2.0 - coneLen]: for i in xrange(circRes): theta = i*(2*pi/circRes) v.addData3f(coneRad*sin(theta), coneRad*cos(theta), z) lines = Geom(vdata) # Make prims for the two lines. for vertices in [(0, 2), (3, 5)]: line = GeomLines(Geom.UHStatic) line.addVertices(*vertices) line.closePrimitive() lines.addPrimitive(line) cones = Geom(vdata) # Make prims for the cones. for back, circ in [(0, 6), (4, 6 + circRes)]: point = back + 1 cone = GeomTriangles(Geom.UHStatic) for i in xrange(circRes): if i + 1 == circRes: cone.addVertices(back, circ, circ + i) cone.addVertices(point, circ + i, circ) else: cone.addVertices(back, circ + i + 1, circ + i) cone.addVertices(point, circ + i, circ + i + 1) cone.closePrimitive() cones.addPrimitive(cone) node = GeomNode('geomnode') node.addGeom(lines) node.addGeom(cones) return node
def makeGeomNode(): vdata = GeomVertexData('handleData', GeomVertexFormat.getV3(), Geom.UHStatic) v = GeomVertexWriter(vdata, 'vertex') length = 1.0 gapLen = 0.2 coneLen = 0.18 coneRad = 0.06 circRes = 10 v.addData3f(0, 0, -length / 2.0) # back cone butt v.addData3f(0, 0, -length / 2.0 + coneLen) # back cone point v.addData3f(0, 0, -gapLen / 2.0) v.addData3f(0, 0, gapLen / 2.0) v.addData3f(0, 0, length / 2.0 - coneLen) # front cone butt v.addData3f(0, 0, length / 2.0) # font cone point # Add vertices for the cone's circles. for z in [-length / 2.0, length / 2.0 - coneLen]: for i in xrange(circRes): theta = i * (2 * pi / circRes) v.addData3f(coneRad * sin(theta), coneRad * cos(theta), z) lines = Geom(vdata) # Make prims for the two lines. for vertices in [(0, 2), (3, 5)]: line = GeomLines(Geom.UHStatic) line.addVertices(*vertices) line.closePrimitive() lines.addPrimitive(line) cones = Geom(vdata) # Make prims for the cones. for back, circ in [(0, 6), (4, 6 + circRes)]: point = back + 1 cone = GeomTriangles(Geom.UHStatic) for i in xrange(circRes): if i + 1 == circRes: cone.addVertices(back, circ, circ + i) cone.addVertices(point, circ + i, circ) else: cone.addVertices(back, circ + i + 1, circ + i) cone.addVertices(point, circ + i, circ + i + 1) cone.closePrimitive() cones.addPrimitive(cone) node = GeomNode('geomnode') node.addGeom(lines) node.addGeom(cones) return node
class Boundary(VisibleObject): ignore_light = True default_shown = True def __init__(self, name, points=[], color=None): VisibleObject.__init__(self, name) self.visible = True if color is None: color = bodyClasses.get_orbit_color('boundary') self.color = color self.points = points def check_settings(self): self.set_shown(settings.show_boundaries) def set_points_list(self, points): self.points = points def create_instance(self): self.vertexData = GeomVertexData('vertexData', GeomVertexFormat.getV3c4(), Geom.UHStatic) self.vertexWriter = GeomVertexWriter(self.vertexData, 'vertex') self.colorwriter = GeomVertexWriter(self.vertexData, 'color') for point in self.points: position = point.project(0, self.context.observer.camera_global_pos, self.context.observer.infinity) self.vertexWriter.addData3f(*position) self.colorwriter.addData4f(*self.color) self.lines = GeomLines(Geom.UHStatic) index = 0 for i in range(len(self.points) - 1): self.lines.addVertex(index) self.lines.addVertex(index + 1) self.lines.closePrimitive() index += 1 self.geom = Geom(self.vertexData) self.geom.addPrimitive(self.lines) self.node = GeomNode("boundary") self.node.addGeom(self.geom) self.instance = NodePath(self.node) self.instance.setRenderModeThickness(settings.boundary_thickness) self.instance.reparentTo(self.context.annotation) self.instance.setBin('background', settings.boundaries_depth) self.instance.set_depth_write(False)
def getGeomFromPrim(prim, matstate): if type(prim) is collada.triangleset.TriangleSet: (vdata, gprim) = getPrimAndDataFromTri(prim, matstate) elif type(prim) is collada.polylist.Polylist or type(prim) is collada.polygons.Polygons: triset = prim.triangleset() (vdata, gprim) = getPrimAndDataFromTri(triset, matstate) elif type(prim) is collada.lineset.LineSet: vdata, indexdata = getVertexData(prim.vertex, prim.vertex_index) gprim = GeomLines(Geom.UHStatic) gprim.setIndexType(Geom.NTUint32) gprim.setVertices(indexdata) gprim.closePrimitive() else: raise Exception("Error: Unsupported primitive type. Exiting.") pgeom = Geom(vdata) pgeom.addPrimitive(gprim) return pgeom
class CartesianBasis(GeomNode): def __init__(self, length=1., tickness=3.): GeomNode.__init__(self, "Basis") self.vertexData = GeomVertexData("Basis", GeomVertexFormat.getV3c4(), Geom.UHStatic) self.vertex = GeomVertexWriter(self.vertexData, 'vertex') self.color = GeomVertexWriter(self.vertexData, 'color') self.mesh = Geom(self.vertexData) self.lines = GeomLines(Geom.UHStatic) self.vertex.addData3f(0.0, 0.0, 0.0) self.color.addData4f(1.0, 0.0, 0.0, 1.0) self.vertex.addData3f(length, 0.0, 0.0) self.color.addData4f(1.0, 0.0, 0.0, 1.0) self.lines.add_vertices(0, 1) self.vertex.addData3f(0.0, 0.0, 0.0) self.color.addData4f(0.0, 1.0, 0.0, 1.0) self.vertex.addData3f(0.0, length, 0.0) self.color.addData4f(0.0, 1.0, 0.0, 1.0) self.lines.add_vertices(2, 3) self.vertex.addData3f(0.0, 0.0, 0.0) self.color.addData4f(0.0, 0.0, 1.0, 1.0) self.vertex.addData3f(0.0, 0.0, length) self.color.addData4f(0.0, 0.0, 1.0, 1.0) self.lines.add_vertices(4, 5) self.lines.closePrimitive() self.mesh.addPrimitive(self.lines) self.addGeom(self.mesh) NodePath(self).setRenderModeThickness(tickness) NodePath(self).setLightOff() NodePath(self).setColorOff() NodePath(self).set_bin('fixed', 9)
class Orbit(VisibleObject): ignore_light = True default_shown = False selected_color = LColor(1.0, 0.0, 0.0, 1.0) def __init__(self, body): VisibleObject.__init__(self, body.get_ascii_name() + '-orbit') self.body = body self.nbOfPoints = 360 self.orbit = self.find_orbit(self.body) self.color = None self.fade = 0.0 if not self.orbit: print("No orbit for", self.get_name()) self.visible = False self.check_settings() def check_settings(self): if self.body.body_class is None: print("No class for", self.body.get_name()) return self.set_shown(settings.show_orbits and bodyClasses.get_show_orbit(self.body.body_class)) def find_orbit(self, body): if body != None: if not isinstance(body.orbit, FixedOrbit): return body.orbit else: return None, None else: return None, None def set_selected(self, selected): if selected: self.color = self.selected_color else: self.color = self.parent.get_orbit_color() if self.instance: self.instance.setColor(self.color * self.fade) def create_instance(self): if not self.orbit: return self.vertexData = GeomVertexData('vertexData', GeomVertexFormat.getV3(), Geom.UHStatic) self.vertexWriter = GeomVertexWriter(self.vertexData, 'vertex') delta = self.body.parent.get_local_position() for i in range(self.nbOfPoints): time = self.orbit.period / self.nbOfPoints * i pos = self.orbit.get_position_at(time) rot = self.orbit.get_rotation_at(time) pos = self.orbit.frame.get_local_position(rot.xform(pos)) - delta self.vertexWriter.addData3f(*pos) self.lines = GeomLines(Geom.UHStatic) for i in range(self.nbOfPoints - 1): self.lines.addVertex(i) self.lines.addVertex(i + 1) self.lines.closePrimitive() self.lines.addVertex(self.nbOfPoints - 1) self.lines.addVertex(0) self.lines.closePrimitive() self.geom = Geom(self.vertexData) self.geom.addPrimitive(self.lines) self.node = GeomNode(self.body.get_ascii_name() + '-orbit') self.node.addGeom(self.geom) self.instance = NodePath(self.node) self.instance.setRenderModeThickness(settings.orbit_thickness) self.instance.setCollideMask(GeomNode.getDefaultCollideMask()) self.instance.node().setPythonTag('owner', self) self.instance.reparentTo(self.context.annotation_shader) if self.color is None: self.color = self.parent.get_orbit_color() self.instance.setColor(self.color * self.fade) self.instance.setAntialias(AntialiasAttrib.MMultisample) self.appearance = ModelAppearance(attribute_color=True) if settings.use_inv_scaling: vertex_control = LargeObjectVertexControl() else: vertex_control = None self.instance_ready = True self.shader = BasicShader(lighting_model=FlatLightingModel(), vertex_control=vertex_control) self.shader.apply(self, self.appearance) self.shader.update(self, self.appearance) def check_visibility(self, pixel_size): if self.parent.shown and self.orbit: distance_to_obs = self.parent.distance_to_obs if distance_to_obs > 0.0: size = self.orbit.get_apparent_radius() / (distance_to_obs * pixel_size) else: size = 0.0 self.visible = size > settings.orbit_fade self.fade = min( 1.0, max(0.0, (size - settings.orbit_fade) / settings.orbit_fade)) if self.color is not None and self.instance is not None: self.instance.setColor(self.color * self.fade) else: self.visible = False def update_instance(self, camera_pos, orientation): if self.instance: self.place_instance_params(self.instance, self.body.parent.scene_position, self.body.parent.scene_scale_factor, LQuaternion()) self.shader.update(self, self.appearance)
class Asterism(VisibleObject): def __init__(self, name): VisibleObject.__init__(self, name) self.visible = True self.color = bodyClasses.get_orbit_color('constellation') self.position = LPoint3d(0, 0, 0) self.segments = [] self.position = None def check_settings(self): self.set_shown(settings.show_asterisms) def set_segments_list(self, segments): self.segments = segments ra_sin = 0 ra_cos = 0 decl = 0 if len(self.segments) > 0 and len(self.segments[0]) > 0: for star in self.segments[0]: asc = star.orbit.get_right_asc() ra_sin += sin(asc) ra_cos += cos(asc) decl += star.orbit.get_declination() ra = atan2(ra_sin, ra_cos) decl /= len(self.segments[0]) self.position = InfinitePosition(right_asc=ra, right_asc_unit=units.Rad, declination=decl, declination_unit=units.Rad) def create_instance(self): self.vertexData = GeomVertexData('vertexData', GeomVertexFormat.getV3c4(), Geom.UHStatic) self.vertexWriter = GeomVertexWriter(self.vertexData, 'vertex') self.colorwriter = GeomVertexWriter(self.vertexData, 'color') #TODO: Ugly hack to calculate star position from the sun... old_cam_pos = self.context.observer.camera_global_pos self.context.observer.camera_global_pos = LPoint3d() center = LPoint3d() for segment in self.segments: if len(segment) < 2: continue for star in segment: #TODO: Temporary workaround to have star pos star.update(0) star.update_obs(self.context.observer) position, distance, scale_factor = self.get_real_pos_rel( star.rel_position, star.distance_to_obs, star.vector_to_obs) self.vertexWriter.addData3f(*position) self.colorwriter.addData4f(*self.color) self.context.observer.camera_global_pos = old_cam_pos self.lines = GeomLines(Geom.UHStatic) index = 0 for segment in self.segments: if len(segment) < 2: continue for i in range(len(segment) - 1): self.lines.addVertex(index) self.lines.addVertex(index + 1) self.lines.closePrimitive() index += 1 index += 1 self.geom = Geom(self.vertexData) self.geom.addPrimitive(self.lines) self.node = GeomNode("asterism") self.node.addGeom(self.geom) self.instance = NodePath(self.node) self.instance.setRenderModeThickness(settings.asterism_thickness) self.instance.reparentTo(self.context.annotation) self.instance.setBin('background', settings.asterisms_depth) self.instance.set_depth_write(False)
class Grid(VisibleObject): ignore_light = True default_shown = False def __init__(self, name, orientation, color): VisibleObject.__init__(self, name) self.visible = True self.nbOfPoints = 360 self.nbOfRings = 17 self.nbOfSectors = 24 self.points_to_remove = (self.nbOfPoints // (self.nbOfRings + 1)) // 2 self.orientation = orientation self.color = color def create_instance(self): self.vertexData = GeomVertexData('vertexData', GeomVertexFormat.getV3c4(), Geom.UHStatic) self.vertexWriter = GeomVertexWriter(self.vertexData, 'vertex') self.colorwriter = GeomVertexWriter(self.vertexData, 'color') for r in range(1, self.nbOfRings + 1): for i in range(self.nbOfPoints): angle = 2 * pi / self.nbOfPoints * i x = cos(angle) * sin(pi * r / (self.nbOfRings + 1)) y = sin(angle) * sin(pi * r / (self.nbOfRings + 1)) z = sin(-pi / 2 + pi * r / (self.nbOfRings + 1)) self.vertexWriter.addData3f( (self.context.observer.infinity * x, self.context.observer.infinity * y, self.context.observer.infinity * z)) if r == self.nbOfRings / 2 + 1: self.colorwriter.addData4f(self.color.x * 1.5, 0, 0, 1) else: self.colorwriter.addData4f(*self.color) for s in range(self.nbOfSectors): for i in range(self.points_to_remove, self.nbOfPoints // 2 - self.points_to_remove + 1): angle = 2 * pi / self.nbOfPoints * i x = cos(2 * pi * s / self.nbOfSectors) * sin(angle) y = sin(2 * pi * s / self.nbOfSectors) * sin(angle) z = cos(angle) self.vertexWriter.addData3f( (self.context.observer.infinity * x, self.context.observer.infinity * y, self.context.observer.infinity * z)) if s == 0: self.colorwriter.addData4f(self.color.x * 1.5, 0, 0, 1) else: self.colorwriter.addData4f(*self.color) self.lines = GeomLines(Geom.UHStatic) index = 0 for r in range(self.nbOfRings): for i in range(self.nbOfPoints - 1): self.lines.addVertex(index) self.lines.addVertex(index + 1) self.lines.closePrimitive() index += 1 self.lines.addVertex(index) self.lines.addVertex(index - self.nbOfPoints + 1) self.lines.closePrimitive() index += 1 for r in range(self.nbOfSectors): for i in range(self.nbOfPoints // 2 - self.points_to_remove * 2): self.lines.addVertex(index) self.lines.addVertex(index + 1) self.lines.closePrimitive() index += 1 index += 1 self.geom = Geom(self.vertexData) self.geom.addPrimitive(self.lines) self.node = GeomNode("grid") self.node.addGeom(self.geom) self.instance = NodePath(self.node) self.instance.setRenderModeThickness(settings.grid_thickness) #myMaterial = Material() #myMaterial.setEmission((1.0, 1.0, 1.0, 1)) #self.instance.setMaterial(myMaterial) self.instance.reparentTo(self.context.annotation) self.instance.setQuat(LQuaternion(*self.orientation)) def set_orientation(self, orientation): self.orientation = orientation if self.instance: self.instance.setQuat(LQuaternion(*self.orientation))
class Grid(GeomNode): def __init__(self, x_extend=None, y_extend=None, x_size=1, y_size=1, z=-0.01, tickness=1., name='Grid', x_color=None, y_color=None): GeomNode.__init__(self, name) if x_color is None: x_color = LVector4f(1.0, 1.0, 1.0, 1.0) if y_color is None: y_color = LVector4f(1.0, 1.0, 1.0, 1.0) if x_extend is None: x_extend = [0, 10] if y_extend is None: y_extend = [0, 10] self.vertexData = GeomVertexData("Chunk", GeomVertexFormat.getV3c4(), Geom.UHStatic) self.vertex = GeomVertexWriter(self.vertexData, 'vertex') self.color = GeomVertexWriter(self.vertexData, 'color') self.mesh = Geom(self.vertexData) self.lines = GeomLines(Geom.UHStatic) nb_lines_x = int((x_extend[1] - x_extend[0]) / x_size) nb_lines_y = int((y_extend[1] - y_extend[0]) / y_size) vertex_nb = 0 for ix in range(nb_lines_x): for iy in range(nb_lines_y): x = x_extend[0] + ix * x_size y = y_extend[0] + iy * y_size self.vertex.addData3f(x, y, z) self.color.addData4f(x_color) self.vertex.addData3f(x + x_size, y, z) self.color.addData4f(x_color) self.vertex.addData3f(x, y, z) self.color.addData4f(y_color) self.vertex.addData3f(x, y + y_size, z) self.color.addData4f(y_color) self.lines.add_vertices(vertex_nb, vertex_nb + 1, vertex_nb + 2, vertex_nb + 3) vertex_nb += 4 self.lines.closePrimitive() self.mesh.addPrimitive(self.lines) self.addGeom(self.mesh) NodePath(self).setRenderModeThickness(tickness) NodePath(self).setLightOff() NodePath(self).setColorOff() NodePath(self).set_bin('fixed', 8)
class Planetimpl(): def __init__(self, world, size, distance, ratio, description, rotation, translation): self.worldOrigin = world self.size = size self.distance = distance self.renderRatio = ratio self.description = description self.rotation = rotation self.translation = translation def impl(self): # Load the Moon model self.planet = loader.loadModel("models/planet_sphere") self.chooseTexture("models/"+self.description+"_1k_tex.jpg") self.planet.reparentTo(self.worldOrigin) self.planet.setScale(self.size * self.renderRatio) self.planet.setPos(self.distance * self.renderRatio, 0.0, 0.0) self.planet.setTag('targetSize', str(self.size)) self.planet.setTag('isPickable', '2') self.startstop = True return self.planet def chooseTexture(self, name): """ Methode zum Setzen der Ursprungstextur """ self.planet.setTexture(loader.loadTexture(name), 1) def line(self): # Create and populate the Moon orbit model using Vertices and Lines self.planetOrbitVertexData = GeomVertexData(self.description+'OrbitVertexData', GeomVertexFormat.getV3(), Geom.UHDynamic) self.planetOrbitVertexWriter = GeomVertexWriter(self.planetOrbitVertexData, 'vertex') self.planetOrbitNumberPoints = 360 for i in range(self.planetOrbitNumberPoints): angleDegrees = i * 360 / self.planetOrbitNumberPoints angleRadians = angleDegrees * (pi / 180.0) x = -self.distance * sin(angleRadians) y = self.distance * cos(angleRadians) self.planetOrbitVertexWriter.addData3f(x, y, 0.0) self.planetOrbitLines = GeomLines(Geom.UHStatic) for i in range(self.planetOrbitNumberPoints-1): self.planetOrbitLines.addVertex(i) self.planetOrbitLines.addVertex(i+1) self.planetOrbitLines.closePrimitive() self.planetOrbitLines.addVertex(self.planetOrbitNumberPoints-1) self.planetOrbitLines.addVertex(0) self.planetOrbitLines.closePrimitive() self.planetOrbitGeom = Geom(self.planetOrbitVertexData) self.planetOrbitGeom.addPrimitive(self.planetOrbitLines) self.planetOrbitNode = GeomNode(self.description+'OrbitNode') self.planetOrbitNode.addGeom(self.planetOrbitGeom) self.planetOrbitNnodePath = render.attachNewNode(self.planetOrbitNode) self.planetOrbitNnodePath.reparentTo(self.worldOrigin) return self.planetOrbitVertexWriter def setstartstop(self): self.startstop = not self.startstop return self.startstop def rotatePlanet(self, task): # Compute earth rotation frameTime = globalClock.getFrameTime() angleDegrees = frameTime * self.rotation self.planet.setHpr(angleDegrees, 0, 0) # End task if self.startstop: return Task.cont else: return Task.done def translatePlanet(self, task): # Compute Moon position relative to Earth with circular orbit frameTime = globalClock.getFrameTime() angleDegrees = frameTime * self.translation angleRadians = angleDegrees * (pi / 180.0) # Compute the Moon's position with respect to the Earth x = -self.distance * self.renderRatio * sin(angleRadians) y = self.distance * self.renderRatio * cos(angleRadians) # Set the position on the model self.planet.setPos(x, y, 0.0) # Also rotate the orbit to follow the Moon and eliminate jitter effect self.planetOrbitVertexWriter.setRow(0) for i in range(self.planetOrbitNumberPoints): angleDegrees = angleDegrees + 360.0 / self.planetOrbitNumberPoints angleRadians = angleDegrees * (pi / 180.0) x = -self.distance * self.renderRatio * sin(angleRadians) y = self.distance * self.renderRatio * cos(angleRadians) self.planetOrbitVertexWriter.setData3f(x, y, 0.0) # End task if self.startstop: return Task.cont else: return Task.done
def _build_grid(self): color = getattr(self.parameters, "color", (0, 0, 0, 0)) node = NodePath(self.identifier) sx = self.grid.maxx - self.grid.minx + 1 sy = self.grid.maxy - self.grid.miny + 1 # 1. the squares squares = {} card = CardMaker('') cardgeom = NodePath(card.generate()) for n in range(sx): for nn in range(sy): square = NodePath(self.identifier + '-square-%d-%d' % (n + 1, nn + 1)) cardgeom.instanceTo(square) square.setPos(float(n) / sx, 0, -float(nn + 1) / sy) square.setScale(1.0 / sx, 1, 1.0 / sy) square.setColor(0, 0, 0, 1) square.reparentTo(node) squares[n, nn] = square #2: the lines gnode = GeomNode(self.identifier + "-lines") vformat = GeomVertexFormat.getV3cp() vdata = GeomVertexData(self.identifier + '-lines', vformat, Geom.UHStatic) v_vertex = GeomVertexWriter(vdata, 'vertex') v_colors = GeomVertexWriter(vdata, 'color') for n in range(sx + 1): px = float(n) / sx v_vertex.addData3f(px, 0.0, 0.0) v_colors.addData4f(*color) v_vertex.addData3f(px, 0, -1) v_colors.addData4f(*color) for n in range(sy + 1): py = float(n) / sy v_vertex.addData3f(0.0, 0.0, -py) v_colors.addData4f(*color) v_vertex.addData3f(1.0, 0, -py) v_colors.addData4f(*color) geom = Geom(vdata) prim = GeomLines(Geom.UHStatic) for n in range(sx + 1): prim.addVertex(2 * n) prim.addVertex(2 * n + 1) for n in range(sy + 1): prim.addVertex(2 * (sx + n + 1)) prim.addVertex(2 * (sx + n + 1) + 1) prim.closePrimitive() geom.addPrimitive(prim) gnode.addGeom(geom) node1 = NodePath(gnode) node1.reparentTo(node) self.node, self.squares, self.sx, self.sy = node, squares, sx, sy self.node.reparentTo(self.parentnode)