97 lines
4.1 KiB
Python
97 lines
4.1 KiB
Python
from typing import Optional
|
|
import pathlib
|
|
import numpy as np
|
|
from nonebot import logger
|
|
|
|
PATH = pathlib.Path(__file__).parent / "shaders" / "frag.glsl"
|
|
with PATH.open(encoding="utf-8") as f:
|
|
FS_SRC = f.read()
|
|
|
|
class Scene:
|
|
def __init__(self, _instruction: str) -> None:
|
|
from konabot.plugins.marchtoy.command import CommandChainParser, CommandParser
|
|
from konabot.plugins.marchtoy.op import OPERATION_ENTRIES
|
|
from konabot.plugins.marchtoy.obj import Object, Camera, OBJECT_ENTRIES
|
|
logger.info(f"building scene: {_instruction}")
|
|
self.canvas_objs: list[tuple[Object, str]] = []
|
|
self.camera: Camera = Camera()
|
|
for raw_cmd in CommandChainParser(_instruction):
|
|
cmd_queue = CommandParser(raw_cmd)
|
|
cmd_obj = next(cmd_queue)
|
|
obj_id, obj_args = cmd_obj.id, cmd_obj.args
|
|
logger.info(f"parsing object: {obj_id} with args {obj_args}")
|
|
obj_instance: Optional[Object] = None
|
|
if obj_id in OBJECT_ENTRIES:
|
|
obj_cls = OBJECT_ENTRIES[obj_id]
|
|
if not issubclass(obj_cls, Object):
|
|
raise Exception(f"{obj_id} is not a subclass of Object.")
|
|
obj_instance = obj_cls()
|
|
try:
|
|
if len(obj_args) != 0:
|
|
obj_instance.parse_args(obj_args)
|
|
except Exception as e:
|
|
raise Exception(
|
|
f"object {obj_id} failed to parse args passed in: {obj_args}.\n{e}"
|
|
) from e
|
|
else:
|
|
raise Exception(f"{obj_id} is not a valid object type.")
|
|
logger.info(f"parsed object {obj_id}({obj_args})")
|
|
if obj_instance != None:
|
|
for cmd in cmd_queue:
|
|
op_id, op_args = cmd.id, cmd.args
|
|
logger.info(f"parsing operation {op_id} with args {op_args}")
|
|
if op_id in OPERATION_ENTRIES:
|
|
op_func = OPERATION_ENTRIES[op_id]
|
|
if not callable(op_func):
|
|
raise Exception(f"{op_id} is not a valid operation.")
|
|
op_func(obj_instance, op_args)
|
|
else:
|
|
raise Exception(f"{op_id} is not a valid operation.")
|
|
logger.info(f"parsed operation {op_id}({op_args})")
|
|
|
|
try:
|
|
sdf_block = obj_instance.sdf_block_glsl()
|
|
self.canvas_objs.append((obj_instance, sdf_block))
|
|
logger.info(f"parsed sdf {sdf_block}")
|
|
except:
|
|
logger.info(f"parsed camera")
|
|
if type(obj_instance) == Camera:
|
|
self.camera = obj_instance
|
|
|
|
def __str__(self) -> str:
|
|
return ", ".join([str(type(obj)) for obj in self.canvas_objs])
|
|
|
|
def compile(self) -> str:
|
|
|
|
sdf_block: str = ""
|
|
color_block: str = ""
|
|
|
|
index = 0
|
|
for canvas_item in self.canvas_objs:
|
|
obj, sdf_expr = canvas_item
|
|
sdf_block += f"float sd{index} = {sdf_expr};"
|
|
sdf_block += f"if(sd{index} < qry.value)"
|
|
sdf_block += "{" + f"qry.value = sd{index}; qry.obj_id = {index}; " + "}\n"
|
|
color = obj.texture.color
|
|
color_block += (
|
|
f"if(obj_id == {index}) return vec4("
|
|
f"{color[0]}, {color[1]}, {color[2]}, {color[3]});\n"
|
|
)
|
|
index += 1
|
|
|
|
content = FS_SRC
|
|
content = content.replace("<SDF_BLOCK>", sdf_block)
|
|
content = content.replace("<COLOR_BLOCK>", color_block)
|
|
|
|
cam_pos = self.camera.transform.t[0:3, 3]
|
|
cam_focus = self.camera.focus
|
|
cam_dir = self.camera.transform.t @ np.array((0.0, 0.0, -1.0, 0.0))
|
|
content = content.replace(
|
|
"<CAM_POS>", f"{cam_pos[0]}, {cam_pos[1]}, {cam_pos[2]}"
|
|
)
|
|
content = content.replace("<CAM_FOCUS>", str(cam_focus))
|
|
content = content.replace(
|
|
"<CAM_DIR>", f"{cam_dir[0]}, {cam_dir[1]}, {cam_dir[2]}"
|
|
)
|
|
return content
|