Ejemplo n.º 1
0
 def __build_Tris(self, sphere, mode):
     vdata = GeomVertexData("Data", self.__vformat[mode], Geom.UHStatic)
     _num_rows = len(sphere.pts)
      
     # Vertices.
     vertices = GeomVertexWriter(vdata, "vertex")
     vertices.reserveNumRows(_num_rows)
     for pt in sphere.pts:
         vertices.addData3f(*pt)
     
     # Map coords.
     if mode == "mid":
         mapcoords = GeomVertexWriter(vdata, "mapcoord")
         mapcoords.reserveNumRows(_num_rows)
         for mc in sphere.coords:
             u, v = mc[:2]
             mapcoords.addData2f(u,v)
         
     # Tris.
     prim = GeomTriangles(Geom.UHStatic)
     prim.reserveNumVertices(len(sphere.tris))
     for tri in sphere.tris:
         prim.addVertices(*tri)
     prim.closePrimitive()
     
     # Geom.
     geom = Geom(vdata)
     geom.addPrimitive(prim)
     geom_node = GeomNode("geom")
     geom_node.addGeom(geom)
     geom_np = NodePath(geom_node)
     return geom_np
Ejemplo n.º 2
0
 def newVertexData(self):
     fmt = GeomVertexFormat.getV3c4()
     #         fmt = GeomVertexFormat.getV3n3c4()
     self.vertexData = GeomVertexData("path", fmt, Geom.UHStatic)
     self.vertexWriter = GeomVertexWriter(self.vertexData, "vertex")
     #         self.normalWriter = GeomVertexWriter(self.vertexData, 'normal')
     self.colorWriter = GeomVertexWriter(self.vertexData, "color")
 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
Ejemplo n.º 4
0
    def addMeshConvexRB(self,vertices, faces,ghost=False,**kw):
        #step 1) create GeomVertexData and add vertex information
        format=GeomVertexFormat.getV3()
        vdata=GeomVertexData("vertices", format, Geom.UHStatic)
        
        vertexWriter=GeomVertexWriter(vdata, "vertex")
        [vertexWriter.addData3f(v[0],v[1],v[2]) for v in vertices]
        
        #step 2) make primitives and assign vertices to them
        tris=GeomTriangles(Geom.UHStatic)
        [self.setGeomFaces(tris,face) for face in faces]
        
        #step 3) make a Geom object to hold the primitives
        geom=Geom(vdata)
        geom.addPrimitive(tris)
        
        #step 4) create the bullet mesh and node
        mesh = BulletTriangleMesh()
        mesh.addGeom(geom)

        shape = BulletConvexHullShape(mesh, dynamic=not ghost)#
        if ghost :
            inodenp = self.worldNP.attachNewNode(BulletGhostNode('Mesh'))
        else :
            inodenp = self.worldNP.attachNewNode(BulletRigidBodyNode('Mesh'))
        inodenp.node().addShape(shape)
#        inodenp.setPos(0, 0, 0.1)
        self.setRB(inodenp,**kw)
        inodenp.setCollideMask(BitMask32.allOn())
   
        self.world.attachRigidBody(inodenp.node())
        return inodenp
Ejemplo n.º 5
0
 def __modify_Model(self, field, data):
     geom = self.node.modifyGeom(0)
     vdata = geom.modifyVertexData()
     vwriter = GeomVertexWriter(vdata, field)
     vwriter.reserveNumRows(len(data))
     set_data = self.set_dict[field]
     for datum in data:
         set_data(vwriter, *datum)
     geom.setVertexData(vdata)
Ejemplo n.º 6
0
 def generate(self):
     '''(Re)generate the entire terrain erasing any current changes'''
     factor = self.blockSize*self.chunkSize
     #print "Factor:", factor
     for terrain in self.terrains:
         terrain.getRoot().removeNode()
     self.terrains = []
     # Breaking master heightmap into subimages
     heightmaps = []
     self.xchunks = (self.heightfield.getXSize()-1)/factor
     self.ychunks = (self.heightfield.getYSize()-1)/factor
     #print "X,Y chunks:", self.xchunks, self.ychunks
     n = 0
     for y in range(0, self.ychunks):
         for x in range(0, self.xchunks):
             heightmap = PNMImage(factor+1, factor+1)
             heightmap.copySubImage(self.heightfield, 0, 0, xfrom = x*factor, yfrom = y*factor)
             heightmaps.append(heightmap)
             n += 1
     
     # Generate GeoMipTerrains
     n = 0
     y = self.ychunks-1
     x = 0
     for heightmap in heightmaps:
         terrain = GeoMipTerrain(str(n))
         terrain.setHeightfield(heightmap)
         terrain.setBruteforce(self.bruteForce)
         terrain.setBlockSize(self.blockSize)
         terrain.generate()
         self.terrains.append(terrain)
         root = terrain.getRoot()
         root.reparentTo(self.root)
         root.setPos(n%self.xchunks*factor, (y)*factor, 0)
         
         # In order to texture span properly we need to reiterate through every vertex
         # and redefine the uv coordinates based on our size, not the subGeoMipTerrain's
         root = terrain.getRoot()
         children = root.getChildren()
         for child in children:
             geomNode = child.node()
             for i in range(geomNode.getNumGeoms()):
                 geom = geomNode.modifyGeom(i)
                 vdata = geom.modifyVertexData()
                 texcoord = GeomVertexWriter(vdata, 'texcoord')
                 vertex = GeomVertexReader(vdata, 'vertex')
                 while not vertex.isAtEnd():
                     v = vertex.getData3f()
                     t = texcoord.setData2f((v[0]+ self.blockSize/2 + self.blockSize*x)/(self.xsize - 1),
                                                     (v[1] + self.blockSize/2 + self.blockSize*y)/(self.ysize - 1))
         x += 1
         if x >= self.xchunks:
             x = 0
             y -= 1
         n += 1
Ejemplo n.º 7
0
	def buildGeom(self, meshData):
		prims = meshData["prims"]
		vertices = meshData["vertices"]
		normals = meshData["normals"]
		texcoords = meshData["texcoords"]
		
		vdata = GeomVertexData('mesh', GeomVertexFormat.getV3n3t2(), Geom.UHStatic)
		vwriter = GeomVertexWriter(vdata, 'vertex')
		nvwriter = GeomVertexWriter(vdata, 'normal')
		tvwriter = GeomVertexWriter(vdata, 'texcoord')
		
		for i in range(len(vertices)):
			v = vertices[i]
			n = normals[i]
			t = texcoords[i]
			vwriter.addData3f(v)
			nvwriter.addData3f(n)
			tvwriter.addData2f(t)
		
		prim = GeomTriangles(Geom.UHStatic)
		
		for i in range(len(prims)):
			A, B, C = prims[i]
			prim.addVertices(A, B, C)
			prim.closePrimitive()
		
		geom = Geom(vdata)
		geom.addPrimitive(prim)
		
		geomNode = GeomNode('trig')
		geomNode.addGeom(geom)
		geomNode.unify(1, True)
		
		return geomNode
Ejemplo n.º 8
0
	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)
Ejemplo n.º 9
0
def makeRotationGeomNode():
    vdata = GeomVertexData('rotHandleData', GeomVertexFormat.getV3(),
            Geom.UHStatic)
    v = GeomVertexWriter(vdata, 'vertex')
    radius = 0.7
    width = 0.08
    res = 30
    innerRad = radius - width

    for i in xrange(res):
        theta = i*(2*pi/res)
        v.addData3f(innerRad*sin(theta), innerRad*cos(theta), width/2.0)
        v.addData3f(innerRad*sin(theta), innerRad*cos(theta), -width/2.0)
        v.addData3f(radius*sin(theta), radius*cos(theta), width/2.0)
        v.addData3f(radius*sin(theta), radius*cos(theta), -width/2.0)

    circle = Geom(vdata)
    # Make prims for the faces of the torus
    faces = [GeomTristrips(Geom.UHStatic) for i in xrange(4)]
    for i in xrange(res):
        i = i*4
        faces[0].addVertices(i + 1, i)
        faces[1].addVertices(i + 2, i + 1)
        faces[2].addVertices(i + 3, i + 2)
        faces[3].addVertices(i, i + 3)
    for i in xrange(4):
        faces[i].addVertices((i + 1) % 4, i)
        faces[i].closePrimitive()
        circle.addPrimitive(faces[i])
    node = GeomNode('geomnode')
    node.addGeom(circle)
    return node
Ejemplo n.º 10
0
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)
Ejemplo n.º 11
0
    def __init__(self, __occupying_unit = None, __occupiable = True, 
	x = 0, z = 0, r = 5, tag = 0):
        self.__occupying_unit = __occupying_unit
        self.__occupiable = __occupiable
	self.__r = r
	self.__x = x
	self.__z = z
	self.__tag = tag
	
	#Procedurally creating a hex!
	geometry_array = GeomVertexArrayFormat()
	geometry_array.addColumn(InternalName.make('vertex'), 3, Geom.NTFloat32, Geom.CPoint)
	geometry_array.addColumn(InternalName.make('normal'), 3, Geom.NTFloat32, Geom.CPoint)
	format = GeomVertexFormat()
	format.addArray(geometry_array)
	format = GeomVertexFormat.registerFormat(format)
	self.__vdata = GeomVertexData('Hex', format, Geom.UHStatic)
	self.__vertex = GeomVertexWriter(self.__vdata, 'vertex')
	self.__normal = GeomVertexWriter(self.__vdata, 'normal')

	#Vertex 1
	self.__vertex.addData3f(self.__x, self.__z+self.__r, 0)
	self.__normal.addData3f(1, 0, 0)
	#Vertex 2
	self.__vertex.addData3f(self.__x+self.__r*sin(pi/3), self.__z+self.__r*cos(pi/3), 0)
	self.__normal.addData3f(1, 0, 0)
	#Vertex 3
	self.__vertex.addData3f(self.__x+self.__r*sin(pi/3), self.__z-self.__r*cos(pi/3), 0)
	self.__normal.addData3f(1, 0, 0)
	#Vertex 4
	self.__vertex.addData3f(self.__x, self.__z-self.__r, 0)
	self.__normal.addData3f(1, 0, 0)
	#Vertex 5
	self.__vertex.addData3f(self.__x-self.__r*sin(pi/3), self.__z-self.__r*cos(pi/3), 0)
	self.__normal.addData3f(1, 0, 0)
	#Vertex 6
	self.__vertex.addData3f(self.__x-self.__r*sin(pi/3), self.__z+self.__r*cos(pi/3), 0)
	self.__normal.addData3f(1, 0, 0)

	self.__hex_primitive = GeomTrifans(Geom.UHStatic)
	self.__hex_primitive.addVertices(5, 4)
	self.__hex_primitive.addVertices(3, 2)
	self.__hex_primitive.addVertices(1, 0)

	self.__hex_primitive.closePrimitive()
	self.__hex_geometry = Geom(self.__vdata)
	self.__hex_geometry.addPrimitive(self.__hex_primitive)
	self.__hex_node = GeomNode('HexNode')
	self.__hex_node.addGeom(self.__hex_geometry)

	nodePath = render.attachNewNode(self.__hex_node)
	nodePath.setTag( "hex", str(tag) )
	nodePath.node().setIntoCollideMask(BitMask32.bit(1))
	nodePath.hide()
Ejemplo n.º 12
0
	def clearMesh(self):
		#if self.np:
		#	self.np.remove()
		self.node.removeAllGeoms()
		
		self.vdata = GeomVertexData ('name', self.format, Geom.UHStatic)
		self.vWriter = GeomVertexWriter (self.vdata, 'vertex')
		self.cWriter = GeomVertexWriter (self.vdata, 'color')
		
		self.geom = Geom(self.vdata)
		#self.node = GeomNode("lines")
		
		self.node.addGeom(self.geom)
Ejemplo n.º 13
0
    def drawBody(self, pos, quat, radius=1,UVcoord=(1,1), numVertices=_polySize):
#        if isRoot:
#            self.bodydata = GeomVertexData("body vertices", GeomVertexFormat.getV3n3t2(), Geom.UHStatic)
        vdata = self.bodydata
        circleGeom = Geom(vdata) # this was originally a copy of all previous geom in vdata...
        vertWriter = GeomVertexWriter(vdata, "vertex")
        #colorWriter = GeomVertexWriter(vdata, "color")
        normalWriter = GeomVertexWriter(vdata, "normal")
