DreamBees Canvas

A GPU-first image editing application designed for 2025 hardware capabilities. DreamBees Canvas prioritizes real-time performance, responsive user experience, and modern optimization techniques.

Features

• GPU-Accelerated Everything: All operations leverage modern GPU compute capabilities
• Sub-millisecond Tool Responsiveness: Brush strokes and interactions feel instant
• Tile-Based Memory Management: Unlimited canvas size with efficient memory usage
• Non-destructive Editing: Infinite undo with full history tracking
• 60fps Performance: Smooth operation at any zoom level
• Modern UI: Clean, responsive interface built with Dear ImGui

Architecture

Core Principles

• GPU-accelerated everything possible
• Sub-millisecond tool responsiveness
• Tile-based memory management for unlimited canvas size
• Non-destructive editing with infinite undo
• 60fps performance at any zoom level

Performance Targets

• UI interactions: 60fps minimum
• Brush strokes: <1ms latency from input to screen
• Zoom/pan: 60fps at any zoom level
• Filter preview: 30fps for real-time parameter adjustment
• Memory efficiency: <100MB RAM for UI and engine overhead
• Startup performance: <2 seconds cold start

Technology Stack

• Core Engine: C++20 with Vulkan for maximum performance
• UI Framework: Dear ImGui for immediate-mode interface
• Platform Support: Windows/Mac/Linux desktop
• Build System: CMake with vcpkg for dependencies
• Graphics API: Vulkan with fallbacks to Metal (macOS) and DirectX 12 (Windows)

Building

Prerequisites

• C++20 compatible compiler (Clang 12+, GCC 10+, MSVC 2019+)
• CMake 3.20+
• Python 3.7+ (for build scripts)
• Git
• Vulkan SDK (latest version)

Quick Start

1. Clone the repository:

   git clone <repository-url>
   cd DreamBeesCanvas

2. Run the build script:

   python scripts/build.py

3. Run the application:

   ./build/bin/DreamBeesCanvas

Manual Build

1. Setup vcpkg (if not using build script):

   git clone https://github.com/Microsoft/vcpkg.git third_party/vcpkg
   cd third_party/vcpkg
   ./bootstrap-vcpkg.sh  # or bootstrap-vcpkg.bat on Windows

2. Install dependencies:

   ./vcpkg install vulkan glfw3 imgui stb freetype zstd

3. Configure with CMake:

   mkdir build && cd build
   cmake .. -DCMAKE_TOOLCHAIN_FILE=../third_party/vcpkg/scripts/buildsystems/vcpkg.cmake

4. Build:

   cmake --build . --config Release

Build Options

The build script supports several options:

python scripts/build.py --help

• --build-type: Choose Debug, Release, or RelWithDebInfo
• --clean: Clean build directory before building
• --install: Install after building
• --verbose: Enable verbose output
• --test: Run tests
• --package: Create distribution package

Project Structure

DreamBeesCanvas/
├── src/                    # Source code
│   ├── core/              # Core engine and foundational systems
│   │   ├── gpu/           # GPU abstraction and Vulkan wrapper
│   │   ├── image/         # Image data structures and management
│   │   ├── math/          # Mathematics and geometry
│   │   └── threading/     # Multi-threading infrastructure
│   ├── canvas/            # Canvas rendering and viewport management
│   ├── tools/             # User interaction tools
│   ├── filters/           # GPU-accelerated filter system
│   ├── io/                # File format support
│   ├── ui/                # User interface
│   ├── input/             # Input handling
│   └── app/               # Application framework
├── shaders/               # GPU shader source code
├── assets/                # Application assets
├── third_party/           # External dependencies
├── tests/                 # Test suite
├── tools/                 # Development tools
├── docs/                  # Documentation
└── scripts/               # Build and deployment scripts

Key Components

GPU Abstraction Layer

• Platform-agnostic GPU access through Vulkan
• Fallbacks to Metal (macOS) and DirectX 12 (Windows)
• Handles device selection, memory management, and command buffer submission

Tile-Based Image System

• Images divided into 512x512 pixel tiles
• Dynamic loading/unloading based on viewport
• LRU caching for efficient memory usage
• Enables unlimited canvas size

Real-Time Canvas Renderer

• Viewport management and layer compositing
• 60fps performance at any zoom level
• GPU-accelerated layer blending with 25+ blend modes

High-Performance Brush Engine

• Sub-millisecond brush system
• Pressure sensitivity and tilt support
• GPU-accelerated stroke rendering
• Real-time tessellation and smoothing

GPU Filter Pipeline

• All filters implemented as compute shaders
• Real-time preview with 30+ fps performance on 4K images
• Non-destructive filter stacking

Development

Code Style

• Follow C++20 best practices
• Use RAII and smart pointers
• Prefer const correctness
• Use meaningful variable and function names
• Document public APIs

Testing

Run the test suite:

python scripts/build.py --test

Performance Profiling

Enable performance monitoring:

python scripts/build.py --build-type RelWithDebInfo

The application includes built-in performance monitoring for:

• Frame timing
• GPU operation timing
• Memory usage
• Tile cache performance

Contributing

1. Fork the repository
2. Create a feature branch
3. Make your changes
4. Add tests for new functionality
5. Ensure all tests pass
6. Submit a pull request

License

This project is licensed under the MIT License - see the LICENSE file for details.

Roadmap

• Complete brush engine implementation
• Add comprehensive filter library
• Implement advanced selection tools
• Add plugin system
• Optimize for mobile platforms
• Add collaborative editing features

Support

For questions, bug reports, or feature requests, please open an issue on GitHub.

Acknowledgments

• Vulkan SDK team for the excellent graphics API
• Dear ImGui for the immediate-mode GUI framework
• vcpkg team for the C++ package manager
• All contributors and testers