nonsensical-dev/zenyx-engine
nonsensical-dev/zenyx-engine
3
0
Fork 1
Code Issues 6 Pull requests 2 Projects 1 Releases Activity Actions

Merge pull request 'multi window support' from rendering into main

Browse source
This commit is contained in:
Caznix 2025-03-25 05:42:15 +00:00 • committed by BitSyndicate
commit ce4702ec5f
8 changed files with 150 additions and 135 deletions
Download patch file Download diff file Expand all files Collapse all files

64
.vscode/launch.json vendored Normal file
View file

@ -0,0 +1,64 @@
{
// Use IntelliSense to learn about possible attributes.
// Hover to view descriptions of existing attributes.
// For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
"version": "0.2.0",
"configurations": [
{
"type": "lldb",
"request": "launch",
"name": "Debug executable 'zenyx'",
"cargo": {
"args": [
"build",
"--bin=zenyx",
"--package=zenyx"
],
"filter": {
"name": "zenyx",
"kind": "bin"
}
},
"args": [],
"cwd": "${workspaceFolder}"
},
{
"type": "lldb",
"request": "launch",
"name": "Debug unit tests in executable 'zenyx'",
"cargo": {
"args": [
"test",
"--no-run",
"--bin=zenyx",
"--package=zenyx"
],
"filter": {
"name": "zenyx",
"kind": "bin"
}
},
"args": [],
"cwd": "${workspaceFolder}"
},
{
"type": "lldb",
"request": "launch",
"name": "Debug unit tests in library 'zen_core'",
"cargo": {
"args": [
"test",
"--no-run",
"--lib",
"--package=zen_core"
],
"filter": {
"name": "zen_core",
"kind": "lib"
}
},
"args": [],
"cwd": "${workspaceFolder}"
}
]
}

17
Cargo.lock generated
View file

@ -2200,14 +2200,29 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "784e0ac535deb450455cbfa28a6f0df145ea1bb7ae51b821cf5e7927fdcfbdd0"
dependencies = [
"pin-project-lite",
"tracing-attributes",
"tracing-core",
]
[[package]]
name = "tracing-attributes"
version = "0.1.28"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "395ae124c09f9e6918a2310af6038fba074bcf474ac352496d5910dd59a2226d"
dependencies = [
"proc-macro2",
"quote",
"syn",
]
[[package]]
name = "tracing-core"
version = "0.1.33"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e672c95779cf947c5311f83787af4fa8fffd12fb27e4993211a84bdfd9610f9c"
dependencies = [
"once_cell",
]
[[package]]
name = "ttf-parser"
@ -3109,13 +3124,13 @@ dependencies = [
"dirs-next",
"futures",
"lazy_static",
"log",
"once_cell",
"parking_lot",
"regex",
"rustyline",
"thiserror 2.0.12",
"tokio",
"tracing",
"wgpu",
"winit",
]

10
engine/Cargo.toml
View file

@ -12,18 +12,18 @@ crashreport = "1.0.1"
dirs-next = "2.0.0"
lazy_static.workspace = true
log = "0.4.22"
once_cell = "1.20.2"
once_cell = "1.21.1"
parking_lot.workspace = true
regex = "1.11.1"
rustyline = { version = "15.0.0", features = ["derive", "rustyline-derive"] }
thiserror = "2.0.11"
tokio = { version = "1.42.0", features = ["macros", "parking_lot","rt-multi-thread"] }
wgpu = "24.0.1"
winit = "0.30.8"
tokio = { version = "1.44.1", features = ["macros", "parking_lot","rt-multi-thread"] }
wgpu = "24.0.3"
winit = "0.30.9"
bytemuck = "1.21.0"
futures = "0.3.31"
cgmath = "0.18.0"
tracing = "0.1.41"
[profile.dev]

84
engine/src/core/logger/mod.rs
View file