#        drawReWriter = GeomVertexRewriter(vdata, "drawFlag")
        texReWriter = GeomVertexRewriter(vdata, "texcoord")

        startRow = vdata.getNumRows()
        vertWriter.setRow(startRow)
        #colorWriter.setRow(startRow)
        normalWriter.setRow(startRow)       
        texReWriter.setRow(startRow)   
       
        #axisAdj=Mat4.rotateMat(45, axis)*Mat4.scaleMat(radius)*Mat4.translateMat(pos)
        perp1 = quat.getRight()
        perp2 = quat.getForward()   
        
#TODO: PROPERLY IMPLEMENT RADIAL NOISE        
        #vertex information is written here
        angleSlice = 2 * pi / numVertices
        currAngle = 0
        for i in xrange(numVertices+1): 
            adjCircle = pos + (perp1 * cos(currAngle) + perp2 * sin(currAngle)) * radius * (.5+bNodeRadNoise*random.random())
            normal = perp1 * cos(currAngle) + perp2 * sin(currAngle)       

            normalWriter.addData3f(normal)
            vertWriter.addData3f(adjCircle)
            texReWriter.addData2f(float(UVcoord[0]*i) / numVertices,UVcoord[1])            # UV SCALE HERE!
            #colorWriter.addData4f(0.5, 0.5, 0.5, 1)
            currAngle += angleSlice 
        
        #we cant draw quads directly so we use Tristrips
        if (startRow != 0):
            lines = GeomTristrips(Geom.UHStatic)         
            for i in xrange(numVertices+1):
                lines.addVertex(i + startRow)
                lines.addVertex(i + startRow - numVertices-1)
            lines.addVertex(startRow)
            lines.addVertex(startRow - numVertices)
            lines.closePrimitive()
            #lines.decompose()
            circleGeom.addPrimitive(lines)           
            circleGeomNode = GeomNode("Debug")
            circleGeomNode.addGeom(circleGeom)   
            self.numPrimitives += numVertices * 2
            self.bodies.attachNewNode(circleGeomNode)
            return circleGeomNode
Ejemplo n.º 14
0
 def __modify_Model(self, field, data):
     set_dict = {
         'vertex':GeomVertexWriter.setData3f,
         'normal':GeomVertexWriter.setData3f,
         'color':GeomVertexWriter.setData4f,
         'texcoord':GeomVertexWriter.setData2f,
         'info':GeomVertexWriter.setData4f,
         'ref':GeomVertexWriter.setData3f,
         'nbr':GeomVertexWriter.setData4i}
         
     geom = self.NP.node().modifyGeom(0)
     vdata = geom.modifyVertexData()
     vwriter = GeomVertexWriter(vdata, field)
     vwriter.reserveNumRows(len(data))
     set_data = set_dict[field]
     for datum in data:
         set_data(vwriter, *datum)
     geom.setVertexData(vdata)
Ejemplo n.º 15
0
 def makeNode(self, pointmap=(lambda x, y: (x, y, 0))):
     vt = tuple(self.vertices)
     t = Triangulator()
     fmt = GeomVertexFormat.getV3()
     vdata = GeomVertexData('name', fmt, Geom.UHStatic)
     vertex = GeomVertexWriter(vdata, 'vertex')
     for x, y in vt:
         t.addPolygonVertex(t.addVertex(x, y))
         vertex.addData3f(pointmap(x, y))
     t.triangulate()
     prim = GeomTriangles(Geom.UHStatic)
     for n in xrange(t.getNumTriangles()):
         prim.addVertices(t.getTriangleV0(n),t.getTriangleV1(n),t.getTriangleV2(n))
     prim.closePrimitive()
     geom = Geom(vdata)
     geom.addPrimitive(prim)
     node = GeomNode('gnode')
     node.addGeom(geom)
     return node
    def registerObject(self, obj):
        """ Registers a new dynamic object, this will store an index for every
        vertex, which can be used to read and store last position data in order
        to compute the velocity. This method also assigns the standard animated
        shader to the node """

        self.debug("Registering dynamic object")

        # Find all GeomNodes
        for node in obj.findAllMatches("**/+GeomNode"):
            geomNode = node.node()
            geomCount = geomNode.getNumGeoms()

            # Find all Geoms
            for i in xrange(geomCount):

                # Modify vertex data
                geom = geomNode.modifyGeom(i)
                geomVertexData = geom.modifyVertexData()

                # Add a new column named "dovindex" to the vertex data
                formatArray = GeomVertexArrayFormat() 
                formatArray.addColumn(InternalName.make("dovindex"), 1, GeomEnums.NTUint32, GeomEnums.CIndex) 
                newArrayFormat = GeomVertexFormat(geomVertexData.getFormat())
                newArrayFormat.addArray(formatArray)
                newArrayFormat = GeomVertexFormat.registerFormat(newArrayFormat)

                # Convert the old vertex data and assign the new vertex data
                convertedVertexData = geomVertexData.convertTo(newArrayFormat)
                geom.setVertexData(convertedVertexData)

                # Write the per-vertex indices the dovindex column 
                newVertexData = geom.modifyVertexData()
                vtxReader = GeomVertexReader(newVertexData, "vertex")
                indexWriter = GeomVertexWriter(newVertexData, "dovindex")

                while not vtxReader.isAtEnd():
                    data = vtxReader.getData3f()
                    indexWriter.setData1i(self.currentIndex)
                    self.currentIndex += 1

                if self.currentIndex > self.maxVertexCount:
                    self.error("Max dynamic vertex count of", self.maxVertexCount, "reached!")
Ejemplo n.º 17
0
    def __init__(self, name = 'Mesh'):
        '''
        Constructor
        '''
        self.name = name
        self.finished = False

        self.format = GeomVertexFormat.getV3n3c4()
        self.vertexData = GeomVertexData(name, self.format, Geom.UHStream)

        self.mesh = Geom(self.vertexData)
        self.triangles = GeomTriangles(Geom.UHStream)
        self.triangleData = self.triangles.modifyVertices()

        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
Ejemplo n.º 18
0
    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
Ejemplo n.º 19
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
Ejemplo n.º 20
0
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
Ejemplo n.º 21
0
def makeGeom():

  # Vertex data
  fmt = GeomVertexFormat.getV3n3t2()
  vdata = GeomVertexData('', fmt, Geom.UHStatic)

  vertex = GeomVertexWriter(vdata, InternalName.getVertex())
  normal = GeomVertexWriter(vdata, InternalName.getNormal())
  texcoord = GeomVertexWriter(vdata, InternalName.getTexcoord())

  for (x, y, z) in vertices:
    vertex.addData3f(x, y, z)
    normal.addData3f(0, 0, 0)

  # Privitive
  prim = GeomTriangles(Geom.UHStatic)

  for (i1, i2, i3) in indices:
    prim.addVertices(i1, i2, i3)
    prim.closePrimitive()

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

  return geom
Ejemplo n.º 22
0
def makeClickableGeom():
    vdata = GeomVertexData('handleData', GeomVertexFormat.getV3(),
            Geom.UHStatic)
    v = GeomVertexWriter(vdata, 'vertex')
    length = 1.0
    cylRad = 0.10
    circRes = 8

    # Add vertices cylinder.
    for z in [length/2.0, -length/2.0]:
        for i in xrange(circRes):
            theta = i*(2*pi/circRes)
            v.addData3f(cylRad*sin(theta), cylRad*cos(theta), z)

    geom = Geom(vdata)
    # Make polys for the circles
    CCW = 1
    CW = 0
    for i, wind in ((0, CCW), (circRes, CW)):
        circle = GeomTristrips(Geom.UHStatic)
        l = range(i, i+circRes)
        for i in xrange(1-wind, (len(l)-wind)/2):
            l.insert(2*i+wind, l.pop())
        for v in l:
            circle.addVertex(v)
        circle.closePrimitive()
        geom.addPrimitive(circle)

    # Make polys for the cylinder.
    cyl = GeomTristrips(Geom.UHStatic)
    for i in xrange(circRes):
        cyl.addVertex(i + circRes)
        cyl.addVertex(i)
    cyl.addVertex(circRes)
    cyl.addVertex(0)
    cyl.closePrimitive()
    geom.addPrimitive(cyl)
    node = GeomNode('geomnode')
    node.addGeom(geom)
    return node
Ejemplo n.º 23
0
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
Ejemplo n.º 24
0
class VertexDataWriter (object):

    def __init__(self, vdata):
        self.count = 0
        self.vertex = GeomVertexWriter(vdata, 'vertex')
        self.normal = GeomVertexWriter(vdata, 'normal')
        self.color = GeomVertexWriter(vdata, 'color')
        self.texcoord = GeomVertexWriter(vdata, 'texcoord')

    def add_vertex(self, point, normal, color, texcoord):
        self.vertex.add_data3f(point)
        self.normal.add_data3f(normal)
        self.color.add_data4f(*color)
        self.texcoord.add_data2f(*texcoord)
        self.count += 1
Ejemplo n.º 25
0
	def projectVerticesToShadow(self):

		inVertices=self.unmodifiedVertexData
		modelWorldX=self.modelWorldX
		modelWorldY=self.modelWorldY
		modelWorldZ=self.modelWorldZ
		zRotationDegrees=self.modelRotation
		lightWorldX=self.lightWorldX
		lightWorldY=self.lightWorldY
		lightWorldZ=self.lightWorldZ

		zRotationRadians=zRotationDegrees*(math.pi/180.0)
		mathCosZRotationRadians=math.cos(zRotationRadians)
		mathSinZRotationRadians=math.sin(zRotationRadians)

		vdata=self.pandaVertexData
		vertex = GeomVertexWriter(vdata, 'vertex')

		for inVertex in inVertices:
			vertexModelX,vertexModelY,vertexModelZ=inVertex

			vertexModelOldX=vertexModelX
			vertexModelOldY=vertexModelY
			vertexModelX=vertexModelOldX*mathCosZRotationRadians-vertexModelOldY*mathSinZRotationRadians
			vertexModelY=vertexModelOldX*mathSinZRotationRadians+vertexModelOldY*mathCosZRotationRadians

			vertexWorldX=modelWorldX+vertexModelX
			vertexWorldY=modelWorldY+vertexModelY
			vertexWorldZ=modelWorldZ+vertexModelZ
			vertexLightZDiff=vertexWorldZ-lightWorldZ
			shadowVertexX=lightWorldX+((vertexWorldX-lightWorldX)*-lightWorldZ/vertexLightZDiff)
			shadowVertexY=lightWorldY+((vertexWorldY-lightWorldY)*-lightWorldZ/vertexLightZDiff)

			normalisedShadowVertexX=shadowVertexX-modelWorldX
			normalisedShadowVertexY=shadowVertexY-modelWorldY
			normalisedShadowVertexZ=0

			vertex.setData3f(normalisedShadowVertexX,normalisedShadowVertexY,normalisedShadowVertexZ)
Ejemplo n.º 26
0
	def line (self, start, end):
		# since we're doing line segments, just vertices in our geom
		format = GeomVertexFormat.getV3()
	   
		# build our data structure and get a handle to the vertex column
		vdata = GeomVertexData ('', format, Geom.UHStatic)
		vertices = GeomVertexWriter (vdata, 'vertex')
		   
		# build a linestrip vertex buffer
		lines = GeomLinestrips (Geom.UHStatic)
	   
		vertices.addData3f (start[0], start[1], start[2])
		vertices.addData3f (end[0], end[1], end[2])
	   
		lines.addVertices (0, 1)
		
		lines.closePrimitive()
	   
		geom = Geom (vdata)
		geom.addPrimitive (lines)
		# Add our primitive to the geomnode
		#self.gnode.addGeom (geom)
		return geom
Ejemplo n.º 27
0
Archivo: ui.py Proyecto: 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
Ejemplo n.º 28
0
 def __init__(self, name):
     self.name = name
     self.poly_groups = []
     
     # GeomVertexFormats
     #
     # GeomVertexFormat.getV3cpt2()  - vertex, color, uv
     # GeomVertexFormat.getV3t2()    - vertex, uv
     # GeomVertexFormat.getV3cp()    - vertex, color
     # GeomVertexFormat.getV3n3t2()  - vertex, normal, uv
     # GeomVertexFormat.getV3n3cpt2()- vertex, normal, rgba, uv
     
     # textured
     self.vdata = GeomVertexData(name, GeomVertexFormat.getV3n3cpt2(), Geom.UHStatic)
     
     # plain color filled polys
     # self.vdata = GeomVertexData(name, GeomVertexFormat.getV3cp(), Geom.UHStatic)
     
     self.vertex = GeomVertexWriter(self.vdata, 'vertex')
     self.vnormal = GeomVertexWriter(self.vdata, 'normal')
     self.color = GeomVertexWriter(self.vdata, 'color')
     self.texcoord = GeomVertexWriter(self.vdata, 'texcoord')
     
     self.root = NodePath(PandaNode(name+'_mesh'))
