801 lines
25 KiB
Rust
801 lines
25 KiB
Rust
//! Main engine implementation.
|
||
//! 主引擎实现。
|
||
|
||
use wasm_bindgen::prelude::*;
|
||
|
||
use super::context::WebGLContext;
|
||
use super::error::Result;
|
||
use crate::input::InputManager;
|
||
use crate::renderer::{Renderer2D, GridRenderer, GizmoRenderer, TransformMode, ViewportManager};
|
||
use crate::resource::TextureManager;
|
||
|
||
/// Engine configuration options.
|
||
/// 引擎配置选项。
|
||
#[derive(Debug, Clone)]
|
||
pub struct EngineConfig {
|
||
/// Maximum sprites per batch.
|
||
/// 每批次最大精灵数。
|
||
pub max_sprites: usize,
|
||
|
||
/// Enable debug mode.
|
||
/// 启用调试模式。
|
||
pub debug: bool,
|
||
}
|
||
|
||
impl Default for EngineConfig {
|
||
fn default() -> Self {
|
||
Self {
|
||
max_sprites: 10000,
|
||
debug: false,
|
||
}
|
||
}
|
||
}
|
||
|
||
/// Main game engine.
|
||
/// 主游戏引擎。
|
||
///
|
||
/// Coordinates all engine subsystems including rendering, input, and resources.
|
||
/// 协调所有引擎子系统，包括渲染、输入和资源。
|
||
pub struct Engine {
|
||
/// WebGL context.
|
||
/// WebGL上下文。
|
||
context: WebGLContext,
|
||
|
||
/// 2D renderer.
|
||
/// 2D渲染器。
|
||
renderer: Renderer2D,
|
||
|
||
/// Grid renderer for editor.
|
||
/// 编辑器网格渲染器。
|
||
grid_renderer: GridRenderer,
|
||
|
||
/// Gizmo renderer for editor overlays.
|
||
/// 编辑器叠加层Gizmo渲染器。
|
||
gizmo_renderer: GizmoRenderer,
|
||
|
||
/// Texture manager.
|
||
/// 纹理管理器。
|
||
texture_manager: TextureManager,
|
||
|
||
/// Input manager.
|
||
/// 输入管理器。
|
||
input_manager: InputManager,
|
||
|
||
/// Engine configuration.
|
||
/// 引擎配置。
|
||
#[allow(dead_code)]
|
||
config: EngineConfig,
|
||
|
||
/// Whether to show grid.
|
||
/// 是否显示网格。
|
||
show_grid: bool,
|
||
|
||
/// Viewport manager for multi-viewport rendering.
|
||
/// 多视口渲染的视口管理器。
|
||
viewport_manager: ViewportManager,
|
||
|
||
/// Whether to show gizmos.
|
||
/// 是否显示辅助工具。
|
||
show_gizmos: bool,
|
||
|
||
/// Whether the engine is running in editor mode.
|
||
/// 引擎是否在编辑器模式下运行。
|
||
///
|
||
/// When false (runtime mode), editor-only UI like grid, gizmos,
|
||
/// and axis indicator are automatically hidden.
|
||
/// 当为 false（运行时模式）时，编辑器专用 UI（如网格、gizmos、坐标轴指示器）会自动隐藏。
|
||
is_editor: bool,
|
||
}
|
||
|
||
impl Engine {
|
||
/// Create a new engine instance.
|
||
/// 创建新的引擎实例。
|
||
///
|
||
/// # Arguments | 参数
|
||
/// * `canvas_id` - The HTML canvas element ID | HTML canvas元素ID
|
||
/// * `config` - Engine configuration | 引擎配置
|
||
///
|
||
/// # Returns | 返回
|
||
/// A new Engine instance or an error | 新的Engine实例或错误
|
||
pub fn new(canvas_id: &str, config: EngineConfig) -> Result<Self> {
|
||
let context = WebGLContext::new(canvas_id)?;
|
||
|
||
// Initialize WebGL state | 初始化WebGL状态
|
||
context.set_viewport();
|
||
context.enable_blend();
|
||
|
||
// Create subsystems | 创建子系统
|
||
let renderer = Renderer2D::new(context.gl(), config.max_sprites)?;
|
||
let grid_renderer = GridRenderer::new(context.gl())?;
|
||
let gizmo_renderer = GizmoRenderer::new(context.gl())?;
|
||
let texture_manager = TextureManager::new(context.gl().clone());
|
||
let input_manager = InputManager::new();
|
||
|
||
log::info!("Engine created successfully | 引擎创建成功");
|
||
|
||
Ok(Self {
|
||
context,
|
||
renderer,
|
||
grid_renderer,
|
||
gizmo_renderer,
|
||
texture_manager,
|
||
input_manager,
|
||
config,
|
||
show_grid: true,
|
||
viewport_manager: ViewportManager::new(),
|
||
show_gizmos: true,
|
||
is_editor: true, // 默认为编辑器模式 | Default to editor mode
|
||
})
|
||
}
|
||
|
||
/// Create a new engine instance from external WebGL context.
|
||
/// 从外部 WebGL 上下文创建引擎实例。
|
||
///
|
||
/// This is designed for environments like WeChat MiniGame.
|
||
/// 适用于微信小游戏等环境。
|
||
pub fn from_external(
|
||
gl_context: JsValue,
|
||
width: u32,
|
||
height: u32,
|
||
config: EngineConfig,
|
||
) -> Result<Self> {
|
||
let context = WebGLContext::from_external(gl_context, width, height)?;
|
||
|
||
context.set_viewport();
|
||
context.enable_blend();
|
||
|
||
let renderer = Renderer2D::new(context.gl(), config.max_sprites)?;
|
||
let grid_renderer = GridRenderer::new(context.gl())?;
|
||
let gizmo_renderer = GizmoRenderer::new(context.gl())?;
|
||
let texture_manager = TextureManager::new(context.gl().clone());
|
||
let input_manager = InputManager::new();
|
||
|
||
log::info!("Engine created from external context | 从外部上下文创建引擎");
|
||
|
||
Ok(Self {
|
||
context,
|
||
renderer,
|
||
grid_renderer,
|
||
gizmo_renderer,
|
||
texture_manager,
|
||
input_manager,
|
||
config,
|
||
show_grid: true,
|
||
viewport_manager: ViewportManager::new(),
|
||
show_gizmos: true,
|
||
is_editor: true, // 默认为编辑器模式 | Default to editor mode
|
||
})
|
||
}
|
||
|
||
/// Clear the screen with specified color.
|
||
/// 使用指定颜色清除屏幕。
|
||
pub fn clear(&self, r: f32, g: f32, b: f32, a: f32) {
|
||
self.context.clear(r, g, b, a);
|
||
}
|
||
|
||
/// Get canvas width.
|
||
/// 获取画布宽度。
|
||
#[inline]
|
||
pub fn width(&self) -> u32 {
|
||
self.context.width()
|
||
}
|
||
|
||
/// Get canvas height.
|
||
/// 获取画布高度。
|
||
#[inline]
|
||
pub fn height(&self) -> u32 {
|
||
self.context.height()
|
||
}
|
||
|
||
/// Submit sprite batch data for rendering.
|
||
/// 提交精灵批次数据进行渲染。
|
||
pub fn submit_sprite_batch(
|
||
&mut self,
|
||
transforms: &[f32],
|
||
texture_ids: &[u32],
|
||
uvs: &[f32],
|
||
colors: &[u32],
|
||
material_ids: &[u32],
|
||
) -> Result<()> {
|
||
self.renderer.submit_batch(
|
||
transforms,
|
||
texture_ids,
|
||
uvs,
|
||
colors,
|
||
material_ids,
|
||
&self.texture_manager,
|
||
)
|
||
}
|
||
|
||
/// Render the current frame.
|
||
/// 渲染当前帧。
|
||
pub fn render(&mut self) -> Result<()> {
|
||
// Clear background with clear color
|
||
let [r, g, b, a] = self.renderer.get_clear_color();
|
||
self.context.clear(r, g, b, a);
|
||
|
||
// Render grid first (background) - only in editor mode
|
||
// 首先渲染网格（背景）- 仅在编辑器模式下
|
||
if self.is_editor && self.show_grid {
|
||
self.grid_renderer.render(self.context.gl(), self.renderer.camera());
|
||
self.grid_renderer.render_axes(self.context.gl(), self.renderer.camera());
|
||
}
|
||
|
||
// Render sprites
|
||
self.renderer.render(self.context.gl(), &self.texture_manager)?;
|
||
|
||
// Render gizmos on top - only in editor mode
|
||
// 在顶部渲染 gizmos - 仅在编辑器模式下
|
||
if self.is_editor && self.show_gizmos {
|
||
self.gizmo_renderer.render(self.context.gl(), self.renderer.camera());
|
||
// Render axis indicator in corner
|
||
// 在角落渲染坐标轴指示器
|
||
self.gizmo_renderer.render_axis_indicator(
|
||
self.context.gl(),
|
||
self.context.width() as f32,
|
||
self.context.height() as f32,
|
||
);
|
||
}
|
||
self.gizmo_renderer.clear();
|
||
|
||
Ok(())
|
||
}
|
||
|
||
/// Render sprites only without clearing the screen.
|
||
/// 仅渲染精灵，不清除屏幕。
|
||
///
|
||
/// This is used for overlay rendering (e.g., UI layer on top of world).
|
||
/// 用于叠加渲染（例如，UI 层叠加在世界上）。
|
||
pub fn render_overlay(&mut self) -> Result<()> {
|
||
// Render sprites without clearing
|
||
// 渲染精灵但不清屏
|
||
self.renderer.render(self.context.gl(), &self.texture_manager)?;
|
||
Ok(())
|
||
}
|
||
|
||
/// Add a rectangle gizmo.
|
||
/// 添加矩形Gizmo。
|
||
pub fn add_gizmo_rect(
|
||
&mut self,
|
||
x: f32,
|
||
y: f32,
|
||
width: f32,
|
||
height: f32,
|
||
rotation: f32,
|
||
origin_x: f32,
|
||
origin_y: f32,
|
||
r: f32,
|
||
g: f32,
|
||
b: f32,
|
||
a: f32,
|
||
show_handles: bool,
|
||
) {
|
||
self.gizmo_renderer.add_rect(x, y, width, height, rotation, origin_x, origin_y, r, g, b, a, show_handles);
|
||
}
|
||
|
||
/// Add a circle gizmo.
|
||
/// 添加圆形Gizmo。
|
||
pub fn add_gizmo_circle(
|
||
&mut self,
|
||
x: f32,
|
||
y: f32,
|
||
radius: f32,
|
||
r: f32,
|
||
g: f32,
|
||
b: f32,
|
||
a: f32,
|
||
) {
|
||
self.gizmo_renderer.add_circle(x, y, radius, r, g, b, a);
|
||
}
|
||
|
||
/// Add a line gizmo.
|
||
/// 添加线条Gizmo。
|
||
pub fn add_gizmo_line(
|
||
&mut self,
|
||
points: Vec<f32>,
|
||
r: f32,
|
||
g: f32,
|
||
b: f32,
|
||
a: f32,
|
||
closed: bool,
|
||
) {
|
||
self.gizmo_renderer.add_line(points, r, g, b, a, closed);
|
||
}
|
||
|
||
/// Add a capsule gizmo.
|
||
/// 添加胶囊Gizmo。
|
||
pub fn add_gizmo_capsule(
|
||
&mut self,
|
||
x: f32,
|
||
y: f32,
|
||
radius: f32,
|
||
half_height: f32,
|
||
rotation: f32,
|
||
r: f32,
|
||
g: f32,
|
||
b: f32,
|
||
a: f32,
|
||
) {
|
||
self.gizmo_renderer.add_capsule(x, y, radius, half_height, rotation, r, g, b, a);
|
||
}
|
||
|
||
/// Set transform tool mode.
|
||
/// 设置变换工具模式。
|
||
pub fn set_transform_mode(&mut self, mode: u8) {
|
||
let transform_mode = match mode {
|
||
1 => TransformMode::Move,
|
||
2 => TransformMode::Rotate,
|
||
3 => TransformMode::Scale,
|
||
_ => TransformMode::Select,
|
||
};
|
||
self.gizmo_renderer.set_transform_mode(transform_mode);
|
||
}
|
||
|
||
/// Load a texture from URL.
|
||
/// 从URL加载纹理。
|
||
pub fn load_texture(&mut self, id: u32, url: &str) -> Result<()> {
|
||
self.texture_manager.load_texture(id, url)
|
||
}
|
||
|
||
/// Load texture by path, returning texture ID.
|
||
/// 按路径加载纹理，返回纹理ID。
|
||
pub fn load_texture_by_path(&mut self, path: &str) -> Result<u32> {
|
||
self.texture_manager.load_texture_by_path(path)
|
||
}
|
||
|
||
/// Get texture ID by path.
|
||
/// 按路径获取纹理ID。
|
||
pub fn get_texture_id_by_path(&self, path: &str) -> Option<u32> {
|
||
self.texture_manager.get_texture_id_by_path(path)
|
||
}
|
||
|
||
/// Get or load texture by path.
|
||
/// 按路径获取或加载纹理。
|
||
pub fn get_or_load_by_path(&mut self, path: &str) -> Result<u32> {
|
||
self.texture_manager.get_or_load_by_path(path)
|
||
}
|
||
|
||
/// Clear the texture path cache.
|
||
/// 清除纹理路径缓存。
|
||
///
|
||
/// This should be called when restoring scene snapshots to ensure
|
||
/// textures are reloaded with correct IDs.
|
||
/// 在恢复场景快照时应调用此方法，以确保纹理使用正确的ID重新加载。
|
||
pub fn clear_texture_path_cache(&mut self) {
|
||
self.texture_manager.clear_path_cache();
|
||
}
|
||
|
||
/// Clear all textures and reset state.
|
||
/// 清除所有纹理并重置状态。
|
||
///
|
||
/// This removes all loaded textures from GPU memory and resets the ID counter.
|
||
/// 这会从GPU内存中移除所有已加载的纹理并重置ID计数器。
|
||
pub fn clear_all_textures(&mut self) {
|
||
self.texture_manager.clear_all();
|
||
}
|
||
|
||
/// 获取纹理加载状态
|
||
/// Get texture loading state
|
||
pub fn get_texture_state(&self, id: u32) -> crate::renderer::texture::TextureState {
|
||
self.texture_manager.get_texture_state(id)
|
||
}
|
||
|
||
/// 检查纹理是否已就绪
|
||
/// Check if texture is ready to use
|
||
pub fn is_texture_ready(&self, id: u32) -> bool {
|
||
self.texture_manager.is_texture_ready(id)
|
||
}
|
||
|
||
/// 获取正在加载中的纹理数量
|
||
/// Get the number of textures currently loading
|
||
pub fn get_texture_loading_count(&self) -> u32 {
|
||
self.texture_manager.get_loading_count()
|
||
}
|
||
|
||
/// Check if a key is currently pressed.
|
||
/// 检查某个键是否当前被按下。
|
||
pub fn is_key_down(&self, key_code: &str) -> bool {
|
||
self.input_manager.is_key_down(key_code)
|
||
}
|
||
|
||
/// Update input state.
|
||
/// 更新输入状态。
|
||
pub fn update_input(&mut self) {
|
||
self.input_manager.update();
|
||
}
|
||
|
||
/// Resize viewport.
|
||
/// 调整视口大小。
|
||
pub fn resize(&mut self, width: f32, height: f32) {
|
||
self.context.resize(width as u32, height as u32);
|
||
self.renderer.resize(width, height);
|
||
}
|
||
|
||
/// Set camera position, zoom, and rotation.
|
||
/// 设置相机位置、缩放和旋转。
|
||
///
|
||
/// # Arguments | 参数
|
||
/// * `x` - Camera X position | 相机X位置
|
||
/// * `y` - Camera Y position | 相机Y位置
|
||
/// * `zoom` - Zoom level | 缩放级别
|
||
/// * `rotation` - Rotation in radians | 旋转角度（弧度）
|
||
pub fn set_camera(&mut self, x: f32, y: f32, zoom: f32, rotation: f32) {
|
||
let camera = self.renderer.camera_mut();
|
||
camera.position.x = x;
|
||
camera.position.y = y;
|
||
camera.set_zoom(zoom);
|
||
camera.rotation = rotation;
|
||
}
|
||
|
||
/// Get camera position.
|
||
/// 获取相机位置。
|
||
pub fn get_camera(&self) -> (f32, f32, f32, f32) {
|
||
let camera = self.renderer.camera();
|
||
(camera.position.x, camera.position.y, camera.zoom, camera.rotation)
|
||
}
|
||
|
||
/// Convert screen coordinates to world coordinates.
|
||
/// 将屏幕坐标转换为世界坐标。
|
||
///
|
||
/// # Arguments | 参数
|
||
/// * `screen_x` - Screen X coordinate (0 = left edge of canvas)
|
||
/// * `screen_y` - Screen Y coordinate (0 = top edge of canvas)
|
||
///
|
||
/// # Returns | 返回
|
||
/// Tuple of (world_x, world_y)
|
||
pub fn screen_to_world(&self, screen_x: f32, screen_y: f32) -> (f32, f32) {
|
||
let camera = self.renderer.camera();
|
||
let world = camera.screen_to_world(crate::math::Vec2::new(screen_x, screen_y));
|
||
(world.x, world.y)
|
||
}
|
||
|
||
/// Convert world coordinates to screen coordinates.
|
||
/// 将世界坐标转换为屏幕坐标。
|
||
///
|
||
/// # Arguments | 参数
|
||
/// * `world_x` - World X coordinate
|
||
/// * `world_y` - World Y coordinate
|
||
///
|
||
/// # Returns | 返回
|
||
/// Tuple of (screen_x, screen_y)
|
||
pub fn world_to_screen(&self, world_x: f32, world_y: f32) -> (f32, f32) {
|
||
let camera = self.renderer.camera();
|
||
let screen = camera.world_to_screen(crate::math::Vec2::new(world_x, world_y));
|
||
(screen.x, screen.y)
|
||
}
|
||
|
||
/// Set grid visibility.
|
||
/// 设置网格可见性。
|
||
pub fn set_show_grid(&mut self, show: bool) {
|
||
self.show_grid = show;
|
||
}
|
||
|
||
/// Set gizmo visibility.
|
||
/// 设置辅助工具可见性。
|
||
pub fn set_show_gizmos(&mut self, show: bool) {
|
||
self.show_gizmos = show;
|
||
}
|
||
|
||
/// Get gizmo visibility.
|
||
/// 获取辅助工具可见性。
|
||
pub fn show_gizmos(&self) -> bool {
|
||
self.show_gizmos
|
||
}
|
||
|
||
/// Set editor mode.
|
||
/// 设置编辑器模式。
|
||
///
|
||
/// When false (runtime mode), editor-only UI like grid, gizmos,
|
||
/// and axis indicator are automatically hidden regardless of their individual settings.
|
||
/// 当为 false（运行时模式）时，编辑器专用 UI（如网格、gizmos、坐标轴指示器）
|
||
/// 会自动隐藏，无论它们的单独设置如何。
|
||
pub fn set_editor_mode(&mut self, is_editor: bool) {
|
||
self.is_editor = is_editor;
|
||
}
|
||
|
||
/// Get editor mode.
|
||
/// 获取编辑器模式。
|
||
pub fn is_editor(&self) -> bool {
|
||
self.is_editor
|
||
}
|
||
|
||
/// Set clear color for the active viewport.
|
||
/// 设置活动视口的清除颜色。
|
||
pub fn set_clear_color(&mut self, r: f32, g: f32, b: f32, a: f32) {
|
||
if let Some(target) = self.viewport_manager.active_mut() {
|
||
target.set_clear_color(r, g, b, a);
|
||
} else {
|
||
// Fallback to primary renderer
|
||
self.renderer.set_clear_color(r, g, b, a);
|
||
}
|
||
}
|
||
|
||
// ===== Multi-viewport API =====
|
||
// ===== 多视口 API =====
|
||
|
||
/// Register a new viewport.
|
||
/// 注册新视口。
|
||
pub fn register_viewport(&mut self, id: &str, canvas_id: &str) -> Result<()> {
|
||
self.viewport_manager.register(id, canvas_id)
|
||
}
|
||
|
||
/// Unregister a viewport.
|
||
/// 注销视口。
|
||
pub fn unregister_viewport(&mut self, id: &str) {
|
||
self.viewport_manager.unregister(id);
|
||
}
|
||
|
||
/// Set the active viewport.
|
||
/// 设置活动视口。
|
||
pub fn set_active_viewport(&mut self, id: &str) -> bool {
|
||
self.viewport_manager.set_active(id)
|
||
}
|
||
|
||
/// Get active viewport ID.
|
||
/// 获取活动视口ID。
|
||
pub fn active_viewport_id(&self) -> Option<&str> {
|
||
self.viewport_manager.active().map(|v| v.id.as_str())
|
||
}
|
||
|
||
/// Set camera for a specific viewport.
|
||
/// 为特定视口设置相机。
|
||
pub fn set_viewport_camera(&mut self, viewport_id: &str, x: f32, y: f32, zoom: f32, rotation: f32) {
|
||
if let Some(viewport) = self.viewport_manager.get_mut(viewport_id) {
|
||
viewport.set_camera(x, y, zoom, rotation);
|
||
}
|
||
}
|
||
|
||
/// Get camera for a specific viewport.
|
||
/// 获取特定视口的相机。
|
||
pub fn get_viewport_camera(&self, viewport_id: &str) -> Option<(f32, f32, f32, f32)> {
|
||
self.viewport_manager.get(viewport_id).map(|v| v.get_camera())
|
||
}
|
||
|
||
/// Set viewport configuration.
|
||
/// 设置视口配置。
|
||
pub fn set_viewport_config(&mut self, viewport_id: &str, show_grid: bool, show_gizmos: bool) {
|
||
if let Some(viewport) = self.viewport_manager.get_mut(viewport_id) {
|
||
viewport.config.show_grid = show_grid;
|
||
viewport.config.show_gizmos = show_gizmos;
|
||
}
|
||
}
|
||
|
||
/// Resize a specific viewport.
|
||
/// 调整特定视口大小。
|
||
pub fn resize_viewport(&mut self, viewport_id: &str, width: u32, height: u32) {
|
||
if let Some(viewport) = self.viewport_manager.get_mut(viewport_id) {
|
||
viewport.resize(width, height);
|
||
}
|
||
}
|
||
|
||
/// Render to a specific viewport.
|
||
/// 渲染到特定视口。
|
||
pub fn render_to_viewport(&mut self, viewport_id: &str) -> Result<()> {
|
||
let viewport = match self.viewport_manager.get(viewport_id) {
|
||
Some(v) => v,
|
||
None => return Ok(()),
|
||
};
|
||
|
||
// Get viewport settings
|
||
let show_grid = viewport.config.show_grid;
|
||
let show_gizmos = viewport.config.show_gizmos;
|
||
let camera = viewport.camera.clone();
|
||
|
||
// Bind viewport and clear
|
||
viewport.bind();
|
||
viewport.clear();
|
||
|
||
// Update renderer camera to match viewport camera
|
||
let renderer_camera = self.renderer.camera_mut();
|
||
renderer_camera.position = camera.position;
|
||
renderer_camera.set_zoom(camera.zoom);
|
||
renderer_camera.rotation = camera.rotation;
|
||
renderer_camera.set_viewport(camera.viewport_width(), camera.viewport_height());
|
||
|
||
// Render grid if enabled - only in editor mode
|
||
// 渲染网格（如果启用）- 仅在编辑器模式下
|
||
if self.is_editor && show_grid {
|
||
self.grid_renderer.render(viewport.gl(), &camera);
|
||
self.grid_renderer.render_axes(viewport.gl(), &camera);
|
||
}
|
||
|
||
// Render sprites
|
||
self.renderer.render(viewport.gl(), &self.texture_manager)?;
|
||
|
||
// Render gizmos if enabled - only in editor mode
|
||
// 渲染 gizmos（如果启用）- 仅在编辑器模式下
|
||
if self.is_editor && show_gizmos {
|
||
self.gizmo_renderer.render(viewport.gl(), &camera);
|
||
// Render axis indicator in corner
|
||
// 在角落渲染坐标轴指示器
|
||
let (vp_width, vp_height) = viewport.dimensions();
|
||
self.gizmo_renderer.render_axis_indicator(
|
||
viewport.gl(),
|
||
vp_width as f32,
|
||
vp_height as f32,
|
||
);
|
||
}
|
||
self.gizmo_renderer.clear();
|
||
|
||
Ok(())
|
||
}
|
||
|
||
/// Get all registered viewport IDs.
|
||
/// 获取所有已注册的视口ID。
|
||
pub fn viewport_ids(&self) -> Vec<String> {
|
||
self.viewport_manager.viewport_ids().into_iter().cloned().collect()
|
||
}
|
||
|
||
// ===== Shader Management =====
|
||
// ===== 着色器管理 =====
|
||
|
||
/// Compile and register a custom shader.
|
||
/// 编译并注册自定义着色器。
|
||
pub fn compile_shader(
|
||
&mut self,
|
||
vertex_source: &str,
|
||
fragment_source: &str,
|
||
) -> Result<u32> {
|
||
self.renderer.compile_shader(self.context.gl(), vertex_source, fragment_source)
|
||
}
|
||
|
||
/// Compile a shader with a specific ID.
|
||
/// 使用特定ID编译着色器。
|
||
pub fn compile_shader_with_id(
|
||
&mut self,
|
||
shader_id: u32,
|
||
vertex_source: &str,
|
||
fragment_source: &str,
|
||
) -> Result<()> {
|
||
self.renderer.compile_shader_with_id(self.context.gl(), shader_id, vertex_source, fragment_source)
|
||
}
|
||
|
||
/// Check if a shader exists.
|
||
/// 检查着色器是否存在。
|
||
pub fn has_shader(&self, shader_id: u32) -> bool {
|
||
self.renderer.has_shader(shader_id)
|
||
}
|
||
|
||
/// Remove a shader.
|
||
/// 移除着色器。
|
||
pub fn remove_shader(&mut self, shader_id: u32) -> bool {
|
||
self.renderer.remove_shader(shader_id)
|
||
}
|
||
|
||
// ===== Material Management =====
|
||
// ===== 材质管理 =====
|
||
|
||
/// Create and register a new material.
|
||
/// 创建并注册新材质。
|
||
pub fn create_material(
|
||
&mut self,
|
||
name: &str,
|
||
shader_id: u32,
|
||
blend_mode: u8,
|
||
) -> u32 {
|
||
use crate::renderer::material::{Material, BlendMode};
|
||
|
||
let blend = match blend_mode {
|
||
0 => BlendMode::None,
|
||
1 => BlendMode::Alpha,
|
||
2 => BlendMode::Additive,
|
||
3 => BlendMode::Multiply,
|
||
4 => BlendMode::Screen,
|
||
5 => BlendMode::PremultipliedAlpha,
|
||
_ => BlendMode::Alpha,
|
||
};
|
||
|
||
let mut material = Material::with_shader(name, shader_id);
|
||
material.blend_mode = blend;
|
||
|
||
self.renderer.register_material(material)
|
||
}
|
||
|
||
/// Create a material with a specific ID.
|
||
/// 使用特定ID创建材质。
|
||
pub fn create_material_with_id(
|
||
&mut self,
|
||
material_id: u32,
|
||
name: &str,
|
||
shader_id: u32,
|
||
blend_mode: u8,
|
||
) {
|
||
use crate::renderer::material::{Material, BlendMode};
|
||
|
||
let blend = match blend_mode {
|
||
0 => BlendMode::None,
|
||
1 => BlendMode::Alpha,
|
||
2 => BlendMode::Additive,
|
||
3 => BlendMode::Multiply,
|
||
4 => BlendMode::Screen,
|
||
5 => BlendMode::PremultipliedAlpha,
|
||
_ => BlendMode::Alpha,
|
||
};
|
||
|
||
let mut material = Material::with_shader(name, shader_id);
|
||
material.blend_mode = blend;
|
||
|
||
self.renderer.register_material_with_id(material_id, material);
|
||
}
|
||
|
||
/// Check if a material exists.
|
||
/// 检查材质是否存在。
|
||
pub fn has_material(&self, material_id: u32) -> bool {
|
||
self.renderer.has_material(material_id)
|
||
}
|
||
|
||
/// Remove a material.
|
||
/// 移除材质。
|
||
pub fn remove_material(&mut self, material_id: u32) -> bool {
|
||
self.renderer.remove_material(material_id)
|
||
}
|
||
|
||
/// Set a material's float uniform.
|
||
/// 设置材质的浮点uniform。
|
||
pub fn set_material_float(&mut self, material_id: u32, name: &str, value: f32) -> bool {
|
||
self.renderer.set_material_float(material_id, name, value)
|
||
}
|
||
|
||
/// Set a material's vec2 uniform.
|
||
/// 设置材质的vec2 uniform。
|
||
pub fn set_material_vec2(&mut self, material_id: u32, name: &str, x: f32, y: f32) -> bool {
|
||
if let Some(material) = self.renderer.get_material_mut(material_id) {
|
||
material.uniforms.set_vec2(name, x, y);
|
||
true
|
||
} else {
|
||
false
|
||
}
|
||
}
|
||
|
||
/// Set a material's vec3 uniform.
|
||
/// 设置材质的vec3 uniform。
|
||
pub fn set_material_vec3(&mut self, material_id: u32, name: &str, x: f32, y: f32, z: f32) -> bool {
|
||
if let Some(material) = self.renderer.get_material_mut(material_id) {
|
||
material.uniforms.set_vec3(name, x, y, z);
|
||
true
|
||
} else {
|
||
false
|
||
}
|
||
}
|
||
|
||
/// Set a material's vec4 uniform.
|
||
/// 设置材质的vec4 uniform。
|
||
pub fn set_material_vec4(&mut self, material_id: u32, name: &str, x: f32, y: f32, z: f32, w: f32) -> bool {
|
||
self.renderer.set_material_vec4(material_id, name, x, y, z, w)
|
||
}
|
||
|
||
/// Set a material's color uniform.
|
||
/// 设置材质的颜色uniform。
|
||
pub fn set_material_color(&mut self, material_id: u32, name: &str, r: f32, g: f32, b: f32, a: f32) -> bool {
|
||
if let Some(material) = self.renderer.get_material_mut(material_id) {
|
||
material.uniforms.set_color(name, r, g, b, a);
|
||
true
|
||
} else {
|
||
false
|
||
}
|
||
}
|
||
|
||
/// Set a material's blend mode.
|
||
/// 设置材质的混合模式。
|
||
pub fn set_material_blend_mode(&mut self, material_id: u32, blend_mode: u8) -> bool {
|
||
use crate::renderer::material::BlendMode;
|
||
|
||
let blend = match blend_mode {
|
||
0 => BlendMode::None,
|
||
1 => BlendMode::Alpha,
|
||
2 => BlendMode::Additive,
|
||
3 => BlendMode::Multiply,
|
||
4 => BlendMode::Screen,
|
||
5 => BlendMode::PremultipliedAlpha,
|
||
_ => return false,
|
||
};
|
||
|
||
if let Some(material) = self.renderer.get_material_mut(material_id) {
|
||
material.blend_mode = blend;
|
||
true
|
||
} else {
|
||
false
|
||
}
|
||
}
|
||
}
|