コード例 #1
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
コード例 #2
0
ファイル: selection.py プロジェクト: tgbugs/desc
def makeSelectRect():
    ctup = (1, 1, 1, 1)
    fmt = GeomVertexFormat.getV3c4()
    vertexData = GeomVertexData('points', fmt, Geom.UHDynamic)

    points = (  #makes nice for Tristrips
        (0, 0, 0),
        (0, 0, 1),
        (1, 0, 0),
        (1, 0, 1),
    )

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

    for point in points:
        verts.addData3f(*point)
        color.addData4f(*ctup)

    boxLines = GeomLinestrips(Geom.UHDynamic)
    boxLines.addVertices(0, 1, 3, 2)
    boxLines.addVertex(0)
    boxLines.closePrimitive()

    boxTris = GeomTristrips(Geom.UHDynamic)
    boxTris.addConsecutiveVertices(0, 3)
    boxTris.closePrimitive()

    box = Geom(vertexData)
    box.addPrimitive(boxLines)
    #box.addPrimitive(boxTris)

    return box
コード例 #3
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
コード例 #4
0
ファイル: terrain.py プロジェクト: pennomi/voronoi-terrain
def add_plane(map_width, map_height):
    # Prepare the vertex format writers
    v_fmt = GeomVertexFormat.getV3n3c4()
    v_data = GeomVertexData('TerrainData', v_fmt, Geom.UHStatic)
    vertex = GeomVertexWriter(v_data, 'vertex')
    normal = GeomVertexWriter(v_data, 'normal')
    color = GeomVertexWriter(v_data, 'color')
    #texcoord = GeomVertexWriter(v_data, 'texcoord')

    # Create a primitive
    prim = GeomTrifans(Geom.UHStatic)
    poly_color = (uniform(0, 0.05), uniform(0, 0.5), uniform(0.5, 1), 0.5, )

    for i, point in enumerate([
            (-map_width/2, -map_height/2),
            (map_width/2, -map_height/2),
            (map_width/2, map_height/2),
            (-map_width/2, map_height/2), ]):
        x, y = point
        vertex.addData3f(x, y, 0)
        normal.addData3f(0, 0, 1)
        color.addData4f(*poly_color)
        #texcoord.addData2f(1, 0)
        prim.addVertex(i)
    prim.addVertex(0)
    prim.closePrimitive()

    # Add to the scene graph
    geom = Geom(v_data)
    geom.addPrimitive(prim)
    node = GeomNode('gnode')
    node.addGeom(geom)
    nodePath = render.attachNewNode(node)
    nodePath.setTwoSided(True)
    nodePath.setAlphaScale(0.5)
コード例 #5
0
ファイル: points.py プロジェクト: tgbugs/desc
def makePoints(n=1000):
    """ make a cloud of points that are a single node VS branching and making subnodes to control display """

    #points = np.random.uniform(-10,10,(n,4))
    points = np.random.randn(n, 3)
    colors = np.random.rand(n, 4)

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

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

    for point, clr4 in zip(points, colors):
        #for point in points:
        verts.addData3f(*point)
        #color.addData4f(*point)
        color.addData4f(*clr4)
        #color.addData4f(.1,.1,.1,1)

    #pointCloud = GeomLinestrips(Geom.UHStatic) #this is f*****g cool!
    pointCloud = GeomTristrips(Geom.UHStatic)  #this is f*****g cool!
    #pointCloud = GeomPoints(Geom.UHStatic)
    #pointCloud.addVerticies(*range(n))
    pointCloud.addConsecutiveVertices(0, n)  #warning may error since n-1?
    pointCloud.closePrimitive()

    cloud = Geom(vertexData)
    cloud.addPrimitive(pointCloud)
    return cloud
コード例 #6
0
    def addPoint(self, x, y, wheel_dir, force):
        """
		Adds a point to the skid mark trail.  The coordinates are in the world frame. The force is
		a number between zero and one, where one is the max force and makes the biggest and darkest
		skid mark.  The argument 'wheel_dir' is given in degrees, where zero points toward the
		positive X axis.
		"""
        h = self.wheel_width * 0.5
        rads = (wheel_dir - 90) * math.pi / 180.0
        x0b, y0b = x + h * math.cos(rads), y + h * math.sin(rads)
        rads = (wheel_dir + 90) * math.pi / 180.0
        x1b, y1b = x + h * math.cos(rads), y + h * math.sin(rads)
        x0a, y0a, x1a, y1a = self.lastpoints
        self.lastpoints = (x0b, y0b, x1b, y1b)
        if not self.havelast:
            self.havelast = True
            return
        indx = self.nextrect * 4
        self.nextrect += 1
        if self.nextrect >= self.nrects:
            self.nextrect = 0
        vtx = GeomVertexWriter(self.vdata, "vertex")
        cx = GeomVertexWriter(self.vdata, "color")
        vtx.setRow(indx)
        cx.setRow(indx)
        c = self.forceToColor(force)
        vtx.addData3f(x0a, y0a, self.zpos)
        vtx.addData3f(x1a, y1a, self.zpos)
        vtx.addData3f(x0b, y0b, self.zpos)
        vtx.addData3f(x1b, y1b, self.zpos)
        cx.addData4f(*c)
        cx.addData4f(*c)
        cx.addData4f(*c)
        cx.addData4f(*c)
コード例 #7
0
ファイル: pandascene.py プロジェクト: agoose77/hivesystem
def make_geom(vertices, normals, colors, texcoords):
    if panda3d is None: raise ImportError("Cannot locate Panda3D")
    format = "V3"
    if normals is not None:
        assert len(normals) == len(vertices)
        format += "n3"

    if colors is not None:
        assert len(colors) == len(vertices)
        format += "cp"

    if texcoords is not None:
        assert len(texcoords) == len(vertices)
        format += "t2"
    format = getattr(GeomVertexFormat, "get" + format)()
    vdata = GeomVertexData("", format, Geom.UHStatic)

    v_vertex = GeomVertexWriter(vdata, 'vertex')
    if normals is not None: v_normals = GeomVertexWriter(vdata, 'normal')
    if colors is not None: v_colors = GeomVertexWriter(vdata, 'color')
    if texcoords is not None: v_texcoords = GeomVertexWriter(vdata, 'texcoord')

    for n in range(len(vertices)):
        v_vertex.addData3f(*vertices[n])
        if normals is not None: v_normals.addData3f(*normals[n])
        if colors is not None: v_colors.addData4f(*colors[n])
        if texcoords is not None: v_texcoords.addData2f(*texcoords[n])

    return Geom(vdata)
コード例 #8
0
ファイル: points.py プロジェクト: tgbugs/desc
def makePoints(n=1000):
    """ make a cloud of points that are a single node VS branching and making subnodes to control display """

    #points = np.random.uniform(-10,10,(n,4))
    points = np.random.randn(n,3)
    colors = np.random.rand(n,4)

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

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

    for point,clr4 in zip(points,colors):
    #for point in points:
        verts.addData3f(*point)
        #color.addData4f(*point)
        color.addData4f(*clr4)
        #color.addData4f(.1,.1,.1,1)

    #pointCloud = GeomLinestrips(Geom.UHStatic) #this is f*****g cool!
    pointCloud = GeomTristrips(Geom.UHStatic) #this is f*****g cool!
    #pointCloud = GeomPoints(Geom.UHStatic)
    #pointCloud.addVerticies(*range(n))
    pointCloud.addConsecutiveVertices(0,n) #warning may error since n-1?
    pointCloud.closePrimitive()

    cloud = Geom(vertexData)
    cloud.addPrimitive(pointCloud)
    return cloud
コード例 #9
0
ファイル: selection.py プロジェクト: tgbugs/desc
def makeSelectRect():
    ctup = (1,1,1,1)
    fmt = GeomVertexFormat.getV3c4()
    vertexData = GeomVertexData('points', fmt, Geom.UHDynamic)

    points = ( #makes nice for Tristrips
        (0,0,0),
        (0,0,1),
        (1,0,0),
        (1,0,1),
    )

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

    for point in points:
        verts.addData3f(*point)
        color.addData4f(*ctup)

    boxLines = GeomLinestrips(Geom.UHDynamic)
    boxLines.addVertices(0,1,3,2)
    boxLines.addVertex(0)
    boxLines.closePrimitive()

    boxTris = GeomTristrips(Geom.UHDynamic)
    boxTris.addConsecutiveVertices(0,3)
    boxTris.closePrimitive()

    box = Geom(vertexData)
    box.addPrimitive(boxLines)
    #box.addPrimitive(boxTris)

    return box
コード例 #10
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)
コード例 #11
0
ファイル: planet.py プロジェクト: PlumpMath/panda3dplanetgen
    def __build_ocean_mesh(self):
        vdata = GeomVertexData('data', GeomVertexFormat.getV3n3c4t2(),
                               Geom.UHStatic)
        vertex = GeomVertexWriter(vdata, 'vertex')
        normal = GeomVertexWriter(vdata, 'normal')
        texcoord = GeomVertexWriter(vdata, 'texcoord')
        color = GeomVertexWriter(vdata, 'color')

        axes = [Vec3.unitX(), Vec3.unitY(), Vec3.unitZ()]
        face = 0

        for x in range(3):
            for s in [-1, 1]:
                for i in range(self.__n + 1):
                    for j in range(self.__n + 1):
                        a = (i * 1.0 / self.__n) * (pi / 2) - (pi / 4)
                        b = (j * 1.0 / self.__n) * (pi / 2) - (pi / 4)
                        xAxis = axes[(x + 3) % 3]
                        yAxis = axes[(x + 4) % 3]
                        zAxis = axes[(x + 5) % 3]
                        v = (xAxis * (-cos(a) * sin(b)) + yAxis *
                             (sin(a) * cos(b)) + zAxis * (cos(a) * cos(b))) * s
                        v.normalize()
                        normal.addData3f(v)
                        vertex.addData3f(v * self.__radius)
                        texcoord.addData2f(i * 1.0, j * 1.0)
                        color.addData4f(self.__ocean_color)
                face = face + 1
        prim = self.__heightmap_primitive()
        geom = Geom(vdata)
        geom.addPrimitive(prim)
        return geom
