def main():
scanner = SimpleScanner()
gl.glClearColor(0.1, 0.1, 0.2, 1.0)
timer_msec = int(1000 / 60) # 60 times per second
renderer = Renderer()
drawings_list = []
fish_queue = Queue(
) # Queue to maintain order of the fish and kill the oldest ones
fish_limit = 10 # Maximum amount of fish to draw
scanned_fish_queue = Queue()
draw_ocean(drawings_list)
fish_shader_program = Renderer.create_shader(gl.GL_VERTEX_SHADER,
FISH_SHADER_CODE)
bubble_texture = Renderer.create_texture_from_file(
'ocean/images/bubble.png')
load_fish_from_files(scanner, drawings_list, fish_queue,
fish_shader_program, bubble_texture)
glut.glutDisplayFunc(partial(renderer.render, drawings_list))
glut.glutIgnoreKeyRepeat(True)
glut.glutKeyboardFunc(create_key_processor(scanner, scanned_fish_queue))
glut.glutTimerFunc(
timer_msec,
create_animation_function(renderer, drawings_list, scanned_fish_queue,
fish_queue, fish_limit, timer_msec,
fish_shader_program, bubble_texture), 0)
glut.glutMainLoop()
def draw_sails(
drawings_list: List[Drawing],
shader: int,
) -> None:
"""
Support function to draw sails
:param drawings_list: List of sprites to draw
:param shader: Shader to animate the sails
:return:
"""
drawing = DrawingSeaweed(
Renderer.create_texture_from_file('ocean/images/sail_1.png'),
shader=shader)
drawing.position = np.array([1.2, -0.43, -0.77])
drawing.scale = np.array([0.6, 0.4, 1.0])
drawings_list.append(drawing)
drawing = DrawingSeaweed(
Renderer.create_texture_from_file('ocean/images/sail_2.png'),
shader=shader)
drawing.position = np.array([1.6, -0.34, -0.77])
drawing.scale = np.array([0.3, 0.5, 1.0])
drawings_list.append(drawing)
drawing = DrawingSeaweed(
Renderer.create_texture_from_file('ocean/images/sail_3.png'),
shader=shader)
drawing.position = np.array([1.7, -0.71, -0.77])
drawing.scale = np.array([0.2, 0.3, 1.0])
drawings_list.append(drawing)
def load_fish_from_files(
scanner: SimpleScanner,
drawings_list: List[Drawing],
fish_queue: Queue,
fish_shader_program: int = 0,
bubble_texture: int = 0,
) -> None:
"""
Load all the predrawing fish from the folder
:param scanner: Object of scanner to process photos
:param drawings_list: Lists of sprites to add fish in it
:param fish_queue: Queue to maintain order of fish
:param fish_shader_program: ID of fish shader
:param bubble_texture: ID of bubble texture
:return:
"""
files = glob('./photos/*.jpg')
for filename in files:
frame = cv2.imread(filename)
if frame is None:
raise ValueError(f'Error reading image with filename: {filename}')
scanned_fish = scan_from_frame(frame, scanner)
drawing = DrawingFish(Renderer.create_texture(scanned_fish),
shader=fish_shader_program,
bubble_texture_id=bubble_texture)
drawings_list.append(drawing)
fish_queue.put(drawing)
def create_back_layer(
filename: str,
z: float,
shader: int = 0,
) -> DrawingStatic:
"""
Create sprite for the scene background
:param filename: Path to the background image
:param z: Depth position of the sprite
:param shader: Shader ID for the background
:return: Sprite object for the background
"""
drawing_back = DrawingStatic(Renderer.create_texture_from_file(filename),
shader=shader)
drawing_back.position = np.array([0, 0., z])
drawing_back.scale = np.array([3.6, 2.0, 1.0])
return drawing_back
def animate(value):
renderer.animate(drawings_list)
glut.glutTimerFunc(timer_msec, animate, 0)
# Get fish scan from scanner thread
if scanned_fish_queue.qsize() > 0:
scanned_fish = scanned_fish_queue.get()
drawing = DrawingFish(Renderer.create_texture(scanned_fish),
shader=fish_shader_program,
bubble_texture_id=bubble_texture)
drawings_list.append(drawing)
fish_queue.put(drawing)
if fish_queue.qsize() > fish_limit:
fish = fish_queue.get()
fish.go_away()
# Remove dead fish from drawing list
for drawing in drawings_list:
if isinstance(drawing, DrawingFish) and not drawing.is_alive:
drawings_list.remove(drawing)
def draw_ocean(drawings_list: List[Drawing]) -> None:
"""
Draw all the sprites in the ocean scene
:param drawings_list: Lists of sprites to draw
:return:
"""
seaweed_shader_program = Renderer.create_shader(gl.GL_VERTEX_SHADER,
SEAWEED_SHADER_CODE)
drawings_list.append(create_back_layer('ocean/images/back_down.png', -0.8))
drawings_list.append(
create_back_layer('ocean/images/back_middle.png', -0.78))
drawings_list.append(create_back_layer('ocean/images/back_reef.png', 0.8))
draw_sails(drawings_list, seaweed_shader_program)
seaweed_texture = Renderer.create_texture_from_file(
'ocean/images/seaweed_2.png')
# Draw seaweed under the ship
drawing = DrawingSeaweed(seaweed_texture, shader=seaweed_shader_program)
drawing.position = np.array([1.2, 0.4, -0.75])
drawing.scale = np.array([0.8, 0.4, 1.0])
drawings_list.append(drawing)
seaweed_texture = Renderer.create_texture_from_file(
'ocean/images/seaweed_1.png')
# Draw seaweed in the right corner
drawing = DrawingSeaweed(seaweed_texture, shader=seaweed_shader_program)
drawing.position = np.array([1.2, 1.0, 0.9])
drawing.scale = np.array([0.8, 1.4, 1.0])
# drawing.color = np.array([0.5, 0.5, 1.0])
drawings_list.append(drawing)
# Draw seaweed in the front of the rock
drawing = DrawingSeaweed(seaweed_texture, shader=seaweed_shader_program)
drawing.position = np.array([0.2, 0.15, -0.7])
drawing.scale = np.array([0.4, 0.4, 1.0])
# drawing.color = np.array([0.6, 0.6, 1.0])
drawings_list.append(drawing)
seaweed_texture = Renderer.create_texture_from_file(
'ocean/images/seaweed_3.png')
# Draw seaweed in the left corner
drawing = DrawingSeaweed(seaweed_texture, shader=seaweed_shader_program)
drawing.position = np.array([-1.2, 0.6, 0.9])
drawing.scale = np.array([0.3, 1.0, 1.0])
# drawing.color = np.array([0.5, 0.5, 1.0])
drawings_list.append(drawing)
# Draw seaweed on the background
drawing = DrawingSeaweed(seaweed_texture, shader=seaweed_shader_program)
drawing.position = np.array([-0.8, -0.5, -0.795])
drawing.scale = np.array([0.3, 1.0, 1.0])
drawing.color = np.array([0.3, 0.3, 0.8])
drawings_list.append(drawing)
drawing = DrawingSeaweed(seaweed_texture, shader=seaweed_shader_program)
drawing.position = np.array([0.0, -0.2, -0.795])
drawing.scale = np.array([-0.3, 1.0, 1.0])
drawing.color = np.array([0.3, 0.3, 0.8])
drawings_list.append(drawing)
drawing = DrawingSeaweed(seaweed_texture, shader=seaweed_shader_program)
drawing.position = np.array([-0.4, -0.2, -0.795])
drawing.scale = np.array([0.1, 0.3, 1.0])
drawing.color = np.array([0.1, 0.1, 0.4])
drawings_list.append(drawing)
class Builder(Actor):
def __init__(self):
self.has_started = False
def replicate(self) -> 'Builder':
return Builder()
def act(self, sight: List[View]) -> Action:
action = Action.WORK if self.has_started else Action.START_REPLICA
self.has_started = True
return action
if __name__ == "__main__":
world = World(Vector(12, 12))
position = Vector(4, 4)
world.insert(Builder(), position, Direction.BACKWARD)
position = Direction.BACKWARD.translate_vector(position)
world.insert(Resource(), position, Direction.BACKWARD)
position = Direction.BACKWARD.translate_vector(position)
world.insert(Resource(), position, Direction.BACKWARD)
renderer = Renderer(world)
interactor = Interactor(world)
renderer.render()
for _ in range(12):
interactor.tick()
renderer.render()
def __init__(self,
game_name,
window_width,
window_height,
font,
fps=None,
floor_manager=None,
main_menu=None,
message_log=True):
# Game console props
self.game_name = game_name
self.window_width = window_width
self.window_height = window_height
self.font = font
self.fps = fps
# if the game had fps specified, update the console fps
if (self.fps != None):
tcod.sys_set_fps(self.fps)
# Initialize font
tcod.console_set_custom_font(self.font.path, self.font.options)
# Initialize root console
self.root_console = tcod.console_init_root(self.window_width,
self.window_height,
self.game_name)
# Initialize the main menu
self.main_menu = main_menu
if (self.main_menu):
self.main_menu.game = self
# Initially game is not running
self.game_state = "not_running"
# Additional props
self.props = {}
# Floor handling DEBUG bring into own handler class
if (floor_manager is None):
self.floor_manager = FloorManager((self.window_width * 3) // 4,
self.window_height,
game=self)
# Dashboards
self.dashboards = []
if (message_log == True):
margin = 4
message_log_dashboard = LogDashboard((self.window_width * 3) // 4,
margin,
self.window_width // 4,
self.window_height - margin,
messages=[])
add_dashboard_to_game(self, message_log_dashboard)
# World map
# TODO make the map width + height configurable
#self.map = GameMap((self.window_width * 3) // 4, self.window_height) DEAD
# Input handlers
self.input_handlers = []
#Renderer
self.game_renderer = Renderer(game=self)
class Game:
# params
# name of game, width of console window, height of console window, game font, game fps
def __init__(self,
game_name,
window_width,
window_height,
font,
fps=None,
floor_manager=None,
main_menu=None,
message_log=True):
# Game console props
self.game_name = game_name
self.window_width = window_width
self.window_height = window_height
self.font = font
self.fps = fps
# if the game had fps specified, update the console fps
if (self.fps != None):
tcod.sys_set_fps(self.fps)
# Initialize font
tcod.console_set_custom_font(self.font.path, self.font.options)
# Initialize root console
self.root_console = tcod.console_init_root(self.window_width,
self.window_height,
self.game_name)
# Initialize the main menu
self.main_menu = main_menu
if (self.main_menu):
self.main_menu.game = self
# Initially game is not running
self.game_state = "not_running"
# Additional props
self.props = {}
# Floor handling DEBUG bring into own handler class
if (floor_manager is None):
self.floor_manager = FloorManager((self.window_width * 3) // 4,
self.window_height,
game=self)
# Dashboards
self.dashboards = []
if (message_log == True):
margin = 4
message_log_dashboard = LogDashboard((self.window_width * 3) // 4,
margin,
self.window_width // 4,
self.window_height - margin,
messages=[])
add_dashboard_to_game(self, message_log_dashboard)
# World map
# TODO make the map width + height configurable
#self.map = GameMap((self.window_width * 3) // 4, self.window_height) DEAD
# Input handlers
self.input_handlers = []
#Renderer
self.game_renderer = Renderer(game=self)
# Start the main game loop
def start_loop(self, logic):
# set the game to be running
if (self.main_menu):
self.game_state = "in_menu"
else:
self.game_state = "playing"
# game loop
while (self.game_state != "not_running"):
# game logic
logic(self)
# TODO
# run through all the input handlers
# Render
if (self.game_state == "playing"):
self.game_renderer.render_all()
self.game_renderer.update_console()
self.game_renderer.clear_all()
elif (self.game_state == "in_menu"):
# TODO implement me
self.game_renderer.render_menu(self.main_menu)
self.game_renderer.update_console()
tcod.console_clear(self.root_console)
# Stop the game loop
def stop_loop(self):
self.game_state = "not_running"
args = parse_args()
ti.init(arch=ti.cuda,
use_unified_memory=False,
device_memory_GB=args.gpu_memory)
output_folder = args.out_dir
os.makedirs(output_folder, exist_ok=True)
from engine.renderer import Renderer
res = args.res
renderer = Renderer(dx=1 / res,
sphere_radius=0.3 / res,
shutter_time=args.shutter_time,
max_num_particles_million=args.max_particles,
taichi_logo=False)
with_gui = args.gui
if with_gui:
gui = ti.GUI('Particle Renderer', (1280, 720))
spp = 200
# 0.23, (0.0, 0.8, 5.5)
def main():
for f in range(args.begin, args.end, args.step):
print('frame', f, end=' ')