Exemple #1
0
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()
Exemple #2
0
    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)
Exemple #4
0
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
Exemple #5
0
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
Exemple #6
0
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)
Exemple #7
0
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
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
Exemple #9
0
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)
Exemple #10
0
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)
Exemple #11
0
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)
Exemple #12
0
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))
Exemple #13
0
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
Exemple #15
0
    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)