Ejemplo n.º 29
0
def createPlane(width,height):

    format=GeomVertexFormat.getV3()
    vdata=GeomVertexData("vertices", format, Geom.UHStatic)

    vertexWriter=GeomVertexWriter(vdata, "vertex")
    vertexWriter.addData3f(0,0,0)
    vertexWriter.addData3f(width,0,0)
    vertexWriter.addData3f(width,height,0)
    vertexWriter.addData3f(0,height,0)

    #step 2) make primitives and assign vertices to them
    tris=GeomTriangles(Geom.UHStatic)

    #have to add vertices one by one since they are not in order
    tris.addVertex(0)
    tris.addVertex(1)
    tris.addVertex(3)

    #indicates that we have finished adding vertices for the first triangle.
    tris.closePrimitive()

    #since the coordinates are in order we can use this convenience function.
    tris.addConsecutiveVertices(1,3) #add vertex 1, 2 and 3
    tris.closePrimitive()

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

    #now put squareGeom in a GeomNode. You can now position your geometry in the scene graph.
    squareGN=GeomNode("square")
    squareGN.addGeom(squareGeom)

    terrainNode = NodePath("terrNode")
    terrainNode.reparentTo(render)
    terrainNode.attachNewNode(squareGN)
    terrainNode.setX(-width/2)
    texGrass = loader.loadTexture("textures/envir-ground.jpg")
    terrainNode.setTexture(texGrass)
Ejemplo n.º 30
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")
Ejemplo n.º 31
0
class Moon(PandaNode):
    def __init__(self, base_object):
        PandaNode.__init__(self, "Moon")

        self.geom = GeomNode("Moon")
        self.vertexData = GeomVertexData("Basis", GeomVertexFormat.getV3cpt2(),
                                         Geom.UHStatic)
        self.vertex = GeomVertexWriter(self.vertexData, 'vertex')
        self.tex_coord = GeomVertexWriter(self.vertexData, 'texcoord')
        self.mesh = Geom(self.vertexData)
        self.tris = GeomTristrips(Geom.UHStatic)

        size = 700
        z = 1000
        dx = 0
        dy = 500

        self.vertex.addData3f(z, size + dx, -size + dy)
        self.tex_coord.addData2f(1.0, 0.0)

        self.vertex.addData3f(z, -size + dx, -size + dy)
        self.tex_coord.addData2f(1.0, 1.0)

        self.vertex.addData3f(z, size + dx, size + dy)
        self.tex_coord.addData2f(0.0, 0.0)

        self.vertex.addData3f(z, -size + dx, size + dy)
        self.tex_coord.addData2f(0.0, 1.0)

        self.tris.add_vertices(0, 1, 2, 3)

        self.tris.closePrimitive()
        self.mesh.addPrimitive(self.tris)
        self.geom.addGeom(self.mesh)

        self.node = base_object.render.attachNewNode(self.geom)
        self.node.set_p(90)
        # self.node.set_r(-90)
        # self.node.set_h(90)

        # self.node.set_p(90)
        # self.node.set_scale(500)

        # self.node.set_pos(1.7 * self.node.get_scale()[0],
        #                   0,
        #                   self.node.get_scale()[0] * 0.5)

        self.texture = base_object.loader.loadTexture(
            base_object.params("moon_texture"))
        self.node.set_texture(self.texture)

        self.node.setLightOff()
        self.node.setColorOff()
        self.node.setTransparency(True)

        self.node.set_bin('fixed', 2)
        self.node.set_depth_write(0)
        self.node.set_depth_test(0)
        # self.node.lookAt(0, 0, 0)

    def move(self, dx):
        self.node.set_pos(self.node.get_pos() + dx)
Ejemplo n.º 32
0
def gpugemsTerrain():
  W, H, D = (1,1,2)
  noise = PerlinNoise3(1,1,1,256,0)
  warpNoise = PerlinNoise3(1,1,1,256,1)
  # noise = PerlinNoise3()
  # warpNoise = PerlinNoise3()

  def densityFunction(x, y, z):
    point = LVecBase3f(x, y, z)
    warpfactor = 0.0004

    warp = warpNoise(LVecBase3f(x*warpfactor, y*warpfactor, z*warpfactor)) * 8
    point.componentwiseMult(LVecBase3f(warp, warp, warp))
    density = -point.z
    floor = 4

    ω = [16.03, 8.05, 4.03, 1.96, 1.01, 0.49, 0.23, 0.097] # frequencies
    A = [0.25, 0.25, 0.5, 0.5, 1, 2, 8, 32] # amplitudes
    for i in range(len(ω)):
      ωVec = LVecBase3f(ω[i], ω[i], ω[i])
      ωVec.componentwiseMult(point)
      density += noise(ωVec) * A[i]

    density += max(min((floor - point.z)*3, 1), 0)*40;

    return density

  def casePoint(density):
    if density < 0:
      return 0
    else:
      return 1

  g = 1 # granularity
  chunk = [[[
    [[[densityFunction((x+32*w)/g, (y+32*h)/g, (z+32*d)/g) for x in range(33)] for y in range(33)] for z in range(33)]
  for w in range(W)] for h in range(H)] for d in range(D)]

  vdata = GeomVertexData('Land', GeomVertexFormat.get_v3n3c4(), Geom.UHStatic)
  vdata.setNumRows(33*33*4)

  vertices = GeomVertexWriter(vdata, 'vertex')
  normals = GeomVertexWriter(vdata, 'normal')
  colors = GeomVertexWriter(vdata, 'color')

  waterNoise = PerlinNoise2()

  ct = 0

  for h in range(H):
    for w in range(W):
      for d in range(D):
        # bigger!
        for z in range(32):
          for y in range(32):
            for x in range(32):
              v0 = chunk[d][h][w][z+1][y][x]
              v1 = chunk[d][h][w][z][y][x]
              v2 = chunk[d][h][w][z][y][x+1]
              v3 = chunk[d][h][w][z+1][y][x+1]
              v4 = chunk[d][h][w][z+1][y+1][x]
              v5 = chunk[d][h][w][z][y+1][x]
              v6 = chunk[d][h][w][z][y+1][x+1]
              v7 = chunk[d][h][w][z+1][y+1][x+1]


              case = casePoint(chunk[d][h][w][z+1][y][x])\
                    + 2*casePoint(chunk[d][h][w][z][y][x])\
                    + 4*casePoint(chunk[d][h][w][z][y][x+1])\
                    + 8*casePoint(chunk[d][h][w][z+1][y][x+1])\
                    + 16*casePoint(chunk[d][h][w][z+1][y+1][x])\
                    + 32*casePoint(chunk[d][h][w][z][y+1][x])\
                    + 64*casePoint(chunk[d][h][w][z][y+1][x+1])\
                    + 128*casePoint(chunk[d][h][w][z+1][y+1][x+1])\

              if case == 0 or case == 255:
                continue

              numpolys = TABLE['case_to_numpolys'][case][0]

              for polyIndex in range(numpolys):
                edgeConnects = TABLE['g_triTable'][case][polyIndex]

                currentTriangleVertices = []
                currentTriangleColors = []
                for edgeIndex in range(3):
                  edge = edgeConnects[edgeIndex]

                  X = x+32*w
                  Y = y+32*h
                  Z = z+32*d

                  scale = 1
                  X = scale*X
                  Y = scale*Y
                  Z = scale*Z

                  ph = min(1, (d*32+z)/32) # point height
                  ph = ph*ph*ph

                  color = None
                  # if d == 0 and z <= 7:
                  #   v = waterNoise.noise(LVecBase2f(X, Y))
                  #   b= 1 - v**2
                  #   if b > 0.99:
                  #     color = [0.12, 0.29, b, 1]

                  if edge == 0:
                    diff = abs(v0)/(abs(v0)+abs(v1))
                    diff = scale * diff
                    currentTriangleVertices.append([X, Y, Z-diff])
                    if color is None:
                      color = [0.49+0.51*ph, 0.84+0.16*ph, 0.06+0.94*ph, 1]
                    currentTriangleColors.append(color)
                  elif edge == 1:
                    diff = abs(v1)/(abs(v1)+abs(v2))
                    diff = scale * diff
                    currentTriangleVertices.append([X+diff, Y, Z-scale])
                    currentTriangleColors.append([0.89, 0.17, 0.1, 1])
                  elif edge == 2:
                    diff = abs(v3)/(abs(v3)+abs(v2))
                    diff = scale * diff
                    currentTriangleVertices.append([X+scale, Y, Z-diff])
                    if color is None:
                      color = [0.49+0.51*ph, 0.84+0.16*ph, 0.06+0.94*ph, 1]
                    currentTriangleColors.append(color)
                  elif edge == 3:
                    diff = abs(v0)/(abs(v0)+abs(v3))
                    diff = scale * diff
                    currentTriangleVertices.append([X+diff, Y, Z])
                    currentTriangleColors.append([0.89, 0.17, 0.1, 1])
                  elif edge == 4:
                    diff = abs(v4)/(abs(v4)+abs(v5))
                    diff = scale * diff
                    currentTriangleVertices.append([X, Y+scale, Z-diff])
                    if color is None:
                      color = [0.49+0.51*ph, 0.84+0.16*ph, 0.06+0.94*ph, 1]
                    currentTriangleColors.append(color)
                  elif edge == 5:
                    diff = abs(v5)/(abs(v5)+abs(v6))
                    diff = scale * diff
                    currentTriangleVertices.append([X+diff, Y+scale, Z-scale])
                    currentTriangleColors.append([0.89, 0.17, 0.1, 1])
                  elif edge == 6:
                    diff = abs(v7)/(abs(v7)+abs(v6))
                    diff = scale * diff
                    currentTriangleVertices.append([X+scale, Y+scale, Z-diff])
                    if color is None:
                      color = [0.49+0.51*ph, 0.84+0.16*ph, 0.06+0.94*ph, 1]
                    currentTriangleColors.append(color)
                  elif edge == 7:
                    diff = abs(v4)/(abs(v4)+abs(v7))
                    diff = scale * diff
                    currentTriangleVertices.append([X+diff, Y+scale, Z])
                    currentTriangleColors.append([0.89, 0.17, 0.1, 1])
                  elif edge == 8:
                    diff = abs(v0)/(abs(v0)+abs(v4))
                    diff = scale * diff
                    currentTriangleVertices.append([X, Y+diff, Z])
                    currentTriangleColors.append([0.89, 0.34, 0.1, 1])
                  elif edge == 9:
                    diff = abs(v1)/(abs(v1)+abs(v5))
                    diff = scale * diff
                    currentTriangleVertices.append([X, Y+diff, Z-scale])
                    currentTriangleColors.append([0.89, 0.34, 0.1, 1])
                  elif edge == 10:
                    diff = abs(v2)/(abs(v2)+abs(v6))
                    diff = scale * diff
                    currentTriangleVertices.append([X+scale, Y+diff, Z-scale])
                    currentTriangleColors.append([0.89, 0.34, 0.1, 1])
                  elif edge == 11:
                    diff = abs(v3)/(abs(v3)+abs(v7))
                    diff = scale * diff
                    currentTriangleVertices.append([X+scale, Y+diff, Z])
                    currentTriangleColors.append([0.89, 0.34, 0.1, 1])

                a = currentTriangleVertices[0]
                b = currentTriangleVertices[1]
                c = currentTriangleVertices[2]
                ba = LVecBase3f(b[0]-a[0], b[1]-a[1], b[2]-a[2])
                ca = LVecBase3f(c[0]-a[0], c[1]-a[1], c[2]-a[2])
                normal = ba.cross(ca).normalized()

                for i in range(3):
                  ct += 1
                  cv = currentTriangleVertices[i]
                  cn = normal
                  cc = currentTriangleColors[i]

                  vertices.addData3f(cv[0], cv[1], cv[2])
                  normals.addData3f(cn[0], cn[1], cn[2])
                  colors.addData4f(cc[0], cc[1], cc[2], cc[3])
