tmaq
/
tornavis
1
0
Fork 0
Code Issues 2 Pull Requests 29 Packages Projects 24 Releases Wiki Activity
tornavis/source/blender/editors/sculpt_paint/sculpt_paint_image.cc

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

538 lines
18 KiB
C++
Raw Normal View History

PBVH Pixel extractor. This patch contains an initial pixel extractor for PBVH and an initial paint brush implementation. PBVH is an accelleration structure blender uses internally to speed up 3d painting operations. At this moment it is extensively used by sculpt, vertex painting and weight painting. For the 3d texturing brush we will be using the PBVH for texture painting. Currently PBVH is organized to work on geometry (vertices, polygons and triangles). For texture painting this should be extended it to use pixels. {F12995467} Screen recording has been done on a Mac Mini with a 6 core 3.3 GHZ Intel processor. # Scope This patch only contains an extending uv seams to fix uv seams. This is not actually we want, but was easy to add to make the brush usable. Pixels are places in the PBVH_Leaf nodes. We want to introduce a special node for pixels, but that will be done in a separate patch to keep the code review small. This reduces the painting performance when using low and medium poly assets. In workbench textures aren't forced to be shown. For now use Material/Rendered view. # Rasterization process The rasterization process will generate the pixel information for a leaf node. In the future those leaf nodes will be split up into multiple leaf nodes to increase the performance when there isn't enough geometry. For this patch this was left out of scope. In order to do so every polygon should be uniquely assigned to a leaf node. For each leaf node for each polygon If polygon not assigned assign polygon to node. Polygons are to complicated to be used directly we have to split the polygons into triangles. For each leaf node for each polygon extract triangles from polygon. The list of triangles can be stored inside the leaf node. The list of polygons aren't needed anymore. Each triangle has: poly_index. vert_indices delta barycentric coordinate between x steps. Each triangle is rasterized in rows. Sequential pixels (in uv space) are stored in a single structure. image position barycentric coordinate of the first pixel number of pixels triangle index inside the leaf node. During the performed experiments we used a fairly simple rasterization process by finding the UV bounds of an triangle and calculate the barycentric coordinates per pixel inside the bounds. Even for complex models and huge images this process is normally finished within 0.5 second. It could be that we want to change this algorithm to reduce hickups when nodes are initialized during a stroke. Reviewed By: brecht Maniphest Tasks: T96710 Differential Revision: https://developer.blender.org/D14504
2022-04-15 16:39:50 +02:00
/* SPDX-License-Identifier: GPL-2.0-or-later
* Copyright 2022 Blender Foundation. All rights reserved. */
#include "DNA_image_types.h"
#include "DNA_object_types.h"
#include "ED_paint.h"
#include "BLI_math.h"
#include "BLI_math_color_blend.h"
#include "BLI_task.h"
#include "IMB_colormanagement.h"
#include "IMB_imbuf.h"
#include "BKE_brush.h"
#include "BKE_image_wrappers.hh"
#include "BKE_pbvh.h"
#include "BKE_pbvh_pixels.hh"
#include "bmesh.h"
#include "sculpt_intern.h"
namespace blender::ed::sculpt_paint::paint::image {
using namespace blender::bke::pbvh::pixels;
using namespace blender::bke::image;
struct ImageData {
Image *image = nullptr;
ImageUser *image_user = nullptr;
Cleanup: Clang tidy
2022-04-15 18:59:02 +02:00
~ImageData() = default;
PBVH Pixel extractor. This patch contains an initial pixel extractor for PBVH and an initial paint brush implementation. PBVH is an accelleration structure blender uses internally to speed up 3d painting operations. At this moment it is extensively used by sculpt, vertex painting and weight painting. For the 3d texturing brush we will be using the PBVH for texture painting. Currently PBVH is organized to work on geometry (vertices, polygons and triangles). For texture painting this should be extended it to use pixels. {F12995467} Screen recording has been done on a Mac Mini with a 6 core 3.3 GHZ Intel processor. # Scope This patch only contains an extending uv seams to fix uv seams. This is not actually we want, but was easy to add to make the brush usable. Pixels are places in the PBVH_Leaf nodes. We want to introduce a special node for pixels, but that will be done in a separate patch to keep the code review small. This reduces the painting performance when using low and medium poly assets. In workbench textures aren't forced to be shown. For now use Material/Rendered view. # Rasterization process The rasterization process will generate the pixel information for a leaf node. In the future those leaf nodes will be split up into multiple leaf nodes to increase the performance when there isn't enough geometry. For this patch this was left out of scope. In order to do so every polygon should be uniquely assigned to a leaf node. For each leaf node for each polygon If polygon not assigned assign polygon to node. Polygons are to complicated to be used directly we have to split the polygons into triangles. For each leaf node for each polygon extract triangles from polygon. The list of triangles can be stored inside the leaf node. The list of polygons aren't needed anymore. Each triangle has: poly_index. vert_indices delta barycentric coordinate between x steps. Each triangle is rasterized in rows. Sequential pixels (in uv space) are stored in a single structure. image position barycentric coordinate of the first pixel number of pixels triangle index inside the leaf node. During the performed experiments we used a fairly simple rasterization process by finding the UV bounds of an triangle and calculate the barycentric coordinates per pixel inside the bounds. Even for complex models and huge images this process is normally finished within 0.5 second. It could be that we want to change this algorithm to reduce hickups when nodes are initialized during a stroke. Reviewed By: brecht Maniphest Tasks: T96710 Differential Revision: https://developer.blender.org/D14504
2022-04-15 16:39:50 +02:00
static bool init_active_image(Object *ob,
ImageData *r_image_data,
PaintModeSettings *paint_mode_settings)
{
return BKE_paint_canvas_image_get(
paint_mode_settings, ob, &r_image_data->image, &r_image_data->image_user);
}
};
struct TexturePaintingUserData {
Object *ob;
Brush *brush;
PBVHNode **nodes;
ImageData image_data;
};
/** Reading and writing to image buffer with 4 float channels. */
class ImageBufferFloat4 {
private:
int pixel_offset;
public:
void set_image_position(ImBuf *image_buffer, ushort2 image_pixel_position)
{
pixel_offset = int(image_pixel_position.y) * image_buffer->x + int(image_pixel_position.x);
}
void next_pixel()
{
pixel_offset += 1;
}
float4 read_pixel(ImBuf *image_buffer) const
{
return &image_buffer->rect_float[pixel_offset * 4];
}
void write_pixel(ImBuf *image_buffer, const float4 pixel_data) const
{
copy_v4_v4(&image_buffer->rect_float[pixel_offset * 4], pixel_data);
}
const char *get_colorspace_name(ImBuf *image_buffer)
{
return IMB_colormanagement_get_float_colorspace(image_buffer);
}
};
/** Reading and writing to image buffer with 4 byte channels. */
class ImageBufferByte4 {
private:
int pixel_offset;
public:
void set_image_position(ImBuf *image_buffer, ushort2 image_pixel_position)
{
pixel_offset = int(image_pixel_position.y) * image_buffer->x + int(image_pixel_position.x);
}
void next_pixel()
{
pixel_offset += 1;
}
float4 read_pixel(ImBuf *image_buffer) const
{
float4 result;
rgba_uchar_to_float(result,
static_cast<const uchar *>(
static_cast<const void *>(&(image_buffer->rect[pixel_offset]))));
return result;
}
void write_pixel(ImBuf *image_buffer, const float4 pixel_data) const
{
rgba_float_to_uchar(
static_cast<uchar *>(static_cast<void *>(&image_buffer->rect[pixel_offset])), pixel_data);
}
const char *get_colorspace_name(ImBuf *image_buffer)
{
return IMB_colormanagement_get_rect_colorspace(image_buffer);
}
};
template<typename ImageBuffer> class PaintingKernel {
ImageBuffer image_accessor;
SculptSession *ss;
const Brush *brush;
const int thread_id;
const MVert *mvert;
float4 brush_color;
float brush_strength;
SculptBrushTestFn brush_test_fn;
SculptBrushTest test;
/* Pointer to the last used image buffer to detect when buffers are switched. */
void *last_used_image_buffer_ptr = nullptr;
const char *last_used_color_space = nullptr;
public:
explicit PaintingKernel(SculptSession *ss,
const Brush *brush,
const int thread_id,
const MVert *mvert)
: ss(ss), brush(brush), thread_id(thread_id), mvert(mvert)
{
init_brush_strength();
init_brush_test();
}
3D Texturing: Fix seam bleeding. {F13294314} # Process In the pixel extraction process a larger domain will be extracted then the input mesh. The borders of uv islands are extended with connected geometry of the input mesh. The extended mesh is then fed into the pixel extraction process. A mask is used to limit the extraction so UV islands will not overlap. Input UV islands. {F13206401} Extended UV Island (only one showing). {F13288764} This patch doesn't include fixing uv seams at non-manifold edges (like suzannes eyes) as that would require a different approach (edge extending or pixel copy-ing). The later has already been implemented in D14702, but should be revisited to only use do the non-manifold edge fixing. This patch supports fixing UV seams across UDIM textures. There might be an issue when using a single texture on multiple uv maps. Reviewed By: brecht, joeedh, JulienKaspar Maniphest Tasks: T97352 Differential Revision: https://developer.blender.org/D14970
2022-11-28 08:31:24 +01:00
bool paint(const PaintGeometryPrimitives &geom_primitives,
const PaintUVPrimitives &uv_primitives,
Sculpt: Normal-based automasking modes Two new normal-based automasking modes. The first mode, "brush", compares vertex normals with the initial normal at the beginning of the brush stroke. The second, "view", compares vertex normals with the view normal. If "occlusion" is on then rays will be shot from each vertex to test if it is occluded by other geometry (note: this can be very slow).\ Only geometry inside the sculpt mesh is considered. Each mode has an associated angular limit and a falloff. Reviewed by: Julien Kaspar and Jeroen Bakker Differential Revision: https://developer.blender.org/D15297 Ref D15297
2022-09-29 08:21:56 +02:00
const PackedPixelRow &pixel_row,
ImBuf *image_buffer,
AutomaskingNodeData *automask_data)
PBVH Pixel extractor. This patch contains an initial pixel extractor for PBVH and an initial paint brush implementation. PBVH is an accelleration structure blender uses internally to speed up 3d painting operations. At this moment it is extensively used by sculpt, vertex painting and weight painting. For the 3d texturing brush we will be using the PBVH for texture painting. Currently PBVH is organized to work on geometry (vertices, polygons and triangles). For texture painting this should be extended it to use pixels. {F12995467} Screen recording has been done on a Mac Mini with a 6 core 3.3 GHZ Intel processor. # Scope This patch only contains an extending uv seams to fix uv seams. This is not actually we want, but was easy to add to make the brush usable. Pixels are places in the PBVH_Leaf nodes. We want to introduce a special node for pixels, but that will be done in a separate patch to keep the code review small. This reduces the painting performance when using low and medium poly assets. In workbench textures aren't forced to be shown. For now use Material/Rendered view. # Rasterization process The rasterization process will generate the pixel information for a leaf node. In the future those leaf nodes will be split up into multiple leaf nodes to increase the performance when there isn't enough geometry. For this patch this was left out of scope. In order to do so every polygon should be uniquely assigned to a leaf node. For each leaf node for each polygon If polygon not assigned assign polygon to node. Polygons are to complicated to be used directly we have to split the polygons into triangles. For each leaf node for each polygon extract triangles from polygon. The list of triangles can be stored inside the leaf node. The list of polygons aren't needed anymore. Each triangle has: poly_index. vert_indices delta barycentric coordinate between x steps. Each triangle is rasterized in rows. Sequential pixels (in uv space) are stored in a single structure. image position barycentric coordinate of the first pixel number of pixels triangle index inside the leaf node. During the performed experiments we used a fairly simple rasterization process by finding the UV bounds of an triangle and calculate the barycentric coordinates per pixel inside the bounds. Even for complex models and huge images this process is normally finished within 0.5 second. It could be that we want to change this algorithm to reduce hickups when nodes are initialized during a stroke. Reviewed By: brecht Maniphest Tasks: T96710 Differential Revision: https://developer.blender.org/D14504
2022-04-15 16:39:50 +02:00
{
image_accessor.set_image_position(image_buffer, pixel_row.start_image_coordinate);
3D Texturing: Fix seam bleeding. {F13294314} # Process In the pixel extraction process a larger domain will be extracted then the input mesh. The borders of uv islands are extended with connected geometry of the input mesh. The extended mesh is then fed into the pixel extraction process. A mask is used to limit the extraction so UV islands will not overlap. Input UV islands. {F13206401} Extended UV Island (only one showing). {F13288764} This patch doesn't include fixing uv seams at non-manifold edges (like suzannes eyes) as that would require a different approach (edge extending or pixel copy-ing). The later has already been implemented in D14702, but should be revisited to only use do the non-manifold edge fixing. This patch supports fixing UV seams across UDIM textures. There might be an issue when using a single texture on multiple uv maps. Reviewed By: brecht, joeedh, JulienKaspar Maniphest Tasks: T97352 Differential Revision: https://developer.blender.org/D14970
2022-11-28 08:31:24 +01:00
const UVPrimitivePaintInput paint_input = uv_primitives.get_paint_input(
pixel_row.uv_primitive_index);
float3 pixel_pos = get_start_pixel_pos(geom_primitives, paint_input, pixel_row);
const float3 delta_pixel_pos = get_delta_pixel_pos(
geom_primitives, paint_input, pixel_row, pixel_pos);
PBVH Pixel extractor. This patch contains an initial pixel extractor for PBVH and an initial paint brush implementation. PBVH is an accelleration structure blender uses internally to speed up 3d painting operations. At this moment it is extensively used by sculpt, vertex painting and weight painting. For the 3d texturing brush we will be using the PBVH for texture painting. Currently PBVH is organized to work on geometry (vertices, polygons and triangles). For texture painting this should be extended it to use pixels. {F12995467} Screen recording has been done on a Mac Mini with a 6 core 3.3 GHZ Intel processor. # Scope This patch only contains an extending uv seams to fix uv seams. This is not actually we want, but was easy to add to make the brush usable. Pixels are places in the PBVH_Leaf nodes. We want to introduce a special node for pixels, but that will be done in a separate patch to keep the code review small. This reduces the painting performance when using low and medium poly assets. In workbench textures aren't forced to be shown. For now use Material/Rendered view. # Rasterization process The rasterization process will generate the pixel information for a leaf node. In the future those leaf nodes will be split up into multiple leaf nodes to increase the performance when there isn't enough geometry. For this patch this was left out of scope. In order to do so every polygon should be uniquely assigned to a leaf node. For each leaf node for each polygon If polygon not assigned assign polygon to node. Polygons are to complicated to be used directly we have to split the polygons into triangles. For each leaf node for each polygon extract triangles from polygon. The list of triangles can be stored inside the leaf node. The list of polygons aren't needed anymore. Each triangle has: poly_index. vert_indices delta barycentric coordinate between x steps. Each triangle is rasterized in rows. Sequential pixels (in uv space) are stored in a single structure. image position barycentric coordinate of the first pixel number of pixels triangle index inside the leaf node. During the performed experiments we used a fairly simple rasterization process by finding the UV bounds of an triangle and calculate the barycentric coordinates per pixel inside the bounds. Even for complex models and huge images this process is normally finished within 0.5 second. It could be that we want to change this algorithm to reduce hickups when nodes are initialized during a stroke. Reviewed By: brecht Maniphest Tasks: T96710 Differential Revision: https://developer.blender.org/D14504
2022-04-15 16:39:50 +02:00
bool pixels_painted = false;
for (int x = 0; x < pixel_row.num_pixels; x++) {
if (!brush_test_fn(&test, pixel_pos)) {
pixel_pos += delta_pixel_pos;
image_accessor.next_pixel();
continue;
}
float4 color = image_accessor.read_pixel(image_buffer);
const float3 normal(0.0f, 0.0f, 0.0f);
const float3 face_normal(0.0f, 0.0f, 0.0f);
const float mask = 0.0f;
Sculpt: Normal-based automasking modes Two new normal-based automasking modes. The first mode, "brush", compares vertex normals with the initial normal at the beginning of the brush stroke. The second, "view", compares vertex normals with the view normal. If "occlusion" is on then rays will be shot from each vertex to test if it is occluded by other geometry (note: this can be very slow).\ Only geometry inside the sculpt mesh is considered. Each mode has an associated angular limit and a falloff. Reviewed by: Julien Kaspar and Jeroen Bakker Differential Revision: https://developer.blender.org/D15297 Ref D15297
2022-09-29 08:21:56 +02:00
PBVH Pixel extractor. This patch contains an initial pixel extractor for PBVH and an initial paint brush implementation. PBVH is an accelleration structure blender uses internally to speed up 3d painting operations. At this moment it is extensively used by sculpt, vertex painting and weight painting. For the 3d texturing brush we will be using the PBVH for texture painting. Currently PBVH is organized to work on geometry (vertices, polygons and triangles). For texture painting this should be extended it to use pixels. {F12995467} Screen recording has been done on a Mac Mini with a 6 core 3.3 GHZ Intel processor. # Scope This patch only contains an extending uv seams to fix uv seams. This is not actually we want, but was easy to add to make the brush usable. Pixels are places in the PBVH_Leaf nodes. We want to introduce a special node for pixels, but that will be done in a separate patch to keep the code review small. This reduces the painting performance when using low and medium poly assets. In workbench textures aren't forced to be shown. For now use Material/Rendered view. # Rasterization process The rasterization process will generate the pixel information for a leaf node. In the future those leaf nodes will be split up into multiple leaf nodes to increase the performance when there isn't enough geometry. For this patch this was left out of scope. In order to do so every polygon should be uniquely assigned to a leaf node. For each leaf node for each polygon If polygon not assigned assign polygon to node. Polygons are to complicated to be used directly we have to split the polygons into triangles. For each leaf node for each polygon extract triangles from polygon. The list of triangles can be stored inside the leaf node. The list of polygons aren't needed anymore. Each triangle has: poly_index. vert_indices delta barycentric coordinate between x steps. Each triangle is rasterized in rows. Sequential pixels (in uv space) are stored in a single structure. image position barycentric coordinate of the first pixel number of pixels triangle index inside the leaf node. During the performed experiments we used a fairly simple rasterization process by finding the UV bounds of an triangle and calculate the barycentric coordinates per pixel inside the bounds. Even for complex models and huge images this process is normally finished within 0.5 second. It could be that we want to change this algorithm to reduce hickups when nodes are initialized during a stroke. Reviewed By: brecht Maniphest Tasks: T96710 Differential Revision: https://developer.blender.org/D14504
2022-04-15 16:39:50 +02:00
const float falloff_strength = SCULPT_brush_strength_factor(
Sculpt: Opaque vertex type for sculpt This is a port of sculpt-dev's `SculptVertRef` refactor (note that `SculptVertRef was renamed to PBVHVertRef`) to master. `PBVHVertRef` is a structure that abstracts the concept of a vertex in the sculpt code; it's simply an `intptr_t` wrapped in a struct. For `PBVH_FACES` and `PBVH_GRIDS` this struct stores a vertex index, but for `BMesh` it stores a direct pointer to a BMVert. The intptr_t is wrapped in a struct to prevent the accidental usage of it as an index. There are many reasons to do this: * Right now `BMesh` verts are not logical sculpt verts; to use the sculpt API they must first be converted to indices. This requires a lot of indirect lookups into tables, leading to performance loss. It has also led to greater code complexity and duplication. * Having an abstract vertex type makes it feasible to have one unified temporary attribute API for all three PBVH modes, which in turn made it rather trivial to port sculpt brushes to DynTopo in sculpt-dev (e.g. the layer brush, draw sharp, the smooth brushes, the paint brushes, etc). This attribute API will be in a future patch. * We need to do this anyway for the eventual move to C++. Differential Revision: https://developer.blender.org/D14272 Reviewed By: Brecht Van Lommel Ref D14272
2022-07-30 04:01:32 +02:00
ss,
brush,
pixel_pos,
sqrtf(test.dist),
normal,
face_normal,
mask,
BKE_pbvh_make_vref(PBVH_REF_NONE),
Sculpt: Normal-based automasking modes Two new normal-based automasking modes. The first mode, "brush", compares vertex normals with the initial normal at the beginning of the brush stroke. The second, "view", compares vertex normals with the view normal. If "occlusion" is on then rays will be shot from each vertex to test if it is occluded by other geometry (note: this can be very slow).\ Only geometry inside the sculpt mesh is considered. Each mode has an associated angular limit and a falloff. Reviewed by: Julien Kaspar and Jeroen Bakker Differential Revision: https://developer.blender.org/D15297 Ref D15297
2022-09-29 08:21:56 +02:00
thread_id,
automask_data);
PBVH Pixel extractor. This patch contains an initial pixel extractor for PBVH and an initial paint brush implementation. PBVH is an accelleration structure blender uses internally to speed up 3d painting operations. At this moment it is extensively used by sculpt, vertex painting and weight painting. For the 3d texturing brush we will be using the PBVH for texture painting. Currently PBVH is organized to work on geometry (vertices, polygons and triangles). For texture painting this should be extended it to use pixels. {F12995467} Screen recording has been done on a Mac Mini with a 6 core 3.3 GHZ Intel processor. # Scope This patch only contains an extending uv seams to fix uv seams. This is not actually we want, but was easy to add to make the brush usable. Pixels are places in the PBVH_Leaf nodes. We want to introduce a special node for pixels, but that will be done in a separate patch to keep the code review small. This reduces the painting performance when using low and medium poly assets. In workbench textures aren't forced to be shown. For now use Material/Rendered view. # Rasterization process The rasterization process will generate the pixel information for a leaf node. In the future those leaf nodes will be split up into multiple leaf nodes to increase the performance when there isn't enough geometry. For this patch this was left out of scope. In order to do so every polygon should be uniquely assigned to a leaf node. For each leaf node for each polygon If polygon not assigned assign polygon to node. Polygons are to complicated to be used directly we have to split the polygons into triangles. For each leaf node for each polygon extract triangles from polygon. The list of triangles can be stored inside the leaf node. The list of polygons aren't needed anymore. Each triangle has: poly_index. vert_indices delta barycentric coordinate between x steps. Each triangle is rasterized in rows. Sequential pixels (in uv space) are stored in a single structure. image position barycentric coordinate of the first pixel number of pixels triangle index inside the leaf node. During the performed experiments we used a fairly simple rasterization process by finding the UV bounds of an triangle and calculate the barycentric coordinates per pixel inside the bounds. Even for complex models and huge images this process is normally finished within 0.5 second. It could be that we want to change this algorithm to reduce hickups when nodes are initialized during a stroke. Reviewed By: brecht Maniphest Tasks: T96710 Differential Revision: https://developer.blender.org/D14504
2022-04-15 16:39:50 +02:00
float4 paint_color = brush_color * falloff_strength * brush_strength;
float4 buffer_color;
blend_color_mix_float(buffer_color, color, paint_color);
buffer_color *= brush->alpha;
IMB_blend_color_float(color, color, buffer_color, static_cast<IMB_BlendMode>(brush->blend));
image_accessor.write_pixel(image_buffer, color);
pixels_painted = true;
image_accessor.next_pixel();
pixel_pos += delta_pixel_pos;
}
return pixels_painted;
}
void init_brush_color(ImBuf *image_buffer)
{
const char *to_colorspace = image_accessor.get_colorspace_name(image_buffer);
if (last_used_color_space == to_colorspace) {
return;
}
copy_v3_v3(brush_color,
ss->cache->invert ? BKE_brush_secondary_color_get(ss->scene, brush) :
BKE_brush_color_get(ss->scene, brush));
/* NOTE: Brush colors are stored in sRGB. We use math color to follow other areas that
* use brush colors. From there on we use IMB_colormanagement to convert the brush color to the
* colorspace of the texture. This isn't ideal, but would need more refactoring to make sure
* that brush colors are stored in scene linear by default. */
srgb_to_linearrgb_v3_v3(brush_color, brush_color);
brush_color[3] = 1.0f;
const char *from_colorspace = IMB_colormanagement_role_colorspace_name_get(
COLOR_ROLE_SCENE_LINEAR);
ColormanageProcessor *cm_processor = IMB_colormanagement_colorspace_processor_new(
from_colorspace, to_colorspace);
IMB_colormanagement_processor_apply_v4(cm_processor, brush_color);
IMB_colormanagement_processor_free(cm_processor);
last_used_color_space = to_colorspace;
}
private:
void init_brush_strength()
{
brush_strength = ss->cache->bstrength;
}
void init_brush_test()
{
brush_test_fn = SCULPT_brush_test_init_with_falloff_shape(ss, &test, brush->falloff_shape);
}
/**
* Extract the starting pixel position from the given encoded_pixels belonging to the triangle.
*/
3D Texturing: Fix seam bleeding. {F13294314} # Process In the pixel extraction process a larger domain will be extracted then the input mesh. The borders of uv islands are extended with connected geometry of the input mesh. The extended mesh is then fed into the pixel extraction process. A mask is used to limit the extraction so UV islands will not overlap. Input UV islands. {F13206401} Extended UV Island (only one showing). {F13288764} This patch doesn't include fixing uv seams at non-manifold edges (like suzannes eyes) as that would require a different approach (edge extending or pixel copy-ing). The later has already been implemented in D14702, but should be revisited to only use do the non-manifold edge fixing. This patch supports fixing UV seams across UDIM textures. There might be an issue when using a single texture on multiple uv maps. Reviewed By: brecht, joeedh, JulienKaspar Maniphest Tasks: T97352 Differential Revision: https://developer.blender.org/D14970
2022-11-28 08:31:24 +01:00
float3 get_start_pixel_pos(const PaintGeometryPrimitives &geom_primitives,
const UVPrimitivePaintInput &paint_input,
PBVH Pixel extractor. This patch contains an initial pixel extractor for PBVH and an initial paint brush implementation. PBVH is an accelleration structure blender uses internally to speed up 3d painting operations. At this moment it is extensively used by sculpt, vertex painting and weight painting. For the 3d texturing brush we will be using the PBVH for texture painting. Currently PBVH is organized to work on geometry (vertices, polygons and triangles). For texture painting this should be extended it to use pixels. {F12995467} Screen recording has been done on a Mac Mini with a 6 core 3.3 GHZ Intel processor. # Scope This patch only contains an extending uv seams to fix uv seams. This is not actually we want, but was easy to add to make the brush usable. Pixels are places in the PBVH_Leaf nodes. We want to introduce a special node for pixels, but that will be done in a separate patch to keep the code review small. This reduces the painting performance when using low and medium poly assets. In workbench textures aren't forced to be shown. For now use Material/Rendered view. # Rasterization process The rasterization process will generate the pixel information for a leaf node. In the future those leaf nodes will be split up into multiple leaf nodes to increase the performance when there isn't enough geometry. For this patch this was left out of scope. In order to do so every polygon should be uniquely assigned to a leaf node. For each leaf node for each polygon If polygon not assigned assign polygon to node. Polygons are to complicated to be used directly we have to split the polygons into triangles. For each leaf node for each polygon extract triangles from polygon. The list of triangles can be stored inside the leaf node. The list of polygons aren't needed anymore. Each triangle has: poly_index. vert_indices delta barycentric coordinate between x steps. Each triangle is rasterized in rows. Sequential pixels (in uv space) are stored in a single structure. image position barycentric coordinate of the first pixel number of pixels triangle index inside the leaf node. During the performed experiments we used a fairly simple rasterization process by finding the UV bounds of an triangle and calculate the barycentric coordinates per pixel inside the bounds. Even for complex models and huge images this process is normally finished within 0.5 second. It could be that we want to change this algorithm to reduce hickups when nodes are initialized during a stroke. Reviewed By: brecht Maniphest Tasks: T96710 Differential Revision: https://developer.blender.org/D14504
2022-04-15 16:39:50 +02:00
const PackedPixelRow &encoded_pixels) const
{
3D Texturing: Fix seam bleeding. {F13294314} # Process In the pixel extraction process a larger domain will be extracted then the input mesh. The borders of uv islands are extended with connected geometry of the input mesh. The extended mesh is then fed into the pixel extraction process. A mask is used to limit the extraction so UV islands will not overlap. Input UV islands. {F13206401} Extended UV Island (only one showing). {F13288764} This patch doesn't include fixing uv seams at non-manifold edges (like suzannes eyes) as that would require a different approach (edge extending or pixel copy-ing). The later has already been implemented in D14702, but should be revisited to only use do the non-manifold edge fixing. This patch supports fixing UV seams across UDIM textures. There might be an issue when using a single texture on multiple uv maps. Reviewed By: brecht, joeedh, JulienKaspar Maniphest Tasks: T97352 Differential Revision: https://developer.blender.org/D14970
2022-11-28 08:31:24 +01:00
return init_pixel_pos(geom_primitives, paint_input, encoded_pixels.start_barycentric_coord);
PBVH Pixel extractor. This patch contains an initial pixel extractor for PBVH and an initial paint brush implementation. PBVH is an accelleration structure blender uses internally to speed up 3d painting operations. At this moment it is extensively used by sculpt, vertex painting and weight painting. For the 3d texturing brush we will be using the PBVH for texture painting. Currently PBVH is organized to work on geometry (vertices, polygons and triangles). For texture painting this should be extended it to use pixels. {F12995467} Screen recording has been done on a Mac Mini with a 6 core 3.3 GHZ Intel processor. # Scope This patch only contains an extending uv seams to fix uv seams. This is not actually we want, but was easy to add to make the brush usable. Pixels are places in the PBVH_Leaf nodes. We want to introduce a special node for pixels, but that will be done in a separate patch to keep the code review small. This reduces the painting performance when using low and medium poly assets. In workbench textures aren't forced to be shown. For now use Material/Rendered view. # Rasterization process The rasterization process will generate the pixel information for a leaf node. In the future those leaf nodes will be split up into multiple leaf nodes to increase the performance when there isn't enough geometry. For this patch this was left out of scope. In order to do so every polygon should be uniquely assigned to a leaf node. For each leaf node for each polygon If polygon not assigned assign polygon to node. Polygons are to complicated to be used directly we have to split the polygons into triangles. For each leaf node for each polygon extract triangles from polygon. The list of triangles can be stored inside the leaf node. The list of polygons aren't needed anymore. Each triangle has: poly_index. vert_indices delta barycentric coordinate between x steps. Each triangle is rasterized in rows. Sequential pixels (in uv space) are stored in a single structure. image position barycentric coordinate of the first pixel number of pixels triangle index inside the leaf node. During the performed experiments we used a fairly simple rasterization process by finding the UV bounds of an triangle and calculate the barycentric coordinates per pixel inside the bounds. Even for complex models and huge images this process is normally finished within 0.5 second. It could be that we want to change this algorithm to reduce hickups when nodes are initialized during a stroke. Reviewed By: brecht Maniphest Tasks: T96710 Differential Revision: https://developer.blender.org/D14504
2022-04-15 16:39:50 +02:00
}
/**
* Extract the delta pixel position that will be used to advance a Pixel instance to the next
* pixel.
*/
3D Texturing: Fix seam bleeding. {F13294314} # Process In the pixel extraction process a larger domain will be extracted then the input mesh. The borders of uv islands are extended with connected geometry of the input mesh. The extended mesh is then fed into the pixel extraction process. A mask is used to limit the extraction so UV islands will not overlap. Input UV islands. {F13206401} Extended UV Island (only one showing). {F13288764} This patch doesn't include fixing uv seams at non-manifold edges (like suzannes eyes) as that would require a different approach (edge extending or pixel copy-ing). The later has already been implemented in D14702, but should be revisited to only use do the non-manifold edge fixing. This patch supports fixing UV seams across UDIM textures. There might be an issue when using a single texture on multiple uv maps. Reviewed By: brecht, joeedh, JulienKaspar Maniphest Tasks: T97352 Differential Revision: https://developer.blender.org/D14970
2022-11-28 08:31:24 +01:00
float3 get_delta_pixel_pos(const PaintGeometryPrimitives &geom_primitives,
const UVPrimitivePaintInput &paint_input,
PBVH Pixel extractor. This patch contains an initial pixel extractor for PBVH and an initial paint brush implementation. PBVH is an accelleration structure blender uses internally to speed up 3d painting operations. At this moment it is extensively used by sculpt, vertex painting and weight painting. For the 3d texturing brush we will be using the PBVH for texture painting. Currently PBVH is organized to work on geometry (vertices, polygons and triangles). For texture painting this should be extended it to use pixels. {F12995467} Screen recording has been done on a Mac Mini with a 6 core 3.3 GHZ Intel processor. # Scope This patch only contains an extending uv seams to fix uv seams. This is not actually we want, but was easy to add to make the brush usable. Pixels are places in the PBVH_Leaf nodes. We want to introduce a special node for pixels, but that will be done in a separate patch to keep the code review small. This reduces the painting performance when using low and medium poly assets. In workbench textures aren't forced to be shown. For now use Material/Rendered view. # Rasterization process The rasterization process will generate the pixel information for a leaf node. In the future those leaf nodes will be split up into multiple leaf nodes to increase the performance when there isn't enough geometry. For this patch this was left out of scope. In order to do so every polygon should be uniquely assigned to a leaf node. For each leaf node for each polygon If polygon not assigned assign polygon to node. Polygons are to complicated to be used directly we have to split the polygons into triangles. For each leaf node for each polygon extract triangles from polygon. The list of triangles can be stored inside the leaf node. The list of polygons aren't needed anymore. Each triangle has: poly_index. vert_indices delta barycentric coordinate between x steps. Each triangle is rasterized in rows. Sequential pixels (in uv space) are stored in a single structure. image position barycentric coordinate of the first pixel number of pixels triangle index inside the leaf node. During the performed experiments we used a fairly simple rasterization process by finding the UV bounds of an triangle and calculate the barycentric coordinates per pixel inside the bounds. Even for complex models and huge images this process is normally finished within 0.5 second. It could be that we want to change this algorithm to reduce hickups when nodes are initialized during a stroke. Reviewed By: brecht Maniphest Tasks: T96710 Differential Revision: https://developer.blender.org/D14504
2022-04-15 16:39:50 +02:00
const PackedPixelRow &encoded_pixels,
const float3 &start_pixel) const
{
3D Texturing: Fix seam bleeding. {F13294314} # Process In the pixel extraction process a larger domain will be extracted then the input mesh. The borders of uv islands are extended with connected geometry of the input mesh. The extended mesh is then fed into the pixel extraction process. A mask is used to limit the extraction so UV islands will not overlap. Input UV islands. {F13206401} Extended UV Island (only one showing). {F13288764} This patch doesn't include fixing uv seams at non-manifold edges (like suzannes eyes) as that would require a different approach (edge extending or pixel copy-ing). The later has already been implemented in D14702, but should be revisited to only use do the non-manifold edge fixing. This patch supports fixing UV seams across UDIM textures. There might be an issue when using a single texture on multiple uv maps. Reviewed By: brecht, joeedh, JulienKaspar Maniphest Tasks: T97352 Differential Revision: https://developer.blender.org/D14970
2022-11-28 08:31:24 +01:00
float3 result = init_pixel_pos(geom_primitives,
paint_input,
encoded_pixels.start_barycentric_coord +
paint_input.delta_barycentric_coord_u);
PBVH Pixel extractor. This patch contains an initial pixel extractor for PBVH and an initial paint brush implementation. PBVH is an accelleration structure blender uses internally to speed up 3d painting operations. At this moment it is extensively used by sculpt, vertex painting and weight painting. For the 3d texturing brush we will be using the PBVH for texture painting. Currently PBVH is organized to work on geometry (vertices, polygons and triangles). For texture painting this should be extended it to use pixels. {F12995467} Screen recording has been done on a Mac Mini with a 6 core 3.3 GHZ Intel processor. # Scope This patch only contains an extending uv seams to fix uv seams. This is not actually we want, but was easy to add to make the brush usable. Pixels are places in the PBVH_Leaf nodes. We want to introduce a special node for pixels, but that will be done in a separate patch to keep the code review small. This reduces the painting performance when using low and medium poly assets. In workbench textures aren't forced to be shown. For now use Material/Rendered view. # Rasterization process The rasterization process will generate the pixel information for a leaf node. In the future those leaf nodes will be split up into multiple leaf nodes to increase the performance when there isn't enough geometry. For this patch this was left out of scope. In order to do so every polygon should be uniquely assigned to a leaf node. For each leaf node for each polygon If polygon not assigned assign polygon to node. Polygons are to complicated to be used directly we have to split the polygons into triangles. For each leaf node for each polygon extract triangles from polygon. The list of triangles can be stored inside the leaf node. The list of polygons aren't needed anymore. Each triangle has: poly_index. vert_indices delta barycentric coordinate between x steps. Each triangle is rasterized in rows. Sequential pixels (in uv space) are stored in a single structure. image position barycentric coordinate of the first pixel number of pixels triangle index inside the leaf node. During the performed experiments we used a fairly simple rasterization process by finding the UV bounds of an triangle and calculate the barycentric coordinates per pixel inside the bounds. Even for complex models and huge images this process is normally finished within 0.5 second. It could be that we want to change this algorithm to reduce hickups when nodes are initialized during a stroke. Reviewed By: brecht Maniphest Tasks: T96710 Differential Revision: https://developer.blender.org/D14504
2022-04-15 16:39:50 +02:00
return result - start_pixel;
}
3D Texturing: Fix seam bleeding. {F13294314} # Process In the pixel extraction process a larger domain will be extracted then the input mesh. The borders of uv islands are extended with connected geometry of the input mesh. The extended mesh is then fed into the pixel extraction process. A mask is used to limit the extraction so UV islands will not overlap. Input UV islands. {F13206401} Extended UV Island (only one showing). {F13288764} This patch doesn't include fixing uv seams at non-manifold edges (like suzannes eyes) as that would require a different approach (edge extending or pixel copy-ing). The later has already been implemented in D14702, but should be revisited to only use do the non-manifold edge fixing. This patch supports fixing UV seams across UDIM textures. There might be an issue when using a single texture on multiple uv maps. Reviewed By: brecht, joeedh, JulienKaspar Maniphest Tasks: T97352 Differential Revision: https://developer.blender.org/D14970
2022-11-28 08:31:24 +01:00
float3 init_pixel_pos(const PaintGeometryPrimitives &geom_primitives,
const UVPrimitivePaintInput &paint_input,
PBVH Pixel extractor. This patch contains an initial pixel extractor for PBVH and an initial paint brush implementation. PBVH is an accelleration structure blender uses internally to speed up 3d painting operations. At this moment it is extensively used by sculpt, vertex painting and weight painting. For the 3d texturing brush we will be using the PBVH for texture painting. Currently PBVH is organized to work on geometry (vertices, polygons and triangles). For texture painting this should be extended it to use pixels. {F12995467} Screen recording has been done on a Mac Mini with a 6 core 3.3 GHZ Intel processor. # Scope This patch only contains an extending uv seams to fix uv seams. This is not actually we want, but was easy to add to make the brush usable. Pixels are places in the PBVH_Leaf nodes. We want to introduce a special node for pixels, but that will be done in a separate patch to keep the code review small. This reduces the painting performance when using low and medium poly assets. In workbench textures aren't forced to be shown. For now use Material/Rendered view. # Rasterization process The rasterization process will generate the pixel information for a leaf node. In the future those leaf nodes will be split up into multiple leaf nodes to increase the performance when there isn't enough geometry. For this patch this was left out of scope. In order to do so every polygon should be uniquely assigned to a leaf node. For each leaf node for each polygon If polygon not assigned assign polygon to node. Polygons are to complicated to be used directly we have to split the polygons into triangles. For each leaf node for each polygon extract triangles from polygon. The list of triangles can be stored inside the leaf node. The list of polygons aren't needed anymore. Each triangle has: poly_index. vert_indices delta barycentric coordinate between x steps. Each triangle is rasterized in rows. Sequential pixels (in uv space) are stored in a single structure. image position barycentric coordinate of the first pixel number of pixels triangle index inside the leaf node. During the performed experiments we used a fairly simple rasterization process by finding the UV bounds of an triangle and calculate the barycentric coordinates per pixel inside the bounds. Even for complex models and huge images this process is normally finished within 0.5 second. It could be that we want to change this algorithm to reduce hickups when nodes are initialized during a stroke. Reviewed By: brecht Maniphest Tasks: T96710 Differential Revision: https://developer.blender.org/D14504
2022-04-15 16:39:50 +02:00
const float2 &barycentric_weights) const
{
3D Texturing: Fix seam bleeding. {F13294314} # Process In the pixel extraction process a larger domain will be extracted then the input mesh. The borders of uv islands are extended with connected geometry of the input mesh. The extended mesh is then fed into the pixel extraction process. A mask is used to limit the extraction so UV islands will not overlap. Input UV islands. {F13206401} Extended UV Island (only one showing). {F13288764} This patch doesn't include fixing uv seams at non-manifold edges (like suzannes eyes) as that would require a different approach (edge extending or pixel copy-ing). The later has already been implemented in D14702, but should be revisited to only use do the non-manifold edge fixing. This patch supports fixing UV seams across UDIM textures. There might be an issue when using a single texture on multiple uv maps. Reviewed By: brecht, joeedh, JulienKaspar Maniphest Tasks: T97352 Differential Revision: https://developer.blender.org/D14970
2022-11-28 08:31:24 +01:00
const int3 &vert_indices = geom_primitives.get_vert_indices(
paint_input.geometry_primitive_index);
PBVH Pixel extractor. This patch contains an initial pixel extractor for PBVH and an initial paint brush implementation. PBVH is an accelleration structure blender uses internally to speed up 3d painting operations. At this moment it is extensively used by sculpt, vertex painting and weight painting. For the 3d texturing brush we will be using the PBVH for texture painting. Currently PBVH is organized to work on geometry (vertices, polygons and triangles). For texture painting this should be extended it to use pixels. {F12995467} Screen recording has been done on a Mac Mini with a 6 core 3.3 GHZ Intel processor. # Scope This patch only contains an extending uv seams to fix uv seams. This is not actually we want, but was easy to add to make the brush usable. Pixels are places in the PBVH_Leaf nodes. We want to introduce a special node for pixels, but that will be done in a separate patch to keep the code review small. This reduces the painting performance when using low and medium poly assets. In workbench textures aren't forced to be shown. For now use Material/Rendered view. # Rasterization process The rasterization process will generate the pixel information for a leaf node. In the future those leaf nodes will be split up into multiple leaf nodes to increase the performance when there isn't enough geometry. For this patch this was left out of scope. In order to do so every polygon should be uniquely assigned to a leaf node. For each leaf node for each polygon If polygon not assigned assign polygon to node. Polygons are to complicated to be used directly we have to split the polygons into triangles. For each leaf node for each polygon extract triangles from polygon. The list of triangles can be stored inside the leaf node. The list of polygons aren't needed anymore. Each triangle has: poly_index. vert_indices delta barycentric coordinate between x steps. Each triangle is rasterized in rows. Sequential pixels (in uv space) are stored in a single structure. image position barycentric coordinate of the first pixel number of pixels triangle index inside the leaf node. During the performed experiments we used a fairly simple rasterization process by finding the UV bounds of an triangle and calculate the barycentric coordinates per pixel inside the bounds. Even for complex models and huge images this process is normally finished within 0.5 second. It could be that we want to change this algorithm to reduce hickups when nodes are initialized during a stroke. Reviewed By: brecht Maniphest Tasks: T96710 Differential Revision: https://developer.blender.org/D14504
2022-04-15 16:39:50 +02:00
float3 result;
const float3 barycentric(barycentric_weights.x,
barycentric_weights.y,
1.0f - barycentric_weights.x - barycentric_weights.y);
interp_v3_v3v3v3(result,
mvert[vert_indices[0]].co,
mvert[vert_indices[1]].co,
mvert[vert_indices[2]].co,
barycentric);
return result;
}
};
3D Texturing: Fix seam bleeding. {F13294314} # Process In the pixel extraction process a larger domain will be extracted then the input mesh. The borders of uv islands are extended with connected geometry of the input mesh. The extended mesh is then fed into the pixel extraction process. A mask is used to limit the extraction so UV islands will not overlap. Input UV islands. {F13206401} Extended UV Island (only one showing). {F13288764} This patch doesn't include fixing uv seams at non-manifold edges (like suzannes eyes) as that would require a different approach (edge extending or pixel copy-ing). The later has already been implemented in D14702, but should be revisited to only use do the non-manifold edge fixing. This patch supports fixing UV seams across UDIM textures. There might be an issue when using a single texture on multiple uv maps. Reviewed By: brecht, joeedh, JulienKaspar Maniphest Tasks: T97352 Differential Revision: https://developer.blender.org/D14970
2022-11-28 08:31:24 +01:00
static std::vector<bool> init_uv_primitives_brush_test(SculptSession *ss,
PaintGeometryPrimitives &geom_primitives,
PaintUVPrimitives &uv_primitives,
const MVert *mvert)
PBVH Pixel extractor. This patch contains an initial pixel extractor for PBVH and an initial paint brush implementation. PBVH is an accelleration structure blender uses internally to speed up 3d painting operations. At this moment it is extensively used by sculpt, vertex painting and weight painting. For the 3d texturing brush we will be using the PBVH for texture painting. Currently PBVH is organized to work on geometry (vertices, polygons and triangles). For texture painting this should be extended it to use pixels. {F12995467} Screen recording has been done on a Mac Mini with a 6 core 3.3 GHZ Intel processor. # Scope This patch only contains an extending uv seams to fix uv seams. This is not actually we want, but was easy to add to make the brush usable. Pixels are places in the PBVH_Leaf nodes. We want to introduce a special node for pixels, but that will be done in a separate patch to keep the code review small. This reduces the painting performance when using low and medium poly assets. In workbench textures aren't forced to be shown. For now use Material/Rendered view. # Rasterization process The rasterization process will generate the pixel information for a leaf node. In the future those leaf nodes will be split up into multiple leaf nodes to increase the performance when there isn't enough geometry. For this patch this was left out of scope. In order to do so every polygon should be uniquely assigned to a leaf node. For each leaf node for each polygon If polygon not assigned assign polygon to node. Polygons are to complicated to be used directly we have to split the polygons into triangles. For each leaf node for each polygon extract triangles from polygon. The list of triangles can be stored inside the leaf node. The list of polygons aren't needed anymore. Each triangle has: poly_index. vert_indices delta barycentric coordinate between x steps. Each triangle is rasterized in rows. Sequential pixels (in uv space) are stored in a single structure. image position barycentric coordinate of the first pixel number of pixels triangle index inside the leaf node. During the performed experiments we used a fairly simple rasterization process by finding the UV bounds of an triangle and calculate the barycentric coordinates per pixel inside the bounds. Even for complex models and huge images this process is normally finished within 0.5 second. It could be that we want to change this algorithm to reduce hickups when nodes are initialized during a stroke. Reviewed By: brecht Maniphest Tasks: T96710 Differential Revision: https://developer.blender.org/D14504
2022-04-15 16:39:50 +02:00
{
3D Texturing: Fix seam bleeding. {F13294314} # Process In the pixel extraction process a larger domain will be extracted then the input mesh. The borders of uv islands are extended with connected geometry of the input mesh. The extended mesh is then fed into the pixel extraction process. A mask is used to limit the extraction so UV islands will not overlap. Input UV islands. {F13206401} Extended UV Island (only one showing). {F13288764} This patch doesn't include fixing uv seams at non-manifold edges (like suzannes eyes) as that would require a different approach (edge extending or pixel copy-ing). The later has already been implemented in D14702, but should be revisited to only use do the non-manifold edge fixing. This patch supports fixing UV seams across UDIM textures. There might be an issue when using a single texture on multiple uv maps. Reviewed By: brecht, joeedh, JulienKaspar Maniphest Tasks: T97352 Differential Revision: https://developer.blender.org/D14970
2022-11-28 08:31:24 +01:00
std::vector<bool> brush_test(uv_primitives.size());
PBVH Pixel extractor. This patch contains an initial pixel extractor for PBVH and an initial paint brush implementation. PBVH is an accelleration structure blender uses internally to speed up 3d painting operations. At this moment it is extensively used by sculpt, vertex painting and weight painting. For the 3d texturing brush we will be using the PBVH for texture painting. Currently PBVH is organized to work on geometry (vertices, polygons and triangles). For texture painting this should be extended it to use pixels. {F12995467} Screen recording has been done on a Mac Mini with a 6 core 3.3 GHZ Intel processor. # Scope This patch only contains an extending uv seams to fix uv seams. This is not actually we want, but was easy to add to make the brush usable. Pixels are places in the PBVH_Leaf nodes. We want to introduce a special node for pixels, but that will be done in a separate patch to keep the code review small. This reduces the painting performance when using low and medium poly assets. In workbench textures aren't forced to be shown. For now use Material/Rendered view. # Rasterization process The rasterization process will generate the pixel information for a leaf node. In the future those leaf nodes will be split up into multiple leaf nodes to increase the performance when there isn't enough geometry. For this patch this was left out of scope. In order to do so every polygon should be uniquely assigned to a leaf node. For each leaf node for each polygon If polygon not assigned assign polygon to node. Polygons are to complicated to be used directly we have to split the polygons into triangles. For each leaf node for each polygon extract triangles from polygon. The list of triangles can be stored inside the leaf node. The list of polygons aren't needed anymore. Each triangle has: poly_index. vert_indices delta barycentric coordinate between x steps. Each triangle is rasterized in rows. Sequential pixels (in uv space) are stored in a single structure. image position barycentric coordinate of the first pixel number of pixels triangle index inside the leaf node. During the performed experiments we used a fairly simple rasterization process by finding the UV bounds of an triangle and calculate the barycentric coordinates per pixel inside the bounds. Even for complex models and huge images this process is normally finished within 0.5 second. It could be that we want to change this algorithm to reduce hickups when nodes are initialized during a stroke. Reviewed By: brecht Maniphest Tasks: T96710 Differential Revision: https://developer.blender.org/D14504
2022-04-15 16:39:50 +02:00
SculptBrushTest test;
SCULPT_brush_test_init(ss, &test);
float3 brush_min_bounds(test.location[0] - test.radius,
test.location[1] - test.radius,
test.location[2] - test.radius);
float3 brush_max_bounds(test.location[0] + test.radius,
test.location[1] + test.radius,
test.location[2] + test.radius);
3D Texturing: Fix seam bleeding. {F13294314} # Process In the pixel extraction process a larger domain will be extracted then the input mesh. The borders of uv islands are extended with connected geometry of the input mesh. The extended mesh is then fed into the pixel extraction process. A mask is used to limit the extraction so UV islands will not overlap. Input UV islands. {F13206401} Extended UV Island (only one showing). {F13288764} This patch doesn't include fixing uv seams at non-manifold edges (like suzannes eyes) as that would require a different approach (edge extending or pixel copy-ing). The later has already been implemented in D14702, but should be revisited to only use do the non-manifold edge fixing. This patch supports fixing UV seams across UDIM textures. There might be an issue when using a single texture on multiple uv maps. Reviewed By: brecht, joeedh, JulienKaspar Maniphest Tasks: T97352 Differential Revision: https://developer.blender.org/D14970
2022-11-28 08:31:24 +01:00
for (int uv_prim_index = 0; uv_prim_index < uv_primitives.size(); uv_prim_index++) {
const UVPrimitivePaintInput &paint_input = uv_primitives.get_paint_input(uv_prim_index);
const int3 &vert_indices = geom_primitives.get_vert_indices(
paint_input.geometry_primitive_index);
PBVH Pixel extractor. This patch contains an initial pixel extractor for PBVH and an initial paint brush implementation. PBVH is an accelleration structure blender uses internally to speed up 3d painting operations. At this moment it is extensively used by sculpt, vertex painting and weight painting. For the 3d texturing brush we will be using the PBVH for texture painting. Currently PBVH is organized to work on geometry (vertices, polygons and triangles). For texture painting this should be extended it to use pixels. {F12995467} Screen recording has been done on a Mac Mini with a 6 core 3.3 GHZ Intel processor. # Scope This patch only contains an extending uv seams to fix uv seams. This is not actually we want, but was easy to add to make the brush usable. Pixels are places in the PBVH_Leaf nodes. We want to introduce a special node for pixels, but that will be done in a separate patch to keep the code review small. This reduces the painting performance when using low and medium poly assets. In workbench textures aren't forced to be shown. For now use Material/Rendered view. # Rasterization process The rasterization process will generate the pixel information for a leaf node. In the future those leaf nodes will be split up into multiple leaf nodes to increase the performance when there isn't enough geometry. For this patch this was left out of scope. In order to do so every polygon should be uniquely assigned to a leaf node. For each leaf node for each polygon If polygon not assigned assign polygon to node. Polygons are to complicated to be used directly we have to split the polygons into triangles. For each leaf node for each polygon extract triangles from polygon. The list of triangles can be stored inside the leaf node. The list of polygons aren't needed anymore. Each triangle has: poly_index. vert_indices delta barycentric coordinate between x steps. Each triangle is rasterized in rows. Sequential pixels (in uv space) are stored in a single structure. image position barycentric coordinate of the first pixel number of pixels triangle index inside the leaf node. During the performed experiments we used a fairly simple rasterization process by finding the UV bounds of an triangle and calculate the barycentric coordinates per pixel inside the bounds. Even for complex models and huge images this process is normally finished within 0.5 second. It could be that we want to change this algorithm to reduce hickups when nodes are initialized during a stroke. Reviewed By: brecht Maniphest Tasks: T96710 Differential Revision: https://developer.blender.org/D14504
2022-04-15 16:39:50 +02:00
3D Texturing: Fix seam bleeding. {F13294314} # Process In the pixel extraction process a larger domain will be extracted then the input mesh. The borders of uv islands are extended with connected geometry of the input mesh. The extended mesh is then fed into the pixel extraction process. A mask is used to limit the extraction so UV islands will not overlap. Input UV islands. {F13206401} Extended UV Island (only one showing). {F13288764} This patch doesn't include fixing uv seams at non-manifold edges (like suzannes eyes) as that would require a different approach (edge extending or pixel copy-ing). The later has already been implemented in D14702, but should be revisited to only use do the non-manifold edge fixing. This patch supports fixing UV seams across UDIM textures. There might be an issue when using a single texture on multiple uv maps. Reviewed By: brecht, joeedh, JulienKaspar Maniphest Tasks: T97352 Differential Revision: https://developer.blender.org/D14970
2022-11-28 08:31:24 +01:00
float3 triangle_min_bounds(mvert[vert_indices[0]].co);
PBVH Pixel extractor. This patch contains an initial pixel extractor for PBVH and an initial paint brush implementation. PBVH is an accelleration structure blender uses internally to speed up 3d painting operations. At this moment it is extensively used by sculpt, vertex painting and weight painting. For the 3d texturing brush we will be using the PBVH for texture painting. Currently PBVH is organized to work on geometry (vertices, polygons and triangles). For texture painting this should be extended it to use pixels. {F12995467} Screen recording has been done on a Mac Mini with a 6 core 3.3 GHZ Intel processor. # Scope This patch only contains an extending uv seams to fix uv seams. This is not actually we want, but was easy to add to make the brush usable. Pixels are places in the PBVH_Leaf nodes. We want to introduce a special node for pixels, but that will be done in a separate patch to keep the code review small. This reduces the painting performance when using low and medium poly assets. In workbench textures aren't forced to be shown. For now use Material/Rendered view. # Rasterization process The rasterization process will generate the pixel information for a leaf node. In the future those leaf nodes will be split up into multiple leaf nodes to increase the performance when there isn't enough geometry. For this patch this was left out of scope. In order to do so every polygon should be uniquely assigned to a leaf node. For each leaf node for each polygon If polygon not assigned assign polygon to node. Polygons are to complicated to be used directly we have to split the polygons into triangles. For each leaf node for each polygon extract triangles from polygon. The list of triangles can be stored inside the leaf node. The list of polygons aren't needed anymore. Each triangle has: poly_index. vert_indices delta barycentric coordinate between x steps. Each triangle is rasterized in rows. Sequential pixels (in uv space) are stored in a single structure. image position barycentric coordinate of the first pixel number of pixels triangle index inside the leaf node. During the performed experiments we used a fairly simple rasterization process by finding the UV bounds of an triangle and calculate the barycentric coordinates per pixel inside the bounds. Even for complex models and huge images this process is normally finished within 0.5 second. It could be that we want to change this algorithm to reduce hickups when nodes are initialized during a stroke. Reviewed By: brecht Maniphest Tasks: T96710 Differential Revision: https://developer.blender.org/D14504
2022-04-15 16:39:50 +02:00
float3 triangle_max_bounds(triangle_min_bounds);
for (int i = 1; i < 3; i++) {
3D Texturing: Fix seam bleeding. {F13294314} # Process In the pixel extraction process a larger domain will be extracted then the input mesh. The borders of uv islands are extended with connected geometry of the input mesh. The extended mesh is then fed into the pixel extraction process. A mask is used to limit the extraction so UV islands will not overlap. Input UV islands. {F13206401} Extended UV Island (only one showing). {F13288764} This patch doesn't include fixing uv seams at non-manifold edges (like suzannes eyes) as that would require a different approach (edge extending or pixel copy-ing). The later has already been implemented in D14702, but should be revisited to only use do the non-manifold edge fixing. This patch supports fixing UV seams across UDIM textures. There might be an issue when using a single texture on multiple uv maps. Reviewed By: brecht, joeedh, JulienKaspar Maniphest Tasks: T97352 Differential Revision: https://developer.blender.org/D14970
2022-11-28 08:31:24 +01:00
const float3 &pos = mvert[vert_indices[i]].co;
PBVH Pixel extractor. This patch contains an initial pixel extractor for PBVH and an initial paint brush implementation. PBVH is an accelleration structure blender uses internally to speed up 3d painting operations. At this moment it is extensively used by sculpt, vertex painting and weight painting. For the 3d texturing brush we will be using the PBVH for texture painting. Currently PBVH is organized to work on geometry (vertices, polygons and triangles). For texture painting this should be extended it to use pixels. {F12995467} Screen recording has been done on a Mac Mini with a 6 core 3.3 GHZ Intel processor. # Scope This patch only contains an extending uv seams to fix uv seams. This is not actually we want, but was easy to add to make the brush usable. Pixels are places in the PBVH_Leaf nodes. We want to introduce a special node for pixels, but that will be done in a separate patch to keep the code review small. This reduces the painting performance when using low and medium poly assets. In workbench textures aren't forced to be shown. For now use Material/Rendered view. # Rasterization process The rasterization process will generate the pixel information for a leaf node. In the future those leaf nodes will be split up into multiple leaf nodes to increase the performance when there isn't enough geometry. For this patch this was left out of scope. In order to do so every polygon should be uniquely assigned to a leaf node. For each leaf node for each polygon If polygon not assigned assign polygon to node. Polygons are to complicated to be used directly we have to split the polygons into triangles. For each leaf node for each polygon extract triangles from polygon. The list of triangles can be stored inside the leaf node. The list of polygons aren't needed anymore. Each triangle has: poly_index. vert_indices delta barycentric coordinate between x steps. Each triangle is rasterized in rows. Sequential pixels (in uv space) are stored in a single structure. image position barycentric coordinate of the first pixel number of pixels triangle index inside the leaf node. During the performed experiments we used a fairly simple rasterization process by finding the UV bounds of an triangle and calculate the barycentric coordinates per pixel inside the bounds. Even for complex models and huge images this process is normally finished within 0.5 second. It could be that we want to change this algorithm to reduce hickups when nodes are initialized during a stroke. Reviewed By: brecht Maniphest Tasks: T96710 Differential Revision: https://developer.blender.org/D14504
2022-04-15 16:39:50 +02:00
triangle_min_bounds.x = min_ff(triangle_min_bounds.x, pos.x);
triangle_min_bounds.y = min_ff(triangle_min_bounds.y, pos.y);
triangle_min_bounds.z = min_ff(triangle_min_bounds.z, pos.z);
triangle_max_bounds.x = max_ff(triangle_max_bounds.x, pos.x);
triangle_max_bounds.y = max_ff(triangle_max_bounds.y, pos.y);
triangle_max_bounds.z = max_ff(triangle_max_bounds.z, pos.z);
}
3D Texturing: Fix seam bleeding. {F13294314} # Process In the pixel extraction process a larger domain will be extracted then the input mesh. The borders of uv islands are extended with connected geometry of the input mesh. The extended mesh is then fed into the pixel extraction process. A mask is used to limit the extraction so UV islands will not overlap. Input UV islands. {F13206401} Extended UV Island (only one showing). {F13288764} This patch doesn't include fixing uv seams at non-manifold edges (like suzannes eyes) as that would require a different approach (edge extending or pixel copy-ing). The later has already been implemented in D14702, but should be revisited to only use do the non-manifold edge fixing. This patch supports fixing UV seams across UDIM textures. There might be an issue when using a single texture on multiple uv maps. Reviewed By: brecht, joeedh, JulienKaspar Maniphest Tasks: T97352 Differential Revision: https://developer.blender.org/D14970
2022-11-28 08:31:24 +01:00
brush_test[uv_prim_index] = isect_aabb_aabb_v3(
PBVH Pixel extractor. This patch contains an initial pixel extractor for PBVH and an initial paint brush implementation. PBVH is an accelleration structure blender uses internally to speed up 3d painting operations. At this moment it is extensively used by sculpt, vertex painting and weight painting. For the 3d texturing brush we will be using the PBVH for texture painting. Currently PBVH is organized to work on geometry (vertices, polygons and triangles). For texture painting this should be extended it to use pixels. {F12995467} Screen recording has been done on a Mac Mini with a 6 core 3.3 GHZ Intel processor. # Scope This patch only contains an extending uv seams to fix uv seams. This is not actually we want, but was easy to add to make the brush usable. Pixels are places in the PBVH_Leaf nodes. We want to introduce a special node for pixels, but that will be done in a separate patch to keep the code review small. This reduces the painting performance when using low and medium poly assets. In workbench textures aren't forced to be shown. For now use Material/Rendered view. # Rasterization process The rasterization process will generate the pixel information for a leaf node. In the future those leaf nodes will be split up into multiple leaf nodes to increase the performance when there isn't enough geometry. For this patch this was left out of scope. In order to do so every polygon should be uniquely assigned to a leaf node. For each leaf node for each polygon If polygon not assigned assign polygon to node. Polygons are to complicated to be used directly we have to split the polygons into triangles. For each leaf node for each polygon extract triangles from polygon. The list of triangles can be stored inside the leaf node. The list of polygons aren't needed anymore. Each triangle has: poly_index. vert_indices delta barycentric coordinate between x steps. Each triangle is rasterized in rows. Sequential pixels (in uv space) are stored in a single structure. image position barycentric coordinate of the first pixel number of pixels triangle index inside the leaf node. During the performed experiments we used a fairly simple rasterization process by finding the UV bounds of an triangle and calculate the barycentric coordinates per pixel inside the bounds. Even for complex models and huge images this process is normally finished within 0.5 second. It could be that we want to change this algorithm to reduce hickups when nodes are initialized during a stroke. Reviewed By: brecht Maniphest Tasks: T96710 Differential Revision: https://developer.blender.org/D14504
2022-04-15 16:39:50 +02:00
brush_min_bounds, brush_max_bounds, triangle_min_bounds, triangle_max_bounds);
}
return brush_test;
}
static void do_paint_pixels(void *__restrict userdata,
const int n,
const TaskParallelTLS *__restrict tls)
{
TexturePaintingUserData *data = static_cast<TexturePaintingUserData *>(userdata);
Object *ob = data->ob;
SculptSession *ss = ob->sculpt;
const Brush *brush = data->brush;
3D Texturing: Fix seam bleeding. {F13294314} # Process In the pixel extraction process a larger domain will be extracted then the input mesh. The borders of uv islands are extended with connected geometry of the input mesh. The extended mesh is then fed into the pixel extraction process. A mask is used to limit the extraction so UV islands will not overlap. Input UV islands. {F13206401} Extended UV Island (only one showing). {F13288764} This patch doesn't include fixing uv seams at non-manifold edges (like suzannes eyes) as that would require a different approach (edge extending or pixel copy-ing). The later has already been implemented in D14702, but should be revisited to only use do the non-manifold edge fixing. This patch supports fixing UV seams across UDIM textures. There might be an issue when using a single texture on multiple uv maps. Reviewed By: brecht, joeedh, JulienKaspar Maniphest Tasks: T97352 Differential Revision: https://developer.blender.org/D14970
2022-11-28 08:31:24 +01:00
PBVH *pbvh = ss->pbvh;
PBVH Pixel extractor. This patch contains an initial pixel extractor for PBVH and an initial paint brush implementation. PBVH is an accelleration structure blender uses internally to speed up 3d painting operations. At this moment it is extensively used by sculpt, vertex painting and weight painting. For the 3d texturing brush we will be using the PBVH for texture painting. Currently PBVH is organized to work on geometry (vertices, polygons and triangles). For texture painting this should be extended it to use pixels. {F12995467} Screen recording has been done on a Mac Mini with a 6 core 3.3 GHZ Intel processor. # Scope This patch only contains an extending uv seams to fix uv seams. This is not actually we want, but was easy to add to make the brush usable. Pixels are places in the PBVH_Leaf nodes. We want to introduce a special node for pixels, but that will be done in a separate patch to keep the code review small. This reduces the painting performance when using low and medium poly assets. In workbench textures aren't forced to be shown. For now use Material/Rendered view. # Rasterization process The rasterization process will generate the pixel information for a leaf node. In the future those leaf nodes will be split up into multiple leaf nodes to increase the performance when there isn't enough geometry. For this patch this was left out of scope. In order to do so every polygon should be uniquely assigned to a leaf node. For each leaf node for each polygon If polygon not assigned assign polygon to node. Polygons are to complicated to be used directly we have to split the polygons into triangles. For each leaf node for each polygon extract triangles from polygon. The list of triangles can be stored inside the leaf node. The list of polygons aren't needed anymore. Each triangle has: poly_index. vert_indices delta barycentric coordinate between x steps. Each triangle is rasterized in rows. Sequential pixels (in uv space) are stored in a single structure. image position barycentric coordinate of the first pixel number of pixels triangle index inside the leaf node. During the performed experiments we used a fairly simple rasterization process by finding the UV bounds of an triangle and calculate the barycentric coordinates per pixel inside the bounds. Even for complex models and huge images this process is normally finished within 0.5 second. It could be that we want to change this algorithm to reduce hickups when nodes are initialized during a stroke. Reviewed By: brecht Maniphest Tasks: T96710 Differential Revision: https://developer.blender.org/D14504
2022-04-15 16:39:50 +02:00
PBVHNode *node = data->nodes[n];
3D Texturing: Fix seam bleeding. {F13294314} # Process In the pixel extraction process a larger domain will be extracted then the input mesh. The borders of uv islands are extended with connected geometry of the input mesh. The extended mesh is then fed into the pixel extraction process. A mask is used to limit the extraction so UV islands will not overlap. Input UV islands. {F13206401} Extended UV Island (only one showing). {F13288764} This patch doesn't include fixing uv seams at non-manifold edges (like suzannes eyes) as that would require a different approach (edge extending or pixel copy-ing). The later has already been implemented in D14702, but should be revisited to only use do the non-manifold edge fixing. This patch supports fixing UV seams across UDIM textures. There might be an issue when using a single texture on multiple uv maps. Reviewed By: brecht, joeedh, JulienKaspar Maniphest Tasks: T97352 Differential Revision: https://developer.blender.org/D14970
2022-11-28 08:31:24 +01:00
PBVHData &pbvh_data = BKE_pbvh_pixels_data_get(*pbvh);
PBVH Pixel extractor. This patch contains an initial pixel extractor for PBVH and an initial paint brush implementation. PBVH is an accelleration structure blender uses internally to speed up 3d painting operations. At this moment it is extensively used by sculpt, vertex painting and weight painting. For the 3d texturing brush we will be using the PBVH for texture painting. Currently PBVH is organized to work on geometry (vertices, polygons and triangles). For texture painting this should be extended it to use pixels. {F12995467} Screen recording has been done on a Mac Mini with a 6 core 3.3 GHZ Intel processor. # Scope This patch only contains an extending uv seams to fix uv seams. This is not actually we want, but was easy to add to make the brush usable. Pixels are places in the PBVH_Leaf nodes. We want to introduce a special node for pixels, but that will be done in a separate patch to keep the code review small. This reduces the painting performance when using low and medium poly assets. In workbench textures aren't forced to be shown. For now use Material/Rendered view. # Rasterization process The rasterization process will generate the pixel information for a leaf node. In the future those leaf nodes will be split up into multiple leaf nodes to increase the performance when there isn't enough geometry. For this patch this was left out of scope. In order to do so every polygon should be uniquely assigned to a leaf node. For each leaf node for each polygon If polygon not assigned assign polygon to node. Polygons are to complicated to be used directly we have to split the polygons into triangles. For each leaf node for each polygon extract triangles from polygon. The list of triangles can be stored inside the leaf node. The list of polygons aren't needed anymore. Each triangle has: poly_index. vert_indices delta barycentric coordinate between x steps. Each triangle is rasterized in rows. Sequential pixels (in uv space) are stored in a single structure. image position barycentric coordinate of the first pixel number of pixels triangle index inside the leaf node. During the performed experiments we used a fairly simple rasterization process by finding the UV bounds of an triangle and calculate the barycentric coordinates per pixel inside the bounds. Even for complex models and huge images this process is normally finished within 0.5 second. It could be that we want to change this algorithm to reduce hickups when nodes are initialized during a stroke. Reviewed By: brecht Maniphest Tasks: T96710 Differential Revision: https://developer.blender.org/D14504
2022-04-15 16:39:50 +02:00
NodeData &node_data = BKE_pbvh_pixels_node_data_get(*node);
const int thread_id = BLI_task_parallel_thread_id(tls);
MVert *mvert = SCULPT_mesh_deformed_mverts_get(ss);
3D Texturing: Fix seam bleeding. {F13294314} # Process In the pixel extraction process a larger domain will be extracted then the input mesh. The borders of uv islands are extended with connected geometry of the input mesh. The extended mesh is then fed into the pixel extraction process. A mask is used to limit the extraction so UV islands will not overlap. Input UV islands. {F13206401} Extended UV Island (only one showing). {F13288764} This patch doesn't include fixing uv seams at non-manifold edges (like suzannes eyes) as that would require a different approach (edge extending or pixel copy-ing). The later has already been implemented in D14702, but should be revisited to only use do the non-manifold edge fixing. This patch supports fixing UV seams across UDIM textures. There might be an issue when using a single texture on multiple uv maps. Reviewed By: brecht, joeedh, JulienKaspar Maniphest Tasks: T97352 Differential Revision: https://developer.blender.org/D14970
2022-11-28 08:31:24 +01:00
std::vector<bool> brush_test = init_uv_primitives_brush_test(
ss, pbvh_data.geom_primitives, node_data.uv_primitives, mvert);
PBVH Pixel extractor. This patch contains an initial pixel extractor for PBVH and an initial paint brush implementation. PBVH is an accelleration structure blender uses internally to speed up 3d painting operations. At this moment it is extensively used by sculpt, vertex painting and weight painting. For the 3d texturing brush we will be using the PBVH for texture painting. Currently PBVH is organized to work on geometry (vertices, polygons and triangles). For texture painting this should be extended it to use pixels. {F12995467} Screen recording has been done on a Mac Mini with a 6 core 3.3 GHZ Intel processor. # Scope This patch only contains an extending uv seams to fix uv seams. This is not actually we want, but was easy to add to make the brush usable. Pixels are places in the PBVH_Leaf nodes. We want to introduce a special node for pixels, but that will be done in a separate patch to keep the code review small. This reduces the painting performance when using low and medium poly assets. In workbench textures aren't forced to be shown. For now use Material/Rendered view. # Rasterization process The rasterization process will generate the pixel information for a leaf node. In the future those leaf nodes will be split up into multiple leaf nodes to increase the performance when there isn't enough geometry. For this patch this was left out of scope. In order to do so every polygon should be uniquely assigned to a leaf node. For each leaf node for each polygon If polygon not assigned assign polygon to node. Polygons are to complicated to be used directly we have to split the polygons into triangles. For each leaf node for each polygon extract triangles from polygon. The list of triangles can be stored inside the leaf node. The list of polygons aren't needed anymore. Each triangle has: poly_index. vert_indices delta barycentric coordinate between x steps. Each triangle is rasterized in rows. Sequential pixels (in uv space) are stored in a single structure. image position barycentric coordinate of the first pixel number of pixels triangle index inside the leaf node. During the performed experiments we used a fairly simple rasterization process by finding the UV bounds of an triangle and calculate the barycentric coordinates per pixel inside the bounds. Even for complex models and huge images this process is normally finished within 0.5 second. It could be that we want to change this algorithm to reduce hickups when nodes are initialized during a stroke. Reviewed By: brecht Maniphest Tasks: T96710 Differential Revision: https://developer.blender.org/D14504
2022-04-15 16:39:50 +02:00
PaintingKernel<ImageBufferFloat4> kernel_float4(ss, brush, thread_id, mvert);
PaintingKernel<ImageBufferByte4> kernel_byte4(ss, brush, thread_id, mvert);
Sculpt: Normal-based automasking modes Two new normal-based automasking modes. The first mode, "brush", compares vertex normals with the initial normal at the beginning of the brush stroke. The second, "view", compares vertex normals with the view normal. If "occlusion" is on then rays will be shot from each vertex to test if it is occluded by other geometry (note: this can be very slow).\ Only geometry inside the sculpt mesh is considered. Each mode has an associated angular limit and a falloff. Reviewed by: Julien Kaspar and Jeroen Bakker Differential Revision: https://developer.blender.org/D15297 Ref D15297
2022-09-29 08:21:56 +02:00
AutomaskingNodeData automask_data;
SCULPT_automasking_node_begin(ob, ss, ss->cache->automasking, &automask_data, data->nodes[n]);
PBVH Pixel extractor. This patch contains an initial pixel extractor for PBVH and an initial paint brush implementation. PBVH is an accelleration structure blender uses internally to speed up 3d painting operations. At this moment it is extensively used by sculpt, vertex painting and weight painting. For the 3d texturing brush we will be using the PBVH for texture painting. Currently PBVH is organized to work on geometry (vertices, polygons and triangles). For texture painting this should be extended it to use pixels. {F12995467} Screen recording has been done on a Mac Mini with a 6 core 3.3 GHZ Intel processor. # Scope This patch only contains an extending uv seams to fix uv seams. This is not actually we want, but was easy to add to make the brush usable. Pixels are places in the PBVH_Leaf nodes. We want to introduce a special node for pixels, but that will be done in a separate patch to keep the code review small. This reduces the painting performance when using low and medium poly assets. In workbench textures aren't forced to be shown. For now use Material/Rendered view. # Rasterization process The rasterization process will generate the pixel information for a leaf node. In the future those leaf nodes will be split up into multiple leaf nodes to increase the performance when there isn't enough geometry. For this patch this was left out of scope. In order to do so every polygon should be uniquely assigned to a leaf node. For each leaf node for each polygon If polygon not assigned assign polygon to node. Polygons are to complicated to be used directly we have to split the polygons into triangles. For each leaf node for each polygon extract triangles from polygon. The list of triangles can be stored inside the leaf node. The list of polygons aren't needed anymore. Each triangle has: poly_index. vert_indices delta barycentric coordinate between x steps. Each triangle is rasterized in rows. Sequential pixels (in uv space) are stored in a single structure. image position barycentric coordinate of the first pixel number of pixels triangle index inside the leaf node. During the performed experiments we used a fairly simple rasterization process by finding the UV bounds of an triangle and calculate the barycentric coordinates per pixel inside the bounds. Even for complex models and huge images this process is normally finished within 0.5 second. It could be that we want to change this algorithm to reduce hickups when nodes are initialized during a stroke. Reviewed By: brecht Maniphest Tasks: T96710 Differential Revision: https://developer.blender.org/D14504
2022-04-15 16:39:50 +02:00
ImageUser image_user = *data->image_data.image_user;
bool pixels_updated = false;
for (UDIMTilePixels &tile_data : node_data.tiles) {
LISTBASE_FOREACH (ImageTile *, tile, &data->image_data.image->tiles) {
ImageTileWrapper image_tile(tile);
if (image_tile.get_tile_number() == tile_data.tile_number) {
image_user.tile = image_tile.get_tile_number();
ImBuf *image_buffer = BKE_image_acquire_ibuf(data->image_data.image, &image_user, nullptr);
if (image_buffer == nullptr) {
continue;
}
if (image_buffer->rect_float != nullptr) {
kernel_float4.init_brush_color(image_buffer);
}
else {
Fix: Uninitialized paint brush when using byte textures. This is a fix for the 3d texturing brush.
2022-04-19 08:35:54 +02:00
kernel_byte4.init_brush_color(image_buffer);
PBVH Pixel extractor. This patch contains an initial pixel extractor for PBVH and an initial paint brush implementation. PBVH is an accelleration structure blender uses internally to speed up 3d painting operations. At this moment it is extensively used by sculpt, vertex painting and weight painting. For the 3d texturing brush we will be using the PBVH for texture painting. Currently PBVH is organized to work on geometry (vertices, polygons and triangles). For texture painting this should be extended it to use pixels. {F12995467} Screen recording has been done on a Mac Mini with a 6 core 3.3 GHZ Intel processor. # Scope This patch only contains an extending uv seams to fix uv seams. This is not actually we want, but was easy to add to make the brush usable. Pixels are places in the PBVH_Leaf nodes. We want to introduce a special node for pixels, but that will be done in a separate patch to keep the code review small. This reduces the painting performance when using low and medium poly assets. In workbench textures aren't forced to be shown. For now use Material/Rendered view. # Rasterization process The rasterization process will generate the pixel information for a leaf node. In the future those leaf nodes will be split up into multiple leaf nodes to increase the performance when there isn't enough geometry. For this patch this was left out of scope. In order to do so every polygon should be uniquely assigned to a leaf node. For each leaf node for each polygon If polygon not assigned assign polygon to node. Polygons are to complicated to be used directly we have to split the polygons into triangles. For each leaf node for each polygon extract triangles from polygon. The list of triangles can be stored inside the leaf node. The list of polygons aren't needed anymore. Each triangle has: poly_index. vert_indices delta barycentric coordinate between x steps. Each triangle is rasterized in rows. Sequential pixels (in uv space) are stored in a single structure. image position barycentric coordinate of the first pixel number of pixels triangle index inside the leaf node. During the performed experiments we used a fairly simple rasterization process by finding the UV bounds of an triangle and calculate the barycentric coordinates per pixel inside the bounds. Even for complex models and huge images this process is normally finished within 0.5 second. It could be that we want to change this algorithm to reduce hickups when nodes are initialized during a stroke. Reviewed By: brecht Maniphest Tasks: T96710 Differential Revision: https://developer.blender.org/D14504
2022-04-15 16:39:50 +02:00
}
for (const PackedPixelRow &pixel_row : tile_data.pixel_rows) {
3D Texturing: Fix seam bleeding. {F13294314} # Process In the pixel extraction process a larger domain will be extracted then the input mesh. The borders of uv islands are extended with connected geometry of the input mesh. The extended mesh is then fed into the pixel extraction process. A mask is used to limit the extraction so UV islands will not overlap. Input UV islands. {F13206401} Extended UV Island (only one showing). {F13288764} This patch doesn't include fixing uv seams at non-manifold edges (like suzannes eyes) as that would require a different approach (edge extending or pixel copy-ing). The later has already been implemented in D14702, but should be revisited to only use do the non-manifold edge fixing. This patch supports fixing UV seams across UDIM textures. There might be an issue when using a single texture on multiple uv maps. Reviewed By: brecht, joeedh, JulienKaspar Maniphest Tasks: T97352 Differential Revision: https://developer.blender.org/D14970
2022-11-28 08:31:24 +01:00
if (!brush_test[pixel_row.uv_primitive_index]) {
PBVH Pixel extractor. This patch contains an initial pixel extractor for PBVH and an initial paint brush implementation. PBVH is an accelleration structure blender uses internally to speed up 3d painting operations. At this moment it is extensively used by sculpt, vertex painting and weight painting. For the 3d texturing brush we will be using the PBVH for texture painting. Currently PBVH is organized to work on geometry (vertices, polygons and triangles). For texture painting this should be extended it to use pixels. {F12995467} Screen recording has been done on a Mac Mini with a 6 core 3.3 GHZ Intel processor. # Scope This patch only contains an extending uv seams to fix uv seams. This is not actually we want, but was easy to add to make the brush usable. Pixels are places in the PBVH_Leaf nodes. We want to introduce a special node for pixels, but that will be done in a separate patch to keep the code review small. This reduces the painting performance when using low and medium poly assets. In workbench textures aren't forced to be shown. For now use Material/Rendered view. # Rasterization process The rasterization process will generate the pixel information for a leaf node. In the future those leaf nodes will be split up into multiple leaf nodes to increase the performance when there isn't enough geometry. For this patch this was left out of scope. In order to do so every polygon should be uniquely assigned to a leaf node. For each leaf node for each polygon If polygon not assigned assign polygon to node. Polygons are to complicated to be used directly we have to split the polygons into triangles. For each leaf node for each polygon extract triangles from polygon. The list of triangles can be stored inside the leaf node. The list of polygons aren't needed anymore. Each triangle has: poly_index. vert_indices delta barycentric coordinate between x steps. Each triangle is rasterized in rows. Sequential pixels (in uv space) are stored in a single structure. image position barycentric coordinate of the first pixel number of pixels triangle index inside the leaf node. During the performed experiments we used a fairly simple rasterization process by finding the UV bounds of an triangle and calculate the barycentric coordinates per pixel inside the bounds. Even for complex models and huge images this process is normally finished within 0.5 second. It could be that we want to change this algorithm to reduce hickups when nodes are initialized during a stroke. Reviewed By: brecht Maniphest Tasks: T96710 Differential Revision: https://developer.blender.org/D14504
2022-04-15 16:39:50 +02:00
continue;
}
bool pixels_painted = false;
if (image_buffer->rect_float != nullptr) {
Sculpt: Normal-based automasking modes Two new normal-based automasking modes. The first mode, "brush", compares vertex normals with the initial normal at the beginning of the brush stroke. The second, "view", compares vertex normals with the view normal. If "occlusion" is on then rays will be shot from each vertex to test if it is occluded by other geometry (note: this can be very slow).\ Only geometry inside the sculpt mesh is considered. Each mode has an associated angular limit and a falloff. Reviewed by: Julien Kaspar and Jeroen Bakker Differential Revision: https://developer.blender.org/D15297 Ref D15297
2022-09-29 08:21:56 +02:00
pixels_painted = kernel_float4.paint(
3D Texturing: Fix seam bleeding. {F13294314} # Process In the pixel extraction process a larger domain will be extracted then the input mesh. The borders of uv islands are extended with connected geometry of the input mesh. The extended mesh is then fed into the pixel extraction process. A mask is used to limit the extraction so UV islands will not overlap. Input UV islands. {F13206401} Extended UV Island (only one showing). {F13288764} This patch doesn't include fixing uv seams at non-manifold edges (like suzannes eyes) as that would require a different approach (edge extending or pixel copy-ing). The later has already been implemented in D14702, but should be revisited to only use do the non-manifold edge fixing. This patch supports fixing UV seams across UDIM textures. There might be an issue when using a single texture on multiple uv maps. Reviewed By: brecht, joeedh, JulienKaspar Maniphest Tasks: T97352 Differential Revision: https://developer.blender.org/D14970
2022-11-28 08:31:24 +01:00
pbvh_data.geom_primitives, node_data.uv_primitives, pixel_row, image_buffer, &automask_data);
PBVH Pixel extractor. This patch contains an initial pixel extractor for PBVH and an initial paint brush implementation. PBVH is an accelleration structure blender uses internally to speed up 3d painting operations. At this moment it is extensively used by sculpt, vertex painting and weight painting. For the 3d texturing brush we will be using the PBVH for texture painting. Currently PBVH is organized to work on geometry (vertices, polygons and triangles). For texture painting this should be extended it to use pixels. {F12995467} Screen recording has been done on a Mac Mini with a 6 core 3.3 GHZ Intel processor. # Scope This patch only contains an extending uv seams to fix uv seams. This is not actually we want, but was easy to add to make the brush usable. Pixels are places in the PBVH_Leaf nodes. We want to introduce a special node for pixels, but that will be done in a separate patch to keep the code review small. This reduces the painting performance when using low and medium poly assets. In workbench textures aren't forced to be shown. For now use Material/Rendered view. # Rasterization process The rasterization process will generate the pixel information for a leaf node. In the future those leaf nodes will be split up into multiple leaf nodes to increase the performance when there isn't enough geometry. For this patch this was left out of scope. In order to do so every polygon should be uniquely assigned to a leaf node. For each leaf node for each polygon If polygon not assigned assign polygon to node. Polygons are to complicated to be used directly we have to split the polygons into triangles. For each leaf node for each polygon extract triangles from polygon. The list of triangles can be stored inside the leaf node. The list of polygons aren't needed anymore. Each triangle has: poly_index. vert_indices delta barycentric coordinate between x steps. Each triangle is rasterized in rows. Sequential pixels (in uv space) are stored in a single structure. image position barycentric coordinate of the first pixel number of pixels triangle index inside the leaf node. During the performed experiments we used a fairly simple rasterization process by finding the UV bounds of an triangle and calculate the barycentric coordinates per pixel inside the bounds. Even for complex models and huge images this process is normally finished within 0.5 second. It could be that we want to change this algorithm to reduce hickups when nodes are initialized during a stroke. Reviewed By: brecht Maniphest Tasks: T96710 Differential Revision: https://developer.blender.org/D14504
2022-04-15 16:39:50 +02:00
}
else {
Sculpt: Normal-based automasking modes Two new normal-based automasking modes. The first mode, "brush", compares vertex normals with the initial normal at the beginning of the brush stroke. The second, "view", compares vertex normals with the view normal. If "occlusion" is on then rays will be shot from each vertex to test if it is occluded by other geometry (note: this can be very slow).\ Only geometry inside the sculpt mesh is considered. Each mode has an associated angular limit and a falloff. Reviewed by: Julien Kaspar and Jeroen Bakker Differential Revision: https://developer.blender.org/D15297 Ref D15297
2022-09-29 08:21:56 +02:00
pixels_painted = kernel_byte4.paint(
3D Texturing: Fix seam bleeding. {F13294314} # Process In the pixel extraction process a larger domain will be extracted then the input mesh. The borders of uv islands are extended with connected geometry of the input mesh. The extended mesh is then fed into the pixel extraction process. A mask is used to limit the extraction so UV islands will not overlap. Input UV islands. {F13206401} Extended UV Island (only one showing). {F13288764} This patch doesn't include fixing uv seams at non-manifold edges (like suzannes eyes) as that would require a different approach (edge extending or pixel copy-ing). The later has already been implemented in D14702, but should be revisited to only use do the non-manifold edge fixing. This patch supports fixing UV seams across UDIM textures. There might be an issue when using a single texture on multiple uv maps. Reviewed By: brecht, joeedh, JulienKaspar Maniphest Tasks: T97352 Differential Revision: https://developer.blender.org/D14970
2022-11-28 08:31:24 +01:00
pbvh_data.geom_primitives, node_data.uv_primitives, pixel_row, image_buffer, &automask_data);
PBVH Pixel extractor. This patch contains an initial pixel extractor for PBVH and an initial paint brush implementation. PBVH is an accelleration structure blender uses internally to speed up 3d painting operations. At this moment it is extensively used by sculpt, vertex painting and weight painting. For the 3d texturing brush we will be using the PBVH for texture painting. Currently PBVH is organized to work on geometry (vertices, polygons and triangles). For texture painting this should be extended it to use pixels. {F12995467} Screen recording has been done on a Mac Mini with a 6 core 3.3 GHZ Intel processor. # Scope This patch only contains an extending uv seams to fix uv seams. This is not actually we want, but was easy to add to make the brush usable. Pixels are places in the PBVH_Leaf nodes. We want to introduce a special node for pixels, but that will be done in a separate patch to keep the code review small. This reduces the painting performance when using low and medium poly assets. In workbench textures aren't forced to be shown. For now use Material/Rendered view. # Rasterization process The rasterization process will generate the pixel information for a leaf node. In the future those leaf nodes will be split up into multiple leaf nodes to increase the performance when there isn't enough geometry. For this patch this was left out of scope. In order to do so every polygon should be uniquely assigned to a leaf node. For each leaf node for each polygon If polygon not assigned assign polygon to node. Polygons are to complicated to be used directly we have to split the polygons into triangles. For each leaf node for each polygon extract triangles from polygon. The list of triangles can be stored inside the leaf node. The list of polygons aren't needed anymore. Each triangle has: poly_index. vert_indices delta barycentric coordinate between x steps. Each triangle is rasterized in rows. Sequential pixels (in uv space) are stored in a single structure. image position barycentric coordinate of the first pixel number of pixels triangle index inside the leaf node. During the performed experiments we used a fairly simple rasterization process by finding the UV bounds of an triangle and calculate the barycentric coordinates per pixel inside the bounds. Even for complex models and huge images this process is normally finished within 0.5 second. It could be that we want to change this algorithm to reduce hickups when nodes are initialized during a stroke. Reviewed By: brecht Maniphest Tasks: T96710 Differential Revision: https://developer.blender.org/D14504
2022-04-15 16:39:50 +02:00
}
if (pixels_painted) {
tile_data.mark_dirty(pixel_row);
}
}
BKE_image_release_ibuf(data->image_data.image, image_buffer, nullptr);
pixels_updated |= tile_data.flags.dirty;
break;
}
}
}
node_data.flags.dirty |= pixels_updated;
}
3D Texturing: Undo. Blender can only support a single undo system per undo step. As sculpting/vertex colors are mutual exclusive operations out approach is just to switch the undo system when painting on an image. PBVHNodes contain a list of areas that needs to be pushed to the undo system. Currently the undo code is in sculpt_paint_image. We should eventually support undo for color filtering and other nodes. we might need to place it to its own compile unit so more brushes can invoke the same code. {F13048942} Reviewed By: brecht Maniphest Tasks: T97479 Differential Revision: https://developer.blender.org/D14821
2022-05-16 15:42:43 +02:00
static void undo_region_tiles(
ImBuf *ibuf, int x, int y, int w, int h, int *tx, int *ty, int *tw, int *th)
{
int srcx = 0, srcy = 0;
IMB_rectclip(ibuf, nullptr, &x, &y, &srcx, &srcy, &w, &h);
*tw = ((x + w - 1) >> ED_IMAGE_UNDO_TILE_BITS);
*th = ((y + h - 1) >> ED_IMAGE_UNDO_TILE_BITS);
*tx = (x >> ED_IMAGE_UNDO_TILE_BITS);
*ty = (y >> ED_IMAGE_UNDO_TILE_BITS);
}
static void push_undo(const NodeData &node_data,
Image &image,
ImageUser &image_user,
const image::ImageTileWrapper &image_tile,
ImBuf &image_buffer,
ImBuf **tmpibuf)
{
for (const UDIMTileUndo &tile_undo : node_data.undo_regions) {
if (tile_undo.tile_number != image_tile.get_tile_number()) {
continue;
}
int tilex, tiley, tilew, tileh;
Undo: Improve image undo performance When texture painting a lot of time is spent in ED_image_paint_tile_find. This fixes stores the PaintTiles in a blender::Map making ED_image_paint_tile_find an O(1) rather than O(n) operation. When using threading the locking should happen during read as well, still this gives a boost in performance as the read is now much faster. Reviewed By: jbakker Maniphest Tasks: T99546 Differential Revision: https://developer.blender.org/D15415
2022-07-25 07:56:17 +02:00
PaintTileMap *undo_tiles = ED_image_paint_tile_map_get();
3D Texturing: Undo. Blender can only support a single undo system per undo step. As sculpting/vertex colors are mutual exclusive operations out approach is just to switch the undo system when painting on an image. PBVHNodes contain a list of areas that needs to be pushed to the undo system. Currently the undo code is in sculpt_paint_image. We should eventually support undo for color filtering and other nodes. we might need to place it to its own compile unit so more brushes can invoke the same code. {F13048942} Reviewed By: brecht Maniphest Tasks: T97479 Differential Revision: https://developer.blender.org/D14821
2022-05-16 15:42:43 +02:00
undo_region_tiles(&image_buffer,
tile_undo.region.xmin,
tile_undo.region.ymin,
BLI_rcti_size_x(&tile_undo.region),
BLI_rcti_size_y(&tile_undo.region),
&tilex,
&tiley,
&tilew,
&tileh);
for (int ty = tiley; ty <= tileh; ty++) {
for (int tx = tilex; tx <= tilew; tx++) {
ED_image_paint_tile_push(undo_tiles,
&image,
&image_buffer,
tmpibuf,
&image_user,
tx,
ty,
nullptr,
nullptr,
true,
true);
}
}
}
}
static void do_push_undo_tile(void *__restrict userdata,
const int n,
Cleanup: replace UNUSED macro with commented args in C++ code This is the conventional way of dealing with unused arguments in C++, since it works on all compilers. Regex find and replace: `UNUSED\((\w+)\)` -> `/*$1*/`
2022-10-04 00:37:25 +02:00
const TaskParallelTLS *__restrict /*tls*/)
3D Texturing: Undo. Blender can only support a single undo system per undo step. As sculpting/vertex colors are mutual exclusive operations out approach is just to switch the undo system when painting on an image. PBVHNodes contain a list of areas that needs to be pushed to the undo system. Currently the undo code is in sculpt_paint_image. We should eventually support undo for color filtering and other nodes. we might need to place it to its own compile unit so more brushes can invoke the same code. {F13048942} Reviewed By: brecht Maniphest Tasks: T97479 Differential Revision: https://developer.blender.org/D14821
2022-05-16 15:42:43 +02:00
{
TexturePaintingUserData *data = static_cast<TexturePaintingUserData *>(userdata);
PBVHNode *node = data->nodes[n];
NodeData &node_data = BKE_pbvh_pixels_node_data_get(*node);
Image *image = data->image_data.image;
ImageUser *image_user = data->image_data.image_user;
ImBuf *tmpibuf = nullptr;
ImageUser local_image_user = *image_user;
LISTBASE_FOREACH (ImageTile *, tile, &image->tiles) {
image::ImageTileWrapper image_tile(tile);
local_image_user.tile = image_tile.get_tile_number();
ImBuf *image_buffer = BKE_image_acquire_ibuf(image, &local_image_user, nullptr);
if (image_buffer == nullptr) {
continue;
}
push_undo(node_data, *image, *image_user, image_tile, *image_buffer, &tmpibuf);
BKE_image_release_ibuf(image, image_buffer, nullptr);
}
if (tmpibuf) {
IMB_freeImBuf(tmpibuf);
}
}
PBVH Pixel extractor. This patch contains an initial pixel extractor for PBVH and an initial paint brush implementation. PBVH is an accelleration structure blender uses internally to speed up 3d painting operations. At this moment it is extensively used by sculpt, vertex painting and weight painting. For the 3d texturing brush we will be using the PBVH for texture painting. Currently PBVH is organized to work on geometry (vertices, polygons and triangles). For texture painting this should be extended it to use pixels. {F12995467} Screen recording has been done on a Mac Mini with a 6 core 3.3 GHZ Intel processor. # Scope This patch only contains an extending uv seams to fix uv seams. This is not actually we want, but was easy to add to make the brush usable. Pixels are places in the PBVH_Leaf nodes. We want to introduce a special node for pixels, but that will be done in a separate patch to keep the code review small. This reduces the painting performance when using low and medium poly assets. In workbench textures aren't forced to be shown. For now use Material/Rendered view. # Rasterization process The rasterization process will generate the pixel information for a leaf node. In the future those leaf nodes will be split up into multiple leaf nodes to increase the performance when there isn't enough geometry. For this patch this was left out of scope. In order to do so every polygon should be uniquely assigned to a leaf node. For each leaf node for each polygon If polygon not assigned assign polygon to node. Polygons are to complicated to be used directly we have to split the polygons into triangles. For each leaf node for each polygon extract triangles from polygon. The list of triangles can be stored inside the leaf node. The list of polygons aren't needed anymore. Each triangle has: poly_index. vert_indices delta barycentric coordinate between x steps. Each triangle is rasterized in rows. Sequential pixels (in uv space) are stored in a single structure. image position barycentric coordinate of the first pixel number of pixels triangle index inside the leaf node. During the performed experiments we used a fairly simple rasterization process by finding the UV bounds of an triangle and calculate the barycentric coordinates per pixel inside the bounds. Even for complex models and huge images this process is normally finished within 0.5 second. It could be that we want to change this algorithm to reduce hickups when nodes are initialized during a stroke. Reviewed By: brecht Maniphest Tasks: T96710 Differential Revision: https://developer.blender.org/D14504
2022-04-15 16:39:50 +02:00
static void do_mark_dirty_regions(void *__restrict userdata,
const int n,
Cleanup: replace UNUSED macro with commented args in C++ code This is the conventional way of dealing with unused arguments in C++, since it works on all compilers. Regex find and replace: `UNUSED\((\w+)\)` -> `/*$1*/`
2022-10-04 00:37:25 +02:00
const TaskParallelTLS *__restrict /*tls*/)
PBVH Pixel extractor. This patch contains an initial pixel extractor for PBVH and an initial paint brush implementation. PBVH is an accelleration structure blender uses internally to speed up 3d painting operations. At this moment it is extensively used by sculpt, vertex painting and weight painting. For the 3d texturing brush we will be using the PBVH for texture painting. Currently PBVH is organized to work on geometry (vertices, polygons and triangles). For texture painting this should be extended it to use pixels. {F12995467} Screen recording has been done on a Mac Mini with a 6 core 3.3 GHZ Intel processor. # Scope This patch only contains an extending uv seams to fix uv seams. This is not actually we want, but was easy to add to make the brush usable. Pixels are places in the PBVH_Leaf nodes. We want to introduce a special node for pixels, but that will be done in a separate patch to keep the code review small. This reduces the painting performance when using low and medium poly assets. In workbench textures aren't forced to be shown. For now use Material/Rendered view. # Rasterization process The rasterization process will generate the pixel information for a leaf node. In the future those leaf nodes will be split up into multiple leaf nodes to increase the performance when there isn't enough geometry. For this patch this was left out of scope. In order to do so every polygon should be uniquely assigned to a leaf node. For each leaf node for each polygon If polygon not assigned assign polygon to node. Polygons are to complicated to be used directly we have to split the polygons into triangles. For each leaf node for each polygon extract triangles from polygon. The list of triangles can be stored inside the leaf node. The list of polygons aren't needed anymore. Each triangle has: poly_index. vert_indices delta barycentric coordinate between x steps. Each triangle is rasterized in rows. Sequential pixels (in uv space) are stored in a single structure. image position barycentric coordinate of the first pixel number of pixels triangle index inside the leaf node. During the performed experiments we used a fairly simple rasterization process by finding the UV bounds of an triangle and calculate the barycentric coordinates per pixel inside the bounds. Even for complex models and huge images this process is normally finished within 0.5 second. It could be that we want to change this algorithm to reduce hickups when nodes are initialized during a stroke. Reviewed By: brecht Maniphest Tasks: T96710 Differential Revision: https://developer.blender.org/D14504
2022-04-15 16:39:50 +02:00
{
TexturePaintingUserData *data = static_cast<TexturePaintingUserData *>(userdata);
PBVHNode *node = data->nodes[n];
BKE_pbvh_pixels_mark_image_dirty(*node, *data->image_data.image, *data->image_data.image_user);
}
} // namespace blender::ed::sculpt_paint::paint::image
extern "C" {
using namespace blender::ed::sculpt_paint::paint::image;
bool SCULPT_paint_image_canvas_get(PaintModeSettings *paint_mode_settings,
Object *ob,
Image **r_image,
ImageUser **r_image_user)
{
Cleanup: always assign return args for SCULPT_paint_image_canvas_get Asserting the variables weren't NULL raised a warning with GCC 12.1, instead of suppressing the warning, always assign NULL which is often expected behavior and makes the function work as documented.
2022-05-19 02:14:30 +02:00
*r_image = nullptr;
*r_image_user = nullptr;
PBVH Pixel extractor. This patch contains an initial pixel extractor for PBVH and an initial paint brush implementation. PBVH is an accelleration structure blender uses internally to speed up 3d painting operations. At this moment it is extensively used by sculpt, vertex painting and weight painting. For the 3d texturing brush we will be using the PBVH for texture painting. Currently PBVH is organized to work on geometry (vertices, polygons and triangles). For texture painting this should be extended it to use pixels. {F12995467} Screen recording has been done on a Mac Mini with a 6 core 3.3 GHZ Intel processor. # Scope This patch only contains an extending uv seams to fix uv seams. This is not actually we want, but was easy to add to make the brush usable. Pixels are places in the PBVH_Leaf nodes. We want to introduce a special node for pixels, but that will be done in a separate patch to keep the code review small. This reduces the painting performance when using low and medium poly assets. In workbench textures aren't forced to be shown. For now use Material/Rendered view. # Rasterization process The rasterization process will generate the pixel information for a leaf node. In the future those leaf nodes will be split up into multiple leaf nodes to increase the performance when there isn't enough geometry. For this patch this was left out of scope. In order to do so every polygon should be uniquely assigned to a leaf node. For each leaf node for each polygon If polygon not assigned assign polygon to node. Polygons are to complicated to be used directly we have to split the polygons into triangles. For each leaf node for each polygon extract triangles from polygon. The list of triangles can be stored inside the leaf node. The list of polygons aren't needed anymore. Each triangle has: poly_index. vert_indices delta barycentric coordinate between x steps. Each triangle is rasterized in rows. Sequential pixels (in uv space) are stored in a single structure. image position barycentric coordinate of the first pixel number of pixels triangle index inside the leaf node. During the performed experiments we used a fairly simple rasterization process by finding the UV bounds of an triangle and calculate the barycentric coordinates per pixel inside the bounds. Even for complex models and huge images this process is normally finished within 0.5 second. It could be that we want to change this algorithm to reduce hickups when nodes are initialized during a stroke. Reviewed By: brecht Maniphest Tasks: T96710 Differential Revision: https://developer.blender.org/D14504
2022-04-15 16:39:50 +02:00
ImageData image_data;
if (!ImageData::init_active_image(ob, &image_data, paint_mode_settings)) {
return false;
}
*r_image = image_data.image;
*r_image_user = image_data.image_user;
return true;
}
bool SCULPT_use_image_paint_brush(PaintModeSettings *settings, Object *ob)
{
if (!U.experimental.use_sculpt_texture_paint) {
return false;
}
if (ob->type != OB_MESH) {
return false;
}
Image *image;
ImageUser *image_user;
return BKE_paint_canvas_image_get(settings, ob, &image, &image_user);
}
void SCULPT_do_paint_brush_image(
PaintModeSettings *paint_mode_settings, Sculpt *sd, Object *ob, PBVHNode **nodes, int totnode)
{
Brush *brush = BKE_paint_brush(&sd->paint);
TexturePaintingUserData data = {nullptr};
data.ob = ob;
data.brush = brush;
data.nodes = nodes;
if (!ImageData::init_active_image(ob, &data.image_data, paint_mode_settings)) {
return;
}
TaskParallelSettings settings;
BKE_pbvh_parallel_range_settings(&settings, true, totnode);
3D Texturing: Undo. Blender can only support a single undo system per undo step. As sculpting/vertex colors are mutual exclusive operations out approach is just to switch the undo system when painting on an image. PBVHNodes contain a list of areas that needs to be pushed to the undo system. Currently the undo code is in sculpt_paint_image. We should eventually support undo for color filtering and other nodes. we might need to place it to its own compile unit so more brushes can invoke the same code. {F13048942} Reviewed By: brecht Maniphest Tasks: T97479 Differential Revision: https://developer.blender.org/D14821
2022-05-16 15:42:43 +02:00
BLI_task_parallel_range(0, totnode, &data, do_push_undo_tile, &settings);
PBVH Pixel extractor. This patch contains an initial pixel extractor for PBVH and an initial paint brush implementation. PBVH is an accelleration structure blender uses internally to speed up 3d painting operations. At this moment it is extensively used by sculpt, vertex painting and weight painting. For the 3d texturing brush we will be using the PBVH for texture painting. Currently PBVH is organized to work on geometry (vertices, polygons and triangles). For texture painting this should be extended it to use pixels. {F12995467} Screen recording has been done on a Mac Mini with a 6 core 3.3 GHZ Intel processor. # Scope This patch only contains an extending uv seams to fix uv seams. This is not actually we want, but was easy to add to make the brush usable. Pixels are places in the PBVH_Leaf nodes. We want to introduce a special node for pixels, but that will be done in a separate patch to keep the code review small. This reduces the painting performance when using low and medium poly assets. In workbench textures aren't forced to be shown. For now use Material/Rendered view. # Rasterization process The rasterization process will generate the pixel information for a leaf node. In the future those leaf nodes will be split up into multiple leaf nodes to increase the performance when there isn't enough geometry. For this patch this was left out of scope. In order to do so every polygon should be uniquely assigned to a leaf node. For each leaf node for each polygon If polygon not assigned assign polygon to node. Polygons are to complicated to be used directly we have to split the polygons into triangles. For each leaf node for each polygon extract triangles from polygon. The list of triangles can be stored inside the leaf node. The list of polygons aren't needed anymore. Each triangle has: poly_index. vert_indices delta barycentric coordinate between x steps. Each triangle is rasterized in rows. Sequential pixels (in uv space) are stored in a single structure. image position barycentric coordinate of the first pixel number of pixels triangle index inside the leaf node. During the performed experiments we used a fairly simple rasterization process by finding the UV bounds of an triangle and calculate the barycentric coordinates per pixel inside the bounds. Even for complex models and huge images this process is normally finished within 0.5 second. It could be that we want to change this algorithm to reduce hickups when nodes are initialized during a stroke. Reviewed By: brecht Maniphest Tasks: T96710 Differential Revision: https://developer.blender.org/D14504
2022-04-15 16:39:50 +02:00
BLI_task_parallel_range(0, totnode, &data, do_paint_pixels, &settings);
TaskParallelSettings settings_flush;
BKE_pbvh_parallel_range_settings(&settings_flush, false, totnode);
BLI_task_parallel_range(0, totnode, &data, do_mark_dirty_regions, &settings_flush);
}
}