@ -1,84 +0,0 @@
use std::fs::OpenOptions;
use std::io::{self, Write};
use std::sync::Arc;
use colored::Colorize;
use log::{Level, Log, Metadata, Record};
use once_cell::sync::Lazy;
use parking_lot::Mutex;
pub static LOGGER: Lazy<DynamicLogger> = Lazy::new(DynamicLogger::new);
// A logger that dynamically switches between file and stdout
pub struct DynamicLogger {
pub writer: Arc<Mutex<Box<dyn Write + Send>>>,
}
impl Default for DynamicLogger {
fn default() -> Self {
Self::new()
}
}
impl DynamicLogger {
pub fn new() -> Self {
Self {
writer: Arc::new(Mutex::new(Box::new(io::stdout()))),
}
}
pub fn write_to_file(&self, file_path: &str) {
let file = OpenOptions::new()
.create(true)
.append(true)
.open(file_path)
.expect("Failed to open log file");
*self.writer.lock() = Box::new(file);
}
pub fn write_to_stdout(&self) {
*self.writer.lock() = Box::new(io::stdout());
}
fn colorize_level(level: Level) -> colored::ColoredString {
match level {
Level::Error => "ERROR".red(),
Level::Warn => "WARN".yellow(),
Level::Info => "INFO".green(),
Level::Debug => "DEBUG".blue(),
Level::Trace => "TRACE".cyan(),
}
}
}
impl Log for DynamicLogger {
fn enabled(&self, metadata: &Metadata) -> bool {
let target = metadata.target();
let is_relevant_target = target.starts_with("wgpu")
|| target.starts_with("winit")
|| target.starts_with(env!("CARGO_PKG_NAME")); // Current crate name
is_relevant_target && metadata.level() <= Level::Debug
}
fn log(&self, record: &Record) {
if self.enabled(record.metadata()) {
let mut writer = self.writer.lock();
let level = Self::colorize_level(record.level()); // Apply coloring
writeln!(
writer,
"{} [{}] - {}",
chrono::Local::now().format("%Y-%m-%d %H:%M:%S"),
level,
record.args()
)
.unwrap();
}
}
fn flush(&self) {
let mut writer = self.writer.lock();
writer.flush().unwrap();
}
}

1
engine/src/core/mod.rs
View file

@ -1,5 +1,4 @@
pub mod ecs;
pub mod logger;
pub mod panic;
pub mod repl;
pub mod splash;

98
engine/src/core/render/mod.rs
View file