Ejemplo n.º 33
0
    def create_profile(self):
        """
        Creates the necessary rendering geometry to render the 3d rendition of
        an IBeam profile.
        """
        beam = self.beam
        s = self.s
        prof = beam.profile

        c_1 = (0.25882353, 0.80784314, 0.95686275, 1)
        c_2 = (0.19607843, 0.63529412, 0.75686275, 1)

        fmt = GeomVertexFormat.getV3n3c4()
        vertexData = GeomVertexData('I prof', fmt, Geom.UHStatic)

        vertexData.setNumRows(108)

        vertices = GeomVertexWriter(vertexData, 'vertex')
        normals = GeomVertexWriter(vertexData, 'normal')
        colors = GeomVertexWriter(vertexData, 'color')

        T = beam.elements[0].trans_matrix[:3, :3]

        b_0 = np.array([beam.x[0], beam.y[0], beam.z[0]]) / s
        b_l = np.array([beam.x[-1], beam.y[-1], beam.z[-1]]) / s

        points = np.array([[0, prof.b / 2, -prof.h / 2],
                           [0, -prof.b / 2, -prof.h / 2],
                           [0, -prof.b / 2, -prof.h / 2 + prof.t_f],
                           [0, -prof.t_w / 2, -prof.h / 2 + prof.t_f],
                           [0, prof.t_w / 2, -prof.h / 2 + prof.t_f],
                           [0, prof.b / 2, -prof.h / 2 + prof.t_f]
                           ]) / s

        R = np.array([[1, 0, 0],
                      [0, -1, 0],
                      [0, 0, -1]])

        ps = None
        for p in points:
            if ps is None:
                ps = np.reshape(np.dot(R, p), (1, 3))
            else:
                ps = np.append(ps, np.reshape(np.dot(R, p), (1, 3)), axis=0)

        points = np.append(points, ps, axis=0)

        ps = None
        for p in points:
            if ps is None:
                ps = np.reshape(b_0 + np.dot(T.T, p), (1, 3))
            else:
                ps = np.append(ps, np.reshape(b_0 + np.dot(T.T, p), (1, 3)),
                               axis=0)

        pe = None
        for p in points:
            if pe is None:
                pe = np.reshape(b_l + np.dot(T.T, p), (1, 3))
            else:
                pe = np.append(pe, np.reshape(b_l + np.dot(T.T, p), (1, 3)),
                               axis=0)

        points = np.append(ps, pe, axis=0)

        surfs = np.array([[0, 1, 2, c_1], [0, 2, 5, c_1],  # front
                          [4, 3, 10, c_1], [4, 10, 9, c_1],
                          [8, 11, 6, c_1], [8, 6, 7, c_1],
                          [12, 0, 5, c_1], [12, 5, 17, c_1],  # t./b. sides
                          [1, 13, 14, c_1], [1, 14, 2, c_1],
                          [11, 23, 18, c_1], [11, 18, 6, c_1],
                          [20, 8, 7, c_1], [20, 7, 19, c_1],
                          [16, 4, 9, c_2], [16, 9, 21, c_2],  # Mid sides
                          [3, 15, 22, c_2], [3, 22, 10, c_2],
                          [13, 12, 17, c_1], [13, 17, 14, c_1],  # Back
                          [15, 16, 21, c_1], [15, 21, 22, c_1],
                          [23, 20, 19, c_1], [23, 19, 18, c_1],
                          [7, 6, 18, c_1], [7, 18, 19, c_1],  # T. t. fl.
                          [9, 8, 20, c_1], [9, 20, 21, c_1],  # In. t. fl. l
                          [11, 10, 22, c_1], [11, 22, 23, c_1],  # In. t. fl. r
                          [5, 4, 16, c_1], [5, 16, 17, c_1],  # In. b. fl. l.
                          [3, 2, 14, c_1], [3, 14, 15, c_1],  # In. b. fl. l.
                          [1, 0, 12, c_1], [1, 12, 13, c_1],  # Bot. bot. fl.
                          ])

        prim = GeomTriangles(Geom.UHStatic)

        vtx_count = -1

        for surf in surfs:
            p, n = self.mk_surface(points[surf[0]],
                                   points[surf[1]],
                                   points[surf[2]])

            for i in range(p.shape[0]):
                vertices.addData3f(*p[i, :])
                normals.addData3f(*(-n))
                colors.addData4f(*surf[3])
                vtx_count += 1

            prim.add_vertices(vtx_count - 2,
                              vtx_count - 1,
                              vtx_count)

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

        node = GeomNode('I_frame')
        node.addGeom(geom)
        return node
Ejemplo n.º 34
0
 def generateNode(self):        
     self.destroy()
     
     self.node = NodePath('gameobjectnode')
     self.node.setTwoSided(True)
     self.node.reparentTo(self.parent.node)
     
     if self.properties['avoidable'] == True:
         self.node.setTag("avoidable", 'true')
     else:
         self.node.setTag("avoidable", 'false')
     
     #setting scripting part
     self.node.setTag("onWalked", self.onWalked)
     self.node.setTag("onPicked", self.onPicked)
     #set unique id
     self.node.setTag("id", self.properties['id'])
     
     tex = loader.loadTexture(resourceManager.getResource(self.properties['url'])+'.png')
     tex.setWrapV(Texture.WM_clamp)
     tex.setWrapU(Texture.WM_clamp)
     
     #this is true pixel art
     #change to FTLinear for linear interpolation between pixel colors
     tex.setMagfilter(Texture.FTNearest)
     tex.setMinfilter(Texture.FTNearest)
     
     xorig = tex.getOrigFileXSize() / self.baseDimension
     yorig = tex.getOrigFileYSize() / self.baseDimension
     xscaled = (tex.getOrigFileXSize() / self.baseDimension) * self.properties['scale']
     yscaled = (tex.getOrigFileYSize() / self.baseDimension) * self.properties['scale']
     
     self.node.setTag("xscaled", str(xscaled))
     self.node.setTag("yscaled", str(yscaled))
     
     cm = CardMaker("tileobject")
     cm.setFrame(0,xorig,0,yorig)
     
     ts = TextureStage('ts')
     ts.setMode(TextureStage.MDecal)
     
     # distinguish between 3d collisions (for objects with an height and sensible self.properties['inclination'])
     # and 2d collisions for plain sprites
     if self.properties['walkable'] == 'false':
         if self.properties['collisionmode'] == "3d":
             #must handle differently objects which are small and big
             if xscaled < 1:
                 self.collisionTube = CollisionBox(LPoint3f(0.5 - xscaled/2 - self.properties['offsetwidth'],0,0),LPoint3f(0.5 + xscaled/2 + self.properties['offsetwidth'],0.1,0.3 + self.properties['offsetheight']))
                 
             if xscaled >= 1:
                 self.collisionTube = CollisionBox(LPoint3f(0 - self.properties['offsetwidth'],0,0),LPoint3f(xscaled + self.properties['offsetwidth'],0.1,0.3 + self.properties['offsetheight']))
             
             self.collisionNode = CollisionNode('objectSphere')
             self.collisionNode.addSolid(self.collisionTube)
             self.collisionNodeNp = self.node.attachNewNode(self.collisionNode)
             self.collisionNodeNp.setX(self.properties['offsethorizontal'])
             self.collisionNodeNp.setZ(self.properties['offsetvertical'])
             self.collisionNodeNp.setX(self.collisionNodeNp.getX()+self.properties['offsetcollisionh'])
             self.collisionNodeNp.setZ(self.collisionNodeNp.getZ()+self.properties['offsetcollisionv']+0.1)
             if main.editormode:
                 self.collisionNodeNp.show()
             
         elif self.properties['collisionmode'] == "2d":
             #must handle differently objects which are small and big
             if xscaled < 1:
                 self.collisionTube = CollisionBox(LPoint3f(0.5 - xscaled/2 - self.properties['offsetwidth'],0,0),LPoint3f(0.5 + xscaled/2 + self.properties['offsetwidth'],yscaled + self.properties['offsetheight'],0.3))
                 
             if xscaled >= 1:
                 self.collisionTube = CollisionBox(LPoint3f(0 - self.properties['offsetwidth'],0,0),LPoint3f(xscaled + self.properties['offsetwidth'],yscaled + self.properties['offsetheight'],0.3))
             
             self.collisionNode = CollisionNode('objectSphere')
             self.collisionNode.addSolid(self.collisionTube)
             self.collisionNodeNp = self.node.attachNewNode(self.collisionNode)
             self.collisionNodeNp.setP(-(270-int(self.properties['inclination'])))
             self.collisionNodeNp.setX(self.properties['offsethorizontal'])
             self.collisionNodeNp.setZ(self.properties['offsetvertical'])
             self.collisionNodeNp.setX(self.collisionNodeNp.getX()+self.properties['offsetcollisionh'])
             self.collisionNodeNp.setZ(self.collisionNodeNp.getZ()+self.properties['offsetcollisionv']+0.1)
             if main.editormode:
                 self.collisionNodeNp.show()
     
     geomnode = NodePath(cm.generate())
     if geomnode.node().isGeomNode():
         vdata = geomnode.node().modifyGeom(0).modifyVertexData()
         writer = GeomVertexWriter(vdata, 'vertex')
         reader = GeomVertexReader(vdata, 'vertex')
         
         '''
         this part apply rotation flattening to the perspective view
         by modifying directly structure vertices
         '''
         i = 0 #counter
         while not reader.isAtEnd():
             v = reader.getData3f()
             x = v[0]
             y = v[1]
             z = v[2]
             newx = x
             newy = y
             newz = z
             if self.properties['rotation'] == -90.0:
                 if i == 0:
                     newx = math.fabs(math.cos(math.radians(self.properties['inclination']))) * z
                     newz = 0
                     ssen = math.fabs(math.sin(math.radians(self.properties['inclination']))) * z
                     sparsen = math.fabs(math.sin(math.radians(self.properties['inclination']))) * ssen
                     spercos = math.fabs(math.cos(math.radians(self.properties['inclination']))) * ssen
                     newy -= spercos
                     newz += sparsen
                 if i == 2:
                     newx += math.fabs(math.cos(math.radians(self.properties['inclination']))) * z
                     newz = 0
                     ssen = math.fabs(math.sin(math.radians(self.properties['inclination']))) * z
                     sparsen = math.fabs(math.sin(math.radians(self.properties['inclination']))) * ssen
                     spercos = math.fabs(math.cos(math.radians(self.properties['inclination']))) * ssen
                     newy -= spercos
                     newz += sparsen
                 writer.setData3f(newx, newy, newz)
             i += 1 #increase vertex counter
     if xscaled >= 1:
         geomnode.setX(0)
     if xscaled < 1:
         geomnode.setX(0.5 - xscaled/2)
     geomnode.setScale(self.properties['scale'])
     geomnode.setX(geomnode.getX()+self.properties['offsethorizontal'])
     geomnode.setZ(geomnode.getZ()+self.properties['offsetvertical'])
     geomnode.setY(-self.properties['elevation'])
     geomnode.setP(int(self.properties['inclination'])-360)
     geomnode.setTexture(tex)
     geomnode.setTransparency(TransparencyAttrib.MAlpha)
     geomnode.reparentTo(self.node)
     self.node.setR(self.properties['rotation'])
Ejemplo n.º 35
0
    def generate(
            self
    ):  # call this after setting some of the variables to update it
        if hasattr(self, 'geomNode'):
            self.geomNode.removeAllGeoms()

        static_mode = Geom.UHStatic if self.static else Geom.UHDynamic
        vertex_format = Mesh._formats[(bool(self.colors), bool(self.uvs),
                                       bool(self.normals))]
        vdata = GeomVertexData('name', vertex_format, static_mode)
        vdata.setNumRows(len(self.vertices))  # for speed
        if not hasattr(self, 'geomNode'):
            self.geomNode = GeomNode('mesh')
            self.attachNewNode(self.geomNode)

        vertexwriter = GeomVertexWriter(vdata, 'vertex')
        for v in self.vertices:
            vertexwriter.addData3f(*v)

        if self.colors:
            colorwriter = GeomVertexWriter(vdata, 'color')
            for c in self.colors:
                colorwriter.addData4f(c)

        if self.uvs:
            uvwriter = GeomVertexWriter(vdata, 'texcoord')
            for uv in self.uvs:
                uvwriter.addData2f(uv[0], uv[1])

        if self.normals != None:
            normalwriter = GeomVertexWriter(vdata, 'normal')
            for norm in self.normals:
                normalwriter.addData3f(*norm)

        if self.mode != 'line' or not self._triangles:
            self.indices = list()

            if self._triangles:
                if isinstance(self._triangles[0], int):
                    for t in self._triangles:
                        self.indices.append(t)

                elif len(
                        self._triangles[0]
                ) >= 3:  # if tris are tuples like this: ((0,1,2), (1,2,3))
                    for t in self._triangles:
                        if len(t) == 3:
                            self.indices.extend(t)

                        elif len(t) == 4:  # turn quad into tris
                            self.indices.extend(
                                [t[i] for i in (0, 1, 2, 2, 3, 0)])

            else:
                self.indices = [i for i in range(len(self.vertices))]

            prim = Mesh._modes[self.mode](static_mode)

            self.generated_vertices = [self.vertices[i] for i in self.indices]
            for v in self.indices:
                prim.addVertex(v)

            prim.close_primitive()
            geom = Geom(vdata)
            geom.addPrimitive(prim)
            self.geomNode.addGeom(geom)

        else:  # line with segments defined in triangles
            for line in self._triangles:
                prim = Mesh._modes[self.mode](static_mode)
                for e in line:
                    prim.addVertex(e)
                prim.close_primitive()
                geom = Geom(vdata)
                geom.addPrimitive(prim)
                self.geomNode.addGeom(geom)

        if self.mode == 'point':
            self.setTexGen(TextureStage.getDefault(),
                           TexGenAttrib.MPointSprite)
