243 lines
8.6 KiB
Zig
243 lines
8.6 KiB
Zig
const std = @import("std");
|
||
const builtin = @import("builtin");
|
||
const dvui = @import("dvui");
|
||
const Document = @import("models/Document.zig");
|
||
const RenderEngine = @import("render/RenderEngine.zig").RenderEngine;
|
||
const basic_models = @import("models/basic_models.zig");
|
||
const Rect_i = basic_models.Rect_i;
|
||
const Size_i = basic_models.Size_i;
|
||
const Point2_f = @import("models/basic_models.zig").Point2_f;
|
||
const Color = dvui.Color;
|
||
const tools = @import("toolbar/tools.zig");
|
||
const Toolbar = @import("toolbar/Toolbar.zig");
|
||
const random_document = @import("random_document.zig");
|
||
const Canvas = @This();
|
||
|
||
allocator: std.mem.Allocator,
|
||
document: *Document,
|
||
render_engine: RenderEngine,
|
||
toolbar: Toolbar,
|
||
texture: ?dvui.Texture = null,
|
||
pos: dvui.Point = dvui.Point{ .x = 400, .y = 400 },
|
||
scroll: dvui.ScrollInfo = .{
|
||
.vertical = .auto,
|
||
.horizontal = .auto,
|
||
},
|
||
native_scaling: bool = true,
|
||
cursor_document_point: ?Point2_f = null,
|
||
draw_document: bool = true,
|
||
show_render_stats: bool = true,
|
||
/// Rect тулбара (из предыдущего кадра) для исключения кликов по нему из handleCanvasMouse.
|
||
toolbar_rect_scale: ?dvui.RectScale = null,
|
||
/// Rect панели свойств (из предыдущего кадра) для исключения кликов по нему из handleCanvasMouse.
|
||
properties_rect_scale: ?dvui.RectScale = null,
|
||
redraw_throttle_ms: u32 = 50,
|
||
frame_index: u64 = 0,
|
||
|
||
_zoom: f32 = 1,
|
||
_rendering_quality: f32 = 100.0,
|
||
_last_redraw_time_ms: i64 = 0, // Метка последней перерисовки чтобы ограничить частоту
|
||
_visible_rect: ?Rect_i = null,
|
||
_redraw_pending: bool = false,
|
||
|
||
pub fn init(allocator: std.mem.Allocator, document: *Document, engine: RenderEngine) Canvas {
|
||
return .{
|
||
.allocator = allocator,
|
||
.document = document,
|
||
.render_engine = engine,
|
||
.toolbar = Toolbar.init(&tools.default_tools),
|
||
};
|
||
}
|
||
|
||
pub fn deinit(self: *Canvas) void {
|
||
self.toolbar.deinit();
|
||
if (self.texture) |texture| {
|
||
dvui.Texture.destroyLater(texture);
|
||
self.texture = null;
|
||
}
|
||
}
|
||
|
||
fn redraw(self: *Canvas) !void {
|
||
const full = self.getZoomedImageSize();
|
||
|
||
const vis_full: Rect_i = self._visible_rect orelse Rect_i{ .x = 0, .y = 0, .w = 0, .h = 0 };
|
||
|
||
if (vis_full.w == 0 or vis_full.h == 0) {
|
||
if (self.texture) |tex| {
|
||
dvui.Texture.destroyLater(tex);
|
||
self.texture = null;
|
||
}
|
||
return;
|
||
}
|
||
|
||
// Качество рендеринга задаётся в процентах площади (1–100),
|
||
// при этом фактически уменьшаем ширину/высоту холста на корень из этой доли.
|
||
const quality_percent: f32 = self.getRenderingQuality();
|
||
const quality_area: f32 = quality_percent / 100.0;
|
||
const quality_side: f32 = std.math.sqrt(quality_area);
|
||
const scale: f32 = std.math.clamp(quality_side, 0.01, 1.0);
|
||
|
||
const canvas_size: Size_i = .{
|
||
.w = @max(@as(u32, 1), @as(u32, @intFromFloat(@as(f32, @floatFromInt(full.w)) * scale))),
|
||
.h = @max(@as(u32, 1), @as(u32, @intFromFloat(@as(f32, @floatFromInt(full.h)) * scale))),
|
||
};
|
||
|
||
var vis_scaled = Rect_i{
|
||
.x = @as(u32, @intFromFloat(@as(f32, @floatFromInt(vis_full.x)) * scale)),
|
||
.y = @as(u32, @intFromFloat(@as(f32, @floatFromInt(vis_full.y)) * scale)),
|
||
.w = @max(@as(u32, 1), @as(u32, @intFromFloat(@as(f32, @floatFromInt(vis_full.w)) * scale))),
|
||
.h = @max(@as(u32, 1), @as(u32, @intFromFloat(@as(f32, @floatFromInt(vis_full.h)) * scale))),
|
||
};
|
||
|
||
if (vis_scaled.x >= canvas_size.w or vis_scaled.y >= canvas_size.h) {
|
||
if (self.texture) |tex| {
|
||
dvui.Texture.destroyLater(tex);
|
||
self.texture = null;
|
||
}
|
||
return;
|
||
}
|
||
|
||
const max_vis_w: u32 = canvas_size.w - vis_scaled.x;
|
||
const max_vis_h: u32 = canvas_size.h - vis_scaled.y;
|
||
if (vis_scaled.w > max_vis_w) vis_scaled.w = max_vis_w;
|
||
if (vis_scaled.h > max_vis_h) vis_scaled.h = max_vis_h;
|
||
|
||
const new_texture = if (self.draw_document)
|
||
self.render_engine.render(self.document, canvas_size, vis_scaled) catch null
|
||
else
|
||
self.render_engine.example(canvas_size, vis_scaled) catch null;
|
||
|
||
if (new_texture) |tex| {
|
||
if (self.texture) |old_tex| {
|
||
dvui.Texture.destroyLater(old_tex);
|
||
}
|
||
|
||
self.texture = tex;
|
||
}
|
||
self._last_redraw_time_ms = std.time.milliTimestamp();
|
||
self.frame_index += 1;
|
||
}
|
||
|
||
pub fn exampleReset(self: *Canvas) !void {
|
||
self.render_engine.exampleReset();
|
||
try self.redraw();
|
||
}
|
||
|
||
pub fn addRandomShapes(self: *Canvas) !void {
|
||
try random_document.addRandomShapes(self.document, self.allocator, std.crypto.random);
|
||
self.requestRedraw();
|
||
}
|
||
|
||
pub fn setZoom(self: *Canvas, value: f32) void {
|
||
self._zoom = @max(value, 0.01);
|
||
}
|
||
|
||
pub fn addZoom(self: *Canvas, value: f32) void {
|
||
self._zoom += value;
|
||
self._zoom = @max(self._zoom, 0.01);
|
||
}
|
||
|
||
pub fn multZoom(self: *Canvas, value: f32) void {
|
||
self._zoom *= value;
|
||
self._zoom = @max(self._zoom, 0.01);
|
||
}
|
||
|
||
pub fn getZoom(self: Canvas) f32 {
|
||
return self._zoom;
|
||
}
|
||
|
||
pub fn setRenderingQuality(self: *Canvas, value: f32) void {
|
||
self._rendering_quality = std.math.clamp(value, 1.0, 100.0);
|
||
self.requestRedraw();
|
||
}
|
||
|
||
pub fn getRenderingQuality(self: Canvas) f32 {
|
||
return self._rendering_quality;
|
||
}
|
||
|
||
pub fn requestRedraw(self: *Canvas) void {
|
||
self._redraw_pending = true;
|
||
}
|
||
|
||
pub fn processPendingRedraw(self: *Canvas) !void {
|
||
if (!self._redraw_pending) return;
|
||
if (self.redraw_throttle_ms == 0) {
|
||
self._redraw_pending = false;
|
||
try self.redraw();
|
||
return;
|
||
}
|
||
const now_ms = std.time.milliTimestamp();
|
||
const elapsed: i64 = if (self._last_redraw_time_ms == 0) self.redraw_throttle_ms else now_ms - self._last_redraw_time_ms;
|
||
if (elapsed < @as(i64, @intCast(self.redraw_throttle_ms))) return;
|
||
self._redraw_pending = false;
|
||
try self.redraw();
|
||
}
|
||
|
||
pub fn getZoomedImageSize(self: Canvas) Rect_i {
|
||
const doc = self.document;
|
||
return .{
|
||
.x = @intFromFloat(self.pos.x),
|
||
.y = @intFromFloat(self.pos.y),
|
||
.w = @intFromFloat(doc.size.w * self._zoom),
|
||
.h = @intFromFloat(doc.size.h * self._zoom),
|
||
};
|
||
}
|
||
|
||
/// Точка контента -> координаты документа.
|
||
pub fn contentPointToDocument(self: Canvas, content_point: dvui.Point, natural_scale: f32) Point2_f {
|
||
const img = self.getZoomedImageSize();
|
||
const px_x = content_point.x * natural_scale - @as(f32, @floatFromInt(img.x));
|
||
const px_y = content_point.y * natural_scale - @as(f32, @floatFromInt(img.y));
|
||
return .{
|
||
.x = px_x / self._zoom,
|
||
.y = px_y / self._zoom,
|
||
};
|
||
}
|
||
|
||
/// Точка контента внутри холста.
|
||
pub fn isContentPointOnDocument(self: Canvas, content_point: dvui.Point, natural_scale: f32) bool {
|
||
const img = self.getZoomedImageSize();
|
||
const left_n = @as(f32, @floatFromInt(img.x)) / natural_scale;
|
||
const top_n = @as(f32, @floatFromInt(img.y)) / natural_scale;
|
||
const right_n = @as(f32, @floatFromInt(img.x + img.w)) / natural_scale;
|
||
const bottom_n = @as(f32, @floatFromInt(img.y + img.h)) / natural_scale;
|
||
return content_point.x >= left_n and content_point.x < right_n and
|
||
content_point.y >= top_n and content_point.y < bottom_n;
|
||
}
|
||
|
||
pub fn updateVisibleImageRect(self: *Canvas, viewport: dvui.Rect, scroll_offset: dvui.Point) bool {
|
||
const next = computeVisibleImageRect(self.*, viewport, scroll_offset);
|
||
var changed = false;
|
||
if (self._visible_rect) |vis| {
|
||
changed |= next.x != vis.x or next.y != vis.y or next.w != vis.w or next.h != vis.h;
|
||
}
|
||
self._visible_rect = next;
|
||
if (changed or self.texture == null) {
|
||
return true;
|
||
}
|
||
return false;
|
||
}
|
||
|
||
fn computeVisibleImageRect(self: Canvas, viewport: dvui.Rect, scroll_offset: dvui.Point) Rect_i {
|
||
const image_rect = self.getZoomedImageSize();
|
||
|
||
const img_w: u32 = image_rect.w;
|
||
const img_h: u32 = image_rect.h;
|
||
|
||
const vis_w: u32 = @min(@as(u32, @intFromFloat(viewport.w)), img_w);
|
||
const vis_h: u32 = @min(@as(u32, @intFromFloat(viewport.h)), img_h);
|
||
|
||
const raw_x: i64 = @intFromFloat(scroll_offset.x - @as(f32, @floatFromInt(image_rect.x)));
|
||
const raw_y: i64 = @intFromFloat(scroll_offset.y - @as(f32, @floatFromInt(image_rect.y)));
|
||
|
||
const vis_x: u32 = @intCast(std.math.clamp(raw_x, 0, @as(i64, img_w) - @as(i64, vis_w)));
|
||
const vis_y: u32 = @intCast(std.math.clamp(raw_y, 0, @as(i64, img_h) - @as(i64, vis_h)));
|
||
|
||
return Rect_i{
|
||
.x = vis_x,
|
||
.y = vis_y,
|
||
.w = vis_w,
|
||
.h = vis_h,
|
||
};
|
||
}
|