def makeRenderState(material=None, diffuseTexture=None, normalTexture=None, glowTexture=None): n = NodePath("n") if not material: material = makeMaterial((0, 0, 0, 1), (1, 1, 1, 1), (0.01, 0.01, 0.01, 1), 1, (1, 1, 1, 1)) n.setMaterial(material) if diffuseTexture: tsDiffuse = TextureStage('diffuse') tsDiffuse.setMode(TextureStage.MModulate) n.setTexture(tsDiffuse, diffuseTexture) if glowTexture: tsGlow = TextureStage('glow') tsGlow.setMode(TextureStage.MGlow) n.setTexture(tsGlow, glowTexture) if normalTexture: tsNormal = TextureStage('normal') tsNormal.setMode(TextureStage.MNormal) n.setTexture(tsNormal, normalTexture) # weird bugs :| #n.setTransparency(True) #n.setColorOff() return n.getState()
def create_instance(self): self.create_buffer() # Water surface maker = CardMaker('water') maker.setFrame(self.x1, self.x2, self.y1, self.y2) self.waterNP = self.parent.instance.attachNewNode(maker.generate()) self.waterNP.setHpr(0, -90, 0) self.waterNP.setPos(0, 0, self.z) self.waterNP.setTransparency(TransparencyAttrib.MAlpha) self.waterNP.setShader(Shader.load(Shader.SL_GLSL, vertex=defaultDirContext.find_shader('water-vertex.glsl'), fragment=defaultDirContext.find_shader('water-fragment.glsl'))) self.waterNP.setShaderInput('wateranim', Vec4(0.03, -0.015, self.scale, 0)) # vx, vy, scale, skip # offset, strength, refraction factor (0=perfect mirror, 1=total refraction), refractivity self.waterNP.setShaderInput('waterdistort', Vec4(0.4, 4.0, 0.25, 0.45)) self.waterNP.setShaderInput('time', 0) # Reflection plane self.waterPlane = Plane(Vec3(0, 0, self.z + 1), Point3(0, 0, self.z)) planeNode = PlaneNode('waterPlane') planeNode.setPlane(self.waterPlane) # reflection texture, created in realtime by the 'water camera' tex0 = self.buffer.getTexture() tex0.setWrapU(Texture.WMClamp) tex0.setWrapV(Texture.WMClamp) ts0 = TextureStage('reflection') self.waterNP.setTexture(ts0, tex0) # distortion texture tex1 = loader.loadTexture('textures/water.png') ts1 = TextureStage('distortion') self.waterNP.setTexture(ts1, tex1) self.task = taskMgr.add(self.update, "waterTask")
def apply_splatted_textures(self, tile: NodePath, first_tex, second_tex, stencil_tex): # first = self.load("textures/sand_tex_1.png") # second = self.load("textures/grass_tex_1.png") # third = self.load("textures/water_tex_1.png") # stencil = self.load("textures/stencil_tex_1.png") # stencil_2 = self.load("textures/stencil_tex_2.png") # # normal = self.load("textures/sea-normal.jpg") # normal = self.loader.load_texture("textures/layingrock-n.jpg") # Apply the first texture. ts1 = TextureStage("stage-first") ts1.setSort(0) ts1.setMode(TextureStage.MReplace) ts1.setSavedResult(True) tile.setTexture(ts1, first_tex) # Apply the second texture. ts2 = TextureStage("stage-second") ts2.setSort(1) ts2.setMode(TextureStage.MReplace) tile.setTexture(ts2, second_tex) ts3 = TextureStage("stage-stencil") ts3.setSort(2) ts3.setCombineRgb(TextureStage.CMInterpolate, TextureStage.CSPrevious, TextureStage.COSrcColor, TextureStage.CSLastSavedResult, TextureStage.COSrcColor, TextureStage.CSTexture, TextureStage.COSrcColor) ts3.setSavedResult(True) tile.setTexture(ts3, stencil_tex)
def splatting(node, first, second, stencil, scale=None, offset=None): """Apply a texture splatting to the provided NodePath. """ # Apply the first texture. ts1 = TextureStage("stage-first") ts1.setSort(0) ts1.setMode(TextureStage.MReplace) ts1.setSavedResult(True) node.setTexture(ts1, first) # Apply the second texture. ts2 = TextureStage("stage-second") ts2.setSort(1) ts2.setMode(TextureStage.MReplace) node.setTexture(ts2, second) # Apply the stencil. ts3 = TextureStage("stage-stencil") ts3.setSort(2) ts3.setCombineRgb(TextureStage.CMInterpolate, TextureStage.CSPrevious, TextureStage.COSrcColor, TextureStage.CSLastSavedResult, TextureStage.COSrcColor, TextureStage.CSTexture, TextureStage.COSrcColor) node.setTexture(ts3, stencil) if scale: node.setTexScale(ts3, scale, scale) if offset is not None: node.setTexOffset(ts1, *offset) node.setTexOffset(ts2, *offset) node.setTexOffset(ts3, *offset)
def create_texture_stages(self): """ Create the texture stages: these are basically textures that you can apply to cards (sometimes mulitple textures at the same time -- is useful with masks). For more on texture stages: https://docs.panda3d.org/1.10/python/programming/texturing/multitexture-introduction """ #Binocular cards if self.current_stim_params['stim_type'] == 'b': #TEXTURE STAGES FOR LEFT CARD # Texture itself self.left_texture_stage = TextureStage('left_texture_stage') # Mask self.left_mask = Texture("left_mask_texture") self.left_mask.setup2dTexture(self.texture_size, self.texture_size, Texture.T_unsigned_byte, Texture.F_luminance) self.left_mask_stage = TextureStage('left_mask_array') #TEXTURE STAGES FOR RIGHT CARD self.right_texture_stage = TextureStage('right_texture_stage') #Mask self.right_mask = Texture("right_mask_texture") self.right_mask.setup2dTexture(self.texture_size, self.texture_size, Texture.T_unsigned_byte, Texture.F_luminance) self.right_mask_stage = TextureStage('right_mask_stage') # Tex card elif self.current_stim_params['stim_type'] == 's': self.texture_stage = TextureStage("texture_stage") return
def __init__(self, render, loader, location, sizeX, sizeY): self.water = loader.loadModel( 'assets/environment/arctic/nature/water.bam') self.water.setPos(location) self.water.setSx(sizeX) self.water.setSy(sizeY) self.newTS = TextureStage('ts') self.normal_TS = TextureStage('normal') self.normal_TS.setMode(TextureStage.MNormal) self.water.setTexture( self.newTS, loader.loadTexture( 'assets/environment/arctic/nature/textures/water_colormap.jpg') ) self.water.setTexScale(self.newTS, 80) self.water.setTexture( self.normal_TS, loader.loadTexture( 'assets/environment/arctic/nature/textures/water_normalmap.jpg' )) self.water.setTexScale(self.normal_TS, 80) self.water.setShaderAuto() ambiet = AmbientLight('ambient') ambiet.setColor((0.2, 0.2, 0.2, 1)) alight = self.water.attachNewNode(ambiet) self.water.setLight(alight) self.water.reparentTo(render) self.skybox = loader.loadModel( "assets/environment/arctic/nature/skybox.bam") self.skybox.setPos(location) self.skybox.setScale(2000)
def generateSurfaceTextures(self): # Textureize self.grassTexture = loader.loadTexture("Textures/grass.png") self.grassTS = TextureStage('grass') self.grassTS.setSort(1) self.rockTexture = loader.loadTexture("Textures/rock.jpg") self.rockTS = TextureStage('rock') self.rockTS.setSort(2) self.rockTS.setCombineRgb(TextureStage.CMAdd, TextureStage.CSLastSavedResult, TextureStage.COSrcColor, TextureStage.CSTexture, TextureStage.COSrcColor) self.sandTexture = loader.loadTexture("Textures/sand.jpg") self.sandTS = TextureStage('sand') self.sandTS.setSort(3) self.sandTS.setPriority(5) self.snowTexture = loader.loadTexture("Textures/ice.png") self.snowTS = TextureStage('snow') self.snowTS.setSort(4) self.snowTS.setPriority(0) # Grid for city placement and guide and stuff self.gridTexture = loader.loadTexture("Textures/grid.png") self.gridTexture.setWrapU(Texture.WMRepeat) self.gridTexture.setWrapV(Texture.WMRepeat) self.gridTS = TextureStage('grid') self.gridTS.setSort(5) self.gridTS.setPriority(10)
def __init__(self, block_index: int, pre_block_socket: BlockSocket, global_network: RoadNetwork, random_seed): super(Block, self).__init__(random_seed) # block information assert self.ID is not None, "Each Block must has its unique ID When define Block" assert self.SOCKET_NUM is not None, "The number of Socket should be specified when define a new block" if block_index == 0: from pgdrive.scene_creator.blocks import FirstBlock assert isinstance(self, FirstBlock), "only first block can use block index 0" elif block_index < 0: logging.debug("It is recommended that block index should > 1") self._block_name = str(block_index) + self.ID self.block_index = block_index self.number_of_sample_trial = 0 # each block contains its own road network and a global network self._global_network = global_network self.block_network = RoadNetwork() # used to spawn npc self._reborn_roads = [] # own sockets, one block derives from a socket, but will have more sockets to connect other blocks self._sockets = [] # used to connect previous blocks, save its info here self._pre_block_socket = pre_block_socket self.pre_block_socket_index = pre_block_socket.index # a bounding box used to improve efficiency x_min, x_max, y_min, y_max self.bounding_box = None # used to create this block, but for first block it is nonsense if block_index != 0: self.positive_lanes = self._pre_block_socket.positive_road.get_lanes(self._global_network) self.negative_lanes = self._pre_block_socket.negative_road.get_lanes(self._global_network) self.positive_lane_num = len(self.positive_lanes) self.negative_lane_num = len(self.negative_lanes) self.positive_basic_lane = self.positive_lanes[-1] # most right or outside lane is the basic lane self.negative_basic_lane = self.negative_lanes[-1] # most right or outside lane is the basic lane self.lane_width = self.positive_basic_lane.width_at(0) if self.render: # render pre-load self.road_texture = self.loader.loadTexture(AssetLoader.file_path("textures", "sci", "color.jpg")) self.road_texture.setMinfilter(SamplerState.FT_linear_mipmap_linear) self.road_texture.setAnisotropicDegree(8) self.road_normal = self.loader.loadTexture(AssetLoader.file_path("textures", "sci", "normal.jpg")) self.ts_color = TextureStage("color") self.ts_normal = TextureStage("normal") self.side_texture = self.loader.loadTexture(AssetLoader.file_path("textures", "side_walk", "color.png")) self.side_texture.setMinfilter(SamplerState.FT_linear_mipmap_linear) self.side_texture.setAnisotropicDegree(8) self.side_normal = self.loader.loadTexture(AssetLoader.file_path("textures", "side_walk", "normal.png")) self.side_walk = self.loader.loadModel(AssetLoader.file_path("models", "box.bam"))
def __init__(self): self.enabled = True sMgr = CIGlobals.getSettingsMgr() reso = sMgr.ReflectionQuality[sMgr.getSetting("refl").getValue()] if reso == 0: self.enabled = False return self.waterPlaneNP = None self.waterNodes = [] # Buffer and reflection camera buffer = base.win.makeTextureBuffer('waterBuffer', reso, reso) buffer.setClearColor(Vec4(0, 0, 0, 1)) cfa = CullFaceAttrib.makeReverse() rs = RenderState.make(cfa) self.watercamNP = base.makeCamera(buffer) self.watercamNP.reparentTo(render) self.makePlane(0.0) cam = self.watercamNP.node() cam.getLens().setFov(base.camLens.getFov()) cam.getLens().setNear(1) cam.getLens().setFar(5000) cam.setInitialState(rs) cam.setTagStateKey('Clipped') self.ts0 = TextureStage("tex_0") self.tex0 = buffer.getTexture() self.tex0.setWrapU(Texture.WMClamp) self.tex0.setWrapV(Texture.WMClamp) self.ts1 = TextureStage("tex_1") self.waterTex = loader.loadTexture('phase_3/maps/water_distort.png') self.waterQuad = None self.waterStage = TextureStage("waterStage") image0 = OnscreenImage(image=self.tex0, scale=0.3, pos=(-0.5, 0, 0.7)) image1 = OnscreenImage(image=waterTex, scale=0.3, pos=(0.5, 0, 0.7)) taskMgr.add(self.update, "waterTask")
def fillTextureStages(self, nodePath): """ Prepares all materials of a given nodepath to have at least the 4 default textures in the correct order: [diffuse, normal, specular, roughness] """ emptyDiffuseTex = loader.loadTexture("Data/Textures/EmptyDiffuseTexture.png") emptyNormalTex = loader.loadTexture("Data/Textures/EmptyNormalTexture.png") emptySpecularTex = loader.loadTexture("Data/Textures/EmptySpecularTexture.png") emptyRoughnessTex = loader.loadTexture("Data/Textures/EmptyRoughnessTexture.png") textureOrder = [emptyDiffuseTex, emptyNormalTex, emptySpecularTex, emptyRoughnessTex] textureSorts = [0, 10, 20, 30] # Prepare the textures for tex in textureOrder: tex.setMinfilter(SamplerState.FTLinear) tex.setMagfilter(SamplerState.FTLinear) tex.setFormat(Texture.FRgba) # Iterate over all geom nodes for np in nodePath.findAllMatches("**/+GeomNode"): # Check how many texture stages the nodepath already has stages = np.findAllTextureStages() numStages = len(stages) # Fill the texture stages up for i in xrange(numStages, 4): stage = TextureStage("DefaultTexStage" + str(i)) stage.setSort(textureSorts[i]) stage.setMode(TextureStage.CMModulate) stage.setColor(Vec4(0, 0, 0, 1)) np.setTexture(stage, textureOrder[i])
def apply_panda(self, shape, texture, texture_lod): texture_stage = TextureStage(shape.str_id() + self.__class__.__name__) self.init_texture_stage(texture_stage, texture) if self.tex_matrix: shape.set_texture_to_lod(self, texture_stage, texture_lod, self.source.is_patched()) if shape.swap_uv: shape.instance.setTexRotate(texture_stage, -90) scale = shape.instance.getTexScale(texture_stage) offset = shape.instance.getTexOffset(texture_stage) if shape.swap_uv: if shape.inv_v: scale.x = -scale.x else: offset.y += 1.0 if not shape.inv_u: scale.y = -scale.y offset.x += 1.0 else: if shape.inv_v: scale.y = -scale.y offset.y += 1.0 if shape.inv_u: scale.x = -scale.x offset.x += 1.0 shape.instance.setTexScale(texture_stage, scale) shape.instance.setTexOffset(texture_stage, offset) shape.instance.setTexture(texture_stage, texture, 1)
def __init__(self, texture_array, scale=0.2, window_size=512, texture_size=512): super().__init__() self.scale = scale self.current_scale = 1 self.texture_array = texture_array self.texture_dtype = type(self.texture_array.flat[0]) self.ndims = self.texture_array.ndim self.center_shift = TransformState.make_pos2d((-0.5, -0.5)) self.shift_back = TransformState.make_pos2d((0.5, 0.5)) #Create texture stage self.texture = Texture("Stimulus") self.texture.setup2dTexture(texture_size, texture_size, Texture.T_unsigned_byte, Texture.F_luminance) self.texture.setWrapU(Texture.WM_clamp) self.texture.setWrapV(Texture.WM_clamp) self.texture.setRamImageAs(self.texture_array, "L") self.textureStage = TextureStage("Stimulus") #Create scenegraph cm = CardMaker('card1') cm.setFrameFullscreenQuad() self.card1 = self.aspect2d.attachNewNode(cm.generate()) self.card1.setTexture(self.textureStage, self.texture) #ts, tx if self.scale != 0: self.taskMgr.add(self.scaleTextureTask, "scaleTextureTask")
def __init__(self, name, inclination, baseDimension): #public props self.baseDimension = baseDimension tex = loader.loadTexture(resourceManager.getResource(name) + '.png') xscaled = tex.getOrigFileXSize() / self.baseDimension yscaled = tex.getOrigFileYSize() / self.baseDimension cm = CardMaker("unscrollobject") cm.setFrame(0, xscaled, 0, yscaled) ts = TextureStage('ts') ts.setMode(TextureStage.MDecal) uvscroll = UvScrollNode("uvscrollnode", 1, 0.0, 0.0, 0.0) uvscroll.addChild(cm.generate()) self.node = NodePath(uvscroll) self.node.setTwoSided(True) self.node.setX((-xscaled / 2) + 0.5) self.node.setP(-(360 - int(inclination))) self.node.setTexture(tex) self.node.setTransparency(TransparencyAttrib.MAlpha) self.node.reparentTo(render)
def _gen_flowers(self, surf_mod, angle, side): """Generate texture flowers. Args: surf_mod (panda3d.core.NodePath): Surface model. angle (int): Surface model angle. side (str): Surface model side. """ for i in range(random.randint(0, 3)): ts = TextureStage("ts_flower{}".format(str(i))) ts.setMode(TextureStage.MDecal) tex = loader.loadTexture( # noqa: F821 "just_tex/flower{}.png".format(str(random.randint(1, 5)))) tex.setWrapU(Texture.WMClamp) tex.setWrapV(Texture.WMClamp) surf_mod.setTexture(ts, tex) surf_mod.setTexPos( ts, random.randint(*FLOWER_RANGES[(angle, side)]["u"]), random.randint(*FLOWER_RANGES[(angle, side)]["v"]), 0, ) surf_mod.setTexScale(ts, 20, 20)
def enable(self): camNode = Camera('shadowCam') camNode.setCameraMask(CIGlobals.ShadowCameraBitmask) self.shadowLens = OrthographicLens() self.shadowLens.setFilmSize(60 * 4, 60 * 4) camNode.setLens(self.shadowLens) self.shadowCamArm = camera.attachNewNode('shadowCamArm') self.shadowCam = self.shadowCamArm.attachNewNode(camNode) self.shadowCamArm.setPos(0, 40, 0) self.shadowCam.setPos(0, -40, 0) self.shadowTex = Texture('shadow') self.shadowTex.setBorderColor(self.clearColor) self.shadowTex.setWrapU(Texture.WMBorderColor) self.shadowTex.setWrapV(Texture.WMBorderColor) self.casterState = NodePath('temp') self.casterState.setColorScaleOff(10) self.casterState.setColor(self.shadowColor, self.shadowColor, self.shadowColor, 1, 10) self.casterState.setTextureOff(10) self.casterState.setLightOff(10) self.casterState.setFogOff(10) camNode.setInitialState(self.casterState.getState()) render.hide(CIGlobals.ShadowCameraBitmask) self.shadowStage = TextureStage('shadow') self.shadowStage.setSort(1000) self.turnOnShadows()
def makeTextureMap(self): '''Citymania function that generates and sets the 4 channel texture map''' self.colorTextures = [] for terrain in self.terrains: terrain.getRoot().clearTexture() heightmap = terrain.heightfield() colormap = PNMImage(heightmap.getXSize() - 1, heightmap.getYSize() - 1) colormap.addAlpha() slopemap = terrain.makeSlopeImage() for x in range(0, colormap.getXSize()): for y in range(0, colormap.getYSize()): # Else if statements used to make sure one channel is used per pixel # Also for some optimization # Snow. We do things funky here as alpha will be 1 already. if heightmap.getGrayVal(x, y) < 200: colormap.setAlpha(x, y, 0) else: colormap.setAlpha(x, y, 1) # Beach. Estimations from http://www.simtropolis.com/omnibus/index.cfm/Main.SimCity_4.Custom_Content.Custom_Terrains_and_Using_USGS_Data if heightmap.getGrayVal(x, y) < 62: colormap.setBlue(x, y, 1) # Rock elif slopemap.getGrayVal(x, y) > 170: colormap.setRed(x, y, 1) else: colormap.setGreen(x, y, 1) colorTexture = Texture() colorTexture.load(colormap) colorTS = TextureStage('color') colorTS.setSort(0) colorTS.setPriority(1) self.colorTextures.append((colorTexture, colorTS))
def setupTexture(self): """ This is the overlay/decal/etc. which contains the typed characters. The texture size and the font size are currently tied together. :return: """ self.texImage = PNMImage(1024, 1024) self.texImage.addAlpha() self.texImage.fill(1.0) self.texImage.alphaFill(1.0) self.tex = Texture('typing') self.tex.setMagfilter(Texture.FTLinear) self.tex.setMinfilter(Texture.FTLinear) self.typingStage = TextureStage('typing') self.typingStage.setMode(TextureStage.MModulate) self.tex.load(self.texImage) # ensure we can quickly update subimages self.tex.setKeepRamImage(True) # temp for drawing chars self.chImage = PNMImage(*self.fontCharSize)
def __init__(self, texture_cube, window_size=512, texture_size=512): super().__init__() self.cube_ind = 0 self.num_slices = texture_cube.shape[0] self.cube = texture_cube # SET Frame rate ShowBaseGlobal.globalClock.setMode(ClockObject.MLimited) ShowBaseGlobal.globalClock.setFrameRate(40) #can lock this at #Create texture stage self.texture = Texture("Stimulus") # self.texture.setMagfilter(SamplerState.FT_nearest) # self.texture.setMinfilter(SamplerState.FT_nearest) self.texture.setup2dTexture(texture_size, texture_size, Texture.T_unsigned_byte, Texture.F_luminance) self.texture.setRamImageAs(self.cube[0, :, :], "L") self.textureStage = TextureStage("Stimulus") #Create scenegraph cm = CardMaker('card1') cm.setFrameFullscreenQuad() self.card1 = self.aspect2d.attachNewNode(cm.generate()) self.card1.setTexture(self.textureStage, self.texture) #ts, tx ShowBaseGlobal.base.setFrameRateMeter(True) self.taskMgr.add(self.setTextureTask, "setTextureTask")
def makeSprite(name, texture, scale, add = False): from panda3d.core import (GeomVertexFormat, GeomVertexData, GeomEnums, InternalName, GeomVertexWriter, GeomPoints, Geom, GeomNode, NodePath, TextureStage, TexGenAttrib, BoundingSphere) format = GeomVertexFormat.getV3() data = GeomVertexData(name + "_data", format, GeomEnums.UHStatic) writer = GeomVertexWriter(data, InternalName.getVertex()) writer.addData3f((0, 0, 0)) primitive = GeomPoints(GeomEnums.UHStatic) primitive.addVertex(0) primitive.closePrimitive() geom = Geom(data) geom.addPrimitive(primitive) geomNode = GeomNode(name) geomNode.addGeom(geom) np = NodePath(geomNode) np.setLightOff(1) np.setMaterialOff(1) np.setRenderModePerspective(True) ts = TextureStage('sprite') if add: ts.setMode(TextureStage.MAdd) np.setTexture(ts, texture) np.setTexGen(ts, TexGenAttrib.MPointSprite) np.setDepthWrite(False) np.setDepthOffset(1) np.setTransparency(True) np.node().setBounds(BoundingSphere((0, 0, 0), 1)) np.node().setFinal(True) np.flattenStrong() np.setScale(scale) return np
def apply_panda(self, shape, texture, texture_lod): texture_stage = TextureStage(shape.str_id() + self.__class__.__name__) self.init_texture_stage(texture_stage, texture) if self.tex_matrix: shape.set_texture_to_lod(self, texture_stage, texture_lod, self.source.is_patched()) shape.instance.setTexture(texture_stage, texture, 1)
def loadFlatQuad(self, fullFilename): cm = CardMaker('cm-%s' % fullFilename) cm.setColor(1.0, 1.0, 1.0, 1.0) aspect = base.camLens.getAspectRatio() htmlWidth = 2.0 * aspect * WEB_WIDTH_PIXELS / float(WIN_WIDTH) htmlHeight = 2.0 * float(WEB_HEIGHT_PIXELS) / float(WIN_HEIGHT) cm.setFrame(-htmlWidth / 2.0, htmlWidth / 2.0, -htmlHeight / 2.0, htmlHeight / 2.0) bottomRightX = WEB_WIDTH_PIXELS / float(WEB_WIDTH + 1) bottomRightY = WEB_HEIGHT_PIXELS / float(WEB_HEIGHT + 1) cm.setUvRange(Point2(0, 1 - bottomRightY), Point2(bottomRightX, 1)) card = cm.generate() quad = NodePath(card) jpgFile = PNMImage(WEB_WIDTH, WEB_HEIGHT) smallerJpgFile = PNMImage() readFile = smallerJpgFile.read(Filename(fullFilename)) if readFile: jpgFile.copySubImage(smallerJpgFile, 0, 0) guiTex = Texture('guiTex') guiTex.setupTexture(Texture.TT2dTexture, WEB_WIDTH, WEB_HEIGHT, 1, Texture.TUnsignedByte, Texture.FRgba) guiTex.setMinfilter(Texture.FTLinear) guiTex.load(jpgFile) guiTex.setWrapU(Texture.WMClamp) guiTex.setWrapV(Texture.WMClamp) ts = TextureStage('webTS') quad.setTexture(ts, guiTex) quad.setTransparency(0) quad.setTwoSided(True) quad.setColor(1.0, 1.0, 1.0, 1.0) result = quad else: result = None Texture.setTexturesPower2(1) return result
def setupTexture(self): cm = CardMaker('quadMaker') cm.setColor(1.0, 1.0, 1.0, 1.0) aspect = base.camLens.getAspectRatio() htmlWidth = 2.0 * aspect * WEB_WIDTH_PIXELS / float(WIN_WIDTH) htmlHeight = 2.0 * float(WEB_HEIGHT_PIXELS) / float(WIN_HEIGHT) cm.setFrame(-htmlWidth / 2.0, htmlWidth / 2.0, -htmlHeight / 2.0, htmlHeight / 2.0) bottomRightX = WEB_WIDTH_PIXELS / float(WEB_WIDTH + 1) bottomRightY = WEB_HEIGHT_PIXELS / float(WEB_HEIGHT + 1) cm.setUvRange(Point2(0, 1 - bottomRightY), Point2(bottomRightX, 1)) card = cm.generate() self.quad = NodePath(card) self.quad.reparentTo(self.parent_) self.guiTex = Texture('guiTex') self.guiTex.setupTexture(Texture.TT2dTexture, WEB_WIDTH, WEB_HEIGHT, 1, Texture.TUnsignedByte, Texture.FRgba) self.guiTex.setMinfilter(Texture.FTLinear) self.guiTex.setKeepRamImage(True) self.guiTex.makeRamImage() self.guiTex.setWrapU(Texture.WMRepeat) self.guiTex.setWrapV(Texture.WMRepeat) ts = TextureStage('webTS') self.quad.setTexture(ts, self.guiTex) self.quad.setTexScale(ts, 1.0, -1.0) self.quad.setTransparency(0) self.quad.setTwoSided(True) self.quad.setColor(1.0, 1.0, 1.0, 1.0) self.calcMouseLimits()
def applySettings(self, jsonfile): if not jsonfile: raise IOError('no file specified!') info = open(jsonfile, 'r') jsonInfo = json.load(info) settings = jsonInfo['settings'] width, height = settings['resolution'] fs = settings['fullscreen'] music = settings['music'] sfx = settings['sfx'] tex_detail = settings['texture-detail'] model_detail = settings['model-detail'] aa = settings['aa'] af = settings.get('af', None) if af == None: self.writeSettingToFile('af', 'off', 'settings.json') base.enableMusic(music) base.enableSoundEffects(sfx) if aa == 'on': render.set_antialias(AntialiasAttrib.MMultisample) aspect2d.set_antialias(AntialiasAttrib.MMultisample) else: render.clear_antialias() ts = TextureStage('ts') if tex_detail == 'high': pass else: if tex_detail == 'low': loadPrcFileData('', 'compressed-textures 1') wp = WindowProperties() wp.setSize(width, height) wp.setFullscreen(fs) base.win.requestProperties(wp) info.close() return
def generateSurfaceTextures(self): # Textureize self.grassTexture = loader.loadTexture("Entities/Maps/grassy2.png") self.grassTexture.setWrapU(Texture.WMRepeat) self.grassTexture.setWrapV(Texture.WMRepeat) self.grassTexture.setMinfilter(SamplerState.FT_linear_mipmap_linear) self.grassTexture.setAnisotropicDegree(8) self.grassTS = TextureStage('grass') self.grassTS.setSort( 1) # sorting order is relevent for assigning textures to the four self.rockTexture = loader.loadTexture("Entities/Maps/simple.jpg") self.rockTexture.setWrapU(Texture.WMRepeat) self.rockTexture.setWrapV(Texture.WMRepeat) self.rockTexture.setMinfilter(SamplerState.FT_linear_mipmap_linear) #self.grassTexture.setAnisotropicDegree(8) self.rockTS = TextureStage('rock') self.rockTS.setSort(2) # self.rockTS.setCombineRgb(TextureStage.CMAdd, TextureStage.CSLastSavedResult, TextureStage.COSrcColor, TextureStage.CSTexture, TextureStage.COSrcColor) self.sandTexture = loader.loadTexture("Entities/Maps/stars.png") self.sandTexture.setWrapU(Texture.WMRepeat) self.sandTexture.setWrapV(Texture.WMRepeat) self.sandTexture.setMinfilter(SamplerState.FT_linear_mipmap_linear) #self.sandTexture.setAnisotropicDegree(8) self.sandTS = TextureStage('sand') self.sandTS.setSort(3) self.sandTS.setPriority(5) # TODO: figure out what this is for... self.snowTexture = loader.loadTexture("Entities/Maps/grass.png") self.snowTexture.setWrapU(Texture.WMRepeat) self.snowTexture.setWrapV(Texture.WMRepeat) self.snowTexture.setMinfilter(SamplerState.FT_linear_mipmap_linear) #self.snowTexture.setAnisotropicDegree(8) self.snowTS = TextureStage('snow') self.snowTS.setSort(4) self.snowTS.setPriority(0) # a background (or rather freground?) texture that will be present independently from the blend map (consider removal) self.overlayTexture = loader.loadTexture("Entities/Maps/heightmap.png") self.overlayTexture.setWrapU(Texture.WMRepeat) self.overlayTexture.setWrapV(Texture.WMRepeat) self.overlayTexture.setMinfilter(SamplerState.FT_linear_mipmap_linear) #self.overlayTexture.setAnisotropicDegree(8) self.overlayTS = TextureStage('overlay') self.overlayTS.setSort(5) self.overlayTS.setPriority(10)
def __init__(self, block_index: int, global_network: RoadNetwork, random_seed, ignore_intersection_checking=False): super(BaseBlock, self).__init__(str(block_index) + self.ID, random_seed, escape_random_seed_assertion=True) # block information assert self.ID is not None, "Each Block must has its unique ID When define Block" assert len(self.ID) == 1, "Block ID must be a character " self.block_index = block_index self.ignore_intersection_checking = ignore_intersection_checking # each block contains its own road network and a global network self._global_network = global_network self.block_network = RoadNetwork() # a bounding box used to improve efficiency x_min, x_max, y_min, y_max self.bounding_box = None # used to spawn npc self._respawn_roads = [] self._block_objects = None if self.render: # render pre-load self.road_texture = self.loader.loadTexture( AssetLoader.file_path("textures", "sci", "color.jpg")) self.road_texture.setMinfilter( SamplerState.FT_linear_mipmap_linear) self.road_texture.setAnisotropicDegree(8) self.road_normal = self.loader.loadTexture( AssetLoader.file_path("textures", "sci", "normal.jpg")) self.ts_color = TextureStage("color") self.ts_normal = TextureStage("normal") self.side_texture = self.loader.loadTexture( AssetLoader.file_path("textures", "sidewalk", "color.png")) self.side_texture.setMinfilter( SamplerState.FT_linear_mipmap_linear) self.side_texture.setAnisotropicDegree(8) self.side_normal = self.loader.loadTexture( AssetLoader.file_path("textures", "sidewalk", "normal.png")) self.sidewalk = self.loader.loadModel( AssetLoader.file_path("models", "box.bam"))
def __init__(self, rgb=(0, 0, 0), tex_name="rgb"): self.rgb = rgb self.texture_array = rgb_texture(rgb=self.rgb) self.texture = Texture(tex_name) self.texture.setup2dTexture(512, 512, Texture.T_unsigned_byte, Texture.F_rgb8) self.texture.setRamImageAs(self.texture_array, "RGB") self.texture_stage = TextureStage(tex_name)
def __init__(self): fn = Filename.fromOsSpecific(self.filepath) self.terrain = GeoMipTerrain("mySimpleTerrain") self.terrain.setHeightfield("Entities/Maps/heightmap.png") self.terrain.getRoot().setSz(40) #terrain.setBruteforce(True) self.terrain.getRoot().reparentTo(render) # Set terrain properties self.terrain.setBlockSize(16) self.terrain.setNear(500) self.terrain.setFar(100) self.terrain.setFocalPoint(base.camera) # Store the root NodePath for convenience root = self.terrain.getRoot() root.reparentTo(render) # some tinkering """ # tell renderer to repeat texture when reading over the edge. texGrass.setWrapU(Texture.WM_repeat) texGrass.setWrapV(Texture.WM_repeat) # apply mipmapping: tell renderer how to handle multiple texture pixels being rendered t a single screen pixel (makes textures 30% larger in GPU mem.) texGrass.setMinfilter(SamplerState.FT_linear_mipmap_linear) """ self.terrain.generate() """ new attempt to include blend mapping: """ # determine terrain size self.heightmap = self.terrain.heightfield() if self.heightmap.getXSize() > self.heightmap.getYSize(): self.size = self.heightmap.getXSize() - 1 else: self.size = self.heightmap.getYSize() - 1 self.xsize = self.heightmap.getXSize() - 1 self.ysize = self.heightmap.getYSize() - 1 # Set multi texture # Source http://www.panda3d.org/phpbb2/viewtopic.php?t=4536 self.generateSurfaceTextures() # load a blend texture from file: self.blendTexture = loader.loadTexture("Entities/Maps/blendMap.png") self.blendTS = TextureStage('blend') self.blendTS.setSort(0) self.blendTS.setPriority(1) # apply textures to the terrain and connect custom shader for blend mapping: self.setSurfaceTextures() # Add a task to keep updating the terrain (for changing terrain, or synamic resolution) def updateTask(task): self.terrain.update() return task.cont taskMgr.add(updateTask, "update")
def apply(self, instance): if self.texture is None: if self.image is None: self.image = self.generate() self.texture = Texture() self.texture.load(self.image) instance.setTexGen(TextureStage.getDefault(), TexGenAttrib.MPointSprite) instance.setTransparency(TransparencyAttrib.MAlpha, 1) instance.setTexture(TextureStage('ts'), self.texture, 1)
def applyNoGlow(np): global NoGlowTS global NoGlowTex if not NoGlowTS: NoGlowTS = TextureStage('noglow') NoGlowTS.setMode(TextureStage.MGlow) if not NoGlowTex: NoGlowTex = loader.loadTexture("phase_3/maps/black.png") np.setTexture(NoGlowTS, NoGlowTex)
def __init__(self, texture_array, scale=0.2, window_size=512, texture_size=512): super().__init__() self.scale = scale self.texture_array = texture_array self.texture_dtype = type(self.texture_array.flat[0]) self.ndims = self.texture_array.ndim #Set window title self.window_properties = WindowProperties() self.window_properties.setSize(window_size, window_size) self.window_properties.setTitle("FullFieldDrift") ShowBaseGlobal.base.win.requestProperties(self.window_properties) #Create texture stage self.texture = Texture("Stimulus") #Select Texture ComponentType (e.g., uint8 or whatever) if self.texture_dtype == np.uint8: self.texture_component_type = Texture.T_unsigned_byte elif self.texture_dtype == np.uint16: self.texture_component_type = Texture.T_unsigned_short #Select Texture Format (color or b/w etc) if self.ndims == 2: self.texture_format = Texture.F_luminance #grayscale self.texture.setup2dTexture(texture_size, texture_size, self.texture_component_type, self.texture_format) self.texture.setRamImageAs(self.texture_array, "L") elif self.ndims == 3: self.texture_format = Texture.F_rgb8 self.texture.setup2dTexture(texture_size, texture_size, self.texture_component_type, self.texture_format) self.texture.setRamImageAs(self.texture_array, "RGB") else: raise ValueError("Texture needs to be 2d or 3d") self.textureStage = TextureStage("Stimulus") #Create scenegraph cm = CardMaker('card') cm.setFrameFullscreenQuad() self.card = self.aspect2d.attachNewNode(cm.generate()) self.card.setTexture(self.textureStage, self.texture) #ts, tx #Set the scale on the card (note this is different from scaling the texture) self.card.setScale(np.sqrt(2)) if self.scale != 0: #Add task to taskmgr to translate texture self.taskMgr.add(self.scaleTextureTask, "scaleTextureTask")