Ejemplo n.º 36
0
    def modifyGeometryUVs(self):
        # Modifies the geometry vertex UVs in-place
        twriter = GeomVertexWriter(self.vdata, InternalName.getTexcoord())
        tanwriter = GeomVertexWriter(self.vdata, InternalName.getTangent())
        bwriter = GeomVertexWriter(self.vdata, InternalName.getBinormal())

        for i in range(len(self.vertices)):
            twriter.setData2f(self.vertices[i].uv)
            tanwriter.setData3f(self.material.tangent)
            bwriter.setData3f(self.material.binormal)
Ejemplo n.º 37
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
Ejemplo n.º 38
0
    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)
Ejemplo n.º 39
0
    def generate(
            self
    ):  # call this after setting some of the variables to update it
        if hasattr(self, 'geomNode'):
            self.geomNode.removeAllGeoms()

        static_mode = Geom.UHStatic if self.static else Geom.UHDynamic
        vertex_format = Mesh._formats[(bool(self.colors), bool(self.uvs),
                                       bool(self.normals))]
        vdata = GeomVertexData('name', vertex_format, static_mode)
        vdata.setNumRows(len(self.vertices))  # for speed
        self.geomNode = GeomNode('mesh')
        self.attachNewNode(self.geomNode)

        vertexwriter = GeomVertexWriter(vdata, 'vertex')
        for v in self.vertices:
            vertexwriter.addData3f((v[0], v[2], v[1]))  # swap y and z

        if self.colors:
            colorwriter = GeomVertexWriter(vdata, 'color')
            for c in self.colors:
                colorwriter.addData4f(c)

        if self.uvs:
            uvwriter = GeomVertexWriter(vdata, 'texcoord')
            for uv in self.uvs:
                uvwriter.addData2f(uv[0], uv[1])

        if self.normals != None:
            normalwriter = GeomVertexWriter(vdata, 'normal')
            for norm in self.normals:
                normalwriter.addData3f((norm[0], norm[2], norm[1]))

        if self.mode != 'line' or not self._triangles:
            prim = Mesh._modes[self.mode](static_mode)

            if self._triangles:
                if isinstance(self._triangles[0], int):
                    for t in self._triangles:
                        prim.addVertex(t)

                elif len(
                        self._triangles[0]
                ) >= 3:  # if tris are tuples like this: ((0,1,2), (1,2,3))
                    for t in self._triangles:
                        if len(t) == 3:
                            for e in t:
                                prim.addVertex(e)
                        elif len(t) == 4:  # turn quad into tris
                            prim.addVertex(t[0])
                            prim.addVertex(t[1])
                            prim.addVertex(t[2])
                            prim.addVertex(t[2])
                            prim.addVertex(t[3])
                            prim.addVertex(t[0])

            else:
                prim.addConsecutiveVertices(0, len(self.vertices))

            prim.close_primitive()
            geom = Geom(vdata)
            geom.addPrimitive(prim)
            self.geomNode.addGeom(geom)

        else:  # line with segments defined in triangles
            for line in self._triangles:
                prim = Mesh._modes[self.mode](static_mode)
                for e in line:
                    prim.addVertex(e)
                prim.close_primitive()
                geom = Geom(vdata)
                geom.addPrimitive(prim)
                self.geomNode.addGeom(geom)

        if self.mode == 'point':
            self.setTexGen(TextureStage.getDefault(),
                           TexGenAttrib.MPointSprite)
            # self.set_render_mode_perspective(True)

        self.recipe = dedent(f'''
            Mesh(
                vertices={[tuple(e) for e in self.vertices]},
                triangles={self._triangles},
                colors={[tuple(e) for e in self.colors]},
                uvs={self.uvs},
                normals={[tuple(e) for e in self.normals]},
                static={self.static},
                mode="{self.mode}",
                thickness={self.thickness}
            )
        ''')
Ejemplo n.º 40
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)
Ejemplo n.º 41
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)
Ejemplo n.º 42
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
Ejemplo n.º 43
0
 def interpolate_maps(self, task):
     # First, the actual interpolation
     t_index = self.last_time
     current_map = {}
     for x in range(0, self.sidelength):
         for y in range(0, self.sidelength):
             # calculate vertices
             p_1 = self.map_a[(x, y)]
             p_2 = self.map_b[(x, y)]
             v_x = p_1[0]*(1.0-t_index) + p_2[0]*t_index
             v_y = p_1[1]*(1.0-t_index) + p_2[1]*t_index
             v_z = p_1[2]*(1.0-t_index) + p_2[2]*t_index
             current_map[(x, y)] = (v_x, v_y, v_z)
     # Set up the writers
     vertex = GeomVertexWriter(self.vdata, 'vertex')
     normal = GeomVertexWriter(self.vdata, 'normal')
     # We don't use vertex readers as we don't care about the
     # current state, but if we did, it'd look like this:
     #     vertex_reader = GeomVertexReader(self.vdata, 'vertex')
     #     v = vertex_reader.getData3f()
     # Remember that all vertex readers working on a
     # GeomVertexData have to be created *after* the writers
     # working on it (due to engine internals; see the manual).
     for x in range(0, self.sidelength):
         for y in range(0, self.sidelength):
             v_x, v_y, v_z = current_map[(x, y)]
             vertex.setData3f(v_x, v_y, v_z)
             # Calculate the normal
             if x==0 and y==0:
                 s_0 = Vec3( 0.0,  1.0, v_z - current_map[(x, y+1)][2])
                 s_1 = Vec3( 1.0,  0.0, v_z - current_map[(x+1, y)][2])
                 e_0 = s_0.cross(s_1)
                 # Flip if necessary, then normalize
                 if e_0[2] < 0.0:
                     e_0 = e_0*-1.0
                 n = e_0
                 n = n/n.length()
             elif x==0 and y==(self.sidelength-1):
                 # First, we calculate the vectors to the neighbors.
                 s_1 = Vec3( 1.0,  0.0, v_z - current_map[(x+1, y)][2])
                 s_2 = Vec3( 0.0, -1.0, v_z - current_map[(x, y-1)][2])
                 e_1 = s_1.cross(s_2)
                 # Flip if necessary, then normalize
                 if e_1[2] < 0.0:
                     e_1 = e_1*-1.0
                 n = e_1
                 n = n/n.length()
             elif x==(self.sidelength-1) and y==0:
                 # First, we calculate the vectors to the neighbors.
                 s_0 = Vec3( 0.0,  1.0, v_z - current_map[(x, y+1)][2])
                 s_3 = Vec3(-1.0,  0.0, v_z - current_map[(x-1, y)][2])
                 e_3 = s_3.cross(s_0)
                 # Flip if necessary, then normalize
                 if e_3[2] < 0.0:
                     e_3 = e_3*-1.0
                 n = e_3
                 n = n/n.length()
             elif x==(self.sidelength-1) or y==(self.sidelength-1):
                 # First, we calculate the vectors to the neighbors.
                 s_2 = Vec3( 0.0, -1.0, v_z - current_map[(x, y-1)][2])
                 s_3 = Vec3(-1.0,  0.0, v_z - current_map[(x-1, y)][2])
                 e_2 = s_2.cross(s_3)
                 # Flip if necessary, then normalize
                 if e_2[2] < 0.0:
                     e_2 = e_2*-1.0
                 n = e_2
                 n = n/n.length()
             elif x==0:
                 # First, we calculate the vectors to the neighbors.
                 s_0 = Vec3( 0.0,  1.0, v_z - current_map[(x, y+1)][2])
                 s_1 = Vec3( 1.0,  0.0, v_z - current_map[(x+1, y)][2])
                 s_2 = Vec3( 0.0, -1.0, v_z - current_map[(x, y-1)][2])
                 e_0 = s_0.cross(s_1)
                 e_1 = s_1.cross(s_2)
                 # Flip if necessary, then normalize
                 if e_0[2] < 0.0:
                     e_0 = e_0*-1.0
                 if e_1[2] < 0.0:
                     e_1 = e_1*-1.0
                 n = e_0 + e_1
                 n = n/n.length()
             elif y==0:
                 # First, we calculate the vectors to the neighbors.
                 s_0 = Vec3( 0.0,  1.0, v_z - current_map[(x, y+1)][2])
                 s_1 = Vec3( 1.0,  0.0, v_z - current_map[(x+1, y)][2])
                 s_3 = Vec3(-1.0,  0.0, v_z - current_map[(x-1, y)][2])
                 e_0 = s_0.cross(s_1)
                 e_3 = s_3.cross(s_0)
                 # Flip if necessary, then normalize
                 if e_0[2] < 0.0:
                     e_0 = e_0*-1.0
                 if e_3[2] < 0.0:
                     e_3 = e_3*-1.0
                 n = e_0 + e_3
                 n = n/n.length()
             elif x==(self.sidelength-1):
                 # First, we calculate the vectors to the neighbors.
                 s_1 = Vec3( 1.0,  0.0, v_z - current_map[(x+1, y)][2])
                 s_2 = Vec3( 0.0, -1.0, v_z - current_map[(x, y-1)][2])
                 s_3 = Vec3(-1.0,  0.0, v_z - current_map[(x-1, y)][2])
                 e_1 = s_1.cross(s_2)
                 e_2 = s_2.cross(s_3)
                 # Flip if necessary, then normalize
                 if e_1[2] < 0.0:
                     e_1 = e_1*-1.0
                 if e_2[2] < 0.0:
                     e_2 = e_2*-1.0
                 n = e_1 + e_2
                 n = n/n.length()
             elif y==(self.sidelength-1):
                 # First, we calculate the vectors to the neighbors.
                 s_1 = Vec3( 1.0,  0.0, v_z - current_map[(x+1, y)][2])
                 s_2 = Vec3( 0.0, -1.0, v_z - current_map[(x, y-1)][2])
                 s_3 = Vec3(-1.0,  0.0, v_z - current_map[(x-1, y)][2])
                 e_1 = s_1.cross(s_2)
                 e_2 = s_2.cross(s_3)
                 # Flip if necessary, then normalize
                 if e_1[2] < 0.0:
                     e_1 = e_1*-1.0
                 if e_2[2] < 0.0:
                     e_2 = e_2*-1.0
                 n = e_1 + e_2
                 n = n/n.length()
             else: # This is a normal case, not an edge or corner.
                 # First, we calculate the vectors to the neighbors.
                 s_0 = Vec3( 0.0,  1.0, v_z - current_map[(x, y+1)][2])
                 s_1 = Vec3( 1.0,  0.0, v_z - current_map[(x+1, y)][2])
                 s_2 = Vec3( 0.0, -1.0, v_z - current_map[(x, y-1)][2])
                 s_3 = Vec3(-1.0,  0.0, v_z - current_map[(x-1, y)][2])
                 e_0 = s_0.cross(s_1)
                 e_1 = s_1.cross(s_2)
                 e_2 = s_2.cross(s_3)
                 e_3 = s_3.cross(s_0)
                 # Flip if necessary, then normalize
                 if e_0[2] < 0.0:
                     e_0 = e_0*-1.0
                 if e_1[2] < 0.0:
                     e_1 = e_1*-1.0
                 if e_2[2] < 0.0:
                     e_2 = e_2*-1.0
                 if e_3[2] < 0.0:
                     e_3 = e_3*-1.0
                 n = e_0 + e_1 + e_2 + e_3
                 n = n/n.length()
             normal.setData3f(n[0], n[1], n[2])
     return Task.cont
Ejemplo n.º 44
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
        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
