def test_sparse_array_clear_range(): # Not using parametrize because there are too many values for that. for mask in range(0x7f): for begin in range(8): for size in range(8): b = core.BitArray(mask) s = core.SparseArray(b) s.clear_range(begin, size) b.clear_range(begin, size) assert core.BitArray(s) == b assert s == core.SparseArray(b)
def test_sparse_array_bits_in_common(): """Tests SparseArray behavior for has_bits_in_common().""" s = core.SparseArray() t = core.SparseArray() s.set_range(2, 4) t.set_range(5, 4) assert s.has_bits_in_common(t) s = core.SparseArray() t = core.SparseArray() s.set_range(2, 4) t.set_range(6, 4) assert not s.has_bits_in_common(t)
def test_sparse_array_augm_assignment(): """Tests SparseArray behavior for augmented assignments.""" # test in-place bitshift to left s = t = core.SparseArray() t <<= 2 assert s is t # test in-place bitshift to right s = t = core.SparseArray() t >>= 2 assert s is t # test in-place bitwise AND s = t = core.SparseArray() u = core.SparseArray() t &= u assert s is t # test in-place bitwise OR s = t = core.SparseArray() u = core.SparseArray() t |= u assert s is t # test in-place bitwise XOR s = t = core.SparseArray() u = core.SparseArray() t ^= u assert s is t
def test_sparse_array_operations(): """Tests SparseArray behavior for various operations.""" # test bitshift to left s = core.SparseArray() s.set_bit(2) t = s << 2 assert t.get_bit(4) assert not t.get_bit(2) # test bitshift to right s = core.SparseArray() s.set_bit(4) t = s >> 2 assert t.get_bit(2) assert not t.get_bit(4) # test bitwise AND s = core.SparseArray() t = core.SparseArray() s.set_bit(2) s.set_bit(3) t.set_bit(1) t.set_bit(3) u = s & t assert not u.get_bit(0) assert not u.get_bit(1) assert not u.get_bit(2) assert u.get_bit(3) # test bitwise OR s = core.SparseArray() t = core.SparseArray() s.set_bit(2) s.set_bit(3) t.set_bit(1) t.set_bit(3) u = s | t assert not u.get_bit(0) assert u.get_bit(1) assert u.get_bit(2) assert u.get_bit(3) # test bitwise XOR s = core.SparseArray() t = core.SparseArray() s.set_bit(2) s.set_bit(3) t.set_bit(1) t.set_bit(3) u = s ^ t assert not u.get_bit(0) assert u.get_bit(1) assert u.get_bit(2) assert not u.get_bit(3)
def test_sparse_array_set_bit_to(): """Tests SparseArray behavior for set_bit_to().""" s = core.SparseArray() s.set_bit_to(5, True) assert s.get_bit(5) s = core.SparseArray.all_on() s.set_bit_to(5, False) assert not s.get_bit(5)
def test_sparse_array_nonzero(): sa = core.SparseArray() assert not sa sa.set_bit(0) assert sa sa = core.SparseArray.all_on() assert sa sa.clear_range(0, 100) assert sa
def test_sparse_array_set_clear_ranges(): """Tests SparseArray behavior for setting and clearing ranges.""" # test clear_range with single overlapping on-range # (clear_range extends beyond highest on-bit) s = core.SparseArray() s.set_range(2, 3) s.clear_range(3, 3) assert s.get_bit(2) assert not s.get_bit(3) # same as above, using set_range_to s = core.SparseArray() s.set_range_to(True, 2, 3) s.set_range_to(False, 3, 3) assert s.get_bit(2) assert not s.get_bit(3) # test clear_range using off-range which overlaps two on-ranges # (lowest off-bit in lowest on-range, highest off-bit in highest on-range) s = core.SparseArray() s.set_range(2, 3) s.set_range(7, 3) s.clear_range(3, 6) assert s.get_bit(2) assert not s.get_bit(3) assert not s.get_bit(8) assert s.get_bit(9) # same as above, using set_range_to s = core.SparseArray() s.set_range_to(True, 2, 3) s.set_range_to(True, 7, 3) s.set_range_to(False, 3, 6) assert s.get_bit(2) assert not s.get_bit(3) assert not s.get_bit(8) assert s.get_bit(9)
def test_sparse_array_pickle(): sa = core.SparseArray() assert sa == pickle.loads(pickle.dumps(sa, -1)) sa = core.SparseArray() sa.invert_in_place() assert sa == pickle.loads(pickle.dumps(sa, -1)) sa = core.SparseArray() sa.set_range(0, 2) sa.set_range(4, 4) assert sa == pickle.loads(pickle.dumps(sa, -1)) sa = core.SparseArray() sa.invert_in_place() sa.clear_range(2, 4) assert sa == pickle.loads(pickle.dumps(sa, -1)) sa = core.SparseArray() sa.invert_in_place() sa.clear_range(0, 2) sa.clear_range(4, 4) assert sa == pickle.loads(pickle.dumps(sa, -1))
def test_sparse_array_getstate(): sa = core.SparseArray() assert sa.__getstate__() == () sa = core.SparseArray() sa.invert_in_place() assert sa.__getstate__() == (0, ) sa = core.SparseArray() sa.set_range(0, 2) sa.set_range(4, 4) assert sa.__getstate__() == (0, 2, 4, 8) sa = core.SparseArray() sa.invert_in_place() sa.clear_range(2, 4) assert sa.__getstate__() == (0, 2, 6) sa = core.SparseArray() sa.invert_in_place() sa.clear_range(0, 2) sa.clear_range(4, 4) assert sa.__getstate__() == (2, 4, 8)
def __init__(self, render=None, sprite_map='', sprite_layout=(8, 8), loop=True, pool_size=1024, check_bounds=False, scale=0.02): self.render = render or base.render self.check_bounds = check_bounds self.scale = scale tex = base.loader.load_texture(sprite_map) tex.set_minfilter(core.SamplerState.FT_nearest) tex.set_magfilter(core.SamplerState.FT_nearest) tex.set_wrap_u(core.SamplerState.WM_repeat if loop else core. SamplerState.WM_clamp) tex.set_wrap_v(core.SamplerState.WM_repeat) self.geom_node = core.GeomNode('fireworks') path = self.render.attach_new_node(self.geom_node) path.set_render_mode_thickness(32) path.set_texture(tex) path.set_tex_gen(core.TextureStage.get_default(), core.TexGenAttrib.M_point_sprite) path.set_antialias(core.AntialiasAttrib.M_point) path.set_depth_test(True) path.set_depth_write(True) path.set_z(1.0) path.set_transparency(core.TransparencyAttrib.M_binary) path.set_shader( core.Shader.load(core.Shader.SL_GLSL, 'assets/shaders/bullet.vert', 'assets/shaders/bullet.frag')) path.set_shader_input('sprite_layout', sprite_layout) self.sprite_layout = sprite_layout self.root = path self._generate_pool(pool_size) self.patterns = [] self.pool_usage = core.SparseArray() self.clock = 0 self.colliders = [] self.accept('window-event', self._update_size) self._update_size(base.win)
def test_sparse_array_clear(): """Tests SparseArray behavior for clear().""" s = core.SparseArray.all_on() s.clear() assert s.is_zero() assert not s.is_inverse() assert s.get_num_subranges() == 0 assert s.get_num_on_bits() == 0 assert s.get_num_bits() == 0 s = core.SparseArray() s.set_range(5, 10) s.clear() assert s.is_zero() assert not s.is_inverse() assert s.get_num_subranges() == 0 assert s.get_num_on_bits() == 0 assert s.get_num_bits() == 0
def update(self, dt): if dt == 0: return geom = self.geom_node.modify_geom(0) vdata = geom.modify_vertex_data() rewriter = core.GeomVertexRewriter(vdata, 'vertex') for pattern in self.patterns[:]: point_range = pattern.range if self.clock >= pattern.life_expectancy: #TODO: delete bullets vdata.transform_vertices( core.Mat4.translate_mat((0, 0, -10000)), point_range) self.patterns.remove(pattern) self.pool_usage &= ~point_range #print("Freeing", point_range) continue vdata.transform_vertices(pattern.update_transform(dt), point_range) # Delete vertices out of bounds. delete_points = core.SparseArray() if self.colliders or self.check_bounds: for sri in range(point_range.get_num_subranges()): begin = point_range.get_subrange_begin(sri) end = point_range.get_subrange_end(sri) for i in range(begin, end): rewriter.set_row(i) pos = rewriter.get_data2() if self.check_bounds: if pos.y > base.cam.get_y( ) + 150 + base.player.cam_tilt * 32: delete_points.set_bit(i) continue left, right = base.trackgen.query(pos.y) if pos.x < left or pos.x > right: delete_points.set_bit(i) continue for node, radius_sq, callback in self.colliders: collider_pos = node.get_pos() if (collider_pos.xy - pos).length_squared() < radius_sq: # Read out sprite type to pass to collide callback, then call it reader = core.GeomVertexReader(vdata, 'offset') reader.set_row(i) type = int(reader.get_data2()[1]) taskMgr.add(callback(type)) delete_points.set_bit(i) if not delete_points.is_zero(): vdata.transform_vertices( core.Mat4.translate_mat((0, 0, -10000)), delete_points) inv_delete_points = ~delete_points point_range &= inv_delete_points self.pool_usage &= inv_delete_points #print("Freeing", delete_points) if point_range.is_zero(): self.patterns.remove(pattern) self.clock += dt