コード例 #1
0
def make_node_from_mesh(points: np.ndarray,
                        faces: np.ndarray,
                        normals: np.ndarray,
                        rgba: np.ndarray = np.asarray([1, 1, 1, 1])):
    vertex_normal_format = GeomVertexFormat.get_v3n3c4()

    v_data = GeomVertexData('sphere', vertex_normal_format, Geom.UHStatic)
    num_rows = np.max([points.shape[0], faces.shape[0]])
    v_data.setNumRows(int(num_rows))

    vertex_data = GeomVertexWriter(v_data, 'vertex')
    normal_data = GeomVertexWriter(v_data, 'normal')
    color_data = GeomVertexWriter(v_data, 'color')

    for point, normal in zip(points, normals):
        vertex_data.addData3(point[0], point[1], point[2])
        normal_data.addData3(normal[0], normal[1], normal[2])
        color_data.addData4(rgba[0], rgba[1], rgba[2], rgba[3])
    geom = Geom(v_data)
    for face in faces:
        tri = GeomTriangles(Geom.UHStatic)
        p_1 = points[face[0], :]
        p_2 = points[face[1], :]
        p_3 = points[face[2], :]
        norm = normals[face[0], :]
        if np.dot(np.cross(p_2 - p_1, p_3 - p_2), norm) < 0:
            tri.add_vertices(face[2], face[1], face[0])
        else:
            tri.add_vertices(face[0], face[1], face[2])
        geom.addPrimitive(tri)

    node = GeomNode('gnode')
    node.addGeom(geom)
    return node
コード例 #2
0
ファイル: test_objects.py プロジェクト: tgbugs/desc
def makeSimpleGeomBuffer(array, color, geomType=GeomPoints):
    """ massively faster than the nonbuffer version """

    full = [tuple(d) for d in np.hstack((array,color))]

    fmt = GeomVertexFormat.getV3c4()

    vertexData = GeomVertexData('points', fmt, Geom.UHDynamic) #FIXME use the index for these too? with setPythonTag, will have to 'reserve' some
    cloudGeom = Geom(vertexData)
    cloudNode = GeomNode('just some points')

    vertexData.setNumRows(len(array))
    mem_array = vertexData.modifyArray(0)
    view = memoryview(mem_array)
    arr = np.asarray(view)
    arr[:] = full

    points = geomType(Geom.UHDynamic)
    points.addConsecutiveVertices(0,len(array))
    points.closePrimitive()

    cloudGeom.addPrimitive(points)
    cloudNode.addGeom(cloudGeom)

    return cloudNode
コード例 #3
0
    def _CreateOneSynapse(self, presynCell, synapsesType):

        presynCell.setPresynapticFocus()  # highlight presynaptic cells

        form = GeomVertexFormat.getV3()
        vdata = GeomVertexData("SynapseLine", form, Geom.UHStatic)
        vdata.setNumRows(1)
        vertex = GeomVertexWriter(vdata, "vertex")

        vertex.addData3f(presynCell.getNode().getPos(self._node))
        vertex.addData3f(0, 0, 0)

        prim = GeomLines(Geom.UHStatic)
        prim.addVertices(0, 1)

        geom = Geom(vdata)
        geom.addPrimitive(prim)

        node = GeomNode("Synapse_" + str(synapsesType))
        node.addGeom(geom)

        nodePath = self._node.attachNewNode(node)

        nodePath.setRenderModeThickness(2)

        # color of the line
        if presynCell.active:
            nodePath.setColor(COL_DISTAL_SYNAPSES_ACTIVE)
        else:
            nodePath.setColor(COL_DISTAL_SYNAPSES_INACTIVE)
コード例 #4
0
 def _make_fullscreen_tri(self):
     """ Creates the oversized triangle used for rendering """
     vformat = GeomVertexFormat.get_v3()
     vdata = GeomVertexData("vertices", vformat, Geom.UH_static)
     vdata.set_num_rows(3)
     vwriter = GeomVertexWriter(vdata, "vertex")
     vwriter.add_data3f(-1, 0, -1)
     vwriter.add_data3f(3, 0, -1)
     vwriter.add_data3f(-1, 0, 3)
     gtris = GeomTriangles(Geom.UH_static)
     gtris.add_next_vertices(3)
     geom = Geom(vdata)
     geom.add_primitive(gtris)
     geom_node = GeomNode("gn")
     geom_node.add_geom(geom)
     geom_node.set_final(True)
     geom_node.set_bounds(OmniBoundingVolume())
     tri = NodePath(geom_node)
     tri.set_depth_test(False)
     tri.set_depth_write(False)
     tri.set_attrib(TransparencyAttrib.make(TransparencyAttrib.M_none), 10000)
     tri.set_color(Vec4(1))
     tri.set_bin("unsorted", 10)
     tri.reparent_to(self._node)
     self._tri = tri
コード例 #5
0
def geom_node():
    array = GeomVertexArrayFormat()
    array.add_column("vertex", 3, Geom.NT_float32, Geom.C_point)
    array.add_column("normal", 3, Geom.NT_float32, Geom.C_normal)
    array.add_column("color", 3, Geom.NT_float32, Geom.C_color)
    array.add_column("texcoord", 3, Geom.NT_float32, Geom.C_texcoord)
    format = GeomVertexFormat()
    format.add_array(array)
    format = GeomVertexFormat.register_format(format)

    vdata = GeomVertexData("test", format, Geom.UH_static)
    vdata.set_num_rows(4)
    vertex = GeomVertexWriter(vdata, 'vertex')
    normal = GeomVertexWriter(vdata, 'normal')
    color = GeomVertexWriter(vdata, 'color')
    texcoord = GeomVertexWriter(vdata, 'texcoord')

    vertex.add_data3f(1, 0, 0)
    normal.add_data3f(0, 0, 1)
    color.add_data4f(0, 0, 1, 1)
    texcoord.add_data2f(1, 0)

    vertex.add_data3f(1, 1, 0)
    normal.add_data3f(0, 1, 1)
    color.add_data4f(1, 0, 1, 1)
    texcoord.add_data2f(1, 1)

    geom = Geom(vdata)
    node = GeomNode('gnode')
    node.add_geom(geom)
    return node
コード例 #6
0
    def get_p3d_geom_node(self, name='UnnamedGeom'):
        # type: (Optional[str]) -> GeomNode
        """Returns a Panda3D GeomNode object"""
        vertex_data = GeomVertexData(name, GeomVertexFormat.get_v3c4(),
                                     Geom.UH_static)
        total_triangles = len(self.__triangles__)

        # Every triangle gets its unique set of vertices for flat shading
        num_rows = total_triangles * 3
        vertex_data.set_num_rows(num_rows)
        vertex_writer = GeomVertexWriter(vertex_data, 'vertex')
        color_writer = GeomVertexWriter(vertex_data, 'color')
        for i in range(total_triangles):
            triangle = self.vertices[self.triangles[i]]
            vertex_writer.add_data3f(*triangle[0])
            vertex_writer.add_data3f(*triangle[1])
            vertex_writer.add_data3f(*triangle[2])
            triangle_color = self.colors[self.triangles[i]].sum(axis=0) / 3
            for _ in [0, 0, 0]:
                color_writer.add_data4f(*triangle_color)

        geom = Geom(vertex_data)
        for i in range(total_triangles):
            triangle = GeomTriangles(Geom.UH_static)
            first = i * 3
            triangle.add_vertex(first)
            triangle.add_vertex(first + 1)
            triangle.add_vertex(first + 2)
            geom.add_primitive(triangle)
        node = GeomNode(name)
        node.add_geom(geom)
        return node
コード例 #7
0
def mesh(vertices, normals, colours, triangles):

    # TODO: Make this name meaningful in some way
    name = 'test'

    v3n3c4 = GeomVertexFormat.get_v3n3c4()
    data = GeomVertexData(name, v3n3c4, Geom.UHStatic)
    data.set_num_rows(len(vertices))

    vertex_writer = GeomVertexWriter(data, 'vertex')
    normal_writer = GeomVertexWriter(data, 'normal')
    colour_writer = GeomVertexWriter(data, 'color')

    for vertex in vertices:
        vertex_writer.add_data3(*vertex)

    for normal in normals:
        normal_writer.add_data3(*normal)

    for colour in colours:
        colour_writer.add_data4(*colour)

    prim = GeomTriangles(Geom.UHStatic)

    for triangle in triangles:
        prim.add_vertices(*triangle)

    geom = Geom(data)
    geom.add_primitive(prim)

    node = GeomNode(name)
    node.add_geom(geom)

    return node
コード例 #8
0
class PointMaker():
    def __init__(self, name):
        self.name = name
        self.new()

    def new(self):
        self.point = 0
        self.vdata = GeomVertexData(
        self.name, GeomVertexFormat.get_v3c4(), Geom.UHStatic)
        self.vdata.set_num_rows(2)
        self.vertex = GeomVertexWriter(self.vdata, 'vertex')
        self.color = GeomVertexWriter(self.vdata, 'color')
        self.prim = GeomPoints(Geom.UHStatic)

    def add(self, pos=(0,0,0), color=(1,1,1,1)):
        self.vertex.add_data3(pos[0],pos[1],pos[2]+0.02)
        self.color.add_data4(color)
        self.prim.add_vertex(self.point)
        self.point += 1

    def wrap_up(self):
        self.prim.close_primitive()
        geom = Geom(self.vdata)
        geom.add_primitive(self.prim)
        node = GeomNode('point')
        node.add_geom(geom)
        return NodePath(node)