Ejemplo n.º 45
0
    def __build_Tris(self, sphere, mode):
        vdata = GeomVertexData("Data", self.__vformat[mode], Geom.UHStatic)
        _num_rows = len(sphere.pts)

        # Vertices.
        vertices = GeomVertexWriter(vdata, "vertex")
        vertices.reserveNumRows(_num_rows)
        for pt in sphere.pts:
            vertices.addData3f(*pt)

        # Map coords.
        if mode == "mid":
            mapcoords = GeomVertexWriter(vdata, "mapcoord")
            mapcoords.reserveNumRows(_num_rows)
            for mc in sphere.coords:
                u, v = mc[:2]
                mapcoords.addData2f(u, v)

        # Tris.
        prim = GeomTriangles(Geom.UHStatic)
        prim.reserveNumVertices(len(sphere.tris))
        for tri in sphere.tris:
            prim.addVertices(*tri)
        prim.closePrimitive()

        # Geom.
        geom = Geom(vdata)
        geom.addPrimitive(prim)
        geom_node = GeomNode("geom")
        geom_node.addGeom(geom)
        geom_np = NodePath(geom_node)
        return geom_np
Ejemplo n.º 46
0
    def regenerateGeometry(self):
        #
        # Generate vertex data
        #

        numVerts = len(self.vertices)

        vdata = GeomVertexData("SolidFace", getFaceFormat(), GeomEnums.UHStatic)
        vdata.uncleanSetNumRows(len(self.vertices))

        vwriter = GeomVertexWriter(vdata, InternalName.getVertex())
        twriter = GeomVertexWriter(vdata, InternalName.getTexcoord())
        nwriter = GeomVertexWriter(vdata, InternalName.getNormal())
        tanwriter = GeomVertexWriter(vdata, InternalName.getTangent())
        bwriter = GeomVertexWriter(vdata, InternalName.getBinormal())

        for i in range(len(self.vertices)):
            vert = self.vertices[i]
            vwriter.setData3f(vert.pos)
            twriter.setData2f(vert.uv)
            nwriter.setData3f(self.plane.getNormal())
            tanwriter.setData3f(self.material.tangent)
            bwriter.setData3f(self.material.binormal)

        #
        # Generate indices
        #

        # Triangles in 3D view
        prim3D = GeomTriangles(GeomEnums.UHStatic)
        prim3D.reserveNumVertices((numVerts - 2) * 3)
        for i in range(1, numVerts - 1):
            prim3D.addVertices(i + 1, i, 0)
            prim3D.closePrimitive()

        # Line loop in 2D view.. using line strips
        prim2D = GeomLinestrips(GeomEnums.UHStatic)
        prim2D.reserveNumVertices(numVerts + 1)
        for i in range(numVerts):
            prim2D.addVertex(i)
        # Close off the line strip with the first vertex.. creating a line loop
        prim2D.addVertex(0)
        prim2D.closePrimitive()

        #
        # Generate mesh objects
        #

        geom3D = SolidFaceGeom(vdata)
        geom3D.setDrawMask(VIEWPORT_3D_MASK)
        geom3D.setPlaneCulled(True)
        geom3D.setPlane(self.plane)
        geom3D.addPrimitive(prim3D)
        self.index3D = self.solid.addFaceGeom(geom3D, self.state3D)

        geom3DLines = SolidFaceGeom(vdata)
        geom3DLines.addPrimitive(prim2D)
        geom3DLines.setDrawMask(VIEWPORT_3D_MASK)
        geom3DLines.setDraw(False)
        self.index3DLines = self.solid.addFaceGeom(geom3DLines, self.state3DLines)

        geom2D = SolidFaceGeom(vdata)
        geom2D.addPrimitive(prim2D)
        geom2D.setDrawMask(VIEWPORT_2D_MASK)
        self.index2D = self.solid.addFaceGeom(geom2D, self.state2D)

        self.geom3D = geom3D
        self.geom3DLines = geom3DLines
        self.geom2D = geom2D

        self.vdata = vdata

        self.hasGeometry = True
Ejemplo n.º 47
0
    def __build_Patches(self, sphere):
        vdata = GeomVertexData("Data", self.__vformat['high'], Geom.UHStatic)
        vertices = GeomVertexWriter(vdata, "vertex")
        mapcoords = GeomVertexWriter(vdata, "mapcoord")
        texcoords = GeomVertexWriter(vdata, "texcoord")

        _num_rows = len(sphere.pts)
        vertices.reserveNumRows(_num_rows)
        mapcoords.reserveNumRows(_num_rows)
        texcoords.reserveNumRows(_num_rows)

        # Pts.
        for pt, uv, coords, in zip(sphere.pts, sphere.uvs, sphere.coords):
            vertices.addData3f(*pt)
            mapcoords.addData2f(*coords)
            texcoords.addData2f(*uv)  ## *.99+.01)

        # Patches.
        prim = GeomPatches(3, Geom.UHStatic)
        prim.reserveNumVertices(len(sphere.tris))
        for tri in sphere.tris:
            prim.addVertices(*tri)
        prim.closePrimitive()

        # Geom.
        geom = Geom(vdata)
        geom.addPrimitive(prim)
        geom_node = GeomNode("geom")
        geom_node.addGeom(geom)
        geom_np = NodePath(geom_node)
        return geom_np
    def __init__(self, position, gridshape):
        self.geomnode = GeomNode("rhomdo")
        super().__init__(self.geomnode)

        z, y, x = position
        depth, height, width = gridshape
        self.color = (x / width), (y / height), (z / depth), 1

        format = GeomVertexFormat.getV3c4()
        vdata = GeomVertexData("vertices", format, Geom.UHStatic)
        vdata.setNumRows(14)

        vertexWriter = GeomVertexWriter(vdata, "vertex")
        colorWriter = GeomVertexWriter(vdata, "color")

        for i in range(14):
            colorWriter.addData4f(*self.color)
            self.color = max(self.color[0] - .03,
                             0), max(self.color[1] - .03,
                                     0), max(self.color[2] - .03, 0), 1

        realX = x * 2 - width
        realY = y * 2 - height
        realZ = z * SR2 - SR2 * .5 * depth
        odd = z % 2 == 1
        if odd:
            realX += 1
            realY += 1

        vertexWriter.addData3f(realX, realY, realZ + SR2)

        vertexWriter.addData3f(realX - 1, realY, realZ + (SR2 / 2))
        vertexWriter.addData3f(realX, realY - 1, realZ + (SR2 / 2))
        vertexWriter.addData3f(realX + 1, realY, realZ + (SR2 / 2))
        vertexWriter.addData3f(realX, realY + 1, realZ + (SR2 / 2))

        vertexWriter.addData3f(realX - 1, realY - 1, realZ)
        vertexWriter.addData3f(realX + 1, realY - 1, realZ)
        vertexWriter.addData3f(realX + 1, realY + 1, realZ)
        vertexWriter.addData3f(realX - 1, realY + 1, realZ)

        vertexWriter.addData3f(realX - 1, realY, realZ - (SR2 / 2))
        vertexWriter.addData3f(realX, realY - 1, realZ - (SR2 / 2))
        vertexWriter.addData3f(realX + 1, realY, realZ - (SR2 / 2))
        vertexWriter.addData3f(realX, realY + 1, realZ - (SR2 / 2))

        vertexWriter.addData3f(realX, realY, realZ - SR2)

        # step 2) make primitives and assign vertices to them
        tris = GeomTriangles(Geom.UHStatic)

        # top
        tris.addVertex(0)
        tris.addVertex(1)
        tris.addVertex(2)
        tris.closePrimitive()
        tris.addVertex(0)
        tris.addVertex(2)
        tris.addVertex(3)
        tris.closePrimitive()
        tris.addVertex(0)
        tris.addVertex(3)
        tris.addVertex(4)
        tris.closePrimitive()
        tris.addVertex(0)
        tris.addVertex(4)
        tris.addVertex(1)
        tris.closePrimitive()

        tris.addVertex(1)
        tris.addVertex(5)
        tris.addVertex(2)
        tris.closePrimitive()
        tris.addVertex(2)
        tris.addVertex(6)
        tris.addVertex(3)
        tris.closePrimitive()
        tris.addVertex(3)
        tris.addVertex(7)
        tris.addVertex(4)
        tris.closePrimitive()
        tris.addVertex(4)
        tris.addVertex(8)
        tris.addVertex(1)
        tris.closePrimitive()

        # middle
        tris.addVertex(1)
        tris.addVertex(8)
        tris.addVertex(9)
        tris.closePrimitive()
        tris.addVertex(1)
        tris.addVertex(9)
        tris.addVertex(5)
        tris.closePrimitive()
        tris.addVertex(2)
        tris.addVertex(5)
        tris.addVertex(10)
        tris.closePrimitive()
        tris.addVertex(2)
        tris.addVertex(10)
        tris.addVertex(6)
        tris.closePrimitive()
        tris.addVertex(3)
        tris.addVertex(6)
        tris.addVertex(11)
        tris.closePrimitive()
        tris.addVertex(3)
        tris.addVertex(11)
        tris.addVertex(7)
        tris.closePrimitive()
        tris.addVertex(4)
        tris.addVertex(7)
        tris.addVertex(12)
        tris.closePrimitive()
        tris.addVertex(4)
        tris.addVertex(12)
        tris.addVertex(8)
        tris.closePrimitive()

        # bottom
        tris.addVertex(5)
        tris.addVertex(9)
        tris.addVertex(10)
        tris.closePrimitive()
        tris.addVertex(6)
        tris.addVertex(10)
        tris.addVertex(11)
        tris.closePrimitive()
        tris.addVertex(7)
        tris.addVertex(11)
        tris.addVertex(12)
        tris.closePrimitive()
        tris.addVertex(8)
        tris.addVertex(12)
        tris.addVertex(9)
        tris.closePrimitive()

        tris.addVertex(9)
        tris.addVertex(13)
        tris.addVertex(10)
        tris.closePrimitive()
        tris.addVertex(10)
        tris.addVertex(13)
        tris.addVertex(11)
        tris.closePrimitive()
        tris.addVertex(11)
        tris.addVertex(13)
        tris.addVertex(12)
        tris.closePrimitive()
        tris.addVertex(12)
        tris.addVertex(13)
        tris.addVertex(9)
        tris.closePrimitive()

        rhomGeom = Geom(vdata)
        rhomGeom.addPrimitive(tris)
        self.geomnode.addGeom(rhomGeom)
Ejemplo n.º 49
0
    def __init__(self):
        ShowBase.__init__(self)

        self.cols = 100
        self.rows = 100

        base.disableMouse()
        base.setFrameRateMeter(True)
        self.cameraHeight = 13
        self.camera.set_pos(self.cols / 2, -30, self.cameraHeight)
        self.camera.look_at(self.cols / 2, 300, 0)

        plights = []

        for i in range(0, int(self.cols / 5), 2):
            plight = PointLight("plight")
            plight.setColor(VBase4(1, 1, 1, 1))
            plights.append(plight)
            plights[i] = self.render.attachNewNode(plight)
            x, y, z = self.camera.get_pos()
            plights[i].setPos(self.cols / 2 + ((i - int(i / 2)) * 10), y + 20,
                              5)
            self.render.set_light(plights[i])

            plight = PointLight("plight")
            plight.setColor(VBase4(1, 1, 1, 1))
            plights.append(plight)
            plights[i + 1] = self.render.attachNewNode(plight)
            x, y, z = self.camera.get_pos()
            plights[i + 1].setPos(self.cols / 2 + ((i - int(i / 2)) * 10),
                                  y + 20, 10)
            self.render.set_light(plights[i + 1])

        self.plights = plights

        format = GeomVertexFormat.getV3c4()
        vdata = GeomVertexData('name', format, Geom.UHStatic)
        vdata.setNumRows(self.cols * self.rows)
        self.vertex = GeomVertexWriter(vdata, 'vertex')
        self.color = GeomVertexWriter(vdata, 'color')

        pz = [random.uniform(-1, 1)]
        for i in range(self.rows):
            pz.append(random.uniform(pz[i - 1] - 1, pz[i] + 1))
        for y in range(0, self.rows):
            for x in range(0, self.cols):
                nz1 = random.uniform(pz[x] - 1, pz[x] + 1)
                nz2 = random.uniform(pz[x - 1] - 1, pz[x - 1] + 1)
                nz3 = random.uniform(pz[x + 1] - 1, pz[x + 1] + 1)
                nz = (nz1 + nz2 + nz3) / 3
                self.vertex.add_data3f((x, y + 1, nz))
                self.vertex.add_data3f((x, y, pz[x]))
                if nz < -5:
                    self.color.add_data4f(0.2, 0.1, 0, 1)
                elif nz < -3:
                    self.color.add_data4f(0, 0.2, 0.1, 1)
                elif nz < 0:
                    self.color.add_data4f(0, 0.4, 0.2, 1)
                elif nz < 2:
                    self.color.add_data4f(0.4, 0.4, 0.4, 1)
                else:
                    self.color.add_data4f(1, 1, 1, 1)
                if nz < -5:
                    self.color.add_data4f(0.2, 0.1, 0, 1)
                elif nz < -3:
                    self.color.add_data4f(0, 0.2, 0.1, 1)
                elif pz[x] < 0:
                    self.color.add_data4f(0, 0.4, 0.2, 1)
                elif pz[x] < 2:
                    self.color.add_data4f(0.4, 0.4, 0.4, 1)
                else:
                    self.color.add_data4f(1, 1, 1, 1)
                pz[x] = nz
                #print (nz)
        self.pz = pz

        geom = Geom(vdata)
        for y in range(0, self.rows):
            prim = GeomTristrips(Geom.UH_static)
            prim.addVertex(y * self.cols * 2)
            prim.add_next_vertices((self.cols * 2) - 1)
            prim.close_primitive()
            geom.addPrimitive(prim)

        nodeTris = GeomNode("TriStrips")
        nodeTris.addGeom(geom)
        self.nodeTrisPath = self.render.attachNewNode(nodeTris)
        self.task_mgr.add(self.moveForwardTask, "moveForwardTask")

        self.vdata = vdata
        self.newNodePath = []
        self.counter = 0
        self.rows1 = self.rows

        skybox = self.loader.loadModel("models/skybox.bam")
        skybox.reparent_to(self.render)
        skybox.set_scale(20000)

        skybox_texture = self.loader.loadTexture("textures/dayfair.jpg")
        skybox_texture.set_minfilter(SamplerState.FT_linear)
        skybox_texture.set_magfilter(SamplerState.FT_linear)
        skybox_texture.set_wrap_u(SamplerState.WM_repeat)
        skybox_texture.set_wrap_v(SamplerState.WM_mirror)
        skybox_texture.set_anisotropic_degree(16)
        skybox.set_texture(skybox_texture)

        skybox_shader = Shader.load(Shader.SL_GLSL, "skybox.vert.glsl",
                                    "skybox.frag.glsl")
        skybox.set_shader(skybox_shader)
