예제 #1
0
파일: water.py 프로젝트: figo-sh/naith
def getWaterSurface(manager, polycount=50000, size=(512, 512)):
    # Get cache directory...
    cacheDir = manager.get("paths").getConfig().find("cache").get("path")

    # Check if the data required already exists...
    cachedWaterSurface = "%s/plane-%dx%d-%dk.bam" % (cacheDir, size[0], size[1], int(polycount / 1000))
    try:
        return loader.loadModel(cachedWaterSurface)
    except:
        pass

    # Make cache directory if needed...
    if not os.path.isdir(cacheDir):
        os.mkdir(cacheDir)

    # Put in an image...
    img = PNMImage(*size)
    img.makeGrayscale()
    img.fill(0, 0, 0)
    img.write("%s/black-%dx%d.png" % (cacheDir, size[0], size[1]))

    # Put in a mesh...
    ht = HeightfieldTesselator("plane")
    assert ht.setHeightfield(Filename("%s/black-%dx%d.png" % (cacheDir, size[0], size[1])))
    ht.setPolyCount(polycount)
    ht.setFocalPoint(size[0] * 0.5, size[1] * 0.5)
    node = ht.generate()
    node.setPos(-0.5 * size[0], 0.5 * size[1], 0)
    node.flattenLight()
    node.writeBamFile(cachedWaterSurface)

    return node
예제 #2
0
	def export(self, file_name, texture_data):
		from pandac.PandaModules import PNMImage, VBase4D
		from pandac.PandaModules import Texture as P3DTexture

		pnm = PNMImage(256, 1024)
		self.texture2.store(pnm)
		pnm.write(file_name)
예제 #3
0
파일: map3d.py 프로젝트: viatoriche/suber
    def get_heightmap_tex(self, size, filename = None):
        """Generate texture of map
        """
        mod = self.world_size / size
        image = PNMImage(size, size)
        for x in xrange(size):
            for y in xrange(size):
                px = x * mod
                py = y * mod
                height = self[px, py]
                color = height / 50
                r = 0
                g = 0
                b = 0
                if color > 255:
                    color = 255
                if color < 0:
                    color = abs(color)
                    b = color
                else:
                    g = color
                image.setPixel(x, y, (r, g, b))

        if filename != None:
            image.write(filename)

        #for x in xrange(-1, 2):
            #for y in xrange(-1, 2):
               #image.setPixel(int(world.chunks_map.charX)+x, int(world.chunks_map.charY)+y, (255, 0, 0))

        texture = Texture()
        texture.load(image)
        return texture
예제 #4
0
def getWaterSurface(manager, polycount=50000, size=(512, 512)):
    # Get cache directory...
    cacheDir = manager.get('paths').getConfig().find('cache').get('path')

    # Check if the data required already exists...
    cachedWaterSurface = "%s/plane-%dx%d-%dk.bam" % (
        cacheDir, size[0], size[1], int(polycount / 1000))
    try:
        return loader.loadModel(cachedWaterSurface)
    except:
        pass

    # Make cache directory if needed...
    if not os.path.isdir(cacheDir):
        os.mkdir(cacheDir)

    # Put in an image...
    img = PNMImage(*size)
    img.makeGrayscale()
    img.fill(0, 0, 0)
    img.write("%s/black-%dx%d.png" % (cacheDir, size[0], size[1]))

    # Put in a mesh...
    ht = HeightfieldTesselator("plane")
    assert ht.setHeightfield(
        Filename("%s/black-%dx%d.png" % (cacheDir, size[0], size[1])))
    ht.setPolyCount(polycount)
    ht.setFocalPoint(size[0] * 0.5, size[1] * 0.5)
    node = ht.generate()
    node.setPos(-0.5 * size[0], 0.5 * size[1], 0)
    node.flattenLight()
    node.writeBamFile(cachedWaterSurface)

    return node