コード例 #12
0
 def primitives(self, vdata):
     vertex = GeomVertexWriter(vdata, 'vertex')
     color = GeomVertexWriter(vdata, 'color')
     n = len(self.border)
     # Points
     for p in self.border:
         vertex.addData3f(p.x, p.y, p.z)
         color.addData4f(0.5, 0.5, 0.5, 0.0)
     for p in self.border:
         vertex.addData3f(p.x, p.y, p.z + self.top)
         color.addData4f(1.0, 1.0, 1.0, 0.0)
     # Wall
     wall = GeomTristrips(Geom.UHStatic)
     for i in range(n):
         wall.addVertices(i, i + n)
     wall.addVertices(0, n)
     wall.closePrimitive()
     yield wall
     # Ceiling
     if self.cover:
         ceil = GeomTristrips(Geom.UHStatic)
         ceil.addConsecutiveVertices(n, n)
         ceil.addVertex(n)
         ceil.closePrimitive()
         yield ceil
コード例 #13
0
ファイル: D_mesh.py プロジェクト: nkolkin13/ProcEdit
	def draw(self):
		if self.rendered_mesh != None:
			self.reset_draw()

		format=GeomVertexFormat.getV3n3cp()
		vdata=GeomVertexData('tri', format, Geom.UHDynamic)

		vertex=GeomVertexWriter(vdata, 'vertex')
		normal=GeomVertexWriter(vdata, 'normal')
		color=GeomVertexWriter(vdata, 'color')
		v_mapping = {}

		i=0
		for v in self.verts.values():
			vertex.addData3f(v.pos.x,v.pos.y,v.pos.z)
			normal.addData3f(v.norm.x, v.norm.y, v.norm.z)
			color.addData4f(v.color[0],v.color[1],v.color[2],v.color[3])
			v_mapping[v.ID] = i
			i += 1

		mesh = Geom(vdata)

		for f in self.faces.values():
			tri = GeomTriangles(Geom.UHDynamic)
			tri.addVertex(v_mapping[f.v1.ID])
			tri.addVertex(v_mapping[f.v2.ID])
			tri.addVertex(v_mapping[f.v3.ID])
			tri.closePrimitive()
			mesh.addPrimitive(tri)

		snode = GeomNode(self.name)
		snode.addGeom(mesh)
		self.rendered_mesh = render.attachNewNode(snode)
		self.rendered_mesh.setTwoSided(True)
コード例 #14
0
ファイル: D_mesh.py プロジェクト: nkolkin13/ProcEdit
    def draw(self):
        if self.rendered_mesh != None:
            self.reset_draw()

        format = GeomVertexFormat.getV3n3cp()
        vdata = GeomVertexData('tri', format, Geom.UHDynamic)

        vertex = GeomVertexWriter(vdata, 'vertex')
        normal = GeomVertexWriter(vdata, 'normal')
        color = GeomVertexWriter(vdata, 'color')
        v_mapping = {}

        i = 0
        for v in self.verts.values():
            vertex.addData3f(v.pos.x, v.pos.y, v.pos.z)
            normal.addData3f(v.norm.x, v.norm.y, v.norm.z)
            color.addData4f(v.color[0], v.color[1], v.color[2], v.color[3])
            v_mapping[v.ID] = i
            i += 1

        mesh = Geom(vdata)

        for f in self.faces.values():
            tri = GeomTriangles(Geom.UHDynamic)
            tri.addVertex(v_mapping[f.v1.ID])
            tri.addVertex(v_mapping[f.v2.ID])
            tri.addVertex(v_mapping[f.v3.ID])
            tri.closePrimitive()
            mesh.addPrimitive(tri)

        snode = GeomNode(self.name)
        snode.addGeom(mesh)
        self.rendered_mesh = render.attachNewNode(snode)
        self.rendered_mesh.setTwoSided(True)
コード例 #15
0
    def __build_Star_Sphere(self, bg_stars):
        from panda3d.core import GeomVertexWriter, GeomVertexFormat, GeomVertexData
        from panda3d.core import Geom, GeomNode, GeomPoints, AmbientLight
        self.star_sphere_np.removeNode()

        # Fill GeomVertexData.
        vformat = GeomVertexFormat.getV3c4()
        vdata = GeomVertexData("Data", vformat, Geom.UHStatic)
        vertices = GeomVertexWriter(vdata, "vertex")
        colours = GeomVertexWriter(vdata, "color")
        for coords in bg_stars:
            x, y, z = coords
            vertices.addData3f(x, y, z)
            colours.addData4f(1, 1, 1, 1)

        # Render bg stars.
        bg_stars = GeomPoints(Geom.UHStatic)
        bg_stars.addNextVertices(_env.STAR_COUNT)
        bg_stars_geom = Geom(vdata)
        bg_stars_geom.addPrimitive(bg_stars)
        star_sphere = GeomNode("star_sphere")
        star_sphere.addGeom(bg_stars_geom)
        star_sphere_np = NodePath(star_sphere)

        star_sphere_np.reparentTo(self.NP)
        return star_sphere_np
コード例 #16
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)
コード例 #17
0
ファイル: environments.py プロジェクト: svfgit/solex
    def __build_Star_Sphere(self, bg_stars):
        from panda3d.core import GeomVertexWriter, GeomVertexFormat, GeomVertexData
        from panda3d.core import Geom, GeomNode, GeomPoints, AmbientLight
        self.star_sphere_np.removeNode()
        
        # Fill GeomVertexData.
        vformat = GeomVertexFormat.getV3c4()
        vdata = GeomVertexData("Data", vformat, Geom.UHStatic) 
        vertices = GeomVertexWriter(vdata, "vertex")
        colours = GeomVertexWriter(vdata, "color")
        for coords in bg_stars:
            x, y, z = coords
            vertices.addData3f(x, y, z)
            colours.addData4f(1, 1, 1, 1)
            
        # Render bg stars.
        bg_stars = GeomPoints(Geom.UHStatic)
        bg_stars.addNextVertices(_env.STAR_COUNT)
        bg_stars_geom = Geom(vdata)
        bg_stars_geom.addPrimitive(bg_stars)
        star_sphere = GeomNode("star_sphere")
        star_sphere.addGeom(bg_stars_geom)
        star_sphere_np = NodePath(star_sphere)

        star_sphere_np.reparentTo(self.NP)
        return star_sphere_np
