def setup(cls, loader): cls.noisetex = loader.load3DTexture("texture/noise/fbm_###.tif") cls.noisestage = TextureStage('noise') cls.layer1stage = TextureStage('layer1') cls.layer2stage = TextureStage('layer2') cls.layer3stage = TextureStage('layer3') cls.layer4stage = TextureStage('layer4') cls.texture_sets = {} layernames = ["layer1", "layer2", "layer3", "layer4"] stages = [ cls.layer1stage, cls.layer2stage, cls.layer3stage, cls.layer4stage ] texture_files = os.listdir("texture/planet/layers/") for filename in texture_files: name, ext = os.path.splitext(filename) if name.endswith("layer1"): paths = [ "texture/planet/layers/" + filename.replace("layer1", layer) for layer in layernames ] if all(os.path.exists(path) for path in paths): setname = name.replace("layer1", "").strip("_") texture_set = [(cls.noisestage, cls.noisetex)] for stage, path in zip(stages, paths): tex = loader.loadTexture(path) tex.setWrapU(Texture.WMClamp) tex.setWrapV(Texture.WMClamp) texture_set.append((stage, tex)) cls.texture_sets[setname] = texture_set cls.ready = True
def render(self): LOG.debug("[SkyBox] Rendering") # If we are an orphan use render if self.parent is None: self.parent = render #LOG.debug("[SkyBox] model=%s"%self.modelFile) self.node = loader.loadModel(self.modelFile) #print("tf1 = %s, tf2 = %s"%(self.texture1File,self.texture2File)) if self.texture1File != '' and self.texture2File == '': #LOG.debug("[SkyBox] single texture = %s"%self.texture1File) t = loader.loadTexture(self.texture1File) self.node.setTexture(t) elif self.texture1File != '' and self.texture2File != '': #LOG.debug("[SkyBox] texture staging 1 = %s, 2 = %s"%(self.texture1File,self.texture2File)) t1 = loader.loadTexture(self.texture1File) t1.setWrapU(Texture.WMClamp) t1.setWrapV(Texture.WMClamp) ts1 = TextureStage('Space') ts1.setSort(self.texture1Sort) t2 = loader.loadTexture(self.texture2File) t2.setWrapU(Texture.WMClamp) t2.setWrapV(Texture.WMClamp) ts2 = TextureStage('SpaceClouds') ts2.setSort(self.texture2Sort) self.node.setTexture(ts1, t1) self.node.setTexture(ts2, t2) if self.shaderFile: LOG.debug("[SkyBox] shader = %s" % self.shaderFile) #skyShader = Shader.load("./data/shaders/%s"%self.shaderFile) skyShader = Shader.load("%s" % self.shaderFile) self.node.setShader(skyShader) # Should this be scaled here or done to the model? # It doesn't look like scaling the objects looks any different. self.node.setScale(280) # make sure it's drawn first (this can be done with shaders?) self.node.setBin('background', 0) # dont set depth attribute when rendering the sky (this can be done with shaders?) self.node.setAttrib(DepthWriteAttrib.make(DepthWriteAttrib.MOff)) # We don't want shadows on the skybox self.node.setLightOff() # Render self.node.reparentTo(self.parent) taskMgr.add(self.moveSkyTask, "Move the sky box with the cam")
def __init__(self, x1, y1, x2, y2, z): Att_base.__init__(self, False, "Water1") # Water surface maker = CardMaker( 'water' ) maker.setFrame( x1, x2, y1, y2 ) self.waterNP = render.attachNewNode(maker.generate()) self.waterNP.setHpr(0,-90,0) self.waterNP.setPos(0,0,z) self.waterNP.setTransparency(TransparencyAttrib.MAlpha ) self.waterNP.setShader(loader.loadShader( 'Shaders/water1.sha' )) # Reflection plane self.waterPlane = Plane( Vec3( 0, 0, z+1 ), Point3( 0, 0, z ) ) planeNode = PlaneNode( 'waterPlane' ) planeNode.setPlane( self.waterPlane ) # Buffer and reflection camera self.buffer = base.win.makeTextureBuffer( 'waterBuffer', 512, 512 ) self.buffer.setClearColor( Vec4( 0, 0, 0, 1 ) ) cfa = CullFaceAttrib.makeReverse( ) rs = RenderState.make(cfa) self.watercamNP = base.makeCamera( self.buffer ) self.watercamNP.reparentTo(render) sa = ShaderAttrib.make() sa = sa.setShader(loader.loadShader('Shaders/splut3Clipped.sha') ) self.cam = self.watercamNP.node() self.cam.getLens( ).setFov( base.camLens.getFov( ) ) self.cam.getLens().setNear(1) self.cam.getLens().setFar(5000) self.cam.setInitialState( rs ) self.cam.setTagStateKey('Clipped') self.cam.setTagState('True', RenderState.make(sa)) # ---- water textures --------------------------------------------- # 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)
def set_leaf_tex(self, leaf_tex): if leaf_tex != None: ts = TextureStage('ts') for leaf in self.leafs: leaf.setTexture(ts, leaf_tex) leaf.setTexScale(ts, 10, 10) leaf.setTransparency(TransparencyAttrib.MAlpha)
def __init__(self, scene, dynamic=True, rate=Vec4(0.004, 0.002, 0.008, 0.010), skycolor=Vec4(0.25, 0.5, 1, 0), texturescale=Vec4(1, 1, 1, 1), scale=(4000, 4000, 1000), texturefile=None): Att_base.__init__(self, False, "Sky Dome 2") self.skybox = loader.loadModel("./media/models/dome2") self.skybox.reparentTo(scene) self.skybox.setScale(scale[0], scale[1], scale[2]) self.skybox.setLightOff() if texturefile == None: texturefile = "./media/textures/clouds_bw.png" texture = loader.loadTexture(texturefile) self.textureStage0 = TextureStage("stage0") self.textureStage0.setMode(TextureStage.MReplace) self.skybox.setTexture(self.textureStage0, texture, 1) #self.skybox.setTexScale(self.textureStage0, texturescale[0], texturescale[1]) self.rate = rate self.textureScale = texturescale self.skycolor = skycolor self.dynamic = dynamic if self.dynamic: self.skybox.setShader( loader.loadShader('./media/shaders/skydome2.sha')) self.setShaderInput()
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 setupRightTexture(self): cm = CardMaker('quadMaker') cm.setColor(1.0, 1.0, 1.0, 1.0) aspect = base.camLens.getAspectRatio() htmlWidth = 2.0 * aspect * WEB_WIDTH / float(WIN_WIDTH) htmlHeight = 2.0 * float(WEB_HEIGHT) / float(WIN_HEIGHT) # the html area will be center aligned and vertically top aligned #cm.setFrame(-htmlWidth/2.0, htmlWidth/2.0, 1.0 - htmlHeight, 1.0) cm.setFrame(0, htmlWidth / 2.0, -htmlHeight / 2.0, htmlHeight / 2.0) card = cm.generate() self.rightQuad = NodePath(card) self.rightQuad.reparentTo(self.parent) self.rightGuiTex = Texture("guiTex") self.rightGuiTex.setupTexture(Texture.TT2dTexture, WEB_HALF_WIDTH, WEB_HEIGHT, 1, Texture.TUnsignedByte, Texture.FRgba) self.rightGuiTex.setKeepRamImage(True) self.rightGuiTex.makeRamImage() self.rightGuiTex.setWrapU(Texture.WMClamp) self.rightGuiTex.setWrapV(Texture.WMClamp) ts = TextureStage('rightWebTS') self.rightQuad.setTexture(ts, self.rightGuiTex) self.rightQuad.setTexScale(ts, 1.0, -1.0) self.rightQuad.setTransparency(0) self.rightQuad.setTwoSided(True) self.rightQuad.setColor(1.0, 1.0, 1.0, 1.0)
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 loadDetail(self): self.detailTS = TextureStage('ts') tex = self.loadTexture("Detail_COLOR.jpg") tex.setWrapU(Texture.WMMirror) tex.setWrapV(Texture.WMMirror) self.detailTexture = tex self.textureBlendMode = self.detailTS.MHeight self.detailTS.setMode(self.textureBlendMode)
def load(self): """single texture""" self.ts = TextureStage('ts') tex = self.loadTexture("rock.jpg") tex.setWrapU(Texture.WMMirror) tex.setWrapV(Texture.WMMirror) self.monoTexture = tex
def load(self): self.ts1 = TextureStage('ts2') tex = self.loadTexture("snow.jpg") tex.setWrapU(Texture.WMMirror) tex.setWrapV(Texture.WMMirror) self.monoTexture = tex self.loadDetail()
def __init__(self, phasedLoading = False): self.wantProws = config.GetBool('want-sprits', 0) self.hulls = { } self.texInfo = ({ }, { }, { }) self.models = { } self.mastSets = { } ShipBlueprints.setupWheel() ShipBlueprints.setupShipTextures() self.preprocessMast(ShipGlobals.Masts.Main_Tri) self.preprocessMast(ShipGlobals.Masts.Fore_Tri) self.preprocessHull(ShipGlobals.INTERCEPTORL1) self.preprocessMast(ShipGlobals.Masts.Skel_Main_A) self.preprocessMast(ShipGlobals.Masts.Skel_Main_B) self.preprocessMast(ShipGlobals.Masts.Skel_Tri) self.preprocessMast(ShipGlobals.Masts.Skel_Fore) self.preprocessMast(ShipGlobals.Masts.Skel_Aft) self.preprocessHull(ShipGlobals.SKEL_INTERCEPTORL3) self.preprocessHull(ShipGlobals.SKEL_WARSHIPL3) if not phasedLoading: self.handlePhase4() self.handlePhase5() self.baseLayer = TextureStage('base') self.colorLayer = TextureStage('color') self.logoLayer = TextureStage('logo') self.logoLayerNoColor = TextureStage('logoNoColor') self.vertLayer = TextureStage('vertex') self.colorLayer.setSort(1) self.colorLayer.setCombineRgb(TextureStage.CMReplace, TextureStage.CSTexture, TextureStage.COSrcColor) self.colorLayer.setCombineAlpha(TextureStage.CMReplace, TextureStage.CSTexture, TextureStage.COSrcAlpha) self.colorLayer.setTexcoordName('uvColor') self.logoLayer.setSort(2) self.logoLayer.setCombineRgb(TextureStage.CMInterpolate, TextureStage.CSTexture, TextureStage.COSrcColor, TextureStage.CSPrevious, TextureStage.COSrcColor, TextureStage.CSTexture, TextureStage.COSrcAlpha) self.logoLayer.setCombineAlpha(TextureStage.CMReplace, TextureStage.CSPrevious, TextureStage.COSrcAlpha) self.logoLayer.setTexcoordName('uvLogo') self.logoLayerNoColor.setSort(2) self.logoLayerNoColor.setCombineRgb(TextureStage.CMInterpolate, TextureStage.CSTexture, TextureStage.COSrcColor, TextureStage.CSConstant, TextureStage.COSrcColor, TextureStage.CSTexture, TextureStage.COSrcAlpha) self.logoLayerNoColor.setCombineAlpha(TextureStage.CMReplace, TextureStage.CSPrevious, TextureStage.COSrcAlpha) self.logoLayerNoColor.setTexcoordName('uvLogo') self.logoLayerNoColor.setColor((1, 1, 1, 1)) self.vertLayer.setSort(3) self.vertLayer.setCombineRgb(TextureStage.CMModulate, TextureStage.CSPrevious, TextureStage.COSrcColor, TextureStage.CSPrimaryColor, TextureStage.COSrcColor) self.vertLayer.setCombineAlpha(TextureStage.CMReplace, TextureStage.CSPrimaryColor, TextureStage.COSrcAlpha) self.baseLayer.setSort(4) self.baseLayer.setCombineRgb(TextureStage.CMModulate, TextureStage.CSTexture, TextureStage.COSrcColor, TextureStage.CSPrevious, TextureStage.COSrcColor) self.baseLayer.setCombineAlpha(TextureStage.CMModulate, TextureStage.CSTexture, TextureStage.COSrcAlpha, TextureStage.CSPrevious, TextureStage.COSrcAlpha)
def loadFlatQuad(self, fullFilename): """Load the flat jpg into a quad.""" assert self.notify.debugStateCall(self) #Texture.setTexturesPower2(AutoTextureScale.ATSUp) #Texture.setTexturesPower2(2) 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) # the html area will be center aligned and vertically top aligned #cm.setFrame(-htmlWidth/2.0, htmlWidth/2.0, 1.0 - htmlHeight, 1.0) 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,0), Point2(bottomRightX, bottomRightY)) cm.setUvRange(Point2(0,1-bottomRightY), Point2(bottomRightX,1)) card = cm.generate() quad = NodePath(card) #quad.reparentTo(self.parent) 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.setKeepRamImage(True) #guiTex.makeRamImage() guiTex.setWrapU(Texture.WMClamp) guiTex.setWrapV(Texture.WMClamp) ts = TextureStage('webTS') quad.setTexture(ts, guiTex) #quad.setTexScale(ts, 1.0, -1.0) quad.setTransparency(0) quad.setTwoSided(True) quad.setColor(1.0, 1.0, 1.0, 1.0) result= quad else: # if we have an error loading the file, return None to signify an error result = None #Texture.setTexturesPower2(AutoTextureScale.ATSDown) Texture.setTexturesPower2(1) return result
def loadAndSetCubeTexture2(self, nodePath1, nodePath2, fileName, textureStageName, texCoordName, sort): #load texture from file texture = loader.loadCubeMap(fileName) #set texture stage textureStage = TextureStage(textureStageName) textureStage.setTexcoordName(texCoordName) textureStage.setSort(sort) #set texture and texture stage nodePath1.setTexture(textureStage, texture) nodePath2.setTexture(textureStage, texture)
def setup(cls, loader): cls.noisetex = loader.load3DTexture("texture/noise/fbm_###.tif") cls.noisestage = TextureStage('noise') cls.layer1stage = TextureStage('layer1') cls.layer2stage = TextureStage('layer2') cls.layer3stage = TextureStage('layer3') cls.layer4stage = TextureStage('layer4') stages = [ cls.layer1stage, cls.layer2stage, cls.layer3stage, cls.layer4stage ] texture_files = os.listdir("texture/") paths = glob.glob("texture/star/layers/*.tif") paths.sort() cls.texture_set = [(cls.noisestage, cls.noisetex)] for stage, path in zip(stages, paths): tex = loader.loadTexture(path) tex.setWrapU(Texture.WMClamp) tex.setWrapV(Texture.WMClamp) cls.texture_set.append((stage, tex)) cls.ready = True
def loadAndSetTexture(self, nodePath, fileName, textureStageName, texCoordName, sort): #load texture from file texture = loader.loadTexture(fileName) texture.setWrapU(Texture.WMClamp) texture.setWrapV(Texture.WMClamp) #set texture stage textureStage = TextureStage(textureStageName) textureStage.setTexcoordName(texCoordName) textureStage.setSort(sort) #set texture and texture stage nodePath.setTexture(textureStage, texture)
def AddNewTextureStage(self, type=Texture.TT2dTexture): """Adds a new texture input to Fragment and returns a two-tuple with the texnum and new TextureStage.""" ts = TextureStage("tex_%d" % self.__curTex) if type == Texture.TT1dTexture: type = "sampler1D" elif type == Texture.TT2dTexture: type = "sampler2D" elif type == Texture.TT3dTexture: type = "sampler2D" elif type == Texture.TTCubeMap: type = "samplerCUBE" if not (isinstance(type, str) and type.startswith("sampler")): raise TypeError, "Unknown texture type %s!" % str(type) self.AddInput("tex_%d" % self.__curTex, "uniform " + type, "TEXUNIT%d" % self.__curTex) self.__curTex += 1 ts.setSort(self.__curTex) return self.__curTex - 1, ts
def __init__(self, speed, raws, cells, tex): self.timer = 0 self.offsetV = 0 self.offsetU = 0 self.u = 0 self.v = 0 self.speed = speed self.raws = raws self.sizeRAWS = 1.00 / self.raws self.cells = cells self.sizeCELLS = 1.00 / self.cells self.ts = TextureStage('ts') self.tile = self.createCARD(tex, self.sizeCELLS, self.sizeRAWS) taskMgr.add(self.anim, "anim")
def Texture(self): """Applies textures and if needed shaders to the terrain. Call this initially, and whenever you have changed the size of some important textures, or added/removed some textures or changed the lighting mode. This function is automatically called by Initialize().""" if self.TextureMap == "": self.TextureMap = None if self.LightMap == "": self.LightMap = None # Does it have a detail map? if len(self.AlphaMaps) > 0: self._textureDetailed() elif self.TextureMap != None: self.Root.setTexture(self.TextureMap, 1) if self.LightMap != None: ts = TextureStage("LightMap") ts.setMode(TextureStage.MModulate) ts.setSort(2) self.Root.setTexture(ts, self.LightMap, 2) elif self.LightMap != None: self.Root.setTexture(ts, self.LightMap, 1)
def __init__(self, panda3d): # Inicialización de variables self.winsize = [0, 0] self.panda3d = panda3d sha_normal = "data/shaders/normalGen.sha" sha_depth = "data/shaders/depthGen.sha" sha_color = "data/shaders/colorGen.sha" sha_ink = "data/shaders/inkGen.sha" self.normal_buff, self.normal_cam = self.make_buffer( "normalsBuffer", sha_normal, 0.5) # self.depth_buff, self.depth_cam = self.make_buffer("depthBuffer", sha_depth, 0.5) self.color_buff, self.color_cam = self.make_buffer( "colorsBuffer", sha_color, 0.5) tex_normal = self.normal_buff.getTextureCard() # tex_depth = self.depth_buff.getTextureCard() tex_color = self.color_buff.getTextureCard() tex_normal.setTransparency(1) tex_normal.setColor(1, 1, 1, 1) tex_normal.reparentTo(self.panda3d.render2d) stage_border = TextureStage("border") stage_border.setSort(1) # tex_normal.setTexture(stage_border, tex_color.getTexture()) # stage_depth = TextureStage("depth") # stage_depth.setSort(2) # tex_normal.setTexture(stage_depth, tex_depth.getTexture()) shader_ink = self.panda3d.loader.loadShader(sha_ink) #tex_normal.setShader(shader_ink) width = self.panda3d.win.getXSize() height = self.panda3d.win.getYSize() tex_normal.setShaderInput("screen", width, height) self.tex_normal = tex_normal
def __init__(self, scene, dynamic=True, rate=(0.005, 0.05), texturescale=(1000, 1000), scale=(40, 40, 10), texturefile=None): Att_base.__init__(self, False, "Sky Dome 1") self.skybox = loader.loadModel("../media/models/dome2") self.skybox.setCollideMask(BitMask32().allOff()) self.skybox.setTwoSided(False) self.skybox.setScale(scale[0], scale[1], scale[2]) self.skybox.setLightOff() if texturefile == None: texturefile = "../media/textures/concrete.jpg" texture = loader.loadTexture(texturefile) self.textureStage0 = TextureStage("stage0") self.textureStage0.setMode(TextureStage.MReplace) self.skybox.setTexture(self.textureStage0, texture, 1) self.skybox.setTexScale(self.textureStage0, texturescale[0], texturescale[1]) self.skybox.reparentTo(scene)
def onAddNewTextureStage(self, evt): if self.object == None: # Huh? Something must be wrong. self.button.Disable() return filter = "Portable Network Graphics (*.png)|*.[pP][nN][gG];*.png" filter += "|All files|*.*" dlg = wx.FileDialog(self, "Select texture", "", "", filter, wx.OPEN) try: if dlg.ShowModal() == wx.ID_OK: tex = loader.loadTexture(Filename.fromOsSpecific(dlg.GetPath()).getFullpath()) if tex == None: wx.MessageDialog(None, "Failed to load texture!", "Error", wx.OK | wx.ICON_ERROR).ShowModal() return stage = TextureStage(tex.getName()) self.object.setTexture(stage, tex) self.viewForNodePath(self.object) # Select the newly created layer. for l in self.layers: if l.stage == stage and l.tex == tex: self.select(l) finally: dlg.Destroy() self.updatePreview()
def make(self): TerrainTile.make(self) self.makeSlopeMap() textureMapper = self.terrain.texturer.textureMapper #try to read textureMaps readTexMaps = True texNum = 0 for tex in textureMapper.textures: texNum += 1 fileName = "maps/textures/" + self.name + "+_texture" + str( texNum) + ".png" if not tex.image.read(Filename(fileName)): readTexMaps = False #otherwise calculate textureMaps if not readTexMaps: self.terrain.texturer.textureMapper.calculateTextures(self) #copy textureMaps to this terrainTile and save if necessary texNum = 0 for tex in self.terrain.texturer.textureMapper.textures: texNum += 1 self.textureMaps.append(tex.image) if not readTexMaps: tex.image.write( Filename("maps/textures/" + self.name + "+_texture" + str(texNum) + ".png")) #load textureMaps as actual textures for the shaders use num = 0 for tex in self.textureMaps: num += 1 newTexture = Texture() newTexture.load(tex) ts = TextureStage('alp' + str(num)) self.getRoot().setTexture(ts, newTexture)
def __init__(self): tex1 = loader.loadTexture('textures/clouds.jpg') tex1.setMagfilter(Texture.FTLinearMipmapLinear) tex1.setMinfilter(Texture.FTLinearMipmapLinear) tex1.setAnisotropicDegree(2) tex1.setWrapU(Texture.WMRepeat) tex1.setWrapV(Texture.WMRepeat) tex1.setFormat(Texture.FAlpha) self.ts1 = TextureStage('clouds') #self.ts1.setMode(TextureStage.MBlend) self.ts1.setColor(Vec4(1, 1, 1, 1)) #self.plane(-2000, -2000, 2000, 2000, 100) self.sphere(10000, -9600) self.clouds.setTransparency(TransparencyAttrib.MDual) self.clouds.setTexture(self.ts1, tex1) self.clouds.setBin('background', 3) self.clouds.setDepthWrite(False) self.clouds.setDepthTest(False) self.clouds.setTwoSided(True) self.clouds.setLightOff(1) self.clouds.setShaderOff(1) self.clouds.setFogOff(1) self.clouds.hide( BitMask32.bit(2)) # Hide from the volumetric lighting camera self.speed = 0.003 self.time = 0 self.dayColor = Vec4(0.98, 0.98, 0.95, 1.0) self.nightColor = Vec4(-0.5, -0.3, .0, 1.0) self.sunsetColor = Vec4(0.75, .60, .65, 1.0) ColoredByTime.__init__(self) self.setColor = self.clouds.setColor
def __init__(self, parent): self.parent = parent self.baseNode = self.parent.attachNewNode(self.__class__.__name__) x1 = -200 y1 = -200 x2 = 200 y2 = 200 z = 0.0 #waterNP = NodePath("Water Node Parent") #waterNP.reparentTo(parent) #sn = self.drawSquare(-100, -100, 0, 100, 100, 0); #sn.reparentTo(self.baseNode) water = Square(self.baseNode, Point3(x1, y1, 0.2), Point3(x2, y2, 0.2), Vec4(0.0, 0.0, 0.5, 0.5)) wNp = water.draw() t1 = loader.loadTexture('assets/textures/wave.png') t1.setWrapU(Texture.WMRepeat) t1.setWrapV(Texture.WMRepeat) wNp.setTexture(t1) # Water Shader from # http://www.panda3d.org/forums/viewtopic.php?p=70853&sid=53d92b5ae1683bd9458f21d6026ad36e # anim: vx, vy, scale, skip # distort: offset, strength, refraction factor (0 = perfect mirror, # 1 = total refraction), refractivity anim = (.022, -.012, 2.5, 0) distort = (.1, 2, .5, .45) self.buffer = base.win.makeTextureBuffer('waterBuffer', 512, 512) self.watercamNP = base.makeCamera(self.buffer) # Create water surface using a card # The surface will be centered and maker = CardMaker('water') # Water surface maker.setFrame(x1, x2, y1, y2) self.waterNP = self.baseNode.attachNewNode(maker.generate()) self.waterNP.setPosHpr((0, 0, z), (0, -90, 0)) self.waterNP.setTransparency(TransparencyAttrib.MAlpha) self.waterNP.setTwoSided(True) # Attach the water shader to the water shader surface waterShader = Shader.load("shaders/water.sha") self.waterNP.setShader(waterShader) self.waterNP.setShaderInput('wateranim', anim) self.waterNP.setShaderInput('waterdistort', distort) self.waterNP.setShaderInput('time', 0) self.waterPlane = Plane((0, 0, z + 1), (0, 0, z)) # Reflection plane PlaneNode('waterPlane').setPlane(self.waterPlane) self.buffer.setClearColor((0, 0, 0.5, 1)) # buffer self.watercamNP.reparentTo(self.baseNode) # reflection camera cam = self.watercamNP.node() cam.getLens().setFov(base.camLens.getFov()) cam.getLens().setNearFar(1, 5000) cam.setInitialState(RenderState.make(CullFaceAttrib.makeReverse())) cam.setTagStateKey('Clipped') cam.setTagState( 'True', RenderState.make(ShaderAttrib.make().setShader( loader.loadShader('shaders/splut3Clipped.sha')))) tex0 = self.buffer.getTexture() # reflection texture, created in # realtime by the 'water camera' tex0.setWrapU(Texture.WMClamp) tex0.setWrapV(Texture.WMClamp) self.waterNP.setTexture(TextureStage('reflection'), tex0) self.waterNP.setTexture( TextureStage('distortion'), loader.loadTexture( 'assets/textures/water.png')) # distortion texture self.task = taskMgr.add(self.update, 'waterUpdate', sort=50)
def _initVisuals(self): textureCard = loader.loadModel('models/minigames/pir_m_gam_srp_water') self.waterStream = textureCard.find('**/waterPlane') tex = textureCard.findTexture('pir_t_gui_srp_waterDrops') textureCard2 = loader.loadModel('models/minigames/pir_m_gam_srp_water') self.waterStream2 = textureCard2.find('**/waterPlane') tex2 = textureCard2.findTexture('pir_t_gui_srp_waterDrops') alphaCard = loader.loadModel( 'models/minigames/pir_m_gui_srp_waterDropsAlpha') self.alphaWaterStream = textureCard.find( '**/pir_t_gui_srp_waterDropsAlpha') alphatex = alphaCard.find( '**/pir_t_gui_srp_waterDropsAlpha').findTexture('*') self.alphaWaterStream2 = textureCard.find( '**/pir_t_gui_srp_waterDropsAlpha2') alphatex2 = alphaCard.find( '**/pir_t_gui_srp_waterDropsAlpha2').findTexture('*') alphaCard2 = loader.loadModel( 'models/minigames/pir_m_gui_srp_waterDropsAlpha') self.alphaWaterStream3 = textureCard.find( '**/pir_t_gui_srp_waterDropsAlpha') alphatex3 = alphaCard2.findTexture('*') self.alphaWaterStream4 = textureCard.find( '**/pir_t_gui_srp_waterDropsAlpha2') alphatex4 = alphaCard2.findTexture('*') tex.setWrapU(Texture.WMRepeat) tex.setWrapV(Texture.WMRepeat) alphatex.setWrapU(Texture.WMRepeat) alphatex.setWrapV(Texture.WMRepeat) tex2.setWrapU(Texture.WMRepeat) tex2.setWrapV(Texture.WMRepeat) alphatex3.setWrapU(Texture.WMRepeat) alphatex3.setWrapV(Texture.WMRepeat) self.setScale(2.5 * self.leakScale) self.waterStream.setScale(self.leakScale) self.waterStream.setPos(self.getX(), 0.0, -0.5 * self.leakScale + self.getZ()) self.waterStream2.setScale(self.leakScale * 0.8, self.leakScale, self.leakScale * 1.2) self.waterStream2.setPos(self.getX(), 0.0, -0.6 * self.leakScale + self.getZ()) self.waterStream.setColor(0.7, 0.85, 1.0, 1.0) self.waterStream2.setColor(0.5, 0.6, 0.9, 1.0) self.waterStream2.reparentTo(self.pitchingGame) self.waterStream.reparentTo(self.pitchingGame) self.waterStream2.setBin('fixed', 42) self.waterStream.setBin('fixed', 40) self.textureYOffset = random.random() self.textureYDelta = 0.25 + 0.025 / self.leakScale self.textureYOffset2 = random.random() self.textureYDelta2 = 0.25412354 + 0.058754645634 / self.leakScale self.textureYOffsetAlpha = 0.0 self.textureYDeltaAlpha = 0.25 + 0.025 / self.leakScale self.textureYOffsetAlpha2 = 0.0 self.textureYDeltaAlpha2 = 0.25412354 + 0.058754645634 / self.leakScale self.textureStage = self.waterStream.findTextureStage('*') self.textureStage2 = self.waterStream2.findTextureStage('*') self.textureStage3 = TextureStage('alphaLayer') self.textureStage3.setMode(TextureStage.MModulate) self.textureStage3.setSort(1) self.waterStream.setTexture(self.textureStage3, alphatex) self.textureStage4 = TextureStage('alphaLayer2') self.textureStage4.setMode(TextureStage.MModulate) self.textureStage4.setSort(2) self.waterStream.setTexture(self.textureStage4, alphatex2) trans = TransformState.makePos((0, 0.48, 0)) self.waterStream.setTexTransform(self.textureStage4, trans) self.textureStage5 = TextureStage('alphaLayer3') self.textureStage5.setMode(TextureStage.MModulate) self.textureStage5.setSort(1) self.waterStream2.setTexture(self.textureStage5, alphatex3) self.textureStage6 = TextureStage('alphaLayer4') self.textureStage6.setMode(TextureStage.MModulate) self.textureStage6.setSort(2) self.waterStream2.setTexture(self.textureStage6, alphatex4) trans = TransformState.makePos((0, 0.48, 0)) self.waterStream2.setTexTransform(self.textureStage6, trans)
def add_shadders(self: ShowBase): normalsBuffer = self.win.makeTextureBuffer("normalsBuffer", 0, 0) normalsBuffer.setClearColor(LVecBase4(0.5, 0.5, 0.5, 0.5)) self.normalsBuffer = normalsBuffer normalsCamera = self.makeCamera(normalsBuffer, lens=self.cam.node().getLens()) normalsCamera.node().setScene(self.render) tempnode = NodePath(PandaNode("temp node")) normalGen = self.loader.loadShader("app/view/shaders/normalGen.sha") tempnode.setShader(normalGen) tempnode.setShaderInput("showborders", LVecBase4(1)) normalsCamera.node().setInitialState(tempnode.getState()) depth_buffer = self.win.makeTextureBuffer("depthBuffer", 0, 0) depth_buffer.setClearColor(LVecBase4(0, 0, 0, 0)) self.depth_buffer = depth_buffer depth_camera = self.makeCamera(depth_buffer, lens=self.cam.node().getLens()) depth_camera.node().setScene(self.render) tempnode = NodePath(PandaNode("temp node depth")) depth_gen = self.loader.loadShader("app/view/shaders/depthGen.sha") tempnode.setShader(depth_gen) depth_camera.node().setInitialState(tempnode.getState()) colors_buffer = self.win.makeTextureBuffer("colorsBuffer", 0, 0) colors_buffer.setClearColor(LVecBase4(0, 0, 0, 0)) self.colors_buffer = colors_buffer colorsCamera = self.makeCamera(colors_buffer, lens=self.cam.node().getLens()) colorsCamera.node().setScene(self.render) tempnode = NodePath(PandaNode("temp node colors")) colorGen = self.loader.loadShader("app/view/shaders/colorGen.sha") tempnode.setShader(colorGen) tempnode.setShaderInput("showborders", LVecBase4(1)) tempnode.setShaderInput("colorborders", LVecBase4(0, 0, 0, 1)) colorsCamera.node().setInitialState(tempnode.getState()) # what we actually do to put edges on screen is apply them as a texture to # a transparent screen-fitted card drawnScene = normalsBuffer.getTextureCard() colorBorderTex = colors_buffer.getTextureCard() depthTex = depth_buffer.getTextureCard() drawnScene.setTransparency(1) drawnScene.setColor(1, 1, 1, 1) drawnScene.reparentTo(render2d) self.drawnScene = drawnScene # this shader accepts, as input, the picture from the normals buffer. # it compares each adjacent pixel, looking for discontinuities. # wherever a discontinuity exists, it emits black ink. self.separation = 0.0005 self.separation = 1 self.cutoff = 0.3 inkGen = loader.loadShader("app/view/shaders/inkGen.sha") stage_border = TextureStage("border") stage_border.setSort(1) drawnScene.setTexture(stage_border, colorBorderTex.getTexture()) stage_depth = TextureStage("depth") stage_depth.setSort(2) drawnScene.setTexture(stage_depth, depthTex.getTexture()) drawnScene.setShader(inkGen) drawnScene.setShaderInput( "separation", LVecBase4(self.separation, 0, self.separation, 0)) drawnScene.setShaderInput("screen", 1280, 720) drawnScene.setShaderInput("cutoff", LVecBase4(self.cutoff)) print("SHADER DEBUG") print(drawnScene.findAllTextureStages())
def __init__(self, world, x1, y1, x2, y2, z): self.world = world logging.info(('setting up water plane at z=' + str(z))) # Water surface maker = CardMaker('water') maker.setFrame(x1, x2, y1, y2) self.waterNP = render.attachNewNode(maker.generate()) self.waterNP.setHpr(0, -90, 0) self.waterNP.setPos(0, 0, z) self.waterNP.setTransparency(TransparencyAttrib.MAlpha) self.waterNP.setShader(loader.loadShader('shaders/water.sha')) self.waterNP.setShaderInput('wateranim', Vec4(0.03, -0.015, 64.0, 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, z + 1), Point3(0, 0, z)) planeNode = PlaneNode('waterPlane') planeNode.setPlane(self.waterPlane) # Buffer and reflection camera buffer = base.win.makeTextureBuffer('waterBuffer', 512, 512) buffer.setClearColor(Vec4(0, 0, 0, 1)) cfa = CullFaceAttrib.makeReverse() rs = RenderState.make(cfa) self.watercamNP = base.makeCamera(buffer) self.watercamNP.reparentTo(render) #sa = ShaderAttrib.make() #sa = sa.setShader(loader.loadShader('shaders/splut3Clipped.sha') ) cam = self.watercamNP.node() cam.getLens().setFov(base.camLens.getFov()) cam.getLens().setNear(1) cam.getLens().setFar(5000) cam.setInitialState(rs) cam.setTagStateKey('Clipped') #cam.setTagState('True', RenderState.make(sa)) # ---- water textures --------------------------------------------- # reflection texture, created in realtime by the 'water camera' tex0 = 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) # ---- Fog --- broken min = Point3(x1, y1, -999.0) max = Point3(x2, y2, z) boundry = BoundingBox(min, max) self.waterFog = Fog('waterFog') self.waterFog.setBounds(boundry) colour = (0.2, 0.5, 0.8) self.waterFog.setColor(*colour) self.waterFog.setExpDensity(0.05) render.attachNewNode(self.waterFog) #render.setFog(world.waterFog) taskMgr.add(self.update, "waterTask")
def construct_scene(lbase, modelpath, bgpath, scale, pos, hpr, bgscale, bghp, texture=None, internal_canonical=False, check_penetration=False, light_spec=None, use_envmap=False, shader=None, world_coords=False): """ Constructs the scene per the parameters. """ # Default scene is lbase's rootnode if bgpath is not None: bgpath = mt.resolve_bg_path(bgpath) rootnode = lbase.rootnode # Modelpath points to the model .egg/.bam file if isstring(modelpath): modelpaths = [modelpath] scales = [scale] poses = [pos] hprs = [hpr] textures = [texture] else: modelpaths = modelpath scales = scale poses = pos hprs = hpr textures = texture texmodes = [] for _i, _t in enumerate(textures): if isinstance(_t, tuple): texfile, texmode = _t texmodes.append(texmode) textures[_i] = texfile else: texmodes.append(TexGenAttrib.MWorldNormal) assert hasattr(modelpaths, '__iter__') assert hasattr(scales, '__iter__') assert hasattr(poses, '__iter__') assert hasattr(hprs, '__iter__') assert hasattr(textures, '__iter__') assert len(modelpaths) == len(scales) == len(hprs) == len(poses) == len( textures), (len(modelpaths), len(scales), len(hprs), len(poses), len(textures)) modelpaths = map(mt.resolve_model_path, modelpaths) modelpaths = map(cm.autogen_egg, modelpaths) textures = map(mt.resolve_texture_path, textures) objnodes = [] for mpth, scale, hpr, pos, t, tm in zip(modelpaths, scales, hprs, poses, textures, texmodes): objnode = tools.read_file(lbase.loader.loadModel, mpth) if t is not None: #ts = TextureStage('ts') ts = TextureStage.get_default() ts.setMode(TextureStage.MReplace) tex = tools.read_file(lbase.loader.loadTexture, t) objnode.setTexGen(ts, tm) objnode.setTexture(tex, 6) robjnode = rootnode.attachNewNode('root_' + objnode.get_name()) objnode.reparentTo(robjnode) if internal_canonical: vertices = np.array(objnode.getTightBounds()) initial_scale_factor = max(abs(vertices[0] - vertices[1])) cscale = 1.2 / initial_scale_factor ppos = vertices.mean(0) * cscale objnode.setPos(-ppos[0], -ppos[1], -ppos[2]) objnode.setScale(cscale, cscale, cscale) if world_coords: refnodeX = rootnode.attachNewNode('world_coords_x') refnodeY = rootnode.attachNewNode('world_coords_y') refnodeZ = rootnode.attachNewNode('world_coords_z') robjnode.wrtReparentTo(refnodeZ) refnodeZ.setH(refnodeX, hpr[2]) robjnode.wrtReparentTo(refnodeY) refnodeY.setP(refnodeX, hpr[1]) robjnode.wrtReparentTo(refnodeX) refnodeX.setR(refnodeX, hpr[0]) robjnode.wrtReparentTo(rootnode) else: robjnode.setHpr(hpr[2], hpr[1], hpr[0]) robjnode.setScale(scale[0], scale[0], scale[0]) robjnode.setPos(pos[0], -pos[2], pos[1]) robjnode.setTwoSided(1) objnodes.append(robjnode) if check_penetration: for (i, n1) in enumerate(objnodes): for j, n2 in enumerate(objnodes[i + 1:]): p = is_penetrating(n1, n2) if p: for onode in objnodes: onode.removeNode() raise PenetrationError(i, j, n1, n2) # Environment map if bgpath and use_envmap: envtex = tools.read_file(lbase.loader.loadTexture, bgpath) # Map onto object ts = TextureStage('env') ts.setMode(TextureStage.MBlendColorScale) if not isinstance(use_envmap, list): use_envmap = [use_envmap] * len(objnodes) for _objnode, ue in zip(objnodes, use_envmap): if ue: if isstring(ue): envtex0 = tools.read_file(lbase.loader.loadTexture, mt.resolve_texture_path(ue)) else: envtex0 = envtex _objnode.setTexGen(ts, TexGenAttrib.MEyeSphereMap) _objnode.setTexture(ts, envtex0) if bgpath and not np.isinf(bghp[0]): bgtex = tools.read_file(lbase.loader.loadTexture, bgpath) # Set as background #plane = cm.autogen_egg(mt.resolve_model_path('plane2d')) bgnode = lbase.loader.loadModel('smiley') # Get material list bgnode.clearMaterial() bgnode.clearTexture() bgnode.setAttrib( CullFaceAttrib.make(CullFaceAttrib.MCullCounterClockwise)) bgnode.setTexture(bgtex, 2) c = 5. bgnode.setScale(c * bgscale[0], c * bgscale[0], c * bgscale[0]) bgnode.setPos(0, 0, 0) #0) bgnode.setHpr(bghp[0], bghp[1], 0.) # Detach point light plight1 = lbase.rootnode.find('**/plight1') if plight1: plight1.detachNode() elif bgpath: bgnode = NodePath("empty-bgnode") imageObject = OnscreenImage(image=bgpath, pos=(0, 0, 0), scale=tuple(bgscale), parent=bgnode, base=lbase) else: bgnode = NodePath("empty-bgnode") bgnode.reparentTo(rootnode) if shader is not None: vshaderpath, fshaderpath = shader rootnode.setShaderAuto() shader = Shader.load(Shader.SLGLSL, vshaderpath, fshaderpath) rootnode.setShader(shader) if light_spec is not None: lbase.rootnode.clearLight() lights = LightBase.make_lights(light_spec=light_spec, lname='scene_lights') lights.reparentTo(rootnode) for light in lights.getChildren(): rootnode.setLight(light) return objnodes, bgnode
def loadShader(self): """Textures based on altitude and slope.""" logging.info("loading textures...") ### texture scaling texScale = self.terrain.tileSize / 32 * self.terrain.horizontalScale self.texScale = Vec4(texScale, texScale, texScale, 1.0) ### Load textures self.normalMap = self.loadTexture("Detail_NRM.png") self.displacementMap = self.loadTexture("Detail_DISP.png") self.testOn = False self.detailTex = self.loadTexture("Detail_COLOR.png") self.detailTex2 = self.loadTexture("Detail_COLOR2.png") self.tex1 = self.loadTexture("dirt.jpg") self.tex2 = self.loadTexture("grass.jpg") self.tex3 = self.loadTexture("rock.jpg") self.tex4 = self.loadTexture("snow.jpg") self.normalTS = TextureStage('normalMap') #self.normalTS2 = TextureStage('normalMap2') self.detailTS = TextureStage('detailMap') self.ts1 = TextureStage('textures') ### Load the boundries for each texture # regionLimits ( min height, max height, min slope, max slope ) self.textureMapper = TextureMapper(self.terrain) self.textureMapper.addTexture(self.tex1) self.textureMapper.addRegionToTex( Vec4(-9999.0, self.indexToHeight(0.1), -0.001, 1.001)) self.textureMapper.addTexture(self.tex2) self.textureMapper.addRegionToTex( Vec4(self.indexToHeight(-0.15), self.indexToHeight(0.75), -0.001, 0.30)) self.textureMapper.addTexture(self.tex3) self.textureMapper.addRegionToTex( Vec4(self.indexToHeight(0.1), self.indexToHeight(0.95), 0.10, 1.001)) #second region forces tex 2 and 4 to blend a bit at their boundries regardless of slope self.textureMapper.addRegionToTex( Vec4(self.indexToHeight(0.4), self.indexToHeight(0.9), -0.001, 1.001)) self.textureMapper.addTexture(self.tex4) self.textureMapper.addRegionToTex( Vec4(self.indexToHeight(0.72), 9999.0, -0.001, 1.001)) logging.info("intializing terrain shader generator...") file = 'shaders/terrain.sha' if SAVED_TEXTURE_MAPS: self.shaderGenerator = BakedTerrainShaderGenerator( self.terrain, self, self.textureMapper) file = 'shaders/bakedTerrain.sha' else: self.shaderGenerator = FullTerrainShaderGenerator( self.terrain, self, self.textureMapper) file = 'shaders/fullTerrain.sha' logging.info("terrain shader generator initialized...") if RUNTYPE == 'python': self.shaderGenerator.saveShader(file) self.shader = Shader.load(file, Shader.SLCg) else: self.shader = Shader.make(self.shaderGenerator.createShader(), Shader.SLCg) self.terrain.setShaderInput("normalMap", self.normalMap) self.terrain.setShaderInput("displacementMap", self.displacementMap) self.terrain.setShaderInput("detailTex", self.detailTex) self.terrain.setShaderInput('tscale', self.texScale) self.terrain.setShaderInput("fogColor", Vec4(1.0, 1.0, 1.0, 1.0)) self.terrain.setShaderInput("camPos", base.camera.getPos())