예제 #5
0
    def get_heightmap_tex(self, size, filename=None):
        """Generate texture of map
        """
        mod = self.world_size / size
        image = PNMImage(size, size)
        for x in xrange(size):
            for y in xrange(size):
                px = x * mod
                py = y * mod
                height = self[px, py]
                color = height / 50
                r = 0
                g = 0
                b = 0
                if color > 255:
                    color = 255
                if color < 0:
                    color = abs(color)
                    b = color
                else:
                    g = color
                image.setPixel(x, y, (r, g, b))

        if filename != None:
            image.write(filename)

        #for x in xrange(-1, 2):
        #for y in xrange(-1, 2):
        #image.setPixel(int(world.chunks_map.charX)+x, int(world.chunks_map.charY)+y, (255, 0, 0))

        texture = Texture()
        texture.load(image)
        return texture
예제 #6
0
파일: m.py 프로젝트: kit-ipe/sensorsEditor
    def paintEvent(self,  event):

        screenData = StringStream() # Used to pass the data as a string
        screenImage = PNMImage() # Converts the texture data into a format usable with Qt

        if self.pandaTexture.hasRamImage():
            print "Should draw yes?"
            self.pandaTexture.store(screenImage)
            screenImage.write(screenData, "test.ppm")
            self.paintPixmap.loadFromData(screenData.getData())
            self.paintSurface.setPixmap(self.paintPixmap)
예제 #7
0
    def get_map_3d_tex(self, size, filename=None, charPos=None):
        """Generate texture of map
        """
        mod = self.world_size / size
        image = PNMImage(size, size)
        for x in xrange(size):
            for y in xrange(size):
                px = x * mod
                py = y * mod
                height = self[px, py]
                if height <= 0:
                    color = (abs(height) / 50) + 50
                    if color > 255:
                        color = 255
                    image.setPixel(x, y, (0, 0, 255 - color))
                else:
                    if height <= self.config.low_mount_level[1]:
                        color = height / 20
                        r = 0
                        g = 50 + color
                        b = 0
                        image.setPixel(x, y, (r, g, b))
                    elif height > self.config.low_mount_level[1]:
                        color = height / 50
                        r = color
                        g = color
                        b = color
                        if r > 255:
                            r = 255
                        if g > 255:
                            r = 255
                        if b > 255:
                            b = 255
                        image.setPixel(x, y, (r, g, b))

        if filename != None:
            image.write(filename)

        if charPos != None:
            charX, charY = charPos
            for x in xrange(-1, 2):
                for y in xrange(-1, 2):
                    image.setPixel(
                        int(charX / mod) + x,
                        int(charY / mod) + y, (255, 0, 0))

        texture = Texture()
        texture.load(image)
        return texture