Ejemplo n.º 50
0
    def create_profile(self):
        """
        Creates the necessary rendering geometry to render the 3d rendition of
        a CHS.
        """

        beam = self.beam
        s = self.s
        prof = beam.profile

        color = (0.25882353, 0.80784314, 0.95686275, 1)

        fmt = GeomVertexFormat.getV3n3c4()
        vertexData = GeomVertexData('something', fmt, Geom.UHStatic)

        vertexData.setNumRows(2304)

        vertices = GeomVertexWriter(vertexData, 'vertex')
        normals = GeomVertexWriter(vertexData, 'normal')
        colors = GeomVertexWriter(vertexData, 'color')

        T = beam.elements[0].trans_matrix[:3, :3]

        b_0 = np.array([beam.x[0], beam.y[0], beam.z[0]]) / s
        b_l = np.array([beam.x[-1], beam.y[-1], beam.z[-1]]) / s

        s_ang = 49

        wall = []

        for in_out in ((prof.D / 2) / s, (prof.D / 2 - prof.t) / s):
            for b in [b_0, b_l]:
                layer = []
                for j in range(s_ang):
                    ang = j * (2 * np.pi / (s_ang-1))

                    p = b + np.dot(T.T, np.array([0,
                                                  in_out * np.sin(ang),
                                                  in_out * np.cos(ang)]))

                    layer.append(p)
                if layer:
                    wall.append(layer)

        prim = GeomTriangles(Geom.UHStatic)

        vtx_count = -1

        for io in (0, 1):
            for l in range(2):
                for a in range(s_ang-1):
                    if io == 0:
                        p, n = self.mk_surface(wall[l][a],
                                               wall[l+1][a+1],
                                               wall[l][a+1])
                    else:
                        p, n = self.mk_surface(wall[l+io][a],
                                               wall[l+io][a+1],
                                               wall[l+1+io][a+1])

                    for i in range(p.shape[0]):
                        vertices.addData3f(*p[i, :])
                        normals.addData3f(*(-n))
                        colors.addData4f(*color)
                        vtx_count += 1

                    prim.add_vertices(vtx_count - 2,
                                      vtx_count - 1,
                                      vtx_count)

                    if io == 0:
                        p, n = self.mk_surface(wall[l+io][a],
                                               wall[l+1+io][a],
                                               wall[l+1+io][a+1])
                    else:
                        p, n = self.mk_surface(wall[l+io][a],
                                               wall[l+1+io][a+1],
                                               wall[l+1+io][a])

                    for i in range(p.shape[0]):
                        vertices.addData3f(*p[i, :])
                        normals.addData3f(*(-n))
                        colors.addData4f(*color)
                        vtx_count += 1

                    prim.add_vertices(vtx_count - 2,
                                      vtx_count - 1,
                                      vtx_count)

        for io in (0, 2):
            for a in range(s_ang-1):
                if io == 0:
                    p, n = self.mk_surface(wall[0][a],
                                           wall[-2][a+1],
                                           wall[-2][a])
                else:
                    p, n = self.mk_surface(wall[1][a],
                                           wall[-1][a],
                                           wall[-1][a+1])
                for i in range(p.shape[0]):
                    vertices.addData3f(*p[i, :])
                    normals.addData3f(*(-n))
                    colors.addData4f(*color)
                    vtx_count += 1
                prim.add_vertices(vtx_count - 2,
                                  vtx_count - 1,
                                  vtx_count)
                if io == 0:
                    p, n = self.mk_surface(wall[0][a],
                                           wall[0][a+1],
                                           wall[-2][a+1])
                else:
                    p, n = self.mk_surface(wall[1][a],
                                           wall[-1][a+1],
                                           wall[1][a+1])
                for i in range(p.shape[0]):
                    vertices.addData3f(*p[i, :])
                    normals.addData3f(*(-n))
                    colors.addData4f(*color)
                    vtx_count += 1
                prim.add_vertices(vtx_count - 2,
                                  vtx_count - 1,
                                  vtx_count)

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

        node = GeomNode('CHS')
        node.addGeom(geom)
        return node
Ejemplo n.º 51
0
def visualize(centers, corners, edges):
    from meshtool.filters.panda_filters.pandacore import getVertexData, attachLights, ensureCameraAt
    from meshtool.filters.panda_filters.pandacontrols import KeyboardMovement, MouseDrag, MouseScaleZoom, MouseCamera
    from panda3d.core import GeomPoints, GeomTriangles, Geom, GeomNode, GeomVertexFormat, GeomVertexData, GeomVertexWriter, LineSegs, VBase3
    from direct.showbase.ShowBase import ShowBase

    format = GeomVertexFormat.getV3c4()
    vdata = GeomVertexData('pts', format, Geom.UHDynamic)
    vertex = GeomVertexWriter(vdata, 'vertex')
    color = GeomVertexWriter(vdata, 'color')

    vertex_index = 0
    center_vertex_indices = {}
    corner_vertex_indices = {}
    for key, center in centers.iteritems():
        vertex.addData3f(center.x * X_SCALE, center.y * Y_SCALE,
                         center.elevation * Z_SCALE)
        curcolor = hex2rgb(COLORS[center.biome])
        color.addData4f(curcolor[0], curcolor[1], curcolor[2], 1)
        center_vertex_indices[key] = vertex_index
        vertex_index += 1

        for corner in center.corners:
            vertex.addData3f(corner.x * X_SCALE, corner.y * Y_SCALE,
                             corner.elevation * Z_SCALE)
            color.addData4f(curcolor[0], curcolor[1], curcolor[2], 1)
            corner_vertex_indices[corner.id] = vertex_index
            vertex_index += 1

    tris = GeomTriangles(Geom.UHDynamic)

    for edge in edges.itervalues():
        corner0 = edge.corner0
        corner1 = edge.corner1
        center0 = edge.center0
        center1 = edge.center1
        if corner0 is None or corner1 is None:
            continue

        tris.addVertices(corner_vertex_indices[corner1.id],
                         corner_vertex_indices[corner0.id],
                         center_vertex_indices[center0.id])

        tris.addVertices(center_vertex_indices[center1.id],
                         corner_vertex_indices[corner0.id],
                         corner_vertex_indices[corner1.id])

    tris.closePrimitive()

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

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

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

    #geomPath.setRenderModeWireframe()

    ensureCameraAt(geomPath, base.cam)

    boundingSphere = geomPath.getBounds()
    base.cam.setPos(boundingSphere.getCenter() + boundingSphere.getRadius())

    base.cam.lookAt(boundingSphere.getCenter())

    geomPath.setScale(VBase3(50, 50, 50))

    KeyboardMovement()
    #MouseDrag(geomPath)
    MouseCamera()
    MouseScaleZoom(geomPath)
    #render.setShaderAuto()
    p3dApp.run()
Ejemplo n.º 52
0
class Mesh():
    def __init__(self, name):
        self.name = name
        self.poly_groups = []

        # GeomVertexFormats
        #
        # GeomVertexFormat.getV3cpt2()  - vertex, color, uv
        # GeomVertexFormat.getV3t2()    - vertex, uv
        # GeomVertexFormat.getV3cp()    - vertex, color
        # GeomVertexFormat.getV3n3t2()  - vertex, normal, uv
        # GeomVertexFormat.getV3n3cpt2()- vertex, normal, rgba, uv

        # textured
        self.vdata = GeomVertexData(name, GeomVertexFormat.getV3n3cpt2(),
                                    Geom.UHStatic)

        # plain color filled polys
        # self.vdata = GeomVertexData(name, GeomVertexFormat.getV3cp(), Geom.UHStatic)

        self.vertex = GeomVertexWriter(self.vdata, 'vertex')
        self.vnormal = GeomVertexWriter(self.vdata, 'normal')
        self.color = GeomVertexWriter(self.vdata, 'color')
        self.texcoord = GeomVertexWriter(self.vdata, 'texcoord')

        self.root = NodePath(PandaNode(name + '_mesh'))

    # f is a 0x36 mesh fragment (see fragment.py for reference)
    def buildFromFragment(self, f, wld_container, debug=False):

        # write vertex coordinates
        for v in f.vertexList:
            self.vertex.addData3f(v[0], v[1], v[2])

        # write vertex colors
        for rgba in f.vertexColorsList:
            '''
            r = (rgba & 0xff000000) >> 24
            g = (rgba & 0x00ff0000) >> 16
            b = (rgba & 0x0000ff00) >> 8
            a = (rgba & 0x000000ff)
            if a != 0:
                print 'vertex color has alpha component, r:0x%x g:0x%x b:0x%x a:0x%x ' % (r, g, b, a)
            '''
            self.color.addData1f(rgba)

        # write vertex normals
        for v in f.vertexNormalsList:
            self.vnormal.addData3f(v[0], v[1], v[2])

        # write texture uv
        for uv in f.uvList:
            self.texcoord.addData2f(uv[0], uv[1])

        # Build PolyGroups
        # each polyTexList is a tuple containing a polygon count and the texture index for those polys
        # we create a PolyGroup for each of these
        # the PolyGroup creates all Polygons sharing a texture and adds them under a NodePath
        poly_idx = 0
        for pt in f.polyTexList:
            n_polys = pt[0]
            tex_idx = pt[1]

            if debug:
                print("  Bulding a poly group with tex_id " + str(tex_idx))
            pg = PolyGroup(self.vdata, tex_idx)

            # pass fragment so that it can access the SPRITES
            if pg.build(wld_container, f, poly_idx, n_polys, tex_idx,
                        debug) == 1:
                self.poly_groups.append(pg)
                pg.nodePath.reparentTo(self.root)

            poly_idx += n_polys

        if poly_idx != f.polyCount or poly_idx != len(f.polyList):
            print 'ERROR: polycount mismatch'
