iop/drawlayer/paint.h

Go to the documentation of this file.

/*
    This file is part of the Ansel project.
    Copyright (C) 2026 Aurélien PIERRE.
 
    Ansel is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.
 
    Ansel is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License
    along with Ansel.  If not, see <http://www.gnu.org/licenses/>.
*/
 
#pragma once
 
#include "iop/drawlayer/brush.h"
 
#include <glib.h>
#include <stdint.h>
 
typedef enum dt_drawlayer_paint_stroke_pos_t
{
  DT_DRAWLAYER_PAINT_STROKE_FIRST = 0,  
  DT_DRAWLAYER_PAINT_STROKE_MIDDLE = 1, 
  DT_DRAWLAYER_PAINT_STROKE_END = 2,    
} dt_drawlayer_paint_stroke_pos_t;
 
typedef struct dt_drawlayer_paint_raw_input_t
{
  float wx;               
  float wy;               
  float lx;               
  float ly;               
  float pressure;         
  float tilt;             
  float acceleration;     
  gint64 event_ts;        
  uint32_t stroke_batch;  
  uint32_t event_index;   
  uint8_t stroke_pos;     
  uint8_t have_layer_coords; 
  uint8_t pressure_profile; 
  uint8_t tilt_profile;     
  uint8_t accel_profile;    
  uint32_t map_flags;     
  float distance_percent; 
  float smoothing_percent;
  float brush_radius;     
  float brush_opacity;    
  float brush_flow;       
  float brush_hardness;   
  float brush_sprinkles;  
  float brush_sprinkle_size; 
  float brush_sprinkle_coarseness; 
  int brush_shape;        
  int brush_mode;         
  float color[3];         
  float display_color[3]; 
} dt_drawlayer_paint_raw_input_t;
 
typedef struct dt_drawlayer_damaged_rect_t
{
  gboolean valid; 
  int nw[2];      
  int se[2];      
} dt_drawlayer_damaged_rect_t;
 
typedef struct dt_drawlayer_paint_stroke_t
{
  GArray *history;      
  GArray *raw_inputs;   
  GArray *pending_dabs; 
  guint raw_input_cursor; 
  GArray *dab_window;   
  dt_drawlayer_brush_dab_t last_input_dab; 
  gboolean have_last_input_dab;            
  dt_drawlayer_brush_dab_t prev_raw_dab;   
  gboolean have_prev_raw_dab;              
  float stroke_arc_length;   
  float sampled_arc_length;  
  float distance_percent;    
  uint64_t stroke_seed;      
  dt_drawlayer_damaged_rect_t bounds; 
  float *smudge_pixels;      
  int smudge_width;          
  int smudge_height;         
  float smudge_pickup_x;     
  float smudge_pickup_y;     
  gboolean have_smudge_pickup; 
} dt_drawlayer_paint_stroke_t;
 
typedef gboolean (*dt_drawlayer_paint_build_dab_cb)(void *user_data,
                                                     dt_drawlayer_paint_stroke_t *state,
                                                     const dt_drawlayer_paint_raw_input_t *input,
                                                     dt_drawlayer_brush_dab_t *out_dab);
typedef gboolean (*dt_drawlayer_paint_layer_to_widget_cb)(void *user_data, float lx, float ly,
                                                           float *wx, float *wy);
typedef void (*dt_drawlayer_paint_stroke_seed_cb)(void *user_data, uint64_t stroke_seed);
 
typedef struct dt_drawlayer_paint_callbacks_t
{
  dt_drawlayer_paint_build_dab_cb build_dab; 
  dt_drawlayer_paint_layer_to_widget_cb layer_to_widget; 
  dt_drawlayer_paint_stroke_seed_cb on_stroke_seed; 
} dt_drawlayer_paint_callbacks_t;
 
void dt_drawlayer_paint_path_state_reset(dt_drawlayer_paint_stroke_t *state);
gboolean dt_drawlayer_paint_queue_raw_input(dt_drawlayer_paint_stroke_t *state,
                                            const dt_drawlayer_paint_raw_input_t *input);
void dt_drawlayer_paint_interpolate_path(dt_drawlayer_paint_stroke_t *state,
                                         const dt_drawlayer_paint_callbacks_t *callbacks,
                                         void *user_data);
void dt_drawlayer_paint_finalize_path(dt_drawlayer_paint_stroke_t *state);
gboolean dt_drawlayer_paint_rasterize_segment_to_buffer(const dt_drawlayer_brush_dab_t *dab,
                                                        float distance_percent,
                                                        const dt_drawlayer_cache_patch_t *sample_patch,
                                                        dt_drawlayer_cache_patch_t *patch,
                                                        float scale,
                                                        dt_drawlayer_cache_patch_t *stroke_mask,
                                                        dt_drawlayer_damaged_rect_t *runtime_state,
                                                        dt_drawlayer_paint_stroke_t *runtime_private);
 
dt_drawlayer_damaged_rect_t *dt_drawlayer_paint_runtime_state_create(void);
void dt_drawlayer_paint_runtime_state_destroy(dt_drawlayer_damaged_rect_t **state);
void dt_drawlayer_paint_runtime_state_reset(dt_drawlayer_damaged_rect_t *state);
 
dt_drawlayer_paint_stroke_t *dt_drawlayer_paint_runtime_private_create(void);
void dt_drawlayer_paint_runtime_private_destroy(dt_drawlayer_paint_stroke_t **state);
void dt_drawlayer_paint_runtime_private_reset(dt_drawlayer_paint_stroke_t *state);
void dt_drawlayer_paint_runtime_set_stroke_seed(dt_drawlayer_paint_stroke_t *state, uint64_t seed);
uint64_t dt_drawlayer_paint_runtime_get_stroke_seed(const dt_drawlayer_paint_stroke_t *state);
gboolean dt_drawlayer_paint_runtime_ensure_smudge_pixels(dt_drawlayer_paint_stroke_t *state,
                                                         int width, int height);
float *dt_drawlayer_paint_runtime_smudge_pixels(dt_drawlayer_paint_stroke_t *state);
int dt_drawlayer_paint_runtime_smudge_width(const dt_drawlayer_paint_stroke_t *state);
int dt_drawlayer_paint_runtime_smudge_height(const dt_drawlayer_paint_stroke_t *state);
gboolean dt_drawlayer_paint_runtime_have_smudge_pickup(const dt_drawlayer_paint_stroke_t *state);
void dt_drawlayer_paint_runtime_get_smudge_pickup(const dt_drawlayer_paint_stroke_t *state,
                                                  float *x, float *y);
void dt_drawlayer_paint_runtime_set_smudge_pickup(dt_drawlayer_paint_stroke_t *state,
                                                  float x, float y, gboolean have_pickup);
gboolean dt_drawlayer_paint_runtime_prepare_dab_context(dt_drawlayer_paint_stroke_t *state,
                                                         const dt_drawlayer_brush_dab_t *dab,
                                                         int width, int height,
                                                         int origin_x, int origin_y,
                                                         float scale);
void dt_drawlayer_paint_runtime_note_dab_damage(dt_drawlayer_damaged_rect_t *state,
                                                const dt_drawlayer_damaged_rect_t *dab_rect);
gboolean dt_drawlayer_paint_runtime_get_stroke_damage(const dt_drawlayer_damaged_rect_t *state,
                                                      dt_drawlayer_damaged_rect_t *out_rect);
gboolean dt_drawlayer_paint_merge_runtime_stroke_damage(dt_drawlayer_damaged_rect_t *path_state,
                                                        dt_drawlayer_damaged_rect_t *target_rect);