@ -1,7 +1,8 @@
use std::collections::HashMap;
use std::sync::Arc;
use ctx::WgpuCtx;
use log::{debug, trace};
use tracing::{debug, error, info, trace, warn};
use winit::application::ApplicationHandler;
use winit::event::WindowEvent;
use winit::event_loop::ControlFlow;
@ -9,76 +10,97 @@ use winit::event_loop::{ActiveEventLoop, EventLoop};
use winit::window::{Window, WindowId};
pub mod ctx;
struct WindowContext<'window> {
window: Arc<Window>,
ctx: WgpuCtx<'window>,
}
#[derive(Default)]
pub struct App<'window> {
window: Option<Arc<Window>>,
ctx: Option<WgpuCtx<'window>>,
windows: HashMap<WindowId, WindowContext<'window>>,
}
impl ApplicationHandler for App<'_> {
fn resumed(&mut self, event_loop: &ActiveEventLoop) {
if self.window.is_none() {
if self.windows.is_empty() {
let win_attr = Window::default_attributes().with_title("Zenyx");
let window = Arc::new(
event_loop
.create_window(win_attr)
.expect("create window err."),
);
self.window = Some(window.clone());
let window_id = window.id();
let wgpu_ctx = WgpuCtx::new_blocking(window.clone()).unwrap();
self.ctx = Some(wgpu_ctx)
self.windows.insert(window_id, WindowContext { window, ctx: wgpu_ctx });
}
}
fn window_event(
&mut self,
event_loop: &ActiveEventLoop,
_window_id: WindowId,
window_id: WindowId,
event: WindowEvent,
) {
match event {
WindowEvent::CloseRequested => {
event_loop.exit();
debug!("Window closed, exiting");
std::process::exit(0)
if let Some(window_context) = self.windows.remove(&window_id) {
drop(window_context);
println!("Window: {:?} closed, exiting", window_id);
}
if self.windows.is_empty() {
event_loop.exit();
}
}
WindowEvent::KeyboardInput { device_id, event, is_synthetic } => {
match event.physical_key {
winit::keyboard::PhysicalKey::Code(code) => {
if event.state.is_pressed() == false {
return;
}
if code == winit::keyboard::KeyCode::Escape {
// event_loop.exit();
debug!("Window closed, exiting");
if let Some(ctx) = &mut self.ctx {
match ctx.bg_color() {
wgpu::Color::WHITE => ctx.change_bg_color(wgpu::Color::BLACK),
wgpu::Color::BLACK => ctx.change_bg_color(wgpu::Color::WHITE),
_ => ctx.change_bg_color(wgpu::Color::WHITE),
WindowEvent::KeyboardInput {
device_id,
event,
is_synthetic,
} => match event.physical_key {
winit::keyboard::PhysicalKey::Code(code) => {
if event.state.is_pressed() == false {
return;
}
match code {
winit::keyboard::KeyCode::Space => {
debug!("Space key pressed");
if let Some(window_context) = self.windows.values_mut().next() {
match window_context.ctx.bg_color() {
wgpu::Color::WHITE => window_context.ctx.change_bg_color(wgpu::Color::BLACK),
wgpu::Color::BLACK => window_context.ctx.change_bg_color(wgpu::Color::WHITE),
_ => window_context.ctx.change_bg_color(wgpu::Color::WHITE),
}
}
// std::process::exit(0)
}
winit::keyboard::KeyCode::Escape => {
debug!("Escape key pressed, spawning new window");
let win_attr = Window::default_attributes()
.with_title(format!("Zenyx - New Window {}", self.windows.len()));
let new_window = Arc::new(
event_loop
.create_window(win_attr)
.expect("create window err."),
);
let window_id = new_window.id();
let wgpu_ctx = WgpuCtx::new_blocking(new_window.clone()).unwrap();
self.windows.insert(window_id, WindowContext { window: new_window, ctx: wgpu_ctx });
}
_ => info!("Unimplemented keycode: {:?}", code),
}
}
_ => {}
}
}
},
WindowEvent::RedrawRequested => {
if let Some(ctx) = &mut self.ctx {
ctx.draw();
}
if let Some(window) = &self.window {
window.request_redraw();
if let Some(window_context) = self.windows.get_mut(&window_id) {
window_context.ctx.draw();
window_context.window.request_redraw();
}
}
WindowEvent::Resized(size) => {
if let (Some(wgpu_ctx), Some(window)) = (&mut self.ctx, &self.window) {
wgpu_ctx.resize(size.into());
window.request_redraw();
let size_str: String = size.height.to_string() + "x" + &size.width.to_string();
//self.window.as_ref().unwrap().set_title(&format!("you reszed the window to
// {size_str}"));
if let Some(window_context) = self.windows.get_mut(&window_id) {
window_context.ctx.resize(size.into());
window_context.window.request_redraw();
let size_str: String =
size.height.to_string() + "x" + &size.width.to_string();
debug!("Window resized to {:?}", size_str);
}
}

7
engine/src/core/repl/input.rs
View file

@ -5,7 +5,6 @@ use std::{
use chrono::Local;
use colored::Colorize;
use log::debug;
use parking_lot::Mutex;
use regex::Regex;
use rustyline::{
@ -13,9 +12,9 @@ use rustyline::{
Hinter, KeyEvent, RepeatCount, Validator, completion::Completer, error::ReadlineError,
highlight::Highlighter, hint::HistoryHinter, history::DefaultHistory,
};
use tracing::{debug, error, info, warn};
use super::handler::COMMAND_MANAGER;
use crate::core::logger::LOGGER;
struct CommandCompleter;
impl CommandCompleter {
@ -89,9 +88,9 @@ impl ConditionalEventHandler for BacktickEventHandler {
if *state { "ON".green() } else { "OFF".red() }
);
if *state {
LOGGER.write_to_stdout();
// LOGGER.write_to_stdout();
} else {
LOGGER.write_to_file("z.log");
// LOGGER.write_to_file("z.log");
}
*state = !*state;
Some(Cmd::Noop)

4
engine/src/main.rs
View file

@ -1,10 +1,10 @@
use core::{panic::set_panic_hook, repl::setup, splash, workspace};
use colored::Colorize;
use log::info;
use tokio::runtime;
#[allow(unused_imports)]
use tracing::{debug, error, info, warn};
use winit::event_loop::EventLoop;
pub mod core;
#[tokio::main(flavor = "current_thread")]