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())
