class Tester(ShowBase): TipoImagenNulo = 0 TipoImagenTopo = 1 TipoImagenRuido = 2 TipoImagenRuidoContinuo = 3 def __init__(self): # super(Tester, self).__init__() self.disableMouse() self.win.setClearColor(Vec4(0.95, 1.0, 1.0, 1.0)) # bullet_world = BulletWorld() # self.cam_pitch = 30.0 self.escribir_archivo = False # cada update # config.iniciar() self.sistema = Sistema() self.sistema.radio_expansion_parcelas = 1 self.sistema.iniciar() Sistema.establecer_instancia(self.sistema) # GestorShader.iniciar(self, Sistema.TopoAltitudOceano, Vec4(0, 0, 1, Sistema.TopoAltitudOceano)) GestorShader.aplicar(self.render, GestorShader.ClaseGenerico, 1) self.render.setShaderInput("distancia_fog_maxima", 3000.0, 0, 0, 0, priority=3) # self.terreno = Terreno(self, bullet_world) self.terreno.iniciar() #self.terreno.nodo.setRenderModeWireframe() # plano = CardMaker("plano_agua") r = Sistema.TopoTamanoParcela * 6 plano.setFrame(-r, r, -r, r) plano.setColor((0, 0, 1, 1)) self.plano_agua = self.render.attachNewNode(plano.generate()) self.plano_agua = self.loader.loadModel("objetos/plano_agua") self.plano_agua.reparentTo(self.render) self.plano_agua.setScale(0.5) #self.plano_agua.setP(-90.0) #self.plano_agua.hide() # self.cam_driver = self.render.attachNewNode("cam_driver") self.camera.reparentTo(self.cam_driver) self.camera.setPos(Sistema.TopoTamanoParcela / 2, 500, 100) self.camera.lookAt(self.cam_driver) self.cam_driver.setP(self.cam_pitch) # self.luz_ambiental = self.render.attachNewNode( AmbientLight("luz_ambiental")) self.luz_ambiental.node().setColor(Vec4(0.1, 0.1, 0.1, 1)) # self.sun = self.render.attachNewNode(DirectionalLight("sun")) self.sun.node().setColor(Vec4(1, 1, 1, 1)) self.sun.setPos(self.terreno.nodo, 100, 100, 100) self.sun.lookAt(self.terreno.nodo) # self.render.setLight(self.luz_ambiental) self.render.setLight(self.sun) # self.texturaImagen = None self.imagen = None self.zoom_imagen = 1 # self.tipo_imagen = Tester.TipoImagenTopo # self.taskMgr.add(self.update, "update") self.accept("wheel_up", self.zoom, [1]) self.accept("wheel_down", self.zoom, [-1]) # self._cargar_ui() #self._actualizar_terreno() self._generar_imagen() def update(self, task): nueva_pos_foco = Vec3(self.sistema.posicion_cursor) # mwn = self.mouseWatcherNode if mwn.isButtonDown(KeyboardButton.up()): nueva_pos_foco[1] -= Sistema.TopoTamanoParcela elif mwn.isButtonDown(KeyboardButton.down()): nueva_pos_foco[1] += Sistema.TopoTamanoParcela elif mwn.isButtonDown(KeyboardButton.left()): nueva_pos_foco[0] += Sistema.TopoTamanoParcela elif mwn.isButtonDown(KeyboardButton.right()): nueva_pos_foco[0] -= Sistema.TopoTamanoParcela # if nueva_pos_foco != self.sistema.posicion_cursor: log.info("update pos_foco=%s" % str(nueva_pos_foco)) self.sistema.posicion_cursor = nueva_pos_foco self._actualizar_terreno() return task.cont def zoom(self, dir): dy = 25 * dir self.camera.setY(self.camera, dy) def analizar_altitudes(self, pos_foco, tamano=1024): log.info("analizar_altitudes en %ix%i" % (tamano, tamano)) i = 0 media = 0 vals = list() min = 999999 max = -999999 for x in range(tamano): for y in range(tamano): a = self.sistema.obtener_altitud_suelo( (pos_foco[0] + x, pos_foco[1] + y)) vals.append(a) if a > max: max = a if a < min: min = a media = ((media * i) + a) / (i + 1) i += 1 sd = 0 for val in vals: sd += ((val - media) * (val - media)) sd /= (tamano * tamano) sd = math.sqrt(sd) log.info("analizar_altitudes rango:[%.3f/%.3f] media=%.3f sd=%.3f" % (min, max, media, sd)) def _actualizar_terreno(self): log.info("_actualizar_terreno pos=%s" % (str(self.sistema.posicion_cursor))) # self.sistema.update(0, self.sistema.posicion_cursor) self.terreno.update() if self.escribir_archivo: log.info("escribir_archivo") self.terreno.nodo.writeBamFile("terreno.bam") self.plano_agua.setPos( Vec3(self.sistema.posicion_cursor[0], self.sistema.posicion_cursor[1], Sistema.TopoAltitudOceano)) # self.cam_driver.setPos( Vec3( self.sistema.posicion_cursor[0] + Sistema.TopoTamanoParcela / 2, self.sistema.posicion_cursor[1] - Sistema.TopoTamanoParcela, Sistema.TopoAltitudOceano)) # self.lblInfo["text"] = self.terreno.obtener_info() # self._generar_imagen() def _ruido(self, position, imagen_ruido, tamano_imagen_ruido): octaves = 8 persistance = 0.55 value = 0.0 amplitude = 1.0 total_amplitude = 0.0 for i_octave in range(octaves): amplitude *= persistance total_amplitude += amplitude period = 1 << (octaves - i_octave) offset_periodo_x, cant_periodos_x = math.modf(position[0] / period) offset_periodo_y, cant_periodos_y = math.modf(position[1] / period) periodo_x0 = (cant_periodos_x * period) % tamano_imagen_ruido periodo_y0 = (cant_periodos_y * period) % tamano_imagen_ruido periodo_x1 = (periodo_x0 + period) % tamano_imagen_ruido periodo_y1 = (periodo_y0 + period) % tamano_imagen_ruido c00 = imagen_ruido.getGray(int(periodo_x0), int(periodo_y0)) c10 = imagen_ruido.getGray(int(periodo_x1), int(periodo_y0)) c01 = imagen_ruido.getGray(int(periodo_x0), int(periodo_y1)) c11 = imagen_ruido.getGray(int(periodo_x1), int(periodo_y1)) interp_x0 = (c00 * (1.0 - offset_periodo_x)) + (c10 * offset_periodo_x) interp_x1 = (c01 * (1.0 - offset_periodo_x)) + (c11 * offset_periodo_x) interp_y = (interp_x0 * (1.0 - offset_periodo_y)) + (interp_x1 * offset_periodo_y) value += interp_y * amplitude #info="_ruido\tposition=%s tamano_imagen_ruido=%i i_octave=%i periodo=%i offset_periodo=%s\n"%(str(position), tamano_imagen_ruido, i_octave, period, str((offset_periodo_x, offset_periodo_y))) #info+="\tpx0=%.1f px1=%.1f offset_x=%.2f py0=%.1f py1=%.1f offset_y=%.2f interp_y=%.3f"%(periodo_x0, periodo_x1, offset_x, periodo_y0, periodo_y1, offset_y, interp_y) #print(info) #print("cxx=%s a=%.4f p=%i v=%.4f"%(str((c00, c10, c01, c11)), amplitude, period, value)) if total_amplitude > 1.0: value /= total_amplitude return value def _limpiar_imagen(self): if self.imagen: self.texturaImagen.releaseAll() self.texturaImagen.clear() self.texturaImagen = None self.imagen.clear() self.imagen = None def _generar_imagen(self): log.info("_generar_imagen") self._limpiar_imagen() if self.tipo_imagen == Tester.TipoImagenTopo: self._generar_imagen_topo() elif self.tipo_imagen == Tester.TipoImagenRuido: self._generar_imagen_ruido() elif self.tipo_imagen == Tester.TipoImagenRuidoContinuo: self._generar_imagen_ruido_continuo() def _generar_imagen_ruido_continuo(self): log.info("_generar_imagen_ruido_continuo") # tamano = 512 # # perlin_noise_scale=64 # perlin=StackedPerlinNoise2(perlin_noise_scale, perlin_noise_scale, 6, 2.0, 0.50, 256, 1069) perlin = self.sistema.ruido_terreno # if not self.imagen: type = PNMFileTypeRegistry.getGlobalPtr().getTypeFromExtension( "*.png") self.imagen = PNMImage(tamano, tamano, 4, 255, type, CS_linear) self.texturaImagen = Texture() self.frmImagen["image"] = self.texturaImagen self.frmImagen["image_scale"] = 0.4 # zoom = self.zoom_imagen log.info("zoom: %.2f" % (zoom)) # range_x, range_y=tamano, tamano # factor_x, factor_y=range_x/tamano, range_y/tamano for x in range(tamano): for y in range(tamano): # _x=x*factor_x # _y=y*factor_y # c00=perlin(_x, _y ) # c10=perlin((_x+range_x) ,_y ) # c01=perlin(_x, (_y+range_y) ) # c11=perlin((_x+range_x) ,(_y+range_y) ) # mix_x, mix_y=1.0-_x/range_x, 1.0-_y/range_y # if mix_x<0.0 or mix_y<0.0 or mix_x>1.0 or mix_y>1.0: # print("error mix_x,mix_y") # interp_x0=(c00*(1.0-mix_x))+(c10*mix_x) # interp_x1=(c01*(1.0-mix_x))+(c11*mix_x) # interp_y=(interp_x0*(1.0-mix_y))+(interp_x1*mix_y) # interp_y=interp_y*0.5+0.5 # interp_y=interp_y if interp_y<1.0 else 1.0 # interp_y=interp_y if interp_y>0.0 else 0.0 # c=interp_y # if c<0.0 or c>1.0: # print("error c") c = self.sistema.calcular_ruido_continuo(perlin, x, y, tamano) self.imagen.setXelA(x, y, c, c, c, 1.0) # # self.imagen.write("texturas/white_noise.png") image_tiled = PNMImage(2 * tamano, 2 * tamano) image_tiled.copySubImage(self.imagen, 0, 0, 0, 0, tamano, tamano) image_tiled.copySubImage(self.imagen, tamano, 0, 0, 0, tamano, tamano) image_tiled.copySubImage(self.imagen, 0, tamano, 0, 0, tamano, tamano) image_tiled.copySubImage(self.imagen, tamano, tamano, 0, 0, tamano, tamano) self.imagen.clear() self.imagen = None self.imagen = image_tiled self.texturaImagen.load(self.imagen) def _generar_imagen_ruido(self): # http://devmag.org.za/2009/04/25/perlin-noise/ log.info("_generar_imagen_ruido") return # tamano = 128 # if not self.imagen: self.imagen = PNMImage(tamano + 1, tamano + 1) self.texturaImagen = Texture() self.frmImagen["image"] = self.texturaImagen self.frmImagen["image_scale"] = 0.4 # zoom = self.zoom_imagen log.info("zoom: %.2f" % (zoom)) imagen_ruido = PNMImage("texturas/white_noise.png") n = 0 vals = list() tamano_imagen_ruido = imagen_ruido.getReadXSize() for x in range(tamano_imagen_ruido): vals.append(list()) for y in range(tamano_imagen_ruido): _x = self.sistema.posicion_cursor[0] + zoom * (tamano / 2.0) - zoom * x _y = self.sistema.posicion_cursor[1] - zoom * (tamano / 2.0) + zoom * y a = self._ruido((_x, _y), imagen_ruido, tamano_imagen_ruido) vals[x].append(a) n += 1 media = 0.0 sd = 0.0 for fila in vals: for val in fila: media += val media /= n for fila in vals: for val in fila: sd += (val - media)**2 sd = math.sqrt(sd / (n - 1)) vals2 = list() k = 7 for x in range(tamano_imagen_ruido): vals2.append(list()) for y in range(tamano_imagen_ruido): val = vals[x][y] val -= (media - 0.5) val += (0.5 - val) * (-(1.0 + (2**k) * sd)) val2 = min(1.0, max(0.0, val)) vals2[x].append(val2) for x in range(tamano_imagen_ruido): for y in range(tamano_imagen_ruido): self.imagen.setXel(x, y, vals2[x][y]) print("_generar_imagen_ruido media=%.4f sd=%.4f" % (media, sd)) # self.texturaImagen.load(self.imagen) def _generar_imagen_topo(self): log.info("_generar_imagen_topo") # tamano = 128 if not self.imagen: self.imagen = PNMImage(tamano + 1, tamano + 1) self.texturaImagen = Texture() self.frmImagen["image"] = self.texturaImagen self.frmImagen["image_scale"] = 0.4 # zoom = self.zoom_imagen log.info("zoom: %.2f" % (zoom)) for x in range(tamano + 1): for y in range(tamano + 1): _x = self.sistema.posicion_cursor[0] + zoom * (tamano / 2.0) - zoom * x _y = self.sistema.posicion_cursor[1] - zoom * (tamano / 2.0) + zoom * y a = self.terreno.sistema.obtener_altitud_suelo( (_x, _y)) / Sistema.TopoAltura if x == tamano / 2 or y == tamano / 2: self.imagen.setXel(x, y, 1.0) else: if a > (Sistema.TopoAltitudOceano / Sistema.TopoAltura): self.imagen.setXel(x, y, a, a, 0.0) else: self.imagen.setXel(x, y, 0.0, 0.0, a) # self.texturaImagen.load(self.imagen) def _ir_a_idx_pos(self): log.info("_ir_a_idx_pos") try: idx_x = int(self.entry_x.get()) idx_y = int(self.entry_y.get()) pos = self.sistema.obtener_pos_parcela((idx_x, idx_y)) tam = self.sistema.obtener_temperatura_anual_media_norm(pos) prec_f = self.sistema.obtener_precipitacion_frecuencia_anual(pos) log.info("idx_pos:(%i,%i); pos:%s; tam=%.4f prec_f=%.4f" % (idx_x, idx_y, str(pos), tam, prec_f)) self.sistema.posicion_cursor = Vec3(pos[0], pos[1], 0.0) self._actualizar_terreno() except Exception as e: log.exception(str(e)) def _cargar_ui(self): # frame self.frame = DirectFrame(parent=self.aspect2d, pos=(0, 0, -0.85), frameSize=(-1, 1, -0.15, 0.25), frameColor=(1, 1, 1, 0.5)) # info self.lblInfo = DirectLabel(parent=self.frame, pos=(-1, 0, 0.15), scale=0.05, text="info terreno?", frameColor=(1, 1, 1, 0.2), frameSize=(0, 40, -2, 2), text_align=TextNode.ALeft, text_pos=(0, 1, 1)) # idx_pos idx_pos = self.sistema.obtener_indice_parcela( self.sistema.posicion_cursor) DirectLabel(parent=self.frame, pos=(-1, 0, 0), scale=0.05, text="idx_pos_x", frameColor=(1, 1, 1, 0), frameSize=(0, 2, -1, 1), text_align=TextNode.ALeft) DirectLabel(parent=self.frame, pos=(-1, 0, -0.1), scale=0.05, text="idx_pos_y", frameColor=(1, 1, 1, 0), frameSize=(0, 2, -1, 1), text_align=TextNode.ALeft) self.entry_x = DirectEntry(parent=self.frame, pos=(-0.7, 0, 0), scale=0.05, initialText=str(idx_pos[0])) self.entry_y = DirectEntry(parent=self.frame, pos=(-0.7, 0, -0.1), scale=0.05, initialText=str(idx_pos[1])) DirectButton(parent=self.frame, pos=(0, 0, -0.1), scale=0.075, text="actualizar", command=self._ir_a_idx_pos) # self.frmImagen = DirectFrame(parent=self.frame, pos=(0.8, 0, 0.2), state=DGG.NORMAL, frameSize=(-0.4, 0.4, -0.4, 0.4)) self.frmImagen.bind(DGG.B1PRESS, self._click_imagen) DirectButton(parent=self.frame, pos=(0.500, 0, 0.65), scale=0.1, text="acercar", command=self._acercar_zoom_imagen, frameSize=(-1, 1, -0.4, 0.4), text_scale=0.5) DirectButton(parent=self.frame, pos=(0.725, 0, 0.65), scale=0.1, text="alejar", command=self._alejar_zoom_imagen, frameSize=(-1, 1, -0.4, 0.4), text_scale=0.5) DirectButton(parent=self.frame, pos=(0.950, 0, 0.65), scale=0.1, text="cambiar", command=self._cambiar_tipo_imagen, frameSize=(-1, 1, -0.4, 0.4), text_scale=0.5) def _cambiar_tipo_imagen(self): log.info("_cambiar_tipo_imagen a:") if self.tipo_imagen == Tester.TipoImagenTopo: log.info("TipoImagenRuido") self.tipo_imagen = Tester.TipoImagenRuido elif self.tipo_imagen == Tester.TipoImagenRuido: log.info("TipoImagenRuidoContinuo") self.tipo_imagen = Tester.TipoImagenRuidoContinuo elif self.tipo_imagen == Tester.TipoImagenRuidoContinuo: log.info("TipoImagenTopo") self.tipo_imagen = Tester.TipoImagenTopo self._generar_imagen() def _click_imagen(self, *args): log.info("_click_imagen %s" % str(args)) def _acercar_zoom_imagen(self): log.info("_acercar_zoom_imagen") self.zoom_imagen -= 4 if self.zoom_imagen < 1: self.zoom_imagen = 1 self._generar_imagen() def _alejar_zoom_imagen(self): log.info("_alejar_zoom_imagen") self.zoom_imagen += 4 if self.zoom_imagen > 4096: self.zoom_imagen = 4096 self._generar_imagen()
class Mundo: def __init__(self, base): # referencias: self.base = base self.sistema = None # componentes: self.nodo = self.base.render.attachNewNode("mundo") self.input_mapper = None self.controlador_camara = None self.terreno = None self.cielo = None self.sol = None self.agua = None self.objetos = None self.hombre = None self.nave = None # variables internas: self._counter = 50 # forzar terreno.update antes de hombre.update self._personajes = [] self._periodo_dia_actual = 0 def iniciar(self): log.info("iniciar") # sistema: self.sistema = Sistema() self.sistema.iniciar() self.sistema.cargar_parametros_iniciales() self.sistema.update(0.0, self.sistema.posicion_cursor) Sistema.establecer_instancia(self.sistema) # fisica: self._configurar_fisica() # mundo: self._establecer_material() # quitarlo, optimizacion? no, al reves! self._establecer_shader() # componentes: self.input_mapper = InputMapperTecladoMouse(self.base) self.controlador_camara = ControladorCamara(self.base) self.controlador_camara.iniciar() # self._cargar_terreno() # self._cargar_personajes() # self._cargar_objetos() # #self._cargar_obj_voxel() # gui: self._cargar_debug_info() self._cargar_gui() # ShowBase self.base.cam.node().setCameraMask(DrawMask(1)) self.base.render.node().adjustDrawMask(DrawMask(5), DrawMask(0), DrawMask(0)) # self.base.accept("l-up", self._hacer, [0]) self.base.accept("m-up", self._hacer, [1]) self.base.accept("v-up", self._hacer, [2]) # self.base.taskMgr.add(self._update, "mundo_update") # def terminar(self): log.info("terminar") # self.base.ignore("l-up") self.base.ignore("m-up") self.base.ignore("v-up") # self.controlador_camara.terminar() # for _personaje in self._personajes: _personaje.terminar() if self.objetos: self.objetos.terminar() if self.agua: self.agua.terminar() if self.sol: self.sol.terminar() if self.cielo: self.cielo.terminar() if self.terreno: self.terreno.terminar() # self.sistema = None Sistema.remover_instancia() def _hacer(self, que): if que == 0: log.debug(self.sistema.obtener_info()) elif que == 1: self.nodo.analyze() elif que == 2: self.base.bufferViewer.toggleEnable() elif que == 3: if not self.nave: return if not self.hombre.conduciendo: self.nave.setPos(self.sistema.posicion_cursor) self.hombre.cuerpo.reparentTo(self.nave.cuerpo) self.hombre.setPos(Vec3(0, 0, -0.5)) self.hombre.conduciendo = True self.controlador_camara.seguir(self.nave.cuerpo) else: self.hombre.cuerpo.reparentTo(self.nodo) self.hombre.setPos(self.sistema.posicion_cursor) self.hombre.conduciendo = False self.controlador_camara.seguir(self.hombre.cuerpo) def _establecer_material(self): log.info("_establecer_material") intensidades = (0.20, 0.35, 0.0) # (a,d,s) material = Material("material_mundo") material.setAmbient( (intensidades[0], intensidades[0], intensidades[0], 1.0)) material.setDiffuse( (intensidades[1], intensidades[1], intensidades[1], 1.0)) material.setSpecular( (intensidades[2], intensidades[2], intensidades[2], 1.0)) material.setShininess(0) self.nodo.setMaterial(material, 1) def _establecer_shader(self): log.info("_establecer_shader") GestorShader.iniciar(self.base, Sistema.TopoAltitudOceano, Vec4(0, 0, 1, Sistema.TopoAltitudOceano)) # # ¿esto habra solucionado el problema del clipping caprichoso? self.nodo.setShaderInput("altitud_agua", Sistema.TopoAltitudOceano, 0.0, 0.0, 0.0, priority=1) # #GestorShader.aplicar(self.nodo, GestorShader.ClaseGenerico, 1) # quitarlo, optimizacion? #GestorShader.aplicar(self, GestorShader.ClaseDebug, 1000) def _cargar_obj_voxel(self): hm = HeightMap(id=66) N = 64 self.obj = voxels.Objeto("volumen", N, N, N, 0) for x in range(N - 2): for y in range(N - 2): h = int(hm.getHeight(x, y) * N) print("%s,%s->%i" % (str(x), str(y), h)) for z in range(h): self.obj.establecer_valor(x + 1, y + 1, z + 1, 255) model_root = ModelRoot("volumen") self.objN = self.nodo.attachNewNode(model_root) self.objN.attachNewNode(self.obj.iniciar_smooth()) self.objN.setColor(0.4, 0.4, 0.4, 1) self.objN.setTwoSided(True, 1) self.objN.setShaderAuto() self.objN.setScale(1) self.objN.setPos(-N / 2, -N / 2, -9.5) def _configurar_fisica(self): self.bullet_world = BulletWorld() #return # debug_fisica = BulletDebugNode("debug_fisica") debug_fisica.showNormals(True) self.debug_fisicaN = self.nodo.attachNewNode(debug_fisica) self.debug_fisicaN.hide() self.base.accept("f3", self._toggle_debug_fisica) # self.bullet_world.setGravity(Vec3(0.0, 0.0, -9.81)) self.bullet_world.setDebugNode(debug_fisica) return # _shape = BulletBoxShape(Vec3(0.5, 0.5, 0.5)) _cuerpo = BulletRigidBodyNode("caja_rigid_body") _cuerpo.setMass(1.0) _cuerpo.addShape(_shape) _cuerpoN = self.nodo.attachNewNode(_cuerpo) _cuerpoN.setPos(0.0, 0.0, 100.0) _cuerpoN.setCollideMask(BitMask32.bit(3)) self.bullet_world.attachRigidBody(_cuerpo) _cuerpoN.reparentTo(self.nodo) caja = self.base.loader.loadModel("box.egg") caja.reparentTo(_cuerpoN) def _cargar_debug_info(self): Negro = Vec4(0.0, 0.0, 0.0, 1.0) #Blanco=Vec4(1.0, 1.0, 1.0, 1.0) self.texto1 = OnscreenText(text="mundo", pos=(-1.2, 0.9), scale=0.045, align=TextNode.ALeft, fg=Negro, mayChange=True) def _cargar_gui(self): self.lblHora = DirectLabel(text="00:00", text_fg=(0.15, 0.15, 0.9, 1.0), text_bg=(1.0, 1.0, 1.0, 1.0), scale=0.1, pos=(1.2, 0.0, -0.8), color=(1, 1, 1, 1)) self.lblTemperatura = DirectLabel(text="0º", text_fg=(0.15, 0.15, 0.9, 1.0), text_bg=(1.0, 1.0, 1.0, 1.0), scale=0.1, pos=(1.2, 0.0, -0.93), color=(1, 1, 1, 1)) def _cargar_personajes(self): # personajes self.hombre = Hombre() self._personajes.append(self.hombre) # nave self.nave = Nave() self._personajes.append(self.nave) # for _personaje in self._personajes: _personaje.input_mapper = self.input_mapper _personaje.altitud_agua = Sistema.TopoAltitudOceano _personaje.iniciar(self.nodo, self.bullet_world) # posicionar self.hombre.setPos(self.sistema.posicion_cursor) pos = self.sistema.posicion_cursor + Vec3(-3, -3, 0) self.nave.setPos( Vec3(pos[0], pos[1], self.sistema.obtener_altitud_suelo(pos))) # self.controlador_camara.seguir(self.hombre.cuerpo) def _cargar_objetos(self): # self.palo = self.base.loader.loadModel("objetos/palof") self.palo.reparentTo(self.nodo) self.palo.setPos(self.sistema.obtener_posicion_3d(Vec3(12, 12, 0))) # luz_omni = self.nodo.attachNewNode(PointLight("luz_omni")) luz_omni.setPos(Vec3(0, -2, 152.5)) luz_omni.node().setColor(Vec4(1, 0, 0, 1)) luz_omni.node().setAttenuation(Vec3(0, 1.1, 0)) self.nodo.setShaderInput("luz_omni[0]", luz_omni, priority=4) # luz_omni.reparentTo(self.palo) # luz_omni.setPos(0, 0, 1) # self.spot_light = self.nodo.attachNewNode(Spotlight("spot_light")) self.spot_light.setPos(self.hombre.cuerpo.getPos() + Vec3(0, -5, 6)) self.spot_light.node().setColor((1, 1, 0.7, 1)) self.spot_light.node().setAttenuation(Vec3(0.04, 0.025, 0.01)) self.spot_light.node().setLens(PerspectiveLens()) #self.spot_light.node().setShadowCaster(True, 256, 256) self.spot_light.lookAt(self.hombre.cuerpo) self.nodo.setLight(self.spot_light) self.spot_light.reparentTo(self.palo) self.spot_light.setPos(0, 0, 1) self.spot_light.setHpr(0, 15, 0) # self.nubes = self.base.loader.loadModel("objetos/plano") self.nubes.reparentTo(self.nodo) #self.nubes.setTwoSided(True) self.nubes.setPos(self.hombre.cuerpo.getPos() + Vec3(0, -16, 2.5)) self.nubes.setP(-90) #noise=StackedPerlinNoise2(1, 1, 8, 2, 0.5, 256, 18) ts0 = TextureStage("ts_nubes") tamano = 512 imagen = PNMImage(tamano, tamano) #imagen.perlinNoiseFill(noise) for x in range(tamano): for y in range(tamano): #v=noise(x, y)*0.5+0.5 imagen.setXelA(x, y, 1, 0, 0, 0.5) tex0 = self.base.loader.loadTexture( "texturas/white_noise.png") #Texture("tex_nubes") # tex0.load(imagen) self.nubes.setTexture(ts0, tex0) # pelota = self.base.loader.loadModel("objetos/pelota.egg") pelota.reparentTo(self.nodo) pelota.setZ( self.sistema.obtener_altitud_suelo(self.sistema.posicion_cursor) + 3.0) material_pelota = Material("material_pelota") intensidades = (0.3, 0.2, 0.2) material_pelota.setAmbient( (intensidades[0], intensidades[0], intensidades[0], 1.0)) material_pelota.setDiffuse( (intensidades[1], intensidades[1], intensidades[1], 1.0)) material_pelota.setSpecular( (intensidades[2], intensidades[2], intensidades[2], 1.0)) material_pelota.setShininess(20) pelota.setMaterial(material_pelota, priority=2) GestorShader.aplicar(pelota, GestorShader.ClaseGenerico, 3) # plano_vertical = self.base.loader.loadModel( "objetos/plano_vertical.egg") plano_vertical.reparentTo(self.nodo) plano_vertical.setPos(0, -6, self.sistema.obtener_altitud_suelo((0, -6, 0))) #plano_vertical.setTwoSided(True) plano_vertical.setBillboardAxis() GestorShader.aplicar(plano_vertical, GestorShader.ClaseGenerico, 3) # nodo_flatten = self.nodo.attachNewNode("nodo_flatten") for x in range(4): p = self.base.loader.loadModel("objetos/pelota.egg") p.clearModelNodes() p.reparentTo(nodo_flatten) p.setPos(6, 0, 153 + x) p.setScale(0.2) nodo_flatten.flattenStrong() # cant = 3 prisma = self.base.loader.loadModel("objetos/prisma_tri.egg") prisma_geomnode = prisma.find("**/+GeomNode") for i_geom in range(prisma_geomnode.node().getNumGeoms()): prisma_geom = prisma_geomnode.node().getGeom(i_geom) ## prisma_vdata = prisma_geom.getVertexData() consolidado_prismas_vdata = GeomVertexData( "vertex_data", prisma_vdata.getFormat(), Geom.UHStatic) consolidado_prismas_vdata.setNumRows(cant * prisma_vdata.getNumRows()) offset = prisma_vdata.getNumRows() ## prisma_prims = list() consolidado_prismas_prims = list() for i_prim in range(prisma_geom.getNumPrimitives()): prim = prisma_geom.getPrimitive(i_prim).decompose() prisma_prims.append(prim) consolidado_prismas_prim = GeomTriangles(Geom.UHStatic) consolidado_prismas_prims.append(consolidado_prismas_prim) for i_cant in range(cant): vdata = GeomVertexData(prisma_vdata) vdata.transformVertices( LMatrix4f.translateMat(3 * i_cant, 0.0, 0.0)) for i_row in range(vdata.getNumRows()): consolidado_prismas_vdata.copyRowFrom( i_cant * offset + i_row, vdata, i_row, Thread.getCurrentThread()) for i_prim in range(len(prisma_prims)): consolidado_prismas_prim = consolidado_prismas_prims[ i_prim] prim_verts = prisma_prims[i_prim].getVertexList() for vert in prim_verts: consolidado_prismas_prim.addVertex(vert + i_cant * offset) consolidado_prismas_geom = Geom(consolidado_prismas_vdata) consolidado_prismas_geom.addPrimitive(consolidado_prismas_prim) # consolidado_prismas_geomnode = GeomNode("copia_geomnode") consolidado_prismas_geomnode.addGeom(consolidado_prismas_geom) self.nodo_prismas = self.nodo.attachNewNode("nodo_prismas") self.nodo_prismas.setPos( 20, 6, 2 + self.sistema.obtener_altitud_suelo((20, 6, 0))) self.nodo_prismas.attachNewNode(consolidado_prismas_geomnode) # def _cargar_terreno(self): # terreno self.terreno = Terreno(self.base, self.bullet_world) self.terreno.iniciar() self.terreno.nodo.reparentTo(self.nodo) self.terreno.update() # cielo self.cielo = Cielo(self.base, Sistema.TopoAltitudOceano - 20.0) self.cielo.nodo.reparentTo(self.nodo) # agua self.agua = Agua(self.base, Sistema.TopoAltitudOceano) self.agua.nodo.reparentTo(self.nodo) # estaba self.base.render self.agua.generar() # self.agua.mostrar_camaras() # sol self.sol = Sol(self.base, Sistema.TopoAltitudOceano - 20.0) self.sol.pivot.reparentTo(self.nodo) # self.cielo.nodo # self.sol.mostrar_camaras() self.nodo.setLight(self.sol.luz) # objetos # self.objetos=Objetos(self.base) # self.objetos.iniciar() # self.objetos.nodo.reparentTo(self.nodo) # self.objetos.update() # # self.cielo.nodo.setBin("background", 0) # self.agua.nodo.setBin("background", 1) # self.sol.nodo.setBin("background", 2) # self.terreno.nodo.setBin("opaque", 0) # self.objetos.nodo.setBin("transparent", 0) # self.controlador_camara.altitud_agua = Sistema.TopoAltitudOceano # def _update(self, task): if self._counter == 50: info = "" info += self.sistema.obtener_info() + "\n" #info+=self.terreno.obtener_info()+"\n" info += self.hombre.obtener_info() + "\n" #info+=self.agua.obtener_info()+"\n" #info+=self.objetos.obtener_info()+"\n" #info+=self.input_mapper.obtener_info()+"\n" #info+=self.cielo.obtener_info() #info+=self.sol.obtener_info()+"\n" self.texto1.setText(info) # tiempo dt = self.base.taskMgr.globalClock.getDt() # input self.input_mapper.update() # fisica self.bullet_world.doPhysics(dt) # controlador cámara self.controlador_camara.altitud_suelo = self.sistema.obtener_altitud_suelo( self.controlador_camara.pos_camara.getXy()) self.controlador_camara.update(dt) pos_pivot_camara = self.controlador_camara.pivot.getPos(self.nodo) self.nodo.setShaderInput("pos_pivot_camara", pos_pivot_camara, priority=10) # sistema self.sistema.update(dt, pos_pivot_camara) # cielo if self.cielo: offset_periodo = self.sistema.calcular_offset_periodo_dia() self.cielo.nodo.setX( self.controlador_camara.target_node_path.getPos().getX()) self.cielo.nodo.setY( self.controlador_camara.target_node_path.getPos().getY()) self.cielo.update(pos_pivot_camara, self.sistema.hora_normalizada, self.sistema.periodo_dia_actual, offset_periodo) self.nodo.setShaderInput("color_luz_ambiental", self.cielo.color_luz_ambiental, priority=10) self.nodo.setShaderInput("offset_periodo_cielo", self.cielo.offset_periodo, priority=10) self.nodo.setShaderInput("color_cielo_base_inicial", self.cielo.color_cielo_base_inicial, priority=10) self.nodo.setShaderInput("color_cielo_base_final", self.cielo.color_cielo_base_final, priority=10) self.nodo.setShaderInput("color_halo_sol_inicial", self.cielo.color_halo_sol_inicial, priority=10) self.nodo.setShaderInput("color_halo_sol_final", self.cielo.color_halo_sol_final, priority=10) # sol if self.sol: self.sol.update(pos_pivot_camara, self.sistema.hora_normalizada, self.sistema.periodo_dia_actual, offset_periodo) self.nodo.setShaderInput("posicion_sol", self.sol.nodo.getPos(self.nodo), priority=10) # personajes for _personaje in self._personajes: _personaje.update(dt) # contador 1/50 if self._counter == 50: self._counter = 0 # if self.terreno: self.terreno.update( ) #pos_pivot_camara)#self.controlador_camara.target_node_path.getPos()) ? if self.objetos: self.objetos.update() #pos_pivot_camara) # gui self.lblHora["text"] = self.sistema.obtener_hora() self.lblTemperatura[ "text"] = "%.0fº" % self.sistema.obtener_temperatura_actual_grados( ) # agua if self.agua: self.agua.nodo.setX( self.controlador_camara.target_node_path.getPos().getX()) self.agua.nodo.setY( self.controlador_camara.target_node_path.getPos().getY()) self.agua.update(dt, self.sol.luz.getPos(self.cielo.nodo), self.sol.luz.node().getColor()) # self._counter += 1 return task.cont def _toggle_debug_fisica(self): if self.debug_fisicaN.isHidden(): self.debug_fisicaN.show() else: self.debug_fisicaN.hide()