40#include <fmt/format.h>
53 std::accumulate(values.
begin(), values.
end(), 0.0f) / values.
size();
108 if (mat_index == -1) {
128std::optional<Bounds<float2>> GreasePencilExporter::compute_screen_space_drawing_bounds(
131 const int layer_index,
137 std::optional<Bounds<float2>> drawing_bounds = std::nullopt;
143 const float4x4 layer_to_world =
layer.to_world_space(
object);
150 object, drawing, memory);
153 [&](
const int curve_i) {
156 for (
const int point_i : points) {
163 std::optional<Bounds<float2>> point_bounds =
Bounds<float2>(screen_co);
164 point_bounds->pad(pixels);
165 drawing_bounds =
bounds::merge(drawing_bounds, point_bounds);
171 return drawing_bounds;
174std::optional<Bounds<float2>> GreasePencilExporter::compute_objects_bounds(
175 const RegionView3D &rv3d,
176 const Depsgraph &depsgraph,
177 const Span<GreasePencilExporter::ObjectInfo> objects,
178 const int frame_number)
180 using bke::greasepencil::Drawing;
181 using bke::greasepencil::Layer;
182 using ObjectInfo = GreasePencilExporter::ObjectInfo;
184 constexpr float gap = 10.0f;
186 std::optional<Bounds<float2>> full_bounds = std::nullopt;
190 const GreasePencil &grease_pencil_eval = *id_cast<GreasePencil *>(object_eval->data);
192 for (
const int layer_index : grease_pencil_eval.layers().index_range()) {
193 const Layer &
layer = *grease_pencil_eval.layers()[layer_index];
194 const Drawing *drawing = grease_pencil_eval.get_drawing_at(
layer, frame_number);
195 if (drawing ==
nullptr) {
199 std::optional<Bounds<float2>> layer_bounds = this->compute_screen_space_drawing_bounds(
200 rv3d, *object_eval, layer_index, *drawing);
208 full_bounds->pad(gap);
221 if (cam_ob ==
nullptr) {
246 if (use_camera_view) {
270 std::optional<Bounds<float2>> full_bounds = this->compute_objects_bounds(
301 for (const int index : range) {
302 const float3 &pos = world_positions[index];
303 const float radius = radii[index];
305 widths[index] = 2.0f * radius / ED_view3d_pixel_size(&rv3d, pos);
338 case SelectMode::Active:
341 case SelectMode::Selected:
344 add_object(base.object);
348 case SelectMode::Visible:
351 add_object(base.object);
367 const bool is_cyclic)
375 for (
const int point_i : points.
drop_back(is_cyclic ? 0 : 1).
drop_front(is_cyclic ? 0 : 1)) {
376 const float point_miter_angle = miter_angles[point_i];
385 miter_limit_angle = point_miter_angle;
389 miter_limit_angle =
math::min(miter_limit_angle, point_miter_angle);
392 return miter_limit_angle;
402 const float4x4 layer_to_world =
layer.to_world_space(
object);
404 const float4x4 layer_to_view = viewmat * layer_to_world;
426 const std::optional<Span<float3>> positions_left =
curves.handle_positions_left();
427 const std::optional<Span<float3>> positions_right =
curves.handle_positions_right();
429 const std::optional<GroupedSpan<int>> fills = drawing.
fills();
445 for (
const int i_curve :
curves.curves_range()) {
446 const bool is_filled = fill_ids[i_curve] != 0;
447 const bool active_filled = is_filled && (fill_index_by_curves[i_curve] == -1);
451 const Span<int> fill = (*fills)[fill_index];
452 const int first_curve = fill.first();
453 for (
const int pos : fill.index_range()) {
454 const int i_curve = fill[pos];
455 fill_index_by_curves[i_curve] = fill_index;
456 first_curves[i_curve] = first_curve;
466 for (
const int i_curve :
curves.curves_range()) {
468 const int fill_index = fill_index_by_curves[i_curve];
470 const bool is_filled = fill_index != -1;
471 const bool active_filled = is_filled && (first_curves[i_curve] == i_curve);
473 const int material_index = material_indices[i_curve];
479 return material_default;
490 if (active_filled &&
params_.export_fill_materials) {
491 const Span<int> fill = (*fills)[fill_index];
495 material_fill_color, fill_colors[i_curve], fill_colors[i_curve].a);
512 if (!hide_stroke[i_curve] &&
params_.export_stroke_materials) {
513 const IndexRange points = points_by_curve[i_curve];
516 *material, vertex_colors.
slice(points));
519 const std::optional<float> uniform_width =
params_.use_uniform_width ?
522 world_positions.
as_span().slice(points),
523 radii.
slice(points)) :
526 const bool is_cyclic = cyclic[i_curve];
551 constexpr int corner_subdivisions = 3;
552 constexpr float outline_radius = 0.0f;
553 constexpr float outline_offset = 0.0f;
563 if (
params_.outline_resample_length > 0.0f) {
574 const std::optional<Span<float3>> outline_positions_right =
582 shape_fn(outline_positions,
583 outline_positions_left,
584 outline_positions_right,
585 outline_points_by_curve,
627 const int frame_number)
const
630 if (
layer->is_visible()) {
632 if ((frame !=
nullptr) && frame->is_selected()) {
644 return fmt::format(
"{},{}", screen_co.x,
camera_rect_.size().y - screen_co.y);
646 return fmt::format(
"{},{}", screen_co.x,
screen_rect_.size().y - screen_co.y);
Camera data-block and utility functions.
Low-level operations for curves.
Low-level operations for grease pencil.
General operations, lookup, etc. for materials.
#define GP_STROKE_MITER_ANGLE_ROUND
Object is a sort of wrapper for general info.
Span< T > as_span() const
MutableSpan< T > as_mutable_span()
IndexRange index_range() const
constexpr IndexRange drop_back(int64_t n) const
static constexpr IndexRange from_single(const int64_t index)
constexpr IndexRange drop_front(int64_t n) const
Span< NewT > constexpr cast() const
constexpr int64_t size() const
constexpr const T * end() const
constexpr const T * begin() const
constexpr bool is_empty() const
constexpr const char * c_str() const
static VArray from_single(T value, const int64_t size)
void append(const T &value)
GAttributeReader lookup_or_default(StringRef name, AttrDomain domain, AttrType data_type, const void *default_value=nullptr) const
VArray< int8_t > curve_types() const
std::optional< Span< float3 > > handle_positions_right() const
VArray< bool > cyclic() const
Span< float3 > positions() const
std::optional< Span< float3 > > handle_positions_left() const
IndexRange curves_range() const
OffsetIndices< int > points_by_curve() const
VArray< ColorGeometry4f > vertex_colors() const
std::optional< GroupedSpan< int > > fills() const
const bke::CurvesGeometry & strokes() const
VArray< float > radii() const
VArray< ColorGeometry4f > fill_colors() const
VArray< float > opacities() const
constexpr Span slice(int64_t start, int64_t size) const
void foreach_index(Fn &&fn, Mode mode=exec_mode::serial) const
GreasePencilExporter(const IOContext &context, const ExportParams ¶ms)
std::string coord_to_svg_string(const float2 &screen_co) const
static std::optional< float > try_get_uniform_point_width(const RegionView3D &rv3d, const Span< float3 > world_positions, const Span< float > radii)
void foreach_shape_in_layer(const Object &object, const bke::greasepencil::Layer &layer, const bke::greasepencil::Drawing &drawing, WriteShapeFn shape_fn)
Bounds< float2 > camera_rect_
std::optional< float4x4 > camera_persmat_
const ExportParams params_
static ColorGeometry4f compute_average_stroke_color(const Material &material, const Span< ColorGeometry4f > vertex_colors)
void prepare_render_params(Scene &scene, int frame_number)
Vector< ObjectInfo > retrieve_objects() const
bool is_selected_frame(const GreasePencil &grease_pencil, int frame_number) const
Bounds< float2 > screen_rect_
static float compute_average_stroke_opacity(const Span< float > opacities)
float2 project_to_screen(const float4x4 &transform, const float3 &position) const
FunctionRef< void(const Span< float3 > positions, const std::optional< Span< float3 > > positions_left, const std::optional< Span< float3 > > positions_right, const OffsetIndices< int > points_by_curve, const Span< int > shape, const VArray< bool > &cyclic, const VArray< int8_t > &types, const ColorGeometry4f &color, float opacity, std::optional< float > width, std::optional< float > miter_limit_angle, bool round_cap, bool is_outline)> WriteShapeFn
GreasePencilImporter(const IOContext &context, const ImportParams ¶ms)
Object * create_object(StringRefNull name)
const ImportParams params_
int32_t create_material(StringRefNull name)
void fill_index_range(MutableSpan< T > span, const T start=0)
Bounds< T > merge(const Bounds< T > &a, const Bounds< T > &b)
IndexMask retrieve_visible_strokes(Object &object, const bke::greasepencil::Drawing &drawing, IndexMaskMemory &memory)
bke::CurvesGeometry create_curves_outline(const bke::greasepencil::Drawing &drawing, const IndexMask &strokes, const float4x4 &transform, const int corner_subdivisions, const float outline_radius, const float outline_offset, const int material_index)
Object * add_type(bContext *C, int type, const char *name, const float loc[3], const float rot[3], bool enter_editmode, unsigned short local_view_bits) ATTR_NONNULL(1) ATTR_RETURNS_NONNULL
constexpr ParallelGrainSize grain_size(int grain_size)
CurvesGeometry resample_to_length(const CurvesGeometry &src_curves, const IndexMask &selection, const VArray< float > &sample_lengths, const ResampleCurvesOutputAttributeIDs &output_ids={}, bool keep_last_segment=false)
static float4x4 persmat_from_camera_object(Scene &scene)
static float get_miter_limit_angle(const VArray< float > miter_angles, const IndexRange points, const bool is_cyclic)
static float get_average(const Span< float > values)
T dot(const QuaternionBase< T > &a, const QuaternionBase< T > &b)
T min(const T &a, const T &b)
CartesianBasis invert(const CartesianBasis &basis)
VectorT project_point(const MatT &mat, const VectorT &point)
T interpolate(const T &a, const T &b, const FactorT &t)
void transform_points(const float4x4 &transform, MutableSpan< float3 > points, bool use_threading=true)
VecBase< T, 3 > transform_point(const CartesianBasis &basis, const VecBase< T, 3 > &v)
void parallel_for(const IndexRange range, const int64_t grain_size, const Function &function, const TaskSizeHints &size_hints=detail::TaskSizeHints_Static(1))
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
Depsgraph * CTX_data_depsgraph_pointer(const bContext *C)
float ED_view3d_pixel_size(const RegionView3D *rv3d, const float co[3])
Material * BKE_object_material_get(Object *ob, short act)
void BKE_camera_params_compute_viewplane(CameraParams *params, int winx, int winy, float aspx, float aspy)
MatBase< float, 4, 4 > float4x4
Material * BKE_material_default_gpencil()
ViewLayer * CTX_data_view_layer(const bContext *C)
void BKE_render_resolution(const RenderData *r, const bool use_crop, int *r_width, int *r_height)
VecBase< float, 4 > float4
void BKE_camera_params_compute_matrix(CameraParams *params)
Material * BKE_grease_pencil_object_material_new(Main *bmain, Object *ob, const char *name, int *r_index)
VecBase< float, 2 > float2
int BKE_grease_pencil_object_material_index_get_by_name(Object *ob, const char *name)
BMesh const char void * data
T * DEG_get_evaluated(const Depsgraph *depsgraph, T *id)
void BKE_camera_params_from_object(CameraParams *params, const struct Object *cam_ob)
rctf BKE_camera_view_border(const struct Scene *scene, const struct Depsgraph *depsgraph, const struct View3D *v3d, const struct RegionView3D *rv3d, int winx, int winy, bool no_shift, bool no_zoom, bool no_roll)
eV3DProjStatus ED_view3d_project_float_global(const ARegion *region, const float co[3], float r_co[2], eV3DProjTest flag)
bool BKE_view_layer_synced_ensure(const Main &bmain, const Scene *scene, ViewLayer *view_layer)
float ED_view3d_calc_zfac(const RegionView3D *rv3d, const float co[3])
Main * CTX_data_main(const bContext *C)
bool BKE_scene_camera_switch_update(Scene *scene)
Scene * CTX_data_scene(const bContext *C)
ColorSceneLinear4f< eAlpha::Premultiplied > ColorGeometry4f
MINLINE void copy_v4_v4(float r[4], const float a[4])
VecBase< float, 3 > float3
void BKE_camera_params_init(CameraParams *params)
GreasePencilStrokeCapType
@ GP_STROKE_CAP_TYPE_ROUND
ListBaseT< Base > * BKE_view_layer_object_bases_get(ViewLayer *view_layer)
KERNEL_FEATURE_LIGHT_PASSES KERNEL_FEATURE_PATH_GUIDING float
static MatBase identity()
eRegionView3D_Persp persp
unsigned short local_view_uid
IOContext(bContext &C, const ARegion *region, const View3D *v3d, const RegionView3D *rv3d, ReportList *reports)
const RegionView3D * rv3d