コード例 #9
0
def make_box():
    """Make a uniform box geometry.

    Returns:
        Geom -- p3d geometry
    """
    vformat = GeomVertexFormat.get_v3n3t2()
    vdata = GeomVertexData('vdata', vformat, Geom.UHStatic)
    vdata.uncleanSetNumRows(24)

    vertex = GeomVertexWriter(vdata, 'vertex')
    normal = GeomVertexWriter(vdata, 'normal')
    tcoord = GeomVertexWriter(vdata, 'texcoord')

    axes = itertools.permutations(np.eye(3), r=2)
    quad = ((0, 0), (1, 0), (0, 1), (1, 1))

    for x, y in axes:
        z = np.cross(x, y)
        for u, v in quad:
            vertex.addData3(*(x * (u - 0.5) + y * (v - 0.5) + z * 0.5))
            normal.addData3(*z)
            tcoord.addData2(u, v)

    prim = GeomTriangles(Geom.UHStatic)
    for i in range(0, 24, 4):
        prim.addVertices(i + 0, i + 1, i + 2)
        prim.addVertices(i + 2, i + 1, i + 3)

    geom = Geom(vdata)
    geom.addPrimitive(prim)
    return geom
コード例 #10
0
def make_plane(size=(1.0, 1.0)):
    """Make a plane geometry.

    Arguments:
        size {tuple} -- plane size x,y

    Returns:
        Geom -- p3d geometry
    """
    vformat = GeomVertexFormat.get_v3n3t2()
    vdata = GeomVertexData('vdata', vformat, Geom.UHStatic)
    vdata.uncleanSetNumRows(4)

    vertex = GeomVertexWriter(vdata, 'vertex')
    normal = GeomVertexWriter(vdata, 'normal')
    tcoord = GeomVertexWriter(vdata, 'texcoord')

    quad = ((0, 0), (1, 0), (0, 1), (1, 1))

    for u, v in quad:
        vertex.addData3((u - 0.5) * size[0], (v - 0.5) * size[1], 0)
        normal.addData3(0, 0, 1)
        tcoord.addData2(u, v)

    prim = GeomTriangles(Geom.UHStatic)
    prim.addVertices(0, 1, 2)
    prim.addVertices(2, 1, 3)

    geom = Geom(vdata)
    geom.addPrimitive(prim)
    return geom
コード例 #11
0
def make_axes():
    """Make an axes geometry.

    Returns:
        Geom -- p3d geometry
    """
    vformat = GeomVertexFormat.get_v3c4()
    vdata = GeomVertexData('vdata', vformat, Geom.UHStatic)
    vdata.uncleanSetNumRows(6)

    vertex = GeomVertexWriter(vdata, 'vertex')
    color = GeomVertexWriter(vdata, 'color')

    for x, y, z in np.eye(3):
        vertex.addData3(0, 0, 0)
        color.addData4(x, y, z, 1)
        vertex.addData3(x, y, z)
        color.addData4(x, y, z, 1)

    prim = GeomLines(Geom.UHStatic)
    prim.addNextVertices(6)

    geom = Geom(vdata)
    geom.addPrimitive(prim)
    return geom
コード例 #12
0
ファイル: Geometry.py プロジェクト: tsp-team/panda3d
    def __init__(self, name, format = GeomVertexFormat.getV3()):
        self.views = []
        self.vertexBuffer = GeomVertexData(name + "-vdata", format, GeomEnums.UHDynamic)

        self.np = NodePath(name)
        self.np.node().setBounds(OmniBoundingVolume())
        self.np.node().setFinal(1)
コード例 #13
0
    def _CreateOneSynapse(self, presynCell, synapsesType):

        form = GeomVertexFormat.getV3()
        vdata = GeomVertexData("SynapseLine", form, Geom.UHStatic)
        vdata.setNumRows(1)
        vertex = GeomVertexWriter(vdata, "vertex")

        vertex.addData3f(presynCell.getNode().getPos(self.__node))
        vertex.addData3f(0, 0, 0)
        # vertex.addData3f(self.__node.getPos())
        # printLog("inputObj:"+str(i)+"bits:"+str(y))
        # printLog(inputObj[i].inputBits[y].getNode().getPos(self.__node))

        prim = GeomLines(Geom.UHStatic)
        prim.addVertices(0, 1)

        geom = Geom(vdata)
        geom.addPrimitive(prim)

        node = GeomNode("Synapse_" + str(synapsesType))
        node.addGeom(geom)

        nodePath = self.__cellsNodePath.attachNewNode(node)

        nodePath.setRenderModeThickness(2)
        # color of the line
        if presynCell.active:
            nodePath.setColor(COL_PROXIMAL_SYNAPSES_ACTIVE)
        else:
            nodePath.setColor(COL_PROXIMAL_SYNAPSES_INACTIVE)