コード例 #18
0
    def __init__(self, base, obj, **kwargs):
        super(GalaxyView, self).__init__(base, obj, **kwargs)

        array = GeomVertexArrayFormat()
        array.addColumn(InternalName.make('vertex'), 3, Geom.NTFloat32,
                        Geom.CPoint)
        array.addColumn(InternalName.make('color'), 4, Geom.NTFloat32,
                        Geom.CColor)
        array.addColumn(InternalName.make('size'), 1, Geom.NTFloat32,
                        Geom.COther)
        gmformat = GeomVertexFormat()
        gmformat.addArray(array)
        gmformat = GeomVertexFormat.registerFormat(gmformat)

        vdata = GeomVertexData('points', gmformat, Geom.UHDynamic)

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

        self.node = NodePath('galaxy')
        self.node.reparentTo(self.base.render)
        self.node.setTransparency(TransparencyAttrib.MAlpha)

        lumsort = sorted([star.luminosity for star in self.obj.stars])
        #highest_luminosity = lumsort[-1]
        median_luminosity = lumsort[len(lumsort) / 2]
        for star in self.obj.stars:
            vertex.addData3f(star.galpos.x, star.galpos.y, star.galpos.z)
            color.addData4f(star.red, star.green, star.blue, 1.0)
            #size.addData1f(min(100, max(5, 10-star.magnitude/2)))
            sizeval = 10 + log(star.luminosity)
            size.addData1f(min(30, max(10, sizeval)))

        prim = GeomPoints(Geom.UHStatic)
        prim.addConsecutiveVertices(0, len(self.obj.stars))
        prim.closePrimitive()

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

        node = GeomNode('gnode')
        node.addGeom(geom)

        galaxy_node = self.node.attachNewNode(node)
        galaxy_node.setRenderModeThickness(1)
        ts = TextureStage.getDefault()  #TextureStage('ts')
        #ts.setMode(TextureStage.MGlow)
        galaxy_node.setTexGen(ts, TexGenAttrib.MPointSprite)
        galaxy_node.setTexture(
            ts, self.base.loader.loadTexture('texture/flare.png'))
        #galaxy_node.setRenderModePerspective(True)

        galaxy_node.setBin("unsorted", 1)
        galaxy_node.setDepthWrite(0)
        galaxy_node.setTransparency(1)

        self.setup_glow_shader()
        """
コード例 #19
0
ファイル: geometry.py プロジェクト: mhcrnl/panda_examples
    def create_geom(self, sidelength):
        # Set up the vertex arrays
        vformat = GeomVertexFormat.getV3n3c4()
        vdata = GeomVertexData("Data", vformat, Geom.UHDynamic)
        vertex = GeomVertexWriter(vdata, 'vertex')
        normal = GeomVertexWriter(vdata, 'normal')
        color = GeomVertexWriter(vdata, 'color')
        geom = Geom(vdata)

        # Write vertex data
        for x in range(0, sidelength):
            for y in range(0, sidelength):
                # vertex_number = x * sidelength + y
                v_x, v_y, v_z = self.map_b[(x, y)]
                n_x, n_y, n_z = 0.0, 0.0, 1.0
                c_r, c_g, c_b, c_a = 0.5, 0.5, 0.5, 0.5
                vertex.addData3f(v_x, v_y, v_z)
                normal.addData3f(n_x, n_y, n_z)
                color.addData4f(c_r, c_g, c_b, c_a)

        # Add triangles
        for x in range(0, sidelength - 1):
            for y in range(0, sidelength - 1):
                # The vertex arrangement (y up, x right)
                # 2 3
                # 0 1
                v_0 = x * sidelength + y
                v_1 = x * sidelength + (y + 1)
                v_2 = (x + 1) * sidelength + y
                v_3 = (x + 1) * sidelength + (y + 1)
                if (x+y)%1 == 0: # An even square
                    tris = GeomTriangles(Geom.UHStatic)
                    tris.addVertices(v_0, v_2, v_3)
                    tris.closePrimitive()
                    geom.addPrimitive(tris)
                    tris = GeomTriangles(Geom.UHStatic)
                    tris.addVertices(v_3, v_1, v_0)
                    tris.closePrimitive()
                    geom.addPrimitive(tris)
                else: # An odd square
                    tris = GeomTriangles(Geom.UHStatic)
                    tris.addVertices(v_1, v_0, v_2)
                    tris.closePrimitive()
                    geom.addPrimitive(tris)
                    tris = GeomTriangles(Geom.UHStatic)
                    tris.addVertices(v_2, v_3, v_1)
                    tris.closePrimitive()
                    geom.addPrimitive(tris)

        # Create the actual node
        node = GeomNode('geom_node')
        node.addGeom(geom)
        
        # Remember GeomVertexWriters to adjust vertex data later
        #self.vertex_writer = vertex
        #self.color_writer = color
        self.vdata = vdata
        
        return node
コード例 #20
0
    def create_geom(self, sidelength):
        # Set up the vertex arrays
        vformat = GeomVertexFormat.getV3n3c4()
        vdata = GeomVertexData("Data", vformat, Geom.UHDynamic)
        vertex = GeomVertexWriter(vdata, 'vertex')
        normal = GeomVertexWriter(vdata, 'normal')
        color = GeomVertexWriter(vdata, 'color')
        geom = Geom(vdata)

        # Write vertex data
        # Vertex data for the poles needs to be different
        for key, value in self.map.items():
            v_x, v_y, v_z, asteroid_color = value
            n_x, n_y, n_z = 1, 1, 1
            #c_r, c_g, c_b, c_a = asteroid_color, asteroid_color, asteroid_color, 1
            c_r, c_g, c_b, c_a = asteroid_color, asteroid_color, asteroid_color, 1
            vertex.addData3f(v_x, v_y, v_z)
            normal.addData3f(n_x, n_y, n_z)
            color.addData4f(c_r, c_g, c_b, c_a)
        #Create triangles
        #top of sphere
        verts_per_row = int(360 / self.step) + 1
        for vert in range(1, verts_per_row + 1):
            tris = GeomTriangles(Geom.UHStatic)
            tris.addVertices(vert + 1, 0, vert)
            tris.closePrimitive()
            geom.addPrimitive(tris)
        #middle of shpere
        for row in range(1, int(180 / self.step) - 1):
            for vert_iir in range(
                    0, verts_per_row -
                    1):  # vert_iir = vertex index in row, not vertex number
                vert_number = verts_per_row * row + vert_iir + 1
                vert_up_row = vert_number - verts_per_row
                #Bottom Triangle in the sphere
                tris = GeomTriangles(Geom.UHStatic)
                tris.add_vertices(vert_up_row, vert_number, vert_up_row + 1)
                tris.close_primitive()
                geom.addPrimitive(tris)
                #Top triangle of square
                tris = GeomTriangles(Geom.UHStatic)
                tris.add_vertices(vert_number + 1, vert_up_row + 1,
                                  vert_number)
                tris.close_primitive()
                geom.addPrimitive(tris)
        #bottom of sphere
        last_vert = len(self.map) - 1
        for vert in range(last_vert - verts_per_row, last_vert):
            tris = GeomTriangles(Geom.UHStatic)
            tris.add_vertices(vert - 1, last_vert, vert)
            tris.close_primitive()
            geom.addPrimitive(tris)

        # Create the actual node
        node = GeomNode('geom_node')
        node.addGeom(geom)

        return node
コード例 #21
0
    def makeSquare(x1, y1, z1, x2, y2, z2):
        format = GeomVertexFormat.getV3n3cpt2()
        vdata = GeomVertexData('square', format, Geom.UHDynamic)

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

        # make sure we draw the sqaure in the right plane
        if x1 != x2:
            vertex.addData3(x1, y1, z1)
            vertex.addData3(x2, y1, z1)
            vertex.addData3(x2, y2, z2)
            vertex.addData3(x1, y2, z2)

            normal.addData3(normalized(2 * x1 - 1, 2 * y1 - 1, 2 * z1 - 1))
            normal.addData3(normalized(2 * x2 - 1, 2 * y1 - 1, 2 * z1 - 1))
            normal.addData3(normalized(2 * x2 - 1, 2 * y2 - 1, 2 * z2 - 1))
            normal.addData3(normalized(2 * x1 - 1, 2 * y2 - 1, 2 * z2 - 1))

        else:
            vertex.addData3(x1, y1, z1)
            vertex.addData3(x2, y2, z1)
            vertex.addData3(x2, y2, z2)
            vertex.addData3(x1, y1, z2)

            normal.addData3(normalized(2 * x1 - 1, 2 * y1 - 1, 2 * z1 - 1))
            normal.addData3(normalized(2 * x2 - 1, 2 * y2 - 1, 2 * z1 - 1))
            normal.addData3(normalized(2 * x2 - 1, 2 * y2 - 1, 2 * z2 - 1))
            normal.addData3(normalized(2 * x1 - 1, 2 * y1 - 1, 2 * z2 - 1))

        # adding different colors to the vertex for visibility
        # color.addData4f(1.0, 0.0, 0.0, 1.0)
        # color.addData4f(0.0, 1.0, 0.0, 1.0)
        # color.addData4f(0.0, 0.0, 1.0, 1.0)
        # color.addData4f(1.0, 0.0, 1.0, 1.0)

        color.addData4f(1.0, 1.0, 1.0, 1.0)
        color.addData4f(1.0, 1.0, 1.0, 1.0)
        color.addData4f(1.0, 1.0, 1.0, 1.0)
        color.addData4f(1.0, 1.0, 1.0, 1.0)

        texcoord.addData2f(0.0, 1.0)
        texcoord.addData2f(0.0, 0.0)
        texcoord.addData2f(1.0, 0.0)
        texcoord.addData2f(1.0, 1.0)

        # Quads aren't directly supported by the Geom interface
        # you might be interested in the CardMaker class if you are
        # interested in rectangle though
        tris = GeomTriangles(Geom.UHDynamic)
        tris.addVertices(0, 1, 3)
        tris.addVertices(1, 2, 3)

        square = Geom(vdata)
        square.addPrimitive(tris)
        return square
コード例 #22
0
ファイル: vis_utils.py プロジェクト: shiraez/DataHack2018
class GroundGen(object):
    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)
コード例 #23
0
def makeSquare(x1, y1, z1, x2, y2, z2):
    format = GeomVertexFormat.getV3n3cpt2()
    vdata = GeomVertexData('square', format, Geom.UHDynamic)

    #initializing variables
    vertex = GeomVertexWriter(vdata, 'vertex')
    normal = GeomVertexWriter(vdata, 'normal')
    color = GeomVertexWriter(vdata, 'color')
    texcoord = GeomVertexWriter(vdata, 'texcoord')

    #gotta draw the sqaure in the right plane
    #aligning vertexes to the right planes
    if x1 != x2:
        vertex.addData3(x1, y1, z1)
        vertex.addData3(x2, y1, z1)
        vertex.addData3(x2, y2, z2)
        vertex.addData3(x1, y2, z2)

        normal.addData3(normalized(2 * x1 - 1, 2 * y1 - 1, 2 * z1 - 1))
        normal.addData3(normalized(2 * x2 - 1, 2 * y1 - 1, 2 * z1 - 1))
        normal.addData3(normalized(2 * x2 - 1, 2 * y2 - 1, 2 * z2 - 1))
        normal.addData3(normalized(2 * x1 - 1, 2 * y2 - 1, 2 * z2 - 1))

    else:
        #adding vertexes
        vertex.addData3(x1, y1, z1)
        vertex.addData3(x2, y2, z1)
        vertex.addData3(x2, y2, z2)
        vertex.addData3(x1, y1, z2)

        normal.addData3(normalized(2 * x1 - 1, 2 * y1 - 1, 2 * z1 - 1))
        normal.addData3(normalized(2 * x2 - 1, 2 * y2 - 1, 2 * z1 - 1))
        normal.addData3(normalized(2 * x2 - 1, 2 * y2 - 1, 2 * z2 - 1))
        normal.addData3(normalized(2 * x1 - 1, 2 * y1 - 1, 2 * z2 - 1))

    #adding different colors to the vertex for visibility
    color.addData4f(1.0, 0.0, 0.0, 1.0)
    color.addData4f(0.0, 1.0, 0.0, 1.0)
    color.addData4f(0.0, 0.0, 1.0, 1.0)
    color.addData4f(1.0, 0.0, 1.0, 1.0)

    texcoord.addData2f(0.0, 1.0)
    texcoord.addData2f(0.0, 0.0)
    texcoord.addData2f(1.0, 0.0)
    texcoord.addData2f(1.0, 1.0)

    #quads aren't directly supported by the geom interface
    tris = GeomTriangles(Geom.UHDynamic)
    tris.addVertices(0, 1, 3)
    tris.addVertices(1, 2, 3)

    #initialize surface
    square = Geom(vdata)
    square.addPrimitive(tris)
    return square
コード例 #24
0
 def update_geom(self, points, colors, sizes):
     geom = self.instance.children[0].node().modify_geom(0)
     vdata = geom.modify_vertex_data()
     vdata.unclean_set_num_rows(len(points))
     vwriter = GeomVertexRewriter(vdata, InternalName.get_vertex())
     colorwriter = GeomVertexWriter(vdata, InternalName.get_color())
     sizewriter = GeomVertexWriter(vdata, InternalName.get_size())
     for (point, color, size) in zip(points, colors, sizes):
         vwriter.addData3f(*point)
         colorwriter.addData4f(*color)
         sizewriter.addData1f(size)
コード例 #25
0
def makeGeom(index_counter, array, ctup, i, pipe, geomType=GeomPoints):
    """ multiprocessing capable geometery maker """
    #man = indexMan(('127.0.0.1',5000), authkey='none')
    #man.connect()
    #index = man.index()
    index = {}

    fmt = GeomVertexFormat.getV3c4()

    vertexData = GeomVertexData(
        'points', fmt, Geom.UHDynamic
    )  #FIXME use the index for these too? with setPythonTag, will have to 'reserve' some
    #vertexData.setPythonTag('uid',index.reserve()) #maybe we don't need this? the geom should have it all?
    cloudGeom = Geom(vertexData)
    #cloudGeom.setPythonTag('uid',index.reserve())
    cloudNode = GeomNode('bin %s selectable' % (i))
    uid = next(index_counter)
    index[uid] = None
    cloudNode.setPythonTag(
        'uid', uid
    )  #FIXME we return cloudnode elsewhere... maybe on the other end we can set the uid in the index properly?

    points = array

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

    for point in points:
        index[next(index_counter)] = [
            point, cloudNode.getPythonTag('uid'), None
        ]  #FIXME we're gonna need a decode on the other end?
        verts.addData3f(*point)
        color.addData4f(*ctup)

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

    cloudGeom.addPrimitive(points)
    cloudNode.addGeom(
        cloudGeom
    )  #TODO figure out if it is faster to add and subtract Geoms from geom nodes...
    #output[i] = cloudNode
    #print('ping',{i:cloudNode})
    #pipe.send((i,))
    #out = q.get()
    #print('pong',out)
    #q.put(out)
    if pipe == None:
        return cloudNode, index
    pipe.send(
        cloudNode.encodeToBamStream())  #FIXME make this return a pointer NOPE
    pipe.send(index)  #FIXME make this return a pointer NOPE
コード例 #26
0
def makeSquare(x1, y1, z1, x2, y2, z2):
    format = GeomVertexFormat.getV3n3cpt2()
    vdata = GeomVertexData('square', format, Geom.UHDynamic)

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

    # make sure we draw the sqaure in the right plane
    if x1 != x2:
        vertex.addData3(x1, y1, z1)
        vertex.addData3(x2, y1, z1)
        vertex.addData3(x2, y2, z2)
        vertex.addData3(x1, y2, z2)

        normal.addData3(normalized(2 * x1 - 1, 2 * y1 - 1, 2 * z1 - 1))
        normal.addData3(normalized(2 * x2 - 1, 2 * y1 - 1, 2 * z1 - 1))
        normal.addData3(normalized(2 * x2 - 1, 2 * y2 - 1, 2 * z2 - 1))
        normal.addData3(normalized(2 * x1 - 1, 2 * y2 - 1, 2 * z2 - 1))

    else:
        vertex.addData3(x1, y1, z1)
        vertex.addData3(x2, y2, z1)
        vertex.addData3(x2, y2, z2)
        vertex.addData3(x1, y1, z2)

        normal.addData3(normalized(2 * x1 - 1, 2 * y1 - 1, 2 * z1 - 1))
        normal.addData3(normalized(2 * x2 - 1, 2 * y2 - 1, 2 * z1 - 1))
        normal.addData3(normalized(2 * x2 - 1, 2 * y2 - 1, 2 * z2 - 1))
        normal.addData3(normalized(2 * x1 - 1, 2 * y1 - 1, 2 * z2 - 1))

    # adding different colors to the vertex for visibility
    color.addData4f(1.0, 0.0, 0.0, 1.0)
    color.addData4f(0.0, 1.0, 0.0, 1.0)
    color.addData4f(0.0, 0.0, 1.0, 1.0)
    color.addData4f(1.0, 0.0, 1.0, 1.0)

    texcoord.addData2f(0.0, 1.0)
    texcoord.addData2f(0.0, 0.0)
    texcoord.addData2f(1.0, 0.0)
    texcoord.addData2f(1.0, 1.0)

    # Quads aren't directly supported by the Geom interface
    # you might be interested in the CardMaker class if you are
    # interested in rectangle though
    tris = GeomTriangles(Geom.UHDynamic)
    tris.addVertices(0, 1, 3)
    tris.addVertices(1, 2, 3)

    square = Geom(vdata)
    square.addPrimitive(tris)
    return square
コード例 #27
0
 def set_points(self, position, color):
     assert len(position) == len(color)
     self.vertexData.setNumRows(len(position))
     self.primitive.clearVertices()
     for i in range(len(position)):
         self.primitive.addVertex(i)
     self.primitive.closePrimitive()
     positionWriter = GeomVertexWriter(self.vertexData, "vertex")
     colorWriter = GeomVertexWriter(self.vertexData, "color")
     for p, c in zip(position, color):
         positionWriter.addData3f(p[0], p[1], p[2])
         colorWriter.addData4f(c[0], c[1], c[2], c[3])
コード例 #28
0
def createTriangle(v1, v2, v3, is_flat=False):
	x1 = v1.x
	y1 = v1.y
	z1 = v1.z

	x2 = v2.x
	y2 = v2.y
	z2 = v2.z

	x3 = v3.x
	y3 = v3.y
	z3 = v3.z

	format=GeomVertexFormat.getV3n3cp()
	vdata=GeomVertexData('tri', format, Geom.UHDynamic)

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

	vertex.addData3f(x1, y1, z1)
	vertex.addData3f(x2, y2, z2)
	vertex.addData3f(x3, y3, z3)

	if is_flat:
		normVector = norm(Vec3( (x1 + x2 + x3)/3.0, (y1 + y2 + y3)/3.0, (z1+ z2+ z3)/3.0))

		normal.addData3f(normVector)
		normal.addData3f(normVector)
		normal.addData3f(normVector)

	else:
		normal.addData3f(norm(Vec3(x1,y1,z1)))
		normal.addData3f(norm(Vec3(x2,y2,z2)))
		normal.addData3f(norm(Vec3(x3,y3,z3)))

	#adding different colors to the vertex for visibility
	color.addData4f(0.5,0.5,0.5,1.0)
	color.addData4f(0.5,0.5,0.5,1.0)
	color.addData4f(0.5,0.5,0.5,1.0)

	tri = GeomTriangles(Geom.UHDynamic)

	tri.addVertex(0)
	tri.addVertex(1)
	tri.addVertex(2)

	tri.closePrimitive()

	output_tri = Geom(vdata)
	output_tri.addPrimitive(tri)

	return output_tri
コード例 #29
0
 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)
コード例 #30
0
ファイル: ui.py プロジェクト: tgbugs/desc
def makeAxis(): #FIXME make this scale based on zoom???
    """
    x y z
    r g b
    """
    colors = (
        (1,0,0,1),
        (0,1,0,1),
        (0,0,1,1),

        (1,0,0,1),
        (0,1,0,1),
        (0,0,1,1),
    )
    points = (
        (0,0,0),
        (0,0,0),
        (0,0,0),
        (1,0,0),
        (0,1,0),
        (0,0,1),
    )

    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 p,c in zip(points,colors):
        verts.addData3f(*p)
        color.addData4f(*c)

    axisX = GeomLinestrips(Geom.UHStatic)
    axisX.addVertices(0,3)
    axisX.closePrimitive()

    axisY = GeomLinestrips(Geom.UHStatic)
    axisY.addVertices(1,4)
    axisY.closePrimitive()

    axisZ = GeomLinestrips(Geom.UHStatic)
    axisZ.addVertices(2,5)
    axisZ.closePrimitive()

    axis = Geom(vertexData)
    axis.addPrimitive(axisX)
    axis.addPrimitive(axisY)
    axis.addPrimitive(axisZ)
    return axis
コード例 #31
0
    def Square(self):
        format = GeomVertexFormat.getV3n3cpt2()
        vdata = GeomVertexData('cube', format, Geom.UHDynamic)

        vertex = GeomVertexWriter(vdata, 'vertex')
        ################################
        #
        # FACE 1
        #
        ################################
        vert1 = LVector3(self.pos.getX(), self.pos.getY(), self.pos.getZ())
        vert2 = LVector3(vert1.getX() + self.len, vert1.getY(), vert1.getZ())
        vert3 = LVector3(vert2.getX(), vert2.getY() + self.wid, vert2.getZ())
        vert4 = LVector3(vert1.getX(), vert1.getY() + self.wid, vert1.getZ())

        vertex.addData3(vert1)
        vertex.addData3(vert2)
        vertex.addData3(vert3)
        vertex.addData3(vert4)

        normal = GeomVertexWriter(vdata, 'normal')
        norm = (vert4 - vert1).cross(vert2 - vert1)
        norm.normalize()

        normal.addData3(norm)
        normal.addData3(norm)
        normal.addData3(norm)
        normal.addData3(norm)

        color = GeomVertexWriter(vdata, 'color')
        color.addData4f(self.color)
        color.addData4f(self.color)
        color.addData4f(self.color)
        color.addData4f(self.color)

        texcoord = GeomVertexWriter(vdata, 'texcoord')
        texcoord.addData2f(1, 0)
        texcoord.addData2f(1, 1)
        texcoord.addData2f(0, 1)
        texcoord.addData2f(0, 0)

        tris = GeomTriangles(Geom.UHDynamic)

        tris.addVertices(0, 3, 1)
        tris.addVertices(1, 3, 2)

        square = Geom(vdata)
        square.addPrimitive(tris)
        self.prim = square

        self.model = GeomNode(self.name)
        self.model.addGeom(self.prim)
コード例 #32
0
ファイル: custom_geometry.py プロジェクト: ctschnur/tex_quads
def create_colored_polygon2d_GeomNode_from_point_cloud(point_cloud, color_vec4=Vec4(0., 0., 1., 1.)):
    # for triangulation (with tripy) the elements of point_cloud
    # must be 3-tuples instead of np.arrays
    triangles = tripy_modified.earclip(
        [tuple(elem) for elem in point_cloud])
    triangles = np.array(triangles)  # convert tuples to np.arrays

    # naive rendering: abusing the concept of an index buffer

    # format = GeomVertexFormat.getV3c4t2()
    format = GeomVertexFormat.getV3c4()
    vdata = GeomVertexData("colored_polygon", format, Geom.UHStatic)
    vdata.setNumRows(4)
    # make a Geom object to hold the primitives
    geom = Geom(vdata)  # give it a reference to the 
    # add position and color to each vertex
    vertex_pos_writer = GeomVertexWriter(vdata, "vertex")
    vertex_color_writer = GeomVertexWriter(vdata, "color")

    # fill vertex buffer
    for triangle in triangles: 
        vertex_pos_writer.addData3f(triangle[0][0], 0, triangle[0][1])  # z is up
        vertex_pos_writer.addData3f(triangle[1][0], 0, triangle[1][1])
        vertex_pos_writer.addData3f(triangle[2][0], 0, triangle[2][1])
        vertex_color_writer.addData4f(color_vec4)
        vertex_color_writer.addData4f(color_vec4)
        vertex_color_writer.addData4f(color_vec4)

    # create the GeomPrimitive (just one) by filling the index buffer 
    # in stages. The documentation says 'Each GeomPrimitive object actually
    # stores several different individual primitives, each of which is
    # represwended simply as a list of vertex numbers, indexing into the
    # vertices stored in the associated GeomVertexData'

    tris = GeomTriangles(Geom.UHStatic)  # derived from GeomPrimitive
    # for idx, triangle in enumerate(triangles): 
    #     tris.addVertex(idx*3 + 0)
    #     tris.addVertex(idx*3 + 1)
    #     tris.addVertex(idx*3 + 2)
    #     # close the current primitive (not the GeomPrimitive!)

    tris.add_consecutive_vertices(0, 3*len(triangles))

    tris.closePrimitive()

    geom.addPrimitive(tris)

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

    return geom_node 
コード例 #33
0
ファイル: custom_geometry.py プロジェクト: ctschnur/tex_quads
def createColoredUnitQuadGeomNode(color_vec4=Vec4(0., 0., 1., 1.), center_it=False):
    # Own Geometry

    # format = GeomVertexFormat.getV3c4t2()
    format = GeomVertexFormat.getV3c4()
    vdata = GeomVertexData("colored_quad", format, Geom.UHStatic)
    vdata.setNumRows(4)

    vertexPosWriter = GeomVertexWriter(vdata, "vertex")
    if center_it == False: 
        vertexPosWriter.addData3f(0, 0, 0)
        vertexPosWriter.addData3f(1, 0, 0)
        vertexPosWriter.addData3f(1, 0, 1)
        vertexPosWriter.addData3f(0, 0, 1)
    else:
        vertexPosWriter.addData3f(0 - 0.5, 0, 0 - 0.5)
        vertexPosWriter.addData3f(1 - 0.5, 0, 0 - 0.5)
        vertexPosWriter.addData3f(1 - 0.5, 0, 1 - 0.5)
        vertexPosWriter.addData3f(0 - 0.5, 0, 1 - 0.5)


    # let's also add color to each vertex
    colorWriter = GeomVertexWriter(vdata, "color")
    colorWriter.addData4f(color_vec4)
    colorWriter.addData4f(color_vec4)
    colorWriter.addData4f(color_vec4)
    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 = GeomTriangles(Geom.UHStatic)

    # 1st triangle
    tris.addVertices(0, 1, 3)
    tris.closePrimitive()  # the 1st primitive is finished

    # 2nd triangle
    tris.addVertices(1, 2, 3)
    tris.closePrimitive()

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

    # now put quadGeom in a GeomNode. You can now position your geometry
    # in the scene graph.
    quadGeomNode = GeomNode("colored_quad_node")
    quadGeomNode.addGeom(quadGeom)

    return quadGeomNode
コード例 #34
0
    def __init__(self, nrects: int = 100, wheel_width=0.2, zpos=-0.38):
        """
		Initalizes one track for a skid mark.  The mark will be placed parallel to X-Y in world coordinates.
		They will be placed at the given height given by 'zpos'.  The 'nrects' argument specifies how long
		the skid can be in input point locations.  You can make the skid mark longer by increasing nrects, or
		spreading out the distance between input points.  Once nrect points have been input, the earlier points
		will disappear.  The 'wheel-width' parameter is the thickness of the wheel that is producing the marks.
		"""
        self.wheel_width = wheel_width  # One unit = about 10 inches in current world.
        self.wheel_state = [
        ]  # Tupels of: X, Y position of wheel, While Direction in degrees, and force
        self.nrects = nrects
        self.zpos = zpos
        self.vdata = GeomVertexData("skid", GeomVertexFormat.getV3c4(),
                                    Geom.UHStatic)
        self.vdata.setNumRows(4 * nrects)
        vtx = GeomVertexWriter(self.vdata, "vertex")
        cx = GeomVertexWriter(self.vdata, "color")
        prim = GeomTriangles(Geom.UHStatic)
        c = self.forceToColor(0.0)
        # Here we set up all the vertexts and the primatives that use them.  For each set of four vertices, a
        # flat rectangle is defined. Then 4 primatives are defined by splitting up the rectangle into pair of 2
        # triangles -- 4 triangles per rectangle. Each pair of triangles are identical, except that their normals
        # are opposite, so that we don't have to worry about back culling later.  Although it would be possible
        # to share vertics between the rectangles we don't do that here so that the chain can be cut at any point
        # by only operating on the vertics and not visiting the primatives.  Finally, to "disable" a rectangle,
        # we set all the vertics to the same point in 3D space (and therefore create a zero-area rectangle).
        for i in range(nrects):
            vtx.addData3f(0.0, 0.0, 0.0)
            vtx.addData3f(0.0, 0.0, 0.0)
            vtx.addData3f(0.0, 0.0, 0.0)
            vtx.addData3f(0.0, 0.0, 0.0)
            cx.addData4f(*c)
            cx.addData4f(*c)
            cx.addData4f(*c)
            cx.addData4f(*c)
            j = i * 4
            j0, j1, j2, j3 = j + 0, j + 1, j + 2, j + 3
            prim.addVertices(j0, j1, j3)
            prim.addVertices(j3, j1, j0)
            prim.addVertices(j0, j3, j2)
            prim.addVertices(j2, j3, j0)
        prim.closePrimitive()
        geom = Geom(self.vdata)
        geom.addPrimitive(prim)
        node = GeomNode('Skid')
        node.addGeom(geom)
        self.nodepath = render.attachNewNode(node)
        self.nextrect = 0
        self.havelast = False
        self.lastpoints = (0, 0, 0, 0)
コード例 #35
0
 def primitives_lines(self, vdata):
     vertex = GeomVertexWriter(vdata, 'vertex')
     color = GeomVertexWriter(vdata, 'color')
     n = len(self.points)
     # Points
     for p in self.points:
         vertex.addData3f(p.x, p.y, p.z)
         color.addData4f(0.2, 0.2, 0.2, 0.0)
     # Triangles
     for a, b, c in self.vertices:
         lines = GeomLinestrips(Geom.UHStatic)
         lines.addVertices(a, b, c, a)
         lines.closePrimitive()
         yield lines
コード例 #36
0
def create_colored_rect(x, z, width, height, colors=None):
    _format = GeomVertexFormat.getV3c4()
    vdata = GeomVertexData('square', _format, Geom.UHDynamic)

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

    vertex.addData3(x, 0, z)
    vertex.addData3(x + width, 0, z)
    vertex.addData3(x + width, 0, z + height)
    vertex.addData3(x, 0, z + height)

    if colors:
        if len(colors) < 4:
            colors = (1.0, 1.0, 1.0, 1.0)
        color.addData4f(colors)
        color.addData4f(colors)
        color.addData4f(colors)
        color.addData4f(colors)
    else:
        color.addData4f(1.0, 0.0, 0.0, 1.0)
        color.addData4f(0.0, 1.0, 0.0, 1.0)
        color.addData4f(0.0, 0.0, 1.0, 1.0)
        color.addData4f(1.0, 1.0, 1.0, 1.0)

    tris = GeomTriangles(Geom.UHDynamic)
    tris.addVertices(0, 1, 2)
    tris.addVertices(2, 3, 0)

    square = Geom(vdata)
    square.addPrimitive(tris)
    return square
コード例 #37
0
def makeAxis():  #FIXME make this scale based on zoom???
    """
    x y z
    r g b
    """
    colors = (
        (1, 0, 0, 1),
        (0, 1, 0, 1),
        (0, 0, 1, 1),
        (1, 0, 0, 1),
        (0, 1, 0, 1),
        (0, 0, 1, 1),
    )
    points = (
        (0, 0, 0),
        (0, 0, 0),
        (0, 0, 0),
        (1, 0, 0),
        (0, 1, 0),
        (0, 0, 1),
    )

    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 p, c in zip(points, colors):
        verts.addData3f(*p)
        color.addData4f(*c)

    axisX = GeomLinestrips(Geom.UHStatic)
    axisX.addVertices(0, 3)
    axisX.closePrimitive()

    axisY = GeomLinestrips(Geom.UHStatic)
    axisY.addVertices(1, 4)
    axisY.closePrimitive()

    axisZ = GeomLinestrips(Geom.UHStatic)
    axisZ.addVertices(2, 5)
    axisZ.closePrimitive()

    axis = Geom(vertexData)
    axis.addPrimitive(axisX)
    axis.addPrimitive(axisY)
    axis.addPrimitive(axisZ)
    return axis
コード例 #38
0
class ModelBuilder:
    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

    def _add_point(self, v, n, c):
        self.vertex.addData3f(v[0], v[1], v[2])
        self.normal.addData3f(n[0], n[1], n[2])
        self.color.addData4f(c[0], c[1], c[2], c[3])
        self.idx += 1
        return self.idx - 1

    def add_triangle(self, v1, v2, v3, n, c):
        i0 = self._add_point(v1, n, c)
        i1 = self._add_point(v2, n, c)
        i2 = self._add_point(v3, n, c)
        self.prim.addVertices(i0, i1, i2)

    def add_rect(self, org, w, h, n, c):
        i0 = self._add_point(org, n, c)
        i1 = self._add_point(org + w, n, c)
        i2 = self._add_point(org + w + h, n, c)
        i3 = self._add_point(org + h, n, c)
        self.prim.addVertices(i0, i1, i2)
        self.prim.addVertices(i2, i3, i0)

    def add_box(self, org, w, h, l, c):
        self.add_rect(org, w, h, -norm(l), c)
        self.add_rect(org, w, l, -norm(h), c)
        self.add_rect(org, h, l, -norm(w), c)
        self.add_rect(org + w, l, h, norm(w), c)
        self.add_rect(org + h, l, w, norm(h), c)
        self.add_rect(org + l, h, w, norm(l), c)

    def build(self, name):
        self.prim.closePrimitive()

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

        node = GeomNode(name)
        node.addGeom(geom)
        return node
コード例 #39
0
    def createTetraeder(self, iterations):
        ''' 
        Note that the first and the last node of the Thetha_Range should be 0 and 180 Degrees 
        because this will be just one time added to verticies
        '''
        #Format
        format = GeomVertexFormat.getV3n3cpt2()
        #VertexData
        vdata = GeomVertexData('name', format, Geom.UHDynamic)


        ##VertexWriter
        vertex      = GeomVertexWriter(vdata, 'vertex')
        normal      = GeomVertexWriter(vdata, 'normal')
        color       = GeomVertexWriter(vdata, 'color')
        texcoord    = GeomVertexWriter(vdata, 'texcoord')
        
        
        vertex.addData3f(0,1.434,-0.507)
        vertex.addData3f(-1.242,-0.717,-0.507)
        vertex.addData3f(1.242,-0.717,-0.507)
        vertex.addData3f(0,0,1.521)
        
        color.addData4f(1,1,1,1)
        color.addData4f(1,1,1,1)
        color.addData4f(1,1,1,1)
        color.addData4f(1,1,1,1)

        normal.addData3f(0,1.434,-0.507)
        normal.addData3f(-1.242,-0.717,-0.507)
        normal.addData3f(1.242,-0.717,-0.507)
        normal.addData3f(0,0,1.521)

        ### Create Geom
        geom = Geom(vdata)
        ### Create Primitives
        prim = GeomTriangles(Geom.UHStatic)
        prim.addVertices(0, 1, 2)
        prim.addVertices(0, 1, 3)
        prim.addVertices(1, 2, 3)
        prim.addVertices(2, 0, 3)
        prim.closePrimitive()

        geom.addPrimitive(prim)
        
        node = GeomNode('gnode')
        node.addGeom(geom)
        
        return node
コード例 #40
0
ファイル: selection.py プロジェクト: tgbugs/desc
def makePoint(point=(0,0,0)):
    clr4 = [1,1,1,1]
    fmt = GeomVertexFormat.getV3c4() #3 component vertex, w/ 4 comp color
    vertexData = GeomVertexData('points', fmt, Geom.UHStatic)
    verts = GeomVertexWriter(vertexData, 'vertex')
    verts.addData3f(*point)
    color = GeomVertexWriter(vertexData, 'color')
    color.addData4f(*clr4)
    pointCloud = GeomPoints(Geom.UHStatic)
    pointCloud.addVertex(0)
    pointCloud.closePrimitive()
    cloud = Geom(vertexData)
    cloud.addPrimitive(pointCloud)
    cloudNode = GeomNode('point')
    cloudNode.addGeom(cloud)
    return cloudNode
コード例 #41
0
ファイル: test_objects.py プロジェクト: tgbugs/desc
def makeGeom(index_counter, array,ctup,i,pipe, geomType=GeomPoints):
    """ multiprocessing capable geometery maker """
    #man = indexMan(('127.0.0.1',5000), authkey='none')
    #man.connect()
    #index = man.index()
    index = {}

    fmt = GeomVertexFormat.getV3c4()

    vertexData = GeomVertexData('points', fmt, Geom.UHDynamic) #FIXME use the index for these too? with setPythonTag, will have to 'reserve' some
    #vertexData.setPythonTag('uid',index.reserve()) #maybe we don't need this? the geom should have it all?
    cloudGeom = Geom(vertexData)
    #cloudGeom.setPythonTag('uid',index.reserve())
    cloudNode = GeomNode('bin %s selectable'%(i))
    uid = next(index_counter)
    index[uid] = None
    cloudNode.setPythonTag('uid',uid) #FIXME we return cloudnode elsewhere... maybe on the other end we can set the uid in the index properly?

    points = array

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

    for point in points:
        index[next(index_counter)]=[point,cloudNode.getPythonTag('uid'),None] #FIXME we're gonna need a decode on the other end?
        verts.addData3f(*point)
        color.addData4f(*ctup)

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

    cloudGeom.addPrimitive(points)
    cloudNode.addGeom(cloudGeom) #TODO figure out if it is faster to add and subtract Geoms from geom nodes...
    #output[i] = cloudNode
    #print('ping',{i:cloudNode})
    #pipe.send((i,))
    #out = q.get()
    #print('pong',out)
    #q.put(out)
    if pipe == None:
        return cloudNode, index
    pipe.send(cloudNode.encodeToBamStream()) #FIXME make this return a pointer NOPE
    pipe.send(index) #FIXME make this return a pointer NOPE
コード例 #42
0
ファイル: ui.py プロジェクト: tgbugs/desc
def makeCameraTarget():
    colors = (
        (0,0,1,1),
        (1,0,0,1),
        (0,1,0,1),
        (0,0,1,1),
        (1,0,0,1),
        (0,1,0,1),
    )
    points = (
        (0,0,1),
        (-1,0,0),
        (0,-1,0),
        (0,0,-1),
        (1,0,0),
        (0,1,0),
        (0,0,1),
    )

    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 p,c in zip(points,colors):
        verts.addData3f(*p)
        color.addData4f(*c)

    targetTris = GeomTristrips(Geom.UHStatic)
    targetTris.addConsecutiveVertices(0,6)
    targetTris.addVertex(0)
    targetTris.addVertex(1)
    targetTris.addVertex(3)
    targetTris.addVertex(5)
    targetTris.addVertex(2)
    targetTris.addVertex(4)
    targetTris.addVertex(0)
    targetTris.closePrimitive()

    target = Geom(vertexData)
    target.addPrimitive(targetTris)
    return target
コード例 #43
0
ファイル: mesh_selection.py プロジェクト: nkolkin13/ProcEdit
	def draw_vert(self,v, v_color):
		format = GeomVertexFormat.getV3cp()
		vdata=GeomVertexData('vert', format, Geom.UHDynamic)
		vertex=GeomVertexWriter(vdata, 'vertex')
		color=GeomVertexWriter(vdata, 'color')
		vertex.addData3f(0.0,0.0,0.0)
		color.addData4f(v_color)		
		mesh = Geom(vdata)
		point = GeomPoints(Geom.UHDynamic)
		point.addVertex(0)
		point.closePrimitive()
		mesh.addPrimitive(point)
		vert_node = GeomNode(self.mesh.name+'_vert_'+str(v.ID))
		vert_node.addGeom(mesh)
		vert_node.setTag('ID',str(v.ID))
		rendered_vert = self.render_root.attachNewNode(vert_node)
		rendered_vert.setPos(v.pos.x,v.pos.y,v.pos.z)
		rendered_vert.setRenderModeThickness(5.0)
		self.render_nodes['vert_'+str(v.ID)] = rendered_vert
コード例 #44
0
def makeCircle(vdata, numVertices=40,offset=Vec3(0,0,0), direction=1):
	circleGeom=Geom(vdata)

	vertWriter=GeomVertexWriter(vdata, "vertex")
	normalWriter=GeomVertexWriter(vdata, "normal")
	colorWriter=GeomVertexWriter(vdata, "color")
	uvWriter=GeomVertexWriter(vdata, "texcoord")
	drawWriter=GeomVertexWriter(vdata, "drawFlag")

	#make sure we start at the end of the GeomVertexData so we dont overwrite anything
	#that might be there already
	startRow=vdata.getNumRows()

	vertWriter.setRow(startRow)
	colorWriter.setRow(startRow)
	uvWriter.setRow(startRow)
	normalWriter.setRow(startRow)
	drawWriter.setRow(startRow)

	angle=2*math.pi/numVertices
	currAngle=angle

	for i in range(numVertices):
		position=Vec3(math.cos(currAngle)+offset.getX(), math.sin(currAngle)+offset.getY(),offset.getZ())
		vertWriter.addData3f(position)
		uvWriter.addData2f(position.getX()/2.0+0.5,position.getY()/2.0+0.5)
		colorWriter.addData4f(1.0, 1.0, 1.0, 1.0)
		position.setZ(position.getZ()*direction)
		position.normalize()
		normalWriter.addData3f(position)
		
		#at default Opengl only draws "front faces" (all shapes whose vertices are arranged CCW). We
		#need direction so we can specify which side we want to be the front face
		currAngle+=angle*direction

	circle=GeomTrifans(Geom.UHStatic)
	circle.addConsecutiveVertices(startRow, numVertices)
	circle.closePrimitive()

	circleGeom.addPrimitive(circle)
	
	return circleGeom
コード例 #45
0
ファイル: test_objects.py プロジェクト: tgbugs/desc
    def msgVec(self, ctup, x, y, z):
        vertexData = GeomVertexData('points', self.fmt, Geom.UHDynamic)
        cloudGeom = Geom(vertexData)
        cloudNode = GeomNode('just some points')

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

        for x_, y_, z_, c in zip(x, y, z, ctup):
            verts.addData3f(x_, y_, z_)
            color.addData4f(*c)

        points = self.geomType(Geom.UHDynamic)  # FIXME static?
        points.addConsecutiveVertices(0,len(x))
        points.closePrimitive()

        cloudGeom.addPrimitive(points)
        cloudNode.addGeom(cloudGeom) #TODO figure out if it is faster to add and subtract Geoms from geom nodes...
        print(cloudNode)
        return cloudNode
コード例 #46
0
ファイル: shaders.py プロジェクト: tgbugs/desc
def make_cube(x, y, z):  # FIXME make prism
    """ make x, y, z sized cube (ints pls) """
    colors = [[1,1,1,0] for i in range(8)]
    #colors[0] = np.array((1,1,1,1))
    #colors[1] = np.array((1,0,0,0))
    #colors[2] = np.array((0,1,0,0))
    #colors[5] = np.array((0,0,1,0))
    points = (
        (0,0,0),
        (0,0,z),
        (0,y,0),
        (0,y,z),
        (x,0,0),
        (x,0,z),
        (x,y,0),
        (x,y,z),
    )
    order = [0, 5, 1, 7, 3, 2, 1, 0, 5, 4, 7, 6, 2, 4, 0]  # perfect for clockwise
    #order = [2, 6, 3, 7, 5, 6, 4, 2, 0, 3, 1, 4, 0, 4]
    #order.reverse()
    #order = [4, 3, 7, 8, 5, 3, 1, 4, 2, 7, 6, 5, 2, 1]


    fmt = GeomVertexFormat.getV3c4()
    vertexData = GeomVertexData('points', fmt, Geom.UHStatic)
    verts = GeomVertexWriter(vertexData, 'vertex')
    color = GeomVertexWriter(vertexData, 'color')

    for p,c in zip(points,colors):
        verts.addData3f(*p)
        color.addData4f(*c)

    targetTris = GeomTristrips(Geom.UHStatic)
    targetTris.addConsecutiveVertices(0,8)
    for i in order:
        targetTris.addVertex(i)#-1)
    targetTris.closePrimitive()

    target = Geom(vertexData)
    target.addPrimitive(targetTris)
    return target
コード例 #47
0
 def create_model(self):
     # Set up the vertex arrays
     vformat = GeomVertexFormat.get_v3c4()
     vdata = GeomVertexData("Data", vformat, Geom.UHStatic)
     vertex = GeomVertexWriter(vdata, 'vertex')
     color = GeomVertexWriter(vdata, 'color')
     geom = Geom(vdata)
     # Vertex data
     vertex.addData3f(1.5, 0, -1)
     color.addData4f(1, 0, 0, 1)
     vertex.addData3f(-1.5, 0, -1)
     color.addData4f(0, 1, 0, 1)
     vertex.addData3f(0, 0, 1)
     color.addData4f(0, 0, 1, 1)
     # Primitive
     tri = GeomTriangles(Geom.UHStatic)
     tri.add_vertex(2)
     tri.add_vertex(1)
     tri.add_vertex(0)
     tri.close_primitive()
     geom.addPrimitive(tri)
     # Create the actual node
     node = GeomNode('geom_node')
     node.addGeom(geom)
     np = NodePath(node)
     # Shader and initial shader vars
     np.set_shader(Shader.load(Shader.SL_GLSL, "shader/shader.vert", "shader/shader.frag"))
     np.set_shader_input("time", 0.0)
     # No instancing necessary
     #np.set_instance_count(27)
     # return np
     np.reparent_to(base.render)
     self.model = np
コード例 #48
0
ファイル: mesh_selection.py プロジェクト: nkolkin13/ProcEdit
	def draw_face(self,f,f_color):
		#add normal
		format = GeomVertexFormat.getV3n3cp()
		vdata=GeomVertexData('vert', format, Geom.UHDynamic)
		vertex=GeomVertexWriter(vdata, 'vertex')
		color=GeomVertexWriter(vdata, 'color')
		normal=GeomVertexWriter(vdata, 'normal')

		vertex.addData3f(f.v1.pos)
		normal.addData3f(f.v1.norm.x, f.v1.norm.y, f.v1.norm.z)
		color.addData4f(f_color)

		vertex.addData3f(f.v2.pos)
		normal.addData3f(f.v2.norm.x, f.v2.norm.y, f.v2.norm.z)
		color.addData4f(f_color)	

		vertex.addData3f(f.v3.pos)
		normal.addData3f(f.v3.norm.x, f.v3.norm.y, f.v3.norm.z)		
		color.addData4f(f_color)		

		mesh = Geom(vdata)
		tri = GeomTriangles(Geom.UHDynamic)
		tri.addVertex(0)
		tri.addVertex(1)
		tri.addVertex(2)
		tri.closePrimitive()
		mesh.addPrimitive(tri)
		face_node = GeomNode(self.mesh.name+'_face_'+str(f.ID))
		face_node.addGeom(mesh)
		face_node.setTag('ID',str(f.ID))
		rendered_face = self.render_root.attachNewNode(face_node)
		rendered_face.setTwoSided(True)
		self.render_nodes['face_'+str(f.ID)] = rendered_face
コード例 #49
0
ファイル: test_objects.py プロジェクト: tgbugs/desc
def makeSimpleGeom(array, ctup, geomType = GeomPoints, fix = False):
    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')

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

    if fix:
        if len(ctup) == len(array):
            for point,c in zip(array, ctup):
                verts.addData3f(*point)
                color.addData4f(*c)
        else:
            for point in array:
                verts.addData3f(*point)
                color.addData4f(*ctup)
    else:
        for point in array:
            verts.addData3f(*point)
            color.addData4f(*ctup)

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

    cloudGeom.addPrimitive(points)
    cloudNode.addGeom(cloudGeom) #TODO figure out if it is faster to add and subtract Geoms from geom nodes...

    if fix:
        return cloudNode.__reduce__()
    else:
        return cloudNode  # decoding fails becuase ForkingPickler is called for reasons beyond comprehension
コード例 #50
0
	def reconstruct(self):
		trianglator = Triangulator()

		#Add vertices to the trianglator
		for vertex in self.vertices:
			trianglator.addPolygonVertex(trianglator.addVertex(vertex))
		
		trianglator.triangulate()

		#Prepare to create the primative
		self.vdata = GeomVertexData('floor', GeomVertexFormat.getV3n3cpt2(), Geom.UHStatic)
		vertexW = GeomVertexWriter(self.vdata, 'vertex')
		normalW = GeomVertexWriter(self.vdata, 'normal')
		colorW = GeomVertexWriter(self.vdata, 'color')
		texcoordW = GeomVertexWriter(self.vdata, 'texcoord')

		#Add vertices to the primative
		i = 0
		while i < trianglator.getNumVertices():
			vertex = trianglator.getVertex(i)
			vertexW.addData3f(vertex.x,vertex.y,0.0)
			normalW.addData3f(0,0,1)
			colorW.addData4f(0.1,0.1,0.1,0.5)
			texcoordW.addData2f(0.0, 1.0)	
			i+=1

		self.geom = Geom(self.vdata)

		#Add triangles to the primative
		i = 0
		print(trianglator.getNumTriangles())
		while i < trianglator.getNumTriangles():
			tri = GeomTriangles(Geom.UHStatic)
			tri.addVertices(trianglator.getTriangleV0(i),trianglator.getTriangleV1(i),trianglator.getTriangleV2(i))
			tri.closePrimitive()
			self.geom.addPrimitive(tri)
			i+=1

		self.addGeom(self.geom)
コード例 #51
0
ファイル: Sky.py プロジェクト: GitNitneroc/tethical
 def __init__(self, mp):
     vdata = GeomVertexData("name_me", GeomVertexFormat.getV3c4(), Geom.UHStatic)
     vertex = GeomVertexWriter(vdata, "vertex")
     color = GeomVertexWriter(vdata, "color")
     primitive = GeomTristrips(Geom.UHStatic)
     film_size = base.cam.node().getLens().getFilmSize()
     x = film_size.getX() / 2.0
     z = x * 256.0 / 240.0
     vertex.addData3f(x, 90, z)
     vertex.addData3f(-x, 90, z)
     vertex.addData3f(x, 90, -z)
     vertex.addData3f(-x, 90, -z)
     color.addData4f(VBase4(*mp["backgroundcolor1"]))
     color.addData4f(VBase4(*mp["backgroundcolor1"]))
     color.addData4f(VBase4(*mp["backgroundcolor2"]))
     color.addData4f(VBase4(*mp["backgroundcolor2"]))
     primitive.addNextVertices(4)
     primitive.closePrimitive()
     geom = Geom(vdata)
     geom.addPrimitive(primitive)
     self.node = GeomNode("sky")
     self.node.addGeom(geom)
     base.camera.attachNewNode(self.node)
コード例 #52
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
コード例 #53
0
    def create_model(self):
        # Set up the vertex arrays
        vformatArray = GeomVertexArrayFormat()
        # Panda3D implicitly generates a bounding volume from a
        # column named "vertex", so you either
        # * have a column of that name, or
        # * add a bounding volume yourself.
        vformatArray.addColumn(InternalName.make("vertex"), 3, Geom.NTFloat32, Geom.CPoint)
        vformatArray.addColumn(InternalName.make("color"), 4, Geom.NTFloat32, Geom.CColor)

        vformat = GeomVertexFormat()
        vformat.addArray(vformatArray)
        vformat = GeomVertexFormat.registerFormat(vformat)

        vdata = GeomVertexData("Data", vformat, Geom.UHStatic)
        vertex = GeomVertexWriter(vdata, 'vertex')
        color = GeomVertexWriter(vdata, 'color')

        geom = Geom(vdata)

        # Vertex data
        vertex.addData3f(1.5, 0, -1)
        color.addData4f(1, 0, 0, 1)
        vertex.addData3f(-1.5, 0, -1)
        color.addData4f(0, 1, 0, 1)
        vertex.addData3f(0, 0, 1)
        color.addData4f(0, 0, 1, 1)

        # Primitive
        tri = GeomPatches(3, Geom.UHStatic)
        tri.add_vertex(2)
        tri.add_vertex(1)
        tri.add_vertex(0)
        tri.close_primitive()
        geom.addPrimitive(tri)

        # Create the actual node
        node = GeomNode('geom_node')
        node.addGeom(geom)
        np = NodePath(node)

        # Shader, initial shader vars, number of instances
        np.set_shader(Shader.load(Shader.SL_GLSL,
                                  vertex = "shader.vert",
                                  tess_control = "shader.tesc",
                                  tess_evaluation = "shader.tese",
                                  geometry = "shader.geom",
                                  fragment = "shader.frag"))
        np.set_shader_input("time", 0.0)
        np.set_shader_input("tess_level", 32.0)
        np.set_instance_count(num_instances)
        np.set_shader_input("numInstances", num_instances)
        return np
コード例 #54
0
def renderCharts(facegraph, verts, vert_indices, lineset=None):
    
    from meshtool.filters.panda_filters.pandacore import getVertexData, attachLights, ensureCameraAt
    from meshtool.filters.panda_filters.pandacontrols import KeyboardMovement, MouseDrag, MouseScaleZoom, ButtonUtils
    from panda3d.core import GeomTriangles, Geom, GeomNode, GeomVertexFormat, GeomVertexData, GeomVertexWriter, LineSegs
    from direct.showbase.ShowBase import ShowBase
       
    vformat = GeomVertexFormat.getV3c4()
    vdata=GeomVertexData('tris', vformat, Geom.UHDynamic)

    vertex=GeomVertexWriter(vdata, 'vertex')
    color=GeomVertexWriter(vdata, 'color')
    
    colors = gen_color3(len(facegraph))
    numtris = 0
    for chart, data in facegraph.nodes_iter(data=True):
        curcolor = next(colors)
        for tri in data['tris']:
            triv = verts[vert_indices[tri]]
            vertex.addData3f(triv[0][0], triv[0][1], triv[0][2])
            vertex.addData3f(triv[1][0], triv[1][1], triv[1][2])
            vertex.addData3f(triv[2][0], triv[2][1], triv[2][2])
            color.addData4f(curcolor[0],curcolor[1], curcolor[2], 1)
            color.addData4f(curcolor[0],curcolor[1], curcolor[2], 1)
            color.addData4f(curcolor[0],curcolor[1], curcolor[2], 1)
            numtris += 1

    tris=GeomTriangles(Geom.UHDynamic)
    tris.addConsecutiveVertices(0, 3*numtris)
    tris.closePrimitive()
        
    linenodes = []
    if lineset:
        for lines in lineset:
            ls = LineSegs()
            ls.setThickness(4)
            curcolor = next(colors)
            ls.setColor(curcolor[0]/256.0, curcolor[1]/256.0, curcolor[2]/256.0, 1)
    
            tuples = False
            for blah in lines:
                if isinstance(blah, tuple):
                    tuples = True
                break
            if tuples:
                for i, j in lines:
                    frompt = verts[i]
                    topt = verts[j]
                    ls.moveTo(frompt[0], frompt[1], frompt[2])
                    ls.drawTo(topt[0], topt[1], topt[2])
            else:
                for i in range(len(lines)-1):
                    frompt = verts[lines[i]]
                    topt = verts[lines[i+1]]
                    ls.moveTo(frompt[0], frompt[1], frompt[2])
                    ls.drawTo(topt[0], topt[1], topt[2])
            
            linenodes.append(ls.create())
        

    pgeom = Geom(vdata)
    pgeom.addPrimitive(tris)

    node = GeomNode("primitive")
    node.addGeom(pgeom)

    p3dApp = ShowBase()
    #attachLights(render)
    geomPath = render.attachNewNode(node)

    for linenode in linenodes:
        geomPath.attachNewNode(linenode)
    
    #geomPath.setRenderModeWireframe()
    
    ensureCameraAt(geomPath, base.cam)
    
    boundingSphere = geomPath.getBounds()
    base.cam.setPos(boundingSphere.getCenter() + boundingSphere.getRadius())

    base.cam.lookAt(boundingSphere.getCenter())
    
    KeyboardMovement()
    ButtonUtils(geomPath)
    MouseDrag(geomPath)
    MouseScaleZoom(geomPath)
    #render.setShaderAuto()
    p3dApp.run()
コード例 #55
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
コード例 #56
0
ファイル: terrain.py プロジェクト: pennomi/voronoi-terrain
    def __init__(self, point, vertices, map_width=1024, map_height=1024, base=0.0):
        self.point = point
        # TODO: Sort these clockwise (they still are 2D points)
# http://stackoverflow.com/questions/6989100/sort-points-in-clockwise-order
        # Might just need to reverse if the wrong way. I think they're already
        # ordered. Should be able to tell by checking the normal calculation.
        self.vertices = vertices

        # Ensure that stuff is working correctly
        if [-10.101, -10.101] in vertices:
            raise ValueError("Can't create this region.")

        # TODO: Constrain the bounds like this... though it's somewhat busted.
        # for i, v in enumerate(vertices):
        #     x, y = v
        #     x = max(min(x, map_width/2), -map_width/2)
        #     y = max(min(y, map_height/2), -map_height/2)
        #     vertices[i] = (x, y)

        for v in vertices:
            if not (-map_width/2 <= v[0] <= map_width/2 and
                    -map_height/2 <= v[1] <= map_height/2):
                raise ValueError("Can't create this region.")

        # Prepare the vertex format writers
        v_fmt = GeomVertexFormat.getV3n3c4()
        v_data = GeomVertexData('TerrainData', v_fmt, Geom.UHStatic)
        vertex = GeomVertexWriter(v_data, 'vertex')
        normal = GeomVertexWriter(v_data, 'normal')
        color = GeomVertexWriter(v_data, 'color')
        #texcoord = GeomVertexWriter(v_data, 'texcoord')

        # Create a primitive
        # TODO: Migrate to Tristrips.
        # TODO: Make walls, floors (and ceilings?)
        prim = GeomTrifans(Geom.UHStatic)

        DETAIL = 128
        HEIGHT_SCALE = 20
        vertices = [
            (v[0], v[1], snoise2(
                v[0]/DETAIL, v[1]/DETAIL, base=base,
                persistence=0.5, lacunarity=2.0,
                repeatx=map_width/4, repeaty=map_height/4,
                octaves=5) * HEIGHT_SCALE)
            for v in vertices]

        num_high = len(list(filter(lambda x: x[2] > HEIGHT_SCALE * 0.4, vertices)))
        num_above = len(list(filter(lambda x: HEIGHT_SCALE * 0.4 > x[2] > 0, vertices)))
        num_below = len(list(filter(lambda x: x[2] <= 0, vertices)))
        num_deep = len(list(filter(lambda x: x[2] < -HEIGHT_SCALE * 0.2, vertices)))

        # Calculate the color:
        #  * White if high altitude
        #  * Green if land
        #  * Tan if coast
        #  * Blue if water
        #  * Dark Blue if deep water
        # poly_color = (uniform(0, 1), uniform(0, 1), uniform(0, 1), 1, )
        if num_high:
            white = uniform(0.7, 1.0)
            poly_color = (white, white, white, 1.0)
        elif num_below and num_above:
            yellow = uniform(0.5, 1.0)
            poly_color = (yellow, yellow, 0.0, 1.0)
        elif num_deep:
            poly_color = (0.0, 0.0, uniform(0.5, 1.0), 1.0)
        elif num_below:
            poly_color = (0.3, 0.3, uniform(0.5, 1.0), 1.0)
        else:
            poly_color = (0.0, uniform(0.5, 1.0), 0.0, 1.0)

        for i, point in enumerate(vertices):
            vertex.addData3f(point[0], point[1], max(point[2], 0))
            normal.addData3f(0, 0, 1)
            color.addData4f(*poly_color)
            #texcoord.addData2f(1, 0)
            prim.addVertex(i)
        prim.addVertex(0)
        prim.closePrimitive()

        # Add to the scene graph
        geom = Geom(v_data)
        geom.addPrimitive(prim)
        node = GeomNode('gnode')
        node.addGeom(geom)
        nodePath = render.attachNewNode(node)
        nodePath.setTwoSided(True)
コード例 #57
0
ファイル: square.py プロジェクト: codedragon/color_world
def make_square(sq_color):
    # sq_color is a list of tuples, describing each vertex:
    # (r, g, b, a) for [bl, br, tr, tl]
    x1 = -1
    y1 = -1
    z1 = -1
    x2 = 1
    y2 = -1
    z2 = 1
    v_format = GeomVertexFormat.getV3n3cpt2()
    v_data = GeomVertexData('square', v_format, Geom.UHDynamic)

    vertex = GeomVertexWriter(v_data, 'vertex')
    normal = GeomVertexWriter(v_data, 'normal')
    color = GeomVertexWriter(v_data, 'color')
    tex_coord = GeomVertexWriter(v_data, 'texcoord')

    # make sure we draw the sqaure in the right plane
    if x1 != x2:
        vertex.addData3(x1, y1, z1)
        vertex.addData3(x2, y1, z1)
        vertex.addData3(x2, y2, z2)
        vertex.addData3(x1, y2, z2)

        normal.addData3(normalized(2 * x1 - 1, 2 * y1 - 1, 2 * z1 - 1))
        normal.addData3(normalized(2 * x2 - 1, 2 * y1 - 1, 2 * z1 - 1))
        normal.addData3(normalized(2 * x2 - 1, 2 * y2 - 1, 2 * z2 - 1))
        normal.addData3(normalized(2 * x1 - 1, 2 * y2 - 1, 2 * z2 - 1))

    else:
        vertex.addData3(x1, y1, z1)
        vertex.addData3(x2, y2, z1)
        vertex.addData3(x2, y2, z2)
        vertex.addData3(x1, y1, z2)

        normal.addData3(normalized(2 * x1 - 1, 2 * y1 - 1, 2 * z1 - 1))
        normal.addData3(normalized(2 * x2 - 1, 2 * y2 - 1, 2 * z1 - 1))
        normal.addData3(normalized(2 * x2 - 1, 2 * y2 - 1, 2 * z2 - 1))
        normal.addData3(normalized(2 * x1 - 1, 2 * y1 - 1, 2 * z2 - 1))

    # adding different colors to the vertex for visibility
    # color.addData4f(1.0, 0.0, 0.0, 1.0)
    # color.addData4f(0.0, 1.0, 0.0, 1.0)
    # color.addData4f(0.0, 0.0, 1.0, 1.0)
    # color.addData4f(1.0, 0.0, 1.0, 1.0)
    color.addData4f(sq_color[0])  # (0, 0) bottom left
    color.addData4f(sq_color[1])  # (0.5, 0) bottom right
    color.addData4f(sq_color[2])  # (0.5, 0.5) top right
    color.addData4f(sq_color[3])  # (0, 0.5) top left

    tex_coord.addData2f(0.0, 1.0)
    tex_coord.addData2f(0.0, 0.0)
    tex_coord.addData2f(1.0, 0.0)
    tex_coord.addData2f(1.0, 1.0)

    # Quads aren't directly supported by the Geom interface
    # you might be interested in the CardMaker class if you are
    # interested in rectangle though
    tris = GeomTriangles(Geom.UHDynamic)
    tris.addVertices(0, 1, 3)
    tris.addVertices(1, 2, 3)

    square = Geom(v_data)
    square.addPrimitive(tris)
    return square