Merge branch 'master' into temp-gpencil-maskingtemp-gpencil-masking

 Conflicts:
	source/blender/blenloader/intern/versioning_300.c

1 files changed, 54 insertions, 31 deletions

diff --git a/source/blender/compositor/intern/COM_MemoryBuffer.cc b/source/blender/compositor/intern/COM_MemoryBuffer.cc
index 68e39b19eaf..8c30d3215d7 100644
--- a/source/blender/compositor/intern/COM_MemoryBuffer.cc
+++ b/source/blender/compositor/intern/COM_MemoryBuffer.cc
@@ -25,29 +25,49 @@ namespace blender::compositor {
 MemoryBuffer::MemoryBuffer(MemoryProxy *memoryProxy, const rcti &rect, MemoryBufferState state)
 {
   m_rect = rect;
+  this->m_is_a_single_elem = false;
   this->m_memoryProxy = memoryProxy;
   this->m_num_channels = COM_data_type_num_channels(memoryProxy->getDataType());
   this->m_buffer = (float *)MEM_mallocN_aligned(
       sizeof(float) * buffer_len() * this->m_num_channels, 16, "COM_MemoryBuffer");
   this->m_state = state;
   this->m_datatype = memoryProxy->getDataType();
+
+  set_strides();
 }
 
-MemoryBuffer::MemoryBuffer(DataType dataType, const rcti &rect)
+MemoryBuffer::MemoryBuffer(DataType dataType, const rcti &rect, bool is_a_single_elem)
 {
   m_rect = rect;
+  this->m_is_a_single_elem = is_a_single_elem;
   this->m_memoryProxy = nullptr;
   this->m_num_channels = COM_data_type_num_channels(dataType);
   this->m_buffer = (float *)MEM_mallocN_aligned(
       sizeof(float) * buffer_len() * this->m_num_channels, 16, "COM_MemoryBuffer");
   this->m_state = MemoryBufferState::Temporary;
   this->m_datatype = dataType;
+
+  set_strides();
 }
 
 MemoryBuffer::MemoryBuffer(const MemoryBuffer &src)
-    : MemoryBuffer(src.m_memoryProxy, src.m_rect, MemoryBufferState::Temporary)
+    : MemoryBuffer(src.m_datatype, src.m_rect, false)
+{
+  m_memoryProxy = src.m_memoryProxy;
+  /* src may be single elem buffer */
+  fill_from(src);
+}
+
+void MemoryBuffer::set_strides()
 {
-  memcpy(m_buffer, src.m_buffer, buffer_len() * m_num_channels * sizeof(float));
+  if (m_is_a_single_elem) {
+    this->elem_stride = 0;
+    this->row_stride = 0;
+  }
+  else {
+    this->elem_stride = m_num_channels;
+    this->row_stride = getWidth() * m_num_channels;
+  }
 }
 
 void MemoryBuffer::clear()
@@ -100,6 +120,8 @@ MemoryBuffer::~MemoryBuffer()
 
 void MemoryBuffer::fill_from(const MemoryBuffer &src)
 {
+  BLI_assert(!this->is_a_single_elem());
+
   unsigned int otherY;
   unsigned int minX = MAX2(this->m_rect.xmin, src.m_rect.xmin);
   unsigned int maxX = MIN2(this->m_rect.xmax, src.m_rect.xmax);
@@ -109,10 +131,8 @@ void MemoryBuffer::fill_from(const MemoryBuffer &src)
   int otherOffset;
 
   for (otherY = minY; otherY < maxY; otherY++) {
-    otherOffset = ((otherY - src.m_rect.ymin) * src.getWidth() + minX - src.m_rect.xmin) *
-                  this->m_num_channels;
-    offset = ((otherY - this->m_rect.ymin) * getWidth() + minX - this->m_rect.xmin) *
-             this->m_num_channels;
+    otherOffset = src.get_coords_offset(minX, otherY);
+    offset = this->get_coords_offset(minX, otherY);
     memcpy(&this->m_buffer[offset],
            &src.m_buffer[otherOffset],
            (maxX - minX) * this->m_num_channels * sizeof(float));
@@ -123,8 +143,7 @@ void MemoryBuffer::writePixel(int x, int y, const float color[4])
 {
   if (x >= this->m_rect.xmin && x < this->m_rect.xmax && y >= this->m_rect.ymin &&
       y < this->m_rect.ymax) {
-    const int offset = (getWidth() * (y - this->m_rect.ymin) + x - this->m_rect.xmin) *
-                       this->m_num_channels;
+    const int offset = get_coords_offset(x, y);
     memcpy(&this->m_buffer[offset], color, sizeof(float) * this->m_num_channels);
   }
 }
@@ -133,8 +152,7 @@ void MemoryBuffer::addPixel(int x, int y, const float color[4])
 {
   if (x >= this->m_rect.xmin && x < this->m_rect.xmax && y >= this->m_rect.ymin &&
       y < this->m_rect.ymax) {
-    const int offset = (getWidth() * (y - this->m_rect.ymin) + x - this->m_rect.xmin) *
-                       this->m_num_channels;
+    const int offset = get_coords_offset(x, y);
     float *dst = &this->m_buffer[offset];
     const float *src = color;
     for (int i = 0; i < this->m_num_channels; i++, dst++, src++) {
@@ -151,26 +169,31 @@ static void read_ewa_pixel_sampled(void *userdata, int x, int y, float result[4]
 
 void MemoryBuffer::readEWA(float *result, const float uv[2], const float derivatives[2][2])
 {
-  BLI_assert(this->m_datatype == DataType::Color);
-  float inv_width = 1.0f / (float)this->getWidth(), inv_height = 1.0f / (float)this->getHeight();
-  /* TODO(sergey): Render pipeline uses normalized coordinates and derivatives,
-   * but compositor uses pixel space. For now let's just divide the values and
-   * switch compositor to normalized space for EWA later.
-   */
-  float uv_normal[2] = {uv[0] * inv_width, uv[1] * inv_height};
-  float du_normal[2] = {derivatives[0][0] * inv_width, derivatives[0][1] * inv_height};
-  float dv_normal[2] = {derivatives[1][0] * inv_width, derivatives[1][1] * inv_height};
-
-  BLI_ewa_filter(this->getWidth(),
-                 this->getHeight(),
-                 false,
-                 true,
-                 uv_normal,
-                 du_normal,
-                 dv_normal,
-                 read_ewa_pixel_sampled,
-                 this,
-                 result);
+  if (m_is_a_single_elem) {
+    memcpy(result, m_buffer, sizeof(float) * this->m_num_channels);
+  }
+  else {
+    BLI_assert(this->m_datatype == DataType::Color);
+    float inv_width = 1.0f / (float)this->getWidth(), inv_height = 1.0f / (float)this->getHeight();
+    /* TODO(sergey): Render pipeline uses normalized coordinates and derivatives,
+     * but compositor uses pixel space. For now let's just divide the values and
+     * switch compositor to normalized space for EWA later.
+     */
+    float uv_normal[2] = {uv[0] * inv_width, uv[1] * inv_height};
+    float du_normal[2] = {derivatives[0][0] * inv_width, derivatives[0][1] * inv_height};
+    float dv_normal[2] = {derivatives[1][0] * inv_width, derivatives[1][1] * inv_height};
+
+    BLI_ewa_filter(this->getWidth(),
+                   this->getHeight(),
+                   false,
+                   true,
+                   uv_normal,
+                   du_normal,
+                   dv_normal,
+                   read_ewa_pixel_sampled,
+                   this,
+                   result);
+  }
 }
 
 }  // namespace blender::compositor