コード例 #14
0
def make_grid(num_ticks=10, step=1.0):
    """Make a grid geometry.

    Keyword Arguments:
        step {float} -- step in meters (default: {1.0})
        num_ticks {int} -- ticks number per axis (default: {5})

    Returns:
        Geom -- p3d geometry
    """
    ticks = np.arange(-num_ticks // 2, num_ticks // 2 + 1) * step

    vformat = GeomVertexFormat.get_v3()
    vdata = GeomVertexData('vdata', vformat, Geom.UHStatic)
    vdata.uncleanSetNumRows(len(ticks) * 4)

    vertex = GeomVertexWriter(vdata, 'vertex')

    for t in ticks:
        vertex.addData3(t, ticks[0], 0)
        vertex.addData3(t, ticks[-1], 0)
        vertex.addData3(ticks[0], t, 0)
        vertex.addData3(ticks[-1], t, 0)

    prim = GeomLines(Geom.UHStatic)
    prim.addNextVertices(len(ticks) * 4)

    geom = Geom(vdata)
    geom.addPrimitive(prim)
    return geom
コード例 #15
0
 def _make_fullscreen_tri(self):
     """ Creates the oversized triangle used for rendering """
     vformat = GeomVertexFormat.get_v3()
     vdata = GeomVertexData("vertices", vformat, Geom.UH_static)
     vdata.set_num_rows(3)
     vwriter = GeomVertexWriter(vdata, "vertex")
     vwriter.add_data3f(-1, 0, -1)
     vwriter.add_data3f(3, 0, -1)
     vwriter.add_data3f(-1, 0, 3)
     gtris = GeomTriangles(Geom.UH_static)
     gtris.add_next_vertices(3)
     geom = Geom(vdata)
     geom.add_primitive(gtris)
     geom_node = GeomNode("gn")
     geom_node.add_geom(geom)
     geom_node.set_final(True)
     geom_node.set_bounds(OmniBoundingVolume())
     tri = NodePath(geom_node)
     tri.set_depth_test(False)
     tri.set_depth_write(False)
     tri.set_attrib(TransparencyAttrib.make(TransparencyAttrib.M_none), 10000)
     tri.set_color(Vec4(1))
     tri.set_bin("unsorted", 10)
     tri.reparent_to(self._node)
     self._tri = tri
コード例 #16
0
    def _create_geom(self):
        color = ConfigVariableColor('grid-color', DEFAULT_GRID_COLOR)

        radius = floor(self.size / (2 * self.spacing))
        diameter = (2 * radius + 1)
        start = -radius * self.spacing

        vertex_format = GeomVertexFormat.get_v3c4()
        vertex_data = GeomVertexData('grid', vertex_format, Geom.UH_static)
        vertex_data.set_num_rows(diameter * 4)
        vertex_writer = GeomVertexWriter(vertex_data, 'vertex')
        color_writer = GeomVertexWriter(vertex_data, 'color')

        for i, j in product(range(diameter), repeat=2):
            vertex_writer.add_data3f(start + i * self.spacing,
                                     start + j * self.spacing, 0.0)
            alpha = GRID_ALPHA - GRID_ALPHA * (
                Vector(i - radius, j - radius).norm() / radius)
            color_writer.add_data4f(color[0], color[1], color[2], alpha)

        primitive = GeomLinestrips(Geom.UH_static)
        for vertex in vertex_indexes(diameter):
            primitive.add_vertex(vertex)
        primitive.close_primitive()
        self.geom = Geom(vertex_data)
        self.geom.add_primitive(primitive)
コード例 #17
0
 def makeGeom(self, points, colors, sizes):
     #format = GeomVertexFormat.getV3c4()
     array = GeomVertexArrayFormat()
     array.addColumn(InternalName.get_vertex(), 3, Geom.NTFloat32, Geom.CPoint)
     array.addColumn(InternalName.get_color(), 4, Geom.NTFloat32, Geom.CColor)
     array.addColumn(InternalName.get_size(), 1, Geom.NTFloat32, Geom.COther)
     format = GeomVertexFormat()
     format.addArray(array)
     format = GeomVertexFormat.registerFormat(format)
     vdata = GeomVertexData('vdata', format, Geom.UH_static)
     vdata.unclean_set_num_rows(len(points))
     self.vwriter = GeomVertexWriter(vdata, InternalName.get_vertex())
     self.colorwriter = GeomVertexWriter(vdata, InternalName.get_color())
     self.sizewriter = GeomVertexWriter(vdata, InternalName.get_size())
     geompoints = GeomPoints(Geom.UH_static)
     geompoints.reserve_num_vertices(len(points))
     index = 0
     for (point, color, size) in zip(points, colors, sizes):
         self.vwriter.addData3f(*point)
         self.colorwriter.addData4f(*color)
         self.sizewriter.addData1f(size)
         geompoints.addVertex(index)
         #geompoints.closePrimitive()
         index += 1
     geom = Geom(vdata)
     geom.addPrimitive(geompoints)
     return geom
コード例 #18
0
ファイル: Icosahedron.py プロジェクト: george-jones/sphere
def pg_draw_tris(pg, render):
    format = GeomVertexFormat.getV3c4()
    vdata = GeomVertexData('pgtris', format, Geom.UHStatic)
    vdata.setNumRows(len(pg.nodes))
    vertex = GeomVertexWriter(vdata, 'vertex')
    color = GeomVertexWriter(vdata, 'color')
    prim = GeomTriangles(Geom.UHStatic)

    for pt in pg.nodes:
        vertex.addData3f(pt.x, pt.y, pt.z)
        color.addData4f(random.random(), random.random(), random.random(), 1.0)

    for pt in pg.nodes:
        if len(pt.conn) > 0:
            for i, cpt in enumerate(pt.conn):
                next_cpt = pt.conn[(i + 1) % len(pt.conn)]
                prim.addVertices(pt.idx, cpt.idx, next_cpt.idx)
                print("%d - %d - %d" % (pt.idx, cpt.idx, next_cpt.idx))

    geom = Geom(vdata)
    geom.addPrimitive(prim)
    node = GeomNode('TheTris')
    node.addGeom(geom)
    nodePath = render.attachNewNode(node)
    nodePath.setPos(0, 10, 0)
コード例 #19
0
ファイル: custom_geometry.py プロジェクト: ctschnur/tex_quads
def createColoredUnitDisk(color_vec4=Vec4(0., 0., 1., 1.), num_of_verts=10, origin_point=Vec3(0., 0., 0.), radius=1.):
    # Own Geometry
    # format = GeomVertexFormat.getV3c4t2()
    format = GeomVertexFormat.getV3c4()
    vdata = GeomVertexData("colored_circle", format, Geom.UHStatic)
    vdata.setNumRows(4)

    vertexPosWriter = GeomVertexWriter(vdata, "vertex")

    # num_of_verts = 10

    # phi = 0.
    r = radius

    # origin_point_x = 0.
    # origin_point_z = 0.
    vertexPosWriter.addData3f(origin_point[0], origin_point[1], origin_point[2])

    circle_points = math_utils.get_circle_vertices(num_of_verts=num_of_verts, radius=r)

    circle_points[:,0] += origin_point[0]
    circle_points[:,1] += origin_point[1]
    circle_points[:,2] += origin_point[2]

    _normal_vector_info = Vec3(0., 1., 0.)      # this is returned just as info about the normal vector of the generated geometry
    for p in circle_points:
        vertexPosWriter.addData3f(p[0], 0, p[1])

    # for i in range(num_of_verts):
    #     phi += 2. * np.pi / num_of_verts
    #     x = r * np.cos(phi)
    #     z = r * np.sin(phi)
    #     vertexPosWriter.addData3f(x, 0, z)

    # let's also add color to each vertex
    colorWriter = GeomVertexWriter(vdata, "color")

    colorWriter.addData4f(color_vec4)  # origin point

    for i in range(num_of_verts):
        colorWriter.addData4f(color_vec4)

    # make primitives and assign vertices to them (primitives and primitive
    # groups can be made independently from vdata, and are later assigned
    # to vdata)
    tris = GeomTrifans(Geom.UHStatic)  # the first vertex is a vertex that all triangles share

    tris.add_consecutive_vertices(0, num_of_verts+1)
    tris.addVertex(1)

    tris.closePrimitive()  # the 1st primitive is finished

    # make a Geom object to hold the primitives
    geom = Geom(vdata)
    geom.addPrimitive(tris)

    geom_node = GeomNode("colored_circle_node")
    geom_node.addGeom(geom)

    return geom_node, _normal_vector_info
コード例 #20
0
ファイル: panda3d_visu.py プロジェクト: EParisot/mod1
 def draw_rain_mesh(self):
     _format = GeomVertexFormat.get_v3cp()
     self.rain_vdata = GeomVertexData('rain', _format, Geom.UHDynamic)
     self.rain_vdata.setNumRows(self.n_points**2)
     vertex = GeomVertexWriter(self.rain_vdata, 'vertex')
     color = GeomVertexWriter(self.rain_vdata, 'color')
     for j in range(self.n_points):
         for i in range(self.n_points):
             # Rain Vertices
             vertex.addData3f(self.x[j][i], self.y[j][i], self.n_points)
             # Rain Colors
             color.addData4f(0.3, 0.3, 1, 0)
     # Rain Primitive
     prim = GeomPoints(Geom.UHDynamic)
     for j in range(self.n_points):
         for i in range(self.n_points):
             prim.add_vertices(j * (self.n_points) + i,
                               j * (self.n_points) + i,
                               j * (self.n_points) + i)
     geom = Geom(self.rain_vdata)
     prim.closePrimitive()
     geom.addPrimitive(prim)
     node = GeomNode('gnode')
     node.addGeom(geom)
     rain_nodePath = render.attachNewNode(node)
     rain_nodePath.setTransparency(TransparencyAttrib.MAlpha)
     rain_nodePath.setAntialias(AntialiasAttrib.MAuto)
     rain_nodePath.setRenderModeThickness(2)
     rain_nodePath.setPos(-50, -50, 0)
コード例 #21
0
def makeSimpleGeomBuffer(array, color, geomType=GeomPoints):
    """ massively faster than the nonbuffer version """

    full = [tuple(d) for d in np.hstack((array, color))]

    fmt = GeomVertexFormat.getV3c4()

    vertexData = GeomVertexData(
        'points', fmt, Geom.UHDynamic
    )  #FIXME use the index for these too? with setPythonTag, will have to 'reserve' some
    cloudGeom = Geom(vertexData)
    cloudNode = GeomNode('just some points')

    vertexData.setNumRows(len(array))
    mem_array = vertexData.modifyArray(0)
    view = memoryview(mem_array)
    arr = np.asarray(view)
    arr[:] = full

    points = geomType(Geom.UHDynamic)
    points.addConsecutiveVertices(0, len(array))
    points.closePrimitive()

    cloudGeom.addPrimitive(points)
    cloudNode.addGeom(cloudGeom)

    return cloudNode
コード例 #22
0
    def _get_geom_vertex_data(cls, layer: Layer, nozzle_diam: float,
                              height: float, name: str) -> GeomVertexData:
        """Generate GeomVertexData for the provided Layer.

        Parameters
        ----------
        layer : Layer
            Layer for which the data should be generated and written.
        nozzle_diam : float
            Nozzle diameter.
        height : float
            Layer height, thickness.
        name : str
            Name for generated GeomVertexData

        Returns
        -------
        GeomVertexData
            Generated GeomVertexData.
        """
        geom_vertex_count = sum([len(path) * 4 for path in layer.paths])

        geom_data = GeomVertexData(name, cls._GEOM_VERTEX_FORMAT,
                                   Geom.UHStatic)
        geom_data.setNumRows(geom_vertex_count)

        cls._write_geom_data(geom_data=geom_data,
                             layer=layer,
                             width=nozzle_diam,
                             height=height)

        return geom_data
コード例 #23
0
ファイル: custom_geometry.py プロジェクト: ctschnur/tex_quads
def create_GeomNode_Single_Point(color_vec4=Vec4(1., 1., 1., 1.)):
    # ---- step 1: create point at (0,0,0) and close the primitive

    format = GeomVertexFormat.getV3c4()
    vdata = GeomVertexData("colored_point", format, Geom.UHStatic)
    vdata.setNumRows(4)

    # add color to each vertex
    colorWriter = GeomVertexWriter(vdata, "color")

    # add a vertex position to each vertex
    vertexPosWriter = GeomVertexWriter(vdata, "vertex")

    # just one origin point vertex, it gets transformed later
    # to it's intended position
    vertexPosWriter.addData3f(0., 0., 0.)
    colorWriter.addData4f(color_vec4)

    # build the primitive
    pointsprimitive = GeomPoints(Geom.UHStatic)
    pointsprimitive.addVertex(0)
    pointsprimitive.closePrimitive()  # this resets all the data contained in the vertexPosWriter and colorWriter

    # ----- step 3: make a GeomNode out of the Geom (to which the Primitives have been added)

    # make a Geom object to hold the primitives
    geom = Geom(vdata)
    geom.addPrimitive(pointsprimitive)

    geom_node = GeomNode("colored_point_node")
    geom_node.addGeom(geom)

    return geom_node
コード例 #24
0
    def _get_geom_data_plate(build_plate_size: LVector2d,
                             name: str = "") -> GeomVertexData:
        """Generate build plate GeomVertexData.

        Parameters
        ----------
        build_plate_size : LVector2d
            Build plate size.
        name : str
            Name for the generated GeomVertexData.
        """
        # noinspection PyArgumentList
        geom_data = GeomVertexData(name, GeomVertexFormat.get_v3t2(),
                                   Geom.UHStatic)
        geom_data.setNumRows(4)

        writer_vertex = GeomVertexWriter(geom_data, "vertex")
        writer_texture = GeomVertexWriter(geom_data, "texcoord")

        # Add build plate vertices
        writer_vertex.addData3d(0, 0, 0)
        writer_vertex.addData3d(build_plate_size.x, 0, 0)
        writer_vertex.addData3d(build_plate_size.x, build_plate_size.y, 0)
        writer_vertex.addData3d(0, build_plate_size.y, 0)

        for uv in [(0, 0), (1, 0), (1, 1), (0, 1)]:
            writer_texture.addData2(*uv)

        return geom_data
コード例 #25
0
 def __init__(self, wheel_pos, radius, heading):
     self.radius = radius
     v_f = GeomVertexFormat.getV3()
     self.vdata = GeomVertexData('skid', v_f, Geom.UHDynamic)
     self.vdata.setNumRows(1)
     self.vertex = GeomVertexWriter(self.vdata, 'vertex')
     self.prim = GeomTriangles(Geom.UHStatic)
     self.cnt = 1
     self.last_pos = wheel_pos
     geom = Geom(self.vdata)
     geom.addPrimitive(self.prim)
     node = GeomNode('gnode')
     node.addGeom(geom)
     nodePath = render.attachNewNode(node)
     nodePath.setTransparency(True)
     nodePath.setDepthOffset(1)
     self.__set_material(nodePath)
     nodePath.node().setBounds(OmniBoundingVolume())
     self.add_vertices(radius, heading)
     self.add_vertices(radius, heading)
     self.remove_seq = Sequence(
         Wait(8),
         LerpFunc(nodePath.setAlphaScale, 8, 1, 0, 'easeInOut'),
         Func(nodePath.remove_node))
     self.remove_seq.start()
コード例 #26
0
ファイル: data_adapter.py プロジェクト: hrhryusuke/wrs
def pandageom_from_vfnf(vertices, face_normals, triangles, name='auto'):
    """
    :param vertices: nx3 nparray, each row is vertex
    :param face_normals: nx3 nparray, each row is the normal of a face
    :param triangles: nx3 nparray, each row is three idx to the vertices
    :param name:
    :return: a geom model that is ready to be used to define a nodepath
    author: weiwei
    date: 20160613, 20210109
    """
    # expand vertices to let each triangle refer to a different vert+normal
    # vertices and normals
    vertformat = GeomVertexFormat.getV3n3()
    vertexdata = GeomVertexData(name, vertformat, Geom.UHStatic)
    vertids = triangles.flatten()
    multiplied_verticies = np.empty((len(vertids), 3), dtype=np.float32)
    multiplied_verticies[:] = vertices[vertids]
    vertex_normals = np.repeat(face_normals.astype(np.float32),
                               repeats=3,
                               axis=0)
    npstr = np.hstack((multiplied_verticies, vertex_normals)).tobytes()
    vertexdata.modifyArrayHandle(0).setData(npstr)
    # triangles
    primitive = GeomTriangles(Geom.UHStatic)
    primitive.setIndexType(GeomEnums.NTUint32)
    multiplied_triangles = np.arange(len(vertids),
                                     dtype=np.uint32).reshape(-1, 3)
    primitive.modifyVertices(-1).modifyHandle().setData(
        multiplied_triangles.tobytes())
    # make geom
    geom = Geom(vertexdata)
    geom.addPrimitive(primitive)
    return geom
コード例 #27
0
    def __init__(self, vertices, normals, colours, tetrahedra):
        super().__init__()
        self.n_vertices = len(vertices)
        self.n_tetrahedra = len(tetrahedra)

        self.data = GeomVertexData(repr(self), format4, Geom.UHDynamic)
        self.data.setNumRows(self.n_vertices)
        self.prim = GeomLinesAdjacency(Geom.UHDynamic)

        vertex_writer = GeomVertexWriter(self.data, "vertex")
        normal_writer = GeomVertexWriter(self.data, "normal")
        colour_writer = GeomVertexWriter(self.data, "colour")

        for vertex in vertices:
            vertex_writer.addData4(*vertex)

        for normal in normals:
            normal_writer.addData4(*normal)

        for colour in colours:
            colour_writer.addData4(*colour)

        for tetra in tetrahedra:
            self.prim.addVertices(*tetra)
            self.prim.closePrimitive()

        self.geom = Geom(self.data)
        self.geom.addPrimitive(self.prim)
        self.node = GeomNode(repr(self))
        self.node.addGeom(self.geom)
コード例 #28
0
    def __init__(self):
        ShowBase.__init__(self)

        PanditorDisableMouseFunc()
        camera.setPos(0.0, 0.0, 50.0)
        camera.lookAt(0.0)
        PanditorEnableMouseFunc()

        # 1) create GeomVertexData
        frmt = GeomVertexFormat.getV3n3cp()
        vdata = GeomVertexData('triangle', frmt, Geom.UHDynamic)

        # 2) create Writers/Rewriters (must all be created before any readers and readers are one-pass-temporary)
        vertex = GeomVertexRewriter(vdata, 'vertex')
        normal = GeomVertexRewriter(vdata, 'normal')
        color = GeomVertexRewriter(vdata, 'color')

        zUp = Vec3(0, 0, 1)
        wt = Vec4(1.0, 1.0, 1.0, 1.0)
        gr = Vec4(0.5, 0.5, 0.5, 1.0)

        # 3) write each column on the vertex data object (for speed, have a different writer for each column)
        def addPoint(x, y, z):
            vertex.addData3f(x, y, z)
            normal.addData3f(zUp)
            color.addData4f(wt)

        addPoint(0.0, 0.0, 0.0)
        addPoint(5.0, 0.0, 0.0)
        addPoint(0.0, 5.0, 0.0)
        addPoint(5.0, 5.0, 0.0)

        # 4) create a primitive and add the vertices via index (not truely associated with the actual vertex table, yet)
        tris = GeomTriangles(Geom.UHDynamic)
        tris.addVertices(0, 1, 2)
        tris.closePrimitive(
        )  # exception thrown if verts added != 3, other types inform Panda how many verts/primitive
        tris.addVertices(2, 1, 3)
        print "vdataPoints", vdata.getArrays()[0]
        # 5.1) (adding to scene) create a Geom and add primitives of like base-type i.e. triangles and triangle strips
        geom = Geom(vdata)
        geom.addPrimitive(tris)
        # 5.2) create a GeomNode to hold the Geom(s) and add the Geom(s)
        gn = GeomNode('gnode')
        gn.addGeom(geom)
        # 5.3) attache the node to the scene
        gnNodePath = render.attachNewNode(gn)

        geomPts = Geom(vdata)
        pts = GeomPoints(Geom.UHStatic)
        pts.addVertices(0, 1, 2)
        pts.closePrimitive()
        geomPts.addPrimitive(pts)
        pointsNode = GeomNode('points_node')
        pointsNode.addGeom(geomPts)
        pointsNP = render.attachNewNode(pointsNode)
        pointsNP.setZ(0.5)

        render.ls()
コード例 #29
0
 def new(self):
     self.point = 0
     self.vdata = GeomVertexData(
     self.name, GeomVertexFormat.get_v3c4(), Geom.UHStatic)
     self.vdata.set_num_rows(2)
     self.vertex = GeomVertexWriter(self.vdata, 'vertex')
     self.color = GeomVertexWriter(self.vdata, 'color')
     self.prim = GeomPoints(Geom.UHStatic)
コード例 #30
0
ファイル: geometry.py プロジェクト: tarsbase/cosmonium
def empty_geom(prefix,
               nb_data,
               nb_vertices,
               points=False,
               normal=True,
               texture=True,
               color=False,
               tanbin=False):
    array = GeomVertexArrayFormat()
    array.addColumn(InternalName.make('vertex'), 3, Geom.NTFloat32,
                    Geom.CPoint)
    if color:
        array.addColumn(InternalName.make('color'), 4, Geom.NTFloat32,
                        Geom.CColor)
    if texture:
        array.addColumn(InternalName.make('texcoord'), 2, Geom.NTFloat32,
                        Geom.CTexcoord)
    if normal:
        array.addColumn(InternalName.make('normal'), 3, Geom.NTFloat32,
                        Geom.CVector)
    if tanbin:
        array.addColumn(InternalName.make('binormal'), 3, Geom.NTFloat32,
                        Geom.CVector)
        array.addColumn(InternalName.make('tangent'), 3, Geom.NTFloat32,
                        Geom.CVector)
    format = GeomVertexFormat()
    format.addArray(array)
    format = GeomVertexFormat.registerFormat(format)
    gvd = GeomVertexData('gvd', format, Geom.UHStatic)
    if nb_data != 0:
        gvd.unclean_set_num_rows(nb_data)
    geom = Geom(gvd)
    gvw = GeomVertexWriter(gvd, 'vertex')
    if color:
        gcw = GeomVertexWriter(gvd, 'color')
    else:
        gcw = None
    if texture:
        gtw = GeomVertexWriter(gvd, 'texcoord')
    else:
        gtw = None
    if normal:
        gnw = GeomVertexWriter(gvd, 'normal')
    else:
        gnw = None
    if tanbin:
        gtanw = GeomVertexWriter(gvd, 'tangent')
        gbiw = GeomVertexWriter(gvd, 'binormal')
    else:
        gtanw = None
        gbiw = None
    if points:
        prim = GeomPoints(Geom.UHStatic)
    else:
        prim = GeomTriangles(Geom.UHStatic)
    if nb_vertices != 0:
        prim.reserve_num_vertices(nb_vertices)
    return (gvw, gcw, gtw, gnw, gtanw, gbiw, prim, geom)
コード例 #31
0
    def __init__(self):
        ShowBase.__init__(self)

        PanditorDisableMouseFunc()
        camera.setPos(0.0, 0.0, 50.0)
        camera.lookAt(0.0)
        PanditorEnableMouseFunc()

        # 1) create GeomVertexData
        frmt = GeomVertexFormat.getV3n3cp()
        vdata = GeomVertexData('triangle', frmt, Geom.UHDynamic)

        # 2) create Writers/Rewriters (must all be created before any readers and readers are one-pass-temporary)
        vertex = GeomVertexRewriter(vdata, 'vertex')
        normal = GeomVertexRewriter(vdata, 'normal')
        color = GeomVertexRewriter(vdata, 'color')

        zUp = Vec3(0, 0, 1)
        wt = Vec4(1.0, 1.0, 1.0, 1.0)
        gr = Vec4(0.5, 0.5, 0.5, 1.0)

        # 3) write each column on the vertex data object (for speed, have a different writer for each column)
        def addPoint(x, y, z):
            vertex.addData3f(x, y, z)
            normal.addData3f(zUp)
            color.addData4f(wt)

        addPoint(0.0, 0.0, 0.0)
        addPoint(5.0, 0.0, 0.0)
        addPoint(0.0, 5.0, 0.0)
        addPoint(5.0, 5.0, 0.0)

        # 4) create a primitive and add the vertices via index (not truely associated with the actual vertex table, yet)
        tris = GeomTriangles(Geom.UHDynamic)
        tris.addVertices(0, 1, 2)
        tris.closePrimitive()  # exception thrown if verts added != 3, other types inform Panda how many verts/primitive
        tris.addVertices(2, 1, 3)
        print "vdataPoints", vdata.getArrays()[0]
        # 5.1) (adding to scene) create a Geom and add primitives of like base-type i.e. triangles and triangle strips
        geom = Geom(vdata)
        geom.addPrimitive(tris)
        # 5.2) create a GeomNode to hold the Geom(s) and add the Geom(s)
        gn = GeomNode('gnode')
        gn.addGeom(geom)
        # 5.3) attache the node to the scene
        gnNodePath = render.attachNewNode(gn)

        geomPts = Geom(vdata)
        pts = GeomPoints(Geom.UHStatic)
        pts.addVertices(0, 1, 2)
        pts.closePrimitive()
        geomPts.addPrimitive(pts)
        pointsNode = GeomNode('points_node')
        pointsNode.addGeom(geomPts)
        pointsNP = render.attachNewNode(pointsNode)
        pointsNP.setZ(0.5)

        render.ls()
コード例 #32
0
 def __init__(self):
     self.vformat = GeomVertexFormat.getV3n3c4()
     self.vdata = GeomVertexData("Data", self.vformat, Geom.UHStatic)
     self.vdata.setNumRows(3)
     self.vertex = GeomVertexWriter(self.vdata, 'vertex')
     self.normal = GeomVertexWriter(self.vdata, 'normal')
     self.color = GeomVertexWriter(self.vdata, 'color')
     self.prim = GeomTriangles(Geom.UHStatic)
     self.idx = 0
コード例 #33
0
ファイル: vis_utils.py プロジェクト: shiraez/DataHack2018
    def __init__(self, size, translation, rotation, color, text):
        self._visible = False
        wy, wx, wz = size[0], size[1], size[2]
        format = GeomVertexFormat.getV3c4()
        vdata = GeomVertexData('cu_points', format, Geom.UHStatic)
        vdata.setNumRows(8)
        self._pos_writer = GeomVertexWriter(vdata, 'vertex')
        self._color_writer = GeomVertexWriter(vdata, 'color')
        self._pos_writer.set_row(0)
        self._color_writer.set_row(0)
        self._pos_writer.addData3f(-0.5 * wx, -0.5 * wy, 0.)
        self._pos_writer.addData3f(-0.5 * wx, -0.5 * wy, wz)
        self._pos_writer.addData3f(0.5 * wx, -0.5 * wy, wz)
        self._pos_writer.addData3f(0.5 * wx, -0.5 * wy, 0.)
        self._pos_writer.addData3f(-0.5 * wx, 0.5 * wy, 0.)
        self._pos_writer.addData3f(-0.5 * wx, 0.5 * wy, wz)
        self._pos_writer.addData3f(0.5 * wx, 0.5 * wy, wz)
        self._pos_writer.addData3f(0.5 * wx, 0.5 * wy, 0.)
        for i in range(8):
            self._color_writer.addData4f(color[0], color[1], color[2],
                                         color[3])

        lines = GeomLines(Geom.UHStatic)
        lines.addVertices(0, 1)
        lines.addVertices(1, 2)
        lines.addVertices(2, 3)
        lines.addVertices(3, 0)
        lines.addVertices(4, 5)
        lines.addVertices(5, 6)
        lines.addVertices(6, 7)
        lines.addVertices(7, 4)
        lines.addVertices(0, 4)
        lines.addVertices(1, 5)
        lines.addVertices(2, 6)
        lines.addVertices(3, 7)
        cuboid = Geom(vdata)
        cuboid.addPrimitive(lines)
        node = GeomNode('cuboid')
        node.addGeom(cuboid)
        self._node_path = NodePath(node)
        # self.title = OnscreenText(text=text, style=1, fg=(1, 1, 1, 1), pos=(-0.1, 0.1), scale=.05,
        #                           parent=self._node_path, align=TextNode.ARight)

        self._txt_node = TextNode('id')
        self._txt_node.setText(text)
        self._txt_node.setTextScale(0.2)
        self._txt_node.setCardColor(0, 0, 1, 1)
        self._txt_node.setCardAsMargin(0, 0, 0, 0)
        self._txt_node.setCardDecal(True)
        self._txt_node.set_align(2)
        text_geom = GeomNode('text')
        text_geom.addChild(self._txt_node)
        self._txt_np = NodePath(text_geom)
        self._txt_np.reparentTo(self._node_path)

        self.show()
        self.update_values(size, translation, rotation, color, text)
コード例 #34
0
ファイル: ui.py プロジェクト: tgbugs/desc
def makeGrid(rng = 1000, spacing = 10): #FIXME make this scale based on zoom???
    ctup = (.3,.3,.3,1)
    xs = range(-rng,rng+1,spacing)
    ys = xs

    fmt = GeomVertexFormat.getV3c4() #3 component vertex, w/ 4 comp color
    #fmt = GeomVertexFormat.getV3() #3 component vertex, w/ 4 comp color
    vertexData = GeomVertexData('points', fmt, Geom.UHStatic)

    verts = GeomVertexWriter(vertexData, 'vertex')
    color = GeomVertexWriter(vertexData, 'color')


    for i,d in enumerate(xs):
        switch1 = (-1) ** i * rng
        switch2 = (-1) ** i * -rng
        #print(d,switch1,0)
        verts.addData3f(d, switch1, 0)
        verts.addData3f(d, switch2, 0)
        color.addData4f(*ctup)
        color.addData4f(*ctup)

    for i,d in enumerate(ys):
        switch1 = (-1) ** i * rng
        switch2 = (-1) ** i * -rng
        verts.addData3f(switch1, d, 0)
        verts.addData3f(switch2, d, 0)
        color.addData4f(*ctup)
        color.addData4f(*ctup)

    gridLines = GeomLinestrips(Geom.UHStatic)
    gridLines.addConsecutiveVertices(0, vertexData.getNumRows())
    gridLines.closePrimitive()

    grid = Geom(vertexData)
    grid.addPrimitive(gridLines)
    return grid
コード例 #35
0
ファイル: meshgenerator.py プロジェクト: nano13/simulacron
    def __init__(self, name = 'Mesh'):
       
        self.name = name
        self.finished = False
 
        self.format = GeomVertexFormat.getV3c4t2()
        #print self.format
        self.vertexData = GeomVertexData(name, self.format, Geom.UHStatic)
        self.vertexData.setNumRows(26136)
       
        self.mesh = Geom(self.vertexData)
        self.triangles = GeomTriangles(Geom.UHStatic)
        self.triangleData = self.triangles.modifyVertices()
        self.triangleData.setNumRows(26136)
       
        self.vertex = GeomVertexWriter(self.vertexData, 'vertex')
        self.normal = GeomVertexWriter(self.vertexData, 'normal')
        self.color = GeomVertexWriter(self.vertexData, 'color')
        self.texcoord = GeomVertexWriter(self.vertexData, 'texcoord')
       
        self.faceCount = 0
コード例 #36
0
ファイル: skybox.py プロジェクト: eswartz/panda3d-stuff
    def createBox(self):
        """
        Create the skybox GeomNode
        :return:
        """

        obj = ''
        obj += "# Skybox\n"
        obj += 'mtllib skybox.mtl\n'


        mtl = '# material for skybox\n'

        fmt = GeomVertexFormat.getV3n3t2()
        vdata = GeomVertexData('skybox', fmt, Geom.UHStatic)
        vdata.setNumRows(24)

        vertex = GeomVertexWriter(vdata, 'vertex')
        normals = GeomVertexWriter(vdata, 'normal')
        texcoord = GeomVertexWriter(vdata, 'texcoord')

        node = GeomNode('skybox')

        for normal in self.normals:
            geom = Geom(vdata)
            prim = GeomTriangles(Geom.UHStatic)

            idx = vertex.getWriteRow()

            verts = self.vertMappings[normal]
            tcs = self.getFaceMapping(normal)

            for v, t in zip(verts, tcs):
                vertex.addData3f(v[0]*2, v[1]*2, v[2]*2)
                normals.addData3f(normal)
                texcoord.addData2f(t)

                obj += 'v {0} {1} {2}\n'.format(v[0]*2, v[1]*2, v[2]*2)
                obj += 'vn {0} {1} {2}\n'.format(*normal)
                obj += 'vt {0} {1}\n'.format(*t)


            tex = self.getFaceTexture(normal)

            prim.addVertices(idx, idx + 1, idx + 3)
            prim.closePrimitive()

            obj += "usemtl {0}\n".format(tex.getName())
            obj += 'f {0}/{0} {1}/{1} {2}/{2}\n'.format(1+idx, 1+idx+1, 1+idx+3)

            prim.addVertices(idx + 1, idx + 2, idx + 3)
            prim.closePrimitive()

            obj += "usemtl {0}\n".format(tex.getName())
            obj += 'f {0}/{0} {1}/{1} {2}/{2}\n'.format(1+idx+1, 1+idx+2, 1+idx+3)

            geom.addPrimitive(prim)

            tex.setWrapU(Texture.WMMirror)
            tex.setWrapV(Texture.WMMirror)

            node.addGeom(geom, RenderState.make(TextureAttrib.make(tex)))


            mtl += "newmtl {0}\n".format(tex.getName())
            mtl += "Ka 1 1 1\n"
            mtl += "Kd 1 1 1\n"
            mtl += "map_Kd {0}\n".format(tex.getFilename().toOsSpecific())

        return node
コード例 #37
0
def add_button(self, text, label_id, pos_x, pos_y, width=0.0, hight=0.1):
    if width == 0.0:
        for c in range(len(text)/2):
            width += 0.08
    ls = LineSegs("lines")
    ls.setColor(0,1,0,1)
    ls.drawTo(-width/2, 0, hight/2)
    ls.drawTo(width/2, 0, hight/2)
    ls.drawTo(width/2, 0,-hight/2)
    ls.drawTo(-width/2, 0,-hight/2)
    ls.drawTo(-width/2, 0, hight/2)
    border = ls.create(False)
    border.setTag('back_ground', '1')
    
    array = GeomVertexArrayFormat()
    array.addColumn("vertex", 4, Geom.NTFloat32, Geom.CPoint)
    arr_format = GeomVertexFormat()
    arr_format.addArray(array)
    arr_format = GeomVertexFormat.registerFormat(arr_format)

    vdata = GeomVertexData('fill', arr_format, Geom.UHStatic)
    vdata.setNumRows(4)
    vertex = GeomVertexWriter(vdata, 'vertex')

    vertex.addData3f(-width/2, 0, hight/2)
    vertex.addData3f(width/2, 0, hight/2)
    vertex.addData3f(-width/2, 0,-hight/2)
    vertex.addData3f(width/2, 0,-hight/2)

    prim = GeomTristrips(Geom.UHStatic)
    prim.addVertex(0)
    prim.addVertex(1)
    prim.addVertex(2)
    prim.addVertex(3)

    geom = Geom(vdata)
    geom.addPrimitive(prim)
    node = GeomNode('gnode')
    node.addGeom(geom)
    nodePath = NodePath("button")
    nodePath.attachNewNode(node)
    nodePath.setPos(0,0,0)
    nodePath.setTag('button', '1')
    nodePath.setBin("unsorted", 0)
    nodePath.setDepthTest(False)
    nodePath.setColor(0,0,0,1)
    nodePath.attachNewNode(border)

    nodePath1 = NodePath("button")
    nodePath1.attachNewNode(node)
    nodePath1.setPos(0,0,0)
    nodePath1.setTag('button1', '1')
    nodePath1.setBin("unsorted", 0)
    nodePath1.setDepthTest(False)
    nodePath1.setColor(0,1,0,1)
    nodePath1.attachNewNode(border)


    button=DirectFrame( 
                        enableEdit=1,                      
                        text=text,
                        geom=nodePath,
                        text_scale=0.05,
                        text_fg=(0,1,0,1),
                        borderWidth=(1,1), 
                        relief = None,
                        text_pos=(0,-0.01,0),
                        textMayChange=1,
                        state=DGG.NORMAL,
                        parent=aspect2d
                        )
    button.setPos(pos_x,0,pos_y)
    button.bind(DGG.B1PRESS, button_click, [button])
    button.bind(DGG.WITHIN, button_hover, [button])
    button.bind(DGG.WITHOUT, button_no_hover, [button])
    # button.resetFrameSize()
    # self.button.bind(DGG.WITHIN, self.onMouseHoverInFunction, [button, some_value1])

    defines.ENTITIES[defines.ENTITY_ID] = {'CATEGORY':'button', 'BUTTON':button, 'NODE':nodePath, 'LABEL':label_id,'STATUS': 0}
    defines.ENTITY_ID += 1
コード例 #38
0
def getVertexData(vertex, vertex_index, normal=None, normal_index=None,
                  texcoordset=(), texcoord_indexset=(),
                  textangentset=(), textangent_indexset=(),
                  texbinormalset=(), texbinormal_indexset=()):
    
    format = GeomVertexFormat()
    formatArray = GeomVertexArrayFormat()
    
    indices2stack = [vertex_index.reshape(-1, 1)]
    alldata = [vertex]
    formatArray.addColumn(InternalName.make("vertex"), 3, Geom.NTFloat32, Geom.CPoint)
    if normal is not None:
        indices2stack.append(normal_index.reshape(-1, 1))
        alldata.append(collada.util.normalize_v3(numpy.copy(normal)))
        formatArray.addColumn(InternalName.make("normal"), 3, Geom.NTFloat32, Geom.CVector)
    if len(texcoordset) > 0:
        indices2stack.append(texcoord_indexset[0].reshape(-1, 1))
        alldata.append(texcoordset[0])
        formatArray.addColumn(InternalName.make("texcoord"), 2, Geom.NTFloat32, Geom.CTexcoord)
    if len(textangentset) > 0:
        indices2stack.append(textangent_indexset[0].reshape(-1, 1))
        alldata.append(textangentset[0])
        formatArray.addColumn(InternalName.make("tangent"), 3, Geom.NTFloat32, Geom.CVector)
    if len(texbinormalset) > 0:
        indices2stack.append(texbinormal_indexset[0].reshape(-1, 1))
        alldata.append(texbinormalset[0])
        formatArray.addColumn(InternalName.make("binormal"), 3, Geom.NTFloat32, Geom.CVector)
        
    #have to flatten and reshape like this so that it's contiguous
    stacked_indices = numpy.hstack(indices2stack).flatten().reshape((-1, len(indices2stack)))

    #index_map - maps each unique value back to a location in the original array it came from
    #   eg. stacked_indices[index_map] == unique_stacked_indices
    #inverse_map - maps original array locations to their location in the unique array
    #   e.g. unique_stacked_indices[inverse_map] == stacked_indices
    unique_stacked_indices, index_map, inverse_map = numpy.unique(stacked_indices.view([('',stacked_indices.dtype)]*stacked_indices.shape[1]), return_index=True, return_inverse=True)
    unique_stacked_indices = unique_stacked_indices.view(stacked_indices.dtype).reshape(-1,stacked_indices.shape[1])
    
    #unique returns as int64, so cast back
    index_map = numpy.cast['uint32'](index_map)
    inverse_map = numpy.cast['uint32'](inverse_map)
    
    #sort the index map to get a list of the index of the first time each value was encountered
    sorted_map = numpy.cast['uint32'](numpy.argsort(index_map))
    
    #since we're sorting the unique values, we have to map the inverse_map to the new index locations
    backwards_map = numpy.zeros_like(sorted_map)
    backwards_map[sorted_map] = numpy.arange(len(sorted_map), dtype=numpy.uint32)
    
    #now this is the new unique values and their indices
    unique_stacked_indices = unique_stacked_indices[sorted_map]
    inverse_map = backwards_map[inverse_map]
    
    #combine the unique stacked indices into unique stacked data
    data2stack = []
    for idx, data in enumerate(alldata):
        data2stack.append(data[unique_stacked_indices[:,idx]])
    unique_stacked_data = numpy.hstack(data2stack).flatten()
    unique_stacked_data.shape = (-1)
    all_data = unique_stacked_data.tostring()

    format.addArray(formatArray)
    format = GeomVertexFormat.registerFormat(format)
    
    vdata = GeomVertexData("dataname", format, Geom.UHStatic)
    arr = GeomVertexArrayData(format.getArray(0), GeomEnums.UHStream)
    datahandle = arr.modifyHandle()
    datahandle.setData(all_data)
    all_data = None
    vdata.setArray(0, arr)
    datahandle = None
    arr = None

    indexFormat = GeomVertexArrayFormat()
    indexFormat.addColumn(InternalName.make("index"), 1, Geom.NTUint32, Geom.CIndex)
    indexFormat = GeomVertexArrayFormat.registerFormat(indexFormat)
    indexArray = GeomVertexArrayData(indexFormat, GeomEnums.UHStream)
    indexHandle = indexArray.modifyHandle()
    indexData = inverse_map.tostring()
    indexHandle.setData(indexData)
    return vdata, indexArray
コード例 #39
0
ファイル: meshgenerator.py プロジェクト: nano13/simulacron
class MeshGenerator():
   
    def __init__(self, name = 'Mesh'):
       
        self.name = name
        self.finished = False
 
        self.format = GeomVertexFormat.getV3c4t2()
        #print self.format
        self.vertexData = GeomVertexData(name, self.format, Geom.UHStatic)
        self.vertexData.setNumRows(26136)
       
        self.mesh = Geom(self.vertexData)
        self.triangles = GeomTriangles(Geom.UHStatic)
        self.triangleData = self.triangles.modifyVertices()
        self.triangleData.setNumRows(26136)
       
        self.vertex = GeomVertexWriter(self.vertexData, 'vertex')
        self.normal = GeomVertexWriter(self.vertexData, 'normal')
        self.color = GeomVertexWriter(self.vertexData, 'color')
        self.texcoord = GeomVertexWriter(self.vertexData, 'texcoord')
       
        self.faceCount = 0
   
    def makeFace(self, x1, y1, z1, x2, y2, z2, id, color):
       
        if x1 != x2:
       
            self.vertex.addData3f(x1, y1, z1)
            self.vertex.addData3f(x2, y1, z1)
            self.vertex.addData3f(x2, y2, z2)
            self.vertex.addData3f(x1, y2, z2)
           
        else:
       
            self.vertex.addData3f(x1, y1, z1)
            self.vertex.addData3f(x2, y2, z1)
            self.vertex.addData3f(x2, y2, z2)
            self.vertex.addData3f(x1, y1, z2)
 
 
        self.color.addData4f(color, color, color, 1.0)
        self.color.addData4f(color, color, color, 1.0)
        self.color.addData4f(color, color, color, 1.0)
        self.color.addData4f(color, color, color, 1.0)
       
        if id == 1:
            self.texcoord.addData2f(0.0, 0.5)
            self.texcoord.addData2f(0.0, 0.0)
            self.texcoord.addData2f(0.25, 0.0)
            self.texcoord.addData2f(0.25, 0.5)
        elif id == 2:
            self.texcoord.addData2f(0.25, 0.5)
            self.texcoord.addData2f(0.25, 0.0)
            self.texcoord.addData2f(0.5, 0.0)
            self.texcoord.addData2f(0.5, 0.5)
        elif id == 3:
            self.texcoord.addData2f(0.5, 0.5)
            self.texcoord.addData2f(0.5, 0.0)
            self.texcoord.addData2f(0.75, 0.0)
            self.texcoord.addData2f(0.75, 0.5)
        elif id == 4:
            self.texcoord.addData2f(0.75, 0.5)
            self.texcoord.addData2f(0.75, 0.0)
            self.texcoord.addData2f(1.0, 0.0)
            self.texcoord.addData2f(1.0, 0.5)
        elif id == 5:
            self.texcoord.addData2f(0.0, 1.0)
            self.texcoord.addData2f(0.0, 0.5)
            self.texcoord.addData2f(0.25, 0.5)
            self.texcoord.addData2f(0.25, 1.0)
        elif id == 6:
            self.texcoord.addData2f(0.25, 1.0)
            self.texcoord.addData2f(0.25, 0.5)
            self.texcoord.addData2f(0.5, 0.5)
            self.texcoord.addData2f(0.5, 1.0)
       
        vertexId = self.faceCount * 4
       
        self.triangles.addVertices(vertexId, vertexId + 1, vertexId + 3)
        self.triangles.addVertices(vertexId + 1, vertexId + 2, vertexId + 3)
       
        self.faceCount += 1
   
    def makeFrontFace(self, x, y, z, id):
        self.makeFace(x + 1, y + 1, z - 1, x, y + 1, z, id, 0.6)
   
    def makeBackFace(self, x, y, z, id):
        self.makeFace(x, y, z - 1, x + 1, y, z, id, 0.85)
   
    def makeRightFace(self, x, y, z, id):
        self.makeFace(x + 1, y, z - 1, x + 1, y + 1, z, id, 1.0)
   
    def makeLeftFace(self, x, y, z, id):
        self.makeFace(x, y + 1, z - 1, x, y, z, id, 0.9)
   
    def makeTopFace(self, x, y, z, id):
        self.makeFace(x + 1, y + 1, z, x, y, z, id, 1.0)
   
    def makeBottomFace(self, x, y, z, id):
        self.makeFace(x, y + 1, z - 1, x + 1, y, z - 1, id, 0.70)
   
    def getMesh(self):
        return self.mesh
   
    def getGeomNode(self):
        if self.finished == False:
            self.triangles.closePrimitive()
            self.mesh.addPrimitive(self.triangles)
            self.finished = True
        geomNode = GeomNode(self.name)
        geomNode.addGeom(self.mesh)
        return geomNode
コード例 #40
0
def getNodeFromController(controller, controlled_prim):
    if type(controlled_prim) is collada.controller.BoundSkinPrimitive:
        ch = Character('simplechar')
        bundle = ch.getBundle(0)
        skeleton = PartGroup(bundle, '<skeleton>')

        character_joints = {}
        for (name, joint_matrix) in controller.joint_matrices.iteritems():
            joint_matrix.shape = (-1)
            character_joints[name] = CharacterJoint(ch, bundle, skeleton, name, Mat4(*joint_matrix)) 
        
        tbtable = TransformBlendTable()
        
        for influence in controller.index:
            blend = TransformBlend()
            for (joint_index, weight_index) in influence:
                char_joint = character_joints[controller.getJoint(joint_index)]
                weight = controller.getWeight(weight_index)[0]
                blend.addTransform(JointVertexTransform(char_joint), weight)
            tbtable.addBlend(blend)
            
        array = GeomVertexArrayFormat()
        array.addColumn(InternalName.make('vertex'), 3, Geom.NTFloat32, Geom.CPoint)
        array.addColumn(InternalName.make('normal'), 3, Geom.NTFloat32, Geom.CPoint)
        array.addColumn(InternalName.make('texcoord'), 2, Geom.NTFloat32, Geom.CTexcoord)
        blendarr = GeomVertexArrayFormat()
        blendarr.addColumn(InternalName.make('transform_blend'), 1, Geom.NTUint16, Geom.CIndex)
        
        format = GeomVertexFormat()
        format.addArray(array)
        format.addArray(blendarr)
        aspec = GeomVertexAnimationSpec()
        aspec.setPanda()
        format.setAnimation(aspec)
        format = GeomVertexFormat.registerFormat(format)
        
        dataname = controller.id + '-' + controlled_prim.primitive.material.id
        vdata = GeomVertexData(dataname, format, Geom.UHStatic)
        vertex = GeomVertexWriter(vdata, 'vertex')
        normal = GeomVertexWriter(vdata, 'normal')
        texcoord = GeomVertexWriter(vdata, 'texcoord')
        transform = GeomVertexWriter(vdata, 'transform_blend') 
        
        numtris = 0
        if type(controlled_prim.primitive) is collada.polylist.BoundPolylist:
            for poly in controlled_prim.primitive.polygons():
                for tri in poly.triangles():
                    for tri_pt in range(3):
                        vertex.addData3f(tri.vertices[tri_pt][0], tri.vertices[tri_pt][1], tri.vertices[tri_pt][2])
                        normal.addData3f(tri.normals[tri_pt][0], tri.normals[tri_pt][1], tri.normals[tri_pt][2])
                        if len(controlled_prim.primitive._texcoordset) > 0:
                            texcoord.addData2f(tri.texcoords[0][tri_pt][0], tri.texcoords[0][tri_pt][1])
                        transform.addData1i(tri.indices[tri_pt])
                    numtris+=1
        elif type(controlled_prim.primitive) is collada.triangleset.BoundTriangleSet:
            for tri in controlled_prim.primitive.triangles():
                for tri_pt in range(3):
                    vertex.addData3f(tri.vertices[tri_pt][0], tri.vertices[tri_pt][1], tri.vertices[tri_pt][2])
                    normal.addData3f(tri.normals[tri_pt][0], tri.normals[tri_pt][1], tri.normals[tri_pt][2])
                    if len(controlled_prim.primitive._texcoordset) > 0:
                        texcoord.addData2f(tri.texcoords[0][tri_pt][0], tri.texcoords[0][tri_pt][1])
                    transform.addData1i(tri.indices[tri_pt])
                numtris+=1
                    
        tbtable.setRows(SparseArray.lowerOn(vdata.getNumRows())) 
        
        gprim = GeomTriangles(Geom.UHStatic)
        for i in range(numtris):
            gprim.addVertices(i*3, i*3+1, i*3+2)
            gprim.closePrimitive()
            
        pgeom = Geom(vdata)
        pgeom.addPrimitive(gprim)
        
        render_state = getStateFromMaterial(controlled_prim.primitive.material)
        control_node = GeomNode("ctrlnode")
        control_node.addGeom(pgeom, render_state)
        ch.addChild(control_node)
    
        bundle = AnimBundle('simplechar', 5.0, 2)
        skeleton = AnimGroup(bundle, '<skeleton>')
        root = AnimChannelMatrixXfmTable(skeleton, 'root')
        
        #hjoint = AnimChannelMatrixXfmTable(root, 'joint1') 
        #table = [10, 11, 12, 13, 14, 15, 14, 13, 12, 11] 
        #data = PTAFloat.emptyArray(len(table)) 
        #for i in range(len(table)): 
        #    data.setElement(i, table[i]) 
        #hjoint.setTable(ord('i'), CPTAFloat(data)) 
        
        #vjoint = AnimChannelMatrixXfmTable(hjoint, 'joint2') 
        #table = [10, 9, 8, 7, 6, 5, 6, 7, 8, 9] 
        #data = PTAFloat.emptyArray(len(table)) 
        #for i in range(len(table)): 
        #    data.setElement(i, table[i]) 
        #vjoint.setTable(ord('j'), CPTAFloat(data)) 

        wiggle = AnimBundleNode('wiggle', bundle)

        np = NodePath(ch) 
        anim = NodePath(wiggle) 
        a = Actor(np, {'simplechar' : anim})
        a.loop('simplechar') 
        return a
        #a.setPos(0, 0, 0)
    
    else:
        raise Exception("Error: unsupported controller type")
コード例 #41
0
ファイル: buffer.py プロジェクト: tgbugs/desc
import numpy as np
from panda3d.core import Geom, GeomVertexFormat, GeomVertexData

from .util.ipython import embed

size = 1000
data = np.random.randint(0,1000,(size,3))
#color = np.random.randint(0,255,(size,4))
color = np.repeat(np.random.randint(0,255,(1,4)), size, 0)
#full = np.hstack((data,color))
full = [tuple(d) for d in np.hstack((data,color))]
#full = [tuple(*d,*color) for d in data]


geom = GeomVertexData('points', GeomVertexFormat.getV3c4(), Geom.UHDynamic)
geom.setNumRows(len(full))
array = geom.modifyArray(0)  # need a writeable version
handle = array.modifyHandle()

#options are then the following:

view = memoryview(array)
arr = np.asarray(view)
arr[:] = full

embed()
#OR
#handle.copyDataFrom('some other handle to a GVDA')
#handle.copySubataFrom(to_start, to_size, buffer, from_start, from_size)
コード例 #42
0
ファイル: __init__.py プロジェクト: gau-veldt/Blockiverse
class Chunk2GeomDecoder:
    """
        Chunk decoder that decodes chunks to Panda3D Geoms/Nodes
    """
    def __init__(self):
    
        self.textures={}
        for k in texMap:
            v=texMap[k]
            tex=loader.loadTexture("gfx/%s"%v)
            tex.setWrapU(Texture.WM_clamp)
            tex.setWrapV(Texture.WM_clamp)
            self.textures[k]=tex
        
        self.viewPoint=(0,0,0)
        self.cubeVtxSrc=[
            # 14 vertices per cube mapped
            # so that UV coords utilize
            # the typical cube unwrap:
            #
            #   ####  <-- square texture
            #   ##U#
            #   BLFR
            #   ##D#    #=unused
            #
            # This form uses 14 vertices per cube since
            # the extra (worldspace overlapped) vertices
            # map different U,V coordinates at the same
            # worldspace coordinates, depending on face
            #   
            # x    y    z    u    v
            (1.00,1.00,1.00,0.00,0.50), # A
            (1.00,1.00,0.00,0.00,0.25), # B
            (0.00,1.00,1.00,0.25,0.50), # C
            (0.00,1.00,0.00,0.25,0.25), # D
            (0.00,0.00,1.00,0.50,0.50), # E
            (0.00,0.00,0.00,0.50,0.25), # F
            (1.00,0.00,1.00,0.75,0.50), # G
            (1.00,0.00,0.00,0.75,0.25), # H
            (1.00,1.00,1.00,1.00,0.50), # I
            (1.00,1.00,0.00,1.00,0.25), # J
            (0.00,1.00,1.00,0.50,0.75), # K
            (1.00,1.00,1.00,0.75,0.75), # L
            (0.00,1.00,0.00,0.50,0.00), # M
            (1.00,1.00,0.00,0.75,0.00)  # N
            ]
        self.triSrc=[
            #
            #  Faces (QUAD/TRIPAIR)
            #  using RHR vertex ordering for
            #  correct face surface normals
            #
            #    front: EFHG/EFH+HGE
            #     rear: CABD/CAB+BDC
            #     left: CDFE/CDF+FEC
            #    right: GHJI/GHJ+JIG
            #    upper: KEGL/KEG+GLK
            #    lower: FMNH/FMN+NHF
            #
            "EFH","HGE",
            "CAB","BDC",
            "CDF","FEC",
            "GHJ","JIG",
            "KEG","GLK",
            "FMN","NHF"
            ]
        #
        # setup cube
        #
        # one cube node will be generated per non-air block
        # since different block id's potentially refer to
        # different textures and thus must be separate nodes
        # of the scene graph.
        #
        #   1. vertices
        self.cubeVtx=GeomVertexData('blockCube',GeomVertexFormat.getV3t2(),Geom.UHStatic)
        self.cubeVtx.setNumRows(len(self.cubeVtxSrc))
        vtxW=GeomVertexWriter(self.cubeVtx,'vertex')
        txcW=GeomVertexWriter(self.cubeVtx,'texcoord')
        for vertex in self.cubeVtxSrc:
            vtxW.addData3f(*vertex[0:3])
            txcW.addData2f(*vertex[3:5])
        #   2. mesh
        self.cubeMesh=GeomTriangles(Geom.UHStatic)
        for tri in self.triSrc:
            for triV in tri:
                triVtxId=ord(triV)-65 # changea 'A'-'N' to 0-13
                self.cubeMesh.addVertex(triVtxId)
            self.cubeMesh.close_primitive()
        #   3. geometry (primitive+vertex pair)
        self.cubeGeom=Geom(self.cubeVtx)
        self.cubeGeom.addPrimitive(self.cubeMesh)

    def setViewpoint(x,y,z):
        self.viewPoint=(x,y,z)

    @decompress
    def Chunk2Geom(self,sChunk,origin):
        """
        Decodes chunk into Panda3D geometry format
        @param
            sChunk: encoded chunk
            origin: chunk location in world as 3-tuple
        @return
            A panda3D Node object translated appropriately to place
            the decoded chunk correctly within the world.
        """
        # determine where chunk should be placed in world space
        orgX=origin[0]
        orgY=origin[1]
        orgZ=origin[2]
        # determine chunk's coordinate
        chunkX=orgX/16
        chunkY=orgY/16
        # generate name tags for the various parts
        chunkId="%s_%s" % (chunkX,chunkY)
        vtxName="vtx_%s" % chunkId
        nodeName="chunk_%s" % chunkId
        # create empty node for entire chunk
        chunkNode=render.attachNewNode(nodeName)
        # convert string chunk to numeric
        chunk=[ord(c) for c in sChunk]
        # TODO: read chunk data and generate cube nodes
        flags=chunk[0]+(chunk[1]<<8)+(chunk[2]<<16)+(chunk[3]<<24)
        chunk=chunk[4:] # remove biome/flagbits
        for cY in range(16):
            for cX in range(16):
                for cZ in range(256):
                    cell=cZ+(cX<<8)+(cY<<12)
                    # lookup neighbours
                    me=chunk[cell]
                    if me>0:
                        n_up=chunk[cell-1]    if cZ>0   else 0
                        n_dn=chunk[cell+1]    if cZ<255 else 0
                        n_lt=chunk[cell-256]  if cX>0   else 0
                        n_rt=chunk[cell+256]  if cX<15  else 0
                        n_bk=chunk[cell-4096] if cY>0   else 0
                        n_fd=chunk[cell+4096] if cY<15  else 0
                        if n_up==0 or n_dn==0 or \
                           n_lt==0 or n_rt==0 or \
                           n_bk==0 or n_fd==0:
                            # for any non-obscured block
                            # generate a cube
                            block=GeomNode("%s_block_%s_%s_%s"%(nodeName,cX,cY,cZ))
                            block.addGeom(self.cubeGeom)
                            blockNode=chunkNode.attachNewNode(block)
                            blockNode.setTexture(self.textures[me])
                            blockNode.setPos(cX,cY,cZ)
        chunkNode.setPos(chunkX*16,chunkY*16,-64)
        return chunkNode
コード例 #43
0
ファイル: __init__.py プロジェクト: gau-veldt/Blockiverse
 def __init__(self):
 
     self.textures={}
     for k in texMap:
         v=texMap[k]
         tex=loader.loadTexture("gfx/%s"%v)
         tex.setWrapU(Texture.WM_clamp)
         tex.setWrapV(Texture.WM_clamp)
         self.textures[k]=tex
     
     self.viewPoint=(0,0,0)
     self.cubeVtxSrc=[
         # 14 vertices per cube mapped
         # so that UV coords utilize
         # the typical cube unwrap:
         #
         #   ####  <-- square texture
         #   ##U#
         #   BLFR
         #   ##D#    #=unused
         #
         # This form uses 14 vertices per cube since
         # the extra (worldspace overlapped) vertices
         # map different U,V coordinates at the same
         # worldspace coordinates, depending on face
         #   
         # x    y    z    u    v
         (1.00,1.00,1.00,0.00,0.50), # A
         (1.00,1.00,0.00,0.00,0.25), # B
         (0.00,1.00,1.00,0.25,0.50), # C
         (0.00,1.00,0.00,0.25,0.25), # D
         (0.00,0.00,1.00,0.50,0.50), # E
         (0.00,0.00,0.00,0.50,0.25), # F
         (1.00,0.00,1.00,0.75,0.50), # G
         (1.00,0.00,0.00,0.75,0.25), # H
         (1.00,1.00,1.00,1.00,0.50), # I
         (1.00,1.00,0.00,1.00,0.25), # J
         (0.00,1.00,1.00,0.50,0.75), # K
         (1.00,1.00,1.00,0.75,0.75), # L
         (0.00,1.00,0.00,0.50,0.00), # M
         (1.00,1.00,0.00,0.75,0.00)  # N
         ]
     self.triSrc=[
         #
         #  Faces (QUAD/TRIPAIR)
         #  using RHR vertex ordering for
         #  correct face surface normals
         #
         #    front: EFHG/EFH+HGE
         #     rear: CABD/CAB+BDC
         #     left: CDFE/CDF+FEC
         #    right: GHJI/GHJ+JIG
         #    upper: KEGL/KEG+GLK
         #    lower: FMNH/FMN+NHF
         #
         "EFH","HGE",
         "CAB","BDC",
         "CDF","FEC",
         "GHJ","JIG",
         "KEG","GLK",
         "FMN","NHF"
         ]
     #
     # setup cube
     #
     # one cube node will be generated per non-air block
     # since different block id's potentially refer to
     # different textures and thus must be separate nodes
     # of the scene graph.
     #
     #   1. vertices
     self.cubeVtx=GeomVertexData('blockCube',GeomVertexFormat.getV3t2(),Geom.UHStatic)
     self.cubeVtx.setNumRows(len(self.cubeVtxSrc))
     vtxW=GeomVertexWriter(self.cubeVtx,'vertex')
     txcW=GeomVertexWriter(self.cubeVtx,'texcoord')
     for vertex in self.cubeVtxSrc:
         vtxW.addData3f(*vertex[0:3])
         txcW.addData2f(*vertex[3:5])
     #   2. mesh
     self.cubeMesh=GeomTriangles(Geom.UHStatic)
     for tri in self.triSrc:
         for triV in tri:
             triVtxId=ord(triV)-65 # changea 'A'-'N' to 0-13
             self.cubeMesh.addVertex(triVtxId)
         self.cubeMesh.close_primitive()
     #   3. geometry (primitive+vertex pair)
     self.cubeGeom=Geom(self.cubeVtx)
     self.cubeGeom.addPrimitive(self.cubeMesh)