mirror of
https://github.com/Yonokid/PyTaiko.git
synced 2026-02-04 19:50:12 +01:00
447 lines
19 KiB
Python
447 lines
19 KiB
Python
import ctypes
|
||
import hashlib
|
||
import sys
|
||
import logging
|
||
import time
|
||
from libs.global_data import PlayerNum, global_data
|
||
from pathlib import Path
|
||
from typing import Optional
|
||
|
||
import pyray as ray
|
||
import raylib as rl
|
||
from raylib import (
|
||
SHADER_UNIFORM_FLOAT,
|
||
SHADER_UNIFORM_VEC2,
|
||
SHADER_UNIFORM_VEC4,
|
||
)
|
||
|
||
from libs.texture import TextureWrapper
|
||
|
||
logger = logging.getLogger(__name__)
|
||
|
||
def force_dedicated_gpu():
|
||
"""Force Windows to use dedicated GPU for this application"""
|
||
if sys.platform == "win32":
|
||
try:
|
||
# NVIDIA Optimus
|
||
nvapi = ctypes.windll.kernel32.LoadLibraryW("nvapi64.dll")
|
||
if nvapi:
|
||
ctypes.windll.kernel32.SetEnvironmentVariableW("SHIM_MCCOMPAT", "0x800000001")
|
||
except Exception as e:
|
||
logger.error(e)
|
||
|
||
def rounded(num: float) -> int:
|
||
"""Round a number to the nearest integer"""
|
||
sign = 1 if (num >= 0) else -1
|
||
num = abs(num)
|
||
result = int(num)
|
||
if (num - result >= 0.5):
|
||
result += 1
|
||
return sign * result
|
||
|
||
def get_current_ms() -> int:
|
||
"""Get the current time in milliseconds"""
|
||
return rounded(time.time() * 1000)
|
||
|
||
def strip_comments(code: str) -> str:
|
||
"""Strip comments from a string of code"""
|
||
result = ''
|
||
index = 0
|
||
for line in code.splitlines():
|
||
comment_index = line.find('//')
|
||
if comment_index == -1:
|
||
result += line
|
||
elif comment_index != 0 and not line[:comment_index].isspace():
|
||
result += line[:comment_index]
|
||
index += 1
|
||
return result
|
||
|
||
def is_input_key_pressed(keys: list[int], gamepad_buttons: list[int]):
|
||
if global_data.input_locked:
|
||
return False
|
||
for key in keys:
|
||
if rl.IsKeyPressed(key):
|
||
return True
|
||
|
||
if rl.IsGamepadAvailable(0):
|
||
for button in gamepad_buttons:
|
||
if rl.IsGamepadButtonPressed(0, button):
|
||
return True
|
||
|
||
return False
|
||
|
||
def is_l_don_pressed(player_num: PlayerNum = PlayerNum.ALL) -> bool:
|
||
"""Check if the left don button is pressed"""
|
||
if player_num == PlayerNum.ALL:
|
||
keys = global_data.config["keys_1p"]["left_don"] + global_data.config["keys_2p"]["left_don"]
|
||
elif player_num == PlayerNum.P1:
|
||
keys = global_data.config["keys_1p"]["left_don"]
|
||
elif player_num == PlayerNum.P2:
|
||
keys = global_data.config["keys_2p"]["left_don"]
|
||
else:
|
||
return False
|
||
gamepad_buttons = global_data.config["gamepad"]["left_don"]
|
||
return is_input_key_pressed(keys, gamepad_buttons)
|
||
|
||
def is_r_don_pressed(player_num: PlayerNum = PlayerNum.ALL) -> bool:
|
||
"""Check if the right don button is pressed"""
|
||
if player_num == PlayerNum.ALL:
|
||
keys = global_data.config["keys_1p"]["right_don"] + global_data.config["keys_2p"]["right_don"]
|
||
elif player_num == PlayerNum.P1:
|
||
keys = global_data.config["keys_1p"]["right_don"]
|
||
elif player_num == PlayerNum.P2:
|
||
keys = global_data.config["keys_2p"]["right_don"]
|
||
else:
|
||
return False
|
||
gamepad_buttons = global_data.config["gamepad"]["right_don"]
|
||
return is_input_key_pressed(keys, gamepad_buttons)
|
||
|
||
def is_l_kat_pressed(player_num: PlayerNum = PlayerNum.ALL) -> bool:
|
||
"""Check if the left kat button is pressed"""
|
||
if player_num == PlayerNum.ALL:
|
||
keys = global_data.config["keys_1p"]["left_kat"] + global_data.config["keys_2p"]["left_kat"]
|
||
elif player_num == PlayerNum.P1:
|
||
keys = global_data.config["keys_1p"]["left_kat"]
|
||
elif player_num == PlayerNum.P2:
|
||
keys = global_data.config["keys_2p"]["left_kat"]
|
||
else:
|
||
return False
|
||
gamepad_buttons = global_data.config["gamepad"]["left_kat"]
|
||
return is_input_key_pressed(keys, gamepad_buttons)
|
||
|
||
def is_r_kat_pressed(player_num: PlayerNum = PlayerNum.ALL) -> bool:
|
||
"""Check if the right kat button is pressed"""
|
||
if player_num == PlayerNum.ALL:
|
||
keys = global_data.config["keys_1p"]["right_kat"] + global_data.config["keys_2p"]["right_kat"]
|
||
elif player_num == PlayerNum.P1:
|
||
keys = global_data.config["keys_1p"]["right_kat"]
|
||
elif player_num == PlayerNum.P2:
|
||
keys = global_data.config["keys_2p"]["right_kat"]
|
||
else:
|
||
return False
|
||
gamepad_buttons = global_data.config["gamepad"]["right_kat"]
|
||
return is_input_key_pressed(keys, gamepad_buttons)
|
||
|
||
global_tex = TextureWrapper()
|
||
|
||
text_cache = set()
|
||
if not Path('cache/image').exists():
|
||
if not Path('cache').exists():
|
||
Path('cache').mkdir()
|
||
Path('cache/image').mkdir()
|
||
|
||
for file in Path('cache/image').iterdir():
|
||
text_cache.add(file.stem)
|
||
|
||
class OutlinedText:
|
||
"""Create an outlined text object."""
|
||
def __init__(self, text: str, font_size: int, color: ray.Color, outline_thickness=5.0, vertical=False):
|
||
"""
|
||
Create an outlined text object.
|
||
|
||
Args:
|
||
text (str): The text to be displayed.
|
||
font_size (int): The size of the font.
|
||
color (ray.Color): The color of the text.
|
||
outline_color (ray.Color): The color of the outline.
|
||
outline_thickness (float): The thickness of the outline.
|
||
vertical (bool): Whether the text is vertical or not.
|
||
"""
|
||
self.text = text
|
||
self.hash = self._hash_text(text, font_size, color, vertical)
|
||
self.outline_thickness = outline_thickness * global_tex.screen_scale
|
||
self.vertical = vertical
|
||
if self.hash in text_cache:
|
||
self.texture = ray.load_texture(f'cache/image/{self.hash}.png')
|
||
else:
|
||
self.font = self._load_font_for_text(text)
|
||
if vertical:
|
||
self.texture = self._create_text_vertical(text, font_size, color, ray.BLANK, self.font)
|
||
else:
|
||
self.texture = self._create_text_horizontal(text, font_size, color, ray.BLANK, self.font)
|
||
ray.gen_texture_mipmaps(self.texture)
|
||
ray.set_texture_filter(self.texture, ray.TextureFilter.TEXTURE_FILTER_TRILINEAR)
|
||
outline_size = ray.ffi.new('float*', self.outline_thickness)
|
||
texture_size = ray.ffi.new("float[2]", [self.texture.width, self.texture.height])
|
||
|
||
self.shader = ray.load_shader('shader/outline.vs', 'shader/outline.fs')
|
||
self.outline_size_loc = ray.get_shader_location(self.shader, "outlineSize")
|
||
self.outline_color_loc = ray.get_shader_location(self.shader, "outlineColor")
|
||
self.texture_size_loc = ray.get_shader_location(self.shader, "textureSize")
|
||
self.alpha_loc = ray.get_shader_location(self.shader, "alpha")
|
||
ray.set_shader_value(self.shader, self.outline_size_loc, outline_size, SHADER_UNIFORM_FLOAT)
|
||
ray.set_shader_value(self.shader, self.texture_size_loc, texture_size, SHADER_UNIFORM_VEC2)
|
||
|
||
self.default_src = ray.Rectangle(0, 0, self.texture.width, self.texture.height)
|
||
|
||
def _hash_text(self, text: str, font_size: int, color: ray.Color, vertical: bool):
|
||
n = hashlib.sha256()
|
||
n.update(text.encode('utf-8'))
|
||
n.update(str(font_size).encode('utf-8'))
|
||
if isinstance(color, tuple):
|
||
n.update(str(color[0]).encode('utf-8'))
|
||
n.update(str(color[1]).encode('utf-8'))
|
||
n.update(str(color[2]).encode('utf-8'))
|
||
n.update(str(color[3]).encode('utf-8'))
|
||
else:
|
||
n.update(str(color.r).encode('utf-8'))
|
||
n.update(str(color.g).encode('utf-8'))
|
||
n.update(str(color.b).encode('utf-8'))
|
||
n.update(str(color.a).encode('utf-8'))
|
||
n.update(str(vertical).encode('utf-8'))
|
||
return n.hexdigest()
|
||
|
||
def _load_font_for_text(self, text: str) -> ray.Font:
|
||
reload_font = False
|
||
for character in text:
|
||
if character not in global_data.font_codepoints:
|
||
global_data.font_codepoints.add(character)
|
||
reload_font = True
|
||
if reload_font:
|
||
codepoint_count = ray.ffi.new('int *', 0)
|
||
codepoints = ray.load_codepoints(''.join(global_data.font_codepoints), codepoint_count)
|
||
global_data.font = ray.load_font_ex(str(Path('Graphics/Modified-DFPKanteiryu-XB.ttf')), 40, codepoints, len(global_data.font_codepoints))
|
||
logger.info(f"Reloaded font with {len(global_data.font_codepoints)} codepoints")
|
||
return global_data.font
|
||
|
||
def _create_text_vertical(self, text: str, font_size: int, color: ray.Color, bg_color: ray.Color, font: Optional[ray.Font]=None, padding: int=10):
|
||
rotate_chars = {'-', '‐', '|', '/', '\\', 'ー', '～', '~', '（', '）', '(', ')',
|
||
'「', '」', '[', ']', '［', '］', '【', '】', '…', '→', '→', ':', '：'}
|
||
side_punctuation = {'.', ',', '。', '、', "'", '"', '´', '`'}
|
||
horizontal_punct = {'?', '!', '？', '！', '†'} # Characters that should be drawn horizontally when repeated
|
||
lowercase_kana = {
|
||
'ぁ', 'ア','ぃ', 'イ','ぅ', 'ウ','ぇ', 'エ','ぉ', 'オ',
|
||
'ゃ', 'ャ','ゅ', 'ュ','ょ', 'ョ','っ', 'ッ','ゎ', 'ヮ',
|
||
'ヶ', 'ヵ','ㇰ','ㇱ','ㇲ','ㇳ','ㇴ','ㇵ','ㇶ','ㇷ','ㇸ',
|
||
'ㇹ','ㇺ','ㇻ','ㇼ','ㇽ','ㇾ','ㇿ'
|
||
}
|
||
|
||
# Group consecutive horizontal punctuation marks
|
||
def group_horizontal_sequences(text):
|
||
groups = []
|
||
i = 0
|
||
while i < len(text):
|
||
if text[i] in horizontal_punct:
|
||
# Start of a horizontal sequence
|
||
sequence = text[i]
|
||
j = i + 1
|
||
# Continue collecting consecutive horizontal punctuation
|
||
while j < len(text) and text[j] in horizontal_punct:
|
||
sequence += text[j]
|
||
j += 1
|
||
|
||
# Only treat as horizontal if there are 2 or more characters
|
||
if len(sequence) >= 2:
|
||
groups.append(('horizontal', sequence))
|
||
else:
|
||
groups.append(('single', sequence))
|
||
i = j
|
||
else:
|
||
groups.append(('single', text[i]))
|
||
i += 1
|
||
return groups
|
||
|
||
# Helper function to calculate adjusted character height
|
||
def get_char_height(char):
|
||
if char in side_punctuation:
|
||
return font_size // 4
|
||
elif char.islower() or char in lowercase_kana:
|
||
return font_size * 0.88
|
||
elif char.isspace():
|
||
return font_size * 0.6
|
||
else:
|
||
return font_size
|
||
|
||
grouped_text = group_horizontal_sequences(text)
|
||
|
||
# Calculate dimensions with proper height adjustments
|
||
max_char_width = 0
|
||
total_height = padding * 2
|
||
|
||
for group_type, content in grouped_text:
|
||
if group_type == 'horizontal':
|
||
# For horizontal sequences, measure the combined width
|
||
if font:
|
||
seq_size = ray.measure_text_ex(font, content, font_size, 0)
|
||
else:
|
||
seq_width = ray.measure_text(content, font_size)
|
||
seq_size = ray.Vector2(seq_width, font_size)
|
||
max_char_width = max(max_char_width, seq_size.x)
|
||
total_height += font_size # Horizontal sequences use full font_size
|
||
else:
|
||
# Single character
|
||
char = content
|
||
if font:
|
||
char_size = ray.measure_text_ex(font, char, font_size, 0)
|
||
else:
|
||
char_width = ray.measure_text(char, font_size)
|
||
char_size = ray.Vector2(char_width, font_size)
|
||
|
||
if char in rotate_chars:
|
||
effective_width = char_size.y
|
||
else:
|
||
effective_width = char_size.x
|
||
max_char_width = max(max_char_width, effective_width)
|
||
|
||
# Use the adjusted height instead of fixed font_size
|
||
total_height += get_char_height(char)
|
||
|
||
width = int(max_char_width + (padding * 2))
|
||
height = int(total_height) # Make sure it's an integer
|
||
image = ray.gen_image_color(width, height, bg_color)
|
||
|
||
curr_char_y = padding - font_size
|
||
|
||
for group_type, content in grouped_text:
|
||
if group_type == 'horizontal':
|
||
# Handle horizontal punctuation sequence
|
||
char_y = font_size
|
||
curr_char_y += char_y
|
||
|
||
if font:
|
||
seq_size = ray.measure_text_ex(font, content, font_size, 0)
|
||
seq_image = ray.image_text_ex(font, content, font_size, 0, color)
|
||
else:
|
||
seq_width = ray.measure_text(content, font_size)
|
||
seq_size = ray.Vector2(seq_width, font_size)
|
||
seq_image = ray.image_text(content, font_size, color)
|
||
|
||
# Center the horizontal sequence
|
||
char_x = width // 2 - seq_size.x // 2
|
||
|
||
ray.image_draw(image, seq_image,
|
||
ray.Rectangle(0, 0, seq_image.width, seq_image.height),
|
||
ray.Rectangle(char_x, curr_char_y, seq_image.width, seq_image.height),
|
||
ray.WHITE)
|
||
ray.unload_image(seq_image)
|
||
|
||
else:
|
||
# Handle single character (existing logic)
|
||
char = content
|
||
char_y = get_char_height(char) # Use the helper function
|
||
curr_char_y += char_y
|
||
|
||
if font:
|
||
char_size = ray.measure_text_ex(font, char, font_size, 0)
|
||
char_image = ray.image_text_ex(font, char, font_size, 0, color)
|
||
else:
|
||
char_width = ray.measure_text(char, font_size)
|
||
char_size = ray.Vector2(char_width, font_size)
|
||
char_image = ray.image_text(char, font_size, color)
|
||
|
||
if char in rotate_chars:
|
||
rotated_image = ray.gen_image_color(char_image.height, char_image.width, ray.BLANK)
|
||
for y in range(char_image.height):
|
||
for x in range(char_image.width):
|
||
src_color = ray.get_image_color(char_image, x, y)
|
||
new_x = char_image.height - 1 - y
|
||
new_y = x
|
||
ray.image_draw_pixel(rotated_image, new_x, new_y, src_color)
|
||
ray.unload_image(char_image)
|
||
char_image = rotated_image
|
||
effective_width = char_size.y
|
||
else:
|
||
effective_width = char_size.x
|
||
|
||
char_x = width // 2 - effective_width // 2
|
||
if char in side_punctuation:
|
||
char_x += font_size//3
|
||
|
||
ray.image_draw(image, char_image,
|
||
ray.Rectangle(0, 0, char_image.width, char_image.height),
|
||
ray.Rectangle(char_x, curr_char_y, char_image.width, char_image.height),
|
||
ray.WHITE)
|
||
ray.unload_image(char_image)
|
||
|
||
ray.export_image(image, f'cache/image/{self.hash}.png')
|
||
texture = ray.load_texture_from_image(image)
|
||
ray.unload_image(image)
|
||
return texture
|
||
|
||
def _create_text_horizontal(self, text: str, font_size: int, color: ray.Color, bg_color: ray.Color, font: Optional[ray.Font]=None, padding: int=10):
|
||
if font:
|
||
text_size = ray.measure_text_ex(font, text, font_size, 0)
|
||
total_width = text_size.x + (padding * 2)
|
||
total_height = text_size.y + (padding * 2)
|
||
else:
|
||
total_width = ray.measure_text(text, font_size) + (padding * 2)
|
||
total_height = font_size + (padding * 2)
|
||
image = ray.gen_image_color(int(total_width), int(total_height), bg_color)
|
||
if font:
|
||
text_image = ray.image_text_ex(font, text, font_size, 0, color)
|
||
else:
|
||
text_image = ray.image_text(text, font_size, color)
|
||
text_x = padding
|
||
text_y = padding
|
||
ray.image_draw(image, text_image,
|
||
ray.Rectangle(0, 0, text_image.width, text_image.height),
|
||
ray.Rectangle(text_x, text_y, text_image.width, text_image.height),
|
||
ray.WHITE)
|
||
ray.unload_image(text_image)
|
||
|
||
ray.export_image(image, f'cache/image/{self.hash}.png')
|
||
texture = ray.load_texture_from_image(image)
|
||
ray.unload_image(image)
|
||
return texture
|
||
|
||
def draw(self, outline_color: ray.Color=ray.BLANK, color: ray.Color=ray.WHITE, scale: float = 1.0, center: bool = False,
|
||
x: float = 0, y: float = 0, x2: float = 0, y2: float = 0,
|
||
origin: ray.Vector2 = ray.Vector2(0,0), rotation: float = 0, fade: float = 1.1) -> None:
|
||
"""
|
||
Wrapper function for raylib's draw_texture_pro().
|
||
Parameters:
|
||
outline_color (ray.Color): The color to outline the text.
|
||
color (ray.Color): The color to tint the text.
|
||
x (float): An x-value added to the top-left corner of the text.
|
||
y (float): The y-value added to the top-left corner of the text.
|
||
x2 (float): The x-value added to the bottom-right corner of the text.
|
||
y2 (float): The y-value added to the bottom-right corner of the text.
|
||
origin (ray.Vector2): The origin point of the text.
|
||
rotation (float): The rotation angle of the text.
|
||
fade (float): The fade factor to apply to the text.
|
||
"""
|
||
if isinstance(outline_color, tuple):
|
||
outline_color_alloc = ray.ffi.new("float[4]", [
|
||
outline_color[0] / 255.0,
|
||
outline_color[1] / 255.0,
|
||
outline_color[2] / 255.0,
|
||
outline_color[3] / 255.0
|
||
])
|
||
else:
|
||
outline_color_alloc = ray.ffi.new("float[4]", [
|
||
outline_color.r / 255.0,
|
||
outline_color.g / 255.0,
|
||
outline_color.b / 255.0,
|
||
outline_color.a / 255.0
|
||
])
|
||
ray.set_shader_value(self.shader, self.outline_color_loc, outline_color_alloc, SHADER_UNIFORM_VEC4)
|
||
if isinstance(color, tuple):
|
||
alpha_value = ray.ffi.new('float*', min(fade * 255, color[3]) / 255.0)
|
||
else:
|
||
alpha_value = ray.ffi.new('float*', min(fade * 255, color.a) / 255.0)
|
||
if fade != 1.1:
|
||
final_color = ray.fade(color, fade)
|
||
else:
|
||
final_color = color
|
||
ray.set_shader_value(self.shader, self.alpha_loc, alpha_value, SHADER_UNIFORM_FLOAT)
|
||
if not self.vertical:
|
||
offset = (10 * global_tex.screen_scale)-10
|
||
else:
|
||
offset = 0
|
||
dest_rect = ray.Rectangle(x, y+offset, self.texture.width+x2, self.texture.height+y2)
|
||
if self.outline_thickness > 0:
|
||
ray.begin_shader_mode(self.shader)
|
||
ray.draw_texture_pro(self.texture, self.default_src, dest_rect, origin, rotation, final_color)
|
||
if self.outline_thickness > 0:
|
||
ray.end_shader_mode()
|
||
|
||
def unload(self):
|
||
"""
|
||
Unload the outlined text object.
|
||
|
||
Args:
|
||
None
|
||
"""
|
||
ray.unload_shader(self.shader)
|
||
ray.unload_texture(self.texture)
|