def createPickingImage(size):
  ''' create a picking image with uniq colors for each point in the image
  '''
  image = PNMImage(*size)
  for x in xrange(size[0]):
    for y in xrange(size[1]):
      r = x % 256
      g = y % 256
      b = (x // 256) + (y//256) * 16
      image.setXelVal(x,y,r,g,b)
  
  # Reverse way is:
  #    tx = r + ((b%16)*256)
  #    ty = g + ((b//16)*256)
  imageFilename = 'data/textures/index-%i-%i.png' % (size[0], size[1])
  image.write(Filename(imageFilename))
def createPickingImage(size):
    ''' create a picking image with uniq colors for each point in the image
  '''
    image = PNMImage(*size)
    for x in xrange(size[0]):
        for y in xrange(size[1]):
            r = x % 256
            g = y % 256
            b = (x // 256) + (y // 256) * 16
            image.setXelVal(x, y, r, g, b)

    # Reverse way is:
    #    tx = r + ((b%16)*256)
    #    ty = g + ((b//16)*256)
    imageFilename = 'data/textures/index-%i-%i.png' % (size[0], size[1])
    image.write(Filename(imageFilename))
예제 #10
0
파일: map3d.py 프로젝트: viatoriche/suber
    def get_map_3d_tex(self, size, filename = None, charPos = None):
        """Generate texture of map
        """
        mod = self.world_size / size
        image = PNMImage(size, size)
        for x in xrange(size):
            for y in xrange(size):
                px = x * mod
                py = y * mod
                height = self[px, py]
                if height <= 0:
                    color = (abs(height) / 50) + 50
                    if color > 255:
                        color = 255
                    image.setPixel(x, y, (0, 0, 255-color))
                else:
                    if height <= self.config.low_mount_level[1]:
                        color = height / 20
                        r = 0
                        g = 50+color
                        b = 0
                        image.setPixel(x, y, (r, g, b))
                    elif height > self.config.low_mount_level[1]:
                        color = height / 50
                        r = color
                        g = color
                        b = color
                        if r > 255:
                            r = 255
                        if g > 255:
                            r = 255
                        if b > 255:
                            b = 255
                        image.setPixel(x, y, (r, g, b))

        if filename != None:
            image.write(filename)

        if charPos != None:
            charX, charY = charPos
            for x in xrange(-1, 2):
                for y in xrange(-1, 2):
                   image.setPixel(int(charX/mod)+x, int(charY/mod)+y, (255, 0, 0))

        texture = Texture()
        texture.load(image)
        return texture
예제 #11
0
	def setupHeightfield( self ):
		# Prep terrain textures
		#coverTextureFile = "data/textures/ground/green.jpg"
		#self.mCoverTexture = loader.loadTexture(coverTextureFile)
		
		# Setup heightfield
		self.mHeightFieldTesselator = HeightfieldTesselator("Heightfield")
		#fName = "data/textures/ground/heightfield.png"
		#self.mHeightFieldTesselator.setPolyCount(10000)
		#fileObj = Filename(fName)
		self.mTerrainVScale = self.mTerrainUScale = 1.0/1024.0
			
		myImage=PNMImage(256,256)
		myImage.makeGrayscale()
	
		p = Perlin(numberOfOctaves = 10, persistance = 0.65, smooth = False)
		for y in range(0,256):
			for x in range(0,256):
				i = p.noise2D(float(x)/256.0,float(y)/256.0)
				myImage.setGray(x, y, abs(i))
	
		bigImage=PNMImage(1024, 1024)
		bigImage.gaussianFilterFrom(1.0, myImage)
		fileObj = Filename("data/textures/ground/myHeightfield.png")
		bigImage.write(fileObj)
		#myTexture = Texture()
		#myTexture.load(bigImage)
		

		
		self.mHeightFieldTesselator.setHeightfield(fileObj)
		self.mTerrainHeight = MAPSIZE/10
		self.mHeightFieldTesselator.setVerticalScale(self.mTerrainHeight)
		self.mHorizontalScale = MAPSIZE/1024.0
		self.mHeightFieldTesselator.setHorizontalScale(self.mHorizontalScale)
		self.mHeightFieldNode = None

#		self.tex0 = loader.loadTexture( 'models/textures/ground/schachbrett.png' )
		self.tex0 = loader.loadTexture( 'data/textures/ground/mud-tile.png' )
		#self.tex1 = loader.loadTexture( 'data/models/textures/ground/green.jpg' )
		#self.tex2 = loader.loadTexture( 'data/models/textures/ground/grey-green-leaves.jpg' )

		#self.ts0 = TextureStage( 'dirt' )
		#self.ts1 = TextureStage( 'fungus' )
		#self.ts2 = TextureStage( 'grass' )
		
		self.updateHeightField()
class TerrainTile(GeoMipTerrain):
    """TerrainTiles are the building blocks of a terrain."""
    def __init__(self, terrain, x, y):
        """Builds a Tile for the terrain at input coordinates.

        Important settings are used directly from the terrain.
        This allows for easier setting changes, and reduces memory overhead.
        x and y parameters give the appropriate world coordinates of this tile.

        """

        self.terrain = terrain
        self.xOffset = x
        self.yOffset = y
        self.heightMapDetail = 1  # higher means greater detail

        self.name = "ID" + str(terrain.id) + "_X" + str(x) + "_Y" + str(y)
        GeoMipTerrain.__init__(self, name=self.name)

        self.image = PNMImage()

        #self.setAutoFlatten(GeoMipTerrain.AFMOff)
        self.setFocalPoint(self.terrain.focus)
        self.setAutoFlatten(GeoMipTerrain.AFMOff)
        self.getRoot().setPos(x, y, 0)
        if self.terrain.bruteForce:
            GeoMipTerrain.setBruteforce(self, True)
            GeoMipTerrain.setBlockSize(
                self, self.terrain.heightMapSize * self.heightMapDetail)
        else:
            GeoMipTerrain.setBlockSize(self, self.terrain.blockSize / 2)
            #self.setBorderStitching(1)
            self.setNear(self.terrain.near)
            self.setFar(self.terrain.far)

    def update(self):
        """Updates the GeoMip to use the correct LOD on each block."""

        #logging.info("TerrainTile.update()")
        GeoMipTerrain.update(self)

    @pstat
    def updateTask(self, task):
        """Updates the GeoMip to use the correct LOD on each block."""

        self.update()
        return task.again

    #@pstat
    def setHeightField(self, filename):
        """Set the GeoMip heightfield from a heightmap image."""

        GeoMipTerrain.setHeightfield(self, filename)

    @pstat
    def generate(self):
        GeoMipTerrain.generate(self)

    @pstat
    def setHeight(self):
        """Sets the height field to match the height map image."""

        self.setHeightField(self.image)

    @pstat
    def makeHeightMap(self):
        """Generate a new heightmap image.

        Panda3d GeoMipMaps require an image from which to build and update
        their height field. This function creates the correct image using the
        tile's position and the Terrain's getHeight() function.

        """

        if SAVED_HEIGHT_MAPS:
            fileName = "maps/height/" + self.name + ".png"
            self.getRoot().setTag('EditableTerrain', '1')
            if self.image.read(Filename(fileName)):
                logging.info("read heightmap from " + fileName)
                return

        heightMapSize = self.terrain.tileSize * self.heightMapDetail + 1
        self.image = PNMImage(heightMapSize, heightMapSize, 1, 65535)

        ySize = self.image.getYSize() - 1
        getHeight = self.terrain.getHeight
        setGray = self.image.setGray
        xo = self.xOffset
        yo = self.yOffset
        d = self.heightMapDetail

        for x in range(self.image.getXSize()):
            for y in range(ySize + 1):
                height = getHeight(x / d + xo, y / d + yo)
                #  feed pixel into image
                # why is it necessary to invert the y axis I wonder?
                setGray(x, ySize - y, height)
        #self.postProcessImage()
        if SAVED_HEIGHT_MAPS:
            fileName = "maps/height/" + self.name + ".png"
            logging.info("saving heightmap to " + fileName)
            self.image.write(Filename(fileName))

    def postProcessImage(self):
        """Perform filters and manipulations on the heightmap image."""

        #self.image.gaussianFilter()

    def setWireFrame(self, state):
        self.getRoot().setRenderModeWireframe()

    def makeSlopeMap(self):

        self.slopeMap = PNMImage()
        if SAVED_SLOPE_MAPS:
            fileName = "maps/slope/" + self.name + ".png"
            if self.slopeMap.read(Filename(fileName)):
                logging.info("read slopemap from " + fileName)
                return

        self.slopeMap = PNMImage(self.terrain.heightMapSize,
                                 self.terrain.heightMapSize)
        self.slopeMap.makeGrayscale()
        self.slopeMap.setMaxval(65535)

        size = self.slopeMap.getYSize()
        getNormal = self.getNormal
        setGray = self.slopeMap.setGray

        for x in range(size):
            for y in range(size):
                #note getNormal works at the same resolution as the heightmap
                normal = getNormal(x, y)
                #  feed pixel into image
                # why is it necessary to invert the y axis I wonder?
                #logging.info( normal)
                normal.z /= self.terrain.getSz()
                normal.normalize()
                slope = 1.0 - normal.dot(Vec3(0, 0, 1))
                setGray(x, y, slope)

        if SAVED_SLOPE_MAPS:
            fileName = "maps/slope/" + self.name + ".png"
            logging.info("saving slopemap to " + fileName)
            self.slopeMap.write(Filename(fileName))

    def createGroups(self):
        self.statics = self.getRoot().attachNewNode(self.name + "_statics")
        self.statics.setSz(1.0 / self.terrain.getSz())
        self.statics.setSx(1.0 / self.terrain.getSx())
        self.statics.setSy(1.0 / self.terrain.getSy())

        self.statics.setShaderAuto()

    @pstat
    def make(self):
        """Build a finished renderable heightMap."""

        # apply shader
        #logging.info( "applying shader")
        self.terrain.texturer.apply(self.getRoot())

        # detail settings
        #self.getRoot().setSx(1.0 / self.heightMapDetail)
        #self.getRoot().setSy(1.0 / self.heightMapDetail)

        #logging.info( "making height map")
        self.makeHeightMap()
        #logging.info( "setHeight()")
        self.setHeight()
        #self.getRoot().setSz(self.maxHeight)

        #http://www.panda3d.org/forums/viewtopic.php?t=12054
        self.calcAmbientOcclusion()
        #logging.info( "generate()")
        self.generate()
        self.getRoot().setCollideMask(BitMask32.bit(1))

        #self.makeSlopeMap()
        #logging.info( "createGroups()")
        self.createGroups()
        self.terrain.populator.populate(self)
예제 #13
0
class TerrainTile(GeoMipTerrain):
	"""TerrainTiles are the building blocks of a terrain."""
	
	def __init__(self, terrain, x, y):
		"""Builds a Tile for the terrain at input coordinates.
		
		Important settings are used directly from the terrain.
		This allows for easier setting changes and reduces memory overhead.
		x and y parameters give the appropriate world coordinates of this tile.
		
		"""
		
		self.terrain = terrain
		self.xOffset = x
		self.yOffset = y
		self.heightMapDetail = 1 # higher means greater detail
		
		self.name = "ID" + str(terrain.id) + "_X" + str(x) + "_Y" + str(y)
		GeoMipTerrain.__init(self, name=self.name)
		
		self.image = PNImage()
		
		#self.setAutoFlatten(GeoMipTerrain.AFMOff
		self.setFocalPoint(self.terrain.focus)
		self.setAutoFlatten(GeoMipTerrain.AFMOff)
		self.getRoot().setPos(x, y, 0)
		if self.terrain.bruteForce:
			GeoMipTerrain.setBruteForce(self, True)
			GeoMipTerrain.setBlockSize(self, self.terrain.heightMapSize * self.heightMapDetail)
		else:
			GeoMipTerrain.setBlockSize(self, self.terrain.blockSize/2)
			#self.setBorderStitching(1)
			self.setNear(self.terrain.near)
			self.setFar(self.terrain.far)
			
		
	def update(self):
		"""Updates the GeoMip to use the correct LOD on each block."""
		
		#logging.info("TerrainTile.update()")
		GeoMipTerrain.update(self)
		
	@pstat
	def updateTask(self, task):
		"""Updates the GeoMip to use the correct LOD on each block."""
		
		self.update()
		return task.again
		
	#@pstat
	def setHeightField(self, filename):
		"Set the GeoMip heightfield from a heightmap image."""
		
		GeoMipTerrain.setHeightfield(self, filename)
		
	@pstat
	def generate(self):
		GeoMipTerrain.generate(self)
		
	@pstat
	def setHeight(self):
		"""Sets the height field to match the height map image."""
		
		self.setHeightField(self.image)
		
	@pstat
	def makeHeightMap(self):
		"""Generate a new heightmap image.
		
		Panda3d GeoMipMaps require an image from which to build and update
        their height field. This function creates the correct image using the
        tile's position and the Terrain's getHeight() function.
		
		"""
		
		if SAVED_HEIGHT_MAPS:
			fileName = "maps/height/" + self.name + ".png"
			self.getRoot().setTag('EditableTerrain', '1')
			if self.image.read(Filename(fileName)):
				logging.info( "read heightmap from " + fileName)
				return
				
		heightMapSize = self.terrain.tileSize * self.heightMapDetail + 1
		self.image = PNMImage(heightMapSize, heightMapSize, 1, 65535)
		
		ySize = self.image.getYSize() - 1
		getHeight = self.terrain.getHeight
		setGray = self.image.setGray
		xo = self.xOffset
		yo = self.yOffset
		d = self.heightMapDetail
		
		for x in range(self.image.getXSize()):
			for y in range(ySize + 1):
				height = getHeight(x / d + xo, y / d + yo)
				# feed pixel into image
				# why is it necessary to invert the y axis I wonder?
				setGray(x, ySize - y, height)
		#self.postProcessImage()
		if SAVED_HEIGHT_MAPS:	
			fileName = "maps/height/" + self.name + ".png"
			logging.info( "saving heightmap to " + fileName)
			self.image.write(Filename(fileName))
			
	
	def postProcessImage(self):
		"""Perform filters and manipulations on the heightmap image."""
		
		#self.image.gaussianFilter()
		
	def setWireFrame(self, state):
		self.getRoot().setRenderModeWireframe()
		
	def makeSlopeMap(self):
		
		self.slopeMap = PNMImage()
		if SAVED_SLOPE_MAPS:
			fileName = "maps/slope/" + self.name + ".png"
			if self.slopeMap.read(Filename(fileName)):
				logging.info( "read slopemap from " + fileName)
				return
				
		self.slopeMap = PNMImage(self.terrain.heightMapSize, self.terrain.heightMapSize)
		self.slopeMap.makeGrayscale()
		self.slopeMap.setMaxval(65535)
		
		size = self.slopeMap.getYSize()
		getNormal = self.getNormal
		setGray = self.slopeMap.setGray
		
		for x in range(size):
			for y in range(size):
				#note getNormal works at the same resolution as the heightmap
				normal = getNormal(x, y)
				# feed pixel into image
				# why is it necessary to invert the y axis I wonder?
				#logging.info( normal)
				normal.z /= self.terrain.getSz()
				normal.normalize()
				slope = 1.0 - normal.dot(Vec3(0, 0, 1))
				setGray(x, y, slope)
				
		if SAVED_SLOPE_MAPS:
			fileName = "maps/slope/" + self.name + ".png"
			logging.info( "saving slopemap to " + fileName)
			self.slopeMap.write(Filename(fileName))
			
	def createGroups(self):
		self.statics = self.getRoot().attachNewNode(self.name + "_statics")
		self.statics.setSz(1.0 / self.terrain.getSz())
		self.statics.setSx(1.0 / self.terrain.getSz())
		self.statics.setSy(1.0 / self.terrain.getSy())
		
		self.statics.setShaderAuto()
		
	@pstat
	def make(self):
		"""Build a finished renderable heightMap."""
		
		# apply shader
		#logging.info( "applying shader")
		self.terrain.texturer.apply(self.getRoot())
		
		# detail settings
		#self.getRoot().setSz(1.0 / self.heightMapDetail)
		#self.getRoot().setSy(1.0 / self.heightMapDetail)
		
		#logging.info( "making height map")
		self.makeHeightMap()
		#logging.info( "setHeight()")
		self.setHeight()
		#self.getRoot().setSz(self.maxHeight)
		
		#http://www.panda3d.org/forums/viewtopic.php?=t=12054
		self.calcAmbientOcclusion()
		#loggin.info( "generate()")
		self.generate()
		self.getRoot().setCollideMask(BitMask32.bit(1))
		
		#self.makeSlopeMap()
		#logging.info( "createGroups()")
		self.createGroups()
		self.terrain.populator.populate(self)