def place_devils_tower(self): self.devils_tower = self.render.attach_new_node( shape.ShapeGen().elliptic_cone(a=(240, 70), b=(200, 80), h=250, max_seg_len=20.0, exp=2.5, top_xy=(40, -20), color=core.Vec4( 0.717, 0.635, 0.558, 1), nac=False)) h = random.randint(0, 360) self.collision.add(collision.CollisionCircle( core.Vec2(0), 230, )) self.devils_tower.set_h(h) z = [] for x in (-220, 0, 220): for y in (-220, 0, 220): z.append(self.sample_terrain_z(x, y)) self.devils_tower.set_z(min(z) - 5) self.noise.setup_fns(noise_type=fns.NoiseType.Value, ) y, x = common.DT_TEX_SHAPE c = fns.empty_coords(y * x) c[0, :] = np.tile( np.cos(np.linspace(-np.pi, np.pi, x, False)) * common.DT_XY_RADIUS, y) c[1, :] = np.tile( np.sin(np.linspace(-np.pi, np.pi, x, False)) * common.DT_XY_RADIUS, y) c[2, :] = np.repeat( np.linspace(-np.pi, np.pi, x, False) * common.DT_Z_RADIUS, y) a = self.noise.fns.genFromCoords(c).reshape((y, x)) normal_map = util.sobel(a, 0.15) # Image.fromarray(normal_map).show() tex = self.loader.load_texture('rock.jpg') ts = core.TextureStage('ts') tex.set_wrap_u(core.Texture.WM_clamp) tex.set_wrap_v(core.Texture.WM_clamp) self.devils_tower.set_texture(ts, tex) self.devils_tower.set_tex_scale(ts, 1) tex = core.Texture('dt_normal_map') tex.setup_2d_texture(y, x, core.Texture.T_unsigned_byte, core.Texture.F_rgb) tex.set_ram_image_as(normal_map, 'RGB') tex.set_wrap_u(core.Texture.WM_clamp) tex.set_wrap_v(core.Texture.WM_clamp) ts = core.TextureStage('ts') ts.set_mode(core.TextureStage.M_normal) tex.reload() self.devils_tower.set_texture(ts, tex)
def build(self): # configure beamer self.set_arena_mode('greenHDMI') self.cylinder_height, self.cylinder_radius, self.cylinder = tools.standard_cylinder(self.parent.mainNode) # paint the cylinder black on the ground tex_ground = tools.create_plain_texture(0) self.ts_ground = pcore.TextureStage('ts_ground') self.cylinder.setTexture(self.ts_ground, tex_ground) # generate textures anti_alias_texture_size = int(math.ceil(608./(math.degrees(math.atan(self.cylinder_height/2./self.cylinder_radius))*2/self.wave_length/0.9) - 2*4)/2. + 2) # empirically # unfortunately, MAdd Texture mode does not work together with the setColorScale - command from base.py # this means, that those textures that are added onto another one cannot be tinted in a certain color # hence, here we generate differently coloured texture from the beginning, depending on the temporal offset of the Stimulus World if self.t_offset == 0.: color_vector = [0,0,1] # blue elif self.t_offset == 1.: color_vector = [1,0,0] # red elif self.t_offset == 2.: color_vector = [0,1,0] # green # generate two sine gratings that are anti-phasic # then in the beginning everything is gray and on the left edge (phi = 0) the first polarity is dark self.tex = tools.create_coloured_sine_grating_texture(anti_alias_texture_size, self.min_intensity, self.max_intensity, color_vector=color_vector) self.tex2 = tools.create_coloured_sine_grating_texture(anti_alias_texture_size, self.max_intensity, self.min_intensity, color_vector=color_vector) # add the two sine gratings onto each other to generate a counterphase flicker self.ts1 = pcore.TextureStage('ts1') self.ts1.setMode(pcore.TextureStage.MAdd) self.ts2 = pcore.TextureStage('ts2') self.ts2.setMode(pcore.TextureStage.MAdd) self.cylinder.setTexture(self.ts1, self.tex) self.cylinder.setTexScale(self.ts1, 360.0/self.wave_length, math.degrees(math.atan(self.cylinder_height/2./self.cylinder_radius))*2/self.wave_length) self.cylinder.setTexRotate(self.ts1, -self.rotation) self.cylinder.setTexture(self.ts2, self.tex2) self.cylinder.setTexScale(self.ts2, 360.0/self.wave_length, math.degrees(math.atan(self.cylinder_height/2./self.cylinder_radius))*2/self.wave_length) self.cylinder.setTexRotate(self.ts2, -self.rotation) self.tex_offset = 0. self.cylinder.setTexOffset(self.ts1, (self.tex_offset + self.angle_function(0))/self.wave_length % 1, 0) self.cylinder.setTexOffset(self.ts2, (self.tex_offset - self.angle_function(0))/self.wave_length % 1, 0)
def build(self): # configure beamer self.set_arena_mode('greenHDMI') self.cylinder_height, self.cylinder_radius, self.cylinder = tools.standard_cylinder(self.parent.mainNode) self.cylinder.setColor(self.bg_intensity/255.,self.bg_intensity/255.,self.bg_intensity/255.,1) self.z = self.z * 10/5. self.dz = self.dz * 10/5. if self.dz > 26.: self.dz = 26. if self.dphi > 360.: self.dphi = 360. self.ts_window = pcore.TextureStage('ts_bar') tex_window = tools.create_window_texture(self.dphi, self.dz, self.bar_intensity, self.bg_intensity) self.cylinder.clearColor() self.cylinder.setTexture(self.ts_window, tex_window) # set starting point of bar depending if it will go rightwards or leftwards if self.velocity > 0: self.phi0 = -(90. + self.dphi/2.) elif self.velocity <= 0: self.phi0 = +(90. + self.dphi/2.) self.cylinder.setTexOffset(self.ts_window, -0.25 + self.dphi/2./360. - self.phi0/360., 0.5 - self.dz/2./26. - self.z/26.) self.T = (180. + self.dphi)/math.fabs(self.velocity)
def build(self): # configure beamer self.set_arena_mode('greenHDMI') self.cylinder_height, self.cylinder_radius, self.cylinder = tools.standard_cylinder(self.parent.mainNode) self.cylinder.setColor(self.bg_intensity/255.,self.bg_intensity/255.,self.bg_intensity/255.,1) # scale cylinder up in height in case the window texture is overlapping the edges self.cylinder_height = self.cylinder_height + self.dz * 2 self.cylinder.setScale(self.cylinder_radius,self.cylinder_radius,self.cylinder_height) self.dz = self.dz * 10/5. self.velocity = self.velocity * 10/5. if self.dz > 26.: self.dz = 26. if self.dphi > 360.: self.dphi = 360. self.ts_window = pcore.TextureStage('ts_bar') tex_window = tools.create_window_texture_set_size(self.dphi, self.dz, self.bar_intensity, self.bg_intensity, 360, int(self.cylinder_height/0.1)) self.cylinder.clearColor() self.cylinder.setTexture(self.ts_window, tex_window) # set starting point depending whether direction is downwards or upwards if self.velocity > 0: self.z0 = -(13 + self.dz/2.) elif self.velocity <= 0: self.z0 = (13 + self.dz/2.) self.cylinder.setTexOffset(self.ts_window, -0.25 + self.dphi/2./360. - self.phi/360., 0.5 - self.dz/2./self.cylinder_height - self.z0/self.cylinder_height) self.T = (26. + self.dz)/math.fabs(self.velocity)
def build(self): # configure beamer if self.color == 'b': self.set_arena_mode('optoblueHDMI') elif self.color == 'r': self.set_arena_mode('optoredHDMI') elif self.color == 'g': self.set_arena_mode('optogreenHDMI') self.cylinder_height, self.cylinder_radius, self.cylinder = tools.standard_cylinder(self.parent.mainNode) self.cylinder.setColor(self.min_intensity/255.,self.min_intensity/255.,self.min_intensity/255.,1) # set background color self.min_intensity = (self.min_intensity)/255. self.max_intensity = (self.max_intensity)/255. self.bg_intensity = self.min_intensity # create window self.ts_window = pcore.TextureStage('ts_window') #self.ts_window.setMode(pcore.TextureStage.MBlend) self.worlds_share(self.cylinder) # store cylinder in shared space to change its color synchronously in all color worlds self.pulse_done = False self.pulse_end = False
def build(self): # configure beamer self.set_arena_mode('greenHDMI') self.cylinder_height, self.cylinder_radius, self.cylinder = tools.standard_cylinder( self.parent.mainNode) self.cylinder_height = self.cylinder_height + self.dz * 2 self.cylinder.setScale(self.cylinder_radius, self.cylinder_radius, self.cylinder_height) self.ts_window = pcore.TextureStage('ts_window') self.plain_tex = tools.create_plain_texture(self.bg_intensity) self.cylinder.setTexture(self.ts_window, self.plain_tex) self.nr_before = 0 self.z = self.z * 10 / 5. self.dz = self.dz * 10 / 5. if self.dz > 26: self.dz = 26 if self.dphi > 360.: self.dphi = 360. self.tex_windowA = tools.create_window_texture_set_size( self.dphi, self.dz, self.max_intensity, self.bg_intensity, 360, int(self.cylinder_height / 0.1)) self.tex_windowB = tools.create_window_texture_set_size( self.dphi, self.dz, self.min_intensity, self.bg_intensity, 360, int(self.cylinder_height / 0.1)) self.cylinder.setTexOffset( self.ts_window, -(-self.dphi / 2. / 360. + self.phi / 360.), 0.5 - self.dz / 2. / self.cylinder_height - self.z / self.cylinder_height) # set up shared variables for synchronizing all color worlds self.shared.phi = self.phi self.shared.z = self.z self.shared.factor = 1 # set up keyboard commands for moving the window base.accept("arrow_right", self.increase_phi) base.accept("arrow_left", self.decrease_phi) base.accept("arrow_up", self.increase_z) base.accept("arrow_down", self.decrease_z) base.accept("arrow_right-repeat", self.increase_phi) base.accept("arrow_left-repeat", self.decrease_phi) base.accept("arrow_up-repeat", self.increase_z) base.accept("arrow_down-repeat", self.decrease_z)
def item_type(self, item_type: str) -> None: """ """ self._item_type = item_type item_data = runtime.library.itemData[item_type] images = item_data['Images'] detail = runtime.loader.load_texture(images['detail']) mask = runtime.loader.load_texture(images['mask']) mask_stage = p3d.TextureStage('mask') runtime.itemCard.set_texture_off() runtime.itemCard.set_texture(detail) runtime.itemCard.set_texture(mask_stage, mask) runtime.itemCard.set_transparency(True)
def place_trees(self): tex = core.Texture('roads') ts = core.TextureStage('ts') # noinspection PyArgumentList tex.setup_2d_texture(1024, 1024, core.Texture.T_float, core.Texture.F_rgb) bounds_tex = np.zeros((1024, 1024, 3), np.float32) bounds_tex[self.__bounds[:1024, :1024], :] = -0.05 # print(bounds_tex.shape) tex.set_ram_image_as(bounds_tex, 'RGB') tex.reload() ts.set_mode(core.TextureStage.M_add) # ts.set_combine_rgb( # core.TextureStage.CM_subtract, # core.TextureStage.CS_texture, # core.TextureStage.CO_src_color, # tex, # core.TextureStage.CO_src_color # ) self.terrain_root.set_texture(ts, tex) trees = [ random.choice((modelgen.fir_tree, modelgen.leaf_tree))() for _ in range(common.W_INDIVIDUAL_TREES) ] x = 3 y = 3 hs = common.T_XY * common.T_XY_SCALE / 2 while y < self.__woods.shape[0] - 3: step = np.random.randint(9, 30) x += step if x > self.__woods.shape[0] - 3: y += np.random.randint(10, 20) if y >= self.__woods.shape[0] - 3: break x = max(3, x % self.__woods.shape[0]) if not self.__woods[y, x]: continue node_path = self.tree_root.attach_new_node('fir_tree') orig, r = random.choice(trees) orig.copy_to(node_path) pos = core.Vec3( (x + random.random() - 0.5) * common.T_XY_SCALE - hs, (y + random.random() - 0.5) * common.T_XY_SCALE - hs, 0) self.collision.add(collision.CollisionCircle(pos.xy, r)) pos.z = self.sample_terrain_z(pos.x, pos.y) node_path.set_pos(pos)
def project(self): # project field of view of beamer N_x = int(self.arena.omega_h * 3) N_y = int(self.arena.omega_v * 3) grid_image = pcore.PNMImage(N_x, N_y) for i in range(N_x - 2): for j in range(N_y - 2): grid_image.setXelA(i + 1, j + 1, 0, 0, 0, 1) for i in range(N_x): grid_image.setXelA(i, 0, 1, 1, 1, 1) grid_image.setXelA(i, int(N_y / 2), 1, 1, 1, 1) grid_image.setXelA(i, N_y - 1, 1, 1, 1, 1) for i in range(N_y): grid_image.setXelA(0, i, 1, 1, 1, 1) grid_image.setXelA(int(N_x / 2), i, 1, 1, 1, 1) grid_image.setXelA(N_x - 1, i, 1, 1, 1, 1) self.tex_grid = pcore.Texture() self.tex_grid.load(grid_image) self.tex_grid.setMagfilter(pcore.Texture.FTNearest) self.proj = render.attachNewNode(pcore.LensNode('proj')) self.proj.node().setLens(self.lens) self.proj.reparentTo(self.beamer) self.ts = pcore.TextureStage('ts_proj') self.ts.setMode(pcore.TextureStage.MBlend) self.ts.setColor( pcore.Vec4(self.color[0], self.color[1], self.color[2], self.color[3])) self.tex_grid.setWrapU(pcore.Texture.WMBorderColor) self.tex_grid.setWrapV(pcore.Texture.WMBorderColor) self.screen.projectTexture(self.ts, self.tex_grid, self.proj) self.proj.node().showFrustum() self.proj.find('frustum').setColor(self.color[0], self.color[1], self.color[2], self.color[3])
from panda3d import core # Some dummy textures we can use for our texture attributes. stage1 = core.TextureStage("stage1") stage2 = core.TextureStage("stage2") stage3 = core.TextureStage("stage3") tex1 = core.Texture("tex1") tex2 = core.Texture("tex2") tex3 = core.Texture("tex3") def test_textureattrib_compose_add(): # Tests a case in which a child node adds another texture. tattr1 = core.TextureAttrib.make() tattr1 = tattr1.add_on_stage(stage1, tex1) tattr2 = core.TextureAttrib.make() tattr2 = tattr2.add_on_stage(stage2, tex2) tattr3 = tattr1.compose(tattr2) assert tattr3.get_num_on_stages() == 2 assert stage1 in tattr3.on_stages assert stage2 in tattr3.on_stages def test_textureattrib_compose_subtract(): # Tests a case in which a child node disables a texture. tattr1 = core.TextureAttrib.make() tattr1 = tattr1.add_on_stage(stage1, tex1) tattr1 = tattr1.add_on_stage(stage2, tex2)
def build(self): #, old_geometry): # configure beamer self.set_arena_mode('greenHDMI') self.cylinder_height, self.cylinder_radius, self.cylinder = tools.standard_cylinder( self.parent.mainNode) # make cylinder bigger in case the window is overlapping the edges and needs more space self.cylinder_height = self.cylinder_height + self.dz * 2 self.cylinder.setScale(self.cylinder_radius, self.cylinder_radius, self.cylinder_height) # like in default.PDNDgrating self.period = self.motion_T * 2 + self.pause * 2 self.T = 100000 # go on for eternity self.count_period = 0 # load texture anti_alias_texture_size = int( math.ceil(608. / (math.degrees( math.atan(self.cylinder_height / 2. / self.cylinder_radius)) * 2 / self.wave_length / 0.9) - 2 * 4) / 2. + 2) # empirically if self.mode == 'sin': self.tex = tools.create_sine_grating_texture( anti_alias_texture_size, self.min_intensity, self.max_intensity) elif self.mode == 'sq': self.tex = tools.create_grating_texture(anti_alias_texture_size, self.min_intensity, self.max_intensity) self.cylinder.setTexture(self.tex) # scale like in the normal PDNDgrating and then scale down even more by the factor between the bigger cylinder and the "normal" cylinder of height 26. #factor_visible = math.degrees(math.atan(26/2./self.cylinder_radius))*2/self.wave_length * self.cylinder_height/26. #self.cylinder.setTexScale(pcore.TextureStage.getDefault(), 360.0/self.wave_length, factor_visible) # visible cylinder height is 26 # generate wavelength by rescaling the texture ( which contains exact one period of the grating) in relation to the desired wavelength # for the horizontal component the scaling factor is given by the ratio between the cylinder width (360 degree) and the wavelength # for the vertical component the scaling factor is given by the ratio between 180 degree (because we would see the whole texture if the scaling factor would be 1) # and the wavelength times the aspect ratio of the arena screen (such that 45 degree remains 45 degree) # # NOTE: Using this convention the vertical scaling factor is given by the requirement that 45 degree generates exactly 45 degree on the arena screen # This scaling factor also defines how wide the bars will be in vertical direction. # Hence, the wavelength is strictly speaking defined only for horizontal gratings moving along the azimuth self.cylinder.setTexture(self.tex) #self.cylinder.setTexScale(pcore.TextureStage.getDefault(), 360.0/self.wave_length, math.degrees(math.atan(self.cylinder_height/2./self.cylinder_radius))*2/self.wave_length) self.cylinder.setTexScale( pcore.TextureStage.getDefault(), 360.0 / self.wave_length, 360.0 / self.wave_length / 2. / (10. * math.pi / self.cylinder_height)) self.cylinder.setTexRotate(pcore.TextureStage.getDefault(), -self.rotation) self.velocity = -self.velocity self.tex_offset = 0. self.cylinder.setTexOffset(pcore.TextureStage.getDefault(), (self.tex_offset + self.angle_function(0)) / self.wave_length % 1, 0) # create window self.z = self.z * 10 / 5. self.dz = self.dz * 10 / 5. if self.dz > 26: self.dz = 26 if self.dphi > 360.: self.dphi = 360. # create black/white mask for transparent area self.ts_window = pcore.TextureStage('ts_window') self.ts_window.setMode(pcore.TextureStage.MBlend) tex_window = tools.create_window_texture_set_size( self.dphi, self.dz, 0, 255, 360, int(self.cylinder_height / 0.1)) self.cylinder.setTexture(self.ts_window, tex_window) self.cylinder.setTexOffset( self.ts_window, -(-self.dphi / 2. / 360. + self.phi / 360.), 0.5 - self.dz / 2. / self.cylinder_height - self.z / self.cylinder_height) # set color of the background around the window self.ts_window.setColor( pcore.Vec4(self.bg_intensity / 255., self.bg_intensity / 255., self.bg_intensity / 255., 1)) # initialize variables to memorize phase of the stimulus self.stop1stdirection_trigger = True self.start2ndirection_trigger = True # set up shared variables for synchronizing all color worlds self.shared.phi = self.phi self.shared.z = self.z self.shared.factor = 1 # set up keyboard commands for moving the window base.accept("arrow_right", self.increase_phi) base.accept("arrow_left", self.decrease_phi) base.accept("arrow_up", self.increase_z) base.accept("arrow_down", self.decrease_z) base.accept("arrow_right-repeat", self.increase_phi) base.accept("arrow_left-repeat", self.decrease_phi) base.accept("arrow_up-repeat", self.increase_z) base.accept("arrow_down-repeat", self.decrease_z)
def __setup(self): # self.start_nonogram(0) if None in self.__solution: self.__generate_solution_cards() self.__root = None self.__base.get_children().detach() self.__root = self.__base.attach_new_node('CellRoot') self.__root.set_pos( -(common.NG_RADIUS * 2 + common.NG_PAD) * self.__yx[1] / 2, 0, (common.NG_RADIUS * 2 + common.NG_PAD) * self.__yx[0] / 2 ) c = core.CardMaker('nbg') c.set_frame(core.Vec4(-100, 100, -100, 100)) self.__card = self.__base.attach_new_node(c.generate()) self.__card.set_color(common.NG_BG_COLOR) self.__card.set_transparency(core.TransparencyAttrib.M_alpha) o = core.Vec3(0) o.xz = common.NG_OFFSET.xz self.__card.set_pos(o) self.__card.set_bin('fixed', 0) self.__card.set_depth_test(False) self.__card.set_depth_write(False) self.__h_txt_grid = [ [] for _ in range(self.__yx[0]) ] # type: List[List[core.NodePath]] self.__h_txt_values = [ [ '' for _ in range(5) ] for _ in range(self.__yx[0]) ] # type: List[List[str]] for h in self.__h_txt_values: h[0] = '0' self.__v_txt_grid = [ [] for _ in range(self.__yx[1]) ] # type: List[List[core.NodePath]] self.__v_txt_values = [ [ '' for _ in range(5) ] for _ in range(self.__yx[0]) ] # type: List[List[str]] for v in self.__v_txt_values: v[0] = '0' tex = core.Texture('cell_tex') tex.setup_2d_texture( *tuple(reversed(common.NG_TEX)), core.Texture.T_float, core.Texture.F_rgba ) tex.set_ram_image_as(util.bw_tex(*common.NG_TEX), 'RGBA') tex.set_wrap_u(core.Texture.WM_clamp) tex.set_wrap_v(core.Texture.WM_clamp) tex.reload() if self.__grid_nodes: self.__grid_nodes = [] self.__root.get_children().detach() cell_np = self.__root.attach_new_node( self.__sg.sphere( core.Vec3(0), core.Vec3.up(), common.NG_RADIUS, common.NG_POLY, name='cell 0/0', nac=False ) ) ts = core.TextureStage('ts') cell_np.set_texture(ts, tex, 1) cell_np.set_tex_offset(ts, 0.25, 0) cell_np.set_bin('fixed', 0) cell_np.set_depth_test(False) cell_np.set_depth_write(False) for y in range(self.__yx[0]): self.__grid_nodes.append([]) for x in range(self.__yx[1]): if x or y: node_path = self.__root.attach_new_node(f'cell {x}/{y}') cell_np.copy_to(node_path) node_path.set_pos( x * (common.NG_RADIUS + common.NG_PAD), 0, -y * (common.NG_RADIUS + common.NG_PAD) ) self.__grid_nodes[-1].append(node_path) else: self.__grid_nodes[-1].append(cell_np)