Ejemplo n.º 53
0
class Orbit(VisibleObject):
    ignore_light = True
    default_shown = False
    selected_color = LColor(1.0, 0.0, 0.0, 1.0)

    def __init__(self, body):
        VisibleObject.__init__(self, body.get_ascii_name() + '-orbit')
        self.body = body
        self.nbOfPoints = 360
        self.orbit = self.find_orbit(self.body)
        self.color = None
        self.fade = 0.0
        if not self.orbit:
            print("No orbit for", self.get_name())
            self.visible = False
        self.check_settings()

    def check_settings(self):
        if self.body.body_class is None:
            print("No class for", self.body.get_name())
            return
        self.set_shown(settings.show_orbits
                       and bodyClasses.get_show_orbit(self.body.body_class))

    def find_orbit(self, body):
        if body != None:
            if not isinstance(body.orbit, FixedOrbit):
                return body.orbit
            else:
                return None, None
        else:
            return None, None

    def set_selected(self, selected):
        if selected:
            self.color = self.selected_color
        else:
            self.color = self.parent.get_orbit_color()
        if self.instance:
            self.instance.setColor(self.color * self.fade)

    def create_instance(self):
        if not self.orbit:
            return
        self.vertexData = GeomVertexData('vertexData',
                                         GeomVertexFormat.getV3(),
                                         Geom.UHStatic)
        self.vertexWriter = GeomVertexWriter(self.vertexData, 'vertex')
        delta = self.body.parent.get_local_position()
        for i in range(self.nbOfPoints):
            time = self.orbit.period / self.nbOfPoints * i
            pos = self.orbit.get_position_at(time)
            rot = self.orbit.get_rotation_at(time)
            pos = self.orbit.frame.get_local_position(rot.xform(pos)) - delta
            self.vertexWriter.addData3f(*pos)
        self.lines = GeomLines(Geom.UHStatic)
        for i in range(self.nbOfPoints - 1):
            self.lines.addVertex(i)
            self.lines.addVertex(i + 1)
            self.lines.closePrimitive()
        self.lines.addVertex(self.nbOfPoints - 1)
        self.lines.addVertex(0)
        self.lines.closePrimitive()
        self.geom = Geom(self.vertexData)
        self.geom.addPrimitive(self.lines)
        self.node = GeomNode(self.body.get_ascii_name() + '-orbit')
        self.node.addGeom(self.geom)
        self.instance = NodePath(self.node)
        self.instance.setRenderModeThickness(settings.orbit_thickness)
        self.instance.setCollideMask(GeomNode.getDefaultCollideMask())
        self.instance.node().setPythonTag('owner', self)
        self.instance.reparentTo(self.context.annotation_shader)
        if self.color is None:
            self.color = self.parent.get_orbit_color()
        self.instance.setColor(self.color * self.fade)
        self.instance.setAntialias(AntialiasAttrib.MMultisample)
        self.appearance = ModelAppearance(attribute_color=True)
        if settings.use_inv_scaling:
            vertex_control = LargeObjectVertexControl()
        else:
            vertex_control = None
        self.instance_ready = True
        self.shader = BasicShader(lighting_model=FlatLightingModel(),
                                  vertex_control=vertex_control)
        self.shader.apply(self, self.appearance)
        self.shader.update(self, self.appearance)

    def check_visibility(self, pixel_size):
        if self.parent.shown and self.orbit:
            distance_to_obs = self.parent.distance_to_obs
            if distance_to_obs > 0.0:
                size = self.orbit.get_apparent_radius() / (distance_to_obs *
                                                           pixel_size)
            else:
                size = 0.0
            self.visible = size > settings.orbit_fade
            self.fade = min(
                1.0,
                max(0.0, (size - settings.orbit_fade) / settings.orbit_fade))
            if self.color is not None and self.instance is not None:
                self.instance.setColor(self.color * self.fade)
        else:
            self.visible = False

    def update_instance(self, camera_pos, orientation):
        if self.instance:
            self.place_instance_params(self.instance,
                                       self.body.parent.scene_position,
                                       self.body.parent.scene_scale_factor,
                                       LQuaternion())
            self.shader.update(self, self.appearance)
Ejemplo n.º 54
0
def makeSquare(x1, y1, z1, x2, y2, z2, colorInfo):
    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(colorInfo[0], colorInfo[1], colorInfo[2], colorInfo[3])
    color.addData4f(colorInfo[0], colorInfo[1], colorInfo[2], colorInfo[3])
    color.addData4f(colorInfo[0], colorInfo[1], colorInfo[2], colorInfo[3])
    color.addData4f(colorInfo[0], colorInfo[1], colorInfo[2], colorInfo[3])

    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
Ejemplo n.º 55
0
 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)
Ejemplo n.º 56
0
    def create_instance(self):
        self.vertexData = GeomVertexData('vertexData',
                                         GeomVertexFormat.getV3c4(),
                                         Geom.UHStatic)
        self.vertexWriter = GeomVertexWriter(self.vertexData, 'vertex')
        self.colorwriter = GeomVertexWriter(self.vertexData, 'color')
        for r in range(1, self.nbOfRings + 1):
            for i in range(self.nbOfPoints):
                angle = 2 * pi / self.nbOfPoints * i
                x = cos(angle) * sin(pi * r / (self.nbOfRings + 1))
                y = sin(angle) * sin(pi * r / (self.nbOfRings + 1))
                z = sin(-pi / 2 + pi * r / (self.nbOfRings + 1))

                self.vertexWriter.addData3f(
                    (self.context.observer.infinity * x,
                     self.context.observer.infinity * y,
                     self.context.observer.infinity * z))
                if r == self.nbOfRings / 2 + 1:
                    self.colorwriter.addData4f(self.color.x * 1.5, 0, 0, 1)
                else:
                    self.colorwriter.addData4f(*self.color)
        for s in range(self.nbOfSectors):
            for i in range(self.points_to_remove,
                           self.nbOfPoints // 2 - self.points_to_remove + 1):
                angle = 2 * pi / self.nbOfPoints * i
                x = cos(2 * pi * s / self.nbOfSectors) * sin(angle)
                y = sin(2 * pi * s / self.nbOfSectors) * sin(angle)
                z = cos(angle)

                self.vertexWriter.addData3f(
                    (self.context.observer.infinity * x,
                     self.context.observer.infinity * y,
                     self.context.observer.infinity * z))
                if s == 0:
                    self.colorwriter.addData4f(self.color.x * 1.5, 0, 0, 1)
                else:
                    self.colorwriter.addData4f(*self.color)
        self.lines = GeomLines(Geom.UHStatic)
        index = 0
        for r in range(self.nbOfRings):
            for i in range(self.nbOfPoints - 1):
                self.lines.addVertex(index)
                self.lines.addVertex(index + 1)
                self.lines.closePrimitive()
                index += 1
            self.lines.addVertex(index)
            self.lines.addVertex(index - self.nbOfPoints + 1)
            self.lines.closePrimitive()
            index += 1
        for r in range(self.nbOfSectors):
            for i in range(self.nbOfPoints // 2 - self.points_to_remove * 2):
                self.lines.addVertex(index)
                self.lines.addVertex(index + 1)
                self.lines.closePrimitive()
                index += 1
            index += 1
        self.geom = Geom(self.vertexData)
        self.geom.addPrimitive(self.lines)
        self.node = GeomNode("grid")
        self.node.addGeom(self.geom)
        self.instance = NodePath(self.node)
        self.instance.setRenderModeThickness(settings.grid_thickness)
        #myMaterial = Material()
        #myMaterial.setEmission((1.0, 1.0, 1.0, 1))
        #self.instance.setMaterial(myMaterial)
        self.instance.reparentTo(self.context.annotation)
        self.instance.setQuat(LQuaternion(*self.orientation))
Ejemplo n.º 57
0
class Asterism(VisibleObject):
    def __init__(self, name):
        VisibleObject.__init__(self, name)
        self.visible = True
        self.color = bodyClasses.get_orbit_color('constellation')
        self.position = LPoint3d(0, 0, 0)
        self.segments = []
        self.position = None

    def check_settings(self):
        self.set_shown(settings.show_asterisms)

    def set_segments_list(self, segments):
        self.segments = segments
        ra_sin = 0
        ra_cos = 0
        decl = 0
        if len(self.segments) > 0 and len(self.segments[0]) > 0:
            for star in self.segments[0]:
                asc = star.orbit.get_right_asc()
                ra_sin += sin(asc)
                ra_cos += cos(asc)
                decl += star.orbit.get_declination()
            ra = atan2(ra_sin, ra_cos)
            decl /= len(self.segments[0])
            self.position = InfinitePosition(right_asc=ra,
                                             right_asc_unit=units.Rad,
                                             declination=decl,
                                             declination_unit=units.Rad)

    def create_instance(self):
        self.vertexData = GeomVertexData('vertexData',
                                         GeomVertexFormat.getV3c4(),
                                         Geom.UHStatic)
        self.vertexWriter = GeomVertexWriter(self.vertexData, 'vertex')
        self.colorwriter = GeomVertexWriter(self.vertexData, 'color')
        #TODO: Ugly hack to calculate star position from the sun...
        old_cam_pos = self.context.observer.camera_global_pos
        self.context.observer.camera_global_pos = LPoint3d()
        center = LPoint3d()
        for segment in self.segments:
            if len(segment) < 2: continue
            for star in segment:
                #TODO: Temporary workaround to have star pos
                star.update(0)
                star.update_obs(self.context.observer)
                position, distance, scale_factor = self.get_real_pos_rel(
                    star.rel_position, star.distance_to_obs,
                    star.vector_to_obs)
                self.vertexWriter.addData3f(*position)
                self.colorwriter.addData4f(*self.color)
        self.context.observer.camera_global_pos = old_cam_pos
        self.lines = GeomLines(Geom.UHStatic)
        index = 0
        for segment in self.segments:
            if len(segment) < 2: continue
            for i in range(len(segment) - 1):
                self.lines.addVertex(index)
                self.lines.addVertex(index + 1)
                self.lines.closePrimitive()
                index += 1
            index += 1
        self.geom = Geom(self.vertexData)
        self.geom.addPrimitive(self.lines)
        self.node = GeomNode("asterism")
        self.node.addGeom(self.geom)
        self.instance = NodePath(self.node)
        self.instance.setRenderModeThickness(settings.asterism_thickness)
        self.instance.reparentTo(self.context.annotation)
        self.instance.setBin('background', settings.asterisms_depth)
        self.instance.set_depth_write(False)
Ejemplo n.º 58
0
def _generate_mesh(radius: float, count: int) -> Geom:
    """Generate mesh for the ground plane."""
    vertex_data = GeomVertexData('ground', VERTEX_FORMAT, Geom.UH_static)
    vertex_data.set_num_rows(count**2)
    vertex_writer = GeomVertexWriter(vertex_data, 'vertex')
    normal_writer = GeomVertexWriter(vertex_data, 'normal')
    texcoord_writer = GeomVertexWriter(vertex_data, 'texcoord')

    step = 2 * radius / count
    for i, j in product(range(count + 1), repeat=2):
        vertex_writer.add_data3f(i * step - radius, j * step - radius, 0.0)
        normal_writer.add_data3f(0.0, 0.0, 1.0)
        texcoord_writer.add_data2f(i * 512, j * 512)

    geom = Geom(vertex_data)
    primitive = GeomTristrips(Geom.UH_static)
    for j in range(count):
        rows = range(count + 1) if j % 2 else reversed(range(count + 1))
        for i in rows:
            primitive.add_vertex((j + (j + 1) % 2) * (count + 1) + i)
            primitive.add_vertex((j + j % 2) * (count + 1) + i)
    primitive.close_primitive()
    geom.add_primitive(primitive)
    return geom
Ejemplo n.º 59
0
class Sun(PandaNode):
    def __init__(self, base_object):
        PandaNode.__init__(self, "Sun")

        self.geom = GeomNode("Sun")
        self.vertexData = GeomVertexData("Basis", GeomVertexFormat.getV3cpt2(),
                                         Geom.UHStatic)
        self.vertex = GeomVertexWriter(self.vertexData, 'vertex')
        self.tex_coord = GeomVertexWriter(self.vertexData, 'texcoord')
        self.mesh = Geom(self.vertexData)
        self.tris = GeomTristrips(Geom.UHStatic)

        self.vertex.addData3f(0.0, 0.0, 0.0)
        self.tex_coord.addData2f(1.0, 0.0)

        self.vertex.addData3f(1.0, 0.0, 0.0)
        self.tex_coord.addData2f(1.0, 1.0)

        self.vertex.addData3f(0.0, 1.0, 0.0)
        self.tex_coord.addData2f(0.0, 0.0)

        self.vertex.addData3f(1.0, 1.0, 0.0)
        self.tex_coord.addData2f(0.0, 1.0)

        self.tris.add_vertices(0, 1, 2, 3)

        self.tris.closePrimitive()
        self.mesh.addPrimitive(self.tris)
        self.geom.addGeom(self.mesh)

        self.node = base_object.render.attachNewNode(self.geom)
        self.node.set_r(-90)
        self.node.set_h(90)
        self.node.set_scale(40)

        self.node.set_pos(0, 500, 0)

        self.texture = base_object.loader.loadTexture(
            base_object.params("sun_texture"))
        self.node.set_texture(self.texture)

        self.node.setLightOff()
        self.node.setColorOff()
        self.node.setTransparency(True)

        self.node.set_bin('fixed', 1)
        self.node.set_depth_write(0)
        self.node.set_depth_test(0)

        self.node.setBillboardPointEye()

    def move(self, dx):
        self.node.set_pos(self.node.get_pos() + dx)