def __init__(self,manager,xml): self.surface = getWaterSurface(manager) self.surface.reparentTo(render) self.surface.hide(BitMask32.bit(1)) # Invisible to reflection camera (speedup) self.surface.hide(BitMask32.bit(2)) # Invisible to volumetric lighting camera (speedup) self.surface.hide(BitMask32.bit(3)) # Invisible to shadow cameras (speedup) self.surface.setShader(loader.loadShader(manager.get('paths').getConfig().find('shaders').get('path')+'/water.cg')) self.surface.setShaderInput('time', 0.0, 0.0, 0.0, 0.0) ntex = loader.loadTexture(manager.get('paths').getConfig().find('textures').get('path')+'/water-normal.png') ntex.setMinfilter(Texture.FTLinearMipmapLinear) self.surface.setShaderInput('normal', ntex) self.surface.setShaderInput('camera', base.cam) self.surface.setTransparency(TransparencyAttrib.MDual, 10) self.surface.setTwoSided(True) self.surface.setShaderInput('waveInfo', Vec4(0.4, 0.4, 0.4, 0)) self.surface.setShaderInput('param2', Vec4(-0.015,0.005, 0.05, 0.05)) self.surface.setShaderInput('param3', Vec4(0.7, 0.3, 0, 0)) self.surface.setShaderInput('param4', Vec4(2.0, 0.5, 0.5, 0.0)) #self.surface.setShaderInput('speed', Vec4(-.8, -.4, -.9, .3)) self.surface.setShaderInput('speed', Vec4(0.2, -1.2, -0.2, -0.7)) self.surface.setShaderInput('deepcolor', Vec4(0.0,0.3,0.5,1.0)) self.surface.setShaderInput('shallowcolor', Vec4(0.0,1.0,1.0,1.0)) self.surface.setShaderInput('reflectioncolor', Vec4(0.95,1.0,1.0,1.0)) self.surface.hide() self.wbuffer = base.win.makeTextureBuffer('water', 512, 512) self.wbuffer.setClearColorActive(True) self.wbuffer.setClearColor(base.win.getClearColor()) self.wcamera = base.makeCamera(self.wbuffer) if manager.get('sky') != None and manager.get('sky').model != None: self.sky = manager.get('sky').model.copyTo(self.wcamera) self.sky.setTwoSided(True) self.sky.setSz(self.sky, -1) self.sky.setClipPlaneOff(1) self.sky.show() self.sky.hide(BitMask32.bit(0)) # Hide for normal camera self.sky.hide(BitMask32.bit(2)) # Hide for volumetric lighting camera self.sky.hide(BitMask32.bit(3)) # Hide for shadow camera(s), if any else: self.sky = None self.wcamera.reparentTo(render) self.wcamera.node().setLens(base.camLens) self.wcamera.node().setCameraMask(BitMask32.bit(1)) self.surface.hide(BitMask32.bit(1)) wtexture = self.wbuffer.getTexture() wtexture.setWrapU(Texture.WMClamp) wtexture.setWrapV(Texture.WMClamp) wtexture.setMinfilter(Texture.FTLinearMipmapLinear) self.surface.setShaderInput('reflection', wtexture) self.wplane = Plane(Vec3(0, 0, 1), Point3(0, 0, 0)) self.wplanenp = render.attachNewNode(PlaneNode('water', self.wplane)) tmpnp = NodePath('StateInitializer') tmpnp.setClipPlane(self.wplanenp) tmpnp.setAttrib(CullFaceAttrib.makeReverse()) self.wcamera.node().setInitialState(tmpnp.getState()) #self.fog = Fog('UnderwaterFog') #self.fog.setColor(0.0,0.3,0.5) self.fogEnabled = False
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 __init__(self, name, halfedge_mesh, color, wireframe=False): GeomNode.__init__(self, name) self._halfedge_mesh = halfedge_mesh self._color = color self._wireframe = wireframe self._create_vertex_data() self._create_geoms() # set visualisation parameters if self._wireframe: self.setAttrib(RenderModeAttrib.make(RenderModeAttrib.MWireframe, 2, 1)) self.setAttrib(CullFaceAttrib.make(CullFaceAttrib.MCullNone))
def __init__(self, name, surface, color, wireframe=False): GeomNode.__init__(self, name) self._surface = surface self._color = color self._wireframe = wireframe self._init_tables() self._create_vertex_data() self._create_geoms() # set visualisation parameters if self._wireframe: self.setAttrib(RenderModeAttrib.make(RenderModeAttrib.MWireframe, 2, 1)) else: self.setAttrib(RenderModeAttrib.make(RenderModeAttrib.MFilledFlat, 2, 1)) self.setAttrib(CullFaceAttrib.make(CullFaceAttrib.MCullNone))
def __init__(self, name, width, height, points, normals=[], color=(1.0,1.0,1.0,1.0), wireframe=False): GeomNode.__init__(self, name) self._width = width self._height = height assert(len(points) == self._width * self._height) if normals: assert(len(normals) == self._width * self._height) self._points = points self._normals = normals self._color = color self._wireframe = wireframe self._create_vertex_data() self._create_geom_primitives() self._create_geoms() # set visualisation parameters if self._wireframe: self.setAttrib(RenderModeAttrib.make(RenderModeAttrib.MWireframe, 2, 1)) self.setAttrib(CullFaceAttrib.make(CullFaceAttrib.MCullNone))
def draw_body(self, position, vector_list, radius = 1, keep_drawing = True, num_vertices = 8): circle_geom = Geom(self.vdata) vertex_writer = GeomVertexWriter(self.vdata, "vertex") color_writer = GeomVertexWriter(self.vdata, "color") normal_writer = GeomVertexWriter(self.vdata, "normal") draw_rewriter = GeomVertexRewriter(self.vdata, "drawFlag") tex_rewriter = GeomVertexRewriter(self.vdata, "texcoord") start_row = self.vdata.getNumRows() vertex_writer.setRow(start_row) color_writer.setRow(start_row) normal_writer.setRow(start_row) sCoord = 0 if start_row != 0: tex_rewriter.setRow(start_row - num_vertices) sCoord = tex_rewriter.getData2f().getX() + 1 draw_rewriter.setRow(start_row - num_vertices) if draw_rewriter.getData1f() == False: sCoord -= 1 draw_rewriter.setRow(start_row) tex_rewriter.setRow(start_row) angle_slice = 2 * math.pi / num_vertices current_angle = 0 perp1 = vector_list[1] perp2 = vector_list[2] # write vertex information for i in range(num_vertices): adjacent_circle = position + (perp1 * math.cos(current_angle) + perp2 * math.sin(current_angle)) * radius normal = perp1 * math.cos(current_angle) + perp2 * math.sin(current_angle) normal_writer.addData3f(normal) vertex_writer.addData3f(adjacent_circle) tex_rewriter.addData2f(sCoord, (i + 0.001) / (num_vertices - 1)) color_writer.addData4f(0.5, 0.5, 0.5, 1.0) draw_rewriter.addData1f(keep_drawing) current_angle += angle_slice draw_reader = GeomVertexReader(self.vdata, "drawFlag") draw_reader.setRow(start_row - num_vertices) # we can't draw quads directly so use Tristrips if start_row != 0 and draw_reader.getData1f() != False: lines = GeomTristrips(Geom.UHStatic) half = int(num_vertices * 0.5) for i in range(num_vertices): lines.addVertex(i + start_row) if i < half: lines.addVertex(i + start_row - half) else: lines.addVertex(i + start_row - half - num_vertices) lines.addVertex(start_row) lines.addVertex(start_row - half) lines.closePrimitive() lines.decompose() circle_geom.addPrimitive(lines) circle_geom_node = GeomNode("Debug") circle_geom_node.addGeom(circle_geom) circle_geom_node.setAttrib(CullFaceAttrib.makeReverse(), 1) self.get_model().attachNewNode(circle_geom_node)
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 __init__(self, manager, xml): self.surface = getWaterSurface(manager) self.surface.reparentTo(render) self.surface.hide(BitMask32.bit(1)) # Invisible to reflection camera (speedup) self.surface.hide(BitMask32.bit(2)) # Invisible to volumetric lighting camera (speedup) self.surface.hide(BitMask32.bit(3)) # Invisible to shadow cameras (speedup) self.surface.setShader( loader.loadShader(manager.get("paths").getConfig().find("shaders").get("path") + "/water.cg") ) self.surface.setShaderInput("time", 0.0, 0.0, 0.0, 0.0) ntex = loader.loadTexture(manager.get("paths").getConfig().find("textures").get("path") + "/water-normal.png") ntex.setMinfilter(Texture.FTLinearMipmapLinear) self.surface.setShaderInput("normal", ntex) self.surface.setShaderInput("camera", base.cam) self.surface.setTransparency(TransparencyAttrib.MDual, 10) self.surface.setTwoSided(True) self.surface.setShaderInput("waveInfo", Vec4(0.4, 0.4, 0.4, 0)) self.surface.setShaderInput("param2", Vec4(-0.015, 0.005, 0.05, 0.05)) self.surface.setShaderInput("param3", Vec4(0.7, 0.3, 0, 0)) self.surface.setShaderInput("param4", Vec4(2.0, 0.5, 0.5, 0.0)) # self.surface.setShaderInput('speed', Vec4(-.8, -.4, -.9, .3)) self.surface.setShaderInput("speed", Vec4(0.2, -1.2, -0.2, -0.7)) self.surface.setShaderInput("deepcolor", Vec4(0.0, 0.3, 0.5, 1.0)) self.surface.setShaderInput("shallowcolor", Vec4(0.0, 1.0, 1.0, 1.0)) self.surface.setShaderInput("reflectioncolor", Vec4(0.95, 1.0, 1.0, 1.0)) self.surface.hide() self.wbuffer = base.win.makeTextureBuffer("water", 512, 512) self.wbuffer.setClearColorActive(True) self.wbuffer.setClearColor(base.win.getClearColor()) self.wcamera = base.makeCamera(self.wbuffer) if manager.get("sky") != None and manager.get("sky").model != None: self.sky = manager.get("sky").model.copyTo(self.wcamera) self.sky.setTwoSided(True) self.sky.setSz(self.sky, -1) self.sky.setClipPlaneOff(1) self.sky.show() self.sky.hide(BitMask32.bit(0)) # Hide for normal camera self.sky.hide(BitMask32.bit(2)) # Hide for volumetric lighting camera self.sky.hide(BitMask32.bit(3)) # Hide for shadow camera(s), if any else: self.sky = None self.wcamera.reparentTo(render) self.wcamera.node().setLens(base.camLens) self.wcamera.node().setCameraMask(BitMask32.bit(1)) self.surface.hide(BitMask32.bit(1)) wtexture = self.wbuffer.getTexture() wtexture.setWrapU(Texture.WMClamp) wtexture.setWrapV(Texture.WMClamp) wtexture.setMinfilter(Texture.FTLinearMipmapLinear) self.surface.setShaderInput("reflection", wtexture) self.wplane = Plane(Vec3(0, 0, 1), Point3(0, 0, 0)) self.wplanenp = render.attachNewNode(PlaneNode("water", self.wplane)) tmpnp = NodePath("StateInitializer") tmpnp.setClipPlane(self.wplanenp) tmpnp.setAttrib(CullFaceAttrib.makeReverse()) self.wcamera.node().setInitialState(tmpnp.getState()) # self.fog = Fog('UnderwaterFog') # self.fog.setColor(0.0,0.3,0.5) self.fogEnabled = False
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 __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 update(self, task): # update matrix of the reflection camera mc = base.camera.getMat() mf = self.waterPlane.getReflectionMat() self.watercamNP.setMat(mc * mf) self.waterNP.setShaderInput('time', task.time) self.waterNP.setX(self.world.ralph.getX()) self.waterNP.setY(self.world.ralph.getY()) return task.cont
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): """ 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 isinstance(modelpath, str): 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) robjnode.setScale(scale[0], scale[0], scale[0]) robjnode.setPos(pos[0], -pos[2], pos[1]) robjnode.setHpr(hpr[2], hpr[1], hpr[0]) 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 isinstance(ue, str): 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 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 __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 drawBody(nodePath, vdata, pos, vecList, radius=1, keepDrawing=True,numVertices=8): circleGeom=Geom(vdata) vertWriter=GeomVertexWriter(vdata, "vertex") colorWriter=GeomVertexWriter(vdata, "color") normalWriter=GeomVertexWriter(vdata, "normal") drawReWriter=GeomVertexRewriter(vdata, "drawFlag") texReWriter=GeomVertexRewriter(vdata, "texcoord") startRow=vdata.getNumRows() vertWriter.setRow(startRow) colorWriter.setRow(startRow) normalWriter.setRow(startRow) sCoord=0 if (startRow!=0): texReWriter.setRow(startRow-numVertices) sCoord=texReWriter.getData2f().getX()+1 drawReWriter.setRow(startRow-numVertices) if(drawReWriter.getData1f()==False): sCoord-=1 drawReWriter.setRow(startRow) texReWriter.setRow(startRow) angleSlice=2*math.pi/numVertices currAngle=0 #axisAdj=Mat4.rotateMat(45, axis)*Mat4.scaleMat(radius)*Mat4.translateMat(pos) perp1=vecList[1] perp2=vecList[2] #vertex information is written here for i in range(numVertices): adjCircle=pos+(perp1*math.cos(currAngle)+perp2*math.sin(currAngle))*radius normal=perp1*math.cos(currAngle)+perp2*math.sin(currAngle) normalWriter.addData3f(normal) vertWriter.addData3f(adjCircle) texReWriter.addData2f(sCoord,(i+0.001)/(numVertices-1)) colorWriter.addData4f(0.5,0.5,0.5,1) drawReWriter.addData1f(keepDrawing) currAngle+=angleSlice drawReader=GeomVertexReader(vdata, "drawFlag") drawReader.setRow(startRow-numVertices) #we cant draw quads directly so we use Tristrips if (startRow!=0) & (drawReader.getData1f()!=False): lines=GeomTristrips(Geom.UHStatic) half=int(numVertices*0.5) for i in range(numVertices): lines.addVertex(i+startRow) if i< half: lines.addVertex(i+startRow-half) else: lines.addVertex(i+startRow-half-numVertices) lines.addVertex(startRow) lines.addVertex(startRow-half) lines.closePrimitive() lines.decompose() circleGeom.addPrimitive(lines) circleGeomNode=GeomNode("Debug") circleGeomNode.addGeom(circleGeom) #I accidentally made the front-face face inwards. Make reverse makes the tree render properly and #should cause any surprises to any poor programmer that tries to use this code circleGeomNode.setAttrib(CullFaceAttrib.makeReverse(),1) global numPrimitives numPrimitives+=numVertices*2 nodePath.attachNewNode(circleGeomNode)
t_start = time.time() zebra.append(app.loader.loadModel(path + objs[f] + '/' + objs[f])) zebra[f].setScale(1,1,1) zebra_vars.append(get_cannonical(zebra[f])) zebra[f].reparentTo(app.render) zebra[f].setScale(s*zebra_vars[f][0],s*zebra_vars[f][0],s*zebra_vars[f][0]) zebra[f].setPos(-100,-100,-100) app.camera.setPos(0,0,0) app.camera.setHpr(0,0,0) bgnode = app.loader.loadModel('/home/darren/panda_inst/share/panda3d/models/smiley') bgnode.clearMaterial() bgnode.clearTexture() bgnode.setAttrib(CullFaceAttrib.make(CullFaceAttrib.MCullCounterClockwise)) bgnode.reparentTo(app.render) bgnode.setPos(0, 0, 0) bgscale=5 bgnode.setScale(bgscale, bgscale, bgscale) movie_ind = 0 imgs = np.zeros((N_MOVIES, N_FRAMES, 3, IMG_SZ, IMG_SZ),dtype='uint8') bg_list = np.zeros(N_MOVIES, dtype='int') obj_list = np.zeros(N_MOVIES, dtype='int') bgnode.setTexture(bgtex[bg_list[movie_ind]], 2) while True: bg_list[movie_ind] = np.random.randint(len(bgtex))
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 )